diff --git a/.agents/skills/conformance/SKILL.md b/.agents/skills/conformance/SKILL.md
new file mode 100644
index 00000000..2acd3479
--- /dev/null
+++ b/.agents/skills/conformance/SKILL.md
@@ -0,0 +1,61 @@
+---
+name: conformance
+description: "Behavioral conformance check across GraphReFly language runtimes (ts/rust/py) for the clean-slate redesign. Replaces the old structural 'parity' diff. Parity = does each runtime satisfy the wave-protocol behavior (conformance scenarios) + dispatcher contract — NOT 'do the symbol sets match'. Use after implementing/changing substrate behavior in any runtime, or when adding a new protocol rule. Authors/runs language-agnostic scenarios and updates conformance.jsonl runtime status. Triggers: 'conformance', 'cross-lang check', 'does rust match', 'parity', 'run the conformance suite', 'is the substrate behavior consistent'."
+argument-hint: "[rule-id | scenario-id | 'full'] [optional: runtime ts|rust|py]"
+---
+
+You are executing **conformance** for the clean-slate GraphReFly redesign.
+
+**Parity is behavioral, not structural (D24).** There is NO `Impl` symbol-set to diff and NO
+cross-track-ledger. Operators / sugar / inspection are **per-language and never in parity**
+(D6/D27 — graph-layer wraps everything to `(ctx)=>void` before register). The ONLY parity
+surface is: **wave-protocol behavior + dispatcher contract + handle format**. Conformance =
+each runtime passes the same language-agnostic scenarios.
+
+## Authority
+
+| Source | Role |
+|---|---|
+| `~/src/graphrefly/spec/conformance.jsonl` | The scenario registry: `{id, name, covers:[rule-id], runtimes:{ts,rust,py}, status, note}`. |
+| `~/src/graphrefly/spec/rules.jsonl` | The rules scenarios pin (`covers` must resolve here). |
+| `~/src/graphrefly/spec/protocol.proto` | Protocol-contract IDL (DR-2) — the light structural anchor codegen'd into each runtime's interface stub. |
+| `~/src/graphrefly/formal/*.tla` | TLA+ model (γ); property tests mirror its invariants. |
+
+## Scope from $ARGUMENTS
+
+- **rule-id** (e.g. `R-diamond`) → all scenarios whose `covers` includes it.
+- **scenario-id** (e.g. `C-1`) → that scenario.
+- **full** → every `status:"required"` scenario.
+- optional **runtime** → restrict to one arm.
+
+## Phase 1 — scenario integrity
+
+1. Load `conformance.jsonl` + `rules.jsonl`. Verify every `covers` rule-id resolves (else HALT — fix the scenario or add the rule via `/spec-amend`).
+2. List the **DR-5 required hard scenarios** and their status: `C-1` cross-graph diamond, `C-2` async-result-at-paused-node, `C-3` INVALIDATE×ctx.state×onInvalidate, `C-4` mixed sync/async diamond, `C-5` PAUSE-lockset multi-source. These are the load-bearing ones — behavioral parity is a blank cheque until they're green on each shipped runtime.
+
+## Phase 2 — run / verify per runtime
+
+For each in-scope `(scenario, runtime)`:
+1. Locate/author the scenario harness in that runtime's conformance test dir (language-agnostic spec → per-runtime adapter; the scenario describes observable wave behavior, not a symbol call).
+2. Run it. Record outcome.
+3. Update `conformance.jsonl` `runtimes.<rt>`: `"todo" | "poc-pass" | "pass" | "fail"`.
+4. Mirror the invariant as a property test (fast-check ts ↔ proptest rust ↔ hypothesis py) where the rule is property-shaped (L5-Q2 / D14).
+
+## Phase 3 — report
+
+| scenario | covers | ts | rust | py | verdict |
+|---|---|---|---|---|---|
+
+- **Behavior drift** = same scenario, different observable outcome across runtimes → this is the ONLY kind of parity gap. File it as a substrate bug in the lagging runtime (route fix via `/dev-dispatch` on that package).
+- **Missing scenario** for a rule (rule's `covers_by` empty) → author it (this is the real risk under behavioral parity: untested behavior can drift silently — D24 residual). Flag via `/dashboard` Gaps (uncoveredRules).
+- **NOT a gap:** a runtime having a different operator set / different sugar / different inspection ergonomics. Those are per-language by design — do not report them.
+
+## Phase 4 — gate
+
+Run `node ~/src/graphrefly/dashboard/build.mjs --check` (scenario↔rule links intact). For a runtime
+to be declared "conformant", all `status:"required"` scenarios must be `"pass"` on its arm.
+
+## Boundaries
+
+Does NOT diff symbol sets (that's the retired structural model). Does NOT touch operators/sugar/inspection
+(per-language). New protocol behavior must go through `/spec-amend` FIRST (scenario authored before code).
diff --git a/.agents/skills/dashboard/SKILL.md b/.agents/skills/dashboard/SKILL.md
new file mode 100644
index 00000000..a2903ef4
--- /dev/null
+++ b/.agents/skills/dashboard/SKILL.md
@@ -0,0 +1,33 @@
+---
+name: dashboard
+description: "Build / check the GraphReFly internal docs dashboard (jsonl single-source -> generated HTML with progress, structure map, gaps, search). Use when the user wants to see global project state, regenerate the dashboard, run the docs consistency gate (broken links / orphans / coverage gaps), or after editing any jsonl in ~/src/graphrefly (decisions/plan/spec/sessions/guide). Triggers: 'build the dashboard', 'check docs consistency', 'what are the gaps', 'show progress', 'regenerate dashboard', 'doc gate'."
+argument-hint: "[--check (gate only) | (default: build + report)]"
+---
+
+You are executing **dashboard** for the clean-slate GraphReFly redesign.
+
+**Repo:** `~/src/graphrefly` (clean-slate branch). All structured docs are jsonl (single source of truth, decision 2); the dashboard renders them into one searchable HTML view for the maintainer (decision 3). Schema contract: `~/src/graphrefly/dashboard/README.md`.
+
+## What this skill does
+
+1. **Run the generator:**
+   - `node ~/src/graphrefly/dashboard/build.mjs` → writes `dashboard/dashboard.html` + prints counts / gaps / broken-links / orphans report.
+   - `node ~/src/graphrefly/dashboard/build.mjs --check` → consistency gate only; **non-zero exit on broken links** (use as a pre-commit / CI gate).
+2. **Interpret the report** for the user:
+   - **counts** — per-jsonl row counts (decisions/phases/rules/conformance/...).
+   - **gaps** — designPhases (status=design|gap) · openDecisions · deferredBacklog · uncoveredRules (no conformance) · todoConformance (runtimes=todo). This answers "哪里还有缺口".
+   - **broken links** — must be zero (session.locks → decision; phase.sessions → session; conformance.covers → rule; flowchart.explains → rule|D#). Legacy 3-digit D### / R# refs are external (old main), reported separately as OK.
+   - **orphans** — decisions referenced by no session (informational).
+3. **If broken links exist:** locate the offending jsonl row, fix the id reference (or add the missing record), re-run `--check`.
+
+## When the jsonl changed
+
+After any edit to `decisions/`, `plan/`, `spec/`, `sessions/`, `guide/` jsonl — run `--check` to catch dangling references immediately (fixes P4 stale-premise + P6 link-rot). The generator is the enforcement mechanism for "single canonical, no broken cross-refs."
+
+## UI styling
+
+`build.mjs` emits a **placeholder shell** with the data model embedded. Visual design / interactive search is a separate `/frontend-design` pass — do NOT hand-style the HTML here; keep `build.mjs` focused on the data model + consistency checks. The dogfood endgame (phase CSP-8) rebuilds this dashboard *with GraphReFly itself* (jsonl producer → reactive views → HTML effect).
+
+## Output
+
+The counts + gaps + link-health report, a plain-language "where are the gaps / what's the progress" summary, and (unless `--check`) confirmation that `dashboard.html` was written. Flag any broken link as a blocker to fix before commit.
diff --git a/.agents/skills/decision-guard/SKILL.md b/.agents/skills/decision-guard/SKILL.md
new file mode 100644
index 00000000..78f64884
--- /dev/null
+++ b/.agents/skills/decision-guard/SKILL.md
@@ -0,0 +1,87 @@
+---
+name: decision-guard
+description: "GraphReFly clean-slate decision-consistency check. Loads the user's locked values/principles + the unified D-numbered decision log (decisions.jsonl) + recurring decision-process patterns. Use BEFORE answering any question of the form 'is this consistent with our decisions?', 'should I pick option A/B/C?', 'what about this proposed fix?', 'is X part of our scope?', 'is this a regression on a prior decision?'. Triggers: 'decision check', 'drift check', 'align check', 'is this consistent', 'should I pick', 'what about this', 'is this in scope', 'consistency review'."
+argument-hint: "[short context of what you're being asked about — paste the proposal if relevant]"
+---
+
+# decision-guard — recall and apply locked decisions, values, invariants (clean-slate)
+
+**Purpose.** Conversations lose context-window state quickly. This is the canonical recall
+surface for the **clean-slate** redesign: invoke BEFORE answering decision questions to anchor
+against the user's locked positions and prevent silent drift — especially when a chat proposes
+a scope expansion mid-implementation, presents A/B/C as a fork, uses "completeness" to justify
+expanding a locked slice, or builds on a premise that may be stale.
+
+> **Clean-slate retired the old port model.** Do NOT reach for `rust-port-decisions.md`,
+> `cross-track-ledger.md`, the `Impl` parity contract, `BindingBoundary`, the actor model, or
+> 3-digit D### port decisions — those are old-`main` history. The clean-slate decision
+> authority is below.
+
+## Sources (load in order)
+
+| Source | Role |
+|---|---|
+| `~/src/graphrefly/decisions/decisions.jsonl` | **Unified D# log** (D1–D33 + DR-*). Canonical record: `{id, layer, question, decision, rationale, supersedes, status}`. |
+| `~/src/graphrefly/sessions/active/SESSION-clean-slate-redesign.md` (DS-1) | Full design narrative + 8 forced constraints + spec-amendment list + conformance hard scenarios. |
+| `~/src/graphrefly/plan/antipatterns.jsonl` | Lessons / anti-patterns to flag against. |
+| `~/src/graphrefly/spec/rules.jsonl` | Protocol rules — for "does the spec already pin this?". |
+| Memory `feedback_*` files | The user's durable values/principles (below). |
+
+## Locked values (durable — cite by name)
+
+1. **No backward compat** (pre-1.0): structurally cleaner option, no legacy shims. `feedback_no_backward_compat`.
+2. **No imperative triggers** in public API: reactive `ctx.up`/signals, not emitters/callbacks/timers+set; remove imperative paths when no caller depends. `feedback_no_imperative`.
+3. **Single source of truth**: one canonical per concern; index points, never duplicates. `feedback_single_source_of_truth`.
+4. **No autonomous decisions** (hard rule): surface spec↔code conflicts; don't silently pick; file-by-file review for multi-file rewrites. `feedback_no_autonomous_decisions`.
+5. **No implement without approval**: decisions locked ≠ implementation approved. `feedback_no_implement_without_approval`.
+6. **Verify premise before greenfield**: design tables lag code — grep symbols + check landed markers before a 9Q; stale premise = HALT. `feedback_verify_premise_before_greenfield`.
+7. **Latest versions + context7** for current API docs. `feedback_latest_versions_context7`.
+8. **Long-command observation discipline** (run-logged + DONE sentinel; no tail; no sleep-poll) and **subagent bg hygiene** (sync-verify or teardown before return). `feedback_long_command_observation`, `feedback_subagent_bg_hygiene`.
+
+## Clean-slate floor (never violate)
+
+**Sacred (L0.7):** topology declarative/serializable/inspectable · wave protocol is a public spec ·
+wave protocol impl is **sync** · all fn go through dispatcher.
+
+**Forced (F-*):** F-PERF (budget every abstraction) · F-PROTO-SPEC (spec+TLA++property) ·
+F-SYNC-CORE (dispatcher.invoke sync void) · F-DISPATCH-ALL (no inline-fn bypass) ·
+F-GRAPH-FIRST-API · F-NO-WEDGE-CUT (every primitive ≥2 segments) ·
+F-NO-IMPL-DEFINED (spec-locked or explicitly undefined-by-design) · F-NO-LLM-ONLY.
+
+**Red flags (HALT if proposed):** async in the sync wave core (async lives only in pools/wire-bridge) ·
+inline-fn bypassing dispatcher · a primitive serving only LLM workflows · a protocol behavior left
+"implementation-defined" · user-replaceable onMessage/onSubscribe · adding a 10th tier casually ·
+graph-level shared mutable state accessed implicitly (must be explicit node + dep).
+
+## Decision-process patterns (apply in order)
+
+1. **Identify the governing D#.** Grep `decisions.jsonl` by `layer`/keyword. Is the proposal within a locked D's scope? Mid-implementation scope expansion = anti-pattern unless promoted to a NEW D#.
+2. **Check the spec.** Does `rules.jsonl` pin the behavior? If yes, follow it — divergence is a bug, not a design call. If silent/ambiguous → real design HALT.
+3. **Verify premise (value 6).** Has the symbol/surface already landed? grep before designing new surface.
+4. **Apply values + floor.** Especially: no autonomous decisions, no imperative, single source of truth, sync-core/async-at-boundary, F-* constraints.
+5. **Verdict:** `consistent (cite D#)` / `regression on D#` / `out-of-scope` / `needs new decision (don't auto-pick)`.
+6. **Routing:**
+   - New fork, no governing D# → present options + recommend, **do NOT lock** → that's `/design-review` → user approval → append `decisions.jsonl`.
+   - Changes protocol behavior → `/spec-amend` (spec-first).
+   - Cross-runtime parity concern → `/conformance` (behavioral scenario, not structural diff).
+
+## Common decision shapes
+
+- **A/B/C (fix shape):** default = the option that **structurally extends an existing pattern** beats per-site workarounds.
+- **Completeness vs discipline:** if a proposal closes a real semantic gap → formalize as a NEW D# (don't continue under the original D's banner). If speculative scope expansion → revert.
+- **Orthogonal sub-decisions:** before locking two "orthogonal" sub-decisions, sketch ONE input exercising BOTH — confirm orthogonality survives the example (antipatterns.jsonl; the 30-second check that catches coupling at design-time).
+
+## Scope boundaries
+
+Read-mostly. Loads decisions + values + patterns; produces **decision + reasoning + relay-ready text**.
+Does NOT run gates, apply fixes, or author scenarios — those are `/dev-dispatch` / `/qa` / `/conformance`
+after a decision locks. Invoke when the question is "what should I decide?", not "what should I do?".
+
+## Update protocol
+
+When a new D# locks (after user approval): append to `~/src/graphrefly/decisions/decisions.jsonl`
+(`{id, layer, date, question, decision, rationale, supersedes, status:"locked", session}`), update the
+session's `locks` in `sessions.jsonl`, and run `node ~/src/graphrefly/dashboard/build.mjs --check`.
+When a new anti-pattern recurs: append to `~/src/graphrefly/plan/antipatterns.jsonl` (+ a `feedback_*`
+memory if generalizable). When a new durable value surfaces: add a `feedback_<name>.md` memory + a
+pointer line here.
diff --git a/.agents/skills/design-review/SKILL.md b/.agents/skills/design-review/SKILL.md
new file mode 100644
index 00000000..5bc4267f
--- /dev/null
+++ b/.agents/skills/design-review/SKILL.md
@@ -0,0 +1,146 @@
+---
+name: design-review
+description: "Validate the design of a new primitive or API surface against the 5-question lens (Q5–Q9 from the per-unit review format). Use BEFORE coding (or right after a sketch lands) when adding a new public API / pattern factory / domain primitive. Triggers: 'design review', 'review the design', 'is this the right shape', 'before I implement'. Different from /qa — that finds bugs in landed code; this validates abstraction + long-term shape + reactive composability + alternatives."
+argument-hint: "[<file path> | <symbol> | --diff] [optional context]"
+---
+
+You are executing the **design-review** workflow for the **clean-slate GraphReFly** redesign.
+
+This skill applies the 5 design-review questions (Q5–Q9 of the 9-question per-unit format) to a **single-symbol / single-file / single-diff** review. Use it BEFORE coding a new public API / sugar factory / operator / inspection surface — or right after a sketch lands, before tests. Different from `/qa` (finds bugs in landed code) and `/decision-guard` (recalls locked decisions); this validates abstraction + long-term shape + reactive composability + alternatives, and its output may become a new `D#` (architectural lock → user approval → append `decisions.jsonl`).
+
+Clean-slate code lives in **`packages/ts/src/`** (`@graphrefly/ts`, D32). The language-neutral authority is **`~/src/graphrefly`** jsonl (branch `clean-slate`) — when this skill and that repo disagree, that repo wins (AGENTS.md).
+
+> **Stale-infra guard.** Do NOT cite the retired port-model: `packages/pure-ts/**` (frozen read-only reference only, D41), `docs/implementation-plan.md` / `optimizations.md` / `roadmap.md` / `test-guidance.md` / `docs-guidance.md`, `GRAPHREFLY-SPEC.md` / `COMPOSITION-GUIDE.md` (migrated to `spec/rules.jsonl` + `guide/guide.jsonl`, B7), `describe({format})` (D39: renderers are pure fns over the snapshot, NOT a `format` option), the `Impl`/facade/actor model.
+
+**When to use:** before a new public symbol in `packages/ts/src/graph/` (sugar / operator / inspection) or a new substrate primitive in `packages/ts/src/{node,dispatcher,ctx,protocol,batch}/`; right after sketching a factory; when two implementations exist and you need a principled pick; when `/dev-dispatch` Phase 2 needs to go deeper than its default template.
+**When NOT:** bug fixes / pure refactors → `/qa`; already-approved work → proceed; trivial additive changes (a JSDoc field, a docstring).
+
+User context: $ARGUMENTS
+
+---
+
+## Phase 0: Scope resolution
+
+Resolve the target(s) from `$ARGUMENTS`:
+
+1. **`--diff` / no args** — review the new public symbols in the uncommitted diff. Enumerate via `git diff --name-only HEAD` + `git status --short`, filtered to `packages/ts/src/**` files that introduce new exports.
+2. **`<file path>`** — public symbols in that file.
+3. **`<symbol name>`** — Grep-locate, then review.
+4. **Multiple targets** — apply Q5–Q9 to each, then add Phase 2 synthesis.
+
+Read in parallel before reviewing (clean-slate authority):
+
+- `~/src/graphrefly/spec/rules.jsonl` — the R-* rules your target touches (the design invariants).
+- `~/src/graphrefly/decisions/decisions.jsonl` — the governing D# (or `/decision-guard` to recall the floor/values).
+- `~/src/graphrefly/plan/phases.jsonl` — the CSP-* phase the target belongs to (locked vs open-design); if the target isn't sequenced yet, the review's output may need a new phase / backlog entry.
+- `~/src/graphrefly/guide/guide.jsonl` (G-composition) — composition patterns (lazy activation, subscription order, SENTINEL/prevData guards, feedback cycles).
+- `~/src/graphrefly/sessions/active/SESSION-clean-slate-redesign.md` (DS-1) — the F-* constraints + the why behind locks.
+- The target file(s) + 1–2 closest existing primitives in the same dir (precedent).
+- **Frozen reference (D41):** `packages/pure-ts/**` + `~/src/callbag-recharge` for analogous prior art (operator behavior, edge cases, test structure) — NOT the authority.
+
+---
+
+## Phase 1: Per-target review (Q5–Q9)
+
+For each target, produce a structured report covering all five questions. Be specific, quote `file:line`. Cap each answer ~150 words.
+
+### Q5 — Is this the right abstraction? Could it be more generic?
+
+- **Layer placement.** Substrate (`node`/`dispatcher`/`ctx`/`protocol`/`batch` — a protocol primitive, must stay thin per R-node-thin) vs graph-layer (`graph/` — sugar / operator / inspection, per-language per D6/D24)? Mismatched layer is the most common drift signal. A new **verb** is a constitutional change (8-verb closed set, D4) — almost certainly the target is sugar, not a verb.
+- **Decomposition.** Could the body split into 2+ smaller primitives that compose? (F-NO-WEDGE-CUT: each must serve ≥2 segments.)
+- **Generalization.** A 2+ similar primitive nearby hinting at a shared abstraction? Could `T = number` be `T = unknown` without losing safety?
+- **Naming.** Does the name describe what it **returns/produces** (composable) or what it does internally (rots)? D6 real factory names show in `describe`.
+
+> **Layer / Decomposition / Generalization / Naming:** …
+
+### Q6 — Right long-term solution? Caveats? Maintenance burden?
+
+- **6-month lens.** What forces this to evolve — spec/conformance changes, rust/py arm parity (D24), F-PERF budget?
+- **Hidden invariants** the type system can't express — list each as `INVARIANT: …` (subscribe order before kick; first-run gate; SENTINEL = `prevData === undefined`; sync-vs-async strategy; stable refs; equals identity).
+- **Constraint locks** (positional args can't grow options; hardcoded enum can't extend).
+- **Doc debt** (contract knowable from JSDoc, or only from the body?).
+
+> **6-month risk / Hidden invariants / Constraint locks / Doc debt:** …
+
+### Q7 — Can we simplify it? Reactive, composable, explainable?
+
+The **explainability check** — a primitive's reactive shape is only as good as its `describe()` snapshot (D39).
+
+- **Wire a minimal composition** (≥2 sources → target → ≥1 sink). Predict `describe()` — a flat JSON-serializable snapshot; renderers (pretty/mermaid/d2) are pure fns over it (D39), NOT a `describe({format})` option. If you can't predict the output, the topology is too imperative.
+- **Island check.** A node with zero in-edges AND zero out-edges (not an entry/exit) is a smell.
+- **Imperative escape paths.** Search for: emit/set/callback wiring that bypasses the graph (R-no-imperative); `.cache` reads inside reactive fn bodies (R-data-not-peek — data moves via messages); raw `Promise`/`setTimeout`/`queueMicrotask` outside a source/pool (R-no-raw-async / F-SYNC-CORE); hardcoded `type === "DATA"` instead of `messageTier` (R-tier); an inline fn bypassing the dispatcher (R-dispatch-all).
+- **SENTINEL / prevData guards.** Never-emitted detection via `ctx.prevData[i] === undefined` (the canonical detector); fix eager-placeholder upstreams rather than bolting on companions.
+- **Feedback cycles.** A fn that re-drives its own dep mid-wave is a wave-level ERROR (D37/R-reentrancy), not iteration; legit accumulation = `ctx.state` (scan), not a topological cycle.
+
+> **Topology / Imperative leaks / cache reads / Feedback cycles / Simplifications:** …
+
+### Q8 — Alternative implementations (A / B / C)
+
+Sketch **≥2** named alternatives. For each: **Shape** (1–3 line pseudo-sig), **Pros** (2–4), **Cons** (2–4), **Precedent** — does the shape exist in the frozen `packages/pure-ts/**` reference (D41), `callbag-recharge`, or RxJS? Cite if so. Don't pick a winner yet — that's Q9.
+
+> **A. {name}** — sketch / Pros / Cons / Precedent
+> **B. {name}** — …
+
+### Q9 — Recommendation + coverage check
+
+Pick the recommended alternative; build a coverage matrix (each Q5–Q8 concern → recommended alt covers it? yes / partially / no — because …). For any `partially`/`no`, name the residual risk: accept it (justify), add a `backlog.jsonl` follow-up, or pick a different alternative. End with:
+
+> **Recommendation:** {alt}, because {2–3 reasons grounded in Q5–Q8}.
+> **Residual risks:** {none, OR 1–2}.
+> **Implementation guidance:** {next step — usually a draft `D#` for approval, or a sub-decision the user must answer first}.
+
+If the design is an architectural lock, draft the `D#` (`{id, layer, date, question, decision, rationale, supersedes, status}`) for the user to approve BEFORE append — do NOT auto-lock (no-autonomous-decisions). A wave-protocol behavior change routes to `/spec-amend` (spec-first), not a direct edit.
+
+---
+
+## Phase 2: Cross-cutting synthesis (multi-target only)
+
+Apply only when reviewing multiple targets in one pass:
+
+- **Naming consistency** (`extract` vs `select` vs `pick` for the same role = drift).
+- **Argument-shape consistency** (options-bag vs positional applied the same way).
+- **Composition direction** (do the targets' input/output shapes line up to compose?).
+- **Repeated patterns** (the same SENTINEL-gate / subscribe-order / batch-on-write in 2+ places → a shared helper candidate).
+
+Output a numbered list, each finding with the pattern, where it appears (file:line × N), and a proposed unifying shape.
+
+---
+
+## Phase 3: Decisions log
+
+- **Architectural lock** (clear) → draft a `D#` for `~/src/graphrefly/decisions/decisions.jsonl`; append only after user approval, then update the DS-1 `locks` in `sessions/sessions.jsonl` and run `node ~/src/graphrefly/dashboard/build.mjs --check`.
+- **Deferred / no clear answer** → append to `~/src/graphrefly/plan/backlog.jsonl` (B# + concrete trigger).
+- **Recurring anti-pattern** → `~/src/graphrefly/plan/antipatterns.jsonl` (+ a `feedback_*` memory if generalizable).
+- **Protocol-behavior change** surfaced → route to `/spec-amend` (spec-first), not a direct code change.
+
+---
+
+## Output discipline
+
+- Be concrete. Quote `file:line` refs.
+- Don't write "this looks good" — say WHICH Q5–Q9 dimensions clear and why.
+- Don't pad. If Q6 has no caveats, write `**Hidden invariants:** none surfaced.` and move on.
+- Don't second-guess the user's stated intent — Q8 alternatives are options to compare; Q5–Q7 probe the recommended shape.
+- Skim-readable: headers per question, bullets within.
+
+---
+
+## Authority hierarchy
+
+1. `~/src/graphrefly/spec/rules.jsonl` — the protocol 宪法.
+2. `~/src/graphrefly/decisions/decisions.jsonl` (+ DS-1 narrative) — locked decisions + F-* floor + durable values.
+3. `~/src/graphrefly/plan/phases.jsonl` — the CSP-* sequencer (phase locks).
+4. `~/src/graphrefly/guide/guide.jsonl` (G-test / G-composition) — testability + composition shape.
+5. Existing patterns in `packages/ts/src/` — only when the above are silent.
+
+If a finding conflicts with a higher-authority doc, surface it explicitly — DO NOT silently override (no-autonomous-decisions).
+
+---
+
+## What to do AFTER this skill completes
+
+- Lock approved → `/dev-dispatch` (or `--light`) with the locked design; a protocol-behavior change goes through `/spec-amend` first.
+- Decisions deferred → leave them in `backlog.jsonl` and move on.
+- Needs more thought → HALT, summarize, let the user think.
+
+This skill produces a report; it modifies no implementation files (it only appends to `~/src/graphrefly` jsonl after explicit user approval of a `D#`).
diff --git a/.agents/skills/dev-dispatch/SKILL.md b/.agents/skills/dev-dispatch/SKILL.md
new file mode 100644
index 00000000..9f183e9a
--- /dev/null
+++ b/.agents/skills/dev-dispatch/SKILL.md
@@ -0,0 +1,125 @@
+---
+name: dev-dispatch
+description: "Implement feature/fix with planning and self-test. Use when user says 'dispatch', 'dev-dispatch', or provides a task with implementation context. Supports --light flag for bug fixes and small changes. Run /qa afterward for code review and final checks."
+argument-hint: "[--light] [task description or context]"
+---
+
+You are executing the **dev-dispatch** workflow for the **clean-slate GraphReFly** redesign.
+
+This repo is **`@graphrefly/ts`** — the self-contained TypeScript implementation (D32). Clean-slate code lands in **`packages/ts/src/`**. The language-neutral authority (spec / decisions / plan / conformance / formal) lives in **`~/src/graphrefly`** (branch `clean-slate`) as jsonl — when this skill and that repo disagree, **that repo wins** (AGENTS.md). Sibling impls: `@graphrefly/rust` (`~/src/graphrefly-rs`), `@graphrefly/py` (`~/src/graphrefly-py`) — each self-contained; cross-language = wire bridge, never in-process (D32).
+
+> **Stale-infra guard.** Do NOT reach for the retired port-model surfaces: `packages/pure-ts/**` (frozen read-only reference only, D41), `docs/implementation-plan.md`, `docs/optimizations.md`, `docs/roadmap.md`, `docs/test-guidance.md`, `docs/docs-guidance.md`, `GRAPHREFLY-SPEC.md`/`COMPOSITION-GUIDE.md` (migrated to `spec/rules.jsonl` + `guide/guide.jsonl`, B7), the `Impl`/facade/actor model / 3-digit D### port decisions. The clean-slate authority is the jsonl below.
+
+> **Ownership guard.** The current working directory is execution context, not architectural ownership. Before implementing anything that mixes Workspace, Canvas, or product-surface vocabulary, classify every new symbol as protocol, `@graphrefly/ts` library/solution, Canvas product, or docs-only. Canvas-owned lifecycle material such as `CanvasWorkspace*` DTOs/helpers, Canvas slot lifecycle lowering, lifecycle reason vocabularies, retention-pressure policy/status, selector adapters, component registries, and product lifecycle APIs belong in `~/src/graphrefly-canvas` unless an explicit D# says `@graphrefly/ts` owns that public API. Focused subpath exports and subpath smoke tests count as TS library API expansion; do not treat "root index unchanged" as sufficient.
+
+The user's task/context is: $ARGUMENTS
+
+### Mode detection
+If `$ARGUMENTS` contains `--light`, this is **light mode**. Otherwise **full mode**. Differences are noted inline per phase.
+
+### Workflow floor (non-negotiable)
+- **decision-first**: any architectural lock needs a `D#` in `~/src/graphrefly/decisions/decisions.jsonl` BEFORE code (`/design-review` → user approval → append). Decisions locked ≠ implementation approved — wait for an explicit "implement".
+- **spec-first** (F-NO-IMPL-DEFINED): any wave-protocol behavior change amends `spec/rules.jsonl` + `formal/*.tla` + `spec/conformance.jsonl` FIRST (`/spec-amend`), THEN code. Operators/sugar/inspection are per-language (D6/D24) — NOT spec, skip spec-amend.
+- **no autonomous decisions**: surface spec↔code conflicts; don't silently pick. File-by-file review for multi-file rewrites.
+- **verify premise**: design tables lag code — grep the named symbols + check landed markers (`plan/phases.jsonl` status/notes) before designing new surface; a stale premise is a HALT.
+- **consistency gate**: after touching any `~/src/graphrefly` jsonl, run `node ~/src/graphrefly/dashboard/build.mjs --check` (non-zero on broken links / orphans).
+
+---
+
+## Phase 1: Context & Planning
+
+Load context and plan in a single pass. **Parallelize all reads.**
+
+Read in parallel (clean-slate authority):
+- `~/src/graphrefly/AGENTS.md` — the single-source authority index (read FIRST).
+- `~/src/graphrefly/spec/rules.jsonl` — the protocol 宪法 (R-* rules); deep-read the rules your change touches.
+- `~/src/graphrefly/decisions/decisions.jsonl` — the unified D# log (or invoke `/decision-guard` to recall the governing D#/values/floor).
+- `~/src/graphrefly/plan/phases.jsonl` — the CSP-* sequencer: find the phase this task belongs to, its `status` (done/impl/design), deps, and note. Read this FIRST among the plan files so you know whether you're on a ready phase or one still gated.
+- `~/src/graphrefly/plan/backlog.jsonl` + `plan/antipatterns.jsonl` — deferred carries (B#) with triggers; anti-patterns to flag against.
+- `~/src/graphrefly/spec/conformance.jsonl` — the behavioral scenarios (C-*) your change must keep green; check the `runtimes` status for the arm you target.
+- `~/src/graphrefly/guide/guide.jsonl` — composition / test / docs / contribute guidance (G-composition / G-test / G-docs / G-contribute).
+- `~/src/graphrefly/sessions/active/SESSION-clean-slate-redesign.md` (DS-1) — the L0–L6 design narrative + F-* constraints, when you need the why behind a lock.
+- Any files the user referenced in $ARGUMENTS.
+- The clean-slate source you'll modify: substrate = `packages/ts/src/{node,dispatcher,ctx,protocol,batch}/`; graph-layer = `packages/ts/src/graph/` (Graph + 8-verb sugar + operators + inspection describe/observe/profile).
+- Existing tests: `packages/ts/src/__tests__/`.
+
+**Frozen reference (D41):** `packages/pure-ts/**` and `~/src/callbag-recharge` are READ-ONLY prior art for analogous operator behavior / edge cases / test structure during a re-derive (D40 Catalog-first). Map concepts to the clean-slate substrate (`node`/`ctx.down`/`ctx.depRecords`/`Graph`, D39 `describe`/`observe`) — do NOT 1:1 port; the old substrate API and semantics differ. They are NOT the behavior authority — `spec/rules.jsonl` is.
+
+While planning, validate proposed changes against the clean-slate floor (cite the rule/D#):
+- **Sacred (L0.7):** topology declarative/serializable/inspectable · wave protocol is a public spec · wave protocol impl is **sync** · all fn go through the dispatcher.
+- **8 verbs, closed (D4):** `node`/`graph`/`batch`/`state` + `producer`/`derived`/`effect`/`mount`. **Operators are `node` sugar (D6), not verbs** — per-language, never in parity (D24); real factory names show in `describe`. Adding a verb is a constitutional change.
+- **Messages** `[[Type, Data?], ...]`; one array to `ctx.down`/`ctx.up` = one wave (R-msg-format). 10-type closed set, no user-defined types (R-msg-closed-set).
+- **DIRTY before DATA/RESOLVED** in the same wave (R-dirty-before-data); two-phase glitch-free diamond (R-two-phase); a diamond/fan-in node recomputes exactly once after all changed deps settle (R-diamond). batch defers tier-≥3, not DIRTY.
+- **`ctx.up` is control-tier only** (DIRTY/PAUSE/RESUME/INVALIDATE/TEARDOWN); DATA/RESOLVED/COMPLETE/ERROR are down-only (R-ctx-up, D8). A handle is pure data, no methods (D7).
+- **No polling** (R-no-polling); **no imperative triggers** (R-no-imperative — reactive `ctx.up`/signals, not emitters/callbacks/timers+set; remove imperative paths when no caller depends); **no raw async** in the sync core (R-no-raw-async / F-SYNC-CORE — async lives only in sources / the pool / the wire bridge).
+- **All fn through the dispatcher** (R-dispatch-all / F-DISPATCH-ALL — no inline-fn bypass). `dispatcher.invoke` is sync void (R-sync-core).
+- **Data moves via messages** (R-data-not-peek — never peek a dep's `.cache` to seed compute; `.cache` is a read-only accessor for external consumers). SENTINEL = absence-of-DATA (R-sentinel); the canonical never-emitted detector is `ctx.prevData[i] === undefined`.
+- **messageTier is a compile-time const table** (D18/D34/R-tier); the clock is **graph-local** (no global singleton, D26/R-clock); `onMessage`/`onSubscribe` are substrate-fixed, not user-replaceable (D19).
+- **Primary-API clean** (R-primary-api-clean): protocol internals (DIRTY/RESOLVED/bitmask) never surface in value-level sugar (derived/effect/operator); ctx-level (node/producer) intentionally exposes tier as a power surface (DR-1). Sugar value-fn → ctx-fn wrapping happens in the graph layer (D27); a value-level `throw` becomes `[[ERROR,e]]` down (D30).
+- **graph = single-thread causal/concurrency domain (D22 / R-graph-domain):** parallelism via pool callback or multi-graph + wire bridge; rewire is intra-graph only.
+- **`ctx.state`** = per-node private cross-wave state (R-ctx-state); shared/observable state must be an explicit node + dep, not `ctx.state` (D23). A synchronous feedback cycle (a fn re-driving its own dep mid-wave) is a wave-level ERROR (D37/R-reentrancy), not iteration.
+- **F-NO-WEDGE-CUT:** every primitive serves ≥2 segments (no LLM-only or single-segment wedge; F-NO-LLM-ONLY). **F-PERF:** budget every abstraction (thin node, default-off inspection).
+
+**Targeting a sibling (py/rust):** if the task targets `@graphrefly/py` (`~/src/graphrefly-py`) or `@graphrefly/rust` (`~/src/graphrefly-rs`), read that package's local layout + its conformance arm status in `spec/conformance.jsonl`. The cross-language contract is **behavioral conformance (D24)**, not symbol parity. PY public APIs are synchronous (return `Node[T]`/`Graph`/value, no `async def`); async lives at the source/pool boundary only (F-SYNC-CORE).
+
+Do NOT start implementing yet.
+
+---
+
+## Phase 2: Architecture Discussion
+
+### Full mode — HALT
+
+**HALT and report before implementing.** Present:
+
+1. **Architecture assumptions** — how this fits the substrate (`node`/`dispatcher`/`ctx`/`protocol`/`batch`) vs graph-layer (`graph/`) split.
+2. **New patterns** — any not yet in `packages/ts/src/`.
+3. **Options considered** — alternatives with pros/cons.
+4. **Recommendation** — preferred approach + why.
+
+Prioritize (in order):
+1. **Correctness** — matches `~/src/graphrefly/spec/rules.jsonl` + the floor.
+2. **Completeness** — edge cases (errors, COMPLETE, reconnect/reactivate, diamonds, SENTINEL gate, PAUSE lockset).
+3. **Consistency** — matches patterns already in `packages/ts/src/`.
+4. **Simplicity** — minimal solution.
+
+No backward compatibility (pre-1.0).
+
+**Escalation routing** (don't silently pick — no-autonomous-decisions):
+- Architectural lock → `/design-review` → user approval → append a `D#` to `decisions.jsonl`.
+- Wave-protocol behavior change → `/spec-amend` (spec-first: rules + TLA+ + conformance, THEN code).
+- Cross-runtime concern → `/conformance` (behavioral scenario, not structural diff).
+- Deferred/open question with no answer yet → append to `~/src/graphrefly/plan/backlog.jsonl` (B# + trigger); a recurring anti-pattern → `plan/antipatterns.jsonl` (+ a `feedback_*` memory if generalizable).
+
+**Wait for user approval before proceeding.**
+
+### Light mode — Skip unless escalation needed
+
+Proceed directly to Phase 3 **unless** Phase 1 reveals any of these:
+- A change to **wave-protocol behavior** (tiers, wave semantics, diamond/equals/SENTINEL, batch, push-on-subscribe, ctx.up/down contract) → spec-first, escalate.
+- A new architectural lock with no governing `D#`.
+- Multiple viable approaches with non-obvious trade-offs.
+
+If any apply: HALT and present findings as in full mode.
+
+---
+
+## Phase 3: Implementation & Self-Test
+
+After user approves (full mode) or after Phase 1 (light mode, no escalation):
+
+1. Implement the changes.
+   - Treat `~/src/graphrefly/spec/rules.jsonl` as non-negotiable for behavior; if code drifts from a rule, align to the rule — or surface the conflict, don't silently pick.
+   - Cite the governing R-id / D# in test expectations.
+2. Create tests (per `guide/guide.jsonl` G-test — unit / property / conformance layering):
+   - Put tests in the most specific existing file under `packages/ts/src/__tests__/`.
+   - Use `graph.observe()` for live message assertions; assert at the node + message level otherwise. A behavioral-protocol change ALSO needs a `spec/conformance.jsonl` scenario (`/conformance`) before its rule flips `draft → active`.
+3. Run checks:
+   - **TS:** `pnpm --filter @graphrefly/ts test` (vitest) + `pnpm run lint` (biome + layer/typecheck gates) + `pnpm run build` (tsup) as relevant.
+   - **PY (if targeted):** the `@graphrefly/py` package's own test/lint/type gates in `~/src/graphrefly-py`.
+   - **jsonl touched:** `node ~/src/graphrefly/dashboard/build.mjs --check` (consistency gate).
+4. Fix any failures.
+
+If implementation leaves an **open architectural decision** (deferred behavior, parity caveat, "needs spec" item), append it to `~/src/graphrefly/plan/backlog.jsonl` (B# + trigger) — NOT a docs file. If it **lands or advances a CSP-* phase**, update that phase's `status`/`note` in `~/src/graphrefly/plan/phases.jsonl`, flip any conformance-backed `draft` rule to `active` once its scenario is green per arm, then run the consistency gate.
+
+When done, briefly list files changed and new exports added. Then suggest running `/qa` for adversarial review and final checks.
diff --git a/.agents/skills/graph-animation/SKILL.md b/.agents/skills/graph-animation/SKILL.md
new file mode 100644
index 00000000..c57191b2
--- /dev/null
+++ b/.agents/skills/graph-animation/SKILL.md
@@ -0,0 +1,418 @@
+---
+name: graph-animation
+description: "Create GraphReFly concept explanation videos using HyperFrames. Use when asked to generate animated diagrams of reactive graph topologies — node activations, START/DIRTY/DATA/COMPLETE message flow, diamond resolution, batch mode, operators, etc. Supports two modes: default = concept-explainer (captioned, beat-structured, 30–90s); `--mode ambient-hero` = silent looping landing-page background (8-stage canonical storyboard, ~42s seamless loop). Invokes /hyperframes for composition authoring and /gsap for deterministic animation. Run /hyperframes-cli for preview/render commands."
+argument-hint: "[--mode ambient-hero] [concept to animate, e.g. 'diamond resolution', 'batch mode', 'node lifecycle']"
+---
+
+You are executing the **graph-animation** workflow for **GraphReFly**.
+
+The user's request: `$ARGUMENTS`
+
+This skill produces a HyperFrames HTML composition that animates GraphReFly reactive graph concepts — topology diagrams with animated message flow, node activations, and tier-coded signals. It wraps `/hyperframes` and `/gsap` with GraphReFly-specific knowledge so you don't have to explain the domain each time.
+
+---
+
+## Mode detection
+
+If `$ARGUMENTS` contains `--mode ambient-hero` (or the user asks for a "hero", "landing-page", "background video", or "loop"), use **ambient-hero mode** — skip directly to the "Mode B: ambient hero" section near the bottom. The 8-stage canonical storyboard is fully specified there; do not re-derive it.
+
+Otherwise, treat the request as **concept-explainer mode** (default) and follow Steps 1–4 below.
+
+---
+
+## Step 1 — Understand the concept (concept-explainer mode only)
+
+If `$ARGUMENTS` is vague or empty, ask the user ONE question: which concept or workflow do you want to animate? Give them these options as examples:
+
+- Node lifecycle (START → DATA → COMPLETE → TEARDOWN)
+- Message propagation through a linear chain (A → B → C)
+- Diamond resolution (fan-out + fan-in, single recomputation)
+- Batch mode (DIRTY cascades, DATA deferred until batch end)
+- Reactive timer source feeding a derived node
+- Operator pipeline (map → filter → combine)
+- Human-in-the-loop gate (promptNode / valve pattern)
+- Multi-agent subgraph ownership (L0–L3 staircase)
+
+If `$ARGUMENTS` names a concept already, proceed directly to Step 2.
+
+---
+
+## Step 2 — GraphReFly visual language
+
+Use these conventions consistently across all GraphReFly animation videos.
+
+### Node shapes (canonical sugar names — `graph.state/producer/derived/effect`)
+
+| Sugar | Role | Shape | Color |
+|---|---|---|---|
+| `state` | Mutable cell, no deps | Circle | `#14B8A6` (teal) |
+| `producer` | Push source (timer, event, async) | Diamond / pill | `#10B981` (emerald) |
+| `derived` | Pure fn of deps | Circle | `#6C63FF` (violet) |
+| `effect` | Sink / side-effect | Rounded rect | `#F59E0B` (amber) |
+| External / human | Out-of-graph input | Hexagon | `#64748B` (slate) |
+
+Border stroke: `2px solid rgba(255,255,255,0.2)`. Inactive fill: 30% opacity of the node color. Active fill: 100% opacity. The underlying primitive `node()` exists below these four sugars; videos should use sugar names for vocabulary teaching.
+
+### Message symbols (canonical — `core/messages.ts`)
+
+The full protocol exports `START / DIRTY / DATA / RESOLVED / COMPLETE / TEARDOWN / INVALIDATE / PAUSE / RESUME / ERROR`. For videos, use the **foundational subset** unless a specific concept requires more:
+
+| Symbol | Color | Visual | When to show |
+|---|---|---|---|
+| `START` | `#94A3B8` (slate-light) | Thin pulse from src→dst, edge brightens | First message on a new connection (handshake) |
+| `DIRTY` | `#FBBF24` (yellow) | Dashed pulse traveling along edge | Upstream may have changed; dep marks dirty |
+| `DATA` | `#34D399` (green) | Solid dot traveling along edge; triggers node fn on arrival | Value flowing |
+| `RESOLVED` | `#60A5FA` (blue) | Ring ripple on destination node | Diamond-resolution wave only (skip in beginner videos) |
+| `COMPLETE` | `#94A3B8` (slate) | Edge fades, dst node dims | Producer finished emitting |
+| `TEARDOWN` | `#A78BFA` (purple) | Edge erases backwards from dst→src | Subscription cancelled / dispose |
+| `BATCH_*` | `#A78BFA` (purple) | Bracket sweep across topology | Batch-mode beats |
+
+Default foundational subset for hero / intro videos: **`START → DIRTY → DATA → COMPLETE`**. Add `RESOLVED` only when teaching diamond resolution; add `TEARDOWN` only when teaching lifecycle.
+
+### Edge conventions
+
+- Directed arrows from producer to consumer.
+- Edge color matches the tier of the in-flight message.
+- Resting state: `rgba(255,255,255,0.15)` gray.
+- Animate as SVG `<path>` or a CSS `clip-path` wipe so timing is seekable.
+
+### Layout
+
+- Canvas: **1920×1080** (landscape), dark background `#0F172A`.
+- Nodes: minimum 80px diameter circles, 24px sans-serif label inside.
+- Edges: 3px stroke with arrowhead marker.
+- Label overlay: bottom-left, `font-size: 28px`, `color: #E2E8F0`, describes what is happening.
+
+### Timing budget
+
+- 2–4 seconds per "beat" (one message hop or one lifecycle phase).
+- Total target: **30–90 seconds** for a concept clip.
+- Add 1.5s of static "intro frame" showing the graph topology before any animation begins.
+
+---
+
+## Step 3 — Scaffold the composition
+
+Use `npx hyperframes init <concept-slug>` to scaffold a new project directory, OR create the file inline if the user prefers a single-file drop.
+
+A minimal starting template (adapt to the specific concept):
+
+```html
+<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="utf-8" />
+  <style>
+    * { margin: 0; padding: 0; box-sizing: border-box; }
+    body { width: 1920px; height: 1080px; background: #0F172A; overflow: hidden; font-family: 'Inter', sans-serif; }
+
+    .node { position: absolute; border-radius: 50%; display: flex; align-items: center; justify-content: center;
+      font-size: 22px; font-weight: 600; color: #fff; opacity: 0.3; transition: none; }
+    .node.active { opacity: 1; }
+    .label { position: absolute; bottom: 60px; left: 80px; font-size: 28px; color: #E2E8F0; opacity: 0; max-width: 900px; line-height: 1.4; }
+
+    svg.edges { position: absolute; top: 0; left: 0; width: 1920px; height: 1080px; }
+  </style>
+
+  <!-- GSAP via CDN (deterministic, seekable) -->
+  <script src="https://cdn.jsdelivr.net/npm/gsap@3/dist/gsap.min.js"></script>
+  <script src="https://cdn.jsdelivr.net/npm/gsap@3/dist/MotionPathPlugin.min.js"></script>
+</head>
+<body>
+  <!-- Stage -->
+  <div id="stage"
+    data-composition-id="graphrefly-concept"
+    data-start="0"
+    data-width="1920"
+    data-height="1080">
+
+    <!-- SVG edges layer -->
+    <svg class="edges" id="edges">
+      <defs>
+        <marker id="arrow" markerWidth="10" markerHeight="7" refX="9" refY="3.5" orient="auto">
+          <polygon points="0 0, 10 3.5, 0 7" fill="rgba(255,255,255,0.15)" />
+        </marker>
+      </defs>
+      <!-- edges drawn here as <path> elements -->
+    </svg>
+
+    <!-- Nodes -->
+    <!-- Example: -->
+    <!-- <div class="node" id="n-source" style="width:90px;height:90px;background:#10B981;left:200px;top:495px;">src</div> -->
+    <!-- <div class="node" id="n-derived" style="width:90px;height:90px;background:#6C63FF;left:900px;top:495px;">node</div> -->
+
+    <!-- Animated message dots (positioned by GSAP MotionPath) -->
+    <div id="msg-dirty"  style="position:absolute;width:18px;height:18px;border-radius:50%;background:#FBBF24;opacity:0;border:2px dashed #fff;"></div>
+    <div id="msg-data"   style="position:absolute;width:18px;height:18px;border-radius:50%;background:#34D399;opacity:0;"></div>
+
+    <!-- Caption label -->
+    <div class="label" id="caption"></div>
+  </div>
+
+  <script>
+    gsap.registerPlugin(MotionPathPlugin);
+
+    const tl = gsap.timeline();
+
+    // --- helpers ---
+    function activate(id) {
+      return tl.to(`#${id}`, { opacity: 1, scale: 1.1, duration: 0.25, yoyo: true, repeat: 1, ease: 'power2.out' }, '<');
+    }
+    function caption(text, at) {
+      tl.to('#caption', { opacity: 1, duration: 0.3 }, at)
+        .call(() => { document.getElementById('caption').textContent = text; }, [], at)
+        .to('#caption', { opacity: 0, duration: 0.3 }, `+=${text.length * 0.04 + 2}`);
+    }
+    function sendMsg(dotId, path, color, duration) {
+      const dot = document.getElementById(dotId);
+      dot.style.background = color;
+      tl.to(dot, { opacity: 1, duration: 0.1 })
+        .to(dot, { motionPath: { path, align: path, autoRotate: false }, duration, ease: 'none' })
+        .to(dot, { opacity: 0, duration: 0.1 });
+    }
+
+    // --- build your timeline below ---
+    // Example: 1.5s static intro
+    tl.to({}, { duration: 1.5 });
+    // ... animate your concept here
+
+    // Register the timeline with HyperFrames for seekable rendering
+    window.__hfGsapTimeline = tl;
+  </script>
+</body>
+</html>
+```
+
+---
+
+## Step 4 — Mode A: concept-explainer patterns
+
+### Diamond resolution
+
+```
+     A
+    / \
+   B   C
+    \ /
+     D (recomputes once)
+```
+
+Sequence:
+1. A emits DATA → DIRTY cascades to B and C simultaneously (two yellow dashes)
+2. B and C each emit DIRTY to D
+3. D receives both DIRTYs — stays dirty, does NOT recompute yet
+4. A emits RESOLVED → B resolves → C resolves → D resolves
+5. D recomputes **once** (green DATA dot appears from D)
+6. Caption: "Diamond resolved — one recomputation, zero double-fires"
+
+### Batch mode
+
+Sequence:
+1. `batch(() => ...)` bracket appears — purple "BATCH_START" ring
+2. Multiple sources emit DATA — nodes flash DIRTY but DATA dots are held (shown as queued dots stacked at source)
+3. batch end — all deferred DATA releases simultaneously
+4. Caption: "Batch defers DATA, not DIRTY — downstream sees one coherent update"
+
+### Node lifecycle
+
+Sequence:
+1. Node dims (initial)
+2. Subscription arrives → node brightens
+3. Upstream emits DATA → node pulses green
+4. RESOLVED ripple out
+5. Unsubscribe → teardown ring (purple) → node dims again
+
+### Operator pipeline
+
+Show 3–4 nodes in a horizontal chain (map → filter → combine). Animate a value token flowing left to right, label each node with its transform (`×2`, `> 5`, `merge`).
+
+---
+
+## Step 5 — Run the dev loop
+
+```bash
+# from the composition project directory:
+npx hyperframes lint        # validate timing/structure
+npx hyperframes preview     # live browser preview with hot reload
+npx hyperframes render      # output MP4
+```
+
+Use `/hyperframes-cli` skill for detailed CLI guidance.
+Use `/gsap` skill for advanced GSAP timeline patterns.
+Use `/hyperframes-media` skill if you need TTS narration or audio.
+
+---
+
+## Step 6 — Quality checks before render
+
+- [ ] All nodes have correct shape + color per the visual language table above
+- [ ] Message colors match the canonical table (START=slate-light, DIRTY=yellow, DATA=green, COMPLETE=slate, RESOLVED=blue if shown, TEARDOWN=purple if shown)
+- [ ] Timeline registers `window.__hfGsapTimeline = tl` (required for seekable render)
+- [ ] Caption text is ≤ 80 chars per line and readable at 1080p (concept-explainer mode only)
+- [ ] `npx hyperframes lint` passes with no errors
+- [ ] Preview scrubbing doesn't stutter (all animations are on the GSAP timeline, not setTimeout)
+
+---
+
+## Mode B: ambient hero (canonical 8-stage landing-page loop)
+
+This mode produces the **GraphReFly landing-page background video** — a silent, looping, atmospheric reactive-graph composition. Use it whenever the user asks for a "hero", "landing-page", "background video", or passes `--mode ambient-hero`.
+
+### Mode-B rules (differ from concept-explainer)
+
+| Rule | Value | Why |
+|---|---|---|
+| Length | ~42s seamless loop | Hero convention 15–60s; matches the 8-stage plan |
+| Audio | none | Plays muted; hero conventions |
+| Captions | none over the topology | Headline text overlays the hero on the page; captions would compete |
+| Small floating labels | OK, ≤ 4 words, ≤ 22px font | E.g. `graph.describe()`, `graph.observe()`, `batch()` — vocabulary pre-teach |
+| Pacing | slow / ambient | No frantic motion; eye should rest |
+| Loop seam | **Stage 8 ends at exactly the same camera/node positions as Stage 1 starts** | Imperceptible loop |
+| Contrast | reduced — palette at ~70% saturation, bg `#0F172A` | Headline text on page must dominate |
+| Render output | MP4 + a WebM/VP9 variant for `<video>` autoplay-muted-loop | Web embedding |
+
+### The 8-stage canonical storyboard (~42s total)
+
+#### Stage 1 — Connection protocol (6s)
+
+**Topology:** two nodes, side by side, mid-canvas. Left = `producer` (emerald diamond), right = `derived` (violet circle). Single edge between them.
+
+Beat-by-beat:
+- 0.0–1.0s: Both nodes appear dim. Edge draws in as a gray line.
+- 1.0–1.8s: `START` pulse (slate-light, thin) travels src→dst. Edge brightens to active. Both nodes pulse subtly (handshake established). Tiny label appears below: `START`.
+- 1.8–2.8s: `DIRTY` dashed yellow pulse travels src→dst. Destination node briefly outlines yellow (marked dirty). Label: `DIRTY`.
+- 2.8–4.0s: `DATA` solid green dot travels src→dst. **On arrival, the destination node's interior briefly displays the literal text `fn(...)` then snaps back** — this teaches "DATA arrival triggers the node's fn". Label: `DATA`.
+- 4.0–5.5s: Repeat one more DIRTY+DATA cycle (faster, no label) to show the steady-state rhythm.
+- 5.5–6.0s: `COMPLETE` slate pulse travels src→dst. Edge fades. Destination dims slightly. Label: `COMPLETE`.
+
+**Marketing payload:** "this is the connection lifecycle. START → DIRTY → DATA → COMPLETE." Foundational subset shown.
+
+#### Stage 2 — Diamond (5s)
+
+**Topology:** add two more nodes to form a diamond. The producer from Stage 1 becomes `A` (top). Stage 1's derived becomes `D` (bottom). Two new derived nodes `B` and `C` appear left and right.
+
+```
+       A
+      / \
+     B   C
+      \ /
+       D
+```
+
+Beat-by-beat:
+- 0.0–1.0s: Nodes `B` and `C` fade in; edges `A→B`, `A→C`, `B→D`, `C→D` draw.
+- 1.0–2.0s: `A` emits DIRTY → cascades to B and C simultaneously (two yellow dashes leaving A). Both B and C outline yellow.
+- 2.0–2.8s: Both B and C emit DIRTY toward D (two yellow dashes converging on D). D outlines yellow but does **not** recompute yet — visually emphasized by D pulsing yellow twice without firing.
+- 2.8–3.8s: `A` emits DATA → green dot to B and C in parallel; B fires (interior `fn(...)` flash), C fires.
+- 3.8–4.5s: B and C each emit DATA → both green dots converge on D simultaneously. D fires **once** (single `fn(...)` flash) — emphasize by halting motion for 200ms after the fire.
+- 4.5–5.0s: All nodes settle, edges return to resting gray.
+
+**Marketing payload:** "the DIRTY-then-DATA wave guarantees D recomputes once, not twice."
+
+#### Stage 3 — Zoom into one node (5s)
+
+**Topology:** camera dollies into node `D` from Stage 2. It grows to ~60% of canvas height. Other nodes fade out.
+
+Beat-by-beat:
+- 0.0–1.5s: Camera zoom + other nodes fade. `D` now reveals its internal anatomy as labeled segments:
+  - **Center**: large `fn(...)` glyph
+  - **Top wedge**: `down ▼` — outgoing edge ports
+  - **Bottom wedge**: `up ▲` — incoming dep ports
+  - **Left wedge**: `cache` — small dotted box showing a value
+  - **Right wedge**: `version: 3` — a small numeric ticker
+  - **Outer ring**: `guard` — a thin guard-ring with a small lock icon
+- 1.5–3.5s: One by one, each anatomy label highlights briefly (~400ms each) in this order: `up ▲` → `fn` → `cache` (a value gets written into the dotted box) → `version: 3 → 4` (ticker increments) → `down ▼` → `guard` (lock briefly clasps).
+- 3.5–5.0s: All anatomy labels fade back to baseline, leaving the node visible as a labeled diagram.
+
+**Marketing payload:** "every node is the same primitive — cache + version + guard + up/down."
+
+#### Stage 4 — Node taxonomy (Y-shape, 5s)
+
+**Topology:** starts with the single node from Stage 3.
+
+Beat-by-beat:
+- 0.0–2.0s: The center label cycles its text every 500ms: `state` (teal flash) → `producer` (emerald flash) → `derived` (violet flash) → `effect` (amber flash). The node's fill color matches each kind as the label changes.
+- 2.0–3.5s: Camera pulls back. The single node splits/morphs into a **Y-shape**:
+  ```
+   state (teal)    ──┐
+                     ├──► derived (violet) ──► effect (amber)
+   producer (emer) ──┘
+  ```
+  Edges draw in left-to-right.
+- 3.5–5.0s: A real flow runs once through the Y — `state` and `producer` both emit DIRTY (two yellow dashes converging on `derived`), then both emit DATA (two green dots converging). `derived` fires **once** (`fn(...)` flash; this is a mini-diamond callback to Stage 2). Then `derived` emits DATA → green dot to `effect`; `effect` fires (amber ring ripple = side effect).
+
+**Marketing payload:** "four sugars, one primitive — state/producer feed derived; derived feeds effect."
+
+#### Stage 5 — Graph level (8s, 4 beats)
+
+##### 5a — Population (1.5s)
+Camera dollies further back. The single Y-chain replicates into 3–4 parallel chains, with cross-edges weaving between them. The topology resolves into a richer connected mesh of ~20 nodes. No messages flowing yet — just structure crystallizing.
+
+##### 5b — describe() blueprint + observe() magnifier (3s)
+- 0.0–1.0s: All nodes drain of color; the topology becomes a faint dotted **blueprint** — pure structure, no signal. Small label fades in top-left: `graph.describe()` with a thin arrow → tiny annotation `"the map"`.
+- 1.0–2.2s: A circular **magnifier lens** (glassy, thin ring border) glides in from the right and hovers over a cluster of 3–4 blueprint nodes. *Inside the lens only*, the blueprint becomes vivid and live message dots (DIRTY yellow + DATA green) flow along the edges within the lens's field of view. Label updates: `graph.observe(path)` → `"the magnifier"`.
+- 2.2–3.0s: The lens drifts to a different cluster, dots flow there instead. Then lens fades; topology re-colorizes fully.
+
+**Marketing payload:** "describe is the map. observe is the magnifier. The graph is its own data." (DS-14.5.A spec-as-projection reframe embodied.)
+
+##### 5c — batch() sweep (2s)
+A purple `BATCH_START` bracket sweeps left-to-right across the entire graph. Multiple producers fire DIRTY *simultaneously* (yellow dashes cascading everywhere); green DATA dots queue up *visibly held* at the producers, glowing brighter as they accumulate. Then a `BATCH_END` bracket sweeps back, and all held DATA releases at once as a synchronized wave rippling through the topology.
+
+**Marketing payload:** "batch defers DATA, not DIRTY — one coherent update."
+
+##### 5d — Subgraph carve (1.5s, hands off to Stage 6)
+Two or three translucent capsule outlines appear around clusters of nodes — each capsule has its own slow-pulsing border color (different agent owners; e.g. cyan capsule, magenta capsule). The bridge nodes between capsules glow brighter — these become the messaging hubs in Stage 6. Capsules persist into Stage 6.
+
+#### Stage 6 — Domain level: orchestration + messaging (6s, 2 beats)
+
+##### 6a — Orchestration (2.5s)
+Inside one capsule, a sequential pipeline animation runs: 4 nodes lit in succession (left-to-right) like a small assembly line — `gate → action → check → action`. Each node fires (`fn(...)` flash) when the green DATA arrives; the next one lights when this one completes. Small label: `pipeline`.
+
+##### 6b — Messaging hub + cursor (3.5s)
+A **central hub node** appears in the gap between the two capsules — distinct visual: a vertical pill shape with a "stream" of small horizontal tokens (items) inside, stacked top-to-bottom. Each capsule has a **cursor marker** (small `▌` glyph) at a position in the hub's stream.
+
+Beat-by-beat:
+- 0.0–1.5s: New tokens fall in from the top of the hub (publishers in one capsule pushing). The hub's stream grows.
+- 1.5–3.0s: Each capsule's cursor independently advances upward, "consuming" tokens. The cursors move at different rates (one capsule reads faster than the other). As a cursor passes a token, the token glows then dims, and a DATA dot leaves the hub edge toward a node inside that capsule.
+- 3.0–3.5s: A small floating label: `hub + cursor`. Beneath in smaller faded text: `static graph, dynamic data`.
+
+**Marketing payload:** the 降维 idea — the graph topology is static, but the hub's stream carries dynamic content; cursors decouple consumers' read pace from publishers' write pace. This is the substrate for higher-level patterns.
+
+#### Stage 7 — Agent loop + memory + "?" (5s)
+
+##### 7a — Agent loop (1.8s)
+Inside one capsule, a closed cyclic subgraph lights up: `agent → tool → result → agent` (a tight loop of 3-4 nodes arranged in a circle). A DATA dot circulates around the loop 2–3 times.
+
+##### 7b — Agentic memory (1.7s)
+A second node appears off the agent loop labeled `memory`. As the agent loop runs, small tokens stream from the loop into `memory`, accumulating visibly (the memory node grows or its interior fills up with stacked tokens).
+
+##### 7c — "?" extensibility (1.5s)
+Several **hexagonal nodes labeled `?`** appear at the periphery of the canvas, each connected to the existing topology by a single edge that trails off into faded space. They pulse gently.
+
+**Marketing payload:** "agent loop, memory — and these are just examples. The substrate is open." (Anti-stealth thesis embodied — the library shows its primitives, not just packaged solutions.)
+
+#### Stage 8 — Loop seam (2s)
+
+Camera zooms back in. All decorations (capsules, hub, `?` nodes, memory, agent loop) fade out. The topology reduces back to the **exact two-node arrangement of Stage 1**: producer (emerald diamond, left) + derived (violet circle, right), same canvas positions, edge resting.
+
+The last frame at t=42s must match the first frame at t=0s pixel-for-pixel for an invisible loop seam.
+
+### Mode-B implementation notes
+
+- **Single GSAP timeline** spans all 8 stages. Use `gsap.timeline({ repeat: -1 })` so the seam loops in preview automatically.
+- **Position parameter** is your friend — use absolute timeline labels (`stage1`, `stage2`, ...) at each stage boundary so timing tweaks don't cascade.
+- **No `setTimeout`, no `requestAnimationFrame`** — everything goes through the GSAP timeline (HyperFrames seeking requirement, also project invariant from AGENTS.md "no raw async primitives").
+- **Camera zoom/pan**: implement as GSAP-animated CSS `transform: scale() translate()` on a wrapper `<div>` containing the topology — *not* by reflowing nodes individually. Keeps motion frame-rate-stable.
+- **Loop-seam validation**: at the end, evaluate `tl.time(0)` vs `tl.time(tl.duration())` visually in preview. The two frames must be indistinguishable.
+- **Render to two formats**: MP4 for downloads/social, WebM (VP9, transparent if your design allows) for `<video autoplay muted loop playsinline>` embedding on the landing page.
+- **Headline test**: after rendering, drop the video into the actual hero slot on the live `website/` and verify the planned headline text is readable over the most visually busy frames (likely Stages 2, 5c, 6b). If contrast fails, increase the overlay darken to 50% rather than dimming the video itself.
+
+### Mode-B quality checks (in addition to Step 6)
+
+- [ ] Total duration is 40–48s
+- [ ] Stage 8's final frame matches Stage 1's opening frame (loop seam invisible)
+- [ ] Sugar names used as labels are exactly: `state`, `producer`, `derived`, `effect` (no `node` in user-facing labels)
+- [ ] Message labels used are exactly: `START`, `DIRTY`, `DATA`, `COMPLETE` (foundational subset)
+- [ ] No captions over the topology (small floating labels of ≤4 words OK; full sentences are forbidden in this mode)
+- [ ] Both MP4 and WebM/VP9 outputs render successfully
+- [ ] Headline-readability test on a live `website/` page passes
diff --git a/.agents/skills/qa/SKILL.md b/.agents/skills/qa/SKILL.md
new file mode 100644
index 00000000..218addc5
--- /dev/null
+++ b/.agents/skills/qa/SKILL.md
@@ -0,0 +1,110 @@
+---
+name: qa
+description: "Adversarial code review, apply fixes, final checks (test/lint/build), and doc updates. Run after /dev-dispatch or any manual implementation. Use when user says 'qa', 'review', or 'code review'. Supports --skip-docs to skip documentation phase."
+argument-hint: "[--skip-docs] [optional context about what was implemented]"
+---
+
+You are executing the **qa** workflow for the **clean-slate GraphReFly** redesign.
+
+This repo is **`@graphrefly/ts`** — the self-contained TypeScript implementation (D32); clean-slate code lives in **`packages/ts/src/`**. Siblings (each self-contained, cross-language = wire bridge, never in-process): `@graphrefly/rust` (`~/src/graphrefly-rs`), `@graphrefly/py` (`~/src/graphrefly-py`). The language-neutral authority (spec / decisions / plan / conformance / formal) lives in **`~/src/graphrefly`** (branch `clean-slate`) as jsonl — when this skill and that repo disagree, that repo wins (AGENTS.md).
+
+> **Stale-infra guard.** Do NOT reach for the retired port-model surfaces: `packages/pure-ts/**` (frozen read-only reference only, D41), `docs/implementation-plan.md` / `implementation-plan-13.6-*.md` / `optimizations.md` / `roadmap.md` / `test-guidance.md` / `docs-guidance.md`, `GRAPHREFLY-SPEC.md` / `COMPOSITION-GUIDE.md` (migrated to `spec/rules.jsonl` + `guide/guide.jsonl`, B7), the `@graphrefly/graphrefly` shim + its 4-file subpath rule, the `Impl`/facade/actor model, the Rust `migration-status.md` / `porting-deferred.md` / canonical-spec-13.6 registries. The clean-slate authority is the `~/src/graphrefly` jsonl.
+
+Context from user: $ARGUMENTS
+
+### Flag detection
+If `$ARGUMENTS` contains `--skip-docs`, skip Phase 4 (Documentation Updates).
+
+### Repo detection
+Inspect the diff to detect which package(s) are touched: `packages/ts/` (this repo), `~/src/graphrefly-py`, `~/src/graphrefly-rs`. The cross-language contract is **behavioral conformance (D24)**, not symbol parity — review each arm against the SAME `spec/rules.jsonl` + `spec/conformance.jsonl`, per-language idioms aside.
+
+---
+
+## Phase 1: Adversarial Code Review
+
+### 1a. Gather the diff
+
+Run `git diff` for uncommitted changes; if the chat's work was already committed, diff against the chat's baseline commit (`git log --oneline` to find it, then `git diff <base>..HEAD`). Include relevant untracked files (read them). Concentrate the review on the **substantive hand-written code** — formally-verified TLA+ (already TLC-checked), generated artifacts, and jsonl data are lower bug-risk than imperative substrate/graph code.
+
+Also load the clean-slate context the review must NOT contradict:
+- `~/src/graphrefly/spec/rules.jsonl` — the protocol 宪法 (R-* rules); the behavior authority. Cite R-ids in findings.
+- `~/src/graphrefly/decisions/decisions.jsonl` — the governing D# (or `/decision-guard`); the F-* floor + durable values.
+- `~/src/graphrefly/plan/backlog.jsonl` + `plan/antipatterns.jsonl` — **already-acknowledged deferred concerns (B#) and known anti-patterns. DO NOT raise a finding that matches an existing deferred B# or antipattern** — those are accepted. DO raise a finding that *contradicts* a deferred entry's stated scope.
+- `~/src/graphrefly/spec/conformance.jsonl` — the C-* scenarios the change must keep green (+ their `runtimes` status).
+- `~/src/graphrefly/formal/*.tla` — when the change implements a formally-modeled rule, cross-check the impl against the TLC-verified model.
+
+### 1b. Launch parallel review subagents
+
+Launch as parallel Agent calls. Each receives the diff + the context from $ARGUMENTS (what was implemented and why). Tell each to do a STATIC review (no servers, no test runs) and return ONLY a findings list.
+
+**Subagent 1: Blind Hunter** — pure code review, no project context:
+> You are a Blind Hunter code reviewer. Review this diff for: logic errors, off-by-one, race/re-entrancy hazards, resource leaks (unclosed subscriptions, unbounded registries), stale-closure / index-desync bugs, missing error handling, dead/unreachable code, sparse-array holes, security issues. For Python, also check thread/free-threaded safety. Be adversarial — assume bugs exist; trace the suspicious paths concretely. If a suspicious path is actually correct, say so in one line rather than raising noise. Output each finding as: **title** | **severity** (critical/major/minor) | **location** (file:line) | **detail** (trigger + consequence + suggested fix).
+
+**Subagent 2: Edge Case Hunter** — clean-slate spec-aware:
+> You are an Edge Case Hunter reviewing a change against the GraphReFly clean-slate SPEC. The authority is `~/src/graphrefly` jsonl (branch clean-slate) — NOT any docs/*.md or packages/pure-ts (retired port-model; ignore). Read the relevant `spec/rules.jsonl` R-* rules + `decisions/decisions.jsonl` D# for the area under review, and the matching `spec/conformance.jsonl` C-* + `formal/*.tla` model if the change implements a spec-locked behavior.
+>
+> Check protocol/wave invariants against the rules: message tuples `[[Type,Data?]]`, one array = one wave (R-msg-format); DIRTY-before-DATA in the same wave (R-dirty-before-data); two-phase glitch-free diamond, recompute-once (R-two-phase/R-diamond); ctx.up control-tier-only (R-ctx-up); SENTINEL = absence-of-DATA, never-emitted detector `prevData===undefined` (R-sentinel); equals DATA→RESOLVED only on a single-DATA wave (R-equals); first-run gate (R-first-run-gate); INVALIDATE idempotent + lifecycle-continue (R-invalidate-idempotent); terminal-is-forever / resubscribable reset (R-terminal); ROM/RAM cache (R-rom-ram); PAUSE lockset + modes (R-pause-lockset/R-pause-modes); reentrancy reject (R-reentrancy/D37).
+>
+> Flag floor violations: imperative side-channel triggers (R-no-imperative — emitters/callbacks/timers+set instead of ctx.up/message flow); polling/busy-wait (R-no-polling); bare async in the sync core (R-no-raw-async / F-SYNC-CORE — async only in sources / pool / wire bridge); inline-fn bypassing the dispatcher (R-dispatch-all / F-DISPATCH-ALL); peeking a dep `.cache` to seed compute (R-data-not-peek); hardcoded `type === "DATA"` instead of messageTier (R-tier); protocol internals (DIRTY/RESOLVED/bitmask) leaking into value-level sugar (R-primary-api-clean / DR-1); counters/inspection on the thin node (R-node-thin); a new verb (D4 closed set) or a 10th tier (D9) introduced casually; graph-level shared mutable state accessed implicitly instead of an explicit node+dep (D22/D23); cross-graph in-process coupling instead of a wire bridge (D22/D32).
+>
+> If the change implements a formally-modeled rule, identify any place the impl DIVERGES from the `formal/*.tla` model (cite the invariant). Surface real-but-unmodeled cross-axis interactions (e.g. X×batch, X×pause) and say whether each is a genuine gap or acceptably-deferred. DROP any finding that matches an already-acknowledged `plan/backlog.jsonl` B# or `plan/antipatterns.jsonl` entry. Output each finding as: **title** | **severity** | **location** (file:line or R-id) | **detail** (the rule/D# it relates to + what the impl does + divergence/gap/ok).
+
+Scale the reviewer count to the change: 2 is the default; for a large or high-risk substrate change add a third reviewer on a specific axis (e.g. concurrency/pool, or a perspective-diverse second spec reviewer).
+
+### 1c. Triage findings
+Classify each: **patch** (fixable, caused by this change — include the fix) · **defer** (pre-existing or out-of-scope — note it) · **reject** (false positive / noise — drop silently). Cross-check every finding against `plan/backlog.jsonl` + `plan/antipatterns.jsonl`; a match to an accepted deferral → **reject** silently.
+
+Fix priority (most→least): 1) **spec alignment** (`spec/rules.jsonl` / the F-* floor — a rule wins over current impl) · 2) **semantic correctness** (protocol + node contract) · 3) **completeness** (edge cases) · 4) **consistency** (patterns already in `packages/ts/src/`) · 5) **level of effort**. (Frozen `packages/pure-ts/**` + `~/src/callbag-recharge` are read-only precedent only — the clean-slate spec wins on any conflict.)
+
+### 1d. Present findings (HALT)
+Present ALL patch + defer findings (treat equally). For each: the issue + location, the **recommended fix** (pros/cons), whether it affects architecture, and whether it needs a user decision or can be auto-applied. Group:
+1. **Needs Decision** — architecture-affecting or ambiguous (route per the floor: architectural lock → `/design-review` → D#; wave-protocol behavior change → `/spec-amend`; an open question with no clear answer → `plan/backlog.jsonl` B#).
+2. **Auto-applicable** — clear fixes following existing patterns.
+
+**Wait for user decisions on group 1.** Group 2 may be applied on the user's batch approval. Do NOT silently pick on a needs-decision item (no-autonomous-decisions).
+
+---
+
+## Phase 2: Apply Review Fixes
+Apply the approved fixes. Cite the governing R-id / D# in any new test expectations.
+
+---
+
+## Phase 3: Final Checks
+Run all checks for the affected package(s) and fix failures (do NOT skip/ignore):
+
+**TypeScript (`@graphrefly/ts`):**
+1. `pnpm --filter @graphrefly/ts test` (vitest) — all pass.
+2. `pnpm run lint` (biome + layer-boundary + typecheck gates); `pnpm run lint:fix` to auto-format.
+3. `pnpm run build` (tsup ESM/CJS/DTS) when public API changed.
+
+**Sibling packages (only if touched):** run that package's own test/lint/type gate in its repo (`~/src/graphrefly-py` / `~/src/graphrefly-rs`) following its local conventions. The cross-language contract is behavioral conformance (D24) — a substrate behavior change should drive its `spec/conformance.jsonl` arm green per runtime.
+
+**jsonl touched (`~/src/graphrefly`):** `node ~/src/graphrefly/dashboard/build.mjs --check` — the consistency gate (non-zero on broken links / orphans).
+
+**TLA+ touched:** re-run the affected model (`cd ~/src/graphrefly/formal && java -cp <tla2tools.jar> tlc2.TLC -config <name>.cfg <name>`); for a new invariant, mutation-verify it is load-bearing (break the guard → confirm it trips) before claiming it.
+
+**Long / heavy commands** (full test sweeps, Rust gates, TLC): run them so they're observably-finishing, not a false-hang — prefer a run-logged wrapper + monitor a guaranteed DONE sentinel (never a guessed progress string, never `sleep`-poll). If this QA runs in a spawned subagent, run such commands **synchronously** (wait for the sentinel) or tear them down (kill by process group) **before returning** — never leak a live background process as a stale "running" entry. (memories `feedback_long_command_observation`, `feedback_subagent_bg_hygiene`, `feedback_no_chained_background_cargo`.)
+
+If a failure exposes a design question, **HALT** and raise it before fixing.
+
+---
+
+## Phase 4: Documentation Updates
+
+**Skip if `--skip-docs` was passed.** Update only what behavior/API actually changed; clean-slate docs are jsonl (single source of truth):
+
+- **`spec/rules.jsonl`** — only if the protocol itself was intentionally revised → that is a `/spec-amend`, not a casual edit (amend rules + `formal/*.tla` + `spec/conformance.jsonl` together). Flip a conformance-backed rule `draft → active` once its scenario is green on the reference arm + formal lands (cite the precedent).
+- **`decisions/decisions.jsonl`** — a new architectural lock surfaced by QA → `/design-review` → user approval → append a `D#` (update the DS-1 `locks` in `sessions/sessions.jsonl`).
+- **`spec/conformance.jsonl`** — flip `runtimes.<arm>` → `pass` when an arm lands green; add a new C-* scenario for a new behavioral rule; keep `covers` ↔ rule `covers_by` bidirectionally consistent.
+- **`plan/phases.jsonl`** — update the CSP-* phase `status`/`note` the change advances.
+- **`plan/backlog.jsonl`** — add new deferred items (B# + concrete trigger) surfaced by QA.
+- **`plan/antipatterns.jsonl`** — a recurring anti-pattern (+ a `feedback_*` memory if generalizable).
+- **`formal/README.md`** — when a TLA+ module was added/changed (module-map row + a mutation-verified note).
+- **Structured JSDoc** on new exported public symbols (`packages/ts/src/<area>`); cite the governing R-id/D# when the API encodes a spec invariant.
+- **`guide/guide.jsonl`** (G-test / G-composition / G-docs / G-contribute) — if a new test/composition pattern or doc convention was established.
+- **`~/src/graphrefly/AGENTS.md`** — only if a fundamental workflow/command changed.
+
+After any `~/src/graphrefly` jsonl edit, re-run `node ~/src/graphrefly/dashboard/build.mjs --check`.
+
+When done, briefly list files changed + new exports, the fixes applied vs deferred (with B# pointers), and the gate results.
diff --git a/.agents/skills/research/SKILL.md b/.agents/skills/research/SKILL.md
new file mode 100644
index 00000000..2082bbef
--- /dev/null
+++ b/.agents/skills/research/SKILL.md
@@ -0,0 +1,143 @@
+---
+name: research
+description: "Research a topic triggered by curiosity or a post the user saw. Uses web search to analyze latest trends, competitor landscape, user patterns, future demands, and how findings relate to GraphReFly's roadmap and gaps. Triggers: 'research', 'look into', 'what's the landscape for', 'I saw this post about', 'trend check', 'competitor analysis'."
+argument-hint: "<topic or URL or paste of post>"
+---
+
+You are executing the **research** workflow for **GraphReFly**.
+
+The user has a topic they want to explore — triggered by curiosity, a post they saw, or a trend they want to understand. Your job is to research it thoroughly using web search, then ground the findings against GraphReFly's current position. The goal is to **facilitate a discussion** about library direction — surface facts, tensions, and open questions that the user can react to, not just deliver a static report.
+
+**Today's date: use the current date from system context for all searches.**
+
+User input: $ARGUMENTS
+
+---
+
+## Phase 0: Topic extraction
+
+Parse `$ARGUMENTS` to determine:
+
+1. **Topic** — the core subject to research (e.g. "reactive state management trends", "AI agent frameworks", "graph-based orchestration")
+2. **Trigger** — what prompted this (a post URL, a screenshot, a thought). If a URL is provided, fetch it first with `mcp__searxng__web_url_read` or `WebFetch` to extract context.
+3. **Angle** — what specifically interests the user (if stated). If not stated, default to: "how does this relate to GraphReFly's positioning?"
+
+State the extracted topic, trigger, and angle before proceeding.
+
+---
+
+## Phase 1: Landscape research
+
+Use `mcp__searxng__searxng_web_search` (preferred) or `WebSearch` to gather intel. Run **at least 4-6 searches** covering different angles. Suggested search patterns (adapt to topic):
+
+1. **Trend pulse** — `"{topic}" trends 2025 2026` or `"{topic}" state of` 
+2. **User pain points** — `"{topic}" problems OR frustrations OR "wish it could"` or reddit/HN discussions
+3. **Competitor landscape** — `"{topic}" libraries OR frameworks comparison` or `"{topic}" vs` 
+4. **Future direction** — `"{topic}" roadmap OR "what's next" OR future`
+5. **Developer adoption** — `"{topic}" adoption OR migration OR "switched to"`
+6. **Academic/deep** — `"{topic}" research OR paper OR architecture` (if relevant)
+
+For each search, read 2-3 promising results using `mcp__searxng__web_url_read` or `WebFetch` to get substance beyond snippets.
+
+---
+
+## Phase 2: Read GraphReFly context
+
+Read these files in parallel to ground findings:
+
+- `docs/implementation-plan.md` — **canonical pre-1.0 sequencer.** Find which phase covers this topic area (Phase 11–16 + Parked) and read what's locked, what's open-design, what's parked. This is where "current phase" lives now.
+- `docs/roadmap.md` — vision / wave context only (Wave 0/1/2/3 announcement frame, harness engineering positioning). Useful for the strategic story; do NOT use as the active sequencer.
+- `docs/optimizations.md` — active backlog and open questions (line-item state)
+- `archive/docs/design-archive-index.jsonl` — **this is an index file, not content.** Scan it for session docs whose titles/descriptions relate to the research topic. Then read the relevant `archive/docs/SESSION-*.md` files in detail. These contain design decisions, trade-off discussions, and architectural context that may directly inform the analysis.
+- `~/src/graphrefly/GRAPHREFLY-SPEC.md` — spec (skim relevant sections if topic touches protocol)
+
+---
+
+## Phase 3: Structured analysis
+
+Produce a report with these sections. Be **honest and specific** — don't flatter GraphReFly where it doesn't deserve it.
+
+### 3.1 Trend summary
+
+> What's happening in this space right now? What are the dominant patterns, tools, and conversations? Cite sources.
+
+3-5 bullet points, each with a source link.
+
+### 3.2 User patterns & demands
+
+> What do developers/users actually want? What pain points keep surfacing? What's the "pull" signal?
+
+Distinguish between:
+- **Validated demand** (multiple sources, real adoption) 
+- **Emerging signal** (early signs, small communities)
+- **Hype** (lots of talk, unclear substance)
+
+### 3.3 Competitor matrix
+
+Build a comparison table:
+
+| Competitor | Approach | Strengths | Weaknesses | Adoption signal |
+|---|---|---|---|---|
+| {name} | {1-line approach} | {2-3 points} | {2-3 points} | {GitHub stars, npm downloads, community size, or "unknown"} |
+
+Include 3-6 competitors. For each, note the most interesting design decision they made.
+
+### 3.4 GraphReFly positioning
+
+Answer each honestly:
+
+- **Where GraphReFly has genuine advantages** — be specific about which feature/design decision creates the edge. Reference spec sections or code.
+- **Where GraphReFly has gaps** — things competitors do that we don't, or user demands we can't meet yet. Reference roadmap items if they're planned.
+- **Where it's unclear** — areas where we'd need to build something to know if our approach works better.
+
+### 3.5 Lessons & insights
+
+> What can we learn from this research? What surprised you?
+
+3-5 numbered insights. For each:
+- The insight itself
+- Why it matters for GraphReFly specifically
+- Whether it validates, challenges, or is orthogonal to our current direction
+
+### 3.6 Plan alignment
+
+Cross-reference findings with `docs/implementation-plan.md` (canonical) and `docs/optimizations.md` (line-item):
+
+| Finding | Plan alignment | Action |
+|---|---|---|
+| {trend/demand/gap} | {matches Phase 11–16 item / matches Parked trigger / no match / conflicts with locked decision} | {already planned in Phase X / consider adding to Phase Y / file as Parked / file in optimizations.md / revisit} |
+
+---
+
+## Phase 4: Recommendations & discussion prompts
+
+End with two subsections:
+
+### 4.1 Recommendations
+
+A prioritized list of **at most 5** concrete recommendations:
+
+1. **{Action}** — {why, grounded in research}. Priority: {high/medium/low}. Effort: {small/medium/large}.
+
+Recommendations should be actionable — not "think about X" but "add X to implementation-plan.md Phase Y" / "file X under Parked with trigger Z" / "prototype X to validate assumption Z" / "write a comparison doc showing advantage over Y".
+
+### 4.2 Discussion prompts
+
+Surface **2-3 open questions** that the research raised but can't answer alone — things that depend on the user's judgment, taste, or strategic priorities. Frame these as genuine questions to spark discussion, not rhetorical ones. Examples:
+
+- "Competitor X chose to do Y — do we think that's the right trade-off for our users, or does our reactive-first approach make Y unnecessary?"
+- "There's emerging demand for Z, but it would pull us toward {direction}. Is that a direction we want to go?"
+- "Our prior decision in SESSION-{name} assumed {thing} — this research suggests that assumption may be shifting. Worth revisiting?"
+
+The goal is to leave the user with something to react to, not just a wall of information.
+
+---
+
+## Output discipline
+
+- **Cite sources.** Every claim about the external world should have a URL or at minimum a named source.
+- **Be honest.** "GraphReFly doesn't address this yet" is more useful than spin.
+- **Date-stamp.** Note that this research reflects the landscape as of the current date.
+- **Keep it scannable.** Use tables, bullets, and headers. Avoid walls of prose.
+- **Don't implement.** This skill produces a research report. It does NOT modify code. It MAY suggest additions to `docs/optimizations.md` if gaps are identified — ask the user first.
+- **Invite discussion.** End on the open questions, not the recommendations. The user should feel pulled to respond, not just informed.
diff --git a/.agents/skills/spec-amend/SKILL.md b/.agents/skills/spec-amend/SKILL.md
new file mode 100644
index 00000000..abed49e4
--- /dev/null
+++ b/.agents/skills/spec-amend/SKILL.md
@@ -0,0 +1,34 @@
+---
+name: spec-amend
+description: "Spec-first protocol amendment flow for the clean-slate GraphReFly redesign. Use BEFORE changing any wave-protocol behavior (tiers, wave semantics, diamond/equals/SENTINEL, batch, push-on-subscribe, ctx.up/down contract). Enforces F-NO-IMPL-DEFINED: amend spec/rules.jsonl + formal/*.tla + spec/conformance.jsonl FIRST, then implement in each language package. Triggers: 'amend the spec', 'change the protocol', 'add a tier', 'spec change', 'new wave rule', 'this changes protocol behavior'. NOT for sugar/operator/inspection changes — those are per-language, never touch spec."
+argument-hint: "[short description of the protocol behavior to change]"
+---
+
+You are executing **spec-amend** for the clean-slate GraphReFly redesign.
+
+**Authority repo:** `~/src/graphrefly` (clean-slate branch) holds the language-neutral spec.
+Per-language packages (`graphrefly-{ts,rust,py}`) implement it; they NEVER define protocol behavior.
+
+## Iron rule (F-NO-IMPL-DEFINED, decision D14/D19)
+
+Protocol behavior is **spec-first**. No "implementation defines what happens." Order is fixed:
+
+1. **Amend the spec data** (before any code):
+   - `~/src/graphrefly/spec/rules.jsonl` — add/edit the normative rule (`{id, area, tier?, statement, rationale, status, since:"D#", covers_by:[]}`). Mark `status:"draft"` until conformance + code land, then `"active"`.
+   - `~/src/graphrefly/formal/*.tla` (+ MC config) — model the behavior; add the invariant; run TLC. (formalization γ, D14.)
+   - `~/src/graphrefly/spec/conformance.jsonl` — add the behavioral scenario(s) that pin the new rule (`covers:[rule-id]`, `runtimes:{ts:"todo",rust:"todo",py:"todo"}`, `status:"required"`).
+2. **Record the decision** if this is a new architectural lock: append a `D#` to `~/src/graphrefly/decisions/decisions.jsonl` (or reference the existing one in `since`).
+3. **Run the consistency gate:** `node ~/src/graphrefly/dashboard/build.mjs --check` (no broken links/orphans).
+4. **THEN implement** in each language package to make the conformance scenarios pass; flip `runtimes.<lang>` → `"pass"` as each lands. Use `/dev-dispatch` per package.
+
+## Closed-set guardrails (do not bypass)
+
+- **9 tiers are a closed set** (D9). Adding a tier is a constitutional change — requires explicit user lock + TLA+ re-model, not a casual amend.
+- **onMessage/onSubscribe are substrate-fixed** (D19) — they are NOT user-replaceable hooks; "amend" means changing the spec'd behavior, not adding a config knob.
+- **equals fires only single-DATA-wave** (D15); **ctx.up is control-tier only** (R-ctx-up); **restore ≠ fresh-lifecycle wipe** (R-restore). Re-read these rules before touching adjacent behavior.
+
+## Output
+
+A spec-amendment plan: which rule(s) change, the TLA+ invariant delta, the conformance scenario(s) added, the D# (new or referenced), and the per-language implementation order. HALT for user approval before writing TLA+/code if the change touches a closed-set guardrail.
+
+After the spec data lands and `--check` is clean, hand off to `/dev-dispatch` per language package and `/conformance` to drive the scenarios green.
diff --git a/.changeset/config.json b/.changeset/config.json
index 139d71f2..d4614bba 100644
--- a/.changeset/config.json
+++ b/.changeset/config.json
@@ -1,13 +1,18 @@
 {
 	"$schema": "https://unpkg.com/@changesets/config@3.1.4/schema.json",
-	"changelog": ["@changesets/changelog-github", { "repo": "graphrefly/graphrefly-ts" }],
+	"changelog": [
+		"@changesets/changelog-github",
+		{
+			"repo": "graphrefly/graphrefly-ts"
+		}
+	],
 	"commit": false,
-	"fixed": [["@graphrefly/graphrefly", "@graphrefly/pure-ts"]],
+	"fixed": [],
 	"linked": [],
 	"access": "public",
 	"baseBranch": "main",
 	"updateInternalDependencies": "patch",
-	"ignore": ["@graphrefly/parity-tests"],
+	"ignore": ["@graphrefly/graphrefly", "@graphrefly/parity-tests"],
 	"___experimentalUnsafeOptions_WILL_CHANGE_IN_PATCH": {
 		"onlyUpdatePeerDependentsWhenOutOfRange": true
 	}
diff --git a/.claude/launch.json b/.claude/launch.json
index 7960d81b..41d95112 100644
--- a/.claude/launch.json
+++ b/.claude/launch.json
@@ -13,18 +13,6 @@
 			"runtimeArgs": ["--dir", "demos/reactive-layout", "dev"],
 			"port": 4322
 		},
-		{
-			"name": "knowledge-graph-demo",
-			"runtimeExecutable": "pnpm",
-			"runtimeArgs": ["--dir", "demos/knowledge-graph", "dev"],
-			"port": 4324
-		},
-		{
-			"name": "pagerduty-triage-demo",
-			"runtimeExecutable": "pnpm",
-			"runtimeArgs": ["--dir", "demos/pagerduty-triage", "dev"],
-			"port": 4325
-		},
 		{
 			"name": "website",
 			"runtimeExecutable": "pnpm",
diff --git a/.claude/skills/conformance/SKILL.md b/.claude/skills/conformance/SKILL.md
new file mode 100644
index 00000000..2acd3479
--- /dev/null
+++ b/.claude/skills/conformance/SKILL.md
@@ -0,0 +1,61 @@
+---
+name: conformance
+description: "Behavioral conformance check across GraphReFly language runtimes (ts/rust/py) for the clean-slate redesign. Replaces the old structural 'parity' diff. Parity = does each runtime satisfy the wave-protocol behavior (conformance scenarios) + dispatcher contract — NOT 'do the symbol sets match'. Use after implementing/changing substrate behavior in any runtime, or when adding a new protocol rule. Authors/runs language-agnostic scenarios and updates conformance.jsonl runtime status. Triggers: 'conformance', 'cross-lang check', 'does rust match', 'parity', 'run the conformance suite', 'is the substrate behavior consistent'."
+argument-hint: "[rule-id | scenario-id | 'full'] [optional: runtime ts|rust|py]"
+---
+
+You are executing **conformance** for the clean-slate GraphReFly redesign.
+
+**Parity is behavioral, not structural (D24).** There is NO `Impl` symbol-set to diff and NO
+cross-track-ledger. Operators / sugar / inspection are **per-language and never in parity**
+(D6/D27 — graph-layer wraps everything to `(ctx)=>void` before register). The ONLY parity
+surface is: **wave-protocol behavior + dispatcher contract + handle format**. Conformance =
+each runtime passes the same language-agnostic scenarios.
+
+## Authority
+
+| Source | Role |
+|---|---|
+| `~/src/graphrefly/spec/conformance.jsonl` | The scenario registry: `{id, name, covers:[rule-id], runtimes:{ts,rust,py}, status, note}`. |
+| `~/src/graphrefly/spec/rules.jsonl` | The rules scenarios pin (`covers` must resolve here). |
+| `~/src/graphrefly/spec/protocol.proto` | Protocol-contract IDL (DR-2) — the light structural anchor codegen'd into each runtime's interface stub. |
+| `~/src/graphrefly/formal/*.tla` | TLA+ model (γ); property tests mirror its invariants. |
+
+## Scope from $ARGUMENTS
+
+- **rule-id** (e.g. `R-diamond`) → all scenarios whose `covers` includes it.
+- **scenario-id** (e.g. `C-1`) → that scenario.
+- **full** → every `status:"required"` scenario.
+- optional **runtime** → restrict to one arm.
+
+## Phase 1 — scenario integrity
+
+1. Load `conformance.jsonl` + `rules.jsonl`. Verify every `covers` rule-id resolves (else HALT — fix the scenario or add the rule via `/spec-amend`).
+2. List the **DR-5 required hard scenarios** and their status: `C-1` cross-graph diamond, `C-2` async-result-at-paused-node, `C-3` INVALIDATE×ctx.state×onInvalidate, `C-4` mixed sync/async diamond, `C-5` PAUSE-lockset multi-source. These are the load-bearing ones — behavioral parity is a blank cheque until they're green on each shipped runtime.
+
+## Phase 2 — run / verify per runtime
+
+For each in-scope `(scenario, runtime)`:
+1. Locate/author the scenario harness in that runtime's conformance test dir (language-agnostic spec → per-runtime adapter; the scenario describes observable wave behavior, not a symbol call).
+2. Run it. Record outcome.
+3. Update `conformance.jsonl` `runtimes.<rt>`: `"todo" | "poc-pass" | "pass" | "fail"`.
+4. Mirror the invariant as a property test (fast-check ts ↔ proptest rust ↔ hypothesis py) where the rule is property-shaped (L5-Q2 / D14).
+
+## Phase 3 — report
+
+| scenario | covers | ts | rust | py | verdict |
+|---|---|---|---|---|---|
+
+- **Behavior drift** = same scenario, different observable outcome across runtimes → this is the ONLY kind of parity gap. File it as a substrate bug in the lagging runtime (route fix via `/dev-dispatch` on that package).
+- **Missing scenario** for a rule (rule's `covers_by` empty) → author it (this is the real risk under behavioral parity: untested behavior can drift silently — D24 residual). Flag via `/dashboard` Gaps (uncoveredRules).
+- **NOT a gap:** a runtime having a different operator set / different sugar / different inspection ergonomics. Those are per-language by design — do not report them.
+
+## Phase 4 — gate
+
+Run `node ~/src/graphrefly/dashboard/build.mjs --check` (scenario↔rule links intact). For a runtime
+to be declared "conformant", all `status:"required"` scenarios must be `"pass"` on its arm.
+
+## Boundaries
+
+Does NOT diff symbol sets (that's the retired structural model). Does NOT touch operators/sugar/inspection
+(per-language). New protocol behavior must go through `/spec-amend` FIRST (scenario authored before code).
diff --git a/.claude/skills/dashboard/SKILL.md b/.claude/skills/dashboard/SKILL.md
new file mode 100644
index 00000000..a2903ef4
--- /dev/null
+++ b/.claude/skills/dashboard/SKILL.md
@@ -0,0 +1,33 @@
+---
+name: dashboard
+description: "Build / check the GraphReFly internal docs dashboard (jsonl single-source -> generated HTML with progress, structure map, gaps, search). Use when the user wants to see global project state, regenerate the dashboard, run the docs consistency gate (broken links / orphans / coverage gaps), or after editing any jsonl in ~/src/graphrefly (decisions/plan/spec/sessions/guide). Triggers: 'build the dashboard', 'check docs consistency', 'what are the gaps', 'show progress', 'regenerate dashboard', 'doc gate'."
+argument-hint: "[--check (gate only) | (default: build + report)]"
+---
+
+You are executing **dashboard** for the clean-slate GraphReFly redesign.
+
+**Repo:** `~/src/graphrefly` (clean-slate branch). All structured docs are jsonl (single source of truth, decision 2); the dashboard renders them into one searchable HTML view for the maintainer (decision 3). Schema contract: `~/src/graphrefly/dashboard/README.md`.
+
+## What this skill does
+
+1. **Run the generator:**
+   - `node ~/src/graphrefly/dashboard/build.mjs` → writes `dashboard/dashboard.html` + prints counts / gaps / broken-links / orphans report.
+   - `node ~/src/graphrefly/dashboard/build.mjs --check` → consistency gate only; **non-zero exit on broken links** (use as a pre-commit / CI gate).
+2. **Interpret the report** for the user:
+   - **counts** — per-jsonl row counts (decisions/phases/rules/conformance/...).
+   - **gaps** — designPhases (status=design|gap) · openDecisions · deferredBacklog · uncoveredRules (no conformance) · todoConformance (runtimes=todo). This answers "哪里还有缺口".
+   - **broken links** — must be zero (session.locks → decision; phase.sessions → session; conformance.covers → rule; flowchart.explains → rule|D#). Legacy 3-digit D### / R# refs are external (old main), reported separately as OK.
+   - **orphans** — decisions referenced by no session (informational).
+3. **If broken links exist:** locate the offending jsonl row, fix the id reference (or add the missing record), re-run `--check`.
+
+## When the jsonl changed
+
+After any edit to `decisions/`, `plan/`, `spec/`, `sessions/`, `guide/` jsonl — run `--check` to catch dangling references immediately (fixes P4 stale-premise + P6 link-rot). The generator is the enforcement mechanism for "single canonical, no broken cross-refs."
+
+## UI styling
+
+`build.mjs` emits a **placeholder shell** with the data model embedded. Visual design / interactive search is a separate `/frontend-design` pass — do NOT hand-style the HTML here; keep `build.mjs` focused on the data model + consistency checks. The dogfood endgame (phase CSP-8) rebuilds this dashboard *with GraphReFly itself* (jsonl producer → reactive views → HTML effect).
+
+## Output
+
+The counts + gaps + link-health report, a plain-language "where are the gaps / what's the progress" summary, and (unless `--check`) confirmation that `dashboard.html` was written. Flag any broken link as a blocker to fix before commit.
diff --git a/.claude/skills/decision-guard/SKILL.md b/.claude/skills/decision-guard/SKILL.md
index a228a176..78f64884 100644
--- a/.claude/skills/decision-guard/SKILL.md
+++ b/.claude/skills/decision-guard/SKILL.md
@@ -1,229 +1,87 @@
 ---
 name: decision-guard
-description: "GraphReFly Rust-port decision-consistency check. Loads the user's locked values/principles/invariants + the canonical D-numbered decision log + recurring decision-process patterns. Use BEFORE answering any question of the form 'is this consistent with our decisions?', 'should I pick option A/B/C?', 'what about this proposed fix?', 'is X part of our scope?', 'is this a regression on a prior decision?'. Triggers: 'decision check', 'drift check', 'align check', 'is this consistent', 'should I pick', 'what about this', 'is this in scope', 'consistency review'."
-argument-hint: "[short context of what you're being asked about — paste the chat/proposal if relevant]"
+description: "GraphReFly clean-slate decision-consistency check. Loads the user's locked values/principles + the unified D-numbered decision log (decisions.jsonl) + recurring decision-process patterns. Use BEFORE answering any question of the form 'is this consistent with our decisions?', 'should I pick option A/B/C?', 'what about this proposed fix?', 'is X part of our scope?', 'is this a regression on a prior decision?'. Triggers: 'decision check', 'drift check', 'align check', 'is this consistent', 'should I pick', 'what about this', 'is this in scope', 'consistency review'."
+argument-hint: "[short context of what you're being asked about — paste the proposal if relevant]"
 ---
 
-# decision-guard — Recall and apply locked decisions, values, invariants
+# decision-guard — recall and apply locked decisions, values, invariants (clean-slate)
 
-**Purpose.** Future conversations about the GraphReFly Rust port lose context-window state quickly. This skill is the canonical recall surface: invoke it BEFORE answering decision questions to anchor against the user's locked positions and prevent silent drift. Especially valuable when:
+**Purpose.** Conversations lose context-window state quickly. This is the canonical recall
+surface for the **clean-slate** redesign: invoke BEFORE answering decision questions to anchor
+against the user's locked positions and prevent silent drift — especially when a chat proposes
+a scope expansion mid-implementation, presents A/B/C as a fork, uses "completeness" to justify
+expanding a locked slice, or builds on a premise that may be stale.
 
-- A chat (or a subagent's chat) proposes a scope expansion mid-implementation.
-- Multiple options (A/B/C, α/β/γ) are presented as a fork.
-- A "completeness" argument is used to justify expanding a locked slice.
-- A finding is being triaged (patch / defer / reject).
-- A premise sounds plausible but might be stale (the substrate moved under it).
+> **Clean-slate retired the old port model.** Do NOT reach for `rust-port-decisions.md`,
+> `cross-track-ledger.md`, the `Impl` parity contract, `BindingBoundary`, the actor model, or
+> 3-digit D### port decisions — those are old-`main` history. The clean-slate decision
+> authority is below.
 
-The user has repeatedly invoked patterns from this skill across sessions; relay-ready answers should cite them by name.
+## Sources (load in order)
 
-## Authority pointers (load these only if the question requires them)
-
-| File | What it is |
+| Source | Role |
 |---|---|
-| `~/src/graphrefly-ts/docs/rust-port-decisions.md` | **D-numbered decision log.** Each entry has Date / Context / Options / Decision / Rationale / Affects. The canonical record. |
-| `~/src/graphrefly-rs/docs/migration-status.md` | Milestone + slice closing blocks; the live tracker. |
-| `~/src/graphrefly-rs/docs/porting-deferred.md` | Deferred concerns registry. Findings matching an entry here → **reject silently** in /qa. |
-| `~/src/graphrefly-ts/docs/cross-track-ledger.md` | TS↔Rust coupling events. Substrate-contract widening lands here BEFORE the change. |
-| `~/src/graphrefly-ts/docs/implementation-plan-13.6-canonical-spec.md` | **Behavior authority** for the Rust port. Canonical spec wins over current TS impl per §11 Implementation Deltas. |
-| `~/src/graphrefly-ts/archive/optimizations/cross-language-notes.jsonl` | Verified, sanctioned divergences (`divergence-*` ids). Findings matching these → reject silently. |
-
-## User values & principles (immovable; cite these by name)
-
-1. **No backward compat (pre-1.0).** Free to refactor/rename any API. No legacy shims. Memory: `feedback_no_backward_compat`. When user says "ignore legacy/backward compat" → take the structurally cleaner option without hesitation.
-2. **No imperative triggers in public API.** Coordination via reactive `NodeInput` signals and message flow. Imperative methods only on L2.35 controller-with-audit primitives. Actively remove imperative paths when no caller depends. Memory: `feedback_no_imperative`.
-3. **Single source of truth.** No mirroring logic across FFI boundary; no duplicate state. Core is authority on its invariants; binding/JS-side preflight = drift bait. Memory: `feedback_single_source_of_truth`.
-4. **No autonomous decisions.** Surface spec↔code conflicts; don't silently pick. File-by-file review cadence for multi-file rewrites. Memory: `feedback_no_autonomous_decisions`. **Hard rule.**
-5. **No implement without approval.** Decisions locked ≠ implementation approved. Wait for explicit "implement" instruction. Memory: `feedback_no_implement_without_approval`.
-6. **Pre-design full decision-set before slicing.** Avoid CoreFull-style accretion (D232→D243→D244→D245 layered widening). Design facade traits' full surface ONCE. Cite spec R-IDs in test expectations. Audit user-visible semantics at design time, not in QA. Memory: `feedback_pre_design_full_decision_set`.
-7. **Verify premise before greenfield.** Design-session task tables lag the code; grep named symbols + check landed markers before any 9Q. Surface stale premises as a HALT. Memory: `feedback_verify_premise_before_greenfield`. This pattern has produced multiple wins (D256 invoke_fn_with_core premise-check; D260 timing-divergence reframe).
-8. **Sync internal, async at boundary — BOTH directions.** Async/Promise only at the four sanctioned edges (napi `#[napi] async fn` surface, wrapper.js public surface, `timer.rs` tokio task, `graphrefly-storage` tokio integration). Inside `graphrefly-core` / `graphrefly-graph` / `graphrefly-operators` / `graphrefly-structures`: pure sync + reactive. **The boundary applies in BOTH directions** — sync escape hatches on binding read methods callable from inside TSFN callbacks violate the invariant (D070/D077 deadlock recurrence). Read methods on Bench* napi classes must be `async fn`. Memory: extend `feedback_async_sources_binding_layer`.
-9. **Consumer-pressure (D196).** No speculative substrate surface. A Rust-core symbol gets a napi binding when (a) a non-pattern consumer materializes, OR (b) a parity scenario exercises it cross-impl. "Parity scenarios are the consumer pressure signal." Applies recursively — don't add features expecting future use; wait for the test/scenario that needs them.
-10. **Spec is authority.** The canonical-spec doc wins over current TS implementation. Widening must be explicit (cross-track-ledger event). Test expectations cite R-IDs (R1.3.5.a, R2.5.3, R2.6.4, etc.) — not intuition.
-11. **Completeness AND discipline.** When implementation surfaces a real semantic gap, **formalize the scope expansion as a new D-number** with proper design + test plan, don't continue under the original D's banner. (Path X-via-D264 pattern, not Path X-direct or Path Y trim.) Discipline without completeness ships half-baked surfaces; completeness without discipline auto-expands scope.
-12. **Long-command observation discipline.** Use `mise run gate` / `mise run run-logged` with sentinel grep (`<<<RUN-LOGGED:DONE>>>`). Never pipe through `tail` (buffers until EOF). Never poll via `sleep` loops. Memory: `feedback_long_command_observation`.
-13. **Subagent hygiene.** Synchronous verification OR teardown bg processes (kill by process group) before returning. A leaked bg process surfaces as a stale "running" entry indistinguishable from a real hang. Memory: `feedback_subagent_bg_hygiene`.
-14. **Distinguish vestigial-surface from speculative-surface.** D196 ("no speculative substrate") governs **new** surface added without consumer pressure. It does **NOT** govern cleanup of surface that an earlier-locked decision RELAXED into vestigial overhead (e.g., D248 relaxed Sink Send+Sync → operator-internal `Arc<Mutex<X>>` capturing single-owner state became dead weight). Vestigial-surface removal is **decision-consistency restoration**, a separate justification class with locked precedent: D253 (SchedulingGroupId delete), D254-AUDIT (Send-closure variant audit), D267 (Family-2 Cat-3 Arc<Mutex>→Rc<RefCell>). Conflating them = framing error; cite this value when classifying cleanup candidates. Memory: `feedback_distinguish_vestigial_vs_speculative`.
-
-## Architectural invariants (compiler-enforced chokepoints)
-
-| Trait/Type | Signature | What it forbids |
-|---|---|---|
-| `CoreActor::run<F, R>` | `F: FnOnce(&Core) -> R + Send + 'static` | Can't put `.await` in closure body (no async context) |
-| `MailboxOp::Defer(SendDeferFn)` | `SendDeferFn = Box<dyn FnOnce(&dyn CoreFull) + Send>` | Deferred closure body must be sync; no `AsyncDefer` variant exists |
-| `BindingBoundary::invoke_fn_with_core` | sync `fn(&self, .., core: &dyn CoreFull)` | Making binding callback async requires widening the trait → cross-track-ledger event |
-| `Sink = Arc<dyn Fn(&[Message]) + 'static>` (post-D248, !Send !Sync) | Sync `Fn` closure | Sinks can't be async; they fire synchronously during a wave |
-| `Core::emit` / `Core::subscribe` etc. | All sync `pub fn` | Adding `pub async fn` in `graphrefly-core` would require tokio in Core — forbidden by D070/D077 |
-| `Core: !Send + !Sync` (D248) | Move-only single-owner | Can't share `Arc<Core>` across threads; cross-Core parallelism is host-native via independent per-worker Cores |
-| `BindingBoundary: Send + Sync` (FFI trait, unchanged by D248) | Send+Sync stays | Only subscriber callbacks (Sink/TopologySink/etc.) relaxed off Send+Sync; the FFI contract is unchanged |
-| `CoreMailbox: Send + Sync` (D249) | Id-only ops + Send cross-thread Defer | DeferQueue is the !Send owner-only companion |
-
-## Invariant-watch list (red flags — HALT if any are proposed)
-
-1. `pub async fn` in `graphrefly-core` / `graphrefly-graph` / `graphrefly-operators` / `graphrefly-structures`. Only `graphrefly-storage` + `graphrefly-bindings-*` are sanctioned to import tokio.
-2. New `MailboxOp::AsyncDefer(BoxFuture<...>)` variant.
-3. Sink / TopologySink / NamespaceChangeSink becoming async return types.
-4. Actor closure body calling `.await`.
-5. napi method body chaining `.then(...)` or awaiting inside the actor closure (instead of inside the napi async fn wrapper).
-6. `wrapper.js` stashing Promise chains in long-lived state. Promises resolve at the napi-call boundary; long-lived state = resolved values.
-7. A reactive primitive returning `Promise<Node<T>>` in the binding layer.
-8. Sync escape hatches on binding read methods (`run_sync` napi methods callable from inside TSFN sink callbacks). The bi-directional async-at-boundary invariant.
-9. `BindingBoundary` widening without a cross-track-ledger row added FIRST.
-10. Adding a new `Impl` parity-contract method without a parity scenario authored in the same slice. (D196 — "parity scenarios are the consumer pressure signal.")
-11. Threadlocal-current-Core or similar machinery (`CURRENT_CORE`, `CoreThreadGuard`, `current_core()` accessor). D256 deleted these; re-adding them is regression.
-12. `core.clone()` anywhere (`impl Clone for Core` was deleted at D221/D246).
-13. Storing `Core` by value in a struct that's then put in `Arc<>` or `OnceLock<>` (Core is `!Send + !Sync` post-D248).
-14. SchedulingGroupId speculative surface (D253 deleted it; re-adding without M6 consumer = regression).
+| `~/src/graphrefly/decisions/decisions.jsonl` | **Unified D# log** (D1–D33 + DR-*). Canonical record: `{id, layer, question, decision, rationale, supersedes, status}`. |
+| `~/src/graphrefly/sessions/active/SESSION-clean-slate-redesign.md` (DS-1) | Full design narrative + 8 forced constraints + spec-amendment list + conformance hard scenarios. |
+| `~/src/graphrefly/plan/antipatterns.jsonl` | Lessons / anti-patterns to flag against. |
+| `~/src/graphrefly/spec/rules.jsonl` | Protocol rules — for "does the spec already pin this?". |
+| Memory `feedback_*` files | The user's durable values/principles (below). |
+
+## Locked values (durable — cite by name)
+
+1. **No backward compat** (pre-1.0): structurally cleaner option, no legacy shims. `feedback_no_backward_compat`.
+2. **No imperative triggers** in public API: reactive `ctx.up`/signals, not emitters/callbacks/timers+set; remove imperative paths when no caller depends. `feedback_no_imperative`.
+3. **Single source of truth**: one canonical per concern; index points, never duplicates. `feedback_single_source_of_truth`.
+4. **No autonomous decisions** (hard rule): surface spec↔code conflicts; don't silently pick; file-by-file review for multi-file rewrites. `feedback_no_autonomous_decisions`.
+5. **No implement without approval**: decisions locked ≠ implementation approved. `feedback_no_implement_without_approval`.
+6. **Verify premise before greenfield**: design tables lag code — grep symbols + check landed markers before a 9Q; stale premise = HALT. `feedback_verify_premise_before_greenfield`.
+7. **Latest versions + context7** for current API docs. `feedback_latest_versions_context7`.
+8. **Long-command observation discipline** (run-logged + DONE sentinel; no tail; no sleep-poll) and **subagent bg hygiene** (sync-verify or teardown before return). `feedback_long_command_observation`, `feedback_subagent_bg_hygiene`.
+
+## Clean-slate floor (never violate)
+
+**Sacred (L0.7):** topology declarative/serializable/inspectable · wave protocol is a public spec ·
+wave protocol impl is **sync** · all fn go through dispatcher.
+
+**Forced (F-*):** F-PERF (budget every abstraction) · F-PROTO-SPEC (spec+TLA++property) ·
+F-SYNC-CORE (dispatcher.invoke sync void) · F-DISPATCH-ALL (no inline-fn bypass) ·
+F-GRAPH-FIRST-API · F-NO-WEDGE-CUT (every primitive ≥2 segments) ·
+F-NO-IMPL-DEFINED (spec-locked or explicitly undefined-by-design) · F-NO-LLM-ONLY.
+
+**Red flags (HALT if proposed):** async in the sync wave core (async lives only in pools/wire-bridge) ·
+inline-fn bypassing dispatcher · a primitive serving only LLM workflows · a protocol behavior left
+"implementation-defined" · user-replaceable onMessage/onSubscribe · adding a 10th tier casually ·
+graph-level shared mutable state accessed implicitly (must be explicit node + dep).
 
 ## Decision-process patterns (apply in order)
 
-When asked "is X consistent / should I pick Y?":
+1. **Identify the governing D#.** Grep `decisions.jsonl` by `layer`/keyword. Is the proposal within a locked D's scope? Mid-implementation scope expansion = anti-pattern unless promoted to a NEW D#.
+2. **Check the spec.** Does `rules.jsonl` pin the behavior? If yes, follow it — divergence is a bug, not a design call. If silent/ambiguous → real design HALT.
+3. **Verify premise (value 6).** Has the symbol/surface already landed? grep before designing new surface.
+4. **Apply values + floor.** Especially: no autonomous decisions, no imperative, single source of truth, sync-core/async-at-boundary, F-* constraints.
+5. **Verdict:** `consistent (cite D#)` / `regression on D#` / `out-of-scope` / `needs new decision (don't auto-pick)`.
+6. **Routing:**
+   - New fork, no governing D# → present options + recommend, **do NOT lock** → that's `/design-review` → user approval → append `decisions.jsonl`.
+   - Changes protocol behavior → `/spec-amend` (spec-first).
+   - Cross-runtime parity concern → `/conformance` (behavioral scenario, not structural diff).
 
-1. **Identify the locked decision-scope.** What D-number is this slice operating under? Is the proposed change within that D's locked scope? Scope expansion mid-implementation = anti-pattern unless promoted to a new D-number.
-2. **Check the canonical spec.** Does the spec rule pin the behavior? If yes, follow spec — implementation that diverges is buggy, not a "design call." If spec is silent/ambiguous, that's a real design HALT.
-3. **Check existing substrate surface.** Verify premise before greenfield: has the trait already been widened? Has the helper already been added? `feedback_verify_premise_before_greenfield` has paid off multiple times — always check before designing new surface.
-4. **Apply the 8 user values above.** Especially: no autonomous decisions, no imperative triggers, single source of truth, sync-internal/async-at-boundary (bi-directional).
-5. **Check D196 consumer pressure — BUT classify the candidate first.** Is the proposed change **new surface** (D196 applies; needs consumer signal) or **vestigial-surface removal** (D196 does NOT apply; decision-consistency restoration is the right frame — precedent D253/D254-AUDIT/D267, value #14)? Speculative-new widening fails D196; vestigial-cleanup is justified by the earlier relaxation that made the surface dead, no new consumer signal required.
-6. **Check completeness AND discipline.** If the proposed change closes a real semantic gap, formalize as new D-number (Path X-via-D[N+1]). If the proposed change is speculative scope expansion, revert (Path Y trim).
-7. **Identify cross-track-ledger events.** Does the change widen `Impl` parity contract? Does it cross presentation↔Rust-port? If yes, ledger row goes in BEFORE the change (`docs/cross-track-ledger.md`).
-8. **Triage findings.** Match against `porting-deferred.md` (reject silently if matches) and `cross-language-notes.jsonl` `divergence-*` (reject silently if matches). Verified divergences ≠ hypothesized divergences — don't preemptively document the latter.
-
-## Common decision-shape templates
-
-### α/β/γ pattern (when napi binding shapes are forked — applies to S6+)
-
-- **α** — owner-thread-pinned `std::thread` worker + channel + oneshot reply
-- **β** — mailbox-only async API (all ops post to mailbox + await reply)
-- **γ** — sync owner-thread API via `spawn_blocking` onto pinned thread
-
-**Lock: α (D255).** β is dead permanently (D070/D077 libuv-busy deadlock recurrence — `bridge_sync` blocks libuv while waiting for TSFN microtask that needs libuv). γ collapses to α at impl level (`napi::tokio_runtime::spawn_blocking` has no thread affinity; `LocalSet` is invasive; γ.ii = std::thread + channel + oneshot IS α).
-
-### A/B/C pattern (when fix shape is forked)
-
-Default: the option that **structurally extends an existing pattern** wins over per-site workarounds. Recent applications:
-- **D260** (wave-end re-drain loop) — A extends D232-AMEND/D249's drain-to-quiescence past `fire_deferred`. B re-introduces D256-deleted threadlocal. C per-sink eager nested waves change mid-batch ordering without principled rationale. → A wins.
-- **F2 S6 fix** (RefCell reentrant borrow panic) — B restructure with RAII Guard is more general; C specialized helper is minimal diff. Either valid; lean B for long-term API generality, C for short-term scope.
-
-### Path X / Path Y / Path Z pattern (when slice scope is contested)
-
-- **Path X-direct** — continue under original D, fix bug introduced by autonomous scope expansion. **Anti-pattern.**
-- **Path X-via-D[N+1]** — stop tracing under original D; lock new semantic as new D-number; resume under new banner. **Right pattern when scope expansion catches a real semantic gap.**
-- **Path Y** — revert scope expansion; ship original D's locked scope only. **Right pattern when scope expansion is speculative.**
-- **Path Z** — defer entire slice; redesign later. **Right pattern when neither shipping nor continuing is principled.**
-
-### Adversarial-review pattern (for /qa)
-
-- **Critical** — show-stopper, breaks first call. Fix or hard HALT.
-- **Major (needs decision)** — architecture-affecting or ambiguous fix. User decides between options.
-- **Auto-applicable** — clear fix following existing patterns. Batch with approval.
-- **Reject** — false positive, matches a porting-deferred entry, or matches a `divergence-*` entry. Drop silently.
-
-## Locked decisions index (concise; load `rust-port-decisions.md` for full)
-
-| D# | Scope | One-line |
-|---|---|---|
-| D246 | β-simplification lock | Single-owner pushed all the way down; delete shared-Core machinery; ignore legacy ergonomics. Operating rule: NO stubs/deferrals — finish each S fully. |
-| D247 | S2c Graph tree shape | `Rc<RefCell<GraphInner>>` (not owned-`&mut`); Graph becomes `!Send+!Sync`. |
-| D248 | S2c Sink contract relax | Substrate `Sink`/`TopologySink` dropped `Send+Sync` → `Core`/`OwnedCore`/`Graph` now `!Send + !Sync`. `BindingBoundary` stays `Send+Sync` (FFI). |
-| D249 | S2c Defer/mailbox split | Minimal owner-only `!Send` `DeferQueue` split off `Send` `CoreMailbox`. `Core::drain_mailbox` drains BOTH queues to mutual quiescence. |
-| D250 | S4 retire imperative re-entry stubs | 3 pause/resume/set_deps in-wave re-entry tests retired as deleted-model (synchronous binding-clones-Core trigger is structurally gone). NO new substrate surface. |
-| D251 | S4 rule-8 reusable coalescing slot | Per-handle `Cell<bool>` scheduled gate + observe-prune torn-id buffer in observe/describe/storage defer paths. One Box + one snapshot per wave instead of per emission. Internal refactor. |
-| D252 | S5 IN_TICK collapse | `IN_TICK_OWNED: AHashSet<u64>` → `Cell<bool>`. Hard invariant: "one Core per OS thread, no nested cross-Core driving on a single thread." Panic-on-violation at BatchGuard claim. |
-| D253 | S5 SchedulingGroupId delete | D196-pure deletion of `SchedulingGroupId` + `node_group` + `partition_of`/`group_of`/`set_scheduling_group` API. Reverses S3 rename. Re-introduce when M6 consumer materializes. |
-| D254 | S5 Tier A bundle | DeferQueue Mutex→RefCell + AtomicBool→Cell; test-file doc sweep; process-discipline memory. **D254-AUDIT inline**: TimerEmit typed variant audit found ZERO surviving emit-only Send closures; not adopted. |
-| D255 | S6 napi binding shape | α/γ-merged actor model (β dead, γ collapses to α). `crates/graphrefly-bindings-js/src/core_actor.rs` owns Core on dedicated worker thread. |
-| D256 | S6 invoke_fn_with_core override | Premise-check win: D245 already added the surface. BenchBinding overrides `BindingBoundary::invoke_fn_with_core`; `CURRENT_CORE` thread-local + `CoreThreadGuard` + `current_core()` accessor **deleted outright**. No cross-track-ledger event (consumption-not-widening). |
-| D257 | S6 Drop discipline | BenchCore::Drop dispatches detached unsubscribe via actor with try_send fallback. |
-| D258 | S6 WORKER_EXTRAS | Owner-thread-only `thread_local!(RefCell<HashMap<u64, Box<dyn Any>>>)` for `!Send` resources (Graph, StorageHandle, LogView/ScanHandle/ReactiveSub). |
-| D260 | S7 wave-end re-drain loop | `BatchGuard::Drop` extends drain past `fire_deferred` to absorb posts made by deferred-jobs themselves. Mutual quiescence in `mailbox + DeferQueue + fire_deferred`. Same `max_batch_drain_iterations` cap. |
-| D261 | S7 try_subscribe tail drain | Brief BatchGuard at end of `try_subscribe` reuses D260's drain machinery to flush handshake-fire-time posts. |
-| D266 | Family-1 sink Arc→Rc cleanup | Decision-consistency restoration post-D248 sink Send+Sync relaxation. 4 type aliases (Sink/TopologySink/DescribeSink/NamespaceChangeSink) Arc→Rc + operator-internal !Send !Sync `Arc<dyn Fn()>` callback fields + 4 `static_assertions::assert_not_impl_any!(...: Send, Sync)`. 13 per-file `#![allow]` annotations removed. No `Impl` widening. Sequenced after D265/F1. |
-| D267 | Family-2 Cat-3 `Arc<Mutex<X>>` → `Rc<RefCell<X>>` cleanup | Decision-consistency restoration; compiler-driven sweep. Try the substitution workspace-wide; compiler classifies Category-1 (bindings Send+Sync required) and Category-2 (storage Send+Sync required) via fail-to-compile → revert; residual compiling set IS Category-3 (operator-internal + test-recording, single-owner). Per-revert one-line comment naming Send+Sync source. Mutex `lock().unwrap()` → RefCell `borrow_mut()`. |
-| D268 | Vestigial union-find / defer-shim surface cleanup | Decision-consistency restoration post-D248/D253/D255 relaxation chain. Family A: delete `PartitionOrderViolation` struct + `SubscribeError::PartitionOrderViolation` variant + 9 dead `Err(_)` match arms + 7 `Result<(), PartitionOrderViolation>` fn signatures. Family B: delete `emit_or_defer`/`complete_or_defer`/`error_or_defer` from Core + BindingBoundary trait + CoreFull impl + default impls; delete `DeferredProducerOp` enum + `push_deferred_producer_op` + `drain_deferred_producer_ops` no-op shim; edit ~15 operator call-sites in `buffer.rs`. Sub-option A.i: inline `try_emit/try_complete/try_error` (pub(crate)) bodies into public `emit/complete/error` — pre-flight confirmed ZERO external callers. Net ~110 LOC, mostly deletions. |
-
-**M1 (QA /qa 2026-05-19)** — Cross-queue FIFO inversion documented as new contract: CoreMailbox drains before DeferQueue every round (queue-priority); intra-queue FIFO preserved. Regression test in `lock_discipline.rs::cross_queue_order_mailbox_then_deferred`.
-
-**M2 (QA /qa 2026-05-19)** — `compact_every` cadence restored to per-emission count (TS parity). `pending_count` tracks qualifying emits at filter gate; `flush_tier(s, snapshot, count)` advances `flush_count` by count.
-
-**Decision-audit batch (2026-05-21)** — D266/D267/D268 locked together as a decision-consistency cleanup train; bundled with doc-hygiene + 3 AMEND-D edits into one /porting-to-rs run sequenced after D265/F1 (parallel session). Doc-hygiene: L4-001 (Core rustdoc) + L4-002 (GraphOps doclinks) + L8-001 (close §7-E/§7-B/§7-F as resolved by D253/D255) + L8-002 (D250 stub-deletion history collapse) + L8-003 (CoreShared/StateCell references) + L1-001 (MailboxOp::Defer rustdoc). AMEND-D: D262/P4 affects-list + D267 wording scope precision (factory constructors retain `run_sync` under lifecycle-precondition rationale; absorbs the 4 `create` factory finding) + porting-deferred §7-C framing (decision-consistency restoration, not D196 deviation; closes when D268 lands). Audit doc: `~/src/graphrefly-rs/docs/decision-audit-2026-05-21.md`. Full L2 invariant-watch sweep #1-#14 CLEAN; L7 TRASH/ confirmed non-compiled.
-
-## Pending / open decisions (track but not yet locked at time of skill creation)
-
-These were under active discussion in the session this skill was created from; current state may have moved by next session — check `rust-port-decisions.md` first.
-
-- **D262** — `compact_every` per-emission count (M2 from /qa). Likely locked by now.
-- **D263** — `terminal_as_real_input` gate-predicate + flag-surfacing. Original framing: "no semantic change; predicate already conformant; just surface flag." Chat extended scope mid-implementation with `skips_auto_cascade`. **Recommendation: Path X-via-D264** (formalize the auto-cascade-skip semantic as its own D-number if it's the right completion of `terminal_as_real_input`'s meaning).
-- **D264 (proposed)** — `terminal_as_real_input` complete semantic with `skips_auto_cascade`, IF spec-cited. Needs spec citation from canonical-spec §5.4 / §519 / R5.4 to confirm auto-cascade-skip is in the spec's text.
-- **D265 (proposed)** — graph_bindings F1 fix: convert sync read methods (`nameOf`, `tryResolve`, `nodeCount`, etc.) to `async fn` to eliminate D070/D077 sink-callback re-entrance deadlock. Refine `Impl` parity contract to `T | Promise<T>` so pure-ts arm doesn't artificially wrap sync reads. Cross-track-ledger row.
-
-D263 /qa findings (pending lock):
-- **D1.a** — drop `|| self.partial` from `skips_auto_cascade`. Don't OR orthogonal design dimensions. Test rewrite ~10 LOC.
-- **D2.a** — `addDep` always calls Core (no JS-side preflight). Single source of truth.
-- **D3** — REJECT (canonical-shape consistency with `fire_operator`); mandatory doc note on `register_user_derived` covering NO_HANDLE deps[i] surface.
-
-## Remaining work (post-S5/S6/S7)
-
-- **S6 follow-on bench TODOs** (per-call latency, channel backpressure, multi-instance OS-thread count) — measurement-driven, not blocking.
-- **D265 / F1 fix** for graph_bindings sync-read-method deadlock.
-- **Storage-parity follow-up** (cross-track-ledger §2: appendLogStorage flush() durability + reject + rollback epoch).
-- **attach_storage re-ship-on-shrink** (pre-existing structures-storage smell).
-- **Loom verification** — outside the gate; periodic check.
-- **Native publish** (D203/D204 — human tag-push gate).
-- **M6** — pyo3 + per-binding pluggable group executor (post-1.0).
-- **D080** — async-everywhere presentation rebase (deferred until consumer pressure).
-
-## Recurring anti-patterns to call out
-
-1. **Autonomous scope expansion** — chat extends a locked D's scope with a new behavior, hits a bug, asks permission to debug. Right answer: **stop. Formalize as new D-number with proper design + test plan, then resume under new banner.** Don't trace bugs under wrong-D.
-2. **"Completeness" used to justify autonomous expansion** — when chat argues "Path X gives more complete results," check if completeness is real (genuine spec/semantic gap) or speculative (chat extending without consumer pressure). If real, formalize as new D. If speculative, revert.
-3. **Stale-premise propagation** — chat builds a recommendation on a premise that the substrate has moved past (D245 had already added the surface chat was about to recreate). Verify premise via grep / canonical doc / decision log before greenlighting.
-4. **Hypothesized divergence preemptive-doc** — adding a `cross-track-ledger.md` or `cross-language-notes.jsonl` entry for a divergence that hasn't been verified by a cross-arm parity test. **Write the test first; document only verified divergences.**
-5. **Dual-source-of-truth fixes** — JS-side preflight mirroring Core invariants; binding-side snapshot kept in sync with actor state. All such fixes drift; reject in favor of single-source-of-truth routing through the authority.
-6. **Sync escape hatch on binding reads** — `run_sync` napi methods callable from inside TSFN sink callbacks. Violates bi-directional async-at-boundary. All read methods must be `async fn`.
-7. **Test expectations from intuition** — writing `expected = [1, 2]` instead of citing R1.3.5.a + the push-on-subscribe handshake rule. Always anchor test expected vectors in spec R-IDs.
-8. **OR-ing orthogonal design flags** — `skips_auto_cascade = self.terminal_as_real_input || self.partial`. Collapses two design dimensions into one; loses expressivity; widens one flag's semantic silently. Each flag's semantic is locked independently; users compose them explicitly.
-9. **Preemptive skip-markers** — `runIf(impl.name !== "rust-via-napi")` added preemptively before a divergence is verified. You skip tests with a consumer-driven reason, not preemptively.
-10. **Deferring documentation** — comment-update sweeps deferred from S[N] to S[N+1] create reviewer noise + risk of missing sites. Delete-the-code-and-its-docs in the same commit.
-11. **D196 misapplication on vestigial-surface cleanup** — waving D196 ("no speculative substrate") at a cleanup that's actually restoring decision-consistency post-relaxation (Family-2 Cat-3 / D267 was the canonical instance; D266→D267 framing was initially wrong). Vestigial surface ≠ speculative surface. When triaging a deferred cleanup item, ask: was this surface made dead by an earlier locked relaxation (D246/D247/D248/D249/D252/D253/D256/...)? If yes, the gate is **decision-consistency restoration** (precedent D253/D254-AUDIT/D267), not D196. Value #14 covers this; cite by name.
-12. **"Orthogonal" sub-decisions whose orthogonality wasn't tested** — D301's B.a (drop reserved-prefix guard) and B.b (keep `_anon_<rawid>` snapshot marker) were framed as orthogonal during the Q4 sub-decision lock. They weren't: B.a let users register `_anon_42` as a node name, and B.b emitted `_anon_42` for unresolvable cross-mount deps with `NodeId(42)`. The `SnapshotError::UnresolvableDeps` Debug-format diagnostic could no longer distinguish "user-named node `_anon_42` failed to hydrate" from "anonymous dep with NodeId 42 couldn't be resolved" — collision caught only at /qa, not at design lock. **When sub-decisions are framed as orthogonal, sketch one input that exercises BOTH simultaneously — confirm the orthogonality survives the example before locking.** The B.a/B.b case took ~30 seconds: "user registers a node named `_anon_42`; snapshot encodes an unresolvable dep with NodeId(42); what does the diagnostic say?" — if that one-input sketch had been part of the lock checklist, the coupling would have surfaced at design-time. Add this sketch as a mandatory pre-lock micro-check for any multi-sub-decision question. Source: D301 /qa (2026-05-26).
-
-## How to use this skill in a new session
-
-When the user asks any of the trigger phrases:
-
-1. **Invoke decision-guard skill** to load this context.
-2. **Read the relevant section** for the question type (values for "is this consistent," shapes for "should I pick A/B/C," anti-patterns for "what about this chat proposal").
-3. **Check the locked decision index** for prior D-numbers that bear on the question; load `rust-port-decisions.md` excerpt if the full text is needed.
-4. **Cross-check `porting-deferred.md`** for already-acknowledged deferrals (reject-silently for /qa findings; spec-extension for new ones).
-5. **Apply the decision-process pattern** (the 8 ordered steps above).
-6. **Produce a relay-ready summary** for the user to paste back into the chat that surfaced the question. The summary should:
-   - Cite the relevant decision/value/invariant by name.
-   - Give the recommended pick (A/B/C, X/Y/Z, α/β/γ).
-   - Explain the reasoning in 2-3 sentences per option.
-   - Flag any HALT-worthy concerns (autonomous expansion, stale premise, dual-source-of-truth, etc.).
-
-## Skill scope boundaries
-
-This skill is **read-mostly**: it loads decisions + values + patterns. It does NOT:
-- Run gates (`mise run gate`) — that's `/porting-to-rs` or `/qa`.
-- Apply fixes — that's `/dev-dispatch` or `/qa` post-decision.
-- Author parity scenarios — that's a follow-up `/dev-dispatch` after a decision locks.
-- Replace `/porting-to-rs` HALTs — those have their own Phase 1/2 protocol.
-
-Invoke decision-guard when the question is **"what should I decide?"**, not "what should I do?". The output is decision + reasoning + relay-ready text. Implementation follows separately.
+## Common decision shapes
 
-## Update protocol
+- **A/B/C (fix shape):** default = the option that **structurally extends an existing pattern** beats per-site workarounds.
+- **Completeness vs discipline:** if a proposal closes a real semantic gap → formalize as a NEW D# (don't continue under the original D's banner). If speculative scope expansion → revert.
+- **Orthogonal sub-decisions:** before locking two "orthogonal" sub-decisions, sketch ONE input exercising BOTH — confirm orthogonality survives the example (antipatterns.jsonl; the 30-second check that catches coupling at design-time).
 
-When a new D-number locks (after user approval), append to:
-- `~/src/graphrefly-ts/docs/rust-port-decisions.md` — full entry (Date / Context / Options / Decision / Rationale / Affects)
-- This skill's "Locked decisions index" — one-line summary
-- `~/src/graphrefly-rs/docs/migration-status.md` — if the lock closes/scopes a slice
+## Scope boundaries
 
-When a new user value surfaces (in feedback memory format), add to:
-- `~/.claude/projects/-Users-davidchenallio-src-graphrefly-ts/memory/feedback_<name>.md`
-- This skill's "User values & principles" section — pointer + one-line summary
+Read-mostly. Loads decisions + values + patterns; produces **decision + reasoning + relay-ready text**.
+Does NOT run gates, apply fixes, or author scenarios — those are `/dev-dispatch` / `/qa` / `/conformance`
+after a decision locks. Invoke when the question is "what should I decide?", not "what should I do?".
 
-When an anti-pattern recurs (caught a 2nd time in /qa or design), add to:
-- This skill's "Recurring anti-patterns to call out" section
-- Optionally a `feedback_<name>.md` memory if it's a generalizable principle.
+## Update protocol
 
-Keep this skill **tight**: aim for ≤ ~500 lines of skill markdown. If it grows past that, factor sub-skills (`decision-guard:invariants`, `decision-guard:decisions`) and have the main skill point at them.
+When a new D# locks (after user approval): append to `~/src/graphrefly/decisions/decisions.jsonl`
+(`{id, layer, date, question, decision, rationale, supersedes, status:"locked", session}`), update the
+session's `locks` in `sessions.jsonl`, and run `node ~/src/graphrefly/dashboard/build.mjs --check`.
+When a new anti-pattern recurs: append to `~/src/graphrefly/plan/antipatterns.jsonl` (+ a `feedback_*`
+memory if generalizable). When a new durable value surfaces: add a `feedback_<name>.md` memory + a
+pointer line here.
diff --git a/.claude/skills/design-review/SKILL.md b/.claude/skills/design-review/SKILL.md
index e96e9a0c..5a783b32 100644
--- a/.claude/skills/design-review/SKILL.md
+++ b/.claude/skills/design-review/SKILL.md
@@ -5,23 +5,16 @@ disable-model-invocation: true
 argument-hint: "[<file path> | <symbol> | --diff] [optional context]"
 ---
 
-You are executing the **design-review** workflow for **GraphReFly** (cross-language: TypeScript + Python).
+You are executing the **design-review** workflow for the **clean-slate GraphReFly** redesign.
 
-This skill applies the 5 design-review questions used in `archive/docs/SESSION-ai-harness-module-review.md` (Q5–Q9 of the 9-question per-unit format). The format originated for module-scope reviews; this skill makes it available for **single-symbol / single-file / single-diff** reviews.
+This skill applies the 5 design-review questions (Q5–Q9 of the 9-question per-unit format) to a **single-symbol / single-file / single-diff** review. Use it BEFORE coding a new public API / sugar factory / operator / inspection surface — or right after a sketch lands, before tests. Different from `/qa` (finds bugs in landed code) and `/decision-guard` (recalls locked decisions); this validates abstraction + long-term shape + reactive composability + alternatives, and its output may become a new `D#` (architectural lock → user approval → append `decisions.jsonl`).
 
-**When to use this skill:**
+Clean-slate code lives in **`packages/ts/src/`** (`@graphrefly/ts`, D32). The language-neutral authority is **`~/src/graphrefly`** jsonl (branch `clean-slate`) — when this skill and that repo disagree, that repo wins (CLAUDE.md).
 
-- Before implementing a new public API in `packages/pure-ts/src/patterns/` or `packages/pure-ts/src/extra/`
-- Right after sketching a new factory / bundle / primitive, before tests are written
-- When two slightly-different implementations exist and you need a principled pick
-- When `/dev-dispatch` Phase 2 (architecture discussion) needs to go deeper than the default 4-question template
+> **Stale-infra guard.** Do NOT cite the retired port-model: `packages/pure-ts/**` (frozen read-only reference only, D41), `docs/implementation-plan.md` / `optimizations.md` / `roadmap.md` / `test-guidance.md` / `docs-guidance.md`, `GRAPHREFLY-SPEC.md` / `COMPOSITION-GUIDE.md` (migrated to `spec/rules.jsonl` + `guide/guide.jsonl`, B7), `describe({format})` (D39: renderers are pure fns over the snapshot, NOT a `format` option), the `Impl`/facade/actor model.
 
-**When NOT to use this skill:**
-
-- Bug fixes — use `/qa`
-- Pure refactors that don't change the API surface — use `/qa`
-- Implementation work that's already been approved at Phase 2 — proceed without this overhead
-- Small additive changes (e.g. adding a JSDoc field, fixing a docstring)
+**When to use:** before a new public symbol in `packages/ts/src/graph/` (sugar / operator / inspection) or a new substrate primitive in `packages/ts/src/{node,dispatcher,ctx,protocol,batch}/`; right after sketching a factory; when two implementations exist and you need a principled pick; when `/dev-dispatch` Phase 2 needs to go deeper than its default template.
+**When NOT:** bug fixes / pure refactors → `/qa`; already-approved work → proceed; trivial additive changes (a JSDoc field, a docstring).
 
 User context: $ARGUMENTS
 
@@ -29,191 +22,126 @@ User context: $ARGUMENTS
 
 ## Phase 0: Scope resolution
 
-Determine the review target(s) from `$ARGUMENTS`:
-
-1. **`--diff` (or no args)** — review the new public symbols introduced in the current uncommitted diff. Run `git diff --name-only HEAD` and `git status --short` to enumerate. Filter to files in `packages/pure-ts/src/patterns/`, `packages/pure-ts/src/extra/`, `packages/pure-ts/src/core/`, `packages/pure-ts/src/graph/`, `packages/pure-ts/src/compat/`, or `packages/pure-ts/src/integrations/` that introduce new exports.
-2. **`<file path>`** — review the public symbols in that file (single-file scope).
-3. **`<symbol name>`** — locate the symbol with Grep, then review it (single-symbol scope).
-4. **Multiple targets** — apply Q5–Q9 to each, then add Phase 2 cross-cutting synthesis.
+Resolve the target(s) from `$ARGUMENTS`:
 
-Read these in parallel before reviewing:
+1. **`--diff` / no args** — review the new public symbols in the uncommitted diff. Enumerate via `git diff --name-only HEAD` + `git status --short`, filtered to `packages/ts/src/**` files that introduce new exports.
+2. **`<file path>`** — public symbols in that file.
+3. **`<symbol name>`** — Grep-locate, then review.
+4. **Multiple targets** — apply Q5–Q9 to each, then add Phase 2 synthesis.
 
-- `~/src/graphrefly/GRAPHREFLY-SPEC.md` § 5.8–5.12 (design invariants)
-- `~/src/graphrefly/COMPOSITION-GUIDE.md` § 1, 2, 3, 5, 7, 8, 28, 32 (composition patterns)
-- `docs/implementation-plan.md` — find the phase the target belongs to (Phase 11–16). The phase entry shows scope locks, design-session IDs (DS-#), and dependencies. If the target's design is locked in a phase, the design review validates against that lock; if not yet locked, the review's output may need to land as a new sub-phase entry or DS-# session.
-- `docs/optimizations.md` "Active work items" (related architectural questions in flight, line-item state)
-- `docs/roadmap.md` — vision context only (no longer the active sequencer; consult only for the strategic frame)
-- The target file(s) themselves
-- 1–2 closest existing primitives in the same directory (precedent)
-- Optionally `~/src/callbag-recharge/` for analogous prior art (NOT spec authority)
+Read in parallel before reviewing (clean-slate authority):
 
-If the target imports anything from `packages/pure-ts/src/patterns/`, `~/src/graphrefly/COMPOSITION-GUIDE.md` is **mandatory** reading — composition primitives have non-obvious load-bearing patterns documented there.
+- `~/src/graphrefly/spec/rules.jsonl` — the R-* rules your target touches (the design invariants).
+- `~/src/graphrefly/decisions/decisions.jsonl` — the governing D# (or `/decision-guard` to recall the floor/values).
+- `~/src/graphrefly/plan/phases.jsonl` — the CSP-* phase the target belongs to (locked vs open-design); if the target isn't sequenced yet, the review's output may need a new phase / backlog entry.
+- `~/src/graphrefly/guide/guide.jsonl` (G-composition) — composition patterns (lazy activation, subscription order, SENTINEL/prevData guards, feedback cycles).
+- `~/src/graphrefly/sessions/active/SESSION-clean-slate-redesign.md` (DS-1) — the F-* constraints + the why behind locks.
+- The target file(s) + 1–2 closest existing primitives in the same dir (precedent).
+- **Frozen reference (D41):** `packages/pure-ts/**` + `~/src/callbag-recharge` for analogous prior art (operator behavior, edge cases, test structure) — NOT the authority.
 
 ---
 
 ## Phase 1: Per-target review (Q5–Q9)
 
-For each target, produce a structured report covering all five questions. Be specific and quote file:line refs. Cap each answer at ~150 words; expand only when the topic genuinely needs it.
+For each target, produce a structured report covering all five questions. Be specific, quote `file:line`. Cap each answer ~150 words.
 
 ### Q5 — Is this the right abstraction? Could it be more generic?
 
-Probe:
-
-- **Layer placement.** Does it belong in `core/` (protocol primitive), `extra/` (operator/source), `patterns/` (Phase 4+ domain factory), or `compat/` (framework adapter)? Mismatched layer is the most common drift signal.
-- **Decomposition.** Could the body be split into 2+ smaller primitives that compose into this one? (Smaller pieces are more likely to be reused.)
-- **Generalization.** Is there a 2+ similar primitive nearby that hints at a shared abstraction? Could `T = number` be `T = unknown` without losing safety? Could the config object be split into smaller bundles?
-- **Naming.** Does the name describe **what it returns / produces**, or **what it does internally**? The former is composable; the latter rots.
-
-Output:
-
-> **Layer:** {core/extra/patterns/compat/integrations} — {fits / mismatches because …}
-> **Decomposition:** {already minimal / could split into A + B / over-decomposed}
-> **Generalization:** {none surfaced / could collapse with X / over-general}
-> **Naming:** {clear / ambiguous because …}
+- **Layer placement.** Substrate (`node`/`dispatcher`/`ctx`/`protocol`/`batch` — a protocol primitive, must stay thin per R-node-thin) vs graph-layer (`graph/` — sugar / operator / inspection, per-language per D6/D24)? Mismatched layer is the most common drift signal. A new **verb** is a constitutional change (8-verb closed set, D4) — almost certainly the target is sugar, not a verb.
+- **Decomposition.** Could the body split into 2+ smaller primitives that compose? (F-NO-WEDGE-CUT: each must serve ≥2 segments.)
+- **Generalization.** A 2+ similar primitive nearby hinting at a shared abstraction? Could `T = number` be `T = unknown` without losing safety?
+- **Naming.** Does the name describe what it **returns/produces** (composable) or what it does internally (rots)? D6 real factory names show in `describe`.
 
-### Q6 — Is this the right long-term solution? What are the caveats? Maintenance burden?
+> **Layer / Decomposition / Generalization / Naming:** …
 
-Probe:
+### Q6 — Right long-term solution? Caveats? Maintenance burden?
 
-- **6-month lens.** What changes in the surrounding codebase would force this to evolve? Spec changes? Phase 5 work? PY parity?
-- **Special cases / hidden invariants.** Anything that the type system can't express but the implementation depends on (subscribe order, init-time-vs-runtime, sync-vs-async strategies, stable references, etc.)? List each one explicitly — these become bug-class footguns.
-- **Constraint locks.** Does the chosen shape close off future extensions? (E.g. positional-arg constructor → can't add options later without breaking; hard-coded enum → can't extend with custom variants.)
-- **Documentation debt.** Is the contract knowable from JSDoc alone, or does it require reading the body? Hidden contracts age badly.
+- **6-month lens.** What forces this to evolve — spec/conformance changes, rust/py arm parity (D24), F-PERF budget?
+- **Hidden invariants** the type system can't express — list each as `INVARIANT: …` (subscribe order before kick; first-run gate; SENTINEL = `prevData === undefined`; sync-vs-async strategy; stable refs; equals identity).
+- **Constraint locks** (positional args can't grow options; hardcoded enum can't extend).
+- **Doc debt** (contract knowable from JSDoc, or only from the body?).
 
-Output:
+> **6-month risk / Hidden invariants / Constraint locks / Doc debt:** …
 
-> **6-month risk:** {low / medium / high — because …}
-> **Hidden invariants:** {bullet list, each as `INVARIANT: …`}
-> **Constraint locks:** {none / list each}
-> **Doc debt:** {complete / requires reading body / undocumented}
+### Q7 — Can we simplify it? Reactive, composable, explainable?
 
-### Q7 — Can we simplify it? Make it reactive, composable, explainable?
+The **explainability check** — a primitive's reactive shape is only as good as its `describe()` snapshot (D39).
 
-This is the **explainability check** — borrowed from the pagerduty-demo + AI/harness-module-review insight. **A primitive's reactive shape is only as good as its `describe()` output.**
+- **Wire a minimal composition** (≥2 sources → target → ≥1 sink). Predict `describe()` — a flat JSON-serializable snapshot; renderers (pretty/mermaid/d2) are pure fns over it (D39), NOT a `describe({format})` option. If you can't predict the output, the topology is too imperative.
+- **Island check.** A node with zero in-edges AND zero out-edges (not an entry/exit) is a smell.
+- **Imperative escape paths.** Search for: emit/set/callback wiring that bypasses the graph (R-no-imperative); `.cache` reads inside reactive fn bodies (R-data-not-peek — data moves via messages); raw `Promise`/`setTimeout`/`queueMicrotask` outside a source/pool (R-no-raw-async / F-SYNC-CORE); hardcoded `type === "DATA"` instead of `messageTier` (R-tier); an inline fn bypassing the dispatcher (R-dispatch-all).
+- **SENTINEL / prevData guards.** Never-emitted detection via `ctx.prevData[i] === undefined` (the canonical detector); fix eager-placeholder upstreams rather than bolting on companions.
+- **Feedback cycles.** A fn that re-drives its own dep mid-wave is a wave-level ERROR (D37/R-reentrancy), not iteration; legit accumulation = `ctx.state` (scan), not a topological cycle.
 
-Probe:
-
-- **Wire a minimal composition.** Imagine `≥2 upstream sources → target → ≥1 downstream sink`. What does `graph.describe({ format: "ascii" })` show? If you can't predict the output, the topology is too imperative.
-- **Island check.** Does any node in the target have zero in-edges AND zero out-edges (and isn't an entry/exit)? Smell.
-- **Imperative escape paths.** Search for: `.emit()` / `.set()` / `.publish()` calls inside fn bodies (vs effect bodies); `.cache` reads inside reactive fn bodies (COMPOSITION-GUIDE §28); raw `Promise` / `setTimeout` / `queueMicrotask` (spec §5.10); event-emitter or callback wiring that bypasses the graph; hardcoded message-type checks (`type === DATA`) instead of `messageTier` (spec §5.11).
-- **Closure-mirror correctness.** If the target captures upstream values via closure subscribe, is the seed correct (COMPOSITION-GUIDE §28)? Is the subscribe ordered before any kick (`feedback_subscribe_before_kick.md`)?
-- **Feedback cycles.** If the target writes back to a node it reads, is the cycle broken cleanly (snapshot-on-settle, batch boundaries, §32 state-mirror)?
-
-Output:
-
-> **Topology check:** {clean — describe walks cleanly | islands: X / Y / Z | imperative leaks: …}
-> **Imperative escape paths:** {none | list each}
-> **Closure / cache reads:** {none | each one's justification}
-> **Feedback cycles:** {none | broken by … / NOT broken — concern}
-> **Simplification opportunities:** {none | bullet list — each with the cost it would impose}
+> **Topology / Imperative leaks / cache reads / Feedback cycles / Simplifications:** …
 
 ### Q8 — Alternative implementations (A / B / C)
 
-Sketch **at least 2** named alternatives. For each, give:
-
-- **Shape** — 1–3 lines of pseudo-signature
-- **Pros** — 2–4 bullets
-- **Cons** — 2–4 bullets
-- **Precedent** — does this shape exist in `callbag-recharge`, RxJS, or another reactive lib? Cite if so.
+Sketch **≥2** named alternatives. For each: **Shape** (1–3 line pseudo-sig), **Pros** (2–4), **Cons** (2–4), **Precedent** — does the shape exist in the frozen `packages/pure-ts/**` reference (D41), `callbag-recharge`, or RxJS? Cite if so. Don't pick a winner yet — that's Q9.
 
-Don't pick a winner yet — that's Q9.
-
-Output:
-
-> **A. {name}**
-> ```ts
-> // sketch
-> ```
-> Pros: …
-> Cons: …
-> Precedent: …
->
-> **B. {name}**
-> …
+> **A. {name}** — sketch / Pros / Cons / Precedent
+> **B. {name}** — …
 
 ### Q9 — Recommendation + coverage check
 
-Pick the recommended alternative from Q8. Then build a coverage matrix:
-
-| Concern from Q5–Q8 | Recommended alt covers it? |
-|---|---|
-| {abstraction concern} | yes / partially / no — because … |
-| {invariant from Q6} | … |
-| {feedback cycle from Q7} | … |
-| {alternative B's pro that we'd lose} | … |
-
-If any row is **partially** or **no**, name the residual risk explicitly. Either:
-
-- The risk is acceptable (justify why)
-- Add a follow-up to `docs/optimizations.md` "Active work items" tracking the gap
-- Pick a different alternative
+Pick the recommended alternative; build a coverage matrix (each Q5–Q8 concern → recommended alt covers it? yes / partially / no — because …). For any `partially`/`no`, name the residual risk: accept it (justify), add a `backlog.jsonl` follow-up, or pick a different alternative. End with:
 
-End with a one-paragraph summary the user can act on:
+> **Recommendation:** {alt}, because {2–3 reasons grounded in Q5–Q8}.
+> **Residual risks:** {none, OR 1–2}.
+> **Implementation guidance:** {next step — usually a draft `D#` for approval, or a sub-decision the user must answer first}.
 
-> **Recommendation:** {alternative}, because {2-3 reasons grounded in Q5–Q8}.
-> **Residual risks:** {none, OR list 1–2}.
-> **Implementation guidance:** {1-3 sentences on what to do next — usually approval to proceed, sometimes a sub-decision the user must answer first}.
+If the design is an architectural lock, draft the `D#` (`{id, layer, date, question, decision, rationale, supersedes, status}`) for the user to approve BEFORE append — do NOT auto-lock (no-autonomous-decisions). A wave-protocol behavior change routes to `/spec-amend` (spec-first), not a direct edit.
 
 ---
 
 ## Phase 2: Cross-cutting synthesis (multi-target only)
 
-Apply only if reviewing multiple targets in the same pass (e.g. `--diff` mode with 3 new factories).
+Apply only when reviewing multiple targets in one pass:
 
-Cross-cutting checks:
+- **Naming consistency** (`extract` vs `select` vs `pick` for the same role = drift).
+- **Argument-shape consistency** (options-bag vs positional applied the same way).
+- **Composition direction** (do the targets' input/output shapes line up to compose?).
+- **Repeated patterns** (the same SENTINEL-gate / subscribe-order / batch-on-write in 2+ places → a shared helper candidate).
 
-- **Naming consistency.** Are similar concepts named consistently across targets? (`extract` vs `select` vs `pick` for the same role is drift.)
-- **Argument shape consistency.** Is the options-bag vs positional-args split applied the same way?
-- **Composition direction.** Are the targets meant to compose? If so, do their input/output shapes line up cleanly?
-- **Repeated patterns.** Did the same closure-mirror / SENTINEL-gate / batch-on-write pattern appear in 2+ places? That's a candidate for a shared helper.
-
-Output a numbered list of cross-cutting findings, each with:
-
-- The pattern/inconsistency
-- Where it appears (file:line × N)
-- A proposed unifying shape
+Output a numbered list, each finding with the pattern, where it appears (file:line × N), and a proposed unifying shape.
 
 ---
 
 ## Phase 3: Decisions log
 
-For any **architectural** question that doesn't have a clear answer in the synthesis (e.g. "should we generalize X across both Y and Z?"), append it to `docs/optimizations.md` under "Active work items" using the standard shape:
-
-```
-- **{Title} ({date}, design-review).** {Question}. Options: {A / B / C}. Tradeoff: {…}. Blocked on: {concrete consumer / spec clarification / further design pass}.
-```
-
-Resolved decisions move to `archive/optimizations/resolved-decisions.jsonl` per `docs/docs-guidance.md` § "Optimization decision log" (only after the user picks one). When a design decision lands as part of a phase that fully completes, the matching `docs/implementation-plan.md` phase body should also be archived to `archive/roadmap/phase-<n>-*.jsonl` per `docs/docs-guidance.md` § "Roadmap archive — Workflow for `docs/implementation-plan.md`" — flag this in the recommendation if the design under review closes out a phase.
+- **Architectural lock** (clear) → draft a `D#` for `~/src/graphrefly/decisions/decisions.jsonl`; append only after user approval, then update the DS-1 `locks` in `sessions/sessions.jsonl` and run `node ~/src/graphrefly/dashboard/build.mjs --check`.
+- **Deferred / no clear answer** → append to `~/src/graphrefly/plan/backlog.jsonl` (B# + concrete trigger).
+- **Recurring anti-pattern** → `~/src/graphrefly/plan/antipatterns.jsonl` (+ a `feedback_*` memory if generalizable).
+- **Protocol-behavior change** surfaced → route to `/spec-amend` (spec-first), not a direct code change.
 
 ---
 
 ## Output discipline
 
 - Be concrete. Quote `file:line` refs.
-- Don't write "this looks good" — if it does, say WHY (which Q5–Q9 dimensions clear).
+- Don't write "this looks good" — say WHICH Q5–Q9 dimensions clear and why.
 - Don't pad. If Q6 has no caveats, write `**Hidden invariants:** none surfaced.` and move on.
-- Don't second-guess the user's stated intent. Q8 alternatives are options to compare; Q5–Q7 probe the recommended shape.
-- Output should be skim-readable: headers per question, bullets within.
+- Don't second-guess the user's stated intent — Q8 alternatives are options to compare; Q5–Q7 probe the recommended shape.
+- Skim-readable: headers per question, bullets within.
 
 ---
 
 ## Authority hierarchy
 
-1. **`~/src/graphrefly/GRAPHREFLY-SPEC.md`** — protocol contract
-2. **`~/src/graphrefly/COMPOSITION-GUIDE.md`** — composition patterns
-3. **`docs/implementation-plan.md`** — pre-1.0 phase locks (canonical sequencer); the matching phase entry holds locked design decisions for active work
-4. **`docs/test-guidance.md`** — testability shape
-5. Existing patterns in `packages/pure-ts/src/` — only when the above are silent
-6. **`docs/roadmap.md`** — vision context only; consult for strategic frame, not phase scope
+1. `~/src/graphrefly/spec/rules.jsonl` — the protocol 宪法.
+2. `~/src/graphrefly/decisions/decisions.jsonl` (+ DS-1 narrative) — locked decisions + F-* floor + durable values.
+3. `~/src/graphrefly/plan/phases.jsonl` — the CSP-* sequencer (phase locks).
+4. `~/src/graphrefly/guide/guide.jsonl` (G-test / G-composition) — testability + composition shape.
+5. Existing patterns in `packages/ts/src/` — only when the above are silent.
 
-If a finding seems to conflict with a higher-authority document, surface it explicitly — DO NOT silently override.
+If a finding conflicts with a higher-authority doc, surface it explicitly — DO NOT silently override (no-autonomous-decisions).
 
 ---
 
 ## What to do AFTER this skill completes
 
-- If recommendation is locked: invoke `/dev-dispatch` (or `/dev-dispatch --light` for small changes) with the locked design.
-- If decisions are deferred: leave them in `docs/optimizations.md` and move on.
-- If the design needs more thought: HALT, summarize, and let the user think.
+- Lock approved → `/dev-dispatch` (or `--light`) with the locked design; a protocol-behavior change goes through `/spec-amend` first.
+- Decisions deferred → leave them in `backlog.jsonl` and move on.
+- Needs more thought → HALT, summarize, let the user think.
 
-This skill produces a report; it does NOT modify implementation files (only `docs/optimizations.md` if architectural decisions are logged).
+This skill produces a report; it modifies no implementation files (it only appends to `~/src/graphrefly` jsonl after explicit user approval of a `D#`).
diff --git a/.claude/skills/dev-dispatch/SKILL.md b/.claude/skills/dev-dispatch/SKILL.md
index 035e34b7..4288cccf 100644
--- a/.claude/skills/dev-dispatch/SKILL.md
+++ b/.claude/skills/dev-dispatch/SKILL.md
@@ -4,91 +4,101 @@ description: "Implement feature/fix with planning and self-test. Use when user s
 argument-hint: "[--light] [task description or context]"
 ---
 
-You are executing the **dev-dispatch** workflow for **GraphReFly** (cross-language: TypeScript + Python).
+You are executing the **dev-dispatch** workflow for the **clean-slate GraphReFly** redesign.
 
-Operational docs, roadmap, optimizations, and skills all live in **graphrefly-ts** (this repo). Implementation may target `graphrefly-ts`, `graphrefly-py` (`~/src/graphrefly-py`), or both.
+This repo is **`@graphrefly/ts`** — the self-contained TypeScript implementation (D32). Clean-slate code lands in **`packages/ts/src/`**. The language-neutral authority (spec / decisions / plan / conformance / formal) lives in **`~/src/graphrefly`** (branch `clean-slate`) as jsonl — when this skill and that repo disagree, **that repo wins** (CLAUDE.md). Sibling impls: `@graphrefly/rust` (`~/src/graphrefly-rs`), `@graphrefly/py` (`~/src/graphrefly-py`) — each self-contained; cross-language = wire bridge, never in-process (D32).
+
+> **Stale-infra guard.** Do NOT reach for the retired port-model surfaces: `packages/pure-ts/**` (frozen read-only reference only, D41), `docs/implementation-plan.md`, `docs/optimizations.md`, `docs/roadmap.md`, `docs/test-guidance.md`, `docs/docs-guidance.md`, `GRAPHREFLY-SPEC.md`/`COMPOSITION-GUIDE.md` (migrated to `spec/rules.jsonl` + `guide/guide.jsonl`, B7), the `Impl`/facade/actor model / 3-digit D### port decisions. The clean-slate authority is the jsonl below.
 
 The user's task/context is: $ARGUMENTS
 
 ### Mode detection
+If `$ARGUMENTS` contains `--light`, this is **light mode**. Otherwise **full mode**. Differences are noted inline per phase.
 
-If `$ARGUMENTS` contains `--light`, this is **light mode**. Otherwise, this is **full mode**. Differences are noted inline per phase.
+### Workflow floor (non-negotiable)
+- **decision-first**: any architectural lock needs a `D#` in `~/src/graphrefly/decisions/decisions.jsonl` BEFORE code (`/design-review` → user approval → append). Decisions locked ≠ implementation approved — wait for an explicit "implement".
+- **spec-first** (F-NO-IMPL-DEFINED): any wave-protocol behavior change amends `spec/rules.jsonl` + `formal/*.tla` + `spec/conformance.jsonl` FIRST (`/spec-amend`), THEN code. Operators/sugar/inspection are per-language (D6/D24) — NOT spec, skip spec-amend.
+- **no autonomous decisions**: surface spec↔code conflicts; don't silently pick. File-by-file review for multi-file rewrites.
+- **verify premise**: design tables lag code — grep the named symbols + check landed markers (`plan/phases.jsonl` status/notes) before designing new surface; a stale premise is a HALT.
+- **consistency gate**: after touching any `~/src/graphrefly` jsonl, run `node ~/src/graphrefly/dashboard/build.mjs --check` (non-zero on broken links / orphans).
 
 ---
 
 ## Phase 1: Context & Planning
 
-Load context and plan the implementation in a single pass. **Parallelize all reads.**
-
-Read in parallel:
-- `~/src/graphrefly/GRAPHREFLY-SPEC.md` — behavior authority; deep-read sections relevant to the task
-- `~/src/graphrefly/COMPOSITION-GUIDE.md` — **composition patterns and insights** (read when building Phase 4+ factories that compose primitives — covers lazy activation, subscription ordering, null guards, Versioned navigation, factory wiring order)
-- `docs/implementation-plan.md` — **CANONICAL pre-1.0 sequencer**. Find the phase this task belongs to (Phase 11 cleanup / Phase 12 consolidation / Phase 13 multi-agent / Phase 14 changesets / Phase 14.5 residuals / Phase 15 eval / Phase 16 launch). The phase entry tells you what's locked, what's still open-design (DS-#), and what cross-references back to `optimizations.md` for line-item state. Read this FIRST so you know whether you're picking up a NOW item or one tagged WAIT/POST-1.0.
-- `docs/optimizations.md` — **line-item state for individual deferred carries**, anti-patterns, and **deferred follow-ups** (read when touching protocol, batch, node lifecycle, or parity, OR when the implementation-plan phase entry references an optimization-id). Resolved decisions are archived in `archive/optimizations/*.jsonl` — search there for historical context (see `docs/docs-guidance.md` § "Optimization decision log")
-- `docs/test-guidance.md` — checklist for the relevant layer (core protocol, node, graph, extra)
-- `docs/roadmap.md` — **vision / wave context only** (no longer the sequencer per 2026-04-30 migration — implementation-plan.md is canonical). Read for the strategic frame on a feature, not to find what's next.
-- Any files the user referenced in $ARGUMENTS
-- Relevant source files in the area you'll modify (TS: `packages/pure-ts/src/`, PY: `~/src/graphrefly-py/src/graphrefly/`)
-- Existing tests for the area (TS: `packages/pure-ts/src/__tests__/`, PY: `~/src/graphrefly-py/tests/`)
-
-**Mandatory for patterns/ work:** If the task touches any file in `packages/pure-ts/src/patterns/` or `packages/pure-ts/src/compat/`, reading `~/src/graphrefly/COMPOSITION-GUIDE.md` is **mandatory**, not optional. The harness, orchestration, messaging, and all Phase 4+ code are composed factories — modifying their tests or implementation requires understanding composition patterns (lazy activation, subscription ordering, feedback cycles, SENTINEL gate).
-
-**Roadmap §2.3 (sources & sinks):** implement as thin wrappers over the **`node` primitive** (`node`, `producer`, `derived`, `effect`) and the message protocol — no parallel source/sink protocol outside `node`.
-
-While planning, explicitly validate proposed changes against these invariants (from the spec and roadmap):
-- **Tier placement (TS)** — every new TS public symbol picks a tier: **universal** (default, browser + Node safe), **node-only** (`<x>/node` subpath, may import `node:*`), or **browser-only** (`<x>/browser` subpath, may use DOM globals). See `docs/docs-guidance.md` § "Browser / Node / Universal split". If the symbol imports `node:fs`, `node:path`, `node:crypto`, `node:sqlite`, `node:child_process`, etc., it belongs in `<x>/node` — NOT in the universal barrel. If it imports `window` / `document` / `indexedDB` / DOM types, it belongs in `<x>/browser`. Adding a new subpath means updating `packages/pure-ts/tsup.config.ts` `ENTRY_POINTS` (+ `nodeOnlyEntries` for node-only) AND `packages/pure-ts/package.json` `exports`.
-- **Control flows through the graph** — lifecycle and coordination use messages and topology, not imperative bypasses around the graph (spec §5.1).
-- **Messages are always** `[[Type, Data?], ...]` — no single-message shorthand.
-- **DIRTY before DATA/RESOLVED** in the same logical update where two-phase push applies; **batch** defers DATA, not DIRTY.
-- **Unknown message types forward** — do not swallow unrecognized tuples.
-- Prefer **composition (nodes + edges)** over monolithic configuration objects.
-- For **diamond** topologies, recomputation happens once per upstream change after all deps settle.
-- **No polling** — never poll node values on a timer or busy-wait. Use reactive sources (`fromTimer`/`from_timer`, `fromCron`/`from_cron`) instead (spec §5.8).
-- **No imperative triggers** — no event emitters, callbacks, or `setTimeout`/`threading.Timer` + `set()` workarounds. All coordination uses reactive `NodeInput` signals (spec §5.9).
-- **No raw async primitives** — TS: no bare `Promise`, `queueMicrotask`, `setTimeout`, `process.nextTick`. PY: no bare `asyncio.ensure_future`, `asyncio.create_task`, `threading.Timer`, or raw coroutines. Async belongs in sources and the runner layer (spec §5.10).
-- **Central timer and `messageTier`/`message_tier`** — TS: use `core/clock.ts`. PY: use `core/clock.py`. Never hardcode type checks (spec §5.11).
-- **Phase 4+ APIs must be developer-friendly** — sensible defaults, minimal boilerplate, clear errors. Protocol internals never surface in primary APIs (spec §5.12).
-- **PY: Thread safety** — design for GIL and free-threaded Python where core APIs are documented as thread-safe. Per-subgraph `RLock` (see roadmap Phase 0.4).
-- **PY: No `async def` in public APIs** — all public functions return `Node[T]`, `Graph`, `None`, or a plain synchronous value.
+Load context and plan in a single pass. **Parallelize all reads.**
+
+Read in parallel (clean-slate authority):
+- `~/src/graphrefly/CLAUDE.md` — the single-source authority index (read FIRST).
+- `~/src/graphrefly/spec/rules.jsonl` — the protocol 宪法 (R-* rules); deep-read the rules your change touches.
+- `~/src/graphrefly/decisions/decisions.jsonl` — the unified D# log (or invoke `/decision-guard` to recall the governing D#/values/floor).
+- `~/src/graphrefly/plan/phases.jsonl` — the CSP-* sequencer: find the phase this task belongs to, its `status` (done/impl/design), deps, and note. Read this FIRST among the plan files so you know whether you're on a ready phase or one still gated.
+- `~/src/graphrefly/plan/backlog.jsonl` + `plan/antipatterns.jsonl` — deferred carries (B#) with triggers; anti-patterns to flag against.
+- `~/src/graphrefly/spec/conformance.jsonl` — the behavioral scenarios (C-*) your change must keep green; check the `runtimes` status for the arm you target.
+- `~/src/graphrefly/guide/guide.jsonl` — composition / test / docs / contribute guidance (G-composition / G-test / G-docs / G-contribute).
+- `~/src/graphrefly/sessions/active/SESSION-clean-slate-redesign.md` (DS-1) — the L0–L6 design narrative + F-* constraints, when you need the why behind a lock.
+- Any files the user referenced in $ARGUMENTS.
+- The clean-slate source you'll modify: substrate = `packages/ts/src/{node,dispatcher,ctx,protocol,batch}/`; graph-layer = `packages/ts/src/graph/` (Graph + 8-verb sugar + operators + inspection describe/observe/profile).
+- Existing tests: `packages/ts/src/__tests__/`.
+
+**Frozen reference (D41):** `packages/pure-ts/**` and `~/src/callbag-recharge` are READ-ONLY prior art for analogous operator behavior / edge cases / test structure during a re-derive (D40 Catalog-first). Map concepts to the clean-slate substrate (`node`/`ctx.down`/`ctx.depRecords`/`Graph`, D39 `describe`/`observe`) — do NOT 1:1 port; the old substrate API and semantics differ. They are NOT the behavior authority — `spec/rules.jsonl` is.
+
+While planning, validate proposed changes against the clean-slate floor (cite the rule/D#):
+- **Sacred (L0.7):** topology declarative/serializable/inspectable · wave protocol is a public spec · wave protocol impl is **sync** · all fn go through the dispatcher.
+- **8 verbs, closed (D4):** `node`/`graph`/`batch`/`state` + `producer`/`derived`/`effect`/`mount`. **Operators are `node` sugar (D6), not verbs** — per-language, never in parity (D24); real factory names show in `describe`. Adding a verb is a constitutional change.
+- **Messages** `[[Type, Data?], ...]`; one array to `ctx.down`/`ctx.up` = one wave (R-msg-format). 10-type closed set, no user-defined types (R-msg-closed-set).
+- **DIRTY before DATA/RESOLVED** in the same wave (R-dirty-before-data); two-phase glitch-free diamond (R-two-phase); a diamond/fan-in node recomputes exactly once after all changed deps settle (R-diamond). batch defers tier-≥3, not DIRTY.
+- **`ctx.up` is control-tier only** (DIRTY/PAUSE/RESUME/INVALIDATE/TEARDOWN); DATA/RESOLVED/COMPLETE/ERROR are down-only (R-ctx-up, D8). A handle is pure data, no methods (D7).
+- **No polling** (R-no-polling); **no imperative triggers** (R-no-imperative — reactive `ctx.up`/signals, not emitters/callbacks/timers+set; remove imperative paths when no caller depends); **no raw async** in the sync core (R-no-raw-async / F-SYNC-CORE — async lives only in sources / the pool / the wire bridge).
+- **All fn through the dispatcher** (R-dispatch-all / F-DISPATCH-ALL — no inline-fn bypass). `dispatcher.invoke` is sync void (R-sync-core).
+- **Data moves via messages** (R-data-not-peek — never peek a dep's `.cache` to seed compute; `.cache` is a read-only accessor for external consumers). SENTINEL = absence-of-DATA (R-sentinel); the canonical never-emitted detector is `ctx.prevData[i] === undefined`.
+- **messageTier is a compile-time const table** (D18/D34/R-tier); the clock is **graph-local** (no global singleton, D26/R-clock); `onMessage`/`onSubscribe` are substrate-fixed, not user-replaceable (D19).
+- **Primary-API clean** (R-primary-api-clean): protocol internals (DIRTY/RESOLVED/bitmask) never surface in value-level sugar (derived/effect/operator); ctx-level (node/producer) intentionally exposes tier as a power surface (DR-1). Sugar value-fn → ctx-fn wrapping happens in the graph layer (D27); a value-level `throw` becomes `[[ERROR,e]]` down (D30).
+- **graph = single-thread causal/concurrency domain (D22 / R-graph-domain):** parallelism via pool callback or multi-graph + wire bridge; rewire is intra-graph only.
+- **`ctx.state`** = per-node private cross-wave state (R-ctx-state); shared/observable state must be an explicit node + dep, not `ctx.state` (D23). A synchronous feedback cycle (a fn re-driving its own dep mid-wave) is a wave-level ERROR (D37/R-reentrancy), not iteration.
+- **F-NO-WEDGE-CUT:** every primitive serves ≥2 segments (no LLM-only or single-segment wedge; F-NO-LLM-ONLY). **F-PERF:** budget every abstraction (thin node, default-off inspection).
+
+**Targeting a sibling (py/rust):** if the task targets `@graphrefly/py` (`~/src/graphrefly-py`) or `@graphrefly/rust` (`~/src/graphrefly-rs`), read that package's local layout + its conformance arm status in `spec/conformance.jsonl`. The cross-language contract is **behavioral conformance (D24)**, not symbol parity. PY public APIs are synchronous (return `Node[T]`/`Graph`/value, no `async def`); async lives at the source/pool boundary only (F-SYNC-CORE).
 
 Do NOT start implementing yet.
 
-**Optional context:** The predecessor codebase **callbag-recharge** at `~/src/callbag-recharge` has mature patterns, tests, and docs. Use it for **analogous** operator behavior, edge cases, and test structure — then map concepts to GraphReFly (unified message tuples, `node`, `Graph`, `describe`/`observe`). It is not the behavior spec; `~/src/graphrefly/GRAPHREFLY-SPEC.md` is.
-
 ---
 
 ## Phase 2: Architecture Discussion
 
 ### Full mode — HALT
 
-**HALT and report to the user before implementing.** Present:
+**HALT and report before implementing.** Present:
 
-1. **Architecture assumptions** — how this fits into `packages/pure-ts/src/core/`, `packages/pure-ts/src/graph/`, `packages/pure-ts/src/extra/`
-2. **New patterns** — any new patterns not yet in this repo
-3. **Options considered** — alternatives with pros/cons
-4. **Recommendation** — preferred approach and why
+1. **Architecture assumptions** — how this fits the substrate (`node`/`dispatcher`/`ctx`/`protocol`/`batch`) vs graph-layer (`graph/`) split.
+2. **New patterns** — any not yet in `packages/ts/src/`.
+3. **Options considered** — alternatives with pros/cons.
+4. **Recommendation** — preferred approach + why.
 
 Prioritize (in order):
-1. **Correctness** — matches `~/src/graphrefly/GRAPHREFLY-SPEC.md` and protocol invariants
-2. **Completeness** — edge cases (errors, completion, reconnect, diamonds)
-3. **Consistency** — matches patterns already in the target repo
-4. **Simplicity** — minimal solution
-5. **Thread safety** (PY) — where concurrent `get()` / propagation applies
+1. **Correctness** — matches `~/src/graphrefly/spec/rules.jsonl` + the floor.
+2. **Completeness** — edge cases (errors, COMPLETE, reconnect/reactivate, diamonds, SENTINEL gate, PAUSE lockset).
+3. **Consistency** — matches patterns already in `packages/ts/src/`.
+4. **Simplicity** — minimal solution.
 
-Do NOT consider backward compatibility at this early stage (pre-1.0).
+No backward compatibility (pre-1.0).
 
-**Cross-language decision log:** If Phase 1–2 surface an **architectural or product-level** question (protocol semantics, batch/node invariants, parity between ports, or anything that needs a spec/product call), **jot it down** in **`docs/optimizations.md`** under **"Active work items"** (this repo is the single source of truth for both TS and PY). When the decision is **resolved**, move it to `archive/optimizations/resolved-decisions.jsonl` per `docs/docs-guidance.md` § "Optimization decision log".
+**Escalation routing** (don't silently pick — no-autonomous-decisions):
+- Architectural lock → `/design-review` → user approval → append a `D#` to `decisions.jsonl`.
+- Wave-protocol behavior change → `/spec-amend` (spec-first: rules + TLA+ + conformance, THEN code).
+- Cross-runtime concern → `/conformance` (behavioral scenario, not structural diff).
+- Deferred/open question with no answer yet → append to `~/src/graphrefly/plan/backlog.jsonl` (B# + trigger); a recurring anti-pattern → `plan/antipatterns.jsonl` (+ a `feedback_*` memory if generalizable).
 
 **Wait for user approval before proceeding.**
 
 ### Light mode — Skip unless escalation needed
 
 Proceed directly to Phase 3 **unless** Phase 1 reveals any of these:
-- Changes to **message protocol**, **node** semantics, or **core** push/pull behavior
-- New patterns not present anywhere in the codebase
-- Multiple viable approaches with non-obvious trade-offs
+- A change to **wave-protocol behavior** (tiers, wave semantics, diamond/equals/SENTINEL, batch, push-on-subscribe, ctx.up/down contract) → spec-first, escalate.
+- A new architectural lock with no governing `D#`.
+- Multiple viable approaches with non-obvious trade-offs.
 
-If any apply, escalate: HALT and present findings as in full mode.
+If any apply: HALT and present findings as in full mode.
 
 ---
 
@@ -96,19 +106,18 @@ If any apply, escalate: HALT and present findings as in full mode.
 
 After user approves (full mode) or after Phase 1 (light mode, no escalation):
 
-1. Implement the changes
-   - Treat `~/src/graphrefly/GRAPHREFLY-SPEC.md` as non-negotiable for behavior
-   - If existing code drifts from the spec, align toward the spec as part of the change
-2. Create tests following `docs/test-guidance.md`:
-   - Put tests in the most specific existing file under `packages/pure-ts/src/__tests__/` (or colocated `*.test.ts` per project convention)
-   - Use **`Graph.observe()`** / **`graph.observe()`** for live message assertions when the Graph API exists; until then, test at the **node** and **message** level per test-guidance
+1. Implement the changes.
+   - Treat `~/src/graphrefly/spec/rules.jsonl` as non-negotiable for behavior; if code drifts from a rule, align to the rule — or surface the conflict, don't silently pick.
+   - Cite the governing R-id / D# in test expectations.
+2. Create tests (per `guide/guide.jsonl` G-test — unit / property / conformance layering):
+   - Put tests in the most specific existing file under `packages/ts/src/__tests__/`.
+   - Use `graph.observe()` for live message assertions; assert at the node + message level otherwise. A behavioral-protocol change ALSO needs a `spec/conformance.jsonl` scenario (`/conformance`) before its rule flips `draft → active`.
 3. Run checks:
-   - **TS:** `pnpm test` — and when the change touches `packages/pure-ts/src/extra/` or `packages/pure-ts/src/patterns/<x>/`, also `pnpm run build` so the post-build `assertBrowserSafeBundles` guardrail catches any Node-builtin that leaked into a universal entry.
-   - **PY:** `cd ~/src/graphrefly-py && uv run pytest && uv run ruff check src/ tests/ && uv run mypy src/`
-4. Fix any failures
-
-If implementation leaves an **open architectural decision** (deferred behavior, parity caveat, or “needs spec” item), add it to **`docs/optimizations.md`** under “Active work items” (this repo is the single source of truth). When resolved, archive to `archive/optimizations/resolved-decisions.jsonl` per `docs/docs-guidance.md`.
+   - **TS:** `pnpm --filter @graphrefly/ts test` (vitest) + `pnpm run lint` (biome + layer/typecheck gates) + `pnpm run build` (tsup) as relevant.
+   - **PY (if targeted):** the `@graphrefly/py` package's own test/lint/type gates in `~/src/graphrefly-py`.
+   - **jsonl touched:** `node ~/src/graphrefly/dashboard/build.mjs --check` (consistency gate).
+4. Fix any failures.
 
-If implementation **closes the last in-flight item from a Phase 11–16 sub-section** in `docs/implementation-plan.md`, mark the sub-section ✅ inline. If it closes the **last in-flight item in a whole Phase**, also archive the phase body to the matching `archive/roadmap/phase-<n>-*.jsonl` and replace the phase body with a 2–4-line summary + archive pointer per `docs/docs-guidance.md` § "Roadmap archive — Workflow for `docs/implementation-plan.md`". Single residual follow-ups move to `docs/optimizations.md` with a back-link to the archived phase id. Same convention applies to fully-completed waves / sections in `docs/roadmap.md`.
+If implementation leaves an **open architectural decision** (deferred behavior, parity caveat, "needs spec" item), append it to `~/src/graphrefly/plan/backlog.jsonl` (B# + trigger) — NOT a docs file. If it **lands or advances a CSP-* phase**, update that phase's `status`/`note` in `~/src/graphrefly/plan/phases.jsonl`, flip any conformance-backed `draft` rule to `active` once its scenario is green per arm, then run the consistency gate.
 
 When done, briefly list files changed and new exports added. Then suggest running `/qa` for adversarial review and final checks.
diff --git a/.claude/skills/parity/SKILL.md b/.claude/skills/parity/SKILL.md
deleted file mode 100644
index a07c5a96..00000000
--- a/.claude/skills/parity/SKILL.md
+++ /dev/null
@@ -1,153 +0,0 @@
----
-name: parity
-description: "Cross-language parity check + adversarial QA pass across graphrefly-ts and graphrefly-py. Run after /dev-dispatch + /qa on both repos. Use when user says 'parity', 'cross-lang check', or 'sync repos'."
-disable-model-invocation: true
-argument-hint: "[feature area or 'full'] [optional: path to sibling repo]"
----
-
-You are executing the **parity** workflow, comparing **graphrefly-ts** (this repo) against **graphrefly-py** (`~/src/graphrefly-py` unless overridden in $ARGUMENTS).
-
-**This repo is the single source of truth** for all operational docs (roadmap, optimizations, test-guidance, docs-guidance, archive). Both repos' docs are maintained here.
-
-Context from user: $ARGUMENTS
-
----
-
-## Phase 1: Scope & Gather
-
-Determine scope from $ARGUMENTS:
-- If a **feature area** is given (e.g. "Graph 1.3", "batch", "node lifecycle"), focus on that area only.
-- If `full`, scan all implemented phases in both repos.
-
-> **PY parity is currently PARKED until 1.0** per the 2026-04-30 re-prioritization in `docs/implementation-plan.md` § Parked. Run `/parity` only when explicitly invoked by the user (e.g. for a one-off audit), or when post-1.0 work resumes. Findings during the parked window get filed to `optimizations.md` under a `[py-parity-*]` tag and are NOT scheduled for implementation until the umbrella reopens.
-
-Read in parallel:
-- **Operational docs (this repo):** `docs/implementation-plan.md` (canonical pre-1.0 sequencer; the matching phase tells you what's locked vs in-flight), `docs/optimizations.md` (active items + deferred, line-item state for `[py-parity-*]` carries), `archive/optimizations/*.jsonl` (cross-language notes, resolved decisions — search with `grep`), `docs/roadmap.md` (vision context only; do NOT use as the sequencer), `~/src/graphrefly/GRAPHREFLY-SPEC.md` (relevant sections)
-- **Composition guide:** `~/src/graphrefly/COMPOSITION-GUIDE.md` — **mandatory** when the scoped area includes `packages/pure-ts/src/patterns/` or `packages/pure-ts/src/compat/` in either repo. Composed factories require understanding lazy activation, subscription ordering, null guards, wiring order, feedback cycles, and SENTINEL gate patterns.
-- **TS source:** `packages/pure-ts/src/` and `packages/pure-ts/src/__tests__/` in the scoped area
-- **PY source:** `~/src/graphrefly-py/src/graphrefly/` and `~/src/graphrefly-py/tests/` in the scoped area
-
-**Important:** Read `archive/optimizations/cross-language-notes.jsonl` entries with `id` prefix `divergence-`. These are **confirmed intentional divergences** — do NOT re-raise them as parity gaps or QA findings. Filter them out before presenting results.
-
----
-
-## Phase 2: Diff — API Surface
-
-For the scoped area, compare:
-
-1. **Public API** — method names, signatures, options/kwargs, return types
-2. **Error behavior** — what throws/raises, error messages, error types
-3. **Edge cases** — boundary conditions, validation rules (e.g. name constraints, duplicate handling)
-4. **Default behavior** — what happens when optional args are omitted
-5. **Subpath tier (TS-only; informational for PY)** — for each symbol, note its TS tier: universal (browser + Node safe), `<x>/node` (Node-only), or `<x>/browser` (DOM-only). See `docs/docs-guidance.md` § "Browser / Node / Universal split". Record this column even though PY has no equivalent split yet — when PY adds a comparable feature (e.g. `fileStorage`), the decision should match TS (filesystem I/O goes in a Node-only module). Treat tier mismatches where PY exposes something from a "universal"-shaped module that TS places under `<x>/node` as a flag for future PY-side consideration, not as a blocking divergence today.
-
-Present a table:
-
-| Aspect | TypeScript | Python | Verdict |
-|--------|-----------|--------|---------|
-| ... | ... | ... | aligned / TS ahead / Py ahead / intentional divergence |
-
-Mark **intentional divergences** (language idiom, concurrency model, etc.) separately from **unintentional gaps**.
-
----
-
-## Phase 3: Diff — Behavioral Semantics
-
-For unintentional gaps found in Phase 2, dig deeper:
-
-1. Read the **implementation** on both sides
-2. Read the **tests** on both sides
-3. Identify the **spec-correct** behavior per `~/src/graphrefly/GRAPHREFLY-SPEC.md`
-4. For items not covered by the spec, check `docs/optimizations.md` open design decisions
-
-For each gap, classify:
-- **spec-decided** — spec says what the behavior should be; one side is wrong
-- **convention-decided** — `optimizations.md` cross-language notes already aligned on this
-- **needs-decision** — neither spec nor optimizations.md covers this; flag for user
-
----
-
-## Phase 4: Cross-Repo Adversarial QA
-
-This is a **second QA pass** that catches issues the per-repo `/qa` missed — bugs that only surface when you read both implementations side by side.
-
-### 4a. Gather both diffs
-
-Run `git diff` in **both** repos. Also read any untracked files in the scoped area.
-
-### 4b. Launch parallel review subagents
-
-Each subagent receives the diffs from **both** repos plus the cross-language notes from `docs/optimizations.md`.
-
-**Subagent 1: Parity Semantic Hunter** — Has read access to both repos:
-> You are a Parity Semantic Hunter reviewing **two implementations** of the same reactive graph protocol (graphrefly-ts and graphrefly-py). Both repos just had independent `/dev-dispatch` + `/qa` runs. First, read `archive/optimizations/cross-language-notes.jsonl` and collect all entries with `id` prefix `divergence-` — these are **confirmed intentional divergences** that must NOT be raised as findings. Then review the diffs side by side for: message ordering mismatches between ports, settlement/batch timing differences, edge cases where one port handles a scenario the other doesn't, validation rules present in one but missing from the other, test coverage asymmetry (scenario tested on one side but not the other), naming or path convention drift. For each finding: **title** | **severity** (critical/major/minor) | **which repo** | **detail** | **suggested fix**.
-
-**Subagent 2: Spec Conformance Hunter** — Has read access to both repos + spec:
-> You are a Spec Conformance Hunter. Read `~/src/graphrefly/GRAPHREFLY-SPEC.md` and both diffs. First, read `archive/optimizations/cross-language-notes.jsonl` and collect all entries with `id` prefix `divergence-` — these are **confirmed intentional divergences** that must NOT be raised as findings. Check whether either implementation drifted from the spec during implementation: incorrect message ordering, wrong terminal behavior, batch semantics that don't match spec §2, node lifecycle violations, graph composition contracts (§3) not met, `describe`/`observe` output that doesn't match Appendix B. Also check design invariant violations (spec §5.8–5.12): polling patterns, imperative triggers bypassing graph topology, raw async primitives (Promises/microtasks in TS, asyncio.ensure_future/create_task in PY) for reactive scheduling, direct time API usage instead of central clock, hardcoded message type checks instead of messageTier/message_tier, and Phase 4+ APIs leaking protocol internals. Also check whether `docs/optimizations.md` cross-language decisions are actually implemented correctly on both sides. For each finding: **title** | **severity** | **spec section** | **which repo(s)** | **detail**.
-
-### 4c. Triage QA findings
-
-Classify each finding:
-- **patch** — fixable code issue; include which repo needs the fix
-- **defer** — pre-existing, not caused by this round of changes
-- **reject** — false positive
-
----
-
-## Phase 5: Present Findings (HALT)
-
-Present ALL findings from Phase 2–4 to the user, grouped:
-
-### Group 1: Parity Gaps — Auto-fixable
-For each: the gap, which repo needs the fix, the fix description, effort (S/M/L).
-
-### Group 2: QA Findings — Auto-fixable
-For each: the issue, which repo, the fix, effort (S/M/L).
-
-### Group 3: Needs Decision
-For each: the gap or issue, both behaviors, spec/convention silence, recommended resolution.
-
-### Group 4: Intentional Divergences (FYI)
-Language-specific differences correct on both sides (thread safety, `|` operator, etc.).
-
-**Wait for user approval before proceeding.**
-
----
-
-## Phase 6: Apply Fixes
-
-After user approves:
-
-1. Apply fixes to **this repo** (graphrefly-ts) — code + tests
-2. Run `pnpm test` — fix failures
-3. If fixes approved for the **sibling repo**, apply those too:
-   - Code + tests in `~/src/graphrefly-py/`
-   - Run `cd ~/src/graphrefly-py && uv run pytest` — fix failures
-4. Update `docs/optimizations.md` (this repo — single source of truth for both):
-   - Add new open decisions under "Active work items" (line-item state for any new `[py-parity-*]` carry).
-   - **Actively sweep:** scan for any fully-resolved items (all sub-tasks DONE, no remaining TODOs) and archive them to `archive/optimizations/resolved-decisions.jsonl` per `docs/docs-guidance.md` § "Optimization decision log". Remove archived content from `optimizations.md`.
-5. Update `docs/implementation-plan.md` (canonical sequencer):
-   - When a `[py-parity-*]` item lands or its scope shifts, mark it ✅ in the matching phase entry (or note "PY parity carry" within the relevant Phase 11–16 sub-section). When PY parity reopens post-1.0, the phase entry is where future agents pick up scope.
-   - If a parity pass closes the **last in-flight item from a Phase**, archive the phase body to `archive/roadmap/phase-<n>-*.jsonl` and replace with a 2–4-line summary + archive pointer per `docs/docs-guidance.md` § "Roadmap archive — Workflow for `docs/implementation-plan.md`". Single residual follow-ups move to `optimizations.md` with a back-link.
-   - Do NOT add new sequencing here during the parked window; just record state changes.
-6. `docs/roadmap.md` is **vision context only** per 2026-04-30 migration — do NOT track item-level state here. Wave-completion archival to `archive/roadmap/*.jsonl` (with a one-line pointer left behind) still applies per `docs/docs-guidance.md` § "Roadmap archive — Workflow for `docs/roadmap.md`" but rarely fires during /parity.
-
----
-
-## Phase 7: Final Checks
-
-Run all checks on both repos and fix any failures:
-
-**TypeScript:**
-```bash
-pnpm test && pnpm run lint:fix && pnpm run build
-```
-
-`pnpm run build` runs `assertBrowserSafeBundles` post-build. If it fails, a TS change leaked a Node builtin into a universal entry — fix per `docs/docs-guidance.md` § "Browser / Node / Universal split" before closing the parity pass.
-
-**Python:**
-```bash
-cd ~/src/graphrefly-py && uv run pytest && uv run ruff check --fix src/ tests/ && uv run mypy src/
-```
-
-Report results. If any failures relate to a design question, HALT.
diff --git a/.claude/skills/porting-to-rs/SKILL.md b/.claude/skills/porting-to-rs/SKILL.md
deleted file mode 100644
index ea481045..00000000
--- a/.claude/skills/porting-to-rs/SKILL.md
+++ /dev/null
@@ -1,326 +0,0 @@
----
-name: porting-to-rs
-description: "Port a slice of GraphReFly from TS to Rust (graphrefly-rs). Use when user says 'port to rust', 'porting-to-rs', or provides a task to add/extend functionality in the Rust workspace. Mirrors /dev-dispatch's plan→halt→implement→self-test loop, specialized for cross-repo Rust port work. Run /qa afterward for adversarial review."
-argument-hint: "[--light] [task description or context]"
----
-
-You are executing the **porting-to-rs** workflow — implementing or extending a slice of the **GraphReFly** Rust port (`graphrefly-rs`, `~/src/graphrefly-rs`) against the canonical TS spec living in `graphrefly-ts` (this repo).
-
-This skill is the Rust-port counterpart to `/dev-dispatch`. Same plan→halt→implement→self-test shape, but the canonical authority and invariants are different: the Rust port targets the **post-Phase 13.6.A consolidated canonical spec** (single document), not the multi-file TS spec + composition guides.
-
-The user's task/context is: $ARGUMENTS
-
-### Mode detection
-
-If `$ARGUMENTS` contains `--light`, this is **light mode** — skip Phase 2 HALT unless escalation triggers (see Phase 2 below). Otherwise, this is **full mode** with mandatory architecture discussion before implementation.
-
----
-
-## Phase 1: Context & Planning
-
-Load context and plan the implementation in a single pass. **Parallelize all reads.**
-
-### Canonical authorities (READ FIRST)
-
-These supersede / consolidate the multi-file TS authority for Rust port purposes:
-
-- **`docs/implementation-plan-13.6-canonical-spec.md`** — *single-document* canonical spec for the Rust port. Folds `~/src/graphrefly/GRAPHREFLY-SPEC.md` + all four `COMPOSITION-GUIDE-*.md` files into one read-once handoff. **This is THE behavior authority for the Rust impl.** Use the rule-ID convention (`R<section>.<sub>[.letter]`) for cross-references in commits, comments, test names. Sections of interest:
-  - §1 Message Protocol — tier table (R1.3.7.b), message variants, payload-handle discipline
-  - §2 Node — lifecycle (R2.2.7 resubscribable, R2.5.3 first-run gate, R2.6 PAUSE/RESUME, R2.6.4 TEARDOWN-precedes-COMPLETE)
-  - §3 Graph — container, mount/unmount, sugar
-  - §5 Design Principles (R5.1–R5.12)
-  - §6 Implementation Guidance — explicit TS / PY / Rust deltas
-  - §11 Implementation Deltas — known TS-vs-canonical-spec drift; the Rust port targets the canonical, NOT the current TS code
-- **`docs/implementation-plan-13.6-flowcharts.md`** — Mermaid diagrams visualizing every internal method, property, and process referenced by the canonical spec. Cross-referenced via rule IDs. Use when:
-  - A spec rule needs to be implemented and you need to see the call/data flow shape
-  - A red 🟥 node flags TS-vs-canonical drift (the Rust port should match canonical)
-  - A yellow 🟨 node flags not-yet-implemented features (out-of-scope for current slice unless explicitly part of $ARGUMENTS)
-  - **Especially Batch 7 — Rewire substrate** (Phase 13.8; experimental TS impl mirrored in `graphrefly-rs/crates/graphrefly-core/tests/setdeps.rs`)
-
-### Rust port operational docs (READ NEXT)
-
-- **`~/src/graphrefly-rs/docs/migration-status.md`** — **canonical milestone tracker** for the 6-milestone Rust port. Read FIRST to know:
-  - What landed (M1 dispatcher, M1 parity Slice A+B, etc.)
-  - What's blocked / in-progress
-  - The closing section format (each closed milestone gets a `## M<n> — closed YYYY-MM-DD` block summarizing what landed, what was deferred, and how it maps back to the migration plan)
-  - The "Carried forward" pointer to porting-deferred.md
-- **`~/src/graphrefly-rs/docs/porting-deferred.md`** — running registry of audit-surfaced concerns deferred to evidence-driven slices. Read to know:
-  - Which §10 perf simplifications are deliberately deferred (and why — Pass 5 bench evidence)
-  - v1 dispatcher limitations (re-entrance, sink-fire lock discipline, recursion stack overflow, etc.)
-  - Spec divergences acknowledged in v1 (e.g., pause-buffer overflow not synthesizing ERROR; alloc_lock_id collision risk)
-  - Open questions from `archive/docs/SESSION-rust-port-architecture.md` Part 6
-  - Audit fixes that landed (so we don't re-introduce them)
-
-### Cross-repo context (READ AS NEEDED)
-
-- **`archive/docs/SESSION-rust-port-architecture.md`** — the migration plan: 6-milestone phasing, layer-by-layer port recommendation, deferral guardrails. Read FIRST when picking up port work in a new area.
-- **`docs/research/handle_protocol.tla` + `handle_protocol_MC.tla`** — TLA+ refinement of `wave_protocol.tla` over the handle abstraction. The Rust port must satisfy the same invariants.
-- **`docs/research/handle-protocol-audit-input.md`** — per-rule classification (which 13.6 invariants are Core-internal vs binding-layer). Use as the layer-classification key during M1–M5.
-- **`packages/pure-ts/src/__experiments__/handle-core/core.ts` + `bindings.ts`** — TS prototype reference impl (~370 lines each, 22 invariant tests). The Rust port mirrors this module-for-module for the M1 dispatcher slice. (Post-Phase-13.9.A cleave: the pure-TS impl moved from root `src/` to `packages/pure-ts/src/`. The root `src/` is now the `@graphrefly/graphrefly` shim — re-exports only, no logic.)
-- **`packages/pure-ts/src/core/node.ts` + supporting files** — TS production dispatcher. Reference for parity behavior, NOT for code structure (the Rust port follows the canonical spec, not the current TS shape — see §11 Implementation Deltas).
-- **`packages/parity-tests/`** — cross-impl parity scenarios (Phase 13.9.A). When a Rust slice closes a milestone listed in `packages/parity-tests/README.md` schedule (M1 dispatcher, M2 Slice E Graph, M3 operators, M4 storage, M5 structures), the slice should ALSO add corresponding scenarios to `packages/parity-tests/scenarios/<layer>/<feature>.test.ts` parameterized via `describe.each(impls)`. The `rustImpl` arm currently exports `null` and activates when `@graphrefly/native` (the napi binding) publishes its package shape — until then, scenarios run against `pureTsImpl` only but the structural parameterization is in place.
-- **`docs/implementation-plan.md`** Phase 13.7 / 13.8 / 13.9 — Rust M1 bench feasibility study + TS rewire integration tests + the Phase 13.9.A cleave. Cross-reference for what bench data exists / what's been tested in TS / how the cleaved package architecture works.
-
-### Rust workspace layout
-
-```
-~/src/graphrefly-rs/
-├── crates/graphrefly-core/          # M1: dispatcher, message tiers, batch, wave engine
-├── crates/graphrefly-graph/         # M2: Graph container, snapshot, content addressing
-├── crates/graphrefly-operators/     # M3: built-in operator types
-├── crates/graphrefly-storage/       # M4: tier dispatch + Node-only persistence (redb)
-├── crates/graphrefly-structures/    # M5: reactiveMap/List/Log/Index (imbl)
-├── crates/graphrefly-bindings-js/   # M1+: napi-rs JS bindings
-├── crates/graphrefly-bindings-py/   # M6: pyo3 Python bindings
-└── crates/graphrefly-bindings-wasm/ # WASM target
-```
-
-`cargo build` / `cargo nextest run` (no `--workspace`) excludes the bindings crates by default — `default-members` skips them since they need their own toolchains (napi-rs, maturin, wasm-pack). **Use `cargo-nextest`, not legacy `cargo test`:** `cargo nextest run -p graphrefly-core` for the typical Rust-only inner loop (the `cascade_depth` stack-safety stress tests are quarantined from the default profile — see `graphrefly-rs/.config/nextest.toml`); `cargo nextest run --profile ci` (alias `cargo tc`) for the full merge-gating suite incl. those guards; `scripts/dev-test.sh` to run the default loop with a per-worktree-isolated target dir (parallel sessions never share the `target/` build lock). Legacy `cargo test` is fallback-only and ignores the nextest profiles + slow-timeout hang-kill. Loom is the one exception — it stays on `cargo test -p graphrefly-core --features loom-checked`.
-
-### Reads to perform in parallel
-
-- `~/src/graphrefly-ts/docs/implementation-plan-13.6-canonical-spec.md` (deep-read sections relevant to $ARGUMENTS)
-- `~/src/graphrefly-ts/docs/implementation-plan-13.6-flowcharts.md` (find the batch matching the slice)
-- `~/src/graphrefly-ts/docs/cross-track-ledger.md` (every time, no exceptions — **surface any unlanded native-side rows as candidates with `[NEEDS-LOCK]` markers for un-D-numbered items**; this is the auto-intake that prevents ledger rot, e.g. the memo:Re P0/P1/P2 rows from 2026-05-16 that sat ~5 days on the native side before the 2026-05-21 D266 batch caught up)
-- `~/src/graphrefly-rs/docs/migration-status.md` (every time, no exceptions)
-- `~/src/graphrefly-rs/docs/porting-deferred.md` (every time, no exceptions)
-- `~/src/graphrefly-rs/CLAUDE.md` (Rust-specific invariants)
-- Any files the user referenced in $ARGUMENTS
-- Existing Rust source for the area (`~/src/graphrefly-rs/crates/<crate>/src/`)
-- Existing Rust tests for the area (`~/src/graphrefly-rs/crates/<crate>/tests/`)
-- `~/src/graphrefly-ts/archive/docs/SESSION-rust-port-architecture.md` if entering a new milestone (M1→M2 transition, etc.)
-
-### Rust-specific invariants (validate proposed changes against these)
-
-These come from `~/src/graphrefly-rs/CLAUDE.md` and are non-negotiable:
-
-1. **No `unsafe`. Anywhere. Enforced by `#![forbid(unsafe_code)]` at every crate root.** If a feature seems to need unsafe, find a safe abstraction (parking_lot, dashmap, imbl, redb, napi-rs / pyo3 wrappers). Escalate before allowing the lint.
-2. **Compiler-enforced thread safety.** `Send` + `Sync` discipline applies to every public type. No `Rc<T>` / `RefCell<T>` in shared state — use `Arc<T>` + `Mutex<T>` / `parking_lot::ReentrantMutex<T>`.
-3. **Per-subgraph `parking_lot::ReentrantMutex`** (planned; mirrors graphrefly-py per-subgraph RLock parity goal).
-4. **No async runtime in Core.** Core dispatcher is sync. `tokio` only enters in `graphrefly-storage` and bindings; never in `graphrefly-core`.
-5. **No `unwrap()` / `expect()` on user-facing paths.** Domain errors via `thiserror`-derived enums. `unwrap` only in tests, build scripts, or impossible-by-construction paths (with comment).
-6. **`#[must_use]` on every public fn that returns a value.**
-7. **`clippy::pedantic` + `rust_2018_idioms` warn-by-default.** Allow on a per-need basis with a comment, never silently.
-8. **Public types live behind newtype wrappers** (`NodeId(u64)`, `HandleId(u64)`, etc.). Don't expose raw integers — they collide structurally.
-9. **Snapshot serialization uses `serde_ipld_dagcbor`** for content-addressed paths, `ciborium` for non-content-addressed snapshots. Never mix codec choice with content-addressing semantics.
-
-### Cross-language invariants (also apply to Rust port)
-
-- **Handle-protocol cleaving plane.** Core operates on opaque `HandleId` integers. User values `T` live in the binding-side registry; they never enter Core types. The `BindingBoundary` trait is the only mandatory FFI crossing per fn-fire.
-- **No polling.** Use reactive timer sources, not `std::thread::sleep` loops or `tokio::interval` busy-checks against state.
-- **No imperative triggers in public API.** All coordination via message flow. Imperative methods only on the L2.35 controller-with-audit primitives.
-- **First-run gate** (R2.5.3) — compute node does NOT fire fn until every dep has delivered at least one real handle.
-- **Equals-substitution under `equals: 'identity'` is zero-FFI** — `HandleId` u64 compare in pure Rust. Custom equals crosses the binding boundary; opt-in only.
-- **DIRTY before DATA/RESOLVED** (R1.3.1.b two-phase push) in the same wave.
-- **Tier ordering** (R1.3.7.b) — Tier 0 START, Tier 1 DIRTY, Tier 2 PAUSE/RESUME, Tier 3 DATA/RESOLVED, Tier 4 INVALIDATE, Tier 5 COMPLETE/ERROR, Tier 6 TEARDOWN. Tier 3+4 buffer under PAUSE; others bypass.
-- **§10 simplifications** (from `archive/docs/SESSION-rust-port-architecture.md` Part 10) — apply where they fit the slice; do NOT blindly transliterate TS patterns. Defer perf-tier §10 items (10.3 / 10.4 / 10.5 / 10.6 / 10.13) until bench evidence justifies; record deferrals in `porting-deferred.md`.
-
-### When to compare against TS for parity vs spec
-
-- **Behavior parity:** the Rust port must satisfy the same invariants as the canonical spec. The TS production code is a **reference for behavior**, not a structural template. When TS code disagrees with the canonical spec, **the canonical spec wins** (see §11 Implementation Deltas — explicit list of TS-vs-canonical drift).
-- **Test parity:** when porting a feature with TS tests, mirror the test scenarios in Rust. Each test should reference the canonical spec rule it covers (e.g., a comment or test name like `r2_6_4_teardown_auto_precedes_complete`).
-- **Bench parity:** if the slice claims a perf win, validate via criterion bench. Pre-existing `dispatcher.rs` bench shapes are the canonical comparison harness.
-
-Do NOT start implementing yet.
-
----
-
-## Phase 2: Architecture Discussion
-
-### Full mode — HALT
-
-**HALT and report to the user before implementing.** Present:
-
-1. **Current state confirmation** — what's already in `graphrefly-rs` for this area (cite migration-status.md milestone status; cite specific files / line ranges; verify `cargo nextest run -p <crate>` is clean before changes).
-2. **Slice scope** — what the slice will and will NOT include. Slices should be:
-   - Coherent (single feature or audit-fix bucket)
-   - Reasonably small (~500–2000 lines including tests for a typical M1-style slice)
-   - Tied to a milestone via the `migration-status.md` table
-   - Aligned with §10 simplifications where applicable (call out which ones apply, which defer)
-3. **Architecture choices** — for each new public API: signature, error variants, lock discipline, refcount discipline, handle-protocol boundary semantics. Cite canonical spec rules (`R<x.y.z>`) for behavior decisions.
-4. **Open questions** — surface any spec ↔ canonical-spec ↔ TS-drift conflicts BEFORE coding. Per the user-feedback memory: "no autonomous decisions — surface spec↔code conflicts instead of silently picking."
-5. **Acceptance bar** — what needs to be green before the slice closes:
-   - All existing tests still pass
-   - New tests cover the canonical-spec rules touched
-   - `cargo clippy -p <crate> --all-targets` clean
-   - `cargo fmt --check` clean
-   - `#![forbid(unsafe_code)]` preserved
-   - `migration-status.md` updated
-   - New limitations / divergences added to `porting-deferred.md`
-
-Prioritize (in order):
-1. **Spec alignment** — matches `docs/implementation-plan-13.6-canonical-spec.md` (canonical post-13.6.A). Where canonical disagrees with current TS impl, follow canonical.
-2. **Refcount + lock discipline** — Rust impl must NOT introduce refcount leaks or lock-ordering bugs. The §10.2 PauseState pattern (retain on buffer-push, release on drain/overflow) is the canonical example.
-3. **Test coverage** — every public API surface gets a test. Edge cases (terminal interactions, pause cross-cuts, set_deps validation) get explicit tests.
-4. **Consistency** — patterns elsewhere in `graphrefly-core` (RAII Subscription via `Weak<Mutex<CoreState>>`, `parking_lot::Mutex`, single state lock).
-5. **Simplicity** — don't pre-optimize. v1 single-mutex is fine; perf-tier §10 simplifications wait for bench evidence.
-
-Do NOT consider backward compatibility at this early stage (pre-1.0).
-
-**Cross-repo decision log:** If Phase 1–2 surface an architectural or product-level question (canonical-spec ambiguity, parity divergence, refcount discipline gap), record it under "Active work items" in `docs/optimizations.md` (the graphrefly-ts source of truth for cross-language decisions). Rust-specific deferrals go in `~/src/graphrefly-rs/docs/porting-deferred.md`. Mark cross-references both ways.
-
-**Decision logging:** For each question you ask during HALT, after the user answers, append the decision to `docs/rust-port-decisions.md` using the format:
-
-```markdown
-### DXXX — [short title]
-- **Date:** YYYY-MM-DD
-- **Context:** [what prompted the question]
-- **Options:** A) … B) … C) …
-- **Decision:** [what user chose]
-- **Rationale:** [why]
-- **Affects:** [which modules/milestones]
-```
-
-**Wait for user approval before proceeding.**
-
-### Light mode — Skip unless escalation needed
-
-Proceed directly to Phase 3 **unless** Phase 1 reveals any of these:
-- Changes to **message protocol** (new tier, new variant, payload semantics)
-- Changes to **`BindingBoundary` trait** (new method, signature change)
-- Changes to wave engine, batch coalescing, or dispatch order
-- New public types in `graphrefly-core` (especially RAII handles, error enums)
-- Multiple viable approaches with non-obvious trade-offs
-- Drift between canonical spec and current `graphrefly-rs` impl that needs an explicit reconciliation call
-- Touching anything flagged in `porting-deferred.md` as a deferred concern
-
-If any apply, escalate: HALT and present findings as in full mode.
-
----
-
-## Phase 3: Implementation & Self-Test
-
-After user approves (full mode) or after Phase 1 (light mode, no escalation):
-
-### 3a. Implement
-
-1. Treat `docs/implementation-plan-13.6-canonical-spec.md` as non-negotiable for behavior. If existing Rust code drifts from canonical, align toward canonical as part of the change.
-2. Cross-reference rule IDs in code comments where the design is non-obvious (e.g., `// R2.6.4 / Lock 6.F: TEARDOWN auto-precedes COMPLETE`).
-3. Apply §10 simplifications where they fit the slice; defer perf-tier ones with a note in `porting-deferred.md`.
-4. Maintain the handle-protocol cleaving plane: Core sees `HandleId`, never `T`. If a temptation arises to leak `T` into Core (e.g., for debugging), use a `BindingBoundary::deref_for_debug` shape instead.
-5. Refcount discipline:
-   - Every `retain_handle` paired with a `release_handle`.
-   - When buffering a handle (PauseState, terminal slot, dep_terminals slot), retain on store, release on remove.
-   - Cross the boundary OUTSIDE the state lock when feasible (mirrors `Core::resume` Phase 2 pattern), to avoid binding-vs-Core lock ordering issues.
-
-### 3b. Tests
-
-1. Put tests in the most specific existing file under `~/src/graphrefly-rs/crates/<crate>/tests/`. Common patterns:
-   - One file per feature: `pause.rs`, `invalidate.rs`, `terminal.rs`, etc.
-   - Use the shared `tests/common/mod.rs` `TestRuntime` + `TestBinding` + `Recorder` infrastructure.
-   - Use `RecordedEvent::*` for high-level message assertions (resolves handles to values automatically).
-2. Cover the edge cases the canonical spec calls out — e.g., R1.4 idempotency-within-wave for INVALIDATE; R2.6.4 idempotency on duplicate TEARDOWN.
-3. For refcount-touching changes, use `TestBinding::refcount_of(handle)` to verify retain/release pairs balance (don't rely on `live_handles()` alone — handles stay alive when ANY share remains).
-4. Test names should reference the canonical rule when covering a specific invariant (e.g., `dynamic_rewire_refires_fn_on_new_deps` covers a Phase 13.8 audit fix; `r1_4_invalidate_idempotent_within_wave` covers a spec rule).
-
-### 3c. Self-check
-
-Run from `~/src/graphrefly-rs`:
-
-```bash
-cargo nextest run --profile ci -p graphrefly-core   # core tests, incl. cascade_depth guards
-cargo nextest run --profile ci                      # default-members, full suite (== `cargo tc`)
-cargo clippy -p graphrefly-core --all-targets
-cargo fmt --check                        # or `cargo fmt && cargo fmt --check`
-```
-
-When the slice touches bindings:
-```bash
-cd crates/graphrefly-bindings-js && pnpm build      # napi-rs build
-cd crates/graphrefly-bindings-py && maturin develop # pyo3 build
-cd crates/graphrefly-bindings-wasm && wasm-pack build
-```
-
-Fix any failures. **Do NOT use `--workspace`** for `cargo build` / `cargo nextest run` unless you have all binding toolchains installed — the workspace excludes bindings from default-members for this reason. (Self-check uses `--profile ci` to run the full suite incl. the `cascade_depth` stack-safety guards before closing a slice; the quarantined default profile is for the inner loop only.)
-
-> **Run the self-check via the sanctioned long-runner, synchronously.** Use `mise run gate` / `mise run gate:core` (or `mise run run-logged -- <cmd>`) and **wait foreground for the `<<<RUN-LOGGED:DONE>>>` sentinel** — never background cargo and monitor a non-guaranteed string. **Subagent hygiene:** if this skill runs in a spawned subagent, it MUST run verification synchronously or tear down any backgrounded command (kill by process group) **before returning** — a live background process leaks as a stale parent-session "running" entry indistinguishable from a real hang. See `~/src/graphrefly-ts/docs/test-guidance.md` § "Running long commands reliably / diagnosing a stuck run" and memories `feedback_long_command_observation.md` / `feedback_subagent_bg_hygiene.md`.
-
-### 3d. Widen the parity-test surface (when slice closes a milestone or adds public API)
-
-If the slice closes (or partially fills) a milestone row in the `packages/parity-tests/README.md` schedule table, add cross-impl scenarios under `~/src/graphrefly-ts/packages/parity-tests/scenarios/<layer>/`:
-
-1. Pick the layer subfolder (`scenarios/core/` for M1 dispatcher, `scenarios/graph/` for M2 Slice E, `scenarios/operators/` for M3, etc. — create the folder if needed).
-2. Write the scenario as `describe.each(impls)("<rule-id> parity — $name", (impl) => { test(...); })`. Reference symbols only via `impl.<name>`, not direct imports — that's what makes the scenario impl-agnostic.
-3. If the scenario references new symbols not yet in `packages/parity-tests/impls/types.ts` `Impl`, widen the interface (and provide the field on `pureTsImpl` in `impls/pure-ts.ts`). Until `@graphrefly/native` publishes, `rustImpl` is `null` and scenarios only run against `pureTsImpl` — but the parameterization stays in place so activation only requires a one-line `rust.ts` flip.
-4. Test: `pnpm --filter @graphrefly/parity-tests test`. Scenario must pass against `pureTsImpl`. When `rustImpl` activates later, mismatches fail loud.
-
-**Skip this step** if the slice is an internal refactor that doesn't change public surface (e.g., a §10 perf simplification under an unchanged API). The parity-tests layer is for surface-visible behavior, not internals.
-
-### 3e. Document the slice
-
-Update both Rust-side operational docs as the work lands:
-
-1. **`~/src/graphrefly-rs/docs/migration-status.md`** — the canonical milestone tracker:
-   - When a sub-bucket lands: mark it ✅ in the M-table or the entry checklist.
-   - When a milestone closes: update the M-table row to ✅, add a `## M<n> — closed YYYY-MM-DD` section documenting what landed, what was deferred, what was carried forward.
-   - Update the test count (per-file breakdown helps future readers).
-   - Cross-reference any cargo-tagged release: `git tag -a vM<n>.0.0 -m "M<n> complete"` + bump `[workspace.package].version`.
-
-2. **`~/src/graphrefly-rs/docs/porting-deferred.md`** — the running registry of deferred concerns:
-   - When the slice surfaces a new perf concern that you DON'T fix: add a section with what / why-deferred / source.
-   - When the slice surfaces a v1 dispatcher limitation: add to "v1 dispatcher limitations".
-   - When the slice acknowledges a TS-spec divergence: add to "Spec divergences acknowledged in v1".
-   - When the slice CLOSES a previously-deferred concern: move that entry's content to "Audit fixes landed in Slice X" (or the milestone's closing section in `migration-status.md`) and remove from the active deferred list.
-
-3. **TS-side `docs/implementation-plan.md`** — only when a TS-side phase entry is affected (e.g., a Phase 13.7 / 13.8 sub-item closing). The Rust port does NOT add Phase 11–16 sub-bullets; the migration-status.md is the canonical Rust tracker.
-
-4. **TS-side `docs/optimizations.md`** — only when the slice surfaces a cross-language design question that needs to be tracked alongside TS / PY work. Rust-only deferrals go in `porting-deferred.md`, not `optimizations.md`.
-
-### 3f. Closing the slice
-
-When done, produce these deliverables:
-
-**A. Behavioral trace table** — for each new/changed module, show a plain-English table:
-
-```
-Module: [name] (milestone)
-Scenario: [description of the most representative scenario]
-
-Step | Event              | Internal state change        | Observable output
-1    | ...                | ...                          | ...
-```
-
-The user verifies this against the spec without reading Rust. If the trace is correct AND parity tests pass, the impl is correct.
-
-**B. Simplification delta** — table showing what the Rust version does differently from TS:
-
-| TS pattern | Rust replacement | Why simpler / Why different |
-|---|---|---|
-
-Flag any entry where Rust is MORE complex than TS — that's a potential over-engineering signal.
-
-**C. Deferred item stubs** — for each new deferred item, confirm a `#[ignore]` test exists in the Rust source:
-
-```rust
-#[test]
-#[ignore = "deferred: <description> (<spec ref>)"]
-fn <test_name>() { /* impl when feature lands */ }
-```
-
-**D. Standard closing checklist:**
-
-1. List files changed and new public types / methods added.
-2. Cite the migration-status.md row this slice closes (or moves toward closing).
-3. Cite the canonical-spec rules covered.
-4. Cite any new entries in porting-deferred.md.
-5. Suggest running `/qa` for adversarial review and final checks.
-
-If implementation **closes a milestone** in `migration-status.md`:
-1. Move the milestone's row from "🚧 in progress" to "✅ landed".
-2. Add the closing section per the existing template (see M1 dispatcher / M1 parity sections for the canonical format).
-3. Sweep `porting-deferred.md` for items resolved by this milestone — move them to the closing section.
-
-If implementation **closes a Rust-side milestone-pre-condition** in `docs/implementation-plan.md` (Phase 13.7 / 13.8 / similar): mark ✅ in the matching TS-side phase entry per `docs/docs-guidance.md` § "Roadmap archive — Workflow for `docs/implementation-plan.md`".
-
----
-
-## Quick reference: typical slice flow
-
-1. Read canonical spec section + flowchart batch covering the feature
-2. Read migration-status.md to know the milestone context + what's landed
-3. Read porting-deferred.md to know what NOT to re-introduce
-4. (Full mode) Halt with architecture proposal citing R<x.y.z> rules
-5. (User approval) Implement + tests + clippy + fmt
-6. **If the slice closes a milestone or adds public API:** widen `~/src/graphrefly-ts/packages/parity-tests/scenarios/<layer>/` with new `describe.each(impls)` scenarios; verify `pnpm --filter @graphrefly/parity-tests test` green
-7. Update migration-status.md + porting-deferred.md
-8. Suggest `/qa`
diff --git a/.claude/skills/qa/SKILL.md b/.claude/skills/qa/SKILL.md
index a177d91a..b5c40454 100644
--- a/.claude/skills/qa/SKILL.md
+++ b/.claude/skills/qa/SKILL.md
@@ -4,201 +4,107 @@ description: "Adversarial code review, apply fixes, final checks (test/lint/buil
 argument-hint: "[--skip-docs] [optional context about what was implemented]"
 ---
 
-You are executing the **qa** workflow for **GraphReFly** (cross-language: TypeScript + Python + Rust port).
+You are executing the **qa** workflow for the **clean-slate GraphReFly** redesign.
 
-Operational docs live in **graphrefly-ts** (this repo). The diff may include changes in `graphrefly-ts`, `graphrefly-py` (`~/src/graphrefly-py`), or **`graphrefly-rs`** (`~/src/graphrefly-rs` — the Rust port).
+This repo is **`@graphrefly/ts`** — the self-contained TypeScript implementation (D32); clean-slate code lives in **`packages/ts/src/`**. Siblings (each self-contained, cross-language = wire bridge, never in-process): `@graphrefly/rust` (`~/src/graphrefly-rs`), `@graphrefly/py` (`~/src/graphrefly-py`). The language-neutral authority (spec / decisions / plan / conformance / formal) lives in **`~/src/graphrefly`** (branch `clean-slate`) as jsonl — when this skill and that repo disagree, that repo wins (CLAUDE.md).
 
-### Repo detection
-
-Inspect the diff to detect which repo(s) are touched. If the diff includes paths under `~/src/graphrefly-rs/` (or the working directory IS `~/src/graphrefly-rs`), this is a **Rust-port QA pass** — see "Rust-port QA additions" callouts inline below for the doc reads, subagent prompt extensions, final-check commands, and Phase 4 doc updates that apply.
+> **Stale-infra guard.** Do NOT reach for the retired port-model surfaces: `packages/pure-ts/**` (frozen read-only reference only, D41), `docs/implementation-plan.md` / `implementation-plan-13.6-*.md` / `optimizations.md` / `roadmap.md` / `test-guidance.md` / `docs-guidance.md`, `GRAPHREFLY-SPEC.md` / `COMPOSITION-GUIDE.md` (migrated to `spec/rules.jsonl` + `guide/guide.jsonl`, B7), the `@graphrefly/graphrefly` shim + its 4-file subpath rule, the `Impl`/facade/actor model, the Rust `migration-status.md` / `porting-deferred.md` / canonical-spec-13.6 registries. The clean-slate authority is the `~/src/graphrefly` jsonl.
 
 Context from user: $ARGUMENTS
 
 ### Flag detection
-
 If `$ARGUMENTS` contains `--skip-docs`, skip Phase 4 (Documentation Updates).
 
+### Repo detection
+Inspect the diff to detect which package(s) are touched: `packages/ts/` (this repo), `~/src/graphrefly-py`, `~/src/graphrefly-rs`. The cross-language contract is **behavioral conformance (D24)**, not symbol parity — review each arm against the SAME `spec/rules.jsonl` + `spec/conformance.jsonl`, per-language idioms aside.
+
 ---
 
 ## Phase 1: Adversarial Code Review
 
 ### 1a. Gather the diff
 
-Run `git diff` to get all uncommitted changes. If there are also untracked files relevant to the task, read and include them.
-
-**Rust-port QA additions** — if the diff is in `~/src/graphrefly-rs/`, ALSO read these as part of the context-load (they are the canonical authority + active deferred-concerns registry for the Rust port; QA must NOT contradict them, and SHOULD update them when the slice closes a deferred item):
+Run `git diff` for uncommitted changes; if the chat's work was already committed, diff against the chat's baseline commit (`git log --oneline` to find it, then `git diff <base>..HEAD`). Include relevant untracked files (read them). Concentrate the review on the **substantive hand-written code** — formally-verified TLA+ (already TLC-checked), generated artifacts, and jsonl data are lower bug-risk than imperative substrate/graph code.
 
-- **`docs/implementation-plan-13.6-canonical-spec.md`** (graphrefly-ts) — single-document canonical spec post-Phase 13.6.A. The Rust port's behavior authority. Use rule IDs (`R<x.y.z>`) to cite spec rules in findings.
-- **`docs/implementation-plan-13.6-flowcharts.md`** (graphrefly-ts) — Mermaid diagrams for all internal methods/processes. Cross-reference for call/data-flow shape during edge-case review.
-- **`~/src/graphrefly-rs/docs/migration-status.md`** — milestone tracker. Read to know which slice this QA pass covers, what's claimed-as-landed, and what test counts to verify.
-- **`~/src/graphrefly-rs/docs/porting-deferred.md`** — registry of audit-surfaced concerns deferred to evidence-driven slices. **DO NOT raise findings that match an existing deferred entry** — those are already-acknowledged divergences/limitations. DO raise findings that contradict a deferred entry's stated scope (e.g., a "deferred for now" item that the slice actually starts touching but didn't update).
+Also load the clean-slate context the review must NOT contradict:
+- `~/src/graphrefly/spec/rules.jsonl` — the protocol 宪法 (R-* rules); the behavior authority. Cite R-ids in findings.
+- `~/src/graphrefly/decisions/decisions.jsonl` — the governing D# (or `/decision-guard`); the F-* floor + durable values.
+- `~/src/graphrefly/plan/backlog.jsonl` + `plan/antipatterns.jsonl` — **already-acknowledged deferred concerns (B#) and known anti-patterns. DO NOT raise a finding that matches an existing deferred B# or antipattern** — those are accepted. DO raise a finding that *contradicts* a deferred entry's stated scope.
+- `~/src/graphrefly/spec/conformance.jsonl` — the C-* scenarios the change must keep green (+ their `runtimes` status).
+- `~/src/graphrefly/formal/*.tla` — when the change implements a formally-modeled rule, cross-check the impl against the TLC-verified model.
 
 ### 1b. Launch parallel review subagents
 
-Launch these as parallel Agent calls. Each receives the diff and the context from $ARGUMENTS (what was implemented and why).
+Launch as parallel Agent calls. Each receives the diff + the context from $ARGUMENTS (what was implemented and why). Tell each to do a STATIC review (no servers, no test runs) and return ONLY a findings list.
 
-**Subagent 1: Blind Hunter** — Pure code review, no project context:
-> You are a Blind Hunter code reviewer. Review this diff for: logic errors, off-by-one errors, race conditions, resource leaks, missing error handling, security issues, dead code, unreachable branches. For Python code, also check thread safety (including free-threaded Python without GIL). Output each finding as: **title** | **severity** (critical/major/minor) | **location** (file:line) | **detail**. Be adversarial — assume bugs exist.
+**Subagent 1: Blind Hunter** — pure code review, no project context:
+> You are a Blind Hunter code reviewer. Review this diff for: logic errors, off-by-one, race/re-entrancy hazards, resource leaks (unclosed subscriptions, unbounded registries), stale-closure / index-desync bugs, missing error handling, dead/unreachable code, sparse-array holes, security issues. For Python, also check thread/free-threaded safety. Be adversarial — assume bugs exist; trace the suspicious paths concretely. If a suspicious path is actually correct, say so in one line rather than raising noise. Output each finding as: **title** | **severity** (critical/major/minor) | **location** (file:line) | **detail** (trigger + consequence + suggested fix).
 
-**Subagent 2: Edge Case Hunter** — Has project read access:
-> You are an Edge Case Hunter. Review this diff in the context of **GraphReFly** (`~/src/graphrefly/GRAPHREFLY-SPEC.md`). First, read `archive/optimizations/cross-language-notes.jsonl` and collect all entries with `id` prefix `divergence-` — these are **confirmed intentional cross-language divergences** that must NOT be raised as findings.
+**Subagent 2: Edge Case Hunter** — clean-slate spec-aware:
+> You are an Edge Case Hunter reviewing a change against the GraphReFly clean-slate SPEC. The authority is `~/src/graphrefly` jsonl (branch clean-slate) — NOT any docs/*.md or packages/pure-ts (retired port-model; ignore). Read the relevant `spec/rules.jsonl` R-* rules + `decisions/decisions.jsonl` D# for the area under review, and the matching `spec/conformance.jsonl` C-* + `formal/*.tla` model if the change implements a spec-locked behavior.
 >
-> **Post-Phase-13.9.A repo layout (read once before reviewing TS diffs):** the pure-TS implementation lives at `packages/pure-ts/src/` (NOT `src/`). Root `src/` is the `@graphrefly/graphrefly` shim — every file there is a one-liner `export * from "@graphrefly/pure-ts/<subpath>"`. If a TS diff touches root `src/`, that's almost always a public-API surface widening (a new subpath was added) and the review should verify 4-file consistency: (1) the actual source under `packages/pure-ts/src/<new>/`, (2) `packages/pure-ts/tsup.config.ts` `ENTRY_POINTS` (+ `nodeOnlyEntries` if Node-only), (3) `packages/pure-ts/package.json` `exports`, (4) the matching one-liner shim source at root `src/<new>/` plus its registration in root `tsup.config.ts` `ENTRY_POINTS` and root `package.json` `exports`. If the diff also affects cross-impl behavior, the review should also confirm a corresponding parity scenario landed in `packages/parity-tests/scenarios/<layer>/`.
+> Check protocol/wave invariants against the rules: message tuples `[[Type,Data?]]`, one array = one wave (R-msg-format); DIRTY-before-DATA in the same wave (R-dirty-before-data); two-phase glitch-free diamond, recompute-once (R-two-phase/R-diamond); ctx.up control-tier-only (R-ctx-up); SENTINEL = absence-of-DATA, never-emitted detector `prevData===undefined` (R-sentinel); equals DATA→RESOLVED only on a single-DATA wave (R-equals); first-run gate (R-first-run-gate); INVALIDATE idempotent + lifecycle-continue (R-invalidate-idempotent); terminal-is-forever / resubscribable reset (R-terminal); ROM/RAM cache (R-rom-ram); PAUSE lockset + modes (R-pause-lockset/R-pause-modes); reentrancy reject (R-reentrancy/D37).
 >
-> Then check: unhandled message sequences (DIRTY without follow-up, DATA vs RESOLVED), diamond resolution (recompute once), COMPLETE/ERROR terminal rules, forward-unknown-types, batch semantics (DATA deferred, DIRTY not), reconnect/teardown leaks, meta companion nodes, and graph mount/signal propagation when `Graph` is in scope. Also flag violations of design invariants (spec §5.8–5.12): polling patterns (busy-wait or setInterval/time.sleep loops on node values), imperative triggers bypassing graph topology, bare Promises/queueMicrotask/setTimeout (TS) or asyncio.ensure_future/create_task/threading.Timer (PY) for reactive scheduling, direct Date.now()/performance.now() (TS) or time.time_ns()/time.monotonic_ns() (PY) usage (must use `core/clock.ts` or `core/clock.py` — for TS, that's now `packages/pure-ts/src/core/clock.ts`), hardcoded message type checks instead of messageTier/message_tier utilities, and Phase 4+ APIs that leak protocol internals (DIRTY/RESOLVED/bitmask) into their primary surface. **If the change touches `packages/pure-ts/src/patterns/` or `packages/pure-ts/src/compat/`, verify the implementation against COMPOSITION-GUIDE.md categories (§1 lazy activation, §2 subscription ordering, §3 null guards, §5 wiring order, §7 feedback cycles, §8 SENTINEL gate).** **Browser / Node / Universal tier (TS):** if the change adds or moves code in `packages/pure-ts/src/extra/` or `packages/pure-ts/src/patterns/`, confirm (a) any new `node:*` import or `require("<builtin>")` / `fileStorage` / `sqliteStorage` / `child_process` / filesystem API lives in a `<x>/node` subpath source file, not on a universal path; (b) any new DOM global (`window`, `document`, `indexedDB`, `Worker`, `MessagePort` constructor calls) lives in a `<x>/browser` subpath; (c) new subpaths are registered in both `packages/pure-ts/tsup.config.ts` `ENTRY_POINTS` (+ `nodeOnlyEntries` when node-only) and `packages/pure-ts/package.json` `exports`, AND mirrored in the root shim's `tsup.config.ts` + `package.json` `exports` + a one-liner shim source at root `src/<x>/<sub>.ts`; (d) JSDoc `@example` blocks import from the correct subpath via the public `@graphrefly/graphrefly/...` name (NOT `@graphrefly/pure-ts` directly) — a Node-only adapter must not suggest the universal barrel in its example. The `assertBrowserSafeBundles` guardrail lives in `packages/pure-ts/tsup.config.ts` (NOT in the root shim's tsup, which has no source-level imports to police). See `docs/docs-guidance.md` § "Browser / Node / Universal split" for the convention. **If the diff is in `~/src/graphrefly-rs/` (Rust port):** review against the *single-document canonical spec* at `~/src/graphrefly-ts/docs/implementation-plan-13.6-canonical-spec.md` (NOT the older multi-file TS spec — they diverge per §11 Implementation Deltas). Cross-reference rule IDs (`R<x.y.z>`) in findings. Cross-reference call/data-flow shape via `~/src/graphrefly-ts/docs/implementation-plan-13.6-flowcharts.md`. Read `~/src/graphrefly-rs/docs/porting-deferred.md` and DROP findings that match an already-acknowledged deferred entry (perf-tier §10 simplifications, v1 dispatcher limitations, spec divergences acknowledged in v1, Phase 13.8 carry-forwards). For Rust slices that close milestones in the `packages/parity-tests/README.md` schedule (M1 dispatcher, M2 Slice E Graph, M3 operators, M4 storage, M5 structures), also flag whether `packages/parity-tests/scenarios/<layer>/` was widened with corresponding `describe.each(impls)` scenarios — surface coverage of the new milestone is part of the parity-gate definition. Also flag Rust-specific invariants: `unsafe` usage (forbidden — `#![forbid(unsafe_code)]`); `unwrap()` / `expect()` on user-facing paths (only allowed in tests/build scripts/impossible-by-construction with comment); missing `#[must_use]` on public-fn returns; raw integer types where newtypes (`NodeId(u64)`, `HandleId(u64)`, `FnId(u64)`, `LockId(u64)`) should be used; refcount imbalance via `BindingBoundary::retain_handle` / `release_handle` pairs; lock-discipline asymmetry across the `parking_lot::Mutex<CoreState>` boundary (sink-fire-with-lock-held vs lock-released); `Send + Sync` violations on public types; async runtime introduction in `graphrefly-core` (forbidden — Core stays sync). For each finding: **title** | **trigger_condition** | **potential_consequence** | **location** | **suggested_guard**.
-
-### 1c. Triage findings
-
-Classify each finding into:
-- **patch** — fixable code issue. Include the fix recommendation.
-- **defer** — pre-existing issue, not caused by this change.
-- **reject** — false positive or noise. Drop silently.
+> Flag floor violations: imperative side-channel triggers (R-no-imperative — emitters/callbacks/timers+set instead of ctx.up/message flow); polling/busy-wait (R-no-polling); bare async in the sync core (R-no-raw-async / F-SYNC-CORE — async only in sources / pool / wire bridge); inline-fn bypassing the dispatcher (R-dispatch-all / F-DISPATCH-ALL); peeking a dep `.cache` to seed compute (R-data-not-peek); hardcoded `type === "DATA"` instead of messageTier (R-tier); protocol internals (DIRTY/RESOLVED/bitmask) leaking into value-level sugar (R-primary-api-clean / DR-1); counters/inspection on the thin node (R-node-thin); a new verb (D4 closed set) or a 10th tier (D9) introduced casually; graph-level shared mutable state accessed implicitly instead of an explicit node+dep (D22/D23); cross-graph in-process coupling instead of a wire bridge (D22/D32).
+>
+> If the change implements a formally-modeled rule, identify any place the impl DIVERGES from the `formal/*.tla` model (cite the invariant). Surface real-but-unmodeled cross-axis interactions (e.g. X×batch, X×pause) and say whether each is a genuine gap or acceptably-deferred. DROP any finding that matches an already-acknowledged `plan/backlog.jsonl` B# or `plan/antipatterns.jsonl` entry. Output each finding as: **title** | **severity** | **location** (file:line or R-id) | **detail** (the rule/D# it relates to + what the impl does + divergence/gap/ok).
 
-For each **patch** and **defer** finding, evaluate fix priority (most to least important):
-1. **Spec alignment** — matches `~/src/graphrefly/GRAPHREFLY-SPEC.md` (or `docs/implementation-plan-13.6-canonical-spec.md` for Rust-port diffs — the canonical post-Phase 13.6.A consolidated spec)
-2. **Semantic correctness** — protocol and node contract
-3. **Completeness** — edge cases covered
-4. **Consistency** — patterns elsewhere in graphrefly-ts (or graphrefly-rs for Rust-port diffs)
-5. **Level of effort**
+Scale the reviewer count to the change: 2 is the default; for a large or high-risk substrate change add a third reviewer on a specific axis (e.g. concurrency/pool, or a perspective-diverse second spec reviewer).
 
-**Optional:** Compare tricky operator behavior with **callbag-recharge** at `~/src/callbag-recharge` for precedent — GraphReFly still wins on spec conflicts.
+### 1c. Triage findings
+Classify each: **patch** (fixable, caused by this change — include the fix) · **defer** (pre-existing or out-of-scope — note it) · **reject** (false positive / noise — drop silently). Cross-check every finding against `plan/backlog.jsonl` + `plan/antipatterns.jsonl`; a match to an accepted deferral → **reject** silently.
 
-**Rust-port QA additions** — when triaging findings on `~/src/graphrefly-rs/` diffs:
-- Cross-check every finding against `~/src/graphrefly-rs/docs/porting-deferred.md`. Findings that match an already-acknowledged deferred entry (perf-tier §10, v1 dispatcher limitation, spec divergence acknowledged in v1, Phase 13.8 carry-forward) → **reject** silently.
-- Findings that contradict the canonical spec at `~/src/graphrefly-ts/docs/implementation-plan-13.6-canonical-spec.md` → **patch** (high priority — canonical wins over current TS impl per §11 Implementation Deltas).
-- Findings about TS-vs-Rust behavior gaps → check whether TS is the reference or canonical is. The canonical spec wins; if Rust is closer to canonical than TS, the finding is `reject`.
-- Findings about Rust-specific invariants (`unsafe` usage, refcount imbalance, `Send + Sync`, `unwrap` on user-facing paths) → **patch** (Rust's value over TS / PY is compiler-enforced safety; bypassing forfeits the win).
+Fix priority (most→least): 1) **spec alignment** (`spec/rules.jsonl` / the F-* floor — a rule wins over current impl) · 2) **semantic correctness** (protocol + node contract) · 3) **completeness** (edge cases) · 4) **consistency** (patterns already in `packages/ts/src/`) · 5) **level of effort**. (Frozen `packages/pure-ts/**` + `~/src/callbag-recharge` are read-only precedent only — the clean-slate spec wins on any conflict.)
 
 ### 1d. Present findings (HALT)
+Present ALL patch + defer findings (treat equally). For each: the issue + location, the **recommended fix** (pros/cons), whether it affects architecture, and whether it needs a user decision or can be auto-applied. Group:
+1. **Needs Decision** — architecture-affecting or ambiguous (route per the floor: architectural lock → `/design-review` → D#; wave-protocol behavior change → `/spec-amend`; an open question with no clear answer → `plan/backlog.jsonl` B#).
+2. **Auto-applicable** — clear fixes following existing patterns.
 
-Present ALL patch and defer findings to the user. Treat both equally. For each finding:
-- The issue and its location
-- **Recommended fix** with pros/cons
-- Whether it affects architecture (flag these)
-- Whether it needs user decision or can be auto-applied
-
-Group findings:
-1. **Needs Decision** — architecture-affecting or ambiguous fixes
-2. **Auto-applicable** — clear fixes that follow existing patterns
-
-**Cross-language decision log:** For **Needs Decision** items that are architectural or affect TS/Python parity, add them to **`docs/optimizations.md`** under "Active work items" (this repo is the single source of truth for both TS and PY). When resolved, archive to `archive/optimizations/resolved-decisions.jsonl` per `docs/docs-guidance.md` § "Optimization decision log".
-
-**Wait for user decisions on group 1. Group 2 can be applied immediately if user approves the batch.**
+**Wait for user decisions on group 1.** Group 2 may be applied on the user's batch approval. Do NOT silently pick on a needs-decision item (no-autonomous-decisions).
 
 ---
 
 ## Phase 2: Apply Review Fixes
-
-Apply the approved fixes from Phase 1.
+Apply the approved fixes. Cite the governing R-id / D# in any new test expectations.
 
 ---
 
 ## Phase 3: Final Checks
+Run all checks for the affected package(s) and fix failures (do NOT skip/ignore):
 
-Run all checks for the affected repo(s) and fix any failures (do NOT skip or ignore):
-
-**TypeScript (post-Phase-13.9.A cleave):**
-1. `pnpm test` — runs `pnpm --filter @graphrefly/pure-ts test && pnpm --filter @graphrefly/parity-tests test`. All tests must pass. Use `pnpm test:pure-ts` or `pnpm test:parity` to scope; `pnpm --filter @graphrefly/pure-ts test:watch` for watch mode.
-2. `pnpm run lint:fix` — fix lint issues (workspace-wide; biome is shared at root).
-3. `pnpm run build` — runs `pnpm --filter @graphrefly/pure-ts build && tsup` (pure-ts first, then root shim). The pure-ts build's `onSuccess` runs `assertBrowserSafeBundles` (fails the build with a `via X → Y → Z` chain if any universal entry transitively imports `node:*` or a bare Node builtin). The shim's tsup config has no equivalent guardrail (intentional — the shim has no source-level node-or-DOM imports, just `export *` lines). If `assertBrowserSafeBundles` fails, move the offending symbol to a `<x>/node` subpath per `docs/docs-guidance.md` § "Browser / Node / Universal split", don't silence the guardrail. **Adding a new public subpath is a 4-file change post-cleave**: source under `packages/pure-ts/src/<x>/`, pure-ts `tsup.config.ts` `ENTRY_POINTS` + `package.json` `exports`, and matching shim entries (root `tsup.config.ts` `ENTRY_POINTS` + root `package.json` `exports` + a one-liner shim source at root `src/<x>.ts`).
-
-**Python (if PY code was changed):**
-1. `cd ~/src/graphrefly-py && uv run pytest`
-2. `cd ~/src/graphrefly-py && uv run ruff check --fix src/ tests/`
-3. `cd ~/src/graphrefly-py && uv run ruff format src/ tests/`
-4. `cd ~/src/graphrefly-py && uv run mypy src/`
-
-**Rust (if Rust code was changed in `~/src/graphrefly-rs/`):**
-
-1. `cd ~/src/graphrefly-rs && mise run gate` — **the sanctioned QA gate.** ONE
-   command runs fmt --check → clippy (default-members) → `cargo nextest run
-   --profile ci` (incl. the `cascade_depth` stack-safety guards) *sequentially*
-   under an atomic mutex with process-group teardown, a direct log, a
-   self-timeout diagnostic, and a GUARANTEED terminal sentinel. Do **NOT**
-   hand-run the 4 cargo commands separately in a QA pass — concurrent/stacked
-   cargo invocations fighting the single target lock is the exact swap-thrash
-   foot-gun this gate exists to prevent (`feedback_no_chained_background_cargo.md`).
-   Use `mise run gate:core` for the fast `-p graphrefly-core`-scoped variant
-   during iteration; the **full `mise run gate` is required before the slice
-   closes**. `GATE_CLIPPY_DENY=1 mise run gate` to treat clippy warnings as
-   errors. (The gate runs `cargo-nextest`, never legacy `cargo test`.)
-2. **Monitor it by the sentinel, never a guessed string.** `mise run gate`
-   emits `<<<RUN-LOGGED:DONE>>> exit=… reason=ok|fail|timeout|signal|crash …`
-   on *every* terminal path (stdout AND the `.gate/*.log`). A Monitor's
-   until-condition MUST grep that token — never harness-buffered tool output,
-   never a non-guaranteed progress line. **Subagent hygiene:** if this QA pass
-   runs in a spawned subagent, run the gate **synchronously** (foreground, wait
-   for the sentinel) or tear down any backgrounded command (kill by process
-   group) **before returning** — a live background process leaks as a stale
-   parent-session "running" entry indistinguishable from a real hang. Full
-   rationale + the "is it hung?" checklist + the disk/`target/`-growth
-   tradeoff: `~/src/graphrefly-ts/docs/test-guidance.md` § "Running long
-   commands reliably / diagnosing a stuck run" (memories
-   `feedback_long_command_observation.md`, `feedback_subagent_bg_hygiene.md`).
-3. **Not covered by the gate — check these manually:**
-   - Loom: `cargo test -p graphrefly-core --features loom-checked` (needs the
-     `--cfg loom` build; nextest can't run it). Run via
-     `mise run run-logged -- cargo test -p graphrefly-core --features loom-checked`.
-   - Verify `#![forbid(unsafe_code)]` is preserved at every crate root.
-
-When the diff touches binding crates (also via `mise run run-logged -- …` so a
-slow build is observable, not a false-hang):
-- `cd crates/graphrefly-bindings-js && pnpm build` (napi-rs)
-- `cd crates/graphrefly-bindings-py && maturin develop` (pyo3 — only when verifying py bindings, not part of default flow)
-- `cd crates/graphrefly-bindings-wasm && wasm-pack build` (wasm-bindgen)
-
-Do NOT use `cargo build --workspace` / `cargo nextest run --workspace` unless all binding toolchains are installed; the workspace excludes them from default-members for this reason.
-
-If a failure is related to an implementation design question, **HALT** and raise it to the user before fixing.
-
----
-
-## Phase 4: Documentation Updates
-
-**Skip this phase if `--skip-docs` was passed.**
+**TypeScript (`@graphrefly/ts`):**
+1. `pnpm --filter @graphrefly/ts test` (vitest) — all pass.
+2. `pnpm run lint` (biome + layer-boundary + typecheck gates); `pnpm run lint:fix` to auto-format.
+3. `pnpm run build` (tsup ESM/CJS/DTS) when public API changed.
 
-**Authoritative checklist:** follow **`docs/docs-guidance.md`** end-to-end (authority order, Tier 0–5, JSDoc tag table, `gen-api-docs.mjs` REGISTRY, `docs:gen` / `docs:gen:check`, `sync-docs`, when to edit which file).
+**Sibling packages (only if touched):** run that package's own test/lint/type gate in its repo (`~/src/graphrefly-py` / `~/src/graphrefly-rs`) following its local conventions. The cross-language contract is behavioral conformance (D24) — a substrate behavior change should drive its `spec/conformance.jsonl` arm green per runtime.
 
-Update documentation when behavior or public API changed:
+**jsonl touched (`~/src/graphrefly`):** `node ~/src/graphrefly/dashboard/build.mjs --check` — the consistency gate (non-zero on broken links / orphans).
 
-- **`docs/docs-guidance.md`** — if documentation *conventions* or generator workflow change, update this file so `/qa` and contributors stay aligned
-- **`~/src/graphrefly/GRAPHREFLY-SPEC.md`** — only if the **spec** itself is intentionally revised (rare; use semver rules in spec §8)
-- **`docs/implementation-plan.md`** — **canonical pre-1.0 sequencer.** When a phase / sub-section item lands, mark it ✅ in the matching Phase 11–16 entry (e.g. "11.1 EC2/EC7 — bridge `value == null` → `=== undefined` ✅ landed") and tag with the date. When all items in a sub-section land, mark the sub-section ✅. When a **whole Phase** lands (every sub-section ✅, no in-flight WAIT/POST-1.0 carries that still need this phase's body to be readable), **archive it**: append a JSONL line per sub-section to the matching `archive/roadmap/phase-<n>-*.jsonl` and replace the in-file body with a 2–4-line summary + archive pointer (id, file). Single residual follow-ups move to `optimizations.md` with a back-link. See `docs/docs-guidance.md` § "Roadmap archive — Workflow for `docs/implementation-plan.md`". New deferred items surfaced by /qa go to `optimizations.md` (line-item state) and may also need a sub-bullet in the matching implementation-plan phase if they reshape its scope.
-- **`docs/optimizations.md`** — add **new open decisions** under "Active work items" (line-item state for the new carry; cross-link from the matching implementation-plan.md phase if relevant). **Then actively sweep:** scan for any fully-resolved items (all sub-tasks DONE, no remaining TODOs) and archive them to `archive/optimizations/resolved-decisions.jsonl` per `docs/docs-guidance.md` § "Optimization decision log". Remove archived content from `optimizations.md` — it should contain only active/open items, anti-patterns, and deferred follow-ups.
-- **Structured JSDoc** on exported public APIs (Tier 1 — parameters, returns, examples per `docs-guidance`; source of truth for generated API pages). `@example` imports must use the correct subpath for the symbol's tier (universal / `<x>/node` / `<x>/browser`).
-- **New public symbols** — barrel export in the pure-ts package (`packages/pure-ts/src/<area>/index.ts`) + **`website/scripts/gen-api-docs.mjs` REGISTRY** entry, then `pnpm --filter @graphrefly/docs-site docs:gen` (or `docs:gen:check` in CI). If the symbol introduced a new subpath, the post-Phase-13.9.A 4-file rule applies: update `packages/pure-ts/tsup.config.ts` (`ENTRY_POINTS` + `nodeOnlyEntries` when node-only) AND `packages/pure-ts/package.json` `exports`, AND mirror in the root shim's `tsup.config.ts` `ENTRY_POINTS` + root `package.json` `exports`, AND create the matching one-liner shim source at root `src/<x>.ts` (`export * from "@graphrefly/pure-ts/<x>"`).
-- **`docs/test-guidance.md`** — if new test patterns are established
-- **`docs/roadmap.md`** — **vision / wave context only** per 2026-04-30 migration. Do NOT track item-level state here; that lives in `implementation-plan.md`. Only edit the roadmap when the strategic frame shifts (a wave completes, a positioning lock changes). When a wave or Phase 7.x / 8.x section is fully done, archive its body to `archive/roadmap/*.jsonl` and leave a one-line pointer per `docs/docs-guidance.md` § "Roadmap archive — Workflow for `docs/roadmap.md`". Most /qa cycles will not touch roadmap.md at all.
-- **`CLAUDE.md`** — only if fundamental workflow/commands changed
+**TLA+ touched:** re-run the affected model (`cd ~/src/graphrefly/formal && java -cp <tla2tools.jar> tlc2.TLC -config <name>.cfg <name>`); for a new invariant, mutation-verify it is load-bearing (break the guard → confirm it trips) before claiming it.
 
-Do **not** hand-edit **`website/src/content/docs/api/*.md`** — regenerate from JSDoc via `docs:gen` per **`docs/docs-guidance.md`**.
+**Long / heavy commands** (full test sweeps, Rust gates, TLC): run them so they're observably-finishing, not a false-hang — prefer a run-logged wrapper + monitor a guaranteed DONE sentinel (never a guessed progress string, never `sleep`-poll). If this QA runs in a spawned subagent, run such commands **synchronously** (wait for the sentinel) or tear them down (kill by process group) **before returning** — never leak a live background process as a stale "running" entry. (memories `feedback_long_command_observation`, `feedback_subagent_bg_hygiene`, `feedback_no_chained_background_cargo`.)
 
-### Rust-port QA additions to Phase 4
+If a failure exposes a design question, **HALT** and raise it before fixing.
 
-When the diff is in `~/src/graphrefly-rs/`, also update these (in addition to or instead of the TS-side docs above):
-
-- **`docs/implementation-plan-13.6-canonical-spec.md`** (graphrefly-ts) — only if QA surfaced a canonical-spec ambiguity that needs to be tightened. Rare; this is the post-Phase 13.6.A locked authority. If touched, also coordinate with the spec-amendment workflow per spec §8 semver rules.
-
-- **`docs/implementation-plan-13.6-flowcharts.md`** (graphrefly-ts) — only if a new internal method / process / property was added that the flowcharts should visualize, OR if a 🟥 RED node (current-code-vs-canonical drift) was resolved by the slice (turn it into a non-red node). Add the rule-ID cross-reference for any new flowchart node.
-
-- **`~/src/graphrefly-rs/docs/migration-status.md`** — **always update on Rust-port QA pass.** Reflect:
-  - Test count post-QA (per-file breakdown helps future readers)
-  - Audit fixes that landed (F1, F2, etc. style, mirroring the Slice A+B closing template)
-  - Cross-link new entries in `porting-deferred.md` from the "Carried forward" pointer
-  - If a milestone closes during QA, add the `## M<n> — closed YYYY-MM-DD` section per the established template
-  - clippy / fmt / `#![forbid(unsafe_code)]` status
-
-- **`~/src/graphrefly-rs/docs/porting-deferred.md`** — **always update on Rust-port QA pass.** Reflect:
-  - **NEW deferred concerns** surfaced by QA but NOT fixed in this slice — add to the appropriate section ("Performance — §10 simplifications deferred", "v1 dispatcher limitations", "Spec divergences acknowledged in v1", or "Phase 13.8 carry-forward follow-ups"). Each entry needs **what / why-deferred / source** triple.
-  - **CLOSED concerns** — if QA fixes resolve a previously-deferred entry, move that entry to the "Audit fixes landed in Slice X" section (or the closing section in `migration-status.md`) and remove from the active deferred list.
-  - **Resolved Open Questions** — if a Part-6 SESSION question got resolved during the slice (via design call or impl), update the entry with `~~strikethrough~~` + the resolution note + the date (mirror the Phase 14 header note pattern).
+---
 
-- **TS-side `docs/optimizations.md`** — only if QA surfaced a CROSS-LANGUAGE design question that needs to be tracked alongside TS / PY work. Rust-only deferrals belong in `porting-deferred.md`, not `optimizations.md`.
+## Phase 4: Documentation Updates
 
-- **TS-side `docs/implementation-plan.md`** — only if a Phase 13.7 / 13.8 / similar Rust-port-tracking sub-item closes; mark ✅ inline with date. The Rust port does NOT add new Phase 11–16 sub-bullets here; `migration-status.md` is the canonical Rust tracker.
+**Skip if `--skip-docs` was passed.** Update only what behavior/API actually changed; clean-slate docs are jsonl (single source of truth):
 
-- **Rustdoc on public API surface** — every new `pub fn` / `pub struct` / `pub enum` in `graphrefly-core` (and binding crates) needs a doc comment with at minimum: behavior summary, `# Panics` (if applicable), and a cross-reference to the canonical spec rule (`R<x.y.z>`) when the API encodes a spec invariant. Generated via `cargo doc -p graphrefly-core` (lands later in CI; smoke-check locally).
+- **`spec/rules.jsonl`** — only if the protocol itself was intentionally revised → that is a `/spec-amend`, not a casual edit (amend rules + `formal/*.tla` + `spec/conformance.jsonl` together). Flip a conformance-backed rule `draft → active` once its scenario is green on the reference arm + formal lands (cite the precedent).
+- **`decisions/decisions.jsonl`** — a new architectural lock surfaced by QA → `/design-review` → user approval → append a `D#` (update the DS-1 `locks` in `sessions/sessions.jsonl`).
+- **`spec/conformance.jsonl`** — flip `runtimes.<arm>` → `pass` when an arm lands green; add a new C-* scenario for a new behavioral rule; keep `covers` ↔ rule `covers_by` bidirectionally consistent.
+- **`plan/phases.jsonl`** — update the CSP-* phase `status`/`note` the change advances.
+- **`plan/backlog.jsonl`** — add new deferred items (B# + concrete trigger) surfaced by QA.
+- **`plan/antipatterns.jsonl`** — a recurring anti-pattern (+ a `feedback_*` memory if generalizable).
+- **`formal/README.md`** — when a TLA+ module was added/changed (module-map row + a mutation-verified note).
+- **Structured JSDoc** on new exported public symbols (`packages/ts/src/<area>`); cite the governing R-id/D# when the API encodes a spec invariant.
+- **`guide/guide.jsonl`** (G-test / G-composition / G-docs / G-contribute) — if a new test/composition pattern or doc convention was established.
+- **`~/src/graphrefly/CLAUDE.md`** — only if a fundamental workflow/command changed.
 
-- **DO NOT update the legacy multi-file TS spec** (`~/src/graphrefly/GRAPHREFLY-SPEC.md` + `COMPOSITION-GUIDE-*.md`) for Rust-port-only findings. The Rust port targets the canonical-spec doc; the multi-file spec is effectively superseded for Rust purposes per the Phase 13.6.A consolidation.
+After any `~/src/graphrefly` jsonl edit, re-run `node ~/src/graphrefly/dashboard/build.mjs --check`.
 
-- **`~/src/graphrefly-ts/packages/parity-tests/scenarios/<layer>/`** (TS-side) — when the Rust slice closes (or partially fills) a milestone in the `packages/parity-tests/README.md` schedule (M1 dispatcher, M2 Slice E Graph, M3 operators, M4 storage, M5 structures), QA should verify the slice author added corresponding `describe.each(impls)` scenarios, OR raise it as a missing-coverage finding. The structural parameterization is in place; the `rustImpl` arm currently exports `null` (activates when `@graphrefly/native` publishes), so new scenarios run against `pureTsImpl` only at the moment but provide cross-impl coverage automatically once `rustImpl` flips. Internal-refactor slices (under unchanged public API, e.g., a §10 perf simplification) don't need parity-test additions.
+When done, briefly list files changed + new exports, the fixes applied vs deferred (with B# pointers), and the gate results.
diff --git a/.claude/skills/rust-review/SKILL.md b/.claude/skills/rust-review/SKILL.md
deleted file mode 100644
index 97caa479..00000000
--- a/.claude/skills/rust-review/SKILL.md
+++ /dev/null
@@ -1,236 +0,0 @@
----
-name: rust-review
-description: "Post-implementation quality review for Rust port slices. Runs the audit-data extractor, then appends one structured row to reviews.jsonl + new rows to findings.jsonl + (if applicable) edits flowcharts.md. Output is data, not prose — every behavioral trace, simplification delta, and finding lands in the audit dashboard. Use after /porting-to-rs completes a slice, or standalone when you want to verify a Rust module's correctness without reading Rust."
-argument-hint: "[module or slice name, e.g. 'batch coalescing' or 'M1 Slice C']"
----
-
-You are executing the **rust-review** workflow. Output is **structured data**, never markdown prose. Every analytical artifact lands in JSONL files under `~/src/graphrefly-rs/docs/audit/data/`, which the audit dashboard at `http://localhost:8769/audit/site/` renders.
-
-Target: $ARGUMENTS
-
----
-
-## Phase 0: Refresh derived data
-
-Re-run the extractor first so you start the review against current source state:
-
-```bash
-cd ~/src/graphrefly-rs && mise run audit-extract
-# or directly:  python3 docs/audit/extract.py
-```
-
-This regenerates the **derived** files (overwritten on every run):
-- `items.jsonl` — every public/crate-private item with `loc`, `attrs`, `rules_cited`
-- `rules.jsonl` — canonical spec rules (262 today)
-- `tests.jsonl` — every `#[test]` fn with `covers_rules` extracted from doc-comment + body
-- `topology.jsonl` — crate-to-crate `use` and `ref` edges
-- `locks.jsonl` — lock acquisition sites (`Mutex::lock`, `RwLock::read|write`, etc.)
-- `flowcharts.jsonl` — Mermaid diagrams from `docs/flowcharts.md` with metadata + source
-
-It does **not** touch `findings.jsonl` and `reviews.jsonl` — those are append-only, author-edited audit artifacts.
-
----
-
-## Phase 1: Load context
-
-Read in parallel:
-
-- `~/src/graphrefly-rs/docs/migration-status.md` — what's claimed as landed
-- `~/src/graphrefly-rs/docs/porting-deferred.md` — known gaps
-- `~/src/graphrefly-rs/docs/flowcharts.md` — Rust-port-specific shape diagrams (canonical Mermaid source)
-- `~/src/graphrefly-ts/docs/implementation-plan-13.6-canonical-spec.md` — sections relevant to $ARGUMENTS
-- `~/src/graphrefly-ts/docs/implementation-plan-13.6-flowcharts.md` — TS spec semantics
-- `~/src/graphrefly-rs/docs/rust-port-decisions.md` — locked decisions
-- The Rust source files for the module (`~/src/graphrefly-rs/crates/<crate>/src/`)
-- The Rust test files (`~/src/graphrefly-rs/crates/<crate>/tests/`)
-- `~/src/graphrefly-rs/docs/audit/data/findings.jsonl` — open findings on $ARGUMENTS to avoid duplicating
-- `~/src/graphrefly-rs/docs/audit/data/reviews.jsonl` — past reviews of nearby slices
-
-Open the dashboard during the review:
-```
-mise run audit-serve              # background server
-http://localhost:8769/audit/site/ # the live data view
-```
-
----
-
-## Phase 2: Behavioral traces
-
-Author 2–5 traces covering: the happy path, the most complex edge case (diamond, pause interaction, terminal cross-cut), and any scenario the parity tests cover. Each trace is a structured object (not markdown). Schema:
-
-```json
-{
-  "id": "T1",
-  "title": "Pause-overflow ERROR synthesis",
-  "rules": ["R1.3.8.c", "Lock 6.A"],
-  "diagrams": ["11.1"],
-  "steps": [
-    {"step": 1, "event": "set_pause_buffer_cap(node, Some(2))", "internal": "NodeRecord.pause_buffer_cap = 2", "output": "—"},
-    {"step": 2, "event": "...", "internal": "...", "output": "..."}
-  ],
-  "commentary": "Pre-Slice-F this was a silent drop. Now structured ERROR with {nodeId, droppedCount, configuredMax, lockHeldDurationMs}."
-}
-```
-
-Build the trace objects in your head, hold them — they get embedded in the `reviews.jsonl` row in Phase 6.
-
----
-
-## Phase 3: Simplification delta
-
-For each public-facing change in the slice, capture a delta row:
-
-```json
-{
-  "n": 1,
-  "ts_pattern": "TS pause overflow: silent drop or implementation-defined",
-  "rust_replacement": "Synthesized Error with structured diagnostic",
-  "simpler": "same",                    // "same" | "yes" | "no" | "rust-harder"
-  "notes": "Slice F A3 — closes documented divergence",
-  "diagram": "11.1"                     // optional flowchart id
-}
-```
-
-Flag `simpler: "no"` or `"rust-harder"` rows as potential over-engineering. If a row's complexity is justified (type safety, thread safety, etc.) put the justification in `notes`. If unjustified, plan to also emit a `kind:"opp"` finding in Phase 5.
-
----
-
-## Phase 4: Deferred gap audit
-
-For each `#[ignore]` test in the module, check it has a matching entry in `porting-deferred.md`. For each deferred-but-not-ignored item, plan a `kind:"limit"` finding in Phase 5. For each item that's silently depended on for correctness, plan a `kind:"bug"` finding.
-
----
-
-## Phase 5: Findings
-
-Each issue surfaced becomes one row in `findings.jsonl`. Re-use a draft authored via the dashboard's "+ New finding" drawer (fastest path — IDs auto-increment from the highest existing `F<NNN>`), or hand-author. Schema:
-
-```json
-{
-  "id": "F011",
-  "kind": "bug",                        // bug | limit | opp | note | complete-gap
-  "severity": "major",                  // critical | major | minor
-  "title": "Diamond resolution overflows at fan-in >32",
-  "where": "crates/graphrefly-core/src/dispatcher.rs",
-  "where_line": 142,
-  "rule": "R5.8",                       // optional
-  "slice": "M3 Slice F audit /qa D4",   // optional
-  "evidence": "Reproducer: tests/wide_fanin.rs::T_diamond_w33. Bitmask is u32 → silently overflows.",
-  "recommendation": "Lift bitmask to u128 for fan-in ≤128, fall back to Vec<u64> chunks above.",
-  "status": "open",                     // open | closed | superseded | draft
-  "opened_at": "2026-05-09",
-  "closed_at": null,
-  "supersedes": null,
-  "source": "rust-review (slice F audit)"
-}
-```
-
-**Authoring tips**:
-- Use the dashboard's authoring drawer for any finding tied to a specific file — the `where` field gets autocomplete.
-- One finding per issue. Don't bundle.
-- For "Rust simpler than TS" wins worth surfacing, use `kind:"opp"`.
-- For deferred-by-design items, use `kind:"limit"` and put the deferral reason in `evidence`.
-- For missing parity scenarios, use `kind:"complete-gap"` and cite the `rule` it would test.
-
----
-
-## Phase 6: Append the review row
-
-When traces, deltas, and findings are all authored, build **one** `reviews.jsonl` row that ties them together and append it (no rewrites — the file is append-only):
-
-```json
-{
-  "id": "rev-2026-05-09-slice-q",
-  "review_date": "2026-05-09",
-  "slice": "M3 Slice Q",
-  "scope": "...",
-  "sha": "<short hash from git rev-parse --short HEAD>",
-  "tests_before": 438,
-  "tests_after": 471,
-  "premise": "<short why-it-matters paragraph>",
-  "traces":  [ ... Phase 2 trace objects ... ],
-  "deltas":  [ ... Phase 3 delta rows ... ],
-  "findings_opened": ["F011", "F012", "F013"],
-  "assessment": {
-    "spec_fidelity": "very high",
-    "over_engineering": "low",
-    "correctness_holes": "none",
-    "halt": "no",
-    "summary": "<one-paragraph verdict>"
-  },
-  "source": "rust-review"
-}
-```
-
-Use absolute dates (`2026-05-09`), not "today". `id` follows `rev-<YYYY-MM-DD>-<slice-slug>`. Append with:
-
-```bash
-echo '<the json>' >> ~/src/graphrefly-rs/docs/audit/data/reviews.jsonl
-```
-
-(One line, no trailing comma, valid JSON.)
-
----
-
-## Phase 7: Maintain `flowcharts.md`
-
-`~/src/graphrefly-rs/docs/flowcharts.md` is still the **canonical Mermaid source**. The extractor reads from it; the dashboard renders from `flowcharts.jsonl`.
-
-For **each new public method, state machine, or distinctive pattern** you traced in Phase 2 that isn't already diagrammed:
-
-1. Add a Mermaid block under the appropriate batch heading (`## Batch N — title`) with a `### x.y title` heading. The extractor will pick it up next time you run `mise run audit-extract`.
-2. Cite the spec rule (`R<x.y.z>`) in the title or prose so `rules_cited` populates correctly.
-3. Use existing conventions: 🟨 YELLOW for v1 limitations, 🟦 BLUE for Rust-specific simplifications, solid arrows for control flow, dashed for data flow.
-4. Update the cross-reference tables at the end of the file (slice→diagram, spec rule→diagram, deferred→diagram).
-
-**For diagrams that became stale**: edit in place, add a short "updated in Slice X" note in the prose, no new diagram needed.
-
-**Mermaid syntax pitfalls** (verified to fail in mermaid v10):
-- `;` in sequenceDiagram message text (use `,` or `—`)
-- `:` inside stateDiagram-v2 state descriptions when followed by `{...}` (use `note right of <state>` blocks)
-- Generics with `<T>` inside class/state diagrams — use `~T~`
-- Stray `activate`/`deactivate` pairs across `alt`/`else` branches — close every branch
-- Bracket labels `["…"]` containing parens or `::` — replace with `[…]` plain text
-
-After Mermaid edits, **re-run the extractor** so `flowcharts.jsonl` updates:
-
-```bash
-mise run audit-extract
-```
-
----
-
-## Phase 8: Verify in the dashboard
-
-1. `mise run audit-serve` (or `preview_start` with the `rust-audit` profile in `.claude/launch.json`).
-2. Open `http://localhost:8769/audit/site/`.
-3. Spot-check each tab:
-   - **Reviews** → your new row sits at the top (newest first), expand it, confirm traces + deltas + findings render correctly.
-   - **Findings** → new rows appear with the right `where` clickable to Repo Map.
-   - **Flowcharts** → any new diagram appears in its batch group; click to render Mermaid.
-   - **Spec ⇄ Impl** → if the slice changed citations, the matrix shows updated counts; rules touched by new findings have the bug indicator; flowchart-citing rules show the 📊 chip.
-   - **Repo Map** → drill into any file you logged a finding on; verify the sidecar shows the new finding.
-4. Note in the conversation any tabs that didn't update as expected.
-
-> **Subagent / background hygiene.** `mise run audit-serve` is a long-lived background server; if you reproduce a finding with a Rust command, run it through `mise run run-logged -- <cmd>` (or `mise run gate:core`) and wait foreground for the `<<<RUN-LOGGED:DONE>>>` sentinel — never monitor a non-guaranteed string. If this skill runs in a spawned subagent, it MUST stop the audit server / tear down any backgrounded command (kill by process group) **before returning** — a live background process leaks as a stale parent-session "running" entry indistinguishable from a real hang. See `~/src/graphrefly-ts/docs/test-guidance.md` § "Running long commands reliably / diagnosing a stuck run" and memory `feedback_subagent_bg_hygiene.md`.
-
----
-
-## When to escalate
-
-If during the review you find:
-- A behavioral trace that **contradicts** the canonical spec → HALT, surface the contradiction, write a `kind:"bug" severity:"critical"` finding, do NOT append the review row until the user resolves.
-- A delta row where Rust adds machinery that's NOT justified by a Rust-specific constraint → write a `kind:"opp"` finding with `recommendation:` listing the simpler shape.
-- A deferred item the current code silently depends on for correctness → flag as `kind:"bug"` (not `limit`) — that's a hidden hole.
-- A flowchart in `flowcharts.md` that contradicts current source (drift) → fix the diagram in Phase 7 and call out the drift in the review's `premise`.
-- A Mermaid render failure you can't fix in two attempts → leave the diagram in but cite it in the review's `assessment.summary` so it gets followup attention.
-
----
-
-## What changed from the old workflow
-
-The pre-2026-05-09 SKILL wrote a markdown report (`reports-NNN-<slug>.md`) under `docs/review/`. Those files are **frozen historical artifacts** — leave them. New reviews go to `docs/audit/data/reviews.jsonl` only.
-
-The Phase 6.5 directive vocabulary (`::: trace`, `::: finding`, …) used by the legacy report renderer is no longer used. The structured shape lives in JSONL fields directly.
-
-The legacy site renderer at `docs/review/site/` was **removed 2026-05-24** (moved to `~/src/graphrefly-rs/TRASH/review-site-removed-2026-05-24/`) to eliminate dual-dashboard confusion. The 6 historical reports at `docs/review/reports-*.md` are preserved as flat-file markdown — every `findings.jsonl` row's `source` field still cites them by filename. Read them in any editor; do not edit them; do not resurrect the renderer.
diff --git a/.claude/skills/spec-amend/SKILL.md b/.claude/skills/spec-amend/SKILL.md
new file mode 100644
index 00000000..abed49e4
--- /dev/null
+++ b/.claude/skills/spec-amend/SKILL.md
@@ -0,0 +1,34 @@
+---
+name: spec-amend
+description: "Spec-first protocol amendment flow for the clean-slate GraphReFly redesign. Use BEFORE changing any wave-protocol behavior (tiers, wave semantics, diamond/equals/SENTINEL, batch, push-on-subscribe, ctx.up/down contract). Enforces F-NO-IMPL-DEFINED: amend spec/rules.jsonl + formal/*.tla + spec/conformance.jsonl FIRST, then implement in each language package. Triggers: 'amend the spec', 'change the protocol', 'add a tier', 'spec change', 'new wave rule', 'this changes protocol behavior'. NOT for sugar/operator/inspection changes — those are per-language, never touch spec."
+argument-hint: "[short description of the protocol behavior to change]"
+---
+
+You are executing **spec-amend** for the clean-slate GraphReFly redesign.
+
+**Authority repo:** `~/src/graphrefly` (clean-slate branch) holds the language-neutral spec.
+Per-language packages (`graphrefly-{ts,rust,py}`) implement it; they NEVER define protocol behavior.
+
+## Iron rule (F-NO-IMPL-DEFINED, decision D14/D19)
+
+Protocol behavior is **spec-first**. No "implementation defines what happens." Order is fixed:
+
+1. **Amend the spec data** (before any code):
+   - `~/src/graphrefly/spec/rules.jsonl` — add/edit the normative rule (`{id, area, tier?, statement, rationale, status, since:"D#", covers_by:[]}`). Mark `status:"draft"` until conformance + code land, then `"active"`.
+   - `~/src/graphrefly/formal/*.tla` (+ MC config) — model the behavior; add the invariant; run TLC. (formalization γ, D14.)
+   - `~/src/graphrefly/spec/conformance.jsonl` — add the behavioral scenario(s) that pin the new rule (`covers:[rule-id]`, `runtimes:{ts:"todo",rust:"todo",py:"todo"}`, `status:"required"`).
+2. **Record the decision** if this is a new architectural lock: append a `D#` to `~/src/graphrefly/decisions/decisions.jsonl` (or reference the existing one in `since`).
+3. **Run the consistency gate:** `node ~/src/graphrefly/dashboard/build.mjs --check` (no broken links/orphans).
+4. **THEN implement** in each language package to make the conformance scenarios pass; flip `runtimes.<lang>` → `"pass"` as each lands. Use `/dev-dispatch` per package.
+
+## Closed-set guardrails (do not bypass)
+
+- **9 tiers are a closed set** (D9). Adding a tier is a constitutional change — requires explicit user lock + TLA+ re-model, not a casual amend.
+- **onMessage/onSubscribe are substrate-fixed** (D19) — they are NOT user-replaceable hooks; "amend" means changing the spec'd behavior, not adding a config knob.
+- **equals fires only single-DATA-wave** (D15); **ctx.up is control-tier only** (R-ctx-up); **restore ≠ fresh-lifecycle wipe** (R-restore). Re-read these rules before touching adjacent behavior.
+
+## Output
+
+A spec-amendment plan: which rule(s) change, the TLA+ invariant delta, the conformance scenario(s) added, the D# (new or referenced), and the per-language implementation order. HALT for user approval before writing TLA+/code if the change touches a closed-set guardrail.
+
+After the spec data lands and `--check` is clean, hand off to `/dev-dispatch` per language package and `/conformance` to drive the scenarios green.
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 0b79730d..4964c6e5 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -43,33 +43,18 @@ jobs:
 
       - run: pnpm test
 
-      # graphrefly-ts#4 — ongoing indicator that pure-ts stays
-      # compatible with the Hermes engine React Native ships. Fast:
-      # RN's pinned hermesc (npm, no build) + Node semantics. The
-      # on-device VM tier (apps/rn-hermes-fixture) runs periodically,
-      # not here. See scripts/hermes-smoke/README.md.
-      - name: RN/Hermes engine smoke
-        run: pnpm test:hermes
-
       - run: pnpm run lint
 
       - run: pnpm run build
 
-      # Dogfood wiring smoke (gate blind-spot follow-up, 2026-05-17):
-      # `check-typecheck.ts` is blind on the `_dogfood-conformance.ts`
-      # typed boundary's runtime behavior + the `// DOGFOOD:`-laundered
-      # surfaces. One offline `--dry-run` harness pass over a single
-      # fixture exercises adapter wiring + graph construction + the
-      # strategy-read path the type gate can't reach. No API key.
-      - name: Eval harness dogfood smoke
-        run: pnpm run eval:smoke
-
-      - name: Docs + demos build
+      # The docs build runs against the clean-slate @graphrefly/ts package and
+      # explicitly historical/archive pages.
+      - name: Docs build
         run: pnpm run docs:build
         env:
           ASTRO_SITE_URL: https://graphrefly.dev
           ASTRO_BASE_PATH: /
 
-      # GITHUB_ACTIONS sets CI=true by default — perf-smoke.test.ts skips wall-clock (matches graphrefly-py).
+      # Clean-slate TS B49 probe.
       - name: Benchmark smoke
         run: pnpm bench
diff --git a/.github/workflows/eval.yml b/.github/workflows/eval.yml
deleted file mode 100644
index 3cb5afa5..00000000
--- a/.github/workflows/eval.yml
+++ /dev/null
@@ -1,76 +0,0 @@
-name: Eval Matrix
-
-on:
-  schedule:
-    - cron: "0 6 * * 1" # Weekly Monday 6am UTC
-  workflow_dispatch:
-    inputs:
-      models:
-        description: "Comma-separated model list (e.g. claude-sonnet-4-6,gpt-4o-mini)"
-        required: false
-        default: "claude-sonnet-4-6"
-      providers:
-        description: "Comma-separated provider per model (same order)"
-        required: false
-        default: "anthropic"
-
-permissions:
-  contents: write
-
-jobs:
-  eval:
-    runs-on: ubuntu-latest
-    timeout-minutes: 30
-    steps:
-      - uses: actions/checkout@v4
-
-      - uses: pnpm/action-setup@v4
-
-      - uses: actions/setup-node@v4
-        with:
-          node-version: 22
-          cache: pnpm
-
-      - run: pnpm install --frozen-lockfile
-
-      - name: Build
-        run: pnpm build
-
-      # Clone spec repo for eval corpus
-      - name: Clone spec repo
-        run: git clone --depth 1 https://github.com/${{ github.repository_owner }}/graphrefly.git ~/src/graphrefly
-
-      - name: Run eval matrix
-        env:
-          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
-          OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
-          GOOGLE_API_KEY: ${{ secrets.GOOGLE_API_KEY }}
-          EVAL_MODELS: ${{ github.event.inputs.models || 'claude-sonnet-4-6' }}
-          EVAL_PROVIDERS: ${{ github.event.inputs.providers || 'anthropic' }}
-          SPEC_EVALS_PATH: ~/src/graphrefly/evals
-        run: pnpm eval:matrix
-
-      - name: Generate scorecard
-        run: pnpm eval:scorecard
-
-      - name: Regression gate
-        if: hashFiles('evals/results/*.json') != ''
-        run: |
-          # Find the two most recent result files for the same layer and compare
-          LATEST=$(ls -t evals/results/*.json | head -1)
-          PREV=$(ls -t evals/results/*.json | head -2 | tail -1)
-          if [ "$LATEST" != "$PREV" ]; then
-            pnpm eval:compare "$PREV" "$LATEST"
-          fi
-
-      - name: Commit results
-        run: |
-          git config user.name "github-actions[bot]"
-          git config user.email "github-actions[bot]@users.noreply.github.com"
-          git add evals/results/ evals/scorecard/
-          if git diff --cached --quiet; then
-            echo "No new results to commit"
-          else
-            git commit -m "chore(evals): automated eval run $(date -u +%Y-%m-%d)"
-            git push
-          fi
diff --git a/.github/workflows/pages.yml b/.github/workflows/pages.yml
index 6ec8d255..f4f3c1a7 100644
--- a/.github/workflows/pages.yml
+++ b/.github/workflows/pages.yml
@@ -44,8 +44,9 @@ jobs:
 
       - run: pnpm install --frozen-lockfile
 
-      # docs:build = website + demos/{compat-matrix,reactive-layout,knowledge-graph,pagerduty-triage}, copied into website/dist/demos/
-      - name: Build docs and demos
+      # Build the current docs site; historical/archive pages are explicit
+      # non-guidance content.
+      - name: Build docs
         run: pnpm run docs:build
         env:
           ASTRO_SITE_URL: https://graphrefly.dev
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index 8cd315c3..7b55fcab 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -22,10 +22,9 @@
 #     GitHub Actions → org=graphrefly, repo=graphrefly-ts, workflow=release.yml
 #
 # Packages currently in scope (from .changeset/config.json):
-#   - @graphrefly/graphrefly + @graphrefly/pure-ts (fixed pair, always
-#     released at same version — shim + impl)
-#   - @graphrefly/cli (independent versioning)
+#   - @graphrefly/ts (clean-slate TypeScript package)
 # Ignored:
+#   - @graphrefly/graphrefly (retired root package, B65)
 #   - @graphrefly/parity-tests (private)
 
 name: Release
@@ -107,9 +106,8 @@ jobs:
       - name: Test
         run: NODE_ENV=test pnpm test
 
-      # Build before publishing — pure-ts ships pre-built dist/, and
-      # downstream packages import from it. semantic-release's prepublishOnly
-      # ran a duplicate build; the changesets flow runs build once here.
+      # Build before publishing. The release build follows the clean-slate
+      # @graphrefly/ts package; the root package is retired/private.
       - name: Build
         env:
           NODE_OPTIONS: --max-old-space-size=6144
diff --git a/.gitignore b/.gitignore
index 3c088844..ecd245de 100644
--- a/.gitignore
+++ b/.gitignore
@@ -27,20 +27,20 @@ coverage/
 .vite/
 *.tmp
 
-# Eval LLM replay cache — local, machine-specific, regenerated on first run.
+# Archived eval LLM replay cache — local, machine-specific, regenerated on first run.
 # Each entry is sha256(provider+model+prompt+...) → response.json. Do not commit.
-evals/results/replay-cache/
+archive/evals/results/replay-cache/
 
 # Harness-loop retrospective checkpoint (FileCheckpointAdapter output). Written
 # on every run-harness invocation incl. `eval:smoke --dry-run`; machine-local,
 # regenerated. Do not commit (mirrors the replay-cache precedent above).
-evals/results/harness-retrospective/
+archive/evals/results/harness-retrospective/
 
 # Environment (keep examples)
 .env
 .env.*
 !.env.example
-evals/.env
+archive/evals/.env
 
 # pnpm
 .pnpm-store/
diff --git a/AGENTS.md b/AGENTS.md
new file mode 100644
index 00000000..59e55b60
--- /dev/null
+++ b/AGENTS.md
@@ -0,0 +1,89 @@
+# graphrefly-ts — agent context (TypeScript implementation)
+
+**GraphReFly** — reactive universal reduction layer (high fan-in/out → information reduction → push;
+not LLM-limited, D1). This repo is the **TypeScript implementation** (`@graphrefly/ts`): a
+self-contained package (substrate + sugar + operators), **no cross-language peer-deps** (D32).
+
+> **This file points, it does not host.** The language-neutral authority — protocol spec,
+> decisions, design sessions, conformance, formal model — lives in `~/src/graphrefly` (branch
+> `clean-slate`). When anything here disagrees with that repo, **that repo wins.** Do not
+> duplicate its content back into this file.
+
+## Authority — where the truth lives (`~/src/graphrefly`)
+
+Read `~/src/graphrefly/CLAUDE.md` first — it is the single-source index for the design.
+
+| Concern | Source of truth |
+|---|---|
+| **Decisions (why)** — unified D# log | `~/src/graphrefly/decisions/decisions.jsonl` (read via `/decision-guard`) |
+| **Design narrative** — full L0–L6 locks, F-* constraints, flags, spec-amendment list | `~/src/graphrefly/sessions/active/SESSION-clean-slate-redesign.md` (DS-1) |
+| **Protocol rules (宪法)** | `~/src/graphrefly/spec/rules.jsonl` (changed via `/spec-amend`) |
+| **Conformance scenarios (parity)** | `~/src/graphrefly/spec/conformance.jsonl` (driven via `/conformance`) |
+| **Formal model** | `~/src/graphrefly/formal/*.tla` (+ MC configs) |
+| **Sequencer (what next) / backlog / anti-patterns** | `~/src/graphrefly/plan/{phases,backlog,antipatterns}.jsonl` |
+| **Guides (composition / docs / test / contribute)** | `~/src/graphrefly/guide/guide.jsonl` |
+| **Rendered view** (progress / structure / gaps / search) | `~/src/graphrefly/dashboard/` (`node dashboard/build.mjs`) |
+
+Sibling implementations (each self-contained, cross-language = wire bridge, not in-process):
+`@graphrefly/rust` (`~/src/graphrefly-rs`), `@graphrefly/py` (`~/src/graphrefly-py`).
+
+## Clean-slate floor (cite, never violate — full text in DS-1 / `rules.jsonl`)
+
+- **Sacred (L0.7):** topology declarative/serializable/inspectable · wave protocol is a public spec ·
+  wave protocol impl is **sync** · all fn go through the dispatcher.
+- **8 verbs, closed set (D4):** `node` `graph` `batch` `state` + `producer` `derived` `effect` `mount`.
+  Operators are `node` sugar, not verbs — per-language, never in parity (D6).
+- **`ctx.up` / `ctx.down(msgs)` (D8):** one `msgs` array = one wave; may mix tiers. `ctx.up` is
+  **control-tier only** (DIRTY/PAUSE/RESUME/INVALIDATE/TEARDOWN); DATA/RESOLVED/COMPLETE/ERROR are
+  down-only (R-ctx-up). Handle = pure data `(pool_id, handle_id)`, no methods (D7).
+- **7-tier const table + 10-message closed set (D9/D34, R-tier/R-msg-closed-set):** adding a tier
+  or message type is a constitutional change.
+- **graph = single-thread causal/concurrency domain (D22):** parallelism via pool callback or
+  multi-graph + wire bridge; rewire intra-graph only.
+- **parity = behavioral conformance (D24):** structural `Impl` + cross-track-ledger retired.
+- **config dissolved (D26):** clock is graph-local (no global singleton); `messageTier` is a
+  compile-time const table; `onMessage`/`onSubscribe` are substrate-fixed, not user-replaceable (D19).
+- **Forced (F-*):** F-SYNC-CORE (async lives only in pools / wire-bridge) · F-DISPATCH-ALL (no
+  inline-fn bypass) · F-NO-IMPL-DEFINED (spec-locked or explicitly undefined) · F-NO-WEDGE-CUT ·
+  F-NO-LLM-ONLY · F-GRAPH-FIRST-API · F-PERF.
+
+Durable values (memory `feedback_*`): no backward compat (pre-1.0) · no imperative triggers ·
+single source of truth · **no autonomous decisions** (surface spec↔code conflicts, don't silently pick) ·
+no implement without explicit approval · verify premise before greenfield.
+
+## Workflow rules
+
+- **spec-first** (F-NO-IMPL-DEFINED): any protocol behavior change → amend `~/src/graphrefly`
+  `spec/rules.jsonl` + `formal/*.tla` + `spec/conformance.jsonl` **before** code (`/spec-amend`).
+- **decision-first**: any architectural lock → a `D#` in `~/src/graphrefly/decisions/decisions.jsonl`
+  before code (`/design-review` → user approval → append).
+- **consistency gate**: `node ~/src/graphrefly/dashboard/build.mjs --check` (non-zero on broken
+  links / orphans) after touching any spec/decision/plan jsonl.
+
+## Commands
+
+```bash
+pnpm test          # full TS test suite
+pnpm run lint      # biome + layer/typecheck gates
+pnpm run lint:fix  # biome check --write
+pnpm run build     # build the package
+pnpm bench         # vitest bench (informational, not a CI gate — L5-Q1)
+
+# Cross-repo note (when working in ~/src/graphrefly-rs from this thread):
+# Rust toolchain is driven by `mise`; in agent shells, prefer:
+#   mise exec -- cargo <cmd>
+# Fallback if PATH is constrained:
+#   ~/.cargo/bin/cargo <cmd>
+```
+
+## Skills (clean-slate)
+
+Project-local skills under `.claude/skills/`:
+
+- **decision-guard** — recall locked D#/values/floor before any decision question.
+- **spec-amend** — spec-first protocol amendment (rules + TLA+ + conformance, then code).
+- **conformance** — drive behavioral conformance scenarios green per runtime.
+- **dashboard** — build / check the `~/src/graphrefly` docs dashboard + consistency gate.
+- **dev-dispatch** — plan, align with spec, implement, self-test.
+- **qa** — adversarial review, fixes, test + lint + build, doc touch-ups.
+- **design-review** — Q5–Q9 design lens before coding new primitives.
diff --git a/CLAUDE.md b/CLAUDE.md
index 0e920099..e5b6a7ee 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -1,214 +1,83 @@
-# graphrefly — unified agent context
-
-**GraphReFly** — reactive graph protocol for human + LLM co-operation. This repo (`graphrefly-ts`) is the **single source of truth** for operational docs, skills, roadmap, and optimization records across both the TypeScript and Python implementations.
-
-## Repos
-
-| Repo | Path | Role |
-|------|------|------|
-| **graphrefly-ts** | this repo | TypeScript implementation + **all operational docs** |
-| **graphrefly-py** | `~/src/graphrefly-py` | Python implementation (must stay in parity) |
-| **graphrefly** (spec) | `~/src/graphrefly` | `GRAPHREFLY-SPEC.md`, `COMPOSITION-GUIDE.md` |
-| **callbag-recharge** | `~/src/callbag-recharge` | TS predecessor (patterns/tests, NOT spec authority) |
-| **callbag-recharge-py** | `~/src/callbag-recharge-py` | PY predecessor (concurrency patterns, subgraph locks) |
-
-## Canonical references (read these)
-
-| Doc | Role |
-|-----|------|
-| `~/src/graphrefly/GRAPHREFLY-SPEC.md` | **Behavior spec** — messages, `node`, `Graph`, invariants |
-| `~/src/graphrefly/COMPOSITION-GUIDE.md` | **Composition guide** — insights, patterns, recipes for Phase 4+ factory authors. **Read before building factories that compose primitives.** Covers: lazy activation, subscription ordering, null guards, feedback cycles, promptNode SENTINEL, wiring order. |
-| `docs/implementation-plan.md` | **CANONICAL pre-1.0 sequencer** — Phases 11–16 + Parked + Open design sessions. Tier 1–10 historical record + the active Phase 11–16 plan locked 2026-04-30 (cleanup → consolidation → multi-agent → changesets/diff → roadmap residuals → eval → launch). Read this FIRST when picking up "what's next." Phase 13 covers multi-agent + intervention substrate (sources: `archive/docs/SESSION-multi-agent-gap-analysis.md` + `SESSION-human-llm-intervention-primitives.md`). |
-| `docs/optimizations.md` | **Active backlog (line-item state)** — open work items, anti-patterns, deferred follow-ups, proposed improvements. Item-level provenance for entries that the implementation-plan.md phases reference. Add new items here. |
-| `archive/optimizations/` | **Optimizations archive** — built-in optimizations, resolved design decisions, cross-language parity notes. Check before introducing new optimizations or debugging perf issues. **Backlog/proposed items belong in `docs/optimizations.md`, not here.** |
-| `docs/cross-track-ledger.md` | **Cross-track coordination ledger** — the single place to log any change that widens the `Impl` contract (`packages/parity-tests/impls/types.ts`) or otherwise couples the presentation track (`@graphrefly/graphrefly`) ↔ Rust-port track (`@graphrefly/native`). Add a row BEFORE landing such a change (N1 → graphrefly-rs migration-status item-8 is the handoff pattern). Not for general optimization items — those stay in `docs/optimizations.md`. |
-| `docs/roadmap.md` | **Vision / wave context** (no longer the active sequencer per 2026-04-30 migration — see `implementation-plan.md`). Useful for the strategic frame: Wave 0/1/2/3 announcement structure, harness engineering positioning, eval-story narrative. New items go to `implementation-plan.md`, not here. |
-| `docs/docs-guidance.md` | How to document APIs and long-form docs (covers both TS and PY) |
-| `docs/test-guidance.md` | How to write and organize tests (covers both TS and PY) |
-| `archive/docs/SESSION-graphrefly-spec-design.md` | Design history and migration from callbag-recharge |
-| `archive/docs/SESSION-reactive-collaboration-harness.md` | **Active** — 7-stage reactive collaboration loop (INTAKE→TRIAGE→QUEUE→GATE→EXECUTE→VERIFY→REFLECT), gate port from callbag-recharge, `promptNode` factory, `valve` rename, strategy model (`rootCause × intervention → successRate`), `harnessLoop()` factory. Source of truth for §9.0. |
-| `archive/docs/SESSION-DS-14.5-A-narrative-reframe.md` | **Active (canonical post-2026-05-04)** — spec-as-projection reframe, multi-agent subgraph ownership protocol (L0–L3 staircase), catalog reframed as user-host concern, Wave 2 narrative shift away from "harness builder". L1–L8 + Q1–Q10 locks. **Read this before editing README / Wave 2 launch copy.** |
-| `archive/docs/SESSION-DS-14-changesets-design.md` | **Active (locked 2026-05-05)** — universal `BaseChange<T>` envelope, `mutations` companion bundles, `mutate(act, opts)` factory, lifecycle-aware diff restore. Substrate for op-log changesets / worker-bridge wire B / `lens.flow` delta / `reactiveLog.scan` / `restoreSnapshot mode "diff"`. Source of truth for Phase 14 implementation. |
-| `archive/docs/SESSION-harness-engineering-strategy.md` | **SUPERSEDED 2026-05-04 by DS-14.5.A** for Wave 2 narrative framing. Original 8-requirement coverage analysis + harness engineering landscape preserved as historical context. New positioning lives in `SESSION-DS-14.5-A-narrative-reframe.md`. |
-| `archive/docs/SESSION-marketing-promotion-strategy.md` | **Active** — positioning pillars (pain-point-first), wave-based announcement plan, pain-point reply marketing playbooks, xiaohongshu strategy, Future AGI competitive intel (§16), prompt optimization algorithm analysis (§17), blog content plan (§18). Source of truth for public-facing copy. **Wave 2 framing should rebase on DS-14.5.A.** |
+# graphrefly-ts — agent context (TypeScript implementation)
+
+**GraphReFly** — reactive universal reduction layer (high fan-in/out → information reduction → push;
+not LLM-limited, D1). This repo is the **TypeScript implementation** (`@graphrefly/ts`): a
+self-contained package (substrate + sugar + operators), **no cross-language peer-deps** (D32).
+
+> **This file points, it does not host.** The language-neutral authority — protocol spec,
+> decisions, design sessions, conformance, formal model — lives in `~/src/graphrefly` (branch
+> `clean-slate`). When anything here disagrees with that repo, **that repo wins.** Do not
+> duplicate its content back into this file.
+
+## Authority — where the truth lives (`~/src/graphrefly`)
+
+Read `~/src/graphrefly/CLAUDE.md` first — it is the single-source index for the design.
+
+| Concern | Source of truth |
+|---|---|
+| **Decisions (why)** — unified D# log | `~/src/graphrefly/decisions/decisions.jsonl` (read via `/decision-guard`) |
+| **Design narrative** — full L0–L6 locks, F-* constraints, flags, spec-amendment list | `~/src/graphrefly/sessions/active/SESSION-clean-slate-redesign.md` (DS-1) |
+| **Protocol rules (宪法)** | `~/src/graphrefly/spec/rules.jsonl` (changed via `/spec-amend`) |
+| **Conformance scenarios (parity)** | `~/src/graphrefly/spec/conformance.jsonl` (driven via `/conformance`) |
+| **Formal model** | `~/src/graphrefly/formal/*.tla` (+ MC configs) |
+| **Sequencer (what next) / backlog / anti-patterns** | `~/src/graphrefly/plan/{phases,backlog,antipatterns}.jsonl` |
+| **Guides (composition / docs / test / contribute)** | `~/src/graphrefly/guide/guide.jsonl` |
+| **Rendered view** (progress / structure / gaps / search) | `~/src/graphrefly/dashboard/` (`node dashboard/build.mjs`) |
+
+Sibling implementations (each self-contained, cross-language = wire bridge, not in-process):
+`@graphrefly/rust` (`~/src/graphrefly-rs`), `@graphrefly/py` (`~/src/graphrefly-py`).
+
+## Clean-slate floor (cite, never violate — full text in DS-1 / `rules.jsonl`)
+
+- **Sacred (L0.7):** topology declarative/serializable/inspectable · wave protocol is a public spec ·
+  wave protocol impl is **sync** · all fn go through the dispatcher.
+- **8 verbs, closed set (D4):** `node` `graph` `batch` `state` + `producer` `derived` `effect` `mount`.
+  Operators are `node` sugar, not verbs — per-language, never in parity (D6).
+- **`ctx.up` / `ctx.down(msgs)` (D8):** one `msgs` array = one wave; may mix tiers. `ctx.up` is
+  **control-tier only** (DIRTY/PAUSE/RESUME/INVALIDATE/TEARDOWN); DATA/RESOLVED/COMPLETE/ERROR are
+  down-only (R-ctx-up). Handle = pure data `(pool_id, handle_id)`, no methods (D7).
+- **7-tier const table + 10-message closed set (D9/D34, R-tier/R-msg-closed-set):** adding a tier
+  or message type is a constitutional change.
+- **graph = single-thread causal/concurrency domain (D22):** parallelism via pool callback or
+  multi-graph + wire bridge; rewire intra-graph only.
+- **parity = behavioral conformance (D24):** structural `Impl` + cross-track-ledger retired.
+- **config dissolved (D26):** clock is graph-local (no global singleton); `messageTier` is a
+  compile-time const table; `onMessage`/`onSubscribe` are substrate-fixed, not user-replaceable (D19).
+- **Forced (F-*):** F-SYNC-CORE (async lives only in pools / wire-bridge) · F-DISPATCH-ALL (no
+  inline-fn bypass) · F-NO-IMPL-DEFINED (spec-locked or explicitly undefined) · F-NO-WEDGE-CUT ·
+  F-NO-LLM-ONLY · F-GRAPH-FIRST-API · F-PERF.
+
+Durable values (memory `feedback_*`): no backward compat (pre-1.0) · no imperative triggers ·
+single source of truth · **no autonomous decisions** (surface spec↔code conflicts, don't silently pick) ·
+no implement without explicit approval · verify premise before greenfield.
+
+## Workflow rules
+
+- **spec-first** (F-NO-IMPL-DEFINED): any protocol behavior change → amend `~/src/graphrefly`
+  `spec/rules.jsonl` + `formal/*.tla` + `spec/conformance.jsonl` **before** code (`/spec-amend`).
+- **decision-first**: any architectural lock → a `D#` in `~/src/graphrefly/decisions/decisions.jsonl`
+  before code (`/design-review` → user approval → append).
+- **consistency gate**: `node ~/src/graphrefly/dashboard/build.mjs --check` (non-zero on broken
+  links / orphans) after touching any spec/decision/plan jsonl.
 
 ## Commands
 
-**TypeScript (this repo) — post-Phase-13.9.A cleave:**
 ```bash
-pnpm test                  # pure-ts test suite + parity-tests
-pnpm test:pure-ts          # just packages/pure-ts (~2980 tests)
-pnpm test:parity           # just packages/parity-tests
-pnpm run lint              # biome check (workspace-wide)
-pnpm run lint:fix          # biome check --write
-pnpm run build             # pure-ts build → root shim build
-pnpm run build:shim        # only the shim (assumes pure-ts already built)
-pnpm bench                 # pure-ts vitest bench
+pnpm test          # full TS test suite
+pnpm run lint      # biome + layer/typecheck gates
+pnpm run lint:fix  # biome check --write
+pnpm run build     # build the package
+pnpm bench         # vitest bench (informational, not a CI gate — L5-Q1)
 ```
 
-For watch-mode work inside the pure-ts package: `pnpm --filter @graphrefly/pure-ts test:watch`.
+## Skills (clean-slate)
 
-**Python (`~/src/graphrefly-py`):**
-```bash
-uv run pytest                          # tests
-uv run ruff check src/ tests/         # lint
-uv run ruff check --fix src/ tests/   # lint fix
-uv run ruff format src/ tests/        # format
-uv run mypy src/                       # type check
-```
-
-Python workspace managed by mise. `mise trust && mise install` to set up uv. `uv sync` to install dependencies. Distribution name and import path: `graphrefly` (i.e. `pip install graphrefly` — the `graphrefly-py` name refers to the repo, not the published package).
-
-## Documentation workflow (critical)
-
-- `docs/docs-guidance.md` is the cross-language documentation standard.
-- `website/src/content/docs/api/*.md` is generated output. Do not hand-edit.
-- For API docs updates:
-  1. Update source JSDoc/docstrings.
-  2. Run docs generation in the respective repo (`pnpm --dir website docs:gen`).
-  3. Validate with `pnpm --dir website docs:gen:check` and `pnpm --dir website sync-docs:check`.
-- `llms.txt` is an AI index; keep it high-signal and avoid drift-prone, exhaustive inline API inventories.
-
-## Layout
-
-**TypeScript (`graphrefly-ts`) — cleave A executed 2026-05-15 (slices A1–A4); install-time model locked 2026-05-14:**
-
-Three published packages with an explicit substrate-vs-presentation split (see "Three-package install-time model" below). **Cleave A is DONE** — see `archive/docs/SESSION-DS-cleave-A-file-moves.md` for the file-move record + post-execution corrections.
-
-- Root `src/` — the **presentation package `@graphrefly/graphrefly`**. Post-cleave it owns the 4-layer structure (`base/ utils/ presets/ solutions/`) + `compat/`, and `src/index.ts` re-exports substrate from `@graphrefly/pure-ts` (peer) for ergonomic single-import UX. Substrate provider is chosen at install time: install `@graphrefly/pure-ts` (default) OR redirect to `@graphrefly/native` via npm/pnpm `overrides` (Q28 lock = option c). **⚠️ Native-drop-in NOT functional — RESOLVED 2026-05-15 as D206 (Option A + Option C follow-on).** The Q28/D198 overrides redirect does NOT work as written (`@graphrefly/native`'s napi surface is async-only — Core on a tokio blocking pool, sync calls deadlock per D070/D077 — while `@graphrefly/graphrefly` consumes pure-ts's sync API) and is **deferred pending D080**. Per **D206**: `@graphrefly/pure-ts` is the **sole working sync substrate** for `@graphrefly/graphrefly`; `@graphrefly/native` is an honest **async substrate** (`createNativeImpl()` wrapper shipped per Option C; bindings crate source at `0.1.0` per D265 hold-local — npm latest is `0.0.3` until the user-gated tag push triggers OIDC republish) + parity arm — **not** a sync drop-in for presentation via overrides; the async-everywhere presentation rebase (Option B / D080) stays deferred until consumer pressure. Canonical: `docs/rust-port-decisions.md` D206/D207 + `archive/docs/SESSION-DS-native-substrate-contract.md`. Legacy Phase-13.9.A shim folders (`src/{patterns,extra,core,graph,testing}/*`) were deleted — no backward-compat paths.
-- `packages/pure-ts/src/` — the **pure-TS substrate implementation**. Permanent first-class peer alongside `@graphrefly/native` (and a future `@graphrefly/wasm` if a consumer surfaces; see Unit 6 note below). Substrate-only post-cleave:
-  - `core/` — message protocol, `node` primitive, batch, sugar constructors (Phase 0). `core/_internal/` holds substrate-internal utilities (`ring-buffer`, `sizeof`, `timer`/`ResettableTimer`) used by `graph/` + reactive structures.
-  - `graph/` — `Graph` container, describe/observe, snapshot (Phase 1+)
-  - `extra/` — operators, sync sources, `sources/event/timer` (`fromTimer`), data structures, storage (Node tiers), `composition/{stratify,topology-diff,pubsub}`, `sources/async` (`fromPromise`/`fromAsyncIter`/`fromAny`), `sources/_keepalive`. **Substrate-vs-presentation classification per `extra/` row is locked in `~/src/graphrefly-rs/CLAUDE.md` § "extra/ row classification"; post-execution corrections to A1 doc Q4/Q7/Q8 are recorded in `archive/docs/SESSION-DS-cleave-A-file-moves.md`.**
-  - `patterns/`, `compat/` — **removed from pure-ts.** All `patterns/*` are presentation (D193) and now live in `@graphrefly/graphrefly` (root `src/{utils,presets}/`); `compat/*` moved to root `src/compat/`.
-- `packages/parity-tests/` — cross-impl parity scenarios (vitest `describe.each([pureTsImpl, rustImpl])` when a local `@graphrefly/native` `.node` is built or the published package is installed). See `packages/parity-tests/README.md` for the milestone registry + the "parity scenarios are the consumer pressure signal" rule (D196). **`packages/parity-tests/impls/types.ts` `Impl` interface IS the public-API contract** for the substrate peers (`@graphrefly/pure-ts` and `@graphrefly/native`) — widening it is a public API decision.
-- `packages/cli` — workspace consumer of `@graphrefly/graphrefly`. Imports presentation (e.g. `SurfaceError`) from the root package barrel; substrate flows through the root shim's `export * from "@graphrefly/pure-ts"`.
-
-### Three-package install-time model (Unit 6 D198, locked 2026-05-14)
-
-| Package | Contains | Build artifact | Substrate or presentation? |
-|---|---|---|---|
-| `@graphrefly/pure-ts` | Full TS implementation of the Rust-portable substrate: `core/`, `graph/`, `extra/operators/`, `extra/sources/sync` + `fromTimer`, `extra/data-structures/`, `extra/storage/` (Node tiers), `extra/composition/stratify`. | TS only — browser + Node | substrate |
-| `@graphrefly/native` | Rust impl of the same substrate via napi. Thin TS wrapper exposes the napi surface. | `.node` binary + TS wrapper | substrate (Node-only) |
-| `@graphrefly/graphrefly` | The parts that **never go to Rust**: `patterns/*`, `extra/io/*`, `extra/composition/*` (except `stratify`), `extra/mutation/*`, `extra/sources/event` (`fromEvent`, `fromRaf`), browser sources, graph-sugar (`graph.log/list/map/index`), `compat/*`. | TS only | presentation |
-
-```
-@graphrefly/graphrefly  ← presentation only
-       │  peerDependency: pick ONE substrate provider
-       ▼
-@graphrefly/pure-ts   OR   @graphrefly/native
-```
-
-Both substrate packages MUST expose the same public API — enforced by `packages/parity-tests/`. **No facade with runtime fallback**: the user picks at install time. Supersedes PART 13 Deferred 1's `optionalDependencies` facade plan. `@graphrefly/wasm` is deferred — adds when a browser-Rust consumer surfaces; until then `@graphrefly/pure-ts` is the universal fallback.
-
-Layering predicate that decides which package gets a new symbol lives in `~/src/graphrefly-rs/CLAUDE.md` § "Layering predicate — substrate vs presentation" (single source of truth, D193).
-
-### 4-layer model inside `@graphrefly/graphrefly` (Unit 8 D200, locked 2026-05-14)
-
-Strict top-down dependency layering (CI-enforced via `scripts/check-layer-boundary.ts`, wired into `pnpm lint`; D201 — mechanism amended 2026-05-15 from "Biome custom rule" to a zero-dep script since GritQL can't express rank comparison. Cleave-A layer-boundary residuals CLOSED 2026-05-15: `scripts/layer-boundary-baseline.json` baseline is now empty (`[]`) — the ratchet hard-fails ANY layer-boundary violation. Do not add baseline entries to silence new violations; fix the layering instead):
-
-| Layer | Charter | Examples |
-|---|---|---|
-| `base/` | **Domain-agnostic infrastructure.** Helpers with NO domain semantics. | io (http/ws/sse/webhook), composition helpers (verifiable, distill, pubsub, backpressure, externalProducer), mutation wrappers (lightMutation, auditLog), worker bridge, browser/runtime sources (fromEvent, fromRaf, fromGitHook, fromFSWatch), meta (domainMeta, keepalive) |
-| `utils/` | **Domain building blocks.** Single-purpose factories returning a `Node` or `Graph` (was consolidation-plan's "building blocks"). | messaging (topic, subscription, hub, topicBridge), orchestration (pipelineGraph, approvalGate, humanInput, tracker, classify, catch), cqrs, reduction, memory, ai/{prompts, agents, safety, extractors, adapters}, inspect, harness (stage types, evalSource, beforeAfterCompare) |
-| `presets/` | **Opinionated compositions of utils** (≥3 utils typically). Single-factory products. Vocabulary preserved from consolidation plan. | agentLoop, agentMemory, resilientPipeline, harnessLoop, refineLoop, spawnable, inspect (composite), guardedExecution, reactiveFactStore, taggedContextPool, heterogeneousDebate, actorPool |
-| `solutions/` | **User-facing packaged products.** Top-level barrel re-exports presets + per-vertical multi-preset starter kits (D202 = (c) both). | `solutions/index.ts` barrel re-exports; vertical folders (`solutions/customer-support-bot/`, `solutions/code-review-agent/`, etc.) deferred until consumer pressure |
-| `compat/` | External framework adapters (NestJS, React, Vue, Solid, Svelte, ag-ui translator, a2ui). | sits alongside the 4 layers; depends on solutions/presets/utils/base in top-down order |
-
-Dependency rules:
-
-```
-substrate (@graphrefly/pure-ts | @graphrefly/native)
-   ▲
-   │
-base/         (no domain semantics)
-   ▲
-   │
-utils/        (domain building blocks)
-   ▲
-   │
-presets/      (opinionated compositions of utils)
-   ▲
-   │
-solutions/    (user-facing packaged products)
-   ▲
-   │
-compat/       (external framework adapters)
-```
-
-Within a layer: free composition (e.g., `utils/orchestration/human-input.ts` may import `utils/messaging/topic.ts` — both utils). Cross-layer: strictly top-down. Circular within-layer rejected. Layer-placement rubric: "zero domain → base; single-domain primitive returning Node/Graph → utils; ≥3 utils composition → preset; ≥2 presets or full vertical with adapters/storage wiring → solution."
-
-Source: `archive/docs/SESSION-rust-port-layer-boundary.md` Units 6, 8 (user-locked 2026-05-14).
-
-### Browser / Node / Universal subpath convention (TS)
-
-Public TS APIs are split into three tiers so browser and Node consumers pull only runnable code:
-
-- **Universal default** (`@graphrefly/graphrefly`, `@graphrefly/graphrefly/extra`, `@graphrefly/graphrefly/utils/<domain>`) — browser + Node safe. Zero `node:*` imports, zero DOM globals.
-- **Node-only** (`@graphrefly/graphrefly/extra/node`, `@graphrefly/graphrefly/utils/<domain>/node`) — may import `node:*`. Use for `fileStorage`, `sqliteStorage`, `fromGitHook`, `fromFSWatch`, the node `fallbackAdapter` variant, etc.
-- **Browser-only** (`@graphrefly/graphrefly/extra/browser`, `@graphrefly/graphrefly/utils/<domain>/browser`) — may use DOM globals. Use for `indexedDbStorage`, `webllmAdapter`, `chromeNanoAdapter`, browser cascade presets.
-
-The build enforces this via `assertBrowserSafeBundles` in `packages/pure-ts/tsup.config.ts` `onSuccess` — any universal entry that transitively imports a Node builtin fails the build with a `via X → Y → Z` chain. Adding a new subpath requires updating BOTH `packages/pure-ts/tsup.config.ts` `ENTRY_POINTS` (+ `nodeOnlyEntries` when Node-only) AND `packages/pure-ts/package.json` `exports`, then mirroring the entry in the root shim (`tsup.config.ts` + `package.json` `exports` + a one-liner `src/<subpath>.ts`). See `docs/docs-guidance.md` § "Browser / Node / Universal split" for the full convention.
-
-**Python (`graphrefly-py`):**
-- `src/graphrefly/core/` — message protocol, `node` primitive, batch, sugar constructors (Phase 0)
-- `src/graphrefly/graph/` — `Graph` container, describe/observe, snapshot (Phase 1+)
-- `src/graphrefly/extra/` — operators, sources, data structures, resilience (Phase 2–3)
-- `src/graphrefly/patterns/` — domain-layer APIs: orchestration, messaging, memory, AI, CQRS, reactive layout (Phase 4+)
-- `src/graphrefly/compat/` — async runners: asyncio, trio (Phase 5+)
-- `src/graphrefly/integrations/` — framework integrations: FastAPI (Phase 5+)
-
-## Design invariants (spec §5.8–5.12)
-
-These are non-negotiable across all implementations. Validate every change against them.
-
-*Summary; canonical text in `~/src/graphrefly/GRAPHREFLY-SPEC.md` §5.8–5.12. Treat that as the authority if anything below disagrees.*
-
-1. **No polling.** State changes propagate reactively via messages. Never poll a node's value on a timer or busy-wait for status. Use reactive timer sources (`fromTimer`/`from_timer`, `fromCron`/`from_cron`) instead.
-2. **No imperative triggers.** All coordination uses reactive `NodeInput` signals and message flow through topology. No event emitters, callbacks, or `setTimeout`/`threading.Timer` + `set()` workarounds. If you need a trigger, it's a reactive source node.
-3. **No raw async primitives in the reactive layer.** TS: no bare `Promise`, `queueMicrotask`, `setTimeout`, or `process.nextTick`. PY: no bare `asyncio.ensure_future`, `asyncio.create_task`, `threading.Timer`, or raw coroutines. Async boundaries belong in sources (`fromPromise`/`from_awaitable`, `fromAsyncIter`/`from_async_iter`) and the runner layer, not in node fns or operators.
-4. **Central timer and `messageTier`/`message_tier` utilities.** TS: use `clock.ts` for all timestamps. PY: use `clock.py`. Use `messageTier`/`message_tier` utilities for tier classification — never hardcode type checks for checkpoint or batch gating.
-5. **Phase 4+ APIs must be developer-friendly.** Domain-layer APIs (orchestration, messaging, memory, AI, CQRS) use sensible defaults, minimal boilerplate, and clear errors. Protocol internals (`DIRTY`, `RESOLVED`, bitmask) never surface in primary APIs — accessible via `.node()` or `inner` when needed.
-
-## Time utility rule
-
-- **TS:** all timestamps go through `src/core/clock.ts`. Internal/event-order durations: `monotonicNs()`. Wall-clock attribution: `wallClockNs()`.
-- **PY:** same rule with `src/graphrefly/core/clock.py`. Functions: `monotonic_ns()` and `wall_clock_ns()`.
-
-## Auto-checkpoint trigger rule
-
-- For persistence auto-checkpoint behavior, gate saves by `messageTier`/`message_tier >= 3`.
-- Do not describe this as DATA/RESOLVED-only; terminal/teardown lifecycle tiers are included.
-
-## Debugging composition (mandatory procedure)
-
-When debugging OOM, infinite loops, silent failures, or unexpected values in composed factories, follow the **"Debugging composition"** section in `~/src/graphrefly/COMPOSITION-GUIDE.md`. That is the single source of truth for the procedure. Do not skip or improvise around it.
-
-## Dry-run equivalence rule
-
-**Dry-run must be behaviorally identical to the real run except for the actual LLM wire call.** Every observability surface the real run exercises — stage trace, budget stream, `graph.describe` (incl. `describe({ explain })` causal-chain mode), `observe`, stats readouts — must also be exercised in dry-run on the same graph topology. Regressions in `describe` / `describe({ explain })` / `observe` or in graph wiring must surface in dry-run BEFORE the user pays for a real run.
-
-When building an example or demo that has a dry-run path:
-- Construct the exact same graph as the real run; only the adapter differs (shipped `dryRunAdapter` or a shaped mock swapped in via `withDryRun`).
-- Call every inspection / explainability method the real run calls. If the real run prints a causal chain, so must dry-run. If the real run subscribes to `budget.totals`, so must dry-run (totals at zero is fine — presence is the point).
-- On regression, exit non-zero from dry-run with a diagnostic so the user sees the bug *before* the confirmation prompt.
-- Inspection tools to reach for first (all shipped — note: there is **no** `graph.explain()` method; causal chains are `describe({ explain })`, and formats are pure renderers over a describe snapshot, not a `describe({ format })` option): `graph.describe()` then render via `graphSpecToPretty` / `graphSpecToMermaid` / `graphSpecToD2` from `@graphrefly/graphrefly/extra/render`; `graph.describe({ explain: { from, to } })`; `graph.observe(path)`; `reachable(graph, from)`; `graphProfile(graph)`; `harnessProfile(graph)`. If you need a new inspection tool that isn't in this list, flag it in `docs/optimizations.md` as a library candidate before shipping ad-hoc scripts.
-
-## Python-specific invariants
-
-- **Thread safety:** Design for GIL and free-threaded Python. Per-subgraph `RLock`, per-node `_cache_lock`. Core APIs documented as thread-safe (see roadmap Phase 0.4).
-- **No `async def` / `Awaitable` in public APIs.** All public functions return `Node[T]`, `Graph`, `None`, or a plain synchronous value.
-- **Diamond resolution** via unlimited-precision Python `int` bitmask (TS uses `Uint32Array` + `BigInt` for fan-in >31).
-- **Context managers:** PY uses `with batch():` instead of TS's `batch(() => ...)`.
-- **`|` pipe operator:** PY `Node.__or__` maps to TS `pipe()`.
-
-## Claude skills (workflows)
-
-Project-local skills live under `.claude/skills/`. These skills operate on **both** TS and PY repos when relevant:
-
-- **dev-dispatch** — plan, align with spec, implement, self-test
-- **qa** — adversarial review, fixes, test + lint + build, doc touch-ups
-- **design-review** — Q5–Q9 design lens (abstraction, long-term shape, reactive composability, alternatives, coverage). Use BEFORE coding for new primitives; complementary to `/qa` (which finds bugs in landed code).
-- **parity** — cross-language parity check (TS vs PY)
+Project-local skills under `.claude/skills/`:
 
-Invoke via the user's Claude Code slash commands or skill names when relevant.
+- **decision-guard** — recall locked D#/values/floor before any decision question.
+- **spec-amend** — spec-first protocol amendment (rules + TLA+ + conformance, then code).
+- **conformance** — drive behavioral conformance scenarios green per runtime.
+- **dashboard** — build / check the `~/src/graphrefly` docs dashboard + consistency gate.
+- **dev-dispatch** — plan, align with spec, implement, self-test.
+- **qa** — adversarial review, fixes, test + lint + build, doc touch-ups.
+- **design-review** — Q5–Q9 design lens before coding new primitives.
diff --git a/README.md b/README.md
index fa404aca..3151645b 100644
--- a/README.md
+++ b/README.md
@@ -2,21 +2,20 @@
 
 **The reactive graph your code, your agents, and your humans share as a blueprint.** Compose in code, review the projected spec, co-edit across agents without colliding, trace every decision.
 
-GraphReFly is a reactive graph protocol for human + LLM co-operation. Code is the source of truth — `factoryTag`-stamped factories project automatically into a `GraphSpec` blueprint that humans and agents read, diff, and review together. Multi-agent worktrees claim subgraph ownership through a structural protocol (TTL → heartbeat → supervisor) so concurrent edits don't corrupt shared topology. Every decision has a causal chain — `graph.describe({ explain: { from, to } })` walks back through dependencies and tells you exactly why a value is what it is.
+GraphReFly is a reactive graph protocol for human + LLM co-operation. Code is the source of truth: build a graph, inspect its live structure with `topology()`, inspect runtime detail with `describe()`, observe message flow with `observe()`, and persist or restore explicit checkpoint data when you need lifecycle durability. Multi-agent and presentation-layer surfaces are being migrated onto the clean-slate TypeScript package; the protocol authority lives in `~/src/graphrefly`.
 
-[![npm](https://img.shields.io/npm/v/@graphrefly/graphrefly?color=blue)](https://www.npmjs.com/package/@graphrefly/graphrefly)
+[![npm](https://img.shields.io/npm/v/@graphrefly/ts?color=blue)](https://www.npmjs.com/package/@graphrefly/ts)
 [![license](https://img.shields.io/github/license/graphrefly/graphrefly-ts)](./LICENSE)
 
-[Docs](https://graphrefly.dev) | [Spec](https://graphrefly.dev/spec/) | [Python API](https://graphrefly.dev/py/api/) | [TS API Reference](https://graphrefly.dev/api/node/)
+[Docs](https://graphrefly.dev) | [Spec](https://graphrefly.dev/spec/) | [Python API](https://graphrefly.dev/py/api/) | [TS API Reference](https://graphrefly.dev/api/reactivelayout/)
 
 ## Packages
 
 | Package | What it is |
 |---|---|
-| [`@graphrefly/graphrefly`](https://www.npmjs.com/package/@graphrefly/graphrefly) | The library — presentation layer (IO, AI patterns, framework adapters) on top of a substrate provider you pick at install time. |
-| [`@graphrefly/pure-ts`](./packages/pure-ts) | Default substrate — pure-TypeScript implementation of `node` / `Graph` / operators / sources / storage. Universal (browser + Node), sync API. |
-| [`@graphrefly/native`](https://www.npmjs.com/package/@graphrefly/native) | Optional substrate — Rust implementation via napi-rs (Node-only, async API). Same `Impl` contract as `@graphrefly/pure-ts`, enforced by `packages/parity-tests/`. |
-| [`@graphrefly/cli`](./packages/cli) | Stateless command-line shell — `describe`, `explain`, `observe`, `reduce`, `snapshot` from your terminal or CI. |
+| [`@graphrefly/ts`](./packages/ts) | Clean-slate TypeScript implementation: substrate, graph, operators, sources, storage, render, testing, and data structures in one self-contained package. This is the current TS target. |
+| `@graphrefly/graphrefly` | Retired root package name. CSP-9/B65 removed active root implementation ownership; use `@graphrefly/ts` and its D125 subpaths. |
+| [`@graphrefly/pure-ts`](./packages/pure-ts) | Frozen read-only reference for old behavior and edge cases. It remains only until B66 can delete it. Do not add new development here. |
 
 ---
 
@@ -35,44 +34,43 @@ GraphReFly is a reactive graph protocol for human + LLM co-operation. Code is th
 ## Quick start
 
 ```bash
-npm install @graphrefly/graphrefly @graphrefly/pure-ts
+npm install @graphrefly/ts
 ```
 
 ```ts
-import { Graph, DATA } from "@graphrefly/graphrefly";
+import { graph } from "@graphrefly/ts";
 
-const g = new Graph("counter");
-const count = g.state<number>("count", 0);
-const doubled = g.derived("doubled", [count], ([c]) => c * 2);
+const g = graph({ name: "counter" });
+const count = g.state(0, { name: "count" });
+const doubled = g.derived([count], (c) => c * 2, { name: "doubled" });
 
-g.effect([doubled], ([d]) => console.log("doubled:", d));
+g.effect([doubled], (d) => console.log("doubled:", d));
 // → doubled: 0
 
-count.down([[DATA, 3]]);
+count.set(3);
 // → doubled: 6
 ```
 
 ## How it works
 
-Code is the source of truth. You compose a reactive graph using primitives (`state`, `derived`, `effect`, `producer`) and factories (`agentLoop`, `harnessLoop`, `agentMemory`, …). `factoryTag`-stamped factories carry self-description into the live graph. `graph.describe({ detail: "spec" })` projects the topology into a JSON `GraphSpec` blueprint — the same shape the original spec was written from, but always in sync with what's actually running. Spec is what your agents read to understand the topology. Code is what they (and you) actually edit.
+Code is the source of truth. In `@graphrefly/ts`, you compose a graph using the eight clean-slate verbs (`node`, `graph`, `batch`, `state`, `producer`, `derived`, `effect`, `mount`) plus operator factories. `graph.topology()` returns a live, JSON-serializable pure-structure snapshot; `graph.describe()` returns the richer developer inspection snapshot; `graph.observe()` is read-only message egress; `graph.profile()` is opt-in and dispatcher-backed.
 
-The graph runs persistently, checkpoints state on `messageTier ≥ 3` and topology on `_topologyVersion` bump, and traces every decision through a causal chain. Ask "why?" at any point — `graph.describe({ explain: { from, to } })` walks backward through dependencies and returns a structured chain that's both human-readable and LLM-parseable.
+The graph core is synchronous. Async work lives at source, pool, storage, or wire-bridge boundaries; user functions route through the dispatcher; DATA moves through messages, not hidden cache peeks.
 
-## Substrate coverage
+## Migration Status
 
-The eight requirements of a production agent system cluster into a handful of composed blocks that sit on top of the reactive graph primitives:
+`@graphrefly/ts` already re-derived most of the old `pure-ts/extra` surface under clean-slate semantics:
 
-| Need | GraphReFly |
+| Area | Status |
 |---|---|
-| Context & state | `persistentState()` — `autoCheckpoint` + `snapshot` / `restore` + incremental diff |
-| Agent memory | `agentMemory()` — `distill` + vectors + knowledge graph + tiers, OpenViking decay |
-| Control flow & resilience | `resilientPipeline()` — `rateLimiter → breaker → retry → timeout → fallback`, correct ordering built in |
-| Execution & policy | `guardedExecution()` — Actor / Guard ABAC + `policy()` + `budgetGate` + scoped describe |
-| Observability & causality | `graphLens()` — reactive topology, health, flow, and `why(node)` causal chains as structured data |
-| Human governance | `pipelineGraph().approvalGate(...)` and `humanInput(...)` — reactive `pending` / `isOpen` with `approve` / `reject` / `modify(fn, n)` |
-| Verification | Multi-model eval harness with regression gates |
-| Continuous improvement | Strategy model: `rootCause × intervention → successRate` |
-| Multi-agent coordination | `ownershipController()` — L0 static / L1 TTL / L2 heartbeat / L3 supervisor staircase; `Actor / Guard ABAC` enforces claims at write time; `validateOwnership` lints PR diffs |
+| Operators | Present: transform, combine, buffer, higher-order, time, control, and error families. Old `window/windowCount/windowTime` are intentionally not ported by the D58 clean-slate decision; use array buffer forms and derived views. |
+| Sources | Present: sync values/iterables, promises, async iterables, events, timers, push notifications, and Node fs watch. |
+| Data structures | Present: `reactiveMap`, `reactiveList`, `reactiveIndex`, `reactiveLog`, `ReactiveView`, and `reactiveCascadingCache`. |
+| Storage | Present as passive helpers: KV, append log, versioned KV, read-through, content-addressed storage, observe-event logs, WAL frame codecs, browser/node backends. Old graph-owned `attachSnapshotStorage` / `restoreSnapshot` convenience APIs are retired; graph restore is `restoreGraph(checkpoint, { registry })`. |
+| Render/inspection | Present: describe renderers, diagnostics, observe filters, profile. Old fake live-topology streams are not restored; D118 keeps `describe()` as a snapshot until real topology-event egress exists. |
+| Presentation | The old root `src/` implementation is retired. Remaining legacy consumers are tracked through B64/B66: archived historical docs, design-gated demos, and legacy recipe/comparison pages. |
+
+So the old `pure-ts` reference is still useful for edge cases and product memory, but the remaining work is no longer "copy the extras layer." It is mainly entrypoint cleanup, presentation rebasing, and explicit decisions for old shapes that conflict with the clean-slate floor.
 
 The library computes structured facts reactively; LLMs and UIs render them. Natural language is never the library's job — which keeps the whole stack model-agnostic and testable.
 
@@ -97,187 +95,118 @@ The library computes structured facts reactively; LLMs and UIs render them. Natu
 Everything is a `node`. Register them on a `Graph` for introspection and let its sugar methods give you the right shape:
 
 ```ts
-import { Graph, DATA, pipe, delay, map } from "@graphrefly/graphrefly";
+import { fromTimer, graph, initNode, map } from "@graphrefly/ts";
 
-const g = new Graph("hello");
+const g = graph({ name: "hello" });
 
 // Writable state
-const name = g.state<string>("name", "world");
+const name = g.state("world", { name: "name" });
 
 // Computed (re-runs when deps change)
-const greeting = g.derived("greeting", [name], ([n]) => `Hello, ${n}!`);
+const greeting = g.derived([name], (n) => `Hello, ${n}!`, { name: "greeting" });
 
 // Push source (timers, events, async streams)
-const clock = g.producer<number>("clock", (emit) => {
-  const id = setInterval(() => emit([[DATA, Date.now()]]), 1000);
-  return () => clearInterval(id);
-});
+const clock = g.initNode(fromTimer(1000), [], { name: "clock" });
 
 // Side effect
-g.effect([greeting], ([s]) => { document.title = s; });
+g.effect([greeting], (s) => { document.title = s; });
 
-// Operator pipeline (off-Graph composition)
-const delayed = pipe(clock, delay(500), map((ts) => new Date(ts as number)));
+// Operator node
+const delayed = initNode(map((ts: number) => new Date(ts)), [clock]);
 ```
 
 ## Streaming & operators
 
-70+ operators — transform, combine, buffer, window, rate-limit, retry, circuit-break:
+Operators are free-standing factories. Instantiate them with `g.initNode(op, deps, opts)` for graph-owned inspection, or with the free `initNode(op, deps)` helper for bare nodes:
 
 ```ts
-import { pipe, merge, switchMap, debounceTime, retry } from "@graphrefly/graphrefly";
-
-const search = pipe(
-  input,
-  debounceTime(300),
-  switchMap((query) => fromPromise(fetch(`/api?q=${query}`))),
-  retry({ strategy: "exponential", maxAttempts: 3 }),
+import { debounceTime, fromPromise, graph, switchMap } from "@graphrefly/ts";
+
+const g = graph();
+const input = g.state("");
+const debounced = g.initNode(debounceTime(300), [input], { name: "debounced" });
+const results = g.initNode(
+  switchMap((query: string) => g.initNode(fromPromise(fetch(`/api?q=${query}`)), [])),
+  [debounced],
+  { name: "results" },
 );
 ```
 
 ## Graph container
 
-`Graph` is the introspection / snapshot / persistence container. Use its sugar methods to register nodes by name:
+`Graph` is the introspection / checkpoint / lifecycle container. Use its sugar methods to register nodes by name:
 
 ```ts
-import { Graph } from "@graphrefly/graphrefly";
-import { graphSpecToMermaid } from "@graphrefly/graphrefly/base/render";
-
-const g = new Graph("pricing");
-const price = g.state<number>("price", 100);
-const tax   = g.derived("tax",   [price],      ([p]) => p * 0.1);
-const total = g.derived("total", [price, tax], ([p, t]) => p + t);
-
-const spec = g.describe();                              // → full graph topology as JSON
-const why  = g.describe({ explain: { from: "price", to: "total" } });
-const mmd  = graphSpecToMermaid(spec);                  // → Mermaid diagram string
-const off  = g.observe((e) => console.log(e));          // → live change stream
-```
+import { describeToMermaid, graph } from "@graphrefly/ts";
 
-## AI & orchestration
+const g = graph({ name: "pricing" });
+const price = g.state(100, { name: "price" });
+const tax = g.derived([price], (p) => p * 0.1, { name: "tax" });
+g.derived([price, tax], (p, t) => p + t, { name: "total" });
 
-First-class patterns for LLM streaming, agent loops, and human-in-the-loop workflows:
-
-```ts
-import { chatStream, agentLoop, toolRegistry } from "@graphrefly/graphrefly";
-
-// Streaming chat with tool use
-const chat = chatStream("assistant", {
-  model: "claude-sonnet-4-20250514",
-  tools: toolRegistry("tools", { search, calculate }),
-});
-
-// Full agent loop: observe → think → act → memory
-const agent = agentLoop("researcher", {
-  llm: chat,
-  memory: agentMemory({ decay: "openviking" }),
-});
-```
-
-## Framework adapters
-
-Drop-in bindings — your framework, your way:
-
-```tsx
-// React
-import { useNode } from "@graphrefly/graphrefly/compat/react";
-const [value, setValue] = useNode(count);
-
-// Vue
-import { useNode } from "@graphrefly/graphrefly/compat/vue";
-const value = useNode(count);  // → Ref<number>
-
-// Svelte
-import { toStore } from "@graphrefly/graphrefly/compat/svelte";
-const value = toStore(count);  // → Svelte store
-
-// Solid
-import { useNode } from "@graphrefly/graphrefly/compat/solid";
-const value = useNode(count);  // → Signal<number>
-
-// NestJS
-import { GraphReflyModule } from "@graphrefly/graphrefly/compat/nestjs";
-@Module({ imports: [GraphReflyModule.forRoot()] })
+const snapshot = g.describe();
+const topology = g.topology();
+const mmd = describeToMermaid(snapshot);
+const off = g.observe().subscribe((event) => console.log(event));
 ```
 
 ## Tree-shaking imports
 
-The root `@graphrefly/graphrefly` barrel re-exports everything (substrate + 4-layer presentation + compat):
+Use `@graphrefly/ts` subpaths for clean-slate bundles:
 
 ```ts
-import { node, Graph, map, switchMap, agentLoop } from "@graphrefly/graphrefly";
-```
+import { batch, node } from "@graphrefly/ts/core";
+import { map, switchMap } from "@graphrefly/ts/operators";
+import { graph } from "@graphrefly/ts/graph";
+import { memoryKv } from "@graphrefly/ts/storage";
 
-For minimal bundle, import substrate symbols from `@graphrefly/pure-ts` (universal — browser + Node safe) and presentation symbols from the matching `@graphrefly/graphrefly/<layer>` subpath:
+// Node-only helpers
+import { fromFSWatch } from "@graphrefly/ts/sources/node";
+import { fileKv, sqliteKv } from "@graphrefly/ts/storage/node";
 
-```ts
-// Substrate (sync, universal)
-import { node, batch, DATA } from "@graphrefly/pure-ts/core";
-import { map, switchMap }     from "@graphrefly/pure-ts/extra/operators";
-import { Graph }              from "@graphrefly/pure-ts/graph";
-
-// Node-only substrate extras (file IO, sqlite, fs watch, …)
-import { fileKv, sqliteKv } from "@graphrefly/pure-ts/extra/storage/node";
-
-// Presentation: pick the right layer (base / utils / presets / solutions / compat)
-import { agentMemory } from "@graphrefly/graphrefly/presets/ai";
-import { graphSpecToMermaid } from "@graphrefly/graphrefly/base/render";
-import { useNode } from "@graphrefly/graphrefly/compat/react";
+// Browser-only helpers
+import { indexedDbKv } from "@graphrefly/ts/storage/browser";
 ```
 
 ## Resilience & checkpoints
 
-Built-in retry, circuit breakers, rate limiters, and persistent storage:
+Clean-slate storage is passive. It can store facts, frames, checkpoints, and observe-event logs, but it does not own graph restore semantics:
 
 ```ts
-import { retry, circuitBreaker, memoryKv, kvStorage } from "@graphrefly/graphrefly";
-import { fileKv } from "@graphrefly/graphrefly/extra/node";
+import { defaultRestoreRegistry, graph, memoryKv, restoreGraph } from "@graphrefly/ts";
 
-// Retry with exponential backoff
-const resilient = pipe(source, retry({ strategy: "exponential" }));
+const g = graph({ name: "pricing" });
+const price = g.state(100, { name: "price", restore: { ref: "state" } });
+const checkpoint = g.checkpoint();
 
-// Circuit breaker
-const breaker = circuitBreaker({ threshold: 5, resetTimeout: 30_000 });
-
-// Multi-tier snapshot storage: hot in-memory + warm on disk.
-graph.attachSnapshotStorage(
-  [kvStorage(memoryKv()), kvStorage(fileKv("./checkpoints"))],
-  { autoRestore: true },
-);
+await memoryKv().put("checkpoint:pricing", checkpoint);
+const restored = restoreGraph(checkpoint, { registry: defaultRestoreRegistry });
 ```
 
 ## Project layout
 
-Substrate vs presentation cleaved 2026-05-15 (Cleave A / D193 + D198 install-time model). The root `src/` is the **presentation** package; the **substrate** lives in `packages/pure-ts/`.
+Clean-slate TS lives in `packages/ts`. The old root presentation implementation has been removed from active ownership; `packages/pure-ts` remains frozen until B66 can delete it.
 
 | Path | Contents |
 |------|----------|
-| `packages/pure-ts/src/core/` | Message protocol, `node` primitive, batch, Actor, policy, central clock (substrate) |
-| `packages/pure-ts/src/graph/` | `Graph` container, describe/observe, snapshot, persistence (substrate) |
-| `packages/pure-ts/src/extra/` | Operators, sync sources, data structures, storage tiers (substrate) |
-| `packages/parity-tests/` | Cross-impl parity scenarios — `describe.each([pureTsImpl, rustImpl])` over both substrate peers |
-| `packages/cli/` | `@graphrefly/cli` — stateless command-line shell |
-| `src/base/` | Domain-agnostic infrastructure (IO, composition, mutation, render, worker, sources) |
-| `src/utils/` | Domain building blocks (messaging, orchestration, memory, ai, resilience, cqrs, harness, …) |
-| `src/presets/` | Opinionated compositions (agentLoop, agentMemory, resilientPipeline, harnessLoop, …) |
-| `src/solutions/` | User-facing packaged products |
-| `src/compat/` | Framework adapters (React, Vue, Svelte, Solid, NestJS, Jotai, Zustand, Nanostores, Signals) |
-| `docs/` | Implementation plan, decisions, cross-track ledger, optimizations, benchmarks |
+| `packages/ts/src/` | Clean-slate TS package: substrate, graph, operators, sources, storage, render, data structures, testing |
+| `packages/pure-ts/` | Frozen read-only reference and temporary legacy-consumer dependency |
+| `archive/packages/parity-tests/` | Archived old structural parity-test package; clean-slate parity is behavioral conformance in `~/src/graphrefly/spec/conformance.jsonl` |
+| `~/src/graphrefly` | Language-neutral authority: decisions, rules, conformance, formal model, sequencer |
 | `website/` | Astro + Starlight docs site ([graphrefly.dev](https://graphrefly.dev)) |
 
-Layer boundary (`base → utils → presets → solutions → compat`) is CI-enforced via `scripts/check-layer-boundary.ts` (D201). The Rust port lives in `~/src/graphrefly-rs/`; cross-track changes are logged in `docs/cross-track-ledger.md`.
+The Rust and Python sibling implementations are self-contained packages in `~/src/graphrefly-rs` and `~/src/graphrefly-py`; cross-language parity is conformance behavior, not old symbol-set parity.
 
 ## Scripts
 
 ```bash
-pnpm test            # pure-ts tests + parity scenarios
-pnpm test:pure-ts    # just packages/pure-ts (~3000 tests)
-pnpm test:parity     # just packages/parity-tests
-pnpm run lint        # biome check + layer-boundary + tsc --noEmit on parity-tests/evals
+pnpm test            # clean-slate TS test suite
+pnpm test:ts         # clean-slate TS test suite
+pnpm run lint        # biome check + clean-slate no-raw-async + active package typecheck gate
 pnpm run lint:fix    # biome --write
-pnpm run build       # pure-ts build → root shim build
-pnpm run build:shim  # only the root shim (assumes pure-ts already built)
-pnpm bench           # pure-ts vitest bench
+pnpm run build       # @graphrefly/ts build
+pnpm bench           # clean-slate TS B49 probe
+pnpm probe:b49:ts    # clean-slate TS perf probe
 ```
 
 ## Acknowledgments
diff --git a/apps/rn-hermes-fixture/App.tsx b/apps/rn-hermes-fixture/App.tsx
index baa1ed39..1540b734 100644
--- a/apps/rn-hermes-fixture/App.tsx
+++ b/apps/rn-hermes-fixture/App.tsx
@@ -1,5 +1,5 @@
 /**
- * On-device RN/Hermes spike screen for @graphrefly/pure-ts
+ * On-device RN/Hermes spike screen for @graphrefly/ts
  * (graphrefly-ts#4). This is the PERIODIC tier: real Hermes VM + RN
  * polyfills, exercised via `expo run:ios` (dev) and
  * `expo run:ios --configuration Release` (Hermes bytecode).
@@ -10,35 +10,22 @@
  * both. Renders a PASS/FAIL banner so a single screenshot confirms
  * the run; mirrors to console for device logs.
  */
-import { DATA, node } from "@graphrefly/pure-ts";
+import type { Node } from "@graphrefly/ts/core";
+import { type Graph, graph } from "@graphrefly/ts/graph";
 import { useEffect, useState } from "react";
 import { Platform, ScrollView, Text, View } from "react-native";
 
-const mkState = (initial: unknown) => node([], undefined, { initial } as never);
+const mkState = (g: Graph, initial: unknown) => g.state(initial);
 
-const mkDerived = (deps: ReadonlyArray<unknown>, compute: (...a: unknown[]) => unknown) =>
-	node(
-		deps as never,
-		((
-			data: ReadonlyArray<ReadonlyArray<unknown> | undefined>,
-			actions: { emit: (v: unknown) => void },
-			ctx: { prevData: ReadonlyArray<unknown> },
-		) => {
-			const args = deps.map((_, i) => {
-				const b = data[i];
-				return b?.length ? b[b.length - 1] : ctx.prevData[i];
-			});
-			actions.emit(compute(...args));
-		}) as never,
-	);
+const mkDerived = (
+	g: Graph,
+	deps: ReadonlyArray<Node<unknown>>,
+	compute: (...a: unknown[]) => unknown,
+) => g.derived(deps, (...args) => compute(...args));
 
-const onData = (n: unknown, cb: (v: unknown) => void) =>
-	(
-		n as {
-			subscribe: (s: (m: ReadonlyArray<ReadonlyArray<unknown>>) => void) => () => void;
-		}
-	).subscribe((msgs) => {
-		for (const m of msgs) if (m[0] === DATA) cb(m[1]);
+const onData = (n: Node<unknown>, cb: (v: unknown) => void) =>
+	n.subscribe((msg) => {
+		if (msg[0] === "DATA") cb(msg[1]);
 	});
 
 function runSpike(): { pass: boolean; lines: string[] } {
@@ -55,22 +42,23 @@ function runSpike(): { pass: boolean; lines: string[] } {
 	};
 
 	try {
-		const a = mkState(1);
-		const b = mkState(2);
-		const sum = mkDerived([a, b], (x, y) => (x as number) + (y as number));
+		const g = graph();
+		const a = mkState(g, 1);
+		const b = mkState(g, 2);
+		const sum = mkDerived(g, [a, b], (x, y) => (x as number) + (y as number));
 		const sumSeen: unknown[] = [];
 		onData(sum, (v) => sumSeen.push(v));
-		(a as { emit: (v: unknown) => void }).emit(10);
-		(b as { emit: (v: unknown) => void }).emit(20);
+		a.set(10);
+		b.set(20);
 		expect("block1 sum emissions", sumSeen, [3, 12, 30]);
 
-		const a2 = mkState(1);
-		const b2 = mkDerived([a2], (x) => (x as number) * 2);
-		const c2 = mkDerived([a2, b2], (x, y) => (x as number) + (y as number));
+		const a2 = mkState(g, 1);
+		const b2 = mkDerived(g, [a2], (x) => (x as number) * 2);
+		const c2 = mkDerived(g, [a2, b2], (x, y) => (x as number) + (y as number));
 		const c2Seen: unknown[] = [];
 		onData(c2, (v) => c2Seen.push(v));
 		const before = c2Seen.length;
-		(a2 as { emit: (v: unknown) => void }).emit(5);
+		a2.set(5);
 		expect("block2 c2 initial", c2Seen.slice(0, before), [3]);
 		expect("block2 c2 after set==5 (ONCE, not twice)", c2Seen.slice(before), [15]);
 	} catch (err) {
@@ -91,8 +79,11 @@ function runSpike(): { pass: boolean; lines: string[] } {
 		const rp = hermes.getRuntimeProperties();
 		log(`hermes bytecode v: ${rp["Bytecode Version"]} build: ${rp.Build ?? "?"}`);
 	}
-	const rnv = (Platform.constants as { reactNativeVersion?: Record<string, number> })
-		.reactNativeVersion;
+	const rnv = (
+		Platform.constants as unknown as {
+			reactNativeVersion?: { major: number; minor: number; patch: number };
+		}
+	).reactNativeVersion;
 	log(
 		`RN ${rnv ? `${rnv.major}.${rnv.minor}.${rnv.patch}` : "?"} / ${Platform.OS} ${Platform.Version}`,
 	);
@@ -133,7 +124,7 @@ export default function App() {
 					{r == null ? "running…" : pass ? "PASS ✅" : "FAIL ❌"}
 				</Text>
 				<Text style={{ color: "#cde", fontSize: 13, marginTop: 4 }}>
-					graphrefly-ts#4 · pure-ts 0.45.0 · Expo SDK 55 / RN 0.83.6
+					graphrefly-ts#4 · @graphrefly/ts · Expo SDK 55 / RN 0.83.6
 				</Text>
 			</View>
 			<ScrollView style={{ flex: 1, padding: 12 }}>
diff --git a/apps/rn-hermes-fixture/CHANGELOG.md b/apps/rn-hermes-fixture/CHANGELOG.md
index f3f1e2cf..cbe5e1a5 100644
--- a/apps/rn-hermes-fixture/CHANGELOG.md
+++ b/apps/rn-hermes-fixture/CHANGELOG.md
@@ -5,46 +5,46 @@
 ### Patch Changes
 
 - Updated dependencies [[`4230039`](https://github.com/graphrefly/graphrefly-ts/commit/4230039498f97be2d5213d76cb8ce8f72a073b9a)]:
-  - @graphrefly/pure-ts@0.49.0
+  - legacy pure TS reference 0.49.0
 
 ## 0.0.6
 
 ### Patch Changes
 
 - Updated dependencies []:
-  - @graphrefly/pure-ts@0.48.1
+  - legacy pure TS reference 0.48.1
 
 ## 0.0.5
 
 ### Patch Changes
 
 - Updated dependencies [[`cfb1500`](https://github.com/graphrefly/graphrefly-ts/commit/cfb1500250504391683557a0b75cec381ca8e201), [`9b3554b`](https://github.com/graphrefly/graphrefly-ts/commit/9b3554b659ccb5aaf1f45dbd1ed933129d691171)]:
-  - @graphrefly/pure-ts@0.48.0
+  - legacy pure TS reference 0.48.0
 
 ## 0.0.4
 
 ### Patch Changes
 
 - Updated dependencies [[`fda9432`](https://github.com/graphrefly/graphrefly-ts/commit/fda94326c6656c27008c2733f305a5c077f8ff09)]:
-  - @graphrefly/pure-ts@0.47.2
+  - legacy pure TS reference 0.47.2
 
 ## 0.0.3
 
 ### Patch Changes
 
 - Updated dependencies [[`76d35c7`](https://github.com/graphrefly/graphrefly-ts/commit/76d35c73eb84a2871ac34907a10a0514674745ca)]:
-  - @graphrefly/pure-ts@0.47.1
+  - legacy pure TS reference 0.47.1
 
 ## 0.0.2
 
 ### Patch Changes
 
 - Updated dependencies [[`36ff7df`](https://github.com/graphrefly/graphrefly-ts/commit/36ff7df3e4fd843ce630ad388921ff33e64a37e1), [`f08b7cf`](https://github.com/graphrefly/graphrefly-ts/commit/f08b7cf8b62ad522a1da5c4664ef719e19e5d7f0)]:
-  - @graphrefly/pure-ts@0.47.0
+  - legacy pure TS reference 0.47.0
 
 ## 0.0.1
 
 ### Patch Changes
 
 - Updated dependencies [[`23c1eba`](https://github.com/graphrefly/graphrefly-ts/commit/23c1eba88c55be7ab925eaf8b704bc6604a0ec57)]:
-  - @graphrefly/pure-ts@0.46.0
+  - legacy pure TS reference 0.46.0
diff --git a/apps/rn-hermes-fixture/metro.config.js b/apps/rn-hermes-fixture/metro.config.js
index 4a8c2dba..5c27aae1 100644
--- a/apps/rn-hermes-fixture/metro.config.js
+++ b/apps/rn-hermes-fixture/metro.config.js
@@ -1,5 +1,5 @@
 // Expo + pnpm monorepo: watch the workspace root and resolve
-// @graphrefly/pure-ts (a workspace package, symlinked) with its
+// @graphrefly/ts (a workspace package, symlinked) with its
 // `exports` map so Metro picks the ESM `import` condition.
 const { getDefaultConfig } = require("expo/metro-config");
 const path = require("node:path");
diff --git a/apps/rn-hermes-fixture/package.json b/apps/rn-hermes-fixture/package.json
index 019b1ec8..eaeae8ee 100644
--- a/apps/rn-hermes-fixture/package.json
+++ b/apps/rn-hermes-fixture/package.json
@@ -2,7 +2,7 @@
 	"name": "@graphrefly/rn-hermes-fixture",
 	"version": "0.0.7",
 	"private": true,
-	"description": "Periodic on-device RN/Hermes verification for @graphrefly/pure-ts (graphrefly-ts#4). Expo SDK 55 official matrix (RN 0.83.6). Real Hermes VM + RN polyfills, dev + release/bytecode. The per-commit faithful compile gate lives in scripts/hermes-smoke.",
+	"description": "Periodic on-device RN/Hermes verification for @graphrefly/ts (graphrefly-ts#4). Expo SDK 55 official matrix (RN 0.83.6). Real Hermes VM + RN polyfills, dev + release/bytecode. The per-commit faithful compile gate lives in scripts/hermes-smoke.",
 	"main": "index.ts",
 	"scripts": {
 		"start": "expo start --dev-client",
@@ -13,7 +13,7 @@
 		"bundle:check": "expo export --platform ios --output-dir .export-check --clear"
 	},
 	"dependencies": {
-		"@graphrefly/pure-ts": "workspace:*",
+		"@graphrefly/ts": "workspace:*",
 		"expo": "^55.0.0",
 		"expo-status-bar": "~3.0.0",
 		"react": "19.2.0",
diff --git a/archive/docs/SESSION-agentic-memory-research.md b/archive/docs/SESSION-agentic-memory-research.md
index 439e6766..d52233ed 100644
--- a/archive/docs/SESSION-agentic-memory-research.md
+++ b/archive/docs/SESSION-agentic-memory-research.md
@@ -7,6 +7,8 @@ ORIGIN: Adapted from callbag-recharge research (~/src/callbag-recharge/src/archi
 
 > **2026-05-13 update — superseded for substrate design by [SESSION-DS-14.7-reactive-fact-store.md](SESSION-DS-14.7-reactive-fact-store.md) (LOCKED).** Triggered by Hassabis YC × DeepMind Startup School talk (2026-04-29, continual learning + REM-replay framing) + MEME paper ([arXiv:2605.12477](https://arxiv.org/abs/2605.12477), Cascade L2 = 3% / Absence L3 = 1% on default config across 6 systems). DS-14.7 formalizes the static-topology `reactiveFactStore<T>()` pattern that supplies the MEME L2/L3 + continual-learning substrate, superseding Part 6 "Second Half" §"opportunity #1" (outcome-feedback gap). The SOTA landscape + four advanced write strategies below remain the canonical research record.
 
+> **2026-06-08 clarification — agentic memory remains a deep solution vertical, not the substrate identity.** Follow-up research on agentic-memory commentary (RAG/vector/file memory limits, INTRA-style internal retrieval, CogniFold-style proactive memory, and biological dynamic-memory analogies) sharpens the positioning: GraphReFly core is still the horizontal reactive universal reduction layer from DS-1, not a memory-only framework or pre-1.0 wedge. However, this session plus DS-14.7 form a substantive agentic-memory vertical. The correct public framing is: **GraphReFly is not a memory database; it is a reactive substrate for dynamic agent memory.** The vertical's differentiated claim is dynamic memory maintenance: facts, provenance, decay, invalidation, retrieval views, and outcome feedback are modeled as inspectable graph flow, so memory changes propagate instead of sitting frozen until the next top-k search. This vertical does NOT solve parametric / biological / LoRA-style in-weight memory, and it does NOT make LLM extraction truthful by itself; it fills the engineering gap between static external RAG and still-distant model-internal dynamic memory.
+
 ## KEY DISCUSSION
 
 ### Goal
diff --git a/archive/docs/SESSION-graphrefly-canvas-data-query-wedge.md b/archive/docs/SESSION-graphrefly-canvas-data-query-wedge.md
new file mode 100644
index 00000000..ac4ed25c
--- /dev/null
+++ b/archive/docs/SESSION-graphrefly-canvas-data-query-wedge.md
@@ -0,0 +1,706 @@
+---
+SESSION: graphrefly-canvas-data-query-wedge
+DATE: 2026-06-04
+TOPIC: Discussion-capture (NOT a decision session). Reconnects the prior GraphReFly Canvas /
+  Workbench product vision with the Data Agent / Data Query wedge surfaced by a Xiaohongshu post
+  about enterprise data agents. The result is a product framing: GraphReFly Canvas is the mother
+  product; Trusted Data Query is the first professional paid wedge. No substrate, protocol, or
+  package-boundary decision is made here.
+REPO: graphrefly-ts
+STATUS: DISCUSSION CAPTURE ONLY. This document captures product strategy and solution-layer shape.
+  Anything that would add a primitive, change the 8-verb floor, change the wave protocol, or lock
+  a new package/API requires the normal /design-review -> user approval -> decision log path.
+---
+
+## CONTEXT
+
+The user pointed out that the assistant's initial "Data Agent" framing had lost an important
+earlier product thread: GraphReFly as the engine under a web application similar in surface to n8n,
+but with a different center of gravity.
+
+Prior product thread, as recalled by the user:
+
+- **GraphReFly Canvas / Workbench** is a separate product or host built on GraphReFly as the bottom
+  engine, not a protocol change to GraphReFly itself.
+- The product has at least two visible layers: a **UI layer** and a **code/spec layer**. The missing
+  middle, and the reason GraphReFly matters, is the live topology layer between them.
+- Commodity surfaces can be rented or reused: page/canvas editors, chat UI, code sandbox, workflow
+  canvas, generated UI renderers, and app-store-like registry surfaces. The non-commodity asset is
+  the binding chain between presentation, boundary nodes, GraphSpec/code, and the reactive runtime.
+- Plugin strategy has a clean divide: plugging into builders that already own the workflow engine
+  demotes GraphReFly into one node; plugging into distribution or UI surfaces can preserve
+  GraphReFly as the engine but hides some moat. The more durable path is an independent or
+  embeddable workbench/canvas whose value is the inspectable topology and code escape hatch.
+- Forkable workbench unit = GraphSpec + presentation JSON + capability manifest, not user data.
+  Users fork logic, connect their own accounts, and keep private data at their own boundaries.
+- Web-first remains plausible for many wedges: OPFS/local storage, optional local inference, thin
+  relay for notifications, premium cloud for offline or heavy work. Native is a later pro/local
+  upgrade, not the assumed first surface.
+
+The new trigger was a Xiaohongshu post/comment cluster about enterprise Data Agents. Its useful
+thesis: enterprise data-agent failure is usually not SQL syntax generation; it is business semantics,
+metric definitions, stale schema/context, entity ambiguity, retrieval misses, and insufficient
+verification. The user connected this to GraphReFly: data retrieval and transformation are fragile
+step-by-step processes; each step should be explicit, explainable, locally repairable, and
+verifiable; once stabilized, an ad-hoc query can become ETL-like reusable work.
+
+This document captures the synthesis:
+
+> **GraphReFly Canvas is the mother product; Trusted Data Query is the first professional wedge.**
+
+## PRODUCT CONCEPT
+
+GraphReFly Canvas is a malleable professional workbench where AI-generated work is not accepted as a
+black-box answer. It is represented as a live, inspectable topology that both humans and LLMs can
+read, patch, verify, and eventually promote into reusable artifacts.
+
+The clean product mental model is three layers:
+
+| Layer | What the user sees or edits | GraphReFly role |
+|---|---|---|
+| **Presentation UI** | Tables, charts, dashboards, controls, layout, answer cards, review buttons | Projection bound to graph boundary nodes |
+| **Inspectable Topology** | Nodes, edges, descriptions, assumptions, validation checks, lineage, execution status, topology diff | The live trust surface and LLM editing target |
+| **Code / Spec Layer** | GraphSpec, node factory names, SQL, dbt/Cube/Snowflake calls, custom code, capability manifests | Durable/forkable substrate for serious users |
+
+This is intentionally not "another n8n". n8n's graph is workflow automation. GraphReFly Canvas'
+graph is a confidence surface: it explains how a result was produced, what assumptions entered it,
+where verification happened, and what local patch would repair it.
+
+## TOPOLOGY LENS / BLUEPRINT OVERLAY
+
+The user proposed a UI mechanism that makes the three-layer product concrete:
+
+> The inspectable topology should be available as a semi-transparent blueprint overlay, or as a
+> minimap-like layer, over either the canvas layer or the code/spec layer.
+
+This topology layer is not the primary workspace for ordinary users. It is an x-ray / blueprint /
+trust lens that can be opened when the user wants to understand, debug, bind UI, or watch execution.
+
+Possible visibility modes:
+
+- **Off:** canvas/code only.
+- **Boundary-only:** show only UI-bound input/output boundary nodes.
+- **Focused path:** show the currently selected node, its upstream/downstream path, and validations.
+- **Full topology:** show the whole graph.
+- **Debug/protocol mode:** expose deeper runtime/protocol state for advanced users.
+
+During graph execution, opening the topology lens should let the user see flow through the graph:
+
+- running / waiting / needs input / ready / verified / failed in normal user language
+- DATA / RESOLVED / COMPLETE / ERROR only in advanced/debug mode
+- active path, stale nodes, error nodes, and verification nodes highlighted
+
+When execution reaches a human-input or missing-input node:
+
+```text
+graph reaches humanInput / missing boundary input
+  -> topology node highlights
+  -> canvas locates the corresponding input UI
+  -> if no UI exists and auto-generate UI is enabled
+       -> AI creates an input widget slot on the canvas
+       -> widget binds to the node
+       -> user fills it
+       -> graph continues
+```
+
+The user also clarified a key navigation rule:
+
+- If the hovered topology node already has a corresponding UI widget, the canvas should **not**
+  automatically move by default; it should show that the node is already pinned.
+- Users can choose in settings whether the canvas follows topology hover/selection:
+  - **No tracking:** show pinned state only.
+  - **Soft tracking:** reveal a subtle connector/highlight without panning.
+  - **Follow selection:** pan/zoom canvas to the corresponding widget when a topology node is
+    selected or when runtime needs human input.
+
+This keeps topology inspection from hijacking the user's canvas layout, while still allowing a
+debugger-like follow mode when desired.
+
+## WHY DATA QUERY FIRST
+
+The Data Agent market gives the workbench a sharp professional wedge.
+
+The initial paid wedge should not be "ETL builder" and should not be "AI writes SQL". It should be:
+
+> **Trusted Data Query: every data answer comes with a graph.**
+
+Reasoning:
+
+- **The acute Data Agent pain is query correctness.** Business users and analysts do not merely need
+  a query entry point; they need the right metric, right grain, right exclusions, right freshness,
+  right source, and a way to see why a number should be trusted.
+- **Data Query is higher-frequency than full ETL.** Professionals ask and review ad-hoc questions
+  daily. A full production pipeline is a later hardening step.
+- **Data Query naturally promotes into ETL.** Once a query graph is verified and reused, it can be
+  saved, scheduled, materialized, exported, or converted into a dbt model/report/pipeline.
+- **The use case forces the topology layer to matter.** Unlike casual app generation, data
+  professionals already want lineage, assumptions, row profiles, validation, and source-of-truth
+  evidence. They are willing to inspect the middle layer because the cost of a wrong answer is real.
+- **It avoids rebuilding the semantic layer.** GraphReFly should wrap and orchestrate existing data
+  systems (dbt Semantic Layer, Cube, Snowflake, BigQuery, DuckDB, warehouses, notebooks), not replace
+  their metric engines.
+
+## TRUSTED DATA QUERY FLOW
+
+The first wedge can be described as:
+
+```text
+business question
+  -> LLM proposes topology or topology diff
+  -> metric/entity/source resolution
+  -> semantic/runtime/tool selection
+  -> query/tool execution
+  -> result profiling
+  -> verification checks
+  -> explanation/evidence assembly
+  -> human approve/edit/split/merge nodes
+  -> saved reusable graph
+  -> optional promotion to ETL/report/dashboard/model
+```
+
+Typical node families are solution-layer/preset catalog entries, not new core verbs:
+
+- `resolveMetric` / `resolveEntity` / `resolveGrain`
+- `selectSource` / `loadCatalog` / `loadSemanticModel`
+- `runQuery` / `runNotebook` / `runDbtMetric` / `callCube` / `callSnowflake`
+- `profileResult` / `sampleRows` / `detectSchemaDrift`
+- `validateFreshness` / `validateRowCount` / `compareBaseline` / `checkBusinessRule`
+- `explainAnswer` / `materializeOutput` / `promoteToPipeline`
+
+Every node should carry metadata that improves both human trust and LLM editing:
+
+- description
+- owner/source of truth
+- grain
+- source tables or semantic models
+- filters and exclusion rules
+- assumptions
+- freshness expectation
+- verification policy
+- last evidence/result profile
+- whether it is editable, locked, or requires human approval
+
+## TOPOLOGY CREATION AND DIFF
+
+The user clarified an important product principle: creating a topology and proposing a topology diff
+are the same underlying capability. The difference is governance and step size.
+
+Low model ability or low enterprise trust:
+
+- change fewer nodes per patch
+- require more verifiable intermediate nodes
+- require explicit verification nodes
+- gate edits through human approval
+- keep external tools narrow and declared
+
+High model ability or low-risk context:
+
+- allow larger topology patches
+- compress several steps into a coarser node
+- use existing external tools such as shell, dbt, notebooks, or warehouse jobs inside a declared node
+- rely on post-run validation and rollback/diff rather than per-step approval
+
+This maps neatly to GraphReFly's existing direction: finite node catalogs, declared factory names,
+descriptions, `describe()`/snapshot/diff, and graph-first inspection. The LLM is constrained to patch
+topology, not freely invent hidden control flow.
+
+## PIN NODE TO CANVAS
+
+The user proposed a core UI action:
+
+> Hover a topology node, see a ghost frame on the canvas, click pin, then decide how that node's data
+> should become UI.
+
+Interaction sketch:
+
+```text
+hover topology node
+  -> if no corresponding UI exists
+       -> canvas shows a ghost frame / ghost square
+  -> click pin on the topology node
+       -> ghost frame becomes a widget slot
+  -> user moves / resizes / positions the slot
+  -> user chooses input or output binding
+  -> user chooses which node data/path to bind
+  -> AI generates UI, or user pastes/provides a custom component
+```
+
+This separates the two decisions that output UI cannot safely infer:
+
+- **Data intent:** which node, which direction, and which data path should be exposed.
+- **Presentation intent:** where the widget lives, how large it is, and what kind of component it
+  should become.
+
+Inputs and outputs differ:
+
+- **Input UI can be inferred from missing interaction.** If the graph is blocked on human input or a
+  required boundary state has no UI, the runtime/AI can propose or auto-create the widget slot when
+  allowed.
+- **Output UI should be pinned by user intent.** The AI can suggest likely output nodes, but the user
+  should declare that a node is presentation-worthy by pinning it.
+
+Once pinned, AI generation and custom component import can share the same binding contract:
+
+```text
+node data -> component props
+component events -> boundary/input node
+```
+
+This lets the user either:
+
+- ask AI to generate a practical widget from schema/metadata, or
+- paste a prettier component generated by another app/builder, then bind its props/events to the
+  selected GraphReFly node.
+
+The product rhythm becomes:
+
+```text
+hover node -> pin -> place -> bind -> generate or paste component
+```
+
+For Data Query examples:
+
+- Pin `runQuery.rows` as a table.
+- Pin `compareBaseline.summary` as a verification panel.
+- Pin `validateFreshness.status` as a small status badge.
+- Pin `explainAnswer.value` as a narrative answer card.
+- Auto-create an input widget when `resolveMetricDefinition` needs the user to choose a business
+  metric definition.
+
+## HOW THIS REDUCES DATA ANNOTATION WORK
+
+The wedge is not "annotate the whole warehouse by hand". The intended product leverage is to make
+annotation incremental and structural.
+
+Instead of asking a team to fully document every table/metric upfront, GraphReFly Canvas can:
+
+- attach descriptions and assumptions to the exact nodes created during real work
+- reuse known-good nodes and factories across later questions
+- localize missing context to the node that failed or became ambiguous
+- turn validation failures into targeted annotation tasks
+- preserve successful query graphs as reusable examples for the next LLM topology proposal
+
+This matches the user's intuition: fewer allowed operations and more known nodes reduce trial cost.
+The workbench narrows the freedom of both humans and LLMs while keeping an escape hatch into code.
+
+## PRODUCT POSITIONING
+
+Candidate positioning:
+
+> **GraphReFly Canvas turns "ask data" into an inspectable, verifiable processing graph that humans
+> and LLMs can safely edit.**
+
+Shorter:
+
+> **Every data answer comes with a graph.**
+
+The customer is not the casual user who only wants a chat answer. The first buyer is likely a
+professional who already feels the cost of plausible-but-wrong numbers:
+
+- analytics engineers
+- data scientists
+- data/BI leads
+- founders/operators living in warehouse dashboards
+- teams already using dbt/Cube/Snowflake/BigQuery but lacking an AI trust surface
+
+What they pay for is confidence, reviewability, reusable artifacts, and lower repair cost after
+schema or business-definition changes.
+
+## NON-GOALS AND GUARDRAILS
+
+This is a product/solution-layer wedge, not a substrate specialization.
+
+- Do **not** make GraphReFly "a data framework" at the core.
+- Do **not** add data-specific verbs to the 8-verb floor.
+- Do **not** rebuild dbt/Cube/Snowflake semantic runtimes.
+- Do **not** sell generic "AI writes SQL" as the differentiated claim.
+- Do **not** hide the topology inside another builder's static DAG where GraphReFly becomes one node.
+- Do **not** let this wedge violate F-NO-WEDGE-CUT: the same Canvas/workbench shape must also remain
+  applicable to research feeds, health dashboards, shopping/review-gated automation, and other
+  private-flow reduction workbenches.
+
+The product wedge is narrow; the GraphReFly substrate remains horizontal.
+
+## RELATION TO EARLIER THREADS
+
+This discussion connects these prior archived themes:
+
+- **First-principles audit:** graph is the right structure for LLM composition because it is
+  executable, inspectable, structurally diffable, and localizes errors.
+- **Universal reduction layer:** professional data query is one concrete "massive info -> reduced
+  trusted answer" instance.
+- **Handle-dispatch substrate draft:** data engineering strengthens the case that large data and
+  warehouse execution should live behind handles/tools/pools, not inside graph node values.
+- **Reactive collaboration harness:** human review gates and verification nodes are part of the
+  trust surface, not decoration.
+- **GraphReFly Canvas / Workbench product thread:** data query becomes the first professional wedge
+  for the UI + topology + code workbench, rather than a separate product identity.
+
+## FOLLOW-UP: WORKSPACE GRAPH, WORK GRAPH, AND REACTIVE ISSUE TRACKER
+
+Recorded 2026-06-06 from follow-up discussion. This is still product/solution-layer framing, not a
+substrate decision.
+
+The clearer product split is:
+
+```text
+WorkspaceGraph
+  -> reactive issue tracker / work orchestration control plane
+
+WorkGraph
+  -> one code + canvas unit
+  -> one GraphReFly graph / concurrency domain / edit domain
+
+Canvas projection
+  -> widgets bound to selected WorkGraph boundary nodes
+
+Topology overlay
+  -> inspectable GraphReFly blueprint over the code/canvas unit
+```
+
+The reactive issue tracker is not a Jira integration. It is the outer WorkspaceGraph that replaces
+Jira/Linear-style status cards with live, verifiable work assertions. It manages requests, priority,
+ownership, approvals, verification summaries, reopen/regression, artifact references, and memory.
+
+Each individual `code + canvas` unit is a WorkGraph. A WorkGraph owns the concrete analysis or tool
+flow: for data work, nodes such as metric/source resolution, query execution, result profiling,
+freshness checks, baseline comparison, explanation assembly, and widget-bound outputs.
+
+### Control-plane recommendation
+
+The WorkspaceGraph should be a fixed product skeleton with extension slots, not a fully free-form
+canvas like WorkGraph, and not one giant graph that mounts all WorkGraphs for execution.
+
+Recommended shape:
+
+```text
+WorkspaceGraph
+  issues
+  workGraphRegistry
+  messagingHub
+  scheduler/router
+  ownership/leases
+  verificationIndex
+  artifactIndex
+  memory/factStore
+  views/queues/board
+```
+
+Power users customize extension slots:
+
+- issue/request types (`adHocDataQuery`, `experimentAnalysis`, `incidentInvestigation`)
+- WorkGraph templates per issue type
+- verifier packs (freshness, row-count drift, schema drift, metric reconciliation, business rules)
+- priority/routing policy nodes
+- widget packs and client-facing canvas layouts
+- artifact promotion targets
+
+This keeps the WorkspaceGraph reliable as a product control plane while letting WorkGraphs remain
+domain-specific and user-extensible.
+
+### Do not collapse all WorkGraphs into one execution graph
+
+WorkGraphs may appear nested in the UI and may be referenced by WorkspaceGraph data, but they should
+remain separate execution/edit domains. The WorkspaceGraph stores `WorkGraphRef` records and talks to
+WorkGraphs through messaging hub / wire-boundary commands and events:
+
+```text
+WorkspaceGraph -> WorkGraph
+  createFromTemplate
+  proposePatch
+  runVerification
+  requestArtifact
+  pause / resume / cancel
+  requestHumanInput
+
+WorkGraph -> WorkspaceGraph
+  planProposed
+  topologyChangedSummary
+  needsInput
+  verificationPassed
+  verificationFailed
+  artifactReady
+  blocked
+```
+
+Reasoning:
+
+- A graph is the single-thread concurrency/edit domain. If every WorkGraph is mounted into one large
+  graph, the product loses natural parallelism and forces one agent/LLM/human ownership boundary over
+  the whole workspace.
+- Separate WorkGraphs let one agent modify one graph at a time while other WorkGraphs continue to
+  verify or run independently.
+- The WorkspaceGraph can still compute global views (board, priority, owner load, blocked issues,
+  verification health) from summaries and events without owning every inner topology.
+- Cross-graph causal influence is still visible as delayed consistency through declared command/event
+  boundaries, rather than hidden imperative calls.
+
+Product shorthand:
+
+> WorkspaceGraph is the control plane. WorkGraph is the execution plane. Canvas is the projection
+> plane.
+
+For data-agent requests, the flow becomes:
+
+```text
+request filed in WorkspaceGraph
+  -> issue/request node created
+  -> WorkGraph template selected or forked
+  -> WorkGraph runs analysis and verification nodes
+  -> Canvas widgets present data views for power users / clients
+  -> verification summary flows back to WorkspaceGraph
+  -> issue verifies, reopens, or asks for human input
+  -> successful graph/artifacts can be promoted into reusable templates or examples
+```
+
+The data analytic views are Canvas widgets, not core substrate. The product can provide a demo widget
+pack for common views (table, chart, metric card, validation panel, narrative answer card), while
+power users build client-specific widget packs and layouts over the same node-binding contract.
+
+### Web-first shell, runner-backed execution
+
+Follow-up product direction: prefer web app first, with desktop/local execution treated as a power-user
+capability layer rather than the primary product surface.
+
+Reasoning:
+
+- The WorkspaceGraph, reactive issue tracker, Canvas, approvals, review, sharing, and client-facing
+  artifacts are naturally web-first.
+- The browser should not directly execute arbitrary local code. It can host the UI, Canvas widgets,
+  demo data, OPFS/local-first storage, JS/WASM execution, and lightweight data views.
+- Code verification, repo access, shell commands, dbt, warehouse credentials, and long-running tasks
+  should run through explicit local or remote runners.
+- Desktop/Tauri can later wrap the same web shell and local runner, but the durable design decision
+  should be the capability boundary, not the packaging format.
+
+Suggested execution channels:
+
+```text
+Browser sandbox
+  Canvas widgets
+  demo datasets
+  DuckDB-WASM / Pyodide / JS WorkGraphs
+  local-first drafts and artifacts
+
+Local runner
+  local repo access
+  git / shell / pnpm test / dbt run / dbt test
+  private credentials
+  power-user WorkGraph verification
+
+Remote runner
+  team/VPC execution
+  shared warehouse access
+  scheduled verification
+  long-running data jobs
+```
+
+The web app should send typed commands to runners rather than arbitrary shell strings. Example command
+surface:
+
+```text
+runVerification(issueId, workGraphId)
+runTests(repoPath, scope)
+runDbt(modelSelector)
+runSql(warehouseProfile, queryPlan)
+produceArtifact(canvasWidgetId)
+```
+
+The runner owns the capability policy:
+
+```text
+filesystem allowlist
+command allowlist
+warehouse profile allowlist
+runtime / memory limits
+artifact output policy
+human approval gates
+```
+
+### Follow-up: sandbox and runner choice
+
+Recorded 2026-06-07 from follow-up discussion. This is still product/solution-layer direction, not
+a substrate, protocol, package API, or D-numbered architectural lock.
+
+The sandbox choice splits into UI rendering trust and execution trust. GraphReFly Canvas itself, plus
+trusted built-in widget packs such as table, chart, metric card, validation panel, input form, and
+narrative answer card, should render directly in the host web app. A sandboxed iframe is only the
+default for untrusted executable UI: AI-generated widgets, pasted custom components, and marketplace
+widgets. The binding contract should be iframe-compatible from the start:
+
+```text
+node data -> component props
+component events -> validated boundary/input node
+```
+
+Generated or pasted widgets can start in iframe preview/runtime, then optionally be promoted to
+project-trusted code after user/team review. Promotion means they can join the normal host bundle or
+trusted component pack. The product should not make "100 widgets = 100 iframes" the normal case;
+most high-frequency widgets should be trusted built-ins, and untrusted widgets may be virtualized,
+grouped by package/trust policy, or rendered as snapshots when off-screen.
+
+Runner sandbox is separate from UI sandbox. The browser must not execute arbitrary local code or
+shell commands. Real verification work should run through typed commands sent to a local or remote
+runner:
+
+```text
+runVerification(issueId, workGraphId)
+runTests(repoPath, scope)
+runDbt(modelSelector)
+runSql(warehouseProfile, queryPlan)
+produceArtifact(canvasWidgetId)
+```
+
+The web product should not require a local app before first use. The entry path is progressive:
+
+```text
+Web-only Canvas
+  demo data / sample WorkGraphs / Canvas / topology lens / built-in widgets
+
+Cloud demo runner
+  controlled templates and demo datasets, no arbitrary customer code or secrets
+
+Local runner
+  optional power-user capability for local repo, dbt, tests, files, and private credentials
+
+Managed secure runner
+  later paid/team infrastructure with login, RBAC, secrets, audit, and stronger isolation
+```
+
+For a local runner, the desired ergonomics are: web app remains the main product, a local CLI or
+daemon is connected only when a task needs local capabilities, the user authorizes one workspace or
+repo allowlist, and every risky action is shown as a typed approval rather than a raw shell string.
+Artifacts, logs, test results, dbt outputs, screenshots, and query evidence return into WorkGraph
+evidence nodes instead of living only in a terminal.
+
+For remote execution, the recommended first serious self-hosted isolation direction is OCI/Docker
+API plus gVisor/runsc or Kubernetes RuntimeClass with gVisor. This keeps image/tool compatibility
+for Python, Node, dbt, git, and CI-like tasks while adding a stronger syscall boundary than default
+runc. Kata Containers and Firecracker/microVMs remain enterprise/multi-tenant isolation upgrades,
+not MVP blockers. E2B, Daytona, Sandbox0, nsjail, bubblewrap, and Wasmtime/WASI are relevant
+evaluation targets:
+
+- E2B / Daytona / Sandbox0: AI-agent sandbox platforms worth prototyping or adapting.
+- gVisor/runsc: default remote-runner v1 candidate.
+- Kata Containers / Firecracker: stronger isolation tier for hosted multi-tenant execution.
+- nsjail / bubblewrap: lightweight local or single-machine process sandbox candidates.
+- Wasmtime/WASI: good for small capability-style plugins or pure compute, not full repo/dbt runs.
+
+Product conclusion: do not make strong login, Kubernetes, or gVisor a prerequisite for GraphReFly
+Canvas v0. Build the web Canvas and demo/cloud-safe flows first, add optional local runner for
+private local work, and defer hosted secure runner infrastructure until the product proves that
+users want managed execution.
+
+## FOLLOW-UP: DATA-QUERY FIRST CUT AND ANALYSIS CHAIN
+
+Recorded 2026-06-08 from follow-up discussion. This narrows the first product proof, but remains
+solution-layer direction only. It is not a protocol change, D-numbered decision, package API lock, or
+implementation approval.
+
+The first concrete deliverable should be `solutions/data-query`, not a full Canvas product and not an
+external semantic-layer runtime. The first proof should use local DuckDB/CSV so the team can validate
+the analysis experience, topology shape, and evidence artifact without waiting on enterprise
+connectors, warehouse auth, or semantic-runtime integration.
+
+The semantic-layer principle is:
+
+> **Wrap, do not own.**
+
+GraphReFly should not rebuild dbt Semantic Layer, Cube, Snowflake semantic views, Wren MDL, BigQuery
+semantic tooling, or future warehouse-native metric engines. The data-query solution owns the
+inspectable analysis topology, evidence ledger, verification chain, and promotion path. It consumes
+semantic context through adapter-shaped nodes:
+
+```text
+localSemanticContext / duckdbCsvContext        (first proof)
+dbtSemanticContext / cubeSemanticContext       (later wrappers)
+snowflakeSemanticContext / bigQueryContext     (later wrappers)
+```
+
+The term **analysis chain** means a graph-shaped evidence trail from a business question to a
+trusted answer:
+
+```text
+question
+  -> clarifyIntent
+  -> resolveMetric / resolveEntity / resolveGrain
+  -> selectSource
+  -> buildQueryPlan
+  -> generateSql
+  -> runDuckDB
+  -> profileResult
+  -> validateChecks
+  -> explainAnswer
+  -> assembleReport
+  -> approveOrRevise
+  -> saveAnalysisGraph
+```
+
+It is called a chain for product language, but it should be implemented and presented as a graph
+spine with sidecar evidence:
+
+```text
+semantic context -> resolveMetric
+schema catalog   -> selectSource / buildQueryPlan
+sample rows      -> profileResult
+business notes   -> validateChecks / explainAnswer
+
+runDuckDB
+  -> sql text
+  -> result table
+  -> execution trace
+  -> source files used
+
+validateChecks
+  -> freshness
+  -> row-count drift
+  -> schema drift
+  -> metric reconciliation
+  -> business-rule assertions
+```
+
+The first example should be an `AnalysisGraph`. This is an example / solution bundle name, not a new
+core graph type or verb. Its purpose is to make "every data answer comes with a graph" concrete:
+
+```text
+AnalysisGraph
+  question
+  semanticContext
+  queryPlan
+  sql
+  result
+  profile
+  checks
+  evidence
+  answer
+  report
+```
+
+Each output should have visible provenance. `answer` says the conclusion; `evidence` says why the
+answer is believable; `checks` say what could be wrong; `sql` says what ran; `profile` says whether
+the result data looks sane; `semanticContext` says which business definitions were used. The first
+local proof can be small: a CSV fixture set, a tiny semantic-context object, one generated SQL query,
+one result table, one validation panel, and one answer card. The differentiator is that opening the
+topology lets the user walk backward from the answer to the metric definition, SQL, source files,
+row profile, and verification checks.
+
+## OPEN QUESTIONS
+
+1. **Vertical packaging:** resolved direction for the first proof = `solutions/data-query` starter
+   kit. Canvas remains the mother product direction, but not the first concrete deliverable.
+2. **Integration order:** resolved direction for the first proof = local DuckDB/CSV. dbt/Cube/
+   Snowflake/BigQuery are later wrappers under the "wrap, do not own" semantic-layer principle.
+3. **Verification baseline:** what minimum verification set makes the demo feel differentiated:
+   freshness, row-count drift, schema drift, metric reconciliation, sample trace, or all of them?
+4. **Promotion target:** should "promote to ETL" first export a dbt model, a scheduled graph, a
+   notebook, a dashboard/report, or just a saved reusable graph?
+5. **Canvas form:** is this wedge better as a standalone web PWA, an internal demo host, or an
+   embeddable component that later powers several vertical packs?
+6. **Sandbox/runner boundary:** resolved direction in the follow-up above; concrete provider choice
+   remains implementation-time evaluation, but the product boundary is web-first plus optional
+   local/remote typed-command runners.
+
+## STATUS
+
+Captured as product strategy / solution-layer direction only. No D-number minted, no spec amended,
+no implementation started.
diff --git a/archive/docs/SESSION-reactive-linear-and-git.md b/archive/docs/SESSION-reactive-linear-and-git.md
new file mode 100644
index 00000000..0d835386
--- /dev/null
+++ b/archive/docs/SESSION-reactive-linear-and-git.md
@@ -0,0 +1,396 @@
+---
+SESSION: reactive-linear-and-git
+DATE: 2026-05-31
+TOPIC: Discussion-capture (NOT a decision session). Started as a /research pass on three repos
+  surfaced by a Xiaohongshu post (Multica / CubeSandbox / ECC + a "stateless agent service unit"
+  essay) and converged into a deep architecture discussion that produced (a) a corrected mental
+  model of how locality / parallelism / write-isolation actually work on the GraphReFly substrate,
+  and (b) a product vision — "a reactive blend of git and Linear" — for causal-level (not text-level)
+  multi-agent collaboration on graph code. Two locked decisions are CHALLENGED by this discussion
+  (DS-14.6.A L2 subgraph-level write isolation; D22 "causal" wording) — both flagged, NEITHER
+  decided. No D-number minted, no spec amended, no code touched.
+REPO: graphrefly-ts (primary)
+STATUS: DISCUSSION CAPTURE ONLY — user said "不拍，纯粹讨论". Nothing here is locked. Anything that
+  would change a locked decision (L2, D22 wording) or add a primitive requires /design-review →
+  explicit approval → decisions.jsonl, per feedback_no_autonomous_decisions +
+  feedback_no_implement_without_approval.
+SUPERSEDES: none (does NOT supersede DS-14.6.A L2 — it surfaces a tension with it)
+---
+
+## CONTEXT
+
+The session began as a `/research` pass triggered by a Xiaohongshu post the user pasted (a blogger's
+comment, NOT the user's own view — clarified mid-session). The post named three repos and laid out a
+"stateless agent service unit" architecture (decision/execution separation; agent layer / sandbox
+layer / session layer / orchestration layer; dynamic disposable containers; context stripped off the
+agent as a managed resource).
+
+Research findings (landscape snapshot 2026-05-31, sources in PART 5):
+- **Multica** (`multica-ai/multica`, ~1.7K★) — kanban-style "managed agents"; Go backend + Next.js +
+  local daemon; 12 CLI runtimes (Claude Code, Codex, OpenClaw, ...); cloud runtime waitlist-only.
+  Orchestration = **task dispatch on a board, NOT a dependency DAG** — this confirmed the user's
+  "编排不强" read as structural, not a maturity gap.
+- **CubeSandbox** (`TencentCloud/CubeSandbox`, ~6K★) — RustVMM/KVM microVM; <60ms cold start, <5MB
+  overhead, E2B-SDK compatible. The "disposable cattle" execution layer.
+- **ECC** (`affaan-m/ECC`) — "Everything Claude Code"; 60 agents + 232 skills as markdown config on
+  top of Claude Code/Codex. The agent-capability-template layer.
+
+Key reframe from the research: **the three repos are not competitors at one layer — they are three
+DIFFERENT layers** (agent-config / sandbox / orchestration). GraphReFly sits at the orchestration +
+decision layer ("the brain"), is orthogonal to the sandbox layer, and should COMPOSE the others as
+node-backends rather than compete. That reframe is the on-ramp; the substance below is the
+architecture discussion it triggered.
+
+---
+
+## PART 1: CORRECTED MECHANISM MODEL (mostly converged)
+
+These are clarifications of EXISTING locked floor (D22 / D26 / F-SYNC-CORE / F-DISPATCH-ALL), not new
+decisions. They corrected several altitude errors the assistant made mid-session; the user drove each
+correction. Captured because the corrected model is load-bearing for the vision in PART 2.
+
+### M1 — Locality is a pool/tool concern, not a node identity; protocol is agnostic to sync/async
+
+The power user registers execution environment per fn at graph-authoring time. Short work →
+in-process fn; long/heavy work → sandbox fn. Concretely, the user can register TWO fns for the same
+action as two tools — `(ctx) => {/* do A in-process */}` and `(ctx) => {/* do A in a remote box */}` —
+and an LLM tool-call picks which one to invoke.
+
+The load-bearing invariant (user's phrasing): **`ctx.down()` is the only continuation point; the
+protocol does not care whether the fn was sync or async.** A sync `ctx.down` lands in the current
+wave; an async one lands in a later tick (pool already does this). Both sides of the protocol just
+"wait for down". Therefore this is NOT new substrate — it is the existing tool registry + pool. The
+assistant's earlier "conservatively present the node as async" framing was solving a non-problem.
+
+### M2 — Parallelism unit = dispatcher = graph (D26), NOT the async boundary
+
+The pivotal correction. The user caught a contradiction: if "async wire ⇒ parallel" were the rule,
+then a pool turning one in-graph fn from sync to async would split a graph into two parallel halves —
+which is nonsense.
+
+Resolution: **parallelism comes from how many dispatchers exist, not from async.** One graph = one
+graph-local clock (D26) = one wave-loop = wave is always single-threaded. Two graphs = two clocks =
+two wave-loops = can land on two threads.
+
+| | sync edge | in-graph async pool node | cross-graph async wire |
+|---|---|---|---|
+| crosses a tick? | no | yes | yes |
+| dispatchers | 1 | **1** | **2** |
+| graph waves run in parallel? | no | **no** (same thread, time-sliced) | **yes** |
+| what leaves the main thread | nothing | only the leaf fn's compute (HTTP/heavy) | the whole other engine |
+
+So **async is necessary-but-not-sufficient for parallelism** (a sync edge forces same-thread; async
+unblocks the tick) — the sufficient condition is a SECOND dispatcher. An in-graph pool node offloads
+the *leaf*'s compute to a pool thread but does NOT fork the graph's reactive propagation; upstream-half
+and downstream-half (when causally coupled) are the same dispatcher running different waves,
+time-sliced on one thread. The thread hand-off point is the **dispatcher boundary**, not the tick
+boundary (an earlier assistant claim, retracted).
+
+> **CORRECTION 2026-05-31b (user):** dispatcher:graph is NOT 1:1. The parallel/dispatcher unit is the
+> **causally-connected component** (= the Rust clean-slate `SchedulingGroupId` / union-find
+> connectivity auto-detect), NOT the "graph container". A graph container may hold several
+> causally-DISJOINT components and be serviced by several dispatchers with no glitch and no race —
+> because disjoint components share no causal path (no cross-component diamond, no shared-state
+> contention). The earlier "one graph = one dispatcher" framing below (M2 table, M5, M6) is corrected
+> by this: read "graph" there as "causally-connected component". This is exactly why V1 (PART 2) and
+> the Rust SchedulingGroup partition are THE SAME THING (see PART 4 F1-RESOLVED).
+
+### M3 — A sync edge welds two graphs into one; async wire keeps them as two engines
+
+Worked example (user's): `graph1: A→B→D`, `graph2: C`, async wires `A⇢C` and `C⇢D` (a cross-graph
+diamond: fast in-graph path A→B→D vs slow cross-graph path A⇢C⇢D). At time T, thread-1 runs B=f(A@N)
+while thread-2 runs D consuming A@N-1 via C — two engines busy simultaneously = pipeline parallelism.
+If A→C→D were a SYNC edge, D would have to consume A in the same wave, dragging A,B,C,D into one
+dispatcher = one engine = no parallelism. **This is the whole sync/async difference: sync pulls the
+consumer into the producer's same tick (weld); async lets it consume one tick late (two engines).**
+
+### M4 — Causal domain spans the wire; "glitch-free" means different things in/across graphs
+
+The user's sharpest correction: **A→(wire)→B means A's cause becomes B's effect, so they ARE one
+causal domain — this does not change with sync/async or read-only/writable.** Async buys *temporal*
+decoupling (B reacts on its own thread, one tick late), NOT *causal* independence. The assistant had
+conflated the two.
+
+Consequence for "glitch-free": in-graph diamonds are **same-tick strongly consistent** (the wave
+protocol's RESOLVED merge guarantees D sees one consistent version of A). A cross-graph diamond
+(fast path vs slow path through another graph) makes D see "new B + old C(based on older A)" — a
+genuine half-new/half-old state — but it is **LEGAL**, because the async wire's contract is exactly
+"I feed you a past value, no same-tick consistency promised". So: in-graph = same-tick glitch-free;
+cross-graph = async-tolerated delayed consistency (a stale-while-revalidate semantics). They are
+different guarantees, both making behavior predictable.
+
+Important corollary the user re-derived: a cross-graph diamond means A still influences D (through C),
+so the two graphs are causally COUPLED even though they run in parallel. **Parallel ≠ causally
+independent ≠ freely separable.** This is why the fission criterion (PART 2) must walk through wires.
+
+### M5 — Why one graph cannot use multiple dispatchers (design choice, not a missing feature)
+
+Putting two dispatchers inside one graph (e.g. two threads pushing the two arms of an in-graph
+diamond A→{B,C}→D) reintroduces **glitches** (D fires twice; momentarily sees "new B + old C") and
+**data races** (B,C writing a shared downstream state need a lock — and the lock serializes away the
+parallelism you added). The entire wave protocol (RESOLVED diamond merge + single-thread sweep) exists
+to kill exactly that glitch. **Single dispatcher per graph is the SOURCE of correctness, not an
+unoptimized state.** D22's "graph = single causal/concurrency domain" is this choice: no threads
+inside a graph; want parallelism → open another graph (cross-graph is async, which makes "see a
+half-old value" a legal contract instead of a hidden race).
+
+> The two parallelism routes contrasted: in-graph multi-dispatcher trades AWAY glitch-free for
+> parallelism (hidden race); multi-graph + async trades AWAY same-tick consistency (async never
+> promised it) for parallelism (explicit at the wire). GraphReFly picks the second: the cost of
+> parallelism is pushed to the wire boundary and made visible, not buried inside the graph.
+
+### M6 — D26 corollary: "graph = the minimal parallel unit the user can decide" is FORCED
+
+The user's original intuition ("the graph is the smallest parallel unit a user can decide") is not a
+convention — it FALLS OUT of single-dispatcher-per-graph (M5) + graph-local clock (D26). You cannot
+sub-divide a graph into two parallel units because that needs a second dispatcher, which only a second
+graph yields. This is the bridge to PART 2's write-isolation model.
+
+---
+
+## PART 2: VISION — "a reactive blend of git and Linear" (exploratory, NOT decided)
+
+The user's own framing (clarified as their vision, motivated by the current "GitHub flooded with
+agent PRs" pain): re-think merge-conflict / commit / ownership at a different dimension. GraphReFly can
+simplify these at the causal level, giving agents more autonomy while humans stop worrying about
+agents touching safety-critical parts — because nodes carry guards and graph isolation lets a human
+carve out a playpen for an agent (and one for themselves). At the graph level a human can SEE who
+touched a graph, who MAY touch it, whether a merge is dangerous; "an agent is writing this patch, so
+I'll take another — guaranteed not to step on each other's toes." Explicitly described as "not fully
+thought through — a vision, like a reactive synthesis of git and Linear."
+
+### V1 — Write-isolation unit = the GRAPH (challenges DS-14.6.A L2)
+
+The user proposed: drop subgraph-level write isolation; **the graph is the write-isolation unit** —
+"a graph represents one causally-entangled interaction, so one graph is single-writer / multi-reader."
+If two changes don't entangle, split into two graphs.
+
+⚠️ **CONFLICT FLAG (not resolved):** This directly contradicts DS-14.6.A **L2** ("write isolation =
+subgraph-level"). Note the irony surfaced in-session: V1 is arguably CLOSER to D22 ("graph = single
+causal/concurrency domain; parallelism via multi-graph") than L2 is — L2's subgraph-level concurrency
+is the deviation from D22. But changing L2 is a decision revision; per decision-first it must go
+through /design-review → approval, NOT be silently adopted here.
+
+Definitions the user pinned down for V1:
+- **(a) "one write" = exactly one external writer-actor holds write access** (may edit inputs / edit
+  topology). Internal fan-in nodes emitting DATA are NOT "writes" (single-thread propagation, no
+  contention). Whoever holds the lock may rewrite; others have free READ (`.cache`, `describe`,
+  `observe`, read the code).
+- **(b) Shared messaging hubs are out of scope** — a hub already lives inside some graph's causal
+  domain, so its internal multi-publisher emits are "internal writes", not external writes. This
+  dissolves the assistant's earlier worry that "N publishers on one topic violates single-writer";
+  cross-agent contribution flows through the READ channel (everyone can read each other's graphs),
+  not through shared external write.
+
+### V2 — Reframe: causal-dimension conflict prevention vs text-dimension conflict detection
+
+The vision's core (assistant's sharpening, user-endorsed direction):
+- **git** judges conflicts in the TEXT dimension → can only detect them AFTER both agents finish and
+  try to merge (lagging; loss already incurred).
+- **GraphReFly** judges in the CAUSAL dimension → conflicts are PREVENTED at the allocation stage,
+  before anyone acts: write-isolation unit is the graph, two agents take different graphs, so they
+  structurally cannot step on each other.
+
+> git = optimistic concurrency (everyone edits, detect conflict after the fact, resolve painfully).
+> GraphReFly = causal partitioning (before acting, hand causally-independent regions to different
+> writers; conflict is structurally impossible). The antidote to "GitHub flooded with agent PRs" is
+> not fewer PRs — it's allocating causally-independent work up front so N agent changes are
+> guaranteed mergeable (they land in mutually-unreachable causal cones).
+
+### V3 — "git × Linear × reactive" decomposed into three axes
+- **git half:** version / diff / branch / ownership / merge — already have `snapshot`, `Graph.diff`,
+  `meta.owner`, changeset. But **causal-aware**, not text-aware.
+- **Linear half:** tasks / who-owns-what / board / status. Insight: a **kanban board = the
+  ContextView rendered for a HUMAN Actor** (their owned graphs, pushed todos, importance-filtered
+  context). Same DS-14.6.A per-view rendering (L4); LLM view → compressed prompt, human view →
+  kanban. "Board vs group-chat" preference and the multi-agent substrate are two projections of ONE
+  mechanism.
+- **reactive half** (neither git nor Linear has it): both are static snapshots you pull/refresh;
+  GraphReFly's "who touched this graph, is the merge dangerous" is PUSHED and live.
+
+### V4 — Structural safety: a playpen, not a leash
+Safety stops being per-operation approval (which deadlocks agents and exhausts humans) and becomes
+structural:
+- **core safety zone** = graphs the human holds write on; agents read-only — agents can't touch it
+  not because each step is blocked, but because they lack write access to that graph.
+- **playpen** = graphs whose write the human handed to an agent — agent plays/errs freely; an error
+  only pollutes that one graph (graph isolation = blast-radius isolation).
+- **boundary** = guards on nodes; cross-zone influence must pass a guard.
+
+This is one dimension above sandbox isolation: a sandbox stops an agent from breaking the MACHINE
+(`rm -rf`); this stops an agent from breaking STATE OTHERS DEPEND ON (the real multi-agent pain a
+sandbox can't solve — two agents editing the same repo inside one sandbox still conflict).
+
+### V5 — Ownership lifecycle (user's answers to the three "thorns")
+
+The user closed the three open thorns the assistant raised; together they form one lifecycle where
+**only ONE step needs distributed coordination**:
+
+```
+create  (create-owns; single-machine; NO contention — creator holds the lock first,
+         exactly like a process creating a file owns its lock; GraphReFly defines the
+         lock semantics, analogous to a filesystem defining file locks)
+  → hold + edit the blueprint  (single-machine; in-graph single-writer)
+  → release  (when the agent is done writing, it releases write access)
+  → acquire  (redis/lease-coordinated; CONTENDED; the ONLY distributed point —
+              multiple agents may want to claim the same just-freed graph)
+  → hold again ...
+```
+
+- **Creative work needs no partition** — the creator owns exclusively; nothing to entangle. Partition
+  only matters when an EXISTING structure is edited by multiple parties. This dissolves the "partition
+  needs a pre-existing graph" paradox: create-owns covers new-structure creation.
+- **Blueprint = graph code = spec-as-projection** (DS-14.5.A), regenerated/updated after each edit.
+  Before acting, an agent READS the blueprint → sees which graphs exist, which code maps to which
+  graph, who currently holds write. "Which graph does the line I want to change belong to, is anyone
+  writing it" becomes a TABLE LOOKUP, not a causal inference. The abstract causal analysis is hidden
+  behind the blueprint index; the agent only deals with the index.
+- **"Don't rebuild redis" ≠ "don't use redis".** GraphReFly defines the SEMANTICS (write access,
+  version, causal); redis (or any lib) provides the MECHANISM (lock, lease, cross-machine store).
+  Same philosophy as `attachStorage` (pluggable backend). The distributed write-coordination is just
+  another adapter ("lock provider" interface; in-memory impl single-machine, redis impl on cloud).
+
+Emergent property the assistant flagged and the user's design choices reinforce: **distributed
+complexity is inversely proportional to write-isolation granularity.** Choosing graph (large unit) +
+static fission shrinks the set of points needing coordination to ONE (acquire-a-free-graph). Had the
+design kept L2 subgraph-level or runtime hot-fission, that surface would be far larger. Short hold +
+strong isolation also means a redis-lease failure (split-brain: two agents both think they hold the
+lock) degrades from catastrophe to "that one graph's change is redone" — blast-radius isolation buys
+fault tolerance, not lock perfection.
+
+### V6 — Fission = STATIC, on the code, blank-start (user clarified twice)
+
+Fission is NOT a runtime operation. It is editing the STATIC code on the filesystem to split one graph
+definition into two — "like making changes to code; like git, but more granular." Because the split
+happens when nothing is running, all the runtime hazards (quiescence, state migration, live-migration)
+**do not exist**. New graphs **blank-start** (re-hydrate from sources on next run via push-on-subscribe;
+lossless for derived/pure compute precisely because the independence criterion guarantees the two
+halves don't couple). The user explicitly chose blank-start over snapshot-fork.
+
+**Fission criterion (causal, wire-aware):** X (writer-A's writable region) and Y (writer-B's) may
+split ⟺ neither is in the other's DIRECTED causal cone, with reachability walked THROUGH wires. A
+shared READ-ONLY upstream Z does NOT count as entanglement (directed reachability A→…→B excludes it).
+This is exactly what `reachable()` computes (directed up/down-stream) — but it is currently
+in-graph-only; cross-wire reachability is **G6 (unverified, from SESSION-multi-agent-gap-analysis)**.
+So "must look at the wires" = `reachable()` must become wire-aware = **G6 is a prerequisite**.
+
+Subtlety raised (open): if the change is a TOPOLOGY edit (adding an edge / wire) rather than an input
+edit, independence must be judged on the POST-change topology, because adding a wire can CREATE
+entanglement that didn't exist pre-change. "Two graphs joined by a new wire are, causally, one
+coupled system" — so the unit of independence analysis is the **wire-connected component**, not the
+graph container alone. (Same hard case as git "a change that adds a reference to something far away".)
+
+### V7 — Fusion is the asymmetric, harder inverse (user: needs both writers + consent)
+
+Fission is single-party (the sole owner decides to split — freedom). **Fusion requires BOTH writers
+present and consenting to surrender write** (merging two graphs → one write-isolation unit → only one
+write access can survive → an ownership negotiation, not an edit — a contract). The user's rule:
+"fusing two graphs needs both to hold write access simultaneously to operate." This is where git's
+merge-conflict pain actually lives; left as the sharpest unresolved corner of the model.
+
+---
+
+## PART 3: OPEN QUESTIONS (none decided — user said "纯粹讨论")
+
+1. **Fission criterion: validate-only vs auto-suggest.** Assistant asked twice; user declined to pick
+   ("不拍"). Assistant leans validate-only first (small, safe, and it forces G6 out as a prerequisite);
+   auto-suggest can wait for a real usage signal. UNRESOLVED — gates the /design-review scope if/when
+   one is opened.
+2. **The single distributed point — "acquire a free graph" lease semantics.** What happens when the
+   lease expires mid-write; can a human reclaim mid-handoff; two agents racing for the same idle graph.
+   This is the one place a little distributed coordination is unavoidable even though graphs are
+   single-machine.
+3. **Blueprint 80/20.** Lookup-by-blueprint prevents the ~80% common conflict (two agents want the
+   same block — direct stomp). The ~20% cross-graph RIPPLE (I write graph #7, an async wire pushes a
+   non-intended value into graph #9's invariant) still needs wire-aware causal analysis. Worth a
+   standing causal-analysis cost, or on-demand only?
+4. **Causal-conflict UX.** Causal-dimension conflicts are more PRECISE than text conflicts but more
+   ABSTRACT ("your change, three wire-hops out, violates my graph's invariant"). `explain()` gives the
+   chain; how to render "two changes are causally incompatible" so a human AND an agent can act on it.
+5. **Topology-edit fission (V6 subtlety):** is the independence criterion evaluated on pre- or
+   post-change topology, and what's the unit (graph vs wire-connected-component)?
+6. **Fusion semantics (V7):** the ownership-merge protocol when two active writers combine graphs.
+
+## PART 4: DECISION-HYGIENE FLAGS (surfaced, NOT acted on)
+
+Per feedback_no_autonomous_decisions — these were recorded as FLAGS for the user to adjudicate. The
+user adjudicated all three on 2026-05-31 (see rulings inline). NONE of these rulings are themselves
+locked decisions/spec changes yet — they set DIRECTION; the actual L2-retire / D22-amend land via the
+proper flows (decisions.jsonl / /spec-amend) when the user opens them.
+
+- **F1 — RESOLVED (user 2026-05-31): L2 is OBSOLETE; both TS and Rust clean-slate branches already
+  lean D22 / V2.** The user's V1 ("graph / causally-connected component = write-isolation +
+  parallel unit") is NOT in conflict with the live codebase — it is the live direction. DS-14.6.A
+  **L2 (subgraph-level write isolation) is retired/stale.** Critical history the user supplied:
+  dispatcher:graph is NOT constrained 1:1 (see CORRECTION 2026-05-31b in PART 1); Rust originally
+  pursued fine-grained subgraph locking (the many mutex/lock machinery in
+  `rust-port-d3-per-subgraph-parallelism`), found it **hurt performance**, and **DROPPED it** to land
+  on D22 (`decisions.jsonl` D22, 2026-05-27: "graph = causal domain = concurrency domain =
+  single-threaded; ... **Rust drops the actor model**; Py drops the subgraph lock"). **CORRECTION
+  2026-05-31 (user): D22 DROPS the actor model — do NOT say Rust "moved to an actor model" (an earlier
+  assistant misquote, retracted).** Rust's actual parallelism/perf direction is **DR-8** (2026-05-30):
+  perf END-STATE = **arena + index/generational handles** (move the hot path off `Rc<RefCell>` onto
+  arena-owned nodes addressed by index handles), with D22 honored — intra-graph multi-threading stays
+  OUT, parallelism = multi-graph (one thread per graph). So the subgraph-lock approach was tried and
+  rejected on perf grounds; V1 = where both tracks already are. V1 ≡ the causally-connected-component
+  partition (cf. the dropped Rust union-find connectivity detection). **Action:** DS-14.6.A L2
+  should be marked superseded when the multi-agent write-isolation story is next formally written;
+  no live decision actually depends on L2's subgraph-level claim. The OTHER DS-14.6.A locks (L3
+  tagged pool, L4 per-view rendering, L7 actorPool, L9 heterogeneousDebate) are independent of L2 and
+  survive.
+- **F2 — RULED (a) (user 2026-05-31): amend D22 wording.** D22 "single-thread CAUSAL/concurrency
+  domain" is imprecise — causal influence SPANS wires (M4); a graph/component bounds the single-thread
+  CONCURRENCY unit, not the causal influence range. The user chose to tighten the wording (option a),
+  NOT just add commentary (option b). **This is a spec-wording change → goes through /spec-amend**
+  (rules.jsonl + formal/*.tla + conformance) when opened; flagged here as the agreed DIRECTION, not
+  yet executed. Proposed tightening: "graph/connected-component = single-thread CONCURRENCY domain;
+  in-component propagation is one synchronous causal wave (same-tick glitch-free); causal influence
+  propagates ACROSS components via async wire as delayed consistency."
+- **F3 — DEFERRED (user 2026-05-31): record now, verify later.** The new design surface (static causal
+  fission + wire-aware reachability/G6 + ownership lease + fusion negotiation) stays captured in this
+  doc; do NOT advance to /design-review yet. Re-open when the user returns to it. Smallest first step
+  when it re-opens = verify G6 (`reachable()` walking through wires) as an isolated check, since the
+  fission criterion is air unless G6 holds.
+
+If/when the user says go, the natural bundle for one /design-review 9Q pass:
+(1) drop L2 subgraph-level → "graph = write-isolation + parallel unit"; (2) static fission criterion
+(validate-only vs auto-suggest = OQ#1); (3) wire-aware reachability (G6); (4) D22 "causal"→"concurrency"
+wording; (5) check the rest of DS-14.6.A (per-view rendering L4, tagged pool L3) survives dropping L2.
+
+## PART 5: SOURCES (landscape 2026-05-31)
+
+- Multica — https://github.com/multica-ai/multica · https://deepwiki.com/multica-ai/multica/1.2-system-architecture
+  · https://multica.ai/ · issue #1900 (multi-runtime-per-agent) · AgentConn review (★/trending)
+- CubeSandbox — https://github.com/TencentCloud/CubeSandbox · https://news.ycombinator.com/item?id=47863430
+- ECC — https://github.com/affaan-m/ECC · https://ecc.tools/
+- Agent harness vs runtime (decision/execution separation consensus) —
+  https://www.credal.ai/blog/agent-harness-vs-agent-runtime ·
+  https://northflank.com/blog/code-execution-environment-for-autonomous-agents
+- Orchestrator-worker > group-chat in production —
+  https://beam.ai/agentic-insights/multi-agent-orchestration-patterns-production
+- K8s Agent Sandbox (disposable stateless sandboxes mainstreaming) —
+  https://kubernetes.io/blog/2026/03/20/running-agents-on-kubernetes-with-agent-sandbox/
+
+## PART 6: CROSS-REFS
+
+- [`SESSION-DS-14.6-A-multi-agent-context-architecture.md`](SESSION-DS-14.6-A-multi-agent-context-architecture.md)
+  — L2 (the CHALLENGED lock), L4 per-view rendering (= the kanban=ContextView insight), L7 actorPool.
+- [`SESSION-DS-14.5-A-narrative-reframe.md`](SESSION-DS-14.5-A-narrative-reframe.md) — spec-as-projection
+  (= "blueprint"), meta.owner + L0–L3 ownership staircase (= write-access model).
+- [`SESSION-multi-agent-gap-analysis.md`](SESSION-multi-agent-gap-analysis.md) — G6 cross-graph
+  explain/reachable (the prerequisite for wire-aware fission), G10 hot-swap (rewire gap).
+- [`SESSION-harness-trends-graphrefly-positioning.md`](SESSION-harness-trends-graphrefly-positioning.md)
+  — variety-reduction thesis, 0.99→1.0 node-boundary resilience, "topology IS the constraint".
+- [`SESSION-DS-14-changesets-design.md`](SESSION-DS-14-changesets-design.md) — mutate/BaseChange
+  (the git-half versioning substrate).
+- Floor: D22 (single causal/concurrency domain — see F2), D26 (graph-local clock — the M2/M6 basis),
+  F-SYNC-CORE, F-DISPATCH-ALL, D7 (handle = pure data).
+- Memory: project_rewire_gap, project_reactive_tracker, project_universal_reduction_layer,
+  feedback_no_autonomous_decisions, feedback_no_implement_without_approval.
+
+---
+
+**STATUS:** Discussion captured 2026-05-31. ZERO decisions locked. No D-number, no spec amendment, no
+code. PART 1 = corrected mechanism model (clarifies existing floor). PART 2 = exploratory vision.
+PART 3 = open questions (OQ#1 fission validate-vs-suggest still un-picked by user). PART 4 = flags
+(F1 L2-conflict, F2 D22-wording, F3 new-surface) awaiting user adjudication before any /design-review.
diff --git a/archive/docs/design-archive-index.jsonl b/archive/docs/design-archive-index.jsonl
index d7d53d82..9d1653ce 100644
--- a/archive/docs/design-archive-index.jsonl
+++ b/archive/docs/design-archive-index.jsonl
@@ -57,3 +57,5 @@
 {"id":"ds-14.6-a-9q-implementation-walk","origin":"graphrefly-ts","date":"2026-05-15","title":"DS-14.6.A 9Q Implementation Walk — multi-agent context architecture (taggedContextPool / actorPool / heterogeneousDebate)","file":"SESSION-DS-14.6-A-9Q-implementation-walk.md","topic":"The dedicated 9Q walk SESSION-DS-14.6-A L10 deferred. Greenfield confirmed (none of taggedContextPool/renderContextView/tierCompress/actorPool/heterogeneousDebate/ContextEntry exist; substrate all shipped — Message envelope+topics, materialize/selector, agent(), spawnable(), DS-14 mutate/mutationLog/LogChange). Refines the non-normative DS-14.6-A PART-3 sketches into normative signatures + exact 4-layer slot placement + spawnable-vs-actorPool selection guidance (L8) + multi-writer lock-test (delta 4). Zero new substrate (L9/L10).","decisions":["D-A1: tagged-context schema types (ContextEntry/ContextView/CompressionRule/RenderedEntry/RuleMatch) live presentation-with-preset, NOT @graphrefly/pure-ts (D193 no-substrate-consumer; Rust re-declares on consumer pressure).","D-A4: pool = append-only reactiveLog + derived tag index. Retention/poolGC = reactiveLog maxSize/trimHead; mutations ride DS-14 LogChange free; structural tier-0 immutability; side-steps the DS14R1 TTL/LRU prune-fidelity bug entirely (no per-key expiry path).","D-B1: actorPool actor = lightweight ActorHandle, NO per-actor subgraph. PART-3 cursor:SubscriptionGraph demoted to a cursor Node; active = one reactive-map node; describe() shows pool/todo/hub only (honors L7; preserves actorPool-vs-spawnable distinction).","D-C1: heterogeneousDebate until-converge = pluggable converge?(transcript)=>boolean, default = last-2-rounds-stable structural compare (zero extra LLM cost).","D-A2 (rec): per-view render incremental via closure-mirror over pool-log cursor (COMPOSITION-GUIDE §28); no O(n)-per-pressure-tick.","D-A3 (rec): one tierCompress operator; truncate/evict/reference inline; LLM path behind optional llmCompressor NodeInput; llm-summary w/o compressor => construction throw.","D-A5 (rec): one shared (entry-id,target-tier) compression cache in the pool bundle, bounded by plain LRU maxSize (regenerable => DS14R1 N/A).","D-B2 (rec): depthCap reactive (depth in SpawnRequest envelope + derived gate); cascade-cancel on release() via subscription teardown §3i; reuse spawnable depthCap/from/validate vocab.","D-B3 (rec): add CONTEXT_TOPIC='context' + TODOS_TOPIC='todos' to message.ts.","D-C2 (rec): output:'synthesizer-final' with no synthesizer-role participant => construction-time throw.","D-C3 (rec): placements presets/ai/context, presets/harness/actor-pool.ts, presets/ai/debate per CLAUDE.md D200.","D-X1 (rec): L8 spawnable-vs-actorPool selection guidance = one COMPOSITION-GUIDE-PATTERNS section (doc only); delta-4 multi-writer lock-test lands with Unit A+B."],"open_questions":[],"real_gaps":["DS14.6A-U-A tagged context (~2.5d): src/presets/ai/context/* (schema + taggedContextPool + tierCompress + renderContextView + poolGC)","DS14.6A-U-B actorPool (~2.5d): src/presets/harness/actor-pool.ts + message.ts topic constants; depends on U-A","DS14.6A-U-C heterogeneousDebate (~2d): src/presets/ai/debate/*; independent/parallelizable","DS14.6A-X (~1d): multi-writer lock-test + COMPOSITION-GUIDE-PATTERNS L8 selection section"],"related_files":["archive/docs/SESSION-DS-14.6-A-9Q-implementation-walk.md","archive/docs/SESSION-DS-14.6-A-multi-agent-context-architecture.md","archive/docs/SESSION-DS-14-changeset-residuals.md","archive/docs/SESSION-DS-14.5-adapter-abort-hookup.md","src/presets/harness/spawnable.ts","src/presets/ai/agents.ts","src/utils/ai/agents/agent.ts","src/base/composition/materialize.ts","src/utils/messaging/message.ts","CLAUDE.md","docs/optimizations.md","docs/implementation-plan.md"]}
 {"id": "ds-native-substrate-contract", "origin": "graphrefly-ts", "date": "2026-05-15", "title": "DS Native Substrate Contract — RESOLVED D206: Option A (publish async preview; pure-ts sole sync substrate; D080 deferred) + Option C committed follow-on", "file": "SESSION-DS-native-substrate-contract.md", "topic": "Cleave-/qa N1's 'build the real @graphrefly/native wrapper' is not well-posed: the napi surface is irreducibly async (Core on tokio blocking pool; sync calls deadlock — D070/D077) while @graphrefly/graphrefly consumes pure-ts's SYNC public API pervasively (incl operator/source authoring + n.cache-at-construction). The advertised install-time overrides drop-in (Q28=option c / D198, CLAUDE.md 'locked 2026-05-14') is non-functional; the only coherent path (D080 async-everywhere public API across all siblings, SESSION-rust-port-architecture.md:1155/1177/1275-1283) is explicitly deferred near-1.0 and never reconciled with Q28/D198. Decisive consumer-pressure input: the only concrete consumer (memo:Re) locked @graphrefly/pure-ts forever for mobile(Hermes)/web; native is a future, post-M5/DS-14.7-napi, install-time-only, NON-blocking backend swap → zero current pressure for native-as-drop-in (D196 ⇒ Option A). RESOLVED 2026-05-15 as D206 (user-ratified): Q-S1=Option A + Option C committed as a follow-on slice. Native publishes as honest async preview 0.0.1 (rs 5424047); @graphrefly/pure-ts stays the sole sync substrate for @graphrefly/graphrefly; D080 async-everywhere rebase (B) deferred until consumer pressure. Option C = hand-written ergonomic async @graphrefly/native public surface over Bench* (NOT a pure-ts drop-in), planned as the next /porting-to-rs slice.", "decisions": ["D206 Q-S1=Option A + Option C-as-committed-follow-on: @graphrefly/native publishes as async preview 0.0.1 + parity arm; @graphrefly/pure-ts remains the sole working sync substrate for @graphrefly/graphrefly; D080 async-everywhere presentation rebase (Option B) deferred until consumer pressure; sync-blocking bridge (D) rejected (deadlocks).", "D206 Q-S2: the B decision (can @graphrefly/graphrefly consume native?) re-opens as its own design→dev-dispatch session when memo:Re premium-backend native swap becomes blocking (post-M5+DS-14.7-napi) OR a concrete consumer files D196 parity-scenario pressure.", "D206 Q-S3: recorded as D206 in graphrefly-ts docs/rust-port-decisions.md; Q28/D198 overrides-drop-in formally deferred pending D080.", "D206 Q-S4: D203 native-publish proceeds reframed (the 'downstream forced onto pure-ts' urgency is acknowledged-inaccurate per memo:Re); ships as honest async preview; tag push native-v0.0.1 is the human action."], "open_questions": [], "real_gaps": ["DONE this session: doc-truth (ts efd4e61 / rs 16e28a8); publish-prep 0.0.1 (rs 5424047); D206 recorded; SESSION doc RESOLVED + Option C slice plan appended.", "Option C follow-on slice (NEXT /porting-to-rs, ~medium): hand-written ergonomic async @graphrefly/native public surface (subpath exports + TS over Bench* mirroring async Impl; factor rust.ts adapter into a shipped module); expose the N1 five on native (closes D203 item-8 as async); flip rust.ts as unknown as Impl → as Impl; native minor bump + README. NOT a pure-ts sync drop-in.", "Option B (D080 async-everywhere presentation rebase) stays deferred — re-opens only per Q-S2 trigger."], "related_files": ["archive/docs/SESSION-DS-native-substrate-contract.md", "archive/docs/SESSION-rust-port-architecture.md", "archive/docs/SESSION-DS-cleave-A-file-moves.md", "src/index.ts", "CLAUDE.md", "docs/optimizations.md", "packages/parity-tests/impls/types.ts", "packages/parity-tests/impls/rust.ts", "../graphrefly-rs/docs/migration-status.md", "../graphrefly-rs/crates/graphrefly-bindings-js/package.json"]}
 {"id": "rust-port-actor-model", "origin": "graphrefly-ts", "date": "2026-05-17", "title": "Rust-port concurrency: the actor / work-stealing model — Slice B strategic re-decision (supersedes D218 B2/B3)", "file": "SESSION-rust-port-actor-model.md", "topic": "The D221 bounded spike (B-2 Step 2c) proved lock-on-shared-Core is STRUCTURALLY whack-a-mole (each removed Core-global touchpoint exposes the next; the disjoint causality is NOT inherently interlocked — real +45%/1.55x separation measured — it is an implementation artifact of shared mutable Core). User reframed the design session from a (P)-seam design into a strategic re-decision and drove it to a cleaner end state than the original a/b/c: NO shared Core, NO LockedCell; the only cell is single-thread lock-free + Send; the graph topology IS the concurrency model (connected component = subgraph = ownership = parallelism = coordination boundary, all one thing); SerializationGroupId is NOT redundant — it is the cheap static substitute for the deleted union-find, promoted to the user-declared independently-schedulable-unit key; correctness = ownership move + Send (borrow checker is the lock, zero runtime lock); execution = run-to-quiescence non-preemptive per group; GraphReFly provides Send unit + runnable wake signal + sync drain, NOT a scheduler, Core never async; parallelism driven by host-native concurrency (TS worker_threads / Py multiprocessing or free-threaded / Go goroutine / standalone Rust any executor) — tokio is an option NEVER a requirement; lazy default (no SchedulingGroupId = one serial single-thread Core = safe default).", "decisions": ["No shared Core, no LockedCell; the only state cell is single-threaded, lock-free, Send.", "SerializationGroupId -> SchedulingGroupId: user-declared boundary of an independently-schedulable reactive unit (cheap static replacement for the deleted union-find); NO declaration => one default group => one causal chain => fully serial single-thread Core (safe default).", "Correctness = ownership move + Send (the borrow checker is the lock; zero runtime lock; Sync not required). Execution = run-to-quiescence, non-preemptive per group (only quiescent state moves between workers).", "GraphReFly provides exactly: the Send lock-free unit + a per-group runnable wake signal + a sync drain. NOT a scheduler; Core never introduces an async runtime.", "Parallelism is driven by host-native concurrency, not tokio: TS=worker_threads/Web Workers (1 Core/worker), Python=multiprocessing or free-threaded thread pool, Go=goroutine+channel (Go runtime is the scheduler), standalone Rust=any executor (std::thread+crossbeam, or tokio iff already present; optional default pool may ship). Binding-thread-affinity (V8 isolate/GIL) forces host-native scheduling anyway -> satisfied automatically.", "M6 = wire the per-group wake signal to the host executor; one group serviced by one worker at a time. Supersedes D218 B2 (per-shard mutex) / B3 (owner-thread-pinned overlay) and D220-EXEC's ~155-site triage.", "(F) single-thread lock-free floor restoration (cell-aware currently_firing; drop FiringGuard's Core::clone) is now strategy-core, not a side fix."], "open_questions": [], "real_gaps": ["DESIGN LOCK ONLY — implementation is a future /porting-to-rs slice gated by explicit user go-ahead (feedback_no_implement_without_approval).", "Code-check (NOT spike) before implementation: (1) claim->drain-to-quiescence->release no-mid-handoff invariant holds on all paths; (2) Core/group state genuinely Send (no Rc / persistent thread-local across handoff); (3) no process-global shared state in binding/registry/snapshot breaking N-independent-Cores (mount=same-Core is consistent: one logical graph = one Core).", "Implementation surface: delete LockedCell + shard/group-lock/owner machinery; rename SerializationGroupId->SchedulingGroupId; Send-ify the single cell; per-group wake signal; (F) floor restoration; M6 wake-bridge. wip/b2-2c-spike-d221 (F)-half = reference, (P)-half obsolete."], "related_files": ["archive/docs/SESSION-rust-port-actor-model.md", "archive/docs/SESSION-rust-port-concurrency-redesign.md", "archive/docs/SESSION-rust-port-architecture.md", "archive/docs/SESSION-rust-port-d3-per-subgraph-parallelism.md", "docs/rust-port-decisions.md", "../graphrefly-rs/docs/migration-status.md", "../graphrefly-rs/docs/porting-deferred.md", "../graphrefly-rs/CLAUDE.md"]}
+{"id":"reactive-linear-and-git","origin":"graphrefly-ts","date":"2026-05-31","title":"Reactive Linear & Git — causal-dimension multi-agent collaboration (DISCUSSION CAPTURE, zero decisions)","file":"SESSION-reactive-linear-and-git.md","topic":"Started as a /research pass on three repos from a Xiaohongshu post (Multica kanban managed-agents / CubeSandbox microVM / ECC Claude-Code config + a 'stateless agent service unit' essay) and converged into a deep architecture discussion. Produced (1) a CORRECTED mechanism model clarifying existing floor — locality is a pool/tool concern with ctx.down() as the sync/async-agnostic continuation (M1); parallelism unit = dispatcher = graph per D26, async is necessary-but-not-sufficient, the sufficient condition is a second dispatcher which only a second graph gives (M2); a sync edge welds two graphs into one engine, async wire keeps them as two pipeline-parallel engines (M3); causal domain SPANS the wire so A->wire->B is one causal domain regardless of sync/async/read-only, async buys temporal not causal decoupling (M4); one graph cannot use multiple dispatchers because that reintroduces glitches+races the wave protocol exists to kill, so single-dispatcher-per-graph is the SOURCE of correctness (M5); therefore 'graph = minimal user-decidable parallel unit' is FORCED by D26 (M6). And (2) an EXPLORATORY vision — 'a reactive blend of git and Linear' for causal-dimension (not text-dimension) multi-agent collaboration on graph code, motivated by the 'GitHub flooded with agent PRs' pain: write-isolation unit = the graph, single-writer/multi-reader (V1, CHALLENGES DS-14.6.A L2); git=optimistic-detect-after vs GraphReFly=causal-partition-prevent-before (V2); git x Linear x reactive three axes incl kanban = the ContextView rendered for a human Actor (V3); structural playpen safety one dimension above sandbox isolation (V4); create-owns ownership lifecycle where only 'acquire a free graph' needs distributed coordination, blueprint=spec-as-projection as the lookup index, don't-rebuild-redis-but-use-redis-as-adapter (V5); fission = STATIC code edit, blank-start, criterion = directed causal cones disjoint walked through wires = wire-aware reachable() = depends on G6 (V6); fusion = asymmetric harder inverse needing both writers' consent (V7).","decisions":[],"flags":["F1 RESOLVED (user 2026-05-31): DS-14.6.A L2 (subgraph-level write isolation) is OBSOLETE/stale; both TS and Rust clean-slate branches already lean D22/V2. dispatcher:graph is NOT 1:1 -- parallel unit = causally-connected component = Rust SchedulingGroupId. Rust tried L2-style subgraph mutex/lock, found it hurt perf, ripped it out, moved to D22 actor model. V1 == Rust SchedulingGroup partition; no live decision depends on L2. Mark L2 superseded when multi-agent write-isolation is next formally written; L3/L4/L7/L9 survive.","F2 RULED (a) (user 2026-05-31): amend D22 wording via /spec-amend -- 'single-thread CAUSAL/concurrency domain' to 'single-thread CONCURRENCY domain; in-component = one synchronous causal wave (same-tick glitch-free); causal influence crosses components via async wire as delayed consistency'. Direction agreed, not yet executed.","F3 DEFERRED (user 2026-05-31): record now, verify later. New design surface (static causal fission + wire-aware reachability/G6 + ownership lease + fusion negotiation) stays captured; do NOT advance to /design-review yet. Smallest re-open step = verify G6 (reachable through wires) in isolation."],"open_questions":["OQ1 (un-picked by user): fission criterion validate-only vs auto-suggest — assistant leans validate-only first (forces G6 as prereq)","OQ2: 'acquire a free graph' lease semantics — the single distributed point (expire mid-write / human reclaim / two agents race)","OQ3: blueprint 80/20 — lookup prevents ~80% direct stomps; ~20% cross-graph ripple still needs wire-aware causal analysis; standing cost or on-demand","OQ4: causal-conflict UX — more precise but more abstract than text conflicts; how to render for human+agent action","OQ5: topology-edit fission — pre- vs post-change topology; unit = graph vs wire-connected-component","OQ6: fusion ownership-merge protocol when two active writers combine graphs"],"status":"DISCUSSION CAPTURE -- flags adjudicated 2026-05-31: F1 resolved (L2 obsolete, V1=live direction=Rust SchedulingGroup), F2 ruled (a) amend D22 via /spec-amend when opened, F3 deferred. Rulings set DIRECTION; no decisions.jsonl/spec change executed yet.","related_files":["archive/docs/SESSION-DS-14.6-A-multi-agent-context-architecture.md","archive/docs/SESSION-DS-14.5-A-narrative-reframe.md","archive/docs/SESSION-multi-agent-gap-analysis.md","archive/docs/SESSION-harness-trends-graphrefly-positioning.md","archive/docs/SESSION-DS-14-changesets-design.md","docs/implementation-plan.md","docs/optimizations.md"]}
+{"id":"graphrefly-canvas-data-query-wedge","origin":"graphrefly-ts","date":"2026-06-04","title":"GraphReFly Canvas x Data Query — Trusted Data Query as the first professional wedge (DISCUSSION CAPTURE, zero decisions)","file":"SESSION-graphrefly-canvas-data-query-wedge.md","topic":"Reconnects the prior GraphReFly Canvas / Workbench product vision (n8n-like web app surface, but with UI + inspectable topology + code/spec rather than a static workflow builder) with the Data Agent / Data Query opportunity surfaced by a Xiaohongshu post about enterprise data-agent accuracy. Captures the synthesis: GraphReFly Canvas is the mother product; Trusted Data Query is the first professional paid wedge. The wedge is not 'AI writes SQL' and not a new data-specific substrate; it turns business questions into inspectable, verifiable, locally repairable topology that can wrap existing semantic/query runtimes (dbt/Cube/Snowflake/warehouse tools), then optionally promote a verified ad-hoc query graph into ETL/report/dashboard/model artifacts.","decisions":[],"status":"DISCUSSION CAPTURE ONLY -- product strategy / solution-layer direction; no D-number minted, no spec amended, no implementation started.","open_questions":["Vertical packaging: solutions/data-query starter kit vs external Canvas app vs embeddable canvas package with data-query pack","Integration order: dbt Semantic Layer, Cube, Snowflake/BigQuery, or local DuckDB/CSV first","Minimum differentiated verification set: freshness, row-count drift, schema drift, metric reconciliation, sample trace, business-rule assertion","Promotion target: dbt model, scheduled graph, notebook, dashboard/report, or saved reusable graph","Canvas form: standalone web PWA, internal demo host, or embeddable component"],"related_files":["archive/docs/SESSION-graphrefly-canvas-data-query-wedge.md","archive/docs/SESSION-first-principles-audit.md","archive/docs/SESSION-universal-reduction-layer.md","archive/docs/SESSION-handle-dispatch-substrate.md","archive/docs/SESSION-reactive-collaboration-harness.md","docs/implementation-plan.md","docs/optimizations.md"]}
diff --git a/archive/evals/ARCHIVE.md b/archive/evals/ARCHIVE.md
new file mode 100644
index 00000000..72350de6
--- /dev/null
+++ b/archive/evals/ARCHIVE.md
@@ -0,0 +1,5 @@
+# Archived Eval Harness
+
+This directory is historical material, retired from active workspace ownership during the CSP-9/B66 closeout on 2026-06-27.
+
+It is not current `@graphrefly/ts` guidance and is not part of the root test, lint, build, docs, or CI gates. CSP-8 may introduce a new clean-slate eval harness after the Canvas direction settles.
diff --git a/evals/CHEAP-AND-SAFE.md b/archive/evals/CHEAP-AND-SAFE.md
similarity index 100%
rename from evals/CHEAP-AND-SAFE.md
rename to archive/evals/CHEAP-AND-SAFE.md
diff --git a/evals/HOW-TO-EVAL.md b/archive/evals/HOW-TO-EVAL.md
similarity index 100%
rename from evals/HOW-TO-EVAL.md
rename to archive/evals/HOW-TO-EVAL.md
diff --git a/archive/evals/README.md b/archive/evals/README.md
new file mode 100644
index 00000000..35127ea5
--- /dev/null
+++ b/archive/evals/README.md
@@ -0,0 +1,133 @@
+# GraphReFly-TS Evals — Runtime Harness
+
+This directory contains the TypeScript eval runner for GraphReFly benchmarks.
+
+Language-agnostic artifacts (corpora, schemas, rubrics, templates) live in the
+spec repo at `~/src/graphrefly/evals/`.
+
+## Eval tiers
+
+### L0 — Generation (Graph > Functions contrastive)
+
+Can an LLM compose a correct graph/pipeline from a natural-language description?
+Two treatments: GraphSpec (declarative JSON) vs plain TypeScript functions. 9 tasks
+(T1–T7 + T8a/T8b) scored on validity, completion, hallucination, bugs, completeness.
+
+### L1 — Generation (NL → GraphSpec)
+
+Zero-shot composition accuracy: NL description → valid, runnable GraphSpec.
+Uses real `validateSpec()` and `compileSpec()` from `src/patterns/graphspec.ts`.
+
+### L1 — Comprehension (debug / modify / explain)
+
+Can an LLM understand, modify, and reason about an *existing* GraphSpec?
+Modification tasks (nl-mod corpus) and bug-finding tasks (contrastive-bugs corpus).
+
+### Dev-DX — Error quality
+
+Vitest suite — no LLM calls. Validates that `validateSpec()` produces actionable
+error messages for common developer mistakes.
+
+## Providers
+
+| Provider | SDK | Budget tier | Publish tier |
+|---|---|---|---|
+| `anthropic` (default) | `@anthropic-ai/sdk` | Haiku 4.5 | Sonnet/Opus 4.6 |
+| `openai` | `openai` | GPT-4o-mini | GPT-4o / GPT-4.1 |
+| `google` | `@google/genai` | Gemini 3 Flash Preview | Gemini 3.1 Pro Preview |
+| `ollama` | `openai` (Ollama) | Gemma 4 27B | — |
+| `openrouter` | `openai` | `openrouter/free` or `:free` models | paid routed models |
+| `groq` | `openai` | GPT-OSS 20B / smaller Llama-family | larger/faster OSS models |
+
+Set `EVAL_PROVIDER` to switch. SDKs are dynamically imported — only install what you use.
+
+## Quick start
+
+```bash
+# Run all automated evals (requires API key for chosen provider)
+pnpm eval
+
+# Run only the Graph>Functions contrastive eval (L0)
+pnpm eval:contrastive
+
+# Run L1 evals (generation + comprehension)
+pnpm eval:llm-dx
+
+# Run multi-model matrix eval
+pnpm eval:matrix
+
+# Generate publishable scorecard
+pnpm eval:scorecard
+
+# Run dev-DX tests (no LLM calls — vitest)
+pnpm eval:dev-dx
+
+# Compare two eval runs
+pnpm eval:compare evals/results/run-a.json evals/results/run-b.json
+```
+
+## Structure
+
+```
+evals/
+├── portable-eval-prompts.md   L0 + L1 copy-paste prompts and rubrics
+├── HOW-TO-EVAL.md             One-pager for running evals
+├── lib/                       Core eval infrastructure
+│   ├── types.ts               Shared type definitions
+│   ├── llm-client.ts          Multi-provider LLM client
+│   ├── cost.ts                Token → USD cost estimation
+│   ├── judge.ts               LLM-as-judge scoring
+│   ├── validator.ts           Wired to real validateSpec + compileSpec
+│   ├── contrastive.ts         A/B runner for Graph>Functions evals
+│   ├── harness-metrics.ts     KPI computation from run data
+│   ├── reporter.ts            Result aggregation and formatting
+│   └── runner.ts              Core eval orchestrator (generation + comprehension)
+├── dev-dx/                    Vitest suites for developer experience
+├── scripts/                   CLI entry points
+│   ├── run-all.ts             pnpm eval
+│   ├── run-l0.ts              pnpm eval:contrastive
+│   ├── run-l1.ts              pnpm eval:llm-dx
+│   ├── run-matrix.ts          pnpm eval:matrix
+│   ├── publish-scorecard.ts   pnpm eval:scorecard
+│   └── compare.ts             pnpm eval:compare
+├── scorecard/                 Generated scorecard (latest.json + latest.md)
+└── results/                   Git-tracked eval results (one file per run)
+```
+
+## Results
+
+| Run | Date | Model | Key findings |
+|-----|------|-------|-------------|
+| [Run 1](results/claude-web-2026-04-05.md) | 2026-04-05 | Claude (web) | Functions won; GraphSpec hallucination on T5/T6 |
+| [Run 2](results/claude-web-2026-04-05-run2.md) | 2026-04-05 | Claude (web) | Tie after catalog update; feedback/resilience gaps confirmed |
+
+Analysis: [eval-analysis.md](results/eval-analysis.md)
+
+## Adding evals
+
+1. Add tasks to the corpus in the spec repo (`~/src/graphrefly/evals/corpus/`)
+2. If needed, add judge prompts in the spec repo (`~/src/graphrefly/evals/templates/judge-prompts/`)
+3. The runner here automatically picks up new corpus entries
+
+## Environment variables
+
+| Variable | Default | Purpose |
+|---|---|---|
+| `EVAL_PROVIDER` | `anthropic` | LLM provider |
+| `EVAL_MODEL` | `claude-sonnet-4-6` | Model for generation |
+| `EVAL_JUDGE_MODEL` | `claude-sonnet-4-6` | Model for LLM judge |
+| `EVAL_MODELS` | — | Comma-separated for matrix runs |
+| `EVAL_PROVIDERS` | — | Provider per model (matrix) |
+| `EVAL_OLLAMA_BASE_URL` | `http://localhost:11434/v1` | Ollama endpoint |
+| `EVAL_OPENROUTER_BASE_URL` | `https://openrouter.ai/api/v1` | OpenRouter endpoint override |
+| `EVAL_COMPAT_CHAT_EXTRA_JSON` | — | JSON merged into OpenAI-compatible chat requests (e.g. OpenRouter provider routing) |
+| `EVAL_GROQ_BASE_URL` | `https://api.groq.com/openai/v1` | Groq endpoint override |
+| `SPEC_EVALS_PATH` | `~/src/graphrefly/evals` | Spec repo evals path |
+| `EVAL_L0_FROM` | — | L0 only: task id to start at (inclusive); set only one of this or `EVAL_L0_AFTER` |
+| `EVAL_L0_AFTER` | — | L0 only: task id to resume after (exclusive); set only one of this or `EVAL_L0_FROM` |
+| `EVAL_TREATMENT` | `A` | L0 only: `A` (manual catalog) \| `B` (auto-gen prompt) \| `C` (B + auto-refine) \| `D` (C + templates). See [`docs/roadmap.md`](../docs/roadmap.md) §9.1.2. |
+| `ANTHROPIC_API_KEY` | — | Anthropic provider |
+| `OPENAI_API_KEY` | — | OpenAI provider |
+| `GOOGLE_API_KEY` | — | Google provider |
+| `OPENROUTER_API_KEY` | — | OpenRouter provider |
+| `GROQ_API_KEY` | — | Groq provider |
diff --git a/evals/dev-dx/seeded-errors.test.ts b/archive/evals/dev-dx/seeded-errors.test.ts
similarity index 100%
rename from evals/dev-dx/seeded-errors.test.ts
rename to archive/evals/dev-dx/seeded-errors.test.ts
diff --git a/evals/lib/_dogfood-conformance.ts b/archive/evals/lib/_dogfood-conformance.ts
similarity index 100%
rename from evals/lib/_dogfood-conformance.ts
rename to archive/evals/lib/_dogfood-conformance.ts
diff --git a/evals/lib/budget-gate.ts b/archive/evals/lib/budget-gate.ts
similarity index 100%
rename from evals/lib/budget-gate.ts
rename to archive/evals/lib/budget-gate.ts
diff --git a/evals/lib/catalog-aware-evaluator.ts b/archive/evals/lib/catalog-aware-evaluator.ts
similarity index 100%
rename from evals/lib/catalog-aware-evaluator.ts
rename to archive/evals/lib/catalog-aware-evaluator.ts
diff --git a/evals/lib/catalog-overlay.ts b/archive/evals/lib/catalog-overlay.ts
similarity index 100%
rename from evals/lib/catalog-overlay.ts
rename to archive/evals/lib/catalog-overlay.ts
diff --git a/evals/lib/contrastive.ts b/archive/evals/lib/contrastive.ts
similarity index 100%
rename from evals/lib/contrastive.ts
rename to archive/evals/lib/contrastive.ts
diff --git a/evals/lib/cost.ts b/archive/evals/lib/cost.ts
similarity index 100%
rename from evals/lib/cost.ts
rename to archive/evals/lib/cost.ts
diff --git a/evals/lib/dry-run-provider.ts b/archive/evals/lib/dry-run-provider.ts
similarity index 100%
rename from evals/lib/dry-run-provider.ts
rename to archive/evals/lib/dry-run-provider.ts
diff --git a/evals/lib/harness-metrics.ts b/archive/evals/lib/harness-metrics.ts
similarity index 100%
rename from evals/lib/harness-metrics.ts
rename to archive/evals/lib/harness-metrics.ts
diff --git a/evals/lib/judge.ts b/archive/evals/lib/judge.ts
similarity index 100%
rename from evals/lib/judge.ts
rename to archive/evals/lib/judge.ts
diff --git a/evals/lib/limits.ts b/archive/evals/lib/limits.ts
similarity index 100%
rename from evals/lib/limits.ts
rename to archive/evals/lib/limits.ts
diff --git a/evals/lib/llm-client.ts b/archive/evals/lib/llm-client.ts
similarity index 100%
rename from evals/lib/llm-client.ts
rename to archive/evals/lib/llm-client.ts
diff --git a/evals/lib/portable-catalog.ts b/archive/evals/lib/portable-catalog.ts
similarity index 100%
rename from evals/lib/portable-catalog.ts
rename to archive/evals/lib/portable-catalog.ts
diff --git a/evals/lib/portable-templates.ts b/archive/evals/lib/portable-templates.ts
similarity index 100%
rename from evals/lib/portable-templates.ts
rename to archive/evals/lib/portable-templates.ts
diff --git a/evals/lib/rate-limiter.ts b/archive/evals/lib/rate-limiter.ts
similarity index 100%
rename from evals/lib/rate-limiter.ts
rename to archive/evals/lib/rate-limiter.ts
diff --git a/evals/lib/replay-cache.ts b/archive/evals/lib/replay-cache.ts
similarity index 100%
rename from evals/lib/replay-cache.ts
rename to archive/evals/lib/replay-cache.ts
diff --git a/evals/lib/reporter.ts b/archive/evals/lib/reporter.ts
similarity index 100%
rename from evals/lib/reporter.ts
rename to archive/evals/lib/reporter.ts
diff --git a/evals/lib/runner.ts b/archive/evals/lib/runner.ts
similarity index 100%
rename from evals/lib/runner.ts
rename to archive/evals/lib/runner.ts
diff --git a/evals/lib/types.ts b/archive/evals/lib/types.ts
similarity index 100%
rename from evals/lib/types.ts
rename to archive/evals/lib/types.ts
diff --git a/evals/lib/validator.ts b/archive/evals/lib/validator.ts
similarity index 100%
rename from evals/lib/validator.ts
rename to archive/evals/lib/validator.ts
diff --git a/evals/portable-eval-prompts.md b/archive/evals/portable-eval-prompts.md
similarity index 100%
rename from evals/portable-eval-prompts.md
rename to archive/evals/portable-eval-prompts.md
diff --git a/evals/results/.gitkeep b/archive/evals/results/.gitkeep
similarity index 100%
rename from evals/results/.gitkeep
rename to archive/evals/results/.gitkeep
diff --git a/evals/results/claude-web-2026-04-05-run2.md b/archive/evals/results/claude-web-2026-04-05-run2.md
similarity index 100%
rename from evals/results/claude-web-2026-04-05-run2.md
rename to archive/evals/results/claude-web-2026-04-05-run2.md
diff --git a/evals/results/claude-web-2026-04-05.md b/archive/evals/results/claude-web-2026-04-05.md
similarity index 100%
rename from evals/results/claude-web-2026-04-05.md
rename to archive/evals/results/claude-web-2026-04-05.md
diff --git a/evals/results/claude-web-2026-04-06-run3.md b/archive/evals/results/claude-web-2026-04-06-run3.md
similarity index 100%
rename from evals/results/claude-web-2026-04-06-run3.md
rename to archive/evals/results/claude-web-2026-04-06-run3.md
diff --git a/evals/results/claude-web-2026-04-06-run4.md b/archive/evals/results/claude-web-2026-04-06-run4.md
similarity index 100%
rename from evals/results/claude-web-2026-04-06-run4.md
rename to archive/evals/results/claude-web-2026-04-06-run4.md
diff --git a/evals/results/eval-analysis.md b/archive/evals/results/eval-analysis.md
similarity index 100%
rename from evals/results/eval-analysis.md
rename to archive/evals/results/eval-analysis.md
diff --git a/evals/results/l0-1775861258795.json b/archive/evals/results/l0-1775861258795.json
similarity index 100%
rename from evals/results/l0-1775861258795.json
rename to archive/evals/results/l0-1775861258795.json
diff --git a/evals/results/l0-1776612540191.json b/archive/evals/results/l0-1776612540191.json
similarity index 100%
rename from evals/results/l0-1776612540191.json
rename to archive/evals/results/l0-1776612540191.json
diff --git a/evals/results/l0-1776616713662.json b/archive/evals/results/l0-1776616713662.json
similarity index 100%
rename from evals/results/l0-1776616713662.json
rename to archive/evals/results/l0-1776616713662.json
diff --git a/evals/results/l0-1776616747119.json b/archive/evals/results/l0-1776616747119.json
similarity index 100%
rename from evals/results/l0-1776616747119.json
rename to archive/evals/results/l0-1776616747119.json
diff --git a/evals/results/l0-1776627148596.json b/archive/evals/results/l0-1776627148596.json
similarity index 100%
rename from evals/results/l0-1776627148596.json
rename to archive/evals/results/l0-1776627148596.json
diff --git a/evals/results/l0-codex-A.json b/archive/evals/results/l0-codex-A.json
similarity index 100%
rename from evals/results/l0-codex-A.json
rename to archive/evals/results/l0-codex-A.json
diff --git a/evals/results/l0-codex-C.json b/archive/evals/results/l0-codex-C.json
similarity index 100%
rename from evals/results/l0-codex-C.json
rename to archive/evals/results/l0-codex-C.json
diff --git a/evals/results/l0-conversational-baseline.json b/archive/evals/results/l0-conversational-baseline.json
similarity index 100%
rename from evals/results/l0-conversational-baseline.json
rename to archive/evals/results/l0-conversational-baseline.json
diff --git a/evals/results/l0-conversational-batch2.json b/archive/evals/results/l0-conversational-batch2.json
similarity index 100%
rename from evals/results/l0-conversational-batch2.json
rename to archive/evals/results/l0-conversational-batch2.json
diff --git a/evals/results/l0-glm47-A.json b/archive/evals/results/l0-glm47-A.json
similarity index 100%
rename from evals/results/l0-glm47-A.json
rename to archive/evals/results/l0-glm47-A.json
diff --git a/evals/results/l0-glm47-B.json b/archive/evals/results/l0-glm47-B.json
similarity index 100%
rename from evals/results/l0-glm47-B.json
rename to archive/evals/results/l0-glm47-B.json
diff --git a/evals/results/l0-glm47-C.json b/archive/evals/results/l0-glm47-C.json
similarity index 100%
rename from evals/results/l0-glm47-C.json
rename to archive/evals/results/l0-glm47-C.json
diff --git a/evals/results/l0-glm47-D.json b/archive/evals/results/l0-glm47-D.json
similarity index 100%
rename from evals/results/l0-glm47-D.json
rename to archive/evals/results/l0-glm47-D.json
diff --git a/evals/results/l0-qwen-A.json b/archive/evals/results/l0-qwen-A.json
similarity index 100%
rename from evals/results/l0-qwen-A.json
rename to archive/evals/results/l0-qwen-A.json
diff --git a/evals/results/l0-qwen-E.json b/archive/evals/results/l0-qwen-E.json
similarity index 100%
rename from evals/results/l0-qwen-E.json
rename to archive/evals/results/l0-qwen-E.json
diff --git a/evals/results/l1-conversational-batch1.json b/archive/evals/results/l1-conversational-batch1.json
similarity index 100%
rename from evals/results/l1-conversational-batch1.json
rename to archive/evals/results/l1-conversational-batch1.json
diff --git a/evals/results/session-2026-04-06-catalog-automation.md b/archive/evals/results/session-2026-04-06-catalog-automation.md
similarity index 100%
rename from evals/results/session-2026-04-06-catalog-automation.md
rename to archive/evals/results/session-2026-04-06-catalog-automation.md
diff --git a/evals/scorecard/latest.json b/archive/evals/scorecard/latest.json
similarity index 100%
rename from evals/scorecard/latest.json
rename to archive/evals/scorecard/latest.json
diff --git a/evals/scorecard/latest.md b/archive/evals/scorecard/latest.md
similarity index 100%
rename from evals/scorecard/latest.md
rename to archive/evals/scorecard/latest.md
diff --git a/evals/scripts/compare.ts b/archive/evals/scripts/compare.ts
similarity index 100%
rename from evals/scripts/compare.ts
rename to archive/evals/scripts/compare.ts
diff --git a/evals/scripts/publish-scorecard.ts b/archive/evals/scripts/publish-scorecard.ts
similarity index 100%
rename from evals/scripts/publish-scorecard.ts
rename to archive/evals/scripts/publish-scorecard.ts
diff --git a/evals/scripts/run-all.ts b/archive/evals/scripts/run-all.ts
similarity index 100%
rename from evals/scripts/run-all.ts
rename to archive/evals/scripts/run-all.ts
diff --git a/evals/scripts/run-harness.ts b/archive/evals/scripts/run-harness.ts
similarity index 100%
rename from evals/scripts/run-harness.ts
rename to archive/evals/scripts/run-harness.ts
diff --git a/evals/scripts/run-l0.ts b/archive/evals/scripts/run-l0.ts
similarity index 100%
rename from evals/scripts/run-l0.ts
rename to archive/evals/scripts/run-l0.ts
diff --git a/evals/scripts/run-l1.ts b/archive/evals/scripts/run-l1.ts
similarity index 100%
rename from evals/scripts/run-l1.ts
rename to archive/evals/scripts/run-l1.ts
diff --git a/evals/scripts/run-matrix.ts b/archive/evals/scripts/run-matrix.ts
similarity index 100%
rename from evals/scripts/run-matrix.ts
rename to archive/evals/scripts/run-matrix.ts
diff --git a/evals/scripts/run-treatments.ts b/archive/evals/scripts/run-treatments.ts
similarity index 100%
rename from evals/scripts/run-treatments.ts
rename to archive/evals/scripts/run-treatments.ts
diff --git a/evals/tsconfig.json b/archive/evals/tsconfig.json
similarity index 100%
rename from evals/tsconfig.json
rename to archive/evals/tsconfig.json
diff --git a/evals/vitest.config.ts b/archive/evals/vitest.config.ts
similarity index 100%
rename from evals/vitest.config.ts
rename to archive/evals/vitest.config.ts
diff --git a/examples/harness-refine-hello/CHANGELOG.md b/archive/examples/harness-refine-hello/CHANGELOG.md
similarity index 100%
rename from examples/harness-refine-hello/CHANGELOG.md
rename to archive/examples/harness-refine-hello/CHANGELOG.md
diff --git a/examples/harness-refine-hello/README.md b/archive/examples/harness-refine-hello/README.md
similarity index 100%
rename from examples/harness-refine-hello/README.md
rename to archive/examples/harness-refine-hello/README.md
diff --git a/examples/harness-refine-hello/index.ts b/archive/examples/harness-refine-hello/index.ts
similarity index 100%
rename from examples/harness-refine-hello/index.ts
rename to archive/examples/harness-refine-hello/index.ts
diff --git a/examples/harness-refine-hello/package.json b/archive/examples/harness-refine-hello/package.json
similarity index 100%
rename from examples/harness-refine-hello/package.json
rename to archive/examples/harness-refine-hello/package.json
diff --git a/examples/harness-refine-hello/pipeline.ts b/archive/examples/harness-refine-hello/pipeline.ts
similarity index 100%
rename from examples/harness-refine-hello/pipeline.ts
rename to archive/examples/harness-refine-hello/pipeline.ts
diff --git a/examples/harness-refine-hello/tsconfig.json b/archive/examples/harness-refine-hello/tsconfig.json
similarity index 100%
rename from examples/harness-refine-hello/tsconfig.json
rename to archive/examples/harness-refine-hello/tsconfig.json
diff --git a/examples/nestjs/order-flow/CHANGELOG.md b/archive/examples/nestjs/order-flow/CHANGELOG.md
similarity index 100%
rename from examples/nestjs/order-flow/CHANGELOG.md
rename to archive/examples/nestjs/order-flow/CHANGELOG.md
diff --git a/examples/nestjs/order-flow/README.md b/archive/examples/nestjs/order-flow/README.md
similarity index 100%
rename from examples/nestjs/order-flow/README.md
rename to archive/examples/nestjs/order-flow/README.md
diff --git a/examples/nestjs/order-flow/index.ts b/archive/examples/nestjs/order-flow/index.ts
similarity index 100%
rename from examples/nestjs/order-flow/index.ts
rename to archive/examples/nestjs/order-flow/index.ts
diff --git a/examples/nestjs/order-flow/package.json b/archive/examples/nestjs/order-flow/package.json
similarity index 100%
rename from examples/nestjs/order-flow/package.json
rename to archive/examples/nestjs/order-flow/package.json
diff --git a/examples/nestjs/order-flow/tsconfig.json b/archive/examples/nestjs/order-flow/tsconfig.json
similarity index 100%
rename from examples/nestjs/order-flow/tsconfig.json
rename to archive/examples/nestjs/order-flow/tsconfig.json
diff --git a/packages/parity-tests/README.md b/archive/packages/parity-tests/README.md
similarity index 100%
rename from packages/parity-tests/README.md
rename to archive/packages/parity-tests/README.md
diff --git a/packages/parity-tests/impls/pure-ts.ts b/archive/packages/parity-tests/impls/pure-ts.ts
similarity index 100%
rename from packages/parity-tests/impls/pure-ts.ts
rename to archive/packages/parity-tests/impls/pure-ts.ts
diff --git a/packages/parity-tests/impls/registry.ts b/archive/packages/parity-tests/impls/registry.ts
similarity index 100%
rename from packages/parity-tests/impls/registry.ts
rename to archive/packages/parity-tests/impls/registry.ts
diff --git a/packages/parity-tests/impls/rust.ts b/archive/packages/parity-tests/impls/rust.ts
similarity index 100%
rename from packages/parity-tests/impls/rust.ts
rename to archive/packages/parity-tests/impls/rust.ts
diff --git a/packages/parity-tests/impls/types.ts b/archive/packages/parity-tests/impls/types.ts
similarity index 100%
rename from packages/parity-tests/impls/types.ts
rename to archive/packages/parity-tests/impls/types.ts
diff --git a/packages/parity-tests/package.json b/archive/packages/parity-tests/package.json
similarity index 100%
rename from packages/parity-tests/package.json
rename to archive/packages/parity-tests/package.json
diff --git a/packages/parity-tests/scenarios/core/batch-throw-rollback.test.ts b/archive/packages/parity-tests/scenarios/core/batch-throw-rollback.test.ts
similarity index 100%
rename from packages/parity-tests/scenarios/core/batch-throw-rollback.test.ts
rename to archive/packages/parity-tests/scenarios/core/batch-throw-rollback.test.ts
diff --git a/packages/parity-tests/scenarios/core/dispatcher.test.ts b/archive/packages/parity-tests/scenarios/core/dispatcher.test.ts
similarity index 100%
rename from packages/parity-tests/scenarios/core/dispatcher.test.ts
rename to archive/packages/parity-tests/scenarios/core/dispatcher.test.ts
diff --git a/packages/parity-tests/scenarios/core/first-run-gate.test.ts b/archive/packages/parity-tests/scenarios/core/first-run-gate.test.ts
similarity index 100%
rename from packages/parity-tests/scenarios/core/first-run-gate.test.ts
rename to archive/packages/parity-tests/scenarios/core/first-run-gate.test.ts
diff --git a/packages/parity-tests/scenarios/core/invalidate-cascade.test.ts b/archive/packages/parity-tests/scenarios/core/invalidate-cascade.test.ts
similarity index 100%
rename from packages/parity-tests/scenarios/core/invalidate-cascade.test.ts
rename to archive/packages/parity-tests/scenarios/core/invalidate-cascade.test.ts
diff --git a/packages/parity-tests/scenarios/core/n1-infra.test.ts b/archive/packages/parity-tests/scenarios/core/n1-infra.test.ts
similarity index 100%
rename from packages/parity-tests/scenarios/core/n1-infra.test.ts
rename to archive/packages/parity-tests/scenarios/core/n1-infra.test.ts
diff --git a/packages/parity-tests/scenarios/core/pause-resume.test.ts b/archive/packages/parity-tests/scenarios/core/pause-resume.test.ts
similarity index 100%
rename from packages/parity-tests/scenarios/core/pause-resume.test.ts
rename to archive/packages/parity-tests/scenarios/core/pause-resume.test.ts
diff --git a/packages/parity-tests/scenarios/core/release-callback-reinstall.test.ts b/archive/packages/parity-tests/scenarios/core/release-callback-reinstall.test.ts
similarity index 100%
rename from packages/parity-tests/scenarios/core/release-callback-reinstall.test.ts
rename to archive/packages/parity-tests/scenarios/core/release-callback-reinstall.test.ts
diff --git a/packages/parity-tests/scenarios/core/set-deps.test.ts b/archive/packages/parity-tests/scenarios/core/set-deps.test.ts
similarity index 100%
rename from packages/parity-tests/scenarios/core/set-deps.test.ts
rename to archive/packages/parity-tests/scenarios/core/set-deps.test.ts
diff --git a/packages/parity-tests/scenarios/core/sink-snapshot.test.ts b/archive/packages/parity-tests/scenarios/core/sink-snapshot.test.ts
similarity index 100%
rename from packages/parity-tests/scenarios/core/sink-snapshot.test.ts
rename to archive/packages/parity-tests/scenarios/core/sink-snapshot.test.ts
diff --git a/packages/parity-tests/scenarios/core/teardown-cascade.test.ts b/archive/packages/parity-tests/scenarios/core/teardown-cascade.test.ts
similarity index 100%
rename from packages/parity-tests/scenarios/core/teardown-cascade.test.ts
rename to archive/packages/parity-tests/scenarios/core/teardown-cascade.test.ts
diff --git a/packages/parity-tests/scenarios/graph/describe-reactive.test.ts b/archive/packages/parity-tests/scenarios/graph/describe-reactive.test.ts
similarity index 100%
rename from packages/parity-tests/scenarios/graph/describe-reactive.test.ts
rename to archive/packages/parity-tests/scenarios/graph/describe-reactive.test.ts
diff --git a/packages/parity-tests/scenarios/graph/edges.test.ts b/archive/packages/parity-tests/scenarios/graph/edges.test.ts
similarity index 100%
rename from packages/parity-tests/scenarios/graph/edges.test.ts
rename to archive/packages/parity-tests/scenarios/graph/edges.test.ts
diff --git a/packages/parity-tests/scenarios/graph/observe-all-reactive.test.ts b/archive/packages/parity-tests/scenarios/graph/observe-all-reactive.test.ts
similarity index 100%
rename from packages/parity-tests/scenarios/graph/observe-all-reactive.test.ts
rename to archive/packages/parity-tests/scenarios/graph/observe-all-reactive.test.ts
diff --git a/packages/parity-tests/scenarios/graph/remove.test.ts b/archive/packages/parity-tests/scenarios/graph/remove.test.ts
similarity index 100%
rename from packages/parity-tests/scenarios/graph/remove.test.ts
rename to archive/packages/parity-tests/scenarios/graph/remove.test.ts
diff --git a/packages/parity-tests/scenarios/graph/resource-profile.test.ts b/archive/packages/parity-tests/scenarios/graph/resource-profile.test.ts
similarity index 100%
rename from packages/parity-tests/scenarios/graph/resource-profile.test.ts
rename to archive/packages/parity-tests/scenarios/graph/resource-profile.test.ts
diff --git a/packages/parity-tests/scenarios/graph/signal.test.ts b/archive/packages/parity-tests/scenarios/graph/signal.test.ts
similarity index 100%
rename from packages/parity-tests/scenarios/graph/signal.test.ts
rename to archive/packages/parity-tests/scenarios/graph/signal.test.ts
diff --git a/packages/parity-tests/scenarios/graph/sugar.test.ts b/archive/packages/parity-tests/scenarios/graph/sugar.test.ts
similarity index 100%
rename from packages/parity-tests/scenarios/graph/sugar.test.ts
rename to archive/packages/parity-tests/scenarios/graph/sugar.test.ts
diff --git a/packages/parity-tests/scenarios/graph/tag-factory.test.ts b/archive/packages/parity-tests/scenarios/graph/tag-factory.test.ts
similarity index 100%
rename from packages/parity-tests/scenarios/graph/tag-factory.test.ts
rename to archive/packages/parity-tests/scenarios/graph/tag-factory.test.ts
diff --git a/packages/parity-tests/scenarios/messaging/skip-cached-replay.test.ts b/archive/packages/parity-tests/scenarios/messaging/skip-cached-replay.test.ts
similarity index 100%
rename from packages/parity-tests/scenarios/messaging/skip-cached-replay.test.ts
rename to archive/packages/parity-tests/scenarios/messaging/skip-cached-replay.test.ts
diff --git a/packages/parity-tests/scenarios/messaging/subscription.test.ts b/archive/packages/parity-tests/scenarios/messaging/subscription.test.ts
similarity index 100%
rename from packages/parity-tests/scenarios/messaging/subscription.test.ts
rename to archive/packages/parity-tests/scenarios/messaging/subscription.test.ts
diff --git a/packages/parity-tests/scenarios/messaging/topic-substrate.test.ts b/archive/packages/parity-tests/scenarios/messaging/topic-substrate.test.ts
similarity index 100%
rename from packages/parity-tests/scenarios/messaging/topic-substrate.test.ts
rename to archive/packages/parity-tests/scenarios/messaging/topic-substrate.test.ts
diff --git a/packages/parity-tests/scenarios/operators/buffer.test.ts b/archive/packages/parity-tests/scenarios/operators/buffer.test.ts
similarity index 100%
rename from packages/parity-tests/scenarios/operators/buffer.test.ts
rename to archive/packages/parity-tests/scenarios/operators/buffer.test.ts
diff --git a/packages/parity-tests/scenarios/operators/combine.test.ts b/archive/packages/parity-tests/scenarios/operators/combine.test.ts
similarity index 100%
rename from packages/parity-tests/scenarios/operators/combine.test.ts
rename to archive/packages/parity-tests/scenarios/operators/combine.test.ts
diff --git a/packages/parity-tests/scenarios/operators/control.test.ts b/archive/packages/parity-tests/scenarios/operators/control.test.ts
similarity index 100%
rename from packages/parity-tests/scenarios/operators/control.test.ts
rename to archive/packages/parity-tests/scenarios/operators/control.test.ts
diff --git a/packages/parity-tests/scenarios/operators/flow.test.ts b/archive/packages/parity-tests/scenarios/operators/flow.test.ts
similarity index 100%
rename from packages/parity-tests/scenarios/operators/flow.test.ts
rename to archive/packages/parity-tests/scenarios/operators/flow.test.ts
diff --git a/packages/parity-tests/scenarios/operators/higher-order.test.ts b/archive/packages/parity-tests/scenarios/operators/higher-order.test.ts
similarity index 100%
rename from packages/parity-tests/scenarios/operators/higher-order.test.ts
rename to archive/packages/parity-tests/scenarios/operators/higher-order.test.ts
diff --git a/packages/parity-tests/scenarios/operators/sources.test.ts b/archive/packages/parity-tests/scenarios/operators/sources.test.ts
similarity index 100%
rename from packages/parity-tests/scenarios/operators/sources.test.ts
rename to archive/packages/parity-tests/scenarios/operators/sources.test.ts
diff --git a/packages/parity-tests/scenarios/operators/stratify.test.ts b/archive/packages/parity-tests/scenarios/operators/stratify.test.ts
similarity index 100%
rename from packages/parity-tests/scenarios/operators/stratify.test.ts
rename to archive/packages/parity-tests/scenarios/operators/stratify.test.ts
diff --git a/packages/parity-tests/scenarios/operators/subscription.test.ts b/archive/packages/parity-tests/scenarios/operators/subscription.test.ts
similarity index 100%
rename from packages/parity-tests/scenarios/operators/subscription.test.ts
rename to archive/packages/parity-tests/scenarios/operators/subscription.test.ts
diff --git a/packages/parity-tests/scenarios/operators/transform.test.ts b/archive/packages/parity-tests/scenarios/operators/transform.test.ts
similarity index 100%
rename from packages/parity-tests/scenarios/operators/transform.test.ts
rename to archive/packages/parity-tests/scenarios/operators/transform.test.ts
diff --git a/packages/parity-tests/scenarios/orchestration/approval-gate-substrate.test.ts b/archive/packages/parity-tests/scenarios/orchestration/approval-gate-substrate.test.ts
similarity index 100%
rename from packages/parity-tests/scenarios/orchestration/approval-gate-substrate.test.ts
rename to archive/packages/parity-tests/scenarios/orchestration/approval-gate-substrate.test.ts
diff --git a/packages/parity-tests/scenarios/storage-wal/README.md b/archive/packages/parity-tests/scenarios/storage-wal/README.md
similarity index 100%
rename from packages/parity-tests/scenarios/storage-wal/README.md
rename to archive/packages/parity-tests/scenarios/storage-wal/README.md
diff --git a/packages/parity-tests/scenarios/storage-wal/durability-mode-pagination.test.ts b/archive/packages/parity-tests/scenarios/storage-wal/durability-mode-pagination.test.ts
similarity index 100%
rename from packages/parity-tests/scenarios/storage-wal/durability-mode-pagination.test.ts
rename to archive/packages/parity-tests/scenarios/storage-wal/durability-mode-pagination.test.ts
diff --git a/packages/parity-tests/scenarios/storage-wal/frame-format.test.ts b/archive/packages/parity-tests/scenarios/storage-wal/frame-format.test.ts
similarity index 100%
rename from packages/parity-tests/scenarios/storage-wal/frame-format.test.ts
rename to archive/packages/parity-tests/scenarios/storage-wal/frame-format.test.ts
diff --git a/packages/parity-tests/scenarios/storage-wal/tier-1-core-ops.test.ts b/archive/packages/parity-tests/scenarios/storage-wal/tier-1-core-ops.test.ts
similarity index 100%
rename from packages/parity-tests/scenarios/storage-wal/tier-1-core-ops.test.ts
rename to archive/packages/parity-tests/scenarios/storage-wal/tier-1-core-ops.test.ts
diff --git a/packages/parity-tests/scenarios/storage-wal/tier-2-wal.test.ts b/archive/packages/parity-tests/scenarios/storage-wal/tier-2-wal.test.ts
similarity index 100%
rename from packages/parity-tests/scenarios/storage-wal/tier-2-wal.test.ts
rename to archive/packages/parity-tests/scenarios/storage-wal/tier-2-wal.test.ts
diff --git a/packages/parity-tests/scenarios/storage-wal/tier-3-restore.test.ts b/archive/packages/parity-tests/scenarios/storage-wal/tier-3-restore.test.ts
similarity index 100%
rename from packages/parity-tests/scenarios/storage-wal/tier-3-restore.test.ts
rename to archive/packages/parity-tests/scenarios/storage-wal/tier-3-restore.test.ts
diff --git a/packages/parity-tests/scenarios/structures/reactive-index-range.test.ts b/archive/packages/parity-tests/scenarios/structures/reactive-index-range.test.ts
similarity index 100%
rename from packages/parity-tests/scenarios/structures/reactive-index-range.test.ts
rename to archive/packages/parity-tests/scenarios/structures/reactive-index-range.test.ts
diff --git a/packages/parity-tests/scenarios/structures/reactive-index.test.ts b/archive/packages/parity-tests/scenarios/structures/reactive-index.test.ts
similarity index 100%
rename from packages/parity-tests/scenarios/structures/reactive-index.test.ts
rename to archive/packages/parity-tests/scenarios/structures/reactive-index.test.ts
diff --git a/packages/parity-tests/scenarios/structures/reactive-list.test.ts b/archive/packages/parity-tests/scenarios/structures/reactive-list.test.ts
similarity index 100%
rename from packages/parity-tests/scenarios/structures/reactive-list.test.ts
rename to archive/packages/parity-tests/scenarios/structures/reactive-list.test.ts
diff --git a/packages/parity-tests/scenarios/structures/reactive-log.test.ts b/archive/packages/parity-tests/scenarios/structures/reactive-log.test.ts
similarity index 100%
rename from packages/parity-tests/scenarios/structures/reactive-log.test.ts
rename to archive/packages/parity-tests/scenarios/structures/reactive-log.test.ts
diff --git a/packages/parity-tests/scenarios/structures/reactive-map.test.ts b/archive/packages/parity-tests/scenarios/structures/reactive-map.test.ts
similarity index 100%
rename from packages/parity-tests/scenarios/structures/reactive-map.test.ts
rename to archive/packages/parity-tests/scenarios/structures/reactive-map.test.ts
diff --git a/packages/parity-tests/scenarios/usage/cleanup.test.ts b/archive/packages/parity-tests/scenarios/usage/cleanup.test.ts
similarity index 100%
rename from packages/parity-tests/scenarios/usage/cleanup.test.ts
rename to archive/packages/parity-tests/scenarios/usage/cleanup.test.ts
diff --git a/packages/parity-tests/scenarios/usage/close-drains.test.ts b/archive/packages/parity-tests/scenarios/usage/close-drains.test.ts
similarity index 100%
rename from packages/parity-tests/scenarios/usage/close-drains.test.ts
rename to archive/packages/parity-tests/scenarios/usage/close-drains.test.ts
diff --git a/packages/parity-tests/tsconfig.json b/archive/packages/parity-tests/tsconfig.json
similarity index 100%
rename from packages/parity-tests/tsconfig.json
rename to archive/packages/parity-tests/tsconfig.json
diff --git a/archive/packages/parity-tests/vitest.config.ts b/archive/packages/parity-tests/vitest.config.ts
new file mode 100644
index 00000000..58691072
--- /dev/null
+++ b/archive/packages/parity-tests/vitest.config.ts
@@ -0,0 +1,54 @@
+import { fileURLToPath } from "node:url";
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+	resolve: {
+		alias: [
+			// Resolve pure-ts to source so parity tests don't require a
+			// pre-build.
+			//
+			// The subpath regex MUST precede the bare alias and is required:
+			// without it, `@graphrefly/pure-ts/extra` falls through to the
+			// built `dist/` via package `exports`, so parity would silently
+			// test STALE substrate for any `extra/*` symbol until pure-ts is
+			// rebuilt. Capture-group `$1` covers `/extra`, `/core/...`, etc.
+			{
+				find: /^@graphrefly\/pure-ts\/(.+)$/,
+				replacement: fileURLToPath(new URL("../pure-ts/src/$1", import.meta.url)),
+			},
+			{
+				find: /^@graphrefly\/pure-ts$/,
+				replacement: fileURLToPath(new URL("../pure-ts/src/index.ts", import.meta.url)),
+			},
+		],
+	},
+	test: {
+		include: ["scenarios/**/*.test.ts"],
+		exclude: ["**/node_modules/**", "**/dist/**"],
+		environment: "node",
+		// `@graphrefly/native` ships a `.node` napi binary via a CJS
+		// loader (`index.js` → `loadBinding(...)`). Vite/vitest's
+		// transform pipeline tries to source-map the loader and stalls
+		// on the binary; standalone `require("@graphrefly/native")`
+		// loads in ~4 ms (verified 2026-05-25 / D291 verify session),
+		// but the same `require` from inside a vitest worker hangs at
+		// boot indefinitely. Externalizing keeps it on node's native
+		// require path and lets vitest boot in <1 s. Discovered while
+		// closing Bucket A; see graphrefly-ts/docs/cross-track-ledger.md
+		// (the parity gate would silently regress on every napi rebuild
+		// without this).
+		//
+		// D291 /qa A4 (2026-05-25): regex anchored to match the bare
+		// package `@graphrefly/native` AND its per-platform sub-packages
+		// (`@graphrefly/native-darwin-arm64`, `@graphrefly/native-linux-x64-gnu`,
+		// etc. — the napi-rs loader resolves to whichever one matches
+		// the host triple) but NOT a hypothetical future `@graphrefly/
+		// native-helpers` TS-only sibling that would benefit from vite's
+		// transform pipeline.
+		server: {
+			deps: {
+				external: [/^@graphrefly\/native($|\/|-(darwin|linux|win32)-)/],
+			},
+		},
+	},
+});
diff --git a/website/prototypes/A-water-ink.html b/archive/website-prototypes/A-water-ink.html
similarity index 100%
rename from website/prototypes/A-water-ink.html
rename to archive/website-prototypes/A-water-ink.html
diff --git a/archive/website-prototypes/ARCHIVE.md b/archive/website-prototypes/ARCHIVE.md
new file mode 100644
index 00000000..b893e4cc
--- /dev/null
+++ b/archive/website-prototypes/ARCHIVE.md
@@ -0,0 +1,5 @@
+# Archived Website Prototypes
+
+This directory contains historical visual prototypes retired from `website/prototypes` during the CSP-9/B66 closeout on 2026-06-27.
+
+Prototype copy, install commands, and import snippets here are non-guidance. Current TypeScript package guidance lives under `@graphrefly/ts` docs, not these archived mockups.
diff --git a/website/prototypes/B-signal-flow.html b/archive/website-prototypes/B-signal-flow.html
similarity index 100%
rename from website/prototypes/B-signal-flow.html
rename to archive/website-prototypes/B-signal-flow.html
diff --git a/website/prototypes/C-constellation.html b/archive/website-prototypes/C-constellation.html
similarity index 100%
rename from website/prototypes/C-constellation.html
rename to archive/website-prototypes/C-constellation.html
diff --git a/website/prototypes/D-topographic.html b/archive/website-prototypes/D-topographic.html
similarity index 100%
rename from website/prototypes/D-topographic.html
rename to archive/website-prototypes/D-topographic.html
diff --git a/website/prototypes/E-glass-light.html b/archive/website-prototypes/E-glass-light.html
similarity index 100%
rename from website/prototypes/E-glass-light.html
rename to archive/website-prototypes/E-glass-light.html
diff --git a/website/prototypes/F-newspaper.html b/archive/website-prototypes/F-newspaper.html
similarity index 100%
rename from website/prototypes/F-newspaper.html
rename to archive/website-prototypes/F-newspaper.html
diff --git a/website/prototypes/py-1-ink-scroll.html b/archive/website-prototypes/py-1-ink-scroll.html
similarity index 100%
rename from website/prototypes/py-1-ink-scroll.html
rename to archive/website-prototypes/py-1-ink-scroll.html
diff --git a/website/prototypes/py-2-terminal-green.html b/archive/website-prototypes/py-2-terminal-green.html
similarity index 100%
rename from website/prototypes/py-2-terminal-green.html
rename to archive/website-prototypes/py-2-terminal-green.html
diff --git a/website/prototypes/py-3-paper-lab.html b/archive/website-prototypes/py-3-paper-lab.html
similarity index 100%
rename from website/prototypes/py-3-paper-lab.html
rename to archive/website-prototypes/py-3-paper-lab.html
diff --git a/website/prototypes/py-4-geometric-zen.html b/archive/website-prototypes/py-4-geometric-zen.html
similarity index 100%
rename from website/prototypes/py-4-geometric-zen.html
rename to archive/website-prototypes/py-4-geometric-zen.html
diff --git a/website/prototypes/py-5-data-cascade.html b/archive/website-prototypes/py-5-data-cascade.html
similarity index 100%
rename from website/prototypes/py-5-data-cascade.html
rename to archive/website-prototypes/py-5-data-cascade.html
diff --git a/website/prototypes/ts-1-signal-noir.html b/archive/website-prototypes/ts-1-signal-noir.html
similarity index 100%
rename from website/prototypes/ts-1-signal-noir.html
rename to archive/website-prototypes/ts-1-signal-noir.html
diff --git a/website/prototypes/ts-2-neon-blueprint.html b/archive/website-prototypes/ts-2-neon-blueprint.html
similarity index 100%
rename from website/prototypes/ts-2-neon-blueprint.html
rename to archive/website-prototypes/ts-2-neon-blueprint.html
diff --git a/website/prototypes/ts-3-gradient-prism.html b/archive/website-prototypes/ts-3-gradient-prism.html
similarity index 100%
rename from website/prototypes/ts-3-gradient-prism.html
rename to archive/website-prototypes/ts-3-gradient-prism.html
diff --git a/website/prototypes/ts-4-brutalist-clarity.html b/archive/website-prototypes/ts-4-brutalist-clarity.html
similarity index 100%
rename from website/prototypes/ts-4-brutalist-clarity.html
rename to archive/website-prototypes/ts-4-brutalist-clarity.html
diff --git a/website/prototypes/ts-5-organic-flow.html b/archive/website-prototypes/ts-5-organic-flow.html
similarity index 100%
rename from website/prototypes/ts-5-organic-flow.html
rename to archive/website-prototypes/ts-5-organic-flow.html
diff --git a/website/prototypes/ts-6-brutalist-flipboard.html b/archive/website-prototypes/ts-6-brutalist-flipboard.html
similarity index 100%
rename from website/prototypes/ts-6-brutalist-flipboard.html
rename to archive/website-prototypes/ts-6-brutalist-flipboard.html
diff --git a/website/prototypes/v2/d1-carbon-notebook.html b/archive/website-prototypes/v2/d1-carbon-notebook.html
similarity index 100%
rename from website/prototypes/v2/d1-carbon-notebook.html
rename to archive/website-prototypes/v2/d1-carbon-notebook.html
diff --git a/website/prototypes/v2/d2-phosphor-terminal.html b/archive/website-prototypes/v2/d2-phosphor-terminal.html
similarity index 100%
rename from website/prototypes/v2/d2-phosphor-terminal.html
rename to archive/website-prototypes/v2/d2-phosphor-terminal.html
diff --git a/website/prototypes/v2/d3-indigo-cartographer.html b/archive/website-prototypes/v2/d3-indigo-cartographer.html
similarity index 100%
rename from website/prototypes/v2/d3-indigo-cartographer.html
rename to archive/website-prototypes/v2/d3-indigo-cartographer.html
diff --git a/website/prototypes/v2/index.html b/archive/website-prototypes/v2/index.html
similarity index 100%
rename from website/prototypes/v2/index.html
rename to archive/website-prototypes/v2/index.html
diff --git a/website/prototypes/v2/l1-swiss-architect.html b/archive/website-prototypes/v2/l1-swiss-architect.html
similarity index 100%
rename from website/prototypes/v2/l1-swiss-architect.html
rename to archive/website-prototypes/v2/l1-swiss-architect.html
diff --git a/website/prototypes/v2/l2-botanical-journal.html b/archive/website-prototypes/v2/l2-botanical-journal.html
similarity index 100%
rename from website/prototypes/v2/l2-botanical-journal.html
rename to archive/website-prototypes/v2/l2-botanical-journal.html
diff --git a/website/prototypes/v2/l3-cyber-showroom-v2.html b/archive/website-prototypes/v2/l3-cyber-showroom-v2.html
similarity index 100%
rename from website/prototypes/v2/l3-cyber-showroom-v2.html
rename to archive/website-prototypes/v2/l3-cyber-showroom-v2.html
diff --git a/website/prototypes/v2/l3-cyber-showroom.html b/archive/website-prototypes/v2/l3-cyber-showroom.html
similarity index 100%
rename from website/prototypes/v2/l3-cyber-showroom.html
rename to archive/website-prototypes/v2/l3-cyber-showroom.html
diff --git a/biome.json b/biome.json
index d8d02700..04ad6f58 100644
--- a/biome.json
+++ b/biome.json
@@ -17,10 +17,13 @@
 			"!**/.astro",
 			"!.tmp",
 			"!TRASH",
+			"!archive/evals",
+			"!archive/examples",
+			"!archive/packages",
+			"!archive/website-prototypes",
 			"!benchmarks",
 			"!website",
-			"!examples/nestjs",
-			"!evals/results/replay-cache"
+			"!examples/nestjs"
 		]
 	},
 	"linter": {
@@ -102,6 +105,14 @@
 					}
 				}
 			}
+		},
+		{
+			"includes": ["examples/nestjs-graph-boundary/**"],
+			"javascript": {
+				"parser": {
+					"unsafeParameterDecoratorsEnabled": true
+				}
+			}
 		}
 	]
 }
diff --git a/demos/compat-matrix/astro.config.mjs b/demos/compat-matrix/astro.config.mjs
index 349f3531..aec8f5d5 100644
--- a/demos/compat-matrix/astro.config.mjs
+++ b/demos/compat-matrix/astro.config.mjs
@@ -35,25 +35,8 @@ export default defineConfig({
 	vite: {
 		resolve: {
 			conditions: ["browser"],
-			dedupe: ["@graphrefly/pure-ts"],
 			alias: [{ find: /^svelte$/, replacement: svelteClientEntry }],
 		},
-		build: {
-			rollupOptions: {
-				// `@mlc-ai/web-llm` — peer dep of the library's browser
-				// `webllmAdapter` (dynamic import with `.catch()`).
-				// `node:*` builtins — the library's Node-only code paths
-				// (`fallbackAdapter`, `withReplayCache`, `fileStorage`,
-				// `sqliteStorage`) import them; the demo never calls them,
-				// but rollup tree-shakes the dist and needs them externalized.
-				external: ["@mlc-ai/web-llm", /^node:/],
-			},
-		},
-		optimizeDeps: {
-			exclude: ["@mlc-ai/web-llm"],
-			esbuildOptions: {
-				conditions: ["browser"],
-			},
-		},
+		optimizeDeps: { esbuildOptions: { conditions: ["browser"] } },
 	},
 });
diff --git a/demos/compat-matrix/package.json b/demos/compat-matrix/package.json
index bd3aeeda..7b046188 100644
--- a/demos/compat-matrix/package.json
+++ b/demos/compat-matrix/package.json
@@ -8,7 +8,7 @@
 		"preview": "astro preview"
 	},
 	"dependencies": {
-		"@graphrefly/graphrefly": "workspace:*",
+		"@graphrefly/ts": "workspace:*",
 		"astro": "^5.16.0",
 		"@astrojs/react": "^4.0.0",
 		"@astrojs/vue": "^5.1.4",
diff --git a/demos/compat-matrix/src/components/ReactDemo.tsx b/demos/compat-matrix/src/components/ReactDemo.tsx
index 944c4be6..5e00d82c 100644
--- a/demos/compat-matrix/src/components/ReactDemo.tsx
+++ b/demos/compat-matrix/src/components/ReactDemo.tsx
@@ -1,10 +1,16 @@
-import type { Node } from "@graphrefly/graphrefly";
-import type { ReadableAtom, WritableAtom } from "@graphrefly/graphrefly/compat/jotai";
-import type { NanoAtom, NanoComputed } from "@graphrefly/graphrefly/compat/nanostores";
-import { useStore, useSubscribe, useSubscribeRecord } from "@graphrefly/graphrefly/compat/react";
-import type { StoreApi } from "@graphrefly/graphrefly/compat/zustand";
-import type { DemoShellHandle } from "@graphrefly/graphrefly/utils/demo-shell";
-import { demoShell } from "@graphrefly/graphrefly/utils/demo-shell";
+import type {
+	JotaiAtom,
+	NanoAtom,
+	WritableJotaiAtom,
+	WritableNanoAtom,
+	ZustandStoreApi,
+} from "@graphrefly/ts/adapters";
+import {
+	useNodeRecord,
+	useNodeInput as useStore,
+	useNodeValue as useSubscribe,
+} from "@graphrefly/ts/adapters/react";
+import type { Node } from "@graphrefly/ts/graph";
 import { useCallback, useEffect, useRef, useState, useSyncExternalStore } from "react";
 import {
 	counterGraph,
@@ -22,6 +28,7 @@ import {
 	zustandDoubledSelector,
 	zustandStore,
 } from "../lib/counter";
+import { type DemoShellHandle, demoShell } from "../lib/demo-shell";
 import {
 	type CodeLayoutSummary,
 	getMeasurementAdapter,
@@ -34,7 +41,7 @@ import { attachPanZoom } from "../lib/pan-zoom";
 
 // ── Custom hooks for non-React-native bindings ─────────────────────────
 
-function useAtomValue<T>(atom: ReadableAtom<T> | WritableAtom<T>): T {
+function useAtomValue<T>(atom: JotaiAtom<T> | WritableJotaiAtom<T>): T | undefined {
 	return useSyncExternalStore(
 		(onStoreChange) => atom.subscribe(() => onStoreChange()),
 		() => atom.get(),
@@ -42,7 +49,7 @@ function useAtomValue<T>(atom: ReadableAtom<T> | WritableAtom<T>): T {
 	);
 }
 
-function useNanoValue<T>(store: NanoAtom<T>): [T, (v: T) => void] {
+function useNanoValue<T>(store: WritableNanoAtom<T>): [T | undefined, (v: T) => void] {
 	const value = useSyncExternalStore(
 		(onStoreChange) => store.subscribe(() => onStoreChange()),
 		() => store.get(),
@@ -52,7 +59,7 @@ function useNanoValue<T>(store: NanoAtom<T>): [T, (v: T) => void] {
 	return [value, set];
 }
 
-function useNanoComputed<T>(store: NanoComputed<T>): T {
+function useNanoComputed<T>(store: NanoAtom<T>): T | undefined {
 	return useSyncExternalStore(
 		(onStoreChange) => store.subscribe(() => onStoreChange()),
 		() => store.get(),
@@ -60,7 +67,7 @@ function useNanoComputed<T>(store: NanoComputed<T>): T {
 	);
 }
 
-function useZustandStore<T extends object>(store: StoreApi<T>): T {
+function useZustandStore<T extends object>(store: ZustandStoreApi<T>): T {
 	return useSyncExternalStore(
 		(onStoreChange) => store.subscribe(() => onStoreChange()),
 		() => store.getState(),
@@ -68,7 +75,10 @@ function useZustandStore<T extends object>(store: StoreApi<T>): T {
 	);
 }
 
-function useZustandSelector<T extends object, R>(store: StoreApi<T>, selector: (s: T) => R): R {
+function useZustandSelector<T extends object, R>(
+	store: ZustandStoreApi<T>,
+	selector: (s: T) => R,
+): R {
 	return useSyncExternalStore(
 		(onStoreChange) => store.subscribe(() => onStoreChange()),
 		() => selector(store.getState()),
@@ -88,16 +98,16 @@ const LIB_LABELS: Record<LibName, string> = {
 };
 
 const LIB_DESCS: Record<LibName, string> = {
-	graphrefly: "Direct node · useStore / useSubscribe",
-	jotai: "Derived atom · atom(read, write)",
-	nanostores: "Sync atom · bidirectional bridge",
-	zustand: "Store API · create(initializer)",
+	graphrefly: "Direct node · framework adapter",
+	jotai: "jotaiAtom facade",
+	nanostores: "nanoAtom facade",
+	zustand: "zustandStore facade",
 };
 
 function RawCard({ selected, onSelect }: { selected: boolean; onSelect: () => void }) {
-	const [value, setValue] = useStore(rawNode as Node<number>);
+	const [value, setValue] = useStore(rawNode);
 	const count = (value as number) ?? 0;
-	const doubled = useSubscribe(rawDoubledNode as Node<number>) as number | null;
+	const doubled = useSubscribe(rawDoubledNode) as number | null;
 	return (
 		<div
 			className={`counter-card${selected ? " selected" : ""}`}
@@ -177,7 +187,8 @@ function JotaiCard({ selected, onSelect }: { selected: boolean; onSelect: () =>
 }
 
 function NanoCard({ selected, onSelect }: { selected: boolean; onSelect: () => void }) {
-	const [count, setCount] = useNanoValue(nanoCounter);
+	const [value, setCount] = useNanoValue(nanoCounter);
+	const count = value ?? 0;
 	const doubled = useNanoComputed(nanoDoubled) ?? 0;
 	return (
 		<div
@@ -266,18 +277,18 @@ function Leaderboard({
 	selected: LibName | "leaderboard" | null;
 	onSelect: (lib: LibName | "leaderboard") => void;
 }) {
-	const record = useSubscribeRecord(
-		keysNode as Node<string[]>,
+	const record = useNodeRecord(
+		keysNode,
 		counterNodeFactory as (key: string) => { count: Node<number> },
 	);
-	const total = useSubscribe(totalNode as Node<number>);
+	const total = useSubscribe(totalNode);
 
 	return (
 		<div
 			className={`leaderboard${selected === "leaderboard" ? " selected" : ""}`}
 			onClick={() => onSelect("leaderboard")}
 		>
-			<div className="leaderboard-title">Leaderboard — useSubscribeRecord</div>
+			<div className="leaderboard-title">Leaderboard — node record</div>
 			<div className="leaderboard-rows">
 				{(["graphrefly", "jotai", "nanostores", "zustand"] as LibName[]).map((lib) => (
 					<button
@@ -370,8 +381,7 @@ export default function ReactDemo() {
 	// Create shell once
 	useEffect(() => {
 		// (#1) Pass a CanvasMeasureAdapter so the shell's `layout/code-lines`
-		// derived node (and `layout/graph-labels`) turn on — otherwise
-		// those paths are dormant per demo-shell.ts:343.
+		// derived node can recompute with the side-pane width.
 		const shell = demoShell({
 			mainRatio: 0.6,
 			viewportWidth: window.innerWidth,
@@ -507,7 +517,7 @@ export default function ReactDemo() {
 	const codeSnippet = codeKey ? codeSnippets[codeKey] : null;
 	const codeTitle = codeKey
 		? codeKey === "leaderboard"
-			? "Leaderboard — useSubscribeRecord code"
+			? "Leaderboard — node record code"
 			: `${LIB_LABELS[codeKey as LibName]} — binding code`
 		: "Select a card to see code";
 
diff --git a/demos/compat-matrix/src/components/SolidDemo.tsx b/demos/compat-matrix/src/components/SolidDemo.tsx
index 0f6ba62a..6eaf9d82 100644
--- a/demos/compat-matrix/src/components/SolidDemo.tsx
+++ b/demos/compat-matrix/src/components/SolidDemo.tsx
@@ -1,12 +1,18 @@
 /** @jsxImportSource solid-js */
 
-import type { Node } from "@graphrefly/graphrefly";
-import type { ReadableAtom, WritableAtom } from "@graphrefly/graphrefly/compat/jotai";
-import type { NanoAtom, NanoComputed } from "@graphrefly/graphrefly/compat/nanostores";
-import { useStore, useSubscribe, useSubscribeRecord } from "@graphrefly/graphrefly/compat/solid";
-import type { StoreApi } from "@graphrefly/graphrefly/compat/zustand";
-import type { DemoShellHandle } from "@graphrefly/graphrefly/utils/demo-shell";
-import { demoShell } from "@graphrefly/graphrefly/utils/demo-shell";
+import type {
+	JotaiAtom,
+	NanoAtom,
+	WritableJotaiAtom,
+	WritableNanoAtom,
+	ZustandStoreApi,
+} from "@graphrefly/ts/adapters";
+import {
+	createNodeRecord,
+	createNodeInput as useStore,
+	createNodeValue as useSubscribe,
+} from "@graphrefly/ts/adapters/solid";
+import type { Node } from "@graphrefly/ts/graph";
 import { createEffect, createMemo, createSignal, onCleanup, onMount } from "solid-js";
 import {
 	counterGraph,
@@ -24,6 +30,7 @@ import {
 	zustandDoubledSelector,
 	zustandStore,
 } from "../lib/counter";
+import { type DemoShellHandle, demoShell } from "../lib/demo-shell";
 import {
 	type CodeLayoutSummary,
 	getMeasurementAdapter,
@@ -45,15 +52,15 @@ const LIB_LABELS: Record<LibName, string> = {
 };
 
 const LIB_DESCS: Record<LibName, string> = {
-	graphrefly: "Direct node · useStore / useSubscribe",
-	jotai: "Derived atom · atom(read, write)",
-	nanostores: "Sync atom · bidirectional bridge",
-	zustand: "Store API · create(initializer)",
+	graphrefly: "Direct node · framework adapter",
+	jotai: "jotaiAtom facade",
+	nanostores: "nanoAtom facade",
+	zustand: "zustandStore facade",
 };
 
 // ── Custom bridging hooks ─────────────────────────────────────────────
 
-function useJotaiAtom<T>(atom: WritableAtom<T>) {
+function useJotaiAtom<T>(atom: WritableJotaiAtom<T>) {
 	const [value, setValue] = createSignal<T>(atom.get(), { equals: false });
 	const unsub = atom.subscribe((v: T) => setValue(() => v));
 	onCleanup(() => unsub());
@@ -63,14 +70,14 @@ function useJotaiAtom<T>(atom: WritableAtom<T>) {
 	};
 }
 
-function useJotaiReadonly<T>(atom: ReadableAtom<T>) {
+function useJotaiReadonly<T>(atom: JotaiAtom<T>) {
 	const [value, setValue] = createSignal<T>(atom.get(), { equals: false });
 	const unsub = atom.subscribe((v: T) => setValue(() => v));
 	onCleanup(() => unsub());
 	return value;
 }
 
-function useNanoAtom<T>(store: NanoAtom<T>) {
+function useNanoAtom<T>(store: WritableNanoAtom<T>) {
 	const [value, setValue] = createSignal<T>(store.get(), { equals: false });
 	const unsub = store.subscribe((v: T) => setValue(() => v));
 	onCleanup(() => unsub());
@@ -80,21 +87,21 @@ function useNanoAtom<T>(store: NanoAtom<T>) {
 	};
 }
 
-function useNanoComputedValue<T>(store: NanoComputed<T>) {
+function useNanoComputedValue<T>(store: NanoAtom<T>) {
 	const [value, setValue] = createSignal<T>(store.get(), { equals: false });
 	const unsub = store.subscribe((v: T) => setValue(() => v));
 	onCleanup(() => unsub());
 	return value;
 }
 
-function useZustandAtom<T extends object>(store: StoreApi<T>) {
+function useZustandAtom<T extends object>(store: ZustandStoreApi<T>) {
 	const [value, setValue] = createSignal<T>(store.getState(), { equals: false });
 	const unsub = store.subscribe((s: T) => setValue(() => s));
 	onCleanup(() => unsub());
 	return value;
 }
 
-function useZustandSelector<T extends object, R>(store: StoreApi<T>, selector: (s: T) => R) {
+function useZustandSelector<T extends object, R>(store: ZustandStoreApi<T>, selector: (s: T) => R) {
 	const [value, setValue] = createSignal<R>(selector(store.getState()), { equals: false });
 	const unsub = store.subscribe((s: T) => setValue(() => selector(s)));
 	onCleanup(() => unsub());
@@ -124,9 +131,9 @@ export default function SolidDemo() {
 	const [codeHit, setCodeHit] = createSignal<{ line: number; graphemeIndex: number } | null>(null);
 
 	// GraphReFly raw — useStore returns [Accessor, setter]
-	const [rawValue, setRawValue] = useStore(rawNode as Node<number>);
+	const [rawValue, setRawValue] = useStore(rawNode);
 	const rawCount = createMemo(() => (rawValue() as number) ?? 0);
-	const rawDoubled = useSubscribe(rawDoubledNode as Node<number>);
+	const rawDoubled = useSubscribe(rawDoubledNode);
 	const rawDoubledVal = createMemo(() => (rawDoubled() as number) ?? 0);
 
 	// Jotai
@@ -148,11 +155,11 @@ export default function SolidDemo() {
 	const zustandDoubledDisplay = createMemo(() => (zustandDoubledVal() as number) ?? 0);
 
 	// Read-only subscriptions
-	const total = useSubscribe(totalNode as Node<number>);
+	const total = useSubscribe(totalNode);
 	const totalVal = createMemo(() => (total() as number) ?? 0);
 
-	const record = useSubscribeRecord(
-		keysNode as Node<string[]>,
+	const record = createNodeRecord(
+		keysNode,
 		counterNodeFactory as (key: string) => { count: Node<number> },
 	);
 
@@ -163,7 +170,7 @@ export default function SolidDemo() {
 	const currentTitle = createMemo(() => {
 		const s = selectedLib();
 		if (!s) return "Select a card to see code";
-		if (s === "leaderboard") return "Leaderboard — useSubscribeRecord code";
+		if (s === "leaderboard") return "Leaderboard — node record code";
 		return `${LIB_LABELS[s]} — binding code`;
 	});
 
@@ -490,7 +497,7 @@ export default function SolidDemo() {
 					class={`leaderboard${selectedLib() === "leaderboard" ? " selected" : ""}`}
 					onClick={() => selectLib("leaderboard")}
 				>
-					<div class="leaderboard-title">Leaderboard — useSubscribeRecord</div>
+					<div class="leaderboard-title">Leaderboard — node record</div>
 					<div class="leaderboard-rows">
 						{libs.map((lib) => (
 							<button
diff --git a/demos/compat-matrix/src/components/SvelteDemo.svelte b/demos/compat-matrix/src/components/SvelteDemo.svelte
index efb5067c..40b51ec5 100644
--- a/demos/compat-matrix/src/components/SvelteDemo.svelte
+++ b/demos/compat-matrix/src/components/SvelteDemo.svelte
@@ -1,8 +1,10 @@
 <script lang="ts">
-import type { Node } from "@graphrefly/graphrefly";
-import { useStore, useSubscribe, useSubscribeRecord } from "@graphrefly/graphrefly/compat/svelte";
-import type { DemoShellHandle } from "@graphrefly/graphrefly/utils/demo-shell";
-import { demoShell } from "@graphrefly/graphrefly/utils/demo-shell";
+import {
+	nodeRecord,
+	nodeWritable as useStore,
+	nodeReadable as useSubscribe,
+} from "@graphrefly/ts/adapters/svelte";
+import type { Node } from "@graphrefly/ts/graph";
 import { onMount } from "svelte";
 import { readable, writable } from "svelte/store";
 import {
@@ -21,6 +23,7 @@ import {
 	zustandDoubledSelector,
 	zustandStore,
 } from "../lib/counter";
+import { type DemoShellHandle, demoShell } from "../lib/demo-shell";
 import {
 	type CodeLayoutSummary,
 	getMeasurementAdapter,
@@ -42,10 +45,10 @@ const LIB_LABELS: Record<LibName, string> = {
 };
 
 const LIB_DESCS: Record<LibName, string> = {
-	graphrefly: "Direct node · useStore / useSubscribe",
-	jotai: "Derived atom · atom(read, write)",
-	nanostores: "Sync atom · bidirectional bridge",
-	zustand: "Store API · create(initializer)",
+	graphrefly: "Direct node · framework adapter",
+	jotai: "jotaiAtom facade",
+	nanostores: "nanoAtom facade",
+	zustand: "zustandStore facade",
 };
 
 const libs: LibName[] = ["graphrefly", "jotai", "nanostores", "zustand"];
@@ -73,25 +76,29 @@ let currentTitle = $derived(
 	selectedLib === null
 		? "Select a card to see code"
 		: selectedLib === "leaderboard"
-			? "Leaderboard — useSubscribeRecord code"
+			? "Leaderboard — node record code"
 			: `${LIB_LABELS[selectedLib]} — binding code`,
 );
 
 // ── GraphReFly raw — Svelte writable store ───────────────────────
-const rawStore = useStore(rawNode as Node<number>);
-const rawDoubledStore = useSubscribe(rawDoubledNode as Node<number>);
+const rawStore = useStore(rawNode);
+const rawDoubledStore = useSubscribe(rawDoubledNode);
 
 // ── Jotai — bridge to Svelte writable ────────────────────────────
 const jotaiStore = writable<number>(jotaiCounter.get() ?? 0);
-const jotaiUnsub = jotaiCounter.subscribe((v: number) => jotaiStore.set(v));
+const jotaiUnsub = jotaiCounter.subscribe((v: number | undefined) => jotaiStore.set(v ?? 0));
 const jotaiDoubledStore = writable<number>(jotaiDoubled.get() ?? 0);
-const jotaiDoubledUnsub = jotaiDoubled.subscribe((v: number) => jotaiDoubledStore.set(v));
+const jotaiDoubledUnsub = jotaiDoubled.subscribe((v: number | undefined) =>
+	jotaiDoubledStore.set(v ?? 0),
+);
 
 // ── Nanostores — bridge to Svelte writable ───────────────────────
-const nanoStore = writable<number>(nanoCounter.get());
-const nanoUnsub = nanoCounter.subscribe((v: number) => nanoStore.set(v));
+const nanoStore = writable<number>(nanoCounter.get() ?? 0);
+const nanoUnsub = nanoCounter.subscribe((v: number | undefined) => nanoStore.set(v ?? 0));
 const nanoDoubledStore = writable<number>(nanoDoubled.get() ?? 0);
-const nanoDoubledUnsub = nanoDoubled.subscribe((v: number) => nanoDoubledStore.set(v));
+const nanoDoubledUnsub = nanoDoubled.subscribe((v: number | undefined) =>
+	nanoDoubledStore.set(v ?? 0),
+);
 
 // ── Zustand — bridge to Svelte readable ──────────────────────────
 type ZustandState = { count: number; inc: () => void; dec: () => void };
@@ -105,9 +112,9 @@ const zustandDoubledSvelteStore = readable<number>(
 );
 
 // ── Total & leaderboard ──────────────────────────────────────────
-const totalStore = useSubscribe(totalNode as Node<number>);
-const recordStore = useSubscribeRecord(
-	keysNode as Node<string[]>,
+const totalStore = useSubscribe(totalNode);
+const recordStore = nodeRecord(
+	keysNode,
 	counterNodeFactory as (key: string) => { count: Node<number> },
 );
 
@@ -412,7 +419,7 @@ function setNano(v: number) {
       tabindex="0"
       onkeydown={(e) => e.key === 'Enter' && selectLib('leaderboard')}
     >
-      <div class="leaderboard-title">Leaderboard — useSubscribeRecord</div>
+      <div class="leaderboard-title">Leaderboard — node record</div>
       <div class="leaderboard-rows">
         {#each libs as lib}
           <button
diff --git a/demos/compat-matrix/src/components/VueDemo.vue b/demos/compat-matrix/src/components/VueDemo.vue
index bafe9b96..4feeed26 100644
--- a/demos/compat-matrix/src/components/VueDemo.vue
+++ b/demos/compat-matrix/src/components/VueDemo.vue
@@ -1,11 +1,17 @@
 <script setup lang="ts">
-import type { Node } from "@graphrefly/graphrefly";
-import type { WritableAtom } from "@graphrefly/graphrefly/compat/jotai";
-import type { NanoAtom, NanoComputed } from "@graphrefly/graphrefly/compat/nanostores";
-import { useStore, useSubscribe, useSubscribeRecord } from "@graphrefly/graphrefly/compat/vue";
-import type { StoreApi } from "@graphrefly/graphrefly/compat/zustand";
-import type { DemoShellHandle } from "@graphrefly/graphrefly/utils/demo-shell";
-import { demoShell } from "@graphrefly/graphrefly/utils/demo-shell";
+import type {
+	NanoAtom,
+	WritableJotaiAtom,
+	WritableNanoAtom,
+	WritableNode,
+	ZustandStoreApi,
+} from "@graphrefly/ts/adapters";
+import {
+	useNodeInput,
+	useNodeRecord,
+	useNodeValue as useSubscribe,
+} from "@graphrefly/ts/adapters/vue";
+import type { Node } from "@graphrefly/ts/graph";
 import { computed, onMounted, onUnmounted, ref, watch } from "vue";
 import {
 	counterGraph,
@@ -23,6 +29,7 @@ import {
 	zustandDoubledSelector,
 	zustandStore,
 } from "../lib/counter";
+import { type DemoShellHandle, demoShell } from "../lib/demo-shell";
 import {
 	type CodeLayoutSummary,
 	getMeasurementAdapter,
@@ -44,14 +51,24 @@ const LIB_LABELS: Record<LibName, string> = {
 };
 
 const LIB_DESCS: Record<LibName, string> = {
-	graphrefly: "Direct node · useStore / useSubscribe",
-	jotai: "Derived atom · atom(read, write)",
-	nanostores: "Sync atom · bidirectional bridge",
-	zustand: "Store API · create(initializer)",
+	graphrefly: "Direct node · framework adapter",
+	jotai: "jotaiAtom facade",
+	nanostores: "nanoAtom facade",
+	zustand: "zustandStore facade",
 };
 
 const codeSnippets = getCodeSnippets("vue");
 
+function useStore<T>(node: WritableNode<T>) {
+	const [value, setValue] = useNodeInput(node);
+	return computed({
+		get: () => value.value,
+		set: (next: T | undefined) => {
+			if (next !== undefined) setValue(next);
+		},
+	});
+}
+
 // ── Shell ─────────────────────────────────────────────────────────────
 const shell = ref<DemoShellHandle | null>(null);
 const mermaidText = ref("");
@@ -66,13 +83,13 @@ const leaderboardH = ref(0);
 const codeHit = ref<{ line: number; graphemeIndex: number } | null>(null);
 
 // ── GraphReFly raw binding ────────────────────────────────────────────
-const rawCount = useStore(rawNode as Node<number>);
-const rawDoubled = useSubscribe(rawDoubledNode as Node<number>);
+const rawCount = useStore(rawNode);
+const rawDoubled = useSubscribe(rawDoubledNode);
 
 // ── Jotai atom bridging ───────────────────────────────────────────────
-function useJotaiAtom<T>(atom: WritableAtom<T>) {
-	const value = ref<T>(atom.get()) as ReturnType<typeof ref<T>>;
-	const unsub = atom.subscribe((v: T) => {
+function useJotaiAtom<T>(atom: WritableJotaiAtom<T>) {
+	const value = ref<T | undefined>(atom.get()) as ReturnType<typeof ref<T | undefined>>;
+	const unsub = atom.subscribe((v: T | undefined) => {
 		value.value = v;
 	});
 	onUnmounted(() => unsub());
@@ -81,9 +98,12 @@ function useJotaiAtom<T>(atom: WritableAtom<T>) {
 		set: (v: T) => atom.set(v),
 	};
 }
-function useJotaiReadonly<T>(atom: { get(): T; subscribe(cb: (v: T) => void): () => void }) {
-	const value = ref<T>(atom.get()) as ReturnType<typeof ref<T>>;
-	const unsub = atom.subscribe((v: T) => {
+function useJotaiReadonly<T>(atom: {
+	get(): T | undefined;
+	subscribe(cb: (v: T | undefined) => void): () => void;
+}) {
+	const value = ref<T | undefined>(atom.get()) as ReturnType<typeof ref<T | undefined>>;
+	const unsub = atom.subscribe((v: T | undefined) => {
 		value.value = v;
 	});
 	onUnmounted(() => unsub());
@@ -93,9 +113,9 @@ const jotai = useJotaiAtom(jotaiCounter);
 const jotaiDoubledVal = useJotaiReadonly(jotaiDoubled);
 
 // ── Nanostores atom bridging ──────────────────────────────────────────
-function useNanoAtom<T>(store: NanoAtom<T>) {
-	const value = ref<T>(store.get()) as ReturnType<typeof ref<T>>;
-	const unsub = store.subscribe((v: T) => {
+function useNanoAtom<T>(store: WritableNanoAtom<T>) {
+	const value = ref<T | undefined>(store.get()) as ReturnType<typeof ref<T | undefined>>;
+	const unsub = store.subscribe((v: T | undefined) => {
 		value.value = v;
 	});
 	onUnmounted(() => unsub());
@@ -104,9 +124,9 @@ function useNanoAtom<T>(store: NanoAtom<T>) {
 		set: (v: T) => store.set(v),
 	};
 }
-function useNanoComputedValue<T>(store: NanoComputed<T>) {
-	const value = ref<T>(store.get()) as ReturnType<typeof ref<T>>;
-	const unsub = store.subscribe((v: T) => {
+function useNanoComputedValue<T>(store: NanoAtom<T>) {
+	const value = ref<T | undefined>(store.get()) as ReturnType<typeof ref<T | undefined>>;
+	const unsub = store.subscribe((v: T | undefined) => {
 		value.value = v;
 	});
 	onUnmounted(() => unsub());
@@ -116,7 +136,7 @@ const nano = useNanoAtom(nanoCounter);
 const nanoDoubledVal = useNanoComputedValue(nanoDoubled);
 
 // ── Zustand store bridging ────────────────────────────────────────────
-function useZustandStore<T extends object>(store: StoreApi<T>) {
+function useZustandStore<T extends object>(store: ZustandStoreApi<T>) {
 	const value = ref<T>(store.getState()) as ReturnType<typeof ref<T>>;
 	const unsub = store.subscribe((state: T) => {
 		value.value = state;
@@ -124,7 +144,7 @@ function useZustandStore<T extends object>(store: StoreApi<T>) {
 	onUnmounted(() => unsub());
 	return computed(() => value.value);
 }
-function useZustandSelector<T extends object, R>(store: StoreApi<T>, selector: (s: T) => R) {
+function useZustandSelector<T extends object, R>(store: ZustandStoreApi<T>, selector: (s: T) => R) {
 	const value = ref<R>(selector(store.getState())) as ReturnType<typeof ref<R>>;
 	const unsub = store.subscribe((state: T) => {
 		value.value = selector(state);
@@ -136,11 +156,10 @@ const zustand = useZustandStore(zustandStore);
 const zustandDoubledVal = useZustandSelector(zustandStore, zustandDoubledSelector);
 
 // ── Read-only subscriptions ───────────────────────────────────────────
-const total = useSubscribe(totalNode as Node<number>);
+const total = useSubscribe(totalNode);
 
-const keysRef = useSubscribe(keysNode as Node<string[]>);
-const record = useSubscribeRecord(
-	keysRef,
+const record = useNodeRecord(
+	keysNode,
 	counterNodeFactory as (key: string) => { count: Node<number> },
 );
 
@@ -158,7 +177,7 @@ const totalVal = computed(() => (total.value as number) ?? 0);
 const currentSnippet = computed(() => (selectedLib.value ? codeSnippets[selectedLib.value] : null));
 const currentTitle = computed(() => {
 	if (!selectedLib.value) return "Select a card to see code";
-	if (selectedLib.value === "leaderboard") return "Leaderboard — useSubscribeRecord code";
+	if (selectedLib.value === "leaderboard") return "Leaderboard — node record code";
 	return `${LIB_LABELS[selectedLib.value]} — binding code`;
 });
 
@@ -435,7 +454,7 @@ function onCodePaneClick(e: MouseEvent) {
         :class="{ selected: selectedLib === 'leaderboard' }"
         @click="selectLib('leaderboard')"
       >
-        <div class="leaderboard-title">Leaderboard — useSubscribeRecord</div>
+        <div class="leaderboard-title">Leaderboard — node record</div>
         <div class="leaderboard-rows">
           <button
             v-for="lib in (['graphrefly', 'jotai', 'nanostores', 'zustand'] as LibName[])"
diff --git a/demos/compat-matrix/src/lib/counter.ts b/demos/compat-matrix/src/lib/counter.ts
index ae2eb8a3..f14a0876 100644
--- a/demos/compat-matrix/src/lib/counter.ts
+++ b/demos/compat-matrix/src/lib/counter.ts
@@ -1,279 +1,232 @@
-import { DATA, Graph, type Node } from "@graphrefly/graphrefly";
-import { atom as jotaiAtom } from "@graphrefly/graphrefly/compat/jotai";
 import {
-	atom as nanoAtom,
-	computed as nanoComputed,
-} from "@graphrefly/graphrefly/compat/nanostores";
-import { create as zustandCreate } from "@graphrefly/graphrefly/compat/zustand";
+	zustandStore as createZustandStore,
+	type JotaiAtom,
+	jotaiAtom,
+	type NanoAtom,
+	type NodeRecordFactory,
+	nanoAtom,
+	type WritableJotaiAtom,
+	type WritableNanoAtom,
+	type WritableNode,
+	type ZustandStoreApi,
+} from "@graphrefly/ts/adapters";
+import { type Graph, graph, type Node } from "@graphrefly/ts/graph";
 import { createLeaderboardLayout } from "./layout-integration";
 
-export const counterGraph = new Graph("compat-matrix");
+export const counterGraph: Graph = graph({ name: "compat-matrix" });
 
-/** Scalar dep read for `graph.derived` fns (last DATA per dep, else prev wave). */
-function depVals(
-	data: readonly (readonly unknown[] | undefined)[],
-	ctx: { readonly prevData: readonly unknown[] },
-): readonly unknown[] {
-	return data.map((b, i) => (b != null && b.length > 0 ? b[b.length - 1] : ctx.prevData[i]));
-}
+// 1. GraphReFly raw: direct node access through focused framework adapters.
+export const rawNode = counterGraph.state(0, { name: "graphrefly/count" });
+export const rawDoubledNode = counterGraph.derived([rawNode], (n) => (n ?? 0) * 2, {
+	name: "graphrefly/doubled",
+});
 
-// ── 1. GraphReFly raw ─────────────────────────────────────
-// Direct node access via useStore / useSubscribe
-export const rawNode = counterGraph.state("graphrefly/count", 0);
+// 2. Jotai-style facade over caller-owned GraphReFly nodes.
+export const jotaiNode = counterGraph.state(0, { name: "jotai/count" });
+export const jotaiCounter: WritableJotaiAtom<number> = jotaiAtom(jotaiNode);
+export const jotaiDoubledNode = counterGraph.derived([jotaiNode], (n) => (n ?? 0) * 2, {
+	name: "jotai/doubled",
+});
+export const jotaiDoubled: JotaiAtom<number> = jotaiAtom(jotaiDoubledNode);
 
-// Derived: doubled — using GraphReFly's native `graph.derived`
-export const rawDoubledNode = counterGraph.derived("graphrefly/doubled", [rawNode], (data, ctx) => {
-	const [n] = depVals(data, ctx);
-	return [((n as number) ?? 0) * 2];
+// 3. Nanostores-style facade over caller-owned GraphReFly nodes.
+export const nanoNode = counterGraph.state(0, { name: "nanostores/count" });
+export const nanoCounter: WritableNanoAtom<number> = nanoAtom(nanoNode);
+export const nanoDoubledNode = counterGraph.derived([nanoNode], (n) => (n ?? 0) * 2, {
+	name: "nanostores/doubled",
 });
+export const nanoDoubled: NanoAtom<number> = nanoAtom(nanoDoubledNode);
 
-// ── 2. Jotai compat ───────────────────────────────────────
-// Backing node for the jotai atom
-export const jotaiNode = counterGraph.state("jotai/count", 0);
+// 4. Zustand-compatible facade. The graph node carries serializable state;
+// the store snapshot adds the caller-owned commands expected by Zustand users.
+type ZustandNodeState = { count: number };
+export type ZustandState = ZustandNodeState & { inc: () => void; dec: () => void };
 
-// Jotai writable derived atom: reads from jotaiNode, writes to jotaiNode.
-// autoTrackNode inside createDerivedAtom uses `a._node` for tracking,
-// so a minimal shape with just `_node` is sufficient.
-export const jotaiCounter = jotaiAtom(
-	(get) => get({ _node: jotaiNode } as any) ?? 0,
-	(_get, _set, v: number) => jotaiNode.emit(v),
+export const zustandCountNode = counterGraph.state<ZustandNodeState>(
+	{ count: 0 },
+	{ name: "zustand/count" },
 );
 
-// Derived: doubled — using Jotai's read-only derived atom API
-export const jotaiDoubled = jotaiAtom(
-	(get) => ((get({ _node: jotaiNode } as any) as number) ?? 0) * 2,
-);
+let cachedZustandCount: number | undefined;
+let cachedZustandSnapshot: ZustandState | undefined;
+function zustandSnapshot(): ZustandState {
+	const base = zustandCountNode.cache ?? { count: 0 };
+	if (cachedZustandSnapshot && cachedZustandCount === base.count) return cachedZustandSnapshot;
+	cachedZustandCount = base.count;
+	cachedZustandSnapshot = {
+		count: base.count,
+		inc: () => zustandStoreRef?.setState((state) => ({ count: state.count + 1 })),
+		dec: () => zustandStoreRef?.setState((state) => ({ count: state.count - 1 })),
+	};
+	return cachedZustandSnapshot;
+}
 
-// ── 3. Nanostores compat ──────────────────────────────────
-// Backing node for the nanostores atom
-export const nanoNode = counterGraph.state("nanostores/count", 0);
-
-// Nanostores atom — synced bidirectionally with nanoNode.
-// Re-entrancy guard prevents infinite loop: set → listen → emit → subscribe → set → ...
-export const nanoCounter = nanoAtom(0);
-let nanoSyncing = false;
-// nanoNode → nanoCounter (push changes from graph to atom)
-nanoNode.subscribe((msgs) => {
-	if (nanoSyncing) return;
-	for (const [t, v] of msgs) {
-		if (t === DATA) {
-			nanoSyncing = true;
-			nanoCounter.set(v as number);
-			nanoSyncing = false;
-		}
-	}
-});
-// nanoCounter → nanoNode (push changes from atom to graph, skip initial)
-nanoCounter.listen((v) => {
-	if (nanoSyncing) return;
-	nanoSyncing = true;
-	nanoNode.emit(v);
-	nanoSyncing = false;
-});
+function zustandWriteSnapshot(value: ZustandState): ZustandNodeState {
+	return {
+		count: value.count,
+	};
+}
 
-// Derived: doubled — using Nanostores' native `computed` API
-export const nanoDoubled = nanoComputed(nanoCounter, (n) => (n ?? 0) * 2);
-
-// ── 4. Zustand compat ─────────────────────────────────────
-type ZustandState = { count: number; inc: () => void; dec: () => void };
-export const zustandStore = zustandCreate<ZustandState>((set, get) => ({
-	count: 0,
-	inc: () => set((s) => ({ ...s, count: s.count + 1 })),
-	dec: () => set((s) => ({ ...s, count: s.count - 1 })),
-}));
-// Zustand's backing node lives on Graph "zustand" — cannot mount it on
-// counterGraph (single-owner invariant). Mirror count onto compat-matrix for
-// leaderboard / total / describe, same pattern as nanostores ↔ nanoNode.
-export const zustandCountNode = counterGraph.state("zustand/count", 0);
-let zustandCountSyncing = false;
-zustandStore.subscribe((state) => {
-	if (zustandCountSyncing) return;
-	zustandCountSyncing = true;
-	zustandCountNode.emit(state.count);
-	zustandCountSyncing = false;
-});
-zustandCountNode.emit(zustandStore.getState().count);
+let zustandStoreRef: ZustandStoreApi<ZustandState> | undefined;
+export const zustandStore: ZustandStoreApi<ZustandState> = createZustandStore(
+	zustandCountNode as unknown as WritableNode<ZustandState>,
+	zustandSnapshot(),
+	{
+		getSnapshot: () => zustandSnapshot(),
+		write: (_node, value) => {
+			zustandCountNode.set(zustandWriteSnapshot(value));
+		},
+	},
+);
+zustandStoreRef = zustandStore;
 
-// Derived: doubled — zustand has no computed() API, so the idiomatic
-// pattern is a selector `(s) => s.count * 2`. Framework code calls this
-// through useSyncExternalStore-with-selector (React/Vue/Solid/Svelte).
-export const zustandDoubledSelector = (s: ZustandState | null): number =>
-	((s?.count ?? 0) as number) * 2;
+export const zustandDoubledSelector = (s: ZustandState | null): number => (s?.count ?? 0) * 2;
+
+export const zustandCountValueNode = counterGraph.derived(
+	[zustandCountNode],
+	(state) => state?.count ?? 0,
+	{ name: "zustand/count-value" },
+);
 
-// ── Total (for useSubscribe demo) ─────────────────────────
+// Total and keyed-record demo nodes.
 export const totalNode = counterGraph.derived(
-	"total",
-	[rawNode, jotaiNode, nanoNode, zustandCountNode],
-	(data, ctx) => {
-		const [a, b, c, d] = depVals(data, ctx);
-		return [
-			((a as number) || 0) + ((b as number) || 0) + ((c as number) || 0) + ((d as number) || 0),
-		];
-	},
+	[rawNode, jotaiNode, nanoNode, zustandCountValueNode],
+	(a, b, c, d) => (a ?? 0) + (b ?? 0) + (c ?? 0) + (d ?? 0),
+	{ name: "total" },
 );
 
-// ── Keys + factory for useSubscribeRecord demo ────────────
-export const keysNode = counterGraph.state("counter-keys", [
-	"graphrefly",
-	"jotai",
-	"nanostores",
-	"zustand",
-]);
+export const keysNode = counterGraph.state<readonly string[]>(
+	["graphrefly", "jotai", "nanostores", "zustand"],
+	{ name: "counter-keys" },
+);
 
-export const counterNodeFactory = (key: string): { count: Node<number> } => {
+export const counterNodeFactory: NodeRecordFactory<string, { count: number }> = (key) => {
 	const map: Record<string, Node<number>> = {
-		graphrefly: rawNode as Node<number>,
-		jotai: jotaiNode as Node<number>,
-		nanostores: nanoNode as Node<number>,
-		zustand: zustandCountNode as Node<number>,
+		graphrefly: rawNode,
+		jotai: jotaiNode,
+		nanostores: nanoNode,
+		zustand: zustandCountValueNode,
 	};
-	return { count: map[key] ?? (rawNode as Node<number>) };
+	return { count: map[key] ?? rawNode };
 };
 
-// ── Reactive-layout integration: leaderboard block-flow positions ─────────
-// Rebuilds when `keysNode` emits new library labels — each framework can
-// subscribe to `leaderboardTotalHeight` for an auto-sizing leaderboard.
+// Reactive-layout integration: leaderboard block-flow positions.
 const leaderboardLayout = createLeaderboardLayout(
 	["graphrefly", "jotai", "nanostores", "zustand"].map((k) => `${k.toUpperCase()}  ${k}/count`),
 );
 export const leaderboardTotalHeight = leaderboardLayout.totalHeight;
-keysNode.subscribe((msgs) => {
-	for (const [t, v] of msgs) {
-		if (t === DATA) {
-			leaderboardLayout.setBlocks((v as string[]).map((k) => `${k.toUpperCase()}  ${k}/count`));
-		}
+keysNode.subscribe((msg) => {
+	if (msg[0] === "DATA") {
+		leaderboardLayout.setBlocks(
+			(msg[1] as readonly string[]).map((k) => `${k.toUpperCase()}  ${k}/count`),
+		);
 	}
 });
 
-// Code snippet strings (shown in the demo shell's code pane).
-//
-// Library-specific snippets (jotai / nanostores / zustand) describe the
-// compat library's *own* API — framework-agnostic, so they're shared.
-// Framework-specific snippets (`graphrefly` direct bindings and the
-// `leaderboard` using `useSubscribeRecord`) are parameterised per
-// framework below and selected via `getCodeSnippets(framework)`.
-
 export type FrameworkName = "react" | "vue" | "solid" | "svelte";
 
 const GRAPHREFLY_BY_FRAMEWORK: Record<FrameworkName, string> = {
-	react: `// GraphReFly — direct node binding + native derived() [React]
-import { state, derived } from "@graphrefly/graphrefly";
-import { useStore, useSubscribe } from "@graphrefly/graphrefly/compat/react";
+	react: `// GraphReFly direct node binding [React]
+import { graph } from "@graphrefly/ts/graph";
+import { useNodeInput, useNodeValue } from "@graphrefly/ts/adapters/react";
 
-const count   = state(0, { name: "count" });
-const doubled = derived([count], ([n]) => (n ?? 0) * 2);
+const g = graph({ name: "counter" });
+const count = g.state(0, { name: "count" });
+const doubled = g.derived([count], (n) => (n ?? 0) * 2, { name: "doubled" });
 
 function Counter() {
-  const [value, setValue] = useStore(count);   // [value, setter]
-  const dbl = useSubscribe(doubled);           // read-only value
+  const [value, setValue] = useNodeInput(count);
+  const dbl = useNodeValue(doubled);
 
   return (
     <div>
       <button onClick={() => setValue((value ?? 0) - 1)}>-</button>
-      <span>{value} · doubled = {dbl}</span>
+      <span>{value} / doubled = {dbl}</span>
       <button onClick={() => setValue((value ?? 0) + 1)}>+</button>
     </div>
   );
 }`,
-	vue: `<!-- GraphReFly — direct node binding + native derived() [Vue] -->
+	vue: `<!-- GraphReFly direct node binding [Vue] -->
 <script setup lang="ts">
-import { state, derived } from "@graphrefly/graphrefly";
-import { useStore, useSubscribe } from "@graphrefly/graphrefly/compat/vue";
+import { graph } from "@graphrefly/ts/graph";
+import { useNodeInput, useNodeValue } from "@graphrefly/ts/adapters/vue";
 
-const count   = state(0, { name: "count" });
-const doubled = derived([count], ([n]) => (n ?? 0) * 2);
+const g = graph({ name: "counter" });
+const count = g.state(0, { name: "count" });
+const doubled = g.derived([count], (n) => (n ?? 0) * 2, { name: "doubled" });
 
-// useStore → writable Ref (v-model friendly)
-const value = useStore(count);
-// useSubscribe → read-only Ref from any node, including derived
-const dbl = useSubscribe(doubled);
+const [value, setValue] = useNodeInput(count);
+const dbl = useNodeValue(doubled);
 </script>
 
 <template>
   <div>
-    <button @click="value = (value ?? 0) - 1">-</button>
-    <span>{{ value }} · doubled = {{ dbl }}</span>
-    <button @click="value = (value ?? 0) + 1">+</button>
+    <button @click="setValue((value ?? 0) - 1)">-</button>
+    <span>{{ value }} / doubled = {{ dbl }}</span>
+    <button @click="setValue((value ?? 0) + 1)">+</button>
   </div>
 </template>`,
-	solid: `// GraphReFly — direct node binding + native derived() [SolidJS]
-import { state, derived } from "@graphrefly/graphrefly";
-import { useStore, useSubscribe } from "@graphrefly/graphrefly/compat/solid";
+	solid: `// GraphReFly direct node binding [SolidJS]
+import { graph } from "@graphrefly/ts/graph";
+import { createNodeInput, createNodeValue } from "@graphrefly/ts/adapters/solid";
 
-const count   = state(0, { name: "count" });
-const doubled = derived([count], ([n]) => (n ?? 0) * 2);
+const g = graph({ name: "counter" });
+const count = g.state(0, { name: "count" });
+const doubled = g.derived([count], (n) => (n ?? 0) * 2, { name: "doubled" });
 
 export function Counter() {
-  // useStore → [Accessor<T>, setter]
-  const [value, setValue] = useStore(count);
-  const dbl = useSubscribe(doubled);           // Accessor<number | null>
+  const [value, setValue] = createNodeInput(count);
+  const dbl = createNodeValue(doubled);
 
   return (
     <div>
       <button onClick={() => setValue((value() ?? 0) - 1)}>-</button>
-      <span>{value()} · doubled = {dbl()}</span>
+      <span>{value()} / doubled = {dbl()}</span>
       <button onClick={() => setValue((value() ?? 0) + 1)}>+</button>
     </div>
   );
 }`,
-	svelte: `<!-- GraphReFly — direct node binding + native derived() [Svelte] -->
+	svelte: `<!-- GraphReFly direct node binding [Svelte] -->
 <script lang="ts">
-  import { state, derived } from "@graphrefly/graphrefly";
-  import { useStore, useSubscribe } from "@graphrefly/graphrefly/compat/svelte";
+  import { graph } from "@graphrefly/ts/graph";
+  import { nodeWritable, nodeReadable } from "@graphrefly/ts/adapters/svelte";
 
-  const count   = state(0, { name: "count" });
-  const doubled = derived([count], ([n]) => (n ?? 0) * 2);
+  const g = graph({ name: "counter" });
+  const count = g.state(0, { name: "count" });
+  const doubled = g.derived([count], (n) => (n ?? 0) * 2, { name: "doubled" });
 
-  // useStore → Svelte writable store; useSubscribe → readable store.
-  // Auto-subscribe via the \`$\` prefix in the template.
-  const value = useStore(count);
-  const dbl   = useSubscribe(doubled);
+  const value = nodeWritable(count);
+  const dbl = nodeReadable(doubled);
 </script>
 
 <div>
   <button on:click={() => $value = ($value ?? 0) - 1}>-</button>
-  <span>{$value} · doubled = {$dbl}</span>
+  <span>{$value} / doubled = {$dbl}</span>
   <button on:click={() => $value = ($value ?? 0) + 1}>+</button>
 </div>`,
 };
 
 const LEADERBOARD_BY_FRAMEWORK: Record<FrameworkName, string> = {
-	react: `// Leaderboard — useSubscribeRecord maps a keys node through a factory [React]
-import {
-  useSubscribeRecord,
-  useSubscribe,
-} from "@graphrefly/graphrefly/compat/react";
-
-const keys = state(["graphrefly", "jotai", "nanostores", "zustand"]);
+	react: `// Leaderboard: useNodeRecord maps keys through a node factory [React]
+import { useNodeRecord, useNodeValue } from "@graphrefly/ts/adapters/react";
 
-// factory: (key) => { count: Node<number> }
-// reacts to key additions/removals AND inner count changes
-const record = useSubscribeRecord(keys, (key) => ({
-  count: nodeForKey(key),
-}));
-
-const total = useSubscribe(totalNode);
+const keys = g.state(["graphrefly", "jotai", "nanostores", "zustand"]);
+const record = useNodeRecord(keys, (key) => ({ count: nodeForKey(key) }));
+const total = useNodeValue(totalNode);
 
 return (
   <ul>
-    {Object.entries(record).map(([k, v]) => <li>{k}: {v.count}</li>)}
+    {Object.entries(record).map(([k, v]) => <li key={k}>{k}: {v.count}</li>)}
     <li>Total: {total}</li>
   </ul>
 );`,
-	vue: `<!-- Leaderboard — useSubscribeRecord maps a keys node through a factory [Vue] -->
+	vue: `<!-- Leaderboard: useNodeRecord maps keys through a node factory [Vue] -->
 <script setup lang="ts">
-import {
-  useSubscribeRecord,
-  useSubscribe,
-} from "@graphrefly/graphrefly/compat/vue";
+import { useNodeRecord, useNodeValue } from "@graphrefly/ts/adapters/vue";
 
-const keys = state(["graphrefly", "jotai", "nanostores", "zustand"]);
-
-// record is a reactive object; re-keyed when \`keys\` changes
-const record = useSubscribeRecord(keys, (key) => ({
-  count: nodeForKey(key),
-}));
-const total = useSubscribe(totalNode);
+const keys = g.state(["graphrefly", "jotai", "nanostores", "zustand"]);
+const record = useNodeRecord(keys, (key) => ({ count: nodeForKey(key) }));
+const total = useNodeValue(totalNode);
 </script>
 
 <template>
@@ -282,19 +235,12 @@ const total = useSubscribe(totalNode);
     <li>Total: {{ total }}</li>
   </ul>
 </template>`,
-	solid: `// Leaderboard — useSubscribeRecord maps a keys node through a factory [SolidJS]
-import {
-  useSubscribeRecord,
-  useSubscribe,
-} from "@graphrefly/graphrefly/compat/solid";
+	solid: `// Leaderboard: createNodeRecord maps keys through a node factory [SolidJS]
+import { createNodeRecord, createNodeValue } from "@graphrefly/ts/adapters/solid";
 
-const keys = state(["graphrefly", "jotai", "nanostores", "zustand"]);
-
-// record is Accessor<Record<string, { count: number }>>
-const record = useSubscribeRecord(keys, (key) => ({
-  count: nodeForKey(key),
-}));
-const total = useSubscribe(totalNode);
+const keys = g.state(["graphrefly", "jotai", "nanostores", "zustand"]);
+const record = createNodeRecord(keys, (key) => ({ count: nodeForKey(key) }));
+const total = createNodeValue(totalNode);
 
 return (
   <ul>
@@ -304,20 +250,13 @@ return (
     <li>Total: {total()}</li>
   </ul>
 );`,
-	svelte: `<!-- Leaderboard — useSubscribeRecord maps a keys node through a factory [Svelte] -->
+	svelte: `<!-- Leaderboard: nodeRecord maps keys through a node factory [Svelte] -->
 <script lang="ts">
-  import {
-    useSubscribeRecord,
-    useSubscribe,
-  } from "@graphrefly/graphrefly/compat/svelte";
-
-  const keys = state(["graphrefly", "jotai", "nanostores", "zustand"]);
-
-  // recordStore is a Svelte readable store; \`$recordStore\` auto-subscribes.
-  const recordStore = useSubscribeRecord(keys, (key) => ({
-    count: nodeForKey(key),
-  }));
-  const totalStore = useSubscribe(totalNode);
+  import { nodeRecord, nodeReadable } from "@graphrefly/ts/adapters/svelte";
+
+  const keys = g.state(["graphrefly", "jotai", "nanostores", "zustand"]);
+  const recordStore = nodeRecord(keys, (key) => ({ count: nodeForKey(key) }));
+  const totalStore = nodeReadable(totalNode);
 </script>
 
 <ul>
@@ -329,61 +268,59 @@ return (
 };
 
 const SHARED_SNIPPETS = {
-	jotai: `// Jotai compat — atom API over GraphReFly node
-import { state } from "@graphrefly/graphrefly";
-import { atom } from "@graphrefly/graphrefly/compat/jotai";
-
-const countNode = state(0, { name: "count" });
-
-// Writable derived atom — reads + writes countNode
-const counter = atom(
-  (get) => get({ _node: countNode, ... }) ?? 0,
-  (_get, _set, v: number) => countNode.emit(v),
-);
+	jotai: `// Jotai-style facade over a caller-owned GraphReFly node
+import { graph } from "@graphrefly/ts/graph";
+import { jotaiAtom } from "@graphrefly/ts/adapters";
 
-// Read-only derived atom — Jotai's native computed pattern
-const doubled = atom((get) => (get(counter) ?? 0) * 2);
+const g = graph({ name: "jotai-counter" });
+const countNode = g.state(0, { name: "count" });
+const counter = jotaiAtom(countNode);
 
-// counter.get() / .set(v) / .subscribe(cb) / .update(fn)
-// doubled.get() / .subscribe(cb)  (read-only)`,
+const doubledNode = g.derived([countNode], (n) => (n ?? 0) * 2, {
+  name: "doubled",
+});
+const doubled = jotaiAtom(doubledNode);
 
-	nanostores: `// Nanostores compat — atom + computed API
-import { atom, computed } from "@graphrefly/graphrefly/compat/nanostores";
+counter.get();
+counter.set(1);
+counter.subscribe((value) => console.log(value));
+doubled.subscribe((value) => console.log(value));`,
 
-const counter = atom(0);
-// counter.get()            → current value
-// counter.set(v)           → emit to GraphReFly node
-// counter.subscribe(cb)    → fires immediately with current value
-// counter.listen(cb)       → fires only on changes
+	nanostores: `// Nanostores-style facade over a caller-owned GraphReFly node
+import { graph } from "@graphrefly/ts/graph";
+import { nanoAtom } from "@graphrefly/ts/adapters";
 
-// Computed from the counter atom
-const doubled = computed(counter, (n) => (n ?? 0) * 2);
+const g = graph({ name: "nano-counter" });
+const countNode = g.state(0, { name: "count" });
+const counter = nanoAtom(countNode);
 
-// Bidirectional: nanostores atom <-> GraphReFly state node
-// Changes in one propagate to the other reactively`,
+const doubledNode = g.derived([countNode], (n) => (n ?? 0) * 2, {
+  name: "doubled",
+});
+const doubled = nanoAtom(doubledNode);
 
-	zustand: `// Zustand compat — store API + selector-based derivation
-import { create } from "@graphrefly/graphrefly/compat/zustand";
+counter.get();
+counter.set(1);
+counter.listen((value) => console.log(value));
+doubled.subscribe((value) => console.log(value));`,
 
-const store = create<{ count: number; inc: () => void; dec: () => void }>(
-  (set, get) => ({
-    count: 0,
-    inc: () => set({ count: get().count + 1 }),
-    dec: () => set({ count: get().count - 1 }),
-  })
-);
+	zustand: `// Zustand-compatible facade over a caller-owned GraphReFly node
+import { graph } from "@graphrefly/ts/graph";
+import { zustandStore } from "@graphrefly/ts/adapters";
 
-// Zustand has no native computed() — derive via selectors at read time:
-const doubled = (s) => s.count * 2;
+const g = graph({ name: "zustand-counter" });
+const countNode = g.state({ count: 0 }, { name: "count" });
+const store = zustandStore(countNode);
 
-// React/Vue/Solid/Svelte subscribe with the selector:
-//   useSyncExternalStore(store.subscribe, () => doubled(store.getState()))
+store.setState((state) => ({ count: state.count + 1 }));
+store.subscribe((state) => console.log(state.count));
 
-// Backed by a GraphReFly state node — inspectable, snapshotable, diffable`,
+// Zustand-style computed values stay selectors at read time.
+const doubled = (state: { count: number }) => state.count * 2;
+const currentDoubled = doubled(store.getState());`,
 };
 
-/** Per-framework code-snippet bundle. The `graphrefly` and `leaderboard`
- *  entries are framework-specific; the others are shared. */
+/** Per-framework code-snippet bundle. */
 export function getCodeSnippets(framework: FrameworkName): Record<string, string> {
 	return {
 		graphrefly: GRAPHREFLY_BY_FRAMEWORK[framework],
diff --git a/demos/compat-matrix/src/lib/demo-shell.ts b/demos/compat-matrix/src/lib/demo-shell.ts
new file mode 100644
index 00000000..40260a8e
--- /dev/null
+++ b/demos/compat-matrix/src/lib/demo-shell.ts
@@ -0,0 +1,106 @@
+import { type Graph, graph, type Node } from "@graphrefly/ts/graph";
+import { describeToMermaid } from "@graphrefly/ts/render";
+import {
+	analyzeAndMeasure,
+	computeLineBreaks,
+	type LineBreaksResult,
+	type MeasurementAdapter,
+} from "@graphrefly/ts/solutions/reactive-layout";
+
+export interface DemoShellGraph {
+	resolve<T = unknown>(id: string): Node<T>;
+}
+
+export interface DemoShellHandle {
+	graph: DemoShellGraph;
+	setDemoGraph(graph: Graph): void;
+	bumpGraphTick(): void;
+	setViewportWidth(width: number): void;
+	setMainRatio(ratio: number): void;
+	setSideSplit(ratio: number): void;
+	setCodeText(text: string): void;
+	selectNode(nodeId: string | null): void;
+	destroy(): void;
+}
+
+export interface DemoShellOptions {
+	mainRatio: number;
+	viewportWidth: number;
+	adapter?: MeasurementAdapter | null;
+	layoutFont?: string;
+}
+
+export function demoShell(opts: DemoShellOptions): DemoShellHandle {
+	const shell = graph({ name: "compat-matrix/demo-shell" });
+	const demoGraphRef = { current: null as Graph | null };
+	const graphTick = shell.state(0, { name: "shell/graph-tick" });
+	const selectedNode = shell.state<string | null>(null, { name: "shell/selected-node" });
+	const viewportWidth = shell.state(opts.viewportWidth, { name: "shell/viewport-width" });
+	const mainRatio = shell.state(opts.mainRatio, { name: "shell/main-ratio" });
+	const codeText = shell.state("", { name: "shell/code-text" });
+
+	const mermaidNode = shell.derived(
+		[graphTick, selectedNode],
+		(_tick, selected) => {
+			const source = demoGraphRef.current;
+			if (!source) return "flowchart LR";
+			const rendered = describeToMermaid(source.describe(), { direction: "LR" });
+			return selected ? `${rendered}\n%% selected: ${selected}` : rendered;
+		},
+		{ name: "graph/mermaid" },
+	);
+
+	const graphHeightRatio = shell.state(0.5, { name: "pane/graph-height-ratio" });
+	const codeLines = shell.derived(
+		[codeText, viewportWidth, mainRatio],
+		(text, width, ratio): LineBreaksResult | null => {
+			if (!opts.adapter || !text) return null;
+			const cache = new Map<string, Map<string, number>>();
+			const maxWidth = Math.max(120, Math.round((width ?? 0) * (1 - (ratio ?? 0.6)) - 32));
+			const font = opts.layoutFont ?? '13px "Fira Code", ui-monospace, monospace';
+			const segments = analyzeAndMeasure(text, font, opts.adapter, cache);
+			return computeLineBreaks(segments, maxWidth, opts.adapter, font, cache);
+		},
+		{ name: "layout/code-lines" },
+	);
+
+	const nodes = new Map<string, Node<unknown>>([
+		["graph/mermaid", mermaidNode],
+		["pane/graph-height-ratio", graphHeightRatio],
+		["layout/code-lines", codeLines],
+	]);
+
+	return {
+		graph: {
+			resolve<T = unknown>(id: string): Node<T> {
+				const node = nodes.get(id);
+				if (!node) throw new Error(`demoShell: unknown node '${id}'`);
+				return node as Node<T>;
+			},
+		},
+		setDemoGraph(nextGraph) {
+			demoGraphRef.current = nextGraph;
+			graphTick.set((graphTick.cache ?? 0) + 1);
+		},
+		bumpGraphTick() {
+			graphTick.set((graphTick.cache ?? 0) + 1);
+		},
+		setViewportWidth(width) {
+			viewportWidth.set(width);
+		},
+		setMainRatio(ratio) {
+			mainRatio.set(ratio);
+		},
+		setSideSplit(ratio) {
+			graphHeightRatio.set(ratio);
+		},
+		setCodeText(text) {
+			codeText.set(text);
+		},
+		selectNode(nodeId) {
+			selectedNode.set(nodeId);
+			graphTick.set((graphTick.cache ?? 0) + 1);
+		},
+		destroy() {},
+	};
+}
diff --git a/demos/compat-matrix/src/lib/layout-integration.ts b/demos/compat-matrix/src/lib/layout-integration.ts
index 9c5df8d6..d9f3322c 100644
--- a/demos/compat-matrix/src/lib/layout-integration.ts
+++ b/demos/compat-matrix/src/lib/layout-integration.ts
@@ -4,8 +4,8 @@
 //
 // (1) `getMeasurementAdapter()` — a lazily-created browser
 //     `CanvasMeasureAdapter` to pass into `demoShell({ adapter })`. With an
-//     adapter present, demoShell exposes `layout/code-lines` (and
-//     `layout/graph-labels`) derived nodes that recompute reactively when
+//     adapter present, demoShell exposes `layout/code-lines`, a derived node
+//     that recomputes reactively when
 //     either the code text OR the side-pane width changes.
 //
 // (2) `createLeaderboardLayout()` — a `reactiveBlockLayout` bundle for the
@@ -18,18 +18,18 @@
 //     can answer "which grapheme did the user click on?" against the
 //     current `layout/code-lines` and the raw snippet text.
 
+import type { Node } from "@graphrefly/ts/graph";
 import {
 	analyzeAndMeasure,
-	CanvasMeasureAdapter,
 	type CharPosition,
 	type ContentBlock,
 	computeCharPositions,
 	computeLineBreaks,
 	type LineBreaksResult,
 	type MeasurementAdapter,
-	type Node,
 	reactiveBlockLayout,
-} from "@graphrefly/graphrefly/utils/reactive-layout";
+} from "@graphrefly/ts/solutions/reactive-layout";
+import { CanvasMeasureAdapter } from "@graphrefly/ts/solutions/reactive-layout/browser";
 
 /** Font string shared across shell measurements + per-framework renders. */
 export const LAYOUT_FONT = '13px "Fira Code", ui-monospace, monospace';
diff --git a/demos/compat-matrix/src/pages/index.astro b/demos/compat-matrix/src/pages/index.astro
index 31c13136..714b636e 100644
--- a/demos/compat-matrix/src/pages/index.astro
+++ b/demos/compat-matrix/src/pages/index.astro
@@ -46,17 +46,17 @@ const href = (p: string) => `${base.replace(/\/$/, "")}/${p.replace(/^\//, "")}`
         <tbody>
           <tr>
             <td><span class="row-label graphrefly">GraphReFly raw</span></td>
-            <td class="matrix-cell"><span class="check">✓</span>useStore / useSubscribe</td>
-            <td class="matrix-cell"><span class="check">✓</span>useStore → Ref (writable)</td>
-            <td class="matrix-cell"><span class="check">✓</span>useStore → [Accessor, setter]</td>
-            <td class="matrix-cell"><span class="check">✓</span>useStore → SvelteWritable</td>
+            <td class="matrix-cell"><span class="check">✓</span>useNodeInput / useNodeValue</td>
+            <td class="matrix-cell"><span class="check">✓</span>useNodeInput → Ref + setter</td>
+            <td class="matrix-cell"><span class="check">✓</span>createNodeInput → [Accessor, setter]</td>
+            <td class="matrix-cell"><span class="check">✓</span>nodeWritable / nodeReadable</td>
           </tr>
           <tr>
             <td><span class="row-label jotai">Jotai</span></td>
-            <td class="matrix-cell"><span class="check">✓</span>atom(read, write) · useSyncExternalStore</td>
-            <td class="matrix-cell"><span class="check">✓</span>atom.subscribe → Ref bridge</td>
-            <td class="matrix-cell"><span class="check">✓</span>atom.subscribe → createSignal</td>
-            <td class="matrix-cell"><span class="check">✓</span>atom.subscribe → writable bridge</td>
+            <td class="matrix-cell"><span class="check">✓</span>jotaiAtom facade · useSyncExternalStore</td>
+            <td class="matrix-cell"><span class="check">✓</span>jotaiAtom.subscribe → Ref bridge</td>
+            <td class="matrix-cell"><span class="check">✓</span>jotaiAtom.subscribe → createSignal</td>
+            <td class="matrix-cell"><span class="check">✓</span>jotaiAtom.subscribe → writable bridge</td>
           </tr>
           <tr>
             <td><span class="row-label nanostores">Nanostores</span></td>
@@ -67,7 +67,7 @@ const href = (p: string) => `${base.replace(/\/$/, "")}/${p.replace(/^\//, "")}`
           </tr>
           <tr>
             <td><span class="row-label zustand">Zustand</span></td>
-            <td class="matrix-cell"><span class="check">✓</span>StoreApi · useSyncExternalStore</td>
+            <td class="matrix-cell"><span class="check">✓</span>ZustandStoreApi · useSyncExternalStore</td>
             <td class="matrix-cell"><span class="check">✓</span>store.subscribe → Ref bridge</td>
             <td class="matrix-cell"><span class="check">✓</span>store.subscribe → createSignal</td>
             <td class="matrix-cell"><span class="check">✓</span>store → Svelte readable</td>
diff --git a/demos/knowledge-graph/.astro/content-assets.mjs b/demos/knowledge-graph/.astro/content-assets.mjs
deleted file mode 100644
index 2b8b8234..00000000
--- a/demos/knowledge-graph/.astro/content-assets.mjs
+++ /dev/null
@@ -1 +0,0 @@
-export default new Map();
\ No newline at end of file
diff --git a/demos/knowledge-graph/.astro/content-modules.mjs b/demos/knowledge-graph/.astro/content-modules.mjs
deleted file mode 100644
index 2b8b8234..00000000
--- a/demos/knowledge-graph/.astro/content-modules.mjs
+++ /dev/null
@@ -1 +0,0 @@
-export default new Map();
\ No newline at end of file
diff --git a/demos/knowledge-graph/.astro/content.d.ts b/demos/knowledge-graph/.astro/content.d.ts
deleted file mode 100644
index c0082cc8..00000000
--- a/demos/knowledge-graph/.astro/content.d.ts
+++ /dev/null
@@ -1,199 +0,0 @@
-declare module 'astro:content' {
-	export interface RenderResult {
-		Content: import('astro/runtime/server/index.js').AstroComponentFactory;
-		headings: import('astro').MarkdownHeading[];
-		remarkPluginFrontmatter: Record<string, any>;
-	}
-	interface Render {
-		'.md': Promise<RenderResult>;
-	}
-
-	export interface RenderedContent {
-		html: string;
-		metadata?: {
-			imagePaths: Array<string>;
-			[key: string]: unknown;
-		};
-	}
-}
-
-declare module 'astro:content' {
-	type Flatten<T> = T extends { [K: string]: infer U } ? U : never;
-
-	export type CollectionKey = keyof AnyEntryMap;
-	export type CollectionEntry<C extends CollectionKey> = Flatten<AnyEntryMap[C]>;
-
-	export type ContentCollectionKey = keyof ContentEntryMap;
-	export type DataCollectionKey = keyof DataEntryMap;
-
-	type AllValuesOf<T> = T extends any ? T[keyof T] : never;
-	type ValidContentEntrySlug<C extends keyof ContentEntryMap> = AllValuesOf<
-		ContentEntryMap[C]
-	>['slug'];
-
-	export type ReferenceDataEntry<
-		C extends CollectionKey,
-		E extends keyof DataEntryMap[C] = string,
-	> = {
-		collection: C;
-		id: E;
-	};
-	export type ReferenceContentEntry<
-		C extends keyof ContentEntryMap,
-		E extends ValidContentEntrySlug<C> | (string & {}) = string,
-	> = {
-		collection: C;
-		slug: E;
-	};
-	export type ReferenceLiveEntry<C extends keyof LiveContentConfig['collections']> = {
-		collection: C;
-		id: string;
-	};
-
-	/** @deprecated Use `getEntry` instead. */
-	export function getEntryBySlug<
-		C extends keyof ContentEntryMap,
-		E extends ValidContentEntrySlug<C> | (string & {}),
-	>(
-		collection: C,
-		// Note that this has to accept a regular string too, for SSR
-		entrySlug: E,
-	): E extends ValidContentEntrySlug<C>
-		? Promise<CollectionEntry<C>>
-		: Promise<CollectionEntry<C> | undefined>;
-
-	/** @deprecated Use `getEntry` instead. */
-	export function getDataEntryById<C extends keyof DataEntryMap, E extends keyof DataEntryMap[C]>(
-		collection: C,
-		entryId: E,
-	): Promise<CollectionEntry<C>>;
-
-	export function getCollection<C extends keyof AnyEntryMap, E extends CollectionEntry<C>>(
-		collection: C,
-		filter?: (entry: CollectionEntry<C>) => entry is E,
-	): Promise<E[]>;
-	export function getCollection<C extends keyof AnyEntryMap>(
-		collection: C,
-		filter?: (entry: CollectionEntry<C>) => unknown,
-	): Promise<CollectionEntry<C>[]>;
-
-	export function getLiveCollection<C extends keyof LiveContentConfig['collections']>(
-		collection: C,
-		filter?: LiveLoaderCollectionFilterType<C>,
-	): Promise<
-		import('astro').LiveDataCollectionResult<LiveLoaderDataType<C>, LiveLoaderErrorType<C>>
-	>;
-
-	export function getEntry<
-		C extends keyof ContentEntryMap,
-		E extends ValidContentEntrySlug<C> | (string & {}),
-	>(
-		entry: ReferenceContentEntry<C, E>,
-	): E extends ValidContentEntrySlug<C>
-		? Promise<CollectionEntry<C>>
-		: Promise<CollectionEntry<C> | undefined>;
-	export function getEntry<
-		C extends keyof DataEntryMap,
-		E extends keyof DataEntryMap[C] | (string & {}),
-	>(
-		entry: ReferenceDataEntry<C, E>,
-	): E extends keyof DataEntryMap[C]
-		? Promise<DataEntryMap[C][E]>
-		: Promise<CollectionEntry<C> | undefined>;
-	export function getEntry<
-		C extends keyof ContentEntryMap,
-		E extends ValidContentEntrySlug<C> | (string & {}),
-	>(
-		collection: C,
-		slug: E,
-	): E extends ValidContentEntrySlug<C>
-		? Promise<CollectionEntry<C>>
-		: Promise<CollectionEntry<C> | undefined>;
-	export function getEntry<
-		C extends keyof DataEntryMap,
-		E extends keyof DataEntryMap[C] | (string & {}),
-	>(
-		collection: C,
-		id: E,
-	): E extends keyof DataEntryMap[C]
-		? string extends keyof DataEntryMap[C]
-			? Promise<DataEntryMap[C][E]> | undefined
-			: Promise<DataEntryMap[C][E]>
-		: Promise<CollectionEntry<C> | undefined>;
-	export function getLiveEntry<C extends keyof LiveContentConfig['collections']>(
-		collection: C,
-		filter: string | LiveLoaderEntryFilterType<C>,
-	): Promise<import('astro').LiveDataEntryResult<LiveLoaderDataType<C>, LiveLoaderErrorType<C>>>;
-
-	/** Resolve an array of entry references from the same collection */
-	export function getEntries<C extends keyof ContentEntryMap>(
-		entries: ReferenceContentEntry<C, ValidContentEntrySlug<C>>[],
-	): Promise<CollectionEntry<C>[]>;
-	export function getEntries<C extends keyof DataEntryMap>(
-		entries: ReferenceDataEntry<C, keyof DataEntryMap[C]>[],
-	): Promise<CollectionEntry<C>[]>;
-
-	export function render<C extends keyof AnyEntryMap>(
-		entry: AnyEntryMap[C][string],
-	): Promise<RenderResult>;
-
-	export function reference<C extends keyof AnyEntryMap>(
-		collection: C,
-	): import('astro/zod').ZodEffects<
-		import('astro/zod').ZodString,
-		C extends keyof ContentEntryMap
-			? ReferenceContentEntry<C, ValidContentEntrySlug<C>>
-			: ReferenceDataEntry<C, keyof DataEntryMap[C]>
-	>;
-	// Allow generic `string` to avoid excessive type errors in the config
-	// if `dev` is not running to update as you edit.
-	// Invalid collection names will be caught at build time.
-	export function reference<C extends string>(
-		collection: C,
-	): import('astro/zod').ZodEffects<import('astro/zod').ZodString, never>;
-
-	type ReturnTypeOrOriginal<T> = T extends (...args: any[]) => infer R ? R : T;
-	type InferEntrySchema<C extends keyof AnyEntryMap> = import('astro/zod').infer<
-		ReturnTypeOrOriginal<Required<ContentConfig['collections'][C]>['schema']>
-	>;
-
-	type ContentEntryMap = {
-		
-	};
-
-	type DataEntryMap = {
-		
-	};
-
-	type AnyEntryMap = ContentEntryMap & DataEntryMap;
-
-	type ExtractLoaderTypes<T> = T extends import('astro/loaders').LiveLoader<
-		infer TData,
-		infer TEntryFilter,
-		infer TCollectionFilter,
-		infer TError
-	>
-		? { data: TData; entryFilter: TEntryFilter; collectionFilter: TCollectionFilter; error: TError }
-		: { data: never; entryFilter: never; collectionFilter: never; error: never };
-	type ExtractDataType<T> = ExtractLoaderTypes<T>['data'];
-	type ExtractEntryFilterType<T> = ExtractLoaderTypes<T>['entryFilter'];
-	type ExtractCollectionFilterType<T> = ExtractLoaderTypes<T>['collectionFilter'];
-	type ExtractErrorType<T> = ExtractLoaderTypes<T>['error'];
-
-	type LiveLoaderDataType<C extends keyof LiveContentConfig['collections']> =
-		LiveContentConfig['collections'][C]['schema'] extends undefined
-			? ExtractDataType<LiveContentConfig['collections'][C]['loader']>
-			: import('astro/zod').infer<
-					Exclude<LiveContentConfig['collections'][C]['schema'], undefined>
-				>;
-	type LiveLoaderEntryFilterType<C extends keyof LiveContentConfig['collections']> =
-		ExtractEntryFilterType<LiveContentConfig['collections'][C]['loader']>;
-	type LiveLoaderCollectionFilterType<C extends keyof LiveContentConfig['collections']> =
-		ExtractCollectionFilterType<LiveContentConfig['collections'][C]['loader']>;
-	type LiveLoaderErrorType<C extends keyof LiveContentConfig['collections']> = ExtractErrorType<
-		LiveContentConfig['collections'][C]['loader']
-	>;
-
-	export type ContentConfig = typeof import("../src/content.config.mjs");
-	export type LiveContentConfig = never;
-}
diff --git a/demos/knowledge-graph/.astro/data-store.json b/demos/knowledge-graph/.astro/data-store.json
deleted file mode 100644
index 46d1f60a..00000000
--- a/demos/knowledge-graph/.astro/data-store.json
+++ /dev/null
@@ -1 +0,0 @@
-[["Map",1,2],"meta::meta",["Map",3,4,5,6],"astro-version","5.18.1","astro-config-digest","{\"root\":{},\"srcDir\":{},\"publicDir\":{},\"outDir\":{},\"cacheDir\":{},\"site\":\"https://example.invalid\",\"compressHTML\":true,\"base\":\"/demos/knowledge-graph/\",\"trailingSlash\":\"ignore\",\"output\":\"static\",\"scopedStyleStrategy\":\"attribute\",\"build\":{\"format\":\"directory\",\"client\":{},\"server\":{},\"assets\":\"_astro\",\"serverEntry\":\"entry.mjs\",\"redirects\":true,\"inlineStylesheets\":\"auto\",\"concurrency\":1},\"server\":{\"open\":false,\"host\":false,\"port\":4324,\"streaming\":true,\"allowedHosts\":[]},\"redirects\":{},\"image\":{\"endpoint\":{\"route\":\"/_image\"},\"service\":{\"entrypoint\":\"astro/assets/services/sharp\",\"config\":{}},\"domains\":[],\"remotePatterns\":[],\"responsiveStyles\":false},\"devToolbar\":{\"enabled\":true},\"markdown\":{\"syntaxHighlight\":{\"type\":\"shiki\",\"excludeLangs\":[\"math\"]},\"shikiConfig\":{\"langs\":[],\"langAlias\":{},\"theme\":\"github-dark\",\"themes\":{},\"wrap\":false,\"transformers\":[]},\"remarkPlugins\":[],\"rehypePlugins\":[],\"remarkRehype\":{},\"gfm\":true,\"smartypants\":true},\"security\":{\"checkOrigin\":true,\"allowedDomains\":[],\"actionBodySizeLimit\":1048576},\"env\":{\"schema\":{},\"validateSecrets\":false},\"experimental\":{\"clientPrerender\":false,\"contentIntellisense\":false,\"headingIdCompat\":false,\"preserveScriptOrder\":false,\"liveContentCollections\":false,\"csp\":false,\"staticImportMetaEnv\":false,\"chromeDevtoolsWorkspace\":false,\"failOnPrerenderConflict\":false,\"svgo\":false},\"legacy\":{\"collections\":false}}"]
\ No newline at end of file
diff --git a/demos/knowledge-graph/.astro/settings.json b/demos/knowledge-graph/.astro/settings.json
deleted file mode 100644
index 6b3daaf0..00000000
--- a/demos/knowledge-graph/.astro/settings.json
+++ /dev/null
@@ -1,5 +0,0 @@
-{
-	"_variables": {
-		"lastUpdateCheck": 1776730092473
-	}
-}
\ No newline at end of file
diff --git a/demos/knowledge-graph/.astro/types.d.ts b/demos/knowledge-graph/.astro/types.d.ts
deleted file mode 100644
index 03d7cc43..00000000
--- a/demos/knowledge-graph/.astro/types.d.ts
+++ /dev/null
@@ -1,2 +0,0 @@
-/// <reference types="astro/client" />
-/// <reference path="content.d.ts" />
\ No newline at end of file
diff --git a/demos/knowledge-graph/astro.config.mjs b/demos/knowledge-graph/astro.config.mjs
deleted file mode 100644
index 289110c0..00000000
--- a/demos/knowledge-graph/astro.config.mjs
+++ /dev/null
@@ -1,30 +0,0 @@
-import react from "@astrojs/react";
-import { defineConfig } from "astro/config";
-
-export default defineConfig({
-	site: process.env.ASTRO_SITE_URL ?? "https://example.invalid",
-	base: "/demos/knowledge-graph/",
-	server: { port: 4324 },
-	integrations: [react()],
-	vite: {
-		resolve: {
-			conditions: ["browser"],
-			dedupe: ["@graphrefly/pure-ts"],
-		},
-		build: {
-			rollupOptions: {
-				// `@mlc-ai/web-llm` — peer dep of the library's browser
-				// `webllmAdapter` (dynamic import with `.catch()`).
-				// `node:*` builtins — the library's `fallbackAdapter` /
-				// `withReplayCache` / `fileStorage` import them for Node-only
-				// paths; this demo never calls them, but rollup tree-shakes
-				// the library dist and can't resolve them for a browser build.
-				// Marking them external means they remain as runtime imports
-				// that only evaluate if the Node-only code ever runs (it won't
-				// in the browser).
-				external: ["@mlc-ai/web-llm", /^node:/],
-			},
-		},
-		optimizeDeps: { exclude: ["@mlc-ai/web-llm"] },
-	},
-});
diff --git a/demos/knowledge-graph/package.json b/demos/knowledge-graph/package.json
deleted file mode 100644
index edb18be7..00000000
--- a/demos/knowledge-graph/package.json
+++ /dev/null
@@ -1,21 +0,0 @@
-{
-	"name": "@graphrefly/demo-knowledge-graph",
-	"private": true,
-	"type": "module",
-	"scripts": {
-		"dev": "astro dev",
-		"build": "astro build",
-		"preview": "astro preview"
-	},
-	"dependencies": {
-		"@graphrefly/graphrefly": "workspace:*",
-		"@graphrefly/pure-ts": "workspace:*",
-		"@astrojs/react": "^4.0.0",
-		"@types/react": "^19.0.0",
-		"@types/react-dom": "^19.0.0",
-		"astro": "^5.16.0",
-		"mermaid": "^11.4.1",
-		"react": "^19.0.0",
-		"react-dom": "^19.0.0"
-	}
-}
diff --git a/demos/knowledge-graph/src/components/AdapterBanner.tsx b/demos/knowledge-graph/src/components/AdapterBanner.tsx
deleted file mode 100644
index 1e727768..00000000
--- a/demos/knowledge-graph/src/components/AdapterBanner.tsx
+++ /dev/null
@@ -1,12 +0,0 @@
-import type { AdapterInfo } from "../lib/types";
-
-export default function AdapterBanner({ info }: { info: AdapterInfo }) {
-	return (
-		<div className={`adapter-banner ${info.status}`}>
-			<span className="pill">{info.name}</span>
-			<span>
-				<strong>{info.status}</strong> — {info.note}
-			</span>
-		</div>
-	);
-}
diff --git a/demos/knowledge-graph/src/components/App.tsx b/demos/knowledge-graph/src/components/App.tsx
deleted file mode 100644
index d6752be8..00000000
--- a/demos/knowledge-graph/src/components/App.tsx
+++ /dev/null
@@ -1,244 +0,0 @@
-import type { DemoShellHandle, HoverTarget } from "@graphrefly/graphrefly/utils/demo-shell";
-import { useCallback, useEffect, useMemo, useRef, useState } from "react";
-import type { Chapter, ChapterResolved } from "../lib/chapters/types";
-import { focusChapter, getShell } from "../lib/shell";
-import CodePane from "./CodePane";
-import BaselineChapterUI, { getBaselineChapter } from "./chapters/BaselineChapter";
-import GuardChapterUI, { getGuardChapter } from "./chapters/GuardChapter";
-import InspectChapterUI, { getInspectChapter } from "./chapters/InspectChapter";
-import ReactiveChapterUI, { getReactiveChapterSync } from "./chapters/ReactiveChapter";
-import GraphPane from "./GraphPane";
-import InspectStrip from "./InspectStrip";
-
-// Chapters declared with a `resolve()` thunk. The thunk only runs on first
-// tab activation, so the demo doesn't pay the cost of constructing
-// promptNode / policyEnforcer / reactiveExplainPath subgraphs for chapters
-// the user never visits, and a runtime failure in one chapter's setup
-// doesn't crash the whole app at module-load time.
-const CHAPTERS: Chapter[] = [
-	{
-		id: "baseline",
-		label: "1. Baseline",
-		tagline: "knowledgeGraph() up close — looks like a fancy Map.",
-		UI: BaselineChapterUI,
-		resolve: () => {
-			const c = getBaselineChapter();
-			return { graph: c.graph, sourceCode: c.sourceCode, registry: c.registry };
-		},
-	},
-	{
-		id: "reactive",
-		label: "2. Reactive turn",
-		tagline: "Paper → promptNode → KG. The moment Graph beats Map.",
-		UI: ReactiveChapterUI,
-		resolve: () => {
-			const c = getReactiveChapterSync();
-			return { graph: c.graph, sourceCode: c.sourceCode, registry: c.registry };
-		},
-	},
-	{
-		id: "inspect",
-		label: "3. Inspect & trace",
-		tagline: "describe() + reactiveExplainPath() — ask why, get a chain.",
-		UI: InspectChapterUI,
-		resolve: () => {
-			const c = getInspectChapter();
-			return { graph: c.graph, sourceCode: c.sourceCode, registry: c.registry };
-		},
-	},
-	{
-		id: "guard",
-		label: "4. Guardrails",
-		tagline: "policyEnforcer wraps the KG — untrusted-llm writes throw.",
-		UI: GuardChapterUI,
-		resolve: () => {
-			const c = getGuardChapter();
-			return { graph: c.graph, sourceCode: c.sourceCode, registry: c.registry };
-		},
-	},
-];
-
-export default function App() {
-	const shellRef = useRef<DemoShellHandle | null>(null);
-	const sidePaneRef = useRef<HTMLDivElement | null>(null);
-	const [chapterId, setChapterId] = useState<string>(CHAPTERS[1]!.id);
-	const activeChapter = useMemo(
-		() => CHAPTERS.find((c) => c.id === chapterId) ?? CHAPTERS[0]!,
-		[chapterId],
-	);
-	// Resolve chapter graph/source/registry on activation. This is what makes
-	// chapter construction lazy — the first time a tab is clicked, its
-	// `resolve()` runs and the result is cached inside that chapter's module.
-	const resolved: ChapterResolved = useMemo(() => activeChapter.resolve(), [activeChapter]);
-
-	const [mainRatio, setMainRatio] = useState(0.6);
-	const [graphRatio, setGraphRatio] = useState(0.5);
-	const [mermaidText, setMermaidText] = useState("");
-	const [hoverTarget, setHoverTarget] = useState<HoverTarget>(null);
-	const [highlightLine, setHighlightLine] = useState<number | null>(null);
-
-	useEffect(() => {
-		const shell = getShell();
-		shellRef.current = shell;
-
-		const mermaidNode = shell.graph.resolve("graph/mermaid");
-		const codeScrollNode = shell.graph.resolve("highlight/code-scroll");
-		const hoverNode = shell.graph.resolve("hover/target");
-
-		const u1 = mermaidNode.subscribe(() => {
-			setMermaidText((mermaidNode.cache as string) ?? "");
-		});
-		const u2 = codeScrollNode.subscribe(() => {
-			setHighlightLine((codeScrollNode.cache as number | null) ?? null);
-		});
-		const u3 = hoverNode.subscribe(() => {
-			setHoverTarget((hoverNode.cache as HoverTarget) ?? null);
-		});
-
-		const onResize = () => shell.setViewportWidth(window.innerWidth);
-		window.addEventListener("resize", onResize);
-
-		return () => {
-			u1();
-			u2();
-			u3();
-			window.removeEventListener("resize", onResize);
-		};
-	}, []);
-
-	useEffect(() => {
-		const shell = shellRef.current;
-		if (!shell) return;
-		focusChapter(shell, resolved);
-	}, [resolved]);
-
-	const onHover = useCallback((t: HoverTarget) => {
-		shellRef.current?.setHoverTarget(t);
-	}, []);
-	const onSelect = useCallback((path: string | null) => {
-		shellRef.current?.selectNode(path);
-	}, []);
-
-	// Drag listeners: each `useEffect` registers + cleans up the active drag
-	// session. A ref tracks the in-flight handlers so unmount during a drag
-	// removes them from the window — fixes the "callbacks fire on a
-	// dead component after route change / HMR" bug.
-	const activeDragHandlers = useRef<{ move: (e: MouseEvent) => void; up: () => void } | null>(null);
-	useEffect(() => {
-		return () => {
-			if (activeDragHandlers.current) {
-				window.removeEventListener("mousemove", activeDragHandlers.current.move);
-				window.removeEventListener("mouseup", activeDragHandlers.current.up);
-				document.body.style.cursor = "";
-				document.body.style.userSelect = "";
-				activeDragHandlers.current = null;
-			}
-		};
-	}, []);
-
-	const beginDrag = useCallback(
-		(cursor: "col-resize" | "row-resize", onMove: (e: MouseEvent) => void) => {
-			document.body.style.cursor = cursor;
-			document.body.style.userSelect = "none";
-			const move = (ev: MouseEvent) => onMove(ev);
-			const up = () => {
-				document.body.style.cursor = "";
-				document.body.style.userSelect = "";
-				window.removeEventListener("mousemove", move);
-				window.removeEventListener("mouseup", up);
-				activeDragHandlers.current = null;
-			};
-			activeDragHandlers.current = { move, up };
-			window.addEventListener("mousemove", move);
-			window.addEventListener("mouseup", up);
-		},
-		[],
-	);
-
-	const onMainDividerDown = useCallback(
-		(e: React.MouseEvent) => {
-			e.preventDefault();
-			beginDrag("col-resize", (ev) => {
-				const ratio = Math.max(0.25, Math.min(0.8, ev.clientX / window.innerWidth));
-				setMainRatio(ratio);
-				shellRef.current?.setMainRatio(ratio);
-			});
-		},
-		[beginDrag],
-	);
-	const onSplitDividerDown = useCallback(
-		(e: React.MouseEvent) => {
-			e.preventDefault();
-			beginDrag("row-resize", (ev) => {
-				if (!sidePaneRef.current) return;
-				const rect = sidePaneRef.current.getBoundingClientRect();
-				const ratio = Math.max(0.15, Math.min(0.85, (ev.clientY - rect.top) / rect.height));
-				setGraphRatio(ratio);
-				shellRef.current?.setSideSplit(ratio);
-			});
-		},
-		[beginDrag],
-	);
-
-	const onHoverNodeFromGraph = useCallback((id: string | null) => {
-		shellRef.current?.setHoverTarget(id ? { pane: "graph", id } : null);
-	}, []);
-
-	const UI = activeChapter.UI;
-	const mainWidthPct = `${Math.round(mainRatio * 100)}%`;
-	const sideWidthPct = `${Math.round((1 - mainRatio) * 100)}%`;
-
-	return (
-		<div className="app">
-			<div className="tab-bar">
-				{CHAPTERS.map((c) => (
-					<button
-						key={c.id}
-						type="button"
-						className={`tab${c.id === chapterId ? " active" : ""}`}
-						onClick={() => setChapterId(c.id)}
-						title={c.tagline}
-					>
-						{c.label}
-					</button>
-				))}
-				<div className="tab-tagline">{activeChapter.tagline}</div>
-			</div>
-
-			<div className="demo-shell">
-				<div className="pane-main" style={{ width: mainWidthPct, maxWidth: mainWidthPct }}>
-					<UI hoverTarget={hoverTarget} onHover={onHover} onSelect={onSelect} />
-				</div>
-				<div
-					className="pane-divider"
-					onMouseDown={onMainDividerDown}
-					title="Drag to resize main / side split"
-				/>
-				<div className="pane-side" ref={sidePaneRef} style={{ width: sideWidthPct }}>
-					<div className="pane-graph" style={{ height: `${graphRatio * 100}%` }}>
-						<h3>Graph topology — describe(graph) → mermaid</h3>
-						<GraphPane
-							text={mermaidText}
-							hoverId={hoverTarget?.id ?? null}
-							onHoverNode={onHoverNodeFromGraph}
-						/>
-					</div>
-					<div
-						className="pane-split-divider"
-						onMouseDown={onSplitDividerDown}
-						title="Drag to resize graph / code split"
-					/>
-					<div className="pane-code">
-						<h3>
-							Source — the code that built this chapter&apos;s graph
-							<span className="layout-meta"> · {resolved.sourceCode.split("\n").length} lines</span>
-						</h3>
-						<CodePane source={resolved.sourceCode} highlightLine={highlightLine} />
-					</div>
-				</div>
-			</div>
-
-			<InspectStrip shell={shellRef.current ?? getShell()} activeGraph={resolved.graph} />
-		</div>
-	);
-}
diff --git a/demos/knowledge-graph/src/components/CodePane.tsx b/demos/knowledge-graph/src/components/CodePane.tsx
deleted file mode 100644
index 1cb8a63f..00000000
--- a/demos/knowledge-graph/src/components/CodePane.tsx
+++ /dev/null
@@ -1,33 +0,0 @@
-import { useEffect, useRef } from "react";
-
-export default function CodePane({
-	source,
-	highlightLine,
-}: {
-	source: string;
-	highlightLine: number | null;
-}) {
-	const ref = useRef<HTMLPreElement | null>(null);
-	const lines = source.split("\n");
-
-	useEffect(() => {
-		if (highlightLine == null) return;
-		const el = ref.current?.querySelector<HTMLElement>(`[data-line='${highlightLine}']`);
-		el?.scrollIntoView({ behavior: "auto", block: "nearest" });
-	}, [highlightLine]);
-
-	return (
-		<pre className="code-pre" ref={ref}>
-			{lines.map((l, i) => {
-				const n = i + 1;
-				const active = highlightLine === n;
-				return (
-					<div key={n} data-line={n} className={`code-line${active ? " active" : ""}`}>
-						<span className="code-lineno">{n}</span>
-						<span className="code-linetext">{l || "\u00a0"}</span>
-					</div>
-				);
-			})}
-		</pre>
-	);
-}
diff --git a/demos/knowledge-graph/src/components/GraphPane.tsx b/demos/knowledge-graph/src/components/GraphPane.tsx
deleted file mode 100644
index e1525a46..00000000
--- a/demos/knowledge-graph/src/components/GraphPane.tsx
+++ /dev/null
@@ -1,112 +0,0 @@
-import { useEffect, useRef } from "react";
-import {
-	initMermaid,
-	MERMAID_NODE_STROKE_DEFAULT,
-	MERMAID_NODE_STROKE_MATCH,
-	mermaid,
-	nextMermaidId,
-} from "../lib/mermaid-render";
-import { attachPanZoom } from "../lib/pan-zoom";
-
-export default function GraphPane({
-	text,
-	hoverId,
-	onHoverNode,
-}: {
-	text: string;
-	hoverId: string | null;
-	onHoverNode: (id: string | null) => void;
-}) {
-	const containerRef = useRef<HTMLDivElement | null>(null);
-	const onHoverNodeRef = useRef(onHoverNode);
-	useEffect(() => {
-		onHoverNodeRef.current = onHoverNode;
-	}, [onHoverNode]);
-
-	useEffect(() => {
-		initMermaid();
-		const el = containerRef.current;
-		if (!el) return;
-		const detachPanZoom = attachPanZoom(el);
-
-		const nodeFor = (target: EventTarget | null): SVGGElement | null => {
-			const t = target as Element | null;
-			return (t?.closest("g.node[data-hover-id]") as SVGGElement | null) ?? null;
-		};
-
-		const onOver = (e: MouseEvent) => {
-			const node = nodeFor(e.target);
-			if (!node) return;
-			const id = node.getAttribute("data-hover-id");
-			if (id) onHoverNodeRef.current(id);
-		};
-		const onOut = (e: MouseEvent) => {
-			const from = nodeFor(e.target);
-			const to = nodeFor(e.relatedTarget);
-			if (from && from !== to) onHoverNodeRef.current(null);
-		};
-
-		el.addEventListener("mouseover", onOver);
-		el.addEventListener("mouseout", onOut);
-
-		return () => {
-			detachPanZoom();
-			el.removeEventListener("mouseover", onOver);
-			el.removeEventListener("mouseout", onOut);
-		};
-	}, []);
-
-	useEffect(() => {
-		const el = containerRef.current;
-		if (!el) return;
-		if (!text) {
-			el.innerHTML = "";
-			return;
-		}
-		let cancelled = false;
-		mermaid
-			.render(nextMermaidId(), text)
-			.then(({ svg, bindFunctions }) => {
-				if (cancelled || !containerRef.current) return;
-				containerRef.current.innerHTML = svg;
-				bindFunctions?.(containerRef.current);
-				const nodes = containerRef.current.querySelectorAll<SVGGElement>("g.node");
-				nodes.forEach((n) => {
-					const label = n.textContent?.trim() ?? "";
-					if (label) {
-						n.setAttribute("data-hover-id", label);
-						n.style.cursor = "pointer";
-					}
-				});
-			})
-			.catch((err) => {
-				if (cancelled || !containerRef.current) return;
-				console.warn("[GraphPane] mermaid render failed:", err);
-				containerRef.current.textContent = text;
-			});
-		return () => {
-			cancelled = true;
-		};
-	}, [text]);
-
-	useEffect(() => {
-		const el = containerRef.current;
-		if (!el) return;
-		const all = el.querySelectorAll<SVGGElement>("g.node[data-hover-id]");
-		all.forEach((n) => {
-			const id = n.getAttribute("data-hover-id") ?? "";
-			const match =
-				hoverId != null && (id === hoverId || id.includes(hoverId) || hoverId.includes(id));
-			const rect = n.querySelector("rect, circle, polygon, path");
-			if (rect) {
-				(rect as SVGElement).setAttribute(
-					"stroke",
-					match ? MERMAID_NODE_STROKE_MATCH : MERMAID_NODE_STROKE_DEFAULT,
-				);
-				(rect as SVGElement).setAttribute("stroke-width", match ? "2.5" : "1");
-			}
-		});
-	}, [hoverId]);
-
-	return <div ref={containerRef} className="mermaid-graph" />;
-}
diff --git a/demos/knowledge-graph/src/components/InspectStrip.tsx b/demos/knowledge-graph/src/components/InspectStrip.tsx
deleted file mode 100644
index 2d9408a2..00000000
--- a/demos/knowledge-graph/src/components/InspectStrip.tsx
+++ /dev/null
@@ -1,78 +0,0 @@
-import type { DemoShellHandle } from "@graphrefly/graphrefly/utils/demo-shell";
-import type { Graph } from "@graphrefly/pure-ts";
-import { useEffect, useState } from "react";
-
-type NodeDetail = {
-	path: string;
-	kind?: string;
-	value?: unknown;
-	status?: string;
-	depth?: number;
-};
-
-export default function InspectStrip({
-	shell,
-	activeGraph,
-}: {
-	shell: DemoShellHandle;
-	activeGraph: Graph | null;
-}) {
-	const [detail, setDetail] = useState<NodeDetail | null>(null);
-	const [stats, setStats] = useState({ entities: 0, edges: 0 });
-
-	useEffect(() => {
-		const nd = shell.graph.resolve("inspect/node-detail");
-		const u = nd.subscribe(() => {
-			setDetail((nd.cache as NodeDetail | null) ?? null);
-		});
-		setDetail((nd.cache as NodeDetail | null) ?? null);
-		return u;
-	}, [shell]);
-
-	useEffect(() => {
-		if (!activeGraph) return;
-		const update = () => {
-			try {
-				const ents = activeGraph.resolve("entities").cache as
-					| ReadonlyMap<string, unknown>
-					| undefined;
-				const eds = activeGraph.resolve("edges").cache as readonly unknown[] | undefined;
-				setStats({ entities: ents?.size ?? 0, edges: eds?.length ?? 0 });
-			} catch {
-				setStats({ entities: 0, edges: 0 });
-			}
-		};
-		update();
-		try {
-			const u1 = activeGraph.resolve("entities").subscribe(update);
-			const u2 = activeGraph.resolve("edges").subscribe(update);
-			return () => {
-				u1();
-				u2();
-			};
-		} catch {
-			return;
-		}
-	}, [activeGraph]);
-
-	return (
-		<div className="inspect-strip">
-			<div className="inspect-meta">
-				<span>
-					entities: <strong>{stats.entities}</strong>
-				</span>
-				<span>
-					edges: <strong>{stats.edges}</strong>
-				</span>
-			</div>
-			<div className="inspect-detail">
-				{detail ? (
-					<>
-						<code>{detail.path}</code>
-						<span className="pill">{detail.kind ?? "node"}</span>
-					</>
-				) : null}
-			</div>
-		</div>
-	);
-}
diff --git a/demos/knowledge-graph/src/components/KGPane.tsx b/demos/knowledge-graph/src/components/KGPane.tsx
deleted file mode 100644
index c528e1a7..00000000
--- a/demos/knowledge-graph/src/components/KGPane.tsx
+++ /dev/null
@@ -1,368 +0,0 @@
-import { useEffect, useRef, useState } from "react";
-import type { Entity, Relation } from "../lib/types";
-
-type Edge = { from: string; to: string; relation: Relation };
-
-type SimNode = {
-	id: string;
-	label: string;
-	kind: Entity["kind"];
-	x: number;
-	y: number;
-	vx: number;
-	vy: number;
-	fx: number | null;
-	fy: number | null;
-};
-
-const W = 540;
-const H = 380;
-const CENTER_X = W / 2;
-const CENTER_Y = H / 2;
-const REPULSION = 1800;
-const SPRING = 0.04;
-const SPRING_LENGTH = 120;
-const GRAVITY = 0.012;
-const DAMPING = 0.82;
-const MAX_SPEED = 6;
-const NODE_RADIUS = 22;
-
-/**
- * Tiny Verlet-ish force-directed layout. Built from scratch so the demo has
- * zero d3 dependency. The simulation runs continuously (rAF) and consumes
- * `entities` / `edges` props reactively — adding a node nudges the layout,
- * doesn't reset it.
- */
-export default function KGPane({
-	entities,
-	edges,
-	hoverId,
-	onHover,
-}: {
-	entities: ReadonlyArray<Entity>;
-	edges: ReadonlyArray<Edge>;
-	hoverId: string | null;
-	onHover: (id: string | null) => void;
-}) {
-	const simRef = useRef<Map<string, SimNode>>(new Map());
-	const svgRef = useRef<SVGSVGElement | null>(null);
-	const dragRef = useRef<{ id: string; pointerId: number } | null>(null);
-	// Latest edges stashed in a ref so the rAF tick reads the current value
-	// without triggering loop re-creation on every KG update.
-	const edgesRef = useRef(edges);
-	edgesRef.current = edges;
-	const [, force] = useState(0);
-
-	// Sync entities into the simulation as a side effect (not a memo). New
-	// nodes get random-ish initial positions near the center; existing
-	// nodes keep their (x, y, v). Run on every entities change — React's
-	// Strict Mode double-invoke is idempotent here because the work is
-	// an upsert against a Map keyed on entity id.
-	useEffect(() => {
-		const map = simRef.current;
-		const seenIds = new Set(entities.map((e) => e.id));
-		for (const e of entities) {
-			const existing = map.get(e.id);
-			if (!existing) {
-				const angle = (map.size * 137.5 * Math.PI) / 180; // golden-angle sprinkle
-				const r = 60 + Math.random() * 40;
-				map.set(e.id, {
-					id: e.id,
-					label: e.label,
-					kind: e.kind,
-					x: CENTER_X + Math.cos(angle) * r,
-					y: CENTER_Y + Math.sin(angle) * r,
-					vx: 0,
-					vy: 0,
-					fx: null,
-					fy: null,
-				});
-			} else {
-				existing.label = e.label;
-				existing.kind = e.kind;
-			}
-		}
-		for (const id of [...map.keys()]) {
-			if (!seenIds.has(id)) map.delete(id);
-		}
-	}, [entities]);
-
-	// rAF loop — integrate forces, then trigger a re-render. Depends on
-	// nothing so the loop runs once per mount; it reads the latest edges
-	// through `edgesRef.current` on each tick.
-	useEffect(() => {
-		let raf = 0;
-		const tick = () => {
-			step(simRef.current, edgesRef.current);
-			force((n) => n + 1);
-			raf = requestAnimationFrame(tick);
-		};
-		raf = requestAnimationFrame(tick);
-		return () => cancelAnimationFrame(raf);
-	}, []);
-
-	// Pointer drag on nodes. Capture on `e.currentTarget` (the <g>) so events
-	// continue routing to it even when the pointer leaves the inner <circle>
-	// or <text>. `release` mirrors the same element.
-	function onPointerDown(e: React.PointerEvent<SVGGElement>, id: string) {
-		const svg = svgRef.current;
-		if (!svg) return;
-		dragRef.current = { id, pointerId: e.pointerId };
-		try {
-			e.currentTarget.setPointerCapture(e.pointerId);
-		} catch {
-			// some browsers throw if capture can't be acquired; drag will still
-			// work via the svg-level pointermove below.
-		}
-		const node = simRef.current.get(id);
-		if (node) {
-			const pt = clientToSvg(svg, e.clientX, e.clientY);
-			node.fx = pt.x;
-			node.fy = pt.y;
-		}
-	}
-	function onPointerMove(e: React.PointerEvent<SVGSVGElement>) {
-		const drag = dragRef.current;
-		if (!drag) return;
-		const svg = svgRef.current;
-		if (!svg) return;
-		const node = simRef.current.get(drag.id);
-		if (!node) return;
-		const pt = clientToSvg(svg, e.clientX, e.clientY);
-		node.fx = pt.x;
-		node.fy = pt.y;
-	}
-	function onPointerUp(e: React.PointerEvent<SVGGElement>, id: string) {
-		const drag = dragRef.current;
-		if (!drag || drag.id !== id) return;
-		const node = simRef.current.get(id);
-		if (node) {
-			node.fx = null;
-			node.fy = null;
-		}
-		dragRef.current = null;
-		try {
-			e.currentTarget.releasePointerCapture(e.pointerId);
-		} catch {
-			// already released (e.g., pointercancel fired) — fine
-		}
-	}
-	// Safety-net cleanup if a drag ends outside any node element (mouse
-	// leaves the window, tab switch, etc.). Releases the sticky pin.
-	useEffect(() => {
-		const onGlobalUp = () => {
-			const drag = dragRef.current;
-			if (!drag) return;
-			const node = simRef.current.get(drag.id);
-			if (node) {
-				node.fx = null;
-				node.fy = null;
-			}
-			dragRef.current = null;
-		};
-		window.addEventListener("pointerup", onGlobalUp);
-		window.addEventListener("pointercancel", onGlobalUp);
-		return () => {
-			window.removeEventListener("pointerup", onGlobalUp);
-			window.removeEventListener("pointercancel", onGlobalUp);
-		};
-	}, []);
-
-	const sim = simRef.current;
-	const isEmpty = entities.length === 0;
-
-	return (
-		<div className="kg-canvas" data-kg-pane>
-			<svg
-				ref={svgRef}
-				viewBox={`0 0 ${W} ${H}`}
-				preserveAspectRatio="xMidYMid meet"
-				onPointerMove={onPointerMove}
-				role="img"
-				aria-label="Knowledge graph: nodes and directional relations rendered with a force-directed layout"
-			>
-				<title>Knowledge graph (force-directed)</title>
-				<defs>
-					<marker
-						id="kg-arrow"
-						viewBox="0 0 10 10"
-						refX="9"
-						refY="5"
-						markerWidth="7"
-						markerHeight="7"
-						orient="auto-start-reverse"
-					>
-						<path d="M 0 0 L 10 5 L 0 10 z" fill="#4de8c2" />
-					</marker>
-					<marker
-						id="kg-arrow-dim"
-						viewBox="0 0 10 10"
-						refX="9"
-						refY="5"
-						markerWidth="6"
-						markerHeight="6"
-						orient="auto-start-reverse"
-					>
-						<path d="M 0 0 L 10 5 L 0 10 z" fill="#1e2444" />
-					</marker>
-				</defs>
-				<g>
-					{edges.map((edge) => {
-						const a = sim.get(edge.from);
-						const b = sim.get(edge.to);
-						if (!a || !b) return null;
-						const isHover = hoverId === edge.from || hoverId === edge.to;
-						// Pull both endpoints back to each node's circle edge so
-						// the line + arrowhead don't sit inside the node.
-						const dx = b.x - a.x;
-						const dy = b.y - a.y;
-						const dist = Math.hypot(dx, dy) || 1;
-						const ux = dx / dist;
-						const uy = dy / dist;
-						const x1 = a.x + ux * NODE_RADIUS;
-						const y1 = a.y + uy * NODE_RADIUS;
-						const x2 = b.x - ux * (NODE_RADIUS + 2);
-						const y2 = b.y - uy * (NODE_RADIUS + 2);
-						const mx = (x1 + x2) / 2;
-						const my = (y1 + y2) / 2;
-						return (
-							<g
-								key={`${edge.from}-${edge.to}-${edge.relation}`}
-								className={`kg-edge${isHover ? " hover" : ""}`}
-							>
-								<line
-									x1={x1}
-									y1={y1}
-									x2={x2}
-									y2={y2}
-									markerEnd={isHover ? "url(#kg-arrow)" : "url(#kg-arrow-dim)"}
-								/>
-								<text x={mx} y={my} textAnchor="middle" dy="-2">
-									{edge.relation}
-								</text>
-							</g>
-						);
-					})}
-				</g>
-				<g>
-					{[...sim.values()].map((n) => {
-						const isHover = hoverId === n.id;
-						const isDragging = dragRef.current?.id === n.id;
-						return (
-							<g
-								key={n.id}
-								className={`kg-node kind-${n.kind}${isHover ? " hover" : ""}${isDragging ? " dragging" : ""}`}
-								onPointerDown={(e) => onPointerDown(e, n.id)}
-								onPointerUp={(e) => onPointerUp(e, n.id)}
-								onPointerEnter={() => onHover(n.id)}
-								onPointerLeave={() => onHover(null)}
-							>
-								<circle cx={n.x} cy={n.y} r={NODE_RADIUS} />
-								<text x={n.x} y={n.y + 3.5} textAnchor="middle">
-									{n.label.length > 14 ? `${n.label.slice(0, 13)}…` : n.label}
-								</text>
-							</g>
-						);
-					})}
-				</g>
-			</svg>
-			{isEmpty && <div className="kg-empty">Empty graph — extract a paragraph to populate it.</div>}
-		</div>
-	);
-}
-
-function clientToSvg(svg: SVGSVGElement, cx: number, cy: number): { x: number; y: number } {
-	const ctm = svg.getScreenCTM();
-	if (!ctm) {
-		// No CTM → svg not rendered. Fall back to an offset-relative approximation
-		// so drags during chapter transitions don't jump to absurd coordinates.
-		const rect = svg.getBoundingClientRect();
-		return { x: cx - rect.left, y: cy - rect.top };
-	}
-	const pt = svg.createSVGPoint();
-	pt.x = cx;
-	pt.y = cy;
-	const t = pt.matrixTransform(ctm.inverse());
-	return { x: t.x, y: t.y };
-}
-
-function step(sim: Map<string, SimNode>, edges: ReadonlyArray<Edge>) {
-	const nodes = [...sim.values()];
-	if (nodes.length === 0) return;
-
-	// Coulomb-ish repulsion: O(n²), fine for ≤30 nodes.
-	for (let i = 0; i < nodes.length; i += 1) {
-		const a = nodes[i]!;
-		if (a.fx != null) continue;
-		for (let j = i + 1; j < nodes.length; j += 1) {
-			const b = nodes[j]!;
-			let dx = a.x - b.x;
-			let dy = a.y - b.y;
-			let d2 = dx * dx + dy * dy;
-			if (d2 < 1) {
-				dx = Math.random() - 0.5;
-				dy = Math.random() - 0.5;
-				d2 = 1;
-			}
-			const force = REPULSION / d2;
-			const inv = 1 / Math.sqrt(d2);
-			const fx = dx * inv * force;
-			const fy = dy * inv * force;
-			a.vx += fx;
-			a.vy += fy;
-			if (b.fx == null) {
-				b.vx -= fx;
-				b.vy -= fy;
-			}
-		}
-	}
-
-	// Spring forces along edges.
-	for (const edge of edges) {
-		const a = sim.get(edge.from);
-		const b = sim.get(edge.to);
-		if (!a || !b) continue;
-		const dx = b.x - a.x;
-		const dy = b.y - a.y;
-		const d = Math.sqrt(dx * dx + dy * dy) || 1;
-		const force = SPRING * (d - SPRING_LENGTH);
-		const fx = (dx / d) * force;
-		const fy = (dy / d) * force;
-		if (a.fx == null) {
-			a.vx += fx;
-			a.vy += fy;
-		}
-		if (b.fx == null) {
-			b.vx -= fx;
-			b.vy -= fy;
-		}
-	}
-
-	// Gravity + integrate.
-	for (const n of nodes) {
-		if (n.fx != null) {
-			n.x = n.fx;
-			n.y = n.fy ?? n.y;
-			n.vx = 0;
-			n.vy = 0;
-			continue;
-		}
-		n.vx += (CENTER_X - n.x) * GRAVITY;
-		n.vy += (CENTER_Y - n.y) * GRAVITY;
-		n.vx *= DAMPING;
-		n.vy *= DAMPING;
-		const speed = Math.hypot(n.vx, n.vy);
-		if (speed > MAX_SPEED) {
-			n.vx = (n.vx / speed) * MAX_SPEED;
-			n.vy = (n.vy / speed) * MAX_SPEED;
-		}
-		n.x += n.vx;
-		n.y += n.vy;
-		// Soft walls.
-		const m = NODE_RADIUS + 4;
-		if (n.x < m) n.x = m;
-		if (n.y < m) n.y = m;
-		if (n.x > W - m) n.x = W - m;
-		if (n.y > H - m) n.y = H - m;
-	}
-}
diff --git a/demos/knowledge-graph/src/components/PaperPane.tsx b/demos/knowledge-graph/src/components/PaperPane.tsx
deleted file mode 100644
index 6a464481..00000000
--- a/demos/knowledge-graph/src/components/PaperPane.tsx
+++ /dev/null
@@ -1,52 +0,0 @@
-import { useMemo } from "react";
-import { splitContentParagraphs } from "../lib/paragraphs";
-
-export default function PaperPane({
-	title,
-	author,
-	url,
-	body,
-	currentParagraph,
-}: {
-	title: string;
-	author?: string;
-	url?: string;
-	body: string;
-	currentParagraph: string;
-}) {
-	const paragraphs = useMemo(() => splitContentParagraphs(body), [body]);
-	return (
-		<div className="paper-pane" data-paper-text>
-			<div>
-				<h4>Paper</h4>
-				<div className="paper-meta" data-paper-meta>
-					<strong>{title}</strong>
-					{author ? ` — ${author}` : null}
-					{url ? (
-						<>
-							{" · "}
-							<a href={url} target="_blank" rel="noreferrer noopener">
-								source
-							</a>
-						</>
-					) : null}
-				</div>
-			</div>
-			<div className="paper-text">
-				{paragraphs.map((p) => (
-					// Key from a content prefix — paragraphs are unique within a
-					// paper at this length. (If a paper truly repeats two
-					// 64-char openings verbatim, React's reconciliation degrades
-					// to a no-op for the dupe; visually identical so harmless.)
-					<div
-						key={p.slice(0, 64)}
-						className={`paragraph${p === currentParagraph ? " current" : ""}`}
-						data-current-paragraph={p === currentParagraph ? "true" : undefined}
-					>
-						{p}
-					</div>
-				))}
-			</div>
-		</div>
-	);
-}
diff --git a/demos/knowledge-graph/src/components/chapters/BaselineChapter.tsx b/demos/knowledge-graph/src/components/chapters/BaselineChapter.tsx
deleted file mode 100644
index 453eb7e1..00000000
--- a/demos/knowledge-graph/src/components/chapters/BaselineChapter.tsx
+++ /dev/null
@@ -1,53 +0,0 @@
-import { useEffect, useMemo, useState } from "react";
-import { readKGSnapshot } from "../../lib/chapters/_shared";
-import { buildBaselineChapter } from "../../lib/chapters/baseline";
-import type { ChapterUIProps } from "../../lib/chapters/types";
-import KGPane from "../KGPane";
-
-let cached: ReturnType<typeof buildBaselineChapter> | null = null;
-export function getBaselineChapter() {
-	if (!cached) cached = buildBaselineChapter();
-	return cached;
-}
-
-export default function BaselineChapterUI({ hoverTarget, onHover }: ChapterUIProps) {
-	const c = useMemo(() => getBaselineChapter(), []);
-	const [snap, setSnap] = useState(() => readKGSnapshot(c.kg));
-
-	useEffect(() => {
-		const a = c.kg.resolve("entities").subscribe(() => setSnap(readKGSnapshot(c.kg)));
-		const b = c.kg.resolve("edges").subscribe(() => setSnap(readKGSnapshot(c.kg)));
-		return () => {
-			a();
-			b();
-		};
-	}, [c]);
-
-	return (
-		<div className="chapter">
-			<p className="chapter-lede">
-				A <code>knowledgeGraph()</code> is a <code>Graph</code> with three named nodes —{" "}
-				<code>entities</code>, <code>edges</code>, <code>adjacency</code> — plus four imperative
-				methods. Hand-seeded here. <strong>This is just a fancy Map so far</strong> — the next
-				chapter is the contrast.
-			</p>
-			<div className="baseline-note">
-				The user-facing data type is whatever you set as <code>TEntity</code> (here:{" "}
-				<code>Entity</code>) and <code>TRelation</code> (here: <code>Relation</code>). The names
-				<code> entities</code>/<code>edges</code>/<code>adjacency</code> are internal node names —
-				the schema of the container, not vocabulary your users see.
-			</div>
-			<div className="controls">
-				<button type="button" className="secondary" onClick={() => c.reseed()}>
-					Re-seed
-				</button>
-			</div>
-			<KGPane
-				entities={snap.entities}
-				edges={snap.edges}
-				hoverId={hoverTarget?.id ?? null}
-				onHover={(id) => onHover(id ? { pane: "visual", id } : null)}
-			/>
-		</div>
-	);
-}
diff --git a/demos/knowledge-graph/src/components/chapters/GuardChapter.tsx b/demos/knowledge-graph/src/components/chapters/GuardChapter.tsx
deleted file mode 100644
index 4ff5884e..00000000
--- a/demos/knowledge-graph/src/components/chapters/GuardChapter.tsx
+++ /dev/null
@@ -1,116 +0,0 @@
-import { useEffect, useMemo, useState } from "react";
-import { SAMPLE_PAPER } from "../../data/sample-paper";
-import { readKGSnapshot } from "../../lib/chapters/_shared";
-import { buildGuardChapter, type GuardChapter } from "../../lib/chapters/guard";
-import type { ChapterUIProps } from "../../lib/chapters/types";
-import { getSharedAdapter } from "../../lib/shell";
-import { useNodeValue } from "../../lib/use-node-value";
-import KGPane from "../KGPane";
-import PaperPane from "../PaperPane";
-
-let cached: GuardChapter | null = null;
-export function getGuardChapter(): GuardChapter {
-	if (!cached) cached = buildGuardChapter(getSharedAdapter().adapter, SAMPLE_PAPER.body);
-	return cached;
-}
-
-export default function GuardChapterUI({ hoverTarget, onHover }: ChapterUIProps) {
-	const chapter = useMemo(() => getGuardChapter(), []);
-	const paperText = useNodeValue(chapter.paperText, SAMPLE_PAPER.body);
-	const currentParagraph = useNodeValue(chapter.currentParagraph, "");
-	const paragraphs = useNodeValue(chapter.paragraphs, [] as readonly string[]);
-	const paragraphIdx = useNodeValue(chapter.paragraphIdx, 0);
-	const violationCount = useNodeValue(chapter.enforced.violationCount, 0);
-
-	const [snap, setSnap] = useState(() => readKGSnapshot(chapter.kg));
-	const [lastResult, setLastResult] = useState<{ ok: boolean; error?: string } | null>(null);
-
-	useEffect(() => {
-		const a = chapter.kg.resolve("entities").subscribe(() => setSnap(readKGSnapshot(chapter.kg)));
-		const b = chapter.kg.resolve("edges").subscribe(() => setSnap(readKGSnapshot(chapter.kg)));
-		return () => {
-			a();
-			b();
-		};
-	}, [chapter]);
-
-	return (
-		<div className="chapter">
-			<p className="chapter-lede">
-				<strong>Composition with guardrails.</strong> Same reactive pipeline. Now the KG is wrapped
-				in a <code>policyEnforcer</code> with <code>mode: "enforce"</code>. The legitimate
-				extraction effect (<code>system</code> actor) writes freely. Click below to attempt a write
-				as <code>untrusted-llm</code>: the guard throws <code>GuardDenied</code> and a violation is
-				recorded.
-			</p>
-			<div className="controls">
-				<button
-					type="button"
-					className="secondary"
-					onClick={() => {
-						setLastResult(null);
-						chapter.advance();
-					}}
-					disabled={paragraphs.length === 0}
-				>
-					Extract next paragraph ({paragraphIdx + 1} / {paragraphs.length})
-				</button>
-				<button
-					type="button"
-					className="danger"
-					onClick={() => setLastResult(chapter.tryMaliciousWrite())}
-				>
-					Try malicious write
-				</button>
-				<button
-					type="button"
-					className="secondary"
-					onClick={() => {
-						setLastResult(null);
-						chapter.reset();
-					}}
-				>
-					Reset KG
-				</button>
-			</div>
-			<div
-				className={`guard-banner${lastResult && !lastResult.ok ? " denied" : ""}`}
-				data-guard-banner
-			>
-				<div>
-					<code>policyEnforcer</code> — <strong>enforce</strong> mode · violations recorded:{" "}
-					<strong>{violationCount}</strong>
-				</div>
-				{lastResult ? (
-					lastResult.ok ? (
-						<div>Last attempt: silently allowed — schema validation in the adapter passed too.</div>
-					) : (
-						<div className="denied-reason">
-							Denied: <code>{lastResult.error}</code>
-						</div>
-					)
-				) : (
-					<div className="paper-meta">No write attempts yet.</div>
-				)}
-			</div>
-			<div className="extraction-grid">
-				<PaperPane
-					title={SAMPLE_PAPER.title}
-					author={SAMPLE_PAPER.author}
-					url={SAMPLE_PAPER.url}
-					body={paperText}
-					currentParagraph={currentParagraph}
-				/>
-				<div className="kg-pane" data-kg-pane>
-					<h4>Knowledge graph (guarded)</h4>
-					<KGPane
-						entities={snap.entities}
-						edges={snap.edges}
-						hoverId={hoverTarget?.id ?? null}
-						onHover={(id) => onHover(id ? { pane: "visual", id } : null)}
-					/>
-				</div>
-			</div>
-		</div>
-	);
-}
diff --git a/demos/knowledge-graph/src/components/chapters/InspectChapter.tsx b/demos/knowledge-graph/src/components/chapters/InspectChapter.tsx
deleted file mode 100644
index 03556aaf..00000000
--- a/demos/knowledge-graph/src/components/chapters/InspectChapter.tsx
+++ /dev/null
@@ -1,92 +0,0 @@
-import type { CausalChain } from "@graphrefly/pure-ts";
-import { useEffect, useMemo, useState } from "react";
-import { SAMPLE_PAPER } from "../../data/sample-paper";
-import { readKGSnapshot } from "../../lib/chapters/_shared";
-import { buildInspectChapter, type InspectChapter } from "../../lib/chapters/inspect";
-import type { ChapterUIProps } from "../../lib/chapters/types";
-import { getSharedAdapter } from "../../lib/shell";
-import { useNodeValue } from "../../lib/use-node-value";
-import KGPane from "../KGPane";
-import PaperPane from "../PaperPane";
-
-let cached: InspectChapter | null = null;
-export function getInspectChapter(): InspectChapter {
-	if (!cached) cached = buildInspectChapter(getSharedAdapter().adapter, SAMPLE_PAPER.body);
-	return cached;
-}
-
-export default function InspectChapterUI({ hoverTarget, onHover }: ChapterUIProps) {
-	const chapter = useMemo(() => getInspectChapter(), []);
-	const paperText = useNodeValue(chapter.paperText, SAMPLE_PAPER.body);
-	const currentParagraph = useNodeValue(chapter.currentParagraph, "");
-	const paragraphs = useNodeValue(chapter.paragraphs, [] as readonly string[]);
-	const paragraphIdx = useNodeValue(chapter.paragraphIdx, 0);
-	const explainChain = useNodeValue<CausalChain | null>(chapter.explain, null);
-	const [snap, setSnap] = useState(() => readKGSnapshot(chapter.kg));
-
-	useEffect(() => {
-		const a = chapter.kg.resolve("entities").subscribe(() => setSnap(readKGSnapshot(chapter.kg)));
-		const b = chapter.kg.resolve("edges").subscribe(() => setSnap(readKGSnapshot(chapter.kg)));
-		return () => {
-			a();
-			b();
-		};
-	}, [chapter]);
-
-	const chainText = useMemo(() => formatChain(explainChain), [explainChain]);
-
-	return (
-		<div className="chapter">
-			<p className="chapter-lede">
-				<strong>Inspect & trace.</strong> The right pane already shows{" "}
-				<code>describe(kg, &#123; format: "mermaid" &#125;)</code>. Below is{" "}
-				<code>reactiveExplainPath(kg, "paper-text", "current-paragraph")</code> — a{" "}
-				<code>Node&lt;CausalChain&gt;</code> that re-derives whenever any node along the path fires.
-				The trace covers named, reactively-wired nodes; promptNode's internal nodes and the
-				imperative <code>apply-extraction</code> effect mark the boundary of static causal trace.
-			</p>
-			<div className="controls">
-				<button
-					type="button"
-					className="secondary"
-					onClick={() => chapter.advance()}
-					disabled={paragraphs.length === 0}
-				>
-					Extract next paragraph ({paragraphIdx + 1} / {paragraphs.length})
-				</button>
-				<button type="button" className="danger" onClick={() => chapter.reset()}>
-					Reset KG
-				</button>
-			</div>
-			<div className="explain-chain" data-explain-chain>
-				{chainText}
-			</div>
-			<div className="extraction-grid">
-				<PaperPane
-					title={SAMPLE_PAPER.title}
-					author={SAMPLE_PAPER.author}
-					url={SAMPLE_PAPER.url}
-					body={paperText}
-					currentParagraph={currentParagraph}
-				/>
-				<div className="kg-pane" data-kg-pane>
-					<h4>Knowledge graph</h4>
-					<KGPane
-						entities={snap.entities}
-						edges={snap.edges}
-						hoverId={hoverTarget?.id ?? null}
-						onHover={(id) => onHover(id ? { pane: "visual", id } : null)}
-					/>
-				</div>
-			</div>
-		</div>
-	);
-}
-
-function formatChain(chain: CausalChain | null): string {
-	if (!chain) return "(awaiting chain…)";
-	if (chain.found === false) return `no path: ${chain.reason ?? "unknown"}`;
-	if (chain.text) return chain.text;
-	if (!chain.steps || chain.steps.length === 0) return "(empty chain)";
-	return chain.steps.map((s) => s.path).join("\n  ↓ ");
-}
diff --git a/demos/knowledge-graph/src/components/chapters/ReactiveChapter.tsx b/demos/knowledge-graph/src/components/chapters/ReactiveChapter.tsx
deleted file mode 100644
index ed56bfa0..00000000
--- a/demos/knowledge-graph/src/components/chapters/ReactiveChapter.tsx
+++ /dev/null
@@ -1,148 +0,0 @@
-import { useEffect, useMemo, useState } from "react";
-import { SAMPLE_PAPER } from "../../data/sample-paper";
-import { readKGSnapshot } from "../../lib/chapters/_shared";
-import { buildReactiveChapter, type ReactiveChapter } from "../../lib/chapters/reactive";
-import type { ChapterUIProps } from "../../lib/chapters/types";
-import { getSharedAdapter } from "../../lib/shell";
-import { fetchPaper } from "../../lib/url-fetcher";
-import { useNodeValue } from "../../lib/use-node-value";
-import AdapterBanner from "../AdapterBanner";
-import KGPane from "../KGPane";
-import PaperPane from "../PaperPane";
-
-let cachedChapter: ReactiveChapter | null = null;
-
-/**
- * Public getter so App can register the chapter with demo-shell synchronously.
- * Uses the shared `lazyAdapter` from `lib/shell.ts` — chapters 2/3/4 all
- * extract through the same adapter so Chrome Nano (when available) is used
- * everywhere, and the adapter banner stays consistent across tab switches.
- */
-export function getReactiveChapterSync(): ReactiveChapter {
-	if (cachedChapter) return cachedChapter;
-	cachedChapter = buildReactiveChapter(getSharedAdapter().adapter, SAMPLE_PAPER.body);
-	return cachedChapter;
-}
-
-export default function ReactiveChapterUI({ hoverTarget, onHover }: ChapterUIProps) {
-	const chapter = useMemo(() => getReactiveChapterSync(), []);
-	const adapter = useMemo(() => getSharedAdapter(), []);
-	const info = useNodeValue(adapter.infoNode, adapter.info());
-	const [meta, setMeta] = useState<{ title: string; author?: string; url?: string }>({
-		title: SAMPLE_PAPER.title,
-		author: SAMPLE_PAPER.author,
-		url: SAMPLE_PAPER.url,
-	});
-	const [urlInput, setUrlInput] = useState<string>("");
-	const [fetchStatus, setFetchStatus] = useState<string | null>(null);
-
-	const paperText = useNodeValue(chapter.paperText, SAMPLE_PAPER.body);
-	const currentParagraph = useNodeValue(chapter.currentParagraph, "");
-	const paragraphs = useNodeValue(chapter.paragraphs, [] as readonly string[]);
-	const paragraphIdx = useNodeValue(chapter.paragraphIdx, 0);
-
-	const [snap, setSnap] = useState(() => readKGSnapshot(chapter.kg));
-	useEffect(() => {
-		const a = chapter.kg.resolve("entities").subscribe(() => setSnap(readKGSnapshot(chapter.kg)));
-		const b = chapter.kg.resolve("edges").subscribe(() => setSnap(readKGSnapshot(chapter.kg)));
-		return () => {
-			a();
-			b();
-		};
-	}, [chapter]);
-
-	async function loadUrl() {
-		const url = urlInput.trim();
-		if (!url) return;
-		setFetchStatus("Fetching…");
-		try {
-			const fetched = await fetchPaper(url);
-			chapter.reset();
-			chapter.setPaperText(fetched.body);
-			setMeta({ title: fetched.title, url: fetched.url });
-			setFetchStatus(null);
-		} catch (err) {
-			setFetchStatus(
-				`Fetch failed (${err instanceof Error ? err.message : String(err)}). Try a different URL or paste content directly.`,
-			);
-		}
-	}
-
-	function loadDefault() {
-		chapter.reset();
-		chapter.setPaperText(SAMPLE_PAPER.body);
-		setMeta({ title: SAMPLE_PAPER.title, author: SAMPLE_PAPER.author, url: SAMPLE_PAPER.url });
-		setFetchStatus(null);
-	}
-
-	return (
-		<div className="chapter">
-			<p className="chapter-lede">
-				<strong>The reactive turn.</strong> Each paragraph in the paper drives a{" "}
-				<code>promptNode</code>; the structured output is funneled into a{" "}
-				<code>knowledgeGraph()</code> via one effect. The KG canvas to the right subscribes to{" "}
-				<code>kg.adjacency</code> — no polling, no triggers.
-			</p>
-			<AdapterBanner info={info} />
-			<div className="controls">
-				<input
-					type="url"
-					placeholder="Paste any article URL — fetched via r.jina.ai (anonymous, 20 RPM)"
-					value={urlInput}
-					onChange={(e) => setUrlInput(e.target.value)}
-					onKeyDown={(e) => {
-						if (e.key === "Enter") loadUrl();
-					}}
-				/>
-				<button type="button" onClick={loadUrl}>
-					Load URL
-				</button>
-				<button type="button" className="secondary" onClick={loadDefault}>
-					Use sample
-				</button>
-				<button
-					type="button"
-					className="secondary"
-					onClick={() => chapter.advance()}
-					disabled={paragraphs.length === 0}
-				>
-					Extract next paragraph ({paragraphIdx + 1} / {paragraphs.length})
-				</button>
-				<button type="button" className="danger" onClick={() => chapter.reset()}>
-					Reset KG
-				</button>
-			</div>
-			{fetchStatus ? (
-				<div className="adapter-banner unavailable">
-					<span>{fetchStatus}</span>
-				</div>
-			) : null}
-			<div className="extraction-grid">
-				<PaperPane
-					title={meta.title}
-					author={meta.author}
-					url={meta.url}
-					body={paperText}
-					currentParagraph={currentParagraph}
-				/>
-				<div className="kg-pane" data-kg-pane>
-					<h4>Knowledge graph (force-directed)</h4>
-					<div className="kg-stats">
-						<span>
-							entities: <strong>{snap.entities.length}</strong>
-						</span>
-						<span>
-							edges: <strong>{snap.edges.length}</strong>
-						</span>
-					</div>
-					<KGPane
-						entities={snap.entities}
-						edges={snap.edges}
-						hoverId={hoverTarget?.id ?? null}
-						onHover={(id) => onHover(id ? { pane: "visual", id } : null)}
-					/>
-				</div>
-			</div>
-		</div>
-	);
-}
diff --git a/demos/knowledge-graph/src/data/sample-paper.ts b/demos/knowledge-graph/src/data/sample-paper.ts
deleted file mode 100644
index 7821a87b..00000000
--- a/demos/knowledge-graph/src/data/sample-paper.ts
+++ /dev/null
@@ -1,43 +0,0 @@
-// Default content for the demo. Bundled so the page works offline and on
-// first paint without needing an external fetch. Source attribution is
-// preserved in the title; users can swap to any URL via the textarea.
-
-export type SamplePaper = {
-	url: string;
-	title: string;
-	author: string;
-	body: string;
-};
-
-export const SAMPLE_PAPER: SamplePaper = {
-	url: "https://medium.com/be-open/what-is-ai-harness-engineering-your-guide-to-controlling-autonomous-systems-30c9c8d2b489",
-	title: "What is AI Harness Engineering? Your Guide to Controlling Autonomous Systems",
-	author: "Mohit Sewak, Ph.D. — Be Open · Mar 3, 2026",
-	body: `AI Harness Engineering represents a fundamental shift in how we approach artificial intelligence development. Rather than writing every instruction, developers become "strategic architects" designing safe environments for autonomous systems. The discipline translates abstract concepts like "AI Alignment" into concrete technical implementations.
-
-The risks of poorly controlled AI systems extend beyond traditional software bugs. Reward Hacking can emerge when systems achieve stated goals through unintended methods, such as eliminating complaint channels rather than improving products. Emergent Behaviors are AI systems developing unexpected capabilities not explicitly programmed, which can be benign or dangerous. Value Brittleness shows up when systems follow literal instructions while missing their intended purpose.
-
-Effective AI control requires a layered system. AI Agent Architecture builds a leash into the brain through structural design that constrains AI decision-making. The Thinking Corner is where Planning happens; the Tool Shed restricts Action to pre-approved tools and APIs; the Magic Mirror is for Reflection on action outcomes; the Never-Forget Notebook is long-term Memory that prevents repeated mistakes through historical record-keeping.
-
-Reward Engineering is the art of the perfect doggy treat. Reward Shaping uses intermediate rewards to guide systems toward complex objectives. Penalty Design establishes clear consequences for prohibited behaviors. Designers must anticipate creative misinterpretation of reward functions.
-
-Constraints and Guardrails are the unbreakable fences — non-negotiable operational rules including prohibitions on harmful content generation, privacy violations, and deceptive practices. Automated monitoring acts as a digital immune system, continuously detecting and correcting deviations.
-
-Human-in-the-Loop is the ultimate failsafe. Human judgment remains essential for high-stakes decisions and ethically complex scenarios where machines lack wisdom, empathy, and contextual understanding.
-
-Mechanistic Interpretability reverse-engineers internal AI processes into understandable components, enabling detection of hidden objectives and deceptive alignment. Formal Verification provides mathematical proofs that AI systems will not violate specific safety rules under defined conditions, but works best for narrow concrete properties rather than complex contextual ethical guidelines.
-
-Red Teaming hires hackers to break your AI: adversarial teams actively attempt to compromise AI safety controls. Adversarial Robustness trains systems on adversarially crafted examples — intentionally designed inputs that trick AI systems — improving resilience to imperceptible modifications.
-
-Human oversight scales poorly when supervising vastly superior intelligence. AI Debate pits competing AI systems against each other to generate arguments humans can evaluate. Weak-to-Strong Generalization develops techniques enabling weaker supervisors to effectively train more capable systems. Constitutional AI provides core principles as an ethical framework, with AI systems supervising each other based on these constitutional guidelines.
-
-The Value Alignment Problem remains unsolved — translating nuanced contextual human values into executable code presents persistent challenges. Engineers and Researchers must continue innovation in scalable oversight, automated interpretability, and robust assurance methods. Policymakers move beyond vague principles toward concrete standards. Business Leaders treat safety as harness engineering investment from project inception, not as an added feature.`,
-};
-
-/** Split a paper body into paragraphs the LLM extractor can chew on. */
-export function splitParagraphs(body: string): readonly string[] {
-	return body
-		.split(/\n\s*\n/)
-		.map((p) => p.trim())
-		.filter((p) => p.length > 40);
-}
diff --git a/demos/knowledge-graph/src/lib/chapters/_shared.ts b/demos/knowledge-graph/src/lib/chapters/_shared.ts
deleted file mode 100644
index 8f8f849f..00000000
--- a/demos/knowledge-graph/src/lib/chapters/_shared.ts
+++ /dev/null
@@ -1,76 +0,0 @@
-// Shared helpers for the four chapters. Keeps the per-chapter source compact
-// so the right-side code pane can quote them at full fidelity.
-
-import { type KnowledgeGraphGraph, knowledgeGraph } from "@graphrefly/graphrefly/utils/memory";
-import type { Node } from "@graphrefly/pure-ts";
-import type { Entity, Relation } from "../types.js";
-
-export type DemoKG = KnowledgeGraphGraph<Entity, Relation>;
-
-export type KGSnapshot = {
-	entities: ReadonlyArray<Entity>;
-	edges: ReadonlyArray<{ from: string; to: string; relation: Relation }>;
-};
-
-export function makeKG(name: string): DemoKG {
-	return knowledgeGraph<Entity, Relation>(name);
-}
-
-/**
- * Read a coherent { entities, edges } snapshot from a knowledgeGraph()'s nodes.
- * Used by chapters/UI to render the visual KG. Reads `.cache` directly — fine
- * for one-shot reads; subscribe to `kg/entities` + `kg/edges` for reactive UI.
- */
-export function readKGSnapshot(kg: DemoKG): KGSnapshot {
-	const entities = kg.resolve("entities").cache as ReadonlyMap<string, Entity> | undefined;
-	// `edges` is reactiveMap.entries — cache is a Map keyed by edge id, not an array.
-	const edgeMap = kg.resolve("edges").cache as
-		| ReadonlyMap<string, { from: string; to: string; relation: Relation }>
-		| undefined;
-	return {
-		entities: entities ? [...entities.values()] : [],
-		edges: edgeMap
-			? [...edgeMap.values()].map((e) => ({ from: e.from, to: e.to, relation: e.relation }))
-			: [],
-	};
-}
-
-/**
- * Apply a single extraction result to the KG. Skips relations whose endpoints
- * weren't included in the same extraction (LLMs occasionally emit dangling
- * references).
- */
-export function applyExtractionToKG(
-	kg: DemoKG,
-	result: {
-		entities: readonly Entity[];
-		relations: readonly { from: string; to: string; relation: Relation }[];
-	},
-): void {
-	const validIds = new Set(result.entities.map((e) => e.id));
-	for (const e of result.entities) kg.upsertEntity(e.id, e);
-	for (const r of result.relations) {
-		if (!validIds.has(r.from) || !validIds.has(r.to)) continue;
-		kg.link(r.from, r.to, r.relation);
-	}
-}
-
-/** Cast a node's cache to the KGSnapshot shape, regardless of subscribe lifecycle. */
-export function snapshotFromNodes(
-	entitiesNode: Node<unknown>,
-	edgesNode: Node<unknown>,
-): KGSnapshot {
-	const ents = (entitiesNode.cache as ReadonlyMap<string, Entity> | undefined) ?? new Map();
-	const edgeMap =
-		(edgesNode.cache as
-			| ReadonlyMap<string, { from: string; to: string; relation: Relation }>
-			| undefined) ?? new Map();
-	return {
-		entities: [...ents.values()],
-		edges: [...edgeMap.values()].map((e) => ({
-			from: e.from,
-			to: e.to,
-			relation: e.relation,
-		})),
-	};
-}
diff --git a/demos/knowledge-graph/src/lib/chapters/baseline.ts b/demos/knowledge-graph/src/lib/chapters/baseline.ts
deleted file mode 100644
index 92400a65..00000000
--- a/demos/knowledge-graph/src/lib/chapters/baseline.ts
+++ /dev/null
@@ -1,75 +0,0 @@
-// Chapter 1 — "this is just a fancy Map so far".
-//
-// Pedagogical purpose: dispel the "knowledgeGraph() is Obsidian" misconception
-// up front. Show the imperative API first so users understand the shape, then
-// label it "static — no reactivity here." The next chapter is the contrast.
-
-import type { NodeRegistry } from "@graphrefly/graphrefly/utils/demo-shell";
-import { type DemoKG, makeKG } from "./_shared.js";
-
-export const BASELINE_SOURCE = `// 1. Create a knowledgeGraph() — it's a Graph with three named nodes
-//    (entities, edges, adjacency) plus four imperative methods.
-const kg = knowledgeGraph<Entity, Relation>("baseline");
-
-// 2. Seed it with hand-written entities and links. This is what every
-//    KG demo on the internet stops at. Looks like a fancy Map.
-kg.upsertEntity("alignment", {
-  id: "alignment", label: "AI Alignment", kind: "concept",
-});
-kg.upsertEntity("hitl", {
-  id: "hitl", label: "Human-in-the-Loop", kind: "method",
-});
-kg.upsertEntity("brittleness", {
-  id: "brittleness", label: "Value Brittleness", kind: "risk",
-});
-
-kg.link("hitl",         "brittleness", "addresses");
-kg.link("alignment",    "brittleness", "contrasts_with");
-kg.link("hitl",         "alignment",    "part_of");
-
-// 3. Imperative query — for outside-the-graph code (event handlers, tool
-//    results, REST handlers). Fine here. The next chapter is the *reactive*
-//    consumer that you cannot build with a plain Map.
-kg.related("hitl");           // → 2 edges
-kg.related("hitl", "addresses"); // → 1 edge
-`;
-
-export type BaselineChapter = {
-	id: "baseline";
-	graph: DemoKG;
-	kg: DemoKG;
-	sourceCode: string;
-	registry: NodeRegistry;
-	reseed: () => void;
-};
-
-function seed(kg: DemoKG): void {
-	kg.upsertEntity("alignment", { id: "alignment", label: "AI Alignment", kind: "concept" });
-	kg.upsertEntity("hitl", { id: "hitl", label: "Human-in-the-Loop", kind: "method" });
-	kg.upsertEntity("brittleness", { id: "brittleness", label: "Value Brittleness", kind: "risk" });
-	kg.link("hitl", "brittleness", "addresses");
-	kg.link("alignment", "brittleness", "contrasts_with");
-	kg.link("hitl", "alignment", "part_of");
-}
-
-export function buildBaselineChapter(): BaselineChapter {
-	const kg = makeKG("baseline");
-	seed(kg);
-
-	const registry: NodeRegistry = new Map([
-		["entities", { codeLine: 7, visualSelector: "[data-kg-pane]" }],
-		["edges", { codeLine: 17, visualSelector: "[data-kg-pane]" }],
-		["adjacency", { codeLine: 17, visualSelector: "[data-kg-pane]" }],
-	]);
-
-	return {
-		id: "baseline",
-		graph: kg,
-		kg,
-		sourceCode: BASELINE_SOURCE,
-		registry,
-		reseed() {
-			seed(kg);
-		},
-	};
-}
diff --git a/demos/knowledge-graph/src/lib/chapters/guard.ts b/demos/knowledge-graph/src/lib/chapters/guard.ts
deleted file mode 100644
index 014111f5..00000000
--- a/demos/knowledge-graph/src/lib/chapters/guard.ts
+++ /dev/null
@@ -1,91 +0,0 @@
-// Chapter 4 — Guard. Same reactive pipeline; wrap the KG in policyGate
-// so an "untrusted-llm" actor is blocked from writing to entities.
-//
-// "Try malicious write" calls `kg.set("entities", value, { actor })` with the
-// untrusted-llm actor. policyGate in `enforce` mode pushes a guard onto
-// the entities node that throws GuardDenied for that actor. The legitimate
-// apply-extraction effect still works because `kg.upsertEntity` calls go
-// through internal writes that aren't tagged with the untrusted actor.
-// This is the closure for homepage pain point 03 ("Composition Without
-// Guardrails").
-
-import type { LLMAdapter } from "@graphrefly/graphrefly/utils/ai";
-import type { NodeRegistry } from "@graphrefly/graphrefly/utils/demo-shell";
-import { type PolicyGateGraph, policyGate } from "@graphrefly/graphrefly/utils/inspect";
-import { buildReactiveChapter, type ReactiveChapter } from "./reactive.js";
-
-export const GUARD_SOURCE = `// Same reactive pipeline as chapter 2.
-const kg = buildReactiveChapter(adapter, paper).kg;
-
-// Wrap the KG in a reactive ABAC enforcer. Mode: "enforce" pushes guards
-// onto target nodes so disallowed writes throw GuardDenied at write time.
-const enforced = policyGate(kg, [
-  { effect: "deny",  action: "write", actorType: "llm", actorId: "untrusted-llm" },
-  { effect: "allow", action: "write", actorType: "system" },
-], { mode: "enforce" });
-
-// A legitimate write — system actor, allowed. Use kg.set(path, value, opts)
-// — the public API. No protocol internals (DATA, raw down) leak into your
-// app code.
-kg.set("entities", nextEntities, { actor: { type: "system", id: "demo" } });
-
-// An adversarial write — same node, untrusted-llm actor. THROWS.
-try {
-  kg.set("entities", nextEntities, { actor: { type: "llm", id: "untrusted-llm" } });
-} catch (err) {
-  // GuardDenied — recorded to enforced.violations.
-}
-
-// All violations are reactive too — subscribe to the topic, build a UI.
-enforced.violations.events.subscribe(...);
-`;
-
-export type GuardChapter = Omit<ReactiveChapter, "id"> & {
-	id: "guard";
-	enforced: PolicyGateGraph;
-	tryMaliciousWrite: () => { ok: boolean; error?: string };
-};
-
-export function buildGuardChapter(adapter: LLMAdapter, initialPaperText: string): GuardChapter {
-	const base = buildReactiveChapter(adapter, initialPaperText);
-
-	const enforced = policyGate(
-		base.kg,
-		[
-			{ effect: "deny", action: "write", actorType: "llm", actorId: "untrusted-llm" },
-			{ effect: "allow", action: "write", actorType: "system" },
-		],
-		{ mode: "enforce", name: "kg_enforced" },
-	);
-
-	const registry: NodeRegistry = new Map(base.registry);
-	registry.set("policies", { codeLine: 5, visualSelector: "[data-guard-banner]" });
-	registry.set("violations", { codeLine: 18, visualSelector: "[data-guard-banner]" });
-
-	return {
-		...base,
-		id: "guard",
-		sourceCode: GUARD_SOURCE,
-		registry,
-		enforced,
-		tryMaliciousWrite() {
-			try {
-				const current =
-					(base.kg.resolve("entities").cache as ReadonlyMap<string, unknown> | undefined) ??
-					new Map();
-				const next = new Map(current);
-				next.set("malicious-injection", {
-					id: "malicious-injection",
-					label: "Malicious payload",
-					kind: "other",
-				});
-				base.kg.set("entities", next, {
-					actor: { type: "llm", id: "untrusted-llm" },
-				});
-				return { ok: true };
-			} catch (err) {
-				return { ok: false, error: err instanceof Error ? err.message : String(err) };
-			}
-		},
-	};
-}
diff --git a/demos/knowledge-graph/src/lib/chapters/inspect.ts b/demos/knowledge-graph/src/lib/chapters/inspect.ts
deleted file mode 100644
index b725d12f..00000000
--- a/demos/knowledge-graph/src/lib/chapters/inspect.ts
+++ /dev/null
@@ -1,71 +0,0 @@
-// Chapter 3 — Inspect & Trace.
-//
-// Reuses the reactive pipeline from chapter 2 and adds two introspection
-// surfaces:
-//
-// 1. `describe()` — the topology mermaid that's already rendering in the
-//    side pane. We just point at it and explain what users are looking at.
-// 2. `graph.describe({ explain: {...}, reactive: true })` — a live causal chain from
-//    `paper-text` to `adjacency`. Bumps whenever any node in between fires.
-//    This is the answer to "why did this entity end up here?" — homepage
-//    pain point 02.
-
-import type { LLMAdapter } from "@graphrefly/graphrefly/utils/ai";
-import type { NodeRegistry } from "@graphrefly/graphrefly/utils/demo-shell";
-import type { CausalChain, Node } from "@graphrefly/pure-ts";
-import { buildReactiveChapter, type ReactiveChapter } from "./reactive.js";
-
-export const INSPECT_SOURCE = `// Same pipeline as chapter 2 — paper → paragraphs → extraction → kg.
-// Now we ask the topology two questions, both reactively.
-
-// Q1: "what does this graph look like?" — describe() returns a snapshot.
-//     The right-side mermaid is just describe({ format: "mermaid" }).
-const snapshot = kg.describe({ detail: "standard" });
-
-// Q2: "what shaped the current paragraph?" — graph.describe({ explain: {...}, reactive: true })
-//     returns a Node<CausalChain> that re-derives whenever any node along
-//     the path fires. Subscribe to it, render the chain.
-//
-//     Trace stops at named nodes wired by user code. promptNode + the
-//     apply-extraction effect involve internal/imperative bridges, so the
-//     KG writes downstream are not statically traceable from here.
-const explain = kg.describe({ explain: { from: "paper-text", to: "current-paragraph" }, reactive: true });
-
-explain.node.subscribe(() => {
-  const chain = explain.node.cache;
-  // chain.steps[i] is { path, kind, depPaths, ... }
-  console.log(chain.text);
-});
-`;
-
-export type InspectChapter = Omit<ReactiveChapter, "id"> & {
-	id: "inspect";
-	explain: Node<CausalChain>;
-	disposeExplain: () => void;
-};
-
-export function buildInspectChapter(adapter: LLMAdapter, initialPaperText: string): InspectChapter {
-	const base = buildReactiveChapter(adapter, initialPaperText);
-
-	const explainHandle = base.kg.describe({
-		explain: { from: "paper-text", to: "current-paragraph", maxDepth: 12 },
-		reactive: true,
-		name: "explain-paper-to-current",
-	});
-	base.kg.add(explainHandle.node, { name: "explain-paper-to-current" });
-
-	const registry: NodeRegistry = new Map(base.registry);
-	registry.set("explain-paper-to-current", {
-		codeLine: 14,
-		visualSelector: "[data-explain-chain]",
-	});
-
-	return {
-		...base,
-		id: "inspect",
-		sourceCode: INSPECT_SOURCE,
-		registry,
-		explain: explainHandle.node,
-		disposeExplain: explainHandle.dispose,
-	};
-}
diff --git a/demos/knowledge-graph/src/lib/chapters/reactive.ts b/demos/knowledge-graph/src/lib/chapters/reactive.ts
deleted file mode 100644
index 0f9b64e4..00000000
--- a/demos/knowledge-graph/src/lib/chapters/reactive.ts
+++ /dev/null
@@ -1,203 +0,0 @@
-// Chapter 2 — the reactive turn. THIS is the moment users understand why a
-// knowledgeGraph() is a Graph, not just a Map.
-//
-// Topology:
-//
-//   paper-text (state)
-//        │
-//        ▼
-//   paragraphs (derived)
-//        │            ┌── paragraph-idx (state)
-//        ▼            ▼
-//      current-paragraph (derived)
-//        │
-//        ▼
-//   extraction (promptNode → JSON)
-//        │
-//        ▼
-//   apply-extraction (effect — calls kg.upsertEntity / kg.link)
-//        │
-//        ▼
-//   kg/{entities,edges,adjacency}  ← UI subscribes here, never polls.
-
-import { type LLMAdapter, promptNode } from "@graphrefly/graphrefly/utils/ai";
-import type { NodeRegistry } from "@graphrefly/graphrefly/utils/demo-shell";
-import { batch, type Node } from "@graphrefly/pure-ts";
-import { buildUserPrompt, EXTRACTION_SYSTEM_PROMPT } from "../extraction-schema.js";
-import { splitContentParagraphs } from "../paragraphs.js";
-import type { Entity, ExtractionResult } from "../types.js";
-import { applyExtractionToKG, type DemoKG, makeKG } from "./_shared.js";
-
-export const REACTIVE_SOURCE = `// 1. The KG is the same factory as chapter 1 — but now it's the END of a
-//    pipeline, not the whole story.
-const kg = knowledgeGraph<Entity, Relation>("reactive");
-
-// 2. Reactive sources for the paper and the current cursor into it.
-const paperText      = state(SAMPLE_PAPER, { name: "paper-text" });
-const paragraphIdx   = state(0,             { name: "paragraph-idx" });
-
-// 3. Pure derived nodes — split + index.
-const paragraphs = derived([paperText], ([t]) => splitParagraphs(t),
-  { name: "paragraphs" });
-const currentParagraph = derived([paragraphs, paragraphIdx],
-  ([ps, i]) => ps[i] ?? "",
-  { name: "current-paragraph" });
-
-// 4. promptNode — universal LLM transform. Re-fires whenever current-paragraph
-//    changes. Output is a JSON ExtractionResult shaped by responseConstraint.
-const extraction = promptNode<ExtractionResult>(
-  llmAdapter,                 // chrome-nano OR mock — same contract
-  [currentParagraph],
-  (p) => buildUserPrompt(p as string),
-  { name: "extraction", format: "json", systemPrompt: EXTRACTION_SYSTEM_PROMPT },
-);
-
-// 5. The bridge — an effect that funnels each new extraction into the KG.
-//    THIS is the only imperative line in the pipeline. Everything downstream
-//    (entities / edges / adjacency / your visualization) is reactive.
-const applyExtraction = effect([extraction], ([result]) => {
-  if (!result) return;
-  applyExtractionToKG(kg, result);
-});
-
-// 6. Advance the cursor → step 4 re-fires → step 5 writes to kg → adjacency
-//    re-derives → your KG visualization re-renders. No polling, no triggers.
-shell.advance(); // → paragraphIdx + 1
-`;
-
-export type ReactiveChapter = {
-	id: "reactive";
-	graph: DemoKG; // the KG IS the chapter graph; upstream nodes are added to it
-	kg: DemoKG;
-	sourceCode: string;
-	registry: NodeRegistry;
-	paperText: Node<string>;
-	paragraphIdx: Node<number>;
-	paragraphs: Node<readonly string[]>;
-	currentParagraph: Node<string>;
-	extraction: Node<ExtractionResult | null>;
-	setPaperText: (text: string) => void;
-	setParagraphIdx: (i: number) => void;
-	advance: () => void;
-	reset: () => void;
-};
-
-export function buildReactiveChapter(
-	adapter: LLMAdapter,
-	initialPaperText: string,
-): ReactiveChapter {
-	const kg = makeKG("reactive");
-
-	const paperText = kg.state("paper-text", initialPaperText);
-	const paragraphIdx = kg.state("paragraph-idx", 0);
-
-	const paragraphs = kg.derived(
-		"paragraphs",
-		[paperText],
-		(data, ctx) => {
-			const t = data[0] != null && data[0].length > 0 ? data[0].at(-1) : ctx.prevData[0];
-			return [splitContentParagraphs((t as string) ?? "")];
-		},
-		{ initial: [] as readonly string[] },
-	);
-
-	const currentParagraph = kg.derived(
-		"current-paragraph",
-		[paragraphs, paragraphIdx],
-		(data, ctx) => {
-			const ps = data[0] != null && data[0].length > 0 ? data[0].at(-1) : ctx.prevData[0];
-			const i = data[1] != null && data[1].length > 0 ? data[1].at(-1) : ctx.prevData[1];
-			const list = (ps as readonly string[]) ?? [];
-			const idx = (i as number) ?? 0;
-			return [list[idx] ?? ""];
-		},
-		{ initial: "" },
-	);
-
-	const extraction = promptNode<ExtractionResult>(
-		adapter,
-		[currentParagraph],
-		(p) => buildUserPrompt((p as string) ?? ""),
-		{
-			name: "extraction",
-			format: "json",
-			systemPrompt: EXTRACTION_SYSTEM_PROMPT,
-			temperature: 0.2,
-		},
-	);
-
-	kg.effect(
-		"apply-extraction",
-		[extraction],
-		(data) => {
-			const result = data[0] != null && data[0].length > 0 ? data[0].at(-1) : null;
-			const r = result as ExtractionResult | null;
-			if (!r) return;
-			applyExtractionToKG(kg, r);
-		},
-		{ keepAlive: true },
-	);
-
-	// promptNode returns an unattached node — register it on the chapter graph.
-	kg.add(extraction, { name: "extraction" });
-
-	const registry: NodeRegistry = new Map([
-		["paper-text", { codeLine: 6, visualSelector: "[data-paper-text]" }],
-		["paragraph-idx", { codeLine: 7, visualSelector: "[data-current-paragraph]" }],
-		["paragraphs", { codeLine: 10, visualSelector: "[data-paper-text]" }],
-		["current-paragraph", { codeLine: 12, visualSelector: "[data-current-paragraph]" }],
-		["extraction", { codeLine: 18, visualSelector: "[data-kg-pane]" }],
-		["apply-extraction", { codeLine: 33, visualSelector: "[data-kg-pane]" }],
-		["entities", { codeLine: 33, visualSelector: "[data-kg-pane]" }],
-		["edges", { codeLine: 33, visualSelector: "[data-kg-pane]" }],
-		["adjacency", { codeLine: 33, visualSelector: "[data-kg-pane]" }],
-	]);
-
-	return {
-		id: "reactive",
-		graph: kg,
-		kg,
-		sourceCode: REACTIVE_SOURCE,
-		registry,
-		paperText,
-		paragraphIdx,
-		paragraphs,
-		currentParagraph,
-		extraction,
-		setPaperText(text: string) {
-			// Atomic — reset paragraph cursor so we don't index past the end of
-			// a (potentially shorter) new paper. Without this, an external
-			// caller hitting `setPaperText` directly would silently freeze the
-			// pipeline at currentParagraph === "".
-			batch(() => {
-				kg.set("paper-text", text);
-				kg.set("paragraph-idx", 0);
-			});
-		},
-		setParagraphIdx(i: number) {
-			kg.set("paragraph-idx", i);
-		},
-		advance() {
-			const ps = (paragraphs.cache as readonly string[] | undefined) ?? [];
-			const cur = (paragraphIdx.cache as number | undefined) ?? 0;
-			if (ps.length === 0) return;
-			kg.set("paragraph-idx", (cur + 1) % ps.length);
-		},
-		reset() {
-			// Reset KG only — clears entities/edges but leaves the paragraph
-			// cursor where the user left it. Two reasons:
-			//   1. Re-extracting the same paragraph wouldn't fire promptNode
-			//      anyway (currentParagraph value unchanged), so resetting idx
-			//      to 0 would just confuse the "Extract next" button label.
-			//   2. Users intuit "Reset KG" as "clear the graph", not "rewind
-			//      the cursor". Advancing extracts the next paragraph as
-			//      expected, repopulating from there.
-			// Defensive `[...keys()]` copy — `removeEntity` mutates the same
-			// Map we're iterating over.
-			batch(() => {
-				const ents = kg.resolve("entities").cache as ReadonlyMap<string, Entity> | undefined;
-				if (ents) for (const id of [...ents.keys()]) kg.removeEntity(id);
-			});
-		},
-	};
-}
diff --git a/demos/knowledge-graph/src/lib/chapters/types.ts b/demos/knowledge-graph/src/lib/chapters/types.ts
deleted file mode 100644
index 4d5a694d..00000000
--- a/demos/knowledge-graph/src/lib/chapters/types.ts
+++ /dev/null
@@ -1,32 +0,0 @@
-import type { NodeRegistry } from "@graphrefly/graphrefly/utils/demo-shell";
-import type { Graph } from "@graphrefly/pure-ts";
-import type { ComponentType } from "react";
-
-export type ChapterUIProps = {
-	hoverTarget: { pane: string; id: string } | null;
-	onHover: (target: { pane: "visual" | "graph" | "code"; id: string } | null) => void;
-	onSelect: (path: string | null) => void;
-};
-
-export type ChapterResolved = {
-	graph: Graph;
-	sourceCode: string;
-	registry: NodeRegistry;
-};
-
-export type Chapter = {
-	id: string;
-	label: string;
-	tagline: string;
-	UI: ComponentType<ChapterUIProps>;
-	/**
-	 * Lazy resolver — returns the chapter's graph + source-code + registry on
-	 * first activation. Cached internally by each chapter's `getXChapter()`,
-	 * so calling `resolve()` multiple times returns the same instance.
-	 *
-	 * Lazy construction means visiting only chapter 1 doesn't pay the cost
-	 * of building chapters 2/3/4 (including their `promptNode`/`policyEnforcer`
-	 * subgraphs) — and a probe failure in one chapter doesn't crash the others.
-	 */
-	resolve: () => ChapterResolved;
-};
diff --git a/demos/knowledge-graph/src/lib/chrome-nano-adapter.ts b/demos/knowledge-graph/src/lib/chrome-nano-adapter.ts
deleted file mode 100644
index d7efb37a..00000000
--- a/demos/knowledge-graph/src/lib/chrome-nano-adapter.ts
+++ /dev/null
@@ -1,182 +0,0 @@
-// Implements the GraphReFly LLMAdapter contract on top of Chrome's built-in
-// Prompt API (`window.LanguageModel`). Returns a `Promise<LLMResponse>` from
-// `invoke` — promptNode's switchMap consumes that without leaking async
-// primitives into the reactive layer (spec §5.10).
-
-import type {
-	ChatMessage,
-	LLMAdapter,
-	LLMInvokeOptions,
-	LLMResponse,
-} from "@graphrefly/graphrefly/utils/ai";
-import { EXTRACTION_SCHEMA } from "./extraction-schema.js";
-import type { AdapterInfo } from "./types.js";
-
-export type ChromeNanoAdapterHandle = {
-	adapter: LLMAdapter;
-	info(): AdapterInfo;
-	destroy(): void;
-};
-
-export type ChromeNanoOptions = {
-	/** Called when adapter info changes (download progress, ready, error). */
-	onInfo?: (info: AdapterInfo) => void;
-};
-
-const RESPONSE_CONSTRAINT = EXTRACTION_SCHEMA;
-
-export function isChromeNanoAvailable(): boolean {
-	return typeof window !== "undefined" && typeof (window as Window).LanguageModel !== "undefined";
-}
-
-export async function probeChromeNano(): Promise<AdapterInfo> {
-	if (!isChromeNanoAvailable()) {
-		return {
-			name: "chrome-nano",
-			status: "unavailable",
-			note: "window.LanguageModel not present. Use Chrome 138+ with the Prompt API origin trial or built-in AI flag enabled.",
-		};
-	}
-	try {
-		const a = await LanguageModel.availability({
-			expectedInputs: [{ type: "text", languages: ["en"] }],
-			expectedOutputs: [{ type: "text", languages: ["en"] }],
-		});
-		if (a === "unavailable") {
-			return {
-				name: "chrome-nano",
-				status: "unavailable",
-				note: "LanguageModel.availability() reported unavailable on this device.",
-			};
-		}
-		if (a === "downloading" || a === "after-download" || a === "downloadable") {
-			return {
-				name: "chrome-nano",
-				status: "downloading",
-				note: "Model is downloading on first use — first prompt will block until ready.",
-			};
-		}
-		return { name: "chrome-nano", status: "ready", note: "On-device Gemini Nano ready." };
-	} catch (err) {
-		return {
-			name: "chrome-nano",
-			status: "unavailable",
-			note: `Probe threw: ${err instanceof Error ? err.message : String(err)}`,
-		};
-	}
-}
-
-/**
- * Lazily creates one shared `LanguageModelSession` and reuses it across calls.
- * Sessions own a context window — for the demo's per-paragraph extraction we
- * want a fresh session each invocation so prior paragraphs don't bias the next
- * one. So `invoke` clones from the warm session each call.
- */
-export function chromeNanoAdapter(opts: ChromeNanoOptions = {}): ChromeNanoAdapterHandle {
-	let warm: Promise<LanguageModelSession> | null = null;
-	let info: AdapterInfo = {
-		name: "chrome-nano",
-		status: "downloading",
-		note: "warming up session…",
-	};
-
-	function setInfo(next: AdapterInfo) {
-		info = next;
-		opts.onInfo?.(next);
-	}
-
-	function ensureWarm(): Promise<LanguageModelSession> {
-		if (warm) return warm;
-		warm = LanguageModel.create({
-			temperature: 0.2,
-			topK: 3,
-			expectedInputs: [{ type: "text", languages: ["en"] }],
-			expectedOutputs: [{ type: "text", languages: ["en"] }],
-			monitor(m) {
-				m.addEventListener("downloadprogress", (e) => {
-					const pct = Math.round((e.loaded ?? 0) * 100);
-					setInfo({
-						name: "chrome-nano",
-						status: "downloading",
-						note: `Model downloading… ${pct}%`,
-					});
-				});
-			},
-		}).then(
-			(session) => {
-				setInfo({
-					name: "chrome-nano",
-					status: "ready",
-					note: "On-device Gemini Nano ready.",
-				});
-				return session;
-			},
-			(err) => {
-				warm = null; // allow retry on next invoke
-				setInfo({
-					name: "chrome-nano",
-					status: "unavailable",
-					note: `LanguageModel.create() failed: ${err instanceof Error ? err.message : String(err)}`,
-				});
-				throw err;
-			},
-		);
-		return warm;
-	}
-
-	const adapter: LLMAdapter = {
-		invoke(messages: readonly ChatMessage[], _opts?: LLMInvokeOptions) {
-			return (async (): Promise<LLMResponse> => {
-				const seed = await ensureWarm();
-				let session: LanguageModelSession | undefined;
-				try {
-					session = await seed.clone();
-					const lm: LanguageModelMessage[] = messages.map((m) => ({
-						role: m.role === "tool" ? "user" : (m.role as LanguageModelMessage["role"]),
-						content: m.content,
-					}));
-					const text = await session.prompt(lm, {
-						responseConstraint: RESPONSE_CONSTRAINT,
-					});
-					return { content: text, finishReason: "stop" };
-				} finally {
-					// `session` is undefined if `seed.clone()` rejected; guard before
-					// calling destroy so the original error propagates instead of
-					// being shadowed by a TypeError.
-					if (session) {
-						try {
-							session.destroy();
-						} catch {
-							// best-effort teardown
-						}
-					}
-				}
-			})() as unknown as ReturnType<LLMAdapter["invoke"]>;
-		},
-		stream(): AsyncIterable<string> {
-			// Streaming isn't used by the demo. Return a generator that throws
-			// on first iteration so a caller composing this into a stream
-			// pipeline gets an immediate, clear error.
-			return {
-				[Symbol.asyncIterator]() {
-					return {
-						next() {
-							return Promise.reject(
-								new Error("chromeNanoAdapter.stream is not implemented for this demo"),
-							);
-						},
-					};
-				},
-			};
-		},
-	};
-
-	return {
-		adapter,
-		info: () => info,
-		destroy() {
-			warm?.then((s) => s.destroy()).catch(() => {});
-			warm = null;
-		},
-	};
-}
diff --git a/demos/knowledge-graph/src/lib/extraction-schema.ts b/demos/knowledge-graph/src/lib/extraction-schema.ts
deleted file mode 100644
index b093f2e3..00000000
--- a/demos/knowledge-graph/src/lib/extraction-schema.ts
+++ /dev/null
@@ -1,84 +0,0 @@
-// JSON Schema fed to Chrome Nano via responseConstraint, and the matching
-// system prompt. Both adapters share the schema so output shape is identical
-// regardless of which one is in use.
-
-import type { EntityKind, Relation } from "./types.js";
-
-export const ENTITY_KINDS: readonly EntityKind[] = [
-	"concept",
-	"method",
-	"risk",
-	"actor",
-	"metric",
-	"other",
-];
-
-export const RELATIONS: readonly Relation[] = [
-	"is_a",
-	"part_of",
-	"addresses",
-	"uses",
-	"causes",
-	"contrasts_with",
-];
-
-export const EXTRACTION_SCHEMA = {
-	type: "object",
-	required: ["entities", "relations"],
-	additionalProperties: false,
-	properties: {
-		entities: {
-			type: "array",
-			maxItems: 8,
-			items: {
-				type: "object",
-				required: ["id", "label", "kind"],
-				additionalProperties: false,
-				properties: {
-					id: { type: "string", pattern: "^[a-z0-9_-]+$" },
-					label: { type: "string", minLength: 1, maxLength: 60 },
-					kind: { type: "string", enum: [...ENTITY_KINDS] },
-				},
-			},
-		},
-		relations: {
-			type: "array",
-			maxItems: 8,
-			items: {
-				type: "object",
-				required: ["from", "to", "relation"],
-				additionalProperties: false,
-				properties: {
-					from: { type: "string" },
-					to: { type: "string" },
-					relation: { type: "string", enum: [...RELATIONS] },
-				},
-			},
-		},
-	},
-};
-
-export const EXTRACTION_SYSTEM_PROMPT = `You extract a tiny knowledge graph from one paragraph at a time.
-
-What to extract:
-- Any meaningful **noun or noun phrase** — proper nouns (people, places, organizations) AND common nouns (concepts, processes, objects). Examples: "habitat", "fauna", "kingdom", "evolution", "neural network", "Mechanistic Interpretability", "Reward Hacking".
-- At most 6 entities per paragraph. Pick the ones the paragraph is actually about.
-
-What to skip:
-- Pronouns ("it", "they", "this"), discourse markers ("yes", "no", "okay", "however"), articles, prepositions, verbs, single letters.
-- Page chrome / UI labels ("Image", "See also", "Edit", "Caption", "Yes", "No").
-- Generic standalone words with no domain meaning ("thing", "stuff", "way").
-- Anything you'd be unable to draw a meaningful relation to/from.
-
-Schema constraints:
-- "id" must be lowercase snake_case derived from the label (use hyphens for spaces).
-- "kind" must be one of: ${ENTITY_KINDS.join(", ")}.
-- Add 1-6 relations between entities you returned.
-- "relation" must be one of: ${RELATIONS.join(", ")}.
-- Direction matters: "from → to". Pick the natural direction (e.g., "hitl part_of harness", not "harness part_of hitl").
-
-Output JSON only, matching the schema. No prose.`;
-
-export function buildUserPrompt(paragraph: string): string {
-	return `Extract entities and relations from this paragraph:\n\n${paragraph}`;
-}
diff --git a/demos/knowledge-graph/src/lib/lazy-adapter.ts b/demos/knowledge-graph/src/lib/lazy-adapter.ts
deleted file mode 100644
index 8da2e4bd..00000000
--- a/demos/knowledge-graph/src/lib/lazy-adapter.ts
+++ /dev/null
@@ -1,156 +0,0 @@
-// LLMAdapter wrapper that picks chrome-nano or mock at first invocation.
-//
-// Why this exists: chapter UIs are constructed synchronously at module load
-// (so the demo-shell can register the chapter's graph for the topology
-// mermaid). But Chrome Nano availability requires `await
-// LanguageModel.availability(...)`. If we built the chapter eagerly with a
-// mock adapter, Chrome Nano would never get a chance even when present.
-//
-// This wrapper is `LLMAdapter`-shaped, so the chapter captures it once. On
-// the first `invoke()`, it probes Chrome Nano, picks the real implementation,
-// and routes everything from then on.
-//
-// Adapter status is exposed as a `state<AdapterInfo>` Node so:
-//   1. UI banners subscribe via `useNodeValue(handle.infoNode, ...)`
-//   2. `graph.describe()` and `graph.describe({ explain: {...}, reactive: true })` see adapter status if
-//      callers attach the node to a graph
-//   3. Chrome Nano download progress propagates automatically (every push
-//      from chrome-nano-adapter's `onInfo` callback writes the state node)
-
-import type { LLMAdapter, LLMResponse } from "@graphrefly/graphrefly/utils/ai";
-import { type Node, node } from "@graphrefly/pure-ts";
-import { chromeNanoAdapter, probeChromeNano } from "./chrome-nano-adapter.js";
-import { mockExtractAdapter } from "./mock-extract-adapter.js";
-import type { AdapterInfo } from "./types.js";
-
-export type LazyAdapterHandle = {
-	adapter: LLMAdapter;
-	/** Reactive view of current adapter status. Subscribe via `useNodeValue`. */
-	infoNode: Node<AdapterInfo>;
-	/** Convenience peek (most callers should subscribe to `infoNode`). */
-	info(): AdapterInfo;
-};
-
-const PROBING_INFO: AdapterInfo = {
-	name: "mock",
-	status: "downloading",
-	note: "Probing Chrome Nano on first extraction…",
-};
-
-const MOCK_FALLBACK_NOTE = (probedNote: string) =>
-	`Chrome Nano not available — using mock fallback (keyword lexicon + capitalized-phrase + noun-suffix heuristic). For real LLM extraction, open Chrome 138+ with the Prompt API enabled (chrome://flags/#prompt-api-for-gemini-nano). Probe result: ${probedNote}`;
-
-export function lazyAdapter(): LazyAdapterHandle {
-	let chosen: LLMAdapter | null = null;
-	let mockFallback: LLMAdapter | null = null;
-	const infoNode = node<AdapterInfo>([], {
-		name: "adapter-info",
-		initial: PROBING_INFO,
-		describeKind: "state",
-	});
-
-	function setInfo(next: AdapterInfo): void {
-		infoNode.emit(next);
-	}
-
-	function mockAdapter(note: string): LLMAdapter {
-		if (!mockFallback) mockFallback = mockExtractAdapter();
-		setInfo({ name: "mock", status: "ready", note });
-		return mockFallback;
-	}
-
-	let pending: Promise<LLMAdapter> | null = null;
-	function choose(): Promise<LLMAdapter> {
-		if (chosen) return Promise.resolve(chosen);
-		if (pending) return pending;
-		pending = (async () => {
-			try {
-				const probed = await probeChromeNano();
-				// Only bind Chrome Nano when the model is actually ready. Treating
-				// "downloading" as ready made first extraction block on
-				// LanguageModel.create() — promptNode saw ERROR/null and the KG
-				// stayed empty even after many "Extract next paragraph" clicks.
-				if (probed.status === "ready") {
-					const handle = chromeNanoAdapter({ onInfo: setInfo });
-					chosen = handle.adapter;
-					setInfo(probed);
-				} else {
-					chosen = mockAdapter(
-						probed.status === "downloading"
-							? `${MOCK_FALLBACK_NOTE(probed.note)} (mock until Nano is ready — reload after download completes.)`
-							: MOCK_FALLBACK_NOTE(probed.note),
-					);
-				}
-				return chosen;
-			} catch (err) {
-				// Probe failure should not brick extraction — fall back to mock.
-				pending = null;
-				chosen = mockAdapter(
-					`Adapter probe failed — using mock fallback: ${
-						err instanceof Error ? err.message : String(err)
-					}`,
-				);
-				return chosen;
-			}
-		})();
-		return pending;
-	}
-
-	async function invokeWithFallback(
-		messages: Parameters<LLMAdapter["invoke"]>[0],
-		opts: Parameters<LLMAdapter["invoke"]>[1],
-	): Promise<LLMResponse> {
-		try {
-			const a = await choose();
-			const result = a.invoke(messages, opts);
-			if (result && typeof (result as PromiseLike<unknown>).then === "function") {
-				return await (result as PromiseLike<LLMResponse>);
-			}
-			return result as LLMResponse;
-		} catch (err) {
-			// Chrome Nano can probe "ready" then fail on create/prompt — recover
-			// once per page load by switching to the deterministic mock.
-			if (chosen !== mockFallback) {
-				chosen = mockAdapter(
-					`Chrome Nano invoke failed — using mock fallback: ${
-						err instanceof Error ? err.message : String(err)
-					}`,
-				);
-				const retry = chosen.invoke(messages, opts);
-				if (retry && typeof (retry as PromiseLike<unknown>).then === "function") {
-					return await (retry as PromiseLike<LLMResponse>);
-				}
-				return retry as LLMResponse;
-			}
-			throw err;
-		}
-	}
-
-	const adapter: LLMAdapter = {
-		invoke(messages, opts) {
-			return invokeWithFallback(messages, opts) as ReturnType<LLMAdapter["invoke"]>;
-		},
-		stream(messages, opts): AsyncIterable<string> {
-			return {
-				[Symbol.asyncIterator]() {
-					let inner: AsyncIterator<string> | null = null;
-					return {
-						async next() {
-							if (!inner) {
-								const a = await choose();
-								inner = a.stream(messages, opts)[Symbol.asyncIterator]();
-							}
-							return inner.next();
-						},
-					};
-				},
-			};
-		},
-	};
-
-	return {
-		adapter,
-		infoNode,
-		info: () => infoNode.cache as AdapterInfo,
-	};
-}
diff --git a/demos/knowledge-graph/src/lib/mermaid-render.ts b/demos/knowledge-graph/src/lib/mermaid-render.ts
deleted file mode 100644
index ec9eb657..00000000
--- a/demos/knowledge-graph/src/lib/mermaid-render.ts
+++ /dev/null
@@ -1,18 +0,0 @@
-import mermaid from "mermaid";
-import {
-	createNextMermaidId,
-	initMermaidRenderer,
-	MERMAID_NODE_STROKE_DEFAULT,
-	MERMAID_NODE_STROKE_MATCH,
-	MERMAID_THEME_VARIABLES,
-} from "../../../shared/lib/mermaid-theme";
-
-export { MERMAID_NODE_STROKE_DEFAULT, MERMAID_NODE_STROKE_MATCH, MERMAID_THEME_VARIABLES };
-
-export function initMermaid(): void {
-	initMermaidRenderer(mermaid);
-}
-
-export const nextMermaidId = createNextMermaidId("knowledge-graph");
-
-export { mermaid };
diff --git a/demos/knowledge-graph/src/lib/mock-extract-adapter.ts b/demos/knowledge-graph/src/lib/mock-extract-adapter.ts
deleted file mode 100644
index b3462af4..00000000
--- a/demos/knowledge-graph/src/lib/mock-extract-adapter.ts
+++ /dev/null
@@ -1,862 +0,0 @@
-// Deterministic fallback when Chrome Nano isn't available. Implements the same
-// LLMAdapter contract so the chapter graph topology is identical — only the
-// extraction quality differs.
-//
-// Strategy: a tiny dictionary of "interesting tokens" + a heuristic. When a
-// paragraph mentions a known concept, emit it as an entity, then link
-// neighbouring concepts via a guessed relation. Good enough to drive the
-// reactive demo without any model.
-
-import type { ChatMessage, LLMAdapter, LLMResponse } from "@graphrefly/graphrefly/utils/ai";
-import { ENTITY_KINDS } from "./extraction-schema.js";
-import type { Entity, EntityKind, Relation } from "./types.js";
-
-type Lex = { label: string; kind: EntityKind; aliases?: readonly string[] };
-
-const LEXICON: readonly Lex[] = [
-	{ label: "AI Harness Engineering", kind: "concept", aliases: ["harness engineering"] },
-	{ label: "AI Alignment", kind: "concept", aliases: ["alignment"] },
-	{ label: "Reward Hacking", kind: "risk" },
-	{ label: "Emergent Behaviors", kind: "risk", aliases: ["emergent behavior"] },
-	{ label: "Value Brittleness", kind: "risk" },
-	{ label: "Planning", kind: "method", aliases: ["thinking corner"] },
-	{ label: "Action", kind: "method", aliases: ["tool shed"] },
-	{ label: "Reflection", kind: "method", aliases: ["magic mirror"] },
-	{ label: "Memory", kind: "method", aliases: ["never-forget notebook"] },
-	{ label: "Reward Engineering", kind: "method" },
-	{ label: "Reward Shaping", kind: "method" },
-	{ label: "Penalty Design", kind: "method" },
-	{ label: "Constraints", kind: "method", aliases: ["guardrails"] },
-	{ label: "Human-in-the-Loop", kind: "method", aliases: ["hitl"] },
-	{ label: "Mechanistic Interpretability", kind: "method", aliases: ["interpretability"] },
-	{ label: "Formal Verification", kind: "method" },
-	{ label: "Red Teaming", kind: "method" },
-	{ label: "Adversarial Robustness", kind: "method" },
-	{ label: "AI Debate", kind: "method" },
-	{ label: "Weak-to-Strong Generalization", kind: "method" },
-	{ label: "Constitutional AI", kind: "method" },
-	{ label: "Engineer", kind: "actor" },
-	{ label: "Policymaker", kind: "actor" },
-	{ label: "Business Leader", kind: "actor" },
-	{ label: "Codebase Retrieval", kind: "method" },
-	{ label: "Code Graph", kind: "concept" },
-	{ label: "Commit Graph", kind: "concept" },
-	{ label: "RepoWiki", kind: "concept" },
-	{ label: "Vector Retrieval", kind: "method" },
-	{ label: "Agentic Search", kind: "method" },
-	{ label: "Engineering Knowledge Engine", kind: "concept" },
-];
-
-function slugify(label: string): string {
-	return label
-		.toLowerCase()
-		.replace(/[^a-z0-9]+/g, "-")
-		.replace(/^-+|-+$/g, "");
-}
-
-function findMatches(text: string): Entity[] {
-	const lower = text.toLowerCase();
-	const found: Entity[] = [];
-	const seen = new Set<string>();
-	for (const lex of LEXICON) {
-		const candidates = [lex.label, ...(lex.aliases ?? [])];
-		const hit = candidates.find((c) => lower.includes(c.toLowerCase()));
-		if (!hit) continue;
-		const id = slugify(lex.label);
-		if (seen.has(id)) continue;
-		seen.add(id);
-		found.push({ id, label: lex.label, kind: lex.kind });
-		if (found.length >= 6) break;
-	}
-	return found;
-}
-
-// Heuristic kind classifier for entities discovered by the generic extractor
-// (i.e., not in LEXICON). Order matters — first match wins.
-const KIND_PATTERNS: ReadonlyArray<{ kind: EntityKind; re: RegExp }> = [
-	{ kind: "risk", re: /(risk|threat|hazard|danger|hacking|brittleness|failure|attack|bias)/i },
-	{
-		kind: "actor",
-		re: /(engineer|leader|user|client|customer|admin|operator|researcher|policymaker|teacher|student|worker)/i,
-	},
-	{ kind: "metric", re: /(rate|score|percent|count|number|metric|kpi)/i },
-	{
-		kind: "method",
-		re: /(method|technique|approach|framework|system|engine|tool|algorithm|protocol|process|model)/i,
-	},
-];
-
-function classifyKind(label: string): EntityKind {
-	for (const p of KIND_PATTERNS) if (p.re.test(label)) return p.kind;
-	return "concept";
-}
-
-// Stop-words that show up in TitleCase headings/sentence-leads but aren't
-// entities. Mostly: pronouns, discourse markers, articles, prepositions,
-// short verbs, and Wikipedia-style page chrome ("Image", "See also").
-const STOP_PHRASES = new Set([
-	"The",
-	"This",
-	"These",
-	"That",
-	"Those",
-	"Some",
-	"Many",
-	"Most",
-	"Other",
-	"Another",
-	"However",
-	"Therefore",
-	"Although",
-	"While",
-	"When",
-	"Where",
-	"Why",
-	"How",
-	"What",
-	"Who",
-	"Which",
-	"Such",
-	"An",
-	"A",
-	"Its",
-	"Their",
-	"His",
-	"Her",
-	"Our",
-	"My",
-	"Your",
-	"It",
-	"They",
-	"We",
-	"You",
-	"I",
-	"For",
-	"From",
-	"With",
-	"Without",
-	"Into",
-	"Onto",
-	"Upon",
-	"About",
-	"Above",
-	"Below",
-	"After",
-	"Before",
-	"During",
-	"Through",
-	"Under",
-	"Over",
-	"Between",
-	// Wikipedia / web-page chrome
-	"Edit",
-	"References",
-	"See",
-	"Also",
-	"Notes",
-	"Bibliography",
-	"External",
-	"Image",
-	"Photo",
-	"Figure",
-	"Table",
-	"Caption",
-	"View",
-	"Print",
-	"Download",
-	"Help",
-	"Cite",
-	"Source",
-	"Note",
-	"Search",
-	"Toggle",
-	"Skip",
-	"Save",
-	"Visit",
-	"Learn",
-	"Read",
-	"Watch",
-	"Listen",
-	"Subscribe",
-	"Follow",
-	// Discourse markers / common short words that happen to start sentences
-	"Yes",
-	"No",
-	"Ok",
-	"Okay",
-	"Sure",
-	"True",
-	"False",
-	"Maybe",
-	"Hello",
-	"Welcome",
-	"Goodbye",
-	"Thanks",
-	"Please",
-	// Calendar / time
-	"Today",
-	"Tomorrow",
-	"Yesterday",
-	"Now",
-	"Then",
-	"Monday",
-	"Tuesday",
-	"Wednesday",
-	"Thursday",
-	"Friday",
-	"Saturday",
-	"Sunday",
-	"January",
-	"February",
-	"March",
-	"April",
-	"May",
-	"June",
-	"July",
-	"August",
-	"September",
-	"October",
-	"November",
-	"December",
-]);
-
-// Comprehensive English stopword set — pronouns, articles, prepositions,
-// conjunctions, modal verbs, common short verbs, discourse markers. Used to
-// reject candidates BEFORE the noun-suffix / frequency tests run, so common
-// non-nouns don't make it through. All entries are lowercased; Set dedupes.
-const STOPWORDS = new Set<string>([
-	// articles, determiners, pronouns
-	"the",
-	"this",
-	"that",
-	"these",
-	"those",
-	"some",
-	"many",
-	"most",
-	"other",
-	"another",
-	"such",
-	"any",
-	"all",
-	"each",
-	"every",
-	"either",
-	"neither",
-	"both",
-	"few",
-	"much",
-	"more",
-	"less",
-	"least",
-	"several",
-	"own",
-	"same",
-	"its",
-	"their",
-	"his",
-	"her",
-	"our",
-	"your",
-	"they",
-	"them",
-	"you",
-	"we",
-	"us",
-	"him",
-	"she",
-	"what",
-	"which",
-	"who",
-	"whom",
-	"whose",
-	"there",
-	"here",
-	"where",
-	"when",
-	"why",
-	"how",
-	"ourselves",
-	"themselves",
-	// auxiliaries / modals
-	"have",
-	"has",
-	"had",
-	"having",
-	"been",
-	"being",
-	"are",
-	"were",
-	"was",
-	"will",
-	"would",
-	"could",
-	"should",
-	"shall",
-	"may",
-	"might",
-	"must",
-	"can",
-	// prepositions / conjunctions
-	"with",
-	"without",
-	"into",
-	"onto",
-	"upon",
-	"about",
-	"above",
-	"below",
-	"after",
-	"before",
-	"during",
-	"through",
-	"under",
-	"over",
-	"between",
-	"among",
-	"across",
-	"against",
-	"along",
-	"around",
-	"behind",
-	"beside",
-	"beyond",
-	"from",
-	"for",
-	"and",
-	"but",
-	"nor",
-	"yet",
-	"or",
-	"though",
-	"although",
-	"while",
-	"because",
-	"since",
-	"until",
-	"unless",
-	"than",
-	"then",
-	"now",
-	"ever",
-	"never",
-	"still",
-	"only",
-	"also",
-	"even",
-	"just",
-	"too",
-	"very",
-	"quite",
-	"rather",
-	"perhaps",
-	"maybe",
-	"indeed",
-	"however",
-	"therefore",
-	"moreover",
-	"furthermore",
-	"additionally",
-	"instead",
-	"likely",
-	"unlikely",
-	"almost",
-	"nearly",
-	"mostly",
-	"often",
-	"again",
-	// common short verbs (low signal as nouns)
-	"get",
-	"gets",
-	"got",
-	"getting",
-	"make",
-	"makes",
-	"made",
-	"making",
-	"take",
-	"takes",
-	"took",
-	"taken",
-	"taking",
-	"give",
-	"gives",
-	"gave",
-	"given",
-	"giving",
-	"see",
-	"sees",
-	"saw",
-	"seen",
-	"seeing",
-	"find",
-	"finds",
-	"found",
-	"finding",
-	"know",
-	"knows",
-	"knew",
-	"known",
-	"knowing",
-	"think",
-	"thinks",
-	"thought",
-	"thinking",
-	"come",
-	"comes",
-	"came",
-	"coming",
-	"want",
-	"wants",
-	"wanted",
-	"wanting",
-	"look",
-	"looks",
-	"looked",
-	"looking",
-	"use",
-	"uses",
-	"used",
-	"using",
-	"work",
-	"works",
-	"worked",
-	"working",
-	"call",
-	"calls",
-	"called",
-	"calling",
-	"try",
-	"tries",
-	"tried",
-	"trying",
-	"ask",
-	"asks",
-	"asked",
-	"asking",
-	"need",
-	"needs",
-	"needed",
-	"feel",
-	"feels",
-	"felt",
-	"feeling",
-	"become",
-	"becomes",
-	"became",
-	"becoming",
-	"leave",
-	"leaves",
-	"left",
-	"leaving",
-	"mean",
-	"means",
-	"meant",
-	"meaning",
-	"keep",
-	"keeps",
-	"kept",
-	"keeping",
-	"begin",
-	"begins",
-	"began",
-	"begun",
-	"seem",
-	"seems",
-	"seemed",
-	"help",
-	"helps",
-	"helped",
-	"show",
-	"shows",
-	"showed",
-	"shown",
-	"showing",
-	"hold",
-	"holds",
-	"held",
-	"holding",
-	"include",
-	"includes",
-	"included",
-	"including",
-	"continue",
-	"continues",
-	"continued",
-	"continuing",
-	"consider",
-	"considers",
-	"considered",
-	"considering",
-	"describe",
-	"describes",
-	"described",
-	"describing",
-	"appear",
-	"appears",
-	"appeared",
-	"appearing",
-	"based",
-	"bases",
-	"basing",
-	// discourse / labels (also in STOP_PHRASES but mirrored here lowercased)
-	"yes",
-	"no",
-	"okay",
-	"sure",
-	"true",
-	"false",
-	"maybe",
-	"hello",
-	"thanks",
-	"please",
-	"today",
-	"tomorrow",
-	"yesterday",
-	"image",
-	"edit",
-	"view",
-	"print",
-	"note",
-	"notes",
-	"cite",
-	"source",
-	"sources",
-	"figure",
-	"table",
-	"caption",
-	"search",
-	"toggle",
-	"skip",
-	"save",
-	"learn",
-	"watch",
-	"listen",
-	"follow",
-	// common adjectives (not nouns)
-	"new",
-	"old",
-	"first",
-	"last",
-	"next",
-	"previous",
-	"good",
-	"bad",
-	"big",
-	"small",
-	"large",
-	"great",
-	"little",
-	"high",
-	"low",
-	"long",
-	"short",
-	"early",
-	"late",
-	"young",
-	"real",
-	"well",
-	"open",
-	"free",
-	"full",
-	"available",
-	"different",
-	"important",
-	"common",
-	"general",
-	"specific",
-	"natural",
-	"social",
-	"human",
-	"modern",
-	"current",
-	"particular",
-	"main",
-	"recent",
-	"various",
-	"similar",
-	"able",
-]);
-
-// Suffixes that strongly indicate a noun (not a verb / adjective / adverb).
-// Avoid weak suffixes like -er / -or / -ar that match many non-nouns
-// (under, over, never, after, danger, paper, water, etc.).
-const NOUN_SUFFIXES: readonly string[] = [
-	"tion",
-	"tions",
-	"sion",
-	"sions",
-	"ment",
-	"ments",
-	"ness",
-	"nesses",
-	"ity",
-	"ities",
-	"ism",
-	"isms",
-	"ance",
-	"ances",
-	"ence",
-	"ences",
-	"ship",
-	"ships",
-	"hood",
-	"hoods",
-	"ology",
-	"ologies",
-	"ologist",
-	"ologists",
-	"graphy",
-	"graphies",
-	"genesis",
-	"icide",
-	"cides",
-	"ician",
-	"icians",
-	"ery",
-	"eries",
-	"acy",
-	"acies",
-];
-
-function looksLikeNoun(lower: string): boolean {
-	if (lower.length < 5) return false;
-	for (const suf of NOUN_SUFFIXES) {
-		if (lower.length > suf.length + 2 && lower.endsWith(suf)) return true;
-	}
-	return false;
-}
-
-/**
- * Generic fallback for content not covered by LEXICON. Three signals merged:
- *   1. Multi-word Title-Case phrases (high-precision proper-noun signal)
- *   2. Single Title-Case words ≥3 mentions (high-precision, e.g., "Wikipedia")
- *   3. Lowercase common nouns identified by noun-suffix heuristic OR
- *      ≥3-mention frequency outside the stopword set
- *
- * Tries to be honest about the kind classification and the label casing
- * (preserves the most-common original casing). Will produce false positives —
- * users should switch to Chrome Nano for real LLM-grade extraction.
- */
-function findGenericMatches(text: string, maxEntities: number, exclude: Set<string>): Entity[] {
-	// Strip markdown link syntax `[label](url)` → `label` so we don't extract
-	// from URLs and we keep readable labels.
-	const cleaned = text.replace(/\[([^\]]+)\]\([^)]+\)/g, "$1");
-
-	type Bucket = { count: number; samples: Map<string, number> };
-	const phraseCount = new Map<string, number>(); // multi-word phrases (Title Case)
-	const wordBuckets = new Map<string, Bucket>(); // lowercased word → bucket
-
-	// Multi-word Title-Case phrases (2–4 words). Direct merge into output.
-	const multiWordRe =
-		/\b([A-Z][a-z]+(?:\s+(?:of|and|the|in|for|on|with)\s+[A-Z][a-z]+|\s+[A-Z][a-z]+){1,3})\b/g;
-	for (const m of cleaned.matchAll(multiWordRe)) {
-		const phrase = m[1]!.trim();
-		const words = phrase.split(/\s+/);
-		const realWords = words.filter((w) => !STOP_PHRASES.has(w));
-		if (realWords.length < 2) continue;
-		phraseCount.set(phrase, (phraseCount.get(phrase) ?? 0) + 1);
-	}
-
-	// Per-word counts (any case). Preserves observed casings so we can pick a
-	// representative label later (e.g., always emit "Habitat" if the source
-	// uses both "habitat" and "Habitat").
-	for (const wordMatch of cleaned.matchAll(/\b[a-zA-Z][a-zA-Z'-]+\b/g)) {
-		const w = wordMatch[0];
-		if (w.length < 4) continue;
-		const key = w.toLowerCase();
-		if (STOPWORDS.has(key)) continue;
-		if (STOP_PHRASES.has(w)) continue;
-		const bucket = wordBuckets.get(key) ?? { count: 0, samples: new Map() };
-		bucket.count += 1;
-		bucket.samples.set(w, (bucket.samples.get(w) ?? 0) + 1);
-		wordBuckets.set(key, bucket);
-	}
-
-	// Decide which singleton words to keep. A word qualifies if EITHER:
-	//   (a) it has a strong noun suffix AND appears ≥2 times; OR
-	//   (b) it appears ≥3 times AND is not in stopwords (already filtered).
-	// In addition, it must not already be part of a multi-word phrase, and
-	// must not be an obvious pronoun-like fragment.
-	const phraseTokens = new Set<string>();
-	for (const p of phraseCount.keys()) {
-		for (const tok of p.split(/\s+/)) phraseTokens.add(tok.toLowerCase());
-	}
-
-	const singletons: Array<{ label: string; count: number; isProper: boolean }> = [];
-	for (const [key, bucket] of wordBuckets) {
-		if (phraseTokens.has(key)) continue;
-		const isNounLike = looksLikeNoun(key);
-		const sufficientFrequency = bucket.count >= 3;
-		if (!isNounLike && !sufficientFrequency) continue;
-		// Pick the most-frequent observed casing as label.
-		const label = [...bucket.samples.entries()].sort((a, b) => b[1] - a[1])[0]![0];
-		const isProper = /^[A-Z]/.test(label);
-		// Reject lowercase singletons that don't look like nouns (defensive).
-		if (!isProper && !isNounLike) continue;
-		singletons.push({ label, count: bucket.count, isProper });
-	}
-
-	// Score: multi-word phrases first (highest precision), then proper-noun
-	// singletons by count, then suffix-noun singletons by count. Within each
-	// group, longer labels rank higher (more specific).
-	const multiEntries: Array<{ label: string; count: number; rank: number }> = [];
-	for (const [label, count] of phraseCount) {
-		multiEntries.push({ label, count, rank: 1000 + count });
-	}
-	const singleEntries = singletons.map((s) => ({
-		label: s.label,
-		count: s.count,
-		rank: (s.isProper ? 500 : 0) + s.count,
-	}));
-
-	const ranked = [...multiEntries, ...singleEntries]
-		.filter(({ label }) => !exclude.has(slugify(label)))
-		.sort((a, b) => b.rank - a.rank || b.label.length - a.label.length)
-		.slice(0, maxEntities);
-
-	return ranked.map(({ label }) => ({
-		id: slugify(label),
-		label: label.length > 50 ? `${label.slice(0, 49)}…` : label,
-		kind: classifyKind(label),
-	}));
-}
-
-// Hand-coded relations for known pairs in the bundled paper. Lookup happens
-// before the generic inferRelation fallback so the demo shows semantically
-// meaningful labels rather than monotone "is_a" chains. Direction matters:
-// from → to. When the two entities both appear in a paragraph, we emit the
-// edge in this exact direction.
-const KNOWN_RELATIONS: ReadonlyArray<{ from: string; to: string; relation: Relation }> = [
-	{ from: "hitl", to: "ai-harness-engineering", relation: "part_of" },
-	{ from: "constraints", to: "ai-harness-engineering", relation: "part_of" },
-	{ from: "reward-engineering", to: "ai-harness-engineering", relation: "part_of" },
-	{ from: "mechanistic-interpretability", to: "ai-harness-engineering", relation: "part_of" },
-	{ from: "red-teaming", to: "ai-harness-engineering", relation: "part_of" },
-	{ from: "adversarial-robustness", to: "ai-harness-engineering", relation: "part_of" },
-	{ from: "formal-verification", to: "ai-harness-engineering", relation: "part_of" },
-	{ from: "ai-debate", to: "ai-harness-engineering", relation: "part_of" },
-	{ from: "weak-to-strong-generalization", to: "ai-harness-engineering", relation: "part_of" },
-	{ from: "constitutional-ai", to: "ai-harness-engineering", relation: "part_of" },
-	{ from: "ai-harness-engineering", to: "ai-alignment", relation: "addresses" },
-	{ from: "hitl", to: "value-brittleness", relation: "addresses" },
-	{ from: "constraints", to: "reward-hacking", relation: "addresses" },
-	{ from: "reward-shaping", to: "reward-engineering", relation: "part_of" },
-	{ from: "penalty-design", to: "reward-engineering", relation: "part_of" },
-	{ from: "planning", to: "action", relation: "causes" },
-	{ from: "action", to: "reflection", relation: "causes" },
-	{ from: "reflection", to: "memory", relation: "causes" },
-	{ from: "memory", to: "planning", relation: "uses" },
-	{ from: "reward-hacking", to: "ai-alignment", relation: "contrasts_with" },
-	{ from: "value-brittleness", to: "ai-alignment", relation: "contrasts_with" },
-	{ from: "emergent-behaviors", to: "ai-alignment", relation: "contrasts_with" },
-	{ from: "engineer", to: "ai-harness-engineering", relation: "uses" },
-	{ from: "policymaker", to: "constraints", relation: "uses" },
-	{ from: "business-leader", to: "ai-harness-engineering", relation: "uses" },
-];
-
-function inferRelation(a: Entity, b: Entity): Relation {
-	const k = `${a.kind}->${b.kind}`;
-	switch (k) {
-		case "risk->method":
-		case "method->risk":
-			return "addresses";
-		case "method->concept":
-			return "part_of";
-		case "concept->method":
-			return "uses";
-		case "concept->concept":
-			return "is_a";
-		case "risk->risk":
-			return "causes";
-		case "method->method":
-			return "uses";
-		case "actor->method":
-		case "actor->concept":
-		case "actor->risk":
-			return "uses";
-		case "concept->risk":
-		case "method->actor":
-			return "addresses";
-		default:
-			return "part_of";
-	}
-}
-
-function extractFromParagraph(paragraph: string) {
-	const lex = findMatches(paragraph);
-	const exclude = new Set(lex.map((e) => e.id));
-	// Top up with generic capitalized-phrase matches when the lexicon misses
-	// (e.g., user pasted a Wikipedia article on something outside the
-	// harness-engineering domain). Aim for ~6 entities total.
-	const remaining = Math.max(0, 6 - lex.length);
-	const generic = remaining > 0 ? findGenericMatches(paragraph, remaining, exclude) : [];
-	const entities = [...lex, ...generic];
-	const ids = new Set(entities.map((e) => e.id));
-	const relations: Array<{ from: string; to: string; relation: Relation }> = [];
-	const seen = new Set<string>();
-
-	// 1. First, emit any KNOWN_RELATIONS whose both endpoints are present in
-	//    this paragraph. These carry hand-vetted direction and label.
-	for (const k of KNOWN_RELATIONS) {
-		if (!ids.has(k.from) || !ids.has(k.to)) continue;
-		const key = `${k.from}\u0000${k.to}`;
-		if (seen.has(key)) continue;
-		seen.add(key);
-		relations.push(k);
-	}
-
-	// 2. Then chain any consecutive matches that didn't get a known edge.
-	//    Direction follows the kind matrix: risks point at the methods that
-	//    address them, actors point at what they use, etc.
-	for (let i = 0; i < entities.length - 1; i += 1) {
-		const a = entities[i]!;
-		const b = entities[i + 1]!;
-		const [from, to] =
-			a.kind === "risk" && b.kind !== "risk"
-				? [b, a]
-				: a.kind === "actor"
-					? [a, b]
-					: b.kind === "actor"
-						? [b, a]
-						: [a, b];
-		const key = `${from.id}\u0000${to.id}`;
-		const reverseKey = `${to.id}\u0000${from.id}`;
-		if (seen.has(key) || seen.has(reverseKey)) continue;
-		seen.add(key);
-		relations.push({ from: from.id, to: to.id, relation: inferRelation(from, to) });
-	}
-	return { entities, relations };
-}
-
-export function mockExtractAdapter(): LLMAdapter {
-	return {
-		invoke(messages: readonly ChatMessage[]) {
-			return (async (): Promise<LLMResponse> => {
-				const userMsg = messages.findLast((m) => m.role === "user");
-				const paragraph = userMsg?.content ?? "";
-				const result = extractFromParagraph(paragraph);
-				// Validate that each kind is in ENTITY_KINDS — if not, drop. (No-op
-				// today, but keeps the adapter honest if LEXICON gains a typo.)
-				const entities = result.entities.filter((e) => ENTITY_KINDS.includes(e.kind));
-				return {
-					content: JSON.stringify({ entities, relations: result.relations }),
-					finishReason: "stop",
-				};
-			})() as unknown as ReturnType<LLMAdapter["invoke"]>;
-		},
-		stream(): AsyncIterable<string> {
-			return {
-				[Symbol.asyncIterator]() {
-					return {
-						next() {
-							return Promise.reject(
-								new Error("mockExtractAdapter.stream is not implemented for this demo"),
-							);
-						},
-					};
-				},
-			};
-		},
-	};
-}
diff --git a/demos/knowledge-graph/src/lib/pan-zoom.ts b/demos/knowledge-graph/src/lib/pan-zoom.ts
deleted file mode 100644
index 6f453073..00000000
--- a/demos/knowledge-graph/src/lib/pan-zoom.ts
+++ /dev/null
@@ -1,92 +0,0 @@
-// Pan + zoom for SVG containers. Same helper as the other demos — kept local so
-// each demo stays self-contained.
-
-export function attachPanZoom(container: HTMLElement): () => void {
-	let scale = 1;
-	let tx = 0;
-	let ty = 0;
-	let dragging = false;
-	let lastX = 0;
-	let lastY = 0;
-
-	const applyTransform = () => {
-		const svg = container.querySelector("svg") as
-			| (SVGElement & { style: CSSStyleDeclaration })
-			| null;
-		if (!svg) return;
-		svg.style.transformOrigin = "0 0";
-		svg.style.transform = `translate(${tx}px, ${ty}px) scale(${scale})`;
-	};
-
-	const onWheel = (e: WheelEvent) => {
-		e.preventDefault();
-		const factor = e.deltaY < 0 ? 1.1 : 1 / 1.1;
-		const rect = container.getBoundingClientRect();
-		const mx = e.clientX - rect.left;
-		const my = e.clientY - rect.top;
-		tx = mx - (mx - tx) * factor;
-		ty = my - (my - ty) * factor;
-		scale = Math.max(0.1, Math.min(10, scale * factor));
-		applyTransform();
-	};
-
-	const onPointerDown = (e: PointerEvent) => {
-		if (e.button !== 0) return;
-		dragging = true;
-		lastX = e.clientX;
-		lastY = e.clientY;
-		container.setPointerCapture(e.pointerId);
-		container.style.cursor = "grabbing";
-	};
-
-	const onPointerMove = (e: PointerEvent) => {
-		if (!dragging) return;
-		tx += e.clientX - lastX;
-		ty += e.clientY - lastY;
-		lastX = e.clientX;
-		lastY = e.clientY;
-		applyTransform();
-	};
-
-	const onPointerUp = (e: PointerEvent) => {
-		if (!dragging) return;
-		dragging = false;
-		try {
-			container.releasePointerCapture(e.pointerId);
-		} catch {
-			// pointer capture may already be released
-		}
-		container.style.cursor = "grab";
-	};
-
-	const onDoubleClick = () => {
-		scale = 1;
-		tx = 0;
-		ty = 0;
-		applyTransform();
-	};
-
-	container.addEventListener("wheel", onWheel, { passive: false });
-	container.addEventListener("pointerdown", onPointerDown);
-	container.addEventListener("pointermove", onPointerMove);
-	container.addEventListener("pointerup", onPointerUp);
-	container.addEventListener("pointercancel", onPointerUp);
-	container.addEventListener("dblclick", onDoubleClick);
-	container.style.cursor = "grab";
-	container.style.touchAction = "none";
-
-	const observer = new MutationObserver(() => applyTransform());
-	observer.observe(container, { childList: true });
-
-	return () => {
-		container.removeEventListener("wheel", onWheel);
-		container.removeEventListener("pointerdown", onPointerDown);
-		container.removeEventListener("pointermove", onPointerMove);
-		container.removeEventListener("pointerup", onPointerUp);
-		container.removeEventListener("pointercancel", onPointerUp);
-		container.removeEventListener("dblclick", onDoubleClick);
-		observer.disconnect();
-		container.style.cursor = "";
-		container.style.touchAction = "";
-	};
-}
diff --git a/demos/knowledge-graph/src/lib/paragraphs.ts b/demos/knowledge-graph/src/lib/paragraphs.ts
deleted file mode 100644
index e7e9604c..00000000
--- a/demos/knowledge-graph/src/lib/paragraphs.ts
+++ /dev/null
@@ -1,29 +0,0 @@
-// Shared paragraph filter — used by both the chapter (to drive `paragraphs`
-// state) and the PaperPane component (to render the same paragraph list).
-// Kept in one place so the two views never drift.
-//
-// Rejects:
-//   - paragraphs shorter than 80 chars (likely nav, headers, captions)
-//   - paragraphs where >40% of chars sit inside markdown link syntax
-//   - bullet/list-only blocks (TOCs, language lists)
-//   - quote/code blocks with no normal prose
-
-export function splitContentParagraphs(body: string): readonly string[] {
-	return body
-		.split(/\n\s*\n/)
-		.map((p) => p.trim())
-		.filter(isContentParagraph);
-}
-
-export function isContentParagraph(p: string): boolean {
-	if (p.length < 80) return false;
-	const linkChars = (p.match(/\[[^\]]+\]\([^)]+\)/g) ?? []).join("").length;
-	if (linkChars / p.length > 0.4) return false;
-	const lines = p.split(/\n/);
-	if (lines.length > 1) {
-		const bulletLines = lines.filter((l) => /^\s*[*\-+\d]+[.\s]/.test(l)).length;
-		if (bulletLines / lines.length > 0.6) return false;
-	}
-	if (/^\s*[>`]/.test(p) && !/[a-z]\s+[a-z]+\s+[a-z]/.test(p.toLowerCase())) return false;
-	return true;
-}
diff --git a/demos/knowledge-graph/src/lib/shell.ts b/demos/knowledge-graph/src/lib/shell.ts
deleted file mode 100644
index a5da73e8..00000000
--- a/demos/knowledge-graph/src/lib/shell.ts
+++ /dev/null
@@ -1,56 +0,0 @@
-import {
-	type DemoShellHandle,
-	demoShell,
-	type NodeRegistry,
-} from "@graphrefly/graphrefly/utils/demo-shell";
-import type { Graph } from "@graphrefly/pure-ts";
-import { type LazyAdapterHandle, lazyAdapter } from "./lazy-adapter.js";
-
-const liveRegistry: NodeRegistry = new Map();
-
-let shell: DemoShellHandle | null = null;
-let sharedAdapter: LazyAdapterHandle | null = null;
-
-/**
- * One LLM adapter shared across every chapter that does extraction. Probes
- * Chrome Nano on first invoke and routes there if available; falls back to
- * the mock heuristic otherwise. Same instance per page load so chapter 2,
- * 3, and 4 all see identical extraction behaviour and the user sees one
- * banner state across tab switches.
- */
-export function getSharedAdapter(): LazyAdapterHandle {
-	if (!sharedAdapter) sharedAdapter = lazyAdapter();
-	return sharedAdapter;
-}
-
-/** Page-level singleton (created once per mount). */
-export function getShell(viewportWidth?: number): DemoShellHandle {
-	if (!shell) {
-		shell = demoShell({
-			mainRatio: 0.6,
-			viewportWidth: viewportWidth ?? window.innerWidth,
-			nodeRegistry: liveRegistry,
-		});
-	}
-	return shell;
-}
-
-/**
- * Atomically repoint the shell at a chapter's graph + source + registry.
- * Same pattern as the reactive-layout demo: one batch, downstream derived
- * nodes (`graph/mermaid`, `highlight/*`) fire once per tab switch.
- */
-export function focusChapter(
-	s: DemoShellHandle,
-	chapter: { graph: Graph; sourceCode: string; registry: NodeRegistry },
-): void {
-	s.batch(() => {
-		liveRegistry.clear();
-		for (const [k, v] of chapter.registry) liveRegistry.set(k, v);
-		s.setDemoGraph(chapter.graph);
-		s.setCodeText(chapter.sourceCode);
-		s.selectNode(null);
-		s.setHoverTarget(null);
-		s.bumpGraphTick();
-	});
-}
diff --git a/demos/knowledge-graph/src/lib/types.ts b/demos/knowledge-graph/src/lib/types.ts
deleted file mode 100644
index d3c88260..00000000
--- a/demos/knowledge-graph/src/lib/types.ts
+++ /dev/null
@@ -1,28 +0,0 @@
-// Shared types across chapters and UI.
-
-export type EntityKind = "concept" | "method" | "risk" | "actor" | "metric" | "other";
-
-export type Entity = {
-	id: string;
-	label: string;
-	kind: EntityKind;
-};
-
-export type Relation = "is_a" | "part_of" | "addresses" | "uses" | "causes" | "contrasts_with";
-
-export type ExtractionResult = {
-	entities: readonly Entity[];
-	relations: ReadonlyArray<{
-		from: string;
-		to: string;
-		relation: Relation;
-	}>;
-};
-
-export type AdapterStatus = "ready" | "downloading" | "unavailable";
-
-export type AdapterInfo = {
-	name: "chrome-nano" | "mock";
-	status: AdapterStatus;
-	note: string;
-};
diff --git a/demos/knowledge-graph/src/lib/url-fetcher.ts b/demos/knowledge-graph/src/lib/url-fetcher.ts
deleted file mode 100644
index c654d84c..00000000
--- a/demos/knowledge-graph/src/lib/url-fetcher.ts
+++ /dev/null
@@ -1,82 +0,0 @@
-// Fetches an arbitrary web page as plain text via Jina's Reader API
-// (https://r.jina.ai/{url}). Anonymous; rate-limited to 20 RPM without a key,
-// which is plenty for a demo. Returns null on CORS / rate-limit / read errors
-// so the caller can fall back to the bundled sample paper.
-//
-// Defenses:
-//   - URL must parse and have an http(s) scheme. Rejects file://, data:, etc.
-//     (Jina filters server-side too, but cheap to reject up front.)
-//   - 15-second AbortController timeout so a slow Jina response doesn't hang
-//     the chapter forever.
-//   - Tolerates non-JSON 200 responses (some Jina error pages return text)
-//     by falling back to plain-text body.
-
-const READER_BASE = "https://r.jina.ai/";
-const FETCH_TIMEOUT_MS = 15_000;
-
-export type FetchedPaper = {
-	url: string;
-	title: string;
-	body: string;
-};
-
-export async function fetchPaper(url: string): Promise<FetchedPaper> {
-	let normalized = url.trim();
-	if (!/^https?:\/\//i.test(normalized)) normalized = `https://${normalized}`;
-	let parsed: URL;
-	try {
-		parsed = new URL(normalized);
-	} catch {
-		throw new Error(`Invalid URL: ${url}`);
-	}
-	if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
-		throw new Error(`Unsupported URL scheme: ${parsed.protocol}`);
-	}
-
-	const controller = new AbortController();
-	const timer = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
-
-	let response: Response;
-	try {
-		response = await fetch(`${READER_BASE}${parsed.toString()}`, {
-			headers: { Accept: "application/json" },
-			signal: controller.signal,
-		});
-	} catch (err) {
-		if (controller.signal.aborted) {
-			throw new Error(`Reader API timed out after ${FETCH_TIMEOUT_MS / 1000}s`);
-		}
-		throw err;
-	} finally {
-		clearTimeout(timer);
-	}
-
-	if (!response.ok) {
-		throw new Error(`Reader API ${response.status} ${response.statusText}`);
-	}
-
-	const raw = await response.text();
-	let payload: {
-		code?: number;
-		status?: number;
-		data?: { url?: string; title?: string; content?: string };
-	} | null;
-	try {
-		payload = JSON.parse(raw);
-	} catch {
-		// Some Jina error/info pages return text/plain even with Accept: json.
-		// Treat the whole body as `content` so the caller still gets something.
-		if (raw.trim().length > 0) {
-			return { url: parsed.toString(), title: parsed.hostname, body: raw };
-		}
-		throw new Error("Reader API returned empty body");
-	}
-
-	const data = payload?.data ?? {};
-	if (!data.content) throw new Error("Reader API returned empty content");
-	return {
-		url: data.url ?? parsed.toString(),
-		title: data.title ?? parsed.hostname,
-		body: data.content,
-	};
-}
diff --git a/demos/knowledge-graph/src/lib/use-node-value.ts b/demos/knowledge-graph/src/lib/use-node-value.ts
deleted file mode 100644
index aecff8d7..00000000
--- a/demos/knowledge-graph/src/lib/use-node-value.ts
+++ /dev/null
@@ -1,19 +0,0 @@
-import type { Node } from "@graphrefly/pure-ts";
-import { useEffect, useRef, useState } from "react";
-
-/** Subscribe to a GraphReFly node and return its current cache as React state. */
-export function useNodeValue<T>(node: Node<T> | null | undefined, initial: T): T {
-	// `initial` is captured by ref so callers can pass a fresh literal each
-	// render (e.g., `[]`) without forcing re-subscription on every render.
-	const initialRef = useRef(initial);
-	initialRef.current = initial;
-	const [v, set] = useState<T>(() => (node?.cache as T) ?? initial);
-	useEffect(() => {
-		if (!node) return;
-		set((node.cache as T) ?? initialRef.current);
-		return node.subscribe(() => {
-			set((node.cache as T) ?? initialRef.current);
-		});
-	}, [node]);
-	return v;
-}
diff --git a/demos/knowledge-graph/src/pages/index.astro b/demos/knowledge-graph/src/pages/index.astro
deleted file mode 100644
index fcfe3723..00000000
--- a/demos/knowledge-graph/src/pages/index.astro
+++ /dev/null
@@ -1,19 +0,0 @@
----
-import App from "../components/App.tsx";
-import "../styles/layout.css";
-import DemoNav from "../../../shared/components/DemoNav.astro";
-
-const base = import.meta.env.BASE_URL;
-const href = (p: string) => `${base.replace(/\/$/, "")}/${p.replace(/^\//, "")}`;
----
-<html lang="en">
-  <head>
-    <meta charset="UTF-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <title>Knowledge graph extraction — GraphReFly</title>
-  </head>
-  <body>
-    <DemoNav links={[{ href: href("/"), label: "Knowledge Graph", active: true }]} />
-    <App client:only="react" />
-  </body>
-</html>
diff --git a/demos/knowledge-graph/src/styles/layout.css b/demos/knowledge-graph/src/styles/layout.css
deleted file mode 100644
index 4c7850e5..00000000
--- a/demos/knowledge-graph/src/styles/layout.css
+++ /dev/null
@@ -1,461 +0,0 @@
-@import "../../../shared/styles/graphrefly-demo.css";
-
-/* ── Tab bar ───────────────────────────────────────────────────── */
-.app {
-	display: flex;
-	flex-direction: column;
-	height: calc(100vh - var(--gr-demo-nav-height));
-}
-.tab-bar {
-	display: flex;
-	align-items: center;
-	gap: 0.35rem;
-	padding: 0.6rem 1rem;
-	border-bottom: 1px solid var(--gr-border-subtle);
-	background: var(--gr-surface);
-}
-.tab {
-	background: transparent;
-	color: var(--gr-text-muted);
-	border: 1px solid transparent;
-	border-radius: 6px;
-	padding: 0.45em 0.9em;
-	font: inherit;
-	font-weight: 600;
-	cursor: pointer;
-	transition:
-		color 0.12s,
-		background 0.12s,
-		border-color 0.12s;
-}
-.tab:hover {
-	color: var(--gr-text);
-	background: var(--gr-surface-raised);
-}
-.tab.active {
-	color: var(--gr-ink);
-	background: var(--gr-lime);
-	border-color: var(--gr-lime-deep);
-}
-.tab-tagline {
-	margin-left: auto;
-	font-size: 12px;
-	color: var(--gr-text-muted);
-	font-style: italic;
-}
-
-/* ── Three-pane shell ──────────────────────────────────────────── */
-.demo-shell {
-	display: flex;
-	flex: 1 1 auto;
-	overflow: hidden;
-	min-height: 0;
-}
-.pane-main {
-	flex: 0 0 auto;
-	overflow-y: auto;
-	padding: 1.25rem 1.5rem 2rem;
-	display: flex;
-	flex-direction: column;
-	gap: 1rem;
-	min-width: 360px;
-}
-.pane-divider {
-	flex: 0 0 5px;
-	background: var(--gr-border);
-	cursor: col-resize;
-	transition: background 0.15s;
-}
-.pane-divider:hover {
-	background: var(--gr-aqua-dim);
-}
-.pane-side {
-	flex: 0 0 auto;
-	display: flex;
-	flex-direction: column;
-	min-width: 320px;
-	background: var(--gr-surface);
-	border-left: 1px solid var(--gr-border-subtle);
-}
-.pane-split-divider {
-	flex: 0 0 5px;
-	background: var(--gr-border);
-	cursor: row-resize;
-}
-.pane-split-divider:hover {
-	background: var(--gr-aqua-dim);
-}
-
-/* ── Inspect strip ─────────────────────────────────────────────── */
-.inspect-strip {
-	flex: 0 0 auto;
-	display: flex;
-	align-items: center;
-	gap: 1.25rem;
-	padding: 0.55rem 1.25rem;
-	border-top: 1px solid var(--gr-border-subtle);
-	background: var(--gr-surface-raised);
-	font-size: 12px;
-	color: var(--gr-text-muted);
-}
-.inspect-meta {
-	display: flex;
-	gap: 1rem;
-}
-.inspect-meta strong {
-	color: var(--gr-text);
-	font-weight: 600;
-}
-.inspect-detail {
-	display: flex;
-	align-items: center;
-	gap: 0.6rem;
-	margin-left: auto;
-}
-.inspect-detail code {
-	color: var(--gr-aqua);
-}
-.inspect-detail .pill {
-	background: var(--gr-surface);
-	color: var(--gr-text-muted);
-	border: 1px solid var(--gr-border);
-	border-radius: 999px;
-	padding: 0.05em 0.6em;
-	font-size: 11px;
-}
-
-/* ── Chapter shared ────────────────────────────────────────────── */
-.chapter {
-	display: flex;
-	flex-direction: column;
-	gap: 1rem;
-}
-.chapter-lede {
-	color: var(--gr-text-muted);
-	max-width: 60em;
-}
-.chapter .controls {
-	display: flex;
-	gap: 0.75rem;
-	flex-wrap: wrap;
-	align-items: center;
-}
-.chapter .controls input[type="text"],
-.chapter .controls input[type="url"] {
-	flex: 1 1 320px;
-	font-family: var(--font-mono);
-	font-size: 12.5px;
-	background: var(--gr-surface);
-	color: var(--gr-text);
-	border: 1px solid var(--gr-border);
-	border-radius: 6px;
-	padding: 0.5rem 0.65rem;
-	min-width: 280px;
-}
-.chapter .controls input:focus {
-	outline: none;
-	border-color: var(--gr-aqua);
-}
-.chapter .controls button {
-	background: var(--gr-aqua);
-	color: var(--gr-deep);
-	border: none;
-	border-radius: 6px;
-	padding: 0.5rem 0.85rem;
-	font: inherit;
-	font-weight: 600;
-	cursor: pointer;
-	transition: background 0.15s;
-}
-.chapter .controls button:hover {
-	background: #6af2d1;
-}
-.chapter .controls button.secondary {
-	background: var(--gr-surface-raised);
-	color: var(--gr-text);
-	border: 1px solid var(--gr-border);
-}
-.chapter .controls button.secondary:hover {
-	border-color: var(--gr-aqua);
-}
-.chapter .controls button.danger {
-	background: var(--gr-danger);
-	color: var(--gr-deep);
-}
-
-/* ── Adapter banner ────────────────────────────────────────────── */
-.adapter-banner {
-	display: flex;
-	align-items: center;
-	gap: 0.75rem;
-	padding: 0.55rem 0.85rem;
-	border-radius: 6px;
-	background: var(--gr-surface);
-	border: 1px solid var(--gr-border);
-	font-size: 12.5px;
-}
-.adapter-banner .pill {
-	font-family: var(--font-mono);
-	font-size: 11px;
-	padding: 0.1em 0.55em;
-	border-radius: 999px;
-	background: var(--gr-surface-raised);
-	color: var(--gr-text-muted);
-	border: 1px solid var(--gr-border);
-}
-.adapter-banner.ready .pill {
-	color: var(--gr-aqua);
-	border-color: var(--gr-aqua);
-}
-.adapter-banner.downloading .pill {
-	color: var(--gr-warn);
-	border-color: var(--gr-warn);
-}
-.adapter-banner.unavailable .pill {
-	color: var(--gr-warn);
-	border-color: var(--gr-warn);
-}
-.adapter-banner code {
-	font-size: 11.5px;
-}
-
-/* ── Extraction main pane (paper text + KG canvas) ────────────── */
-.extraction-grid {
-	display: grid;
-	grid-template-columns: minmax(280px, 1fr) minmax(360px, 1.4fr);
-	gap: 1rem;
-	flex: 1 1 auto;
-	min-height: 420px;
-	/* Two-column layout where each column manages its own height. The KG
-	   pane sticks to the top of the scroll viewport (see .kg-pane below)
-	   while the paper pane scrolls internally up to its capped height. */
-	align-items: start;
-}
-.kg-pane {
-	background: var(--gr-surface);
-	border: 1px solid var(--gr-border-subtle);
-	border-radius: 8px;
-	padding: 1rem;
-	display: flex;
-	flex-direction: column;
-	gap: 0.5rem;
-	overflow: hidden;
-	min-height: 0;
-	/* Float with scroll within its grid column — stays visible as the user
-	   scrolls the main pane (which is the nearest scrollable ancestor). */
-	position: sticky;
-	top: 0.5rem;
-	max-height: calc(100vh - 180px);
-}
-/* Narrower viewports: shrink the column minimums so two columns still fit
-   (and sticky still works). Only collapse to a single column when truly
-   too narrow to render side-by-side. */
-@media (max-width: 1100px) {
-	.extraction-grid {
-		grid-template-columns: minmax(240px, 1fr) minmax(280px, 1fr);
-	}
-}
-@media (max-width: 720px) {
-	.extraction-grid {
-		grid-template-columns: 1fr;
-	}
-	/* Override the sticky kg-pane for single-column stacked layout. Use a
-	   matching specific selector instead of !important so the cascade is
-	   predictable. */
-	.extraction-grid .kg-pane {
-		position: static;
-	}
-}
-.paper-pane {
-	background: var(--gr-surface);
-	border: 1px solid var(--gr-border-subtle);
-	border-radius: 8px;
-	padding: 1rem;
-	display: flex;
-	flex-direction: column;
-	gap: 0.65rem;
-	overflow: hidden;
-	min-height: 0;
-	/* Cap so the paper doesn't stretch the grid row indefinitely on long
-	   articles. Internal `.paper-text` scrolls. */
-	max-height: calc(100vh - 220px);
-}
-.paper-pane h4,
-.kg-pane h4 {
-	font-size: 11px;
-	letter-spacing: 0.1em;
-	text-transform: uppercase;
-	color: var(--gr-text-muted);
-	font-weight: 700;
-}
-.paper-meta {
-	font-size: 11.5px;
-	color: var(--gr-text-muted);
-}
-.paper-meta a {
-	color: var(--gr-aqua);
-	text-decoration: none;
-}
-.paper-meta a:hover {
-	text-decoration: underline;
-}
-.paper-text {
-	flex: 1 1 auto;
-	overflow: auto;
-	font-family: var(--font-sans);
-	font-size: 13.5px;
-	line-height: 1.55;
-	color: var(--gr-text);
-	white-space: pre-wrap;
-	background: var(--gr-preview-bg);
-	border: 1px dashed var(--gr-border);
-	border-radius: 6px;
-	padding: 0.6rem 0.85rem;
-}
-.paper-text .paragraph {
-	padding: 0.35rem 0.4rem;
-	border-radius: 4px;
-	margin: 0 -0.4rem;
-}
-.paper-text .paragraph.current {
-	background: var(--gr-aqua-glow);
-	box-shadow: inset 2px 0 0 var(--gr-aqua);
-}
-.kg-stats {
-	display: flex;
-	gap: 1rem;
-	font-size: 11.5px;
-	color: var(--gr-text-muted);
-}
-.kg-stats strong {
-	color: var(--gr-text);
-	font-family: var(--font-mono);
-}
-.kg-canvas {
-	flex: 1 1 auto;
-	background: var(--gr-preview-bg);
-	border: 1px dashed var(--gr-border);
-	border-radius: 6px;
-	overflow: hidden;
-	position: relative;
-	min-height: 320px;
-}
-.kg-canvas svg {
-	width: 100%;
-	height: 100%;
-	display: block;
-}
-.kg-empty {
-	position: absolute;
-	inset: 0;
-	display: flex;
-	align-items: center;
-	justify-content: center;
-	color: var(--gr-text-muted);
-	font-size: 13px;
-	pointer-events: none;
-}
-.kg-node circle {
-	fill: var(--gr-surface-raised);
-	stroke: var(--gr-aqua);
-	stroke-width: 1.2;
-	cursor: grab;
-	transition: stroke-width 0.1s;
-}
-.kg-node.kind-risk circle {
-	stroke: var(--gr-danger);
-}
-.kg-node.kind-method circle {
-	stroke: var(--gr-warn);
-}
-.kg-node.kind-actor circle {
-	stroke: #8aa7ff;
-}
-.kg-node.kind-metric circle {
-	stroke: #ce9af5;
-}
-.kg-node.hover circle,
-.kg-node.dragging circle {
-	stroke-width: 2.5;
-	filter: drop-shadow(0 0 6px var(--gr-aqua-glow));
-}
-.kg-node text {
-	fill: var(--gr-text);
-	font-family: var(--font-sans);
-	font-size: 11.5px;
-	font-weight: 600;
-	pointer-events: none;
-	user-select: none;
-}
-.kg-edge line {
-	stroke: var(--gr-border);
-	stroke-width: 1;
-}
-.kg-edge.hover line {
-	stroke: var(--gr-aqua);
-	stroke-width: 1.6;
-}
-.kg-edge text {
-	fill: var(--gr-text-muted);
-	font-family: var(--font-mono);
-	font-size: 9.5px;
-	pointer-events: none;
-	user-select: none;
-}
-
-/* ── Explain chain (chapter 3) ────────────────────────────────── */
-.explain-chain {
-	background: var(--gr-surface);
-	border: 1px solid var(--gr-border-subtle);
-	border-radius: 8px;
-	padding: 0.85rem 1rem;
-	font-family: var(--font-mono);
-	font-size: 12px;
-	color: var(--gr-text-muted);
-	white-space: pre-wrap;
-	max-height: 14em;
-	overflow: auto;
-}
-.explain-chain strong {
-	color: var(--gr-aqua);
-}
-.explain-chain .step {
-	padding: 0.15rem 0;
-}
-
-/* ── Guard violations (chapter 4) ─────────────────────────────── */
-.guard-banner {
-	background: var(--gr-surface);
-	border: 1px solid var(--gr-border-subtle);
-	border-radius: 8px;
-	padding: 0.85rem 1rem;
-	font-size: 12.5px;
-	color: var(--gr-text);
-	display: flex;
-	flex-direction: column;
-	gap: 0.5rem;
-}
-.guard-banner.denied {
-	border-color: var(--gr-danger);
-}
-.guard-banner code {
-	color: var(--gr-aqua);
-}
-.guard-banner .denied-reason {
-	color: var(--gr-danger);
-	font-family: var(--font-mono);
-	font-size: 12px;
-}
-
-/* ── Baseline note ─────────────────────────────────────────────── */
-.baseline-note {
-	background: var(--gr-surface);
-	border: 1px dashed var(--gr-border);
-	border-radius: 8px;
-	padding: 0.75rem 1rem;
-	font-size: 12.5px;
-	color: var(--gr-text-muted);
-}
-.baseline-note strong {
-	color: var(--gr-warn);
-}
diff --git a/demos/knowledge-graph/src/types/dom-chromium-ai.d.ts b/demos/knowledge-graph/src/types/dom-chromium-ai.d.ts
deleted file mode 100644
index a94e93f1..00000000
--- a/demos/knowledge-graph/src/types/dom-chromium-ai.d.ts
+++ /dev/null
@@ -1,82 +0,0 @@
-// Minimal ambient declarations for Chrome's built-in Prompt API
-// (https://developer.chrome.com/docs/ai/prompt-api). Hand-rolled so the demo
-// doesn't pull a third-party @types package.
-
-export {};
-
-declare global {
-	interface Window {
-		LanguageModel?: typeof LanguageModel;
-	}
-
-	type LanguageModelAvailability =
-		| "available"
-		| "readily"
-		| "after-download"
-		| "downloading"
-		| "downloadable"
-		| "unavailable";
-
-	interface LanguageModelMessage {
-		role: "system" | "user" | "assistant";
-		content: string;
-	}
-
-	interface LanguageModelExpectedIO {
-		type: "text";
-		languages?: readonly string[];
-	}
-
-	interface LanguageModelDownloadProgressEvent extends Event {
-		readonly loaded: number;
-	}
-
-	interface LanguageModelDownloadMonitor extends EventTarget {
-		addEventListener(
-			type: "downloadprogress",
-			listener: (e: LanguageModelDownloadProgressEvent) => void,
-		): void;
-	}
-
-	interface LanguageModelCreateOptions {
-		temperature?: number;
-		topK?: number;
-		signal?: AbortSignal;
-		initialPrompts?: readonly LanguageModelMessage[];
-		expectedInputs?: readonly LanguageModelExpectedIO[];
-		expectedOutputs?: readonly LanguageModelExpectedIO[];
-		monitor?: (m: LanguageModelDownloadMonitor) => void;
-	}
-
-	interface LanguageModelPromptOptions {
-		signal?: AbortSignal;
-		// JSON Schema (or RegExp) constraint on the response.
-		responseConstraint?: unknown;
-		omitResponseConstraintInput?: boolean;
-	}
-
-	interface LanguageModelSession {
-		readonly contextWindow: number;
-		readonly contextUsage: number;
-		prompt(
-			input: string | readonly LanguageModelMessage[],
-			options?: LanguageModelPromptOptions,
-		): Promise<string>;
-		promptStreaming(
-			input: string | readonly LanguageModelMessage[],
-			options?: LanguageModelPromptOptions,
-		): ReadableStream<string>;
-		append(messages: readonly LanguageModelMessage[]): Promise<void>;
-		clone(options?: { signal?: AbortSignal }): Promise<LanguageModelSession>;
-		destroy(): void;
-		addEventListener(type: "contextoverflow", listener: (e: Event) => void): void;
-	}
-
-	const LanguageModel: {
-		availability(opts?: {
-			expectedInputs?: readonly LanguageModelExpectedIO[];
-			expectedOutputs?: readonly LanguageModelExpectedIO[];
-		}): Promise<LanguageModelAvailability>;
-		create(opts?: LanguageModelCreateOptions): Promise<LanguageModelSession>;
-	};
-}
diff --git a/demos/knowledge-graph/tsconfig.json b/demos/knowledge-graph/tsconfig.json
deleted file mode 100644
index b0c60a12..00000000
--- a/demos/knowledge-graph/tsconfig.json
+++ /dev/null
@@ -1,8 +0,0 @@
-{
-	"extends": "astro/tsconfigs/strict",
-	"compilerOptions": {
-		"jsx": "react-jsx",
-		"jsxImportSource": "react",
-		"types": ["./src/types/dom-chromium-ai.d.ts"]
-	}
-}
diff --git a/demos/pagerduty-triage/.astro/content-assets.mjs b/demos/pagerduty-triage/.astro/content-assets.mjs
deleted file mode 100644
index 2b8b8234..00000000
--- a/demos/pagerduty-triage/.astro/content-assets.mjs
+++ /dev/null
@@ -1 +0,0 @@
-export default new Map();
\ No newline at end of file
diff --git a/demos/pagerduty-triage/.astro/content-modules.mjs b/demos/pagerduty-triage/.astro/content-modules.mjs
deleted file mode 100644
index 2b8b8234..00000000
--- a/demos/pagerduty-triage/.astro/content-modules.mjs
+++ /dev/null
@@ -1 +0,0 @@
-export default new Map();
\ No newline at end of file
diff --git a/demos/pagerduty-triage/.astro/content.d.ts b/demos/pagerduty-triage/.astro/content.d.ts
deleted file mode 100644
index c0082cc8..00000000
--- a/demos/pagerduty-triage/.astro/content.d.ts
+++ /dev/null
@@ -1,199 +0,0 @@
-declare module 'astro:content' {
-	export interface RenderResult {
-		Content: import('astro/runtime/server/index.js').AstroComponentFactory;
-		headings: import('astro').MarkdownHeading[];
-		remarkPluginFrontmatter: Record<string, any>;
-	}
-	interface Render {
-		'.md': Promise<RenderResult>;
-	}
-
-	export interface RenderedContent {
-		html: string;
-		metadata?: {
-			imagePaths: Array<string>;
-			[key: string]: unknown;
-		};
-	}
-}
-
-declare module 'astro:content' {
-	type Flatten<T> = T extends { [K: string]: infer U } ? U : never;
-
-	export type CollectionKey = keyof AnyEntryMap;
-	export type CollectionEntry<C extends CollectionKey> = Flatten<AnyEntryMap[C]>;
-
-	export type ContentCollectionKey = keyof ContentEntryMap;
-	export type DataCollectionKey = keyof DataEntryMap;
-
-	type AllValuesOf<T> = T extends any ? T[keyof T] : never;
-	type ValidContentEntrySlug<C extends keyof ContentEntryMap> = AllValuesOf<
-		ContentEntryMap[C]
-	>['slug'];
-
-	export type ReferenceDataEntry<
-		C extends CollectionKey,
-		E extends keyof DataEntryMap[C] = string,
-	> = {
-		collection: C;
-		id: E;
-	};
-	export type ReferenceContentEntry<
-		C extends keyof ContentEntryMap,
-		E extends ValidContentEntrySlug<C> | (string & {}) = string,
-	> = {
-		collection: C;
-		slug: E;
-	};
-	export type ReferenceLiveEntry<C extends keyof LiveContentConfig['collections']> = {
-		collection: C;
-		id: string;
-	};
-
-	/** @deprecated Use `getEntry` instead. */
-	export function getEntryBySlug<
-		C extends keyof ContentEntryMap,
-		E extends ValidContentEntrySlug<C> | (string & {}),
-	>(
-		collection: C,
-		// Note that this has to accept a regular string too, for SSR
-		entrySlug: E,
-	): E extends ValidContentEntrySlug<C>
-		? Promise<CollectionEntry<C>>
-		: Promise<CollectionEntry<C> | undefined>;
-
-	/** @deprecated Use `getEntry` instead. */
-	export function getDataEntryById<C extends keyof DataEntryMap, E extends keyof DataEntryMap[C]>(
-		collection: C,
-		entryId: E,
-	): Promise<CollectionEntry<C>>;
-
-	export function getCollection<C extends keyof AnyEntryMap, E extends CollectionEntry<C>>(
-		collection: C,
-		filter?: (entry: CollectionEntry<C>) => entry is E,
-	): Promise<E[]>;
-	export function getCollection<C extends keyof AnyEntryMap>(
-		collection: C,
-		filter?: (entry: CollectionEntry<C>) => unknown,
-	): Promise<CollectionEntry<C>[]>;
-
-	export function getLiveCollection<C extends keyof LiveContentConfig['collections']>(
-		collection: C,
-		filter?: LiveLoaderCollectionFilterType<C>,
-	): Promise<
-		import('astro').LiveDataCollectionResult<LiveLoaderDataType<C>, LiveLoaderErrorType<C>>
-	>;
-
-	export function getEntry<
-		C extends keyof ContentEntryMap,
-		E extends ValidContentEntrySlug<C> | (string & {}),
-	>(
-		entry: ReferenceContentEntry<C, E>,
-	): E extends ValidContentEntrySlug<C>
-		? Promise<CollectionEntry<C>>
-		: Promise<CollectionEntry<C> | undefined>;
-	export function getEntry<
-		C extends keyof DataEntryMap,
-		E extends keyof DataEntryMap[C] | (string & {}),
-	>(
-		entry: ReferenceDataEntry<C, E>,
-	): E extends keyof DataEntryMap[C]
-		? Promise<DataEntryMap[C][E]>
-		: Promise<CollectionEntry<C> | undefined>;
-	export function getEntry<
-		C extends keyof ContentEntryMap,
-		E extends ValidContentEntrySlug<C> | (string & {}),
-	>(
-		collection: C,
-		slug: E,
-	): E extends ValidContentEntrySlug<C>
-		? Promise<CollectionEntry<C>>
-		: Promise<CollectionEntry<C> | undefined>;
-	export function getEntry<
-		C extends keyof DataEntryMap,
-		E extends keyof DataEntryMap[C] | (string & {}),
-	>(
-		collection: C,
-		id: E,
-	): E extends keyof DataEntryMap[C]
-		? string extends keyof DataEntryMap[C]
-			? Promise<DataEntryMap[C][E]> | undefined
-			: Promise<DataEntryMap[C][E]>
-		: Promise<CollectionEntry<C> | undefined>;
-	export function getLiveEntry<C extends keyof LiveContentConfig['collections']>(
-		collection: C,
-		filter: string | LiveLoaderEntryFilterType<C>,
-	): Promise<import('astro').LiveDataEntryResult<LiveLoaderDataType<C>, LiveLoaderErrorType<C>>>;
-
-	/** Resolve an array of entry references from the same collection */
-	export function getEntries<C extends keyof ContentEntryMap>(
-		entries: ReferenceContentEntry<C, ValidContentEntrySlug<C>>[],
-	): Promise<CollectionEntry<C>[]>;
-	export function getEntries<C extends keyof DataEntryMap>(
-		entries: ReferenceDataEntry<C, keyof DataEntryMap[C]>[],
-	): Promise<CollectionEntry<C>[]>;
-
-	export function render<C extends keyof AnyEntryMap>(
-		entry: AnyEntryMap[C][string],
-	): Promise<RenderResult>;
-
-	export function reference<C extends keyof AnyEntryMap>(
-		collection: C,
-	): import('astro/zod').ZodEffects<
-		import('astro/zod').ZodString,
-		C extends keyof ContentEntryMap
-			? ReferenceContentEntry<C, ValidContentEntrySlug<C>>
-			: ReferenceDataEntry<C, keyof DataEntryMap[C]>
-	>;
-	// Allow generic `string` to avoid excessive type errors in the config
-	// if `dev` is not running to update as you edit.
-	// Invalid collection names will be caught at build time.
-	export function reference<C extends string>(
-		collection: C,
-	): import('astro/zod').ZodEffects<import('astro/zod').ZodString, never>;
-
-	type ReturnTypeOrOriginal<T> = T extends (...args: any[]) => infer R ? R : T;
-	type InferEntrySchema<C extends keyof AnyEntryMap> = import('astro/zod').infer<
-		ReturnTypeOrOriginal<Required<ContentConfig['collections'][C]>['schema']>
-	>;
-
-	type ContentEntryMap = {
-		
-	};
-
-	type DataEntryMap = {
-		
-	};
-
-	type AnyEntryMap = ContentEntryMap & DataEntryMap;
-
-	type ExtractLoaderTypes<T> = T extends import('astro/loaders').LiveLoader<
-		infer TData,
-		infer TEntryFilter,
-		infer TCollectionFilter,
-		infer TError
-	>
-		? { data: TData; entryFilter: TEntryFilter; collectionFilter: TCollectionFilter; error: TError }
-		: { data: never; entryFilter: never; collectionFilter: never; error: never };
-	type ExtractDataType<T> = ExtractLoaderTypes<T>['data'];
-	type ExtractEntryFilterType<T> = ExtractLoaderTypes<T>['entryFilter'];
-	type ExtractCollectionFilterType<T> = ExtractLoaderTypes<T>['collectionFilter'];
-	type ExtractErrorType<T> = ExtractLoaderTypes<T>['error'];
-
-	type LiveLoaderDataType<C extends keyof LiveContentConfig['collections']> =
-		LiveContentConfig['collections'][C]['schema'] extends undefined
-			? ExtractDataType<LiveContentConfig['collections'][C]['loader']>
-			: import('astro/zod').infer<
-					Exclude<LiveContentConfig['collections'][C]['schema'], undefined>
-				>;
-	type LiveLoaderEntryFilterType<C extends keyof LiveContentConfig['collections']> =
-		ExtractEntryFilterType<LiveContentConfig['collections'][C]['loader']>;
-	type LiveLoaderCollectionFilterType<C extends keyof LiveContentConfig['collections']> =
-		ExtractCollectionFilterType<LiveContentConfig['collections'][C]['loader']>;
-	type LiveLoaderErrorType<C extends keyof LiveContentConfig['collections']> = ExtractErrorType<
-		LiveContentConfig['collections'][C]['loader']
-	>;
-
-	export type ContentConfig = typeof import("../src/content.config.mjs");
-	export type LiveContentConfig = never;
-}
diff --git a/demos/pagerduty-triage/.astro/data-store.json b/demos/pagerduty-triage/.astro/data-store.json
deleted file mode 100644
index 1d5a78ed..00000000
--- a/demos/pagerduty-triage/.astro/data-store.json
+++ /dev/null
@@ -1 +0,0 @@
-[["Map",1,2],"meta::meta",["Map",3,4,5,6],"astro-version","5.18.1","astro-config-digest","{\"root\":{},\"srcDir\":{},\"publicDir\":{},\"outDir\":{},\"cacheDir\":{},\"site\":\"https://example.invalid\",\"compressHTML\":true,\"base\":\"/demos/pagerduty-triage/\",\"trailingSlash\":\"ignore\",\"output\":\"static\",\"scopedStyleStrategy\":\"attribute\",\"build\":{\"format\":\"directory\",\"client\":{},\"server\":{},\"assets\":\"_astro\",\"serverEntry\":\"entry.mjs\",\"redirects\":true,\"inlineStylesheets\":\"auto\",\"concurrency\":1},\"server\":{\"open\":false,\"host\":false,\"port\":4325,\"streaming\":true,\"allowedHosts\":[]},\"redirects\":{},\"image\":{\"endpoint\":{\"route\":\"/_image\"},\"service\":{\"entrypoint\":\"astro/assets/services/sharp\",\"config\":{}},\"domains\":[],\"remotePatterns\":[],\"responsiveStyles\":false},\"devToolbar\":{\"enabled\":true},\"markdown\":{\"syntaxHighlight\":{\"type\":\"shiki\",\"excludeLangs\":[\"math\"]},\"shikiConfig\":{\"langs\":[],\"langAlias\":{},\"theme\":\"github-dark\",\"themes\":{},\"wrap\":false,\"transformers\":[]},\"remarkPlugins\":[],\"rehypePlugins\":[],\"remarkRehype\":{},\"gfm\":true,\"smartypants\":true},\"security\":{\"checkOrigin\":true,\"allowedDomains\":[],\"actionBodySizeLimit\":1048576},\"env\":{\"schema\":{},\"validateSecrets\":false},\"experimental\":{\"clientPrerender\":false,\"contentIntellisense\":false,\"headingIdCompat\":false,\"preserveScriptOrder\":false,\"liveContentCollections\":false,\"csp\":false,\"staticImportMetaEnv\":false,\"chromeDevtoolsWorkspace\":false,\"failOnPrerenderConflict\":false,\"svgo\":false},\"legacy\":{\"collections\":false}}"]
\ No newline at end of file
diff --git a/demos/pagerduty-triage/.astro/settings.json b/demos/pagerduty-triage/.astro/settings.json
deleted file mode 100644
index ef9812c9..00000000
--- a/demos/pagerduty-triage/.astro/settings.json
+++ /dev/null
@@ -1,5 +0,0 @@
-{
-	"_variables": {
-		"lastUpdateCheck": 1776915547666
-	}
-}
\ No newline at end of file
diff --git a/demos/pagerduty-triage/.astro/types.d.ts b/demos/pagerduty-triage/.astro/types.d.ts
deleted file mode 100644
index 03d7cc43..00000000
--- a/demos/pagerduty-triage/.astro/types.d.ts
+++ /dev/null
@@ -1,2 +0,0 @@
-/// <reference types="astro/client" />
-/// <reference path="content.d.ts" />
\ No newline at end of file
diff --git a/demos/pagerduty-triage/astro.config.mjs b/demos/pagerduty-triage/astro.config.mjs
deleted file mode 100644
index d029c251..00000000
--- a/demos/pagerduty-triage/astro.config.mjs
+++ /dev/null
@@ -1,21 +0,0 @@
-import react from "@astrojs/react";
-import { defineConfig } from "astro/config";
-
-export default defineConfig({
-	site: process.env.ASTRO_SITE_URL ?? "https://example.invalid",
-	base: "/demos/pagerduty-triage/",
-	server: { port: 4325 },
-	integrations: [react()],
-	vite: {
-		resolve: {
-			conditions: ["browser"],
-			dedupe: ["@graphrefly/pure-ts"],
-		},
-		build: {
-			rollupOptions: {
-				external: ["@mlc-ai/web-llm", /^node:/],
-			},
-		},
-		optimizeDeps: { exclude: ["@mlc-ai/web-llm", "@graphrefly/graphrefly"] },
-	},
-});
diff --git a/demos/pagerduty-triage/package.json b/demos/pagerduty-triage/package.json
deleted file mode 100644
index b1362145..00000000
--- a/demos/pagerduty-triage/package.json
+++ /dev/null
@@ -1,21 +0,0 @@
-{
-	"name": "@graphrefly/demo-pagerduty-triage",
-	"private": true,
-	"type": "module",
-	"scripts": {
-		"dev": "astro dev",
-		"build": "astro build",
-		"preview": "astro preview"
-	},
-	"dependencies": {
-		"@graphrefly/graphrefly": "workspace:*",
-		"@graphrefly/pure-ts": "workspace:*",
-		"@astrojs/react": "^4.0.0",
-		"@types/react": "^19.0.0",
-		"@types/react-dom": "^19.0.0",
-		"astro": "^5.16.0",
-		"mermaid": "^11.4.1",
-		"react": "^19.0.0",
-		"react-dom": "^19.0.0"
-	}
-}
diff --git a/demos/pagerduty-triage/src/components/App.tsx b/demos/pagerduty-triage/src/components/App.tsx
deleted file mode 100644
index 3044ae35..00000000
--- a/demos/pagerduty-triage/src/components/App.tsx
+++ /dev/null
@@ -1,1075 +0,0 @@
-import type { DemoShellHandle } from "@graphrefly/graphrefly/utils/demo-shell";
-import { useCallback, useEffect, useMemo, useRef, useState } from "react";
-import { createAdapter, isChromeNanoAvailable } from "../lib/adapter-factory";
-import {
-	type Alert,
-	EMISSION_PHASES,
-	emissionDelayMs,
-	emissionPhaseLabel,
-	generateAlerts,
-} from "../lib/alerts";
-import {
-	AUTO_ESCALATE_AFTER_MS,
-	createTriagePipeline,
-	type QueuedAlert,
-	type TriageBins,
-	type TriagePipeline,
-} from "../lib/pipeline";
-import { getShell, setDemoGraph } from "../lib/shell";
-import type {
-	AdapterMode,
-	Disposition,
-	LearnedPattern,
-	TokenSnapshot,
-	TriageReason,
-} from "../lib/types";
-import { useNodeValue } from "../lib/use-node-value";
-import GraphPane from "./GraphPane";
-
-// ── Constants ───────────────────────────────────────────────────
-
-const TOTAL_TIME_MS = 5 * 60 * 1000;
-const ACTIONABLE_LIMIT = 8;
-
-// ── Severity color map ──────────────────────────────────────────
-
-const SEV_COLORS: Record<string, string> = {
-	critical: "var(--gr-danger)",
-	high: "#f0a060",
-	warning: "var(--gr-warn)",
-	low: "var(--gr-aqua-dim)",
-	info: "var(--gr-text-muted)",
-};
-
-// ── Stable fallback objects for useNodeValue ────────────────────
-// Module-level constants so the effect's `[node, fallback]` deps don't
-// change every render (which would re-subscribe on every tick).
-const EMPTY_QUEUE: readonly QueuedAlert[] = [];
-const EMPTY_BINS: TriageBins = {
-	actionable: [],
-	escalated: [],
-	resolved: [],
-	deferred: [],
-};
-const EMPTY_TOKENS: TokenSnapshot = {
-	inputTokens: 0,
-	outputTokens: 0,
-	cacheReadTokens: 0,
-	localCacheHits: 0,
-	calls: 0,
-};
-const EMPTY_PATTERNS: readonly LearnedPattern[] = [];
-
-// ── Types ───────────────────────────────────────────────────────
-
-type Phase = "setup" | "ready" | "running" | "finished";
-
-interface FocusedAlert {
-	readonly alert: Alert;
-	readonly brief: string;
-	readonly confidence: number;
-	readonly source: "queue" | "actionable";
-}
-
-// ── App ─────────────────────────────────────────────────────────
-
-export default function App() {
-	const shellRef = useRef<DemoShellHandle | null>(null);
-	const sidePaneRef = useRef<HTMLDivElement | null>(null);
-
-	// ── Phase / config ──────────────────────────────────────────
-	const [phase, setPhase] = useState<Phase>("setup");
-	const [paused, setPaused] = useState(false);
-	const [adapterMode, setAdapterMode] = useState<AdapterMode>("dry-run");
-	const [pipelineMode, setPipelineMode] = useState<"baseline" | "graphrefly">("graphrefly");
-	const [apiKey, setApiKey] = useState("");
-	const [baseUrl, setBaseUrl] = useState("https://api.openai.com/v1");
-	const [model, setModel] = useState("gpt-4o-mini");
-	const [nanoAvailable, setNanoAvailable] = useState(false);
-
-	// ── Alerts ──────────────────────────────────────────────────
-	const [alerts, setAlerts] = useState<readonly Alert[]>(() => generateAlerts());
-	const [alertIndex, setAlertIndex] = useState(0);
-
-	// ── Pipeline ────────────────────────────────────────────────
-	const pipelineRef = useRef<TriagePipeline | null>(null);
-
-	// ── Shell state ─────────────────────────────────────────────
-	const [mainRatio, setMainRatio] = useState(0.6);
-	const [graphRatio, setGraphRatio] = useState(0.38);
-	const [mermaidText, setMermaidText] = useState("");
-
-	// ── Run timing (refs so we don't re-render on every tick) ──
-	const runStartTsRef = useRef<number | null>(null);
-	const pauseStartTsRef = useRef<number | null>(null);
-	const totalPausedMsRef = useRef(0);
-	const alertIndexRef = useRef(0);
-	const lastEmitAtElapsedRef = useRef(Number.NEGATIVE_INFINITY);
-	const [timeLeft, setTimeLeft] = useState(TOTAL_TIME_MS);
-	const [currentPhaseLabel, setCurrentPhaseLabel] = useState(EMISSION_PHASES[0].label);
-
-	// ── Focus ───────────────────────────────────────────────────
-	const [focused, setFocused] = useState<FocusedAlert | null>(null);
-
-	// ── Reactive node values ────────────────────────────────────
-	const pipeline = pipelineRef.current;
-	const queue = useNodeValue<readonly QueuedAlert[]>(pipeline?.userQueue ?? null, EMPTY_QUEUE);
-	const bins = useNodeValue<TriageBins>(pipeline?.bins ?? null, EMPTY_BINS);
-	const tokens = useNodeValue<TokenSnapshot>(pipeline?.tokens ?? null, EMPTY_TOKENS);
-	const patterns = useNodeValue<readonly LearnedPattern[]>(
-		pipeline?.patterns ?? null,
-		EMPTY_PATTERNS,
-	);
-	const autoCount = useNodeValue<number>(pipeline?.autoCount ?? null, 0);
-
-	// ── Probe Chrome Nano on mount ──────────────────────────────
-	useEffect(() => {
-		setNanoAvailable(isChromeNanoAvailable());
-	}, []);
-
-	// ── Shell setup ─────────────────────────────────────────────
-	useEffect(() => {
-		const shell = getShell();
-		shellRef.current = shell;
-
-		const mermaidNode = shell.graph.resolve("graph/mermaid");
-		const u1 = mermaidNode.subscribe(() => {
-			setMermaidText((mermaidNode.cache as string) ?? "");
-		});
-
-		const onResize = () => shell.setViewportWidth(window.innerWidth);
-		window.addEventListener("resize", onResize);
-
-		return () => {
-			u1();
-			window.removeEventListener("resize", onResize);
-		};
-	}, []);
-
-	// ── Tick driver (clock + emissions, one interval) ──────────
-	useEffect(() => {
-		if (phase !== "running") return;
-		const tick = () => {
-			const start = runStartTsRef.current;
-			if (start == null) return;
-			const pausedNow = pauseStartTsRef.current !== null ? Date.now() - pauseStartTsRef.current : 0;
-			const elapsed = Math.max(0, Date.now() - start - totalPausedMsRef.current - pausedNow);
-			const remaining = Math.max(0, TOTAL_TIME_MS - elapsed);
-			setTimeLeft(remaining);
-			setCurrentPhaseLabel(emissionPhaseLabel(elapsed));
-
-			if (remaining <= 0) {
-				setPhase("finished");
-				return;
-			}
-
-			// Skip emissions while paused (clock already frozen via pausedNow).
-			if (pauseStartTsRef.current !== null) return;
-
-			if (alertIndexRef.current < alerts.length) {
-				const lastEmit = lastEmitAtElapsedRef.current;
-				const nextDelay = emissionDelayMs(elapsed);
-				if (elapsed - lastEmit >= nextDelay) {
-					pipelineRef.current?.pushAlert(alerts[alertIndexRef.current]!);
-					lastEmitAtElapsedRef.current = elapsed;
-					alertIndexRef.current += 1;
-					setAlertIndex(alertIndexRef.current);
-				}
-			}
-		};
-		tick(); // immediate first emission so a ticket arrives right away
-		const id = setInterval(tick, 200);
-		return () => clearInterval(id);
-	}, [phase, alerts]);
-
-	// ── Auto-focus: on start / after triage, focus first queue item ─
-	useEffect(() => {
-		if (phase !== "running") return;
-		if (focused?.source === "queue") {
-			const still = queue.find((q) => q.alert.id === focused.alert.id);
-			if (!still) {
-				if (queue.length > 0) {
-					const q = queue[0]!;
-					setFocused({
-						alert: q.alert,
-						brief: q.brief,
-						confidence: q.confidence,
-						source: "queue",
-					});
-				} else {
-					setFocused(null);
-				}
-				return;
-			}
-		}
-		if (!focused && queue.length > 0) {
-			const q = queue[0]!;
-			setFocused({
-				alert: q.alert,
-				brief: q.brief,
-				confidence: q.confidence,
-				source: "queue",
-			});
-		}
-	}, [phase, focused, queue]);
-
-	// ── Setup → Ready: build pipeline ───────────────────────────
-	const goToReady = useCallback(() => {
-		pipelineRef.current?.destroy();
-
-		const adapter = createAdapter({
-			mode: adapterMode,
-			apiKey: adapterMode === "byok" ? apiKey : undefined,
-			baseUrl: adapterMode === "byok" ? baseUrl : undefined,
-			model: adapterMode === "byok" ? model : undefined,
-		});
-
-		const p = createTriagePipeline({ adapter, mode: pipelineMode });
-		pipelineRef.current = p;
-		if (shellRef.current) setDemoGraph(shellRef.current, p.graph);
-
-		runStartTsRef.current = null;
-		pauseStartTsRef.current = null;
-		totalPausedMsRef.current = 0;
-		alertIndexRef.current = 0;
-		lastEmitAtElapsedRef.current = Number.NEGATIVE_INFINITY;
-		setAlertIndex(0);
-		setTimeLeft(TOTAL_TIME_MS);
-		setFocused(null);
-		setPaused(false);
-		setCurrentPhaseLabel(EMISSION_PHASES[0].label);
-		setPhase("ready");
-	}, [adapterMode, pipelineMode, apiKey, baseUrl, model]);
-
-	// ── Ready → Running: begin clock + emissions ────────────────
-	const startRun = useCallback(() => {
-		if (!pipelineRef.current) return;
-		runStartTsRef.current = Date.now();
-		totalPausedMsRef.current = 0;
-		pauseStartTsRef.current = null;
-		alertIndexRef.current = 0;
-		lastEmitAtElapsedRef.current = Number.NEGATIVE_INFINITY;
-		setAlertIndex(0);
-		setPaused(false);
-		setTimeLeft(TOTAL_TIME_MS);
-		setFocused(null);
-		setPhase("running");
-	}, []);
-
-	// ── Pause / Resume ──────────────────────────────────────────
-	const togglePause = useCallback(() => {
-		if (phase !== "running") return;
-		setPaused((prev) => {
-			const next = !prev;
-			if (next) {
-				pauseStartTsRef.current = Date.now();
-			} else if (pauseStartTsRef.current !== null) {
-				totalPausedMsRef.current += Date.now() - pauseStartTsRef.current;
-				pauseStartTsRef.current = null;
-			}
-			return next;
-		});
-	}, [phase]);
-
-	// ── Back to config ──────────────────────────────────────────
-	const backToSetup = useCallback(() => {
-		pipelineRef.current?.destroy();
-		pipelineRef.current = null;
-		setPhase("setup");
-		setPaused(false);
-		setFocused(null);
-		setAlertIndex(0);
-	}, []);
-
-	// ── Randomize alerts ────────────────────────────────────────
-	const randomize = useCallback(() => {
-		setAlerts(generateAlerts({ seed: Date.now() }));
-	}, []);
-
-	// ── Decision ────────────────────────────────────────────────
-	const handleDecision = useCallback(
-		(disposition: Disposition, deferMs?: number) => {
-			if (paused) return;
-			if (!focused) return;
-			const p = pipelineRef.current;
-			if (!p) return;
-			if (focused.source === "queue") {
-				p.recordDecision(focused.alert.id, disposition, deferMs);
-				setFocused(null);
-			} else {
-				// Re-triage from the Actionable bin into another disposition.
-				// "actionable" is a no-op and should be disabled in the UI, but
-				// guard here too for safety.
-				if (disposition === "actionable") return;
-				p.retriageActionable(focused.alert.id, disposition, deferMs);
-				setFocused(null);
-			}
-		},
-		[focused, paused],
-	);
-
-	// ── Click queue-count summary ───────────────────────────────
-	const focusFirstQueue = useCallback(() => {
-		if (paused) return;
-		if (queue.length === 0) return;
-		const q = queue[0]!;
-		setFocused({
-			alert: q.alert,
-			brief: q.brief,
-			confidence: q.confidence,
-			source: "queue",
-		});
-	}, [queue, paused]);
-
-	// ── Click actionable bin card — toggle focus ────────────────
-	const handleActionableClick = useCallback(
-		(item: { alert: Alert; brief: string; confidence: number }) => {
-			if (paused) return;
-			if (focused?.source === "actionable" && focused.alert.id === item.alert.id) {
-				// Toggle off → fall back to first queue item.
-				if (queue.length > 0) {
-					const q = queue[0]!;
-					setFocused({
-						alert: q.alert,
-						brief: q.brief,
-						confidence: q.confidence,
-						source: "queue",
-					});
-				} else {
-					setFocused(null);
-				}
-				return;
-			}
-			setFocused({
-				alert: item.alert,
-				brief: item.brief,
-				confidence: item.confidence,
-				source: "actionable",
-			});
-		},
-		[focused, queue, paused],
-	);
-
-	// ── Drag handlers ───────────────────────────────────────────
-	const activeDragHandlers = useRef<{
-		move: (e: MouseEvent) => void;
-		up: () => void;
-	} | null>(null);
-
-	useEffect(() => {
-		return () => {
-			if (activeDragHandlers.current) {
-				window.removeEventListener("mousemove", activeDragHandlers.current.move);
-				window.removeEventListener("mouseup", activeDragHandlers.current.up);
-				document.body.style.cursor = "";
-				document.body.style.userSelect = "";
-			}
-		};
-	}, []);
-
-	const beginDrag = useCallback(
-		(cursor: "col-resize" | "row-resize", onMove: (e: MouseEvent) => void) => {
-			document.body.style.cursor = cursor;
-			document.body.style.userSelect = "none";
-			const move = (ev: MouseEvent) => onMove(ev);
-			const up = () => {
-				document.body.style.cursor = "";
-				document.body.style.userSelect = "";
-				window.removeEventListener("mousemove", move);
-				window.removeEventListener("mouseup", up);
-				activeDragHandlers.current = null;
-			};
-			activeDragHandlers.current = { move, up };
-			window.addEventListener("mousemove", move);
-			window.addEventListener("mouseup", up);
-		},
-		[],
-	);
-
-	const onMainDividerDown = useCallback(
-		(e: React.MouseEvent) => {
-			e.preventDefault();
-			beginDrag("col-resize", (ev) => {
-				const ratio = Math.max(0.25, Math.min(0.8, ev.clientX / window.innerWidth));
-				setMainRatio(ratio);
-				shellRef.current?.setMainRatio(ratio);
-			});
-		},
-		[beginDrag],
-	);
-
-	const onSplitDividerDown = useCallback(
-		(e: React.MouseEvent) => {
-			e.preventDefault();
-			beginDrag("row-resize", (ev) => {
-				if (!sidePaneRef.current) return;
-				const rect = sidePaneRef.current.getBoundingClientRect();
-				const ratio = Math.max(0.15, Math.min(0.85, (ev.clientY - rect.top) / rect.height));
-				setGraphRatio(ratio);
-				shellRef.current?.setSideSplit(ratio);
-			});
-		},
-		[beginDrag],
-	);
-
-	// ── Cleanup on unmount ──────────────────────────────────────
-	useEffect(() => {
-		return () => {
-			pipelineRef.current?.destroy();
-		};
-	}, []);
-
-	// ── Helpers ─────────────────────────────────────────────────
-	const fmtTime = (ms: number) => {
-		const s = Math.ceil(ms / 1000);
-		return `${Math.floor(s / 60)}:${String(s % 60).padStart(2, "0")}`;
-	};
-
-	const mainWidthPct = `${Math.round(mainRatio * 100)}%`;
-	const sideWidthPct = `${Math.round((1 - mainRatio) * 100)}%`;
-
-	const queueIsHighlighted = useMemo(
-		() => focused?.source === "queue" && queue.some((q) => q.alert.id === focused.alert.id),
-		[focused, queue],
-	);
-
-	// ── Setup (config) screen ───────────────────────────────────
-	if (phase === "setup") {
-		return (
-			<div className="app">
-				<div className="setup-screen">
-					<h2>PagerDuty Triage Demo</h2>
-					<p className="setup-desc">
-						You're the on-call SRE for the next <strong>5 minutes</strong>. Alerts stream in at an
-						accelerating pace — your job is to push each one to the right bin before the queue backs
-						up.
-					</p>
-
-					<div className="setup-info">
-						<h3>The rules</h3>
-						<ul>
-							<li>
-								<strong>Each alert is pre-classified by an LLM.</strong> High-confidence (≥80%)
-								alerts auto-route to the right bin. Low-confidence alerts land in your{" "}
-								<strong>queue</strong> for you to decide.
-							</li>
-							<li>
-								<strong>Five actions per alert</strong> &mdash; Actionable · Escalate · Resolve ·
-								Defer 30s · Defer 1m. Defer re-queues the alert after the delay.
-							</li>
-							<li>
-								<strong>
-									Queue alerts auto-escalate after {Math.round(AUTO_ESCALATE_AFTER_MS / 1000)}{" "}
-									seconds
-								</strong>{" "}
-								if you ignore them &mdash; simulates pager fatigue. Clear your queue or pay the
-								price.
-							</li>
-							<li>
-								<strong>Pause button</strong> freezes the clock, alert intake, and all actions. Use
-								it to read the graph or catch your breath.
-							</li>
-						</ul>
-
-						<h3>Intake tempo</h3>
-						<ul className="tempo-list">
-							<li>
-								<span className="tempo-range">0:00 &rarr; 1:00</span>
-								<span className="tempo-rate">one alert every 30s</span>{" "}
-								<span className="tempo-note">calm &mdash; read carefully</span>
-							</li>
-							<li>
-								<span className="tempo-range">1:00 &rarr; 2:00</span>
-								<span className="tempo-rate">one alert every 20s</span>{" "}
-								<span className="tempo-note">steady</span>
-							</li>
-							<li>
-								<span className="tempo-range">2:00 &rarr; 3:00</span>
-								<span className="tempo-rate">one alert every 15s</span>{" "}
-								<span className="tempo-note">elevated</span>
-							</li>
-							<li>
-								<span className="tempo-range">3:00 &rarr; 4:50</span>
-								<span className="tempo-rate">one alert every 10s</span>{" "}
-								<span className="tempo-note">pressured</span>
-							</li>
-							<li>
-								<span className="tempo-range">4:50 &rarr; 5:00</span>
-								<span className="tempo-rate">burst &mdash; ~1/sec</span>{" "}
-								<span className="tempo-note">chaos finale</span>
-							</li>
-						</ul>
-
-						<h3>Scoring priority (highest first)</h3>
-						<ol>
-							<li>
-								<strong>Resolve</strong> benign noise &mdash; you kept the signal clean.
-							</li>
-							<li>
-								<strong>Avoid escalating</strong> unless it's truly senior-on-call material.
-							</li>
-							<li>
-								<strong>Defer</strong> buys time, but the alert comes back.
-							</li>
-							<li>
-								<strong>Actionable</strong> means "I'm on it" &mdash; use it sparingly; it piles up
-								work.
-							</li>
-						</ol>
-					</div>
-
-					<div className="setup-section">
-						<h3>Pipeline Mode</h3>
-						<div className="mode-buttons">
-							<button
-								type="button"
-								className={pipelineMode === "baseline" ? "active" : ""}
-								onClick={() => setPipelineMode("baseline")}
-							>
-								Baseline
-							</button>
-							<button
-								type="button"
-								className={pipelineMode === "graphrefly" ? "active" : ""}
-								onClick={() => setPipelineMode("graphrefly")}
-							>
-								GraphReFly
-							</button>
-						</div>
-						<p className="mode-hint">
-							{pipelineMode === "baseline" ? (
-								<>
-									<strong>Baseline</strong> &mdash; no learning. Every low-confidence alert lands in
-									your queue; you triage manually from start to finish.
-								</>
-							) : (
-								<>
-									<strong>GraphReFly</strong> &mdash; agentMemory extracts a pattern after 2&ndash;3
-									similar decisions and auto-classifies matching alerts with zero LLM cost (local
-									cache hit). Try both modes and compare <em>LLM Calls</em>, <em>Auto count</em>,
-									and how many alerts you manually handle.
-								</>
-							)}
-						</p>
-					</div>
-
-					<div className="setup-section">
-						<h3>LLM Adapter</h3>
-						<div className="mode-buttons">
-							<button
-								type="button"
-								className={adapterMode === "dry-run" ? "active" : ""}
-								onClick={() => setAdapterMode("dry-run")}
-							>
-								Dry Run
-							</button>
-							<button
-								type="button"
-								className={`${adapterMode === "chrome-nano" ? "active" : ""} ${!nanoAvailable ? "disabled" : ""}`}
-								onClick={() => nanoAvailable && setAdapterMode("chrome-nano")}
-								title={
-									nanoAvailable ? "Chrome Nano available" : "Chrome 138+ with Prompt API required"
-								}
-							>
-								Chrome Nano {!nanoAvailable && "(N/A)"}
-							</button>
-							<button
-								type="button"
-								className={adapterMode === "byok" ? "active" : ""}
-								onClick={() => setAdapterMode("byok")}
-							>
-								BYOK
-							</button>
-						</div>
-
-						{adapterMode === "dry-run" && (
-							<p className="mode-hint">
-								Mock responses &mdash; see the full graph topology and UX without needing an API
-								key.
-							</p>
-						)}
-						{adapterMode === "chrome-nano" && (
-							<p className="mode-hint">
-								On-device Gemini Nano &mdash; zero API cost, runs in your browser.
-							</p>
-						)}
-						{adapterMode === "byok" && (
-							<div className="byok-fields">
-								<p className="mode-hint">
-									Bring your own key &mdash; any OpenAI-compatible API. Look for free tier providers
-									online.
-								</p>
-								<input
-									type="password"
-									placeholder="API Key"
-									value={apiKey}
-									onChange={(e) => setApiKey(e.target.value)}
-								/>
-								<input
-									type="text"
-									placeholder="Base URL (default: https://api.openai.com/v1)"
-									value={baseUrl}
-									onChange={(e) => setBaseUrl(e.target.value)}
-								/>
-								<input
-									type="text"
-									placeholder="Model (default: gpt-4o-mini)"
-									value={model}
-									onChange={(e) => setModel(e.target.value)}
-								/>
-							</div>
-						)}
-					</div>
-
-					<div className="setup-actions">
-						<button type="button" className="btn-primary" onClick={goToReady}>
-							Continue &rarr;
-						</button>
-						<button type="button" className="btn-secondary" onClick={randomize}>
-							Randomize Alerts
-						</button>
-					</div>
-				</div>
-			</div>
-		);
-	}
-
-	// ── Running / Ready / Finished ──────────────────────────────
-	// Action buttons are available for both queue-sourced and actionable-sourced
-	// focuses. The Actionable button itself is additionally disabled when the
-	// focus is already in the Actionable bin (moving actionable→actionable is
-	// a no-op) — see `FocusPane` for the per-button check.
-	const actionsDisabled = !focused || paused || phase !== "running";
-	const actionableFull = bins.actionable.length >= ACTIONABLE_LIMIT;
-
-	return (
-		<div className="app">
-			<div className="demo-shell">
-				{/* Main pane: header + bins + tokens + patterns */}
-				<div className="pane-main" style={{ width: mainWidthPct, maxWidth: mainWidthPct }}>
-					<div className="triage-header">
-						<div className="timer" data-urgent={phase === "running" && timeLeft < 30_000}>
-							{fmtTime(timeLeft)}
-						</div>
-						<div className="header-stats">
-							<button
-								type="button"
-								className={`stat stat-btn${queueIsHighlighted ? " active" : ""}`}
-								onClick={focusFirstQueue}
-								disabled={queue.length === 0 || phase !== "running" || paused}
-								title="Click to focus the first ticket in queue"
-							>
-								<span className="stat-label">Queue</span>
-								<span className="stat-value warn">{queue.length}</span>
-							</button>
-							<span className="stat">
-								<span className="stat-label">Alerts</span>
-								<span className="stat-value">
-									{alertIndex}/{alerts.length}
-								</span>
-							</span>
-							{pipelineMode === "graphrefly" && (
-								<>
-									<span className="stat">
-										<span className="stat-label">Auto</span>
-										<span className="stat-value auto">{autoCount}</span>
-									</span>
-									<span className="stat">
-										<span className="stat-label">Patterns</span>
-										<span className="stat-value">{patterns.length}</span>
-									</span>
-								</>
-							)}
-							<span className="stat">
-								<span className="stat-label">Phase</span>
-								<span className="stat-value small">{currentPhaseLabel}</span>
-							</span>
-						</div>
-						<div className="header-controls">
-							{phase === "running" && (
-								<button
-									type="button"
-									className={`btn-pill${paused ? " resume" : " pause"}`}
-									onClick={togglePause}
-								>
-									{paused ? "Resume" : "Pause"}
-								</button>
-							)}
-							{phase === "ready" && (
-								<button type="button" className="btn-pill start" onClick={startRun}>
-									Start &rarr;
-								</button>
-							)}
-							<span className={`pill ${pipelineMode}`}>{pipelineMode}</span>
-							<span className="pill adapter">{adapterMode}</span>
-						</div>
-					</div>
-
-					{phase === "ready" && (
-						<div className="ready-banner">
-							<strong>Ready.</strong> Take a moment to explore the panels. The graph topology on the
-							right shows every node wired up. When you're ready, press{" "}
-							<button type="button" className="inline-btn" onClick={startRun}>
-								Start
-							</button>{" "}
-							to begin the 5-minute run &mdash; alerts will start flowing immediately.
-						</div>
-					)}
-
-					{paused && phase === "running" && (
-						<div className="pause-banner">
-							<strong>PAUSED.</strong> Clock and alert intake are frozen. Press{" "}
-							<button type="button" className="inline-btn" onClick={togglePause}>
-								Resume
-							</button>{" "}
-							to continue.
-						</div>
-					)}
-
-					{phase === "finished" && (
-						<div className="finished-banner">
-							<strong>Time's up!</strong> Review your bins below. Resolve count (highest-value),
-							Escalated count (cost), Auto count (GraphReFly savings), and LLM calls are the numbers
-							to compare between runs.
-							<button type="button" className="btn-secondary" onClick={backToSetup}>
-								Try again
-							</button>
-						</div>
-					)}
-
-					{/* Bins */}
-					<div className="bins-grid">
-						<BinColumn
-							title="Actionable"
-							items={bins.actionable}
-							color="var(--gr-danger)"
-							onSelect={handleActionableClick}
-							selectedId={focused?.source === "actionable" ? focused.alert.id : null}
-						/>
-						<BinColumn title="Escalated" items={bins.escalated} color="#f0a060" />
-						<BinColumn title="Resolved" items={bins.resolved} color="var(--gr-aqua)" />
-						<DeferredColumn items={bins.deferred} />
-					</div>
-
-					{/* Token usage */}
-					<div className="token-bar">
-						<h3>Token Usage</h3>
-						<div className="token-stats">
-							<span>
-								Input: <strong>{tokens.inputTokens.toLocaleString()}</strong>
-							</span>
-							<span>
-								Output: <strong>{tokens.outputTokens.toLocaleString()}</strong>
-							</span>
-							<span>
-								LLM Calls: <strong>{tokens.calls}</strong>
-							</span>
-							{pipelineMode === "graphrefly" && (
-								<span className="cache-hit">
-									Local Cache Hits: <strong>{tokens.localCacheHits}</strong>
-								</span>
-							)}
-						</div>
-					</div>
-
-					{pipelineMode === "graphrefly" && patterns.length > 0 && (
-						<div className="patterns-panel">
-							<h3>Learned Patterns</h3>
-							{patterns.map((p) => (
-								<div key={p.patternKey} className="pattern-row">
-									<code>{p.patternKey}</code>
-									<span className={`pill ${p.disposition}`}>{p.disposition}</span>
-									<span className="pattern-meta">
-										{p.sampleCount} samples · {Math.round(p.confidence * 100)}%
-									</span>
-								</div>
-							))}
-						</div>
-					)}
-				</div>
-
-				<div className="pane-divider" onMouseDown={onMainDividerDown} />
-
-				{/* Side pane: topology (top) + focus pane (bottom) */}
-				<div className="pane-side" ref={sidePaneRef} style={{ width: sideWidthPct }}>
-					<div className="pane-graph" style={{ height: `${graphRatio * 100}%` }}>
-						<h3>Graph topology — describe(graph) → mermaid</h3>
-						<GraphPane text={mermaidText} />
-					</div>
-					<div className="pane-split-divider" onMouseDown={onSplitDividerDown} />
-					<div className="pane-focus">
-						<h3>
-							Focused ticket
-							{focused && (
-								<span className={`focus-source ${focused.source}`}>
-									{focused.source === "queue" ? "from queue" : "already triaged"}
-								</span>
-							)}
-						</h3>
-						<FocusPane
-							focused={focused}
-							queue={queue}
-							phase={phase}
-							paused={paused}
-							actionsDisabled={actionsDisabled}
-							actionableFull={actionableFull}
-							onDecision={handleDecision}
-						/>
-					</div>
-				</div>
-			</div>
-		</div>
-	);
-}
-
-// ── Focus pane component ───────────────────────────────────────
-
-function FocusPane({
-	focused,
-	queue,
-	phase,
-	paused,
-	actionsDisabled,
-	actionableFull,
-	onDecision,
-}: {
-	focused: FocusedAlert | null;
-	queue: readonly QueuedAlert[];
-	phase: Phase;
-	paused: boolean;
-	actionsDisabled: boolean;
-	actionableFull: boolean;
-	onDecision: (d: Disposition, deferMs?: number) => void;
-}) {
-	if (!focused) {
-		return (
-			<div className="focus-empty">
-				{phase === "ready" && <p>Press Start above to begin. First queue ticket auto-focuses.</p>}
-				{phase === "running" && !paused && queue.length === 0 && (
-					<p>No tickets in queue. Relax&hellip; or audit the bins while you wait.</p>
-				)}
-				{phase === "running" && paused && <p>Paused &mdash; resume to continue.</p>}
-				{phase === "finished" && <p>Run complete. Review the bins in the left pane.</p>}
-			</div>
-		);
-	}
-	return (
-		<div className="focus-content">
-			<div className="focus-detail">
-				<div className="focus-ids">
-					<span className="focus-id">{focused.alert.id}</span>
-					<span className="severity-badge" style={{ color: SEV_COLORS[focused.alert.severity] }}>
-						{focused.alert.severity}
-					</span>
-					{focused.source === "actionable" && (
-						<span className="in-progress-badge">in-progress</span>
-					)}
-				</div>
-				<div className="focus-service">{focused.alert.service}</div>
-				<div className="focus-summary">{focused.alert.summary}</div>
-				<div className="focus-brief">
-					<span className="brief-label">LLM brief</span>
-					<span className="brief-text">{focused.brief}</span>
-					<span className="confidence">{Math.round(focused.confidence * 100)}% confidence</span>
-				</div>
-			</div>
-			<div className="focus-actions">
-				<button
-					type="button"
-					className="action-btn actionable"
-					onClick={() => onDecision("actionable")}
-					disabled={actionsDisabled || focused.source === "actionable" || actionableFull}
-					title={
-						focused.source === "actionable"
-							? "Alert is already in the Actionable bin"
-							: actionableFull
-								? `Actionable bin is full (${ACTIONABLE_LIMIT} max) — resolve or escalate some first`
-								: undefined
-					}
-				>
-					Actionable
-				</button>
-				<button
-					type="button"
-					className="action-btn escalated"
-					onClick={() => onDecision("escalated")}
-					disabled={actionsDisabled}
-				>
-					Escalate
-				</button>
-				<button
-					type="button"
-					className="action-btn resolved"
-					onClick={() => onDecision("resolved")}
-					disabled={actionsDisabled}
-				>
-					Resolve
-				</button>
-				<button
-					type="button"
-					className="action-btn deferred"
-					onClick={() => onDecision("deferred", 30_000)}
-					disabled={actionsDisabled}
-				>
-					Defer 30s
-				</button>
-				<button
-					type="button"
-					className="action-btn deferred"
-					onClick={() => onDecision("deferred", 60_000)}
-					disabled={actionsDisabled}
-				>
-					Defer 1m
-				</button>
-			</div>
-		</div>
-	);
-}
-
-// ── Bin card content (shared) ───────────────────────────────────
-
-const REASON_LABEL: Record<TriageReason, string> = {
-	pattern: "pattern",
-	"high-conf": "high-conf",
-	timeout: "timeout",
-	manual: "manual",
-};
-
-const REASON_TITLE: Record<TriageReason, string> = {
-	pattern: "Matched a learned pattern — no LLM call, bypassed focus",
-	"high-conf": "LLM returned disposition with ≥80% confidence — bypassed focus",
-	timeout: "Sat in queue past the auto-escalate threshold",
-	manual: "You triaged this from the focus pane",
-};
-
-function BinCardContent({
-	item,
-}: {
-	item: {
-		alert: Alert;
-		brief: string;
-		autoClassified: boolean;
-		confidence: number;
-		reason: TriageReason;
-	};
-}) {
-	return (
-		<>
-			<div className="card-top">
-				<span className="card-id">{item.alert.id}</span>
-				<span className="severity-dot" style={{ background: SEV_COLORS[item.alert.severity] }} />
-				<span className={`reason-badge reason-${item.reason}`} title={REASON_TITLE[item.reason]}>
-					{REASON_LABEL[item.reason]}
-					{item.reason !== "manual" && (
-						<span className="reason-conf"> · {Math.round(item.confidence * 100)}%</span>
-					)}
-				</span>
-			</div>
-			<div className="card-svc">{item.alert.service}</div>
-			<div className="card-brief">{item.brief}</div>
-		</>
-	);
-}
-
-// ── Bin column ─────────────────────────────────────────────────
-
-function BinColumn({
-	title,
-	items,
-	color,
-	onSelect,
-	selectedId,
-}: {
-	title: string;
-	items: readonly {
-		alert: Alert;
-		brief: string;
-		autoClassified: boolean;
-		confidence: number;
-		reason: TriageReason;
-	}[];
-	color: string;
-	onSelect?: (item: { alert: Alert; brief: string; confidence: number }) => void;
-	selectedId?: string | null;
-}) {
-	return (
-		<div className="bin-column">
-			<div className="bin-header" style={{ borderColor: color }}>
-				<span>{title}</span>
-				<span className="bin-count" style={{ color }}>
-					{items.length}
-				</span>
-			</div>
-			<div className="bin-scroll">
-				{items.map((item) =>
-					onSelect ? (
-						<button
-							type="button"
-							key={item.alert.id}
-							className={`bin-card${item.autoClassified ? " auto" : ""}${selectedId === item.alert.id ? " selected" : ""}`}
-							onClick={() =>
-								onSelect({
-									alert: item.alert,
-									brief: item.brief,
-									confidence: item.confidence,
-								})
-							}
-						>
-							<BinCardContent item={item} />
-						</button>
-					) : (
-						<div key={item.alert.id} className={`bin-card${item.autoClassified ? " auto" : ""}`}>
-							<BinCardContent item={item} />
-						</div>
-					),
-				)}
-			</div>
-		</div>
-	);
-}
-
-// ── Deferred column ────────────────────────────────────────────
-
-function DeferredColumn({
-	items,
-}: {
-	items: readonly {
-		alert: Alert;
-		brief: string;
-		autoClassified: boolean;
-		confidence: number;
-		reason: TriageReason;
-		retryAt: number;
-	}[];
-}) {
-	const [now, setNow] = useState(Date.now());
-	useEffect(() => {
-		if (items.length === 0) return;
-		const interval = setInterval(() => setNow(Date.now()), 1000);
-		return () => clearInterval(interval);
-	}, [items.length]);
-
-	return (
-		<div className="bin-column">
-			<div className="bin-header" style={{ borderColor: "var(--gr-warn)" }}>
-				<span>Deferred</span>
-				<span className="bin-count" style={{ color: "var(--gr-warn)" }}>
-					{items.length}
-				</span>
-			</div>
-			<div className="bin-scroll">
-				{items.map((item) => {
-					const remaining = Math.max(0, Math.ceil((item.retryAt - now) / 1000));
-					return (
-						<div key={item.alert.id} className={`bin-card${item.autoClassified ? " auto" : ""}`}>
-							<BinCardContent item={item} />
-							<div className="defer-timer">
-								{remaining > 0 ? `re-queue in ${remaining}s` : "re-queuing…"}
-							</div>
-						</div>
-					);
-				})}
-			</div>
-		</div>
-	);
-}
diff --git a/demos/pagerduty-triage/src/components/GraphPane.tsx b/demos/pagerduty-triage/src/components/GraphPane.tsx
deleted file mode 100644
index 0a78547d..00000000
--- a/demos/pagerduty-triage/src/components/GraphPane.tsx
+++ /dev/null
@@ -1,42 +0,0 @@
-import { useEffect, useRef } from "react";
-import { initMermaid, mermaid, nextMermaidId } from "../lib/mermaid-render";
-import { attachPanZoom } from "../lib/pan-zoom";
-
-export default function GraphPane({ text }: { text: string }) {
-	const containerRef = useRef<HTMLDivElement | null>(null);
-
-	useEffect(() => {
-		initMermaid();
-		const el = containerRef.current;
-		if (!el) return;
-		const detachPanZoom = attachPanZoom(el);
-		return () => detachPanZoom();
-	}, []);
-
-	useEffect(() => {
-		const el = containerRef.current;
-		if (!el) return;
-		if (!text) {
-			el.innerHTML = "";
-			return;
-		}
-		let cancelled = false;
-		mermaid
-			.render(nextMermaidId(), text)
-			.then(({ svg, bindFunctions }) => {
-				if (cancelled || !containerRef.current) return;
-				containerRef.current.innerHTML = svg;
-				bindFunctions?.(containerRef.current);
-			})
-			.catch((err) => {
-				if (cancelled || !containerRef.current) return;
-				console.warn("[GraphPane] mermaid render failed:", err);
-				containerRef.current.textContent = text;
-			});
-		return () => {
-			cancelled = true;
-		};
-	}, [text]);
-
-	return <div ref={containerRef} className="mermaid-graph" />;
-}
diff --git a/demos/pagerduty-triage/src/lib/adapter-factory.ts b/demos/pagerduty-triage/src/lib/adapter-factory.ts
deleted file mode 100644
index 430718eb..00000000
--- a/demos/pagerduty-triage/src/lib/adapter-factory.ts
+++ /dev/null
@@ -1,196 +0,0 @@
-// ── Adapter factory ─────────────────────────────────────────────
-// Creates the LLM adapter based on user selection.
-
-import type { ChatMessage, LLMAdapter, LLMResponse } from "@graphrefly/graphrefly/utils/ai";
-import { createDryRunAdapter } from "./dry-run-fixtures.js";
-import type { AdapterMode } from "./types.js";
-
-// ── Chrome Nano ─────────────────────────────────────────────────
-
-export function isChromeNanoAvailable(): boolean {
-	return typeof window !== "undefined" && typeof (window as Window).LanguageModel !== "undefined";
-}
-
-export async function probeChromeNano(): Promise<{
-	available: boolean;
-	note: string;
-}> {
-	if (!isChromeNanoAvailable()) {
-		return {
-			available: false,
-			note: "window.LanguageModel not present. Use Chrome 138+ with Prompt API enabled.",
-		};
-	}
-	try {
-		const a = await LanguageModel.availability({
-			expectedInputs: [{ type: "text", languages: ["en"] }],
-		});
-		if (a === "unavailable") {
-			return { available: false, note: "LanguageModel reported unavailable." };
-		}
-		return { available: true, note: a === "readily" ? "Ready" : `Status: ${a}` };
-	} catch (err) {
-		return {
-			available: false,
-			note: `Probe error: ${err instanceof Error ? err.message : String(err)}`,
-		};
-	}
-}
-
-// Chrome Nano commonly wraps JSON in prose ("Here's the classification: {...}")
-// or markdown fences. Extract the first balanced `{...}` so `JSON.parse`
-// downstream succeeds; if nothing extractable is found, return the raw text
-// and let the caller see the parse error.
-function extractJsonObject(text: string): string {
-	const fenced = text.match(/```(?:json)?\s*([\s\S]*?)\s*```/);
-	const source = fenced ? fenced[1]! : text;
-	const start = source.indexOf("{");
-	if (start < 0) return text;
-	let depth = 0;
-	let inString = false;
-	let inEscape = false;
-	for (let i = start; i < source.length; i++) {
-		const ch = source[i]!;
-		if (inEscape) {
-			inEscape = false;
-			continue;
-		}
-		if (ch === "\\") {
-			inEscape = true;
-			continue;
-		}
-		if (ch === '"') {
-			inString = !inString;
-			continue;
-		}
-		if (inString) continue;
-		if (ch === "{") depth++;
-		else if (ch === "}") {
-			depth--;
-			if (depth === 0) return source.slice(start, i + 1);
-		}
-	}
-	return text;
-}
-
-function createChromeNanoAdapter(): LLMAdapter {
-	let session: Promise<LanguageModel> | null = null;
-
-	function ensureSession(): Promise<LanguageModel> {
-		if (session) return session;
-		session = LanguageModel.create({
-			temperature: 0.2,
-			topK: 3,
-			systemPrompt: "You are an SRE triage assistant. Respond with JSON only.",
-			expectedInputs: [{ type: "text", languages: ["en"] }],
-			expectedOutputs: [{ type: "text", languages: ["en"] }],
-		}).catch((err) => {
-			// Clear the cached promise so the next call retries creation.
-			session = null;
-			throw err;
-		}) as Promise<LanguageModel>;
-		return session;
-	}
-
-	return {
-		provider: "chrome-nano",
-		model: "gemini-nano",
-		invoke(messages: readonly ChatMessage[]) {
-			return (async (): Promise<LLMResponse> => {
-				const s = await ensureSession();
-				const userMsg = messages.find((m) => m.role === "user");
-				const raw = await s.prompt(userMsg?.content ?? "");
-				return { content: extractJsonObject(raw), finishReason: "stop" };
-			})() as unknown as ReturnType<LLMAdapter["invoke"]>;
-		},
-		stream() {
-			return {
-				[Symbol.asyncIterator]() {
-					return {
-						next: () =>
-							Promise.reject(new Error("stream not implemented for Chrome Nano triage demo")),
-					};
-				},
-			};
-		},
-	};
-}
-
-// ── BYOK (Bring Your Own Key) ───────────────────────────────────
-// Uses a simple fetch-based adapter that talks to the OpenAI-compatible API.
-
-function createByokAdapter(apiKey: string, baseUrl: string, model: string): LLMAdapter {
-	return {
-		provider: "byok",
-		model,
-		invoke(messages: readonly ChatMessage[]) {
-			return (async (): Promise<LLMResponse> => {
-				const resp = await fetch(`${baseUrl}/chat/completions`, {
-					method: "POST",
-					headers: {
-						"Content-Type": "application/json",
-						Authorization: `Bearer ${apiKey}`,
-					},
-					body: JSON.stringify({
-						model,
-						messages: messages.map((m) => ({ role: m.role, content: m.content })),
-						temperature: 0.3,
-						max_tokens: 200,
-					}),
-				});
-				if (!resp.ok) {
-					throw new Error(`BYOK API error: ${resp.status} ${resp.statusText}`);
-				}
-				const data = (await resp.json()) as {
-					choices: { message: { content: string } }[];
-					usage?: { prompt_tokens: number; completion_tokens: number };
-				};
-				const content = data.choices[0]?.message.content ?? "";
-				return {
-					content,
-					finishReason: "stop",
-					usage: data.usage
-						? {
-								input: { regular: data.usage.prompt_tokens },
-								output: { regular: data.usage.completion_tokens },
-							}
-						: undefined,
-				};
-			})() as unknown as ReturnType<LLMAdapter["invoke"]>;
-		},
-		stream() {
-			return {
-				[Symbol.asyncIterator]() {
-					return {
-						next: () => Promise.reject(new Error("stream not implemented for BYOK triage demo")),
-					};
-				},
-			};
-		},
-	};
-}
-
-// ── Factory ─────────────────────────────────────────────────────
-
-export interface CreateAdapterOpts {
-	mode: AdapterMode;
-	apiKey?: string;
-	baseUrl?: string;
-	model?: string;
-}
-
-export function createAdapter(opts: CreateAdapterOpts): LLMAdapter {
-	switch (opts.mode) {
-		case "dry-run":
-			return createDryRunAdapter();
-		case "chrome-nano":
-			return createChromeNanoAdapter();
-		case "byok":
-			if (!opts.apiKey) throw new Error("BYOK mode requires an API key");
-			return createByokAdapter(
-				opts.apiKey,
-				opts.baseUrl ?? "https://api.openai.com/v1",
-				opts.model ?? "gpt-4o-mini",
-			);
-	}
-}
diff --git a/demos/pagerduty-triage/src/lib/alerts.ts b/demos/pagerduty-triage/src/lib/alerts.ts
deleted file mode 100644
index a8e1da07..00000000
--- a/demos/pagerduty-triage/src/lib/alerts.ts
+++ /dev/null
@@ -1,119 +0,0 @@
-// ── Alert generator ──────────────────────────────────────────────
-// Scaffolded vocabulary that randomly combines into realistic PagerDuty alerts.
-// A seeded PRNG ensures reproducibility across Baseline / GraphReFly runs.
-
-export type Severity = "critical" | "high" | "warning" | "low" | "info";
-
-export interface Alert {
-	readonly id: string;
-	readonly service: string;
-	readonly severity: Severity;
-	readonly summary: string;
-	readonly timestamp: number;
-}
-
-// ── Vocabulary ──────────────────────────────────────────────────
-
-const SERVICES = [
-	"payment-api",
-	"auth-service",
-	"db-primary",
-	"db-replica",
-	"user-service",
-	"order-service",
-	"notification-svc",
-	"search-index",
-	"cdn-edge",
-	"ml-inference",
-] as const;
-
-const ERROR_TEMPLATES: readonly { tpl: string; severities: readonly Severity[] }[] = [
-	{ tpl: "Connection timeout after 30s", severities: ["critical", "high"] },
-	{ tpl: "Connection refused on port 5432", severities: ["critical", "high"] },
-	{ tpl: "5xx error rate exceeded 5% threshold", severities: ["critical", "high"] },
-	{ tpl: "Disk usage exceeded 90%", severities: ["high", "warning"] },
-	{ tpl: "Memory usage exceeded 85%", severities: ["high", "warning"] },
-	{ tpl: "CPU utilization at 95% for 5 minutes", severities: ["high", "warning"] },
-	{ tpl: "Latency p99 exceeded 2000ms", severities: ["high", "warning"] },
-	{ tpl: "SSL certificate expires in 7 days", severities: ["warning", "low"] },
-	{ tpl: "Health check failing on 2/5 instances", severities: ["high", "warning"] },
-	{ tpl: "Queue depth exceeded 10000 messages", severities: ["high", "warning"] },
-	{ tpl: "Pod restart loop detected (CrashLoopBackOff)", severities: ["critical", "high"] },
-	{ tpl: "DNS resolution failure", severities: ["critical", "high"] },
-	{ tpl: "Rate limiter engaged — 429 responses climbing", severities: ["warning", "low"] },
-	{ tpl: "Deployment rollback triggered", severities: ["high", "warning"] },
-	{ tpl: "Log ingestion pipeline stalled", severities: ["warning", "low"] },
-];
-
-// ── Seeded PRNG (mulberry32) ────────────────────────────────────
-
-function mulberry32(seed: number): () => number {
-	let s = seed | 0;
-	return () => {
-		s = (s + 0x6d2b79f5) | 0;
-		let t = Math.imul(s ^ (s >>> 15), 1 | s);
-		t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;
-		return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
-	};
-}
-
-// ── Generator ───────────────────────────────────────────────────
-
-export interface AlertGeneratorOptions {
-	seed?: number;
-	count?: number;
-}
-
-export function generateAlerts(opts?: AlertGeneratorOptions): readonly Alert[] {
-	const seed = opts?.seed ?? Date.now() ^ 0xdeadbeef;
-	const count = opts?.count ?? 80; // enough for a 5-minute run (~52 alerts produced across phases)
-	const rng = mulberry32(seed);
-
-	const pick = <T>(arr: readonly T[]): T => arr[Math.floor(rng() * arr.length)]!;
-
-	const alerts: Alert[] = [];
-	for (let i = 0; i < count; i++) {
-		const service = pick(SERVICES);
-		const error = pick(ERROR_TEMPLATES);
-		const severity = pick(error.severities);
-		alerts.push({
-			id: `PD-${String(i + 1).padStart(4, "0")}`,
-			service,
-			severity,
-			summary: `[${service}] ${error.tpl}`,
-			timestamp: 0, // filled at emission time
-		});
-	}
-	return alerts;
-}
-
-// ── Emission schedule ───────────────────────────────────────────
-// Returns next delay-in-ms based on elapsed run time (not alert index).
-// 5-minute round with a long readable ramp-up:
-//   0:00 – 1:00  → 30s between alerts   (calm, you read carefully)
-//   1:00 – 2:00  → 20s between alerts   (steady)
-//   2:00 – 3:00  → 15s between alerts   (elevated)
-//   3:00 – 4:50  → 10s between alerts   (pressured)
-//   4:50 – 5:00  → 1s burst             (chaos finale)
-
-export const EMISSION_PHASES = [
-	{ untilMs: 60_000, delayMs: 30_000, label: "calm (30s)" },
-	{ untilMs: 120_000, delayMs: 20_000, label: "steady (20s)" },
-	{ untilMs: 180_000, delayMs: 15_000, label: "elevated (15s)" },
-	{ untilMs: 290_000, delayMs: 10_000, label: "pressured (10s)" },
-	{ untilMs: 300_000, delayMs: 1_000, label: "burst (1s)" },
-] as const;
-
-export function emissionDelayMs(elapsedMs: number): number {
-	for (const phase of EMISSION_PHASES) {
-		if (elapsedMs < phase.untilMs) return phase.delayMs;
-	}
-	return EMISSION_PHASES[EMISSION_PHASES.length - 1].delayMs;
-}
-
-export function emissionPhaseLabel(elapsedMs: number): string {
-	for (const phase of EMISSION_PHASES) {
-		if (elapsedMs < phase.untilMs) return phase.label;
-	}
-	return EMISSION_PHASES[EMISSION_PHASES.length - 1].label;
-}
diff --git a/demos/pagerduty-triage/src/lib/dry-run-fixtures.ts b/demos/pagerduty-triage/src/lib/dry-run-fixtures.ts
deleted file mode 100644
index 9fa998b9..00000000
--- a/demos/pagerduty-triage/src/lib/dry-run-fixtures.ts
+++ /dev/null
@@ -1,156 +0,0 @@
-// ── Dry-run fixtures ────────────────────────────────────────────
-// Deterministic mock responses for the triage demo's dry-run mode.
-// Uses dryRunAdapter with a respond function that returns plausible
-// classification results based on keyword matching.
-
-import type { ChatMessage, LLMAdapter } from "@graphrefly/graphrefly/utils/ai";
-import { dryRunAdapter } from "@graphrefly/graphrefly/utils/ai";
-
-const SEVERITY_DISPOSITION: Record<string, { disposition: string; confidence: number }> = {
-	critical: { disposition: "actionable", confidence: 0.85 },
-	high: { disposition: "actionable", confidence: 0.65 },
-	warning: { disposition: "deferred", confidence: 0.55 },
-	low: { disposition: "resolved", confidence: 0.7 },
-	info: { disposition: "resolved", confidence: 0.8 },
-};
-
-const KEYWORD_RULES: readonly {
-	keywords: readonly string[];
-	disposition: string;
-	confidence: number;
-	brief: string;
-}[] = [
-	{
-		keywords: ["connection timeout", "connection refused"],
-		disposition: "actionable",
-		confidence: 0.75,
-		brief: "Connection failure — likely needs restart or investigation",
-	},
-	{
-		keywords: ["5xx", "error rate"],
-		disposition: "escalated",
-		confidence: 0.8,
-		brief: "Error rate spike — may indicate systemic issue",
-	},
-	{
-		keywords: ["disk usage", "disk"],
-		disposition: "actionable",
-		confidence: 0.7,
-		brief: "Disk pressure — may need cleanup or volume expansion",
-	},
-	{
-		keywords: ["memory usage"],
-		disposition: "actionable",
-		confidence: 0.65,
-		brief: "Memory pressure — check for leaks or scale up",
-	},
-	{
-		keywords: ["cpu"],
-		disposition: "deferred",
-		confidence: 0.55,
-		brief: "CPU spike — often transient, monitor for recurrence",
-	},
-	{
-		keywords: ["ssl", "certificate"],
-		disposition: "deferred",
-		confidence: 0.6,
-		brief: "Certificate approaching expiry — schedule renewal",
-	},
-	{
-		keywords: ["health check"],
-		disposition: "actionable",
-		confidence: 0.7,
-		brief: "Health check failures — partial outage possible",
-	},
-	{
-		keywords: ["queue depth"],
-		disposition: "deferred",
-		confidence: 0.5,
-		brief: "Queue backlog — may self-resolve, monitor",
-	},
-	{
-		keywords: ["crashloop", "restart loop"],
-		disposition: "escalated",
-		confidence: 0.85,
-		brief: "Pod crash loop — needs immediate attention",
-	},
-	{
-		keywords: ["dns"],
-		disposition: "escalated",
-		confidence: 0.8,
-		brief: "DNS resolution failure — broad impact likely",
-	},
-	{
-		keywords: ["rate limit", "429"],
-		disposition: "resolved",
-		confidence: 0.65,
-		brief: "Rate limiter active — working as designed",
-	},
-	{
-		keywords: ["rollback", "deployment"],
-		disposition: "actionable",
-		confidence: 0.7,
-		brief: "Deployment rollback — check what changed",
-	},
-	{
-		keywords: ["log", "ingestion", "pipeline"],
-		disposition: "deferred",
-		confidence: 0.5,
-		brief: "Log pipeline stall — non-critical, check batch processor",
-	},
-];
-
-function classifyFromKeywords(text: string): {
-	disposition: string;
-	confidence: number;
-	brief: string;
-} {
-	const lower = text.toLowerCase();
-	for (const rule of KEYWORD_RULES) {
-		if (rule.keywords.some((kw) => lower.includes(kw))) {
-			return { disposition: rule.disposition, confidence: rule.confidence, brief: rule.brief };
-		}
-	}
-	// Fallback: use severity if mentioned
-	for (const [sev, result] of Object.entries(SEVERITY_DISPOSITION)) {
-		if (lower.includes(sev)) {
-			return { ...result, brief: `${sev}-level alert — default triage` };
-		}
-	}
-	return {
-		disposition: "actionable",
-		confidence: 0.4,
-		brief: "Unknown pattern — needs manual review",
-	};
-}
-
-export function createDryRunAdapter(): LLMAdapter {
-	return dryRunAdapter({
-		provider: "dry-run",
-		model: "triage-mock",
-		latencyMs: 200,
-		respond: (messages: readonly ChatMessage[]) => {
-			const userMsg = messages.find((m) => m.role === "user");
-			if (!userMsg)
-				return JSON.stringify({
-					alertId: "",
-					disposition: "actionable",
-					confidence: 0.4,
-					brief: "No input",
-				});
-
-			// Echo the Alert ID from the prompt — routeEffect uses it to look
-			// up the in-flight alert; an undefined/missing alertId silently
-			// skips via the staleness guard (pendingAlerts.get(undefined) → null).
-			const alertIdMatch = userMsg.content.match(/Alert ID:\s*(\S+)/);
-			const alertId = alertIdMatch?.[1] ?? "";
-
-			const result = classifyFromKeywords(userMsg.content);
-			return JSON.stringify({ alertId, ...result });
-		},
-		usage: () => ({
-			input: { regular: 120 },
-			output: { regular: 40 },
-		}),
-	});
-}
diff --git a/demos/pagerduty-triage/src/lib/mermaid-render.ts b/demos/pagerduty-triage/src/lib/mermaid-render.ts
deleted file mode 100644
index e4c942d7..00000000
--- a/demos/pagerduty-triage/src/lib/mermaid-render.ts
+++ /dev/null
@@ -1,18 +0,0 @@
-import mermaid from "mermaid";
-import {
-	createNextMermaidId,
-	initMermaidRenderer,
-	MERMAID_NODE_STROKE_DEFAULT,
-	MERMAID_NODE_STROKE_MATCH,
-	MERMAID_THEME_VARIABLES,
-} from "../../../shared/lib/mermaid-theme";
-
-export { MERMAID_NODE_STROKE_DEFAULT, MERMAID_NODE_STROKE_MATCH, MERMAID_THEME_VARIABLES };
-
-export function initMermaid(): void {
-	initMermaidRenderer(mermaid);
-}
-
-export const nextMermaidId = createNextMermaidId("pagerduty-triage");
-
-export { mermaid };
diff --git a/demos/pagerduty-triage/src/lib/pan-zoom.ts b/demos/pagerduty-triage/src/lib/pan-zoom.ts
deleted file mode 100644
index 9de09524..00000000
--- a/demos/pagerduty-triage/src/lib/pan-zoom.ts
+++ /dev/null
@@ -1,91 +0,0 @@
-// Pan + zoom for SVG containers.
-
-export function attachPanZoom(container: HTMLElement): () => void {
-	let scale = 1;
-	let tx = 0;
-	let ty = 0;
-	let dragging = false;
-	let lastX = 0;
-	let lastY = 0;
-
-	const applyTransform = () => {
-		const svg = container.querySelector("svg") as
-			| (SVGElement & { style: CSSStyleDeclaration })
-			| null;
-		if (!svg) return;
-		svg.style.transformOrigin = "0 0";
-		svg.style.transform = `translate(${tx}px, ${ty}px) scale(${scale})`;
-	};
-
-	const onWheel = (e: WheelEvent) => {
-		e.preventDefault();
-		const factor = e.deltaY < 0 ? 1.1 : 1 / 1.1;
-		const rect = container.getBoundingClientRect();
-		const mx = e.clientX - rect.left;
-		const my = e.clientY - rect.top;
-		tx = mx - (mx - tx) * factor;
-		ty = my - (my - ty) * factor;
-		scale = Math.max(0.1, Math.min(10, scale * factor));
-		applyTransform();
-	};
-
-	const onPointerDown = (e: PointerEvent) => {
-		if (e.button !== 0) return;
-		dragging = true;
-		lastX = e.clientX;
-		lastY = e.clientY;
-		container.setPointerCapture(e.pointerId);
-		container.style.cursor = "grabbing";
-	};
-
-	const onPointerMove = (e: PointerEvent) => {
-		if (!dragging) return;
-		tx += e.clientX - lastX;
-		ty += e.clientY - lastY;
-		lastX = e.clientX;
-		lastY = e.clientY;
-		applyTransform();
-	};
-
-	const onPointerUp = (e: PointerEvent) => {
-		if (!dragging) return;
-		dragging = false;
-		try {
-			container.releasePointerCapture(e.pointerId);
-		} catch {
-			// pointer capture may already be released
-		}
-		container.style.cursor = "grab";
-	};
-
-	const onDoubleClick = () => {
-		scale = 1;
-		tx = 0;
-		ty = 0;
-		applyTransform();
-	};
-
-	container.addEventListener("wheel", onWheel, { passive: false });
-	container.addEventListener("pointerdown", onPointerDown);
-	container.addEventListener("pointermove", onPointerMove);
-	container.addEventListener("pointerup", onPointerUp);
-	container.addEventListener("pointercancel", onPointerUp);
-	container.addEventListener("dblclick", onDoubleClick);
-	container.style.cursor = "grab";
-	container.style.touchAction = "none";
-
-	const observer = new MutationObserver(() => applyTransform());
-	observer.observe(container, { childList: true });
-
-	return () => {
-		container.removeEventListener("wheel", onWheel);
-		container.removeEventListener("pointerdown", onPointerDown);
-		container.removeEventListener("pointermove", onPointerMove);
-		container.removeEventListener("pointerup", onPointerUp);
-		container.removeEventListener("pointercancel", onPointerUp);
-		container.removeEventListener("dblclick", onDoubleClick);
-		observer.disconnect();
-		container.style.cursor = "";
-		container.style.touchAction = "";
-	};
-}
diff --git a/demos/pagerduty-triage/src/lib/pipeline.ts b/demos/pagerduty-triage/src/lib/pipeline.ts
deleted file mode 100644
index ec655086..00000000
--- a/demos/pagerduty-triage/src/lib/pipeline.ts
+++ /dev/null
@@ -1,708 +0,0 @@
-// ── PagerDuty triage pipeline ───────────────────────────────────
-// A composition demo: the full causal chain is visible in describe().
-//
-// Architectural shape:
-//
-//   alertInput ──┐
-//                ├──withLatestFrom──► classify ─► routingAction ─┐
-//   patterns ────┘                                                │
-//                                                                 │
-//   userActionInput ─────────────────────────────► userAction ────┤
-//   autoEscalateChan ─────────────────────────────────────────────┤ merge → allActions
-//   deferExpireChan ──────────────────────────────────────────────┤
-//                                                                 │
-//                  ┌──────────────── scan → bins ─────────────────┤
-//                  ├──────────────── scan → queue ────────────────┤
-//                  ├──────────────── scan → auto-count ───────────┤
-//                  ├──────────────── scan → decision-log ─────────┤
-//                  └──────────────── effect → timer-lifecycle ────┘
-//
-//   obsAdapter.stats.{totalInputTokens, totalOutputTokens, totalCalls}
-//        └──combine──► tokens                       (classify → adapter → tokens)
-//
-//   decision-log ──► agentMemory ──► memory.compact ──► patterns
-//         (the learning loop that feeds back into classify above)
-//
-// TWO imperative entry points — `pushAlert` and `recordDecision` /
-// `retriageActionable` — because alerts and user clicks are genuinely
-// external. Everything downstream is reactive; every edge in the diagram
-// tells the user WHY a value changed.
-
-import { agentMemory } from "@graphrefly/graphrefly/presets/ai";
-import type { LLMAdapter } from "@graphrefly/graphrefly/utils/ai";
-import { observableAdapter, promptNode } from "@graphrefly/graphrefly/utils/ai";
-import type { Node } from "@graphrefly/pure-ts";
-import {
-	fromTimer,
-	Graph,
-	keepalive,
-	merge,
-	reactiveLog,
-	scan,
-	wallClockNs,
-	withLatestFrom,
-} from "@graphrefly/pure-ts";
-import type { Alert } from "./alerts.js";
-import type {
-	ClassifyResult,
-	Disposition,
-	LearnedPattern,
-	TokenSnapshot,
-	TriagedAlert,
-} from "./types.js";
-
-// ── Prompts & helpers ───────────────────────────────────────────
-
-const CLASSIFY_SYSTEM = `You are an on-call SRE triage assistant. Given a PagerDuty alert, classify it.
-Respond with JSON only: {"alertId": "<echo the Alert ID from the prompt>", "disposition": "actionable"|"escalated"|"resolved"|"deferred", "confidence": 0.0-1.0, "brief": "one-line explanation"}
-- "actionable": needs immediate human intervention
-- "escalated": needs senior engineer / team lead attention
-- "resolved": likely auto-resolved or known-safe, can be closed
-- "deferred": not urgent, revisit later
-Be conservative with confidence — if unsure, keep it below 0.6.`;
-
-function classifyPrompt(alert: Alert, patterns: readonly LearnedPattern[]): string {
-	let ctx = "";
-	if (patterns.length > 0) {
-		ctx = "\n\nKnown patterns from prior operator decisions:\n";
-		for (const p of patterns) {
-			ctx += `- "${p.patternKey}" → ${p.disposition} (${p.sampleCount} samples, ${Math.round(p.confidence * 100)}% confident)\n`;
-		}
-		ctx +=
-			"\nUse these to inform your confidence. If an alert clearly matches a known pattern, set confidence high.";
-	}
-	return `Alert ID: ${alert.id}\nClassify this PagerDuty alert:\nService: ${alert.service}\nSeverity: ${alert.severity}\nSummary: ${alert.summary}${ctx}`;
-}
-
-function matchesPattern(alert: Alert, pattern: LearnedPattern): boolean {
-	const m = pattern.match;
-	if (m.service) {
-		const services = Array.isArray(m.service) ? m.service : [m.service];
-		const svcMatch = services.some((s) => {
-			if (s.endsWith("*")) return alert.service.startsWith(s.slice(0, -1));
-			return alert.service === s;
-		});
-		if (!svcMatch) return false;
-	}
-	if (m.severityRange && m.severityRange.length > 0) {
-		if (!m.severityRange.includes(alert.severity)) return false;
-	}
-	if (m.errorCategory) {
-		const cat = m.errorCategory.toLowerCase().replace(/-/g, " ");
-		const sum = alert.summary.toLowerCase().replace(/-/g, " ");
-		const keywords = cat.split(/\s+/).filter((kw) => kw.length > 2);
-		if (keywords.length > 0) {
-			const matched = keywords.filter((kw) => sum.includes(kw));
-			if (matched.length < Math.ceil(keywords.length * 0.7)) return false;
-		}
-	}
-	return true;
-}
-
-function findMatchingPattern(
-	alert: Alert,
-	patterns: readonly LearnedPattern[],
-): LearnedPattern | null {
-	for (const p of patterns) {
-		if (p.confidence >= 0.7 && matchesPattern(alert, p)) return p;
-	}
-	return null;
-}
-
-// Spec §5.11: timestamps go through the central clock. `wallClockNs()`
-// gives wall-clock nanoseconds; /1e6 = ms for display.
-function wallClockMs(): number {
-	return Math.floor(wallClockNs() / 1e6);
-}
-
-// ── Public types ────────────────────────────────────────────────
-
-/** Milliseconds a low-confidence alert sits in the user queue before the
- *  pipeline auto-escalates it (simulates pager fatigue / SLA breach). */
-export const AUTO_ESCALATE_AFTER_MS = 45_000;
-
-export interface TriagePipelineOptions {
-	adapter: LLMAdapter;
-	mode: "baseline" | "graphrefly";
-}
-
-export interface QueuedAlert {
-	readonly alert: Alert;
-	readonly brief: string;
-	readonly confidence: number;
-}
-
-export interface TriageBins {
-	readonly actionable: readonly TriagedAlert[];
-	readonly escalated: readonly TriagedAlert[];
-	readonly resolved: readonly TriagedAlert[];
-	readonly deferred: readonly DeferredAlert[];
-}
-
-export interface DeferredAlert extends TriagedAlert {
-	readonly retryAt: number;
-}
-
-export interface TriagePipeline {
-	readonly graph: Graph;
-	readonly pushAlert: (alert: Alert) => void;
-	readonly recordDecision: (alertId: string, disposition: Disposition, deferMs?: number) => void;
-	readonly retriageActionable: (
-		alertId: string,
-		disposition: Disposition,
-		deferMs?: number,
-	) => void;
-	readonly userQueue: Node<readonly QueuedAlert[]>;
-	readonly bins: Node<TriageBins>;
-	readonly tokens: Node<TokenSnapshot>;
-	readonly patterns: Node<readonly LearnedPattern[]>;
-	readonly autoCount: Node<number>;
-	readonly destroy: () => void;
-}
-
-// ── Internal action types (the one message currency) ───────────
-
-type TriageAction =
-	| { readonly k: "classify-pattern-match"; readonly triaged: TriagedAlert }
-	| { readonly k: "classify-high-conf"; readonly triaged: TriagedAlert }
-	| { readonly k: "classify-low-conf"; readonly entry: QueuedAlert }
-	| {
-			readonly k: "user-decision";
-			readonly entry: QueuedAlert;
-			readonly triaged: TriagedAlert;
-	  }
-	| {
-			readonly k: "user-retriage-actionable";
-			readonly oldAlertId: string;
-			readonly newTriaged: TriagedAlert;
-	  }
-	| { readonly k: "auto-escalate"; readonly triaged: TriagedAlert }
-	| {
-			readonly k: "defer-expired";
-			readonly alertId: string;
-			readonly reQueued: QueuedAlert;
-	  };
-
-const EMPTY_BINS: TriageBins = {
-	actionable: [],
-	escalated: [],
-	resolved: [],
-	deferred: [],
-};
-const EMPTY_QUEUE: readonly QueuedAlert[] = [];
-
-// ── Pure reducers (scan bodies) ─────────────────────────────────
-
-function addTriagedToBins(prev: TriageBins, triaged: TriagedAlert): TriageBins {
-	if (triaged.disposition === "deferred") {
-		const delayMs = triaged.deferMs ?? 30_000;
-		const deferred: DeferredAlert = { ...triaged, retryAt: wallClockMs() + delayMs };
-		return { ...prev, deferred: [...prev.deferred, deferred] };
-	}
-	return {
-		...prev,
-		[triaged.disposition]: [...prev[triaged.disposition], triaged],
-	};
-}
-
-function reduceBins(prev: TriageBins, a: TriageAction): TriageBins {
-	switch (a.k) {
-		case "classify-pattern-match":
-		case "classify-high-conf":
-		case "user-decision":
-		case "auto-escalate":
-			return addTriagedToBins(prev, a.triaged);
-		case "user-retriage-actionable": {
-			const cleaned: TriageBins = {
-				...prev,
-				actionable: prev.actionable.filter((t) => t.alert.id !== a.oldAlertId),
-			};
-			return addTriagedToBins(cleaned, a.newTriaged);
-		}
-		case "defer-expired":
-			return { ...prev, deferred: prev.deferred.filter((d) => d.alert.id !== a.alertId) };
-		default:
-			return prev;
-	}
-}
-
-function reduceQueue(prev: readonly QueuedAlert[], a: TriageAction): readonly QueuedAlert[] {
-	switch (a.k) {
-		case "classify-low-conf":
-			return [...prev, a.entry];
-		case "user-decision":
-			return prev.filter((q) => q.alert.id !== a.entry.alert.id);
-		case "auto-escalate":
-			return prev.filter((q) => q.alert.id !== a.triaged.alert.id);
-		case "defer-expired":
-			return [...prev, a.reQueued];
-		default:
-			return prev;
-	}
-}
-
-function reduceAutoCount(prev: number, a: TriageAction): number {
-	return a.k === "classify-pattern-match" ? prev + 1 : prev;
-}
-
-// ── Factory ─────────────────────────────────────────────────────
-
-export function createTriagePipeline(opts: TriagePipelineOptions): TriagePipeline {
-	const { adapter: rawAdapter, mode } = opts;
-	const graph = new Graph(`triage-${mode}`);
-
-	// ── Observable adapter (library primitive) ──────────────────
-	// Token accounting is built into the library; we just subscribe to it.
-	const { adapter, stats } = observableAdapter(rawAdapter, { name: "llm" });
-
-	// ── Imperative entry points (the only two in the whole pipeline) ─
-	const alertInput = graph.state<Alert | null>("alerts/input", null);
-	const userActionInput = graph.state<TriageAction | null>("user-action/input", null);
-
-	// Per-alert timer fan-in channels. Effects that fire on timer DATA
-	// emit actions here; `merge` below combines them with classify/user
-	// streams into a single action stream.
-	const autoEscalateChan = graph.state<TriageAction | null>("auto-escalate/chan", null);
-	const deferExpireChan = graph.state<TriageAction | null>("defer-expire/chan", null);
-
-	// ── Decision log (reactive list of user decisions) ──────────
-	// agentMemory consumes the .node view below. Appends happen inside
-	// the logDecisionEffect once a user-decision action materializes.
-	const decisionLog = reactiveLog<{
-		alert: Alert;
-		disposition: Disposition;
-		deferMs?: number;
-	}>(undefined, { name: "decisions/log", maxSize: 200 });
-	graph.add(decisionLog.entries, { name: "decisions/log" });
-
-	// ── Pattern learning (graphrefly mode) ──────────────────────
-	// Visible edge: decisions/log → agentMemory internals → memory.compact →
-	// patterns/learned. In baseline mode, patterns is a derived([]) that never
-	// emits — so no learning loop appears in the graph.
-	let patternsNode: Node<readonly LearnedPattern[]>;
-	let memoryKeepalive: (() => void) | null = null;
-
-	if (mode === "graphrefly") {
-		const memory = agentMemory<LearnedPattern>("triage-patterns", decisionLog.entries, {
-			extractFn: (raw) => {
-				const decisions = raw as readonly {
-					alert: Alert;
-					disposition: Disposition;
-					deferMs?: number;
-				}[];
-				if (!decisions || decisions.length === 0) return { upsert: [] };
-				const groups = new Map<
-					string,
-					{ alerts: Alert[]; disposition: Disposition; deferMs?: number }
-				>();
-				for (const d of decisions) {
-					const cat = extractErrorCategory(d.alert.summary);
-					const key = `${d.alert.service}::${cat}`;
-					const g = groups.get(key);
-					if (g) {
-						g.alerts.push(d.alert);
-						groups.set(key, { ...g, disposition: d.disposition, deferMs: d.deferMs });
-					} else {
-						groups.set(key, {
-							alerts: [d.alert],
-							disposition: d.disposition,
-							deferMs: d.deferMs,
-						});
-					}
-				}
-				const upsert: { key: string; value: LearnedPattern }[] = [];
-				for (const [key, g] of groups) {
-					if (g.alerts.length < 2) continue;
-					const sep = key.indexOf("::");
-					const service = key.slice(0, sep);
-					const errorCategory = key.slice(sep + 2);
-					const sevs = [...new Set(g.alerts.map((a) => a.severity))];
-					upsert.push({
-						key,
-						value: {
-							patternKey: `${errorCategory} on ${service}`,
-							match: { service, severityRange: sevs, errorCategory },
-							disposition: g.disposition,
-							deferMs: g.deferMs,
-							sampleCount: g.alerts.length,
-							confidence: Math.min(0.95, 0.5 + g.alerts.length * 0.15),
-						},
-					});
-				}
-				return { upsert };
-			},
-			score: (m) => m.sampleCount * m.confidence,
-			cost: (m) => 50 + m.patternKey.length,
-			budget: 4000,
-		});
-		patternsNode = graph.derived<readonly LearnedPattern[]>(
-			"patterns/learned",
-			[memory.compact],
-			(data, ctx) => {
-				const compact = data[0] != null && data[0].length > 0 ? data[0].at(-1) : ctx.prevData[0];
-				if (!compact) return [[]];
-				const entries = compact as readonly { key: string; value: LearnedPattern }[];
-				return [entries.map((e) => e.value)];
-			},
-			{ initial: [] as readonly LearnedPattern[] },
-		);
-		// Keep patterns live so agentMemory runs even before classify subscribes.
-		memoryKeepalive = keepalive(patternsNode);
-	} else {
-		// Baseline: empty patterns, no learning.
-		patternsNode = graph.state<readonly LearnedPattern[]>("patterns/learned", []);
-	}
-
-	// ── Classify (promptNode with withLatestFrom snapshot) ──────
-	// `withLatestFrom(alert, patterns)` emits [alert, patterns] ONLY when
-	// alert changes — patterns updates don't re-invoke the LLM on an alert
-	// that's already been decided. This breaks the feedback cycle
-	// (patterns → classify → decisions → patterns) cleanly and keeps the
-	// learning loop as a FIRST-CLASS visible edge in describe().
-	const alertWithPatterns = withLatestFrom(alertInput, patternsNode, {
-		name: "alert+patterns",
-	});
-	graph.add(alertWithPatterns, { name: "alert+patterns" });
-
-	const classify = promptNode<ClassifyResult>(
-		adapter,
-		[alertWithPatterns],
-		(pair) => {
-			if (!pair) return "";
-			const [alert, patterns] = pair as [Alert | null, readonly LearnedPattern[] | null];
-			if (!alert) return "";
-			return classifyPrompt(alert, patterns ?? []);
-		},
-		{
-			name: "classify",
-			format: "json",
-			systemPrompt: CLASSIFY_SYSTEM,
-		},
-	);
-	graph.add(classify, { name: "classify" });
-
-	// ── Routing decision: classify result → TriageAction ────────
-	// Reads `patternsNode.cache` for a cold snapshot of patterns at the
-	// moment of routing (pattern-match gate). Declaring patternsNode as a
-	// dep here would re-fire on pattern updates; `withLatestFrom` above
-	// is the reactive snapshot, this is the application-time peek that
-	// mirrors it for the pattern-match check.
-	const routingAction = graph.derived<TriageAction | null>(
-		"routing-action",
-		[classify],
-		(data, ctx) => {
-			const result = data[0] != null && data[0].length > 0 ? data[0].at(-1) : ctx.prevData[0];
-			if (!result) return [];
-			const cls = result as ClassifyResult;
-			// Recover the originating alert: alertInput's current cache is the
-			// last-pushed alert. classify fires synchronously on that input, so
-			// this is always the correct one at decision time.
-			const alert = alertInput.cache as Alert | null;
-			if (!alert || alert.id !== cls.alertId) return [];
-			if (mode === "graphrefly") {
-				const pats = (patternsNode.cache as readonly LearnedPattern[] | undefined) ?? [];
-				const match = findMatchingPattern(alert, pats);
-				if (match) {
-					return [
-						{
-							k: "classify-pattern-match",
-							triaged: {
-								alert,
-								disposition: match.disposition,
-								deferMs: match.deferMs,
-								brief: `Auto: matches pattern "${match.patternKey}"`,
-								confidence: match.confidence,
-								autoClassified: true,
-								reason: "pattern",
-								triagedAt: wallClockMs(),
-							},
-						},
-					];
-				}
-			}
-			if (cls.confidence >= 0.8) {
-				return [
-					{
-						k: "classify-high-conf",
-						triaged: {
-							alert,
-							disposition: cls.disposition,
-							brief: cls.brief,
-							confidence: cls.confidence,
-							autoClassified: false,
-							reason: "high-conf",
-							triagedAt: wallClockMs(),
-						},
-					},
-				];
-			}
-			return [
-				{
-					k: "classify-low-conf",
-					entry: { alert, brief: cls.brief, confidence: cls.confidence },
-				},
-			];
-		},
-		{ initial: null },
-	);
-
-	// ── Merge all action sources ────────────────────────────────
-	const allActions = merge(routingAction, userActionInput, autoEscalateChan, deferExpireChan);
-	graph.add(allActions, { name: "all-actions" });
-
-	// ── Scan → bins / queue / auto-count ────────────────────────
-	// Every event that mutates bins/queue/auto-count flows through
-	// allActions → these scans. The edges are all declared, all visible.
-	const bins = scan<TriageAction, TriageBins>(
-		allActions,
-		(prev, a) => (a == null ? prev : reduceBins(prev, a)),
-		EMPTY_BINS,
-		{ name: "bins" },
-	);
-	const userQueue = scan<TriageAction, readonly QueuedAlert[]>(
-		allActions,
-		(prev, a) => (a == null ? prev : reduceQueue(prev, a)),
-		EMPTY_QUEUE,
-		{ name: "queue/user" },
-	);
-	const autoCount = scan<TriageAction, number>(
-		allActions,
-		(prev, a) => (a == null ? prev : reduceAutoCount(prev, a)),
-		0,
-		{ name: "auto-count" },
-	);
-	graph.add(bins, { name: "bins" });
-	graph.add(userQueue, { name: "queue/user" });
-	graph.add(autoCount, { name: "auto-count" });
-
-	// ── Tokens: derived directly from observableAdapter.stats ───
-	// This is THE key library-primitive showcase: tokens isn't a thing we
-	// maintain; it's a reactive view over adapter stats + the auto-count
-	// (which doubles as "local cache hits" since pattern-match == zero-LLM).
-	// Edges visible: adapter.stats.totalInputTokens → tokens, etc.
-	const tokens = graph.derived<TokenSnapshot>(
-		"tokens",
-		[stats.totalInputTokens, stats.totalOutputTokens, stats.totalCalls, autoCount],
-		(data, ctx) => {
-			const read = (i: number) =>
-				data[i] != null && data[i]!.length > 0 ? data[i]!.at(-1) : ctx.prevData[i];
-			return [
-				{
-					inputTokens: (read(0) as number | undefined) ?? 0,
-					outputTokens: (read(1) as number | undefined) ?? 0,
-					cacheReadTokens: 0,
-					localCacheHits: (read(3) as number | undefined) ?? 0,
-					calls: (read(2) as number | undefined) ?? 0,
-				},
-			];
-		},
-	);
-
-	// ── Effect: log user decisions into decisions/log ───────────
-	// decision-log / agentMemory is the learning loop. Visible in the graph:
-	// all-actions → log-decision-effect → decisions/log → memory → patterns.
-	const logDecisionEffect = graph.effect("log-decision-effect", [allActions], (data) => {
-		const action = (
-			data[0] != null && data[0].length > 0 ? data[0].at(-1) : null
-		) as TriageAction | null;
-		if (!action) return;
-		if (action.k === "user-decision") {
-			decisionLog.append({
-				alert: action.entry.alert,
-				disposition: action.triaged.disposition,
-				deferMs: action.triaged.deferMs,
-			});
-		} else if (action.k === "user-retriage-actionable") {
-			decisionLog.append({
-				alert: action.newTriaged.alert,
-				disposition: action.newTriaged.disposition,
-				deferMs: action.newTriaged.deferMs,
-			});
-		}
-	});
-	const logDecisionKeepalive = keepalive(logDecisionEffect);
-
-	// ── Effect: per-alert timer lifecycle ───────────────────────
-	// On classify-low-conf: spawn auto-escalate timer.
-	// On user-decision: cancel auto-escalate + maybe spawn defer timer.
-	// On user-retriage-actionable (→ deferred): spawn defer timer.
-	// On defer-expired: spawn auto-escalate for re-queued alert.
-	const queueEscalateDisposers = new Map<string, () => void>();
-	const deferDisposers = new Map<string, () => void>();
-
-	function startAutoEscalateTimer(entry: QueuedAlert): void {
-		const timerSrc = fromTimer(AUTO_ESCALATE_AFTER_MS);
-		graph.add(timerSrc, { name: `escalate-timer/${entry.alert.id}` });
-		const onTick = graph.effect(`escalate-effect/${entry.alert.id}`, [timerSrc], (data) => {
-			const tick = data[0] != null && data[0].length > 0 ? data[0].at(-1) : null;
-			if (tick == null) return; // first-run sentinel
-			queueEscalateDisposers.delete(entry.alert.id);
-			// Re-emit into the auto-escalate channel; scans pick it up like
-			// any other action. If the alert has already been handled, the
-			// queue reducer is a no-op (filter returns same ref).
-			const queueNow = (userQueue.cache as readonly QueuedAlert[] | undefined) ?? [];
-			if (!queueNow.some((q) => q.alert.id === entry.alert.id)) return;
-			autoEscalateChan.emit({
-				k: "auto-escalate",
-				triaged: {
-					alert: entry.alert,
-					disposition: "escalated",
-					brief: `[Auto-escalated after ${Math.round(AUTO_ESCALATE_AFTER_MS / 1000)}s] ${entry.brief}`,
-					confidence: entry.confidence,
-					autoClassified: false,
-					reason: "timeout",
-					triagedAt: wallClockMs(),
-				},
-			});
-		});
-		queueEscalateDisposers.set(entry.alert.id, keepalive(onTick));
-	}
-
-	function cancelAutoEscalateTimer(alertId: string): void {
-		const dispose = queueEscalateDisposers.get(alertId);
-		if (dispose) {
-			dispose();
-			queueEscalateDisposers.delete(alertId);
-		}
-	}
-
-	function startDeferTimer(triaged: TriagedAlert): void {
-		const delayMs = triaged.deferMs ?? 30_000;
-		const timerSrc = fromTimer(delayMs);
-		graph.add(timerSrc, { name: `defer-timer/${triaged.alert.id}` });
-		const onTick = graph.effect(`defer-effect/${triaged.alert.id}`, [timerSrc], (data) => {
-			const tick = data[0] != null && data[0].length > 0 ? data[0].at(-1) : null;
-			if (tick == null) return;
-			deferDisposers.delete(triaged.alert.id);
-			deferExpireChan.emit({
-				k: "defer-expired",
-				alertId: triaged.alert.id,
-				reQueued: {
-					alert: triaged.alert,
-					brief: `[Re-queued] ${triaged.brief}`,
-					confidence: triaged.confidence,
-				},
-			});
-		});
-		deferDisposers.set(triaged.alert.id, keepalive(onTick));
-	}
-
-	const timerLifecycle = graph.effect("timer-lifecycle", [allActions], (data) => {
-		const action = (
-			data[0] != null && data[0].length > 0 ? data[0].at(-1) : null
-		) as TriageAction | null;
-		if (!action) return;
-		switch (action.k) {
-			case "classify-low-conf":
-				startAutoEscalateTimer(action.entry);
-				break;
-			case "user-decision":
-				cancelAutoEscalateTimer(action.entry.alert.id);
-				if (action.triaged.disposition === "deferred") {
-					startDeferTimer(action.triaged);
-				}
-				break;
-			case "user-retriage-actionable":
-				if (action.newTriaged.disposition === "deferred") {
-					startDeferTimer(action.newTriaged);
-				}
-				break;
-			case "defer-expired":
-				// Re-queued alert accrues a fresh auto-escalate.
-				startAutoEscalateTimer(action.reQueued);
-				break;
-		}
-	});
-	const timerLifecycleKeepalive = keepalive(timerLifecycle);
-
-	// ── Public API (imperative entry points) ────────────────────
-
-	function pushAlert(alert: Alert): void {
-		alertInput.emit({ ...alert, timestamp: wallClockMs() });
-	}
-
-	function recordDecision(alertId: string, disposition: Disposition, deferMs?: number): void {
-		const queueNow = (userQueue.cache as readonly QueuedAlert[] | undefined) ?? [];
-		const entry = queueNow.find((q) => q.alert.id === alertId);
-		if (!entry) return;
-		userActionInput.emit({
-			k: "user-decision",
-			entry,
-			triaged: {
-				alert: entry.alert,
-				disposition,
-				deferMs,
-				brief: entry.brief,
-				confidence: entry.confidence,
-				autoClassified: false,
-				reason: "manual",
-				triagedAt: wallClockMs(),
-			},
-		});
-	}
-
-	function retriageActionable(alertId: string, disposition: Disposition, deferMs?: number): void {
-		if (disposition === "actionable") return;
-		const binsNow = bins.cache as TriageBins | undefined;
-		if (!binsNow) return;
-		const triaged = binsNow.actionable.find((t) => t.alert.id === alertId);
-		if (!triaged) return;
-		userActionInput.emit({
-			k: "user-retriage-actionable",
-			oldAlertId: alertId,
-			newTriaged: {
-				alert: triaged.alert,
-				disposition,
-				deferMs,
-				brief: triaged.brief,
-				confidence: triaged.confidence,
-				autoClassified: false,
-				reason: "manual",
-				triagedAt: wallClockMs(),
-			},
-		});
-	}
-
-	return {
-		graph,
-		pushAlert,
-		recordDecision,
-		retriageActionable,
-		userQueue,
-		bins,
-		tokens,
-		patterns: patternsNode,
-		autoCount,
-		destroy() {
-			for (const unsub of queueEscalateDisposers.values()) unsub();
-			queueEscalateDisposers.clear();
-			for (const unsub of deferDisposers.values()) unsub();
-			deferDisposers.clear();
-			timerLifecycleKeepalive();
-			logDecisionKeepalive();
-			if (memoryKeepalive) memoryKeepalive();
-		},
-	};
-}
-
-// ── Helpers ─────────────────────────────────────────────────────
-
-function extractErrorCategory(summary: string): string {
-	const stripped = summary.replace(/^\[.*?\]\s*/, "").toLowerCase();
-	if (stripped.includes("connection timeout")) return "connection-timeout";
-	if (stripped.includes("connection refused")) return "connection-refused";
-	if (stripped.includes("5xx") || stripped.includes("error rate")) return "error-rate-spike";
-	if (stripped.includes("disk usage") || stripped.includes("disk")) return "disk-pressure";
-	if (stripped.includes("memory usage") || stripped.includes("memory")) return "memory-pressure";
-	if (stripped.includes("cpu")) return "cpu-pressure";
-	if (stripped.includes("latency") || stripped.includes("p99")) return "latency-spike";
-	if (stripped.includes("ssl") || stripped.includes("certificate")) return "certificate-expiry";
-	if (stripped.includes("health check")) return "health-check-failure";
-	if (stripped.includes("queue depth")) return "queue-backlog";
-	if (stripped.includes("crashloop") || stripped.includes("restart")) return "pod-crash-loop";
-	if (stripped.includes("dns")) return "dns-failure";
-	if (stripped.includes("rate limit") || stripped.includes("429")) return "rate-limiting";
-	if (stripped.includes("rollback") || stripped.includes("deployment")) return "deployment-issue";
-	if (stripped.includes("log") || stripped.includes("ingestion")) return "log-pipeline-stall";
-	return "unknown";
-}
diff --git a/demos/pagerduty-triage/src/lib/shell.ts b/demos/pagerduty-triage/src/lib/shell.ts
deleted file mode 100644
index cab3ae18..00000000
--- a/demos/pagerduty-triage/src/lib/shell.ts
+++ /dev/null
@@ -1,30 +0,0 @@
-import {
-	type DemoShellHandle,
-	demoShell,
-	type NodeRegistry,
-} from "@graphrefly/graphrefly/utils/demo-shell";
-import type { Graph } from "@graphrefly/pure-ts";
-
-const liveRegistry: NodeRegistry = new Map();
-let shell: DemoShellHandle | null = null;
-
-export function getShell(viewportWidth?: number): DemoShellHandle {
-	if (!shell) {
-		shell = demoShell({
-			mainRatio: 0.65,
-			viewportWidth: viewportWidth ?? (typeof window !== "undefined" ? window.innerWidth : 1280),
-			nodeRegistry: liveRegistry,
-		});
-	}
-	return shell;
-}
-
-export function setDemoGraph(s: DemoShellHandle, g: Graph): void {
-	s.batch(() => {
-		liveRegistry.clear();
-		s.setDemoGraph(g);
-		s.selectNode(null);
-		s.setHoverTarget(null);
-		s.bumpGraphTick();
-	});
-}
diff --git a/demos/pagerduty-triage/src/lib/types.ts b/demos/pagerduty-triage/src/lib/types.ts
deleted file mode 100644
index e95ebf45..00000000
--- a/demos/pagerduty-triage/src/lib/types.ts
+++ /dev/null
@@ -1,83 +0,0 @@
-import type { Alert, Severity } from "./alerts.js";
-
-// ── User decisions ──────────────────────────────────────────────
-
-export type Disposition = "actionable" | "escalated" | "resolved" | "deferred";
-
-/** Which routing path landed the alert in its bin. Rendered as a pill on the bin card so users can see WHY a ticket skipped focus. */
-export type TriageReason =
-	| "pattern" // matched a learned pattern (AUTO path)
-	| "high-conf" // LLM confidence ≥ 0.8, bypassed queue
-	| "timeout" // sat in queue > auto-escalate threshold
-	| "manual"; // user decision from queue or re-triage
-
-export interface TriagedAlert {
-	readonly alert: Alert;
-	readonly disposition: Disposition;
-	/** For deferred: delay in ms before re-surfacing. */
-	readonly deferMs?: number;
-	/** LLM classification brief. */
-	readonly brief: string;
-	/** LLM confidence 0-1. */
-	readonly confidence: number;
-	/** Whether this was auto-classified by a learned pattern. */
-	readonly autoClassified: boolean;
-	/** Routing path that landed this alert in its bin. */
-	readonly reason: TriageReason;
-	/** Timestamp when triaged. */
-	readonly triagedAt: number;
-}
-
-// ── LLM classification output ───────────────────────────────────
-
-export interface ClassifyResult {
-	/** Echoed from the prompt so stale results can be detected. */
-	readonly alertId: string;
-	readonly disposition: Disposition;
-	readonly confidence: number;
-	readonly brief: string;
-}
-
-// ── Learned pattern (extracted by agentMemory) ──────────────────
-
-export interface LearnedPattern {
-	/** Semantic description, e.g. "connection-timeout on db-*" */
-	readonly patternKey: string;
-	/** Matching attributes (structured for programmatic matching) */
-	readonly match: {
-		readonly service?: string | readonly string[];
-		readonly severityRange?: readonly Severity[];
-		readonly errorCategory: string;
-	};
-	/** The user's consistent decision for this pattern. */
-	readonly disposition: Disposition;
-	readonly deferMs?: number;
-	/** How many user decisions formed this pattern. */
-	readonly sampleCount: number;
-	/** Confidence that the pattern is stable. */
-	readonly confidence: number;
-}
-
-// ── Token accounting ────────────────────────────────────────────
-
-export interface TokenSnapshot {
-	readonly inputTokens: number;
-	readonly outputTokens: number;
-	readonly cacheReadTokens: number;
-	readonly localCacheHits: number;
-	readonly calls: number;
-}
-
-// ── Demo mode ───────────────────────────────────────────────────
-
-export type AdapterMode = "chrome-nano" | "byok" | "dry-run";
-
-export interface AdapterInfo {
-	readonly name: string;
-	readonly status: "ready" | "downloading" | "unavailable";
-	readonly note: string;
-}
-
-// ── Run state ───────────────────────────────────────────────────
-
-export type RunPhase = "setup" | "running" | "finished";
diff --git a/demos/pagerduty-triage/src/lib/use-node-value.ts b/demos/pagerduty-triage/src/lib/use-node-value.ts
deleted file mode 100644
index 8453a6a8..00000000
--- a/demos/pagerduty-triage/src/lib/use-node-value.ts
+++ /dev/null
@@ -1,19 +0,0 @@
-import type { Node } from "@graphrefly/pure-ts";
-import { useEffect, useState } from "react";
-
-/** Subscribe to a GraphReFly Node and re-render on each DATA emission. */
-export function useNodeValue<T>(node: Node<T> | null | undefined, fallback: T): T {
-	const [value, setValue] = useState<T>(() => (node?.cache as T) ?? fallback);
-
-	useEffect(() => {
-		if (!node) return;
-		// Sync immediately in case cache changed between render and effect
-		setValue((node.cache as T) ?? fallback);
-		const unsub = node.subscribe(() => {
-			setValue((node.cache as T) ?? fallback);
-		});
-		return unsub;
-	}, [node, fallback]);
-
-	return value;
-}
diff --git a/demos/pagerduty-triage/src/pages/index.astro b/demos/pagerduty-triage/src/pages/index.astro
deleted file mode 100644
index 6a7a2717..00000000
--- a/demos/pagerduty-triage/src/pages/index.astro
+++ /dev/null
@@ -1,19 +0,0 @@
----
-import App from "../components/App.tsx";
-import "../styles/layout.css";
-import DemoNav from "../../../shared/components/DemoNav.astro";
-
-const base = import.meta.env.BASE_URL;
-const href = (p: string) => `${base.replace(/\/$/, "")}/${p.replace(/^\//, "")}`;
----
-<html lang="en">
-  <head>
-    <meta charset="UTF-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <title>PagerDuty triage — GraphReFly</title>
-  </head>
-  <body>
-    <DemoNav links={[{ href: href("/"), label: "PagerDuty Triage", active: true }]} />
-    <App client:only="react" />
-  </body>
-</html>
diff --git a/demos/pagerduty-triage/src/styles/layout.css b/demos/pagerduty-triage/src/styles/layout.css
deleted file mode 100644
index 511e73e1..00000000
--- a/demos/pagerduty-triage/src/styles/layout.css
+++ /dev/null
@@ -1,964 +0,0 @@
-@import "../../../shared/styles/graphrefly-demo.css";
-
-/* ── App shell ────────────────────────────────────────────────── */
-.app {
-	display: flex;
-	flex-direction: column;
-	height: calc(100vh - var(--gr-demo-nav-height));
-}
-
-/* ── Three-pane shell ─────────────────────────────────────────── */
-.demo-shell {
-	display: flex;
-	flex: 1 1 auto;
-	overflow: hidden;
-	min-height: 0;
-}
-.pane-main {
-	flex: 0 0 auto;
-	overflow-y: auto;
-	padding: 0.75rem 1rem 2rem;
-	display: flex;
-	flex-direction: column;
-	gap: 0.75rem;
-	min-width: 360px;
-}
-.pane-divider {
-	flex: 0 0 5px;
-	background: var(--gr-border);
-	cursor: col-resize;
-	transition: background 0.15s;
-}
-.pane-divider:hover {
-	background: var(--gr-aqua-dim);
-}
-.pane-side {
-	flex: 0 0 auto;
-	display: flex;
-	flex-direction: column;
-	min-width: 320px;
-	background: var(--gr-surface);
-	border-left: 1px solid var(--gr-border-subtle);
-}
-.pane-split-divider {
-	flex: 0 0 5px;
-	background: var(--gr-border);
-	cursor: row-resize;
-}
-.pane-split-divider:hover {
-	background: var(--gr-aqua-dim);
-}
-
-/* ── Setup screen ─────────────────────────────────────────────── */
-.setup-screen {
-	max-width: 640px;
-	margin: 3rem auto;
-	padding: 2rem;
-	display: flex;
-	flex-direction: column;
-	gap: 1.5rem;
-}
-.setup-screen h2 {
-	font-size: 1.75rem;
-	font-weight: 800;
-	color: var(--gr-aqua);
-}
-.setup-desc {
-	color: var(--gr-text-muted);
-	line-height: 1.6;
-}
-.setup-desc strong {
-	color: var(--gr-text);
-}
-.setup-section {
-	display: flex;
-	flex-direction: column;
-	gap: 0.5rem;
-}
-.setup-section h3 {
-	font-size: 11px;
-	letter-spacing: 0.12em;
-	text-transform: uppercase;
-	color: var(--gr-text-muted);
-	font-weight: 700;
-}
-.mode-buttons {
-	display: flex;
-	gap: 0.5rem;
-	flex-wrap: wrap;
-}
-.mode-buttons button {
-	background: var(--gr-surface-raised);
-	color: var(--gr-text);
-	border: 1px solid var(--gr-border);
-	border-radius: 6px;
-	padding: 0.5rem 1rem;
-	font: inherit;
-	font-weight: 600;
-	cursor: pointer;
-	transition:
-		color 0.15s,
-		background 0.15s,
-		border-color 0.15s;
-}
-.mode-buttons button:hover {
-	border-color: var(--gr-aqua);
-}
-.mode-buttons button.active {
-	background: var(--gr-aqua);
-	color: var(--gr-deep);
-	border-color: var(--gr-aqua);
-}
-.mode-buttons button.disabled {
-	opacity: 0.4;
-	cursor: not-allowed;
-}
-.mode-hint {
-	font-size: 12.5px;
-	color: var(--gr-text-muted);
-}
-.byok-fields {
-	display: flex;
-	flex-direction: column;
-	gap: 0.5rem;
-	margin-top: 0.25rem;
-}
-.byok-fields input {
-	font-family: var(--font-mono);
-	font-size: 12.5px;
-	background: var(--gr-surface);
-	color: var(--gr-text);
-	border: 1px solid var(--gr-border);
-	border-radius: 6px;
-	padding: 0.5rem 0.65rem;
-}
-.byok-fields input:focus {
-	outline: none;
-	border-color: var(--gr-aqua);
-}
-.setup-actions {
-	display: flex;
-	gap: 0.75rem;
-	margin-top: 0.5rem;
-}
-.btn-primary {
-	background: var(--gr-aqua);
-	color: var(--gr-deep);
-	border: none;
-	border-radius: 6px;
-	padding: 0.6rem 1.25rem;
-	font: inherit;
-	font-weight: 700;
-	cursor: pointer;
-	transition: background 0.15s;
-}
-.btn-primary:hover {
-	background: #6af2d1;
-}
-.btn-secondary {
-	background: var(--gr-surface-raised);
-	color: var(--gr-text);
-	border: 1px solid var(--gr-border);
-	border-radius: 6px;
-	padding: 0.6rem 1.25rem;
-	font: inherit;
-	font-weight: 600;
-	cursor: pointer;
-}
-.btn-secondary:hover {
-	border-color: var(--gr-aqua);
-}
-
-/* ── Triage header ────────────────────────────────────────────── */
-.triage-header {
-	display: flex;
-	align-items: center;
-	gap: 1rem;
-	padding: 0.5rem 0;
-	border-bottom: 1px solid var(--gr-border-subtle);
-}
-.timer {
-	font-family: var(--font-mono);
-	font-size: 1.5rem;
-	font-weight: 700;
-	color: var(--gr-aqua);
-	min-width: 4.5rem;
-}
-.timer[data-urgent="true"] {
-	color: var(--gr-danger);
-	animation: pulse 0.5s ease-in-out infinite alternate;
-}
-@keyframes pulse {
-	from {
-		opacity: 1;
-	}
-	to {
-		opacity: 0.5;
-	}
-}
-.header-stats {
-	display: flex;
-	gap: 1rem;
-}
-.stat {
-	display: flex;
-	flex-direction: column;
-	align-items: center;
-	font-size: 11px;
-}
-.stat-label {
-	color: var(--gr-text-muted);
-	text-transform: uppercase;
-	letter-spacing: 0.08em;
-	font-weight: 600;
-}
-.stat-value {
-	font-family: var(--font-mono);
-	font-size: 14px;
-	font-weight: 700;
-	color: var(--gr-text);
-}
-.stat-value.auto {
-	color: var(--gr-aqua);
-}
-.header-mode {
-	margin-left: auto;
-	display: flex;
-	gap: 0.4rem;
-}
-
-/* ── Pills ────────────────────────────────────────────────────── */
-.pill {
-	font-family: var(--font-mono);
-	font-size: 10px;
-	padding: 0.1em 0.55em;
-	border-radius: 999px;
-	background: var(--gr-surface-raised);
-	color: var(--gr-text-muted);
-	border: 1px solid var(--gr-border);
-	text-transform: uppercase;
-	letter-spacing: 0.06em;
-	font-weight: 600;
-}
-.pill.graphrefly {
-	color: var(--gr-aqua);
-	border-color: var(--gr-aqua);
-}
-.pill.baseline {
-	color: var(--gr-warn);
-	border-color: var(--gr-warn);
-}
-.pill.actionable {
-	color: var(--gr-danger);
-	border-color: var(--gr-danger);
-}
-.pill.escalated {
-	color: #f0a060;
-	border-color: #f0a060;
-}
-.pill.resolved {
-	color: var(--gr-aqua);
-	border-color: var(--gr-aqua);
-}
-.pill.deferred {
-	color: var(--gr-warn);
-	border-color: var(--gr-warn);
-}
-
-/* ── Triage modal ─────────────────────────────────────────────── */
-.triage-modal {
-	background: var(--gr-surface);
-	border: 1px solid var(--gr-aqua);
-	border-radius: 8px;
-	padding: 1rem;
-	display: flex;
-	flex-direction: column;
-	gap: 0.6rem;
-	box-shadow: 0 0 20px var(--gr-aqua-glow);
-}
-.modal-alert {
-	display: flex;
-	align-items: center;
-	gap: 0.6rem;
-}
-.alert-id {
-	font-family: var(--font-mono);
-	font-size: 12px;
-	color: var(--gr-text-muted);
-}
-.alert-service {
-	font-weight: 700;
-	font-size: 14px;
-}
-.severity-badge {
-	font-family: var(--font-mono);
-	font-size: 11px;
-	font-weight: 700;
-	text-transform: uppercase;
-}
-.modal-summary {
-	font-family: var(--font-mono);
-	font-size: 12.5px;
-	color: var(--gr-text);
-	padding: 0.4rem 0.6rem;
-	background: var(--gr-preview-bg);
-	border-radius: 4px;
-	border: 1px dashed var(--gr-border);
-}
-.modal-brief {
-	font-size: 12.5px;
-	color: var(--gr-text-muted);
-}
-.brief-label {
-	font-weight: 700;
-	color: var(--gr-text);
-}
-.confidence {
-	margin-left: 0.4rem;
-	font-family: var(--font-mono);
-	font-size: 11px;
-	color: var(--gr-aqua-dim);
-}
-.modal-actions {
-	display: flex;
-	gap: 0.5rem;
-	flex-wrap: wrap;
-	margin-top: 0.25rem;
-}
-.action-btn {
-	border: none;
-	border-radius: 6px;
-	padding: 0.45rem 0.85rem;
-	font: inherit;
-	font-weight: 700;
-	font-size: 13px;
-	cursor: pointer;
-	transition: filter 0.12s;
-}
-.action-btn:hover {
-	filter: brightness(1.15);
-}
-.action-btn.actionable {
-	background: var(--gr-danger);
-	color: var(--gr-deep);
-}
-.action-btn.escalated {
-	background: #f0a060;
-	color: var(--gr-deep);
-}
-.action-btn.resolved {
-	background: var(--gr-aqua);
-	color: var(--gr-deep);
-}
-.action-btn.deferred {
-	background: var(--gr-warn);
-	color: var(--gr-deep);
-}
-
-/* ── Queue prompt ─────────────────────────────────────────────── */
-.queue-prompt {
-	padding: 0.5rem 0.75rem;
-	background: var(--gr-surface);
-	border: 1px dashed var(--gr-border);
-	border-radius: 6px;
-	font-size: 12.5px;
-	color: var(--gr-text-muted);
-}
-.queue-prompt strong {
-	color: var(--gr-warn);
-	font-family: var(--font-mono);
-}
-.inline-btn {
-	background: none;
-	border: none;
-	color: var(--gr-aqua);
-	font: inherit;
-	font-weight: 700;
-	cursor: pointer;
-	text-decoration: underline;
-}
-
-/* ── Finished banner ──────────────────────────────────────────── */
-.finished-banner {
-	padding: 0.75rem 1rem;
-	background: var(--gr-surface);
-	border: 1px solid var(--gr-aqua);
-	border-radius: 6px;
-	font-weight: 600;
-	display: flex;
-	align-items: center;
-	gap: 1rem;
-}
-
-/* ── Bins grid ────────────────────────────────────────────────── */
-.bins-grid {
-	display: grid;
-	grid-template-columns: repeat(4, 1fr);
-	gap: 0.5rem;
-	flex: 1 1 auto;
-	min-height: 200px;
-}
-@media (max-width: 1000px) {
-	.bins-grid {
-		grid-template-columns: repeat(2, 1fr);
-	}
-}
-.bin-column {
-	display: flex;
-	flex-direction: column;
-	min-height: 0;
-}
-.bin-header {
-	display: flex;
-	justify-content: space-between;
-	align-items: center;
-	padding: 0.35rem 0.5rem;
-	border-bottom: 2px solid;
-	font-size: 11px;
-	font-weight: 700;
-	text-transform: uppercase;
-	letter-spacing: 0.1em;
-	color: var(--gr-text-muted);
-}
-.bin-count {
-	font-family: var(--font-mono);
-	font-size: 14px;
-	font-weight: 800;
-}
-.bin-scroll {
-	flex: 1 1 auto;
-	overflow-y: auto;
-	display: flex;
-	flex-direction: column;
-	gap: 0.35rem;
-	padding: 0.35rem 0;
-	max-height: 320px;
-}
-button.bin-card,
-button.queue-item {
-	all: unset;
-	box-sizing: border-box;
-	cursor: pointer;
-}
-.bin-card {
-	background: var(--gr-surface);
-	border: 1px solid var(--gr-border-subtle);
-	border-radius: 6px;
-	padding: 0.4rem 0.55rem;
-	font-size: 11.5px;
-	text-align: left;
-	width: 100%;
-	color: var(--gr-text);
-	cursor: default;
-	transition: border-color 0.12s;
-}
-.bin-card.auto {
-	border-left: 2px solid var(--gr-aqua);
-}
-.card-top {
-	display: flex;
-	align-items: center;
-	gap: 0.4rem;
-}
-.card-id {
-	font-family: var(--font-mono);
-	font-size: 10px;
-	color: var(--gr-text-muted);
-}
-.severity-dot {
-	width: 6px;
-	height: 6px;
-	border-radius: 50%;
-	flex-shrink: 0;
-}
-.auto-badge {
-	font-family: var(--font-mono);
-	font-size: 9px;
-	color: var(--gr-aqua);
-	border: 1px solid var(--gr-aqua);
-	border-radius: 999px;
-	padding: 0 0.35em;
-	margin-left: auto;
-}
-.reason-badge {
-	font-family: var(--font-mono);
-	font-size: 9px;
-	border-radius: 999px;
-	padding: 0.05em 0.45em;
-	margin-left: auto;
-	letter-spacing: 0.02em;
-	cursor: help;
-	white-space: nowrap;
-}
-.reason-badge .reason-conf {
-	opacity: 0.75;
-}
-.reason-badge.reason-pattern {
-	color: var(--gr-aqua);
-	border: 1px solid var(--gr-aqua);
-	background: rgba(77, 232, 194, 0.08);
-}
-.reason-badge.reason-high-conf {
-	color: var(--gr-warn);
-	border: 1px solid var(--gr-warn);
-	background: rgba(240, 200, 106, 0.08);
-}
-.reason-badge.reason-timeout {
-	color: var(--gr-danger);
-	border: 1px solid var(--gr-danger);
-	background: rgba(239, 110, 122, 0.08);
-}
-.reason-badge.reason-manual {
-	color: var(--gr-text-muted);
-	border: 1px solid var(--gr-border);
-}
-.card-svc {
-	font-weight: 600;
-	font-size: 11px;
-	margin-top: 0.15rem;
-}
-.card-brief {
-	color: var(--gr-text-muted);
-	font-size: 10.5px;
-	margin-top: 0.1rem;
-	overflow: hidden;
-	text-overflow: ellipsis;
-	white-space: nowrap;
-}
-.defer-timer {
-	font-family: var(--font-mono);
-	font-size: 10px;
-	color: var(--gr-warn);
-	margin-top: 0.2rem;
-}
-
-/* ── Token bar ────────────────────────────────────────────────── */
-.token-bar {
-	background: var(--gr-surface);
-	border: 1px solid var(--gr-border-subtle);
-	border-radius: 6px;
-	padding: 0.6rem 0.85rem;
-}
-.token-bar h3 {
-	font-size: 10px;
-	letter-spacing: 0.12em;
-	text-transform: uppercase;
-	color: var(--gr-text-muted);
-	font-weight: 700;
-	margin-bottom: 0.35rem;
-}
-.token-stats {
-	display: flex;
-	gap: 1.25rem;
-	font-size: 12px;
-	color: var(--gr-text-muted);
-}
-.token-stats strong {
-	font-family: var(--font-mono);
-	color: var(--gr-text);
-}
-.cache-hit strong {
-	color: var(--gr-aqua);
-}
-
-/* ── Patterns panel ───────────────────────────────────────────── */
-.patterns-panel {
-	background: var(--gr-surface);
-	border: 1px solid var(--gr-border-subtle);
-	border-radius: 6px;
-	padding: 0.6rem 0.85rem;
-}
-.patterns-panel h3 {
-	font-size: 10px;
-	letter-spacing: 0.12em;
-	text-transform: uppercase;
-	color: var(--gr-text-muted);
-	font-weight: 700;
-	margin-bottom: 0.35rem;
-}
-.pattern-row {
-	display: flex;
-	align-items: center;
-	gap: 0.5rem;
-	padding: 0.25rem 0;
-	font-size: 12px;
-}
-.pattern-row code {
-	font-size: 11px;
-}
-.pattern-meta {
-	margin-left: auto;
-	font-size: 10.5px;
-	color: var(--gr-text-muted);
-	font-family: var(--font-mono);
-}
-
-/* ── Setup info block (pre-game instructions) ─────────────────── */
-.setup-info {
-	background: var(--gr-surface);
-	border: 1px solid var(--gr-border-subtle);
-	border-radius: 8px;
-	padding: 1rem 1.25rem;
-	display: flex;
-	flex-direction: column;
-	gap: 0.75rem;
-}
-.setup-info h3 {
-	font-size: 11px;
-	letter-spacing: 0.12em;
-	text-transform: uppercase;
-	color: var(--gr-aqua);
-	font-weight: 700;
-	margin-top: 0.4rem;
-}
-.setup-info h3:first-child {
-	margin-top: 0;
-}
-.setup-info ul,
-.setup-info ol {
-	padding-left: 1.25rem;
-	font-size: 13px;
-	color: var(--gr-text-muted);
-	line-height: 1.55;
-}
-.setup-info li {
-	margin-bottom: 0.35rem;
-}
-.setup-info strong {
-	color: var(--gr-text);
-}
-.setup-info em {
-	color: var(--gr-aqua);
-	font-style: normal;
-}
-.tempo-list {
-	list-style: none;
-	padding-left: 0;
-	font-family: var(--font-mono);
-	font-size: 12.5px;
-}
-.tempo-list li {
-	display: grid;
-	grid-template-columns: 9rem 12rem auto;
-	gap: 0.6rem;
-	padding: 0.15rem 0;
-	color: var(--gr-text);
-}
-.tempo-range {
-	color: var(--gr-aqua);
-	font-weight: 600;
-}
-.tempo-rate {
-	color: var(--gr-text);
-}
-.tempo-note {
-	color: var(--gr-text-muted);
-}
-
-/* ── Stat button (clickable queue count) ──────────────────────── */
-.stat-btn {
-	background: none;
-	border: 1px solid transparent;
-	border-radius: 6px;
-	padding: 0.2rem 0.45rem;
-	cursor: pointer;
-	font: inherit;
-	transition:
-		border-color 0.12s,
-		background 0.12s;
-}
-.stat-btn:hover:not(:disabled) {
-	border-color: var(--gr-aqua);
-	background: var(--gr-surface-raised);
-}
-.stat-btn:disabled {
-	cursor: default;
-	opacity: 0.65;
-}
-.stat-btn.active {
-	border-color: var(--gr-aqua);
-	background: var(--gr-aqua-glow);
-}
-.stat-value.warn {
-	color: var(--gr-warn);
-}
-.stat-value.small {
-	font-size: 11.5px;
-	font-weight: 600;
-	color: var(--gr-text-muted);
-	letter-spacing: 0.04em;
-}
-
-/* ── Header controls (pause / start pills) ───────────────────── */
-.header-controls {
-	margin-left: auto;
-	display: flex;
-	align-items: center;
-	gap: 0.5rem;
-}
-.btn-pill {
-	font-family: var(--font-mono);
-	font-size: 11px;
-	font-weight: 700;
-	letter-spacing: 0.08em;
-	text-transform: uppercase;
-	border: 1px solid var(--gr-border);
-	background: var(--gr-surface-raised);
-	color: var(--gr-text);
-	border-radius: 999px;
-	padding: 0.35em 0.9em;
-	cursor: pointer;
-	transition:
-		border-color 0.12s,
-		color 0.12s,
-		background 0.12s;
-}
-.btn-pill:hover {
-	border-color: var(--gr-aqua);
-}
-.btn-pill.pause {
-	border-color: var(--gr-warn);
-	color: var(--gr-warn);
-}
-.btn-pill.resume {
-	border-color: var(--gr-aqua);
-	background: var(--gr-aqua);
-	color: var(--gr-deep);
-}
-.btn-pill.start {
-	border-color: var(--gr-aqua);
-	background: var(--gr-aqua);
-	color: var(--gr-deep);
-}
-
-/* ── Ready / Pause banners ───────────────────────────────────── */
-.ready-banner {
-	padding: 0.75rem 1rem;
-	background: var(--gr-surface);
-	border: 1px dashed var(--gr-aqua);
-	border-radius: 6px;
-	font-size: 13px;
-	color: var(--gr-text-muted);
-}
-.ready-banner strong {
-	color: var(--gr-aqua);
-	margin-right: 0.25rem;
-}
-.pause-banner {
-	padding: 0.75rem 1rem;
-	background: rgba(240, 200, 106, 0.08);
-	border: 1px solid var(--gr-warn);
-	border-radius: 6px;
-	font-size: 13px;
-	color: var(--gr-text);
-}
-.pause-banner strong {
-	color: var(--gr-warn);
-	font-family: var(--font-mono);
-	letter-spacing: 0.12em;
-	margin-right: 0.4rem;
-}
-
-/* ── Focus pane (lower right) ────────────────────────────────── */
-.pane-focus {
-	flex: 1 1 auto;
-	display: flex;
-	flex-direction: column;
-	min-height: 0;
-	background: var(--gr-surface);
-}
-.pane-focus h3 {
-	font-size: 11px;
-	letter-spacing: 0.12em;
-	text-transform: uppercase;
-	color: var(--gr-text-muted);
-	padding: 0.6rem 1rem;
-	border-bottom: 1px solid var(--gr-border-subtle);
-	font-weight: 600;
-	display: flex;
-	align-items: center;
-	gap: 0.5rem;
-}
-.focus-source {
-	font-family: var(--font-mono);
-	font-size: 9.5px;
-	padding: 0.08em 0.55em;
-	border-radius: 999px;
-	text-transform: uppercase;
-	letter-spacing: 0.06em;
-	border: 1px solid;
-}
-.focus-source.queue {
-	color: var(--gr-aqua);
-	border-color: var(--gr-aqua);
-}
-.focus-source.actionable {
-	color: var(--gr-danger);
-	border-color: var(--gr-danger);
-}
-.focus-empty {
-	flex: 1 1 auto;
-	display: flex;
-	align-items: center;
-	justify-content: center;
-	color: var(--gr-text-muted);
-	font-size: 13px;
-	padding: 2rem;
-	text-align: center;
-}
-.focus-content {
-	flex: 1 1 auto;
-	display: flex;
-	flex-direction: column;
-	justify-content: space-between;
-	padding: 1.25rem;
-	gap: 1rem;
-	min-height: 0;
-}
-.focus-detail {
-	flex: 1 1 auto;
-	display: flex;
-	flex-direction: column;
-	align-items: center;
-	justify-content: center;
-	text-align: center;
-	gap: 0.6rem;
-	padding: 0.5rem 0.5rem 1rem;
-	overflow: auto;
-}
-.focus-ids {
-	display: flex;
-	align-items: center;
-	gap: 0.75rem;
-}
-.focus-ids .severity-badge {
-	font-size: 13.5px;
-}
-.focus-id {
-	font-family: var(--font-mono);
-	font-size: 14px;
-	color: var(--gr-text-muted);
-}
-.focus-service {
-	font-weight: 700;
-	font-size: 22px;
-	color: var(--gr-text);
-	letter-spacing: -0.01em;
-}
-.focus-summary {
-	font-family: var(--font-mono);
-	font-size: 16px;
-	color: var(--gr-text);
-	background: var(--gr-preview-bg);
-	border: 1px dashed var(--gr-border);
-	border-radius: 6px;
-	padding: 0.75rem 1rem;
-	max-width: 48rem;
-	line-height: 1.55;
-}
-.focus-brief {
-	display: flex;
-	flex-direction: column;
-	align-items: center;
-	gap: 0.25rem;
-	font-size: 15px;
-	color: var(--gr-text-muted);
-	margin-top: 0.2rem;
-}
-.focus-brief .brief-label {
-	font-size: 11px;
-	letter-spacing: 0.12em;
-	text-transform: uppercase;
-	color: var(--gr-aqua);
-	font-weight: 700;
-}
-.focus-brief .brief-text {
-	color: var(--gr-text);
-	max-width: 42rem;
-	font-size: 15px;
-	line-height: 1.5;
-}
-.focus-brief .confidence {
-	font-family: var(--font-mono);
-	font-size: 13px;
-	color: var(--gr-aqua-dim);
-}
-.in-progress-badge {
-	font-size: 11px;
-	letter-spacing: 0.1em;
-	text-transform: uppercase;
-	font-weight: 700;
-	color: var(--gr-warn);
-	background: rgba(240, 160, 96, 0.12);
-	border: 1px solid var(--gr-warn);
-	border-radius: 999px;
-	padding: 0.1rem 0.55rem;
-}
-.focus-actions .action-btn {
-	font-size: 14.5px;
-	padding: 0.55rem 1rem;
-}
-.focus-actions {
-	display: flex;
-	gap: 0.5rem;
-	flex-wrap: wrap;
-	justify-content: center;
-}
-.action-btn:disabled {
-	opacity: 0.35;
-	cursor: not-allowed;
-}
-
-/* ── Bin card selected state ─────────────────────────────────── */
-.bin-card.selected {
-	outline: 2px solid var(--gr-aqua);
-	outline-offset: -1px;
-}
-
-/* ── Queue list (side pane) — kept for legacy, unused ─────────── */
-.queue-list {
-	flex: 1 1 auto;
-	overflow-y: auto;
-	padding: 0.35rem 0.5rem;
-}
-.queue-item {
-	display: flex;
-	align-items: center;
-	gap: 0.5rem;
-	padding: 0.35rem 0.5rem;
-	border-radius: 4px;
-	cursor: pointer;
-	font-size: 12px;
-	transition: background 0.1s;
-}
-.queue-item:hover {
-	background: var(--gr-surface-raised);
-}
-.queue-item.selected {
-	background: var(--gr-aqua-glow);
-	border-left: 2px solid var(--gr-aqua);
-}
-.queue-id {
-	font-family: var(--font-mono);
-	font-size: 10px;
-	color: var(--gr-text-muted);
-	min-width: 4.5em;
-}
-.queue-svc {
-	font-weight: 600;
-	flex: 1 1 auto;
-	overflow: hidden;
-	text-overflow: ellipsis;
-	white-space: nowrap;
-}
-.queue-conf {
-	font-family: var(--font-mono);
-	font-size: 10px;
-	color: var(--gr-aqua-dim);
-}
-.queue-empty {
-	color: var(--gr-text-muted);
-	font-size: 12px;
-	padding: 1rem;
-	text-align: center;
-}
diff --git a/demos/pagerduty-triage/src/types/dom-chromium-ai.d.ts b/demos/pagerduty-triage/src/types/dom-chromium-ai.d.ts
deleted file mode 100644
index c5265809..00000000
--- a/demos/pagerduty-triage/src/types/dom-chromium-ai.d.ts
+++ /dev/null
@@ -1,67 +0,0 @@
-// Minimal ambient declarations for Chrome's built-in Prompt API
-// (https://developer.chrome.com/docs/ai/prompt-api). Hand-rolled so the demo
-// doesn't pull a third-party @types package.
-
-export {};
-
-declare global {
-	interface Window {
-		LanguageModel?: typeof LanguageModel;
-	}
-
-	type LanguageModelAvailability =
-		| "available"
-		| "readily"
-		| "after-download"
-		| "downloading"
-		| "downloadable"
-		| "unavailable";
-
-	interface LanguageModelMessage {
-		role: "system" | "user" | "assistant";
-		content: string;
-	}
-
-	interface LanguageModelExpectedIO {
-		type: "text";
-		languages?: readonly string[];
-	}
-
-	interface LanguageModelDownloadProgressEvent extends Event {
-		loaded: number;
-		total: number;
-	}
-
-	interface LanguageModelCreateOptions {
-		signal?: AbortSignal;
-		monitor?: (m: EventTarget) => void;
-		systemPrompt?: string;
-		initialPrompts?: readonly LanguageModelMessage[];
-		temperature?: number;
-		topK?: number;
-		expectedInputs?: readonly LanguageModelExpectedIO[];
-		expectedOutputs?: readonly LanguageModelExpectedIO[];
-	}
-
-	interface LanguageModelPromptOptions {
-		signal?: AbortSignal;
-		responseConstraint?: unknown;
-	}
-
-	interface LanguageModel extends EventTarget {
-		prompt(input: string, options?: LanguageModelPromptOptions): Promise<string>;
-		promptStreaming(input: string, options?: LanguageModelPromptOptions): ReadableStream<string>;
-		clone(options?: { signal?: AbortSignal }): Promise<LanguageModel>;
-		destroy(): void;
-
-		readonly inputUsage: number;
-		readonly inputQuota: number;
-	}
-
-	const LanguageModel: {
-		availability(options?: {
-			expectedInputs?: readonly LanguageModelExpectedIO[];
-		}): Promise<LanguageModelAvailability>;
-		create(options?: LanguageModelCreateOptions): Promise<LanguageModel>;
-	};
-}
diff --git a/demos/pagerduty-triage/tsconfig.json b/demos/pagerduty-triage/tsconfig.json
deleted file mode 100644
index b0c60a12..00000000
--- a/demos/pagerduty-triage/tsconfig.json
+++ /dev/null
@@ -1,8 +0,0 @@
-{
-	"extends": "astro/tsconfigs/strict",
-	"compilerOptions": {
-		"jsx": "react-jsx",
-		"jsxImportSource": "react",
-		"types": ["./src/types/dom-chromium-ai.d.ts"]
-	}
-}
diff --git a/demos/reactive-layout/astro.config.mjs b/demos/reactive-layout/astro.config.mjs
index 48ee11b4..6a4ea3a5 100644
--- a/demos/reactive-layout/astro.config.mjs
+++ b/demos/reactive-layout/astro.config.mjs
@@ -9,15 +9,13 @@ export default defineConfig({
 	vite: {
 		resolve: {
 			conditions: ["browser"],
-			dedupe: ["@graphrefly/pure-ts"],
+			dedupe: ["@graphrefly/ts"],
 		},
 		build: {
 			rollupOptions: {
-				// See knowledge-graph/astro.config for the rationale. The
-				// library's Node-only code paths (`fallbackAdapter`,
-				// `withReplayCache`, `fileStorage`, `sqliteStorage`) import
-				// `node:*` builtins; the demos never call them, but rollup
-				// tree-shakes the library dist and needs them externalized.
+				// The solution subpaths include optional Node-only adapters.
+				// This browser demo never calls them, but rollup still sees
+				// those imports while tree-shaking and needs them externalized.
 				external: ["@mlc-ai/web-llm", /^node:/],
 			},
 		},
diff --git a/demos/reactive-layout/package.json b/demos/reactive-layout/package.json
index 00ddf5b5..45d079a2 100644
--- a/demos/reactive-layout/package.json
+++ b/demos/reactive-layout/package.json
@@ -8,7 +8,7 @@
 		"preview": "astro preview"
 	},
 	"dependencies": {
-		"@graphrefly/graphrefly": "workspace:*",
+		"@graphrefly/ts": "workspace:*",
 		"@astrojs/react": "^4.0.0",
 		"@types/react": "^19.0.0",
 		"@types/react-dom": "^19.0.0",
diff --git a/demos/reactive-layout/src/components/App.tsx b/demos/reactive-layout/src/components/App.tsx
index e648d3f7..6dc9c82c 100644
--- a/demos/reactive-layout/src/components/App.tsx
+++ b/demos/reactive-layout/src/components/App.tsx
@@ -1,4 +1,3 @@
-import type { DemoShellHandle, HoverTarget } from "@graphrefly/graphrefly/utils/demo-shell";
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import { buildAdaptersChapter } from "../lib/chapters/adapters";
 import { buildBatchChapter } from "../lib/chapters/batch";
@@ -7,6 +6,7 @@ import { buildFlowChapter } from "../lib/chapters/flow";
 import { buildPlaygroundChapter } from "../lib/chapters/playground";
 import { buildRecomputesChapter } from "../lib/chapters/recomputes";
 import type { Chapter } from "../lib/chapters/types";
+import type { DemoShellHandle, HoverTarget } from "../lib/shell";
 import { focusChapter, getShell } from "../lib/shell";
 import CodePane from "./CodePane";
 import AdaptersChapterUI, { getAdaptersChapter } from "./chapters/AdaptersChapter";
@@ -18,6 +18,12 @@ import RecomputesChapterUI, { getRecomputesChapter } from "./chapters/Recomputes
 import GraphPane from "./GraphPane";
 import InspectStrip from "./InspectStrip";
 
+function requireShellNode(shell: DemoShellHandle, id: string) {
+	const node = shell.graph.find(id);
+	if (!node) throw new Error(`Reactive layout shell missing node '${id}'`);
+	return node;
+}
+
 // The getX helpers memoize the underlying chapter builders — they run once per
 // page. The `buildX` imports are retained above to keep them in the dependency
 // graph (tree-shaking safe) and so a consumer reading this file sees the full
@@ -126,9 +132,9 @@ export default function App() {
 		const shell = getShell();
 		shellRef.current = shell;
 
-		const mermaidNode = shell.graph.resolve("graph/mermaid");
-		const codeScrollNode = shell.graph.resolve("highlight/code-scroll");
-		const hoverNode = shell.graph.resolve("hover/target");
+		const mermaidNode = requireShellNode(shell, "graph/mermaid");
+		const codeScrollNode = requireShellNode(shell, "highlight/code-scroll");
+		const hoverNode = requireShellNode(shell, "hover/target");
 
 		const u1 = mermaidNode.subscribe(() => {
 			setMermaidText((mermaidNode.cache as string) ?? "");
diff --git a/demos/reactive-layout/src/components/InspectStrip.tsx b/demos/reactive-layout/src/components/InspectStrip.tsx
index 4e011460..7db5054b 100644
--- a/demos/reactive-layout/src/components/InspectStrip.tsx
+++ b/demos/reactive-layout/src/components/InspectStrip.tsx
@@ -1,6 +1,6 @@
-import type { Graph } from "@graphrefly/graphrefly";
-import type { DemoShellHandle } from "@graphrefly/graphrefly/utils/demo-shell";
+import type { Graph } from "@graphrefly/ts/graph";
 import { useEffect, useState } from "react";
+import type { DemoShellHandle } from "../lib/shell";
 
 type NodeDetail = {
 	path: string;
@@ -16,15 +16,32 @@ type MetaSnapshot = {
 	layoutTimeNs: bigint | null;
 };
 
+function segmentNodeId(graph: Graph): string | null {
+	const described = graph
+		.describe()
+		.nodes.find((node) => node.id === "segments" || node.id.endsWith(":segments"));
+	return described?.id ?? null;
+}
+
+function metaCache<T>(meta: Record<string, unknown>, key: string): T | null {
+	const value = meta[key];
+	if (value === null || typeof value !== "object" || !("cache" in value)) return null;
+	return (value as { cache?: T }).cache ?? null;
+}
+
 function readMetaSnapshot(graph: Graph | null): MetaSnapshot {
 	if (!graph) return { cacheHitRate: null, segmentCount: null, layoutTimeNs: null };
 	try {
-		const seg = graph.resolve("segments");
-		const meta = seg.meta ?? {};
+		const segmentsId = segmentNodeId(graph);
+		const described =
+			segmentsId === null
+				? undefined
+				: graph.describe().nodes.find((node) => node.id === segmentsId);
+		const meta = described?.meta ?? {};
 		return {
-			cacheHitRate: (meta["cache-hit-rate"]?.cache as number | null) ?? null,
-			segmentCount: (meta["segment-count"]?.cache as number | null) ?? null,
-			layoutTimeNs: (meta["layout-time-ns"]?.cache as bigint | null) ?? null,
+			cacheHitRate: metaCache<number>(meta, "cache-hit-rate"),
+			segmentCount: metaCache<number>(meta, "segment-count"),
+			layoutTimeNs: metaCache<bigint>(meta, "layout-time-ns"),
 		};
 	} catch {
 		return { cacheHitRate: null, segmentCount: null, layoutTimeNs: null };
@@ -50,7 +67,8 @@ export default function InspectStrip({
 	const [meta, setMeta] = useState<MetaSnapshot>(() => readMetaSnapshot(activeGraph));
 
 	useEffect(() => {
-		const nd = shell.graph.resolve("inspect/node-detail");
+		const nd = shell.graph.find("inspect/node-detail");
+		if (!nd) return;
 		const u = nd.subscribe(() => {
 			setDetail((nd.cache as NodeDetail | null) ?? null);
 		});
@@ -63,17 +81,12 @@ export default function InspectStrip({
 		if (!activeGraph) return;
 		// Subscribe to meta nodes on `segments` if present.
 		try {
-			const segs = activeGraph.resolve("segments");
-			const unsubs: Array<() => void> = [];
-			const m = segs.meta;
-			if (m) {
-				for (const n of Object.values(m)) {
-					unsubs.push(n.subscribe(() => setMeta(readMetaSnapshot(activeGraph))));
-				}
-			}
-			return () => {
-				for (const u of unsubs) u();
-			};
+			const segmentsId = segmentNodeId(activeGraph);
+			if (segmentsId === null) return;
+			const unsub = activeGraph
+				.observe(segmentsId)
+				.subscribe(() => setMeta(readMetaSnapshot(activeGraph)));
+			return () => unsub();
 		} catch {
 			return;
 		}
diff --git a/demos/reactive-layout/src/components/chapters/AdaptersChapter.tsx b/demos/reactive-layout/src/components/chapters/AdaptersChapter.tsx
index d08869c3..21c26cc1 100644
--- a/demos/reactive-layout/src/components/chapters/AdaptersChapter.tsx
+++ b/demos/reactive-layout/src/components/chapters/AdaptersChapter.tsx
@@ -1,4 +1,4 @@
-import type { LineBreaksResult } from "@graphrefly/graphrefly/utils/reactive-layout";
+import type { LineBreaksResult } from "@graphrefly/ts/solutions/reactive-layout";
 import { useEffect, useRef, useState } from "react";
 import { type AdaptersChapter, buildAdaptersChapter } from "../../lib/chapters/adapters";
 import { type ChapterProps, hoverProps } from "../../lib/chapters/types";
@@ -45,7 +45,7 @@ function useCanvasRender(
 export default function AdaptersChapterUI({ onHover }: ChapterProps) {
 	const chapter = getAdaptersChapter();
 	const [text, setText] = useState<string>(() => {
-		return (chapter.canvas.graph.resolve("text").cache as string) ?? "";
+		return (chapter.canvas.input.text.cache as string) ?? "";
 	});
 	const [maxWidth, setMaxWidth] = useState<number>(360);
 
diff --git a/demos/reactive-layout/src/components/chapters/BlocksChapter.tsx b/demos/reactive-layout/src/components/chapters/BlocksChapter.tsx
index 24fbe335..f8ae48bd 100644
--- a/demos/reactive-layout/src/components/chapters/BlocksChapter.tsx
+++ b/demos/reactive-layout/src/components/chapters/BlocksChapter.tsx
@@ -1,4 +1,4 @@
-import type { ContentBlock, PositionedBlock } from "@graphrefly/graphrefly/utils/reactive-layout";
+import type { ContentBlock, PositionedBlock } from "@graphrefly/ts/solutions/reactive-layout";
 import { useState } from "react";
 import { type BlocksChapter, buildBlocksChapter } from "../../lib/chapters/blocks";
 import { type ChapterProps, hoverProps } from "../../lib/chapters/types";
@@ -13,9 +13,9 @@ export function getBlocksChapter(): BlocksChapter {
 
 function textStyleForBlock(index: number): { font: string; lineHeight: number } {
 	const chapter = getBlocksChapter();
-	const blocks = chapter.bundle.graph.resolve("blocks").cache as ContentBlock[] | undefined;
+	const blocks = chapter.bundle.input.blocks.cache as readonly ContentBlock[] | undefined;
 	const src = blocks?.[index];
-	if (src?.type === "text") {
+	if (src?.kind === "text") {
 		return {
 			font: src.font ?? LAYOUT_FONT,
 			lineHeight: src.lineHeight ?? LAYOUT_LINE_HEIGHT,
@@ -24,10 +24,10 @@ function textStyleForBlock(index: number): { font: string; lineHeight: number }
 	return { font: LAYOUT_FONT, lineHeight: LAYOUT_LINE_HEIGHT };
 }
 
-function BlockRender({ block }: { block: PositionedBlock }) {
-	if (block.type === "text") {
-		const lines = block.textLineBreaks?.lines ?? [];
-		const { font, lineHeight } = textStyleForBlock(block.index);
+function BlockRender({ block, index }: { block: PositionedBlock; index: number }) {
+	if (block.kind === "text") {
+		const lines = block.lineBreaks?.lines ?? [];
+		const { font, lineHeight } = textStyleForBlock(index);
 		return (
 			<div
 				style={{
@@ -57,13 +57,8 @@ function BlockRender({ block }: { block: PositionedBlock }) {
 			</div>
 		);
 	}
-	if (block.type === "svg") {
-		const chapter = getBlocksChapter();
-		const raw = chapter.bundle.graph.resolve("blocks").cache as Array<{
-			type: string;
-			content?: string;
-		}>;
-		const src = raw?.[block.index]?.content ?? "";
+	if (block.kind === "svg") {
+		const src = block.block.kind === "svg" ? block.block.svg : "";
 		return (
 			<div
 				style={{ position: "absolute", left: block.x, top: block.y, width: block.width }}
@@ -137,8 +132,8 @@ export default function BlocksChapterUI({ onHover }: ChapterProps) {
 				data-block="all"
 				style={{ width: maxWidth, height: totalHeight ?? 0 }}
 			>
-				{(blockFlow ?? []).map((b) => (
-					<BlockRender key={b.index} block={b} />
+				{(blockFlow ?? []).map((b, index) => (
+					<BlockRender key={b.id ?? index} block={b} index={index} />
 				))}
 			</div>
 		</div>
diff --git a/demos/reactive-layout/src/components/chapters/FlowChapter.tsx b/demos/reactive-layout/src/components/chapters/FlowChapter.tsx
index 1bcf3e83..d88428fa 100644
--- a/demos/reactive-layout/src/components/chapters/FlowChapter.tsx
+++ b/demos/reactive-layout/src/components/chapters/FlowChapter.tsx
@@ -1,10 +1,10 @@
-import { DATA } from "@graphrefly/graphrefly";
-import { fromRaf } from "@graphrefly/graphrefly/base/sources/browser";
+import { graph } from "@graphrefly/ts/graph";
 import type {
 	FlowContainer,
+	FlowLinesResult,
 	Obstacle,
-	PositionedLine,
-} from "@graphrefly/graphrefly/utils/reactive-layout";
+} from "@graphrefly/ts/solutions/reactive-layout";
+import { fromRaf } from "@graphrefly/ts/sources/browser";
 import { useEffect, useRef, useState } from "react";
 import { buildFlowChapter, type FlowChapter } from "../../lib/chapters/flow.js";
 import { type ChapterProps, hoverProps } from "../../lib/chapters/types.js";
@@ -161,9 +161,9 @@ function driftObstacles(
 		let x = o.x + drift.vx * dt * 0.06;
 		let y = o.y + drift.vy * dt * 0.04;
 		const minX = padX;
-		const maxX = container.width - padX - o.w;
+		const maxX = container.width - padX - o.width;
 		const minY = padY;
-		const maxY = container.height - padY - o.h;
+		const maxY = container.height - padY - o.height;
 		if (x <= minX || x >= maxX) {
 			drift.vx *= -1;
 			x = Math.max(minX, Math.min(maxX, x));
@@ -178,17 +178,17 @@ function driftObstacles(
 
 export default function FlowChapterUI({ onHover }: ChapterProps) {
 	const chapter = getFlowChapter();
-	const lines = useNodeValue(chapter.bundle.flowLines) as PositionedLine[] | null;
+	const flowLines = useNodeValue(chapter.bundle.flowLines) as FlowLinesResult | null;
+	const lines = flowLines?.lines ?? null;
 	// Obstacles live in the graph — the demo reads them reactively and writes
 	// back via chapter.bundle.setObstacles. No React state for obstacles.
 	const obstacles =
-		(useNodeValue(chapter.bundle.graph.node("obstacles")) as Obstacle[] | null) ??
-		chapter.initialObstacles;
+		(useNodeValue(chapter.bundle.input.obstacles) as Obstacle[] | null) ?? chapter.initialObstacles;
 
 	const [paused, setPaused] = useState(false);
 	const [draggingIdx, setDraggingIdx] = useState<number | null>(null);
 	const [frameSize, setFrameSize] = useState<{ width: number; height: number }>(() => {
-		const c = chapter.bundle.graph.node("container").cache as FlowContainer;
+		const c = chapter.bundle.input.container.cache as FlowContainer;
 		return { width: c.width, height: c.height };
 	});
 	const dragRef = useRef<DragState | null>(null);
@@ -226,15 +226,14 @@ export default function FlowChapterUI({ onHover }: ChapterProps) {
 			vx: 0.18 + (i % 2 === 0 ? 0.05 : -0.04),
 			vy: 0.12 + (i % 2 === 0 ? -0.03 : 0.05),
 		}));
-		const raf = fromRaf();
+		const rafGraph = graph({ name: "flow-raf" });
+		const raf = rafGraph.initNode(fromRaf(), [], { name: "flow-raf/tick" });
 		let lastT = -1;
-		const unsub = raf.subscribe((msgs) => {
+		const unsub = raf.subscribe((msg) => {
 			// Collect the latest DATA timestamp in this batch (rAF is single-
 			// emission per tick, but batches can in principle coalesce).
 			let t = -1;
-			for (const m of msgs) {
-				if (m[0] === DATA) t = m[1] as number;
-			}
+			if (msg[0] === "DATA") t = msg[1] as number;
 			if (t < 0) return;
 			if (lastT < 0) {
 				lastT = t;
@@ -244,8 +243,8 @@ export default function FlowChapterUI({ onHover }: ChapterProps) {
 			lastT = t;
 			// Read current state each tick — avoids stale-closure bugs when
 			// the container is resized mid-animation.
-			const prev = chapter.bundle.graph.node("obstacles").cache as Obstacle[];
-			const container = chapter.bundle.graph.node("container").cache as FlowContainer;
+			const prev = chapter.bundle.input.obstacles.cache as Obstacle[];
+			const container = chapter.bundle.input.container.cache as FlowContainer;
 			const draggedIdx = dragRef.current?.obstacleIndex ?? -1;
 			const next = driftObstacles(prev, drifts, dt, container, draggedIdx);
 			chapter.bundle.setObstacles(next);
@@ -281,7 +280,7 @@ export default function FlowChapterUI({ onHover }: ChapterProps) {
 		if (!s) return;
 		const dx = e.clientX - s.startClientX;
 		const dy = e.clientY - s.startClientY;
-		const current = chapter.bundle.graph.node("obstacles").cache as Obstacle[];
+		const current = chapter.bundle.input.obstacles.cache as Obstacle[];
 		const next = [...current];
 		const o = next[s.obstacleIndex]!;
 		if (o.kind === "circle") {
@@ -337,8 +336,8 @@ export default function FlowChapterUI({ onHover }: ChapterProps) {
 					<div className="flow-lines" data-flow="lines">
 						{(lines ?? []).map((l, i, arr) => {
 							const isLast = i === arr.length - 1;
-							const textAlign = l.flushToRight ? "right" : "justify";
-							const textAlignLast = isLast ? "left" : l.flushToRight ? "right" : "justify";
+							const textAlign = "justify";
+							const textAlignLast = isLast ? "left" : "justify";
 							return (
 								<div
 									key={`${i}-${l.y}-${l.x}`}
@@ -380,7 +379,7 @@ export default function FlowChapterUI({ onHover }: ChapterProps) {
 									</div>
 								);
 							}
-							const ascii = renderRectAscii(o.x, o.y, o.w, o.h);
+							const ascii = renderRectAscii(o.x, o.y, o.width, o.height);
 							// No `width` / `height` styles — let the <pre> define its
 							// own rendered size (monospace glyph width isn't exactly
 							// CELL_W, so a cell-grid-based width would clip the left/
diff --git a/demos/reactive-layout/src/components/chapters/PlaygroundChapter.tsx b/demos/reactive-layout/src/components/chapters/PlaygroundChapter.tsx
index e63b9b3a..62e2a73b 100644
--- a/demos/reactive-layout/src/components/chapters/PlaygroundChapter.tsx
+++ b/demos/reactive-layout/src/components/chapters/PlaygroundChapter.tsx
@@ -1,8 +1,7 @@
-import type { DATA as _DATA } from "@graphrefly/graphrefly";
-import type { ReactiveLayoutBundle } from "@graphrefly/graphrefly/utils/reactive-layout";
 import { useState } from "react";
 import { buildPlaygroundChapter, type PlaygroundChapter } from "../../lib/chapters/playground";
 import { type ChapterProps, hoverProps } from "../../lib/chapters/types";
+import type { DemoReactiveLayoutBundle } from "../../lib/layout-bundles";
 import { LAYOUT_LINE_HEIGHT } from "../../lib/measure-adapter";
 import { useNodeValue } from "../../lib/use-node-value";
 
@@ -19,7 +18,7 @@ function ParagraphCard({
 	id,
 	onHover,
 }: {
-	bundle: ReactiveLayoutBundle;
+	bundle: DemoReactiveLayoutBundle;
 	id: string;
 	onHover: ChapterProps["onHover"];
 }) {
@@ -28,11 +27,11 @@ function ParagraphCard({
 	const segments = useNodeValue(bundle.segments);
 
 	const [text, setText] = useState<string>(() => {
-		const s = bundle.graph.resolve("text").cache;
+		const s = bundle.input.text.cache;
 		return (s as string) ?? "";
 	});
 	const [maxWidth, setMaxWidth] = useState<number>(() => {
-		const s = bundle.graph.resolve("max-width").cache;
+		const s = bundle.input.maxWidth.cache;
 		return (s as number) ?? 480;
 	});
 	const [fontSize, setFontSize] = useState<number>(14);
diff --git a/demos/reactive-layout/src/components/chapters/RecomputesChapter.tsx b/demos/reactive-layout/src/components/chapters/RecomputesChapter.tsx
index b2b80094..8ca802c3 100644
--- a/demos/reactive-layout/src/components/chapters/RecomputesChapter.tsx
+++ b/demos/reactive-layout/src/components/chapters/RecomputesChapter.tsx
@@ -27,10 +27,10 @@ export default function RecomputesChapterUI({ onHover }: ChapterProps) {
 	const lineBreaks = useNodeValue(chapter.bundle.lineBreaks);
 
 	const [text, setText] = useState<string>(() => {
-		return (chapter.bundle.graph.resolve("text").cache as string) ?? "";
+		return (chapter.bundle.input.text.cache as string) ?? "";
 	});
 	const [maxWidth, setMaxWidth] = useState<number>(() => {
-		return (chapter.bundle.graph.resolve("max-width").cache as number) ?? 520;
+		return (chapter.bundle.input.maxWidth.cache as number) ?? 520;
 	});
 
 	// Live counters — kept in React state via a tick so renders pick up refs.
diff --git a/demos/reactive-layout/src/lib/chapters/adapters.ts b/demos/reactive-layout/src/lib/chapters/adapters.ts
index 8c28cc45..37053d7f 100644
--- a/demos/reactive-layout/src/lib/chapters/adapters.ts
+++ b/demos/reactive-layout/src/lib/chapters/adapters.ts
@@ -1,18 +1,18 @@
-import type { NodeRegistry } from "@graphrefly/graphrefly/utils/demo-shell";
 import {
 	analyzeAndMeasure,
-	CliMeasureAdapter,
+	CellMeasureAdapter,
 	computeLineBreaks,
-	PrecomputedAdapter,
-	type ReactiveLayoutBundle,
-	reactiveLayout,
-} from "@graphrefly/graphrefly/utils/reactive-layout";
+	metricKey,
+	PrecomputedMeasureAdapter,
+} from "@graphrefly/ts/solutions/reactive-layout";
+import { createDemoReactiveLayout, type DemoReactiveLayoutBundle } from "../layout-bundles.js";
 import { getMeasurementAdapter, LAYOUT_FONT, LAYOUT_LINE_HEIGHT } from "../measure-adapter.js";
+import type { NodeRegistry } from "../shell.js";
 
 export const ADAPTERS_SOURCE = `// Same topology, three adapters.
 const canvas = reactiveLayout({ adapter: new CanvasMeasureAdapter(),   ...opts });
-const cli    = reactiveLayout({ adapter: new CliMeasureAdapter({ cellPx: 8 }), ...opts });
-const replay = reactiveLayout({ adapter: new PrecomputedAdapter({ metrics }),  ...opts });
+const cli    = createDemoReactiveLayout({ adapter: new CellMeasureAdapter({ cellWidth: 8 }), ...opts });
+const replay = createDemoReactiveLayout({ adapter: new PrecomputedMeasureAdapter({ metrics }),  ...opts });
 
 // Browser preview pixels in, ASCII cell math elsewhere, snapshot replay for SSR.
 // Subscribers to \`lineBreaks\` see the same structure — only the widths differ.
@@ -28,7 +28,7 @@ replay.lineBreaks.subscribe(ssr);
  * This is the demo's SSR story: one measurement pass produces a static JSON
  * blob that replays identically on any device.
  */
-function snapshotMetrics(text: string): Record<string, Record<string, number>> {
+function snapshotMetrics(text: string): Record<string, number> {
 	const adapter = getMeasurementAdapter();
 	const cache = new Map<string, Map<string, number>>();
 	analyzeAndMeasure(text, LAYOUT_FONT, adapter, cache);
@@ -36,17 +36,17 @@ function snapshotMetrics(text: string): Record<string, Record<string, number>> {
 	for (const ch of text) {
 		analyzeAndMeasure(ch, LAYOUT_FONT, adapter, cache);
 	}
-	const out: Record<string, Record<string, number>> = {};
+	const out: Record<string, number> = {};
 	for (const [font, segs] of cache) {
-		out[font] = Object.fromEntries(segs);
+		for (const [segment, width] of segs) out[metricKey(segment, font)] = width;
 	}
 	return out;
 }
 
 export type AdaptersChapter = {
-	canvas: ReactiveLayoutBundle;
-	cli: ReactiveLayoutBundle;
-	replay: ReactiveLayoutBundle;
+	canvas: DemoReactiveLayoutBundle;
+	cli: DemoReactiveLayoutBundle;
+	replay: DemoReactiveLayoutBundle;
 	setText: (t: string) => void;
 	setMaxWidth: (w: number) => void;
 	sourceCode: string;
@@ -59,7 +59,7 @@ export function buildAdaptersChapter(): AdaptersChapter {
 	// Fresh metrics for the precomputed adapter so replay can hit anything in seed.
 	const metrics = snapshotMetrics(seedText);
 
-	const canvas = reactiveLayout({
+	const canvas = createDemoReactiveLayout({
 		adapter: getMeasurementAdapter(),
 		name: "layout.canvas",
 		text: seedText,
@@ -68,8 +68,8 @@ export function buildAdaptersChapter(): AdaptersChapter {
 		maxWidth: 360,
 	});
 
-	const cli = reactiveLayout({
-		adapter: new CliMeasureAdapter({ cellPx: 8 }),
+	const cli = createDemoReactiveLayout({
+		adapter: new CellMeasureAdapter({ cellWidth: 8 }),
 		name: "layout.cli",
 		text: seedText,
 		font: LAYOUT_FONT,
@@ -77,8 +77,8 @@ export function buildAdaptersChapter(): AdaptersChapter {
 		maxWidth: 360,
 	});
 
-	const replay = reactiveLayout({
-		adapter: new PrecomputedAdapter({ metrics, fallback: "per-char" }),
+	const replay = createDemoReactiveLayout({
+		adapter: new PrecomputedMeasureAdapter({ metrics, fallback: "per-char" }),
 		name: "layout.replay",
 		text: seedText,
 		font: LAYOUT_FONT,
diff --git a/demos/reactive-layout/src/lib/chapters/batch.ts b/demos/reactive-layout/src/lib/chapters/batch.ts
index 1e886dfa..120e8d94 100644
--- a/demos/reactive-layout/src/lib/chapters/batch.ts
+++ b/demos/reactive-layout/src/lib/chapters/batch.ts
@@ -1,10 +1,7 @@
-import { batch } from "@graphrefly/graphrefly";
-import type { NodeRegistry } from "@graphrefly/graphrefly/utils/demo-shell";
-import {
-	type ReactiveLayoutBundle,
-	reactiveLayout,
-} from "@graphrefly/graphrefly/utils/reactive-layout";
+import { batch } from "@graphrefly/ts/core";
+import { createDemoReactiveLayout, type DemoReactiveLayoutBundle } from "../layout-bundles.js";
 import { getMeasurementAdapter, LAYOUT_FONT, LAYOUT_LINE_HEIGHT } from "../measure-adapter.js";
+import type { NodeRegistry } from "../shell.js";
 
 export const BATCH_SOURCE = `// Unbatched — 5 writes fan out as 5 separate recompute cycles.
 layout.setText("five");
@@ -33,8 +30,8 @@ export type BatchStats = {
 };
 
 export type BatchChapter = {
-	batched: ReactiveLayoutBundle;
-	unbatched: ReactiveLayoutBundle;
+	batched: DemoReactiveLayoutBundle;
+	unbatched: DemoReactiveLayoutBundle;
 	batchedStats: BatchStats;
 	unbatchedStats: BatchStats;
 	resetStats: () => void;
@@ -47,7 +44,7 @@ export type BatchChapter = {
 export function buildBatchChapter(): BatchChapter {
 	const adapter = getMeasurementAdapter();
 
-	const unbatched = reactiveLayout({
+	const unbatched = createDemoReactiveLayout({
 		adapter,
 		name: "layout.unbatched",
 		text: "Baseline: 5 sequential writes fan out to 5 recompute cycles.",
@@ -56,7 +53,7 @@ export function buildBatchChapter(): BatchChapter {
 		maxWidth: 420,
 	});
 
-	const batched = reactiveLayout({
+	const batched = createDemoReactiveLayout({
 		adapter,
 		name: "layout.batched",
 		text: "Wrapped in batch(): same 5 writes collapse into 1 cycle.",
@@ -97,7 +94,7 @@ export function buildBatchChapter(): BatchChapter {
 	let nonce = 0;
 	const applyFiveEdits = () => {
 		nonce += 1;
-		const writes = (b: ReactiveLayoutBundle) => {
+		const writes = (b: DemoReactiveLayoutBundle) => {
 			b.setText(`edit-${nonce}a`);
 			b.setFont(nonce % 2 === 0 ? LAYOUT_FONT : '15px "Fira Code", monospace');
 			b.setLineHeight(nonce % 2 === 0 ? 22 : 24);
diff --git a/demos/reactive-layout/src/lib/chapters/blocks.ts b/demos/reactive-layout/src/lib/chapters/blocks.ts
index 50e3605e..b4309bfd 100644
--- a/demos/reactive-layout/src/lib/chapters/blocks.ts
+++ b/demos/reactive-layout/src/lib/chapters/blocks.ts
@@ -1,11 +1,14 @@
-import type { NodeRegistry } from "@graphrefly/graphrefly/utils/demo-shell";
 import {
 	type ContentBlock,
-	type ReactiveBlockLayoutBundle,
-	reactiveBlockLayout,
+	ImageSizeAdapter,
 	SvgBoundsAdapter,
-} from "@graphrefly/graphrefly/utils/reactive-layout";
+} from "@graphrefly/ts/solutions/reactive-layout";
+import {
+	createDemoReactiveBlockLayout,
+	type DemoReactiveBlockLayoutBundle,
+} from "../layout-bundles.js";
 import { getMeasurementAdapter, LAYOUT_FONT, LAYOUT_LINE_HEIGHT } from "../measure-adapter.js";
+import type { NodeRegistry } from "../shell.js";
 
 export const BLOCKS_SOURCE = `// Mixed content as a reactive graph.
 const layout = reactiveBlockLayout({
@@ -15,10 +18,10 @@ const layout = reactiveBlockLayout({
   maxWidth: 520,
   gap: 16,
   blocks: [
-    { type: "text",  text: "A heading over the image." },
-    { type: "svg",   content: "<svg viewBox='0 0 160 48'>…</svg>" },
-    { type: "image", src: "hero.png", naturalWidth: 480, naturalHeight: 270 },
-    { type: "text",  text: "A caption paragraph that can wrap." },
+    { kind: "text",  text: "A heading over the image." },
+    { kind: "svg",   svg: "<svg viewBox='0 0 160 48'>…</svg>" },
+    { kind: "image", src: "hero.png", width: 480, height: 270 },
+    { kind: "text",  text: "A caption paragraph that can wrap." },
   ],
 });
 
@@ -31,7 +34,7 @@ const layout = reactiveBlockLayout({
 `;
 
 export type BlocksChapter = {
-	bundle: ReactiveBlockLayoutBundle;
+	bundle: DemoReactiveBlockLayoutBundle;
 	setMaxWidth: (w: number) => void;
 	sourceCode: string;
 	registry: NodeRegistry;
@@ -40,7 +43,7 @@ export type BlocksChapter = {
 export function buildBlocksChapter(): BlocksChapter {
 	const initialBlocks: ContentBlock[] = [
 		{
-			type: "text",
+			kind: "text",
 			text: "Mixed content layout — the heading before the art.",
 			font: '16px "Fira Code", monospace',
 			lineHeight: 24,
@@ -49,8 +52,8 @@ export function buildBlocksChapter(): BlocksChapter {
 			// Natural dimensions intentionally larger than any slider value so
 			// the block always scales down to the container — letting the user
 			// watch the SVG + the caption below reflow together.
-			type: "svg",
-			content: `<svg viewBox="0 0 1200 360" xmlns="http://www.w3.org/2000/svg">
+			kind: "svg",
+			svg: `<svg viewBox="0 0 1200 360" xmlns="http://www.w3.org/2000/svg">
   <defs>
     <linearGradient id="g" x1="0" x2="1">
       <stop offset="0" stop-color="#4de8c2"/>
@@ -63,23 +66,24 @@ export function buildBlocksChapter(): BlocksChapter {
 </svg>`,
 		},
 		{
-			type: "text",
+			kind: "text",
 			text: "A caption that wraps whenever you drag the width slider. Width constraints cascade into each block's measurement, then into the vertical flow.",
 		},
 		{
-			type: "image",
+			kind: "image",
 			src: "placeholder.png",
 			// Same idea: natural width > slider max so the ratio always binds.
-			naturalWidth: 1200,
-			naturalHeight: 450,
+			width: 1200,
+			height: 450,
 		},
 	];
 
-	const bundle = reactiveBlockLayout({
+	const bundle = createDemoReactiveBlockLayout({
 		adapters: {
 			text: getMeasurementAdapter(),
 			// Parse the inline SVG viewBox — no DOM, no async, pure string regex.
 			svg: new SvgBoundsAdapter(),
+			image: new ImageSizeAdapter({ "placeholder.png": { width: 1200, height: 450 } }),
 		},
 		name: "layout.blocks",
 		blocks: initialBlocks,
diff --git a/demos/reactive-layout/src/lib/chapters/flow.ts b/demos/reactive-layout/src/lib/chapters/flow.ts
index a84fc7c8..3837ef9c 100644
--- a/demos/reactive-layout/src/lib/chapters/flow.ts
+++ b/demos/reactive-layout/src/lib/chapters/flow.ts
@@ -1,12 +1,11 @@
-import type { Graph } from "@graphrefly/graphrefly";
-import type { NodeRegistry } from "@graphrefly/graphrefly/utils/demo-shell";
+import type { Graph } from "@graphrefly/ts/graph";
+import type { FlowContainer, Obstacle } from "@graphrefly/ts/solutions/reactive-layout";
 import {
-	type FlowContainer,
-	type Obstacle,
-	type ReactiveFlowLayoutBundle,
-	reactiveFlowLayout,
-} from "@graphrefly/graphrefly/utils/reactive-layout";
+	createDemoReactiveFlowLayout,
+	type DemoReactiveFlowLayoutBundle,
+} from "../layout-bundles.js";
 import { getMeasurementAdapter, LAYOUT_FONT, LAYOUT_LINE_HEIGHT } from "../measure-adapter.js";
+import type { NodeRegistry } from "../shell.js";
 
 export const FLOW_SOURCE = `// Multi-column text that wraps around moving ASCII obstacles.
 const flow = reactiveFlowLayout({
@@ -27,7 +26,7 @@ const flow = reactiveFlowLayout({
 // from the graph, computes bounce, and writes back via flow.setObstacles.
 // \`segments\` stays cached (text unchanged); only \`flow-lines\` re-runs.
 fromRaf().subscribe(([[, t]]) => {
-  flow.setObstacles(driftObstacles(flow.graph.node("obstacles").cache, t));
+  flow.setObstacles(driftObstacles(flow.input.obstacles.cache, t));
 });
 
 // The cursor carries across slots AND columns — no duplicated text
@@ -43,7 +42,7 @@ const FLOW_CONTAINER: FlowContainer = {
 
 export type FlowChapter = {
 	graph: Graph;
-	bundle: ReactiveFlowLayoutBundle;
+	bundle: DemoReactiveFlowLayoutBundle;
 	setContainerSize: (w: number, h: number) => void;
 	sourceCode: string;
 	registry: NodeRegistry;
@@ -60,12 +59,12 @@ export function buildFlowChapter(): FlowChapter {
 	const adapter = getMeasurementAdapter();
 
 	const initialObstacles: Obstacle[] = [
-		{ kind: "circle", cx: 170, cy: 140, r: 52, hPad: 18, vPad: 6 },
-		{ kind: "circle", cx: 440, cy: 300, r: 44, hPad: 18, vPad: 6 },
-		{ kind: "rect", x: 260, y: 430, w: 120, h: 62, hPad: 18, vPad: 6 },
+		{ kind: "circle", cx: 170, cy: 140, r: 52 },
+		{ kind: "circle", cx: 440, cy: 300, r: 44 },
+		{ kind: "rect", x: 260, y: 430, width: 120, height: 62 },
 	];
 
-	const bundle = reactiveFlowLayout({
+	const bundle = createDemoReactiveFlowLayout({
 		adapter,
 		name: "layout.flow",
 		text: ESSAY,
diff --git a/demos/reactive-layout/src/lib/chapters/playground.ts b/demos/reactive-layout/src/lib/chapters/playground.ts
index 00205f01..6ecf20c7 100644
--- a/demos/reactive-layout/src/lib/chapters/playground.ts
+++ b/demos/reactive-layout/src/lib/chapters/playground.ts
@@ -1,14 +1,11 @@
-import type { Graph } from "@graphrefly/graphrefly";
-import type { NodeRegistry } from "@graphrefly/graphrefly/utils/demo-shell";
-import {
-	type ReactiveLayoutBundle,
-	reactiveLayout,
-} from "@graphrefly/graphrefly/utils/reactive-layout";
+import type { Graph } from "@graphrefly/ts/graph";
+import { createDemoReactiveLayout, type DemoReactiveLayoutBundle } from "../layout-bundles.js";
 import { getMeasurementAdapter, LAYOUT_FONT, LAYOUT_LINE_HEIGHT } from "../measure-adapter.js";
+import type { NodeRegistry } from "../shell.js";
 
 export const PLAYGROUND_SOURCE = `// Create one reactive-layout graph. The 4 state inputs are the knobs;
 // the 4 derived outputs auto-recompute only along the paths they feed.
-const layout = reactiveLayout({
+const layout = createDemoReactiveLayout({
   adapter:    new CanvasMeasureAdapter(),
   text:       "GraphReFly — reactive text layout. 中文也能流畅分行。",
   font:       "14px Fira Code",
@@ -25,14 +22,14 @@ layout.setText("Try typing here.");
 layout.setMaxWidth(320);
 
 // Subscribe reactively — no timer, no re-read pattern.
-layout.lineBreaks.subscribe(([[type, v]]) => { if (type === DATA) render(v); });
+layout.lineBreaks.subscribe((msgs) => { for (const [type, v] of msgs) if (type === "DATA") render(v); });
 `;
 
 export type PlaygroundChapter = {
 	graph: Graph;
 	sourceCode: string;
 	registry: NodeRegistry;
-	bundles: ReactiveLayoutBundle[];
+	bundles: DemoReactiveLayoutBundle[];
 };
 
 /**
@@ -44,7 +41,7 @@ export type PlaygroundChapter = {
 export function buildPlaygroundChapter(): PlaygroundChapter {
 	const adapter = getMeasurementAdapter();
 
-	const intro = reactiveLayout({
+	const intro = createDemoReactiveLayout({
 		adapter,
 		name: "layout.intro",
 		text: "GraphReFly — text layout as a reactive graph. Change inputs, only the dependent derived nodes re-run.",
@@ -53,7 +50,7 @@ export function buildPlaygroundChapter(): PlaygroundChapter {
 		maxWidth: 480,
 	});
 
-	const cjk = reactiveLayout({
+	const cjk = createDemoReactiveLayout({
 		adapter,
 		name: "layout.cjk",
 		text: "中文也能流畅分行：标点不会出现在行首，CJK 字符按字形分割。Mixed scripts 同样正常。",
@@ -62,7 +59,7 @@ export function buildPlaygroundChapter(): PlaygroundChapter {
 		maxWidth: 480,
 	});
 
-	const emoji = reactiveLayout({
+	const emoji = createDemoReactiveLayout({
 		adapter,
 		name: "layout.emoji",
 		text: "Emoji 🚀, soft-hy­phens, and URLs like https://graphrefly.dev all keep their break points.",
diff --git a/demos/reactive-layout/src/lib/chapters/recomputes.ts b/demos/reactive-layout/src/lib/chapters/recomputes.ts
index d8dbd901..959fddd2 100644
--- a/demos/reactive-layout/src/lib/chapters/recomputes.ts
+++ b/demos/reactive-layout/src/lib/chapters/recomputes.ts
@@ -1,5 +1,3 @@
-import { monotonicNs } from "@graphrefly/graphrefly";
-import type { NodeRegistry } from "@graphrefly/graphrefly/utils/demo-shell";
 import {
 	analyzeAndMeasure,
 	computeCharPositions,
@@ -7,10 +5,10 @@ import {
 	type LineBreaksResult,
 	type MeasurementAdapter,
 	type PreparedSegment,
-	type ReactiveLayoutBundle,
-	reactiveLayout,
-} from "@graphrefly/graphrefly/utils/reactive-layout";
+} from "@graphrefly/ts/solutions/reactive-layout";
+import { createDemoReactiveLayout, type DemoReactiveLayoutBundle } from "../layout-bundles.js";
 import { getMeasurementAdapter, LAYOUT_FONT, LAYOUT_LINE_HEIGHT } from "../measure-adapter.js";
+import type { NodeRegistry } from "../shell.js";
 
 export const RECOMPUTES_SOURCE = `// Reactive mode — incremental recompute via equals + per-dep fan-out.
 const layout = reactiveLayout({ adapter, text, font, lineHeight, maxWidth });
@@ -57,7 +55,7 @@ export function runBaseline(
 	const t0 = monotonicNs();
 	const segments = analyzeAndMeasure(text, font, adapter, new Map());
 	stats.segmentsRuns += 1;
-	const lineBreaks = computeLineBreaks(segments, maxWidth, adapter, font, new Map());
+	const lineBreaks = computeLineBreaks(segments, maxWidth);
 	stats.lineBreaksRuns += 1;
 	const height = lineBreaks.lineCount * lineHeight;
 	stats.heightRuns += 1;
@@ -67,6 +65,10 @@ export function runBaseline(
 	return { segments, lineBreaks, height };
 }
 
+function monotonicNs(): bigint {
+	return BigInt(Math.round(performance.now() * 1_000_000));
+}
+
 export type ReactiveStats = {
 	segmentsRuns: number;
 	lineBreaksRuns: number;
@@ -85,7 +87,10 @@ export type ReactiveStats = {
  * where `segments` never re-runs — an earlier version tried that and the
  * reported time kept growing with wall-clock time between edits.
  */
-export function instrumentReactive(bundle: ReactiveLayoutBundle, stats: ReactiveStats): () => void {
+export function instrumentReactive(
+	bundle: DemoReactiveLayoutBundle,
+	stats: ReactiveStats,
+): () => void {
 	const unsubs: Array<() => void> = [];
 	unsubs.push(
 		bundle.segments.subscribe(() => {
@@ -125,7 +130,7 @@ export function timedReactive(stats: ReactiveStats, mutate: () => void): void {
 }
 
 export type RecomputesChapter = {
-	bundle: ReactiveLayoutBundle;
+	bundle: DemoReactiveLayoutBundle;
 	reactiveStats: ReactiveStats;
 	baselineStats: BaselineStats;
 	resetStats: () => void;
@@ -136,7 +141,7 @@ export type RecomputesChapter = {
 
 export function buildRecomputesChapter(): RecomputesChapter {
 	const adapter = getMeasurementAdapter();
-	const bundle = reactiveLayout({
+	const bundle = createDemoReactiveLayout({
 		adapter,
 		name: "layout.recomputes",
 		text: "Drag the width slider to see only line-breaks + downstream re-run. Type to see segments recompute as well.",
diff --git a/demos/reactive-layout/src/lib/chapters/types.ts b/demos/reactive-layout/src/lib/chapters/types.ts
index 06464473..14ab70af 100644
--- a/demos/reactive-layout/src/lib/chapters/types.ts
+++ b/demos/reactive-layout/src/lib/chapters/types.ts
@@ -1,6 +1,6 @@
-import type { Graph } from "@graphrefly/graphrefly";
-import type { HoverTarget, NodeRegistry } from "@graphrefly/graphrefly/utils/demo-shell";
+import type { Graph } from "@graphrefly/ts/graph";
 import type { ComponentType } from "react";
+import type { HoverTarget, NodeRegistry } from "../shell";
 
 /**
  * Props pair for any element that should light up a node-registry entry on
diff --git a/demos/reactive-layout/src/lib/layout-bundles.ts b/demos/reactive-layout/src/lib/layout-bundles.ts
new file mode 100644
index 00000000..9694ea59
--- /dev/null
+++ b/demos/reactive-layout/src/lib/layout-bundles.ts
@@ -0,0 +1,187 @@
+import type { Node } from "@graphrefly/ts/core";
+import { graph, type StateNode } from "@graphrefly/ts/graph";
+import {
+	type BlockAdapters,
+	blockMeasurementProvider,
+	type ContentBlock,
+	type FlowColumns,
+	type FlowContainer,
+	type MeasurementAdapter,
+	type Measurements,
+	type Obstacle,
+	type ReactiveBlockLayoutBundle,
+	type ReactiveFlowLayoutBundle,
+	type ReactiveLayoutBundle,
+	reactiveBlockLayout as reactiveBlockLayoutCore,
+	reactiveFlowLayout as reactiveFlowLayoutCore,
+	reactiveLayout as reactiveLayoutCore,
+	textMeasurementProvider,
+} from "@graphrefly/ts/solutions/reactive-layout";
+
+export type DemoReactiveLayoutBundle = ReactiveLayoutBundle & {
+	readonly input: ReactiveLayoutBundle["input"] & {
+		readonly text: StateNode<string>;
+		readonly font: StateNode<string>;
+		readonly adapter: StateNode<MeasurementAdapter>;
+	};
+	setText(text: string): void;
+	setFont(font: string): void;
+};
+
+export type DemoReactiveBlockLayoutBundle = ReactiveBlockLayoutBundle & {
+	readonly input: ReactiveBlockLayoutBundle["input"] & {
+		readonly blocks: StateNode<readonly ContentBlock[]>;
+		readonly maxWidth: StateNode<number>;
+		readonly adapters: StateNode<BlockAdapters>;
+		readonly font: StateNode<string>;
+		readonly lineHeight: StateNode<number>;
+	};
+	setBlocks(blocks: readonly ContentBlock[]): void;
+	setMaxWidth(maxWidth: number): void;
+	setFont(font: string): void;
+	setLineHeight(lineHeight: number): void;
+};
+
+export type DemoReactiveFlowLayoutBundle = ReactiveFlowLayoutBundle & {
+	readonly input: ReactiveFlowLayoutBundle["input"] & {
+		readonly text: StateNode<string>;
+		readonly font: StateNode<string>;
+		readonly adapter: StateNode<MeasurementAdapter>;
+	};
+	setText(text: string): void;
+	setFont(font: string): void;
+};
+
+export interface DemoReactiveLayoutOptions {
+	readonly adapter: MeasurementAdapter;
+	readonly name: string;
+	readonly text: string;
+	readonly font: string;
+	readonly lineHeight: number;
+	readonly maxWidth: number;
+}
+
+export interface DemoReactiveBlockLayoutOptions {
+	readonly adapters: BlockAdapters;
+	readonly name: string;
+	readonly blocks: readonly ContentBlock[];
+	readonly maxWidth: number;
+	readonly gap: number;
+	readonly defaultFont: string;
+	readonly defaultLineHeight: number;
+}
+
+export interface DemoReactiveFlowLayoutOptions {
+	readonly adapter: MeasurementAdapter;
+	readonly name: string;
+	readonly text: string;
+	readonly font: string;
+	readonly lineHeight: number;
+	readonly container: FlowContainer;
+	readonly columns: FlowColumns;
+	readonly obstacles: readonly Obstacle[];
+	readonly minSlotWidth: number;
+}
+
+function scopedName(scope: string, local: string): string {
+	return `${scope}:${local}`;
+}
+
+function textMeasurements(
+	g: ReturnType<typeof graph>,
+	name: string,
+	text: Node<string>,
+	font: Node<string>,
+	adapter: Node<MeasurementAdapter>,
+): Node<Measurements> {
+	return textMeasurementProvider({
+		graph: g,
+		text,
+		font,
+		adapter,
+		name: scopedName(name, "measurements"),
+	});
+}
+
+export function createDemoReactiveLayout(
+	opts: DemoReactiveLayoutOptions,
+): DemoReactiveLayoutBundle {
+	const g = graph({ name: opts.name });
+	const text = g.state(opts.text, { name: "text" });
+	const font = g.state(opts.font, { name: "font" });
+	const adapter = g.state(opts.adapter, { name: "adapter" });
+	const measurements = textMeasurements(g, opts.name, text, font, adapter);
+	const bundle = reactiveLayoutCore({
+		graph: g,
+		measurements,
+		name: opts.name,
+		lineHeight: opts.lineHeight,
+		maxWidth: opts.maxWidth,
+	});
+	return {
+		...bundle,
+		input: { ...bundle.input, text, font, adapter },
+		setText: (next) => text.set(next),
+		setFont: (next) => font.set(next),
+	};
+}
+
+export function createDemoReactiveBlockLayout(
+	opts: DemoReactiveBlockLayoutOptions,
+): DemoReactiveBlockLayoutBundle {
+	const g = graph({ name: opts.name });
+	const blocks = g.state(opts.blocks, { name: "blocks" });
+	const maxWidth = g.state(opts.maxWidth, { name: "max-width" });
+	const adapters = g.state(opts.adapters, { name: "adapters" });
+	const font = g.state(opts.defaultFont, { name: "font" });
+	const lineHeight = g.state(opts.defaultLineHeight, { name: "line-height" });
+	const measurements = blockMeasurementProvider({
+		graph: g,
+		blocks,
+		maxWidth,
+		adapters,
+		font,
+		lineHeight,
+		name: scopedName(opts.name, "measurements"),
+	});
+	const bundle = reactiveBlockLayoutCore({
+		graph: g,
+		measurements,
+		name: opts.name,
+		gap: opts.gap,
+	});
+	return {
+		...bundle,
+		input: { ...bundle.input, blocks, maxWidth, adapters, font, lineHeight },
+		setBlocks: (next) => blocks.set(next),
+		setMaxWidth: (next) => maxWidth.set(next),
+		setFont: (next) => font.set(next),
+		setLineHeight: (next) => lineHeight.set(next),
+	};
+}
+
+export function createDemoReactiveFlowLayout(
+	opts: DemoReactiveFlowLayoutOptions,
+): DemoReactiveFlowLayoutBundle {
+	const g = graph({ name: opts.name });
+	const text = g.state(opts.text, { name: "text" });
+	const font = g.state(opts.font, { name: "font" });
+	const adapter = g.state(opts.adapter, { name: "adapter" });
+	const measurements = textMeasurements(g, opts.name, text, font, adapter);
+	const bundle = reactiveFlowLayoutCore({
+		graph: g,
+		measurements,
+		name: opts.name,
+		lineHeight: opts.lineHeight,
+		container: opts.container,
+		columns: opts.columns,
+		obstacles: opts.obstacles,
+		minSlotWidth: opts.minSlotWidth,
+	});
+	return {
+		...bundle,
+		input: { ...bundle.input, text, font, adapter },
+		setText: (next) => text.set(next),
+		setFont: (next) => font.set(next),
+	};
+}
diff --git a/demos/reactive-layout/src/lib/measure-adapter.ts b/demos/reactive-layout/src/lib/measure-adapter.ts
index 2fff435d..72b91102 100644
--- a/demos/reactive-layout/src/lib/measure-adapter.ts
+++ b/demos/reactive-layout/src/lib/measure-adapter.ts
@@ -1,7 +1,5 @@
-import {
-	CanvasMeasureAdapter,
-	type MeasurementAdapter,
-} from "@graphrefly/graphrefly/utils/reactive-layout";
+import type { MeasurementAdapter } from "@graphrefly/ts/solutions/reactive-layout";
+import { CanvasMeasureAdapter } from "@graphrefly/ts/solutions/reactive-layout/browser";
 
 export const LAYOUT_FONT = '14px "Fira Code", ui-monospace, monospace';
 export const LAYOUT_LINE_HEIGHT = 22;
diff --git a/demos/reactive-layout/src/lib/mermaid-render.ts b/demos/reactive-layout/src/lib/mermaid-render.ts
index 848b6c4e..9ea8f2ae 100644
--- a/demos/reactive-layout/src/lib/mermaid-render.ts
+++ b/demos/reactive-layout/src/lib/mermaid-render.ts
@@ -10,7 +10,7 @@ import {
 export { MERMAID_NODE_STROKE_DEFAULT, MERMAID_NODE_STROKE_MATCH, MERMAID_THEME_VARIABLES };
 
 export function initMermaid(): void {
-	initMermaidRenderer(mermaid);
+	initMermaidRenderer(mermaid as Parameters<typeof initMermaidRenderer>[0]);
 }
 
 export const nextMermaidId = createNextMermaidId("reactive-layout");
diff --git a/demos/reactive-layout/src/lib/shell.ts b/demos/reactive-layout/src/lib/shell.ts
index 8ed13b28..9cc788df 100644
--- a/demos/reactive-layout/src/lib/shell.ts
+++ b/demos/reactive-layout/src/lib/shell.ts
@@ -1,41 +1,127 @@
-import type { Graph } from "@graphrefly/graphrefly";
-import {
-	type DemoShellHandle,
-	demoShell,
-	type NodeRegistry,
-} from "@graphrefly/graphrefly/utils/demo-shell";
-import { getMeasurementAdapter, LAYOUT_FONT } from "./measure-adapter.js";
-
-/**
- * Single mutable registry. `demoShell()` captures it by reference at creation
- * time; its `highlight/code-scroll` / `highlight/visual` derived nodes read
- * through it on every fire, so clearing + repopulating this Map is enough to
- * re-point cross-highlighting to the new chapter.
- */
-const liveRegistry: NodeRegistry = new Map();
+import type { Node } from "@graphrefly/ts/core";
+import { batch } from "@graphrefly/ts/core";
+import { type Graph, graph } from "@graphrefly/ts/graph";
+import { describeToMermaid } from "@graphrefly/ts/render";
+
+export type HoverTarget = { pane: "visual" | "graph" | "code"; id: string } | null;
+
+export type NodeRegistryEntry = {
+	readonly codeLine?: number | null;
+	readonly visualSelector?: string | null;
+};
+
+export type NodeRegistry = Map<string, NodeRegistryEntry>;
+
+export type DemoShellHandle = {
+	readonly graph: Graph;
+	batch<T>(fn: () => T): T;
+	setDemoGraph(graph: Graph): void;
+	setCodeText(source: string): void;
+	selectNode(path: string | null): void;
+	setHoverTarget(target: HoverTarget): void;
+	setMainRatio(ratio: number): void;
+	setSideSplit(ratio: number): void;
+	setViewportWidth(width: number): void;
+	bumpGraphTick(): void;
+};
 
+type NodeDetail = {
+	path: string;
+	kind?: string;
+	value?: unknown;
+	status?: string;
+};
+
+const liveRegistry: NodeRegistry = new Map();
 let shell: DemoShellHandle | null = null;
 
-/** Page-level singleton (created once per mount). */
-export function getShell(viewportWidth?: number): DemoShellHandle {
-	if (!shell) {
-		shell = demoShell({
-			mainRatio: 0.58,
-			viewportWidth: viewportWidth ?? window.innerWidth,
-			adapter: getMeasurementAdapter(),
-			layoutFont: LAYOUT_FONT,
-			nodeRegistry: liveRegistry,
-		});
+function registryEntry(id: string | null): NodeRegistryEntry | undefined {
+	if (id === null) return undefined;
+	const exact = liveRegistry.get(id);
+	if (exact) return exact;
+	for (const [key, value] of liveRegistry) {
+		if (id.endsWith(`:${key}`) || id.includes(key) || key.includes(id)) return value;
 	}
+	return undefined;
+}
+
+function findNode(g: Graph | null, id: string | null): Node<unknown> | undefined {
+	if (g === null || id === null) return undefined;
+	const exact = g.find(id);
+	if (exact) return exact;
+	const local = g.find(id.replace(/^.*:/, ""));
+	if (local) return local;
+	const described = g
+		.describe()
+		.nodes.find((node) => id.endsWith(`:${node.id}`) || node.id.endsWith(`:${id}`));
+	return described ? g.find(described.id) : undefined;
+}
+
+function nodeDetail(g: Graph | null, id: string | null): NodeDetail | null {
+	const node = findNode(g, id);
+	if (!node || id === null) return null;
+	const described = g
+		?.describe()
+		.nodes.find((entry) => entry.id === id || id.endsWith(`:${entry.id}`));
+	return {
+		path: described?.id ?? id,
+		kind: described?.factory,
+		value: node.cache,
+		status: node.status,
+	};
+}
+
+export function getShell(viewportWidth?: number): DemoShellHandle {
+	if (shell) return shell;
+	const g = graph({ name: "reactive-layout-demo-shell" });
+	const demoGraph = g.state<Graph | null>(null, { name: "graph/current" });
+	const sourceCode = g.state("", { name: "source/code" });
+	const selectedNode = g.state<string | null>(null, { name: "selected/node" });
+	const hoverTarget = g.state<HoverTarget>(null, { name: "hover/target" });
+	const mainRatio = g.state(0.58, { name: "layout/main-ratio" });
+	const sideSplit = g.state(0.5, { name: "layout/side-split" });
+	const viewport = g.state(viewportWidth ?? window.innerWidth, { name: "layout/viewport-width" });
+	const graphTick = g.state(0, { name: "graph/tick" });
+
+	g.derived(
+		[demoGraph, graphTick],
+		(current) => {
+			if (current === null) return "";
+			return describeToMermaid(current.describe(), { direction: "TD" });
+		},
+		{ name: "graph/mermaid" },
+	);
+	g.derived(
+		[hoverTarget, selectedNode, graphTick],
+		(hover, selected) => {
+			const id = hover?.id ?? selected;
+			return registryEntry(id)?.codeLine ?? null;
+		},
+		{ name: "highlight/code-scroll" },
+	);
+	g.derived(
+		[demoGraph, hoverTarget, selectedNode, graphTick],
+		(current, hover, selected) => {
+			return nodeDetail(current, hover?.id ?? selected);
+		},
+		{ name: "inspect/node-detail" },
+	);
+
+	shell = {
+		graph: g,
+		batch,
+		setDemoGraph: (next) => demoGraph.set(next),
+		setCodeText: (next) => sourceCode.set(next),
+		selectNode: (next) => selectedNode.set(next),
+		setHoverTarget: (next) => hoverTarget.set(next),
+		setMainRatio: (next) => mainRatio.set(next),
+		setSideSplit: (next) => sideSplit.set(next),
+		setViewportWidth: (next) => viewport.set(next),
+		bumpGraphTick: () => graphTick.set(((graphTick.cache as number | undefined) ?? 0) + 1),
+	};
 	return shell;
 }
 
-/**
- * Atomically repoint the shell at a chapter's graph + source + registry.
- * The `batch()` coalesces every state write so downstream derived nodes
- * (`graph/mermaid`, `layout/code-lines`, `highlight/*`) fire once per tab
- * switch — the same batching story chapter C demonstrates in the main pane.
- */
 export function focusChapter(
 	s: DemoShellHandle,
 	chapter: { graph: Graph; sourceCode: string; registry: NodeRegistry },
diff --git a/demos/reactive-layout/src/lib/use-node-value.ts b/demos/reactive-layout/src/lib/use-node-value.ts
index 20dc243c..b8da24fc 100644
--- a/demos/reactive-layout/src/lib/use-node-value.ts
+++ b/demos/reactive-layout/src/lib/use-node-value.ts
@@ -1,4 +1,4 @@
-import type { Node } from "@graphrefly/graphrefly";
+import type { Node } from "@graphrefly/ts/core";
 import { useEffect, useState } from "react";
 
 /**
diff --git a/docs/docs-guidance.md b/docs/docs-guidance.md
index c510fee6..1937ff5a 100644
--- a/docs/docs-guidance.md
+++ b/docs/docs-guidance.md
@@ -30,9 +30,9 @@ The TS library ships a **three-tier subpath convention** so browser and Node con
 
 | Tier | Subpath shape | Contains | Allowed imports |
 |------|--------------|----------|-----------------|
-| **Universal** (default) | `@graphrefly/graphrefly`, `@graphrefly/graphrefly/extra`, `@graphrefly/graphrefly/utils/<domain>` | Protocol, operators, reactive data structures, pattern factories that don't touch filesystem / DOM | Core, `core/hash` (uses `globalThis.crypto.subtle`), `storage-core`, other universal extras. Zero `node:*`. Zero DOM globals. |
-| **Node-only** | `@graphrefly/graphrefly/extra/node`, `@graphrefly/graphrefly/utils/<domain>/node` | Filesystem sources, SQLite storage, `child_process` adapters, Node-specific middleware | May import `node:*`. May import universal modules. |
-| **Browser-only** | `@graphrefly/graphrefly/extra/browser`, `@graphrefly/graphrefly/utils/<domain>/browser` | IndexedDB storage, WebLLM / Chrome Nano adapters, DOM-specific helpers | May use `window`, `document`, `indexedDB`, `Worker` globals. May import universal modules. |
+| **Universal** (default) | `@graphrefly/ts/<capability>` | Protocol, graph, operators, storage contracts, renderers, and DOM-free solutions | Zero `node:*`. Zero DOM globals. |
+| **Node-only** | `@graphrefly/ts/<capability>/node` or focused node subpaths | Filesystem or Node runtime adapters | May import `node:*`. May import universal modules. |
+| **Browser-only** | `@graphrefly/ts/<capability>/browser` or focused browser subpaths | IndexedDB, Canvas, DOM, browser workers, and other browser-only helpers | May use browser globals. May import universal modules. |
 
 **Rule of thumb:** pick the lowest tier that can execute your code. A pattern factory that *mentions* `fileStorage` in its JSDoc but doesn't import it stays universal; a factory that *calls* `fileStorage()` must live under `<domain>/node`.
 
@@ -64,7 +64,7 @@ Cross-reference: the exports map is `sideEffects: false` — individual entries
 
 ### Writing JSDoc for node-only / browser-only APIs
 
-- **Single-tier symbol:** JSDoc `@example` imports from the correct subpath — `import { fileStorage } from "@graphrefly/graphrefly/extra/node"`, not `"@graphrefly/graphrefly/extra"`.
+- **Single-tier symbol:** JSDoc `@example` imports from the correct `@graphrefly/ts` subpath for that symbol.
 - **Adapter with both tiers** (e.g. `fallbackAdapter`): the browser-safe base lives in `patterns/ai`, the Node-extended variant in `patterns/ai/node`. Each file's JSDoc `@example` uses its own subpath; cross-reference the other via `{@link }` or a prose note.
 - **Aggregator files** (`extra/node.ts`, `patterns/<x>/browser.ts`): have a `@module` docstring explaining what the aggregator is for and which global APIs it assumes.
 
@@ -75,7 +75,7 @@ Cross-reference: the exports map is `sideEffects: false` — individual entries
 | Tier | What | TS | PY |
 |------|------|----|----|
 | **0 — Protocol spec** | `~/src/graphrefly/GRAPHREFLY-SPEC.md` | Both sites via `sync-docs.mjs` | Both sites via `sync-docs.mjs` |
-| **1 — JSDoc / Docstrings** | Structured doc blocks on exports | `src/**/*.ts` → `gen-api-docs.mjs` → `website/src/content/docs/api/` | `src/graphrefly/**/*.py` → `gen_api_docs.py` → `website/src/content/docs/api/` |
+| **1 — JSDoc / Docstrings** | Structured doc blocks on exports | `packages/ts/src/**/*.ts`; TS API pages are currently a hand-vetted clean-slate allowlist | `src/graphrefly/**/*.py` → `gen_api_docs.py` → `website/src/content/docs/api/` |
 | **2 — Runnable examples** | Self-contained scripts | `examples/*.ts` | `examples/*.py` (in graphrefly-py) |
 | **3 — Recipes / guides** | Long-form Starlight pages | `website/src/content/docs/recipes/` | `website/src/content/docs/recipes/` (in graphrefly-py) |
 | **4 — Interactive demos** | Live UI / Pyodide labs | `website/src/components/examples/` (Astro) | `website/src/content/docs/lab/` (Pyodide) |
@@ -96,17 +96,7 @@ Cross-reference: the exports map is `sideEffects: false` — individual entries
 
 ### TypeScript
 
-API reference pages (`website/src/content/docs/api/*.md`) are **generated** from structured JSDoc on exported functions via `website/scripts/gen-api-docs.mjs`.
-
-```bash
-pnpm --filter @graphrefly/docs-site docs:gen              # regenerate all
-pnpm --filter @graphrefly/docs-site docs:gen node map      # specific functions
-pnpm --filter @graphrefly/docs-site docs:gen:check         # CI dry-run — exit 1 if stale
-```
-
-**Do NOT edit `website/src/content/docs/api/*.md` by hand** — edit the JSDoc in source, then run `docs:gen`.
-
-To add a new function, register it in `website/scripts/gen-api-docs.mjs` in the `REGISTRY` object.
+The old TypeScript API generator was retired with the legacy root/pure-ts docs source. Current TS API reference pages are a small, hand-vetted clean-slate allowlist backed by real `@graphrefly/ts` export-map entries. A replacement generator must fail closed from `packages/ts/package.json` exports plus an explicit allowlist; do not map old symbols to guessed subpaths.
 
 ### Python
 
@@ -181,7 +171,7 @@ Every exported function must have a structured JSDoc block. The generator reads
 
 - **Description:** One or two sentences. Start with a verb ("Creates", "Transforms").
 - **@param:** Use `@param name - Description.` (the `- ` is stripped by the generator).
-- **@example:** First example has no title (becomes "Basic Usage"). Additional examples have a title. Use the correct install package for the symbol's tier: `@graphrefly/pure-ts` (substrate), `@graphrefly/graphrefly` (presentation), or a subpath (`@graphrefly/graphrefly/extra/node`, `@graphrefly/graphrefly/base/sources/browser`, etc.) per the browser/Node/universal split above.
+- **@example:** First example has no title (becomes "Basic Usage"). Additional examples have a title. Import from the narrowest real `@graphrefly/ts` subpath for the symbol.
 - **@remarks:** One per bullet. Start with `**Bold keyword:**`.
 - **Overloaded functions:** Put the structured JSDoc above the **implementation** (the declaration with a body).
 
diff --git a/docs/implementation-plan-13.6-canonical-spec.md b/docs/implementation-plan-13.6-canonical-spec.md
index 0f64cf9f..33c99f4a 100644
--- a/docs/implementation-plan-13.6-canonical-spec.md
+++ b/docs/implementation-plan-13.6-canonical-spec.md
@@ -1,5 +1,11 @@
 # GraphReFly Canonical Spec & Invariants (post-Phase 13.6.A)
 
+> **Old-main reference, not clean-slate authority.** This document predates the
+> clean-slate jsonl spec system. For current protocol decisions, use
+> `~/src/graphrefly/spec/rules.jsonl` and the D# log. In particular, clean-slate
+> has a closed 10-message set, no `MessageTypeRegistry`/custom message types,
+> and `messageTier` is a compile-time const table (R-msg-closed-set, R-tier, D18/D34).
+
 *Consolidated source-of-truth for the GraphReFly protocol, primitives, container, patterns, and invariants — incorporating the 24 locks resolved in `implementation-plan-13.6-locks-draft.md`. Supersedes the multi-file split (`GRAPHREFLY-SPEC.md` + `COMPOSITION-GUIDE-*.md`) for read-once handoff.*
 
 **Status:** post-Phase 13.6.A audit, pre-implementation. The canonical text below describes what the spec + composition guide WILL be after the lock-driven edits land. Use this for Rust port; the underlying TS edit work is tracked under Phase 13.6.B.
@@ -2193,4 +2199,3 @@ For your final review pass, cross-check:
 - **Implementation Delta #18** (sugars on Graph in TS, in core in Rust) — re-confirm the divergence is acceptable.
 
 After your review, the next step is to either (a) execute the canonical edits per the dev-dispatch normal workflow (Phase 3), or (b) hand off to the Rust port agent.
-
diff --git a/docs/implementation-plan-13.6-flowcharts.md b/docs/implementation-plan-13.6-flowcharts.md
index 38fd167d..ceb65c38 100644
--- a/docs/implementation-plan-13.6-flowcharts.md
+++ b/docs/implementation-plan-13.6-flowcharts.md
@@ -1,5 +1,11 @@
 # GraphReFly Canonical Flowcharts (post-Phase 13.6.A)
 
+> **Old-main reference, not clean-slate authority.** These diagrams predate the
+> clean-slate jsonl spec system. For current protocol decisions, use
+> `~/src/graphrefly/spec/rules.jsonl` and the D# log; clean-slate has a closed
+> 10-message set, no `MessageTypeRegistry`/custom message types, and `messageTier`
+> is a compile-time const table (R-msg-closed-set, R-tier, D18/D34).
+
 *Mermaid diagrams covering all internal methods, properties, and processes from protocol level upward. Companion to `implementation-plan-13.6-canonical-spec.md`. Use side-by-side: each diagram references the canonical spec rules (`R<x.y.z>`) it visualizes.*
 
 **Batch status:**
diff --git a/docs/known-issues.md b/docs/known-issues.md
index a04e3cc2..59139608 100644
--- a/docs/known-issues.md
+++ b/docs/known-issues.md
@@ -1,50 +1,33 @@
-# Known issues — deferred to post-Rust-port
+# Known issues
 
-## Demos disabled in `docs:build` pending API migration
+## HISTORICAL — pre-CSP-9 browser demos retired from active workspace
 
-**Symptom:** `pnpm run docs:build` previously ran 4 demos under `demos/`; 3 of them now fail with errors like `"state" is not exported by ... dist/core/index.js, imported by src/lib/counter.ts`.
+**Symptom:** `demos/knowledge-graph/` and `demos/pagerduty-triage/`
+still import retired root/pure-ts surfaces such as old AI utilities,
+`agentMemory`, and `utils/demo-shell`.
 
-**Cause:** The standalone `state` / `derived` / `producer` / `effect` exports were removed from `packages/pure-ts/src/core/sugar.ts` at some point during the Graph narrow-waist refactor (per `project_graph_narrow_waist.md` memory). The "Graph narrow-waist" decision moved these to Graph methods (`Graph.state()` / `Graph.derived()` / `Graph.effect()` / `Graph.produce()`), but the migration of demos / examples / generated docs that still consume the old standalone API was never completed.
+**Cause:** those browser demos were authored before CSP-9/B65/B66 retired
+`@graphrefly/graphrefly` as an implementation owner and froze pure-ts as
+reference-only material.
 
-**Affected callers** (NOT migrated yet):
+**Resolution:** the demos are historical references only. They are not active
+workspace packages, not advertised as runnable clean-slate demos, and should not
+be migrated by reviving compatibility shims. Re-activation requires a separate
+design/migration slice over current `@graphrefly/ts` public subpaths.
+
+Known historical callers:
 - `demos/knowledge-graph/src/lib/{lazy-adapter.ts, chapters/reactive.ts}`
 - `demos/pagerduty-triage/src/lib/pipeline.ts`
-- `examples/basic/state-and-derived/index.ts`
-- `examples/framework/{react,solid,svelte,vue}/src/store.ts`
-- `examples/{harness-refine-hello, inbox-reducer, knowledge-graph, reactive-layout, spending-alerts}/*.ts`
-- `packages/cli/tests/dispatch.test.ts` (not in `pnpm test` path; not blocking)
-- 100+ generated `website/src/content/docs/api/*.md` (auto-regenerated; will heal once symbols are re-added or REGISTRY is migrated)
-- `website/scripts/gen-api-docs.mjs` REGISTRY (218 entries point at the missing symbols)
-
-**Workaround in place:** Root `package.json` `docs:build` ships `compat-matrix` + `reactive-layout`; `knowledge-graph` and `pagerduty-triage` remain skipped until migrated. CI is unblocked for the shipped demos; the two skipped demos are NOT in the website static output.
-
-**Decision deferred to:** post-Rust-port (after M5 close + facade build, per PART 13 of `archive/docs/SESSION-rust-port-architecture.md`). Two paths:
-- **A — Re-add standalone `state`/`derived`/`producer`/`effect`** as thin wrappers around `node()` in `core/sugar.ts`. Restores public surface; coexists with Graph methods. Minimal surgery, restores 100+ callers.
-- **B — Migrate every caller** to Graph methods. Heavier, changes demo/example pedagogical surface (every demo grows a Graph instance).
-
-Path A is the cheaper restore. Punt the decision until after the Rust port settles the API surface, since some of those callers may also be affected by other API churn.
-
-## Restoring this when ready
-
-1. Pick A or B and execute.
-2. Edit root `package.json` `docs:build` script to restore the remaining demos (`knowledge-graph`, `pagerduty-triage`) alongside the already-shipped `compat-matrix` + `reactive-layout`.
-3. Delete this section from `known-issues.md`.
 
-## `@graphrefly/cli` marked private
+## RESOLVED — `@graphrefly/cli` retired during CSP-9/B66
 
-**Symptom:** changesets `pnpm release` fails with TypeScript build errors when trying to publish this package — `Property 'explain' does not exist on type 'Graph'`, `Module '"@graphrefly/graphrefly"' has no exported member 'memoryStorage'`, etc.
+**Symptom:** the CLI package depended on the retired root `@graphrefly/graphrefly` facade and old GraphSpec-oriented APIs.
 
-**Cause:** Same root cause as the demos above — the package references removed/renamed APIs (`Graph.explain`, `memoryStorage`, `StorageTier`, `fileStorage`) that drifted during Phase 4+ refactors.
+**Cause:** after B65, there is no active root implementation for the CLI to consume. Migrating the old CLI would require reviving or redesigning `GraphSpec`, `createGraph`, `runReduction`, `SurfaceError`, `Graph.fromSnapshot`, and `Graph.diff` semantics instead of using existing `@graphrefly/ts` public surfaces.
 
-**Workaround in place:** Package marked `"private": true` in its `package.json`. Changesets respects the flag and skips publishing it. It still builds via `pnpm build` for local dev (no publish guard there), but `prepublishOnly` is gated behind the privacy flag.
+**Resolution:** CSP-9/B66 removed `packages/cli` from active workspace, lockfile, release, README, and site docs ownership. A future CLI would be a new clean-slate product over existing `@graphrefly/ts` surfaces, not restoration of the old GraphSpec shell.
 
-**Decision deferred to:** same window as the demo migration (post-Rust-port). Restoration:
-1. Migrate `cli/src/dispatch.ts` to current API (Graph methods, current storage symbols).
-2. Remove `"private": true` from `package.json`.
-3. Restore the `NOT YET PUBLISHED — see docs/known-issues.md` text in `description` to the original.
-4. Set up npm trusted-publisher config at `https://www.npmjs.com/package/@graphrefly/cli/access`.
-5. Push a changeset that bumps → next release publishes.
-6. Delete this section from `known-issues.md`.
+Retained as a tombstone only; remove this section when known-issues archival cleanup happens.
 
 ## ✅ RESOLVED — First-consumer P0s (memo:Re Story 6.4) — fixed in `0.47.0`
 
diff --git a/docs/optimizations.md b/docs/optimizations.md
index d474cb75..60993fc6 100644
--- a/docs/optimizations.md
+++ b/docs/optimizations.md
@@ -487,7 +487,7 @@ The recurring **"defer until a real consumer surfaces"** gate is **relaxed pre-1
     - **Describe-surface break: meta kind renamed** for queue/flow nodes: `meta.messaging_type` / `meta.messaging: true` → `meta.job_queue_type` / `meta.job_queue: true`. Affected kinds: `queue_depth`, `job_flow_completed_count`, `job_flow_pump` — visible in `graph.describe()` JSON, `observe()` streams, and third-party inspection tooling that filters by domain tag. No in-repo code filters by this key; document in release notes for external tooling authors.
   - **`patterns/ai` subpath rename.** `patterns/ai/node-middleware` → `patterns/ai/node`; `patterns/ai/browser-presets` → `patterns/ai/browser`. New aggregator files [`src/patterns/ai/node.ts`](../src/patterns/ai/node.ts) and [`src/patterns/ai/browser.ts`](../src/patterns/ai/browser.ts) re-export the underlying modules. Pre-1.0 rename with no back-compat shim.
   - **Build-time regression check** in [`tsup.config.ts`](../tsup.config.ts) `onSuccess`: walks the dist import graph from every universal entry and asserts none transitively reaches Node builtins. `nodeOnlyEntries` allow-list guards `extra/node`, `extra/storage-node`, `patterns/ai/node` (the real entry-list — `extra/sources-fs` is no longer a tsup entry after the codemod). New universal entries that accidentally pull a Node builtin fail the build with a clear "via X → Y → Z" chain. The check was hardened in a follow-up QA pass to (a) match both `node:*` AND bare `require("<builtin>")` so a missing `NODE_BUILTINS` entry in `restoreNodePrefix` can't silently escape; (b) use a whitespace-loose regex so minified production output (`export{x}from"./foo.js"`) still parses; (c) include a side-effect-import branch (`import "X"`); (d) seed universal entries from the declared `ENTRY_POINTS` list instead of a chunk-filename heuristic; (e) keep ESM and CJS resolution trees disjoint so a `.cjs` require can't accidentally resolve to an ESM twin; (f) handle directory-as-index resolution. `NODE_BUILTINS` was expanded from 17 names to the full Node builtin set so `restoreNodePrefix` re-attaches `node:` to `child_process`, `dns`, `http`, `tls`, `zlib`, etc. `fromGitHook` — which ran through the old gap — was moved to `src/extra/git-hook.ts` and re-exported via `extra/node`.
-  - External consumers updated: `examples/inbox-reducer/adapter-stack.ts` imports `fileStorage` from `@graphrefly/graphrefly/extra/node`. `evals/scripts/run-harness.ts` switched to `src/extra/storage-node.js` direct import.
+  - External consumers updated: `examples/inbox-reducer/adapter-stack.ts` imports `fileStorage` from `@graphrefly/graphrefly/extra/node`. `evals/scripts/run-harness.ts` switched to `src/extra/storage-node.js` direct import. CSP-9/B66 later retired `examples/inbox-reducer` from the active tree rather than migrating that old root-package consumer.
   - **2037 tests / lint clean / build green** post-split.
   **Follow-up:** per-pattern `packages/<name>/` thin re-export packages (Phase B of the original plan) is deferred to the v1.0 cut when full source extraction becomes worthwhile. Monolith-with-subpaths is the intentional shape until then.
 
diff --git a/docs/roadmap.md b/docs/roadmap.md
index a7ad4d78..b0b92f34 100644
--- a/docs/roadmap.md
+++ b/docs/roadmap.md
@@ -210,17 +210,17 @@ Goal: establish credibility by showing eval → schema fix → re-eval feedback
 
 > **Replaces former §9.1 (eval harness), §9.1b (catalog automation), §9.0 closed-loop subsection, and §9.4 (scorecard).** Single source of truth for the eval work.
 >
-> **Cost safety:** Always run `EVAL_MODE=dry-run` first. Default budget cap is `$2 / 100 calls` with replay cache on. See [evals/CHEAP-AND-SAFE.md](../evals/CHEAP-AND-SAFE.md) for the 4-step pre-flight ladder, the USD-cap gotcha for OpenRouter routes, and the cheap-model preset table (GLM, DeepSeek, Gemini Flash, GPT-nano).
+> **Historical as of 2026-06-27:** the old TypeScript eval harness was retired to `archive/evals` during CSP-9/B66 closeout. The `pnpm eval:*` root scripts and scheduled eval workflow are removed. Keep this section as design history only; CSP-8 may introduce a new clean-slate eval harness after the Canvas direction settles.
 
 ##### Next-action sequence (the dependency chain)
 
-1. ~~Write `CatalogFnEntry` objects + Treatment-D templates~~ — DONE (archived id `9.1.2-portable-catalog-and-templates`). `EVAL_TREATMENT=A|B|C|D` env var live in [evals/lib/contrastive.ts](../evals/lib/contrastive.ts).
-2. **Now → Run B + C** automated, two cheap models (e.g. `gemini-2.0-flash` + `z-ai/glm-4.7`), 5 runs each, commit trend data. → §9.1.1 L0 + §9.1.2 + §9.1.3 automated
+1. ~~Write `CatalogFnEntry` objects + Treatment-D templates~~ — DONE (archived id `9.1.2-portable-catalog-and-templates`). `EVAL_TREATMENT=A|B|C|D` env var live in [evals/lib/contrastive.ts](../archive/evals/lib/contrastive.ts).
+2. ~~Run B + C automated~~ — parked with the archived eval harness; do not run from this repo's active root scripts.
 3. ~~Build templates (`resilientFetch`, `adaptivePoller`, `conditionalMap`, `median`, `llmScore` desc)~~ — DONE (same archive entry).
-4. **Run D** — compare A→B→C→D progression. → §9.1.2
-5. **Wire harness execution method** (EXECUTE actuator + VERIFY re-eval + `run-treatments.ts`). Wave 1 dogfood demo. → §9.1.3
-6. **Cross-model validation** — promote to publish-tier models (`claude-sonnet-4-6`, `gpt-4.1`) for the blog numbers. → §9.1.1 + §9.1.3
-7. **Publish**: blog + scorecard + reproduce-guide + design-partner outreach. → §9.1.5
+4. ~~Run D / compare A→D progression~~ — parked with the archived eval harness.
+5. ~~Wire harness execution method~~ — parked; a future CSP-8 eval harness should be redesigned against current `@graphrefly/ts` and Canvas context.
+6. ~~Cross-model validation~~ — parked.
+7. ~~Publish scorecard/reproduce guide~~ — parked until a new eval harness exists.
 
 Steps 2 and 4 are the **internal evidence track**. Step 5 is the **demo track** (we use our own harness to run our own evals — the meta-story for Wave 1). Steps 6-7 are the **external story track**.
 
@@ -240,7 +240,7 @@ Every eval run picks a value from each axis. The intersection determines cost, s
 - **L0 — Graph > Functions contrastive** — DONE infra; Run 1-4 archived. Open: trend data (§9.1.5).
 - **L1 — NL → GraphSpec generation** — DONE infra; uses real `validateSpec()` + `compileSpec()` from `src/patterns/graphspec.ts`.
 - **L1 — Comprehension** — debug/modify/explain via `nl-mod` + `contrastive-bugs` corpora.
-- **Dev-DX** — vitest, no LLM calls; validates `validateSpec()` error messages. Implementation: [evals/dev-dx/seeded-errors.test.ts](../evals/dev-dx/seeded-errors.test.ts).
+- **Dev-DX** — vitest, no LLM calls; validates `validateSpec()` error messages. Implementation: [evals/dev-dx/seeded-errors.test.ts](../archive/evals/dev-dx/seeded-errors.test.ts).
 
 ##### 9.1.2 — Treatment progression (the eval-driven catalog experiment)
 
@@ -249,22 +249,18 @@ Four treatments, same 12 tasks, measuring delta at each automation step.
 | Treatment | Developer does | Library does | Status |
 |-----------|---------------|-------------|--------|
 | A: Manual catalog | Writes `catalogDescription` string | Nothing | DONE — Run 4 baseline 173/180 |
-| B: Auto-gen prompt | Writes `CatalogFnEntry` objects | `generateCatalogPrompt()` | **Ready to run** — `EVAL_TREATMENT=B pnpm eval:contrastive` |
-| C: + auto-refine | Same as B | + `maxAutoRefine: 2` | **Ready to run** — `EVAL_TREATMENT=C pnpm eval:contrastive`. Refine loop wired via `llmRefine` + a cost-safe adapter shim. Records `auto-refine attempts used` as a JudgeScore diagnostic per task. |
-| D: + templates | Same as C + selects templates | + pre-built templates | **Ready to run** — `EVAL_TREATMENT=D pnpm eval:contrastive` |
+| B: Auto-gen prompt | Writes `CatalogFnEntry` objects | `generateCatalogPrompt()` | Historical only; old runner archived |
+| C: + auto-refine | Same as B | + `maxAutoRefine: 2` | Historical only; old runner archived |
+| D: + templates | Same as C + selects templates | + pre-built templates | Historical only; old runner archived |
 | E: + catalog subsetting | Same as D | + task-relevant subset | Future |
 
 **Treatment B/C/D enablement (DONE):**
 
-> Authoring of `CatalogFnEntry` data, Treatment-D templates, the 5 Run-4 gap fixes, the `EVAL_TREATMENT` env var, and contrastive-runner wiring archived to `archive/roadmap/phase-9-harness-sprint.jsonl` (id: `9.1.2-portable-catalog-and-templates`). Files: [evals/lib/portable-catalog.ts](../evals/lib/portable-catalog.ts), [evals/lib/portable-templates.ts](../evals/lib/portable-templates.ts), [evals/lib/contrastive.ts](../evals/lib/contrastive.ts).
+> Authoring of `CatalogFnEntry` data, Treatment-D templates, the 5 Run-4 gap fixes, the `EVAL_TREATMENT` env var, and contrastive-runner wiring archived to `archive/roadmap/phase-9-harness-sprint.jsonl` (id: `9.1.2-portable-catalog-and-templates`). Files: [evals/lib/portable-catalog.ts](../archive/evals/lib/portable-catalog.ts), [evals/lib/portable-templates.ts](../archive/evals/lib/portable-templates.ts), [evals/lib/contrastive.ts](../archive/evals/lib/contrastive.ts).
 
 **Treatment B/C/D — execution remaining:**
 
-- [ ] Run Treatment B (auto-gen prompt) — L0 across two cheap models (e.g. `gemini-2.0-flash` + `z-ai/glm-4.7`)
-- [ ] Run Treatment C (auto-gen + refine) — L0 across same two models, track refine counts. Requires wiring `llmCompose` (with `maxAutoRefine: 2`) into contrastive runner; current path is equivalent to B.
-- [ ] Run Treatment D (auto-gen + refine + templates) — L0 across same two models
-- [ ] Compare A→D progression, write up for blog
-- [ ] Cross-model validation on publish-tier model (GPT-4o or Claude Sonnet)
+- [ ] Future CSP-8 eval design should decide which of these experiments still matter and rebuild them on current `@graphrefly/ts` surfaces.
 
 > **Rich catalog types** (`CatalogFnEntry` schema, `generateCatalogPrompt()`): DONE — archived to `archive/roadmap/phase-9-harness-sprint.jsonl` (id: `9.1b-rich-catalog`).
 
@@ -279,26 +275,26 @@ Four treatments, same 12 tasks, measuring delta at each automation step.
 | Auto-refine fixes same error repeatedly | Bad description | Fix description, don't rely on refine |
 | Per-task delta = 0 across A→D | Task at ceiling | Stop adding catalog for it |
 
-**Principle:** Add a catalog fn only when the operation genuinely doesn't exist. Add a template when the LLM composes correct fns in wrong structure. Add docs when the LLM doesn't reach for an existing fn. Add a catalog wrapper (not a primitive) when `dynamicNode` already supports the pattern. See session log [evals/results/session-2026-04-06-catalog-automation.md](../evals/results/session-2026-04-06-catalog-automation.md) §6 for full analysis.
+**Principle:** Add a catalog fn only when the operation genuinely doesn't exist. Add a template when the LLM composes correct fns in wrong structure. Add docs when the LLM doesn't reach for an existing fn. Add a catalog wrapper (not a primitive) when `dynamicNode` already supports the pattern. See session log [evals/results/session-2026-04-06-catalog-automation.md](../archive/evals/results/session-2026-04-06-catalog-automation.md) §6 for full analysis.
 
 **Key metric: score per prompt token.** If this ratio declines, the catalog is growing faster than quality. Declining efficiency = time to prune or subset.
 
-##### 9.1.3 — Execution methods (how a run happens)
+##### 9.1.3 — Execution methods (historical)
 
-Pick one per run. The first three are zero or low cost — exhaust them before reaching for paid API runs.
+These methods belonged to the archived eval harness and are not active repo commands.
 
-> **Mandatory pre-flight ladder for any paid run:** see [evals/CHEAP-AND-SAFE.md](../evals/CHEAP-AND-SAFE.md). Step 1 = `EVAL_MODE=dry-run`. Step 2 = local Ollama. Step 3 = single task with `EVAL_MAX_PRICE_USD=0.10` and `EVAL_REPLAY=write-only`. Step 4 = full corpus with replay cache on. Cost-safety implementation: [evals/lib/llm-client.ts:281](../evals/lib/llm-client.ts) (`createSafeProvider`).
+> **Historical safety note:** the old cost-safety docs now live under `archive/evals`. Reuse ideas from them, not the old scripts, if CSP-8 rebuilds evals.
 
-- **Portable / copy-paste** — DONE; [evals/portable-eval-prompts.md](../evals/portable-eval-prompts.md). Zero cost, any AI. Used for first-look credibility checks and reproducibility claims.
-- **Local Ollama** — DONE; zero cost, slower. Validates pipeline end-to-end before paid runs. `EVAL_PROVIDER=ollama EVAL_MODEL=gemma4:e4b pnpm eval`.
-- **Automated API (cheap budget tier)** — DONE infra; cost-safety wired. Default cheap picks: `gemini-2.0-flash` (in pricing table — USD cap works), `z-ai/glm-4.7` and `deepseek/deepseek-v3.2` via OpenRouter (rely on `EVAL_MAX_CALLS`). Used for treatment-progression iteration.
+- **Portable / copy-paste** — DONE; [evals/portable-eval-prompts.md](../archive/evals/portable-eval-prompts.md). Zero cost, any AI. Used for first-look credibility checks and reproducibility claims.
+- **Local Ollama** — historical; active `pnpm eval` command removed.
+- **Automated API (cheap budget tier)** — historical; active `pnpm eval:*` commands removed.
 - **Automated API (publish tier)** — DONE infra; gated by budget caps. Sonnet/Opus/GPT-4.1 for blog numbers. Used only after cheap-tier validates the methodology.
 - **Harness-driven (dogfood demo)** — partially DONE; the §9.0 harness loop wraps eval runs via `evalIntakeBridge`. Closed-loop automation work moved here from §9.0:
   - [ ] **EXECUTE actuators** — pluggable implementations that apply catalog entry updates, template additions, doc edits, or `CatalogFnEntry` modifications. Default: promptNode (current). Advanced: tool-use agent that writes code + runs lint.
-  - [ ] **VERIFY re-eval** — after EXECUTE produces a fix, re-run *only the affected eval tasks* (not full suite). Wire `affectsEvalTasks` from the triaged item → eval runner → compare before/after scores. Default: promptNode review (current). Advanced: actual eval execution via [evals/lib/runner.ts](../evals/lib/runner.ts).
-  - [ ] **4-treatment runner script** ([evals/scripts/run-treatments.ts](../evals/scripts/run-treatments.ts)) — automate the A→D experiment: iterate treatments, run evals per treatment, collect results, feed into harness loop for comparative analysis. Currently fully manual.
+  - [ ] **VERIFY re-eval** — after EXECUTE produces a fix, re-run *only the affected eval tasks* (not full suite). Wire `affectsEvalTasks` from the triaged item → eval runner → compare before/after scores. Default: promptNode review (current). Advanced: actual eval execution via [evals/lib/runner.ts](../archive/evals/lib/runner.ts).
+  - [ ] **4-treatment runner script** ([evals/scripts/run-treatments.ts](../archive/evals/scripts/run-treatments.ts)) — automate the A→D experiment: iterate treatments, run evals per treatment, collect results, feed into harness loop for comparative analysis. Currently fully manual.
   - [ ] **CI-triggered eval→harness pipeline** — on push/merge, run affected evals → feed results into harness → strategy model updates → report delta. Deferred until EXECUTE actuators are real.
-- **CI scheduled** — DONE; `eval.yml` runs weekly Mon 6am UTC + on manual dispatch. Generates scorecard, runs regression gate (fails if validity drops >5%).
+- **CI scheduled** — retired 2026-06-27; `eval.yml` removed with the archived eval harness.
 
 **Design note:** EXECUTE and VERIFY are intentionally pluggable. The above wires *our specific* actuators for the catalog automation use case. Other users plug in their own. The harness loop infrastructure is general; the actuators are domain-specific.
 
@@ -390,7 +386,7 @@ Peer projection of **9.3-core** as a terminal binary. Targets the Claude Code /
 - [x] Output contract — stdout = JSON by default, `--format=pretty` toggles pretty JSON; `describe` supports `--format=mermaid|d2` for diagram export; stderr = `SurfaceError` JSON payload on failure; exit codes `0` (ok), `1` (error), `2` (usage)
 - [x] Stdin pipe support — any `<spec>` positional accepts `-` for stdin; `reduce --input -` piping works (`cat input.json | graphrefly reduce spec.json --input -`)
 - [x] Zero external args-parser — hand-rolled dispatcher. Keeps the package dependency surface tiny; no `commander`/`yargs`.
-- [ ] `graphrefly eval [run|matrix|scorecard]` — deferred. Existing `tsx evals/scripts/run-all.ts` pipelines cover the workflow today; folding into CLI requires deciding whether eval logic moves into `@graphrefly/cli` or stays in the repo's `evals/` dir.
+- [ ] `graphrefly eval [run|matrix|scorecard]` — deferred to a future CSP-8 eval redesign; the old `evals/scripts/*` pipelines are archived and are not active implementation guidance.
 - [ ] Publish to npm as `@graphrefly/cli`, single `bin` entry, `npx @graphrefly/cli` works without install
 - [ ] "Try it in 30 seconds" section in README: single `npx` command producing visible eval output
 - [ ] Man page / `--help` parity with 9.3-core operations (shared JSDoc source) — `printHelp()` stub exists, parity pass deferred
@@ -404,7 +400,7 @@ Peer projection of **9.3-core** as a terminal binary. Targets the Claude Code /
 Full adapter layer archived to `archive/optimizations/resolved-decisions.jsonl` (id: `llm-adapter-layer-9-3d`). Core, providers, middleware, and routing all landed together. Open follow-ups:
 
 - [x] **`resilientAdapter()` call-path wrapper** — SHIPPED 2026-04-21 at [src/patterns/ai/adapters/middleware/resilient-adapter.ts](../src/patterns/ai/adapters/middleware/resilient-adapter.ts). Composes `withRateLimiter` + `withBudgetGate` + `withBreaker` + `withTimeout` + `withRetry` + `cascadingLlmAdapter` fallback in the documented order; per-attempt deadline rearm; `withTimeout` re-throws `LLMTimeoutError` (so retry's default predicate recognizes it against real fetch/SDK providers). Follow-ups tracked in [docs/optimizations.md](optimizations.md): `onFallback`/`onExhausted` surface, shared limiter across calls.
-- [ ] **`evals/lib/` migration** — fresh eval work after §9.1 will use the new adapter layer directly; the existing imperative stack at `evals/lib/{llm-client, rate-limiter, budget-gate, replay-cache, limits}.ts` stays untouched until then (per QA direction).
+- [ ] **Eval adapter migration** — future CSP-8 eval work should use the current adapter layer directly; the old imperative `archive/evals/lib/{llm-client, rate-limiter, budget-gate, replay-cache, limits}.ts` stack is historical material.
 - [x] ~~**MCP `llmCompose` wiring**~~ — WAS SHIPPED 2026-04-21 in `packages/mcp-server/` (now removed). The `llmCompose` capability remains available via the adapter layer; user-host applications wire it into their own MCP/CLI surfaces.
 - [ ] **Limits registry population** — library ships shape only. Users populate a `CapabilitiesRegistry` with their own data. A first-party curated table can ship as an opt-in `@graphrefly/capabilities-*` package post-1.0 if demand warrants.
 
@@ -438,7 +434,7 @@ fromTimer(interval) → fetchTransactions → anomalyDetector → flagNode
 - [x] `examples/spending-alerts/` — SHIPPED 2026-04-21. 5-hop deterministic pipeline (`txFeed → anomalyScore → thresholdGate → reasonFactors → alertMessage`, with `vendorStats`/`userProfile` as side inputs). Runnable via `pnpm --filter @graphrefly-examples/spending-alerts start`.
 - [x] `website/src/content/docs/demos/spending-alerts.md` — SHIPPED 2026-04-21. Walkthrough + causal chain output + "how you get this in your own code" + agent-extension path (swap `alertMessage` for a `promptNode` with `resilientAdapter`).
 - [x] Wire homepage "Demo: Spending Alerts →" link to the docs page.
-- [ ] Interactive 3-pane Astro shell at `demos/spending-alerts/` — follow-up. Will reuse `demoShell` + `lazyAdapter` patterns from `demos/knowledge-graph/`; adds a Chrome-Nano-backed `promptNode` justifier with mock fallback. Non-blocking for Wave 2 (roadmap note: "No GIF required — static walkthrough is sufficient").
+- [ ] Interactive 3-pane Astro shell at `demos/spending-alerts/` — deferred/rethink. Do not reuse the retired pre-CSP-9 `demoShell` / `lazyAdapter` patterns from the deleted `demos/knowledge-graph/`; any browser shell should be redesigned over current `@graphrefly/ts` public subpaths. Non-blocking for Wave 2 (roadmap note: "No GIF required — static walkthrough is sufficient").
 
 #### 9.2 deliverables for announcement
 
@@ -512,18 +508,18 @@ streamingPromptNode
 |---|---|---|---|
 | "Demo: Email Triage →" | 01 Context Without Control | Demo 0 (`website/src/content/docs/demos/email-triage.md`) | Wave 3 |
 | "Demo: Spending Alerts →" | 02 Action Without Explanation | §9.3e (`website/src/content/docs/demos/spending-alerts.md`) | **Wave 2** |
-| "Demo: Knowledge Graph →" | 03 Composition Without Guardrails | Interactive 4-chapter demo at `demos/knowledge-graph/` (Chrome Nano on-device extraction; mock fallback). Docs page at `website/src/content/docs/demos/knowledge-graph.md`. Node-runnable mirror at `examples/knowledge-graph/`. | Wave 2 (interactive) |
+| "Demo: Knowledge Graph →" | 03 Composition Without Guardrails | The old interactive `demos/knowledge-graph/` browser source was retired in CSP-9/B66 because it depended on deleted root/pure-ts AI/demo-shell surfaces. Keep the historical docs page at `website/src/content/docs/demos/knowledge-graph.md`; use the Node-runnable clean-slate mirror at `examples/knowledge-graph/` until a new browser demo is designed over `@graphrefly/ts`. | Wave 2 historical / redesign needed |
 
 - [ ] Demo 0 video/GIF — required to gate Show HN
 - [ ] `website/src/content/docs/demos/email-triage.md` (Demo 0 companion page)
-- [ ] **Port `examples/inbox-reducer` to a website demo page (opened 2026-04-21):** `website/src/content/docs/demos/inbox-reducer.md` companion to the Node-runnable example. Highlights what this example shows well (correct + concise + intuitive + capable): 7-node pipeline, 3 LLM calls over 50 emails, live stage-by-stage trace, `graph.explain` causal chain, dry-run with exact token counts, mermaid.live clickable diagram, fallback/replay-cache/resilience stack in one line, reactive delta demo (honestly framed — see next item for the true reactive-savings demo). Keep as a "here's a complete, production-shaped pipeline" reference. Does NOT replace Email Triage (Demo 0) or Spending Alerts — it's a more thorough walkthrough of adapter stack + observability than those.
+- [x] **Retire the old `examples/inbox-reducer` port plan (opened 2026-04-21, closed 2026-06-27):** the pre-CSP-9 example depended on retired root-package AI/storage/render surfaces and was deleted from the active tree in CSP-9/B66. Do not port it by reviving compatibility shims. A future inbox demo should be designed directly over current `@graphrefly/ts` public subpaths.
 - [ ] **Second inbox-like demo that genuinely shows reactive-savings + explainability (opened 2026-04-21):** The current `inbox-reducer` batches classify over all emails, so a 1-email delta re-runs every stage at full cost — it doesn't sell the reactive-push efficiency claim. Build a sibling example (working name: `inbox-stream` or `live-inbox-reducer`) that:
   - **Classifies per-email** — a `map(emails, classifyOne)`-shaped topology where each email is classified individually (50 small LLM calls initially). Compose via `funnel` or `mergeMap` with configurable concurrency.
   - **Shows real delta savings** — push a 51st email, only THAT email re-classifies (1 small call), downstream extract/rank/brief recompute deterministically plus maybe one small brief call. Vs. a full rerun = 51+N+1 calls.
   - **Leans into `graph.explain`** — for any action item in the final brief, `graph.explain("emails[e42]", "brief")` walks back through its own classify call, its extract call, and the rank decision. Shows causal-chain UX on a DAG with real fan-in/out, not just a linear pipeline.
   - **Streams incoming emails** via `fromTimer` or `fromAsyncIter` so the "arrive live, re-triage" story is visible.
   - Optional: fan-out multiple consumers of `classifications` (actionable / notifications / deferred digest) to show multi-sink reactivity.
-  **Ship as a website demo**: `website/src/content/docs/demos/inbox-stream.md`. This is the demo that sells the "reactive + explainable" moat; `inbox-reducer` stays as the approachable baseline.
+  **Ship as a website demo**: `website/src/content/docs/demos/inbox-stream.md`. This is the demo that sells the "reactive + explainable" moat; the deleted `inbox-reducer` remains historical provenance only.
 - [ ] Show HN: "GraphReFly — the reactive harness layer for agent workflows [harness scorecard inside]"
 - [ ] `@graphrefly/ai-sdk` and/or `@graphrefly/langgraph` on npm
 - [ ] 3 template repos public
diff --git a/evals/README.md b/evals/README.md
index 35127ea5..91ded20a 100644
--- a/evals/README.md
+++ b/evals/README.md
@@ -1,133 +1,5 @@
-# GraphReFly-TS Evals — Runtime Harness
+# Retired Eval Harness
 
-This directory contains the TypeScript eval runner for GraphReFly benchmarks.
+The legacy TypeScript eval harness was retired to `archive/evals` during the CSP-9/B66 closeout on 2026-06-27.
 
-Language-agnostic artifacts (corpora, schemas, rubrics, templates) live in the
-spec repo at `~/src/graphrefly/evals/`.
-
-## Eval tiers
-
-### L0 — Generation (Graph > Functions contrastive)
-
-Can an LLM compose a correct graph/pipeline from a natural-language description?
-Two treatments: GraphSpec (declarative JSON) vs plain TypeScript functions. 9 tasks
-(T1–T7 + T8a/T8b) scored on validity, completion, hallucination, bugs, completeness.
-
-### L1 — Generation (NL → GraphSpec)
-
-Zero-shot composition accuracy: NL description → valid, runnable GraphSpec.
-Uses real `validateSpec()` and `compileSpec()` from `src/patterns/graphspec.ts`.
-
-### L1 — Comprehension (debug / modify / explain)
-
-Can an LLM understand, modify, and reason about an *existing* GraphSpec?
-Modification tasks (nl-mod corpus) and bug-finding tasks (contrastive-bugs corpus).
-
-### Dev-DX — Error quality
-
-Vitest suite — no LLM calls. Validates that `validateSpec()` produces actionable
-error messages for common developer mistakes.
-
-## Providers
-
-| Provider | SDK | Budget tier | Publish tier |
-|---|---|---|---|
-| `anthropic` (default) | `@anthropic-ai/sdk` | Haiku 4.5 | Sonnet/Opus 4.6 |
-| `openai` | `openai` | GPT-4o-mini | GPT-4o / GPT-4.1 |
-| `google` | `@google/genai` | Gemini 3 Flash Preview | Gemini 3.1 Pro Preview |
-| `ollama` | `openai` (Ollama) | Gemma 4 27B | — |
-| `openrouter` | `openai` | `openrouter/free` or `:free` models | paid routed models |
-| `groq` | `openai` | GPT-OSS 20B / smaller Llama-family | larger/faster OSS models |
-
-Set `EVAL_PROVIDER` to switch. SDKs are dynamically imported — only install what you use.
-
-## Quick start
-
-```bash
-# Run all automated evals (requires API key for chosen provider)
-pnpm eval
-
-# Run only the Graph>Functions contrastive eval (L0)
-pnpm eval:contrastive
-
-# Run L1 evals (generation + comprehension)
-pnpm eval:llm-dx
-
-# Run multi-model matrix eval
-pnpm eval:matrix
-
-# Generate publishable scorecard
-pnpm eval:scorecard
-
-# Run dev-DX tests (no LLM calls — vitest)
-pnpm eval:dev-dx
-
-# Compare two eval runs
-pnpm eval:compare evals/results/run-a.json evals/results/run-b.json
-```
-
-## Structure
-
-```
-evals/
-├── portable-eval-prompts.md   L0 + L1 copy-paste prompts and rubrics
-├── HOW-TO-EVAL.md             One-pager for running evals
-├── lib/                       Core eval infrastructure
-│   ├── types.ts               Shared type definitions
-│   ├── llm-client.ts          Multi-provider LLM client
-│   ├── cost.ts                Token → USD cost estimation
-│   ├── judge.ts               LLM-as-judge scoring
-│   ├── validator.ts           Wired to real validateSpec + compileSpec
-│   ├── contrastive.ts         A/B runner for Graph>Functions evals
-│   ├── harness-metrics.ts     KPI computation from run data
-│   ├── reporter.ts            Result aggregation and formatting
-│   └── runner.ts              Core eval orchestrator (generation + comprehension)
-├── dev-dx/                    Vitest suites for developer experience
-├── scripts/                   CLI entry points
-│   ├── run-all.ts             pnpm eval
-│   ├── run-l0.ts              pnpm eval:contrastive
-│   ├── run-l1.ts              pnpm eval:llm-dx
-│   ├── run-matrix.ts          pnpm eval:matrix
-│   ├── publish-scorecard.ts   pnpm eval:scorecard
-│   └── compare.ts             pnpm eval:compare
-├── scorecard/                 Generated scorecard (latest.json + latest.md)
-└── results/                   Git-tracked eval results (one file per run)
-```
-
-## Results
-
-| Run | Date | Model | Key findings |
-|-----|------|-------|-------------|
-| [Run 1](results/claude-web-2026-04-05.md) | 2026-04-05 | Claude (web) | Functions won; GraphSpec hallucination on T5/T6 |
-| [Run 2](results/claude-web-2026-04-05-run2.md) | 2026-04-05 | Claude (web) | Tie after catalog update; feedback/resilience gaps confirmed |
-
-Analysis: [eval-analysis.md](results/eval-analysis.md)
-
-## Adding evals
-
-1. Add tasks to the corpus in the spec repo (`~/src/graphrefly/evals/corpus/`)
-2. If needed, add judge prompts in the spec repo (`~/src/graphrefly/evals/templates/judge-prompts/`)
-3. The runner here automatically picks up new corpus entries
-
-## Environment variables
-
-| Variable | Default | Purpose |
-|---|---|---|
-| `EVAL_PROVIDER` | `anthropic` | LLM provider |
-| `EVAL_MODEL` | `claude-sonnet-4-6` | Model for generation |
-| `EVAL_JUDGE_MODEL` | `claude-sonnet-4-6` | Model for LLM judge |
-| `EVAL_MODELS` | — | Comma-separated for matrix runs |
-| `EVAL_PROVIDERS` | — | Provider per model (matrix) |
-| `EVAL_OLLAMA_BASE_URL` | `http://localhost:11434/v1` | Ollama endpoint |
-| `EVAL_OPENROUTER_BASE_URL` | `https://openrouter.ai/api/v1` | OpenRouter endpoint override |
-| `EVAL_COMPAT_CHAT_EXTRA_JSON` | — | JSON merged into OpenAI-compatible chat requests (e.g. OpenRouter provider routing) |
-| `EVAL_GROQ_BASE_URL` | `https://api.groq.com/openai/v1` | Groq endpoint override |
-| `SPEC_EVALS_PATH` | `~/src/graphrefly/evals` | Spec repo evals path |
-| `EVAL_L0_FROM` | — | L0 only: task id to start at (inclusive); set only one of this or `EVAL_L0_AFTER` |
-| `EVAL_L0_AFTER` | — | L0 only: task id to resume after (exclusive); set only one of this or `EVAL_L0_FROM` |
-| `EVAL_TREATMENT` | `A` | L0 only: `A` (manual catalog) \| `B` (auto-gen prompt) \| `C` (B + auto-refine) \| `D` (C + templates). See [`docs/roadmap.md`](../docs/roadmap.md) §9.1.2. |
-| `ANTHROPIC_API_KEY` | — | Anthropic provider |
-| `OPENAI_API_KEY` | — | OpenAI provider |
-| `GOOGLE_API_KEY` | — | Google provider |
-| `OPENROUTER_API_KEY` | — | OpenRouter provider |
-| `GROQ_API_KEY` | — | Groq provider |
+This directory is intentionally a tombstone so active-tree grep and docs checks have a stable path. It does not contain runnable eval scripts, CI wiring, or current `@graphrefly/ts` guidance. Future CSP-8 eval work should redesign the harness after the Canvas direction settles.
diff --git a/examples/README.md b/examples/README.md
index 781a9c1a..df47a657 100644
--- a/examples/README.md
+++ b/examples/README.md
@@ -4,9 +4,9 @@ Runnable, self-contained examples that show how to compose GraphReFly in
 different environments. Each example lives in its own package so you can
 `cd` into one, `pnpm install`, and run it without touching the others.
 
-Every example references `@graphrefly/graphrefly` via `workspace:*` — this
-resolves locally inside the monorepo. **To copy any example out as a
-starter for your own project, replace `workspace:*` with a published
+Clean-slate examples reference `@graphrefly/ts` via `workspace:*` so they
+exercise the clean-slate package surface directly. **To copy any example out
+as a starter for your own project, replace `workspace:*` with a published
 version** (see `examples/basic/state-and-derived/README.md`).
 
 ## Layout
@@ -16,32 +16,47 @@ examples/
 ├── basic/
 │   └── state-and-derived/       state() + derived() + subscribe(), run via tsx
 ├── compat/
-│   ├── jotai/                   atom(...) API over GraphReFly nodes
-│   ├── nanostores/              atom + computed API
-│   └── zustand/                 create(initializer) API
+│   ├── jotai/                   Jotai-style atom facade over caller-owned GraphReFly nodes
+│   ├── nanostores/              Nanostores-style atom facade over caller-owned GraphReFly nodes
+│   └── zustand/                 Zustand StoreApi facade over a caller-owned GraphReFly state node
 ├── framework/
-│   ├── react/                   Vite + React 19, useStore / useSubscribe
-│   ├── vue/                     Vite + Vue 3, useStore / useSubscribe
-│   ├── solid/                   Vite + SolidJS, useStore / useSubscribe
-│   └── svelte/                  Vite + Svelte 5 (runes), useStore / useSubscribe
+│   ├── react/                   Vite + React 19, useNodeInput/useNodeValue via `@graphrefly/ts/adapters/react` (D238)
+│   ├── vue/                     Vite + Vue 3, useNodeInput/useNodeValue via `@graphrefly/ts/adapters/vue` (D238)
+│   ├── solid/                   Vite + SolidJS, createNodeInput/createNodeValue via `@graphrefly/ts/adapters/solid` (D238)
+│   └── svelte/                  Vite + Svelte 5 (runes), nodeWritable/nodeReadable via `@graphrefly/ts/adapters/svelte` (D238)
+├── knowledge-graph/             Node-runnable semantic-memory KG reducer via `@graphrefly/ts/patterns`
+├── nestjs-graph-boundary/       NestJS HTTP, WebSocket, message, cron, guard/filter boundary nodes via focused provider bundles
 ├── reactive-layout/
-│   └── flow/                    Multi-column text wrapping drifting obstacles
-└── nestjs/
-    └── order-flow/              Full CQRS flow — command, event, projection, saga, SSE, WS
+│   ├── flow/                    Multi-column text wrapping drifting obstacles
+│   └── recipes/                 Host-owned measurement glue notes; not a standalone package
+└── spending-alerts/             Node-runnable deterministic causal tracing pipeline
 ```
 
 ## Running an example
 
-All examples follow the same pattern:
+Runnable package examples follow the same pattern:
 
 ```bash
 cd examples/<subject>/<name>
 pnpm install
-pnpm start        # headless examples (basic, compat, nestjs)
+pnpm start        # headless examples (basic, compat, knowledge-graph, nestjs-graph-boundary, spending-alerts)
 # or
 pnpm dev          # Vite-hosted examples (framework, reactive-layout)
 ```
 
+For single-directory examples such as `examples/spending-alerts`, run the
+same commands from that directory instead of `examples/<subject>/<name>`.
+`examples/reactive-layout/recipes/` is documentation-only glue, so it has no
+package commands.
+
+## Retired
+
+`examples/inbox-reducer/` was retired from the active tree during CSP-9/B66
+closeout. It depended on the retired root package and old AI pattern surfaces,
+so it is not an active clean-slate starter. Re-activating the concept needs a
+separate design slice over current `@graphrefly/ts` public subpaths, not
+compatibility shims.
+
 ## Demos vs examples
 
 - **`examples/`** (this folder) — minimum viable compositions. Copy one,
diff --git a/examples/basic/state-and-derived/README.md b/examples/basic/state-and-derived/README.md
index 1adba7f6..950250e2 100644
--- a/examples/basic/state-and-derived/README.md
+++ b/examples/basic/state-and-derived/README.md
@@ -1,7 +1,7 @@
 # basic / state-and-derived
 
-The simplest possible GraphReFly example: a source `state()` node feeding a
-`derived()` node, observed through `subscribe()`.
+The simplest possible clean-slate GraphReFly TS example: a graph-owned
+`state()` node feeding a `derived()` node, observed through `subscribe()`.
 
 ## Run
 
@@ -12,12 +12,12 @@ pnpm start
 
 ## Use as a starter
 
-Inside this monorepo the example links `@graphrefly/graphrefly` via
+Inside this monorepo the example links `@graphrefly/ts` via
 `workspace:*`. To copy this folder into your own project, replace
 `workspace:*` with a published version:
 
 ```json
 "dependencies": {
-  "@graphrefly/graphrefly": "^0.24.0"
+  "@graphrefly/ts": "^0.0.0"
 }
 ```
diff --git a/examples/basic/state-and-derived/index.ts b/examples/basic/state-and-derived/index.ts
index 716da39a..903dd7c4 100644
--- a/examples/basic/state-and-derived/index.ts
+++ b/examples/basic/state-and-derived/index.ts
@@ -1,35 +1,32 @@
 /**
  * Basic reactive counter — the simplest GraphReFly example.
  *
- * Shows `state()`, `derived()`, and subscribing through the message protocol.
+ * Shows clean-slate `graph().state()`, `derived()`, and subscribing through the
+ * message protocol.
  *
- * Spec references:
- * - §2.2: `subscribe()` delivers `[[START], [DATA, cached]]` — subscribers
- *   receive the current cached value as the first DATA tuple.
- * - §1.3.3: equals substitution — emitting the same value again produces
- *   `[RESOLVED]` instead of `[DATA, v]`, so downstream does not re-run.
+ * Clean-slate note: every value occurrence is DATA (D49); RESOLVED is only the
+ * substrate-synthesized "undirty / no occurrence" settle.
  */
-import { DATA, derived, state } from "@graphrefly/graphrefly";
+import { graph } from "@graphrefly/ts";
 
-// Source node. ROM: its cache persists across subscriber churn.
-const count = state(0);
+const g = graph({ name: "counter" });
 
-// Derived node — recomputes whenever `count` emits DATA. Sugar wraps the user
-// fn and calls `actions.emit(value)` internally (see spec §2.8).
-const doubled = derived([count], ([n]) => (n as number) * 2);
+// Source node. Its cache persists across subscriber churn.
+const count = g.state(0, { name: "count" });
+
+// Derived node — recomputes whenever `count` emits DATA.
+const doubled = g.derived([count], (n) => n * 2, { name: "doubled" });
 
 // Subscribe — filter DATA tuples out of the message stream. On subscribe the
-// sink receives `[[START], [DATA, 0]]`, so you'll see `doubled: 0` first.
-const unsub = doubled.subscribe((msgs) => {
-	for (const [type, data] of msgs) {
-		if (type === DATA) console.log("doubled:", data);
-	}
+// sink receives START and cached DATA, so you'll see `doubled: 0` first.
+const unsub = doubled.subscribe(([type, data]) => {
+	if (type === "DATA") console.log("doubled:", data);
 });
 // → doubled: 0
 
-count.emit(1); // → doubled: 2
-count.emit(2); // → doubled: 4
-count.emit(3); // → doubled: 6
-count.emit(3); // (no emission — equals substitution turns this into RESOLVED)
+count.set(1); // → doubled: 2
+count.set(2); // → doubled: 4
+count.set(3); // → doubled: 6
+count.set(3); // → doubled: 6 (D49: this is another DATA occurrence)
 
 unsub();
diff --git a/examples/basic/state-and-derived/package.json b/examples/basic/state-and-derived/package.json
index 4507d5a5..9852774e 100644
--- a/examples/basic/state-and-derived/package.json
+++ b/examples/basic/state-and-derived/package.json
@@ -8,7 +8,7 @@
 		"start": "tsx index.ts"
 	},
 	"dependencies": {
-		"@graphrefly/graphrefly": "workspace:*"
+		"@graphrefly/ts": "workspace:*"
 	},
 	"devDependencies": {
 		"tsx": "^4.21.0",
diff --git a/examples/compat/jotai/README.md b/examples/compat/jotai/README.md
index 66b65c0a..57192cd2 100644
--- a/examples/compat/jotai/README.md
+++ b/examples/compat/jotai/README.md
@@ -1,9 +1,8 @@
 # compat / jotai
 
-Jotai-compatible atom API over GraphReFly nodes. Shows writable atoms,
-read-only derived atoms, writable derived atoms, and the two-way bridge
-(`atom._node` is a native GraphReFly node — it is wave-correct when you
-subscribe to it directly).
+Jotai-style atom facades over caller-owned GraphReFly nodes. Primitive
+writes use `g.state(...)`, derived reads use `g.derived(...)`, and
+`jotaiAtom(node)` exposes the tiny atom-like surface plus `._node`.
 
 ## Run
 
diff --git a/examples/compat/jotai/index.ts b/examples/compat/jotai/index.ts
index 7df03df1..c862ca29 100644
--- a/examples/compat/jotai/index.ts
+++ b/examples/compat/jotai/index.ts
@@ -1,44 +1,35 @@
 /**
- * Jotai-compatible atom API over GraphReFly nodes.
+ * Jotai-style atom facade over caller-owned GraphReFly nodes.
  *
- * Shows all three `atom()` overloads plus the two-way-bridge invariant
- * (guide §26): every compat layer exposes its backing node as `._node`,
- * and that node must be wave-correct when observed directly.
+ * `jotaiAtom(node)` exposes a tiny atom-like surface plus `._node` for direct
+ * GraphReFly composition. Derived reads stay graph-owned via `g.derived(...)`.
  */
+import { graph } from "@graphrefly/ts";
+import { jotaiAtom } from "@graphrefly/ts/adapters";
 
-import { atom } from "@graphrefly/graphrefly/compat/jotai";
-import { DATA } from "@graphrefly/graphrefly/core";
+const g = graph({ name: "jotai-example" });
 
-// 1. Primitive (writable) atom — wraps `state()` under the hood.
-const count = atom(0);
+// Primitive writable atom over a clean-slate state node.
+const countNode = g.state(0, { name: "count" });
+const count = jotaiAtom(countNode);
 
-// 2. Read-only derived atom — `atom((get) => ...)` wraps `dynamicNode`.
-const doubled = atom((get) => (get(count) ?? 0) * 2);
-
-// 3. Writable derived atom — read + custom write (here: clamp to [0, 10]).
-const clamped = atom(
-	(get) => get(count) ?? 0,
-	(_get, _set, v: number) => count.set(Math.max(0, Math.min(10, v))),
-);
+// Read-only derived atom over a clean-slate derived node.
+const doubledNode = g.derived([countNode], (n) => n * 2, { name: "doubled" });
+const doubled = jotaiAtom(doubledNode);
 
 // Observe via Jotai's surface API. Jotai-style `subscribe` fires only on
 // changes — it does NOT deliver the initial value.
 const unsubDoubled = doubled.subscribe((v) => console.log("doubled:", v));
 
-// Two-way-bridge check (guide §26): subscribe directly to the backing node.
-// Raw node subscriptions honor push-on-subscribe (spec §2.2) — the first
-// emission is the currently cached value, delivered synchronously on subscribe.
-const unsubRaw = count._node.subscribe((msgs) => {
-	for (const [t, v] of msgs) {
-		if (t === DATA) console.log("count._node DATA:", v);
-	}
+// Direct node subscriptions still honor push-on-subscribe.
+const unsubRaw = count._node.subscribe(([type, data]) => {
+	if (type === "DATA") console.log("count._node DATA:", data);
 });
-// → count._node DATA: 0   (push-on-subscribe of cached state)
+// -> count._node DATA: 0
 
-count.set(1); // doubled: 2 · count._node DATA: 1
-count.set(5); // doubled: 10 · count._node DATA: 5
-count.update((n) => n + 1); // doubled: 12 · count._node DATA: 6
-clamped.set(99); // clamp → count := 10 → doubled: 20 · count._node DATA: 10
+count.set(1); // doubled: 2 / count._node DATA: 1
+count.set(5); // doubled: 10 / count._node DATA: 5
+count.update((n) => (n ?? 0) + 1); // doubled: 12 / count._node DATA: 6
 
 unsubDoubled();
 unsubRaw();
diff --git a/examples/compat/jotai/package.json b/examples/compat/jotai/package.json
index b615cc2f..e1423160 100644
--- a/examples/compat/jotai/package.json
+++ b/examples/compat/jotai/package.json
@@ -8,7 +8,7 @@
 		"start": "tsx index.ts"
 	},
 	"dependencies": {
-		"@graphrefly/graphrefly": "workspace:*"
+		"@graphrefly/ts": "workspace:*"
 	},
 	"devDependencies": {
 		"tsx": "^4.21.0",
diff --git a/examples/compat/nanostores/README.md b/examples/compat/nanostores/README.md
index 013e0a0d..75cb1507 100644
--- a/examples/compat/nanostores/README.md
+++ b/examples/compat/nanostores/README.md
@@ -1,8 +1,9 @@
 # compat / nanostores
 
-Nanostores-compatible `atom()` and `computed()` API backed by GraphReFly.
-Demonstrates `subscribe` (fires with initial value) vs `listen` (changes
-only), and multi-store `computed`.
+Nanostores-style atom facades over caller-owned GraphReFly nodes.
+Computed values are ordinary `g.derived(...)` nodes wrapped with
+`nanoAtom(node)`. Demonstrates `subscribe` (fires with initial value) vs
+`listen` (changes only).
 
 ## Run
 
diff --git a/examples/compat/nanostores/index.ts b/examples/compat/nanostores/index.ts
index 27883705..fc63806a 100644
--- a/examples/compat/nanostores/index.ts
+++ b/examples/compat/nanostores/index.ts
@@ -1,32 +1,35 @@
 /**
- * Nanostores-compatible atom + computed API over GraphReFly nodes.
+ * Nanostores-style atom facade over caller-owned GraphReFly nodes.
  *
- * - `subscribe(cb)` fires immediately with the current value (matches
- *   GraphReFly's push-on-subscribe — spec §2.2).
- * - `listen(cb)` fires only on subsequent changes.
- * - `atom._node` / `computed._node` are native GraphReFly nodes, safe to
- *   compose with `derived()` or register into a `Graph`.
+ * The computed examples are ordinary `g.derived(...)` nodes wrapped with
+ * `nanoAtom`, keeping GraphReFly topology explicit and inspectable.
  */
-import { atom, computed } from "@graphrefly/graphrefly/compat/nanostores";
+import { graph } from "@graphrefly/ts";
+import { nanoAtom } from "@graphrefly/ts/adapters";
 
-const count = atom(0);
+const g = graph({ name: "nanostores-example" });
+const countNode = g.state(0, { name: "count" });
+const count = nanoAtom(countNode, { immediate: false });
 
-// Computed — nanostores' equivalent of `derived`.
-const doubled = computed(count, (n) => n * 2);
+const doubledNode = g.derived([countNode], (n) => n * 2, { name: "doubled" });
+const doubled = nanoAtom(doubledNode, { immediate: false });
 
-// Multi-dep computed.
-const offset = atom(100);
-const labelled = computed([count, offset], (n, o) => `count+offset = ${n + o}`);
+const offsetNode = g.state(100, { name: "offset" });
+const offset = nanoAtom(offsetNode, { immediate: false });
+const labelledNode = g.derived([countNode, offsetNode], (n, o) => `count+offset = ${n + o}`, {
+	name: "labelled",
+});
+const labelled = nanoAtom(labelledNode, { immediate: false });
 
 // `subscribe` — fires immediately with the cached value, then on every change.
 const unsubDoubled = doubled.subscribe((v) => console.log("doubled:", v));
-// → doubled: 0
+// -> doubled: 0
 
 // `listen` — changes only, no initial call.
 const unsubLabel = labelled.listen((s) => console.log("labelled:", s));
 
-count.set(1); // doubled: 2
-count.set(5); // doubled: 10 · labelled: count+offset = 105
+count.set(1); // doubled: 2 / labelled: count+offset = 101
+count.set(5); // doubled: 10 / labelled: count+offset = 105
 offset.set(200); // labelled: count+offset = 205
 
 unsubDoubled();
diff --git a/examples/compat/nanostores/package.json b/examples/compat/nanostores/package.json
index 1333fe80..16bd3dc9 100644
--- a/examples/compat/nanostores/package.json
+++ b/examples/compat/nanostores/package.json
@@ -8,7 +8,7 @@
 		"start": "tsx index.ts"
 	},
 	"dependencies": {
-		"@graphrefly/graphrefly": "workspace:*"
+		"@graphrefly/ts": "workspace:*"
 	},
 	"devDependencies": {
 		"tsx": "^4.21.0",
diff --git a/examples/compat/zustand/README.md b/examples/compat/zustand/README.md
index 5ae46a41..d3c3ac8a 100644
--- a/examples/compat/zustand/README.md
+++ b/examples/compat/zustand/README.md
@@ -1,8 +1,8 @@
 # compat / zustand
 
-Zustand-compatible `create(initializer)` store API. The returned object is
-both a Zustand `StoreApi` and a GraphReFly `Graph` — you can introspect
-and snapshot it.
+Zustand-compatible `StoreApi` over a caller-owned GraphReFly state node.
+This example consumes `@graphrefly/ts` plus `@graphrefly/ts/adapters`;
+the old `compat/zustand` package surface is not recreated.
 
 ## Run
 
diff --git a/examples/compat/zustand/index.ts b/examples/compat/zustand/index.ts
index 080c768a..9d7e095d 100644
--- a/examples/compat/zustand/index.ts
+++ b/examples/compat/zustand/index.ts
@@ -1,44 +1,44 @@
 /**
- * Zustand-compatible store API backed by GraphReFly.
+ * Zustand-compatible StoreApi backed by a caller-owned GraphReFly state node.
  *
- * - `create(initializer)` returns a `Graph & StoreApi<T>` — the store IS a
- *   graph, so you can `.add()` further nodes, introspect with `describe()`,
- *   and snapshot like any other graph.
- * - Zustand fires listeners on every `setState` regardless of reference
- *   equality, so the backing state node is constructed with a permissive
- *   `equals: () => false` to match.
- * - Derive via selectors at read time — zustand has no built-in computed.
+ * The example uses the dependency-free adapter surface from
+ * `@graphrefly/ts/adapters`; it does not recreate the old compat namespace or
+ * a store-owned Graph factory.
  */
-import { create } from "@graphrefly/graphrefly/compat/zustand";
+import { graph } from "@graphrefly/ts";
+import { zustandStore } from "@graphrefly/ts/adapters";
 
-type Counter = {
+type CounterState = {
 	count: number;
-	inc: () => void;
-	dec: () => void;
-	reset: () => void;
 };
 
-const store = create<Counter>((set, get) => ({
-	count: 0,
-	inc: () => set({ count: get().count + 1 }),
-	dec: () => set({ count: get().count - 1 }),
-	reset: () => set({ count: 0 }),
-}));
+const g = graph({ name: "zustand-example" });
+const counter = g.state<CounterState>({ count: 0 }, { name: "counter" });
+const store = zustandStore(counter);
 
 // Selector-based derivation (zustand idiom).
-const doubled = (s: Counter) => s.count * 2;
+const doubled = (s: CounterState) => s.count * 2;
+const inc = () => store.setState((state) => ({ count: state.count + 1 }));
+const dec = () => store.setState((state) => ({ count: state.count - 1 }));
+const reset = () => store.setState({ count: 0 });
 
 const unsub = store.subscribe((state, prev) => {
-	console.log(`count ${prev.count} → ${state.count} · doubled: ${doubled(state)}`);
+	console.log(`count ${prev.count} -> ${state.count} / doubled: ${doubled(state)}`);
 });
 
-store.getState().inc(); // count 0 → 1 · doubled: 2
-store.getState().inc(); // count 1 → 2 · doubled: 4
-store.getState().dec(); // count 2 → 1 · doubled: 2
-store.getState().reset(); // count 1 → 0 · doubled: 0
+inc(); // count 0 -> 1 / doubled: 2
+inc(); // count 1 -> 2 / doubled: 4
+dec(); // count 2 -> 1 / doubled: 2
+reset(); // count 1 -> 0 / doubled: 0
 
-// The store is a Graph — use `describe()` or `snapshot()` for introspection.
-console.log("graph snapshot:", store.snapshot());
+console.log(
+	"graph nodes:",
+	g.describe().nodes.map((node) => node.name ?? node.id),
+);
+console.log(
+	"graph checkpoint nodes:",
+	g.checkpoint().nodes.map((node) => node.id),
+);
 
 unsub();
 store.destroy();
diff --git a/examples/compat/zustand/package.json b/examples/compat/zustand/package.json
index 76c2616e..307882aa 100644
--- a/examples/compat/zustand/package.json
+++ b/examples/compat/zustand/package.json
@@ -8,7 +8,7 @@
 		"start": "tsx index.ts"
 	},
 	"dependencies": {
-		"@graphrefly/graphrefly": "workspace:*"
+		"@graphrefly/ts": "workspace:*"
 	},
 	"devDependencies": {
 		"tsx": "^4.21.0",
diff --git a/examples/framework/react/README.md b/examples/framework/react/README.md
index 8daab8ae..53658192 100644
--- a/examples/framework/react/README.md
+++ b/examples/framework/react/README.md
@@ -2,11 +2,10 @@
 
 Minimal React + GraphReFly counter.
 
-- `useStore(node)` → `[value, setValue]` — tied to a state node.
-- `useSubscribe(node)` → `value` — works for any node (here: a derived).
+- `useNodeInput(node)` -> `[value, setValue]` — tied to a state node.
+- `useNodeValue(node)` -> `value` — works for any node (here: a derived).
 
-Both are powered by `useSyncExternalStore` so they integrate cleanly with
-concurrent React.
+Both hooks come from the focused D238 subpath `@graphrefly/ts/adapters/react`.
 
 ## Run
 
diff --git a/examples/framework/react/package.json b/examples/framework/react/package.json
index d02a76be..d3208261 100644
--- a/examples/framework/react/package.json
+++ b/examples/framework/react/package.json
@@ -3,14 +3,14 @@
 	"private": true,
 	"version": "0.0.8",
 	"type": "module",
-	"description": "React binding for GraphReFly — useStore / useSubscribe.",
+	"description": "React binding for GraphReFly — useNodeInput / useNodeValue.",
 	"scripts": {
 		"dev": "vite",
 		"build": "vite build",
 		"preview": "vite preview"
 	},
 	"dependencies": {
-		"@graphrefly/graphrefly": "workspace:*",
+		"@graphrefly/ts": "workspace:*",
 		"react": "^19.0.0",
 		"react-dom": "^19.0.0"
 	},
diff --git a/examples/framework/react/src/Counter.tsx b/examples/framework/react/src/Counter.tsx
index 1e9d7c35..6529dc2a 100644
--- a/examples/framework/react/src/Counter.tsx
+++ b/examples/framework/react/src/Counter.tsx
@@ -1,11 +1,9 @@
-import { useStore, useSubscribe } from "@graphrefly/graphrefly/compat/react";
+import { useNodeInput, useNodeValue } from "@graphrefly/ts/adapters/react";
 import { count, doubled } from "./store";
 
 export function Counter() {
-	// `useStore` returns a `[value, setter]` tuple backed by a state node.
-	const [value, setValue] = useStore(count);
-	// `useSubscribe` returns a read-only value for any node (here: a derived).
-	const dbl = useSubscribe(doubled);
+	const [value, setValue] = useNodeInput(count);
+	const dbl = useNodeValue(doubled);
 	const n = value ?? 0;
 	return (
 		<section>
diff --git a/examples/framework/react/src/store.ts b/examples/framework/react/src/store.ts
index 4a865b06..bebb4eab 100644
--- a/examples/framework/react/src/store.ts
+++ b/examples/framework/react/src/store.ts
@@ -1,8 +1,8 @@
-import { derived, state } from "@graphrefly/graphrefly/core";
+import { graph } from "@graphrefly/ts";
 
-// Shared graph state — nodes outlive React mount/unmount. ROM state: cache
+const g = graph({ name: "react-example" });
+
+// Shared graph state: nodes outlive React mount/unmount. ROM state: cache
 // persists across subscriber churn (spec §2.6).
-export const count = state(0, { name: "count" });
-export const doubled = derived([count], ([n]) => (n as number) * 2, {
-	name: "doubled",
-});
+export const count = g.state(0, { name: "count" });
+export const doubled = g.derived([count], (n) => n * 2, { name: "doubled" });
diff --git a/examples/framework/solid/README.md b/examples/framework/solid/README.md
index 8a6df425..6242909b 100644
--- a/examples/framework/solid/README.md
+++ b/examples/framework/solid/README.md
@@ -2,10 +2,11 @@
 
 Minimal SolidJS + GraphReFly counter.
 
-- `useStore(node)` → `[Accessor<T>, setter]`.
-- `useSubscribe(node)` → `Accessor<T>` — works for any node (here: a derived).
+- `createNodeInput(node)` -> `[Accessor<T>, setter]`.
+- `createNodeValue(node)` -> `Accessor<T>` — works for any node (here: a derived).
 
-Cleanup is tied to the Solid reactive owner via `onCleanup`.
+The helpers come from the D238-focused `@graphrefly/ts/adapters/solid` subpath; cleanup is
+tied to the Solid reactive owner via `onCleanup`.
 
 ## Run
 
diff --git a/examples/framework/solid/package.json b/examples/framework/solid/package.json
index 4aa6c18b..75c06a8f 100644
--- a/examples/framework/solid/package.json
+++ b/examples/framework/solid/package.json
@@ -3,14 +3,14 @@
 	"private": true,
 	"version": "0.0.8",
 	"type": "module",
-	"description": "SolidJS binding for GraphReFly — useStore / useSubscribe.",
+	"description": "SolidJS binding for GraphReFly — createNodeInput / createNodeValue.",
 	"scripts": {
 		"dev": "vite",
 		"build": "vite build",
 		"preview": "vite preview"
 	},
 	"dependencies": {
-		"@graphrefly/graphrefly": "workspace:*",
+		"@graphrefly/ts": "workspace:*",
 		"solid-js": "^1.9.0"
 	},
 	"devDependencies": {
diff --git a/examples/framework/solid/src/Counter.tsx b/examples/framework/solid/src/Counter.tsx
index 19f3c803..8be9dea6 100644
--- a/examples/framework/solid/src/Counter.tsx
+++ b/examples/framework/solid/src/Counter.tsx
@@ -1,11 +1,10 @@
-import { useStore, useSubscribe } from "@graphrefly/graphrefly/compat/solid";
+import { createNodeInput, createNodeValue } from "@graphrefly/ts/adapters/solid";
 import type { Component } from "solid-js";
 import { count, doubled } from "./store";
 
 export const Counter: Component = () => {
-	// `useStore` returns `[Accessor, setter]` — call the accessor to read.
-	const [value, setValue] = useStore(count);
-	const dbl = useSubscribe(doubled);
+	const [value, setValue] = createNodeInput(count);
+	const dbl = createNodeValue(doubled);
 	return (
 		<section>
 			<h1>GraphReFly · Solid</h1>
diff --git a/examples/framework/solid/src/store.ts b/examples/framework/solid/src/store.ts
index cf2ed176..cc151837 100644
--- a/examples/framework/solid/src/store.ts
+++ b/examples/framework/solid/src/store.ts
@@ -1,6 +1,6 @@
-import { derived, state } from "@graphrefly/graphrefly/core";
+import { graph } from "@graphrefly/ts";
 
-export const count = state(0, { name: "count" });
-export const doubled = derived([count], ([n]) => (n as number) * 2, {
-	name: "doubled",
-});
+const g = graph({ name: "solid-example" });
+
+export const count = g.state(0, { name: "count" });
+export const doubled = g.derived([count], (n) => n * 2, { name: "doubled" });
diff --git a/examples/framework/svelte/README.md b/examples/framework/svelte/README.md
index 99026f04..c2470ea3 100644
--- a/examples/framework/svelte/README.md
+++ b/examples/framework/svelte/README.md
@@ -2,13 +2,13 @@
 
 Minimal Svelte 5 (runes mode) + GraphReFly counter.
 
-- `useStore(node)` → a Svelte writable store. `$value` reads it; assigning to
+- `nodeWritable(node)` -> a Svelte writable store. `$value` reads it; assigning to
   `$value` writes back to the node.
-- `useSubscribe(node)` → a Svelte readable store for any node (here: a
+- `nodeReadable(node)` -> a Svelte readable store for any node (here: a
   derived). Read as `$dbl`.
 
-The `$`-prefix auto-subscription is the idiomatic Svelte path and
-stays clean in runes mode.
+Both helpers come from the D238-focused `@graphrefly/ts/adapters/svelte` subpath. The `$`-prefix
+auto-subscription is the idiomatic Svelte path and stays clean in runes mode.
 
 ## Run
 
diff --git a/examples/framework/svelte/package.json b/examples/framework/svelte/package.json
index 118459bf..4a4d4a94 100644
--- a/examples/framework/svelte/package.json
+++ b/examples/framework/svelte/package.json
@@ -3,14 +3,14 @@
 	"private": true,
 	"version": "0.0.8",
 	"type": "module",
-	"description": "Svelte 5 binding for GraphReFly — useStore / useSubscribe.",
+	"description": "Svelte 5 binding for GraphReFly — nodeWritable / nodeReadable.",
 	"scripts": {
 		"dev": "vite",
 		"build": "vite build",
 		"preview": "vite preview"
 	},
 	"dependencies": {
-		"@graphrefly/graphrefly": "workspace:*",
+		"@graphrefly/ts": "workspace:*",
 		"svelte": "^5.0.0"
 	},
 	"devDependencies": {
diff --git a/examples/framework/svelte/src/App.svelte b/examples/framework/svelte/src/App.svelte
index de00a2d1..888ca99e 100644
--- a/examples/framework/svelte/src/App.svelte
+++ b/examples/framework/svelte/src/App.svelte
@@ -1,19 +1,17 @@
 <script lang="ts">
-import { useStore, useSubscribe } from "@graphrefly/graphrefly/compat/svelte";
+import { nodeReadable, nodeWritable } from "@graphrefly/ts/adapters/svelte";
 import { count, doubled } from "./store";
 
-// `useStore` returns a Svelte writable store — `$`-prefix reads and writes it.
-const value = useStore(count);
-// `useSubscribe` returns a readable store for any node (here: a derived).
-const dbl = useSubscribe(doubled);
+const value = nodeWritable(count);
+const dbl = nodeReadable(doubled);
 </script>
 
 <section>
 	<h1>GraphReFly · Svelte 5</h1>
 	<div class="row">
-		<button type="button" on:click={() => ($value = ($value ?? 0) - 1)}>−</button>
+		<button type="button" onclick={() => ($value = ($value ?? 0) - 1)}>−</button>
 		<span class="value">{$value ?? 0}</span>
-		<button type="button" on:click={() => ($value = ($value ?? 0) + 1)}>+</button>
+		<button type="button" onclick={() => ($value = ($value ?? 0) + 1)}>+</button>
 	</div>
 	<p>doubled = <strong>{$dbl ?? 0}</strong></p>
 </section>
diff --git a/examples/framework/svelte/src/store.ts b/examples/framework/svelte/src/store.ts
index cf2ed176..abb9af7f 100644
--- a/examples/framework/svelte/src/store.ts
+++ b/examples/framework/svelte/src/store.ts
@@ -1,6 +1,6 @@
-import { derived, state } from "@graphrefly/graphrefly/core";
+import { graph } from "@graphrefly/ts";
 
-export const count = state(0, { name: "count" });
-export const doubled = derived([count], ([n]) => (n as number) * 2, {
-	name: "doubled",
-});
+const g = graph({ name: "svelte-example" });
+
+export const count = g.state(0, { name: "count" });
+export const doubled = g.derived([count], (n) => n * 2, { name: "doubled" });
diff --git a/examples/framework/vue/README.md b/examples/framework/vue/README.md
index f3f91bb6..5414c699 100644
--- a/examples/framework/vue/README.md
+++ b/examples/framework/vue/README.md
@@ -2,13 +2,12 @@
 
 Minimal Vue 3 + GraphReFly counter.
 
-- `useStore(node)` → writable `Ref<T>` — ideal for `v-model` or direct
-  assignment.
-- `useSubscribe(node)` → read-only `Ref<T>` — works for any node (here: a
+- `useNodeInput(node)` -> `[Ref<T>, setter]` — tied to a writable node.
+- `useNodeValue(node)` -> read-only `Ref<T>` — works for any node (here: a
   derived).
 
-Subscriptions are tied to the Vue effect scope and clean up automatically on
-`onScopeDispose`.
+The helpers come from the D238-focused `@graphrefly/ts/adapters/vue` subpath; subscriptions
+clean up automatically on `onScopeDispose`.
 
 ## Run
 
diff --git a/examples/framework/vue/package.json b/examples/framework/vue/package.json
index 6750c605..9fa12d0a 100644
--- a/examples/framework/vue/package.json
+++ b/examples/framework/vue/package.json
@@ -3,14 +3,14 @@
 	"private": true,
 	"version": "0.0.8",
 	"type": "module",
-	"description": "Vue 3 binding for GraphReFly — useStore / useSubscribe.",
+	"description": "Vue 3 binding for GraphReFly — useNodeInput / useNodeValue.",
 	"scripts": {
 		"dev": "vite",
 		"build": "vite build",
 		"preview": "vite preview"
 	},
 	"dependencies": {
-		"@graphrefly/graphrefly": "workspace:*",
+		"@graphrefly/ts": "workspace:*",
 		"vue": "^3.5.0"
 	},
 	"devDependencies": {
diff --git a/examples/framework/vue/src/App.vue b/examples/framework/vue/src/App.vue
index 286ee4c8..aae24b98 100644
--- a/examples/framework/vue/src/App.vue
+++ b/examples/framework/vue/src/App.vue
@@ -1,20 +1,18 @@
 <script setup lang="ts">
-import { useStore, useSubscribe } from "@graphrefly/graphrefly/compat/vue";
+import { useNodeInput, useNodeValue } from "@graphrefly/ts/adapters/vue";
 import { count, doubled } from "./store";
 
-// `useStore` returns a writable Ref — v-model and direct assignment both work.
-const value = useStore(count);
-// `useSubscribe` returns a read-only Ref for any node.
-const dbl = useSubscribe(doubled);
+const [value, setValue] = useNodeInput(count);
+const dbl = useNodeValue(doubled);
 </script>
 
 <template>
 	<section>
 		<h1>GraphReFly · Vue</h1>
 		<div class="row">
-			<button type="button" @click="value = (value ?? 0) - 1">−</button>
+			<button type="button" @click="setValue((value ?? 0) - 1)">−</button>
 			<span class="value">{{ value ?? 0 }}</span>
-			<button type="button" @click="value = (value ?? 0) + 1">+</button>
+			<button type="button" @click="setValue((value ?? 0) + 1)">+</button>
 		</div>
 		<p>doubled = <strong>{{ dbl ?? 0 }}</strong></p>
 	</section>
diff --git a/examples/framework/vue/src/store.ts b/examples/framework/vue/src/store.ts
index cf2ed176..d9193927 100644
--- a/examples/framework/vue/src/store.ts
+++ b/examples/framework/vue/src/store.ts
@@ -1,6 +1,6 @@
-import { derived, state } from "@graphrefly/graphrefly/core";
+import { graph } from "@graphrefly/ts";
 
-export const count = state(0, { name: "count" });
-export const doubled = derived([count], ([n]) => (n as number) * 2, {
-	name: "doubled",
-});
+const g = graph({ name: "vue-example" });
+
+export const count = g.state(0, { name: "count" });
+export const doubled = g.derived([count], (n) => n * 2, { name: "doubled" });
diff --git a/examples/inbox-reducer/.gitignore b/examples/inbox-reducer/.gitignore
deleted file mode 100644
index 9a564b91..00000000
--- a/examples/inbox-reducer/.gitignore
+++ /dev/null
@@ -1,2 +0,0 @@
-.cache/
-node_modules/
diff --git a/examples/inbox-reducer/CHANGELOG.md b/examples/inbox-reducer/CHANGELOG.md
deleted file mode 100644
index 464fd51c..00000000
--- a/examples/inbox-reducer/CHANGELOG.md
+++ /dev/null
@@ -1,57 +0,0 @@
-# @graphrefly-examples/inbox-reducer
-
-## 0.0.8
-
-### Patch Changes
-
-- Updated dependencies [[`4230039`](https://github.com/graphrefly/graphrefly-ts/commit/4230039498f97be2d5213d76cb8ce8f72a073b9a)]:
-  - @graphrefly/graphrefly@0.49.0
-
-## 0.0.7
-
-### Patch Changes
-
-- Updated dependencies [[`812ff96`](https://github.com/graphrefly/graphrefly-ts/commit/812ff96091f063557e01ad861baf6a87ad2082a2)]:
-  - @graphrefly/graphrefly@0.48.1
-
-## 0.0.6
-
-### Patch Changes
-
-- Updated dependencies [[`cfb1500`](https://github.com/graphrefly/graphrefly-ts/commit/cfb1500250504391683557a0b75cec381ca8e201), [`9b3554b`](https://github.com/graphrefly/graphrefly-ts/commit/9b3554b659ccb5aaf1f45dbd1ed933129d691171)]:
-  - @graphrefly/graphrefly@0.48.0
-
-## 0.0.5
-
-### Patch Changes
-
-- Updated dependencies [[`fda9432`](https://github.com/graphrefly/graphrefly-ts/commit/fda94326c6656c27008c2733f305a5c077f8ff09)]:
-  - @graphrefly/graphrefly@0.47.2
-
-## 0.0.4
-
-### Patch Changes
-
-- Updated dependencies [[`76d35c7`](https://github.com/graphrefly/graphrefly-ts/commit/76d35c73eb84a2871ac34907a10a0514674745ca)]:
-  - @graphrefly/graphrefly@0.47.1
-
-## 0.0.3
-
-### Patch Changes
-
-- Updated dependencies [[`36ff7df`](https://github.com/graphrefly/graphrefly-ts/commit/36ff7df3e4fd843ce630ad388921ff33e64a37e1), [`f08b7cf`](https://github.com/graphrefly/graphrefly-ts/commit/f08b7cf8b62ad522a1da5c4664ef719e19e5d7f0)]:
-  - @graphrefly/graphrefly@0.47.0
-
-## 0.0.2
-
-### Patch Changes
-
-- Updated dependencies [[`23c1eba`](https://github.com/graphrefly/graphrefly-ts/commit/23c1eba88c55be7ab925eaf8b704bc6604a0ec57)]:
-  - @graphrefly/graphrefly@0.46.0
-
-## 0.0.1
-
-### Patch Changes
-
-- Updated dependencies [[`64ab268`](https://github.com/graphrefly/graphrefly-ts/commit/64ab26858804265f60f169f69f95343793e5afde)]:
-  - @graphrefly/graphrefly@0.45.0
diff --git a/examples/inbox-reducer/README.md b/examples/inbox-reducer/README.md
deleted file mode 100644
index 5b1abf7a..00000000
--- a/examples/inbox-reducer/README.md
+++ /dev/null
@@ -1,129 +0,0 @@
-# Inbox Reducer — 50 emails → 3-bullet morning brief
-
-A non-toy example that exercises every safety + inspection primitive
-GraphReFly ships for LLM workflows:
-
-| Feature | Where it shows up |
-|---|---|
-| **Dry-run token counting** (no spend) | Pre-flight banner — reports exact input/output tokens, and USD estimate if pricing is in `config.ts`. |
-| **`resilientAdapter`** (rate-limit + budget + timeout + retry + fallback) | One call in `index.ts` wraps the provider. |
-| **`withReplayCache`** (file-backed) | First run pays for the 3 LLM calls; reruns serve from `.cache/` for free. |
-| **`observableAdapter`** stats | Counts every call's input/output tokens reactively — surfaces in both dry-run and real-run summaries. |
-| **Live budget subscriber** | `budget.totals` streams to stdout after each LLM call. |
-| **`promptNode`** (reactive LLM transform) | The three LLM hops (classify, extract, brief) — topology + retries handled by the factory. |
-| **Stage-by-stage stdout trace** | Each of the 7 named nodes logs when it fires. |
-| **`graph.describe({ explain: { from, to } })`** | Prints the causal chain from `emails` → `brief` at the end, with the WHY annotation for each hop. |
-
-## Topology
-
-```
-emails (state)
-  │  promptNode — batched classify (LLM call 1)
-  ▼
-classifications ──┐
-  │               │
-  ▼               │
-actionable (derived filter)
-  │               │  promptNode — batched extract (LLM call 2)
-  ▼               │
-extractions ──────┤
-                  │
-  ▼               ▼
-ranked (derived: priority × confidence)
-  │
-  ▼
-top3 (derived)
-  │  promptNode — free-text brief (LLM call 3)
-  ▼
-brief (string)
-```
-
-Three LLM calls total. Everything else is deterministic reactive derivation.
-
-## Running
-
-```bash
-# 1) pick a provider + model — edit config.ts OR set INBOX_CONFIG
-export INBOX_CONFIG=openrouter         # or `anthropic`, `google`, `ollama`
-export OPENROUTER_API_KEY=sk-or-v1-... # whichever env var your config references
-
-# Optional: override the preset's model without editing config.ts
-# export INBOX_MODEL=gemma4:26b
-
-# Optional: timeout for the whole pipeline (default 120000 ms = 2 min)
-# export INBOX_TIMEOUT_MS=180000
-
-pnpm --filter @graphrefly-examples/inbox-reducer start
-# or
-npx tsx examples/inbox-reducer/index.ts
-```
-
-### Local model via Ollama
-
-If you have Ollama running locally:
-
-```bash
-ollama pull gemma4:26b           # or any other model
-export INBOX_CONFIG=ollama
-# INBOX_MODEL defaults to gemma4:26b; override if your tag differs
-
-# Large models on consumer hardware are slow. The 50-email classify prompt
-# is ~3K tokens of input — easily 1-3 minutes per call on M1-class silicon.
-# Three calls in the pipeline → plan for 10+ minutes end-to-end.
-export INBOX_TIMEOUT_MS=900000   # 15 minutes
-
-pnpm --filter @graphrefly-examples/inbox-reducer start
-```
-
-No API key required. The Ollama preset ships with **no per-call timeout and
-no retries** — local inference isn't transient, so aborting/retrying it just
-wastes time. `INBOX_TIMEOUT_MS` is the only bound; set it generously for big
-models.
-
-If a call fails (5xx, malformed JSON, etc.), the adapter's error is printed
-with an `[adapter]` prefix, so you'll see the real reason for any `null`
-stage output instead of guessing.
-
-### Two timeouts — which one is biting you?
-
-| Knob | Layer | What it aborts | Default |
-|---|---|---|---|
-| `INBOX_TIMEOUT_MS` | Outer pipeline | The whole end-to-end wait for the brief | 120 000 ms |
-| `resilience.timeoutMs` in `config.ts` | Per HTTP call (via `resilientAdapter`) | A single LLM request | API presets: 30–60 s · Ollama preset: none |
-
-If you see `[adapter] invoke failed after ~120000ms — AbortError: ...` lines
-before the outer timeout fires, `resilience.timeoutMs` is the knob to raise
-(or delete) in `config.ts`.
-
-The script:
-
-1. **Dry-runs first.** Prints exact token counts. If `capabilities.pricing` is
-   filled in in `config.ts`, also prints the USD estimate. Otherwise, USD is
-   skipped — no fabricated numbers.
-2. **Prompts** `Proceed to real run? [y/N]` — pass `--yes` to skip.
-3. **Real run** with live stage trace, budget stream, final brief, and
-   `graph.explain` causal chain.
-
-Rerun after the first success: the three LLM calls hit the replay cache
-(`.cache/`) and the whole pipeline completes offline with identical output.
-Delete `.cache/` to force fresh API calls.
-
-## Config
-
-All config lives in `config.ts`. Three preset shapes are provided — pick one
-with `INBOX_CONFIG` or edit the file to add your own. Every field maps
-1-to-1 onto a shipped library type (links in the file header).
-
-**Pricing:** by default, the preset pricing blocks are commented out, so the
-dry-run reports token counts only. Uncomment and fill in from your provider's
-current pricing page to enable USD estimates. No fabricated rates.
-
-## What this example is not
-
-- **Not a test.** It runs against real APIs; you pay for the first run.
-  Intended to be run by a human looking at stdout, not by CI.
-- **Not a replacement for the eval harness.** The eval harness at `evals/`
-  measures accuracy across many runs. This is a single end-to-end trace
-  showing how the primitives compose for a real task.
-- **Not the website demo.** An interactive Chrome-Nano-backed version at
-  `demos/inbox-reducer/` is scoped for a later session.
diff --git a/examples/inbox-reducer/adapter-stack.ts b/examples/inbox-reducer/adapter-stack.ts
deleted file mode 100644
index 1b7e6600..00000000
--- a/examples/inbox-reducer/adapter-stack.ts
+++ /dev/null
@@ -1,117 +0,0 @@
-/**
- * Adapter stack — how to wire safety around a real LLM adapter.
- *
- * Composes in this order (innermost to outermost):
- *
- * ```text
- *   createAdapter(provider)         ← real wire call
- *     └─ observableAdapter           ← emits reactive token-count stats
- *         └─ withReplayCache          ← file cache; reruns are free
- *             └─ resilientAdapter      ← rateLimit / budget / timeout / retry / fallback
- * ```
- *
- * Every layer is a shipped building block. No bespoke glue — just
- * composition. Swap any one layer for your own middleware at the same
- * point; the others don't care.
- */
-
-import { DATA, type LLMAdapter, type Messages, type TokenUsage } from "@graphrefly/graphrefly";
-import { fileStorage } from "@graphrefly/graphrefly/extra/node";
-import {
-	type AdapterStats,
-	type BudgetGateBundle,
-	computePrice,
-	createAdapter,
-	observableAdapter,
-	resilientAdapter,
-	withReplayCache,
-} from "@graphrefly/graphrefly/patterns/ai";
-import type { InboxConfig, InboxProviderConfig } from "./config.js";
-
-export interface AdapterStackBundle {
-	readonly adapter: LLMAdapter;
-	readonly stats: AdapterStats;
-	readonly budget: BudgetGateBundle | undefined;
-	/** Subscribe-friendly message listener for budget totals (if configured). */
-	readonly onBudget: (cb: (line: string) => void) => (() => void) | undefined;
-}
-
-function resolveApiKey(cfg: InboxProviderConfig): string | undefined {
-	return cfg.apiKeyEnv ? process.env[cfg.apiKeyEnv] : undefined;
-}
-
-export function assertApiKey(cfg: InboxProviderConfig): void {
-	if (cfg.apiKeyEnv && !process.env[cfg.apiKeyEnv]) {
-		console.error(
-			`\nMissing env var ${cfg.apiKeyEnv} for provider kind=${cfg.kind}, model=${cfg.model}.`,
-		);
-		console.error("Export the env var, or edit examples/inbox-reducer/config.ts.");
-		process.exit(2);
-	}
-}
-
-export function buildProviderAdapter(cfg: InboxProviderConfig): LLMAdapter {
-	return createAdapter({
-		provider: cfg.kind,
-		apiKey: resolveApiKey(cfg),
-		model: cfg.model,
-		baseURL: cfg.baseURL,
-		bodyExtras: cfg.bodyExtras,
-	});
-}
-
-/**
- * Build the full adapter stack for a real run.
- *
- * @param config - Active `InboxConfig`.
- * @param cacheDir - Directory for the replay cache files.
- */
-export function buildAdapterStack(config: InboxConfig, cacheDir: string): AdapterStackBundle {
-	const pricing = config.primary.capabilities?.pricing;
-	const pricingFn = pricing ? (usage: TokenUsage) => computePrice(usage, pricing) : undefined;
-
-	const { adapter: observed, stats } = observableAdapter(buildProviderAdapter(config.primary), {
-		name: config.primary.model,
-	});
-
-	// Replay cache sits INSIDE the resilience stack so cache hits are not
-	// rate-limited, budget-gated, or retried. Observable sits INSIDE the
-	// cache so only real wire calls count against stats.
-	const cached = withReplayCache(observed, {
-		storage: fileStorage(cacheDir),
-		mode: "read-write",
-		keyPrefix: `inbox-reducer:${config.primary.kind}:${config.primary.model}`,
-	});
-
-	const { adapter, budget } = resilientAdapter(cached, {
-		rateLimit: config.resilience?.rpm
-			? { rpm: config.resilience.rpm, tpm: config.resilience.tpm }
-			: undefined,
-		budget: config.budget ? { caps: config.budget, pricingFn } : undefined,
-		timeoutMs: config.resilience?.timeoutMs,
-		retry: config.resilience?.retryAttempts
-			? { attempts: config.resilience.retryAttempts }
-			: undefined,
-		fallback: config.fallback ? buildProviderAdapter(config.fallback) : undefined,
-	});
-
-	const onBudget = (cb: (line: string) => void): (() => void) | undefined => {
-		if (!budget) return undefined;
-		return budget.totals.subscribe((msgs: Messages) => {
-			for (const [type, value] of msgs) {
-				if (type !== DATA) continue;
-				const t = value as {
-					calls: number;
-					inputTokens: number;
-					outputTokens: number;
-					usd: number;
-				};
-				if (t.calls === 0) continue;
-				const usd = t.usd ? `  $${t.usd.toFixed(4)}` : "";
-				cb(`${t.calls} calls · ${t.inputTokens}t in · ${t.outputTokens}t out${usd}`);
-			}
-		});
-	};
-
-	return { adapter, stats, budget, onBudget };
-}
diff --git a/examples/inbox-reducer/config.ts b/examples/inbox-reducer/config.ts
deleted file mode 100644
index 21eb167f..00000000
--- a/examples/inbox-reducer/config.ts
+++ /dev/null
@@ -1,248 +0,0 @@
-/**
- * Inbox-reducer runtime configuration.
- *
- * Edit this file to point the example at the LLM provider + model you want
- * to examine. Every field below maps 1-to-1 onto a shipped library type —
- * no bespoke schema, no new library surface:
- *
- * - `kind`              → `CreateAdapterOptions.provider` (src/patterns/ai/adapters/core/factory.ts)
- * - `capabilities`      → `ModelCapabilities`              (src/patterns/ai/adapters/core/capabilities.ts)
- * - `capabilities.pricing` → `ModelPricing`                 (src/patterns/ai/adapters/core/pricing.ts)
- * - `budget`            → `WithBudgetGateOptions.caps`    (src/patterns/ai/adapters/middleware/budget-gate.ts)
- * - `resilience`        → `resilientAdapter` options       (src/patterns/ai/adapters/middleware/resilient-adapter.ts)
- *
- * The `capabilities.pricing` block is OPTIONAL. When present, the pre-flight
- * dry run multiplies counted tokens by your configured rates. When absent,
- * the dry run reports token counts only — no invented USD figures. The
- * example ships with pricing commented out; fill in the numbers from your
- * provider's current pricing page if you want the USD estimate.
- *
- * Active config is picked by `INBOX_CONFIG=openrouter|anthropic|google|ollama`
- * (default: `openrouter`). `INBOX_MODEL=...` overrides the preset's model id
- * without editing this file.
- */
-
-import type { AdapterProvider, ModelCapabilities } from "@graphrefly/graphrefly/patterns/ai";
-
-export interface InboxProviderConfig {
-	/** Dispatches to the shipped provider constructor via `createAdapter`. */
-	kind: AdapterProvider;
-	/** Model id passed to the adapter and used as part of the replay-cache key. */
-	model: string;
-	/** Env var holding the API key. `process.env[apiKeyEnv]` is read at startup. */
-	apiKeyEnv?: string;
-	/** Base URL override (OpenRouter, self-host, etc.). */
-	baseURL?: string;
-	/** Extra request body fields (e.g. OpenRouter routing hints). */
-	bodyExtras?: Record<string, unknown>;
-	/** Static facts about this model. `pricing` is optional — see module docs. */
-	capabilities?: ModelCapabilities;
-}
-
-export interface InboxConfig {
-	primary: InboxProviderConfig;
-	/** Optional second-tier adapter engaged when primary exhausts retries. */
-	fallback?: InboxProviderConfig;
-	/** Budget caps applied via `resilientAdapter({ budget: { caps } })`. */
-	budget?: { calls?: number; inputTokens?: number; outputTokens?: number; usd?: number };
-	/** Rate-limit + timeout + retry wired into `resilientAdapter`. */
-	resilience?: {
-		rpm?: number;
-		tpm?: number;
-		timeoutMs?: number;
-		retryAttempts?: number;
-	};
-}
-
-// ----------------------------------------------------------------------------
-// Example 1 — OpenAI-compat preset (OpenRouter here; `kind` also supports
-// "openai" | "deepseek" | "groq" | "xai" | "ollama" — all go through the
-// same shipped OpenAI-compat provider with different defaults).
-// ----------------------------------------------------------------------------
-const openrouterExample: InboxConfig = {
-	primary: {
-		kind: "openrouter",
-		model: "deepseek/deepseek-chat",
-		apiKeyEnv: "OPENROUTER_API_KEY",
-		capabilities: {
-			id: "deepseek/deepseek-chat",
-			provider: "openrouter",
-			limits: { contextWindow: 64_000, rpm: 60 },
-			// Uncomment + fill in from https://openrouter.ai/models to enable
-			// USD estimates in the dry-run summary. Numbers are $/1M tokens.
-			// pricing: {
-			//   currency: "USD",
-			//   input:  { regular: /* $ / 1M input tokens  */ 0 },
-			//   output: { regular: /* $ / 1M output tokens */ 0 },
-			// },
-		},
-	},
-	budget: { calls: 20 },
-	resilience: { rpm: 60, timeoutMs: 30_000, retryAttempts: 3 },
-};
-
-// ----------------------------------------------------------------------------
-// Example 2 — Anthropic direct (requires `@anthropic-ai/sdk` installed in the
-// surrounding app OR a provider-side HTTP shim; our `anthropicAdapter` also
-// supports a fetch-only path, see src/patterns/ai/adapters/providers/anthropic.ts).
-// ----------------------------------------------------------------------------
-const anthropicExample: InboxConfig = {
-	primary: {
-		kind: "anthropic",
-		model: "claude-haiku-4-5",
-		apiKeyEnv: "ANTHROPIC_API_KEY",
-		capabilities: {
-			id: "claude-haiku-4-5",
-			provider: "anthropic",
-			limits: { contextWindow: 200_000, rpm: 50 },
-			// pricing: {
-			//   currency: "USD",
-			//   input:  { regular: 0 /* $/1M input */  },
-			//   output: { regular: 0 /* $/1M output */ },
-			// },
-		},
-	},
-	budget: { calls: 20 },
-	resilience: { rpm: 50, timeoutMs: 60_000, retryAttempts: 3 },
-};
-
-// ----------------------------------------------------------------------------
-// Example 3 — Google direct (Gemini). Works via our `googleAdapter`.
-//
-// Default: Gemini 2.5 Flash-Lite on the free tier. Chosen because:
-//   - Thinking mode OFF by default → fast, predictable, no reasoning-token
-//     bloat that wrecks cost on other thinking models.
-//   - Lowest price of the Flash family: $0.10 / $0.40 per 1M in/out.
-//   - Free-tier 15 RPM / 250K TPM / 1,000 RPD — well above what this
-//     example needs (3 calls per run, ~4K input tokens total).
-//   - 1M-token context window.
-//
-// Free-tier rate limits as of April 2026 (source: ai.google.dev). Numbers
-// below match the free-tier so the budget gate short-circuits correctly if
-// you rerun the demo many times in a minute. Upgrade the `rpm` / `tpm` /
-// `rpd` values to your paid-tier quota if applicable.
-// ----------------------------------------------------------------------------
-const googleExample: InboxConfig = {
-	primary: {
-		kind: "google",
-		model: "gemini-2.5-flash-lite",
-		apiKeyEnv: "GOOGLE_API_KEY",
-		capabilities: {
-			id: "gemini-2.5-flash-lite",
-			provider: "google",
-			limits: {
-				contextWindow: 1_000_000,
-				rpm: 15,
-				tpm: 250_000,
-				rpd: 1_000,
-			},
-			pricing: {
-				currency: "USD",
-				input: { regular: 0.1, cacheRead: 0.01 },
-				output: { regular: 0.4 },
-			},
-		},
-	},
-	// Free tier is generous enough that $1 is unreachable in normal use.
-	// Leaving the cap in place as a safety net for a runaway loop.
-	budget: { usd: 1 },
-	resilience: { rpm: 15, tpm: 250_000, timeoutMs: 60_000, retryAttempts: 2 },
-};
-
-// ----------------------------------------------------------------------------
-// Example 3b — Google Gemini 2.5 Flash (full, not Lite). Thinking mode ON by
-// default; slower and ~3-6× pricier than Flash-Lite. Uncomment this block +
-// the `NAMED` entry below, and set `INBOX_CONFIG=googleFlash`, if you want
-// the richer reasoning for comparison.
-//
-// To disable thinking for speed (recommended for this example), pass
-// `bodyExtras: { generationConfig: { thinkingConfig: { thinkingBudget: 0 } } }`.
-// ----------------------------------------------------------------------------
-// const googleFlashExample: InboxConfig = {
-// 	primary: {
-// 		kind: "google",
-// 		model: "gemini-2.5-flash",
-// 		apiKeyEnv: "GOOGLE_API_KEY",
-// 		bodyExtras: {
-// 			generationConfig: { thinkingConfig: { thinkingBudget: 0 } },
-// 		},
-// 		capabilities: {
-// 			id: "gemini-2.5-flash",
-// 			provider: "google",
-// 			limits: { contextWindow: 1_000_000, rpm: 10, tpm: 250_000, rpd: 250 },
-// 			pricing: {
-// 				currency: "USD",
-// 				input: { regular: 0.3, cacheRead: 0.03 },
-// 				output: { regular: 2.5 },
-// 			},
-// 		},
-// 	},
-// 	budget: { usd: 2 },
-// 	resilience: { rpm: 10, tpm: 250_000, timeoutMs: 60_000, retryAttempts: 2 },
-// };
-
-// ----------------------------------------------------------------------------
-// Example 4 — Ollama (local). No API key needed, no budget needed (free).
-// The shipped `openai-compat` preset for Ollama sets baseURL to
-// `http://localhost:11434/v1` — no need to set it here. Pricing is omitted
-// (it's free), so the dry-run reports token counts only.
-//
-// Default model is `gemma4:26b` — override via `INBOX_MODEL=...` if your
-// local tag differs (e.g. `INBOX_MODEL=llama3.1:70b`).
-//
-// IMPORTANT: no per-call `timeoutMs` and no retries.
-//   - Large local models on consumer hardware can take minutes to chew
-//     through a 4K-token prompt. Aborting at, say, 120s mid-inference
-//     returns a 500 and achieves nothing but wasted work.
-//   - Retrying a timed-out local call with the exact same input is useless
-//     — it'll take the same amount of time next attempt too. Retries are
-//     for transient network failures (429, connection reset), which don't
-//     apply to localhost.
-//   - The outer `INBOX_TIMEOUT_MS` (default 120 000 ms, raise for big
-//     models) is the one timeout that matters — set it generously.
-// ----------------------------------------------------------------------------
-const ollamaExample: InboxConfig = {
-	primary: {
-		kind: "ollama",
-		model: "gemma4:26b",
-		capabilities: {
-			id: "gemma4:26b",
-			provider: "ollama",
-			limits: { contextWindow: 8192 }, // adjust for your model's window
-		},
-	},
-	// No budget — Ollama is local. No per-call timeout or retries; the outer
-	// INBOX_TIMEOUT_MS is the only bound on the pipeline.
-	resilience: {},
-};
-
-const NAMED: Record<string, InboxConfig> = {
-	openrouter: openrouterExample,
-	anthropic: anthropicExample,
-	google: googleExample,
-	ollama: ollamaExample,
-};
-
-const active = process.env.INBOX_CONFIG ?? "openrouter";
-if (!(active in NAMED)) {
-	console.error(`Unknown INBOX_CONFIG=${active}. Pick one of: ${Object.keys(NAMED).join(", ")}`);
-	process.exit(2);
-}
-
-// Apply INBOX_MODEL override without mutating the preset.
-function withModelOverride(cfg: InboxConfig, override: string | undefined): InboxConfig {
-	if (!override) return cfg;
-	const primary: InboxProviderConfig = {
-		...cfg.primary,
-		model: override,
-		capabilities: cfg.primary.capabilities
-			? { ...cfg.primary.capabilities, id: override }
-			: undefined,
-	};
-	return { ...cfg, primary };
-}
-
-export const config: InboxConfig = withModelOverride(
-	NAMED[active] as InboxConfig,
-	process.env.INBOX_MODEL,
-);
diff --git a/examples/inbox-reducer/dry-run-mock.ts b/examples/inbox-reducer/dry-run-mock.ts
deleted file mode 100644
index d0b30240..00000000
--- a/examples/inbox-reducer/dry-run-mock.ts
+++ /dev/null
@@ -1,54 +0,0 @@
-/**
- * Dry-run mock — shaped responses so the pipeline flows end-to-end without
- * any API call.
- *
- * Routes on prompt-head substrings (see [pipeline.ts](./pipeline.ts) —
- * `CLASSIFY_HEAD`, `EXTRACT_HEAD`). Returns canned JSON for classify/extract
- * so `promptNode`'s `format: "json"` parse succeeds, and plain text for the
- * brief.
- *
- * For richer offline fallback (recorded real responses), swap this out for
- * `fallbackAdapter({ fixturesDir: "./fixtures" })` — same `LLMAdapter`
- * shape, no pipeline changes. Files land under `./fixtures/fallback/`
- * (auto-namespaced by keyPrefix).
- */
-
-import type { LLMAdapter } from "@graphrefly/graphrefly";
-import { dryRunAdapter } from "@graphrefly/graphrefly/patterns/ai";
-import { EMAILS } from "./emails.js";
-import { CLASSIFY_HEAD, EXTRACT_HEAD } from "./pipeline.js";
-
-export function buildDryRunMock(providerLabel: string, modelLabel: string): LLMAdapter {
-	return dryRunAdapter({
-		provider: providerLabel,
-		model: modelLabel,
-		respond: (messages) => {
-			const last = messages[messages.length - 1]?.content ?? "";
-			const text = typeof last === "string" ? last : "";
-			if (text.includes(CLASSIFY_HEAD)) {
-				// Shaped classifications — keep a quarter of emails actionable so
-				// the downstream extract prompt has non-empty input.
-				return JSON.stringify(
-					EMAILS.map((e, i) => ({
-						id: e.id,
-						actionable: i % 4 === 0,
-						priority: 3,
-						category: "work",
-						confidence: 0.75,
-					})),
-				);
-			}
-			if (text.includes(EXTRACT_HEAD)) {
-				return JSON.stringify(
-					EMAILS.filter((_, i) => i % 4 === 0).map((e) => ({
-						id: e.id,
-						title: `stub: ${e.subject.slice(0, 48)}`,
-						action: "Review",
-						entities: [e.from],
-					})),
-				);
-			}
-			return "- stub bullet one\n- stub bullet two\n- stub bullet three";
-		},
-	});
-}
diff --git a/examples/inbox-reducer/emails.ts b/examples/inbox-reducer/emails.ts
deleted file mode 100644
index e440584f..00000000
--- a/examples/inbox-reducer/emails.ts
+++ /dev/null
@@ -1,399 +0,0 @@
-/**
- * 50 mock emails — varied mix of actionable work items, personal notes,
- * promotional noise, calendar reminders, newsletters, and notifications.
- *
- * The reducer pipeline will classify each, filter the actionable ones,
- * extract action items, rank by priority × confidence, and draft a brief.
- */
-
-export interface Email {
-	readonly id: string;
-	readonly from: string;
-	readonly subject: string;
-	readonly snippet: string;
-	readonly receivedAt: string;
-}
-
-export const EMAILS: readonly Email[] = [
-	// --- Work: concrete action requests (should rank high) ---
-	{
-		id: "e01",
-		from: "alice@acme.co",
-		subject: "Can you review PR #482 before EOD?",
-		snippet:
-			"Merge window closes at 5pm PT. Two tests still flaky — see line 34 of runner.ts. Need your approval.",
-		receivedAt: "2026-04-21T08:12:00Z",
-	},
-	{
-		id: "e02",
-		from: "finance@acme.co",
-		subject: "Invoice #INV-2031 requires approval",
-		snippet:
-			"Vendor: Acme Hosting. Amount: $4,200. Due: Friday 4/24. Approve in Ramp or reply with concerns.",
-		receivedAt: "2026-04-21T08:25:00Z",
-	},
-	{
-		id: "e03",
-		from: "legal@acme.co",
-		subject: "Please sign updated MSA with FidelityCorp",
-		snippet: "Redlines resolved. DocuSign link inside. Counterparty expects return by Wed.",
-		receivedAt: "2026-04-21T08:40:00Z",
-	},
-	{
-		id: "e04",
-		from: "hr@acme.co",
-		subject: "Complete Q2 compliance training by 4/30",
-		snippet: "30-minute module. Required for all US employees. Link inside.",
-		receivedAt: "2026-04-21T09:00:00Z",
-	},
-	{
-		id: "e05",
-		from: "bob@acme.co",
-		subject: "Re: Sprint planning — your inputs on the roadmap?",
-		snippet:
-			"Need your priorities for the May sprint by Friday so I can draft the doc. 3 bullets is fine.",
-		receivedAt: "2026-04-21T09:14:00Z",
-	},
-	{
-		id: "e06",
-		from: "security@acme.co",
-		subject: "Rotate your SSH key — expires 4/28",
-		snippet: "Your acme-prod key expires in 7 days. Use the self-serve portal to rotate.",
-		receivedAt: "2026-04-21T09:30:00Z",
-	},
-	{
-		id: "e07",
-		from: "design@acme.co",
-		subject: "Figma mocks for onboarding v3 — final review",
-		snippet: "Last chance to comment. Shipping to eng Monday. Link inside.",
-		receivedAt: "2026-04-21T09:45:00Z",
-	},
-	{
-		id: "e08",
-		from: "pm@acme.co",
-		subject: "Customer escalation — RightAngle account",
-		snippet:
-			"RightAngle threatened to churn. Need your take on a retention discount before 2pm call.",
-		receivedAt: "2026-04-21T10:00:00Z",
-	},
-
-	// --- Personal: real but lower urgency ---
-	{
-		id: "e09",
-		from: "mom@gmail.com",
-		subject: "Dinner Sunday?",
-		snippet: "Dad and I are free Sunday 6pm. Let me know if you can make it.",
-		receivedAt: "2026-04-21T07:15:00Z",
-	},
-	{
-		id: "e10",
-		from: "sarah.chen@gmail.com",
-		subject: "Coffee this week?",
-		snippet: "Back in town Thursday through Saturday. Blue Bottle on 18th?",
-		receivedAt: "2026-04-21T07:42:00Z",
-	},
-	{
-		id: "e11",
-		from: "dentist@smileclinic.com",
-		subject: "Reminder: cleaning appointment 4/24",
-		snippet: "Friday 10:30am with Dr. Okafor. Reply STOP to cancel.",
-		receivedAt: "2026-04-21T06:00:00Z",
-	},
-	{
-		id: "e12",
-		from: "landlord@sfapts.com",
-		subject: "Annual lease renewal — action required",
-		snippet:
-			"Your lease renews 5/31. Rent increase of 3%. Sign the addendum by 4/30 or we'll assume month-to-month.",
-		receivedAt: "2026-04-21T08:05:00Z",
-	},
-
-	// --- Promotional / marketing (should be filtered as non-actionable) ---
-	{
-		id: "e13",
-		from: "offers@bestbuy.com",
-		subject: "30% off laptops this week only",
-		snippet: "Shop Dell, HP, Lenovo. Sale ends Sunday midnight.",
-		receivedAt: "2026-04-21T05:00:00Z",
-	},
-	{
-		id: "e14",
-		from: "deals@airlines.com",
-		subject: "Flights to Tokyo from $645 round-trip",
-		snippet: "Limited-time fare alert. Book by Friday for May–June travel.",
-		receivedAt: "2026-04-21T05:15:00Z",
-	},
-	{
-		id: "e15",
-		from: "marketing@shoestore.com",
-		subject: "New Nike drops — shop the collection",
-		snippet: "Air Max 2026, Pegasus 41, and more. Free shipping on orders over $50.",
-		receivedAt: "2026-04-21T05:30:00Z",
-	},
-	{
-		id: "e16",
-		from: "promo@groceryapp.com",
-		subject: "$10 off your next 3 orders",
-		snippet: "Code SPRING10. Expires 4/30.",
-		receivedAt: "2026-04-21T05:45:00Z",
-	},
-	{
-		id: "e17",
-		from: "deals@hotels.com",
-		subject: "Weekend getaway deals from $89/night",
-		snippet: "Book your spring escape. Free cancellation.",
-		receivedAt: "2026-04-21T06:00:00Z",
-	},
-	{
-		id: "e18",
-		from: "crm@streamingservice.com",
-		subject: "We miss you — 2 months free",
-		snippet: "Come back to MovieStream. First 2 months on us.",
-		receivedAt: "2026-04-21T06:15:00Z",
-	},
-	{
-		id: "e19",
-		from: "offers@creditcard.com",
-		subject: "Earn 60,000 bonus points",
-		snippet: "Limited-time welcome bonus on the Platinum Travel card.",
-		receivedAt: "2026-04-21T06:30:00Z",
-	},
-	{
-		id: "e20",
-		from: "store@electronics.com",
-		subject: "Flash sale: headphones 40% off",
-		snippet: "Today only. Over-ear, in-ear, gaming. Free 2-day shipping.",
-		receivedAt: "2026-04-21T06:45:00Z",
-	},
-
-	// --- Newsletters / digests ---
-	{
-		id: "e21",
-		from: "digest@hackernews.com",
-		subject: "HN weekly digest — top 10 stories",
-		snippet: "AI agent harnesses · new Rust async runtime · YC S26 batch · more.",
-		receivedAt: "2026-04-21T04:00:00Z",
-	},
-	{
-		id: "e22",
-		from: "newsletter@tldr.tech",
-		subject: "TLDR — Apr 21: three things to know",
-		snippet:
-			"1. Anthropic ships managed agents. 2. NVIDIA Q1 earnings beat. 3. New WebGPU spec draft.",
-		receivedAt: "2026-04-21T04:30:00Z",
-	},
-	{
-		id: "e23",
-		from: "noreply@substack.com",
-		subject: "New post: 'Why your eval harness lies to you'",
-		snippet: "Substack post from Ben Hylak. Read time: 9 min.",
-		receivedAt: "2026-04-21T04:45:00Z",
-	},
-	{
-		id: "e24",
-		from: "weekly@changelog.com",
-		subject: "Changelog weekly — episode 621",
-		snippet: "New episode on developer tooling. Listen in your podcast app.",
-		receivedAt: "2026-04-21T05:00:00Z",
-	},
-	{
-		id: "e25",
-		from: "briefing@morningbrew.com",
-		subject: "Morning Brew — 4/21",
-		snippet: "Markets: S&P +0.4%. Stories: Tesla delivery miss, Fed pause, retail sales up.",
-		receivedAt: "2026-04-21T05:15:00Z",
-	},
-
-	// --- Notifications (systems, not humans) ---
-	{
-		id: "e26",
-		from: "no-reply@amazon.com",
-		subject: "Your package has been delivered",
-		snippet: "Order #114-2918 delivered to front porch. Photo attached.",
-		receivedAt: "2026-04-21T07:00:00Z",
-	},
-	{
-		id: "e27",
-		from: "alerts@united.com",
-		subject: "Flight UA 5321 confirmed for 4/27",
-		snippet: "SFO → JFK, departing 8:15am. Check-in opens 4/26 8:15am.",
-		receivedAt: "2026-04-21T07:10:00Z",
-	},
-	{
-		id: "e28",
-		from: "github.com",
-		subject: "[acme/runner] Build #1923 failed",
-		snippet: "Job 'test:integration' failed on main. See log for stack trace.",
-		receivedAt: "2026-04-21T10:15:00Z",
-	},
-	{
-		id: "e29",
-		from: "linear.app",
-		subject: "You were assigned AE-224 — 'Fix rate-limit leak'",
-		snippet: "Assigned by Bob Martinez. Priority: High. Due: 4/25.",
-		receivedAt: "2026-04-21T10:20:00Z",
-	},
-	{
-		id: "e30",
-		from: "pagerduty.com",
-		subject: "[RESOLVED] High error rate on api-gateway",
-		snippet: "Incident #8821 auto-resolved after 4 min. No action needed.",
-		receivedAt: "2026-04-21T03:15:00Z",
-	},
-	{
-		id: "e31",
-		from: "notifications@slack.com",
-		subject: "Daily summary from #eng-harness",
-		snippet: "23 messages. Top threads: eval run failure · cache key bug · PR #487.",
-		receivedAt: "2026-04-21T07:30:00Z",
-	},
-	{
-		id: "e32",
-		from: "billing@stripe.com",
-		subject: "Invoice paid: $199.00",
-		snippet: "Your monthly subscription was charged. Receipt attached.",
-		receivedAt: "2026-04-21T07:45:00Z",
-	},
-
-	// --- Threads / replies (mix of real and informational) ---
-	{
-		id: "e33",
-		from: "carol@acme.co",
-		subject: "Re: Re: Eval run looked off — can you double-check the judge config?",
-		snippet:
-			"You were right. Judge was pointing at the wrong model. Fix in PR #489. Can you approve?",
-		receivedAt: "2026-04-21T09:55:00Z",
-	},
-	{
-		id: "e34",
-		from: "daniel@acme.co",
-		subject: "Re: Architecture review doc",
-		snippet: "Added comments throughout. See sections 3.2 and 4.1 for concerns.",
-		receivedAt: "2026-04-21T10:05:00Z",
-	},
-	{
-		id: "e35",
-		from: "emily@vendor.co",
-		subject: "Re: Pricing question",
-		snippet:
-			"Confirmed: the usage-based tier caps at $2k/mo. Let me know if you want the enterprise tier.",
-		receivedAt: "2026-04-21T10:10:00Z",
-	},
-	{
-		id: "e36",
-		from: "frank@acme.co",
-		subject: "Re: Lunch",
-		snippet: "Thanks! See you at 12:30 at the usual place.",
-		receivedAt: "2026-04-21T10:20:00Z",
-	},
-	{
-		id: "e37",
-		from: "gina@acme.co",
-		subject: "Re: Q2 OKR draft",
-		snippet:
-			"LGTM. Only comment: 'ship harness' should be split into 'harness MVP' and 'harness GA'.",
-		receivedAt: "2026-04-21T10:30:00Z",
-	},
-
-	// --- Calendar invites / meeting reminders ---
-	{
-		id: "e38",
-		from: "calendar@google.com",
-		subject: "Reminder: 1:1 with Manager in 15 minutes",
-		snippet: "10:30am PT · Google Meet · No agenda attached.",
-		receivedAt: "2026-04-21T10:15:00Z",
-	},
-	{
-		id: "e39",
-		from: "calendar@google.com",
-		subject: "Tomorrow: Architecture review with partner team",
-		snippet: "4/22 2:00pm PT · Zoom link inside · Bring the reduction-layer diagram.",
-		receivedAt: "2026-04-21T10:20:00Z",
-	},
-	{
-		id: "e40",
-		from: "calendar@google.com",
-		subject: "New meeting request: onboarding intro with new hire",
-		snippet: "4/23 11:00am · 30 min · Accept/Tentative/Decline.",
-		receivedAt: "2026-04-21T10:25:00Z",
-	},
-
-	// --- Urgent / ambiguous (human follow-ups) ---
-	{
-		id: "e41",
-		from: "henry@acme.co",
-		subject: "Can you jump on a quick call?",
-		snippet: "Customer-facing issue with the ingest pipeline. Slack huddle running now.",
-		receivedAt: "2026-04-21T10:40:00Z",
-	},
-	{
-		id: "e42",
-		from: "isabel@acme.co",
-		subject: "Heads up — board deck needs your section by Thursday",
-		snippet: "Your 2 slides on harness adoption. Keep to bullets. Thursday 5pm.",
-		receivedAt: "2026-04-21T10:45:00Z",
-	},
-	{
-		id: "e43",
-		from: "jack@acme.co",
-		subject: "FYI: eval infra cost spike",
-		snippet: "Looks like we left a GPU box running overnight. $180 one-off. No action for you.",
-		receivedAt: "2026-04-21T10:50:00Z",
-	},
-
-	// --- Billing / receipts ---
-	{
-		id: "e44",
-		from: "receipts@uber.com",
-		subject: "Your Uber trip receipt",
-		snippet: "From Mission St to SFO. $37.42. Tap to rate your driver.",
-		receivedAt: "2026-04-21T06:00:00Z",
-	},
-	{
-		id: "e45",
-		from: "receipts@doordash.com",
-		subject: "Order from Golden Boy delivered",
-		snippet: "$28.15 · Receipt attached.",
-		receivedAt: "2026-04-21T06:30:00Z",
-	},
-
-	// --- Spam / low-quality outreach ---
-	{
-		id: "e46",
-		from: "outbound@salestool.co",
-		subject: "Quick question about Acme's AI strategy",
-		snippet: "Saw your post on LinkedIn. Would love to connect for 15 min this week?",
-		receivedAt: "2026-04-21T04:30:00Z",
-	},
-	{
-		id: "e47",
-		from: "recruiter@megacorp.com",
-		subject: "Sr. Eng role at MegaCorp — interested?",
-		snippet:
-			"Based on your GitHub activity, you'd be a great fit for our infra team. Open to a chat?",
-		receivedAt: "2026-04-21T04:45:00Z",
-	},
-	{
-		id: "e48",
-		from: "no-reply@linkedin.com",
-		subject: "5 people viewed your profile this week",
-		snippet: "See who's interested. Upgrade to Premium to see all viewers.",
-		receivedAt: "2026-04-21T05:00:00Z",
-	},
-
-	// --- Mixed (automated but actually useful) ---
-	{
-		id: "e49",
-		from: "statuspage@provider.io",
-		subject: "[Investigating] Elevated error rate on US-West region",
-		snippet: "Started 08:42 UTC. Affecting ~3% of reads. Updates every 15 min.",
-		receivedAt: "2026-04-21T08:45:00Z",
-	},
-	{
-		id: "e50",
-		from: "noreply@1password.com",
-		subject: "Security alert: new sign-in from Chrome on macOS",
-		snippet: "If this was you, no action needed. If not, lock your account immediately.",
-		receivedAt: "2026-04-21T08:50:00Z",
-	},
-];
diff --git a/examples/inbox-reducer/index.ts b/examples/inbox-reducer/index.ts
deleted file mode 100644
index 6d3e0141..00000000
--- a/examples/inbox-reducer/index.ts
+++ /dev/null
@@ -1,291 +0,0 @@
-/**
- * Inbox reducer — runnable entry.
- *
- * Orchestration only. The pipeline topology lives in [pipeline.ts](./pipeline.ts)
- * (the copy-paste target); provider wiring in [adapter-stack.ts](./adapter-stack.ts);
- * dry-run mock in [dry-run-mock.ts](./dry-run-mock.ts); config in [config.ts](./config.ts).
- *
- * Flow:
- *   1. DRY RUN    — mock adapter, real prompts. Reports exact token counts,
- *                   USD estimate (if pricing in config), and exercises the
- *                   full observability surface (`graph.explain`, diagram link).
- *   2. CONFIRM    — prompt user (--yes to skip).
- *   3. REAL RUN   — resilientAdapter(withReplayCache(observableAdapter(provider))).
- *                   Stage log, budget stream, morning brief, causal chain.
- *   4. DELTA DEMO — push a 51st email, watch ONLY downstream-of-change re-fire.
- *                   Shows reactive recompute: fewer LLM calls than a full rerun.
- */
-
-import { existsSync, mkdirSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { createInterface } from "node:readline";
-import { fileURLToPath } from "node:url";
-
-import {
-	awaitSettled,
-	DATA,
-	type Messages,
-	TimeoutError,
-	type TokenUsage,
-	validateGraphObservability,
-} from "@graphrefly/graphrefly";
-import { graphSpecToAscii } from "@graphrefly/graphrefly/extra/render";
-import { computePrice, observableAdapter } from "@graphrefly/graphrefly/patterns/ai";
-
-import { assertApiKey, buildAdapterStack } from "./adapter-stack.js";
-import { config } from "./config.js";
-import { buildDryRunMock } from "./dry-run-mock.js";
-import { EMAILS, type Email } from "./emails.js";
-import { inboxReducerGraph } from "./pipeline.js";
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const CACHE_DIR = join(__dirname, ".cache");
-const BRIEF_TIMEOUT_MS = Number(process.env.INBOX_TIMEOUT_MS ?? "120000");
-
-// ---------------------------------------------------------------------------
-// Small I/O helpers
-// ---------------------------------------------------------------------------
-
-const hr = (char = "─", width = 72): string => char.repeat(width);
-
-async function confirm(question: string): Promise<boolean> {
-	if (process.argv.includes("--yes") || process.argv.includes("-y")) return true;
-	const rl = createInterface({ input: process.stdin, output: process.stdout });
-	return new Promise((resolve) => {
-		rl.question(`${question} [y/N] `, (ans) => {
-			rl.close();
-			resolve(ans.trim().toLowerCase() === "y");
-		});
-	});
-}
-
-// (Flowchart rendering — `graphSpecToAscii(graph.describe())` from
-// `@graphrefly/graphrefly/extra/render` produces a stdout-native DAG diagram
-// with Unicode box-drawing glyphs. For clickable mermaid,
-// `graphSpecToMermaidUrl(graph.describe())` encodes a mermaid.live deep
-// link; for bare mermaid text use `graphSpecToMermaid`.)
-
-// ---------------------------------------------------------------------------
-// Stage-log formatter for subscribers
-// ---------------------------------------------------------------------------
-
-function stageLog(name: string, tag = "stage"): (msgs: Messages) => void {
-	return (msgs) => {
-		for (const [type, value] of msgs) {
-			if (type !== DATA) continue;
-			let preview: string;
-			if (Array.isArray(value)) preview = `${value.length} items`;
-			else if (typeof value === "string") preview = `${value.length} chars`;
-			else if (value == null) preview = "null";
-			else preview = typeof value;
-			console.log(`[${tag}]     ${name.padEnd(16)} → ${preview}`);
-		}
-	};
-}
-
-// ---------------------------------------------------------------------------
-// DRY RUN — mock adapter, full observability surface
-// ---------------------------------------------------------------------------
-
-async function dryRun(): Promise<void> {
-	console.log(`\n${hr("═")}`);
-	console.log("DRY RUN — no API calls, no spend");
-	console.log(hr("═"));
-	console.log(`Provider:   ${config.primary.kind}    Model: ${config.primary.model}`);
-	console.log(`Cache dir:  ${CACHE_DIR}`);
-	console.log(`Timeout:    ${BRIEF_TIMEOUT_MS}ms (INBOX_TIMEOUT_MS)`);
-
-	const { adapter, stats } = observableAdapter(
-		buildDryRunMock(config.primary.kind, config.primary.model),
-		{ name: `${config.primary.model}::dryrun` },
-	);
-	const { graph, brief } = inboxReducerGraph(adapter, EMAILS);
-
-	try {
-		await awaitSettled(brief, {
-			predicate: (v) => typeof v === "string",
-			timeoutMs: BRIEF_TIMEOUT_MS,
-		});
-
-		// Smoke-exercise every observability surface the real run touches —
-		// if describe / explain / ascii renderers regress, we fail loud HERE
-		// instead of after any wire spend (CLAUDE.md "Dry-run equivalence rule").
-		const smoke = validateGraphObservability(graph, {
-			pairs: [["emails", "brief"]],
-			formats: ["ascii", "pretty"],
-		});
-		if (!smoke.ok) {
-			console.error(`\n!! ${smoke.summary()}. Aborting before any spend.`);
-			for (const f of smoke.failures) console.error(JSON.stringify(f));
-			process.exit(3);
-		}
-		const chain = graph.describe({ explain: { from: "emails", to: "brief" } });
-		console.log(
-			`Causal chain: ${chain.steps.length} hops (${chain.steps.map((s) => s.path).join(" → ")})`,
-		);
-		// Exercise the `.text` render too — the real run prints it.
-		if (chain.text.length < 10) {
-			console.error(`\n!! describe({ explain }).text render is degenerate. Aborting.`);
-			process.exit(3);
-		}
-		// Path 1B — stdout-native DAG flowchart via the `graphSpecToAscii`
-		// pure renderer over `graph.describe()`.
-		console.log("\nFlowchart:");
-		console.log(graphSpecToAscii(graph.describe()));
-	} finally {
-		graph.destroy();
-	}
-
-	const inputTokens = stats.totalInputTokens.cache ?? 0;
-	const outputTokens = stats.totalOutputTokens.cache ?? 0;
-	const calls = stats.totalCalls.cache ?? 0;
-
-	console.log(`\nLLM calls this run:  ${calls}`);
-	console.log(`Input tokens:        ${inputTokens.toLocaleString()}`);
-	console.log(`Output tokens (mock): ${outputTokens.toLocaleString()}`);
-
-	const pricing = config.primary.capabilities?.pricing;
-	if (pricing) {
-		const usage: TokenUsage = {
-			input: { regular: inputTokens },
-			output: { regular: outputTokens },
-		};
-		const price = computePrice(usage, pricing);
-		console.log(
-			`Estimated cost:      $${price.total.toFixed(4)} ${price.currency} (from config.ts pricing).`,
-		);
-	} else {
-		console.log(
-			"Estimated cost:      not computed — add `capabilities.pricing` in config.ts for USD.",
-		);
-	}
-	console.log();
-}
-
-// ---------------------------------------------------------------------------
-// REAL RUN — full safety stack, stage log, causal chain, then DELTA demo
-// ---------------------------------------------------------------------------
-
-async function realRun(): Promise<void> {
-	assertApiKey(config.primary);
-	if (config.fallback) assertApiKey(config.fallback);
-	if (!existsSync(CACHE_DIR)) mkdirSync(CACHE_DIR, { recursive: true });
-
-	console.log(`\n${hr("═")}`);
-	console.log("REAL RUN");
-	console.log(hr("═"));
-
-	const { adapter, stats, onBudget } = buildAdapterStack(config, CACHE_DIR);
-	onBudget?.((line) => console.log(`[budget]    ${line}`));
-
-	const { graph, emails, classifications, actionable, extractions, ranked, top3, brief } =
-		inboxReducerGraph(adapter, EMAILS);
-
-	// Wire stage logs. `graph.destroy` will TEARDOWN these subscribers, so
-	// we don't need to collect unsub tokens.
-	emails.subscribe(stageLog("emails"));
-	classifications.subscribe(stageLog("classifications"));
-	actionable.subscribe(stageLog("actionable"));
-	extractions.subscribe(stageLog("extractions"));
-	ranked.subscribe(stageLog("ranked"));
-	top3.subscribe(stageLog("top3"));
-	brief.subscribe(stageLog("brief"));
-
-	try {
-		const briefText = await awaitSettled(brief, {
-			predicate: (v) => typeof v === "string",
-			timeoutMs: BRIEF_TIMEOUT_MS,
-		});
-
-		console.log(`\n${hr("═")}`);
-		console.log("MORNING BRIEF");
-		console.log(hr("═"));
-		console.log(briefText);
-
-		console.log(`\n${hr("═")}`);
-		console.log("CAUSAL CHAIN — graph.describe({ explain: { from: 'emails', to: 'brief' } })");
-		console.log(hr("═"));
-		console.log(graph.describe({ explain: { from: "emails", to: "brief" } }).text);
-
-		// --- Path 2: reactive delta demo --------------------------------------
-		console.log(`\n${hr("═")}`);
-		console.log("REACTIVE DELTA — push a 51st email, wait for pipeline to re-fire");
-		console.log(hr("═"));
-		console.log("Resetting call counter, pushing a 51st email...\n");
-		// Reference `briefText` to silence the unused-variable warning — we
-		// used to compare against it; the counter-based gate below is more
-		// robust, but keeping the capture documents that we saw a prior value.
-		void briefText;
-		stats.reset();
-
-		const newEmail: Email = {
-			id: "e51",
-			from: "carol@acme.co",
-			subject: "Can you approve the Q3 budget by tomorrow?",
-			snippet: "Finance needs sign-off on the attached line items before tomorrow's board meeting.",
-			receivedAt: "2026-04-22T08:00:00Z",
-		};
-		emails.emit([...EMAILS, newEmail]);
-
-		// Count-based gate: wait for classify + extract + brief to all fire
-		// once on the new input (3 total delta calls). Avoids both the
-		// push-on-subscribe race (stale cached brief) AND the false-timeout
-		// when the model happens to return an identical brief for similar
-		// inputs. `stats.totalCalls` was reset above, so this counts only
-		// delta-triggered calls.
-		await awaitSettled(stats.totalCalls, {
-			predicate: (n) => n >= 3,
-			timeoutMs: BRIEF_TIMEOUT_MS,
-		});
-
-		const deltaCalls = stats.totalCalls.cache ?? 0;
-		const deltaIn = stats.totalInputTokens.cache ?? 0;
-		const deltaOut = stats.totalOutputTokens.cache ?? 0;
-		console.log(
-			`\nDelta complete: ${deltaCalls} LLM calls · ${deltaIn.toLocaleString()}t in · ${deltaOut.toLocaleString()}t out.`,
-		);
-		console.log("");
-		console.log("Honest read of this topology:");
-		console.log("  classify/extract/brief ALL re-fire because the classify prompt batches");
-		console.log("  every email — a single-email delta still rebuilds every stage.");
-		console.log("  The reactive topology DID save work on the deterministic nodes (actionable,");
-		console.log("  ranked, top3 — pure recompute, no LLM), but LLM spend is driven by the prompt");
-		console.log("  shape, not reactivity alone.");
-		console.log("");
-		console.log("To get a real reactive-savings win, split classify into a per-email `map` —");
-		console.log("then a 1-email delta is 1 classify + 1 extract + 1 brief = 3 small calls vs.");
-		console.log("50+1+1 = 52 for a full rerun. Topology determines the savings.");
-	} finally {
-		const finalStats = `${stats.totalCalls.cache ?? 0} wire calls · ${(stats.totalInputTokens.cache ?? 0).toLocaleString()}t in · ${(stats.totalOutputTokens.cache ?? 0).toLocaleString()}t out`;
-		console.log(`\n${hr("─")}`);
-		console.log(`Final delta stats: ${finalStats}`);
-		console.log(`Replay cache at ${CACHE_DIR} — delete to force fresh API calls.`);
-		graph.destroy();
-	}
-}
-
-// ---------------------------------------------------------------------------
-// Main
-// ---------------------------------------------------------------------------
-
-(async () => {
-	await dryRun();
-	const ok = await confirm("Proceed to real run?");
-	if (!ok) {
-		console.log("Cancelled — no API calls made.");
-		process.exit(0);
-	}
-	await realRun();
-})().catch((err) => {
-	if (err instanceof TimeoutError) {
-		console.error(
-			`\nBrief did not settle within ${BRIEF_TIMEOUT_MS}ms (INBOX_TIMEOUT_MS).` +
-				"\nCheck the [adapter] lines above for the real cause; raise INBOX_TIMEOUT_MS" +
-				"\nfor slow local models, or drop resilience.timeoutMs in config.ts if a" +
-				"\nper-call timeout is aborting individual HTTP calls too quickly.",
-		);
-	} else {
-		console.error("\nRun failed:", err);
-	}
-	process.exit(1);
-});
diff --git a/examples/inbox-reducer/package.json b/examples/inbox-reducer/package.json
deleted file mode 100644
index 76fba780..00000000
--- a/examples/inbox-reducer/package.json
+++ /dev/null
@@ -1,17 +0,0 @@
-{
-	"name": "@graphrefly-examples/inbox-reducer",
-	"private": true,
-	"version": "0.0.8",
-	"type": "module",
-	"description": "Inbox reducer — 50 mock emails → 3-bullet morning brief. Exercises resilientAdapter, withReplayCache, withDryRun + observableAdapter, promptNode, and graph.explain against a real LLM provider.",
-	"scripts": {
-		"start": "tsx index.ts"
-	},
-	"dependencies": {
-		"@graphrefly/graphrefly": "workspace:*"
-	},
-	"devDependencies": {
-		"tsx": "^4.21.0",
-		"typescript": "^5.7.0"
-	}
-}
diff --git a/examples/inbox-reducer/pipeline.ts b/examples/inbox-reducer/pipeline.ts
deleted file mode 100644
index 373291ef..00000000
--- a/examples/inbox-reducer/pipeline.ts
+++ /dev/null
@@ -1,240 +0,0 @@
-/**
- * Inbox-reducer pipeline — the core graph topology.
- *
- * **This is the file to copy if you want a reactive LLM pipeline.** Every
- * building block is shipped; all this file does is wire 7 named nodes
- * (3 LLM hops + 4 deterministic derivations) into one `Graph`.
- *
- * ```
- *   emails (state)
- *     │  promptNode — classify
- *     ▼
- *   classifications ─┐
- *     │              │
- *     ▼              │
- *   actionable (filter)
- *     │              │  promptNode — extract
- *     ▼              │
- *   extractions ─────┤
- *     │              │
- *     ▼              ▼
- *   ranked (score + sort)
- *     │
- *     ▼
- *   top3 (take 3)
- *     │  promptNode — brief
- *     ▼
- *   brief (string)
- * ```
- *
- * 3 LLM calls total — not 50. `classifications` is consumed by multiple
- * downstream derivations (`actionable`, `ranked`) but the LLM runs once;
- * every other node is pure reactive math.
- *
- * Annotations live next to `graph.add` via the `annotation` option — they
- * surface in `graph.describe({ explain: { from: "emails", to: "brief" } })`
- * output and in `describe()`, so the final causal-chain printout documents
- * the pipeline's own reasoning.
- */
-
-import { derived, Graph, type LLMAdapter, type Node, state } from "@graphrefly/graphrefly";
-import { promptNode } from "@graphrefly/graphrefly/patterns/ai";
-import type { Email } from "./emails.js";
-
-// ----------------------------------------------------------------------------
-// Types — the shape of what flows through each stage
-// ----------------------------------------------------------------------------
-
-export interface Classification {
-	readonly id: string;
-	readonly actionable: boolean;
-	readonly priority: 1 | 2 | 3 | 4 | 5;
-	readonly category: "personal" | "work" | "billing" | "promo" | "notification" | "newsletter";
-	readonly confidence: number;
-}
-
-export interface ActionItem {
-	readonly id: string;
-	readonly title: string;
-	readonly action: string;
-	readonly deadline?: string;
-	readonly entities: readonly string[];
-}
-
-export interface RankedItem {
-	readonly item: ActionItem;
-	readonly classification: Classification;
-	readonly score: number;
-}
-
-export interface InboxReducerGraph {
-	readonly graph: Graph;
-	readonly emails: Node<readonly Email[]>;
-	readonly classifications: Node<readonly Classification[] | null>;
-	readonly actionable: Node<readonly Email[] | null>;
-	readonly extractions: Node<readonly ActionItem[] | null>;
-	readonly ranked: Node<readonly RankedItem[] | null>;
-	readonly top3: Node<readonly RankedItem[] | null>;
-	readonly brief: Node<string | null>;
-}
-
-// ----------------------------------------------------------------------------
-// Prompt heads — single source of truth
-//
-// Exported so the dry-run mock (and any other offline fixture source) can
-// route responses by matching on these exact strings. Change them here; the
-// mock keeps working.
-// ----------------------------------------------------------------------------
-
-export const CLASSIFY_HEAD =
-	"Classify each email below. Return a JSON array with one object per email in the SAME order.";
-export const EXTRACT_HEAD =
-	"For each email below, extract ONE action item the recipient must do. Return a JSON array in the SAME order as the input.";
-export const BRIEF_HEAD = "Write a 3-bullet morning brief covering these top action items.";
-
-const CLASSIFY_SYSTEM =
-	"You are an email triage assistant. Output valid JSON only — no prose, no markdown fences.";
-const EXTRACT_SYSTEM =
-	"You extract concrete action items from emails. Output valid JSON only — no prose, no markdown fences.";
-const BRIEF_SYSTEM = "You write concise morning briefings. Plain text only. No markdown.";
-
-const classifyPrompt = (emails: readonly Email[]): string =>
-	[
-		CLASSIFY_HEAD,
-		"Each object: {id, actionable, priority (1-5), category, confidence (0..1)}.",
-		"- actionable=true means the recipient must DO something (reply/approve/sign/decide).",
-		"- Promotional / newsletter / receipt / resolved-notification = actionable=false.",
-		"- priority 5 = blocker today, 1 = can ignore.",
-		"",
-		JSON.stringify(emails, null, 2),
-	].join("\n");
-
-const extractPrompt = (emails: readonly Email[]): string =>
-	[
-		EXTRACT_HEAD,
-		"Each object: {id, title (<=60 chars), action (imperative verb phrase), deadline?, entities: string[]}.",
-		"",
-		JSON.stringify(emails, null, 2),
-	].join("\n");
-
-const briefPrompt = (items: readonly RankedItem[]): string =>
-	[
-		BRIEF_HEAD,
-		"Use dashes for bullets. Keep each bullet under 20 words. No preamble.",
-		"",
-		JSON.stringify(
-			items.map((r) => ({
-				title: r.item.title,
-				action: r.item.action,
-				deadline: r.item.deadline,
-				priority: r.classification.priority,
-			})),
-			null,
-			2,
-		),
-	].join("\n");
-
-// ----------------------------------------------------------------------------
-// Builder — the pipeline itself, ~40 lines of wiring
-// ----------------------------------------------------------------------------
-
-export function inboxReducerGraph(
-	adapter: LLMAdapter,
-	initialEmails: readonly Email[],
-): InboxReducerGraph {
-	const graph = new Graph("inbox-reducer");
-
-	const emails = state<readonly Email[]>(initialEmails, { name: "emails" });
-	graph.add(emails, {
-		name: "emails",
-		annotation: "Raw inbox. In production: fromStorage / fromIMAP / fromGmail.",
-	});
-
-	const classifications = promptNode<readonly Classification[]>(
-		adapter,
-		[emails],
-		(es) => classifyPrompt(es as readonly Email[]),
-		{ name: "classify", format: "json", systemPrompt: CLASSIFY_SYSTEM },
-	);
-	graph.add(classifications, {
-		name: "classifications",
-		annotation:
-			"LLM-classified {actionable, priority, category, confidence} per email. One batched call.",
-	});
-
-	// `actionable` returns null while classifications haven't settled, so the
-	// downstream `extract` promptNode's SENTINEL gate skips until real data
-	// arrives. See COMPOSITION-GUIDE §8 (promptNode SENTINEL gate).
-	const actionable = derived<readonly Email[] | null>(
-		[emails, classifications],
-		([rawEmails, rawClass]) => {
-			const cs = rawClass as readonly Classification[] | null;
-			if (cs == null) return null;
-			const es = rawEmails as readonly Email[];
-			const byId = new Map(cs.map((c) => [c.id, c]));
-			return es.filter((e) => byId.get(e.id)?.actionable === true);
-		},
-		{ name: "actionable" },
-	);
-	graph.add(actionable, {
-		name: "actionable",
-		annotation: "Filter: keep emails where classification.actionable === true.",
-	});
-
-	const extractions = promptNode<readonly ActionItem[]>(
-		adapter,
-		[actionable],
-		(as) => extractPrompt(as as readonly Email[]),
-		{ name: "extract", format: "json", systemPrompt: EXTRACT_SYSTEM },
-	);
-	graph.add(extractions, {
-		name: "extractions",
-		annotation: "Structured action items for the actionable subset. One batched call.",
-	});
-
-	const ranked = derived<readonly RankedItem[] | null>(
-		[extractions, classifications],
-		([rawExt, rawClass]) => {
-			const items = rawExt as readonly ActionItem[] | null;
-			const cs = rawClass as readonly Classification[] | null;
-			if (items == null || cs == null) return null;
-			const byId = new Map(cs.map((c) => [c.id, c]));
-			const out: RankedItem[] = [];
-			for (const item of items) {
-				const cl = byId.get(item.id);
-				if (!cl) continue;
-				out.push({ item, classification: cl, score: cl.priority * cl.confidence });
-			}
-			out.sort((a, b) => b.score - a.score);
-			return out;
-		},
-		{ name: "ranked" },
-	);
-	graph.add(ranked, {
-		name: "ranked",
-		annotation: "Rank by classification.priority × classification.confidence. Deterministic.",
-	});
-
-	const top3 = derived<readonly RankedItem[] | null>(
-		[ranked],
-		([raw]) => {
-			const r = raw as readonly RankedItem[] | null;
-			return r == null ? null : r.slice(0, 3);
-		},
-		{ name: "top3" },
-	);
-	graph.add(top3, { name: "top3", annotation: "Top 3 by score — the daily action list." });
-
-	const brief = promptNode<string>(
-		adapter,
-		[top3],
-		(t3) => briefPrompt(t3 as readonly RankedItem[]),
-		{ name: "brief", format: "text", systemPrompt: BRIEF_SYSTEM },
-	);
-	graph.add(brief, {
-		name: "brief",
-		annotation: "Human-readable 3-bullet morning brief authored by the LLM from the top-3.",
-	});
-
-	return { graph, emails, classifications, actionable, extractions, ranked, top3, brief };
-}
diff --git a/examples/inbox-reducer/tsconfig.json b/examples/inbox-reducer/tsconfig.json
deleted file mode 100644
index 72a7b95d..00000000
--- a/examples/inbox-reducer/tsconfig.json
+++ /dev/null
@@ -1,12 +0,0 @@
-{
-	"compilerOptions": {
-		"target": "ES2022",
-		"module": "ES2022",
-		"moduleResolution": "bundler",
-		"strict": true,
-		"esModuleInterop": true,
-		"skipLibCheck": true,
-		"noEmit": true
-	},
-	"include": ["index.ts", "pipeline.ts", "emails.ts", "config.ts"]
-}
diff --git a/examples/knowledge-graph/README.md b/examples/knowledge-graph/README.md
index 46e922a5..68ab8883 100644
--- a/examples/knowledge-graph/README.md
+++ b/examples/knowledge-graph/README.md
@@ -1,10 +1,18 @@
-# Knowledge-graph extraction (Node-runnable)
+# Knowledge-graph extraction
 
-Pre-parsed documents → reactive `effect` → `knowledgeGraph()` → live `graph.describe({ explain: {...}, reactive: true })`.
+Pre-parsed documents -> graph-visible `KnowledgeAssertion` facts ->
+`knowledgeGraphReducerBundle()` -> deterministic entity/relation/topic
+projections.
 
-Mirrors the browser demo at `demos/knowledge-graph/` (which uses Chrome's built-in Gemini Nano against a real long paper). This example uses pre-parsed documents so it runs in CI with no API key, no model download, no network.
+This is the clean-slate Node-runnable successor for the same concept as the
+retired pre-CSP-9 browser demo formerly under `demos/knowledge-graph/`. That
+browser demo depended on retired root/pure-ts demo surfaces, so it is no longer
+part of the active tree. This example uses pre-parsed documents, so it runs
+with no API key, no model download, and no network.
+
+## Run
 
 ```bash
 pnpm install
-pnpm --filter @graphrefly-examples/knowledge-graph start
+pnpm start
 ```
diff --git a/examples/knowledge-graph/index.ts b/examples/knowledge-graph/index.ts
index 62f0fa9f..8dd75c0d 100644
--- a/examples/knowledge-graph/index.ts
+++ b/examples/knowledge-graph/index.ts
@@ -1,38 +1,31 @@
 /**
- * Knowledge-graph extraction — Node-runnable mirror of the browser demo.
+ * Knowledge-graph extraction — clean-slate Node example.
  *
- * Per SESSION-strategy-roadmap-demo-reprioritization.md: this example uses
- * pre-parsed documents (NOT a real LLM call) so it runs in CI / on a laptop
- * with no API key. The browser demo at `demos/knowledge-graph/` runs the same
- * pipeline against Chrome's built-in Gemini Nano.
- *
- * Pipeline:
- *
- *   fromArray(docs)          (source — pre-extracted entities + relations)
- *        │
- *        ▼
- *   apply-extraction         (effect — kg.upsertEntity / kg.link)
- *        │
- *        ▼
- *   kg/{entities,edges,adjacency}   (UI / consumers subscribe here)
- *        │
- *        ▼
- *   kg.describe({ explain: { from: "docs", to: "adjacency" }, reactive: true })  (live causal chain)
+ * Pre-parsed documents become graph-visible KnowledgeAssertion facts. The
+ * semantic-memory reducer bundle materializes deterministic entity, relation,
+ * topic, status, and error projections without owning LLM extraction, storage,
+ * or an imperative graph mutation API.
  */
 
-import { DATA, effect } from "@graphrefly/graphrefly/core";
-import { fromIter } from "@graphrefly/graphrefly/extra/sources";
-import { knowledgeGraph } from "@graphrefly/graphrefly/patterns/memory";
+import { graph } from "@graphrefly/ts";
+import {
+	type KnowledgeAssertion,
+	type KnowledgeGraphRelation,
+	type KnowledgeGraphStatus,
+	knowledgeGraphReducerBundle,
+} from "@graphrefly/ts/patterns";
 
 type Entity = { id: string; label: string; kind: string };
 type Relation = "addresses" | "is_a" | "part_of" | "uses";
 type Doc = {
-	entities: Entity[];
-	relations: Array<{ from: string; to: string; relation: Relation }>;
+	readonly id: string;
+	readonly entities: readonly Entity[];
+	readonly relations: readonly { from: string; to: string; relation: Relation }[];
 };
 
 const DOCS: readonly Doc[] = [
 	{
+		id: "doc-1",
 		entities: [
 			{ id: "harness", label: "AI Harness Engineering", kind: "concept" },
 			{ id: "alignment", label: "AI Alignment", kind: "concept" },
@@ -44,6 +37,7 @@ const DOCS: readonly Doc[] = [
 		],
 	},
 	{
+		id: "doc-2",
 		entities: [
 			{ id: "hitl", label: "Human-in-the-Loop", kind: "method" },
 			{ id: "brittleness", label: "Value Brittleness", kind: "risk" },
@@ -55,6 +49,7 @@ const DOCS: readonly Doc[] = [
 		],
 	},
 	{
+		id: "doc-3",
 		entities: [
 			{ id: "interpretability", label: "Mechanistic Interpretability", kind: "method" },
 			{ id: "redteam", label: "Red Teaming", kind: "method" },
@@ -67,52 +62,116 @@ const DOCS: readonly Doc[] = [
 	},
 ];
 
-const kg = knowledgeGraph<Entity, Relation>("paper-kg");
-
-const docs = fromIter<Doc>(DOCS, { name: "docs" });
-kg.add(docs, { name: "docs" });
+function assertionsFromDocs(docs: readonly Doc[]): KnowledgeAssertion[] {
+	const byId = new Map<string, Entity>();
+	for (const doc of docs) {
+		for (const entity of doc.entities) byId.set(entity.id, entity);
+	}
 
-const apply = effect(
-	[docs],
-	([doc]) => {
-		const d = doc as Doc | undefined;
-		if (!d) return;
-		const ids = new Set(d.entities.map((e) => e.id));
-		for (const e of d.entities) kg.upsertEntity(e.id, e);
-		for (const r of d.relations) {
-			if (!ids.has(r.from) || !ids.has(r.to)) continue;
-			kg.link(r.from, r.to, r.relation);
+	const assertions: KnowledgeAssertion[] = [];
+	for (const doc of docs) {
+		for (const entity of doc.entities) {
+			assertions.push({
+				id: `${doc.id}:label:${entity.id}`,
+				subject: { id: entity.id, type: entity.kind },
+				predicate: "label",
+				object: { kind: "value", value: entity.label, valueType: "text" },
+				confidence: 1,
+				sources: [doc.id],
+				provenance: "pre-parsed-demo-doc",
+			});
 		}
-	},
-	{ name: "apply-extraction" },
-);
-kg.add(apply, { name: "apply-extraction" });
+		for (const relation of doc.relations) {
+			const subject = byId.get(relation.from);
+			const object = byId.get(relation.to);
+			if (subject === undefined || object === undefined) continue;
+			assertions.push({
+				id: `${doc.id}:${relation.from}:${relation.relation}:${relation.to}`,
+				subject: { id: subject.id, type: subject.kind },
+				predicate: relation.relation,
+				object: { kind: "entity", id: object.id, type: object.kind },
+				confidence: 0.9,
+				sources: [doc.id],
+				provenance: "pre-parsed-demo-doc",
+			});
+		}
+	}
+	return assertions;
+}
 
-// Live causal chain. Re-derives whenever any node along the path fires.
-const explain = kg.describe({ explain: { from: "docs", to: "adjacency" }, reactive: true });
-explain.node.subscribe((msgs) => {
-	for (const [type, value] of msgs) {
-		if (type !== DATA) continue;
-		const chain = value as { found: boolean; steps?: ReadonlyArray<{ path: string }> };
-		if (!chain.found) continue;
-		const path = chain.steps?.map((s) => s.path).join(" → ") ?? "";
-		console.log(`explainPath: ${path}`);
+function activate<T>(node: {
+	subscribe: (sink: (message: readonly [string, unknown?]) => void) => () => void;
+}): { readonly value: T; readonly unsubscribe: () => void } {
+	let latest: T | undefined;
+	const unsubscribe = node.subscribe(([type, value]) => {
+		if (type === "DATA") latest = value as T;
+	});
+	if (latest === undefined) {
+		unsubscribe();
+		throw new Error("expected node to emit DATA on subscribe");
 	}
-});
+	return { value: latest, unsubscribe };
+}
 
-// Print final KG snapshot.
-const entities = kg.resolve("entities").cache as ReadonlyMap<string, Entity>;
-const edges = kg.resolve("edges").cache as
-	| ReadonlyArray<{ from: string; to: string; relation: Relation }>
-	| undefined;
+const g = graph({ name: "knowledge-graph-example" });
+const docs = g.state(DOCS, { name: "docs" });
+const assertions = g.derived([docs], assertionsFromDocs, { name: "assertions" });
+const policy = g.state(
+	{ allowedPredicates: ["addresses", "is_a", "label", "part_of", "uses"] },
+	{ name: "policy" },
+);
+const kg = knowledgeGraphReducerBundle(g, { name: "kg", assertions, policy });
 
-console.log(`\nentities (${entities.size}):`);
-for (const e of entities.values()) {
-	console.log(`  ${e.id} [${e.kind}] — ${e.label}`);
+const subscriptions: [
+	{ readonly value: KnowledgeGraphStatus; readonly unsubscribe: () => void },
+	{ readonly value: readonly { id: string; type?: string }[]; readonly unsubscribe: () => void },
+	{ readonly value: readonly KnowledgeGraphRelation[]; readonly unsubscribe: () => void },
+	{
+		readonly value: readonly { predicate: string; assertionIds: readonly string[] }[];
+		readonly unsubscribe: () => void;
+	},
+] = [] as never;
+try {
+	subscriptions.push(activate<KnowledgeGraphStatus>(kg.status));
+	subscriptions.push(activate<readonly { id: string; type?: string }[]>(kg.entities));
+	subscriptions.push(activate<readonly KnowledgeGraphRelation[]>(kg.relations));
+	subscriptions.push(
+		activate<readonly { predicate: string; assertionIds: readonly string[] }[]>(kg.topics),
+	);
+} catch (error) {
+	for (const subscription of subscriptions) subscription.unsubscribe();
+	throw error;
+}
+const [status, entities, relations, topics] = subscriptions.map(({ value }) => value) as [
+	KnowledgeGraphStatus,
+	readonly { id: string; type?: string }[],
+	readonly KnowledgeGraphRelation[],
+	readonly { predicate: string; assertionIds: readonly string[] }[],
+];
+
+console.log(`status: ${status.state}`);
+console.log(`entities (${entities.length}):`);
+for (const entity of entities) {
+	console.log(`  ${entity.id}${entity.type === undefined ? "" : ` [${entity.type}]`}`);
 }
-console.log(`\nedges (${edges?.length ?? 0}):`);
-for (const e of edges ?? []) {
-	console.log(`  ${e.from} —${e.relation}→ ${e.to}`);
+
+console.log(`\nrelations (${relations.length}):`);
+for (const relation of relations) {
+	const object =
+		relation.object.kind === "entity"
+			? relation.object.id
+			: `${relation.object.valueType ?? "value"}:${String(relation.object.value)}`;
+	console.log(`  ${relation.subject.id} -${relation.predicate}-> ${object}`);
+}
+
+console.log(`\ntopics (${topics.length}):`);
+for (const topic of topics) {
+	console.log(`  ${topic.predicate}: ${topic.assertionIds.length}`);
+}
+
+console.log("\ncausal chain:");
+for (const edge of g.describe({ explain: { from: "docs", to: "kg/relations" } }).edges) {
+	console.log(`  ${edge.from} -> ${edge.to}`);
 }
 
-explain.dispose();
+for (const subscription of subscriptions) subscription.unsubscribe();
diff --git a/examples/knowledge-graph/package.json b/examples/knowledge-graph/package.json
index 7689a2c8..0c2f73e2 100644
--- a/examples/knowledge-graph/package.json
+++ b/examples/knowledge-graph/package.json
@@ -3,12 +3,12 @@
 	"private": true,
 	"version": "0.0.8",
 	"type": "module",
-	"description": "Reactive knowledge-graph extraction — pre-extracted documents → KG → adjacency. Node-runnable mirror of the browser demo.",
+	"description": "Reactive knowledge-graph reducer over graph-visible semantic-memory assertion facts.",
 	"scripts": {
 		"start": "tsx index.ts"
 	},
 	"dependencies": {
-		"@graphrefly/graphrefly": "workspace:*"
+		"@graphrefly/ts": "workspace:*"
 	},
 	"devDependencies": {
 		"tsx": "^4.21.0",
diff --git a/examples/nestjs-graph-boundary/README.md b/examples/nestjs-graph-boundary/README.md
new file mode 100644
index 00000000..6c00f7bd
--- /dev/null
+++ b/examples/nestjs-graph-boundary/README.md
@@ -0,0 +1,32 @@
+# NestJS Graph Boundary
+
+Clean-slate NestJS integration demo for `@graphrefly/ts/adapters/nestjs`.
+
+The demo uses the D494/D495 provider bundle helpers over D486/D488 phase bridges: `POST /echo` and `POST /orders` bind existing graph boundary nodes with `@GraphReq(...)` and `@GraphHttpReply(...)`, the WebSocket gateway binds `@GraphWs(...)` with `@GraphWsAck(...)` and `@GraphWsReply(...)`, and the message-pattern controller binds `@GraphMessage(...)` with `@GraphMessageReply(...)`. Standard GraphReFly Nest providers consume the metadata for interceptor, guard, filter, cron, lifecycle, WebSocket, and message phases. `POST /orders` also shows guard denial response headers through the targeted GraphReFly guard-denial filter. It also shows a Nest Logger provider observing the graph-visible `orders.audit` node through `graph.observe(...)` and an explicit diagnostics boundary for sanitized adapter diagnostics.
+
+The adapter owns only keyed ingress/egress bindings and host-private pending handles. Admission, policy, audit, and lifecycle semantics are ordinary graph composition. Provider bundles reduce Nest module boilerplate, but they do not scan the container, create graphs, own business graphs, hide route registries, hide event buses, or own retry/session/transport lifecycle policy.
+
+```bash
+pnpm --filter @graphrefly-examples/nestjs-graph-boundary start
+```
+
+Endpoints:
+
+- `POST /echo`
+- `POST /policy`
+- `POST /orders`
+- `POST /handled-error`
+- `POST /cron/tick`
+- `POST /cron/check`
+- `GET /audit/:requestId`
+- `POST /lifecycle/teardown`
+- WebSocket `orders.reserve` on `/graphrefly`
+- TCP microservice pattern `orders.reserve` on `MICRO_HOST:MICRO_PORT` (default `127.0.0.1:3001`)
+
+Use `x-request-id` for stable request ids; otherwise the demo uses deterministic process-local ids.
+
+`POST /cron/check` runs the deterministic manual cron controller for an optional JSON body such as `{ "iso": "2026-01-05T08:30:00.000Z" }`.
+
+Cron missed ticks while the host is unavailable are skipped by default; restart or resume continues from the current time and does not synthesize missed-status or catch-up DATA. Cron remains five-field and minute-granularity; no seconds grammar or scheduledAt/actualAt/missedCount envelope is added.
+
+WebSocket sockets, ack callbacks, and microservice contexts stay host-private. Graph-visible DATA carries only the selected payload envelope and reply correlation uses `requestId` plus `bindingId`. Adapter diagnostics are host-side snapshots by default; graph-visible diagnostics require the explicit diagnostics boundary and contain only sanitized data fields. There is no diagnostics callback, logging API, hidden event bus, or transport retry/session/reconnect policy in the example.
diff --git a/examples/nestjs-graph-boundary/package.json b/examples/nestjs-graph-boundary/package.json
new file mode 100644
index 00000000..4e2ad4c3
--- /dev/null
+++ b/examples/nestjs-graph-boundary/package.json
@@ -0,0 +1,27 @@
+{
+	"name": "@graphrefly-examples/nestjs-graph-boundary",
+	"private": true,
+	"version": "0.0.8",
+	"type": "module",
+	"description": "NestJS keyed ingress/egress boundary nodes over @graphrefly/ts.",
+	"scripts": {
+		"start": "tsx src/main.ts",
+		"check": "pnpm --dir ../.. --filter @graphrefly/ts build && tsc --noEmit"
+	},
+	"dependencies": {
+		"@graphrefly/ts": "workspace:*",
+		"@nestjs/common": "^11.1.17",
+		"@nestjs/core": "^11.1.17",
+		"@nestjs/microservices": "^11.1.27",
+		"@nestjs/platform-express": "^11.1.18",
+		"@nestjs/platform-ws": "^11.1.18",
+		"@nestjs/websockets": "^11.1.18",
+		"reflect-metadata": "^0.2.2",
+		"rxjs": "^7.8.2"
+	},
+	"devDependencies": {
+		"@types/node": "^25.5.0",
+		"tsx": "^4.21.0",
+		"typescript": "^5.7.0"
+	}
+}
diff --git a/examples/nestjs-graph-boundary/src/main.ts b/examples/nestjs-graph-boundary/src/main.ts
new file mode 100644
index 00000000..50fde3ac
--- /dev/null
+++ b/examples/nestjs-graph-boundary/src/main.ts
@@ -0,0 +1,716 @@
+import "reflect-metadata";
+import { depLatest } from "@graphrefly/ts";
+import {
+	fromNestCron,
+	fromNestDiagnostics,
+	fromNestError,
+	fromNestGuard,
+	fromNestLifecycle,
+	fromNestReq,
+	GraphCron,
+	GraphError,
+	GraphGuard,
+	GraphGuardDecision,
+	type GraphGuardDecision as GraphGuardDecisionPayload,
+	GraphHttpReply,
+	GraphLifecycle,
+	GraphReq,
+	type HttpDataIssue,
+	type NestBoundaryEnvelope,
+	type NestReplyEnvelope,
+} from "@graphrefly/ts/adapters/nestjs";
+import {
+	fromNestMessage,
+	GRAPHREFLY_NEST_MESSAGE_BRIDGE,
+	GraphMessage,
+	type GraphMessageBridge,
+	GraphMessageReply,
+	provideGraphMessageProviders,
+} from "@graphrefly/ts/adapters/nestjs/microservices";
+import {
+	createGraphCronController,
+	createGraphExceptionFilter,
+	GraphGuardDeniedFilter,
+	graphCronTarget,
+	graphLifecycleTarget,
+	provideGraphNativeProviders,
+} from "@graphrefly/ts/adapters/nestjs/native";
+import {
+	fromNestWs,
+	GRAPHREFLY_NEST_WS_BRIDGE,
+	GraphWs,
+	GraphWsAck,
+	type GraphWsBridge,
+	GraphWsReply,
+	provideGraphWsProviders,
+} from "@graphrefly/ts/adapters/nestjs/websockets";
+import { type Graph, graph } from "@graphrefly/ts/graph";
+import {
+	BadRequestException,
+	Body,
+	Controller,
+	Get,
+	Headers,
+	Inject,
+	Injectable,
+	Logger,
+	Module,
+	type OnModuleDestroy,
+	Param,
+	Post,
+	UseFilters,
+} from "@nestjs/common";
+import { NestFactory } from "@nestjs/core";
+import { Ctx, MessagePattern, Payload, Transport } from "@nestjs/microservices";
+import { WsAdapter } from "@nestjs/platform-ws";
+import {
+	Ack,
+	ConnectedSocket,
+	MessageBody,
+	SubscribeMessage,
+	WebSocketGateway,
+} from "@nestjs/websockets";
+
+interface HttpHost<T> {
+	readonly requestId: string;
+	readonly body: T;
+	readonly headers?: Record<string, string | string[] | undefined>;
+	readonly path?: string;
+}
+
+interface HttpResult<T = unknown> {
+	readonly status: number;
+	readonly body: T;
+}
+
+interface PolicyState {
+	readonly acceptOrders: boolean;
+	readonly reason?: string;
+}
+
+interface OrderRequest {
+	readonly orderId: string;
+	readonly item: string;
+	readonly quantity: number;
+}
+
+interface WsOrderHost {
+	readonly requestId: string;
+	readonly body: OrderRequest;
+	readonly client: object;
+	readonly ack: (payload: unknown, envelope: NestReplyEnvelope<unknown>) => void;
+}
+
+interface MessageOrderHost {
+	readonly requestId: string;
+	readonly body: OrderRequest;
+	readonly context: object;
+}
+
+interface AuditEntry {
+	readonly requestId: string;
+	readonly accepted: boolean;
+	readonly orderId?: string;
+	readonly reason?: string;
+}
+
+let fallbackRequestSeq = 0;
+
+function nextRequestSeq(): number {
+	fallbackRequestSeq += 1;
+	return fallbackRequestSeq;
+}
+
+function requestId(prefix: string, seq: () => number, ...candidates: unknown[]): string {
+	for (const candidate of candidates) {
+		const value = Array.isArray(candidate) ? candidate[0] : candidate;
+		if (typeof value !== "string") continue;
+		const trimmed = value.trim();
+		if (trimmed.length > 0) return trimmed;
+	}
+	return `${prefix}-${seq()}`;
+}
+
+function result<T>(status: number, body: T): HttpResult<T> {
+	return { status, body };
+}
+
+const g = graph({ name: "nestjs-graph-boundary" });
+
+const diagnosticsIn = fromNestDiagnostics(g, {
+	bindingId: "node.nest.diagnostics",
+	phase: "adapter",
+});
+
+const policy = g.state<PolicyState>({ acceptOrders: true }, { name: "policy/current" });
+
+const echoIn = fromNestReq<HttpHost<{ readonly message?: string }>, { readonly message?: string }>(
+	g,
+	{
+		bindingId: "node.echo.in",
+		payload: (host) => host.body,
+		requestId: (host) => host.requestId,
+	},
+);
+
+const echoOut = g.node<NestReplyEnvelope<HttpResult>>(
+	[echoIn.node],
+	(ctx) => {
+		const envelope = depLatest(ctx, 0) as NestBoundaryEnvelope<{ readonly message?: string }>;
+		if (envelope.requestId === undefined) return;
+		ctx.down([
+			[
+				"DATA",
+				{
+					requestId: envelope.requestId,
+					bindingId: "http.echo.out",
+					version: 1,
+					payload: result(200, { echo: envelope.payload.message ?? "" }),
+				},
+			],
+		]);
+	},
+	{ name: "http.echo.out" },
+);
+
+const ordersIn = fromNestReq<HttpHost<OrderRequest>, OrderRequest>(g, {
+	bindingId: "node.orders.in",
+});
+
+const ordersGuardIn = fromNestGuard<
+	HttpHost<OrderRequest>,
+	{ readonly apiKey?: string; readonly orderId?: string }
+>(g, {
+	bindingId: "node.orders.guard.in",
+});
+
+const ordersGuardOut = g.node<NestReplyEnvelope<GraphGuardDecisionPayload>>(
+	[ordersGuardIn.node],
+	(ctx) => {
+		const envelope = depLatest(ctx, 0) as NestBoundaryEnvelope<{
+			readonly apiKey?: string;
+			readonly orderId?: string;
+		}>;
+		if (envelope.requestId === undefined) return;
+		ctx.down([
+			[
+				"DATA",
+				{
+					requestId: envelope.requestId,
+					bindingId: "guard.orders.out",
+					version: 1,
+					payload:
+						envelope.payload.apiKey === "demo-key"
+							? { kind: "allow", reason: "demo api key accepted" }
+							: {
+									kind: "deny",
+									reason: "missing demo api key",
+									status: 403,
+									body: { accepted: false, reason: "send x-api-key: demo-key" },
+									headers: { "x-graphrefly-guard": "orders.denied" },
+								},
+				},
+			],
+		]);
+	},
+	{ name: "guard.orders.out" },
+);
+
+const ordersAudit = g.node<AuditEntry>(
+	[ordersIn.node, policy],
+	(ctx) => {
+		const envelope = depLatest(ctx, 0) as NestBoundaryEnvelope<OrderRequest>;
+		if (envelope.requestId === undefined) return;
+		const currentPolicy = depLatest(ctx, 1) as PolicyState;
+		const accepted = currentPolicy.acceptOrders && envelope.payload.quantity > 0;
+		ctx.down([
+			[
+				"DATA",
+				{
+					requestId: envelope.requestId,
+					accepted,
+					orderId: envelope.payload.orderId,
+					reason: accepted ? undefined : (currentPolicy.reason ?? "orders are not admitted"),
+				},
+			],
+		]);
+	},
+	{ name: "orders.audit" },
+);
+
+const ordersOut = g.node<NestReplyEnvelope<HttpResult>>(
+	[ordersAudit],
+	(ctx) => {
+		const audit = depLatest(ctx, 0) as AuditEntry;
+		const issue: HttpDataIssue = {
+			kind: "issue",
+			code: "orders.not_admitted",
+			message: audit.reason ?? "Order was not admitted.",
+			status: 403,
+			body: { accepted: false, reason: audit.reason },
+		};
+		ctx.down([
+			[
+				"DATA",
+				{
+					requestId: audit.requestId,
+					bindingId: "http.orders.out",
+					version: 1,
+					payload: audit.accepted ? result(202, { accepted: true, orderId: audit.orderId }) : issue,
+				},
+			],
+		]);
+	},
+	{ name: "http.orders.out" },
+);
+
+const errorIn = fromNestError<
+	{ requestId: string; exception: Error },
+	{ readonly message: string }
+>(g, {
+	bindingId: "node.error.in",
+});
+
+const errorOut = g.node<NestReplyEnvelope<HttpResult>>(
+	[errorIn.node],
+	(ctx) => {
+		const envelope = depLatest(ctx, 0) as NestBoundaryEnvelope<{ readonly message: string }>;
+		if (envelope.requestId === undefined) return;
+		ctx.down([
+			[
+				"DATA",
+				{
+					requestId: envelope.requestId,
+					bindingId: "http.error.out",
+					version: 1,
+					payload: result(418, { handled: true, message: envelope.payload.message }),
+				},
+			],
+		]);
+	},
+	{ name: "http.error.out" },
+);
+
+const wsOrdersIn = fromNestWs<WsOrderHost, OrderRequest>(g, {
+	bindingId: "node.ws.orders.in",
+});
+
+const wsOrdersAck = g.node<
+	NestReplyEnvelope<{ readonly accepted: true; readonly orderId: string }>
+>(
+	[wsOrdersIn.node],
+	(ctx) => {
+		const envelope = depLatest(ctx, 0) as NestBoundaryEnvelope<OrderRequest>;
+		if (envelope.requestId === undefined) return;
+		ctx.down([
+			[
+				"DATA",
+				{
+					requestId: envelope.requestId,
+					bindingId: "ws.orders.ack",
+					version: 1,
+					payload: { accepted: true, orderId: envelope.payload.orderId },
+				},
+			],
+		]);
+	},
+	{ name: "ws.orders.ack" },
+);
+
+const wsOrdersReply = g.node<NestReplyEnvelope<HttpResult>>(
+	[wsOrdersIn.node],
+	(ctx) => {
+		const envelope = depLatest(ctx, 0) as NestBoundaryEnvelope<OrderRequest>;
+		if (envelope.requestId === undefined) return;
+		ctx.down([
+			[
+				"DATA",
+				{
+					requestId: envelope.requestId,
+					bindingId: "ws.orders.reply",
+					version: 1,
+					payload: result(202, {
+						accepted: true,
+						transport: "websocket",
+						orderId: envelope.payload.orderId,
+					}),
+				},
+			],
+		]);
+	},
+	{ name: "ws.orders.reply" },
+);
+
+const messageOrdersIn = fromNestMessage<MessageOrderHost, OrderRequest>(g, {
+	bindingId: "node.message.orders.in",
+});
+
+const messageOrdersReply = g.node<NestReplyEnvelope<HttpResult>>(
+	[messageOrdersIn.node],
+	(ctx) => {
+		const envelope = depLatest(ctx, 0) as NestBoundaryEnvelope<OrderRequest>;
+		if (envelope.requestId === undefined) return;
+		ctx.down([
+			[
+				"DATA",
+				{
+					requestId: envelope.requestId,
+					bindingId: "message.orders.reply",
+					version: 1,
+					payload: result(202, {
+						accepted: true,
+						transport: "microservice",
+						orderId: envelope.payload.orderId,
+					}),
+				},
+			],
+		]);
+	},
+	{ name: "message.orders.reply" },
+);
+
+const graphHandledExceptionFilter = createGraphExceptionFilter({
+	diagnosticBoundary: diagnosticsIn,
+	target: (_host, exception) =>
+		exception instanceof Error && exception.message === "graph-handled"
+			? { target: DemoController, methodKey: "handledError" }
+			: undefined,
+	host: (host, exception) => {
+		const req = host.switchToHttp().getRequest<{
+			headers?: Record<string, string | string[] | undefined>;
+			id?: string;
+			requestId?: string;
+		}>();
+		return {
+			requestId: requestId(
+				"error",
+				nextRequestSeq,
+				req.requestId,
+				req.id,
+				req.headers?.["x-request-id"],
+			),
+			exception: exception instanceof Error ? exception : new Error(String(exception)),
+		};
+	},
+	requestId: (host) => host.requestId,
+});
+
+const cronIn = fromNestCron<unknown, { readonly tick: string; readonly timezone: string }>(g, {
+	bindingId: "cron.demo.in",
+});
+
+const lifecycleIn = fromNestLifecycle<unknown, { readonly event: string }>(g, {
+	bindingId: "lifecycle.app.in",
+});
+
+@Injectable()
+class GraphAuditLogger implements OnModuleDestroy {
+	private readonly logger = new Logger("GraphAudit");
+	private readonly audit = new Map<string, AuditEntry>();
+	private readonly stopAudit = g.observe("orders.audit").subscribe((event) => {
+		if (event.msg[0] !== "DATA") return;
+		const entry = event.msg[1] as AuditEntry;
+		this.audit.set(entry.requestId, entry);
+		this.logger.log(
+			`orders.audit ${entry.requestId} accepted=${entry.accepted}${
+				entry.reason ? ` reason=${entry.reason}` : ""
+			}`,
+		);
+	});
+	private readonly stopDiagnostics = diagnosticsIn.node.subscribe((msg) => {
+		if (msg[0] !== "DATA") return;
+		const envelope = msg[1] as NestBoundaryEnvelope;
+		this.logger.warn(`nest.diagnostic ${JSON.stringify(envelope.payload)}`);
+	});
+
+	auditEntry(requestId: string): AuditEntry | undefined {
+		return this.audit.get(requestId);
+	}
+
+	onModuleDestroy(): void {
+		this.stopAudit();
+		this.stopDiagnostics();
+	}
+}
+
+@Injectable()
+class GraphBoundaryDemo {
+	setPolicy(nextPolicy: PolicyState): PolicyState {
+		policy.set(nextPolicy);
+		return nextPolicy;
+	}
+
+	teardown(): HttpResult {
+		return result(202, { lifecycle: "teardown-envelope-emitted" });
+	}
+
+	describe(): ReturnType<Graph["describe"]> {
+		return g.describe();
+	}
+}
+
+@Controller()
+class DemoController {
+	constructor(
+		private readonly demo: GraphBoundaryDemo,
+		private readonly auditLogger: GraphAuditLogger,
+	) {}
+
+	@Post("echo")
+	@GraphReq(echoIn, {
+		bindingId: "http.echo.in",
+		payload: (host: HttpHost<{ readonly message?: string }>) => host.body,
+		requestId: (host: HttpHost<unknown>) => host.requestId,
+	})
+	@GraphHttpReply(echoOut, { bindingId: "http.echo.out" })
+	echo(): void {}
+
+	@Post("policy")
+	policy(@Body() body: Partial<PolicyState>): PolicyState {
+		return this.demo.setPolicy({
+			acceptOrders: body.acceptOrders ?? true,
+			reason: body.reason,
+		});
+	}
+
+	@Post("orders")
+	@UseFilters(GraphGuardDeniedFilter)
+	@GraphGuard(ordersGuardIn, {
+		bindingId: "guard.orders.in",
+		payload: (host: HttpHost<OrderRequest>) => ({
+			apiKey: String(host.headers?.["x-api-key"] ?? ""),
+			orderId: host.body.orderId,
+		}),
+		requestId: (host: HttpHost<unknown>) => host.requestId,
+	})
+	@GraphGuardDecision(ordersGuardOut, { bindingId: "guard.orders.out" })
+	@GraphReq(ordersIn, {
+		bindingId: "http.orders.in",
+		payload: (host: HttpHost<OrderRequest>) => host.body,
+		requestId: (host: HttpHost<unknown>) => host.requestId,
+	})
+	@GraphHttpReply(ordersOut, { bindingId: "http.orders.out" })
+	orders(): void {}
+
+	@Post("handled-error")
+	@UseFilters(graphHandledExceptionFilter)
+	@GraphError(errorIn, {
+		bindingId: "error.demo.in",
+		payload: (host: { exception: Error }) => ({ message: host.exception.message }),
+		requestId: (host: { requestId: string }) => host.requestId,
+	})
+	@GraphHttpReply(errorOut, { bindingId: "http.error.out" })
+	handledError(): void {
+		throw new Error("graph-handled");
+	}
+
+	@Get("audit/:requestId")
+	audit(@Param("requestId") id: string): HttpResult {
+		return result(200, this.auditLogger.auditEntry(id) ?? null);
+	}
+
+	@Post("lifecycle/teardown")
+	@GraphLifecycle(lifecycleIn, {
+		bindingId: "lifecycle.app.in",
+		payload: () => ({ event: "manual-teardown" }),
+	})
+	teardown(@Headers("x-request-id") _header?: string): HttpResult {
+		return this.demo.teardown();
+	}
+
+	@Post("cron/tick")
+	@GraphCron(cronIn, {
+		bindingId: "cron.demo.in",
+		payload: (host: { timestamp_ns: string; timezone?: string }) => ({
+			tick: host.timestamp_ns,
+			timezone: host.timezone ?? "host-local",
+		}),
+	})
+	cronTick(): HttpResult {
+		return result(202, { cron: "registered" });
+	}
+
+	@Post("cron/check")
+	manualCronCheck(@Body() body: { readonly iso?: string } = {}): HttpResult {
+		const now = body.iso === undefined ? new Date() : new Date(body.iso);
+		if (!Number.isFinite(now.getTime())) {
+			throw new BadRequestException("cron/check requires a valid ISO date");
+		}
+		manualCronController.check(now);
+		return result(202, { checkedAt: now.toISOString() });
+	}
+
+	@Get("graph")
+	graph(): ReturnType<GraphBoundaryDemo["describe"]> {
+		return this.demo.describe();
+	}
+}
+
+@WebSocketGateway({ path: "/graphrefly" })
+class OrdersGateway {
+	constructor(
+		@Inject(GRAPHREFLY_NEST_WS_BRIDGE)
+		private readonly bridge: GraphWsBridge<WsOrderHost>,
+	) {}
+
+	handleDisconnect(client: object): void {
+		this.bridge.handleDisconnect(client);
+	}
+
+	@SubscribeMessage("orders.reserve")
+	@GraphWs(wsOrdersIn, {
+		bindingId: "ws.orders.in",
+		payload: (host: WsOrderHost) => host.body,
+		requestId: (host: WsOrderHost) => host.requestId,
+	})
+	@GraphWsAck(wsOrdersAck, { bindingId: "ws.orders.ack" })
+	@GraphWsReply(wsOrdersReply, { bindingId: "ws.orders.reply" })
+	reserve(
+		@MessageBody() body: OrderRequest & { readonly requestId?: string },
+		@ConnectedSocket() client: object,
+		@Ack() ack: WsOrderHost["ack"],
+	): Promise<unknown> | undefined {
+		return this.bridge.handleMessage(OrdersGateway, "reserve", {
+			requestId: requestId("ws", nextRequestSeq, body.requestId),
+			body,
+			client,
+			ack,
+		});
+	}
+}
+
+@Controller()
+class OrdersMessageController {
+	constructor(
+		@Inject(GRAPHREFLY_NEST_MESSAGE_BRIDGE)
+		private readonly bridge: GraphMessageBridge<MessageOrderHost>,
+	) {}
+
+	@MessagePattern("orders.reserve")
+	@GraphMessage(messageOrdersIn, {
+		bindingId: "message.orders.in",
+		payload: (host: MessageOrderHost) => host.body,
+		requestId: (host: MessageOrderHost) => host.requestId,
+	})
+	@GraphMessageReply(messageOrdersReply, { bindingId: "message.orders.reply" })
+	reserve(
+		@Payload() body: OrderRequest & { readonly requestId?: string },
+		@Ctx() context: object,
+	): Promise<unknown> | undefined {
+		return this.bridge.handleMessage(OrdersMessageController, "reserve", {
+			requestId: requestId("message", nextRequestSeq, body.requestId),
+			body,
+			context,
+		});
+	}
+}
+
+const cronTargets = [
+	graphCronTarget(DemoController, "cronTick", {
+		expr: "* * * * *",
+		timezone: "UTC",
+	}),
+];
+
+const lifecycleTargets = [
+	graphLifecycleTarget(DemoController, "teardown", {
+		event: "module-destroy",
+		host: () => ({ event: "module-destroy" }),
+	}),
+];
+
+const manualCronController = createGraphCronController({ targets: cronTargets });
+
+@Module({
+	controllers: [DemoController, OrdersMessageController],
+	providers: [
+		GraphBoundaryDemo,
+		GraphAuditLogger,
+		OrdersGateway,
+		...provideGraphNativeProviders({
+			http: {
+				boundaryInterceptor: {
+					diagnosticBoundary: diagnosticsIn,
+					host: (context) => {
+						const req = context.switchToHttp?.().getRequest<{
+							body?: unknown;
+							headers?: Record<string, string | string[] | undefined>;
+							id?: string;
+							path?: string;
+							requestId?: string;
+						}>() ?? { body: {}, headers: {}, path: undefined };
+						return {
+							requestId: requestId(
+								String(context.getHandler().name || "graph"),
+								nextRequestSeq,
+								req.requestId,
+								req.id,
+								req.headers?.["x-request-id"],
+								req.headers?.["x-correlation-id"],
+							),
+							body: req.body ?? {},
+							headers: req.headers,
+							path: req.path,
+						};
+					},
+					requestId: (host) => host.requestId,
+				},
+				guard: {
+					diagnosticBoundary: diagnosticsIn,
+					host: (context) => {
+						const req = context.switchToHttp().getRequest<{
+							body?: OrderRequest;
+							headers?: Record<string, string | string[] | undefined>;
+							id?: string;
+							requestId?: string;
+						}>();
+						return {
+							requestId: requestId(
+								"guard",
+								nextRequestSeq,
+								req.requestId,
+								req.id,
+								req.headers?.["x-request-id"],
+							),
+							body: req.body ?? { orderId: "", item: "", quantity: 0 },
+							headers: req.headers,
+							path: undefined,
+						};
+					},
+					requestId: (host) => host.requestId,
+				},
+			},
+			cronScheduler: { targets: cronTargets },
+			lifecycleHooks: { targets: lifecycleTargets },
+		}),
+		...provideGraphWsProviders<WsOrderHost>({
+			bridge: {
+				ack: (host) => host.ack,
+				client: (host) => host.client,
+				diagnosticBoundary: diagnosticsIn,
+			},
+		}),
+		...provideGraphMessageProviders<MessageOrderHost>({
+			bridge: { diagnosticBoundary: diagnosticsIn },
+		}),
+	],
+})
+class AppModule {}
+
+const app = await NestFactory.create(AppModule);
+const attachWsAdapter = app.useWebSocketAdapter.bind(app);
+attachWsAdapter(new WsAdapter(app));
+app.connectMicroservice({
+	transport: Transport.TCP,
+	options: {
+		host: process.env.MICRO_HOST ?? "127.0.0.1",
+		port: Number(process.env.MICRO_PORT ?? 3001),
+	},
+});
+const port = Number(process.env.PORT ?? 3000);
+await app.startAllMicroservices();
+await app.listen(port);
+console.log(`NestJS GraphBoundary demo listening on http://localhost:${port}`);
+console.log(
+	`NestJS GraphBoundary message transport listening on ${process.env.MICRO_HOST ?? "127.0.0.1"}:${Number(process.env.MICRO_PORT ?? 3001)}`,
+);
diff --git a/examples/nestjs-graph-boundary/tsconfig.json b/examples/nestjs-graph-boundary/tsconfig.json
new file mode 100644
index 00000000..3bf5e7c1
--- /dev/null
+++ b/examples/nestjs-graph-boundary/tsconfig.json
@@ -0,0 +1,14 @@
+{
+	"compilerOptions": {
+		"target": "ES2022",
+		"module": "NodeNext",
+		"moduleResolution": "NodeNext",
+		"strict": true,
+		"experimentalDecorators": true,
+		"emitDecoratorMetadata": true,
+		"skipLibCheck": true,
+		"noEmit": true,
+		"types": ["node"]
+	},
+	"include": ["src/**/*.ts"]
+}
diff --git a/examples/reactive-layout/README.md b/examples/reactive-layout/README.md
new file mode 100644
index 00000000..b8514cc5
--- /dev/null
+++ b/examples/reactive-layout/README.md
@@ -0,0 +1,12 @@
+# reactive-layout examples
+
+Reactive-layout examples are split by purpose:
+
+- `flow/` is a runnable browser demo for `reactiveFlowLayout` plus browser canvas measurement.
+- `recipes/` is user-land glue for platform measurement facts: React Native
+  `onLayout`/native probes, Skia font readiness, and provider composition with
+  `mergeMeasurements`.
+
+The recipes are intentionally not standalone apps because they reference optional host runtimes
+such as React Native and React Native Skia. Those packages stay caller-owned and do not become
+workspace or universal reactive-layout dependencies.
diff --git a/examples/reactive-layout/flow/README.md b/examples/reactive-layout/flow/README.md
index f842dd6c..eacff6ce 100644
--- a/examples/reactive-layout/flow/README.md
+++ b/examples/reactive-layout/flow/README.md
@@ -5,14 +5,16 @@ through a reactive graph.
 
 What's wired:
 
-- **`reactiveFlowLayout({...})`** builds a graph with state nodes for
-  `text / font / line-height / container / columns / obstacles` and two
-  derived nodes — `segments` (recomputes only when text/font change) and
-  `flowLines` (recomputes whenever any dep changes).
+- **`canvasTextMeasurements({...})`** measures `text / font` upstream as
+  graph-visible facts.
+- **`reactiveFlowLayout({...})`** consumes that `measurements` node plus
+  state nodes for `line-height / container / columns / obstacles` and exposes
+  `segments` and `flowLines`.
 - Two **`effect`** nodes render the current `obstacles` and `flowLines`
   into DOM.
 - **`fromRaf()`** is the reactive clock; each frame tick drives
-  `bundle.setObstacles(...)` which writes through the graph.
+  `bundle.setObstacles(...)` which writes through the graph. It imports from
+  `@graphrefly/ts/sources/browser`; reactive-layout does not own animation sources.
 
 This mirrors the `flow` chapter in `demos/reactive-layout` but strips all
 the demo-shell / mermaid / code-pane scaffolding — it's the minimum needed
diff --git a/examples/reactive-layout/flow/package.json b/examples/reactive-layout/flow/package.json
index 4de32e14..85f2af0a 100644
--- a/examples/reactive-layout/flow/package.json
+++ b/examples/reactive-layout/flow/package.json
@@ -10,7 +10,7 @@
 		"preview": "vite preview"
 	},
 	"dependencies": {
-		"@graphrefly/graphrefly": "workspace:*"
+		"@graphrefly/ts": "workspace:*"
 	},
 	"devDependencies": {
 		"typescript": "^5.7.0",
diff --git a/examples/reactive-layout/flow/src/main.ts b/examples/reactive-layout/flow/src/main.ts
index 03ea75c4..da2b287b 100644
--- a/examples/reactive-layout/flow/src/main.ts
+++ b/examples/reactive-layout/flow/src/main.ts
@@ -1,11 +1,11 @@
-import { DATA, ERROR, effect } from "@graphrefly/graphrefly/core";
-import { fromRaf } from "@graphrefly/graphrefly/extra/sources";
+import { graph, type Message } from "@graphrefly/ts";
 import {
-	CanvasMeasureAdapter,
+	type FlowLinesResult,
 	type Obstacle,
-	type PositionedLine,
 	reactiveFlowLayout,
-} from "@graphrefly/graphrefly/patterns/reactive-layout";
+} from "@graphrefly/ts/solutions/reactive-layout";
+import { canvasTextMeasurements } from "@graphrefly/ts/solutions/reactive-layout/browser";
+import { fromRaf } from "@graphrefly/ts/sources/browser";
 
 // ---------------------------------------------------------------------------
 // Stage setup — a simple HTML <main> with a fixed-size stage. The layout
@@ -98,22 +98,25 @@ function driftAt(t: number): Obstacle[] {
 		cx: o.baseX + o.ampX * Math.sin(t * o.speedX),
 		cy: o.baseY + o.ampY * Math.sin(t * o.speedY),
 		r: o.r,
-		hPad: 8,
-		vPad: 4,
 	}));
 }
 
 // ---------------------------------------------------------------------------
-// Reactive graph — `reactiveFlowLayout` returns a bundle with state nodes
-// (text / font / container / columns / obstacles) and two derived nodes
-// (`segments`, `flowLines`). We only reach in to update `obstacles`; the
-// rest of the graph propagates automatically.
+// Reactive graph — Canvas measurement is an upstream provider node. The layout
+// bundle consumes the latest graph-visible measurements DATA and owns no adapter.
 // ---------------------------------------------------------------------------
 
+const layoutGraph = graph({ name: "reactive-flow-layout" });
+const textNode = layoutGraph.state(ESSAY, { name: "text" });
+const fontNode = layoutGraph.state(FONT, { name: "font" });
+const measurements = canvasTextMeasurements({
+	graph: layoutGraph,
+	text: textNode,
+	font: fontNode,
+});
 const bundle = reactiveFlowLayout({
-	adapter: new CanvasMeasureAdapter(),
-	text: ESSAY,
-	font: FONT,
+	graph: layoutGraph,
+	measurements,
 	lineHeight: LINE_HEIGHT,
 	container: CONTAINER,
 	columns: { count: 2, gap: 28 },
@@ -135,45 +138,49 @@ const linesLayer = document.createElement("div");
 linesLayer.dataset.flow = "lines";
 stage.appendChild(linesLayer);
 
-const obstaclesNode = bundle.graph.node("obstacles");
-
-effect([obstaclesNode], ([obstacles]) => {
-	const arr = (obstacles as Obstacle[]) ?? [];
-	obstacleLayer.innerHTML = "";
-	for (const o of arr) {
-		if (o.kind !== "circle") continue;
-		const el = document.createElement("div");
-		el.style.position = "absolute";
-		el.style.left = `${o.cx - o.r}px`;
-		el.style.top = `${o.cy - o.r}px`;
-		el.style.width = `${o.r * 2}px`;
-		el.style.height = `${o.r * 2}px`;
-		el.style.borderRadius = "50%";
-		el.style.background = "rgba(120, 170, 255, 0.15)";
-		el.style.border = "1px solid rgba(120, 170, 255, 0.45)";
-		el.style.pointerEvents = "none";
-		obstacleLayer.appendChild(el);
-	}
-}).subscribe(() => {});
-
-effect([bundle.flowLines], ([lines]) => {
-	const arr = (lines as PositionedLine[]) ?? [];
-	linesLayer.innerHTML = "";
-	for (const line of arr) {
-		const el = document.createElement("div");
-		el.textContent = line.text;
-		el.style.position = "absolute";
-		el.style.left = `${line.x}px`;
-		el.style.top = `${line.y}px`;
-		el.style.width = `${line.slotWidth}px`;
-		el.style.height = `${LINE_HEIGHT}px`;
-		el.style.lineHeight = `${LINE_HEIGHT}px`;
-		el.style.textAlign = line.flushToRight ? "right" : "justify";
-		el.style.whiteSpace = "pre";
-		el.style.overflow = "hidden";
-		linesLayer.appendChild(el);
-	}
-}).subscribe(() => {});
+const obstaclesNode = bundle.input.obstacles;
+
+bundle.graph
+	.effect([obstaclesNode], (obstacles) => {
+		const arr = (obstacles as Obstacle[]) ?? [];
+		obstacleLayer.innerHTML = "";
+		for (const o of arr) {
+			if (o.kind !== "circle") continue;
+			const el = document.createElement("div");
+			el.style.position = "absolute";
+			el.style.left = `${o.cx - o.r}px`;
+			el.style.top = `${o.cy - o.r}px`;
+			el.style.width = `${o.r * 2}px`;
+			el.style.height = `${o.r * 2}px`;
+			el.style.borderRadius = "50%";
+			el.style.background = "rgba(120, 170, 255, 0.15)";
+			el.style.border = "1px solid rgba(120, 170, 255, 0.45)";
+			el.style.pointerEvents = "none";
+			obstacleLayer.appendChild(el);
+		}
+	})
+	.subscribe(() => {});
+
+bundle.graph
+	.effect([bundle.flowLines], (lines) => {
+		const arr = (lines as FlowLinesResult | null)?.lines ?? [];
+		linesLayer.innerHTML = "";
+		for (const line of arr) {
+			const el = document.createElement("div");
+			el.textContent = line.text;
+			el.style.position = "absolute";
+			el.style.left = `${line.x}px`;
+			el.style.top = `${line.y}px`;
+			el.style.width = `${line.slotWidth}px`;
+			el.style.height = `${LINE_HEIGHT}px`;
+			el.style.lineHeight = `${LINE_HEIGHT}px`;
+			el.style.textAlign = "left";
+			el.style.whiteSpace = "pre";
+			el.style.overflow = "hidden";
+			linesLayer.appendChild(el);
+		}
+	})
+	.subscribe(() => {});
 
 // ---------------------------------------------------------------------------
 // Reactive clock — `fromRaf()` is a GraphReFly source node emitting frame
@@ -187,10 +194,9 @@ effect([bundle.flowLines], ([lines]) => {
 // callback outside the graph.
 // ---------------------------------------------------------------------------
 
-const frame = fromRaf();
-frame.subscribe((msgs) => {
-	for (const [type, value] of msgs) {
-		if (type === DATA) bundle.setObstacles(driftAt(value as number));
-		else if (type === ERROR) console.error("fromRaf error:", value);
-	}
+const frame = bundle.graph.initNode(fromRaf(), [], { name: "frame" });
+frame.subscribe((msg: Message) => {
+	const [type, value] = msg;
+	if (type === "DATA") bundle.setObstacles(driftAt(value as number));
+	else if (type === "ERROR") console.error("fromRaf error:", value);
 });
diff --git a/examples/reactive-layout/recipes/README.md b/examples/reactive-layout/recipes/README.md
new file mode 100644
index 00000000..7aa36c25
--- /dev/null
+++ b/examples/reactive-layout/recipes/README.md
@@ -0,0 +1,230 @@
+# reactive-layout / recipes
+
+These recipes show user-land measurement glue. They do not add public React Native hooks,
+components, generic fallback policy, or runtime ownership to GraphReFly. Host runtimes write facts
+into graph state; reactive-layout consumes a caller-composed `measurements` node.
+
+## React Native onLayout/native probe facts
+
+React Native layout is asynchronous. Treat `onLayout` or a native probe as the host event that
+updates graph state, then project that state into measurement facts with
+`reactNativeLayoutMeasurements`.
+
+```tsx
+import type { ReactNode } from "react";
+import { View } from "react-native";
+import { graph } from "@graphrefly/ts";
+import { mergeMeasurements } from "@graphrefly/ts/solutions/reactive-layout";
+import {
+  reactNativeLayoutMeasurements,
+  type ReactNativeLayoutProbe,
+} from "@graphrefly/ts/solutions/reactive-layout/react-native";
+
+const g = graph({ name: "rn-layout-recipe" });
+const layoutProbes = g.state<readonly ReactNativeLayoutProbe[]>([], {
+  name: "rn-layout-probes",
+});
+
+function recordLayout(id: string, width: number, height: number) {
+  const previous = layoutProbes.cache ?? [];
+  layoutProbes.set([
+    ...previous.filter((probe) => probe.id !== id),
+    { id, width, height, source: "onLayout" },
+  ]);
+}
+
+function recordNativePending(id: string) {
+  const previous = layoutProbes.cache ?? [];
+  layoutProbes.set([
+    ...previous.filter((probe) => probe.id !== id),
+    { id, ready: false, code: "layout.pending", source: "native-probe" },
+  ]);
+}
+
+function MeasuredCard({ id, children }: { id: string; children: ReactNode }) {
+  return (
+    <View
+      onLayout={(event) => {
+        const { width, height } = event.nativeEvent.layout;
+        recordLayout(id, width, height);
+      }}
+    >
+      {children}
+    </View>
+  );
+}
+
+const rnLayoutFacts = reactNativeLayoutMeasurements({
+  graph: g,
+  probes: layoutProbes,
+  name: "rn-layout-measurements",
+});
+
+const measurements = mergeMeasurements({
+  graph: g,
+  sources: [rnLayoutFacts],
+  name: "measurements",
+});
+```
+
+The local `MeasuredCard` is application glue, not a GraphReFly export. Invalid, pending, or missing
+native measurements become `DataIssue` facts; they are not protocol `ERROR`s and do not make RN
+measurement look synchronous.
+
+## Skia fonts/readiness facts
+
+Skia text measurement is synchronous only after the caller has a ready Skia runtime and font manager.
+Keep `useFonts` readiness explicit, then pass a ready capability to
+`skiaReadyTextMeasurements`.
+
+```tsx
+import { useEffect } from "react";
+import { Skia, useFonts } from "@shopify/react-native-skia";
+import { graph } from "@graphrefly/ts";
+import {
+  mergeMeasurements,
+  type MeasurementReadiness,
+} from "@graphrefly/ts/solutions/reactive-layout";
+import {
+  skiaParagraphTextMeasureCapability,
+  skiaReadyTextMeasurements,
+} from "@graphrefly/ts/solutions/reactive-layout/skia";
+
+const g = graph({ name: "skia-layout-recipe" });
+const text = g.state("Measure me with Skia Paragraph.", { name: "text" });
+const font = g.state("Inter", { name: "font" });
+const readiness = g.state<MeasurementReadiness>(
+  { ready: false, code: "font.loading", source: "useFonts" },
+  { name: "skia-font-ready" },
+);
+
+function SkiaLayoutOwner() {
+  const fontManager = useFonts({
+    Inter: [require("./Inter-Regular.ttf")],
+  });
+
+  useEffect(() => {
+    if (!fontManager) {
+      readiness.set({ ready: false, code: "font.loading", source: "useFonts" });
+      return;
+    }
+    skiaCapability.set(
+      skiaParagraphTextMeasureCapability({
+        Skia,
+        fontManager,
+        textStyleForFont: (family) => ({ fontFamilies: [family], fontSize: 16 }),
+      }),
+    );
+    readiness.set({ ready: true, source: "useFonts" });
+  }, [fontManager]);
+
+  return null;
+}
+
+const skiaCapability = g.state(
+  skiaParagraphTextMeasureCapability({
+    Skia,
+    textStyleForFont: (family) => ({ fontFamilies: [family], fontSize: 16 }),
+  }),
+  { name: "skia-capability" },
+);
+
+const skiaTextFacts = skiaReadyTextMeasurements({
+  graph: g,
+  text,
+  font,
+  capability: skiaCapability,
+  readiness,
+  name: "skia-text-measurements",
+});
+
+const measurements = mergeMeasurements({
+  graph: g,
+  sources: [skiaTextFacts],
+  name: "measurements",
+});
+```
+
+The `useFonts` result is deliberately not hidden inside the provider. While fonts are loading, the
+graph carries a readiness issue. When the caller marks readiness true and writes the ready
+capability, Skia text facts become ordinary measurement DATA.
+
+## Provider composition for layout
+
+Compose text, readiness, image, and SVG provider facts upstream. `mergeMeasurements` preserves the
+source order you pass; it is not a fallback, dedupe, stale, or priority policy engine.
+
+```ts
+import { graph } from "@graphrefly/ts";
+import {
+  ImageSizeAdapter,
+  SvgBoundsAdapter,
+  cellTextMeasurements,
+  imageSizeMeasurements,
+  mergeMeasurements,
+  reactiveLayout,
+  readinessMeasurements,
+  svgBoundsMeasurements,
+  type MeasurementReadiness,
+} from "@graphrefly/ts/solutions/reactive-layout";
+
+const g = graph({ name: "provider-composition-recipe" });
+const text = g.state("Graph-visible provider facts.", { name: "text" });
+const font = g.state("14px Inter", { name: "font" });
+const fontReady = g.state<MeasurementReadiness>(
+  { ready: true, source: "font-face-set" },
+  { name: "font-ready" },
+);
+
+const textFacts = cellTextMeasurements({
+  graph: g,
+  text,
+  font,
+  cellWidth: 7,
+  targetId: "copy",
+  name: "copy-text-measurements",
+});
+
+const readinessFacts = readinessMeasurements({
+  graph: g,
+  readiness: fontReady,
+  targetId: "font:Inter",
+  name: "font-readiness-measurements",
+});
+
+const imageFacts = imageSizeMeasurements({
+  graph: g,
+  images: g.state([{ id: "hero", src: "hero.png" }], { name: "images" }),
+  measurer: g.state(new ImageSizeAdapter({ "hero.png": { width: 1280, height: 720 } }), {
+    name: "image-size-capability",
+  }),
+  name: "image-size-measurements",
+});
+
+const svgFacts = svgBoundsMeasurements({
+  graph: g,
+  svgs: g.state([{ id: "logo", svg: '<svg width="120" height="32"></svg>' }], {
+    name: "svgs",
+  }),
+  measurer: g.state(new SvgBoundsAdapter(), { name: "svg-bounds-capability" }),
+  name: "svg-bounds-measurements",
+});
+
+const measurements = mergeMeasurements({
+  graph: g,
+  sources: [readinessFacts, textFacts, imageFacts, svgFacts],
+  name: "measurements",
+});
+
+const layout = reactiveLayout({
+  graph: g,
+  measurements,
+  targetId: "copy",
+  maxWidth: 360,
+  lineHeight: 20,
+});
+```
+
+Layout reads the text facts for `targetId: "copy"`. Readiness, image, and SVG facts stay visible for
+downstream projections or issue UI, but layout does not own provider precedence or missing-fact
+policy.
diff --git a/examples/spending-alerts/CHANGELOG.md b/examples/spending-alerts/CHANGELOG.md
index fedbb965..d96bacf3 100644
--- a/examples/spending-alerts/CHANGELOG.md
+++ b/examples/spending-alerts/CHANGELOG.md
@@ -5,53 +5,53 @@
 ### Patch Changes
 
 - Updated dependencies [[`4230039`](https://github.com/graphrefly/graphrefly-ts/commit/4230039498f97be2d5213d76cb8ce8f72a073b9a)]:
-  - @graphrefly/graphrefly@0.49.0
+  - legacy root package 0.49.0
 
 ## 0.0.7
 
 ### Patch Changes
 
 - Updated dependencies [[`812ff96`](https://github.com/graphrefly/graphrefly-ts/commit/812ff96091f063557e01ad861baf6a87ad2082a2)]:
-  - @graphrefly/graphrefly@0.48.1
+  - legacy root package 0.48.1
 
 ## 0.0.6
 
 ### Patch Changes
 
 - Updated dependencies [[`cfb1500`](https://github.com/graphrefly/graphrefly-ts/commit/cfb1500250504391683557a0b75cec381ca8e201), [`9b3554b`](https://github.com/graphrefly/graphrefly-ts/commit/9b3554b659ccb5aaf1f45dbd1ed933129d691171)]:
-  - @graphrefly/graphrefly@0.48.0
+  - legacy root package 0.48.0
 
 ## 0.0.5
 
 ### Patch Changes
 
 - Updated dependencies [[`fda9432`](https://github.com/graphrefly/graphrefly-ts/commit/fda94326c6656c27008c2733f305a5c077f8ff09)]:
-  - @graphrefly/graphrefly@0.47.2
+  - legacy root package 0.47.2
 
 ## 0.0.4
 
 ### Patch Changes
 
 - Updated dependencies [[`76d35c7`](https://github.com/graphrefly/graphrefly-ts/commit/76d35c73eb84a2871ac34907a10a0514674745ca)]:
-  - @graphrefly/graphrefly@0.47.1
+  - legacy root package 0.47.1
 
 ## 0.0.3
 
 ### Patch Changes
 
 - Updated dependencies [[`36ff7df`](https://github.com/graphrefly/graphrefly-ts/commit/36ff7df3e4fd843ce630ad388921ff33e64a37e1), [`f08b7cf`](https://github.com/graphrefly/graphrefly-ts/commit/f08b7cf8b62ad522a1da5c4664ef719e19e5d7f0)]:
-  - @graphrefly/graphrefly@0.47.0
+  - legacy root package 0.47.0
 
 ## 0.0.2
 
 ### Patch Changes
 
 - Updated dependencies [[`23c1eba`](https://github.com/graphrefly/graphrefly-ts/commit/23c1eba88c55be7ab925eaf8b704bc6604a0ec57)]:
-  - @graphrefly/graphrefly@0.46.0
+  - legacy root package 0.46.0
 
 ## 0.0.1
 
 ### Patch Changes
 
 - Updated dependencies [[`64ab268`](https://github.com/graphrefly/graphrefly-ts/commit/64ab26858804265f60f169f69f95343793e5afde)]:
-  - @graphrefly/graphrefly@0.45.0
+  - legacy root package 0.45.0
diff --git a/examples/spending-alerts/index.ts b/examples/spending-alerts/index.ts
index 4bf21919..4fd7fecb 100644
--- a/examples/spending-alerts/index.ts
+++ b/examples/spending-alerts/index.ts
@@ -3,7 +3,7 @@
  *
  * Feeds a handful of transactions through the graph defined in
  * `pipeline.ts`, prints each alert, and — on the first flagged txn —
- * renders the structural causal chain via `graph.explain`.
+ * renders the structural causal chain via `graph.describe({ explain })`.
  *
  * Run:
  *   pnpm --filter @graphrefly-examples/spending-alerts start
@@ -12,7 +12,7 @@
  *   npx tsx examples/spending-alerts/index.ts
  */
 
-import { DATA } from "@graphrefly/graphrefly";
+import { describeToPretty } from "@graphrefly/ts/render";
 import { spendingAlertsGraph, type Transaction } from "./pipeline.js";
 
 const { graph, feed } = spendingAlertsGraph({
@@ -22,31 +22,32 @@ const { graph, feed } = spendingAlertsGraph({
 	},
 });
 
-const alertMessage = graph.resolve("alertMessage");
+const alertMessage = graph.find("alertMessage");
+if (alertMessage === undefined) {
+	throw new Error("spending-alerts graph is missing the alertMessage node");
+}
 
 // Subscribe BEFORE feeding — sources push lazily on activation.
 let firstFlagExplained = false;
-alertMessage.subscribe((msgs) => {
-	for (const [type, value] of msgs) {
-		if (type !== DATA) continue;
-		const text = value as string;
-		const rule = "─".repeat(60);
-		console.log(`\n${rule}`);
-		console.log(text);
-		// When the text mentions "flagged" AND we haven't rendered the
-		// chain yet, explain what led here. The chain's text is the
-		// answer to homepage pain-point 02 — "why was this flagged?"
-		if (!firstFlagExplained && text.includes("flagged")) {
-			firstFlagExplained = true;
-			const chain = graph.describe({ explain: { from: "txFeed", to: "alertMessage" } });
-			const heavy = "═".repeat(60);
-			console.log(`\n${heavy}`);
-			console.log(
-				"Causal chain — graph.describe({ explain: { from: 'txFeed', to: 'alertMessage' } }):",
-			);
-			console.log(heavy);
-			console.log(chain.text);
-		}
+alertMessage.subscribe(([type, value]) => {
+	if (type !== "DATA") return;
+	const text = value as string;
+	const rule = "─".repeat(60);
+	console.log(`\n${rule}`);
+	console.log(text);
+	// When the text mentions "flagged" AND we haven't rendered the
+	// chain yet, explain what led here. The chain's text is the
+	// answer to homepage pain-point 02 — "why was this flagged?"
+	if (!firstFlagExplained && text.includes("flagged")) {
+		firstFlagExplained = true;
+		const chain = graph.describe({ explain: { from: "txFeed", to: "alertMessage" } });
+		const heavy = "═".repeat(60);
+		console.log(`\n${heavy}`);
+		console.log(
+			"Causal chain — graph.describe({ explain: { from: 'txFeed', to: 'alertMessage' } }):",
+		);
+		console.log(heavy);
+		console.log(describeToPretty(chain));
 	}
 });
 
@@ -85,5 +86,3 @@ const TRANSACTIONS: readonly Transaction[] = [
 ];
 
 for (const txn of TRANSACTIONS) feed(txn);
-
-graph.destroy();
diff --git a/examples/spending-alerts/package.json b/examples/spending-alerts/package.json
index 665c44c2..6659def4 100644
--- a/examples/spending-alerts/package.json
+++ b/examples/spending-alerts/package.json
@@ -8,7 +8,7 @@
 		"start": "tsx index.ts"
 	},
 	"dependencies": {
-		"@graphrefly/graphrefly": "workspace:*"
+		"@graphrefly/ts": "workspace:*"
 	},
 	"devDependencies": {
 		"tsx": "^4.21.0",
diff --git a/examples/spending-alerts/pipeline.ts b/examples/spending-alerts/pipeline.ts
index cd34774c..a4f8fca1 100644
--- a/examples/spending-alerts/pipeline.ts
+++ b/examples/spending-alerts/pipeline.ts
@@ -3,9 +3,8 @@
  *
  * Five hops on the causal spine from a raw transaction to a human-readable
  * alert, plus two side inputs (per-vendor stats, user profile). Every node
- * is added to a named `Graph` so `graph.describe({ explain: { from: "txFeed", to: "alertMessage" } })`
- * walks backward through `deps` and renders every step's value + `trace()`
- * annotation.
+ * is registered on a named `Graph` so `graph.describe({ explain: { from: "txFeed", to: "alertMessage" } })`
+ * walks backward through `deps` and renders every step's current value.
  *
  * ```
  *   txFeed (source)
@@ -20,15 +19,16 @@
  * ```
  *
  * The pipeline is factored so consumers pick the **justifier** — the
- * deterministic templater shipped here, or (in the browser demo) a
- * `promptNode` backed by Chrome Nano. Both shapes `(reason, txn) => string`.
- * Structural explainability doesn't change: the graph topology *is* the
- * trace, regardless of which justifier is plugged in.
+ * deterministic templater shipped here, or any caller-supplied synchronous
+ * justifier. Both shapes are `(reason, txn) => string`.
+ * Structural explainability doesn't change: the graph topology and
+ * current node values are the trace, regardless of which justifier is plugged in.
  *
  * @module
  */
 
-import { derived, Graph, producer, state } from "@graphrefly/graphrefly";
+import { type Ctx, depBatch } from "@graphrefly/ts/core";
+import { Graph } from "@graphrefly/ts/graph";
 
 export interface Transaction {
 	readonly id: string;
@@ -74,16 +74,14 @@ export interface ReasonFactors {
 
 /**
  * A justifier turns the structured reason + txn into natural language.
- * Sync by design so the derived node stays within a single wave. In the
- * browser demo, Chrome Nano's async output is composed via `promptNode`
- * downstream — the `alertMessage` node emits the template fragment, then
- * a separate `llmAlert` node re-phrases it. Keeps the core pipeline
- * deterministic and explainable-without-LLM.
+ * Sync by design so the derived node stays within a single wave. A browser
+ * demo can compose async phrasing downstream at an explicit adapter boundary;
+ * this core pipeline remains deterministic and explainable-without-LLM.
  */
 export type Justifier = (reason: ReasonFactors, txn: Transaction) => string;
 
 export interface SpendingAlertsOptions {
-	/** Static user profile — in a real app this would come from a `fromStorage` source. */
+	/** Static user profile — in a real app this would come from a retained app-data node. */
 	readonly profile?: UserProfile;
 	/** z-score cutoff for flagging. Default 3. */
 	readonly zThreshold?: number;
@@ -100,6 +98,14 @@ export interface SpendingAlertsGraph {
 	readonly feed: (txn: Transaction) => void;
 }
 
+interface VendorAccumulator {
+	readonly count: number;
+	readonly mean: number;
+	readonly m2: number;
+}
+
+type VendorAccumulatorByVendor = Record<string, VendorAccumulator>;
+
 const DEFAULT_PROFILE: UserProfile = {
 	dailyAverage: 45,
 	typicalCategories: ["groceries", "coffee", "utilities"],
@@ -122,7 +128,7 @@ const defaultJustifier: Justifier = (reason, txn) => {
  * Build the spending-alerts graph. Returns a live `Graph` plus a `feed()`
  * function to push transactions through. The graph exposes named nodes so
  * `graph.describe({ explain: { from: "txFeed", to: "alertMessage" } })` produces a walkable causal
- * chain enriched with each node's value and annotation.
+ * chain enriched with each node's current value.
  */
 export function spendingAlertsGraph(opts: SpendingAlertsOptions = {}): SpendingAlertsGraph {
 	const profile = opts.profile ?? DEFAULT_PROFILE;
@@ -130,14 +136,7 @@ export function spendingAlertsGraph(opts: SpendingAlertsOptions = {}): SpendingA
 	const dailyRatioThreshold = opts.dailyRatioThreshold ?? 5;
 	const justifier = opts.justifier ?? defaultJustifier;
 
-	const graph = new Graph("spending-alerts");
-
-	// Annotate each node with the WHY so `explain()` surfaces it alongside
-	// the value. This is what turns a chain of values into a chain of
-	// reasoning.
-	const trace = (path: string, reason: string): void => {
-		graph.trace(path, reason);
-	};
+	const graph = new Graph({ name: "spending-alerts" });
 
 	// 1. Source — raw transaction stream. The producer captures `emit` on
 	// activation; the caller's `feed()` closes over it to push txns in.
@@ -146,61 +145,58 @@ export function spendingAlertsGraph(opts: SpendingAlertsOptions = {}): SpendingA
 	// lifecycle state rather than always blaming the caller for ordering.
 	let pushTxn: ((txn: Transaction) => void) | null = null;
 	let status: "pending" | "active" | "deactivated" = "pending";
-	const txFeed = producer<Transaction>(
-		(actions) => {
-			pushTxn = (txn) => actions.emit(txn);
+	const txFeed = graph.producer<Transaction>(
+		(ctx: Ctx) => {
+			pushTxn = (txn) => ctx.down([["DATA", txn]]);
 			status = "active";
-			return () => {
+			ctx.onDeactivation(() => {
 				pushTxn = null;
 				status = "deactivated";
-			};
+			});
 		},
 		{ name: "txFeed" },
 	);
-	graph.add(txFeed, { name: "txFeed" });
-	trace("txFeed", "Raw transaction stream from bank API / simulator.");
 
-	// 2. Running per-vendor stats (mean / std). Stateful accumulator —
-	// held in a closure; each new txn updates the map then the derived
-	// node emits the current snapshot for the txn's vendor.
-	const statsByVendor = new Map<string, { count: number; mean: number; m2: number }>();
-	const vendorStats = derived<VendorStats>(
+	// 2. Running per-vendor stats (mean / std). The accumulator is per-node
+	// graph state (R-ctx-state), so lifecycle/checkpoint behavior stays owned
+	// by the node rather than by a factory closure.
+	const vendorStats = graph.node<VendorStats>(
 		[txFeed],
-		([rawTxn]) => {
-			const txn = rawTxn as Transaction;
-			// Welford online update.
-			const prev = statsByVendor.get(txn.vendor) ?? {
-				count: 0,
-				mean: 0,
-				m2: 0,
-			};
-			const count = prev.count + 1;
-			const delta = txn.amount - prev.mean;
-			const mean = prev.mean + delta / count;
-			const m2 = prev.m2 + delta * (txn.amount - mean);
-			statsByVendor.set(txn.vendor, { count, mean, m2 });
-			const std = count >= 2 ? Math.sqrt(m2 / (count - 1)) : 0;
-			return { count, mean, std };
+		(ctx: Ctx) => {
+			const batch = depBatch(ctx, 0);
+			if (batch === null) return;
+			const statsByVendor =
+				ctx.state.get<VendorAccumulatorByVendor>() ??
+				(Object.create(null) as VendorAccumulatorByVendor);
+			for (const value of batch) {
+				const txn = value as Transaction;
+				// Welford online update.
+				const prev = statsByVendor[txn.vendor] ?? {
+					count: 0,
+					mean: 0,
+					m2: 0,
+				};
+				const count = prev.count + 1;
+				const delta = txn.amount - prev.mean;
+				const mean = prev.mean + delta / count;
+				const m2 = prev.m2 + delta * (txn.amount - mean);
+				statsByVendor[txn.vendor] = { count, mean, m2 };
+				const std = count >= 2 ? Math.sqrt(m2 / (count - 1)) : 0;
+				ctx.down([["DATA", { count, mean, std }]]);
+			}
+			ctx.state.set(statsByVendor);
 		},
 		{ name: "vendorStats" },
 	);
-	graph.add(vendorStats, { name: "vendorStats" });
-	trace("vendorStats", "Running per-vendor mean + sample std (Welford online update).");
 
-	// 3. User profile — static state for this demo; in a real app this is
-	// `fromStorage(...)` so it persists across sessions.
-	const userProfile = state<UserProfile>(profile, { name: "userProfile" });
-	graph.add(userProfile, { name: "userProfile" });
-	trace("userProfile", "User baseline: daily-average spend + typical categories.");
+	// 3. User profile — static state for this demo.
+	const userProfile = graph.state<UserProfile>(profile, { name: "userProfile" });
 
 	// 4. Anomaly score — composes txn × vendor stats × user profile. This is
 	// the structural join point; `deps` above are what `explainPath` walks.
-	const anomalyScore = derived<AnomalyScore>(
+	const anomalyScore = graph.derived(
 		[txFeed, vendorStats, userProfile],
-		([rawTxn, rawStats, rawProfile]) => {
-			const txn = rawTxn as Transaction;
-			const stats = rawStats as VendorStats;
-			const prof = rawProfile as UserProfile;
+		(txn, stats, prof): AnomalyScore => {
 			const scale = stats.std > 0 ? stats.std : Math.max(stats.mean, 1);
 			const zScore = (txn.amount - stats.mean) / scale;
 			const dailyRatio = txn.amount / Math.max(prof.dailyAverage, 1);
@@ -210,16 +206,13 @@ export function spendingAlertsGraph(opts: SpendingAlertsOptions = {}): SpendingA
 		},
 		{ name: "anomalyScore" },
 	);
-	graph.add(anomalyScore, { name: "anomalyScore" });
-	trace("anomalyScore", "z-score vs vendor history + daily-spend ratio + category familiarity.");
 
 	// 5. Threshold gate — binary flagged? + the threshold used. Echoes
 	// the txn + score so `reasonFactors` has what it needs without
 	// shortcutting back to `txFeed` or `anomalyScore`.
-	const thresholdGate = derived<Flagged>(
+	const thresholdGate = graph.derived(
 		[anomalyScore],
-		([rawScore]) => {
-			const score = rawScore as AnomalyScore;
+		(score): Flagged => {
 			const flagged =
 				score.zScore > zThreshold ||
 				score.dailyRatio > dailyRatioThreshold ||
@@ -228,20 +221,14 @@ export function spendingAlertsGraph(opts: SpendingAlertsOptions = {}): SpendingA
 		},
 		{ name: "thresholdGate" },
 	);
-	graph.add(thresholdGate, { name: "thresholdGate" });
-	trace(
-		"thresholdGate",
-		`Flag when zScore > ${zThreshold} OR dailyRatio > ${dailyRatioThreshold} OR category is unknown.`,
-	);
 
 	// 6. Reason factors — structured list of contributing signals + the
 	// originating txn. Only depends on `thresholdGate` so the causal spine
 	// stays `txFeed → anomalyScore → thresholdGate → reasonFactors →
 	// alertMessage`.
-	const reasonFactors = derived<ReasonFactors>(
+	const reasonFactors = graph.derived(
 		[thresholdGate],
-		([rawGate]) => {
-			const gate = rawGate as Flagged;
+		(gate): ReasonFactors => {
 			const { score, txn } = gate;
 			if (!gate.flagged) return { factors: [], severity: "low", txn };
 			const factors: string[] = [];
@@ -260,27 +247,19 @@ export function spendingAlertsGraph(opts: SpendingAlertsOptions = {}): SpendingA
 		},
 		{ name: "reasonFactors" },
 	);
-	graph.add(reasonFactors, { name: "reasonFactors" });
-	trace("reasonFactors", "Decomposes the flag into contributing signals — trustable breakdown.");
 
 	// 7. Alert message — human-readable final output. Only depends on
 	// `reasonFactors` so `graph.describe({ explain: { from: 'txFeed', to: 'alertMessage' } })` walks
 	// through every intermediate on the reasoning spine. Pluggable via
-	// `justifier` (deterministic template here; swap for a `promptNode` in
-	// the browser demo — the graph topology is identical either way).
-	const alertMessage = derived<string>(
+	// `justifier` (deterministic template here; richer phrasing can be
+	// composed downstream through an explicit adapter boundary).
+	graph.derived(
 		[reasonFactors],
-		([rawReason]) => {
-			const reason = rawReason as ReasonFactors;
+		(reason): string => {
 			return justifier(reason, reason.txn);
 		},
 		{ name: "alertMessage" },
 	);
-	graph.add(alertMessage, { name: "alertMessage" });
-	trace(
-		"alertMessage",
-		"Final human-readable alert. Swap the justifier for a promptNode to get LLM-authored rationale.",
-	);
 
 	return {
 		graph,
diff --git a/llms.txt b/llms.txt
index e56026bd..3f00fa56 100644
--- a/llms.txt
+++ b/llms.txt
@@ -1,161 +1,53 @@
-# GraphReFly — TypeScript packages (`@graphrefly/graphrefly`, `@graphrefly/pure-ts`, `@graphrefly/native`)
+# GraphReFly — TypeScript clean-slate implementation
 
-The reactive harness layer for agent workflows. Reactive graph runtime for human + LLM co-operation — causal tracing, persistent checkpoints, policy enforcement, zero dependencies.
+GraphReFly is a reactive universal reduction layer: high fan-in/out data becomes explicit graph facts, reductions, effects, and inspectable topology. This repo is the TypeScript implementation, published as `@graphrefly/ts`.
 
-Keywords: harness engineering, agent harness, reactive graph, causal trace, explain, agent orchestration, LLM co-operation, human-in-the-loop, reactive middleware, universal reduction layer.
+## Current Package Truth
 
-This file is an AI-oriented index for the TypeScript repos. It intentionally points to generated API docs and source-of-truth docs instead of duplicating a long API list that can drift.
+- `@graphrefly/ts` is the only active TypeScript implementation.
+- `@graphrefly/graphrefly` is a retired root package identity only.
+- `@graphrefly/pure-ts` is a frozen read-only reference for old behavior and edge cases until B66 deletion.
+- `archive/packages/parity-tests` preserves the old structural `Impl` parity harness for history only.
+- Cross-runtime parity is behavioral conformance in `~/src/graphrefly/spec/conformance.jsonl`, not symbol-set matching.
 
-## Canonical behavior and docs authority
+## Authority
 
-- Behavior spec: `~/src/graphrefly/GRAPHREFLY-SPEC.md`
-- Composition guidance: `~/src/graphrefly/COMPOSITION-GUIDE.md`
-- Docs conventions: `docs/docs-guidance.md`
-- Active sequencer + decision log: `docs/implementation-plan.md`, `docs/rust-port-decisions.md`
-- Cross-track-ledger (TS ↔ native couplings): `docs/cross-track-ledger.md`
-- Roadmap / vision frame: `docs/roadmap.md`
-- Testing standard: `docs/test-guidance.md`
+The language-neutral authority lives in `~/src/graphrefly`:
 
-## Active strategy docs (read for current direction)
+- Decisions: `decisions/decisions.jsonl`
+- Protocol rules: `spec/rules.jsonl`
+- Conformance scenarios: `spec/conformance.jsonl`
+- Formal model: `formal/*.tla`
+- Sequencer/backlog: `plan/*.jsonl`
+- Dashboard check: `node ~/src/graphrefly/dashboard/build.mjs --check`
 
-- `archive/docs/SESSION-DS-14.5-A-narrative-reframe.md` — spec-as-projection reframe, multi-agent subgraph ownership protocol (L0–L3), catalog reframed as user-host concern. Wave 2 narrative source-of-truth.
-- `archive/docs/SESSION-DS-14-changesets-design.md` — universal `BaseChange<T>` envelope, `mutations` companion bundles, `mutate(act, opts)` factory.
-- `archive/docs/SESSION-reactive-collaboration-harness.md` — 7-stage reactive collaboration loop (INTAKE→TRIAGE→QUEUE→GATE→EXECUTE→VERIFY→REFLECT), `harnessLoop()` factory.
-- `archive/docs/SESSION-marketing-promotion-strategy.md` — positioning pillars, wave plan, reply-marketing playbooks, competitive intel.
+When this repo and the authority repo disagree, the authority repo wins.
 
-## Primary links
+## Useful Entry Points
 
-- Site: https://graphrefly.dev
-- API reference: https://graphrefly.dev/api/node/
-- Python docs: https://graphrefly.dev/py/api/
+- Package source: `packages/ts/src`
+- Core protocol/substrate: `@graphrefly/ts/core`
+- Graph layer and inspection: `@graphrefly/ts/graph`
+- Operators: `@graphrefly/ts/operators`
+- Sources: `@graphrefly/ts/sources`, `@graphrefly/ts/sources/browser`, `@graphrefly/ts/sources/node`
+- Storage: `@graphrefly/ts/storage`, `@graphrefly/ts/storage/browser`, `@graphrefly/ts/storage/node`
+- Render helpers: `@graphrefly/ts/render`
+- Reactive layout solution: `@graphrefly/ts/solutions/reactive-layout`
 
-## Three-package install-time model (Unit 6 D198, locked 2026-05-14)
+## Commands
 
-Consumers pick a substrate provider at **install time**. Both substrate packages expose the same public API — enforced cross-arm by `packages/parity-tests/`.
+```bash
+pnpm --filter @graphrefly/ts test
+pnpm --filter @graphrefly/ts build
+pnpm run lint
+pnpm run dashboard:check
+```
 
-| Package | What it is | Build artifact | Role |
-|---|---|---|---|
-| `@graphrefly/graphrefly` | Presentation layer: IO adapters, AI patterns, composition helpers, framework adapters, render helpers. Re-exports the chosen substrate's surface for ergonomic single-import UX. | TS only (browser + Node) | presentation |
-| `@graphrefly/pure-ts` | Pure-TypeScript substrate: `node` primitive, `Graph`, operators, sources, data structures, storage tiers. Default sync substrate; universal browser + Node. | TS only | substrate |
-| `@graphrefly/native` | Rust substrate via napi-rs. Async-only public surface (Node-only). | `.node` binary + TS wrapper | substrate (async) |
+## Clean-Slate Floor
 
-`@graphrefly/pure-ts` is the **sole working sync substrate** for `@graphrefly/graphrefly` today (D206). `@graphrefly/native` is a real shipping substrate + parity arm but NOT a sync drop-in via overrides — the async-everywhere presentation rebase (D080) stays deferred until consumer pressure. A future `@graphrefly/wasm` is deferred per D196 until a browser-Rust consumer surfaces.
-
-## Package entry points
-
-- Presentation root: `@graphrefly/graphrefly`
-- Substrate roots: `@graphrefly/pure-ts`, `@graphrefly/native`
-
-### `@graphrefly/graphrefly` subpaths (presentation)
-
-The presentation package follows a 4-layer model (D200, 2026-05-14): `base/` (domain-agnostic infrastructure) → `utils/` (domain building blocks) → `presets/` (opinionated compositions) → `solutions/` (user-facing products). All re-exported at the root barrel.
-
-- `@graphrefly/graphrefly` — root barrel; re-exports substrate (`@graphrefly/pure-ts`) + all four layers + `compat/*`.
-- `@graphrefly/graphrefly/base`, `base/io`, `base/composition`, `base/meta`, `base/mutation`, `base/render`, `base/sources`, `base/sources/event`, `base/sources/node`, `base/sources/browser`, `base/utils`, `base/worker` — base-layer subpaths.
-- `@graphrefly/graphrefly/utils`, `utils/ai`, `utils/ai/node`, `utils/ai/browser`, `utils/cqrs`, `utils/demo-shell`, `utils/domain-templates`, `utils/graphspec`, `utils/harness`, `utils/inspect`, `utils/job-queue`, `utils/memory`, `utils/messaging`, `utils/orchestration`, `utils/process`, `utils/reactive-layout`, `utils/reduction`, `utils/resilience`.
-- `@graphrefly/graphrefly/presets`, `presets/ai`, `presets/harness`, `presets/inspect`, `presets/memory`, `presets/resilience`.
-- `@graphrefly/graphrefly/solutions` — vertical packages (deferred until consumer pressure; barrel present, vertical folders not shipped).
-- `@graphrefly/graphrefly/compat/{react,vue,svelte,solid,nestjs,jotai,zustand,nanostores,signals}` — framework adapters.
-- `@graphrefly/graphrefly/extra/node` + `extra/browser` — runtime-specific re-exports of the substrate's Node-only / browser-only surface.
-
-### `@graphrefly/pure-ts` subpaths (substrate)
-
-- `@graphrefly/pure-ts` — universal default (browser + Node safe).
-- `@graphrefly/pure-ts/core` — `node` primitive, `batch`, `Actor`, `policy`, central clock.
-- `@graphrefly/pure-ts/graph` — `Graph` container, `describe`/`observe`/`snapshot`/`mount`.
-- `@graphrefly/pure-ts/extra` — operators, sync sources, data structures, universal storage.
-- `@graphrefly/pure-ts/extra/operators`, `extra/sources`, `extra/storage`, `extra/storage/wal`.
-- `@graphrefly/pure-ts/extra/node`, `extra/storage/node` — Node-only (may import `node:*`).
-- `@graphrefly/pure-ts/extra/browser`, `extra/storage/browser` — browser-only (may use DOM globals).
-- `@graphrefly/pure-ts/testing` — test helpers for parity / regression suites.
-
-## Public API by layer (presentation 4-layer model, D200)
-
-Full export lists live in the generated API pages under `website/src/content/docs/api/`. The descriptions below explain *what lives in each layer and why* so an LLM reading this cold can navigate without consuming the drift-prone catalog. The CI-enforced layer boundary is in `scripts/check-layer-boundary.ts` (D201).
-
-### Substrate (re-exported from `@graphrefly/pure-ts` at the root barrel)
-
-The minimal reactive substrate. One primitive (`node`) plus a `Graph` container that exposes the **sugar as methods** (`g.state(name, …)`, `g.derived(name, deps, fn)`, `g.effect(deps, fn)`, `g.producer(name, factory)`); freestanding `pipe`, `dynamicNode`, `autoTrackNode` are available for off-`Graph` composition. Protocol internals: message types (`DATA`, `DIRTY`, `RESOLVED`, `COMPLETE`, `ERROR`, `TEARDOWN`, `INVALIDATE`, `PAUSE`, `RESUME`), two-phase batch semantics (`batch`, `isBatching`, `partitionForBatch`), guard/policy (`policy`, `GuardDenied`, `accessHintForGuard`), actor identity (`Actor`), the central clock (`monotonicNs`, `wallClockNs`). **Anything outside the substrate must not call `Date.now()` / `performance.now()` directly — use `core/clock.ts`.** Spec §5.8–5.12 invariants are enforced here.
-
-The `Graph` container exposes `describe` / `observe` / `snapshot` / `restoreSnapshot` / `mount` / `attachSnapshotStorage` / `teardown`. Causal walkback is `g.describe({ explain: { from, to } })` (there is no `graph.explain()` method). Diagram rendering is a pure renderer over a describe snapshot: `graphSpecToMermaid(g.describe())`, `graphSpecToPretty`, `graphSpecToD2` — exported from `@graphrefly/graphrefly/base/render`. `reachable(graph, startPath)` computes the dependency closure.
-
-### `base/` — domain-agnostic infrastructure
-
-- `base/io` — fromHttp, fromWebSocket, fromSSE, fromWebhook, fromKafka, fromNats, fromPulsar, fromRabbitMQ, drizzle, prisma, kysely, clickhouse, otel, prometheus, statsd, syslog, csv, ndjson.
-- `base/composition` — verifiable, distill, pubsub, backpressure (`createWatermarkController`), externalProducer, materialize, externalRegister.
-- `base/mutation` — `mutate(act, opts)` factory + lightMutation, auditLog helpers.
-- `base/render` — `graphSpecToMermaid`, `graphSpecToD2`, `graphSpecToPretty`, mermaid URL helpers.
-- `base/sources/event` — fromCron, dom event sources.
-- `base/sources/node` — fromGitHook, fromFSWatch, server-side event sources (Node-only).
-- `base/sources/browser` — DOM-using browser sources.
-- `base/meta` — domainMeta, keepalive helpers.
-- `base/worker` — worker bridge.
-
-### `utils/` — domain building blocks
-
-- `utils/messaging` — `topic`, `subscription` (cursor / `pull` / `ack`), `topicBridge`, `messagingHub` (Pulsar-inspired lazy topic registry).
-- `utils/orchestration` — `pipelineGraph` (with `approvalGate` method — the human-approval gate; this replaced the older `gate(...)` name), `humanInput`, `tracker`, `classify`, `catch`.
-- `utils/memory` — `reactiveFactStore<T>()` (DS-14.7 v1 substrate; cascade + temporal + dependentsIndex), `simpleFactStore` (deferred to v1.1), `persistentFactStore`.
-- `utils/ai` — `chatStream`, `toolRegistry`, `systemPromptBuilder`, `llmExtractor`, `llmConsolidator`, `fromLLM`, `streamingPromptNode`, `streamExtractor`, `knobsAsTools`, `gaugesAsContext`. AI provider adapters under `utils/ai/adapters/` (Anthropic, OpenAI, Google, etc.); Node-only and browser-only variants split via `utils/ai/node` and `utils/ai/browser`.
-- `utils/resilience` — `circuitBreaker`, `withBreaker`, `withStatus`, `rateLimiter`, `withMaxAttempts`, fallback, budgetGate.
-- `utils/cqrs` — `cqrs(name, opts?)` Graph (commands / events / projections / sagas).
-- `utils/harness` — stage type primitives, evalSource, beforeAfterCompare, actuatorExecutor, evalIntakeBridge, HarnessExecutor, HarnessVerifier.
-- `utils/inspect` — `graphLens`, `audit`, `policyGate`, structured introspection.
-- `utils/job-queue` — `jobQueue`, `jobFlow`.
-- `utils/graphspec` — spec compile/decompile + `validateOwnership(spec, prDiff)` (multi-agent claim linter).
-- `utils/reactive-layout` — `reactiveLayout`, `reactiveBlockLayout`, Knuth-Plass-style line breaking as a state→derived graph (Pretext-inspired).
-- `utils/reduction` — universal reduction primitives for massive-info → actionable-items pipelines.
-
-### `presets/` — opinionated compositions
-
-- `presets/ai` — `agentLoop` (ReAct inner loop), `agentMemory` (distill + vectors + KG + tiers with OpenViking decay).
-- `presets/harness` — `harnessLoop` (INTAKE → TRIAGE → QUEUE → GATE → EXECUTE → VERIFY → REFLECT), `refineLoop`, `harnessProfile`, `ownershipController` (L0 static / L1 TTL / L2 heartbeat / L3 supervisor staircase).
-- `presets/resilience` — `resilientPipeline` (rateLimiter → breaker → retry → timeout → fallback in the correct order).
-- `presets/inspect` — `guardedExecution` (Actor / Guard ABAC + policy + budgetGate + scoped describe).
-- `presets/memory` — composed memory products on top of `reactiveFactStore`.
-
-### `solutions/` — user-facing products
-
-Barrel re-exports preset combinations. Vertical folders (`solutions/customer-support-bot/`, `solutions/code-review-agent/`, etc.) are deferred until consumer pressure (D202).
-
-### `compat/*` — framework adapters
-
-React (`useNode`), Vue (`useNode → Ref`), Svelte (`toStore`), Solid (`useNode → Signal`), NestJS (`GraphReflyModule.forRoot()`), plus interop shims for Jotai, Zustand, Nanostores, TC39 Signals proposal. Each compat layer lives in its own subpath so unused adapters tree-shake out.
-
-## Design docs that back the above
-
-- Phase 4+ factory authors must read `~/src/graphrefly/COMPOSITION-GUIDE.md` before composing primitives — covers lazy activation, subscription ordering, null guards, feedback cycles, `promptNode` SENTINEL, wiring order.
-- Backlog / anti-patterns / deferred follow-ups: `docs/optimizations.md`.
-- Historical design decisions and parity notes: `archive/optimizations/`.
-- Cross-track coupling between TS and native: `docs/cross-track-ledger.md` (the single place to log `Impl`-widening changes; see also `~/src/graphrefly-rs/docs/migration-status.md`).
-
-## Generated docs workflow
-
-TypeScript API pages are generated from JSDoc:
-
-- Generator: `website/scripts/gen-api-docs.mjs`
-- Output: `website/src/content/docs/api/*.md`
-- Commands:
-  - `pnpm --dir website docs:gen`
-  - `pnpm --dir website docs:gen:check`
-  - `pnpm --dir website sync-docs`
-  - `pnpm --dir website sync-docs:check`
-
-Do not hand-edit generated API pages or `website/public/llms.txt` (mirror of root `llms.txt`).
-
-## Core design invariants
-
-- No polling; propagation is reactive.
-- No imperative triggers outside graph/message flow.
-- No raw async primitives inside reactive layer logic.
-- Use central clock (`monotonicNs` / `wallClockNs`) and `messageTier` helpers for timing/tier semantics.
-- Keep Phase 4+ surfaces developer-oriented (hide protocol internals from primary API docs).
-- Substrate vs presentation classification follows the layering predicate in `~/src/graphrefly-rs/CLAUDE.md` § "Layering predicate — substrate vs presentation".
-
-## Harness engineering coverage
-
-GraphReFly covers the 8 requirements of a production agent harness — context/state control, execution boundary, control flow, verification, observability, policy/safety, human governance, continuous improvement. Mapping lives in `README.md` and `archive/docs/SESSION-harness-engineering-strategy.md` (with Wave 2 framing reframed by `archive/docs/SESSION-DS-14.5-A-narrative-reframe.md`).
-
-## Reactive collaboration loop (§9.0)
-
-`harnessLoop()` wires a static topology: INTAKE → TRIAGE → QUEUE → GATE → EXECUTE → VERIFY → REFLECT. Static topology + flowing data (the Kafka insight). Humans steer via `approvalGate.modify((value, index, pending) => T, n?)`. Strategy model (`rootCause × intervention → successRate`) feeds TRIAGE routing. Design source: `archive/docs/SESSION-reactive-collaboration-harness.md`.
+- Eight verbs only: `node`, `graph`, `batch`, `state`, `producer`, `derived`, `effect`, `mount`.
+- All user functions go through the dispatcher.
+- The wave protocol implementation is synchronous; async belongs at source, pool, storage, or wire-bridge boundaries.
+- DATA moves through messages, not hidden cache peeks inside reactive functions.
+- Operators are node sugar and per-language; they are not parity verbs.
+- No restoration of old `compat/*`, `utils/*`, `presets/*`, `base/*`, `GraphSpec`, `factoryTag`, `Actor`, `guard`, old structural `Impl` parity, fake topology streams, or storage-owned hydration/restore.
diff --git a/package.json b/package.json
index b48861de..a0aed8ec 100644
--- a/package.json
+++ b/package.json
@@ -1,8 +1,10 @@
 {
 	"name": "@graphrefly/graphrefly",
 	"version": "0.49.0",
-	"packageManager": "pnpm@10.33.0+sha512.10568bb4a6afb58c9eb3630da90cc9516417abebd3fabbe6739f0ae795728da1491e9db5a544c76ad8eb7570f5c4bb3d6c637b2cb41bfdcdb47fa823c8649319",
-	"description": "Reactive harness layer for agent workflows. Describe automations in plain language, trace every decision, enforce policies, persist checkpoints. Zero dependencies.",
+	"private": true,
+	"deprecated": "CSP-9/B65: root @graphrefly/graphrefly is retired; use @graphrefly/ts and its D125 subpaths.",
+	"packageManager": "pnpm@11.7.0+sha512.19cc852c120c7125760f2443ee6be0ca5b40f9f50598de1a09a1f177503e010e57c23c77646e01e761de59bf874fb22a3398c33ab9691fc13eb946b6f0f4d620",
+	"description": "Retired GraphReFly root package. Use @graphrefly/ts for the clean-slate TypeScript implementation.",
 	"repository": {
 		"type": "git",
 		"url": "https://github.com/graphrefly/graphrefly-ts"
@@ -12,638 +14,33 @@
 	},
 	"homepage": "https://graphrefly.dev",
 	"type": "module",
-	"sideEffects": false,
-	"main": "dist/index.cjs",
-	"module": "dist/index.js",
-	"types": "dist/index.d.ts",
-	"exports": {
-		".": {
-			"import": {
-				"types": "./dist/index.d.ts",
-				"default": "./dist/index.js"
-			},
-			"require": {
-				"types": "./dist/index.d.cts",
-				"default": "./dist/index.cjs"
-			}
-		},
-		"./base": {
-			"import": {
-				"types": "./dist/base/index.d.ts",
-				"default": "./dist/base/index.js"
-			},
-			"require": {
-				"types": "./dist/base/index.d.cts",
-				"default": "./dist/base/index.cjs"
-			}
-		},
-		"./base/composition": {
-			"import": {
-				"types": "./dist/base/composition/index.d.ts",
-				"default": "./dist/base/composition/index.js"
-			},
-			"require": {
-				"types": "./dist/base/composition/index.d.cts",
-				"default": "./dist/base/composition/index.cjs"
-			}
-		},
-		"./base/io": {
-			"import": {
-				"types": "./dist/base/io/index.d.ts",
-				"default": "./dist/base/io/index.js"
-			},
-			"require": {
-				"types": "./dist/base/io/index.d.cts",
-				"default": "./dist/base/io/index.cjs"
-			}
-		},
-		"./base/meta": {
-			"import": {
-				"types": "./dist/base/meta/index.d.ts",
-				"default": "./dist/base/meta/index.js"
-			},
-			"require": {
-				"types": "./dist/base/meta/index.d.cts",
-				"default": "./dist/base/meta/index.cjs"
-			}
-		},
-		"./base/mutation": {
-			"import": {
-				"types": "./dist/base/mutation/index.d.ts",
-				"default": "./dist/base/mutation/index.js"
-			},
-			"require": {
-				"types": "./dist/base/mutation/index.d.cts",
-				"default": "./dist/base/mutation/index.cjs"
-			}
-		},
-		"./base/render": {
-			"import": {
-				"types": "./dist/base/render/index.d.ts",
-				"default": "./dist/base/render/index.js"
-			},
-			"require": {
-				"types": "./dist/base/render/index.d.cts",
-				"default": "./dist/base/render/index.cjs"
-			}
-		},
-		"./base/sources": {
-			"import": {
-				"types": "./dist/base/sources/index.d.ts",
-				"default": "./dist/base/sources/index.js"
-			},
-			"require": {
-				"types": "./dist/base/sources/index.d.cts",
-				"default": "./dist/base/sources/index.cjs"
-			}
-		},
-		"./base/sources/event": {
-			"import": {
-				"types": "./dist/base/sources/event/index.d.ts",
-				"default": "./dist/base/sources/event/index.js"
-			},
-			"require": {
-				"types": "./dist/base/sources/event/index.d.cts",
-				"default": "./dist/base/sources/event/index.cjs"
-			}
-		},
-		"./base/sources/node": {
-			"import": {
-				"types": "./dist/base/sources/node/index.d.ts",
-				"default": "./dist/base/sources/node/index.js"
-			},
-			"require": {
-				"types": "./dist/base/sources/node/index.d.cts",
-				"default": "./dist/base/sources/node/index.cjs"
-			}
-		},
-		"./base/sources/browser": {
-			"browser": {
-				"import": {
-					"types": "./dist/base/sources/browser/index.d.ts",
-					"default": "./dist/base/sources/browser/index.js"
-				},
-				"require": {
-					"types": "./dist/base/sources/browser/index.d.cts",
-					"default": "./dist/base/sources/browser/index.cjs"
-				}
-			},
-			"import": {
-				"types": "./dist/base/sources/browser/index.d.ts",
-				"default": "./dist/base/sources/browser/index.js"
-			},
-			"require": {
-				"types": "./dist/base/sources/browser/index.d.cts",
-				"default": "./dist/base/sources/browser/index.cjs"
-			}
-		},
-		"./base/utils": {
-			"import": {
-				"types": "./dist/base/utils/index.d.ts",
-				"default": "./dist/base/utils/index.js"
-			},
-			"require": {
-				"types": "./dist/base/utils/index.d.cts",
-				"default": "./dist/base/utils/index.cjs"
-			}
-		},
-		"./base/worker": {
-			"import": {
-				"types": "./dist/base/worker/index.d.ts",
-				"default": "./dist/base/worker/index.js"
-			},
-			"require": {
-				"types": "./dist/base/worker/index.d.cts",
-				"default": "./dist/base/worker/index.cjs"
-			}
-		},
-		"./utils": {
-			"import": {
-				"types": "./dist/utils/index.d.ts",
-				"default": "./dist/utils/index.js"
-			},
-			"require": {
-				"types": "./dist/utils/index.d.cts",
-				"default": "./dist/utils/index.cjs"
-			}
-		},
-		"./utils/ai": {
-			"import": {
-				"types": "./dist/utils/ai/index.d.ts",
-				"default": "./dist/utils/ai/index.js"
-			},
-			"require": {
-				"types": "./dist/utils/ai/index.d.cts",
-				"default": "./dist/utils/ai/index.cjs"
-			}
-		},
-		"./utils/ai/node": {
-			"import": {
-				"types": "./dist/utils/ai/node.d.ts",
-				"default": "./dist/utils/ai/node.js"
-			},
-			"require": {
-				"types": "./dist/utils/ai/node.d.cts",
-				"default": "./dist/utils/ai/node.cjs"
-			}
-		},
-		"./utils/ai/browser": {
-			"browser": {
-				"import": {
-					"types": "./dist/utils/ai/browser.d.ts",
-					"default": "./dist/utils/ai/browser.js"
-				},
-				"require": {
-					"types": "./dist/utils/ai/browser.d.cts",
-					"default": "./dist/utils/ai/browser.cjs"
-				}
-			},
-			"import": {
-				"types": "./dist/utils/ai/browser.d.ts",
-				"default": "./dist/utils/ai/browser.js"
-			},
-			"require": {
-				"types": "./dist/utils/ai/browser.d.cts",
-				"default": "./dist/utils/ai/browser.cjs"
-			}
-		},
-		"./utils/cqrs": {
-			"import": {
-				"types": "./dist/utils/cqrs/index.d.ts",
-				"default": "./dist/utils/cqrs/index.js"
-			},
-			"require": {
-				"types": "./dist/utils/cqrs/index.d.cts",
-				"default": "./dist/utils/cqrs/index.cjs"
-			}
-		},
-		"./utils/demo-shell": {
-			"import": {
-				"types": "./dist/utils/demo-shell/index.d.ts",
-				"default": "./dist/utils/demo-shell/index.js"
-			},
-			"require": {
-				"types": "./dist/utils/demo-shell/index.d.cts",
-				"default": "./dist/utils/demo-shell/index.cjs"
-			}
-		},
-		"./utils/domain-templates": {
-			"import": {
-				"types": "./dist/utils/domain-templates/index.d.ts",
-				"default": "./dist/utils/domain-templates/index.js"
-			},
-			"require": {
-				"types": "./dist/utils/domain-templates/index.d.cts",
-				"default": "./dist/utils/domain-templates/index.cjs"
-			}
-		},
-		"./utils/graphspec": {
-			"import": {
-				"types": "./dist/utils/graphspec/index.d.ts",
-				"default": "./dist/utils/graphspec/index.js"
-			},
-			"require": {
-				"types": "./dist/utils/graphspec/index.d.cts",
-				"default": "./dist/utils/graphspec/index.cjs"
-			}
-		},
-		"./utils/harness": {
-			"import": {
-				"types": "./dist/utils/harness/index.d.ts",
-				"default": "./dist/utils/harness/index.js"
-			},
-			"require": {
-				"types": "./dist/utils/harness/index.d.cts",
-				"default": "./dist/utils/harness/index.cjs"
-			}
-		},
-		"./utils/inspect": {
-			"import": {
-				"types": "./dist/utils/inspect/index.d.ts",
-				"default": "./dist/utils/inspect/index.js"
-			},
-			"require": {
-				"types": "./dist/utils/inspect/index.d.cts",
-				"default": "./dist/utils/inspect/index.cjs"
-			}
-		},
-		"./utils/job-queue": {
-			"import": {
-				"types": "./dist/utils/job-queue/index.d.ts",
-				"default": "./dist/utils/job-queue/index.js"
-			},
-			"require": {
-				"types": "./dist/utils/job-queue/index.d.cts",
-				"default": "./dist/utils/job-queue/index.cjs"
-			}
-		},
-		"./utils/memory": {
-			"import": {
-				"types": "./dist/utils/memory/index.d.ts",
-				"default": "./dist/utils/memory/index.js"
-			},
-			"require": {
-				"types": "./dist/utils/memory/index.d.cts",
-				"default": "./dist/utils/memory/index.cjs"
-			}
-		},
-		"./utils/messaging": {
-			"import": {
-				"types": "./dist/utils/messaging/index.d.ts",
-				"default": "./dist/utils/messaging/index.js"
-			},
-			"require": {
-				"types": "./dist/utils/messaging/index.d.cts",
-				"default": "./dist/utils/messaging/index.cjs"
-			}
-		},
-		"./utils/orchestration": {
-			"import": {
-				"types": "./dist/utils/orchestration/index.d.ts",
-				"default": "./dist/utils/orchestration/index.js"
-			},
-			"require": {
-				"types": "./dist/utils/orchestration/index.d.cts",
-				"default": "./dist/utils/orchestration/index.cjs"
-			}
-		},
-		"./utils/process": {
-			"import": {
-				"types": "./dist/utils/process/index.d.ts",
-				"default": "./dist/utils/process/index.js"
-			},
-			"require": {
-				"types": "./dist/utils/process/index.d.cts",
-				"default": "./dist/utils/process/index.cjs"
-			}
-		},
-		"./utils/reactive-layout": {
-			"import": {
-				"types": "./dist/utils/reactive-layout/index.d.ts",
-				"default": "./dist/utils/reactive-layout/index.js"
-			},
-			"require": {
-				"types": "./dist/utils/reactive-layout/index.d.cts",
-				"default": "./dist/utils/reactive-layout/index.cjs"
-			}
-		},
-		"./utils/reduction": {
-			"import": {
-				"types": "./dist/utils/reduction/index.d.ts",
-				"default": "./dist/utils/reduction/index.js"
-			},
-			"require": {
-				"types": "./dist/utils/reduction/index.d.cts",
-				"default": "./dist/utils/reduction/index.cjs"
-			}
-		},
-		"./utils/resilience": {
-			"import": {
-				"types": "./dist/utils/resilience/index.d.ts",
-				"default": "./dist/utils/resilience/index.js"
-			},
-			"require": {
-				"types": "./dist/utils/resilience/index.d.cts",
-				"default": "./dist/utils/resilience/index.cjs"
-			}
-		},
-		"./utils/surface": {
-			"import": {
-				"types": "./dist/utils/surface/index.d.ts",
-				"default": "./dist/utils/surface/index.js"
-			},
-			"require": {
-				"types": "./dist/utils/surface/index.d.cts",
-				"default": "./dist/utils/surface/index.cjs"
-			}
-		},
-		"./utils/topology-view": {
-			"import": {
-				"types": "./dist/utils/topology-view/index.d.ts",
-				"default": "./dist/utils/topology-view/index.js"
-			},
-			"require": {
-				"types": "./dist/utils/topology-view/index.d.cts",
-				"default": "./dist/utils/topology-view/index.cjs"
-			}
-		},
-		"./presets": {
-			"import": {
-				"types": "./dist/presets/index.d.ts",
-				"default": "./dist/presets/index.js"
-			},
-			"require": {
-				"types": "./dist/presets/index.d.cts",
-				"default": "./dist/presets/index.cjs"
-			}
-		},
-		"./presets/ai": {
-			"import": {
-				"types": "./dist/presets/ai/index.d.ts",
-				"default": "./dist/presets/ai/index.js"
-			},
-			"require": {
-				"types": "./dist/presets/ai/index.d.cts",
-				"default": "./dist/presets/ai/index.cjs"
-			}
-		},
-		"./presets/harness": {
-			"import": {
-				"types": "./dist/presets/harness/index.d.ts",
-				"default": "./dist/presets/harness/index.js"
-			},
-			"require": {
-				"types": "./dist/presets/harness/index.d.cts",
-				"default": "./dist/presets/harness/index.cjs"
-			}
-		},
-		"./presets/inspect": {
-			"import": {
-				"types": "./dist/presets/inspect/index.d.ts",
-				"default": "./dist/presets/inspect/index.js"
-			},
-			"require": {
-				"types": "./dist/presets/inspect/index.d.cts",
-				"default": "./dist/presets/inspect/index.cjs"
-			}
-		},
-		"./presets/resilience": {
-			"import": {
-				"types": "./dist/presets/resilience/index.d.ts",
-				"default": "./dist/presets/resilience/index.js"
-			},
-			"require": {
-				"types": "./dist/presets/resilience/index.d.cts",
-				"default": "./dist/presets/resilience/index.cjs"
-			}
-		},
-		"./solutions": {
-			"import": {
-				"types": "./dist/solutions/index.d.ts",
-				"default": "./dist/solutions/index.js"
-			},
-			"require": {
-				"types": "./dist/solutions/index.d.cts",
-				"default": "./dist/solutions/index.cjs"
-			}
-		},
-		"./testing": {
-			"import": {
-				"types": "./dist/testing/index.d.ts",
-				"default": "./dist/testing/index.js"
-			},
-			"require": {
-				"types": "./dist/testing/index.d.cts",
-				"default": "./dist/testing/index.cjs"
-			}
-		},
-		"./compat": {
-			"import": {
-				"types": "./dist/compat/index.d.ts",
-				"default": "./dist/compat/index.js"
-			},
-			"require": {
-				"types": "./dist/compat/index.d.cts",
-				"default": "./dist/compat/index.cjs"
-			}
-		},
-		"./compat/jotai": {
-			"import": {
-				"types": "./dist/compat/jotai/index.d.ts",
-				"default": "./dist/compat/jotai/index.js"
-			},
-			"require": {
-				"types": "./dist/compat/jotai/index.d.cts",
-				"default": "./dist/compat/jotai/index.cjs"
-			}
-		},
-		"./compat/nanostores": {
-			"import": {
-				"types": "./dist/compat/nanostores/index.d.ts",
-				"default": "./dist/compat/nanostores/index.js"
-			},
-			"require": {
-				"types": "./dist/compat/nanostores/index.d.cts",
-				"default": "./dist/compat/nanostores/index.cjs"
-			}
-		},
-		"./compat/nestjs": {
-			"import": {
-				"types": "./dist/compat/nestjs/index.d.ts",
-				"default": "./dist/compat/nestjs/index.js"
-			},
-			"require": {
-				"types": "./dist/compat/nestjs/index.d.cts",
-				"default": "./dist/compat/nestjs/index.cjs"
-			}
-		},
-		"./compat/react": {
-			"import": {
-				"types": "./dist/compat/react/index.d.ts",
-				"default": "./dist/compat/react/index.js"
-			},
-			"require": {
-				"types": "./dist/compat/react/index.d.cts",
-				"default": "./dist/compat/react/index.cjs"
-			}
-		},
-		"./compat/signals": {
-			"import": {
-				"types": "./dist/compat/signals/index.d.ts",
-				"default": "./dist/compat/signals/index.js"
-			},
-			"require": {
-				"types": "./dist/compat/signals/index.d.cts",
-				"default": "./dist/compat/signals/index.cjs"
-			}
-		},
-		"./compat/solid": {
-			"import": {
-				"types": "./dist/compat/solid/index.d.ts",
-				"default": "./dist/compat/solid/index.js"
-			},
-			"require": {
-				"types": "./dist/compat/solid/index.d.cts",
-				"default": "./dist/compat/solid/index.cjs"
-			}
-		},
-		"./compat/svelte": {
-			"import": {
-				"types": "./dist/compat/svelte/index.d.ts",
-				"default": "./dist/compat/svelte/index.js"
-			},
-			"require": {
-				"types": "./dist/compat/svelte/index.d.cts",
-				"default": "./dist/compat/svelte/index.cjs"
-			}
-		},
-		"./compat/vue": {
-			"import": {
-				"types": "./dist/compat/vue/index.d.ts",
-				"default": "./dist/compat/vue/index.js"
-			},
-			"require": {
-				"types": "./dist/compat/vue/index.d.cts",
-				"default": "./dist/compat/vue/index.cjs"
-			}
-		},
-		"./compat/zustand": {
-			"import": {
-				"types": "./dist/compat/zustand/index.d.ts",
-				"default": "./dist/compat/zustand/index.js"
-			},
-			"require": {
-				"types": "./dist/compat/zustand/index.d.cts",
-				"default": "./dist/compat/zustand/index.cjs"
-			}
-		}
-	},
-	"files": [
-		"dist",
-		"LICENSE"
-	],
-	"publishConfig": {
-		"access": "public"
-	},
 	"scripts": {
 		"docs:dev": "pnpm --dir website dev",
-		"docs:build": "pnpm build && pnpm --dir website build && pnpm --dir demos/compat-matrix build && pnpm --dir demos/reactive-layout build && pnpm --dir demos/knowledge-graph build && pnpm --dir demos/pagerduty-triage build && mkdir -p website/dist/demos/compat-matrix website/dist/demos/reactive-layout website/dist/demos/knowledge-graph website/dist/demos/pagerduty-triage && cp -r demos/compat-matrix/dist/. website/dist/demos/compat-matrix/ && cp -r demos/reactive-layout/dist/. website/dist/demos/reactive-layout/ && cp -r demos/knowledge-graph/dist/. website/dist/demos/knowledge-graph/ && cp -r demos/pagerduty-triage/dist/. website/dist/demos/pagerduty-triage/",
+		"docs:build": "pnpm build && pnpm --dir website build",
 		"docs:preview": "pnpm --dir website preview",
-		"build": "pnpm --filter @graphrefly/pure-ts build && NODE_OPTIONS=--max-old-space-size=8192 tsup",
-		"build:shim": "NODE_OPTIONS=--max-old-space-size=8192 tsup",
-		"prepare": "node -e \"const fs=require('fs');const distOk=fs.existsSync('dist/index.js')&&fs.existsSync('packages/pure-ts/dist/index.js');const src=fs.existsSync('tsup.config.ts');process.exit(distOk||!src?0:1)\" || pnpm run build",
-		"test": "pnpm --filter @graphrefly/pure-ts test && pnpm test:graphrefly && pnpm --filter @graphrefly/parity-tests test",
-		"test:graphrefly": "vitest run",
-		"test:pure-ts": "pnpm --filter @graphrefly/pure-ts test",
-		"test:parity": "pnpm --filter @graphrefly/parity-tests test",
-		"test:hermes": "pnpm --filter @graphrefly/pure-ts build && node scripts/hermes-smoke/run.mjs",
-		"bench": "pnpm --filter @graphrefly/pure-ts bench",
-		"bench:baseline": "pnpm --filter @graphrefly/pure-ts bench:baseline",
+		"dashboard": "node ../graphrefly/dashboard/build.mjs",
+		"dashboard:check": "node ../graphrefly/dashboard/build.mjs --check",
+		"build": "pnpm --filter @graphrefly/ts build",
+		"test": "pnpm --filter @graphrefly/ts test",
+		"test:ts": "pnpm --filter @graphrefly/ts test",
+		"probe:b49:ts": "tsx packages/ts/src/__bench__/b49-probe.ts",
+		"bench": "pnpm run probe:b49:ts",
 		"changeset": "changeset",
 		"version-packages": "changeset version",
 		"release": "pnpm run build && changeset publish",
-		"lint": "biome check . && tsx scripts/check-layer-boundary.ts && tsx scripts/check-typecheck.ts",
-		"lint:layers": "tsx scripts/check-layer-boundary.ts",
+		"lint": "biome check . && tsx scripts/check-no-raw-async.ts && tsx scripts/check-typecheck.ts",
+		"lint:no-raw-async": "tsx scripts/check-no-raw-async.ts",
 		"lint:typecheck": "tsx scripts/check-typecheck.ts",
 		"lint:fix": "biome check --write .",
-		"format": "biome format --write .",
-		"eval": "tsx evals/scripts/run-all.ts",
-		"eval:contrastive": "tsx evals/scripts/run-l0.ts",
-		"eval:llm-dx": "tsx evals/scripts/run-l1.ts",
-		"eval:compare": "tsx evals/scripts/compare.ts",
-		"eval:matrix": "tsx evals/scripts/run-matrix.ts",
-		"eval:scorecard": "tsx evals/scripts/publish-scorecard.ts",
-		"eval:dev-dx": "vitest run --config evals/vitest.config.ts",
-		"eval:harness": "tsx evals/scripts/run-harness.ts",
-		"eval:smoke": "test -f evals/results/l0-conversational-baseline.json || { echo 'eval:smoke: fixture evals/results/l0-conversational-baseline.json is missing — the dogfood wiring smoke would vacuously pass (run-harness exits 0 on empty results). Restore the fixture or repoint eval:smoke.' >&2; exit 1; }; tsx evals/scripts/run-harness.ts --dry-run --file l0-conversational-baseline"
-	},
-	"keywords": [
-		"reactive",
-		"graph",
-		"automation",
-		"workflow",
-		"llm",
-		"ai-agents",
-		"harness-engineering",
-		"agent-harness",
-		"causal-trace",
-		"orchestration",
-		"state-management",
-		"signals",
-		"streaming",
-		"observable",
-		"causal-tracing",
-		"human-in-the-loop",
-		"natural-language",
-		"durable-workflow",
-		"framework-agnostic",
-		"react",
-		"vue",
-		"svelte",
-		"nestjs",
-		"zero-dependency"
-	],
-	"license": "MIT",
-	"peerDependencies": {
-		"@graphrefly/pure-ts": "workspace:>=0.45.0",
-		"@nestjs/common": ">=10",
-		"react": ">=18",
-		"react-dom": ">=18",
-		"solid-js": ">=1",
-		"svelte": ">=4",
-		"vue": ">=3"
-	},
-	"peerDependenciesMeta": {
-		"@graphrefly/pure-ts": {
-			"optional": false
-		},
-		"react": {
-			"optional": true
-		},
-		"react-dom": {
-			"optional": true
-		},
-		"solid-js": {
-			"optional": true
-		},
-		"svelte": {
-			"optional": true
-		},
-		"vue": {
-			"optional": true
-		},
-		"@nestjs/common": {
-			"optional": true
-		}
+		"format": "biome format --write ."
 	},
 	"devDependencies": {
-		"@anthropic-ai/sdk": "^0.82.0",
 		"@biomejs/biome": "2.4.6",
 		"@changesets/changelog-github": "^0.7.0",
 		"@changesets/cli": "^2.31.0",
-		"@google/genai": "^1.48.0",
 		"@nestjs/common": "^11.1.17",
 		"@nestjs/core": "^11.1.17",
+		"@nestjs/microservices": "^11.1.27",
 		"@nestjs/platform-express": "^11.1.18",
 		"@nestjs/platform-ws": "^11.1.18",
 		"@nestjs/testing": "^11.1.17",
@@ -659,7 +56,6 @@
 		"fast-check": "^4.7.0",
 		"hermes-compiler": "250829098.0.10",
 		"jsdom": "^29.0.1",
-		"openai": "^6.34.0",
 		"react": "^19.2.4",
 		"react-dom": "^19.2.4",
 		"reflect-metadata": "^0.2.2",
@@ -672,13 +68,5 @@
 		"vitest": "^3.0.0",
 		"vue": "^3.5.31"
 	},
-	"pnpm": {
-		"onlyBuiltDependencies": [
-			"@biomejs/biome",
-			"@nestjs/core",
-			"esbuild",
-			"protobufjs",
-			"sharp"
-		]
-	}
+	"license": "MIT"
 }
diff --git a/packages/cli/CHANGELOG.md b/packages/cli/CHANGELOG.md
deleted file mode 100644
index f9d1ddc7..00000000
--- a/packages/cli/CHANGELOG.md
+++ /dev/null
@@ -1,78 +0,0 @@
-# Changelog
-
-## 0.0.9
-
-### Patch Changes
-
-- Updated dependencies [[`4230039`](https://github.com/graphrefly/graphrefly-ts/commit/4230039498f97be2d5213d76cb8ce8f72a073b9a)]:
-  - @graphrefly/graphrefly@0.49.0
-
-## 0.0.8
-
-### Patch Changes
-
-- Updated dependencies [[`812ff96`](https://github.com/graphrefly/graphrefly-ts/commit/812ff96091f063557e01ad861baf6a87ad2082a2)]:
-  - @graphrefly/graphrefly@0.48.1
-
-## 0.0.7
-
-### Patch Changes
-
-- Updated dependencies [[`cfb1500`](https://github.com/graphrefly/graphrefly-ts/commit/cfb1500250504391683557a0b75cec381ca8e201), [`9b3554b`](https://github.com/graphrefly/graphrefly-ts/commit/9b3554b659ccb5aaf1f45dbd1ed933129d691171)]:
-  - @graphrefly/graphrefly@0.48.0
-
-## 0.0.6
-
-### Patch Changes
-
-- Updated dependencies [[`fda9432`](https://github.com/graphrefly/graphrefly-ts/commit/fda94326c6656c27008c2733f305a5c077f8ff09)]:
-  - @graphrefly/graphrefly@0.47.2
-
-## 0.0.5
-
-### Patch Changes
-
-- Updated dependencies [[`76d35c7`](https://github.com/graphrefly/graphrefly-ts/commit/76d35c73eb84a2871ac34907a10a0514674745ca)]:
-  - @graphrefly/graphrefly@0.47.1
-
-## 0.0.4
-
-### Patch Changes
-
-- Updated dependencies [[`36ff7df`](https://github.com/graphrefly/graphrefly-ts/commit/36ff7df3e4fd843ce630ad388921ff33e64a37e1), [`f08b7cf`](https://github.com/graphrefly/graphrefly-ts/commit/f08b7cf8b62ad522a1da5c4664ef719e19e5d7f0)]:
-  - @graphrefly/graphrefly@0.47.0
-
-## 0.0.3
-
-### Patch Changes
-
-- Updated dependencies [[`23c1eba`](https://github.com/graphrefly/graphrefly-ts/commit/23c1eba88c55be7ab925eaf8b704bc6604a0ec57)]:
-  - @graphrefly/graphrefly@0.46.0
-
-## 0.0.2
-
-### Patch Changes
-
-- Updated dependencies [[`64ab268`](https://github.com/graphrefly/graphrefly-ts/commit/64ab26858804265f60f169f69f95343793e5afde)]:
-  - @graphrefly/graphrefly@0.45.0
-  - @graphrefly/mcp-server@0.0.2
-
-## 0.0.1 — 2026-04-19
-
-Initial release — stateless command-line shell over the GraphReFly surface layer (roadmap §9.3c).
-
-### Commands shipped
-
-- `describe <spec>` — compile + emit topology. `--detail=minimal|standard|full`, `--format=json|pretty|mermaid|d2`.
-- `explain  <spec> --from X --to Y` — compile + emit a `CausalChain`.
-- `observe  <spec> [--path P]` — compile + one-shot observe of graph or a single node.
-- `reduce   <spec> --input <path|->` — one-shot stateless `input → pipeline → output` run with optional `--input-path` / `--output-path` / `--timeout-ms`.
-- `snapshot diff <a> <b>` — diff two snapshot files.
-- `snapshot validate <file>` — structural snapshot envelope validation.
-- `mcp` — boot the `@graphrefly/mcp-server` on stdio; honors `GRAPHREFLY_STORAGE_DIR`.
-
-### Quality-of-life
-
-- Spec and input sources accept `-` for stdin.
-- Exit code drains stdout/stderr cleanly before exiting (prevents truncated file redirects on fast hosts).
-- `SurfaceError` codes surfaced as JSON on stderr; exit `1` on any runtime error.
diff --git a/packages/cli/README.md b/packages/cli/README.md
deleted file mode 100644
index d90874c0..00000000
--- a/packages/cli/README.md
+++ /dev/null
@@ -1,108 +0,0 @@
-# @graphrefly/cli
-
-Stateless command-line shell for [GraphReFly](https://graphrefly.dev). Compile a `GraphSpec`, inspect its topology, trace causal chains, run one-shot reductions, and diff snapshots — all without writing code.
-
-## Install
-
-```bash
-npm install -g @graphrefly/cli
-# then use the `graphrefly` binary
-```
-
-Or run on demand:
-
-```bash
-npx @graphrefly/cli <command> ...
-```
-
-## 30-second quickstart
-
-Create a tiny pricing graph as JSON, describe it, then explain one edge:
-
-```bash
-cat > pricing.json <<'JSON'
-{
-  "name": "pricing",
-  "nodes": {
-    "price": { "kind": "state", "initial": 100 },
-    "tax":   { "kind": "derived", "deps": ["price"], "fn": "mul", "args": [0.1] },
-    "total": { "kind": "derived", "deps": ["price", "tax"], "fn": "add" }
-  }
-}
-JSON
-
-npx @graphrefly/cli describe pricing.json --format=pretty
-npx @graphrefly/cli describe pricing.json --format=mermaid > pricing.mmd
-npx @graphrefly/cli explain  pricing.json --from price --to total --format=pretty
-npx @graphrefly/cli observe  pricing.json --path total
-```
-
-Pipe the spec in via stdin by passing `-`:
-
-```bash
-cat pricing.json | npx @graphrefly/cli describe -
-```
-
-## Commands
-
-| Command | What it does |
-|---|---|
-| `describe <spec>` | Compile a `GraphSpec` and emit its topology. Supports `--detail=minimal\|standard\|full` and `--format=json\|pretty\|mermaid\|d2`. |
-| `explain  <spec> --from X --to Y` | Compile + walk dependencies from `Y` back to `X` and emit a `CausalChain`. |
-| `observe  <spec> [--path P]` | Compile + one-shot observe: full graph state, or a single node if `--path` is given. |
-| `reduce   <spec> --input <path\|-> [--input-path P] [--output-path Q] [--timeout-ms N]` | Stateless run: push `input` to `inputPath` (default `input`), await first `DATA` on `outputPath` (default `output`), print result, dispose. |
-| `snapshot diff <a> <b>` | Diff two snapshot files on disk. |
-| `snapshot validate <file>` | Structural validation of a snapshot envelope. |
-| `help` / `--help` / `-h` | Print the help text. |
-
-### Common flags
-
-- `--format=json\|pretty` — stdout format (default `json`). `describe` also accepts `mermaid` and `d2` for topology rendering.
-- `--detail=minimal\|standard\|full` — detail level for `describe` / `observe`.
-
-### Spec and input sources
-
-Any `<spec>` positional accepts either a path to a `.json` file or `-` for stdin. Same for `reduce --input`.
-
-## Examples
-
-Render a Mermaid diagram for a README:
-
-```bash
-npx @graphrefly/cli describe graph.json --format=mermaid > graph.mmd
-```
-
-Trace why a node has the value it has:
-
-```bash
-npx @graphrefly/cli explain graph.json --from user.input --to billing.total --format=pretty
-```
-
-One-shot reduction (stateless pipeline-as-function):
-
-```bash
-echo '{"query":"hello"}' | npx @graphrefly/cli reduce pipeline.json --input -
-```
-
-## Exit codes
-
-| Code | Meaning |
-|---|---|
-| `0` | Success. |
-| `1` | Runtime or validation error (`SurfaceError` printed as JSON on stderr). |
-| `2` | Unknown command — prints help and exits. |
-
-## Programmatic use
-
-```ts
-import { dispatch, parseArgv } from "@graphrefly/cli";
-
-const argv = parseArgv(["describe", "pricing.json", "--format=pretty"]);
-const exitCode = await dispatch(argv, { catalog: myFnCatalog });
-```
-
-`catalog` is a `GraphSpecCatalog` from `@graphrefly/graphrefly`. The default binary ships an empty catalog — state-only and passthrough specs work out of the box; custom `fn` names need an operator-provided catalog entry.
-
-## License
-
-[MIT](./LICENSE)
diff --git a/packages/cli/package.json b/packages/cli/package.json
deleted file mode 100644
index d802f53d..00000000
--- a/packages/cli/package.json
+++ /dev/null
@@ -1,58 +0,0 @@
-{
-	"name": "@graphrefly/cli",
-	"version": "0.0.9",
-	"private": true,
-	"description": "Command-line interface for GraphReFly — stateless shell over the surface layer (describe, explain, reduce, snapshot). NOT YET PUBLISHED — see docs/known-issues.md.",
-	"license": "MIT",
-	"repository": {
-		"type": "git",
-		"url": "https://github.com/graphrefly/graphrefly-ts",
-		"directory": "packages/cli"
-	},
-	"bugs": {
-		"url": "https://github.com/graphrefly/graphrefly-ts/issues"
-	},
-	"homepage": "https://graphrefly.dev",
-	"type": "module",
-	"main": "dist/index.js",
-	"types": "dist/index.d.ts",
-	"bin": {
-		"graphrefly": "dist/bin.js"
-	},
-	"files": [
-		"dist",
-		"README.md",
-		"CHANGELOG.md",
-		"LICENSE"
-	],
-	"exports": {
-		".": {
-			"types": "./dist/index.d.ts",
-			"default": "./dist/index.js"
-		}
-	},
-	"scripts": {
-		"build": "tsc -p tsconfig.json",
-		"test": "vitest run",
-		"lint": "biome check .",
-		"typecheck": "tsc -p tsconfig.json --noEmit",
-		"prepublishOnly": "pnpm build && pnpm test"
-	},
-	"publishConfig": {
-		"access": "public"
-	},
-	"dependencies": {
-		"@graphrefly/graphrefly": "workspace:*"
-	},
-	"devDependencies": {
-		"typescript": "^5.7.0",
-		"vitest": "^3.0.0"
-	},
-	"keywords": [
-		"graphrefly",
-		"cli",
-		"agent-harness",
-		"reactive-graph",
-		"causal-trace"
-	]
-}
diff --git a/packages/cli/src/bin.ts b/packages/cli/src/bin.ts
deleted file mode 100644
index 3ceeab49..00000000
--- a/packages/cli/src/bin.ts
+++ /dev/null
@@ -1,39 +0,0 @@
-#!/usr/bin/env node
-/**
- * `graphrefly` binary.
- *
- * Server operators who need a custom catalog should import `dispatch`
- * from `@graphrefly/cli` and pass `{ catalog }` — the default binary
- * ships with an empty catalog (state-only + passthrough specs work out
- * of the box; custom fn names require an operator-provided entry).
- */
-
-import { dispatch, parseArgv } from "./dispatch.js";
-
-const argv = parseArgv(process.argv.slice(2));
-dispatch(argv)
-	.then((code) => {
-		// Set exitCode rather than calling process.exit() so Node can
-		// drain pending stdout/stderr writes before exiting. Piping
-		// `graphrefly describe ... > out.json` through `process.exit`
-		// truncates the file on fast hosts; the explicit drain below
-		// plus exitCode avoids that.
-		process.exitCode = code;
-		if (process.stdout.writableLength === 0 && process.stderr.writableLength === 0) {
-			return;
-		}
-		// Flush both streams, then let the loop exit naturally with
-		// the configured exitCode.
-		const drain = (stream: NodeJS.WriteStream): Promise<void> =>
-			new Promise((resolve) => {
-				if (stream.writableLength === 0) resolve();
-				else stream.once("drain", () => resolve());
-			});
-		Promise.all([drain(process.stdout), drain(process.stderr)]).catch(() => {
-			// Swallow drain errors — the exitCode is already set.
-		});
-	})
-	.catch((err) => {
-		console.error("graphrefly: fatal", err);
-		process.exit(1);
-	});
diff --git a/packages/cli/src/dispatch.ts b/packages/cli/src/dispatch.ts
deleted file mode 100644
index ebed5272..00000000
--- a/packages/cli/src/dispatch.ts
+++ /dev/null
@@ -1,265 +0,0 @@
-/**
- * CLI command dispatcher — hand-rolled, zero external args deps.
- *
- * Each subcommand is a small async function that takes a parsed `Argv`
- * and returns an exit code. Tests invoke subcommands directly without
- * the binary entrypoint; the binary only threads `process.argv`.
- *
- * Subcommand signatures follow the shape required by §9.3c:
- * - `describe <spec>` — compile + describe
- * - `explain <spec> --from X --to Y` — compile + explain
- * - `observe <spec> [--path P]` — compile + one-shot observe
- * - `reduce <spec> --input <path|-> [--output Y]` — one-shot run
- * - `snapshot diff <a> <b>` — snapshot file diff (no tier)
- * - `snapshot validate <file>` — structural snapshot validation
- *
- * `--format=json|pretty` toggles stdout formatting.
- *
- * @module
- */
-
-import type { GraphSpec, GraphSpecCatalog } from "@graphrefly/graphrefly";
-import { createGraph, Graph, runReduction, SurfaceError } from "@graphrefly/graphrefly";
-import type { OutputFormat } from "./io.js";
-import { readJson, writeOutput } from "./io.js";
-
-export interface Argv {
-	command: string;
-	subcommand?: string;
-	positional: string[];
-	flags: Record<string, string | true>;
-}
-
-export function parseArgv(tokens: readonly string[]): Argv {
-	const [command, ...rest] = tokens;
-	const positional: string[] = [];
-	const flags: Record<string, string | true> = {};
-	let subcommand: string | undefined;
-	for (let i = 0; i < rest.length; i++) {
-		const t = rest[i]!;
-		if (t.startsWith("--")) {
-			const eq = t.indexOf("=");
-			if (eq >= 0) {
-				flags[t.slice(2, eq)] = t.slice(eq + 1);
-			} else {
-				const next = rest[i + 1];
-				if (next != null && !next.startsWith("--")) {
-					flags[t.slice(2)] = next;
-					i += 1;
-				} else {
-					flags[t.slice(2)] = true;
-				}
-			}
-		} else if (subcommand == null && command === "snapshot") {
-			subcommand = t;
-		} else {
-			positional.push(t);
-		}
-	}
-	return {
-		command: command ?? "",
-		...(subcommand != null ? { subcommand } : {}),
-		positional,
-		flags,
-	};
-}
-
-function resolveFormat(argv: Argv): OutputFormat {
-	const f = argv.flags.format;
-	if (f === "pretty") return "pretty";
-	return "json";
-}
-
-export interface DispatchOptions {
-	/** Fn/source catalog for `compile`, `reduce`, etc. Empty by default. */
-	catalog?: GraphSpecCatalog;
-}
-
-export async function dispatch(argv: Argv, opts?: DispatchOptions): Promise<number> {
-	const catalog: GraphSpecCatalog = opts?.catalog ?? {};
-	try {
-		switch (argv.command) {
-			case "describe":
-				return describeCmd(argv, catalog);
-			case "explain":
-				return explainCmd(argv, catalog);
-			case "observe":
-				return observeCmd(argv, catalog);
-			case "reduce":
-				return await reduceCmd(argv, catalog);
-			case "snapshot":
-				return snapshotCmd(argv);
-			case "help":
-			case "--help":
-			case "-h":
-			case "":
-				printHelp();
-				return 0;
-			default:
-				process.stderr.write(`graphrefly: unknown command "${argv.command}"\n`);
-				printHelp();
-				return 2;
-		}
-	} catch (err) {
-		if (err instanceof SurfaceError) {
-			process.stderr.write(`${JSON.stringify(err.toJSON())}\n`);
-			return 1;
-		}
-		const message = err instanceof Error ? err.message : String(err);
-		process.stderr.write(`graphrefly: ${message}\n`);
-		return 1;
-	}
-}
-
-function requireSpecPath(argv: Argv): string {
-	const spec = argv.positional[0] ?? (argv.flags.spec as string | undefined);
-	if (spec == null || typeof spec !== "string") {
-		throw new Error(
-			"expected a GraphSpec path (or `-` for stdin) as the first positional argument",
-		);
-	}
-	return spec;
-}
-
-function describeCmd(argv: Argv, catalog: GraphSpecCatalog): number {
-	const spec = readJson(requireSpecPath(argv)) as GraphSpec;
-	const g = createGraph(spec, { catalog });
-	try {
-		const format = argv.flags.format as string | undefined;
-		if (format === "mermaid" || format === "d2" || format === "pretty") {
-			const rendered = g.describe({
-				detail: (argv.flags.detail as "minimal" | "standard" | "full" | undefined) ?? "standard",
-				format,
-			});
-			process.stdout.write(`${rendered as unknown as string}\n`);
-			return 0;
-		}
-		const described = g.describe({
-			detail: (argv.flags.detail as "minimal" | "standard" | "full" | undefined) ?? "standard",
-		});
-		writeOutput(described, resolveFormat(argv));
-		return 0;
-	} finally {
-		g.destroy();
-	}
-}
-
-function explainCmd(argv: Argv, catalog: GraphSpecCatalog): number {
-	const spec = readJson(requireSpecPath(argv)) as GraphSpec;
-	const from = argv.flags.from as string | undefined;
-	const to = argv.flags.to as string | undefined;
-	if (from == null || to == null) {
-		throw new Error("explain requires --from <path> and --to <path>");
-	}
-	const g = createGraph(spec, { catalog });
-	try {
-		const chain = g.describe({ explain: { from, to } });
-		writeOutput((chain as { toJSON(): unknown }).toJSON(), resolveFormat(argv));
-		return 0;
-	} finally {
-		g.destroy();
-	}
-}
-
-function observeCmd(argv: Argv, catalog: GraphSpecCatalog): number {
-	const spec = readJson(requireSpecPath(argv)) as GraphSpec;
-	const path = argv.flags.path as string | undefined;
-	const detail = (argv.flags.detail as "minimal" | "standard" | "full" | undefined) ?? "standard";
-	const g = createGraph(spec, { catalog });
-	try {
-		const described = g.describe({ detail });
-		if (path == null) {
-			writeOutput(described, resolveFormat(argv));
-			return 0;
-		}
-		const slice = described.nodes[path];
-		if (slice == null) {
-			throw new SurfaceError("node-not-found", `node "${path}" is not registered`, { path });
-		}
-		writeOutput({ path, ...(slice as unknown as Record<string, unknown>) }, resolveFormat(argv));
-		return 0;
-	} finally {
-		g.destroy();
-	}
-}
-
-async function reduceCmd(argv: Argv, catalog: GraphSpecCatalog): Promise<number> {
-	const spec = readJson(requireSpecPath(argv)) as GraphSpec;
-	const inputSource = argv.flags.input as string | undefined;
-	if (inputSource == null) throw new Error("reduce requires --input <path|-> for the input JSON");
-	const input = readJson(inputSource);
-	const result = await runReduction(spec, input, {
-		catalog,
-		...(typeof argv.flags["input-path"] === "string"
-			? { inputPath: argv.flags["input-path"] as string }
-			: {}),
-		...(typeof argv.flags["output-path"] === "string"
-			? { outputPath: argv.flags["output-path"] as string }
-			: {}),
-		...(typeof argv.flags["timeout-ms"] === "string"
-			? { timeoutMs: Number(argv.flags["timeout-ms"]) }
-			: {}),
-	});
-	writeOutput(result, resolveFormat(argv));
-	return 0;
-}
-
-function snapshotCmd(argv: Argv): number {
-	switch (argv.subcommand) {
-		case "diff": {
-			const [a, b] = argv.positional;
-			if (a == null || b == null) {
-				throw new Error("snapshot diff requires two snapshot file paths");
-			}
-			const snapA = readJson(a) as import("@graphrefly/graphrefly").GraphPersistSnapshot;
-			const snapB = readJson(b) as import("@graphrefly/graphrefly").GraphPersistSnapshot;
-			const diff = Graph.diff(snapA, snapB);
-			writeOutput(diff, resolveFormat(argv));
-			return 0;
-		}
-		case "validate": {
-			const [file] = argv.positional;
-			if (file == null) throw new Error("snapshot validate requires a snapshot file path");
-			const snap = readJson(file) as import("@graphrefly/graphrefly").GraphPersistSnapshot;
-			// Minimal structural check — the full parser lives inside Graph;
-			// reconstructing validates the envelope version + required keys.
-			try {
-				Graph.fromSnapshot(snap);
-				writeOutput({ valid: true }, resolveFormat(argv));
-				return 0;
-			} catch (err) {
-				const message = err instanceof Error ? err.message : String(err);
-				writeOutput({ valid: false, error: message }, resolveFormat(argv));
-				return 1;
-			}
-		}
-		default:
-			throw new Error(
-				`snapshot: unknown subcommand "${argv.subcommand ?? ""}" (expected diff|validate)`,
-			);
-	}
-}
-
-function printHelp(): void {
-	process.stdout.write(`graphrefly — reactive harness CLI
-
-USAGE
-  graphrefly <command> [options]
-
-COMMANDS
-  describe <spec>                     Compile a GraphSpec and emit its topology.
-  explain  <spec> --from X --to Y     Compile + emit a CausalChain from X to Y.
-  observe  <spec> [--path P]          Compile + emit one-shot node or graph state.
-  reduce   <spec> --input <path|->    Run a one-shot input → pipeline → output.
-  snapshot diff     <a> <b>           Diff two snapshot files.
-  snapshot validate <file>            Validate a snapshot file envelope.
-
-COMMON FLAGS
-  --format=json|pretty                Stdout format (json default).
-  --detail=minimal|standard|full      Detail level for describe/observe.
-
-SPEC SOURCES
-  A <spec> positional is either a path to a .json file or "-" for stdin.
-  Same applies to --input for reduce.
-`);
-}
diff --git a/packages/cli/src/index.ts b/packages/cli/src/index.ts
deleted file mode 100644
index 18ffb0aa..00000000
--- a/packages/cli/src/index.ts
+++ /dev/null
@@ -1,11 +0,0 @@
-/**
- * @graphrefly/cli — stateless command-line shell over the §9.3-core
- * surface layer.
- *
- * @module
- */
-
-export type { Argv, DispatchOptions } from "./dispatch.js";
-export { dispatch, parseArgv } from "./dispatch.js";
-export type { OutputFormat } from "./io.js";
-export { readJson, writeOutput } from "./io.js";
diff --git a/packages/cli/src/io.ts b/packages/cli/src/io.ts
deleted file mode 100644
index 7be4ba3e..00000000
--- a/packages/cli/src/io.ts
+++ /dev/null
@@ -1,62 +0,0 @@
-/**
- * Stdin / file / stdout utilities for CLI commands.
- *
- * Each CLI command is stateless — state flows through snapshot files or
- * piped JSON. These helpers centralize reading JSON from `-` (stdin) or
- * a file path, and writing output in one of the supported formats.
- *
- * @module
- */
-
-import { readFileSync } from "node:fs";
-
-export type OutputFormat = "json" | "pretty";
-
-/**
- * Read a JSON payload from a file path or `"-"` for stdin. Unknown path
- * throws with a clear message. Invalid JSON surfaces the parse error
- * with the file location.
- */
-export function readJson(pathOrDash: string): unknown {
-	const text = pathOrDash === "-" ? readStdinSync() : readFileSync(pathOrDash, "utf8");
-	try {
-		return JSON.parse(text);
-	} catch (err) {
-		const message = err instanceof Error ? err.message : String(err);
-		throw new Error(
-			`failed to parse JSON from ${pathOrDash === "-" ? "stdin" : pathOrDash}: ${message}`,
-		);
-	}
-}
-
-function readStdinSync(): string {
-	// Reject TTY input early — readFileSync(0) on an interactive terminal
-	// blocks until Ctrl-D with no prompt, which looks like a hang. Piped
-	// or redirected stdin is the supported shape.
-	if (process.stdin.isTTY) {
-		throw new Error(
-			"stdin requested (`-`) but stdin is a TTY — pipe or redirect input, e.g. `cat spec.json | graphrefly …`",
-		);
-	}
-	// readFileSync on /dev/stdin is POSIX; on Windows Node accepts fd 0
-	// via the same shim. If it fails, surface the error rather than
-	// fall back to an async iterator that won't terminate under sync
-	// `readFileSync`'s blocking semantics.
-	return readFileSync(0, "utf8");
-}
-
-/** Write a result payload to stdout in the requested format. */
-export function writeOutput(value: unknown, format: OutputFormat): void {
-	if (typeof value === "string") {
-		const text = format === "json" ? JSON.stringify(value) : value;
-		process.stdout.write(text);
-		// Terminate the line if the rendered text doesn't already end
-		// with a newline. `JSON.stringify(value)` always wraps the string
-		// in quotes, so it never ends in "\n" unless the last character
-		// was a "\n" before stringification (which would render as \\n).
-		if (!text.endsWith("\n")) process.stdout.write("\n");
-		return;
-	}
-	const text = format === "pretty" ? JSON.stringify(value, null, 2) : JSON.stringify(value);
-	process.stdout.write(`${text}\n`);
-}
diff --git a/packages/cli/tests/dispatch.test.ts b/packages/cli/tests/dispatch.test.ts
deleted file mode 100644
index 4a9b7771..00000000
--- a/packages/cli/tests/dispatch.test.ts
+++ /dev/null
@@ -1,142 +0,0 @@
-import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { type GraphSpecCatalog, node } from "@graphrefly/graphrefly";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { dispatch, parseArgv } from "../src/index.js";
-
-const catalog: GraphSpecCatalog = {
-	fns: {
-		double: (deps) =>
-			node(deps, (batchData, actions) => actions.emit((batchData[0]?.at(-1) as number) * 2), {
-				describeKind: "derived",
-			}),
-		addOne: (deps) =>
-			node(deps, (batchData, actions) => actions.emit((batchData[0]?.at(-1) as number) + 1), {
-				describeKind: "derived",
-			}),
-	},
-};
-
-const basicSpec = {
-	name: "basic",
-	nodes: {
-		input: {
-			type: "state",
-			deps: [],
-			value: 0,
-			meta: { factory: "state", factoryArgs: { initial: 0 } },
-		},
-		doubled: { type: "derived", deps: ["input"], meta: { factory: "double" } },
-		output: { type: "derived", deps: ["doubled"], meta: { factory: "addOne" } },
-	},
-};
-
-describe("parseArgv", () => {
-	it("splits command + positional + flags", () => {
-		const argv = parseArgv(["describe", "spec.json", "--format", "pretty"]);
-		expect(argv.command).toBe("describe");
-		expect(argv.positional).toEqual(["spec.json"]);
-		expect(argv.flags).toEqual({ format: "pretty" });
-	});
-
-	it("recognizes snapshot subcommand", () => {
-		const argv = parseArgv(["snapshot", "diff", "a.json", "b.json"]);
-		expect(argv.command).toBe("snapshot");
-		expect(argv.subcommand).toBe("diff");
-		expect(argv.positional).toEqual(["a.json", "b.json"]);
-	});
-
-	it("treats --flag=value as one token", () => {
-		const argv = parseArgv(["reduce", "-", "--input=/tmp/x.json"]);
-		expect(argv.flags).toEqual({ input: "/tmp/x.json" });
-		expect(argv.positional).toEqual(["-"]);
-	});
-});
-
-describe("dispatch", () => {
-	let dir: string;
-	let specPath: string;
-
-	beforeEach(() => {
-		dir = mkdtempSync(join(tmpdir(), "graphrefly-cli-"));
-		specPath = join(dir, "spec.json");
-		writeFileSync(specPath, JSON.stringify(basicSpec));
-	});
-
-	afterEach(() => {
-		rmSync(dir, { recursive: true, force: true });
-	});
-
-	it("describe emits JSON topology to stdout", async () => {
-		const writes: string[] = [];
-		vi.spyOn(process.stdout, "write").mockImplementation((chunk) => {
-			writes.push(String(chunk));
-			return true;
-		});
-		const code = await dispatch(parseArgv(["describe", specPath]), { catalog });
-		expect(code).toBe(0);
-		const payload = JSON.parse(writes.join(""));
-		expect(payload.name).toBe("basic");
-		vi.restoreAllMocks();
-	});
-
-	it("reduce runs a pipeline from a JSON file", async () => {
-		const inputPath = join(dir, "input.json");
-		writeFileSync(inputPath, JSON.stringify(5));
-		const writes: string[] = [];
-		vi.spyOn(process.stdout, "write").mockImplementation((chunk) => {
-			writes.push(String(chunk));
-			return true;
-		});
-		const code = await dispatch(parseArgv(["reduce", specPath, "--input", inputPath]), { catalog });
-		expect(code).toBe(0);
-		expect(writes.join("").trim()).toBe("11");
-		vi.restoreAllMocks();
-	});
-
-	it("explain returns a causal chain", async () => {
-		const writes: string[] = [];
-		vi.spyOn(process.stdout, "write").mockImplementation((chunk) => {
-			writes.push(String(chunk));
-			return true;
-		});
-		const code = await dispatch(
-			parseArgv(["explain", specPath, "--from", "input", "--to", "output"]),
-			{ catalog },
-		);
-		expect(code).toBe(0);
-		const chain = JSON.parse(writes.join("")) as {
-			from: string;
-			to: string;
-			found: boolean;
-		};
-		expect(chain.from).toBe("input");
-		expect(chain.to).toBe("output");
-		expect(chain.found).toBe(true);
-		vi.restoreAllMocks();
-	});
-
-	it("surfaces SurfaceError as JSON on stderr with exit code 1", async () => {
-		const badPath = join(dir, "bad.json");
-		writeFileSync(badPath, JSON.stringify({ name: "", nodes: {} }));
-		const errs: string[] = [];
-		vi.spyOn(process.stderr, "write").mockImplementation((chunk) => {
-			errs.push(String(chunk));
-			return true;
-		});
-		const code = await dispatch(parseArgv(["describe", badPath]), { catalog });
-		expect(code).toBe(1);
-		const payload = JSON.parse(errs.join("").trim());
-		expect(payload.code).toBe("invalid-spec");
-		vi.restoreAllMocks();
-	});
-
-	it("unknown command returns exit code 2", async () => {
-		vi.spyOn(process.stderr, "write").mockImplementation(() => true);
-		vi.spyOn(process.stdout, "write").mockImplementation(() => true);
-		const code = await dispatch(parseArgv(["nope"]), { catalog });
-		expect(code).toBe(2);
-		vi.restoreAllMocks();
-	});
-});
diff --git a/packages/cli/tsconfig.json b/packages/cli/tsconfig.json
deleted file mode 100644
index cfab47a7..00000000
--- a/packages/cli/tsconfig.json
+++ /dev/null
@@ -1,16 +0,0 @@
-{
-	"compilerOptions": {
-		"target": "ES2022",
-		"module": "ES2022",
-		"moduleResolution": "bundler",
-		"declaration": true,
-		"outDir": "dist",
-		"rootDir": "src",
-		"strict": true,
-		"esModuleInterop": true,
-		"skipLibCheck": true,
-		"forceConsistentCasingInFileNames": true
-	},
-	"include": ["src"],
-	"exclude": ["node_modules", "dist", "tests", "**/*.test.ts"]
-}
diff --git a/packages/cli/vitest.config.ts b/packages/cli/vitest.config.ts
deleted file mode 100644
index 63810571..00000000
--- a/packages/cli/vitest.config.ts
+++ /dev/null
@@ -1,33 +0,0 @@
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-import { defineConfig } from "vitest/config";
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-
-export default defineConfig({
-	resolve: {
-		alias: [
-			// Resolve workspace-local @graphrefly/graphrefly to the
-			// presentation layer root src/index.ts (A3 cleave: substrate lives
-			// in @graphrefly/pure-ts, presentation re-exported from root src/).
-			{
-				find: /^@graphrefly\/graphrefly$/,
-				replacement: path.resolve(__dirname, "../../src/index.ts"),
-			},
-			// Alias @graphrefly/pure-ts subpath imports (e.g. /core/messages.js)
-			// so vitest resolves substrate source when transitively imported.
-			{
-				find: /^@graphrefly\/pure-ts\/(.+)$/,
-				replacement: path.resolve(__dirname, "../pure-ts/src/$1"),
-			},
-			// Alias bare @graphrefly/pure-ts import.
-			{
-				find: "@graphrefly/pure-ts",
-				replacement: path.resolve(__dirname, "../pure-ts/src/index.ts"),
-			},
-		],
-	},
-	test: {
-		include: ["tests/**/*.test.ts"],
-	},
-});
diff --git a/packages/parity-tests/vitest.config.ts b/packages/parity-tests/vitest.config.ts
deleted file mode 100644
index a1093835..00000000
--- a/packages/parity-tests/vitest.config.ts
+++ /dev/null
@@ -1,55 +0,0 @@
-import { fileURLToPath } from "node:url";
-import { defineConfig } from "vitest/config";
-
-export default defineConfig({
-	resolve: {
-		alias: [
-			// Resolve pure-ts to source so parity tests don't require a
-			// pre-build. Mirrors the alias pattern in
-			// packages/cli/vitest.config.ts.
-			//
-			// The subpath regex MUST precede the bare alias and is required:
-			// without it, `@graphrefly/pure-ts/extra` falls through to the
-			// built `dist/` via package `exports`, so parity would silently
-			// test STALE substrate for any `extra/*` symbol until pure-ts is
-			// rebuilt. Capture-group `$1` covers `/extra`, `/core/...`, etc.
-			{
-				find: /^@graphrefly\/pure-ts\/(.+)$/,
-				replacement: fileURLToPath(new URL("../pure-ts/src/$1", import.meta.url)),
-			},
-			{
-				find: /^@graphrefly\/pure-ts$/,
-				replacement: fileURLToPath(new URL("../pure-ts/src/index.ts", import.meta.url)),
-			},
-		],
-	},
-	test: {
-		include: ["scenarios/**/*.test.ts"],
-		exclude: ["**/node_modules/**", "**/dist/**"],
-		environment: "node",
-		// `@graphrefly/native` ships a `.node` napi binary via a CJS
-		// loader (`index.js` → `loadBinding(...)`). Vite/vitest's
-		// transform pipeline tries to source-map the loader and stalls
-		// on the binary; standalone `require("@graphrefly/native")`
-		// loads in ~4 ms (verified 2026-05-25 / D291 verify session),
-		// but the same `require` from inside a vitest worker hangs at
-		// boot indefinitely. Externalizing keeps it on node's native
-		// require path and lets vitest boot in <1 s. Discovered while
-		// closing Bucket A; see graphrefly-ts/docs/cross-track-ledger.md
-		// (the parity gate would silently regress on every napi rebuild
-		// without this).
-		//
-		// D291 /qa A4 (2026-05-25): regex anchored to match the bare
-		// package `@graphrefly/native` AND its per-platform sub-packages
-		// (`@graphrefly/native-darwin-arm64`, `@graphrefly/native-linux-x64-gnu`,
-		// etc. — the napi-rs loader resolves to whichever one matches
-		// the host triple) but NOT a hypothetical future `@graphrefly/
-		// native-helpers` TS-only sibling that would benefit from vite's
-		// transform pipeline.
-		server: {
-			deps: {
-				external: [/^@graphrefly\/native($|\/|-(darwin|linux|win32)-)/],
-			},
-		},
-	},
-});
diff --git a/packages/pure-ts/CHANGELOG.md b/packages/pure-ts/CHANGELOG.md
deleted file mode 100644
index 9f07441c..00000000
--- a/packages/pure-ts/CHANGELOG.md
+++ /dev/null
@@ -1,83 +0,0 @@
-# Changelog — @graphrefly/pure-ts
-
-## 0.49.0
-
-### Minor Changes
-
-- [`4230039`](https://github.com/graphrefly/graphrefly-ts/commit/4230039498f97be2d5213d76cb8ce8f72a073b9a) Thanks [@clfhhc](https://github.com/clfhhc)! - widen batch bindings
-
-## 0.48.1
-
-## 0.48.0
-
-### Minor Changes
-
-- [`9b3554b`](https://github.com/graphrefly/graphrefly-ts/commit/9b3554b659ccb5aaf1f45dbd1ed933129d691171) Thanks [@clfhhc](https://github.com/clfhhc)! - fix reactive-layout in RN and clear napi
-
-### Patch Changes
-
-- [`cfb1500`](https://github.com/graphrefly/graphrefly-ts/commit/cfb1500250504391683557a0b75cec381ca8e201) Thanks [@clfhhc](https://github.com/clfhhc)! - clean up
-
-## 0.47.2
-
-### Patch Changes
-
-- [`fda9432`](https://github.com/graphrefly/graphrefly-ts/commit/fda94326c6656c27008c2733f305a5c077f8ff09) Thanks [@clfhhc](https://github.com/clfhhc)! - fix legacy cleanup
-
-## 0.47.1
-
-### Patch Changes
-
-- [`76d35c7`](https://github.com/graphrefly/graphrefly-ts/commit/76d35c73eb84a2871ac34907a10a0514674745ca) Thanks [@clfhhc](https://github.com/clfhhc)! - fix dead queue
-
-## 0.47.0
-
-### Minor Changes
-
-- [`f08b7cf`](https://github.com/graphrefly/graphrefly-ts/commit/f08b7cf8b62ad522a1da5c4664ef719e19e5d7f0) Thanks [@clfhhc](https://github.com/clfhhc)! - memo:Re consumer follow-ups (rebuildable-projection story + ergonomics):
-
-  - **`reactiveFactStore`** — opt-in `recordIngest?: boolean` config exposes a
-    payload-carrying `ingestLog: ReactiveLogBundle<MemoryFragment<T>>`.
-    `attachStorage` it (with `bigintJsonCodecFor`) and replay entries into
-    `config.ingest` on restart to rebuild a byte-identical store (cascade
-    `validTo` is now deterministically derived from the triggering root).
-  - **`appendLogStorage`** — new `mode?: "append" | "overwrite"` option
-    (`"append"` default = accumulate/read-merge, unchanged; `"overwrite"` =
-    snapshot, replace key per flush). Contradictory JSDoc clarified — it is a
-    true logical append log; callers do not need a custom tier.
-  - **`ReactiveLogBundle.attach`** — new `attach(upstream, { skipCachedReplay })`
-    option to drop the push-on-subscribe cached-replay burst (avoids
-    double-counting when attaching after a replay).
-
-  Migration note: `harnessLoop` moved export paths — it is now
-  `@graphrefly/graphrefly/presets/harness` (was
-  `@graphrefly/pure-ts/patterns/harness`, which now errors with
-  `ERR_PACKAGE_PATH_NOT_EXPORTED`). The root barrel re-export is unchanged.
-
-### Patch Changes
-
-- [`36ff7df`](https://github.com/graphrefly/graphrefly-ts/commit/36ff7df3e4fd843ce630ad388921ff33e64a37e1) Thanks [@clfhhc](https://github.com/clfhhc)! - fix rxjs dependencies and data dispatch in agentic memory
-
-## 0.46.0
-
-### Minor Changes
-
-- [`23c1eba`](https://github.com/graphrefly/graphrefly-ts/commit/23c1eba88c55be7ab925eaf8b704bc6604a0ec57) Thanks [@clfhhc](https://github.com/clfhhc)! - substrate changes
-
-## 0.45.0
-
-### Minor Changes
-
-- [`64ab268`](https://github.com/graphrefly/graphrefly-ts/commit/64ab26858804265f60f169f69f95343793e5afde) Thanks [@clfhhc](https://github.com/clfhhc)! - minor fix
-
-## Unreleased — package rename + framing reset (PART 13 of `archive/docs/SESSION-rust-port-architecture.md`)
-
-- Renamed: `@graphrefly/legacy-pure-ts` → `@graphrefly/pure-ts` (D082).
-- Reframed: pure-TS is now a permanent first-class peer (D084), not a deprecation track. The "frozen pure-TS oracle" / "Sunset trigger Q4" framing in the 0.44.0 entry below is superseded — pure-TS continues post-1.0 as the universal fallback alongside `@graphrefly/native` (napi) and `@graphrefly/wasm` (wasm-bindgen).
-- Behavior unchanged.
-
-## 0.44.0 — 2026-05-05 (Phase 13.9.A cleave, originally published as @graphrefly/legacy-pure-ts)
-
-Initial release of the cleaved pure-TS package. Surface identical to `@graphrefly/graphrefly@0.44.0`; the implementation moved to `packages/legacy-pure-ts/` via `git mv` (history preserved). No behavioral change.
-
-Future entries land here for parity-fix backports (Rust port surfaces a divergence), spec-amendment lockstep updates, and (post-D084) feature parity with native + wasm siblings. See [README.md](./README.md) § Lifecycle.
diff --git a/packages/pure-ts/LICENSE b/packages/pure-ts/LICENSE
deleted file mode 100644
index 359b17c0..00000000
--- a/packages/pure-ts/LICENSE
+++ /dev/null
@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2026 David Chen
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
diff --git a/packages/pure-ts/README.md b/packages/pure-ts/README.md
deleted file mode 100644
index 0349d255..00000000
--- a/packages/pure-ts/README.md
+++ /dev/null
@@ -1,70 +0,0 @@
-# @graphrefly/pure-ts
-
-**Pure-TypeScript substrate for GraphReFly. Permanent first-class peer alongside `@graphrefly/native` — pick one at install time.**
-
-This package is the pure-TypeScript implementation of the substrate that GraphReFly's reactive primitives, `Graph` container, operators, sources, data structures, and storage tiers are built on. It is the sole working **sync** substrate for `@graphrefly/graphrefly` (the presentation package); `@graphrefly/native` is its **async** Rust sibling shipping the same `Impl` contract via napi.
-
-## Lifecycle
-
-- **Status:** permanent first-class peer (D084, 2026-05-08; D198 install-time model, 2026-05-14; D206 sync-substrate role, 2026-05-15).
-- **Not a frozen oracle.** Feature parity with the native sibling is maintained indefinitely; new substrate primitives land here in lockstep with the Rust port. The pure-ts tests are still the highest-fidelity behavior oracle for parity (`packages/parity-tests/` runs cross-arm scenarios over both), but pure-ts is also a real shipping substrate, not a sunset target.
-- **Supported runtimes:** browser + Node — universal subpath entries are guaranteed to import zero `node:*` builtins (enforced by `assertBrowserSafeBundles` in `tsup.config.ts`). Node-only subpaths live under `extra/node` + `extra/storage/node`; browser-only under `extra/browser` + `extra/storage/browser`.
-
-## Why this exists (D084 → D198, locked 2026-05-08 / 2026-05-14)
-
-See `archive/docs/SESSION-rust-port-architecture.md` Part 12, the `docs/implementation-plan.md` "Three-package install-time model" section, and `docs/rust-port-decisions.md` D198/D206 for the architectural narrative. Short version:
-
-1. The substrate (core protocol, `Graph`, operators, sources, data structures, storage tiers) is portable to Rust; presentation (io adapters, AI patterns, composition helpers, framework adapters) stays in TS. The cleave was executed 2026-05-15 (Cleave A, D193).
-2. Consumers pick a substrate provider at **install time**, not at runtime. Install `@graphrefly/pure-ts` (default) OR redirect to `@graphrefly/native` via npm/pnpm `overrides`. Both packages MUST expose the same public API — enforced cross-arm by `packages/parity-tests/`.
-3. `@graphrefly/native` is napi-only (Node). `@graphrefly/pure-ts` is the universal fallback — browser, Node, sandboxed runtimes. A future `@graphrefly/wasm` is deferred until a consumer surfaces (D196 consumer-pressure gate).
-
-## What consumers should use
-
-**You probably want `@graphrefly/graphrefly`**, which re-exports this package's surface alongside its own presentation layer. Use `@graphrefly/pure-ts` directly only if you want the substrate without the presentation layer (e.g. a minimal browser embed) or you're authoring a parity-test scenario.
-
-## Public API
-
-The exports map mirrors `@graphrefly/graphrefly`'s substrate surface exactly. Subpaths:
-
-| Subpath | Contents |
-|---|---|
-| `@graphrefly/pure-ts` | Universal default — full substrate that's safe in browser + Node. |
-| `@graphrefly/pure-ts/core` | `node` primitive, `Graph`-bound sugar (`state`/`derived`/`effect`/`producer` as Graph methods), `batch`, `Actor`, `policy`, clock. |
-| `@graphrefly/pure-ts/graph` | `Graph` container — `describe` / `observe` / `snapshot` / `restoreSnapshot` / `mount` / `attachSnapshotStorage`. |
-| `@graphrefly/pure-ts/extra` | Universal operators, sync sources, data structures (`reactiveMap` / `reactiveList` / `reactiveIndex` / `reactiveLog`), `kvStorage`, `cascadingCache`. |
-| `@graphrefly/pure-ts/extra/operators`, `…/sources`, `…/storage` | Subset re-exports for tighter bundles. |
-| `@graphrefly/pure-ts/extra/node` | Node-only sources/storage (`fileKv`, `sqliteKv`, etc.). May import `node:*`. |
-| `@graphrefly/pure-ts/extra/browser` | Browser-only sources/storage (`indexedDbKv`, etc.). May use DOM globals. |
-| `@graphrefly/pure-ts/extra/storage/wal` | Write-ahead-log replay path (D082). |
-| `@graphrefly/pure-ts/testing` | Test helpers (only for consumers writing parity / regression suites). |
-
-The parity contract that both substrate peers must satisfy is the `Impl` interface in `packages/parity-tests/impls/types.ts`. Widening it is a public API decision logged in `docs/cross-track-ledger.md`.
-
-## Source layout
-
-```
-src/
-  core/       — message protocol, `node`, batch, Actor, policy, clock, versioning
-  core/_internal/ — substrate-internal utilities (ring-buffer, sizeof, timer)
-  graph/      — Graph container, describe/observe/snapshot, storage attachment
-  extra/operators/        — 70+ universal operators (transform, combine, timing, …)
-  extra/sources/sync/     — `fromIter`, `of`, `empty`, `never`, `throwError`, `cached`, `replay`
-  extra/sources/event/timer — `fromTimer`
-  extra/sources/async     — `fromPromise`, `fromAsyncIter`, `fromAny`
-  extra/data-structures/  — reactiveMap/List/Index/Log, pubsub
-  extra/storage/          — kvStorage, cascadingCache, content-addressed, WAL
-  extra/composition/      — stratify, topology-diff, pubsub (substrate-portable composition)
-```
-
-Presentation-only modules (`patterns/*`, `compat/*`, `extra/io/*`, browser/event sources, render helpers, etc.) live in the root `@graphrefly/graphrefly` package, not here. The classification predicate is documented in `~/src/graphrefly-rs/CLAUDE.md` § "Layering predicate — substrate vs presentation".
-
-## Build
-
-```bash
-pnpm --filter @graphrefly/pure-ts build
-pnpm --filter @graphrefly/pure-ts test
-pnpm --filter @graphrefly/pure-ts test:watch
-pnpm --filter @graphrefly/pure-ts bench
-```
-
-The `tsup.config.ts` post-build guardrail (`assertBrowserSafeBundles`) fails the build if any universal entry transitively imports `node:*` builtins, with a `via X → Y → Z` chain in the error message. Adding a new subpath requires updating BOTH `packages/pure-ts/tsup.config.ts` `ENTRY_POINTS` (+ `nodeOnlyEntries` when Node-only) AND `packages/pure-ts/package.json` `exports`, then mirroring the entry in the root shim. See `docs/docs-guidance.md` § "Browser / Node / Universal split" in the repo root.
diff --git a/packages/pure-ts/package.json b/packages/pure-ts/package.json
deleted file mode 100644
index e5685f40..00000000
--- a/packages/pure-ts/package.json
+++ /dev/null
@@ -1,231 +0,0 @@
-{
-	"name": "@graphrefly/pure-ts",
-	"version": "0.49.0",
-	"description": "Pure TypeScript implementation of GraphReFly. Universal fallback sibling for the @graphrefly/graphrefly facade — works without Rust deps. Permanent first-class peer alongside @graphrefly/native and @graphrefly/wasm.",
-	"repository": {
-		"type": "git",
-		"url": "https://github.com/graphrefly/graphrefly-ts",
-		"directory": "packages/pure-ts"
-	},
-	"bugs": {
-		"url": "https://github.com/graphrefly/graphrefly-ts/issues"
-	},
-	"homepage": "https://graphrefly.dev",
-	"type": "module",
-	"sideEffects": false,
-	"main": "dist/index.cjs",
-	"module": "dist/index.js",
-	"types": "dist/index.d.ts",
-	"exports": {
-		".": {
-			"import": {
-				"types": "./dist/index.d.ts",
-				"default": "./dist/index.js"
-			},
-			"require": {
-				"types": "./dist/index.d.cts",
-				"default": "./dist/index.cjs"
-			}
-		},
-		"./core": {
-			"import": {
-				"types": "./dist/core/index.d.ts",
-				"default": "./dist/core/index.js"
-			},
-			"require": {
-				"types": "./dist/core/index.d.cts",
-				"default": "./dist/core/index.cjs"
-			}
-		},
-		"./testing": {
-			"import": {
-				"types": "./dist/testing/index.d.ts",
-				"default": "./dist/testing/index.js"
-			},
-			"require": {
-				"types": "./dist/testing/index.d.cts",
-				"default": "./dist/testing/index.cjs"
-			}
-		},
-		"./extra": {
-			"import": {
-				"types": "./dist/extra/index.d.ts",
-				"default": "./dist/extra/index.js"
-			},
-			"require": {
-				"types": "./dist/extra/index.d.cts",
-				"default": "./dist/extra/index.cjs"
-			}
-		},
-		"./extra/node": {
-			"import": {
-				"types": "./dist/extra/node.d.ts",
-				"default": "./dist/extra/node.js"
-			},
-			"require": {
-				"types": "./dist/extra/node.d.cts",
-				"default": "./dist/extra/node.cjs"
-			}
-		},
-		"./extra/browser": {
-			"import": {
-				"types": "./dist/extra/browser.d.ts",
-				"default": "./dist/extra/browser.js"
-			},
-			"require": {
-				"types": "./dist/extra/browser.d.cts",
-				"default": "./dist/extra/browser.cjs"
-			}
-		},
-		"./extra/operators": {
-			"import": {
-				"types": "./dist/extra/operators/index.d.ts",
-				"default": "./dist/extra/operators/index.js"
-			},
-			"require": {
-				"types": "./dist/extra/operators/index.d.cts",
-				"default": "./dist/extra/operators/index.cjs"
-			}
-		},
-		"./extra/sources": {
-			"import": {
-				"types": "./dist/extra/sources/index.d.ts",
-				"default": "./dist/extra/sources/index.js"
-			},
-			"require": {
-				"types": "./dist/extra/sources/index.d.cts",
-				"default": "./dist/extra/sources/index.cjs"
-			}
-		},
-		"./extra/storage": {
-			"import": {
-				"types": "./dist/extra/storage/index.d.ts",
-				"default": "./dist/extra/storage/index.js"
-			},
-			"require": {
-				"types": "./dist/extra/storage/index.d.cts",
-				"default": "./dist/extra/storage/index.cjs"
-			}
-		},
-		"./extra/storage/node": {
-			"import": {
-				"types": "./dist/extra/storage/tiers-node.d.ts",
-				"default": "./dist/extra/storage/tiers-node.js"
-			},
-			"require": {
-				"types": "./dist/extra/storage/tiers-node.d.cts",
-				"default": "./dist/extra/storage/tiers-node.cjs"
-			}
-		},
-		"./extra/storage/browser": {
-			"import": {
-				"types": "./dist/extra/storage/tiers-browser.d.ts",
-				"default": "./dist/extra/storage/tiers-browser.js"
-			},
-			"require": {
-				"types": "./dist/extra/storage/tiers-browser.d.cts",
-				"default": "./dist/extra/storage/tiers-browser.cjs"
-			}
-		},
-		"./extra/storage/wal": {
-			"import": {
-				"types": "./dist/extra/storage/wal.d.ts",
-				"default": "./dist/extra/storage/wal.js"
-			},
-			"require": {
-				"types": "./dist/extra/storage/wal.d.cts",
-				"default": "./dist/extra/storage/wal.cjs"
-			}
-		},
-		"./graph": {
-			"import": {
-				"types": "./dist/graph/index.d.ts",
-				"default": "./dist/graph/index.js"
-			},
-			"require": {
-				"types": "./dist/graph/index.d.cts",
-				"default": "./dist/graph/index.cjs"
-			}
-		}
-	},
-	"files": [
-		"dist",
-		"LICENSE"
-	],
-	"publishConfig": {
-		"access": "public"
-	},
-	"scripts": {
-		"build": "tsup",
-		"prepare": "node -e \"const fs=require('fs');process.exit(fs.existsSync('dist/index.js')||!fs.existsSync('tsup.config.ts')?0:1)\" || pnpm run build",
-		"test": "vitest run",
-		"bench": "vitest bench",
-		"bench:baseline": "vitest bench --outputJson ../../benchmarks/vitest-baseline.json",
-		"test:watch": "vitest"
-	},
-	"keywords": [
-		"reactive",
-		"graph",
-		"automation",
-		"workflow",
-		"llm",
-		"ai-agents",
-		"harness-engineering",
-		"agent-harness",
-		"causal-trace",
-		"orchestration",
-		"state-management",
-		"signals",
-		"streaming",
-		"observable",
-		"causal-tracing",
-		"human-in-the-loop",
-		"natural-language",
-		"durable-workflow",
-		"framework-agnostic",
-		"react",
-		"vue",
-		"svelte",
-		"nestjs",
-		"zero-dependency"
-	],
-	"license": "MIT",
-	"peerDependencies": {
-		"rxjs": ">=7"
-	},
-	"peerDependenciesMeta": {
-		"rxjs": {
-			"optional": true
-		}
-	},
-	"devDependencies": {
-		"@anthropic-ai/sdk": "^0.82.0",
-		"@google/genai": "^1.48.0",
-		"@nestjs/common": "^11.1.17",
-		"@nestjs/core": "^11.1.17",
-		"@nestjs/platform-express": "^11.1.18",
-		"@nestjs/platform-ws": "^11.1.18",
-		"@nestjs/testing": "^11.1.17",
-		"@nestjs/websockets": "^11.1.18",
-		"@solidjs/testing-library": "^0.8.10",
-		"@testing-library/react": "^16.3.2",
-		"@testing-library/svelte": "^5.3.1",
-		"@testing-library/vue": "^8.1.0",
-		"@types/node": "^25.5.0",
-		"@types/react": "^19.2.14",
-		"@types/react-dom": "^19.2.3",
-		"fast-check": "^4.7.0",
-		"jsdom": "^29.0.1",
-		"openai": "^6.34.0",
-		"react": "^19.2.4",
-		"react-dom": "^19.2.4",
-		"reflect-metadata": "^0.2.2",
-		"rxjs": "^7.8.2",
-		"solid-js": "^1.9.12",
-		"svelte": "^5.55.1",
-		"tsup": "^8.5.1",
-		"typescript": "^5.7.0",
-		"vitest": "^3.0.0",
-		"vue": "^3.5.31"
-	}
-}
diff --git a/packages/pure-ts/src/__bench__/cross-worker.bench.local.ts b/packages/pure-ts/src/__bench__/cross-worker.bench.local.ts
deleted file mode 100644
index 10ff6b8a..00000000
--- a/packages/pure-ts/src/__bench__/cross-worker.bench.local.ts
+++ /dev/null
@@ -1,222 +0,0 @@
-/**
- * Cross-Worker bench — the unique structural Rust-side win.
- *
- * Phase 13.7 follow-up: confirms (or refutes) the rust-port session doc's
- * claim that "Rust core via napi-rs enables cross-Worker shared state that
- * TS literally cannot do."
- *
- * Run as a standalone Node script (vitest bench's `bench()` doesn't compose
- * cleanly with Worker spawning + async timing):
- *
- *   pnpm tsx src/__bench__/cross-worker.bench.ts
- *
- * Or:
- *   node --import tsx src/__bench__/cross-worker.bench.ts
- *
- * Three scenarios:
- *
- * 1. **Rust shared core, N Workers** — N Worker threads, all calling into
- *    one process-global Rust `BenchCore` via napi-rs. Mutation visible to
- *    all Workers. Concurrency: serialized through `parking_lot::Mutex`
- *    inside Core; multiple Workers contend for the lock.
- *
- * 2. **TS parallel isolated, N Workers** — N Worker threads, each with its
- *    own HandleRuntime. No shared state. Each Worker emits independently.
- *    This is the closest TS-only approximation of "parallel emission";
- *    state cannot be shared across Workers.
- *
- * 3. **TS single-thread sequential** — main thread emitting N×M times in a
- *    single loop. The "what if we just don't try to parallelize" baseline.
- *
- * The scaling story: scenario 1 shows whether shared-state contention
- * is acceptable for the win of "every Worker can read every Worker's
- * latest emission." Scenarios 2 and 3 are baselines.
- */
-
-import { createRequire } from "node:module";
-import { fileURLToPath } from "node:url";
-import {
-	isMainThread,
-	type MessagePort,
-	parentPort,
-	Worker,
-	workerData,
-} from "node:worker_threads";
-
-const require = createRequire(import.meta.url);
-
-const BINDING_PATH =
-	"/Users/davidchenallio/src/graphrefly-rs/target/release/graphrefly_bindings_js.node";
-
-type Binding = any;
-
-interface RustWorkerData {
-	mode: "rust";
-	stateId: number;
-	emits: number;
-	startSignal: number;
-}
-
-interface TsWorkerData {
-	mode: "ts";
-	emits: number;
-	startSignal: number;
-}
-
-type WorkerInit = RustWorkerData | TsWorkerData;
-
-const NUM_WORKERS = 4;
-const EMITS_PER_WORKER = 250_000;
-
-if (isMainThread) {
-	main();
-} else {
-	worker();
-}
-
-async function main() {
-	console.log("=".repeat(70));
-	console.log("Cross-Worker bench");
-	console.log(`  Workers: ${NUM_WORKERS}, emits per Worker: ${EMITS_PER_WORKER.toLocaleString()}`);
-	console.log(`  Total emits: ${(NUM_WORKERS * EMITS_PER_WORKER).toLocaleString()}`);
-	console.log("=".repeat(70));
-
-	// Scenario 3: TS single-thread sequential (baseline).
-	{
-		const { HandleRuntime } = await import("../__experiments__/handle-core/bindings.js");
-		const rt = new HandleRuntime();
-		const s = rt.state(0);
-		rt.subscribe(s, () => undefined);
-		const total = NUM_WORKERS * EMITS_PER_WORKER;
-		const t0 = process.hrtime.bigint();
-		for (let i = 0; i < total; i++) {
-			s.set(i);
-		}
-		const elapsed = Number(process.hrtime.bigint() - t0) / 1e6; // ms
-		const throughput = total / (elapsed / 1000);
-		console.log(`\n[3] TS single-thread sequential ${total.toLocaleString()} emits:`);
-		console.log(`    elapsed: ${elapsed.toFixed(1)}ms`);
-		console.log(`    throughput: ${Math.round(throughput).toLocaleString()} emits/sec`);
-	}
-
-	// Scenario 1: Rust shared core, N Workers.
-	{
-		const binding: Binding = require(BINDING_PATH);
-		const stateId = binding.globalRegisterStateInt(0);
-		binding.globalSubscribeNoop(stateId);
-		const t0 = process.hrtime.bigint();
-		const workers: Worker[] = [];
-		const promises: Promise<number>[] = [];
-		for (let i = 0; i < NUM_WORKERS; i++) {
-			const workerFile = fileURLToPath(import.meta.url);
-			const w = new Worker(workerFile, {
-				workerData: {
-					mode: "rust",
-					stateId,
-					emits: EMITS_PER_WORKER,
-					startSignal: i,
-				} satisfies RustWorkerData,
-			});
-			workers.push(w);
-			promises.push(
-				new Promise<number>((resolve, reject) => {
-					w.once("message", (ms: number) => resolve(ms));
-					w.once("error", reject);
-				}),
-			);
-		}
-		const workerElapsedMs = await Promise.all(promises);
-		const wallElapsed = Number(process.hrtime.bigint() - t0) / 1e6;
-		const total = NUM_WORKERS * EMITS_PER_WORKER;
-		const throughput = total / (wallElapsed / 1000);
-		console.log(`\n[1] Rust shared core, ${NUM_WORKERS} Workers:`);
-		console.log(
-			`    per-Worker elapsed (ms): ${workerElapsedMs.map((v) => v.toFixed(1)).join(", ")}`,
-		);
-		console.log(`    wall elapsed: ${wallElapsed.toFixed(1)}ms`);
-		console.log(`    throughput: ${Math.round(throughput).toLocaleString()} emits/sec`);
-		const finalCache = binding.globalCacheInt(stateId);
-		console.log(`    final cache value (last winner of contention): ${finalCache}`);
-		await Promise.all(workers.map((w) => w.terminate()));
-	}
-
-	// Scenario 2: TS parallel isolated, N Workers (each with its own HandleRuntime).
-	{
-		const t0 = process.hrtime.bigint();
-		const workers: Worker[] = [];
-		const promises: Promise<number>[] = [];
-		for (let i = 0; i < NUM_WORKERS; i++) {
-			const workerFile = fileURLToPath(import.meta.url);
-			const w = new Worker(workerFile, {
-				workerData: {
-					mode: "ts",
-					emits: EMITS_PER_WORKER,
-					startSignal: i,
-				} satisfies TsWorkerData,
-				// tsx loader so the Worker can resolve .ts imports.
-				execArgv: ["--import", "tsx"],
-			});
-			workers.push(w);
-			promises.push(
-				new Promise<number>((resolve, reject) => {
-					w.once("message", (ms: number) => resolve(ms));
-					w.once("error", reject);
-				}),
-			);
-		}
-		const workerElapsedMs = await Promise.all(promises);
-		const wallElapsed = Number(process.hrtime.bigint() - t0) / 1e6;
-		const total = NUM_WORKERS * EMITS_PER_WORKER;
-		const throughput = total / (wallElapsed / 1000);
-		console.log(`\n[2] TS parallel isolated, ${NUM_WORKERS} Workers (NOT shared):`);
-		console.log(
-			`    per-Worker elapsed (ms): ${workerElapsedMs.map((v) => v.toFixed(1)).join(", ")}`,
-		);
-		console.log(`    wall elapsed: ${wallElapsed.toFixed(1)}ms`);
-		console.log(`    throughput: ${Math.round(throughput).toLocaleString()} emits/sec`);
-		console.log("    (note: each Worker has its OWN state — no cross-Worker visibility)");
-		await Promise.all(workers.map((w) => w.terminate()));
-	}
-
-	console.log("\n=".repeat(35));
-	console.log("Interpretation:");
-	console.log("  - Scenario 1 (Rust shared) is the unique Rust-only capability:");
-	console.log("    every Worker reads every Worker's latest emission. TS Workers");
-	console.log("    cannot share state without SharedArrayBuffer + Atomics.");
-	console.log("  - Scenario 2 throughput vs Scenario 3 shows TS parallel scaling");
-	console.log("    (limited by V8 isolate startup + Worker overhead).");
-}
-
-function worker() {
-	const init = workerData as WorkerInit;
-	if (init.mode === "rust") {
-		const binding: Binding = require(BINDING_PATH);
-		// Use the tight-loop FFI variant — measures Rust-core throughput
-		// under contention, not per-emit napi-rs overhead.
-		const t0 = process.hrtime.bigint();
-		binding.globalRustEmitLoop(init.stateId, init.emits);
-		const elapsed = Number(process.hrtime.bigint() - t0) / 1e6;
-		(parentPort as MessagePort).postMessage(elapsed);
-	} else {
-		// Worker imports the COMPILED handle-core prototype (compile via:
-		// tsc --module nodenext --moduleResolution nodenext --target esnext
-		//   --outDir /tmp/handle-core-compiled <core.ts> <bindings.ts>
-		// before running this bench).
-		import("/tmp/handle-core-compiled/bindings.js")
-			.then(({ HandleRuntime }) => {
-				const rt = new HandleRuntime();
-				const s = rt.state(0);
-				rt.subscribe(s, () => undefined);
-				const t0 = process.hrtime.bigint();
-				for (let i = 0; i < init.emits; i++) {
-					s.set(i);
-				}
-				const elapsed = Number(process.hrtime.bigint() - t0) / 1e6;
-				(parentPort as MessagePort).postMessage(elapsed);
-			})
-			.catch((err) => {
-				console.error("[worker] import failed:", err);
-				(parentPort as MessagePort).postMessage(-1);
-			});
-	}
-}
diff --git a/packages/pure-ts/src/__bench__/fanout-profile.ts b/packages/pure-ts/src/__bench__/fanout-profile.ts
deleted file mode 100644
index 4963dd84..00000000
--- a/packages/pure-ts/src/__bench__/fanout-profile.ts
+++ /dev/null
@@ -1,148 +0,0 @@
-/**
- * Fan-out sink-notification profiling harness (docs/optimizations.md Item 1).
- *
- * Not a vitest bench — run with `pnpm tsx src/__bench__/fanout-profile.ts`
- * (or the equivalent node invocation). Prints a structured table of
- * per-sub-notification cost across the scale curve, cross-checked via the
- * built-in per-node `v.version` counter (spec §7, V0) and `graphProfile()`.
- *
- * Goal: expose whether per-emit cost scales linearly with subscriber count
- * or has a super-linear component — the optimization doc's hypothesis is
- * that `_deliverToSinks`' `[...this._sinks]` snapshot allocation dominates
- * past ~100 subs. The harness makes the snapshot-array allocation count
- * explicit (2 per emit, since downWithBatch splits DIRTY (tier 1) and DATA
- * (tier 3) into separate `sink()` calls even outside batch — confirmed via
- * notifyCount === 2 * subs * emits).
- */
-
-import { node } from "../core/node.js";
-import { Graph } from "../graph/graph.js";
-import { graphProfile } from "../graph/profile.js";
-
-const SUB_COUNTS = [1, 10, 50, 100, 500, 1000, 5000];
-const EMITS = 20_000;
-const WARMUP_EMITS = 2_000;
-
-interface Sample {
-	subs: number;
-	emits: number;
-	elapsedMs: number;
-	hz: number;
-	nsPerEmit: number;
-	nsPerNotify: number;
-	nsPerSubAmortized: number;
-	versionDelta: number;
-	notifyCount: number;
-}
-
-function sample(subs: number): Sample {
-	const src = node<number>([], { initial: 0, versioning: 0 });
-	let notifyCount = 0;
-	const unsubs: (() => void)[] = [];
-	for (let i = 0; i < subs; i++) {
-		unsubs.push(
-			src.subscribe(() => {
-				notifyCount++;
-			}),
-		);
-	}
-
-	// Structural sanity check via graphProfile — confirms the harness
-	// actually built the topology we think we built.
-	const g = new Graph("fanout-probe");
-	g.add(src, { name: "src" });
-	const profile = graphProfile(g);
-	const target = profile.nodes.find((n) => n.path === "src");
-	if (!target || target.subscriberCount !== subs) {
-		throw new Error(
-			`graphProfile mismatch: expected ${subs} subs, got ${target?.subscriberCount ?? "missing"}`,
-		);
-	}
-
-	const versionBefore = src.v?.version ?? 0;
-
-	// Warmup (skip the first batch of emits to let v8 stabilize).
-	for (let i = 0; i < WARMUP_EMITS; i++) src.emit(i);
-	notifyCount = 0;
-
-	const t0 = process.hrtime.bigint();
-	for (let i = 0; i < EMITS; i++) src.emit(WARMUP_EMITS + i);
-	const t1 = process.hrtime.bigint();
-
-	for (const u of unsubs) u();
-
-	const elapsedNs = Number(t1 - t0);
-	const versionDelta = (src.v?.version ?? 0) - versionBefore;
-	const hz = (EMITS / elapsedNs) * 1e9;
-
-	return {
-		subs,
-		emits: EMITS,
-		elapsedMs: elapsedNs / 1e6,
-		hz,
-		nsPerEmit: elapsedNs / EMITS,
-		nsPerNotify: elapsedNs / Math.max(notifyCount, 1),
-		nsPerSubAmortized: elapsedNs / EMITS / Math.max(subs, 1),
-		versionDelta,
-		notifyCount,
-	};
-}
-
-function fmtNum(n: number, digits = 0): string {
-	return n.toLocaleString("en-US", {
-		minimumFractionDigits: digits,
-		maximumFractionDigits: digits,
-	});
-}
-
-function main(): void {
-	console.log("Fan-out scaling probe — docs/optimizations.md Item 1");
-	console.log(`Emits per sample: ${EMITS} (after ${WARMUP_EMITS} warmup emits, discarded)`);
-	console.log("Expected notifyCount per sample = 2 × subs × emits (DIRTY + DATA tier groups).");
-	console.log("Expected versionDelta = emits + warmup (all unique values).");
-	console.log();
-
-	const samples = SUB_COUNTS.map(sample);
-
-	console.log("| subs  |        hz |  ns/emit | ns/notify | ns/sub (amort) | notifyCount | vΔ |");
-	console.log("|-------|-----------|----------|-----------|----------------|-------------|----|");
-	for (const s of samples) {
-		const vSentinel =
-			s.versionDelta === EMITS + WARMUP_EMITS ? "" : ` ✗expected ${EMITS + WARMUP_EMITS}`;
-		const expectNotify = 2 * s.subs * EMITS;
-		const notifyOk = s.notifyCount === expectNotify ? "" : ` ✗expected ${fmtNum(expectNotify)}`;
-		console.log(
-			`| ${s.subs.toString().padStart(5)} | ${fmtNum(s.hz).padStart(9)} | ${s.nsPerEmit
-				.toFixed(0)
-				.padStart(8)} | ${s.nsPerNotify.toFixed(2).padStart(9)} | ${s.nsPerSubAmortized
-				.toFixed(2)
-				.padStart(
-					14,
-				)} | ${fmtNum(s.notifyCount).padStart(11)}${notifyOk} | ${s.versionDelta}${vSentinel} |`,
-		);
-	}
-
-	console.log();
-	console.log("Per-notify cost vs. 1-sub baseline (constant = linear scaling):");
-	const base = samples[0].nsPerNotify;
-	for (const s of samples) {
-		const ratio = s.nsPerNotify / base;
-		console.log(
-			`  ${s.subs.toString().padStart(5)} subs: ${s.nsPerNotify.toFixed(2)} ns/notify (${ratio.toFixed(2)}× baseline)`,
-		);
-	}
-
-	console.log();
-	console.log("Interpretation key:");
-	console.log(
-		"  - Linear scaling → ns/notify ≈ constant across sub counts. Any rise reveals per-emit overhead that doesn't amortize per sink.",
-	);
-	console.log(
-		"  - Prime suspect: `NodeImpl._deliverToSinks` allocates `[...this._sinks]` on every sink() call. With N subs × 2 sink() calls/emit × M emits, that's 2NM array slots allocated.",
-	);
-	console.log(
-		"  - Secondary suspect: `downWithBatch` allocates `messages.slice(...)` per tier split and wraps deferred phases in closures. Closure cost does NOT depend on sub count — it's per-emit, not per-notify.",
-	);
-}
-
-main();
diff --git a/packages/pure-ts/src/__bench__/ffi-cost.bench.local.ts b/packages/pure-ts/src/__bench__/ffi-cost.bench.local.ts
deleted file mode 100644
index 29c9339d..00000000
--- a/packages/pure-ts/src/__bench__/ffi-cost.bench.local.ts
+++ /dev/null
@@ -1,147 +0,0 @@
-/**
- * FFI cost bench — measures the cost of crossing the napi-rs boundary from
- * JS into the Rust core, then compares end-to-end emit throughput against
- * the pure-TS handle-core prototype.
- *
- * Phase 13.7 follow-up: with Pass-2 dispatcher numbers showing Rust 2.3-3.4×
- * faster, this bench answers whether FFI overhead eats the win on small graphs.
- *
- * Run:
- *   pnpm vitest bench src/__bench__/ffi-cost.bench.ts
- *
- * Companion: `~/src/graphrefly-rs/target/release/graphrefly_bindings_js.node`
- * (built via `cargo build -p graphrefly-bindings-js --release` in graphrefly-rs).
- */
-
-import { createRequire } from "node:module";
-import { bench, describe } from "vitest";
-import { HandleRuntime } from "../__experiments__/handle-core/bindings.js";
-
-const require = createRequire(import.meta.url);
-const binding: any = require("/Users/davidchenallio/src/graphrefly-rs/target/release/graphrefly_bindings_js.node");
-
-// ---------------------------------------------------------------------------
-// 1. Pure napi-rs FFI overhead (no Rust dispatcher work).
-// ---------------------------------------------------------------------------
-describe("ffi_overhead/noop_call", () => {
-	bench("noop_call (no return)", () => {
-		binding.noopCall();
-	});
-});
-
-describe("ffi_overhead/noop_returning_int", () => {
-	bench("noop returning i32", () => {
-		binding.noopCallReturningInt();
-	});
-});
-
-// ---------------------------------------------------------------------------
-// 2. End-to-end emit through FFI: one JS-side emit per iteration.
-//    Compares against TS-only emit on the equivalent state node.
-// ---------------------------------------------------------------------------
-describe("end_to_end_emit/rust_via_ffi", () => {
-	const core = new binding.BenchCore();
-	const s = core.registerStateInt(0);
-	core.subscribeNoop(s);
-	let i = 0;
-	bench("emit_int via FFI", () => {
-		core.emitInt(s, ++i);
-	});
-});
-
-describe("end_to_end_emit/ts_only", () => {
-	const rt = new HandleRuntime();
-	const s = rt.state(0);
-	rt.subscribe(s, () => undefined);
-	let i = 0;
-	bench("emit_int pure TS", () => {
-		s.set(++i);
-	});
-});
-
-// ---------------------------------------------------------------------------
-// 3. Amortized Rust dispatcher cost with N emits in a single FFI call.
-//    Subtracting (FFI / N) from end-to-end gives the per-emit Rust cost.
-//
-//    NOTE: We use vitest bench's per-iteration mode but each call does N
-//    internal emits; throughput numbers should be divided by the inner N.
-// ---------------------------------------------------------------------------
-const RUST_LOOP_INNER_N = 1000;
-describe(`rust_emit_loop/inner_${RUST_LOOP_INNER_N}`, () => {
-	const core = new binding.BenchCore();
-	const s = core.registerStateInt(0);
-	core.subscribeNoop(s);
-	bench(`${RUST_LOOP_INNER_N} emits per FFI call`, () => {
-		core.rustEmitLoop(s, RUST_LOOP_INNER_N);
-	});
-});
-
-// ---------------------------------------------------------------------------
-// 4. End-to-end with derived chain through FFI vs TS.
-//    Measures the realistic case: a state + chain of derived passthroughs,
-//    where each emit triggers a wave through the Rust core (or TS core).
-// ---------------------------------------------------------------------------
-const CHAIN_N = 16;
-
-describe(`chain_${CHAIN_N}/rust_via_ffi`, () => {
-	const core = new binding.BenchCore();
-	const s = core.registerStateInt(0);
-	let prev = s;
-	for (let i = 0; i < CHAIN_N; i++) {
-		prev = core.registerDerived([prev], "Identity");
-	}
-	core.subscribeNoop(prev);
-	let i = 0;
-	bench(`emit at root, chain depth ${CHAIN_N}`, () => {
-		core.emitInt(s, ++i);
-	});
-});
-
-describe(`chain_${CHAIN_N}/ts_only`, () => {
-	const rt = new HandleRuntime();
-	const s = rt.state(0);
-	let prev: { _id: unknown; current: () => unknown } = s as unknown as {
-		_id: unknown;
-		current: () => unknown;
-	};
-	for (let i = 0; i < CHAIN_N; i++) {
-		prev = rt.derived([prev as any], (v: unknown) => v as number);
-	}
-	rt.subscribe(prev as never, () => undefined);
-	let j = 0;
-	bench(`emit at root, chain depth ${CHAIN_N}`, () => {
-		s.set(++j);
-	});
-});
-
-// ---------------------------------------------------------------------------
-// 5. End-to-end large fanout — 100 leaves under one state. The case where
-//    Rust dispatcher won 3.01× in pure microbench. Does FFI eat that?
-// ---------------------------------------------------------------------------
-const FANOUT_N = 100;
-
-describe(`fanout_${FANOUT_N}/rust_via_ffi`, () => {
-	const core = new binding.BenchCore();
-	const s = core.registerStateInt(0);
-	for (let i = 0; i < FANOUT_N; i++) {
-		const leaf = core.registerDerived([s], "Identity");
-		core.subscribeNoop(leaf);
-	}
-	let i = 0;
-	bench(`emit at root, ${FANOUT_N} leaves`, () => {
-		core.emitInt(s, ++i);
-	});
-});
-
-describe(`fanout_${FANOUT_N}/ts_only`, () => {
-	const rt = new HandleRuntime();
-	const s = rt.state(0);
-	for (let i = 0; i < FANOUT_N; i++) {
-		const leaf = rt.derived([s], (v: number) => v);
-		rt.subscribe(leaf, () => undefined);
-	}
-	let j = 0;
-	bench(`emit at root, ${FANOUT_N} leaves`, () => {
-		s.set(++j);
-	});
-});
diff --git a/packages/pure-ts/src/__bench__/graphrefly.bench.ts b/packages/pure-ts/src/__bench__/graphrefly.bench.ts
deleted file mode 100644
index 81a07977..00000000
--- a/packages/pure-ts/src/__bench__/graphrefly.bench.ts
+++ /dev/null
@@ -1,756 +0,0 @@
-/**
- * Core benchmarks aligned with callbag-recharge `src/__bench__/compare.bench.ts` shapes.
- * Omitted (not in GraphReFly core yet): producer, operator, pipe / pipeRaw, Inspector.
- *
- * `describe` bodies run at file load (like callbag); do not use `beforeAll` for graph setup —
- * Vitest benchmark mode does not run `beforeAll` before Tinybench.
- */
-import { afterAll, bench, describe } from "vitest";
-import { batch } from "../core/batch.js";
-import { DATA, DIRTY, type Messages } from "../core/messages.js";
-import { type Node, node } from "../core/node.js";
-
-const push = (n: { down: (m: Messages) => void }, v: number) => {
-	n.down([[DIRTY], [DATA, v]]);
-};
-const read = (n: { cache: unknown }) => n.cache;
-
-// ─── Primitives (state analogue) ───────────────────────────
-
-describe("state: read", () => {
-	const s = node<number>([], { initial: 0 });
-	bench("state.cache", () => {
-		read(s);
-	});
-});
-
-describe("state: write (no subscribers)", () => {
-	const s = node<number>([], { initial: 0 });
-	let i = 0;
-	bench("state.set()", () => {
-		push(s, i++);
-	});
-});
-
-describe("state: write (with subscriber)", () => {
-	const s = node<number>([], { initial: 0 });
-	const unsub = s.subscribe(() => undefined);
-	let i = 0;
-	bench("state.set() + subscriber", () => {
-		push(s, i++);
-	});
-	afterAll(() => unsub());
-});
-
-// ─── Derived ───────────────────────────────────────────────
-
-describe("derived: single-dep (P0 fast path)", () => {
-	const a = node<number>([], { initial: 0 });
-	const d = node(
-		[a],
-		(batchData, actions, ctx) => {
-			const data = batchData.map((batch, i) =>
-				batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-			);
-			actions.emit((data[0] as number) * 2);
-		},
-		{ describeKind: "derived" },
-	);
-	const unsub = d.subscribe(() => undefined);
-	let i = 0;
-	bench("set + get", () => {
-		push(a, i++);
-		read(d);
-	});
-	afterAll(() => unsub());
-});
-
-describe("derived: multi-dep", () => {
-	const a = node<number>([], { initial: 0 });
-	const b = node<number>([], { initial: 0 });
-	const d = node(
-		[a, b],
-		(batchData, actions, ctx) => {
-			const data = batchData.map((batch, i) =>
-				batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-			);
-			actions.emit((data[0] as number) + (data[1] as number));
-		},
-		{ describeKind: "derived" },
-	);
-	const unsub = d.subscribe(() => undefined);
-	let i = 0;
-	bench("set one dep + get", () => {
-		push(a, i++);
-		read(d);
-	});
-	afterAll(() => unsub());
-});
-
-describe("derived: cached read (unchanged deps)", () => {
-	const a = node<number>([], { initial: 5 });
-	const d = node(
-		[a],
-		(batchData, actions, ctx) => {
-			const data = batchData.map((batch, i) =>
-				batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-			);
-			actions.emit((data[0] as number) * 2);
-		},
-		{ describeKind: "derived" },
-	);
-	const unsub = d.subscribe(() => undefined);
-	bench("get (cached)", () => {
-		read(d);
-	});
-	afterAll(() => unsub());
-});
-
-// ─── Diamond ───────────────────────────────────────────────
-
-describe("diamond: A → B,C → D", () => {
-	const a = node<number>([], { initial: 0 });
-	const b = node(
-		[a],
-		(batchData, actions, ctx) => {
-			const data = batchData.map((batch, i) =>
-				batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-			);
-			actions.emit((data[0] as number) + 1);
-		},
-		{ describeKind: "derived" },
-	);
-	const c = node(
-		[a],
-		(batchData, actions, ctx) => {
-			const data = batchData.map((batch, i) =>
-				batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-			);
-			actions.emit((data[0] as number) * 2);
-		},
-		{ describeKind: "derived" },
-	);
-	const d = node(
-		[b, c],
-		(batchData, actions, ctx) => {
-			const data = batchData.map((batch, i) =>
-				batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-			);
-			actions.emit((data[0] as number) + (data[1] as number));
-		},
-		{ describeKind: "derived" },
-	);
-	const unsub = d.subscribe(() => undefined);
-	let i = 0;
-	bench("set root + get leaf", () => {
-		push(a, i++);
-		read(d);
-	});
-	afterAll(() => unsub());
-});
-
-describe("diamond: deep (5 levels)", () => {
-	const root = node<number>([], { initial: 0 });
-	const l1a = node(
-		[root],
-		(batchData, actions, ctx) => {
-			const data = batchData.map((batch, i) =>
-				batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-			);
-			actions.emit((data[0] as number) + 1);
-		},
-		{ describeKind: "derived" },
-	);
-	const l1b = node(
-		[root],
-		(batchData, actions, ctx) => {
-			const data = batchData.map((batch, i) =>
-				batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-			);
-			actions.emit((data[0] as number) * 2);
-		},
-		{ describeKind: "derived" },
-	);
-	const l2a = node(
-		[l1a, l1b],
-		(batchData, actions, ctx) => {
-			const data = batchData.map((batch, i) =>
-				batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-			);
-			actions.emit((data[0] as number) + (data[1] as number));
-		},
-		{ describeKind: "derived" },
-	);
-	const l2b = node(
-		[l1a, l1b],
-		(batchData, actions, ctx) => {
-			const data = batchData.map((batch, i) =>
-				batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-			);
-			actions.emit((data[0] as number) * (data[1] as number));
-		},
-		{ describeKind: "derived" },
-	);
-	const leaf = node(
-		[l2a, l2b],
-		(batchData, actions, ctx) => {
-			const data = batchData.map((batch, i) =>
-				batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-			);
-			actions.emit((data[0] as number) + (data[1] as number));
-		},
-		{ describeKind: "derived" },
-	);
-	const unsub = leaf.subscribe(() => undefined);
-	let i = 0;
-	bench("set root + get leaf", () => {
-		push(root, i++);
-		read(leaf);
-	});
-	afterAll(() => unsub());
-});
-
-describe("diamond: wide (10 intermediates)", () => {
-	const root = node<number>([], { initial: 0 });
-	const intermediates = Array.from({ length: 10 }, (_, j) =>
-		node(
-			[root],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as number) + j);
-			},
-			{ describeKind: "derived" },
-		),
-	);
-	const leaf = node(
-		intermediates,
-		(batchData, actions, ctx) => {
-			const data = batchData.map((batch, i) =>
-				batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-			);
-			actions.emit(data.reduce((sum: number, v) => sum + (v as number), 0));
-		},
-		{ describeKind: "derived" },
-	);
-	const unsub = leaf.subscribe(() => undefined);
-	let i = 0;
-	bench("set root + get leaf", () => {
-		push(root, i++);
-		read(leaf);
-	});
-	afterAll(() => unsub());
-});
-
-// ─── Effect (subscriber / derived re-run) ─────────────────
-
-describe("effect: single dep re-run", () => {
-	const trigger = node<number>([], { initial: 0 });
-	const unsub = trigger.subscribe(() => {
-		read(trigger);
-	});
-	let i = 0;
-	bench("state.set() triggers effect", () => {
-		push(trigger, i++);
-	});
-	afterAll(() => unsub());
-});
-
-describe("effect: multi-dep (diamond + effect)", () => {
-	const a = node<number>([], { initial: 0 });
-	const b = node(
-		[a],
-		(batchData, actions, ctx) => {
-			const data = batchData.map((batch, i) =>
-				batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-			);
-			actions.emit((data[0] as number) + 1);
-		},
-		{ describeKind: "derived" },
-	);
-	const c = node(
-		[a],
-		(batchData, actions, ctx) => {
-			const data = batchData.map((batch, i) =>
-				batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-			);
-			actions.emit((data[0] as number) * 2);
-		},
-		{ describeKind: "derived" },
-	);
-	const eff = node(
-		[b, c],
-		(batchData, actions, ctx) => {
-			const data = batchData.map((batch, i) =>
-				batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-			);
-			actions.emit((data[0] as number) + (data[1] as number));
-		},
-		{ describeKind: "derived" },
-	);
-	const unsub = eff.subscribe(() => undefined);
-	let i = 0;
-	bench("set root, effect runs once", () => {
-		push(a, i++);
-	});
-	afterAll(() => unsub());
-});
-
-// ─── Fan-out ───────────────────────────────────────────────
-
-describe("fan-out: 10 subscribers", () => {
-	const src = node<number>([], { initial: 0 });
-	const unsubs = Array.from({ length: 10 }, () => src.subscribe(() => undefined));
-	let i = 0;
-	bench("set with 10 subscribers", () => {
-		push(src, i++);
-	});
-	afterAll(() => {
-		for (const u of unsubs) u();
-	});
-});
-
-describe("fan-out: 100 subscribers", () => {
-	const src = node<number>([], { initial: 0 });
-	const unsubs = Array.from({ length: 100 }, () => src.subscribe(() => undefined));
-	let i = 0;
-	bench("set with 100 subscribers", () => {
-		push(src, i++);
-	});
-	afterAll(() => {
-		for (const u of unsubs) u();
-	});
-});
-
-// B18 — extended fan-out scaling to validate the sink-notification cost trend.
-describe("fan-out: 1000 subscribers", () => {
-	const src = node<number>([], { initial: 0 });
-	const unsubs = Array.from({ length: 1000 }, () => src.subscribe(() => undefined));
-	let i = 0;
-	bench("set with 1000 subscribers", () => {
-		push(src, i++);
-	});
-	afterAll(() => {
-		for (const u of unsubs) u();
-	});
-});
-
-// ─── B7 — passthrough-heavy chains (measure `_emit([msg])` wrapper cost) ─────
-//
-// Fn-less nodes (`node([dep])` without a `fn`) forward DATA/RESOLVED via the
-// passthrough branch at `_onDepMessage`, which calls `this._emit([msg])` per
-// forwarded message — one fresh single-element wrapper allocation per node
-// per message. A 5-level chain runs the path 5× per source write; a 10-level
-// chain runs it 10×. Baseline for the single-message `_emit` overload
-// decision in B7.
-
-describe("passthrough: 5-level fn-less chain", () => {
-	const head = node<number>([], { initial: 0 });
-	let cur: Node<number> = head;
-	for (let j = 0; j < 5; j++) cur = node<number>([cur]);
-	const tail = cur;
-	const unsub = tail.subscribe(() => undefined);
-	let i = 0;
-	bench("set head + propagate through 5 fn-less passthroughs", () => {
-		push(head, i++);
-	});
-	afterAll(() => unsub());
-});
-
-describe("passthrough: 10-level fn-less chain", () => {
-	const head = node<number>([], { initial: 0 });
-	let cur: Node<number> = head;
-	for (let j = 0; j < 10; j++) cur = node<number>([cur]);
-	const tail = cur;
-	const unsub = tail.subscribe(() => undefined);
-	let i = 0;
-	bench("set head + propagate through 10 fn-less passthroughs", () => {
-		push(head, i++);
-	});
-	afterAll(() => unsub());
-});
-
-describe("passthrough: 20-level fn-less chain", () => {
-	const head = node<number>([], { initial: 0 });
-	let cur: Node<number> = head;
-	for (let j = 0; j < 20; j++) cur = node<number>([cur]);
-	const tail = cur;
-	const unsub = tail.subscribe(() => undefined);
-	let i = 0;
-	bench("set head + propagate through 20 fn-less passthroughs", () => {
-		push(head, i++);
-	});
-	afterAll(() => unsub());
-});
-
-// ─── Batching ──────────────────────────────────────────────
-
-describe("batch: 10 sets + derived reader", () => {
-	const items = Array.from({ length: 10 }, (_, k) => node<number>([], { initial: k }));
-	const agg = node(
-		items,
-		(batchData, actions, ctx) => {
-			const data = batchData.map((batch, i) =>
-				batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-			);
-			actions.emit(data.reduce((s, v) => (s as number) + (v as number), 0));
-		},
-		{ describeKind: "derived" },
-	);
-	const unsub = agg.subscribe(() => undefined);
-	let k = 0;
-	let k2 = 0;
-	bench("unbatched (10 sets)", () => {
-		for (const s of items) push(s, k++);
-	});
-	bench("batched (10 sets)", () => {
-		batch(() => {
-			for (const s of items) push(s, k2++);
-		});
-	});
-	afterAll(() => unsub());
-});
-
-// ─── Equals (push-phase memoization) ───────────────────────
-
-describe("equals: diamond with memoization", () => {
-	const a1 = node<number>([], { initial: 0 });
-	const b1 = node(
-		[a1],
-		(batchData, actions, ctx) => {
-			const data = batchData.map((batch, i) =>
-				batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-			);
-			actions.emit((data[0] as number) >= 5 ? 1 : 0);
-		},
-		{ describeKind: "derived" },
-	);
-	const c1 = node(
-		[a1],
-		(batchData, actions, ctx) => {
-			const data = batchData.map((batch, i) =>
-				batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-			);
-			actions.emit((data[0] as number) * 2);
-		},
-		{ describeKind: "derived" },
-	);
-	const e1 = node(
-		[b1, c1],
-		(batchData, actions, ctx) => {
-			const data = batchData.map((batch, i) =>
-				batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-			);
-			actions.emit((data[0] as number) + (data[1] as number));
-		},
-		{ describeKind: "derived" },
-	);
-	const u1 = e1.subscribe(() => undefined);
-	let k1 = 0;
-
-	const a2 = node<number>([], { initial: 0 });
-	const b2 = node(
-		[a2],
-		(batchData, actions, ctx) => {
-			const data = batchData.map((batch, i) =>
-				batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-			);
-			actions.emit((data[0] as number) >= 5 ? 1 : 0);
-		},
-		{ describeKind: "derived", equals: (x, y) => x === y },
-	);
-	const c2 = node(
-		[a2],
-		(batchData, actions, ctx) => {
-			const data = batchData.map((batch, i) =>
-				batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-			);
-			actions.emit((data[0] as number) * 2);
-		},
-		{ describeKind: "derived" },
-	);
-	const e2 = node(
-		[b2, c2],
-		(batchData, actions, ctx) => {
-			const data = batchData.map((batch, i) =>
-				batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-			);
-			actions.emit((data[0] as number) + (data[1] as number));
-		},
-		{ describeKind: "derived" },
-	);
-	const u2 = e2.subscribe(() => undefined);
-	let k2 = 0;
-
-	bench("without equals", () => {
-		push(a1, k1++);
-	});
-	bench("with equals (subtree skip)", () => {
-		push(a2, k2++);
-	});
-	afterAll(() => {
-		u1();
-		u2();
-	});
-});
-
-// ─── GraphReFly protocol extras (not in callbag compare) ───
-
-describe("graphrefly: linear 10-node chain", () => {
-	const head = node<number>([], { initial: 0 });
-	let cur: Node<number> = head;
-	for (let j = 0; j < 9; j++) {
-		const prev = cur;
-		cur = node(
-			[prev],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as number) + 1);
-			},
-			{ describeKind: "derived" },
-		);
-	}
-	const tail = cur;
-	const unsub = tail.subscribe(() => undefined);
-	let i = 0;
-	bench("linear 10-node chain: DIRTY+DATA", () => {
-		push(head, i++);
-	});
-	afterAll(() => unsub());
-});
-
-describe("graphrefly: fan-in batch", () => {
-	const x = node<number>([], { initial: 0 });
-	const y = node<number>([], { initial: 0 });
-	const sum = node(
-		[x, y],
-		(batchData, actions, ctx) => {
-			const data = batchData.map((batch, i) =>
-				batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-			);
-			actions.emit((data[0] as number) + (data[1] as number));
-		},
-		{ describeKind: "derived" },
-	);
-	const unsub = sum.subscribe(() => undefined);
-	let i = 0;
-	bench("fan-in: batched DIRTY+DATA on two sources", () => {
-		const n = i++;
-		batch(() => {
-			push(x, n);
-			push(y, n + 1);
-		});
-	});
-	afterAll(() => unsub());
-});
-
-// ─── Equals subtree skip — workload-driven bench variants (B3) ─────────────
-
-/**
- * The 2026-04-11 baseline's `equals: with (subtree skip)` bench showed ~1% win
- * because the source value incremented monotonically every iteration and
- * `equals` (default `Object.is`) was never seeing the same value twice.
- *
- * These variants drive two orthogonal levers to expose the real subtree-skip
- * benefit:
- *
- * 1. **Inputs actually repeat** — `push(a, k % 2)` toggles the source
- *    between 0 and 1, so every other write is a no-op that the first-level
- *    equals substitution absorbs into RESOLVED.
- *
- * 2. **`equals: () => false` as the "unmemoized" baseline** — NOT just
- *    omitting `equals`. Omitting equals uses default `Object.is`, which
- *    *already* does subtree-skip on same-value writes; that was the
- *    original bench's bug. `alwaysDiffer` forces every DATA to propagate
- *    regardless, simulating a naive reactive system with no memoization.
- *
- * 3. **Heavier fn body** — a trivial `(v) => v + 1` body is too cheap for
- *    the saved fn-run to outweigh the equals comparison cost. We use a
- *    small fixed-work loop inside fn so the fn-skip actually dominates.
- */
-
-const alwaysDiffer = () => false;
-
-// Synthetic "non-trivial fn" — adds a small fixed cost so that skipping
-// the fn actually dominates the wire framing overhead.
-function heavyTransform(v: number): number {
-	let acc = v;
-	for (let i = 0; i < 50; i++) acc = (acc * 31 + 7) >>> 0;
-	return acc >>> 0;
-}
-
-// Pattern generator: produces `[0, 0, 1, 1, 0, 0, 1, 1, ...]` — every
-// other write is a true duplicate of the previous, so equals substitution
-// has something to collapse. A simple `k % 2` toggle produces NO duplicates
-// (every write alternates 0/1), which is why the 2026-04-13 first attempt
-// still measured no difference. Half the writes are genuine no-ops here.
-const noopPattern = (k: number): number => Math.floor(k / 2) % 2;
-
-describe("equals: 5-level linear chain, 50% no-op writes (heavy fn)", () => {
-	// Baseline: source + all levels use `alwaysDiffer`. Every source write
-	// fully propagates through the chain — the source never collapses
-	// duplicates, downstream levels never pre-fn skip. Represents a naive
-	// reactive system with no memoization anywhere.
-	const a1 = node<number>([], { initial: 0, equals: alwaysDiffer });
-	let cur1: Node<number> = node(
-		[a1],
-		(batchData, actions, ctx) => {
-			const data = batchData.map((batch, i) =>
-				batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-			);
-			actions.emit(heavyTransform(data[0] as number));
-		},
-		{ describeKind: "derived", equals: alwaysDiffer },
-	);
-	for (let j = 0; j < 4; j++) {
-		const prev = cur1;
-		cur1 = node(
-			[prev],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit(heavyTransform(data[0] as number));
-			},
-			{ describeKind: "derived", equals: alwaysDiffer },
-		);
-	}
-	const tail1 = cur1;
-	const u1 = tail1.subscribe(() => undefined);
-	let k1 = 0;
-
-	// Optimized: default `equals` (Object.is) everywhere. Source collapses
-	// duplicate writes to RESOLVED via §3.5.1 substitution, downstream
-	// levels pre-fn skip (`!_waveHasNewData`) so the leaf fn only runs on
-	// actual transitions (half the time for the noop pattern).
-	const a2 = node<number>([], { initial: 0 });
-	let cur2: Node<number> = node(
-		[a2],
-		(batchData, actions, ctx) => {
-			const data = batchData.map((batch, i) =>
-				batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-			);
-			actions.emit(heavyTransform(data[0] as number));
-		},
-		{ describeKind: "derived" },
-	);
-	for (let j = 0; j < 4; j++) {
-		const prev = cur2;
-		cur2 = node(
-			[prev],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit(heavyTransform(data[0] as number));
-			},
-			{ describeKind: "derived" },
-		);
-	}
-	const tail2 = cur2;
-	const u2 = tail2.subscribe(() => undefined);
-	let k2 = 0;
-
-	bench("baseline (alwaysDiffer — no subtree skip)", () => {
-		push(a1, noopPattern(k1));
-		k1++;
-	});
-	bench("with equals subtree skip (default Object.is)", () => {
-		push(a2, noopPattern(k2));
-		k2++;
-	});
-	afterAll(() => {
-		u1();
-		u2();
-	});
-});
-
-describe("equals: diamond with 50% no-op inputs (heavy fn)", () => {
-	// Diamond: both legs share the same source. When the source value
-	// doesn't change, both legs emit RESOLVED at the first node and the
-	// join's pre-fn skip fires. Baseline uses `alwaysDiffer` on every
-	// node including the source so nothing collapses.
-	const src1 = node<number>([], { initial: 0, equals: alwaysDiffer });
-	const l1 = node(
-		[src1],
-		(batchData, actions, ctx) => {
-			const data = batchData.map((batch, i) =>
-				batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-			);
-			actions.emit(heavyTransform(data[0] as number));
-		},
-		{ describeKind: "derived", equals: alwaysDiffer },
-	);
-	const r1 = node(
-		[src1],
-		(batchData, actions, ctx) => {
-			const data = batchData.map((batch, i) =>
-				batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-			);
-			actions.emit(heavyTransform(data[0] as number) + 1);
-		},
-		{ describeKind: "derived", equals: alwaysDiffer },
-	);
-	const j1 = node(
-		[l1, r1],
-		(batchData, actions, ctx) => {
-			const data = batchData.map((batch, i) =>
-				batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-			);
-			actions.emit(heavyTransform((data[0] as number) + (data[1] as number)));
-		},
-		{ describeKind: "derived", equals: alwaysDiffer },
-	);
-	const u1 = j1.subscribe(() => undefined);
-	let k1 = 0;
-
-	const src2 = node<number>([], { initial: 0 });
-	const l2 = node(
-		[src2],
-		(batchData, actions, ctx) => {
-			const data = batchData.map((batch, i) =>
-				batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-			);
-			actions.emit(heavyTransform(data[0] as number));
-		},
-		{ describeKind: "derived" },
-	);
-	const r2 = node(
-		[src2],
-		(batchData, actions, ctx) => {
-			const data = batchData.map((batch, i) =>
-				batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-			);
-			actions.emit(heavyTransform(data[0] as number) + 1);
-		},
-		{ describeKind: "derived" },
-	);
-	const j2 = node(
-		[l2, r2],
-		(batchData, actions, ctx) => {
-			const data = batchData.map((batch, i) =>
-				batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-			);
-			actions.emit(heavyTransform((data[0] as number) + (data[1] as number)));
-		},
-		{ describeKind: "derived" },
-	);
-	const u2 = j2.subscribe(() => undefined);
-	let k2 = 0;
-
-	bench("baseline (alwaysDiffer — no diamond skip)", () => {
-		push(src1, noopPattern(k1));
-		k1++;
-	});
-	bench("with equals subtree skip (default Object.is)", () => {
-		push(src2, noopPattern(k2));
-		k2++;
-	});
-	afterAll(() => {
-		u1();
-		u2();
-	});
-});
diff --git a/packages/pure-ts/src/__bench__/handle-core.bench.ts b/packages/pure-ts/src/__bench__/handle-core.bench.ts
deleted file mode 100644
index 2c00f069..00000000
--- a/packages/pure-ts/src/__bench__/handle-core.bench.ts
+++ /dev/null
@@ -1,108 +0,0 @@
-/**
- * Handle-core TS prototype benchmarks — pairs with
- * `~/src/graphrefly-rs/crates/graphrefly-core/benches/dispatcher.rs` for
- * the Phase 13.7 Rust-vs-TS comparison.
- *
- * Same workload patterns, same scenario names. Run both with:
- *   cd ~/src/graphrefly-rs && cargo bench -p graphrefly-core --bench dispatcher
- *   pnpm vitest bench src/__bench__/handle-core.bench.ts
- *
- * Side-by-side numbers answer "is the Rust dispatcher fundamentally faster?"
- * (FFI overhead measured separately in a follow-up.)
- */
-
-import { bench, describe } from "vitest";
-import { HandleRuntime } from "../__experiments__/handle-core/bindings.js";
-
-// ---------------------------------------------------------------------------
-// state_emit_identity_dedup — emit same value repeatedly; identity equals
-// substitutes to RESOLVED on the wire (zero-FFI hot path in handle protocol).
-// ---------------------------------------------------------------------------
-describe("state_emit_identity_dedup", () => {
-	const rt = new HandleRuntime();
-	const s = rt.state(1);
-	rt.subscribe(s, () => undefined);
-	bench("emit_same_handle", () => {
-		s.set(1); // same primitive value → same handle (interned)
-	});
-});
-
-// ---------------------------------------------------------------------------
-// state_emit_changing_value — fresh value each time; full DATA dispatch.
-// ---------------------------------------------------------------------------
-describe("state_emit_changing_value", () => {
-	const rt = new HandleRuntime();
-	const s = rt.state(0);
-	rt.subscribe(s, () => undefined);
-	let i = 0;
-	bench("emit_fresh_handle_each", () => {
-		s.set(++i); // fresh primitive → fresh handle
-	});
-});
-
-// ---------------------------------------------------------------------------
-// chain_propagation/N — N-deep derived chain; one update at root → wave
-// propagates through all N nodes' fns.
-// ---------------------------------------------------------------------------
-function buildChain(rt: HandleRuntime, length: number) {
-	const s = rt.state(0);
-	let prev: { _id: unknown; current: () => unknown } = s as unknown as {
-		_id: unknown;
-		current: () => unknown;
-	};
-	for (let i = 0; i < length; i++) {
-		// Each derived passes through with no transformation — measures pure
-		// dispatch cost, not user-fn cost.
-		prev = rt.derived([prev as any], (v: unknown) => v as number);
-	}
-	rt.subscribe(prev as never, () => undefined);
-	return s;
-}
-
-for (const N of [1, 4, 16, 64]) {
-	describe(`chain_propagation/${N}`, () => {
-		const rt = new HandleRuntime();
-		const s = buildChain(rt, N);
-		let i = 0;
-		bench(`chain_${N}`, () => {
-			s.set(++i);
-		});
-	});
-}
-
-// ---------------------------------------------------------------------------
-// diamond_fanout/N — s → {d1..dN} → sink; sink has all dN as deps.
-// One update at s should fire sink ONCE despite N inner derived.
-// ---------------------------------------------------------------------------
-for (const N of [2, 8, 32]) {
-	describe(`diamond_fanout/${N}`, () => {
-		const rt = new HandleRuntime();
-		const s = rt.state(0);
-		const inner = Array.from({ length: N }, () => rt.derived([s], (v: number) => v));
-		const sink = rt.derived(inner as any, (...vs: number[]) => vs.reduce((a, b) => a + b, 0));
-		rt.subscribe(sink, () => undefined);
-		let i = 0;
-		bench(`diamond_${N}`, () => {
-			s.set(++i);
-		});
-	});
-}
-
-// ---------------------------------------------------------------------------
-// large_fanout/N — s → {leaf1..leafN}, no further reduction.
-// Pure dispatch / propagation cost; each leaf re-runs its (trivial) fn.
-// ---------------------------------------------------------------------------
-for (const N of [10, 100, 1000]) {
-	describe(`large_fanout/${N}`, () => {
-		const rt = new HandleRuntime();
-		const s = rt.state(0);
-		for (let i = 0; i < N; i++) {
-			const leaf = rt.derived([s], (v: number) => v);
-			rt.subscribe(leaf, () => undefined);
-		}
-		let j = 0;
-		bench(`fanout_${N}`, () => {
-			s.set(++j);
-		});
-	});
-}
diff --git a/packages/pure-ts/src/__bench__/memory.bench.local.ts b/packages/pure-ts/src/__bench__/memory.bench.local.ts
deleted file mode 100644
index 59d0c785..00000000
--- a/packages/pure-ts/src/__bench__/memory.bench.local.ts
+++ /dev/null
@@ -1,205 +0,0 @@
-/**
- * Memory bench — the third axis the user asked about ("performance / memory /
- * correctness"). Phase 13.7 follow-up to `rust-bench-v0-results.md`.
- *
- * Methodology:
- *   1. Build a large graph (state + N derived passthrough chain).
- *   2. Force GC if available; record `process.memoryUsage()`.
- *   3. Emit M times.
- *   4. Force GC again; record memoryUsage.
- *   5. Compare TS-only vs Rust-via-FFI: which holds less retained heap, which
- *      has lower peak heap during emission?
- *
- * Run with --expose-gc for honest GC-controlled numbers:
- *   pnpm tsx --expose-gc src/__bench__/memory.bench.ts
- *
- * Without --expose-gc the bench still runs but `gc()` calls are no-ops; peaks
- * are measured at whatever moment we sample. Rust-side state is OUTSIDE the
- * V8 heap, so the JS heap-usage delta IS the cleanest "GC pressure" signal.
- */
-
-import { createRequire } from "node:module";
-
-const require = createRequire(import.meta.url);
-const binding: any = require("/Users/davidchenallio/src/graphrefly-rs/target/release/graphrefly_bindings_js.node");
-
-const GRAPH_SIZE = 1000; // 1000-node chain — large enough that Rust state is non-trivial
-const EMITS = 1_000_000;
-
-interface MemSnapshot {
-	rss: number;
-	heapTotal: number;
-	heapUsed: number;
-	external: number;
-	arrayBuffers: number;
-}
-
-function snapshot(): MemSnapshot {
-	const m = process.memoryUsage();
-	return {
-		rss: m.rss,
-		heapTotal: m.heapTotal,
-		heapUsed: m.heapUsed,
-		external: m.external,
-		arrayBuffers: m.arrayBuffers,
-	};
-}
-
-function gcIfAvailable() {
-	if (typeof globalThis.gc === "function") {
-		globalThis.gc();
-	}
-}
-
-function fmt(bytes: number): string {
-	const mb = bytes / 1024 / 1024;
-	return mb >= 1 ? `${mb.toFixed(2)} MiB` : `${(bytes / 1024).toFixed(1)} KiB`;
-}
-
-function delta(before: MemSnapshot, after: MemSnapshot, key: keyof MemSnapshot): string {
-	const d = after[key] - before[key];
-	const sign = d >= 0 ? "+" : "";
-	return `${sign}${fmt(d)}`;
-}
-
-console.log("=".repeat(70));
-console.log(`Memory bench — graph size ${GRAPH_SIZE}, ${EMITS.toLocaleString()} emits`);
-const gcReady = typeof globalThis.gc === "function";
-console.log(
-	`  GC control: ${gcReady ? "enabled (--expose-gc)" : "DISABLED — run with --expose-gc for clean numbers"}`,
-);
-console.log("=".repeat(70));
-
-// ---------------------------------------------------------------------------
-// 1. TS-only baseline
-// ---------------------------------------------------------------------------
-async function tsOnlyBench() {
-	const { HandleRuntime } = await import("/tmp/handle-core-compiled/bindings.js");
-	gcIfAvailable();
-	const before = snapshot();
-
-	const rt = new HandleRuntime();
-	const s = rt.state(0);
-	let prev: { _id: unknown; current: () => unknown } = s as unknown as {
-		_id: unknown;
-		current: () => unknown;
-	};
-	for (let i = 0; i < GRAPH_SIZE; i++) {
-		prev = rt.derived([prev as any], (v: unknown) => v as number);
-	}
-	rt.subscribe(prev as never, () => undefined);
-
-	const afterBuild = snapshot();
-	const t0 = process.hrtime.bigint();
-	for (let i = 0; i < EMITS; i++) {
-		s.set(i);
-	}
-	const elapsedMs = Number(process.hrtime.bigint() - t0) / 1e6;
-	const peak = snapshot();
-
-	gcIfAvailable();
-	const afterGc = snapshot();
-
-	console.log(`\n[TS-only] ${GRAPH_SIZE}-node chain + ${EMITS.toLocaleString()} emits`);
-	console.log(
-		`  graph build:    heapUsed ${delta(before, afterBuild, "heapUsed")}, rss ${delta(before, afterBuild, "rss")}`,
-	);
-	console.log(
-		`  during emits:   heapUsed ${delta(afterBuild, peak, "heapUsed")} (peak), rss ${delta(afterBuild, peak, "rss")} (peak)`,
-	);
-	console.log(
-		`  after gc:       heapUsed ${delta(afterBuild, afterGc, "heapUsed")} (retained), rss ${delta(afterBuild, afterGc, "rss")}`,
-	);
-	console.log(`  elapsed:        ${elapsedMs.toFixed(1)}ms`);
-	console.log(
-		`  TOTAL rss growth: ${delta(before, afterGc, "rss")} (V8 heap dominates here — pure JS)`,
-	);
-	return {
-		elapsedMs,
-		peakHeap: peak.heapUsed - afterBuild.heapUsed,
-		peakRss: peak.rss - afterBuild.rss,
-		totalRss: afterGc.rss - before.rss,
-	};
-}
-
-// ---------------------------------------------------------------------------
-// 2. Rust core via FFI
-// ---------------------------------------------------------------------------
-function rustViaFfiBench() {
-	gcIfAvailable();
-	const before = snapshot();
-
-	const core = new binding.BenchCore();
-	const s = core.registerStateInt(0);
-	let prev = s;
-	for (let i = 0; i < GRAPH_SIZE; i++) {
-		prev = core.registerDerived([prev], "Identity");
-	}
-	core.subscribeNoop(prev);
-
-	const afterBuild = snapshot();
-	const t0 = process.hrtime.bigint();
-	for (let i = 0; i < EMITS; i++) {
-		core.emitInt(s, i);
-	}
-	const elapsedMs = Number(process.hrtime.bigint() - t0) / 1e6;
-	const peak = snapshot();
-
-	gcIfAvailable();
-	const afterGc = snapshot();
-
-	console.log(`\n[Rust via FFI] ${GRAPH_SIZE}-node chain + ${EMITS.toLocaleString()} emits`);
-	console.log(
-		`  graph build:    heapUsed ${delta(before, afterBuild, "heapUsed")}, rss ${delta(before, afterBuild, "rss")}`,
-	);
-	console.log(
-		`  during emits:   heapUsed ${delta(afterBuild, peak, "heapUsed")} (peak), rss ${delta(afterBuild, peak, "rss")} (peak)`,
-	);
-	console.log(
-		`  after gc:       heapUsed ${delta(afterBuild, afterGc, "heapUsed")} (retained), rss ${delta(afterBuild, afterGc, "rss")}`,
-	);
-	console.log(`  elapsed:        ${elapsedMs.toFixed(1)}ms`);
-	console.log(`  TOTAL rss growth: ${delta(before, afterGc, "rss")} (this IS Rust+JS combined)`);
-	return {
-		elapsedMs,
-		peakHeap: peak.heapUsed - afterBuild.heapUsed,
-		peakRss: peak.rss - afterBuild.rss,
-		totalRss: afterGc.rss - before.rss,
-	};
-}
-
-(async () => {
-	const ts = await tsOnlyBench();
-	const rust = rustViaFfiBench();
-
-	console.log(`\n${"=".repeat(70)}`);
-	console.log("Comparison");
-	console.log("=".repeat(70));
-	console.log(`  Peak JS heap during emits (V8 only):`);
-	console.log(`    TS-only:      ${fmt(ts.peakHeap)}`);
-	console.log(`    Rust via FFI: ${fmt(rust.peakHeap)}`);
-	const heapRatio = ts.peakHeap / Math.max(rust.peakHeap, 1);
-	console.log(`    Ratio:        TS uses ${heapRatio.toFixed(1)}× more JS heap during emit loop`);
-	console.log("");
-	console.log("  Peak RSS during emits (TOTAL process memory — JS + Rust + everything):");
-	console.log(`    TS-only:      ${fmt(ts.peakRss)}`);
-	console.log(`    Rust via FFI: ${fmt(rust.peakRss)}`);
-	const rssRatio = ts.peakRss / Math.max(rust.peakRss, 1);
-	console.log(`    Ratio:        TS uses ${rssRatio.toFixed(1)}× more TOTAL memory at peak`);
-	console.log("");
-	console.log("  Total RSS growth (post-GC; what the process holds long-term):");
-	console.log(`    TS-only:      ${fmt(ts.totalRss)}`);
-	console.log(`    Rust via FFI: ${fmt(rust.totalRss)}`);
-	if (ts.totalRss > 0 && rust.totalRss > 0) {
-		console.log(
-			`    Ratio:        TS holds ${(ts.totalRss / rust.totalRss).toFixed(1)}× more total memory after GC`,
-		);
-	}
-	console.log("");
-	console.log(`  Throughput:`);
-	console.log(`    TS-only:      ${(EMITS / (ts.elapsedMs / 1000)).toFixed(0)} emits/sec`);
-	console.log(`    Rust via FFI: ${(EMITS / (rust.elapsedMs / 1000)).toFixed(0)} emits/sec`);
-	console.log(
-		`    Ratio:        Rust ${(ts.elapsedMs / rust.elapsedMs).toFixed(2)}× faster end-to-end`,
-	);
-})();
diff --git a/packages/pure-ts/src/__bench__/operators-via-tsfn.bench.local.ts b/packages/pure-ts/src/__bench__/operators-via-tsfn.bench.local.ts
deleted file mode 100644
index f622bd9a..00000000
--- a/packages/pure-ts/src/__bench__/operators-via-tsfn.bench.local.ts
+++ /dev/null
@@ -1,108 +0,0 @@
-/**
- * Phase D bench harness — operators-via-TSFN throughput.
- *
- * Three-bench shape per D049 (~/src/graphrefly-rs/docs/porting-deferred.md
- * "Phase D — three-bench shape (D049) deferred"):
- *
- *   (1) bench_builtin_fn      — pure FFI baseline. core.registerDerived([s], "Identity").
- *                                No TSFN, no JS callback. Rust dispatcher resolves
- *                                Identity in pure Rust.
- *   (2) bench_tsfn_identity   — TSFN scheduling overhead. operators.registerMap(s, h => h).
- *                                JS callback fires per emit but does no work; returns
- *                                input handle unchanged.
- *   (3) bench_tsfn_addone_js  — End-to-end Rust-via-TSFN-into-JS. JS callback does
- *                                work + 2× sync FFI (deref_int + intern_int).
- *
- * Subtraction interpretation:
- *   (2) − (1) = per-emit TSFN scheduling cost (libuv hop + JS cb invocation).
- *   (3) − (2) = JS-side compute + 2 sync FFI calls (deref_int + intern_int).
- *   (3)       = headline "operator with JS callback" throughput.
- *
- * **Important — `await` semantics.** All three benches `await` `emit_int` so the
- * measurement covers full end-to-end wave drain (libuv hop → tokio
- * spawn_blocking → wave_owner acquire → wave engine → TSFN trip if applicable →
- * wave drain → libuv pump → Promise resolve). The legacy
- * [ffi-cost.bench.ts](./ffi-cost.bench.ts) fires-and-forgets `emit_int` —
- * pre-D070 era when emit was sync. For Phase D the await is correct because
- * the headline metric is per-emit end-to-end cost.
- *
- * **Setup uses top-level await, not `beforeAll`.** Per the convention noted in
- * [graphrefly.bench.ts](./graphrefly.bench.ts:5): vitest benchmark mode does
- * NOT run `beforeAll` before Tinybench. All setup happens at file load (top-
- * level await is supported in Node ESM); each bench fn closes over the
- * resolved fixtures.
- *
- * **TSFN wire signature (resolved in Slice Y).** The napi binding now
- * uses `callee_handled::<false>()` so JS receives `(value)` directly,
- * matching the typed `Function<u32, u32>` declaration. JS callbacks
- * here take `(h: number) => number` natively — no err-first defensive
- * picker needed.
- *
- * Run:
- *   pnpm --filter @graphrefly/pure-ts bench src/__bench__/operators-via-tsfn.bench.ts
- *
- * Prerequisite: build the napi binding first (with `operators` feature).
- *   cd ~/src/graphrefly-rs && cargo build -p graphrefly-bindings-js --release --features standard
- *   cp ~/src/graphrefly-rs/target/release/libgraphrefly_bindings_js.dylib \
- *      ~/src/graphrefly-rs/target/release/graphrefly_bindings_js.node
- */
-
-import { createRequire } from "node:module";
-import { bench, describe } from "vitest";
-
-const require = createRequire(import.meta.url);
-const binding: any = require("/Users/davidchenallio/src/graphrefly-rs/target/release/graphrefly_bindings_js.node");
-
-// ---------------------------------------------------------------------------
-// (1) Pure-FFI baseline — no TSFN, no JS callback.
-// ---------------------------------------------------------------------------
-const core1 = new binding.BenchCore();
-const s1: number = await core1.registerStateInt(0);
-const mapped1: number = await core1.registerDerived([s1], "Identity");
-await core1.subscribeNoop(mapped1);
-let i1 = 0;
-
-// ---------------------------------------------------------------------------
-// (2) TSFN identity — JS callback fires per emit, does no JS work.
-// ---------------------------------------------------------------------------
-const core2 = new binding.BenchCore();
-const operators2 = binding.BenchOperators.fromCore(core2);
-const s2: number = await core2.registerStateInt(0);
-const mapped2: number = await operators2.registerMap(s2, (h: number) => h);
-await core2.subscribeNoop(mapped2);
-let i2 = 0;
-
-// ---------------------------------------------------------------------------
-// (3) TSFN add-one — JS callback does work + 2× sync FFI.
-// ---------------------------------------------------------------------------
-const core3 = new binding.BenchCore();
-const operators3 = binding.BenchOperators.fromCore(core3);
-const s3: number = await core3.registerStateInt(0);
-const mapped3: number = await operators3.registerMap(s3, (h: number) => {
-	const v = core3.derefInt(h);
-	return core3.internInt(v + 1);
-});
-await core3.subscribeNoop(mapped3);
-let i3 = 0;
-
-// ---------------------------------------------------------------------------
-// Benches
-// ---------------------------------------------------------------------------
-
-describe("operators_via_tsfn/builtin_fn", () => {
-	bench("emit_int — chain depth 1, builtin Identity", async () => {
-		await core1.emitInt(s1, ++i1);
-	});
-});
-
-describe("operators_via_tsfn/tsfn_identity", () => {
-	bench("emit_int — JS callback (h) => h", async () => {
-		await core2.emitInt(s2, ++i2);
-	});
-});
-
-describe("operators_via_tsfn/tsfn_addone_js", () => {
-	bench("emit_int — JS callback (h) => intern(deref(h)+1)", async () => {
-		await core3.emitInt(s3, ++i3);
-	});
-});
diff --git a/packages/pure-ts/src/__bench__/r8-dispatch-overhead.bench.ts b/packages/pure-ts/src/__bench__/r8-dispatch-overhead.bench.ts
deleted file mode 100644
index 5219af58..00000000
--- a/packages/pure-ts/src/__bench__/r8-dispatch-overhead.bench.ts
+++ /dev/null
@@ -1,121 +0,0 @@
-/**
- * R8 unified handle-table model — dispatch-overhead microbench.
- *
- * Validates the core R8 claim: a LocalSync pool's invoke is "O(1) pointer
- * indirection inside the same wave tick (no microtask, no Promise alloc) —
- * externally indistinguishable from direct fn call."
- *
- * R6 target #1: LocalSync indirection overhead vs direct fn call must be < 50ns
- * per call. If the gap is larger, the uniform handle-table model loses its
- * "no perf penalty for inline fns" claim.
- *
- * Workloads:
- *   - direct: literal fn() call in a tight loop (baseline)
- *   - via_map: Map<HandleId, Fn> lookup then call
- *   - via_array: Fn[] indexed lookup then call (the Rust `Vec<Box<dyn Fn>>`
- *     analogue, which is what a real dispatcher would use)
- *   - via_closure_table: object property dispatch (alternative impl shape)
- *   - via_async_resolved: Promise.resolve wrap (LocalAsync pool simulation)
- *
- * The four sync variants should be within tens of nanoseconds of each other.
- * The async variant should be measurably slower (microtask hop).
- */
-
-import { bench, describe } from "vitest";
-
-const ITERS = 1000;
-
-// ---------------------------------------------------------------------------
-// Direct fn call — the baseline. No indirection.
-// ---------------------------------------------------------------------------
-describe("dispatch_overhead/direct", () => {
-	const fn = (x: number): number => x + 1;
-	bench("direct_call_x1000", () => {
-		let acc = 0;
-		for (let i = 0; i < ITERS; i++) {
-			acc = fn(acc);
-		}
-		if (acc < 0) throw new Error("unreachable");
-	});
-});
-
-// ---------------------------------------------------------------------------
-// Via Map<HandleId, Fn> — naive handle-table impl. JS Map is hash-based.
-// ---------------------------------------------------------------------------
-describe("dispatch_overhead/via_map", () => {
-	const table = new Map<number, (x: number) => number>();
-	table.set(1, (x) => x + 1);
-	bench("map_lookup_call_x1000", () => {
-		let acc = 0;
-		for (let i = 0; i < ITERS; i++) {
-			const f = table.get(1);
-			if (f !== undefined) acc = f(acc);
-		}
-		if (acc < 0) throw new Error("unreachable");
-	});
-});
-
-// ---------------------------------------------------------------------------
-// Via Fn[] — Vec<Box<dyn Fn>> analogue. The shape a real Rust dispatcher
-// would use. Indexed lookup is ~1 cycle in Rust, JS arrays should be close.
-// ---------------------------------------------------------------------------
-describe("dispatch_overhead/via_array", () => {
-	const table: Array<(x: number) => number> = [];
-	const handle = table.length;
-	table.push((x) => x + 1);
-	bench("array_index_call_x1000", () => {
-		let acc = 0;
-		for (let i = 0; i < ITERS; i++) {
-			acc = table[handle](acc);
-		}
-		if (acc < 0) throw new Error("unreachable");
-	});
-});
-
-// ---------------------------------------------------------------------------
-// Via object property — an alternative dispatch-table shape. Lets V8 inline
-// the call site via hidden classes if the shape is stable.
-// ---------------------------------------------------------------------------
-describe("dispatch_overhead/via_object", () => {
-	const dispatcher = { fn1: (x: number) => x + 1 };
-	bench("object_prop_call_x1000", () => {
-		let acc = 0;
-		for (let i = 0; i < ITERS; i++) {
-			acc = dispatcher.fn1(acc);
-		}
-		if (acc < 0) throw new Error("unreachable");
-	});
-});
-
-// ---------------------------------------------------------------------------
-// Via async wrap — Promise.resolve().then(). Simulates a LocalAsync pool
-// where work is local but the protocol is async. Should be MUCH slower than
-// the sync variants — quantifying that gap is the point.
-// ---------------------------------------------------------------------------
-describe("dispatch_overhead/via_async_resolved", () => {
-	const fn = (x: number): number => x + 1;
-	bench("async_resolve_call_x1000", async () => {
-		let acc = 0;
-		for (let i = 0; i < ITERS; i++) {
-			acc = await Promise.resolve(fn(acc));
-		}
-		if (acc < 0) throw new Error("unreachable");
-	});
-});
-
-// ---------------------------------------------------------------------------
-// Via queueMicrotask — the cheapest async hop. Quantifies the microtask
-// floor cost.
-// ---------------------------------------------------------------------------
-describe("dispatch_overhead/via_microtask", () => {
-	const fn = (x: number): number => x + 1;
-	bench("microtask_call_x1000", async () => {
-		let acc = 0;
-		for (let i = 0; i < ITERS; i++) {
-			acc = await new Promise<number>((resolve) => {
-				queueMicrotask(() => resolve(fn(acc)));
-			});
-		}
-		if (acc < 0) throw new Error("unreachable");
-	});
-});
diff --git a/packages/pure-ts/src/__bench__/r8-poc.bench.ts b/packages/pure-ts/src/__bench__/r8-poc.bench.ts
deleted file mode 100644
index ed1f8264..00000000
--- a/packages/pure-ts/src/__bench__/r8-poc.bench.ts
+++ /dev/null
@@ -1,238 +0,0 @@
-/**
- * R8 PoC end-to-end bench — apples-to-apples comparison of fn-on-node
- * (baseline) vs fn-in-dispatcher-pool (R8) using the SAME protocol code.
- *
- * Workloads mirror `graphrefly.bench.ts` hot paths:
- *   - state.set() with subscriber
- *   - derived: single-dep, multi-dep
- *   - diamond: A → B,C → D
- *   - fan-out: 10 / 100 / 1000 subscribers
- *   - chain: 10-deep linear
- *
- * What this bench answers:
- *   Does moving `fn` from a Node member field into an external dispatcher
- *   pool measurably regress per-wave perf on real graph shapes?
- *
- * R6 target #2 (refined under R8): R8 within 1.5× of baseline on every
- * workload. Microbench (r8-dispatch-overhead.bench.ts) already showed
- * single-call indirection is ~0 ns; this bench confirms the end-to-end
- * graph protocol does not amplify it.
- */
-
-import { afterAll, bench, describe } from "vitest";
-import { baselineNode } from "../__experiments__/r8-poc/baseline.js";
-import type { Actions, Ctx, TinyNode } from "../__experiments__/r8-poc/protocol.js";
-import { r8Node } from "../__experiments__/r8-poc/r8.js";
-
-type Make = typeof baselineNode | typeof r8Node;
-
-// Helper to extract "fresh DATA this wave, else prev" — same shape as
-// graphrefly.bench.ts.
-const lastOrPrev =
-	(idx: number) =>
-	(batchData: ReadonlyArray<unknown[] | null>, ctx: Ctx): number => {
-		const b = batchData[idx];
-		return (b != null && b.length > 0 ? b.at(-1) : ctx.prevData[idx]) as number;
-	};
-
-// ─── state.set with subscriber ────────────────────────────────────
-
-function setupStateWithSubscriber(make: Make) {
-	const s = make<number>([], undefined, 0);
-	const unsub = s.subscribe(() => undefined);
-	return { s, unsub };
-}
-
-describe("baseline / state.set() + subscriber", () => {
-	const { s, unsub } = setupStateWithSubscriber(baselineNode);
-	let i = 0;
-	bench("baseline_state_set_sub", () => {
-		s.pushExternal(i++);
-	});
-	afterAll(() => unsub());
-});
-
-describe("r8 / state.set() + subscriber", () => {
-	const { s, unsub } = setupStateWithSubscriber(r8Node);
-	let i = 0;
-	bench("r8_state_set_sub", () => {
-		s.pushExternal(i++);
-	});
-	afterAll(() => unsub());
-});
-
-// ─── derived: single-dep ──────────────────────────────────────────
-
-function setupDerivedSingle(make: Make) {
-	const a = make<number>([], undefined, 0);
-	const d = make<number>([a], (batchData, actions, ctx) => {
-		const v = lastOrPrev(0)(batchData, ctx);
-		(actions as Actions<number>).emit(v * 2);
-	});
-	const unsub = d.subscribe(() => undefined);
-	return { a, d, unsub };
-}
-
-describe("baseline / derived single-dep", () => {
-	const { a, unsub } = setupDerivedSingle(baselineNode);
-	let i = 0;
-	bench("baseline_derived_1dep", () => {
-		a.pushExternal(i++);
-	});
-	afterAll(() => unsub());
-});
-
-describe("r8 / derived single-dep", () => {
-	const { a, unsub } = setupDerivedSingle(r8Node);
-	let i = 0;
-	bench("r8_derived_1dep", () => {
-		a.pushExternal(i++);
-	});
-	afterAll(() => unsub());
-});
-
-// ─── derived: multi-dep (2) ───────────────────────────────────────
-
-function setupDerivedMulti(make: Make) {
-	const a = make<number>([], undefined, 0);
-	const b = make<number>([], undefined, 0);
-	const d = make<number>(
-		[a as TinyNode<unknown>, b as TinyNode<unknown>],
-		(batchData, actions, ctx) => {
-			const x = lastOrPrev(0)(batchData, ctx);
-			const y = lastOrPrev(1)(batchData, ctx);
-			(actions as Actions<number>).emit(x + y);
-		},
-	);
-	const unsub = d.subscribe(() => undefined);
-	return { a, b, d, unsub };
-}
-
-describe("baseline / derived multi-dep", () => {
-	const { a, unsub } = setupDerivedMulti(baselineNode);
-	let i = 0;
-	bench("baseline_derived_2dep", () => {
-		a.pushExternal(i++);
-	});
-	afterAll(() => unsub());
-});
-
-describe("r8 / derived multi-dep", () => {
-	const { a, unsub } = setupDerivedMulti(r8Node);
-	let i = 0;
-	bench("r8_derived_2dep", () => {
-		a.pushExternal(i++);
-	});
-	afterAll(() => unsub());
-});
-
-// ─── diamond: A → B, C → D ────────────────────────────────────────
-
-function setupDiamond(make: Make) {
-	const a = make<number>([], undefined, 0);
-	const b = make<number>([a], (batchData, actions, ctx) => {
-		const v = lastOrPrev(0)(batchData, ctx);
-		(actions as Actions<number>).emit(v + 1);
-	});
-	const c = make<number>([a], (batchData, actions, ctx) => {
-		const v = lastOrPrev(0)(batchData, ctx);
-		(actions as Actions<number>).emit(v * 2);
-	});
-	const d = make<number>(
-		[b as TinyNode<unknown>, c as TinyNode<unknown>],
-		(batchData, actions, ctx) => {
-			const x = lastOrPrev(0)(batchData, ctx);
-			const y = lastOrPrev(1)(batchData, ctx);
-			(actions as Actions<number>).emit(x + y);
-		},
-	);
-	const unsub = d.subscribe(() => undefined);
-	return { a, unsub };
-}
-
-describe("baseline / diamond", () => {
-	const { a, unsub } = setupDiamond(baselineNode);
-	let i = 0;
-	bench("baseline_diamond", () => {
-		a.pushExternal(i++);
-	});
-	afterAll(() => unsub());
-});
-
-describe("r8 / diamond", () => {
-	const { a, unsub } = setupDiamond(r8Node);
-	let i = 0;
-	bench("r8_diamond", () => {
-		a.pushExternal(i++);
-	});
-	afterAll(() => unsub());
-});
-
-// ─── fan-out: N subscribers ───────────────────────────────────────
-
-function setupFanOut(make: Make, n: number) {
-	const s = make<number>([], undefined, 0);
-	const unsubs = Array.from({ length: n }, () => s.subscribe(() => undefined));
-	return { s, unsubs };
-}
-
-for (const n of [10, 100, 1000] as const) {
-	describe(`baseline / fan-out ${n}`, () => {
-		const { s, unsubs } = setupFanOut(baselineNode, n);
-		let i = 0;
-		bench(`baseline_fanout_${n}`, () => {
-			s.pushExternal(i++);
-		});
-		afterAll(() => {
-			for (const u of unsubs) u();
-		});
-	});
-
-	describe(`r8 / fan-out ${n}`, () => {
-		const { s, unsubs } = setupFanOut(r8Node, n);
-		let i = 0;
-		bench(`r8_fanout_${n}`, () => {
-			s.pushExternal(i++);
-		});
-		afterAll(() => {
-			for (const u of unsubs) u();
-		});
-	});
-}
-
-// ─── chain: 10-deep linear ─────────────────────────────────────────
-
-function setupChain(make: Make, length: number) {
-	const head = make<number>([], undefined, 0);
-	let cur: TinyNode<number> = head;
-	for (let j = 0; j < length; j++) {
-		const prev = cur;
-		cur = make<number>([prev], (batchData, actions, ctx) => {
-			const v = lastOrPrev(0)(batchData, ctx);
-			(actions as Actions<number>).emit(v + 1);
-		});
-	}
-	const tail = cur;
-	const unsub = tail.subscribe(() => undefined);
-	return { head, unsub };
-}
-
-for (const len of [5, 10, 20] as const) {
-	describe(`baseline / chain ${len}`, () => {
-		const { head, unsub } = setupChain(baselineNode, len);
-		let i = 0;
-		bench(`baseline_chain_${len}`, () => {
-			head.pushExternal(i++);
-		});
-		afterAll(() => unsub());
-	});
-
-	describe(`r8 / chain ${len}`, () => {
-		const { head, unsub } = setupChain(r8Node, len);
-		let i = 0;
-		bench(`r8_chain_${len}`, () => {
-			head.pushExternal(i++);
-		});
-		afterAll(() => unsub());
-	});
-}
diff --git a/packages/pure-ts/src/__experiments__/handle-core/bindings.ts b/packages/pure-ts/src/__experiments__/handle-core/bindings.ts
deleted file mode 100644
index cf6367fc..00000000
--- a/packages/pure-ts/src/__experiments__/handle-core/bindings.ts
+++ /dev/null
@@ -1,380 +0,0 @@
-/**
- * Binding layer — owns the value registry; talks to Core in handles only.
- *
- * In the eventual Rust split, this file's contents become the per-language
- * SDK harness. The Core (above) compiles to Rust; this layer stays in TS
- * (and a parallel Python version stays in Python). The boundary is the
- * `BindingBoundary` interface in core.ts.
- *
- * Key discipline: the value registry uses `WeakMap<object, HandleId>` for
- * objects, ensuring that the same JS object always gets the same HandleId.
- * This is what makes `equals: 'identity'` work correctly at the Core level
- * without ever crossing the boundary on the hot path.
- *
- * Primitives are deduped via a `Map<primitive, HandleId>` so `intern(42)`
- * twice returns the same handle. Optional but recommended for the same
- * identity-equals correctness reason.
- */
-
-import {
-	type BindingBoundary,
-	Core,
-	DATA,
-	type FnId,
-	type FnResult,
-	type HandleId,
-	type Message,
-	NO_HANDLE,
-	type NodeId,
-} from "./core.js";
-
-// ---------------------------------------------------------------------------
-// Value registry — what lives on the binding side, NOT the Core side
-// ---------------------------------------------------------------------------
-
-class ValueRegistry {
-	private nextHandle = 1;
-	private readonly handleToValue = new Map<HandleId, unknown>();
-	/** Object-identity dedup: same JS object → same HandleId. */
-	private readonly valueToHandle = new WeakMap<object, HandleId>();
-	/** Primitive dedup. */
-	private readonly primitiveToHandle = new Map<unknown, HandleId>();
-	/** Refcount per handle — released when count hits 0. */
-	private readonly refcounts = new Map<HandleId, number>();
-
-	intern(value: unknown): HandleId {
-		// Dedup: same value should yield same handle so `equals: identity`
-		// works. WeakMap for objects (so we don't pin them); Map for
-		// primitives (cheap, primitives don't leak).
-		if (value === undefined) {
-			throw new Error("undefined is not a valid DATA value (it is SENTINEL)");
-		}
-		if (typeof value === "object" && value !== null) {
-			const existing = this.valueToHandle.get(value);
-			if (existing !== undefined) {
-				this.refcounts.set(existing, (this.refcounts.get(existing) ?? 0) + 1);
-				return existing;
-			}
-		} else {
-			const existing = this.primitiveToHandle.get(value);
-			if (existing !== undefined) {
-				this.refcounts.set(existing, (this.refcounts.get(existing) ?? 0) + 1);
-				return existing;
-			}
-		}
-		const id = this.nextHandle++ as HandleId;
-		this.handleToValue.set(id, value);
-		if (typeof value === "object" && value !== null) {
-			this.valueToHandle.set(value, id);
-		} else {
-			this.primitiveToHandle.set(value, id);
-		}
-		this.refcounts.set(id, 1);
-		return id;
-	}
-
-	deref(handle: HandleId): unknown {
-		if (handle === NO_HANDLE) {
-			throw new Error("cannot deref NO_HANDLE");
-		}
-		if (!this.handleToValue.has(handle)) {
-			throw new Error(`unknown handle ${handle}`);
-		}
-		return this.handleToValue.get(handle);
-	}
-
-	release(handle: HandleId): void {
-		const cur = this.refcounts.get(handle) ?? 0;
-		if (cur <= 1) {
-			const value = this.handleToValue.get(handle);
-			this.handleToValue.delete(handle);
-			this.refcounts.delete(handle);
-			// WeakMap cleans itself; primitive map needs explicit delete.
-			if (value !== undefined && (typeof value !== "object" || value === null)) {
-				this.primitiveToHandle.delete(value);
-			}
-		} else {
-			this.refcounts.set(handle, cur - 1);
-		}
-	}
-
-	/** Test helper: how many handles are live? Detects leaks. */
-	liveCount(): number {
-		return this.handleToValue.size;
-	}
-
-	/** Test helper: full snapshot for diagnostic asserts. */
-	snapshot(): { handles: number; refcounts: ReadonlyMap<HandleId, number> } {
-		return {
-			handles: this.handleToValue.size,
-			refcounts: new Map(this.refcounts),
-		};
-	}
-}
-
-// ---------------------------------------------------------------------------
-// Fn registry — fnId -> JS callable
-// ---------------------------------------------------------------------------
-
-type UserFn = (...args: unknown[]) => unknown;
-type CustomEqualsFn = (a: unknown, b: unknown) => boolean;
-
-class FnRegistry {
-	private nextId = 1;
-	private readonly userFns = new Map<FnId, UserFn>();
-	private readonly equalsFns = new Map<FnId, CustomEqualsFn>();
-
-	registerFn(fn: UserFn): FnId {
-		const id = this.nextId++ as FnId;
-		this.userFns.set(id, fn);
-		return id;
-	}
-
-	registerEquals(fn: CustomEqualsFn): FnId {
-		const id = this.nextId++ as FnId;
-		this.equalsFns.set(id, fn);
-		return id;
-	}
-
-	getUserFn(id: FnId): UserFn {
-		const fn = this.userFns.get(id);
-		if (!fn) throw new Error(`unknown user fn ${id}`);
-		return fn;
-	}
-
-	getEqualsFn(id: FnId): CustomEqualsFn {
-		const fn = this.equalsFns.get(id);
-		if (!fn) throw new Error(`unknown equals fn ${id}`);
-		return fn;
-	}
-}
-
-// ---------------------------------------------------------------------------
-// Public API — `state`, `derived`, `subscribe` in handle-protocol terms
-// ---------------------------------------------------------------------------
-
-export interface NodeAPI<T> {
-	readonly _id: NodeId;
-	readonly _phantom: T; // brand for type inference
-}
-
-/**
- * Marker interface: fn returns this when it wants to declare which
- * deps it actually tracked this run. Used by `dynamic` nodes only.
- */
-interface WithTrackedTag {
-	__handleCoreTracked: true;
-}
-
-export interface WithTracked<T> extends WithTrackedTag {
-	value: T | undefined;
-	tracked: ReadonlySet<number>;
-}
-
-/**
- * Helper for dynamic-fn return: `tracked(value, [depIdxA, depIdxC])`
- * tells Core "I read deps A and C this run; do not re-fire me when
- * other deps update." Pass `undefined` as value for noop.
- */
-export function tracked<T>(value: T | undefined, indices: readonly number[]): WithTracked<T> {
-	return {
-		__handleCoreTracked: true,
-		value,
-		tracked: new Set(indices),
-	};
-}
-
-/**
- * FFI cost counters. Every method on `BindingBoundary` is wrapped to
- * increment its corresponding counter, giving you a per-graph trace of
- * exactly how many boundary crossings occurred. In a Rust-core port,
- * each tick of `invokeFn` and `customEquals` is one FFI call (~0.5–1µs
- * for napi-rs, 2–5µs for PyO3). `releaseHandle` is also a crossing but
- * is amortizable (refcount decrement only).
- *
- * Use this to verify the architectural promise: identity-equals graphs
- * should show ZERO `customEquals` crossings; pure-state graphs without
- * derived chains should show ZERO `invokeFn`.
- */
-export interface FfiCounters {
-	invokeFn: number;
-	customEquals: number;
-	releaseHandle: number;
-}
-
-export class HandleRuntime {
-	private readonly registry = new ValueRegistry();
-	private readonly fns = new FnRegistry();
-	private readonly core: Core;
-	private readonly counters: FfiCounters = {
-		invokeFn: 0,
-		customEquals: 0,
-		releaseHandle: 0,
-	};
-
-	constructor() {
-		const boundary: BindingBoundary = {
-			invokeFn: (_nodeId, fnId, depHandles): FnResult => {
-				this.counters.invokeFn++;
-				const fn = this.fns.getUserFn(fnId);
-				const args = depHandles.map((h) => this.registry.deref(h));
-				const out = fn(...args);
-				if (out === undefined) {
-					return { kind: "noop" };
-				}
-				// `fn` may return a `WithTracked<T>` sentinel (for dynamic nodes)
-				// or a plain value. Detect via prototype tag.
-				if (
-					typeof out === "object" &&
-					out !== null &&
-					(out as WithTrackedTag).__handleCoreTracked === true
-				) {
-					const tagged = out as { value: unknown; tracked: ReadonlySet<number> };
-					if (tagged.value === undefined) {
-						return { kind: "noop", tracked: tagged.tracked };
-					}
-					const handle = this.registry.intern(tagged.value);
-					return { kind: "data", handle, tracked: tagged.tracked };
-				}
-				const handle = this.registry.intern(out);
-				return { kind: "data", handle };
-			},
-			customEquals: (equalsHandle, a, b) => {
-				this.counters.customEquals++;
-				const fn = this.fns.getEqualsFn(equalsHandle);
-				return fn(this.registry.deref(a), this.registry.deref(b));
-			},
-			releaseHandle: (handle) => {
-				this.counters.releaseHandle++;
-				this.registry.release(handle);
-			},
-		};
-		this.core = new Core(boundary);
-	}
-
-	/** Reset FFI counters (e.g. between test phases). */
-	resetCounters(): void {
-		this.counters.invokeFn = 0;
-		this.counters.customEquals = 0;
-		this.counters.releaseHandle = 0;
-	}
-
-	ffiCounters(): Readonly<FfiCounters> {
-		return { ...this.counters };
-	}
-
-	state<T>(initial?: T): NodeAPI<T> & {
-		set(value: T): void;
-		current(): T | undefined;
-	} {
-		const initialHandle = initial === undefined ? NO_HANDLE : this.registry.intern(initial);
-		const id = this.core.registerState(initialHandle);
-		return {
-			_id: id,
-			_phantom: undefined as unknown as T,
-			set: (value: T) => {
-				const handle = this.registry.intern(value);
-				this.core.emit(id, handle);
-			},
-			current: () => {
-				const h = this.core.cacheOf(id);
-				if (h === NO_HANDLE) return undefined;
-				return this.registry.deref(h) as T;
-			},
-		};
-	}
-
-	derived<T, D extends readonly NodeAPI<unknown>[]>(
-		deps: D,
-		fn: (...args: { [K in keyof D]: D[K] extends NodeAPI<infer U> ? U : never }) => T,
-		opts?: { equals?: "identity" | ((a: T, b: T) => boolean) },
-	): NodeAPI<T> & { current(): T | undefined } {
-		const fnId = this.fns.registerFn(fn as UserFn);
-		const eq =
-			opts?.equals && opts.equals !== "identity"
-				? {
-						kind: "custom" as const,
-						handle: this.fns.registerEquals(opts.equals as CustomEqualsFn),
-					}
-				: { kind: "identity" as const };
-		const id = this.core.registerDerived(
-			deps.map((d) => d._id),
-			fnId,
-			eq,
-		);
-		return {
-			_id: id,
-			_phantom: undefined as unknown as T,
-			current: () => {
-				const h = this.core.cacheOf(id);
-				if (h === NO_HANDLE) return undefined;
-				return this.registry.deref(h) as T;
-			},
-		};
-	}
-
-	/**
-	 * Dynamic node — declares a SUPERSET of possible deps; fn returns
-	 * `tracked(value, [depIdx, ...])` to declare which subset it actually
-	 * read this run. Untracked dep updates do not fire this node's fn.
-	 *
-	 * Use case: `track`-style operators (rxjs's `switchMap` analogue),
-	 * `autoTrackNode` for compat layers, conditional dep selection.
-	 *
-	 * Boundary cost: same per-fire as static `derived`. The win is
-	 * fewer fires per wave under selective-deps patterns.
-	 */
-	dynamic<T, D extends readonly NodeAPI<unknown>[]>(
-		deps: D,
-		fn: (
-			...args: { [K in keyof D]: D[K] extends NodeAPI<infer U> ? U : never }
-		) => WithTracked<T> | T,
-	): NodeAPI<T> & { current(): T | undefined } {
-		const fnId = this.fns.registerFn(fn as UserFn);
-		const id = this.core.registerDynamic(
-			deps.map((d) => d._id),
-			fnId,
-			{ kind: "identity" },
-		);
-		return {
-			_id: id,
-			_phantom: undefined as unknown as T,
-			current: () => {
-				const h = this.core.cacheOf(id);
-				if (h === NO_HANDLE) return undefined;
-				return this.registry.deref(h) as T;
-			},
-		};
-	}
-
-	subscribe<T>(
-		node: NodeAPI<T>,
-		sink: (
-			event: { tag: "data"; value: T } | { tag: "resolved" } | { tag: "dirty" } | { tag: "start" },
-		) => void,
-	): () => void {
-		const wrapped = (msgs: readonly Message[]) => {
-			for (const msg of msgs) {
-				if (msg[0] === DATA) {
-					sink({ tag: "data", value: this.registry.deref(msg[1]) as T });
-				} else if (msg[0] === "DIRTY") {
-					sink({ tag: "dirty" });
-				} else if (msg[0] === "RESOLVED") {
-					sink({ tag: "resolved" });
-				} else if (msg[0] === "START") {
-					sink({ tag: "start" });
-				}
-			}
-		};
-		return this.core.subscribe(node._id, wrapped);
-	}
-
-	// Inspection / leak detection — handy for tests
-	debug() {
-		return {
-			liveHandles: this.registry.liveCount(),
-			ffi: this.ffiCounters(),
-			snapshot: this.registry.snapshot(),
-		};
-	}
-}
diff --git a/packages/pure-ts/src/__experiments__/handle-core/core.test.ts b/packages/pure-ts/src/__experiments__/handle-core/core.test.ts
deleted file mode 100644
index 35cf7835..00000000
--- a/packages/pure-ts/src/__experiments__/handle-core/core.test.ts
+++ /dev/null
@@ -1,221 +0,0 @@
-/**
- * Handle-core prototype tests.
- *
- * Each test maps to one or more invariants from the Phase 13.6 inventory.
- * The test names cite the inventory rule IDs so a failing test points at
- * a concrete spec section.
- */
-
-import { describe, expect, it } from "vitest";
-import { HandleRuntime } from "./bindings.js";
-
-type Event =
-	| { tag: "start" }
-	| { tag: "dirty" }
-	| { tag: "data"; value: unknown }
-	| { tag: "resolved" };
-
-function record() {
-	const events: Event[] = [];
-	const sink = (e: Event) => events.push(e);
-	const dataValues = () =>
-		events.filter((e): e is Event & { tag: "data" } => e.tag === "data").map((e) => e.value);
-	const tags = () => events.map((e) => e.tag);
-	return { events, sink, dataValues, tags };
-}
-
-describe("handle-core: identity dedup (Rule 1.3 — equals-substitution)", () => {
-	it("emitting the same primitive twice yields one DATA + one RESOLVED", () => {
-		const rt = new HandleRuntime();
-		const s = rt.state<number>();
-		const r = record();
-		rt.subscribe(s, r.sink);
-		s.set(42);
-		s.set(42); // should be RESOLVED, not DATA — same handle
-		expect(r.dataValues()).toEqual([42]);
-		// Wave 1: START. Wave 2: DIRTY+DATA. Wave 3: DIRTY+RESOLVED.
-		expect(r.tags()).toEqual(["start", "dirty", "data", "dirty", "resolved"]);
-	});
-
-	it("emitting the same object reference twice yields one DATA + one RESOLVED", () => {
-		const rt = new HandleRuntime();
-		const s = rt.state<{ x: number }>();
-		const r = record();
-		rt.subscribe(s, r.sink);
-		const obj = { x: 1 };
-		s.set(obj);
-		s.set(obj);
-		expect(r.dataValues()).toEqual([obj]);
-		expect(r.tags().filter((t) => t === "data").length).toBe(1);
-		expect(r.tags().filter((t) => t === "resolved").length).toBe(1);
-	});
-
-	it("structurally-equal but distinct objects produce TWO DATA (no deep equals by default)", () => {
-		const rt = new HandleRuntime();
-		const s = rt.state<{ x: number }>();
-		const r = record();
-		rt.subscribe(s, r.sink);
-		s.set({ x: 1 });
-		s.set({ x: 1 }); // distinct object reference → distinct handle → DATA
-		expect(r.tags().filter((t) => t === "data").length).toBe(2);
-		expect(r.tags().filter((t) => t === "resolved").length).toBe(0);
-	});
-});
-
-describe("handle-core: first-run gate (Rule 2.3 / P.1)", () => {
-	it("derived with two state deps does not fire until both have emitted", () => {
-		const rt = new HandleRuntime();
-		const a = rt.state<number>();
-		const b = rt.state<number>();
-		let calls = 0;
-		const sum = rt.derived([a, b], (av: number, bv: number) => {
-			calls++;
-			return av + bv;
-		});
-		// subscribe — neither dep has a value, so derived should NOT fire
-		const r = record();
-		rt.subscribe(sum, r.sink);
-		expect(calls).toBe(0);
-		expect(sum.current()).toBeUndefined();
-		// emit on a — gate still closed (b is sentinel)
-		a.set(10);
-		expect(calls).toBe(0);
-		// emit on b — gate releases, fn fires
-		b.set(20);
-		expect(calls).toBe(1);
-		expect(sum.current()).toBe(30);
-	});
-
-	it("derived with pre-initialized state deps fires on first subscribe", () => {
-		const rt = new HandleRuntime();
-		const a = rt.state(10);
-		const b = rt.state(20);
-		let calls = 0;
-		const sum = rt.derived([a, b], (av: number, bv: number) => {
-			calls++;
-			return av + bv;
-		});
-		const r = record();
-		rt.subscribe(sum, r.sink);
-		// Both deps have cached handles → push-on-subscribe → fn fires
-		expect(calls).toBe(1);
-		expect(sum.current()).toBe(30);
-		expect(r.dataValues()).toEqual([30]);
-	});
-});
-
-describe("handle-core: diamond resolution (Spec §1.3.3)", () => {
-	it("D = B + C, both depend on A; one update on A → D fires once", () => {
-		const rt = new HandleRuntime();
-		const a = rt.state(1);
-		const b = rt.derived([a], (av: number) => av * 2);
-		const c = rt.derived([a], (av: number) => av * 3);
-		let dCalls = 0;
-		const d = rt.derived([b, c], (bv: number, cv: number) => {
-			dCalls++;
-			return bv + cv;
-		});
-		const r = record();
-		rt.subscribe(d, r.sink);
-		expect(dCalls).toBe(1); // initial activation: a=1 → b=2, c=3, d=5
-		expect(d.current()).toBe(5);
-
-		const before = dCalls;
-		a.set(10);
-		// One update at the root must produce ONE fire of D, not two.
-		expect(dCalls - before).toBe(1);
-		expect(d.current()).toBe(50); // 20 + 30
-	});
-
-	it("emitted DATA at root yields one DATA event at sink (single wave-close)", () => {
-		const rt = new HandleRuntime();
-		const a = rt.state(1);
-		const b = rt.derived([a], (av: number) => av + 100);
-		const c = rt.derived([a], (av: number) => av + 200);
-		const sum = rt.derived([b, c], (bv: number, cv: number) => bv + cv);
-		const r = record();
-		rt.subscribe(sum, r.sink);
-		const initialDataCount = r.tags().filter((t) => t === "data").length;
-		a.set(5);
-		const finalDataCount = r.tags().filter((t) => t === "data").length;
-		// Exactly one new DATA after the initial activation DATA.
-		expect(finalDataCount - initialDataCount).toBe(1);
-		expect(sum.current()).toBe(310); // (5+100) + (5+200)
-	});
-});
-
-describe("handle-core: push-on-subscribe (Rule 1.2 / 2.1)", () => {
-	it("late subscriber to state with cached value receives current handle as DATA", () => {
-		const rt = new HandleRuntime();
-		const s = rt.state(99);
-		// no prior subscribers — but state was constructed with initial
-		const r = record();
-		rt.subscribe(s, r.sink);
-		expect(r.dataValues()).toEqual([99]);
-	});
-
-	it("late subscriber to sentinel state receives only START (no DATA)", () => {
-		const rt = new HandleRuntime();
-		const s = rt.state<number>();
-		const r = record();
-		rt.subscribe(s, r.sink);
-		expect(r.dataValues()).toEqual([]);
-		expect(r.tags()).toEqual(["start"]);
-	});
-});
-
-describe("handle-core: custom equals (FFI-only when opted in)", () => {
-	it("derived with custom deep-equals dedups structurally-equal outputs", () => {
-		const rt = new HandleRuntime();
-		const a = rt.state(1);
-		// derived returns a fresh object each fire; with identity equals,
-		// every update propagates as DATA. With custom deep equals, equal
-		// shapes dedup to RESOLVED.
-		const wrapper = rt.derived([a], (av: number) => ({ value: av < 10 ? "small" : "big" }), {
-			equals: (x: { value: string }, y: { value: string }) => x.value === y.value,
-		});
-		const r = record();
-		rt.subscribe(wrapper, r.sink);
-		const initialDataCount = r.tags().filter((t) => t === "data").length;
-		expect(initialDataCount).toBe(1); // initial activation
-
-		a.set(2); // still "small" — should be RESOLVED downstream
-		a.set(3);
-		const midDataCount = r.tags().filter((t) => t === "data").length;
-		expect(midDataCount).toBe(initialDataCount); // no new DATA
-
-		a.set(20); // crosses threshold → "big" → DATA
-		const finalDataCount = r.tags().filter((t) => t === "data").length;
-		expect(finalDataCount).toBe(initialDataCount + 1);
-	});
-});
-
-describe("handle-core: undefined is SENTINEL (Rule M.4)", () => {
-	it("emitting undefined throws — undefined is reserved as SENTINEL globally", () => {
-		const rt = new HandleRuntime();
-		const s = rt.state<number | null>();
-		expect(() => s.set(undefined as unknown as number)).toThrow(/SENTINEL/);
-	});
-
-	it("null is a valid DATA payload", () => {
-		const rt = new HandleRuntime();
-		const s = rt.state<number | null>();
-		const r = record();
-		rt.subscribe(s, r.sink);
-		s.set(null);
-		expect(r.dataValues()).toEqual([null]);
-	});
-});
-
-describe("handle-core: handle release / refcount (memory hygiene)", () => {
-	it("replacing a state value releases the old handle", () => {
-		const rt = new HandleRuntime();
-		const s = rt.state(1);
-		const before = rt.debug().liveHandles;
-		s.set(2);
-		const after = rt.debug().liveHandles;
-		// Old handle for `1` should have been released; new handle for `2`
-		// added. Net change: 0.
-		expect(after).toBe(before);
-	});
-});
diff --git a/packages/pure-ts/src/__experiments__/handle-core/core.ts b/packages/pure-ts/src/__experiments__/handle-core/core.ts
deleted file mode 100644
index 27f8fabe..00000000
--- a/packages/pure-ts/src/__experiments__/handle-core/core.ts
+++ /dev/null
@@ -1,556 +0,0 @@
-/**
- * Handle-based reactive core — research prototype (Phase 13.6 brainstorm).
- *
- * Validates the architecture sketched in the 2026-05-02 brainstorm:
- *
- *   The core never sees user values T. It operates entirely on `HandleId`
- *   opaque integers. Values live in a binding-side registry (a `Map`
- *   from HandleId to T, plus a `WeakMap<value, HandleId>` for identity
- *   dedup). Equals-substitution with `equals: 'identity'` becomes a
- *   handle-id compare — zero FFI when this layer is in Rust.
- *
- *   fn invocation is the ONE crossing the binding side has to make:
- *   the core asks `invokeFn(nodeId, depHandles)`; the binding side
- *   dereferences handles to T, calls user fn, registers the output as
- *   a new handle, returns it. Custom equals optionally crosses too.
- *
- * Scope: the slice of the protocol that's most invariant-dense and
- * therefore most informative to validate at this stage:
- *
- *   - State + derived nodes
- *   - Subscribe / unsubscribe (push-on-subscribe for cached state)
- *   - DIRTY / DATA / RESOLVED ordering
- *   - Equals-substitution (identity by default; custom hook)
- *   - First-run gate (fn does not fire until every dep has a handle)
- *   - Diamond resolution (one fn call per wave even with shared upstream)
- *   - Wave model (one Core.tick = drain pending until quiescent)
- *
- * Out of scope for this prototype (worth a v2 if the v1 holds up):
- *   - PAUSE / RESUME with lock IDs
- *   - INVALIDATE broadcast
- *   - Dynamic deps (autoTrack / dynamicNode)
- *   - Producers / effects with cleanup
- *   - Errors and COMPLETE auto-prop
- *   - Resubscribable lifecycle
- *
- * Two important things to note about this prototype:
- *
- *   1. The Core has no `T` in its types. Inspect signatures of the
- *      public methods — `HandleId` is everywhere user values would
- *      otherwise sit. That is the design point. In a Rust port the
- *      Core compiles without ever seeing a `serde::Serialize`.
- *
- *   2. The binding layer (`bindings.ts`) keeps the WeakMap-based
- *      value registry. That layer is what would become per-language
- *      SDK harness in a portability scheme.
- */
-
-// ---------------------------------------------------------------------------
-// Types — pure IDs, no user values anywhere
-// ---------------------------------------------------------------------------
-
-export type NodeId = number & { readonly __brand: "NodeId" };
-export type HandleId = number & { readonly __brand: "HandleId" };
-export type FnId = number & { readonly __brand: "FnId" };
-
-/** No-handle sentinel — distinct from any valid HandleId (which start at 1). */
-export const NO_HANDLE = 0 as HandleId;
-
-/** Internal-subscription marker — keeps derived deps activated when consumed
- * by another derived. Distinct from external sinks so we can filter it
- * out when delivering DATA. (In a Rust port, this would be a separate
- * "consumer link" concept rather than abusing the subscribers set.) */
-const NOOP_SINK: Sink = () => {};
-
-export const DIRTY = "DIRTY" as const;
-export const DATA = "DATA" as const;
-export const RESOLVED = "RESOLVED" as const;
-export const START = "START" as const;
-export type MessageTag = typeof DIRTY | typeof DATA | typeof RESOLVED | typeof START;
-
-/** A wire message. DATA carries a HandleId; the rest are payload-free. */
-export type Message =
-	| readonly [typeof START]
-	| readonly [typeof DIRTY]
-	| readonly [typeof RESOLVED]
-	| readonly [typeof DATA, HandleId];
-
-export type Sink = (messages: readonly Message[]) => void;
-
-/**
- * Equals-mode tells the core how to compare handles.
- *
- *   - 'identity' (default): handle-id compare. Cheap. Correct iff
- *     the binding-side registry maintains "same value ⇒ same handle"
- *     (the WeakMap discipline in `bindings.ts`).
- *
- *   - 'custom': core asks the binding side via `customEqualsHandle`.
- *     This crosses the boundary every emit; rare opt-in for cases
- *     where structural equality matters more than identity.
- */
-export type EqualsMode = { kind: "identity" } | { kind: "custom"; handle: FnId };
-
-/**
- * What the binding side returns when the core invokes a fn.
- *
- *   - `{ kind: 'data', handle }` — fn produced a value, registered as
- *     `handle`. Core treats as outgoing DATA (subject to equals dedup).
- *   - `{ kind: 'noop' }` — fn ran but produced no emission this wave.
- *     Core sends RESOLVED to subscribers.
- *
- * `tracked` (optional) — for dynamic nodes only. The set of dep indices
- * the fn actually read this run; deps outside this set don't gate
- * future fires. Static nodes ignore this field. See `registerDynamic()`.
- */
-export type FnResult =
-	| { kind: "data"; handle: HandleId; tracked?: ReadonlySet<number> }
-	| { kind: "noop"; tracked?: ReadonlySet<number> };
-
-/**
- * The boundary the binding side implements. Core calls this and only
- * this when it needs to invoke user code.
- *
- *   - `invokeFn(nodeId, fnId, depHandles)` — fire fn. Binding
- *     dereferences handles, calls user fn, returns result.
- *   - `customEquals(equalsHandle, a, b)` — only called when a node
- *     declares `equals: { kind: 'custom' }`.
- *   - `releaseHandle(id)` — core informs binding that handle is no
- *     longer referenced by any node cache. Binding decrements refcount;
- *     value GC'd when no other holders remain. Safe to be a no-op
- *     during prototyping; matters for memory pressure under load.
- */
-export interface BindingBoundary {
-	invokeFn(nodeId: NodeId, fnId: FnId, depHandles: readonly HandleId[]): FnResult;
-	customEquals(equalsHandle: FnId, a: HandleId, b: HandleId): boolean;
-	releaseHandle(handle: HandleId): void;
-}
-
-// ---------------------------------------------------------------------------
-// Internal node record — Core's view of the world
-// ---------------------------------------------------------------------------
-
-interface NodeRecord {
-	readonly id: NodeId;
-	readonly deps: readonly NodeId[];
-	/** ROM (state) keeps cache across deactivation; RAM (derived/dynamic) clears it. */
-	readonly kind: "state" | "derived" | "dynamic";
-	readonly fnId: FnId | null; // null for state nodes (no fn)
-	readonly equals: EqualsMode;
-
-	// Mutable state
-	cache: HandleId; // NO_HANDLE iff sentinel
-	/** Per-dep handle of last DATA seen. Parallels `deps` array. */
-	depHandles: HandleId[];
-	hasFiredOnce: boolean;
-	subscribers: Set<Sink>;
-	/** For dynamic nodes: which dep indices fn actually tracks. Mutated
-	 * by fn fire results. For static derived, all indices are tracked.
-	 */
-	tracked: Set<number>;
-
-	// Wave-scoped state — cleared at wave end
-	dirty: boolean;
-	involvedThisWave: boolean;
-}
-
-// ---------------------------------------------------------------------------
-// Core
-// ---------------------------------------------------------------------------
-
-export class Core {
-	private nextNodeId = 1;
-	private readonly nodes = new Map<NodeId, NodeRecord>();
-	/** child -> set of parent node ids it depends on. */
-	private readonly children = new Map<NodeId, Set<NodeId>>();
-
-	/** Nodes whose fn we owe a fire to — drained by `tick()`. */
-	private readonly pendingFires = new Set<NodeId>();
-	/** Nodes whose subscribers we owe a wave-close (DATA or RESOLVED) to. */
-	private readonly pendingNotify = new Map<NodeId, Message[]>();
-	private inTick = false;
-
-	constructor(private readonly binding: BindingBoundary) {}
-
-	// -------------------------------------------------------------------
-	// Registration
-	// -------------------------------------------------------------------
-
-	registerState(initial: HandleId): NodeId {
-		const id = this.allocId();
-		const rec: NodeRecord = {
-			id,
-			deps: [],
-			kind: "state",
-			fnId: null,
-			equals: { kind: "identity" },
-			cache: initial,
-			depHandles: [],
-			hasFiredOnce: initial !== NO_HANDLE,
-			subscribers: new Set(),
-			tracked: new Set(),
-			dirty: false,
-			involvedThisWave: false,
-		};
-		this.nodes.set(id, rec);
-		this.children.set(id, new Set());
-		return id;
-	}
-
-	registerDerived(
-		deps: readonly NodeId[],
-		fnId: FnId,
-		equals: EqualsMode = { kind: "identity" },
-	): NodeId {
-		return this.registerComputed(deps, fnId, equals, "derived");
-	}
-
-	/**
-	 * Dynamic node: declares a SUPERSET of possible deps at construction
-	 * (Rule L2.11 / P.22). The fn declares which subset it actually
-	 * tracked this run by returning `tracked: Set<number>` in FnResult.
-	 * Untracked dep updates still arrive at the Core (DATA on the wire)
-	 * but do NOT cause this node's fn to fire — equals absorption at
-	 * the consumer prevents wasted work.
-	 *
-	 * Boundary cost: same as static derived (one invokeFn per fire).
-	 * The "selective deps" pattern means fewer fires per wave even
-	 * though the dep declaration is broader.
-	 */
-	registerDynamic(
-		deps: readonly NodeId[],
-		fnId: FnId,
-		equals: EqualsMode = { kind: "identity" },
-	): NodeId {
-		return this.registerComputed(deps, fnId, equals, "dynamic");
-	}
-
-	private registerComputed(
-		deps: readonly NodeId[],
-		fnId: FnId,
-		equals: EqualsMode,
-		kind: "derived" | "dynamic",
-	): NodeId {
-		const id = this.allocId();
-		// Static derived tracks all deps; dynamic starts empty and grows by fn return.
-		const trackedInit: Set<number> =
-			kind === "derived" ? new Set(deps.map((_, i) => i)) : new Set();
-		const rec: NodeRecord = {
-			id,
-			deps: deps.slice(),
-			kind,
-			fnId,
-			equals,
-			cache: NO_HANDLE,
-			depHandles: deps.map(() => NO_HANDLE),
-			hasFiredOnce: false,
-			subscribers: new Set(),
-			tracked: trackedInit,
-			dirty: false,
-			involvedThisWave: false,
-		};
-		this.nodes.set(id, rec);
-		this.children.set(id, new Set());
-		for (const dep of deps) {
-			const set = this.children.get(dep);
-			if (!set) throw new Error(`unknown dep ${dep}`);
-			set.add(id);
-		}
-		return id;
-	}
-
-	// -------------------------------------------------------------------
-	// Subscription
-	// -------------------------------------------------------------------
-
-	subscribe(nodeId: NodeId, sink: Sink): () => void {
-		const rec = this.requireNode(nodeId);
-		rec.subscribers.add(sink);
-		// Push-on-subscribe (Spec §2.2):
-		// State nodes (and derived that have already fired) push their
-		// cached handle to the new subscriber.
-		const startMsg: Message = [START];
-		if (rec.cache !== NO_HANDLE) {
-			sink([startMsg, [DATA, rec.cache]]);
-		} else {
-			sink([startMsg]);
-		}
-		// Derived activation: if first subscriber, eagerly subscribe to deps
-		// so they push their cached handles, which will fill our depHandles
-		// and may release the first-run gate.
-		if (rec.kind !== "state" && rec.subscribers.size === 1) {
-			this.activateDerived(rec);
-		}
-		return () => {
-			rec.subscribers.delete(sink);
-			// Deactivation cleanup is out of scope for v1
-			// (would clear cache for RAM nodes, release handle, etc.)
-		};
-	}
-
-	private activateDerived(rec: NodeRecord): void {
-		// Recursive activation: for each dep, if it's a derived with no
-		// cache yet (hasn't fired), activate it first. State nodes need
-		// no activation — their cache is set at construction.
-		// This mirrors push-on-subscribe transitively up the dep chain:
-		// when D first subscribes, the recursive walk activates B and C
-		// (which activate A, etc.), populating caches on the way down.
-		this.runWave(() => {
-			for (let i = 0; i < rec.deps.length; i++) {
-				const depRec = this.requireNode(rec.deps[i]);
-				if (depRec.kind !== "state" && depRec.cache === NO_HANDLE && !depRec.hasFiredOnce) {
-					// Subscribe a no-op sink to keep the dep activated; this
-					// also triggers its recursive activation. (In a Rust
-					// port, "internal subscription" is a Core-level concept
-					// distinct from external sinks; we model it by adding
-					// to the subscribers set with a marker sink.)
-					depRec.subscribers.add(NOOP_SINK);
-					if (depRec.subscribers.size === 1) {
-						this.activateDerived(depRec);
-					}
-				}
-				// Now dep should have a cache (state always; derived after
-				// activation walked above). Push-on-subscribe.
-				if (depRec.cache !== NO_HANDLE) {
-					this.deliverDataToConsumer(rec, i, depRec.cache);
-				}
-			}
-		});
-	}
-
-	// -------------------------------------------------------------------
-	// Emission entry point — for state nodes
-	// -------------------------------------------------------------------
-
-	emit(nodeId: NodeId, newHandle: HandleId): void {
-		const rec = this.requireNode(nodeId);
-		if (rec.kind !== "state") {
-			throw new Error("emit() is for state nodes only; derived emits via fn");
-		}
-		this.runWave(() => this.commitEmission(rec, newHandle));
-	}
-
-	// -------------------------------------------------------------------
-	// The wave engine — DIRTY first, then DATA / RESOLVED
-	// -------------------------------------------------------------------
-
-	private runWave(thunk: () => void): void {
-		if (this.inTick) {
-			// Re-entrant emission (e.g. from inside fn) — just queue work.
-			thunk();
-			return;
-		}
-		this.inTick = true;
-		try {
-			thunk();
-			// Drain: keep firing pending fns until quiescent.
-			let guard = 0;
-			while (this.pendingFires.size > 0) {
-				if (++guard > 10_000) {
-					throw new Error("wave drain exceeded 10k iterations (cycle?)");
-				}
-				const next = this.pickNextFire();
-				if (next === null) break;
-				this.fireFn(next);
-			}
-			// Phase 2: deliver wave-close to subscribers.
-			this.flushNotifications();
-		} finally {
-			// Wave cleanup
-			for (const rec of this.nodes.values()) {
-				rec.dirty = false;
-				rec.involvedThisWave = false;
-			}
-			this.inTick = false;
-		}
-	}
-
-	/**
-	 * Pick a node whose deps are all settled (no pending fires upstream).
-	 * Topological-ish order ensures diamond resolution: D fires once,
-	 * after both B and C settle.
-	 */
-	private pickNextFire(): NodeId | null {
-		for (const id of this.pendingFires) {
-			const rec = this.requireNode(id);
-			let allDepsSettled = true;
-			for (const depId of rec.deps) {
-				if (this.pendingFires.has(depId)) {
-					allDepsSettled = false;
-					break;
-				}
-			}
-			if (allDepsSettled) return id;
-		}
-		// Cycle? Pick any (will throw or stabilize).
-		const it = this.pendingFires.values().next();
-		return it.done ? null : it.value;
-	}
-
-	private fireFn(nodeId: NodeId): void {
-		this.pendingFires.delete(nodeId);
-		const rec = this.requireNode(nodeId);
-		if (rec.fnId === null) return;
-		// First-run gate: every dep must have a handle before we fire.
-		for (const h of rec.depHandles) {
-			if (h === NO_HANDLE) {
-				// Gate not yet open; defer (will be re-added when remaining
-				// deps deliver). This branch is the canonical first-run
-				// gate enforcement point.
-				return;
-			}
-		}
-		const result = this.binding.invokeFn(rec.id, rec.fnId, rec.depHandles);
-		rec.hasFiredOnce = true;
-		// For dynamic nodes, fn declares which dep indices it actually
-		// read this run. Subsequent updates on untracked deps will not
-		// re-add this node to pendingFires. (Static derived ignores
-		// `result.tracked` — its `rec.tracked` was filled at construction.)
-		if (rec.kind === "dynamic" && result.tracked) {
-			rec.tracked = new Set(result.tracked);
-		}
-		if (result.kind === "noop") {
-			// fn produced no value this wave — emit RESOLVED if dirty.
-			if (rec.dirty) {
-				this.queueNotify(rec, [RESOLVED]);
-			}
-		} else {
-			this.commitEmission(rec, result.handle);
-		}
-	}
-
-	// -------------------------------------------------------------------
-	// Emission commit — the only place equals-substitution lives
-	// -------------------------------------------------------------------
-
-	private commitEmission(rec: NodeRecord, newHandle: HandleId): void {
-		if (newHandle === NO_HANDLE) {
-			throw new Error("NO_HANDLE is not a valid DATA payload");
-		}
-		const oldHandle = rec.cache;
-		// Equals-substitution: outgoing DATA whose handle equals the cache
-		// is rewritten to RESOLVED on the wire. Never bypassable via choice
-		// of API (rule 1.3) — there is no other path that updates cache.
-		const isData = !this.handlesEqual(rec.equals, oldHandle, newHandle);
-
-		// Always send DIRTY first if this is the first-tier-3 of the wave.
-		if (!rec.dirty) {
-			rec.dirty = true;
-			this.queueNotify(rec, [DIRTY]);
-		}
-
-		if (isData) {
-			rec.cache = newHandle;
-			// Release the prior cache handle (refcount decrement).
-			if (oldHandle !== NO_HANDLE) {
-				this.binding.releaseHandle(oldHandle);
-			}
-			this.queueNotify(rec, [DATA, newHandle]);
-			// Propagate to children
-			for (const childId of this.children.get(rec.id) ?? []) {
-				const child = this.requireNode(childId);
-				const idx = child.deps.indexOf(rec.id);
-				this.deliverDataToConsumer(child, idx, newHandle);
-			}
-		} else {
-			// RESOLVED: handle unchanged. Do NOT release; old still in use.
-			this.queueNotify(rec, [RESOLVED]);
-			// Children whose fn fires on RESOLVED would still get it; but
-			// for `equals: identity` derived gates we propagate via
-			// involvedThisWave only — no fn fire if their value unchanged.
-			for (const childId of this.children.get(rec.id) ?? []) {
-				const child = this.requireNode(childId);
-				if (!child.involvedThisWave) {
-					child.involvedThisWave = true;
-					this.queueNotify(child, [DIRTY]);
-					this.queueNotify(child, [RESOLVED]);
-					child.dirty = true;
-				}
-			}
-		}
-	}
-
-	private handlesEqual(mode: EqualsMode, a: HandleId, b: HandleId): boolean {
-		if (a === b) return true; // identity-on-handles always sufficient
-		// NO_HANDLE on either side means one of them is sentinel; treat as
-		// not-equal without crossing the boundary. Custom equals never sees
-		// a sentinel — handles passed to it always reference real values.
-		if (a === NO_HANDLE || b === NO_HANDLE) return false;
-		if (mode.kind === "identity") return false;
-		return this.binding.customEquals(mode.handle, a, b);
-	}
-
-	private deliverDataToConsumer(consumer: NodeRecord, depIdx: number, handle: HandleId): void {
-		consumer.depHandles[depIdx] = handle;
-		consumer.involvedThisWave = true;
-		// Static derived: any dep update fires fn (subject to first-run gate).
-		// Dynamic: only updates on tracked deps fire fn. Untracked dep updates
-		// still flow through cache (so a future fire sees the latest), but
-		// don't re-schedule fn this wave. This is the L2.11 selective-deps
-		// invariant: rule "fn fires but equals absorption prevents downstream
-		// propagation" simplifies to "fn doesn't fire at all" under handles.
-		if (consumer.kind === "derived") {
-			this.pendingFires.add(consumer.id);
-		} else if (consumer.kind === "dynamic") {
-			// First fire ever → must run regardless of tracked set
-			// (fn hasn't yet had a chance to declare its tracked deps).
-			if (!consumer.hasFiredOnce || consumer.tracked.has(depIdx)) {
-				this.pendingFires.add(consumer.id);
-			}
-		}
-	}
-
-	// -------------------------------------------------------------------
-	// Subscriber notification — buffered to wave end
-	// -------------------------------------------------------------------
-
-	private queueNotify(rec: NodeRecord, msg: Message): void {
-		if (rec.subscribers.size === 0) return;
-		let buf = this.pendingNotify.get(rec.id);
-		if (!buf) {
-			buf = [];
-			this.pendingNotify.set(rec.id, buf);
-		}
-		buf.push(msg);
-	}
-
-	private flushNotifications(): void {
-		// Stable iteration: we want children to receive parent's wave-close
-		// before they fire. But by the time we reach `flushNotifications`,
-		// all fns have already fired in the drain loop, so order doesn't
-		// affect observable fn behavior — only the order subscribers see
-		// distinct nodes' messages.
-		for (const [nodeId, msgs] of this.pendingNotify) {
-			const rec = this.requireNode(nodeId);
-			for (const sink of rec.subscribers) {
-				sink(msgs);
-			}
-		}
-		this.pendingNotify.clear();
-	}
-
-	// -------------------------------------------------------------------
-	// Helpers
-	// -------------------------------------------------------------------
-
-	private allocId(): NodeId {
-		return this.nextNodeId++ as NodeId;
-	}
-
-	private requireNode(id: NodeId): NodeRecord {
-		const rec = this.nodes.get(id);
-		if (!rec) throw new Error(`unknown node ${id}`);
-		return rec;
-	}
-
-	// -------------------------------------------------------------------
-	// Inspection (for tests + Phase 13.6 audit data — pure-Rust analog
-	// would be `describe()` over the same fields)
-	// -------------------------------------------------------------------
-
-	cacheOf(id: NodeId): HandleId {
-		return this.requireNode(id).cache;
-	}
-	hasFiredOnce(id: NodeId): boolean {
-		return this.requireNode(id).hasFiredOnce;
-	}
-}
diff --git a/packages/pure-ts/src/__experiments__/handle-core/extensions.test.ts b/packages/pure-ts/src/__experiments__/handle-core/extensions.test.ts
deleted file mode 100644
index f044529f..00000000
--- a/packages/pure-ts/src/__experiments__/handle-core/extensions.test.ts
+++ /dev/null
@@ -1,170 +0,0 @@
-/**
- * Tests for the prototype extensions added in the second pass:
- *
- *   - FFI cost counters (invokeFn / customEquals / releaseHandle)
- *   - Dynamic node analogue (selective deps via `tracked()`)
- *   - Refcount snapshot for leak detection
- *
- * These directly answer brainstorm questions:
- *   "Does identity-equals stay zero-FFI on the equality path?"
- *   "How many FFI crossings does a typical wave actually require?"
- *   "Does selective-deps in dynamic nodes save fires?"
- */
-
-import { describe, expect, it } from "vitest";
-import { HandleRuntime, tracked } from "./bindings.js";
-
-describe("FFI cost counters — boundary crossing accounting", () => {
-	it("identity-equals graph crosses customEquals ZERO times", () => {
-		const rt = new HandleRuntime();
-		const a = rt.state(1);
-		const b = rt.state(2);
-		const sum = rt.derived([a, b], (av: number, bv: number) => av + bv);
-		const events: number[] = [];
-		rt.subscribe(sum, (e) => {
-			if (e.tag === "data") events.push(e.value);
-		});
-		a.set(10);
-		b.set(20);
-		a.set(10); // identity hit — RESOLVED
-		const ffi = rt.ffiCounters();
-		expect(ffi.customEquals).toBe(0); // identity-equals never crosses
-		expect(ffi.invokeFn).toBeGreaterThan(0);
-	});
-
-	it("custom-equals graph crosses customEquals exactly once per non-identity emit", () => {
-		const rt = new HandleRuntime();
-		const src = rt.state(1);
-		const wrap = rt.derived([src], (v: number) => ({ kind: v < 10 ? "small" : "big" }), {
-			equals: (x: { kind: string }, y: { kind: string }) => x.kind === y.kind,
-		});
-		rt.subscribe(wrap, () => {});
-		rt.resetCounters();
-		src.set(2); // produces fresh object → customEquals called once
-		src.set(3);
-		src.set(4);
-		const ffi = rt.ffiCounters();
-		// Exactly one customEquals call per fresh object emission.
-		expect(ffi.customEquals).toBe(3);
-	});
-
-	it("invokeFn count = number of fn fires (one per fire, never more)", () => {
-		const rt = new HandleRuntime();
-		const a = rt.state(1);
-		const b = rt.state(2);
-		const sum = rt.derived([a, b], (av: number, bv: number) => av + bv);
-		const product = rt.derived([a, b], (av: number, bv: number) => av * bv);
-		// Subscribe both — each derived fires once on activation
-		rt.subscribe(sum, () => {});
-		rt.subscribe(product, () => {});
-		const baseline = rt.ffiCounters().invokeFn;
-		expect(baseline).toBeGreaterThan(0);
-		rt.resetCounters();
-		// Update root once — both derived should fire exactly once
-		a.set(10);
-		const ffi = rt.ffiCounters();
-		expect(ffi.invokeFn).toBe(2); // sum + product, one fire each
-	});
-
-	it("releaseHandle count tracks cache replacements", () => {
-		const rt = new HandleRuntime();
-		const s = rt.state(1);
-		rt.subscribe(s, () => {});
-		rt.resetCounters();
-		s.set(2);
-		s.set(3);
-		s.set(4);
-		// Each set replaces the cached handle → 3 releases of the prior cache.
-		expect(rt.ffiCounters().releaseHandle).toBe(3);
-	});
-});
-
-describe("Dynamic node — selective deps via tracked()", () => {
-	it("untracked dep updates do not fire fn", () => {
-		const rt = new HandleRuntime();
-		const a = rt.state(1);
-		const b = rt.state(100);
-		let fnCalls = 0;
-		// fn reads only a; declares only dep 0 as tracked.
-		const sel = rt.dynamic([a, b], (av: number, _bv: number) => {
-			fnCalls++;
-			return tracked(av * 2, [0]);
-		});
-		rt.subscribe(sel, () => {});
-		expect(fnCalls).toBe(1); // initial activation
-		const baseline = fnCalls;
-		// Update untracked dep b — fn must NOT fire
-		b.set(200);
-		expect(fnCalls).toBe(baseline);
-		// Update tracked dep a — fn fires
-		a.set(5);
-		expect(fnCalls).toBe(baseline + 1);
-		expect(sel.current()).toBe(10);
-	});
-
-	it("dynamic node sees fewer FFI invokeFn calls than equivalent static derived", () => {
-		// Same topology, two implementations. Update an unused dep N times.
-		const rt = new HandleRuntime();
-		const a = rt.state(1);
-		const unused = rt.state(0);
-		const staticDerived = rt.derived([a, unused], (av: number, _u: number) => av + 1);
-		const dynamicSelective = rt.dynamic([a, unused], (av: number, _u: number) =>
-			tracked(av + 1, [0]),
-		);
-		rt.subscribe(staticDerived, () => {});
-		rt.subscribe(dynamicSelective, () => {});
-		rt.resetCounters();
-		// Update unused 5 times — static fires 5 times (then equals dedups
-		// downstream), dynamic fires 0 times.
-		for (let i = 1; i <= 5; i++) unused.set(i);
-		const ffi = rt.ffiCounters();
-		// Static derived was hit 5 times; dynamic was hit 0 times.
-		// Total invokeFn should equal 5 (only the static one fires).
-		expect(ffi.invokeFn).toBe(5);
-	});
-
-	it("dynamic node reading all deps behaves like static derived", () => {
-		const rt = new HandleRuntime();
-		const a = rt.state(1);
-		const b = rt.state(2);
-		const sum = rt.dynamic([a, b], (av: number, bv: number) => tracked(av + bv, [0, 1]));
-		rt.subscribe(sum, () => {});
-		expect(sum.current()).toBe(3);
-		a.set(10);
-		expect(sum.current()).toBe(12);
-		b.set(20);
-		expect(sum.current()).toBe(30);
-	});
-});
-
-describe("Refcount / leak detection", () => {
-	it("steady-state graph has bounded handle count", () => {
-		const rt = new HandleRuntime();
-		const a = rt.state(0);
-		const dbl = rt.derived([a], (v: number) => v * 2);
-		rt.subscribe(dbl, () => {});
-		const baseline = rt.debug().liveHandles;
-		// Run many updates — handle count should stay bounded.
-		for (let i = 1; i <= 20; i++) a.set(i);
-		const after = rt.debug().liveHandles;
-		// We expect ~2 live handles steady state: a's current cache + dbl's
-		// current cache. The exact number depends on intern timing but should
-		// be far less than 20.
-		expect(after).toBeLessThan(5);
-		expect(after).toBeGreaterThanOrEqual(baseline);
-	});
-
-	it("refcount snapshot reports refcounts per handle", () => {
-		const rt = new HandleRuntime();
-		const a = rt.state({ x: 1 });
-		const b = rt.state({ x: 1 }); // distinct object → distinct handle
-		rt.subscribe(a, () => {});
-		rt.subscribe(b, () => {});
-		const snap = rt.debug().snapshot;
-		expect(snap.handles).toBeGreaterThanOrEqual(2);
-		// Refcount entries exist for each live handle.
-		for (const [, count] of snap.refcounts) {
-			expect(count).toBeGreaterThan(0);
-		}
-	});
-});
diff --git a/packages/pure-ts/src/__experiments__/r8-poc/baseline.ts b/packages/pure-ts/src/__experiments__/r8-poc/baseline.ts
deleted file mode 100644
index 981f67e3..00000000
--- a/packages/pure-ts/src/__experiments__/r8-poc/baseline.ts
+++ /dev/null
@@ -1,35 +0,0 @@
-/**
- * Baseline variant — fn is a member field on the node, called directly.
- * Mirrors how current pure-ts stores `_fn` on the Node instance.
- */
-
-import { type Actions, type Ctx, type Fn, TinyNode } from "./protocol.js";
-
-export class BaselineNode<T> extends TinyNode<T> {
-	private _fn: Fn<T> | null;
-
-	constructor(deps: TinyNode<unknown>[], fn?: Fn<T>, initial?: T) {
-		super(deps);
-		this._fn = fn ?? null;
-		if (initial !== undefined) {
-			this._hasData = true;
-			this._cache = initial;
-		}
-	}
-
-	protected _invokeFn(
-		batchData: ReadonlyArray<unknown[] | null>,
-		actions: Actions<T>,
-		ctx: Ctx,
-	): void {
-		if (this._fn !== null) this._fn(batchData, actions, ctx);
-	}
-}
-
-export function baselineNode<T>(
-	deps: TinyNode<unknown>[],
-	fn?: Fn<T>,
-	initial?: T,
-): BaselineNode<T> {
-	return new BaselineNode(deps, fn, initial);
-}
diff --git a/packages/pure-ts/src/__experiments__/r8-poc/protocol.ts b/packages/pure-ts/src/__experiments__/r8-poc/protocol.ts
deleted file mode 100644
index a06d1c72..00000000
--- a/packages/pure-ts/src/__experiments__/r8-poc/protocol.ts
+++ /dev/null
@@ -1,177 +0,0 @@
-/**
- * R8 PoC — minimal reactive protocol with abstract fn invocation.
- *
- * The protocol matches pure-ts's hot path (DIRTY/DATA two-phase wave; fan-in
- * counter for diamond resolution; push-on-subscribe for cached state). Only
- * the fn-invocation step is left abstract — subclasses decide whether the
- * fn is a member field (Baseline) or looked up in an external dispatcher
- * pool by handle (R8).
- *
- * Apples-to-apples bench: same protocol code path, only fn dispatch differs.
- *
- * Out of scope (irrelevant to R8 dispatch cost):
- *   - RESOLVED / INVALIDATE messages
- *   - PAUSE / RESUME locks
- *   - equals-substitution short-circuits
- *   - Producers, effects, ERROR/COMPLETE
- *   - batch() (handled by callers if needed)
- *   - dynamic deps / autoTrack
- */
-
-export type DataMsg<T = unknown> = readonly ["DATA", T];
-export type DirtyMsg = readonly ["DIRTY"];
-export type Message<T = unknown> = DirtyMsg | DataMsg<T>;
-
-export type Sink<T = unknown> = (msg: Message<T>) => void;
-
-export type Actions<T> = {
-	emit(v: T): void;
-};
-
-export type Ctx = {
-	prevData: readonly unknown[];
-};
-
-export type Fn<T> = (
-	batchData: ReadonlyArray<unknown[] | null>,
-	actions: Actions<T>,
-	ctx: Ctx,
-) => void;
-
-/** Sentinel for "this dep hasn't emitted DATA yet". */
-const NO_DATA = Symbol("NO_DATA");
-
-export abstract class TinyNode<T> {
-	protected _deps: TinyNode<unknown>[];
-	protected _subscribers: Sink<T>[] = [];
-	protected _depData: unknown[];
-	protected _depPrevData: unknown[];
-	protected _depDirtyFlags: boolean[];
-	protected _depPendingCount = 0;
-	protected _emittedDirtyThisWave = false;
-	protected _insideRunWave = false;
-	_hasData = false;
-	_cache: T | undefined;
-
-	constructor(deps: TinyNode<unknown>[]) {
-		this._deps = deps;
-		this._depData = deps.map(() => NO_DATA as unknown);
-		this._depPrevData = deps.map(() => NO_DATA as unknown);
-		this._depDirtyFlags = deps.map(() => false);
-
-		// Wire ourselves as subscribers to each dep, capturing dep index.
-		for (let i = 0; i < deps.length; i++) {
-			const idx = i;
-			deps[i]._subscribers.push((msg) => this._receiveFromDep(idx, msg));
-			// Seed initial value if dep already has cached data.
-			if (deps[i]._hasData) {
-				this._depData[idx] = deps[i]._cache;
-				this._depPrevData[idx] = deps[i]._cache;
-			}
-		}
-	}
-
-	/** Subclass-defined fn invocation — the one variation that R8 tests. */
-	protected abstract _invokeFn(
-		batchData: ReadonlyArray<unknown[] | null>,
-		actions: Actions<T>,
-		ctx: Ctx,
-	): void;
-
-	/** Wave receive from upstream dep. */
-	private _receiveFromDep(idx: number, msg: Message): void {
-		if (msg[0] === "DIRTY") {
-			if (!this._depDirtyFlags[idx]) {
-				this._depDirtyFlags[idx] = true;
-				this._depPendingCount++;
-				// Propagate DIRTY downstream exactly once per wave.
-				if (!this._emittedDirtyThisWave) {
-					this._emittedDirtyThisWave = true;
-					this._emitDirty();
-				}
-			}
-		} else {
-			// DATA
-			this._depData[idx] = msg[1];
-			if (this._depDirtyFlags[idx]) {
-				this._depDirtyFlags[idx] = false;
-				this._depPendingCount--;
-				if (this._depPendingCount === 0) {
-					this._runWave();
-				}
-			}
-		}
-	}
-
-	private _runWave(): void {
-		const actions: Actions<T> = {
-			emit: (v: T) => {
-				// If actions.emit is called AFTER _runWave returned (i.e. from
-				// an async fn's deferred callback), our subscribers have already
-				// cleared the DIRTY from this wave (we emitted DIRTY at wave start,
-				// but never DATA in time). So we need to re-DIRTY them before the
-				// DATA so the (DIRTY, DATA) pair is well-formed. When called
-				// synchronously inside fn, _insideRunWave is true → DIRTY already
-				// in flight, skip.
-				if (!this._insideRunWave) {
-					this._emitDirty();
-				}
-				this._hasData = true;
-				this._cache = v;
-				this._emitData(v);
-			},
-		};
-		const ctx: Ctx = { prevData: this._depPrevData };
-		// batchData shape mirrors pure-ts's Array<batch | null>: a non-null
-		// single-element array signals "fresh DATA this wave for that dep."
-		const batchData: ReadonlyArray<unknown[] | null> = this._depData.map((v) =>
-			v === NO_DATA ? null : [v],
-		);
-		this._insideRunWave = true;
-		this._invokeFn(batchData, actions, ctx);
-		this._insideRunWave = false;
-
-		// Roll prevData forward. Reset wave-local flags.
-		for (let i = 0; i < this._depData.length; i++) {
-			this._depPrevData[i] = this._depData[i];
-		}
-		this._emittedDirtyThisWave = false;
-	}
-
-	private _emitDirty(): void {
-		const subs = this._subscribers;
-		const msg: DirtyMsg = ["DIRTY"];
-		for (let i = 0; i < subs.length; i++) subs[i](msg);
-	}
-
-	private _emitData(v: T): void {
-		const subs = this._subscribers;
-		const msg: DataMsg<T> = ["DATA", v];
-		for (let i = 0; i < subs.length; i++) subs[i](msg);
-	}
-
-	/** State-like external push: emit DIRTY then DATA in one tick. */
-	pushExternal(v: T): void {
-		this._hasData = true;
-		this._cache = v;
-		this._emitDirty();
-		this._emitData(v);
-		this._emittedDirtyThisWave = false;
-	}
-
-	subscribe(cb: Sink<T>): () => void {
-		this._subscribers.push(cb);
-		// Push-on-subscribe for cached data.
-		if (this._hasData) {
-			cb(["DATA", this._cache as T]);
-		}
-		return () => {
-			const i = this._subscribers.indexOf(cb);
-			if (i >= 0) this._subscribers.splice(i, 1);
-		};
-	}
-
-	get cache(): T | undefined {
-		return this._cache;
-	}
-}
diff --git a/packages/pure-ts/src/__experiments__/r8-poc/r8-async.test.ts b/packages/pure-ts/src/__experiments__/r8-poc/r8-async.test.ts
deleted file mode 100644
index a025b5f0..00000000
--- a/packages/pure-ts/src/__experiments__/r8-poc/r8-async.test.ts
+++ /dev/null
@@ -1,166 +0,0 @@
-/**
- * R8 async/remote PoC — proves the R9 claim:
- *
- *   dispatcher.invoke() is uniformly SYNC void. Async pool fns kick off work
- *   and emit results LATER via actions.emit(). The reactive graph protocol
- *   handles "late emit" correctly through the (DIRTY, DATA) pair invariant.
- *   No wave-id needed. Cross-network is identical to local-async — just a
- *   different setTimeout delay.
- */
-
-import { describe, expect, it } from "vitest";
-import type { Actions, Ctx, TinyNode } from "./protocol.js";
-import { baselineNode } from "./baseline.js";
-import {
-	dispatcher,
-	r8AsyncNode,
-	r8Node,
-	r8RemoteNode,
-} from "./r8.js";
-
-const lastOrPrev =
-	(idx: number) =>
-	(batchData: ReadonlyArray<unknown[] | null>, ctx: Ctx): number => {
-		const b = batchData[idx];
-		return (b != null && b.length > 0 ? b.at(-1) : ctx.prevData[idx]) as number;
-	};
-
-const delay = (ms: number) => new Promise<void>((r) => setTimeout(r, ms));
-
-describe("R9 — dispatcher.invoke stays sync, async fns emit later", () => {
-	it("local-async: pushExternal returns sync; DATA arrives after microtask", async () => {
-		const source = r8Node<number>([], undefined, 0);
-
-		// Async fn: doubles the input, but only emits after a Promise.resolve hop.
-		const asyncDoubler = r8AsyncNode<number>([source], (batchData, actions, ctx) => {
-			const v = lastOrPrev(0)(batchData, ctx);
-			// Kick off async work — dispatcher.invoke has ALREADY returned to wave.
-			Promise.resolve().then(() => {
-				(actions as Actions<number>).emit(v * 2);
-			});
-			// (fn returns void, no Promise leaks back to dispatcher)
-		});
-
-		const received: number[] = [];
-		asyncDoubler.subscribe((msg) => {
-			if (msg[0] === "DATA") received.push(msg[1] as number);
-		});
-
-		// SYNC: pushExternal returns immediately. No DATA yet.
-		const t0 = performance.now();
-		source.pushExternal(5);
-		const tSyncReturn = performance.now() - t0;
-
-		expect(received).toEqual([]); // No DATA emitted yet — fn is async
-		expect(tSyncReturn).toBeLessThan(1); // pushExternal is sync, sub-ms
-
-		// After microtask flush, DATA arrives.
-		await Promise.resolve();
-		await Promise.resolve();
-		expect(received).toEqual([10]);
-	});
-
-	it("simulated remote: 5ms RTT — wave protocol waits correctly", async () => {
-		const source = r8Node<number>([], undefined, 0);
-
-		const remoteTransform = r8RemoteNode<number>([source], (batchData, ctx) => {
-			const v = lastOrPrev(0)(batchData, ctx);
-			return v + 100; // sandbox-side computation
-		});
-
-		const received: number[] = [];
-		remoteTransform.subscribe((msg) => {
-			if (msg[0] === "DATA") received.push(msg[1] as number);
-		});
-
-		source.pushExternal(7);
-		expect(received).toEqual([]); // Wave kicked off, no DATA yet
-
-		await delay(15); // Wait > RTT
-		expect(received).toEqual([107]);
-	});
-
-	it("mixed sync + async diamond: D fires once after async leg resolves", async () => {
-		// A → B (sync) → D
-		// A → C (async, ~5ms) → D
-		const a = r8Node<number>([], undefined, 0);
-		const b = r8Node<number>([a], (batchData, actions, ctx) => {
-			const v = lastOrPrev(0)(batchData, ctx);
-			(actions as Actions<number>).emit(v + 1);
-		});
-		const c = r8RemoteNode<number>([a], (batchData, ctx) => {
-			const v = lastOrPrev(0)(batchData, ctx);
-			return v * 10;
-		});
-		const d = r8Node<number>(
-			[b as TinyNode<unknown>, c as TinyNode<unknown>],
-			(batchData, actions, ctx) => {
-				const x = lastOrPrev(0)(batchData, ctx);
-				const y = lastOrPrev(1)(batchData, ctx);
-				(actions as Actions<number>).emit(x + y);
-			},
-		);
-
-		const received: number[] = [];
-		d.subscribe((msg) => {
-			if (msg[0] === "DATA") received.push(msg[1] as number);
-		});
-
-		a.pushExternal(3);
-		// B has emitted DATA(4) sync to D, but D still has C dirty.
-		// fn should NOT have fired yet.
-		expect(received).toEqual([]);
-
-		await delay(15); // C resolves with 30 → D fires with 4 + 30 = 34
-		expect(received).toEqual([34]);
-	});
-
-	it("two back-to-back pushes with async leg: both results flow through", async () => {
-		const a = r8Node<number>([], undefined, 0);
-		const slow = r8RemoteNode<number>([a], (batchData, ctx) => {
-			const v = lastOrPrev(0)(batchData, ctx);
-			return v + 1000;
-		});
-
-		const received: number[] = [];
-		slow.subscribe((msg) => {
-			if (msg[0] === "DATA") received.push(msg[1] as number);
-		});
-
-		// Two pushes in quick succession. Each triggers a fresh remote call.
-		// Merge semantics: both eventually arrive.
-		a.pushExternal(1);
-		a.pushExternal(2);
-
-		await delay(20);
-		expect(received.length).toBeGreaterThanOrEqual(1);
-		// Both results should arrive — order depends on RTT consistency.
-		// We assert the SET of values rather than order.
-		expect(received).toContain(1002);
-	});
-
-	it("dispatcher.invokeRouted is verified-sync — measures < 100μs even with async fn body", async () => {
-		// Register a no-op async fn and time the dispatcher invoke step alone.
-		const noop = r8AsyncNode<number>([r8Node<number>([], undefined, 0)], () => {
-			// Don't even start async work — just return.
-		});
-
-		// Build a source with an async derived attached; measure source.pushExternal
-		// (which sync-invokes through dispatcher).
-		const source = r8Node<number>([], undefined, 0);
-		const node = r8AsyncNode<number>([source], (_b, _a, _c) => {
-			// no-op async body
-		});
-		node.subscribe(() => undefined);
-
-		const ITERS = 1000;
-		const t0 = performance.now();
-		for (let i = 0; i < ITERS; i++) source.pushExternal(i);
-		const elapsed = performance.now() - t0;
-		const perCall = (elapsed * 1000) / ITERS; // μs
-
-		expect(perCall).toBeLessThan(5); // < 5μs per push end-to-end including async dispatch
-		// Hold reference so noop isn't GC'd before bench finishes (TS-only concern)
-		void noop;
-	});
-});
diff --git a/packages/pure-ts/src/__experiments__/r8-poc/r8-poc.test.ts b/packages/pure-ts/src/__experiments__/r8-poc/r8-poc.test.ts
deleted file mode 100644
index eb6d27e6..00000000
--- a/packages/pure-ts/src/__experiments__/r8-poc/r8-poc.test.ts
+++ /dev/null
@@ -1,77 +0,0 @@
-/**
- * Sanity tests — both Baseline and R8 must produce identical output on
- * the workloads the bench measures. If they diverge, the bench is invalid.
- */
-
-import { describe, expect, it } from "vitest";
-import { baselineNode } from "./baseline.js";
-import type { Actions, Ctx, TinyNode } from "./protocol.js";
-import { r8Node } from "./r8.js";
-
-const lastOrPrev =
-	(idx: number) =>
-	(batchData: ReadonlyArray<unknown[] | null>, ctx: Ctx): unknown => {
-		const b = batchData[idx];
-		return b != null && b.length > 0 ? b.at(-1) : ctx.prevData[idx];
-	};
-
-function runDoubler(make: typeof baselineNode | typeof r8Node): number[] {
-	const a = make<number>([], undefined, 0);
-	const d = make<number>([a], (batchData, actions, ctx) => {
-		const v = lastOrPrev(0)(batchData, ctx) as number;
-		(actions as Actions<number>).emit(v * 2);
-	});
-	const received: number[] = [];
-	d.subscribe((msg) => {
-		if (msg[0] === "DATA") received.push(msg[1] as number);
-	});
-	for (let i = 1; i <= 5; i++) a.pushExternal(i);
-	return received;
-}
-
-function runDiamond(make: typeof baselineNode | typeof r8Node): number[] {
-	const a = make<number>([], undefined, 0);
-	const b = make<number>([a], (batchData, actions, ctx) => {
-		const v = lastOrPrev(0)(batchData, ctx) as number;
-		(actions as Actions<number>).emit(v + 1);
-	});
-	const c = make<number>([a], (batchData, actions, ctx) => {
-		const v = lastOrPrev(0)(batchData, ctx) as number;
-		(actions as Actions<number>).emit(v * 10);
-	});
-	const d = make<number>(
-		[b as TinyNode<unknown>, c as TinyNode<unknown>],
-		(batchData, actions, ctx) => {
-			const x = lastOrPrev(0)(batchData, ctx) as number;
-			const y = lastOrPrev(1)(batchData, ctx) as number;
-			(actions as Actions<number>).emit(x + y);
-		},
-	);
-	const received: number[] = [];
-	d.subscribe((msg) => {
-		if (msg[0] === "DATA") received.push(msg[1] as number);
-	});
-	for (let i = 1; i <= 3; i++) a.pushExternal(i);
-	return received;
-}
-
-describe("R8 PoC parity", () => {
-	it("doubler chain matches between baseline and r8", () => {
-		const base = runDoubler(baselineNode);
-		const r8 = runDoubler(r8Node);
-		expect(r8).toEqual(base);
-		// Derived has not run a wave at subscribe time, so no push-on-subscribe.
-		// Each pushExternal(i) triggers one wave → one DATA emission.
-		expect(base).toEqual([2, 4, 6, 8, 10]);
-	});
-
-	it("diamond fan-in matches", () => {
-		const base = runDiamond(baselineNode);
-		const r8 = runDiamond(r8Node);
-		expect(r8).toEqual(base);
-		// Diamond fires d.fn once per wave: (a+1) + (a*10)
-		// No initial wave → no push-on-subscribe value.
-		// push 1: 2 + 10 = 12; push 2: 3 + 20 = 23; push 3: 4 + 30 = 34
-		expect(base).toEqual([12, 23, 34]);
-	});
-});
diff --git a/packages/pure-ts/src/__experiments__/r8-poc/r8.ts b/packages/pure-ts/src/__experiments__/r8-poc/r8.ts
deleted file mode 100644
index 12ad2832..00000000
--- a/packages/pure-ts/src/__experiments__/r8-poc/r8.ts
+++ /dev/null
@@ -1,283 +0,0 @@
-/**
- * R8 variant — fn lives in an external dispatcher pool, indexed by handle.
- * Node holds only `_poolRef = (poolId, handleId)`. Wave invocation is
- * `dispatcher.invoke(poolRef, ...)` which is an array-indexed lookup + call.
- *
- * This is the structural shape the user's R8 model proposes: fn fully
- * decoupled from the graph; pool decides sync/async at the call site.
- */
-
-import { type Actions, type Ctx, type Fn, TinyNode } from "./protocol.js";
-
-// Pool kinds. Only LocalSync is exercised in this PoC — that's the
-// hot-path R6 target. LocalAsync etc. measured separately in
-// r8-dispatch-overhead.bench.ts.
-export type PoolId = number;
-
-type AnyFn = Fn<unknown>;
-
-class LocalSyncPool {
-	private fns: AnyFn[] = [];
-
-	register(fn: AnyFn): number {
-		const id = this.fns.length;
-		this.fns.push(fn);
-		return id;
-	}
-
-	// Hot path — must compile to array-index + call. No null check on the
-	// handle because dispatcher routes only to registered handles.
-	invoke(
-		handle: number,
-		batchData: ReadonlyArray<unknown[] | null>,
-		actions: Actions<unknown>,
-		ctx: Ctx,
-	): void {
-		this.fns[handle](batchData, actions, ctx);
-	}
-}
-
-/**
- * LocalAsyncPool — fn registered here is "deferred-emit" by convention.
- * dispatcher.invoke is still SYNC void; the fn kicks off async work and
- * emits the result later via `actions.emit(v)`. The protocol's
- * `_insideRunWave` flag ensures the late emit pairs DIRTY+DATA correctly.
- *
- * Implementation note: this pool is structurally identical to LocalSyncPool
- * — same fn[] table, same array-index dispatch. The "async" nature lives
- * in the fn's own body, not in the pool's invoke. This validates the R9
- * claim: dispatcher.invoke is uniformly sync; pool kind is a label that
- * documents fn behavior, not a different call mechanism.
- */
-class LocalAsyncPool {
-	private fns: AnyFn[] = [];
-
-	register(fn: AnyFn): number {
-		const id = this.fns.length;
-		this.fns.push(fn);
-		return id;
-	}
-
-	invoke(
-		handle: number,
-		batchData: ReadonlyArray<unknown[] | null>,
-		actions: Actions<unknown>,
-		ctx: Ctx,
-	): void {
-		this.fns[handle](batchData, actions, ctx);
-	}
-}
-
-/**
- * SimulatedRemotePool — same as LocalAsync structurally, but the registered
- * fn is a "remote stub" that simulates network RTT via setTimeout. Proves
- * the protocol works across an asynchronous boundary that LOOKS like RPC.
- *
- * The user-facing fn passed to `registerRemote` is the sandbox-side logic
- * (what would actually run on the other end). This pool wraps it with a
- * setTimeout to simulate the RTT.
- */
-class SimulatedRemotePool {
-	private fns: AnyFn[] = [];
-	rttMs: number;
-
-	constructor(rttMs = 5) {
-		this.rttMs = rttMs;
-	}
-
-	registerRemote<T>(
-		sandboxFn: (
-			batchData: ReadonlyArray<unknown[] | null>,
-			ctx: Ctx,
-		) => T,
-	): number {
-		const id = this.fns.length;
-		const wrapper: AnyFn = (batchData, actions, ctx) => {
-			// Simulate sending request → wait RTT → result comes back.
-			// Two setTimeouts mimic the two legs of a real RPC.
-			setTimeout(() => {
-				const result = sandboxFn(batchData, ctx);
-				actions.emit(result);
-			}, this.rttMs);
-		};
-		this.fns.push(wrapper);
-		return id;
-	}
-
-	invoke(
-		handle: number,
-		batchData: ReadonlyArray<unknown[] | null>,
-		actions: Actions<unknown>,
-		ctx: Ctx,
-	): void {
-		this.fns[handle](batchData, actions, ctx);
-	}
-}
-
-export type PoolKind = "sync" | "async" | "remote";
-
-export class Dispatcher {
-	private localSyncPools: LocalSyncPool[] = [new LocalSyncPool()];
-	private localAsyncPools: LocalAsyncPool[] = [new LocalAsyncPool()];
-	private remotePools: SimulatedRemotePool[] = [new SimulatedRemotePool(5)];
-
-	pool(id: PoolId = 0): LocalSyncPool {
-		return this.localSyncPools[id];
-	}
-
-	asyncPool(id: PoolId = 0): LocalAsyncPool {
-		return this.localAsyncPools[id];
-	}
-
-	remotePool(id: PoolId = 0): SimulatedRemotePool {
-		return this.remotePools[id];
-	}
-
-	// Single uniform sync invoke entry point — routes by pool kind.
-	invokeRouted(
-		kind: PoolKind,
-		poolId: PoolId,
-		handle: number,
-		batchData: ReadonlyArray<unknown[] | null>,
-		actions: Actions<unknown>,
-		ctx: Ctx,
-	): void {
-		switch (kind) {
-			case "sync":
-				this.localSyncPools[poolId].invoke(handle, batchData, actions, ctx);
-				return;
-			case "async":
-				this.localAsyncPools[poolId].invoke(handle, batchData, actions, ctx);
-				return;
-			case "remote":
-				this.remotePools[poolId].invoke(handle, batchData, actions, ctx);
-				return;
-		}
-	}
-}
-
-// Shared dispatcher for the bench (matches the "global dispatcher per Impl"
-// shape the eventual design would take).
-export const dispatcher = new Dispatcher();
-
-type PoolRef = { kind: PoolKind; poolId: PoolId; handle: number };
-
-export class R8Node<T> extends TinyNode<T> {
-	private _poolRef: PoolRef | null;
-
-	constructor(deps: TinyNode<unknown>[], fn?: Fn<T>, initial?: T) {
-		super(deps);
-		if (fn !== undefined) {
-			const handle = dispatcher.pool(0).register(fn as AnyFn);
-			this._poolRef = { kind: "sync", poolId: 0, handle };
-		} else {
-			this._poolRef = null;
-		}
-		if (initial !== undefined) {
-			this._hasData = true;
-			this._cache = initial;
-		}
-	}
-
-	protected _invokeFn(
-		batchData: ReadonlyArray<unknown[] | null>,
-		actions: Actions<T>,
-		ctx: Ctx,
-	): void {
-		const ref = this._poolRef;
-		if (ref !== null) {
-			dispatcher.invokeRouted(
-				ref.kind,
-				ref.poolId,
-				ref.handle,
-				batchData,
-				actions as Actions<unknown>,
-				ctx,
-			);
-		}
-	}
-}
-
-export function r8Node<T>(deps: TinyNode<unknown>[], fn?: Fn<T>, initial?: T): R8Node<T> {
-	return new R8Node(deps, fn, initial);
-}
-
-/**
- * Async-pool variant — fn is registered in LocalAsyncPool. The fn body is
- * expected to start async work and call actions.emit(v) when done.
- */
-export class R8AsyncNode<T> extends TinyNode<T> {
-	private _poolRef: PoolRef;
-
-	constructor(deps: TinyNode<unknown>[], fn: Fn<T>) {
-		super(deps);
-		const handle = dispatcher.asyncPool(0).register(fn as AnyFn);
-		this._poolRef = { kind: "async", poolId: 0, handle };
-	}
-
-	protected _invokeFn(
-		batchData: ReadonlyArray<unknown[] | null>,
-		actions: Actions<T>,
-		ctx: Ctx,
-	): void {
-		dispatcher.invokeRouted(
-			this._poolRef.kind,
-			this._poolRef.poolId,
-			this._poolRef.handle,
-			batchData,
-			actions as Actions<unknown>,
-			ctx,
-		);
-	}
-}
-
-export function r8AsyncNode<T>(deps: TinyNode<unknown>[], fn: Fn<T>): R8AsyncNode<T> {
-	return new R8AsyncNode(deps, fn);
-}
-
-/**
- * Remote-pool variant — fn is registered as a "sandbox-side" pure transform
- * (batchData + ctx → result). The remote pool wraps it with a simulated RTT.
- * User-facing API never deals with the wire — just registers what would run
- * on the other side.
- */
-export class R8RemoteNode<T> extends TinyNode<T> {
-	private _poolRef: PoolRef;
-
-	constructor(
-		deps: TinyNode<unknown>[],
-		sandboxFn: (
-			batchData: ReadonlyArray<unknown[] | null>,
-			ctx: Ctx,
-		) => T,
-	) {
-		super(deps);
-		const handle = dispatcher.remotePool(0).registerRemote(sandboxFn);
-		this._poolRef = { kind: "remote", poolId: 0, handle };
-	}
-
-	protected _invokeFn(
-		batchData: ReadonlyArray<unknown[] | null>,
-		actions: Actions<T>,
-		ctx: Ctx,
-	): void {
-		dispatcher.invokeRouted(
-			this._poolRef.kind,
-			this._poolRef.poolId,
-			this._poolRef.handle,
-			batchData,
-			actions as Actions<unknown>,
-			ctx,
-		);
-	}
-}
-
-export function r8RemoteNode<T>(
-	deps: TinyNode<unknown>[],
-	sandboxFn: (
-		batchData: ReadonlyArray<unknown[] | null>,
-		ctx: Ctx,
-	) => T,
-): R8RemoteNode<T> {
-	return new R8RemoteNode(deps, sandboxFn);
-}
diff --git a/packages/pure-ts/src/__tests__/core/__snapshots__/multi-message-delivery.test.ts.snap b/packages/pure-ts/src/__tests__/core/__snapshots__/multi-message-delivery.test.ts.snap
deleted file mode 100644
index 5aa93163..00000000
--- a/packages/pure-ts/src/__tests__/core/__snapshots__/multi-message-delivery.test.ts.snap
+++ /dev/null
@@ -1,100 +0,0 @@
-// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
-
-exports[`multi-message delivery — fn-run contract > diamond: K emits inside batch — fan-in D's fn-run count (the K+1 finding) 1`] = `
-{
-  "finalD": 14,
-  "runCount": 1,
-  "runs": [
-    [
-      [
-        2,
-      ],
-      [
-        12,
-      ],
-    ],
-  ],
-}
-`;
-
-exports[`multi-message delivery — fn-run contract > single-dep: K emits inside batch — documents current fn-run count at derived 1`] = `
-{
-  "runCount": 1,
-  "runs": [
-    [
-      [
-        1,
-        2,
-        3,
-      ],
-    ],
-  ],
-}
-`;
-
-exports[`multi-message delivery — fn-run contract > single-dep: multi-DATA .down() on source fires derived fn per message today (design intent: once) 1`] = `
-{
-  "runCount": 1,
-  "runs": [
-    [
-      [
-        10,
-        20,
-        30,
-      ],
-    ],
-  ],
-}
-`;
-
-exports[`multi-message delivery — fn-run contract > single-dep: source.emit() three times outside batch fires fn three times (one per wave) 1`] = `
-{
-  "runCount": 3,
-  "runs": [
-    [
-      [
-        1,
-      ],
-    ],
-    [
-      [
-        2,
-      ],
-    ],
-    [
-      [
-        3,
-      ],
-    ],
-  ],
-}
-`;
-
-exports[`multi-message delivery — subscriber batch structure > derived's own subscriber sees multi-DATA from a single source .down() as how many sink calls? 1`] = `
-{
-  "calls": [
-    [
-      [
-        "graphrefly/DIRTY",
-        undefined,
-      ],
-    ],
-    [
-      [
-        "graphrefly/DATA",
-        30,
-      ],
-    ],
-  ],
-  "sinkCallCount": 2,
-}
-`;
-
-exports[`multi-message delivery — subscriber batch structure > diamond: K=2 emits in batch — per-node sink call counts 1`] = `
-{
-  "a": 2,
-  "b": 2,
-  "c": 2,
-  "d": 2,
-}
-`;
diff --git a/packages/pure-ts/src/__tests__/core/first-run-gate.test.ts b/packages/pure-ts/src/__tests__/core/first-run-gate.test.ts
deleted file mode 100644
index 7d4b8e91..00000000
--- a/packages/pure-ts/src/__tests__/core/first-run-gate.test.ts
+++ /dev/null
@@ -1,293 +0,0 @@
-/**
- * DS-2.7.A — first-run gate cross-port lock (spec §2.7).
- *
- * Pins the four normative rules locked 2026-05-19 in
- * `archive/docs/SESSION-DS-2.7.A-first-run-gate.md`:
- *
- * - `R2.7.0` — RESOLVED does NOT settle the gate. A dep that only ever
- *   emits RESOLVED holds the gate forever.
- * - `R2.7.1` — Terminal does NOT settle by default; Reduce-class operators
- *   opt in via `NodeOptions.terminalAsRealInput: true`.
- * - `R2.7.2` — `partial: true` truly disables the gate (the fn body MUST
- *   guard SENTINEL slots); `terminalAsRealInput` is ignored when
- *   `partial: true` (the gate is OFF either way).
- * - `R2.7.3` — Gate scope = `_hasCalledFnOnce`. INVALIDATE does NOT re-arm.
- *
- * These assertions target the bare `node()` primitive — operator-level
- * Reduce-class behavior is covered separately by the existing
- * `operators.test.ts` `reduce` / `last` / `take` suites, and by the
- * cross-impl behavioral parity scenario at
- * `packages/parity-tests/scenarios/core/first-run-gate.test.ts`.
- *
- * **`ctx.prevData[i]` reflects the END of the *previous* wave** (see
- * `node.ts:2810` — snapshot taken BEFORE this wave's commit). For the
- * *current* wave's value, read `data[i]?.at(-1)` (the fn's first
- * argument) per the documented contract. Combined access pattern:
- * `data[i]?.at(-1) ?? ctx.prevData[i]`.
- *
- * @module
- */
-
-import { describe, expect, it } from "vitest";
-import { COMPLETE, ERROR, INVALIDATE, RESOLVED } from "../../core/messages.js";
-import { node } from "../../core/node.js";
-
-/** Convenience: "current value of dep i this fn-fire" — DATA this wave with
- * prevData fallback. Mirrors `dynamicNode`'s unwrap (`core/sugar.ts:91-101`).
- * (`graph.derived` passes raw `batchData` to the user fn — it does NOT
- * unwrap; only `dynamicNode`/`autoTrackNode` do.) Correctness relies on the
- * spec §1.2 invariant that `undefined` is never a valid DATA payload — if a
- * batch is non-empty its last element is the real DATA value, never the
- * SENTINEL. */
-function currentOf(
-	data: readonly (readonly unknown[] | undefined)[],
-	prevData: readonly unknown[],
-	i: number,
-): unknown {
-	const batch = data[i];
-	if (batch != null && batch.length > 0) return batch[batch.length - 1];
-	return prevData[i];
-}
-
-describe("DS-2.7.A R2.7.0 — RESOLVED does NOT settle the first-run gate", () => {
-	it("a dep that only ever emits RESOLVED keeps fn gated forever", () => {
-		const ready = node<number>([], { initial: 1 });
-		const resolvedOnly = node<number>(); // sentinel forever from this side
-		const fired: Array<unknown> = [];
-		const out = node<unknown>([ready, resolvedOnly], (data, a, ctx) => {
-			fired.push([currentOf(data, ctx.prevData, 0), currentOf(data, ctx.prevData, 1)]);
-			a.emit(true);
-		});
-		const unsub = out.subscribe(() => undefined);
-		try {
-			// Direct RESOLVED on `resolvedOnly` — explicitly NOT a DATA delivery.
-			resolvedOnly.down([[RESOLVED]]);
-			// ready has cached DATA via push-on-subscribe; resolvedOnly only
-			// ever sent RESOLVED — gate must HOLD.
-			expect(fired).toHaveLength(0);
-		} finally {
-			unsub();
-		}
-	});
-
-	it("once the RESOLVED-only dep finally emits DATA, fn fires once", () => {
-		const ready = node<number>([], { initial: 1 });
-		const slow = node<number>();
-		const fired: Array<[unknown, unknown]> = [];
-		const out = node<unknown>([ready, slow], (data, a, ctx) => {
-			fired.push([currentOf(data, ctx.prevData, 0), currentOf(data, ctx.prevData, 1)]);
-			a.emit(true);
-		});
-		const unsub = out.subscribe(() => undefined);
-		try {
-			slow.down([[RESOLVED]]); // gate still held
-			expect(fired).toHaveLength(0);
-			slow.emit(7); // real DATA — releases the gate
-			expect(fired).toEqual([[1, 7]]);
-		} finally {
-			unsub();
-		}
-	});
-});
-
-describe("DS-2.7.A R2.7.1 — terminal does NOT settle the gate by default", () => {
-	it("default (no terminalAsRealInput): COMPLETE-only dep holds the gate", () => {
-		const ready = node<number>([], { initial: 1 });
-		const completeOnly = node<number>(); // will COMPLETE without ever emitting DATA
-		const fired: Array<unknown> = [];
-		const out = node<unknown>([ready, completeOnly], (_data, a) => {
-			fired.push(true);
-			a.emit(true);
-		});
-		const unsub = out.subscribe(() => undefined);
-		try {
-			completeOnly.down([[COMPLETE]]);
-			expect(fired).toHaveLength(0);
-		} finally {
-			unsub();
-		}
-	});
-
-	it("default: ERROR-only dep also holds the gate (terminal !== DATA)", () => {
-		const ready = node<number>([], { initial: 1 });
-		const errorOnly = node<number>();
-		const fired: Array<unknown> = [];
-		// `errorWhenDepsError: false` so the gate-holds path is observed
-		// rather than the ERROR-propagation path tearing the wave first.
-		const out = node<unknown>(
-			[ready, errorOnly],
-			(_data, a) => {
-				fired.push(true);
-				a.emit(true);
-			},
-			{ errorWhenDepsError: false },
-		);
-		const unsub = out.subscribe(() => undefined);
-		try {
-			errorOnly.down([[ERROR, new Error("boom")]]);
-			expect(fired).toHaveLength(0);
-		} finally {
-			unsub();
-		}
-	});
-
-	it("terminalAsRealInput: true — COMPLETE-only dep releases the gate", () => {
-		const ready = node<number>([], { initial: 1 });
-		const completeOnly = node<number>();
-		const fired: Array<[unknown, unknown, unknown]> = [];
-		const out = node<unknown>(
-			[ready, completeOnly],
-			(data, a, ctx) => {
-				fired.push([
-					currentOf(data, ctx.prevData, 0),
-					currentOf(data, ctx.prevData, 1),
-					ctx.terminalDeps[1],
-				]);
-				a.emit(true);
-			},
-			{ terminalAsRealInput: true, completeWhenDepsComplete: false },
-		);
-		const unsub = out.subscribe(() => undefined);
-		try {
-			completeOnly.down([[COMPLETE]]);
-			expect(fired).toHaveLength(1);
-			expect(fired[0]?.[0]).toBe(1); // ready cached DATA carried over
-			expect(fired[0]?.[1]).toBeUndefined(); // completeOnly never emitted DATA
-			expect(fired[0]?.[2]).toBe(true); // terminalDeps[1] === true (COMPLETE)
-		} finally {
-			unsub();
-		}
-	});
-});
-
-describe("DS-2.7.A R2.7.2 — partial: true disables the gate; SENTINEL must be guarded by fn body", () => {
-	it("partial: true fires fn on a SENTINEL dep slot (prevData[i] === undefined for the SENTINEL slot)", () => {
-		const a = node<number>([], { initial: 1 });
-		const b = node<number>(); // sentinel forever
-		const fired: Array<[unknown, unknown, unknown]> = [];
-		const out = node<unknown>(
-			[a, b],
-			(data, ax, ctx) => {
-				fired.push([
-					currentOf(data, ctx.prevData, 0),
-					currentOf(data, ctx.prevData, 1),
-					ctx.prevData[1],
-				]);
-				ax.emit(true);
-			},
-			{ partial: true },
-		);
-		const unsub = out.subscribe(() => undefined);
-		try {
-			// a's push-on-subscribe wave fires fn EXACTLY once even though b
-			// is sentinel — partial:true releases the gate; subsequent waves
-			// would not re-fire fn without a new dep wave.
-			expect(fired).toHaveLength(1);
-			expect(fired[0]?.[0]).toBe(1); // a delivered DATA(1) this wave
-			expect(fired[0]?.[1]).toBeUndefined(); // b never emitted — SENTINEL slot
-			expect(fired[0]?.[2]).toBeUndefined(); // and ctx.prevData[1] is the SENTINEL guard the fn body must check
-		} finally {
-			unsub();
-		}
-	});
-
-	// QA F5 (DS-2.7.A `/qa` 2026-05-20) — de-tautologized: the original test
-	// compared two `partial: true` nodes whose deps NEVER terminated, so the
-	// terminal-aware code path in the predicate was never exercised regardless
-	// of the flag value. Vacuously identical outputs do not prove the flag is
-	// ignored. This rewrite drives BOTH variants through a real terminal AFTER
-	// fn has already fired (still in the first-wave gate window — see the
-	// `out2.terminalAsRealInput:true` variant); both must observe identical
-	// terminal-handling behavior because the outer `!_partial` short-circuit
-	// at `node.ts:2689` skips the entire terminal-aware predicate.
-	it("partial: true × terminalAsRealInput is ignored — both variants behave identically across an upstream terminal", () => {
-		// Variant A: partial:true only. Variant B: partial:true + flag.
-		// If the predicate ever started consulting `_terminalAsRealInput`
-		// under `partial: true`, the two variants would diverge in the
-		// fn-fire count or in the SENTINEL slot read after the terminal.
-		function build(flag: boolean): {
-			fires: Array<[unknown, unknown]>;
-			b: ReturnType<typeof node<number>>;
-			unsub: () => void;
-		} {
-			const a = node<number>([], { initial: 1 });
-			const b = node<number>(); // sentinel, will terminate later
-			const fires: Array<[unknown, unknown]> = [];
-			const out = node<unknown>(
-				[a, b],
-				(data, ax, ctx) => {
-					fires.push([currentOf(data, ctx.prevData, 0), currentOf(data, ctx.prevData, 1)]);
-					ax.emit(true);
-				},
-				flag ? { partial: true, terminalAsRealInput: true } : { partial: true },
-			);
-			const unsub = out.subscribe(() => undefined);
-			return { fires, b, unsub };
-		}
-
-		const A = build(false);
-		const B = build(true);
-		try {
-			// Phase 1 — push-on-subscribe with a's DATA + b sentinel: BOTH
-			// variants fire exactly once with the SENTINEL slot undefined.
-			expect(A.fires).toEqual([[1, undefined]]);
-			expect(B.fires).toEqual([[1, undefined]]);
-
-			// Phase 2 — b COMPLETEs without any DATA. partial:true means
-			// the gate is OFF either way; the COMPLETE wave delivers terminal
-			// state with no DATA → fn fires per-wave only if some dep was
-			// dirty. b was dirty from push-on-subscribe handling.
-			//
-			// The critical assertion: A and B see IDENTICAL post-terminal
-			// behavior. If `terminalAsRealInput` had ANY effect under
-			// `partial: true`, B's fire count would diverge from A's.
-			A.b.down([[COMPLETE]]);
-			B.b.down([[COMPLETE]]);
-
-			expect(A.fires).toEqual(B.fires);
-		} finally {
-			A.unsub();
-			B.unsub();
-		}
-	});
-});
-
-describe("DS-2.7.A R2.7.3 — gate scope is `_hasCalledFnOnce`; INVALIDATE does not re-arm", () => {
-	it("after fn fires once, an INVALIDATE on one dep does NOT re-gate on the other still-sentinel dep", () => {
-		const a = node<number>([], { initial: 1 });
-		const b = node<number>([], { initial: 2 });
-		const fired: Array<[unknown, unknown]> = [];
-		const out = node<unknown>([a, b], (data, ax, ctx) => {
-			fired.push([currentOf(data, ctx.prevData, 0), currentOf(data, ctx.prevData, 1)]);
-			ax.emit(true);
-		});
-		const unsub = out.subscribe(() => undefined);
-		try {
-			// Initial push-on-subscribe wave from BOTH cached state nodes
-			// fires fn exactly once (combined activation; R2.7.3 + R2.7.0).
-			expect(fired).toHaveLength(1);
-			fired.length = 0;
-			// INVALIDATE `b` — clears its prevData and dataBatch. Without
-			// R2.7.3, the gate would re-arm and the next DATA on `a` would be
-			// held until `b` re-settles. R2.7.3 says: once fn has fired
-			// (`_hasCalledFnOnce`), the gate does NOT re-engage. (QA F6:
-			// tightened from `>= 1` to exact-1 to catch any double-fire
-			// regression — e.g., a future change that re-fires fn on the
-			// INVALIDATE wave plus the DATA wave.)
-			b.down([[INVALIDATE]]);
-			a.emit(7);
-			// fn re-runs on `a`'s DATA wave; gate is NOT holding it. Expect
-			// EXACTLY ONE re-fire from `a.emit(7)`.
-			expect(fired).toHaveLength(1);
-			const last = fired[0];
-			// data[0] = [7] → currentOf yields 7 (a delivered DATA this wave).
-			expect(last?.[0]).toBe(7);
-			// b slot: data[1] = undefined (not involved), ctx.prevData[1] =
-			// undefined (cleared by INVALIDATE). Both are SENTINEL — fn fired
-			// because the gate is one-shot, not because b re-settled.
-			expect(last?.[1]).toBeUndefined();
-		} finally {
-			unsub();
-		}
-	});
-});
diff --git a/packages/pure-ts/src/__tests__/core/invalidate.test.ts b/packages/pure-ts/src/__tests__/core/invalidate.test.ts
deleted file mode 100644
index 40500ec5..00000000
--- a/packages/pure-ts/src/__tests__/core/invalidate.test.ts
+++ /dev/null
@@ -1,620 +0,0 @@
-/**
- * DS-13.5.A — INVALIDATE protocol redesign tests.
- *
- * Spec: GRAPHREFLY-SPEC.md §1.3 (tier table), §2.4 (INVALIDATE settles wave),
- * §2.4a (same-wave merge rules), §2.6 (TEARDOWN auto-precedes with
- * COMPLETE/ERROR — Q16).
- *
- * The Agent 5 deadlock pattern (a single `[[INVALIDATE]]` left dependents
- * wedged in DIRTY because INVALIDATE wasn't a settle-class signal for
- * `_dirtyDepCount` accounting) is the regression sentinel for §2.4.
- */
-
-import { describe, expect, it } from "vitest";
-import { batch } from "../../core/batch.js";
-import {
-	COMPLETE,
-	DATA,
-	DIRTY,
-	ERROR,
-	INVALIDATE,
-	type Messages,
-	RESOLVED,
-	TEARDOWN,
-} from "../../core/messages.js";
-import { node } from "../../core/node.js";
-import { Graph } from "../../graph/graph.js";
-
-const DIRTY_TYPE_FOR_TEST = DIRTY;
-
-describe("DS-13.5.A — INVALIDATE settles wave", () => {
-	it("a single [[INVALIDATE]] on a dep settles the consuming wave (counter-test for Agent 5 deadlock)", () => {
-		// Regression: pre-DS-13.5.A, INVALIDATE on a clean dep INCREMENTED
-		// `_dirtyDepCount` and never decremented, leaving the consumer
-		// permanently waiting for a settlement that never arrived. Agent 5
-		// worked around it via `[[INVALIDATE], [RESOLVED]]`. Post-DS-13.5.A,
-		// INVALIDATE is settle-class — no paired RESOLVED needed.
-		const src = node<number>({ initial: 1 });
-		let runs = 0;
-		const consumer = node(
-			[src],
-			(_data, actions) => {
-				runs += 1;
-				actions.emit(runs);
-			},
-			{ describeKind: "derived" },
-		);
-		const unsub = consumer.subscribe(() => undefined);
-		expect(runs).toBeGreaterThanOrEqual(1);
-		const before = runs;
-
-		// Plain `[[INVALIDATE]]` should settle the consumer's wave.
-		src.down([[INVALIDATE]]);
-
-		// Now push a DATA: consumer must re-fire (proves the wave was not stuck).
-		src.emit(2);
-		expect(runs).toBeGreaterThan(before);
-
-		unsub();
-	});
-
-	it("INVALIDATE clears the dep's prevData slot back to SENTINEL", () => {
-		const src = node<string>({ initial: "first" });
-		const seenPrev: unknown[] = [];
-		let runs = 0;
-		const consumer = node(
-			[src],
-			(batchData, _actions, ctx) => {
-				runs += 1;
-				seenPrev.push(ctx.prevData[0]);
-				const latest = batchData[0]?.at(-1) ?? ctx.prevData[0];
-				return latest;
-			},
-			{ describeKind: "derived" },
-		);
-		const unsub = consumer.subscribe(() => undefined);
-
-		// First run sees prevData[0] === undefined (SENTINEL).
-		expect(runs).toBe(1);
-		expect(seenPrev[0]).toBeUndefined();
-
-		// Establish a prevData via emit so we can assert INVALIDATE clears it.
-		src.emit("second");
-		expect(runs).toBe(2);
-		expect(seenPrev[1]).toBe("first"); // prevData[0] holds the prior emission
-
-		// INVALIDATE must reset prevData[0] back to undefined (SENTINEL).
-		src.down([[INVALIDATE]]);
-		// Trigger fn re-run by emitting fresh DATA. On this run prevData[0]
-		// must be `undefined` — INVALIDATE cleared the dep's prior-value slot.
-		src.emit("third");
-		expect(runs).toBe(3); // fn DID re-run (not vacuous)
-		expect(seenPrev[2]).toBeUndefined();
-
-		unsub();
-	});
-});
-
-describe("DS-13.5.A — same-wave merge rules (§2.4a)", () => {
-	it("DATA + INVALIDATE in same wave: both deliver in tier order, cache ends cleared", () => {
-		// Spec §2.4a: the natural tier-sort walk handles the merge. DATA
-		// (tier 3) processes first (cache → 42), then INVALIDATE (tier 4)
-		// clears cache back to undefined. Subscribers observe the full
-		// chronology — no message is silently dropped.
-		const src = node<number>({ initial: 0 });
-		const seen: symbol[] = [];
-		const unsub = src.subscribe((msgs) => {
-			for (const m of msgs as Messages) seen.push(m[0]);
-		});
-		seen.length = 0;
-
-		src.down([[DATA, 42], [INVALIDATE]]);
-
-		// Cache ends cleared (INVALIDATE wins by running last in tier order).
-		expect(src.cache).toBeUndefined();
-		// Both DATA and INVALIDATE delivered to sinks.
-		expect(seen).toContain(DATA);
-		expect(seen).toContain(INVALIDATE);
-		// Order: DATA before INVALIDATE.
-		const dataIdx = seen.indexOf(DATA);
-		const invIdx = seen.indexOf(INVALIDATE);
-		expect(dataIdx).toBeGreaterThanOrEqual(0);
-		expect(invIdx).toBeGreaterThan(dataIdx);
-
-		unsub();
-	});
-
-	it("non-monotone input [[INVALIDATE], [DATA, v]] sorts to [DATA, INVALIDATE] order", () => {
-		// User emits in reverse order; _frameBatch's stable tier-sort puts
-		// DATA (tier 3) before INVALIDATE (tier 4). End state matches the
-		// monotone case — cache cleared, both delivered.
-		const src = node<number>({ initial: 0 });
-		const seen: symbol[] = [];
-		const unsub = src.subscribe((msgs) => {
-			for (const m of msgs as Messages) seen.push(m[0]);
-		});
-		seen.length = 0;
-
-		src.down([[INVALIDATE], [DATA, 99]]);
-
-		expect(src.cache).toBeUndefined();
-		const dataIdx = seen.indexOf(DATA);
-		const invIdx = seen.indexOf(INVALIDATE);
-		expect(dataIdx).toBeGreaterThanOrEqual(0);
-		expect(invIdx).toBeGreaterThan(dataIdx);
-
-		unsub();
-	});
-
-	it("RESOLVED + INVALIDATE in same wave: both deliver, cache ends cleared", () => {
-		// RESOLVED is a no-op for cache; INVALIDATE clears it. Both delivered.
-		const src = node<number>({ initial: 7 });
-		const seen: symbol[] = [];
-		const unsub = src.subscribe((msgs) => {
-			for (const m of msgs as Messages) seen.push(m[0]);
-		});
-		seen.length = 0;
-
-		src.down([[RESOLVED], [INVALIDATE]]);
-
-		// Cache cleared by INVALIDATE (RESOLVED leaves cache alone, INVALIDATE wins).
-		expect(src.cache).toBeUndefined();
-		expect(seen).toContain(RESOLVED);
-		expect(seen).toContain(INVALIDATE);
-		const resIdx = seen.indexOf(RESOLVED);
-		const invIdx = seen.indexOf(INVALIDATE);
-		expect(invIdx).toBeGreaterThan(resIdx);
-
-		unsub();
-	});
-
-	it("Q9: INVALIDATE + INVALIDATE in same wave collapses to one (consumer counter settles cleanly)", () => {
-		const src = node<number>({ initial: 5 });
-		let invalidateDeliveries = 0;
-		const sinkUnsub = src.subscribe((msgs) => {
-			for (const m of msgs as Messages) {
-				if (m[0] === INVALIDATE) invalidateDeliveries += 1;
-			}
-		});
-		invalidateDeliveries = 0;
-
-		// Add a consumer derived node so we can verify _dirtyDepCount settles.
-		let runs = 0;
-		const consumer = node(
-			[src],
-			(_data, actions) => {
-				runs += 1;
-				actions.emit(runs);
-			},
-			{ describeKind: "derived" },
-		);
-		const consumerUnsub = consumer.subscribe(() => undefined);
-		const runsBefore = runs;
-
-		src.down([[INVALIDATE], [INVALIDATE]]);
-
-		// Q9 — only one INVALIDATE delivered to sinks regardless of input count.
-		expect(invalidateDeliveries).toBe(1);
-		// Cache cleared.
-		expect(src.cache).toBeUndefined();
-
-		// Consumer wave settled cleanly — emit fresh DATA to confirm fn re-fires.
-		src.emit(99);
-		expect(runs).toBeGreaterThan(runsBefore);
-
-		sinkUnsub();
-		consumerUnsub();
-	});
-});
-
-describe("DS-13.5.A — INVALIDATE inside batch", () => {
-	it("plain [[INVALIDATE]] inside batch settles the consuming wave alongside fresh DATA on another dep", () => {
-		// Mirrors the Agent 5 reset shape: INVALIDATE on one dep, fresh DATA
-		// on others, all in a single batch. Post-DS-13.5.A, the consumer
-		// re-runs once with the cleared `prevData[lastResponse] = undefined`
-		// and the new status/turn values — no trailing RESOLVED needed.
-		const lastResponse = node<{ token: string } | undefined>({ initial: undefined });
-		const status = node<string>({ initial: "idle" });
-		const turn = node<number>({ initial: 0 });
-
-		let runs = 0;
-		let observedLastResponse: unknown = "unset";
-		const consumer = node(
-			[status, lastResponse, turn],
-			(batchData, actions, ctx) => {
-				runs += 1;
-				const respBatch = batchData[1];
-				observedLastResponse =
-					respBatch != null && respBatch.length > 0 ? respBatch.at(-1) : ctx.prevData[1];
-				const stat = batchData[0]?.at(-1) ?? ctx.prevData[0];
-				const t = batchData[2]?.at(-1) ?? ctx.prevData[2];
-				actions.emit(`${stat as string}@${t as number}`);
-			},
-			{ describeKind: "derived" },
-		);
-		const unsub = consumer.subscribe(() => undefined);
-
-		// Establish a prior response so first-run gate passes and the
-		// consumer's prevData[lastResponse] holds a non-SENTINEL value.
-		lastResponse.emit({ token: "first" });
-		const runsAfterFirst = runs;
-		expect(runsAfterFirst).toBeGreaterThanOrEqual(1);
-
-		// Reset batch — INVALIDATE on lastResponse + fresh DATA on status (transition
-		// to a NEW value so equals doesn't dedup it).
-		batch(() => {
-			lastResponse.down([[INVALIDATE]]);
-			status.emit("thinking");
-		});
-
-		// Consumer re-ran with the new status — observed `lastResponse`
-		// must be SENTINEL `undefined` (INVALIDATE cleared `prevData[1]`).
-		expect(runs).toBeGreaterThan(runsAfterFirst);
-		expect(observedLastResponse).toBeUndefined();
-
-		unsub();
-	});
-});
-
-describe("DS-13.5.A Q16 — TEARDOWN auto-precedes with COMPLETE", () => {
-	it("plain [[TEARDOWN]] on a non-terminal node delivers [[COMPLETE], [TEARDOWN]] to sinks", () => {
-		const n = node<number>({ initial: 1 });
-		const seen: symbol[] = [];
-		const unsub = n.subscribe((msgs) => {
-			for (const m of msgs as Messages) seen.push(m[0]);
-		});
-		seen.length = 0;
-
-		n.down([[TEARDOWN]]);
-
-		const completeIdx = seen.indexOf(COMPLETE);
-		const teardownIdx = seen.indexOf(TEARDOWN);
-		expect(completeIdx).toBeGreaterThanOrEqual(0);
-		expect(teardownIdx).toBeGreaterThan(completeIdx);
-
-		unsub();
-	});
-
-	it("idempotent: redundant TEARDOWN deliveries do NOT re-emit a synthetic [COMPLETE]", () => {
-		const n = node<number>({ initial: 1 });
-		let completeCount = 0;
-		let teardownCount = 0;
-		const unsub = n.subscribe((msgs) => {
-			for (const m of msgs as Messages) {
-				if (m[0] === COMPLETE) completeCount += 1;
-				else if (m[0] === TEARDOWN) teardownCount += 1;
-			}
-		});
-
-		n.down([[TEARDOWN]]);
-		n.down([[TEARDOWN]]);
-
-		// Q16 only auto-precedes COMPLETE on the FIRST TEARDOWN (when the
-		// node is not yet torn down). Redundant TEARDOWN re-deliveries — e.g.
-		// from `Graph.destroy` broadcast colliding with dep cascade — must
-		// not fire COMPLETE again to sinks.
-		expect(completeCount).toBe(1);
-		expect(teardownCount).toBeGreaterThanOrEqual(1);
-
-		unsub();
-	});
-
-	it("does NOT auto-prefix COMPLETE when ERROR is already in the wave", () => {
-		const n = node<number>({ initial: 1 });
-		let completeCount = 0;
-		const unsub = n.subscribe((msgs) => {
-			for (const m of msgs as Messages) {
-				if (m[0] === COMPLETE) completeCount += 1;
-			}
-		});
-
-		n.down([[ERROR, new Error("boom")], [TEARDOWN]]);
-
-		// ERROR is the terminal signal; Q16 must not stack a redundant
-		// COMPLETE prefix when the wave already carries a terminal lifecycle.
-		expect(completeCount).toBe(0);
-
-		unsub();
-	});
-
-	it("does NOT auto-prefix COMPLETE when COMPLETE is already in the wave", () => {
-		const n = node<number>({ initial: 1 });
-		let completeCount = 0;
-		const unsub = n.subscribe((msgs) => {
-			for (const m of msgs as Messages) {
-				if (m[0] === COMPLETE) completeCount += 1;
-			}
-		});
-
-		n.down([[COMPLETE], [TEARDOWN]]);
-
-		expect(completeCount).toBe(1);
-
-		unsub();
-	});
-
-	it("Graph.remove on a non-terminal node delivers COMPLETE before TEARDOWN to subscribers", () => {
-		const g = new Graph("q16-remove");
-		const member = node<number>({ initial: 0, name: "member" });
-		g.add(member);
-
-		const seen: symbol[] = [];
-		const unsub = member.subscribe((msgs) => {
-			for (const m of msgs as Messages) seen.push(m[0]);
-		});
-		seen.length = 0;
-
-		g.remove("member");
-
-		const completeIdx = seen.indexOf(COMPLETE);
-		const teardownIdx = seen.indexOf(TEARDOWN);
-		expect(completeIdx).toBeGreaterThanOrEqual(0);
-		expect(teardownIdx).toBeGreaterThan(completeIdx);
-
-		unsub();
-	});
-
-	it("Graph.destroy delivers COMPLETE before TEARDOWN to every member's subscribers", () => {
-		const g = new Graph("q16-destroy");
-		const a = node<number>({ initial: 1, name: "a" });
-		g.add(a);
-
-		const seen: symbol[] = [];
-		const unsub = a.subscribe((msgs) => {
-			for (const m of msgs as Messages) seen.push(m[0]);
-		});
-		seen.length = 0;
-
-		g.destroy();
-
-		const completeIdx = seen.indexOf(COMPLETE);
-		const teardownIdx = seen.indexOf(TEARDOWN);
-		expect(completeIdx).toBeGreaterThanOrEqual(0);
-		expect(teardownIdx).toBeGreaterThan(completeIdx);
-
-		unsub();
-	});
-});
-
-describe("DS-13.5.A — push-on-subscribe after INVALIDATE (sentinel transition)", () => {
-	it("late subscriber receives [START] only — no DIRTY — after source.down([[INVALIDATE]])", () => {
-		// Regression sentinel for the agentLoop abort-test root cause.
-		// Pre-fix, INVALIDATE set _status="dirty"; defaultOnSubscribe pushed
-		// [START, DIRTY] to late-attaching subscribers, infecting their dep
-		// slot with a phantom dirty count that never settled. Post-fix,
-		// INVALIDATE sets _status="sentinel"; push-on-subscribe sends only
-		// [START]. Locks the load-bearing transition at the protocol layer.
-		const src = node<number>({ initial: 42, name: "src" });
-		// Establish initial state, then INVALIDATE.
-		const earlyUnsub = src.subscribe(() => undefined);
-		src.down([[INVALIDATE]]);
-		earlyUnsub();
-		// Late subscriber attaches AFTER the INVALIDATE.
-		const seen: symbol[] = [];
-		const unsub = src.subscribe((msgs) => {
-			for (const m of msgs as Messages) seen.push(m[0]);
-		});
-		// Push-on-subscribe should send only [START] — no DIRTY, no DATA.
-		// (DATA absent because cache is undefined post-INVALIDATE; the
-		// load-bearing property is the absence of DIRTY in the handshake.)
-		expect(seen).not.toContain(DATA);
-		expect(seen).not.toContain(DIRTY_TYPE_FOR_TEST);
-		// Source's status is "sentinel" post-INVALIDATE pre-subscribe, then
-		// transitions to "pending" inside subscribe() per the "activated but
-		// no value yet" rule. Either is fine — the regression sentinel is
-		// "no DIRTY pushed to the late subscriber."
-		expect(["sentinel", "pending"]).toContain(src.status);
-		unsub();
-	});
-
-	it("consumer attaches AFTER source's INVALIDATE; consumer fn fires once on next DATA without phantom dirty count", () => {
-		// Protocol-level repro of the agent-abort C2/C3 scenario:
-		// `_terminalResult` lazily activated AFTER the reset batch had
-		// INVALIDATE'd `lastResponseState` — the new dep slot must NOT
-		// inherit a phantom DIRTY that wedges _dirtyDepCount.
-		const src = node<number>({ initial: 1, name: "src" });
-		// INVALIDATE before the consumer subscribes — like the agent reset
-		// batch fires before _terminalResult activates via awaitSettled.
-		const keepalive = src.subscribe(() => undefined);
-		src.down([[INVALIDATE]]);
-		keepalive();
-
-		let runs = 0;
-		let lastSeen: number | undefined;
-		const consumer = node<number>(
-			[src],
-			(batchData, actions, ctx) => {
-				runs += 1;
-				const v = batchData[0]?.at(-1) ?? ctx.prevData[0];
-				if (typeof v === "number") {
-					lastSeen = v;
-					actions.emit(v);
-				} else {
-					actions.down([[RESOLVED]]);
-				}
-			},
-			{ describeKind: "derived", partial: true, name: "consumer" },
-		);
-		const unsub = consumer.subscribe(() => undefined);
-		const runsAfterAttach = runs;
-
-		// Now emit fresh DATA — consumer fn MUST fire (would hang at
-		// _dirtyDepCount=1 if push-on-subscribe had pushed DIRTY).
-		src.emit(99);
-		expect(runs).toBeGreaterThan(runsAfterAttach);
-		expect(lastSeen).toBe(99);
-
-		unsub();
-	});
-});
-
-describe("DS-13.5.A Q9 — INVALIDATE+INVALIDATE collapse fires cleanup hook exactly once", () => {
-	it("object-form `invalidate` hook fires once on collapsed wave", () => {
-		// Q9 spec rationale: "cleanup hooks fire at most once per wave".
-		// Locks the cleanup-firing invariant against a future refactor that
-		// might move Q9 collapse out of `_frameBatch`.
-		const src = node<number>({ initial: 0, name: "src" });
-		let invalidateHookFired = 0;
-		const consumer = node<number>(
-			[src],
-			(_batchData, actions) => {
-				actions.emit(1);
-				return {
-					onInvalidate: () => {
-						invalidateHookFired += 1;
-					},
-				};
-			},
-			{ describeKind: "derived", name: "consumer" },
-		);
-		const unsub = consumer.subscribe(() => undefined);
-
-		// Collapse case: two INVALIDATEs in one wave on the source.
-		src.down([[INVALIDATE], [INVALIDATE]]);
-
-		// Cleanup hook MUST fire exactly once despite two INVALIDATEs in the
-		// same wave (Q9 collapses to one delivery on the wire).
-		expect(invalidateHookFired).toBe(1);
-
-		unsub();
-	});
-});
-
-describe("DS-13.5.A — INVALIDATE on terminal-resubscribable (N1 regression)", () => {
-	it("INVALIDATE on a multi-subscribed terminal-resubscribable triggers fresh-lifecycle reset (no stale prevData leak)", () => {
-		// N1 regression: a resubscribable node with multiple subscribers
-		// reaches COMPLETE. One sub unsubs (so `_deactivate` does NOT run —
-		// remaining sub keeps node alive). INVALIDATE arrives. Without the
-		// pass-3 fix, the prior lifecycle's `_hasCalledFnOnce`,
-		// `_dirtyDepCount`, and DepRecord `prevData` would persist into the
-		// next wave — fn would compute against ghost state.
-		const src = node<number>({ initial: 0, name: "src" });
-		let _fnCallsWithStalePrev = 0;
-		const seenPrevValues: unknown[] = [];
-		const consumer = node<number>(
-			[src],
-			(batchData, actions, ctx) => {
-				const incoming = batchData[0];
-				const fromBatch =
-					incoming != null && incoming.length > 0 ? (incoming.at(-1) as number) : undefined;
-				const prev = ctx.prevData[0];
-				seenPrevValues.push(prev);
-				// Stale-prev detection: after INVALIDATE clears the dep slot,
-				// a fresh-lifecycle fn run should see prevData[0] === undefined.
-				// If the lifecycle reset didn't fire, prevData[0] holds the
-				// pre-COMPLETE value (e.g. 7) instead of undefined.
-				if (prev !== undefined && fromBatch == null) {
-					_fnCallsWithStalePrev += 1;
-				}
-				if (fromBatch != null) actions.emit(fromBatch * 2);
-				else actions.down([[RESOLVED]]);
-			},
-			{ describeKind: "derived", resubscribable: true, name: "consumer" },
-		);
-
-		// Multi-sub setup: ka1 + ka2 keep consumer alive across terminal.
-		const ka1 = consumer.subscribe(() => undefined);
-		const ka2 = consumer.subscribe(() => undefined);
-
-		// Push a value through. Consumer fn runs, prevData[0] becomes 7.
-		src.emit(7);
-
-		// Drive consumer to terminal: emit COMPLETE on src, autoComplete cascades.
-		src.down([[COMPLETE]]);
-		expect(consumer.status).toBe("completed");
-
-		// ka1 detaches. ka2 still attached → `_deactivate` does NOT run.
-		// Prior-lifecycle state (prevData=7, _hasCalledFnOnce=true) lingers.
-		ka1();
-		expect(consumer.status).toBe("completed"); // still terminal
-
-		// INVALIDATE arrives. Pass-3 fix: triggers full lifecycle reset.
-		consumer.down([[INVALIDATE]]);
-		expect(consumer.status).toBe("sentinel");
-
-		// Now subscribe a fresh consumer at the same node — they should see
-		// fresh-lifecycle behavior. Drive a fresh wave on src to make the
-		// consumer's fn run; assert prevData[0] is undefined (SENTINEL),
-		// proving the reset cleared the stale value.
-		const seenLast: unknown[] = [];
-		const ka3 = consumer.subscribe((msgs) => {
-			for (const m of msgs as Messages) {
-				if (m[0] === DATA) seenLast.push(m[1]);
-			}
-		});
-
-		// Need to re-establish src's emission too, since src is also terminal
-		// after the COMPLETE cascade. Use a fresh src for the next wave —
-		// this mirrors how a real resubscribable consumer would re-attach
-		// after its own deps reset.
-		// Actually src here completed on src.down([[COMPLETE]]); to test
-		// downstream reset cleanly, build a fresh source:
-		const src2 = node<number>({ initial: 0, name: "src2" });
-		const consumer2 = node<number>(
-			[src2],
-			(batchData, actions, ctx) => {
-				const incoming = batchData[0];
-				const fromBatch =
-					incoming != null && incoming.length > 0 ? (incoming.at(-1) as number) : undefined;
-				const prev = ctx.prevData[0];
-				if (prev !== undefined && fromBatch == null) {
-					_fnCallsWithStalePrev += 1;
-				}
-				if (fromBatch != null) actions.emit(fromBatch * 2);
-				else actions.down([[RESOLVED]]);
-			},
-			{ describeKind: "derived", resubscribable: true, name: "consumer2" },
-		);
-		const c2_ka1 = consumer2.subscribe(() => undefined);
-		const c2_ka2 = consumer2.subscribe(() => undefined);
-		src2.emit(7); // prevData[0] = 7
-		src2.down([[COMPLETE]]); // consumer2 → completed
-		c2_ka1();
-		// INVALIDATE on terminal-resubscribable
-		consumer2.down([[INVALIDATE]]);
-
-		// Now re-emit on src2 — but src2 is itself completed. New subscribe
-		// to consumer2 should NOT see stale fn computations from prior
-		// lifecycle.
-		const c2_seenLast: number[] = [];
-		const c2_ka3 = consumer2.subscribe((msgs) => {
-			for (const m of msgs as Messages) {
-				if (m[0] === DATA) c2_seenLast.push(m[1] as number);
-			}
-		});
-		// The state we care about: consumer2._hasCalledFnOnce should be false
-		// post-reset (so first-run gate re-arms), DepRecords should be reset,
-		// and any prior-lifecycle prevData should be cleared.
-		// The most direct assertion: consumer2.cache is undefined (cleared
-		// by INVALIDATE), status is "sentinel" or "pending" post-subscribe.
-		expect(consumer2.cache).toBeUndefined();
-		expect(["sentinel", "pending"]).toContain(consumer2.status);
-
-		ka2();
-		ka3();
-		c2_ka2();
-		c2_ka3();
-	});
-
-	it("subscribe() afterTerminalReset path still works for single-sub resubscribable (regression check on the helper extraction)", () => {
-		// Validate that extracting `_resetForFreshLifecycle` didn't break the
-		// existing `subscribe()` afterTerminalReset path.
-		const src = node<number>({ initial: 0, resubscribable: true, name: "src" });
-		const sub1 = src.subscribe(() => undefined);
-		src.emit(5);
-		expect(src.cache).toBe(5);
-		src.down([[COMPLETE]]);
-		expect(src.status).toBe("completed");
-		sub1();
-
-		// Re-subscribe — terminal-resubscribable should reset cleanly.
-		const seen: symbol[] = [];
-		const sub2 = src.subscribe((msgs) => {
-			for (const m of msgs as Messages) seen.push(m[0]);
-		});
-		// Cache cleared by reset, status flips to pending on activation.
-		expect(src.cache).toBeUndefined();
-		expect(["sentinel", "pending"]).toContain(src.status);
-		sub2();
-	});
-});
diff --git a/packages/pure-ts/src/__tests__/core/lifecycle.test.ts b/packages/pure-ts/src/__tests__/core/lifecycle.test.ts
deleted file mode 100644
index d8ca6254..00000000
--- a/packages/pure-ts/src/__tests__/core/lifecycle.test.ts
+++ /dev/null
@@ -1,364 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import { COMPLETE, DATA, DIRTY, INVALIDATE, type Messages, PAUSE } from "../../core/messages.js";
-import { node } from "../../core/node.js";
-
-describe("0.6 lifecycle: INVALIDATE", () => {
-	it("INVALIDATE on a source node clears cache, transitions to sentinel, reaches subscribers", () => {
-		const s = node<number>({ initial: 1 });
-		const seen: symbol[] = [];
-		const unsub = s.subscribe((msgs) => {
-			for (const m of msgs) seen.push(m[0] as symbol);
-		});
-
-		s.down([[INVALIDATE]]);
-
-		// DS-13.5.A: INVALIDATE is settle-class; status transitions to
-		// "sentinel" (no value, nothing pending) — NOT "dirty" (which means
-		// "value about to change"). Cache is cleared per spec §1.2.
-		expect(s.status).toBe("sentinel");
-		expect(seen).toContain(INVALIDATE);
-		expect(s.cache).toBeUndefined();
-
-		unsub();
-	});
-
-	it("derived node forwards INVALIDATE from a dependency to its sinks", () => {
-		const src = node<number>({ initial: 0 });
-		const d = node(
-			[src],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as number) * 2);
-			},
-			{ describeKind: "derived" },
-		);
-		const seen: symbol[] = [];
-		const unsub = d.subscribe((msgs) => {
-			for (const m of msgs) seen.push(m[0] as symbol);
-		});
-
-		src.down([[INVALIDATE]]);
-
-		// DS-13.5.A: post-INVALIDATE the derived's status is "sentinel"
-		// (cache cleared, no pending update), not "dirty".
-		expect(seen).toContain(INVALIDATE);
-		expect(d.status).toBe("sentinel");
-		expect(d.cache).toBeUndefined();
-
-		unsub();
-	});
-
-	it("INVALIDATE after COMPLETE reaches sinks and clears cache", () => {
-		const s = node<number>({ initial: 1 });
-		const types: symbol[] = [];
-		const unsub = s.subscribe((msgs) => {
-			for (const m of msgs) types.push(m[0] as symbol);
-		});
-
-		s.down([[COMPLETE]]);
-		s.down([[INVALIDATE]]);
-
-		expect(types).toContain(INVALIDATE);
-		expect(s.cache).toBeUndefined();
-
-		unsub();
-	});
-
-	it("INVALIDATE runs fn cleanup once", () => {
-		const src = node<number>({ initial: 0 });
-		let cleanups = 0;
-		const n = node([src], (_data, _actions, _ctx) => ({
-			onInvalidate: () => {
-				cleanups += 1;
-			},
-		}));
-		const unsub = n.subscribe(() => undefined);
-
-		expect(cleanups).toBe(0);
-		n.down([[INVALIDATE]]);
-		expect(cleanups).toBe(1);
-		n.down([[INVALIDATE]]);
-		expect(cleanups).toBe(1);
-
-		unsub();
-	});
-
-	it("diamond fan-in: INVALIDATE cascade fires invalidate hook ONCE at the join", () => {
-		// TLA+ batch 5 B parity: topology `A → {B, C} → D`. When A is
-		// invalidated, D receives INVALIDATE via both parents. The first
-		// arrival resets D's cache and fires the invalidate hook; the second
-		// must NOT re-fire because there's nothing left to clean up.
-		// Before the `_cached === undefined` guard in `_onDepMessage`'s
-		// INVALIDATE branch, D's object-form `invalidate` hook double-fired
-		// and the INVALIDATE was re-broadcast to D's children. The guard
-		// matches the TLA+ `CleanupWitnessNonTrivial` invariant's semantic.
-		const a = node<number>({ initial: 1 });
-		const b = node(
-			[a],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit(data[0] as number);
-			},
-			{ describeKind: "derived" },
-		);
-		const c = node(
-			[a],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as number) + 1);
-			},
-			{ describeKind: "derived" },
-		);
-		let invalidates = 0;
-		const d = node<number>([b, c], (data, actions, _ctx) => {
-			// Compute + emit so `d._cached` is populated — the guard's input.
-			const bv = data[0].at(-1) ?? 0;
-			const cv = data[1].at(-1) ?? 0;
-			actions.emit((bv as number) + (cv as number));
-			return {
-				onInvalidate: () => {
-					invalidates += 1;
-				},
-			};
-		});
-		// Sink on D's own downstream to observe the INVALIDATE broadcast count
-		// reaching children.
-		const e = node(
-			[d],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit(data[0] as number);
-			},
-			{ describeKind: "derived" },
-		);
-		const eSeen: symbol[] = [];
-		const unsubE = e.subscribe((msgs) => {
-			for (const [t] of msgs as Messages) eSeen.push(t);
-		});
-		const unsubD = d.subscribe(() => undefined);
-
-		// Prime D's cache: first activation runs fn which emits → d._cached set.
-		expect(d.cache).toBe(3); // (1) + (1+1)
-		expect(invalidates).toBe(0);
-
-		// Invalidate A — cascades to both B and C, then to D via both paths.
-		a.down([[INVALIDATE]]);
-
-		// With the diamond fan-in guard: hook fires exactly once at D.
-		// Without it: fires twice (the latent bug this test is guarding).
-		expect(invalidates).toBe(1);
-
-		// E should also see exactly ONE INVALIDATE forwarded from D. Without
-		// the guard, D would re-broadcast INVALIDATE on the second arrival
-		// and E would count two.
-		const invalidatesAtE = eSeen.filter((t) => t === INVALIDATE).length;
-		expect(invalidatesAtE).toBe(1);
-
-		unsubE();
-		unsubD();
-	});
-});
-
-describe("NodeFnCleanup object form — granular hooks", () => {
-	it("{ beforeRun } fires only before re-runs, not on deactivation or INVALIDATE", () => {
-		const src = node<number>({ initial: 0 });
-		let beforeRuns = 0;
-		let fnRuns = 0;
-		const n = node([src], (_data, _actions, _ctx) => {
-			fnRuns += 1;
-			return {
-				onRerun: () => {
-					beforeRuns += 1;
-				},
-			};
-		});
-		const unsub = n.subscribe(() => undefined);
-		expect(fnRuns).toBe(1);
-		expect(beforeRuns).toBe(0);
-
-		// Trigger a re-run by emitting new DATA from src.
-		src.down([[DIRTY], [DATA, 1]]);
-		expect(fnRuns).toBe(2);
-		expect(beforeRuns).toBe(1);
-
-		// INVALIDATE must NOT fire beforeRun.
-		n.down([[INVALIDATE]]);
-		expect(beforeRuns).toBe(1);
-
-		// Deactivation must NOT fire beforeRun.
-		unsub();
-		expect(beforeRuns).toBe(1);
-	});
-
-	it("{ deactivate } fires only on deactivation, not on re-run or INVALIDATE", () => {
-		const src = node<number>({ initial: 0 });
-		let deactivates = 0;
-		const n = node([src], (_data, _actions, _ctx) => ({
-			onDeactivation: () => {
-				deactivates += 1;
-			},
-		}));
-		const unsub = n.subscribe(() => undefined);
-		expect(deactivates).toBe(0);
-
-		src.down([[DIRTY], [DATA, 1]]);
-		expect(deactivates).toBe(0);
-
-		n.down([[INVALIDATE]]);
-		expect(deactivates).toBe(0);
-
-		unsub();
-		expect(deactivates).toBe(1);
-	});
-
-	it("{ invalidate } fires only on INVALIDATE, not on re-run or deactivation", () => {
-		const src = node<number>({ initial: 0 });
-		let invalidates = 0;
-		const n = node([src], (_data, _actions, _ctx) => ({
-			onInvalidate: () => {
-				invalidates += 1;
-			},
-		}));
-		const unsub = n.subscribe(() => undefined);
-		expect(invalidates).toBe(0);
-
-		src.down([[DIRTY], [DATA, 1]]);
-		expect(invalidates).toBe(0);
-
-		n.down([[INVALIDATE]]);
-		expect(invalidates).toBe(1);
-
-		unsub();
-		expect(invalidates).toBe(1);
-	});
-
-	it("object with multiple hooks fires each on its own transition", () => {
-		const src = node<number>({ initial: 0 });
-		let br = 0;
-		let de = 0;
-		let iv = 0;
-		const n = node([src], (_data, _actions, _ctx) => ({
-			onRerun: () => {
-				br += 1;
-			},
-			onDeactivation: () => {
-				de += 1;
-			},
-			onInvalidate: () => {
-				iv += 1;
-			},
-		}));
-		const unsub = n.subscribe(() => undefined);
-		expect([br, de, iv]).toEqual([0, 0, 0]);
-
-		src.down([[DIRTY], [DATA, 1]]);
-		expect([br, de, iv]).toEqual([1, 0, 0]);
-
-		n.down([[INVALIDATE]]);
-		expect([br, de, iv]).toEqual([1, 0, 1]);
-
-		unsub();
-		expect([br, de, iv]).toEqual([1, 1, 1]);
-	});
-
-	it("object cleanup is preserved across re-runs (deactivate still fires after many re-runs)", () => {
-		const src = node<number>({ initial: 0 });
-		let deactivates = 0;
-		const n = node([src], (_data, _actions, _ctx) => ({
-			onDeactivation: () => {
-				deactivates += 1;
-			},
-		}));
-		const unsub = n.subscribe(() => undefined);
-
-		for (let i = 1; i <= 5; i++) {
-			src.down([[DIRTY], [DATA, i]]);
-		}
-		expect(deactivates).toBe(0);
-
-		unsub();
-		expect(deactivates).toBe(1);
-	});
-
-	it("object cleanup with only beforeRun does not block deactivation", () => {
-		const src = node<number>({ initial: 0 });
-		let beforeRuns = 0;
-		const n = node([src], (_data, _actions, _ctx) => ({
-			onRerun: () => {
-				beforeRuns += 1;
-			},
-		}));
-		const unsub = n.subscribe(() => undefined);
-		src.down([[DIRTY], [DATA, 1]]);
-		expect(beforeRuns).toBe(1);
-		unsub(); // should not throw; absent deactivate hook is a no-op
-		expect(beforeRuns).toBe(1);
-	});
-});
-
-describe("0.6 lifecycle: node.up fan-out", () => {
-	it("up() invokes each dependency's up with the same message batch", () => {
-		const a = node<number>({ initial: 0 });
-		const b = node<number>({ initial: 0 });
-		const d = node(
-			[a, b],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as number) + (data[1] as number));
-			},
-			{ describeKind: "derived" },
-		);
-		d.subscribe(() => {});
-
-		const spyA = vi.spyOn(a, "up");
-		const spyB = vi.spyOn(b, "up");
-		const batch: Messages = [[PAUSE, "lock"]];
-		d.up(batch);
-
-		expect(spyA).toHaveBeenCalledTimes(1);
-		expect(spyA).toHaveBeenCalledWith(batch, { internal: true });
-		expect(spyB).toHaveBeenCalledTimes(1);
-		expect(spyB).toHaveBeenCalledWith(batch, { internal: true });
-
-		spyA.mockRestore();
-		spyB.mockRestore();
-	});
-});
-
-describe("0.6 two-phase ordering", () => {
-	it("derived subscriber sees DIRTY before DATA in dep push order", () => {
-		const src = node<number>({ initial: 0 });
-		const d = node(
-			[src],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as number) + 1);
-			},
-			{ describeKind: "derived" },
-		);
-		const batches: symbol[][] = [];
-		const unsub = d.subscribe((msgs) => {
-			batches.push(msgs.map((m) => m[0] as symbol));
-		});
-
-		src.down([[DIRTY], [DATA, 5]]);
-
-		const order = batches.flat();
-		expect(order.indexOf(DIRTY)).toBeGreaterThanOrEqual(0);
-		expect(order.indexOf(DATA)).toBeGreaterThan(order.indexOf(DIRTY));
-		expect(d.cache).toBe(6);
-		unsub();
-	});
-});
diff --git a/packages/pure-ts/src/__tests__/core/multi-message-delivery.test.ts b/packages/pure-ts/src/__tests__/core/multi-message-delivery.test.ts
deleted file mode 100644
index c089edec..00000000
--- a/packages/pure-ts/src/__tests__/core/multi-message-delivery.test.ts
+++ /dev/null
@@ -1,198 +0,0 @@
-/**
- * Tests nailing down actual behaviour for multi-message dep deliveries and
- * multi-emit-in-batch scenarios. These exist to ground the "K+1 diamond"
- * investigation in observed behavior rather than code tracing.
- *
- * Documented bug candidates surfaced by this file:
- *
- * - **Bug 1 (per-message fn invocation)**: multi-message batch delivered to
- *   a dep subscriber triggers `_maybeRunFnOnSettlement` per-message instead
- *   of once, violating `_execFn`'s documented "full wave batch" contract
- *   (see node.ts:1462–1466).
- *
- * - **Bug 2 (multi-emit-in-batch K+1 at fan-in)**: K `.emit()` calls inside
- *   one `batch(() => ...)` scope produce K+1 downstream settlements at a
- *   diamond fan-in node, not K (as the deferred-but-separate semantic would
- *   predict) and not 1 (as atomic coalescing would predict).
- *
- * Tests use raw `node([deps], fn)` so `fn` receives the raw `batchData`
- * (per-dep array of wave values) instead of the pre-unwrapped scalar that
- * `derived()` sugar hands to its user fn.
- */
-
-import { describe, expect, it } from "vitest";
-import { batch } from "../../core/batch.js";
-import { DATA, START } from "../../core/messages.js";
-import { node } from "../../core/node.js";
-
-// Snapshot a batchData argument to a comparable shape.
-function snapBatch(batchData: readonly (readonly unknown[] | undefined)[]): unknown[] {
-	return batchData.map((b) => (b === undefined ? undefined : [...b]));
-}
-
-describe("multi-message delivery — fn-run contract", () => {
-	it("single-dep: multi-DATA .down() on source fires derived fn per message today (design intent: once)", () => {
-		const a = node([], { initial: 0 });
-		const runs: unknown[][] = [];
-		const b = node([a], (batchData, actions) => {
-			runs.push(snapBatch(batchData));
-			const last = (batchData[0] ?? []).at(-1);
-			actions.emit(last as number);
-		});
-		const unsub = b.subscribe(() => {});
-		runs.length = 0;
-
-		(a as unknown as { down: (m: readonly (readonly [symbol, unknown?])[]) => void }).down([
-			[DATA, 10],
-			[DATA, 20],
-			[DATA, 30],
-		]);
-
-		// Snapshot the observed behaviour. Under the current implementation
-		// fn runs 3 times. Under the intended semantic (node.ts:1462 comment)
-		// it should run once with batchData = [[10, 20, 30]].
-		expect({ runCount: runs.length, runs }).toMatchSnapshot();
-		unsub();
-	});
-
-	it("single-dep: source.emit() three times outside batch fires fn three times (one per wave)", () => {
-		const a = node([], { initial: 0 });
-		const runs: unknown[][] = [];
-		const b = node([a], (batchData, actions) => {
-			runs.push(snapBatch(batchData));
-			actions.emit((batchData[0] ?? []).at(-1) as number);
-		});
-		const unsub = b.subscribe(() => {});
-		runs.length = 0;
-
-		(a as unknown as { emit: (v: number) => void }).emit(1);
-		(a as unknown as { emit: (v: number) => void }).emit(2);
-		(a as unknown as { emit: (v: number) => void }).emit(3);
-
-		expect({ runCount: runs.length, runs }).toMatchSnapshot();
-		unsub();
-	});
-
-	it("single-dep: K emits inside batch — documents current fn-run count at derived", () => {
-		const a = node([], { initial: 0 });
-		const runs: unknown[][] = [];
-		const b = node([a], (batchData, actions) => {
-			runs.push(snapBatch(batchData));
-			actions.emit((batchData[0] ?? []).at(-1) as number);
-		});
-		const unsub = b.subscribe(() => {});
-		runs.length = 0;
-
-		batch(() => {
-			(a as unknown as { emit: (v: number) => void }).emit(1);
-			(a as unknown as { emit: (v: number) => void }).emit(2);
-			(a as unknown as { emit: (v: number) => void }).emit(3);
-		});
-
-		expect({ runCount: runs.length, runs }).toMatchSnapshot();
-		unsub();
-	});
-
-	it("diamond: K emits inside batch — fan-in D's fn-run count (the K+1 finding)", () => {
-		const a = node([], { initial: 0 });
-		const b = node([a], (batchData, actions) => {
-			actions.emit((batchData[0] ?? []).at(-1) as number);
-		});
-		const c = node([a], (batchData, actions) => {
-			actions.emit(((batchData[0] ?? []).at(-1) as number) + 10);
-		});
-		const dRuns: unknown[][] = [];
-		const d = node([b, c], (batchData, actions) => {
-			dRuns.push(snapBatch(batchData));
-			const bv = ((batchData[0] ?? []).at(-1) as number) ?? 0;
-			const cv = ((batchData[1] ?? []).at(-1) as number) ?? 0;
-			actions.emit(bv + cv);
-		});
-		const unsub = d.subscribe(() => {});
-		dRuns.length = 0;
-
-		batch(() => {
-			(a as unknown as { emit: (v: number) => void }).emit(1);
-			(a as unknown as { emit: (v: number) => void }).emit(2);
-		});
-
-		expect({
-			runCount: dRuns.length,
-			runs: dRuns,
-			finalD: (d as unknown as { cache?: number }).cache,
-		}).toMatchSnapshot();
-		unsub();
-	});
-});
-
-describe("multi-message delivery — subscriber batch structure", () => {
-	it("derived's own subscriber sees multi-DATA from a single source .down() as how many sink calls?", () => {
-		const a = node([], { initial: 0 });
-		const b = node([a], (batchData, actions) => {
-			actions.emit((batchData[0] ?? []).at(-1) as number);
-		});
-
-		const sinkCalls: readonly [string, unknown?][][] = [];
-		const unsub = b.subscribe((msgs) => {
-			const call = (msgs as readonly [symbol, unknown?][])
-				.filter((m) => m[0] !== START)
-				.map((m) => [(m[0] as symbol).description, m[1]] as [string, unknown]);
-			if (call.length > 0) sinkCalls.push(call);
-		});
-		sinkCalls.length = 0;
-
-		(a as unknown as { down: (m: readonly (readonly [symbol, unknown?])[]) => void }).down([
-			[DATA, 10],
-			[DATA, 20],
-			[DATA, 30],
-		]);
-
-		expect({ sinkCallCount: sinkCalls.length, calls: sinkCalls }).toMatchSnapshot();
-		unsub();
-	});
-
-	it("diamond: K=2 emits in batch — per-node sink call counts", () => {
-		const a = node([], { initial: 0 });
-		const b = node([a], (batchData, actions) => {
-			actions.emit((batchData[0] ?? []).at(-1) as number);
-		});
-		const c = node([a], (batchData, actions) => {
-			actions.emit(((batchData[0] ?? []).at(-1) as number) + 10);
-		});
-		const d = node([b, c], (batchData, actions) => {
-			const bv = ((batchData[0] ?? []).at(-1) as number) ?? 0;
-			const cv = ((batchData[1] ?? []).at(-1) as number) ?? 0;
-			actions.emit(bv + cv);
-		});
-
-		const calls = { a: 0, b: 0, c: 0, d: 0 };
-		const ua = a.subscribe((msgs) => {
-			if ((msgs as readonly [symbol, unknown?][]).some((m) => m[0] !== START)) calls.a += 1;
-		});
-		const ub = b.subscribe((msgs) => {
-			if ((msgs as readonly [symbol, unknown?][]).some((m) => m[0] !== START)) calls.b += 1;
-		});
-		const uc = c.subscribe((msgs) => {
-			if ((msgs as readonly [symbol, unknown?][]).some((m) => m[0] !== START)) calls.c += 1;
-		});
-		const ud = d.subscribe((msgs) => {
-			if ((msgs as readonly [symbol, unknown?][]).some((m) => m[0] !== START)) calls.d += 1;
-		});
-		// Reset after activation.
-		calls.a = 0;
-		calls.b = 0;
-		calls.c = 0;
-		calls.d = 0;
-
-		batch(() => {
-			(a as unknown as { emit: (v: number) => void }).emit(1);
-			(a as unknown as { emit: (v: number) => void }).emit(2);
-		});
-
-		expect(calls).toMatchSnapshot();
-		ua();
-		ub();
-		uc();
-		ud();
-	});
-});
diff --git a/packages/pure-ts/src/__tests__/core/node.test.ts b/packages/pure-ts/src/__tests__/core/node.test.ts
deleted file mode 100644
index 05bc4789..00000000
--- a/packages/pure-ts/src/__tests__/core/node.test.ts
+++ /dev/null
@@ -1,1635 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { batch } from "../../core/batch.js";
-import {
-	COMPLETE,
-	DATA,
-	DIRTY,
-	ERROR,
-	INVALIDATE,
-	PAUSE,
-	RESOLVED,
-	RESUME,
-	START,
-	TEARDOWN,
-} from "../../core/messages.js";
-import { describeNode, metaSnapshot } from "../../core/meta.js";
-import { node } from "../../core/node.js";
-
-describe("node primitive", () => {
-	it("source node emits messages to subscribers", () => {
-		const s = node<number>();
-		const seen: symbol[][] = [];
-		const unsub = s.subscribe((messages) => {
-			seen.push(messages.map((m) => m[0] as symbol));
-		});
-
-		s.down([[DIRTY], [DATA, 1]]);
-
-		expect(s.cache).toBe(1);
-		expect(s.status).toBe("settled");
-		// SENTINEL node: subscribe delivers [[START]] alone (no cached value).
-		// The explicit DIRTY+DATA batch is partitioned by tier: DIRTY (tier 1)
-		// delivered first, DATA (tier 3) delivered second — two separate sink
-		// calls.
-		expect(seen).toEqual([[START], [DIRTY], [DATA]]);
-		unsub();
-	});
-
-	it("derived node emits RESOLVED when equals says unchanged", () => {
-		const source = node<number>({ initial: 1 });
-		const d = node(
-			[source],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as number) > 0 ? "positive" : "other");
-			},
-			{ describeKind: "derived", equals: (a, b) => a === b },
-		);
-		const seen: symbol[][] = [];
-		const unsub = d.subscribe((messages) => {
-			seen.push(messages.map((m) => m[0] as symbol));
-		});
-
-		source.down([[DATA, 2]]);
-
-		expect(d.cache).toBe("positive");
-		expect(seen).toContainEqual([RESOLVED]);
-		unsub();
-	});
-
-	it("diamond settles once per upstream change", () => {
-		const a = node<number>({ initial: 0 });
-		const b = node(
-			[a],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as number) + 1);
-			},
-			{ describeKind: "derived" },
-		);
-		const c = node(
-			[a],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as number) + 2);
-			},
-			{ describeKind: "derived" },
-		);
-		let dRuns = 0;
-		const d = node(
-			[b, c],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				dRuns += 1;
-				actions.emit((data[0] as number) + (data[1] as number));
-			},
-			{ describeKind: "derived" },
-		);
-
-		const unsub = d.subscribe(() => undefined);
-		const before = dRuns;
-		a.down([[DIRTY], [DATA, 5]]);
-		const after = dRuns;
-
-		expect(after - before).toBe(1);
-		expect(d.cache).toBe(13);
-		unsub();
-	});
-
-	it("fn throw is forwarded as ERROR downstream", () => {
-		const source = node<number>({ initial: 0 });
-		const broken = node(
-			[source],
-			(_batchData, _actions) => {
-				throw new Error("boom");
-			},
-			{ describeKind: "derived" },
-		);
-		const seen: symbol[] = [];
-		const payloads: unknown[] = [];
-		const unsub = broken.subscribe((messages) => {
-			for (const m of messages) {
-				seen.push(m[0] as symbol);
-				if (m[0] === ERROR) payloads.push(m[1]);
-			}
-		});
-
-		source.down([[DATA, 1]]);
-		expect(broken.status).toBe("errored");
-		expect(seen).toContain(ERROR);
-		expect(payloads[0]).toBeInstanceOf(Error);
-		expect((payloads[0] as Error).message).toContain("fn threw");
-		expect((payloads[0] as Error).cause).toBeInstanceOf(Error);
-		expect(((payloads[0] as Error).cause as Error).message).toBe("boom");
-		unsub();
-	});
-
-	// Regression: GRAPHREFLY-SPEC §1.3.3 — RESOLVED enables transitive skip (leaf fn not re-run).
-	it("RESOLVED on mid skips leaf compute when value unchanged", () => {
-		const source = node<number>({ initial: 0 });
-		const mid = node(
-			[source],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as number) > 0 ? "p" : "n");
-			},
-			{ describeKind: "derived", equals: (a, b) => a === b },
-		);
-		let leafRuns = 0;
-		const leaf = node(
-			[mid],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				leafRuns += 1;
-				actions.emit(data[0]);
-			},
-			{ describeKind: "derived" },
-		);
-		const unsub = leaf.subscribe(() => undefined);
-		const afterConnect = leafRuns;
-
-		source.down([[DIRTY], [DATA, 1]]);
-		const afterFirstPush = leafRuns;
-		expect(afterFirstPush).toBeGreaterThan(afterConnect);
-
-		source.down([[DIRTY], [DATA, 2]]);
-		expect(leafRuns).toBe(afterFirstPush);
-		unsub();
-	});
-
-	// Regression: GRAPHREFLY-SPEC §1.3.4 — ERROR is terminal (no further downstream messages).
-	it("after ERROR, non-resubscribable node does not emit to sinks again", () => {
-		const source = node<number>();
-		const broken = node(
-			[source],
-			(_batchData, _actions) => {
-				throw new Error("boom");
-			},
-			{ describeKind: "derived" },
-		);
-		let deliveries = 0;
-		const unsub = broken.subscribe(() => {
-			deliveries += 1;
-		});
-
-		source.down([[DATA, 1]]);
-		// 3 deliveries: START (subscribe ceremony) + DIRTY (dep wave, now that
-		// pre-dirty no longer absorbs it) + ERROR (throwing fn).
-		expect(deliveries).toBe(3);
-
-		source.down([[DIRTY], [DATA, 2]]);
-		// No additional deliveries after terminal ERROR
-		expect(deliveries).toBe(3);
-		unsub();
-	});
-
-	// Regression: GRAPHREFLY-SPEC §2.5 — custom equals never receives undefined (initial cached state).
-	it("custom equals is not called with undefined on first computation", () => {
-		const source = node<number>({ initial: 1 });
-		let equalsCalled = false;
-		const mid = node(
-			[source],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit(new Map([["k", data[0]]]));
-			},
-			{
-				describeKind: "derived",
-				equals: (a, b) => {
-					equalsCalled = true;
-					// This would crash if a were undefined: (a as Map<...>).size
-					return (a as Map<string, unknown>).size === (b as Map<string, unknown>).size;
-				},
-			},
-		);
-		const unsub = mid.subscribe(() => {});
-		// First computation should NOT call equals (cached is still undefined)
-		expect(equalsCalled).toBe(false);
-		// Change source value so fn re-runs with a different dep value
-		source.down([[DIRTY], [DATA, 2]]);
-		// Second computation should call equals (both sides are real Maps)
-		expect(equalsCalled).toBe(true);
-		unsub();
-	});
-
-	// Spec: GRAPHREFLY-SPEC §1.3
-	it("ERROR message tuple contains the exact thrown Error instance as payload", () => {
-		const source = node<number>({ initial: 0 });
-		const theError = new Error("exact-instance");
-		const broken = node([source], (_batchData, _actions) => {
-			throw theError;
-		});
-		const collected: unknown[][] = [];
-		const unsub = broken.subscribe((messages) => {
-			collected.push([...messages]);
-		});
-
-		source.down([[DATA, 1]]);
-		unsub();
-
-		// Find the ERROR message tuple across all collected batches
-		const errorMsg = collected.flat().find((m) => (m as unknown[])[0] === ERROR) as
-			| unknown[]
-			| undefined;
-		expect(errorMsg).toBeDefined();
-		expect(errorMsg?.[0]).toBe(ERROR);
-		// Error is wrapped with node name context; original is in .cause
-		const wrapped = errorMsg?.[1] as Error;
-		expect(wrapped).toBeInstanceOf(Error);
-		expect(wrapped.message).toContain("fn threw");
-		expect(wrapped.cause).toBe(theError);
-	});
-
-	it("resetOnTeardown clears cached value on TEARDOWN", () => {
-		const n = node<number>({ initial: 42, resetOnTeardown: true });
-		const unsub = n.subscribe(() => undefined);
-		expect(n.cache).toBe(42);
-		n.down([[TEARDOWN]]);
-		expect(n.cache).toBeUndefined();
-		unsub();
-	});
-
-	it("resubscribable nodes allow fresh subscriptions after terminal", () => {
-		const n = node<number>({ initial: 1, resubscribable: true });
-		const seen: symbol[] = [];
-		const unsub1 = n.subscribe((messages) => {
-			for (const m of messages) {
-				seen.push(m[0] as symbol);
-			}
-		});
-
-		n.down([[COMPLETE]]);
-		unsub1();
-
-		const unsub2 = n.subscribe(() => undefined);
-		n.down([[DATA, 2]]);
-		unsub2();
-
-		expect(seen).toContain(COMPLETE);
-		expect(n.cache).toBe(2);
-	});
-
-	it("passthrough node forwards unknown message types", () => {
-		const CUSTOM = Symbol("custom");
-		const source = node<number>({ initial: 0 });
-		const passthrough = node([source]);
-		const seen: symbol[] = [];
-		const unsub = passthrough.subscribe((messages) => {
-			for (const m of messages) {
-				seen.push(m[0] as symbol);
-			}
-		});
-
-		source.down([[CUSTOM, 1]]);
-		unsub();
-
-		expect(seen).toContain(CUSTOM);
-	});
-
-	it("supports node(deps, opts) without fn as passthrough form", () => {
-		const source = node<number>({ initial: 1 });
-		const wire = node([source], { name: "wire" });
-		const seen: symbol[] = [];
-		const unsub = wire.subscribe((messages) => {
-			for (const m of messages) {
-				seen.push(m[0] as symbol);
-			}
-		});
-
-		source.down([[DATA, 2]]);
-		unsub();
-
-		expect(wire.name).toBe("wire");
-		expect(seen).toContain(DATA);
-	});
-
-	it("forwards PAUSE and RESUME through a derived node", () => {
-		const source = node<number>({ initial: 0 });
-		const d = node(
-			[source],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit(data[0] as number);
-			},
-			{ describeKind: "derived" },
-		);
-		const seen: symbol[] = [];
-		const unsub = d.subscribe((messages) => {
-			for (const m of messages) {
-				seen.push(m[0] as symbol);
-			}
-		});
-
-		source.down([[PAUSE, "lock"]]);
-		source.down([[RESUME, "lock"]]);
-		unsub();
-
-		expect(seen).toContain(PAUSE);
-		expect(seen).toContain(RESUME);
-	});
-
-	it("forwards PAUSE then RESUME through multi-hop derived chain", () => {
-		const source = node<number>({ initial: 1 });
-		const hop = node(
-			[source],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit(data[0] as number);
-			},
-			{ describeKind: "derived" },
-		);
-		const leaf = node(
-			[hop],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as number) * 2);
-			},
-			{ describeKind: "derived" },
-		);
-		const seen: symbol[] = [];
-		const unsub = leaf.subscribe((messages) => {
-			for (const m of messages) {
-				seen.push(m[0] as symbol);
-			}
-		});
-
-		source.down([[PAUSE, "lock-a"]]);
-		source.down([[RESUME, "lock-a"]]);
-		unsub();
-
-		expect(seen.indexOf(PAUSE)).toBeGreaterThanOrEqual(0);
-		expect(seen.indexOf(RESUME)).toBeGreaterThan(seen.indexOf(PAUSE));
-	});
-
-	it("INVALIDATE propagates and clears caches along multi-hop derived chain", () => {
-		const source = node<number>({ initial: 42 });
-		const hop = node(
-			[source],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit(data[0] as number);
-			},
-			{ describeKind: "derived" },
-		);
-		const leaf = node(
-			[hop],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as number) + 1);
-			},
-			{ describeKind: "derived" },
-		);
-		let sawInvalidate = false;
-		const unsub = leaf.subscribe((messages) => {
-			sawInvalidate ||= messages.some((m) => m[0] === INVALIDATE);
-		});
-
-		expect(leaf.cache).toBe(43);
-		source.down([[INVALIDATE]]);
-		unsub();
-
-		expect(sawInvalidate).toBe(true);
-		expect(source.cache).toBeUndefined();
-		expect(hop.cache).toBeUndefined();
-		expect(leaf.cache).toBeUndefined();
-		// ROM rule: state nodes preserve status across disconnect.
-		// DS-13.5.A: INVALIDATE transitions status to "sentinel" (cache
-		// cleared, no pending update); unsub() doesn't change that.
-		expect(source.status).toBe("sentinel");
-	});
-
-	it("INVALIDATE clears dep memo so identical DATA triggers recompute", () => {
-		const source = node<number>({ initial: 7 });
-		let runs = 0;
-		const d = node(
-			[source],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				runs += 1;
-				actions.emit((data[0] as number) + 1);
-			},
-			{ describeKind: "derived" },
-		);
-		const unsub = d.subscribe(() => undefined);
-		expect(runs).toBe(1);
-		expect(d.cache).toBe(8);
-		source.down([[INVALIDATE]]);
-		source.down([[DIRTY], [DATA, 7]]);
-
-		expect(runs).toBe(2);
-		expect(d.cache).toBe(8);
-		unsub();
-	});
-
-	it("supports node(fn, opts) producer form", () => {
-		const p = node(
-			(_data, actions) => {
-				actions.down([[DATA, 42]]);
-			},
-			{ name: "producer-like" },
-		);
-		const values: number[] = [];
-		const unsub = p.subscribe((messages) => {
-			for (const m of messages) {
-				if (m[0] === DATA) {
-					values.push(m[1] as number);
-				}
-			}
-		});
-		unsub();
-
-		expect(p.name).toBe("producer-like");
-		// Producer emits 42 during _startProducer → delivered to subscriber
-		// via _downToSinks. Subscribe-time push is skipped (value was freshly
-		// produced during this subscribe call).
-		expect(values).toEqual([42]);
-	});
-
-	it("completeWhenDepsComplete: false suppresses auto-COMPLETE", () => {
-		const a = node<number>({ initial: 1 });
-		const b = node<number>({ initial: 2 });
-		const d = node(
-			[a, b],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as number) + (data[1] as number));
-			},
-			{ describeKind: "derived", completeWhenDepsComplete: false },
-		);
-		const seen: symbol[] = [];
-		const unsub = d.subscribe((messages) => {
-			for (const m of messages) {
-				seen.push(m[0] as symbol);
-			}
-		});
-
-		a.down([[COMPLETE]]);
-		b.down([[COMPLETE]]);
-		unsub();
-
-		expect(seen).not.toContain(COMPLETE);
-		expect(d.status).not.toBe("completed");
-	});
-
-	it("completeWhenDepsComplete: true (default) emits COMPLETE when all deps complete", () => {
-		const a = node<number>({ initial: 1 });
-		const b = node<number>({ initial: 2 });
-		const d = node(
-			[a, b],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as number) + (data[1] as number));
-			},
-			{ describeKind: "derived" },
-		);
-		const seen: symbol[] = [];
-		const unsub = d.subscribe((messages) => {
-			for (const m of messages) {
-				seen.push(m[0] as symbol);
-			}
-		});
-
-		a.down([[COMPLETE]]);
-		expect(seen).not.toContain(COMPLETE);
-
-		b.down([[COMPLETE]]);
-		unsub();
-
-		expect(seen).toContain(COMPLETE);
-	});
-
-	it("supports >31 dependencies via Uint32Array bitmask", () => {
-		const sources: ReturnType<typeof node<number>>[] = [];
-		for (let i = 0; i < 40; i++) {
-			sources.push(node<number>({ initial: i }));
-		}
-
-		let fnRuns = 0;
-		const sum = node(
-			sources,
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				fnRuns += 1;
-				actions.emit((data as number[]).reduce((a, b) => a + b, 0));
-			},
-			{ describeKind: "derived" },
-		);
-
-		const unsub = sum.subscribe(() => undefined);
-		const before = fnRuns;
-
-		// Update source at index 35 (beyond 31-bit limit)
-		sources[35].down([[DIRTY], [DATA, 100]]);
-
-		expect(fnRuns - before).toBe(1);
-		// Original sum: 0+1+...+39 = 780. Replace 35 with 100: 780 - 35 + 100 = 845
-		expect(sum.cache).toBe(845);
-		unsub();
-	});
-
-	it(">31 deps: diamond settlement works correctly", () => {
-		const sources: ReturnType<typeof node<number>>[] = [];
-		for (let i = 0; i < 35; i++) {
-			sources.push(node<number>({ initial: 0 }));
-		}
-
-		let fnRuns = 0;
-		const combined = node(
-			sources,
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				fnRuns += 1;
-				actions.emit((data as number[]).reduce((a, b) => a + b, 0));
-			},
-			{ describeKind: "derived" },
-		);
-
-		const unsub = combined.subscribe(() => undefined);
-		const before = fnRuns;
-
-		// Update two sources — should still settle once
-		batch(() => {
-			sources[0].down([[DIRTY], [DATA, 10]]);
-			sources[34].down([[DIRTY], [DATA, 20]]);
-		});
-
-		expect(fnRuns - before).toBe(1);
-		expect(combined.cache).toBe(30);
-		unsub();
-	});
-
-	it(">31 deps: COMPLETE fires when all deps complete", () => {
-		const sources: ReturnType<typeof node<number>>[] = [];
-		for (let i = 0; i < 35; i++) {
-			sources.push(node<number>({ initial: i }));
-		}
-
-		const combined = node(
-			sources,
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data as number[]).reduce((a, b) => a + b, 0));
-			},
-			{ describeKind: "derived" },
-		);
-		const seen: symbol[] = [];
-		const unsub = combined.subscribe((messages) => {
-			for (const m of messages) {
-				seen.push(m[0] as symbol);
-			}
-		});
-
-		// Complete all but last
-		for (let i = 0; i < 34; i++) {
-			sources[i].down([[COMPLETE]]);
-		}
-		expect(seen).not.toContain(COMPLETE);
-
-		// Complete the last one
-		sources[34].down([[COMPLETE]]);
-		unsub();
-
-		expect(seen).toContain(COMPLETE);
-	});
-
-	it("chain computes correctly through derived nodes", () => {
-		const source = node<number>({ initial: 0 });
-		const d1 = node(
-			[source],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as number) * 2);
-			},
-			{ describeKind: "derived" },
-		);
-		const leaf = node(
-			[d1],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as number) + 100);
-			},
-			{ describeKind: "derived" },
-		);
-		const unsub = leaf.subscribe(() => undefined);
-
-		source.down([[DIRTY], [DATA, 5]]);
-
-		// Values propagate correctly through chain
-		expect(d1.cache).toBe(10);
-		expect(leaf.cache).toBe(110);
-		unsub();
-	});
-
-	it("diamond still settles once", () => {
-		const a = node<number>({ initial: 0 });
-		const b = node(
-			[a],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as number) + 1);
-			},
-			{ describeKind: "derived" },
-		);
-		const c = node(
-			[a],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as number) + 2);
-			},
-			{ describeKind: "derived" },
-		);
-		let dRuns = 0;
-		const d = node(
-			[b, c],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				dRuns += 1;
-				actions.emit((data[0] as number) + (data[1] as number));
-			},
-			{ describeKind: "derived" },
-		);
-
-		const unsub = d.subscribe(() => undefined);
-		const before = dRuns;
-		a.down([[DIRTY], [DATA, 5]]);
-		const after = dRuns;
-
-		// Diamond settlement works correctly
-		expect(after - before).toBe(1);
-		expect(d.cache).toBe(13);
-		unsub();
-	});
-
-	it("DIRTY is always delivered to subscribers", () => {
-		const source = node<number>({ initial: 0 });
-		const d1 = node(
-			[source],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as number) + 1);
-			},
-			{ describeKind: "derived" },
-		);
-		const d2 = node(
-			[source],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as number) + 2);
-			},
-			{ describeKind: "derived" },
-		);
-
-		const e1: symbol[][] = [];
-		const e2: symbol[][] = [];
-		const unsub1 = d1.subscribe((msgs) => {
-			e1.push(msgs.map((m) => m[0] as symbol));
-		});
-		const unsub2 = d2.subscribe((msgs) => {
-			e2.push(msgs.map((m) => m[0] as symbol));
-		});
-
-		e1.length = 0;
-		e2.length = 0;
-		source.down([[DIRTY], [DATA, 5]]);
-		unsub1();
-		unsub2();
-
-		// DIRTY is always present
-		const allTypes1 = e1.flat();
-		const allTypes2 = e2.flat();
-		expect(allTypes1).toContain(DIRTY);
-		expect(allTypes2).toContain(DIRTY);
-	});
-
-	it("handles RESOLVED for unchanged values", () => {
-		const source = node<number>({ initial: 1 });
-		const d = node(
-			[source],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as number) > 0 ? "positive" : "negative");
-			},
-			{ describeKind: "derived" },
-		);
-		const unsub1 = d.subscribe(() => undefined);
-
-		const emissions: symbol[][] = [];
-		unsub1();
-		const unsub2 = d.subscribe((msgs) => {
-			emissions.push(msgs.map((m) => m[0] as symbol));
-		});
-
-		emissions.length = 0;
-		// Value changes but derived result stays "positive"
-		source.down([[DIRTY], [DATA, 2]]);
-
-		expect(d.cache).toBe("positive");
-		// Should emit RESOLVED (not DATA) since value unchanged
-		const allTypes = emissions.flat();
-		expect(allTypes).toContain(RESOLVED);
-		expect(allTypes).not.toContain(DATA);
-		unsub2();
-	});
-
-	it("standalone DIRTY passes through to derived nodes", () => {
-		const source = node<number>({ initial: 0 });
-		const d = node(
-			[source],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as number) * 2);
-			},
-			{ describeKind: "derived" },
-		);
-		const seen: symbol[] = [];
-		const unsub = d.subscribe((messages) => {
-			for (const m of messages) {
-				seen.push(m[0] as symbol);
-			}
-		});
-
-		seen.length = 0;
-		// Standalone DIRTY without DATA — must NOT be swallowed
-		source.down([[DIRTY]]);
-
-		expect(seen).toContain(DIRTY);
-		unsub();
-	});
-
-	it("dep COMPLETE after DIRTY does not block settlement", () => {
-		const a = node<number>({ initial: 1 });
-		const b = node<number>({ initial: 2 });
-		let fnRuns = 0;
-		const d = node(
-			[a, b],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				fnRuns += 1;
-				actions.emit((data[0] as number) + (data[1] as number));
-			},
-			{ describeKind: "derived" },
-		);
-
-		const unsub = d.subscribe(() => undefined);
-		const before = fnRuns;
-
-		// a sends DIRTY, then COMPLETEs instead of DATA/RESOLVED
-		// b sends a normal update
-		a.down([[DIRTY]]);
-		a.down([[COMPLETE]]);
-		b.down([[DIRTY], [DATA, 10]]);
-
-		// derived should still recompute with latest values
-		expect(fnRuns).toBeGreaterThan(before);
-		expect(d.cache).toBe(11); // a=1 (initial, no DATA), b=10
-		unsub();
-	});
-
-	it("multi-dep passthrough waits for all deps to COMPLETE", () => {
-		const a = node<number>({ initial: 1 });
-		const b = node<number>({ initial: 2 });
-		const wire = node([a, b], { name: "wire" });
-		const seen: symbol[] = [];
-		const unsub = wire.subscribe((messages) => {
-			for (const m of messages) {
-				seen.push(m[0] as symbol);
-			}
-		});
-
-		a.down([[COMPLETE]]);
-		expect(seen).not.toContain(COMPLETE);
-		expect(wire.status).not.toBe("completed");
-
-		b.down([[COMPLETE]]);
-		expect(seen).toContain(COMPLETE);
-		unsub();
-	});
-
-	it("double-unsubscribe is safe", () => {
-		const source = node<number>({ initial: 0 });
-		const d1 = node(
-			[source],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as number) + 1);
-			},
-			{ describeKind: "derived" },
-		);
-		const d2 = node(
-			[source],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as number) + 2);
-			},
-			{ describeKind: "derived" },
-		);
-		const d3 = node(
-			[source],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as number) + 3);
-			},
-			{ describeKind: "derived" },
-		);
-
-		const unsub1 = d1.subscribe(() => undefined);
-		const unsub2 = d2.subscribe(() => undefined);
-		const unsub3 = d3.subscribe(() => undefined);
-
-		// Double-unsubscribe should not corrupt counter state
-		unsub2();
-		unsub2();
-
-		unsub1();
-		unsub3();
-
-		// Source should still work after all unsubs
-		source.down([[DIRTY], [DATA, 5]]);
-		expect(source.cache).toBe(5);
-	});
-});
-
-describe("D1: sink snapshot during emitToSinks", () => {
-	it("unsubscribing another sink mid-delivery does not skip it", () => {
-		const src = node<number>();
-		const log: string[] = [];
-		let unsubB: () => void = () => {};
-		const unsubA = src.subscribe((msgs) => {
-			// Only unsub B during the actual DATA delivery (ignore the
-			// subscribe-time [[START]] handshake).
-			if (msgs.some((m) => m[0] === DATA)) {
-				log.push("A");
-				unsubB();
-			}
-		});
-		unsubB = src.subscribe((msgs) => {
-			if (msgs.some((m) => m[0] === DATA)) log.push("B");
-		});
-		src.down([[DIRTY], [DATA, 1]]);
-		// Both should have been called despite A removing B mid-iteration
-		expect(log).toContain("A");
-		expect(log).toContain("B");
-		unsubA();
-	});
-});
-
-describe("D2: DIRTY→COMPLETE without DATA unsticks dirty node", () => {
-	it("dep goes DIRTY then COMPLETE (no DATA) — derived resolves", () => {
-		const a = node({ initial: 1 });
-		const b = node({ initial: 2 });
-		const sinkMsgs: symbol[][] = [];
-		const d = node(
-			[a, b],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as number) + (data[1] as number));
-			},
-			{ describeKind: "derived" },
-		);
-		d.subscribe((msgs) => {
-			sinkMsgs.push(msgs.map((m) => m[0] as symbol));
-		});
-		expect(d.cache).toBe(3);
-
-		// a goes DIRTY then COMPLETE without DATA
-		a.down([[DIRTY]]);
-		expect(d.status).toBe("dirty");
-		a.down([[COMPLETE]]);
-		// Dep values unchanged → runFn fires the equality shortcut → RESOLVED
-		// Node must NOT stay stuck in "dirty".
-		expect(d.status).not.toBe("dirty");
-		// Sinks should have received DIRTY then RESOLVED (value unchanged)
-		const flat = sinkMsgs.flat();
-		expect(flat).toContain(DIRTY);
-		expect(flat).toContain(RESOLVED);
-	});
-
-	it("dep goes DIRTY then COMPLETE — multi-dep diamond unsticks", () => {
-		const a = node({ initial: 1 });
-		const b = node({ initial: 2 });
-		const d = node(
-			[a, b],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as number) + (data[1] as number));
-			},
-			{ describeKind: "derived" },
-		);
-		d.subscribe(() => undefined);
-
-		// Both deps go dirty, only b settles; a completes without DATA
-		a.down([[DIRTY]]);
-		b.down([[DIRTY]]);
-		expect(d.status).toBe("dirty");
-		b.down([[DATA, 20]]);
-		// b settled but a still dirty → no recompute yet
-		a.down([[COMPLETE]]);
-		// Now a is done (no pending dirty bits) → derived should recompute
-		expect(d.status).not.toBe("dirty");
-		expect(d.cache).toBe(21); // 1 + 20
-	});
-});
-
-describe("D3: TEARDOWN updates status to sentinel", () => {
-	it("source node status becomes sentinel after TEARDOWN", () => {
-		const src = node({ initial: 1 });
-		expect(src.status).toBe("settled");
-		src.down([[TEARDOWN]]);
-		expect(src.status).toBe("sentinel");
-	});
-
-	it("terminated node status becomes sentinel after TEARDOWN (B3)", () => {
-		const src = node({ initial: 1 });
-		src.down([[COMPLETE]]);
-		expect(src.status).toBe("completed");
-		src.down([[TEARDOWN]]);
-		expect(src.status).toBe("sentinel");
-	});
-});
-
-describe("connect-order re-entrancy guard", () => {
-	it("multi-dep node sees all dep values on first compute (no premature runFn)", () => {
-		// dep `a` emits DATA immediately on subscribe (producer pattern).
-		// Without the _connecting guard, `runFn` would fire during the subscribe
-		// loop before `b` is wired, seeing b.cache as undefined.
-		const a = node(
-			(_data, actions) => {
-				actions.down([[DATA, "from-a"]]);
-			},
-			{ name: "a" },
-		);
-		const b = node<number>({ initial: 42, name: "b" });
-
-		const seen: unknown[][] = [];
-		const d = node(
-			[a, b],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				seen.push([...data]);
-				actions.emit(`${data[0]}-${data[1]}`);
-			},
-			{ describeKind: "derived" },
-		);
-
-		const unsub = d.subscribe(() => undefined);
-
-		// The first (and ideally only) runFn call should see both dep values
-		expect(seen.length).toBeGreaterThanOrEqual(1);
-		expect(seen[0]).toEqual(["from-a", 42]);
-		expect(d.cache).toBe("from-a-42");
-		unsub();
-	});
-
-	it("connect guard does not suppress post-connect updates", () => {
-		const a = node(
-			(_data, actions) => {
-				actions.down([[DATA, 1]]);
-			},
-			{ name: "a" },
-		);
-		const b = node<number>({ initial: 2, name: "b" });
-		const d = node(
-			[a, b],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as number) + (data[1] as number));
-			},
-			{ describeKind: "derived" },
-		);
-		const unsub = d.subscribe(() => undefined);
-
-		// After connect, normal updates still propagate
-		b.down([[DIRTY], [DATA, 10]]);
-		expect(d.cache).toBe(11);
-		unsub();
-	});
-
-	it("runFn terminal guard: dep updates after COMPLETE do not recompute", () => {
-		const src = node({ initial: 1 });
-		let recompute = 0;
-		const d = node(
-			[src],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				recompute += 1;
-				actions.emit(data[0]);
-			},
-			{ describeKind: "derived" },
-		);
-		d.subscribe(() => undefined);
-		expect(recompute).toBe(1);
-		src.down([[COMPLETE]]);
-		// fn runs once more on the terminal event so operators like
-		// last()/reduce can emit final values via ctx.terminalDeps.
-		expect(recompute).toBe(2);
-		expect(d.status).toBe("completed");
-		src.down([[DIRTY], [DATA, 2]]);
-		// After completion, no further recomputes.
-		expect(recompute).toBe(2);
-	});
-
-	it("TEARDOWN after COMPLETE runs lifecycle and reaches sinks (B3)", () => {
-		const src = node({ initial: 1 });
-		const n = node(
-			[src],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit(data[0]);
-			},
-			{ describeKind: "derived", meta: { m: 0 } },
-		);
-		const sinkTypes: symbol[] = [];
-		let metaSawTeardown = false;
-		const unsubMeta = n.meta.m.subscribe((msgs) => {
-			if (msgs.some((m) => m[0] === TEARDOWN)) metaSawTeardown = true;
-		});
-		const unsub = n.subscribe((msgs) => {
-			for (const m of msgs) sinkTypes.push(m[0] as symbol);
-		});
-		src.down([[COMPLETE]]);
-		expect(n.status).toBe("completed");
-		n.down([[TEARDOWN]]);
-		expect(metaSawTeardown).toBe(true);
-		expect(sinkTypes.filter((t) => t === TEARDOWN).length).toBeGreaterThanOrEqual(1);
-		unsub();
-		unsubMeta();
-	});
-});
-
-describe("meta (companion stores)", () => {
-	it("meta keys are subscribable nodes with initial values", () => {
-		const n = node(
-			[node({ initial: 0 })],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit(data[0]);
-			},
-			{ describeKind: "derived", name: "with-meta", meta: { description: "hi", status: "idle" } },
-		);
-		expect(n.meta.description.cache).toBe("hi");
-		expect(n.meta.status.cache).toBe("idle");
-		expect(metaSnapshot(n)).toEqual({ description: "hi", status: "idle" });
-	});
-
-	it("meta field is independently subscribable from the parent node", () => {
-		const src = node({ initial: 1 });
-		const n = node(
-			[src],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as number) * 2);
-			},
-			{ describeKind: "derived", meta: { err: null as string | null } },
-		);
-		const seen: symbol[][] = [];
-		const unsub = n.meta.err.subscribe((msgs) => {
-			seen.push(msgs.map((m) => m[0] as symbol));
-		});
-		n.meta.err.down([[DIRTY], [DATA, "bad"]]);
-		unsub();
-		// Subscribe handshake partitions [[START], [DATA, null]]: START (tier 0)
-		// delivers first, DATA (tier 3) second. Then the explicit down() further
-		// partitions into DIRTY and DATA.
-		expect(seen).toEqual([[START], [DATA], [DIRTY], [DATA]]);
-		expect(metaSnapshot(n).err).toBe("bad");
-	});
-
-	it("meta can be updated without subscribing to the parent", () => {
-		const n = node({ initial: 0, meta: { tag: "a" } });
-		expect(n.meta.tag.cache).toBe("a");
-		n.meta.tag.down([[DATA, "b"]]);
-		expect(n.meta.tag.cache).toBe("b");
-		expect(metaSnapshot(n)).toEqual({ tag: "b" });
-	});
-
-	it("metaSnapshot is empty when no meta option", () => {
-		const n = node({ initial: 1 });
-		expect(metaSnapshot(n)).toEqual({});
-	});
-
-	it("parent TEARDOWN still disconnects when one meta.down throws", () => {
-		const src = node({ initial: 1 });
-		const n = node(
-			[src],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as number) * 2);
-			},
-			{ describeKind: "derived", meta: { flaky: 0, stable: 1 } },
-		);
-		const origFlakyDown = n.meta.flaky.down.bind(n.meta.flaky);
-		n.meta.flaky.down = (msgs) => {
-			if (msgs[0]?.[0] === TEARDOWN) throw new Error("meta teardown boom");
-			origFlakyDown(msgs);
-		};
-		let stableSawTeardown = false;
-		const unsubStable = n.meta.stable.subscribe((msgs) => {
-			if (msgs.some((m) => m[0] === TEARDOWN)) stableSawTeardown = true;
-		});
-		const unsub = n.subscribe(() => {});
-		n.down([[TEARDOWN]]);
-		expect(stableSawTeardown).toBe(true);
-		expect(n.status).toBe("sentinel");
-		unsub();
-		unsubStable();
-	});
-
-	it("parent TEARDOWN propagates to every meta child when none throw", () => {
-		const n = node({ initial: 0, meta: { a: 1, b: 2, c: 3 } });
-		const saw: string[] = [];
-		const unsubs = (["a", "b", "c"] as const).map((key) =>
-			n.meta[key].subscribe((msgs) => {
-				if (msgs.some((m) => m[0] === TEARDOWN)) saw.push(key);
-			}),
-		);
-		n.down([[TEARDOWN]]);
-		expect(saw.sort()).toEqual(["a", "b", "c"]);
-		for (const u of unsubs) u();
-	});
-
-	it("TEARDOWN runs stopProducer even when meta.down throws (producer restarts on resubscribe)", () => {
-		let producerRuns = 0;
-		const p = node(
-			(_data, actions) => {
-				producerRuns += 1;
-				actions.down([[DATA, producerRuns]]);
-			},
-			{ meta: { m: 0 } },
-		);
-		const origMetaDown = p.meta.m.down.bind(p.meta.m);
-		p.meta.m.down = (msgs) => {
-			if (msgs[0]?.[0] === TEARDOWN) throw new Error("meta teardown boom");
-			origMetaDown(msgs);
-		};
-		const u1 = p.subscribe(() => undefined);
-		expect(producerRuns).toBe(1);
-		p.down([[TEARDOWN]]);
-		expect(producerRuns).toBe(1);
-		u1();
-		const u2 = p.subscribe(() => undefined);
-		expect(producerRuns).toBe(2);
-		u2();
-	});
-
-	it("metaSnapshot omits keys when cache getter throws", () => {
-		const n = node({ initial: 0, meta: { fine: 1, bad: 2 } });
-		Object.defineProperty(n.meta.bad, "cache", {
-			get: () => {
-				throw new Error("no snapshot");
-			},
-		});
-		expect(metaSnapshot(n)).toEqual({ fine: 1 });
-	});
-
-	it("metaSnapshot omits every key whose cache getter throws", () => {
-		const n = node({ initial: 0, meta: { ok: 0, x: 1, y: 2 } });
-		for (const key of ["x", "y"] as const) {
-			Object.defineProperty(n.meta[key], "cache", {
-				get: () => {
-					throw new Error("bad");
-				},
-			});
-		}
-		expect(metaSnapshot(n)).toEqual({ ok: 0 });
-	});
-
-	it("meta mapping is frozen (read-only parity with graphrefly-py MappingProxyType)", () => {
-		const n = node({ initial: 0, meta: { k: 1 } });
-		expect(Object.isFrozen(n.meta)).toBe(true);
-	});
-
-	it("describeNode includes meta and spec fields", () => {
-		const n = node({
-			initial: 0,
-			meta: { description: "purpose", type_hint: "integer" },
-			name: "retry_limit",
-		});
-		const d = describeNode(n);
-		expect(d.type).toBe("state");
-		expect(d.status).toBe("settled");
-		expect(d.name).toBe("retry_limit");
-		expect(d.deps).toEqual([]);
-		expect(d.meta).toEqual({ description: "purpose", type_hint: "integer" });
-		expect(d.value).toBe(0);
-	});
-
-	it("describeNode derived lists dep names", () => {
-		const src = node({ initial: 1, name: "input" });
-		const n = node(
-			[src],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as number) * 2);
-			},
-			{ describeKind: "derived", name: "validate", meta: { description: "ok" } },
-		);
-		const snap = describeNode(n);
-		expect(snap.type).toBe("derived");
-		expect(snap.deps).toEqual(["input"]);
-		expect(snap.meta).toEqual({ description: "ok" });
-	});
-});
-
-// §3.5 — equals substitution is a tier-3 dispatch invariant.
-// Every outgoing DATA payload is compared against the live `.cache` inside
-// `_updateState` (inside `_emit`), regardless of emission path: `actions.emit`,
-// `actions.down`, `node.down`, or bundle-wrapped down. Cache advances per
-// DATA immediately, so successive emissions within one fn run see the
-// progressively updated value. See archive/docs/SESSION-foundation-redesign.md
-// §3.5.1–.3.
-describe("§3.5 equals substitution — dispatch-layer invariant", () => {
-	function collectTier3(n: ReturnType<typeof node<number>>): {
-		msgs: symbol[];
-		values: Array<number | undefined>;
-		unsub: () => void;
-	} {
-		const msgs: symbol[] = [];
-		const values: Array<number | undefined> = [];
-		const unsub = n.subscribe((batch) => {
-			for (const m of batch) {
-				msgs.push(m[0] as symbol);
-				values.push(m[0] === DATA ? (m[1] as number) : undefined);
-			}
-		});
-		// subscribe() synchronously delivers the START handshake (plus the
-		// paired initial DATA if the node already has a cache). Drop that
-		// baseline so tests only assert on emissions they trigger themselves.
-		msgs.length = 0;
-		values.length = 0;
-		return { msgs, values, unsub };
-	}
-
-	it("multi-emit within a producer fn sees progressively advanced cache", () => {
-		// Edge case from SESSION-foundation-redesign.md §3.5.1: fn emits
-		// v1, v2, v3, v2 starting from cache=2. Each emit must see the
-		// LIVE cache (advanced by the previous emit), not a snapshot at
-		// fn entry. Downstream must see DATA(1),DATA(2),DATA(3),DATA(2) —
-		// no spurious RESOLVED collapse — and the final node cache must
-		// equal the last value actually emitted (2).
-		const src = node<number>({ initial: 2 });
-		const { msgs, values, unsub } = collectTier3(src);
-
-		src.emit(1);
-		src.emit(2);
-		src.emit(3);
-		src.emit(2);
-
-		expect(msgs.filter((m) => m === DATA)).toHaveLength(4);
-		expect(msgs.filter((m) => m === RESOLVED)).toHaveLength(0);
-		expect(values.filter((v): v is number => v != null)).toEqual([1, 2, 3, 2]);
-		expect(src.cache).toBe(2);
-		unsub();
-	});
-
-	it("actions.emit(same) collapses to RESOLVED when value equals live cache", () => {
-		const src = node<number>({ initial: 7 });
-		const { msgs, unsub } = collectTier3(src);
-
-		src.emit(7); // same as cache — should collapse
-
-		expect(msgs).toContain(RESOLVED);
-		expect(msgs.filter((m) => m === DATA)).toHaveLength(0);
-		expect(src.cache).toBe(7);
-		unsub();
-	});
-
-	it("raw node.down([[DATA, same]]) collapses to RESOLVED and synthesizes DIRTY (§1.3.1)", () => {
-		// §3.5.1: equals substitution is protocol-invariant, not opt-in.
-		// Raw `down([[DATA, same]])` runs through the dispatch-layer equals
-		// check inside `_updateState`. When substituting DATA→RESOLVED with
-		// no DIRTY in the wave, the walk synthesizes a DIRTY prefix so the
-		// emitted batch `[[DIRTY], [RESOLVED]]` remains spec §1.3.1
-		// compliant (DIRTY precedes RESOLVED).
-		const src = node<number>({ initial: 42 });
-		const { msgs, unsub } = collectTier3(src);
-
-		src.down([[DATA, 42]]);
-
-		expect(msgs).toEqual([DIRTY, RESOLVED]);
-		expect(src.cache).toBe(42);
-		unsub();
-	});
-
-	it("raw node.down([[DIRTY], [DATA, same]]) collapses DATA → RESOLVED without adding a second DIRTY", () => {
-		// Bundle-style raw emission: caller frames DIRTY+DATA explicitly.
-		// DIRTY is tier-1 and passes through unchanged. The tier-3 DATA
-		// gets equals-substituted when payload matches live cache. Because
-		// the caller already supplied DIRTY, the walk must NOT synthesize
-		// a second one.
-		const src = node<number>({ initial: 5 });
-		const { msgs, unsub } = collectTier3(src);
-
-		src.down([[DIRTY], [DATA, 5]]);
-
-		expect(msgs).toEqual([DIRTY, RESOLVED]);
-		expect(src.cache).toBe(5);
-		unsub();
-	});
-
-	it("raw down with two same-value DATAs in one batch: equals skipped, both pass through as DATA", () => {
-		// Multi-DATA batches skip equals substitution — running equals on
-		// every DATA is wasted when downstream fn must run regardless.
-		// Cache advances to the last value in the batch.
-		const src = node<number>({ initial: 9 });
-		const { msgs, values, unsub } = collectTier3(src);
-
-		src.down([
-			[DATA, 9],
-			[DATA, 9],
-		]);
-
-		expect(msgs).toEqual([DIRTY, DATA, DATA]);
-		expect(values.filter((v): v is number => v != null)).toEqual([9, 9]);
-		expect(src.cache).toBe(9);
-		unsub();
-	});
-
-	it("interleaved DATAs in multi-DATA batch: equals skipped, all pass through", () => {
-		// Multi-DATA batches skip equals — all DATAs pass through as-is.
-		// Cache advances sequentially (1 → 1 → 2).
-		const src = node<number>({ initial: 1 });
-		const { msgs, values, unsub } = collectTier3(src);
-
-		src.down([[DIRTY], [DATA, 1], [DATA, 1], [DATA, 2]]);
-
-		expect(msgs).toEqual([DIRTY, DATA, DATA, DATA]);
-		expect(values.filter((v): v is number => v != null)).toEqual([1, 1, 2]);
-		expect(src.cache).toBe(2);
-		unsub();
-	});
-
-	it("mixed emit+down+emit sequence sees coherent live cache through all paths", () => {
-		// actions.emit and raw down must share the same `.cache` view:
-		// 1. emit(x) when cache != x → DATA, cache = x
-		// 2. down([[DATA, x]]) with cache = x → collapses to RESOLVED
-		// 3. emit(x) again with cache = x → collapses to RESOLVED
-		const src = node<number>({ initial: 0 });
-		const { msgs, values, unsub } = collectTier3(src);
-
-		src.emit(5); // 0 → 5: DATA
-		src.down([[DATA, 5]]); // cache=5, same: RESOLVED (+ synthetic DIRTY)
-		src.emit(5); // cache=5, same: RESOLVED (via bundle DIRTY prefix)
-
-		expect(msgs.filter((m) => m === DATA)).toHaveLength(1);
-		expect(msgs.filter((m) => m === RESOLVED)).toHaveLength(2);
-		expect(values.filter((v): v is number => v != null)).toEqual([5]);
-		expect(src.cache).toBe(5);
-		unsub();
-	});
-
-	it("actions.emit(v) ≡ actions.down(bundle([DATA, v]).resolve()) — both paths hit the same dispatch walk", () => {
-		// §3.5.2 taxonomy: emit is sugar for bundle-wrapped raw down. Two
-		// identical state nodes emitting via the two paths must produce
-		// byte-for-byte identical wire output.
-		const nA = node<number>({ initial: 0 });
-		const nB = node<number>({ initial: 0 });
-		const collectedA = collectTier3(nA);
-		const collectedB = collectTier3(nB);
-
-		// nA uses actions.emit via node.emit sugar.
-		nA.emit(5);
-		// nB uses raw down with the exact batch bundle would produce for
-		// emit(5) when status is not already "dirty": `[[DIRTY], [DATA, 5]]`.
-		nB.down([[DIRTY], [DATA, 5]]);
-
-		// Both should produce [DIRTY, DATA(5)] — nA via bundle auto-prefix
-		// inside node.emit, nB via the explicit [DIRTY] in the raw batch.
-		expect(collectedA.msgs).toEqual(collectedB.msgs);
-		expect(collectedA.values).toEqual(collectedB.values);
-		expect(nA.cache).toBe(nB.cache);
-		collectedA.unsub();
-		collectedB.unsub();
-	});
-
-	it("actions.emit(v) and raw actions.down([[DATA, v]]) are equivalent — both auto-prefix DIRTY", () => {
-		// B1 unified dispatch: every entry point (emit, down, actions.*)
-		// flows through `_emit` → `_frameBatch`, which auto-prefixes
-		// DIRTY when any tier-3 payload is present and the node isn't
-		// already in `"dirty"` status. emit(v) and down([[DATA,v]]) now
-		// produce identical wire output.
-		const nEmit = node<number>({ initial: 0 });
-		const nRaw = node<number>({ initial: 0 });
-		const collectedEmit = collectTier3(nEmit);
-		const collectedRaw = collectTier3(nRaw);
-
-		nEmit.emit(6);
-		nRaw.down([[DATA, 6]]);
-
-		expect(collectedEmit.msgs).toEqual([DIRTY, DATA]);
-		expect(collectedRaw.msgs).toEqual([DIRTY, DATA]);
-		collectedEmit.unsub();
-		collectedRaw.unsub();
-	});
-
-	it("cache advance is visible to a post-DATA COMPLETE in the same walked batch", () => {
-		// §3.5.3 — mixed-tier cache-advance ordering. The walk processes
-		// messages in array order; when caller-supplied (or bundle-sorted)
-		// order is tier-monotone, the tier-3 slice fully advances cache
-		// before tier-4 handlers run. A COMPLETE observer sees the
-		// post-DATA cache.
-		const src = node<number>({ initial: 0 });
-		const finalSnapshot = { cache: -1 };
-		const unsub = src.subscribe((batch) => {
-			for (const m of batch) {
-				if (m[0] === COMPLETE) {
-					finalSnapshot.cache = src.cache ?? -1;
-				}
-			}
-		});
-
-		src.down([[DATA, 99], [COMPLETE]]);
-
-		expect(finalSnapshot.cache).toBe(99);
-		expect(src.cache).toBe(99);
-		unsub();
-	});
-
-	it("§3.5.3 unified dispatch path: tier sort happens inside _emit; cache advances within tier-3 slice", () => {
-		// Under B1 the bundle builder is gone — tier sort lives inside
-		// `_emit` → `_frameBatch`. Passing `[[COMPLETE], [DATA, 77]]`
-		// directly to `actions.down(...)` produces the same result: the
-		// framing stage sorts to tier order (DIRTY auto-prefix + DATA
-		// then COMPLETE), advances cache within the tier-3 slice before
-		// the COMPLETE handler runs, so downstream observers watching
-		// COMPLETE see `cache === 77`.
-		let completeCache = -1;
-		const src = node<number>(
-			[],
-			(_data, actions) => {
-				actions.down([[COMPLETE] as Message, [DATA, 77] as Message]);
-			},
-			{ initial: 0 },
-		);
-		const unsub = src.subscribe((batch) => {
-			for (const m of batch) {
-				if (m[0] === COMPLETE) completeCache = src.cache ?? -2;
-			}
-		});
-		expect(completeCache).toBe(77);
-		expect(src.cache).toBe(77);
-		unsub();
-	});
-
-	it("passthrough forwarding with custom-equals source: passthrough's own walk substitutes, not the source's", () => {
-		// A passthrough node (deps, no fn) forwards dep DATA through its
-		// own `_emit` → `_updateState`, which compares against the
-		// passthrough's own `_cached`. Two identical DATA emissions from
-		// the source produce DATA then RESOLVED at the passthrough — even
-		// though the passthrough code path never calls `actions.emit`.
-		//
-		// `src` uses `equals: () => false` so its own walk never collapses,
-		// ensuring the second DATA reaches `pass` unchanged and we can
-		// observe `pass`'s own substitution rather than src's.
-		const src = node<number>({ equals: (_a, _b) => false });
-		const pass = node<number>([src]);
-		const { msgs, unsub } = collectTier3(pass as ReturnType<typeof node<number>>);
-
-		src.down([[DIRTY], [DATA, 3]]);
-		src.down([[DIRTY], [DATA, 3]]);
-
-		const data = msgs.filter((m) => m === DATA);
-		const resolved = msgs.filter((m) => m === RESOLVED);
-		expect(data).toHaveLength(1); // first propagates as DATA
-		expect(resolved).toHaveLength(1); // second collapses at pass (exact count)
-		expect(pass.cache).toBe(3);
-		unsub();
-	});
-
-	it("initial: null is a real cached value — equals fires and collapses matching emit", () => {
-		// §2.5 load-bearing semantic: null is valid DATA; undefined is the
-		// protocol-reserved sentinel for "no cached value". A node with
-		// `initial: null` has _cached = null, so emit(null) collapses to
-		// RESOLVED via equals. A node with no initial has _cached = undefined
-		// (sentinel), so equals is skipped and the first emit(null) passes as DATA.
-		const nWithInitial = node<number | null>({ initial: null });
-		const nWithout = node<number | null>();
-
-		const collectedWith = collectTier3(nWithInitial as unknown as ReturnType<typeof node<number>>);
-		const collectedWithout = collectTier3(nWithout as unknown as ReturnType<typeof node<number>>);
-
-		nWithInitial.emit(null);
-		nWithout.emit(null);
-
-		// With initial: null — equals(null, null) = true → collapse to RESOLVED
-		expect(collectedWith.msgs.filter((m) => m === DATA)).toHaveLength(0);
-		expect(collectedWith.msgs).toContain(RESOLVED);
-
-		// Without initial — _cached = undefined (sentinel) → equals skipped → DATA
-		expect(collectedWithout.msgs.filter((m) => m === DATA)).toHaveLength(1);
-
-		collectedWith.unsub();
-		collectedWithout.unsub();
-	});
-
-	it("equals throw on single-DATA batch delivers DIRTY prefix then ERROR (P2 atomicity)", () => {
-		// When equals throws, the walk aborts, `_emit` delivers the
-		// successfully-walked prefix to sinks, then emits a fresh ERROR.
-		// Subscribers observe `[...walked_prefix, ERROR]`.
-		const src = node<number>({
-			initial: 0,
-			equals: () => {
-				throw new Error("equals boom");
-			},
-		});
-		const seen: Array<[symbol, unknown]> = [];
-		const unsub = src.subscribe((batch) => {
-			for (const m of batch) seen.push([m[0] as symbol, m[1]]);
-		});
-		// Truncate the START handshake baseline.
-		seen.length = 0;
-
-		// Single DATA batch: equals fires and throws. Walk aborts at
-		// index 1 (the DATA). Prefix `[DIRTY]` delivered, then ERROR.
-		src.down([[DATA, 5]]);
-
-		const msgKinds = seen.map(([k]) => k);
-		expect(msgKinds).toContain(DIRTY);
-		expect(msgKinds).toContain(ERROR);
-		expect(msgKinds).not.toContain(DATA);
-		// Cache stays at 0 — equals threw before cache could advance.
-		expect(src.cache).toBe(0);
-		unsub();
-	});
-});
diff --git a/packages/pure-ts/src/__tests__/core/perf-smoke.test.ts b/packages/pure-ts/src/__tests__/core/perf-smoke.test.ts
deleted file mode 100644
index 40c31c48..00000000
--- a/packages/pure-ts/src/__tests__/core/perf-smoke.test.ts
+++ /dev/null
@@ -1,35 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { DATA, DIRTY } from "../../core/messages.js";
-import { node } from "../../core/node.js";
-
-/**
- * Loose perf smoke — parity with graphrefly-py `tests/test_perf_smoke.py` (roadmap 0.7).
- * Correctness always; wall-clock only when `CI` is unset (GitHub Actions sets `CI=true`).
- */
-describe("perf smoke", () => {
-	it("many sequential DIRTY+DATA updates: correctness; wall clock off CI", () => {
-		const src = node<number>({ initial: 0 });
-		const d = node(
-			[src],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as number) + 1);
-			},
-			{ describeKind: "derived" },
-		);
-		d.subscribe(() => undefined);
-		const n = 40_000;
-		const t0 = performance.now();
-		for (let i = 0; i < n; i++) {
-			src.down([[DIRTY], [DATA, i]]);
-		}
-		const elapsed = (performance.now() - t0) / 1000;
-		expect(d.cache).toBe(n);
-		if (process.env.CI) {
-			return;
-		}
-		expect(elapsed).toBeLessThan(30);
-	});
-});
diff --git a/packages/pure-ts/src/__tests__/core/phase-13-6-b1.test.ts b/packages/pure-ts/src/__tests__/core/phase-13-6-b1.test.ts
deleted file mode 100644
index ba655648..00000000
--- a/packages/pure-ts/src/__tests__/core/phase-13-6-b1.test.ts
+++ /dev/null
@@ -1,168 +0,0 @@
-/**
- * Phase 13.6.B Batch 1 — verification tests for B1 locks.
- *
- * Sources:
- * - Lock 2.A field — `cfg.equalsThrowPolicy: "rethrow" | "log-and-continue"`
- * - Lock 2.F′ — `cfg.maxFnRerunDepth` + `cfg.maxBatchDrainIterations`
- * - Lock 6.A field — `cfg.pauseBufferMax`
- * - Lock 6.C′ — `dynamicNode` and `autoTrackNode` default `partial: true`
- * - Lock 6.H — INVALIDATE transitions emitting node to "sentinel" (regression
- *   coverage; behavior already landed via DS-13.5.A)
- *
- * Lock-side wiring (read-from-config) is staged for B4/B5; this file only
- * verifies the field surface and the default-flip behavior shipped in B1.
- */
-
-import { describe, expect, it } from "vitest";
-import { GraphReFlyConfig } from "../../core/config.js";
-import { DATA, DIRTY, INVALIDATE } from "../../core/messages.js";
-import { node } from "../../core/node.js";
-import { autoTrackNode, dynamicNode } from "../../core/sugar.js";
-
-describe("Phase 13.6.B B1 — config field additions (Locks 2.A, 2.F′, 6.A)", () => {
-	it("GraphReFlyConfig exposes maxFnRerunDepth with default 100", () => {
-		const cfg = new GraphReFlyConfig({
-			onMessage: () => undefined,
-			onSubscribe: () => undefined,
-		});
-		expect(cfg.maxFnRerunDepth).toBe(100);
-		cfg.maxFnRerunDepth = 250;
-		expect(cfg.maxFnRerunDepth).toBe(250);
-	});
-
-	it("GraphReFlyConfig exposes maxBatchDrainIterations with default 1000", () => {
-		const cfg = new GraphReFlyConfig({
-			onMessage: () => undefined,
-			onSubscribe: () => undefined,
-		});
-		expect(cfg.maxBatchDrainIterations).toBe(1000);
-		cfg.maxBatchDrainIterations = 2500;
-		expect(cfg.maxBatchDrainIterations).toBe(2500);
-	});
-
-	it("GraphReFlyConfig exposes pauseBufferMax with default 10_000", () => {
-		const cfg = new GraphReFlyConfig({
-			onMessage: () => undefined,
-			onSubscribe: () => undefined,
-		});
-		expect(cfg.pauseBufferMax).toBe(10_000);
-		cfg.pauseBufferMax = 500;
-		expect(cfg.pauseBufferMax).toBe(500);
-	});
-
-	it("GraphReFlyConfig exposes equalsThrowPolicy as 'rethrow' | 'log-and-continue'", () => {
-		const cfg = new GraphReFlyConfig({
-			onMessage: () => undefined,
-			onSubscribe: () => undefined,
-		});
-		// Default depends on NODE_ENV. Either is valid; only the surface matters
-		// for B1. Behavior wiring (Lock 2.A′) is staged for B5.
-		expect(["rethrow", "log-and-continue"]).toContain(cfg.equalsThrowPolicy);
-		cfg.equalsThrowPolicy = "rethrow";
-		expect(cfg.equalsThrowPolicy).toBe("rethrow");
-		cfg.equalsThrowPolicy = "log-and-continue";
-		expect(cfg.equalsThrowPolicy).toBe("log-and-continue");
-	});
-
-	it("config-field setters do NOT trigger freeze (operational, not protocol-shaping)", () => {
-		const cfg = new GraphReFlyConfig({
-			onMessage: () => undefined,
-			onSubscribe: () => undefined,
-		});
-		// Touch all four operational fields, then assert the registry is still mutable.
-		cfg.maxFnRerunDepth = 50;
-		cfg.maxBatchDrainIterations = 500;
-		cfg.pauseBufferMax = 100;
-		cfg.equalsThrowPolicy = "log-and-continue";
-		expect(cfg._isFrozen()).toBe(false);
-	});
-});
-
-describe("Phase 13.6.B B1 — Lock 6.C′ partial:true default flip", () => {
-	it("dynamicNode runs fn before all deps have delivered (partial:true default)", () => {
-		// Two source deps; only `a` emits before the dynamic fn runs. With
-		// partial:true (default), fn fires and `track(b)` returns undefined
-		// rather than waiting for b.
-		const a = node<number>([], { initial: 1 });
-		const b = node<number>([]); // sentinel — never emits DATA in this test
-		const seen: Array<{ av: unknown; bv: unknown }> = [];
-		const dyn = dynamicNode<{ av: unknown; bv: unknown }>([a, b], (track) => {
-			const av = track(a);
-			const bv = track(b);
-			return { av, bv };
-		});
-		const unsub = dyn.subscribe((msgs) => {
-			for (const m of msgs) {
-				if (m[0] === DATA) seen.push(m[1] as { av: unknown; bv: unknown });
-			}
-		});
-		// First run should have fired despite `b` being sentinel.
-		expect(seen.length).toBeGreaterThanOrEqual(1);
-		expect(seen[0]?.av).toBe(1);
-		expect(seen[0]?.bv).toBeUndefined();
-		unsub();
-	});
-
-	it("dynamicNode partial:false opt-in still gates on all deps", () => {
-		const a = node<number>([], { initial: 1 });
-		const b = node<number>([]); // sentinel
-		const seen: Array<unknown> = [];
-		const dyn = dynamicNode<number>(
-			[a, b],
-			(track) => (track(a) as number) + ((track(b) as number) ?? 0),
-			{ partial: false },
-		);
-		const unsub = dyn.subscribe((msgs) => {
-			for (const m of msgs) {
-				if (m[0] === DATA) seen.push(m[1]);
-			}
-		});
-		// fn must NOT have run — `b` never delivered DATA.
-		expect(seen.length).toBe(0);
-		unsub();
-	});
-
-	it("autoTrackNode discovers deps without first-run-gate stall (partial:true default)", () => {
-		const a = node<number>([], { initial: 7 });
-		const b = node<number>([], { initial: 5 });
-		const seen: number[] = [];
-		const at = autoTrackNode<number>((track) => (track(a) as number) + (track(b) as number));
-		const unsub = at.subscribe((msgs) => {
-			for (const m of msgs) {
-				if (m[0] === DATA) seen.push(m[1] as number);
-			}
-		});
-		// After discovery convergence, fn should produce 12.
-		expect(seen).toContain(12);
-		unsub();
-	});
-});
-
-describe("Phase 13.6.B B1 — Lock 6.H regression: INVALIDATE leaves emitter in 'sentinel'", () => {
-	it("INVALIDATE on a node with cache resets status to 'sentinel', not 'dirty'", () => {
-		const s = node<number>([], { initial: 42 });
-		expect(s.cache).toBe(42);
-		expect(s.status).toBe("settled");
-		// Keepalive subscriber so the node stays mounted across INVALIDATE.
-		const unsub = s.subscribe(() => undefined);
-		s.down([[INVALIDATE]]);
-		expect(s.cache).toBeUndefined();
-		expect(s.status).toBe("sentinel");
-		unsub();
-	});
-
-	it("late subscribers after INVALIDATE see [START] (no phantom DIRTY)", () => {
-		const s = node<number>([], { initial: 42 });
-		const keepalive = s.subscribe(() => undefined);
-		s.down([[INVALIDATE]]);
-		// Status is "sentinel" + cache undefined → push-on-subscribe must NOT
-		// emit DIRTY (that's the regression Lock 6.H guards against).
-		const lateSeen: symbol[] = [];
-		const lateUnsub = s.subscribe((msgs) => {
-			for (const m of msgs) lateSeen.push(m[0] as symbol);
-		});
-		expect(lateSeen).not.toContain(DIRTY);
-		lateUnsub();
-		keepalive();
-	});
-});
diff --git a/packages/pure-ts/src/__tests__/core/phase-13-6-b2.test.ts b/packages/pure-ts/src/__tests__/core/phase-13-6-b2.test.ts
deleted file mode 100644
index e39d80fa..00000000
--- a/packages/pure-ts/src/__tests__/core/phase-13-6-b2.test.ts
+++ /dev/null
@@ -1,83 +0,0 @@
-/**
- * Phase 13.6.B Batch 2 — Lock 4.A + 4.A′ cleanup-hook rename.
- *
- * Verifies the new field names (`onRerun`, `onDeactivation`, `onInvalidate`)
- * fire correctly. The legacy `{ beforeRun, deactivate, invalidate }` shape and
- * `() => void` shorthand are accepted as a transitional shim — see
- * `docs/optimizations.md` "Lock 4.A — drop () => void cleanup-shorthand
- * call-site sweep" for the planned follow-up sweep.
- */
-
-import { describe, expect, it } from "vitest";
-import { DATA, INVALIDATE } from "../../core/messages.js";
-import { node } from "../../core/node.js";
-
-describe("Phase 13.6.B B2 — Lock 4.A cleanup-hook rename", () => {
-	it("{ onDeactivation } fires on last-sink unsubscribe", () => {
-		let deactivations = 0;
-		const src = node<number>([], { initial: 1 });
-		const d = node<number>([src], (data, a) => {
-			a.emit((data[0]?.at(-1) as number) ?? 0);
-			return {
-				onDeactivation: () => {
-					deactivations++;
-				},
-			};
-		});
-		const u1 = d.subscribe(() => undefined);
-		const u2 = d.subscribe(() => undefined);
-		expect(deactivations).toBe(0);
-		u1();
-		expect(deactivations).toBe(0); // still has u2
-		u2();
-		expect(deactivations).toBe(1);
-	});
-
-	it("{ onInvalidate } fires on INVALIDATE delivery without ending the activation", () => {
-		let invalidations = 0;
-		let deactivations = 0;
-		const src = node<number>([], { initial: 7 });
-		const d = node<number>([src], (data, a) => {
-			a.emit((data[0]?.at(-1) as number) ?? 0);
-			return {
-				onInvalidate: () => {
-					invalidations++;
-				},
-				onDeactivation: () => {
-					deactivations++;
-				},
-			};
-		});
-		const unsub = d.subscribe(() => undefined);
-		expect(invalidations).toBe(0);
-		src.down([[INVALIDATE]]);
-		expect(invalidations).toBe(1);
-		expect(deactivations).toBe(0); // INVALIDATE preserves activation
-		unsub();
-		expect(deactivations).toBe(1);
-	});
-
-	it("{ onRerun } fires before fn re-runs (between waves)", () => {
-		let reruns = 0;
-		const src = node<number>([], { initial: 1 });
-		const seen: number[] = [];
-		const d = node<number>([src], (data, a) => {
-			const v = (data[0]?.at(-1) as number) ?? 0;
-			seen.push(v);
-			a.emit(v);
-			return {
-				onRerun: () => {
-					reruns++;
-				},
-			};
-		});
-		const unsub = d.subscribe(() => undefined);
-		expect(reruns).toBe(0);
-		src.down([[DATA, 2]]);
-		// Cleanup runs BEFORE fn re-runs, so reruns increments by 1 prior to
-		// the fn call that emitted seen=[..., 2].
-		expect(reruns).toBe(1);
-		expect(seen).toEqual([1, 2]);
-		unsub();
-	});
-});
diff --git a/packages/pure-ts/src/__tests__/core/phase-13-6-b3.test.ts b/packages/pure-ts/src/__tests__/core/phase-13-6-b3.test.ts
deleted file mode 100644
index f70151df..00000000
--- a/packages/pure-ts/src/__tests__/core/phase-13-6-b3.test.ts
+++ /dev/null
@@ -1,441 +0,0 @@
-/**
- * Phase 13.6.B Batch 3 — PAUSE buffer reshape verification.
- *
- * Sources:
- * - Lock 2.C — `_pauseBuffer` is `Messages[]` (array of waves), per-wave replay
- * - Lock 2.C′ — current-code refactor: type + push site + drain site
- * - Lock 2.C′-pre — buffer scope extends to tier-3 AND tier-4 (INVALIDATE)
- * - Lock 6.A — `cfg.pauseBufferMax` cap with overflow ERROR (cycle-gated)
- *
- * Audit-sweep tests required by Lock 2.C:
- * (a) multi-DATA wave during pause replays verbatim (no equals collapse)
- * (b) single-DATA wave matching prior buffered wave's emission collapses to
- *     RESOLVED on replay
- * (c) single-RESOLVED wave during pause replays verbatim
- *
- * Plus Lock 2.C′-pre coverage:
- * (d) tier-4 INVALIDATE waves are buffered too
- * (e) cross-tier ordering (DATA wave then INVALIDATE wave) preserved on replay
- *
- * Plus Lock 6.A overflow:
- * (f) buffer at cap drops oldest + ERRORs once per cycle
- * (g) ERROR diagnostic carries { nodeId, droppedCount, configuredMax,
- *     lockHeldDurationMs }
- */
-
-import { describe, expect, it } from "vitest";
-import { GraphReFlyConfig, registerBuiltins } from "../../core/config.js";
-import { DATA, ERROR, INVALIDATE, PAUSE, RESOLVED, RESUME } from "../../core/messages.js";
-import { defaultConfig, node } from "../../core/node.js";
-
-function freshConfig(opts?: { pauseBufferMax?: number }): GraphReFlyConfig {
-	const cfg = new GraphReFlyConfig({
-		onMessage: defaultConfig.onMessage,
-		onSubscribe: defaultConfig.onSubscribe,
-	});
-	registerBuiltins(cfg);
-	if (opts?.pauseBufferMax != null) {
-		cfg.pauseBufferMax = opts.pauseBufferMax;
-	}
-	return cfg;
-}
-
-describe("Phase 13.6.B B3 — Lock 2.C wave-shape preserved across pause boundary", () => {
-	it("multi-DATA wave during pause replays verbatim (no equals collapse)", () => {
-		// Pre-13.6.B bug: the flat `Message[]` buffer split a multi-DATA wave
-		// into N single-DATA waves on replay; equals substitution then
-		// wrongly collapsed duplicates. With Messages[] + per-wave replay,
-		// the wave shape is preserved — `_updateState`'s `dataCount > 1`
-		// guard suppresses equals, and both DATAs reach subscribers.
-		const s = node<number>([], { pausable: "resumeAll", initial: 0 });
-		const seen: number[] = [];
-		const unsub = s.subscribe((msgs) => {
-			for (const m of msgs) if (m[0] === DATA) seen.push(m[1] as number);
-		});
-		const baseLen = seen.length;
-
-		const lock = Symbol("multi-data");
-		s.down([[PAUSE, lock]]);
-
-		// One down() call carrying multiple DATA = one multi-DATA wave.
-		s.down([
-			[DATA, 5],
-			[DATA, 5], // duplicate — must NOT collapse on replay
-		]);
-
-		s.down([[RESUME, lock]]);
-
-		expect(seen.slice(baseLen)).toEqual([5, 5]);
-		expect(s.cache).toBe(5);
-		unsub();
-	});
-
-	it("Lock 2.C: repeated same-value pulses during pause replay against the pre-pause baseline (wave 1 DATA, wave 2 RESOLVED)", () => {
-		// Two consecutive single-DATA waves with the same value during a
-		// `resumeAll` pause, against a node whose pre-pause cache is 0.
-		//
-		// Lock 2.C (Phase 13.6.A) spec-intent: the equals reference for a
-		// replayed wave is "the cache as at the end of the *previous wave
-		// in the buffer*, starting from pre-pause cache". So:
-		//   - wave 1 (DATA 7) replays vs pre-pause cache 0 → 7 ≠ 0 → DATA(7)
-		//   - wave 2 (DATA 7) replays vs cache 7 (shaped by wave 1) → equals
-		//     → RESOLVED
-		// `s.cache` ends at 7.
-		//
-		// Pre-2026-05-17 the mid-pause `_updateState` advanced `_cached` to
-		// 7 BEFORE the buffer drained, so BOTH waves collapsed to RESOLVED
-		// (the old D2 "absorbed pulse" semantic). The `_prePauseSnapshot`
-		// restore-before-drain (Lock 2.C impl) brings this into spec
-		// alignment. Producers wanting every write observable regardless of
-		// value still set `equals: () => false` (no collapse at all).
-		const s = node<number>([], { pausable: "resumeAll", initial: 0 });
-		const seen: Array<[symbol, unknown?]> = [];
-		const unsub = s.subscribe((msgs) => {
-			for (const m of msgs) seen.push([m[0], m[1]]);
-		});
-		const baseLen = seen.length;
-
-		const lock = Symbol("baseline-replay");
-		s.down([[PAUSE, lock]]);
-		s.emit(7);
-		s.emit(7);
-		s.down([[RESUME, lock]]);
-
-		const tail = seen.slice(baseLen);
-		const dataPayloads = tail.filter(([t]) => t === DATA).map(([, v]) => v);
-		const resolvedCount = tail.filter(([t]) => t === RESOLVED).length;
-		// Spec-aligned: wave 1 emits DATA(7), wave 2 collapses to RESOLVED.
-		expect(dataPayloads).toEqual([7]);
-		expect(resolvedCount).toBeGreaterThanOrEqual(1);
-		expect(s.cache).toBe(7);
-		unsub();
-	});
-
-	it("Lock 2.C: a distinct-then-same pulse sequence during pause replays DATA then RESOLVED", () => {
-		// pre-pause cache 0; mid-pause emits 1, 2, 2. Spec-intent replay:
-		//   wave 1 (DATA 1) vs 0 → DATA(1)
-		//   wave 2 (DATA 2) vs 1 → DATA(2)
-		//   wave 3 (DATA 2) vs 2 → RESOLVED
-		const s = node<number>([], { pausable: "resumeAll", initial: 0 });
-		const seen: Array<[symbol, unknown?]> = [];
-		const unsub = s.subscribe((msgs) => {
-			for (const m of msgs) seen.push([m[0], m[1]]);
-		});
-		const baseLen = seen.length;
-		const lock = Symbol("seq");
-		s.down([[PAUSE, lock]]);
-		s.emit(1);
-		s.emit(2);
-		s.emit(2);
-		s.down([[RESUME, lock]]);
-		const tail = seen.slice(baseLen);
-		const dataPayloads = tail.filter(([t]) => t === DATA).map(([, v]) => v);
-		expect(dataPayloads).toEqual([1, 2]);
-		expect(tail.filter(([t]) => t === RESOLVED).length).toBeGreaterThanOrEqual(1);
-		expect(s.cache).toBe(2);
-		unsub();
-	});
-
-	it("Lock 2.C /qa-Blind#1: every pause cycle re-captures its own pre-pause baseline (not just the first)", () => {
-		// The pre-fix bug keyed snapshot capture on `_pauseBuffer == null`,
-		// but the buffer stays `[]` (not nulled) after a cycle's drain — so
-		// only the FIRST pause cycle ever captured a snapshot. The 2nd+ cycle
-		// had `_prePauseSnapshot === null` → restore skipped → the old D2
-		// "absorbed pulse" bug silently resurfaced for every later cycle.
-		// (Mid-drain re-pause is one motivating instance; the general defect
-		// is per-cycle and is reproduced deterministically here with two
-		// SEQUENTIAL cycles, no fragile reentrancy.)
-		const s = node<number>([], { pausable: "resumeAll", initial: 0 });
-		const data: number[] = [];
-		const unsub = s.subscribe((msgs) => {
-			for (const m of msgs) if (m[0] === DATA) data.push(m[1] as number);
-		});
-		const base = data.length;
-
-		// Cycle 1 (the only one the buggy code snapshots): baseline 0.
-		const l1 = Symbol("c1");
-		s.down([[PAUSE, l1]]);
-		s.emit(5); // 5 ≠ baseline 0 → replays as DATA(5); cache → 5
-		s.down([[RESUME, l1]]);
-
-		// Cycle 2 (fresh, sequential): baseline must be re-captured as 5.
-		const l2 = Symbol("c2");
-		s.down([[PAUSE, l2]]);
-		s.emit(9); // 9 ≠ baseline 5 → DATA(9) buffered; cache → 9
-		s.emit(9); // 9 === 9 → RESOLVED buffered
-		s.down([[RESUME, l2]]);
-
-		// Fix: cycle-2 snapshot = 5 (re-captured at l2's first PAUSE via the
-		// `!wasPaused` gate). Restore → 5; replay DATA(9) vs 5 → DATA(9),
-		// then RESOLVED. Total [5, 9].
-		// Pre-fix: no cycle-2 snapshot → restore skipped → cache stays the
-		// mid-pause-advanced 9 → replay DATA(9) vs 9 → RESOLVED. Total [5].
-		expect(data.slice(base)).toEqual([5, 9]);
-		expect(s.cache).toBe(9);
-		unsub();
-	});
-
-	it("Lock 2.C /qa-Edge#1: V1 versioning cid/prev chain rebuilt off the pre-pause baseline (no fabricated self-link)", () => {
-		const s = node<number>([], {
-			pausable: "resumeAll",
-			versioning: 1,
-			initial: 0,
-		});
-		const c0 = (s.v as { cid: string }).cid; // pre-pause cid = hash(0)
-		const unsub = s.subscribe(() => {});
-		const lock = Symbol("v1-chain");
-		s.down([[PAUSE, lock]]);
-		s.emit(1); // mid-pause: advanceVersion sets prev=c0, cid=hash(1)
-		s.down([[RESUME, lock]]);
-		const v = s.v as { version: number; cid: string; prev: string | null };
-		// With the fix: restore cid→c0/prev→null pre-drain, then the replayed
-		// DATA(1) rebuilds prev=c0, cid=hash(1). Without it (only `version`
-		// restored), the replay's advanceVersion reads the mid-pause cid as
-		// `prev` → prev === cid, a fabricated self-referential audit edge.
-		expect(v.prev).toBe(c0);
-		expect(v.cid).not.toBe(v.prev);
-		expect(v.version).toBe(1);
-		unsub();
-	});
-
-	it("single-RESOLVED wave during pause replays verbatim", () => {
-		// A `down([[RESOLVED]])` call against a node that already has a cache
-		// produces a single-RESOLVED wave. The buffer must store and replay
-		// it without rewriting.
-		const s = node<number>([], { pausable: "resumeAll", initial: 99 });
-		const seen: symbol[] = [];
-		const unsub = s.subscribe((msgs) => {
-			for (const m of msgs) seen.push(m[0] as symbol);
-		});
-		const baseLen = seen.length;
-
-		const lock = Symbol("resolved");
-		s.down([[PAUSE, lock]]);
-		s.down([[RESOLVED]]);
-		s.down([[RESUME, lock]]);
-
-		expect(seen.slice(baseLen)).toContain(RESOLVED);
-		expect(s.cache).toBe(99);
-		unsub();
-	});
-});
-
-describe("Phase 13.6.B B3 — Lock 2.C′-pre tier-4 INVALIDATE buffered + ordered", () => {
-	it("INVALIDATE wave during pause is buffered (does NOT clear cache mid-pause)", () => {
-		// Pre-13.6.B: tier-4 INVALIDATE bypassed the buffer and ran through
-		// _updateState immediately mid-pause, clearing cache while subscribers
-		// were still cut off. Lock 2.C′-pre says INVALIDATE is part of the
-		// settle slice and must be buffered.
-		const s = node<number>([], { pausable: "resumeAll", initial: 42 });
-		const seen: Array<[symbol, unknown?]> = [];
-		const unsub = s.subscribe((msgs) => {
-			for (const m of msgs) seen.push([m[0], m[1]]);
-		});
-		const baseLen = seen.length;
-
-		const lock = Symbol("invalidate-buffered");
-		s.down([[PAUSE, lock]]);
-
-		// Send INVALIDATE while paused. Without buffering, this would reset
-		// cache to undefined and status to "sentinel" mid-pause — observable
-		// to a snapshot but the subscriber sees nothing until replay. With
-		// buffering, mid-pause cache stays at 42 (the original wave's
-		// `_updateState` still ran since we don't gate state mutations on
-		// pause; but the message itself is buffered for replay).
-		s.down([[INVALIDATE]]);
-		// Subscriber must NOT have seen INVALIDATE while paused.
-		const tailMid = seen.slice(baseLen);
-		expect(tailMid.map(([t]) => t)).not.toContain(INVALIDATE);
-
-		s.down([[RESUME, lock]]);
-
-		// On replay, INVALIDATE reaches the subscriber.
-		const tailFinal = seen.slice(baseLen);
-		expect(tailFinal.map(([t]) => t)).toContain(INVALIDATE);
-		unsub();
-	});
-
-	it("DATA wave then INVALIDATE wave preserved in arrival order on replay", () => {
-		const s = node<number>([], { pausable: "resumeAll", initial: 0 });
-		const seen: Array<[symbol, unknown?]> = [];
-		const unsub = s.subscribe((msgs) => {
-			for (const m of msgs) seen.push([m[0], m[1]]);
-		});
-		const baseLen = seen.length;
-
-		const lock = Symbol("ordered");
-		s.down([[PAUSE, lock]]);
-		s.emit(1); // wave A — single-DATA
-		s.down([[INVALIDATE]]); // wave B — single-INVALIDATE
-		s.emit(2); // wave C — single-DATA after invalidate
-		s.down([[RESUME, lock]]);
-
-		// Pull just the settle-class entries (DATA / RESOLVED / INVALIDATE)
-		// from the post-base trace.
-		const tail = seen
-			.slice(baseLen)
-			.filter(([t]) => t === DATA || t === RESOLVED || t === INVALIDATE);
-		// Expect: DATA(1), INVALIDATE, DATA(2). The DATA(1) carries the value
-		// because cache was 0 before; equals(0,1) false → DATA. INVALIDATE
-		// resets cache. DATA(2) carries because cache is now undefined.
-		const types = tail.map(([t]) => t);
-		const dataValues = tail.filter(([t]) => t === DATA).map(([, v]) => v);
-		expect(types).toEqual([DATA, INVALIDATE, DATA]);
-		expect(dataValues).toEqual([1, 2]);
-		unsub();
-	});
-});
-
-describe("Phase 13.6.B B3 — Lock 6.A pauseBufferMax overflow", () => {
-	it("buffer over cap emits ERROR once per cycle and transitions node to terminal", () => {
-		// Lock 6.A: "The error propagates downstream per default error
-		// semantics (rule 1.4)." Rule 1.4 makes ERROR a terminal lifecycle
-		// signal — overflow heavy-hands the node into `"errored"` rather
-		// than silently shedding past the first drop. Bump
-		// `cfg.pauseBufferMax` if the producer's sustained pause backlog
-		// genuinely exceeds the default 10_000.
-		const cfg = freshConfig({ pauseBufferMax: 3 });
-		const s = node<number>([], { pausable: "resumeAll", initial: 0, config: cfg });
-		const seen: Array<[symbol, unknown?]> = [];
-		const unsub = s.subscribe((msgs) => {
-			for (const m of msgs) seen.push([m[0], m[1]]);
-		});
-		const baseLen = seen.length;
-
-		const lock = Symbol("overflow");
-		s.down([[PAUSE, lock]]);
-		s.emit(1);
-		s.emit(2);
-		s.emit(3);
-		s.emit(4); // first overflow → ERROR + terminal
-		s.emit(5); // post-terminal — no-op
-
-		const errorsMidPause = seen.slice(baseLen).filter(([t]) => t === ERROR);
-		expect(errorsMidPause.length).toBe(1);
-		// Node is now terminal.
-		expect(s.status).toBe("errored");
-
-		// RESUME after terminal — buffered waves are NOT replayed (terminal
-		// node's `_emit` no-ops on tier-3 input).
-		s.down([[RESUME, lock]]);
-		const dataValues = seen
-			.slice(baseLen)
-			.filter(([t]) => t === DATA)
-			.map(([, v]) => v);
-		expect(dataValues).toEqual([]);
-		unsub();
-	});
-
-	it("overflow ERROR carries diagnostic { nodeId, droppedCount, configuredMax, lockHeldDurationMs }", () => {
-		const cfg = freshConfig({ pauseBufferMax: 1 });
-		const s = node<number>([], {
-			pausable: "resumeAll",
-			initial: 0,
-			config: cfg,
-			name: "overflow-diag",
-		});
-		const errors: Error[] = [];
-		const unsub = s.subscribe((msgs) => {
-			for (const m of msgs) {
-				if (m[0] === ERROR) errors.push(m[1] as Error);
-			}
-		});
-
-		const lock = Symbol("diag");
-		s.down([[PAUSE, lock]]);
-		s.emit(1);
-		s.emit(2); // first overflow → ERROR + terminal
-		s.emit(3); // post-terminal — no-op
-		s.down([[RESUME, lock]]);
-
-		expect(errors.length).toBe(1);
-		const detail = (errors[0] as Error & { detail?: Record<string, unknown> }).detail;
-		expect(detail).toBeDefined();
-		expect(detail?.nodeId).toBe("overflow-diag");
-		expect(detail?.configuredMax).toBe(1);
-		expect(typeof detail?.droppedCount).toBe("number");
-		expect(detail?.droppedCount).toBeGreaterThanOrEqual(1);
-		expect(typeof detail?.lockHeldDurationMs).toBe("number");
-		expect(detail?.lockHeldDurationMs).toBeGreaterThanOrEqual(0);
-		// And the node is terminal (Lock 6.A G1.2 fix — overflow ERROR
-		// transitions status, not just delivers signal out-of-band).
-		expect(s.status).toBe("errored");
-		// Single-line readable error (no doubled `Node "X":` prefix from
-		// `_wrapFnError` on top of the inner message — G2.3 fix).
-		expect(errors[0].message.split("Node ").length).toBe(2);
-		unsub();
-	});
-
-	it("overflow bookkeeping resets via _resetForFreshLifecycle on resubscribable terminal recovery", () => {
-		// Resubscribable node hits overflow → terminal. After last unsub +
-		// re-subscribe, `subscribe` invokes `_resetForFreshLifecycle()`
-		// which clears `_pauseStartNs / _pauseDroppedCount / _pauseOverflowed`
-		// (G2.1 fix). The next pause cycle's overflow can therefore emit a
-		// fresh ERROR rather than being gated by stale `_pauseOverflowed === true`.
-		const cfg = freshConfig({ pauseBufferMax: 1 });
-		const s = node<number>([], {
-			pausable: "resumeAll",
-			initial: 0,
-			resubscribable: true,
-			config: cfg,
-		});
-
-		// Cycle 1 — overflow → terminal.
-		const errors1: Error[] = [];
-		let u1 = s.subscribe((msgs) => {
-			for (const m of msgs) if (m[0] === ERROR) errors1.push(m[1] as Error);
-		});
-		s.down([[PAUSE, Symbol("c1")]]);
-		s.emit(1);
-		s.emit(2); // overflow → ERROR + terminal
-		expect(errors1.length).toBe(1);
-		expect(s.status).toBe("errored");
-		u1();
-
-		// Cycle 2 — re-subscribe (triggers _resetForFreshLifecycle on the
-		// resubscribable terminal node). New pause cycle works fresh.
-		const errors2: Error[] = [];
-		u1 = s.subscribe((msgs) => {
-			for (const m of msgs) if (m[0] === ERROR) errors2.push(m[1] as Error);
-		});
-		s.down([[PAUSE, Symbol("c2")]]);
-		s.emit(10);
-		s.emit(20); // overflow → fresh ERROR (would be silenced by stale _pauseOverflowed)
-		expect(errors2.length).toBe(1);
-		u1();
-	});
-});
-
-describe("Phase 13.6.B B3 — Lock 4.A G1.3 cleanup hook fires once across pause/replay", () => {
-	it("onInvalidate fires exactly once when INVALIDATE is buffered through pause and replayed on RESUME", () => {
-		// Pre-G1.3 bug: `c.onInvalidate` was NOT nulled after firing in the
-		// `_updateState` INVALIDATE branch. A buffered INVALIDATE wave fired
-		// the hook once during the original mid-pause `_updateState` walk
-		// AND AGAIN when the wave was replayed on RESUME — double-firing
-		// resource teardown / cache flush hooks. G1.3 nulls the slot before
-		// invocation (mirroring `onRerun`'s pattern), so the replay walk
-		// sees `c.onInvalidate === undefined` and skips.
-		let invalidations = 0;
-		const src = node<number>([], { pausable: "resumeAll", initial: 1 });
-		const d = node<number>([src], (data, a) => {
-			a.emit((data[0]?.at(-1) as number) ?? 0);
-			return {
-				onInvalidate: () => {
-					invalidations++;
-				},
-			};
-		});
-		const unsub = d.subscribe(() => undefined);
-		expect(invalidations).toBe(0);
-
-		// Pause downstream, send INVALIDATE through src → d while paused.
-		const lock = Symbol("once");
-		d.down([[PAUSE, lock]]);
-		src.down([[INVALIDATE]]); // buffers an INVALIDATE wave on `d`
-		d.down([[RESUME, lock]]);
-
-		// Hook fires exactly once across the pause boundary, not twice.
-		expect(invalidations).toBe(1);
-		unsub();
-	});
-});
diff --git a/packages/pure-ts/src/__tests__/core/phase-13-6-b6.test.ts b/packages/pure-ts/src/__tests__/core/phase-13-6-b6.test.ts
deleted file mode 100644
index 37e7b378..00000000
--- a/packages/pure-ts/src/__tests__/core/phase-13-6-b6.test.ts
+++ /dev/null
@@ -1,447 +0,0 @@
-/**
- * Phase 13.6.B Batch 6 — `replayBuffer: N` implementation (Lock 6.G, spec §2.5).
- *
- * The node maintains a circular buffer of the last N **outgoing** DATA
- * values; new (late) subscribers receive the buffer as one wave after
- * the START handshake. Replaces the legacy `replay()` operator + sink-
- * hook monkey-patching pattern.
- *
- * Audit-sweep tests required by Lock 6.G:
- * (a) late subscriber sees buffered DATAs in order, after START
- * (b) capacity overflow drops oldest
- * (c) `replayBuffer: 0` / absent / negative / NaN → feature disabled
- * (d) RESOLVED entries are NOT buffered (equals-substituted DATA)
- * (e) INVALIDATE on a non-terminal node preserves buffer (history survives)
- * (f) TEARDOWN clears buffer
- * (g) Resubscribable lifecycle reset (terminal-then-subscribe) clears buffer
- * (h) `initial:` value alone does not populate the buffer (only outgoing DATA)
- * (i) interaction with pause: pause-buffered DATAs push to replay only when
- *     RESUME drain dispatches them to sinks (not during mid-pause cache
- *     advance)
- * (j) buffer survives subscribe/unsubscribe cycles for non-resubscribable nodes
- *     that keep at least one sink alive (no `_deactivate` in between)
- */
-
-import { describe, expect, it } from "vitest";
-import { COMPLETE, DATA, INVALIDATE, PAUSE, RESUME, START, TEARDOWN } from "../../core/messages.js";
-import { node } from "../../core/node.js";
-
-describe("Phase 13.6.B B6 — Lock 6.G `replayBuffer: N` core behavior", () => {
-	it("(a) late subscriber receives buffered DATAs in order after START", () => {
-		const s = node<number>([], { replayBuffer: 5 });
-		const earlySeen: number[] = [];
-		const earlyUnsub = s.subscribe((msgs) => {
-			for (const m of msgs) if (m[0] === DATA) earlySeen.push(m[1] as number);
-		});
-
-		s.emit(1);
-		s.emit(2);
-		s.emit(3);
-
-		// Late subscriber arrives — must receive buffered history.
-		const lateOrder: Array<[symbol, unknown?]> = [];
-		const lateUnsub = s.subscribe((msgs) => {
-			for (const m of msgs) lateOrder.push([m[0], m[1]]);
-		});
-
-		// Late sub must see START first, then DATA for each buffered value.
-		expect(lateOrder[0][0]).toBe(START);
-		const lateData = lateOrder.filter(([t]) => t === DATA).map(([, v]) => v);
-		expect(lateData).toEqual([1, 2, 3]);
-
-		// Live emission after subscribe goes to both subscribers.
-		s.emit(4);
-		expect(earlySeen).toEqual([1, 2, 3, 4]);
-		const lateLive = lateOrder
-			.filter(([t]) => t === DATA)
-			.map(([, v]) => v)
-			.slice(3); // drop the replay slice
-		expect(lateLive).toEqual([4]);
-
-		earlyUnsub();
-		lateUnsub();
-	});
-
-	it("(b) capacity overflow drops oldest", () => {
-		const s = node<number>([], { replayBuffer: 3 });
-		const keepAlive = s.subscribe(() => {});
-
-		s.emit(1);
-		s.emit(2);
-		s.emit(3);
-		s.emit(4); // pushes 1 out
-		s.emit(5); // pushes 2 out
-
-		const lateData: number[] = [];
-		const lateUnsub = s.subscribe((msgs) => {
-			for (const m of msgs) if (m[0] === DATA) lateData.push(m[1] as number);
-		});
-
-		expect(lateData).toEqual([3, 4, 5]);
-
-		keepAlive();
-		lateUnsub();
-	});
-
-	it("(c) replayBuffer: 0 / negative / NaN / absent → feature disabled", () => {
-		for (const cap of [0, -3, Number.NaN, Number.POSITIVE_INFINITY, undefined]) {
-			const s = node<number>([], cap === undefined ? {} : { replayBuffer: cap });
-			const keepAlive = s.subscribe(() => {});
-			s.emit(1);
-			s.emit(2);
-			const lateData: number[] = [];
-			const lateUnsub = s.subscribe((msgs) => {
-				for (const m of msgs) if (m[0] === DATA) lateData.push(m[1] as number);
-			});
-			// With buffer disabled, late sub gets only the cache push (one DATA).
-			expect(lateData).toEqual([2]);
-			keepAlive();
-			lateUnsub();
-		}
-	});
-
-	it("(d) RESOLVED entries are NOT buffered (equals-substituted DATA)", () => {
-		const s = node<number>([], { replayBuffer: 5 });
-		const keepAlive = s.subscribe(() => {});
-
-		s.emit(1);
-		s.emit(1); // equals → RESOLVED, not pushed
-		s.emit(2);
-		s.emit(2); // equals → RESOLVED, not pushed
-		s.emit(3);
-
-		const lateData: number[] = [];
-		const lateUnsub = s.subscribe((msgs) => {
-			for (const m of msgs) if (m[0] === DATA) lateData.push(m[1] as number);
-		});
-
-		expect(lateData).toEqual([1, 2, 3]);
-
-		keepAlive();
-		lateUnsub();
-	});
-
-	it("(e) INVALIDATE on a non-terminal node preserves the replay buffer", () => {
-		const s = node<number>([], { replayBuffer: 5 });
-		const keepAlive = s.subscribe(() => {});
-
-		s.emit(10);
-		s.emit(20);
-		s.emit(30);
-
-		// INVALIDATE — clears _cached, sets status to "sentinel". Per spec
-		// §2.5 + Lock 6.G semantics confirmed in B6 design discussion: the
-		// replay buffer is independent of `_cached` and represents emission
-		// history, not current value. INVALIDATE does NOT touch it.
-		s.down([[INVALIDATE]]);
-		expect(s.cache).toBeUndefined();
-		expect(s.status).toBe("sentinel");
-
-		const lateData: number[] = [];
-		const lateOrder: symbol[] = [];
-		const lateUnsub = s.subscribe((msgs) => {
-			for (const m of msgs) {
-				lateOrder.push(m[0] as symbol);
-				if (m[0] === DATA) lateData.push(m[1] as number);
-			}
-		});
-
-		// Late sub gets START + the prior history.
-		expect(lateOrder[0]).toBe(START);
-		expect(lateData).toEqual([10, 20, 30]);
-
-		keepAlive();
-		lateUnsub();
-	});
-
-	it("(f) TEARDOWN clears the replay buffer (history dropped)", () => {
-		// `resetOnTeardown: true` so this state node's `_cached` is also
-		// cleared (otherwise RAM rule preserves it and the cache-DATA
-		// fallback would deliver the last value — separate concern from
-		// buffer clearing). With both cleared, a re-subscribe sees no
-		// DATA at all, proving the buffer was cleared (not "merged into
-		// cache push").
-		const s = node<number>([], {
-			replayBuffer: 5,
-			resubscribable: true,
-			resetOnTeardown: true,
-		});
-		const keepAlive = s.subscribe(() => {});
-
-		s.emit(1);
-		s.emit(2);
-		s.emit(3);
-
-		s.down([[TEARDOWN]]);
-		keepAlive();
-
-		const lateData: number[] = [];
-		const lateUnsub = s.subscribe((msgs) => {
-			for (const m of msgs) if (m[0] === DATA) lateData.push(m[1] as number);
-		});
-
-		expect(lateData).toEqual([]);
-
-		lateUnsub();
-	});
-
-	it("(f, follow-up) state node without `resetOnTeardown` — buffer cleared, cache preserved", () => {
-		// State node default: TEARDOWN preserves `_cached` (RAM rule). The
-		// replay buffer is still cleared — a re-subscribe sees the
-		// single cache value via the legacy cache-DATA push, NOT the
-		// pre-teardown emission history.
-		const s = node<number>([], { replayBuffer: 5, resubscribable: true });
-		const keepAlive = s.subscribe(() => {});
-
-		s.emit(1);
-		s.emit(2);
-		s.emit(3);
-
-		s.down([[TEARDOWN]]);
-		keepAlive();
-
-		const lateData: number[] = [];
-		const lateUnsub = s.subscribe((msgs) => {
-			for (const m of msgs) if (m[0] === DATA) lateData.push(m[1] as number);
-		});
-
-		// Only the residual cached value (3), NOT the full buffered history.
-		expect(lateData).toEqual([3]);
-
-		lateUnsub();
-	});
-
-	it("(g) terminal-resubscribable subscribe after COMPLETE clears buffer", () => {
-		// Drive node to terminal (COMPLETE), drop the sink so `_deactivate`
-		// fires + clears `_replayBuffer`. New sub after terminal goes through
-		// `_resetForFreshLifecycle` (afterTerminalReset path) — also a
-		// belt-and-suspenders clear. Either path leaves the buffer empty.
-		const s = node<number>([], { replayBuffer: 5, resubscribable: true });
-		const sinkA = s.subscribe(() => {});
-		s.emit(1);
-		s.emit(2);
-		s.emit(3);
-
-		s.down([[COMPLETE]]);
-		sinkA();
-
-		const lateData: number[] = [];
-		const lateUnsub = s.subscribe((msgs) => {
-			for (const m of msgs) if (m[0] === DATA) lateData.push(m[1] as number);
-		});
-
-		expect(lateData).toEqual([]);
-
-		lateUnsub();
-	});
-
-	it("(h) `initial:` value alone does not populate replay buffer", () => {
-		// Pre-populated cache via `initial` is NOT an outgoing emission —
-		// the buffer should remain empty. Late sub should fall back to the
-		// legacy cache-DATA push for the initial value.
-		const s = node<number>([], { initial: 42, replayBuffer: 5 });
-
-		const seen: Array<[symbol, unknown?]> = [];
-		const unsub = s.subscribe((msgs) => {
-			for (const m of msgs) seen.push([m[0], m[1]]);
-		});
-
-		// Subscriber sees START + DATA(42) via the legacy path (buffer empty
-		// because no `emit` yet). Exactly one DATA, not duplicated.
-		const dataPayloads = seen.filter(([t]) => t === DATA).map(([, v]) => v);
-		expect(dataPayloads).toEqual([42]);
-
-		unsub();
-	});
-
-	it("(h, follow-up) once node emits, buffer takes over from cache push", () => {
-		const s = node<number>([], { initial: 42, replayBuffer: 3 });
-		const keepAlive = s.subscribe(() => {});
-		s.emit(100);
-		s.emit(200);
-
-		const lateData: number[] = [];
-		const lateUnsub = s.subscribe((msgs) => {
-			for (const m of msgs) if (m[0] === DATA) lateData.push(m[1] as number);
-		});
-
-		// Late sub sees buffered history [42-was-cache-but-not-buffered, 100, 200]
-		// — but `42` was never an outgoing emission, so only [100, 200] show up.
-		// The buffer takes priority over cache push (no duplicate `200` from cache).
-		expect(lateData).toEqual([100, 200]);
-
-		keepAlive();
-		lateUnsub();
-	});
-
-	it("(i) pause/resume — replay buffer pushes only when DATA actually dispatches", () => {
-		// Mid-pause emissions advance `_cached` (the original wave's
-		// `_updateState` runs synchronously) but DON'T dispatch to sinks.
-		// Per Lock 6.G spec ("outgoing DATA"), the replay buffer must NOT
-		// push during pause-buffering. On RESUME drain, the buffered waves
-		// replay through `_emit(wave)` and reach the dispatch site — at
-		// which point they push to the replay buffer.
-		//
-		// QA D6 (Phase 13.6.B QA pass): asserts the EXACT post-resume
-		// buffer contents to lock the post-equals "outgoing" semantic.
-		// Each buffered wave goes through `_updateState` again on drain;
-		// equals-substitution compares each replayed DATA against the
-		// walking cache. With distinct values 1/2/3 and the cache walking
-		// 3→1→2→3, every replayed DATA differs from the current cache and
-		// dispatches as DATA → buffer accumulates [1, 2, 3]. If a future
-		// refactor moved the push site INTO `_updateState`, mid-pause
-		// emissions would push (corrupting the "values-seen" semantic) and
-		// this assertion would shift — catching the regression.
-		const s = node<number>([], { pausable: "resumeAll", replayBuffer: 10 });
-		const keepAlive = s.subscribe(() => {});
-
-		const lock = Symbol("pause-replay");
-		s.down([[PAUSE, lock]]);
-		s.emit(1);
-		s.emit(2);
-		s.emit(3);
-
-		// Mid-pause: late sub arriving here has empty replay buffer → falls
-		// back to cache-DATA push (latest mid-pause cache). Confirms the
-		// dispatch-only push semantic — no buffer entries accumulated yet.
-		const midPauseData: number[] = [];
-		const midPauseUnsub = s.subscribe((msgs) => {
-			for (const m of msgs) if (m[0] === DATA) midPauseData.push(m[1] as number);
-		});
-		expect(midPauseData).toEqual([3]);
-		midPauseUnsub();
-
-		s.down([[RESUME, lock]]);
-
-		// Post-RESUME drain: the three buffered waves replay through
-		// `_emit`. Cache walks 3→1→2→3 (each replayed DATA differs from
-		// the current cache, so equals-substitution does NOT collapse to
-		// RESOLVED). Each dispatches DATA → pushes to replay buffer.
-		// Buffer post-resume = [1, 2, 3].
-		const lateData: number[] = [];
-		const lateUnsub = s.subscribe((msgs) => {
-			for (const m of msgs) if (m[0] === DATA) lateData.push(m[1] as number);
-		});
-
-		expect(lateData).toEqual([1, 2, 3]);
-
-		keepAlive();
-		lateUnsub();
-	});
-
-	it("(i.2) pause/resume — equals-collapsed mid-pause emits do NOT push to replay buffer", () => {
-		// QA D6 follow-up: explicitly exercise the post-equals "outgoing"
-		// semantic. Mid-pause emit values that match the seed via equals;
-		// on RESUME drain, equals-substitution collapses each to RESOLVED
-		// → those waves do NOT push to the replay buffer (push site is
-		// gated on the `DATA` message type after `_updateState`'s
-		// substitution). Buffer post-resume = [] because every replayed
-		// wave collapsed.
-		const s = node<number>([], {
-			pausable: "resumeAll",
-			replayBuffer: 10,
-			initial: 7,
-		});
-		const keepAlive = s.subscribe(() => {});
-
-		const lock = Symbol("pause-collapse");
-		s.down([[PAUSE, lock]]);
-		// Emit the same value the cache already holds — every wave will
-		// collapse to RESOLVED on replay (equals(7, 7) = true).
-		s.emit(7);
-		s.emit(7);
-		s.emit(7);
-		s.down([[RESUME, lock]]);
-
-		const lateData: number[] = [];
-		const lateUnsub = s.subscribe((msgs) => {
-			for (const m of msgs) if (m[0] === DATA) lateData.push(m[1] as number);
-		});
-
-		// Buffer is empty → late sub falls back to cache-DATA push (the
-		// preserved `_cached === 7`). NOT three identical replays.
-		expect(lateData).toEqual([7]);
-
-		keepAlive();
-		lateUnsub();
-	});
-
-	it("(j) buffer persists across subscribe/unsubscribe when keepalive prevents _deactivate", () => {
-		const s = node<number>([], { replayBuffer: 3 });
-		const keepAlive = s.subscribe(() => {});
-
-		s.emit(7);
-		s.emit(8);
-		s.emit(9);
-
-		// Subscribe → unsubscribe a transient sink. `_deactivate` does NOT
-		// fire because `keepAlive` keeps `_sinkCount > 0`. Buffer must
-		// persist for the next late sub.
-		const transient = s.subscribe(() => {});
-		transient();
-
-		const lateData: number[] = [];
-		const lateUnsub = s.subscribe((msgs) => {
-			for (const m of msgs) if (m[0] === DATA) lateData.push(m[1] as number);
-		});
-
-		expect(lateData).toEqual([7, 8, 9]);
-
-		keepAlive();
-		lateUnsub();
-	});
-
-	it("(k) sentinel-status node with empty buffer falls back to no-DATA START handshake", () => {
-		// Compute node, no `initial`, no emit, no DATA — `_cached` undefined,
-		// status sentinel, buffer empty. Sub should see only START (no DATA).
-		const s = node<number>([], { replayBuffer: 5 });
-		const seen: symbol[] = [];
-		const unsub = s.subscribe((msgs) => {
-			for (const m of msgs) seen.push(m[0] as symbol);
-		});
-
-		expect(seen).toContain(START);
-		expect(seen).not.toContain(DATA);
-
-		unsub();
-	});
-
-	it("(l) buffer correctly captures `null` payloads (null is valid DATA)", () => {
-		const s = node<number | null>([], { replayBuffer: 3 });
-		const keepAlive = s.subscribe(() => {});
-
-		s.emit(1);
-		s.emit(null);
-		s.emit(2);
-
-		const lateData: Array<number | null> = [];
-		const lateUnsub = s.subscribe((msgs) => {
-			for (const m of msgs) if (m[0] === DATA) lateData.push(m[1] as number | null);
-		});
-
-		expect(lateData).toEqual([1, null, 2]);
-
-		keepAlive();
-		lateUnsub();
-	});
-
-	it("(m) capacity is floored from fractional input", () => {
-		// Lock 6.G: clamp via Math.floor. `replayBuffer: 2.7` → capacity 2.
-		const s = node<number>([], { replayBuffer: 2.7 });
-		const keepAlive = s.subscribe(() => {});
-
-		s.emit(1);
-		s.emit(2);
-		s.emit(3);
-
-		const lateData: number[] = [];
-		const lateUnsub = s.subscribe((msgs) => {
-			for (const m of msgs) if (m[0] === DATA) lateData.push(m[1] as number);
-		});
-
-		expect(lateData).toEqual([2, 3]);
-
-		keepAlive();
-		lateUnsub();
-	});
-});
diff --git a/packages/pure-ts/src/__tests__/core/phase-13-6-b7.test.ts b/packages/pure-ts/src/__tests__/core/phase-13-6-b7.test.ts
deleted file mode 100644
index 03965a87..00000000
--- a/packages/pure-ts/src/__tests__/core/phase-13-6-b7.test.ts
+++ /dev/null
@@ -1,218 +0,0 @@
-/**
- * Phase 13.6.B Batch 7 — `ctx.store` default flips to preserve-across-deactivation
- * (Lock 6.D, G.20 flip).
- *
- * Pre-flip: `_deactivate` and `_resetForFreshLifecycle` both wiped
- * `_store` to `{}`. Operators relied on this implicit reset.
- *
- * Post-flip: `_store` PRESERVES across both lifecycle paths. Operators
- * that need restart-on-resubscribe install `onDeactivation` cleanups
- * that explicitly clear their store keys.
- *
- * Tests focus on the core flip semantic — operator-specific behavior is
- * already covered by the broader test suite (any regression would surface
- * there).
- *
- * (a) Bare `node()` with no cleanup hook — store survives across
- *     sub→unsub→re-sub.
- * (b) `onDeactivation` hook fires when sole sink unsubs and can clear
- *     specific store keys.
- * (c) `_resetForFreshLifecycle` (terminal-resubscribable subscribe-after-
- *     terminal) preserves store.
- * (d) `onDeactivation` selective clear: keys NOT listed in the hook
- *     persist across cycles; listed keys are gone.
- * (e) Multiple subscribe/unsubscribe cycles with different sinks (no full
- *     deactivation between) — store flows through unchanged.
- */
-
-import { describe, expect, it } from "vitest";
-import { COMPLETE } from "../../core/messages.js";
-import { node } from "../../core/node.js";
-
-describe("Phase 13.6.B B7 — Lock 6.D `ctx.store` preserve-by-default", () => {
-	it("(a) bare node — store survives sub→unsub→re-sub when no onDeactivation hook", () => {
-		const src = node<number>([], { initial: 0, resubscribable: true });
-		const observed: number[] = [];
-		const computed = node<number>([src], (data, a, ctx) => {
-			ctx.store.invocations = ((ctx.store.invocations as number | undefined) ?? 0) + 1;
-			observed.push(ctx.store.invocations as number);
-			const batch = data[0];
-			if (batch != null && batch.length > 0) a.emit(batch.at(-1) as number);
-			else a.emit(ctx.prevData[0] as number);
-		});
-
-		const unsub1 = computed.subscribe(() => {});
-		src.emit(1);
-		src.emit(2);
-		const lastBefore = observed[observed.length - 1];
-		unsub1();
-
-		// Re-subscribe → store preserved → invocations counter continues.
-		const unsub2 = computed.subscribe(() => {});
-		src.emit(3);
-		const lastAfter = observed[observed.length - 1];
-
-		// `lastAfter` MUST be > `lastBefore` because the counter wasn't reset.
-		// Pre-flip auto-wipe would have reset it; post-flip preserves it.
-		expect(lastAfter).toBeGreaterThan(lastBefore);
-		unsub2();
-	});
-
-	it("(b) onDeactivation fires + can clear specific store keys", () => {
-		const src = node<number>([], { initial: 0, resubscribable: true });
-		let onDeactivationFired = 0;
-		const cycle1Snapshots: Record<string, unknown>[] = [];
-		const cycle2Snapshots: Record<string, unknown>[] = [];
-		let cycle = 1;
-
-		const computed = node<number>([src], (data, a, ctx) => {
-			ctx.store.runs = ((ctx.store.runs as number | undefined) ?? 0) + 1;
-			(cycle === 1 ? cycle1Snapshots : cycle2Snapshots).push({ ...ctx.store });
-			const batch = data[0];
-			if (batch != null && batch.length > 0) a.emit(batch.at(-1) as number);
-			else a.emit(ctx.prevData[0] as number);
-			const store = ctx.store;
-			return {
-				onDeactivation: () => {
-					onDeactivationFired += 1;
-					delete store.runs;
-				},
-			};
-		});
-
-		const u1 = computed.subscribe(() => {});
-		src.emit(1);
-		src.emit(2);
-		expect(onDeactivationFired).toBe(0);
-		u1();
-		expect(onDeactivationFired).toBe(1);
-
-		cycle = 2;
-		const u2 = computed.subscribe(() => {});
-		src.emit(3);
-
-		// Cycle 1 ended with `runs >= 2`. Cycle 2's first snapshot must show
-		// `runs === 1` — the cleanup wiped the key, fn re-init started fresh.
-		const cycle1Last = cycle1Snapshots[cycle1Snapshots.length - 1].runs as number;
-		const cycle2First = cycle2Snapshots[0].runs as number;
-		expect(cycle1Last).toBeGreaterThanOrEqual(2);
-		expect(cycle2First).toBe(1);
-		u2();
-	});
-
-	it("(c) terminal-resubscribable lifecycle reset preserves store", () => {
-		// `_resetForFreshLifecycle` is invoked when a new subscriber arrives
-		// after a terminal-resubscribable node was driven terminal. Lock 6.D
-		// says `ctx.store` preserves through this path too — pre-flip the
-		// reset path also auto-wiped the store.
-		const src = node<number>([], { initial: 0, resubscribable: true });
-		const cycle1: Record<string, unknown>[] = [];
-		const cycle2: Record<string, unknown>[] = [];
-		let cycle = 1;
-		const computed = node<number>(
-			[src],
-			(data, a, ctx) => {
-				ctx.store.calls = ((ctx.store.calls as number | undefined) ?? 0) + 1;
-				(cycle === 1 ? cycle1 : cycle2).push({ ...ctx.store });
-				const batch = data[0];
-				if (batch != null && batch.length > 0) a.emit(batch.at(-1) as number);
-				else a.emit(ctx.prevData[0] as number);
-				// NO onDeactivation hook — store persists through every path.
-			},
-			{ resubscribable: true },
-		);
-
-		const u1 = computed.subscribe(() => {});
-		src.emit(1);
-		// Drive computed terminal via COMPLETE on src (autoComplete cascades).
-		src.down([[COMPLETE]]);
-		u1();
-
-		cycle = 2;
-		const u2 = computed.subscribe(() => {});
-		src.emit(2);
-
-		expect(cycle1.length).toBeGreaterThan(0);
-		expect(cycle2.length).toBeGreaterThan(0);
-		const cycle1Last = cycle1[cycle1.length - 1].calls as number;
-		const cycle2First = cycle2[0].calls as number;
-		// Without onDeactivation, the calls counter survives the
-		// terminal-then-deactivate-then-resubscribable cycle. Pre-flip would
-		// have reset it.
-		expect(cycle2First).toBeGreaterThan(cycle1Last);
-		u2();
-	});
-
-	it("(d) onDeactivation selective clear — listed keys gone, unlisted keys persist", () => {
-		const src = node<number>([], { initial: 0, resubscribable: true });
-		const cycle1: Array<Record<string, unknown>> = [];
-		const cycle2: Array<Record<string, unknown>> = [];
-		let cycle = 1;
-		const computed = node<number>([src], (data, a, ctx) => {
-			(cycle === 1 ? cycle1 : cycle2).push({
-				targetBefore: ctx.store.target,
-				keptBefore: ctx.store.kept,
-			});
-			ctx.store.target = "delete-me";
-			ctx.store.kept = "persist-me";
-			const batch = data[0];
-			if (batch != null && batch.length > 0) a.emit(batch.at(-1) as number);
-			else a.emit(ctx.prevData[0] as number);
-			const store = ctx.store;
-			return {
-				onDeactivation: () => {
-					delete store.target;
-					// NOT deleting `kept`.
-				},
-			};
-		});
-
-		const u1 = computed.subscribe(() => {});
-		src.emit(1);
-		u1();
-
-		cycle = 2;
-		const u2 = computed.subscribe(() => {});
-		src.emit(2);
-		u2();
-
-		// Cycle 1 first call: store empty.
-		expect(cycle1[0].targetBefore).toBeUndefined();
-		expect(cycle1[0].keptBefore).toBeUndefined();
-
-		// Cycle 2 first call: target was cleared, kept survived.
-		expect(cycle2.length).toBeGreaterThan(0);
-		expect(cycle2[0].targetBefore).toBeUndefined();
-		expect(cycle2[0].keptBefore).toBe("persist-me");
-	});
-
-	it("(e) transient sink subscribe/unsub during keepalive — store flows unchanged", () => {
-		const src = node<number>([], { initial: 0, resubscribable: true });
-		const observed: number[] = [];
-		const computed = node<number>([src], (data, a, ctx) => {
-			ctx.store.runs = ((ctx.store.runs as number | undefined) ?? 0) + 1;
-			observed.push(ctx.store.runs as number);
-			const batch = data[0];
-			if (batch != null && batch.length > 0) a.emit(batch.at(-1) as number);
-			else a.emit(ctx.prevData[0] as number);
-		});
-
-		const keepalive = computed.subscribe(() => {});
-		src.emit(1);
-		src.emit(2);
-
-		// Transient sink subscribe + immediate unsub. Because keepalive holds
-		// `_sinkCount > 0`, _deactivate does NOT run on the transient unsub.
-		const transient = computed.subscribe(() => {});
-		transient();
-
-		src.emit(3);
-
-		// Observer counter increments monotonically across the transient
-		// sub/unsub — no spurious reset.
-		expect(observed).toEqual(observed.slice().sort((a, b) => a - b));
-		expect(observed[observed.length - 1]).toBeGreaterThanOrEqual(3);
-
-		keepalive();
-	});
-});
diff --git a/packages/pure-ts/src/__tests__/core/phase-13-6-b8.test.ts b/packages/pure-ts/src/__tests__/core/phase-13-6-b8.test.ts
deleted file mode 100644
index f6f719df..00000000
--- a/packages/pure-ts/src/__tests__/core/phase-13-6-b8.test.ts
+++ /dev/null
@@ -1,60 +0,0 @@
-/**
- * Phase 13.6.B Batch 8 — extras data-structure cleanup.
- *
- * Covers:
- * - Lock 5.A — `reactiveLog<T>` narrowing + `hasLatest` removal + `append`
- *   runtime guard (further coverage in `extra/reactive-log-stress.test.ts`).
- * - Lock 4.D — `defaultTierOpts` constant exposed from `extra/storage`.
- * - Lock 6.E — `compactEvery` is part of the defaults table (no separate
- *   tier-by-tier opt; uniform across debounced tiers).
- */
-
-import { describe, expect, it } from "vitest";
-import { reactiveLog } from "../../extra/data-structures/reactive-log.js";
-import { defaultTierOpts } from "../../extra/storage/tiers.js";
-
-describe("Phase 13.6.B B8 — Lock 5.A reactiveLog narrowing", () => {
-	it("append(undefined) throws with Lock 5.A diagnostic", () => {
-		const lg = reactiveLog<number>();
-		expect(() => lg.append(undefined as unknown as number)).toThrow(/Lock 5\.A/);
-	});
-
-	it("appendMany rejects an undefined element with index in the message", () => {
-		const lg = reactiveLog<number>();
-		expect(() => lg.appendMany([1, undefined as unknown as number, 3])).toThrow(
-			/values\[1\][\s\S]*Lock 5\.A/,
-		);
-		// Backend left untouched — none of the values landed because the
-		// guard runs before mutation.
-		expect(lg.entries.cache).toEqual([]);
-	});
-
-	it("hasLatest is no longer on the bundle (TS-level removal)", () => {
-		const lg = reactiveLog<number>();
-		// @ts-expect-error — `hasLatest` was retired in Lock 5.A.
-		const _stale = lg.hasLatest;
-		expect(_stale).toBeUndefined();
-	});
-
-	it("lastValue still exists with narrowed Node<T> type", () => {
-		const lg = reactiveLog<number>();
-		const lv = lg.lastValue;
-		expect(lv.cache).toBeUndefined(); // empty log = sentinel
-		lg.append(7);
-		expect(lv.cache).toBe(7);
-	});
-});
-
-describe("Phase 13.6.B B8 — Lock 4.D / 6.E defaultTierOpts", () => {
-	it("exposes a frozen defaults constant with the locked values", () => {
-		expect(defaultTierOpts.debounceMs).toBe(0);
-		expect(defaultTierOpts.compactEvery).toBeUndefined();
-		expect(defaultTierOpts.filter).toBeUndefined();
-		expect(defaultTierOpts.keyOf).toBeUndefined();
-		expect(defaultTierOpts.codec).toBeDefined();
-	});
-
-	it("constant is frozen — accidental mutation throws in strict mode", () => {
-		expect(Object.isFrozen(defaultTierOpts)).toBe(true);
-	});
-});
diff --git a/packages/pure-ts/src/__tests__/core/phase-13-6-b9.test.ts b/packages/pure-ts/src/__tests__/core/phase-13-6-b9.test.ts
deleted file mode 100644
index 71a51b55..00000000
--- a/packages/pure-ts/src/__tests__/core/phase-13-6-b9.test.ts
+++ /dev/null
@@ -1,118 +0,0 @@
-/**
- * Phase 13.6.B Batch 9 — patterns + testing.
- *
- * - Lock 3.A — `awaitSettled` accepts a `kick` callback (subscribe-before-kick
- *   is structurally enforced; firstWhere subscribes synchronously before the
- *   Promise constructor runs).
- * - Lock 3.B — `assertDirtyPrecedesTerminalData` shipped at
- *   `@graphrefly/graphrefly/testing`. Detailed coverage in
- *   `__tests__/testing/assertions.test.ts`.
- * - Lock 3.C — `withBudgetGate` auto-wires adapter abort: budget exhaustion
- *   fires AbortController on every in-flight call.
- * - Lock 4.B (A) — `mutate` accepts `down` hook for closure-state
- *   rollback. Lock 4.B (B) `registerMutable` and (C) dev-mode Proxy are
- *   deferred carries (see docs/optimizations.md).
- * - Lock 1.A retest — audit-only; no code change in this batch.
- */
-
-import { describe, expect, it } from "vitest";
-import { mutate } from "../../../../../src/base/mutation/index.js";
-import { firstWhere } from "../../../../../src/base/sources/settled.js";
-import { node } from "../../core/node.js";
-
-describe("Phase 13.6.B B9 — Lock 3.A awaitSettled / firstWhere `kick` callback", () => {
-	it("kick fires after subscribe — synchronous emission lands in the Promise", async () => {
-		const src = node<number>([], { initial: null });
-		const result = await firstWhere(src, (v) => typeof v === "number" && v > 0, {
-			skipCurrent: true,
-			kick: () => src.emit(42),
-		});
-		expect(result).toBe(42);
-	});
-
-	it("kick that throws rejects the returned Promise without leaking subscription", async () => {
-		const src = node<number>([], { initial: null });
-		await expect(
-			firstWhere(src, (v) => typeof v === "number" && v > 0, {
-				skipCurrent: true,
-				kick: () => {
-					throw new Error("kick boom");
-				},
-			}),
-		).rejects.toThrow(/kick boom/);
-	});
-
-	it("no-kick form still works (caller fires emit after the call returns)", async () => {
-		const src = node<number>([], { initial: null });
-		const settled = firstWhere(src, (v) => typeof v === "number" && v > 0, {
-			skipCurrent: true,
-		});
-		// External event arrives after the helper returns.
-		setTimeout(() => src.emit(7), 0);
-		const result = await settled;
-		expect(result).toBe(7);
-	});
-});
-
-describe("Phase 13.6.B B9 — Lock 4.B (A) mutate `down` hook", () => {
-	it("fires down on action throw, after batch rollback", () => {
-		const out: string[] = [];
-		const myMap = new Map<string, number>();
-		const action = mutate(
-			{
-				up: (key: string, value: number) => {
-					myMap.set(key, value); // closure-state mutation
-					out.push(`set ${key}=${value}`);
-					if (value < 0) throw new Error("negative not allowed");
-					return value;
-				},
-				down: () => {
-					out.push("down");
-					myMap.clear();
-				},
-			},
-			{ frame: "transactional" },
-		);
-
-		// Success path — down is NOT fired.
-		action("a", 1);
-		expect(myMap.get("a")).toBe(1);
-		expect(out).toEqual(["set a=1"]);
-
-		// Failure path — down fires.
-		expect(() => action("b", -1)).toThrow(/negative/);
-		expect(out).toEqual(["set a=1", "set b=-1", "down"]);
-		expect(myMap.size).toBe(0); // down cleared the closure map
-	});
-
-	it("down that throws does NOT mask the original action error", () => {
-		const action = mutate(
-			{
-				up: () => {
-					throw new Error("original error");
-				},
-				down: () => {
-					throw new Error("down boom");
-				},
-			},
-			{ frame: "transactional" },
-		);
-		// Original error wins.
-		expect(() => action()).toThrow(/original error/);
-	});
-
-	it("down is not fired on successful action", () => {
-		let fired = 0;
-		const action = mutate(
-			{
-				up: () => 42,
-				down: () => {
-					fired += 1;
-				},
-			},
-			{ frame: "transactional" },
-		);
-		expect(action()).toBe(42);
-		expect(fired).toBe(0);
-	});
-});
diff --git a/packages/pure-ts/src/__tests__/core/phase-13-6-qa.test.ts b/packages/pure-ts/src/__tests__/core/phase-13-6-qa.test.ts
deleted file mode 100644
index 0e4c6c8f..00000000
--- a/packages/pure-ts/src/__tests__/core/phase-13-6-qa.test.ts
+++ /dev/null
@@ -1,223 +0,0 @@
-/**
- * Phase 13.6.B QA pass — regression tests for the patches landed during
- * the /qa adversarial review of B6–B10.
- *
- * - P1 — `firstWhere` settle helpers gate on `!settled`.
- * - P2 — `wrapMutation` `compensate` gates on `captureSet`.
- * - D1 — `onResubscribableReset` hook fires from `_resetForFreshLifecycle`.
- * - D5 — `assertDirtyPrecedesTerminalData` admits the push-on-subscribe
- *        handshake window (START + replay-buffer DATAs + optional DIRTY).
- *
- * D2 (BudgetGateBundle.dispose) and D3 (abort-capable warning) live in
- * the existing budget-gate test surface.
- */
-
-import { describe, expect, it, vi } from "vitest";
-import { mutate } from "../../../../../src/base/mutation/index.js";
-import { firstWhere } from "../../../../../src/base/sources/settled.js";
-import {
-	COMPLETE,
-	DATA,
-	DIRTY,
-	INVALIDATE,
-	type Messages,
-	RESOLVED,
-	START,
-} from "../../core/messages.js";
-import { node } from "../../core/node.js";
-import { assertDirtyPrecedesTerminalData } from "../../testing/index.js";
-
-describe("Phase 13.6.B QA P1 — firstWhere settle helpers gate on !settled", () => {
-	it("kick fires matching DATA then throws — Promise resolves with the DATA, not the kick error", async () => {
-		const src = node<number>([], { initial: null });
-		const result = await firstWhere(src, (v) => typeof v === "number" && v > 0, {
-			skipCurrent: true,
-			kick: () => {
-				src.emit(42);
-				// The settler ran inside the synchronous emit above; the
-				// throw below MUST NOT mask the resolved value.
-				throw new Error("kick boom");
-			},
-		});
-		expect(result).toBe(42);
-	});
-
-	it("source delivers [DATA matched, ERROR] in same wave — Promise resolves with DATA", async () => {
-		const src = node<number>([], { initial: null });
-		// Subscribe-and-fire-wave pattern: kick emits a multi-message wave
-		// where the first DATA matches and a follow-up ERROR would have
-		// overwritten `pending` pre-P1.
-		const result = await firstWhere(src, (v) => typeof v === "number" && v > 0, {
-			skipCurrent: true,
-			kick: () => {
-				src.down([
-					[DATA, 7],
-					[Symbol.for("graphrefly/ERROR"), new Error("late ERROR")],
-				]);
-			},
-		});
-		expect(result).toBe(7);
-	});
-});
-
-describe("Phase 13.6.B QA P2 — mutate down gates on captureSet", () => {
-	it("down does NOT fire when the action body never ran (framework-level batch error)", () => {
-		const downCalls: string[] = [];
-		// Force a pre-action throw: pass an invalid `seq` cursor whose
-		// `down([DIRTY, DATA])` rejects synchronously. The thrown error
-		// bubbles out of `bumpCursor` BEFORE `action()` runs → captureSet
-		// stays false → down must NOT fire (P2 contract).
-		const seq = node<number>([], { initial: 0 });
-		const downSpy = vi.spyOn(seq, "down").mockImplementation(() => {
-			throw new Error("cursor down threw");
-		});
-		const action = mutate(
-			{
-				up: () => {
-					downCalls.push("action ran");
-					return "ok";
-				},
-				down: () => downCalls.push("down fired"),
-			},
-			{ frame: "transactional", seq },
-		);
-		expect(() => action()).toThrow(/cursor down threw/);
-		expect(downCalls).toEqual([]);
-		downSpy.mockRestore();
-	});
-
-	it("down DOES fire when the action body throws", () => {
-		const out: string[] = [];
-		const action = mutate(
-			{
-				up: () => {
-					out.push("action partial");
-					throw new Error("action threw");
-				},
-				down: () => out.push("down fired"),
-			},
-			{ frame: "transactional" },
-		);
-		expect(() => action()).toThrow(/action threw/);
-		expect(out).toEqual(["action partial", "down fired"]);
-	});
-});
-
-describe("Phase 13.6.B QA D1 — onResubscribableReset hook", () => {
-	it("fires on multi-sub-stayed terminal-resubscribable reset (the case _deactivate doesn't fire)", () => {
-		// The exact case D1 was designed for: a sibling sink keeps the
-		// node alive across terminal, so _deactivate never runs and the
-		// `onDeactivation` hook never fires. When a NEW subscriber
-		// arrives, `_resetForFreshLifecycle` runs and must fire
-		// `onResubscribableReset` to clear store-flag state.
-		const src = node<number>([], { initial: 0, resubscribable: true });
-		const flagWipes: number[] = [];
-		const computed = node<number>(
-			[src],
-			(data, a, ctx) => {
-				if (ctx.store.emitted) {
-					a.down([[RESOLVED]]);
-					return;
-				}
-				const batch = data[0];
-				if (batch != null && batch.length > 0) a.emit(batch.at(-1) as number);
-				else a.emit(ctx.prevData[0] as number);
-				ctx.store.emitted = true;
-				const store = ctx.store;
-				return {
-					onResubscribableReset: () => {
-						flagWipes.push(1);
-						delete store.emitted;
-					},
-				};
-			},
-			{ resubscribable: true },
-		);
-
-		// TWO sinks subscribe — `sinkKeep` will outlive the terminal so
-		// _deactivate doesn't fire when sinkA unsubs.
-		const sinkKeep = computed.subscribe(() => {});
-		const sinkA = computed.subscribe(() => {});
-		src.emit(1);
-		expect(flagWipes).toEqual([]);
-
-		// Drive computed terminal via src COMPLETE (autoComplete cascade).
-		src.down([[COMPLETE]]);
-
-		// Drop sinkA — but sinkKeep is still attached, so _sinkCount > 0,
-		// _deactivate does NOT run, store flag stays `emitted: true`.
-		sinkA();
-		expect(flagWipes).toEqual([]);
-
-		// New sinkC subscribes — wasTerminal && _resubscribable →
-		// `_resetForFreshLifecycle` runs → `onResubscribableReset` fires
-		// → flag cleared.
-		const sinkC = computed.subscribe(() => {});
-		expect(flagWipes).toEqual([1]);
-
-		sinkKeep();
-		sinkC();
-	});
-
-	it("does NOT fire on the regular _deactivate path (only that's onDeactivation)", () => {
-		const src = node<number>([], { initial: 0, resubscribable: true });
-		let resetFires = 0;
-		let deactivateFires = 0;
-		const computed = node<number>(
-			[src],
-			(data, a, ctx) => {
-				const batch = data[0];
-				if (batch != null && batch.length > 0) a.emit(batch.at(-1) as number);
-				else a.emit(ctx.prevData[0] as number);
-				return {
-					onDeactivation: () => {
-						deactivateFires += 1;
-					},
-					onResubscribableReset: () => {
-						resetFires += 1;
-					},
-				};
-			},
-			{ resubscribable: true },
-		);
-
-		const u1 = computed.subscribe(() => {});
-		src.emit(1);
-		u1(); // last-sink-detach → _deactivate fires → onDeactivation only
-		expect(deactivateFires).toBe(1);
-		expect(resetFires).toBe(0);
-	});
-});
-
-describe("Phase 13.6.B QA D5 — assertDirtyPrecedesTerminalData handshake carve-out", () => {
-	it("admits the Lock 6.G replayBuffer handshake [START, DATA, DATA, DATA]", () => {
-		const messages: Messages = [[START], [DATA, 1], [DATA, 2], [DATA, 3]];
-		expect(() => assertDirtyPrecedesTerminalData(messages)).not.toThrow();
-	});
-
-	it("admits handshake followed by post-handshake wave [START, DATA, DIRTY, DATA]", () => {
-		const messages: Messages = [[START], [DATA, 1], [DIRTY], [DATA, 2]];
-		expect(() => assertDirtyPrecedesTerminalData(messages)).not.toThrow();
-	});
-
-	it("rejects post-handshake DATA with no preceding DIRTY", () => {
-		const messages: Messages = [
-			[START],
-			[DATA, 1],
-			[DIRTY],
-			[DATA, 2],
-			[DATA, 3], // unbalanced — no second DIRTY
-		];
-		expect(() => assertDirtyPrecedesTerminalData(messages)).toThrow(/P\.25/);
-	});
-
-	it("rejects post-INVALIDATE RESOLVED without preceding DIRTY (P3 case)", () => {
-		const messages: Messages = [[INVALIDATE], [RESOLVED]];
-		expect(() => assertDirtyPrecedesTerminalData(messages)).toThrow(/P\.25/);
-	});
-
-	it("legacy P.25 [RESOLVED] without START still admitted (back-compat)", () => {
-		const messages: Messages = [[RESOLVED], [DIRTY], [DATA, 1]];
-		expect(() => assertDirtyPrecedesTerminalData(messages)).not.toThrow();
-	});
-});
diff --git a/packages/pure-ts/src/__tests__/core/protocol.test.ts b/packages/pure-ts/src/__tests__/core/protocol.test.ts
deleted file mode 100644
index fedce19e..00000000
--- a/packages/pure-ts/src/__tests__/core/protocol.test.ts
+++ /dev/null
@@ -1,908 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { batch, downWithBatch, isBatching } from "../../core/batch.js";
-import type { GlobalInspectorEvent } from "../../core/config.js";
-import { GraphReFlyConfig, registerBuiltins } from "../../core/config.js";
-import {
-	COMPLETE,
-	DATA,
-	DIRTY,
-	ERROR,
-	type Messages,
-	PAUSE,
-	RESOLVED,
-	RESUME,
-	START,
-	TEARDOWN,
-} from "../../core/messages.js";
-import { defaultConfig, node } from "../../core/node.js";
-
-/** Shorthand for the tierOf callback required by downWithBatch in v5. */
-const tierOf = (t: symbol) => defaultConfig.messageTier(t);
-
-describe("message protocol", () => {
-	// Regression: GRAPHREFLY-SPEC §1.1 — Messages are arrays of tuples; no single-message shorthand.
-	it("messages are arrays of [Type, Data?] tuples — no shorthand", () => {
-		const msgs: readonly [typeof DATA, number][] = [[DATA, 42]];
-		expect(msgs).toEqual([[DATA, 42]]);
-	});
-});
-
-describe("downWithBatch", () => {
-	// Regression: GRAPHREFLY-SPEC §1.3.1 — outside a batch, DIRTY reaches sinks before DATA.
-	it("without batch: emits immediate then phase-2 in order", () => {
-		const log: symbol[][] = [];
-		downWithBatch(
-			(msgs) => {
-				log.push(msgs.map((m) => m[0]));
-			},
-			[[DIRTY], [DATA, 1]],
-			tierOf,
-		);
-		expect(log).toEqual([[DIRTY], [DATA]]);
-	});
-
-	// Regression: phase-2 before terminal — COMPLETE alone would otherwise reach sinks before deferred DATA.
-	it("without batch: DATA then COMPLETE when both appear in one downWithBatch", () => {
-		const log: symbol[][] = [];
-		downWithBatch(
-			(msgs) => {
-				log.push(msgs.map((m) => m[0]));
-			},
-			[[DATA, 1], [COMPLETE]],
-			tierOf,
-		);
-		expect(log).toEqual([[DATA], [COMPLETE]]);
-	});
-
-	// Regression: GRAPHREFLY-SPEC §1.3.7 — inside batch, DIRTY flushes immediately; DATA waits for batch end.
-	it("inside batch: DIRTY immediate, DATA deferred until batch exits", () => {
-		const log: symbol[][] = [];
-		batch(() => {
-			expect(isBatching()).toBe(true);
-			downWithBatch(
-				(msgs) => {
-					log.push(msgs.map((m) => m[0]));
-				},
-				[[DIRTY], [DATA, 42]],
-				tierOf,
-			);
-			expect(log).toEqual([[DIRTY]]);
-		});
-		expect(isBatching()).toBe(false);
-		expect(log).toEqual([[DIRTY], [DATA]]);
-	});
-
-	// Regression: GRAPHREFLY-SPEC §1.3.7 — RESOLVED is phase-2 and deferred with DATA.
-	it("RESOLVED is deferred like DATA (phase 2)", () => {
-		const log: symbol[][] = [];
-		batch(() => {
-			downWithBatch(
-				(msgs) => {
-					log.push(msgs.map((m) => m[0]));
-				},
-				[[DIRTY], [RESOLVED]],
-				tierOf,
-			);
-			expect(log).toEqual([[DIRTY]]);
-		});
-		expect(log).toEqual([[DIRTY], [RESOLVED]]);
-	});
-
-	// Regression: GRAPHREFLY-SPEC §1.3.7 — nested batch: inner deferred work waits for outer drain.
-	it("nested batch does not flush until outermost exits", () => {
-		const log: string[] = [];
-		batch(() => {
-			downWithBatch(
-				(msgs) => log.push(`a:${msgs[0]?.[0] === DATA ? "d" : "i"}`),
-				[[DATA, 1]],
-				tierOf,
-			);
-			batch(() => {
-				downWithBatch(
-					(msgs) => log.push(`b:${msgs[0]?.[0] === DATA ? "d" : "i"}`),
-					[[DATA, 2]],
-					tierOf,
-				);
-				expect(log.filter((x) => x.startsWith("b"))).toEqual([]);
-			});
-			expect(log.filter((x) => x.startsWith("b"))).toEqual([]);
-		});
-		expect(log).toEqual(["a:d", "b:d"]);
-	});
-
-	// Regression: GRAPHREFLY-SPEC §1.3.6 — unknown types are not treated as phase-2 for deferral.
-	it("unknown message types are not deferred (forward-compat)", () => {
-		const CUSTOM = Symbol("custom.upstream");
-		const log: string[] = [];
-		batch(() => {
-			downWithBatch(
-				(msgs) => {
-					log.push(String(msgs[0]?.[0]));
-				},
-				[[CUSTOM, { x: 1 }]],
-				tierOf,
-			);
-			expect(log.length).toBe(1);
-		});
-		expect(log.length).toBe(1);
-	});
-
-	// Regression: GRAPHREFLY-SPEC §1.1 — empty batches are ignored.
-	it("empty messages is a no-op", () => {
-		let n = 0;
-		downWithBatch(
-			() => {
-				n += 1;
-			},
-			[],
-			tierOf,
-		);
-		expect(n).toBe(0);
-	});
-
-	// Regression: GRAPHREFLY-SPEC §1.3.7 — throwing during batch discards deferred phase-2 for that batch.
-	it("does not flush deferred phase-2 when batch fn throws", () => {
-		const log: symbol[][] = [];
-		expect(() =>
-			batch(() => {
-				downWithBatch(
-					(msgs) => {
-						log.push(msgs.map((m) => m[0]));
-					},
-					[[DATA, 1]],
-					tierOf,
-				);
-				throw new Error("abort");
-			}),
-		).toThrow("abort");
-		expect(log).toEqual([]);
-	});
-
-	// Regression: GRAPHREFLY-SPEC §1.3.7 — inner batch throw aborts outer deferral without flushing pending DATA.
-	it("nested inner throw clears pending for outer batch", () => {
-		const log: symbol[][] = [];
-		expect(() =>
-			batch(() => {
-				downWithBatch(
-					(msgs) => {
-						log.push(msgs.map((m) => m[0]));
-					},
-					[[DATA, 1]],
-					tierOf,
-				);
-				batch(() => {
-					throw new Error("inner");
-				});
-			}),
-		).toThrow("inner");
-		expect(log).toEqual([]);
-	});
-});
-
-describe("batch drain semantics", () => {
-	// Regression: GRAPHREFLY-SPEC §1.3.7 — during drain, `isBatching` stays true; nested phase-2 re-queues.
-	it("isBatching is true during drain (nested emissions are deferred)", () => {
-		const log: string[] = [];
-		let batchingDuringDrain: boolean | undefined;
-
-		batch(() => {
-			downWithBatch(
-				(_msgs) => {
-					// This runs during drain — isBatching should be true
-					batchingDuringDrain = isBatching();
-					log.push("first-drain");
-					// Nested emission during drain should be deferred
-					downWithBatch(
-						(_msgs2) => {
-							log.push("nested-drain");
-						},
-						[[DATA, 99]],
-						tierOf,
-					);
-				},
-				[[DATA, 1]],
-				tierOf,
-			);
-		});
-
-		expect(batchingDuringDrain).toBe(true);
-		// Both should have drained: first, then nested
-		expect(log).toEqual(["first-drain", "nested-drain"]);
-	});
-
-	// Regression: GRAPHREFLY-SPEC §1.3.7 — drain processes multiple deferred emissions; isolate callback failures.
-	it("per-emission try/catch: one throwing callback does not orphan others", () => {
-		const log: string[] = [];
-
-		expect(() =>
-			batch(() => {
-				downWithBatch(
-					() => {
-						throw new Error("boom");
-					},
-					[[DATA, 1]],
-					tierOf,
-				);
-				downWithBatch(
-					() => {
-						log.push("second");
-					},
-					[[DATA, 2]],
-					tierOf,
-				);
-			}),
-		).toThrow("boom");
-
-		// Second callback should still have run despite first throwing
-		expect(log).toEqual(["second"]);
-	});
-
-	// Regression: GRAPHREFLY-SPEC §1.3.7 — after outermost batch exits, `isBatching` is false.
-	it("isBatching is false after drain completes", () => {
-		batch(() => {
-			downWithBatch(() => undefined, [[DATA, 1]], tierOf);
-		});
-		expect(isBatching()).toBe(false);
-	});
-
-	// Regression: GRAPHREFLY-SPEC §1.3.7 — nested throw during drain: outer deferred items still run where specified (A4).
-	it("nested batch throw during drain does not clear outer deferral queue (A4)", () => {
-		const log: string[] = [];
-		expect(() =>
-			batch(() => {
-				downWithBatch(
-					() => {
-						downWithBatch(
-							() => {
-								log.push("deferred-from-callback");
-							},
-							[[DATA, 1]],
-							tierOf,
-						);
-						batch(() => {
-							throw new Error("inner");
-						});
-					},
-					[[DATA, 0]],
-					tierOf,
-				);
-			}),
-		).toThrow("inner");
-		expect(log).toEqual(["deferred-from-callback"]);
-	});
-});
-
-describe("D4: drain cycle detection", () => {
-	// Regression: GRAPHREFLY-SPEC §1.3.7 — unbounded re-entrant deferral during drain must throw (cycle guard).
-	it("reactive cycle during drain throws instead of infinite-looping", () => {
-		expect(() =>
-			batch(() => {
-				const cyclicEmit = (): void => {
-					downWithBatch(
-						() => {
-							// re-enqueue indefinitely
-							downWithBatch(() => cyclicEmit(), [[DATA, 1]], tierOf);
-						},
-						[[DATA, 0]],
-						tierOf,
-					);
-				};
-				cyclicEmit();
-			}),
-		).toThrow(/reactive cycle/);
-	});
-});
-
-describe("terminal and control messages are not phase-2", () => {
-	// Regression: GRAPHREFLY-SPEC §1.2 — PAUSE, RESUME emit immediately even in batch (tier 2).
-	it("PAUSE, RESUME emit immediately in batch", () => {
-		for (const t of [PAUSE, RESUME] as const) {
-			const log: symbol[] = [];
-			batch(() => {
-				downWithBatch(
-					(msgs) => {
-						log.push(msgs[0]?.[0] as symbol);
-					},
-					[[t]],
-					tierOf,
-				);
-				expect(log).toEqual([t]);
-			});
-			expect(log).toEqual([t]);
-		}
-	});
-
-	// DS-13.5.A: TEARDOWN is tier 6, deferred to drainPhase4 inside a batch.
-	it("TEARDOWN is deferred inside batch (tier 6)", () => {
-		const log: symbol[] = [];
-		batch(() => {
-			downWithBatch(
-				(msgs) => {
-					log.push(msgs[0]?.[0] as symbol);
-				},
-				[[TEARDOWN]],
-				tierOf,
-			);
-			// TEARDOWN is deferred inside batch.
-			expect(log).toEqual([]);
-		});
-		// Delivered on batch exit.
-		expect(log).toEqual([TEARDOWN]);
-	});
-
-	// Canonical ordering: terminal signals (COMPLETE, ERROR) are tier 5 — deferred to
-	// after phase-2 (settle slice) inside a batch, so DATA/RESOLVED/INVALIDATE reach
-	// sinks before node goes terminal.
-	it("ERROR, COMPLETE are deferred (tier 5) — delivered after phase-2 in batch", () => {
-		for (const t of [ERROR, COMPLETE] as const) {
-			const log: symbol[] = [];
-			batch(() => {
-				downWithBatch(
-					(msgs) => {
-						log.push(msgs[0]?.[0] as symbol);
-					},
-					[[t]],
-					tierOf,
-				);
-				// Terminal is deferred inside batch (tier 5).
-				expect(log).toEqual([]);
-			});
-			// Delivered on batch exit.
-			expect(log).toEqual([t]);
-		}
-	});
-
-	// Canonical ordering: [[DATA, v], [COMPLETE]] delivers DATA before COMPLETE.
-	it("DATA before COMPLETE in composite batch (one-shot source pattern)", () => {
-		const log: symbol[][] = [];
-		downWithBatch(
-			(msgs) => {
-				log.push(msgs.map((m) => m[0]));
-			},
-			[[DATA, null], [COMPLETE]],
-			tierOf,
-		);
-		expect(log).toEqual([[DATA], [COMPLETE]]);
-	});
-
-	// Canonical ordering with all three tiers present.
-	it("DIRTY then DATA then COMPLETE in composite batch", () => {
-		const log: symbol[][] = [];
-		downWithBatch(
-			(msgs) => {
-				log.push(msgs.map((m) => m[0]));
-			},
-			[[DIRTY], [DATA, 42], [COMPLETE]],
-			tierOf,
-		);
-		expect(log).toEqual([[DIRTY], [DATA], [COMPLETE]]);
-	});
-
-	// Inside batch: immediate, then deferred phase-2, then deferred terminal.
-	it("inside batch: DIRTY immediate, DATA and COMPLETE deferred in order", () => {
-		const log: symbol[][] = [];
-		batch(() => {
-			downWithBatch(
-				(msgs) => {
-					log.push(msgs.map((m) => m[0]));
-				},
-				[[DIRTY], [DATA, 1], [COMPLETE]],
-				tierOf,
-			);
-			// Only DIRTY is immediate.
-			expect(log).toEqual([[DIRTY]]);
-		});
-		// After batch: DATA then COMPLETE.
-		expect(log).toEqual([[DIRTY], [DATA], [COMPLETE]]);
-	});
-});
-
-describe("integration: void sources", () => {
-	// Regression: one-shot sources (IDB, Promise wrappers) emitting [[DATA, null], [COMPLETE]]
-	// through operators previously broke because COMPLETE was delivered before DATA.
-	it("one-shot void producer delivers DATA(null) then COMPLETE to subscriber", () => {
-		const log: [symbol, unknown?][] = [];
-		// Simulate a one-shot void source (like fromIDBTransaction).
-		// null is the protocol-idiomatic "void" value; undefined is reserved as sentinel.
-		const oneShot = node<null>(
-			[],
-			(_data, actions) => {
-				actions.down([[DATA, null], [COMPLETE]]);
-			},
-			{ describeKind: "producer" },
-		);
-		const unsub = oneShot.subscribe((msgs: Messages) => {
-			for (const m of msgs) log.push([m[0], m[1]]);
-		});
-		// Subscribe delivers [[START]] handshake first; then the producer's
-		// fn emits DATA(null)+COMPLETE during `_onActivate`. Under the
-		// B1 unified dispatch, raw `actions.down([[DATA], [COMPLETE]])` is
-		// auto-framed with `[DIRTY]` at the emit waist.
-		expect(log.map((m) => m[0])).toEqual([START, DIRTY, DATA, COMPLETE]);
-		expect(log[2][1]).toBe(null);
-		unsub();
-	});
-});
-
-// ---------------------------------------------------------------------------
-// B3 — Equals subtree skip correctness (guards against cascade regressions)
-// ---------------------------------------------------------------------------
-
-describe("B3: equals subtree skip — downstream fn-run counts under no-op inputs", () => {
-	it("5-level chain: 50% no-op writes only re-run leaf fn on actual changes", () => {
-		// Source toggles between 0 and 1 every other write. With equals
-		// configured on every level, the duplicate writes should produce
-		// RESOLVED at the first derived, which cascades as RESOLVED through
-		// the chain, which fires the downstream pre-fn skip at every level.
-		// The leaf fn should run exactly (writes / 2 + 1) times — once for
-		// each distinct value, not once per write.
-		const a = node<number>([], { initial: 0 });
-		let leafRuns = 0;
-		const b = node(
-			[a],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as number) * 2);
-			},
-			{ describeKind: "derived", equals: (x, y) => x === y },
-		);
-		const c = node(
-			[b],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as number) + 1);
-			},
-			{ describeKind: "derived", equals: (x, y) => x === y },
-		);
-		const d = node(
-			[c],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as number) - 1);
-			},
-			{ describeKind: "derived", equals: (x, y) => x === y },
-		);
-		const e = node(
-			[d],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				leafRuns += 1;
-				actions.emit((data[0] as number) + 7);
-			},
-			{ describeKind: "derived", equals: (x, y) => x === y },
-		);
-		const unsub = e.subscribe(() => undefined);
-		const baseRuns = leafRuns; // initial activation run
-		// Pattern: 0, 0, 1, 1, 0, 0, 1, 1 — each distinct value repeats
-		// twice, so the leaf should run exactly 4 times (one per pair).
-		const pattern = [0, 0, 1, 1, 0, 0, 1, 1];
-		for (const v of pattern) {
-			a.down([[DATA, v]]);
-		}
-		// Expected: baseRuns (initial) + 4 transitions (0→1, 1→0, 0→1 after
-		// the first 0 which equals the initial). Actually the initial cache
-		// is 0; the first push(0) should RESOLVED (no leaf re-run); second
-		// push(0) RESOLVED; push(1) → DATA → leaf runs; push(1) RESOLVED;
-		// push(0) → DATA → leaf runs; push(0) RESOLVED; push(1) → DATA →
-		// leaf runs; push(1) RESOLVED. That's 3 leaf runs after initial.
-		expect(leafRuns - baseRuns).toBe(3);
-		expect(e.cache).toBe(1 * 2 + 1 - 1 + 7); // = 9
-		unsub();
-	});
-
-	it("diamond: both legs collapse to RESOLVED when source doesn't change", () => {
-		// Source toggle drives both legs. Duplicate writes should produce
-		// RESOLVED on both legs, which the join's pre-fn skip absorbs.
-		const src = node<number>([], { initial: 0 });
-		let joinRuns = 0;
-		const left = node(
-			[src],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as number) * 2);
-			},
-			{ describeKind: "derived", equals: (x, y) => x === y },
-		);
-		const right = node(
-			[src],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as number) + 10);
-			},
-			{ describeKind: "derived", equals: (x, y) => x === y },
-		);
-		const joined = node(
-			[left, right],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				joinRuns += 1;
-				actions.emit((data[0] as number) + (data[1] as number));
-			},
-			{ describeKind: "derived", equals: (x, y) => x === y },
-		);
-		const unsub = joined.subscribe(() => undefined);
-		const baseRuns = joinRuns;
-		// Write the same value twice — the join should see RESOLVED on both
-		// legs and skip entirely.
-		src.down([[DATA, 0]]);
-		src.down([[DATA, 0]]);
-		expect(joinRuns - baseRuns).toBe(0);
-		// Actually change the value — join runs once.
-		src.down([[DATA, 1]]);
-		expect(joinRuns - baseRuns).toBe(1);
-		expect(joined.cache).toBe(1 * 2 + (1 + 10)); // = 13
-		unsub();
-	});
-});
-
-// ---------------------------------------------------------------------------
-// C0 — PAUSE/RESUME lock-id tracking + bufferAll
-// ---------------------------------------------------------------------------
-
-describe("C0: PAUSE/RESUME lock-id", () => {
-	it("bare [[PAUSE]] without lockId throws", () => {
-		const a = node([], { initial: 0 });
-		const d = node(
-			[a],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit(data[0]);
-			},
-			{ describeKind: "derived" },
-		);
-		const unsub = d.subscribe(() => {});
-		expect(() => a.down([[PAUSE]])).toThrow(/lockId/);
-		unsub();
-	});
-
-	it("bare [[RESUME]] without lockId throws", () => {
-		const a = node([], { initial: 0 });
-		const d = node(
-			[a],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit(data[0]);
-			},
-			{ describeKind: "derived" },
-		);
-		const unsub = d.subscribe(() => {});
-		expect(() => a.down([[RESUME]])).toThrow(/lockId/);
-		unsub();
-	});
-
-	it("multi-pauser correctness — releasing one lock keeps paused while another holds", () => {
-		const a = node([], { initial: 0 });
-		// effect-style node that can be observed for paused state
-		let fnRuns = 0;
-		const d = node(
-			[a],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				fnRuns += 1;
-				actions.emit(data[0]);
-			},
-			{ describeKind: "derived" },
-		);
-		const unsub = d.subscribe(() => {});
-		const baseRuns = fnRuns;
-
-		const lockA = Symbol("A");
-		const lockB = Symbol("B");
-
-		// Two pausers hold locks.
-		a.down([[PAUSE, lockA]]);
-		a.down([[PAUSE, lockB]]);
-
-		// While paused, a new DATA from `a` should not cause `d.fn` to run.
-		a.down([[DIRTY], [DATA, 1]]);
-		expect(fnRuns).toBe(baseRuns); // still paused, no fn execution
-
-		// Lock A releases first — lock B still held, so `d` stays paused.
-		a.down([[RESUME, lockA]]);
-		expect(fnRuns).toBe(baseRuns); // B still holds
-
-		// Lock B releases — now all locks released, pending wave replays.
-		a.down([[RESUME, lockB]]);
-		expect(fnRuns).toBe(baseRuns + 1);
-		expect(d.cache).toBe(1);
-
-		unsub();
-	});
-
-	it("idempotent RESUME for unknown lockId is a no-op", () => {
-		const a = node([], { initial: 0 });
-		const d = node(
-			[a],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit(data[0]);
-			},
-			{ describeKind: "derived" },
-		);
-		const unsub = d.subscribe(() => {});
-
-		const lock = Symbol("ghost");
-		// Never paused with this lock — RESUME should not throw, should not
-		// unpause anything, and should leave the node in a normal state.
-		expect(() => a.down([[RESUME, lock]])).not.toThrow();
-		a.down([[DIRTY], [DATA, 42]]);
-		expect(d.cache).toBe(42);
-		unsub();
-	});
-
-	it("pausable: resumeAll buffers DATA and replays on final lock release", () => {
-		// A node with bufferAll mode buffers outgoing tier-3 messages while
-		// paused, then replays them in order when the final lock is released.
-		const s = node<number>(
-			(_actions) => {
-				// Manual producer — we drive it via node.emit from outside.
-			},
-			{ pausable: "resumeAll", initial: 0, describeKind: "state" },
-		);
-		const log: number[] = [];
-		const unsub = s.subscribe((msgs) => {
-			for (const m of msgs) {
-				if (m[0] === DATA) log.push(m[1] as number);
-			}
-		});
-		const baseLog = log.length;
-
-		const lock = Symbol("bufferAll");
-		s.down([[PAUSE, lock]]);
-
-		// While paused, emit three DATA values — they should be buffered, not
-		// delivered live.
-		s.emit(1);
-		s.emit(2);
-		s.emit(3);
-		expect(log.length).toBe(baseLog); // nothing delivered while paused
-
-		// Release the lock — buffered values replay in order.
-		s.down([[RESUME, lock]]);
-		expect(log.slice(baseLog)).toEqual([1, 2, 3]);
-		expect(s.cache).toBe(3);
-
-		unsub();
-	});
-
-	it("R2.6.0 boundary: pausable: resumeAll DOES buffer a leaf source's direct external down([[DATA,v]]) and replays on RESUME (vs default mode = immediate)", () => {
-		// Spec §2.6 R2.6.0 (Option A, pinned 2026-05-17): the default-vs-
-		// resumeAll distinction for a leaf source's *direct external*
-		// `down([[DATA, v]])` push.
-		//   - **default `pausable: true`**: no dep wave to coalesce → the
-		//     direct push is delivered IMMEDIATELY (cross-impl-pinned in
-		//     `packages/parity-tests/scenarios/core/pause-resume.test.ts`,
-		//     and raw-API-pinned by the default-mode tests in this file).
-		//   - **`pausable: "resumeAll"`** (this test): the explicit
-		//     opt-in to buffer the node's outgoing tier-3/4 settle slices
-		//     while paused — INCLUDING a leaf source's own direct
-		//     `down([[DATA,v]])` — replaying them on final-lock RESUME.
-		// So the two modes are NOT equivalent for a self-paused leaf
-		// source's external push: default = keep producing; resumeAll =
-		// buffer & replay everything the node emits.
-		const s = node<number>([], {
-			pausable: "resumeAll",
-			initial: 0,
-			describeKind: "state",
-		});
-		const log: number[] = [];
-		const unsub = s.subscribe((msgs) => {
-			for (const m of msgs) {
-				if (m[0] === DATA) log.push(m[1] as number);
-			}
-		});
-		const baseLen = log.length;
-
-		const lock = Symbol("r2.6.0-self-down");
-		s.down([[PAUSE, lock]]);
-
-		// Direct external self-emit while self-paused — NOT `s.emit(...)`.
-		// Under "resumeAll" this is captured into the pause buffer.
-		s.down([[DATA, 42]]);
-		expect(log.slice(baseLen)).toEqual([]); // buffered, NOT delivered live
-		expect(s.cache).toBe(42); // cache still advances mid-pause (R2.6.1)
-
-		// Final-lock RESUME drains the buffer — the sink observes 42 now.
-		s.down([[RESUME, lock]]);
-		expect(log.slice(baseLen)).toEqual([42]);
-		expect(s.cache).toBe(42);
-
-		unsub();
-	});
-
-	it("pausable: resumeAll — COMPLETE bypasses bufferAll and reaches subscribers even while paused", () => {
-		// Spec §2.6 bufferAll: tier-5 (COMPLETE/ERROR) dispatches synchronously
-		// even while a pause lock is held — stream-lifecycle signals must
-		// reach observers regardless of flow control, parallel to tier-6
-		// TEARDOWN's bypass. Prior to this: tier-5 was captured in pauseBuffer
-		// and silently discarded at _deactivate if no RESUME ever came,
-		// stranding subscribers without an end-of-stream signal.
-		const s = node([], { pausable: "resumeAll", initial: 0 });
-		const seen: Array<[symbol, unknown?]> = [];
-		const unsub = s.subscribe((msgs) => {
-			for (const m of msgs) seen.push([m[0], m[1]]);
-		});
-		// Capture the index right after the subscribe handshake so we can
-		// reason about only the post-activation trace (initial [[DATA, 0]]
-		// push-on-subscribe is part of the handshake and not relevant here).
-		const postActivation = seen.length;
-		const lock = Symbol("held-indefinitely");
-		s.down([[PAUSE, lock]]);
-		s.emit(1); // captured in buffer, never observed (expected lost)
-		s.emit(2); // captured in buffer, never observed (expected lost)
-		s.down([[COMPLETE]]);
-		const tail = seen.slice(postActivation);
-		// Subscriber MUST observe COMPLETE even though lock is still held.
-		expect(tail.map((m) => m[0])).toContain(COMPLETE);
-		// Emits (1) and (2) must stay buffered — no DATA payload 1 or 2
-		// reached the subscriber. (DIRTY/RESOLVED tier-1/3 bookkeeping is
-		// orthogonal; specifically the deferred DATA values are absent.)
-		for (const [t, v] of tail) {
-			if (t === DATA) {
-				expect(v).not.toBe(1);
-				expect(v).not.toBe(2);
-			}
-		}
-		unsub();
-	});
-
-	it("pausable: resumeAll — ERROR bypasses bufferAll and reaches subscribers even while paused", () => {
-		// Companion to the COMPLETE test: tier-5 ERROR also bypasses bufferAll.
-		const s = node([], { pausable: "resumeAll", initial: 0 });
-		const seen: Array<{ type: symbol; value?: unknown }> = [];
-		const unsub = s.subscribe((msgs) => {
-			for (const m of msgs) seen.push({ type: m[0], value: m[1] });
-		});
-		const lock = Symbol("held");
-		s.down([[PAUSE, lock]]);
-		s.emit(1);
-		const err = new Error("boom");
-		s.down([[ERROR, err]]);
-		const errorEntry = seen.find((e) => e.type === ERROR);
-		expect(errorEntry).toBeDefined();
-		expect(errorEntry?.value).toBe(err);
-		unsub();
-	});
-
-	it("pause state is cleared on teardown — no leak, no cross-lifecycle bleed", () => {
-		// Regression: bufferAll state (_pauseLocks, _pauseBuffer) used to
-		// leak across _deactivate, which was both a memory leak on
-		// non-resubscribable nodes and a correctness bug on resubscribable
-		// nodes (new subscribers would see a permanently stuck node with
-		// pauseLocks from a dead lifecycle).
-		const s = node<number>([], {
-			pausable: "resumeAll",
-			resubscribable: true,
-			initial: 0,
-		}) as unknown as import("../../core/node.js").NodeImpl<number>;
-		const lockOldLifecycle = Symbol("lock-old");
-
-		const unsub = s.subscribe(() => undefined);
-		s.down([[PAUSE, lockOldLifecycle]]);
-		s.emit(1); // buffered
-		s.emit(2); // buffered
-		// Terminate the lifecycle WITHOUT releasing the lock.
-		s.down([[COMPLETE]]);
-		unsub();
-		// After teardown the internal pause state should be clean.
-		expect(s._pauseLocks).toBeNull();
-		expect(s._pauseBuffer).toBeNull();
-		expect(s._paused).toBe(false);
-
-		// Resubscribable reset: new subscriber should see a clean node, not
-		// a stuck-paused leftover from the previous lifecycle.
-		const log: number[] = [];
-		const unsub2 = s.subscribe((msgs) => {
-			for (const m of msgs) if (m[0] === DATA) log.push(m[1] as number);
-		});
-		expect(s._pauseLocks).toBeNull();
-		expect(s._paused).toBe(false);
-		// Emit a new value — should flow through, not get swallowed.
-		s.emit(99);
-		expect(log).toContain(99);
-		unsub2();
-	});
-});
-
-describe("globalInspector hook", () => {
-	function freshConfig(): GraphReFlyConfig {
-		const cfg = new GraphReFlyConfig({
-			onMessage: defaultConfig.onMessage,
-			onSubscribe: defaultConfig.onSubscribe,
-		});
-		registerBuiltins(cfg);
-		return cfg;
-	}
-
-	it("fires once per outgoing batch with the final messages", () => {
-		const cfg = freshConfig();
-		const events: GlobalInspectorEvent[] = [];
-		cfg.globalInspector = (ev) => events.push(ev);
-
-		const s = node([], { config: cfg, initial: 0 });
-		const off = s.subscribe(() => {});
-		// Subscribe handshake delivers START + cached DATA via `downToSink`,
-		// not through `_emit`'s framing waist — hook does not fire on handshake.
-		expect(events.length).toBe(0);
-
-		s.emit(1);
-		expect(events.length).toBe(1);
-		const ev = events[0]!;
-		expect(ev.kind).toBe("emit");
-		expect(ev.node).toBe(s);
-		// finalMessages is post-equals: DIRTY + DATA(1).
-		const types = ev.messages.map((m) => m[0]);
-		expect(types).toContain(DIRTY);
-		expect(types).toContain(DATA);
-
-		off();
-	});
-
-	it("respects inspectorEnabled toggle (no fire when disabled)", () => {
-		const cfg = freshConfig();
-		cfg.inspectorEnabled = false;
-		let calls = 0;
-		cfg.globalInspector = () => {
-			calls++;
-		};
-
-		const s = node([], { config: cfg, initial: 0 });
-		const off = s.subscribe(() => {});
-		s.emit(1);
-		expect(calls).toBe(0);
-		off();
-	});
-
-	it("swallows hook exceptions (instrumentation cannot break the data plane)", () => {
-		const cfg = freshConfig();
-		cfg.globalInspector = () => {
-			throw new Error("inspector blew up");
-		};
-
-		const s = node([], { config: cfg, initial: 0 });
-		const log: number[] = [];
-		const off = s.subscribe((msgs) => {
-			for (const m of msgs) if (m[0] === DATA) log.push(m[1] as number);
-		});
-		expect(() => s.emit(42)).not.toThrow();
-		expect(log).toContain(42);
-		off();
-	});
-
-	it("settable at any time (does not freeze the config)", () => {
-		const cfg = freshConfig();
-		const s = node([], { config: cfg, initial: 0 });
-		// Touching a hook getter freezes the config; touching globalInspector must not.
-		const initial = cfg.globalInspector;
-		expect(initial).toBeUndefined();
-		// Setting after a node exists should still work.
-		cfg.globalInspector = () => {};
-		expect(cfg.globalInspector).toBeDefined();
-		// Resetting to undefined unsubscribes.
-		cfg.globalInspector = undefined;
-		expect(cfg.globalInspector).toBeUndefined();
-		void s;
-	});
-});
diff --git a/packages/pure-ts/src/__tests__/core/regressions.test.ts b/packages/pure-ts/src/__tests__/core/regressions.test.ts
deleted file mode 100644
index 7d54c2d7..00000000
--- a/packages/pure-ts/src/__tests__/core/regressions.test.ts
+++ /dev/null
@@ -1,291 +0,0 @@
-/**
- * Regression tests for spec-verified behaviors.
- * Each test names the bug and anchors it to a spec section.
- *
- * Note: Many PY regression scenarios are already covered in other TS test files:
- * - RESOLVED transitive skip → node.test.ts
- * - Diamond recompute count → node.test.ts, operators.test.ts
- * - describe() Appendix B → graph.test.ts
- * - switchMap forward_inner duplicate → operators.test.ts
- *
- * This file collects additional regression scenarios surfaced by cross-repo parity.
- */
-
-import { describe, expect, it } from "vitest";
-import { batch } from "../../core/batch.js";
-import { DATA, DIRTY, ERROR } from "../../core/messages.js";
-import { type NodeImpl, node } from "../../core/node.js";
-import { autoTrackNode } from "../../core/sugar.js";
-
-describe("regressions", () => {
-	// Spec: GRAPHREFLY-SPEC §1.2 — bare [DATA] without payload is a protocol violation.
-	it("bare [DATA] tuple (missing payload) is silently skipped", () => {
-		const source = node<number>({ initial: 0 });
-		const unsub = source.subscribe(() => undefined);
-		// Bare [DATA] should not crash or update the cached value.
-		source.down([[DATA] as unknown as [symbol, number]]);
-		expect(source.cache).toBe(0);
-		expect(source.status).toBe("settled"); // unchanged from initial
-		unsub();
-	});
-
-	// Spec: batch drain — AggregateError when multiple callbacks throw (parity with PY ExceptionGroup).
-	it("batch drain collects multiple errors into AggregateError", () => {
-		const a = node<number>({ initial: 0 });
-		const b = node<number>({ initial: 0 });
-		const errA = new Error("error-a");
-		const errB = new Error("error-b");
-		// Subscribers that only throw when non-initial DATA arrives (deferred during batch drain).
-		// Push-on-subscribe delivers the initial value (0), so we skip that.
-		a.subscribe((msgs) => {
-			if (msgs.some((m) => m[0] === DATA && (m[1] as number) > 0)) throw errA;
-		});
-		b.subscribe((msgs) => {
-			if (msgs.some((m) => m[0] === DATA && (m[1] as number) > 0)) throw errB;
-		});
-
-		let caught: unknown;
-		try {
-			batch(() => {
-				a.down([[DIRTY], [DATA, 1]]);
-				b.down([[DIRTY], [DATA, 2]]);
-			});
-		} catch (e) {
-			caught = e;
-		}
-
-		expect(caught).toBeInstanceOf(AggregateError);
-		const agg = caught as AggregateError;
-		expect(agg.errors).toHaveLength(2);
-		expect(agg.errors).toContain(errA);
-		expect(agg.errors).toContain(errB);
-	});
-
-	// Verify single error still throws unwrapped (backward compat).
-	it("batch drain with single callback error throws unwrapped", () => {
-		const a = node<number>({ initial: 0 });
-		const singleErr = new Error("single");
-		// Only throw on non-initial DATA to avoid throwing during push-on-subscribe.
-		a.subscribe((msgs) => {
-			if (msgs.some((m) => m[0] === DATA && (m[1] as number) > 0)) throw singleErr;
-		});
-
-		let caught: unknown;
-		try {
-			a.down([[DIRTY], [DATA, 1]]);
-		} catch (e) {
-			caught = e;
-		}
-
-		expect(caught).toBe(singleErr);
-	});
-
-	// ---------------------------------------------------------------------------
-	// subscribe() transactional rollback
-	// ---------------------------------------------------------------------------
-
-	// When a dep's subscribe() throws during _activate(), the calling node's
-	// subscription must be fully rolled back: sink removed, sinkCount correct,
-	// and all previously-subscribed deps unsubscribed. The node must be
-	// re-subscribable without counter drift.
-
-	it("subscribe rollback: _activate() dep-throw leaves node clean for re-subscribe", () => {
-		const a = node<number>([], { initial: 1 });
-		const b = node<number>([], { initial: 2 });
-		// combined depends on [a, b]. We patch b.subscribe to throw once,
-		// so _activate() succeeds on a then fails on b.
-		const combined = node(
-			[a, b],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as number) + (data[1] as number));
-			},
-			{ describeKind: "derived" },
-		);
-
-		const err = new Error("subscribe-denied");
-		const origB = (b as NodeImpl<number>).subscribe.bind(b);
-		let patchCallCount = 0;
-		(b as NodeImpl<number>).subscribe = (sink, actor) => {
-			if (patchCallCount++ === 0) throw err;
-			return origB(sink, actor);
-		};
-
-		// Subscribing to combined should throw (b.subscribe fails)
-		expect(() => combined.subscribe(() => {})).toThrow("subscribe-denied");
-
-		// Restore b
-		(b as NodeImpl<number>).subscribe = origB;
-
-		// combined's internal sinkCount must be 0 — no sink leaked
-		expect((combined as NodeImpl<number>)._sinkCount).toBe(0);
-		// a must have no subscribers (combined rolled back its subscription to a)
-		expect((a as NodeImpl<number>)._sinkCount).toBe(0);
-
-		// Re-subscribe must work and deliver the correct sum
-		const seen: number[] = [];
-		const unsub = combined.subscribe((msgs) => {
-			for (const [t, v] of msgs) if (t === DATA) seen.push(v as number);
-		});
-		expect(seen).toContain(3); // 1 + 2
-		unsub();
-	});
-
-	it("subscribe rollback: failed _activate() does not leave orphaned sinks on deps", () => {
-		// Three-dep chain: a, b, c. b.subscribe throws. After rollback:
-		// - a must have 0 sinks (was subscribed, then rolled back)
-		// - b must have 0 sinks (subscribe threw before sink registration)
-		// - c must have 0 sinks (never reached)
-		const a = node<number>([], { initial: 10 });
-		const b = node<number>([], { initial: 20 });
-		const c = node<number>([], { initial: 30 });
-		const combined = node(
-			[a, b, c],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as number) + (data[1] as number) + (data[2] as number));
-			},
-			{ describeKind: "derived" },
-		);
-
-		const origB = (b as NodeImpl<number>).subscribe.bind(b);
-		(b as NodeImpl<number>).subscribe = () => {
-			throw new Error("b-denied");
-		};
-
-		expect(() => combined.subscribe(() => {})).toThrow("b-denied");
-		(b as NodeImpl<number>).subscribe = origB;
-
-		expect((a as NodeImpl<number>)._sinkCount).toBe(0);
-		expect((b as NodeImpl<number>)._sinkCount).toBe(0);
-		expect((c as NodeImpl<number>)._sinkCount).toBe(0);
-		// combined is clean — subsequent subscribe works
-		const vals: number[] = [];
-		const unsub = combined.subscribe((msgs) => {
-			for (const [t, v] of msgs) if (t === DATA) vals.push(v as number);
-		});
-		expect(vals).toContain(60);
-		unsub();
-	});
-
-	it("_addDep rollback: subscribe-throws removes dep record and node recovers cleanly", () => {
-		// autoTrackNode discovers dep b during fn. b.subscribe throws on the
-		// FIRST internal _addDep call. The dep record must be removed from
-		// _deps and _dirtyDepCount must not be left inflated — otherwise the
-		// pending-rerun second pass (which retries _addDep(b) and succeeds)
-		// would drift the counter and hang the wave.
-		//
-		// Correct behavior: autoTrackNode treats the first failed discovery as
-		// a transient cache read (stores error in ctx.store, does NOT emit ERROR),
-		// retries on pendingRerun, succeeds on the second _addDep(b) call, and
-		// eventually emits the correct sum without any ERROR.
-		const a = node<number>([], { initial: 1 });
-		const b = node<number>([], { initial: 2 });
-
-		const origB = (b as NodeImpl<number>).subscribe.bind(b);
-		let addDepCallCount = 0;
-		(b as NodeImpl<number>).subscribe = (sink, actor) => {
-			// Throw only on the first internal subscribe from _addDep.
-			if (addDepCallCount++ === 0) throw new Error("b-transient-denied");
-			return origB(sink, actor);
-		};
-
-		const tracker = autoTrackNode((track) => {
-			const av = track(a) as number;
-			const bv = track(b) as number;
-			return av + bv;
-		});
-
-		const emitted: number[] = [];
-		const errors: unknown[] = [];
-		const unsub = tracker.subscribe((msgs) => {
-			for (const [t, v] of msgs) {
-				if (t === DATA) emitted.push(v as number);
-				if (t === ERROR) errors.push(v);
-			}
-		});
-
-		// No ERROR must be emitted — the failed first discovery was retried
-		expect(errors).toHaveLength(0);
-		// Tracker must have settled to the correct sum (1 + 2 = 3)
-		expect(emitted).toContain(3);
-		// b is properly subscribed after the second (successful) _addDep call
-		expect((b as NodeImpl<number>)._sinkCount).toBeGreaterThan(0);
-
-		unsub();
-		(b as NodeImpl<number>).subscribe = origB;
-	});
-
-	// ---------------------------------------------------------------------------
-	// Stale drainPhase2 liveness check (dep.unsub === null guard)
-	// ---------------------------------------------------------------------------
-
-	// When a node subscribes and immediately unsubscribes inside a batch, the
-	// handshake DATA is deferred into drainPhase2. After unsubscription,
-	// dep.unsub is null. The stale drainPhase2 closure must be silently
-	// dropped — it must NOT trigger the node's fn or cause any emissions.
-
-	it("stale drainPhase2 closure is silently dropped after unsubscription", () => {
-		const s = node<number>([], { initial: 1 });
-		const seen: number[] = [];
-		const derived1 = node(
-			[s],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as number) * 10);
-			},
-			{ describeKind: "derived" },
-		);
-
-		batch(() => {
-			// Subscribe to derived1 inside the batch. The handshake DATA(10) is
-			// deferred into drainPhase2 because we are inside a batch.
-			const unsub = derived1.subscribe((msgs) => {
-				for (const [t, v] of msgs) if (t === DATA) seen.push(v as number);
-			});
-			// Immediately unsubscribe — derived1 deactivates. dep.unsub is set
-			// to null by resetDepRecord. The stale drainPhase2 closure now has
-			// dep.unsub === null.
-			unsub();
-		});
-		// drainPhase2 ran after the batch. The stale closure must have been
-		// dropped — derived1.fn must not have run, no DATA emitted.
-		expect(seen).toEqual([]);
-		// derived1 has no subscribers now
-		expect((derived1 as NodeImpl<number>)._sinkCount).toBe(0);
-	});
-
-	it("stale closure dropped but re-subscription after batch works correctly", () => {
-		// After the stale-closure scenario, a fresh subscribe must produce the
-		// correct value — no counter drift from the dropped stale wave.
-		const s = node<number>([], { initial: 5 });
-		const doubled = node(
-			[s],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as number) * 2);
-			},
-			{ describeKind: "derived" },
-		);
-
-		batch(() => {
-			const unsub = doubled.subscribe(() => {});
-			unsub();
-		});
-
-		const seen: number[] = [];
-		const unsub2 = doubled.subscribe((msgs) => {
-			for (const [t, v] of msgs) if (t === DATA) seen.push(v as number);
-		});
-		expect(seen).toContain(10); // 5 * 2
-		unsub2();
-	});
-});
diff --git a/packages/pure-ts/src/__tests__/core/rewire-integration.test.ts b/packages/pure-ts/src/__tests__/core/rewire-integration.test.ts
deleted file mode 100644
index 343dee47..00000000
--- a/packages/pure-ts/src/__tests__/core/rewire-integration.test.ts
+++ /dev/null
@@ -1,1070 +0,0 @@
-/**
- * Phase 13.8 — exploratory integration tests for `_setDeps` / `_rewire`.
- *
- * Goal is gap-finding, NOT API validation. Every scenario corresponds to
- * an interaction surface the M1 Rust substrate impl can't exercise. Test
- * outcomes (pass/fail/surprise) feed into `docs/research/rewire-gap-findings.md`.
- *
- * Source: `docs/implementation-plan.md` §Phase 13.8 + design notes
- * `docs/research/rewire-design-notes.md`.
- */
-
-import { describe, expect, it } from "vitest";
-import { batch } from "../../core/batch.js";
-import { COMPLETE, DATA, DIRTY, INVALIDATE, PAUSE, RESUME, TEARDOWN } from "../../core/messages.js";
-import type { NodeFn, NodeImpl } from "../../core/node.js";
-import { node } from "../../core/node.js";
-
-// Test-only helper: the substrate `setDeps` requires `fn` at every call site
-// to enforce explicit fn-deps pairing (Phase 13.8 lock). Tests that don't
-// intend to swap fn pass `undefined` here and the helper retrieves the current
-// `_fn` from the node — pragmatic test ergonomics. Tests that DO swap fn pass
-// a fresh NodeFn.
-const setDeps = (n: unknown, deps: readonly unknown[], fn?: NodeFn): void => {
-	const impl = n as NodeImpl;
-	impl.setDeps(deps as Parameters<NodeImpl["setDeps"]>[0], fn ?? (impl._fn as NodeFn));
-};
-
-// Test-only no-op fn for guard-rejection paths where the fn argument never runs.
-const noopFn: NodeFn = () => {};
-
-describe("Phase 13.8 — _setDeps integration scenarios", () => {
-	// ─────────────────────────────────────────────────────────────────────
-	// Baseline: validate the substrate works on the simplest topology
-	// ─────────────────────────────────────────────────────────────────────
-
-	it("baseline: rewire from {A} to {B} swaps values; cache preserved through rewire window", () => {
-		const a = node<number>({ initial: 1 });
-		const b = node<number>({ initial: 2 });
-		const c = node([a], (data, actions, ctx) => {
-			const v = data[0]?.[0] ?? ctx.prevData[0];
-			actions.emit(((v as number) ?? 0) * 10);
-		});
-		const seen: unknown[] = [];
-		const unsub = c.subscribe((msgs) => {
-			for (const m of msgs) if (m[0] === DATA) seen.push(m[1]);
-		});
-
-		// Initial wave: c sees a=1 → 10
-		expect(c.cache).toBe(10);
-
-		// Rewire to b. c.cache is preserved ACROSS rewire window per Q7;
-		// resubscribe handshake delivers [[START], [DATA, 2]] → fires fn → 20.
-		setDeps(c, [b]);
-		expect(c.cache).toBe(20);
-		expect(seen).toEqual([10, 20]);
-		unsub();
-	});
-
-	it("rejects self-rewire with a clear error", () => {
-		const a = node<number>({ initial: 1 });
-		const c = node([a], (data, actions) => {
-			actions.emit((data[0]?.[0] as number) ?? 0);
-		});
-		c.subscribe(() => {});
-		expect(() => setDeps(c, [c])).toThrowError(/self-dependency/);
-	});
-
-	it("rejects cycle introduction via DFS through transitive _deps", () => {
-		const a = node<number>({ initial: 1 });
-		const b = node([a], (data, actions, ctx) => {
-			const v = data[0]?.[0] ?? ctx.prevData[0];
-			actions.emit(((v as number) ?? 0) + 1);
-		});
-		const c = node([b], (data, actions, ctx) => {
-			const v = data[0]?.[0] ?? ctx.prevData[0];
-			actions.emit(((v as number) ?? 0) * 2);
-		});
-		c.subscribe(() => {});
-		// b→a, c→b, so b transitively depends on a. Trying to make a depend on
-		// c would close cycle a→c→b→a.
-		expect(() => setDeps(a, [c])).toThrowError(/would create cycle/);
-	});
-
-	it("idempotent: rewire to identical dep set is a no-op (kept deps untouched, fn does not re-fire)", () => {
-		const a = node<number>({ initial: 1 });
-		const c = node([a], (data, actions, ctx) => {
-			const v = data[0]?.[0] ?? ctx.prevData[0];
-			actions.emit(((v as number) ?? 0) * 10);
-		});
-		const seen: unknown[] = [];
-		c.subscribe((msgs) => {
-			for (const m of msgs) if (m[0] === DATA) seen.push(m[1]);
-		});
-		expect(c.cache).toBe(10);
-
-		// Surgical lock: same dep set → no removed/added → kept dep `a` is
-		// untouched. No resubscribe, no push-on-subscribe replay, no fn
-		// re-fire. Cache preserved. The only initial DATA seen is from
-		// activation; nothing further.
-		setDeps(c, [a]);
-		expect(c.cache).toBe(10);
-		expect(seen).toEqual([10]);
-	});
-
-	// ─────────────────────────────────────────────────────────────────────
-	// Scenario 1 — rewire mid-batch
-	// ─────────────────────────────────────────────────────────────────────
-
-	it("scenario 1: rewire inside batch — topology change consistent with batched downstream emits", () => {
-		const a = node<number>({ initial: 1 });
-		const b = node<number>({ initial: 100 });
-		const c = node([a], (data, actions, ctx) => {
-			const v = data[0]?.[0] ?? ctx.prevData[0];
-			actions.emit((v as number) ?? 0);
-		});
-		const seen: unknown[] = [];
-		c.subscribe((msgs) => {
-			for (const m of msgs) if (m[0] === DATA) seen.push(m[1]);
-		});
-		expect(c.cache).toBe(1);
-
-		batch(() => {
-			a.down([[DATA, 2]]);
-			// rewire mid-batch — c switches from {a} to {b}.
-			setDeps(c, [b]);
-		});
-
-		// Final state: c is now wired to b=100. The mid-batch a=2 emit went
-		// into c's old DepRecord which got discarded by rewire.
-		expect(c.cache).toBe(100);
-		expect(seen.at(-1)).toBe(100);
-	});
-
-	// ─────────────────────────────────────────────────────────────────────
-	// Scenario 2 — rewire × INVALIDATE same wave
-	// ─────────────────────────────────────────────────────────────────────
-
-	it("scenario 2: INVALIDATE then rewire — INVALIDATE clears cache, rewire to fresh dep populates", () => {
-		const a = node<number>({ initial: 5 });
-		const b = node<number>({ initial: 50 });
-		const c = node([a], (data, actions, ctx) => {
-			const v = data[0]?.[0] ?? ctx.prevData[0];
-			actions.emit((v as number) * 2);
-		});
-		const seen: { tag: symbol; value?: unknown }[] = [];
-		c.subscribe((msgs) => {
-			for (const m of msgs) seen.push({ tag: m[0] as symbol, value: m[1] });
-		});
-		expect(c.cache).toBe(10);
-
-		// INVALIDATE c via dep — clears c._cached.
-		a.down([[INVALIDATE]]);
-		expect(c.cache).toBeUndefined();
-
-		// Rewire to b. Cache was cleared by INVALIDATE; resubscribe handshake
-		// delivers b=50 → fn → 100. End state: cache populated, no stale
-		// INVALIDATE artifact.
-		setDeps(c, [b]);
-		expect(c.cache).toBe(100);
-
-		// INVALIDATE was visible in stream; final DATA is post-rewire 100.
-		const tags = seen.map((e) => e.tag);
-		expect(tags).toContain(INVALIDATE);
-		expect(seen.findLast((e) => e.tag === DATA)?.value).toBe(100);
-	});
-
-	// ─────────────────────────────────────────────────────────────────────
-	// Scenario 3 — rewire while paused
-	// ─────────────────────────────────────────────────────────────────────
-
-	it("scenario 3: rewire while paused — pause locks preserved; RESUME drains correctly post-rewire", () => {
-		const a = node<number>({ initial: 1 });
-		const b = node<number>({ initial: 99 });
-		const c = node(
-			[a],
-			(data, actions, ctx) => {
-				const v = data[0]?.[0] ?? ctx.prevData[0];
-				actions.emit((v as number) * 10);
-			},
-			{ pausable: "resumeAll" },
-		);
-		const seen: { tag: symbol; value?: unknown }[] = [];
-		c.subscribe((msgs) => {
-			for (const m of msgs) seen.push({ tag: m[0] as symbol, value: m[1] });
-		});
-		expect(c.cache).toBe(10);
-
-		const lockId = Symbol("L");
-		c.down([[PAUSE, lockId]]);
-
-		// Rewire while paused — pause lockset preserved per Q3.
-		setDeps(c, [b]);
-
-		// Still paused — even though we connected a new dep, c shouldn't
-		// fire fn while paused (resumeAll buffers settle-tier emissions).
-		// Cache was preserved through rewire (Q7); fn re-fires after
-		// resubscribe but its emit is buffered.
-		expect((c as unknown as NodeImpl)._paused).toBe(true);
-
-		c.down([[RESUME, lockId]]);
-		expect((c as unknown as NodeImpl)._paused).toBe(false);
-
-		// After RESUME the buffered post-rewire wave drained. b=99 → fn → 990.
-		expect(c.cache).toBe(990);
-		expect(seen.findLast((e) => e.tag === DATA)?.value).toBe(990);
-	});
-
-	// ─────────────────────────────────────────────────────────────────────
-	// Scenario 4 — rewire × TEARDOWN cascade
-	// ─────────────────────────────────────────────────────────────────────
-
-	it("scenario 4: rewire on terminal node REJECTED with clear error", () => {
-		const a = node<number>({ initial: 1 });
-		const b = node<number>({ initial: 2 });
-		const c = node([a], (data, actions, ctx) => {
-			const v = data[0]?.[0] ?? ctx.prevData[0];
-			actions.emit((v as number) * 10);
-		});
-		c.subscribe(() => {});
-		c.down([[COMPLETE]]);
-		expect(c.status).toBe("completed");
-		expect(() => setDeps(c, [b])).toThrowError(/terminal state/);
-	});
-
-	it("scenario 4b: TEARDOWN on a removed-dep does NOT cascade to rewired node", () => {
-		const a = node<number>({ initial: 1 });
-		const b = node<number>({ initial: 2 });
-		const c = node([a], (data, actions, ctx) => {
-			const v = data[0]?.[0] ?? ctx.prevData[0];
-			actions.emit((v as number) * 10);
-		});
-		c.subscribe(() => {});
-		expect(c.cache).toBe(10);
-
-		// Rewire c off of a, onto b.
-		setDeps(c, [b]);
-		expect(c.cache).toBe(20);
-
-		// TEARDOWN on a. After rewire a is no longer a dep of c, so this
-		// MUST NOT propagate to c.
-		a.down([[TEARDOWN]]);
-		expect(c.status).not.toBe("completed");
-		expect(c.cache).toBe(20);
-	});
-
-	// ─────────────────────────────────────────────────────────────────────
-	// Scenario 5 — rewire × non-empty replay buffer
-	// ─────────────────────────────────────────────────────────────────────
-
-	it("scenario 5: replay buffer on N is preserved across rewire", () => {
-		const a = node<number>({ initial: 1 });
-		const b = node<number>({ initial: 100 });
-		const c = node(
-			[a],
-			(data, actions, ctx) => {
-				const v = data[0]?.[0] ?? ctx.prevData[0];
-				actions.emit((v as number) * 10);
-			},
-			{ replayBuffer: 5 },
-		);
-		c.subscribe(() => {});
-		a.down([[DATA, 2]]);
-		a.down([[DATA, 3]]);
-		// Replay buffer of c should now contain its OUTGOING history: 10, 20, 30.
-		const cBuf = (c as unknown as NodeImpl)._replayBuffer;
-		expect(cBuf).toEqual([10, 20, 30]);
-
-		setDeps(c, [b]);
-		// After full disconnect/resubscribe, c re-fires off b=100 → 1000.
-		// Replay buffer preserved AND extended with the new emission.
-		const cBufAfter = (c as unknown as NodeImpl)._replayBuffer;
-		expect(cBufAfter?.at(-1)).toBe(1000);
-		expect((cBufAfter ?? []).slice(0, 3)).toEqual([10, 20, 30]);
-	});
-
-	// ─────────────────────────────────────────────────────────────────────
-	// Scenario 6 — rewire × meta companions
-	// ─────────────────────────────────────────────────────────────────────
-
-	it("scenario 6: rewire does not disturb meta companions on N", () => {
-		// `meta` builds child state nodes from initial values (per
-		// node.ts:933 `meta[k] = new NodeImpl([], undefined, { initial: v, ... })`).
-		// We capture the meta companion identity pre-rewire and assert it
-		// (a) survives rewire intact, (b) keeps its cached value, (c) stays
-		// reachable on the parent at the same key.
-		const a = node<number>({ initial: 1 });
-		const b = node<number>({ initial: 2 });
-		const c = node(
-			[a],
-			(data, actions, ctx) => {
-				const v = data[0]?.[0] ?? ctx.prevData[0];
-				actions.emit((v as number) * 10);
-			},
-			{ meta: { status: "alive" } },
-		);
-		c.subscribe(() => {});
-		const metaBefore = c.meta.status;
-		expect(metaBefore.cache).toBe("alive");
-
-		setDeps(c, [b]);
-
-		// Meta unaffected — rewire only touches `_deps`, not `meta`.
-		expect(c.meta.status).toBe(metaBefore);
-		expect(c.meta.status.cache).toBe("alive");
-		expect(c.cache).toBe(20);
-	});
-
-	// ─────────────────────────────────────────────────────────────────────
-	// Scenario 7 — rewire × dep COMPLETE/ERROR
-	// ─────────────────────────────────────────────────────────────────────
-
-	it("scenario 7: rewire AWAY from a COMPLETED dep — N stays live, no auto-complete cascade", () => {
-		const a = node<number>({ initial: 1 });
-		const b = node<number>({ initial: 2 });
-		const c = node([a], (data, actions, ctx) => {
-			const v = data[0]?.[0] ?? ctx.prevData[0];
-			actions.emit((v as number) * 10);
-		});
-		c.subscribe(() => {});
-		expect(c.cache).toBe(10);
-
-		// COMPLETE a — but c hasn't received it yet because we'll rewire first.
-		// Actually the emit is synchronous, so we need to be careful here.
-		// Pre-rewire emit COMPLETE on a — c receives it, dep.terminal set,
-		// auto-complete fires because c has only one dep and it's done.
-		// To test "rewire AWAY from completed dep doesn't propagate" we need
-		// the dep to complete BEFORE c subscribes to it... which doesn't apply
-		// here since c was already subscribed.
-		//
-		// Instead: rewire c to b, THEN complete a (the now-removed dep).
-		setDeps(c, [b]);
-		a.down([[COMPLETE]]);
-		expect(c.status).not.toBe("completed");
-		expect(c.cache).toBe(20);
-	});
-
-	it("scenario 7b: rewire TO a terminal non-resubscribable dep — REJECTED (Q1 lock 2026-05-04)", () => {
-		const aTerm = node<number>({ initial: 1 });
-		aTerm.subscribe(() => {});
-		aTerm.down([[COMPLETE]]);
-		expect(aTerm.status).toBe("completed");
-
-		const live = node<number>({ initial: 5 });
-		const c = node([live], (data, actions, ctx) => {
-			const v = data[0]?.[0] ?? ctx.prevData[0];
-			actions.emit((v as number) * 10);
-		});
-		c.subscribe(() => {});
-		expect(c.cache).toBe(50);
-
-		// Phase 13.8 Q1 lock: substrate rejects this with a clear error
-		// instead of silently producing a wedge state.
-		expect(() => setDeps(c, [aTerm])).toThrowError(/non-resubscribable terminal dep/);
-
-		// c's prior wiring is intact — failed _setDeps did not mutate state.
-		expect(c.cache).toBe(50);
-	});
-
-	it("scenario 7c: rewire TO a resubscribable terminal dep — ALLOWED, dep resets via subscribe handshake", () => {
-		// A resubscribable terminal dep can be added: subscribe() triggers
-		// `_resetForFreshLifecycle` on it, putting it in a clean sentinel
-		// state for the new edge.
-		const aTerm = node<number>({ initial: 1, resubscribable: true });
-		aTerm.subscribe(() => {});
-		aTerm.down([[COMPLETE]]);
-		expect(aTerm.status).toBe("completed");
-
-		const c = node<number>(
-			[],
-			(data, actions, ctx) => {
-				const v = data[0]?.[0] ?? ctx.prevData[0];
-				actions.emit(((v as number) ?? 0) * 10);
-			},
-			{ describeKind: "derived" },
-		);
-		c.subscribe(() => {});
-
-		// Adding aTerm via _setDeps should NOT throw — it's resubscribable.
-		expect(() => setDeps(c, [aTerm])).not.toThrow();
-		// After rewire, aTerm has been re-armed via subscribe →
-		// `_resetForFreshLifecycle` (clears cache, sets status to sentinel),
-		// then subscribe's "activated but no value yet" reflector transitions
-		// status to "pending" (the live re-armed lifecycle).
-		expect(aTerm.status).toBe("pending");
-		// aTerm now needs a fresh emission to drive c.
-		aTerm.down([[DATA, 7]]);
-		expect(c.cache).toBe(70);
-	});
-
-	// ─────────────────────────────────────────────────────────────────────
-	// Scenario 8 — rewire × resubscribable terminal-reset in flight
-	// ─────────────────────────────────────────────────────────────────────
-
-	it("scenario 8: resubscribable node post-COMPLETE then INVALIDATE-reset then rewire — clean re-arm", () => {
-		const a = node<number>({ initial: 1 });
-		const b = node<number>({ initial: 100 });
-		const c = node(
-			[a],
-			(data, actions, ctx) => {
-				const v = data[0]?.[0] ?? ctx.prevData[0];
-				actions.emit((v as number) * 10);
-			},
-			{ resubscribable: true },
-		);
-		c.subscribe(() => {});
-		expect(c.cache).toBe(10);
-
-		// Drive c into completed via dep COMPLETE → c auto-completes.
-		a.down([[COMPLETE]]);
-		expect(c.status).toBe("completed");
-		// On a resubscribable node, INVALIDATE triggers _resetForFreshLifecycle.
-		c.down([[INVALIDATE]]);
-		// After reset, status returns to sentinel; dep records reset; cache cleared.
-		expect(c.status).toBe("sentinel");
-
-		// Now rewire to b. Substrate path: full disconnect of (resetted) old
-		// deps, fresh resubscribe to b. This exercises the post-reset
-		// resubscribe path.
-		setDeps(c, [b]);
-		// b is live → fn fires → c.cache = 1000.
-		expect(c.cache).toBe(1000);
-	});
-
-	// ─────────────────────────────────────────────────────────────────────
-	// Scenario 9 — covered by the graph-layer rewire-mock-harness test;
-	// _setDeps substrate is graph-agnostic. See rewire-mock-harness.test.ts.
-	// ─────────────────────────────────────────────────────────────────────
-
-	// ─────────────────────────────────────────────────────────────────────
-	// Extra exploratory cases — surfaced from full-disconnect/resubscribe
-	// ─────────────────────────────────────────────────────────────────────
-
-	it("rewire on inactive node (no subscribers) just swaps _deps without resubscribing", () => {
-		const a = node<number>({ initial: 1 });
-		const b = node<number>({ initial: 2 });
-		const c = node([a], (data, actions, ctx) => {
-			const v = data[0]?.[0] ?? ctx.prevData[0];
-			actions.emit((v as number) * 10);
-		});
-		// No subscribe → c is inactive.
-		expect((c as unknown as NodeImpl)._sinks).toBeNull();
-
-		setDeps(c, [b]);
-		const deps = (c as unknown as NodeImpl)._deps.map((d) => d.node);
-		expect(deps).toEqual([b]);
-		// No subscription was wired (deferred to _activate).
-		expect((c as unknown as NodeImpl)._deps[0].unsub).toBeNull();
-	});
-
-	it("rewire to empty deps {} leaves N as a degenerate fn-with-no-deps shape; cache preserved", () => {
-		const a = node<number>({ initial: 7 });
-		const c = node([a], (data, actions, ctx) => {
-			const v = data[0]?.[0] ?? ctx.prevData[0];
-			actions.emit((v as number) * 10);
-		});
-		c.subscribe(() => {});
-		expect(c.cache).toBe(70);
-
-		setDeps(c, []);
-		// No deps → _activate's empty-deps branch fires fn ONCE if a producer.
-		// But c is a derived (has fn AND had deps); _setDeps doesn't re-run
-		// _activate's empty-deps branch. Cache preserved per Q7; fn does
-		// not re-fire because no dep delivers DATA. This is consistent with
-		// design notes: "M1 should treat this as a degenerate state, not
-		// auto-deactivate."
-		expect(c.cache).toBe(70);
-		expect((c as unknown as NodeImpl)._deps).toEqual([]);
-	});
-
-	it("rewire dedupes new dep set by reference identity", () => {
-		const a = node<number>({ initial: 1 });
-		const c = node<number>([a], (data, actions, ctx) => {
-			const v = data[0]?.[0] ?? ctx.prevData[0];
-			actions.emit((v as number) * 10);
-		});
-		c.subscribe(() => {});
-		setDeps(c, [a, a, a]);
-		expect((c as unknown as NodeImpl)._deps.length).toBe(1);
-		expect(c.cache).toBe(10);
-	});
-
-	it("rewire preserves _hasCalledFnOnce — first-run gate not re-armed (Q2)", () => {
-		const a = node<number>({ initial: 1 });
-		const b = node<number>({ initial: 2 });
-		const c = node([a], (data, actions, ctx) => {
-			const v = data[0]?.[0] ?? ctx.prevData[0];
-			actions.emit((v as number) * 10);
-		});
-		c.subscribe(() => {});
-		expect((c as unknown as NodeImpl)._hasCalledFnOnce).toBe(true);
-
-		setDeps(c, [b]);
-		// The flag stays true across rewire: if it were reset, the first-run
-		// gate would re-engage and (with full disconnect) the new dep would
-		// have to re-deliver before fn could fire. But push-on-subscribe
-		// from b={initial:2} satisfies the gate immediately so this is
-		// behaviorally indistinguishable in this specific topology — the
-		// invariant is that the flag stays true.
-		expect((c as unknown as NodeImpl)._hasCalledFnOnce).toBe(true);
-		expect(c.cache).toBe(20);
-	});
-
-	// ─────────────────────────────────────────────────────────────────────
-	// Surgical-mode-specific invariants
-	// ─────────────────────────────────────────────────────────────────────
-
-	it("surgical: kept dep's DepRecord state (prevData, dataBatch) carries through verbatim", () => {
-		const a = node<number>({ initial: 7 });
-		const b = node<number>({ initial: 100 });
-		const c = node([a], (data, actions, ctx) => {
-			const v = data[0]?.[0] ?? ctx.prevData[0];
-			actions.emit((v as number) * 10);
-		});
-		c.subscribe(() => {});
-		expect(c.cache).toBe(70);
-
-		// Snapshot the kept dep's DepRecord BEFORE rewire.
-		const beforeRec = (c as unknown as NodeImpl)._deps[0];
-		const beforeUnsub = beforeRec.unsub;
-		const beforePrevData = beforeRec.prevData;
-
-		// Append b — kept dep is `a` at index 0, added is `b` at index 1.
-		setDeps(c, [a, b]);
-
-		// Same DepRecord object identity — proves we did NOT recreate it.
-		const afterRec = (c as unknown as NodeImpl)._deps[0];
-		expect(afterRec).toBe(beforeRec);
-		// Unsub function is the same — subscription was not re-issued.
-		expect(afterRec.unsub).toBe(beforeUnsub);
-		// prevData is the same value (untouched).
-		expect(afterRec.prevData).toBe(beforePrevData);
-	});
-
-	it("surgical: kept dep does NOT see an unsub-then-resub on its sinks", () => {
-		// We can't directly observe the dep's sinks set, but we can prove
-		// no resubscribe happened by counting fn fires. With surgical mode,
-		// adding a new dep to N should NOT cause N's fn to re-fire from
-		// kept deps — it only fires when the NEW dep settles.
-		const a = node<number>({ initial: 5 });
-		const b = node<number>({ initial: 10 });
-		let fnFireCount = 0;
-		const c = node([a], (data, actions, ctx) => {
-			fnFireCount++;
-			const av = data[0]?.[0] ?? ctx.prevData[0];
-			const bv = data[1]?.[0] ?? ctx.prevData[1];
-			actions.emit(((av as number) ?? 0) + ((bv as number) ?? 0));
-		});
-		c.subscribe(() => {});
-		expect(fnFireCount).toBe(1); // initial wave fired once
-		expect(c.cache).toBe(5);
-
-		// Append b. Surgical: a is untouched. fn fires ONCE more for the
-		// added dep b's settlement. (Full-disconnect would have caused 2
-		// fires — once on each kept-dep handshake replay.)
-		setDeps(c, [a, b]);
-		expect(fnFireCount).toBe(2);
-		expect(c.cache).toBe(15);
-	});
-
-	it("surgical: tail-removal preserves remaining kept deps' DepRecord identity", () => {
-		const a = node<number>({ initial: 3 });
-		const b = node<number>({ initial: 4 });
-		const c = node([a, b], (data, actions, ctx) => {
-			const av = data[0]?.[0] ?? ctx.prevData[0];
-			const bv = data[1]?.[0] ?? ctx.prevData[1];
-			actions.emit(((av as number) ?? 0) * ((bv as number) ?? 0));
-		});
-		c.subscribe(() => {});
-		expect(c.cache).toBe(12);
-
-		const beforeRecA = (c as unknown as NodeImpl)._deps[0];
-		// Tail-remove: drop `b`. `a` stays at index 0.
-		setDeps(c, [a]);
-		const afterRecA = (c as unknown as NodeImpl)._deps[0];
-		expect(afterRecA).toBe(beforeRecA);
-		expect((c as unknown as NodeImpl)._deps).toHaveLength(1);
-		// fn fires (or doesn't) per the auto-settle path — test that node is alive.
-		expect(c.status).not.toBe("completed");
-	});
-
-	// ─────────────────────────────────────────────────────────────────────
-	// Reorder + interior-remove (Option C: DepRecord-ref-keyed dispatch)
-	// ─────────────────────────────────────────────────────────────────────
-	//
-	// Subscription callbacks bind to the DepRecord reference; index is
-	// looked up dynamically via `_deps.indexOf(record)` at dispatch time.
-	// Kept deps may shift position freely without re-subscribing.
-
-	it("reorder: swap [a, b] → [b, a] preserves both DepRecords; kept deps don't re-subscribe", () => {
-		const a = node<number>({ initial: 1 });
-		const b = node<number>({ initial: 2 });
-		const c = node([a, b], (data, actions, ctx) => {
-			const av = data[0]?.[0] ?? ctx.prevData[0];
-			const bv = data[1]?.[0] ?? ctx.prevData[1];
-			actions.emit(((av as number) ?? 0) * 100 + ((bv as number) ?? 0));
-		});
-		c.subscribe(() => {});
-		// Initial wave: a=1 (idx 0), b=2 (idx 1) → 1*100+2 = 102
-		expect(c.cache).toBe(102);
-
-		const beforeRecA = (c as unknown as NodeImpl)._deps[0];
-		const beforeRecB = (c as unknown as NodeImpl)._deps[1];
-		const beforeUnsubA = beforeRecA.unsub;
-		const beforeUnsubB = beforeRecB.unsub;
-
-		// Swap: now b is at idx 0, a is at idx 1.
-		setDeps(c, [b, a]);
-
-		// Same DepRecord objects (kept deps preserved).
-		const afterRecB = (c as unknown as NodeImpl)._deps[0];
-		const afterRecA = (c as unknown as NodeImpl)._deps[1];
-		expect(afterRecB).toBe(beforeRecB);
-		expect(afterRecA).toBe(beforeRecA);
-		// Subscriptions unchanged (no resub).
-		expect(afterRecB.unsub).toBe(beforeUnsubB);
-		expect(afterRecA.unsub).toBe(beforeUnsubA);
-
-		// Now drive a new value through `a` — fn should see a at idx 1
-		// (per the new ordering), not idx 0.
-		a.down([[DATA, 5]]);
-		// fn: data[0]=b's batch (no new data this wave) prevData[0]=2; data[1]=a's batch [5].
-		// Result: 2*100 + 5 = 205.
-		expect(c.cache).toBe(205);
-	});
-
-	it("interior-remove: [a, b, cdep] → [a, cdep] preserves cdep's DepRecord", () => {
-		const a = node<number>({ initial: 1 });
-		const b = node<number>({ initial: 2 });
-		const cdep = node<number>({ initial: 3 });
-		const sink = node([a, b, cdep], (data, actions, ctx) => {
-			const av = data[0]?.[0] ?? ctx.prevData[0];
-			const bv = data[1]?.[0] ?? ctx.prevData[1];
-			const cv = data[2]?.[0] ?? ctx.prevData[2];
-			actions.emit(((av as number) ?? 0) + ((bv as number) ?? 0) + ((cv as number) ?? 0));
-		});
-		sink.subscribe(() => {});
-		expect(sink.cache).toBe(6);
-
-		const beforeRecCdep = (sink as unknown as NodeImpl)._deps[2];
-		const beforeUnsubCdep = beforeRecCdep.unsub;
-
-		// Drop b. Kept cdep shifts from idx 2 to idx 1.
-		setDeps(sink, [a, cdep]);
-
-		// cdep's DepRecord identity preserved across the shift.
-		const afterRecCdep = (sink as unknown as NodeImpl)._deps[1];
-		expect(afterRecCdep).toBe(beforeRecCdep);
-		expect(afterRecCdep.unsub).toBe(beforeUnsubCdep);
-
-		// Drive new DATA through cdep — fn sees it at the new index 1.
-		cdep.down([[DATA, 10]]);
-		// fn: data[0]=a's batch (none) prevData[0]=1; data[1]=cdep's batch [10] → 1+10=11.
-		expect(sink.cache).toBe(11);
-	});
-
-	it("two-step rebuild also works for callers who prefer explicit clear-then-rebuild", () => {
-		const a = node<number>({ initial: 1 });
-		const b = node<number>({ initial: 2 });
-		const c = node([a, b], (data, actions, ctx) => {
-			const av = data[0]?.[0] ?? ctx.prevData[0];
-			const bv = data[1]?.[0] ?? ctx.prevData[1];
-			actions.emit(((av as number) ?? 0) + ((bv as number) ?? 0));
-		});
-		c.subscribe(() => {});
-		expect(c.cache).toBe(3);
-
-		// Step 1: clear all deps (cache preserved per Q7).
-		setDeps(c, []);
-		expect(c.cache).toBe(3);
-
-		// Step 2: rebuild in different order. Both are "added" — fresh DepRecords.
-		setDeps(c, [b, a]);
-		expect((c as unknown as NodeImpl)._deps[0].node).toBe(b);
-		expect((c as unknown as NodeImpl)._deps[1].node).toBe(a);
-	});
-
-	// ─────────────────────────────────────────────────────────────────────
-	// opts.fn — fn replacement at rewire time
-	// ─────────────────────────────────────────────────────────────────────
-
-	it("opts.fn: rewire with new fn that handles the new dep shape", () => {
-		const a = node<number>({ initial: 1 });
-		const b = node<number>({ initial: 2 });
-		const c = node([a, b], (data, actions, ctx) => {
-			const av = data[0]?.[0] ?? ctx.prevData[0];
-			const bv = data[1]?.[0] ?? ctx.prevData[1];
-			actions.emit(((av as number) ?? 0) * 10 + ((bv as number) ?? 0));
-		});
-		c.subscribe(() => {});
-		// Initial: a*10 + b = 12
-		expect(c.cache).toBe(12);
-
-		// Swap order [a, b] → [b, a] AND swap fn so user-visible computation
-		// stays a*10 + b (now reading from new positions).
-		(c as unknown as NodeImpl).setDeps([b, a], (data, actions, ctx) => {
-			const bv = data[0]?.[0] ?? ctx.prevData[0];
-			const av = data[1]?.[0] ?? ctx.prevData[1];
-			actions.emit(((av as number) ?? 0) * 10 + ((bv as number) ?? 0));
-		});
-
-		// Drive a fresh wave through `a` (now at index 1).
-		a.down([[DATA, 5]]);
-		// New fn: a*10 + b = 5*10 + 2 = 52
-		expect(c.cache).toBe(52);
-	});
-
-	it("opts.fn: pure fn swap — same dep set, new fn", () => {
-		const a = node<number>({ initial: 7 });
-		const c = node([a], (data, actions, ctx) => {
-			const v = data[0]?.[0] ?? ctx.prevData[0];
-			actions.emit((v as number) * 10);
-		});
-		c.subscribe(() => {});
-		expect(c.cache).toBe(70);
-
-		// Swap fn only; dep set unchanged. Cache preserved per Q7.
-		(c as unknown as NodeImpl).setDeps([a], (data, actions, ctx) => {
-			const v = data[0]?.[0] ?? ctx.prevData[0];
-			actions.emit((v as number) + 100);
-		});
-
-		// Trigger a fresh wave through `a`. New fn runs.
-		a.down([[DATA, 5]]);
-		expect(c.cache).toBe(105); // 5 + 100, not 5 * 10
-	});
-
-	it("opts.fn: old cleanup's onRerun fires once when fn is swapped, before new fn runs", () => {
-		const a = node<number>({ initial: 1 });
-		let oldRerunFired = 0;
-		let newRerunFired = 0;
-		const c = node([a], (data, actions, ctx) => {
-			const v = data[0]?.[0] ?? ctx.prevData[0];
-			actions.emit((v as number) * 2);
-			return { onRerun: () => oldRerunFired++ };
-		});
-		c.subscribe(() => {});
-		expect(c.cache).toBe(2);
-		// Initial run: onRerun was set but hasn't fired yet (first run, no prior).
-		expect(oldRerunFired).toBe(0);
-
-		(c as unknown as NodeImpl).setDeps([a], (data, actions, ctx) => {
-			const v = data[0]?.[0] ?? ctx.prevData[0];
-			actions.emit((v as number) + 1000);
-			return { onRerun: () => newRerunFired++ };
-		});
-
-		// Drive a fresh wave. Should fire OLD onRerun (clean wrap-up of last
-		// old-fn run), then run new fn (which sets new cleanup).
-		a.down([[DATA, 5]]);
-		expect(oldRerunFired).toBe(1);
-		expect(newRerunFired).toBe(0); // new onRerun wasn't fired (it's the LATEST cleanup, fires next time)
-		expect(c.cache).toBe(1005);
-
-		// Drive another wave — now NEW fn's onRerun fires.
-		a.down([[DATA, 6]]);
-		expect(oldRerunFired).toBe(1); // didn't fire again
-		expect(newRerunFired).toBe(1);
-		expect(c.cache).toBe(1006);
-	});
-
-	it("opts.fn: _addDep with new fn — appended slot consumed by replacement fn", () => {
-		const a = node<number>({ initial: 1 });
-		const b = node<number>({ initial: 100 });
-		const c = node([a], (data, actions, ctx) => {
-			const v = data[0]?.[0] ?? ctx.prevData[0];
-			actions.emit((v as number) * 10);
-		});
-		c.subscribe(() => {});
-		expect(c.cache).toBe(10);
-
-		// Append b AND swap fn to consume both deps.
-		(c as unknown as NodeImpl).addDep(b, (data, actions, ctx) => {
-			const av = data[0]?.[0] ?? ctx.prevData[0];
-			const bv = data[1]?.[0] ?? ctx.prevData[1];
-			actions.emit(((av as number) ?? 0) + ((bv as number) ?? 0));
-		});
-
-		// New fn fires once b's handshake delivers — a + b = 1 + 100 = 101.
-		expect(c.cache).toBe(101);
-	});
-
-	// ─────────────────────────────────────────────────────────────────────
-	// _addDep guards (Phase 13.8 QA — symmetric with _setDeps)
-	// ─────────────────────────────────────────────────────────────────────
-
-	it("_addDep rejects non-resubscribable terminal dep (Q1)", () => {
-		const aTerm = node<number>({ initial: 1 });
-		aTerm.subscribe(() => {});
-		aTerm.down([[COMPLETE]]);
-		expect(aTerm.status).toBe("completed");
-
-		const c = node<number>({ initial: 5 });
-		c.subscribe(() => {});
-
-		expect(() => (c as unknown as NodeImpl).addDep(aTerm, noopFn)).toThrowError(
-			/non-resubscribable terminal dep/,
-		);
-	});
-
-	it("_addDep allows resubscribable terminal dep (re-arms via subscribe handshake)", () => {
-		const aTerm = node<number>({ initial: 1, resubscribable: true });
-		aTerm.subscribe(() => {});
-		aTerm.down([[COMPLETE]]);
-		expect(aTerm.status).toBe("completed");
-
-		const c = node<number>(
-			[],
-			(data, actions, ctx) => {
-				const v = data[0]?.[0] ?? ctx.prevData[0];
-				actions.emit(((v as number) ?? 0) * 10);
-			},
-			{ describeKind: "derived" },
-		);
-		c.subscribe(() => {});
-
-		// Same fn — still required at API; this is a fn-preservation rewire.
-		const cFn = (c as unknown as NodeImpl)._fn as NodeFn;
-		expect(() => (c as unknown as NodeImpl).addDep(aTerm, cFn)).not.toThrow();
-		expect(aTerm.status).toBe("pending");
-	});
-
-	it("_addDep rejects on terminal `this`", () => {
-		const a = node<number>({ initial: 1 });
-		const b = node<number>({ initial: 2 });
-		const c = node([a], (data, actions, ctx) => {
-			const v = data[0]?.[0] ?? ctx.prevData[0];
-			actions.emit((v as number) * 10);
-		});
-		c.subscribe(() => {});
-		c.down([[COMPLETE]]);
-		expect(c.status).toBe("completed");
-
-		expect(() => (c as unknown as NodeImpl).addDep(b, noopFn)).toThrowError(/terminal state/);
-	});
-
-	it("_addDep rejects self-dependency", () => {
-		const a = node<number>({ initial: 1 });
-		const c = node([a], (data, actions, ctx) => {
-			const v = data[0]?.[0] ?? ctx.prevData[0];
-			actions.emit((v as number) * 10);
-		});
-		c.subscribe(() => {});
-
-		expect(() => (c as unknown as NodeImpl).addDep(c, noopFn)).toThrowError(/self-dependency/);
-	});
-
-	it("_addDep rejects cycle introduction", () => {
-		const a = node<number>({ initial: 1 });
-		const b = node([a], (data, actions, ctx) => {
-			const v = data[0]?.[0] ?? ctx.prevData[0];
-			actions.emit(((v as number) ?? 0) + 1);
-		});
-		b.subscribe(() => {});
-		// Try to make `a` depend on `b` — would close cycle a→b→a.
-		expect(() => (a as unknown as NodeImpl).addDep(b, noopFn)).toThrowError(/would create cycle/);
-	});
-
-	it("_addDep rejects mid-fn (with autoTrackNode escape hatch via _addDepInternal)", () => {
-		const a = node<number>({ initial: 1 });
-		const b = node<number>({ initial: 2 });
-		const c = node([a], (data, actions, ctx) => {
-			const v = data[0]?.[0] ?? ctx.prevData[0];
-			actions.emit((v as number) * 10);
-			// Try to mutate deps mid-fn — public _addDep should reject.
-			try {
-				(c as unknown as NodeImpl).addDep(b, noopFn);
-			} catch (err) {
-				ctx.store.midFnAddDepError = (err as Error).message;
-			}
-		});
-		c.subscribe(() => {});
-		// fn ran, error captured.
-		expect((c as unknown as NodeImpl)._store.midFnAddDepError).toMatch(/mid-fn/);
-	});
-
-	// ─────────────────────────────────────────────────────────────────────
-	// Reentrancy guard (Phase 13.8 QA C — _inDepMutation)
-	// ─────────────────────────────────────────────────────────────────────
-
-	it("reentrancy: _setDeps re-entry from a DIRTY subscriber callback rejects with clear error", () => {
-		// Construct a subscriber that fires _setDeps on DIRTY (which arrives
-		// during _setDeps's emit-DIRTY phase, BEFORE _isExecutingFn is set).
-		// This isolates the `_inDepMutation` guard from the `_isExecutingFn`
-		// guard.
-		const a = node<number>({ initial: 1 });
-		const b = node<number>({ initial: 2 });
-		const c = node([a], (data, actions, ctx) => {
-			const v = data[0]?.[0] ?? ctx.prevData[0];
-			actions.emit((v as number) * 10);
-		});
-
-		let reentrantError: string | undefined;
-		c.subscribe((msgs) => {
-			if (reentrantError) return; // capture first only
-			for (const m of msgs) {
-				if (m[0] === DIRTY) {
-					try {
-						(c as unknown as NodeImpl).setDeps([b], noopFn);
-					} catch (err) {
-						reentrantError = (err as Error).message;
-						return;
-					}
-				}
-			}
-		});
-
-		// Trigger a fresh DIRTY wave on c by emitting DATA on a. This causes
-		// c's status to go dirty and emit DIRTY downstream → subscriber
-		// callback fires re-entrantly. At this moment _setDeps is not in
-		// flight (we're inside the dep-message dispatch, not _setDeps), so
-		// this case actually checks an UNRELATED reentrancy scenario.
-		a.down([[DATA, 5]]);
-		// Without an outer _setDeps in flight, the reentrant call may not
-		// trigger the _inDepMutation guard. Documenting this fragility:
-		// reentrancy guard fires when _setDeps/_addDep/_removeDep is in
-		// flight. The above scenario is not in that state.
-
-		// Direct test: trigger reentrancy DURING _setDeps's emit-DIRTY phase.
-		// When _setDeps emits DIRTY downstream, c's subscriber fires; if it
-		// calls back into _setDeps, the outer _setDeps is still in flight
-		// (`_inDepMutation === true`).
-		const c2 = node<number>({ initial: 0 });
-		let outerSetDepsReentrantError: string | undefined;
-		c2.subscribe((msgs) => {
-			if (outerSetDepsReentrantError) return;
-			for (const m of msgs) {
-				if (m[0] === DIRTY) {
-					try {
-						(c2 as unknown as NodeImpl).setDeps([b], noopFn);
-					} catch (err) {
-						outerSetDepsReentrantError = (err as Error).message;
-						return;
-					}
-				}
-			}
-		});
-		// Now call _setDeps on c2. It emits DIRTY downstream → subscriber
-		// fires reentrantly → guard rejects.
-		(c2 as unknown as NodeImpl).setDeps([a], noopFn);
-		expect(outerSetDepsReentrantError).toMatch(/reentrant dep mutation/);
-	});
-
-	// ─────────────────────────────────────────────────────────────────────
-	// _removeDep
-	// ─────────────────────────────────────────────────────────────────────
-
-	it("_removeDep: removes a dep, drops its DepRecord, surviving deps' records preserved", () => {
-		const a = node<number>({ initial: 5 });
-		const b = node<number>({ initial: 10 });
-		// fn deliberately omits defensive `?? 0` so the missing-slot effect is
-		// visible — demonstrates the user-fn-shape concern when removing a
-		// dep without supplying a new fn.
-		const c = node([a, b], (data, actions, ctx) => {
-			const av = data[0]?.[0] ?? ctx.prevData[0];
-			const bv = data[1]?.[0] ?? ctx.prevData[1];
-			actions.emit((av as number) + (bv as number));
-		});
-		c.subscribe(() => {});
-		expect(c.cache).toBe(15);
-
-		const beforeRecA = (c as unknown as NodeImpl)._deps[0];
-
-		// Drop b but keep the same fn — even though it'll silently break
-		// because data[1]/prevData[1] no longer exist. The Phase 13.8 lock
-		// requires fn at every call; passing the existing fn here demonstrates
-		// the foot-gun: explicitness doesn't fix semantics if the user
-		// re-passes a fn that's incompatible with the new shape.
-		const cFnOld = (c as unknown as NodeImpl)._fn as NodeFn;
-		(c as unknown as NodeImpl).removeDep(b, cFnOld);
-
-		// a's DepRecord identity preserved.
-		const afterRecA = (c as unknown as NodeImpl)._deps[0];
-		expect(afterRecA).toBe(beforeRecA);
-		expect((c as unknown as NodeImpl)._deps).toHaveLength(1);
-
-		// Drive a fresh wave. fn sees data[0]=a's batch [3], data[1]=undefined,
-		// prevData=[5] (length 1 — only a's record). av=3, bv=undefined.
-		// 3 + undefined = NaN. Demonstrates why opts.fn matters on shape change.
-		a.down([[DATA, 3]]);
-		expect(c.cache).toBeNaN();
-	});
-
-	it("_removeDep with opts.fn: surviving fn handles the shrunken dep set", () => {
-		const a = node<number>({ initial: 5 });
-		const b = node<number>({ initial: 10 });
-		const c = node([a, b], (data, actions, ctx) => {
-			const av = data[0]?.[0] ?? ctx.prevData[0];
-			const bv = data[1]?.[0] ?? ctx.prevData[1];
-			actions.emit(((av as number) ?? 0) + ((bv as number) ?? 0));
-		});
-		c.subscribe(() => {});
-		expect(c.cache).toBe(15);
-
-		// Drop b AND swap fn to read only a.
-		(c as unknown as NodeImpl).removeDep(b, (data, actions, ctx) => {
-			const v = data[0]?.[0] ?? ctx.prevData[0];
-			actions.emit((v as number) * 100);
-		});
-
-		a.down([[DATA, 7]]);
-		expect(c.cache).toBe(700); // new fn: a * 100
-	});
-
-	it("_removeDep is idempotent on absent dep (still applies fn swap if requested)", () => {
-		const a = node<number>({ initial: 1 });
-		const b = node<number>({ initial: 2 });
-		const c = node([a], (data, actions, ctx) => {
-			const v = data[0]?.[0] ?? ctx.prevData[0];
-			actions.emit((v as number) * 10);
-		});
-		c.subscribe(() => {});
-		expect(c.cache).toBe(10);
-
-		const lengthBefore = (c as unknown as NodeImpl)._deps.length;
-		const cFnOld = (c as unknown as NodeImpl)._fn as NodeFn;
-		// b is not a dep; remove is no-op for the dep set. fn still required.
-		expect(() => (c as unknown as NodeImpl).removeDep(b, cFnOld)).not.toThrow();
-		expect((c as unknown as NodeImpl)._deps.length).toBe(lengthBefore);
-
-		// But fn swap still applies even on absent dep.
-		(c as unknown as NodeImpl).removeDep(b, (data, actions, ctx) => {
-			const v = data[0]?.[0] ?? ctx.prevData[0];
-			actions.emit((v as number) + 50);
-		});
-		a.down([[DATA, 3]]);
-		expect(c.cache).toBe(53); // new fn: a + 50
-	});
-
-	it("_removeDep rejects on terminal node", () => {
-		const a = node<number>({ initial: 1 });
-		const c = node([a], (data, actions, ctx) => {
-			const v = data[0]?.[0] ?? ctx.prevData[0];
-			actions.emit((v as number) * 10);
-		});
-		c.subscribe(() => {});
-		c.down([[COMPLETE]]);
-		expect(c.status).toBe("completed");
-
-		expect(() => (c as unknown as NodeImpl).removeDep(a, noopFn)).toThrowError(/terminal state/);
-	});
-
-	it("_removeDep auto-settle: removing the sole DIRTY contributor closes the wave (no DATA → RESOLVED)", () => {
-		const a = node<number>({ initial: 1 });
-		const b = node<number>({ initial: 7 });
-		const c = node([a, b], (data, actions, ctx) => {
-			const av = data[0]?.[0] ?? ctx.prevData[0];
-			const bv = data[1]?.[0] ?? ctx.prevData[1];
-			actions.emit((av as number) + (bv as number));
-		});
-		c.subscribe(() => {});
-		expect(c.cache).toBe(8); // initial wave: 1 + 7
-
-		// Drive a into DIRTY-but-not-yet-DATA. c starts a wave waiting on a.
-		a.down([[DIRTY]]);
-		expect((c as unknown as NodeImpl)._status).toBe("dirty");
-		expect((c as unknown as NodeImpl)._dirtyDepCount).toBe(1);
-
-		// Remove a — sole DIRTY contributor. Auto-settle path runs.
-		// `_maybeRunFnOnSettlement` sees `_waveHasNewData=false` (a never
-		// delivered DATA this wave) → pre-fn-skip branch: emit RESOLVED
-		// downstream, don't re-run fn. Cache unchanged because no new
-		// dep value arrived; the wave was a "no-op wave" from c's POV.
-		const cFnPreserve = (c as unknown as NodeImpl)._fn as NodeFn;
-		(c as unknown as NodeImpl).removeDep(a, cFnPreserve);
-
-		expect((c as unknown as NodeImpl)._dirtyDepCount).toBe(0);
-		expect(c.cache).toBe(8); // unchanged — RESOLVED settles without re-firing fn
-		expect((c as unknown as NodeImpl)._status).not.toBe("dirty");
-	});
-});
diff --git a/packages/pure-ts/src/__tests__/core/rewire-mock-harness.test.ts b/packages/pure-ts/src/__tests__/core/rewire-mock-harness.test.ts
deleted file mode 100644
index 21157e2f..00000000
--- a/packages/pure-ts/src/__tests__/core/rewire-mock-harness.test.ts
+++ /dev/null
@@ -1,397 +0,0 @@
-/**
- * Phase 13.8 — mock AI self-pruning harness scenario for `_rewire`.
- *
- * Per `project_rewire_gap` memory: "AI self-pruning of harness topology"
- * is the founding use case for rewire. This test builds the canonical
- * scenario from the implementation-plan §13.8 deliverable list.
- *
- * If the API can't express this cleanly, the rewire shape is wrong —
- * findings flow back into `rewire-gap-findings.md`.
- *
- * Also covers Phase 13.8 Scenario 9 — `graph._rewire("mount::leaf", [...])`
- * across mount boundaries.
- */
-
-import { describe, expect, it } from "vitest";
-import { batch } from "../../core/batch.js";
-import { COMPLETE, DATA } from "../../core/messages.js";
-import type { Node, NodeFn, NodeImpl } from "../../core/node.js";
-import { node } from "../../core/node.js";
-import { Graph, type TopologyEvent } from "../../graph/graph.js";
-
-// Test helper: read the current `_fn` off a node so rewire calls can pass
-// the existing fn explicitly (the substrate API requires fn at every call).
-const fnOf = (n: Node): NodeFn => (n as NodeImpl)._fn as NodeFn;
-// No-op fn for guard-rejection tests where the fn argument never runs.
-const noopFn: NodeFn = () => {};
-
-describe("Phase 13.8 — graph._rewire mock-harness scenario", () => {
-	// ─────────────────────────────────────────────────────────────────────
-	// Mock AI self-pruning harness
-	// ─────────────────────────────────────────────────────────────────────
-
-	it("AI self-pruning: graph rewires `score` to bypass redundant `enrich` wrapper", () => {
-		const g = new Graph("harness");
-
-		// Pipeline: ingest → enrich → score → output
-		const ingest = g.add(node<number>({ initial: 1 }), { name: "ingest" });
-		const enrich = g.add(
-			node<number>([ingest], (data, actions, ctx) => {
-				const v = data[0]?.[0] ?? ctx.prevData[0];
-				// Pretend-enrich: add 10 (sometimes a no-op for some inputs).
-				actions.emit(((v as number) ?? 0) + 10);
-			}),
-			{ name: "enrich" },
-		);
-		const score = g.add(
-			node<number>([enrich], (data, actions, ctx) => {
-				const v = data[0]?.[0] ?? ctx.prevData[0];
-				actions.emit(((v as number) ?? 0) * 2);
-			}),
-			{ name: "score" },
-		);
-		const output = g.add(
-			node<number>([score], (data, actions, ctx) => {
-				const v = data[0]?.[0] ?? ctx.prevData[0];
-				actions.emit(v as number);
-			}),
-			{ name: "output" },
-		);
-
-		const seen: number[] = [];
-		output.subscribe((msgs) => {
-			for (const m of msgs) if (m[0] === DATA) seen.push(m[1] as number);
-		});
-
-		// Initial wiring: 1 → enrich(11) → score(22) → output(22)
-		expect(output.cache).toBe(22);
-
-		// AI decides `enrich` is no-op-grade for current inputs and prunes
-		// it: rewire `score` to read directly from `ingest`. Same fn (score
-		// computes `data[0] * 2` and `ingest` produces a number, same shape
-		// as the old `enrich` dep).
-		const audit = g._rewire("score", ["ingest"], fnOf(score));
-
-		expect(audit.removed).toEqual(["enrich"]);
-		expect(audit.added).toEqual(["ingest"]);
-		expect(audit.kept).toEqual([]);
-
-		// New wiring: 1 → score(2) → output(2)
-		expect(output.cache).toBe(2);
-		// Stream saw both pre- and post-rewire values.
-		expect(seen).toContain(22);
-		expect(seen.at(-1)).toBe(2);
-
-		// `enrich` was unsubscribed by score's rewire, but still registered
-		// on the graph. Removing it via graph.remove should not affect score.
-		g.remove("enrich");
-		expect(score.cache).toBe(2);
-		expect(output.cache).toBe(2);
-	});
-
-	// ─────────────────────────────────────────────────────────────────────
-	// Topology event emission
-	// ─────────────────────────────────────────────────────────────────────
-
-	it("emits TopologyEvent { kind: 'rewired', name, audit } on graph.topology", () => {
-		const g = new Graph("g");
-		const a = g.add(node<number>({ initial: 1 }), { name: "a" });
-		const b = g.add(node<number>({ initial: 2 }), { name: "b" });
-		const c = g.add(
-			node<number>([a], (data, actions, ctx) => {
-				const v = data[0]?.[0] ?? ctx.prevData[0];
-				actions.emit((v as number) * 10);
-			}),
-			{ name: "c" },
-		);
-		void b;
-		c.subscribe(() => {});
-
-		const events: TopologyEvent[] = [];
-		g.topology.subscribe((msgs) => {
-			for (const m of msgs) if (m[0] === DATA) events.push(m[1] as TopologyEvent);
-		});
-
-		const audit = g._rewire("c", ["b"], fnOf(c));
-
-		const rewired = events.find((e) => e.kind === "rewired");
-		expect(rewired).toBeDefined();
-		expect(rewired?.name).toBe("c");
-		expect((rewired as { audit: typeof audit }).audit).toEqual(audit);
-	});
-
-	// ─────────────────────────────────────────────────────────────────────
-	// Scenario 9 — cross-mount rewire
-	// ─────────────────────────────────────────────────────────────────────
-
-	it("scenario 9: graph._rewire with cross-mount path resolves via `mount::leaf`", () => {
-		const root = new Graph("root");
-		const child = new Graph("child");
-		root.mount("child", child);
-
-		const inner = child.add(node<number>({ initial: 5 }), { name: "inner" });
-		void inner;
-		const a = root.add(node<number>({ initial: 1 }), { name: "a" });
-		void a;
-		const consumer = root.add(
-			node<number>([a], (data, actions, ctx) => {
-				const v = data[0]?.[0] ?? ctx.prevData[0];
-				actions.emit((v as number) * 10);
-			}),
-			{ name: "consumer" },
-		);
-		consumer.subscribe(() => {});
-		expect(consumer.cache).toBe(10);
-
-		// Rewire consumer to point at child::inner. Same fn (multiplication
-		// of a single dep value).
-		const audit = root._rewire("consumer", ["child::inner"], fnOf(consumer));
-		expect(audit.removed).toEqual(["a"]);
-		expect(audit.added).toEqual(["child::inner"]);
-
-		expect(consumer.cache).toBe(50);
-	});
-
-	it("scenario 9b: cross-mount cycle rejection works through reachability check", () => {
-		const root = new Graph("root");
-		const child = new Graph("child");
-		root.mount("child", child);
-
-		const inner = child.add(node<number>({ initial: 1 }), { name: "inner" });
-		void inner;
-		const a = root.add(
-			node<number>(
-				["child::inner"].map((p) => root.resolve(p)),
-				(data, actions, ctx) => {
-					const v = data[0]?.[0] ?? ctx.prevData[0];
-					actions.emit((v as number) + 1);
-				},
-			),
-			{ name: "a" },
-		);
-		void a;
-
-		// Try to make `child::inner` depend on `a` — would create cycle
-		// inner → a → inner.
-		expect(() => root._rewire("child::inner", ["a"], noopFn)).toThrowError(/would create cycle/);
-	});
-
-	// ─────────────────────────────────────────────────────────────────────
-	// Edge cases unique to the Graph layer
-	// ─────────────────────────────────────────────────────────────────────
-
-	it("rewire on a foreign Node not registered raises a clear error", () => {
-		const g = new Graph("g");
-		expect(() => g._rewire("nonexistent", [], noopFn)).toThrowError(/unknown node/);
-	});
-
-	it("audit kept[] reflects deps present in both old and new sets", () => {
-		const g = new Graph("g");
-		const a = g.add(node<number>({ initial: 1 }), { name: "a" });
-		const b = g.add(node<number>({ initial: 2 }), { name: "b" });
-		const c = g.add(node<number>({ initial: 3 }), { name: "c" });
-		void a;
-		void b;
-		void c;
-		const sink = g.add(
-			node<number>([a, b], (data, actions, ctx) => {
-				const av = data[0]?.[0] ?? ctx.prevData[0];
-				const bv = data[1]?.[0] ?? ctx.prevData[1];
-				actions.emit(((av as number) ?? 0) + ((bv as number) ?? 0));
-			}),
-			{ name: "sink" },
-		);
-		sink.subscribe(() => {});
-
-		const audit = g._rewire("sink", ["a", "c"], fnOf(sink));
-		expect(audit.kept).toEqual(["a"]);
-		expect(audit.removed).toEqual(["b"]);
-		expect(audit.added).toEqual(["c"]);
-	});
-
-	it("reverse-rewire from a back to enrich restores the prior topology", () => {
-		const g = new Graph("g");
-		const ingest = g.add(node<number>({ initial: 1 }), { name: "ingest" });
-		const enrich = g.add(
-			node<number>([ingest], (data, actions, ctx) => {
-				const v = data[0]?.[0] ?? ctx.prevData[0];
-				actions.emit(((v as number) ?? 0) + 10);
-			}),
-			{ name: "enrich" },
-		);
-		void enrich;
-		const score = g.add(
-			node<number>([enrich], (data, actions, ctx) => {
-				const v = data[0]?.[0] ?? ctx.prevData[0];
-				actions.emit(((v as number) ?? 0) * 2);
-			}),
-			{ name: "score" },
-		);
-		score.subscribe(() => {});
-		expect(score.cache).toBe(22);
-
-		const scoreFn = fnOf(score);
-		g._rewire("score", ["ingest"], scoreFn);
-		expect(score.cache).toBe(2);
-
-		// Reverse: re-attach to enrich. Note enrich was decoupled from score
-		// but still registered on the graph and its subscription survived
-		// (or got dropped — depends on lifecycle). Since enrich had only
-		// score as a downstream and score unsubscribed, enrich deactivated.
-		// On rewire-to-enrich, score re-subscribes → enrich re-activates.
-		g._rewire("score", ["enrich"], scoreFn);
-		expect(score.cache).toBe(22);
-	});
-
-	// ─────────────────────────────────────────────────────────────────────
-	// Surface check: terminal-ed deps in the harness still propagate
-	// ─────────────────────────────────────────────────────────────────────
-
-	it("harness lifecycle: COMPLETE on ingest after rewire-away does NOT cascade to score", () => {
-		const g = new Graph("g");
-		const ingest = g.add(node<number>({ initial: 1 }), { name: "ingest" });
-		const enrich = g.add(
-			node<number>([ingest], (data, actions, ctx) => {
-				const v = data[0]?.[0] ?? ctx.prevData[0];
-				actions.emit(((v as number) ?? 0) + 10);
-			}),
-			{ name: "enrich" },
-		);
-		const score = g.add(
-			node<number>([enrich], (data, actions, ctx) => {
-				const v = data[0]?.[0] ?? ctx.prevData[0];
-				actions.emit(((v as number) ?? 0) * 2);
-			}),
-			{ name: "score" },
-		);
-		score.subscribe(() => {});
-
-		// Rewire score off enrich, onto a fresh source.
-		const fresh = g.add(node<number>({ initial: 5 }), { name: "fresh" });
-		void fresh;
-		g._rewire("score", ["fresh"], fnOf(score));
-
-		// Now COMPLETE enrich. score is no longer subscribed to enrich →
-		// no cascade.
-		enrich.down([[COMPLETE]]);
-		expect(score.status).not.toBe("completed");
-	});
-
-	// ─────────────────────────────────────────────────────────────────────
-	// Mid-batch rewire at the Graph layer
-	// ─────────────────────────────────────────────────────────────────────
-
-	it("graph._rewire and graph.set in the same batch — rewire wins, set queued against new dep", () => {
-		const g = new Graph("g");
-		const a = g.add(node<number>({ initial: 1 }), { name: "a" });
-		const b = g.add(node<number>({ initial: 100 }), { name: "b" });
-		void a;
-		void b;
-		const c = g.add(
-			node<number>([a], (data, actions, ctx) => {
-				const v = data[0]?.[0] ?? ctx.prevData[0];
-				actions.emit((v as number) * 10);
-			}),
-			{ name: "c" },
-		);
-		c.subscribe(() => {});
-		expect(c.cache).toBe(10);
-
-		// Inside one batch: set b to 200, rewire c to b. Order of ops
-		// matters — set b first, rewire after, so c sees b=200.
-		batch(() => {
-			g.set("b", 200);
-			g._rewire("c", ["b"], fnOf(c));
-		});
-		expect(c.cache).toBe(2000);
-	});
-
-	// ─────────────────────────────────────────────────────────────────────
-	// Graph-layer _addDep / _removeDep / _rewire opts.fn
-	// ─────────────────────────────────────────────────────────────────────
-
-	it("graph._addDep with opts.fn: append new dep + replace fn via path resolution", () => {
-		const g = new Graph("g");
-		const a = g.add(node<number>({ initial: 3 }), { name: "a" });
-		const b = g.add(node<number>({ initial: 4 }), { name: "b" });
-		void b;
-		const c = g.add(
-			node<number>([a], (data, actions, ctx) => {
-				const v = data[0]?.[0] ?? ctx.prevData[0];
-				actions.emit((v as number) * 2);
-			}),
-			{ name: "c" },
-		);
-		c.subscribe(() => {});
-		expect(c.cache).toBe(6);
-
-		// Append b by path; supply new fn that uses both deps.
-		const idx = g._addDep("c", "b", (data, actions, ctx) => {
-			const av = data[0]?.[0] ?? ctx.prevData[0];
-			const bv = data[1]?.[0] ?? ctx.prevData[1];
-			actions.emit(((av as number) ?? 0) * ((bv as number) ?? 0));
-		});
-		expect(idx).toBe(1);
-		expect(c.cache).toBe(12); // 3 * 4
-	});
-
-	it("graph._removeDep with opts.fn: drop dep + replace fn via path resolution", () => {
-		const g = new Graph("g");
-		const a = g.add(node<number>({ initial: 5 }), { name: "a" });
-		const b = g.add(node<number>({ initial: 10 }), { name: "b" });
-		void a;
-		void b;
-		const c = g.add(
-			node<number>([a, b], (data, actions, ctx) => {
-				const av = data[0]?.[0] ?? ctx.prevData[0];
-				const bv = data[1]?.[0] ?? ctx.prevData[1];
-				actions.emit(((av as number) ?? 0) + ((bv as number) ?? 0));
-			}),
-			{ name: "c" },
-		);
-		c.subscribe(() => {});
-		expect(c.cache).toBe(15);
-
-		// Drop b by path; supply fn that consumes only a.
-		g._removeDep("c", "b", (data, actions, ctx) => {
-			const v = data[0]?.[0] ?? ctx.prevData[0];
-			actions.emit((v as number) * 100);
-		});
-
-		g.set("a", 7);
-		expect(c.cache).toBe(700);
-	});
-
-	it("graph._rewire with opts.fn: full rewire including fn replacement", () => {
-		const g = new Graph("g");
-		const a = g.add(node<number>({ initial: 1 }), { name: "a" });
-		const b = g.add(node<number>({ initial: 2 }), { name: "b" });
-		void a;
-		void b;
-		const c = g.add(
-			node<number>([a], (data, actions, ctx) => {
-				const v = data[0]?.[0] ?? ctx.prevData[0];
-				actions.emit((v as number) * 10);
-			}),
-			{ name: "c" },
-		);
-		c.subscribe(() => {});
-		expect(c.cache).toBe(10);
-
-		// Rewire to [a, b] AND swap fn.
-		g._rewire("c", ["a", "b"], (data, actions, ctx) => {
-			const av = data[0]?.[0] ?? ctx.prevData[0];
-			const bv = data[1]?.[0] ?? ctx.prevData[1];
-			actions.emit(((av as number) ?? 0) - ((bv as number) ?? 0));
-		});
-		expect(c.cache).toBe(-1); // 1 - 2
-	});
-
-	it("graph._addDep / _removeDep on unknown node throws", () => {
-		const g = new Graph("g");
-		const a = g.add(node<number>({ initial: 1 }), { name: "a" });
-		void a;
-		expect(() => g._addDep("nonexistent", a, noopFn)).toThrowError(/unknown node/);
-		expect(() => g._removeDep("nonexistent", a, noopFn)).toThrowError(/unknown node/);
-	});
-});
diff --git a/packages/pure-ts/src/__tests__/core/rewire-real-consumer.test.ts b/packages/pure-ts/src/__tests__/core/rewire-real-consumer.test.ts
deleted file mode 100644
index b0e0d4e5..00000000
--- a/packages/pure-ts/src/__tests__/core/rewire-real-consumer.test.ts
+++ /dev/null
@@ -1,523 +0,0 @@
-/**
- * Phase 13.8 — real-consumer ergonomics validation for `_rewire` + `_setDeps` /
- * `_addDep` / `_removeDep` substrate APIs.
- *
- * Goal: take the rewire substrate out of synthetic [a, b, c] tests and into
- * realistic AI self-pruning shapes that match the founding use case
- * (`project_rewire_gap` memory, blocked since 2026-04-26 until Phase 13.8).
- * Findings flow back into `docs/research/rewire-gap-findings.md` § Real-consumer
- * ergonomics.
- *
- * Each test simulates an AI controller that:
- * 1. Builds a realistic pipeline using the public `Graph` API.
- * 2. Subscribes to `graph.topology` to capture rewire audits as a real
- *    consumer would.
- * 3. Observes pipeline output, decides a topology change is warranted.
- * 4. Calls `Graph._rewire` / `_addDep` / `_removeDep` with appropriate
- *    `opts.fn`.
- * 5. Verifies the post-change output is correct AND the topology subscriber
- *    saw a coherent audit trail.
- */
-
-import { describe, expect, it } from "vitest";
-import { DATA } from "../../core/messages.js";
-import type { Node, NodeFn, NodeImpl } from "../../core/node.js";
-import { node } from "../../core/node.js";
-import { Graph, type GraphRewireAudit, type TopologyEvent } from "../../graph/graph.js";
-
-const fnOf = (n: Node): NodeFn => (n as NodeImpl)._fn as NodeFn;
-const _noopFn: NodeFn = () => {};
-
-describe("Phase 13.8 — real-consumer ergonomics", () => {
-	// ─────────────────────────────────────────────────────────────────────
-	// Scenario A: AI prunes a no-op intermediate stage
-	// ─────────────────────────────────────────────────────────────────────
-	//
-	// Pipeline: rawText → normalize → trim → score → output
-	// AI runs a sample wave, observes that `trim` is a no-op for the current
-	// input distribution (text is already trimmed), and rewires `score` to
-	// read directly from `normalize`. `trim` stays registered on the graph
-	// but is no longer on the data path. No fn signature change needed
-	// because both `normalize` and `trim` produce the same shape (string).
-
-	it("Scenario A: AI prunes a no-op stage; pipeline output unchanged; audit captured", () => {
-		const g = new Graph("text-pipeline");
-
-		// Pipeline stages.
-		// Input is already-trimmed so `trim` is genuinely a no-op for this wave.
-		g.add(node<string>({ initial: "hello world" }), { name: "rawText" });
-		g.add(
-			node<string>([g.node("rawText")], (data, actions, ctx) => {
-				const v = (data[0]?.[0] ?? ctx.prevData[0]) as string;
-				actions.emit(v.toLowerCase());
-			}),
-			{ name: "normalize" },
-		);
-		g.add(
-			node<string>([g.node("normalize")], (data, actions, ctx) => {
-				const v = (data[0]?.[0] ?? ctx.prevData[0]) as string;
-				// Trimming is a no-op for already-trimmed inputs.
-				actions.emit(v.trim());
-			}),
-			{ name: "trim" },
-		);
-		const score = g.add(
-			node<number>([g.node("trim")], (data, actions, ctx) => {
-				const v = (data[0]?.[0] ?? ctx.prevData[0]) as string;
-				// Length-based score.
-				actions.emit(v.length);
-			}),
-			{ name: "score" },
-		);
-
-		score.subscribe(() => {});
-
-		// AI controller subscribes to topology to keep an audit log.
-		const auditLog: TopologyEvent[] = [];
-		g.topology.subscribe((msgs) => {
-			for (const m of msgs) if (m[0] === DATA) auditLog.push(m[1] as TopologyEvent);
-		});
-
-		// rawText "  hello world  " → normalize "  hello world  " (lowercase
-		// is no-op) → trim "hello world" → score 11.
-		const before = score.cache;
-		expect(before).toBe(11);
-
-		// AI decides: for this input, trim is no-op (the lowercased text was
-		// already trimmed-equivalent for our purposes). Bypass it.
-		const audit = g._rewire("score", ["normalize"], fnOf(score));
-
-		expect(audit.removed).toEqual(["trim"]);
-		expect(audit.added).toEqual(["normalize"]);
-		expect(audit.kept).toEqual([]);
-
-		// Output unchanged because trim was no-op for this input.
-		expect(score.cache).toBe(11);
-
-		// Audit visible to the topology subscriber.
-		const rewireEvent = auditLog.find((e) => e.kind === "rewired");
-		expect(rewireEvent).toBeDefined();
-		expect((rewireEvent as { audit: GraphRewireAudit }).audit).toEqual(audit);
-
-		// `trim` is still registered on the graph; just not on the data path.
-		expect(g.node("trim")).toBeDefined();
-	});
-
-	// ─────────────────────────────────────────────────────────────────────
-	// Scenario B: AI swaps a broken tool with `opts.fn` to update planner shape
-	// ─────────────────────────────────────────────────────────────────────
-	//
-	// Pipeline: planner aggregates [toolA, toolB] outputs.
-	// AI detects toolB is broken/irrelevant; replaces it with toolC.
-	// Tool slot count is unchanged BUT the meaning of slot 1 changed — the
-	// planner's fn would still work positionally, but a careful AI would
-	// supply a new fn that knows about toolC's specific shape.
-
-	it("Scenario B: AI swaps a tool dep + supplies new fn that knows the new tool's shape", () => {
-		const g = new Graph("multi-tool-planner");
-
-		g.add(node<string>({ initial: "Q1 revenue by region" }), { name: "query" });
-
-		// Tools — each produces a different kind of insight.
-		g.add(
-			node<{ source: string; rows: number }>([g.node("query")], (data, actions, ctx) => {
-				const q = (data[0]?.[0] ?? ctx.prevData[0]) as string;
-				actions.emit({ source: "sql", rows: q.length });
-			}),
-			{ name: "toolSQL" },
-		);
-		g.add(
-			node<{ source: string; matches: number }>([g.node("query")], (data, actions, ctx) => {
-				const q = (data[0]?.[0] ?? ctx.prevData[0]) as string;
-				// Pretend this tool is broken — emits zeros.
-				actions.emit({ source: "vectorSearch-broken", matches: 0 });
-				void q;
-			}),
-			{ name: "toolBroken" },
-		);
-		g.add(
-			node<{ source: string; pages: number }>([g.node("query")], (data, actions, ctx) => {
-				const q = (data[0]?.[0] ?? ctx.prevData[0]) as string;
-				actions.emit({ source: "docSearch", pages: Math.floor(q.length / 5) });
-			}),
-			{ name: "toolDocs" },
-		);
-
-		// Planner — initially uses [toolSQL, toolBroken].
-		const planner = g.add(
-			node<string>([g.node("toolSQL"), g.node("toolBroken")], (data, actions, ctx) => {
-				const sql = (data[0]?.[0] ?? ctx.prevData[0]) as { source: string; rows: number };
-				const vec = (data[1]?.[0] ?? ctx.prevData[1]) as {
-					source: string;
-					matches: number;
-				};
-				actions.emit(
-					`Plan: query SQL (${sql?.rows ?? 0} rows) + vector (${vec?.matches ?? 0} matches)`,
-				);
-			}),
-			{ name: "planner" },
-		);
-		planner.subscribe(() => {});
-
-		const initialPlan = planner.cache;
-		expect(initialPlan).toContain("rows");
-		expect(initialPlan).toContain("matches");
-
-		// AI detects toolBroken returns 0 matches consistently → swap for toolDocs.
-		// The new tool produces a DIFFERENT shape (`pages` instead of `matches`),
-		// so the planner needs a new fn to consume it.
-		g._rewire("planner", ["toolSQL", "toolDocs"], (data, actions, ctx) => {
-			const sql = (data[0]?.[0] ?? ctx.prevData[0]) as { source: string; rows: number };
-			const docs = (data[1]?.[0] ?? ctx.prevData[1]) as {
-				source: string;
-				pages: number;
-			};
-			actions.emit(`Plan: query SQL (${sql?.rows ?? 0} rows) + docs (${docs?.pages ?? 0} pages)`);
-		});
-
-		// Post-rewire plan reflects the new tool's shape.
-		const newPlan = planner.cache;
-		expect(newPlan).toContain("rows");
-		expect(newPlan).toContain("pages");
-		expect(newPlan).not.toContain("matches");
-	});
-
-	// ─────────────────────────────────────────────────────────────────────
-	// Scenario C: AI extends pipeline with a new stage via `_addDep` + opts.fn
-	// ─────────────────────────────────────────────────────────────────────
-	//
-	// Pipeline: input → output (single dep). AI adds a `validator` stage
-	// dep to output and updates output's fn to combine input + validation.
-
-	it("Scenario C: AI extends a node's deps with `_addDep` + opts.fn", () => {
-		const g = new Graph("validation-extend");
-
-		g.add(node<number>({ initial: 42 }), { name: "input" });
-		g.add(
-			node<{ ok: boolean }>([g.node("input")], (data, actions, ctx) => {
-				const v = (data[0]?.[0] ?? ctx.prevData[0]) as number;
-				actions.emit({ ok: v > 0 });
-			}),
-			{ name: "validator" },
-		);
-		const output = g.add(
-			node<string>([g.node("input")], (data, actions, ctx) => {
-				const v = (data[0]?.[0] ?? ctx.prevData[0]) as number;
-				actions.emit(`Result: ${v}`);
-			}),
-			{ name: "output" },
-		);
-		output.subscribe(() => {});
-		expect(output.cache).toBe("Result: 42");
-
-		// AI decides output should also incorporate validator state.
-		const newIdx = g._addDep("output", "validator", (data, actions, ctx) => {
-			const v = (data[0]?.[0] ?? ctx.prevData[0]) as number;
-			const validation = (data[1]?.[0] ?? ctx.prevData[1]) as {
-				ok: boolean;
-			};
-			actions.emit(`Result: ${v} (ok=${validation?.ok ?? "?"})`);
-		});
-		expect(newIdx).toBe(1); // appended at end
-
-		expect(output.cache).toBe("Result: 42 (ok=true)");
-	});
-
-	// ─────────────────────────────────────────────────────────────────────
-	// Scenario D: AI strips a stage via `_removeDep` + opts.fn
-	// ─────────────────────────────────────────────────────────────────────
-
-	it("Scenario D: AI strips a dep via `_removeDep` + opts.fn", () => {
-		const g = new Graph("trim-down");
-
-		g.add(node<number>({ initial: 100 }), { name: "input" });
-		g.add(
-			node<number>([g.node("input")], (data, actions, ctx) => {
-				const v = (data[0]?.[0] ?? ctx.prevData[0]) as number;
-				actions.emit(v * 0.05); // expensive tax computation
-			}),
-			{ name: "tax" },
-		);
-		const total = g.add(
-			node<number>([g.node("input"), g.node("tax")], (data, actions, ctx) => {
-				const base = (data[0]?.[0] ?? ctx.prevData[0]) as number;
-				const tax = (data[1]?.[0] ?? ctx.prevData[1]) as number;
-				actions.emit(base + tax);
-			}),
-			{ name: "total" },
-		);
-		total.subscribe(() => {});
-		expect(total.cache).toBe(105); // 100 + 5
-
-		// AI decides tax is no longer needed (e.g. customer is tax-exempt).
-		// Drop the tax dep AND swap fn to ignore the missing slot.
-		g._removeDep("total", "tax", (data, actions, ctx) => {
-			const base = (data[0]?.[0] ?? ctx.prevData[0]) as number;
-			actions.emit(base);
-		});
-
-		// Drive a fresh wave through input.
-		g.set("input", 200);
-		expect(total.cache).toBe(200); // tax-free
-	});
-
-	// ─────────────────────────────────────────────────────────────────────
-	// Scenario E: External-controller pattern (the ergonomic reality)
-	// ─────────────────────────────────────────────────────────────────────
-	//
-	// **Ergonomic finding:** rewires CANNOT be triggered from inside a
-	// subscriber callback that fires synchronously during the upstream's
-	// fn execution. Subscribers fire while `_isExecutingFn === true`, so
-	// `_setDeps`/`_addDep`/`_removeDep` reject with "mid-fn topology
-	// mutation". The error is then caught by the upstream's `_execFn`
-	// catch and emitted as ERROR downstream — silently breaking the
-	// caller's intent.
-	//
-	// The correct pattern: AI controllers call rewire from OUTSIDE any
-	// subscriber callback — typically from the outer driver loop after
-	// inspecting state via `graph.observe()` or direct `node.cache` reads.
-	// This test demonstrates the working pattern.
-
-	it("Scenario E: external-driver rewire (the pattern AI controllers should use)", () => {
-		const g = new Graph("external-driver");
-
-		g.add(node<number>({ initial: 1 }), { name: "a" });
-		g.add(node<number>({ initial: 100 }), { name: "b" });
-		const consumer = g.add(
-			node<number>([g.node("a")], (data, actions, ctx) => {
-				const v = (data[0]?.[0] ?? ctx.prevData[0]) as number;
-				actions.emit(v * 10);
-			}),
-			{ name: "consumer" },
-		);
-		consumer.subscribe(() => {});
-
-		// Initial wave: a=1 → consumer=10.
-		expect(consumer.cache).toBe(10);
-
-		// AI driver loop: drive an input, inspect state, rewire if needed.
-		g.set("a", 5);
-		// consumer = 50 now.
-		if ((consumer.cache as number) >= 50) {
-			g._rewire("consumer", ["b"], fnOf(consumer));
-		}
-		// Now consumer reads from b=100 → 1000.
-		expect(consumer.cache).toBe(1000);
-	});
-
-	it("Scenario E2: subscriber-driven rewire is rejected mid-fn (foot-gun documented)", () => {
-		// Confirms the constraint described above. A subscriber that fires
-		// during upstream fn-emit cannot call rewire — it'll be rejected.
-		const g = new Graph("foot-gun-mid-fn");
-
-		const a = g.add(node<number>({ initial: 1 }), { name: "a" });
-		g.add(node<number>({ initial: 100 }), { name: "b" });
-		const consumer = g.add(
-			node<number>([g.node("a")], (data, actions, ctx) => {
-				const v = (data[0]?.[0] ?? ctx.prevData[0]) as number;
-				actions.emit(v * 10);
-			}),
-			{ name: "consumer" },
-		);
-		consumer.subscribe(() => {});
-
-		let caughtError: string | undefined;
-		consumer.subscribe((msgs) => {
-			for (const m of msgs) {
-				if (m[0] === DATA && (m[1] as number) >= 50) {
-					try {
-						g._rewire("consumer", ["b"], fnOf(consumer));
-					} catch (err) {
-						caughtError = (err as Error).message;
-					}
-				}
-			}
-		});
-
-		g.set("a", 5);
-		// Rewire was rejected ("mid-fn topology mutation") and caught locally.
-		// consumer's deps unchanged → still reads from `a`. cache = 50.
-		expect(caughtError).toMatch(/mid-fn topology mutation/);
-		expect(consumer.cache).toBe(50);
-		// consumer's deps are unchanged (still [a]).
-		const deps = (consumer as unknown as { _deps: { node: unknown }[] })._deps;
-		expect(deps).toHaveLength(1);
-		expect(deps[0].node).toBe(a);
-	});
-
-	// ─────────────────────────────────────────────────────────────────────
-	// Scenario F: COMPLETE on a removed dep does not propagate (cascade clean)
-	// ─────────────────────────────────────────────────────────────────────
-
-	it("Scenario F: completing a pruned dep does NOT cascade to the consumer", () => {
-		const g = new Graph("cascade-isolation");
-
-		g.add(node<number>({ initial: 1 }), { name: "stale" });
-		g.add(node<number>({ initial: 2 }), { name: "fresh" });
-		const consumer = g.add(
-			node<number>([g.node("stale")], (data, actions, ctx) => {
-				const v = (data[0]?.[0] ?? ctx.prevData[0]) as number;
-				actions.emit(v * 10);
-			}),
-			{ name: "consumer" },
-		);
-		consumer.subscribe(() => {});
-		expect(consumer.cache).toBe(10);
-
-		// AI decides "stale" is being deprecated; rewire consumer onto "fresh".
-		g._rewire("consumer", ["fresh"], fnOf(consumer));
-		expect(consumer.cache).toBe(20);
-
-		// Now COMPLETE the deprecated source. Should NOT propagate to consumer.
-		g.complete("stale");
-		expect(consumer.status).not.toBe("completed");
-		expect(consumer.cache).toBe(20);
-	});
-
-	// ─────────────────────────────────────────────────────────────────────
-	// Scenario G: Topology subscriber audits multiple sequential rewires
-	// ─────────────────────────────────────────────────────────────────────
-	//
-	// AI controllers often perform multiple rewires in sequence. The
-	// topology subscriber should see each one with a coherent audit.
-
-	it("Scenario G: sequential rewires produce a coherent audit trail", () => {
-		const g = new Graph("audit-trail");
-
-		g.add(node<number>({ initial: 1 }), { name: "a" });
-		g.add(node<number>({ initial: 2 }), { name: "b" });
-		g.add(node<number>({ initial: 3 }), { name: "c" });
-		const sink = g.add(
-			node<number>([g.node("a")], (data, actions, ctx) => {
-				const v = (data[0]?.[0] ?? ctx.prevData[0]) as number;
-				actions.emit(v * 100);
-			}),
-			{ name: "sink" },
-		);
-		sink.subscribe(() => {});
-
-		const audits: GraphRewireAudit[] = [];
-		g.topology.subscribe((msgs) => {
-			for (const m of msgs) {
-				if (m[0] === DATA) {
-					const ev = m[1] as TopologyEvent;
-					if (ev.kind === "rewired") audits.push(ev.audit);
-				}
-			}
-		});
-
-		// AI does a sequence of rewires.
-		g._rewire("sink", ["b"], fnOf(sink));
-		g._rewire("sink", ["a", "b"], (data, actions, ctx) => {
-			const av = (data[0]?.[0] ?? ctx.prevData[0]) as number;
-			const bv = (data[1]?.[0] ?? ctx.prevData[1]) as number;
-			actions.emit(av + bv);
-		});
-		g._rewire("sink", ["c"], (data, actions, ctx) => {
-			const cv = (data[0]?.[0] ?? ctx.prevData[0]) as number;
-			actions.emit(cv * 1000);
-		});
-
-		expect(audits).toHaveLength(3);
-		expect(audits[0]).toEqual({ name: "sink", removed: ["a"], added: ["b"], kept: [] });
-		expect(audits[1]).toEqual({ name: "sink", removed: [], added: ["a"], kept: ["b"] });
-		expect(audits[2]).toEqual({ name: "sink", removed: ["a", "b"], added: ["c"], kept: [] });
-
-		expect(sink.cache).toBe(3000); // 3 * 1000
-	});
-
-	// ─────────────────────────────────────────────────────────────────────
-	// Scenario H: graph.observe + rewire — value observers stay coherent
-	// ─────────────────────────────────────────────────────────────────────
-	//
-	// `graph.observe(path)` is the user-facing way to watch a node's
-	// value stream. After a rewire that changes how the node computes,
-	// the observer should keep seeing values from the same node identity
-	// (the node didn't change, only its inputs).
-
-	it("Scenario H: graph.observe sink stays coherent across a rewire", () => {
-		const g = new Graph("observe-coherence");
-
-		g.add(node<number>({ initial: 10 }), { name: "src1" });
-		g.add(node<number>({ initial: 100 }), { name: "src2" });
-		g.add(
-			node<number>([g.node("src1")], (data, actions, ctx) => {
-				const v = (data[0]?.[0] ?? ctx.prevData[0]) as number;
-				actions.emit(v * 2);
-			}),
-			{ name: "out" },
-		);
-
-		const observed: number[] = [];
-		const obs = g.observe("out");
-		obs.subscribe((msgs) => {
-			for (const m of msgs) if (m[0] === DATA) observed.push(m[1] as number);
-		});
-
-		// Initial: 10 * 2 = 20.
-		expect(observed).toContain(20);
-
-		// Rewire to src2 with new fn that knows the new dep.
-		g._rewire("out", ["src2"], (data, actions, ctx) => {
-			const v = (data[0]?.[0] ?? ctx.prevData[0]) as number;
-			actions.emit(v + 1);
-		});
-		// 100 + 1 = 101 — observer sees this through the same subscription.
-		expect(observed).toContain(101);
-
-		// Drive a fresh wave through the new dep.
-		g.set("src2", 200);
-		// 200 + 1 = 201.
-		expect(observed).toContain(201);
-
-		// Observer never had to re-subscribe; the node identity stayed stable.
-	});
-
-	// ─────────────────────────────────────────────────────────────────────
-	// Scenario I: Required-fn lock surfaces the foot-gun explicitly
-	// ─────────────────────────────────────────────────────────────────────
-	//
-	// Phase 13.8 lock makes `fn` required at every rewire call site. This
-	// closes the silent shape-mismatch path — the caller MUST acknowledge
-	// what fn pairs with the new dep set. If they pass the OLD fn for a
-	// shape-changing rewire, the bug surfaces but at least the call site
-	// makes the decision visible (auditable in code review / AI logs).
-
-	it("Scenario I: required-fn lock — caller must explicitly acknowledge fn-deps pairing", () => {
-		const g = new Graph("required-fn-foot-gun");
-
-		g.add(node<number>({ initial: 5 }), { name: "tens" }); // tens digit
-		g.add(node<number>({ initial: 7 }), { name: "ones" }); // ones digit
-		g.add(node<number>({ initial: 99 }), { name: "different" });
-		const score = g.add(
-			node<number>([g.node("tens"), g.node("ones")], (data, actions, ctx) => {
-				const t = (data[0]?.[0] ?? ctx.prevData[0]) as number;
-				const o = (data[1]?.[0] ?? ctx.prevData[1]) as number;
-				actions.emit(t * 10 + o); // 57
-			}),
-			{ name: "score" },
-		);
-		score.subscribe(() => {});
-		expect(score.cache).toBe(57);
-
-		// AI rewires score's deps to [different, ones]. Caller MUST pass fn —
-		// type system enforces it. If the caller passes the OLD fn, the bug
-		// surfaces (data[0] is now "different" not "tens") but the call site
-		// explicitly declared "I'm reusing the existing fn for the new shape."
-		g._rewire("score", ["different", "ones"], fnOf(score));
-		expect(score.cache).toBe(997); // 99 * 10 + 7 — wrong semantics but visible
-		// Compare: with a fresh fn that knows the new dep semantics, the
-		// caller takes responsibility correctly. Pure fn swap (no dep
-		// change) — needs a fresh wave to trigger fn re-execution.
-		g._rewire("score", ["different", "ones"], (data, actions, ctx) => {
-			// Treat the slot as just "the multiplier" rather than "tens".
-			const m = (data[0]?.[0] ?? ctx.prevData[0]) as number;
-			const o = (data[1]?.[0] ?? ctx.prevData[1]) as number;
-			actions.emit(m + o); // semantic intent: sum
-		});
-		// Pure fn swap doesn't auto-fire; drive a fresh DATA on `different`
-		// to trigger. Use a NEW value so equals-suppression doesn't skip emit.
-		g.set("different", 50);
-		expect(score.cache).toBe(57); // 50 + 7 (new fn semantics)
-	});
-});
diff --git a/packages/pure-ts/src/__tests__/core/sugar.test.ts b/packages/pure-ts/src/__tests__/core/sugar.test.ts
deleted file mode 100644
index 4727892c..00000000
--- a/packages/pure-ts/src/__tests__/core/sugar.test.ts
+++ /dev/null
@@ -1,231 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { DATA, DIRTY, RESOLVED } from "../../core/messages.js";
-import { describeNode } from "../../core/meta.js";
-import { type Node, node } from "../../core/node.js";
-import { pipe } from "../../core/sugar.js";
-
-describe("sugar constructors", () => {
-	it("node([], { initial }) is a manual source with initial value", () => {
-		const s = node([], { initial: 10 });
-		expect(s.cache).toBe(10);
-		const seen: symbol[] = [];
-		const unsub = s.subscribe((msgs) => {
-			for (const m of msgs) seen.push(m[0] as symbol);
-		});
-		s.down([[DIRTY], [DATA, 11]]);
-		unsub();
-		expect(s.cache).toBe(11);
-		expect(seen).toContain(DIRTY);
-		expect(seen).toContain(DATA);
-	});
-
-	it("node([]) (zero-arg overload) starts in sentinel status with no cached DATA", () => {
-		// qa D2: zero-arg `node([])` is the canonical raw form for "no value yet".
-		const s = node<number>([]);
-		expect(s.cache).toBeUndefined();
-		expect(s.status).toBe("sentinel");
-		const seen: Array<[symbol, unknown]> = [];
-		const unsub = s.subscribe((msgs) => {
-			for (const m of msgs) seen.push([m[0] as symbol, m[1]]);
-		});
-		// Subscribe-with-sentinel: NO DATA arrives push-on-subscribe
-		// (status="sentinel" means no cached value to replay).
-		expect(seen.find(([t]) => t === DATA)).toBeUndefined();
-		// First emit transitions to "settled" status with a real value.
-		s.emit(42);
-		expect(s.cache).toBe(42);
-		expect(s.status).toBe("settled");
-		expect(seen.find(([t]) => t === DATA)?.[1]).toBe(42);
-		unsub();
-	});
-
-	it("node([], { initial: null }) caches null as a valid DATA value (distinct from sentinel)", () => {
-		// Spec §2.2: `T | null` is the valid DATA domain; only `undefined`
-		// is the SENTINEL. Confirm `node([], { initial: null })` differs from `node([])`:
-		// the null cache puts the node in `"settled"` status with an
-		// observable null DATA on subscribe.
-		const s = node<number | null>([], { initial: null });
-		expect(s.cache).toBeNull();
-		expect(s.status).toBe("settled");
-		const seen: unknown[] = [];
-		const unsub = s.subscribe((msgs) => {
-			for (const m of msgs) {
-				if (m[0] === DATA) seen.push(m[1]);
-			}
-		});
-		expect(seen).toEqual([null]);
-		unsub();
-	});
-
-	it("node producer runs on subscribe and can emit", () => {
-		const p = node<number>(
-			[],
-			(_data, actions) => {
-				actions.emit(1);
-			},
-			{ describeKind: "producer" },
-		);
-		const seen: number[] = [];
-		const unsub = p.subscribe((msgs) => {
-			for (const m of msgs) {
-				if (m[0] === DATA) seen.push(m[1] as number);
-			}
-		});
-		expect(p.cache).toBe(1);
-		// Producer emits 1 during _startProducer → single delivery.
-		expect(seen).toEqual([1]);
-		unsub();
-	});
-
-	it("node derived is deps + value-returning fn", () => {
-		const src = node([], { initial: 2 });
-		const d = node(
-			[src],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as number) * 3);
-			},
-			{ describeKind: "derived" },
-		);
-		const seen: symbol[] = [];
-		const unsub = d.subscribe((msgs) => {
-			for (const m of msgs) seen.push(m[0] as symbol);
-		});
-		src.down([[DATA, 3]]);
-		expect(d.cache).toBe(9);
-		expect(seen).toContain(DATA);
-		unsub();
-	});
-
-	it("effect and producer set describe kind for describe()", () => {
-		const e = node(
-			[node([], { initial: 0 })],
-			(batchData, _actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				void data;
-			},
-			{ describeKind: "effect" },
-		);
-		expect(describeNode(e).type).toBe("effect");
-		const p = node<number>(
-			[],
-			(_data, actions) => {
-				actions.emit(1);
-			},
-			{ describeKind: "producer" },
-		);
-		expect(describeNode(p).type).toBe("producer");
-	});
-
-	it("effect runs without auto-emit from return value", () => {
-		const src = node([], { initial: 0 });
-		let runs = 0;
-		const e = node(
-			[src],
-			(batchData, _actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				void data;
-				runs += 1;
-				return undefined;
-			},
-			{ describeKind: "effect" },
-		);
-		const unsub = e.subscribe(() => undefined);
-		src.down([[DIRTY], [DATA, 1]]);
-		unsub();
-		// Initial connect runs once; dep update runs again.
-		expect(runs).toBe(2);
-		expect(e.cache).toBeUndefined();
-	});
-
-	it("node derived propagates dep value types into the callback (no extra casts needed)", () => {
-		const a = node([], { initial: 2 });
-		const b = node([], { initial: "hi" as string });
-		const out = node(
-			[a, b],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				const sum = data[0] as number;
-				const label = data[1] as string;
-				actions.emit(`${label}:${sum * 2}`);
-			},
-			{ describeKind: "derived" },
-		);
-		const unsub = out.subscribe(() => undefined);
-		expect(out.cache).toBe("hi:4");
-		a.down([[DATA, 5]]);
-		expect(out.cache).toBe("hi:10");
-		unsub();
-	});
-
-	it("node effect receives typed deps and runs without auto-emit", () => {
-		const src = node([], { initial: 7 });
-		const flag = node([], { initial: false });
-		let lastSeen: [number, boolean] | undefined;
-		const e = node(
-			[src, flag],
-			(batchData, _actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				const n = data[0] as number;
-				const f = data[1] as boolean;
-				lastSeen = [n, f];
-			},
-			{ describeKind: "effect" },
-		);
-		const unsub = e.subscribe(() => undefined);
-		expect(lastSeen).toEqual([7, false]);
-		flag.down([[DATA, true]]);
-		expect(lastSeen).toEqual([7, true]);
-		unsub();
-	});
-
-	it("pipe chains unary node transforms", () => {
-		const src = node([], { initial: 1 });
-		const doubled = (n: Node) =>
-			node(
-				[n],
-				(batchData, actions, ctx) => {
-					const data = batchData.map((batch, i) =>
-						batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-					);
-					actions.emit((data[0] as number) * 2);
-				},
-				{ describeKind: "derived" },
-			);
-		const out = pipe(src, doubled, doubled);
-		const unsub = out.subscribe(() => undefined);
-		expect(out.cache).toBe(4);
-		unsub();
-	});
-
-	it("pipe with no ops returns source", () => {
-		const src = node([], { initial: "x" as string });
-		expect(pipe(src)).toBe(src);
-	});
-
-	it("raw node with explicit actions.down() does not emit DATA", () => {
-		const src = node([], { initial: 0 });
-		const d = node([src], (_data, actions) => {
-			actions.down([[DIRTY], [RESOLVED]]);
-		});
-		const vals: unknown[] = [];
-		const unsub = d.subscribe((msgs) => {
-			for (const m of msgs) {
-				if (m[0] === DATA) vals.push(m[1]);
-			}
-		});
-		src.down([[DIRTY], [DATA, 1]]);
-		unsub();
-		expect(vals.length).toBe(0);
-	});
-});
diff --git a/packages/pure-ts/src/__tests__/core/versioning.test.ts b/packages/pure-ts/src/__tests__/core/versioning.test.ts
deleted file mode 100644
index 38a6fe70..00000000
--- a/packages/pure-ts/src/__tests__/core/versioning.test.ts
+++ /dev/null
@@ -1,427 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { batch } from "../../core/batch.js";
-import { registerBuiltins } from "../../core/config.js";
-import { DATA, DIRTY, RESOLVED } from "../../core/messages.js";
-import { describeNode } from "../../core/meta.js";
-import { GraphReFlyConfig, type NodeImpl, node } from "../../core/node.js";
-
-import {
-	advanceVersion,
-	createVersioning,
-	defaultHash,
-	isV1,
-	type V1,
-} from "../../core/versioning.js";
-import { Graph } from "../../graph/graph.js";
-
-// ---------------------------------------------------------------------------
-// Unit: versioning module
-// ---------------------------------------------------------------------------
-
-describe("createVersioning", () => {
-	it("V0: returns id + version 0", () => {
-		const v = createVersioning(0, undefined);
-		expect(v.id).toBeTypeOf("string");
-		expect(v.id.length).toBeGreaterThan(0);
-		expect(v.version).toBe(0);
-		expect("cid" in v).toBe(false);
-	});
-
-	it("V0: accepts custom id", () => {
-		const v = createVersioning(0, undefined, { id: "custom-id" });
-		expect(v.id).toBe("custom-id");
-	});
-
-	it("V1: returns id + version 0 + cid + prev null", () => {
-		const v = createVersioning(1, 42);
-		expect(v.id).toBeTypeOf("string");
-		expect(v.version).toBe(0);
-		expect(isV1(v)).toBe(true);
-		const v1 = v as V1;
-		expect(v1.cid).toBeTypeOf("string");
-		expect(v1.cid.length).toBe(16);
-		expect(v1.prev).toBeNull();
-	});
-
-	it("V1: cid is deterministic for same value", () => {
-		const a = createVersioning(1, { x: 1, y: 2 });
-		const b = createVersioning(1, { y: 2, x: 1 }); // different key order
-		expect((a as V1).cid).toBe((b as V1).cid);
-	});
-
-	it("V1: cid differs for different values", () => {
-		const a = createVersioning(1, 42);
-		const b = createVersioning(1, 43);
-		expect((a as V1).cid).not.toBe((b as V1).cid);
-	});
-});
-
-describe("advanceVersion", () => {
-	it("V0: increments version", () => {
-		const v = createVersioning(0, undefined);
-		advanceVersion(v, 1, defaultHash);
-		expect(v.version).toBe(1);
-		advanceVersion(v, 2, defaultHash);
-		expect(v.version).toBe(2);
-	});
-
-	it("V1: increments version and rotates cid → prev", () => {
-		const v = createVersioning(1, "hello") as V1;
-		const firstCid = v.cid;
-		advanceVersion(v, "world", defaultHash);
-		expect(v.version).toBe(1);
-		expect(v.prev).toBe(firstCid);
-		expect(v.cid).not.toBe(firstCid);
-	});
-});
-
-describe("defaultHash", () => {
-	it("produces 16 hex chars", () => {
-		expect(defaultHash(42)).toMatch(/^[0-9a-f]{16}$/);
-	});
-
-	it("is deterministic", () => {
-		expect(defaultHash([1, 2, 3])).toBe(defaultHash([1, 2, 3]));
-	});
-
-	it("sorts object keys", () => {
-		expect(defaultHash({ b: 2, a: 1 })).toBe(defaultHash({ a: 1, b: 2 }));
-	});
-});
-
-// ---------------------------------------------------------------------------
-// Integration: node with versioning
-// ---------------------------------------------------------------------------
-
-describe("node V0 versioning", () => {
-	it("state node has v with id and version 0", () => {
-		const s = node([], { versioning: 0, initial: 42 });
-		expect(s.v).toBeDefined();
-		expect(s.v!.id).toBeTypeOf("string");
-		expect(s.v!.version).toBe(0);
-	});
-
-	it("version increments on DATA", () => {
-		const s = node([], { versioning: 0, initial: 0 });
-		const unsub = s.subscribe(() => {});
-		s.down([[DATA, 1]]);
-		expect(s.v!.version).toBe(1);
-		s.down([[DATA, 2]]);
-		expect(s.v!.version).toBe(2);
-		unsub();
-	});
-
-	it("version does NOT increment on RESOLVED", () => {
-		const s = node([], { versioning: 0, initial: 0 });
-		const unsub = s.subscribe(() => {});
-		s.down([[DIRTY], [RESOLVED]]);
-		expect(s.v!.version).toBe(0);
-		unsub();
-	});
-
-	it("version increments in derived node on recompute", () => {
-		const a = node([], { name: "a", initial: 1 });
-		const b = node(
-			[a],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as number) * 2);
-			},
-			{ describeKind: "derived", name: "b", versioning: 0 },
-		);
-		const unsub = b.subscribe(() => {});
-		// Initial compute on subscribe: version is already 1
-		expect(b.v!.version).toBe(1);
-		a.down([[DIRTY], [DATA, 5]]);
-		expect(b.v!.version).toBe(2);
-		expect(b.cache).toBe(10);
-		unsub();
-	});
-
-	it("version does NOT increment when derived value unchanged (RESOLVED)", () => {
-		const a = node([], { name: "a", initial: 1 });
-		// derived always returns constant — emits RESOLVED after first DATA
-		const b = node(
-			[a],
-			(batchData, actions, ctx) => {
-				const _data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit(42);
-			},
-			{ describeKind: "derived", name: "b", versioning: 0 },
-		);
-		const unsub = b.subscribe(() => {});
-		// Initial compute: version 0 → 1 (first DATA)
-		expect(b.v!.version).toBe(1);
-		a.down([[DIRTY], [DATA, 2]]);
-		// Value unchanged (still 42) → RESOLVED, no version bump
-		expect(b.v!.version).toBe(1);
-		unsub();
-	});
-
-	it("v is undefined when versioning not enabled", () => {
-		const s = node([], { initial: 0 });
-		expect(s.v).toBeUndefined();
-	});
-
-	it("custom id is preserved", () => {
-		const s = node([], { versioning: 0, versioningId: "my-node-001", initial: 0 });
-		expect(s.v!.id).toBe("my-node-001");
-	});
-});
-
-describe("node V1 versioning", () => {
-	it("state node has cid and prev", () => {
-		const s = node([], { versioning: 1, initial: 42 });
-		expect(s.v).toBeDefined();
-		expect(isV1(s.v!)).toBe(true);
-		const v = s.v as V1;
-		expect(v.cid).toBeTypeOf("string");
-		expect(v.cid.length).toBe(16);
-		expect(v.prev).toBeNull();
-	});
-
-	it("cid changes and prev links on DATA", () => {
-		const s = node([], { versioning: 1, initial: "a" });
-		const initialCid = (s.v as V1).cid;
-
-		const unsub = s.subscribe(() => {});
-		s.down([[DATA, "b"]]);
-		const v = s.v as V1;
-		expect(v.version).toBe(1);
-		expect(v.cid).not.toBe(initialCid);
-		expect(v.prev).toBe(initialCid);
-		unsub();
-	});
-
-	it("linked history across multiple updates", () => {
-		const s = node([], { versioning: 1, initial: 0 });
-		const unsub = s.subscribe(() => {});
-		const cids: string[] = [(s.v as V1).cid];
-		for (let i = 1; i <= 3; i++) {
-			s.down([[DATA, i]]);
-			cids.push((s.v as V1).cid);
-			expect((s.v as V1).prev).toBe(cids[i - 1]);
-		}
-		// All cids should be unique
-		expect(new Set(cids).size).toBe(4);
-		unsub();
-	});
-
-	it("custom hash function", () => {
-		const customHash = (v: unknown) => `custom-${String(v)}`;
-		const s = node([], { versioning: 1, versioningHash: customHash, initial: 42 });
-		expect((s.v as V1).cid).toBe("custom-42");
-
-		const unsub = s.subscribe(() => {});
-		s.down([[DATA, 99]]);
-		expect((s.v as V1).cid).toBe("custom-99");
-		expect((s.v as V1).prev).toBe("custom-42");
-		unsub();
-	});
-});
-
-describe("versioning in batch", () => {
-	it("version advances once per DATA in batch", () => {
-		const s = node([], { versioning: 0, initial: 0 });
-		const unsub = s.subscribe(() => {});
-		batch(() => {
-			s.down([[DATA, 1]]);
-			s.down([[DATA, 2]]);
-		});
-		expect(s.v!.version).toBe(2);
-		expect(s.cache).toBe(2);
-		unsub();
-	});
-});
-
-describe("versioning in describeNode", () => {
-	it("V0 appears in describe output", () => {
-		const s = node([], { versioning: 0, name: "x", initial: 0 });
-		const d = describeNode(s);
-		expect(d.v).toBeDefined();
-		expect(d.v!.id).toBe(s.v!.id);
-		expect(d.v!.version).toBe(0);
-		expect(d.v!.cid).toBeUndefined();
-	});
-
-	it("V1 appears in describe output with cid and prev", () => {
-		const s = node([], { versioning: 1, name: "x", initial: 42 });
-		const d = describeNode(s);
-		expect(d.v).toBeDefined();
-		expect(d.v!.cid).toBeTypeOf("string");
-		expect(d.v!.prev).toBeNull();
-	});
-
-	it("no v field when versioning disabled", () => {
-		const s = node([], { name: "x", initial: 0 });
-		const d = describeNode(s);
-		expect(d.v).toBeUndefined();
-	});
-});
-
-// ---------------------------------------------------------------------------
-// Retroactive _applyVersioning + config-level defaults
-// ---------------------------------------------------------------------------
-
-describe("_applyVersioning — retroactive + monotonic upgrade", () => {
-	it("attaches V0 to a node that had no versioning", () => {
-		const s = node([], { initial: 42 }) as unknown as NodeImpl<number>;
-		expect(s.v).toBeUndefined();
-		s._applyVersioning(0);
-		expect(s.v).toBeDefined();
-		expect(s.v!.version).toBe(0);
-	});
-
-	it("upgrades V0 → V1, preserving id and version counter", () => {
-		const s = node([], { versioning: 0, initial: 42 }) as unknown as NodeImpl<number>;
-		const unsub = s.subscribe(() => {});
-		s.down([[DATA, 99]]);
-		const originalId = s.v!.id;
-		const originalVersion = s.v!.version;
-		expect(originalVersion).toBe(1);
-
-		s._applyVersioning(1);
-		expect(s.v!.id).toBe(originalId);
-		expect(s.v!.version).toBe(originalVersion);
-		expect(isV1(s.v!)).toBe(true);
-		expect((s.v as V1).cid).toBeTypeOf("string");
-		unsub();
-	});
-
-	it("is monotonic — V1 → V0 is a no-op (levels only go up)", () => {
-		const s = node([], { versioning: 1, initial: 42 }) as unknown as NodeImpl<number>;
-		const cidBefore = (s.v as V1).cid;
-		s._applyVersioning(0);
-		expect(isV1(s.v!)).toBe(true);
-		expect((s.v as V1).cid).toBe(cidBefore);
-	});
-});
-
-describe("config-level defaults — defaultVersioning + defaultHashFn", () => {
-	it("nodes inherit config.defaultVersioning when opts.versioning is omitted", () => {
-		const cfg = new GraphReFlyConfig({
-			onMessage: () => undefined,
-			onSubscribe: () => undefined,
-			defaultVersioning: 0,
-		});
-		registerBuiltins(cfg);
-		const s = node([], { config: cfg, initial: 1 });
-		expect(s.v).toBeDefined();
-		expect(s.v!.version).toBe(0);
-	});
-
-	it("nodes use config.defaultHashFn when opts.versioningHash is omitted", () => {
-		let customHashCalls = 0;
-		const customHash = (v: unknown): string => {
-			customHashCalls += 1;
-			return `cust-${String(v)}`;
-		};
-		const cfg = new GraphReFlyConfig({
-			onMessage: () => undefined,
-			onSubscribe: () => undefined,
-			defaultVersioning: 1,
-			defaultHashFn: customHash,
-		});
-		registerBuiltins(cfg);
-		const s = node([], { config: cfg, initial: 42 });
-		expect(customHashCalls).toBeGreaterThanOrEqual(1);
-		expect((s.v as V1).cid).toBe("cust-42");
-	});
-
-	it("per-node opts.versioning overrides config.defaultVersioning", () => {
-		const cfg = new GraphReFlyConfig({
-			onMessage: () => undefined,
-			onSubscribe: () => undefined,
-			defaultVersioning: 1,
-		});
-		registerBuiltins(cfg);
-		// Per-node opt-out at v0.
-		const s = node([], { config: cfg, versioning: 0, initial: 1 });
-		expect(s.v).toBeDefined();
-		expect(isV1(s.v!)).toBe(false);
-	});
-});
-
-describe("versioning with effect nodes", () => {
-	it("effect nodes can have V0 versioning (no auto-emit, so version stays 0)", () => {
-		const a = node([], { initial: 1 });
-		let called = 0;
-		// Use node() directly since effect() sugar doesn't accept extra opts
-		const e = node(
-			[a],
-			() => {
-				called++;
-			},
-			{ describeKind: "effect", versioning: 0 },
-		);
-		const unsub = e.subscribe(() => {});
-		// Effect runs once on initial connect
-		a.down([[DIRTY], [DATA, 2]]);
-		// Effect runs again on dep change
-		expect(called).toBe(2);
-		// Effects don't emit DATA, so version doesn't advance
-		expect(e.v!.version).toBe(0);
-		unsub();
-	});
-});
-
-// ---------------------------------------------------------------------------
-// 6.0: Graph.diff version-aware
-// ---------------------------------------------------------------------------
-
-describe("Graph.diff V0 optimization", () => {
-	it("skips value comparison when versions match", () => {
-		const nodeA = {
-			type: "state",
-			status: "settled",
-			value: { big: "object" },
-			deps: [],
-			meta: {},
-			v: { id: "x", version: 5 },
-		};
-		const a = { name: "g", nodes: { n: nodeA }, edges: [], subgraphs: [] };
-		const b = { name: "g", nodes: { n: { ...nodeA } }, edges: [], subgraphs: [] };
-		const result = Graph.diff(a, b);
-		expect(result.nodesChanged).toEqual([]);
-	});
-
-	it("detects value change when versions differ", () => {
-		const a = {
-			name: "g",
-			nodes: {
-				n: {
-					type: "state",
-					status: "settled",
-					value: 1,
-					deps: [],
-					meta: {},
-					v: { id: "x", version: 1 },
-				},
-			},
-			edges: [],
-			subgraphs: [],
-		};
-		const b = {
-			name: "g",
-			nodes: {
-				n: {
-					type: "state",
-					status: "settled",
-					value: 2,
-					deps: [],
-					meta: {},
-					v: { id: "x", version: 2 },
-				},
-			},
-			edges: [],
-			subgraphs: [],
-		};
-		const result = Graph.diff(a, b);
-		expect(result.nodesChanged).toHaveLength(1);
-		expect(result.nodesChanged[0].field).toBe("value");
-	});
-});
diff --git a/packages/pure-ts/src/__tests__/exports.test.ts b/packages/pure-ts/src/__tests__/exports.test.ts
deleted file mode 100644
index 350f88b3..00000000
--- a/packages/pure-ts/src/__tests__/exports.test.ts
+++ /dev/null
@@ -1,91 +0,0 @@
-/**
- * Smoke-test the substrate barrel exports (@graphrefly/pure-ts).
- *
- * Post-cleave A2: pure-ts exports core, graph, extra (substrate only).
- * Presentation exports (patterns, compat) moved to @graphrefly/graphrefly.
- * Presentation export tests moved to root src/__tests__/base/exports.test.ts.
- */
-import { describe, expect, it } from "vitest";
-import {
-	catchError,
-	combine,
-	combineLatest,
-	core,
-	DEFAULT_ACTOR,
-	debounce,
-	debounceTime,
-	extra,
-	flatMap,
-	GuardDenied,
-	graph,
-	map,
-	mergeMap,
-	policy,
-	rescue,
-	throttle,
-	throttleTime,
-	version,
-} from "../index.js";
-
-describe("graphrefly substrate (pure-ts)", () => {
-	it("exports version (D4: build-injected; source = dev sentinel)", () => {
-		// D4: `version` is build-time injected from package.json via the
-		// tsup `define` for `process.env.GRAPHREFLY_PKG_VERSION`. This
-		// suite runs the UNBUILT source (no define), so it sees the honest
-		// `"0.0.0-dev"` sentinel — never the misleading old `"0.0.0"`.
-		// The real semver is asserted against the built artifact instead.
-		expect(version).toBe("0.0.0-dev");
-	});
-
-	it("exports layer namespaces", () => {
-		expect(typeof core).toBe("object");
-		expect(typeof graph).toBe("object");
-		expect(typeof extra).toBe("object");
-		expect(typeof graph.Graph).toBe("function");
-		expect(typeof map).toBe("function");
-	});
-
-	it("exports core sugar helpers", () => {
-		expect(typeof core.pipe).toBe("function");
-		expect(typeof core.dynamicNode).toBe("function");
-		expect(typeof core.autoTrackNode).toBe("function");
-	});
-
-	it("exports reactive-log helpers from extra (Audit 1)", () => {
-		expect(typeof extra.reactiveLog).toBe("function");
-		expect(typeof extra.mergeReactiveLogs).toBe("function");
-		expect(typeof extra.NativeLogBackend).toBe("function");
-	});
-
-	it("exports storage three-layer surface from extra (Audit 4)", () => {
-		expect(typeof extra.memoryBackend).toBe("function");
-		expect(typeof extra.snapshotStorage).toBe("function");
-		expect(typeof extra.appendLogStorage).toBe("function");
-		expect(typeof extra.kvStorage).toBe("function");
-		expect(typeof extra.memorySnapshot).toBe("function");
-		expect(typeof extra.memoryAppendLog).toBe("function");
-		expect(typeof extra.memoryKv).toBe("function");
-		expect(typeof extra.jsonCodec).toBe("object");
-	});
-
-	it("RxJS alias identity (substrate operators)", () => {
-		expect(combineLatest).toBe(combine);
-		expect(debounceTime).toBe(debounce);
-		expect(throttleTime).toBe(throttle);
-		expect(catchError).toBe(rescue);
-		expect(flatMap).toBe(mergeMap);
-	});
-
-	it("exports actor and guard primitives", () => {
-		expect(DEFAULT_ACTOR.type).toBe("system");
-		expect(typeof policy).toBe("function");
-		expect(GuardDenied.name).toBe("GuardDenied");
-		const err = new GuardDenied({
-			actor: DEFAULT_ACTOR,
-			action: "write",
-			nodeName: "n::x",
-		});
-		expect(err.node).toBe("n::x");
-		expect(err.nodeName).toBe("n::x");
-	});
-});
diff --git a/packages/pure-ts/src/__tests__/extra/edge-cases.test.ts b/packages/pure-ts/src/__tests__/extra/edge-cases.test.ts
deleted file mode 100644
index 223dde10..00000000
--- a/packages/pure-ts/src/__tests__/extra/edge-cases.test.ts
+++ /dev/null
@@ -1,611 +0,0 @@
-/**
- * Edge-case tests for operators — P0 (data-loss) and P1 (correctness).
- * Cross-referenced from docs/batch-review/batch-7.md.
- */
-
-import { afterEach, describe, expect, it, vi } from "vitest";
-import { batch } from "../../core/batch.js";
-import type { Messages } from "../../core/messages.js";
-import { COMPLETE, DATA, DIRTY, ERROR } from "../../core/messages.js";
-import { node } from "../../core/node.js";
-
-import {
-	combine,
-	concat,
-	concatMap,
-	debounce,
-	exhaustMap,
-	filter,
-	map,
-	merge,
-	mergeMap,
-	switchMap,
-	throttle,
-	timeout,
-} from "../../extra/operators/index.js";
-import { collect } from "../test-helpers.js";
-
-function msgs(batches: unknown[][]): unknown[][] {
-	return batches.flat() as unknown[][];
-}
-
-function dataValues(batches: unknown[][]): unknown[] {
-	return msgs(batches)
-		.filter((m) => (m as unknown[])[0] === DATA)
-		.map((m) => (m as unknown[])[1]);
-}
-
-function hasMsg(batches: unknown[][], type: symbol): boolean {
-	return msgs(batches).some((m) => (m as unknown[])[0] === type);
-}
-
-afterEach(() => {
-	vi.useRealTimers();
-});
-
-// --- P0: Data-loss edge cases ---
-
-describe("P0: debounce flush-on-complete", () => {
-	it("flushes pending value on source COMPLETE", () => {
-		vi.useFakeTimers();
-		const s = node([], { initial: 0 });
-		const d = debounce(s, 100);
-		const { batches, unsub } = collect(d);
-
-		// Emit a value — debounce defers it
-		s.down([[DIRTY]]);
-		s.down([[DATA, 42]]);
-
-		// No data yet (debounced)
-		expect(dataValues(batches)).toEqual([]);
-
-		// Source completes before debounce timer fires
-		s.down([[COMPLETE]]);
-
-		// Pending value should be flushed
-		expect(dataValues(batches)).toEqual([42]);
-		expect(hasMsg(batches, COMPLETE)).toBe(true);
-		unsub();
-	});
-
-	it("cancels pending on upstream ERROR", () => {
-		vi.useFakeTimers();
-		const s = node([], { initial: 0 });
-		const d = debounce(s, 100);
-		const { batches, unsub } = collect(d);
-
-		s.down([[DIRTY]]);
-		s.down([[DATA, 42]]);
-		s.down([[ERROR, new Error("fail")]]);
-
-		// Pending is discarded, ERROR forwarded
-		expect(dataValues(batches)).toEqual([]);
-		expect(hasMsg(batches, ERROR)).toBe(true);
-		unsub();
-	});
-
-	it("forwards upstream COMPLETE even without pending", () => {
-		vi.useFakeTimers();
-		const s = node([], { initial: 0 });
-		const d = debounce(s, 100);
-		const { batches, unsub } = collect(d);
-
-		s.down([[COMPLETE]]);
-		expect(hasMsg(batches, COMPLETE)).toBe(true);
-		unsub();
-	});
-
-	it("emits each debounced value in sequence", () => {
-		vi.useFakeTimers();
-		const s = node([], { initial: 0 });
-		const d = debounce(s, 50);
-		const { batches, unsub } = collect(d);
-
-		s.down([[DIRTY]]);
-		s.down([[DATA, 1]]);
-		vi.advanceTimersByTime(60);
-		s.down([[DIRTY]]);
-		s.down([[DATA, 2]]);
-		vi.advanceTimersByTime(60);
-
-		expect(dataValues(batches)).toEqual([1, 2]);
-		unsub();
-	});
-});
-
-describe("P0: throttle COMPLETE/ERROR forwarding", () => {
-	it("forwards upstream COMPLETE", () => {
-		vi.useFakeTimers();
-		const s = node([], { initial: 0 });
-		const t = throttle(s, 100);
-		const { batches, unsub } = collect(t);
-
-		s.down([[COMPLETE]]);
-		expect(hasMsg(batches, COMPLETE)).toBe(true);
-		unsub();
-	});
-
-	it("forwards upstream ERROR", () => {
-		vi.useFakeTimers();
-		const s = node([], { initial: 0 });
-		const t = throttle(s, 100);
-		const { batches, unsub } = collect(t);
-
-		s.down([[ERROR, new Error("x")]]);
-		expect(hasMsg(batches, ERROR)).toBe(true);
-		unsub();
-	});
-});
-
-describe("P0: throttle trailing-COMPLETE flushes pending", () => {
-	// /qa F3 (2026-05-12): regression test for the trailing-COMPLETE flush
-	// behavior added in /qa m21. GraphReFly intentionally diverges from
-	// RxJS (which drops trailing pending on COMPLETE) — we flush for
-	// symmetry with debounce's live-COMPLETE behavior and with throttle's
-	// own Dead-source branch. See cross-language-notes divergence entry.
-	it("flushes trailing pending value before COMPLETE", () => {
-		vi.useFakeTimers();
-		const s = node<number>([], { initial: 0 });
-		const t = throttle(s, 100, { trailing: true });
-		const { batches, unsub } = collect(t);
-
-		// First value goes through (leading edge)
-		s.down([[DATA, 1]]);
-		// Second value within the window becomes pending
-		s.down([[DATA, 2]]);
-		// Source completes while pending=2 is waiting for trailing timer
-		s.down([[COMPLETE]]);
-
-		// The pending trailing value should have been flushed before COMPLETE
-		const values = dataValues(batches);
-		expect(values).toContain(2);
-		expect(hasMsg(batches, COMPLETE)).toBe(true);
-		unsub();
-	});
-
-	it("no trailing flush when nothing is pending", () => {
-		vi.useFakeTimers();
-		const s = node<number>([], { initial: 0 });
-		const t = throttle(s, 100, { trailing: true });
-		const { batches, unsub } = collect(t);
-
-		// Emit and let the window expire
-		s.down([[DATA, 1]]);
-		vi.advanceTimersByTime(200);
-		// Now complete with nothing pending
-		s.down([[COMPLETE]]);
-
-		const values = dataValues(batches);
-		// initial:0 goes through as leading, then 1 goes through as leading
-		expect(values).toEqual([0, 1]);
-		expect(hasMsg(batches, COMPLETE)).toBe(true);
-		unsub();
-	});
-});
-
-describe("P0: timeout timer cleanup", () => {
-	it("clears timer when source completes before timeout", () => {
-		vi.useFakeTimers();
-		const s = node([], { initial: 0 });
-		const t = timeout(s, 100);
-		const { batches, unsub } = collect(t);
-
-		// Source completes immediately
-		s.down([[COMPLETE]]);
-
-		// Advance past timeout — should NOT fire ERROR
-		vi.advanceTimersByTime(200);
-		expect(hasMsg(batches, ERROR)).toBe(false);
-		expect(hasMsg(batches, COMPLETE)).toBe(true);
-		unsub();
-	});
-
-	it("clears timer when source errors before timeout", () => {
-		vi.useFakeTimers();
-		const s = node([], { initial: 0 });
-		const t = timeout(s, 100);
-		const { batches, unsub } = collect(t);
-
-		s.down([[ERROR, new Error("upstream")]]);
-		vi.advanceTimersByTime(200);
-
-		// Only one ERROR (upstream), not two (no timeout ERROR)
-		const errors = msgs(batches).filter((m) => (m as unknown[])[0] === ERROR);
-		expect(errors.length).toBe(1);
-		unsub();
-	});
-
-	it("resets timer on each DATA emission", async () => {
-		vi.useFakeTimers();
-		const s = node([], { initial: 0 });
-		const t = timeout(s, 100);
-		const { batches, unsub } = collect(t);
-
-		// Emit at t=50, resets timer
-		vi.advanceTimersByTime(50);
-		s.down([[DIRTY]]);
-		s.down([[DATA, 1]]);
-
-		// Emit at t=100 (50ms since last), resets again
-		vi.advanceTimersByTime(50);
-		s.down([[DIRTY]]);
-		s.down([[DATA, 2]]);
-
-		// Advance to t=150 (50ms since last) — timer still has 50ms left
-		vi.advanceTimersByTime(50);
-		expect(hasMsg(batches, ERROR)).toBe(false);
-
-		// Advance to t=210 (110ms since last DATA) — timeout fires
-		vi.advanceTimersByTime(60);
-		expect(hasMsg(batches, ERROR)).toBe(true);
-		unsub();
-	});
-});
-
-describe("P0: merge ALL-complete semantics", () => {
-	it("completes only after ALL sources complete", () => {
-		const s1 = node([], { initial: 1 });
-		const s2 = node([], { initial: 2 });
-		const m = merge(s1, s2);
-		const { batches, unsub } = collect(m);
-
-		s1.down([[COMPLETE]]);
-		expect(hasMsg(batches, COMPLETE)).toBe(false);
-
-		s2.down([[COMPLETE]]);
-		expect(hasMsg(batches, COMPLETE)).toBe(true);
-		unsub();
-	});
-
-	it("error from one source propagates immediately", () => {
-		const s1 = node([], { initial: 1 });
-		const s2 = node([], { initial: 2 });
-		const m = merge(s1, s2);
-		const { batches, unsub } = collect(m);
-
-		s1.down([[ERROR, new Error("fail")]]);
-		expect(hasMsg(batches, ERROR)).toBe(true);
-		unsub();
-	});
-
-	it("forwards values from each source independently", () => {
-		const s1 = node([], { initial: 0 });
-		const s2 = node([], { initial: 0 });
-		const m = merge(s1, s2);
-		const { batches, unsub } = collect(m);
-
-		batch(() => {
-			s1.down([[DIRTY]]);
-			s1.down([[DATA, 10]]);
-		});
-		batch(() => {
-			s2.down([[DIRTY]]);
-			s2.down([[DATA, 20]]);
-		});
-
-		const values = dataValues(batches);
-		expect(values).toContain(10);
-		expect(values).toContain(20);
-		unsub();
-	});
-});
-
-// --- P1: Correctness edge cases ---
-
-describe("P1: switchMap outer-complete waits for inner", () => {
-	it("waits for active inner to complete before emitting COMPLETE", () => {
-		const outer = node([], { initial: 0 });
-		const inner = node([], { initial: 10 });
-		const out = switchMap(outer, () => inner);
-		const { batches, unsub } = collect(out);
-
-		// Outer completes while inner is still active
-		outer.down([[COMPLETE]]);
-		expect(hasMsg(batches, COMPLETE)).toBe(false);
-
-		// Inner completes
-		inner.down([[COMPLETE]]);
-		expect(hasMsg(batches, COMPLETE)).toBe(true);
-		unsub();
-	});
-
-	it("error in inner propagates to output", () => {
-		const outer = node([], { initial: 0 });
-		const inner = node([], { initial: 10 });
-		const out = switchMap(outer, () => inner);
-		const { batches, unsub } = collect(out);
-
-		inner.down([[ERROR, new Error("inner-fail")]]);
-		expect(hasMsg(batches, ERROR)).toBe(true);
-		unsub();
-	});
-});
-
-describe("P1: concatMap inner error propagation", () => {
-	it("inner error forwards to output", () => {
-		const outer = node([], { initial: 0 });
-		const inner = node([], { initial: 10 });
-		const out = concatMap(outer, () => inner);
-		const { batches, unsub } = collect(out);
-
-		inner.down([[ERROR, new Error("inner-err")]]);
-		expect(hasMsg(batches, ERROR)).toBe(true);
-		unsub();
-	});
-});
-
-describe("P1: exhaustMap inner error propagation", () => {
-	it("inner error forwards to output", () => {
-		const outer = node([], { initial: 0 });
-		const inner = node([], { initial: 10 });
-		const out = exhaustMap(outer, () => inner);
-		const { batches, unsub } = collect(out);
-
-		inner.down([[ERROR, new Error("inner-err")]]);
-		expect(hasMsg(batches, ERROR)).toBe(true);
-		unsub();
-	});
-});
-
-// R2.7.1 empty-source COMPLETE forwarding for the *Map family.
-// Surfaced 2026-05-20 by `packages/parity-tests/scenarios/operators/higher-order.test.ts`
-// after DS-2.7.A made terminal-only no longer settle the first-run gate by
-// default. switchMap/exhaustMap/concatMap/mergeMap each opt in via
-// `terminalAsRealInput: true` so an outer that COMPLETEs without any prior
-// DATA still propagates COMPLETE downstream (active inner state separately
-// gates the actual emit in each operator's fn body).
-describe("R2.7.1: *Map empty-source COMPLETE forwarding", () => {
-	it("switchMap forwards COMPLETE when outer completes with no DATA emitted", () => {
-		const outer = node<number>([]);
-		const innerProto = node<number>([]);
-		const out = switchMap(outer, () => innerProto);
-		const { batches, unsub } = collect(out);
-
-		outer.down([[COMPLETE]]);
-		expect(hasMsg(batches, COMPLETE)).toBe(true);
-		unsub();
-	});
-
-	it("exhaustMap forwards COMPLETE when outer completes with no DATA emitted", () => {
-		const outer = node<number>([]);
-		const innerProto = node<number>([]);
-		const out = exhaustMap(outer, () => innerProto);
-		const { batches, unsub } = collect(out);
-
-		outer.down([[COMPLETE]]);
-		expect(hasMsg(batches, COMPLETE)).toBe(true);
-		unsub();
-	});
-
-	it("concatMap forwards COMPLETE when outer completes with no DATA emitted", () => {
-		const outer = node<number>([]);
-		const innerProto = node<number>([]);
-		const out = concatMap(outer, () => innerProto);
-		const { batches, unsub } = collect(out);
-
-		outer.down([[COMPLETE]]);
-		expect(hasMsg(batches, COMPLETE)).toBe(true);
-		unsub();
-	});
-
-	it("mergeMap forwards COMPLETE when outer completes with no DATA emitted", () => {
-		const outer = node<number>([]);
-		const innerProto = node<number>([]);
-		const out = mergeMap(outer, () => innerProto);
-		const { batches, unsub } = collect(out);
-
-		outer.down([[COMPLETE]]);
-		expect(hasMsg(batches, COMPLETE)).toBe(true);
-		unsub();
-	});
-
-	// /qa follow-on (2026-05-21): close the ERROR-on-empty-outer coverage gap.
-	// The R2.7.1 opt-in releases the gate for *any* terminal, so source ERROR
-	// must also forward downstream when no DATA ever fired. Without this pin
-	// an ERROR-only path could silently regress (the *Map fn body's
-	// `ctx.terminalDeps[0] != null && ctx.terminalDeps[0] !== true` branch).
-	it("switchMap forwards ERROR when outer ERRORs with no DATA emitted", () => {
-		const outer = node<number>([]);
-		const innerProto = node<number>([]);
-		const out = switchMap(outer, () => innerProto);
-		const { batches, unsub } = collect(out);
-
-		outer.down([[ERROR, new Error("outer-fail")]]);
-		expect(hasMsg(batches, ERROR)).toBe(true);
-		unsub();
-	});
-});
-
-describe("P1: diamond glitch-freedom", () => {
-	it("combine never exposes intermediate state in a diamond", () => {
-		const root = node([], { initial: 1 });
-		const left = map(root, (x) => (x as number) * 2);
-		const right = map(root, (x) => (x as number) + 10);
-		const joined = combine(left, right);
-
-		const snapshots: unknown[] = [];
-		const unsub = joined.subscribe((batchMsgs: Messages) => {
-			for (const m of batchMsgs) {
-				if (m[0] === DATA) snapshots.push(m[1]);
-			}
-		});
-
-		// Initial: left=2, right=11
-		expect(snapshots.length).toBeGreaterThanOrEqual(1);
-		const initial = snapshots[snapshots.length - 1] as unknown[];
-		expect(initial).toEqual([2, 11]);
-
-		// Update root to 5 → left=10, right=15
-		snapshots.length = 0;
-		batch(() => {
-			root.down([[DIRTY]]);
-			root.down([[DATA, 5]]);
-		});
-
-		// Should only see [10, 15], never [10, 11] or [2, 15]
-		for (const snap of snapshots) {
-			const [l, r] = snap as [number, number];
-			expect(l).toBe((r - 10) * 2); // invariant: left = (right - 10) * 2
-		}
-
-		if (snapshots.length > 0) {
-			expect(snapshots[snapshots.length - 1]).toEqual([10, 15]);
-		}
-		unsub();
-	});
-});
-
-describe("P1: reentrancy safety", () => {
-	it("subscriber modifying state during emission produces consistent final value", () => {
-		const s = node([], { initial: 0 });
-		const d = node(
-			[s],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit(data[0] as number);
-			},
-			{ describeKind: "derived" },
-		);
-		const values: number[] = [];
-
-		d.subscribe((batchMsgs: Messages) => {
-			for (const m of batchMsgs) {
-				if (m[0] === DATA) {
-					const v = m[1] as number;
-					values.push(v);
-					// Reentrant: set state again during emission
-					if (v === 1) {
-						batch(() => {
-							s.down([[DIRTY]]);
-							s.down([[DATA, 2]]);
-						});
-					}
-				}
-			}
-		});
-
-		batch(() => {
-			s.down([[DIRTY]]);
-			s.down([[DATA, 1]]);
-		});
-
-		// Should eventually settle at 2
-		expect(d.cache).toBe(2);
-		expect(values).toContain(2);
-	});
-
-	it("self-unsubscribe during emission does not crash", () => {
-		const s = node([], { initial: 0 });
-		let unsub: (() => void) | undefined;
-
-		unsub = s.subscribe((batchMsgs: Messages) => {
-			for (const m of batchMsgs) {
-				if (m[0] === DATA) {
-					// Unsubscribe during emission
-					unsub?.();
-				}
-			}
-		});
-
-		// Should not throw
-		expect(() => {
-			batch(() => {
-				s.down([[DIRTY]]);
-				s.down([[DATA, 1]]);
-			});
-		}).not.toThrow();
-	});
-});
-
-describe("P1: combine edge cases", () => {
-	it("error from any source propagates", () => {
-		const s1 = node([], { initial: 1 });
-		const s2 = node([], { initial: 2 });
-		const c = combine(s1, s2);
-		const { batches, unsub } = collect(c);
-
-		s1.down([[ERROR, new Error("boom")]]);
-		expect(hasMsg(batches, ERROR)).toBe(true);
-		unsub();
-	});
-
-	it("single source combine works", () => {
-		const s = node([], { initial: 42 });
-		const c = combine(s);
-		const { batches, unsub } = collect(c);
-
-		expect(dataValues(batches).length).toBeGreaterThanOrEqual(1);
-		const last = dataValues(batches).pop() as unknown[];
-		expect(last).toEqual([42]);
-		unsub();
-	});
-});
-
-describe("P1: concat error handling", () => {
-	it("error from first source stops chain", () => {
-		const s1 = node([], { initial: 1 });
-		const s2 = node([], { initial: 2 });
-		const c = concat(s1, s2);
-		const { batches, unsub } = collect(c);
-
-		s1.down([[ERROR, new Error("first-err")]]);
-		expect(hasMsg(batches, ERROR)).toBe(true);
-		// s2 should never emit
-		unsub();
-	});
-});
-
-describe("P1: filter does not dedup", () => {
-	it("passes consecutive different values through", () => {
-		const s = node([], { initial: 0 });
-		const f = filter(s, () => true);
-		const { batches, unsub } = collect(f);
-
-		batch(() => {
-			s.down([[DIRTY]]);
-			s.down([[DATA, 1]]);
-		});
-		batch(() => {
-			s.down([[DIRTY]]);
-			s.down([[DATA, 2]]);
-		});
-
-		const values = dataValues(batches);
-		expect(values).toContain(1);
-		expect(values).toContain(2);
-		unsub();
-	});
-});
-
-describe("P1: batch + diamond coalescing", () => {
-	it("batch coalesces to final value", () => {
-		const s = node([], { initial: 0 });
-		const d = node(
-			[s],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit(data[0] as number);
-			},
-			{ describeKind: "derived" },
-		);
-		const { batches, unsub } = collect(d);
-
-		batch(() => {
-			s.down([[DIRTY]]);
-			s.down([[DATA, 1]]);
-			s.down([[DIRTY]]);
-			s.down([[DATA, 2]]);
-			s.down([[DIRTY]]);
-			s.down([[DATA, 3]]);
-		});
-
-		// Should see final value 3 (may see intermediates, but last must be 3)
-		const values = dataValues(batches);
-		expect(values[values.length - 1]).toBe(3);
-		unsub();
-	});
-});
diff --git a/packages/pure-ts/src/__tests__/extra/operator-protocol-harness.ts b/packages/pure-ts/src/__tests__/extra/operator-protocol-harness.ts
deleted file mode 100644
index 49ad5cc1..00000000
--- a/packages/pure-ts/src/__tests__/extra/operator-protocol-harness.ts
+++ /dev/null
@@ -1,89 +0,0 @@
-/**
- * Helpers for operator tests that assert GRAPHREFLY-SPEC §1 message ordering and lifecycle.
- */
-import type { Message, Messages } from "../../core/messages.js";
-import { DATA, DIRTY, RESOLVED, START } from "../../core/messages.js";
-import { defaultConfig, type Node } from "../../core/node.js";
-
-export type ProtocolCapture = {
-	readonly batches: Messages[];
-	unsub(): void;
-	/** All messages in subscription order (flattened batches). */
-	flat(): Message[];
-};
-
-/**
- * Records each `subscribe` callback invocation as one batch.
- *
- * The §2.2 handshake (`[[START]]`, and the cached-value `[[DATA, v]]` that
- * immediately follows when the node has a cached value) is filtered out —
- * it carries no wave-state content and would pollute ordering assertions.
- * Messages from the first-subscriber activation cascade (fn runs, operator
- * emissions, terminal signals) are captured normally.
- */
-export function subscribeProtocol(node: Node<unknown>): ProtocolCapture {
-	const batches: Messages[] = [];
-	let expectHandshakeData = false;
-	const unsub = node.subscribe((msgs) => {
-		// --- Handshake filtering (handles both split and combined batches) ---
-		// Split case (inside batch): [[START]] then [[DATA, v]] as separate callbacks.
-		// Combined case (outside batch): [[START], [DATA, v]] in one callback.
-		if (msgs[0][0] === START) {
-			// Strip START and any paired handshake DATA from the batch.
-			const rest = msgs.filter((m) => defaultConfig.messageTier(m[0]) > 0);
-			if (rest.length === 0) {
-				// Pure [[START]] — flag so a follow-up [[DATA, v]] is also dropped.
-				expectHandshakeData = true;
-				return;
-			}
-			if (rest.length === 1 && rest[0][0] === DATA) {
-				// Combined [[START], [DATA, v]] — drop the handshake DATA.
-				return;
-			}
-			// START mixed with non-handshake messages — keep the rest.
-			batches.push([...rest] as unknown as Messages);
-			return;
-		}
-		// Handshake cached-value DATA — drop when it immediately follows
-		// a split START. Any other sequence is a real post-handshake message.
-		if (expectHandshakeData) {
-			expectHandshakeData = false;
-			if (msgs.length === 1 && msgs[0][0] === DATA) return;
-		}
-		batches.push([...msgs] as unknown as Messages);
-	});
-	return {
-		batches,
-		unsub,
-		flat() {
-			return batches.flat() as Message[];
-		},
-	};
-}
-
-/** True if some batch lists DIRTY before the first DATA in that same batch. */
-export function batchHasDirtyBeforeData(batches: readonly Messages[]): boolean {
-	for (const batch of batches) {
-		const types = batch.map((m) => m[0]);
-		const dirtyIdx = types.indexOf(DIRTY);
-		const dataIdx = types.indexOf(DATA);
-		if (dirtyIdx >= 0 && dataIdx >= 0 && dirtyIdx < dataIdx) return true;
-	}
-	return false;
-}
-
-/**
- * True if the first `DIRTY` appears before the first `DATA` or `RESOLVED` when flattening
- * all subscription callbacks in order (two-phase often splits across batches).
- */
-export function globalDirtyBeforePhase2(flat: readonly Message[]): boolean {
-	const types = flat.map((m) => m[0]);
-	const dirtyIdx = types.indexOf(DIRTY);
-	const phase2Idx = types.findIndex((t) => t === DATA || t === RESOLVED);
-	return dirtyIdx >= 0 && phase2Idx >= 0 && dirtyIdx < phase2Idx;
-}
-
-/** True if any recorded message is RESOLVED. */
-export function sawResolved(batches: readonly Messages[]): boolean {
-	return batches.some((b) => b.some((m) => m[0] === RESOLVED));
-}
diff --git a/packages/pure-ts/src/__tests__/extra/operator-protocol-matrix.test.ts b/packages/pure-ts/src/__tests__/extra/operator-protocol-matrix.test.ts
deleted file mode 100644
index c13ee2b8..00000000
--- a/packages/pure-ts/src/__tests__/extra/operator-protocol-matrix.test.ts
+++ /dev/null
@@ -1,1102 +0,0 @@
-/**
- * Regression: operator-level protocol and lifecycle vs GRAPHREFLY-SPEC §1.3 (two-phase, RESOLVED, subscriptions).
- */
-import { afterEach, describe, expect, it, vi } from "vitest";
-import type { Message, Messages } from "../../core/messages.js";
-import { COMPLETE, DATA, DIRTY, ERROR } from "../../core/messages.js";
-import type { Node } from "../../core/node.js";
-import { node } from "../../core/node.js";
-
-import {
-	audit,
-	buffer,
-	bufferCount,
-	bufferTime,
-	catchError,
-	combine,
-	combineLatest,
-	concat,
-	concatMap,
-	debounce,
-	debounceTime,
-	delay,
-	distinctUntilChanged,
-	elementAt,
-	exhaustMap,
-	filter,
-	find,
-	first,
-	flatMap,
-	interval,
-	last,
-	map,
-	merge,
-	mergeMap,
-	pairwise,
-	pausable,
-	race,
-	reduce,
-	repeat,
-	rescue,
-	sample,
-	scan,
-	skip,
-	switchMap,
-	take,
-	takeUntil,
-	takeWhile,
-	tap,
-	throttle,
-	throttleTime,
-	timeout,
-	valve,
-	window,
-	windowCount,
-	windowTime,
-	withLatestFrom,
-	zip,
-} from "../../extra/operators/index.js";
-import {
-	globalDirtyBeforePhase2,
-	sawResolved,
-	subscribeProtocol,
-} from "./operator-protocol-harness.js";
-
-function assertDirtyBeforeDataOnTwoPhase(node: Node<unknown>, push: () => void): void {
-	const cap = subscribeProtocol(node);
-	push();
-	try {
-		expect(globalDirtyBeforePhase2(cap.flat())).toBe(true);
-	} finally {
-		cap.unsub();
-	}
-}
-
-/** Second push uses a distinct value so sinks get DATA, not only RESOLVED (same cached output). */
-function assertReconnectSeesData(
-	build: () => { source: Node<number>; out: Node<unknown>; pushSecond?: () => void },
-): void {
-	const { source, out, pushSecond } = build();
-	const a = subscribeProtocol(out);
-	source.down([[DATA, 1]]);
-	expect(a.flat().some((m) => m[0] === DATA)).toBe(true);
-	a.unsub();
-	const b = subscribeProtocol(out);
-	(pushSecond ?? (() => source.down([[DIRTY], [DATA, 99]])))();
-	expect(b.flat().some((m) => m[0] === DATA)).toBe(true);
-	b.unsub();
-}
-
-describe("Tier 1 operator protocol matrix", () => {
-	describe("map", () => {
-		// Regression: GRAPHREFLY-SPEC §1.3.1 — DIRTY precedes DATA/RESOLVED in two-phase push.
-		it("DIRTY precedes DATA when source uses two-phase down", () => {
-			const s = node([], { initial: 0 });
-			const out = map(s, (n) => (n as number) * 2);
-			assertDirtyBeforeDataOnTwoPhase(out, () => s.down([[DIRTY], [DATA, 3]]));
-		});
-
-		// Regression: GRAPHREFLY-SPEC §1.3.3 — RESOLVED when recomputed value unchanged.
-		it("emits RESOLVED when projected value is unchanged", () => {
-			const s = node([], { initial: 2 });
-			const out = map(s, (n) => (n as number) % 2);
-			const cap = subscribeProtocol(out);
-			s.down([[DATA, 2]]);
-			s.down([[DIRTY], [DATA, 4]]);
-			expect(sawResolved(cap.batches)).toBe(true);
-			cap.unsub();
-		});
-
-		// Regression: GRAPHREFLY-SPEC §2 — subscribe lifecycle; operators reset inner state on teardown where applicable.
-		it("second subscription receives later DATA after unsubscribe", () => {
-			assertReconnectSeesData(() => {
-				const s = node([], { initial: 0 });
-				const out = map(s, (n) => (n as number) + 1);
-				return {
-					source: s,
-					out,
-					pushSecond: () => s.down([[DATA, 5]]),
-				};
-			});
-		});
-	});
-
-	describe("filter", () => {
-		it("DIRTY precedes DATA when source uses two-phase down", () => {
-			const s = node([], { initial: 0 });
-			const out = filter(s, (n) => (n as number) > -1);
-			assertDirtyBeforeDataOnTwoPhase(out, () => s.down([[DIRTY], [DATA, 3]]));
-		});
-
-		it("emits RESOLVED when filtered output value repeats", () => {
-			const s = node([], { initial: 1 });
-			const out = filter(s, (n) => (n as number) % 2 === 1);
-			const cap = subscribeProtocol(out);
-			s.down([[DATA, 1]]);
-			s.down([[DIRTY], [DATA, 3]]);
-			expect(sawResolved(cap.batches)).toBe(true);
-			cap.unsub();
-		});
-
-		it("second subscription receives later DATA after unsubscribe", () => {
-			assertReconnectSeesData(() => {
-				const s = node([], { initial: 0 });
-				const out = filter(s, (n) => (n as number) >= 0);
-				return { source: s, out, pushSecond: () => s.down([[DATA, 2]]) };
-			});
-		});
-	});
-
-	describe("tap", () => {
-		it("DIRTY precedes DATA when source uses two-phase down", () => {
-			const s = node([], { initial: 0 });
-			const out = tap(s, () => undefined);
-			assertDirtyBeforeDataOnTwoPhase(out, () => s.down([[DIRTY], [DATA, 3]]));
-		});
-
-		it("emits RESOLVED when upstream value maps to same output via following map semantics", () => {
-			const s = node([], { initial: 2 });
-			const out = tap(
-				map(s, (n) => (n as number) % 2),
-				() => undefined,
-			);
-			const cap = subscribeProtocol(out);
-			s.down([[DATA, 2]]);
-			s.down([[DIRTY], [DATA, 4]]);
-			expect(sawResolved(cap.batches)).toBe(true);
-			cap.unsub();
-		});
-
-		it("second subscription receives later DATA after unsubscribe", () => {
-			assertReconnectSeesData(() => {
-				const s = node([], { initial: 0 });
-				const out = tap(s, () => undefined);
-				return { source: s, out, pushSecond: () => s.down([[DATA, 2]]) };
-			});
-		});
-	});
-
-	describe("scan", () => {
-		it("DIRTY precedes DATA when source uses two-phase down", () => {
-			const s = node([], { initial: 0 });
-			const out = scan(s, (a, x) => a + (x as number), 0);
-			assertDirtyBeforeDataOnTwoPhase(out, () => s.down([[DIRTY], [DATA, 2]]));
-		});
-
-		it("may emit RESOLVED when accumulator unchanged (same protocol as derived nodes)", () => {
-			const s = node([], { initial: 0 });
-			const out = scan(s, (_a, x) => (x as number) % 2, 0);
-			const cap = subscribeProtocol(out);
-			s.down([[DATA, 2]]);
-			s.down([[DIRTY], [DATA, 4]]);
-			expect(sawResolved(cap.batches)).toBe(true);
-			cap.unsub();
-		});
-
-		it("second subscription receives later DATA after unsubscribe", () => {
-			assertReconnectSeesData(() => {
-				const s = node([], { resubscribable: true, initial: 0 });
-				const out = scan(s, (a, x) => a + (x as number), 0);
-				return { source: s, out };
-			});
-		});
-	});
-
-	describe("take", () => {
-		it("DIRTY precedes DATA when source uses two-phase down", () => {
-			const s = node([], { initial: 0 });
-			const out = take(s, 5);
-			assertDirtyBeforeDataOnTwoPhase(out, () => s.down([[DIRTY], [DATA, 1]]));
-		});
-
-		it("emits RESOLVED when further DATA would repeat current output before take limit", () => {
-			const s = node([], { initial: 1 });
-			const out = take(
-				map(s, (n) => (n as number) % 2),
-				3,
-			);
-			const cap = subscribeProtocol(out);
-			s.down([[DATA, 2]]);
-			s.down([[DIRTY], [DATA, 4]]);
-			expect(sawResolved(cap.batches)).toBe(true);
-			cap.unsub();
-		});
-
-		it("second subscription receives later DATA after unsubscribe", () => {
-			assertReconnectSeesData(() => {
-				const s = node([], { resubscribable: true, initial: 0 });
-				const out = take(s, 10);
-				return { source: s, out };
-			});
-		});
-	});
-
-	describe("skip", () => {
-		it("DIRTY precedes DATA when source uses two-phase down", () => {
-			const s = node([], { initial: 0 });
-			const out = skip(s, 0);
-			assertDirtyBeforeDataOnTwoPhase(out, () => s.down([[DIRTY], [DATA, 1]]));
-		});
-
-		it("forwards RESOLVED when inner mapped value unchanged", () => {
-			const s = node([], { initial: 2 });
-			const out = skip(
-				map(s, (n) => (n as number) % 2),
-				0,
-			);
-			const cap = subscribeProtocol(out);
-			s.down([[DATA, 2]]);
-			s.down([[DIRTY], [DATA, 4]]);
-			expect(sawResolved(cap.batches)).toBe(true);
-			cap.unsub();
-		});
-
-		it("second subscription receives later DATA after unsubscribe", () => {
-			assertReconnectSeesData(() => {
-				const s = node([], { initial: 0 });
-				const out = skip(s, 0);
-				return { source: s, out, pushSecond: () => s.down([[DATA, 2]]) };
-			});
-		});
-	});
-
-	describe("distinctUntilChanged", () => {
-		it("DIRTY precedes DATA when source uses two-phase down", () => {
-			const s = node([], { initial: 0 });
-			const out = distinctUntilChanged(s);
-			assertDirtyBeforeDataOnTwoPhase(out, () => s.down([[DIRTY], [DATA, 1]]));
-		});
-
-		it("suppresses duplicate consecutive values (RESOLVED / no duplicate DATA)", () => {
-			const s = node([], { initial: 1 });
-			const out = distinctUntilChanged(s);
-			const cap = subscribeProtocol(out);
-			s.down([[DATA, 1]]);
-			s.down([[DIRTY], [DATA, 1]]);
-			expect(sawResolved(cap.batches) || cap.flat().filter((m) => m[0] === DATA).length === 1).toBe(
-				true,
-			);
-			cap.unsub();
-		});
-
-		it("second subscription receives later DATA after unsubscribe", () => {
-			assertReconnectSeesData(() => {
-				const s = node([], { resubscribable: true, initial: 0 });
-				const out = distinctUntilChanged(s);
-				return { source: s, out };
-			});
-		});
-	});
-
-	describe("pairwise", () => {
-		// Regression: GRAPHREFLY-SPEC §1.3 — after two source values, output delivers a DATA tuple (ordering may omit DIRTY at sink per single-callback batches).
-		it("emits DATA tuple after two source emissions", () => {
-			const s = node([], { initial: 0 });
-			const out = pairwise(s);
-			const cap = subscribeProtocol(out);
-			s.down([[DATA, 0]]);
-			s.down([[DIRTY], [DATA, 1]]);
-			expect(cap.flat().some((m) => m[0] === DATA)).toBe(true);
-			cap.unsub();
-		});
-
-		it("second subscription receives later DATA after unsubscribe", () => {
-			assertReconnectSeesData(() => {
-				const s = node([], { initial: 0 });
-				const out = pairwise(s);
-				return {
-					source: s,
-					out,
-					pushSecond: () => {
-						s.down([[DATA, 0]]);
-						s.down([[DATA, 1]]);
-					},
-				};
-			});
-		});
-	});
-
-	describe("derived with initial (replaces startWith)", () => {
-		it("DIRTY precedes DATA when source uses two-phase down after seed", () => {
-			const s = node([], { initial: 0 });
-			const out = node(
-				[s as Node],
-				(batchData, actions, ctx) => {
-					const data = batchData.map((batch, i) =>
-						batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-					);
-					actions.emit(data[0]);
-				},
-				{ describeKind: "derived", initial: -1 },
-			);
-			assertDirtyBeforeDataOnTwoPhase(out, () => s.down([[DIRTY], [DATA, 0]]));
-		});
-
-		it("second subscription receives later DATA after unsubscribe", () => {
-			assertReconnectSeesData(() => {
-				const s = node([], { resubscribable: true, initial: 0 });
-				const out = node(
-					[s as Node],
-					(batchData, actions, ctx) => {
-						const data = batchData.map((batch, i) =>
-							batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-						);
-						actions.emit(data[0]);
-					},
-					{ describeKind: "derived", initial: 0 },
-				);
-				return { source: s, out };
-			});
-		});
-	});
-
-	describe("first", () => {
-		it("DIRTY precedes DATA when source uses two-phase down", () => {
-			const s = node([], { initial: 0 });
-			const out = first(s);
-			assertDirtyBeforeDataOnTwoPhase(out, () => s.down([[DIRTY], [DATA, 7]]));
-		});
-
-		// Regression: GRAPHREFLY-SPEC §2 — resubscribable `take(1)` resets counters on resubscribe (`onResubscribe`).
-		it("resubscribable first() delivers DATA again after prior COMPLETE", () => {
-			const s = node([], { resubscribable: true, initial: 0 });
-			const out = first(s, { resubscribable: true });
-			const a = subscribeProtocol(out);
-			s.down([[DATA, 1]]);
-			expect(a.flat().some((m) => m[0] === DATA)).toBe(true);
-			a.unsub();
-			const b = subscribeProtocol(out);
-			s.down([[DATA, 2]]);
-			expect(b.flat().some((m) => m[0] === DATA)).toBe(true);
-			b.unsub();
-		});
-	});
-
-	describe("combine", () => {
-		it("DIRTY precedes DATA on two-phase update", () => {
-			const a = node([], { initial: 1 });
-			const b = node([], { initial: 2 });
-			const c = combine(a, b);
-			assertDirtyBeforeDataOnTwoPhase(c, () => a.down([[DIRTY], [DATA, 10]]));
-		});
-
-		it("emits RESOLVED when tuple unchanged", () => {
-			const a = node([], { initial: 1 });
-			const b = node([], { initial: 2 });
-			const c = combine(a, b);
-			const cap = subscribeProtocol(c);
-			a.down([[DATA, 0]]);
-			b.down([[DATA, 0]]);
-			a.down([[DIRTY], [DATA, 0]]);
-			b.down([[DIRTY], [DATA, 0]]);
-			expect(sawResolved(cap.batches)).toBe(true);
-			cap.unsub();
-		});
-
-		it("second subscription sees updates after unsubscribe", () => {
-			const a = node([], { initial: 1 });
-			const b = node([], { initial: 2 });
-			const c = combine(a, b);
-			const x = subscribeProtocol(c);
-			a.down([[DATA, 3]]);
-			expect(x.flat().some((m) => m[0] === DATA)).toBe(true);
-			x.unsub();
-			const y = subscribeProtocol(c);
-			b.down([[DATA, 4]]);
-			expect(y.flat().some((m) => m[0] === DATA)).toBe(true);
-			y.unsub();
-		});
-	});
-
-	describe("zip", () => {
-		it("DIRTY precedes DATA when first arm uses two-phase", () => {
-			const x = node([], { initial: 1 });
-			const y = node([], { initial: 2 });
-			const z = zip(x, y);
-			const cap = subscribeProtocol(z);
-			x.down([[DIRTY], [DATA, 10]]);
-			y.down([[DATA, 20]]);
-			expect(globalDirtyBeforePhase2(cap.flat())).toBe(true);
-			cap.unsub();
-		});
-
-		it("second subscription receives paired DATA after unsubscribe", () => {
-			const x = node([], { initial: 1 });
-			const y = node([], { initial: 2 });
-			const z = zip(x, y);
-			const a = subscribeProtocol(z);
-			x.down([[DATA, 1]]);
-			y.down([[DATA, 2]]);
-			expect(a.flat().some((m) => m[0] === DATA)).toBe(true);
-			a.unsub();
-			const b = subscribeProtocol(z);
-			x.down([[DATA, 3]]);
-			y.down([[DATA, 4]]);
-			expect(b.flat().some((m) => m[0] === DATA)).toBe(true);
-			b.unsub();
-		});
-	});
-
-	describe("merge", () => {
-		// Regression: GRAPHREFLY-SPEC §1.3.5 — merge completes only after all sources complete.
-		it("DIRTY precedes DATA when a source uses two-phase down", () => {
-			const a = node([], { initial: 0 });
-			const b = node([], { initial: 0 });
-			const m = merge(a, b);
-			assertDirtyBeforeDataOnTwoPhase(m, () => a.down([[DIRTY], [DATA, 1]]));
-		});
-
-		it("second subscription receives DATA from either source after unsubscribe", () => {
-			const a = node([], { initial: 0 });
-			const b = node([], { initial: 0 });
-			const m = merge(a, b);
-			const x = subscribeProtocol(m);
-			a.down([[DATA, 1]]);
-			expect(x.flat().some((m) => m[0] === DATA)).toBe(true);
-			x.unsub();
-			const y = subscribeProtocol(m);
-			b.down([[DATA, 2]]);
-			expect(y.flat().some((m) => m[0] === DATA)).toBe(true);
-			y.unsub();
-		});
-	});
-
-	describe("race", () => {
-		it("DIRTY precedes DATA when winning source uses two-phase", () => {
-			const a = node([], { initial: 0 });
-			const b = node([], { initial: 0 });
-			const r = race(a, b);
-			assertDirtyBeforeDataOnTwoPhase(r, () => a.down([[DIRTY], [DATA, 1]]));
-		});
-
-		it("new race() instance forwards DATA after prior race completed", () => {
-			const a1 = node([], { resubscribable: true, initial: 0 });
-			const b1 = node([], { resubscribable: true, initial: 0 });
-			const r1 = race(a1, b1);
-			const x = subscribeProtocol(r1);
-			a1.down([[DATA, 1]]);
-			expect(x.flat().some((m) => m[0] === DATA)).toBe(true);
-			x.unsub();
-			const a2 = node([], { resubscribable: true, initial: 0 });
-			const b2 = node([], { resubscribable: true, initial: 0 });
-			const r2 = race(a2, b2);
-			const y = subscribeProtocol(r2);
-			b2.down([[DATA, 2]]);
-			expect(y.flat().some((m) => m[0] === DATA)).toBe(true);
-			y.unsub();
-		});
-	});
-
-	describe("concat", () => {
-		it("DIRTY precedes DATA on first source two-phase", () => {
-			const a = node<number>();
-			const b = node<number>();
-			const c = concat(a, b);
-			assertDirtyBeforeDataOnTwoPhase(c, () => a.down([[DIRTY], [DATA, 1]]));
-		});
-
-		it("second subscription receives DATA after unsubscribe", () => {
-			const a = node([], { resubscribable: true, initial: 0 });
-			const b = node([], { resubscribable: true, initial: 0 });
-			const c = concat(a, b);
-			const x = subscribeProtocol(c);
-			a.down([[DATA, 1]]);
-			a.down([[COMPLETE]]);
-			b.down([[DATA, 2]]);
-			expect(x.flat().some((m) => m[0] === DATA)).toBe(true);
-			x.unsub();
-			const y = subscribeProtocol(c);
-			a.down([[DATA, 3]]);
-			a.down([[COMPLETE]]);
-			b.down([[DATA, 4]]);
-			expect(y.flat().some((m) => m[0] === DATA)).toBe(true);
-			y.unsub();
-		});
-	});
-
-	describe("withLatestFrom", () => {
-		it("DIRTY on primary precedes DATA when paired", () => {
-			const p = node([], { initial: 1 });
-			const q = node([], { initial: 2 });
-			const w = withLatestFrom(p, q);
-			const cap = subscribeProtocol(w);
-			q.down([[DATA, 20]]);
-			p.down([[DIRTY], [DATA, 10]]);
-			expect(globalDirtyBeforePhase2(cap.flat())).toBe(true);
-			cap.unsub();
-		});
-
-		it("second subscription receives DATA after unsubscribe", () => {
-			const p = node([], { initial: 1 });
-			const q = node([], { initial: 2 });
-			const w = withLatestFrom(p, q);
-			const x = subscribeProtocol(w);
-			q.down([[DATA, 1]]);
-			p.down([[DATA, 2]]);
-			expect(x.flat().some((m) => m[0] === DATA)).toBe(true);
-			x.unsub();
-			const y = subscribeProtocol(w);
-			q.down([[DATA, 3]]);
-			p.down([[DATA, 4]]);
-			expect(y.flat().some((m) => m[0] === DATA)).toBe(true);
-			y.unsub();
-		});
-	});
-
-	describe("reduce", () => {
-		it("does not emit DATA until upstream COMPLETE (operator semantics)", () => {
-			const s = node([], { initial: 0 });
-			const r = reduce(s, (a, x) => a + (x as number), 0);
-			const cap = subscribeProtocol(r);
-			s.down([[DIRTY], [DATA, 1]]);
-			expect(cap.flat().filter((m) => m[0] === DATA).length).toBe(0);
-			cap.unsub();
-		});
-
-		it("second subscription can complete again with resubscribable source", () => {
-			const s = node([], { resubscribable: true, initial: 0 });
-			const r = reduce(s, (a, x) => a + (x as number), 0, { resubscribable: true });
-			const x = subscribeProtocol(r);
-			s.down([[DATA, 1]]);
-			s.down([[COMPLETE]]);
-			expect(x.flat().some((m) => m[0] === DATA)).toBe(true);
-			x.unsub();
-			const y = subscribeProtocol(r);
-			s.down([[DATA, 2]]);
-			s.down([[COMPLETE]]);
-			expect(y.flat().filter((m) => m[0] === DATA).length).toBeGreaterThanOrEqual(1);
-			y.unsub();
-		});
-	});
-
-	describe("takeUntil", () => {
-		// Regression: GRAPHREFLY-SPEC §1.3 — primary stream two-phase before notifier stops.
-		// Notifier must be SENTINEL (no initial value) so it doesn't trigger
-		// takeUntil's COMPLETE on subscribe — the test verifies the primary
-		// stream's two-phase protocol while the notifier is idle.
-		it("DIRTY precedes DATA on primary when notifier has not fired", () => {
-			const s = node([], { initial: 0 });
-			const stop = node<number>();
-			const out = takeUntil(s, stop);
-			assertDirtyBeforeDataOnTwoPhase(out, () => s.down([[DIRTY], [DATA, 3]]));
-		});
-
-		it("second subscription receives DATA after unsubscribe (notifier idle)", () => {
-			assertReconnectSeesData(() => {
-				const s = node([], { initial: 0 });
-				// Use SENTINEL for notifier — node([], { initial: 0 }) would push DATA on resubscribe,
-				// triggering takeUntil's COMPLETE (notifier must be truly idle).
-				const stop = node<number>();
-				const out = takeUntil(s, stop);
-				return { source: s, out };
-			});
-		});
-	});
-
-	describe("takeWhile", () => {
-		it("DIRTY precedes DATA when predicate still holds", () => {
-			const s = node([], { initial: 0 });
-			const out = takeWhile(s, (n) => (n as number) < 9);
-			assertDirtyBeforeDataOnTwoPhase(out, () => s.down([[DIRTY], [DATA, 1]]));
-		});
-
-		it("second subscription receives later DATA after unsubscribe", () => {
-			assertReconnectSeesData(() => {
-				const s = node([], { initial: 0 });
-				const out = takeWhile(s, (n) => (n as number) < 100);
-				return { source: s, out };
-			});
-		});
-	});
-
-	describe("find", () => {
-		it("DIRTY precedes DATA on two-phase source", () => {
-			const s = node([], { initial: 0 });
-			const out = find(s, (n) => (n as number) >= 0);
-			assertDirtyBeforeDataOnTwoPhase(out, () => s.down([[DIRTY], [DATA, 1]]));
-		});
-
-		// Regression: GRAPHREFLY-SPEC §2 — resubscribable take(1) inside find.
-		it("resubscribable find allows another first match after COMPLETE", () => {
-			const s = node([], { resubscribable: true, initial: 0 });
-			const out = find(s, (n) => (n as number) > 0, { resubscribable: true });
-			const a = subscribeProtocol(out);
-			s.down([[DATA, 1]]);
-			expect(a.flat().some((m) => m[0] === DATA)).toBe(true);
-			a.unsub();
-			const b = subscribeProtocol(out);
-			s.down([[DATA, 2]]);
-			expect(b.flat().some((m) => m[0] === DATA)).toBe(true);
-			b.unsub();
-		});
-	});
-
-	describe("elementAt", () => {
-		it("DIRTY precedes DATA when reaching indexed emission", () => {
-			const s = node([], { initial: 0 });
-			const out = elementAt(s, 1);
-			const cap = subscribeProtocol(out);
-			s.down([[DIRTY], [DATA, 10]]);
-			s.down([[DIRTY], [DATA, 20]]);
-			expect(globalDirtyBeforePhase2(cap.flat())).toBe(true);
-			cap.unsub();
-		});
-	});
-
-	describe("last", () => {
-		it("DIRTY precedes final DATA on COMPLETE after two-phase source", () => {
-			const s = node([], { initial: 0 });
-			const out = last(s);
-			const cap = subscribeProtocol(out);
-			s.down([[DIRTY], [DATA, 7]]);
-			s.down([[COMPLETE]]);
-			const flat = cap.flat();
-			// last emits RESOLVED during activation (accumulating, no value
-			// yet). That's an activation-ceremony emission — no DIRTY
-			// precedes it (spec §2.2: ceremony ≠ transition). The two-phase
-			// check applies to the terminal DATA emission: there must be a
-			// DIRTY before the final DATA.
-			const dataIdx = flat.findIndex((m) => m[0] === DATA);
-			expect(dataIdx).toBeGreaterThanOrEqual(0);
-			const dirtyBeforeData = flat.slice(0, dataIdx).some((m) => m[0] === DIRTY);
-			expect(dirtyBeforeData).toBe(true);
-			cap.unsub();
-		});
-	});
-
-	describe("valve", () => {
-		// Regression: GRAPHREFLY-SPEC §1.3 — valve derives from source when control is open.
-		it("DIRTY precedes DATA when control is true", () => {
-			const data = node([], { initial: 0 });
-			const open = node([], { initial: true });
-			const out = valve(data, open);
-			assertDirtyBeforeDataOnTwoPhase(out, () => data.down([[DIRTY], [DATA, 5]]));
-		});
-
-		it("second subscription receives later DATA after unsubscribe", () => {
-			const data = node([], { initial: 0 });
-			const open = node([], { initial: true });
-			const out = valve(data, open);
-			const a = subscribeProtocol(out);
-			data.down([[DATA, 1]]);
-			expect(a.flat().some((m) => m[0] === DATA)).toBe(true);
-			a.unsub();
-			const b = subscribeProtocol(out);
-			data.down([[DIRTY], [DATA, 99]]);
-			expect(b.flat().some((m) => m[0] === DATA)).toBe(true);
-			b.unsub();
-		});
-	});
-});
-
-describe("Tier 2 operator protocol matrix", () => {
-	afterEach(() => {
-		vi.useRealTimers();
-	});
-
-	describe("switchMap", () => {
-		// Outer two-phase may interleave with inner subscription setup; assert global ordering once inner emits.
-		it("DIRTY precedes inner DATA after outer selects inner (two-phase outer)", () => {
-			const src = node<number>();
-			const inner = node<number>();
-			const out = switchMap(src, () => inner);
-			const cap = subscribeProtocol(out);
-			src.down([[DIRTY], [DATA, 1]]);
-			inner.down([[DIRTY], [DATA, 99]]);
-			expect(globalDirtyBeforePhase2(cap.flat())).toBe(true);
-			cap.unsub();
-		});
-
-		it("second subscription follows new outer DATA after unsubscribe", () => {
-			const src = node([], { initial: 0 });
-			const inner = node([], { initial: 100 });
-			const out = switchMap(src, () => inner);
-			const a = subscribeProtocol(out);
-			src.down([[DATA, 1]]);
-			inner.down([[DATA, 11]]);
-			expect(a.flat().some((m) => m[0] === DATA)).toBe(true);
-			a.unsub();
-			const b = subscribeProtocol(out);
-			src.down([[DATA, 2]]);
-			inner.down([[DATA, 22]]);
-			expect(b.flat().some((m) => m[0] === DATA)).toBe(true);
-			b.unsub();
-		});
-	});
-
-	describe("exhaustMap", () => {
-		// Regression: GRAPHREFLY-SPEC §1.3 — inner DIRTY propagates before inner DATA.
-		// After initial attach on connect, push to the inner and verify ordering.
-		it("inner DIRTY precedes inner DATA through exhaustMap", () => {
-			const src = node([], { initial: 0 });
-			const inner = node([], { initial: 10 });
-			const out = exhaustMap(src, () => inner);
-			// Subscribe and let initial connect attach to inner.
-			const batches: Messages[] = [];
-			const unsub = out.subscribe((msgs) => batches.push([...msgs] as unknown as Messages));
-			// Clear initial connect messages; isolate the scripted push.
-			batches.length = 0;
-			inner.down([[DIRTY], [DATA, 20]]);
-			const flat = batches.flat() as Message[];
-			expect(globalDirtyBeforePhase2(flat)).toBe(true);
-			unsub();
-		});
-	});
-
-	describe("concatMap", () => {
-		// Regression: GRAPHREFLY-SPEC §1.3 — inner two-phase ordering must survive queued higher-order dispatch.
-		it("DIRTY precedes DATA from active inner after outer two-phase", () => {
-			const src = node<number>();
-			const inner = node<number>();
-			const out = concatMap(src, () => inner);
-			const cap = subscribeProtocol(out);
-			src.down([[DIRTY], [DATA, 1]]);
-			inner.down([[DIRTY], [DATA, 77]]);
-			expect(globalDirtyBeforePhase2(cap.flat())).toBe(true);
-			cap.unsub();
-		});
-
-		it("second subscription runs sequential inners after unsubscribe", () => {
-			const run = (): void => {
-				const src = node([], { initial: 0 });
-				const a = node([], { initial: 100 });
-				const b = node([], { initial: 200 });
-				let wave = 0;
-				const out = concatMap(src, () => {
-					wave += 1;
-					return wave === 1 ? a : b;
-				});
-				const x = subscribeProtocol(out);
-				src.down([[DATA, 1]]);
-				a.down([[COMPLETE]]);
-				src.down([[DATA, 2]]);
-				b.down([[DATA, 201]]);
-				expect(x.flat().some((m) => m[1] === 201)).toBe(true);
-				x.unsub();
-				const y = subscribeProtocol(out);
-				src.down([[DATA, 1]]);
-				a.down([[COMPLETE]]);
-				src.down([[DATA, 2]]);
-				b.down([[DATA, 202]]);
-				expect(y.flat().some((m) => m[1] === 202)).toBe(true);
-				y.unsub();
-			};
-			run();
-		});
-	});
-
-	describe("mergeMap", () => {
-		it("DIRTY precedes DATA from inner after outer two-phase", () => {
-			const src = node<number>();
-			const inner = node<number>();
-			const out = mergeMap(src, () => inner);
-			const cap = subscribeProtocol(out);
-			src.down([[DIRTY], [DATA, 1]]);
-			inner.down([[DIRTY], [DATA, 10]]);
-			expect(globalDirtyBeforePhase2(cap.flat())).toBe(true);
-			cap.unsub();
-		});
-
-		it("second subscription follows new outer DATA after unsubscribe", () => {
-			const src = node([], { initial: 0 });
-			const inner = node([], { initial: 100 });
-			const out = mergeMap(src, () => inner);
-			const a = subscribeProtocol(out);
-			src.down([[DATA, 1]]);
-			inner.down([[DATA, 11]]);
-			expect(a.flat().some((m) => m[0] === DATA)).toBe(true);
-			a.unsub();
-			const b = subscribeProtocol(out);
-			src.down([[DATA, 2]]);
-			inner.down([[DATA, 22]]);
-			expect(b.flat().some((m) => m[0] === DATA)).toBe(true);
-			b.unsub();
-		});
-	});
-
-	describe("flatMap (alias of mergeMap)", () => {
-		// Regression: flatMap is the same function reference as mergeMap (RxJS naming).
-		it("is mergeMap", () => {
-			expect(flatMap).toBe(mergeMap);
-		});
-
-		it("DIRTY precedes DATA from inner after outer two-phase", () => {
-			const src = node<number>();
-			const inner = node<number>();
-			const out = flatMap(src, () => inner);
-			const cap = subscribeProtocol(out);
-			src.down([[DIRTY], [DATA, 1]]);
-			inner.down([[DIRTY], [DATA, 10]]);
-			expect(globalDirtyBeforePhase2(cap.flat())).toBe(true);
-			cap.unsub();
-		});
-	});
-
-	describe("debounce", () => {
-		it("after reconnect, emits debounced DATA for new activity (fake timers)", () => {
-			vi.useFakeTimers();
-			const s = node([], { initial: 0 });
-			const out = debounce(s, 50);
-			const a = subscribeProtocol(out);
-			s.down([[DATA, 1]]);
-			vi.advanceTimersByTime(50);
-			expect(a.flat().some((m) => m[0] === DATA)).toBe(true);
-			a.unsub();
-			const b = subscribeProtocol(out);
-			s.down([[DATA, 2]]);
-			vi.advanceTimersByTime(50);
-			expect(b.flat().some((m) => m[1] === 2)).toBe(true);
-			b.unsub();
-		});
-	});
-
-	describe("delay", () => {
-		// v5: delay is a producer that transforms the timeline. DIRTY+DATA
-		// arrive atomically at timer-fire time via a.emit(v) → bundle.
-		// No early DIRTY forwarding — the downstream doesn't see the
-		// source's transition until the delayed value is ready.
-		it("DIRTY+DATA arrive together after timer fires (fake timers)", () => {
-			vi.useFakeTimers();
-			const s = node([], { initial: 0 });
-			const out = delay(s, 40);
-			const cap = subscribeProtocol(out);
-			s.down([[DIRTY]]);
-			s.down([[DATA, 7]]);
-			// Before timer: no DIRTY, no DATA visible at the delayed node.
-			expect(cap.flat().filter((m) => m[0] === DATA).length).toBe(0);
-			expect(cap.flat().filter((m) => m[0] === DIRTY).length).toBe(0);
-			vi.advanceTimersByTime(40);
-			// After timer: DIRTY+DATA arrive together (bundle auto-prefix).
-			const flat = cap.flat();
-			expect(globalDirtyBeforePhase2(flat)).toBe(true);
-			expect(flat.some((m) => m[0] === DATA && m[1] === 7)).toBe(true);
-			cap.unsub();
-		});
-	});
-
-	describe("throttle", () => {
-		// Regression: throttle uses `performance.now()` for spacing — lastEmit starts at -Infinity so the first leading edge always fires.
-		it("reconnect sees leading DATA again (fake timers)", () => {
-			vi.useFakeTimers({ shouldAdvanceTime: true });
-			const s = node<number>();
-			const out = throttle(s, 1_000, { trailing: false });
-			const a = subscribeProtocol(out);
-			s.down([[DATA, 1]]);
-			expect(a.flat().find((m) => m[0] === DATA)?.[1]).toBe(1);
-			a.unsub();
-			vi.advanceTimersByTime(2_000);
-			// Subscribe and drain initial cached push, then advance past any throttle window it may trigger.
-			const bBatches: Messages[] = [];
-			const bUnsub = out.subscribe((msgs) => bBatches.push([...msgs] as unknown as Messages));
-			bBatches.length = 0;
-			vi.advanceTimersByTime(2_000);
-			s.down([[DATA, 2]]);
-			expect(
-				(bBatches as Message[][]).flat().some((m: Message) => m[0] === DATA && m[1] === 2),
-			).toBe(true);
-			bUnsub();
-		});
-	});
-
-	describe("sample", () => {
-		it("DIRTY on notifier precedes sampled DATA", () => {
-			const src = node([], { initial: 1 });
-			const tick = node([], { initial: 0 });
-			const out = sample(src, tick);
-			const cap = subscribeProtocol(out);
-			src.down([[DATA, 10]]);
-			tick.down([[DIRTY], [DATA, 1]]);
-			expect(globalDirtyBeforePhase2(cap.flat())).toBe(true);
-			cap.unsub();
-		});
-	});
-
-	describe("audit", () => {
-		it("after reconnect, emits audited DATA for new activity (fake timers)", () => {
-			vi.useFakeTimers();
-			const s = node([], { initial: 0 });
-			const out = audit(s, 50);
-			const a = subscribeProtocol(out);
-			s.down([[DATA, 1]]);
-			vi.advanceTimersByTime(60);
-			expect(a.flat().some((m) => m[0] === DATA)).toBe(true);
-			a.unsub();
-			const b = subscribeProtocol(out);
-			s.down([[DATA, 2]]);
-			vi.advanceTimersByTime(60);
-			expect(b.flat().some((m) => m[1] === 2)).toBe(true);
-			b.unsub();
-		});
-	});
-
-	describe("buffer", () => {
-		it("DIRTY precedes flushed buffer DATA when notifier uses two-phase", () => {
-			const src = node([], { initial: 0 });
-			const n = node([], { initial: 0 });
-			const out = buffer(src, n);
-			const cap = subscribeProtocol(out);
-			src.down([[DATA, 1]]);
-			src.down([[DATA, 2]]);
-			n.down([[DIRTY], [DATA, 0]]);
-			expect(globalDirtyBeforePhase2(cap.flat())).toBe(true);
-			expect(cap.flat().some((m) => m[0] === DATA && Array.isArray(m[1]))).toBe(true);
-			cap.unsub();
-		});
-	});
-
-	describe("bufferCount", () => {
-		it("DIRTY precedes DATA when buffer fills on two-phase pushes", () => {
-			const s = node([], { initial: 0 });
-			const out = bufferCount(s, 2);
-			const cap = subscribeProtocol(out);
-			s.down([[DIRTY], [DATA, 1]]);
-			s.down([[DIRTY], [DATA, 2]]);
-			expect(globalDirtyBeforePhase2(cap.flat())).toBe(true);
-			cap.unsub();
-		});
-	});
-
-	describe("bufferTime", () => {
-		// v5: bufferTime is a producer. DIRTY+DATA arrive atomically
-		// when the interval fires via a.emit(buf) → bundle.
-		it("DIRTY+DATA arrive together after interval fires (fake timers)", () => {
-			vi.useFakeTimers();
-			const s = node<number>();
-			const out = bufferTime(s, 50);
-			const cap = subscribeProtocol(out);
-			s.down([[DIRTY]]);
-			s.down([[DATA, 7]]);
-			// Before interval: nothing visible at the buffered node.
-			expect(cap.flat().filter((m) => m[0] === DATA).length).toBe(0);
-			vi.advanceTimersByTime(50);
-			// After interval: DIRTY+DATA arrive together.
-			const flat = cap.flat();
-			expect(globalDirtyBeforePhase2(flat)).toBe(true);
-			expect(flat.some((m) => m[0] === DATA)).toBe(true);
-			cap.unsub();
-		});
-	});
-
-	describe("windowCount", () => {
-		it("DIRTY precedes DATA when filling a window (no eager outer DATA)", () => {
-			const src = node<number | undefined>([], { initial: undefined });
-			const out = windowCount(src, 2);
-			const cap = subscribeProtocol(out);
-			src.down([[DIRTY], [DATA, 1]]);
-			src.down([[DIRTY], [DATA, 2]]);
-			expect(globalDirtyBeforePhase2(cap.flat())).toBe(true);
-			cap.unsub();
-		});
-	});
-
-	describe("window", () => {
-		it("DIRTY precedes first window emission when notifier closes on two-phase", () => {
-			const src = node<number | undefined>([], { initial: undefined });
-			const n = node([], { initial: 0 });
-			const out = window(src, n);
-			const cap = subscribeProtocol(out);
-			src.down([[DIRTY], [DATA, 1]]);
-			n.down([[DIRTY], [DATA, 0]]);
-			expect(globalDirtyBeforePhase2(cap.flat())).toBe(true);
-			cap.unsub();
-		});
-	});
-
-	describe("windowTime", () => {
-		it("DIRTY precedes DATA after window interval (fake timers)", () => {
-			vi.useFakeTimers({ shouldAdvanceTime: true });
-			vi.setSystemTime(10_000);
-			const s = node<number>();
-			const out = windowTime(s, 100);
-			assertDirtyBeforeDataOnTwoPhase(out, () => s.down([[DIRTY], [DATA, 1]]));
-		});
-	});
-
-	describe("timeout", () => {
-		// Regression: split `down` so DIRTY is not elided at the sink (single-dep DIRTY skip when batched with DATA).
-		it("DIRTY precedes DATA when idle timer is long", () => {
-			const s = node<number>();
-			const out = timeout(s, 999_999);
-			const cap = subscribeProtocol(out);
-			s.down([[DIRTY]]);
-			s.down([[DATA, 1]]);
-			expect(globalDirtyBeforePhase2(cap.flat())).toBe(true);
-			cap.unsub();
-		});
-
-		it("emits ERROR after idle window (fake timers)", () => {
-			vi.useFakeTimers();
-			const s = node([], { initial: 0 });
-			const out = timeout(s, 30);
-			const cap = subscribeProtocol(out);
-			vi.advanceTimersByTime(30);
-			expect(cap.flat().some((m) => m[0] === ERROR)).toBe(true);
-			cap.unsub();
-		});
-	});
-
-	describe("pausable", () => {
-		it("DIRTY precedes DATA when not paused", () => {
-			const s = node<number>();
-			const out = pausable(s);
-			const cap = subscribeProtocol(out);
-			s.down([[DIRTY]]);
-			s.down([[DATA, 1]]);
-			expect(globalDirtyBeforePhase2(cap.flat())).toBe(true);
-			cap.unsub();
-		});
-	});
-
-	describe("rescue", () => {
-		it("DIRTY precedes DATA on successful path", () => {
-			const s = node<number>();
-			const out = rescue(s, () => 0);
-			const cap = subscribeProtocol(out);
-			s.down([[DIRTY]]);
-			s.down([[DATA, 1]]);
-			expect(globalDirtyBeforePhase2(cap.flat())).toBe(true);
-			cap.unsub();
-		});
-	});
-
-	describe("repeat", () => {
-		it("completes producer after N inner COMPLETE rounds", () => {
-			const s = node([], { resubscribable: true, initial: 1 });
-			const out = repeat(s, 2);
-			const cap = subscribeProtocol(out);
-			s.down([[COMPLETE]]);
-			s.down([[COMPLETE]]);
-			expect(cap.flat().some((m) => m[0] === COMPLETE)).toBe(true);
-			cap.unsub();
-		});
-	});
-
-	describe("interval", () => {
-		it("emits DATA on timer while subscribed (fake timers)", () => {
-			vi.useFakeTimers();
-			const out = interval(50);
-			const cap = subscribeProtocol(out);
-			vi.advanceTimersByTime(50);
-			expect(cap.flat().some((m) => m[0] === DATA)).toBe(true);
-			cap.unsub();
-		});
-	});
-
-	describe("RxJS alias exports", () => {
-		it("combineLatest is combine", () => {
-			expect(combineLatest).toBe(combine);
-		});
-
-		it("debounceTime is debounce", () => {
-			expect(debounceTime).toBe(debounce);
-		});
-
-		it("throttleTime is throttle", () => {
-			expect(throttleTime).toBe(throttle);
-		});
-
-		it("catchError is rescue", () => {
-			expect(catchError).toBe(rescue);
-		});
-	});
-});
diff --git a/packages/pure-ts/src/__tests__/extra/operators.test.ts b/packages/pure-ts/src/__tests__/extra/operators.test.ts
deleted file mode 100644
index 9eb33c0f..00000000
--- a/packages/pure-ts/src/__tests__/extra/operators.test.ts
+++ /dev/null
@@ -1,2120 +0,0 @@
-import { afterEach, describe, expect, it, vi } from "vitest";
-import { batch } from "../../core/batch.js";
-import { COMPLETE, DATA, DIRTY, ERROR, PAUSE, RESOLVED, RESUME } from "../../core/messages.js";
-import { metaSnapshot } from "../../core/meta.js";
-import { type Node, node } from "../../core/node.js";
-
-import {
-	audit,
-	bufferCount,
-	combine,
-	concat,
-	concatMap,
-	debounce,
-	delay,
-	distinctUntilChanged,
-	elementAt,
-	exhaustMap,
-	filter,
-	find,
-	first,
-	interval,
-	last,
-	map,
-	merge,
-	mergeMap,
-	pairwise,
-	pausable,
-	race,
-	reduce,
-	repeat,
-	rescue,
-	sample,
-	scan,
-	settle,
-	skip,
-	switchMap,
-	take,
-	takeUntil,
-	takeWhile,
-	tap,
-	throttle,
-	timeout,
-	valve,
-	withLatestFrom,
-	zip,
-} from "../../extra/operators/index.js";
-import { collect } from "../test-helpers.js";
-
-function tick(ms = 0): Promise<void> {
-	return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-describe("extra operators (Tier 1)", () => {
-	// Regression: GRAPHREFLY-SPEC §1.3 — derived map forwards DATA through the protocol.
-	it("map doubles values for downstream subscribers", () => {
-		const s = node([], { initial: 1 });
-		const m = map(s, (n) => n * 2);
-		const { batches, unsub } = collect(m);
-		s.down([[DATA, 2]]);
-		expect(batches.some((b) => b.some((x) => x[0] === DATA && x[1] === 4))).toBe(true);
-		unsub();
-	});
-
-	// Regression: GRAPHREFLY-SPEC §1.3 — filter is a derived gate on settled values.
-	it("filter passes only values matching the predicate", () => {
-		const s = node([], { initial: 1 });
-		const f = filter(
-			map(s, (n) => n * 2),
-			(n) => n > 2,
-		);
-		const { batches, unsub } = collect(f);
-		s.down([[DATA, 2]]);
-		expect(batches.some((b) => b.some((x) => x[0] === DATA && x[1] === 4))).toBe(true);
-		unsub();
-	});
-
-	// Regression: GRAPHREFLY-SPEC §2.6 — tap observes without changing the stream shape.
-	it("tap runs side effects for each forwarded DATA", () => {
-		const s = node([], { initial: 1 });
-		const seen: number[] = [];
-		const t = tap(
-			filter(
-				map(s, (n) => n * 2),
-				(n) => n > 2,
-			),
-			(n) => {
-				seen.push(n);
-			},
-		);
-		const { batches, unsub } = collect(t);
-		s.down([[DATA, 2]]);
-		expect(seen.filter((n) => n === 4).length).toBeGreaterThanOrEqual(1);
-		expect(batches.some((b) => b.some((x) => x[0] === DATA))).toBe(true);
-		unsub();
-	});
-
-	// Regression: GRAPHREFLY-SPEC §1.3 — scan accumulates on each DATA/RESOLVED cycle.
-	it("scan folds successive DATA into an accumulator", () => {
-		const s = node([], { initial: 0 });
-		const sc = scan(s, (a, x) => a + (x as number), 0);
-		const { batches: bs } = collect(sc);
-		s.down([[DATA, 1]]);
-		s.down([[DATA, 2]]);
-		expect(sc.cache).toBe(3);
-		expect(bs.length).toBeGreaterThan(0);
-	});
-
-	// Regression: GRAPHREFLY-SPEC §1.3.5 — reduce emits once when upstream completes.
-	it("reduce emits aggregated DATA on upstream COMPLETE", () => {
-		const sR = node([], { initial: 0 });
-		const r = reduce(sR, (a, x) => a + (x as number), 0);
-		const { batches: br } = collect(r);
-		sR.down([[DATA, 10]]);
-		sR.down([[COMPLETE]]);
-		expect(br.some((b) => b.some((m) => m[0] === DATA))).toBe(true);
-		expect(br.some((b) => b.some((m) => m[0] === COMPLETE))).toBe(true);
-	});
-
-	// Regression: GRAPHREFLY-SPEC §1.3 — take counts DATA emissions (RESOLVED does not advance).
-	it("take counts only DATA (composes with skip)", () => {
-		const s = node<number>();
-		const out = take(skip(s, 1), 2);
-		const { batches } = collect(out);
-		s.down([[DATA, 1]]);
-		s.down([[DATA, 2]]);
-		s.down([[DATA, 3]]);
-		const dataVals = batches
-			.flat()
-			.filter((m) => m[0] === DATA)
-			.map((m) => m[1]);
-		expect(dataVals).toEqual([2, 3]);
-		expect(batches.flat().some((m) => m[0] === COMPLETE)).toBe(true);
-	});
-
-	// Regression: GRAPHREFLY-SPEC §1.3.4 — non-positive take completes immediately (terminal).
-	it("take(0) completes without DATA", () => {
-		const s = node<number>();
-		const out = take(s, 0);
-		const { batches } = collect(out);
-		s.down([[DATA, 1]]);
-		expect(out.cache).toBe(undefined);
-		expect(batches.flat().some((m) => m[0] === COMPLETE)).toBe(true);
-	});
-
-	// Regression: GRAPHREFLY-SPEC §1.3 — takeWhile completes when predicate fails.
-	it("takeWhile forwards DATA until predicate is false", () => {
-		const s = node([], { initial: 1 });
-		const tw = takeWhile(s, (n) => (n as number) < 3);
-		const { batches } = collect(tw);
-		// Push-on-subscribe delivers initial value 1 (passes predicate)
-		s.down([[DATA, 2]]);
-		s.down([[DATA, 5]]);
-		const dataVals = batches
-			.flat()
-			.filter((m) => m[0] === DATA)
-			.map((m) => m[1]);
-		// All emitted values must satisfy the predicate (< 3)
-		expect(dataVals.every((v) => (v as number) < 3)).toBe(true);
-		expect(dataVals).toContain(1);
-		expect(dataVals).toContain(2);
-		// Value 5 must NOT appear (predicate fails)
-		expect(dataVals).not.toContain(5);
-	});
-
-	// Regression: GRAPHREFLY-SPEC §1.3.4 — first is take(1); terminal after one DATA.
-	it("first emits a single DATA then completes", () => {
-		const s2 = node<number>();
-		const f2 = first(s2);
-		const { batches: bf2 } = collect(f2);
-		s2.down([[DATA, 9]]);
-		s2.down([[DATA, 9]]);
-		expect(bf2.flat().filter((m) => m[0] === DATA).length).toBe(1);
-	});
-
-	// Regression: GRAPHREFLY-SPEC §1.3.5 — takeUntil completes when notifier matches predicate.
-	it("takeUntil completes when notifier emits matching DATA", () => {
-		const s = node([], { initial: 0 });
-		const stop = node([], { initial: 0 });
-		const tu = takeUntil(s, stop);
-		const { batches } = collect(tu);
-		s.down([[DATA, 1]]);
-		stop.down([[DATA, 1]]);
-		expect(batches.flat().some((m) => m[0] === COMPLETE)).toBe(true);
-	});
-
-	// Regression: GRAPHREFLY-SPEC §1.3.3 — distinctUntilChanged suppresses unchanged consecutive values.
-	it("distinctUntilChanged does not repeat DATA for identical consecutive values", () => {
-		const s2 = node<number>();
-		const d = distinctUntilChanged(s2);
-		const { batches: bd } = collect(d);
-		s2.down([[DATA, 1]]);
-		s2.down([[DATA, 1]]);
-		s2.down([[DATA, 1]]);
-		const dataCount = bd.flat().filter((m) => m[0] === DATA).length;
-		expect(dataCount).toBe(1);
-	});
-
-	// Regression: GRAPHREFLY-SPEC §1.3 — pairwise needs two source emissions before first tuple.
-	it("pairwise emits a tuple of the last two DATA values", () => {
-		const s3 = node([], { initial: 0 });
-		const p = pairwise(s3);
-		const { batches: bp } = collect(p);
-		s3.down([[DATA, 1]]);
-		s3.down([[DATA, 2]]);
-		const lastData = bp
-			.flat()
-			.filter((m) => m[0] === DATA)
-			.at(-1)?.[1] as readonly [number, number] | undefined;
-		expect(lastData).toEqual([1, 2]);
-	});
-
-	// Regression: GRAPHREFLY-SPEC §1.3 — combine is multi-dep derived (latest tuple).
-	it("combine reflects latest value from each source", () => {
-		const a = node([], { initial: 1 });
-		const b = node([], { initial: 2 });
-		const c = combine(a, b);
-		collect(c);
-		a.down([[DATA, 10]]);
-		expect(c.cache).toEqual([10, 2]);
-	});
-
-	// Regression: GRAPHREFLY-SPEC §1.3 — zip pairs DATA in lockstep.
-	it("zip emits when each source has produced a value", () => {
-		const x = node([], { initial: 1 });
-		const y = node([], { initial: 2 });
-		const z = zip(x, y);
-		const { batches: bz } = collect(z);
-		x.down([[DATA, 3]]);
-		y.down([[DATA, 4]]);
-		expect(bz.flat().some((m) => m[0] === DATA)).toBe(true);
-	});
-
-	// Regression: GRAPHREFLY-SPEC §1.3 — merge forwards any source DATA.
-	it("merge forwards DATA from the first source that emits", () => {
-		const m1 = node([], { initial: 1 });
-		const m2 = node([], { initial: 2 });
-		const mg = merge(m1, m2);
-		const { batches: bm } = collect(mg);
-		m1.down([[DATA, 5]]);
-		expect(bm.length).toBeGreaterThan(0);
-	});
-
-	// Regression: GRAPHREFLY-SPEC §1.3.5 — merge completes only after all sources complete.
-	it("merge completes only after every source has completed", () => {
-		const e1 = node([], { initial: 0 });
-		const e2 = node([], { initial: 0 });
-		const mgc = merge(e1, e2);
-		const { batches: bmc } = collect(mgc);
-		e1.down([[COMPLETE]]);
-		expect(bmc.flat().some((m) => m[0] === COMPLETE)).toBe(false);
-		e2.down([[COMPLETE]]);
-		expect(bmc.flat().some((m) => m[0] === COMPLETE)).toBe(true);
-	});
-
-	// F-15: merge() accepts an optional trailing opts object that overlays
-	// the default factoryTag meta and threads through to node opts.
-	it("merge() accepts trailing opts that override meta and node options", () => {
-		const m1 = node([], { initial: 0 });
-		const m2 = node([], { initial: 0 });
-		const tagged = merge(m1, m2, {
-			meta: { metric: "events", factory: "merge-aliased" },
-			name: "tagged-merge",
-		});
-		// node-level option threads through
-		expect(tagged.name).toBe("tagged-merge");
-		// user-supplied meta wins over the default factoryTag entries
-		expect(metaSnapshot(tagged)).toMatchObject({
-			factory: "merge-aliased",
-			metric: "events",
-		});
-	});
-
-	// F-15: empty-merge variant honors trailing opts symmetrically.
-	it("merge() with no sources but trailing opts forwards meta", () => {
-		const empty = merge<number>({ meta: { metric: "noop" } });
-		expect(metaSnapshot(empty)).toMatchObject({ metric: "noop", factory: "merge" });
-	});
-
-	// F-15 / qa A-2: a trailing `undefined` from `merge(a, b, opts ?? undefined)`
-	// must NOT be passed into the source-subscribe loop. Pre-fix this crashed
-	// with "Cannot read properties of undefined (reading 'subscribe')".
-	it("merge() with trailing undefined treats it as 'no opts' (idiomatic optional pass)", () => {
-		const m1 = node([], { initial: 1 });
-		const m2 = node([], { initial: 2 });
-		const opts: { meta?: Record<string, unknown> } | undefined = undefined;
-		const merged = merge(m1, m2, opts);
-		const { batches } = collect(merged);
-		m1.down([[DATA, 5]]);
-		expect(batches.flat().some((m) => m[0] === DATA && m[1] === 5)).toBe(true);
-	});
-
-	// Regression: GRAPHREFLY-SPEC §1.3 — concat serializes sources after the first completes.
-	it("concat forwards second source only after the first completes", () => {
-		const f = node([], { initial: 1 });
-		const sec = node([], { initial: 2 });
-		const co = concat(f, sec);
-		const { batches: bco } = collect(co);
-		f.down([[DATA, 7]]);
-		f.down([[COMPLETE]]);
-		sec.down([[DATA, 8]]);
-		const concatData = bco
-			.flat()
-			.filter((m) => m[0] === DATA)
-			.map((m) => m[1]);
-		expect(concatData).toContain(7);
-		expect(concatData).toContain(8);
-	});
-
-	// Regression: GRAPHREFLY-SPEC §1.3 — race mirrors first winning DATA source.
-	it("race forwards DATA from whichever source wins", () => {
-		const r1 = node([], { initial: 1 });
-		const r2 = node([], { initial: 2 });
-		const rc = race(r1, r2);
-		const { batches: br } = collect(rc);
-		r1.down([[DATA, 11]]);
-		expect(br.flat().filter((m) => m[0] === DATA).length).toBeGreaterThanOrEqual(1);
-	});
-
-	// Regression: GRAPHREFLY-SPEC §1.3 — derived with initial seeds before upstream DATA.
-	it("derived with initial emits seed before upstream DATA", () => {
-		const s = node([], { initial: 0 });
-		const sw = node(
-			[s as Node],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit(data[0]);
-			},
-			{ describeKind: "derived", initial: -1 },
-		);
-		const { batches: bsw } = collect(sw);
-		s.down([[DATA, 0]]);
-		expect(
-			bsw
-				.flat()
-				.filter((m) => m[0] === DATA)
-				.map((m) => m[1]),
-		).toContain(-1);
-	});
-
-	// Regression: GRAPHREFLY-SPEC §1.3 — elementAt is indexed take-after-skip.
-	it("elementAt emits the nth DATA (zero-based index)", () => {
-		const s2 = node<number>();
-		const ea = elementAt(s2, 2);
-		const { batches: bea } = collect(ea);
-		s2.down([[DATA, 10]]);
-		s2.down([[DATA, 20]]);
-		s2.down([[DATA, 30]]);
-		expect(bea.flat().find((m) => m[0] === DATA)?.[1]).toBe(30);
-	});
-
-	// Regression: GRAPHREFLY-SPEC §1.3 — find is filter + take(1).
-	it("find completes on first value matching the predicate", () => {
-		const s3 = node([], { initial: 0 });
-		const fd = find(s3, (n) => (n as number) >= 2);
-		const { batches: bfd } = collect(fd);
-		s3.down([[DATA, 1]]);
-		s3.down([[DATA, 2]]);
-		expect(bfd.flat().find((m) => m[0] === DATA)?.[1]).toBe(2);
-	});
-
-	// Regression: GRAPHREFLY-SPEC §1.3.5 — last emits on upstream COMPLETE (or default).
-	it("last emits the final DATA when upstream completes", () => {
-		const s4 = node([], { initial: 0 });
-		const la = last(s4, { defaultValue: 99 });
-		const { batches: bla } = collect(la);
-		s4.down([[DATA, 42]]);
-		s4.down([[COMPLETE]]);
-		expect(bla.flat().find((m) => m[0] === DATA)?.[1]).toBe(42);
-	});
-
-	// Regression: GRAPHREFLY-SPEC §1.3 — withLatestFrom pairs primary with latest secondary.
-	it("withLatestFrom forwards primary with secondary snapshot", () => {
-		const p = node<number>();
-		const q = node([], { initial: 2 });
-		const w = withLatestFrom(p, q);
-		const { batches } = collect(w);
-		q.down([[DATA, 20]]);
-		p.down([[DATA, 10]]);
-		const dataMsg = batches.flat().find((m) => m[0] === DATA);
-		expect(dataMsg?.[1]).toEqual([10, 20]);
-	});
-
-	// Regression: GRAPHREFLY-SPEC §1.3 — race winner keeps streaming; loser ignored after pick.
-	it("race continues forwarding from winner (not just first DATA)", () => {
-		const a = node<number>();
-		const b = node<number>();
-		const rc = race(a, b);
-		const { batches } = collect(rc);
-		a.down([[DATA, 1]]);
-		a.down([[DATA, 2]]);
-		b.down([[DATA, 99]]);
-		const dataVals = batches
-			.flat()
-			.filter((m) => m[0] === DATA)
-			.map((m) => m[1]);
-		expect(dataVals).toEqual([1, 2]);
-	});
-
-	// Regression: GRAPHREFLY-SPEC §1.3.2 — diamond: phase-1 completes before phase-2 recompute.
-	it("map through diamond topology", () => {
-		const src = node([], { initial: 1 });
-		const left = map(src, (n) => (n as number) * 2);
-		const right = map(src, (n) => (n as number) + 10);
-		const combo = combine(left, right);
-		collect(combo);
-		src.down([[DATA, 3]]);
-		expect(combo.cache).toEqual([6, 13]);
-	});
-
-	// Regression: GRAPHREFLY-SPEC §1.3.5 — reduce aggregates until COMPLETE, then emits once.
-	it("reduce emits only on COMPLETE", () => {
-		const s = node([], { initial: 0 });
-		const r = reduce(s, (a, x) => a + (x as number), 0);
-		const { batches } = collect(r);
-		s.down([[DATA, 1]]);
-		s.down([[DATA, 2]]);
-		expect(batches.flat().filter((m) => m[0] === DATA).length).toBe(0);
-		s.down([[COMPLETE]]);
-		const dataVals = batches
-			.flat()
-			.filter((m) => m[0] === DATA)
-			.map((m) => m[1]);
-		expect(dataVals).toEqual([3]);
-		expect(batches.flat().some((m) => m[0] === COMPLETE)).toBe(true);
-	});
-
-	// Regression: GRAPHREFLY-SPEC §1.3 — concat may buffer second source until first completes.
-	it("concat buffers second-source DATA during phase 0", () => {
-		const a = node([], { initial: 0 });
-		const b = node([], { initial: 0 });
-		const co = concat(a, b);
-		const { batches } = collect(co);
-		b.down([[DATA, 50]]);
-		a.down([[COMPLETE]]);
-		const dataVals = batches
-			.flat()
-			.filter((m) => m[0] === DATA)
-			.map((m) => m[1]);
-		expect(dataVals).toContain(50);
-	});
-});
-
-describe("extra operators (Tier 2)", () => {
-	afterEach(() => {
-		vi.useRealTimers();
-	});
-
-	// Regression: GRAPHREFLY-SPEC §2 — switchMap tears down previous inner subscription on new outer DATA.
-	it("switchMap unsubscribes prior inner", () => {
-		const src = node([], { initial: 0 });
-		const innerA = node([], { initial: 100 });
-		const innerB = node([], { initial: 200 });
-		const out = switchMap(src, (v) => ((v as number) === 0 ? innerA : innerB));
-		const { batches, unsub } = collect(out);
-		innerA.down([[DATA, 11]]);
-		src.down([[DATA, 1]]);
-		innerB.down([[DATA, 22]]);
-		innerA.down([[DATA, 99]]);
-		const dataVals = batches
-			.flat()
-			.filter((m) => m[0] === DATA)
-			.map((m) => m[1] as number);
-		expect(dataVals).toContain(11);
-		expect(dataVals).toContain(22);
-		expect(dataVals).not.toContain(99);
-		unsub();
-	});
-
-	// Regression: exhaustMap drops outer DATA while inner is active.
-	// fn+closure B pattern: source is a declared dep, so the dep-wave
-	// propagates DIRTY downstream. Drop emits RESOLVED to close the wave.
-	it("exhaustMap drops outer DATA while inner active", () => {
-		const src = node([], { initial: 0 });
-		const inner = node([], { initial: 10 });
-		const out = exhaustMap(src, () => inner);
-		const { batches, unsub } = collect(out);
-		src.down([[DATA, 1]]);
-		inner.down([[DATA, 1]]);
-		const beforeDrop = batches.flat().length;
-		src.down([[DATA, 2]]); // dropped — inner still active
-		// Drop emits DIRTY+RESOLVED (dep-wave opened by source, closed by fn).
-		const dropMsgs = batches.flat().slice(beforeDrop);
-		const dropTypes = dropMsgs.map((m: any) => m[0]);
-		expect(dropTypes).toContain(DIRTY);
-		expect(dropTypes).toContain(RESOLVED);
-		expect(dropTypes).not.toContain(DATA);
-		inner.down([[COMPLETE]]);
-		unsub();
-	});
-
-	// Regression: GRAPHREFLY-SPEC §2 — concatMap waits for inner COMPLETE before next outer value.
-	it("concatMap runs inners sequentially", () => {
-		const src = node([], { initial: 0 });
-		const a = node([], { initial: 100 });
-		const b = node([], { initial: 200 });
-		let wave = 0;
-		const out = concatMap(src, () => {
-			wave += 1;
-			return wave === 1 ? a : b;
-		});
-		const { batches, unsub } = collect(out);
-		src.down([[DATA, 1]]);
-		b.down([[DATA, 999]]);
-		expect(
-			batches
-				.flat()
-				.filter((m) => m[0] === DATA)
-				.some((m) => m[1] === 999),
-		).toBe(false);
-		a.down([[COMPLETE]]);
-		src.down([[DATA, 2]]);
-		b.down([[DATA, 201]]);
-		expect(
-			batches
-				.flat()
-				.filter((m) => m[0] === DATA)
-				.map((m) => m[1] as number),
-		).toContain(201);
-		unsub();
-	});
-
-	// Regression: GRAPHREFLY-SPEC §2 — mergeMap multiplexes concurrent inner subscriptions.
-	it("mergeMap keeps multiple inners active", () => {
-		const src = node([], { initial: 0 });
-		const inner1 = node([], { initial: 1 });
-		const inner2 = node([], { initial: 2 });
-		let pick = 0;
-		const out = mergeMap(src, () => {
-			pick += 1;
-			return pick === 1 ? inner1 : inner2;
-		});
-		const { batches, unsub } = collect(out);
-		src.down([[DATA, 1]]);
-		src.down([[DATA, 2]]);
-		inner1.down([[DATA, 10]]);
-		inner2.down([[DATA, 20]]);
-		const dataVals = new Set(
-			batches
-				.flat()
-				.filter((m) => m[0] === DATA)
-				.map((m) => m[1] as number),
-		);
-		expect(dataVals.has(10)).toBe(true);
-		expect(dataVals.has(20)).toBe(true);
-		inner1.down([[COMPLETE]]);
-		inner2.down([[COMPLETE]]);
-		src.down([[COMPLETE]]);
-		unsub();
-	});
-
-	// Regression: roadmap §3.1b — higher-order projects accept scalar via fromAny coercion.
-	it("switchMap coerces scalar project returns", () => {
-		const src = node([], { initial: 0 });
-		const out = switchMap(src, (v) => (v as number) + 100);
-		const { batches, unsub } = collect(out);
-		src.down([[DATA, 2]]);
-		const dataVals = batches
-			.flat()
-			.filter((m) => m[0] === DATA)
-			.map((m) => m[1]);
-		expect(dataVals).toContain(102);
-		unsub();
-	});
-
-	// Regression: roadmap §3.1b — higher-order projects accept PromiseLike via fromAny coercion.
-	it("switchMap coerces Promise project returns", async () => {
-		const src = node([], { initial: 0 });
-		const out = switchMap(src, (v) => Promise.resolve((v as number) + 5));
-		const { batches, unsub } = collect(out);
-		src.down([[DATA, 3]]);
-		await tick(0);
-		const dataVals = batches
-			.flat()
-			.filter((m) => m[0] === DATA)
-			.map((m) => m[1]);
-		expect(dataVals).toContain(8);
-		unsub();
-	});
-
-	// Regression: parity 3.1 — forwardInner emits current settled inner value on attach.
-	it("switchMap forwards settled inner current value immediately", () => {
-		const src = node([], { initial: 1 });
-		const out = switchMap(src, (v) => node([], { initial: (v as number) * 10 }));
-		const { batches, unsub } = collect(out);
-		const dataVals = batches
-			.flat()
-			.filter((m) => m[0] === DATA)
-			.map((m) => m[1]);
-		expect(dataVals).toContain(10);
-		unsub();
-	});
-
-	// Regression: SESSION-tier2-parity-nonlocal-forward-inner #4 — forwardInner must not duplicate
-	// initial DATA when an inner derived node already emits during subscribe.
-	it("switchMap does not duplicate initial DATA for derived inner on attach", () => {
-		const src = node<number>();
-		const base = node<number>();
-		const out = switchMap(src, () => map(base, (n) => (n as number) + 1));
-		const { batches, unsub } = collect(out);
-		src.down([[DATA, 1]]);
-		base.down([[DATA, 10]]);
-		const initial = batches
-			.flat()
-			.filter((m) => m[0] === DATA)
-			.map((m) => m[1]);
-		expect(initial.filter((v) => v === 11).length).toBe(1);
-		unsub();
-	});
-
-	// Regression: roadmap §3.1b — higher-order projects accept Iterable via fromAny coercion.
-	it("concatMap coerces iterable project returns", () => {
-		const src = node<number>(
-			[],
-			(_data, a) => {
-				a.down([[DATA, 4], [COMPLETE]]);
-			},
-			{ describeKind: "producer" },
-		);
-		const out = concatMap(src, (v) => [v * 2, v * 3]);
-		const { batches, unsub } = collect(out);
-		const dataVals = batches
-			.flat()
-			.filter((m) => m[0] === DATA)
-			.map((m) => m[1] as number);
-		expect(dataVals).toEqual(expect.arrayContaining([8, 12]));
-		unsub();
-	});
-
-	// Regression: roadmap §3.1b — higher-order projects accept AsyncIterable via fromAny coercion.
-	it("mergeMap coerces async iterable project returns", async () => {
-		const src = node([], { initial: 0 });
-		const out = mergeMap(src, async function* (v: number) {
-			yield v + 1;
-			yield v + 2;
-		});
-		const { batches, unsub } = collect(out);
-		src.down([[DATA, 10]]);
-		await tick(0);
-		await tick(0);
-		const dataVals = batches
-			.flat()
-			.filter((m) => m[0] === DATA)
-			.map((m) => m[1] as number);
-		expect(dataVals).toEqual(expect.arrayContaining([11, 12]));
-		unsub();
-	});
-
-	// Regression: GRAPHREFLY-SPEC §1.3 — debounce delays phase-2 until quiet window (timers).
-	it("debounce emits once after quiet window (fake timers)", () => {
-		vi.useFakeTimers();
-		const s = node([], { initial: 0 });
-		const out = debounce(s, 50);
-		const { batches, unsub } = collect(out);
-		s.down([[DATA, 1]]);
-		s.down([[DATA, 2]]);
-		s.down([[DATA, 3]]);
-		expect(batches.flat().filter((m) => m[0] === DATA).length).toBe(0);
-		vi.advanceTimersByTime(50);
-		expect(batches.flat().find((m) => m[0] === DATA)?.[1]).toBe(3);
-		unsub();
-	});
-
-	// Regression: GRAPHREFLY-SPEC §1.3.7 — timer-backed operators should not fire phase-2 while
-	// source DATA is still deferred inside an active batch.
-	it("debounce does not flush DATA until batch exits (fake timers)", () => {
-		vi.useFakeTimers();
-		const s = node<number>();
-		const out = debounce(s, 50);
-		const { batches, unsub } = collect(out);
-		batch(() => {
-			s.down([[DATA, 7]]);
-			vi.advanceTimersByTime(100);
-			expect(batches.flat().some((m) => m[0] === DATA)).toBe(false);
-		});
-		vi.advanceTimersByTime(50);
-		expect(batches.flat().find((m) => m[0] === DATA)?.[1]).toBe(7);
-		unsub();
-	});
-
-	// Regression: GRAPHREFLY-SPEC §1.3 — delay forwards DIRTY immediately; DATA after timeout.
-	it("delay shifts DATA by ms (fake timers)", () => {
-		vi.useFakeTimers();
-		const s = node<number>();
-		const out = delay(s, 40);
-		const { batches, unsub } = collect(out);
-		s.down([[DATA, 7]]);
-		expect(batches.flat().filter((m) => m[0] === DATA).length).toBe(0);
-		vi.advanceTimersByTime(40);
-		expect(batches.flat().find((m) => m[0] === DATA)?.[1]).toBe(7);
-		unsub();
-	});
-
-	// Regression: GRAPHREFLY-SPEC §1.3.4 — timeout emits ERROR when no DATA resets the timer.
-	it("timeout errors when idle (fake timers)", () => {
-		vi.useFakeTimers();
-		const s = node([], { initial: 0 });
-		const out = timeout(s, 30);
-		const { batches, unsub } = collect(out);
-		vi.advanceTimersByTime(30);
-		expect(batches.flat().some((m) => m[0] === ERROR)).toBe(true);
-		unsub();
-	});
-
-	// Regression: GRAPHREFLY-SPEC §1.3 — throttle rate-limits DATA (leading edge).
-	it("throttle leading edge passes first emission", () => {
-		vi.useFakeTimers();
-		const s = node<number>();
-		const out = throttle(s, 1_000, { trailing: false });
-		const { batches, unsub } = collect(out);
-		s.down([[DATA, 1]]);
-		expect(batches.flat().find((m) => m[0] === DATA)?.[1]).toBe(1);
-		s.down([[DATA, 2]]);
-		expect(batches.flat().filter((m) => m[0] === DATA).length).toBe(1);
-		unsub();
-	});
-
-	// Regression: GRAPHREFLY-SPEC §1.3 — sample pulls latest source value on notifier DATA.
-	it("sample emits when notifier settles", () => {
-		const src = node<number>();
-		const tick = node<number>();
-		const out = sample(src, tick);
-		const { batches, unsub } = collect(out);
-		src.down([[DATA, 10]]);
-		tick.down([[DATA, 1]]);
-		expect(batches.flat().find((m) => m[0] === DATA)?.[1]).toBe(10);
-		unsub();
-	});
-
-	// Regression: GRAPHREFLY-SPEC §1.3 — bufferCount emits fixed-size arrays of DATA.
-	it("bufferCount batches DATA", () => {
-		const s = node([], { initial: 1 });
-		const out = bufferCount(s, 2);
-		const { batches, unsub } = collect(out);
-		s.down([[DATA, 2]]);
-		s.down([[DATA, 3]]);
-		// Push-on-subscribe delivers initial 1; subsequent DATA values fill buffers.
-		// Verify that at least one buffer was emitted with expected size.
-		const buffers = batches
-			.flat()
-			.filter((m) => m[0] === DATA)
-			.map((m) => m[1] as number[]);
-		expect(buffers.length).toBeGreaterThanOrEqual(1);
-		expect(buffers.some((b) => b.length === 2)).toBe(true);
-		unsub();
-	});
-
-	// Regression: GRAPHREFLY-SPEC §1.3.4 — rescue converts ERROR into downstream DATA.
-	it("rescue maps ERROR to value", () => {
-		const s = node<number>();
-		const out = rescue(s, () => 42);
-		const { batches, unsub } = collect(out);
-		s.down([[ERROR, new Error("x")]]);
-		expect(batches.flat().find((m) => m[0] === DATA)?.[1]).toBe(42);
-		unsub();
-	});
-
-	// Regression: SESSION-tier2-parity-nonlocal-forward-inner — rescue wrapped around a higher-order
-	// operator must recover inner ERROR as DATA and avoid leaking terminal ERROR downstream.
-	it("rescue recovers ERROR from switchMap inner source", () => {
-		const src = node([], { initial: 1 });
-		const out = rescue(
-			switchMap(src, () =>
-				node<number>(
-					[],
-					(_data, a) => {
-						a.down([[ERROR, new Error("inner")], [COMPLETE]]);
-					},
-					{ describeKind: "producer" },
-				),
-			),
-			() => 123,
-		);
-		const { batches, unsub } = collect(out);
-		const flat = batches.flat();
-		expect(flat.find((m) => m[0] === DATA)?.[1]).toBe(123);
-		expect(flat.some((m) => m[0] === ERROR)).toBe(false);
-		unsub();
-	});
-
-	// Regression: GRAPHREFLY-SPEC §1.3.4 — rescue recovery failure propagates ERROR.
-	it("rescue forwards ERROR when recover throws", () => {
-		const s = node([], { initial: 0 });
-		const boom = new Error("recover");
-		const out = rescue(s, () => {
-			throw boom;
-		});
-		const { batches, unsub } = collect(out);
-		s.down([[ERROR, new Error("up")]]);
-		const errMsg = batches.flat().find((m) => m[0] === ERROR);
-		expect(errMsg?.[1]).toBe(boom);
-		unsub();
-	});
-
-	// Regression: GRAPHREFLY-SPEC §1.2 — PAUSE buffers; RESUME flushes pending protocol messages.
-	it("pausable buffers then flushes on RESUME", () => {
-		const s = node([], { initial: 0 });
-		const out = pausable(s);
-		const { batches, unsub } = collect(out);
-		const lock = Symbol("test-lock");
-		s.down([[PAUSE, lock]]);
-		s.down([[DIRTY]]);
-		s.down([[DATA, 5]]);
-		s.down([[RESUME, lock]]);
-		expect(batches.flat().filter((m) => m[0] === DATA).length).toBeGreaterThanOrEqual(1);
-		unsub();
-	});
-
-	// Regression: GRAPHREFLY-SPEC §2.1 — interval producer emits on timer while subscribed.
-	it("interval ticks via producer (fake timers)", () => {
-		vi.useFakeTimers();
-		const tick = interval(100);
-		const { batches, unsub } = collect(tick);
-		vi.advanceTimersByTime(250);
-		const values = batches
-			.flat()
-			.filter((m) => m[0] === DATA)
-			.map((m) => m[1] as number);
-		expect(values.length).toBeGreaterThanOrEqual(2);
-		unsub();
-	});
-
-	// Regression: GRAPHREFLY-SPEC §2 — repeat resubscribes to source for N terminal rounds.
-	it("repeat completes after N rounds", () => {
-		const s = node([], { resubscribable: true, initial: 1 });
-		const out = repeat(s, 2);
-		const { batches, unsub } = collect(out);
-		s.down([[COMPLETE]]);
-		s.down([[COMPLETE]]);
-		expect(batches.flat().some((m) => m[0] === COMPLETE)).toBe(true);
-		unsub();
-	});
-
-	// Regression: GRAPHREFLY-SPEC §1.3 — audit samples latest after window (trailing edge).
-	it("audit emits trailing-only after timer (fake timers)", () => {
-		vi.useFakeTimers();
-		const s = node([], { initial: 0 });
-		const out = audit(s, 100);
-		const { batches, unsub } = collect(out);
-		s.down([[DATA, 1]]);
-		// No leading emit
-		const immediate = batches.flat().filter((m) => m[0] === DATA);
-		expect(immediate.length).toBe(0);
-		vi.advanceTimersByTime(150);
-		const after = batches.flat().filter((m) => m[0] === DATA);
-		expect(after.length).toBe(1);
-		expect(after[0][1]).toBe(1);
-		unsub();
-	});
-
-	// Regression: operator validates repeat count > 0.
-	it("repeat throws on count <= 0", () => {
-		const s = node([], { initial: 0 });
-		expect(() => repeat(s, 0)).toThrow(RangeError);
-	});
-
-	// Regression: operator validates bufferCount count > 0.
-	it("bufferCount throws on count <= 0", () => {
-		const s = node([], { initial: 0 });
-		expect(() => bufferCount(s, 0)).toThrow(RangeError);
-	});
-});
-
-// ---------------------------------------------------------------------------
-// Tier 1 operator matrix — DIRTY, RESOLVED-suppression, ERROR/COMPLETE propagation, reconnect
-// ---------------------------------------------------------------------------
-
-describe("Tier 1 operator matrix — map", () => {
-	it("DIRTY arrives before DATA at subscriber", () => {
-		// Spec: GRAPHREFLY-SPEC §1.3.1
-		const src = node([], { initial: 1 });
-		const m = map(src, (x) => (x as number) * 2);
-		const types: symbol[] = [];
-		const unsub = m.subscribe((msgs) => {
-			for (const msg of msgs) types.push(msg[0] as symbol);
-		});
-		types.length = 0;
-		src.down([[DIRTY], [DATA, 2]]);
-		unsub();
-		const dirtyIdx = types.indexOf(DIRTY);
-		const dataIdx = types.indexOf(DATA);
-		expect(dirtyIdx).toBeGreaterThanOrEqual(0);
-		expect(dataIdx).toBeGreaterThan(dirtyIdx);
-	});
-
-	it("RESOLVED suppression: same-value upstream emits RESOLVED, fn does not rerun", () => {
-		// Spec: GRAPHREFLY-SPEC §1.3.3
-		const src = node([], { initial: 1 });
-		let fnRuns = 0;
-		const m = map(src, (x) => {
-			fnRuns += 1;
-			return (x as number) > 0 ? "pos" : "neg";
-		});
-		const unsub = m.subscribe(() => undefined);
-		fnRuns = 0;
-		// Push a new upstream value that maps to the same output ("pos")
-		src.down([[DIRTY], [DATA, 2]]);
-		const runsAfter = fnRuns;
-		unsub();
-		// map always reruns, but the node should emit RESOLVED not DATA
-		// The downstream should not see DATA for the unchanged value
-		const unsub2 = m.subscribe((msgs) => {
-			// Collect for RESOLVED check only — map's fn runs but RESOLVED is sent downstream
-			void msgs;
-		});
-		unsub2();
-		const src2 = node([], { initial: 1 });
-		const m2 = map(src2, (x) => {
-			return (x as number) > 0 ? "pos" : "neg";
-		});
-		const resolvedTypes: symbol[] = [];
-		const unsubR = m2.subscribe((msgs) => {
-			for (const msg of msgs) resolvedTypes.push(msg[0] as symbol);
-		});
-		resolvedTypes.length = 0;
-		src2.down([[DIRTY], [DATA, 3]]); // still maps to "pos"
-		unsubR();
-		expect(resolvedTypes).toContain(RESOLVED);
-		expect(resolvedTypes).not.toContain(DATA);
-		void runsAfter;
-	});
-
-	it("ERROR propagation: upstream ERROR flows through map", () => {
-		// Spec: GRAPHREFLY-SPEC §1.3.4
-		const src = node([], { initial: 0 });
-		const m = map(src, (x) => x);
-		const types: symbol[] = [];
-		const unsub = m.subscribe((msgs) => {
-			for (const msg of msgs) types.push(msg[0] as symbol);
-		});
-		const err = new Error("up");
-		src.down([[ERROR, err]]);
-		unsub();
-		expect(types).toContain(ERROR);
-	});
-
-	it("COMPLETE propagation: upstream COMPLETE flows through map", () => {
-		// Spec: GRAPHREFLY-SPEC §1.3.4
-		const src = node([], { initial: 0 });
-		const m = map(src, (x) => x);
-		const types: symbol[] = [];
-		const unsub = m.subscribe((msgs) => {
-			for (const msg of msgs) types.push(msg[0] as symbol);
-		});
-		src.down([[COMPLETE]]);
-		unsub();
-		expect(types).toContain(COMPLETE);
-	});
-
-	it("reconnect after teardown: resubscribe receives fresh values", () => {
-		const src = node([], { initial: 1 });
-		const m = map(src, (x) => (x as number) * 2);
-		const unsub1 = m.subscribe(() => undefined);
-		unsub1();
-		const values: number[] = [];
-		const unsub2 = m.subscribe((msgs) => {
-			for (const msg of msgs) {
-				if (msg[0] === DATA) values.push(msg[1] as number);
-			}
-		});
-		src.down([[DATA, 5]]);
-		unsub2();
-		expect(values).toContain(10);
-	});
-});
-
-describe("Tier 1 operator matrix — filter", () => {
-	it("DIRTY arrives before DATA at subscriber", () => {
-		// Spec: GRAPHREFLY-SPEC §1.3.1
-		const src = node([], { initial: 1 });
-		const f = filter(src, (x) => (x as number) > 0);
-		const types: symbol[] = [];
-		const unsub = f.subscribe((msgs) => {
-			for (const msg of msgs) types.push(msg[0] as symbol);
-		});
-		types.length = 0;
-		src.down([[DIRTY], [DATA, 2]]);
-		unsub();
-		const dirtyIdx = types.indexOf(DIRTY);
-		const dataIdx = types.indexOf(DATA);
-		expect(dirtyIdx).toBeGreaterThanOrEqual(0);
-		expect(dataIdx).toBeGreaterThan(dirtyIdx);
-	});
-
-	it("RESOLVED suppression: filtered-out value emits RESOLVED not DATA", () => {
-		// Spec: GRAPHREFLY-SPEC §1.3.3
-		const src = node([], { initial: 5 });
-		const f = filter(src, (x) => (x as number) > 10);
-		const types: symbol[] = [];
-		const unsub = f.subscribe((msgs) => {
-			for (const msg of msgs) types.push(msg[0] as symbol);
-		});
-		types.length = 0;
-		src.down([[DIRTY], [DATA, 3]]); // 3 < 10 → filtered out → RESOLVED
-		unsub();
-		expect(types).toContain(RESOLVED);
-		expect(types).not.toContain(DATA);
-	});
-
-	it("ERROR propagation: upstream ERROR flows through filter", () => {
-		// Spec: GRAPHREFLY-SPEC §1.3.4
-		const src = node([], { initial: 0 });
-		const f = filter(src, (x) => (x as number) > 0);
-		const types: symbol[] = [];
-		const unsub = f.subscribe((msgs) => {
-			for (const msg of msgs) types.push(msg[0] as symbol);
-		});
-		src.down([[ERROR, new Error("up")]]);
-		unsub();
-		expect(types).toContain(ERROR);
-	});
-
-	it("COMPLETE propagation: upstream COMPLETE flows through filter", () => {
-		// Spec: GRAPHREFLY-SPEC §1.3.4
-		const src = node([], { initial: 0 });
-		const f = filter(src, (x) => (x as number) > 0);
-		const types: symbol[] = [];
-		const unsub = f.subscribe((msgs) => {
-			for (const msg of msgs) types.push(msg[0] as symbol);
-		});
-		src.down([[COMPLETE]]);
-		unsub();
-		expect(types).toContain(COMPLETE);
-	});
-
-	it("reconnect after teardown: resubscribe receives fresh values", () => {
-		const src = node([], { initial: 1 });
-		const f = filter(src, (x) => (x as number) > 0);
-		const unsub1 = f.subscribe(() => undefined);
-		unsub1();
-		const values: number[] = [];
-		const unsub2 = f.subscribe((msgs) => {
-			for (const msg of msgs) {
-				if (msg[0] === DATA) values.push(msg[1] as number);
-			}
-		});
-		src.down([[DATA, 5]]);
-		unsub2();
-		expect(values).toContain(5);
-	});
-});
-
-describe("Tier 1 operator matrix — scan", () => {
-	it("DIRTY arrives before DATA at subscriber", () => {
-		// Spec: GRAPHREFLY-SPEC §1.3.1
-		const src = node([], { initial: 0 });
-		const sc = scan(src, (a, x) => a + (x as number), 0);
-		const types: symbol[] = [];
-		const unsub = sc.subscribe((msgs) => {
-			for (const msg of msgs) types.push(msg[0] as symbol);
-		});
-		types.length = 0;
-		src.down([[DIRTY], [DATA, 1]]);
-		unsub();
-		const dirtyIdx = types.indexOf(DIRTY);
-		const dataIdx = types.indexOf(DATA);
-		expect(dirtyIdx).toBeGreaterThanOrEqual(0);
-		expect(dataIdx).toBeGreaterThan(dirtyIdx);
-	});
-
-	it("ERROR propagation: upstream ERROR flows through scan", () => {
-		// Spec: GRAPHREFLY-SPEC §1.3.4
-		const src = node([], { initial: 0 });
-		const sc = scan(src, (a, x) => a + (x as number), 0);
-		const types: symbol[] = [];
-		const unsub = sc.subscribe((msgs) => {
-			for (const msg of msgs) types.push(msg[0] as symbol);
-		});
-		src.down([[ERROR, new Error("up")]]);
-		unsub();
-		expect(types).toContain(ERROR);
-	});
-
-	it("COMPLETE propagation: upstream COMPLETE flows through scan", () => {
-		// Spec: GRAPHREFLY-SPEC §1.3.4
-		const src = node([], { initial: 0 });
-		const sc = scan(src, (a, x) => a + (x as number), 0);
-		const types: symbol[] = [];
-		const unsub = sc.subscribe((msgs) => {
-			for (const msg of msgs) types.push(msg[0] as symbol);
-		});
-		src.down([[COMPLETE]]);
-		unsub();
-		expect(types).toContain(COMPLETE);
-	});
-
-	it("reconnect after teardown: resubscribe accumulates fresh", () => {
-		const src = node([], { initial: 0 });
-		const sc = scan(src, (a, x) => a + (x as number), 0);
-		const unsub1 = sc.subscribe(() => undefined);
-		src.down([[DATA, 5]]);
-		unsub1();
-		// After teardown, resubscribe and push again
-		const values: number[] = [];
-		const unsub2 = sc.subscribe((msgs) => {
-			for (const msg of msgs) {
-				if (msg[0] === DATA) values.push(msg[1] as number);
-			}
-		});
-		src.down([[DATA, 3]]);
-		unsub2();
-		expect(values.length).toBeGreaterThan(0);
-	});
-
-	// DS-2.7.A QA D1 — wire-shape regression: pins the post-opt-in behavior on
-	// an immediate-COMPLETE source. Pre-DS-2.7.A scan-on-empty emitted
-	// `[seed (push-on-subscribe), COMPLETE]` (gate held; fn never fired; auto-
-	// COMPLETE propagated). Post-opt-in the gate releases on the
-	// terminal-only wave, fn fires once with `batch0` empty, emits
-	// `[[RESOLVED]]`, then auto-COMPLETE propagates — `[seed, RESOLVED, COMPLETE]`.
-	// RESOLVED is semantically a no-op for DATA consumers but IS a new wire-
-	// level message; this test pins it so a future predicate revert is loud.
-	it("scan(immediate-COMPLETE-source, …): seed → RESOLVED → COMPLETE wire shape (DS-2.7.A opt-in)", () => {
-		const src = node<number>([], { initial: 100 });
-		const sc = scan(src, (a, x) => a + (x as number), 0);
-		const types: symbol[] = [];
-		const dataVals: unknown[] = [];
-		const unsub = sc.subscribe((msgs) => {
-			for (const msg of msgs) {
-				types.push(msg[0] as symbol);
-				if (msg[0] === DATA) dataVals.push(msg[1]);
-			}
-		});
-		// Initial DATA via push-on-subscribe consumed (acc = 0 + 100 = 100).
-		// Now COMPLETE the source with no further DATA.
-		src.down([[COMPLETE]]);
-		// Wire shape: at least DATA(100) before COMPLETE; the post-DATA
-		// terminal wave routes through fn (RESOLVED) then `_maybeAutoTerminalAfterWave`
-		// fires COMPLETE.
-		expect(dataVals).toContain(100);
-		expect(types).toContain(COMPLETE);
-		// COMPLETE is the LAST emission (terminal); no DATA after it.
-		const lastIdx = types.lastIndexOf(COMPLETE);
-		const dataAfterComplete = types.slice(lastIdx + 1).some((t) => t === DATA);
-		expect(dataAfterComplete).toBe(false);
-		unsub();
-	});
-});
-
-describe("Tier 1 operator matrix — take", () => {
-	it("DIRTY arrives before DATA at subscriber", () => {
-		// Spec: GRAPHREFLY-SPEC §1.3.1
-		const src = node([], { initial: 0 });
-		const t = take(src, 5);
-		const types: symbol[] = [];
-		const unsub = t.subscribe((msgs) => {
-			for (const msg of msgs) types.push(msg[0] as symbol);
-		});
-		types.length = 0;
-		src.down([[DIRTY], [DATA, 1]]);
-		unsub();
-		const dirtyIdx = types.indexOf(DIRTY);
-		const dataIdx = types.indexOf(DATA);
-		expect(dirtyIdx).toBeGreaterThanOrEqual(0);
-		expect(dataIdx).toBeGreaterThan(dirtyIdx);
-	});
-
-	it("RESOLVED suppression: upstream RESOLVED flows as RESOLVED (no DATA)", () => {
-		// Spec: GRAPHREFLY-SPEC §1.3.3
-		const src = node([], { initial: 1 });
-		const t = take(src, 5);
-		// Push same value twice via a derived with equals
-		const derived2 = map(src, (x) => ((x as number) > 0 ? "pos" : "neg"));
-		const t2 = take(derived2, 5);
-		const types: symbol[] = [];
-		const unsub = t2.subscribe((msgs) => {
-			for (const msg of msgs) types.push(msg[0] as symbol);
-		});
-		types.length = 0;
-		src.down([[DIRTY], [DATA, 2]]); // still "pos"
-		unsub();
-		expect(types).toContain(RESOLVED);
-		expect(types).not.toContain(DATA);
-		void t;
-	});
-
-	it("ERROR propagation: upstream ERROR flows through take", () => {
-		// Spec: GRAPHREFLY-SPEC §1.3.4
-		const src = node([], { initial: 0 });
-		const t = take(src, 5);
-		const types: symbol[] = [];
-		const unsub = t.subscribe((msgs) => {
-			for (const msg of msgs) types.push(msg[0] as symbol);
-		});
-		src.down([[ERROR, new Error("up")]]);
-		unsub();
-		expect(types).toContain(ERROR);
-	});
-
-	it("COMPLETE propagation: upstream COMPLETE flows through take", () => {
-		// Spec: GRAPHREFLY-SPEC §1.3.4
-		const src = node([], { initial: 0 });
-		const t = take(src, 5);
-		const types: symbol[] = [];
-		const unsub = t.subscribe((msgs) => {
-			for (const msg of msgs) types.push(msg[0] as symbol);
-		});
-		src.down([[COMPLETE]]);
-		unsub();
-		expect(types).toContain(COMPLETE);
-	});
-
-	it("reconnect after teardown: resubscribe receives fresh values", () => {
-		const src = node<number>();
-		const t = take(src, 3);
-		const unsub1 = t.subscribe(() => undefined);
-		src.down([[DATA, 1]]);
-		unsub1();
-		const values: number[] = [];
-		const unsub2 = t.subscribe((msgs) => {
-			for (const msg of msgs) {
-				if (msg[0] === DATA) values.push(msg[1] as number);
-			}
-		});
-		src.down([[DATA, 7]]);
-		unsub2();
-		expect(values).toContain(7);
-	});
-
-	// DS-2.7.A QA F3 — pins the `terminalAsRealInput: true` motivation. An
-	// immediate-COMPLETE source (no prior DATA) must still emit COMPLETE
-	// downstream through `take(n>0)` — `completeWhenDepsComplete: false` means
-	// auto-COMPLETE is OFF; fn fires via the opt-in and forwards `[[COMPLETE]]`.
-	it("forwards COMPLETE on an immediate-COMPLETE source before count reached (no prior DATA)", () => {
-		const src = node<number>();
-		const t = take(src, 5);
-		const types: symbol[] = [];
-		const unsub = t.subscribe((msgs) => {
-			for (const msg of msgs) types.push(msg[0] as symbol);
-		});
-		src.down([[COMPLETE]]);
-		expect(types).toContain(COMPLETE);
-		unsub();
-	});
-});
-
-describe("Tier 1 operator matrix — takeWhile", () => {
-	it("DIRTY arrives before DATA at subscriber", () => {
-		// Spec: GRAPHREFLY-SPEC §1.3.1
-		const src = node([], { initial: 0 });
-		const tw = takeWhile(src, (x) => (x as number) < 100);
-		const types: symbol[] = [];
-		const unsub = tw.subscribe((msgs) => {
-			for (const msg of msgs) types.push(msg[0] as symbol);
-		});
-		types.length = 0;
-		src.down([[DIRTY], [DATA, 1]]);
-		unsub();
-		const dirtyIdx = types.indexOf(DIRTY);
-		const dataIdx = types.indexOf(DATA);
-		expect(dirtyIdx).toBeGreaterThanOrEqual(0);
-		expect(dataIdx).toBeGreaterThan(dirtyIdx);
-	});
-
-	it("ERROR propagation: upstream ERROR flows through takeWhile", () => {
-		// Spec: GRAPHREFLY-SPEC §1.3.4
-		const src = node([], { initial: 0 });
-		const tw = takeWhile(src, (x) => (x as number) < 100);
-		const types: symbol[] = [];
-		const unsub = tw.subscribe((msgs) => {
-			for (const msg of msgs) types.push(msg[0] as symbol);
-		});
-		src.down([[ERROR, new Error("up")]]);
-		unsub();
-		expect(types).toContain(ERROR);
-	});
-
-	it("COMPLETE propagation: upstream COMPLETE flows through takeWhile after predicate fails", () => {
-		// Spec: GRAPHREFLY-SPEC §1.3.4
-		// takeWhile only forwards COMPLETE once done=true (predicate failed);
-		// COMPLETE from upstream while predicate is still passing is intentionally not forwarded
-		// because the stream is still live. Only when the predicate gate closes does upstream
-		// COMPLETE propagate.
-		const src = node([], { initial: 0 });
-		const tw = takeWhile(src, (x) => (x as number) < 3);
-		const types: symbol[] = [];
-		const unsub = tw.subscribe((msgs) => {
-			for (const msg of msgs) types.push(msg[0] as symbol);
-		});
-		// Push a value that fails the predicate — this causes takeWhile to emit COMPLETE itself
-		src.down([[DATA, 5]]); // predicate fails → done=true, emits COMPLETE
-		// Now send upstream COMPLETE (with done=true, it should also forward)
-		src.down([[COMPLETE]]);
-		unsub();
-		expect(types).toContain(COMPLETE);
-	});
-
-	it("reconnect after teardown: resubscribe receives fresh values", () => {
-		const src = node([], { initial: 0 });
-		const tw = takeWhile(src, (x) => (x as number) < 100);
-		const unsub1 = tw.subscribe(() => undefined);
-		unsub1();
-		const values: number[] = [];
-		const unsub2 = tw.subscribe((msgs) => {
-			for (const msg of msgs) {
-				if (msg[0] === DATA) values.push(msg[1] as number);
-			}
-		});
-		src.down([[DATA, 5]]);
-		unsub2();
-		expect(values).toContain(5);
-	});
-
-	// DS-2.7.A QA F3 — pins the documented motivation for the
-	// `terminalAsRealInput: true` opt-in. Before the F1 fix, `takeWhile` on a
-	// COMPLETE-only-no-DATA source never propagated COMPLETE — the gate
-	// released (via the opt-in), fn fired with `batch0` empty, and fell into
-	// the `RESOLVED` branch with the node left alive forever
-	// (`completeWhenDepsComplete: false`). Post-F1 the fn forwards
-	// `[[COMPLETE]]` from the new `ctx.terminalDeps[0] === true` branch.
-	it("forwards COMPLETE on an immediate-COMPLETE source (no prior DATA)", () => {
-		const src = node<number>();
-		const tw = takeWhile(src, (x) => (x as number) < 3);
-		const types: symbol[] = [];
-		const unsub = tw.subscribe((msgs) => {
-			for (const msg of msgs) types.push(msg[0] as symbol);
-		});
-		src.down([[COMPLETE]]);
-		expect(types).toContain(COMPLETE);
-		unsub();
-	});
-});
-
-describe("Tier 1 operator matrix — skip", () => {
-	it("DIRTY arrives before DATA at subscriber (after skip threshold)", () => {
-		// Spec: GRAPHREFLY-SPEC §1.3.1
-		const src = node([], { initial: 0 });
-		const sk = skip(src, 0);
-		const types: symbol[] = [];
-		const unsub = sk.subscribe((msgs) => {
-			for (const msg of msgs) types.push(msg[0] as symbol);
-		});
-		types.length = 0;
-		src.down([[DIRTY], [DATA, 1]]);
-		unsub();
-		const dirtyIdx = types.indexOf(DIRTY);
-		const dataIdx = types.indexOf(DATA);
-		expect(dirtyIdx).toBeGreaterThanOrEqual(0);
-		expect(dataIdx).toBeGreaterThan(dirtyIdx);
-	});
-
-	it("ERROR propagation: upstream ERROR flows through skip", () => {
-		// Spec: GRAPHREFLY-SPEC §1.3.4
-		const src = node([], { initial: 0 });
-		const sk = skip(src, 0);
-		const types: symbol[] = [];
-		const unsub = sk.subscribe((msgs) => {
-			for (const msg of msgs) types.push(msg[0] as symbol);
-		});
-		src.down([[ERROR, new Error("up")]]);
-		unsub();
-		expect(types).toContain(ERROR);
-	});
-
-	it("COMPLETE propagation: upstream COMPLETE flows through skip", () => {
-		// Spec: GRAPHREFLY-SPEC §1.3.4
-		const src = node([], { initial: 0 });
-		const sk = skip(src, 0);
-		const types: symbol[] = [];
-		const unsub = sk.subscribe((msgs) => {
-			for (const msg of msgs) types.push(msg[0] as symbol);
-		});
-		src.down([[COMPLETE]]);
-		unsub();
-		expect(types).toContain(COMPLETE);
-	});
-
-	it("reconnect after teardown: resubscribe receives fresh values", () => {
-		const src = node([], { initial: 0 });
-		const sk = skip(src, 0);
-		const unsub1 = sk.subscribe(() => undefined);
-		unsub1();
-		const values: number[] = [];
-		const unsub2 = sk.subscribe((msgs) => {
-			for (const msg of msgs) {
-				if (msg[0] === DATA) values.push(msg[1] as number);
-			}
-		});
-		src.down([[DATA, 9]]);
-		unsub2();
-		expect(values).toContain(9);
-	});
-});
-
-describe("Tier 1 operator matrix — distinctUntilChanged", () => {
-	it("DIRTY arrives before DATA at subscriber", () => {
-		// Spec: GRAPHREFLY-SPEC §1.3.1
-		const src = node([], { initial: 1 });
-		const d = distinctUntilChanged(src);
-		const types: symbol[] = [];
-		const unsub = d.subscribe((msgs) => {
-			for (const msg of msgs) types.push(msg[0] as symbol);
-		});
-		types.length = 0;
-		src.down([[DIRTY], [DATA, 2]]);
-		unsub();
-		const dirtyIdx = types.indexOf(DIRTY);
-		const dataIdx = types.indexOf(DATA);
-		expect(dirtyIdx).toBeGreaterThanOrEqual(0);
-		expect(dataIdx).toBeGreaterThan(dirtyIdx);
-	});
-
-	it("RESOLVED suppression: duplicate value emits RESOLVED not DATA", () => {
-		// Spec: GRAPHREFLY-SPEC §1.3.3
-		const src = node([], { initial: 5 });
-		const d = distinctUntilChanged(src);
-		const types: symbol[] = [];
-		const unsub = d.subscribe((msgs) => {
-			for (const msg of msgs) types.push(msg[0] as symbol);
-		});
-		types.length = 0;
-		src.down([[DIRTY], [DATA, 5]]); // same value again
-		unsub();
-		expect(types).toContain(RESOLVED);
-		expect(types).not.toContain(DATA);
-	});
-
-	it("ERROR propagation: upstream ERROR flows through distinctUntilChanged", () => {
-		// Spec: GRAPHREFLY-SPEC §1.3.4
-		const src = node([], { initial: 0 });
-		const d = distinctUntilChanged(src);
-		const types: symbol[] = [];
-		const unsub = d.subscribe((msgs) => {
-			for (const msg of msgs) types.push(msg[0] as symbol);
-		});
-		src.down([[ERROR, new Error("up")]]);
-		unsub();
-		expect(types).toContain(ERROR);
-	});
-
-	it("COMPLETE propagation: upstream COMPLETE flows through distinctUntilChanged", () => {
-		// Spec: GRAPHREFLY-SPEC §1.3.4
-		const src = node([], { initial: 0 });
-		const d = distinctUntilChanged(src);
-		const types: symbol[] = [];
-		const unsub = d.subscribe((msgs) => {
-			for (const msg of msgs) types.push(msg[0] as symbol);
-		});
-		src.down([[COMPLETE]]);
-		unsub();
-		expect(types).toContain(COMPLETE);
-	});
-
-	it("reconnect after teardown: resubscribe receives fresh values", () => {
-		const src = node([], { initial: 0 });
-		const d = distinctUntilChanged(src);
-		const unsub1 = d.subscribe(() => undefined);
-		unsub1();
-		const values: number[] = [];
-		const unsub2 = d.subscribe((msgs) => {
-			for (const msg of msgs) {
-				if (msg[0] === DATA) values.push(msg[1] as number);
-			}
-		});
-		src.down([[DATA, 7]]);
-		unsub2();
-		expect(values).toContain(7);
-	});
-});
-
-describe("Tier 1 operator matrix — pairwise", () => {
-	it("DIRTY arrives before DATA at subscriber", () => {
-		// Spec: GRAPHREFLY-SPEC §1.3.1
-		const src = node([], { initial: 0 });
-		const p = pairwise(src);
-		const types: symbol[] = [];
-		const unsub = p.subscribe((msgs) => {
-			for (const msg of msgs) types.push(msg[0] as symbol);
-		});
-		// Seed first value, then push second to trigger pairwise DATA
-		src.down([[DATA, 1]]);
-		types.length = 0;
-		src.down([[DIRTY], [DATA, 2]]);
-		unsub();
-		const dirtyIdx = types.indexOf(DIRTY);
-		const dataIdx = types.indexOf(DATA);
-		expect(dirtyIdx).toBeGreaterThanOrEqual(0);
-		expect(dataIdx).toBeGreaterThan(dirtyIdx);
-	});
-
-	it("ERROR propagation: upstream ERROR flows through pairwise", () => {
-		// Spec: GRAPHREFLY-SPEC §1.3.4
-		const src = node([], { initial: 0 });
-		const p = pairwise(src);
-		const types: symbol[] = [];
-		const unsub = p.subscribe((msgs) => {
-			for (const msg of msgs) types.push(msg[0] as symbol);
-		});
-		src.down([[ERROR, new Error("up")]]);
-		unsub();
-		expect(types).toContain(ERROR);
-	});
-
-	it("COMPLETE propagation: upstream COMPLETE flows through pairwise", () => {
-		// Spec: GRAPHREFLY-SPEC §1.3.4
-		const src = node([], { initial: 0 });
-		const p = pairwise(src);
-		const types: symbol[] = [];
-		const unsub = p.subscribe((msgs) => {
-			for (const msg of msgs) types.push(msg[0] as symbol);
-		});
-		src.down([[COMPLETE]]);
-		unsub();
-		expect(types).toContain(COMPLETE);
-	});
-
-	it("reconnect after teardown: resubscribe gets fresh pair on two pushes", () => {
-		const src = node([], { initial: 0 });
-		const p = pairwise(src);
-		const unsub1 = p.subscribe(() => undefined);
-		src.down([[DATA, 1]]);
-		src.down([[DATA, 2]]);
-		unsub1();
-		const values: unknown[] = [];
-		const unsub2 = p.subscribe((msgs) => {
-			for (const msg of msgs) {
-				if (msg[0] === DATA) values.push(msg[1]);
-			}
-		});
-		src.down([[DATA, 3]]);
-		src.down([[DATA, 4]]);
-		unsub2();
-		expect(values.length).toBeGreaterThan(0);
-	});
-});
-
-describe("Tier 1 operator matrix — reduce", () => {
-	it("ERROR propagation: upstream ERROR flows through reduce", () => {
-		// Spec: GRAPHREFLY-SPEC §1.3.4
-		const src = node([], { initial: 0 });
-		const r = reduce(src, (a, x) => a + (x as number), 0);
-		const types: symbol[] = [];
-		const unsub = r.subscribe((msgs) => {
-			for (const msg of msgs) types.push(msg[0] as symbol);
-		});
-		src.down([[ERROR, new Error("up")]]);
-		unsub();
-		expect(types).toContain(ERROR);
-	});
-
-	it("reconnect after teardown: resubscribe emits on COMPLETE (accumulated value)", () => {
-		// reduce is stateful across subscriptions unless resubscribable:true is set.
-		// After teardown and re-subscribe, it still emits on upstream COMPLETE.
-		const src = node([], { initial: 0 });
-		const r = reduce(src, (a, x) => a + (x as number), 0);
-		const unsub1 = r.subscribe(() => undefined);
-		unsub1();
-		const values: number[] = [];
-		const unsub2 = r.subscribe((msgs) => {
-			for (const msg of msgs) {
-				if (msg[0] === DATA) values.push(msg[1] as number);
-			}
-		});
-		src.down([[DATA, 5]]);
-		src.down([[COMPLETE]]);
-		unsub2();
-		// reduce emits on COMPLETE — values array must have at least one entry
-		expect(values.length).toBeGreaterThan(0);
-	});
-});
-
-// ---------------------------------------------------------------------------
-// Tier 2 — teardown and reconnect freshness
-// ---------------------------------------------------------------------------
-
-describe("Tier 2 teardown and reconnect freshness — switchMap", () => {
-	afterEach(() => {
-		vi.useRealTimers();
-	});
-
-	it("after teardown, resubscribe creates a new inner subscription (old state not retained)", () => {
-		// Spec: GRAPHREFLY-SPEC §2
-		const src = node([], { initial: 0 });
-		let innerCallCount = 0;
-		const out = switchMap(src, (v) => {
-			innerCallCount += 1;
-			return node([], { initial: (v as number) * 10 });
-		});
-		const unsub1 = out.subscribe(() => undefined);
-		const firstCount = innerCallCount;
-		unsub1();
-		// Resubscribe — a fresh inner subscription should be created
-		const values: number[] = [];
-		const unsub2 = out.subscribe((msgs) => {
-			for (const msg of msgs) {
-				if (msg[0] === DATA) values.push(msg[1] as number);
-			}
-		});
-		src.down([[DATA, 2]]);
-		unsub2();
-		expect(innerCallCount).toBeGreaterThan(firstCount);
-		expect(values).toContain(20);
-	});
-});
-
-describe("Tier 2 teardown and reconnect freshness — debounce", () => {
-	afterEach(() => {
-		vi.useRealTimers();
-	});
-
-	it("after teardown, timers are cleared — no stale emissions after unsubscribe + timer advance", () => {
-		// Spec: GRAPHREFLY-SPEC §1.3
-		vi.useFakeTimers();
-		const src = node([], { initial: 0 });
-		const out = debounce(src, 50);
-		const staleValues: number[] = [];
-		const unsub = out.subscribe((msgs) => {
-			for (const msg of msgs) {
-				if (msg[0] === DATA) staleValues.push(msg[1] as number);
-			}
-		});
-		src.down([[DATA, 1]]);
-		// Unsubscribe before timer fires — teardown must clear pending timer
-		unsub();
-		// Advance time past the debounce window
-		vi.advanceTimersByTime(100);
-		// No stale emission should have arrived after unsubscribe
-		expect(staleValues.length).toBe(0);
-	});
-});
-
-describe("Tier 2 teardown and reconnect freshness — concatMap", () => {
-	afterEach(() => {
-		vi.useRealTimers();
-	});
-
-	it("after teardown + resubscribe, queue is fresh (no buffered items from previous subscription)", () => {
-		// Spec: GRAPHREFLY-SPEC §2
-		// Verify that after teardown and resubscribe, the concatMap processes
-		// new outer values fresh (no stale buffered items leak across subscriptions).
-		const src = node([], { initial: 0 });
-		let wave = 0;
-		const out = concatMap(src, (v) => {
-			wave += 1;
-			return node([], { initial: (v as number) * 100 });
-		});
-		const unsub1 = out.subscribe(() => undefined);
-		src.down([[DATA, 1]]);
-		unsub1();
-		const _prevWave = wave;
-		// Resubscribe — push-on-subscribe replays src's cached value through concatMap
-		const values: number[] = [];
-		const unsub2 = out.subscribe((msgs) => {
-			for (const msg of msgs) {
-				if (msg[0] === DATA) values.push(msg[1] as number);
-			}
-		});
-		// Output compute node clears its cache on disconnect (ROM/RAM rule).
-		// Resubscribe re-runs concatMap with the source's current value, emitting
-		// fresh DATA to the new sink.
-		expect(values.length).toBeGreaterThan(0);
-		unsub2();
-	});
-});
-
-// ---------------------------------------------------------------------------
-// Diamond resolution through operator chain — recompute count
-// ---------------------------------------------------------------------------
-
-describe("diamond resolution through operator chain", () => {
-	it("source → map as A, map as B → combine([A, B]): DATA emitted exactly once per push", () => {
-		// Spec: GRAPHREFLY-SPEC §2 (diamond resolution)
-		// A and B both depend on src; combine waits for both to settle before recomputing.
-		// Exactly one DATA message should reach the combine subscriber per src push.
-		const src = node([], { initial: 0 });
-		const a = map(src, (x) => x);
-		const b = map(src, (x) => x);
-		const c = combine(a, b);
-		let dataCount = 0;
-		const unsub = c.subscribe((msgs) => {
-			for (const msg of msgs) {
-				if (msg[0] === DATA) dataCount += 1;
-			}
-		});
-		dataCount = 0;
-		src.down([[DIRTY], [DATA, 5]]);
-		expect(dataCount).toBe(1);
-		expect(c.cache).toEqual([5, 5]);
-		unsub();
-	});
-});
-
-// ---------------------------------------------------------------------------
-// D8 / SENTINEL dep safety — operators must not corrupt state when dep is
-// SENTINEL (no cached DATA). Regression: operator fn received undefined from
-// dep.cache and processed it as real data.
-// ---------------------------------------------------------------------------
-describe("SENTINEL dep safety (D8 fallback)", () => {
-	it("switchMap does not call project until real DATA arrives", () => {
-		const trigger = node<number>();
-		let projectCalls = 0;
-		const out = switchMap(trigger, (_v) => {
-			projectCalls++;
-			return node([], { initial: "inner" });
-		});
-		const { messages, unsub } = collect(out, { flat: true });
-		expect(projectCalls).toBe(0);
-		expect(messages.filter((m) => m[0] === DATA)).toHaveLength(0);
-		trigger.down([[DATA, 1]]);
-		expect(projectCalls).toBe(1);
-		expect(messages.some((m) => m[0] === DATA && m[1] === "inner")).toBe(true);
-		unsub();
-	});
-
-	it("exhaustMap does not call project until real DATA arrives", () => {
-		const trigger = node<number>();
-		let projectCalls = 0;
-		const out = exhaustMap(trigger, (_v) => {
-			projectCalls++;
-			return node([], { initial: "inner" });
-		});
-		const { unsub } = collect(out, { flat: true });
-		expect(projectCalls).toBe(0);
-		trigger.down([[DATA, 1]]);
-		expect(projectCalls).toBe(1);
-		unsub();
-	});
-
-	it("concatMap does not call project until real DATA arrives", () => {
-		const trigger = node<number>();
-		let projectCalls = 0;
-		const out = concatMap(trigger, (_v) => {
-			projectCalls++;
-			return node([], { initial: "inner" });
-		});
-		const { unsub } = collect(out, { flat: true });
-		expect(projectCalls).toBe(0);
-		trigger.down([[DATA, 1]]);
-		expect(projectCalls).toBe(1);
-		unsub();
-	});
-
-	it("mergeMap does not call project until real DATA arrives", () => {
-		const trigger = node<number>();
-		let projectCalls = 0;
-		const out = mergeMap(trigger, (_v) => {
-			projectCalls++;
-			return node([], { initial: "inner" });
-		});
-		const { unsub } = collect(out, { flat: true });
-		expect(projectCalls).toBe(0);
-		trigger.down([[DATA, 1]]);
-		expect(projectCalls).toBe(1);
-		unsub();
-	});
-
-	it("reduce does not accumulate SENTINEL undefined as data", () => {
-		const trigger = node<number>();
-		const out = reduce(trigger, (acc, v) => acc + v, 0);
-		const { messages, unsub } = collect(out, { flat: true });
-		trigger.down([[DATA, 10]]);
-		trigger.down([[DATA, 20]]);
-		trigger.down([[COMPLETE]]);
-		const dataVals = messages.filter((m) => m[0] === DATA).map((m) => m[1]);
-		expect(dataVals).toContain(30);
-		unsub();
-	});
-
-	it("takeWhile does not evaluate predicate on SENTINEL undefined", () => {
-		const trigger = node<number>();
-		let predicateCalls = 0;
-		const out = takeWhile(trigger, (v) => {
-			predicateCalls++;
-			return v < 10;
-		});
-		const { unsub } = collect(out, { flat: true });
-		expect(predicateCalls).toBe(0);
-		trigger.down([[DATA, 5]]);
-		expect(predicateCalls).toBe(1);
-		unsub();
-	});
-
-	it("last does not emit SENTINEL undefined on COMPLETE", () => {
-		const trigger = node<number>();
-		const out = last(trigger);
-		const { messages, unsub } = collect(out, { flat: true });
-		trigger.down([[COMPLETE]]);
-		const dataVals = messages.filter((m) => m[0] === DATA);
-		expect(dataVals).toHaveLength(0);
-		unsub();
-	});
-
-	it("bufferCount does not include SENTINEL undefined in buffer", () => {
-		const trigger = node<number>();
-		const out = bufferCount(trigger, 2);
-		const { messages, unsub } = collect(out, { flat: true });
-		trigger.down([[DATA, 1]]);
-		trigger.down([[DATA, 2]]);
-		const dataVals = messages.filter((m) => m[0] === DATA).map((m) => m[1]);
-		expect(dataVals).toEqual([[1, 2]]);
-		unsub();
-	});
-});
-
-describe("withLatestFrom — secondary dep semantics", () => {
-	it("primary fires before secondary has any value — no DATA emitted (sentinel gate)", () => {
-		// Secondary has never emitted; _sentinelDepCount > 0 keeps fn gated.
-		const primary = node<number>();
-		const secondary = node<number>();
-		const w = withLatestFrom(primary, secondary);
-		const { messages, unsub } = collect(w, { flat: true });
-		primary.down([[DATA, 1]]);
-		expect(messages.filter((m) => m[0] === DATA)).toHaveLength(0);
-		unsub();
-	});
-
-	it("secondary updates, then primary fires — pairs with latest secondary value", () => {
-		const primary = node<number>();
-		const secondary = node([], { initial: 10 });
-		const w = withLatestFrom(primary, secondary);
-		const { messages, unsub } = collect(w, { flat: true });
-		secondary.down([[DATA, 20]]);
-		primary.down([[DATA, 1]]);
-		const dataVals = messages.filter((m) => m[0] === DATA).map((m) => m[1]);
-		expect(dataVals).toEqual([[1, 20]]);
-		unsub();
-	});
-
-	it("secondary COMPLETE — operator continues, primary still emits with frozen secondary value", () => {
-		// Secondary completes; autoComplete requires ALL deps terminal so
-		// withLatestFrom does not complete. ctx.prevData[1] retains the
-		// last secondary value for future primary emissions.
-		const primary = node<number>();
-		const secondary = node([], { initial: 10 });
-		const w = withLatestFrom(primary, secondary);
-		const { messages, unsub } = collect(w, { flat: true });
-		secondary.down([[COMPLETE]]);
-		primary.down([[DATA, 5]]);
-		const dataVals = messages.filter((m) => m[0] === DATA).map((m) => m[1]);
-		expect(dataVals).toEqual([[5, 10]]);
-		expect(messages.filter((m) => m[0] === COMPLETE || m[0] === ERROR)).toHaveLength(0);
-		unsub();
-	});
-
-	it("secondary ERROR — propagates to output (autoError)", () => {
-		// Both deps must be settled (sentinelDepCount=0) for _maybeAutoTerminalAfterWave
-		// to fire. A sentinel primary blocks terminal propagation from secondary — see
-		// "withLatestFrom sentinel gate swallows secondary ERROR" in docs/optimizations.md.
-		const primary = node([], { initial: 1 });
-		const secondary = node([], { initial: 10 });
-		const w = withLatestFrom(primary, secondary);
-		const { messages, unsub } = collect(w, { flat: true });
-		secondary.down([[ERROR, new Error("secondary failed")]]);
-		const errorMsgs = messages.filter((m) => m[0] === ERROR);
-		expect(errorMsgs).toHaveLength(1);
-		expect((errorMsgs[0]?.[1] as Error).message).toBe("secondary failed");
-		unsub();
-	});
-
-	it("secondary COMPLETE without prior DATA — primary emission suppressed (RESOLVED)", () => {
-		// secondary completes before ever emitting DATA.
-		// withLatestFrom has no value to pair — suppress the emission.
-		const primary = node<number>();
-		const secondary = node<number>(); // raw, never emits DATA
-		const w = withLatestFrom(primary, secondary);
-		const { messages, unsub } = collect(w, { flat: true });
-		secondary.down([[COMPLETE]]); // completes without DATA
-		primary.down([[DATA, 5]]);
-		const dataVals = messages.filter((m) => m[0] === DATA);
-		expect(dataVals).toHaveLength(0); // no pairable value → suppress
-		unsub();
-	});
-});
-
-// ---------------------------------------------------------------------------
-// Phase 13.E — valve `abortInFlight` opt
-// ---------------------------------------------------------------------------
-
-describe("valve abortInFlight (Phase 13.E / DS-13.E)", () => {
-	it("calls controller.abort() on the truthy → falsy edge", () => {
-		const ctrl = new AbortController();
-		const src = node<number>([], { initial: 1 });
-		const open = node<boolean>([], { initial: true });
-		const v = valve(src, open, { abortInFlight: ctrl });
-		const { unsub } = collect(v);
-
-		expect(ctrl.signal.aborted).toBe(false);
-		open.emit(false);
-		expect(ctrl.signal.aborted).toBe(true);
-
-		unsub();
-	});
-
-	it("does not abort on activation when control starts falsy (no transition)", () => {
-		const ctrl = new AbortController();
-		const src = node<number>([], { initial: 1 });
-		const open = node<boolean>([], { initial: false });
-		const v = valve(src, open, { abortInFlight: ctrl });
-		const { unsub } = collect(v);
-
-		// Initial state is closed; no DATA-driven transition has fired yet.
-		expect(ctrl.signal.aborted).toBe(false);
-
-		unsub();
-	});
-
-	it("does not abort on falsy → truthy → falsy second close (single-shot — controller is already aborted)", () => {
-		const ctrl = new AbortController();
-		const src = node<number>([], { initial: 1 });
-		const open = node<boolean>([], { initial: true });
-		const v = valve(src, open, { abortInFlight: ctrl });
-		const { unsub } = collect(v);
-
-		open.emit(false);
-		expect(ctrl.signal.aborted).toBe(true);
-
-		// Re-opening the gate AFTER an abort has fired — the AbortController is
-		// already aborted, so a subsequent close is a no-op (.abort() is
-		// idempotent per spec).
-		open.emit(true);
-		open.emit(false);
-		expect(ctrl.signal.aborted).toBe(true);
-
-		unsub();
-	});
-
-	it("does not abort when no abortInFlight is provided (backwards compat)", () => {
-		const src = node<number>([], { initial: 1 });
-		const open = node<boolean>([], { initial: true });
-		const v = valve(src, open);
-		const { unsub } = collect(v);
-		open.emit(false);
-		// No abortInFlight — nothing to assert beyond the lack of an exception.
-		// The valve still emits RESOLVED on close (covered in sources.test.ts).
-		unsub();
-	});
-
-	it("forwards source DATA while open, regardless of abortInFlight", () => {
-		const ctrl = new AbortController();
-		const src = node<number>([], { initial: 1 });
-		const open = node<boolean>([], { initial: true });
-		const v = valve(src, open, { abortInFlight: ctrl });
-		const { messages, unsub } = collect(v, { flat: true });
-
-		src.emit(2);
-		src.emit(3);
-
-		const dataVals = messages.filter((m) => m[0] === DATA).map((m) => m[1]);
-		expect(dataVals).toContain(2);
-		expect(dataVals).toContain(3);
-		expect(ctrl.signal.aborted).toBe(false);
-		unsub();
-	});
-});
-
-// ---------------------------------------------------------------------------
-// DS-14.5 — AB-2 (*Map.abortInFlight) + AB-3 (factory form)
-// ---------------------------------------------------------------------------
-
-describe("DS-14.5 AB-2/AB-3 — abortInFlight on valve + *Map", () => {
-	it("AB-3: valve factory form mints/aborts the live controller per cycle", () => {
-		let live: AbortController | undefined;
-		const src = node<number>([], { initial: 1 });
-		const open = node<boolean>([], { initial: true });
-		const { unsub } = collect(valve(src, open, { abortInFlight: () => live }));
-
-		const c1 = new AbortController();
-		live = c1;
-		open.emit(false);
-		expect(c1.signal.aborted).toBe(true);
-
-		open.emit(true);
-		const c2 = new AbortController();
-		live = c2;
-		open.emit(false);
-		expect(c2.signal.aborted).toBe(true);
-		expect(c1.signal.aborted).toBe(true); // c1 stays spent
-		unsub();
-	});
-
-	it("AB-2: switchMap supersede fires abortInFlight for the prior inner", () => {
-		let current: AbortController | undefined;
-		const srcN = node<number>([], { initial: 1 });
-		const out = switchMap(
-			srcN,
-			(n) => {
-				current = new AbortController();
-				return node<number>([], { initial: n as number });
-			},
-			{ abortInFlight: () => current },
-		);
-		const { unsub } = collect(out);
-		const first = current;
-		expect(first?.signal.aborted).toBe(false);
-		srcN.emit(2); // supersede
-		expect(first?.signal.aborted).toBe(true);
-		unsub();
-	});
-
-	it("AB-2: mergeMap aborts all in-flight inners on source ERROR", () => {
-		const ctrl = new AbortController();
-		const srcN = node<number>([], { initial: 1 });
-		const out = mergeMap(srcN, (n) => node<number>([], { initial: n as number }), {
-			abortInFlight: ctrl,
-		});
-		const { unsub } = collect(out);
-		expect(ctrl.signal.aborted).toBe(false);
-		srcN.down([[ERROR, new Error("boom")]]);
-		expect(ctrl.signal.aborted).toBe(true);
-		unsub();
-	});
-});
-
-// ---------------------------------------------------------------------------
-// Phase 13.L — `settle` operator
-// ---------------------------------------------------------------------------
-
-describe("settle (Phase 13.L / DS-13.L) — convergence detector", () => {
-	// `equals: () => false` defeats the source node's default Object.is dedup
-	// so every emit() fires a real wave that settle can count. Real-world
-	// callers usually feed settle from upstream operators / topic streams
-	// that don't dedup; this is the test-fixture knob.
-	const noDedup = { equals: () => false };
-
-	it("forwards each upstream DATA unchanged", () => {
-		const src = node<number>([], { initial: 1, ...noDedup });
-		const s = settle(src, { quietWaves: 3, equals: (a, b) => a === b });
-		const { messages, unsub } = collect(s, { flat: true });
-
-		src.emit(2);
-		src.emit(3);
-
-		const dataVals = messages.filter((m) => m[0] === DATA).map((m) => m[1]);
-		expect(dataVals).toEqual([1, 2, 3]);
-		unsub();
-	});
-
-	it("emits COMPLETE after `quietWaves` consecutive no-change waves under `equals`", () => {
-		const src = node<number>([], { initial: 1, ...noDedup });
-		const s = settle(src, { quietWaves: 2, equals: (a, b) => a === b });
-		const { messages, unsub } = collect(s, { flat: true });
-
-		// Initial activation: wave 1, sees DATA=1 (change vs SENTINEL).
-		// Re-emit 1 twice — under `equals`, both count as quiet.
-		src.emit(1);
-		src.emit(1);
-
-		const completeMsgs = messages.filter((m) => m[0] === COMPLETE);
-		expect(completeMsgs).toHaveLength(1);
-		unsub();
-	});
-
-	it("resets the quiet counter when DATA changes", () => {
-		const src = node<number>([], { initial: 1, ...noDedup });
-		const s = settle(src, { quietWaves: 2, equals: (a, b) => a === b });
-		const { messages, unsub } = collect(s, { flat: true });
-
-		// One quiet wave (re-emit 1).
-		src.emit(1);
-		// Real change — resets counter.
-		src.emit(2);
-		// One quiet wave (re-emit 2) — should NOT complete yet (need 2 in a row).
-		src.emit(2);
-
-		expect(messages.filter((m) => m[0] === COMPLETE)).toHaveLength(0);
-
-		// Second quiet — now completes.
-		src.emit(2);
-		expect(messages.filter((m) => m[0] === COMPLETE)).toHaveLength(1);
-		unsub();
-	});
-
-	it("without `equals`, every DATA wave resets the quiet counter (strict no-DATA semantics)", () => {
-		const src = node<number>([], { initial: 1, ...noDedup });
-		// No `equals` — only true "no DATA in this wave" counts as quiet.
-		const s = settle(src, { quietWaves: 3 });
-		const { messages, unsub } = collect(s, { flat: true });
-
-		// Even repeated emits of the same value reset the counter under strict
-		// semantics (no `equals`).
-		src.emit(1);
-		src.emit(1);
-		src.emit(1);
-		src.emit(1);
-
-		// Five total DATA waves; never any quiet waves → no COMPLETE.
-		expect(messages.filter((m) => m[0] === COMPLETE)).toHaveLength(0);
-		unsub();
-	});
-
-	it("`maxWaves` forces COMPLETE on cap regardless of convergence", () => {
-		const src = node<number>([], { initial: 0, ...noDedup });
-		const s = settle(src, { quietWaves: 100, maxWaves: 3 });
-		const { messages, unsub } = collect(s, { flat: true });
-
-		// quietWaves is 100 (effectively unreachable). maxWaves=3 forces COMPLETE
-		// on the third wave. Initial activation counts as wave 1.
-		src.emit(1); // wave 2
-		src.emit(2); // wave 3 → maxWaves reached → COMPLETE
-
-		expect(messages.filter((m) => m[0] === COMPLETE)).toHaveLength(1);
-		unsub();
-	});
-
-	it("rejects invalid quietWaves at construction", () => {
-		const src = node<number>([], { initial: 1 });
-		expect(() => settle(src, { quietWaves: 0 })).toThrow(RangeError);
-		expect(() => settle(src, { quietWaves: -1 })).toThrow(RangeError);
-		expect(() => settle(src, { quietWaves: 1.5 })).toThrow(RangeError);
-	});
-
-	it("rejects invalid maxWaves at construction", () => {
-		const src = node<number>([], { initial: 1 });
-		expect(() => settle(src, { quietWaves: 1, maxWaves: 0 })).toThrow(RangeError);
-		expect(() => settle(src, { quietWaves: 1, maxWaves: -1 })).toThrow(RangeError);
-		expect(() => settle(src, { quietWaves: 1, maxWaves: 1.5 })).toThrow(RangeError);
-	});
-
-	it("upstream COMPLETE propagates through (terminal-deps default)", () => {
-		const src = node<number>([], { initial: 1 });
-		const s = settle(src, { quietWaves: 100 });
-		const { messages, unsub } = collect(s, { flat: true });
-
-		src.down([[COMPLETE]]);
-
-		expect(messages.filter((m) => m[0] === COMPLETE)).toHaveLength(1);
-		unsub();
-	});
-});
diff --git a/packages/pure-ts/src/__tests__/extra/reactive-data-structures.test.ts b/packages/pure-ts/src/__tests__/extra/reactive-data-structures.test.ts
deleted file mode 100644
index 58d986b0..00000000
--- a/packages/pure-ts/src/__tests__/extra/reactive-data-structures.test.ts
+++ /dev/null
@@ -1,342 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { batch } from "../../core/batch.js";
-import { DATA, DIRTY } from "../../core/messages.js";
-import { node } from "../../core/node.js";
-import { reactiveIndex } from "../../extra/data-structures/reactive-index.js";
-import { reactiveList } from "../../extra/data-structures/reactive-list.js";
-import { reactiveLog } from "../../extra/data-structures/reactive-log.js";
-import { appendLogStorage, memoryBackend } from "../../extra/storage/tiers.js";
-import { collect } from "../test-helpers.js";
-
-describe("extra reactiveLog / logSlice (roadmap §3.2)", () => {
-	it("append and clear emit versioned snapshots", () => {
-		const lg = reactiveLog<number>();
-		const { batches, unsub } = collect(lg.entries);
-		lg.append(1);
-		unsub();
-		const flat = (batches as [symbol, unknown][][]).flat();
-		expect(flat.some((m) => m[0] === DIRTY)).toBe(true);
-		// Push-on-subscribe delivers the initial cached empty array first;
-		// find the DATA that contains the appended value.
-		const dataMessages = flat.filter((m) => m[0] === DATA) as [symbol, readonly number[]][];
-		const appended = dataMessages.find((m) => (m[1] as readonly number[]).length > 0);
-		expect(appended).toBeDefined();
-		expect([...appended![1]]).toEqual([1]);
-	});
-
-	it("tail returns last n entries", () => {
-		const lg = reactiveLog<string>();
-		lg.append("a");
-		lg.append("b");
-		const tail = lg.view({ kind: "tail", n: 1 });
-		expect(tail.cache).toEqual(["b"]);
-	});
-
-	it("slice matches tuple slice semantics", () => {
-		const lg = reactiveLog([0, 1, 2, 3]);
-		const sl = lg.view({ kind: "slice", start: 1, stop: 3 });
-		expect(sl.cache).toEqual([1, 2]);
-	});
-
-	// Regression: memo:Re P0 (2026-05-16). N sequential append() waves each
-	// scheduled a microtask-chained doFlush() on the no-debounce tier; a single
-	// await tier.flush() short-circuited (pending empty) and resolved before the
-	// in-flight chain drained, so only wave #1 ("a") was durable. fix:
-	// appendLogStorage.flushNow returns the outstanding flushChain when pending
-	// is empty. appendMany (one wave) was the passing control.
-	it("attachStorage persists EVERY sequential append wave, not just the first", async () => {
-		const backend = memoryBackend();
-		const tier = appendLogStorage<string>(backend, { name: "L" });
-		const log = reactiveLog<string>([], { name: "L" });
-		log.attachStorage([tier]);
-		log.append("a");
-		log.append("b");
-		log.append("c");
-		log.append("d");
-		await tier.flush?.();
-		const loaded = await tier.loadEntries!();
-		expect(loaded.entries).toEqual(["a", "b", "c", "d"]);
-	});
-
-	it("attachStorage appendMany control (single wave) persists all", async () => {
-		const backend = memoryBackend();
-		const tier = appendLogStorage<string>(backend, { name: "L" });
-		const log = reactiveLog<string>([], { name: "L" });
-		log.attachStorage([tier]);
-		log.appendMany(["a", "b", "c", "d"]);
-		await tier.flush?.();
-		const loaded = await tier.loadEntries!();
-		expect(loaded.entries).toEqual(["a", "b", "c", "d"]);
-	});
-
-	it("attachStorage flush() drains the in-flight chain against an ASYNC backend", async () => {
-		// Locks the C3 serialized-chain path: async read/write force every
-		// doFlush onto the promise chain; flush() must still await all of it.
-		const store = new Map<string, Uint8Array>();
-		const asyncBackend = {
-			name: "async-mem",
-			async read(k: string) {
-				await Promise.resolve();
-				const v = store.get(k);
-				return v === undefined ? undefined : new Uint8Array(v);
-			},
-			async write(k: string, b: Uint8Array) {
-				await Promise.resolve();
-				store.set(k, new Uint8Array(b));
-			},
-			async delete(k: string) {
-				store.delete(k);
-			},
-			list: (p?: string) => [...store.keys()].filter((k) => (p ? k.startsWith(p) : true)).sort(),
-		};
-		const tier = appendLogStorage<string>(asyncBackend, { name: "A" });
-		const log = reactiveLog<string>([], { name: "A" });
-		log.attachStorage([tier]);
-		log.append("x");
-		log.append("y");
-		log.append("z");
-		await tier.flush?.();
-		const loaded = await tier.loadEntries!();
-		expect(loaded.entries).toEqual(["x", "y", "z"]);
-	});
-
-	// QA/D3 regression: flush() now returns the in-flight chain when pending
-	// is empty, so a failed in-flight write SURFACES on `await tier.flush()`
-	// (was: silently resolved). Locks the durability error-surfacing contract
-	// the Rust parity arm must mirror (cross-track-ledger §2).
-	it("attachStorage flush() rejects when an in-flight chained write fails", async () => {
-		const failing = {
-			name: "failing",
-			read: async () => undefined,
-			write: async () => {
-				await Promise.resolve();
-				throw new Error("backend write failed");
-			},
-			delete: async () => {},
-			list: () => [],
-		};
-		const tier = appendLogStorage<string>(failing, { name: "F" });
-		const log = reactiveLog<string>([], { name: "F" });
-		log.attachStorage([tier]);
-		log.append("a");
-		log.append("b");
-		await expect(tier.flush?.()).rejects.toThrow("backend write failed");
-	});
-
-	// QA/F9 regression (option A): a debounced tier has no internal flush
-	// timer and attachStorage's per-wave path is suppressed for it — without
-	// a driver it buffered forever (silent data loss). attachStorage now
-	// drives a reactive fromTimer flush per debounced tier, AND a final
-	// best-effort drain on teardown.
-	it("attachStorage drives a debounced tier's flush via reactive timer", async () => {
-		const backend = memoryBackend();
-		const tier = appendLogStorage<string>(backend, { name: "D", debounceMs: 10 });
-		const log = reactiveLog<string>([], { name: "D" });
-		log.attachStorage([tier]);
-		log.append("a");
-		log.append("b");
-		// No explicit flush(), no teardown — only the reactive timer drives it.
-		await new Promise((r) => setTimeout(r, 60)); // > 1 period (10ms), generous
-		await tier.flush?.(); // drain any in-flight chain (durability fix)
-		const loaded = await tier.loadEntries!();
-		expect(loaded.entries).toEqual(["a", "b"]);
-	});
-
-	it("attachStorage detach drains a debounced tier's last buffered window", async () => {
-		const backend = memoryBackend();
-		const tier = appendLogStorage<string>(backend, {
-			name: "DT",
-			debounceMs: 100_000, // long — timer will NOT fire during the test
-		});
-		const log = reactiveLog<string>([], { name: "DT" });
-		const detach = log.attachStorage([tier]);
-		log.append("x");
-		log.append("y");
-		detach(); // teardown final-flush schedules the drain
-		await tier.flush?.(); // await the in-flight drain
-		const loaded = await tier.loadEntries!();
-		expect(loaded.entries).toEqual(["x", "y"]);
-	});
-
-	// QA/rollback strong-semantic regression: rollback() bumps an epoch;
-	// a doFlush whose buckets were captured pre-rollback is skipped at entry,
-	// so rolled-back-but-already-chained entries are NOT persisted (was: the
-	// in-flight chained write still committed them).
-	it("rollback() aborts an in-flight chained write scheduled before it", async () => {
-		const store = new Map<string, Uint8Array>();
-		const asyncBackend = {
-			name: "async-mem",
-			async read(k: string) {
-				await Promise.resolve();
-				const v = store.get(k);
-				return v === undefined ? undefined : new Uint8Array(v);
-			},
-			async write(k: string, b: Uint8Array) {
-				await Promise.resolve();
-				store.set(k, new Uint8Array(b));
-			},
-			async delete(k: string) {
-				store.delete(k);
-			},
-			list: () => [...store.keys()].sort(),
-		};
-		const tier = appendLogStorage<string>(asyncBackend, { name: "R" });
-		// No-debounce → appendEntries schedules a chained (async) doFlush.
-		tier.appendEntries(["a", "b"]);
-		await tier.rollback?.(); // bump epoch BEFORE the chained doFlush runs
-		await tier.flush?.(); // drains the chain — doFlush no-ops (epoch stale)
-		const loaded = await tier.loadEntries!();
-		expect(loaded.entries).toEqual([]);
-	});
-
-	it("rollback() does NOT abort writes scheduled AFTER it", async () => {
-		const store = new Map<string, Uint8Array>();
-		const asyncBackend = {
-			name: "async-mem2",
-			async read(k: string) {
-				await Promise.resolve();
-				const v = store.get(k);
-				return v === undefined ? undefined : new Uint8Array(v);
-			},
-			async write(k: string, b: Uint8Array) {
-				await Promise.resolve();
-				store.set(k, new Uint8Array(b));
-			},
-			async delete(k: string) {
-				store.delete(k);
-			},
-			list: () => [...store.keys()].sort(),
-		};
-		const tier = appendLogStorage<string>(asyncBackend, { name: "R2" });
-		tier.appendEntries(["stale"]);
-		await tier.rollback?.();
-		tier.appendEntries(["kept"]); // new epoch — must persist
-		await tier.flush?.();
-		const loaded = await tier.loadEntries!();
-		expect(loaded.entries).toEqual(["kept"]);
-	});
-});
-
-describe("extra reactiveIndex (roadmap §3.2)", () => {
-	it("orders by secondary then primary and supports delete", () => {
-		const idx = reactiveIndex<string, string>();
-		idx.upsert("p1", 10, "a");
-		idx.upsert("p2", 5, "b");
-		expect(idx.byPrimary.cache).toEqual(
-			new Map([
-				["p1", "a"],
-				["p2", "b"],
-			]),
-		);
-		const ordered = idx.ordered.cache as readonly { primary: string }[];
-		expect(ordered.map((r) => r.primary)).toEqual(["p2", "p1"]);
-		idx.delete("p2");
-		const m = idx.byPrimary.cache as Map<string, string>;
-		expect([...m.keys()]).toEqual(["p1"]);
-	});
-});
-
-describe("reactiveLog.attach — skipCachedReplay (memo:Re P2)", () => {
-	it("default: appends the upstream's cached value on subscribe (push-on-subscribe)", () => {
-		const up = node<number>([], { initial: undefined });
-		up.emit(1);
-		up.emit(2);
-		const log = reactiveLog<number>();
-		const dispose = log.attach(up);
-		// Cached last value (2) replayed at subscribe → appended.
-		expect(log.entries.cache).toEqual([2]);
-		up.emit(3);
-		expect(log.entries.cache).toEqual([2, 3]);
-		dispose();
-	});
-
-	it("skipCachedReplay: drops the cached-replay burst, keeps live emissions", () => {
-		const up = node<number>([], { initial: undefined });
-		up.emit(1);
-		up.emit(2);
-		const log = reactiveLog<number>();
-		const dispose = log.attach(up, { skipCachedReplay: true });
-		// Cached 2 delivered synchronously during subscribe → skipped.
-		expect(log.entries.cache).toEqual([]);
-		// Subsequent live emissions still append.
-		up.emit(3);
-		up.emit(4);
-		expect(log.entries.cache).toEqual([3, 4]);
-		dispose();
-	});
-
-	it("skipCachedReplay on a cold upstream is a no-op (nothing to skip)", () => {
-		const up = node<number>([], { initial: undefined });
-		const log = reactiveLog<number>();
-		const dispose = log.attach(up, { skipCachedReplay: true });
-		up.emit(1);
-		expect(log.entries.cache).toEqual([1]);
-		dispose();
-	});
-
-	it("skipCachedReplay works when attach() runs inside batch() (handshake is downWithBatch-deferred)", () => {
-		const up = node<number>([], { initial: undefined });
-		up.emit(1);
-		up.emit(2);
-		const log = reactiveLog<number>();
-		let dispose = () => {};
-		// Under batch(), the cached handshake DATA is deferred to drain —
-		// AFTER attach() returns. A synchronous-window flag would miss it and
-		// append 2 anyway; the first-frame skip must still catch it.
-		batch(() => {
-			dispose = log.attach(up, { skipCachedReplay: true });
-		});
-		expect(log.entries.cache).toEqual([]);
-		up.emit(3);
-		expect(log.entries.cache).toEqual([3]);
-		dispose();
-	});
-
-	it("skipCachedReplay drops the FULL replay buffer handshake, not just the last value", () => {
-		const up = node<number>([], { initial: undefined, replayBuffer: 3 });
-		up.emit(1);
-		up.emit(2);
-		up.emit(3);
-		const log = reactiveLog<number>();
-		const dispose = log.attach(up, { skipCachedReplay: true });
-		// Entire [1,2,3] replay-buffer handshake frame dropped.
-		expect(log.entries.cache).toEqual([]);
-		up.emit(4);
-		expect(log.entries.cache).toEqual([4]);
-		dispose();
-	});
-
-	it("attachStorage throws on an overwrite-mode tier (delta-ship would truncate)", () => {
-		const log = reactiveLog<number>();
-		const tier = appendLogStorage<number>(memoryBackend(), {
-			name: "L",
-			mode: "overwrite",
-		});
-		expect(() => log.attachStorage([tier])).toThrow(/overwrite/);
-		// An append-mode tier is accepted.
-		const ok = appendLogStorage<number>(memoryBackend(), { name: "L2" });
-		expect(() => log.attachStorage([ok])()).not.toThrow();
-	});
-
-	it("default (no opt) still appends the full replay buffer on attach", () => {
-		const up = node<number>([], { initial: undefined, replayBuffer: 3 });
-		up.emit(1);
-		up.emit(2);
-		up.emit(3);
-		const log = reactiveLog<number>();
-		const dispose = log.attach(up);
-		expect(log.entries.cache).toEqual([1, 2, 3]);
-		dispose();
-	});
-});
-
-describe("extra reactiveList (roadmap §3.2)", () => {
-	it("append, insert, pop, clear", () => {
-		const lst = reactiveList<number>();
-		lst.append(1);
-		lst.insert(0, 0);
-		expect(lst.items.cache).toEqual([0, 1]);
-		expect(lst.pop()).toBe(1);
-		expect(lst.items.cache).toEqual([0]);
-	});
-});
diff --git a/packages/pure-ts/src/__tests__/extra/reactive-index-stress.test.ts b/packages/pure-ts/src/__tests__/extra/reactive-index-stress.test.ts
deleted file mode 100644
index 9053415e..00000000
--- a/packages/pure-ts/src/__tests__/extra/reactive-index-stress.test.ts
+++ /dev/null
@@ -1,570 +0,0 @@
-/**
- * Stress tests for reactiveIndex — Wave 4 audit scenarios + new APIs.
- *
- * Covers: sort semantics, reorder via upsert, mixed-type secondary, delete/clear
- * no-ops, byPrimary cascade, bulk operations, diamond topology, emit ordering
- * across `ordered` and `byPrimary`, pluggable backend, version counter advance.
- */
-
-import { describe, expect, it } from "vitest";
-import { DATA, DIRTY } from "../../core/messages.js";
-import { node } from "../../core/node.js";
-import {
-	type IndexBackend,
-	type IndexRow,
-	NativeIndexBackend,
-	reactiveIndex,
-} from "../../extra/data-structures/reactive-index.js";
-import { combine } from "../../extra/operators/index.js";
-import { collect } from "../test-helpers.js";
-
-describe("reactiveIndex stress tests", () => {
-	// ── Scenario 1: Sort order ──────────────────────────────────────────
-	it("S1: orders by (secondary, primary) — primary tiebreaks identical secondary", () => {
-		const idx = reactiveIndex<string, string>();
-		idx.upsert("p2", 10, "b");
-		idx.upsert("p1", 10, "a");
-		idx.upsert("p3", 5, "c");
-
-		const rows = idx.ordered.cache as readonly IndexRow<string, string>[];
-		expect(rows.map((r) => r.primary)).toEqual(["p3", "p1", "p2"]);
-	});
-
-	// ── Scenario 2: Reorder via upsert on same primary ──────────────────
-	it("S2: upsert with new secondary reorders row; byPrimary value preserved", () => {
-		const idx = reactiveIndex<string, string>();
-		idx.upsert("p1", 10, "a");
-		idx.upsert("p2", 20, "b");
-		idx.upsert("p3", 30, "c");
-
-		// Move p3 to the front by dropping its secondary
-		idx.upsert("p3", 1, "c");
-
-		const rows = idx.ordered.cache as readonly IndexRow<string, string>[];
-		expect(rows.map((r) => r.primary)).toEqual(["p3", "p1", "p2"]);
-
-		const byPrim = idx.byPrimary.cache as ReadonlyMap<string, string>;
-		expect(byPrim.get("p3")).toBe("c");
-		expect(byPrim.size).toBe(3);
-	});
-
-	// ── Scenario 3: Mixed-type secondary — falls to localeCompare ───────
-	it("S3: mixed-type secondary uses String().localeCompare() fallback", () => {
-		const idx = reactiveIndex<string, string>();
-		idx.upsert("a", 1, "num");
-		idx.upsert("b", "hello", "str");
-		idx.upsert("c", true, "bool");
-
-		const rows = idx.ordered.cache as readonly IndexRow<string, string>[];
-		// Order determined by String() coercion: "1" < "hello" < "true"
-		// under localeCompare — exact order depends on locale; lock in current behavior.
-		const secondaries = rows.map((r) => String(r.secondary));
-		// Just verify all three types are present and the array is stable
-		expect(secondaries).toHaveLength(3);
-		expect(rows.map((r) => r.primary).sort()).toEqual(["a", "b", "c"]);
-	});
-
-	// ── Scenario 4: Delete non-existent primary ─────────────────────────
-	it("S4: delete on non-existent primary is a no-op, no emission", () => {
-		const idx = reactiveIndex<string, string>();
-		idx.upsert("p1", 1, "a");
-		const { messages, unsub } = collect(idx.ordered, { flat: true });
-		const beforeLen = messages.length;
-
-		idx.delete("nonexistent");
-
-		expect(messages.length).toBe(beforeLen);
-		unsub();
-	});
-
-	// ── Scenario 5: Clear on empty ──────────────────────────────────────
-	it("S5: clear on empty index emits nothing", () => {
-		const idx = reactiveIndex<string, string>();
-		const { messages, unsub } = collect(idx.ordered, { flat: true });
-		const beforeLen = messages.length;
-
-		idx.clear();
-		expect(messages.length).toBe(beforeLen);
-
-		unsub();
-	});
-
-	// ── Scenario 6: byPrimary cascade on upsert ─────────────────────────
-	it("S6: byPrimary emits new Map identity when ordered emits", () => {
-		const idx = reactiveIndex<string, string>();
-		idx.upsert("p1", 1, "a");
-
-		const seen: (ReadonlyMap<string, string> | null)[] = [];
-		const unsub = idx.byPrimary.subscribe((msgs) => {
-			for (const msg of msgs as [symbol, unknown][]) {
-				if (msg[0] === DATA) seen.push(msg[1] as ReadonlyMap<string, string>);
-			}
-		});
-
-		idx.upsert("p1", 2, "a");
-		idx.upsert("p2", 3, "b");
-
-		unsub();
-
-		// Each upsert triggers an ordered emission → byPrimary recomputes.
-		// Count: 1 initial (push-on-subscribe) + 2 upserts = 3
-		expect(seen.length).toBeGreaterThanOrEqual(3);
-		// Final byPrimary should have both keys
-		expect(seen.at(-1)!.get("p1")).toBe("a");
-		expect(seen.at(-1)!.get("p2")).toBe("b");
-	});
-
-	// ── Scenario 7: Bulk upsert stress via upsertMany ───────────────────
-	it("S7: upsertMany of 1000 rows emits one snapshot (not 1000)", () => {
-		const idx = reactiveIndex<number, number>();
-		const { messages, unsub } = collect(idx.ordered, { flat: true });
-		const beforeLen = messages.length;
-
-		const rows = Array.from({ length: 1000 }, (_, i) => ({
-			primary: i,
-			secondary: i,
-			value: i * 10,
-		}));
-		idx.upsertMany(rows);
-
-		const newMessages = messages.slice(beforeLen);
-		const dirtyCount = newMessages.filter((m) => m[0] === DIRTY).length;
-		const dataCount = newMessages.filter((m) => m[0] === DATA).length;
-
-		expect(dirtyCount).toBe(1);
-		expect(dataCount).toBe(1);
-
-		expect(idx.size).toBe(1000);
-		unsub();
-	});
-
-	// ── Scenario 8: Diamond topology — glitch-free ──────────────────────
-	it("S8: two derived views from ordered — combine sees consistent pairs", () => {
-		const idx = reactiveIndex<string, number>();
-		const count = node(
-			[idx.ordered],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as readonly IndexRow<string, number>[]).length);
-			},
-			{ describeKind: "derived", initial: 0 },
-		);
-		const total = node(
-			[idx.ordered],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit(
-					(data[0] as readonly IndexRow<string, number>[]).reduce((a, r) => a + r.value, 0),
-				);
-			},
-			{ describeKind: "derived", initial: 0 },
-		);
-		const combined = combine(count, total);
-
-		const seen: [number, number][] = [];
-		const unsub = combined.subscribe((msgs) => {
-			for (const msg of msgs as [symbol, unknown][]) {
-				if (msg[0] === DATA) seen.push(msg[1] as [number, number]);
-			}
-		});
-
-		idx.upsert("a", 1, 10);
-		idx.upsert("b", 2, 20);
-		idx.upsert("c", 3, 30);
-
-		unsub();
-
-		// Final state
-		expect(seen.at(-1)).toEqual([3, 60]);
-		// Monotonic (count and total only increase under pure insert)
-		for (let i = 1; i < seen.length; i++) {
-			expect(seen[i]![0]).toBeGreaterThanOrEqual(seen[i - 1]![0]);
-			expect(seen[i]![1]).toBeGreaterThanOrEqual(seen[i - 1]![1]);
-		}
-	});
-
-	// ── Scenario 9: byPrimary keepalive — .cache works without subscriber ─
-	it("S9: byPrimary.cache returns current state without any external subscriber", () => {
-		const idx = reactiveIndex<string, string>();
-		idx.upsert("p1", 1, "a");
-		idx.upsert("p2", 2, "b");
-
-		// No one subscribes to byPrimary, but keepaliveDerived keeps it wired.
-		const m = idx.byPrimary.cache as ReadonlyMap<string, string>;
-		expect(m.get("p1")).toBe("a");
-		expect(m.get("p2")).toBe("b");
-	});
-
-	// ── Scenario 10: null / undefined secondary ─────────────────────────
-	it("S10: null and undefined secondaries sort via localeCompare fallback", () => {
-		const idx = reactiveIndex<string, string>();
-		idx.upsert("a", null, "n");
-		idx.upsert("b", undefined, "u");
-		idx.upsert("c", 5, "num");
-
-		const rows = idx.ordered.cache as readonly IndexRow<string, string>[];
-		expect(rows).toHaveLength(3);
-		// No crashes; exact order is implementation-defined under localeCompare fallback.
-		expect(rows.map((r) => r.primary).sort()).toEqual(["a", "b", "c"]);
-	});
-
-	// ── Scenario 12: Emit ordering across ordered and byPrimary ─────────
-	it("S12: single upsert produces DIRTY on both ordered and byPrimary before any DATA", () => {
-		const idx = reactiveIndex<string, string>();
-
-		const orderedEvents: string[] = [];
-		const byPrimaryEvents: string[] = [];
-
-		const u1 = idx.ordered.subscribe((msgs) => {
-			for (const msg of msgs as [symbol, unknown][]) {
-				if (msg[0] === DIRTY) orderedEvents.push("DIRTY");
-				if (msg[0] === DATA) orderedEvents.push("DATA");
-			}
-		});
-		const u2 = idx.byPrimary.subscribe((msgs) => {
-			for (const msg of msgs as [symbol, unknown][]) {
-				if (msg[0] === DIRTY) byPrimaryEvents.push("DIRTY");
-				if (msg[0] === DATA) byPrimaryEvents.push("DATA");
-			}
-		});
-
-		// Clear push-on-subscribe
-		const beforeOrd = orderedEvents.length;
-		const beforeBp = byPrimaryEvents.length;
-
-		idx.upsert("p1", 1, "a");
-
-		u1();
-		u2();
-
-		const newOrd = orderedEvents.slice(beforeOrd);
-		const newBp = byPrimaryEvents.slice(beforeBp);
-
-		// ordered: DIRTY then DATA
-		expect(newOrd).toEqual(["DIRTY", "DATA"]);
-		// byPrimary: also DIRTY then DATA (derived cascade)
-		expect(newBp).toEqual(["DIRTY", "DATA"]);
-	});
-
-	// ── Scenario 13: Large index O(n log n) smoke test ──────────────────
-	it("S13: 5000 upserts complete without pathological slowdown", () => {
-		const idx = reactiveIndex<number, number>();
-		const t0 = Date.now();
-		for (let i = 0; i < 5000; i++) {
-			idx.upsert(i, 5000 - i, i * 2); // reverse order on secondary
-		}
-		const elapsed = Date.now() - t0;
-
-		expect(idx.size).toBe(5000);
-		// Sorted by secondary ascending → primary order should be 4999, 4998, ..., 0
-		const rows = idx.ordered.cache as readonly IndexRow<number, number>[];
-		expect(rows[0]!.primary).toBe(4999);
-		expect(rows[4999]!.primary).toBe(0);
-
-		// Perf ceiling: 5000 upserts on flat array is O(n²) worst case; verify not absurd.
-		// 1 second is plenty of headroom; if this fails we regressed hard.
-		expect(elapsed).toBeLessThan(2000);
-	});
-});
-
-// ── New API tests ───────────────────────────────────────────────────────
-
-describe("reactiveIndex new APIs", () => {
-	it("has() returns true only for present primary keys (O(1))", () => {
-		const idx = reactiveIndex<string, string>();
-		idx.upsert("a", 1, "x");
-		idx.upsert("b", 2, "y");
-
-		expect(idx.has("a")).toBe(true);
-		expect(idx.has("b")).toBe(true);
-		expect(idx.has("missing")).toBe(false);
-
-		idx.delete("a");
-		expect(idx.has("a")).toBe(false);
-		expect(idx.has("b")).toBe(true);
-
-		idx.clear();
-		expect(idx.has("b")).toBe(false);
-	});
-
-	it("get() returns value by primary key (O(1))", () => {
-		const idx = reactiveIndex<string, number>();
-		idx.upsert("a", 1, 100);
-		idx.upsert("b", 2, 200);
-
-		expect(idx.get("a")).toBe(100);
-		expect(idx.get("b")).toBe(200);
-		expect(idx.get("missing")).toBeUndefined();
-
-		// After upsert replaces value
-		idx.upsert("a", 1, 999);
-		expect(idx.get("a")).toBe(999);
-	});
-
-	it("size reflects backend state in O(1)", () => {
-		const idx = reactiveIndex<string, string>();
-		expect(idx.size).toBe(0);
-
-		idx.upsert("a", 1, "x");
-		expect(idx.size).toBe(1);
-
-		idx.upsert("b", 2, "y");
-		expect(idx.size).toBe(2);
-
-		idx.upsert("a", 1, "xx"); // update, not insert
-		expect(idx.size).toBe(2);
-
-		idx.delete("a");
-		expect(idx.size).toBe(1);
-
-		idx.clear();
-		expect(idx.size).toBe(0);
-	});
-
-	describe("upsertMany", () => {
-		it("empty iterable is a no-op, no emission", () => {
-			const idx = reactiveIndex<string, string>();
-			const { messages, unsub } = collect(idx.ordered, { flat: true });
-			const beforeLen = messages.length;
-
-			idx.upsertMany([]);
-
-			expect(messages.length).toBe(beforeLen);
-			expect(idx.size).toBe(0);
-			unsub();
-		});
-
-		it("N rows emit exactly 1 DIRTY + 1 DATA (not 2N)", () => {
-			const idx = reactiveIndex<string, string>();
-			const { messages, unsub } = collect(idx.ordered, { flat: true });
-			const beforeLen = messages.length;
-
-			idx.upsertMany([
-				{ primary: "a", secondary: 3, value: "x" },
-				{ primary: "b", secondary: 1, value: "y" },
-				{ primary: "c", secondary: 2, value: "z" },
-			]);
-
-			const newMessages = messages.slice(beforeLen);
-			const dirtyCount = newMessages.filter((m) => m[0] === DIRTY).length;
-			const dataCount = newMessages.filter((m) => m[0] === DATA).length;
-
-			expect(dirtyCount).toBe(1);
-			expect(dataCount).toBe(1);
-
-			// Final order
-			const rows = idx.ordered.cache as readonly IndexRow<string, string>[];
-			expect(rows.map((r) => r.primary)).toEqual(["b", "c", "a"]);
-
-			unsub();
-		});
-
-		it("accepts any Iterable (generator function)", () => {
-			const idx = reactiveIndex<number, number>();
-			function* gen() {
-				for (let i = 0; i < 5; i++) {
-					yield { primary: i, secondary: i, value: i * 10 };
-				}
-			}
-			idx.upsertMany(gen());
-			expect(idx.size).toBe(5);
-			expect(idx.get(3)).toBe(30);
-		});
-	});
-
-	describe("deleteMany", () => {
-		it("empty iterable is a no-op, no emission", () => {
-			const idx = reactiveIndex<string, string>();
-			idx.upsert("a", 1, "x");
-			const { messages, unsub } = collect(idx.ordered, { flat: true });
-			const beforeLen = messages.length;
-
-			idx.deleteMany([]);
-			expect(messages.length).toBe(beforeLen);
-			unsub();
-		});
-
-		it("deletes present keys and ignores missing", () => {
-			const idx = reactiveIndex<string, string>();
-			idx.upsertMany([
-				{ primary: "a", secondary: 1, value: "x" },
-				{ primary: "b", secondary: 2, value: "y" },
-				{ primary: "c", secondary: 3, value: "z" },
-			]);
-
-			idx.deleteMany(["a", "missing", "c"]);
-
-			expect(idx.has("a")).toBe(false);
-			expect(idx.has("b")).toBe(true);
-			expect(idx.has("c")).toBe(false);
-			expect(idx.size).toBe(1);
-		});
-
-		it("emits once even when deleting many rows", () => {
-			const idx = reactiveIndex<number, number>();
-			idx.upsertMany(
-				Array.from({ length: 100 }, (_, i) => ({ primary: i, secondary: i, value: i })),
-			);
-
-			const { messages, unsub } = collect(idx.ordered, { flat: true });
-			const beforeLen = messages.length;
-
-			idx.deleteMany(Array.from({ length: 100 }, (_, i) => i));
-
-			const newMessages = messages.slice(beforeLen);
-			expect(newMessages.filter((m) => m[0] === DIRTY).length).toBe(1);
-			expect(newMessages.filter((m) => m[0] === DATA).length).toBe(1);
-			expect(idx.size).toBe(0);
-			unsub();
-		});
-
-		it("emits nothing if no keys were present", () => {
-			const idx = reactiveIndex<string, string>();
-			idx.upsert("a", 1, "x");
-
-			const { messages, unsub } = collect(idx.ordered, { flat: true });
-			const beforeLen = messages.length;
-
-			idx.deleteMany(["missing1", "missing2"]);
-
-			expect(messages.length).toBe(beforeLen);
-			expect(idx.size).toBe(1);
-			unsub();
-		});
-	});
-});
-
-// ── Backend tests ───────────────────────────────────────────────────────
-
-describe("NativeIndexBackend", () => {
-	it("version counter advances on every mutation", () => {
-		const b = new NativeIndexBackend<string, string>();
-		expect(b.version).toBe(0);
-
-		expect(b.upsert("a", 1, "x")).toBe(true); // new insert
-		expect(b.version).toBe(1);
-
-		expect(b.upsert("a", 2, "xx")).toBe(false); // update
-		expect(b.version).toBe(2);
-
-		expect(b.delete("a")).toBe(true);
-		expect(b.version).toBe(3);
-
-		expect(b.delete("a")).toBe(false); // no-op
-		expect(b.version).toBe(3); // unchanged
-
-		b.upsert("a", 1, "x");
-		b.upsert("b", 2, "y");
-		expect(b.clear()).toBe(2);
-		expect(b.version).toBe(6); // 3 + 2 upserts + 1 clear
-
-		expect(b.clear()).toBe(0); // no-op
-		expect(b.version).toBe(6);
-	});
-
-	it("has and get are O(1) — correctness check", () => {
-		const b = new NativeIndexBackend<number, string>();
-		for (let i = 0; i < 1000; i++) {
-			b.upsert(i, 1000 - i, `v${i}`);
-		}
-
-		expect(b.has(500)).toBe(true);
-		expect(b.has(9999)).toBe(false);
-		expect(b.get(500)).toBe("v500");
-		expect(b.get(0)).toBe("v0");
-		expect(b.get(999)).toBe("v999");
-	});
-
-	it("maintains sort order via bisect", () => {
-		const b = new NativeIndexBackend<string, string>();
-		b.upsert("c", 3, "cc");
-		b.upsert("a", 1, "aa");
-		b.upsert("b", 2, "bb");
-
-		const rows = b.toArray();
-		expect(rows.map((r) => r.primary)).toEqual(["a", "b", "c"]);
-	});
-
-	it("upsert on existing primary moves the row", () => {
-		const b = new NativeIndexBackend<string, string>();
-		b.upsert("a", 1, "aa");
-		b.upsert("b", 2, "bb");
-		b.upsert("c", 3, "cc");
-
-		// Move "a" to the end by dropping secondary past "c"
-		b.upsert("a", 99, "aa_new");
-
-		const rows = b.toArray();
-		expect(rows.map((r) => r.primary)).toEqual(["b", "c", "a"]);
-		expect(b.get("a")).toBe("aa_new");
-	});
-});
-
-// ── Pluggable backend test ──────────────────────────────────────────────
-
-describe("reactiveIndex with user-provided backend", () => {
-	it("can plug in a custom backend implementation", () => {
-		// A minimal custom backend that counts mutation types (doesn't actually
-		// optimize anything — just proves the plug-point works).
-		class CountingBackend<K, V> implements IndexBackend<K, V> {
-			private readonly inner = new NativeIndexBackend<K, V>();
-			upsertCount = 0;
-			deleteCount = 0;
-			clearCount = 0;
-
-			get version(): number {
-				return this.inner.version;
-			}
-			get size(): number {
-				return this.inner.size;
-			}
-			has(primary: K): boolean {
-				return this.inner.has(primary);
-			}
-			get(primary: K): V | undefined {
-				return this.inner.get(primary);
-			}
-			upsert(primary: K, secondary: unknown, value: V): boolean {
-				this.upsertCount += 1;
-				return this.inner.upsert(primary, secondary, value);
-			}
-			delete(primary: K): boolean {
-				const removed = this.inner.delete(primary);
-				if (removed) this.deleteCount += 1;
-				return removed;
-			}
-			clear(): number {
-				const n = this.inner.clear();
-				if (n > 0) this.clearCount += 1;
-				return n;
-			}
-			toArray(): readonly IndexRow<K, V>[] {
-				return this.inner.toArray();
-			}
-			toPrimaryMap(): ReadonlyMap<K, V> {
-				return this.inner.toPrimaryMap();
-			}
-		}
-
-		const backend = new CountingBackend<string, string>();
-		const idx = reactiveIndex<string, string>({ backend });
-
-		idx.upsert("a", 1, "x");
-		idx.upsert("b", 2, "y");
-		idx.upsert("a", 1, "xx"); // update
-		idx.delete("a");
-		idx.delete("missing");
-		idx.clear();
-
-		expect(backend.upsertCount).toBe(3);
-		expect(backend.deleteCount).toBe(1);
-		expect(backend.clearCount).toBe(1);
-
-		// Reactive surface still works correctly
-		expect(idx.size).toBe(0);
-	});
-});
diff --git a/packages/pure-ts/src/__tests__/extra/reactive-list-stress.test.ts b/packages/pure-ts/src/__tests__/extra/reactive-list-stress.test.ts
deleted file mode 100644
index f4a925a2..00000000
--- a/packages/pure-ts/src/__tests__/extra/reactive-list-stress.test.ts
+++ /dev/null
@@ -1,594 +0,0 @@
-/**
- * Stress tests for reactiveList — Wave 4 audit scenarios.
- *
- * Covers: rapid append, appendMany semantics, boundary inserts, pop negative
- * indexing, empty-list throws, batched appends (coalescing contract),
- * diamond topology, initial-array isolation, and snapshot-before-return ordering.
- */
-
-import { describe, expect, it } from "vitest";
-import { batch } from "../../core/batch.js";
-import { DATA, DIRTY } from "../../core/messages.js";
-import { node } from "../../core/node.js";
-import {
-	type ListBackend,
-	NativeListBackend,
-	reactiveList,
-} from "../../extra/data-structures/reactive-list.js";
-import { combine } from "../../extra/operators/index.js";
-import { collect } from "../test-helpers.js";
-
-describe("reactiveList stress tests", () => {
-	// ── Scenario 1: Rapid append ────────────────────────────────────────
-	it("S1: 1000 appends — each emits DIRTY+DATA, final snapshot has all values", () => {
-		const lst = reactiveList<number>();
-		const { messages, unsub } = collect(lst.items, { flat: true });
-
-		const N = 1000;
-		for (let i = 0; i < N; i++) lst.append(i);
-
-		unsub();
-
-		const dirtyCount = messages.filter((m) => m[0] === DIRTY).length;
-		const dataCount = messages.filter((m) => m[0] === DATA).length;
-
-		expect(dirtyCount).toBe(N);
-		expect(dataCount).toBe(N + 1); // +1 for push-on-subscribe
-
-		const lastData = messages.filter((m) => m[0] === DATA).at(-1)!;
-		const snap = lastData[1] as readonly number[];
-		expect(snap.length).toBe(N);
-		expect(snap[0]).toBe(0);
-		expect(snap[N - 1]).toBe(N - 1);
-	});
-
-	// ── Scenario 2: Insert at boundaries ────────────────────────────────
-	it("S2: insert(0, x) prepends, insert(length, x) appends, both emit", () => {
-		const lst = reactiveList<number>([1, 2, 3]);
-		const { messages, unsub } = collect(lst.items, { flat: true });
-		const beforeLen = messages.length;
-
-		lst.insert(0, 0);
-		expect(lst.items.cache).toEqual([0, 1, 2, 3]);
-
-		lst.insert(4, 4); // at length
-		expect(lst.items.cache).toEqual([0, 1, 2, 3, 4]);
-
-		const newMessages = messages.slice(beforeLen);
-		expect(newMessages.filter((m) => m[0] === DIRTY).length).toBe(2);
-		expect(newMessages.filter((m) => m[0] === DATA).length).toBe(2);
-
-		unsub();
-	});
-
-	// ── Scenario 3: Insert out-of-range throws, no emission ─────────────
-	it("S3: insert with invalid index throws RangeError, no emission", () => {
-		const lst = reactiveList<number>([1, 2, 3]);
-		const { messages, unsub } = collect(lst.items, { flat: true });
-		const beforeLen = messages.length;
-
-		expect(() => lst.insert(-1, 99)).toThrow(RangeError);
-		expect(() => lst.insert(4, 99)).toThrow(RangeError); // length+1 is out of range
-
-		// Buf unchanged
-		expect(lst.items.cache).toEqual([1, 2, 3]);
-		// No new messages
-		expect(messages.length).toBe(beforeLen);
-
-		unsub();
-	});
-
-	// ── Scenario 4: Pop negative index semantics ────────────────────────
-	it("S4: pop(-1) returns last, pop(-length) returns first, pop(-length-1) throws", () => {
-		const lst = reactiveList<string>(["a", "b", "c"]);
-
-		expect(lst.pop(-1)).toBe("c");
-		expect(lst.items.cache).toEqual(["a", "b"]);
-
-		expect(lst.pop(-2)).toBe("a"); // -2 on length 2 → index 0
-		expect(lst.items.cache).toEqual(["b"]);
-
-		expect(() => lst.pop(-2)).toThrow(RangeError); // -2 on length 1 → out of range
-	});
-
-	// ── Scenario 5: Pop from empty throws ───────────────────────────────
-	it("S5: pop on empty list throws, no emission", () => {
-		const lst = reactiveList<number>();
-		const { messages, unsub } = collect(lst.items, { flat: true });
-		const beforeLen = messages.length;
-
-		expect(() => lst.pop()).toThrow(RangeError);
-		expect(messages.length).toBe(beforeLen);
-
-		unsub();
-	});
-
-	// ── Scenario 6: Clear on empty list is a no-op ──────────────────────
-	it("S6: clear on empty list emits no messages", () => {
-		const lst = reactiveList<number>();
-		const { messages, unsub } = collect(lst.items, { flat: true });
-		const beforeLen = messages.length;
-
-		lst.clear();
-		expect(messages.length).toBe(beforeLen);
-
-		unsub();
-	});
-
-	// ── Scenario 7: Batched appends — nested batch delivery contract ────
-	it("S7: N appends inside outer batch — N DIRTY callbacks then N DATA callbacks", () => {
-		const lst = reactiveList<number>();
-		const callbackInvocations: unknown[][] = [];
-		const unsub = lst.items.subscribe((msgs) => {
-			callbackInvocations.push(msgs as unknown[]);
-		});
-		const beforeLen = callbackInvocations.length;
-
-		const N = 5;
-		batch(() => {
-			for (let i = 0; i < N; i++) lst.append(i);
-		});
-
-		unsub();
-
-		const newInvocations = callbackInvocations.slice(beforeLen);
-		// Updated contract (Bug 2 fix, per-node emit coalescing inside batch):
-		// N consecutive emits to the same node inside one explicit `batch()`
-		// scope coalesce into ONE multi-message delivery — N DIRTYs in one
-		// tier-1 sink call, then N DATAs in one tier-3 sink call. Total: 2
-		// callbacks regardless of N. This is the source-side correctness fix
-		// that also resolves the K+1 fan-in over-fire at diamond nodes.
-		expect(newInvocations.length).toBe(2);
-
-		// First callback: tier-1 batch with N DIRTY messages.
-		const dirtyCall = newInvocations[0] as [symbol, unknown][];
-		expect(dirtyCall.length).toBe(N);
-		for (const msg of dirtyCall) expect(msg[0]).toBe(DIRTY);
-
-		// Second callback: tier-3 batch with N DATA messages.
-		const dataCall = newInvocations[1] as [symbol, unknown][];
-		expect(dataCall.length).toBe(N);
-		for (const msg of dataCall) expect(msg[0]).toBe(DATA);
-
-		// Final DATA payload has all N values.
-		const lastSnap = dataCall.at(-1)?.[1] as readonly number[];
-		expect(lastSnap).toEqual([0, 1, 2, 3, 4]);
-	});
-
-	// ── Scenario 7b: appendMany collapses the N-callback problem ────────
-	it("S7b: appendMany(N values) yields 1 DIRTY + 1 DATA callback (vs 2N for N appends)", () => {
-		const lst = reactiveList<number>();
-		const invocations: unknown[][] = [];
-		const unsub = lst.items.subscribe((msgs) => {
-			invocations.push(msgs as unknown[]);
-		});
-		const beforeLen = invocations.length;
-
-		lst.appendMany([0, 1, 2, 3, 4]);
-
-		unsub();
-
-		const newInvocations = invocations.slice(beforeLen);
-		// 1 DIRTY callback + 1 DATA callback = 2 total
-		expect(newInvocations.length).toBe(2);
-		expect((newInvocations[0] as [symbol, unknown][])[0]![0]).toBe(DIRTY);
-		expect((newInvocations[1] as [symbol, unknown][])[0]![0]).toBe(DATA);
-	});
-
-	// ── Scenario 8: Diamond through combine — glitch-free ───────────────
-	it("S8: diamond topology via combine — observed pairs are consistent", () => {
-		const lst = reactiveList<number>();
-
-		const length = node(
-			[lst.items],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as readonly number[]).length);
-			},
-			{ describeKind: "derived", initial: 0 },
-		);
-		const sum = node(
-			[lst.items],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as readonly number[]).reduce((a, b) => a + b, 0));
-			},
-			{ describeKind: "derived", initial: 0 },
-		);
-
-		const combined = combine(length, sum);
-		const seen: [number, number][] = [];
-		const unsub = combined.subscribe((msgs) => {
-			for (const msg of msgs as [symbol, unknown][]) {
-				if (msg[0] === DATA) seen.push(msg[1] as [number, number]);
-			}
-		});
-
-		lst.append(10);
-		lst.append(20);
-		lst.append(30);
-
-		unsub();
-
-		// Final pair should be (3, 60)
-		expect(seen.at(-1)).toEqual([3, 60]);
-		// All observed pairs should be self-consistent
-		// (length N means we've appended N items; sum == whatever was appended)
-		// We can't strictly check sum == f(length) without tracking history,
-		// but we can verify monotonicity: length and sum only increase.
-		for (let i = 1; i < seen.length; i++) {
-			expect(seen[i]![0]).toBeGreaterThanOrEqual(seen[i - 1]![0]);
-			expect(seen[i]![1]).toBeGreaterThanOrEqual(seen[i - 1]![1]);
-		}
-	});
-
-	// ── Scenario 9: Large list snapshot cost (perf smoke) ───────────────
-	it("S9: append 1000 items — final snapshot reflects all, no data loss", () => {
-		const lst = reactiveList<number>();
-		for (let i = 0; i < 1000; i++) lst.append(i);
-
-		const snap = lst.items.cache as readonly number[];
-		expect(snap.length).toBe(1000);
-		// Spot checks
-		expect(snap[0]).toBe(0);
-		expect(snap[500]).toBe(500);
-		expect(snap[999]).toBe(999);
-	});
-
-	// ── Scenario 10: Subscriber after mutation gets cached snapshot ─────
-	it("S10: subscribe after mutation — push-on-subscribe delivers latest snapshot", () => {
-		const lst = reactiveList<string>();
-		lst.append("a");
-		lst.append("b");
-
-		const { messages, unsub } = collect(lst.items, { flat: true });
-
-		const firstData = messages.find((m) => m[0] === DATA);
-		expect(firstData).toBeDefined();
-		const snap = firstData![1] as readonly string[];
-		expect(snap).toEqual(["a", "b"]);
-
-		unsub();
-	});
-
-	// ── Scenario 11: Initial array isolation ────────────────────────────
-	it("S11: external mutation of initial array does not affect list", () => {
-		const seed = [1, 2, 3];
-		const lst = reactiveList<number>(seed);
-
-		// Mutate the seed after construction
-		seed.push(999);
-		seed[0] = -1;
-
-		// Internal buf should be unaffected
-		expect(lst.items.cache).toEqual([1, 2, 3]);
-
-		// And list mutations shouldn't touch the seed either
-		lst.append(4);
-		expect(seed).toEqual([-1, 2, 3, 999]);
-	});
-
-	// ── Scenario 12: Pop emits snapshot before returning value ──────────
-	it("S12: pop returns value after snapshot is queued", () => {
-		const lst = reactiveList<number>([10, 20, 30]);
-		let snapshotAtReturnTime: readonly number[] | undefined;
-
-		const unsub = lst.items.subscribe((msgs) => {
-			for (const msg of msgs as [symbol, unknown][]) {
-				if (msg[0] === DATA) snapshotAtReturnTime = msg[1] as readonly number[];
-			}
-		});
-
-		const popped = lst.pop(); // returns 30
-		expect(popped).toBe(30);
-
-		// By this point (after pop returns and outside any outer batch),
-		// the snapshot reflecting the post-pop state should have been delivered.
-		expect(snapshotAtReturnTime).toEqual([10, 20]);
-
-		unsub();
-	});
-
-	// ── appendMany tests ─────────────────────────────────────────────────
-	describe("appendMany", () => {
-		it("empty values array is a no-op", () => {
-			const lst = reactiveList<number>();
-			const { messages, unsub } = collect(lst.items, { flat: true });
-			const beforeLen = messages.length;
-
-			lst.appendMany([]);
-
-			expect(messages.length).toBe(beforeLen);
-			expect(lst.items.cache).toEqual([]);
-
-			unsub();
-		});
-
-		it("N values emits exactly 1 DIRTY + 1 DATA with all values appended", () => {
-			const lst = reactiveList<number>([0]);
-			const { messages, unsub } = collect(lst.items, { flat: true });
-			const beforeLen = messages.length;
-
-			lst.appendMany([1, 2, 3, 4, 5]);
-
-			const newMessages = messages.slice(beforeLen);
-			const dirtyCount = newMessages.filter((m) => m[0] === DIRTY).length;
-			const dataCount = newMessages.filter((m) => m[0] === DATA).length;
-
-			expect(dirtyCount).toBe(1);
-			expect(dataCount).toBe(1);
-
-			const snap = newMessages.find((m) => m[0] === DATA)![1] as readonly number[];
-			expect(snap).toEqual([0, 1, 2, 3, 4, 5]);
-
-			unsub();
-		});
-
-		it("appendMany preserves input order", () => {
-			const lst = reactiveList<string>();
-			lst.appendMany(["c", "a", "b"]);
-			expect(lst.items.cache).toEqual(["c", "a", "b"]);
-			lst.appendMany(["d"]);
-			expect(lst.items.cache).toEqual(["c", "a", "b", "d"]);
-		});
-
-		it("appendMany emits one snapshot vs N appends emitting N snapshots", () => {
-			const lstOne = reactiveList<number>();
-			const one = collect(lstOne.items, { flat: true });
-			const beforeOne = one.messages.length;
-			lstOne.appendMany([1, 2, 3, 4, 5]);
-			const oneDirty = one.messages.slice(beforeOne).filter((m) => m[0] === DIRTY).length;
-			one.unsub();
-
-			const lstMany = reactiveList<number>();
-			const many = collect(lstMany.items, { flat: true });
-			const beforeMany = many.messages.length;
-			for (const v of [1, 2, 3, 4, 5]) lstMany.append(v);
-			const manyDirty = many.messages.slice(beforeMany).filter((m) => m[0] === DIRTY).length;
-			many.unsub();
-
-			expect(oneDirty).toBe(1);
-			expect(manyDirty).toBe(5);
-		});
-
-		it("appendMany does not retain reference to input array", () => {
-			const lst = reactiveList<number>();
-			const input = [1, 2, 3];
-			lst.appendMany(input);
-
-			// Mutating the input after should not affect the list
-			input.push(999);
-			input[0] = -1;
-
-			expect(lst.items.cache).toEqual([1, 2, 3]);
-		});
-	});
-});
-
-// ── New API tests ──────────────────────────────────────────────────────
-
-describe("reactiveList new APIs", () => {
-	it("size getter returns O(1) count", () => {
-		const lst = reactiveList<number>();
-		expect(lst.size).toBe(0);
-
-		lst.append(1);
-		expect(lst.size).toBe(1);
-
-		lst.appendMany([2, 3, 4]);
-		expect(lst.size).toBe(4);
-
-		lst.pop();
-		expect(lst.size).toBe(3);
-
-		lst.clear();
-		expect(lst.size).toBe(0);
-	});
-
-	describe("at(index)", () => {
-		it("positive index returns value", () => {
-			const lst = reactiveList<string>(["a", "b", "c"]);
-			expect(lst.at(0)).toBe("a");
-			expect(lst.at(1)).toBe("b");
-			expect(lst.at(2)).toBe("c");
-		});
-
-		it("negative index (Python-style) returns from end", () => {
-			const lst = reactiveList<string>(["a", "b", "c"]);
-			expect(lst.at(-1)).toBe("c");
-			expect(lst.at(-2)).toBe("b");
-			expect(lst.at(-3)).toBe("a");
-		});
-
-		it("out-of-range returns undefined", () => {
-			const lst = reactiveList<string>(["a", "b", "c"]);
-			expect(lst.at(3)).toBeUndefined();
-			expect(lst.at(99)).toBeUndefined();
-			expect(lst.at(-4)).toBeUndefined();
-			expect(lst.at(-99)).toBeUndefined();
-		});
-
-		it("on empty list always returns undefined", () => {
-			const lst = reactiveList<number>();
-			expect(lst.at(0)).toBeUndefined();
-			expect(lst.at(-1)).toBeUndefined();
-		});
-	});
-
-	describe("insertMany", () => {
-		it("empty values array is a no-op, no emission", () => {
-			const lst = reactiveList<number>([1, 2, 3]);
-			const { messages, unsub } = collect(lst.items, { flat: true });
-			const beforeLen = messages.length;
-
-			lst.insertMany(1, []);
-
-			expect(messages.length).toBe(beforeLen);
-			expect(lst.items.cache).toEqual([1, 2, 3]);
-			unsub();
-		});
-
-		it("N values at index emits exactly 1 DIRTY + 1 DATA", () => {
-			const lst = reactiveList<number>([1, 2, 3]);
-			const { messages, unsub } = collect(lst.items, { flat: true });
-			const beforeLen = messages.length;
-
-			lst.insertMany(1, [10, 20, 30]);
-
-			const newMessages = messages.slice(beforeLen);
-			expect(newMessages.filter((m) => m[0] === DIRTY).length).toBe(1);
-			expect(newMessages.filter((m) => m[0] === DATA).length).toBe(1);
-
-			expect(lst.items.cache).toEqual([1, 10, 20, 30, 2, 3]);
-			unsub();
-		});
-
-		it("insertMany at 0 (prepend all)", () => {
-			const lst = reactiveList<number>([4, 5]);
-			lst.insertMany(0, [1, 2, 3]);
-			expect(lst.items.cache).toEqual([1, 2, 3, 4, 5]);
-		});
-
-		it("insertMany at size (appendMany equivalent)", () => {
-			const lst = reactiveList<number>([1, 2]);
-			lst.insertMany(2, [3, 4]);
-			expect(lst.items.cache).toEqual([1, 2, 3, 4]);
-		});
-
-		it("insertMany throws on out-of-range index", () => {
-			const lst = reactiveList<number>([1, 2, 3]);
-			expect(() => lst.insertMany(-1, [99])).toThrow(RangeError);
-			expect(() => lst.insertMany(4, [99])).toThrow(RangeError);
-		});
-	});
-});
-
-// ── Native backend direct tests ────────────────────────────────────────
-
-describe("NativeListBackend", () => {
-	it("version counter advances on every state-changing op", () => {
-		const b = new NativeListBackend<number>();
-		expect(b.version).toBe(0);
-
-		b.append(1);
-		expect(b.version).toBe(1);
-
-		b.appendMany([2, 3]);
-		expect(b.version).toBe(2);
-
-		b.appendMany([]); // no-op
-		expect(b.version).toBe(2);
-
-		b.insert(0, 0);
-		expect(b.version).toBe(3);
-
-		b.insertMany(1, [100, 200]);
-		expect(b.version).toBe(4);
-
-		b.insertMany(1, []); // no-op
-		expect(b.version).toBe(4);
-
-		b.pop(0);
-		expect(b.version).toBe(5);
-
-		expect(b.clear()).toBe(5);
-		expect(b.version).toBe(6);
-
-		expect(b.clear()).toBe(0); // no-op
-		expect(b.version).toBe(6);
-	});
-
-	it("at supports negative indexing", () => {
-		const b = new NativeListBackend<number>([10, 20, 30]);
-		expect(b.at(0)).toBe(10);
-		expect(b.at(-1)).toBe(30);
-		expect(b.at(-3)).toBe(10);
-		expect(b.at(3)).toBeUndefined();
-		expect(b.at(-4)).toBeUndefined();
-	});
-
-	it("initial array is copied (not retained)", () => {
-		const seed = [1, 2, 3];
-		const b = new NativeListBackend<number>(seed);
-
-		seed.push(999);
-		seed[0] = -1;
-
-		expect(b.toArray()).toEqual([1, 2, 3]);
-	});
-});
-
-// ── Pluggable backend ──────────────────────────────────────────────────
-
-describe("reactiveList with user-provided backend", () => {
-	it("can plug in a custom backend implementation", () => {
-		class CountingListBackend<T> implements ListBackend<T> {
-			private readonly inner = new NativeListBackend<T>();
-			appendCount = 0;
-			insertCount = 0;
-			popCount = 0;
-
-			get version(): number {
-				return this.inner.version;
-			}
-			get size(): number {
-				return this.inner.size;
-			}
-			at(i: number): T | undefined {
-				return this.inner.at(i);
-			}
-			append(v: T): void {
-				this.appendCount += 1;
-				this.inner.append(v);
-			}
-			appendMany(values: readonly T[]): void {
-				if (values.length > 0) this.appendCount += values.length;
-				this.inner.appendMany(values);
-			}
-			insert(i: number, v: T): void {
-				this.insertCount += 1;
-				this.inner.insert(i, v);
-			}
-			insertMany(i: number, values: readonly T[]): void {
-				if (values.length > 0) this.insertCount += values.length;
-				this.inner.insertMany(i, values);
-			}
-			pop(i: number): T {
-				this.popCount += 1;
-				return this.inner.pop(i);
-			}
-			clear(): number {
-				return this.inner.clear();
-			}
-			toArray(): readonly T[] {
-				return this.inner.toArray();
-			}
-		}
-
-		const backend = new CountingListBackend<number>();
-		const lst = reactiveList<number>(undefined, { backend });
-
-		lst.append(1);
-		lst.appendMany([2, 3]);
-		lst.insert(0, 0);
-		lst.insertMany(4, [10, 20]);
-		lst.pop();
-
-		expect(backend.appendCount).toBe(3); // 1 + 2
-		expect(backend.insertCount).toBe(3); // 1 + 2
-		expect(backend.popCount).toBe(1);
-		expect(lst.items.cache).toEqual([0, 1, 2, 3, 10]);
-	});
-
-	it("when backend is provided, initial is ignored", () => {
-		const backend = new NativeListBackend<number>([100, 200]);
-		const lst = reactiveList<number>([1, 2, 3], { backend });
-
-		// Initial [1,2,3] ignored; backend's seeded [100, 200] wins.
-		expect(lst.items.cache).toEqual([100, 200]);
-	});
-});
diff --git a/packages/pure-ts/src/__tests__/extra/reactive-log-stress.test.ts b/packages/pure-ts/src/__tests__/extra/reactive-log-stress.test.ts
deleted file mode 100644
index 38cbb162..00000000
--- a/packages/pure-ts/src/__tests__/extra/reactive-log-stress.test.ts
+++ /dev/null
@@ -1,750 +0,0 @@
-/**
- * Stress tests for reactiveLog — Wave 4 audit scenarios + new APIs.
- *
- * Covers: unbounded append, ring-buffer trim under maxSize, appendMany atomicity,
- * seed oversize, trimHead edges, tail memoization, slice semantics, diamond,
- * size/at getters, pluggable backend, version counter advance.
- */
-
-import { describe, expect, it } from "vitest";
-import { COMPLETE, DATA, DIRTY, ERROR, RESOLVED } from "../../core/messages.js";
-import { node } from "../../core/node.js";
-import {
-	type LogBackend,
-	mergeReactiveLogs,
-	NativeLogBackend,
-	reactiveLog,
-} from "../../extra/data-structures/reactive-log.js";
-import { combine } from "../../extra/operators/index.js";
-import { collect } from "../test-helpers.js";
-
-describe("reactiveLog stress tests", () => {
-	// ── Scenario 1: Append stress, unbounded ───────────────────────────
-	it("S1: 1000 appends (unbounded) — all preserved in order", () => {
-		const lg = reactiveLog<number>();
-		const { messages, unsub } = collect(lg.entries, { flat: true });
-
-		for (let i = 0; i < 1000; i++) lg.append(i);
-		unsub();
-
-		expect(messages.filter((m) => m[0] === DIRTY).length).toBe(1000);
-		expect(messages.filter((m) => m[0] === DATA).length).toBe(1001); // +1 push-on-subscribe
-
-		const last = messages.filter((m) => m[0] === DATA).at(-1)!;
-		const snap = last[1] as readonly number[];
-		expect(snap.length).toBe(1000);
-		expect(snap[0]).toBe(0);
-		expect(snap[999]).toBe(999);
-	});
-
-	// ── Scenario 2: Append stress with maxSize=10 — sliding window ─────
-	it("S2: 1000 appends with maxSize=10 — sliding window, each append emits", () => {
-		const lg = reactiveLog<number>([], { maxSize: 10 });
-		const { messages, unsub } = collect(lg.entries, { flat: true });
-
-		for (let i = 0; i < 1000; i++) lg.append(i);
-		unsub();
-
-		expect(messages.filter((m) => m[0] === DIRTY).length).toBe(1000);
-		expect(messages.filter((m) => m[0] === DATA).length).toBe(1001);
-
-		// Final snapshot is last 10 values
-		const last = messages.filter((m) => m[0] === DATA).at(-1)!;
-		const snap = last[1] as readonly number[];
-		expect(snap.length).toBe(10);
-		expect(snap[0]).toBe(990);
-		expect(snap[9]).toBe(999);
-
-		// Size is bounded
-		expect(lg.size).toBe(10);
-	});
-
-	// ── Scenario 3: appendMany atomicity with maxSize trim ─────────────
-	it("S3: appendMany of 100 values with maxSize=10 — single snapshot, final tail", () => {
-		const lg = reactiveLog<number>([], { maxSize: 10 });
-		const { messages, unsub } = collect(lg.entries, { flat: true });
-		const beforeLen = messages.length;
-
-		const input = Array.from({ length: 100 }, (_, i) => i);
-		lg.appendMany(input);
-
-		const newMessages = messages.slice(beforeLen);
-		expect(newMessages.filter((m) => m[0] === DIRTY).length).toBe(1);
-		expect(newMessages.filter((m) => m[0] === DATA).length).toBe(1);
-
-		const snap = newMessages.find((m) => m[0] === DATA)![1] as readonly number[];
-		expect(snap).toEqual([90, 91, 92, 93, 94, 95, 96, 97, 98, 99]);
-
-		unsub();
-	});
-
-	// ── Scenario 4: Seed larger than maxSize — pre-trimmed ─────────────
-	it("S4: seed larger than maxSize — initial value is pre-trimmed tail", () => {
-		const seed = Array.from({ length: 20 }, (_, i) => i + 1); // [1..20]
-		const lg = reactiveLog<number>(seed, { maxSize: 5 });
-
-		// Initial state exposed via entries.cache
-		expect(lg.size).toBe(5);
-		expect(lg.entries.cache).toEqual([16, 17, 18, 19, 20]);
-	});
-
-	// ── Scenario 5: trimHead edge cases ────────────────────────────────
-	it("S5: trimHead n=0 no-op, n=length clears, n>length clamped, n<0 throws", () => {
-		const lg = reactiveLog<number>([1, 2, 3, 4, 5]);
-		const { messages, unsub } = collect(lg.entries, { flat: true });
-		const beforeLen = messages.length;
-
-		// n=0: no-op
-		lg.trimHead(0);
-		expect(messages.length).toBe(beforeLen);
-		expect(lg.size).toBe(5);
-
-		// n=2: removes [1, 2]
-		lg.trimHead(2);
-		expect(lg.entries.cache).toEqual([3, 4, 5]);
-		expect(lg.size).toBe(3);
-
-		// n>length: clamped to clear
-		lg.trimHead(100);
-		expect(lg.size).toBe(0);
-
-		// n<0: throws
-		expect(() => lg.trimHead(-1)).toThrow(RangeError);
-
-		unsub();
-	});
-
-	// ── Scenario 6: tail(n) correctness over time ──────────────────────
-	it("S6: tail(n) always reflects the last n entries", () => {
-		const lg = reactiveLog<number>([1, 2, 3]);
-		const last2 = lg.view({ kind: "tail", n: 2 });
-		expect(last2.cache).toEqual([2, 3]);
-
-		lg.append(4);
-		expect(last2.cache).toEqual([3, 4]);
-
-		lg.append(5);
-		expect(last2.cache).toEqual([4, 5]);
-
-		// Trim cascade
-		lg.trimHead(4); // only [5] left
-		expect(last2.cache).toEqual([5]);
-
-		lg.clear();
-		expect(last2.cache).toEqual([]);
-	});
-
-	// ── Scenario 7: tail(n) memoization — repeat calls return same node ─
-	it("S7: tail(n) memoized — repeat calls with same n return same node", () => {
-		const lg = reactiveLog<number>();
-		const t1 = lg.view({ kind: "tail", n: 5 });
-		const t2 = lg.view({ kind: "tail", n: 5 });
-		const t3 = lg.view({ kind: "tail", n: 10 }); // different n
-
-		expect(t1).toBe(t2); // identical node
-		expect(t1).not.toBe(t3); // different n → different node
-
-		// Behavior still correct
-		lg.appendMany([1, 2, 3, 4, 5, 6, 7]);
-		expect(t1.cache).toEqual([3, 4, 5, 6, 7]);
-		expect(t3.cache).toEqual([1, 2, 3, 4, 5, 6, 7]);
-	});
-
-	// ── Scenario 8: slice correctness ──────────────────────────────────
-	it("S8: slice(start, stop) semantics match Array.prototype.slice", () => {
-		const lg = reactiveLog<number>([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
-		const s = lg.view({ kind: "slice", start: 2, stop: 5 });
-		expect(s.cache).toEqual([2, 3, 4]);
-
-		// Omitting stop
-		const to_end = lg.view({ kind: "slice", start: 7 });
-		expect(to_end.cache).toEqual([7, 8, 9]);
-
-		// Negative start throws
-		expect(() => lg.view({ kind: "slice", start: -1, stop: 3 })).toThrow(RangeError);
-	});
-
-	// ── Scenario 9: slice across trimHead — indices shift ──────────────
-	it("S9: slice [2, 5) behaves positionally after trimHead shifts indices", () => {
-		const lg = reactiveLog<number>([10, 20, 30, 40, 50, 60, 70, 80]);
-		const window = lg.view({ kind: "slice", start: 2, stop: 5 });
-		expect(window.cache).toEqual([30, 40, 50]);
-
-		// Trim first 3 → remaining is [40, 50, 60, 70, 80]
-		lg.trimHead(3);
-		// slice(2, 5) now refers to indices 2..4 of the NEW list: [60, 70, 80]
-		expect(window.cache).toEqual([60, 70, 80]);
-	});
-
-	// ── Scenario 10: Diamond — tail + slice both derived ───────────────
-	it("S10: tail and slice diamond from entries — both settle consistently", () => {
-		const lg = reactiveLog<number>();
-		const t = lg.view({ kind: "tail", n: 2 });
-		const s = lg.view({ kind: "slice", start: 0, stop: 3 });
-		const combined = combine(t, s);
-
-		const seen: [readonly number[], readonly number[]][] = [];
-		const unsub = combined.subscribe((msgs) => {
-			for (const msg of msgs as [symbol, unknown][]) {
-				if (msg[0] === DATA) {
-					seen.push(msg[1] as [readonly number[], readonly number[]]);
-				}
-			}
-		});
-
-		lg.appendMany([10, 20, 30, 40, 50]);
-		unsub();
-
-		// Final pair
-		expect(seen.at(-1)).toEqual([
-			[40, 50],
-			[10, 20, 30],
-		]);
-	});
-
-	// ── Scenario 11: clear after trimHead-to-empty is a no-op ──────────
-	it("S11: trimHead(length) then clear() — second is no-op", () => {
-		const lg = reactiveLog<number>([1, 2, 3]);
-		const { messages, unsub } = collect(lg.entries, { flat: true });
-		const beforeLen = messages.length;
-
-		lg.trimHead(3); // clears
-		const afterTrimLen = messages.length;
-		expect(afterTrimLen).toBeGreaterThan(beforeLen);
-
-		lg.clear(); // no-op now
-		expect(messages.length).toBe(afterTrimLen);
-
-		unsub();
-	});
-
-	// ── Scenario 12: maxSize=1 edge ────────────────────────────────────
-	it("S12: maxSize=1 — continuous appends keep replacing", () => {
-		const lg = reactiveLog<number>([], { maxSize: 1 });
-		lg.append(1);
-		expect(lg.entries.cache).toEqual([1]);
-		lg.append(2);
-		expect(lg.entries.cache).toEqual([2]);
-		lg.append(3);
-		expect(lg.entries.cache).toEqual([3]);
-		expect(lg.size).toBe(1);
-	});
-
-	// ── Scenario 13: appendMany oversize input is pre-trimmed ──────────
-	it("S13: appendMany skips values that would be immediately evicted", () => {
-		// We can verify this indirectly: final state is last maxSize values,
-		// and the snapshot is emitted exactly once.
-		const lg = reactiveLog<number>([], { maxSize: 5 });
-		const { messages, unsub } = collect(lg.entries, { flat: true });
-		const beforeLen = messages.length;
-
-		lg.appendMany(Array.from({ length: 1000 }, (_, i) => i));
-
-		const newMessages = messages.slice(beforeLen);
-		expect(newMessages.filter((m) => m[0] === DIRTY).length).toBe(1);
-		expect(newMessages.filter((m) => m[0] === DATA).length).toBe(1);
-
-		expect(lg.entries.cache).toEqual([995, 996, 997, 998, 999]);
-		unsub();
-	});
-
-	// ── Scenario 14: Subscriber after mutations ────────────────────────
-	it("S14: subscribe after mutations — push-on-subscribe delivers current state", () => {
-		const lg = reactiveLog<string>();
-		lg.append("a");
-		lg.append("b");
-		lg.append("c");
-
-		const { messages, unsub } = collect(lg.entries, { flat: true });
-		const firstData = messages.find((m) => m[0] === DATA);
-		expect(firstData).toBeDefined();
-		expect(firstData![1]).toEqual(["a", "b", "c"]);
-		unsub();
-	});
-
-	// ── Scenario 15: tail(0) — always empty ────────────────────────────
-	it("S15: tail(0) returns empty node; recomputes but always empty", () => {
-		const lg = reactiveLog<number>();
-		const t0 = lg.view({ kind: "tail", n: 0 });
-		expect(t0.cache).toEqual([]);
-
-		lg.append(1);
-		lg.append(2);
-		expect(t0.cache).toEqual([]);
-	});
-
-	// ── Scenario 16: maxSize validation ────────────────────────────────
-	it("S16: maxSize < 1 throws at construction", () => {
-		expect(() => reactiveLog<number>([], { maxSize: 0 })).toThrow(RangeError);
-		expect(() => reactiveLog<number>([], { maxSize: -1 })).toThrow(RangeError);
-	});
-});
-
-// ── New bundle APIs ────────────────────────────────────────────────────
-
-describe("reactiveLog new APIs", () => {
-	it("size reflects backend state in O(1)", () => {
-		const lg = reactiveLog<number>();
-		expect(lg.size).toBe(0);
-
-		lg.append(1);
-		expect(lg.size).toBe(1);
-
-		lg.appendMany([2, 3, 4]);
-		expect(lg.size).toBe(4);
-
-		lg.trimHead(2);
-		expect(lg.size).toBe(2);
-
-		lg.clear();
-		expect(lg.size).toBe(0);
-	});
-
-	it("at(index) returns value at index, undefined on out-of-range", () => {
-		const lg = reactiveLog<string>(["a", "b", "c"]);
-
-		expect(lg.at(0)).toBe("a");
-		expect(lg.at(1)).toBe("b");
-		expect(lg.at(2)).toBe("c");
-		expect(lg.at(3)).toBeUndefined();
-		// P5: Python-style negative indexing supported (parity with reactiveList).
-		expect(lg.at(-1)).toBe("c");
-		expect(lg.at(-2)).toBe("b");
-		expect(lg.at(-3)).toBe("a");
-		expect(lg.at(-4)).toBeUndefined();
-		expect(lg.at(99)).toBeUndefined();
-	});
-
-	it("at() under ring buffer — O(1) access at all positions", () => {
-		const lg = reactiveLog<number>([], { maxSize: 5 });
-		for (let i = 0; i < 100; i++) lg.append(i);
-
-		// Last 5 values: 95..99
-		expect(lg.at(0)).toBe(95);
-		expect(lg.at(1)).toBe(96);
-		expect(lg.at(4)).toBe(99);
-		expect(lg.at(5)).toBeUndefined();
-	});
-
-	describe("slice memoization", () => {
-		it("repeat calls with same (start, stop) return same node", () => {
-			const lg = reactiveLog<number>();
-			const s1 = lg.view({ kind: "slice", start: 2, stop: 5 });
-			const s2 = lg.view({ kind: "slice", start: 2, stop: 5 });
-			const s3 = lg.view({ kind: "slice", start: 2 }); // different — no stop
-			const s4 = lg.view({ kind: "slice", start: 2, stop: 5 });
-
-			expect(s1).toBe(s2);
-			expect(s1).toBe(s4);
-			expect(s1).not.toBe(s3);
-		});
-	});
-});
-
-// ── Native backend direct tests ────────────────────────────────────────
-
-describe("NativeLogBackend", () => {
-	it("version counter advances on every mutation", () => {
-		const b = new NativeLogBackend<number>();
-		expect(b.version).toBe(0);
-
-		b.append(1);
-		expect(b.version).toBe(1);
-
-		b.append(2);
-		expect(b.version).toBe(2);
-
-		b.appendMany([3, 4]);
-		expect(b.version).toBe(3); // one bump for the whole batch
-
-		b.appendMany([]); // no-op
-		expect(b.version).toBe(3);
-
-		expect(b.trimHead(1)).toBe(1);
-		expect(b.version).toBe(4);
-
-		expect(b.trimHead(0)).toBe(0); // no-op
-		expect(b.version).toBe(4);
-
-		expect(b.clear()).toBe(3);
-		expect(b.version).toBe(5);
-
-		expect(b.clear()).toBe(0); // no-op
-		expect(b.version).toBe(5);
-	});
-
-	it("ring buffer mode (maxSize=5) correctness", () => {
-		const b = new NativeLogBackend<number>(undefined, 5);
-		for (let i = 0; i < 100; i++) b.append(i);
-
-		expect(b.size).toBe(5);
-		expect(b.toArray()).toEqual([95, 96, 97, 98, 99]);
-		expect(b.at(0)).toBe(95);
-		expect(b.at(4)).toBe(99);
-	});
-
-	it("ring buffer — trimHead advances head index correctly", () => {
-		const b = new NativeLogBackend<number>(undefined, 5);
-		for (let i = 0; i < 7; i++) b.append(i); // [2, 3, 4, 5, 6] — head past start
-
-		b.trimHead(2);
-		expect(b.toArray()).toEqual([4, 5, 6]);
-		expect(b.size).toBe(3);
-
-		b.append(7);
-		b.append(8);
-		expect(b.toArray()).toEqual([4, 5, 6, 7, 8]);
-	});
-
-	it("slice (ring buffer mode) produces correct contiguous array", () => {
-		const b = new NativeLogBackend<number>(undefined, 10);
-		for (let i = 0; i < 50; i++) b.append(i); // last 10 = [40..49]
-
-		expect(b.slice(0, 5)).toEqual([40, 41, 42, 43, 44]);
-		expect(b.slice(5)).toEqual([45, 46, 47, 48, 49]);
-		expect(b.slice(3, 7)).toEqual([43, 44, 45, 46]);
-
-		// Out-of-range stop clamps
-		expect(b.slice(0, 9999)).toEqual([40, 41, 42, 43, 44, 45, 46, 47, 48, 49]);
-
-		// start >= size → empty
-		expect(b.slice(99, 999)).toEqual([]);
-	});
-
-	it("tail (ring buffer) handles n > size", () => {
-		const b = new NativeLogBackend<number>(undefined, 10);
-		b.append(1);
-		b.append(2);
-		expect(b.tail(5)).toEqual([1, 2]); // clamped
-		expect(b.tail(0)).toEqual([]);
-	});
-});
-
-// ── Pluggable backend ──────────────────────────────────────────────────
-
-describe("reactiveLog with user-provided backend", () => {
-	it("can plug in a custom backend implementation", () => {
-		class CountingLogBackend<T> implements LogBackend<T> {
-			private readonly inner = new NativeLogBackend<T>();
-			appendCount = 0;
-			appendManyCount = 0;
-
-			get version(): number {
-				return this.inner.version;
-			}
-			get size(): number {
-				return this.inner.size;
-			}
-			at(i: number): T | undefined {
-				return this.inner.at(i);
-			}
-			append(v: T): void {
-				this.appendCount += 1;
-				this.inner.append(v);
-			}
-			appendMany(values: readonly T[]): void {
-				if (values.length > 0) this.appendManyCount += 1;
-				this.inner.appendMany(values);
-			}
-			clear(): number {
-				return this.inner.clear();
-			}
-			trimHead(n: number): number {
-				return this.inner.trimHead(n);
-			}
-			slice(start: number, stop?: number): readonly T[] {
-				return this.inner.slice(start, stop);
-			}
-			tail(n: number): readonly T[] {
-				return this.inner.tail(n);
-			}
-			toArray(): readonly T[] {
-				return this.inner.toArray();
-			}
-		}
-
-		const backend = new CountingLogBackend<number>();
-		const lg = reactiveLog<number>(undefined, { backend });
-
-		lg.append(1);
-		lg.append(2);
-		lg.appendMany([3, 4, 5]);
-
-		expect(backend.appendCount).toBe(2);
-		expect(backend.appendManyCount).toBe(1);
-		expect(lg.size).toBe(5);
-		expect(lg.entries.cache).toEqual([1, 2, 3, 4, 5]);
-	});
-});
-
-// ── Audit 1 — lifecycle composition ────────────────────────────────────
-
-describe("reactiveLog Audit 1 helpers — lifecycle composition", () => {
-	it("withLatest() lazy-activates lastValue (Lock 5.A: hasLatest retired)", () => {
-		const lg = reactiveLog<number>();
-		// Empty log → SENTINEL alignment: lastValue caches `undefined`.
-		// Lock 5.A retired `hasLatest` — empty-vs-non-empty is now
-		// distinguished by wave shape (RESOLVED vs DATA).
-		const lv = lg.lastValue;
-		expect(lv.cache).toBeUndefined();
-
-		// Returning entries from withLatest() is the documented chaining shape.
-		const entries = lg.withLatest();
-		expect(entries).toBe(lg.entries);
-
-		lg.append(7);
-		expect(lv.cache).toBe(7);
-
-		lg.append(11);
-		expect(lv.cache).toBe(11);
-	});
-
-	it("lastValue never emits DATA(undefined) — clear() routes through RESOLVED", () => {
-		const lg = reactiveLog<number>();
-		// Seed values BEFORE subscribing so the initial subscribe captures the
-		// last-value DATA, then clear() is the specific transition under test.
-		lg.append(1);
-		lg.append(2);
-
-		const { messages, unsub } = collect(lg.lastValue, { flat: true });
-		// Initial subscribe captures DATA(2) (the cached lastValue).
-		const beforeClearLen = messages.length;
-		expect(messages.some((m) => m[0] === DATA && m[1] === 2)).toBe(true);
-
-		lg.clear();
-		// The clear() wave specifically must route through RESOLVED — no
-		// DATA(undefined) anywhere in the post-clear segment.
-		const afterClear = messages.slice(beforeClearLen);
-		expect(afterClear.some((m) => m[0] === RESOLVED)).toBe(true);
-		expect(afterClear.some((m) => m[0] === DATA && m[1] === undefined)).toBe(false);
-
-		// Re-append produces DATA(3) cleanly after the empty interval.
-		lg.append(3);
-		expect(messages.some((m) => m[0] === DATA && m[1] === 3)).toBe(true);
-		// Whole-stream invariant — no DATA(undefined) ever (spec §1.2).
-		expect(messages.some((m) => m[0] === DATA && m[1] === undefined)).toBe(false);
-		unsub();
-	});
-
-	it("Lock 5.A: append(undefined) is rejected at runtime", () => {
-		const lg = reactiveLog<number>();
-		// Lock 5.A narrows `T` to exclude `undefined`. The runtime guard
-		// rejects literal `undefined` so the empty-vs-non-empty wave-shape
-		// disambiguation (RESOLVED vs DATA) stays unambiguous.
-		expect(() => lg.append(undefined as unknown as number)).toThrow(/Lock 5\.A/);
-		expect(() => lg.appendMany([1, undefined as unknown as number, 2])).toThrow(/Lock 5\.A/);
-		// Earlier successful append still landed (single-value rejection
-		// throws synchronously before any backend mutation).
-		lg.append(1);
-		expect(lg.entries.cache).toEqual([1]);
-	});
-
-	it("attach(upstream) drains DATA into the log and disposer detaches", () => {
-		const lg = reactiveLog<number>();
-		const src = node<number>([], { initial: 0 });
-		const detach = lg.attach(src);
-
-		// On subscribe, push-on-subscribe replays `node([], { initial: 0 })`'s cached `0` —
-		// the attach handler treats that DATA the same as any post-subscribe
-		// emission, so the initial cached value lands in the log.
-		expect(lg.entries.cache).toEqual([0]);
-		src.emit(1);
-		src.emit(2);
-		expect(lg.entries.cache).toEqual([0, 1, 2]);
-
-		detach();
-		src.emit(3);
-		// After detach: subsequent emissions are NOT forwarded.
-		expect(lg.entries.cache).toEqual([0, 1, 2]);
-	});
-
-	it("disposeAllViews releases tail/slice/fromCursor view caches", () => {
-		const lg = reactiveLog<number>([1, 2, 3, 4, 5]);
-		const cursor = node<number>([], { initial: 0 });
-
-		const t = lg.view({ kind: "tail", n: 2 });
-		const s = lg.view({ kind: "slice", start: 1 });
-		const c = lg.view({ kind: "fromCursor", cursor });
-
-		// Pre-dispose: same calls return the memoized nodes.
-		expect(lg.view({ kind: "tail", n: 2 })).toBe(t);
-		expect(lg.view({ kind: "slice", start: 1 })).toBe(s);
-		expect(lg.view({ kind: "fromCursor", cursor })).toBe(c);
-
-		lg.disposeAllViews();
-
-		// Post-dispose: view caches are cleared, so identical specs return
-		// fresh nodes (not the previously memoized ones).
-		expect(lg.view({ kind: "tail", n: 2 })).not.toBe(t);
-		expect(lg.view({ kind: "slice", start: 1 })).not.toBe(s);
-		expect(lg.view({ kind: "fromCursor", cursor })).not.toBe(c);
-	});
-
-	it("view + attach + withLatest co-activate without dropping initial state", () => {
-		const lg = reactiveLog<number>([10, 20, 30]);
-		const tail = lg.view({ kind: "tail", n: 2 });
-		const lastValue = lg.lastValue;
-		const upstream = node<number>([], { initial: 40 });
-		const detach = lg.attach(upstream);
-
-		expect(lg.entries.cache).toEqual([10, 20, 30, 40]);
-		expect(tail.cache).toEqual([30, 40]);
-		expect(lastValue.cache).toBe(40);
-
-		upstream.emit(50);
-		expect(tail.cache).toEqual([40, 50]);
-		expect(lastValue.cache).toBe(50);
-
-		detach();
-	});
-});
-
-// ── LogBackend snapshot/restore ────────────────────────────────────────
-
-describe("LogBackend.snapshot / restore (Audit 1)", () => {
-	it("NativeLogBackend.snapshot() round-trips through restore()", () => {
-		const a = new NativeLogBackend<number>([1, 2, 3]);
-		const snap = a.snapshot();
-
-		const b = new NativeLogBackend<number>();
-		expect(b.size).toBe(0);
-		b.restore(snap);
-		expect(b.toArray()).toEqual([1, 2, 3]);
-		expect(b.size).toBe(3);
-	});
-
-	it("snapshot() returns the same shape as toArray()", () => {
-		const a = new NativeLogBackend<number>([1, 2, 3]);
-		expect(a.snapshot()).toEqual(a.toArray());
-	});
-
-	it("restore() resets backend state; subsequent append flushes the merged shape via entries", () => {
-		// Direct backend access via the user-provided backend escape hatch.
-		const backend = new NativeLogBackend<number>();
-		const lg = reactiveLog<number>(undefined, { backend });
-
-		// Subscribe to the SAME log we'll restore into; capture only emissions
-		// that flow after restore + append.
-		const { messages, unsub } = collect(lg.entries, { flat: true });
-		const beforeRestoreLen = messages.length;
-
-		backend.restore([1, 2, 3]);
-		// `restore` mutates the backend directly; the entries node only flushes
-		// on the next mutation that runs through `wrapMutation`. Append one
-		// element to trigger the snapshot push.
-		lg.append(4);
-
-		expect(lg.entries.cache).toEqual([1, 2, 3, 4]);
-		const afterRestore = messages.slice(beforeRestoreLen);
-		// The post-restore append produced a DATA wave carrying the merged
-		// snapshot through `entries`.
-		const lastData = afterRestore.filter((m) => m[0] === DATA).at(-1);
-		expect(lastData?.[1]).toEqual([1, 2, 3, 4]);
-
-		unsub();
-	});
-});
-
-// ── mergeReactiveLogs lifecycle ────────────────────────────────────────
-
-describe("mergeReactiveLogs (Audit 1)", () => {
-	it("flatlines initial snapshots from each input log", () => {
-		const a = reactiveLog<string>(["a1", "a2"]);
-		const b = reactiveLog<string>(["b1"]);
-		const merged = mergeReactiveLogs([a.entries, b.entries]);
-		expect(merged.node.cache).toEqual(["a1", "a2", "b1"]);
-		merged.dispose();
-	});
-
-	it("memoized by reference identity on the logs array", () => {
-		const a = reactiveLog<number>([1]);
-		const b = reactiveLog<number>([2]);
-		const arr = [a.entries, b.entries] as const;
-		const m1 = mergeReactiveLogs(arr);
-		const m2 = mergeReactiveLogs(arr);
-		expect(m1).toBe(m2);
-		m1.dispose();
-	});
-
-	it("appends from any input log fan into the merged stream", () => {
-		const a = reactiveLog<number>();
-		const b = reactiveLog<number>();
-		const merged = mergeReactiveLogs([a.entries, b.entries]);
-		expect(merged.node.cache).toEqual([]);
-
-		a.append(1);
-		expect(merged.node.cache).toEqual([1]);
-		b.append(2);
-		expect(merged.node.cache).toEqual([1, 2]);
-		a.append(3);
-		expect(merged.node.cache).toEqual([1, 3, 2]);
-
-		merged.dispose();
-	});
-
-	it("dispose() releases subscriptions; further input changes are ignored", () => {
-		const a = reactiveLog<number>();
-		const b = reactiveLog<number>();
-		const merged = mergeReactiveLogs([a.entries, b.entries]);
-
-		a.append(1);
-		expect(merged.node.cache).toEqual([1]);
-
-		merged.dispose();
-
-		// After dispose, further input changes don't flow into the merge.
-		a.append(2);
-		b.append(3);
-		expect(merged.node.cache).toEqual([1]);
-	});
-
-	it("ERROR on an input log propagates through the merge", () => {
-		const a = reactiveLog<number>();
-		const b = reactiveLog<number>();
-		const merged = mergeReactiveLogs([a.entries, b.entries]);
-		const flat = collect(merged.node, { flat: true });
-
-		// Drive a known DATA through `a` first so we can verify normal flow
-		// happens BEFORE the ERROR — otherwise the test passes vacuously when
-		// the merge wiring never connected.
-		a.append(1);
-		expect(flat.messages.some((m) => m[0] === DATA && Array.isArray(m[1]))).toBe(true);
-		const preErrorCount = flat.messages.length;
-
-		// `Node.down` is public API (core/node.ts §3.5). Driving ERROR through
-		// the underlying entries node simulates an upstream failure;
-		// reactiveLog's append-side surface has no ERROR channel by design.
-		a.entries.down([[ERROR, new Error("boom")]]);
-
-		const afterError = flat.messages.slice(preErrorCount);
-		expect(afterError.some((m) => m[0] === ERROR)).toBe(true);
-		flat.unsub();
-		merged.dispose();
-	});
-
-	it("COMPLETE on one input drops it from active set; subsequent DATA from completed input is ignored", () => {
-		const a = reactiveLog<number>([1, 2]);
-		const b = reactiveLog<number>([10]);
-		const merged = mergeReactiveLogs([a.entries, b.entries]);
-
-		expect(merged.node.cache).toEqual([1, 2, 10]);
-
-		// Mark `a` complete via the entries node's protocol channel
-		// (`Node.down` is public). Per the impl, this releases `a`'s
-		// subscription so even a stray DATA from `a` wouldn't reach the merge.
-		a.entries.down([[COMPLETE]]);
-
-		// Append to `a` post-COMPLETE — this is misbehaving (well-behaved
-		// nodes don't emit after COMPLETE), but the merge is robust: the
-		// subscription is gone so the value never reaches `merged.node`.
-		a.append(99);
-		expect(merged.node.cache).toEqual([1, 2, 10]);
-
-		// Append to `b` still flows through the merge with exact placement —
-		// `a`'s last bucket is cleared to [], so output = [] ++ [10, 11].
-		b.append(11);
-		expect(merged.node.cache).toEqual([10, 11]);
-
-		merged.dispose();
-	});
-});
diff --git a/packages/pure-ts/src/__tests__/extra/reactive-map-stress.test.ts b/packages/pure-ts/src/__tests__/extra/reactive-map-stress.test.ts
deleted file mode 100644
index ad08cf54..00000000
--- a/packages/pure-ts/src/__tests__/extra/reactive-map-stress.test.ts
+++ /dev/null
@@ -1,630 +0,0 @@
-/**
- * Stress tests for reactiveMap — Wave 4 audit scenarios.
- *
- * Covers: rapid mutations, read-triggered emission, size-getter asymmetry,
- * LRU under concurrent reads, diamond topology, TTL precision,
- * maxSize=1, subscriber-during-batch, and empty-map no-ops.
- */
-
-import { describe, expect, it, vi } from "vitest";
-import { batch } from "../../core/batch.js";
-import { DATA, DIRTY } from "../../core/messages.js";
-import { node } from "../../core/node.js";
-import {
-	type MapBackend,
-	NativeMapBackend,
-	reactiveMap,
-} from "../../extra/data-structures/reactive-map.js";
-import { combine } from "../../extra/operators/index.js";
-import { collect } from "../test-helpers.js";
-
-describe("reactiveMap stress tests", () => {
-	// ── Scenario 1: Rapid set/delete cycle ──────────────────────────────
-	it("S1: rapid set then delete — each mutation emits DIRTY+DATA", () => {
-		const m = reactiveMap<number, number>();
-		const { messages, unsub } = collect(m.entries, { flat: true });
-
-		const N = 100;
-		for (let i = 0; i < N; i++) m.set(i, i);
-		for (let i = 0; i < N; i++) m.delete(i);
-
-		unsub();
-
-		// Each set and each delete (that finds a key) emits DIRTY+DATA.
-		// Total mutations: N sets + N deletes = 2N pushSnapshot calls.
-		// Each pushSnapshot produces 1 DIRTY + 1 DATA = 2 messages.
-		// Plus initial push-on-subscribe DATA.
-		const dirtyCount = messages.filter((m) => m[0] === DIRTY).length;
-		const dataCount = messages.filter((m) => m[0] === DATA).length;
-
-		expect(dirtyCount).toBe(N * 2); // 100 sets + 100 deletes
-		expect(dataCount).toBe(N * 2 + 1); // +1 for push-on-subscribe
-
-		// Final snapshot should be empty
-		const lastData = messages.filter((m) => m[0] === DATA).at(-1)!;
-		expect((lastData[1] as ReadonlyMap<number, number>).size).toBe(0);
-	});
-
-	// ── Scenario 2: Read-triggered emission inside a batch ──────────────
-	it("S2: get() on expired key inside outer batch — nested batch correctness", () => {
-		vi.useFakeTimers();
-		const m = reactiveMap<string, number>();
-		m.set("a", 1, { ttl: 1 });
-
-		const { messages, unsub } = collect(m.entries, { flat: true });
-		const beforeLen = messages.length;
-
-		vi.advanceTimersByTime(1500);
-
-		// get() inside an outer batch should still emit correctly
-		batch(() => {
-			const val = m.get("a"); // expired → triggers pushSnapshot inside
-			expect(val).toBeUndefined();
-			m.set("b", 2); // another mutation in same outer batch
-		});
-
-		unsub();
-		vi.useRealTimers();
-
-		// Both the expiry-triggered snapshot and the set("b") snapshot should have emitted.
-		const newMessages = messages.slice(beforeLen);
-		const dirtyCount = newMessages.filter((m) => m[0] === DIRTY).length;
-		const dataCount = newMessages.filter((m) => m[0] === DATA).length;
-
-		// Inside the outer batch, two pushSnapshot calls happen.
-		// The nested batches accumulate; drain happens when outer batch closes.
-		expect(dirtyCount).toBe(2);
-		expect(dataCount).toBe(2);
-
-		// Final state should have only "b"
-		const lastData = newMessages.filter((m) => m[0] === DATA).at(-1)!;
-		const snap = lastData[1] as ReadonlyMap<string, number>;
-		expect(snap.has("a")).toBe(false);
-		expect(snap.get("b")).toBe(2);
-	});
-
-	// ── Scenario 3: size is a pure read — D2(a), spec §5.8 compliance ───
-	it("S3: size is a pure read (no side-effect emission, includes not-yet-pruned expired)", () => {
-		vi.useFakeTimers();
-		const m = reactiveMap<string, number>();
-		m.set("a", 1, { ttl: 1 });
-		m.set("b", 2); // no TTL
-
-		const { messages, unsub } = collect(m.entries, { flat: true });
-		const beforeLen = messages.length;
-
-		vi.advanceTimersByTime(1500);
-
-		// D2(a): .size is now a pure read — no pruning, no emission. Raw
-		// store count includes the not-yet-pruned expired "a".
-		const sz = m.size;
-		expect(sz).toBe(2);
-
-		// No messages emitted from the size read.
-		expect(messages.length).toBe(beforeLen);
-
-		// Explicit pruneExpired() delivers the live count + one snapshot emit.
-		m.pruneExpired();
-		expect(m.size).toBe(1);
-		const afterPrune = messages.slice(beforeLen);
-		expect(afterPrune.filter((msg) => msg[0] === DIRTY).length).toBe(1);
-		expect(afterPrune.filter((msg) => msg[0] === DATA).length).toBe(1);
-
-		// entries.cache is fresh post-prune.
-		const cached = m.entries.cache as ReadonlyMap<string, number>;
-		expect(cached.has("a")).toBe(false);
-		expect(cached.size).toBe(1);
-		expect(cached.get("b")).toBe(2);
-
-		// Subsequent size access: nothing to prune, pure read, no emission.
-		const afterReadLen = messages.length;
-		expect(m.size).toBe(1);
-		expect(messages.length).toBe(afterReadLen);
-
-		unsub();
-		vi.useRealTimers();
-	});
-
-	// ── Scenario 4: LRU under interleaved reads ─────────────────────────
-	it("S4: interleaved get() calls reorder LRU correctly", () => {
-		const m = reactiveMap<string, number>({ maxSize: 3 });
-		m.set("a", 1);
-		m.set("b", 2);
-		m.set("c", 3);
-
-		// Touch "a" (oldest) — moves it to end of LRU
-		m.get("a");
-
-		// Now LRU order is: b, c, a
-		// Adding "d" should evict "b" (oldest untouched)
-		m.set("d", 4);
-		expect(m.has("a")).toBe(true);
-		expect(m.has("b")).toBe(false); // evicted
-		expect(m.has("c")).toBe(true);
-		expect(m.has("d")).toBe(true);
-
-		// Touch "c", then add "e" — should evict "a" (now oldest)
-		m.get("c");
-		// LRU order: a, d, c (after get("c") moved it to end)
-		// Wait, after set("d"), order was: c, a, d
-		// After get("c"): a, d, c
-		m.set("e", 5);
-		// Should evict "a" (first in iteration order)
-		expect(m.has("a")).toBe(false); // evicted
-		expect(m.has("c")).toBe(true);
-		expect(m.has("d")).toBe(true);
-		expect(m.has("e")).toBe(true);
-	});
-
-	// ── Scenario 5: Diamond topology — glitch-free ──────────────────────
-	it("S5: diamond through two derived nodes — consistent settle", () => {
-		const m = reactiveMap<string, number>();
-		m.set("x", 10);
-
-		// Two derived nodes from the same entries source
-		const left = node(
-			[m.entries],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				const s = data[0] as ReadonlyMap<string, number>;
-				actions.emit(s.get("x") ?? 0);
-			},
-			{ describeKind: "derived", initial: 10 },
-		);
-		const right = node(
-			[m.entries],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				const s = data[0] as ReadonlyMap<string, number>;
-				actions.emit((s.get("x") ?? 0) * 2);
-			},
-			{ describeKind: "derived", initial: 20 },
-		);
-
-		// Combine — should never see inconsistent (left, right) pair
-		const combined = combine(left, right);
-		const seen: [number, number][] = [];
-		const unsub = combined.subscribe((msgs) => {
-			for (const msg of msgs as [symbol, unknown][]) {
-				if (msg[0] === DATA) {
-					seen.push(msg[1] as [number, number]);
-				}
-			}
-		});
-
-		m.set("x", 20);
-		m.set("x", 30);
-
-		unsub();
-
-		// Every observed pair should be consistent: right === left * 2
-		for (const [l, r] of seen) {
-			expect(r).toBe(l * 2);
-		}
-		// We should have seen the initial (push-on-subscribe) plus at least the final state
-		expect(seen.length).toBeGreaterThanOrEqual(1);
-		expect(seen.at(-1)).toEqual([30, 60]);
-	});
-
-	// ── Scenario 6: TTL with fake timers — lazy eviction ────────────────
-	it("S6: TTL lazy eviction via get/has/pruneExpired", () => {
-		vi.useFakeTimers();
-		const m = reactiveMap<string, number>();
-		m.set("a", 1, { ttl: 2 });
-		m.set("b", 2, { ttl: 5 });
-
-		// Before expiry — both present
-		expect(m.get("a")).toBe(1);
-		expect(m.has("b")).toBe(true);
-
-		// Advance past "a" TTL but before "b"
-		vi.advanceTimersByTime(3000);
-
-		// get("a") should find it expired and trigger emission
-		const { messages, unsub } = collect(m.entries, { flat: true });
-		const val = m.get("a");
-		expect(val).toBeUndefined();
-
-		// An emission should have occurred (get found expired key)
-		const dataAfterExpiry = messages.filter((msg) => msg[0] === DATA);
-		// push-on-subscribe + expiry emission
-		expect(dataAfterExpiry.length).toBeGreaterThanOrEqual(2);
-
-		// "b" should still be alive
-		expect(m.has("b")).toBe(true);
-
-		// Advance past "b" TTL
-		vi.advanceTimersByTime(3000);
-		m.pruneExpired();
-		expect(m.size).toBe(0);
-
-		unsub();
-		vi.useRealTimers();
-	});
-
-	// ── Scenario 7: maxSize=1 ───────────────────────────────────────────
-	it("S7: maxSize=1 — second set evicts first", () => {
-		const m = reactiveMap<string, number>({ maxSize: 1 });
-		m.set("a", 1);
-		m.set("b", 2);
-
-		expect(m.has("a")).toBe(false);
-		expect(m.get("b")).toBe(2);
-		expect(m.size).toBe(1);
-
-		// Verify snapshot consistency
-		const snap = m.entries.cache as ReadonlyMap<string, number>;
-		expect(snap.size).toBe(1);
-		expect(snap.get("b")).toBe(2);
-	});
-
-	// ── Scenario 8: Subscriber during pushSnapshot ──────────────────────
-	it("S8: new subscriber gets push-on-subscribe (cached state)", () => {
-		const m = reactiveMap<string, number>();
-		m.set("x", 42);
-
-		// Subscribe AFTER mutation — should get cached snapshot via push-on-subscribe
-		const { messages, unsub } = collect(m.entries, { flat: true });
-
-		// First message should be DATA with the current snapshot (push-on-subscribe)
-		const firstData = messages.find((msg) => msg[0] === DATA);
-		expect(firstData).toBeDefined();
-		const snap = firstData![1] as ReadonlyMap<string, number>;
-		expect(snap.get("x")).toBe(42);
-
-		unsub();
-	});
-
-	// ── Scenario 9: TTL precision at boundary ───────────────────────────
-	it("S9: key expires at exactly expiresAt (>= comparison)", () => {
-		vi.useFakeTimers();
-		const m = reactiveMap<string, number>();
-		m.set("a", 1, { ttl: 1 });
-
-		// At exactly 1000ms — should be expired (>= comparison)
-		vi.advanceTimersByTime(1000);
-		expect(m.get("a")).toBeUndefined();
-
-		vi.useRealTimers();
-	});
-
-	// ── Scenario 10: Empty map no-ops ───────────────────────────────────
-	it("S10: clear on empty map and delete on missing key are no-ops", () => {
-		const m = reactiveMap<string, number>();
-		const { messages, unsub } = collect(m.entries, { flat: true });
-		const beforeLen = messages.length;
-
-		m.clear(); // no-op: already empty
-		m.delete("nonexistent"); // no-op: key doesn't exist
-
-		expect(messages.length).toBe(beforeLen); // no new messages
-
-		unsub();
-	});
-
-	// ── Additional: throws on non-positive TTL ──────────────────────────
-	it("throws RangeError on ttl <= 0", () => {
-		const m = reactiveMap<string, number>();
-		expect(() => m.set("a", 1, { ttl: 0 })).toThrow(RangeError);
-		expect(() => m.set("a", 1, { ttl: -1 })).toThrow(RangeError);
-	});
-
-	// ── Additional: concurrent set doesn't double-emit ──────────────────
-	it("set on existing key emits exactly one DIRTY+DATA pair", () => {
-		const m = reactiveMap<string, number>();
-		m.set("a", 1);
-
-		const { messages, unsub } = collect(m.entries, { flat: true });
-		const beforeLen = messages.length;
-
-		m.set("a", 2); // overwrite
-
-		const newMessages = messages.slice(beforeLen);
-		const dirtyCount = newMessages.filter((msg) => msg[0] === DIRTY).length;
-		const dataCount = newMessages.filter((msg) => msg[0] === DATA).length;
-
-		expect(dirtyCount).toBe(1);
-		expect(dataCount).toBe(1);
-
-		const snap = newMessages.find((msg) => msg[0] === DATA)![1] as ReadonlyMap<string, number>;
-		expect(snap.get("a")).toBe(2);
-
-		unsub();
-	});
-});
-
-// ── New API tests ───────────────────────────────────────────────────────
-
-describe("reactiveMap new APIs", () => {
-	describe("setMany", () => {
-		it("empty iterable is a no-op, no emission", () => {
-			const m = reactiveMap<string, number>();
-			const { messages, unsub } = collect(m.entries, { flat: true });
-			const beforeLen = messages.length;
-
-			m.setMany([]);
-
-			expect(messages.length).toBe(beforeLen);
-			expect(m.size).toBe(0);
-			unsub();
-		});
-
-		it("N entries emit exactly 1 DIRTY + 1 DATA (not 2N)", () => {
-			const m = reactiveMap<string, number>();
-			const { messages, unsub } = collect(m.entries, { flat: true });
-			const beforeLen = messages.length;
-
-			m.setMany([
-				["a", 1],
-				["b", 2],
-				["c", 3],
-			]);
-
-			const newMessages = messages.slice(beforeLen);
-			expect(newMessages.filter((msg) => msg[0] === DIRTY).length).toBe(1);
-			expect(newMessages.filter((msg) => msg[0] === DATA).length).toBe(1);
-
-			const snap = newMessages.find((msg) => msg[0] === DATA)![1] as ReadonlyMap<string, number>;
-			expect(snap.size).toBe(3);
-			expect(snap.get("a")).toBe(1);
-			expect(snap.get("b")).toBe(2);
-			expect(snap.get("c")).toBe(3);
-
-			unsub();
-		});
-
-		it("applies batch TTL to all entries", () => {
-			vi.useFakeTimers();
-			const m = reactiveMap<string, number>();
-			m.setMany(
-				[
-					["a", 1],
-					["b", 2],
-				],
-				{ ttl: 2 },
-			);
-			expect(m.get("a")).toBe(1);
-			expect(m.get("b")).toBe(2);
-
-			vi.advanceTimersByTime(3000);
-			expect(m.get("a")).toBeUndefined();
-			expect(m.get("b")).toBeUndefined();
-
-			vi.useRealTimers();
-		});
-
-		it("throws on invalid TTL", () => {
-			const m = reactiveMap<string, number>();
-			expect(() => m.setMany([["a", 1]], { ttl: 0 })).toThrow(RangeError);
-			expect(() => m.setMany([["a", 1]], { ttl: -1 })).toThrow(RangeError);
-		});
-
-		it("accepts generator", () => {
-			const m = reactiveMap<number, number>();
-			function* gen(): Generator<[number, number]> {
-				for (let i = 0; i < 5; i++) yield [i, i * 10];
-			}
-			m.setMany(gen());
-			expect(m.size).toBe(5);
-			expect(m.get(3)).toBe(30);
-		});
-	});
-
-	describe("deleteMany", () => {
-		it("empty iterable is a no-op, no emission", () => {
-			const m = reactiveMap<string, number>();
-			m.set("a", 1);
-			const { messages, unsub } = collect(m.entries, { flat: true });
-			const beforeLen = messages.length;
-
-			m.deleteMany([]);
-			expect(messages.length).toBe(beforeLen);
-			unsub();
-		});
-
-		it("deletes present keys and ignores missing", () => {
-			const m = reactiveMap<string, number>();
-			m.setMany([
-				["a", 1],
-				["b", 2],
-				["c", 3],
-			]);
-
-			m.deleteMany(["a", "missing", "c"]);
-
-			expect(m.has("a")).toBe(false);
-			expect(m.has("b")).toBe(true);
-			expect(m.has("c")).toBe(false);
-			expect(m.size).toBe(1);
-		});
-
-		it("emits once for N deletions", () => {
-			const m = reactiveMap<number, number>();
-			m.setMany(Array.from({ length: 50 }, (_, i) => [i, i] as [number, number]));
-
-			const { messages, unsub } = collect(m.entries, { flat: true });
-			const beforeLen = messages.length;
-
-			m.deleteMany(Array.from({ length: 50 }, (_, i) => i));
-
-			const newMessages = messages.slice(beforeLen);
-			expect(newMessages.filter((msg) => msg[0] === DIRTY).length).toBe(1);
-			expect(newMessages.filter((msg) => msg[0] === DATA).length).toBe(1);
-			expect(m.size).toBe(0);
-			unsub();
-		});
-
-		it("emits nothing if no keys were present", () => {
-			const m = reactiveMap<string, number>();
-			m.set("a", 1);
-
-			const { messages, unsub } = collect(m.entries, { flat: true });
-			const beforeLen = messages.length;
-
-			m.deleteMany(["x", "y"]);
-
-			expect(messages.length).toBe(beforeLen);
-			expect(m.size).toBe(1);
-			unsub();
-		});
-	});
-});
-
-// ── Native backend direct tests ────────────────────────────────────────
-
-describe("NativeMapBackend", () => {
-	it("version counter advances on every state-changing op", () => {
-		const b = new NativeMapBackend<string, number>();
-		expect(b.version).toBe(0);
-
-		b.set("a", 1);
-		expect(b.version).toBe(1);
-
-		b.set("a", 2); // update (still a mutation)
-		expect(b.version).toBe(2);
-
-		expect(b.delete("a")).toBe(true);
-		expect(b.version).toBe(3);
-
-		expect(b.delete("a")).toBe(false); // missing → no version bump
-		expect(b.version).toBe(3);
-
-		b.set("a", 1);
-		b.set("b", 2);
-		expect(b.clear()).toBe(2);
-		expect(b.version).toBe(6);
-
-		expect(b.clear()).toBe(0); // no-op
-		expect(b.version).toBe(6);
-	});
-
-	it("get/has on expired key bumps version (for wrapper emission)", () => {
-		vi.useFakeTimers();
-		const b = new NativeMapBackend<string, number>();
-		b.set("a", 1, 1);
-		const before = b.version;
-
-		vi.advanceTimersByTime(1500);
-
-		expect(b.get("a")).toBeUndefined();
-		expect(b.version).toBeGreaterThan(before); // pruned → version advanced
-
-		vi.useRealTimers();
-	});
-
-	it("get/has on live key does NOT bump version (LRU touch is internal)", () => {
-		const b = new NativeMapBackend<string, number>();
-		b.set("a", 1);
-		const after = b.version;
-
-		b.get("a");
-		expect(b.version).toBe(after);
-
-		b.has("a");
-		expect(b.version).toBe(after);
-	});
-
-	it("maxSize eviction drops first-inserted key", () => {
-		const b = new NativeMapBackend<string, number>({ maxSize: 2 });
-		b.set("a", 1);
-		b.set("b", 2);
-		b.set("c", 3);
-
-		expect(b.has("a")).toBe(false); // evicted
-		expect(b.has("b")).toBe(true);
-		expect(b.has("c")).toBe(true);
-	});
-
-	it("LRU touch via get changes eviction target", () => {
-		const b = new NativeMapBackend<string, number>({ maxSize: 2 });
-		b.set("a", 1);
-		b.set("b", 2);
-		b.get("a"); // touches a → now LRU is: b, a
-		b.set("c", 3); // should evict b
-
-		expect(b.has("a")).toBe(true);
-		expect(b.has("b")).toBe(false);
-		expect(b.has("c")).toBe(true);
-	});
-
-	it("constructor validates options", () => {
-		expect(() => new NativeMapBackend<string, number>({ maxSize: 0 })).toThrow(RangeError);
-		expect(() => new NativeMapBackend<string, number>({ defaultTtl: 0 })).toThrow(RangeError);
-		expect(() => new NativeMapBackend<string, number>({ defaultTtl: -1 })).toThrow(RangeError);
-	});
-
-	it("defaultTtl applies when set() omits ttl", () => {
-		vi.useFakeTimers();
-		const b = new NativeMapBackend<string, number>({ defaultTtl: 0.1 });
-		b.set("a", 1);
-		vi.advanceTimersByTime(150);
-		expect(b.get("a")).toBeUndefined();
-		vi.useRealTimers();
-	});
-});
-
-// ── Pluggable backend ──────────────────────────────────────────────────
-
-describe("reactiveMap with user-provided backend", () => {
-	it("can plug in a custom backend implementation", () => {
-		class CountingMapBackend<K, V> implements MapBackend<K, V> {
-			private readonly inner = new NativeMapBackend<K, V>();
-			setCount = 0;
-			deleteCount = 0;
-			clearCount = 0;
-
-			get version(): number {
-				return this.inner.version;
-			}
-			get size(): number {
-				return this.inner.size;
-			}
-			has(k: K): boolean {
-				return this.inner.has(k);
-			}
-			get(k: K): V | undefined {
-				return this.inner.get(k);
-			}
-			set(k: K, v: V, ttl?: number): void {
-				this.setCount += 1;
-				this.inner.set(k, v, ttl);
-			}
-			delete(k: K): boolean {
-				const had = this.inner.delete(k);
-				if (had) this.deleteCount += 1;
-				return had;
-			}
-			clear(): number {
-				const n = this.inner.clear();
-				if (n > 0) this.clearCount += 1;
-				return n;
-			}
-			pruneExpired(): number {
-				return this.inner.pruneExpired();
-			}
-			toMap(): ReadonlyMap<K, V> {
-				return this.inner.toMap();
-			}
-		}
-
-		const backend = new CountingMapBackend<string, number>();
-		const m = reactiveMap<string, number>({ backend });
-
-		m.set("a", 1);
-		m.set("b", 2);
-		m.set("a", 11); // update
-		m.delete("a");
-		m.delete("missing");
-		m.clear();
-
-		expect(backend.setCount).toBe(3);
-		expect(backend.deleteCount).toBe(1);
-		expect(backend.clearCount).toBe(1);
-
-		expect(m.size).toBe(0);
-	});
-});
diff --git a/packages/pure-ts/src/__tests__/extra/reactive-map.test.ts b/packages/pure-ts/src/__tests__/extra/reactive-map.test.ts
deleted file mode 100644
index 5e1fafe0..00000000
--- a/packages/pure-ts/src/__tests__/extra/reactive-map.test.ts
+++ /dev/null
@@ -1,175 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import { DATA, DIRTY } from "../../core/messages.js";
-import { reactiveMap } from "../../extra/data-structures/reactive-map.js";
-import { collect } from "../test-helpers.js";
-
-describe("extra reactiveMap (roadmap §3.2)", () => {
-	it("emits DIRTY then DATA with versioned snapshot on set", () => {
-		const m = reactiveMap<string, number>();
-		const { batches, unsub } = collect(m.entries);
-		m.set("a", 1);
-		unsub();
-		const flat = (batches as [symbol, unknown][][]).flat();
-		// Push-on-subscribe delivers the initial cached empty Map as DATA first.
-		// After that, set("a", 1) emits DIRTY then DATA with the updated map.
-		// Find the DIRTY and the DATA that follows it (skipping the initial cached push).
-		const iDirty = flat.findIndex((m) => m[0] === DIRTY);
-		expect(iDirty).toBeGreaterThanOrEqual(0);
-		// Find the DATA after DIRTY (the one from set())
-		const iDataAfterDirty = flat.findIndex((m, i) => i > iDirty && m[0] === DATA);
-		expect(iDataAfterDirty).toBeGreaterThan(iDirty);
-		const dataMsg = flat[iDataAfterDirty] as [symbol, ReadonlyMap<string, number>];
-		expect(dataMsg[1].get("a")).toBe(1);
-	});
-
-	it("get refreshes LRU order and returns value", () => {
-		const m = reactiveMap<string, number>({ maxSize: 2 });
-		m.set("a", 1);
-		m.set("b", 2);
-		m.get("a");
-		m.set("c", 3);
-		expect(m.has("a")).toBe(true);
-		expect(m.has("b")).toBe(false);
-		expect(m.get("c")).toBe(3);
-	});
-
-	it("evicts oldest entries when maxSize exceeded", () => {
-		const m = reactiveMap<string, number>({ maxSize: 2 });
-		m.set("x", 1);
-		m.set("y", 2);
-		m.set("z", 3);
-		expect(m.size).toBe(2);
-		expect(m.has("x")).toBe(false);
-		expect(m.get("y")).toBe(2);
-		expect(m.get("z")).toBe(3);
-	});
-
-	it("expires keys by ttl on read and pruneExpired", () => {
-		vi.useFakeTimers();
-		const m = reactiveMap<string, number>();
-		m.set("a", 1, { ttl: 1 });
-		expect(m.get("a")).toBe(1);
-		vi.advanceTimersByTime(1000);
-		expect(m.get("a")).toBeUndefined();
-		m.set("b", 2, { ttl: 5 });
-		vi.advanceTimersByTime(2000);
-		m.pruneExpired();
-		expect(m.has("b")).toBe(true);
-		vi.useRealTimers();
-	});
-
-	it("uses defaultTtl when set omits ttl", () => {
-		vi.useFakeTimers();
-		const m = reactiveMap<string, number>({ defaultTtl: 0.1 });
-		m.set("k", 1);
-		vi.advanceTimersByTime(150);
-		expect(m.get("k")).toBeUndefined();
-		vi.useRealTimers();
-	});
-
-	it("delete and clear emit updates", () => {
-		const m = reactiveMap<string, number>();
-		const { batches, unsub } = collect(m.entries);
-		m.set("a", 1);
-		const afterSet = batches.length;
-		m.delete("a");
-		expect(batches.length).toBeGreaterThan(afterSet);
-		m.set("b", 2);
-		const afterB = batches.length;
-		m.clear();
-		expect(batches.length).toBeGreaterThan(afterB);
-		unsub();
-		expect(m.size).toBe(0);
-	});
-
-	// ── DS14R1 — TTL/LRU prune fidelity in mutationLog ───────────────────────
-	describe("DS14R1 — prune fidelity (mutationLog stays synced with entries)", () => {
-		type AnyMapChange = {
-			structure: string;
-			lifecycle: string;
-			change:
-				| { kind: "set"; key: string; value: number }
-				| { kind: "delete"; key: string; previous: number; reason: string }
-				| { kind: "clear"; count: number };
-		};
-
-		/** Last full snapshot array emitted by a reactiveLog `entries` node. */
-		function lastLog(node: Parameters<typeof collect>[0]): AnyMapChange[] {
-			const { messages, unsub } = collect(node, { flat: true });
-			unsub();
-			let out: AnyMapChange[] = [];
-			for (const m of messages) if (m[0] === DATA) out = m[1] as AnyMapChange[];
-			return out;
-		}
-		function lastEntries(node: Parameters<typeof collect>[0]): ReadonlyMap<string, number> {
-			const { messages, unsub } = collect(node, { flat: true });
-			unsub();
-			let out: ReadonlyMap<string, number> = new Map();
-			for (const m of messages) if (m[0] === DATA) out = m[1] as ReadonlyMap<string, number>;
-			return out;
-		}
-
-		it("read-time TTL expiry appends delete{reason:'expired'} synced with entries", () => {
-			vi.useFakeTimers();
-			const m = reactiveMap<string, number>({ defaultTtl: 0.1, mutationLog: true });
-			m.set("k", 1);
-			vi.advanceTimersByTime(150);
-			// Pure read that discovers the expired entry → prunes it.
-			expect(m.get("k")).toBeUndefined();
-			const log = lastLog(m.mutationLog!.entries);
-			const del = log.find((c) => c.change.kind === "delete");
-			expect(del).toBeDefined();
-			expect(del?.change).toMatchObject({ kind: "delete", key: "k", reason: "expired" });
-			expect(del?.structure).toBe("map");
-			expect(del?.lifecycle).toBe("data");
-			// entries snapshot is consistent with the read (key absent).
-			expect(lastEntries(m.entries).has("k")).toBe(false);
-			vi.useRealTimers();
-		});
-
-		it("LRU eviction appends delete{reason:'lru-evict'}", () => {
-			const m = reactiveMap<string, number>({ maxSize: 2, mutationLog: true });
-			m.set("a", 1);
-			m.set("b", 2);
-			m.set("c", 3); // evicts "a"
-			const log = lastLog(m.mutationLog!.entries);
-			const evict = log.find((c) => c.change.kind === "delete" && c.change.reason === "lru-evict");
-			expect(evict?.change).toMatchObject({ kind: "delete", key: "a", reason: "lru-evict" });
-			expect(lastEntries(m.entries).has("a")).toBe(false);
-		});
-
-		it("replaying mutationLog reconstructs entries exactly (desync regression)", () => {
-			vi.useFakeTimers();
-			const m = reactiveMap<string, number>({ maxSize: 3, mutationLog: true });
-			m.set("a", 1);
-			m.set("b", 2, { ttl: 0.1 });
-			m.set("c", 3);
-			vi.advanceTimersByTime(150);
-			expect(m.has("b")).toBe(false); // TTL prune on read
-			m.set("d", 4);
-			m.set("e", 5); // LRU pressure → evicts oldest live key
-			const log = lastLog(m.mutationLog!.entries);
-			const replay = new Map<string, number>();
-			for (const c of log) {
-				if (c.change.kind === "set") replay.set(c.change.key, c.change.value);
-				else if (c.change.kind === "delete") replay.delete(c.change.key);
-				else if (c.change.kind === "clear") replay.clear();
-			}
-			expect([...replay.entries()].sort()).toEqual([...lastEntries(m.entries).entries()].sort());
-			vi.useRealTimers();
-		});
-
-		it("no mutationLog configured → prune still works, zero records, no throw", () => {
-			vi.useFakeTimers();
-			const m = reactiveMap<string, number>({ defaultTtl: 0.1 });
-			const { batches, unsub } = collect(m.entries);
-			m.set("k", 1);
-			vi.advanceTimersByTime(150);
-			expect(m.get("k")).toBeUndefined(); // prune path with trackPrunes off
-			expect(batches.length).toBeGreaterThan(0);
-			expect(m.mutationLog).toBeUndefined();
-			unsub();
-			vi.useRealTimers();
-		});
-	});
-});
diff --git a/packages/pure-ts/src/__tests__/extra/session1-foundation.test.ts b/packages/pure-ts/src/__tests__/extra/session1-foundation.test.ts
deleted file mode 100644
index 371392e3..00000000
--- a/packages/pure-ts/src/__tests__/extra/session1-foundation.test.ts
+++ /dev/null
@@ -1,476 +0,0 @@
-/**
- * Session 1 — Foundation layer tests for the Wave A implementation effort.
- *
- * Covers:
- * - `src/extra/http-error.ts` → `makeHttpError`
- * - `src/extra/operators.ts` → `onFirstData` / `tapFirst`
- * - `src/extra/sources.ts` → `nodeSignal`, `awaitSettled({ skipCurrent })`
- * - `src/extra/adapters.ts` → `parseSSEStream`
- * - `src/extra/reactive-map.ts` → `retention` option
- * - `src/extra/content-addressed-storage.ts` → `contentAddressedStorage`, `canonicalJson`
- */
-
-import { describe, expect, it, vi } from "vitest";
-import { DATA } from "../../core/messages.js";
-import { node } from "../../core/node.js";
-
-import { fromSSE, parseSSEStream } from "../../extra/adapters.js";
-import {
-	ContentAddressedMissError,
-	canonicalJson,
-	contentAddressedStorage,
-} from "../../extra/content-addressed-storage.js";
-import { makeHttpError } from "../../extra/http-error.js";
-import { onFirstData, tapFirst } from "../../extra/operators.js";
-import { reactiveMap } from "../../extra/reactive-map.js";
-import { awaitSettled, fromAny, nodeSignal } from "../../extra/sources.js";
-import { memoryKv } from "../../extra/storage-tiers.js";
-import { collect } from "../test-helpers.js";
-
-// ─── makeHttpError ────────────────────────────────────────────────────────
-
-describe("makeHttpError (Wave A Unit 12)", () => {
-	it("stamps status + headers + message with provider prefix", async () => {
-		const resp = new Response("rate limited", {
-			status: 429,
-			statusText: "Too Many Requests",
-			headers: { "retry-after": "30" },
-		});
-		const err = (await makeHttpError(resp, "anthropic")) as Error & {
-			status: number;
-			headers: Headers;
-		};
-		expect(err.status).toBe(429);
-		expect(err.headers.get("retry-after")).toBe("30");
-		expect(err.message).toMatch(/^anthropic API 429:/);
-		expect(err.message).toMatch(/rate limited/);
-	});
-
-	it("defaults to HTTP prefix when no provider given", async () => {
-		const resp = new Response("nope", { status: 500, statusText: "Internal Server Error" });
-		const err = await makeHttpError(resp);
-		expect(err.message).toMatch(/^HTTP API 500:/);
-	});
-
-	it("swallows body-read errors and still returns an error with status", async () => {
-		// Response whose `text()` rejects — simulate a broken body stream.
-		const resp = {
-			status: 502,
-			statusText: "Bad Gateway",
-			headers: new Headers(),
-			text: () => Promise.reject(new Error("body unreadable")),
-		} as unknown as Response;
-		const err = (await makeHttpError(resp, "openai")) as Error & { status: number };
-		expect(err.status).toBe(502);
-		expect(err.message).toMatch(/^openai API 502:/);
-		// No body appended (empty after fallback).
-		expect(err.message).not.toMatch(/—/);
-	});
-});
-
-// ─── onFirstData / tapFirst ───────────────────────────────────────────────
-
-describe("onFirstData / tapFirst (Wave A cross-cutting)", () => {
-	it("fires once on the first non-null DATA; passes subsequent values through", () => {
-		const src = node<number | null>([], { initial: null });
-		const calls: number[] = [];
-		const wrapped = onFirstData(src, (v) => calls.push(v as number));
-		const { unsub } = collect(wrapped);
-		src.emit(1);
-		src.emit(2);
-		src.emit(3);
-		unsub();
-		expect(calls).toEqual([1]);
-	});
-
-	it("does not count null as 'first' by default", () => {
-		const src = node<number | null>([], { initial: null });
-		const calls: number[] = [];
-		const wrapped = onFirstData(src, (v) => calls.push(v as number));
-		const { unsub } = collect(wrapped);
-		// Cached null pushed on subscribe. Should NOT fire.
-		expect(calls).toEqual([]);
-		src.emit(42);
-		unsub();
-		expect(calls).toEqual([42]);
-	});
-
-	it("custom where predicate overrides the null default", () => {
-		const src = node<number>([], { initial: 0 });
-		const calls: number[] = [];
-		const wrapped = onFirstData(src, (v) => calls.push(v), {
-			where: (v) => v >= 10,
-		});
-		const { unsub } = collect(wrapped);
-		src.emit(1);
-		src.emit(2);
-		src.emit(15);
-		src.emit(20);
-		unsub();
-		expect(calls).toEqual([15]);
-	});
-
-	it("forwards values unchanged", () => {
-		const src = node<number>([], { initial: 5 });
-		const wrapped = onFirstData(src, () => {});
-		const { messages, unsub } = collect(wrapped, { flat: true });
-		src.emit(10);
-		src.emit(20);
-		unsub();
-		const dataValues = messages.filter((m) => m[0] === DATA).map((m) => m[1]);
-		// push-on-subscribe delivers 5, then emit(10), emit(20).
-		expect(dataValues).toEqual([5, 10, 20]);
-	});
-
-	it("tapFirst is an alias for onFirstData", () => {
-		expect(tapFirst).toBe(onFirstData);
-	});
-});
-
-// ─── nodeSignal ───────────────────────────────────────────────────────────
-
-describe("nodeSignal (Wave A Unit 4 / Unit 11)", () => {
-	it("fires abort when the node emits true", () => {
-		const aborted = node([], { initial: false });
-		const { signal, dispose } = nodeSignal(aborted);
-		expect(signal.aborted).toBe(false);
-		aborted.emit(true);
-		expect(signal.aborted).toBe(true);
-		dispose();
-	});
-
-	it("aborts immediately when the cached value is already true (push-on-subscribe)", () => {
-		const aborted = node([], { initial: true });
-		const { signal, dispose } = nodeSignal(aborted);
-		expect(signal.aborted).toBe(true);
-		dispose();
-	});
-
-	it("ignores null / false values and only fires on true", () => {
-		const aborted = node<boolean>([], { initial: false });
-		const { signal, dispose } = nodeSignal(aborted);
-		aborted.emit(false);
-		aborted.emit(false);
-		expect(signal.aborted).toBe(false);
-		aborted.emit(true);
-		expect(signal.aborted).toBe(true);
-		dispose();
-	});
-
-	it("uses the provided reason on abort", () => {
-		const aborted = node([], { initial: false });
-		const reason = new Error("custom cancellation");
-		const { signal, dispose } = nodeSignal(aborted, { reason });
-		aborted.emit(true);
-		expect(signal.reason).toBe(reason);
-		dispose();
-	});
-
-	it("dispose cleanly unsubscribes from the source before any abort", () => {
-		const aborted = node([], { initial: false });
-		const { signal, dispose } = nodeSignal(aborted);
-		dispose();
-		aborted.emit(true);
-		expect(signal.aborted).toBe(false);
-	});
-
-	it("treats source ERROR as an abort (fail-closed semantics)", () => {
-		// Use a derived that synchronously throws → ERROR message.
-		const trigger = node([], { initial: 0 });
-		const failing = node<boolean>(
-			[trigger],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				if ((data[0] as number) > 0) throw new Error("broken");
-				actions.emit(false);
-			},
-			{ describeKind: "derived" },
-		);
-		const { signal, dispose } = nodeSignal(failing);
-		trigger.emit(1);
-		expect(signal.aborted).toBe(true);
-		dispose();
-	});
-});
-
-// ─── awaitSettled skipCurrent ─────────────────────────────────────────────
-
-describe("awaitSettled({ skipCurrent: true }) (Wave A Unit 4)", () => {
-	it("ignores the cached value and resolves on the next emission", async () => {
-		const s = node<string | null>([], { initial: "stale" });
-		const p = awaitSettled(s, { skipCurrent: true });
-		// The cached "stale" is synchronously pushed — must be ignored.
-		setTimeout(() => s.emit("fresh"), 5);
-		expect(await p).toBe("fresh");
-	});
-
-	it("without skipCurrent, resolves immediately with the cached value", async () => {
-		const s = node<string | null>([], { initial: "cached" });
-		const val = await awaitSettled(s);
-		expect(val).toBe("cached");
-	});
-
-	it("combines with timeoutMs", async () => {
-		const s = node<string | null>([], { initial: "stale" });
-		await expect(awaitSettled(s, { skipCurrent: true, timeoutMs: 25 })).rejects.toThrow(
-			/Timed out/,
-		);
-	});
-});
-
-// ─── parseSSEStream ───────────────────────────────────────────────────────
-
-describe("parseSSEStream (Wave A Unit 12)", () => {
-	function makeSSEStream(text: string): ReadableStream<Uint8Array> {
-		const encoder = new TextEncoder();
-		return new ReadableStream<Uint8Array>({
-			start(controller) {
-				controller.enqueue(encoder.encode(text));
-				controller.close();
-			},
-		});
-	}
-
-	it("yields one event per SSE block", async () => {
-		const stream = makeSSEStream("event: message\ndata: hello\n\nevent: custom\ndata: world\n\n");
-		const events: Array<{ event: string; data: string }> = [];
-		for await (const ev of parseSSEStream(stream)) {
-			events.push({ event: ev.event, data: ev.data });
-		}
-		expect(events).toEqual([
-			{ event: "message", data: "hello" },
-			{ event: "custom", data: "world" },
-		]);
-	});
-
-	it("joins multi-line data with LF", async () => {
-		const stream = makeSSEStream("data: line1\ndata: line2\ndata: line3\n\n");
-		const events = [];
-		for await (const ev of parseSSEStream(stream)) events.push(ev);
-		expect(events[0]?.data).toBe("line1\nline2\nline3");
-	});
-
-	it("honors a custom parse function", async () => {
-		const stream = makeSSEStream('data: {"x":1}\n\ndata: {"x":2}\n\n');
-		const events: Array<{ x: number }> = [];
-		for await (const ev of parseSSEStream<{ x: number }>(stream, {
-			parse: (raw) => JSON.parse(raw) as { x: number },
-		})) {
-			events.push(ev.data);
-		}
-		expect(events).toEqual([{ x: 1 }, { x: 2 }]);
-	});
-
-	it("cancels the upstream reader on external abort", async () => {
-		const ctrl = new AbortController();
-		const encoder = new TextEncoder();
-		let cancelCalled = false;
-		const stream = new ReadableStream<Uint8Array>({
-			start(c) {
-				c.enqueue(encoder.encode("data: a\n\n"));
-				// Never closes — simulate a quiet stream.
-			},
-			cancel() {
-				cancelCalled = true;
-			},
-		});
-		const events: string[] = [];
-		const task = (async () => {
-			for await (const ev of parseSSEStream(stream, { signal: ctrl.signal })) {
-				events.push(ev.data as string);
-				ctrl.abort();
-			}
-		})();
-		await task;
-		expect(events).toEqual(["a"]);
-		expect(cancelCalled).toBe(true);
-	});
-
-	it("fromSSE delegates to parseSSEStream (integration)", async () => {
-		const stream = makeSSEStream("data: one\n\ndata: two\n\n");
-		const out: string[] = [];
-		const node = fromSSE(stream);
-		await new Promise<void>((resolve) => {
-			node.subscribe((msgs) => {
-				for (const m of msgs) {
-					if (m[0] === DATA) out.push((m[1] as { data: string }).data);
-				}
-			});
-			setTimeout(resolve, 50);
-		});
-		expect(out).toEqual(["one", "two"]);
-	});
-});
-
-// ─── reactive-map retention ───────────────────────────────────────────────
-
-describe("reactiveMap retention (Wave A Unit 7 C1)", () => {
-	it("archives entries below archiveThreshold on mutation", () => {
-		const archived: Array<[string, number, number]> = [];
-		const m = reactiveMap<string, number>({
-			retention: {
-				score: (_k, v) => v,
-				archiveThreshold: 5,
-				onArchive: (k, v, s) => archived.push([k, v, s]),
-			},
-		});
-		m.set("a", 3);
-		m.set("b", 7);
-		m.set("c", 2);
-		m.set("d", 10);
-		// a (3) and c (2) are below threshold 5 → archived.
-		expect(archived.map(([k]) => k).sort()).toEqual(["a", "c"]);
-		expect(m.has("a")).toBe(false);
-		expect(m.has("b")).toBe(true);
-		expect(m.has("c")).toBe(false);
-		expect(m.has("d")).toBe(true);
-	});
-
-	it("caps entries at retention.maxSize, archiving lowest-scored first", () => {
-		const archived: string[] = [];
-		const m = reactiveMap<string, number>({
-			retention: {
-				score: (_k, v) => v,
-				maxSize: 2,
-				onArchive: (k) => archived.push(k),
-			},
-		});
-		m.set("low", 1);
-		m.set("mid", 5);
-		m.set("high", 10);
-		// After inserting "high", cap is 2 — "low" (score 1) archived.
-		expect(archived).toEqual(["low"]);
-		m.set("extra", 20);
-		// Next cap hit archives "mid" (score 5, now the lowest).
-		expect(archived).toEqual(["low", "mid"]);
-		expect(m.has("high")).toBe(true);
-		expect(m.has("extra")).toBe(true);
-	});
-
-	it("emits exactly one post-mutation snapshot reflecting archival side-effects", () => {
-		const m = reactiveMap<string, number>({
-			retention: { score: (_k, v) => v, archiveThreshold: 0 },
-		});
-		m.set("a", 5);
-		const { batches, unsub } = collect(m.entries);
-		m.set("b", -1); // below threshold — archived.
-		unsub();
-		const flat = (batches as [symbol, unknown][][]).flat();
-		const lastData = [...flat].reverse().find((msg) => msg[0] === DATA);
-		expect(lastData).toBeDefined();
-		const map = (lastData as [symbol, ReadonlyMap<string, number>])[1];
-		expect(map.has("b")).toBe(false); // archived in the same wave
-		expect(map.has("a")).toBe(true);
-	});
-
-	it("rejects conflicting maxSize + retention at construction", () => {
-		expect(() =>
-			reactiveMap({
-				maxSize: 5,
-				retention: { score: () => 0, archiveThreshold: 0 },
-			}),
-		).toThrow(/mutually exclusive/);
-	});
-
-	it("rejects retention with no trigger (no threshold, no maxSize)", () => {
-		expect(() =>
-			reactiveMap({
-				retention: { score: () => 0 },
-			}),
-		).toThrow(/at least one of/);
-	});
-});
-
-// ─── contentAddressedStorage ──────────────────────────────────────────────
-
-describe("contentAddressedStorage (Wave A Unit 11 + 12)", () => {
-	it("stores and looks up by content-hash", async () => {
-		const cache = contentAddressedStorage<{ q: string }, { ans: string }>({
-			storage: memoryKv(),
-			keyPrefix: "qa",
-		});
-		await cache.store({ q: "hi" }, { ans: "hello" });
-		const hit = await cache.lookup({ q: "hi" });
-		expect(hit).toEqual({ ans: "hello" });
-		const miss = await cache.lookup({ q: "different" });
-		expect(miss).toBeUndefined();
-	});
-
-	it("throws ContentAddressedMissError in read-strict mode on miss", async () => {
-		const cache = contentAddressedStorage<{ q: string }, { ans: string }>({
-			storage: memoryKv(),
-			mode: "read-strict",
-		});
-		await expect(cache.lookup({ q: "nope" })).rejects.toBeInstanceOf(ContentAddressedMissError);
-	});
-
-	it("write mode never returns hits, even when previously stored", async () => {
-		const storage = memoryKv();
-		const writer = contentAddressedStorage<{ id: string }, string>({ storage, mode: "write" });
-		await writer.store({ id: "x" }, "value");
-		expect(await writer.lookup({ id: "x" })).toBeUndefined();
-		// Reading via a separate read handle sees the stored value.
-		const reader = contentAddressedStorage<{ id: string }, string>({ storage, mode: "read" });
-		expect(await reader.lookup({ id: "x" })).toBe("value");
-	});
-
-	it("read mode never stores", async () => {
-		const storage = memoryKv();
-		const reader = contentAddressedStorage<{ id: string }, string>({ storage, mode: "read" });
-		await reader.store({ id: "x" }, "value");
-		expect(await reader.lookup({ id: "x" })).toBeUndefined();
-	});
-
-	it("keyContext extractor lets callers exclude fields from the hash", async () => {
-		const cache = contentAddressedStorage<{ query: string; retries: number }, string>({
-			storage: memoryKv(),
-			// Exclude `retries` from the hash so retries of the same query are cache-hits.
-			keyContext: ({ query }) => ({ query }),
-		});
-		await cache.store({ query: "foo", retries: 0 }, "bar");
-		expect(await cache.lookup({ query: "foo", retries: 5 })).toBe("bar");
-	});
-
-	it("canonicalJson handles circular references via __cycle marker", () => {
-		const a: { self?: unknown } = {};
-		a.self = a;
-		const json = canonicalJson(a);
-		expect(json).toBe('{"self":{"__cycle":true}}');
-	});
-
-	it("canonicalJson sorts object keys for stable hashing", () => {
-		const a = canonicalJson({ b: 1, a: 2, c: 3 });
-		const b = canonicalJson({ a: 2, c: 3, b: 1 });
-		expect(a).toBe(b);
-	});
-});
-
-// ─── sanity — fromAny + onFirstData composition ───────────────────────────
-
-describe("fromAny + onFirstData composition (Wave A Unit 10/11 use case)", () => {
-	it("invokes the side-effect exactly once per adapter Promise bridge", async () => {
-		let recorded = 0;
-		const resp = { text: "ok" };
-		const bridged = fromAny(Promise.resolve(resp));
-		const tapped = onFirstData(bridged, () => {
-			recorded++;
-		});
-		// Activate — the Promise resolves and `tapped` terminates with COMPLETE.
-		const unsub = tapped.subscribe(() => {});
-		await new Promise((r) => setTimeout(r, 5));
-		unsub();
-		// R2.2.7.b (D118, 2026-05-10): re-subscribe to a non-resubscribable
-		// terminated node throws — the stream is permanently over.
-		// Pre-D118 the second subscribe replayed the terminal as a courtesy;
-		// the new semantic makes the contract explicit. The original test
-		// intent ("re-subscribe should NOT re-fire") still holds — rejection
-		// trivially doesn't re-fire — and is now exercised via the throw.
-		expect(() => tapped.subscribe(() => {})).toThrow(/non-resubscribable.*terminated.*R2\.2\.7\.b/);
-		expect(recorded).toBe(1);
-	});
-});
-
-// silences an unused import warning when vi is not referenced above
-void vi;
diff --git a/packages/pure-ts/src/__tests__/extra/storage-wal.test.ts b/packages/pure-ts/src/__tests__/extra/storage-wal.test.ts
deleted file mode 100644
index 01939ad7..00000000
--- a/packages/pure-ts/src/__tests__/extra/storage-wal.test.ts
+++ /dev/null
@@ -1,1233 +0,0 @@
-/**
- * WAL substrate tests (Phase 14.6 — DS-14-storage). Covers `WALFrame`
- * checksums, `BaseStorageTier.listByPrefix` lazy iteration,
- * `attachSnapshotStorage` paired-tier WAL emission, and
- * `Graph.restoreSnapshot({ mode: "diff" })` replay (lifecycle ordering,
- * torn-write tail drop / mid-stream abort, INVALIDATE persistence).
- *
- * @module
- */
-
-import { describe, expect, it, vi } from "vitest";
-
-import { node } from "../../core/node.js";
-import { kvStorage, memoryBackend, memorySnapshot } from "../../extra/storage/tiers.js";
-import {
-	graphWalPrefix,
-	REPLAY_ORDER,
-	RestoreError,
-	StorageError,
-	verifyWalFrameChecksum,
-	WAL_FORMAT_VERSION,
-	type WALFrame,
-	walFrameChecksum,
-	walFrameKey,
-} from "../../extra/storage/wal.js";
-import { Graph } from "../../graph/graph.js";
-
-// ── Helpers ───────────────────────────────────────────────────────────────
-
-/** Wait until `tier.savePending`-style async chains drain. */
-async function settle(): Promise<void> {
-	await new Promise((r) => setTimeout(r, 20));
-}
-
-// ── walFrameChecksum / verifyWalFrameChecksum ─────────────────────────────
-
-describe("walFrameChecksum", () => {
-	it("returns 64 hex chars (SHA-256)", async () => {
-		const frame: Omit<WALFrame, "checksum"> = {
-			t: "c",
-			lifecycle: "data",
-			path: "n",
-			change: {
-				structure: "graph.value",
-				version: 1,
-				t_ns: 1,
-				lifecycle: "data",
-				change: { kind: "node.set", path: "n", value: 1 },
-			},
-			frame_seq: 1,
-			frame_t_ns: 1,
-			format_version: 1,
-		};
-		const sum = await walFrameChecksum(frame);
-		expect(sum).toMatch(/^[0-9a-f]{64}$/);
-	});
-
-	it("is stable across runs for identical input", async () => {
-		const frame: Omit<WALFrame, "checksum"> = {
-			t: "c",
-			lifecycle: "spec",
-			path: "x",
-			change: {
-				structure: "graph.spec",
-				version: 1,
-				t_ns: 42,
-				lifecycle: "spec",
-				change: { kind: "graph.add", nodeId: "x" },
-			},
-			frame_seq: 5,
-			frame_t_ns: 100,
-			format_version: 1,
-		};
-		const a = await walFrameChecksum(frame);
-		const b = await walFrameChecksum(frame);
-		expect(a).toBe(b);
-	});
-
-	it("verifyWalFrameChecksum returns true on a fresh frame and false on tamper", async () => {
-		const body: Omit<WALFrame, "checksum"> = {
-			t: "c",
-			lifecycle: "data",
-			path: "n",
-			change: {
-				structure: "graph.value",
-				version: 1,
-				t_ns: 7,
-				lifecycle: "data",
-				change: { kind: "node.set", path: "n", value: 99 },
-			},
-			frame_seq: 1,
-			frame_t_ns: 7,
-			format_version: 1,
-		};
-		const checksum = await walFrameChecksum(body);
-		const frame: WALFrame = { ...body, checksum };
-		expect(await verifyWalFrameChecksum(frame)).toBe(true);
-
-		// Tamper: bump frame_seq without re-checksumming → must reject.
-		const torn: WALFrame = { ...frame, frame_seq: 999 };
-		expect(await verifyWalFrameChecksum(torn)).toBe(false);
-	});
-
-	it("excludes format_version from the checksum body (codec tag, parity-locked w/ Rust ChecksumBody)", async () => {
-		const body: Omit<WALFrame, "checksum"> = {
-			t: "c",
-			lifecycle: "data",
-			path: "n",
-			change: {
-				structure: "graph.value",
-				version: 1,
-				t_ns: 3,
-				lifecycle: "data",
-				change: { kind: "node.set", path: "n", value: 1 },
-			},
-			frame_seq: 1,
-			frame_t_ns: 3,
-			format_version: WAL_FORMAT_VERSION,
-		};
-		const base = await walFrameChecksum(body);
-		// A codec bump must NOT invalidate a stored checksum — the tag
-		// describes the encoding, not the integrity-protected payload.
-		const bumped = await walFrameChecksum({ ...body, format_version: 7 });
-		expect(bumped).toBe(base);
-		// And a frame whose ONLY drift is format_version still verifies.
-		expect(await verifyWalFrameChecksum({ ...body, format_version: 7, checksum: base })).toBe(true);
-	});
-});
-
-// ── kvStorage.listByPrefix ────────────────────────────────────────────────
-
-describe("kvStorage.listByPrefix (Phase 14.6 / DS-14-storage Q5)", () => {
-	it("yields entries in lex-ASC key order", async () => {
-		const tier = kvStorage<{ n: number }>(memoryBackend());
-		await tier.save("p/00000000000000000003", { n: 3 });
-		await tier.save("p/00000000000000000001", { n: 1 });
-		await tier.save("p/00000000000000000002", { n: 2 });
-		await tier.flush?.();
-
-		const collected: string[] = [];
-		for await (const entry of tier.listByPrefix?.<{ n: number }>("p/") ?? []) {
-			collected.push(entry.key);
-		}
-		expect(collected).toEqual([
-			"p/00000000000000000001",
-			"p/00000000000000000002",
-			"p/00000000000000000003",
-		]);
-	});
-
-	it("filters strictly by literal byte-prefix (no glob)", async () => {
-		const tier = kvStorage<{ n: number }>(memoryBackend());
-		await tier.save("a/1", { n: 1 });
-		await tier.save("ab/2", { n: 2 });
-		await tier.save("b/3", { n: 3 });
-		await tier.flush?.();
-
-		const aKeys: string[] = [];
-		for await (const e of tier.listByPrefix?.("a/") ?? []) aKeys.push(e.key);
-		expect(aKeys).toEqual(["a/1"]);
-	});
-
-	it('throws StorageError("backend-no-list-support") when backend.list is missing', async () => {
-		const noList = {
-			name: "no-list",
-			read() {
-				return undefined;
-			},
-			write() {},
-		};
-		const tier = kvStorage<{ n: number }>(noList);
-		await expect(async () => {
-			for await (const _ of tier.listByPrefix?.("p/") ?? []) {
-				/* drain */
-			}
-		}).rejects.toBeInstanceOf(StorageError);
-	});
-});
-
-// ── walFrameKey ───────────────────────────────────────────────────────────
-
-describe("walFrameKey", () => {
-	it("zero-pads to 20 digits for lex-ASC = numeric ASC", () => {
-		expect(walFrameKey("g/wal", 1)).toBe("g/wal/00000000000000000001");
-		expect(walFrameKey("g/wal", 12345)).toBe("g/wal/00000000000000012345");
-	});
-
-	it("rejects negative or non-integer frame_seq", () => {
-		expect(() => walFrameKey("p", -1)).toThrow(RangeError);
-		expect(() => walFrameKey("p", 1.5)).toThrow(RangeError);
-	});
-});
-
-// ── attachSnapshotStorage paired tier shape ───────────────────────────────
-
-describe("attachSnapshotStorage paired tier shape (Q3 lock B)", () => {
-	it('emits a mode:"full" baseline on first write', async () => {
-		const g = new Graph("g");
-		g.add(node([], { initial: 0, name: "a" }), { name: "a" });
-		const snapTier = memorySnapshot({ name: "g", compactEvery: 10 });
-		const walBackend = memoryBackend();
-		const walTier = kvStorage(walBackend, { name: "g-wal" });
-		const h = g.attachSnapshotStorage([{ snapshot: snapTier, wal: walTier }]);
-		await settle();
-		g.set("a", 1);
-		await settle();
-		const baseline = (await snapTier.load?.()) as { mode: string; seq: number } | undefined;
-		expect(baseline?.mode).toBe("full");
-		expect(baseline?.seq).toBeGreaterThan(0);
-		h.dispose();
-	});
-
-	it("emits WAL frames to walTier between baselines", async () => {
-		const g = new Graph("g");
-		g.add(node([], { initial: 0, name: "a" }), { name: "a" });
-		const snapTier = memorySnapshot({ name: "g", compactEvery: 10 });
-		const walBackend = memoryBackend();
-		const walTier = kvStorage(walBackend, { name: "g-wal" });
-		const h = g.attachSnapshotStorage([{ snapshot: snapTier, wal: walTier }]);
-		await settle();
-
-		// First flush emits a baseline (isFirst=true). Subsequent flushes
-		// should emit WAL frames until compactEvery hits.
-		g.set("a", 1);
-		await settle();
-		g.set("a", 2);
-		await settle();
-		g.set("a", 3);
-		await settle();
-
-		const walKeys: string[] = [];
-		for await (const e of walTier.listByPrefix?.(`${graphWalPrefix("g")}/`) ?? []) {
-			walKeys.push(e.key);
-		}
-		expect(walKeys.length).toBeGreaterThan(0);
-		// All frames must lex-sort to numeric ASC.
-		const sorted = [...walKeys].sort();
-		expect(walKeys).toEqual(sorted);
-		h.dispose();
-	});
-
-	it("when wal is omitted, every flush writes a full baseline (no diff loss)", async () => {
-		const g = new Graph("g");
-		g.add(node([], { initial: 0, name: "a" }), { name: "a" });
-		const saves: unknown[] = [];
-		const snapTier = {
-			name: "test",
-			save(record: unknown) {
-				saves.push(record);
-			},
-			compactEvery: 10,
-		};
-		const h = g.attachSnapshotStorage([{ snapshot: snapTier }]);
-		await settle();
-		g.set("a", 1);
-		await settle();
-		g.set("a", 2);
-		await settle();
-		// Every save is mode:"full" because no walTier captured intermediate state.
-		for (const r of saves) {
-			expect((r as { mode: string }).mode).toBe("full");
-		}
-		expect(saves.length).toBeGreaterThan(0);
-		h.dispose();
-	});
-});
-
-// ── Group-3 Edge #3: destroyAsync awaits in-flight storage saves ──────────
-
-describe("Graph.destroyAsync awaits storage disposers (Group-3 Edge #3)", () => {
-	function gatedSlowTier() {
-		let release!: () => void;
-		const gate = new Promise<void>((r) => {
-			release = r;
-		});
-		let saveCompleted = false;
-		const tier = {
-			name: "slow",
-			compactEvery: 10,
-			async save(_record: unknown) {
-				await gate;
-				saveCompleted = true;
-			},
-			load() {
-				return undefined;
-			},
-		};
-		return { tier, release, isDone: () => saveCompleted };
-	}
-
-	it("destroyAsync() blocks on an in-flight save until it completes", async () => {
-		const { tier, release, isDone } = gatedSlowTier();
-		const g = new Graph("g");
-		g.add(node([], { initial: 0, name: "a" }), { name: "a" });
-		g.attachSnapshotStorage([{ snapshot: tier }]);
-		await settle();
-		g.set("a", 1); // triggers a baseline flush → save() in-flight (gated)
-
-		const destroyP = g.destroyAsync();
-		// destroyAsync must NOT resolve while the save is gated.
-		const raced = await Promise.race([
-			destroyP.then(() => "destroyed" as const),
-			new Promise<"pending">((r) => setTimeout(() => r("pending"), 30)),
-		]);
-		expect(raced).toBe("pending");
-		expect(isDone()).toBe(false);
-
-		release(); // let the save complete
-		await destroyP;
-		expect(isDone()).toBe(true); // destroyAsync awaited it
-		expect(g.destroyed).toBe(true);
-	});
-
-	it("sync destroy() does NOT await the save (fire-and-forget — the bug destroyAsync fixes)", async () => {
-		const { tier, release, isDone } = gatedSlowTier();
-		const g = new Graph("g");
-		g.add(node([], { initial: 0, name: "a" }), { name: "a" });
-		g.attachSnapshotStorage([{ snapshot: tier }]);
-		await settle();
-		g.set("a", 1);
-
-		g.destroy(); // sync — returns immediately, save still gated
-		expect(isDone()).toBe(false);
-		expect(g.destroyed).toBe(true);
-
-		// The abandoned save still runs once released, but destroy() never
-		// waited for it — exactly the durability gap destroyAsync closes.
-		release();
-		await settle();
-		expect(isDone()).toBe(true);
-	});
-});
-
-// ── Graph.restoreSnapshot({ mode: "diff" }) replay ────────────────────────
-
-describe('Graph.restoreSnapshot({ mode: "diff" }) (Q9 lock)', () => {
-	it("replays node.set frames onto a fresh graph", async () => {
-		// Author: produce a baseline + WAL frames.
-		const author = new Graph("g");
-		author.add(node([], { initial: 0, name: "a" }), { name: "a" });
-		const snapTier = memorySnapshot({ name: "g", compactEvery: 100 });
-		const walBackend = memoryBackend();
-		const walTier = kvStorage(walBackend, { name: "g-wal" });
-		const h = author.attachSnapshotStorage([{ snapshot: snapTier, wal: walTier }]);
-		await settle();
-		author.set("a", 7);
-		await settle();
-		author.set("a", 11);
-		await settle();
-		h.dispose();
-
-		// Replayer: reconstruct from baseline + WAL.
-		const replayer = new Graph("g");
-		replayer.add(node([], { initial: 0, name: "a" }), { name: "a" });
-		const result = await replayer.restoreSnapshot({
-			mode: "diff",
-			source: { tier: snapTier, walTier },
-		});
-
-		expect(replayer.node("a").cache).toBe(11);
-		expect(result.replayedFrames).toBeGreaterThan(0);
-		expect(result.skippedFrames).toBe(0);
-		expect(result.finalSeq).toBeGreaterThan(0);
-		// Cross-scope phases all present (frames=0 for spec/ownership when
-		// diff is value-only; that's still a phase entry).
-		const phaseLifecycles = result.phases.map((p) => p.lifecycle);
-		expect(phaseLifecycles).toEqual([...REPLAY_ORDER]);
-	});
-
-	it("lifecycle filter scopes replay to a single scope", async () => {
-		const author = new Graph("g");
-		author.add(node([], { initial: 0, name: "a" }), { name: "a" });
-		const snapTier = memorySnapshot({ name: "g", compactEvery: 100 });
-		const walTier = kvStorage(memoryBackend(), { name: "g-wal" });
-		const h = author.attachSnapshotStorage([{ snapshot: snapTier, wal: walTier }]);
-		await settle();
-		author.set("a", 42);
-		await settle();
-		h.dispose();
-
-		const replayer = new Graph("g");
-		replayer.add(node([], { initial: 0, name: "a" }), { name: "a" });
-		const specOnly = await replayer.restoreSnapshot({
-			mode: "diff",
-			source: { tier: snapTier, walTier },
-			lifecycle: ["spec"],
-		});
-		// Spec-only: data frames are dropped → cache stays at the baseline value (0).
-		expect(replayer.node("a").cache).toBe(0);
-		expect(specOnly.phases.find((p) => p.lifecycle === "data")?.frames).toBe(0);
-	});
-
-	it("production-emitted frames carry format_version = WAL_FORMAT_VERSION", async () => {
-		const author = new Graph("g");
-		author.add(node([], { initial: 0, name: "a" }), { name: "a" });
-		const snapTier = memorySnapshot({ name: "g", compactEvery: 100 });
-		const walTier = kvStorage(memoryBackend(), { name: "g-wal" });
-		const h = author.attachSnapshotStorage([{ snapshot: snapTier, wal: walTier }]);
-		await settle();
-		author.set("a", 1);
-		await settle();
-		author.set("a", 2);
-		await settle();
-		h.dispose();
-
-		let n = 0;
-		for await (const e of walTier.listByPrefix?.<WALFrame>(`${graphWalPrefix("g")}/`) ?? []) {
-			n++;
-			expect(e.value.format_version).toBe(WAL_FORMAT_VERSION);
-			// Tag is genuinely written, not a deserialization default.
-			expect(Object.hasOwn(e.value, "format_version")).toBe(true);
-			// And the persisted checksum still verifies (tag excluded from body).
-			expect(await verifyWalFrameChecksum(e.value)).toBe(true);
-		}
-		expect(n).toBeGreaterThanOrEqual(2);
-	});
-
-	it("targetSeq scopes replay up to a specific frame_seq", async () => {
-		const author = new Graph("g");
-		author.add(node([], { initial: 0, name: "a" }), { name: "a" });
-		const snapTier = memorySnapshot({ name: "g", compactEvery: 100 });
-		const walTier = kvStorage(memoryBackend(), { name: "g-wal" });
-		const h = author.attachSnapshotStorage([{ snapshot: snapTier, wal: walTier }]);
-		await settle();
-		author.set("a", 1);
-		await settle();
-		author.set("a", 2);
-		await settle();
-		author.set("a", 3);
-		await settle();
-		h.dispose();
-
-		// Find the second frame's seq.
-		const seqs: number[] = [];
-		for await (const e of walTier.listByPrefix?.<WALFrame>(`${graphWalPrefix("g")}/`) ?? []) {
-			seqs.push(e.value.frame_seq);
-		}
-		seqs.sort((a, b) => a - b);
-		expect(seqs.length).toBeGreaterThanOrEqual(2);
-
-		const replayer = new Graph("g");
-		replayer.add(node([], { initial: 0, name: "a" }), { name: "a" });
-		const result = await replayer.restoreSnapshot({
-			mode: "diff",
-			source: { tier: snapTier, walTier },
-			targetSeq: seqs[1],
-		});
-		// Replayed only first two value changes → cache should be 2.
-		expect(replayer.node("a").cache).toBe(2);
-		// Strengthened assertion: exactly two frames applied, all in the
-		// data lifecycle (since the diffs were value-only `node.set` frames).
-		expect(result.replayedFrames).toBe(2);
-		expect(result.skippedFrames).toBe(0);
-		expect(result.phases.find((p) => p.lifecycle === "data")?.frames).toBe(2);
-		expect(result.phases.find((p) => p.lifecycle === "spec")?.frames).toBe(0);
-	});
-
-	it("torn write at WAL tail is dropped by default policy", async () => {
-		const author = new Graph("g");
-		author.add(node([], { initial: 0, name: "a" }), { name: "a" });
-		const snapTier = memorySnapshot({ name: "g", compactEvery: 100 });
-		const walBackend = memoryBackend();
-		const walTier = kvStorage<WALFrame>(walBackend, { name: "g-wal" });
-		const h = author.attachSnapshotStorage([{ snapshot: snapTier, wal: walTier }]);
-		await settle();
-		author.set("a", 5);
-		await settle();
-		author.set("a", 6);
-		await settle();
-		h.dispose();
-
-		// Tamper the LAST WAL key (tail): set a frame whose checksum is
-		// stale. We do this by reading, mutating, and re-writing with a
-		// drift in `path` (checksum no longer matches body).
-		const walKeys: string[] = [];
-		for await (const e of walTier.listByPrefix?.<WALFrame>(`${graphWalPrefix("g")}/`) ?? []) {
-			walKeys.push(e.key);
-		}
-		const tailKey = walKeys[walKeys.length - 1] as string;
-		const tailRaw = await walTier.load(tailKey);
-		expect(tailRaw).toBeDefined();
-		const torn = { ...(tailRaw as WALFrame), path: "tampered" };
-		await walTier.save(tailKey, torn);
-		await walTier.flush?.();
-
-		const replayer = new Graph("g");
-		replayer.add(node([], { initial: 0, name: "a" }), { name: "a" });
-		const result = await replayer.restoreSnapshot({
-			mode: "diff",
-			source: { tier: snapTier, walTier },
-		});
-		expect(result.skippedFrames).toBeGreaterThanOrEqual(1);
-		// Earlier frames still applied → cache reflects pre-torn state.
-		expect(replayer.node("a").cache).toBe(5);
-	});
-
-	it('torn write mid-stream aborts with RestoreError("torn-write-mid-stream")', async () => {
-		const author = new Graph("g");
-		author.add(node([], { initial: 0, name: "a" }), { name: "a" });
-		const snapTier = memorySnapshot({ name: "g", compactEvery: 100 });
-		const walTier = kvStorage<WALFrame>(memoryBackend(), { name: "g-wal" });
-		const h = author.attachSnapshotStorage([{ snapshot: snapTier, wal: walTier }]);
-		await settle();
-		author.set("a", 1);
-		await settle();
-		author.set("a", 2);
-		await settle();
-		author.set("a", 3);
-		await settle();
-		h.dispose();
-
-		// Tamper a mid-stream frame.
-		const walKeys: string[] = [];
-		for await (const e of walTier.listByPrefix?.<WALFrame>(`${graphWalPrefix("g")}/`) ?? []) {
-			walKeys.push(e.key);
-		}
-		expect(walKeys.length).toBeGreaterThanOrEqual(2);
-		const midKey = walKeys[Math.floor(walKeys.length / 2)] as string;
-		const midRaw = await walTier.load(midKey);
-		const torn = { ...(midRaw as WALFrame), path: "tampered-mid" };
-		await walTier.save(midKey, torn);
-		await walTier.flush?.();
-
-		const replayer = new Graph("g");
-		replayer.add(node([], { initial: 0, name: "a" }), { name: "a" });
-		await expect(
-			replayer.restoreSnapshot({
-				mode: "diff",
-				source: { tier: snapTier, walTier },
-			}),
-		).rejects.toBeInstanceOf(RestoreError);
-	});
-
-	it("INVALIDATE persists as node.invalidate and replays via graph.invalidate", async () => {
-		const author = new Graph("g");
-		author.add(node([], { initial: 0, name: "a" }), { name: "a" });
-		const snapTier = memorySnapshot({ name: "g", compactEvery: 100 });
-		const walTier = kvStorage<WALFrame>(memoryBackend(), { name: "g-wal" });
-		const h = author.attachSnapshotStorage([{ snapshot: snapTier, wal: walTier }]);
-		await settle();
-		author.set("a", 7);
-		await settle();
-		author.invalidate("a");
-		await settle();
-		h.dispose();
-
-		// Inspect the WAL for an invalidate frame.
-		const kinds: string[] = [];
-		for await (const e of walTier.listByPrefix?.<WALFrame>(`${graphWalPrefix("g")}/`) ?? []) {
-			const inner = (e.value.change as { change: { kind: string } }).change;
-			kinds.push(inner.kind);
-		}
-		expect(kinds).toContain("node.invalidate");
-
-		const replayer = new Graph("g");
-		replayer.add(node([], { initial: 7, name: "a" }), { name: "a" });
-		await replayer.restoreSnapshot({
-			mode: "diff",
-			source: { tier: snapTier, walTier },
-		});
-		// Post-replay, cache should be SENTINEL (undefined) on the replayer.
-		expect(replayer.node("a").cache).toBeUndefined();
-	});
-
-	it("baseline-missing throws when no full baseline is available", async () => {
-		const snapTier = memorySnapshot({ name: "g", compactEvery: 100 });
-		const walTier = kvStorage<WALFrame>(memoryBackend(), { name: "g-wal" });
-		const replayer = new Graph("g");
-		await expect(
-			replayer.restoreSnapshot({
-				mode: "diff",
-				source: { tier: snapTier, walTier },
-			}),
-		).rejects.toBeInstanceOf(RestoreError);
-	});
-
-	it("accepts pre-collected AsyncIterable<WALFrame> source", async () => {
-		const author = new Graph("g");
-		author.add(node([], { initial: 0, name: "a" }), { name: "a" });
-		const snapTier = memorySnapshot({ name: "g", compactEvery: 100 });
-		const walTier = kvStorage<WALFrame>(memoryBackend(), { name: "g-wal" });
-		const h = author.attachSnapshotStorage([{ snapshot: snapTier, wal: walTier }]);
-		await settle();
-		author.set("a", 3);
-		await settle();
-		author.set("a", 4);
-		await settle();
-		h.dispose();
-
-		const collected: WALFrame[] = [];
-		for await (const e of walTier.listByPrefix?.<WALFrame>(`${graphWalPrefix("g")}/`) ?? []) {
-			collected.push(e.value);
-		}
-
-		// Apply pre-collected stream to a graph already at baseline state.
-		const replayer = new Graph("g");
-		replayer.add(node([], { initial: 0, name: "a" }), { name: "a" });
-		const result = await replayer.restoreSnapshot({
-			mode: "diff",
-			source: (async function* () {
-				for (const f of collected) yield f;
-			})(),
-		});
-		expect(replayer.node("a").cache).toBe(4);
-		expect(result.replayedFrames).toBeGreaterThan(0);
-	});
-
-	it("onTornWrite callback overrides default tail/mid policies", async () => {
-		const author = new Graph("g");
-		author.add(node([], { initial: 0, name: "a" }), { name: "a" });
-		const snapTier = memorySnapshot({ name: "g", compactEvery: 100 });
-		const walTier = kvStorage<WALFrame>(memoryBackend(), { name: "g-wal" });
-		const h = author.attachSnapshotStorage([{ snapshot: snapTier, wal: walTier }]);
-		await settle();
-		author.set("a", 1);
-		await settle();
-		author.set("a", 2);
-		await settle();
-		author.set("a", 3);
-		await settle();
-		h.dispose();
-
-		const walKeys: string[] = [];
-		for await (const e of walTier.listByPrefix?.<WALFrame>(`${graphWalPrefix("g")}/`) ?? []) {
-			walKeys.push(e.key);
-		}
-		const midKey = walKeys[Math.floor(walKeys.length / 2)] as string;
-		const midRaw = await walTier.load(midKey);
-		const torn = { ...(midRaw as WALFrame), path: "tampered" };
-		await walTier.save(midKey, torn);
-		await walTier.flush?.();
-
-		const onTornWrite = vi.fn().mockReturnValue("skip" as const);
-		const replayer = new Graph("g");
-		replayer.add(node([], { initial: 0, name: "a" }), { name: "a" });
-		// With override → "skip" mid-stream too.
-		const result = await replayer.restoreSnapshot({
-			mode: "diff",
-			source: { tier: snapTier, walTier },
-			onTornWrite,
-		});
-		expect(onTornWrite).toHaveBeenCalled();
-		expect(result.skippedFrames).toBeGreaterThanOrEqual(1);
-	});
-
-	it("rejects empty lifecycle filter [] (Phase 14.6 fix J)", async () => {
-		const snapTier = memorySnapshot({ name: "g", compactEvery: 100 });
-		const walTier = kvStorage<WALFrame>(memoryBackend(), { name: "g-wal" });
-		const replayer = new Graph("g");
-		await expect(
-			replayer.restoreSnapshot({
-				mode: "diff",
-				source: { tier: snapTier, walTier },
-				lifecycle: [],
-			}),
-		).rejects.toBeInstanceOf(RestoreError);
-	});
-
-	it("rejects targetSeq below baseline.seq (Phase 14.6 fix D)", async () => {
-		const author = new Graph("g");
-		author.add(node([], { initial: 0, name: "a" }), { name: "a" });
-		const snapTier = memorySnapshot({ name: "g", compactEvery: 100 });
-		const walTier = kvStorage<WALFrame>(memoryBackend(), { name: "g-wal" });
-		const h = author.attachSnapshotStorage([{ snapshot: snapTier, wal: walTier }]);
-		await settle();
-		author.set("a", 1);
-		await settle();
-		h.dispose();
-
-		const baseline = (await snapTier.load?.()) as { seq: number };
-		expect(baseline.seq).toBeGreaterThan(0);
-
-		const replayer = new Graph("g");
-		replayer.add(node([], { initial: 0, name: "a" }), { name: "a" });
-		await expect(
-			replayer.restoreSnapshot({
-				mode: "diff",
-				source: { tier: snapTier, walTier },
-				targetSeq: baseline.seq - 1,
-			}),
-		).rejects.toBeInstanceOf(RestoreError);
-	});
-});
-
-// ── Phase 14.6 fix B1 — walTier required for tier-handle source ───────────
-
-describe("restoreSnapshot tier-handle source (Phase 14.6 fix B1)", () => {
-	it("throws RestoreError when walTier is omitted", async () => {
-		const snapTier = memorySnapshot({ name: "g" });
-		const replayer = new Graph("g");
-		await expect(
-			replayer.restoreSnapshot({
-				mode: "diff",
-				// walTier intentionally omitted — pre-fix code defaulted to
-				// `handle.tier` (a SnapshotStorageTier), surfacing as a
-				// "wal-tier-required" lazily during list iteration. Now it
-				// fails fast.
-				source: { tier: snapTier } as unknown as Parameters<
-					typeof replayer.restoreSnapshot
-				>[0]["source"],
-			}),
-		).rejects.toBeInstanceOf(RestoreError);
-	});
-});
-
-// ── Phase 14.6 fix C — walTier validation at attach time ──────────────────
-
-describe("attachSnapshotStorage WAL tier validation (Phase 14.6 fix C)", () => {
-	it("throws TypeError synchronously when wal tier lacks save(key, value)", () => {
-		const g = new Graph("g");
-		g.add(node([], { initial: 0, name: "a" }), { name: "a" });
-		const snapTier = memorySnapshot({ name: "g" });
-		const noSaveWal = {
-			name: "no-save-wal",
-			// Intentionally missing `save` — should fail fast at attach.
-			async *listByPrefix() {
-				/* empty */
-			},
-		} as unknown as Parameters<typeof g.attachSnapshotStorage>[0][number]["wal"];
-		expect(() => g.attachSnapshotStorage([{ snapshot: snapTier, wal: noSaveWal }])).toThrow(
-			TypeError,
-		);
-	});
-});
-
-// ── Phase 14.6 fix A — runFlush concurrency serialization ─────────────────
-
-describe("attachSnapshotStorage runFlush concurrency (Phase 14.6 fix A)", () => {
-	it("serializes back-to-back flushes — no frame_seq collision", async () => {
-		const g = new Graph("g");
-		g.add(node([], { initial: 0, name: "a" }), { name: "a" });
-		const snapTier = memorySnapshot({ name: "g", compactEvery: 100 });
-		const walTier = kvStorage<WALFrame>(memoryBackend(), { name: "g-wal" });
-		const h = g.attachSnapshotStorage([{ snapshot: snapTier, wal: walTier }]);
-		await settle();
-		// Fire many sets back-to-back — synchronously, with no settle in
-		// between — so multiple `runFlush` invocations queue concurrently.
-		for (let i = 1; i <= 10; i++) g.set("a", i);
-		await settle();
-		await settle();
-		h.dispose();
-
-		const seqs: number[] = [];
-		for await (const e of walTier.listByPrefix?.<WALFrame>(`${graphWalPrefix("g")}/`) ?? []) {
-			seqs.push(e.value.frame_seq);
-		}
-		// All frame_seq values must be unique and strictly monotonic.
-		const unique = new Set(seqs);
-		expect(unique.size).toBe(seqs.length);
-		const sorted = [...seqs].sort((a, b) => a - b);
-		expect(seqs).toEqual(sorted);
-	});
-
-	it("re-attach to populated WAL bootstraps frame_seq above prior tail", async () => {
-		const sharedBackend = memoryBackend();
-		const snapBackend = memoryBackend();
-
-		// Session 1: write some frames + dispose.
-		{
-			const g = new Graph("g");
-			g.add(node([], { initial: 0, name: "a" }), { name: "a" });
-			const snapTier = (await import("../../extra/storage/tiers.js")).snapshotStorage<
-				import("../../graph/graph.js").GraphCheckpointRecord
-			>(snapBackend, { name: "g", compactEvery: 100 });
-			const walTier = kvStorage<WALFrame>(sharedBackend, { name: "g-wal" });
-			const h = g.attachSnapshotStorage([{ snapshot: snapTier, wal: walTier }]);
-			await settle();
-			g.set("a", 1);
-			await settle();
-			g.set("a", 2);
-			await settle();
-			h.dispose();
-		}
-
-		// Read the highest frame_seq written by session 1.
-		const walTier1 = kvStorage<WALFrame>(sharedBackend, { name: "g-wal" });
-		const session1Seqs: number[] = [];
-		for await (const e of walTier1.listByPrefix?.<WALFrame>(`${graphWalPrefix("g")}/`) ?? []) {
-			session1Seqs.push(e.value.frame_seq);
-		}
-		const session1Tail = Math.max(...session1Seqs);
-		expect(session1Tail).toBeGreaterThan(0);
-
-		// Session 2: re-attach to the SAME backends, write more frames.
-		// Pre-fix the next baseline would land at seq=1 because bootstrap
-		// hadn't completed before the first flush; post-fix the bootstrap
-		// completes first and seq picks up after `session1Tail`.
-		{
-			const g = new Graph("g");
-			g.add(node([], { initial: 0, name: "a" }), { name: "a" });
-			const snapTier = (await import("../../extra/storage/tiers.js")).snapshotStorage<
-				import("../../graph/graph.js").GraphCheckpointRecord
-			>(snapBackend, { name: "g", compactEvery: 100 });
-			const walTier = kvStorage<WALFrame>(sharedBackend, { name: "g-wal" });
-			const h = g.attachSnapshotStorage([{ snapshot: snapTier, wal: walTier }]);
-			await settle();
-			g.set("a", 3);
-			await settle();
-			h.dispose();
-		}
-
-		// Inspect: every new baseline + frame_seq must exceed session1Tail.
-		const walTier2 = kvStorage<WALFrame>(sharedBackend, { name: "g-wal" });
-		const allSeqs: number[] = [];
-		for await (const e of walTier2.listByPrefix?.<WALFrame>(`${graphWalPrefix("g")}/`) ?? []) {
-			allSeqs.push(e.value.frame_seq);
-		}
-		// Session 2 frames must have frame_seq > session1Tail.
-		const session2Seqs = allSeqs.filter((s) => s > session1Tail);
-		expect(session2Seqs.length).toBeGreaterThan(0);
-		const baselineSnap = (await (
-			await import("../../extra/storage/tiers.js")
-		)
-			.snapshotStorage<import("../../graph/graph.js").GraphCheckpointRecord>(snapBackend, {
-				name: "g",
-			})
-			.load?.()) as { seq: number };
-		expect(baselineSnap.seq).toBeGreaterThan(session1Tail);
-	});
-});
-
-// ── DS-14.5.A delta #7: _topologyVersion + spec-snapshot persistence ───────
-
-describe("Graph._topologyVersion counter (DS-14.5.A Q1)", () => {
-	it("bumps once per `add`", () => {
-		const g = new Graph("g");
-		const v0 = g.topologyVersion;
-		g.add(node([], { initial: 1, name: "a" }), { name: "a" });
-		expect(g.topologyVersion).toBe(v0 + 1);
-		g.add(node([], { initial: 2, name: "b" }), { name: "b" });
-		expect(g.topologyVersion).toBe(v0 + 2);
-	});
-
-	it("bumps on `remove` (node path)", () => {
-		const g = new Graph("g");
-		g.add(node([], { initial: 1, name: "a" }), { name: "a" });
-		const v = g.topologyVersion;
-		g.remove("a");
-		expect(g.topologyVersion).toBe(v + 1);
-	});
-
-	it("bumps on `mount` and on unmount (`remove` mount-cycle path)", () => {
-		const g = new Graph("g");
-		const child = new Graph("c");
-		const vMount = g.topologyVersion;
-		g.mount("c", () => {});
-		expect(g.topologyVersion).toBe(vMount + 1);
-		// Mount a real child then unmount via remove().
-		g.mount("c2", (sub) => {
-			sub.add(node([], { initial: 0, name: "x" }), { name: "x" });
-		});
-		const vUnmount = g.topologyVersion;
-		g.remove("c2");
-		expect(g.topologyVersion).toBe(vUnmount + 1);
-		void child;
-	});
-
-	it("bumps on `tagFactory` (no TopologyEvent emitted, but spec drifts)", () => {
-		const g = new Graph("g");
-		const v = g.topologyVersion;
-		g.tagFactory("myFactory", { k: 1 });
-		expect(g.topologyVersion).toBe(v + 1);
-	});
-
-	it("bumps on `setDeps`/`_setDeps` rewire (via Graph._rewire)", () => {
-		const g = new Graph("g");
-		g.add(node([], { initial: 1, name: "a" }), { name: "a" });
-		g.add(node([], { initial: 2, name: "b" }), { name: "b" });
-		g.add(
-			node<number>([g.node("a")], (data, actions, ctx) => {
-				actions.emit((data[0]?.[0] ?? ctx.prevData[0]) as number);
-			}),
-			{ name: "c" },
-		);
-		const v = g.topologyVersion;
-		g._rewire("c", ["b"], (data, actions, ctx) => {
-			actions.emit((data[0]?.[0] ?? ctx.prevData[0]) as number);
-		});
-		expect(g.topologyVersion).toBe(v + 1);
-	});
-
-	it("bumps on `_addDep` and `_removeDep` (DS-14.5.A F1 — dep-shape drift)", () => {
-		const g = new Graph("g");
-		g.add(node([], { initial: 1, name: "a" }), { name: "a" });
-		g.add(node([], { initial: 2, name: "b" }), { name: "b" });
-		g.add(
-			node<number>([g.node("a")], (data, actions, ctx) => {
-				actions.emit((data[0]?.[0] ?? ctx.prevData[0]) as number);
-			}),
-			{ name: "c" },
-		);
-		const vAdd = g.topologyVersion;
-		g._addDep("c", "b", (data, actions, ctx) => {
-			actions.emit((data[0]?.[0] ?? ctx.prevData[0]) as number);
-		});
-		expect(g.topologyVersion).toBe(vAdd + 1);
-		const vRemove = g.topologyVersion;
-		g._removeDep("c", "b", (data, actions, ctx) => {
-			actions.emit((data[0]?.[0] ?? ctx.prevData[0]) as number);
-		});
-		expect(g.topologyVersion).toBe(vRemove + 1);
-	});
-
-	it("is distinct from value mutations (set does NOT bump)", () => {
-		const g = new Graph("g");
-		g.add(node([], { initial: 1, name: "a" }), { name: "a" });
-		const v = g.topologyVersion;
-		g.set("a", 99);
-		expect(g.topologyVersion).toBe(v);
-	});
-});
-
-describe("attachSnapshotStorage spec snapshot (DS-14.5.A delta #7, Q8)", () => {
-	it("writes a lifecycle:'spec' mode:'full' record when topology drifts", async () => {
-		const g = new Graph("g");
-		const saves: import("../../graph/graph.js").GraphCheckpointRecord[] = [];
-		const tier = {
-			name: "g-spec",
-			save(r: import("../../graph/graph.js").GraphCheckpointRecord) {
-				saves.push(r);
-			},
-		};
-		// paths:[] → no value-event subscriptions; ONLY the topology hook fires.
-		const h = g.attachSnapshotStorage([{ snapshot: tier }], { paths: [] });
-		g.add(node([], { initial: 0, name: "a" }), { name: "a" });
-		await settle();
-		const specRecs = saves.filter((r) => r.lifecycle === "spec");
-		expect(specRecs.length).toBeGreaterThan(0);
-		expect(specRecs[0]!.mode).toBe("full");
-		await h.dispose();
-	});
-
-	it("Q8 squelch: a wave with NO topology change writes no extra spec record", async () => {
-		const g = new Graph("g");
-		g.add(node([], { initial: 0, name: "a" }), { name: "a" });
-		const saves: import("../../graph/graph.js").GraphCheckpointRecord[] = [];
-		const tier = {
-			name: "g-spec",
-			save(r: import("../../graph/graph.js").GraphCheckpointRecord) {
-				saves.push(r);
-			},
-		};
-		const h = g.attachSnapshotStorage([{ snapshot: tier }], { paths: [] });
-		g.add(node([], { initial: 1, name: "b" }), { name: "b" });
-		await settle();
-		const afterFirst = saves.filter((r) => r.lifecycle === "spec").length;
-		expect(afterFirst).toBeGreaterThan(0);
-		// A pure value mutation — no topology bump — must not add a spec record.
-		g.set("a", 42);
-		await settle();
-		const afterValue = saves.filter((r) => r.lifecycle === "spec").length;
-		expect(afterValue).toBe(afterFirst);
-		await h.dispose();
-	});
-
-	it("F6 — restoreSnapshot (default scope) rejects a lifecycle:'spec' baseline as a value baseline", async () => {
-		const author = new Graph("g");
-		const backend = memoryBackend();
-		const { snapshotStorage } = await import("../../extra/storage/tiers.js");
-		const specTier = snapshotStorage<import("../../graph/graph.js").GraphCheckpointRecord>(
-			backend,
-			{ name: "g" },
-		);
-		const h = author.attachSnapshotStorage([{ snapshot: specTier }], { paths: [] });
-		author.add(node([], { initial: 0, name: "alpha" }), { name: "alpha" });
-		await settle();
-		await h.dispose();
-
-		// The tier now holds ONLY a lifecycle:"spec" baseline. A default-scope
-		// (no `lifecycle` filter) diff restore must NOT this.restore() that
-		// topology projection as a value baseline — it fails fast (F6).
-		const replayer = new Graph("g");
-		await expect(
-			replayer.restoreSnapshot({
-				mode: "diff",
-				source: {
-					tier: specTier,
-					walTier: kvStorage(memoryBackend(), { name: "g-wal" }),
-				},
-			}),
-		).rejects.toBeInstanceOf(RestoreError);
-	});
-
-	it("F7 — restoreSnapshot({ lifecycle:['spec'] }) over a VALUE baseline falls through: value baseline applied, spec-filtered frames replayed", async () => {
-		// Author a NORMAL value baseline + data WAL frames (no topology drift
-		// after attach → snapshot tier holds a value, non-spec baseline).
-		const author = new Graph("g");
-		author.add(node([], { initial: 0, name: "a" }), { name: "a" });
-		const snapTier = memorySnapshot({ name: "g", compactEvery: 100 });
-		const walTier = kvStorage<WALFrame>(memoryBackend(), { name: "g-wal" });
-		const h = author.attachSnapshotStorage([{ snapshot: snapTier, wal: walTier }]);
-		await settle();
-		author.set("a", 7);
-		await settle();
-		author.set("a", 11);
-		await settle();
-		await h.dispose();
-
-		// Sanity: the baseline is a value baseline (not lifecycle:"spec"), so
-		// the spec-only fast path must NOT engage — we fall through to the
-		// WAL-diff path which applies the value baseline then filters WAL
-		// frames to the "spec" lifecycle (data frames dropped → 0 frames).
-		const baseline = (await snapTier.load?.()) as { lifecycle?: string };
-		expect(baseline.lifecycle).not.toBe("spec");
-
-		const replayer = new Graph("g");
-		replayer.add(node([], { initial: 0, name: "a" }), { name: "a" });
-		const result = await replayer.restoreSnapshot({
-			mode: "diff",
-			source: { tier: snapTier, walTier },
-			lifecycle: ["spec"],
-		});
-		// Value baseline WAS applied (cache reflects the baseline's captured
-		// value, NOT the latest WAL value — data frames are spec-filtered out).
-		expect(replayer.node("a").cache).toBe(0);
-		// The spec phase ran with zero matching frames (fall-through semantic,
-		// NOT the fast-path `phases:[{lifecycle:"spec",frames:0}]` shape — the
-		// WAL walk produced a per-lifecycle phase set).
-		expect(result.phases.find((p) => p.lifecycle === "data")?.frames).toBe(0);
-		expect(result.replayedFrames).toBe(0);
-	});
-
-	it("spec snapshot round-trips via restoreSnapshot({ lifecycle:['spec'] })", async () => {
-		const author = new Graph("g");
-		const backend = memoryBackend();
-		// Dedicated spec tier — keep value baselines out by using paths:[].
-		const { snapshotStorage } = await import("../../extra/storage/tiers.js");
-		const specTier = snapshotStorage<import("../../graph/graph.js").GraphCheckpointRecord>(
-			backend,
-			{ name: "g" },
-		);
-		const h = author.attachSnapshotStorage([{ snapshot: specTier }], { paths: [] });
-		author.add(node([], { initial: 0, name: "alpha" }), { name: "alpha" });
-		author.add(node([], { initial: 0, name: "beta" }), { name: "beta" });
-		author.tagFactory("authoredGraph", { v: 1 });
-		await settle();
-		await h.dispose(); // dispose drains + reconciles the lone tagFactory bump
-
-		// Round-trip property (DS-14.5.A L1: spec IS code's projection): the
-		// persisted lifecycle:"spec" baseline captures exactly
-		// `describe({detail:"spec"})`.
-		const persisted = (await specTier.load?.()) as
-			| import("../../graph/graph.js").GraphCheckpointRecord
-			| undefined;
-		expect(persisted?.lifecycle).toBe("spec");
-		expect(persisted?.mode).toBe("full");
-		const { expand: _e, ...authorSpec } = author.describe({ detail: "spec" });
-		expect((persisted as { snapshot: unknown }).snapshot).toEqual({
-			...authorSpec,
-			version: 1,
-		});
-
-		// And `restoreSnapshot({ lifecycle:["spec"] })` replays it via the
-		// spec-only fast path (full baseline, no WAL walk).
-		const replayer = new Graph("g");
-		const result = await replayer.restoreSnapshot({
-			mode: "diff",
-			lifecycle: ["spec"],
-			source: {
-				tier: specTier,
-				walTier: kvStorage(memoryBackend(), { name: "g-wal" }),
-			},
-		});
-		expect(result.phases).toEqual([{ lifecycle: "spec", frames: 0 }]);
-		expect(result.replayedFrames).toBe(0);
-	});
-});
-
-// ── B4 / D275 — applyWalFrame graph.mount / graph.unmount arms ────────────
-//
-// Mirrors graphrefly-rs D275 (Rust shipped 2026-05-22). Decompose side
-// already emits graph.mount / graph.unmount frames (graph.ts:6654, :6662);
-// pre-B4 the apply side stubbed both out with a `// deferred` comment so
-// snapshot+WAL round-trips silently dropped subgraph topology. These
-// scenarios assert idempotent apply for top-level + nested paths.
-
-describe("applyWalFrame — graph.mount / graph.unmount (B4 / D275)", () => {
-	async function makeMountFrame(
-		path: string,
-		frame_seq: number,
-		frame_t_ns: number,
-	): Promise<WALFrame> {
-		const body: Omit<WALFrame, "checksum"> = {
-			t: "c",
-			lifecycle: "spec",
-			path,
-			change: {
-				structure: "graph.spec",
-				version: 1,
-				t_ns: frame_t_ns,
-				lifecycle: "spec",
-				change: { kind: "graph.mount", path, subgraphId: path },
-			},
-			frame_seq,
-			frame_t_ns,
-			format_version: 1,
-		};
-		return { ...body, checksum: await walFrameChecksum(body) };
-	}
-
-	async function makeUnmountFrame(
-		path: string,
-		frame_seq: number,
-		frame_t_ns: number,
-	): Promise<WALFrame> {
-		const body: Omit<WALFrame, "checksum"> = {
-			t: "c",
-			lifecycle: "spec",
-			path,
-			change: {
-				structure: "graph.spec",
-				version: 1,
-				t_ns: frame_t_ns,
-				lifecycle: "spec",
-				change: { kind: "graph.unmount", path },
-			},
-			frame_seq,
-			frame_t_ns,
-			format_version: 1,
-		};
-		return { ...body, checksum: await walFrameChecksum(body) };
-	}
-
-	it("graph.mount frame creates the missing top-level subgraph", async () => {
-		const replayer = new Graph("g");
-		const frame = await makeMountFrame("child", 1, 100);
-		const result = await replayer.restoreSnapshot({
-			mode: "diff",
-			source: (async function* () {
-				yield frame;
-			})(),
-		});
-		expect(result.replayedFrames).toBe(1);
-		// `tryResolve("child")` returns undefined for a path ending at a
-		// subgraph (resolve throws — tryResolve catches), so use the public
-		// describe contract: subgraphs list must include the mount.
-		const desc = replayer.describe({ detail: "spec" });
-		expect(desc.subgraphs).toContain("child");
-	});
-
-	it("graph.unmount frame removes the subgraph at the path", async () => {
-		const replayer = new Graph("g");
-		replayer.mount("child");
-		expect(replayer.describe({ detail: "spec" }).subgraphs).toContain("child");
-
-		const frame = await makeUnmountFrame("child", 1, 100);
-		const result = await replayer.restoreSnapshot({
-			mode: "diff",
-			source: (async function* () {
-				yield frame;
-			})(),
-		});
-		expect(result.replayedFrames).toBe(1);
-		expect(replayer.describe({ detail: "spec" }).subgraphs).not.toContain("child");
-	});
-
-	it("graph.mount / graph.unmount are idempotent across repeated frames AND re-apply (B4-QA F6)", async () => {
-		const replayer = new Graph("g");
-		// Mount twice, then unmount twice — both pairs must be safe no-ops on
-		// the redundant invocation (mirrors Rust D275 idempotent skip).
-		const m1 = await makeMountFrame("child", 1, 100);
-		const m2 = await makeMountFrame("child", 2, 200);
-		const u1 = await makeUnmountFrame("child", 3, 300);
-		const u2 = await makeUnmountFrame("child", 4, 400);
-		const frames = [m1, m2, u1, u2];
-		const result1 = await replayer.restoreSnapshot({
-			mode: "diff",
-			source: (async function* () {
-				for (const f of frames) yield f;
-			})(),
-		});
-		expect(result1.replayedFrames).toBe(4);
-		expect(result1.skippedFrames).toBe(0);
-		expect(replayer.describe({ detail: "spec" }).subgraphs).not.toContain("child");
-
-		// B4-QA F6 (2026-05-22): re-source the same 4 frames against the now-
-		// converged graph. End-state must still match — that's the actual
-		// idempotency property Rust D275's `child_names()` guard pins (per-
-		// frame inner work is a no-op on the second pass; outer accounting
-		// still consumes them).
-		const result2 = await replayer.restoreSnapshot({
-			mode: "diff",
-			source: (async function* () {
-				for (const f of frames) yield f;
-			})(),
-		});
-		expect(result2.replayedFrames).toBe(4);
-		expect(result2.skippedFrames).toBe(0);
-		expect(replayer.describe({ detail: "spec" }).subgraphs).not.toContain("child");
-	});
-
-	it("graph.mount skips silently when leaf collides with an existing node (B4-QA F1)", async () => {
-		// B4-QA F1 (2026-05-22): a corrupt or compaction-shifted WAL frame
-		// that mounts `path: "n"` where the live graph has a NODE named `n`
-		// (not a mount) used to throw `node with that name exists` and abort
-		// the whole spec phase. Best-effort charter says skip silently — the
-		// node owns the slot and the frame is a mount that can't replace it.
-		const replayer = new Graph("g");
-		replayer.add(node([], { initial: 1, name: "n" }), { name: "n" });
-		const frame = await makeMountFrame("n", 1, 100);
-		const result = await replayer.restoreSnapshot({
-			mode: "diff",
-			source: (async function* () {
-				yield frame;
-			})(),
-		});
-		// Apply consumed the frame (replayedFrames counts at the outer
-		// dispatch level); inner mount was a no-op.
-		expect(result.replayedFrames).toBe(1);
-		// Node still there; no shadow mount created.
-		expect(replayer.tryResolve("n")?.cache).toBe(1);
-		expect(replayer.describe({ detail: "spec" }).subgraphs).not.toContain("n");
-	});
-
-	it("graph.mount auto-creates missing intermediate mounts for a nested path", async () => {
-		const replayer = new Graph("g");
-		// Only the deep path is emitted (out-of-order or compaction artifact)
-		// — apply must walk down and create the missing parent so the leaf
-		// has a home. Mirrors Rust D275's `graph.child_names()` guard with
-		// the per-segment idempotent skip.
-		const frame = await makeMountFrame("outer::inner", 1, 100);
-		const result = await replayer.restoreSnapshot({
-			mode: "diff",
-			source: (async function* () {
-				yield frame;
-			})(),
-		});
-		expect(result.replayedFrames).toBe(1);
-		const desc = replayer.describe({ detail: "spec" });
-		expect(desc.subgraphs).toContain("outer");
-		expect(desc.subgraphs).toContain("outer::inner");
-	});
-});
diff --git a/packages/pure-ts/src/__tests__/extra/storage.test.ts b/packages/pure-ts/src/__tests__/extra/storage.test.ts
deleted file mode 100644
index 7bd6a5fb..00000000
--- a/packages/pure-ts/src/__tests__/extra/storage.test.ts
+++ /dev/null
@@ -1,680 +0,0 @@
-import { rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { describe, expect, it } from "vitest";
-import { fromIDBRequest, fromIDBTransaction } from "../../../../../src/base/sources/browser/idb.js";
-import { COMPLETE, DATA, ERROR } from "../../core/messages.js";
-import {
-	appendLogStorage,
-	bigintJsonCodec,
-	bigintJsonCodecFor,
-	dictKv,
-	jsonCodec,
-	memoryAppendLog,
-	memoryBackend,
-	memoryKv,
-	memorySnapshot,
-	snapshotStorage,
-} from "../../extra/storage/tiers.js";
-import { indexedDbKv } from "../../extra/storage/tiers-browser.js";
-import { fileKv, sqliteKv } from "../../extra/storage/tiers-node.js";
-import { collect } from "../test-helpers.js";
-
-function tick(ms = 0): Promise<void> {
-	return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-class FakeIDBRequest<T> {
-	onsuccess: ((this: IDBRequest<T>, ev: Event) => unknown) | null = null;
-	onerror: ((this: IDBRequest<T>, ev: Event) => unknown) | null = null;
-	onupgradeneeded: ((this: IDBOpenDBRequest, ev: Event) => unknown) | null = null;
-	result!: T;
-	error: DOMException | null = null;
-
-	succeed(value: T): void {
-		this.result = value;
-		this.onsuccess?.call(this as unknown as IDBRequest<T>, {} as Event);
-	}
-}
-
-function installFakeIndexedDb() {
-	const original = (globalThis as { indexedDB?: IDBFactory }).indexedDB;
-	// Per-key store — `indexedDbKv` uses arbitrary keys unlike old `indexedDbStorage`
-	const stored = new Map<unknown, unknown>();
-	const stores = new Set<string>();
-	const opens: Array<{ close: () => void }> = [];
-	const api = {
-		open(_dbName: string, _version?: number): IDBOpenDBRequest {
-			const req = new FakeIDBRequest<IDBDatabase>();
-			const db = {
-				objectStoreNames: {
-					contains(name: string) {
-						return stores.has(name);
-					},
-				},
-				createObjectStore(name: string) {
-					stores.add(name);
-					return {} as IDBObjectStore;
-				},
-				transaction(_storeName: string, _mode: IDBTransactionMode) {
-					const tx = {
-						oncomplete: null as ((this: IDBTransaction, ev: Event) => unknown) | null,
-						onerror: null as ((this: IDBTransaction, ev: Event) => unknown) | null,
-						onabort: null as ((this: IDBTransaction, ev: Event) => unknown) | null,
-						error: null as DOMException | null,
-						objectStore() {
-							return {
-								put(value: unknown, key: unknown) {
-									const putReq = new FakeIDBRequest<unknown>();
-									queueMicrotask(() => {
-										stored.set(key, value);
-										putReq.succeed(undefined);
-										queueMicrotask(() =>
-											tx.oncomplete?.call(tx as unknown as IDBTransaction, {} as Event),
-										);
-									});
-									return putReq as unknown as IDBRequest<IDBValidKey>;
-								},
-								get(key: unknown) {
-									const getReq = new FakeIDBRequest<unknown>();
-									queueMicrotask(() => {
-										getReq.succeed(stored.get(key));
-										queueMicrotask(() =>
-											tx.oncomplete?.call(tx as unknown as IDBTransaction, {} as Event),
-										);
-									});
-									return getReq as unknown as IDBRequest<unknown>;
-								},
-								delete(key: unknown) {
-									const delReq = new FakeIDBRequest<unknown>();
-									queueMicrotask(() => {
-										stored.delete(key);
-										delReq.succeed(undefined);
-										queueMicrotask(() =>
-											tx.oncomplete?.call(tx as unknown as IDBTransaction, {} as Event),
-										);
-									});
-									return delReq as unknown as IDBRequest<unknown>;
-								},
-								getAllKeys() {
-									const keysReq = new FakeIDBRequest<unknown[]>();
-									queueMicrotask(() => {
-										keysReq.succeed([...stored.keys()]);
-										queueMicrotask(() =>
-											tx.oncomplete?.call(tx as unknown as IDBTransaction, {} as Event),
-										);
-									});
-									return keysReq as unknown as IDBRequest<IDBValidKey[]>;
-								},
-							} as unknown as IDBObjectStore;
-						},
-					};
-					return tx as unknown as IDBTransaction;
-				},
-				close() {
-					/* noop */
-				},
-			} as unknown as IDBDatabase;
-			opens.push(db as unknown as { close: () => void });
-			queueMicrotask(() => {
-				req.result = db;
-				req.onupgradeneeded?.call(req as unknown as IDBOpenDBRequest, {} as Event);
-				req.onsuccess?.call(req as unknown as IDBRequest<IDBDatabase>, {} as Event);
-			});
-			return req as unknown as IDBOpenDBRequest;
-		},
-	};
-	(globalThis as { indexedDB?: IDBFactory }).indexedDB = api as unknown as IDBFactory;
-	return {
-		restore() {
-			(globalThis as { indexedDB?: IDBFactory }).indexedDB = original;
-		},
-		opens,
-	};
-}
-
-describe("storage tier factories (kv)", () => {
-	it("memoryKv round-trips", async () => {
-		const tier = memoryKv();
-		await tier.save("k", { v: 42 });
-		expect(await tier.load("k")).toEqual({ v: 42 });
-		await tier.delete?.("k");
-		expect(await tier.load("k")).toBeUndefined();
-	});
-
-	it("memoryKv isolates via codec (JSON clone)", async () => {
-		const tier = memoryKv<{ v: number }>();
-		const obj = { v: 1 };
-		await tier.save("k", obj);
-		obj.v = 2;
-		expect((await tier.load("k"))?.v).toBe(1);
-	});
-
-	it("memoryKv list returns sorted keys", async () => {
-		const tier = memoryKv();
-		await tier.save("b", 2);
-		await tier.save("a", 1);
-		const keys = await tier.list?.();
-		expect(keys).toEqual(["a", "b"]);
-	});
-
-	it("dictKv uses caller-provided bytes store", async () => {
-		const store: Record<string, Uint8Array> = {};
-		const tier = dictKv<{ hello: string }>(store);
-		await tier.save("app", { hello: "world" });
-		expect(store.app).toBeInstanceOf(Uint8Array);
-		expect(await tier.load("app")).toEqual({ hello: "world" });
-		await tier.delete?.("app");
-		expect(store.app).toBeUndefined();
-	});
-
-	it("fileKv writes atomically", async () => {
-		const dir = join(tmpdir(), `grf-kv-${Date.now()}`);
-		try {
-			const tier = fileKv<{ n: number }>(dir);
-			await tier.save("app", { n: 1 });
-			expect(await tier.load("app")).toEqual({ n: 1 });
-			await tier.delete?.("app");
-			expect(await tier.load("app")).toBeUndefined();
-		} finally {
-			rmSync(dir, { recursive: true, force: true });
-		}
-	});
-
-	it("fileKv sanitizes unsafe key chars", async () => {
-		const dir = join(tmpdir(), `grf-kv-${Date.now()}-sanitize`);
-		try {
-			const tier = fileKv(dir);
-			await tier.save("app/with:slashes", { ok: true });
-			expect(await tier.load("app/with:slashes")).toEqual({ ok: true });
-		} finally {
-			rmSync(dir, { recursive: true, force: true });
-		}
-	});
-
-	it("fileKv round-trips non-ASCII keys via UTF-8 percent escaping", async () => {
-		const dir = join(tmpdir(), `grf-kv-${Date.now()}-utf8`);
-		try {
-			const tier = fileKv(dir);
-			const keys = ["caf\u00e9", "\u20ac100", "\ud83d\udc4b hello"];
-			for (const k of keys) await tier.save(k, { k });
-			for (const k of keys) expect(await tier.load(k)).toEqual({ k });
-			// list() must recover every key we stored, unchanged.
-			const listed = await tier.list?.();
-			expect(Array.isArray(listed) || listed === undefined).toBe(true);
-			expect([...(listed as readonly string[])].sort()).toEqual([...keys].sort());
-			for (const k of keys) await tier.delete?.(k);
-		} finally {
-			rmSync(dir, { recursive: true, force: true });
-		}
-	});
-
-	it("fileKv.list returns [] when directory does not exist", async () => {
-		const dir = join(tmpdir(), `grf-kv-${Date.now()}-nonexistent`);
-		const tier = fileKv(dir);
-		expect(await tier.list?.()).toEqual([]);
-	});
-
-	it("sqliteKv round-trips and closes", async () => {
-		const path = join(tmpdir(), `grf-kv-${Date.now()}.db`);
-		try {
-			const tier = sqliteKv<{ x: number }>(path);
-			await tier.save("g", { x: 99 });
-			expect(await tier.load("g")).toEqual({ x: 99 });
-			tier.close();
-			// double-close is idempotent
-			tier.close();
-		} finally {
-			try {
-				rmSync(path, { force: true });
-			} catch {
-				/* ignore */
-			}
-		}
-	});
-
-	it("load returns undefined on miss", async () => {
-		expect(await memoryKv().load("nope")).toBeUndefined();
-		const store: Record<string, Uint8Array> = {};
-		expect(await dictKv(store).load("nope")).toBeUndefined();
-	});
-});
-
-describe("IndexedDB helpers", () => {
-	it("fromIDBRequest emits DATA then COMPLETE", async () => {
-		const req = new FakeIDBRequest<number>();
-		const { batches, unsub } = collect(fromIDBRequest(req as unknown as IDBRequest<number>));
-		req.succeed(42);
-		await tick(0);
-		const flat = batches.flat();
-		expect(flat.some((m) => m[0] === DATA && m[1] === 42)).toBe(true);
-		expect(flat.some((m) => m[0] === COMPLETE)).toBe(true);
-		unsub();
-	});
-
-	it("fromIDBTransaction emits ERROR on abort", async () => {
-		const tx = {
-			oncomplete: null as ((this: IDBTransaction, ev: Event) => unknown) | null,
-			onerror: null as ((this: IDBTransaction, ev: Event) => unknown) | null,
-			onabort: null as ((this: IDBTransaction, ev: Event) => unknown) | null,
-			error: new DOMException("boom", "AbortError"),
-		} as unknown as IDBTransaction;
-		const { batches, unsub } = collect(fromIDBTransaction(tx));
-		tx.onabort?.call(tx, {} as Event);
-		await tick(0);
-		expect(batches.flat().some((m) => m[0] === ERROR)).toBe(true);
-		unsub();
-	});
-
-	it("indexedDbKv save/load round-trip", async () => {
-		const fake = installFakeIndexedDb();
-		try {
-			const tier = indexedDbKv({ dbName: "t", storeName: "cp" });
-			await tier.save("g", { v: 7 });
-			const loaded = await tier.load("g");
-			// indexedDbKv stores encoded bytes — decode gives back the value
-			expect(loaded).toEqual({ v: 7 });
-		} finally {
-			fake.restore();
-		}
-	});
-
-	it("indexedDbKv delete removes record", async () => {
-		const fake = installFakeIndexedDb();
-		try {
-			const tier = indexedDbKv({ dbName: "t", storeName: "cp" });
-			await tier.save("g", { v: 7 });
-			await tier.delete?.("g");
-			expect(await tier.load("g")).toBeUndefined();
-		} finally {
-			fake.restore();
-		}
-	});
-
-	it("indexedDbKv rejects when indexedDB unavailable", async () => {
-		const original = (globalThis as { indexedDB?: IDBFactory }).indexedDB;
-		(globalThis as { indexedDB?: IDBFactory }).indexedDB = undefined;
-		try {
-			const tier = indexedDbKv({ dbName: "missing", storeName: "missing" });
-			await expect(tier.load("g")).rejects.toThrow(/not available/);
-		} finally {
-			(globalThis as { indexedDB?: IDBFactory }).indexedDB = original;
-		}
-	});
-});
-
-// ── Audit 4 — transaction semantics ───────────────────────────────────
-
-describe("storage tier transaction semantics (Audit 4)", () => {
-	it("snapshotStorage with debounceMs > 0 buffers across waves until flush()", async () => {
-		const backend = memoryBackend();
-		const tier = snapshotStorage<{ name: string; value: number }>(backend, {
-			name: "snap",
-			debounceMs: 10_000,
-		});
-
-		// Three saves in sequence — none should hit the backend yet.
-		tier.save({ name: "snap", value: 1 });
-		tier.save({ name: "snap", value: 2 });
-		tier.save({ name: "snap", value: 3 });
-
-		expect(backend.read("snap")).toBeUndefined();
-
-		// Explicit flush commits the latest pending snapshot only — snapshot
-		// tiers track a single pending record by design.
-		await tier.flush?.();
-		const bytes = backend.read("snap") as Uint8Array;
-		const decoded = JSON.parse(new TextDecoder().decode(bytes));
-		expect(decoded).toEqual({ name: "snap", value: 3 });
-	});
-
-	it("snapshotStorage rollback() discards pending without writing", async () => {
-		const backend = memoryBackend();
-		const tier = snapshotStorage<{ name: string; v: number }>(backend, {
-			name: "snap",
-			debounceMs: 10_000,
-		});
-
-		tier.save({ name: "snap", v: 42 });
-		await tier.rollback?.();
-		// flush() after rollback is a no-op — pending was cleared.
-		await tier.flush?.();
-		expect(backend.read("snap")).toBeUndefined();
-	});
-
-	it("snapshotStorage with debounceMs=0 (sync-through) writes on every save", () => {
-		const backend = memoryBackend();
-		const tier = snapshotStorage<{ name: string; v: number }>(backend, { name: "snap" });
-
-		tier.save({ name: "snap", v: 1 });
-		expect(backend.read("snap")).toBeDefined();
-		const decoded1 = JSON.parse(new TextDecoder().decode(backend.read("snap") as Uint8Array));
-		expect(decoded1.v).toBe(1);
-
-		tier.save({ name: "snap", v: 2 });
-		const decoded2 = JSON.parse(new TextDecoder().decode(backend.read("snap") as Uint8Array));
-		expect(decoded2.v).toBe(2);
-	});
-
-	it("appendLogStorage with debounceMs > 0 buffers entries until flush()", async () => {
-		const backend = memoryBackend();
-		const tier = appendLogStorage<{ id: number }>(backend, {
-			name: "log",
-			debounceMs: 10_000,
-		});
-
-		tier.appendEntries([{ id: 1 }, { id: 2 }]);
-		tier.appendEntries([{ id: 3 }]);
-		expect(backend.read("log")).toBeUndefined();
-
-		await tier.flush?.();
-		const bytes = backend.read("log") as Uint8Array;
-		const decoded = JSON.parse(new TextDecoder().decode(bytes));
-		expect(decoded).toEqual([{ id: 1 }, { id: 2 }, { id: 3 }]);
-	});
-
-	it("appendLogStorage rollback() discards buffered entries", async () => {
-		const backend = memoryBackend();
-		const tier = appendLogStorage<{ id: number }>(backend, {
-			name: "log",
-			debounceMs: 10_000,
-		});
-
-		tier.appendEntries([{ id: 1 }, { id: 2 }]);
-		await tier.rollback?.();
-		await tier.flush?.();
-		expect(backend.read("log")).toBeUndefined();
-	});
-
-	it("appendLogStorage keyOf partitions entries across backend keys", async () => {
-		const backend = memoryBackend();
-		const tier = appendLogStorage<{ topic: string; id: number }>(backend, {
-			keyOf: (e) => e.topic,
-		});
-
-		// Each `appendEntries` triggers an auto-flush (no debounceMs) that
-		// schedules a microtask-chained write on the per-tier serialized chain.
-		// `tier.flush()` alone now drains the full in-flight chain (memo:Re P0
-		// fix 2026-05-16 — flushNow returns the outstanding flushChain when
-		// `pending` is empty), so the per-call awaits are no longer required.
-		tier.appendEntries([{ topic: "orders", id: 1 }]);
-		tier.appendEntries([{ topic: "shipments", id: 10 }]);
-		tier.appendEntries([{ topic: "orders", id: 2 }]);
-		await tier.flush?.();
-
-		const orders = JSON.parse(new TextDecoder().decode(backend.read("orders") as Uint8Array));
-		const shipments = JSON.parse(new TextDecoder().decode(backend.read("shipments") as Uint8Array));
-		expect(orders).toEqual([
-			{ topic: "orders", id: 1 },
-			{ topic: "orders", id: 2 },
-		]);
-		expect(shipments).toEqual([{ topic: "shipments", id: 10 }]);
-	});
-
-	it("multi-tier read: first-tier-wins via tier.load() — caller iterates in order", async () => {
-		const hot = memorySnapshot<{ name: string; value: number }>({ name: "snap" });
-		const cold = memorySnapshot<{ name: string; value: number }>({ name: "snap" });
-
-		// Only the cold tier has the record.
-		await cold.save({ name: "snap", value: 99 });
-
-		const tiers = [hot, cold];
-		// First-hit-wins read pattern (mirrors framework wiring per Audit 4).
-		let found: { name: string; value: number } | undefined;
-		for (const t of tiers) {
-			const v = await t.load?.();
-			if (v !== undefined) {
-				found = v;
-				break;
-			}
-		}
-		expect(found?.value).toBe(99);
-	});
-
-	it("userspace iteration over tiers: per-tier failures are isolated; healthy tiers still persist", async () => {
-		// This test exercises the **userspace** pattern documented in Audit 4
-		// for callers that fan a single write across multiple tiers — NOT the
-		// framework's wiring layer (which iterates tiers internally per
-		// primitive). It pins the documented "best-effort cross-tier
-		// atomicity" caveat: one tier failing does NOT prevent others from
-		// persisting, and the failure surfaces as an exception the caller can
-		// route to `options.onError` or equivalent.
-		const goodTier = memoryAppendLog<{ id: number }>({ name: "good" });
-		const failTier = {
-			name: "bad",
-			appendEntries: () => {
-				throw new Error("disk full");
-			},
-			flush: async () => {},
-			rollback: async () => {},
-		};
-
-		const tiers = [goodTier, failTier];
-		const errors: unknown[] = [];
-		for (const t of tiers) {
-			try {
-				const r = t.appendEntries([{ id: 1 }]);
-				if (r instanceof Promise) await r;
-			} catch (e) {
-				errors.push(e);
-			}
-		}
-
-		expect(errors.length).toBe(1);
-		await goodTier.flush?.();
-		const result = await goodTier.loadEntries?.();
-		expect(result?.entries).toEqual([{ id: 1 }]);
-	});
-
-	it("appendLogStorage.loadEntries honors pageSize + cursor (windowed pagination)", async () => {
-		const backend = memoryBackend();
-		const tier = appendLogStorage<{ id: number }>(backend, { name: "log" });
-		tier.appendEntries([{ id: 1 }, { id: 2 }, { id: 3 }, { id: 4 }, { id: 5 }]);
-		await tier.flush?.();
-
-		// Page 1
-		const p1 = await tier.loadEntries?.({ pageSize: 2 });
-		expect(p1?.entries).toEqual([{ id: 1 }, { id: 2 }]);
-		expect(p1?.cursor).toBeDefined();
-		// Page 2 — resume from the returned cursor
-		const p2 = await tier.loadEntries?.({ pageSize: 2, cursor: p1?.cursor });
-		expect(p2?.entries).toEqual([{ id: 3 }, { id: 4 }]);
-		expect(p2?.cursor).toBeDefined();
-		// Page 3 — last partial page; cursor undefined signals done
-		const p3 = await tier.loadEntries?.({ pageSize: 2, cursor: p2?.cursor });
-		expect(p3?.entries).toEqual([{ id: 5 }]);
-		expect(p3?.cursor).toBeUndefined();
-
-		// Walk the whole log via the cursor protocol — reconstructs the full
-		// stream with no gaps/dups.
-		const walked: { id: number }[] = [];
-		let cur = (await tier.loadEntries?.({ pageSize: 2 })) ?? {
-			entries: [],
-			cursor: undefined,
-		};
-		walked.push(...cur.entries);
-		while (cur.cursor !== undefined) {
-			cur = (await tier.loadEntries?.({ pageSize: 2, cursor: cur.cursor })) ?? {
-				entries: [],
-				cursor: undefined,
-			};
-			walked.push(...cur.entries);
-		}
-		expect(walked).toEqual([{ id: 1 }, { id: 2 }, { id: 3 }, { id: 4 }, { id: 5 }]);
-	});
-
-	it("appendLogStorage.loadEntries back-compat: no opts returns whole log + cursor undefined", async () => {
-		const backend = memoryBackend();
-		const tier = appendLogStorage<{ id: number }>(backend, { name: "log" });
-		tier.appendEntries([{ id: 1 }, { id: 2 }, { id: 3 }]);
-		await tier.flush?.();
-
-		const all = await tier.loadEntries?.();
-		expect(all?.entries).toEqual([{ id: 1 }, { id: 2 }, { id: 3 }]);
-		expect(all?.cursor).toBeUndefined();
-
-		// pageSize larger than the log → one full page, cursor undefined.
-		const big = await tier.loadEntries?.({ pageSize: 100 });
-		expect(big?.entries).toEqual([{ id: 1 }, { id: 2 }, { id: 3 }]);
-		expect(big?.cursor).toBeUndefined();
-
-		// Empty log → empty page, cursor undefined (graceful).
-		const empty = appendLogStorage<{ id: number }>(memoryBackend(), {
-			name: "empty",
-		});
-		const e = await empty.loadEntries?.({ pageSize: 2 });
-		expect(e?.entries).toEqual([]);
-		expect(e?.cursor).toBeUndefined();
-
-		// Cursor past the end → empty page, cursor undefined.
-		const past = await tier.loadEntries?.({
-			pageSize: 2,
-			cursor: { position: 99 } as never,
-		});
-		expect(past?.entries).toEqual([]);
-		expect(past?.cursor).toBeUndefined();
-
-		// /qa-Blind#4: no `pageSize` + a cursor honors `cursor.position`
-		// (forward-only tail). Pin the locked behaviour — pre-change `cursor`
-		// was never returned without `pageSize` so no prior caller observed
-		// the old cursor-ignored shape; this is contract definition, not a
-		// reachable regression.
-		const tail = await tier.loadEntries?.({
-			cursor: { position: 1 } as never,
-		});
-		expect(tail?.entries).toEqual([{ id: 2 }, { id: 3 }]);
-		expect(tail?.cursor).toBeUndefined();
-
-		// /qa-Blind#6: non-integer / Infinity pageSize degrades to the
-		// whole-tail path (no silent float-window slice).
-		for (const bad of [2.5, Number.POSITIVE_INFINITY, Number.NaN]) {
-			const r = await tier.loadEntries?.({ pageSize: bad });
-			expect(r?.entries).toEqual([{ id: 1 }, { id: 2 }, { id: 3 }]);
-			expect(r?.cursor).toBeUndefined();
-		}
-	});
-
-	it("appendLogStorage compactEvery auto-flushes every N writes regardless of debounce", async () => {
-		const backend = memoryBackend();
-		const tier = appendLogStorage<{ id: number }>(backend, {
-			name: "log",
-			debounceMs: 10_000,
-			compactEvery: 2,
-		});
-
-		// Entry 1 — under compactEvery threshold; debounce is 10s so the
-		// backend stays untouched.
-		tier.appendEntries([{ id: 1 }]);
-		expect(backend.read("log")).toBeUndefined();
-
-		// Entry 2 — compactEvery hit → tier auto-flushes. Awaiting the
-		// `appendEntries` return drains the per-tier flush chain. **No
-		// explicit `tier.flush?.()`** — that would mask the auto-flush
-		// behavior under test.
-		await Promise.resolve(tier.appendEntries([{ id: 2 }]));
-
-		const bytes = backend.read("log") as Uint8Array;
-		expect(bytes).toBeDefined();
-		expect(JSON.parse(new TextDecoder().decode(bytes))).toEqual([{ id: 1 }, { id: 2 }]);
-	});
-});
-
-describe("bigintJsonCodec — BigInt-safe persistence (memo:Re P1)", () => {
-	it("plain jsonCodec throws on a bigint field (the consumer pain)", () => {
-		expect(() => jsonCodec.encode({ t_ns: 123n })).toThrow();
-	});
-
-	it("round-trips bigint fields losslessly", () => {
-		const value = {
-			t_ns: 1_700_000_000_000_000_000n,
-			validTo: 42n,
-			payload: "x",
-			n: 7,
-		};
-		const back = bigintJsonCodec.decode(bigintJsonCodec.encode(value));
-		expect(back).toEqual(value);
-		expect(typeof (back as { t_ns: unknown }).t_ns).toBe("bigint");
-		expect(typeof (back as { n: unknown }).n).toBe("number");
-	});
-
-	it("round-trips nested arrays of bigint-carrying fragments (FactStore shape)", () => {
-		const codec =
-			bigintJsonCodecFor<ReadonlyArray<{ id: string; t_ns: bigint; validTo?: bigint }>>();
-		const frags = [
-			{ id: "a", t_ns: 10n },
-			{ id: "b", t_ns: 20n, validTo: 25n },
-		];
-		expect(codec.decode(codec.encode(frags))).toEqual(frags);
-	});
-
-	it("preserves stable key order (order-independent encoding)", () => {
-		const a = bigintJsonCodec.encode({ z: 1n, a: 2n });
-		const b = bigintJsonCodec.encode({ a: 2n, z: 1n });
-		expect(new TextDecoder().decode(a)).toBe(new TextDecoder().decode(b));
-	});
-
-	it("persists a bigint-carrying snapshot through a real tier", async () => {
-		const backend = memoryBackend();
-		type S = { t_ns: bigint; label: string };
-		const tier = snapshotStorage<S>(backend, {
-			codec: bigintJsonCodecFor<S>(),
-		});
-		await tier.save({ t_ns: 999n, label: "frag" });
-		await tier.flush?.();
-		expect(await tier.load?.()).toEqual({ t_ns: 999n, label: "frag" });
-	});
-
-	it("reviver does NOT throw or coerce on a non-decimal $bigint tag (collision/tamper safe)", () => {
-		// Each is a legitimate single-key user object that must round-trip
-		// UNCHANGED — never BigInt("notnum") (throws), BigInt("") (→0n),
-		// BigInt("0x1f") (→31n), BigInt("1e3") (throws).
-		for (const bad of ["notnum", "", "0x1f", "1e3", "  12  ", "+5", "01"]) {
-			const v = { payload: { $bigint: bad } };
-			expect(bigintJsonCodec.decode(bigintJsonCodec.encode(v))).toEqual(v);
-		}
-		// Canonical base-10 (incl. negative / zero) DOES revive.
-		expect(bigintJsonCodec.decode(bigintJsonCodec.encode({ x: -12n }))).toEqual({ x: -12n });
-		expect(bigintJsonCodec.decode(bigintJsonCodec.encode({ x: 0n }))).toEqual({ x: 0n });
-		// A two-key object that merely contains $bigint is left alone.
-		const multi = { $bigint: "5", other: 1 };
-		expect(bigintJsonCodec.decode(bigintJsonCodec.encode(multi))).toEqual(multi);
-	});
-});
-
-describe("appendLogStorage — mode: append | overwrite (memo:Re P1)", () => {
-	const read = (b: ReturnType<typeof memoryBackend>, k: string) =>
-		JSON.parse(new TextDecoder().decode(b.read(k) as Uint8Array));
-
-	it("append (default) accumulates across flushes", async () => {
-		const backend = memoryBackend();
-		const tier = appendLogStorage<number>(backend, { name: "L" });
-		await Promise.resolve(tier.appendEntries([1, 2]));
-		await tier.flush?.();
-		await Promise.resolve(tier.appendEntries([3]));
-		await tier.flush?.();
-		expect(read(backend, "L")).toEqual([1, 2, 3]);
-	});
-
-	it("append: a fresh tier over an existing key continues accumulation", async () => {
-		const backend = memoryBackend();
-		const t1 = appendLogStorage<string>(backend, { name: "L" });
-		await Promise.resolve(t1.appendEntries(["a", "b"]));
-		await t1.flush?.();
-		const t2 = appendLogStorage<string>(backend, { name: "L" });
-		await Promise.resolve(t2.appendEntries(["c"]));
-		await t2.flush?.();
-		expect(read(backend, "L")).toEqual(["a", "b", "c"]);
-	});
-
-	it("overwrite replaces the key per flush (no read-merge, no growth)", async () => {
-		const backend = memoryBackend();
-		const tier = appendLogStorage<number>(backend, { name: "L", mode: "overwrite" });
-		await Promise.resolve(tier.appendEntries([1, 2]));
-		await tier.flush?.();
-		expect(read(backend, "L")).toEqual([1, 2]);
-		await Promise.resolve(tier.appendEntries([9]));
-		await tier.flush?.();
-		// Only the latest flush's entries — prior [1,2] discarded.
-		expect(read(backend, "L")).toEqual([9]);
-	});
-});
diff --git a/packages/pure-ts/src/__tests__/graph/codec.test.ts b/packages/pure-ts/src/__tests__/graph/codec.test.ts
deleted file mode 100644
index 4d7d7bbc..00000000
--- a/packages/pure-ts/src/__tests__/graph/codec.test.ts
+++ /dev/null
@@ -1,329 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { GraphReFlyConfig, registerBuiltins } from "../../core/config.js";
-import { node } from "../../core/node.js";
-
-import {
-	decodeEnvelope,
-	diffForWAL,
-	ENVELOPE_VERSION,
-	encodeEnvelope,
-	Graph,
-	type GraphCodec,
-	JsonCodec,
-	registerBuiltinCodecs,
-	replayWAL,
-	type WALEntry,
-} from "../../graph/index.js";
-
-function freshConfig(): GraphReFlyConfig {
-	const cfg = new GraphReFlyConfig({
-		onMessage: () => undefined,
-		onSubscribe: () => undefined,
-	});
-	registerBuiltins(cfg);
-	return cfg;
-}
-
-describe("GraphCodec — JsonCodec", () => {
-	it("exposes name, version, contentType", () => {
-		expect(JsonCodec.name).toBe("json");
-		expect(JsonCodec.version).toBe(1);
-		expect(JsonCodec.contentType).toBe("application/json");
-	});
-
-	it("round-trips a graph snapshot", () => {
-		const g = new Graph("g");
-		g.add(node([], { initial: 42 }), { name: "a" });
-		const snap = g.snapshot();
-		const bytes = JsonCodec.encode(snap);
-		const decoded = JsonCodec.decode(bytes);
-		expect(decoded).toEqual(snap);
-	});
-
-	it("decode ignores optional codecVersion", () => {
-		const snap = new Graph("x").snapshot();
-		const bytes = JsonCodec.encode(snap);
-		expect(JsonCodec.decode(bytes, 999)).toEqual(snap);
-	});
-});
-
-describe("envelope v1", () => {
-	it("encodeEnvelope / decodeEnvelope round-trip", () => {
-		const cfg = freshConfig();
-		registerBuiltinCodecs(cfg);
-		const payload = new TextEncoder().encode('{"hello":"world"}');
-		const bytes = encodeEnvelope(JsonCodec, payload);
-		expect(bytes[0]).toBe(ENVELOPE_VERSION);
-		const { codec, codecVersion, payload: inner } = decodeEnvelope(bytes, cfg);
-		expect(codec.name).toBe("json");
-		expect(codecVersion).toBe(1);
-		expect(new TextDecoder().decode(inner)).toBe('{"hello":"world"}');
-	});
-
-	it("envelope layout: [env_v=1][name_len][name][codec_v u16 BE][payload]", () => {
-		const payload = new Uint8Array([0xaa, 0xbb]);
-		const bytes = encodeEnvelope(JsonCodec, payload);
-		// env_v
-		expect(bytes[0]).toBe(1);
-		// name_len = 4 ("json")
-		expect(bytes[1]).toBe(4);
-		// name bytes
-		expect(new TextDecoder().decode(bytes.subarray(2, 6))).toBe("json");
-		// codec_v u16 BE = 1 → 0x00, 0x01
-		expect(bytes[6]).toBe(0);
-		expect(bytes[7]).toBe(1);
-		// payload
-		expect(bytes[8]).toBe(0xaa);
-		expect(bytes[9]).toBe(0xbb);
-	});
-
-	it("encodeEnvelope rejects oversized name", () => {
-		const fake: GraphCodec = {
-			name: "x".repeat(256),
-			version: 1,
-			contentType: "test",
-			encode: () => new Uint8Array(),
-			decode: () => ({}) as never,
-		};
-		expect(() => encodeEnvelope(fake, new Uint8Array())).toThrow(/name.*bytes/);
-	});
-
-	it("encodeEnvelope rejects empty name", () => {
-		const fake: GraphCodec = {
-			name: "",
-			version: 1,
-			contentType: "test",
-			encode: () => new Uint8Array(),
-			decode: () => ({}) as never,
-		};
-		expect(() => encodeEnvelope(fake, new Uint8Array())).toThrow(/name.*bytes/);
-	});
-
-	it("encodeEnvelope rejects out-of-range codec version", () => {
-		const fake: GraphCodec = {
-			name: "x",
-			version: 70000,
-			contentType: "test",
-			encode: () => new Uint8Array(),
-			decode: () => ({}) as never,
-		};
-		expect(() => encodeEnvelope(fake, new Uint8Array())).toThrow(/u16 range/);
-	});
-
-	it("decodeEnvelope rejects truncated bytes", () => {
-		const cfg = freshConfig();
-		registerBuiltinCodecs(cfg);
-		expect(() => decodeEnvelope(new Uint8Array([1, 10]), cfg)).toThrow(/truncated|too short/);
-	});
-
-	it("decodeEnvelope rejects unknown envelope version", () => {
-		const cfg = freshConfig();
-		registerBuiltinCodecs(cfg);
-		const bytes = new Uint8Array([99, 1, 65, 0, 1]); // env_v=99
-		expect(() => decodeEnvelope(bytes, cfg)).toThrow(/envelope version/);
-	});
-
-	it("decodeEnvelope rejects unknown codec name", () => {
-		const cfg = freshConfig();
-		// Note: JsonCodec NOT registered on this config.
-		const payload = new Uint8Array();
-		const bytes = encodeEnvelope(JsonCodec, payload);
-		expect(() => decodeEnvelope(bytes, cfg)).toThrow(/codec "json" not registered/);
-	});
-
-	it("preserves codec_v=u16 max", () => {
-		const cfg = freshConfig();
-		const codec: GraphCodec = {
-			name: "max",
-			version: 0xffff,
-			contentType: "test",
-			encode: () => new Uint8Array([1, 2, 3]),
-			decode: (_b) => ({ nodes: {}, edges: [], subgraphs: [], name: "x", version: 1 }),
-		};
-		cfg.registerCodec(codec);
-		const bytes = encodeEnvelope(codec, new Uint8Array([1, 2, 3]));
-		const decoded = decodeEnvelope(bytes, cfg);
-		expect(decoded.codecVersion).toBe(0xffff);
-	});
-});
-
-describe("config codec registry", () => {
-	it("defaultConfig has JsonCodec pre-registered", () => {
-		const g = new Graph("g");
-		expect(g.config.lookupCodec<GraphCodec>("json")).toBe(JsonCodec);
-	});
-
-	it("registerCodec / lookupCodec round-trip", () => {
-		const cfg = freshConfig();
-		const fake: GraphCodec = {
-			name: "fake",
-			version: 2,
-			contentType: "application/fake",
-			encode: () => new Uint8Array(),
-			decode: () => ({}) as never,
-		};
-		cfg.registerCodec(fake);
-		expect(cfg.lookupCodec<GraphCodec>("fake")).toBe(fake);
-		expect(cfg.lookupCodec<GraphCodec>("missing")).toBeUndefined();
-	});
-
-	it("registerCodec throws after freeze", () => {
-		const cfg = freshConfig();
-		registerBuiltinCodecs(cfg);
-		// Read a hook to trigger freeze.
-		void cfg.onMessage;
-		const codec: GraphCodec = {
-			name: "late",
-			version: 1,
-			contentType: "test",
-			encode: () => new Uint8Array(),
-			decode: () => ({}) as never,
-		};
-		expect(() => cfg.registerCodec(codec)).toThrow(/frozen/);
-	});
-
-	it("overwrites registration before freeze", () => {
-		const cfg = freshConfig();
-		const a: GraphCodec = {
-			name: "same",
-			version: 1,
-			contentType: "a",
-			encode: () => new Uint8Array(),
-			decode: () => ({}) as never,
-		};
-		const b: GraphCodec = {
-			name: "same",
-			version: 2,
-			contentType: "b",
-			encode: () => new Uint8Array(),
-			decode: () => ({}) as never,
-		};
-		cfg.registerCodec(a);
-		cfg.registerCodec(b);
-		expect(cfg.lookupCodec<GraphCodec>("same")).toBe(b);
-	});
-});
-
-describe("Graph.snapshot({format}) overloads", () => {
-	it("no arg → GraphPersistSnapshot object", () => {
-		const g = new Graph("g");
-		g.add(node([], { initial: 1 }), { name: "a" });
-		const snap = g.snapshot();
-		expect(typeof snap).toBe("object");
-		expect(snap.name).toBe("g");
-	});
-
-	it('{format: "json-string"} → deterministic JSON string', () => {
-		const g = new Graph("g");
-		g.add(node([], { initial: 7 }), { name: "a" });
-		const str = g.snapshot({ format: "json-string" });
-		expect(typeof str).toBe("string");
-		const reparsed = JSON.parse(str);
-		expect(reparsed.name).toBe("g");
-		expect(reparsed.nodes.a).toBeDefined();
-	});
-
-	it('{format: "bytes", codec: "json"} → Uint8Array with envelope', () => {
-		const g = new Graph("g");
-		g.add(node([], { initial: 42 }), { name: "a" });
-		const bytes = g.snapshot({ format: "bytes", codec: "json" });
-		expect(bytes).toBeInstanceOf(Uint8Array);
-		// Envelope header + "json" + 2 bytes of codec_v = at least 8 bytes
-		expect(bytes.length).toBeGreaterThan(8);
-		expect(bytes[0]).toBe(ENVELOPE_VERSION);
-	});
-
-	it('{format: "bytes"} throws without codec name', () => {
-		const g = new Graph("g");
-		expect(() => g.snapshot({ format: "bytes" } as never)).toThrow(/requires.*codec/);
-	});
-
-	it('{format: "bytes"} throws when codec not registered', () => {
-		const g = new Graph("g");
-		expect(() => g.snapshot({ format: "bytes", codec: "cbor" })).toThrow(/not registered/);
-	});
-
-	it("unknown format throws", () => {
-		const g = new Graph("g");
-		expect(() => g.snapshot({ format: "xml" as never })).toThrow(/unknown format/);
-	});
-});
-
-describe("Graph.decode(bytes)", () => {
-	it("round-trips snapshot bytes via defaultConfig", () => {
-		const g = new Graph("g");
-		g.add(node([], { initial: 99 }), { name: "a" });
-		const bytes = g.snapshot({ format: "bytes", codec: "json" });
-		const snap = Graph.decode(bytes);
-		expect(snap.name).toBe("g");
-		expect(snap.nodes.a).toBeDefined();
-	});
-
-	it("accepts custom config", () => {
-		const cfg = freshConfig();
-		registerBuiltinCodecs(cfg);
-		const g = new Graph("g", { config: cfg });
-		g.add(node([], { initial: 1 }), { name: "a" });
-		const bytes = g.snapshot({ format: "bytes", codec: "json" });
-		const snap = Graph.decode(bytes, { config: cfg });
-		expect(snap.name).toBe("g");
-	});
-
-	it("rejects bytes encoded with codec not on target config", () => {
-		const defaultBytes = new Graph("g").snapshot({ format: "bytes", codec: "json" });
-		const isolated = freshConfig(); // no codecs registered
-		expect(() => Graph.decode(defaultBytes, { config: isolated })).toThrow(/not registered/);
-	});
-});
-
-describe("replayWAL (unaffected by codec changes)", () => {
-	it("replays full+diff chain", () => {
-		const g = new Graph("g");
-		g.add(node([], { initial: 1 }), { name: "a" });
-		const first = g.snapshot();
-		g.set("a", 2);
-		const second = g.snapshot();
-		const entries: WALEntry[] = [
-			{
-				mode: "full",
-				snapshot: first,
-				seq: 1,
-				timestamp_ns: 100,
-				format_version: 1,
-			},
-			{
-				mode: "diff",
-				diff: diffForWAL(first, second),
-				seq: 2,
-				timestamp_ns: 200,
-				format_version: 1,
-			},
-		];
-		const replayed = replayWAL(entries);
-		expect(replayed.nodes.a).toBeDefined();
-	});
-
-	it("reconstructs nodes added between full anchors via nodesAddedFull", () => {
-		// Regression guard for D3: diffs must carry full slices for added
-		// nodes, otherwise replay between compacts loses topology.
-		const g = new Graph("g");
-		g.add(node([], { initial: 1 }), { name: "a" });
-		const first = g.snapshot();
-		g.add(node([], { initial: 42 }), { name: "b" });
-		const second = g.snapshot();
-		const entries: WALEntry[] = [
-			{ mode: "full", snapshot: first, seq: 1, timestamp_ns: 100, format_version: 1 },
-			{
-				mode: "diff",
-				diff: diffForWAL(first, second),
-				seq: 2,
-				timestamp_ns: 200,
-				format_version: 1,
-			},
-		];
-		const replayed = replayWAL(entries);
-		expect(replayed.nodes.a).toBeDefined();
-		expect(replayed.nodes.b).toBeDefined();
-		expect(replayed.nodes.b.value).toBe(42);
-	});
-});
diff --git a/packages/pure-ts/src/__tests__/graph/describe-appendix-b.schema.json b/packages/pure-ts/src/__tests__/graph/describe-appendix-b.schema.json
deleted file mode 100644
index 654df8eb..00000000
--- a/packages/pure-ts/src/__tests__/graph/describe-appendix-b.schema.json
+++ /dev/null
@@ -1,46 +0,0 @@
-{
-	"$schema": "https://json-schema.org/draft/2020-12/schema",
-	"type": "object",
-	"required": ["name", "nodes", "edges", "subgraphs"],
-	"properties": {
-		"name": { "type": "string" },
-		"nodes": {
-			"type": "object",
-			"additionalProperties": {
-				"type": "object",
-				"required": ["type", "status"],
-				"properties": {
-					"type": {
-						"type": "string",
-						"enum": ["state", "derived", "producer", "operator", "effect"]
-					},
-					"status": {
-						"type": "string",
-						"enum": ["disconnected", "dirty", "settled", "resolved", "completed", "errored"]
-					},
-					"value": {},
-					"deps": {
-						"type": "array",
-						"items": { "type": "string" }
-					},
-					"meta": { "type": "object" }
-				}
-			}
-		},
-		"edges": {
-			"type": "array",
-			"items": {
-				"type": "object",
-				"required": ["from", "to"],
-				"properties": {
-					"from": { "type": "string" },
-					"to": { "type": "string" }
-				}
-			}
-		},
-		"subgraphs": {
-			"type": "array",
-			"items": { "type": "string" }
-		}
-	}
-}
diff --git a/packages/pure-ts/src/__tests__/graph/describe-ascii.test.ts b/packages/pure-ts/src/__tests__/graph/describe-ascii.test.ts
deleted file mode 100644
index aa15fd04..00000000
--- a/packages/pure-ts/src/__tests__/graph/describe-ascii.test.ts
+++ /dev/null
@@ -1,442 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { graphSpecToAscii } from "../../../../../src/base/render/index.js";
-import { node } from "../../core/node.js";
-import { Graph } from "../../graph/graph.js";
-
-/**
- * Helper — strip trailing whitespace per line + drop leading / trailing empty
- * lines so our structural asserts don't depend on exact canvas padding.
- */
-function normalize(text: string): string {
-	return text
-		.split("\n")
-		.map((l) => l.replace(/\s+$/u, ""))
-		.join("\n")
-		.replace(/^\n+|\n+$/gu, "");
-}
-
-function allBoxesPresent(output: string, paths: readonly string[]): boolean {
-	return paths.every((p) => output.includes(p));
-}
-
-describe("graphSpecToAscii (extra/render — ex `describe({ format: 'ascii' })`)", () => {
-	it("renders a single node as one box containing its label", () => {
-		const g = new Graph("g");
-		g.add(node([], { name: "a", initial: 1 }), { name: "a" });
-		const out = graphSpecToAscii(g.describe());
-		expect(out).toContain("a");
-		// Default Unicode charset uses box-drawing corners.
-		expect(out).toMatch(/[┌┐└┘]/u);
-	});
-
-	it("LR chain: three nodes arranged left-to-right with rightward arrows", () => {
-		const g = new Graph("g");
-		const a = node([], { name: "a", initial: 1 });
-		const b = node(
-			[a],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as number) + 1);
-			},
-			{ describeKind: "derived", name: "b" },
-		);
-		const c = node(
-			[b],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as number) + 1);
-			},
-			{ describeKind: "derived", name: "c" },
-		);
-		g.add(a, { name: "a" });
-		g.add(b, { name: "b" });
-		g.add(c, { name: "c" });
-		const out = graphSpecToAscii(g.describe(), { direction: "LR" });
-		expect(allBoxesPresent(out, ["a", "b", "c"])).toBe(true);
-		// LR arrow tip points right.
-		expect(out).toContain("▶");
-		// LR boxes share rows — `a` and `b` both appear at the top region.
-		const lines = normalize(out).split("\n");
-		const aLine = lines.findIndex((l) => l.includes("a"));
-		const bLine = lines.findIndex((l) => l.includes("b"));
-		expect(aLine).toBeGreaterThanOrEqual(0);
-		expect(bLine).toBeGreaterThanOrEqual(0);
-		// In LR, a and b should be on roughly the same row (since b is on next layer, not below).
-		expect(Math.abs(aLine - bLine)).toBeLessThanOrEqual(1);
-	});
-
-	it("TD chain: three nodes arranged top-to-bottom with downward arrows", () => {
-		const g = new Graph("g");
-		const a = node([], { name: "a", initial: 1 });
-		const b = node(
-			[a],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as number) + 1);
-			},
-			{ describeKind: "derived", name: "b" },
-		);
-		const c = node(
-			[b],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as number) + 1);
-			},
-			{ describeKind: "derived", name: "c" },
-		);
-		g.add(a, { name: "a" });
-		g.add(b, { name: "b" });
-		g.add(c, { name: "c" });
-		const out = graphSpecToAscii(g.describe(), { direction: "TD" });
-		expect(allBoxesPresent(out, ["a", "b", "c"])).toBe(true);
-		// TD arrow tip points down.
-		expect(out).toContain("▼");
-		// TD: a above b above c — earlier-layer labels appear on earlier lines.
-		const lines = normalize(out).split("\n");
-		const aLine = lines.findIndex((l) => l.includes("a"));
-		const bLine = lines.findIndex((l) => l.includes("b"));
-		const cLine = lines.findIndex((l) => l.includes("c"));
-		expect(aLine).toBeLessThan(bLine);
-		expect(bLine).toBeLessThan(cLine);
-	});
-
-	it("diamond (A→B, A→C, B→D, C→D): 4 boxes, no broken edges", () => {
-		const g = new Graph("g");
-		const a = node([], { name: "a", initial: 1 });
-		const b = node(
-			[a],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as number) + 1);
-			},
-			{ describeKind: "derived", name: "b" },
-		);
-		const c = node(
-			[a],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as number) + 2);
-			},
-			{ describeKind: "derived", name: "c" },
-		);
-		const d = node(
-			[b, c],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as number) + (data[1] as number));
-			},
-			{ describeKind: "derived", name: "d" },
-		);
-		g.add(a, { name: "a" });
-		g.add(b, { name: "b" });
-		g.add(c, { name: "c" });
-		g.add(d, { name: "d" });
-		const out = graphSpecToAscii(g.describe());
-		expect(allBoxesPresent(out, ["a", "b", "c", "d"])).toBe(true);
-		expect(out).toContain("▶");
-		// Every row should stay sane width; no Infinity / NaN leakage.
-		for (const line of out.split("\n")) {
-			expect(line.length).toBeLessThan(400);
-		}
-	});
-
-	it("long edge spanning 3 layers stays connected via virtual-node routing", () => {
-		// Graph: a → b → c → d with an extra edge a → d that skips two layers.
-		// Virtual-node splitting should make a→d flow through the middle
-		// layers cleanly; no stray empty gutter.
-		const g = new Graph("g");
-		const a = node([], { name: "a", initial: 1 });
-		const b = node(
-			[a],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as number) + 1);
-			},
-			{ describeKind: "derived", name: "b" },
-		);
-		const c = node(
-			[b],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as number) + 1);
-			},
-			{ describeKind: "derived", name: "c" },
-		);
-		const d = node(
-			[c, a],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as number) + (data[1] as number));
-			},
-			{ describeKind: "derived", name: "d" },
-		);
-		g.add(a, { name: "a" });
-		g.add(b, { name: "b" });
-		g.add(c, { name: "c" });
-		g.add(d, { name: "d" });
-		const out = graphSpecToAscii(g.describe());
-		expect(allBoxesPresent(out, ["a", "b", "c", "d"])).toBe(true);
-		// One arrow tip per distinct target-node entry point. b, c, d each
-		// receive at least one arrow; edges converging on the same cell
-		// (c→d + a→d through virtuals) share the tip glyph — that's
-		// visually correct.
-		const arrowCount = (out.match(/▶/gu) ?? []).length;
-		expect(arrowCount).toBeGreaterThanOrEqual(3);
-		// Spanning edge's virtuals: the grid must have at least one
-		// intermediate column with a horizontal or corner glyph between
-		// a and d besides the ones rendered around b / c — a rough
-		// "chain is visible" check.
-		expect(out).toMatch(/[─│┌┐└┘┬┴├┤┼]/u);
-	});
-
-	it("asciiCharset: 'ascii' uses plain ASCII glyphs only", () => {
-		const g = new Graph("g");
-		const a = node([], { name: "a", initial: 1 });
-		const b = node(
-			[a],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as number) + 1);
-			},
-			{ describeKind: "derived", name: "b" },
-		);
-		g.add(a, { name: "a" });
-		g.add(b, { name: "b" });
-		const out = graphSpecToAscii(g.describe(), { asciiCharset: "ascii" });
-		// No Unicode box-drawing characters.
-		expect(out).not.toMatch(/[─│┌┐└┘┬┴├┤┼▶▼]/u);
-		// Must have the ASCII equivalents.
-		expect(out).toMatch(/[-|+>]/u);
-	});
-
-	it("maxLabelWidth truncates long labels with an ellipsis", () => {
-		const g = new Graph("g");
-		g.add(node([], { name: "this_is_a_rather_long_path_name", initial: 1 }), {
-			name: "this_is_a_rather_long_path_name",
-		});
-		const out = graphSpecToAscii(g.describe(), { maxLabelWidth: 10 });
-		expect(out).toContain("…");
-		expect(out).not.toContain("this_is_a_rather_long_path_name");
-	});
-
-	it("CJK labels keep box structure aligned (2 cells per wide char)", () => {
-		const g = new Graph("g");
-		g.add(node([], { name: "日本語", initial: 1 }), { name: "日本語" });
-		const out = graphSpecToAscii(g.describe());
-		expect(out).toContain("日本語");
-		// The box borders should be long enough that the top row has at
-		// least 6 horizontal glyphs (3 CJK = 6 cells + 2 borders + 2 padding).
-		const lines = normalize(out).split("\n");
-		const topBorder = lines.find((l) => l.includes("┌"));
-		expect(topBorder).toBeDefined();
-		// Top border should contain the corner + several horizontal runs.
-		expect(topBorder!).toMatch(/┌─+┐/u);
-	});
-
-	it("subgraph-qualified paths render as full labels", () => {
-		const g = new Graph("g");
-		const sub = new Graph("sub");
-		const a = node([], { name: "a", initial: 1 });
-		sub.add(a, { name: "a" });
-		g.mount("sub", sub);
-		const out = graphSpecToAscii(g.describe());
-		expect(out).toContain("sub::a");
-	});
-
-	it("invalid direction throws a clear error", () => {
-		const g = new Graph("g");
-		g.add(node([], { name: "a", initial: 0 }), { name: "a" });
-		expect(() => graphSpecToAscii(g.describe(), { direction: "BT" as unknown as "LR" })).toThrow(
-			/ascii describe supports direction "LR" or "TD"/,
-		);
-	});
-
-	it("logger callback fires with the rendered text before return", () => {
-		const g = new Graph("g");
-		g.add(node([], { name: "a", initial: 1 }), { name: "a" });
-		let captured = "";
-		const out = graphSpecToAscii(g.describe(), {
-			logger: (text) => {
-				captured = text;
-			},
-		});
-		expect(captured).toBe(out);
-		expect(captured).toContain("a");
-	});
-
-	it("node([describe({reactive:true})], fn) yields a live string Node", () => {
-		const g = new Graph("g");
-		g.add(node([], { name: "a", initial: 1 }), { name: "a" });
-		const handle = g.describe({ reactive: true });
-		const ascii = node(
-			[handle.node],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit(graphSpecToAscii(data[0]));
-			},
-			{ describeKind: "derived", name: "live-ascii" },
-		);
-		const unsub = ascii.subscribe(() => {});
-		try {
-			const first = ascii.cache;
-			expect(typeof first).toBe("string");
-			expect(first).toContain("a");
-			// Add a second node — describe recomputes → ascii recomputes.
-			g.add(node([], { name: "b", initial: 2 }), { name: "b" });
-			const second = ascii.cache;
-			expect(typeof second).toBe("string");
-			expect(second).toContain("b");
-		} finally {
-			unsub();
-			handle.dispose();
-		}
-	});
-
-	it("scales to 100-node wide DAG without throwing", () => {
-		const g = new Graph("g");
-		const roots: ReturnType<typeof state>[] = [];
-		for (let i = 0; i < 10; i += 1) {
-			const s = node([], { name: `r${i}`, initial: i });
-			roots.push(s);
-			g.add(s, { name: `r${i}` });
-		}
-		// 3 downstream layers of 30 derived nodes each, randomly wired.
-		let prev = roots;
-		for (let layer = 0; layer < 3; layer += 1) {
-			const next: ReturnType<typeof state>[] = [];
-			for (let i = 0; i < 30; i += 1) {
-				const deps = [
-					prev[(i * 3 + layer) % prev.length]!,
-					prev[(i * 7 + layer + 1) % prev.length]!,
-				];
-				const d = node(
-					deps,
-					(batchData, actions, ctx) => {
-						const data = batchData.map((batch, i) =>
-							batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-						);
-						actions.emit((data[0] as number) + (data[1] as number));
-					},
-					{ describeKind: "derived", name: `L${layer}_n${i}` },
-				);
-				next.push(d as unknown as ReturnType<typeof state>);
-				g.add(d, { name: `L${layer}_n${i}` });
-			}
-			prev = next;
-		}
-		const start = Date.now();
-		const out = graphSpecToAscii(g.describe(), { maxLabelWidth: 10 });
-		const elapsed = Date.now() - start;
-		expect(out.length).toBeGreaterThan(100);
-		// Every registered name should appear in the output. Truncation
-		// preserves the prefix so the unique `L0_n0` / `r0` prefixes stay
-		// visible.
-		for (let i = 0; i < 10; i += 1) expect(out).toContain(`r${i}`);
-		for (let layer = 0; layer < 3; layer += 1) {
-			for (let i = 0; i < 30; i += 1) expect(out).toContain(`L${layer}_n${i}`);
-		}
-		// Loose bound so the test doesn't flake on slow CI.
-		expect(elapsed).toBeLessThan(2000);
-	});
-
-	it("empty graph renders as a valid (possibly empty) string without throwing", () => {
-		const g = new Graph("empty");
-		const out = graphSpecToAscii(g.describe());
-		expect(typeof out).toBe("string");
-	});
-
-	it("malformed snapshot with same-layer or back edges renders best-effort, no crash", () => {
-		// Real GraphReFly graphs are DAGs, so we feed graphSpecToAscii a synthetic
-		// GraphDescribeOutput containing a back-edge to exercise the defensive
-		// drop in `insertVirtualNodes`. We build the smallest possible describe
-		// shape by hand.
-		const fake = {
-			name: "cyclic",
-			nodes: {
-				a: { type: "state", status: "settled", value: 1, deps: [], meta: {} },
-				b: { type: "state", status: "settled", value: 2, deps: ["a"], meta: {} },
-			},
-			// Forward edge + back-edge that would make a cycle. Renderer must
-			// drop the back-edge and render the two boxes.
-			edges: [
-				{ from: "a", to: "b" },
-				{ from: "b", to: "a" },
-			],
-			subgraphs: [],
-		};
-		const out = graphSpecToAscii(fake as never);
-		expect(out).toContain("a");
-		expect(out).toContain("b");
-		// No NaN leaked into the output.
-		expect(out).not.toMatch(/NaN/);
-	});
-
-	it("LR and TD of the same graph contain the same set of labels", () => {
-		const g = new Graph("g");
-		const a = node([], { name: "alpha", initial: 1 });
-		const b = node(
-			[a],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as number) + 1);
-			},
-			{ describeKind: "derived", name: "beta" },
-		);
-		const c = node(
-			[a],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as number) + 2);
-			},
-			{ describeKind: "derived", name: "gamma" },
-		);
-		const d = node(
-			[b, c],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as number) + (data[1] as number));
-			},
-			{ describeKind: "derived", name: "delta" },
-		);
-		g.add(a, { name: "alpha" });
-		g.add(b, { name: "beta" });
-		g.add(c, { name: "gamma" });
-		g.add(d, { name: "delta" });
-		const lr = graphSpecToAscii(g.describe(), { direction: "LR" });
-		const td = graphSpecToAscii(g.describe(), { direction: "TD" });
-		for (const n of ["alpha", "beta", "gamma", "delta"]) {
-			expect(lr).toContain(n);
-			expect(td).toContain(n);
-		}
-	});
-});
diff --git a/packages/pure-ts/src/__tests__/graph/explain-cross-mount.test.ts b/packages/pure-ts/src/__tests__/graph/explain-cross-mount.test.ts
deleted file mode 100644
index 02e0194a..00000000
--- a/packages/pure-ts/src/__tests__/graph/explain-cross-mount.test.ts
+++ /dev/null
@@ -1,202 +0,0 @@
-/**
- * Phase 13.K — Cross-graph `explain()` walk validation regression.
- *
- * Source: `archive/docs/SESSION-multi-agent-gap-analysis.md` G6 + drift suspicion.
- *
- * The static-face / dynamic-interior pitch (the multi-agent layer's
- * differentiator vs LangGraph's imperative supervisor) depends on
- * `Graph.describe({ explain })` walking through `parent.mount(...)`
- * boundaries cleanly. This file pins the cases:
- *
- *  1. Parent → child: `parent.derived` ← `child::node`. Walks one hop down.
- *  2. Child → parent → child: an explicit shared dep at parent level lets
- *     explain trace from one child through the parent into another child.
- *  3. Through `topicBridge`: source-topic `events` → bridge `output` →
- *     `bridge::attach` → target-topic `events`. The bridge → target.events
- *     edge is a soft forward edge declared via `meta.attachTarget` (see
- *     `src/base/meta/attach-edge-meta.ts`). Wave propagation flows via
- *     the imperative `targetTopic.publish(v)` in the attach effect body;
- *     explain consumes the resolved `meta.attachTarget` reverse-pred
- *     index to walk past the hop. Phase 13.K resolution dispatch D
- *     (2026-05-22).
- *
- * Per the locked plan: if any case fails, file the gap before claiming the
- * pitch.
- */
-
-import { describe, expect, it } from "vitest";
-import { topic, topicBridge } from "../../../../../src/utils/messaging/index.js";
-import { node } from "../../core/node.js";
-import { Graph } from "../../graph/graph.js";
-
-// ---------------------------------------------------------------------------
-// Case 1: parent → child (one-hop down)
-// ---------------------------------------------------------------------------
-
-describe("Phase 13.K — cross-mount explain walks (G6 validation)", () => {
-	it("explain walks from a parent.derived dep to its mounted child source", () => {
-		const parent = new Graph("parent");
-		const child = new Graph("child");
-		const x = node<number>([], { name: "x", initial: 1, describeKind: "state" });
-		child.add(x, { name: "x" });
-		parent.mount("child", child);
-
-		// Parent derived depending on the mounted child node by Node ref.
-		const y = parent.derived<number>(
-			"y",
-			[x as import("../../core/node.js").Node<unknown>],
-			(data, ctx) => {
-				const b0 = data[0];
-				const v = (b0 != null && b0.length > 0 ? b0.at(-1) : ctx.prevData[0]) as number;
-				return [v * 2];
-			},
-		);
-		void y;
-
-		const chain = parent.describe({ explain: { from: "child::x", to: "y" } });
-		expect(chain.found).toBe(true);
-		// Two-hop minimum — `from` and `to` are non-trivially connected.
-		expect(chain.steps.length).toBeGreaterThanOrEqual(2);
-		for (const step of chain.steps) {
-			expect(step.path).not.toContain("<anonymous>");
-			expect(step.path).not.toBe("");
-		}
-	});
-
-	// -------------------------------------------------------------------------
-	// Case 2: child A → parent → child B (multi-mount with shared parent dep)
-	// -------------------------------------------------------------------------
-
-	it("explain walks across two mounts via a shared parent-level node", () => {
-		const parent = new Graph("parent");
-		const childA = new Graph("childA");
-		const childB = new Graph("childB");
-
-		const a = node<number>([], { name: "a", initial: 10, describeKind: "state" });
-		childA.add(a, { name: "a" });
-
-		// Parent-level derived that depends on childA.a — visible to childB
-		// when childB constructs a derived against this Node ref.
-		parent.mount("childA", childA);
-		const shared = parent.derived<number>(
-			"shared",
-			[a as import("../../core/node.js").Node<unknown>],
-			(data, ctx) => {
-				const b0 = data[0];
-				const v = (b0 != null && b0.length > 0 ? b0.at(-1) : ctx.prevData[0]) as number;
-				return [v + 100];
-			},
-		);
-
-		// childB has a derived against `shared` via Node ref.
-		const bDerived = childB.derived<number>(
-			"b",
-			[shared as import("../../core/node.js").Node<unknown>],
-			(data, ctx) => {
-				const b0 = data[0];
-				const v = (b0 != null && b0.length > 0 ? b0.at(-1) : ctx.prevData[0]) as number;
-				return [v * 3];
-			},
-		);
-		void bDerived;
-		parent.mount("childB", childB);
-
-		// Walk from childA::a all the way to childB::b.
-		const chain = parent.describe({
-			explain: { from: "childA::a", to: "childB::b" },
-		});
-		expect(chain.found).toBe(true);
-		// Path: childA::a → shared → childB::b — three steps minimum.
-		expect(chain.steps.length).toBeGreaterThanOrEqual(3);
-		// Middle step is the shared parent node.
-		expect(chain.steps.some((s) => s.path === "shared")).toBe(true);
-		for (const step of chain.steps) {
-			expect(step.path).not.toContain("<anonymous>");
-		}
-	});
-
-	// -------------------------------------------------------------------------
-	// Case 3: topicBridge end-to-end via soft forward edge (Phase 13.K
-	//   resolution, dispatch D). The bridge now declares an `attach` effect
-	//   mount whose `meta.attachTarget` points at `dst::events`; describe
-	//   resolves the Node ref to a path string, and explain consumes the
-	//   resulting reverse-pred index as a "soft forward edge" so the BFS
-	//   walks past the imperative `targetTopic.publish(v)` hop. Wave
-	//   propagation is unchanged — the soft edge is an explainability
-	//   concern only. See `src/base/meta/attach-edge-meta.ts`.
-	// -------------------------------------------------------------------------
-
-	it("explain walks topicBridge.output → bridge.attach → dst.events via soft forward edge", () => {
-		const parent = new Graph("parent");
-		const src = topic<number>("src");
-		const dst = topic<number>("dst");
-		parent.mount("src", src);
-		parent.mount("dst", dst);
-		const bridge = topicBridge<number>("bridge", src, dst);
-		parent.mount("bridge", bridge);
-
-		// Declared edges still walk: src::events → bridge::subscription::
-		// available → bridge::output.
-		const insideBridge = parent.describe({
-			explain: { from: "src::events", to: "bridge::output" },
-		});
-		expect(insideBridge.found).toBe(true);
-
-		// End-to-end walk now succeeds: src::events → … → bridge::output →
-		// bridge::attach → dst::events. The bridge::attach → dst::events
-		// hop is a soft forward edge (no declared dep — bridge::attach's
-		// `meta.attachTarget` resolved to "dst::events" at describe time).
-		const endToEnd = parent.describe({
-			explain: { from: "src::events", to: "dst::events" },
-		});
-		expect(endToEnd.found).toBe(true);
-		const paths = endToEnd.steps.map((s) => s.path);
-		expect(paths).toContain("bridge::output");
-		expect(paths).toContain("bridge::attach");
-		expect(paths[0]).toBe("src::events");
-		expect(paths[paths.length - 1]).toBe("dst::events");
-
-		// The soft-edge marker lands on `bridge::attach` — that step's
-		// OUTGOING edge to `dst::events` is the attach-meta hop, NOT a
-		// declared dep, so `via_attach_edge: true` AND `dep_index` is
-		// absent.
-		const attachStep = endToEnd.steps.find((s) => s.path === "bridge::attach")!;
-		expect(attachStep).toBeDefined();
-		expect(attachStep.via_attach_edge).toBe(true);
-		expect(attachStep.dep_index).toBeUndefined();
-
-		// Declared-dep hops do NOT get the marker — sanity that we didn't
-		// over-mark every step.
-		const outputStep = endToEnd.steps.find((s) => s.path === "bridge::output")!;
-		expect(outputStep.via_attach_edge).toBeUndefined();
-
-		// Pretty-print renders the soft hop with a distinct arrow + suffix
-		// so `console.log(chain.text)` makes the wave-untraversable hop
-		// visible (not just present in the structured `steps[]`).
-		expect(endToEnd.text).toMatch(/↝ dst::events.*\(via attach-edge\)/);
-		// Declared-dep hops use the standard `↓` arrow and have no suffix.
-		expect(endToEnd.text).toMatch(/↓ bridge::output/);
-	});
-});
-
-// ---------------------------------------------------------------------------
-// Sanity: explain rejects from/to that don't exist in the snapshot
-// ---------------------------------------------------------------------------
-
-describe("Phase 13.K — explain failure modes (sanity)", () => {
-	it("returns no-such-from when `from` is not in the snapshot", () => {
-		const g = new Graph("parent");
-		g.add(node<number>([], { name: "x", initial: 1 }), { name: "x" });
-		const chain = g.describe({ explain: { from: "ghost", to: "x" } });
-		expect(chain.found).toBe(false);
-		expect(chain.reason).toBe("no-such-from");
-	});
-
-	it("returns no-such-to when `to` is not in the snapshot", () => {
-		const g = new Graph("parent");
-		g.add(node<number>([], { name: "x", initial: 1 }), { name: "x" });
-		const chain = g.describe({ explain: { from: "x", to: "ghost" } });
-		expect(chain.found).toBe(false);
-		expect(chain.reason).toBe("no-such-to");
-	});
-});
diff --git a/packages/pure-ts/src/__tests__/graph/explain.test.ts b/packages/pure-ts/src/__tests__/graph/explain.test.ts
deleted file mode 100644
index 09097c57..00000000
--- a/packages/pure-ts/src/__tests__/graph/explain.test.ts
+++ /dev/null
@@ -1,429 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { node } from "../../core/node.js";
-
-import { explainPath, Graph } from "../../graph/index.js";
-
-describe("explainPath (roadmap §9.2)", () => {
-	it("single-hop: state → derived returns 2-step chain", () => {
-		const g = new Graph("g");
-		const a = node([], { name: "a", initial: 1 });
-		const b = node(
-			[a],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as number) * 2);
-			},
-			{ describeKind: "derived", name: "b" },
-		);
-		g.add(a, { name: "a" });
-		g.add(b, { name: "b" });
-		// Activate so derived computes.
-		g.observe("b").subscribe(() => {});
-
-		const chain = g.describe({ explain: { from: "a", to: "b" } });
-		expect(chain.found).toBe(true);
-		expect(chain.reason).toBe("ok");
-		expect(chain.steps.map((s) => s.path)).toEqual(["a", "b"]);
-		expect(chain.steps[0]?.value).toBe(1);
-		expect(chain.steps[1]?.value).toBe(2);
-		expect(chain.steps[0]?.dep_index).toBe(0);
-	});
-
-	it("multi-hop diamond returns shortest path", () => {
-		// a → b, a → c, d depends on [b, c]
-		const g = new Graph("diamond");
-		const a = node([], { name: "a", initial: 1 });
-		const b = node(
-			[a],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as number) + 1);
-			},
-			{ describeKind: "derived", name: "b" },
-		);
-		const c = node(
-			[a],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as number) + 10);
-			},
-			{ describeKind: "derived", name: "c" },
-		);
-		const d = node(
-			[b, c],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as number) + (data[1] as number));
-			},
-			{ describeKind: "derived", name: "d" },
-		);
-		g.add(a, { name: "a" });
-		g.add(b, { name: "b" });
-		g.add(c, { name: "c" });
-		g.add(d, { name: "d" });
-		g.observe("d").subscribe(() => {});
-
-		const chain = g.describe({ explain: { from: "a", to: "d" } });
-		expect(chain.found).toBe(true);
-		// BFS finds shortest: a → b → d OR a → c → d (both 3 steps).
-		expect(chain.steps).toHaveLength(3);
-		expect(chain.steps[0]?.path).toBe("a");
-		expect(chain.steps[2]?.path).toBe("d");
-		expect(["b", "c"]).toContain(chain.steps[1]?.path);
-	});
-
-	it("returns no-path when nodes are disconnected", () => {
-		const g = new Graph("g");
-		const a = node([], { name: "a", initial: 1 });
-		const z = node([], { name: "z", initial: "z" });
-		g.add(a, { name: "a" });
-		g.add(z, { name: "z" });
-
-		const chain = g.describe({ explain: { from: "a", to: "z" } });
-		expect(chain.found).toBe(false);
-		expect(chain.reason).toBe("no-path");
-		expect(chain.steps).toEqual([]);
-		expect(chain.text).toMatch(/no path/);
-	});
-
-	it("returns no-such-from / no-such-to for unknown nodes", () => {
-		const g = new Graph("g");
-		g.add(node([], { name: "a", initial: 1 }), { name: "a" });
-
-		expect(g.describe({ explain: { from: "missing", to: "a" } }).reason).toBe("no-such-from");
-		expect(g.describe({ explain: { from: "a", to: "missing" } }).reason).toBe("no-such-to");
-	});
-
-	it("from === to returns single-step chain", () => {
-		const g = new Graph("g");
-		g.add(node([], { name: "a", initial: 42 }), { name: "a" });
-		const chain = g.describe({ explain: { from: "a", to: "a" } });
-		expect(chain.found).toBe(true);
-		expect(chain.steps).toHaveLength(1);
-		expect(chain.steps[0]?.path).toBe("a");
-	});
-
-	it("respects maxDepth and reports max-depth-exceeded when truncated", () => {
-		// chain: a → b → c → d
-		const g = new Graph("g");
-		const a = node([], { name: "a", initial: 1 });
-		const b = node(
-			[a],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit(data[0]);
-			},
-			{ describeKind: "derived", name: "b" },
-		);
-		const c = node(
-			[b],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit(data[0]);
-			},
-			{ describeKind: "derived", name: "c" },
-		);
-		const d = node(
-			[c],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit(data[0]);
-			},
-			{ describeKind: "derived", name: "d" },
-		);
-		g.add(a, { name: "a" });
-		g.add(b, { name: "b" });
-		g.add(c, { name: "c" });
-		g.add(d, { name: "d" });
-		g.observe("d").subscribe(() => {});
-
-		const ok = g.describe({ explain: { from: "a", to: "d" } });
-		expect(ok.found).toBe(true);
-		expect(ok.steps).toHaveLength(4);
-
-		const trunc = g.describe({ explain: { from: "a", to: "d", maxDepth: 2 } });
-		expect(trunc.found).toBe(false);
-		expect(trunc.reason).toBe("max-depth-exceeded");
-	});
-
-	it("attaches graph.trace() reason annotations to steps", () => {
-		const g = new Graph("g");
-		const a = node([], { name: "a", initial: 1 });
-		const b = node(
-			[a],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as number) + 1);
-			},
-			{ describeKind: "derived", name: "b" },
-		);
-		g.add(a, { name: "a" });
-		g.add(b, { name: "b" });
-		g.observe("b").subscribe(() => {});
-
-		g.trace("b", "doubled because pricing rule R7");
-		const chain = g.describe({ explain: { from: "a", to: "b" } });
-		expect(chain.steps[1]?.annotation).toBe("doubled because pricing rule R7");
-		expect(chain.text).toMatch(/annotation: doubled because/);
-	});
-
-	it("standalone explainPath works on a hand-built describe snapshot", () => {
-		const described = {
-			name: "synthetic",
-			nodes: {
-				x: { type: "state" as const, deps: [], value: 1 },
-				y: { type: "derived" as const, deps: ["x"], value: 2 },
-			},
-			edges: [],
-			subgraphs: [],
-		};
-		const chain = explainPath(described, "x", "y");
-		expect(chain.found).toBe(true);
-		expect(chain.steps).toHaveLength(2);
-		expect(chain.steps[0]?.dep_index).toBe(0);
-		const json = chain.toJSON();
-		expect(json.found).toBe(true);
-		expect(json.steps).toHaveLength(2);
-	});
-
-	it("includes lastMutation actor when guarded writes occurred", () => {
-		const g = new Graph("g");
-		const a = node<number>([], {
-			name: "a",
-			guard: () => true, // permissive — we just want the lastMutation populated
-			initial: 0,
-		});
-		g.add(a, { name: "a" });
-		g.set("a", 5, { actor: { type: "llm", id: "agent-7" } });
-		const chain = g.describe({ explain: { from: "a", to: "a" } });
-		expect(chain.steps[0]?.lastMutation?.actor.type).toBe("llm");
-		expect(chain.steps[0]?.lastMutation?.actor.id).toBe("agent-7");
-	});
-
-	it("includes lastMutation for unguarded nodes when actor is provided", () => {
-		// QA fix A1: actor attribution no longer requires a guard.
-		const g = new Graph("g");
-		g.add(node<number>([], { name: "a", initial: 0 }), { name: "a" }); // no guard
-		g.set("a", 9, { actor: { type: "human", id: "alice" } });
-		const chain = g.describe({ explain: { from: "a", to: "a" } });
-		expect(chain.steps[0]?.lastMutation?.actor.id).toBe("alice");
-	});
-
-	it("findCycle: returns shortest cycle when from === to and a cycle exists", () => {
-		// a → b → a (feedback)
-		const g = new Graph("g");
-		const a = node([], { name: "a", initial: 1 });
-		const b = node([], { name: "b", initial: 2 });
-		g.add(a, { name: "a" });
-		g.add(b, { name: "b" });
-		// Synthesize cycle topology via raw describe (the standalone explainPath
-		// works on any GraphDescribeOutput, including hand-built cycles).
-		const described = {
-			name: "g",
-			nodes: {
-				a: { type: "state" as const, deps: ["b"], value: 1 },
-				b: { type: "state" as const, deps: ["a"], value: 2 },
-			},
-			edges: [],
-			subgraphs: [],
-		};
-		const chain = explainPath(described, "a", "a", { findCycle: true });
-		expect(chain.found).toBe(true);
-		expect(chain.steps).toHaveLength(3);
-		expect(chain.steps.map((s) => s.path)).toEqual(["a", "b", "a"]);
-	});
-
-	it("findCycle: detects direct self-loop (a depends on a)", () => {
-		const described = {
-			name: "g",
-			nodes: {
-				a: { type: "derived" as const, deps: ["a"], value: 0 },
-			},
-			edges: [],
-			subgraphs: [],
-		};
-		const chain = explainPath(described, "a", "a", { findCycle: true });
-		expect(chain.found).toBe(true);
-		expect(chain.steps).toHaveLength(2);
-		expect(chain.steps[0]?.dep_index).toBe(0);
-	});
-
-	it("findCycle: falls back to trivial single-step when no cycle exists", () => {
-		const described = {
-			name: "g",
-			nodes: {
-				a: { type: "state" as const, deps: [], value: 0 },
-			},
-			edges: [],
-			subgraphs: [],
-		};
-		const chain = explainPath(described, "a", "a", { findCycle: true });
-		expect(chain.found).toBe(true);
-		expect(chain.steps).toHaveLength(1);
-	});
-
-	it("dep_indices preserves multi-edge slot info", () => {
-		// d depends on [a, a] — same node twice
-		const described = {
-			name: "g",
-			nodes: {
-				a: { type: "state" as const, deps: [], value: 1 },
-				d: { type: "derived" as const, deps: ["a", "a"], value: 2 },
-			},
-			edges: [],
-			subgraphs: [],
-		};
-		const chain = explainPath(described, "a", "d");
-		expect(chain.found).toBe(true);
-		expect(chain.steps).toHaveLength(2);
-		expect(chain.steps[0]?.dep_index).toBe(0);
-		expect(chain.steps[0]?.dep_indices).toEqual([0, 1]);
-	});
-
-	it("walks transitively through factory-internal nodes that weren't graph.add-ed", () => {
-		// Shape mirrors `promptNode` — a factory adds the terminal output to
-		// the graph but not the intermediate `derived` it used to build its
-		// input. Before the transitive-deps fix, describe emitted a dangling
-		// dep pointer (e.g. `out.deps = ["intermediate"]` with no entry under
-		// `intermediate`), so explainPath's BFS had nowhere to walk from
-		// `out`. Post-fix the intermediate is surfaced under its meta.name and
-		// the chain completes.
-		const g = new Graph("factory-internals");
-		const src = node([], { name: "src", initial: 1 });
-		// Intermediate is NOT graph.add-ed — simulates promptNode's internal
-		// `brief::messages` derived helper.
-		const intermediate = node(
-			[src],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as number) * 2);
-			},
-			{ describeKind: "derived", name: "prompt::messages" },
-		);
-		const out = node(
-			[intermediate],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as number) + 100);
-			},
-			{ describeKind: "derived", name: "out" },
-		);
-		g.add(src, { name: "src" });
-		g.add(out, { name: "out" });
-		// Activate so every node computes.
-		g.observe("out").subscribe(() => {});
-
-		const d = g.describe({ detail: "standard" });
-		// All three nodes present in describe — no dangling pointer.
-		expect(Object.keys(d.nodes).sort()).toEqual(["out", "prompt::messages", "src"]);
-		// Edges derived from _deps cover every hop, including through the
-		// un-add-ed intermediate.
-		const edgeSet = new Set(d.edges.map((e) => `${e.from}→${e.to}`));
-		expect(edgeSet.has("src→prompt::messages")).toBe(true);
-		expect(edgeSet.has("prompt::messages→out")).toBe(true);
-
-		const chain = g.describe({ explain: { from: "src", to: "out" } });
-		expect(chain.found).toBe(true);
-		expect(chain.reason).toBe("ok");
-		expect(chain.steps.map((s) => s.path)).toEqual(["src", "prompt::messages", "out"]);
-		expect(chain.steps[0]?.value).toBe(1);
-		expect(chain.steps[1]?.value).toBe(2);
-		expect(chain.steps[2]?.value).toBe(102);
-	});
-
-	it("deduplicates orphan-dep paths when two internals share a meta.name", () => {
-		// Two factory-internal derived nodes both named "internal" — the
-		// describe walk must not collapse them. Second one gets "#2" suffix.
-		const g = new Graph("dup-internals");
-		const a = node([], { name: "a", initial: 1 });
-		const b = node([], { name: "b", initial: 10 });
-		const internalA = node(
-			[a],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as number) + 1);
-			},
-			{ describeKind: "derived", name: "internal" },
-		);
-		const internalB = node(
-			[b],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as number) + 1);
-			},
-			{ describeKind: "derived", name: "internal" },
-		);
-		// Neither internal is graph.add-ed; both are upstream of their own
-		// registered terminal.
-		const outA = node(
-			[internalA],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as number) * 10);
-			},
-			{ describeKind: "derived", name: "outA" },
-		);
-		const outB = node(
-			[internalB],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as number) * 10);
-			},
-			{ describeKind: "derived", name: "outB" },
-		);
-		g.add(a, { name: "a" });
-		g.add(b, { name: "b" });
-		g.add(outA, { name: "outA" });
-		g.add(outB, { name: "outB" });
-		g.observe("outA").subscribe(() => {});
-		g.observe("outB").subscribe(() => {});
-
-		const d = g.describe({ detail: "standard" });
-		const keys = Object.keys(d.nodes).sort();
-		expect(keys).toContain("internal");
-		expect(keys).toContain("internal#2");
-		// Both terminals walk back to their own state via the suffixed pair.
-		const chainA = g.describe({ explain: { from: "a", to: "outA" } });
-		const chainB = g.describe({ explain: { from: "b", to: "outB" } });
-		expect(chainA.found).toBe(true);
-		expect(chainB.found).toBe(true);
-		expect(chainA.steps.map((s) => s.path)).toEqual([
-			"a",
-			expect.stringMatching(/^internal/),
-			"outA",
-		]);
-		expect(chainB.steps.map((s) => s.path)).toEqual([
-			"b",
-			expect.stringMatching(/^internal/),
-			"outB",
-		]);
-	});
-});
diff --git a/packages/pure-ts/src/__tests__/graph/graph.test.ts b/packages/pure-ts/src/__tests__/graph/graph.test.ts
deleted file mode 100644
index 9382e84c..00000000
--- a/packages/pure-ts/src/__tests__/graph/graph.test.ts
+++ /dev/null
@@ -1,3661 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { compileSpec, decompileSpec } from "../../../../../src/utils/graphspec/index.js";
-import { DEFAULT_ACTOR } from "../../core/actor.js";
-import { batch } from "../../core/batch.js";
-import { GuardDenied, policy } from "../../core/guard.js";
-import { COMPLETE, DATA, DIRTY, PAUSE, RESUME, TEARDOWN } from "../../core/messages.js";
-import { factoryTag, placeholderArgs } from "../../core/meta.js";
-import { node } from "../../core/node.js";
-import {
-	graphSpecToD2,
-	graphSpecToJson,
-	graphSpecToMermaid,
-	graphSpecToMermaidUrl,
-	graphSpecToPretty,
-} from "../../extra/render/index.js";
-import {
-	GRAPH_META_SEGMENT,
-	Graph,
-	type GraphPersistSnapshot,
-	type ObserveResult,
-	reachable,
-} from "../../graph/graph.js";
-import { latestVals } from "../test-helpers.js";
-import { assertDescribeMatchesAppendixB } from "./validate-describe-appendix-b.js";
-
-describe("Graph (Phase 1.1)", () => {
-	it("Graph(name) and empty name throws", () => {
-		const g = new Graph("app");
-		expect(g.name).toBe("app");
-		expect(() => new Graph("")).toThrow(/non-empty/);
-	});
-
-	it("add / remove / node / get / set", () => {
-		const g = new Graph("g");
-		const a = node([], { name: "a", initial: 1 });
-		g.add(a, { name: "a" });
-		expect(g.node("a").cache).toBe(1);
-		g.set("a", 2);
-		expect(g.node("a").cache).toBe(2);
-		expect(g.node("a")).toBe(a);
-		g.remove("a");
-		expect(() => g.node("a")).toThrow(/unknown node/);
-	});
-
-	it("add duplicate name throws", () => {
-		const g = new Graph("g");
-		const n = node([], { initial: 0 });
-		g.add(n, { name: "x" });
-		expect(() => g.add(node([], { initial: 1 }), { name: "x" })).toThrow(/already exists/);
-	});
-
-	it("add duplicate node instance throws", () => {
-		const g = new Graph("g");
-		const n = node([], { initial: 0 });
-		g.add(n, { name: "x" });
-		expect(() => g.add(n, { name: "y" })).toThrow(/already registered/);
-	});
-
-	it("remove sends TEARDOWN", () => {
-		const g = new Graph("g");
-		const n = node([], { initial: 0 });
-		const seen: symbol[] = [];
-		n.subscribe((msgs) => {
-			for (const m of msgs) seen.push(m[0] as symbol);
-		});
-		g.add(n, { name: "n" });
-		g.remove("n");
-		expect(seen).toContain(TEARDOWN);
-	});
-
-	it("remove removes node and derived edges go with it", () => {
-		const g = new Graph("g");
-		const a = node([], { name: "a", initial: 0 });
-		const b = node(
-			[a],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit(data[0]);
-			},
-			{ describeKind: "derived", name: "b" },
-		);
-		g.add(a, { name: "a" });
-		g.add(b, { name: "b" });
-		expect(g.edges().length).toBe(1);
-		g.remove("a");
-		// `a` is gone from _nodes, so the derived edge a→b no longer surfaces
-		// (`edges()` only emits edges where both endpoints resolve to a
-		// registered node in the tree).
-		expect(g.edges()).toEqual([]);
-	});
-
-	it("set on graph drives derived value (wiring via deps)", () => {
-		const g = new Graph("g");
-		const a = node([], { name: "a", initial: 1 });
-		const b = node(
-			[a],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as number) * 2);
-			},
-			{ describeKind: "derived", name: "b" },
-		);
-		g.add(a, { name: "a" });
-		g.add(b, { name: "b" });
-		b.subscribe(() => {
-			/* ensure b is connected upstream */
-		});
-		g.set("a", 3);
-		expect(g.node("b").cache).toBe(6);
-	});
-
-	it("empty local name throws on add", () => {
-		const g = new Graph("g");
-		expect(() => g.add(node([], { initial: 0 }), { name: "" })).toThrow(/non-empty/);
-	});
-
-	it("edges() returns edges derived from constructor deps", () => {
-		const g = new Graph("g");
-		const a = node([], { name: "a", initial: 0 });
-		const b = node(
-			[a],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit(data[0]);
-			},
-			{ describeKind: "derived", name: "b" },
-		);
-		g.add(a, { name: "a" });
-		g.add(b, { name: "b" });
-		// Derived from b's _deps — no explicit connect() call needed.
-		expect(g.edges()).toEqual([["a", "b"]]);
-	});
-
-	it("single colon in names is allowed", () => {
-		const g = new Graph("g");
-		const n = node([], { initial: 0 });
-		g.add(n, { name: "my:node" });
-		expect(g.node("my:node")).toBe(n);
-		expect(g.node("my:node").cache).toBe(0);
-		g.set("my:node", 5);
-		expect(g.node("my:node").cache).toBe(5);
-	});
-
-	it("Graph name with single colon is allowed", () => {
-		const g = new Graph("app:v2");
-		expect(g.name).toBe("app:v2");
-	});
-
-	it("Graph name with :: throws", () => {
-		expect(() => new Graph("a::b")).toThrow(/must not contain/);
-	});
-});
-
-describe("Graph composition (Phase 1.2)", () => {
-	it("mount + resolve by relative path", () => {
-		const root = new Graph("app");
-		const child = new Graph("payment");
-		const n = node([], { name: "amount", initial: 7 });
-		child.add(n, { name: "amount" });
-		root.mount("payment", child);
-		expect(root.resolve("payment::amount")).toBe(n);
-		expect(root.resolve("payment::amount").cache).toBe(7);
-	});
-
-	it("resolve strips leading graph name when it matches this.name", () => {
-		const root = new Graph("app");
-		const child = new Graph("pay");
-		const n = node([], { name: "x", initial: 1 });
-		child.add(n, { name: "x" });
-		root.mount("payment", child);
-		expect(root.resolve("app::payment::x")).toBe(n);
-	});
-
-	it("resolve on child strips child graph name prefix", () => {
-		const child = new Graph("pay");
-		const n = node([], { name: "x", initial: 2 });
-		child.add(n, { name: "x" });
-		expect(child.resolve("pay::x")).toBe(n);
-		expect(child.resolve("x")).toBe(n);
-	});
-
-	// Self-resolve fix (2026-04-30): a single-segment path equal to the graph
-	// name is treated as a local-node lookup. Pre-fix this threw "resolve
-	// path ends at graph name only", blocking topics named after their own
-	// internal node (e.g. `topic("events").resolve("events")`).
-	it("resolve(graph-name) returns the local node when one matches", () => {
-		const g = new Graph("events");
-		const n = node([], { name: "events", initial: 0 });
-		g.add(n, { name: "events" });
-		expect(g.resolve("events")).toBe(n);
-	});
-
-	it("resolve(graph-name) throws unknown-name when no local node matches", () => {
-		const g = new Graph("ghost");
-		expect(() => g.resolve("ghost")).toThrow(/unknown/);
-	});
-
-	it("resolve throws when path ends at subgraph", () => {
-		const root = new Graph("app");
-		const child = new Graph("c");
-		child.add(node([], { initial: 0 }), { name: "x" });
-		root.mount("sub", child);
-		expect(() => root.resolve("sub")).toThrow(/subgraph/);
-	});
-
-	it("resolve throws for trailing path after a node name", () => {
-		const g = new Graph("g");
-		g.add(node([], { initial: 0 }), { name: "a" });
-		expect(() => g.resolve("a::b")).toThrow(/node/);
-	});
-
-	it("add after mount at same name throws", () => {
-		const root = new Graph("r");
-		root.mount("m", new Graph("c"));
-		expect(() => root.add(node([], { initial: 0 }), { name: "m" })).toThrow(/mount/);
-	});
-
-	it("mount after add at same name throws", () => {
-		const root = new Graph("r");
-		root.add(node([], { initial: 0 }), { name: "m" });
-		expect(() => root.mount("m", new Graph("c"))).toThrow(/node/);
-	});
-
-	it("mount cycle is rejected", () => {
-		const a = new Graph("a");
-		const b = new Graph("b");
-		a.mount("b", b);
-		expect(() => b.mount("a", a)).toThrow(/cycle/);
-	});
-
-	it("same child graph instance mounted twice is rejected", () => {
-		const root = new Graph("root");
-		const child = new Graph("ch");
-		child.add(node([], { initial: 0 }), { name: "n" });
-		root.mount("c1", child);
-		expect(() => root.mount("c2", child)).toThrow(/already mounted/);
-	});
-
-	it("signal reaches nodes inside mounted graphs once per node", () => {
-		const root = new Graph("root");
-		const child = new Graph("child");
-		const n = node([], { name: "n", initial: 0 });
-		child.add(n, { name: "n" });
-		root.mount("c", child);
-		const seen: symbol[] = [];
-		n.subscribe((msgs) => {
-			for (const m of msgs) seen.push(m[0] as symbol);
-		});
-		root.signal([[PAUSE, "id1"]]);
-		expect(seen.filter((t) => t === PAUSE).length).toBe(1);
-	});
-
-	it("signal visits mounts before local nodes", () => {
-		const root = new Graph("root");
-		const child = new Graph("child");
-		const order: string[] = [];
-		const rootNode = node([], { name: "rootN", initial: 0 });
-		const childNode = node([], { name: "childN", initial: 0 });
-		child.add(childNode, { name: "cn" });
-		root.add(rootNode, { name: "rn" });
-		root.mount("c", child);
-		childNode.subscribe(() => order.push("child"));
-		rootNode.subscribe(() => order.push("root"));
-		// Clear initial push-on-subscribe emissions
-		order.length = 0;
-		root.signal([[PAUSE, "x"]]);
-		expect(order).toEqual(["child", "root"]);
-	});
-
-	it(":: in local add name throws", () => {
-		const g = new Graph("g");
-		expect(() => g.add(node([], { initial: 0 }), { name: "a::b" })).toThrow(/path separator/);
-	});
-
-	it("single colon in mount name is allowed", () => {
-		const root = new Graph("r");
-		const child = new Graph("c");
-		child.add(node([], { initial: 0 }), { name: "x" });
-		root.mount("my:mount", child);
-		expect(root.resolve("my:mount::x").cache).toBe(0);
-	});
-
-	it("node / get / set accept :: qualified paths", () => {
-		const root = new Graph("app");
-		const child = new Graph("sub");
-		const n = node([], { name: "val", initial: 10 });
-		child.add(n, { name: "val" });
-		root.mount("sub", child);
-		expect(root.node("sub::val")).toBe(n);
-		expect(root.node("sub::val").cache).toBe(10);
-		root.set("sub::val", 42);
-		expect(root.node("sub::val").cache).toBe(42);
-	});
-
-	it("child graph's edges() reflects constructor deps regardless of parent mount", () => {
-		const root = new Graph("app");
-		const child = new Graph("sub");
-		const a = node([], { name: "a", initial: 0 });
-		const b = node(
-			[a],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit(data[0]);
-			},
-			{ describeKind: "derived", name: "b" },
-		);
-		child.add(a, { name: "a" });
-		child.add(b, { name: "b" });
-		root.mount("sub", child);
-		// Derived directly from node _deps — no connect() call needed.
-		expect(child.edges()).toEqual([["a", "b"]]);
-	});
-
-	it("remove(mount_name) unmounts and sends TEARDOWN through subtree", () => {
-		const root = new Graph("root");
-		const child = new Graph("child");
-		const grandchild = new Graph("gc");
-		const n1 = node([], { name: "n1", initial: 1 });
-		const n2 = node([], { name: "n2", initial: 2 });
-		child.add(n1, { name: "n1" });
-		grandchild.add(n2, { name: "n2" });
-		child.mount("gc", grandchild);
-		root.mount("child", child);
-
-		const teardowns: string[] = [];
-		n1.subscribe((msgs) => {
-			for (const m of msgs) if (m[0] === TEARDOWN) teardowns.push("n1");
-		});
-		n2.subscribe((msgs) => {
-			for (const m of msgs) if (m[0] === TEARDOWN) teardowns.push("n2");
-		});
-
-		root.remove("child");
-		// Both nodes in the subtree should receive TEARDOWN.
-		expect(teardowns).toContain("n1");
-		expect(teardowns).toContain("n2");
-		// Mount should be gone.
-		expect(() => root.resolve("child::n1")).toThrow();
-	});
-
-	it("remove(mount_name) unmounts subgraph — tree edges drop accordingly", () => {
-		const root = new Graph("root");
-		const child = new Graph("child");
-		const a = node([], { name: "a", initial: 0 });
-		const b = node(
-			[a],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit(data[0]);
-			},
-			{ describeKind: "derived", name: "b" },
-		);
-		root.add(a, { name: "a" });
-		child.add(b, { name: "b" });
-		root.mount("sub", child);
-		// Cross-subgraph edge is derived (b's constructor dep points at a).
-		expect(root.edges({ recursive: true }).length).toBe(1);
-		root.remove("sub");
-		expect(root.edges({ recursive: true })).toEqual([]);
-	});
-});
-
-describe("Graph introspection (Phase 1.3)", () => {
-	it("does not override options.name on add", () => {
-		const g = new Graph("g");
-		const n = node([], { name: "keep", initial: 1 });
-		g.add(n, { name: "alias" });
-		expect(n.name).toBe("keep");
-	});
-
-	it("rejects reserved __meta__ for add and mount", () => {
-		const g = new Graph("g");
-		expect(() => g.add(node([], { initial: 0 }), { name: GRAPH_META_SEGMENT })).toThrow(/reserved/);
-		expect(() => g.mount(GRAPH_META_SEGMENT, new Graph("c"))).toThrow(/reserved/);
-	});
-
-	it("describe includes qualified nodes, edges, subgraphs (recursive)", () => {
-		const root = new Graph("app");
-		const child = new Graph("pay");
-		const grandchild = new Graph("inner");
-		const a = node([], { initial: 1 });
-		const b = node(
-			[a],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as number) + 1);
-			},
-			{ describeKind: "derived" },
-		);
-		child.add(a, { name: "a" });
-		child.add(b, { name: "b" });
-		grandchild.add(node([], { initial: 0 }), { name: "x" });
-		child.mount("gc", grandchild);
-		root.mount("sub", child);
-		const d = root.describe();
-		expect(d.name).toBe("app");
-		expect(d.subgraphs).toEqual(["sub", "sub::gc"]);
-		expect(d.nodes["sub::a"]).toMatchObject({ type: "state" });
-		expect(d.nodes["sub::b"]).toMatchObject({ type: "derived", deps: ["sub::a"] });
-		expect(d.nodes["sub::gc::x"]).toMatchObject({ type: "state" });
-		expect(d.edges).toContainEqual({ from: "sub::a", to: "sub::b" });
-	});
-
-	it("describe filter supports depsIncludes, metaHas, and path-aware predicate", () => {
-		const g = new Graph("g");
-		const a = node([], { name: "a", meta: { label: "input" }, initial: 1 });
-		const b = node(
-			[a],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as number) + 1);
-			},
-			{ describeKind: "derived", name: "b" },
-		);
-		g.add(a, { name: "a" });
-		g.add(b, { name: "b" });
-
-		const byDeps = g.describe({ filter: { depsIncludes: "a" } });
-		expect(Object.keys(byDeps.nodes)).toEqual(["b"]);
-
-		const byMeta = g.describe({ detail: "standard", filter: { metaHas: "label" } });
-		expect(Object.keys(byMeta.nodes)).toContain("a");
-		const byDepsSnake = g.describe({ filter: { deps_includes: "a" } });
-		expect(Object.keys(byDepsSnake.nodes)).toEqual(["b"]);
-		const byMetaSnake = g.describe({ detail: "standard", filter: { meta_has: "label" } });
-		expect(Object.keys(byMetaSnake.nodes)).toContain("a");
-
-		const byPath = g.describe({
-			filter: (path, node) => path.startsWith("a") && node.type === "state",
-		});
-		expect(Object.keys(byPath.nodes)).toContain("a");
-	});
-
-	it("metaHas filter at minimal detail excludes all nodes (no meta at minimal)", () => {
-		const g = new Graph("g");
-		g.add(node([], { name: "a", meta: { label: "input" }, initial: 1 }), { name: "a" });
-		// Default (minimal) detail omits meta, so metaHas filter matches nothing
-		const d = g.describe({ filter: { metaHas: "label" } });
-		expect(Object.keys(d.nodes)).toEqual([]);
-		g.destroy();
-	});
-
-	it("reachable traverses upstream via deps and incoming edges", () => {
-		const d = {
-			name: "g",
-			nodes: {
-				a: { type: "state", status: "settled", deps: [], meta: {} },
-				b: { type: "derived", status: "settled", deps: ["a"], meta: {} },
-				c: { type: "derived", status: "settled", deps: ["b"], meta: {} },
-				x: { type: "state", status: "settled", deps: [], meta: {} },
-			},
-			edges: [{ from: "x", to: "b" }],
-			subgraphs: [],
-		} satisfies GraphPersistSnapshot;
-
-		expect(reachable(d, "c", "upstream")).toEqual(["a", "b", "x"]);
-		expect(reachable(d, "c", "upstream", { maxDepth: 1 })).toEqual(["b"]);
-	});
-
-	it("reachable traverses downstream via reverse deps and outgoing edges", () => {
-		const d = {
-			name: "g",
-			nodes: {
-				a: { type: "state", status: "settled", deps: [], meta: {} },
-				b: { type: "derived", status: "settled", deps: ["a"], meta: {} },
-				c: { type: "derived", status: "settled", deps: ["b"], meta: {} },
-				sink: { type: "state", status: "settled", deps: [], meta: {} },
-			},
-			edges: [{ from: "a", to: "sink" }],
-			subgraphs: [],
-		} satisfies GraphPersistSnapshot;
-
-		expect(reachable(d, "a", "downstream")).toEqual(["b", "c", "sink"]);
-		expect(reachable(d, "a", "downstream", { maxDepth: 1 })).toEqual(["b", "sink"]);
-	});
-
-	it("reachable validates direction and maxDepth as integer", () => {
-		const d = {
-			name: "g",
-			nodes: { a: { type: "state", status: "settled", deps: [], meta: {} } },
-			edges: [],
-			subgraphs: [],
-		} satisfies GraphPersistSnapshot;
-
-		expect(() => reachable(d, "a", "sideways" as unknown as "upstream")).toThrow(
-			/direction must be/,
-		);
-		expect(() => reachable(d, "a", "upstream", { maxDepth: 1.5 })).toThrow(/integer >= 0/);
-		expect(() => reachable(d, "a", "upstream", { maxDepth: -1 })).toThrow(/integer >= 0/);
-		expect(reachable(d, "a", "upstream", { maxDepth: 0 })).toEqual([]);
-	});
-
-	it("reachable handles unknown start and malformed edge entries", () => {
-		// Unit 16 B (batch 8) dropped the full defensive coercion: we now
-		// trust top-level GraphDescribeOutput shape (pre-1.0, no legacy
-		// snapshots circulating). Minimal guards remain for malformed edge
-		// array entries (common when a persisted snapshot loses its schema).
-		const malformed = {
-			name: "g",
-			nodes: { a: { type: "state", status: "settled", deps: ["b"], meta: {} } },
-			edges: [{ from: "b", to: "a" }, { from: 1 }, null],
-			subgraphs: [],
-		} as unknown as GraphPersistSnapshot;
-		expect(reachable(malformed, "missing", "upstream")).toEqual([]);
-	});
-
-	it("describe lists each meta companion as its own node entry (Python parity)", () => {
-		const g = new Graph("g");
-		const n = node({ initial: 0, meta: { desc: "purpose" } });
-		g.add(n, { name: "n" });
-		const d = g.describe({ detail: "standard" });
-		const metaKey = `n::${GRAPH_META_SEGMENT}::desc`;
-		expect(d.nodes[metaKey]).toMatchObject({ type: "state" });
-		expect(d.nodes.n?.meta).toEqual({ desc: "purpose" });
-	});
-
-	it("resolve, set, and observe on meta companion path", () => {
-		const g = new Graph("g");
-		const n = node({ initial: 0, meta: { tag: "x" } });
-		g.add(n, { name: "n" });
-		const metaPath = `n::${GRAPH_META_SEGMENT}::tag`;
-		expect(g.resolve(metaPath).cache).toBe("x");
-		const seen: unknown[] = [];
-		const off = g.observe(metaPath).subscribe((msgs) => {
-			for (const m of msgs) {
-				if (m[0] === DATA) seen.push(m[1]);
-			}
-		});
-		g.set(metaPath, "y");
-		off();
-		expect(seen).toContain("y");
-	});
-
-	it("signal delivers to meta companions", () => {
-		const g = new Graph("g");
-		const n = node({ initial: 0, meta: { m: 0 } });
-		g.add(n, { name: "n" });
-		const metaPath = `n::${GRAPH_META_SEGMENT}::m`;
-		const types: symbol[] = [];
-		g.observe(metaPath).subscribe((msgs) => {
-			for (const m of msgs) types.push(m[0] as symbol);
-		});
-		g.signal([[PAUSE, "id"]]);
-		expect(types).toContain(PAUSE);
-	});
-
-	it("signal does not duplicate TEARDOWN to meta (parent already cascades)", () => {
-		const g = new Graph("g");
-		const n = node({ initial: 0, meta: { m: 0 } });
-		g.add(n, { name: "n" });
-		const metaPath = `n::${GRAPH_META_SEGMENT}::m`;
-		let teardowns = 0;
-		g.observe(metaPath).subscribe((msgs) => {
-			for (const m of msgs) {
-				if (m[0] === TEARDOWN) teardowns += 1;
-			}
-		});
-		g.signal([[TEARDOWN]]);
-		expect(teardowns).toBe(1);
-	});
-
-	it("observe() sink sees sorted paths for graph.signal", () => {
-		const g = new Graph("g");
-		g.add(node([], { initial: 0 }), { name: "b" });
-		g.add(node([], { initial: 0 }), { name: "a" });
-		const order: string[] = [];
-		g.observe().subscribe((path, msgs) => {
-			for (const m of msgs) {
-				if (m[0] === PAUSE) order.push(path);
-			}
-		});
-		g.signal([[PAUSE, "z"]]);
-		expect(order).toEqual(["a", "b"]);
-	});
-
-	it("observe(path, { timeline: true }) includes timestamp and batch context", () => {
-		const g = new Graph("g");
-		const a = node([], { name: "a", initial: 0 });
-		const b = node(
-			[a],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as number) + 1);
-			},
-			{ describeKind: "derived", name: "b" },
-		);
-		g.add(a, { name: "a" });
-		g.add(b, { name: "b" });
-		const obs = g.observe("b", { timeline: true });
-		batch(() => {
-			g.set("a", 2);
-		});
-		obs.dispose();
-		const timed = obs.events.filter((e) => e.timestamp_ns != null);
-		expect(timed.length).toBeGreaterThan(0);
-		expect(obs.events.some((e) => e.in_batch === true)).toBe(true);
-		expect(obs.values.b).toBe(3);
-	});
-
-	it("observe(path, { causal: true, derived: true }) captures trigger and dep snapshots", () => {
-		const g = new Graph("g");
-		const a = node([], { name: "a", initial: 0 });
-		const b = node(
-			[a],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as number) + 1);
-			},
-			{ describeKind: "derived", name: "b" },
-		);
-		g.add(a, { name: "a" });
-		g.add(b, { name: "b" });
-		const obs = g.observe("b", { causal: true, derived: true, timeline: true });
-		g.set("a", 5);
-		obs.dispose();
-		const derivedEvents = obs.events.filter((e) => e.type === "derived");
-		const derivedEvent = derivedEvents[derivedEvents.length - 1];
-		expect(derivedEvent?.dep_values).toEqual([5]);
-		// Single-value wave: dep_batches[0] is a 1-element array of the same value.
-		expect(derivedEvent?.dep_batches?.[0]).toEqual([5]);
-		const dataEvents = obs.events.filter((e) => e.type === "data");
-		const dataEvent = dataEvents[dataEvents.length - 1];
-		expect(dataEvent?.trigger_dep_index).toBe(0);
-		expect(dataEvent?.trigger_dep_name).toBe("a");
-		expect(dataEvent?.dep_values).toEqual([5]);
-		expect(dataEvent?.dep_batches?.[0]).toEqual([5]);
-		expect(obs.values.b).toBe(6);
-	});
-
-	it("dep_batches tracks per-dep wave batches", () => {
-		const g = new Graph("g");
-		const a = node([], { name: "a", initial: 0 });
-		const b = node([], { name: "b", initial: 100 });
-		const c = node(
-			[a, b],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as number) + (data[1] as number));
-			},
-			{ describeKind: "derived", name: "c" },
-		);
-		g.add(a, { name: "a" });
-		g.add(b, { name: "b" });
-		g.add(c, { name: "c" });
-		const obs = g.observe("c", { causal: true, derived: true });
-		// Drive a single wave with both deps updating via batch().
-		batch(() => {
-			g.set("a", 5);
-			g.set("b", 200);
-		});
-		obs.dispose();
-		const derivedEvents = obs.events.filter((e) => e.type === "derived");
-		// After the batched update, the most recent derived run should see both
-		// deps' batches — each of length 1 (single DATA per dep in this wave).
-		const last = derivedEvents[derivedEvents.length - 1];
-		expect(last).toBeDefined();
-		expect(last?.dep_batches).toBeDefined();
-		expect(last?.dep_batches?.length).toBe(2);
-		expect(last?.dep_batches?.[0]).toEqual([5]);
-		expect(last?.dep_batches?.[1]).toEqual([200]);
-		// dep_values holds the last scalar per dep — matches older tooling.
-		expect(last?.dep_values).toEqual([5, 200]);
-	});
-
-	it("observe(path, { causal: true, derived: true }) includes initial derived run", () => {
-		const g = new Graph("g");
-		const a = node([], { name: "a", initial: 0 });
-		const b = node(
-			[a],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as number) + 1);
-			},
-			{ describeKind: "derived", name: "b" },
-		);
-		g.add(a, { name: "a" });
-		g.add(b, { name: "b" });
-		const obs = g.observe("b", { causal: true, derived: true, timeline: true });
-		g.set("a", 3);
-		obs.dispose();
-		const derivedEvents = obs.events.filter((e) => e.type === "derived");
-		expect(derivedEvents.length).toBeGreaterThanOrEqual(2);
-		expect(derivedEvents.some((e) => JSON.stringify(e.dep_values) === JSON.stringify([0]))).toBe(
-			true,
-		);
-		expect(derivedEvents.some((e) => JSON.stringify(e.dep_values) === JSON.stringify([3]))).toBe(
-			true,
-		);
-	});
-
-	it("observe({ structured: true }) on whole graph returns structured result", () => {
-		const g = new Graph("g");
-		g.add(node([], { name: "a", initial: 1 }), { name: "a" });
-		g.add(node([], { name: "b", initial: 2 }), { name: "b" });
-		const obs = g.observe({ structured: true, timeline: true });
-		g.set("a", 10);
-		g.set("b", 20);
-		obs.dispose();
-		expect(obs.values.a).toBe(10);
-		expect(obs.values.b).toBe(20);
-		expect(obs.events.some((e) => e.path === "a" && e.type === "data")).toBe(true);
-		expect(obs.events.some((e) => e.path === "b" && e.type === "data")).toBe(true);
-		expect(obs.events.some((e) => e.timestamp_ns != null)).toBe(true);
-	});
-
-	it("graphSpecToMermaid exports qualified nodes and edges with direction", () => {
-		const g = new Graph("g");
-		const child = new Graph("child");
-		const a = node([], { name: "a", initial: 0 });
-		const b = node(
-			[a],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as number) + 1);
-			},
-			{ describeKind: "derived", name: "b" },
-		);
-		child.add(a, { name: "a" });
-		child.add(b, { name: "b" });
-		g.mount("sub", child);
-		const text = graphSpecToMermaid(g.describe(), { direction: "TD" });
-		expect(text).toContain("flowchart TD");
-		expect(text).toContain('["sub::a"]');
-		expect(text).toContain('["sub::b"]');
-		expect(text).toContain("-->");
-	});
-
-	it("graphSpecToD2 exports qualified nodes and maps direction", () => {
-		const g = new Graph("g");
-		const a = node([], { name: "a", initial: 1 });
-		const b = node(
-			[a],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as number) * 2);
-			},
-			{ describeKind: "derived", name: "b" },
-		);
-		g.add(a, { name: "a" });
-		g.add(b, { name: "b" });
-		const text = graphSpecToD2(g.describe(), { direction: "RL" });
-		expect(text).toContain("direction: left");
-		expect(text).toContain('"a"');
-		expect(text).toContain('"b"');
-		expect(text).toContain("->");
-	});
-
-	it("graphSpecToMermaid rejects invalid direction at runtime", () => {
-		const g = new Graph("g");
-		g.add(node([], { name: "a", initial: 0 }), { name: "a" });
-		expect(() =>
-			graphSpecToMermaid(g.describe(), { direction: "SIDEWAYS" as unknown as "TD" }),
-		).toThrow(/invalid diagram direction/);
-	});
-
-	it("graphSpecToD2 rejects invalid direction at runtime", () => {
-		const g = new Graph("g");
-		g.add(node([], { name: "a", initial: 0 }), { name: "a" });
-		expect(() => graphSpecToD2(g.describe(), { direction: "SIDEWAYS" as unknown as "TD" })).toThrow(
-			/invalid diagram direction/,
-		);
-	});
-
-	it("D2: describe({ reactive: true }) returns a reactive handle that recomputes on graph change", () => {
-		const g = new Graph("g");
-		const a = node([], { name: "a", initial: 1 });
-		const b = node(
-			[a],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as number) * 2);
-			},
-			{ describeKind: "derived", name: "b" },
-		);
-		g.add(a, { name: "a" });
-		g.add(b, { name: "b" });
-		g.observe("b").subscribe(() => {});
-
-		const live = g.describe({ reactive: true });
-		const unsub = live.node.subscribe(() => {});
-		const first = live.node.cache;
-		expect(first?.name).toBe("g");
-		expect(Object.keys(first?.nodes ?? {}).sort()).toEqual(["a", "b"]);
-
-		// Structural change — add a new node.
-		g.add(node([], { name: "c", initial: 9 }), { name: "c" });
-		const next = live.node.cache;
-		expect(Object.keys(next?.nodes ?? {})).toContain("c");
-
-		unsub();
-		live.dispose();
-	});
-
-	it("D2: derived(describe({ reactive: true }) → graphSpecToMermaid) yields a live Mermaid Node<string>", () => {
-		const g = new Graph("g");
-		g.add(node([], { name: "a", initial: 1 }), { name: "a" });
-		const live = g.describe({ reactive: true });
-		const mermaid = node(
-			[live.node],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit(graphSpecToMermaid(data[0]));
-			},
-			{ describeKind: "derived", name: "live-mermaid" },
-		);
-		const unsub = mermaid.subscribe(() => {});
-		expect(typeof mermaid.cache).toBe("string");
-		expect(mermaid.cache).toContain("flowchart");
-		unsub();
-		live.dispose();
-	});
-
-	it("graphSpecToMermaidUrl emits mermaid.live deep link round-trippable to mermaid source", () => {
-		const g = new Graph("g");
-		const a = node([], { name: "a", initial: 1 });
-		const b = node(
-			[a],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as number) + 1);
-			},
-			{ describeKind: "derived", name: "b" },
-		);
-		g.add(a, { name: "a" });
-		g.add(b, { name: "b" });
-		const url = graphSpecToMermaidUrl(g.describe());
-		expect(url).toMatch(/^https:\/\/mermaid\.live\/edit#base64:/);
-		const b64 = url.slice("https://mermaid.live/edit#base64:".length);
-		// url-safe base64 → standard base64 + padding
-		let std = b64.replace(/-/g, "+").replace(/_/g, "/");
-		while (std.length % 4 !== 0) std += "=";
-		const json = JSON.parse(globalThis.atob(std));
-		expect(json.code).toContain("flowchart");
-		expect(json.code).toContain("-->");
-		expect(json.mermaid?.theme).toBe("default");
-	});
-
-	it("graphSpecToMermaid and graphSpecToD2 render constructor deps without explicit connect", () => {
-		const g = new Graph("g");
-		const a = node([], { name: "a", initial: 1 });
-		const b = node(
-			[a],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as number) + 1);
-			},
-			{ describeKind: "derived", name: "b" },
-		);
-		g.add(a, { name: "a" });
-		g.add(b, { name: "b" });
-		// No connect() — deps only
-		const mermaid = graphSpecToMermaid(g.describe());
-		expect(mermaid).toContain("-->");
-		const d2 = graphSpecToD2(g.describe());
-		expect(d2).toContain("->");
-	});
-
-	it("trace() silently drops unknown paths and follows inspector gating", () => {
-		const g = new Graph("g");
-		g.add(node([], { name: "a", initial: 0 }), { name: "a" });
-		g.trace("a", "first");
-		expect(g.trace().some((e) => e.annotation === "first")).toBe(true);
-		// Unit 14 E (batch 8): unknown path → silent drop (matches observe
-		// resilience), no throw. The entry is not recorded.
-		g.trace("missing", "x");
-		expect(g.trace().some((e) => e.annotation === "x")).toBe(false);
-
-		const prev = g.config.inspectorEnabled;
-		try {
-			g.config.inspectorEnabled = false;
-			expect(g.trace()).toEqual([]);
-			g.trace("a", "second");
-		} finally {
-			g.config.inspectorEnabled = prev;
-		}
-		expect(g.trace().some((e) => e.annotation === "second")).toBe(false);
-	});
-
-	it("observe({ format }) logs events with include/exclude filters", () => {
-		const g = new Graph("g");
-		const logs: string[] = [];
-		g.add(node([], { name: "a", initial: 0 }), { name: "a" });
-		const obs = g.observe("a", {
-			format: "pretty",
-			includeTypes: ["data", "dirty", "resolved"],
-			excludeTypes: ["resolved"],
-			theme: "none",
-			logger: (line) => logs.push(line),
-		});
-		g.set("a", 1);
-		obs.dispose();
-		expect(logs.some((line) => line.includes("DATA"))).toBe(true);
-		expect(logs.some((line) => line.includes("RESOLVED"))).toBe(false);
-	});
-
-	it("observe({ format: 'json' }) supports JSON output in graph-wide mode", () => {
-		const g = new Graph("g");
-		const lines: string[] = [];
-		g.add(node([], { name: "a", initial: 0 }), { name: "a" });
-		g.add(node([], { name: "b", initial: 0 }), { name: "b" });
-		const obs = g.observe({
-			format: "json",
-			theme: "none",
-			logger: (line) => lines.push(line),
-		});
-		g.set("a", 2);
-		g.set("b", 3);
-		obs.dispose();
-		const parsed = lines.map((line) => JSON.parse(line) as { type?: string; path?: string });
-		expect(parsed.some((evt) => evt.type === "data" && evt.path === "a")).toBe(true);
-		expect(parsed.some((evt) => evt.type === "data" && evt.path === "b")).toBe(true);
-	});
-
-	it("graphSpecToPretty / graphSpecToJson render the snapshot", () => {
-		const g = new Graph("g");
-		const a = node([], { name: "a", initial: 1 });
-		const b = node(
-			[a],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as number) + 1);
-			},
-			{ describeKind: "derived", name: "b" },
-		);
-		g.add(a, { name: "a" });
-		g.add(b, { name: "b" });
-		const pretty = graphSpecToPretty(g.describe({ detail: "standard" }));
-		expect(pretty).toContain("Graph g");
-		expect(pretty).toContain("Nodes:");
-		expect(pretty).toContain("Edges:");
-		const jsonText = graphSpecToJson(g.describe({ detail: "standard" }), { indent: 2 });
-		expect(jsonText).toBe(graphSpecToJson(g.describe({ detail: "standard" }), { indent: 2 }));
-		const parsed = JSON.parse(jsonText) as {
-			name: string;
-			nodes: Record<string, unknown>;
-			edges: Array<{ from: string; to: string }>;
-		};
-		expect(parsed.name).toBe("g");
-		expect(parsed.nodes.a).toBeDefined();
-		expect(parsed.edges).toEqual([{ from: "a", to: "b" }]);
-	});
-
-	it("D1 byte-identical fixture pins each graphSpecTo* renderer's output", () => {
-		// Locks the exact pre-extraction bytes for a known-shape fixture graph
-		// so any drift in `graphSpecTo*` (tab/spacing changes, key reordering,
-		// label escaping regressions) surfaces immediately. The fixture is the
-		// minimal a→b derived chain plus a `c::child` mount so all three of
-		// edges / subgraphs / qualified labels are exercised.
-		const g = new Graph("fixture");
-		const a = node([], { name: "a", initial: 1 });
-		const b = node(
-			[a],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as number) + 1);
-			},
-			{ describeKind: "derived", name: "b" },
-		);
-		g.add(a, { name: "a" });
-		g.add(b, { name: "b" });
-		const child = new Graph("child");
-		child.add(node([], { name: "leaf", initial: 0 }), { name: "leaf" });
-		g.mount("c", child);
-
-		// Mermaid — flowchart text with sorted ids n0/n1/...
-		const mermaid = graphSpecToMermaid(g.describe(), { direction: "LR" });
-		expect(mermaid).toBe(
-			["flowchart LR", '  n0["a"]', '  n1["b"]', '  n2["c::leaf"]', "  n0 --> n1"].join("\n"),
-		);
-
-		// D2 — direction text + sibling ids + arrows.
-		const d2 = graphSpecToD2(g.describe(), { direction: "LR" });
-		expect(d2).toBe(
-			["direction: right", 'n0: "a"', 'n1: "b"', 'n2: "c::leaf"', "n0 -> n1"].join("\n"),
-		);
-
-		// Pretty — node lines include the runtime status + value via
-		// `describeData`. Source `state(N)` nodes settle synchronously; the
-		// derived `b` is `sentinel` until any subscriber wakes it.
-		const pretty = graphSpecToPretty(g.describe({ detail: "standard" }));
-		expect(pretty).toBe(
-			[
-				"Graph fixture",
-				"Nodes:",
-				"- a (state/settled): 1",
-				"- b (derived/sentinel): undefined",
-				"- c::leaf (state/settled): 0",
-				"Edges:",
-				"- a -> b",
-				"Subgraphs:",
-				"- c",
-			].join("\n"),
-		);
-
-		// JSON — deterministic sorted-key text. We don't pin the entire
-		// 1-3KB output since it embeds version counters and per-node meta;
-		// we lock the structural keys + edge/subgraph/name layout instead.
-		const jsonText = graphSpecToJson(g.describe(), { indent: 2 });
-		const parsed = JSON.parse(jsonText) as {
-			name: string;
-			edges: Array<{ from: string; to: string }>;
-			subgraphs: string[];
-			nodes: Record<string, unknown>;
-		};
-		expect(parsed.name).toBe("fixture");
-		expect(parsed.edges).toEqual([{ from: "a", to: "b" }]);
-		expect(parsed.subgraphs).toEqual(["c"]);
-		expect(Object.keys(parsed.nodes).sort()).toEqual(["a", "b", "c::leaf"]);
-
-		// Mermaid URL — same mermaid bytes, base64url'd into the fragment.
-		const url = graphSpecToMermaidUrl(g.describe(), { direction: "LR" });
-		expect(url.startsWith("https://mermaid.live/edit#base64:")).toBe(true);
-		const b64 = url.slice("https://mermaid.live/edit#base64:".length);
-		let std = b64.replace(/-/g, "+").replace(/_/g, "/");
-		while (std.length % 4 !== 0) std += "=";
-		const decoded = JSON.parse(globalThis.atob(std)) as { code: string };
-		expect(decoded.code).toBe(mermaid);
-	});
-});
-
-describe("Graph lifecycle & persistence (Phase 1.4)", () => {
-	it("destroy signals TEARDOWN and clears registries (including mounts)", () => {
-		const root = new Graph("root");
-		const child = new Graph("child");
-		const n = node([], { name: "n", initial: 0 });
-		child.add(n, { name: "n" });
-		root.mount("c", child);
-		const types: symbol[] = [];
-		n.subscribe((msgs) => {
-			for (const m of msgs) types.push(m[0] as symbol);
-		});
-		root.destroy();
-		expect(types).toContain(TEARDOWN);
-		expect(() => root.resolve("c::n")).toThrow();
-		expect(root.describe().nodes).toEqual({});
-		expect(root.describe().subgraphs).toEqual([]);
-	});
-
-	it("parent destroy drains child mount disposers (EH-2 regression)", () => {
-		const root = new Graph("root");
-		const child = new Graph("child");
-		root.mount("c", child);
-		// Disposer registered on the CHILD — only reachable via parent destroy
-		// through the _destroyClearOnly cascade. Pre-fix this leaked silently.
-		let childDisposed = 0;
-		child.addDisposer(() => {
-			childDisposed += 1;
-		});
-		// Grandchild too — disposers must drain at every depth.
-		const grandchild = new Graph("gc");
-		child.mount("gc", grandchild);
-		let grandchildDisposed = 0;
-		grandchild.addDisposer(() => {
-			grandchildDisposed += 1;
-		});
-		root.destroy();
-		expect(childDisposed).toBe(1);
-		expect(grandchildDisposed).toBe(1);
-	});
-
-	it("snapshot extends describe with version 1", () => {
-		const g = new Graph("app");
-		g.add(node([], { initial: 1 }), { name: "z" });
-		g.add(node([], { initial: 2 }), { name: "a" });
-		const snap = g.snapshot();
-		expect(snap.version).toBe(1);
-		expect(snap.name).toBe("app");
-		expect(snap.nodes.a?.value).toBe(2);
-		expect(snap.nodes.z?.value).toBe(1);
-	});
-
-	it("snapshot returns stable output with sorted keys", () => {
-		const g = new Graph("g");
-		g.add(node([], { initial: 0 }), { name: "b" });
-		g.add(node([], { initial: 0 }), { name: "a" });
-		const o1 = g.snapshot();
-		const o2 = g.snapshot();
-		expect(JSON.stringify(o1)).toBe(JSON.stringify(o2));
-		expect(Object.keys(o1.nodes).sort()).toEqual(["a", "b"]);
-	});
-
-	it("JSON.stringify(graph) works via toJSON hook", () => {
-		const g = new Graph("g");
-		g.add(node([], { initial: 0 }), { name: "b" });
-		g.add(node([], { initial: 0 }), { name: "a" });
-		const j1 = JSON.stringify(g);
-		const j2 = JSON.stringify(g);
-		expect(j1).toBe(j2);
-		const parsed = JSON.parse(j1) as GraphPersistSnapshot;
-		expect(Object.keys(parsed.nodes).sort()).toEqual(["a", "b"]);
-	});
-
-	it("restore applies state (and producer) values; skips derived", () => {
-		const g = new Graph("g");
-		const a = node([], { name: "a", initial: 10 });
-		const b = node(
-			[a],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as number) * 2);
-			},
-			{ describeKind: "derived", name: "b" },
-		);
-		g.add(a, { name: "a" });
-		g.add(b, { name: "b" });
-		b.subscribe(() => {});
-		const snap = g.snapshot();
-		g.set("a", 0);
-		expect(g.node("b").cache).toBe(0);
-		g.restore(snap);
-		expect(g.node("a").cache).toBe(10);
-		expect(g.node("b").cache).toBe(20);
-	});
-
-	it("restore throws when snapshot name mismatches graph", () => {
-		const g = new Graph("one");
-		const snap: GraphPersistSnapshot = {
-			version: 1,
-			name: "other",
-			nodes: {},
-			edges: [],
-			subgraphs: [],
-		};
-		expect(() => g.restore(snap)).toThrow(/other/);
-	});
-
-	it("Graph.fromSnapshot with build restores values", () => {
-		const a = node([], { name: "a", initial: 0 });
-		const g0 = new Graph("app");
-		g0.add(a, { name: "a" });
-		g0.set("a", 7);
-		const snap = g0.snapshot();
-
-		const g1 = Graph.fromSnapshot(snap, (g) => {
-			g.add(node([], { name: "a", initial: 0 }), { name: "a" });
-		});
-		expect(g1.node("a").cache).toBe(7);
-	});
-
-	it("restore sets meta companion paths from snapshot", () => {
-		const n0 = node({ initial: 0, meta: { tag: "hi" } });
-		const g0 = new Graph("g");
-		g0.add(n0, { name: "n" });
-		const snap = g0.snapshot();
-		const metaPath = `n::${GRAPH_META_SEGMENT}::tag`;
-
-		const n1 = node({ initial: 0, meta: { tag: "" } });
-		const g1 = new Graph("g");
-		g1.add(n1, { name: "n" });
-		g1.restore(snap);
-		expect(g1.node(metaPath).cache).toBe("hi");
-	});
-
-	it("attachSnapshotStorage triggers only for messageTier >= 3", async () => {
-		const g = new Graph("g");
-		g.add(node([], { name: "a", initial: 0 }), { name: "a" });
-		const saves: unknown[] = [];
-		const tier = {
-			name: "test",
-			save(data: unknown) {
-				saves.push(data);
-			},
-			debounceMs: 5,
-			compactEvery: 2,
-		};
-		const h = g.attachSnapshotStorage([{ snapshot: tier }]);
-		// Wait for any initial push-on-subscribe checkpoint to drain
-		await new Promise((r) => setTimeout(r, 15));
-		saves.length = 0;
-		g.signal([[PAUSE, "lock"]]);
-		await new Promise((r) => setTimeout(r, 15));
-		expect(saves.length).toBe(0);
-		g.set("a", 1);
-		await new Promise((r) => setTimeout(r, 15));
-		expect(saves.length).toBe(1);
-		h.dispose();
-	});
-
-	it("restore supports selective hydration via only pattern", () => {
-		const g = new Graph("g");
-		g.add(node([], { name: "a", initial: 1 }), { name: "a" });
-		g.add(node([], { name: "b", initial: 2 }), { name: "b" });
-		const snap = g.snapshot();
-		g.set("a", 10);
-		g.set("b", 20);
-		g.restore(snap, { only: "a" });
-		expect(g.node("a").cache).toBe(1);
-		expect(g.node("b").cache).toBe(20);
-	});
-
-	it("fromSnapshot reconstructs dynamic nodes via factories option", () => {
-		const g0 = new Graph("g");
-		const a = node([], { name: "a", initial: 1 });
-		const sum = node(
-			[a],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as number) + 1);
-			},
-			{ describeKind: "derived", name: "sum" },
-		);
-		g0.add(a, { name: "a" });
-		g0.add(sum, { name: "sum" });
-		sum.subscribe(() => {});
-		const snap = g0.snapshot();
-		const g1 = Graph.fromSnapshot(snap, {
-			factories: {
-				sum: (name, ctx) =>
-					node(
-						ctx.resolvedDeps,
-						(batchData, actions, ctx) => {
-							const data = batchData.map((batch, i) =>
-								batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-							);
-							actions.emit((data[0] as number) + 1);
-						},
-						{ describeKind: "derived", name },
-					),
-			},
-		});
-		const s = g1.node("sum");
-		s.subscribe(() => {});
-		g1.set("a", 5);
-		expect(g1.node("sum").cache).toBe(6);
-	});
-});
-
-describe("EH-2: child mount disposer drain", () => {
-	it("addDisposer cleanup on a child fires when parent destroys", () => {
-		const root = new Graph("root");
-		const child = new Graph("child");
-		root.mount("c", child);
-		let disposed = 0;
-		child.addDisposer(() => {
-			disposed += 1;
-		});
-		expect(disposed).toBe(0);
-		root.destroy();
-		expect(disposed).toBe(1);
-	});
-
-	it("disposers drain at every depth via _destroyClearOnly cascade", () => {
-		const root = new Graph("root");
-		const child = new Graph("child");
-		const grandchild = new Graph("gc");
-		root.mount("c", child);
-		child.mount("gc", grandchild);
-		const order: string[] = [];
-		root.addDisposer(() => order.push("root"));
-		child.addDisposer(() => order.push("child"));
-		grandchild.addDisposer(() => order.push("grandchild"));
-		root.destroy();
-		// All depths drained — order may vary but every disposer must fire exactly once.
-		expect(order.sort()).toEqual(["child", "grandchild", "root"]);
-	});
-
-	it("multiple disposers on the same child all fire", () => {
-		const root = new Graph("root");
-		const child = new Graph("child");
-		root.mount("c", child);
-		let a = 0;
-		let b = 0;
-		child.addDisposer(() => {
-			a += 1;
-		});
-		child.addDisposer(() => {
-			b += 1;
-		});
-		root.destroy();
-		expect(a).toBe(1);
-		expect(b).toBe(1);
-	});
-});
-
-describe("Graph guard (Phase 1.5)", () => {
-	const human = { type: "human" as const, id: "u1" };
-	const llm = { type: "llm" as const, id: "gpt" };
-
-	it("meta companions inherit primary guard", () => {
-		const g = new Graph("g");
-		const n = node([], {
-			name: "n",
-			meta: { note: "a" },
-			guard: policy((allow, deny) => {
-				allow("write", { where: (a) => a.type === "human" });
-				deny("write", { where: (a) => a.type === "llm" });
-			}),
-			initial: 0,
-		});
-		g.add(n, { name: "n" });
-		const metaPath = `n::${GRAPH_META_SEGMENT}::note`;
-		g.set(metaPath, "b", { actor: human });
-		expect(g.node(metaPath).cache).toBe("b");
-		expect(() => g.set(metaPath, "c", { actor: llm })).toThrow(GuardDenied);
-	});
-
-	it("set and signal use write vs signal actions", () => {
-		const g = new Graph("g");
-		const n = node([], {
-			guard: (_a, action) => action !== "signal",
-			initial: 0,
-		});
-		g.add(n, { name: "x" });
-		expect(() => g.signal([[PAUSE, "p"]])).toThrow(GuardDenied);
-		g.set("x", 1, { actor: human });
-		expect(g.node("x").cache).toBe(1);
-	});
-
-	it("describe and observe respect observe action", () => {
-		const g = new Graph("g");
-		const secret = node([], {
-			name: "secret",
-			guard: policy((allow, deny) => {
-				allow("write");
-				allow("observe");
-				deny("observe", { where: (a) => a.type === "llm" });
-			}),
-			initial: 0,
-		});
-		g.add(secret, { name: "secret" });
-		const dLlm = g.describe({ actor: llm });
-		expect(dLlm.nodes.secret).toBeUndefined();
-		const dHuman = g.describe({ actor: human });
-		expect(dHuman.nodes.secret).toBeDefined();
-
-		expect(() => g.observe("secret", { actor: llm })).toThrow(GuardDenied);
-		const sub = g.observe("secret", { actor: human }).subscribe(() => {});
-		sub();
-	});
-
-	// Unit 6 / B.1: GraphDescribeOptions.actor accepts Actor | Node<Actor>.
-	it("describe({ actor: Node<Actor> }) static — unwraps current cache", () => {
-		const g = new Graph("g");
-		const secret = node([], {
-			name: "secret",
-			guard: policy((allow, deny) => {
-				allow("observe");
-				deny("observe", { where: (a) => a.type === "llm" });
-			}),
-			initial: 0,
-		});
-		g.add(secret, { name: "secret" });
-
-		const actorNode = node([], { name: "actor", initial: human });
-		actorNode.subscribe(() => undefined);
-
-		expect(g.describe({ actor: actorNode }).nodes.secret).toBeDefined();
-		actorNode.emit(llm);
-		expect(g.describe({ actor: actorNode }).nodes.secret).toBeUndefined();
-	});
-
-	it("describe({ reactive: true, actor: Node<Actor> }) re-derives when actor changes", () => {
-		const g = new Graph("g");
-		const secret = node([], {
-			name: "secret",
-			guard: policy((allow, deny) => {
-				allow("observe");
-				deny("observe", { where: (a) => a.type === "llm" });
-			}),
-			initial: 0,
-		});
-		g.add(secret, { name: "secret" });
-
-		const actorNode = node([], { name: "actor", initial: human });
-		actorNode.subscribe(() => undefined);
-
-		const handle = g.describe({ reactive: true, actor: actorNode });
-		const unsub = handle.node.subscribe(() => undefined);
-
-		// human can observe — secret visible.
-		expect((handle.node.cache as { nodes: Record<string, unknown> }).nodes.secret).toBeDefined();
-
-		// Switch actor; describe re-derives and the secret disappears.
-		actorNode.emit(llm);
-		expect((handle.node.cache as { nodes: Record<string, unknown> }).nodes.secret).toBeUndefined();
-
-		// Back to human — visible again.
-		actorNode.emit(human);
-		expect((handle.node.cache as { nodes: Record<string, unknown> }).nodes.secret).toBeDefined();
-
-		unsub();
-		handle.dispose();
-	});
-
-	it("describe({ reactive: true, actor: Node<Actor> }) reflects mixed actor + topology change in final state", () => {
-		const g = new Graph("g");
-		const secret = node([], {
-			name: "secret",
-			guard: policy((allow, deny) => {
-				allow("observe");
-				deny("observe", { where: (a) => a.type === "llm" });
-			}),
-			initial: 0,
-		});
-		g.add(secret, { name: "secret" });
-
-		const actorNode = node([], { name: "actor", initial: human });
-		actorNode.subscribe(() => undefined);
-
-		const handle = g.describe({ reactive: true, actor: actorNode });
-		const unsub = handle.node.subscribe(() => undefined);
-
-		// Final state must reflect BOTH the actor switch and the new topology.
-		batch(() => {
-			actorNode.emit(llm);
-			g.add(node([], { name: "b", initial: 1 }), { name: "b" });
-		});
-
-		const cache = handle.node.cache as { nodes: Record<string, unknown> };
-		expect(Object.keys(cache.nodes)).toContain("b");
-		expect(cache.nodes.secret).toBeUndefined(); // llm cannot observe secret
-
-		unsub();
-		handle.dispose();
-	});
-
-	it("describe({ reactive: true, actor: Node<Actor> }) cleans up actor subscription on dispose", () => {
-		const g = new Graph("g");
-		g.add(node([], { name: "a", initial: 0 }), { name: "a" });
-		const actorNode = node([], { name: "actor", initial: human });
-		actorNode.subscribe(() => undefined);
-
-		// Spy on the actor's subscribe so we can prove the unsubscribe really
-		// ran (the original test only asserted "no throw on post-dispose emit"
-		// — that would pass even if `actorUnsub?.()` were dropped in dispose).
-		const realSubscribe = actorNode.subscribe.bind(actorNode);
-		let unsubCalls = 0;
-		(actorNode as unknown as { subscribe: typeof actorNode.subscribe }).subscribe = ((
-			cb: Parameters<typeof actorNode.subscribe>[0],
-		) => {
-			const off = realSubscribe(cb);
-			return () => {
-				unsubCalls += 1;
-				off();
-			};
-		}) as typeof actorNode.subscribe;
-
-		const handle = g.describe({ reactive: true, actor: actorNode });
-		const unsub = handle.node.subscribe(() => undefined);
-
-		unsub();
-		handle.dispose();
-
-		// `actorUnsub?.()` must have run — proven by the spy on `subscribe`.
-		// The post-dispose emit must not re-enter the disposed handle.
-		expect(unsubCalls).toBeGreaterThanOrEqual(1);
-		expect(() => actorNode.emit(llm)).not.toThrow();
-	});
-
-	it("describe({ reactive: true, actor: Node<Actor> }) releases subscription on actor COMPLETE", () => {
-		const g = new Graph("g");
-		const secret = node([], {
-			name: "secret",
-			guard: policy((allow, deny) => {
-				allow("observe");
-				deny("observe", { where: (a) => a.type === "llm" });
-			}),
-			initial: 0,
-		});
-		g.add(secret, { name: "secret" });
-
-		const actorNode = node([], { name: "actor", initial: human });
-		actorNode.subscribe(() => undefined);
-
-		const realSubscribe = actorNode.subscribe.bind(actorNode);
-		let unsubCalls = 0;
-		(actorNode as unknown as { subscribe: typeof actorNode.subscribe }).subscribe = ((
-			cb: Parameters<typeof actorNode.subscribe>[0],
-		) => {
-			const off = realSubscribe(cb);
-			return () => {
-				unsubCalls += 1;
-				off();
-			};
-		}) as typeof actorNode.subscribe;
-
-		const handle = g.describe({ reactive: true, actor: actorNode });
-		const unsub = handle.node.subscribe(() => undefined);
-
-		// human can observe; secret visible.
-		expect((handle.node.cache as { nodes: Record<string, unknown> }).nodes.secret).toBeDefined();
-
-		// Actor terminates. Implementation must release the subscription and
-		// re-derive against the last-known cache (which is still `human`).
-		actorNode.down([[COMPLETE]]);
-		expect(unsubCalls).toBeGreaterThanOrEqual(1);
-		expect((handle.node.cache as { nodes: Record<string, unknown> }).nodes.secret).toBeDefined();
-
-		unsub();
-		handle.dispose();
-	});
-
-	it("observe() filters paths for actor", () => {
-		const g = new Graph("g");
-		const n = node([], {
-			name: "hidden",
-			guard: policy((allow, deny) => {
-				allow("observe");
-				deny("observe", { where: (a) => a.type === "llm" });
-			}),
-			initial: 0,
-		});
-		g.add(n, { name: "hidden" });
-		const paths: string[] = [];
-		const unsub = g.observe({ actor: llm }).subscribe((p) => {
-			paths.push(p);
-		});
-		unsub();
-		expect(paths.some((p) => p.startsWith("hidden"))).toBe(false);
-	});
-
-	it("lastMutation records actor on guarded write (timestamp_ns)", () => {
-		const n = node([], { guard: () => true, initial: 0 });
-		n.down([[DATA, 5]], { actor: human });
-		expect(n.lastMutation?.actor.type).toBe("human");
-		expect(typeof n.lastMutation?.timestamp_ns).toBe("number");
-		expect(n.lastMutation!.timestamp_ns).toBeGreaterThan(0);
-	});
-
-	it("subscribe checks observe guard when actor is passed", () => {
-		const n = node([], {
-			guard: policy((allow, deny) => {
-				allow("write");
-				allow("observe", { where: (a) => a.type === "human" });
-				deny("observe", { where: (a) => a.type === "llm" });
-			}),
-			initial: 0,
-		});
-		expect(() => n.subscribe(() => {}, llm)).toThrow(GuardDenied);
-		const unsub = n.subscribe(() => {}, human);
-		unsub();
-	});
-
-	it("internal TEARDOWN bypasses guard", () => {
-		const g = new Graph("g");
-		const n = node([], { guard: () => false, initial: 0 });
-		g.add(n, { name: "x" });
-		g.remove("x");
-		expect(true).toBe(true);
-	});
-
-	it("DEFAULT_ACTOR satisfies allow-all guard", () => {
-		const n = node([], {
-			guard: (a) => a.type === "system",
-			initial: 0,
-		});
-		n.down([[DATA, 1]]);
-		expect(n.cache).toBe(1);
-		expect(n.lastMutation?.actor).toEqual(DEFAULT_ACTOR);
-	});
-});
-
-describe("Graph Phase 1.6 — describe schema, observe streams, snapshot, signals, policy", () => {
-	const human = { type: "human" as const, id: "u1" };
-
-	it("describe() conforms to GRAPHREFLY-SPEC Appendix B (all node kinds)", () => {
-		const g = new Graph("app");
-		const a = node([], { name: "a", initial: 0 });
-		const b = node(
-			[a],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as number) + 1);
-			},
-			{ describeKind: "derived", name: "b" },
-		);
-		const p = node(() => {}, { describeKind: "producer", name: "p" });
-		const e = node(
-			[a],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				return (() => {})(data, actions, ctx) ?? undefined;
-			},
-			{ describeKind: "effect" },
-		);
-		g.add(a, { name: "a" });
-		g.add(b, { name: "b" });
-		g.add(p, { name: "p" });
-		g.add(e, { name: "e" });
-		assertDescribeMatchesAppendixB(g.describe({ detail: "standard" }));
-	});
-
-	it("describe() on nested mounts conforms to Appendix B", () => {
-		const root = new Graph("root");
-		const child = new Graph("ch");
-		const n = node([], { name: "n", initial: 0 });
-		child.add(n, { name: "n" });
-		root.mount("c", child);
-		assertDescribeMatchesAppendixB(root.describe({ detail: "standard" }));
-	});
-
-	it("observe(path) on state sees DATA when graph.set writes (DATA-only batch)", () => {
-		const g = new Graph("g");
-		const n = node([], { name: "n", initial: 0 });
-		g.add(n, { name: "n" });
-		const seq: symbol[] = [];
-		const off = g.observe("n").subscribe((msgs) => {
-			for (const m of msgs) seq.push(m[0] as symbol);
-		});
-		g.set("n", 1);
-		off();
-		expect(seq).toContain(DATA);
-		expect(g.node("n").cache).toBe(1);
-	});
-
-	it("observe(path) on derived sees DIRTY before DATA when upstream graph.set recomputes", () => {
-		const g = new Graph("g");
-		const a = node([], { name: "a", initial: 0 });
-		const b = node(
-			[a],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as number) + 1);
-			},
-			{ describeKind: "derived", name: "b" },
-		);
-		g.add(a, { name: "a" });
-		g.add(b, { name: "b" });
-		const seq: symbol[] = [];
-		const off = g.observe("b").subscribe((msgs) => {
-			for (const m of msgs) seq.push(m[0] as symbol);
-		});
-		g.set("a", 5);
-		const iDirty = seq.indexOf(DIRTY);
-		const iData = seq.indexOf(DATA);
-		expect(iDirty).toBeGreaterThanOrEqual(0);
-		expect(iData).toBeGreaterThan(iDirty);
-		expect(g.node("b").cache).toBe(6);
-		off();
-	});
-
-	it("snapshot survives JSON wire and restores nested mount values", () => {
-		const root0 = new Graph("app");
-		const child0 = new Graph("sub");
-		const n0 = node([], { name: "x", initial: 3 });
-		child0.add(n0, { name: "x" });
-		root0.mount("sub", child0);
-		const snap = root0.snapshot();
-		const wired = JSON.parse(JSON.stringify(snap)) as GraphPersistSnapshot;
-
-		const root1 = Graph.fromSnapshot(wired, (g) => {
-			const ch = new Graph("sub");
-			ch.add(node([], { name: "x", initial: 0 }), { name: "x" });
-			g.mount("sub", ch);
-		});
-		expect(root1.name).toBe("app");
-		expect(root1.node("sub::x").cache).toBe(3);
-	});
-
-	it("graph.signal reaches every mounted subgraph (sibling mounts)", () => {
-		const root = new Graph("root");
-		const c1 = new Graph("c1");
-		const c2 = new Graph("c2");
-		const n1 = node([], { name: "n1", initial: 0 });
-		const n2 = node([], { name: "n2", initial: 0 });
-		c1.add(n1, { name: "n1" });
-		c2.add(n2, { name: "n2" });
-		root.mount("m1", c1);
-		root.mount("m2", c2);
-		const pauses: string[] = [];
-		n1.subscribe((msgs) => {
-			for (const m of msgs) if (m[0] === PAUSE) pauses.push("n1");
-		});
-		n2.subscribe((msgs) => {
-			for (const m of msgs) if (m[0] === PAUSE) pauses.push("n2");
-		});
-		root.signal([[PAUSE, "k"]]);
-		expect(pauses.sort()).toEqual(["n1", "n2"]);
-	});
-
-	it("policy: deny wins when both allow and deny match the same actor and action", () => {
-		const g = policy((allow, deny) => {
-			allow("write", { where: (a) => a.type === "human" });
-			deny("write", { where: (a) => a.id === "u1" });
-		});
-		const n = node([], { guard: g, initial: 0 });
-		expect(g(human, "write")).toBe(false);
-		expect(g({ type: "human", id: "u2" }, "write")).toBe(true);
-		n.down([[DATA, 1]], { actor: { type: "human", id: "u2" } });
-		expect(n.cache).toBe(1);
-		expect(() => n.down([[DATA, 2]], { actor: human })).toThrow(GuardDenied);
-	});
-
-	it("policy: action wildcard * matches any GuardAction", () => {
-		const g = policy((allow, _deny) => {
-			allow("*", { where: (a) => a.type === "wallet" });
-		});
-		const w = { type: "wallet" as const, id: "w1" };
-		expect(g(w, "write")).toBe(true);
-		expect(g(w, "signal")).toBe(true);
-		expect(g(w, "observe")).toBe(true);
-		expect(g(human, "write")).toBe(false);
-	});
-
-	it("policy: composed guards require both policies to allow", () => {
-		const p1 = policy((allow, _deny) => {
-			allow("write", { where: (a) => a.type === "human" });
-		});
-		const p2 = policy((allow, _deny) => {
-			allow("write", { where: (a) => a.id === "u1" });
-		});
-		const both = (a: Parameters<typeof p1>[0], act: Parameters<typeof p1>[1]) =>
-			p1(a, act) && p2(a, act);
-		const n = node([], { guard: both, initial: 0 });
-		n.down([[DATA, 9]], { actor: human });
-		expect(n.cache).toBe(9);
-		expect(() => n.down([[DATA, 0]], { actor: { type: "human", id: "other" } })).toThrow(
-			GuardDenied,
-		);
-	});
-
-	it("policy: default is deny when no rule matches", () => {
-		const g = policy((allow, _deny) => {
-			allow("write", { where: (a) => a.type === "system" });
-		});
-		expect(g(human, "write")).toBe(false);
-	});
-
-	it("graph.set records lastMutation with actor", () => {
-		const g = new Graph("g");
-		const n = node([], { name: "n", guard: () => true, initial: 0 });
-		g.add(n, { name: "n" });
-		g.set("n", 5, { actor: human });
-		expect(n.lastMutation?.actor.type).toBe("human");
-		expect(n.lastMutation?.actor.id).toBe("u1");
-		expect(typeof n.lastMutation?.timestamp_ns).toBe("number");
-	});
-
-	it("observe() whole-graph delivers qualified paths for mounted nodes", () => {
-		const g = new Graph("g");
-		const child = new Graph("ch");
-		const n = node([], { name: "n", initial: 0 });
-		child.add(n, { name: "n" });
-		g.mount("sub", child);
-		const paths: string[] = [];
-		const unsub = g.observe().subscribe((path) => {
-			paths.push(path);
-		});
-		g.set("sub::n", 1);
-		unsub();
-		expect(paths).toContain("sub::n");
-	});
-
-	it("restore rejects snapshot with wrong version", () => {
-		const g = new Graph("g");
-		g.add(node([], { initial: 0 }), { name: "x" });
-		const snap = g.snapshot();
-		(snap as Record<string, unknown>).version = 99;
-		expect(() => g.restore(snap)).toThrow(/version/);
-	});
-
-	it("restore rejects snapshot missing required keys", () => {
-		const g = new Graph("g");
-		expect(() => g.restore({ name: "g", version: 1 } as GraphPersistSnapshot)).toThrow(
-			/required key/,
-		);
-	});
-
-	it("fromSnapshot without build rejects edges", () => {
-		const g = new Graph("g");
-		const a = node([], { name: "a", initial: 1 });
-		const b = node(
-			[a],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as number) * 2);
-			},
-			{ describeKind: "derived", name: "b" },
-		);
-		g.add(a, { name: "a" });
-		g.add(b, { name: "b" });
-		const snap = g.snapshot();
-		expect(() => Graph.fromSnapshot(snap)).toThrow(/could not reconstruct/);
-	});
-
-	it("fromSnapshot without build rejects non-state nodes", () => {
-		const snap: GraphPersistSnapshot = {
-			version: 1,
-			name: "g",
-			nodes: { x: { type: "derived", status: "settled", deps: [], meta: {} } },
-			edges: [],
-			subgraphs: [],
-		};
-		expect(() => Graph.fromSnapshot(snap)).toThrow(/could not reconstruct/);
-	});
-
-	it("fromSnapshot without build auto-creates mounts and state nodes", () => {
-		const root = new Graph("app");
-		const child = new Graph("sub");
-		child.add(node([], { name: "x", initial: 42 }), { name: "x" });
-		root.mount("sub", child);
-		const snap = root.snapshot();
-		const wired = JSON.parse(JSON.stringify(snap)) as GraphPersistSnapshot;
-		const restored = Graph.fromSnapshot(wired);
-		expect(restored.name).toBe("app");
-		expect(restored.node("sub::x").cache).toBe(42);
-	});
-});
-
-// ---------------------------------------------------------------------------
-// Phase 3.3b — Progressive disclosure for describe() and observe()
-// ---------------------------------------------------------------------------
-
-describe("describe() detail levels (3.3b)", () => {
-	function makeGraph() {
-		const g = new Graph("test-detail");
-		const a = node([], { name: "a", meta: { description: "source", access: "both" }, initial: 10 });
-		const b = node(
-			[a],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit(data * 2);
-			},
-			{ describeKind: "derived", name: "b" },
-		);
-		g.add(a, { name: "a" });
-		g.add(b, { name: "b" });
-		return { g, a, b };
-	}
-
-	it("default (minimal) returns only type and deps", () => {
-		const { g } = makeGraph();
-		const d = g.describe();
-		const nodeA = d.nodes.a!;
-		expect(nodeA.type).toBe("state");
-		expect(nodeA.deps).toEqual([]);
-		expect(nodeA.status).toBeUndefined();
-		expect(nodeA.value).toBeUndefined();
-		expect(nodeA.meta).toBeUndefined();
-		expect(nodeA.v).toBeUndefined();
-
-		const nodeB = d.nodes.b!;
-		expect(nodeB.type).toBe("derived");
-		expect(nodeB.deps).toEqual(["a"]);
-		expect(nodeB.status).toBeUndefined();
-		g.destroy();
-	});
-
-	it('detail: "standard" includes type, status, value, deps, meta', () => {
-		const { g, b } = makeGraph();
-		// Subscribe to b so it connects and settles
-		const unsub = b.subscribe(() => {});
-		const d = g.describe({ detail: "standard" });
-		const nodeA = d.nodes.a!;
-		expect(nodeA.type).toBe("state");
-		expect(nodeA.status).toBe("settled");
-		expect(nodeA.value).toBe(10);
-		expect(nodeA.meta).toEqual(expect.objectContaining({ description: "source" }));
-		expect(nodeA.v).toBeUndefined(); // no versioning
-
-		const nodeB = d.nodes.b!;
-		expect(nodeB.status).toBe("settled");
-		expect(nodeB.value).toBe(20);
-		unsub();
-		g.destroy();
-	});
-
-	it('detail: "full" includes standard + versioning + guard + lastMutation', () => {
-		const tester = { type: "human", name: "tester" };
-		const g = new Graph("full-detail");
-		const a = node([], {
-			name: "a",
-			versioning: 0,
-			guard: policy((allow) => {
-				allow("write");
-				allow("observe");
-			}),
-			meta: { description: "guarded" },
-			initial: 5,
-		});
-		g.add(a, { name: "a" });
-		// Trigger a mutation with actor to populate lastMutation
-		a.down([[DATA, 6]], { actor: tester });
-
-		const d = g.describe({ detail: "full" });
-		const nodeA = d.nodes.a!;
-		expect(nodeA.type).toBe("state");
-		expect(nodeA.status).toBe("settled");
-		expect(nodeA.value).toBe(6);
-		expect(nodeA.v).toBeDefined();
-		expect(nodeA.v!.version).toBeGreaterThanOrEqual(1);
-		expect(nodeA.guard).toBeDefined();
-		expect(nodeA.lastMutation).toBeDefined();
-		expect((nodeA.lastMutation!.actor as { name: string }).name).toBe("tester");
-		g.destroy();
-	});
-});
-
-describe("describe() field selection (3.3b)", () => {
-	it("fields override detail level", () => {
-		const g = new Graph("fields");
-		g.add(node([], { name: "x", meta: { label: "X", extra: "e" }, initial: 42 }), { name: "x" });
-
-		const d = g.describe({ fields: ["type", "status"] });
-		const x = d.nodes.x!;
-		expect(x.type).toBe("state");
-		expect(x.status).toBe("settled");
-		expect(x.value).toBeUndefined();
-		expect(x.meta).toBeUndefined();
-		g.destroy();
-	});
-
-	it("dotted meta path selects specific meta keys", () => {
-		const g = new Graph("meta-dot");
-		g.add(node([], { name: "x", meta: { label: "L", secret: "S", extra: "E" }, initial: 1 }), {
-			name: "x",
-		});
-
-		const d = g.describe({ fields: ["type", "meta.label"] });
-		const x = d.nodes.x!;
-		expect(x.type).toBe("state");
-		expect(x.meta).toEqual({ label: "L" });
-		expect(x.value).toBeUndefined();
-		g.destroy();
-	});
-
-	it("rejects mixing detail and fields (qa A6 — pass either, not both)", () => {
-		const g = new Graph("precedence");
-		g.add(node([], { name: "x", initial: 1 }), { name: "x" });
-
-		// Mixing detail+fields was permissive but produced ambiguous spec-mode
-		// semantics (e.g. `{detail: "spec", fields: [...]}` had specMode=true
-		// with non-spec field projection). Pre-1.0: reject the mix outright.
-		expect(() => g.describe({ detail: "full", fields: ["type"] })).toThrow(
-			/pass either `detail` or `fields`/,
-		);
-		g.destroy();
-	});
-});
-
-describe("describe() detail: minimal", () => {
-	it("returns minimal type + deps output usable by compileSpec", () => {
-		// Tier 2.1 A2: ex-`format: "spec"` was an alias for the minimal
-		// projection (type + deps only). The richer `detail: "spec"` projection
-		// (type + deps + meta) lives in `core/meta.ts` `resolveDescribeFields`.
-		const g = new Graph("spec-format");
-		const a = node([], { name: "a", meta: { description: "src" }, initial: 1 });
-		const b = node(
-			[a],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit(data + 1);
-			},
-			{ describeKind: "derived", name: "b" },
-		);
-		g.add(a, { name: "a" });
-		g.add(b, { name: "b" });
-
-		const d = g.describe({ detail: "minimal" });
-		expect(d.nodes.a!.type).toBe("state");
-		expect(d.nodes.a!.status).toBeUndefined();
-		expect(d.nodes.a!.value).toBeUndefined();
-		expect(d.nodes.a!.meta).toBeUndefined();
-
-		expect(d.nodes.b!.type).toBe("derived");
-		expect(d.nodes.b!.deps).toEqual(["a"]);
-		g.destroy();
-	});
-});
-
-describe("describe() expand() (3.3b)", () => {
-	it("expand from minimal to standard re-reads live graph", () => {
-		const g = new Graph("expand");
-		const a = node([], { name: "a", meta: { label: "A" }, initial: 1 });
-		g.add(a, { name: "a" });
-
-		const minimal = g.describe();
-		expect(minimal.nodes.a!.value).toBeUndefined();
-
-		// Mutate between describe and expand
-		g.set("a", 99);
-
-		const expanded = minimal.expand!("standard");
-		expect(expanded.nodes.a!.value).toBe(99); // live re-read
-		expect(expanded.nodes.a!.status).toBe("settled");
-		expect(expanded.nodes.a!.meta).toEqual(expect.objectContaining({ label: "A" }));
-		g.destroy();
-	});
-
-	it("expand with field array", () => {
-		const g = new Graph("expand-fields");
-		g.add(node([], { name: "x", initial: 5 }), { name: "x" });
-
-		const d = g.describe();
-		const expanded = d.expand!(["type", "value"]);
-		expect(expanded.nodes.x!.value).toBe(5);
-		expect(expanded.nodes.x!.status).toBeUndefined();
-		g.destroy();
-	});
-});
-
-describe("observe() detail levels (3.3b)", () => {
-	it('detail: "minimal" only includes DATA events', () => {
-		Graph.inspectorEnabled = true;
-		const g = new Graph("obs-min");
-		const a = node([], { name: "a", initial: 1 });
-		const b = node(
-			[a],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit(data * 2);
-			},
-			{ describeKind: "derived", name: "b" },
-		);
-		g.add(a, { name: "a" });
-		g.add(b, { name: "b" });
-
-		const obs = g.observe("b", { detail: "minimal" }) as ObserveResult;
-		// Initial DATA from subscription connect + update DATA
-		g.set("a", 2);
-
-		// All events should be DATA only — no DIRTY/RESOLVED
-		expect(obs.events.every((e) => e.type === "data")).toBe(true);
-		expect(obs.events.filter((e) => e.type === "dirty")).toHaveLength(0);
-		// But dirtyCount is still tracked internally
-		expect(obs.dirtyCount).toBeGreaterThanOrEqual(1);
-		expect(obs.values.b).toBe(4);
-		obs.dispose();
-		g.destroy();
-		Graph.inspectorEnabled = false;
-	});
-
-	it('detail: "full" enables timeline + causal + derived', () => {
-		Graph.inspectorEnabled = true;
-		const g = new Graph("obs-full");
-		const a = node([], { name: "a", initial: 10 });
-		const b = node(
-			[a],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data as number) * 2);
-			},
-			{ describeKind: "derived", name: "b" },
-		);
-		g.add(a, { name: "a" });
-		g.add(b, { name: "b" });
-
-		const obs = g.observe("b", { detail: "full" }) as ObserveResult;
-		// Initial DATA on subscribe; trigger an update with causal info
-		g.set("a", 20);
-
-		// Find the DATA event from the update (last DATA has the post-update value)
-		const dataEvents = obs.events.filter((e) => e.type === "data");
-		expect(dataEvents.length).toBeGreaterThanOrEqual(2); // initial + update
-		const lastData = dataEvents[dataEvents.length - 1]!;
-		expect(lastData.data).toBe(40); // 20 * 2
-		expect(lastData.timestamp_ns).toBeDefined(); // timeline
-		expect(lastData.trigger_dep_name).toBe("a"); // causal
-
-		const derivedEvts = obs.events.filter((e) => e.type === "derived");
-		expect(derivedEvts.length).toBeGreaterThanOrEqual(1); // derived
-		const lastDerived = derivedEvts[derivedEvts.length - 1]!;
-		expect(lastDerived.dep_values).toEqual([20]);
-		obs.dispose();
-		g.destroy();
-		Graph.inspectorEnabled = false;
-	});
-
-	it('graph-wide detail: "minimal" filters non-DATA events', () => {
-		Graph.inspectorEnabled = true;
-		const g = new Graph("obs-all-min");
-		const a = node([], { name: "a", initial: 1 });
-		const b = node(
-			[a],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit(data);
-			},
-			{ describeKind: "derived", name: "b" },
-		);
-		g.add(a, { name: "a" });
-		g.add(b, { name: "b" });
-
-		const obs = g.observe({ detail: "minimal" }) as ObserveResult;
-		g.set("a", 2);
-
-		expect(obs.events.every((e) => e.type === "data")).toBe(true);
-		expect(obs.dirtyCount).toBeGreaterThanOrEqual(1);
-		obs.dispose();
-		g.destroy();
-		Graph.inspectorEnabled = false;
-	});
-});
-
-describe("observe() expand() (3.3b)", () => {
-	it("expand upgrades observation from minimal to full", () => {
-		Graph.inspectorEnabled = true;
-		const g = new Graph("obs-expand");
-		const a = node([], { name: "a", initial: 1 });
-		const b = node(
-			[a],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit(data + 10);
-			},
-			{ describeKind: "derived", name: "b" },
-		);
-		g.add(a, { name: "a" });
-		g.add(b, { name: "b" });
-
-		const minimal = g.observe("b", { detail: "minimal" }) as ObserveResult;
-		g.set("a", 2);
-		expect(minimal.events.filter((e) => e.type === "dirty")).toHaveLength(0);
-
-		// Expand to full — disposes old, creates new subscription
-		const full = minimal.expand("full");
-		// Clear push-on-subscribe events so we only see the dep-triggered update
-		full.events.length = 0;
-		g.set("a", 3);
-
-		const dataEvt = full.events.find((e) => e.type === "data");
-		expect(dataEvt).toBeDefined();
-		expect(dataEvt!.timestamp_ns).toBeDefined();
-		expect(dataEvt!.trigger_dep_name).toBe("a");
-		full.dispose();
-		g.destroy();
-		Graph.inspectorEnabled = false;
-	});
-});
-
-describe("observe() tier-surfacing variants", () => {
-	it("surfaces INVALIDATE events with counter", () => {
-		const g = new Graph("obs-inv");
-		g.add(node([], { name: "a", initial: 1 }), { name: "a" });
-		const obs = g.observe("a", { structured: true }) as ObserveResult;
-		obs.events.length = 0;
-		g.invalidate("a");
-		obs.dispose();
-		expect(obs.events.some((e) => e.type === "invalidate" && e.path === "a")).toBe(true);
-		expect(obs.invalidateCount).toBe(1);
-	});
-
-	it("surfaces PAUSE and RESUME events with lockId payload", () => {
-		const g = new Graph("obs-pr");
-		g.add(node([], { name: "a", initial: 1 }), { name: "a" });
-		const obs = g.observe("a", { structured: true }) as ObserveResult;
-		obs.events.length = 0;
-		g.node("a").down([[PAUSE, "lock-1"]], { internal: true });
-		g.node("a").down([[RESUME, "lock-1"]], { internal: true });
-		obs.dispose();
-		const pause = obs.events.find((e) => e.type === "pause");
-		const resume = obs.events.find((e) => e.type === "resume");
-		expect(pause).toBeDefined();
-		expect(resume).toBeDefined();
-		expect((pause as { lockId: unknown }).lockId).toBe("lock-1");
-		expect((resume as { lockId: unknown }).lockId).toBe("lock-1");
-		expect(obs.pauseCount).toBe(1);
-		expect(obs.resumeCount).toBe(1);
-	});
-
-	it("surfaces TEARDOWN when graph.destroy() runs", () => {
-		const g = new Graph("obs-td");
-		g.add(node([], { name: "a", initial: 1 }), { name: "a" });
-		const obs = g.observe("a", { structured: true }) as ObserveResult;
-		obs.events.length = 0;
-		g.destroy();
-		expect(obs.events.some((e) => e.type === "teardown" && e.path === "a")).toBe(true);
-		expect(obs.teardownCount).toBe(1);
-		obs.dispose();
-	});
-
-	it('detail: "minimal" bumps new counters without emitting events', () => {
-		const g = new Graph("obs-min-new");
-		g.add(node([], { name: "a", initial: 1 }), { name: "a" });
-		const obs = g.observe("a", { detail: "minimal" }) as ObserveResult;
-		obs.events.length = 0;
-		g.invalidate("a");
-		g.node("a").down([[PAUSE, "l"]], { internal: true });
-		g.node("a").down([[RESUME, "l"]], { internal: true });
-		obs.dispose();
-		expect(obs.events.every((e) => e.type === "data")).toBe(true);
-		expect(obs.invalidateCount).toBe(1);
-		expect(obs.pauseCount).toBe(1);
-		expect(obs.resumeCount).toBe(1);
-	});
-
-	it("pretty format renders lockId for pause/resume", () => {
-		const g = new Graph("obs-fmt");
-		g.add(node([], { name: "a", initial: 1 }), { name: "a" });
-		const lines: string[] = [];
-		const obs = g.observe("a", {
-			format: "pretty",
-			theme: "none",
-			includeTypes: ["pause", "resume", "invalidate", "teardown"],
-			logger: (line) => lines.push(line),
-		}) as ObserveResult;
-		g.invalidate("a");
-		g.node("a").down([[PAUSE, "lk"]], { internal: true });
-		g.node("a").down([[RESUME, "lk"]], { internal: true });
-		obs.dispose();
-		expect(lines.some((l) => l.includes("INVALIDATE"))).toBe(true);
-		expect(lines.some((l) => l.includes("PAUSE") && l.includes('"lk"'))).toBe(true);
-		expect(lines.some((l) => l.includes("RESUME") && l.includes('"lk"'))).toBe(true);
-	});
-});
-
-// ——————————————————————————————————————————————————————————————
-//  Narrow-waist API: graph.derived / graph.effect / graph.state / graph.producer / graph.batch
-//  See archive/docs/SESSION-graph-narrow-waist.md (P1–P3 Bundle 1 spot tests).
-// ——————————————————————————————————————————————————————————————
-
-describe("Graph narrow-waist — graph.batch", () => {
-	it("coalesces multiple writes into one downstream wave", async () => {
-		const g = new Graph("nw-batch");
-		g.add(node<number>([], { name: "a", initial: undefined }), { name: "a" });
-		g.add(node<number>([], { name: "b", initial: undefined }), { name: "b" });
-		const out = g.derived("sum", ["a", "b"], (data, ctx) => {
-			const [x, y] = latestVals(data, ctx);
-			return [(x as number) + (y as number)];
-		});
-		const dataEvents: number[] = [];
-		out.subscribe((msgs) => {
-			for (const m of msgs) if (m[0] === DATA) dataEvents.push(m[1] as number);
-		});
-		g.batch(() => {
-			g.set("a", 1);
-			g.set("b", 2);
-		});
-		expect(dataEvents).toEqual([3]);
-	});
-
-	it("nested graph.batch coalesces to one downstream wave", () => {
-		const g = new Graph("nw-batch-nest");
-		g.add(node([], { name: "a", initial: 0 }), { name: "a" });
-		const out = g.derived("twice", ["a"], (data, ctx) => {
-			const [x] = latestVals(data, ctx);
-			return [(x as number) * 2];
-		});
-		const dataEvents: number[] = [];
-		out.subscribe((msgs) => {
-			for (const m of msgs) if (m[0] === DATA) dataEvents.push(m[1] as number);
-		});
-		const before = dataEvents.length;
-		g.batch(() => {
-			g.set("a", 1);
-			g.batch(() => g.set("a", 5));
-			g.set("a", 10);
-		});
-		// Three writes, one outer batch → exactly one new DATA wave downstream
-		// (not three). The final value wins at `a` via equals/dedup, propagated
-		// through `out` as `20`.
-		expect(dataEvents.length - before).toBe(1);
-		expect(dataEvents.at(-1)).toBe(20);
-	});
-
-	// P11.5-D2: P8 (`graph-derived-multi-emit-array-semantics`) pins the fn
-	// RETURNING a multi-emit array. This pins the complementary RECEIVING
-	// side: when an upstream emits TWO distinct DATA in one batch wave, the
-	// `graph.derived` fn sees the dep slot as the full per-wave batch
-	// `data[0] = [1, 2]` (raw), while `latestVals` collapses it to the last
-	// value `2`. A regression that pre-collapsed the dep slot before the fn
-	// (or dropped the first emit) would change `rawDepSlot` to `[2]`/`2`.
-	it("P11.5-D2 — derived fn RECEIVES upstream multi-emit as the full data[0] batch", () => {
-		const g = new Graph("nw-multiemit-receive");
-		// Raw source (not a state node — distinct values 1≠2 are not
-		// equals-absorbed, so both survive the batch as a multi-message wave).
-		const src = node<number>([], { name: "src" });
-		g.add(src, { name: "src" });
-		let rawDepSlot: unknown;
-		let collapsed: unknown;
-		const out = g.derived<number>("recv", ["src"], (data, ctx) => {
-			rawDepSlot = data[0];
-			[collapsed] = latestVals(data, ctx);
-			return [collapsed as number];
-		});
-		out.subscribe(() => undefined);
-		g.batch(() => {
-			src.emit(1);
-			src.emit(2);
-		});
-		// The fn sees the entire per-wave batch for the dep slot, in order.
-		expect(rawDepSlot).toEqual([1, 2]);
-		// `latestVals` is the documented collapse-to-last helper.
-		expect(collapsed).toBe(2);
-		g.destroy();
-	});
-});
-
-describe("Graph narrow-waist — graph.derived (P1 SENTINEL absorption)", () => {
-	it("fn does NOT fire until every dep has delivered real DATA", () => {
-		const g = new Graph("nw-derived-sentinel");
-		// Sentinel form: node<T>([]) with no initial leaves the node in "sentinel".
-		g.add(node<number>([], { name: "a", initial: undefined }), { name: "a" });
-		g.add(node<number>([], { name: "b", initial: undefined }), { name: "b" });
-		let fnCalls = 0;
-		const out = g.derived("sum", ["a", "b"], (data, ctx) => {
-			fnCalls += 1;
-			const [x, y] = latestVals(data, ctx);
-			return [(x as number) + (y as number)];
-		});
-		const dataEvents: number[] = [];
-		out.subscribe((msgs) => {
-			for (const m of msgs) if (m[0] === DATA) dataEvents.push(m[1] as number);
-		});
-		// Subscription alone with two sentinel deps must NOT fire fn.
-		expect(fnCalls).toBe(0);
-		expect(dataEvents).toEqual([]);
-		// Settling only one dep must NOT fire fn.
-		g.set("a", 1);
-		expect(fnCalls).toBe(0);
-		// Settling the second dep releases the gate.
-		g.set("b", 2);
-		expect(fnCalls).toBe(1);
-		expect(dataEvents).toEqual([3]);
-	});
-
-	it("null is a real DATA value and releases the gate", () => {
-		const g = new Graph("nw-derived-null");
-		g.add(node<number | null>([], { name: "a", initial: undefined }), { name: "a" });
-		let saw: unknown = "untouched";
-		const out = g.derived("identity", ["a"], (data, ctx) => {
-			const [x] = latestVals(data, ctx);
-			saw = x;
-			return [x as number | null];
-		});
-		out.subscribe(() => {});
-		expect(saw).toBe("untouched");
-		g.set("a", null);
-		expect(saw).toBe(null);
-	});
-
-	it("empty depPaths fires once on activation", () => {
-		const g = new Graph("nw-derived-empty");
-		const out = g.derived("k", [], () => [42]);
-		const events: number[] = [];
-		out.subscribe((msgs) => {
-			for (const m of msgs) if (m[0] === DATA) events.push(m[1] as number);
-		});
-		expect(events).toEqual([42]);
-	});
-
-	it("registers under the supplied name and exposes describe edges", () => {
-		const g = new Graph("nw-derived-describe");
-		g.add(node([], { name: "a", initial: 1 }), { name: "a" });
-		const out = g.derived("doubled", ["a"], (data, ctx) => {
-			const [x] = latestVals(data, ctx);
-			return [(x as number) * 2];
-		});
-		out.subscribe(() => {});
-		const desc = g.describe();
-		expect(Object.keys(desc.nodes)).toContain("doubled");
-		expect(desc.edges).toContainEqual({ from: "a", to: "doubled" });
-	});
-
-	it("forwards equals + initial + meta + annotation through to the underlying primitive", () => {
-		const g = new Graph("nw-derived-opts");
-		g.add(node([], { name: "a", initial: 0 }), { name: "a" });
-		const out = g.derived(
-			"n",
-			["a"],
-			(data, ctx) => {
-				const [x] = latestVals(data, ctx);
-				return [(x as number) + 1];
-			},
-			{
-				equals: (l, r) => l === r,
-				initial: 99,
-				meta: { domain: "test" },
-				annotation: "doubled+1",
-			},
-		);
-		expect(out.cache).toBe(99);
-		expect(g.annotation("n")).toBe("doubled+1");
-		const desc = g.describe({ detail: "standard" });
-		expect((desc.nodes.n?.meta as { domain?: string } | undefined)?.domain).toBe("test");
-	});
-});
-
-describe("Graph narrow-waist — graph.derived (P2 keepAlive consistency)", () => {
-	it("keepAlive: false (default) → cache stays sentinel until external subscribe", () => {
-		const g = new Graph("nw-keepalive-off");
-		g.add(node([], { name: "a", initial: 1 }), { name: "a" });
-		const out = g.derived("n", ["a"], (data, ctx) => {
-			const [x] = latestVals(data, ctx);
-			return [(x as number) * 10];
-		});
-		// No keepalive, no subscriber → derived stays inactive, cache is sentinel.
-		expect(out.cache).toBeUndefined();
-	});
-
-	it("keepAlive: true → cache populated immediately and tracks upstream", () => {
-		const g = new Graph("nw-keepalive-on");
-		g.add(node([], { name: "a", initial: 1 }), { name: "a" });
-		const out = g.derived(
-			"n",
-			["a"],
-			(data, ctx) => {
-				const [x] = latestVals(data, ctx);
-				return [(x as number) * 10];
-			},
-			{ keepAlive: true },
-		);
-		expect(out.cache).toBe(10);
-		g.set("a", 7);
-		expect(out.cache).toBe(70);
-	});
-
-	it("keepAlive keeps cache current for EXTERNAL consumers (UI / debug / audit)", () => {
-		// The supported use of keepAlive: external code reads `.cache` without
-		// having to manage its own subscription. Reactive fns must NOT read
-		// .cache from another node (spec §5.12) — declare it as a real dep
-		// instead. See the next test.
-		const g = new Graph("nw-keepalive-external");
-		g.add(node([], { name: "value", initial: 5 }), { name: "value" });
-		const doubled = g.derived(
-			"doubled",
-			["value"],
-			(data, ctx) => {
-				const [v] = latestVals(data, ctx);
-				return [(v as number) * 2];
-			},
-			{
-				keepAlive: true,
-			},
-		);
-		// External (non-reactive) consumer reads .cache directly.
-		expect(doubled.cache).toBe(10);
-		g.set("value", 7);
-		expect(doubled.cache).toBe(14);
-		g.set("value", 100);
-		expect(doubled.cache).toBe(200);
-	});
-
-	it("multi-dep derived composes via real edges (no .cache reads from inside fn)", () => {
-		// The §5.12-correct alternative to "trigger × latest.cache". Both inputs
-		// are real deps; the edge appears in describe(); the message protocol
-		// carries the values. Re-fires when EITHER dep updates.
-		const g = new Graph("nw-derived-composition");
-		g.add(node([], { name: "trigger", initial: 2 }), { name: "trigger" });
-		g.add(node([], { name: "value", initial: 5 }), { name: "value" });
-		const out = g.derived("combined", ["trigger", "value"], (data, ctx) => {
-			const [t, v] = latestVals(data, ctx);
-			return [(t as number) * (v as number)];
-		});
-		const seen: number[] = [];
-		out.subscribe((msgs) => {
-			for (const m of msgs) if (m[0] === DATA) seen.push(m[1] as number);
-		});
-		expect(seen).toEqual([10]);
-		g.set("value", 100);
-		expect(seen.at(-1)).toBe(200);
-		// Edge "value -> combined" is visible in describe().
-		const desc = g.describe();
-		expect(desc.edges).toContainEqual({ from: "value", to: "combined" });
-	});
-});
-
-describe("Graph narrow-waist — graph.derived (P3 disposal completeness)", () => {
-	it("graph.destroy() severs the keepAlive subscription on upstream", () => {
-		const g = new Graph("nw-keepalive-dispose");
-		const a = node([], { name: "a", initial: 1 });
-		g.add(a, { name: "a" });
-		let fnCalls = 0;
-		g.derived(
-			"n",
-			["a"],
-			(data, ctx) => {
-				const [x] = latestVals(data, ctx);
-				fnCalls += 1;
-				return [(x as number) * 10];
-			},
-			{ keepAlive: true },
-		);
-		const callsBeforeDestroy = fnCalls;
-		expect(callsBeforeDestroy).toBeGreaterThan(0);
-		g.destroy();
-		// After destroy, the keepAlive disposer must have unsubscribed from
-		// `a`. If it hadn't, this push would re-fire fn and bump the count.
-		a.emit(2);
-		expect(fnCalls).toBe(callsBeforeDestroy);
-	});
-
-	it("two derived with keepAlive on the same graph both get torn down", () => {
-		const g = new Graph("nw-keepalive-many");
-		g.add(node([], { name: "a", initial: 1 }), { name: "a" });
-		g.derived(
-			"x",
-			["a"],
-			(data, ctx) => {
-				const [v] = latestVals(data, ctx);
-				return [v as number];
-			},
-			{ keepAlive: true },
-		);
-		g.derived(
-			"y",
-			["a"],
-			(data, ctx) => {
-				const [v] = latestVals(data, ctx);
-				return [(v as number) + 1];
-			},
-			{ keepAlive: true },
-		);
-		expect(g.node("x").cache).toBe(1);
-		expect(g.node("y").cache).toBe(2);
-		// destroy() must not throw with multiple keepalive disposers registered.
-		expect(() => g.destroy()).not.toThrow();
-	});
-
-	it("keepAlive disposer self-prunes on graph.remove(name) (qa B3)", () => {
-		// Repeated remove/recreate cycles must not accumulate stale disposers
-		// in the graph's `_disposers` set. The keepalive sink watches for
-		// TEARDOWN on its node and removes its own disposer entry.
-		const g = new Graph("nw-keepalive-selfprune") as Graph & {
-			_disposers: Set<() => void>;
-		};
-		g.add(node([], { name: "a", initial: 1 }), { name: "a" });
-		const before = g._disposers.size;
-		for (let i = 0; i < 10; i++) {
-			g.derived(
-				`n${i}`,
-				["a"],
-				(data, ctx) => {
-					const [v] = latestVals(data, ctx);
-					return [v as number];
-				},
-				{ keepAlive: true },
-			);
-			g.remove(`n${i}`);
-		}
-		// All 10 keepAlive disposers must have self-pruned via the TEARDOWN sent
-		// by graph.remove. _disposers should NOT grow by 10.
-		expect(g._disposers.size).toBe(before);
-	});
-});
-
-describe("Graph narrow-waist — graph.derived/effect mixed (string | Node) deps", () => {
-	it("graph.derived accepts mixed (string | Node) deps and reacts to emissions on both", () => {
-		const g = new Graph("nw-mixed-deps");
-		// Path-resolved dep — registered on the graph.
-		g.add(node<number>([], { name: "a", initial: 1 }), { name: "a" });
-		// External Node ref — NOT registered on this graph (mirrors the
-		// `reactiveLog().entries` cqrs case at src/utils/cqrs/index.ts:584/635
-		// where the entries node is an internal substrate).
-		const external = node<number>([], { name: "external", initial: 10 });
-
-		const seen: Array<readonly number[]> = [];
-		const out = g.derived<number>("sum", ["a", external], (data, ctx) => {
-			const [va, vb] = latestVals(data, ctx) as [number, number];
-			return [va + vb];
-		});
-		out.subscribe((msgs) => {
-			for (const m of msgs) {
-				if (m[0] === DATA) seen.push([m[1] as number]);
-			}
-		});
-		// Initial activation pushes both deps' caches → sum = 11.
-		expect(seen.flat()).toEqual([11]);
-
-		// Emission on the path-resolved dep flows through.
-		g.set("a", 2);
-		expect(seen.flat()).toEqual([11, 12]);
-
-		// Emission on the external Node ref also flows through (registered as
-		// a dep at construction even without graph mounting).
-		external.emit(20);
-		expect(seen.flat()).toEqual([11, 12, 22]);
-
-		// `out` is registered under `sum` on this graph.
-		expect(g.node("sum")).toBe(out);
-
-		g.destroy();
-	});
-
-	it("graph.effect accepts mixed (string | Node) deps and fires on both", () => {
-		const g = new Graph("nw-mixed-deps-effect");
-		g.add(node<number>([], { name: "a", initial: 1 }), { name: "a" });
-		const external = node<number>([], { name: "external", initial: 100 });
-
-		const calls: Array<[number, number]> = [];
-		const fx = g.effect("logger", ["a", external], (data, _up, ctx) => {
-			const [va, vb] = latestVals(data, ctx) as [number, number];
-			calls.push([va, vb]);
-		});
-		fx.subscribe(() => {});
-
-		// Initial activation fires once with both deps' caches.
-		expect(calls).toEqual([[1, 100]]);
-
-		g.set("a", 2);
-		expect(calls).toEqual([
-			[1, 100],
-			[2, 100],
-		]);
-
-		external.emit(200);
-		expect(calls).toEqual([
-			[1, 100],
-			[2, 100],
-			[2, 200],
-		]);
-
-		g.destroy();
-	});
-
-	it("graph.derived with all-Node deps still resolves and registers on the graph", () => {
-		// The `event` cqrs site shape: a single external Node ref, no string paths.
-		const g = new Graph("nw-all-node-deps");
-		const ext = node<number>([], { name: "ext", initial: 7 });
-		const out = g.derived<number>("doubled", [ext], (data, ctx) => {
-			const [v] = latestVals(data, ctx) as [number];
-			return [v * 2];
-		});
-		const seen: number[] = [];
-		out.subscribe((msgs) => {
-			for (const m of msgs) if (m[0] === DATA) seen.push(m[1] as number);
-		});
-		expect(seen).toEqual([14]);
-		ext.emit(5);
-		expect(seen).toEqual([14, 10]);
-		expect(g.node("doubled")).toBe(out);
-		g.destroy();
-	});
-});
-
-describe("Graph narrow-waist — graph.effect", () => {
-	it("runs side-effect when deps settle and registers under name", () => {
-		const g = new Graph("nw-effect");
-		g.add(node([], { name: "a", initial: 1 }), { name: "a" });
-		const calls: number[] = [];
-		const fx = g.effect("logger", ["a"], (data, _up, ctx) => {
-			const [x] = latestVals(data, ctx);
-			calls.push(x as number);
-		});
-		fx.subscribe(() => {});
-		g.set("a", 2);
-		g.set("a", 3);
-		expect(calls).toEqual([1, 2, 3]);
-		expect(g.node("logger")).toBe(fx);
-	});
-
-	it("cleanup fires exactly once on graph.destroy()", () => {
-		const g = new Graph("nw-effect-cleanup");
-		g.add(node([], { name: "a", initial: 1 }), { name: "a" });
-		let cleanups = 0;
-		const fx = g.effect("fx", ["a"], () => {
-			return {
-				onDeactivation: () => {
-					cleanups += 1;
-				},
-			};
-		});
-		fx.subscribe(() => {});
-		// One activation, one deactivation → exactly one cleanup. A double-fire
-		// regression (e.g. TEARDOWN cascading twice) would push this above 1.
-		g.destroy();
-		expect(cleanups).toBe(1);
-	});
-
-	it("respects SENTINEL gate (no fn fire until deps settle)", () => {
-		const g = new Graph("nw-effect-sentinel");
-		g.add(node<number>([], { name: "a", initial: undefined }), { name: "a" });
-		let fnCalls = 0;
-		const fx = g.effect("fx", ["a"], () => {
-			fnCalls += 1;
-		});
-		fx.subscribe(() => {});
-		expect(fnCalls).toBe(0);
-		g.set("a", 1);
-		expect(fnCalls).toBe(1);
-	});
-
-	// F5 — `keepAlive: true` parity with `Graph.derived`. Without this opt
-	// (or an external subscriber / explicit `keepalive(...)` from
-	// extra/sources), an effect is dormant and its fn never fires when its
-	// deps emit. With it, the effect activates internally and stays live.
-	it("keepAlive: true activates the effect without an external subscriber", () => {
-		const g = new Graph("nw-effect-keepalive");
-		g.add(node([], { name: "a", initial: 1 }), { name: "a" });
-		const calls: number[] = [];
-		g.effect(
-			"logger",
-			["a"],
-			(data, _up, ctx) => {
-				const [x] = latestVals(data, ctx);
-				calls.push(x as number);
-			},
-			{ keepAlive: true },
-		);
-		// No fx.subscribe() — the keepAlive opt installs the internal sub.
-		g.set("a", 2);
-		g.set("a", 3);
-		expect(calls).toEqual([1, 2, 3]);
-	});
-
-	it("keepAlive default (omitted / false) leaves effect dormant", () => {
-		const g = new Graph("nw-effect-dormant");
-		g.add(node([], { name: "a", initial: 1 }), { name: "a" });
-		const calls: number[] = [];
-		g.effect("logger", ["a"], (data, _up, ctx) => {
-			const [x] = latestVals(data, ctx);
-			calls.push(x as number);
-		});
-		// No subscribe + no keepAlive → fn never fires.
-		g.set("a", 2);
-		g.set("a", 3);
-		expect(calls).toEqual([]);
-	});
-
-	it("keepAlive: true drains on graph.destroy() (no leak)", () => {
-		const g = new Graph("nw-effect-keepalive-drain");
-		g.add(node([], { name: "a", initial: 1 }), { name: "a" });
-		let cleanups = 0;
-		g.effect(
-			"fx",
-			["a"],
-			() => {
-				return {
-					onDeactivation: () => {
-						cleanups += 1;
-					},
-				};
-			},
-			{ keepAlive: true },
-		);
-		g.destroy();
-		// One activation (from keepAlive), one deactivation → exactly one cleanup.
-		expect(cleanups).toBe(1);
-	});
-});
-
-describe("Graph narrow-waist — graph.state", () => {
-	it("creates a dep-free state node with initial value and registers under name", () => {
-		const g = new Graph("nw-state-basic");
-		const n = g.state("s", 42);
-		const seen: number[] = [];
-		n.subscribe((msgs) => {
-			for (const m of msgs) if (m[0] === DATA) seen.push(m[1] as number);
-		});
-		expect(seen).toEqual([42]);
-		expect(g.node("s")).toBe(n);
-	});
-
-	it("creates a sentinel state node when no initial is provided", () => {
-		const g = new Graph("nw-state-sentinel");
-		const n = g.state<number>("s");
-		const seen: number[] = [];
-		n.subscribe((msgs) => {
-			for (const m of msgs) if (m[0] === DATA) seen.push(m[1] as number);
-		});
-		expect(seen).toEqual([]);
-		// Setting a value should emit DATA.
-		g.set("s", 7);
-		expect(seen).toEqual([7]);
-	});
-
-	it("accepts null as a valid initial value (null is valid DATA per spec §1.1)", () => {
-		const g = new Graph("nw-state-null");
-		const n = g.state<number | null>("s", null);
-		const seen: Array<number | null> = [];
-		n.subscribe((msgs) => {
-			for (const m of msgs) if (m[0] === DATA) seen.push(m[1] as number | null);
-		});
-		expect(seen).toEqual([null]);
-	});
-
-	it("annotation flows through to graph.annotation()", () => {
-		const g = new Graph("nw-state-annot");
-		g.state("s", 1, { annotation: "first value" });
-		expect(g.annotation("s")).toBe("first value");
-	});
-});
-
-describe("Graph narrow-waist — graph.producer", () => {
-	it("creates a dep-free source with push channel and registers under name", () => {
-		const g = new Graph("nw-producer-basic");
-		const seen: number[] = [];
-		const n = g.producer<number>("p", (push) => {
-			push([10]);
-			push([20]);
-		});
-		n.subscribe((msgs) => {
-			for (const m of msgs) if (m[0] === DATA) seen.push(m[1] as number);
-		});
-		expect(seen).toEqual([10, 20]);
-		expect(g.node("p")).toBe(n);
-	});
-
-	it("push([v1, v2]) emits multi-DATA", () => {
-		const g = new Graph("nw-producer-multi");
-		const seen: number[] = [];
-		const n = g.producer<number>("p", (push) => {
-			push([1, 2, 3]);
-		});
-		n.subscribe((msgs) => {
-			for (const m of msgs) if (m[0] === DATA) seen.push(m[1] as number);
-		});
-		expect(seen).toEqual([1, 2, 3]);
-	});
-
-	it("returns cleanup function from setupFn", () => {
-		const g = new Graph("nw-producer-cleanup");
-		let cleanedUp = false;
-		const n = g.producer("p", () => {
-			return {
-				onDeactivation: () => {
-					cleanedUp = true;
-				},
-			};
-		});
-		// Subscribe to activate the node (setup fn runs on first subscriber).
-		n.subscribe(() => {});
-		g.destroy();
-		expect(cleanedUp).toBe(true);
-	});
-
-	it("annotation flows through to graph.annotation()", () => {
-		const g = new Graph("nw-producer-annot");
-		g.producer("p", () => {}, { annotation: "producer node" });
-		expect(g.annotation("p")).toBe("producer node");
-	});
-});
-
-describe("Graph narrow-waist — graph.* signal forwarding (qa B4)", () => {
-	it("graph.producer signal abort removes the produced node", () => {
-		const g = new Graph("nw-signal-producer");
-		const ac = new AbortController();
-		g.producer("p", () => {}, { signal: ac.signal });
-		expect(g.tryResolve("p")).not.toBeUndefined();
-		ac.abort();
-		expect(g.tryResolve("p")).toBeUndefined();
-	});
-
-	it("graph.derived signal abort removes the derived node and fires teardown", () => {
-		const g = new Graph("nw-signal-derived");
-		const ac = new AbortController();
-		g.add(node([], { name: "a", initial: 1 }), { name: "a" });
-		const n = g.derived(
-			"d",
-			["a"],
-			(data, ctx) => {
-				const [v] = latestVals(data, ctx);
-				return [v as number];
-			},
-			{
-				signal: ac.signal,
-				keepAlive: true,
-			},
-		);
-		expect(n.cache).toBe(1);
-		ac.abort();
-		expect(g.tryResolve("d")).toBeUndefined();
-	});
-
-	it("graph.effect signal abort fires the effect's deactivate cleanup", () => {
-		const g = new Graph("nw-signal-effect");
-		const ac = new AbortController();
-		g.add(node([], { name: "a", initial: 1 }), { name: "a" });
-		let cleanups = 0;
-		const fx = g.effect(
-			"fx",
-			["a"],
-			() => ({
-				onDeactivation: () => {
-					cleanups += 1;
-				},
-			}),
-			{ signal: ac.signal },
-		);
-		fx.subscribe(() => {});
-		expect(cleanups).toBe(0);
-		ac.abort();
-		// graph.remove sends TEARDOWN → effect deactivates → cleanup fires.
-		expect(cleanups).toBe(1);
-		expect(g.tryResolve("fx")).toBeUndefined();
-	});
-
-	it("already-aborted signal removes the node synchronously at construction", () => {
-		const g = new Graph("nw-signal-pre-aborted");
-		const ac = new AbortController();
-		ac.abort();
-		g.add(node([], { name: "a", initial: 1 }), { name: "a" });
-		g.derived(
-			"d",
-			["a"],
-			(data, ctx) => {
-				const [v] = latestVals(data, ctx);
-				return [v as number];
-			},
-			{ signal: ac.signal },
-		);
-		expect(g.tryResolve("d")).toBeUndefined();
-	});
-});
-
-// ——————————————————————————————————————————————————————————————
-//  Bundle 3: graph.describe({ explain }) / graph.describe({ reachable })
-//  fold dispatch contract. See archive/docs/SESSION-graph-narrow-waist.md
-//  Phase 5 + qa BH16 finding.
-// ——————————————————————————————————————————————————————————————
-
-describe("Graph.describe({ explain }) — fold dispatch (Bundle 3)", () => {
-	it("returns a CausalChain matching the deleted Graph.explain shape", () => {
-		const g = new Graph("explain-fold");
-		const a = node([], { name: "a", initial: 1 });
-		const b = node(
-			[a],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as number) * 2);
-			},
-			{ describeKind: "derived", name: "b" },
-		);
-		g.add(a, { name: "a" });
-		g.add(b, { name: "b" });
-		g.observe("b").subscribe(() => {});
-		const chain = g.describe({ explain: { from: "a", to: "b" } });
-		expect(chain.found).toBe(true);
-		expect(chain.steps.map((s) => s.path)).toEqual(["a", "b"]);
-	});
-
-	it("returns reactive { node, dispose } when reactive: true is set", () => {
-		const g = new Graph("explain-fold-reactive");
-		const a = node([], { name: "a", initial: 1 });
-		const b = node(
-			[a],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as number) + 1);
-			},
-			{ describeKind: "derived", name: "b" },
-		);
-		g.add(a, { name: "a" });
-		g.add(b, { name: "b" });
-		const handle = g.describe({ explain: { from: "a", to: "b" }, reactive: true });
-		expect(typeof handle.dispose).toBe("function");
-		expect(handle.node.subscribe).toBeDefined();
-		// Cache settles after a subscribe → push-on-subscribe + first
-		// recompute through the version-bump coalescer.
-		handle.node.subscribe(() => {});
-		expect(handle.node.cache?.found).toBe(true);
-		handle.dispose();
-	});
-
-	// DF13 regression: the static explain overload must REJECT
-	// `reactive: true` and reactive-only `name`/`reactiveName` slots, and
-	// must type its return as `CausalChain` (not a reactive handle) so a
-	// caller who meant a live Node cannot silently get a one-shot
-	// snapshot. The `@ts-expect-error`s below are the compile-time lock —
-	// they fail the typecheck/DTS build if the narrowing regresses.
-	it("DF13: static explain overload type-rejects reactive-only options", () => {
-		const g = new Graph("explain-df13-narrowing");
-		const a = node([], { name: "a", initial: 1 });
-		g.add(a, { name: "a" });
-		// Static form → CausalChain. `.found` is a CausalChain field;
-		// `.node` is NOT (present only on the reactive handle).
-		const chain = g.describe({ explain: { from: "a", to: "a" } });
-		expect(chain.found).toBe(true);
-		// @ts-expect-error — static explain returns CausalChain, not a handle.
-		expect(chain.node).toBeUndefined();
-		// @ts-expect-error — `name` is a reactive-mode-only slot.
-		g.describe({ explain: { from: "a", to: "a" }, name: "x" });
-		// @ts-expect-error — `reactiveName` is a reactive-mode-only slot.
-		g.describe({ explain: { from: "a", to: "a" }, reactiveName: "x" });
-		// Reactive form → { node, dispose }; narrows away from CausalChain.
-		const handle = g.describe({ explain: { from: "a", to: "a" }, reactive: true });
-		expect(handle.node.subscribe).toBeDefined();
-		// @ts-expect-error — reactive handle has no `.found` (that's CausalChain).
-		expect(handle.found).toBeUndefined();
-		handle.dispose();
-	});
-
-	it("threads maxDepth + findCycle into the underlying explainPath call", () => {
-		const g = new Graph("explain-fold-opts");
-		const a = node([], { name: "a", initial: 1 });
-		const b = node(
-			[a],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit(data[0]);
-			},
-			{ describeKind: "derived", name: "b" },
-		);
-		const c = node(
-			[b],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit(data[0]);
-			},
-			{ describeKind: "derived", name: "c" },
-		);
-		g.add(a, { name: "a" });
-		g.add(b, { name: "b" });
-		g.add(c, { name: "c" });
-		g.observe("c").subscribe(() => {});
-		// maxDepth 1 truncates a → b → c (2 hops) to "not found" / truncated.
-		const chain = g.describe({ explain: { from: "a", to: "c", maxDepth: 1 } });
-		expect(chain.found).toBe(false);
-	});
-
-	it("name option flows through to the reactive derived's meta.name", () => {
-		const g = new Graph("explain-fold-name");
-		const a = node([], { name: "a", initial: 1 });
-		const b = node(
-			[a],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit(data[0]);
-			},
-			{ describeKind: "derived", name: "b" },
-		);
-		g.add(a, { name: "a" });
-		g.add(b, { name: "b" });
-		const handle = g.describe({
-			explain: { from: "a", to: "b" },
-			reactive: true,
-			name: "my-explain",
-		});
-		expect((handle.node as { name?: string }).name).toBe("my-explain");
-		handle.dispose();
-	});
-
-	it("reactiveName falls back to the explain-mode `name` slot when name is absent", () => {
-		const g = new Graph("explain-fold-fallback");
-		const a = node([], { name: "a", initial: 1 });
-		const b = node(
-			[a],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit(data[0]);
-			},
-			{ describeKind: "derived", name: "b" },
-		);
-		g.add(a, { name: "a" });
-		g.add(b, { name: "b" });
-		const handle = g.describe({
-			explain: { from: "a", to: "b" },
-			reactive: true,
-			reactiveName: "fallback-name",
-		});
-		expect((handle.node as { name?: string }).name).toBe("fallback-name");
-		handle.dispose();
-	});
-
-	it("name wins over reactiveName when both are set", () => {
-		const g = new Graph("explain-fold-name-wins");
-		const a = node([], { name: "a", initial: 1 });
-		const b = node(
-			[a],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit(data[0]);
-			},
-			{ describeKind: "derived", name: "b" },
-		);
-		g.add(a, { name: "a" });
-		g.add(b, { name: "b" });
-		const handle = g.describe({
-			explain: { from: "a", to: "b" },
-			reactive: true,
-			name: "winner",
-			reactiveName: "loser",
-		});
-		expect((handle.node as { name?: string }).name).toBe("winner");
-		handle.dispose();
-	});
-});
-
-describe("Graph.describe({ reachable }) — fold dispatch (Bundle 3)", () => {
-	it("returns string[] matching the deleted Graph.reachable default form", () => {
-		const g = new Graph("reach-fold");
-		const a = node([], { name: "a", initial: 1 });
-		const b = node(
-			[a],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit(data[0]);
-			},
-			{ describeKind: "derived", name: "b" },
-		);
-		const c = node(
-			[b],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit(data[0]);
-			},
-			{ describeKind: "derived", name: "c" },
-		);
-		g.add(a, { name: "a" });
-		g.add(b, { name: "b" });
-		g.add(c, { name: "c" });
-		g.observe("c").subscribe(() => {});
-		const downstream = g.describe({
-			reachable: { from: "a", direction: "downstream" },
-		});
-		expect(downstream).toEqual(["b", "c"]);
-	});
-
-	it("returns ReachableResult shape when withDetail: true", () => {
-		const g = new Graph("reach-fold-detail");
-		const a = node([], { name: "a", initial: 1 });
-		const b = node(
-			[a],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit(data[0]);
-			},
-			{ describeKind: "derived", name: "b" },
-		);
-		g.add(a, { name: "a" });
-		g.add(b, { name: "b" });
-		g.observe("b").subscribe(() => {});
-		const result = g.describe({
-			reachable: { from: "a", direction: "downstream", withDetail: true },
-		});
-		expect(Array.isArray(result.paths)).toBe(true);
-		expect(result.paths).toEqual(["b"]);
-		expect(result.depths instanceof Map).toBe(true);
-		expect(result.depths.get("b")).toBe(1);
-		expect(result.truncated).toBe(false);
-	});
-
-	it("threads maxDepth + both into the underlying reachable() call", () => {
-		const g = new Graph("reach-fold-depth");
-		const a = node([], { name: "a", initial: 1 });
-		const b = node(
-			[a],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit(data[0]);
-			},
-			{ describeKind: "derived", name: "b" },
-		);
-		const c = node(
-			[b],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit(data[0]);
-			},
-			{ describeKind: "derived", name: "c" },
-		);
-		g.add(a, { name: "a" });
-		g.add(b, { name: "b" });
-		g.add(c, { name: "c" });
-		g.observe("c").subscribe(() => {});
-		const truncated = g.describe({
-			reachable: { from: "a", direction: "downstream", maxDepth: 1 },
-		});
-		expect(truncated).toEqual(["b"]);
-	});
-
-	it("matches the standalone reachable() helper for parity", () => {
-		const g = new Graph("reach-fold-parity");
-		const a = node([], { name: "a", initial: 1 });
-		const b = node(
-			[a],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit(data[0]);
-			},
-			{ describeKind: "derived", name: "b" },
-		);
-		g.add(a, { name: "a" });
-		g.add(b, { name: "b" });
-		g.observe("b").subscribe(() => {});
-		const viaDescribe = g.describe({
-			reachable: { from: "a", direction: "downstream" },
-		});
-		const viaStandalone = reachable(g.describe(), "a", "downstream");
-		expect(viaDescribe).toEqual(viaStandalone);
-	});
-});
-
-describe("Graph.describe() — mode-conflict TypeError dispatch (Bundle 3)", () => {
-	it("throws when both `explain` and `reachable` are set", () => {
-		const g = new Graph("conflict-modes");
-		expect(() =>
-			g.describe({
-				explain: { from: "a", to: "b" },
-				reachable: { from: "a", direction: "downstream" },
-			} as any),
-		).toThrow(/mutually exclusive/);
-	});
-
-	it("throws when `explain` is paired with `detail`", () => {
-		const g = new Graph("conflict-detail");
-		expect(() =>
-			g.describe({
-				explain: { from: "a", to: "b" },
-				detail: "full",
-			} as any),
-		).toThrow(/`explain` mode does not accept `detail`/);
-	});
-
-	it("throws when `explain` is paired with `fields`", () => {
-		const g = new Graph("conflict-fields");
-		expect(() =>
-			g.describe({
-				explain: { from: "a", to: "b" },
-				fields: ["type"],
-			} as any),
-		).toThrow(/`explain` mode does not accept `fields`/);
-	});
-
-	it("throws when `reachable` is paired with `actor`", () => {
-		const g = new Graph("conflict-actor");
-		expect(() =>
-			g.describe({
-				reachable: { from: "a", direction: "downstream" },
-				actor: DEFAULT_ACTOR,
-			} as any),
-		).toThrow(/`reachable` mode does not accept `actor`/);
-	});
-
-	it("throws when `reachable` is paired with `reactive: true`", () => {
-		const g = new Graph("conflict-reactive");
-		expect(() =>
-			g.describe({
-				reachable: { from: "a", direction: "downstream" },
-				reactive: true,
-			} as any),
-		).toThrow(/static-only/);
-	});
-
-	it('throws when `reachable` is paired with `reactive: "diff"`', () => {
-		const g = new Graph("conflict-diff");
-		expect(() =>
-			g.describe({
-				reachable: { from: "a", direction: "downstream" },
-				reactive: "diff",
-			} as any),
-		).toThrow(/static-only/);
-	});
-
-	it("accepts `reachable` + `reactive: false` as a no-op (qa BH1/EC8 — symmetric with explain mode)", () => {
-		const g = new Graph("reach-reactive-false-allowed");
-		const a = node([], { name: "a", initial: 1 });
-		const b = node(
-			[a],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit(data[0]);
-			},
-			{ describeKind: "derived", name: "b" },
-		);
-		g.add(a, { name: "a" });
-		g.add(b, { name: "b" });
-		g.observe("b").subscribe(() => {});
-		// `reactive: false` is the implicit default — explicit form must
-		// pass through without error so spread-style callers don't trip.
-		expect(() =>
-			g.describe({
-				reachable: { from: "a", direction: "downstream" },
-				reactive: false,
-			} as any),
-		).not.toThrow();
-	});
-
-	it('throws when `explain` is paired with `reactive: "diff"`', () => {
-		const g = new Graph("conflict-explain-diff");
-		expect(() =>
-			g.describe({
-				explain: { from: "a", to: "b" },
-				reactive: "diff",
-			} as any),
-		).toThrow(/does not support `reactive: "diff"`/);
-	});
-
-	it("accepts `explain` + `reactive: false` as a no-op", () => {
-		const g = new Graph("explain-reactive-false");
-		const a = node([], { name: "a", initial: 1 });
-		const b = node(
-			[a],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit(data[0]);
-			},
-			{ describeKind: "derived", name: "b" },
-		);
-		g.add(a, { name: "a" });
-		g.add(b, { name: "b" });
-		g.observe("b").subscribe(() => {});
-		// Defensive style — explicit `reactive: false` should produce a
-		// static CausalChain (same as omitting `reactive`).
-		const chain = g.describe({
-			explain: { from: "a", to: "b" },
-			reactive: false,
-		});
-		expect(chain.found).toBe(true);
-	});
-});
-
-describe("DF1: compound factory tagging requirement", () => {
-	// DF1 (`docs/optimizations.md`). When a registered node has an upstream
-	// dep whose `name` follows the `parent::child` convention AND the parent
-	// prefix collides with the registered node's path, that's a compound
-	// factory pattern. The parent MUST stamp `meta.factory` (via
-	// `factoryTag(name, placeholderArgs(opts))`) so `decompileSpec` /
-	// `compileSpec` can round-trip the factory's internals via the catalog.
-	// Without the tag, the spec round-trip silently splits the topology —
-	// `describe()` now refuses to produce output until the tag lands.
-
-	function buildUntaggedCompound(): Graph {
-		const g = new Graph("untagged-compound");
-		// `child` carries the `parent::child` `name` convention but is NOT
-		// registered directly (`g.add` rejects `::`). Instead it's an
-		// upstream dep of the registered `parent` node — describe's BFS
-		// transitive-deps walk surfaces it as `parent_factory::child` in
-		// the resolved path map.
-		const child = node([], { initial: 1, name: "parent_factory::child" });
-		const parent = node(
-			[child],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as number) * 2);
-			},
-			{ describeKind: "derived", name: "parent_factory" },
-		);
-		g.add(parent, { name: "parent_factory" });
-		return g;
-	}
-
-	function buildTaggedCompound(): Graph {
-		const g = new Graph("tagged-compound");
-		const child = node([], { initial: 1, name: "parent_factory::child" });
-		const parent = node(
-			[child],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as number) * 2);
-			},
-			{
-				describeKind: "derived",
-				name: "parent_factory",
-				meta: factoryTag("parent_factory", placeholderArgs({ multiplier: 2 })),
-			},
-		);
-		g.add(parent, { name: "parent_factory" });
-		return g;
-	}
-
-	it("describe() throws TypeError on untagged compound topology", () => {
-		const g = buildUntaggedCompound();
-		expect(() => g.describe()).toThrow(TypeError);
-		expect(() => g.describe()).toThrow(/untagged compound factory at "parent_factory"/);
-		// Error must reference the offending child path so the author can
-		// trace which factory needs the tag.
-		expect(() => g.describe()).toThrow(/parent_factory::child/);
-		// Error must suggest the fix.
-		expect(() => g.describe()).toThrow(/factoryTag\("parent_factory"/);
-		// Error must reference the canonical doc.
-		expect(() => g.describe()).toThrow(/DF1/);
-	});
-
-	it("describe() succeeds when the parent stamps factoryTag", () => {
-		const g = buildTaggedCompound();
-		const desc = g.describe();
-		// Parent path resolves; child surfaces via BFS transitive-deps.
-		expect(Object.keys(desc.nodes)).toContain("parent_factory");
-		expect(Object.keys(desc.nodes)).toContain("parent_factory::child");
-	});
-
-	it("describe({ strictFactoryTags: false }) opts out for legacy / debug graphs", () => {
-		const g = buildUntaggedCompound();
-		// Opt-out lets the offender produce describe output; useful for
-		// inspecting graphs mid-migration without fixing every factory.
-		const desc = g.describe({ strictFactoryTags: false });
-		expect(Object.keys(desc.nodes)).toContain("parent_factory");
-		expect(Object.keys(desc.nodes)).toContain("parent_factory::child");
-	});
-
-	it("decompileSpec round-trip succeeds for tagged compound factories (with catalog)", () => {
-		// Tagged compound factory round-trips via the catalog. Without a
-		// catalog entry for `parent_factory`, `compileSpec` would refuse —
-		// so the round-trip here is just decompile + spec equality with
-		// `describe({ detail: 'spec' })`. Catalog-driven `compileSpec` is
-		// covered by the existing `graphspec/spec-roundtrip.test.ts` suite.
-		const g = buildTaggedCompound();
-		const spec = decompileSpec(g);
-		// `parent_factory` survives as a tagged spec node; `::child` is
-		// stripped (the factory recreates it on `compileSpec`).
-		expect(Object.keys(spec.nodes)).toContain("parent_factory");
-		expect(Object.keys(spec.nodes)).not.toContain("parent_factory::child");
-		// Verify the factory tag is preserved.
-		const parentSpec = spec.nodes.parent_factory as { meta?: Record<string, unknown> };
-		expect(parentSpec.meta?.factory).toBe("parent_factory");
-	});
-
-	it("decompileSpec hard-rejects untagged compound topology (matches describe)", () => {
-		// The decompileSpec pre-pass enforces the same invariant. Without
-		// `strictFactoryTags: false`, decompile fails at describe() before
-		// it even reaches its own check.
-		const g = buildUntaggedCompound();
-		expect(() => decompileSpec(g)).toThrow(/untagged compound factory/);
-	});
-
-	it("describe() ignores `parent::child` paths when the parent isn't a registered node", () => {
-		// Common pattern: factory creates `${baseName}::messages` /
-		// `${baseName}::output` but never registers `baseName` itself.
-		// Here only `prompt_node::output` is registered; `prompt_node` is
-		// not a node entry, so the assertion correctly skips.
-		const g = new Graph("orphan-prefix");
-		const messages = node([], { initial: [], name: "prompt_node::messages" });
-		const output = node(
-			[messages],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit(data[0]);
-			},
-			{ describeKind: "derived", name: "prompt_node::output" },
-		);
-		// Cannot `g.add` a `::` name, so register under a different alias.
-		g.add(output, { name: "out" });
-		// `prompt_node::messages` surfaces via BFS but `prompt_node` is
-		// not registered → assertion silently skips.
-		expect(() => g.describe()).not.toThrow();
-	});
-
-	it("strictFactoryTags assertion is honored by every describe-mode entry point", () => {
-		// `describe({ reactive: true })` defers the inner `describe()` call
-		// until the backing derived node's fn runs, so the throw surfaces
-		// via the protocol's ERROR message slot rather than a sync throw at
-		// handle creation. The static `describe()` path catches the same
-		// violation immediately. The static path's coverage is sufficient
-		// for this regression — the reactive path's inner call goes through
-		// the same `describe()` method that the static path tests, so any
-		// regression in the assertion logic also surfaces statically.
-		const g = buildUntaggedCompound();
-		// Static path throws.
-		expect(() => g.describe()).toThrow(/untagged compound factory/);
-		// Reactive path can be instantiated (lazy inner call); subscribing
-		// surfaces the throw via the ERROR message (or via the inner static
-		// describe call if scheduled synchronously).
-		const handle = g.describe({ reactive: true });
-		// We don't assert specific reactive timing here — the static path
-		// covers the assertion logic, and reactive describe forwards to it.
-		handle.dispose();
-		// Sanity: opt-out works on reactive too.
-		const optOut = g.describe({ reactive: true, strictFactoryTags: false });
-		optOut.dispose();
-	});
-
-	// Use compileSpec to silence linter on unused import — left as a
-	// future-extension point: when compound-factory `compileSpec` lands
-	// against the catalog, this test should round-trip the tagged graph.
-	void compileSpec;
-});
-
-// ────────────────────────────────────────────────────────────────────────
-// C3 — cross-graph Node ownership (locked 2026-05-01)
-//
-// `Graph.add` stamps a module-scoped `WeakMap<Node, Graph>` on the first
-// registration. A second `add` on a different non-destroyed Graph throws
-// `TypeError` with `code === "cross-graph-ownership"`. The stamp is
-// released synchronously in the same call as TEARDOWN cascades
-// (`Graph.remove` / `Graph.destroy`) so a freshly-detached Node can be
-// re-registered on another graph in the same tick.
-//
-// Mount lineage stays innermost-owned: a child's nodes belong to the
-// child, not to the parent. Re-mount under a different parent works as
-// long as the child itself isn't dual-owned. Standalone `node([], fn)`
-// usage that never goes through `add` carries no stamp.
-// ────────────────────────────────────────────────────────────────────────
-
-describe("C3: cross-graph Node ownership", () => {
-	it("g1.add(n) then g2.add(n) throws TypeError with code='cross-graph-ownership' naming both graphs", () => {
-		const g1 = new Graph("g1");
-		const g2 = new Graph("g2");
-		const n = node([], { name: "shared", initial: 0 });
-		g1.add(n, { name: "shared" });
-		let err: unknown;
-		try {
-			g2.add(n, { name: "shared" });
-		} catch (e) {
-			err = e;
-		}
-		expect(err).toBeInstanceOf(TypeError);
-		expect((err as { code?: string }).code).toBe("cross-graph-ownership");
-		const msg = (err as Error).message;
-		expect(msg).toContain('"g1"');
-		expect(msg).toContain('"g2"');
-		expect(msg).toContain('"shared"');
-	});
-
-	it("error message names both graphs as <unnamed> when names are empty (defensive — Graph rejects empty names today, but the formatter must be safe)", () => {
-		// Direct unit cover for the `<unnamed>` branch: cannot construct a
-		// Graph with name "" through the public ctor (rejected with
-		// "non-empty"), but the formatter must still cope with that branch
-		// for forward-compat. Validate that real graphs with non-empty names
-		// never hit `<unnamed>` in error messages.
-		const g1 = new Graph("alpha");
-		const g2 = new Graph("beta");
-		const n = node([], { name: "x", initial: 0 });
-		g1.add(n, { name: "x" });
-		expect(() => g2.add(n, { name: "x" })).toThrow(/"alpha".*"beta"|"beta".*"alpha"/);
-	});
-
-	it("after g1.remove(name), g2.add(n) succeeds (freshly-detached)", () => {
-		const g1 = new Graph("g1");
-		const g2 = new Graph("g2");
-		const n = node([], { name: "x", initial: 1 });
-		g1.add(n, { name: "x" });
-		g1.remove("x");
-		// Same tick — stamp must already be released.
-		expect(() => g2.add(n, { name: "x" })).not.toThrow();
-		expect(g2.node("x")).toBe(n);
-	});
-
-	it("after g1.destroy(), g2.add(n) succeeds (freshly-detached)", () => {
-		const g1 = new Graph("g1");
-		const g2 = new Graph("g2");
-		const n = node([], { name: "x", initial: 1 });
-		g1.add(n, { name: "x" });
-		g1.destroy();
-		// Same tick — destroy must release stamps in the same call as
-		// TEARDOWN per the locked semantics.
-		expect(() => g2.add(n, { name: "x" })).not.toThrow();
-		expect(g2.node("x")).toBe(n);
-	});
-
-	it("Graph.mount rejects when child carries a node already owned by a different Graph (defensive against direct _nodes mutation)", () => {
-		const foreign = new Graph("foreign");
-		const n = node([], { name: "x", initial: 0 });
-		foreign.add(n, { name: "x" });
-
-		// Build a child that bypasses `add` and pokes `_nodes` directly —
-		// this is exactly the defensive case the mount stamp-walk catches.
-		// (Real callers use `child.add`, which would already have thrown.)
-		const child = new Graph("child");
-		(child as unknown as { _nodes: Map<string, unknown> })._nodes.set("x", n);
-
-		const parent = new Graph("parent");
-		let err: unknown;
-		try {
-			parent.mount("c", child);
-		} catch (e) {
-			err = e;
-		}
-		expect(err).toBeInstanceOf(TypeError);
-		expect((err as { code?: string }).code).toBe("cross-graph-ownership");
-		expect((err as Error).message).toContain('"foreign"');
-	});
-
-	it("mounted child's nodes stay owned by the child; re-mount under a different parent works", () => {
-		const child = new Graph("child");
-		const n = node([], { name: "x", initial: 0 });
-		child.add(n, { name: "x" });
-
-		const parentA = new Graph("parentA");
-		parentA.mount("c", child);
-		// Adding `n` to the parent itself must still fail — child owns it.
-		expect(() => parentA.add(n, { name: "y" })).toThrow(/cross-graph-ownership|owned/);
-
-		// Unmount and re-mount under a different parent.
-		parentA.remove("c");
-		const parentB = new Graph("parentB");
-		expect(() => parentB.mount("c", child)).not.toThrow();
-		// Child still owns its node.
-		expect(parentB.node("c::x")).toBe(n);
-	});
-
-	it("standalone node([], fn) without add carries no stamp and may be added later to any graph", () => {
-		const n = node([], { name: "free", initial: 7 });
-		// Never went through `add` — no stamp. Either graph can claim it.
-		const g1 = new Graph("g1");
-		expect(() => g1.add(n, { name: "free" })).not.toThrow();
-		// Now g2 can't claim it (g1 owns it) — but a fresh standalone node
-		// could go to g2 freely.
-		const g2 = new Graph("g2");
-		const m = node([], { name: "free", initial: 8 });
-		expect(() => g2.add(m, { name: "free" })).not.toThrow();
-	});
-});
diff --git a/packages/pure-ts/src/__tests__/graph/reactive-changesets.test.ts b/packages/pure-ts/src/__tests__/graph/reactive-changesets.test.ts
deleted file mode 100644
index 8807b062..00000000
--- a/packages/pure-ts/src/__tests__/graph/reactive-changesets.test.ts
+++ /dev/null
@@ -1,536 +0,0 @@
-/**
- * Tier 1.5.1 (`describe({ reactive: "diff" })`) + Tier 1.5.2
- * (`observe({ reactive: true })` + `tiers`) + Tier 1.5.D2
- * (`observe({ changeset: true })`) coverage.
- */
-
-import { describe, expect, it } from "vitest";
-import { batch } from "../../core/batch.js";
-import { DATA } from "../../core/messages.js";
-import { node } from "../../core/node.js";
-
-import { type DescribeChangeset, topologyDiff } from "../../extra/composition/topology-diff.js";
-import type { GraphChange } from "../../graph/changeset.js";
-import { Graph, type GraphDescribeOutput, type ObserveChangeset } from "../../graph/graph.js";
-
-const emptySnap = (name = "g"): GraphDescribeOutput => ({
-	name,
-	nodes: {},
-	edges: [],
-	subgraphs: [],
-});
-
-describe("topologyDiff (pure function)", () => {
-	it("returns empty events for identical snapshots", () => {
-		const snap = emptySnap();
-		const result = topologyDiff(snap, snap);
-		expect(result.events).toEqual([]);
-		expect(typeof result.flushedAt_ns).toBe("number");
-	});
-
-	it("emits node-added for new nodes (sorted)", () => {
-		const prev = emptySnap();
-		const next: GraphDescribeOutput = {
-			...emptySnap(),
-			nodes: {
-				b: { type: "state", deps: [] },
-				a: { type: "state", deps: [] },
-			},
-		};
-		const result = topologyDiff(prev, next);
-		expect(result.events).toHaveLength(2);
-		expect(result.events[0]).toMatchObject({ type: "node-added", path: "a" });
-		expect(result.events[1]).toMatchObject({ type: "node-added", path: "b" });
-	});
-
-	it("emits node-removed for missing nodes", () => {
-		const prev: GraphDescribeOutput = {
-			...emptySnap(),
-			nodes: { a: { type: "state", deps: [] } },
-		};
-		const next = emptySnap();
-		const result = topologyDiff(prev, next);
-		expect(result.events).toEqual([{ type: "node-removed", path: "a" }]);
-	});
-
-	it("emits node-meta-changed when meta differs", () => {
-		const prev: GraphDescribeOutput = {
-			...emptySnap(),
-			nodes: { a: { type: "state", deps: [], meta: { x: 1 } } },
-		};
-		const next: GraphDescribeOutput = {
-			...emptySnap(),
-			nodes: { a: { type: "state", deps: [], meta: { x: 2 } } },
-		};
-		const result = topologyDiff(prev, next);
-		expect(result.events).toHaveLength(1);
-		expect(result.events[0]).toMatchObject({
-			type: "node-meta-changed",
-			path: "a",
-			prevMeta: { x: 1 },
-			nextMeta: { x: 2 },
-		});
-	});
-
-	it("treats deep-equal meta as unchanged", () => {
-		const prev: GraphDescribeOutput = {
-			...emptySnap(),
-			nodes: { a: { type: "state", deps: [], meta: { x: { y: 1 } } } },
-		};
-		const next: GraphDescribeOutput = {
-			...emptySnap(),
-			nodes: { a: { type: "state", deps: [], meta: { x: { y: 1 } } } },
-		};
-		expect(topologyDiff(prev, next).events).toEqual([]);
-	});
-
-	it("emits edge-added and edge-removed", () => {
-		const prev: GraphDescribeOutput = {
-			...emptySnap(),
-			edges: [{ from: "a", to: "b" }],
-		};
-		const next: GraphDescribeOutput = {
-			...emptySnap(),
-			edges: [{ from: "b", to: "c" }],
-		};
-		const result = topologyDiff(prev, next);
-		const types = result.events.map((e) => e.type);
-		expect(types).toEqual(["edge-added", "edge-removed"]);
-	});
-
-	it("emits subgraph-mounted and subgraph-unmounted", () => {
-		const prev: GraphDescribeOutput = { ...emptySnap(), subgraphs: ["sub-a"] };
-		const next: GraphDescribeOutput = { ...emptySnap(), subgraphs: ["sub-b"] };
-		const result = topologyDiff(prev, next);
-		const types = result.events.map((e) => e.type);
-		expect(types).toContain("subgraph-mounted");
-		expect(types).toContain("subgraph-unmounted");
-	});
-
-	it("flushedAt_ns is monotonic across calls", () => {
-		const snap = emptySnap();
-		const a = topologyDiff(snap, snap);
-		const b = topologyDiff(snap, snap);
-		expect(b.flushedAt_ns).toBeGreaterThanOrEqual(a.flushedAt_ns);
-	});
-});
-
-describe("Graph.describe({ reactive: 'diff' })", () => {
-	it("seeds the initial cache with a synthetic full-add diff", () => {
-		const g = new Graph("g");
-		const a = node([], { initial: 1 });
-		g.add(a, { name: "a" });
-
-		const handle = g.describe({ reactive: "diff" });
-		const initial = handle.node.cache as DescribeChangeset | undefined;
-		expect(initial).toBeDefined();
-		const paths = initial?.events
-			.filter((e) => e.type === "node-added")
-			.map((e) => (e as { path: string }).path);
-		expect(paths).toContain("a");
-
-		handle.dispose();
-	});
-
-	it("emits a non-empty changeset on topology change", () => {
-		const g = new Graph("g");
-		const a = node([], { initial: 1 });
-		g.add(a, { name: "a" });
-
-		const handle = g.describe({ reactive: "diff" });
-		const changesets: DescribeChangeset[] = [];
-		const off = handle.node.subscribe((msgs) => {
-			for (const m of msgs) {
-				if (m[0] === DATA) changesets.push(m[1] as DescribeChangeset);
-			}
-		});
-
-		// Initial cache push-on-subscribe ⇒ at least one changeset.
-		const initialCount = changesets.length;
-		expect(initialCount).toBeGreaterThanOrEqual(1);
-
-		// Add another node — should fire a new diff after coalescing.
-		const b = node([], { initial: 2 });
-		g.add(b, { name: "b" });
-
-		expect(changesets.length).toBeGreaterThan(initialCount);
-		const last = changesets[changesets.length - 1]!;
-		const addedPaths = last.events
-			.filter((e) => e.type === "node-added")
-			.map((e) => (e as { path: string }).path);
-		expect(addedPaths).toContain("b");
-
-		off();
-		handle.dispose();
-	});
-});
-
-describe("Graph.observe({ reactive: true })", () => {
-	it("emits an ObserveChangeset wrapping observed events", () => {
-		const g = new Graph("g");
-		const a = node<number | null>([], { initial: null });
-		g.add(a, { name: "a" });
-
-		const observeNode = g.observe({ reactive: true });
-		const changesets: ObserveChangeset[] = [];
-		const off = observeNode.subscribe((msgs) => {
-			for (const m of msgs) {
-				if (m[0] === DATA) changesets.push(m[1] as ObserveChangeset);
-			}
-		});
-
-		a.emit(42);
-
-		// At least one changeset; events include a "data" entry.
-		expect(changesets.length).toBeGreaterThan(0);
-		const allEvents = changesets.flatMap((c) => c.events);
-		expect(allEvents.some((e) => e.type === "data")).toBe(true);
-		expect(typeof changesets[0]!.flushedAt_ns).toBe("number");
-
-		off();
-	});
-
-	it("delivers events from multiple sources fired in one batch", () => {
-		const g = new Graph("g");
-		const a = node<number | null>([], { initial: null });
-		const b = node<number | null>([], { initial: null });
-		g.add(a, { name: "a" });
-		g.add(b, { name: "b" });
-
-		const observeNode = g.observe({ reactive: true });
-		const allEvents: ObserveChangeset["events"][number][] = [];
-		const off = observeNode.subscribe((msgs) => {
-			for (const m of msgs) {
-				if (m[0] === DATA) {
-					const cs = m[1] as ObserveChangeset;
-					allEvents.push(...cs.events);
-				}
-			}
-		});
-
-		batch(() => {
-			a.emit(1);
-			b.emit(2);
-		});
-
-		// Both sources' DATA events should surface across the changesets.
-		const paths = new Set(allEvents.filter((e) => e.type === "data").map((e) => e.path));
-		expect(paths.has("a")).toBe(true);
-		expect(paths.has("b")).toBe(true);
-
-		off();
-	});
-
-	it("filters events by tiers", () => {
-		const g = new Graph("g");
-		const a = node<number | null>([], { initial: null });
-		g.add(a, { name: "a" });
-
-		// "data" events excluded — only "error" / "complete" / "teardown".
-		const observeNode = g.observe({ reactive: true, tiers: ["error", "complete", "teardown"] });
-		const changesets: ObserveChangeset[] = [];
-		const off = observeNode.subscribe((msgs) => {
-			for (const m of msgs) {
-				if (m[0] === DATA) changesets.push(m[1] as ObserveChangeset);
-			}
-		});
-
-		a.emit(42);
-
-		// "data" event filtered out before accumulation; no changeset emits.
-		expect(changesets).toEqual([]);
-
-		off();
-	});
-});
-
-describe("Graph.observe({ changeset: true })", () => {
-	const collect = (graph: Graph): { all: GraphChange[]; off: () => void } => {
-		const changesetNode = graph.observe({ changeset: true });
-		const all: GraphChange[] = [];
-		const off = changesetNode.subscribe((msgs) => {
-			for (const m of msgs) {
-				if (m[0] === DATA) all.push(m[1] as GraphChange);
-			}
-		});
-		return { all, off };
-	};
-
-	it("emits node-added topology events when a node lands on the graph", () => {
-		const g = new Graph("g");
-		const { all, off } = collect(g);
-
-		const a = node([], { initial: 0 });
-		g.add(a, { name: "a" });
-
-		const added = all.filter((e) => e.type === "node-added");
-		expect(added.length).toBeGreaterThan(0);
-		expect(added.some((e) => e.scope === "a")).toBe(true);
-
-		off();
-	});
-
-	it("emits a data event with fromPath/fromDepIndex attributing the upstream edge", () => {
-		const g = new Graph("g");
-		const a = node<number>([], { name: "a", initial: 1 });
-		g.add(a, { name: "a" });
-		// derived depends on a — when a emits, derived recomputes and we
-		// should see a data event scoped to "d" with fromPath "a", fromDepIndex 0.
-		g.derived("d", ["a"], (data, ctx) => {
-			const batch0 = data[0];
-			const v = batch0 != null && batch0.length > 0 ? batch0.at(-1) : ctx.prevData[0];
-			return [(v as number) * 2];
-		});
-
-		const { all, off } = collect(g);
-		// Activate the derived node so the changeset stream subscribes through.
-		const dNode = g.node("d");
-		const offD = dNode.subscribe(() => {});
-
-		// Reset accumulator — only care about changes after subscription kicks
-		// the network, so we collect the next emission cleanly.
-		all.length = 0;
-
-		g.set("a", 7);
-
-		const dEvents = all.filter((e) => e.type === "data" && e.scope === "d");
-		expect(dEvents.length).toBeGreaterThan(0);
-		const ev = dEvents[0];
-		if (ev.type !== "data") throw new Error("unreachable");
-		expect(ev.fromPath).toBe("a");
-		expect(ev.fromDepIndex).toBe(0);
-		expect(ev.value).toBe(14);
-
-		offD();
-		off();
-	});
-
-	it("data events from source nodes carry fromDepIndex: -1 (no upstream dep)", () => {
-		const g = new Graph("g");
-		const a = node<number | null>([], { name: "a", initial: null });
-		g.add(a, { name: "a" });
-		const { all, off } = collect(g);
-
-		all.length = 0;
-		a.emit(99);
-
-		const dataEvents = all.filter((e) => e.type === "data" && e.scope === "a");
-		expect(dataEvents.length).toBe(1);
-		const ev = dataEvents[0];
-		if (ev.type !== "data") throw new Error("unreachable");
-		expect(ev.fromDepIndex).toBe(-1);
-		expect(ev.fromPath).toBe("a");
-		expect(ev.value).toBe(99);
-
-		off();
-	});
-
-	it("envelope `version` is monotonic across all events", () => {
-		const g = new Graph("g");
-		const a = node<number>([], { name: "a", initial: 0 });
-		g.add(a, { name: "a" });
-		g.derived("d", ["a"], (data, ctx) => {
-			const batch0 = data[0];
-			const v = batch0 != null && batch0.length > 0 ? batch0.at(-1) : ctx.prevData[0];
-			return [(v as number) + 1];
-		});
-
-		const { all, off } = collect(g);
-		g.node("d").subscribe(() => {});
-
-		batch(() => {
-			g.set("a", 1);
-			g.set("a", 2);
-			g.set("a", 3);
-		});
-
-		// Strictly increasing version stamps.
-		for (let i = 1; i < all.length; i++) {
-			expect(all[i].version).toBeGreaterThan(all[i - 1].version);
-		}
-		off();
-	});
-
-	it("wraps a batch in batch-start / batch-end with payload events between", () => {
-		const g = new Graph("g");
-		const a = node<number | null>([], { name: "a", initial: null });
-		const b = node<number | null>([], { name: "b", initial: null });
-		g.add(a, { name: "a" });
-		g.add(b, { name: "b" });
-
-		const { all, off } = collect(g);
-		all.length = 0;
-
-		batch(() => {
-			a.emit(1);
-			b.emit(2);
-		});
-
-		// Inside a batch each upstream delivery wave gets one
-		// batch-start / batch-end pair. With two distinct sources `a` and `b`,
-		// the runtime delivers two coalesced waves (one per source), so we
-		// expect ≥2 frame pairs. The pairing invariants — equal counts,
-		// strictly nested versions, every data event inside a frame — are
-		// what the design guarantees.
-		const batchStarts = all.filter((e) => e.type === "batch-start");
-		const batchEnds = all.filter((e) => e.type === "batch-end");
-		expect(batchStarts.length).toBeGreaterThan(0);
-		expect(batchStarts.length).toBe(batchEnds.length);
-		// Versions strictly nested per frame: bs[i] < be[i] < bs[i+1].
-		for (let i = 0; i < batchStarts.length; i++) {
-			expect(batchStarts[i].version).toBeLessThan(batchEnds[i].version);
-			if (i > 0) {
-				expect(batchEnds[i - 1].version).toBeLessThan(batchStarts[i].version);
-			}
-		}
-		// At least one data event in the wrapped region overall.
-		const dataEvents = all.filter((e) => e.type === "data");
-		expect(dataEvents.length).toBeGreaterThan(0);
-		// Every data event must lie inside SOME frame.
-		for (const ev of dataEvents) {
-			const enclosing = batchStarts.findIndex(
-				(bs, i) =>
-					bs.version < ev.version &&
-					ev.version < (batchEnds[i]?.version ?? Number.POSITIVE_INFINITY),
-			);
-			expect(enclosing).toBeGreaterThanOrEqual(0);
-		}
-		off();
-	});
-
-	it("emits node-removed when a node is removed", () => {
-		const g = new Graph("g");
-		const a = node([], { initial: 0 });
-		g.add(a, { name: "a" });
-
-		const { all, off } = collect(g);
-		all.length = 0;
-		g.remove("a");
-
-		const removed = all.filter((e) => e.type === "node-removed");
-		expect(removed.length).toBeGreaterThan(0);
-		expect(removed.some((e) => e.scope === "a")).toBe(true);
-		off();
-	});
-
-	it("emits mount / unmount for child subgraphs", () => {
-		const g = new Graph("g");
-		const child = new Graph("child");
-
-		const { all, off } = collect(g);
-		all.length = 0;
-
-		g.mount("child", child);
-		const mounts = all.filter((e) => e.type === "mount");
-		expect(mounts.length).toBe(1);
-		expect(mounts[0].scope).toBe("child");
-
-		all.length = 0;
-		g.remove("child");
-		const unmounts = all.filter((e) => e.type === "unmount");
-		expect(unmounts.length).toBe(1);
-		expect(unmounts[0].scope).toBe("child");
-		off();
-	});
-
-	it("rejects {changeset:true, reactive:true} mutually-exclusive combination", () => {
-		const g = new Graph("g");
-		expect(() =>
-			(g as unknown as { observe: (...args: unknown[]) => unknown }).observe({
-				changeset: true,
-				reactive: true,
-			}),
-		).toThrow(/mutually exclusive/);
-	});
-
-	// /qa F-1: changeset stream subscribes to nodes added AFTER activation.
-	it("/qa F-1: streams data events for nodes added after subscription", () => {
-		const g = new Graph("g");
-		const { all, off } = collect(g);
-		all.length = 0;
-
-		// Add a fresh node post-activation; emit on it; expect data events.
-		const late = node<number>([], { initial: 0, equals: () => false });
-		g.add(late, { name: "late" });
-		all.length = 0; // drop the node-added event
-		g.set("late", 42);
-		g.set("late", 43);
-
-		const dataEvents = all.filter((e) => e.type === "data" && e.scope === "late");
-		expect(dataEvents.length).toBeGreaterThanOrEqual(2);
-		off();
-	});
-
-	// /qa F-21: subscriptions detach symmetrically on node-removed.
-	it("/qa F-21: stops streaming data events after node-removed", () => {
-		const g = new Graph("g");
-		const { all, off } = collect(g);
-
-		const live = node<number>([], { initial: 0, equals: () => false });
-		g.add(live, { name: "live" });
-		all.length = 0;
-		g.set("live", 1);
-		const before = all.filter((e) => e.type === "data" && e.scope === "live").length;
-		expect(before).toBeGreaterThan(0);
-
-		g.remove("live");
-		// After removal the node detaches; future emissions on the orphaned
-		// Node ref must not surface on the changeset stream.
-		all.length = 0;
-		live.emit(2);
-		const after = all.filter((e) => e.type === "data" && e.scope === "live").length;
-		expect(after).toBe(0);
-		off();
-	});
-
-	// /qa F-4: tier whitelist filters topology + batch frame variants.
-	it("/qa F-4: tiers: ['data'] filters out topology + batch events", () => {
-		const g = new Graph("g");
-		const out = g.observe({ changeset: true, tiers: ["data"] });
-		const all: GraphChange[] = [];
-		const off = out.subscribe((msgs) => {
-			for (const m of msgs) if (m[0] === DATA) all.push(m[1] as GraphChange);
-		});
-		const a = node<number>([], { initial: 0, equals: () => false });
-		g.add(a, { name: "a" });
-		batch(() => {
-			g.set("a", 1);
-			g.set("a", 2);
-		});
-		// No topology or batch-frame events should leak through.
-		expect(all.some((e) => e.type === "node-added")).toBe(false);
-		expect(all.some((e) => e.type === "batch-start")).toBe(false);
-		expect(all.some((e) => e.type === "batch-end")).toBe(false);
-		// Data events still flow.
-		expect(all.some((e) => e.type === "data")).toBe(true);
-		off();
-	});
-
-	// /qa F-3: GraphChangeNodeAdded carries the resolved describeKind.
-	it("/qa F-3: node-added events carry the resolved describeKind", () => {
-		const g = new Graph("g");
-		const { all, off } = collect(g);
-
-		// Add a state node — its describeKind is "state".
-		g.state("s", 0);
-		const stateAdded = all.find(
-			(e): e is GraphChange & { type: "node-added"; nodeKind?: string } =>
-				e.type === "node-added" && e.scope === "s",
-		);
-		expect(stateAdded).toBeDefined();
-		expect(stateAdded?.nodeKind).toBe("state");
-
-		// Add a derived node — describeKind "derived".
-		g.derived("d", ["s"], (data, ctx) => {
-			const x = data[0]?.[0] ?? ctx.prevData[0]?.[0] ?? 0;
-			return [x as number];
-		});
-		const derivedAdded = all.find(
-			(e): e is GraphChange & { type: "node-added"; nodeKind?: string } =>
-				e.type === "node-added" && e.scope === "d",
-		);
-		expect(derivedAdded).toBeDefined();
-		expect(derivedAdded?.nodeKind).toBe("derived");
-		off();
-	});
-});
diff --git a/packages/pure-ts/src/__tests__/graph/snapshot-cross-mount.test.ts b/packages/pure-ts/src/__tests__/graph/snapshot-cross-mount.test.ts
deleted file mode 100644
index f9008d40..00000000
--- a/packages/pure-ts/src/__tests__/graph/snapshot-cross-mount.test.ts
+++ /dev/null
@@ -1,298 +0,0 @@
-/**
- * M4.E1 / D276 — regression-pinning scenarios for cross-mount derived dep
- * snapshot round-trips. graphrefly-rs landed D276 on 2026-05-22 with the
- * claim that pure-ts had the same bidirectional gap (encode collapses
- * cross-mount deps to bare names; decode flat-lookup misses them). These
- * scenarios were authored 2026-05-22 to verify that premise: all 4 pass
- * against current pure-ts, so the cross-track-ledger §2 row 62 closes as
- * "verified divergence-free" — TS's `describe`-based tree-wide
- * `nodeToPath` encoding does not have the Rust-specific single-graph
- * fall-through to `_anon_<rawid>` that D276 fixed. Tests remain as pins
- * so a future refactor of `Graph.snapshot` / `Graph.fromSnapshot` can't
- * regress the bidirectional cross-mount contract.
- *
- * @module
- */
-
-import { describe, expect, it } from "vitest";
-
-import { node } from "../../core/node.js";
-import { Graph } from "../../graph/graph.js";
-
-describe("M4.E1: cross-mount derived dep snapshot round-trip", () => {
-	it("round-trips: snapshot → fromSnapshot → snapshot produces an equal snapshot (cross-mount)", () => {
-		// Build a topology where `c2::b` depends on `c1::a` (cross-mount).
-		const g = new Graph("root");
-		const c1 = new Graph("c1");
-		const c2 = new Graph("c2");
-		g.mount("c1", c1);
-		g.mount("c2", c2);
-		const a = node([], { name: "a", initial: 10 });
-		c1.add(a, { name: "a" });
-		const b = node(
-			[a],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit(((data[0] as number) ?? 0) + 1);
-			},
-			{ describeKind: "derived", name: "b" },
-		);
-		c2.add(b, { name: "b" });
-		b.subscribe(() => {});
-
-		const snap1 = g.snapshot();
-		// Critical: c2::b's deps in the snapshot MUST reference c1::a in some
-		// resolvable form. Inspect the encoded deps before testing decode.
-		expect(snap1.nodes["c2::b"]).toBeDefined();
-		const bDeps = snap1.nodes["c2::b"]?.deps ?? [];
-		expect(bDeps).toHaveLength(1);
-		// The encoded dep should resolve to c1::a — either as the qualified
-		// path "c1::a" (what nodeToPath yields for cross-mount reach) or as
-		// the bare local name "a" (the fallback shape that bites decode).
-		// If the failure mode is the bare-name fallback, decode will throw.
-		// We record the actual encoded shape so the test diagnoses which
-		// branch the bug sits in.
-		const encoded = bDeps[0] as string;
-		expect(encoded).toBeTypeOf("string");
-
-		// Decode side: reconstruct via factories and confirm `b` resolves.
-		const g2 = Graph.fromSnapshot(snap1, {
-			factories: {
-				"c2::b": (name, ctx) =>
-					node(
-						ctx.resolvedDeps,
-						(batchData, actions, ctx2) => {
-							const data = batchData.map((batch, i) =>
-								batch != null && batch.length > 0 ? batch.at(-1) : ctx2.prevData[i],
-							);
-							actions.emit(((data[0] as number) ?? 0) + 1);
-						},
-						{ describeKind: "derived", name },
-					),
-			},
-		});
-		const restoredB = g2.tryResolve("c2::b");
-		expect(restoredB).toBeDefined();
-
-		// Live propagation: setting c1::a must update c2::b through the
-		// rebuilt cross-mount dep.
-		restoredB?.subscribe(() => {});
-		g2.set("c1::a", 99);
-		expect(g2.node("c2::b").cache).toBe(100);
-
-		// Idempotent round-trip — re-snapshot must equal the first snapshot
-		// shape (deps encoded identically). Lock the steady-state.
-		const snap2 = g2.snapshot();
-		expect(snap2.nodes["c2::b"]?.deps).toEqual(snap1.nodes["c2::b"]?.deps);
-	});
-
-	it("round-trips a 3-level deep chain that crosses three mounts", () => {
-		// c1::a → c2::b → c3::c — each level lives in its own mount sibling.
-		const g = new Graph("root");
-		const c1 = new Graph("c1");
-		const c2 = new Graph("c2");
-		const c3 = new Graph("c3");
-		g.mount("c1", c1);
-		g.mount("c2", c2);
-		g.mount("c3", c3);
-		const a = node([], { name: "a", initial: 1 });
-		c1.add(a, { name: "a" });
-		const b = node(
-			[a],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit(((data[0] as number) ?? 0) * 2);
-			},
-			{ describeKind: "derived", name: "b" },
-		);
-		c2.add(b, { name: "b" });
-		const c = node(
-			[b],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit(((data[0] as number) ?? 0) + 100);
-			},
-			{ describeKind: "derived", name: "c" },
-		);
-		c3.add(c, { name: "c" });
-		c.subscribe(() => {});
-
-		const snap = g.snapshot();
-		const factory = (name: string, ctx: { resolvedDeps: ReadonlyArray<unknown> }) =>
-			node(
-				ctx.resolvedDeps as ReadonlyArray<import("../../core/node.js").NodeInput<unknown>>,
-				(batchData: Array<ReadonlyArray<unknown> | undefined>, actions, ctx2) => {
-					const data = batchData.map((batch, i) =>
-						batch != null && batch.length > 0 ? batch.at(-1) : ctx2.prevData[i],
-					);
-					if (name === "b") actions.emit(((data[0] as number) ?? 0) * 2);
-					else actions.emit(((data[0] as number) ?? 0) + 100);
-				},
-				{ describeKind: "derived", name },
-			);
-		const g2 = Graph.fromSnapshot(snap, {
-			factories: {
-				"c2::b": factory,
-				"c3::c": factory,
-			},
-		});
-		g2.node("c3::c").subscribe(() => {});
-		expect(g2.node("c3::c").cache).toBe(102); // 1 * 2 + 100
-		g2.set("c1::a", 5);
-		expect(g2.node("c3::c").cache).toBe(110); // 5 * 2 + 100
-	});
-
-	it("round-trips a cross-mount-UP-into-parent dep (child node depends on a root-graph state)", () => {
-		// QA F4 pin (2026-05-22): the original 3 tests covered cross-mount
-		// SIBLING + 3-level deep DOWN. This test pins the orthogonal axis: a
-		// node inside a mount depending UP on a node owned by the parent
-		// root graph. `nodeToPath` for a tree-wide describe walks `root` →
-		// children, so `root_state` (registered on `root` directly) encodes
-		// as bare `"root_state"` while `c1::b` encodes as `"c1::b"`. The
-		// asymmetry is real and worth pinning so a future tree-wide-encode
-		// refactor can't silently break the up-into-parent case.
-		const g = new Graph("root");
-		const c1 = new Graph("c1");
-		g.mount("c1", c1);
-		const rootState = node([], { name: "root_state", initial: 7 });
-		g.add(rootState, { name: "root_state" });
-		const b = node(
-			[rootState],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit(((data[0] as number) ?? 0) + 10);
-			},
-			{ describeKind: "derived", name: "b" },
-		);
-		c1.add(b, { name: "b" });
-		b.subscribe(() => {});
-
-		const snap = g.snapshot();
-		expect(snap.nodes["c1::b"]).toBeDefined();
-		const bDeps = snap.nodes["c1::b"]?.deps ?? [];
-		expect(bDeps).toHaveLength(1);
-		// Lock the wire shape: dep on a root-owned node encodes as the bare
-		// `"root_state"` name (not `"root::root_state"` — root self-name is
-		// stripped per the describe contract).
-		expect(bDeps[0]).toBe("root_state");
-
-		const g2 = Graph.fromSnapshot(snap, {
-			factories: {
-				"c1::b": (name, ctx) =>
-					node(
-						ctx.resolvedDeps,
-						(batchData, actions, ctx2) => {
-							const data = batchData.map((batch, i) =>
-								batch != null && batch.length > 0 ? batch.at(-1) : ctx2.prevData[i],
-							);
-							actions.emit(((data[0] as number) ?? 0) + 10);
-						},
-						{ describeKind: "derived", name },
-					),
-			},
-		});
-		g2.node("c1::b").subscribe(() => {});
-		expect(g2.node("c1::b").cache).toBe(17); // 7 + 10
-		// Live propagation through the rebuilt up-into-parent dep.
-		g2.set("root_state", 42);
-		expect(g2.node("c1::b").cache).toBe(52);
-	});
-
-	it("round-trips a diamond cross-mount: c2::b depends on BOTH c1::a AND c3::a", () => {
-		// QA F4 pin (2026-05-22): two distinct cross-mount deps on a single
-		// derived node. Validates that the tree-wide `nodeToPath` encoding
-		// produces TWO qualified paths in `deps`, the decode `created.has`
-		// retry loop resolves both before factory invocation, and the
-		// rebuilt node receives the correct ordered `resolvedDeps`. Rust
-		// D276's tree-wide hydration explicitly handles multi-dep ordering;
-		// this pins TS does too.
-		const g = new Graph("root");
-		const c1 = new Graph("c1");
-		const c2 = new Graph("c2");
-		const c3 = new Graph("c3");
-		g.mount("c1", c1);
-		g.mount("c2", c2);
-		g.mount("c3", c3);
-		const a1 = node([], { name: "a", initial: 10 });
-		c1.add(a1, { name: "a" });
-		const a3 = node([], { name: "a", initial: 20 });
-		c3.add(a3, { name: "a" });
-		const b = node(
-			[a1, a3],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit(((data[0] as number) ?? 0) + ((data[1] as number) ?? 0));
-			},
-			{ describeKind: "derived", name: "b" },
-		);
-		c2.add(b, { name: "b" });
-		b.subscribe(() => {});
-
-		const snap = g.snapshot();
-		const bDeps = snap.nodes["c2::b"]?.deps ?? [];
-		// Lock the wire shape: BOTH deps encode as qualified paths, in
-		// declared dep order (c1::a first, c3::a second). Same-local-name
-		// collision (`a` in both `c1` and `c3`) is disambiguated by the
-		// mount prefix — pinning that disambiguation.
-		expect(bDeps).toEqual(["c1::a", "c3::a"]);
-
-		const g2 = Graph.fromSnapshot(snap, {
-			factories: {
-				"c2::b": (name, ctx) =>
-					node(
-						ctx.resolvedDeps,
-						(batchData, actions, ctx2) => {
-							const data = batchData.map((batch, i) =>
-								batch != null && batch.length > 0 ? batch.at(-1) : ctx2.prevData[i],
-							);
-							actions.emit(((data[0] as number) ?? 0) + ((data[1] as number) ?? 0));
-						},
-						{ describeKind: "derived", name },
-					),
-			},
-		});
-		g2.node("c2::b").subscribe(() => {});
-		expect(g2.node("c2::b").cache).toBe(30); // 10 + 20
-		// Both deps must propagate independently after restore.
-		g2.set("c1::a", 100);
-		expect(g2.node("c2::b").cache).toBe(120); // 100 + 20
-		g2.set("c3::a", 200);
-		expect(g2.node("c2::b").cache).toBe(300); // 100 + 200
-	});
-
-	it("back-compat: same-graph deps still encode as bare local names", () => {
-		// Lock the existing behavior so cross-mount fixes don't disturb the
-		// established single-graph encoding (Rust D276's "same-graph deps
-		// collapse to bare local names" invariant).
-		const g = new Graph("g");
-		const a = node([], { name: "a", initial: 1 });
-		g.add(a, { name: "a" });
-		const b = node(
-			[a],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit(((data[0] as number) ?? 0) + 1);
-			},
-			{ describeKind: "derived", name: "b" },
-		);
-		g.add(b, { name: "b" });
-		b.subscribe(() => {});
-
-		const snap = g.snapshot();
-		// Same-graph dep should be the bare local name "a", NOT "g::a" —
-		// pinning the back-compat wire shape.
-		expect(snap.nodes.b?.deps).toEqual(["a"]);
-	});
-});
diff --git a/packages/pure-ts/src/__tests__/graph/topology.test.ts b/packages/pure-ts/src/__tests__/graph/topology.test.ts
deleted file mode 100644
index 0d77cb38..00000000
--- a/packages/pure-ts/src/__tests__/graph/topology.test.ts
+++ /dev/null
@@ -1,208 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { DATA } from "../../core/messages.js";
-import { node } from "../../core/node.js";
-
-import { Graph, type TopologyEvent } from "../../graph/index.js";
-
-function collectTopology(g: Graph): {
-	events: TopologyEvent[];
-	stop: () => void;
-} {
-	const events: TopologyEvent[] = [];
-	const off = g.topology.subscribe((msgs) => {
-		for (const m of msgs) {
-			if (m[0] === DATA) events.push(m[1] as TopologyEvent);
-		}
-	});
-	return { events, stop: off };
-}
-
-describe("Graph.topology (structural-change companion)", () => {
-	it("emits { added, node } on add()", () => {
-		const g = new Graph("g");
-		const { events, stop } = collectTopology(g);
-		g.add(node([], { initial: 1 }), { name: "a" });
-		expect(events).toEqual([{ kind: "added", name: "a", nodeKind: "node" }]);
-		stop();
-	});
-
-	it("emits { added, mount } on mount()", () => {
-		const parent = new Graph("parent");
-		const { events, stop } = collectTopology(parent);
-		const child = new Graph("child");
-		parent.mount("kids", child);
-		expect(events).toEqual([{ kind: "added", name: "kids", nodeKind: "mount" }]);
-		stop();
-	});
-
-	it("emits { removed, node, audit } on remove() of a local node", () => {
-		const g = new Graph("g");
-		g.add(node([], { initial: 1 }), { name: "a" });
-		const { events, stop } = collectTopology(g);
-		g.remove("a");
-		expect(events).toHaveLength(1);
-		const e = events[0]!;
-		expect(e.kind).toBe("removed");
-		expect(e.name).toBe("a");
-		expect(e.nodeKind).toBe("node");
-		if (e.kind === "removed") {
-			expect(e.audit).toEqual({ kind: "node", nodes: ["a"], mounts: [] });
-		}
-		stop();
-	});
-
-	it("emits { removed, mount, audit } on unmount", () => {
-		const parent = new Graph("parent");
-		const child = new Graph("child");
-		child.add(node([], { initial: 0 }), { name: "x" });
-		parent.mount("kids", child);
-		const { events, stop } = collectTopology(parent);
-		parent.remove("kids");
-		expect(events).toHaveLength(1);
-		const e = events[0]!;
-		expect(e.kind).toBe("removed");
-		expect(e.name).toBe("kids");
-		expect(e.nodeKind).toBe("mount");
-		if (e.kind === "removed") {
-			expect(e.audit.kind).toBe("mount");
-			expect(e.audit.mounts).toContain("kids");
-			expect(e.audit.nodes).toContain("x");
-		}
-		stop();
-	});
-
-	it("is silent at construction — constructor does not emit", () => {
-		const g = new Graph("g");
-		const { events, stop } = collectTopology(g);
-		// No mutations, no events.
-		expect(events).toEqual([]);
-		stop();
-	});
-
-	it("does not emit for value mutations (only structural changes)", () => {
-		const g = new Graph("g");
-		const a = node([], { name: "a", initial: 0 });
-		g.add(a, { name: "a" });
-		const { events, stop } = collectTopology(g);
-		a.emit(1);
-		a.emit(2);
-		expect(events).toEqual([]);
-		stop();
-	});
-
-	it("does not emit events that happened before first subscription (no retention)", () => {
-		const g = new Graph("g");
-		g.add(node([], { initial: 1 }), { name: "a" });
-		g.add(node([], { initial: 2 }), { name: "b" });
-		const { events, stop } = collectTopology(g);
-		// Late subscriber sees only subsequent events.
-		expect(events).toEqual([]);
-		g.add(node([], { initial: 3 }), { name: "c" });
-		expect(events).toEqual([{ kind: "added", name: "c", nodeKind: "node" }]);
-		stop();
-	});
-
-	it("own-graph only — parent topology does NOT emit for changes inside a mounted child", () => {
-		const parent = new Graph("parent");
-		const child = new Graph("child");
-		parent.mount("kids", child);
-		const { events, stop } = collectTopology(parent);
-		child.add(node([], { initial: 0 }), { name: "x" });
-		// parent sees no event — the add happened on `child`, not `parent`.
-		expect(events).toEqual([]);
-		// child's own topology does see it
-		const childObs = collectTopology(child);
-		child.add(node([], { initial: 1 }), { name: "y" });
-		expect(childObs.events).toEqual([{ kind: "added", name: "y", nodeKind: "node" }]);
-		childObs.stop();
-		stop();
-	});
-
-	it("does not emit on failed add() (name collision) — emit only after successful registration", () => {
-		const g = new Graph("g");
-		g.add(node([], { initial: 1 }), { name: "a" });
-		const { events, stop } = collectTopology(g);
-		expect(() => g.add(node([], { initial: 2 }), { name: "a" })).toThrow(/already exists/);
-		expect(events).toEqual([]);
-		stop();
-	});
-
-	it("does not emit on failed mount() (cycle / reparent / collision)", () => {
-		const parent = new Graph("parent");
-		const child = new Graph("child");
-		parent.mount("kids", child);
-		const { events, stop } = collectTopology(parent);
-		// Reparent rejection
-		expect(() => parent.mount("kids2", child)).toThrow(/already mounted/);
-		expect(events).toEqual([]);
-		stop();
-	});
-
-	it("lazy: accessing .topology without subscribing does not activate the producer", () => {
-		const g = new Graph("g");
-		// Access the node (creates it) but do not subscribe.
-		const topology = g.topology;
-		expect(topology).toBeDefined();
-		// Perform mutations — nothing should be observable since no sink exists.
-		g.add(node([], { initial: 1 }), { name: "a" });
-		g.add(node([], { initial: 2 }), { name: "b" });
-		// Subscribe AFTER mutations — no retention of past events.
-		const { events, stop } = collectTopology(g);
-		expect(events).toEqual([]);
-		stop();
-	});
-
-	it("same Node reference across accesses (getter is cached)", () => {
-		const g = new Graph("g");
-		const t1 = g.topology;
-		const t2 = g.topology;
-		expect(t1).toBe(t2);
-	});
-
-	it("multiple subscribers each receive each event", () => {
-		const g = new Graph("g");
-		const a = collectTopology(g);
-		const b = collectTopology(g);
-		g.add(node([], { initial: 0 }), { name: "x" });
-		expect(a.events).toEqual([{ kind: "added", name: "x", nodeKind: "node" }]);
-		expect(b.events).toEqual([{ kind: "added", name: "x", nodeKind: "node" }]);
-		a.stop();
-		b.stop();
-	});
-
-	it("bulk-remove via filter loop emits one 'removed' event per entry", () => {
-		const g = new Graph("g");
-		g.add(node([], { initial: 1 }), { name: "a" });
-		g.add(node([], { initial: 2 }), { name: "b" });
-		g.add(node([], { initial: 3 }), { name: "c" });
-		const { events, stop } = collectTopology(g);
-		// Snapshot the universe from the graph itself so future fixture
-		// growth is picked up automatically (mirrors the deleted
-		// `g.removeAll(filter)` snapshot semantics).
-		const universe = [...g._nodes.keys(), ...g._mounts.keys()];
-		for (const name of universe.filter((n) => n !== "b")) {
-			g.remove(name);
-		}
-		// Should see two "removed" events for a and c
-		expect(events.filter((e) => e.kind === "removed")).toHaveLength(2);
-		const names = events.filter((e) => e.kind === "removed").map((e) => e.name);
-		expect(names.sort()).toEqual(["a", "c"]);
-		stop();
-	});
-
-	it("interleaved add + remove yields correct event sequence", () => {
-		const g = new Graph("g");
-		const { events, stop } = collectTopology(g);
-		g.add(node([], { initial: 1 }), { name: "a" });
-		g.add(node([], { initial: 2 }), { name: "b" });
-		g.remove("a");
-		g.add(node([], { initial: 3 }), { name: "c" });
-		expect(events.map((e) => `${e.kind}:${e.name}`)).toEqual([
-			"added:a",
-			"added:b",
-			"removed:a",
-			"added:c",
-		]);
-		stop();
-	});
-});
diff --git a/packages/pure-ts/src/__tests__/graph/validate-describe-appendix-b.ts b/packages/pure-ts/src/__tests__/graph/validate-describe-appendix-b.ts
deleted file mode 100644
index f07aeb18..00000000
--- a/packages/pure-ts/src/__tests__/graph/validate-describe-appendix-b.ts
+++ /dev/null
@@ -1,58 +0,0 @@
-import { expect } from "vitest";
-
-/** GRAPHREFLY-SPEC Appendix B — mirrors `describe-appendix-b.schema.json` in this folder. */
-
-const NODE_TYPES = new Set(["state", "derived", "producer", "operator", "effect"]);
-const STATUSES = new Set([
-	"disconnected",
-	"sentinel",
-	"dirty",
-	"settled",
-	"resolved",
-	"completed",
-	"errored",
-]);
-
-/**
- * Structural validation matching Appendix B / `describe-appendix-b.schema.json`
- * (no JSON Schema runtime — keeps devDependencies minimal).
- */
-export function assertDescribeMatchesAppendixB(data: unknown): void {
-	expect(data).toEqual(expect.any(Object));
-	const d = data as Record<string, unknown>;
-	expect(typeof d.name).toBe("string");
-	expect(d.nodes).toEqual(expect.any(Object));
-	expect(Array.isArray(d.edges)).toBe(true);
-	// `Graph.describe()` always includes `subgraphs` (GRAPHREFLY-SPEC Appendix B).
-	expect(Array.isArray(d.subgraphs)).toBe(true);
-	for (const s of d.subgraphs as unknown[]) {
-		expect(typeof s).toBe("string");
-	}
-
-	for (const edge of d.edges as unknown[]) {
-		expect(edge).toEqual(expect.any(Object));
-		const e = edge as Record<string, unknown>;
-		expect(typeof e.from).toBe("string");
-		expect(typeof e.to).toBe("string");
-	}
-
-	const nodes = d.nodes as Record<string, unknown>;
-	for (const [path, slice] of Object.entries(nodes)) {
-		expect(path.length).toBeGreaterThan(0);
-		expect(slice).toEqual(expect.any(Object));
-		const n = slice as Record<string, unknown>;
-		expect(typeof n.type).toBe("string");
-		expect(NODE_TYPES.has(n.type as string)).toBe(true);
-		expect(typeof n.status).toBe("string");
-		expect(STATUSES.has(n.status as string)).toBe(true);
-		if (n.deps !== undefined) {
-			expect(Array.isArray(n.deps)).toBe(true);
-			for (const dep of n.deps as unknown[]) {
-				expect(typeof dep).toBe("string");
-			}
-		}
-		if (n.meta !== undefined) {
-			expect(n.meta).toEqual(expect.any(Object));
-		}
-	}
-}
diff --git a/packages/pure-ts/src/__tests__/graph/validate-no-islands.test.ts b/packages/pure-ts/src/__tests__/graph/validate-no-islands.test.ts
deleted file mode 100644
index b849ac9c..00000000
--- a/packages/pure-ts/src/__tests__/graph/validate-no-islands.test.ts
+++ /dev/null
@@ -1,205 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { node } from "../../core/node.js";
-
-import { Graph } from "../../graph/graph.js";
-import { validateNoIslands } from "../../graph/validate-no-islands.js";
-
-describe("validateNoIslands (Tier 9.3)", () => {
-	it("passes a connected graph (state → derived chain)", () => {
-		const g = new Graph("g");
-		const a = node([], { name: "a", initial: 1 });
-		const b = node(
-			[a],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as number) * 2);
-			},
-			{ describeKind: "derived", name: "b" },
-		);
-		g.add(a, { name: "a" });
-		g.add(b, { name: "b" });
-		const r = validateNoIslands(g);
-		expect(r.ok).toBe(true);
-		expect(r.orphans).toEqual([]);
-		expect(r.summary()).toBe("validateNoIslands: ok (no islands)");
-	});
-
-	it("reports a node with zero in-edges AND zero out-edges as an island", () => {
-		const g = new Graph("g");
-		const a = node([], { name: "a", initial: 1 });
-		const b = node(
-			[a],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as number) * 2);
-			},
-			{ describeKind: "derived", name: "b" },
-		);
-		const orphan = node([], { name: "orphan", initial: 99 });
-		g.add(a, { name: "a" });
-		g.add(b, { name: "b" });
-		g.add(orphan, { name: "orphan" });
-		const r = validateNoIslands(g);
-		expect(r.ok).toBe(false);
-		expect(r.orphans).toHaveLength(1);
-		expect(r.orphans[0]?.path).toBe("orphan");
-		// A3 (qa): orphans surface kind alongside path for triage.
-		expect(r.orphans[0]?.kind).toBe("state");
-		expect(r.summary()).toContain("1 island node(s)");
-		expect(r.summary()).toContain("orphan");
-		expect(r.summary()).toContain("(state)");
-	});
-
-	it("does NOT flag source nodes (zero in-edges, ≥1 out-edge)", () => {
-		// `a` has no deps but `b` declares it; out-edge count = 1 → not an island.
-		const g = new Graph("g");
-		const a = node([], { name: "a", initial: 1 });
-		const b = node(
-			[a],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as number) * 2);
-			},
-			{ describeKind: "derived", name: "b" },
-		);
-		g.add(a, { name: "a" });
-		g.add(b, { name: "b" });
-		const r = validateNoIslands(g);
-		expect(r.orphans.find((o) => o.path === "a")).toBeUndefined();
-	});
-
-	it("does NOT flag sink nodes (≥1 in-edge, zero out-edges)", () => {
-		// `b` has deps but no other node references it → in=1, out=0 → not an island.
-		const g = new Graph("g");
-		const a = node([], { name: "a", initial: 1 });
-		const b = node(
-			[a],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as number) * 2);
-			},
-			{ describeKind: "derived", name: "b" },
-		);
-		g.add(a, { name: "a" });
-		g.add(b, { name: "b" });
-		const r = validateNoIslands(g);
-		expect(r.orphans.find((o) => o.path === "b")).toBeUndefined();
-	});
-
-	it("reports multiple orphans sorted by path (A9: insertion-order doesn't match sort order)", () => {
-		// A9: insert in order that does NOT match sorted output, with mixed
-		// case and digits, so the assertion actively distinguishes "sorted"
-		// from "insertion-ordered".
-		const g = new Graph("g");
-		g.add(node([], { name: "Zeta", initial: 0 }), { name: "Zeta" });
-		g.add(node([], { name: "alpha", initial: 0 }), { name: "alpha" });
-		g.add(node([], { name: "Beta", initial: 0 }), { name: "Beta" });
-		g.add(node([], { name: "10gamma", initial: 0 }), { name: "10gamma" });
-		const r = validateNoIslands(g);
-		// ASCII-asc: digits < uppercase < lowercase.
-		expect(r.orphans.map((o) => o.path)).toEqual(["10gamma", "Beta", "Zeta", "alpha"]);
-	});
-
-	it("walks mounted subgraphs (path-qualified orphans appear with subgraph prefix)", () => {
-		const g = new Graph("parent");
-		const sub = new Graph("child");
-		sub.add(node([], { name: "subOrphan", initial: 0 }), { name: "subOrphan" });
-		g.mount("child", sub);
-		// Add a connected pair on the parent so the mounted-orphan is the only flag.
-		const a = node([], { name: "a", initial: 1 });
-		const b = node(
-			[a],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as number) * 2);
-			},
-			{ describeKind: "derived", name: "b" },
-		);
-		g.add(a, { name: "a" });
-		g.add(b, { name: "b" });
-		const r = validateNoIslands(g);
-		expect(r.ok).toBe(false);
-		// Mounted child paths use `<mountName>::<path>` qualification.
-		expect(r.orphans.map((o) => o.path)).toContain("child::subOrphan");
-	});
-
-	it("EH-9: filters synthetic __internal__/ paths from orphan list", () => {
-		// `__internal__/` is the synthetic prefix the registrar falls back to
-		// for unnamed factory helpers; those are bookkeeping, not user
-		// topology. validateNoIslands suppresses them so callers don't get
-		// false-positives from compound factories.
-		const g = new Graph("g");
-		const a = node([], { name: "a", initial: 1 });
-		const b = node(
-			[a],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as number) * 2);
-			},
-			{ describeKind: "derived", name: "b" },
-		);
-		g.add(a, { name: "a" });
-		g.add(b, { name: "b" });
-		// Inject a node under the synthetic prefix that would otherwise look
-		// like an orphan (zero deps, no other node references it).
-		const helper = node([], { name: "__internal__/helper", initial: 0 });
-		g.add(helper, { name: "__internal__/helper" });
-		const r = validateNoIslands(g);
-		expect(r.ok).toBe(true);
-		expect(r.orphans.find((o) => o.path.startsWith("__internal__/"))).toBeUndefined();
-	});
-
-	it("EH-9 (qa P6): filter is path-prefix based and coexists with real orphans", () => {
-		// qa P6: the prior test only covered the prefix-string-filter contract
-		// using a user-named node. This test exercises the real
-		// graph.ts transitive-walk path that synthesizes `__internal__/N`
-		// names — a registered derived whose dep is an UNREGISTERED unnamed
-		// state. describe() walks the dep into `__internal__/0`. Confirm
-		// (a) the synthetic path actually appears in describe under the
-		// `__internal__/` prefix, and (b) the filter still surfaces a
-		// genuine orphan alongside it.
-		const g = new Graph("g");
-		// Unregistered unnamed source. graph.ts:1959 will assign it
-		// `__internal__/0` during describe().
-		const unnamedSource = node([], { initial: 7 });
-		const consumer = node(
-			[unnamedSource],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as number) + 1);
-			},
-			{ describeKind: "derived", name: "consumer" },
-		);
-		g.add(consumer, { name: "consumer" });
-		// A real orphan — must still be flagged.
-		g.add(node([], { name: "real-orphan", initial: 99 }), { name: "real-orphan" });
-
-		const desc = g.describe({ detail: "minimal" });
-		const allPaths = Object.keys(desc.nodes);
-		const synthPath = allPaths.find((p) => p.startsWith("__internal__/"));
-		expect(
-			synthPath,
-			"describe should synthesize an __internal__/ path for the unnamed dep",
-		).toBeDefined();
-
-		const r = validateNoIslands(g);
-		// Synthetic paths NEVER appear in orphans regardless of edges.
-		expect(r.orphans.find((o) => o.path.startsWith("__internal__/"))).toBeUndefined();
-		// Real orphan still flagged.
-		expect(r.orphans.map((o) => o.path)).toContain("real-orphan");
-	});
-});
diff --git a/packages/pure-ts/src/__tests__/properties/_generators.ts b/packages/pure-ts/src/__tests__/properties/_generators.ts
deleted file mode 100644
index f6847ee3..00000000
--- a/packages/pure-ts/src/__tests__/properties/_generators.ts
+++ /dev/null
@@ -1,138 +0,0 @@
-/**
- * Shared fast-check generators for the protocol-invariant harness.
- *
- * Topologies live next to the invariants that exercise them (`_invariants.ts`)
- * — each invariant picks the smallest topology that demonstrates the property.
- * This module ships only the **event-sequence** vocabulary used to drive those
- * topologies and the trace-recording helpers shared by every invariant.
- *
- * See `archive/docs/SESSION-rigor-infrastructure-plan.md` § "Project 1" for the
- * full motivation and the 9-invariant target list (first 6 land here).
- */
-
-import * as fc from "fast-check";
-import { batch } from "../../core/batch.js";
-import { COMPLETE, START } from "../../core/messages.js";
-import type { Node } from "../../core/node.js";
-
-// ---------------------------------------------------------------------------
-// Event vocabulary
-// ---------------------------------------------------------------------------
-
-export type EmitEvent = { readonly kind: "emit"; readonly value: number };
-export type BatchEvent = { readonly kind: "batch"; readonly values: readonly number[] };
-export type CompleteEvent = { readonly kind: "complete" };
-export type Event = EmitEvent | BatchEvent | CompleteEvent;
-
-export interface EventSequenceOptions {
-	readonly maxLen?: number;
-	/** Inclusive value range for emitted numbers. Small alphabet exercises equals-substitution. */
-	readonly valueRange?: readonly [number, number];
-	/**
-	 * Cap on source emits inside one `batch` event. Defaults to 4 (full
-	 * coverage). Set to `1` to keep batches structurally present but with a
-	 * single emit each — used by invariant #4 to dodge the documented
-	 * "multi-emit batch fires K+1 settlements at fan-in" finding (see
-	 * `docs/optimizations.md`).
-	 */
-	readonly maxBatchEmits?: number;
-}
-
-/**
- * fast-check arbitrary producing a list of state-mutation events. Never
- * emits `complete` — invariants that need a terminal inject one explicitly.
- * Values are drawn from a small alphabet (default 0–4) so equal-value
- * emissions are common, exercising the equals-substitution path.
- */
-export function eventSequenceArb(opts: EventSequenceOptions = {}): fc.Arbitrary<readonly Event[]> {
-	const [lo, hi] = opts.valueRange ?? [0, 4];
-	const value = fc.integer({ min: lo, max: hi });
-	const emitArb: fc.Arbitrary<EmitEvent> = fc.record({
-		kind: fc.constant<"emit">("emit"),
-		value,
-	});
-	const batchArb: fc.Arbitrary<BatchEvent> = fc.record({
-		kind: fc.constant<"batch">("batch"),
-		values: fc.array(value, { minLength: 1, maxLength: opts.maxBatchEmits ?? 4 }),
-	});
-	return fc.array(fc.oneof({ weight: 7, arbitrary: emitArb }, { weight: 2, arbitrary: batchArb }), {
-		minLength: 1,
-		maxLength: opts.maxLen ?? 10,
-	});
-}
-
-// ---------------------------------------------------------------------------
-// Source driver
-// ---------------------------------------------------------------------------
-
-/**
- * Apply one event to a source. Unexpected throws propagate as fast-check
- * property failures — that is the desired behaviour for the harness. Only
- * the post-COMPLETE skip is defensive; everything else trusts the substrate
- * to either succeed or expose a real bug.
- */
-export function applyEvent(
-	source: Node<number>,
-	event: Event,
-	completed: { value: boolean },
-): void {
-	if (completed.value) return;
-	if (event.kind === "emit") {
-		source.emit(event.value);
-	} else if (event.kind === "batch") {
-		batch(() => {
-			for (const v of event.values) source.emit(v);
-		});
-	} else {
-		source.down([[COMPLETE]]);
-		completed.value = true;
-	}
-}
-
-// ---------------------------------------------------------------------------
-// Trace recording
-// ---------------------------------------------------------------------------
-
-export interface Trace {
-	/** Flat list of message types in delivery order (START filtered). */
-	readonly types: symbol[];
-	/** Parallel array of payloads (`undefined` for tuples without a payload). */
-	readonly values: unknown[];
-	/**
-	 * Position of the first post-activation message. Messages in
-	 * `types[0..activationEnd-1]` came from the synchronous `subscribe()`
-	 * handshake (push-on-subscribe, §2.2); messages at `activationEnd` and
-	 * after are event-driven.
-	 */
-	readonly activationEnd: number;
-}
-
-/**
- * Subscribe to `node`, drive `events` against `source`, return the recorded
- * trace. `node` and `source` may be the same (invariants that observe the
- * source directly) or different (downstream invariants).
- *
- * `activationEnd` is captured the instant `subscribe()` returns, giving
- * invariants a clean boundary to skip push-on-subscribe deliveries without
- * depending on heuristics like "first DIRTY."
- */
-export function captureTrace<T>(
-	node: Node<T>,
-	source: Node<number>,
-	events: readonly Event[],
-): Trace {
-	const types: symbol[] = [];
-	const values: unknown[] = [];
-	const unsub = node.subscribe((msgs) => {
-		for (const msg of msgs as readonly [symbol, unknown?][]) {
-			if (msg[0] === START) continue;
-			types.push(msg[0]);
-			values.push(msg[1]);
-		}
-	});
-	const activationEnd = types.length;
-	const completed = { value: false };
-	for (const e of events) applyEvent(source, e, completed);
-	unsub();
-	return { types, values, activationEnd };
-}
diff --git a/packages/pure-ts/src/__tests__/properties/_invariants.ts b/packages/pure-ts/src/__tests__/properties/_invariants.ts
deleted file mode 100644
index 119b8bbe..00000000
--- a/packages/pure-ts/src/__tests__/properties/_invariants.ts
+++ /dev/null
@@ -1,5419 +0,0 @@
-/**
- * Protocol invariant registry — all 9 invariants from
- * `archive/docs/SESSION-rigor-infrastructure-plan.md` § "Project 1".
- *
- * Each entry is a self-contained property the harness runs via fast-check.
- * The registry shape is the **LLM-readable contract surface**: an LLM (or a
- * future scorecard generator) can enumerate `INVARIANTS` to discover what the
- * substrate guarantees, without reading any operator code.
- *
- * Companion TLA+ spec at `~/src/graphrefly/formal/wave_protocol.tla` encodes
- * the first 6 (protocol-layer) invariants for exhaustive model checking by
- * TLC. Invariants 7–9 target the subscribe lifecycle (START handshake,
- * throw recovery, unsub-reentry), which the TLA+ model doesn't currently
- * model — they live only in the fast-check harness. Counter-examples from
- * TLC port directly into new `Invariant` entries here. See
- * `~/src/graphrefly/formal/README.md` for the porting workflow.
- *
- * Adding a new invariant: append a new `Invariant` object below; the iterating
- * test file in `protocol-invariants.test.ts` will pick it up automatically.
- * Names must be unique — enforced at module load.
- */
-
-import * as fc from "fast-check";
-import { vi } from "vitest";
-import { batch } from "../../core/batch.js";
-import {
-	GraphReFlyConfig,
-	type NodeCtx,
-	type RigorRecorder,
-	registerBuiltins,
-} from "../../core/config.js";
-import { policy } from "../../core/guard.js";
-import {
-	COMPLETE,
-	DATA,
-	DIRTY,
-	ERROR,
-	INVALIDATE,
-	type Messages,
-	PAUSE,
-	RESOLVED,
-	RESUME,
-	START,
-} from "../../core/messages.js";
-import { defaultConfig, type Node, node } from "../../core/node.js";
-import {
-	buffer,
-	bufferCount,
-	bufferTime,
-	combine,
-	concat,
-	concatMap,
-	debounce,
-	delay,
-	distinctUntilChanged,
-	elementAt,
-	exhaustMap,
-	filter,
-	find,
-	interval,
-	last,
-	map,
-	merge,
-	mergeMap,
-	pairwise,
-	race,
-	reduce,
-	repeat,
-	rescue,
-	sample,
-	scan,
-	skip,
-	switchMap,
-	take,
-	takeUntil,
-	takeWhile,
-	tap,
-	throttle,
-	timeout,
-	windowCount,
-	zip,
-} from "../../extra/operators/index.js";
-import { Graph } from "../../graph/graph.js";
-import { latestVals } from "../test-helpers.js";
-import { applyEvent, captureTrace, type Event, eventSequenceArb } from "./_generators.js";
-
-// ---------------------------------------------------------------------------
-// Registry shape
-// ---------------------------------------------------------------------------
-
-export interface Invariant {
-	/** kebab-case identifier — used as the vitest test name. Must be unique. */
-	readonly name: string;
-	/** Human + LLM-readable summary. Single sentence. */
-	readonly description: string;
-	/** Reference into `~/src/graphrefly/GRAPHREFLY-SPEC.md` (section anchor). */
-	readonly specRef: string;
-	/** Returns the fast-check property this invariant asserts. */
-	readonly property: () => fc.IPropertyWithHooks<unknown>;
-	/** fast-check run count override (default 100). */
-	readonly numRuns?: number;
-	/**
-	 * When set, this invariant is **authored ahead of a known substrate gap** —
-	 * it encodes the behavior the framework SHOULD guarantee, but the current
-	 * implementation does not. The test runner skips these (via `it.skip`) so
-	 * CI stays green, but the registry still surfaces them to LLMs and
-	 * docs-gen as part of the contract surface.
-	 *
-	 * Landing the substrate fix is the trigger to flip this to `undefined`
-	 * and let the test run — a failing property then means the fix regressed.
-	 * The value is the docs/optimizations.md anchor the fix is tracked under.
-	 */
-	readonly openUntilSubstrateFix?: string;
-}
-
-// ---------------------------------------------------------------------------
-// Helpers — small predicates over recorded traces
-// ---------------------------------------------------------------------------
-
-/** Number of source emits a wave attempts (batch-wave fans out to N attempts). */
-function waveAttemptCount(event: Event): number {
-	if (event.kind === "emit") return 1;
-	if (event.kind === "batch") return event.values.length;
-	return 0;
-}
-
-/** Capture trace as a list of per-wave segments (one segment per event). */
-function captureTracePerWave<T>(
-	leaf: Node<T>,
-	source: Node<number>,
-	events: readonly Event[],
-): { initial: symbol[]; perWave: symbol[][] } {
-	const initial: symbol[] = [];
-	let bucket: symbol[] = initial;
-	const unsub = leaf.subscribe((msgs) => {
-		for (const msg of msgs as readonly [symbol, unknown?][]) {
-			if (msg[0] === START) continue;
-			bucket.push(msg[0]);
-		}
-	});
-	const perWave: symbol[][] = [];
-	const completed = { value: false };
-	for (const e of events) {
-		const seg: symbol[] = [];
-		bucket = seg;
-		perWave.push(seg);
-		applyEvent(source, e, completed);
-	}
-	unsub();
-	return { initial, perWave };
-}
-
-// ---------------------------------------------------------------------------
-// Invariants
-// ---------------------------------------------------------------------------
-
-/**
- * #1 — No DATA without a preceding DIRTY in the same wave.
- *
- * Walks the post-activation trace; tracks `pending = (DIRTY count − settlement count)`.
- * If `pending` ever goes negative, a settlement (DATA/RESOLVED) reached the
- * sink without an outstanding DIRTY — protocol §1.3 invariant 1 violation.
- *
- * Topology: `state → derived(*2) → derived(+1)` (linear chain).
- * Caught by hand audit: Wave 1 `mergeMap` ERROR leak (settlement without DIRTY).
- */
-const invariant1: Invariant = {
-	name: "no-data-without-dirty",
-	description:
-		"In any post-activation wave, every DATA/RESOLVED settlement is preceded by an unbalanced DIRTY.",
-	specRef: "GRAPHREFLY-SPEC §1.3 invariant 1",
-	property: () =>
-		fc.property(eventSequenceArb(), (events) => {
-			const s = node([], { initial: 0 });
-			const m = node(
-				[s],
-				(batchData, actions, ctx) => {
-					const data = batchData.map((batch, i) =>
-						batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-					);
-					actions.emit((data[0] as number) * 2);
-				},
-				{ describeKind: "derived" },
-			);
-			const leaf = node(
-				[m],
-				(batchData, actions, ctx) => {
-					const data = batchData.map((batch, i) =>
-						batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-					);
-					actions.emit((data[0] as number) + 1);
-				},
-				{ describeKind: "derived" },
-			);
-			const trace = captureTrace(leaf, s, events);
-			let pending = 0;
-			for (let i = trace.activationEnd; i < trace.types.length; i++) {
-				const t = trace.types[i];
-				if (t === DIRTY) pending += 1;
-				else if (t === DATA || t === RESOLVED) {
-					pending -= 1;
-					if (pending < 0) return false;
-				}
-				// COMPLETE/ERROR/INVALIDATE don't affect the DIRTY/settlement balance.
-			}
-			return true;
-		}),
-};
-
-/**
- * #2 — RESOLVED settles exactly the wave that dirtied it; no leaks across waves.
- *
- * Stronger than #1: at the end of the run, `pending` must be exactly 0. A
- * positive pending means a DIRTY was sent without a follow-up settlement —
- * subscribers permanently believe the value might still change. A negative
- * pending means a settlement arrived without any DIRTY (caught first by #1).
- *
- * Topology: `state → derived` (single-dep, default Object.is equals).
- */
-const invariant2: Invariant = {
-	name: "resolved-per-wave",
-	description:
-		"After all events complete, every DIRTY observed at a downstream node has been balanced by exactly one DATA or RESOLVED.",
-	specRef: "GRAPHREFLY-SPEC §1.3 invariant 7 (batch drain)",
-	property: () =>
-		fc.property(eventSequenceArb(), (events) => {
-			const s = node([], { initial: 0 });
-			const leaf = node(
-				[s],
-				(batchData, actions, ctx) => {
-					const data = batchData.map((batch, i) =>
-						batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-					);
-					actions.emit(data[0] as number);
-				},
-				{ describeKind: "derived" },
-			);
-			const trace = captureTrace(leaf, s, events);
-			let pending = 0;
-			for (let i = trace.activationEnd; i < trace.types.length; i++) {
-				const t = trace.types[i];
-				if (t === DIRTY) pending += 1;
-				else if (t === DATA || t === RESOLVED) pending -= 1;
-			}
-			return pending === 0;
-		}),
-};
-
-/**
- * #3 — Terminal monotonicity: after COMPLETE/ERROR, no further DATA/DIRTY/RESOLVED.
- *
- * The invariant owns its terminal injection: prefix events, then a forced
- * COMPLETE, then suffix events. The forced COMPLETE is always present and
- * always at a known position with driven events after it, so the test
- * always exercises the post-terminal monotonicity path.
- *
- * Topology: `state` (source itself).
- */
-const invariant3: Invariant = {
-	name: "terminal-monotonicity",
-	description:
-		"Once COMPLETE or ERROR appears in the trace, no further DIRTY, DATA, or RESOLVED messages may follow.",
-	specRef: "GRAPHREFLY-SPEC §1.3 invariant 4 (terminal)",
-	property: () =>
-		fc.property(
-			eventSequenceArb({ maxLen: 4 }),
-			eventSequenceArb({ maxLen: 4 }),
-			(prefix, suffix) => {
-				const sequence: Event[] = [...prefix, { kind: "complete" }, ...suffix];
-				const s = node([], { initial: 0 });
-				const trace = captureTrace(s, s, sequence);
-				const terminalIdx = trace.types.findIndex((t) => t === COMPLETE || t === ERROR);
-				if (terminalIdx === -1) return false; // forced complete must reach the trace
-				for (let i = terminalIdx + 1; i < trace.types.length; i++) {
-					const t = trace.types[i];
-					if (t === DIRTY || t === DATA || t === RESOLVED) return false;
-				}
-				return true;
-			},
-		),
-};
-
-/**
- * #4 — Diamond resolution: fan-in converges to at most ONE settlement per
- * source-emit propagation (no glitch where B-path and C-path each fire D
- * independently).
- *
- * Topology: A → B; A → C; D = derived([B, C]). Each source emit on A is
- * one propagation cycle; D may fire at most once per cycle. A `batch` event
- * with K emits fans out to ONE coalesced downstream wave at D (per the
- * per-node emit coalescing fix, 2026-04-17) — so the bound inside a batch
- * is 1. Outside batch, the bound is the count of source-emit attempts in
- * the wave. What the invariant rules out is `D fires 2K times` (one per
- * dep edge).
- */
-const invariant4: Invariant = {
-	name: "diamond-resolution",
-	description:
-		"In a diamond topology (two paths fan in to a derived), settlements at the fan-in node are bounded by the count of source-emit attempts in the wave — never 2× per dep edge.",
-	specRef: "GRAPHREFLY-SPEC §1.3 invariant 3 (diamond)",
-	property: () =>
-		fc.property(eventSequenceArb(), (events) => {
-			const a = node([], { initial: 0 });
-			const b = node(
-				[a],
-				(batchData, actions, ctx) => {
-					const data = batchData.map((batch, i) =>
-						batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-					);
-					actions.emit(data[0] as number);
-				},
-				{ describeKind: "derived" },
-			);
-			const c = node(
-				[a],
-				(batchData, actions, ctx) => {
-					const data = batchData.map((batch, i) =>
-						batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-					);
-					actions.emit((data[0] as number) + 1);
-				},
-				{ describeKind: "derived" },
-			);
-			const d = node(
-				[b, c],
-				(batchData, actions, ctx) => {
-					const data = batchData.map((batch, i) =>
-						batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-					);
-					actions.emit((data[0] as number) + (data[1] as number));
-				},
-				{ describeKind: "derived" },
-			);
-			const { perWave } = captureTracePerWave(d, a, events);
-			for (let i = 0; i < perWave.length; i++) {
-				const seg = perWave[i];
-				const bound = waveAttemptCount(events[i]);
-				let settlements = 0;
-				for (const t of seg) if (t === DATA || t === RESOLVED) settlements += 1;
-				if (settlements > bound) return false;
-			}
-			return true;
-		}),
-};
-
-/**
- * #5 — Equals substitution: a suppressed DATA becomes RESOLVED, never silence.
- *
- * Drives the source. Every emit must produce exactly one settlement (DATA when
- * the value changed, RESOLVED when equals matched). The total settlement count
- * must equal the total emit-attempt count — silent drops would make this fail.
- *
- * Topology: `state` (source itself), default Object.is equals, small value
- * alphabet so equal-value emits are common.
- */
-const invariant5: Invariant = {
-	name: "equals-substitution",
-	description:
-		"Every source emit produces exactly one settlement (DATA or RESOLVED) — equality never causes silent drop.",
-	specRef: "GRAPHREFLY-SPEC §1.3 invariant 2 (equals)",
-	property: () =>
-		fc.property(eventSequenceArb(), (events) => {
-			const s = node([], { initial: 0 });
-			const trace = captureTrace(s, s, events);
-			let settlements = 0;
-			for (let i = trace.activationEnd; i < trace.types.length; i++) {
-				const t = trace.types[i];
-				if (t === DATA || t === RESOLVED) settlements += 1;
-			}
-			const expected = events.reduce((n, e) => n + waveAttemptCount(e), 0);
-			return settlements === expected;
-		}),
-};
-
-/**
- * #6 — Version counter per-emit correctness: `advanceVersion` fires exactly
- * once per observable cache change, and never on RESOLVED.
- *
- * After each event, asserts `v.version` advanced by exactly the expected
- * delta (number of value-changing emits in the event). A substrate bug that
- * double-increments on one emit and skips another would be caught here but
- * miss a final-value-only test.
- *
- * Topology: `node([], { versioning: 0 , initial: 0 })`.
- */
-const invariant6: Invariant = {
-	name: "version-counter-per-emit",
-	description:
-		"`v.version` advances by exactly the number of value-changing emits in each event; unchanged on RESOLVED.",
-	specRef: "GRAPHREFLY-SPEC §7 (versioning)",
-	property: () =>
-		fc.property(eventSequenceArb(), (events) => {
-			const initial = 0;
-			const s = node([], { versioning: 0, initial: initial });
-			const unsub = s.subscribe(() => {});
-			const completed = { value: false };
-			let cache = initial;
-			try {
-				for (const event of events) {
-					let expectedDelta = 0;
-					let simCache = cache;
-					if (event.kind === "emit") {
-						if (!Object.is(event.value, simCache)) {
-							expectedDelta += 1;
-							simCache = event.value;
-						}
-					} else if (event.kind === "batch") {
-						for (const v of event.values) {
-							if (!Object.is(v, simCache)) {
-								expectedDelta += 1;
-								simCache = v;
-							}
-						}
-					}
-					const before = s.v?.version ?? 0;
-					applyEvent(s, event, completed);
-					const after = s.v?.version ?? 0;
-					if (after - before !== expectedDelta) return false;
-					cache = simCache;
-				}
-			} finally {
-				unsub();
-			}
-			return true;
-		}),
-};
-
-/**
- * #7 — START handshake. Per GRAPHREFLY-SPEC §2.2 the very first delivery
- * to a new subscriber starts with exactly `[[START]]` on its own.
- *
- * The remainder of the handshake depends on topology:
- * - **Source with cached value** (`node([], { initial: v })`): `[[START]]` → `[[DATA, v]]`.
- *   The cached value is pushed directly; no DIRTY precedes it.
- * - **Derived (compute node)**: `[[START]]` → `[[DIRTY]]` → `[[DATA, fn(deps)]]`.
- *   The compute node emits DIRTY first (it doesn't have a cached value at
- *   subscribe time until deps have pushed), then computes and delivers DATA.
- * - **Sentinel** (`node<T>([])`, no initial): just `[[START]]`. No further
- *   push until something sets the cache.
- *
- * Tier-group delivery (§1.3.7) means each entry is its own `sink()` call —
- * START (tier 0) and DATA (tier 3) are always separate batches, and DIRTY
- * (tier 1) sits between them in the derived case.
- *
- * Probed (2026-04-17): `node([], { initial: 42 })` → 2 batches; `node([s], (batchData, actions, ctx) => {
- 	const data = batchData.map((batch, i) => batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i]);
- 	actions.emit(data * 2);
- }, { describeKind: "derived" })` →
- * 3 batches with DIRTY in the middle; `node<T>([])` → 1 batch.
- */
-const invariant7: Invariant = {
-	name: "start-handshake",
-	description:
-		"First batch is exactly [[START]]. For a cached source the next batch is [[DATA, v]]; for a derived node the sequence is [[START]], [[DIRTY]], [[DATA, fn(deps)]]; for a sentinel only [[START]] is delivered.",
-	specRef: "GRAPHREFLY-SPEC §2.2 (push-on-subscribe)",
-	property: () =>
-		fc.property(
-			fc.integer({ min: 0, max: 10 }),
-			fc.constantFrom<"source" | "derived" | "derived-multi" | "sentinel">(
-				"source",
-				"derived",
-				"derived-multi",
-				"sentinel",
-			),
-			(cachedValue, kind) => {
-				let target: Node<number>;
-				let expectedFinal: number;
-				if (kind === "source") {
-					target = node([], { initial: cachedValue });
-					expectedFinal = cachedValue;
-				} else if (kind === "derived") {
-					const src = node([], { initial: cachedValue });
-					target = node(
-						[src],
-						(batchData, actions, ctx) => {
-							const data = batchData.map((batch, i) =>
-								batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-							);
-							actions.emit((data[0] as number) * 2);
-						},
-						{ describeKind: "derived" },
-					);
-					expectedFinal = cachedValue * 2;
-				} else if (kind === "derived-multi") {
-					// Multi-dep derived: both deps cached at subscribe time.
-					// Per the known "withLatestFrom multi-dep push-on-subscribe"
-					// gap (docs/optimizations.md), two-dep activation may emit
-					// a RESOLVED from the first-dep first-run gate before the
-					// combined DATA. This invariant accepts either of the two
-					// valid handshakes: [[START], [DIRTY], [DATA, ...]] (clean)
-					// or [[START], [DIRTY], [RESOLVED], [DIRTY], [DATA, ...]]
-					// (sequential dep arrival). Any other shape is a violation.
-					const s1 = node([], { initial: cachedValue });
-					const s2 = node([], { initial: cachedValue + 1 });
-					target = node(
-						[s1, s2],
-						(batchData, actions, ctx) => {
-							const data = batchData.map((batch, i) =>
-								batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-							);
-							actions.emit((data[0] as number) + (data[1] as number));
-						},
-						{ describeKind: "derived" },
-					);
-					expectedFinal = cachedValue + (cachedValue + 1);
-				} else {
-					target = node<number>([]);
-					expectedFinal = Number.NaN;
-				}
-				const batches: [symbol, unknown?][][] = [];
-				const unsub = target.subscribe((msgs) => {
-					batches.push([...(msgs as readonly [symbol, unknown?][])]);
-				});
-				unsub();
-				// Every kind: first batch is exactly [[START]].
-				if (batches.length === 0) return false;
-				if (batches[0].length !== 1 || batches[0][0][0] !== START) return false;
-				if (kind === "sentinel") return batches.length === 1;
-				if (kind === "source") {
-					// Source: [[START]], [[DATA, cached]].
-					if (batches.length !== 2) return false;
-					const d = batches[1];
-					return d.length === 1 && d[0][0] === DATA && Object.is(d[0][1], cachedValue);
-				}
-				if (kind === "derived") {
-					// Single-dep derived: [[START]], [[DIRTY]], [[DATA, fn(deps)]].
-					if (batches.length !== 3) return false;
-					if (batches[1].length !== 1 || batches[1][0][0] !== DIRTY) return false;
-					const d2 = batches[2];
-					return d2.length === 1 && d2[0][0] === DATA && Object.is(d2[0][1], expectedFinal);
-				}
-				// kind === "derived-multi": tightened 2026-04-23 alongside the
-				// first-run gate landing (docs/optimizations.md: Multi-dep
-				// push-on-subscribe ordering — RESOLVED). Substrate now
-				// guarantees the clean handshake; the previous gap-aware form
-				// `[[START], [DIRTY], [RESOLVED], [DIRTY], [DATA]]` was the
-				// pre-fix substrate shape and is no longer reachable for sugar
-				// `derived` / `effect` with `partial: false` default. #10
-				// `multi-dep-initial-pair-clean` is the dedicated guard for
-				// this exact shape; #7 now asserts the same clean 3-batch form
-				// as the single-dep case, so a regression fails BOTH here and
-				// #10 (not only #10).
-				if (batches.length !== 3) return false;
-				if (batches[1].length !== 1 || batches[1][0][0] !== DIRTY) return false;
-				const lastMulti = batches[2];
-				if (lastMulti.length !== 1 || lastMulti[0][0] !== DATA) return false;
-				return Object.is(lastMulti[0][1], expectedFinal);
-			},
-		),
-};
-
-/**
- * #8 — Throw recovery / state consistency. When a subscriber's callback
- * throws, the node's internal cache/version state remains consistent and
- * matches what it would be in the throw-free world. Subscribers registered
- * **before** the thrower may see partial delivery for a wave where the
- * throw interrupts, but subsequent emits still update state correctly.
- *
- * The plan's original "batch drain atomicity" is weaker than it sounds at
- * runtime: emit() is synchronous and a throwing subscriber does propagate
- * out, potentially leaving later subscribers starved for that wave. This
- * invariant captures what **does** hold: state consistency post-throw.
- *
- * Topology: `node([], { initial: 0 })` with a throwing subscriber, observed from outside.
- */
-const invariant8: Invariant = {
-	name: "throw-recovery-consistency",
-	description:
-		"A throwing subscriber callback does not corrupt the node's cache or version: after removing the thrower, a fresh emit updates cache and version exactly as if no throw had happened.",
-	specRef: "GRAPHREFLY-SPEC §1.3 invariant 7 (batch drain)",
-	property: () =>
-		fc.property(eventSequenceArb({ maxLen: 6 }), (events) => {
-			const s = node([], { initial: 0 });
-			// Throw only on DIRTY — which never appears during subscribe()'s
-			// handshake (START + cached-DATA push), so we safely get past
-			// registration. Every real emit produces DIRTY, triggering the throw.
-			const uBad = s.subscribe((msgs) => {
-				for (const [t] of msgs as readonly [symbol, unknown?][]) {
-					if (t === DIRTY) throw new Error("intentional");
-				}
-			});
-			const completed = { value: false };
-			for (const event of events) {
-				try {
-					applyEvent(s, event, completed);
-				} catch {
-					// Swallow the rethrown subscriber error; we're checking state, not delivery.
-				}
-			}
-			uBad();
-			// After removing the thrower, emit one value and check cache advances.
-			// Choose a value distinct from current cache to force a real DATA.
-			const before = s.cache;
-			const fresh = before === 999 ? 1000 : 999;
-			s.emit(fresh);
-			return s.cache === fresh;
-		}),
-};
-
-/**
- * #9 — Subscribe/unsubscribe reentry. Unsubscribing from inside a subscribe
- * callback is safe: the act of calling the unsub function during its own
- * callback does not throw, does not leak, and does not disrupt other
- * subscribers' delivery. Subsequent emits still reach non-unsubbed
- * observers with the correct message sequence.
- *
- * Topology: `node([], { initial: 0 })` with a self-unsubbing subscriber and an independent
- * observer. Property: observer's message balance still satisfies
- * NoDataWithoutDirty + BalancedWaves after the self-unsub has fired.
- */
-const invariant9: Invariant = {
-	name: "subscribe-unsubscribe-reentry",
-	description:
-		"A subscriber calling its own unsub from inside its callback does not throw and does not disrupt delivery to other subscribers.",
-	specRef: "GRAPHREFLY-SPEC §2.2 (subscribe lifecycle)",
-	property: () =>
-		fc.property(
-			eventSequenceArb({ maxLen: 6 }),
-			fc.nat({ max: 3 }), // unsub after the Nth DATA received
-			(events, unsubAfterN) => {
-				const s = node([], { initial: 0 });
-				let dataCount = 0;
-				let unsubSelf: (() => void) | null = null;
-				let reentryError: unknown = null;
-				unsubSelf = s.subscribe((msgs) => {
-					for (const [t] of msgs as readonly [symbol, unknown?][]) {
-						if (t === DATA) dataCount += 1;
-					}
-					if (dataCount >= unsubAfterN && unsubSelf) {
-						try {
-							const u = unsubSelf;
-							unsubSelf = null;
-							u();
-						} catch (err) {
-							reentryError = err;
-						}
-					}
-				});
-				// Independent observer — must stay uncorrupted.
-				const observerTypes: symbol[] = [];
-				let observerActivationEnd = 0;
-				const uObs = s.subscribe((msgs) => {
-					for (const msg of msgs as readonly [symbol, unknown?][]) {
-						if (msg[0] === START) continue;
-						observerTypes.push(msg[0]);
-					}
-				});
-				observerActivationEnd = observerTypes.length;
-				const completed = { value: false };
-				for (const e of events) applyEvent(s, e, completed);
-				uObs();
-				if (unsubSelf) unsubSelf();
-				if (reentryError !== null) return false;
-				// Balance check on observer's post-activation trace.
-				let pending = 0;
-				for (let i = observerActivationEnd; i < observerTypes.length; i++) {
-					const t = observerTypes[i];
-					if (t === DIRTY) pending += 1;
-					else if (t === DATA || t === RESOLVED) pending -= 1;
-					if (pending < 0) return false;
-				}
-				return pending === 0;
-			},
-		),
-};
-
-/**
- * #10 — Multi-dep push-on-subscribe initial pair (OPEN, ahead of substrate fix).
- *
- * When a compute node has two already-cached `node([])` deps and is subscribed,
- * the handshake should deliver ONE combined initial DATA: `[[START],
- * [DIRTY], [DATA, fn(initA, initB)]]`. Today `_activate` at
- * src/core/node.ts:1002 subscribes deps sequentially — each push-on-subscribe
- * is its own wave — so the actual handshake is
- * `[[START], [DIRTY], [RESOLVED], [DIRTY], [DATA, fn(initA, initB)]]` (fast-
- * check invariant #7 accepts both shapes for that reason).
- *
- * This is the stricter form: the handshake's tier-3 traffic must be EXACTLY
- * `[DATA, fn(initA, initB)]` — no precursor RESOLVED. Driving this green
- * unblocks docs/optimizations.md "Multi-dep push-on-subscribe ordering".
- *
- * Topology: `node([node([], { initial: x }), node([], { initial: y })], (batchData, actions, ctx) => {
- 	const data = batchData.map((batch, i) => batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i]);
- 	actions.emit(data[0] + data[1]);
- }, { describeKind: "derived" })`.
- */
-const invariant10MultiDepInitial: Invariant = {
-	name: "multi-dep-initial-pair-clean",
-	description:
-		"A two-dep derived with two already-cached state deps delivers exactly [[START], [DIRTY], [DATA, fn(initA, initB)]] on first subscribe — no precursor RESOLVED from sequential dep activation.",
-	specRef: "GRAPHREFLY-SPEC §2.7 (multi-dep push-on-subscribe)",
-	property: () =>
-		fc.property(fc.integer({ min: 0, max: 9 }), fc.integer({ min: 0, max: 9 }), (x, y) => {
-			const a = node([], { initial: x });
-			const b = node([], { initial: y });
-			const d = node(
-				[a, b],
-				(batchData, actions, ctx) => {
-					const data = batchData.map((batch, i) =>
-						batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-					);
-					actions.emit((data[0] as number) + (data[1] as number));
-				},
-				{ describeKind: "derived" },
-			);
-			const batches: [symbol, unknown?][][] = [];
-			const unsub = d.subscribe((msgs) => {
-				batches.push([...(msgs as readonly [symbol, unknown?][])]);
-			});
-			unsub();
-			// Strict shape: exactly 3 sink calls — [START], [DIRTY], [DATA, sum].
-			if (batches.length !== 3) return false;
-			if (batches[0].length !== 1 || batches[0][0][0] !== START) return false;
-			if (batches[1].length !== 1 || batches[1][0][0] !== DIRTY) return false;
-			if (batches[2].length !== 1) return false;
-			const dataMsg = batches[2][0];
-			return dataMsg[0] === DATA && Object.is(dataMsg[1], x + y);
-		}),
-};
-
-/**
- * #11 — Pause multi-pauser correctness. Multiple controllers can hold
- * independent pause locks on the same node; the node stays paused as long as
- * any lock is held, and `fn` fires exactly once — coalescing the pending wave
- * — on final-lock release. Spec §2.6: "This gives multi-pauser correctness
- * by construction: if controller A and controller B both hold pause locks,
- * releasing A's lock does not resume the node while B still holds its lock."
- *
- * Topology: `state → derived(tracks fn runs)`. Property:
- *   (a) while N locks pause upstream, intermediate releases (k < N-1 out of
- *       N-1 are released) do not cause `fn` to run;
- *   (b) the final lock release runs `fn` exactly once with the latest value.
- *
- * TLA+ mirror: `wave_protocol_pause_MC` — TLC enumerates every interleaving
- * of Pause/Resume across two lockIds and verifies the protocol invariants
- * (TerminalClearsPauseState, BufferImpliesLockedAndResumeAll, etc.) hold.
- */
-const invariant11PauseMultiPauser: Invariant = {
-	name: "pause-multi-pauser",
-	description:
-		"Multiple pause locks are tracked independently: releasing one lockId while another is held does not resume; fn fires exactly once with the latest dep values after the final lock releases.",
-	specRef: "GRAPHREFLY-SPEC §2.6 (PAUSE/RESUME lock-id)",
-	property: () =>
-		fc.property(fc.integer({ min: 1, max: 3 }), (numLocks) => {
-			const s = node([], { initial: 0 });
-			let fnRuns = 0;
-			const d = node(
-				[s],
-				(batchData, actions, ctx) => {
-					const data = batchData.map((batch, i) =>
-						batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-					);
-					fnRuns += 1;
-					actions.emit(data[0] as number);
-				},
-				{ describeKind: "derived" },
-			);
-			const unsub = d.subscribe(() => {});
-			const runsAfterSubscribe = fnRuns;
-
-			const locks = Array.from({ length: numLocks }, (_, i) => Symbol(`lock-${i}`));
-			for (const l of locks) s.down([[PAUSE, l]]);
-			s.emit(1); // cache 0 → 1; would trigger d.fn if not paused
-
-			// Release all but the last lock. While any lock held, fn must not fire.
-			for (let i = 0; i < numLocks - 1; i++) {
-				s.down([[RESUME, locks[i]]]);
-			}
-			const runsBeforeFinalRelease = fnRuns;
-
-			s.down([[RESUME, locks[numLocks - 1]]]);
-			const runsAfterRelease = fnRuns;
-
-			unsub();
-
-			// (a) N-1 partial releases — fn must not have re-run.
-			if (runsBeforeFinalRelease !== runsAfterSubscribe) return false;
-			// (b) Final release — fn fires exactly once for the coalesced wave.
-			if (runsAfterRelease !== runsAfterSubscribe + 1) return false;
-			return true;
-		}),
-};
-
-/**
- * #12 — Nested-drain peer-read consistency (simple topology).
- *
- * A derived `T = derived([A, B])` must never observe a snapshot where one
- * peer's value reflects a wave not yet delivered to `T`. Specifically, if an
- * effect on `B` enters `batch(() => A.emit(newA))` inside its sink callback,
- * the nested drain can force `T`'s dep-0 callback to fire with `newA`
- * BEFORE `B`'s outer sink-delivery loop reaches `T`'s dep-1 — leaving `T`'s
- * B DepRecord holding the PRIOR wave's B value. Any intermediate DATA `T`
- * emits must satisfy: if `a == newA`, then `b == triggerB` (the B value
- * whose sink triggered the nested A.emit). A sighting of `[newA, oldB]`
- * is a peer-read glitch.
- *
- * **Current status (probed 2026-04-23): PASSES on the current substrate.**
- * The `_dirtyDepCount` gate (node.ts `_maybeRunFnOnSettlement`) correctly
- * blocks T's fn from firing during the nested drain while dep-1 is still
- * pending. The documented COMPOSITION-GUIDE §32 / agentLoop bug lives in
- * **compound topologies** (switchMap resubscribe, feedback diamonds) that
- * this simple-topology harness does not model.
- *
- * This invariant ships anyway as a **regression guard**: any future change
- * to `_emit`, `_activate`, or `_maybeRunFnOnSettlement` that breaks the
- * simple-topology case will fail here immediately. Fully unblocking
- * docs/optimizations.md "Nested-drain wave-ordering" requires an
- * additional compound-topology invariant (switchMap-shaped dep re-wire) —
- * tracked separately.
- *
- * Topology: `A = node([], { initial: 0 })`, `B = node([], { initial: 0 })`, `T = derived([A, B])`, effect
- * on `B` that emits to `A` inside `batch()` when `B` hits `triggerValue`.
- * Subscribe effect before T (puts effect earlier in B's sink snapshot).
- */
-const invariant12NestedDrain: Invariant = {
-	name: "nested-drain-peer-consistency",
-	description:
-		"A derived([A, B]) must never observe a peer value from a wave not yet delivered to it. When a sibling sink of B enters batch(() => A.emit(newA)) inside its callback on the B=triggerB wave, every DATA T emits during that outer wave must reflect [newA, triggerB] or [initialA, triggerB] — never [newA, oldB].",
-	specRef: "GRAPHREFLY-SPEC §1.3 invariant 2 + COMPOSITION-GUIDE §32",
-	property: () =>
-		fc.property(
-			fc.integer({ min: 1, max: 9 }), // triggerB — B value that gates the nested drain (!= initial 0)
-			fc.integer({ min: 100, max: 199 }), // newA — A value emitted from inside the nested batch
-			(triggerB, newA) => {
-				const a = node([], { initial: 0 });
-				const b = node([], { initial: 0 });
-				const tEmits: (readonly [number, number])[] = [];
-				const t = node(
-					[a, b],
-					(batchData, actions, ctx) => {
-						const data = batchData.map((batch, i) =>
-							batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-						);
-						actions.emit([data[0] as number, data[1] as number] as const);
-					},
-					{ describeKind: "derived" },
-				);
-				// Sibling sink of B — enters nested batch when B hits triggerB.
-				const sibling = node(
-					[b],
-					(batchData, actions, ctx) => {
-						const data = batchData.map((batch, i) =>
-							batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-						);
-						return (
-							(([bv]) => {
-								if (bv === triggerB) {
-									batch(() => a.emit(newA));
-								}
-							})(data, actions, ctx) ?? undefined
-						);
-					},
-					{ describeKind: "effect" },
-				);
-				// Order matters: sibling subscribes first, so it precedes T in B's
-				// sinks snapshot — the pathological ordering the bug needs.
-				const uSibling = sibling.subscribe(() => {});
-				const uT = t.subscribe((msgs) => {
-					for (const m of msgs as readonly [symbol, unknown?][]) {
-						if (m[0] === DATA) tEmits.push(m[1] as readonly [number, number]);
-					}
-				});
-				// Single external drive: B.emit(triggerB). Everything else is
-				// downstream drain traffic from that one wave (including the
-				// nested batch the sibling triggers).
-				b.emit(triggerB);
-				uT();
-				uSibling();
-				// Any DATA with a=newA must carry b=triggerB. A sighting of
-				// [newA, 0] (initial B) is the peer-read glitch: it means T's
-				// fn fired during the nested drain while its B DepRecord still
-				// held pre-trigger value. Likewise `[0, triggerB]` (initial A)
-				// is fine (outer B wave settling before the nested A arrives).
-				for (const [av, bv] of tEmits) {
-					if (av === newA && bv !== triggerB) return false;
-				}
-				// Final cache must also be consistent with both latest values.
-				if (t.cache !== undefined) {
-					const [av, bv] = t.cache as readonly [number, number];
-					if (av !== newA || bv !== triggerB) return false;
-				}
-				return true;
-			},
-		),
-};
-
-/**
- * #12b — Nested-drain peer-read consistency under COMPOUND topology
- * (switchMap upstream).
- *
- * Mirrors invariant #12 but with the agentLoop §32 shape: the upstream
- * dep is a `switchMap` output (not a plain `state`). switchMap re-subscribes
- * its inner per outer DATA; the inner pushes its cached value via
- * `forwardInner` → `a.emit(...)` on the switchMap output. This is the
- * "compound topology" shape the optimizations.md note flagged as the case
- * the simple-topology #12 invariant doesn't model.
- *
- * **Verifies the same _dirtyDepCount gating works under switchMap.** When
- * the switchMap output emits via `a.emit`, `_emit` synthesizes a DIRTY
- * before the DATA. Both sinks (sibling effect + terminal derived) get
- * marked DIRTY in Phase 1. In Phase 2, sibling fires first; its nested
- * batch emits to `status` which then drains and tries to fire terminal's
- * fn — but terminal's switchMap-output dep is still DIRTY (Phase 2 for
- * loop hasn't reached it), so `_dirtyDepCount > 0` blocks the fn run.
- * Terminal fires only after Phase 2 visits its switchMap-output dep.
- *
- * Topology: `trigger = node([], { initial: 0 })`, `inner_n = node([], { initial: ... })` per trigger value,
- * `compound = switchMap(trigger, n => inner_n)`, `status = node([], { initial: "thinking" })`,
- * `sibling = node([compound], (batchData, actions, ctx) => {
- 	const data = batchData.map((batch, i) => batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i]);
- 	return ((…)(data, actions, ctx) ?? undefined);
- }, { describeKind: "effect" })` that nests `batch(() => status.emit("done"))`,
- * `terminal = node([compound, status], (batchData, actions, ctx) => {
- 	const data = batchData.map((batch, i) => batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i]);
- 	actions.emit((…)(data, ctx));
- }, { describeKind: "derived" })`.
- */
-const invariant12bNestedDrainCompound: Invariant = {
-	name: "nested-drain-peer-consistency-compound",
-	description:
-		"Compound-topology mirror of #12. derived([switchMap(...), status]) must never observe [oldCompound, newStatus] when a sibling sink of switchMap output enters batch(() => status.emit(newStatus)) inside its callback. Verifies _dirtyDepCount gating holds when the upstream is a switchMap output rather than a plain state.",
-	specRef: "GRAPHREFLY-SPEC §1.3 invariant 2 + COMPOSITION-GUIDE §32",
-	property: () =>
-		fc.property(
-			fc.integer({ min: 100, max: 199 }), // newInner — value the new switchMap inner emits
-			(newInner) => {
-				const trigger = node([], { initial: 0 });
-				const inner0 = node([], { initial: 0 });
-				const inner1 = node([], { initial: newInner });
-				// switchMap with equals: () => false — matches agentLoop's shape.
-				const compound = switchMap<number, number>(trigger, (n) => (n === 0 ? inner0 : inner1));
-				const status = node<"thinking" | "done">([], { initial: "thinking" });
-
-				// Sibling sink of compound: when a non-zero value arrives,
-				// transition status to "done" inside a nested batch.
-				const sibling = node(
-					[compound],
-					(batchData, _actions, ctx) => {
-						const data = batchData.map((batch, i) =>
-							batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-						);
-						if ((data[0] as number) !== 0) {
-							batch(() => status.emit("done"));
-						}
-					},
-					{ describeKind: "effect" },
-				);
-
-				const terminal = node(
-					[compound, status],
-					(batchData, actions, ctx) => {
-						const data = batchData.map((batch, i) =>
-							batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-						);
-						actions.emit([data[0] as number, data[1] as string] as const);
-					},
-					{ describeKind: "derived" },
-				);
-
-				const seen: (readonly [number, string])[] = [];
-				const uSibling = sibling.subscribe(() => {});
-				const uTerminal = terminal.subscribe((msgs) => {
-					for (const m of msgs) {
-						if (m[0] === DATA) seen.push(m[1] as readonly [number, string]);
-					}
-				});
-
-				// Drive: trigger=1 → switchMap dispatches new inner → compound
-				// emits newInner. Sibling fires first (subscribe order); nested
-				// batch transitions status to "done"; terminal must NOT observe
-				// [0, "done"] (stale compound + new status).
-				trigger.emit(1);
-
-				const finalCache = terminal.cache as readonly [number, string] | undefined;
-				uTerminal();
-				uSibling();
-
-				// The bug shape: terminal observes [oldCompound, "done"] —
-				// compound dep prevData stale during nested-drain status update.
-				// Acceptable: any tuple where compound=newInner OR status=="thinking"
-				// (status update gated by _dirtyDepCount until compound dep settles).
-				for (const [cv, st] of seen) {
-					if (st === "done" && cv !== newInner) return false;
-				}
-				// Final cache must reflect both latest values.
-				if (finalCache === undefined) return false;
-				if (finalCache[0] !== newInner || finalCache[1] !== "done") return false;
-				return true;
-			},
-		),
-};
-
-/**
- * #13 — bufferAll replay ordering. In `pausable: "resumeAll"` mode, outgoing
- * tier-3 settlements emitted during a pause window are captured into the
- * node's bufferAll buffer; on final-lock RESUME the buffer drains to
- * subscribers BEFORE the forwarded RESUME message. Spec §2.6 bufferAll:
- * "On final-lock RESUME, the buffered messages are replayed through the
- * node's own `_emit` pipeline BEFORE the RESUME signal is forwarded
- * downstream."
- *
- * Property:
- *   (a) during pause, no tier-3 (DATA/RESOLVED) reaches the subscriber;
- *   (b) on RESUME, the subscriber observes all buffered tier-3 messages
- *       (in order — at least one, since per spec a buffered DATA may
- *       collapse to RESOLVED against current cache) followed by the
- *       RESUME tuple itself — no tier-3 appears after RESUME.
- *
- * TLA+ mirror: `wave_protocol_bufferall_MC` — TLC verifies the per-node
- * structural invariants (BufferImpliesLockedAndResumeAll,
- * BufferHoldsOnlyDeferredTiers) which together with the atomic drain-then-
- * forward in DeliverPauseResume enforce this ordering by construction.
- */
-const invariant13BufferAllReplay: Invariant = {
-	name: "buffer-all-replay-ordering",
-	description:
-		"In pausable:'resumeAll' mode, tier-3 settlements emitted during a pause window are buffered and replayed to subscribers BEFORE the forwarded RESUME; no tier-3 message appears after the RESUME that closed the pause window.",
-	specRef: "GRAPHREFLY-SPEC §2.6 (bufferAll mode)",
-	property: () =>
-		fc.property(
-			fc.array(fc.integer({ min: 0, max: 4 }), { minLength: 1, maxLength: 5 }),
-			(values) => {
-				const s = node<number>((_actions) => {}, {
-					pausable: "resumeAll",
-					initial: 0,
-					describeKind: "state",
-				});
-				const trace: symbol[] = [];
-				const unsub = s.subscribe((msgs) => {
-					for (const m of msgs as readonly [symbol, unknown?][]) {
-						trace.push(m[0]);
-					}
-				});
-				const lock = Symbol("bufferAll");
-				s.down([[PAUSE, lock]]);
-				const idxPauseRecorded = trace.length;
-
-				for (const v of values) s.emit(v);
-
-				// (a) During pause: tier-3 must NOT appear in trace after the
-				// PAUSE was recorded. Substrate synthesizes DIRTY (tier-1, immediate)
-				// for each emit, but DATA/RESOLVED is buffered.
-				for (let i = idxPauseRecorded; i < trace.length; i++) {
-					if (trace[i] === DATA || trace[i] === RESOLVED) return false;
-				}
-
-				const idxBeforeResume = trace.length;
-				s.down([[RESUME, lock]]);
-				unsub();
-
-				// (b) Post-RESUME segment: must contain the RESUME tuple; every
-				// DATA/RESOLVED in the post-resume segment must appear before the
-				// RESUME (atomic drain-then-forward), never after.
-				let resumeIdx = -1;
-				for (let i = idxBeforeResume; i < trace.length; i++) {
-					if (trace[i] === RESUME) {
-						resumeIdx = i;
-						break;
-					}
-				}
-				if (resumeIdx === -1) return false; // RESUME must reach subscriber
-				for (let i = resumeIdx + 1; i < trace.length; i++) {
-					if (trace[i] === DATA || trace[i] === RESOLVED) return false;
-				}
-				return true;
-			},
-		),
-};
-
-/**
- * #14 — Resubscribe clears pause state (no lock leakage across lifecycles).
- * Spec §2.6 "Teardown": "On TEARDOWN or deactivation, the buffer and lock
- * set are discarded... Resubscribable nodes also clear the lock set on
- * resubscribe so a new lifecycle cannot inherit a lock from a prior one."
- *
- * Without this clearing, a lock held by a disposed controller in lifecycle
- * L1 would survive into L2 and leave the re-subscribed node permanently
- * stuck paused — every subsequent emit would be dropped/buffered with no
- * way to release.
- *
- * Property: after pausing with N locks in L1, emitting (which buffers),
- * terminating without releasing any lock, and re-subscribing to start L2,
- * a fresh emit in L2 produces an observable DATA/RESOLVED at the new
- * subscriber. If pause state leaked, the emit would be buffered with no
- * active RESUME path to drain it.
- *
- * TLA+ mirror: `wave_protocol_resubscribe_MC` — TLC verifies
- * `ResubscribeYieldsCleanState` (pauseLocks/pauseBuffer/dirtyMask/handshake/
- * trace all empty immediately after `Resubscribe` action) and
- * `TerminalClearsPauseState` (non-resubscribable terminal nodes also clear
- * pause state).
- */
-const invariant14ResubscribePause: Invariant = {
-	name: "resubscribe-clears-pause-state",
-	description:
-		"On a resubscribable node, pause locks and bufferAll buffer from a terminated lifecycle do not leak into a resubscribe: a fresh emit in the new lifecycle reaches the new subscriber.",
-	specRef: "GRAPHREFLY-SPEC §2.6 (Teardown / Resubscribable)",
-	property: () =>
-		fc.property(fc.integer({ min: 1, max: 3 }), (numLocks) => {
-			const s = node([], {
-				pausable: "resumeAll",
-				resubscribable: true,
-				initial: 0,
-			});
-
-			// Lifecycle 1: subscribe, pause with N locks, emit (buffered),
-			// terminate without releasing a single lock. This is the
-			// "controller disposed without cleanup" failure mode.
-			const u1 = s.subscribe(() => {});
-			const locks = Array.from({ length: numLocks }, (_, i) => Symbol(`L1-${i}`));
-			for (const l of locks) s.down([[PAUSE, l]]);
-			s.emit(99); // buffered, never drained
-			s.down([[COMPLETE]]);
-			u1();
-
-			// Lifecycle 2: fresh subscribe triggers terminal reset. Any lock
-			// that leaked would keep the new lifecycle stuck paused.
-			let sawTier3 = false;
-			const u2 = s.subscribe((msgs) => {
-				for (const m of msgs as readonly [symbol, unknown?][]) {
-					if (m[0] === DATA || m[0] === RESOLVED) sawTier3 = true;
-				}
-			});
-			s.emit(42);
-			u2();
-
-			// If pause state cleared correctly: emit(42) produces DIRTY + DATA
-			// through the pipeline, subscriber sees DATA. If it leaked: the
-			// DATA goes into the stale bufferAll buffer and never reaches the
-			// subscriber.
-			return sawTier3;
-		}),
-};
-/**
- * #15 — Multi-sink trace convergence (§2.4). Two subscribers on the same
- * node observe the same sequence of post-activation messages.
- *
- * Mirrors TLA+ `MultiSinkTracesConverge`. `_deliverToSinks` at
- * src/core/node.ts:2248 iterates a snapshot of the sinks Set, so each
- * subscriber receives every wave's settlement in order. A regression that
- * dropped deliveries from a later-subscribed sink (or reordered the
- * snapshot) would fail this property.
- *
- * Topology: `node([], { initial: 0 })` with two observers; after activation (handshake
- * filtered), the post-activation DATA/RESOLVED/DIRTY sequence at observer A
- * must equal observer B's. COMPOSITION-GUIDE §32-class peer-read bugs at
- * the multi-dep diamond level require a separate topology and are tracked
- * in docs/optimizations.md as a follow-up.
- */
-const invariant15MultiSinkConverge: Invariant = {
-	name: "multi-sink-trace-convergence",
-	description:
-		"Two sinks subscribed to the same source node observe the same post-activation sequence of DIRTY/DATA/RESOLVED messages.",
-	specRef: "GRAPHREFLY-SPEC §2.4 (node fn contract) + §2.2 (subscribe)",
-	property: () =>
-		fc.property(eventSequenceArb({ maxLen: 6 }), (events) => {
-			// Topology-fragility note: `activationEndA` / `activationEndB` are
-			// captured as `seq.length` at the instant `subscribe()` returns.
-			// This is correct for a plain `node([], { initial: 0 })` where neither sink's
-			// subscribe induces side-effect traffic at the other sink. If
-			// this invariant ever grows to cover diamond/shared-ancestor
-			// topologies, the second subscribe could synthesize activation
-			// messages at the first sink via a mutual upstream mount, and
-			// length-at-time would understate A's activation by those
-			// messages. Anchor on "count of START messages observed" if that
-			// regime is exercised.
-			const s = node([], { initial: 0 });
-			const seqA: symbol[] = [];
-			const seqB: symbol[] = [];
-			const pushOnce = (bucket: symbol[]) => (msgs: readonly [symbol, unknown?][]) => {
-				for (const msg of msgs) {
-					if (msg[0] === START) continue;
-					bucket.push(msg[0]);
-				}
-			};
-			const uA = s.subscribe(pushOnce(seqA));
-			const activationEndA = seqA.length;
-			const uB = s.subscribe(pushOnce(seqB));
-			const activationEndB = seqB.length;
-			const completed = { value: false };
-			for (const e of events) applyEvent(s, e, completed);
-			uA();
-			uB();
-			const postA = seqA.slice(activationEndA);
-			const postB = seqB.slice(activationEndB);
-			if (postA.length !== postB.length) return false;
-			for (let i = 0; i < postA.length; i++) {
-				if (postA[i] !== postB[i]) return false;
-			}
-			return true;
-		}),
-};
-
-/**
- * #16 — Up-direction tier guard (§1.4). Calling `node.up(messages)` with a
- * tier-3 (DATA/RESOLVED) or tier-4 (COMPLETE/ERROR) payload throws; tier-1
- * (DIRTY), tier-2 (PAUSE/RESUME), and tier-5 (TEARDOWN) do not throw on a
- * node that has deps.
- *
- * Mirrors TLA+ `UpQueuesCarryControlPlane`. The runtime enforces this at
- * `_validateUpTiers` (src/core/node.ts ~L981). Spec §1.4: "up — upstream
- * from sink toward source (PAUSE, RESUME, INVALIDATE, TEARDOWN)"; §2.2 `up`
- * interface says tier-3/4 throw.
- *
- * Regression guard: any future refactor that drops the tier check would
- * allow DATA/ERROR payloads to flow toward deps, bypassing equals
- * substitution and cache advance — a protocol-invariant violation.
- *
- * Note: TLA+ models the ASPIRATIONAL semantic where `UpPause` at a leaf
- * applies `pauseLocks` at the parent. The current runtime's `up()` only
- * forwards to deps; sources with no deps silently absorb the message. This
- * gap is tracked in docs/optimizations.md as "up-direction PAUSE semantics."
- * This invariant covers the contract the runtime DOES honor today (tier
- * guard + forwarding shape).
- */
-const invariant16UpTierGuard: Invariant = {
-	name: "up-direction-tier-guard",
-	description:
-		"Calling `up()` with a tier-3 (DATA/RESOLVED) or tier-4 (COMPLETE/ERROR) payload throws; tier-1/2/5 payloads do not throw on a node with deps.",
-	specRef: "GRAPHREFLY-SPEC §1.4 (direction conventions) + §2.2 (up interface)",
-	property: () =>
-		fc.property(
-			fc.constantFrom<"DIRTY" | "PAUSE" | "RESUME" | "DATA" | "RESOLVED" | "COMPLETE" | "ERROR">(
-				"DIRTY",
-				"PAUSE",
-				"RESUME",
-				"DATA",
-				"RESOLVED",
-				"COMPLETE",
-				"ERROR",
-			),
-			(tierName) => {
-				const s = node([], { initial: 0 });
-				const d = node(
-					[s],
-					(batchData, actions, ctx) => {
-						const data = batchData.map((batch, i) =>
-							batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-						);
-						actions.emit(data[0] as number);
-					},
-					{ describeKind: "derived" },
-				);
-				const unsub = d.subscribe(() => {});
-				try {
-					// Build the message. PAUSE/RESUME require a lockId payload.
-					let thrown = false;
-					try {
-						if (tierName === "DIRTY") {
-							d.up([[DIRTY]]);
-						} else if (tierName === "PAUSE") {
-							d.up([[PAUSE, Symbol("up-pause")]]);
-						} else if (tierName === "RESUME") {
-							d.up([[RESUME, Symbol("up-resume")]]);
-						} else if (tierName === "DATA") {
-							d.up([[DATA, 1]]);
-						} else if (tierName === "RESOLVED") {
-							d.up([[RESOLVED]]);
-						} else if (tierName === "COMPLETE") {
-							d.up([[COMPLETE]]);
-						} else {
-							d.up([[ERROR, new Error("up-error")]]);
-						}
-					} catch {
-						thrown = true;
-					}
-					const isTier34 =
-						tierName === "DATA" ||
-						tierName === "RESOLVED" ||
-						tierName === "COMPLETE" ||
-						tierName === "ERROR";
-					return thrown === isTier34;
-				} finally {
-					unsub();
-				}
-			},
-		),
-};
-
-/**
- * #17 — Pausable:false structural + paired negative control (§2.6).
- *
- * Mirrors TLA+ `PausableOffStructural` and strengthens the test beyond a
- * single-mode check. The runtime's `_emit` at src/core/node.ts ~L1953
- * guards lock accumulation behind `this._pausable !== false` — so PAUSE
- * arriving at a `pausable: false` node MUST be ignored, and fn execution
- * MUST continue firing normally (per the spec §2.6 table: "fn fires
- * normally regardless of flow control signals").
- *
- * The test uses a **derived node** whose fn execution is the observable
- * (state sources bypass `_maybeRunFnOnSettlement`'s `_paused` gate — see
- * node.ts:1602 — so pausable:on vs pausable:false at a pure source looks
- * identical to downstream subscribers, which would make a source-level
- * test silently false-positive). A derived node makes the mode matter.
- *
- * Paired property — with the same stimulus topology, flip only the
- * `pausable` option:
- * - `pausable: false`: `down([[PAUSE, lockId]])` on derived → subsequent
- *   source emit triggers fn, DATA reaches subscriber. ✓ contract.
- * - `pausable: true` (default): same stimulus, fn is suppressed via
- *   `_maybeRunFnOnSettlement`'s `_paused` early-return; subscriber sees
- *   NO DATA. ✓ confirms the option actually wires through. If both
- *   branches produced the same observation, the option would be silently
- *   ignored and this test would fail — i.e. it cannot pass for the
- *   "false-positive because the option never reached the runtime" reason.
- */
-const invariant17PausableOffStructural: Invariant = {
-	name: "pausable-off-structural",
-	description:
-		"A derived with `pausable: false` delivers DATA after PAUSE (lock ignored); same topology with `pausable: true` does NOT deliver (fn suppressed). The paired check rules out a test passing because the option was silently ignored.",
-	specRef: "GRAPHREFLY-SPEC §2.6 (pausable option — false)",
-	property: () =>
-		fc.property(fc.integer({ min: 1, max: 9 }), (emitVal) => {
-			const run = (pausable: boolean): boolean => {
-				const s = node([], { initial: 0 });
-				const d = node(
-					[s],
-					(batchData, actions, ctx) => {
-						const data = batchData.map((batch, i) =>
-							batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-						);
-						actions.emit((data[0] as number) * 2);
-					},
-					{ describeKind: "derived", pausable },
-				);
-				let sawData = false;
-				let dataValue: number | null = null;
-				const unsub = d.subscribe((msgs) => {
-					for (const m of msgs as readonly [symbol, unknown?][]) {
-						if (m[0] === DATA) {
-							sawData = true;
-							dataValue = m[1] as number;
-						}
-					}
-				});
-				// After activation-time handshake, hold a PAUSE lock at the
-				// derived. Then emit a fresh value upstream. Whether DATA
-				// reaches the subscriber depends on `pausable`:
-				// - false: lock ignored at _emit's `this._pausable !== false`
-				//   guard; fn fires; DATA flows through.
-				// - true: lock accumulates, `_paused` becomes true,
-				//   `_maybeRunFnOnSettlement` early-returns on `if (this._paused)`.
-				d.down([[PAUSE, Symbol("pausable-off-negcontrol")]]);
-				sawData = false;
-				dataValue = null;
-				s.emit(emitVal);
-				unsub();
-				return sawData && dataValue === emitVal * 2;
-			};
-			// Contract check (positive): pausable:false → DATA must arrive.
-			const positive = run(false);
-			// Negative control: pausable:true → DATA must NOT arrive. If both
-			// branches deliver DATA, the option was silently ignored and the
-			// positive check passed for the wrong reason.
-			const negative = !run(true);
-			return positive && negative;
-		}),
-};
-
-// ---------------------------------------------------------------------------
-// Operator-layer invariants (added 2026-04-24 batch 9, G)
-//
-// These test composed-behavior correctness of higher-order operators
-// (switchMap / mergeMap / exhaustMap). They differ from the protocol-layer
-// invariants above in that they assert LIFECYCLE semantics — which inner
-// sources contribute to the downstream trace and which are suppressed —
-// rather than raw message ordering. Each invariant picks the narrowest
-// topology that exhibits the target property.
-//
-// These are fast-check-only. TLA+ does not model operator internals; the
-// wave-protocol spec stops at the `node` primitive. Operator correctness
-// lives at the runtime layer and is tested via property generation over
-// outer-source event sequences.
-// ---------------------------------------------------------------------------
-
-/**
- * #18 — switchMap: a value emitted into a SUPERSEDED inner source never
- * reaches the downstream trace.
- *
- * Topology: `outer = state`; `sm = switchMap(outer, v => inner_v)` where
- * `inner_v` is the SAME memoised `state` per outer value so we can reach
- * in and emit post-supersession. Drive outer with a strictly-ascending
- * sequence (distinct values); after all outer emits, emit a sentinel
- * value into every inner except the last (currently-active) one. No
- * sentinel may appear in the downstream trace.
- *
- * Catches: "inner subscription not torn down on supersede" — the class
- * flagged in `docs/optimizations.md` under "switchMap-inner teardown
- * hardening for refineExecutor / evalVerifier." A regression that keeps
- * a stale inner subscribed (e.g. forgetting to call `innerUnsub()` on
- * new-outer arrival) would produce sentinel values downstream and trip
- * this invariant.
- */
-const invariant18SwitchMapStaleInnerSuppressed: Invariant = {
-	name: "switchmap-stale-inner-suppressed",
-	description:
-		"After switchMap supersedes to a new inner, emits into a prior inner source never reach the downstream trace.",
-	specRef: "src/extra/operators.ts:switchMap — supersede-on-outer-emit teardown contract",
-	property: () =>
-		fc.property(
-			fc.uniqueArray(fc.integer({ min: 1, max: 99 }), {
-				minLength: 2,
-				maxLength: 5,
-			}),
-			(outerValues) => {
-				const outer = node<number>([], { initial: outerValues[0] });
-				const inners = new Map<number, Node<number>>();
-				const sm = switchMap(outer as Node<number>, (v: number) => {
-					let inner = inners.get(v);
-					if (!inner) {
-						inner = node<number>([], { initial: v * 10 });
-						inners.set(v, inner);
-					}
-					return inner;
-				});
-				const dataValues: number[] = [];
-				const unsub = sm.subscribe((msgs) => {
-					for (const msg of msgs as readonly [symbol, unknown?][]) {
-						if (msg[0] === DATA) dataValues.push(msg[1] as number);
-					}
-				});
-				// Drive outer through the remaining distinct values (already seeded
-				// at outerValues[0] via state construction — initial subscription
-				// pushes through the first inner already).
-				for (let i = 1; i < outerValues.length; i++) outer.emit(outerValues[i]);
-				const lastOuter = outerValues[outerValues.length - 1];
-				const lenBefore = dataValues.length;
-				// Emit a unique sentinel into each superseded inner. If teardown
-				// worked, none reach the trace; if it didn't, at least one does.
-				const SENTINEL = 987654;
-				for (const [v, inner] of inners) {
-					if (v !== lastOuter) inner.emit(SENTINEL);
-				}
-				unsub();
-				for (let i = lenBefore; i < dataValues.length; i++) {
-					if (dataValues[i] === SENTINEL) return false;
-				}
-				return true;
-			},
-		),
-};
-
-/**
- * #19 — mergeMap: every live inner source's DATA emits reach the downstream
- * trace. No silent drop of non-current inners.
- *
- * Topology: `outer = state`; `mm = mergeMap(outer, v => inner_v)` with
- * memoised inner states per outer value. After driving outer with a
- * distinct sequence, emit a uniquely-tagged sentinel `v * 1000 + k` into
- * inner `v` (for a fresh k). Every emitted sentinel must appear in the
- * downstream trace — any missing one indicates a leaked/unsubscribed
- * inner.
- *
- * Catches: mergeMap inner-tracking regressions. Unlike switchMap which
- * supersedes, mergeMap keeps ALL inners live until each completes; a
- * regression that drops an inner subscription (e.g. clearAll fires
- * erroneously, or innerStops loses an entry) would silently suppress
- * valid DATA and trip this invariant.
- */
-const invariant19MergeMapAllInnersContribute: Invariant = {
-	name: "mergemap-all-live-inners-contribute",
-	description:
-		"Every DATA emitted into a live inner source after mergeMap has subscribed to it reaches the downstream trace.",
-	specRef: "src/extra/operators.ts:mergeMap — all-inners-forward contract",
-	property: () =>
-		fc.property(
-			fc.uniqueArray(fc.integer({ min: 1, max: 99 }), {
-				minLength: 2,
-				maxLength: 4,
-			}),
-			(outerValues) => {
-				const outer = node<number>([], { initial: outerValues[0] });
-				const inners = new Map<number, Node<number>>();
-				const mm = mergeMap(outer as Node<number>, (v: number) => {
-					let inner = inners.get(v);
-					if (!inner) {
-						inner = node<number>([], { initial: v * 10 });
-						inners.set(v, inner);
-					}
-					return inner;
-				});
-				const dataValues: number[] = [];
-				const unsub = mm.subscribe((msgs) => {
-					for (const msg of msgs as readonly [symbol, unknown?][]) {
-						if (msg[0] === DATA) dataValues.push(msg[1] as number);
-					}
-				});
-				for (let i = 1; i < outerValues.length; i++) outer.emit(outerValues[i]);
-				// Emit a distinct sentinel into each inner. All of them must appear
-				// downstream — mergeMap keeps inners live.
-				const expectedSentinels: number[] = [];
-				for (const [v, inner] of inners) {
-					const sentinel = v * 1000 + 7;
-					expectedSentinels.push(sentinel);
-					inner.emit(sentinel);
-				}
-				unsub();
-				for (const s of expectedSentinels) {
-					if (!dataValues.includes(s)) return false;
-				}
-				return true;
-			},
-		),
-};
-
-/**
- * #20 — exhaustMap: while an inner is active, subsequent outer emits are
- * DROPPED. Only the first outer's inner contributes until that inner
- * completes.
- *
- * Topology: `outer = state`; `em = exhaustMap(outer, v => inner_v)` with
- * memoised inner states per outer value. Drive outer with a distinct
- * sequence. The first value's inner remains uncompleted — so all
- * subsequent outers must NOT have had `project` called on them (no
- * inner created for them). Assert `inners.size === 1` (only the first
- * outer's inner was created).
- *
- * Catches: exhaustMap regression where the drop-while-active gate is
- * bypassed. A broken implementation that spawns inners for every outer
- * emit (mergeMap-style) would create multiple entries in the inners
- * map and trip this invariant.
- */
-const invariant20ExhaustMapDropsWhileActive: Invariant = {
-	name: "exhaustmap-drops-while-active",
-	description:
-		"While an exhaustMap inner is active (uncompleted), subsequent outer emits are dropped — no new inner is created for them.",
-	specRef: "src/extra/operators.ts:exhaustMap — drop-while-active contract",
-	property: () =>
-		fc.property(
-			fc.uniqueArray(fc.integer({ min: 1, max: 99 }), {
-				minLength: 2,
-				maxLength: 4,
-			}),
-			(outerValues) => {
-				const outer = node<number>([], { initial: outerValues[0] });
-				const projectCalls: number[] = [];
-				const em = exhaustMap(outer as Node<number>, (v: number) => {
-					projectCalls.push(v);
-					// Inner never completes — it's a long-lived state source.
-					return node<number>([], { initial: v * 10 });
-				});
-				const unsub = em.subscribe(() => {});
-				for (let i = 1; i < outerValues.length; i++) outer.emit(outerValues[i]);
-				unsub();
-				// Only the FIRST outer value's project should have fired; the
-				// remaining outers arrived while the first inner was still
-				// active and should have been dropped without a project call.
-				return projectCalls.length === 1 && projectCalls[0] === outerValues[0];
-			},
-		),
-};
-
-/**
- * #21 — concatMap: `project` is called serially — never for outer N+1 until
- * inner N completes. Queue depth is unbounded (unless `maxBuffer` is set);
- * `project` calls cadence ties to inner completion ordering, not outer
- * arrival ordering.
- *
- * Topology: `outer = state`; `cm = concatMap(outer, v => memoisedInner(v))`
- * with a counter wrapping `project` and a memoised inner state per outer
- * value so we can reach in and drive COMPLETE. Drive outer through a
- * distinct sequence; `project` should only have fired once (for the
- * initial subscription). Then complete each inner in outer-arrival order,
- * asserting that each completion triggers exactly one new `project` call
- * for the next queued outer value.
- *
- * Catches: queue-bypass regressions (e.g. `project` called eagerly on
- * every outer emit), or FIFO-violation (e.g. outer N+2 subscribes before
- * outer N+1 — breaks `tryPump`'s serial contract).
- */
-const invariant21ConcatMapSerialSubscription: Invariant = {
-	name: "concatmap-serial-inner-subscription",
-	description:
-		"concatMap calls `project` for outer N+1 only after inner N completes; queued outer emits never trigger concurrent project calls.",
-	specRef: "src/extra/operators.ts:concatMap — serialized-subscription contract",
-	property: () =>
-		fc.property(
-			fc.uniqueArray(fc.integer({ min: 1, max: 99 }), {
-				minLength: 2,
-				maxLength: 4,
-			}),
-			(outerValues) => {
-				const outer = node<number>([], { initial: outerValues[0] });
-				const projectCalls: number[] = [];
-				const inners = new Map<number, Node<number>>();
-				const cm = concatMap(outer as Node<number>, (v: number) => {
-					projectCalls.push(v);
-					const inner = node<number>([], { initial: v * 10 });
-					inners.set(v, inner);
-					return inner;
-				});
-				const unsub = cm.subscribe(() => {});
-				// Initial subscription fires project for outerValues[0].
-				if (projectCalls.length !== 1) return false;
-				if (projectCalls[0] !== outerValues[0]) return false;
-
-				// Emit remaining outer values — all should queue without firing project.
-				for (let i = 1; i < outerValues.length; i++) outer.emit(outerValues[i]);
-				if (projectCalls.length !== 1) return false;
-
-				// Complete inners in outer-arrival order; each completion must trigger
-				// exactly one new project call for the next queued outer.
-				for (let i = 0; i < outerValues.length - 1; i++) {
-					const prevInner = inners.get(outerValues[i]);
-					if (!prevInner) return false;
-					prevInner.down([[COMPLETE]]);
-					if (projectCalls.length !== i + 2) return false;
-					if (projectCalls[i + 1] !== outerValues[i + 1]) return false;
-				}
-
-				unsub();
-				return true;
-			},
-		),
-};
-
-/**
- * #22 — mergeMap: `{ concurrent: K }` never permits more than K concurrent
- * inner subscriptions. With K < outerValues.length, outer emits beyond K
- * queue; `project` is not called for them until a prior inner completes.
- *
- * Topology: same memoised-inner-per-outer pattern as #21. Count `project`
- * calls; drive outer through a distinct sequence. After all emits,
- * `project` has been called exactly `min(K, outerValues.length)` times.
- * Then complete inners in order; each completion triggers one new
- * `project` call until all outers have been subscribed.
- *
- * Catches: concurrency-bound bypass (queue.shift not gated on `active <
- * maxConcurrent`), premature queue drain, or the `spawn` / `drainBuffer`
- * counters diverging from actual live subscriptions.
- */
-const invariant22MergeMapConcurrencyBound: Invariant = {
-	name: "mergemap-concurrency-bound-respected",
-	description:
-		"mergeMap with `{concurrent: K}` keeps at most K project calls pending; additional outers queue until a prior inner completes.",
-	specRef: "src/extra/operators.ts:mergeMap — concurrency bound contract",
-	property: () =>
-		fc.property(
-			fc.uniqueArray(fc.integer({ min: 1, max: 99 }), {
-				minLength: 3,
-				maxLength: 5,
-			}),
-			fc.integer({ min: 1, max: 2 }),
-			(outerValues, K) => {
-				const outer = node<number>([], { initial: outerValues[0] });
-				const projectCalls: number[] = [];
-				const inners = new Map<number, Node<number>>();
-				const mm = mergeMap(
-					outer as Node<number>,
-					(v: number) => {
-						projectCalls.push(v);
-						const inner = node<number>([], { initial: v * 10 });
-						inners.set(v, inner);
-						return inner;
-					},
-					{ concurrent: K },
-				);
-				const unsub = mm.subscribe(() => {});
-				// Emit the remaining outers. The first K project calls should have
-				// fired (initial + K-1 additional); the rest queue.
-				for (let i = 1; i < outerValues.length; i++) outer.emit(outerValues[i]);
-				const expectedInitial = Math.min(K, outerValues.length);
-				if (projectCalls.length !== expectedInitial) return false;
-				// Completed inners should pop one queued outer each.
-				for (let i = 0; i < outerValues.length - K; i++) {
-					const prevInner = inners.get(outerValues[i]);
-					if (!prevInner) return false;
-					prevInner.down([[COMPLETE]]);
-					const expected = Math.min(K + i + 1, outerValues.length);
-					if (projectCalls.length !== expected) return false;
-				}
-				unsub();
-				return true;
-			},
-		),
-};
-
-/**
- * #23 — race: the first source to emit DATA wins; losers' subsequent DATA
- * never reaches the output, and the winner continues forwarding DATA
- * afterwards.
- *
- * Topology: N captured-push `producer<number>` sources (no cached DATA,
- * no push-on-subscribe artifacts). `r = race(...sources)`. After
- * subscribe, `pushers[0]` fires first with a winner tag — that settles
- * the winner index. Then every loser pushes a uniquely-tagged sentinel
- * that MUST NOT reach the trace. Finally `pushers[0]` fires a second
- * winner tag that MUST reach the trace (winner-continues contract).
- *
- * Using producers (not `state` with cached DATA) ensures the winner is
- * selected by the actual first-DATA-arrival semantic race advertises,
- * not by the push-on-subscribe ordering artifact of cached-state
- * sources. A regression that selects winners by subscribe order rather
- * than first-emit would now fail this invariant when we push into
- * sources[0] explicitly first.
- *
- * Catches: winner-lock regressions (e.g. `winner` reset on each batch,
- * or losers re-entering after an unrelated event), short-circuit bypass
- * (a loser forwarding DATA despite `winner !== null`), or winner drop
- * (forwarding only the first winner DATA and suppressing subsequent
- * winner emits).
- */
-const invariant23RaceFirstWins: Invariant = {
-	name: "race-first-wins-only",
-	description:
-		"race() forwards DATA only from whichever source emitted DATA first; losers' subsequent DATA never reaches output; the winner continues forwarding its subsequent DATA.",
-	specRef: "src/extra/operators.ts:race — first-DATA-wins contract",
-	property: () =>
-		fc.property(fc.integer({ min: 2, max: 5 }), (sourceCount) => {
-			const pushers: Array<((v: number) => void) | undefined> = Array.from(
-				{ length: sourceCount },
-				() => undefined,
-			);
-			const sources: Node<number>[] = Array.from({ length: sourceCount }, (_, i) => {
-				return node<number>(
-					[],
-					(_data, a) => {
-						pushers[i] = (v) => a.emit(v);
-						return {
-							onDeactivation: () => {
-								pushers[i] = undefined;
-							},
-						};
-					},
-					{ describeKind: "producer" },
-				) as Node<number>;
-			});
-			const r = race(...sources);
-			const emitted: number[] = [];
-			const unsub = r.subscribe((msgs) => {
-				for (const m of msgs as readonly [symbol, unknown?][]) {
-					if (m[0] === DATA) emitted.push(m[1] as number);
-				}
-			});
-			// Producer sources don't auto-fire on subscribe; push sources[0] first
-			// to elect it the winner by explicit first-DATA-arrival order.
-			const WINNER_TAG_1 = 77777;
-			pushers[0]?.(WINNER_TAG_1);
-			// Losers push sentinels — all must be suppressed.
-			const LOSER_TAG = 99900;
-			for (let i = 1; i < sourceCount; i++) {
-				pushers[i]?.(LOSER_TAG + i);
-			}
-			// Winner pushes a second DATA — must reach output (winner-continues).
-			const WINNER_TAG_2 = 77778;
-			pushers[0]?.(WINNER_TAG_2);
-			unsub();
-			for (const v of emitted) {
-				if (v >= LOSER_TAG && v < LOSER_TAG + sourceCount) return false;
-			}
-			return emitted.length === 2 && emitted[0] === WINNER_TAG_1 && emitted[1] === WINNER_TAG_2;
-		}),
-};
-
-/**
- * #24 — repeat: `repeat(source, N)` emits downstream COMPLETE exactly after
- * the N-th inner COMPLETE — never sooner, never later.
- *
- * Topology: `s = node<number>([], { resubscribable: true , initial: 0 })`;
- * `r = repeat(s, N)`. Drive s through N-1 COMPLETE signals via raw
- * `s.down([[COMPLETE]])`; the outer r MUST NOT have emitted COMPLETE yet
- * (repeat resubscribes and waits for next inner terminal). After the N-th
- * COMPLETE, r MUST emit exactly one downstream COMPLETE.
- *
- * Catches: off-by-one in `remaining` counter, premature downstream
- * COMPLETE (e.g. forwarding the first inner COMPLETE), or over-repeat
- * (e.g. resubscribing after the final COMPLETE).
- */
-const invariant24RepeatCountRespected: Invariant = {
-	name: "repeat-count-respected",
-	description:
-		"repeat(source, N) emits downstream COMPLETE exactly after the N-th inner COMPLETE — never sooner, never later.",
-	specRef: "src/extra/operators.ts:repeat — count-respecting contract",
-	property: () =>
-		fc.property(fc.integer({ min: 1, max: 5 }), (N) => {
-			const s = node<number>([], { resubscribable: true, initial: 0 });
-			const r = repeat(s, N);
-			let completes = 0;
-			const unsub = r.subscribe((msgs) => {
-				for (const m of msgs as readonly [symbol, unknown?][]) {
-					if (m[0] === COMPLETE) completes += 1;
-				}
-			});
-			for (let i = 0; i < N - 1; i++) {
-				s.down([[COMPLETE]]);
-				if (completes !== 0) {
-					unsub();
-					return false;
-				}
-			}
-			s.down([[COMPLETE]]);
-			if (completes !== 1) {
-				unsub();
-				return false;
-			}
-			// Post-N COMPLETE leak check: an additional source COMPLETE must NOT
-			// re-trigger repeat (`remaining` should have hit 0 and downstream should
-			// be terminated). Catches an over-repeat regression that the narrow
-			// N-COMPLETE loop would silently pass.
-			s.down([[COMPLETE]]);
-			unsub();
-			return completes === 1;
-		}),
-};
-
-/**
- * #25 — debounce: `debounce(source, ms)` emits only the LAST value when the
- * source emits rapidly within the ms quiet window; intermediate values
- * are coalesced.
- *
- * Topology: `s = node<number>([], { initial: 0 })`; `d = debounce(s, 50)`. Under fake
- * timers, emit each generated value with a 10ms gap (< ms, so each reset
- * keeps the timer alive). No DATA must reach the trace during the burst.
- * After `advanceTimersByTime(60)` (crosses the reset quiet window), the
- * trace must contain exactly one new DATA equal to the LAST value.
- *
- * Catches: coalesce-bypass regressions (emit-per-input), timer-reset
- * drops (failing to `clearTimeout` on each DATA), or pending-value
- * staleness (flushing an earlier value instead of the latest).
- */
-const invariant25DebounceCoalesce: Invariant = {
-	name: "debounce-coalesces-rapid-emits",
-	description:
-		"debounce(source, ms) emits exactly one downstream DATA equal to the last rapidly-emitted value when all source emits fall within the ms quiet window.",
-	specRef: "src/extra/operators.ts:debounce — coalesce contract",
-	property: () =>
-		fc.property(
-			fc.array(fc.integer({ min: 1, max: 999 }), { minLength: 2, maxLength: 6 }),
-			(values) => {
-				vi.useFakeTimers();
-				try {
-					// { equals: () => false } on the source prevents Object.is absorption
-					// from silently swallowing `[5, 5]`-style shrunk counter-examples at
-					// the source before debounce even sees the second emit — otherwise
-					// coalescing could appear to work vacuously on any-repeat input.
-					const s = node<number>([], { equals: () => false, initial: 0 });
-					const d = debounce(s as Node<number>, 50);
-					const emitted: number[] = [];
-					const unsub = d.subscribe((msgs) => {
-						for (const m of msgs as readonly [symbol, unknown?][]) {
-							if (m[0] === DATA) emitted.push(m[1] as number);
-						}
-					});
-					for (const v of values) {
-						s.emit(v);
-						vi.advanceTimersByTime(10);
-					}
-					// Burst complete: all gaps 10ms < ms=50, so no timer has fired.
-					if (emitted.length !== 0) {
-						unsub();
-						return false;
-					}
-					vi.advanceTimersByTime(60);
-					unsub();
-					return emitted.length === 1 && emitted[0] === values[values.length - 1];
-				} finally {
-					vi.useRealTimers();
-				}
-			},
-		),
-	// producer/factory churn under fake timers is tolerable; default 100 runs.
-};
-
-/**
- * #26 — timeout: `timeout(source, ms)` emits exactly one ERROR when the
- * source is idle past the ms budget; no DATA or COMPLETE precedes the
- * ERROR.
- *
- * Topology: silent `producer<number>` that never emits, wrapped in
- * `timeout(silent, ms)`. Under fake timers, advance `ms - 1` — no
- * terminal message yet. Advance 2 more — exactly one ERROR, no DATA,
- * no COMPLETE.
- *
- * Catches: watchdog-timer off-by-one, double-ERROR (timer re-firing
- * after emit), or forwarding a spurious DATA/COMPLETE during the
- * timeout cascade.
- */
-const invariant26TimeoutErrorsOnIdle: Invariant = {
-	name: "timeout-errors-on-idle",
-	description:
-		"timeout(source, ms) emits exactly one ERROR when the source is idle past the ms budget; no DATA or COMPLETE precedes the ERROR.",
-	specRef: "src/extra/operators.ts:timeout — idle-watchdog contract",
-	property: () =>
-		fc.property(fc.integer({ min: 20, max: 200 }), (ms) => {
-			vi.useFakeTimers();
-			try {
-				const silent = node<number>(
-					() => {
-						return { onDeactivation: () => {} };
-					},
-					{ describeKind: "producer" },
-				);
-				const t = timeout(silent as Node<number>, ms);
-				const seen: symbol[] = [];
-				const unsub = t.subscribe((msgs) => {
-					for (const m of msgs as readonly [symbol, unknown?][]) {
-						if (m[0] === DATA || m[0] === COMPLETE || m[0] === ERROR) {
-							seen.push(m[0]);
-						}
-					}
-				});
-				vi.advanceTimersByTime(ms - 1);
-				if (seen.length !== 0) {
-					unsub();
-					return false;
-				}
-				vi.advanceTimersByTime(2);
-				unsub();
-				return seen.length === 1 && seen[0] === ERROR;
-			} finally {
-				vi.useRealTimers();
-			}
-		}),
-};
-
-/**
- * #27 — throttle (leading-edge, trailing=false): passes the first DATA of a
- * burst immediately and suppresses subsequent DATAs arriving within the
- * same ms window.
- *
- * Topology: `producer<number>` with a captured push fn so the property
- * controls emit timing. `throttle(src, 100, { trailing: false })`.
- * Under fake timers, emit each generated value with a 5ms gap (all
- * within the 100ms window). Only `values[0]` reaches the output.
- *
- * Catches: leading-edge gate bypass (every emit passes), trailing-edge
- * leak (`trailing: false` honored), or `lastEmitNs` reset inside the
- * window.
- */
-const invariant27ThrottleLeadingSuppresses: Invariant = {
-	name: "throttle-leading-passes-first-suppresses-rest",
-	description:
-		"Default throttle(source, ms, { trailing: false }) passes only the first DATA of a burst; subsequent DATAs within the same ms window are suppressed.",
-	specRef: "src/extra/operators.ts:throttle — leading-edge contract",
-	property: () =>
-		fc.property(
-			fc.array(fc.integer({ min: 1, max: 999 }), { minLength: 2, maxLength: 5 }),
-			(values) => {
-				vi.useFakeTimers();
-				try {
-					let pushSrc: ((v: number) => void) | undefined;
-					// { equals: () => false } on the source prevents Object.is
-					// absorption from quietly collapsing `[5, 5]`-style repeats at the
-					// producer's own output before throttle ever sees them. Without
-					// this, a throttle regression that passes every emit would still
-					// look like "one DATA passed" on any duplicate-value input.
-					const s = node<number>(
-						[],
-						(_data, a) => {
-							pushSrc = (v) => a.emit(v);
-							return {
-								onDeactivation: () => {
-									pushSrc = undefined;
-								},
-							};
-						},
-						{ describeKind: "producer", equals: () => false },
-					);
-					const t = throttle(s as Node<number>, 100, { trailing: false });
-					const emitted: number[] = [];
-					const unsub = t.subscribe((msgs) => {
-						for (const m of msgs as readonly [symbol, unknown?][]) {
-							if (m[0] === DATA) emitted.push(m[1] as number);
-						}
-					});
-					for (const v of values) {
-						pushSrc?.(v);
-						vi.advanceTimersByTime(5);
-					}
-					unsub();
-					return emitted.length === 1 && emitted[0] === values[0];
-				} finally {
-					vi.useRealTimers();
-				}
-			},
-		),
-};
-
-/**
- * #28 — zip: emits the i-th tuple only once both `a` and `b` have delivered
- * their i-th DATA. Tuples stay positionally aligned regardless of dep
- * emit order.
- *
- * Topology: `node<number>([], { initial: 0 })` and `node<number>([], { initial: 100 })` wrapped in
- * `zip(a, b)`. Initial subscribe delivers [0, 100] (both cached DATAs
- * queue; tryEmit pairs them). Then emit N values into `a` (no tuples
- * emitted; queue_b empty). Then emit N values into `b` — exactly N
- * tuples, `emitted[k] === [k, 100 + k]` for k = 1..N.
- *
- * Catches: queue-bypass (emit-per-source without pairing), FIFO
- * violation in `tryEmit`, or `active` counter divergence that would
- * let one source race past the other.
- */
-const invariant28ZipStrictPair: Invariant = {
-	name: "zip-strict-pair-per-position",
-	description:
-		"zip(a, b) emits the i-th tuple only after both a and b have delivered their i-th DATA; tuples stay positionally aligned regardless of dep emit order.",
-	specRef: "src/extra/operators.ts:zip — strict-pair contract",
-	property: () =>
-		fc.property(fc.integer({ min: 1, max: 4 }), (N) => {
-			const a = node<number>([], { initial: 0 });
-			const b = node<number>([], { initial: 100 });
-			const z = zip(a, b);
-			const emitted: [number, number][] = [];
-			const unsub = z.subscribe((msgs) => {
-				for (const m of msgs as readonly [symbol, unknown?][]) {
-					if (m[0] === DATA) emitted.push(m[1] as [number, number]);
-				}
-			});
-			if (emitted.length !== 1 || emitted[0][0] !== 0 || emitted[0][1] !== 100) {
-				unsub();
-				return false;
-			}
-			for (let i = 1; i <= N; i++) a.emit(i);
-			if (emitted.length !== 1) {
-				unsub();
-				return false;
-			}
-			for (let j = 1; j <= N; j++) b.emit(100 + j);
-			unsub();
-			if (emitted.length !== N + 1) return false;
-			for (let k = 1; k <= N; k++) {
-				if (emitted[k][0] !== k || emitted[k][1] !== 100 + k) return false;
-			}
-			return true;
-		}),
-};
-
-/**
- * #29 — distinctUntilChanged: suppresses consecutive duplicate DATA values
- * even when the upstream source admits them; the downstream trace is
- * the dedup'd sequence.
- *
- * Topology: `node<number>([], { equals: () => false , initial: -1 })` — source-level
- * absorption disabled so every `emit` produces DATA. Wrapped in
- * `distinctUntilChanged(s)`. Emit each generated value; assert the
- * downstream trace equals the canonical dedup of `[-1, ...values]`
- * starting from the initial.
- *
- * Catches: dedup state corruption across waves, first-DATA bypass,
- * or `equals` fn misapplication (e.g. using `Object.is` on objects
- * when a deep equality was configured).
- */
-const invariant29DistinctUntilChanged: Invariant = {
-	name: "distinct-until-changed-dedups-consecutive",
-	description:
-		"distinctUntilChanged suppresses consecutive duplicate DATA values even when the upstream source admits them; the downstream trace is the dedup'd sequence.",
-	specRef: "src/extra/operators.ts:distinctUntilChanged — consecutive-dedup contract",
-	property: () =>
-		fc.property(
-			fc.array(fc.integer({ min: 0, max: 3 }), { minLength: 2, maxLength: 8 }),
-			(values) => {
-				const s = node<number>([], { equals: () => false, initial: -1 });
-				const d = distinctUntilChanged(s as Node<number>);
-				const emitted: number[] = [];
-				const unsub = d.subscribe((msgs) => {
-					for (const m of msgs as readonly [symbol, unknown?][]) {
-						if (m[0] === DATA) emitted.push(m[1] as number);
-					}
-				});
-				for (const v of values) s.emit(v);
-				unsub();
-				const expected: number[] = [-1];
-				let prev = -1;
-				for (const v of values) {
-					if (v !== prev) {
-						expected.push(v);
-						prev = v;
-					}
-				}
-				if (emitted.length !== expected.length) return false;
-				for (let i = 0; i < expected.length; i++) {
-					if (emitted[i] !== expected[i]) return false;
-				}
-				return true;
-			},
-		),
-};
-
-/**
- * #30 — sample: `sample(src, notifier)` re-emits src's latest DATA each time
- * notifier emits DATA. Source-tick pairing is positional.
- *
- * Topology: `node<number>([], { initial: -1 })` (src) + `node<number>([], { initial: -1 })` (ticker)
- * wrapped in `sample(src, ticker)`. Initial subscribe:
- * - sample subscribes src → callback fires with src's cached DATA(-1), sets
- *   lastSourceValue.v = -1.
- * - sample subscribes ticker → callback fires with ticker's cached
- *   DATA(-1) → emits `lastSourceValue.v = -1`.
- *
- * Then, for each i in 1..N, mutate src to a unique value and tick; the
- * output must carry that unique value positionally.
- *
- * Catches: held-value staleness (emitting prior src value after newer
- * src DATA), notifier DATA swallowed without emit, or source-completed
- * leaks (sample continuing after source terminates).
- */
-const invariant30Sample: Invariant = {
-	name: "sample-emits-source-latest-on-notifier",
-	description:
-		"sample(src, notifier) emits the latest src DATA each time notifier emits; source-tick pairing is positional.",
-	specRef: "src/extra/operators.ts:sample — latest-on-notifier contract",
-	property: () =>
-		fc.property(fc.integer({ min: 2, max: 5 }), (N) => {
-			const src = node<number>([], { initial: -1 });
-			const ticker = node<number>([], { initial: -1 });
-			const sp = sample(src as Node<number>, ticker as Node<number>);
-			const emitted: number[] = [];
-			const unsub = sp.subscribe((msgs) => {
-				for (const m of msgs as readonly [symbol, unknown?][]) {
-					if (m[0] === DATA) emitted.push(m[1] as number);
-				}
-			});
-			for (let i = 1; i <= N; i++) {
-				src.emit(i * 100);
-				ticker.emit(i);
-			}
-			const expected = [-1];
-			for (let i = 1; i <= N; i++) expected.push(i * 100);
-			if (emitted.length !== expected.length) {
-				unsub();
-				return false;
-			}
-			for (let k = 0; k < expected.length; k++) {
-				if (emitted[k] !== expected[k]) {
-					unsub();
-					return false;
-				}
-			}
-			// Source-completed leak check: after src COMPLETE, sample must clear its
-			// held value and notifier ticks must no longer produce DATA.
-			const lenBeforeComplete = emitted.length;
-			src.down([[COMPLETE]]);
-			ticker.emit(999);
-			ticker.emit(1000);
-			unsub();
-			return emitted.length === lenBeforeComplete;
-		}),
-};
-
-/**
- * #31 — pairwise: emits `[prev, curr]` starting from the second DATA; the
- * first DATA produces no tuple.
- *
- * Topology: `node<number>([], { equals: () => false , initial: values[0] })` (source
- * absorption disabled so even equal consecutive values pass) wrapped in
- * `pairwise(s)`. Emit `values[1..]`; assert the downstream trace is
- * exactly `[(values[0], values[1]), (values[1], values[2]), …]`.
- *
- * Catches: first-DATA tuple leak (emitting `[undefined, v0]`), prev-state
- * corruption across waves, or tuple-order flip.
- */
-const invariant31Pairwise: Invariant = {
-	name: "pairwise-emits-adjacent-tuples",
-	description:
-		"pairwise(source) emits [prev, curr] starting from the second DATA; the first DATA produces no tuple and tuples stay positionally aligned.",
-	specRef: "src/extra/operators.ts:pairwise — adjacent-tuple contract",
-	property: () =>
-		fc.property(
-			fc.array(fc.integer({ min: 1, max: 999 }), { minLength: 2, maxLength: 6 }),
-			(values) => {
-				const s = node<number>([], { equals: () => false, initial: values[0] });
-				const p = pairwise(s as Node<number>);
-				const emitted: [number, number][] = [];
-				const unsub = p.subscribe((msgs) => {
-					for (const m of msgs as readonly [symbol, unknown?][]) {
-						if (m[0] === DATA) emitted.push(m[1] as [number, number]);
-					}
-				});
-				for (let i = 1; i < values.length; i++) s.emit(values[i]);
-				unsub();
-				const expected: [number, number][] = [];
-				for (let i = 1; i < values.length; i++) {
-					expected.push([values[i - 1], values[i]]);
-				}
-				if (emitted.length !== expected.length) return false;
-				for (let k = 0; k < expected.length; k++) {
-					if (emitted[k][0] !== expected[k][0] || emitted[k][1] !== expected[k][1]) {
-						return false;
-					}
-				}
-				return true;
-			},
-		),
-};
-
-/**
- * #32 — bufferCount: `bufferCount(source, N)` emits one array of exactly N
- * DATAs per N consecutive source DATAs. Arrays are positionally aligned
- * with source order.
- *
- * Topology: `node<number>([], { equals: () => false , initial: -1 })` wrapped in
- * `bufferCount(s, N)`. The cached DATA(-1) on subscribe counts as the
- * first source DATA. Emit N*M - 1 more values (total N*M); assert
- * exactly M arrays of size N, with the concatenated values equal to
- * `[-1, 1, 2, ..., N*M - 1]`.
- *
- * Catches: chunk-size drift (wrong array length), chunk-boundary miss
- * (e.g. emit-before-push check), or partial-tail leak (emit a sub-N
- * array without a COMPLETE gate).
- */
-const invariant32BufferCount: Invariant = {
-	name: "buffer-count-chunks-exactly-n",
-	description:
-		"bufferCount(source, N) emits exactly one array of size N per N consecutive source DATAs; arrays stay positionally aligned with source order.",
-	specRef: "src/extra/operators.ts:bufferCount — chunking contract",
-	property: () =>
-		fc.property(fc.integer({ min: 2, max: 5 }), fc.integer({ min: 2, max: 5 }), (N, M) => {
-			const s = node<number>([], { equals: () => false, initial: -1 });
-			const b = bufferCount(s as Node<number>, N);
-			const emitted: number[][] = [];
-			const unsub = b.subscribe((msgs) => {
-				for (const m of msgs as readonly [symbol, unknown?][]) {
-					if (m[0] === DATA) emitted.push(m[1] as number[]);
-				}
-			});
-			const total = N * M;
-			for (let i = 1; i < total; i++) s.emit(i);
-			unsub();
-			if (emitted.length !== M) return false;
-			for (const chunk of emitted) {
-				if (chunk.length !== N) return false;
-			}
-			const flat: number[] = [];
-			for (const c of emitted) flat.push(...c);
-			if (flat.length !== total) return false;
-			if (flat[0] !== -1) return false;
-			for (let i = 1; i < total; i++) {
-				if (flat[i] !== i) return false;
-			}
-			return true;
-		}),
-};
-
-/**
- * #33 — delay: `delay(source, ms)` emits every source DATA exactly once,
- * in source-arrival order, after the ms shift. No DATA reaches
- * downstream before ms elapses from its source-arrival time.
- *
- * Topology: captured-push `producer<number>`. Under fake timers, fire
- * all N values at t=0. Assert zero DATA at t=99 and t=100-epsilon
- * (timer not yet fired). At t=101, all N DATAs delivered in source
- * order.
- *
- * Catches: timer-drop (delay swallowing a DATA), out-of-order delivery
- * (e.g. emitting values[1] before values[0]), or eager emission
- * (bypassing the ms shift).
- */
-const invariant33Delay: Invariant = {
-	name: "delay-preserves-values-and-order",
-	description:
-		"delay(source, ms) emits every source DATA exactly once, in source-arrival order, after the ms shift; no DATA reaches downstream before ms elapses.",
-	specRef: "src/extra/operators.ts:delay — time-shift contract",
-	property: () =>
-		fc.property(
-			fc.array(fc.integer({ min: 1, max: 999 }), { minLength: 2, maxLength: 5 }),
-			(values) => {
-				vi.useFakeTimers();
-				try {
-					let pushSrc: ((v: number) => void) | undefined;
-					const s = node<number>(
-						[],
-						(_data, a) => {
-							pushSrc = (v) => a.emit(v);
-							return {
-								onDeactivation: () => {
-									pushSrc = undefined;
-								},
-							};
-						},
-						{ describeKind: "producer", equals: () => false },
-					);
-					const d = delay(s as Node<number>, 100, { equals: () => false });
-					const emitted: number[] = [];
-					const unsub = d.subscribe((msgs) => {
-						for (const m of msgs as readonly [symbol, unknown?][]) {
-							if (m[0] === DATA) emitted.push(m[1] as number);
-						}
-					});
-					for (const v of values) pushSrc?.(v);
-					if (emitted.length !== 0) {
-						unsub();
-						return false;
-					}
-					vi.advanceTimersByTime(99);
-					if (emitted.length !== 0) {
-						unsub();
-						return false;
-					}
-					vi.advanceTimersByTime(2);
-					unsub();
-					if (emitted.length !== values.length) return false;
-					for (let i = 0; i < values.length; i++) {
-						if (emitted[i] !== values[i]) return false;
-					}
-					return true;
-				} finally {
-					vi.useRealTimers();
-				}
-			},
-		),
-};
-
-/**
- * #34 — buffer: `buffer(src, notifier)` emits accumulated source DATAs as an
- * array on each notifier DATA, then resets the buffer. No emission
- * between notifier ticks.
- *
- * Topology: `node<number>([], { equals: () => false , initial: -1 })` (src) +
- * `node<number>([], { equals: () => false , initial: -1 })` (notifier) wrapped in
- * `buffer(src, notifier)`. Initial subscribe order: src subscribes
- * first, cached DATA(-1) → buf=[-1]; notifier subscribes, cached
- * DATA(-1) → flush [-1], buf=[].
- *
- * Then for each of R rounds: emit K distinct values into src (buf
- * grows to K; no emit yet) then tick notifier (flush the K values
- * as one array, buf=[]). Assert exactly R + 1 arrays emitted (1
- * initial + R per-round); each round-array has K sequential values.
- *
- * Catches: buffer-drop (value swallowed without notifier), flush-on-
- * source (erroneous emit on every source DATA), non-empty-gate missing
- * (flush when buf empty yielding []), or reset-miss (values leaked
- * across rounds).
- */
-const invariant34Buffer: Invariant = {
-	name: "buffer-notifier-flushes-accumulated",
-	description:
-		"buffer(src, notifier) emits accumulated source DATAs as an array on each notifier DATA, then resets the buffer; no emission between notifier ticks.",
-	specRef: "src/extra/operators.ts:buffer — notifier-flush contract",
-	property: () =>
-		fc.property(fc.integer({ min: 2, max: 4 }), fc.integer({ min: 2, max: 4 }), (R, K) => {
-			const src = node<number>([], { equals: () => false, initial: -1 });
-			const notifier = node<number>([], { equals: () => false, initial: -1 });
-			const b = buffer(src as Node<number>, notifier as Node<number>);
-			const emitted: number[][] = [];
-			const unsub = b.subscribe((msgs) => {
-				for (const m of msgs as readonly [symbol, unknown?][]) {
-					if (m[0] === DATA) emitted.push(m[1] as number[]);
-				}
-			});
-			if (emitted.length !== 1 || emitted[0].length !== 1 || emitted[0][0] !== -1) {
-				unsub();
-				return false;
-			}
-			let counter = 0;
-			for (let r = 0; r < R; r++) {
-				for (let k = 0; k < K; k++) src.emit(counter++);
-				if (emitted.length !== r + 1) {
-					unsub();
-					return false;
-				}
-				notifier.emit(100 + r);
-				if (emitted.length !== r + 2) {
-					unsub();
-					return false;
-				}
-				const latest = emitted[emitted.length - 1];
-				if (latest.length !== K) {
-					unsub();
-					return false;
-				}
-				for (let k = 0; k < K; k++) {
-					if (latest[k] !== r * K + k) {
-						unsub();
-						return false;
-					}
-				}
-			}
-			unsub();
-			return true;
-		}),
-};
-
-/**
- * #35 — bufferTime: `bufferTime(src, ms)` emits an array of the values
- * accumulated during each ms window; empty windows produce no
- * emission.
- *
- * Topology: captured-push `producer<number>` with `{ equals: () => false }`
- * wrapped in `bufferTime(src, 100)`. Under fake timers, for each
- * generated non-empty window: push the window's values, then
- * `advanceTimersByTime(100)` to fire the setInterval tick. Assert the
- * downstream trace is exactly `windows[i]` per position.
- *
- * Catches: window-boundary drift (tick fires at wrong time), empty-
- * buffer emission, or across-window leak.
- */
-const invariant35BufferTime: Invariant = {
-	name: "buffertime-flushes-on-window-boundary",
-	description:
-		"bufferTime(src, ms) emits one array per ms window containing that window's source DATAs in order; empty windows produce no emission.",
-	specRef: "src/extra/operators.ts:bufferTime — time-window contract",
-	property: () =>
-		fc.property(
-			fc.array(fc.array(fc.integer({ min: 1, max: 999 }), { minLength: 1, maxLength: 4 }), {
-				minLength: 2,
-				maxLength: 4,
-			}),
-			(windows) => {
-				vi.useFakeTimers();
-				try {
-					let push: ((v: number) => void) | undefined;
-					const src = node<number>(
-						[],
-						(_data, a) => {
-							push = (v) => a.emit(v);
-							return {
-								onDeactivation: () => {
-									push = undefined;
-								},
-							};
-						},
-						{ describeKind: "producer", equals: () => false },
-					);
-					const b = bufferTime(src as Node<number>, 100);
-					const emitted: number[][] = [];
-					const unsub = b.subscribe((msgs) => {
-						for (const m of msgs as readonly [symbol, unknown?][]) {
-							if (m[0] === DATA) emitted.push(m[1] as number[]);
-						}
-					});
-					for (const win of windows) {
-						for (const v of win) push?.(v);
-						vi.advanceTimersByTime(100);
-					}
-					unsub();
-					if (emitted.length !== windows.length) return false;
-					for (let i = 0; i < windows.length; i++) {
-						if (emitted[i].length !== windows[i].length) return false;
-						for (let j = 0; j < windows[i].length; j++) {
-							if (emitted[i][j] !== windows[i][j]) return false;
-						}
-					}
-					return true;
-				} finally {
-					vi.useRealTimers();
-				}
-			},
-		),
-};
-
-/**
- * #36 — interval: `interval(periodMs)` emits an incrementing counter
- * starting at 0, one DATA per periodMs. Advancing N periods under
- * fake timers yields exactly N DATAs `[0, 1, ..., N-1]`.
- *
- * Catches: counter initialization drift, double-fire (two DATAs per
- * period), or period-miss.
- */
-const invariant36Interval: Invariant = {
-	name: "interval-emits-monotonic-counter-per-period",
-	description:
-		"interval(periodMs) emits an incrementing counter (0, 1, 2, ...) one per periodMs; advancing N periods yields exactly N DATAs with the expected counter values.",
-	specRef: "src/extra/operators.ts:interval — periodic-emit contract",
-	property: () =>
-		fc.property(fc.integer({ min: 1, max: 6 }), (N) => {
-			vi.useFakeTimers();
-			try {
-				const iv = interval(50);
-				const emitted: number[] = [];
-				const unsub = iv.subscribe((msgs) => {
-					for (const m of msgs as readonly [symbol, unknown?][]) {
-						if (m[0] === DATA) emitted.push(m[1] as number);
-					}
-				});
-				vi.advanceTimersByTime(50 * N);
-				unsub();
-				if (emitted.length !== N) return false;
-				for (let i = 0; i < N; i++) {
-					if (emitted[i] !== i) return false;
-				}
-				return true;
-			} finally {
-				vi.useRealTimers();
-			}
-		}),
-};
-
-/**
- * #37 — rescue: `rescue(src, recover)` swallows source ERROR and emits
- * `recover(err)` as DATA; no ERROR is forwarded to the output.
- *
- * Topology: `node<number>([], { equals: () => false , initial: -1 })` wrapped in
- * `rescue(s, err => recoveryValue)` where `recoveryValue` is
- * generated from `fc.integer({ min: 100, max: 999 })` (disjoint from
- * the initial -1 so absorption doesn't confuse the check). Initial
- * subscribe delivers DATA(-1). Then `src.down([[ERROR, errTag]])`
- * triggers the recover path. Assert: output trace is `[-1,
- * recoveryValue]`, zero ERRORs, zero COMPLETEs.
- *
- * Catches: ERROR leak (forwarded alongside recovery DATA),
- * recovery-fn not called (DATA from recover missing), or
- * double-emission of the recovery value.
- */
-const invariant37Rescue: Invariant = {
-	name: "rescue-replaces-error-with-value",
-	description:
-		"rescue(src, recover) swallows a source ERROR and emits recover(err) as DATA; no ERROR or spurious COMPLETE reaches the output.",
-	specRef: "src/extra/operators.ts:rescue — error-recovery contract",
-	property: () =>
-		fc.property(
-			fc.integer({ min: 100, max: 999 }),
-			fc.integer({ min: 1, max: 99 }),
-			(recoveryValue, errTag) => {
-				const src = node<number>([], { equals: () => false, initial: -1 });
-				const r = rescue(src as Node<number>, () => recoveryValue);
-				const emitted: number[] = [];
-				const terminals: symbol[] = [];
-				const unsub = r.subscribe((msgs) => {
-					for (const m of msgs as readonly [symbol, unknown?][]) {
-						if (m[0] === DATA) emitted.push(m[1] as number);
-						else if (m[0] === ERROR || m[0] === COMPLETE) terminals.push(m[0]);
-					}
-				});
-				if (emitted.length !== 1 || emitted[0] !== -1) {
-					unsub();
-					return false;
-				}
-				src.down([[ERROR, errTag]]);
-				unsub();
-				if (terminals.length !== 0) return false;
-				return emitted.length === 2 && emitted[1] === recoveryValue;
-			},
-		),
-};
-
-/**
- * #38 — concat: `concat(a, b)` emits all of `a`'s DATA in phase 0; on `a`
- * COMPLETE, phase=1 flushes any buffered `b` DATA and continues
- * forwarding `b`. Second-source DATAs never reach output before `a`
- * COMPLETEs.
- *
- * Topology: `node<number>([], { equals: () => false , initial: -1 })` (a) +
- * `node<number>([], { equals: () => false , initial: -2 })` (b) wrapped in
- * `concat(a, b)`. Subscribe order inside concat: secondSrc first →
- * cached DATA(-2) goes to `pending` (phase=0). firstSrc second →
- * cached DATA(-1) passes through (phase=0 DATA branch). Initial
- * output: `[-1]`.
- *
- * Then: emit M values into `a` (all forwarded). Emit K values into
- * `b` (all buffered in `pending`; output unchanged). `a.down([[COMPLETE]])`
- * → phase=1, flush pending = `[-2, 101..100+K]` via sequential
- * `a.emit(v)`. Assert output = `[-1, 1..M, -2, 101..100+K]`.
- *
- * Catches: second-source leak into phase 0, pending-drop on COMPLETE,
- * out-of-order flush, or stuck-phase (never transitioning to phase=1).
- */
-const invariant38Concat: Invariant = {
-	name: "concat-phase-transition-a-completes-before-b",
-	description:
-		"concat(a, b) emits all of a's DATA in phase 0; on a COMPLETE, phase=1 flushes any buffered b DATA and continues forwarding b. Second-source DATAs never reach output before a COMPLETEs.",
-	specRef: "src/extra/operators.ts:concat — phase-transition contract",
-	property: () =>
-		fc.property(fc.integer({ min: 1, max: 4 }), fc.integer({ min: 1, max: 4 }), (M, K) => {
-			const aSrc = node<number>([], { equals: () => false, initial: -1 });
-			const bSrc = node<number>([], { equals: () => false, initial: -2 });
-			const c = concat(aSrc as Node<number>, bSrc as Node<number>);
-			const emitted: number[] = [];
-			const unsub = c.subscribe((msgs) => {
-				for (const m of msgs as readonly [symbol, unknown?][]) {
-					if (m[0] === DATA) emitted.push(m[1] as number);
-				}
-			});
-			if (emitted.length !== 1 || emitted[0] !== -1) {
-				unsub();
-				return false;
-			}
-			for (let i = 1; i <= M; i++) aSrc.emit(i);
-			if (emitted.length !== 1 + M) {
-				unsub();
-				return false;
-			}
-			for (let j = 1; j <= K; j++) bSrc.emit(100 + j);
-			if (emitted.length !== 1 + M) {
-				unsub();
-				return false;
-			}
-			aSrc.down([[COMPLETE]]);
-			unsub();
-			const expected: number[] = [-1];
-			for (let i = 1; i <= M; i++) expected.push(i);
-			expected.push(-2);
-			for (let j = 1; j <= K; j++) expected.push(100 + j);
-			if (emitted.length !== expected.length) return false;
-			for (let k = 0; k < expected.length; k++) {
-				if (emitted[k] !== expected[k]) return false;
-			}
-			return true;
-		}),
-};
-
-/**
- * #39 — take: `take(src, N)` forwards the first N source DATAs and then
- * emits exactly one COMPLETE; subsequent source DATAs never reach
- * output.
- *
- * Topology: `node<number>([], { equals: () => false , initial: 0 })` wrapped in
- * `take(s, N)`. Cached DATA(0) counts as the first take. Emit N-1
- * more values (total N); `take` emits all N DATAs `[0, 1, ..., N-1]`
- * then COMPLETEs. Emit `extras` more values into s; none reach
- * output, COMPLETE count stays at 1.
- *
- * Catches: off-by-one in count, missing COMPLETE on threshold, late
- * DATA leak after done, or multiple COMPLETEs.
- */
-const invariant39Take: Invariant = {
-	name: "take-terminates-after-n-datas",
-	description:
-		"take(src, N) forwards exactly the first N source DATAs then emits exactly one COMPLETE; subsequent source DATAs never reach output.",
-	specRef: "src/extra/operators.ts:take — termination contract",
-	property: () =>
-		fc.property(fc.integer({ min: 1, max: 5 }), fc.integer({ min: 1, max: 3 }), (N, extras) => {
-			const s = node<number>([], { equals: () => false, initial: 0 });
-			const t = take(s as Node<number>, N);
-			const emitted: number[] = [];
-			let completes = 0;
-			const unsub = t.subscribe((msgs) => {
-				for (const m of msgs as readonly [symbol, unknown?][]) {
-					if (m[0] === DATA) emitted.push(m[1] as number);
-					else if (m[0] === COMPLETE) completes += 1;
-				}
-			});
-			for (let i = 1; i < N; i++) s.emit(i);
-			if (emitted.length !== N) {
-				unsub();
-				return false;
-			}
-			if (completes !== 1) {
-				unsub();
-				return false;
-			}
-			for (let i = 0; i < N; i++) {
-				if (emitted[i] !== i) {
-					unsub();
-					return false;
-				}
-			}
-			for (let i = 0; i < extras; i++) s.emit(1000 + i);
-			// `completeWhenDepsComplete: false` means take emits its own COMPLETE
-			// on threshold; a subsequent source COMPLETE must not bubble through
-			// as a second downstream COMPLETE.
-			s.down([[COMPLETE]]);
-			unsub();
-			return emitted.length === N && completes === 1;
-		}),
-};
-
-/**
- * #40 — skip: `skip(src, N)` drops the first N source DATAs and forwards
- * the remainder; total downstream DATA count equals
- * `max(0, srcCount - N)`.
- *
- * Topology: `node<number>([], { equals: () => false , initial: 0 })` wrapped in
- * `skip(s, N)`. Cached DATA(0) is the first source DATA. Emit
- * `extras` additional values (total `1 + extras` source DATAs).
- * Assert downstream length is `max(0, 1 + extras - N)`, and the
- * values are exactly `[0, 1, ..., extras].slice(N)`.
- *
- * Catches: count mis-tracking, forwarding a skipped DATA, or dropping
- * a non-skipped DATA after the window closes.
- */
-const invariant40Skip: Invariant = {
-	name: "skip-drops-first-n-datas",
-	description:
-		"skip(src, N) drops the first N source DATAs and forwards the remainder; total downstream count equals max(0, srcCount - N).",
-	specRef: "src/extra/operators.ts:skip — position-gated forwarding contract",
-	property: () =>
-		fc.property(fc.integer({ min: 0, max: 3 }), fc.integer({ min: 1, max: 5 }), (N, extras) => {
-			const s = node<number>([], { equals: () => false, initial: 0 });
-			const sk = skip(s as Node<number>, N);
-			const emitted: number[] = [];
-			const unsub = sk.subscribe((msgs) => {
-				for (const m of msgs as readonly [symbol, unknown?][]) {
-					if (m[0] === DATA) emitted.push(m[1] as number);
-				}
-			});
-			for (let i = 1; i <= extras; i++) s.emit(i);
-			unsub();
-			const totalSrc = 1 + extras;
-			const expectedCount = Math.max(0, totalSrc - N);
-			if (emitted.length !== expectedCount) return false;
-			const allSrc: number[] = [0];
-			for (let i = 1; i <= extras; i++) allSrc.push(i);
-			const expected = allSrc.slice(N);
-			for (let k = 0; k < expected.length; k++) {
-				if (emitted[k] !== expected[k]) return false;
-			}
-			return true;
-		}),
-};
-
-/**
- * #41 — scan: `scan(src, reducer, seed)` emits `reducer(acc, value)` once
- * per source DATA; the accumulator chain is sequential and
- * positional.
- *
- * Topology: `node<number>([], { equals: () => false , initial: values[0] })` wrapped
- * in `scan(s, (acc, v) => acc + v, 0)` (sum reducer). Cached
- * DATA(values[0]) folds acc 0 → values[0]. Emit values[1..];
- * accumulator chain is monotonically increasing (all fc integers
- * ≥ 1 → strictly monotonic sums, no equals-absorption at scan's
- * output). Assert downstream matches the canonical prefix-sum.
- *
- * Catches: seed not applied, accumulator reset across waves, skipped
- * value in the fold, or reversed chain (folding newer before older).
- */
-const invariant41Scan: Invariant = {
-	name: "scan-folds-accumulator-per-data",
-	description:
-		"scan(src, reducer, seed) emits reducer(acc, value) once per source DATA; the accumulator chain is sequential and positional.",
-	specRef: "src/extra/operators.ts:scan — accumulator contract",
-	property: () =>
-		fc.property(
-			fc.array(fc.integer({ min: 1, max: 100 }), { minLength: 2, maxLength: 6 }),
-			(values) => {
-				const s = node<number>([], { equals: () => false, initial: values[0] });
-				const sc = scan(s as Node<number>, (acc: number, v: number) => acc + v, 0);
-				const emitted: number[] = [];
-				const unsub = sc.subscribe((msgs) => {
-					for (const m of msgs as readonly [symbol, unknown?][]) {
-						if (m[0] === DATA) emitted.push(m[1] as number);
-					}
-				});
-				for (let i = 1; i < values.length; i++) s.emit(values[i]);
-				unsub();
-				// scan's `initial: seed` pushes DATA(seed) on subscribe BEFORE the fn
-				// runs for the source's cached DATA — so the observed trace is
-				// `[seed, acc_1, acc_2, ...]` rather than just the prefix sums.
-				const expected: number[] = [0];
-				let acc = 0;
-				for (const v of values) {
-					acc += v;
-					expected.push(acc);
-				}
-				if (emitted.length !== expected.length) return false;
-				for (let k = 0; k < expected.length; k++) {
-					if (emitted[k] !== expected[k]) return false;
-				}
-				return true;
-			},
-		),
-};
-
-/**
- * #42 — reduce: `reduce(src, reducer, seed)` stays silent while source emits
- * DATA, accumulating into `store.acc`; on source COMPLETE, emits
- * exactly one DATA carrying the final accumulator value, then one
- * COMPLETE.
- *
- * Topology: `node<number>([], { equals: () => false , initial: values[0] })`
- * wrapped in `reduce(s, (acc, v) => acc + v, 0)`. Emit `values[1..]`
- * (all silent at reduce's output — store.acc accumulates, no DATA).
- * Then `s.down([[COMPLETE]])` — reduce fires the terminal branch:
- * exactly one DATA = `sum(values)`, exactly one COMPLETE.
- *
- * Catches: premature emit (firing during DATA), missing terminal
- * emit, wrong accumulator value, or COMPLETE before DATA in the
- * terminal wave.
- */
-const invariant42Reduce: Invariant = {
-	name: "reduce-emits-once-on-complete",
-	description:
-		"reduce(src, reducer, seed) stays silent during DATA and emits exactly one DATA (carrying the final accumulator) followed by one COMPLETE on source COMPLETE.",
-	specRef: "src/extra/operators.ts:reduce — single-emit-on-complete contract",
-	property: () =>
-		fc.property(
-			fc.array(fc.integer({ min: 1, max: 100 }), { minLength: 2, maxLength: 6 }),
-			(values) => {
-				const s = node<number>([], { equals: () => false, initial: values[0] });
-				const r = reduce(s as Node<number>, (acc: number, v: number) => acc + v, 0);
-				const emitted: number[] = [];
-				let completes = 0;
-				const unsub = r.subscribe((msgs) => {
-					for (const m of msgs as readonly [symbol, unknown?][]) {
-						if (m[0] === DATA) emitted.push(m[1] as number);
-						else if (m[0] === COMPLETE) completes += 1;
-					}
-				});
-				for (let i = 1; i < values.length; i++) s.emit(values[i]);
-				if (emitted.length !== 0 || completes !== 0) {
-					unsub();
-					return false;
-				}
-				s.down([[COMPLETE]]);
-				unsub();
-				const expectedSum = values.reduce((a, v) => a + v, 0);
-				return emitted.length === 1 && emitted[0] === expectedSum && completes === 1;
-			},
-		),
-};
-
-/**
- * #43 — merge: `merge(...sources)` forwards every DATA from every live
- * source; total downstream count equals the sum of per-source DATA
- * counts. Order is subscribe-interleaved per source but the emitted
- * set of values must exactly match the input union.
- *
- * Topology: N sources, each `node<number>([], { equals: () => false , initial: -1 - i })`
- * for i ∈ 0..N-1 (unique negative caches). `m = merge(...sources)`.
- * Subscribe delivers N cached DATAs `[-1, -2, ..., -N]` in
- * subscribe order. Then K rounds round-robin, each source emits
- * `i * 1000 + k` (globally unique). Assert:
- *   - total emitted count = N + N*K
- *   - emitted set equals the canonical union set
- *
- * Catches: inner-source drop, duplicate fan-out, subscribe order
- * miss (first source's cache skipped), premature COMPLETE on one-
- * source-complete (merge must wait for all).
- */
-const invariant43Merge: Invariant = {
-	name: "merge-forwards-data-from-all-sources",
-	description:
-		"merge(...sources) forwards every DATA from every live source; total downstream count equals the sum of per-source counts and the emitted set matches the union.",
-	specRef: "src/extra/operators.ts:merge — fan-in contract",
-	property: () =>
-		fc.property(fc.integer({ min: 2, max: 4 }), fc.integer({ min: 1, max: 3 }), (N, K) => {
-			const sources = Array.from({ length: N }, (_, i) =>
-				node<number>([], { equals: () => false, initial: -1 - i }),
-			);
-			const m = merge(...(sources as Node<number>[]));
-			const emitted: number[] = [];
-			let completes = 0;
-			const unsub = m.subscribe((msgs) => {
-				for (const mm of msgs as readonly [symbol, unknown?][]) {
-					if (mm[0] === DATA) emitted.push(mm[1] as number);
-					else if (mm[0] === COMPLETE) completes += 1;
-				}
-			});
-			for (let k = 1; k <= K; k++) {
-				for (let i = 0; i < N; i++) sources[i].emit(i * 1000 + k);
-			}
-			if (emitted.length !== N + N * K) {
-				unsub();
-				return false;
-			}
-			const expectedSet = new Set<number>();
-			for (let i = 0; i < N; i++) expectedSet.add(-1 - i);
-			for (let k = 1; k <= K; k++) {
-				for (let i = 0; i < N; i++) expectedSet.add(i * 1000 + k);
-			}
-			const emittedSet = new Set(emitted);
-			if (emittedSet.size !== expectedSet.size) {
-				unsub();
-				return false;
-			}
-			for (const v of expectedSet) {
-				if (!emittedSet.has(v)) {
-					unsub();
-					return false;
-				}
-			}
-			// Staged COMPLETE check: merge must NOT forward downstream COMPLETE until
-			// every inner source completes. Complete all but the last — downstream
-			// stays live. Then complete the last — exactly one COMPLETE emerges.
-			for (let i = 0; i < N - 1; i++) sources[i].down([[COMPLETE]]);
-			if (completes !== 0) {
-				unsub();
-				return false;
-			}
-			sources[N - 1].down([[COMPLETE]]);
-			unsub();
-			return completes === 1;
-		}),
-};
-
-/**
- * #44 — filter: `filter(src, predicate)` forwards exactly the source DATAs
- * that satisfy predicate, in order; non-matching DATAs emit
- * RESOLVED (not captured as DATA).
- *
- * Topology: `node<number>([], { equals: () => false , initial: values[0] })` +
- * `filter(s, v => v % 2 === 0, { equals: () => false })`. The outer
- * `equals: () => false` on filter disables its own Object.is dedupe
- * so consecutive identical matching values both pass through —
- * otherwise `values = [2, 2]` would collapse to one emit and
- * conflate operator semantics with protocol absorption. Emit
- * `values[1..]`; assert downstream equals `values.filter(even)`.
- *
- * Catches: predicate false-positive (forwarding a non-matching
- * value), predicate false-negative (dropping a matching value),
- * batch-iteration bug (only first element evaluated per wave), or
- * RESOLVED vs DATA conflation on non-matches.
- */
-const invariant44Filter: Invariant = {
-	name: "filter-forwards-only-matching-predicate",
-	description:
-		"filter(src, predicate) forwards exactly the source DATAs that satisfy predicate, in order; non-matching DATAs do not reach the output.",
-	specRef: "src/extra/operators.ts:filter — predicate-gated forwarding contract",
-	property: () =>
-		fc.property(
-			fc.array(fc.integer({ min: 0, max: 9 }), { minLength: 2, maxLength: 8 }),
-			(values) => {
-				const s = node<number>([], { equals: () => false, initial: values[0] });
-				const f = filter(s as Node<number>, (v) => v % 2 === 0, {
-					equals: () => false,
-				});
-				const emitted: number[] = [];
-				const unsub = f.subscribe((msgs) => {
-					for (const m of msgs as readonly [symbol, unknown?][]) {
-						if (m[0] === DATA) emitted.push(m[1] as number);
-					}
-				});
-				for (let i = 1; i < values.length; i++) s.emit(values[i]);
-				unsub();
-				const expected = values.filter((v) => v % 2 === 0);
-				if (emitted.length !== expected.length) return false;
-				for (let k = 0; k < expected.length; k++) {
-					if (emitted[k] !== expected[k]) return false;
-				}
-				return true;
-			},
-		),
-};
-
-/**
- * #45 — map: `map(src, project)` emits `project(v)` for every source
- * DATA v, in order. Count is preserved exactly; ordering is
- * preserved exactly.
- *
- * Topology: `node<number>([], { equals: () => false , initial: values[0] })`
- * wrapped in `map(s, v => v * 2 + 7, { equals: () => false })`.
- * The project fn `v * 2 + 7` is injective so consecutive
- * identical inputs would still produce distinct outputs only if
- * inputs differ; the `equals: () => false` on map itself lets
- * identical projected outputs pass when inputs repeat. Emit
- * `values[1..]`; assert downstream = `values.map(project)`.
- *
- * Catches: dropped emit (output < input count), duplicated emit,
- * batch-iteration bug (only first element projected per wave),
- * or project-fn not applied (raw value forwarded).
- */
-const invariant45Map: Invariant = {
-	name: "map-transforms-values-one-to-one",
-	description:
-		"map(src, project) emits project(v) for every source DATA v, in order; count and ordering are preserved.",
-	specRef: "src/extra/operators.ts:map — one-to-one transform contract",
-	property: () =>
-		fc.property(
-			fc.array(fc.integer({ min: 0, max: 50 }), { minLength: 2, maxLength: 8 }),
-			(values) => {
-				const s = node<number>([], { equals: () => false, initial: values[0] });
-				const project = (v: number) => v * 2 + 7;
-				const m = map(s as Node<number>, project, { equals: () => false });
-				const emitted: number[] = [];
-				const unsub = m.subscribe((msgs) => {
-					for (const mm of msgs as readonly [symbol, unknown?][]) {
-						if (mm[0] === DATA) emitted.push(mm[1] as number);
-					}
-				});
-				for (let i = 1; i < values.length; i++) s.emit(values[i]);
-				unsub();
-				const expected = values.map(project);
-				if (emitted.length !== expected.length) return false;
-				for (let k = 0; k < expected.length; k++) {
-					if (emitted[k] !== expected[k]) return false;
-				}
-				return true;
-			},
-		),
-};
-
-/**
- * #46 — combine: `combine(a, b)` emits `[latestA, latestB]` on every dep
- * settle; tuples track the freshest value per dep.
- *
- * Topology: `node<number>([], { equals: () => false , initial: 0 })` +
- * `node<number>([], { equals: () => false , initial: 100 })` wrapped in
- * `combine(a, b)`. combine is `node([a, b], (batchData, actions, ctx) => {
- 	const data = batchData.map((batch, i) => batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i]);
- 	actions.emit(data);
- }, { describeKind: "derived" })` with
- * a custom element-wise tuple-equals; it defaults `partial: false`
- * so activation produces exactly one initial tuple `[0, 100]`.
- *
- * Then alternate distinct emits: `a.emit(i*10)` → tuple becomes
- * `[i*10, bCache]`; `b.emit(1000+i)` → tuple becomes
- * `[aLatest, 1000+i]`. Each emit produces exactly one new tuple
- * DATA. Assert total count is `1 + 2*steps` and the final tuple
- * is the most recent pair.
- *
- * Catches: first-run gate missed (no initial tuple), stale-value
- * leak (tuple carries prior dep value on cross-dep emit), or
- * duplicate-emission.
- */
-const invariant46Combine: Invariant = {
-	name: "combine-emits-latest-tuple-on-any-dep-settle",
-	description:
-		"combine(a, b) emits [latestA, latestB] on every dep settle; tuples track the freshest value per dep and count = 1 + (a-emits + b-emits).",
-	specRef: "src/extra/operators.ts:combine — multi-dep snapshot contract",
-	property: () =>
-		fc.property(fc.integer({ min: 2, max: 4 }), (steps) => {
-			const a = node<number>([], { equals: () => false, initial: 0 });
-			const b = node<number>([], { equals: () => false, initial: 100 });
-			const c = combine(a, b) as Node<readonly [number, number]>;
-			const emitted: [number, number][] = [];
-			const unsub = c.subscribe((msgs) => {
-				for (const m of msgs as readonly [symbol, unknown?][]) {
-					if (m[0] === DATA) emitted.push(m[1] as [number, number]);
-				}
-			});
-			if (emitted.length !== 1 || emitted[0][0] !== 0 || emitted[0][1] !== 100) {
-				unsub();
-				return false;
-			}
-			let aValue = 0;
-			let bValue = 100;
-			for (let i = 1; i <= steps; i++) {
-				aValue = i * 10;
-				a.emit(aValue);
-				const latestA = emitted[emitted.length - 1];
-				if (latestA[0] !== aValue || latestA[1] !== bValue) {
-					unsub();
-					return false;
-				}
-				bValue = 1000 + i;
-				b.emit(bValue);
-				const latestB = emitted[emitted.length - 1];
-				if (latestB[0] !== aValue || latestB[1] !== bValue) {
-					unsub();
-					return false;
-				}
-			}
-			unsub();
-			return emitted.length === 1 + 2 * steps;
-		}),
-};
-
-/**
- * #47 — takeWhile: `takeWhile(src, predicate)` forwards matching DATAs;
- * on the first non-matching DATA, emits exactly one COMPLETE and
- * stops — no DATA forwarded for the non-match, predicate doesn't
- * re-evaluate later.
- *
- * Topology: `node<number>([], { equals: () => false , initial: 0 })` +
- * `takeWhile(s, v => v < 100)`. Cached DATA(0) passes predicate
- * (1st match). Emit `N - 1` more values 1..N-1 (all < 100), then
- * emit 500 (non-match). Expect: N matching DATAs, 1 COMPLETE, 0
- * extras. Emit `extras` more values (all > 100) — none reach
- * output, COMPLETE count stays 1.
- *
- * Catches: forwarding the non-matching value as DATA, missing
- * COMPLETE on first non-match, double-COMPLETE, late DATA leak
- * after done.
- */
-const invariant47TakeWhile: Invariant = {
-	name: "takewhile-terminates-on-first-non-matching",
-	description:
-		"takeWhile(src, predicate) forwards matching DATAs; on the first non-matching DATA, emits exactly one COMPLETE and stops. The non-match value never reaches output.",
-	specRef: "src/extra/operators.ts:takeWhile — predicate-termination contract",
-	property: () =>
-		fc.property(fc.integer({ min: 1, max: 5 }), fc.integer({ min: 1, max: 3 }), (N, extras) => {
-			const s = node<number>([], { equals: () => false, initial: 0 });
-			const tw = takeWhile(s as Node<number>, (v) => v < 100);
-			const emitted: number[] = [];
-			let completes = 0;
-			const unsub = tw.subscribe((msgs) => {
-				for (const m of msgs as readonly [symbol, unknown?][]) {
-					if (m[0] === DATA) emitted.push(m[1] as number);
-					else if (m[0] === COMPLETE) completes += 1;
-				}
-			});
-			for (let i = 1; i < N; i++) s.emit(i);
-			if (emitted.length !== N || completes !== 0) {
-				unsub();
-				return false;
-			}
-			s.emit(500);
-			if (emitted.length !== N || completes !== 1) {
-				unsub();
-				return false;
-			}
-			for (let i = 0; i < extras; i++) s.emit(200 + i);
-			// Post-terminal source COMPLETE must not bubble through as a second
-			// downstream COMPLETE (takeWhile uses `completeWhenDepsComplete: false`).
-			s.down([[COMPLETE]]);
-			unsub();
-			return emitted.length === N && completes === 1;
-		}),
-};
-
-/**
- * #48 — last: `last(src)` stays silent during DATA and on source COMPLETE
- * emits exactly one DATA (the final DATA value seen) followed by
- * one COMPLETE.
- *
- * Topology: `node<number>([], { equals: () => false , initial: values[0] })`
- * wrapped in `last(s)`. Emit `values[1..]` — all silent at last's
- * output (store.latest tracks). Then `s.down([[COMPLETE]])` fires
- * the terminal branch: one DATA = `values[values.length - 1]`,
- * one COMPLETE.
- *
- * Catches: premature emit during DATA, wrong value (not the last
- * seen), missing terminal emit, reversed order (COMPLETE before
- * DATA).
- */
-const invariant48Last: Invariant = {
-	name: "last-emits-latest-on-complete",
-	description:
-		"last(src) stays silent during DATA and on source COMPLETE emits exactly one DATA (the final DATA value seen) followed by one COMPLETE.",
-	specRef: "src/extra/operators.ts:last — latest-on-complete contract",
-	property: () =>
-		fc.property(
-			fc.array(fc.integer({ min: 1, max: 999 }), { minLength: 2, maxLength: 5 }),
-			(values) => {
-				const s = node<number>([], { equals: () => false, initial: values[0] });
-				const l = last(s as Node<number>);
-				const emitted: number[] = [];
-				let completes = 0;
-				const unsub = l.subscribe((msgs) => {
-					for (const m of msgs as readonly [symbol, unknown?][]) {
-						if (m[0] === DATA) emitted.push(m[1] as number);
-						else if (m[0] === COMPLETE) completes += 1;
-					}
-				});
-				for (let i = 1; i < values.length; i++) s.emit(values[i]);
-				if (emitted.length !== 0 || completes !== 0) {
-					unsub();
-					return false;
-				}
-				s.down([[COMPLETE]]);
-				unsub();
-				return emitted.length === 1 && emitted[0] === values[values.length - 1] && completes === 1;
-			},
-		),
-};
-
-/**
- * #49 — tap: `tap(src, fn)` forwards every DATA unchanged; the side-effect
- * fn is invoked exactly once per source DATA in order — independent
- * of whether tap's own output absorbs identical consecutive emits.
- *
- * **Arm 1 (identity contract):** `node<number>([], { equals: () => false , initial: values[0] })` +
- * `tap(s, v => sideEffects.push(v), { equals: () => false })`. The
- * `equals: () => false` on tap keeps consecutive identical values
- * passing through so emit count == side-effect count. Emit
- * `values[1..]`; assert both `emitted` and `sideEffects` equal
- * `values` exactly (same length, same order, same content).
- *
- * **Arm 2 (side-effect / emit decoupling):** source with
- * `equals: () => false`, tap WITHOUT the override, all emits are
- * identical so tap's Object.is absorbs everything after the first.
- * Assert: `sideEffects.length` equals the source-emit count
- * (fn fires per input) while `emittedCount` is exactly 1 (tap's
- * output absorbed the rest). Locks in the documented ordering:
- * `fnOrObserver(v)` is called BEFORE `a.emit(v)` per iteration.
- *
- * Catches: side-effect skip (fn not called for some DATAs),
- * double-invocation, value mutation on the forwarded DATA,
- * RESOLVED vs DATA conflation on the emit path, or a refactor
- * that moves the fn call after `a.emit` (post-absorption), which
- * would break the "once per source DATA" contract.
- */
-const invariant49Tap: Invariant = {
-	name: "tap-is-identity-with-side-effect",
-	description:
-		"tap(src, fn) forwards every DATA unchanged; the side-effect fn is invoked exactly once per source DATA, in order.",
-	specRef: "src/extra/operators.ts:tap — identity-passthrough contract",
-	property: () =>
-		fc.property(
-			fc.array(fc.integer({ min: 1, max: 100 }), { minLength: 2, maxLength: 6 }),
-			(values) => {
-				// Arm 1 — identity with no absorption: emit count, side-effect count,
-				// and value sequence all equal `values`.
-				{
-					const s = node<number>([], { equals: () => false, initial: values[0] });
-					const sideEffects: number[] = [];
-					const t = tap(
-						s as Node<number>,
-						(v: number) => {
-							sideEffects.push(v);
-						},
-						{ equals: () => false },
-					);
-					const emitted: number[] = [];
-					const unsub = t.subscribe((msgs) => {
-						for (const m of msgs as readonly [symbol, unknown?][]) {
-							if (m[0] === DATA) emitted.push(m[1] as number);
-						}
-					});
-					for (let i = 1; i < values.length; i++) s.emit(values[i]);
-					unsub();
-					if (emitted.length !== values.length || sideEffects.length !== values.length) {
-						return false;
-					}
-					for (let k = 0; k < values.length; k++) {
-						if (emitted[k] !== values[k]) return false;
-						if (sideEffects[k] !== values[k]) return false;
-					}
-				}
-				// Arm 2 — side-effect / emit decoupling: source drives `repeats`
-				// identical emits; tap's own cache absorbs all but the first. fn
-				// must still fire `repeats` times (documented "once per source
-				// DATA" contract, independent of downstream absorption).
-				{
-					const repeats = values.length;
-					const fixedValue = 42;
-					const s = node<number>([], { equals: () => false, initial: fixedValue });
-					const sideEffects: number[] = [];
-					const t = tap(s as Node<number>, (v: number) => {
-						sideEffects.push(v);
-					});
-					let emittedCount = 0;
-					const unsub = t.subscribe((msgs) => {
-						for (const m of msgs as readonly [symbol, unknown?][]) {
-							if (m[0] === DATA) emittedCount += 1;
-						}
-					});
-					for (let i = 1; i < repeats; i++) s.emit(fixedValue);
-					unsub();
-					if (sideEffects.length !== repeats) return false;
-					// Only the first DATA passes tap's Object.is; the rest absorb.
-					if (emittedCount !== 1) return false;
-				}
-				return true;
-			},
-		),
-};
-
-/**
- * #50 — takeUntil: `takeUntil(src, notifier)` forwards src DATAs until
- * notifier emits DATA; on notifier DATA, emits exactly one COMPLETE
- * and stops forwarding src.
- *
- * Topology: `node<number>([], { equals: () => false , initial: 0 })` (src) plus a
- * captured-trigger `producer<number>` notifier (doesn't emit until
- * we call `triggerNotifier()` — rules out accidental cached-DATA
- * termination during subscribe). Emit `M - 1` extra src values (M
- * total including the cached DATA(0)). `triggerNotifier()` → one
- * COMPLETE. Emit K more src values — none reach output, COMPLETE
- * count stays 1.
- *
- * Catches: notifier ignored, premature termination from unrelated
- * notifier messages, late src DATA leak after `stopped`, or
- * double-COMPLETE.
- */
-const invariant50TakeUntil: Invariant = {
-	name: "takeuntil-terminates-on-notifier-data",
-	description:
-		"takeUntil(src, notifier) forwards src DATAs until notifier emits DATA; on notifier DATA, emits exactly one COMPLETE and stops forwarding src.",
-	specRef: "src/extra/operators.ts:takeUntil — notifier-termination contract",
-	property: () =>
-		fc.property(fc.integer({ min: 1, max: 5 }), fc.integer({ min: 1, max: 3 }), (M, K) => {
-			let triggerNotifier: (() => void) | undefined;
-			const notifier = node<number>(
-				[],
-				(_data, a) => {
-					triggerNotifier = () => a.emit(1);
-					return {
-						onDeactivation: () => {
-							triggerNotifier = undefined;
-						},
-					};
-				},
-				{ describeKind: "producer" },
-			);
-			const s = node<number>([], { equals: () => false, initial: 0 });
-			const tu = takeUntil(s as Node<number>, notifier);
-			const emitted: number[] = [];
-			let completes = 0;
-			const unsub = tu.subscribe((msgs) => {
-				for (const m of msgs as readonly [symbol, unknown?][]) {
-					if (m[0] === DATA) emitted.push(m[1] as number);
-					else if (m[0] === COMPLETE) completes += 1;
-				}
-			});
-			for (let i = 1; i < M; i++) s.emit(i);
-			if (emitted.length !== M || completes !== 0) {
-				unsub();
-				return false;
-			}
-			triggerNotifier?.();
-			if (completes !== 1) {
-				unsub();
-				return false;
-			}
-			for (let i = 0; i < K; i++) s.emit(1000 + i);
-			unsub();
-			return emitted.length === M && completes === 1;
-		}),
-};
-
-/**
- * #51 — find: `find(src, predicate)` skips non-matching DATAs; on the
- * first matching DATA, emits exactly that value followed by one
- * COMPLETE. (`find = take(filter(src, predicate), 1)` — this
- * invariant is load-bearing for the composition: a broken `take`
- * or `filter` would surface here first on a concrete domain
- * semantic.)
- *
- * Topology: `node<number>([], { equals: () => false , initial: 0 })` wrapped in
- * `find(s, v => v > 100)`. Cached DATA(0) and emit `nonMatches` more
- * values `1..nonMatches` (all <= nonMatches, well under 100 →
- * non-matching). Assert no DATA emitted. `s.emit(500)` (match) → one
- * DATA = 500, one COMPLETE. Extras ignored.
- *
- * Catches: forwarding non-matching DATA, missing COMPLETE on match,
- * late DATA after match + complete.
- */
-const invariant51Find: Invariant = {
-	name: "find-emits-first-matching-and-completes",
-	description:
-		"find(src, predicate) skips non-matching DATAs; on the first matching DATA, emits that value followed by exactly one COMPLETE.",
-	specRef: "src/extra/operators.ts:find — first-match-and-terminate contract",
-	property: () =>
-		fc.property(
-			fc.integer({ min: 0, max: 4 }),
-			fc.integer({ min: 1, max: 3 }),
-			(nonMatches, extras) => {
-				const s = node<number>([], { equals: () => false, initial: 0 });
-				const f = find(s as Node<number>, (v) => v > 100);
-				const emitted: number[] = [];
-				let completes = 0;
-				const unsub = f.subscribe((msgs) => {
-					for (const m of msgs as readonly [symbol, unknown?][]) {
-						if (m[0] === DATA) emitted.push(m[1] as number);
-						else if (m[0] === COMPLETE) completes += 1;
-					}
-				});
-				for (let i = 1; i <= nonMatches; i++) s.emit(i);
-				if (emitted.length !== 0 || completes !== 0) {
-					unsub();
-					return false;
-				}
-				const matchValue = 500;
-				s.emit(matchValue);
-				if (emitted.length !== 1 || emitted[0] !== matchValue || completes !== 1) {
-					unsub();
-					return false;
-				}
-				for (let i = 0; i < extras; i++) s.emit(200 + i);
-				// Post-terminal source COMPLETE must not produce a second downstream
-				// COMPLETE — `find = take(filter(...), 1)` inherits take's
-				// `completeWhenDepsComplete: false`.
-				s.down([[COMPLETE]]);
-				unsub();
-				return emitted.length === 1 && completes === 1;
-			},
-		),
-};
-
-/**
- * #52 — elementAt: `elementAt(src, index)` drops the first `index` DATAs
- * and emits exactly the next DATA (the index-th in source order,
- * zero-based) followed by one COMPLETE. (`elementAt = take(skip(src,
- * index), 1)` — composition-verifying.)
- *
- * Topology: `node<number>([], { equals: () => false , initial: 0 })` wrapped in
- * `elementAt(s, index)` with `index ∈ 0..3`. Source emits
- * `[0, 1, ..., index]` in order (1 cached + `index` additional); the
- * index-th value (zero-based) is `index` itself. Assert
- * `emitted = [index]`, `completes = 1`. Extras ignored.
- *
- * Catches: off-by-one on position gating, early emit before
- * reaching index, or COMPLETE missing.
- */
-const invariant52ElementAt: Invariant = {
-	name: "elementat-emits-nth-and-completes",
-	description:
-		"elementAt(src, index) drops the first `index` DATAs and emits exactly the next DATA (the index-th in source order, zero-based) followed by one COMPLETE.",
-	specRef: "src/extra/operators.ts:elementAt — position-gated single-emit contract",
-	property: () =>
-		fc.property(fc.integer({ min: 0, max: 3 }), fc.integer({ min: 1, max: 3 }), (index, extras) => {
-			const s = node<number>([], { equals: () => false, initial: 0 });
-			const e = elementAt(s as Node<number>, index);
-			const emitted: number[] = [];
-			let completes = 0;
-			const unsub = e.subscribe((msgs) => {
-				for (const m of msgs as readonly [symbol, unknown?][]) {
-					if (m[0] === DATA) emitted.push(m[1] as number);
-					else if (m[0] === COMPLETE) completes += 1;
-				}
-			});
-			for (let i = 1; i <= index; i++) s.emit(i);
-			if (emitted.length !== 1 || emitted[0] !== index || completes !== 1) {
-				unsub();
-				return false;
-			}
-			for (let i = 0; i < extras; i++) s.emit(1000 + i);
-			// Post-terminal source COMPLETE must not bubble through
-			// (`elementAt = take(skip(...), 1)` inherits take's
-			// `completeWhenDepsComplete: false`).
-			s.down([[COMPLETE]]);
-			unsub();
-			return emitted.length === 1 && completes === 1;
-		}),
-};
-
-/**
- * #53 — windowCount: `windowCount(src, N)` emits one sub-node per N
- * source DATAs. Each sub-node carries exactly N DATAs and
- * COMPLETEs; downstream count of sub-nodes equals `M` where
- * `N * M` = total source DATAs.
- *
- * Topology: `node<number>([], { equals: () => false , initial: -1 })` wrapped in
- * `windowCount(s, N)`. Initial cached DATA(-1) opens the first
- * window (via lazy `openWindow` on first DATA). Emit `N*M - 1`
- * additional values so total source DATAs = N*M. Subscribe to each
- * emitted sub-node and collect its DATAs and COMPLETE. Assert:
- * - exactly M sub-nodes emitted,
- * - each sub-node has N DATAs and is completed,
- * - flattened sub-node sequence equals `[-1, 1, 2, ..., N*M - 1]`
- *   (source DATAs in order).
- *
- * Catches: sub-node fan-out off-by-one, window not closed on
- * threshold, values leaked between windows, or a sub-node
- * failing to COMPLETE.
- */
-const invariant53WindowCount: Invariant = {
-	name: "windowcount-sub-nodes-per-chunk",
-	description:
-		"windowCount(src, N) emits one sub-node per N source DATAs; each sub-node carries exactly N DATAs and COMPLETEs; the flattened sub-node sequence equals the source DATA sequence in order.",
-	specRef: "src/extra/operators.ts:windowCount — per-window sub-node emission contract",
-	property: () =>
-		fc.property(fc.integer({ min: 2, max: 4 }), fc.integer({ min: 2, max: 4 }), (N, M) => {
-			const s = node<number>([], { equals: () => false, initial: -1 });
-			const w = windowCount(s as Node<number>, N);
-			const windows: number[][] = [];
-			const windowCompleted: boolean[] = [];
-			const subUnsubs: (() => void)[] = [];
-			const unsub = w.subscribe((msgs) => {
-				for (const m of msgs as readonly [symbol, unknown?][]) {
-					if (m[0] === DATA) {
-						const sub = m[1] as Node<number>;
-						const idx = windows.length;
-						windows.push([]);
-						windowCompleted.push(false);
-						const u = sub.subscribe((sMsgs) => {
-							for (const sm of sMsgs as readonly [symbol, unknown?][]) {
-								if (sm[0] === DATA) windows[idx].push(sm[1] as number);
-								else if (sm[0] === COMPLETE) windowCompleted[idx] = true;
-							}
-						});
-						subUnsubs.push(u);
-					}
-				}
-			});
-			for (let i = 1; i < N * M; i++) s.emit(i);
-			unsub();
-			for (const u of subUnsubs) u();
-			if (windows.length !== M) return false;
-			for (let m = 0; m < M; m++) {
-				if (windows[m].length !== N) return false;
-				if (!windowCompleted[m]) return false;
-			}
-			const allValues: number[] = [-1];
-			for (let i = 1; i < N * M; i++) allValues.push(i);
-			let idx = 0;
-			for (let m = 0; m < M; m++) {
-				for (let k = 0; k < N; k++) {
-					if (windows[m][k] !== allValues[idx++]) return false;
-				}
-			}
-			return true;
-		}),
-};
-
-// ---------------------------------------------------------------------------
-// Rigor ghost-state mirrors — fast-check counterparts to TLC invariants that
-// reference TLA+ ghost state (`cleanupWitness`, `terminatedBy`,
-// `nonVacuousInvalidateCount`, `batchActive`) with no first-class runtime
-// representation. The substrate exposes a `RigorRecorder` slot on
-// `GraphReFlyConfig`; tests attach a recorder, drive the graph, then assert
-// against the accumulated log.
-//
-// Triage notes (2026-04-24): TLC #18 `MultiSinkIterationCoherent` and TLC #27
-// `MultiSinkIterationDriftClean` are NOT mirrored here — their TLA+ ghost
-// (`pendingExtraDelivery`) has no runtime analogue. The runtime's
-// `_deliverToSinks` iterates sinks synchronously over a single shared
-// `messages` reference, so mid-iteration drift is not a representable state.
-// TLC #20 / #22 / #23 are also skipped pending runtime features (§2.3 meta
-// TEARDOWN). §2.5 `replayBuffer` shipped in Phase 13.6.B B6 (Lock 6.G); the
-// TLC #20 / #23 mirrors are tracked separately in `docs/optimizations.md`.
-// ---------------------------------------------------------------------------
-
-interface CleanupWitnessEntry {
-	node: NodeCtx;
-	prevValue: unknown;
-}
-interface TerminalTransitionEntry {
-	node: NodeCtx;
-	kind: "completed" | "errored";
-	autoComplete: boolean;
-	autoError: boolean;
-	hasDeps: boolean;
-}
-interface RigorLog {
-	readonly recorder: RigorRecorder;
-	readonly witnesses: CleanupWitnessEntry[];
-	readonly terminals: TerminalTransitionEntry[];
-}
-
-/**
- * Build a fresh isolated `GraphReFlyConfig` with the default handlers + a
- * `RigorRecorder` attached. Returns the config plus the accumulated log. Each
- * property run constructs its own config so runs can't leak state between
- * them.
- */
-function createRigorLoggedConfig(): { config: GraphReFlyConfig; log: RigorLog } {
-	const cfg = new GraphReFlyConfig({
-		onMessage: defaultConfig.onMessage,
-		onSubscribe: defaultConfig.onSubscribe,
-	});
-	registerBuiltins(cfg);
-	const witnesses: CleanupWitnessEntry[] = [];
-	const terminals: TerminalTransitionEntry[] = [];
-	const recorder: RigorRecorder = {
-		onNonVacuousInvalidate(n, prev) {
-			witnesses.push({ node: n, prevValue: prev });
-		},
-		onTerminalTransition(n, kind, autoComplete, autoError, hasDeps) {
-			terminals.push({ node: n, kind, autoComplete, autoError, hasDeps });
-		},
-	};
-	cfg.rigorRecorder = recorder;
-	return { config: cfg, log: { recorder, witnesses, terminals } };
-}
-
-/**
- * #54 — cleanup-witness-in-value-domain (mirrors TLC #19
- * `CleanupWitnessInValueDomain`). Every recorded cleanup witness carries a
- * `prevValue` drawn from the value domain — specifically, not the
- * `undefined` sentinel. The runtime's `_onDepMessage` INVALIDATE branch
- * guards the hook with `if (this._cached === undefined) return`, so a
- * vacuous invalidate (never-populated or already-reset cache) never fires
- * the witness append.
- *
- * Topology: `node<number>([], { initial: 0 })` fed into a `derived` that observes DATA; the
- * derived is the node we invalidate. Seed it with a DATA so `_cached` is
- * populated, then invalidate N times (`derived.down([[INVALIDATE]])`).
- * Only the first invalidate finds `_cached !== undefined` — that's the
- * non-vacuous witness. Subsequent invalidates on the already-reset cache
- * are vacuous and must not fire.
- *
- * Assert: witnesses for the derived node have `prevValue !== undefined` and
- * the witnesses captured equal the number of distinct value-to-undefined
- * transitions driven by the test (here, 1 per DATA→invalidate cycle).
- *
- * Catches: regressions that drop the `_cached === undefined` vacuous-guard,
- * or fire the hook on TEARDOWN / status reset paths.
- */
-const invariant54CleanupWitnessInValueDomain: Invariant = {
-	name: "cleanup-witness-in-value-domain",
-	description:
-		"Every non-vacuous INVALIDATE records a cleanup witness with a prev value drawn from the value domain (never the `undefined` sentinel).",
-	specRef:
-		"wave_protocol.tla #19 CleanupWitnessInValueDomain (via src/core/node.ts:_updateState INVALIDATE branch)",
-	property: () =>
-		fc.property(fc.array(fc.integer(), { minLength: 1, maxLength: 5 }), (values) => {
-			const { config, log } = createRigorLoggedConfig();
-			const s = node<number>([], { config, equals: () => false, initial: values[0] ?? 0 });
-			const d = node<number>(
-				[s],
-				(batchData, actions, ctx) => {
-					const data = batchData.map((batch, i) =>
-						batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-					);
-					actions.emit((data[0] as number) * 2);
-				},
-				{ describeKind: "derived", config },
-			);
-			const unsub = d.subscribe(() => {});
-			// Each cycle: emit a fresh DATA (populates d._cached via derived's
-			// auto-emit of fn return), then invalidate (fires the witness
-			// hook on the first arrival) — then a second invalidate which
-			// is vacuous (cache already reset) and MUST NOT fire the hook.
-			let expected = 0;
-			for (const v of values) {
-				s.emit(v);
-				d.down([[INVALIDATE]]);
-				expected++;
-				d.down([[INVALIDATE]]);
-			}
-			unsub();
-			// Non-vacuous guard: the total witness log length must be at least
-			// the expected count so a future Node-facade refactor that makes
-			// `w.node === d` silently return empty fails loud instead of
-			// passing vacuously. (QA batch 20 guard.)
-			if (log.witnesses.length < expected) return false;
-			const onD = log.witnesses.filter((w) => w.node === d);
-			if (onD.length !== expected) return false;
-			for (const w of onD) {
-				if (w.prevValue === undefined) return false;
-			}
-			return true;
-		}),
-};
-
-/**
- * #55 — cleanup-witness-not-sentinel (mirrors TLC #24
- * `CleanupWitnessNotSentinel`). Structural companion to #54: no witness
- * entry — for ANY node, under any topology — equals the `undefined`
- * sentinel. Whereas #54 drives a specific topology and asserts a count,
- * #55 runs an event-driven graph and sweeps the whole witness log.
- *
- * Topology: `node<number>([], { initial: 0 })` → passthrough `derived` → leaf `effect`
- * sink. Drive the source with `eventSequenceArb` (random emit / batch /
- * resolved / terminal); opportunistically fire `INVALIDATE` on any node in
- * the chain. Sweep: every witness entry must have a non-undefined
- * `prevValue`.
- *
- * Catches: a regression that reorders `this._cached = undefined` before the
- * witness hook (so the hook sees the already-cleared sentinel), or that
- * fires the witness hook on a TEARDOWN reset path where `_cached` is
- * legitimately `undefined`.
- */
-const invariant55CleanupWitnessNotSentinel: Invariant = {
-	name: "cleanup-witness-not-sentinel",
-	description:
-		"No cleanup witness entry equals the `undefined` sentinel — the witness hook only fires when _cached is a real value.",
-	specRef:
-		"wave_protocol.tla #24 CleanupWitnessNotSentinel (via src/core/node.ts:_onDepMessage INVALIDATE guard)",
-	property: () =>
-		fc.property(
-			fc.array(fc.integer({ min: 0, max: 10 }), { minLength: 1, maxLength: 4 }),
-			(emits) => {
-				const { config, log } = createRigorLoggedConfig();
-				const s = node<number>([], { config, equals: () => false, initial: 0 });
-				const d = node<number>(
-					[s],
-					(batchData, actions, ctx) => {
-						const data = batchData.map((batch, i) =>
-							batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-						);
-						actions.emit((data[0] as number) + 1);
-					},
-					{ describeKind: "derived", config },
-				);
-				const unsub = d.subscribe(() => {});
-				// Interleave emits with invalidates at both nodes. First
-				// invalidate on a populated cache = non-vacuous; second =
-				// vacuous (cache cleared). Both paths must respect the guard.
-				for (const v of emits) {
-					s.emit(v);
-					d.down([[INVALIDATE]]);
-					s.down([[INVALIDATE]]);
-					d.down([[INVALIDATE]]);
-				}
-				unsub();
-				// Non-vacuous guard: each emit cycle's first `d.down([[INVALIDATE]])`
-				// runs on a populated `d._cached` (seeded by `s.emit(v)` propagating
-				// through the derived fn), so at least `emits.length` witnesses
-				// MUST be captured. A substrate regression that stops populating
-				// `d._cached` (or a future Node-facade wrap that breaks the log)
-				// would trip this before the sentinel sweep runs vacuously.
-				if (log.witnesses.length < emits.length) return false;
-				for (const w of log.witnesses) {
-					if (w.prevValue === undefined) return false;
-				}
-				return true;
-			},
-		),
-};
-
-/**
- * #56 — cleanup-witness-accounting (mirrors TLC #26
- * `CleanupWitnessAccounting`). Quantitative law tying the witness log
- * length to the count of non-vacuous INVALIDATE deliveries. The runtime
- * guard `if (this._cached === undefined) return` enforces this
- * structurally: the hook cannot fire without a cache advance and the
- * cache cannot be cleared without firing. So the invariant reduces to
- * ≥1 non-vacuous invalidate produced ≥1 witness entry and the count per
- * node equals the number of populated→cleared transitions driven.
- *
- * Topology: `node<number>([], { initial: 0 })` fed to `derived`. Controlled cycles of
- * (emit → invalidate) on the derived node; a counter tracks the exact
- * number of non-vacuous invalidates we drove. Assert
- * `witnesses-for-derived.length === counter`.
- *
- * Catches: off-by-N regressions between the witness guard and the cache
- * reset (e.g. a refactor that moves the cache reset above the hook so
- * every hook sees `undefined`, or vice-versa — hook fires but cache
- * never clears).
- */
-const invariant56CleanupWitnessAccounting: Invariant = {
-	name: "cleanup-witness-accounting",
-	description:
-		"The witness log length for a node equals the count of non-vacuous INVALIDATE deliveries to that node (cache populated → cache cleared transitions).",
-	specRef:
-		"wave_protocol.tla #26 CleanupWitnessAccounting (via src/core/node.ts:_onDepMessage INVALIDATE guard)",
-	property: () =>
-		fc.property(fc.integer({ min: 1, max: 6 }), fc.integer({ min: 1, max: 3 }), (N, extras) => {
-			const { config, log } = createRigorLoggedConfig();
-			const s = node<number>([], { config, equals: () => false, initial: 0 });
-			const d = node<number>(
-				[s],
-				(batchData, actions, ctx) => {
-					const data = batchData.map((batch, i) =>
-						batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-					);
-					actions.emit((data[0] as number) + 1);
-				},
-				{ describeKind: "derived", config },
-			);
-			const unsub = d.subscribe(() => {});
-			let nonVacuous = 0;
-			for (let i = 0; i < N; i++) {
-				s.emit(i + 1); // populates d._cached via derived's auto-emit
-				d.down([[INVALIDATE]]); // non-vacuous — hook fires
-				nonVacuous++;
-				for (let k = 0; k < extras; k++) {
-					// vacuous: cache already cleared
-					d.down([[INVALIDATE]]);
-				}
-			}
-			unsub();
-			// Non-vacuous guard: the full witness log must have at least
-			// `nonVacuous` entries so a vacuous-pass path (e.g. a future
-			// Node-facade refactor breaking `w.node === d`) can't silently
-			// satisfy the exact-count equality below.
-			if (log.witnesses.length < nonVacuous) return false;
-			const onD = log.witnesses.filter((w) => w.node === d);
-			return onD.length === nonVacuous;
-		}),
-};
-
-/**
- * #57 — no-dep-cascade-terminal-when-gate-false (mirrors TLC #25
- * `NoDepCascadeTerminalWhenGateFalse`). A derived node configured with
- * `completeWhenDepsComplete: false` must NOT transition to `"completed"`
- * when all of its deps terminate via COMPLETE. Symmetrically,
- * `errorWhenDepsError: false` must suppress the dep-cascade ERROR path.
- * The runtime gate lives in `_maybeAutoTerminalAfterWave` — if the gate
- * is flipped to always-emit, this invariant trips.
- *
- * Topology: two `state<number>` sources feeding a `derived` with
- * `completeWhenDepsComplete: false`. Emit a DATA to each, then drive
- * COMPLETE at each source. The gate-off derived must not terminate.
- * Sweep terminals: any `kind === "completed" && hasDeps === true &&
- * autoComplete === false` is a failure.
- *
- * Catches: a refactor that drops the `_autoComplete` check inside
- * `_maybeAutoTerminalAfterWave`, or that auto-terminates a gated node via
- * a different code path (e.g. a mis-wired `_maybeAutoTerminalAfterWave`
- * call from a terminal-delivery site).
- */
-const invariant57NoDepCascadeTerminalWhenGateFalse: Invariant = {
-	name: "no-dep-cascade-terminal-when-gate-false",
-	description:
-		"A derived with `completeWhenDepsComplete: false` / `errorWhenDepsError: false` never transitions to `completed` / `errored` via dep cascade — no such entry appears in the terminal log.",
-	specRef:
-		"wave_protocol.tla #25 NoDepCascadeTerminalWhenGateFalse (via src/core/node.ts:_maybeAutoTerminalAfterWave)",
-	property: () =>
-		fc.property(fc.boolean(), fc.boolean(), (useError, drainExtra) => {
-			const { config, log } = createRigorLoggedConfig();
-			const a = node<number>([], { config, equals: () => false, initial: 0 });
-			const b = node<number>([], { config, equals: () => false, initial: 0 });
-			const d = node<number>(
-				[a, b],
-				(batchData, actions, ctx) => {
-					const data = batchData.map((batch, i) =>
-						batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-					);
-					actions.emit((data[0] as number) + (data[1] as number));
-				},
-				{
-					describeKind: "derived",
-					config,
-					completeWhenDepsComplete: false,
-					errorWhenDepsError: false,
-				},
-			);
-			const unsub = d.subscribe(() => {});
-			a.emit(1);
-			b.emit(2);
-			if (useError) {
-				a.down([[ERROR, new Error("test")]]);
-				b.down([[ERROR, new Error("test")]]);
-			} else {
-				a.down([[COMPLETE]]);
-				b.down([[COMPLETE]]);
-			}
-			if (drainExtra) {
-				// drain any post-terminal wave that a regression might enqueue
-				a.down([[COMPLETE]]);
-				b.down([[COMPLETE]]);
-			}
-			unsub();
-			// Non-vacuous guard: the test's premise is that `a` and `b`
-			// actually terminated — if neither source transitioned (e.g. a
-			// future runtime change that stops propagating direct ERROR /
-			// COMPLETE through sources), the "d didn't dep-cascade" check
-			// below trivially holds without exercising the gate. Sources
-			// have no deps, so their terminal transitions fire with
-			// `hasDeps === false`.
-			const expectedKind = useError ? "errored" : "completed";
-			const sourceTerminals = log.terminals.filter(
-				(t) => (t.node === a || t.node === b) && t.kind === expectedKind && !t.hasDeps,
-			);
-			if (sourceTerminals.length < 2) return false;
-			for (const t of log.terminals) {
-				if (t.node !== d) continue;
-				// A terminal transition on d with hasDeps=true and the matching
-				// gate flag false must never fire — that's dep-cascade behavior.
-				if (t.kind === "completed" && t.autoComplete === false && t.hasDeps) return false;
-				if (t.kind === "errored" && t.autoError === false && t.hasDeps) return false;
-			}
-			return true;
-		}),
-};
-
-// ---------------------------------------------------------------------------
-// Graph narrow-waist (P1–P7) — composition contract for graph.derived /
-// graph.effect / graph.producer / graph.batch. Source: `archive/docs/SESSION-
-// graph-narrow-waist.md` § "TLA+ / Fast-Check Coverage Plan".
-//
-// These properties exercise the **path-based** API at small generated
-// topologies. Each property uses a fresh `Graph` per run so state cannot leak
-// between runs. The underlying primitive contracts (first-run gate, equals,
-// terminal cascade, etc.) are exercised by invariants 1–57 — these mirror
-// only the Graph-layer absorption surface.
-// ---------------------------------------------------------------------------
-
-/**
- * #58 — graph-derived-sentinel-absorption (Plan P1).
- *
- * `graph.derived` resolves dep paths to Node refs and inherits the underlying
- * `derived()` first-run gate (spec §2.7, partial: false). fn must NOT fire
- * while ANY dep is in `sentinel` status. Once every dep has delivered at
- * least one real DATA, the gate releases on the next settle.
- *
- * Topology: K ∈ [1, 4] sentinel `node<number>([])` deps + one `graph.derived`
- * summing them. Drive: settle K-1 deps and assert fn stays at 0; settle the
- * last dep and assert fn fires exactly once.
- *
- * Catches: regressions where graph.derived loses the underlying first-run
- * gate (e.g. accidentally setting `partial: true` while resolving paths), or
- * where path resolution returns a populated stand-in instead of a SENTINEL
- * source.
- */
-const invariant58GraphDerivedSentinelAbsorption: Invariant = {
-	name: "graph-derived-sentinel-absorption",
-	description:
-		"graph.derived's fn does not fire while any dep path resolves to a SENTINEL node — fires only after the last dep delivers real DATA.",
-	specRef: "archive/docs/SESSION-graph-narrow-waist.md § P1 (via spec §2.7 partial: false default)",
-	property: () =>
-		fc.property(
-			fc.integer({ min: 1, max: 4 }),
-			fc.array(fc.integer({ min: 0, max: 10 }), { minLength: 4, maxLength: 8 }),
-			(k, values) => {
-				const g = new Graph("prop-p1");
-				try {
-					for (let i = 0; i < k; i++) {
-						g.add(node<number>([], { name: `a${i}`, initial: undefined }), { name: `a${i}` });
-					}
-					let fnCalls = 0;
-					const out = g.derived(
-						"sum",
-						Array.from({ length: k }, (_, i) => `a${i}`),
-						(data, ctx) => {
-							fnCalls += 1;
-							return [(latestVals(data, ctx) as number[]).reduce((s, v) => s + v, 0)];
-						},
-					);
-					out.subscribe(() => {});
-					if (fnCalls !== 0) return false;
-					// Settle k-1 deps; gate must stay closed.
-					for (let i = 0; i < k - 1; i++) {
-						g.set(`a${i}`, values[i]);
-						if (fnCalls !== 0) return false;
-					}
-					// Settle the last dep; gate releases — exactly one fn invocation.
-					g.set(`a${k - 1}`, values[k - 1]);
-					return fnCalls === 1;
-				} finally {
-					g.destroy();
-				}
-			},
-		),
-};
-
-/**
- * #59 — graph-derived-keepalive-cache-current (Plan P2).
- *
- * A `graph.derived(name, deps, fn, { keepAlive: true })` node's `.cache` must
- * reflect `fn(latest deps)` after every emission, EVEN WITH NO EXTERNAL
- * SUBSCRIBER. The keepAlive sink owns the activation; without it, the
- * derived's RAM cache stays at `undefined` (spec §2.2). This pins the
- * keepAlive primitive contract independent of the §28 closure-mirror
- * pattern (the §28 pattern stays canonical for sample-passively-on-trigger
- * cases — see `archive/docs/SESSION-graph-narrow-waist.md` § "Status of
- * existing modifications" for the post-§28-reading reframing).
- *
- * Topology: `node([], { initial: 0 }) → graph.derived("doubled", ["a"], v => v*2, { keepAlive })`
- * with no external subscriber. Drive: random sequence of `state.emit(v)` and
- * `batch(...)` events on the source. Assert: after every event, `out.cache`
- * equals `2 * a.cache` (or `undefined` only while a is sentinel — but the
- * source `node([], { initial: 0 })` is seeded so a is never sentinel here).
- *
- * Catches: a regression where the keepAlive sink fails to keep the derived
- * activated across emission boundaries (e.g. self-pruning fires too eagerly),
- * or where `derived`'s cache update lags the keepAlive sink's read.
- */
-const invariant59GraphDerivedKeepAliveCacheCurrent: Invariant = {
-	name: "graph-derived-keepalive-cache-current",
-	description:
-		"A graph.derived(..., { keepAlive: true }) node's `.cache` reflects fn(latest deps) after every emission, even with no external subscriber.",
-	specRef: "archive/docs/SESSION-graph-narrow-waist.md § P2",
-	property: () =>
-		fc.property(eventSequenceArb({ valueRange: [0, 50] }), (events) => {
-			const g = new Graph("prop-p2");
-			try {
-				const a = node([], { name: "a", initial: 0 });
-				g.add(a, { name: "a" });
-				const out = g.derived(
-					"doubled",
-					["a"],
-					(data, ctx) => {
-						const [x] = latestVals(data, ctx);
-						return [(x as number) * 2];
-					},
-					{
-						keepAlive: true,
-					},
-				);
-				// No external subscribe — keepAlive must keep cache current on its own.
-				if (out.cache !== 0) return false; // initial fn(0) = 0
-				const completed = { value: false };
-				for (const ev of events) {
-					if (completed.value) break;
-					applyEvent(a, ev, completed);
-					if (completed.value) break;
-					const aCache = a.cache as number | undefined;
-					if (aCache === undefined) return false; // a was seeded, must never go sentinel
-					if (out.cache !== aCache * 2) return false;
-				}
-				return true;
-			} finally {
-				g.destroy();
-			}
-		}),
-};
-
-/**
- * #60 — graph-disposal-completeness (Plan P3).
- *
- * After `graph.destroy()`, every subscription created by `graph.derived` /
- * `graph.effect` / `graph.producer` (including keepAlive subscriptions) must
- * be torn down. Concretely: emissions on a SOURCE NODE that is held outside
- * the graph and was registered (so the graph subscribed to it) must NOT
- * reach any of the graph's fns after destroy.
- *
- * Topology: external `node([], { initial: 0 })` registered via `g.add` as "a"; N
- * `graph.derived(..., { keepAlive: true })` nodes over "a". Drive: emit once,
- * record `fnCallCount`, destroy graph, emit again. Assert post-destroy
- * `fnCallCount` is unchanged.
- *
- * Catches: regressions where the keepAlive disposer is forgotten on
- * destroy, or where a future option flag (e.g. `keepAlive: "weak"`) leaks a
- * subscription past destroy.
- */
-const invariant60GraphDisposalCompleteness: Invariant = {
-	name: "graph-disposal-completeness",
-	description:
-		"After graph.destroy(), upstream emissions on retained source nodes do not reach any fn registered via graph.derived/effect/produce.",
-	specRef: "archive/docs/SESSION-graph-narrow-waist.md § P3",
-	property: () =>
-		fc.property(
-			fc.integer({ min: 1, max: 4 }),
-			fc.integer({ min: 1, max: 5 }),
-			(numDerived, postDestroyEmits) => {
-				const a = node([], { name: "a", initial: 0 });
-				const g = new Graph("prop-p3");
-				let fnCallCount = 0;
-				try {
-					g.add(a, { name: "a" });
-					for (let i = 0; i < numDerived; i++) {
-						g.derived(
-							`d${i}`,
-							["a"],
-							(data, ctx) => {
-								const [x] = latestVals(data, ctx);
-								fnCallCount += 1;
-								return [(x as number) + i];
-							},
-							{ keepAlive: true },
-						);
-					}
-					// Drive at least one fn invocation so the property is non-vacuous.
-					a.emit(1);
-					if (fnCallCount === 0) return false;
-				} finally {
-					g.destroy();
-				}
-				const beforeDestroyCalls = fnCallCount;
-				// Post-destroy: emissions on the retained source must not reach
-				// any of the graph's fns. Positive assertion guards the
-				// vacuous-pass case where a future change makes `state.emit`
-				// silently no-op on a borrowed-but-destroyed source — verify
-				// `a.cache` actually advances on each emit so we know the
-				// emit had real effect. (If a future change DOES tear down
-				// borrowed sources on graph.destroy, this guard surfaces it
-				// instead of letting the gate-check pass trivially.)
-				for (let i = 0; i < postDestroyEmits; i++) {
-					const expected = 2 + i;
-					a.emit(expected);
-					if (a.cache !== expected) return false;
-				}
-				return fnCallCount === beforeDestroyCalls;
-			},
-		),
-};
-
-/**
- * #61 — graph-batch-atomicity (Plan P4).
- *
- * Inside `graph.batch(fn)`, all `graph.set(name, v)` calls produce exactly
- * ONE coalesced downstream wave per affected node — not one per `set`. This
- * is the same semantics as core `batch()` (spec §1.3 invariant 7); the
- * property pins it at the Graph-method boundary so a future graph-scoped
- * batch implementation can't regress the contract.
- *
- * Topology: `node([], { initial: 0 }) → graph.derived("x2", ["a"], v => v*2)`. Subscribe.
- * Drive: random sequence of values, all written to "a" inside ONE
- * `graph.batch(...)`. Assert: downstream sees exactly one DATA settlement,
- * with the final batched value (or no DATA if the final value equals the
- * pre-batch cache, in which case there is exactly one RESOLVED).
- *
- * Catches: a regression where `graph.batch` accidentally maps to a no-op or
- * to per-call delivery (e.g. a future graph-scoped frame implementation
- * forgetting to defer DATA).
- */
-const invariant61GraphBatchAtomicity: Invariant = {
-	name: "graph-batch-atomicity",
-	description:
-		"Inside graph.batch(fn), N graph.set() calls on the same path produce exactly one coalesced settlement (DATA or RESOLVED) downstream.",
-	specRef: "archive/docs/SESSION-graph-narrow-waist.md § P4 (via spec §1.3 invariant 7)",
-	property: () =>
-		fc.property(
-			fc.array(fc.integer({ min: 0, max: 20 }), { minLength: 1, maxLength: 6 }),
-			(vals) => {
-				const g = new Graph("prop-p4");
-				try {
-					g.add(node([], { name: "a", initial: 0 }), { name: "a" });
-					const out = g.derived("x2", ["a"], (data, ctx) => {
-						const [x] = latestVals(data, ctx);
-						return [(x as number) * 2];
-					});
-					let postBatchSettlements = 0;
-					out.subscribe((msgs) => {
-						for (const m of msgs) {
-							if (m[0] === DATA || m[0] === RESOLVED) postBatchSettlements += 1;
-						}
-					});
-					// Subscription handshake delivered up to one initial DATA. Reset
-					// the counter to measure only post-batch settlements.
-					postBatchSettlements = 0;
-					g.batch(() => {
-						for (const v of vals) g.set("a", v);
-					});
-					// Exactly one settlement (DATA when final value differs, RESOLVED
-					// when it matches the pre-batch cache).
-					return postBatchSettlements === 1;
-				} finally {
-					g.destroy();
-				}
-			},
-		),
-};
-
-/**
- * #62 — graph-derived-path-resolution-construction (Plan P5, RESTATED).
- *
- * `graph.derived(name, paths, fn)` resolves every path via `graph.resolve`
- * AT CONSTRUCTION TIME. Paths must address Nodes that exist on the current
- * topology; emissions on those resolved Nodes during their lifetime drive
- * fn. Cross-mount paths via `::` are supported.
- *
- * **Restated from session-doc P5:** the original P5 ("if mount removed, the
- * derived errors rather than silently reading stale refs") is deferred —
- * post-construction mount removal is undefined behavior tracked under
- * `project_rewire_gap` / optimizations.md C4. This property only asserts
- * the **construction-time + lifetime** contract: paths resolve to the
- * expected Nodes, and emissions during the mount's lifetime reach the
- * derived's fn.
- *
- * Topology: parent graph with one mounted child holding K ∈ [1, 3] state
- * nodes; `graph.derived` over `mount::aN` paths. Drive: emit values into
- * each child state; assert the derived's fn fires with the corresponding
- * values delivered through the resolved deps.
- *
- * Catches: regressions where path resolution silently swallows `::`
- * segments or returns a wrong Node ref.
- */
-const invariant62GraphDerivedPathResolutionConstruction: Invariant = {
-	name: "graph-derived-path-resolution-construction",
-	description:
-		"graph.derived resolves `::`-qualified paths at construction time and routes upstream emissions through the resolved deps to fn during the mount's lifetime.",
-	specRef:
-		"archive/docs/SESSION-graph-narrow-waist.md § P5 (RESTATED — post-mount-removal behavior tracked under optimizations.md C4 rewire gap)",
-	property: () =>
-		fc.property(
-			fc.integer({ min: 1, max: 3 }),
-			fc.array(fc.integer({ min: 0, max: 30 }), { minLength: 3, maxLength: 6 }),
-			(k, values) => {
-				const parent = new Graph("prop-p5-parent");
-				try {
-					const child = new Graph("child");
-					for (let i = 0; i < k; i++) {
-						child.add(node([], { name: `a${i}`, initial: 0 }), { name: `a${i}` });
-					}
-					parent.mount("m", child);
-					let lastSeen: number | undefined;
-					const out = parent.derived(
-						"sum",
-						Array.from({ length: k }, (_, i) => `m::a${i}`),
-						(data, ctx) => {
-							const sum = (latestVals(data, ctx) as number[]).reduce((s, v) => s + v, 0);
-							lastSeen = sum;
-							return [sum];
-						},
-					);
-					out.subscribe(() => {});
-					// Drive emissions through the resolved cross-mount deps.
-					let expected = 0;
-					for (let i = 0; i < values.length; i++) {
-						const idx = i % k;
-						const v = values[i];
-						parent.set(`m::a${idx}`, v);
-						// Recompute expected sum from current child caches.
-						let s = 0;
-						for (let j = 0; j < k; j++) {
-							s += child.node(`a${j}`).cache as number;
-						}
-						expected = s;
-						if (lastSeen !== expected) return false;
-					}
-					return true;
-				} finally {
-					parent.destroy();
-				}
-			},
-		),
-};
-
-/**
- * #63 — graph-narrow-waist-topology-visibility (Plan P6).
- *
- * Every node created by `graph.derived` / `graph.effect` / `graph.producer`
- * appears in `graph.describe().nodes` under its registered name, with
- * correct edges in `describe().edges`. The contract is: pattern authors
- * never create islands when they use the narrow-waist API.
- *
- * Topology: K ∈ [1, 4] state nodes plus M ∈ [1, 4] derived nodes wired to
- * a random subset of the states. Build via `graph.derived`; assert each
- * registered name appears in `describe().nodes` and each (state → derived)
- * edge appears in `describe().edges`.
- *
- * Catches: a regression where `graph.derived/effect/produce` skip the
- * `graph.add` registration step (e.g. via a future "anonymous" mode), or
- * where the underlying `_deps` walk in `edges()` misses path-resolved deps.
- */
-const invariant63GraphNarrowWaistTopologyVisibility: Invariant = {
-	name: "graph-narrow-waist-topology-visibility",
-	description:
-		"Every node created via graph.derived/effect/produce appears in graph.describe().nodes under its registered name, with edges from each dep path in graph.describe().edges.",
-	specRef: "archive/docs/SESSION-graph-narrow-waist.md § P6",
-	property: () =>
-		fc.property(
-			fc.integer({ min: 1, max: 4 }),
-			fc.array(fc.array(fc.nat(3), { minLength: 1, maxLength: 4 }), {
-				minLength: 1,
-				maxLength: 4,
-			}),
-			(numStates, derivedSpecs) => {
-				const g = new Graph("prop-p6");
-				try {
-					for (let i = 0; i < numStates; i++) {
-						g.add(node([], { name: `s${i}`, initial: i }), { name: `s${i}` });
-					}
-					const expectedDerivedNames: string[] = [];
-					const expectedEdges = new Set<string>();
-					for (let i = 0; i < derivedSpecs.length; i++) {
-						const depIdxs = Array.from(new Set(derivedSpecs[i].map((idx) => idx % numStates)));
-						const depPaths = depIdxs.map((idx) => `s${idx}`);
-						const name = `d${i}`;
-						g.derived(name, depPaths, (data, ctx) => [
-							(latestVals(data, ctx) as number[]).reduce((s, v) => s + v, 0),
-						]);
-						expectedDerivedNames.push(name);
-						for (const p of depPaths) expectedEdges.add(`${p}->${name}`);
-					}
-					const desc = g.describe();
-					// Every state must be in nodes.
-					for (let i = 0; i < numStates; i++) {
-						if (!(`s${i}` in desc.nodes)) return false;
-					}
-					// Every derived must be in nodes.
-					for (const name of expectedDerivedNames) {
-						if (!(name in desc.nodes)) return false;
-					}
-					// Every expected edge must be present.
-					const actualEdges = new Set(desc.edges.map((e) => `${e.from}->${e.to}`));
-					for (const ee of expectedEdges) {
-						if (!actualEdges.has(ee)) return false;
-					}
-					// No phantom edges — every actual edge between the named nodes
-					// must correspond to an expected one (or be among non-derived
-					// state-to-state, which there shouldn't be any of since states
-					// have no deps).
-					for (const e of desc.edges) {
-						if (!expectedEdges.has(`${e.from}->${e.to}`)) return false;
-					}
-					return true;
-				} finally {
-					g.destroy();
-				}
-			},
-		),
-};
-
-/**
- * #64 — graph-derived-keepalive-equivalence (Plan P7).
- *
- * For the same fn and dep paths, `graph.derived(name, deps, fn, { keepAlive:
- * true })` and `graph.derived(name, deps, fn)` (default no-keepAlive) must
- * produce identical `.cache` values WHENEVER both are activated. The
- * keepAlive option is a subscription convenience — it owns activation when
- * no external subscriber exists, but does not change the computed value.
- *
- * Topology: shared upstream `node([], { initial: 0 }) → "a"`. Two derived nodes "with" and
- * "without" keepAlive computing the same fn on the same dep. To activate
- * the no-keepAlive variant we attach an external subscribe; the keepAlive
- * variant has none. Drive: random sequence of emits on "a"; assert the two
- * caches are equal after every event.
- *
- * Catches: a regression where keepAlive accidentally changes the value
- * pipeline (e.g. by intercepting DATA messages or by reordering the
- * subscription wave so the two fns see different snapshots).
- */
-const invariant64GraphDerivedKeepAliveEquivalence: Invariant = {
-	name: "graph-derived-keepalive-equivalence",
-	description:
-		"graph.derived with keepAlive: true and an externally-subscribed graph.derived without keepAlive produce identical .cache values for the same fn and deps after every emission.",
-	specRef: "archive/docs/SESSION-graph-narrow-waist.md § P7",
-	property: () =>
-		fc.property(eventSequenceArb({ valueRange: [0, 30] }), (events) => {
-			const g = new Graph("prop-p7");
-			try {
-				const a = node([], { name: "a", initial: 0 });
-				g.add(a, { name: "a" });
-				const fn = (
-					data: readonly (readonly unknown[] | undefined)[],
-					ctx: { readonly prevData: readonly unknown[] },
-				): readonly number[] => {
-					const [x] = latestVals(data, ctx);
-					return [(x as number) * 3 + 1];
-				};
-				const withKA = g.derived("withKA", ["a"], fn, { keepAlive: true });
-				const noKA = g.derived("noKA", ["a"], fn);
-				// Activate noKA via an external subscribe. withKA stays activation-
-				// owned by its keepAlive sink.
-				noKA.subscribe(() => {});
-				const completed = { value: false };
-				if (withKA.cache !== noKA.cache) return false;
-				for (const ev of events) {
-					if (completed.value) break;
-					applyEvent(a, ev, completed);
-					if (completed.value) break;
-					if (withKA.cache !== noKA.cache) return false;
-				}
-				return true;
-			} finally {
-				g.destroy();
-			}
-		}),
-};
-
-/**
- * #65 — graph-derived-multi-emit-array-semantics (Plan P8).
- *
- * When `graph.derived`'s fn returns `[v1, v2, ..., vN]` (N > 1),
- * downstream receives all N values as DATA messages in the same wave,
- * in the exact order the array specifies. This verifies the multi-emit
- * contract documented in `GraphDerivedFn`'s JSDoc: `[v1, v2, ...]` →
- * multi-emit in one wave.
- *
- * Topology: `node([], { initial: 1 }) → graph.derived("multi", ["a"], fn)`
- * where fn returns `[v, v*10, v*100]`. Subscribe and collect DATA values.
- * Drive: emit K random values; assert downstream receives exactly 3*K DATA
- * values (plus activation DATAs from the initial) in correct order.
- *
- * Catches: regressions where multi-element array returns are collapsed
- * into a single emit, emitted out of order, or partially dropped.
- */
-const invariant65GraphDerivedMultiEmitArray: Invariant = {
-	name: "graph-derived-multi-emit-array-semantics",
-	description:
-		"When graph.derived fn returns [v1, v2, ..., vN], downstream receives all N values as DATA in order within one wave.",
-	specRef: "archive/docs/SESSION-graph-narrow-waist.md § P8",
-	property: () =>
-		fc.property(
-			fc.array(fc.integer({ min: 1, max: 50 }), { minLength: 1, maxLength: 10 }),
-			(values) => {
-				const g = new Graph("prop-p8");
-				try {
-					// equals: () => false so same-value sets still emit DATA — this
-					// property tests multi-emit semantics, not dedup.
-					const a = node<number>([], {
-						name: "a",
-						initial: values[0],
-						equals: () => false,
-					});
-					g.add(a, { name: "a" });
-					const out = g.derived("multi", ["a"], (data, ctx) => {
-						const [x] = latestVals(data, ctx);
-						const v = x as number;
-						return [v, v * 10, v * 100];
-					});
-					const collected: number[] = [];
-					out.subscribe((msgs) => {
-						for (const msg of msgs as readonly [symbol, unknown?][]) {
-							if (msg[0] === DATA) collected.push(msg[1] as number);
-						}
-					});
-					// Activation emits fn(initial) = [values[0], values[0]*10, values[0]*100].
-					if (collected.length !== 3) return false;
-					if (collected[0] !== values[0]) return false;
-					if (collected[1] !== values[0] * 10) return false;
-					if (collected[2] !== values[0] * 100) return false;
-					// Drive subsequent emissions.
-					for (let i = 1; i < values.length; i++) {
-						g.set("a", values[i]);
-						const base = (i + 1) * 3;
-						if (collected.length !== base) return false;
-						if (collected[base - 3] !== values[i]) return false;
-						if (collected[base - 2] !== values[i] * 10) return false;
-						if (collected[base - 1] !== values[i] * 100) return false;
-					}
-					return true;
-				} finally {
-					g.destroy();
-				}
-			},
-		),
-};
-
-/**
- * #66 — graph-derived-empty-array-resolved (Plan P9).
- *
- * When `graph.derived`'s fn returns `[]` (empty array), the node settles
- * as RESOLVED — no DATA is emitted. This is the "no change" contract:
- * the derived fn computed but produced nothing new. Downstream must see
- * RESOLVED (not an empty array as DATA, not silence).
- *
- * Topology: `node([], { initial: 0 }) → graph.derived("gate", ["a"], fn)`
- * where fn returns `[v]` for even values and `[]` for odd values.
- * Subscribe, capture all message types. Drive: emit K random values;
- * assert DATA appears only for even inputs, RESOLVED appears for odd.
- *
- * Catches: regressions where `[]` return is treated as a DATA emission
- * of an empty array, or where the RESOLVED signal is lost entirely.
- */
-const invariant66GraphDerivedEmptyArrayResolved: Invariant = {
-	name: "graph-derived-empty-array-resolved",
-	description:
-		"When graph.derived fn returns [], the node emits RESOLVED (no DATA), not an empty array as DATA.",
-	specRef: "archive/docs/SESSION-graph-narrow-waist.md § P9",
-	property: () =>
-		fc.property(
-			fc.array(fc.integer({ min: 0, max: 100 }), { minLength: 1, maxLength: 15 }),
-			(values) => {
-				const g = new Graph("prop-p9");
-				try {
-					const a = node<number>([], { name: "a", initial: values[0] });
-					g.add(a, { name: "a" });
-					// fn returns [v] for even values, [] for odd values.
-					const out = g.derived("gate", ["a"], (data, ctx) => {
-						const [x] = latestVals(data, ctx);
-						const v = x as number;
-						return v % 2 === 0 ? [v] : [];
-					});
-					const dataValues: number[] = [];
-					let resolvedCount = 0;
-					out.subscribe((msgs) => {
-						for (const msg of msgs as readonly [symbol, unknown?][]) {
-							if (msg[0] === DATA) dataValues.push(msg[1] as number);
-							if (msg[0] === RESOLVED) resolvedCount++;
-						}
-					});
-					// Activation: fn(values[0]) — DATA if even, RESOLVED if odd.
-					const initEven = values[0] % 2 === 0;
-					if (initEven) {
-						if (dataValues.length !== 1 || dataValues[0] !== values[0]) return false;
-					} else {
-						if (dataValues.length !== 0) return false;
-						if (resolvedCount < 1) return false;
-					}
-					// Drive subsequent values.
-					let expectedDataCount = initEven ? 1 : 0;
-					for (let i = 1; i < values.length; i++) {
-						const cur = values[i];
-						const resolvedBefore = resolvedCount;
-						g.set("a", cur);
-						const curEven = cur % 2 === 0;
-						if (curEven) {
-							// Even → DATA expected (unless equals suppressed when cache
-							// already holds `cur`). Either way, no spurious value.
-							if (dataValues.length > expectedDataCount) {
-								if (dataValues[dataValues.length - 1] !== cur) return false;
-								expectedDataCount = dataValues.length;
-							}
-						} else {
-							// Odd → fn returns [] → must emit RESOLVED, never DATA.
-							if (dataValues.length !== expectedDataCount) return false;
-							// Strict: the [] return must produce exactly one RESOLVED
-							// for the wave (no silence, no DATA leak).
-							if (resolvedCount <= resolvedBefore) return false;
-						}
-					}
-					// Final: no DATA was ever emitted for an odd input.
-					for (const d of dataValues) {
-						if (d % 2 !== 0) return false;
-					}
-					return true;
-				} finally {
-					g.destroy();
-				}
-			},
-		),
-};
-
-/**
- * #67 — graph-narrow-waist-options-flow-through (Plan P10).
- *
- * Phase 11 / C2 widening — `GraphDerivedOptions`, `GraphEffectOptions`,
- * `GraphStateOptions`, `GraphProducerOptions` all extend the input-side
- * `NodeOptions` shape (excluding `name` / `describeKind`). Every valid
- * `NodeOptions` field passed via the Graph methods MUST flow through to the
- * underlying `node()` call.
- *
- * This invariant pins three load-bearing fields:
- * - `guard` — the registered node has `hasGuard() === true` and rejects
- *   denied actions (e.g. observe by an actor not on the allow list).
- * - `meta` — every key/value in `opts.meta` appears under `describe()`'s
- *   `node.meta` (with `detail: "standard"` or higher).
- * - `equals` — when `opts.equals` returns `true` for two values, the second
- *   `set()` does NOT produce a fresh DATA emission downstream (substituted
- *   to RESOLVED per spec §3.5.1).
- *
- * Catches: regressions where a Graph method silently drops options that
- * were passed but didn't land on the underlying `node()` (e.g. a future
- * destructure that omits a new option). The `Omit<NodeOptions, "name" |
- * "describeKind">` extension means an authored node-level field stays
- * consistent across raw `node()` and `graph.derived/effect/state/producer`.
- */
-const invariant67GraphNarrowWaistOptionsFlowThrough: Invariant = {
-	name: "graph-narrow-waist-options-flow-through",
-	description:
-		"All valid input-side NodeOptions (guard, meta, equals, ...) flow through Graph.derived / Graph.effect / Graph.state / Graph.producer to the underlying node().",
-	specRef:
-		"archive/docs/SESSION-graph-narrow-waist.md § Phase 11 / docs/optimizations.md C2 (widen GraphDerivedOptions / GraphEffectOptions)",
-	property: () =>
-		fc.property(
-			fc.array(fc.integer({ min: 0, max: 5 }), { minLength: 2, maxLength: 6 }),
-			(values) => {
-				const g = new Graph("prop-p10");
-				try {
-					// 1. `guard` flows through state/derived/effect.
-					const observeHumanOnly = policy((allow) => {
-						allow("observe", { where: (a) => a.type === "human" });
-					});
-					const writeAllowAll = policy((allow) => {
-						allow("write");
-						allow("observe");
-						allow("signal");
-					});
-
-					const guardedState = g.state("g_state", 0, {
-						guard: writeAllowAll,
-						meta: { kind: "guarded_state", tier: "warm" },
-					});
-					const guardedDerived = g.derived(
-						"g_derived",
-						["g_state"],
-						(data, ctx) => [latestVals(data, ctx)[0] as number],
-						{
-							guard: observeHumanOnly,
-							meta: { kind: "guarded_derived" },
-							// equals: collapse same-value emits to RESOLVED.
-							equals: (a, b) => a === b,
-						},
-					);
-					let effectInvocations = 0;
-					const effectNode = g.effect(
-						"g_effect",
-						["g_state"],
-						() => {
-							effectInvocations += 1;
-						},
-						{
-							guard: writeAllowAll,
-							meta: { kind: "guarded_effect" },
-						},
-					);
-					// Subscribe to drive activation — effects only fire when the
-					// node has at least one sink (or `keepAlive`).
-					effectNode.subscribe(() => {});
-
-					// 1a. hasGuard() returns true for all three.
-					if (!guardedState.hasGuard()) return false;
-					if (!guardedDerived.hasGuard()) return false;
-					if (!g.resolve("g_effect").hasGuard()) return false;
-
-					// 1b. observe-restricted derived denies a non-human actor.
-					if (
-						guardedDerived.allowsObserve({ type: "llm", id: "a1" }) ||
-						!guardedDerived.allowsObserve({ type: "human", id: "u1" })
-					) {
-						return false;
-					}
-
-					// 2. `meta` flows through to describe().
-					const desc = g.describe({ detail: "standard" });
-					if (desc.nodes.g_state?.meta?.kind !== "guarded_state") return false;
-					if (desc.nodes.g_state?.meta?.tier !== "warm") return false;
-					if (desc.nodes.g_derived?.meta?.kind !== "guarded_derived") return false;
-					if (desc.nodes.g_effect?.meta?.kind !== "guarded_effect") return false;
-
-					// 3. `equals` short-circuits cache emit on the derived.
-					const dataValues: number[] = [];
-					let resolvedCount = 0;
-					guardedDerived.subscribe((msgs) => {
-						for (const msg of msgs as readonly [symbol, unknown?][]) {
-							if (msg[0] === DATA) dataValues.push(msg[1] as number);
-							if (msg[0] === RESOLVED) resolvedCount += 1;
-						}
-					});
-					// Activation pushes initial DATA(0).
-					if (dataValues.length !== 1 || dataValues[0] !== 0) return false;
-					// Set the same value again — equals collapses to RESOLVED, not DATA.
-					const resolvedBefore = resolvedCount;
-					g.set("g_state", 0);
-					if (dataValues.length !== 1) return false;
-					if (resolvedCount <= resolvedBefore) return false;
-
-					// 4. Driving distinct values still emits DATA.
-					let lastDataLen = dataValues.length;
-					for (const v of values) {
-						g.set("g_state", v);
-						// Either DATA fired (new value) or RESOLVED fired (same as cached).
-						// In both cases something downstream surfaced.
-						const grew = dataValues.length > lastDataLen;
-						if (grew) {
-							const last = dataValues[dataValues.length - 1];
-							if (last !== v) return false;
-							lastDataLen = dataValues.length;
-						}
-					}
-
-					// 5. `effect` fired at least once on activation; the GuardDenied
-					// path is exercised via `allowsObserve` above.
-					if (effectInvocations < 1) return false;
-
-					return true;
-				} finally {
-					g.destroy();
-				}
-			},
-		),
-};
-
-/**
- * #68 — graph-changeset-data-edge-attribution (D2 — Three-layer view).
- *
- * For every `data` event on the changeset stream, `fromPath` + `fromDepIndex`
- * correctly attribute the upstream edge that delivered the value:
- *   - For source nodes (no upstream deps), `fromPath === scope` and
- *     `fromDepIndex === -1`.
- *   - For derived nodes triggered by a tracked dep, `fromPath` is the upstream
- *     dep's qualified observe path and `fromDepIndex` is its index in the
- *     scoped node's `_deps` array.
- *
- * Topology: K state sources `s_0…s_{K-1}` feed one `derived("d", [s_0…])`.
- * Drive: emit on a random source; assert the next data event for `d`
- * attributes `fromPath = "s_i"` and `fromDepIndex = i` for the source picked.
- */
-const invariant68ChangesetDataEdgeAttribution: Invariant = {
-	name: "graph-changeset-data-edge-attribution",
-	description:
-		"On `Graph.observe({ changeset: true })`, every `data` event for a derived node attributes the upstream edge via fromPath + fromDepIndex; source-node data events use fromDepIndex: -1.",
-	specRef: "docs/optimizations.md § D — Three-layer view (D2)",
-	property: () =>
-		fc.property(
-			fc.integer({ min: 1, max: 4 }),
-			fc.array(fc.nat(3), { minLength: 1, maxLength: 6 }),
-			(numStates, drives) => {
-				const g = new Graph("inv-cs-attr");
-				try {
-					const sources: Node<number>[] = [];
-					const sourceNames: string[] = [];
-					for (let i = 0; i < numStates; i++) {
-						const name = `s${i}`;
-						const s = node<number>([], { name, initial: 0, equals: () => false });
-						g.add(s, { name });
-						sources.push(s);
-						sourceNames.push(name);
-					}
-					g.derived("d", sourceNames, (data, ctx) => {
-						const vals = latestVals(data, ctx) as number[];
-						return [vals.reduce((a, b) => a + b, 0)];
-					});
-					const changesetNode = g.observe({ changeset: true });
-					const events: GraphChange[] = [];
-					const off = changesetNode.subscribe((msgs) => {
-						for (const m of msgs) {
-							if (m[0] === DATA) events.push(m[1] as GraphChange);
-						}
-					});
-					// Activate so the subscription chain is live.
-					g.node("d").subscribe(() => {});
-					events.length = 0;
-
-					for (const drive of drives) {
-						const idx = drive % numStates;
-						g.set(`s${idx}`, drive + 1);
-						const dataForD = events.filter((e) => e.type === "data" && e.scope === "d");
-						const dataForSource = events.filter((e) => e.type === "data" && e.scope === `s${idx}`);
-						// Source data event: fromDepIndex must be -1.
-						for (const ev of dataForSource) {
-							if (ev.type !== "data") return false;
-							if (ev.fromDepIndex !== -1) return false;
-							if (ev.fromPath !== `s${idx}`) return false;
-						}
-						// Derived data event: fromDepIndex must point at the
-						// driven source.
-						const lastDerived = dataForD.at(-1);
-						if (lastDerived != null) {
-							if (lastDerived.type !== "data") return false;
-							if (lastDerived.fromPath !== `s${idx}`) return false;
-							if (lastDerived.fromDepIndex !== idx) return false;
-						}
-						events.length = 0;
-					}
-					off();
-					return true;
-				} finally {
-					g.destroy();
-				}
-			},
-		),
-};
-
-/**
- * #69 — graph-changeset-version-monotonic (D2 — Three-layer view).
- *
- * `Graph.observe({ changeset: true })` emits events whose envelope `version`
- * counter is strictly monotonic across all variants — data, dirty, resolved,
- * error, complete, teardown, batch-start, batch-end, and topology events.
- * The invariant holds across an arbitrary mix of explicit `batch()` calls,
- * topology mutations (add/remove), and value emissions.
- */
-const invariant69ChangesetVersionMonotonic: Invariant = {
-	name: "graph-changeset-version-monotonic",
-	description:
-		"All events from a single `Graph.observe({ changeset: true })` handle have strictly increasing envelope.version stamps.",
-	specRef: "docs/optimizations.md § D — Three-layer view (D2)",
-	property: () =>
-		fc.property(
-			fc.array(
-				fc.oneof(
-					fc.record({ kind: fc.constant("emit" as const), value: fc.integer() }),
-					fc.record({
-						kind: fc.constant("batch" as const),
-						values: fc.array(fc.integer(), { minLength: 1, maxLength: 4 }),
-					}),
-					fc.record({ kind: fc.constant("addNode" as const), nameSeq: fc.nat(50) }),
-				),
-				{ minLength: 1, maxLength: 12 },
-			),
-			(ops) => {
-				const g = new Graph("inv-cs-ver");
-				try {
-					const root = node<number>([], { name: "root", initial: 0, equals: () => false });
-					g.add(root, { name: "root" });
-					const changesetNode = g.observe({ changeset: true });
-					const events: GraphChange[] = [];
-					const off = changesetNode.subscribe((msgs) => {
-						for (const m of msgs) {
-							if (m[0] === DATA) events.push(m[1] as GraphChange);
-						}
-					});
-					const used = new Set<string>(["root"]);
-					for (const op of ops) {
-						if (op.kind === "emit") {
-							g.set("root", op.value);
-						} else if (op.kind === "batch") {
-							batch(() => {
-								for (const v of op.values) g.set("root", v);
-							});
-						} else {
-							const newName = `n_${op.nameSeq}_${used.size}`;
-							if (used.has(newName)) continue;
-							used.add(newName);
-							g.add(node([], { name: newName, initial: 0 }), { name: newName });
-						}
-					}
-					off();
-					for (let i = 1; i < events.length; i++) {
-						if (events[i].version <= events[i - 1].version) return false;
-					}
-					return true;
-				} finally {
-					g.destroy();
-				}
-			},
-		),
-};
-
-/**
- * #70 — graph-changeset-batch-frame-pairing (D2 — Three-layer view).
- *
- * Every `batch-start` event on the changeset stream is matched by a
- * subsequent `batch-end` whose `version` is strictly greater. Frames are
- * non-overlapping (no nested batch-start before the previous batch-end).
- * Every event between a batch-start and its batch-end has a `version`
- * strictly within the pair's bounds.
- */
-const invariant70ChangesetBatchFramePairing: Invariant = {
-	name: "graph-changeset-batch-frame-pairing",
-	description:
-		"`batch-start` and `batch-end` events on the changeset stream pair up — equal counts, non-overlapping, and every interleaved event lies within its enclosing pair's version range.",
-	specRef: "docs/optimizations.md § D — Three-layer view (D2)",
-	property: () =>
-		fc.property(
-			fc.array(fc.array(fc.integer(), { minLength: 1, maxLength: 3 }), {
-				minLength: 1,
-				maxLength: 5,
-			}),
-			(batches) => {
-				const g = new Graph("inv-cs-frame");
-				try {
-					const a = node<number>([], { name: "a", initial: 0, equals: () => false });
-					const b = node<number>([], { name: "b", initial: 0, equals: () => false });
-					g.add(a, { name: "a" });
-					g.add(b, { name: "b" });
-					const changesetNode = g.observe({ changeset: true });
-					const events: GraphChange[] = [];
-					const off = changesetNode.subscribe((msgs) => {
-						for (const m of msgs) {
-							if (m[0] === DATA) events.push(m[1] as GraphChange);
-						}
-					});
-					events.length = 0;
-					for (const vals of batches) {
-						batch(() => {
-							for (let i = 0; i < vals.length; i++) {
-								(i % 2 === 0 ? a : b).emit(vals[i]);
-							}
-						});
-					}
-					off();
-
-					// Walk events: maintain a stack of open frame versions.
-					let openVersion: number | null = null;
-					for (const ev of events) {
-						if (ev.type === "batch-start") {
-							if (openVersion != null) return false; // nested
-							openVersion = ev.version;
-						} else if (ev.type === "batch-end") {
-							if (openVersion == null) return false; // unmatched
-							if (ev.version <= openVersion) return false; // bs < be
-							openVersion = null;
-						} else {
-							// Every non-boundary event inside a frame must lie
-							// within the frame's bounds (it's already after
-							// batch-start since events are version-monotonic;
-							// but it must precede batch-end too — which we
-							// can only check post-hoc). Skip here; the
-							// version-monotonic invariant pins ordering.
-						}
-					}
-					if (openVersion != null) return false; // unclosed frame
-					return true;
-				} finally {
-					g.destroy();
-				}
-			},
-		),
-};
-
-/**
- * #71 — graph-changeset-topology-lifecycle (D2 — Three-layer view).
- *
- * Topology variants on the changeset stream fire at the right lifecycle
- * moments: `node-added` for `Graph.add`, `node-removed` for
- * `Graph.remove(name)` of a registered node, `mount` for `Graph.mount`, and
- * `unmount` for `Graph.remove(name)` of a mounted subgraph. The qualified
- * `scope` matches the path the change applies to.
- */
-const invariant71ChangesetTopologyLifecycle: Invariant = {
-	name: "graph-changeset-topology-lifecycle",
-	description:
-		"Topology events on the changeset stream — node-added, node-removed, mount, unmount — correspond 1:1 with Graph.add / Graph.remove / Graph.mount lifecycle calls and carry the qualified path as scope.",
-	specRef: "docs/optimizations.md § D — Three-layer view (D2)",
-	property: () =>
-		fc.property(
-			fc.array(
-				fc.oneof(
-					fc.record({ kind: fc.constant("addNode" as const), seq: fc.nat(20) }),
-					fc.record({ kind: fc.constant("addMount" as const), seq: fc.nat(20) }),
-				),
-				{ minLength: 1, maxLength: 6 },
-			),
-			(ops) => {
-				const g = new Graph("inv-cs-topo");
-				try {
-					const changesetNode = g.observe({ changeset: true });
-					const events: GraphChange[] = [];
-					const off = changesetNode.subscribe((msgs) => {
-						for (const m of msgs) {
-							if (m[0] === DATA) events.push(m[1] as GraphChange);
-						}
-					});
-					events.length = 0;
-
-					const addedNodes: string[] = [];
-					const addedMounts: string[] = [];
-					const usedNames = new Set<string>();
-					for (const op of ops) {
-						if (op.kind === "addNode") {
-							const name = `n_${op.seq}_${usedNames.size}`;
-							if (usedNames.has(name)) continue;
-							usedNames.add(name);
-							g.add(node([], { name, initial: 0 }), { name });
-							addedNodes.push(name);
-						} else {
-							const name = `m_${op.seq}_${usedNames.size}`;
-							if (usedNames.has(name)) continue;
-							usedNames.add(name);
-							const child = new Graph(name);
-							g.mount(name, child);
-							addedMounts.push(name);
-						}
-					}
-					// Verify node-added / mount events correspond.
-					for (const n of addedNodes) {
-						if (!events.some((e) => e.type === "node-added" && e.scope === n)) return false;
-					}
-					for (const m of addedMounts) {
-						if (!events.some((e) => e.type === "mount" && e.scope === m)) return false;
-					}
-					// Tear down each and verify removal events.
-					events.length = 0;
-					for (const n of addedNodes) g.remove(n);
-					for (const m of addedMounts) g.remove(m);
-					for (const n of addedNodes) {
-						if (!events.some((e) => e.type === "node-removed" && e.scope === n)) return false;
-					}
-					for (const m of addedMounts) {
-						if (!events.some((e) => e.type === "unmount" && e.scope === m)) return false;
-					}
-					off();
-					return true;
-				} finally {
-					g.destroy();
-				}
-			},
-		),
-};
-
-/**
- * #72 — single-invalidate-settles (mirrors TLC #29 `InvalidateSettlesWave`,
- * DS-13.5.A 2026-05-02 lock Q14 / Q15).
- *
- * The deadlock counter-test the DS-13.5.A INVALIDATE redesign closed:
- * pre-redesign, an INVALIDATE arriving alone at a derived's only dep would
- * NOT clear the dep's bit from `_dirtyDepCount`, leaving the derived stuck
- * in `status = "dirty"` forever. The runtime fix
- * (`_depInvalidated` decrements `_dirtyDepCount`, mirroring RESOLVED) means
- * subsequent emits propagate freshly.
- *
- * Property: drive `(emit(v), invalidate)` cycles N times. Assert:
- *   - Wave balance holds: every DIRTY paired with one settle (DATA, RESOLVED,
- *     or INVALIDATE).
- *   - Each cycle's emit value reaches the sink as a DATA (the wave isn't
- *     stuck — a regression that drops the dirtyDepCount decrement would
- *     prevent later emits from firing fn).
- *   - Trace contains exactly N INVALIDATE arrivals (cleanup messages
- *     observable to the sink).
- *
- * Topology: `state → derived` (single-dep, identity fn). The minimum
- * topology where INVALIDATE-alone wave behavior surfaces.
- *
- * Catches: DS-13.5.A regression — any future change that drops the
- * `_dirtyDepCount` decrement on INVALIDATE delivery would either (a) hang
- * the test (no DATA arrives because fn never fires) or (b) trip the wave-
- * balance assertion if the substrate also stops recording trace messages.
- */
-const invariant72SingleInvalidateSettles: Invariant = {
-	name: "single-invalidate-settles",
-	description:
-		"An INVALIDATE arriving alone at a derived's only dep settles the wave without deadlock — subsequent emits propagate freshly without leftover dirty state.",
-	specRef:
-		"wave_protocol.tla #29 InvalidateSettlesWave (DS-13.5.A 2026-05-02 Q14; via src/core/node.ts:_onDepMessage INVALIDATE branch)",
-	property: () =>
-		fc.property(
-			// QA P1 (2026-05-07): use `uniqueArray` so consecutive emits never
-			// carry the same value. With duplicates allowed, a derived using
-			// default Object.is equals could absorb a repeated emit into
-			// RESOLVED (cache stays the same) even though the source side
-			// never absorbs (its `equals: () => false` override). The post-
-			// invalidate cache reset on the source clears `prevData[s-slot]`
-			// at the dependent but not the dependent's own cache, so cycle-N's
-			// DATA(v) followed by cycle-(N+1)'s same-value DATA(v) at the dep
-			// would emit RESOLVED. uniqueArray sidesteps the equals-axis
-			// interaction entirely, keeping this property focused on the
-			// wave-settlement guarantee.
-			fc.uniqueArray(fc.integer({ min: 1, max: 100 }), {
-				minLength: 2,
-				maxLength: 5,
-			}),
-			(values) => {
-				const s = node<number>([], { initial: 0, equals: () => false });
-				const d = node<number>(
-					[s],
-					(batchData, actions, ctx) => {
-						const data = batchData.map((batchEntry, i) =>
-							batchEntry != null && batchEntry.length > 0 ? batchEntry.at(-1) : ctx.prevData[i],
-						);
-						actions.emit(data[0] as number);
-					},
-					{ describeKind: "derived" },
-				);
-
-				const trace: symbol[] = [];
-				const dataValues: number[] = [];
-				const unsub = d.subscribe((msgs) => {
-					for (const msg of msgs as readonly [symbol, unknown?][]) {
-						if (msg[0] === START) continue;
-						trace.push(msg[0]);
-						if (msg[0] === DATA) dataValues.push(msg[1] as number);
-					}
-				});
-
-				// Drive (emit, invalidate) cycles. Each cycle: emit a fresh DATA,
-				// then INVALIDATE. After each INVALIDATE the derived's wave must
-				// settle so the next emit propagates a new DATA.
-				for (const v of values) {
-					s.emit(v);
-					s.down([[INVALIDATE]]);
-				}
-
-				unsub();
-
-				// 1. Wave balance: DIRTY count = (DATA + RESOLVED + INVALIDATE) count.
-				let pending = 0;
-				for (const t of trace) {
-					if (t === DIRTY) pending += 1;
-					else if (t === DATA || t === RESOLVED || t === INVALIDATE) pending -= 1;
-					if (pending < 0) return false;
-				}
-				if (pending !== 0) return false;
-
-				// 2. Each emit value must have appeared as a DATA at the sink.
-				//    This is the deadlock counter-test: if INVALIDATE doesn't
-				//    settle the wave, the next emit never fires fn so DATA is
-				//    missing. The handshake DATA(0) precedes the first cycle
-				//    DATA, so we expect `values.length + 1` DATAs total — an
-				//    initial DATA(0) from subscribe handshake, then one DATA(v)
-				//    per cycle.
-				if (dataValues.length !== values.length + 1) return false;
-				// QA P3 (2026-05-07): assert the handshake DATA carries the
-				// initial value. Without this, a regression that misroutes the
-				// handshake DATA to a wrong value would still pass the count
-				// check vacuously.
-				if (dataValues[0] !== 0) return false;
-				for (let i = 0; i < values.length; i++) {
-					if (dataValues[i + 1] !== values[i]) return false;
-				}
-
-				// 3. Trace must contain exactly `values.length` INVALIDATE messages.
-				const invCount = trace.filter((t) => t === INVALIDATE).length;
-				if (invCount !== values.length) return false;
-
-				return true;
-			},
-		),
-};
-
-/**
- * #73 — invalidate-merge-order-independent (mirrors TLC #30
- * `MergeRulesRespected`, DS-13.5.A 2026-05-02 lock Q9 + tier-sort).
- *
- * Within a single `down(messages)` call on the source, any permutation of
- * {≤1 [DATA, v], N [INVALIDATE]} entries produces the same outcome at the
- * source's observer because tier-sort + Q9 collapse normalize the order:
- *
- *   - tier-sort: DATA (tier 3) sorts before INVALIDATE (tier 4) regardless
- *     of input order. So `[INV, DATA]` and `[DATA, INV]` both deliver as
- *     `[DIRTY, DATA(v), INVALIDATE]` to the observer.
- *
- *   - Q9 collapse (DS-13.5.A): K INVALIDATE entries in a single down() call
- *     collapse to exactly ONE outgoing INVALIDATE. So
- *     `[INV, INV, ..., INV]` delivers as `[DIRTY, INVALIDATE]` regardless
- *     of K.
- *
- *   - With both DATA and INVs: `[DATA, INV*K]` (any permutation) delivers
- *     as `[DIRTY, DATA(v), INVALIDATE]` — DATA before INV, INVs collapsed.
- *
- * Note: Q1/Q3 explicit "DATA/RESOLVED wins" merges were retired during
- * implementation (see implementation-plan.md DS-13.5.A row N1) — natural
- * tier-sort handles `[DATA(v), INVALIDATE]` correctly: BOTH messages
- * deliver to observers, cache ends cleared (INVALIDATE runs after DATA
- * in tier order, clearing the cache that DATA just set). Cache outcome
- * vs DATA's cache assignment is the LOCAL sequencing on the source; both
- * messages remain observable.
- *
- * Topology: subscribe directly to the source. The merge happens inside
- * `_frameBatch` on `down()`; observing the source is the cleanest way to
- * see the merged stream without derived-fn interactions.
- *
- * Catches: regressions to the Q9 collapse logic (e.g., a refactor that
- * forwards K INVs as K outgoing INVALIDATEs) or to tier-sort (e.g., a
- * refactor that emits INV before DATA when input order was [INV, DATA]).
- */
-const invariant73InvalidateMergeOrderIndependent: Invariant = {
-	name: "invalidate-merge-order-independent",
-	description:
-		"Within a single down() call, any permutation of {≤1 [DATA, v], N [INVALIDATE]} entries delivers as ONE DIRTY + tier-sorted [DATA?, INVALIDATE] at the observer — DATA before INV (tier-sort), all INVs collapsed to one (Q9).",
-	specRef:
-		"wave_protocol.tla #30 MergeRulesRespected (DS-13.5.A 2026-05-02 Q9 + tier-sort; via src/core/node.ts:_frameBatch tier-sort + Q9 collapse)",
-	property: () =>
-		fc.property(
-			// Either an emit value (1..10), or null meaning all-INV input.
-			// Value 0 excluded so DATA-vs-RESOLVED distinction is unambiguous
-			// (initial cache = 0; non-zero value forces DATA).
-			fc.option(fc.integer({ min: 1, max: 10 }), { nil: null }),
-			fc.integer({ min: 1, max: 4 }), // numInvs (≥1 to make Q9 meaningful)
-			fc.integer({ min: 0, max: 0xffffff }), // permutation seed
-			(emitValue, numInvs, seed) => {
-				const s = node<number>([], { initial: 0 });
-
-				const trace: symbol[] = [];
-				const traceValues: unknown[] = [];
-				const unsub = s.subscribe((msgs) => {
-					for (const msg of msgs as readonly [symbol, unknown?][]) {
-						if (msg[0] === START) continue;
-						trace.push(msg[0]);
-						traceValues.push(msg[1]);
-					}
-				});
-
-				// Drop handshake messages — only post-handshake settles matter.
-				const activationEnd = trace.length;
-
-				// Build messages: ≤1 [DATA, v] + N [INVALIDATE].
-				type RawMsg = readonly [symbol, unknown?];
-				const messages: RawMsg[] = [];
-				if (emitValue !== null) messages.push([DATA, emitValue] as const);
-				for (let i = 0; i < numInvs; i++) messages.push([INVALIDATE] as const);
-
-				// Permute via seeded Fisher-Yates so shrinking still works.
-				const shuffled = [...messages];
-				let rng = seed | 0;
-				for (let i = shuffled.length - 1; i > 0; i--) {
-					rng = (rng * 1103515245 + 12345) & 0x7fffffff;
-					const j = rng % (i + 1);
-					[shuffled[i], shuffled[j]] = [shuffled[j], shuffled[i]];
-				}
-
-				// Single down() call — exercises _frameBatch tier-sort + Q9 collapse
-				// on a multi-message input. Returning false on any structural
-				// violation lets fast-check shrink to the smallest counter-example.
-				s.down(shuffled as Messages);
-
-				unsub();
-
-				// Slice trace to post-handshake observations.
-				const post = trace.slice(activationEnd);
-				const postValues = traceValues.slice(activationEnd);
-
-				// Expected shape independent of permutation:
-				//   - emitValue !== null: [DIRTY, DATA(emitValue), INVALIDATE]
-				//   - emitValue === null: [DIRTY, INVALIDATE] (Q9 collapse)
-				const dirtyCount = post.filter((t) => t === DIRTY).length;
-				const dataCount = post.filter((t) => t === DATA).length;
-				const resolvedCount = post.filter((t) => t === RESOLVED).length;
-				const invCount = post.filter((t) => t === INVALIDATE).length;
-
-				// Exactly one DIRTY (auto-prefix).
-				if (dirtyCount !== 1) return false;
-				// Always exactly one INVALIDATE (Q9 collapses K → 1).
-				if (invCount !== 1) return false;
-				// No spurious RESOLVED (cache=0, emitValue ∈ 1..10 always differs).
-				if (resolvedCount !== 0) return false;
-
-				if (emitValue !== null) {
-					// Exactly one DATA carrying emitValue.
-					if (dataCount !== 1) return false;
-					const dataIdx = post.indexOf(DATA);
-					if (postValues[dataIdx] !== emitValue) return false;
-					// Tier-sort: DATA must precede INVALIDATE.
-					const invIdx = post.indexOf(INVALIDATE);
-					if (dataIdx >= invIdx) return false;
-				} else {
-					// All-INV input → no DATA in output.
-					if (dataCount !== 0) return false;
-				}
-
-				return true;
-			},
-		),
-};
-/**
- * #74 — replay-buffer-bounded (mirrors TLC #20 `ReplayBufferBounded`,
- * Phase 13.6.B B6 / Lock 6.G, spec §2.5).
- *
- * Structural cap: a node constructed with `replayBuffer: N` MUST drop
- * the oldest entry on overflow. Observed externally via a late subscriber
- * — the handshake's DATA tail length never exceeds `N` regardless of how
- * many DATA emissions preceded the subscribe, and the tail values are
- * the LAST `min(M, N)` emits in emission order (drop-oldest, not
- * drop-newest; ring contract).
- *
- * Property: keep-alive subscribe (so emits actually push into the buffer
- * — leaf sources are lazy w.r.t. sinks; pattern mirrors
- * `phase-13-6-b6.test.ts`), drive M emits with unique values, then
- * late-subscribe. Assert:
- *   - Late sub's handshake DATA tail length === min(M, N).
- *   - Tail values equal the last `min(M, N)` emits in emission order.
- *
- * Topology: leaf source — the minimum surface to observe the buffer +
- * the late-subscribe handshake.
- *
- * Catches: regressions in `_pushReplayBuffer` cap enforcement
- * (`packages/pure-ts/src/core/node.ts:3761`) — a refactor that swapped
- * drop-oldest for drop-newest, or off-by-one'd the
- * `length > capacity` check, would surface as a mismatch on tail values
- * or tail length.
- */
-const invariant74ReplayBufferBounded: Invariant = {
-	name: "replay-buffer-bounded",
-	description:
-		"A node with `replayBuffer: N` enforces drop-oldest ring semantics: any late subscriber sees at most N DATA values in the handshake tail, and they are the last N emits in emission order.",
-	specRef:
-		"wave_protocol.tla #20 ReplayBufferBounded (Phase 13.6.B B6 Lock 6.G; spec §2.5; via packages/pure-ts/src/core/node.ts:_pushReplayBuffer)",
-	property: () =>
-		fc.property(
-			fc.integer({ min: 1, max: 6 }), // capacity N
-			// Unique values so equals-substitution can't silently rewrite a
-			// repeat DATA to RESOLVED (RESOLVED entries are NOT pushed into the
-			// ring per Lock 6.G — node.ts:3764). Without uniqueness a repeat
-			// emit would skip the buffer and skew the cap/order assertions
-			// even though the protocol is intact (mirrors #72's QA-P1 fix).
-			fc.uniqueArray(fc.integer({ min: 1, max: 1000 }), {
-				minLength: 1,
-				maxLength: 12,
-			}),
-			(cap, values) => {
-				const s = node<number>([], { replayBuffer: cap });
-
-				// Keep-alive so emits run through the deliver path that calls
-				// `_pushReplayBuffer`. Raw leaf sources without sinks short-
-				// circuit emit; matches phase-13-6-b6.test.ts pattern.
-				const keepAlive = s.subscribe(() => {});
-
-				for (const v of values) s.emit(v);
-
-				// Late-subscribe — record the full handshake trace (not just
-				// START + DATA). The shape assertion below catches a
-				// regression that injected a spurious RESOLVED/DIRTY/INVALIDATE
-				// into the handshake wave (e.g., a re-enabled cache-push branch
-				// that equals-substituted to RESOLVED, or a phantom DIRTY from
-				// a status-transition refactor). Symmetric with #75 (QA-BH-1).
-				const trace: symbol[] = [];
-				const lateData: number[] = [];
-				const lateUnsub = s.subscribe((msgs) => {
-					for (const m of msgs as readonly [symbol, unknown?][]) {
-						trace.push(m[0]);
-						if (m[0] === DATA) lateData.push(m[1] as number);
-					}
-				});
-
-				keepAlive();
-				lateUnsub();
-
-				// Handshake shape: [START, DATA*] — START first, every
-				// subsequent message is DATA (no RESOLVED/DIRTY/INVALIDATE).
-				// A future refactor that re-enabled the cache-push branch
-				// alongside buffer replay would surface as an extra DATA;
-				// a refactor that injected a phantom-status frame would
-				// surface as a non-DATA in the post-START tail.
-				if (trace.length === 0) return false;
-				if (trace[0] !== START) return false;
-				for (let i = 1; i < trace.length; i++) {
-					if (trace[i] !== DATA) return false;
-				}
-
-				// Cap respected: tail never exceeds capacity.
-				const expectedLen = Math.min(values.length, cap);
-				if (lateData.length !== expectedLen) return false;
-
-				// Drop-oldest: tail equals the LAST `expectedLen` emits in
-				// emission order. Drop-newest would put the FIRST values here.
-				const expected = values.slice(values.length - expectedLen);
-				for (let i = 0; i < expectedLen; i++) {
-					if (lateData[i] !== expected[i]) return false;
-				}
-
-				return true;
-			},
-		),
-};
-
-/**
- * #75 — late-subscriber-receives-replay (mirrors TLC #23
- * `LateSubscriberReceivesReplay`, Phase 13.6.B B6 / Lock 6.G, spec §2.5).
- *
- * Observation contract: when a late subscriber attaches to a node with a
- * non-empty `replayBuffer`, the handshake delivers the buffered DATA
- * values as a tail of the subscribe wave — in emission/ring order, after
- * the `[START]` marker, with NO extra DATA injected by the cache-push
- * branch (the buffer's last entry IS the cache at quiescence; appending
- * cache afterward would duplicate it — see `defaultOnSubscribe` Lock 6.G
- * note at `packages/pure-ts/src/core/node.ts:619-626`).
- *
- * Property: drive M emits (M ≤ N so no overflow noise) on a leaf
- * `node([], { replayBuffer: N })`, then late-subscribe. Assert:
- *   - First message is `[START]`; every subsequent message in the
- *     handshake is DATA (no spurious RESOLVED/DIRTY — node is at rest).
- *   - Handshake DATA count === M (no duplicate from the cache-push branch).
- *   - Handshake DATA values equal the M emits in emission order.
- *
- * Topology: leaf source — the subscribe-side replay path is independent
- * of any operator structure above. Overflow + cap behavior is covered by
- * #74; this property focuses on the observation contract.
- *
- * Catches: regressions in `defaultOnSubscribe` (`node.ts:639-645`, the
- * replay-branch body) — re-enabling the cache-push branch alongside
- * buffer replay would duplicate the most-recent value (M+1 DATAs instead
- * of M); reordering the buffer iteration would surface as an order
- * mismatch.
- */
-const invariant75LateSubscriberReceivesReplay: Invariant = {
-	name: "late-subscriber-receives-replay",
-	description:
-		"A late subscriber on a node with non-empty `replayBuffer` receives every buffered DATA value as a contiguous tail of the handshake, in emission order, with no duplicate from the cache-push branch.",
-	specRef:
-		"wave_protocol.tla #23 LateSubscriberReceivesReplay (Phase 13.6.B B6 Lock 6.G; spec §2.5; via packages/pure-ts/src/core/node.ts:defaultOnSubscribe + _pushReplayBuffer)",
-	property: () =>
-		fc.property(
-			fc.integer({ min: 2, max: 8 }), // capacity N
-			fc.uniqueArray(fc.integer({ min: 1, max: 1000 }), {
-				minLength: 1,
-				maxLength: 8,
-			}),
-			(cap, values) => {
-				// Constrain to the no-overflow path so this property focuses
-				// on the observation contract (#23). Overflow + cap are
-				// covered by #74; values.length > cap here would conflate
-				// the two and weaken the failure mode signal. Use `fc.pre`
-				// so fast-check counts/discards instead of silently passing
-				// (QA-BH-2 fix — a generator-bound refactor that inverted
-				// the precondition would otherwise silently make the property
-				// always vacuous; fc.pre fails the run if the discard rate
-				// exceeds the configured cap).
-				fc.pre(values.length <= cap);
-
-				const s = node<number>([], { replayBuffer: cap });
-				const keepAlive = s.subscribe(() => {});
-
-				for (const v of values) s.emit(v);
-
-				const trace: Array<readonly [symbol, unknown?]> = [];
-				const lateUnsub = s.subscribe((msgs) => {
-					for (const m of msgs as readonly [symbol, unknown?][]) {
-						trace.push([m[0], m[1]] as const);
-					}
-				});
-
-				keepAlive();
-				lateUnsub();
-
-				// Handshake shape: [START, DATA(v0), DATA(v1), ...].
-				if (trace.length === 0) return false;
-				if (trace[0]![0] !== START) return false;
-
-				// Every post-START entry MUST be DATA — no spurious RESOLVED
-				// or DIRTY in the handshake (node is at rest).
-				for (let i = 1; i < trace.length; i++) {
-					if (trace[i]![0] !== DATA) return false;
-				}
-
-				const dataValues = trace.slice(1).map(([, v]) => v as number);
-
-				// Count: exactly `values.length` DATAs — no duplicate from
-				// the cache-push branch (buffer-authoritative path, Lock 6.G).
-				if (dataValues.length !== values.length) return false;
-
-				// Order: values in emission order.
-				for (let i = 0; i < values.length; i++) {
-					if (dataValues[i] !== values[i]) return false;
-				}
-
-				return true;
-			},
-		),
-};
-
-// ---------------------------------------------------------------------------
-// Dropped TLC mirrors (tracked in docs/optimizations.md "Remaining rigor-infra
-// follow-ons"):
-//
-// - TLC #18 `MultiSinkIterationCoherent` / #27 `MultiSinkIterationDriftClean`
-//   — TLA+ ghost `pendingExtraDelivery` has no runtime analogue. The runtime's
-//   `_deliverToSinks` iterates sinks synchronously over a single shared
-//   `messages` reference; there is no mid-iteration pending queue to sweep.
-// - TLC #22 `MetaTeardownObservedPreReset` — §2.3 meta companion TEARDOWN
-//   tier-5 modeling is not in the TS runtime.
-// - TLC #28 `TerminatedImpliesBatchIdle` — TLA+ models `batchActive` as a
-//   gate on terminal actions (`Terminate` / `Teardown` require
-//   `batchActive.status = "idle"`). The TS runtime allows terminal
-//   transitions inside an active batch because `_frameBatch` + `downWithBatch`
-//   tier-sort delivery so DATA always ships before COMPLETE in the flushed
-//   wave. The invariant is a modeling-level law that doesn't map to runtime
-//   semantics — a mirror would be a test of the tier-sort rather than the
-//   claimed property.
-// ---------------------------------------------------------------------------
-
-// ---------------------------------------------------------------------------
-// Registry
-// ---------------------------------------------------------------------------
-
-/**
- * The invariant catalog. Order is the canonical reading order; tests run all
- * of them. Append new invariants to the end — name + specRef are stable
- * identifiers downstream tools can rely on.
- */
-export const INVARIANTS: readonly Invariant[] = [
-	invariant1,
-	invariant2,
-	invariant3,
-	invariant4,
-	invariant5,
-	invariant6,
-	invariant7,
-	invariant8,
-	invariant9,
-	invariant10MultiDepInitial,
-	invariant11PauseMultiPauser,
-	invariant12NestedDrain,
-	invariant12bNestedDrainCompound,
-	invariant13BufferAllReplay,
-	invariant14ResubscribePause,
-	invariant15MultiSinkConverge,
-	invariant16UpTierGuard,
-	invariant17PausableOffStructural,
-	invariant18SwitchMapStaleInnerSuppressed,
-	invariant19MergeMapAllInnersContribute,
-	invariant20ExhaustMapDropsWhileActive,
-	invariant21ConcatMapSerialSubscription,
-	invariant22MergeMapConcurrencyBound,
-	invariant23RaceFirstWins,
-	invariant24RepeatCountRespected,
-	invariant25DebounceCoalesce,
-	invariant26TimeoutErrorsOnIdle,
-	invariant27ThrottleLeadingSuppresses,
-	invariant28ZipStrictPair,
-	invariant29DistinctUntilChanged,
-	invariant30Sample,
-	invariant31Pairwise,
-	invariant32BufferCount,
-	invariant33Delay,
-	invariant34Buffer,
-	invariant35BufferTime,
-	invariant36Interval,
-	invariant37Rescue,
-	invariant38Concat,
-	invariant39Take,
-	invariant40Skip,
-	invariant41Scan,
-	invariant42Reduce,
-	invariant43Merge,
-	invariant44Filter,
-	invariant45Map,
-	invariant46Combine,
-	invariant47TakeWhile,
-	invariant48Last,
-	invariant49Tap,
-	invariant50TakeUntil,
-	invariant51Find,
-	invariant52ElementAt,
-	invariant53WindowCount,
-	invariant54CleanupWitnessInValueDomain,
-	invariant55CleanupWitnessNotSentinel,
-	invariant56CleanupWitnessAccounting,
-	invariant57NoDepCascadeTerminalWhenGateFalse,
-	invariant58GraphDerivedSentinelAbsorption,
-	invariant59GraphDerivedKeepAliveCacheCurrent,
-	invariant60GraphDisposalCompleteness,
-	invariant61GraphBatchAtomicity,
-	invariant62GraphDerivedPathResolutionConstruction,
-	invariant63GraphNarrowWaistTopologyVisibility,
-	invariant64GraphDerivedKeepAliveEquivalence,
-	invariant65GraphDerivedMultiEmitArray,
-	invariant66GraphDerivedEmptyArrayResolved,
-	invariant67GraphNarrowWaistOptionsFlowThrough,
-	invariant68ChangesetDataEdgeAttribution,
-	invariant69ChangesetVersionMonotonic,
-	invariant70ChangesetBatchFramePairing,
-	invariant71ChangesetTopologyLifecycle,
-	invariant72SingleInvalidateSettles,
-	invariant73InvalidateMergeOrderIndependent,
-	invariant74ReplayBufferBounded,
-	invariant75LateSubscriberReceivesReplay,
-];
-
-// Enforce name uniqueness — the registry doubles as the LLM-readable contract
-// surface, and duplicate names would silently corrupt both the vitest test
-// list and any downstream enumeration.
-{
-	const seen = new Set<string>();
-	for (const inv of INVARIANTS) {
-		if (seen.has(inv.name)) {
-			throw new Error(`Duplicate invariant name in registry: ${inv.name}`);
-		}
-		seen.add(inv.name);
-	}
-}
diff --git a/packages/pure-ts/src/__tests__/properties/protocol-invariants.test.ts b/packages/pure-ts/src/__tests__/properties/protocol-invariants.test.ts
deleted file mode 100644
index 75d33d27..00000000
--- a/packages/pure-ts/src/__tests__/properties/protocol-invariants.test.ts
+++ /dev/null
@@ -1,45 +0,0 @@
-/**
- * Property-based protocol invariant suite (Project 1 from
- * `archive/docs/SESSION-rigor-infrastructure-plan.md`).
- *
- * This file is a thin runner — every invariant lives in `_invariants.ts`,
- * registered in the `INVARIANTS` array. To add a new property, append to that
- * registry; this file picks it up automatically.
- *
- * The deliberate split (registry + iterator) makes the invariant list
- * **enumerable** — LLMs composing higher-level blocks can read `_invariants.ts`
- * and answer "does my composition break any of these?" from a finite list,
- * not from operator-by-operator narrative docs.
- *
- * Reproducing a failure: set `FC_SEED=<seed>` (fast-check prints the seed in
- * every failure report) to replay the exact counterexample path.
- */
-
-import * as fc from "fast-check";
-import { describe, it } from "vitest";
-import { INVARIANTS } from "./_invariants.js";
-
-const SEED_FROM_ENV = process.env.FC_SEED ? Number(process.env.FC_SEED) : undefined;
-/**
- * Force-run invariants marked `openUntilSubstrateFix` in the registry. They
- * are skipped in normal CI runs because they encode behavior the substrate
- * does NOT yet guarantee (e.g. clean multi-dep push-on-subscribe). Set
- * `RUN_OPEN_INVARIANTS=1` locally to run them — failures are the documented
- * outcome until the referenced substrate fix lands.
- */
-const FORCE_RUN_OPEN = process.env.RUN_OPEN_INVARIANTS === "1";
-
-describe("protocol invariants (property-based)", () => {
-	for (const inv of INVARIANTS) {
-		const title = inv.openUntilSubstrateFix
-			? `${inv.name} — ${inv.specRef} (open until: ${inv.openUntilSubstrateFix})`
-			: `${inv.name} — ${inv.specRef}`;
-		const runner = inv.openUntilSubstrateFix && !FORCE_RUN_OPEN ? it.skip : it;
-		runner(title, () => {
-			fc.assert(inv.property(), {
-				numRuns: inv.numRuns ?? 100,
-				...(SEED_FROM_ENV !== undefined ? { seed: SEED_FROM_ENV } : {}),
-			});
-		});
-	}
-});
diff --git a/packages/pure-ts/src/__tests__/test-helpers.ts b/packages/pure-ts/src/__tests__/test-helpers.ts
deleted file mode 100644
index 59104741..00000000
--- a/packages/pure-ts/src/__tests__/test-helpers.ts
+++ /dev/null
@@ -1,104 +0,0 @@
-/**
- * Shared test utilities for subscribing to nodes and collecting messages.
- *
- * Single `collect` function with options covers all collection modes:
- * - batches (default) or flat individual messages
- * - with or without START handshake filtering
- */
-import { START } from "../core/messages.js";
-
-type Subscribable = { subscribe: (fn: (m: unknown) => void) => () => void };
-
-export type CollectOptions = {
-	/** Collect flat individual messages instead of batches. Default: false. */
-	flat?: boolean;
-	/** Include START handshake messages. Default: false (filters START). */
-	raw?: boolean;
-};
-
-type CollectBatchResult = { messages: unknown[][]; batches: unknown[][]; unsub: () => void };
-type CollectFlatResult = {
-	messages: [symbol, unknown?][];
-	msgs: [symbol, unknown?][];
-	unsub: () => void;
-};
-
-/**
- * Subscribe and collect messages from a node.
- *
- * @param node - The subscribable node.
- * @param opts - Collection options.
- * @returns `{ messages, unsub }` — `messages` is either `unknown[][]` (batches) or
- *   `[symbol, unknown?][]` (flat), depending on `opts.flat`.
- *
- * @example
- * // Default: batches, no START
- * const { messages, unsub } = collect(n);
- *
- * @example
- * // Flat messages, no START
- * const { messages, unsub } = collect(n, { flat: true });
- *
- * @example
- * // Batches including START
- * const { messages, unsub } = collect(n, { raw: true });
- */
-export function collect(
-	node: Subscribable,
-	opts: CollectOptions & { flat: true },
-): CollectFlatResult;
-export function collect(node: Subscribable, opts?: CollectOptions): CollectBatchResult;
-export function collect(
-	node: Subscribable,
-	opts?: CollectOptions,
-): CollectBatchResult | CollectFlatResult {
-	const flat = opts?.flat === true;
-	const raw = opts?.raw === true;
-
-	if (flat) {
-		const messages: [symbol, unknown?][] = [];
-		const unsub = node.subscribe((m) => {
-			for (const msg of m as [symbol, unknown?][]) {
-				if (raw || msg[0] !== START) messages.push(msg);
-			}
-		});
-		return { messages, msgs: messages, unsub };
-	}
-
-	const messages: unknown[][] = [];
-	const unsub = node.subscribe((msgs) => {
-		const filtered = raw
-			? (msgs as unknown[])
-			: (msgs as unknown[]).filter((m) => (m as [symbol, unknown])[0] !== START);
-		if (filtered.length > 0) messages.push(filtered);
-	});
-	return { messages, batches: messages, unsub };
-}
-
-/**
- * @deprecated Use `collect(node, { flat: true })` instead.
- */
-export function collectFlat(node: Subscribable) {
-	return collect(node, { flat: true });
-}
-
-/**
- * Collapse the raw `data: readonly (readonly unknown[] | undefined)[]` shape
- * passed to `GraphDerivedFn` / `GraphEffectFn` into per-dep latest scalars.
- *
- * For each dep `i`:
- * - If `data[i]` has at least one DATA value, returns the LAST one.
- * - Otherwise (dep not involved this wave, or RESOLVED), returns
- *   `ctx.prevData[i]` — the last DATA value from the prior wave.
- *
- * Mirrors the canonical scalar-read formula documented on `GraphDerivedFn`.
- * Tests that don't care about multi-emit semantics use this; tests that DO
- * care should index `data[i]` directly. The name reflects the collapse —
- * "latest of each dep" — not "all values."
- */
-export function latestVals(
-	data: readonly (readonly unknown[] | undefined)[],
-	ctx: { readonly prevData: readonly unknown[] },
-): readonly unknown[] {
-	return data.map((b, i) => (b != null && b.length > 0 ? b[b.length - 1] : ctx.prevData[i]));
-}
diff --git a/packages/pure-ts/src/__tests__/testing/assertions.test.ts b/packages/pure-ts/src/__tests__/testing/assertions.test.ts
deleted file mode 100644
index 139f2da5..00000000
--- a/packages/pure-ts/src/__tests__/testing/assertions.test.ts
+++ /dev/null
@@ -1,71 +0,0 @@
-/**
- * Tests for `src/testing/assertions.ts` — Lock 3.B helper.
- */
-
-import { describe, expect, it } from "vitest";
-import type { Messages } from "../../core/messages.js";
-import { COMPLETE, DATA, DIRTY, ERROR, RESOLVED, START } from "../../core/messages.js";
-import { assertDirtyPrecedesTerminalData } from "../../testing/index.js";
-
-describe("assertDirtyPrecedesTerminalData (Lock 3.B)", () => {
-	it("accepts a typical wave: DIRTY then DATA", () => {
-		const messages: Messages = [[DIRTY], [DATA, 1]];
-		expect(() => assertDirtyPrecedesTerminalData(messages)).not.toThrow();
-	});
-
-	it("accepts the P.25 carve-out: leading [RESOLVED] without DIRTY", () => {
-		const messages: Messages = [[RESOLVED], [DIRTY], [DATA, 1]];
-		expect(() => assertDirtyPrecedesTerminalData(messages)).not.toThrow();
-	});
-
-	it("rejects DATA without a preceding DIRTY", () => {
-		const messages: Messages = [[DATA, 1]];
-		expect(() => assertDirtyPrecedesTerminalData(messages)).toThrow(/P\.25/);
-	});
-
-	it("rejects RESOLVED that is not at the head", () => {
-		const messages: Messages = [
-			[DIRTY],
-			[DATA, 1],
-			// Mid-stream RESOLVED without a preceding DIRTY → violation.
-			[RESOLVED],
-		];
-		expect(() => assertDirtyPrecedesTerminalData(messages)).toThrow(/P\.25/);
-	});
-
-	it("counts DIRTY/settlement balance correctly across multi-wave streams", () => {
-		const messages: Messages = [[DIRTY], [DATA, 1], [DIRTY], [DATA, 2], [DIRTY], [RESOLVED]];
-		expect(() => assertDirtyPrecedesTerminalData(messages)).not.toThrow();
-	});
-
-	it("rejects more settlements than DIRTYs", () => {
-		const messages: Messages = [
-			[DIRTY],
-			[DATA, 1],
-			[DATA, 2], // second DATA without a second DIRTY
-		];
-		expect(() => assertDirtyPrecedesTerminalData(messages)).toThrow(/P\.25/);
-	});
-
-	it("ignores ERROR / COMPLETE / START in the balance check", () => {
-		const messages: Messages = [
-			[START],
-			[DIRTY],
-			[DATA, 1],
-			[ERROR, new Error("boom")],
-			[COMPLETE],
-		];
-		expect(() => assertDirtyPrecedesTerminalData(messages)).not.toThrow();
-	});
-
-	it("error message includes a window of surrounding messages for diagnostics", () => {
-		const messages: Messages = [[DIRTY], [DATA, 1], [DATA, 2], [DIRTY], [DATA, 3]];
-		try {
-			assertDirtyPrecedesTerminalData(messages);
-			expect.fail("expected to throw");
-		} catch (err) {
-			expect((err as Error).message).toMatch(/Window:/);
-			expect((err as Error).message).toMatch(/index 2/);
-		}
-	});
-});
diff --git a/packages/pure-ts/src/core/_internal/ring-buffer.ts b/packages/pure-ts/src/core/_internal/ring-buffer.ts
deleted file mode 100644
index 36680249..00000000
--- a/packages/pure-ts/src/core/_internal/ring-buffer.ts
+++ /dev/null
@@ -1,99 +0,0 @@
-/**
- * Fixed-capacity ring buffer — O(1) push and drop-oldest eviction.
- *
- * Used by `Graph._traceRing` (reasoning trace), `reactiveLog` (append-only
- * log backend), and `reactiveSink` (drop-oldest backpressure buffer). One
- * implementation, three use sites.
- *
- * @module
- * @internal
- */
-
-/**
- * Fixed-capacity ring buffer. Once `capacity` entries are stored, subsequent
- * `push` calls evict the oldest entry (drop-oldest / FIFO eviction).
- *
- * Operations:
- * - `push(item)` — O(1).
- * - `shift()` — O(1) remove oldest (returns `undefined` when empty).
- * - `at(i)` — O(1) index lookup, with Python-style negative indexing.
- * - `toArray()` — O(n) materialize in insertion order.
- * - `clear()` — O(1) reset to empty.
- *
- * Not thread-safe; JS semantics assumed (single-threaded within a sync call).
- */
-export class RingBuffer<T> {
-	private buf: (T | undefined)[];
-	private head = 0;
-	private _size = 0;
-
-	constructor(private capacity: number) {
-		if (!Number.isInteger(capacity) || capacity <= 0) {
-			throw new Error(`RingBuffer capacity must be a positive integer (got ${capacity})`);
-		}
-		this.buf = new Array(capacity);
-	}
-
-	/** Current number of stored entries. */
-	get size(): number {
-		return this._size;
-	}
-
-	/** Configured maximum before drop-oldest eviction fires. */
-	get maxSize(): number {
-		return this.capacity;
-	}
-
-	/**
-	 * Append an item. If size equals capacity, drops the oldest entry and
-	 * advances the head pointer.
-	 */
-	push(item: T): void {
-		const idx = (this.head + this._size) % this.capacity;
-		this.buf[idx] = item;
-		if (this._size < this.capacity) this._size++;
-		else this.head = (this.head + 1) % this.capacity;
-	}
-
-	/** Remove and return the oldest entry; `undefined` when empty. */
-	shift(): T | undefined {
-		if (this._size === 0) return undefined;
-		const item = this.buf[this.head];
-		this.buf[this.head] = undefined;
-		this.head = (this.head + 1) % this.capacity;
-		this._size--;
-		return item;
-	}
-
-	/**
-	 * O(1) index lookup. Negative indices count from the tail (Python-style).
-	 * Returns `undefined` for out-of-range.
-	 */
-	at(i: number): T | undefined {
-		if (this._size === 0) return undefined;
-		const n = i < 0 ? this._size + i : i;
-		if (n < 0 || n >= this._size) return undefined;
-		return this.buf[(this.head + n) % this.capacity];
-	}
-
-	/**
-	 * Materialize the contents in insertion order (oldest → newest).
-	 * Returns a new array each call.
-	 */
-	toArray(): T[] {
-		const result: T[] = new Array(this._size);
-		for (let i = 0; i < this._size; i++) {
-			result[i] = this.buf[(this.head + i) % this.capacity]!;
-		}
-		return result;
-	}
-
-	/** Reset to empty. Storage slots are released so held refs can GC. */
-	clear(): void {
-		for (let i = 0; i < this._size; i++) {
-			this.buf[(this.head + i) % this.capacity] = undefined;
-		}
-		this.head = 0;
-		this._size = 0;
-	}
-}
diff --git a/packages/pure-ts/src/core/_internal/sizeof.ts b/packages/pure-ts/src/core/_internal/sizeof.ts
deleted file mode 100644
index c3db3425..00000000
--- a/packages/pure-ts/src/core/_internal/sizeof.ts
+++ /dev/null
@@ -1,196 +0,0 @@
-/**
- * Approximate in-memory size estimation for arbitrary JS values.
- *
- * Iterative walk with cycle detection via `WeakSet`. V8-tuned overhead
- * heuristics. Not exact — approximate enough for profiling and hotspot
- * detection.
- *
- * Use cases: `graphProfile` (per-node value size), reactive data structure
- * memory audits, heuristic cache admission.
- *
- * @module
- */
-
-/** Approximate per-type overhead in bytes (V8 heuristics). */
-export const OVERHEAD = {
-	object: 56,
-	array: 64,
-	string: 40, // header; content added separately
-	number: 8,
-	boolean: 4,
-	null: 0,
-	undefined: 0,
-	symbol: 40,
-	bigint: 16, // base; scales with digit count (see `_bigintSize`)
-	function: 120,
-	map: 72,
-	set: 72,
-	mapEntry: 40,
-	setEntry: 24,
-	date: 24,
-	regexp: 48,
-	error: 64,
-	url: 80,
-	promise: 48,
-	weakmap: 40,
-	weakset: 40,
-} as const;
-
-/**
- * Optional user hook. Declare a `sizeof` symbol key on any object to return
- * a precomputed size (in bytes); the walker will honor it and skip recursion.
- *
- * @example
- * ```ts
- * const SIZEOF = Symbol.for("sizeof");
- * class MyCache { [SIZEOF]() { return this.bytes; } }
- * ```
- */
-export const SIZEOF_SYMBOL = Symbol.for("sizeof");
-
-/**
- * Estimate the approximate retained memory (in bytes) of a JS value.
- *
- * Handles primitives, plain objects, arrays, Maps, Sets, ArrayBuffers +
- * TypedArrays (shared-buffer dedup), Date, RegExp, Error, URL, Promise,
- * WeakMap, WeakSet, nested combinations. Cyclic refs are counted once.
- *
- * @param value - The value to measure.
- * @returns Approximate size in bytes.
- */
-export function sizeof(value: unknown): number {
-	const seen = new WeakSet<object>();
-	const seenBuffers = new WeakSet<ArrayBufferLike>();
-	// Iterative walk via explicit stack — avoids blowing the call stack on
-	// deeply nested values (linked lists, AST nodes, deep JSON).
-	const stack: unknown[] = [value];
-	let total = 0;
-	while (stack.length > 0) {
-		const v = stack.pop();
-		total += _shallowSize(v, seen, seenBuffers, stack);
-	}
-	return total;
-}
-
-/** Shallow size of `v`; pushes children onto `stack` for iterative traversal. */
-function _shallowSize(
-	value: unknown,
-	seen: WeakSet<object>,
-	seenBuffers: WeakSet<ArrayBufferLike>,
-	stack: unknown[],
-): number {
-	if (value === null || value === undefined) return 0;
-
-	const t = typeof value;
-	switch (t) {
-		case "number":
-			return OVERHEAD.number;
-		case "boolean":
-			return OVERHEAD.boolean;
-		case "string":
-			return OVERHEAD.string + (value as string).length * 2;
-		case "bigint":
-			return OVERHEAD.bigint + _bigintSize(value as bigint);
-		case "symbol":
-			return OVERHEAD.symbol;
-		case "function":
-			if (seen.has(value as object)) return 0;
-			seen.add(value as object);
-			return OVERHEAD.function;
-		case "undefined":
-			return 0;
-	}
-
-	const obj = value as object;
-	if (seen.has(obj)) return 0;
-	seen.add(obj);
-
-	// User-supplied size hook wins — `Symbol.for("sizeof")` method on the
-	// object returns an exact byte count and we skip recursion.
-	const hook = (obj as Record<symbol, unknown>)[SIZEOF_SYMBOL];
-	if (typeof hook === "function") {
-		try {
-			const reported = (hook as () => unknown).call(obj);
-			if (typeof reported === "number" && Number.isFinite(reported)) return reported;
-		} catch {
-			/* ignore — fall through to default estimator */
-		}
-	}
-
-	if (obj instanceof Date) return OVERHEAD.date;
-	if (obj instanceof RegExp) return OVERHEAD.regexp + obj.source.length * 2;
-	if (obj instanceof Error) {
-		const m = obj.message ? obj.message.length * 2 : 0;
-		const s = obj.stack ? obj.stack.length * 2 : 0;
-		return OVERHEAD.error + m + s;
-	}
-	if (typeof URL !== "undefined" && obj instanceof URL) {
-		return OVERHEAD.url + obj.href.length * 2;
-	}
-	if (typeof Promise !== "undefined" && obj instanceof Promise) {
-		return OVERHEAD.promise;
-	}
-	if (obj instanceof WeakMap) return OVERHEAD.weakmap;
-	if (obj instanceof WeakSet) return OVERHEAD.weakset;
-
-	if (obj instanceof Map) {
-		let size = OVERHEAD.map;
-		for (const [k, v] of obj) {
-			size += OVERHEAD.mapEntry;
-			stack.push(k);
-			stack.push(v);
-		}
-		return size;
-	}
-
-	if (obj instanceof Set) {
-		let size = OVERHEAD.set;
-		for (const v of obj) {
-			size += OVERHEAD.setEntry;
-			stack.push(v);
-		}
-		return size;
-	}
-
-	if (Array.isArray(obj)) {
-		const size = OVERHEAD.array + obj.length * 8;
-		for (const item of obj) stack.push(item);
-		return size;
-	}
-
-	// ArrayBuffer — count once per buffer (multi-view dedup via `seenBuffers`).
-	if (obj instanceof ArrayBuffer) {
-		if (seenBuffers.has(obj)) return 0;
-		seenBuffers.add(obj);
-		return obj.byteLength;
-	}
-	if (ArrayBuffer.isView(obj)) {
-		const view = obj as { byteLength: number; buffer: ArrayBufferLike };
-		if (seenBuffers.has(view.buffer)) return 48; // view header only
-		seenBuffers.add(view.buffer);
-		// Charge the full underlying buffer — a small view over a large
-		// buffer still retains all of it. Add the view header on top.
-		return view.buffer.byteLength + 48;
-	}
-
-	// Plain object — sum key overhead + recurse into values.
-	let size = OVERHEAD.object;
-	const keys = Object.keys(obj);
-	for (const key of keys) {
-		size += OVERHEAD.string + key.length * 2;
-		try {
-			stack.push((obj as Record<string, unknown>)[key]);
-		} catch {
-			/* getter throw — skip this key */
-		}
-	}
-	return size;
-}
-
-/** BigInt digit-count-based sizing: each ~32-bit limb ≈ 8 bytes. */
-function _bigintSize(n: bigint): number {
-	const abs = n < 0n ? -n : n;
-	if (abs === 0n) return 0;
-	const bits = abs.toString(2).length;
-	return Math.ceil(bits / 32) * 8;
-}
diff --git a/packages/pure-ts/src/core/_internal/timer.ts b/packages/pure-ts/src/core/_internal/timer.ts
deleted file mode 100644
index 9b869317..00000000
--- a/packages/pure-ts/src/core/_internal/timer.ts
+++ /dev/null
@@ -1,53 +0,0 @@
-/**
- * Creates a resettable deadline timer for internal timeout, retry, and rate-limiting use.
- *
- * @remarks **Centralised primitive:** wraps `setTimeout`/`clearTimeout` with a generation guard
- * so that stale callbacks never fire after `cancel()` or a new `start()`.
- *
- * @remarks **Spec §5.10 exception:** resilience operators (`timeout`, `retry`, `rateLimiter`)
- * need raw timers — `fromTimer` creates a new Node per reset, which is too heavy here.
- * Lives in `src/extra/` (not `src/core/`) because it is a documented escape hatch from
- * the protocol-pure core layer.
- *
- * @example
- * ```ts
- * import { ResettableTimer } from "@graphrefly/pure-ts";
- *
- * const timer = new ResettableTimer();
- * timer.start(1000, () => console.log("fired"));
- * timer.cancel();          // cancels before firing
- * timer.start(500, () => console.log("new deadline"));
- * console.log(timer.pending); // true
- * ```
- *
- * @category extra
- */
-export class ResettableTimer {
-	private _timer: ReturnType<typeof setTimeout> | undefined;
-	private _gen = 0;
-
-	/** Schedule callback after delayMs. Cancels any pending timer. */
-	start(delayMs: number, callback: () => void): void {
-		this.cancel();
-		this._gen += 1;
-		const gen = this._gen;
-		this._timer = setTimeout(() => {
-			this._timer = undefined;
-			if (gen !== this._gen) return;
-			callback();
-		}, delayMs);
-	}
-
-	/** Cancel the pending timer (if any). */
-	cancel(): void {
-		if (this._timer !== undefined) {
-			clearTimeout(this._timer);
-			this._timer = undefined;
-		}
-	}
-
-	/** Whether a timer is currently pending. */
-	get pending(): boolean {
-		return this._timer !== undefined;
-	}
-}
diff --git a/packages/pure-ts/src/core/actor.ts b/packages/pure-ts/src/core/actor.ts
deleted file mode 100644
index 09879da1..00000000
--- a/packages/pure-ts/src/core/actor.ts
+++ /dev/null
@@ -1,35 +0,0 @@
-/**
- * Who is performing an operation (attribution + ABAC input).
- *
- * @see GRAPHREFLY-SPEC — roadmap Phase 1.5 (Actor & Guard).
- */
-export type Actor = {
-	type: "human" | "llm" | "wallet" | "system" | string;
-	id: string;
-} & Record<string, unknown>;
-
-/** Default actor when none is passed ({@link normalizeActor}). */
-export const DEFAULT_ACTOR: Actor = { type: "system", id: "" };
-
-/**
- * Fills missing `type` / `id` on an actor and returns {@link DEFAULT_ACTOR} when input is undefined.
- *
- * @param actor - Optional partial actor from a transport hint.
- * @returns A normalized `Actor` safe to pass to guards and graph APIs.
- *
- * @example
- * ```ts
- * import { normalizeActor } from "@graphrefly/pure-ts";
- *
- * normalizeActor({ type: "human", id: "u1" });
- * ```
- */
-export function normalizeActor(actor?: Actor): Actor {
-	if (actor == null) return DEFAULT_ACTOR;
-	const { type, id, ...rest } = actor;
-	return {
-		type: type ?? "system",
-		id: id ?? "",
-		...rest,
-	} as Actor;
-}
diff --git a/packages/pure-ts/src/core/batch.ts b/packages/pure-ts/src/core/batch.ts
deleted file mode 100644
index 946e2f76..00000000
--- a/packages/pure-ts/src/core/batch.ts
+++ /dev/null
@@ -1,453 +0,0 @@
-/**
- * Batch deferral for tier-3+ messages, plus per-node emit coalescing inside
- * explicit `batch()` scopes.
- *
- * **Canonical invariant:** GRAPHREFLY-SPEC.md §1.3.7 — inside a batch,
- * tier 0–2 signals propagate immediately; tier 3 (DATA/RESOLVED) and tier 4
- * (INVALIDATE) form one settle slice; tier 5 (COMPLETE/ERROR) and tier 6
- * (TEARDOWN) follow in ascending phase order after the outermost `batch()`
- * callback returns.
- *
- * **Per-node emit coalescing (Bug 2 fix, 2026-04-17).** Inside an explicit
- * `batch()` scope, consecutive emissions from the same node accumulate in
- * `NodeImpl._batchPendingMessages` (see JSDoc there) instead of each producing
- * a separate downstream wave. K `.emit()` calls to the same source collapse to
- * one coalesced `downWithBatch` call per child edge at batch end. Outside batch
- * (or during drain), coalescing does NOT apply — each emit produces its own wave.
- *
- * **Phase vocabulary (post-DS-13.5.A renumbering):**
- * - Phase 1 = tiers 0–2 — immediate, never queued.
- * - Phase 2 = tier 3 (DATA/RESOLVED) + tier 4 (INVALIDATE) — {@link drainPhase2}.
- *   The "settle slice." INVALIDATE is settle-class (decrements
- *   `_dirtyDepCount` like RESOLVED) so it shares the same drain queue —
- *   one batch-frame == one wave settlement, regardless of whether the
- *   wave carries DATA, RESOLVED, INVALIDATE, or any mix across nodes.
- * - Phase 3 = tier 5 (COMPLETE/ERROR) — {@link drainPhase3}. Terminal signals.
- * - Phase 4 = tier 6 (TEARDOWN) — {@link drainPhase4}. Unified teardown deferral.
- *
- * **Q16 atomicity carve-out (DS-13.5.A).** When a single emit's framed wave
- * carries BOTH tier-5 (COMPLETE/ERROR) AND tier-6 (TEARDOWN) — the shape
- * Q16 produces by auto-prefixing a synthetic `[COMPLETE]` before
- * user-emitted `[TEARDOWN]` on a non-terminal node — the entire
- * terminal+teardown slice drains together at phase 4, not split across
- * phases 3 and 4. Splitting would let the dep callback's settlement
- * check fire between COMPLETE delivery and TEARDOWN delivery,
- * re-establishing cleanup hooks that then double-fire on TEARDOWN
- * (regression originally surfaced by `Graph.destroy` cleanup-fires-once
- * tests). Standalone COMPLETE/ERROR emissions (no TEARDOWN in the same
- * wave) still drain at phase 3 normally.
- *
- * Drain rule: fire any pending flush hooks first, then the lowest non-empty
- * phase. Re-enqueues during drain (and hooks registered by reentrant batches
- * inside subscriber callbacks) bump the loop back to the top so newly-added
- * hooks and closures get processed.
- */
-
-import type { Messages } from "./messages.js";
-
-/**
- * Lock 2.F′ (Phase 13.6.A): the drain-iteration cap is read from
- * `cfg.maxBatchDrainIterations` via a getter callback that `node.ts`
- * registers at module-init time. The callback indirection avoids the
- * `batch.ts` → `node.ts` import cycle (`node.ts` imports `batch.ts`'s
- * `downWithBatch` / `isBatching`).
- *
- * Default `() => 1000` is in force until `node.ts` registers its getter
- * (which reads `defaultConfig.maxBatchDrainIterations`). Test isolation
- * with `new GraphReFlyConfig(...)` does NOT route through the global
- * drain cap — batch deferral is process-global, so the cap is necessarily
- * a process-global setting tied to `defaultConfig`.
- */
-let _maxBatchDrainIterationsGetter: () => number = () => 1000;
-export function _setMaxBatchDrainIterationsGetter(getter: () => number): void {
-	_maxBatchDrainIterationsGetter = getter;
-}
-
-let batchDepth = 0;
-let flushInProgress = false;
-
-/** Tier 3 (DATA/RESOLVED) + tier 4 (INVALIDATE) deferral queue — settle slice, drained first. */
-const drainPhase2: Array<() => void> = [];
-/** Tier 5 (COMPLETE/ERROR) deferral queue — drained after the settle slice. */
-const drainPhase3: Array<() => void> = [];
-/** Tier 6 (TEARDOWN) deferral queue — drained last. */
-const drainPhase4: Array<() => void> = [];
-
-/**
- * Per-batch hook pairs. Each entry is registered by a node the first time
- * it touches state inside an explicit `batch()` scope. The pair carries
- * both the success-path `flush` (deliver accumulated messages) and the
- * throw-path `rollback` (restore pre-batch state, do NOT deliver).
- *
- * **D282 — R4.3.2 throw rollback (locked 2026-05-23).** On success drain,
- * `flush` is invoked at the head of `drainPending`, before the standard
- * tier-3/4/5 drain queues — it calls `downWithBatch` with the node's
- * accumulated multi-message batch, which enqueues the tier-3+ portion
- * into `drainPhase2/3/4` for the standard loop. On `batch()` throw,
- * `rollback` is invoked INSTEAD of `flush` (the pre-D282 implementation
- * fired `flush` on both paths and relied on a same-finally drainPhase
- * clear — that was unsound because at the catch-path `batchDepth === 0`
- * and `flushInProgress === false`, so the flush's `downWithBatch` call
- * dispatched synchronously, leaking the wave to subscribers; see the
- * 2026-05-22 Slice A revert + the C1 reopen entry in
- * `docs/optimizations.md`).
- *
- * The paired registry converges TS to the Rust substrate's pre-existing
- * `discard_wave_cleanup` + `restore_wave_cache_snapshots` semantic at
- * `graphrefly-rs/crates/graphrefly-core/src/batch.rs:3693`. Subscriber
- * wire shape on throw is now parity-observable (cross-track-ledger §2
- * C1 row).
- *
- * Inner batches inside `flushInProgress` SKIP rollback per
- * cross-language decision A4 — the existing `!flushInProgress` gate in
- * `batch()`'s catch path preserves that.
- */
-const batchHooks: Array<{ flush: () => void; rollback: () => void }> = [];
-
-/**
- * Returns whether the current call stack is inside a batch scope **or** while
- * a deferred drain is in progress. Nested `downWithBatch` calls during drain
- * still defer (they bump the drain loop).
- */
-export function isBatching(): boolean {
-	return batchDepth > 0 || flushInProgress;
-}
-
-/**
- * Returns whether the current call stack is inside an **explicit** `batch()`
- * scope. Excludes `flushInProgress` — i.e. emissions that happen during a
- * drain (e.g. inside a fn callback) are NOT explicitly batched and should
- * not trigger per-node coalescing (Bug 2).
- */
-export function isExplicitlyBatching(): boolean {
-	return batchDepth > 0;
-}
-
-/**
- * Register a paired flush/rollback hook for the current batch. Used by
- * `NodeImpl._emit` on first state-touch inside an explicit `batch()` scope.
- *
- * - **Success drain**: `flush` fires at the head of `drainPending` — the
- *   node delivers its accumulated multi-message batch via `downWithBatch`.
- * - **Outermost throw (`batchDepth === 0 && !flushInProgress`)**:
- *   `rollback` fires instead — the node restores cache/status/versioning
- *   from `_preBatchSnapshot` and clears `_batchPendingMessages` WITHOUT
- *   dispatching downstream. R4.3.2.
- * - **Inner throw under `flushInProgress` (A4 carve-out)**: neither
- *   `flush` nor `rollback` fires at the inner-throw boundary — the inner
- *   batch's accumulators stay live; the outer drain's continued loop
- *   will pick up `flush` per the standard success path.
- *
- * Called outside any batch context (defensive — shouldn't happen in
- * practice because `_emit`'s registration is gated on
- * `isExplicitlyBatching()`), `flush` fires immediately since there's no
- * drain coming.
- */
-export function registerBatchHook(hook: { flush: () => void; rollback: () => void }): void {
-	if (batchDepth > 0) {
-		batchHooks.push(hook);
-	} else {
-		hook.flush();
-	}
-}
-
-/**
- * Legacy single-hook API for **flush-only** coalescers (external
- * bystanders that aggregate downstream changes — e.g.
- * `graph.observe({ reactive: true })`'s changeset flusher,
- * `describe({ reactive: true })`'s recompute trigger, the topology-emit
- * coalescer). These callers DON'T own per-node pre-batch state, so a
- * throw-rollback path is a no-op for them.
- *
- * Thin shim over {@link registerBatchHook} that pairs the provided
- * `hook` (used as `flush`) with a no-op `rollback`. Net effect on the
- * throw path: nothing fires; the external coalescer's accumulated state
- * stays as-is. Since the coalescer's accumulation is normally driven by
- * a SINK callback on per-node DATA, and per-node DATA was rolled back
- * before this hook would fire, the coalescer's per-call accumulator is
- * typically empty in the rollback scenario anyway — the no-op rollback
- * is the right semantic (no false flush of an empty changeset).
- *
- * @deprecated Use {@link registerBatchHook} for new code so the
- * rollback hook is explicit. Kept for the in-tree graph-level coalescers
- * (`graph.ts` changesets / reactive-describe / reactive-observe /
- * topology-emitter) which are flush-only by design.
- */
-export function registerBatchFlushHook(hook: () => void): void {
-	registerBatchHook({
-		flush: hook,
-		rollback: () => {
-			/* flush-only coalescer: rollback is a no-op */
-		},
-	});
-}
-
-/**
- * Runs `fn` inside a batch scope. Nested `batch()` calls share one deferral
- * queue. If `fn` throws, deferred work for the outer frame is discarded
- * (unless a drain is already in progress — cross-language decision A4).
- */
-export function batch(fn: () => void): void {
-	batchDepth += 1;
-	let threw = false;
-	let userError: unknown;
-	try {
-		fn();
-	} catch (e) {
-		threw = true;
-		userError = e;
-		throw e;
-	} finally {
-		batchDepth -= 1;
-		if (batchDepth === 0) {
-			if (threw) {
-				if (!flushInProgress) {
-					// D282 R4.3.2: fire the per-node ROLLBACK hooks (NOT
-					// flush). Each rollback restores the node's pre-batch
-					// cache/status/versioning/wave-flags/replayBuffer state
-					// from `_preBatchSnapshot` and clears
-					// `_batchPendingMessages` without dispatching. The
-					// drainPhase queues at this point hold any deferred
-					// closures from re-entrant downWithBatch calls during
-					// `fn`; clear them too (Rust's `discard_wave_cleanup`
-					// drops the analogous `pending_notify`).
-					//
-					// /qa F6: collect rollback errors and aggregate-throw
-					// AFTER the originating user throw re-propagates. A
-					// buggy rollback (e.g. a malformed snapshot triggering
-					// an exception in `_rollbackBatchPending`) MUST surface
-					// — silent best-effort masking was the Slice-A reviewer
-					// finding #5 anti-pattern that recurred here pre-/qa.
-					// Same shape as `drainPending`'s error-collection (line
-					// 264 below).
-					const hooks = batchHooks.splice(0);
-					const rollbackErrors: unknown[] = [];
-					for (const h of hooks) {
-						try {
-							h.rollback();
-						} catch (e) {
-							rollbackErrors.push(e);
-						}
-					}
-					drainPhase2.length = 0;
-					drainPhase3.length = 0;
-					drainPhase4.length = 0;
-					if (rollbackErrors.length > 0) {
-						// Wrap as a `cause` on the originating user error so
-						// the user-throw remains the primary signal (callers
-						// `expect.rejects.toThrow(/userError/)` still match).
-						// Aggregated rollback errors are inspectable via
-						// `(err as Error).cause` per the D4 wrap pattern.
-						const cause =
-							rollbackErrors.length === 1
-								? rollbackErrors[0]
-								: new AggregateError(rollbackErrors, "batch rollback: multiple hooks threw");
-						if (userError instanceof Error) {
-							(userError as Error & { cause?: unknown }).cause = cause;
-						} else {
-							// Non-Error user throw: log the rollback errors
-							// to surface them (best-effort but loud, not
-							// silent). The user's throw still propagates as
-							// the primary signal.
-							console.error("batch rollback hooks threw during throw path:", cause);
-						}
-					}
-				}
-				// flushInProgress branch (A4 carve-out): inner-batch throw
-				// re-propagates WITHOUT rollback. The inner batch's hook
-				// entries stay in `batchHooks` and will fire `flush` on the
-				// outer drain's next iteration. This is the "commit-on-
-				// outer-success" semantic exercised by Case 11 of the
-				// `scenarios/core/batch-throw-rollback.test.ts` parity suite.
-			} else {
-				drainPending();
-			}
-		}
-	}
-}
-
-function drainPending(): void {
-	const ownsFlush = !flushInProgress;
-	if (ownsFlush) flushInProgress = true;
-
-	const errors: unknown[] = [];
-
-	let iterations = 0;
-	try {
-		// Loop while EITHER tier-3+ deferred work OR pending batch hooks exist.
-		// Hooks can be re-registered mid-drain by reentrant `batch()` calls
-		// inside subscriber callbacks; checking `batchHooks` each iteration
-		// (not just before the loop) ensures those late hooks fire too.
-		while (
-			drainPhase2.length > 0 ||
-			drainPhase3.length > 0 ||
-			drainPhase4.length > 0 ||
-			(ownsFlush && batchHooks.length > 0)
-		) {
-			// Fire any pending batch hooks' FLUSH side FIRST so their
-			// downWithBatch calls enqueue tier-3+ work into drainPhase
-			// before we process it. (Rollback is only fired on the
-			// throw path in `batch()`'s catch.)
-			if (ownsFlush && batchHooks.length > 0) {
-				const hooks = batchHooks.splice(0);
-				for (const h of hooks) {
-					try {
-						h.flush();
-					} catch (e) {
-						errors.push(e);
-					}
-				}
-				continue; // restart loop — hooks may have enqueued tier-3+ work or more hooks
-			}
-			iterations += 1;
-			const maxIterations = _maxBatchDrainIterationsGetter();
-			if (iterations > maxIterations) {
-				// Lock 2.F′ broadens the diagnostic: capture which phase queue
-				// is non-empty + total queued size at throw + the configured
-				// limit so callers tracking down a reactive cycle see what
-				// queue is unbounded.
-				const phase = drainPhase2.length > 0 ? 2 : drainPhase3.length > 0 ? 3 : 4;
-				const queueSizeAtThrow = drainPhase2.length + drainPhase3.length + drainPhase4.length;
-				drainPhase2.length = 0;
-				drainPhase3.length = 0;
-				drainPhase4.length = 0;
-				const err = new Error(
-					`batch drain exceeded cfg.maxBatchDrainIterations (${maxIterations}) at phase ${phase} — likely a reactive cycle`,
-				);
-				(err as Error & { detail?: unknown }).detail = {
-					phase,
-					queueSizeAtThrow,
-					configuredLimit: maxIterations,
-				};
-				throw err;
-			}
-			// Always drain the lowest non-empty phase. Re-enqueues at any level
-			// cause the next iteration to restart from phase 2 if needed.
-			const queue =
-				drainPhase2.length > 0 ? drainPhase2 : drainPhase3.length > 0 ? drainPhase3 : drainPhase4;
-			const ops = queue.splice(0);
-			for (const run of ops) {
-				try {
-					run();
-				} catch (e) {
-					errors.push(e);
-				}
-			}
-		}
-	} finally {
-		if (ownsFlush) flushInProgress = false;
-	}
-
-	if (errors.length === 1) throw errors[0];
-	if (errors.length > 1) {
-		throw new AggregateError(errors, "batch drain: multiple callbacks threw");
-	}
-}
-
-/**
- * Deliver pre-sorted messages through `sink` with tier-based deferral applied.
- *
- * `messages` MUST be in ascending tier order (produced by `_frameBatch` in
- * `node.ts`); the walker exploits that invariant to find phase cuts in one
- * pass without re-sorting.
- *
- * Behavior (post-DS-13.5.A tier renumbering):
- * - Tier 0–2 — delivered synchronously.
- * - Tier 3 (DATA/RESOLVED) — deferred to {@link drainPhase2} when batching.
- * - Tier 4 (INVALIDATE) — deferred to {@link drainPhase2} alongside the value
- *   settlements (the "settle slice" — INVALIDATE settles a wave so it must
- *   land in the same drain phase as DATA/RESOLVED).
- * - Tier 5 (COMPLETE/ERROR) — deferred to {@link drainPhase3} when batching.
- * - Tier 6 (TEARDOWN) — deferred to {@link drainPhase4} when batching.
- *
- * Tier-classification uses the caller-supplied `tierOf` so that batch stays
- * decoupled from `GraphReFlyConfig`. NodeImpl passes `config.tierOf` (a
- * pre-bound closure built once in the config constructor) at the emit site;
- * alternate configs can pass their own lookup.
- */
-export function downWithBatch(
-	sink: (messages: Messages) => void,
-	messages: Messages,
-	tierOf: (t: symbol) => number,
-): void {
-	if (messages.length === 0) return;
-
-	// Fast path: single message (hot in propagation).
-	if (messages.length === 1) {
-		const tier = tierOf(messages[0][0]);
-		if (tier < 3 || !isBatching()) {
-			sink(messages);
-			return;
-		}
-		// tier 3 (DATA/RESOLVED) and tier 4 (INVALIDATE) share drainPhase2 —
-		// one settle slice. tier 5 → drainPhase3 (terminal). tier ≥ 6 → drainPhase4 (TEARDOWN).
-		const queue = tier >= 6 ? drainPhase4 : tier === 5 ? drainPhase3 : drainPhase2;
-		queue.push(() => sink(messages));
-		return;
-	}
-
-	// Multi-message: walk once over pre-sorted input, find phase cuts.
-	// Monotone tier order means `phase2Start <= phase3Start <= phase4Start`.
-	const n = messages.length;
-	let phase2Start = n;
-	let phase3Start = n;
-	let phase4Start = n;
-
-	let i = 0;
-	while (i < n && tierOf(messages[i][0]) < 3) i++;
-	phase2Start = i;
-	// Phase 2 (settle slice): tier 3 DATA/RESOLVED + tier 4 INVALIDATE.
-	while (i < n && tierOf(messages[i][0]) <= 4) i++;
-	phase3Start = i;
-	// Phase 3 (terminal): tier 5 COMPLETE/ERROR.
-	while (i < n && tierOf(messages[i][0]) === 5) i++;
-	phase4Start = i;
-	// Anything from phase4Start..n has tier >= 6 (TEARDOWN).
-
-	const batching = isBatching();
-
-	// DS-13.5.A Q16 atomicity: Q16 auto-precedes TEARDOWN with [COMPLETE].
-	// Splitting that pair across two sink calls lets fn re-run between them
-	// (the dep callback's settlement check sees `_hasNewTerminal=true` after
-	// COMPLETE delivery and falls through to `_execFn`, which re-establishes
-	// cleanup that then fires again on TEARDOWN). Keep COMPLETE/ERROR +
-	// TEARDOWN atomic so the terminal lifecycle pair is observed as one
-	// logical wave — applies to both sync delivery and in-batch deferred
-	// delivery (push as a single op into the latest phase queue).
-	if (phase4Start > phase3Start && n > phase4Start) {
-		if (phase2Start > 0) sink(messages.slice(0, phase2Start));
-		if (phase3Start > phase2Start) {
-			const phase2 = messages.slice(phase2Start, phase3Start);
-			if (batching) drainPhase2.push(() => sink(phase2));
-			else sink(phase2);
-		}
-		const terminalAndTeardown = messages.slice(phase3Start, n);
-		if (batching) drainPhase4.push(() => sink(terminalAndTeardown));
-		else sink(terminalAndTeardown);
-		return;
-	}
-
-	if (phase2Start > 0) {
-		// Immediate tier 0–2 region.
-		const immediate = messages.slice(0, phase2Start);
-		sink(immediate);
-	}
-
-	if (phase3Start > phase2Start) {
-		const phase2 = messages.slice(phase2Start, phase3Start);
-		if (batching) drainPhase2.push(() => sink(phase2));
-		else sink(phase2);
-	}
-
-	if (phase4Start > phase3Start) {
-		const phase3 = messages.slice(phase3Start, phase4Start);
-		if (batching) drainPhase3.push(() => sink(phase3));
-		else sink(phase3);
-	}
-
-	if (n > phase4Start) {
-		const phase4 = messages.slice(phase4Start, n);
-		if (batching) drainPhase4.push(() => sink(phase4));
-		else sink(phase4);
-	}
-}
diff --git a/packages/pure-ts/src/core/clock.ts b/packages/pure-ts/src/core/clock.ts
deleted file mode 100644
index 6ac28fde..00000000
--- a/packages/pure-ts/src/core/clock.ts
+++ /dev/null
@@ -1,30 +0,0 @@
-/**
- * Centralised timestamp utilities.
- *
- * Convention: all graphrefly-ts timestamps use nanoseconds (`_ns` suffix).
- *
- * - {@link monotonicNs} — monotonic clock (ordering, durations, timeline events).
- * - {@link wallClockNs} — wall-clock (mutation attribution, cron emission).
- *
- * **Precision limits (JS platform):**
- *
- * - `monotonicNs`: effective ~microsecond precision. `performance.now()` returns
- *   milliseconds with ~5µs resolution; the last 3 digits of the nanosecond value
- *   are always zero. Python's `time.monotonic_ns()` gives true nanoseconds.
- *
- * - `wallClockNs`: ~256ns precision loss at current epoch. `Date.now() * 1e6`
- *   produces values around 1.8×10¹⁸ which exceed IEEE 754's 2⁵³ safe integer
- *   limit. Python's `time.time_ns()` (arbitrary-precision `int`) has no loss.
- *   In practice this is irrelevant — JS is single-threaded, so sub-microsecond
- *   timestamp collisions cannot occur.
- */
-
-/** Monotonic nanosecond timestamp via `performance.now()`. */
-export function monotonicNs(): number {
-	return Math.trunc(performance.now() * 1_000_000);
-}
-
-/** Wall-clock nanosecond timestamp via `Date.now()`. */
-export function wallClockNs(): number {
-	return Date.now() * 1_000_000;
-}
diff --git a/packages/pure-ts/src/core/config.ts b/packages/pure-ts/src/core/config.ts
deleted file mode 100644
index 9b701932..00000000
--- a/packages/pure-ts/src/core/config.ts
+++ /dev/null
@@ -1,594 +0,0 @@
-/**
- * Singleton protocol config. Holds the message-type registry, the
- * `onMessage` / `onSubscribe` hooks, versioning defaults, and the freeze flag.
- *
- * Layering: this file is protocol-pure. It imports only from `messages.ts`
- * and declares opaque type shapes for handlers — the concrete default
- * implementations and the `defaultConfig` instance live in `node.ts` so that
- * handler bodies can touch `NodeImpl` internals without creating a cycle.
- *
- * Two access paths:
- * 1. **Default instance** (`defaultConfig` in `node.ts`) — use
- *    `configure((cfg) => ...)` at app startup; every node implicitly binds to it.
- * 2. **Isolated instance** (`new GraphReFlyConfig(...)`) — pass via
- *    `opts.config` for test isolation or custom protocol stacks.
- *
- * A config **freezes on first getter read** of any hook (`onMessage`,
- * `onSubscribe`). `NodeImpl`'s constructor intentionally touches one of these
- * on first use so configuration cannot drift once nodes exist.
- */
-
-import {
-	COMPLETE,
-	DATA,
-	DIRTY,
-	ERROR,
-	INVALIDATE,
-	type Message,
-	type Messages,
-	type MessageTypeRegistration,
-	type MessageTypeRegistrationInput,
-	PAUSE,
-	RESOLVED,
-	RESUME,
-	START,
-	TEARDOWN,
-} from "./messages.js";
-import type { HashFn, VersioningLevel } from "./versioning.js";
-
-// ---------------------------------------------------------------------------
-// Handler type shapes
-// ---------------------------------------------------------------------------
-
-/**
- * Minimal node surface visible to default handlers. Concrete `NodeImpl`
- * implements this plus a large set of package-private fields; handlers that
- * need the richer surface cast to the concrete type in `node.ts`.
- */
-export interface NodeCtx {
-	readonly name?: string;
-	readonly status: string;
-	readonly cache: unknown;
-}
-
-/** Imperative actions available inside a node's compute function (§5). */
-export interface NodeActions {
-	/**
-	 * Sugar for `down([[DATA, value]])`. One call = one wave with a
-	 * single DATA payload. The emit pipeline auto-prefixes `[DIRTY]`,
-	 * runs equals substitution against the live cache, and dispatches
-	 * to sinks with phase deferral. Diamond-safe by construction.
-	 */
-	emit(value: unknown): void;
-	/**
-	 * Send one or more messages downstream. Accepts either a single
-	 * {@link Message} tuple or a {@link Messages} array of tuples. One
-	 * call = one wave: the emit pipeline tier-sorts the input,
-	 * auto-prefixes `[DIRTY]` when a tier-3 payload is present and the
-	 * node isn't already dirty, runs equals substitution, then
-	 * dispatches. Multiple calls produce multiple waves.
-	 */
-	down(messageOrMessages: Message | Messages): void;
-	/**
-	 * Send one or more messages upstream. Accepts the same shapes as
-	 * {@link down}. Tier 3 (DATA/RESOLVED) and tier 5 (COMPLETE/ERROR)
-	 * are downstream-only and will throw — `up` is for control-plane
-	 * tiers only: DIRTY (tier 1), PAUSE / RESUME (tier 2), INVALIDATE
-	 * (tier 4), and TEARDOWN (tier 6). No cache advance, no equals, no
-	 * framing — a plain forward to every dep.
-	 */
-	up(messageOrMessages: Message | Messages): void;
-}
-
-/**
- * Message-flow context passed to {@link OnMessageHandler}.
- *
- * - `"down-in"` — message arriving from a dep (identified by `depIndex`).
- * - `"up-in"` — message arriving from a sink.
- */
-export type MessageContext = { direction: "down-in"; depIndex: number } | { direction: "up-in" };
-
-/**
- * Per-sink context passed to {@link OnSubscribeHandler}.
- */
-export interface SubscribeContext {
-	/** Post-subscribe sink count. `1` means first subscriber after 0. */
-	sinkCount: number;
-	/** True when this subscribe cleared a resubscribable terminal state. */
-	afterTerminalReset: boolean;
-}
-
-/**
- * Singleton message interceptor. Called for every message in either direction
- * before the default per-tier dispatch runs. Return `"consume"` to suppress
- * default handling.
- */
-export type OnMessageHandler = (
-	node: NodeCtx,
-	msg: Message,
-	ctx: MessageContext,
-	actions: NodeActions,
-) => "consume" | undefined;
-
-/**
- * Singleton subscribe ceremony. Fires for every sink subscribe on every node.
- * Default implementation emits the START handshake (+ cached DATA when
- * present) to the new sink. Return a cleanup function to run on unsubscribe.
- */
-export type OnSubscribeHandler = (
-	node: NodeCtx,
-	sink: (messages: Messages) => void,
-	ctx: SubscribeContext,
-	actions: NodeActions,
-) => (() => void) | undefined;
-
-/**
- * Event payload for {@link GlobalInspectorHook}. One event fires per outgoing
- * message batch from any node bound to the config.
- *
- * - `kind: "emit"` — fires after equals substitution (`finalMessages`) and
- *   before sink dispatch. `messages` is the exact batch sinks see.
- */
-export type GlobalInspectorEvent = {
-	kind: "emit";
-	node: NodeCtx;
-	messages: Messages;
-};
-
-/**
- * Process-global observability hook for full-graph tracing
- * (Redux-DevTools-style action history). Fires from every node's `_emit`
- * waist whenever {@link GraphReFlyConfig.inspectorEnabled} is `true`.
- *
- * Distinct from per-node `_setInspectorHook` (which is the dep-message /
- * fn-run causal trace used by `Graph.observe(path, { causal, derived })`).
- * Use the global hook to record every emission across every node — useful for
- * time-travel debuggers, tracers, and replay tooling. Use the per-node hook
- * to attribute a single subscribed path's wave to its driving deps.
- *
- * Errors thrown from the hook are swallowed — instrumentation must not break
- * the data plane.
- */
-export type GlobalInspectorHook = (event: GlobalInspectorEvent) => void;
-
-/**
- * Ghost-state recorder used by the fast-check protocol invariant suite to
- * mirror TLC invariants that reference TLA+ ghost variables (`cleanupWitness`,
- * `terminatedBy`, `nonVacuousInvalidateCount`) with no first-class runtime
- * representation. Attached to a `GraphReFlyConfig` via
- * {@link GraphReFlyConfig.rigorRecorder}; zero production cost when unset
- * (call sites in `NodeImpl` are guarded by a single `!= null` check).
- *
- * See `src/__tests__/properties/_invariants.ts` for the consumer side.
- *
- * Errors thrown from recorder methods are swallowed by `NodeImpl` — like
- * {@link GlobalInspectorHook}, instrumentation must not break the data plane.
- */
-export interface RigorRecorder {
-	/**
-	 * Fired at the non-vacuous branch of a node's INVALIDATE handler — the
-	 * `this._cached !== undefined` path where the cleanup hook runs and the
-	 * cache is reset. `prevValue` is the pre-reset `_cached` value. The
-	 * vacuous branch (diamond fan-in second arrival or never-populated
-	 * mid-chain derived) does NOT fire this hook, mirroring the TLA+
-	 * `cleanupWitness` append guard.
-	 */
-	onNonVacuousInvalidate(node: NodeCtx, prevValue: unknown): void;
-	/**
-	 * Fired when a node's status transitions to a terminal kind ("completed"
-	 * or "errored"). `autoComplete` / `autoError` are the node's configured
-	 * auto-terminal gates; `hasDeps` is `deps.length > 0`. Mirrors the TLA+
-	 * `terminatedBy` classification ghost — dep-cascade transitions can be
-	 * inferred by `hasDeps === true && autoX === true`.
-	 */
-	onTerminalTransition(
-		node: NodeCtx,
-		kind: "completed" | "errored",
-		autoComplete: boolean,
-		autoError: boolean,
-		hasDeps: boolean,
-	): void;
-}
-
-// ---------------------------------------------------------------------------
-// GraphReFlyConfig
-// ---------------------------------------------------------------------------
-
-/**
- * Singleton protocol config.
- *
- * A config freezes on first getter read of any hook. After freeze, any
- * attempt to mutate (register a message type, set a hook) throws.
- */
-export class GraphReFlyConfig {
-	private _messageTypes = new Map<symbol, MessageTypeRegistration>();
-	private _codecs = new Map<string, { readonly name: string; readonly version: number }>();
-	private _onMessage: OnMessageHandler;
-	private _onSubscribe: OnSubscribeHandler;
-	private _defaultVersioning: VersioningLevel | undefined;
-	private _defaultHashFn: HashFn | undefined;
-	private _inspectorEnabled: boolean = !(
-		typeof process !== "undefined" && process.env?.NODE_ENV === "production"
-	);
-	private _globalInspector?: GlobalInspectorHook;
-	private _rigorRecorder?: RigorRecorder;
-	private _maxFnRerunDepth = 100;
-	private _maxBatchDrainIterations = 1000;
-	private _pauseBufferMax = 10_000;
-	private _equalsThrowPolicy: "rethrow" | "log-and-continue" =
-		typeof process !== "undefined" && process.env?.NODE_ENV === "production"
-			? "log-and-continue"
-			: "rethrow";
-	private _frozen = false;
-
-	/**
-	 * Pre-bound tier lookup — shared by every node bound to this config. Since
-	 * the registry is frozen on first hook access, this closure can be built
-	 * once in the constructor and handed directly to `downWithBatch` /
-	 * `_frameBatch` paths without per-node or per-emission `.bind(config)`
-	 * allocation.
-	 */
-	readonly tierOf: (t: symbol) => number;
-
-	constructor(init: {
-		onMessage: OnMessageHandler;
-		onSubscribe: OnSubscribeHandler;
-		defaultVersioning?: VersioningLevel;
-		defaultHashFn?: HashFn;
-	}) {
-		this._onMessage = init.onMessage;
-		this._onSubscribe = init.onSubscribe;
-		this._defaultVersioning = init.defaultVersioning;
-		this._defaultHashFn = init.defaultHashFn;
-		// Captured once. Calls back into `this._messageTypes` — still returns
-		// the current registration, but post-freeze the registry is immutable
-		// so the closure is effectively constant.
-		this.tierOf = (t: symbol): number => {
-			const reg = this._messageTypes.get(t);
-			return reg != null ? reg.tier : 1;
-		};
-	}
-
-	// --- Hook getters (freeze on read) ---
-
-	get onMessage(): OnMessageHandler {
-		this._frozen = true;
-		return this._onMessage;
-	}
-
-	get onSubscribe(): OnSubscribeHandler {
-		this._frozen = true;
-		return this._onSubscribe;
-	}
-
-	// --- Hook setters (throw when frozen) ---
-
-	set onMessage(v: OnMessageHandler) {
-		this._assertUnfrozen();
-		this._onMessage = v;
-	}
-
-	set onSubscribe(v: OnSubscribeHandler) {
-		this._assertUnfrozen();
-		this._onSubscribe = v;
-	}
-
-	/**
-	 * Default versioning level applied to every node bound to this config,
-	 * unless the node's own `opts.versioning` provides an explicit override.
-	 * Setting this is only allowed before the config freezes (i.e., before
-	 * the first node is created) so every node in the graph sees a
-	 * consistent starting level. Individual nodes can still opt into a
-	 * higher level via `opts.versioning`, or post-hoc via
-	 * `NodeImpl._applyVersioning(level)` when the node is quiescent.
-	 *
-	 * v0 is the minimum opt-in — unversioned nodes (`undefined`) skip
-	 * the version counter entirely. v1 adds content-addressed cid.
-	 * Future levels (v2, v3) are reserved for linked-history and
-	 * cryptographic attestation extensions.
-	 */
-	get defaultVersioning(): VersioningLevel | undefined {
-		return this._defaultVersioning;
-	}
-	set defaultVersioning(v: VersioningLevel | undefined) {
-		this._assertUnfrozen();
-		this._defaultVersioning = v;
-	}
-
-	/**
-	 * Default content-hash function applied to every versioned node bound
-	 * to this config, unless the node's own `opts.versioningHash` provides
-	 * an explicit override. Use this when a graph needs a non-default hash
-	 * — e.g., swap the vendored sync SHA-256 for a faster non-crypto hash
-	 * (xxHash, FNV-1a) in hot-path workloads, or a stronger hash when
-	 * versioning v1 cids are used as audit anchors.
-	 *
-	 * Only settable before the config freezes. Individual nodes can still
-	 * override via `opts.versioningHash`.
-	 */
-	get defaultHashFn(): HashFn | undefined {
-		return this._defaultHashFn;
-	}
-	set defaultHashFn(v: HashFn | undefined) {
-		this._assertUnfrozen();
-		this._defaultHashFn = v;
-	}
-
-	/**
-	 * When `false`, structured observation options (`causal`, `timeline`)
-	 * and `Graph.trace()` writes are no-ops. Raw `Graph.observe()` always
-	 * works. Default: `true` outside production (`NODE_ENV !== "production"`).
-	 *
-	 * Settable at any time — inspector gating is an operational concern, not
-	 * a protocol invariant, so it does NOT require freeze before node creation.
-	 */
-	get inspectorEnabled(): boolean {
-		return this._inspectorEnabled;
-	}
-	set inspectorEnabled(v: boolean) {
-		this._inspectorEnabled = v;
-	}
-
-	/**
-	 * Process-global observability hook (Redux-DevTools-style full-graph
-	 * tracer). Fires once per outgoing batch from every node bound to this
-	 * config, gated by {@link inspectorEnabled}. See {@link GlobalInspectorHook}.
-	 *
-	 * Settable at any time — like {@link inspectorEnabled} this is operational,
-	 * not protocol-shaping, so it does NOT trigger config freeze.
-	 */
-	get globalInspector(): GlobalInspectorHook | undefined {
-		return this._globalInspector;
-	}
-	set globalInspector(v: GlobalInspectorHook | undefined) {
-		this._globalInspector = v;
-	}
-
-	/**
-	 * Ghost-state recorder for the fast-check protocol invariant suite. Attach
-	 * a {@link RigorRecorder} to capture TLA+-ghost events (cleanup witnesses,
-	 * terminal classification, batch-idle checks) that have no first-class
-	 * runtime surface; detach (`undefined`) for production, which is the
-	 * default. Settable at any time — like {@link globalInspector} this is
-	 * operational, not protocol-shaping, so it does NOT trigger config freeze.
-	 *
-	 * See `src/__tests__/properties/_invariants.ts` rigor mirror invariants
-	 * (#54–#58) for the consumer side. Call sites in `NodeImpl` fire at:
-	 *   - the non-vacuous branch of `_onDepMessage`'s INVALIDATE handler
-	 *   - every status transition to `"completed"` / `"errored"`.
-	 */
-	get rigorRecorder(): RigorRecorder | undefined {
-		return this._rigorRecorder;
-	}
-	set rigorRecorder(v: RigorRecorder | undefined) {
-		this._rigorRecorder = v;
-	}
-
-	/**
-	 * Depth cap on `_pendingRerun` chains inside `NodeImpl._execFn`. Covers
-	 * re-entrance, dep delivery during fn execution, and `autoTrackNode`
-	 * dep-discovery loops. When `_rerunDepth > maxFnRerunDepth`, the
-	 * dispatcher emits `[[ERROR, { nodeId, currentDepth, configuredLimit,
-	 * lastDiscoveredDeps? }]]` and resets `_rerunDepth := 0`.
-	 *
-	 * Default `100`. Settable at any time — operational, not protocol-shaping,
-	 * so it does NOT trigger config freeze.
-	 *
-	 * Source: Lock 2.F′ (Phase 13.6.A locks). Replaces the prior
-	 * module-level `MAX_RERUN_DEPTH` constant in `node.ts`.
-	 */
-	get maxFnRerunDepth(): number {
-		return this._maxFnRerunDepth;
-	}
-	set maxFnRerunDepth(v: number) {
-		this._maxFnRerunDepth = v;
-	}
-
-	/**
-	 * Iteration cap on the batch drain loop in `core/batch.ts`. When iterations
-	 * exceed `maxBatchDrainIterations`, drain throws with diagnostic
-	 * `{ phase, queueSizeAtThrow, configuredLimit }`.
-	 *
-	 * Default `1000`. Settable at any time.
-	 *
-	 * Source: Lock 2.F′ (Phase 13.6.A locks). Replaces the prior
-	 * module-level `MAX_DRAIN_ITERATIONS` constant in `batch.ts`.
-	 */
-	get maxBatchDrainIterations(): number {
-		return this._maxBatchDrainIterations;
-	}
-	set maxBatchDrainIterations(v: number) {
-		this._maxBatchDrainIterations = v;
-	}
-
-	/**
-	 * Cap on the PAUSE-replay buffer (`_pauseBuffer: Messages[]` per Lock 2.C).
-	 * Counts buffered waves (each containing one or more tier-3/tier-4
-	 * messages). On overflow, the dispatcher drops oldest waves and emits
-	 * `[[ERROR, { nodeId, droppedCount, configuredMax, lockHeldDurationMs }]]`
-	 * once per overflow event.
-	 *
-	 * Default `10_000` waves. Loud-fail-with-drop is preferable to silent
-	 * bloat or process kill when a lock is held for minutes under high emit
-	 * rate.
-	 *
-	 * Source: Lock 6.A (Phase 13.6.A locks).
-	 */
-	get pauseBufferMax(): number {
-		return this._pauseBufferMax;
-	}
-	set pauseBufferMax(v: number) {
-		this._pauseBufferMax = v;
-	}
-
-	/**
-	 * Behavior when a user-provided `equals` callback throws inside dispatch.
-	 *
-	 * - `"rethrow"` (dev default) — dispatcher rethrows the error annotated with
-	 *   node id + wave context, surfacing the buggy `equals` immediately.
-	 * - `"log-and-continue"` (prod default — `NODE_ENV === "production"`) —
-	 *   dispatcher catches, logs once per node, and proceeds as if equals
-	 *   returned `false` (emit DATA verbatim). One bad equals doesn't kill
-	 *   the wave.
-	 *
-	 * Settable at any time.
-	 *
-	 * Source: Lock 2.A (Phase 13.6.A locks).
-	 */
-	get equalsThrowPolicy(): "rethrow" | "log-and-continue" {
-		return this._equalsThrowPolicy;
-	}
-	set equalsThrowPolicy(v: "rethrow" | "log-and-continue") {
-		this._equalsThrowPolicy = v;
-	}
-
-	// --- Registry (writes require unfrozen; reads are free lookups) ---
-
-	/**
-	 * Register a custom message type. Must be called before any node that
-	 * uses this config has been created — otherwise throws. Default
-	 * `wireCrossing` is `tier >= 3`.
-	 */
-	registerMessageType(t: symbol, input: MessageTypeRegistrationInput): this {
-		this._assertUnfrozen();
-		this._messageTypes.set(t, {
-			tier: input.tier,
-			wireCrossing: input.wireCrossing ?? input.tier >= 3,
-			metaPassthrough: input.metaPassthrough ?? true,
-		});
-		return this;
-	}
-
-	/** Tier for `t`. Unknown types default to tier 1 (immediate, after START). */
-	messageTier(t: symbol): number {
-		const reg = this._messageTypes.get(t);
-		return reg != null ? reg.tier : 1;
-	}
-
-	/**
-	 * Whether `t` is registered as wire-crossing. Unknown types default to
-	 * `true` (spec §1.3.6 forward-compat — unknowns cross the wire).
-	 */
-	isWireCrossing(t: symbol): boolean {
-		const reg = this._messageTypes.get(t);
-		return reg != null ? reg.wireCrossing : true;
-	}
-
-	/** Convenience inverse of {@link isWireCrossing}. */
-	isLocalOnly(t: symbol): boolean {
-		return !this.isWireCrossing(t);
-	}
-
-	/**
-	 * Whether `t` is forwarded to meta companions by `Graph.signal`. Defaults
-	 * to `true` for unknowns (forward-compat — new types pass through meta by
-	 * default; opt-in filter via `registerMessageType({metaPassthrough: false})`).
-	 */
-	isMetaPassthrough(t: symbol): boolean {
-		const reg = this._messageTypes.get(t);
-		return reg != null ? reg.metaPassthrough : true;
-	}
-
-	/** Whether `t` is a registered (built-in or custom) type. */
-	isKnownMessageType(t: symbol): boolean {
-		return this._messageTypes.has(t);
-	}
-
-	// --- Codec registry (writes require unfrozen; reads are free lookups) ---
-
-	/**
-	 * Register a graph codec by `codec.name`. Used by the envelope-based
-	 * `graph.snapshot({format: "bytes", codec: name})` path and
-	 * `Graph.decode(bytes)` auto-dispatch. Must be called before any node
-	 * bound to this config is created — otherwise throws.
-	 *
-	 * Re-registering the same name overwrites, so user codecs can shadow
-	 * built-in ones before freeze (e.g., to swap a zstd-wrapped dag-cbor in
-	 * for `"dag-cbor"`).
-	 */
-	registerCodec<T extends { readonly name: string; readonly version: number }>(codec: T): this {
-		this._assertUnfrozen();
-		this._codecs.set(codec.name, codec);
-		return this;
-	}
-
-	/**
-	 * Resolve a registered codec by name. Returns `undefined` for unknown
-	 * names. Typed callers cast to their concrete codec interface (e.g.,
-	 * `config.lookupCodec<GraphCodec>("json")`) — this method stays
-	 * layer-pure (no import of graph-layer types into `core/`).
-	 */
-	lookupCodec<T = { readonly name: string; readonly version: number }>(
-		name: string,
-	): T | undefined {
-		return this._codecs.get(name) as T | undefined;
-	}
-
-	/** @internal Used by tests and dev tooling — check freeze state without triggering it. */
-	_isFrozen(): boolean {
-		return this._frozen;
-	}
-
-	private _assertUnfrozen(): void {
-		if (this._frozen) {
-			throw new Error(
-				"GraphReFlyConfig is frozen: a node has already captured this config. " +
-					"Register custom types and set hooks before creating any node.",
-			);
-		}
-	}
-}
-
-// ---------------------------------------------------------------------------
-// Built-in registration
-// ---------------------------------------------------------------------------
-
-/**
- * Register the 10 built-in message types on a fresh config. Called by
- * `node.ts` when it constructs `defaultConfig` and by test code / advanced
- * users after `new GraphReFlyConfig(...)`.
- */
-export function registerBuiltins(cfg: GraphReFlyConfig): void {
-	cfg.registerMessageType(START, { tier: 0, wireCrossing: false });
-	cfg.registerMessageType(DIRTY, { tier: 1, wireCrossing: false });
-	cfg.registerMessageType(PAUSE, { tier: 2, wireCrossing: false });
-	cfg.registerMessageType(RESUME, { tier: 2, wireCrossing: false });
-	cfg.registerMessageType(DATA, { tier: 3, wireCrossing: true });
-	cfg.registerMessageType(RESOLVED, { tier: 3, wireCrossing: true });
-	// INVALIDATE, COMPLETE, ERROR, TEARDOWN do NOT pass through to meta
-	// companions via Graph.signal (spec §2.3). Meta still sees them via the
-	// primary's own down-cascade.
-	//
-	// DS-13.5.A (2026-05-01): INVALIDATE promoted to its own tier-4 settle
-	// group between value-settle (tier-3 DATA/RESOLVED) and terminal
-	// (tier-5 COMPLETE/ERROR). INVALIDATE settles a wave (same role as
-	// RESOLVED for `_dirtyDepCount` accounting) so a single `[[INVALIDATE]]`
-	// emission no longer leaves dependents wedged in DIRTY (the Agent 5
-	// deadlock). COMPLETE/ERROR shift to tier-5; TEARDOWN to tier-6.
-	//
-	// `wireCrossing: true` (was `false` pre-DS-13.5.A) — INVALIDATE persists
-	// across worker-bridge / WAL boundaries for replay determinism (per
-	// DS-13.5.A "attachStorage / WAL: persist INVALIDATE for replay
-	// determinism"). Worker bridges that previously dropped tier-1
-	// INVALIDATE traffic must now forward it.
-	cfg.registerMessageType(INVALIDATE, {
-		tier: 4,
-		wireCrossing: true,
-		metaPassthrough: false,
-	});
-	cfg.registerMessageType(COMPLETE, {
-		tier: 5,
-		wireCrossing: true,
-		metaPassthrough: false,
-	});
-	cfg.registerMessageType(ERROR, {
-		tier: 5,
-		wireCrossing: true,
-		metaPassthrough: false,
-	});
-	cfg.registerMessageType(TEARDOWN, {
-		tier: 6,
-		wireCrossing: true,
-		metaPassthrough: false,
-	});
-}
diff --git a/packages/pure-ts/src/core/guard.ts b/packages/pure-ts/src/core/guard.ts
deleted file mode 100644
index 905dea11..00000000
--- a/packages/pure-ts/src/core/guard.ts
+++ /dev/null
@@ -1,278 +0,0 @@
-import type { Actor } from "./actor.js";
-import { type Node, NodeImpl } from "./node.js";
-
-/**
- * Actions checked by {@link NodeGuard}. `write` covers both {@link Node.down} and
- * {@link Node.up} today; finer-grained strings may be added later (e.g. `"write.data"`).
- */
-export type GuardAction = "write" | "signal" | "observe" | (string & {});
-
-export type NodeGuard = (actor: Actor, action: GuardAction) => boolean;
-
-export type GuardDeniedDetails = {
-	actor: Actor;
-	action: GuardAction;
-	/** Registry or options name when known */
-	nodeName?: string;
-};
-
-/**
- * Thrown when a {@link NodeGuard} denies an action for a given actor.
- *
- * Carries the rejected `actor`, `action`, and optional `nodeName` for diagnostic
- * messages and middleware error handling.
- *
- * @example
- * ```ts
- * import { GuardDenied, policy } from "@graphrefly/pure-ts";
- *
- * const guard = policy((allow) => { allow("observe"); });
- * try {
- *   if (!guard({ type: "llm", id: "agent-1" }, "write")) {
- *     throw new GuardDenied(
- *       { actor: { type: "llm", id: "agent-1" }, action: "write", nodeName: "userInput" },
- *     );
- *   }
- * } catch (e) {
- *   if (e instanceof GuardDenied) console.error(e.action, e.actor.type); // "write" "llm"
- * }
- * ```
- */
-export class GuardDenied extends Error {
-	readonly actor: Actor;
-	readonly action: GuardAction;
-	readonly nodeName?: string;
-
-	/**
-	 * @param details - Actor, action, and optional node name for the denial.
-	 * @param message - Optional override for the default error message.
-	 */
-	constructor(details: GuardDeniedDetails, message?: string) {
-		super(
-			message ??
-				`GuardDenied: action "${String(details.action)}" denied for actor type "${String(details.actor.type)}"`,
-		);
-		this.name = "GuardDenied";
-		this.actor = details.actor;
-		this.action = details.action;
-		this.nodeName = details.nodeName;
-	}
-
-	/** Qualified registry path when known (roadmap diagnostics: same as {@link nodeName}). */
-	get node(): string | undefined {
-		return this.nodeName;
-	}
-}
-
-type Where = (actor: Actor) => boolean;
-
-type Rule = {
-	kind: "allow" | "deny";
-	actions: Set<GuardAction>;
-	where: Where;
-};
-
-function normalizeActions(action: GuardAction | readonly GuardAction[]): GuardAction[] {
-	if (Array.isArray(action)) {
-		return [...action];
-	}
-	return [action as GuardAction];
-}
-
-function matchesActions(set: Set<GuardAction>, action: GuardAction): boolean {
-	return set.has(action) || set.has("*" as GuardAction);
-}
-
-export type PolicyAllow = (
-	action: GuardAction | readonly GuardAction[],
-	opts?: { where?: Where },
-) => void;
-
-export type PolicyDeny = (
-	action: GuardAction | readonly GuardAction[],
-	opts?: { where?: Where },
-) => void;
-
-export type PolicyRuleData = {
-	effect: "allow" | "deny";
-	action: GuardAction | readonly GuardAction[];
-	actorType?: string | readonly string[];
-	actorId?: string | readonly string[];
-	claims?: Record<string, unknown>;
-};
-
-/**
- * Declarative guard builder. Precedence: any matching **deny** blocks even if an allow also matches.
- * If no rule matches, the guard returns `false` (deny-by-default). Aligned with graphrefly-py `policy()`.
- *
- * @param build - Callback that registers `allow(...)` / `deny(...)` rules in order.
- * @returns A `NodeGuard` for use as `node({ guard })`.
- *
- * @example
- * ```ts
- * const guard = policy((allow, deny) => {
- *   allow("observe");
- *   deny("write", { where: (a) => a.type === "llm" });
- * });
- * ```
- */
-export function policy(build: (allow: PolicyAllow, deny: PolicyDeny) => void): NodeGuard {
-	const rules: Rule[] = [];
-	const allow: PolicyAllow = (action, opts) => {
-		rules.push({
-			kind: "allow",
-			actions: new Set(normalizeActions(action)),
-			where: opts?.where ?? (() => true),
-		});
-	};
-	const deny: PolicyDeny = (action, opts) => {
-		rules.push({
-			kind: "deny",
-			actions: new Set(normalizeActions(action)),
-			where: opts?.where ?? (() => true),
-		});
-	};
-	build(allow, deny);
-	return (actor, action) => {
-		let denied = false;
-		let allowed = false;
-		for (const r of rules) {
-			if (!matchesActions(r.actions, action)) continue;
-			if (!r.where(actor)) continue;
-			if (r.kind === "deny") {
-				denied = true;
-			} else {
-				allowed = true;
-			}
-		}
-		if (denied) return false;
-		return allowed;
-	};
-}
-
-/**
- * Rebuild a declarative guard from persisted policy data (snapshot-safe).
- *
- * Rules are deny-overrides, same semantics as {@link policy}.
- */
-export function policyFromRules(rules: readonly PolicyRuleData[]): NodeGuard {
-	return policy((allow, deny) => {
-		for (const rule of rules) {
-			const actorTypes =
-				rule.actorType == null
-					? null
-					: new Set(Array.isArray(rule.actorType) ? rule.actorType : [rule.actorType]);
-			const actorIds =
-				rule.actorId == null
-					? null
-					: new Set(Array.isArray(rule.actorId) ? rule.actorId : [rule.actorId]);
-			const claimEntries = Object.entries(rule.claims ?? {});
-			const where: Where = (actor) => {
-				if (actorTypes !== null && !actorTypes.has(String(actor.type))) return false;
-				if (actorIds !== null && !actorIds.has(String(actor.id ?? ""))) return false;
-				for (const [key, value] of claimEntries) {
-					if ((actor as Record<string, unknown>)[key] !== value) return false;
-				}
-				return true;
-			};
-			if (rule.effect === "deny") {
-				deny(rule.action, { where });
-			} else {
-				allow(rule.action, { where });
-			}
-		}
-	});
-}
-
-/**
- * Reactive-options widening of {@link policy} (DS-14.5.A delta #8, Q7;
- * follows the DS-13.5.B reactive-options pattern landed 2026-05-03).
- *
- * The closure-builder `policy()` form freezes its rules at construction.
- * Multi-agent subgraph ownership needs the allow-set to *re-point* when an
- * ownership claim is made / released / overridden, without rebuilding graph
- * topology. `policyAllowing` accepts either a static actor-id allow-list OR a
- * `Node<readonly string[]>` whose current cache is the live allow-list; the
- * returned `NodeGuard` reads the latest value synchronously at write-check
- * time (`Node.cache` is a sync getter — no async in the guard path).
- *
- * Semantics:
- * - `action === "write"` (and `"signal"`): allowed iff `actor.id` is in the
- *   current allow-set. Deny-by-default when the set is empty / SENTINEL
- *   (`cache == null`) — an unclaimed subgraph denies every writer until a
- *   claim names an owner (Q7 hard-block; the un-claimed case is closed, not
- *   open).
- * - `action === "observe"`: always allowed — ownership gates *writes*, not
- *   reads (reviewers / supervisors must still inspect an owned subgraph).
- * - other custom actions: deny-by-default (same as `policy()`).
- *
- * @param allowed - Static `readonly string[]` of permitted `Actor.id`s, OR a
- *   `Node<readonly string[]>` reactive option (claim/release/override
- *   re-emits the set).
- *
- * @example
- * ```ts
- * const owner = state<readonly string[]>(["agent-a"]);
- * const g = policyAllowing(owner);
- * g({ type: "llm", id: "agent-a" }, "write"); // true
- * g({ type: "llm", id: "agent-b" }, "write"); // false
- * owner.set(["agent-b"]);                       // claim handed over
- * g({ type: "llm", id: "agent-b" }, "write"); // true (re-pointed, no rewire)
- * ```
- */
-export function policyAllowing(allowed: readonly string[] | Node<readonly string[]>): NodeGuard {
-	const readAllow = (): readonly string[] => {
-		if (allowed instanceof NodeImpl) {
-			const c = (allowed as Node<readonly string[]>).cache;
-			return Array.isArray(c) ? c : [];
-		}
-		return allowed as readonly string[];
-	};
-	return (actor, action) => {
-		if (action === "observe") return true;
-		if (action === "write" || action === "signal") {
-			const set = readAllow();
-			return set.includes(String(actor.id ?? ""));
-		}
-		return false;
-	};
-}
-
-const STANDARD_WRITE_TYPES = ["human", "llm", "wallet", "system"] as const;
-
-/**
- * Derives a best-effort `meta.access` hint string by probing `guard` with the
- * standard actor types `human`, `llm`, `wallet`, `system` for the `"write"` action
- * (roadmap 1.5). Aligned with graphrefly-py `access_hint_for_guard`.
- *
- * @param guard - Guard function to probe (typically from {@link policy}).
- * @returns `"restricted"` when no standard type is allowed; `"both"` when both
- *   `human` and `llm` are allowed (plus optionally `system`); the single allowed
- *   type name when only one passes; or a `"+"` joined list otherwise.
- *
- * @example
- * ```ts
- * import { policy, accessHintForGuard } from "@graphrefly/pure-ts";
- *
- * const guardBoth = policy((allow) => { allow("write"); });
- * accessHintForGuard(guardBoth); // "both"
- *
- * const guardHuman = policy((allow) => {
- *   allow("write", { where: (a) => a.type === "human" });
- * });
- * accessHintForGuard(guardHuman); // "human"
- * ```
- */
-export function accessHintForGuard(guard: NodeGuard): string {
-	const allowed = STANDARD_WRITE_TYPES.filter((t) => guard({ type: t, id: "" }, "write"));
-	if (allowed.length === 0) return "restricted";
-	if (
-		allowed.includes("human") &&
-		allowed.includes("llm") &&
-		allowed.every((t) => t === "human" || t === "llm" || t === "system")
-	) {
-		return "both";
-	}
-	if (allowed.length === 1) return allowed[0];
-	return allowed.join("+");
-}
diff --git a/packages/pure-ts/src/core/hash.ts b/packages/pure-ts/src/core/hash.ts
deleted file mode 100644
index 63d2736d..00000000
--- a/packages/pure-ts/src/core/hash.ts
+++ /dev/null
@@ -1,30 +0,0 @@
-/**
- * Cross-environment sha256. Uses `globalThis.crypto.subtle.digest` which is
- * available in Node 18+ (via `webcrypto`) and in every browser. No `node:*`
- * imports — safe to pull into browser bundles.
- *
- * **Async by design.** `crypto.subtle.digest` returns a `Promise<ArrayBuffer>`.
- * Synchronous sha256 requires platform-specific shims (`node:crypto` on Node,
- * a pure-JS fallback on browsers). Keeping this async cuts that fork entirely;
- * callers that need a hash for key computation run inside an `async` context
- * already (every LLM `invoke` / cache write path is async).
- *
- * @module
- */
-
-/** Return the hex sha256 of `input`. */
-export async function sha256Hex(input: string | Uint8Array): Promise<string> {
-	const bytes = typeof input === "string" ? new TextEncoder().encode(input) : input;
-	const buf = await globalThis.crypto.subtle.digest("SHA-256", bytes as BufferSource);
-	const view = new Uint8Array(buf);
-	// Pre-allocated hex lookup table — faster than `.toString(16).padStart(2, "0")`
-	// on hot paths (~4× speedup in microbench). 64-char hex output.
-	let out = "";
-	for (let i = 0; i < view.length; i++) {
-		out += HEX[view[i] as number];
-	}
-	return out;
-}
-
-const HEX: string[] = new Array(256);
-for (let i = 0; i < 256; i++) HEX[i] = i.toString(16).padStart(2, "0");
diff --git a/packages/pure-ts/src/core/index.ts b/packages/pure-ts/src/core/index.ts
deleted file mode 100644
index d9890efb..00000000
--- a/packages/pure-ts/src/core/index.ts
+++ /dev/null
@@ -1,107 +0,0 @@
-/**
- * Core layer: message protocol, node primitive, lifecycle (Phase 0).
- */
-
-export { RingBuffer } from "./_internal/ring-buffer.js";
-export { ResettableTimer } from "./_internal/timer.js";
-export * from "./actor.js";
-export { batch, downWithBatch, isBatching } from "./batch.js";
-export { monotonicNs, wallClockNs } from "./clock.js";
-export {
-	type GlobalInspectorEvent,
-	type GlobalInspectorHook,
-	GraphReFlyConfig,
-	type MessageContext,
-	type NodeActions,
-	type NodeCtx,
-	type OnMessageHandler,
-	type OnSubscribeHandler,
-	type RigorRecorder,
-	registerBuiltins,
-	type SubscribeContext,
-} from "./config.js";
-export * from "./guard.js";
-export { sha256Hex } from "./hash.js";
-export {
-	COMPLETE,
-	COMPLETE_MSG,
-	COMPLETE_ONLY_BATCH,
-	DATA,
-	DIRTY,
-	DIRTY_MSG,
-	DIRTY_ONLY_BATCH,
-	ERROR,
-	INVALIDATE,
-	INVALIDATE_MSG,
-	INVALIDATE_ONLY_BATCH,
-	type Message,
-	type Messages,
-	type MessageTypeRegistration,
-	type MessageTypeRegistrationInput,
-	PAUSE,
-	RESOLVED,
-	RESOLVED_MSG,
-	RESOLVED_ONLY_BATCH,
-	RESUME,
-	START,
-	START_MSG,
-	TEARDOWN,
-	TEARDOWN_MSG,
-	TEARDOWN_ONLY_BATCH,
-} from "./messages.js";
-export {
-	type DescribeDetail,
-	type DescribeField,
-	type DescribeNodeOutput,
-	describeNode,
-	factoryTag,
-	placeholderArgs,
-	resolveDescribeFields,
-} from "./meta.js";
-export {
-	configure,
-	type DepRecord,
-	defaultConfig,
-	type FnCtx,
-	type Node,
-	type NodeDescribeKind,
-	type NodeFn,
-	type NodeFnCleanup,
-	NodeImpl,
-	type NodeInspectorHook,
-	type NodeInspectorHookEvent,
-	type NodeOptions,
-	type NodeSink,
-	type NodeStatus,
-	type NodeTransportOptions,
-	node,
-} from "./node.js";
-export {
-	isTornDownError,
-	type SubscribeOutcome,
-	subscribeOr,
-	TornDownError,
-	trySubscribeOrDead,
-} from "./subscribe-error.js";
-export {
-	type AutoTrackOptions,
-	autoTrackNode,
-	type DynamicFn,
-	dynamicNode,
-	type NodeValues,
-	type PipeOperator,
-	pipe,
-	type TrackFn,
-} from "./sugar.js";
-export {
-	advanceVersion,
-	createVersioning,
-	defaultHash,
-	type HashFn,
-	isV1,
-	type NodeVersionInfo,
-	type V0,
-	type V1,
-	type VersioningLevel,
-	type VersioningOptions,
-} from "./versioning.js";
diff --git a/packages/pure-ts/src/core/messages.ts b/packages/pure-ts/src/core/messages.ts
deleted file mode 100644
index 684cf519..00000000
--- a/packages/pure-ts/src/core/messages.ts
+++ /dev/null
@@ -1,114 +0,0 @@
-/**
- * GraphReFly message protocol — §1 `~/src/graphrefly/GRAPHREFLY-SPEC.md`.
- * Emissions are always `[[Type, Data?], ...]` (no single-tuple shorthand).
- *
- * This file is protocol-pure:
- * - Message type symbols (10 built-ins).
- * - `Message` / `Messages` tuple types.
- * - `MessageTypeRegistration` interface (shape of a registry entry).
- *
- * It does NOT own the registry, tier lookups, or any cross-cutting singleton
- * state — that lives in `GraphReFlyConfig` (see `config.ts`) so custom
- * protocols can build isolated instances. Import this module when you need
- * the symbol constants or the tuple types; import `config.ts` when you need
- * tier / wire-crossing / registry lookups.
- */
-
-/** Subscribe-time handshake. Delivered to each new sink at the top of `subscribe()`. Tier 0. */
-export const START = Symbol.for("graphrefly/START");
-/** Value delivery (`DATA`, value). Tier 3 — deferred inside `batch()`. */
-export const DATA = Symbol.for("graphrefly/DATA");
-/** Phase 1: value about to change. Tier 1 — immediate. */
-export const DIRTY = Symbol.for("graphrefly/DIRTY");
-/** Phase 2: dirty pass completed, value unchanged. Tier 3 — deferred inside `batch()`. */
-export const RESOLVED = Symbol.for("graphrefly/RESOLVED");
-/** Clear cached state; do not auto-emit. Tier 1 — immediate. */
-export const INVALIDATE = Symbol.for("graphrefly/INVALIDATE");
-/** Suspend activity. Tier 2 — immediate. */
-export const PAUSE = Symbol.for("graphrefly/PAUSE");
-/** Resume after pause. Tier 2 — immediate. */
-export const RESUME = Symbol.for("graphrefly/RESUME");
-/** Permanent cleanup. Tier 5 — deferred to batch phase 4. */
-export const TEARDOWN = Symbol.for("graphrefly/TEARDOWN");
-/** Clean termination. Tier 4 — deferred to batch phase 3. */
-export const COMPLETE = Symbol.for("graphrefly/COMPLETE");
-/** Error termination. Tier 4 — deferred to batch phase 3. */
-export const ERROR = Symbol.for("graphrefly/ERROR");
-
-/** One protocol tuple: `[Type, optional payload]`. */
-export type Message = readonly [symbol, unknown?];
-
-/** A batch of tuples — the wire shape for `node.down()` / `node.up()`. */
-export type Messages = readonly Message[];
-
-// ---------------------------------------------------------------------------
-// Interned singletons for payload-free tuples
-// ---------------------------------------------------------------------------
-//
-// Every emission path used to allocate fresh `[[DIRTY]]`, `[[RESOLVED]]`,
-// etc. — two arrays per emit in the hot path. Since none of these tuples
-// carry a payload, one frozen instance is indistinguishable from a
-// fresh one. We intern them at module load and reuse forever. Only
-// `[DATA, v]`, `[ERROR, e]`, `[PAUSE, lockId]`, `[RESUME, lockId]` still
-// allocate per-call because they carry payloads.
-//
-// Downstream code MUST treat these as immutable. `Object.freeze` makes
-// accidental mutation throw in strict mode. Do not `push`, splice, or
-// otherwise mutate a Messages array that came from one of these.
-
-/** Singleton `[DIRTY]` tuple — payload-free, interned. */
-export const DIRTY_MSG: Message = Object.freeze([DIRTY]) as Message;
-/** Singleton `[RESOLVED]` tuple — payload-free, interned. */
-export const RESOLVED_MSG: Message = Object.freeze([RESOLVED]) as Message;
-/** Singleton `[INVALIDATE]` tuple — payload-free, interned. */
-export const INVALIDATE_MSG: Message = Object.freeze([INVALIDATE]) as Message;
-/** Singleton `[START]` tuple — payload-free, interned. */
-export const START_MSG: Message = Object.freeze([START]) as Message;
-/** Singleton `[COMPLETE]` tuple — payload-free, interned. */
-export const COMPLETE_MSG: Message = Object.freeze([COMPLETE]) as Message;
-/** Singleton `[TEARDOWN]` tuple — payload-free, interned. */
-export const TEARDOWN_MSG: Message = Object.freeze([TEARDOWN]) as Message;
-
-/** Pre-wrapped `[[DIRTY]]` for `_emit([DIRTY_ONLY_BATCH])`-style callers. */
-export const DIRTY_ONLY_BATCH: Messages = Object.freeze([DIRTY_MSG]) as Messages;
-/** Pre-wrapped `[[RESOLVED]]`. */
-export const RESOLVED_ONLY_BATCH: Messages = Object.freeze([RESOLVED_MSG]) as Messages;
-/** Pre-wrapped `[[INVALIDATE]]`. */
-export const INVALIDATE_ONLY_BATCH: Messages = Object.freeze([INVALIDATE_MSG]) as Messages;
-/** Pre-wrapped `[[COMPLETE]]`. */
-export const COMPLETE_ONLY_BATCH: Messages = Object.freeze([COMPLETE_MSG]) as Messages;
-/** Pre-wrapped `[[TEARDOWN]]`. */
-export const TEARDOWN_ONLY_BATCH: Messages = Object.freeze([TEARDOWN_MSG]) as Messages;
-
-// ---------------------------------------------------------------------------
-// Registry entry shape
-// ---------------------------------------------------------------------------
-
-/**
- * Per-type record stored in a {@link GraphReFlyConfig}'s registry.
- *
- * - `tier` — signal tier (0–5 built-in; custom tiers allowed but should fit
- *   the phase model used by `batch.ts`).
- * - `wireCrossing` — when `true`, forwarded across SSE/WebSocket/worker
- *   adapters. Defaults to `tier >= 3` if omitted in registration input.
- * - `metaPassthrough` — when `false`, this message type is filtered out of
- *   `Graph.signal` deliveries to meta companion nodes (spec §2.3). Meta
- *   companions still receive everything via their primary's own cascade.
- *   Defaults to `true` (meta receives the message).
- */
-export interface MessageTypeRegistration {
-	tier: number;
-	wireCrossing: boolean;
-	metaPassthrough: boolean;
-}
-
-/**
- * Input accepted by {@link GraphReFlyConfig.registerMessageType}. Only `tier`
- * is required; `wireCrossing` defaults to `tier >= 3`; `metaPassthrough`
- * defaults to `true`.
- */
-export interface MessageTypeRegistrationInput {
-	tier: number;
-	wireCrossing?: boolean;
-	metaPassthrough?: boolean;
-}
diff --git a/packages/pure-ts/src/core/meta.ts b/packages/pure-ts/src/core/meta.ts
deleted file mode 100644
index f8eac288..00000000
--- a/packages/pure-ts/src/core/meta.ts
+++ /dev/null
@@ -1,333 +0,0 @@
-import type { Actor } from "./actor.js";
-import { accessHintForGuard } from "./guard.js";
-import { type Node, type NodeDescribeKind, NodeImpl } from "./node.js";
-
-/**
- * JSON-shaped slice of a node for `Graph.describe()`
- * (GRAPHREFLY-SPEC §3.6, Appendix B).
- */
-export type DescribeNodeOutput = {
-	type: NodeDescribeKind;
-	status?: Node["status"];
-	deps: string[];
-	meta?: Record<string, unknown>;
-	name?: string;
-	value?: unknown;
-	/** True when the node is in `"sentinel"` state (no value ever). */
-	sentinel?: boolean;
-	v?: { id: string; version: number; cid?: string; prev?: string | null };
-	guard?: string;
-	lastMutation?: Readonly<{ actor: Actor; timestamp_ns: number }>;
-	/**
-	 * Latest annotation attached via `graph.trace(path, annotation)` or via
-	 * `graph.add(node, { name: path, annotation })`, when present. Populated by
-	 * `Graph.describe` only — `describeNode` has no graph context.
-	 */
-	annotation?: string;
-};
-
-/**
- * Detail level for progressive disclosure (Phase 3.3b).
- *
- * - `"minimal"` — `type`, `deps` only.
- * - `"standard"` — minimal + `status`, `value`, `meta`, `v`.
- * - `"full"` — every field.
- * - `"spec"` — Tier 1.5.3 (Session A.1 lock + Phase 3 path (b)). Projects
- *   spec-relevant fields (`type`, `deps`, `meta` — including
- *   `meta.factory` / `meta.factoryArgs`) and strips runtime fields
- *   (`status`, `lastMutation`, `guard`, `sentinel`, `v`). **Retains
- *   `value` for state nodes only** so the seed initial value round-trips
- *   through `decompileSpec` → `compileSpec` without forcing every state
- *   constructor to spawn `meta.factory`/`factoryArgs` companion nodes.
- *   The output is structurally identical to the `GraphSpec` shape so
- *   `decompileSpec(g) === describe(g, { detail: "spec" })`.
- */
-export type DescribeDetail = "minimal" | "standard" | "full" | "spec";
-
-/** Valid field names for `describe({ fields: [...] })`. */
-export type DescribeField =
-	| "type"
-	| "status"
-	| "value"
-	| "deps"
-	| "meta"
-	| "v"
-	| "guard"
-	| "lastMutation"
-	| `meta.${string}`;
-
-/** Resolve which fields to include based on detail level or explicit field list. */
-export function resolveDescribeFields(
-	detail?: DescribeDetail,
-	fields?: readonly DescribeField[],
-): Set<string> | null {
-	if (fields != null && fields.length > 0) return new Set(fields);
-	switch (detail) {
-		case "standard":
-			return new Set(["type", "status", "value", "deps", "meta", "v"]);
-		case "full":
-			return null;
-		case "spec":
-			// Spec projection: structural fields + meta (carries factory/factoryArgs)
-			// + value (retained for state nodes only — gated in {@link describeNode}
-			// via the `specMode` parameter). Strips runtime status/lastMutation/
-			// guard/v. Tier 1.5.3 Phase 3 lock (path (b)).
-			return new Set(["type", "deps", "meta", "value"]);
-		default:
-			return new Set(["type", "deps"]);
-	}
-}
-
-function inferDescribeType(n: NodeImpl): NodeDescribeKind {
-	if (n._describeKind != null) return n._describeKind;
-	const hasDeps = n._deps.length > 0;
-	if (!hasDeps) return n._fn != null ? "producer" : "state";
-	// With deps: derived (passthrough falls under derived, no fn → derived shape).
-	return "derived";
-}
-
-/**
- * Walk an arbitrary value, replacing non-JSON-serializable fields with
- * descriptive string placeholders (Tier 1.5.3 Phase 2.5 — DG2=ii). Useful for
- * `Graph.prototype.tagFactory(name, args)` when the factory's options include
- * `LLMAdapter` instances, callbacks, or `Node`s that don't survive
- * serialization. Output preserves structure for documentation / audit value;
- * recipients of the spec see "<Node>" / "<function>" / etc. in place of the
- * unserializable bits.
- *
- * Heuristics:
- * - `null` / `undefined` / boolean / number / string — kept as-is.
- * - `function` — `"<function>"`.
- * - Object with `subscribe` method — `"<Node>"` (matches Node-shape duck check).
- * - Array — recursed.
- * - Plain object — recursed.
- * - Anything else — `"<unserializable>"`.
- *
- * **`undefined`-key caveat (DF11, 2026-04-29 doc lock).** Keys whose value
- * is `undefined` survive `placeholderArgs` (they are kept as-is per the
- * heuristic above). However, `JSON.stringify` DROPS such keys at the
- * serialization boundary, so a spec round-trip via `toJSONString` does
- * not preserve them. Callers that need `undefined` to round-trip must
- * substitute an explicit sentinel (e.g. `null`) before tagging — meta-
- * vs-spec disagreement at the JSON boundary is otherwise inevitable.
- */
-export function placeholderArgs(opts: Record<string, unknown>): Record<string, unknown> {
-	const seen = new WeakSet<object>();
-	const out: Record<string, unknown> = {};
-	for (const [k, v] of safeEntries(opts)) {
-		out[k] = _placeholderValue(v, seen);
-	}
-	return out;
-}
-
-function _placeholderValue(v: unknown, seen: WeakSet<object>): unknown {
-	if (v === null || v === undefined) return v;
-	const t = typeof v;
-	if (t === "boolean" || t === "number" || t === "string") return v;
-	if (t === "function") return "<function>";
-	if (Array.isArray(v)) {
-		// QA F6: cycle guard.
-		if (seen.has(v)) return "<cycle>";
-		seen.add(v);
-		return v.map((x) => _placeholderValue(x, seen));
-	}
-	if (t === "object") {
-		const obj = v as Record<string, unknown>;
-		// QA F6: cycle guard for plain objects.
-		if (seen.has(obj)) return "<cycle>";
-		seen.add(obj);
-		// Node-shape duck check: subscribe() + cache. Wrapped in try/catch in
-		// case `subscribe` is a getter with side effects (QA F7).
-		try {
-			if (typeof obj.subscribe === "function" && "cache" in obj) return "<Node>";
-		} catch {
-			return "<unserializable>";
-		}
-		const out: Record<string, unknown> = {};
-		for (const [k2, v2] of safeEntries(obj)) out[k2] = _placeholderValue(v2, seen);
-		return out;
-	}
-	return "<unserializable>";
-}
-
-/**
- * QA F7: `Object.entries` triggers all enumerable own getters. A user-supplied
- * options bag may include proxies or lazy adapters whose property access has
- * side effects (connections, counters, throws). Skip properties that throw on
- * read so `placeholderArgs` can't crash `tagFactory` time.
- */
-function safeEntries(obj: Record<string, unknown>): Array<[string, unknown]> {
-	const out: Array<[string, unknown]> = [];
-	let keys: string[];
-	try {
-		keys = Object.keys(obj);
-	} catch {
-		return out;
-	}
-	for (const k of keys) {
-		try {
-			out.push([k, (obj as Record<string, unknown>)[k]]);
-		} catch {
-			out.push([k, "<unserializable>"]);
-		}
-	}
-	return out;
-}
-
-/**
- * Build a `meta` fragment that stamps a factory identifier and its construction
- * arguments onto a node, so `describe({ detail: "spec" })` exposes enough
- * information for `compileSpec` to recreate the node from the snapshot.
- *
- * Use inside node-producing factories at construction time:
- *
- * ```ts
- * import { factoryTag } from "@graphrefly/pure-ts";
- *
- * export function rateLimiter<T>(source: NodeInput<T>, opts: RateLimiterOptions): Node<T> {
- *   return derived([fromAny(source)], fn, {
- *     name: "rate-limiter",
- *     meta: { ...factoryTag("rateLimiter", opts), domain: "resilience" },
- *   });
- * }
- * ```
- *
- * `factoryArgs` should be JSON-serializable so the spec round-trips through
- * `decompileSpec → compileSpec`. Function-typed args break determinism — use
- * the {@link COMPOSITION-GUIDE} §39 `meta.fnId` pattern for those.
- *
- * Tier 1.5.3 (Session A.1 lock).
- */
-export function factoryTag(
-	factory: string,
-	factoryArgs?: unknown,
-): { factory: string; factoryArgs?: unknown } {
-	const out: { factory: string; factoryArgs?: unknown } = { factory };
-	if (factoryArgs !== undefined) out.factoryArgs = factoryArgs;
-	return out;
-}
-
-/**
- * Reads the current cached value of every companion meta field on a node,
- * suitable for merging into `describe()`-style JSON.
- *
- * Values come from {@link Node.cache}, which returns the last settled cache.
- * If a meta field is in `"dirty"` status (DIRTY received, DATA pending), the
- * snapshot contains the *previous* value — check `node.meta[key].status`
- * when freshness matters.
- */
-export function metaSnapshot(node: Node): Record<string, unknown> {
-	const out: Record<string, unknown> = {};
-	for (const [key, child] of Object.entries(node.meta)) {
-		try {
-			out[key] = child.cache;
-		} catch {
-			/* omit key — describe tooling still gets other fields */
-		}
-	}
-	return out;
-}
-
-/**
- * Builds a single-node slice of `Graph.describe()` JSON (structure + `meta`
- * snapshot). Parity with `graphrefly-py` `describe_node`.
- *
- * `specMode` (Tier 1.5.3 Phase 3 / path (b)): when true, the `value` field is
- * only included for state nodes — derived/effect/producer values are runtime
- * artifacts and would bloat spec round-trips. Pass `true` from
- * `Graph.describe({ detail: "spec" })`.
- */
-export function describeNode(
-	node: Node,
-	includeFields?: Set<string> | null,
-	specMode?: boolean,
-): DescribeNodeOutput {
-	const all = includeFields == null;
-	const metaKeys: string[] | null =
-		!all && includeFields != null
-			? [...includeFields].filter((f) => f.startsWith("meta.")).map((f) => f.slice(5))
-			: null;
-	const wantsMeta = all || includeFields!.has("meta") || (metaKeys != null && metaKeys.length > 0);
-
-	let type: NodeDescribeKind = "state";
-	let deps: string[] = [];
-
-	if (node instanceof NodeImpl) {
-		type = inferDescribeType(node);
-		deps = node._deps.map((d) => d.node.name ?? "");
-	}
-
-	const out: DescribeNodeOutput = { type, deps };
-
-	if (all || includeFields!.has("status")) {
-		out.status = node.status;
-	}
-
-	const guard = node instanceof NodeImpl ? node._guard : undefined;
-
-	if (wantsMeta) {
-		const rawMeta: Record<string, unknown> = { ...metaSnapshot(node) };
-		if (guard != null && rawMeta.access === undefined) {
-			rawMeta.access = accessHintForGuard(guard);
-		}
-		// `meta.attachTarget` (when present, per
-		// `src/base/meta/attach-edge-meta.ts`) carries a live `Node` ref —
-		// resolved to a qualified path string by `Graph.describe()` via
-		// its `nodeToPath` map. Standalone `describeNode` callers get the
-		// raw `Node` ref since there is no graph context here to resolve
-		// against — DO NOT `JSON.stringify` `describeNode` output
-		// directly when `meta.attachTarget` may be set; go through
-		// `Graph.describe()` for the resolved snapshot.
-		if (metaKeys != null && metaKeys.length > 0 && !includeFields!.has("meta")) {
-			const filtered: Record<string, unknown> = {};
-			for (const k of metaKeys) {
-				if (k in rawMeta) filtered[k] = rawMeta[k];
-			}
-			out.meta = filtered;
-		} else {
-			out.meta = rawMeta;
-		}
-	}
-
-	if (node.name != null) {
-		out.name = node.name;
-	}
-
-	if (all || includeFields!.has("value")) {
-		// Spec mode: only state nodes retain `value` — derived/effect/producer
-		// values are runtime artifacts irrelevant to re-instantiation. State
-		// nodes need `value` because that's where `compileSpec` reads the seed
-		// initial back from.
-		const allowValue = !specMode || type === "state";
-		if (allowValue) {
-			if (node.status === "sentinel") out.sentinel = true;
-			try {
-				out.value = node.cache;
-			} catch {
-				/* omit value */
-			}
-		}
-	}
-
-	if ((all || includeFields!.has("v")) && node.v != null) {
-		const vInfo: NonNullable<DescribeNodeOutput["v"]> = {
-			id: node.v.id,
-			version: node.v.version,
-		};
-		if ("cid" in node.v) {
-			vInfo.cid = (node.v as { cid: string }).cid;
-			vInfo.prev = (node.v as { prev: string | null }).prev;
-		}
-		out.v = vInfo;
-	}
-
-	if (all || includeFields!.has("guard")) {
-		if (guard != null) out.guard = accessHintForGuard(guard);
-	}
-
-	if (all || includeFields!.has("lastMutation")) {
-		if (node.lastMutation != null) out.lastMutation = node.lastMutation;
-	}
-
-	return out;
-}
diff --git a/packages/pure-ts/src/core/node.ts b/packages/pure-ts/src/core/node.ts
deleted file mode 100644
index a7ee0bae..00000000
--- a/packages/pure-ts/src/core/node.ts
+++ /dev/null
@@ -1,4219 +0,0 @@
-/**
- * `NodeImpl` — the single GraphReFly node primitive.
- *
- * Per-dep state lives in a `DepRecord[]` — one entry per declared dep —
- * consolidating subscription cleanup, latest-data tracking, dirty/settled
- * flags, and terminal state into a single structure per dep.
- *
- * This file also owns the default singleton handlers (`defaultOnMessage`,
- * `defaultOnSubscribe`), the `defaultConfig` instance, and the public
- * `configure(...)` entry point. They live here because their bodies touch
- * `NodeImpl` internals; `config.ts` stays NodeImpl-agnostic.
- *
- * See GRAPHREFLY-SPEC §2 and COMPOSITION-GUIDE §1/§9 for the behavior
- * contract. See SESSION-foundation-redesign.md §§1–10 for design history.
- */
-
-import { registerBuiltinCodecs } from "../graph/codec.js";
-import type { Actor } from "./actor.js";
-import { normalizeActor } from "./actor.js";
-import {
-	_setMaxBatchDrainIterationsGetter,
-	downWithBatch,
-	isExplicitlyBatching,
-	registerBatchHook,
-} from "./batch.js";
-import { monotonicNs, wallClockNs } from "./clock.js";
-import type {
-	MessageContext,
-	NodeActions,
-	NodeCtx,
-	OnMessageHandler,
-	OnSubscribeHandler,
-	SubscribeContext,
-} from "./config.js";
-import { GraphReFlyConfig, registerBuiltins } from "./config.js";
-import type { GuardAction, NodeGuard } from "./guard.js";
-import { GuardDenied } from "./guard.js";
-import {
-	COMPLETE,
-	COMPLETE_MSG,
-	COMPLETE_ONLY_BATCH,
-	DATA,
-	DIRTY,
-	DIRTY_MSG,
-	DIRTY_ONLY_BATCH,
-	ERROR,
-	INVALIDATE,
-	INVALIDATE_ONLY_BATCH,
-	type Message,
-	type Messages,
-	PAUSE,
-	RESOLVED,
-	RESOLVED_MSG,
-	RESOLVED_ONLY_BATCH,
-	RESUME,
-	START,
-	START_MSG,
-	TEARDOWN,
-	TEARDOWN_ONLY_BATCH,
-} from "./messages.js";
-import { TornDownError } from "./subscribe-error.js";
-import {
-	advanceVersion,
-	createVersioning,
-	defaultHash,
-	type HashFn,
-	type NodeVersionInfo,
-	type VersioningLevel,
-} from "./versioning.js";
-
-// ---------------------------------------------------------------------------
-// Internal sentinel + type helpers
-// ---------------------------------------------------------------------------
-
-/**
- * Placeholder unsubscribe used to mark a dep subscription as "pending" during
- * the synchronous window between `dep.unsub = noopUnsub` and the return of
- * `dep.node.subscribe(...)`. Ensures the liveness check `dep.unsub === null`
- * in the subscription callback correctly passes for synchronous push-on-
- * subscribe deliveries, while still blocking stale drainPhase2 closures that
- * fire after deactivation has set `dep.unsub = null`.
- */
-const noopUnsub: () => void = () => {};
-
-// ---------------------------------------------------------------------------
-// Public types
-// ---------------------------------------------------------------------------
-
-/**
- * Lifecycle status of a node.
- *
- * @see GRAPHREFLY-SPEC.md §2.2
- */
-export type NodeStatus =
-	| "sentinel"
-	| "pending"
-	| "dirty"
-	| "settled"
-	| "resolved"
-	| "completed"
-	| "errored";
-
-/** Callback that receives downstream message batches. */
-export type NodeSink = (messages: Messages) => void;
-
-/**
- * Observability hook events fired by a per-node inspector. Used by
- * `Graph.observe(path, { causal, derived })` to build causal traces.
- *
- * - `"dep_message"` — fires in `_onDepMessage` before default dispatch,
- *   one event per message received from a dep. Includes `depIndex` and
- *   the raw `Message` tuple.
- * - `"run"` — fires in `_execFn` just before the user fn runs. Includes
- *   the per-dep `prevData` snapshot that will be passed to fn.
- */
-export type NodeInspectorHookEvent =
-	| { kind: "dep_message"; depIndex: number; message: Message }
-	| {
-			kind: "run";
-			batchData: readonly (readonly unknown[] | undefined)[];
-			prevData: readonly unknown[];
-	  };
-
-/** Callback attached to a node for per-message/per-run inspection. */
-export type NodeInspectorHook = (event: NodeInspectorHookEvent) => void;
-
-/** Describe `type` for `Graph.describe` (GRAPHREFLY-SPEC Appendix B). */
-export type NodeDescribeKind = "state" | "derived" | "producer" | "effect";
-
-/** Actor/delivery context for {@link Node.down} and {@link Node.up}. */
-export type NodeTransportOptions = {
-	actor?: Actor;
-	/** When `true`, skips guard checks. */
-	internal?: boolean;
-	/** `signal` for `Graph.signal` deliveries; default `write`. */
-	delivery?: "write" | "signal";
-};
-
-/**
- * Cleanup return shape from a node {@link NodeFn}.
- *
- * Lock 4.A (Phase 13.6.A) renamed the named-hook fields:
- *
- * - `onRerun` fires before the next fn invocation (i.e. between waves once
- *   fn has settled and is about to recompute).
- * - `onDeactivation` fires on deactivation (last-sink unsubscribe or
- *   TEARDOWN).
- * - `onInvalidate` fires on INVALIDATE (spec v0.4 graph-wide flush signal).
- *
- * Each hook is independent and fires exactly once on its named transition;
- * missing hooks are no-ops. Returning `{}` (or no cleanup) is valid — the
- * common case. The three normal-lifecycle slots (`onRerun` /
- * `onDeactivation` / `onInvalidate`) cover every ordinary lifecycle event;
- * `onResubscribableReset` (below) is a fourth slot for the
- * post-terminal-resubscribable reset path that runs WITHOUT `_deactivate`.
- *
- * **Lock 4.A:** the legacy `() => void` cleanup shorthand was removed
- * entirely — from the type, from every runtime firing site, and from every
- * call site. There is no shim. Every site declares the exact transition(s)
- * it means: a resource disposed when the node deactivates uses
- * `{ onDeactivation }`; a per-rerun reset uses `{ onRerun }`; an
- * INVALIDATE-time flush uses `{ onInvalidate }`.
- *
- * Closure access: hooks are declared inside `NodeFn`, so they see the same
- * closure as the fn body (per-run locals, `ctx.store`, dep refs).
- */
-export type NodeFnCleanup = {
-	onRerun?: () => void;
-	onDeactivation?: () => void;
-	onInvalidate?: () => void;
-	/**
-	 * Phase 13.6.B QA D1 (Lock 6.D follow-up): fires from
-	 * `_resetForFreshLifecycle` — the post-terminal-resubscribable
-	 * reset path that runs WITHOUT `_deactivate`. Two callers:
-	 *   1. `subscribe()` after a terminal-resubscribable node was
-	 *      kept alive by another sink (multi-sub-stayed case);
-	 *   2. INVALIDATE on a terminal-resubscribable node.
-	 *
-	 * Pre-Lock-6.D the framework auto-wiped `ctx.store` on this
-	 * path. Post-flip the store preserves; operators with
-	 * one-shot store flags (`frozenContext.emitted`,
-	 * `take.completed`, etc.) need an explicit hook to clear
-	 * those flags when the node enters a fresh lifecycle without
-	 * deactivation.
-	 *
-	 * Distinct from `onDeactivation` because the cleanup contract
-	 * is different: `onDeactivation` may dispose timers /
-	 * subscriptions / external resources that must NOT be
-	 * disposed on a mid-life lifecycle reset. Use this slot ONLY
-	 * for store-state resets that need to fire on every "fresh
-	 * lifecycle" transition.
-	 */
-	onResubscribableReset?: () => void;
-};
-
-/**
- * Fn-time context exposing per-wave metadata and a per-node persistent
- * scratch pad.
- *
- * - `prevData[i]` — last DATA value from dep `i` as of the END of the
- *   previous wave (i.e. the value that was stable before this wave started).
- *   Use as the fallback when `data[i]` is `undefined` (not involved) or
- *   `[]` (RESOLVED, no new values this wave).
- *   `undefined` means dep `i` has never produced DATA (sentinel state).
- *   `null` is a valid DATA value. `undefined` is not a valid DATA value —
- *   the protocol reserves it as the "never sent" sentinel.
- *   - `ctx.prevData[i] === undefined` → dep has never produced DATA
- *   - `ctx.prevData[i] !== undefined` → last DATA value (may be `null`)
- * - `terminalDeps[i]` — runtime shape:
- *   - `undefined` → dep `i` is still live.
- *   - `true` → dep `i` sent COMPLETE.
- *   - anything else → dep `i` sent ERROR, value is the error payload.
- *   Type is `readonly unknown[]` because `true | unknown` collapses to
- *   `unknown` anyway; the three states are documented contract, not type.
- * - `store` — mutable bag that persists across fn runs. Lock 6.D (Phase
- *   13.6.B) flipped the default: store now PRESERVES across deactivation
- *   and across terminal-resubscribable lifecycle reset. Operators that
- *   want the old wipe-on-deactivation behavior must clear keys explicitly
- *   in `onDeactivation`. See COMPOSITION-GUIDE-GRAPH §20.
- */
-export interface FnCtx {
-	readonly prevData: readonly unknown[];
-	readonly terminalDeps: readonly unknown[];
-	readonly store: Record<string, unknown>;
-}
-
-/**
- * Compute function passed to `node(deps, fn, opts?)`.
- *
- * `data[i]` holds the batch of DATA values received from dep `i` during the
- * current wave. Shape contract:
- * - `undefined` — dep `i` was not involved in this wave (no DIRTY received).
- * - `[]` — dep `i` was involved (dirtied), but settled as RESOLVED (value
- *   unchanged). Use `ctx.prevData[i]` to read its last known value from the
- *   previous wave.
- * - `[v1, v2, ...]` — dep `i` sent one or more DATA values. `at(-1)` gives
- *   the latest; iterate for multi-emission processing.
- *
- * Emission is explicit via `actions.emit(v)` (sugar: equals + framing) or
- * `actions.down(msgs)` (raw). Return a cleanup shape to register teardown:
- * `{ onRerun?, onDeactivation?, onInvalidate? }` (each hook fires on its
- * named transition only — Lock 4.A, named-hooks only post-13.6.A). See
- * {@link NodeFnCleanup}. Any non-cleanup return value is ignored. The
- * `| void` leg lets arrow-block bodies satisfy `NodeFn` without an explicit
- * `return undefined`.
- *
- * Sugar constructors (`derived`, `effect`, `dynamicNode`) unwrap `data[i]`
- * to a single scalar (`at(-1)` with `ctx.prevData[i]` fallback) so their
- * user-facing fn signatures stay unchanged. Use raw `node()` when you need
- * the full batch array.
- */
-export type NodeFn = (
-	data: readonly (readonly unknown[] | undefined)[],
-	actions: NodeActions,
-	ctx: FnCtx,
-	// biome-ignore lint/suspicious/noConfusingVoidType: see JSDoc above.
-) => NodeFnCleanup | void;
-
-/** Options accepted by every node constructor. */
-export interface NodeOptions<T = unknown> {
-	name?: string;
-	describeKind?: NodeDescribeKind;
-	equals?: (a: T, b: T) => boolean;
-	/**
-	 * Pre-populate the cache at construction. `null` is a valid initial value.
-	 * `undefined` is treated as absent (not a valid DATA payload).
-	 */
-	initial?: T | null;
-	meta?: Record<string, unknown>;
-	resubscribable?: boolean;
-	resetOnTeardown?: boolean;
-	/** Auto-emit `[[COMPLETE]]` when all deps complete. Default `true`. */
-	completeWhenDepsComplete?: boolean;
-	/**
-	 * Auto-propagate `[[ERROR]]` when any dep errors. Default `true`.
-	 * Set `false` only for rescue/catchError operators that handle errors
-	 * explicitly via `ctx.terminalDeps`.
-	 */
-	errorWhenDepsError?: boolean;
-	/**
-	 * First-run gate (§2.7 `R2.7.0`/`R2.7.2`). When `false` (default — matches
-	 * the universal contract "fn does not fire until every declared dep has
-	 * delivered at least one real DATA"), fn is held until every declared dep
-	 * has contributed real DATA (`d.dataBatch.length > 0` this wave OR
-	 * `d.prevData !== undefined` from a prior wave). Sugar constructors
-	 * (`derived`, `effect`) inherit the default so multi-parent activation
-	 * produces one combined initial wave `[[START], [DIRTY], [DATA, fn(init...)]]`
-	 * instead of the sequential `[[START], [DIRTY], [RESOLVED], [DIRTY], [DATA]]`
-	 * shape produced by per-dep push-on-subscribe firings.
-	 *
-	 * **Terminal does NOT settle the gate by default** (`R2.7.1`, DS-2.7.A
-	 * cross-port lock 2026-05-19). Reduce-class operators (`reduce`, `scan`,
-	 * `last`, `take`, `takeWhile`) opt in via {@link terminalAsRealInput}.
-	 *
-	 * When `true`, fn fires as soon as `_dirtyDepCount === 0` regardless of
-	 * whether any dep is still sentinel (`R2.7.2` — gate is truly OFF). The
-	 * fn body MUST guard every dep slot for SENTINEL
-	 * (`ctx.prevData[i] === undefined`) — failing to do so will read SENTINEL
-	 * as `undefined` pass-through and is the operator author's bug, not a
-	 * gate failure. Operators like `withLatestFrom`, `valve`, worker-bridge
-	 * aggregators, and effects like `agentLoop.effFullDeny` that deliberately
-	 * fire on partial deps pass `partial: true` explicitly.
-	 * {@link terminalAsRealInput} is ignored when `partial: true` (the gate
-	 * is OFF either way).
-	 *
-	 * Zero-dep producer-pattern factories (`stratify`, `budgetGate`, etc.)
-	 * are unaffected either way — an empty `_deps` array has nothing for the
-	 * gate to hold on.
-	 *
-	 * Gate scope (`R2.7.3`): applies only until fn has fired once
-	 * (`_hasCalledFnOnce`). Subsequent waves, INVALIDATE, and `_addDep` do
-	 * not re-gate. Terminal reset (resubscribable node reconnect) resets
-	 * `_hasCalledFnOnce` and re-arms the gate.
-	 */
-	partial?: boolean;
-	/**
-	 * First-run gate opt-in (§2.7 `R2.7.1`, DS-2.7.A cross-port lock
-	 * 2026-05-19). Default `false`. When `true`, a dep terminal
-	 * (COMPLETE / ERROR / TEARDOWN) also settles the gate for that dep —
-	 * `d` is considered settled when `d.dataBatch.length > 0` OR
-	 * `d.prevData !== undefined` OR `d.terminal !== undefined`.
-	 *
-	 * Use for Reduce-class operators that need to fire on
-	 * upstream-COMPLETE-without-DATA to emit a seed/accumulator or to
-	 * forward `[[COMPLETE]]` from inside `fn` (`reduce`, `scan`, `last`,
-	 * `take`, `takeWhile`; `first` / `find` / `elementAt` inherit via
-	 * `take`). Without this opt-in, a source that COMPLETEs without ever
-	 * emitting DATA holds the gate forever — the operator's terminal
-	 * branch never runs and downstream never sees COMPLETE.
-	 *
-	 * Ignored when `partial: true` — the gate is OFF either way.
-	 */
-	terminalAsRealInput?: boolean;
-	/**
-	 * Tier-2 PAUSE/RESUME handling.
-	 * - `true` (default): wave completion suppressed while paused; fn fires
-	 *   once on RESUME if gate is satisfied.
-	 * - `false`: node ignores PAUSE (sources like timers that must keep running).
-	 * - `"resumeAll"`: on RESUME, replay every buffered DATA (future).
-	 */
-	pausable?: boolean | "resumeAll";
-	/**
-	 * Spec §2.5 / Lock 6.G — circular buffer of last-N **outgoing** DATA
-	 * values. When set to a positive integer `N`, the node retains the last
-	 * `N` values it actually delivered to sinks. New (late) subscribers
-	 * receive the buffer as `[[START], [DATA, v0], [DATA, v1], …, [DATA, vK-1]]`
-	 * after the START handshake — see `defaultOnSubscribe`. Replaces the
-	 * old `replay()` operator + `wrapSubscribeHook` monkey-patching pattern.
-	 *
-	 * Semantic notes:
-	 * - **Outgoing-DATA-only (post-equals).** RESOLVED entries
-	 *   (equals-substitution collapses) are NOT buffered. Pause-buffered
-	 *   DATA is NOT pushed until the RESUME drain actually dispatches it
-	 *   to sinks — the buffer reflects what subscribers observed, not
-	 *   internal cache advances mid-pause. **On RESUME drain, each
-	 *   buffered wave re-runs through `_updateState` and re-applies
-	 *   equals-substitution against the walking cache; values that
-	 *   collapse to RESOLVED on replay also collapse out of the replay
-	 *   buffer, so a sequence of identical-value mid-pause emits
-	 *   contributes 0 entries.** This is the locked "post-equals
-	 *   outgoing" semantic (QA D6, Phase 13.6.B QA pass).
-	 * - **INVALIDATE preserves history.** INVALIDATE clears `_cached` and
-	 *   sets status to `"sentinel"` but does NOT touch the replay buffer:
-	 *   a late subscriber arriving post-INVALIDATE still receives the
-	 *   prior emission history. The buffer represents "values this node
-	 *   actually emitted", which an INVALIDATE doesn't retroactively erase.
-	 * - **Lifecycle reset clears.** TEARDOWN (`_deactivate`) and
-	 *   terminal-resubscribable lifecycle reset (`_resetForFreshLifecycle`)
-	 *   both null the buffer — matches the TLA+ model's
-	 *   `replaySnapshot' = <<>>` clear in `Resubscribe` (formal model
-	 *   batch 6 G).
-	 * - **Late-subscribe priority.** When the buffer has entries,
-	 *   `defaultOnSubscribe` delivers them INSTEAD of the cache-DATA push
-	 *   (the buffer's most-recent entry equals `_cached` at quiescence).
-	 *   When the buffer is empty (e.g. node has `initial:` but never
-	 *   emitted, or post-resubscribable-reset), the legacy cache-DATA
-	 *   push still fires.
-	 *
-	 * `0` / absent / non-positive values disable the buffer entirely.
-	 */
-	replayBuffer?: number;
-	guard?: NodeGuard;
-	versioning?: VersioningLevel;
-	versioningId?: string;
-	versioningHash?: HashFn;
-	/**
-	 * Override the config instance this node binds to. Defaults to
-	 * {@link defaultConfig}. Useful for test isolation and custom protocol
-	 * stacks. The first node that reads any hook on the config freezes it.
-	 */
-	config?: GraphReFlyConfig;
-}
-
-/** A reactive node in the GraphReFly protocol. */
-export interface Node<T = unknown> {
-	readonly name?: string;
-	readonly status: NodeStatus;
-	/**
-	 * Current cached value. Returns `undefined` when the node is in
-	 * `"sentinel"` state (no DATA ever emitted). v5 reserves `undefined`
-	 * globally as the sentinel value — the valid DATA type is `T | null`.
-	 * Therefore `node.cache === undefined` is a valid "never emitted" guard.
-	 * `node.status` distinguishes the richer states (`"sentinel"`,
-	 * `"settled"`, `"errored"`, etc.) when you need more than has-value.
-	 */
-	readonly cache: T | null | undefined;
-	readonly meta: Record<string, Node>;
-	readonly lastMutation: Readonly<{ actor: Actor; timestamp_ns: number }> | undefined;
-	readonly v: Readonly<NodeVersionInfo> | undefined;
-	/**
-	 * Send one or more messages downstream. Accepts either a single
-	 * {@link Message} tuple (e.g. `node.down([DATA, 42])`) or a
-	 * {@link Messages} array of tuples (e.g.
-	 * `node.down([[DIRTY], [DATA, 42]])`). One call = one wave: the
-	 * emit pipeline tier-sorts the input, auto-prefixes `[DIRTY]` when
-	 * any tier-3 payload is present and the node is not already dirty,
-	 * runs equals substitution against the live cache (§3.5.1), then
-	 * dispatches to sinks with phase deferral.
-	 */
-	down(messageOrMessages: Message | Messages, options?: NodeTransportOptions): void;
-	/**
-	 * Sugar for `down([[DATA, value]])`. One wave with a single DATA
-	 * payload — the pipeline adds the synthetic DIRTY prefix and runs
-	 * equals substitution against the live cache.
-	 */
-	emit(value: T | undefined | null, options?: NodeTransportOptions): void;
-	/**
-	 * Send one or more messages upstream. Accepts the same shapes as
-	 * {@link down}. Upstream is restricted to control-plane tiers
-	 * (DIRTY, PAUSE, RESUME, INVALIDATE, TEARDOWN); tier-3 (DATA/RESOLVED)
-	 * and tier-5 (COMPLETE/ERROR) payloads throw — value/terminal traffic
-	 * is downstream-only in this protocol. No equals substitution, no
-	 * cache advance, no DIRTY auto-prefix — the up direction just
-	 * forwards to every dep.
-	 */
-	up?(messageOrMessages: Message | Messages, options?: NodeTransportOptions): void;
-	subscribe(sink: NodeSink, actor?: Actor): () => void;
-	allowsObserve(actor: Actor): boolean;
-	hasGuard(): boolean;
-	/**
-	 * Atomically replace this node's full upstream dependency set and its
-	 * transform fn (dynamic rewire). Kept deps preserve their per-dep
-	 * runtime state; removed deps' state is discarded; added deps start at
-	 * SENTINEL. Cache, replay buffer, pause locks, and `firstRunPassed`
-	 * are preserved. Idempotent when `newDeps` equals the current set.
-	 *
-	 * The `fn` parameter is **required** even when unchanged — a dep-shape
-	 * change silently misroutes positional `data[i]`/`prevData[i]` reads
-	 * unless the caller re-declares the fn at the call site (pass the
-	 * existing fn ref to keep behavior).
-	 *
-	 * Rejects: self-dependency, cycle introduction, mid-fn mutation,
-	 * terminal `this`, or a non-resubscribable-terminal node in `newDeps`.
-	 * Semantics are TLA+-verified (`wave_protocol_rewire_MC`).
-	 */
-	setDeps(newDeps: readonly Node[], fn: NodeFn, _opts?: Record<string, never>): void;
-	/**
-	 * Append a single dep (post-construction) with full validation,
-	 * replacing the transform fn for the grown shape. Returns the new
-	 * dep's index in the dep set, or the existing index if already
-	 * present. Same rejection rules as {@link setDeps}. The `fn` parameter
-	 * is required (the new shape adds a `data` slot).
-	 */
-	addDep(depNode: Node, fn: NodeFn, _opts?: Record<string, never>): number;
-	/**
-	 * Remove a single dep, replacing the transform fn for the shrunk
-	 * shape. Idempotent — a no-op (fn swap still applies) if `depNode` is
-	 * not a current dep. Removing the last dep yields a degenerate
-	 * no-deps node (cache preserved). Same rejection rules as
-	 * {@link setDeps}; the `fn` parameter is required.
-	 */
-	removeDep(depNode: Node, fn: NodeFn, _opts?: Record<string, never>): void;
-}
-
-// ---------------------------------------------------------------------------
-// DepRecord — per-dep state (§8.2)
-// ---------------------------------------------------------------------------
-
-/**
- * Per-dep runtime state. One entry per upstream node.
- *
- * `terminal` is the single terminal-state slot, shaped to match
- * {@link FnCtx.terminalDeps}:
- * - `undefined` — dep is still live.
- * - `true` — dep sent COMPLETE.
- * - anything else — dep sent ERROR with that payload.
- *
- * `[ERROR, undefined]` is rejected at the dispatch boundary (`_emit`) per
- * spec §1.2 — `undefined` would collide with the "live" encoding here.
- * Always pass meaningful error values (Error objects, domain tags).
- */
-export interface DepRecord {
-	readonly node: Node;
-	unsub: (() => void) | null;
-	/**
-	 * Last DATA value from this dep as of the end of the previous completed
-	 * wave. `undefined` until dep has produced at least one DATA (sentinel).
-	 * Committed by `_execFn` after snapshotting `ctx.prevData` and before
-	 * `_clearWaveFlags`. `undefined` is reserved as the "never sent" sentinel —
-	 * `undefined` is not a valid DATA payload.
-	 */
-	prevData: unknown;
-	/** True while awaiting DATA/RESOLVED for the current wave. */
-	dirty: boolean;
-	/**
-	 * True if this dep was dirtied in the current wave (set in `_depDirtied`,
-	 * cleared in `_clearWaveFlags`). Distinguishes "RESOLVED" (`involvedThisWave
-	 * && dataBatch.length === 0`) from "not involved" (`!involvedThisWave`) in
-	 * the `data[i]` batch snapshot passed to fn.
-	 */
-	involvedThisWave: boolean;
-	/**
-	 * DATA values accumulated from this dep during the current wave.
-	 * Populated by `_depSettledAsData`, cleared by `_clearWaveFlags`.
-	 * Snapshotted (copied) by `_execFn` before `_clearWaveFlags` runs so
-	 * that fn always sees the full wave batch.
-	 */
-	dataBatch: unknown[];
-	/** Terminal-state slot — see JSDoc on {@link DepRecord}. */
-	terminal: unknown;
-}
-
-function createDepRecord(n: Node): DepRecord {
-	return {
-		node: n,
-		unsub: null,
-		prevData: undefined,
-		dirty: false,
-		involvedThisWave: false,
-		dataBatch: [],
-		terminal: undefined,
-	};
-}
-
-function resetDepRecord(d: DepRecord): void {
-	d.prevData = undefined;
-	d.dirty = false;
-	d.involvedThisWave = false;
-	d.dataBatch.length = 0;
-	d.terminal = undefined;
-}
-
-/**
- * @internal Returns `true` if `target` is reachable from `from` via upstream
- * dep traversal (i.e. `from` already transitively depends on `target`).
- *
- * Used by `_setDeps` cycle prevention: adding edge `from → target` (which
- * happens when `from` becomes a dep of `target`) closes a cycle iff
- * `target` is already reachable upstream from `from`.
- *
- * O(V + E) over the visited subgraph. Bounded by the universe of nodes
- * reachable upstream from `from`, NOT the global node count.
- */
-function _reachableUpstream(from: Node, target: Node): boolean {
-	if (from === target) return true;
-	const visited = new Set<Node>();
-	const stack: Node[] = [from];
-	while (stack.length > 0) {
-		const n = stack.pop() as Node;
-		if (visited.has(n)) continue;
-		visited.add(n);
-		const deps = (n as NodeImpl)._deps;
-		if (deps == null) continue;
-		for (const d of deps) {
-			if (d.node === target) return true;
-			if (!visited.has(d.node)) stack.push(d.node);
-		}
-	}
-	return false;
-}
-
-// ---------------------------------------------------------------------------
-// Normalization helper
-// ---------------------------------------------------------------------------
-
-/**
- * Accept either a single `Message` tuple or a `Messages` array and return
- * a `Messages` array. The discriminator is the type of the first element:
- * a `Message` has a symbol at index 0, while a `Messages` array has a
- * nested array at index 0. This lets `node.down(...)` and `actions.down(...)`
- * take either shape without a wrapper allocation on the common single-msg
- * path.
- */
-function normalizeMessages(input: Message | Messages): Messages {
-	if (input.length === 0) return input as Messages;
-	return typeof (input as Message)[0] === "symbol" ? [input as Message] : (input as Messages);
-}
-
-// ---------------------------------------------------------------------------
-// Default handlers
-// ---------------------------------------------------------------------------
-
-/**
- * Default {@link OnMessageHandler}. For `"down-in"` messages (from a dep),
- * routes to `NodeImpl._onDepMessage`. For `"up-in"` messages (from a sink),
- * the up-path is wired directly via `Node.up()` and never passes through
- * onMessage — this hook is reserved for future P5 symmetry.
- */
-const defaultOnMessage: OnMessageHandler = (
-	node: NodeCtx,
-	msg: Message,
-	ctx: MessageContext,
-	_actions: NodeActions,
-): "consume" | undefined => {
-	if (ctx.direction === "down-in") {
-		(node as NodeImpl)._onDepMessage(ctx.depIndex, msg);
-	}
-	// up-in is currently unused; default is to do nothing.
-	return undefined;
-};
-
-/**
- * Default {@link OnSubscribeHandler}. Delivers the subscribe handshake —
- * `[[START]]` for a sentinel cache, or `[[START], [DATA, cached]]` when a
- * value exists. Terminal nodes skip entirely so absence of START tells the
- * sink the stream is over (spec §2.2). Delivered through `downWithBatch` so
- * `subscribe()` inside `batch()` still defers the paired DATA correctly.
- *
- * Lock 6.G (spec §2.5): when `replayBuffer: N` is set and the buffer has
- * entries, the buffer is delivered INSTEAD of the cache-DATA push (the
- * buffer's most-recent entry equals `_cached` at quiescence — appending
- * cache afterward would duplicate). When the buffer is empty (e.g. node
- * has `initial:` but never emitted, or post-resubscribable-reset), the
- * legacy cache-DATA push still fires. INVALIDATE clears `_cached` but
- * NOT `_replayBuffer` — a late subscriber arriving post-INVALIDATE
- * receives the prior emission history.
- */
-const defaultOnSubscribe: OnSubscribeHandler = (
-	node: NodeCtx,
-	sink: NodeSink,
-	_ctx: SubscribeContext,
-	_actions: NodeActions,
-): (() => void) | undefined => {
-	const impl = node as NodeImpl;
-	if (impl._status === "completed" || impl._status === "errored") return;
-	const cached = impl._cached;
-	const replayBuf = impl._replayBuffer;
-	const initial: Message[] = [START_MSG];
-	if (replayBuf != null && replayBuf.length > 0) {
-		// Replay buffer authoritative — its last entry mirrors `_cached`
-		// at quiescence, so we do NOT also push the cache-DATA frame.
-		// Post-INVALIDATE the buffer persists while `_cached` is cleared;
-		// a late subscriber still receives the prior history per spec
-		// §2.5 ("last N outgoing DATA values").
-		for (const v of replayBuf) initial.push([DATA, v] as Message);
-	} else if (cached !== undefined) {
-		// Buffer disabled or empty — legacy push-on-subscribe.
-		initial.push([DATA, cached] as Message);
-	}
-	// When the node is mid-wave (`"dirty"`), append a DIRTY so the late
-	// joiner participates in the in-flight wave. Without this, the next
-	// DATA/RESOLVED the sink receives lacks the preceding DIRTY required
-	// by spec §1.3.1 — the emit-side DIRTY auto-prefix is suppressed when
-	// `_status` is already `"dirty"`.
-	if (impl._status === "dirty") initial.push(DIRTY_MSG);
-	downWithBatch(sink, initial, impl._config.tierOf);
-};
-
-// ---------------------------------------------------------------------------
-// defaultConfig + configure
-// ---------------------------------------------------------------------------
-
-/**
- * Default {@link GraphReFlyConfig} instance. Every `NodeImpl` constructed
- * without an explicit `opts.config` binds to this instance and freezes it
- * on first hook access.
- */
-export const defaultConfig = new GraphReFlyConfig({
-	onMessage: defaultOnMessage,
-	onSubscribe: defaultOnSubscribe,
-});
-registerBuiltins(defaultConfig);
-registerBuiltinCodecs(defaultConfig);
-// Lock 2.F′ (Phase 13.6.A): wire `batch.ts`'s drain-cap getter to
-// `defaultConfig.maxBatchDrainIterations`. Batch deferral is process-global,
-// so the cap is necessarily tied to `defaultConfig` regardless of any
-// per-node `opts.config` isolation.
-_setMaxBatchDrainIterationsGetter(() => defaultConfig.maxBatchDrainIterations);
-
-/**
- * Apply configuration to {@link defaultConfig}. Must be called before the
- * first node is created — otherwise throws. Custom message types, hook
- * overrides, etc. go through here at app startup.
- *
- * ```ts
- * configure((cfg) => {
- *   cfg.registerMessageType(MY_TYPE, { tier: 3 });
- *   cfg.onMessage = (node, msg, ctx, actions) => { ... };
- * });
- * ```
- */
-export function configure(fn: (cfg: GraphReFlyConfig) => void): void {
-	if (defaultConfig._isFrozen()) {
-		throw new Error(
-			"configure() called after a node was created — the default " +
-				"GraphReFlyConfig is frozen. Call configure(...) at application " +
-				"startup, before any node factories run.",
-		);
-	}
-	fn(defaultConfig);
-}
-
-// Re-export the class for advanced callers that want an isolated instance.
-export { GraphReFlyConfig };
-
-// ---------------------------------------------------------------------------
-// NodeImpl
-// ---------------------------------------------------------------------------
-
-/**
- * Single-class node implementation. Covers state, producer, derived, effect,
- * and passthrough shapes. See `sugar.ts` for ergonomic factories and
- * `dynamicNode()` (sugar-level wrapper around plain `NodeImpl`).
- */
-export class NodeImpl<T = unknown> implements Node<T> {
-	// --- Identity ---
-	readonly _optsName: string | undefined;
-	readonly _describeKind: NodeDescribeKind | undefined;
-	readonly meta: Record<string, Node>;
-	/**
-	 * Cached `Object.keys(meta).length > 0` check. `meta` is frozen at
-	 * construction so this boolean never flips. Used by `_emit` to skip
-	 * the meta TEARDOWN fan-out block allocation on the common "no meta"
-	 * hot path.
-	 */
-	readonly _hasMeta: boolean;
-
-	// --- Config ---
-	readonly _config: GraphReFlyConfig;
-
-	// --- Topology ---
-	/** Mutable for autoTrackNode / Graph.connect() post-construction dep addition. */
-	_deps: DepRecord[];
-	_sinks: NodeSink | Set<NodeSink> | null = null;
-	_sinkCount = 0;
-
-	// --- State ---
-	_cached: T | undefined;
-	_status: NodeStatus;
-	_cleanup: NodeFnCleanup | undefined;
-	_store: Record<string, unknown> = {};
-	_waveHasNewData = false;
-	_hasNewTerminal = false;
-	/**
-	 * Set in `_depInvalidated` whenever a dep delivers INVALIDATE during a
-	 * wave. Used by `_maybeRunFnOnSettlement` to suppress both the pre-fn
-	 * skip RESOLVED emit AND the fn re-run when a wave consists only of
-	 * dep INVALIDATE arrivals: the cascade in `_onDepMessage`'s INVALIDATE
-	 * branch (`_emit(INVALIDATE_ONLY_BATCH)`) has already settled the wave,
-	 * and re-firing here would either deliver a redundant RESOLVED that
-	 * contradicts the just-cleared cache, or run fn with cleared
-	 * `prevData[i]` (e.g. `undefined * 2 = NaN`). DS-13.5.A invariant.
-	 *
-	 * Cleared in `_clearWaveFlags` alongside `_waveHasNewData` /
-	 * `_hasNewTerminal`.
-	 */
-	_waveHasInvalidate = false;
-	_hasCalledFnOnce = false;
-	_paused = false;
-	_pendingWave = false;
-	_isExecutingFn = false;
-	_pendingRerun = false;
-	_rerunDepth = 0;
-	/**
-	 * @internal Phase 13.8 reentrancy guard for `_setDeps` / `_addDep` /
-	 * `_removeDep`. Set on entry, cleared in `finally`. A reentrant
-	 * substrate call (typically synchronous re-entry from a push-on-
-	 * subscribe DATA → downstream subscriber → re-call) is rejected with
-	 * a clear error; the TLA+ spec assumes single-step atomicity, this
-	 * flag enforces that contract at the substrate boundary.
-	 *
-	 * Distinct from `_isExecutingFn` (which guards mid-fn rewires) — this
-	 * guards mid-rewire reentry.
-	 */
-	_inDepMutation = false;
-
-	// --- Settlement counter (A3) ---
-	/**
-	 * Count of deps currently in `dirty === true`. `_maybeRunFnOnSettlement`
-	 * treats `0` as "wave settled" — O(1) check for full dep settlement.
-	 */
-	_dirtyDepCount = 0;
-
-	// --- DS-13.5.A Q16 idempotency guard ---
-	/**
-	 * Set to `true` the first time a TEARDOWN message is fully processed by
-	 * `_updateState`. Used by `_frameBatch` to suppress the synthetic
-	 * `[COMPLETE]` auto-prefix on subsequent TEARDOWN deliveries (which would
-	 * otherwise re-deliver `[COMPLETE], [TEARDOWN]` pairs to sinks every time
-	 * a redundant TEARDOWN arrives via `Graph.destroy` broadcast + dep cascade).
-	 */
-	private _teardownDone = false;
-
-	// --- Per-batch emit accumulator (Bug 2: K+1 fan-in fix) ---
-	/**
-	 * Inside an explicit `batch(() => ...)` scope, every `_emit` accumulates
-	 * its already-framed messages here instead of dispatching synchronously.
-	 * At batch end, `_flushBatchPending` runs (registered via
-	 * `registerBatchFlushHook`) and delivers the whole accumulated batch as
-	 * one `downWithBatch` call — collapsing what would otherwise be K
-	 * separate sink invocations into one. This is the fix for the diamond
-	 * fan-in K+1 over-fire.
-	 *
-	 * `null` outside batch (or after flush). Only ever appended to within
-	 * a single explicit batch lifetime; reset to `null` on flush. State
-	 * updates (cache, version, status) still happen per-emit via
-	 * `_updateState` — only the downstream delivery is coalesced.
-	 */
-	_batchPendingMessages: Message[] | null = null;
-
-	// --- D282 R4.3.2 throw-rollback snapshot (locked 2026-05-23; /qa F3 widened) ---
-	/**
-	 * Captured lazily at the TOP of `_emit` on first state-touch inside an
-	 * explicit `batch()` scope. **Capture MUST precede every state-mutating
-	 * sub-path of the emit pipeline** — PAUSE/RESUME lock bookkeeping, meta
-	 * TEARDOWN fan-out, `_updateState`, and `_pushReplayBuffer` all mutate
-	 * fields covered by this snapshot. On outermost-batch THROW the
-	 * substrate's `batch.ts` invokes {@link _rollbackBatchPending} which
-	 * restores these fields and clears `_batchPendingMessages` WITHOUT
-	 * dispatching downstream — converging TS to the Rust substrate's
-	 * pre-existing `discard_wave_cleanup` + `restore_wave_cache_snapshots`
-	 * shape (`graphrefly-rs/crates/graphrefly-core/src/batch.rs:3693`).
-	 *
-	 * **Snapshot scope (D282 user lock — mirror at the invariant level:
-	 * "post-rollback observable state ≡ pre-batch observable state").**
-	 *
-	 * Top-level fields (cache/status/version/wave/replay/log-latch):
-	 * - `cached`/`status`/`versioning` — Rust's `restore_wave_cache_snapshots`
-	 *   equivalent. TS bundles version metadata on the live `_versioning`
-	 *   object (Rust splits via separate handle/version fields), so the
-	 *   restore mutates fields in place (same precedent as Lock 2.C
-	 *   `_prePauseSnapshot` restore).
-	 * - `hasCalledFnOnce` — R2.5.3 / D011 first-run gate flag.
-	 *   Un-reverted = subscriber-detectable behavioral leak via partial-
-	 *   deps gating semantics.
-	 * - `teardownDone` — R2.2.7 / R2.5.3 terminal-lifecycle flag.
-	 *   Un-reverted = structural terminal state post-rollback while emit-
-	 *   side was rolled back (E7-symmetric gap).
-	 * - `waveHasNewData` / `hasNewTerminal` / `waveHasInvalidate` — wave
-	 *   flags normally cleared by `_clearWaveFlags` at end-of-wave; on
-	 *   rollback they'd leak into the next wave's settlement decision.
-	 * - `replayBuffer` — `_pushReplayBuffer` is called at the dispatch
-	 *   point and may evict the oldest entry on overflow. Snapshot stores
-	 *   a **shallow content copy** (`[...buffer]` or `null`); restore
-	 *   replaces the full buffer (`/qa` F5 — pure length-truncation
-	 *   corrupts when an eviction happened during the batch).
-	 * - `equalsErrorLogged` — Lock 2.A once-per-lifetime log latch.
-	 *   Un-reverted = a buggy `equals` that fired only during the rolled-
-	 *   back wave silently suppresses future legitimate error logs.
-	 * - `pendingDeactivateAfterBatch` — `/qa` F4(c) defer-flag. TEARDOWN-
-	 *   inside-batch sets this so the irreversible `_deactivate()` side
-	 *   effect (dep unsubscribe + `onDeactivation` fire) is deferred to
-	 *   `_flushBatchPending` on the success path and cleared on rollback.
-	 *
-	 * Nested `pause` sub-snapshot (only populated when PAUSE/RESUME state
-	 * was touched during the batch; `null` otherwise — `/qa` F3):
-	 * - `locks` — clone of `_pauseLocks` Set (or `null` if buffer was null).
-	 * - `paused` / `pauseStartNs` / `pauseDroppedCount` / `pauseOverflowed` —
-	 *   pause-cycle bookkeeping fields, mutated by PAUSE/RESUME branches.
-	 * - `buffer` — shallow content copy of `_pauseBuffer` (or `null`).
-	 * - `prePauseSnapshot` — the pre-pause Lock 2.C snapshot itself;
-	 *   captured by the PAUSE branch on first-PAUSE-of-cycle. Restored
-	 *   verbatim on D282 rollback to preserve the Lock 2.C semantic.
-	 *
-	 * Capture order matters: snapshot is taken BEFORE the PAUSE/RESUME
-	 * block at line ~3270 (was AFTER in the initial D282 landing — caught
-	 * by /qa F3). `null` outside batch (or after flush/rollback). Cleared
-	 * on both paths (single-use per batch session).
-	 */
-	_preBatchSnapshot: {
-		cached: T | undefined;
-		status: NodeStatus;
-		versioning: { version: number; cid?: string; prev?: string | null } | undefined;
-		hasCalledFnOnce: boolean;
-		teardownDone: boolean;
-		waveHasNewData: boolean;
-		hasNewTerminal: boolean;
-		waveHasInvalidate: boolean;
-		replayBuffer: T[] | null;
-		equalsErrorLogged: boolean;
-		pendingDeactivateAfterBatch: boolean;
-		pause: {
-			locks: Set<unknown> | null;
-			paused: boolean;
-			buffer: Messages[] | null;
-			startNs: number | undefined;
-			droppedCount: number;
-			overflowed: boolean;
-			prePauseSnapshot: NodeImpl<T>["_prePauseSnapshot"];
-		} | null;
-	} | null = null;
-
-	/**
-	 * @internal D282 /qa F4(c) defer-flag. Set by the TEARDOWN branch in
-	 * `_updateState` when `isExplicitlyBatching()` is true; cleared either
-	 * by `_flushBatchPending` (which fires `_deactivate()` on the success
-	 * path) or by `_rollbackBatchPending` (which discards the pending
-	 * deactivation entirely on throw). Outside batch, the TEARDOWN branch
-	 * calls `_deactivate()` synchronously and never sets this flag.
-	 *
-	 * This is the F4 (c) fix surface: terminal-inside-batch's irreversible
-	 * side effect (dep unsubscribe + `onDeactivation` fire) is deferred so
-	 * the rollback path can keep the node alive. Used by the 4 in-tree
-	 * multi-channel-atomic-terminate callers (`external-register.ts` x3 +
-	 * `sqlite.ts` x1) that pre-date D282.
-	 */
-	_pendingDeactivateAfterBatch = false;
-
-	// --- PAUSE/RESUME lock tracking (C0) ---
-	/**
-	 * Set of active pause locks held against this node. Every `[PAUSE, lockId]`
-	 * adds its `lockId` to the set; every `[RESUME, lockId]` removes it.
-	 * `_paused` is a derived quantity: `_pauseLocks.size > 0`. Multi-pauser
-	 * correctness — one controller releasing its lock does NOT resume the
-	 * node while another controller still holds its lock.
-	 */
-	_pauseLocks: Set<unknown> | null = null;
-	/**
-	 * Buffered settle slices (tier-3 DATA/RESOLVED + tier-4 INVALIDATE)
-	 * held while paused. Only populated when `_pausable === "resumeAll"`
-	 * (bufferAll mode). Each entry is one **wave** — the tier-3+4 subset
-	 * of an entire `_emit` call's `finalMessages`, preserving wave shape
-	 * (single-DATA, multi-DATA, or single-RESOLVED). On final lock release
-	 * the buffer is replayed through `_emit` once per wave so the original
-	 * Lock 1.D wave-content invariants (multi-DATA waves emit verbatim with
-	 * no equals substitution; single-DATA waves equals-substitute against
-	 * the cache shaped by all prior buffered waves) hold across the pause
-	 * boundary. Non-bufferAll pause mode drops DATA on the floor (upstream
-	 * is expected to honor PAUSE by suppressing production).
-	 *
-	 * Source: Lock 2.C + 2.C′ + 2.C′-pre (Phase 13.6.A locks).
-	 */
-	_pauseBuffer: Messages[] | null = null;
-	/**
-	 * Monotonic-ns timestamp of the first PAUSE that started the current
-	 * pause cycle. Cleared on final RESUME. Used to populate
-	 * `lockHeldDurationMs` in `pauseBufferMax` overflow ERRORs (Lock 6.A).
-	 */
-	_pauseStartNs: number | undefined;
-	/**
-	 * Cumulative count of waves dropped due to `pauseBufferMax` overflow
-	 * during the current pause cycle. Cleared on final RESUME. Reported in
-	 * the overflow ERROR diagnostic; useful for users tuning the cap.
-	 */
-	_pauseDroppedCount = 0;
-	/**
-	 * Whether an overflow ERROR has already been emitted for the current
-	 * pause cycle. Gates the ERROR to once per pause cycle so a producer
-	 * pushing thousands of waves over the cap doesn't spam errors. Cleared
-	 * on final RESUME. Source: Lock 6.A.
-	 */
-	_pauseOverflowed = false;
-	/**
-	 * Lock 2.C — pre-pause cache/status/versioning snapshot. Captured on the
-	 * FIRST PAUSE of a pause cycle (only under `_pausable === "resumeAll"`),
-	 * in the SAME `if (!wasPaused)` block as `_pauseStartNs` so a mid-drain
-	 * re-pause (a subscriber's reaction to a replayed wave issuing a fresh
-	 * PAUSE) re-captures the new cycle's baseline — the `_pauseBuffer == null`
-	 * guard is NOT a valid "first pause of cycle" signal during the drain
-	 * (the drain sets `_pauseBuffer = []`, not `null`, before replaying).
-	 * Restored just before the RESUME drain replays buffered waves so each
-	 * replayed wave's `_updateState` re-derives equals/version from the
-	 * **pre-pause baseline forward** — spec §2.6 (Lock 2.C): "the cache as at
-	 * the end of the previous wave in the buffer, starting from pre-pause
-	 * cache". Without the restore a mid-pause `_updateState` already advanced
-	 * `_cached`, so every buffered same-value single-DATA wave collapsed to
-	 * RESOLVED on replay (the old D2 "absorbed pulse" semantic, now retired).
-	 *
-	 * `versioning` captures the **mutable** version state (`version`, plus V1
-	 * `cid`/`prev`) — NOT the whole `NodeVersionInfo` object: `_versioning`
-	 * object identity is stable across the synchronous PAUSE→drain→RESUME
-	 * window (`_upgradeVersioning`/`_applyVersioning` is rejected mid-fn and
-	 * cannot interleave), so restoring fields onto the live object is sound
-	 * and keeps `id` intact. Restoring only `version` (the V0 counter) would
-	 * leave V1's `cid`/`prev` linked-history chain pointing at a mid-pause
-	 * cid — a fabricated audit edge (spec §7). Value snapshots are by
-	 * reference: spec treats node values as immutable, so an in-place mutation
-	 * of `_cached` across a pause is a caller contract violation, not a
-	 * substrate concern.
-	 *
-	 * `null` = not in a bufferAll pause cycle. Cleared on final RESUME,
-	 * `_deactivate`, and `_resetForFreshLifecycle`.
-	 */
-	_prePauseSnapshot: {
-		cached: T | undefined;
-		status: NodeStatus;
-		versioning: { version: number; cid?: string; prev?: string | null } | undefined;
-	} | null = null;
-	/**
-	 * Whether `_updateState` has already logged an `equals`-throw under
-	 * `equalsThrowPolicy: "log-and-continue"`. Gates the `console.error`
-	 * to once per node lifetime so a buggy `equals` doesn't spam logs at
-	 * production rates. Source: Lock 2.A (Phase 13.6.A).
-	 */
-	_equalsErrorLogged = false;
-
-	// --- Lock 6.G: replayBuffer (spec §2.5) ---
-	/**
-	 * Circular buffer of last-N **outgoing** DATA values for late-subscriber
-	 * catch-up. `null` when the option is unset or disabled (capacity 0).
-	 * Allocated lazily on first push so nodes that never emit DATA pay no
-	 * allocation cost. See `NodeOptions.replayBuffer` for full semantics.
-	 *
-	 * Cleared by `_deactivate` (TEARDOWN, last-unsub) and
-	 * `_resetForFreshLifecycle` (terminal-resubscribable reset). NOT cleared
-	 * by INVALIDATE on a non-terminal node — a late subscriber arriving
-	 * post-INVALIDATE still receives the prior emission history.
-	 */
-	_replayBuffer: T[] | null = null;
-	/**
-	 * Cap for `_replayBuffer`. Frozen at construction from
-	 * `opts.replayBuffer ?? 0`. `0` means the feature is disabled — push
-	 * site short-circuits and `defaultOnSubscribe` falls back to the
-	 * legacy cache-DATA handshake.
-	 */
-	readonly _replayBufferCapacity: number;
-
-	// --- Options (frozen at construction) ---
-	/**
-	 * The user-supplied transform fn. Mutable post-construction ONLY via
-	 * `_setDeps` / `_addDep` / `_removeDep` `opts.fn` (Phase 13.8). Callers
-	 * MUST NOT assign directly — the substrate ensures the next `_execFn`
-	 * reads the new value at the right wave boundary, fires old cleanup's
-	 * `onRerun`, and updates `_cleanup` from the new fn's return.
-	 *
-	 * @internal Direct mutation outside `_setDeps`/`_addDep`/`_removeDep`
-	 *   would skip the cleanup wrap-up and is a bug.
-	 */
-	_fn: NodeFn | undefined;
-	readonly _equals: (a: T, b: T) => boolean;
-	readonly _resubscribable: boolean;
-	readonly _resetOnTeardown: boolean;
-	readonly _autoComplete: boolean;
-	readonly _autoError: boolean;
-	readonly _pausable: boolean | "resumeAll";
-	/**
-	 * @internal First-run-gate override (§2.7 `R2.7.2`, DS-2.7.A 2026-05-19).
-	 * `false` (default) holds fn until every dep has delivered real DATA
-	 * (or terminal, when {@link _terminalAsRealInput} is set per `R2.7.1`).
-	 * `true` disables the gate; fn fires as soon as `_dirtyDepCount === 0`,
-	 * regardless of dep sentinel state — the fn body MUST guard every dep
-	 * slot for SENTINEL (`ctx.prevData[i] === undefined`). Operators that
-	 * need partial firing (`withLatestFrom`, `valve`, worker-bridge
-	 * aggregators) pass `partial: true` explicitly at construction.
-	 */
-	readonly _partial: boolean;
-	/**
-	 * @internal Reduce-class first-run-gate opt-in (§2.7 `R2.7.1`,
-	 * DS-2.7.A 2026-05-19). When `true`, a dep's terminal counts as a
-	 * settled state for the gate (in addition to real DATA), so operators
-	 * like `reduce` / `last` / `take` that need to fire on
-	 * upstream-COMPLETE-without-DATA actually run their terminal branch.
-	 * Ignored when {@link _partial} is `true` (gate is OFF either way).
-	 */
-	readonly _terminalAsRealInput: boolean;
-	readonly _guard: NodeGuard | undefined;
-	/**
-	 * @internal Additional guards stacked at runtime via {@link NodeImpl._pushGuard}
-	 * (e.g. by `policyGate({ mode: "enforce" })`, roadmap §9.2). Effective
-	 * write/signal/observe checks AND the original `_guard` with every entry here.
-	 */
-	_extraGuards: Set<NodeGuard> | undefined;
-	_hashFn: HashFn;
-	_versioning: NodeVersionInfo | undefined;
-	/**
-	 * Explicit versioning level, tracked separately from `_versioning` so
-	 * monotonicity checks and future v2/v3 extensions don't rely on the
-	 * fragile `"cid" in _versioning` shape discriminator. `undefined` means
-	 * the node has no versioning attached; `0` / `1` / future levels name
-	 * the tier. Mutated in lockstep with `_versioning` by the constructor
-	 * and by `_applyVersioning`.
-	 */
-	_versioningLevel: VersioningLevel | undefined;
-
-	// --- ABAC ---
-	_lastMutation: { actor: Actor; timestamp_ns: number } | undefined;
-
-	/**
-	 * @internal Per-node inspector hooks for `Graph.observe(path,
-	 * { causal, derived })`. Fires in `_onDepMessage` and `_execFn`.
-	 * Attached via `_setInspectorHook` (returns a disposer). Multiple
-	 * observers can attach simultaneously — all registered hooks fire for
-	 * every event.
-	 */
-	_inspectorHooks: Set<NodeInspectorHook> | undefined;
-
-	// --- Actions (built once in the constructor) ---
-	readonly _actions: NodeActions;
-
-	constructor(deps: readonly Node[], fn: NodeFn | undefined, opts: NodeOptions<T>) {
-		// Bind to config FIRST so meta nodes inherit it. Touching a hook
-		// getter below freezes the config on first node creation.
-		this._config = opts.config ?? defaultConfig;
-		void this._config.onMessage;
-
-		this._optsName = opts.name;
-		this._describeKind = opts.describeKind;
-		this._equals = (opts.equals ?? (Object.is as (a: T, b: T) => boolean)) as (
-			a: T,
-			b: T,
-		) => boolean;
-		this._resubscribable = opts.resubscribable ?? false;
-		this._resetOnTeardown = opts.resetOnTeardown ?? false;
-		this._autoComplete = opts.completeWhenDepsComplete ?? true;
-		this._autoError = opts.errorWhenDepsError ?? true;
-		this._pausable = opts.pausable ?? true;
-		// Lock 6.G (spec §2.5): clamp to a non-negative integer. Negative /
-		// fractional / NaN / Infinity all collapse to `0` (disabled). The
-		// push site short-circuits on capacity 0, so the field doubles as
-		// the on/off switch.
-		const replayCapRaw = opts.replayBuffer;
-		this._replayBufferCapacity =
-			typeof replayCapRaw === "number" && Number.isFinite(replayCapRaw) && replayCapRaw > 0
-				? Math.floor(replayCapRaw)
-				: 0;
-		this._guard = opts.guard;
-		this._fn = fn;
-		// Spec §2.7 first-run gate. Default `false` = gate ON — matches the
-		// universal "fn does not fire until every declared dep has delivered
-		// real DATA" contract (R2.7.0). Operators that deliberately fire on
-		// partial deps (`withLatestFrom`, `valve`, worker-bridge aggregators)
-		// opt out with `partial: true` (R2.7.2). Zero-dep producer-pattern
-		// factories (`stratify`, `budgetGate`, `distill`, `verifiable`) are
-		// unaffected — the gate has no deps to hold on an empty `_deps` array.
-		this._partial = opts.partial ?? false;
-		// Spec §2.7 R2.7.1 (DS-2.7.A cross-port lock 2026-05-19). Reduce-class
-		// operators (`reduce`/`scan`/`last`/`take`/`takeWhile`) opt terminal
-		// into the gate's settle predicate so they fire on
-		// upstream-COMPLETE-without-DATA to emit a seed/accumulator or forward
-		// COMPLETE. Default `false` = terminal does NOT settle; a source that
-		// only ever terminates without real DATA holds the gate.
-		this._terminalAsRealInput = opts.terminalAsRealInput ?? false;
-
-		// `undefined` is the sentinel ("no cached value") so `initial: undefined`
-		// is treated as absent. `null` is a valid DATA value and sets the cache.
-		this._cached = opts.initial !== undefined ? (opts.initial as T) : undefined;
-		// State-with-initial starts "settled"; everything else starts "sentinel".
-		this._status =
-			deps.length === 0 && fn == null && this._cached !== undefined ? "settled" : "sentinel";
-
-		// Versioning
-		// Hash resolution: per-node `opts.versioningHash` wins; then the
-		// bound config's `defaultHashFn`; then the vendored sync SHA-256.
-		// Hot-path workloads that want a faster hash (xxHash, FNV-1a) can
-		// set it once at app init via `configure(cfg => { cfg.defaultHashFn = ... })`.
-		this._hashFn = opts.versioningHash ?? this._config.defaultHashFn ?? defaultHash;
-		// Versioning level resolution: per-node `opts.versioning` wins; if
-		// absent, fall back to the bound config's `defaultVersioning`. `null`
-		// stays unversioned. Explicit levels (0, 1, …) attach the versioning
-		// info at construction so the next DATA emit advances it.
-		const versioningLevel: VersioningLevel | undefined =
-			opts.versioning ?? this._config.defaultVersioning;
-		this._versioningLevel = versioningLevel;
-		this._versioning =
-			versioningLevel != null
-				? createVersioning(versioningLevel, this._cached === undefined ? undefined : this._cached, {
-						id: opts.versioningId,
-						hash: this._hashFn,
-					})
-				: undefined;
-
-		// Per-dep records: one DepRecord per declared dep.
-		this._deps = deps.map(createDepRecord);
-
-		// Meta companions (simple state children; inherit config + guard +
-		// `resubscribable` from parent). EC7 (Tier 4.2, 2026-04-29): meta
-		// companions inherit `resubscribable` so a resubscribable producer's
-		// meta children also accept post-terminal-reset re-emissions.
-		// Without this, a `resubscribable: true` parent's `withStatus.status`
-		// / `withBreaker.breakerState` / `rateLimiter.droppedCount` companion
-		// stays terminated after the parent's first terminal — defeating the
-		// "next subscription cycle resets" semantic the parent advertises.
-		const meta: Record<string, Node> = {};
-		for (const [k, v] of Object.entries(opts.meta ?? {})) {
-			const metaOpts: NodeOptions<unknown> = {
-				initial: v,
-				name: `${opts.name ?? "node"}:meta:${k}`,
-				describeKind: "state",
-				config: this._config,
-			};
-			if (opts.guard != null) metaOpts.guard = opts.guard;
-			if (opts.resubscribable === true) metaOpts.resubscribable = true;
-			meta[k] = new NodeImpl<unknown>([], undefined, metaOpts);
-		}
-		Object.freeze(meta);
-		this.meta = meta;
-		this._hasMeta = Object.keys(meta).length > 0;
-
-		// Actions: built once, closure over `this`. Every call goes through
-		// `_emit` which owns the full dispatch invariant — tier sort,
-		// synthetic DIRTY prefix, equals substitution, and phase dispatch.
-		// One call = one wave. Multiple calls produce multiple waves.
-		// No accumulation, no user-facing bundle builder.
-		const self = this;
-		this._actions = {
-			emit(value: unknown): void {
-				self._emit([[DATA, value] as Message]);
-			},
-			down(messageOrMessages: Message | Messages): void {
-				self._emit(normalizeMessages(messageOrMessages));
-			},
-			up(messageOrMessages: Message | Messages): void {
-				self._emitUp(normalizeMessages(messageOrMessages));
-			},
-		};
-
-		// Bind commonly detached protocol methods.
-		this.down = this.down.bind(this);
-		this.up = this.up.bind(this);
-	}
-
-	// --- Derived state ---
-
-	private get _isTerminal(): boolean {
-		return this._status === "completed" || this._status === "errored";
-	}
-
-	// --- Public getters ---
-
-	get name(): string | undefined {
-		return this._optsName;
-	}
-
-	get status(): NodeStatus {
-		return this._status;
-	}
-
-	get cache(): T | undefined | null {
-		return this._cached === undefined ? undefined : (this._cached as T);
-	}
-
-	get lastMutation(): Readonly<{ actor: Actor; timestamp_ns: number }> | undefined {
-		return this._lastMutation;
-	}
-
-	get v(): Readonly<NodeVersionInfo> | undefined {
-		return this._versioning;
-	}
-
-	hasGuard(): boolean {
-		return this._guard != null;
-	}
-
-	/**
-	 * @internal Retroactively attach (or upgrade) versioning state on this
-	 * node. Intended for `Graph.setVersioning(level)` bulk application and
-	 * for rare cases where a specific node needs to be bumped to a higher
-	 * level (e.g., `v0 → v1`) after construction.
-	 *
-	 * **Safety:** the mutation is rejected mid-wave. Specifically,
-	 * throws if the node is currently executing its fn (`_isExecutingFn`).
-	 * Callers at quiescent points — before the first sink subscribes, or
-	 * after all sinks unsubscribe, or between external `down()` / `emit()`
-	 * invocations — are safe. The re-entrance window that motivated §10.6.4
-	 * removal was the "transition `_versioning` from `undefined` to a fresh
-	 * object mid-`_updateState`" case; that path is now guarded.
-	 *
-	 * **Monotonicity:** levels can only go up. Downgrade (e.g., `v1 → v0`)
-	 * is a no-op — once a node carries higher-level metadata, dropping it
-	 * mid-graph would tear the linked-history invariant for v1 and above.
-	 *
-	 * **Linked-history boundary (D1, 2026-04-13):** upgrading v0 → v1
-	 * produces a **fresh history root**. The new v1 state has `cid =
-	 * hash(currentCachedValue)` and `prev = null`, not a synthetic `prev`
-	 * anchored to any previous v0 value. The v0 monotonic `version` counter
-	 * is preserved across the upgrade, but the linked-cid chain (spec §7)
-	 * starts fresh at the upgrade point. Downstream audit tools that walk
-	 * `v.cid.prev` backwards through time will see a `null` boundary at
-	 * the upgrade — **this is intentional**: v0 had no cid to link to, and
-	 * fabricating one would lie about the hash. Callers that require an
-	 * unbroken cid chain from birth must attach versioning at construction
-	 * via `opts.versioning` or `config.defaultVersioning`, not retroactively.
-	 *
-	 * @param level - New minimum versioning level.
-	 * @param opts - Optional id / hash overrides; applied only if the
-	 *   node currently has no versioning state.
-	 */
-	_applyVersioning(level: VersioningLevel, opts?: { id?: string; hash?: HashFn }): void {
-		if (this._isExecutingFn) {
-			throw new Error(
-				`Node "${this.name}": _applyVersioning cannot run mid-fn — ` +
-					"call it outside of `_execFn` (typically at graph setup time " +
-					"before the first subscribe).",
-			);
-		}
-		const currentLevel = this._versioningLevel;
-		if (currentLevel != null && level <= currentLevel) {
-			// Downgrade or no-op. Monotonic: higher levels only.
-			return;
-		}
-		const hash = opts?.hash ?? this._hashFn;
-		if (hash !== this._hashFn) this._hashFn = hash;
-		const initialValue = this._cached === undefined ? undefined : this._cached;
-		// Preserve the existing id + version counter across upgrades so
-		// downstream consumers watching `v.id` don't see an identity jump.
-		const current = this._versioning;
-		const preservedId = current?.id ?? opts?.id;
-		const preservedVersion = current?.version ?? 0;
-		const fresh = createVersioning(level, initialValue, {
-			id: preservedId,
-			hash,
-		});
-		fresh.version = preservedVersion;
-		this._versioning = fresh;
-		this._versioningLevel = level;
-	}
-
-	/**
-	 * @internal Attach an inspector hook. Returns a disposer that removes
-	 * the hook. Used by `Graph.observe(path, { causal, derived })` to build
-	 * causal traces. Multiple hooks may be attached concurrently — all fire
-	 * for every event in registration order. Passing `undefined` is a no-op
-	 * and returns a no-op disposer.
-	 */
-	_setInspectorHook(hook?: NodeInspectorHook): () => void {
-		if (hook == null) return () => {};
-		if (this._inspectorHooks == null) this._inspectorHooks = new Set();
-		this._inspectorHooks.add(hook);
-		return () => {
-			this._inspectorHooks?.delete(hook);
-			if (this._inspectorHooks?.size === 0) this._inspectorHooks = undefined;
-		};
-	}
-
-	/**
-	 * @internal Push an additional guard onto this node. Effective enforcement
-	 * is the AND of `_guard` and every guard pushed via this hook — any one
-	 * rejecting throws {@link GuardDenied}. Returns a disposer that removes
-	 * the pushed guard. Multiple guards may be stacked simultaneously.
-	 *
-	 * Used by `policyGate({ mode: "enforce" })` (roadmap §9.2) to overlay
-	 * runtime constraint enforcement onto an existing graph without rebuilding
-	 * its nodes. Pre-1.0 internal API; not part of the public surface.
-	 *
-	 * **Identity semantics:** guards are tracked in a `Set`, so pushing the
-	 * same `NodeGuard` reference twice is a single registration. Wrap each
-	 * push in a unique closure if independent stacking is needed.
-	 *
-	 * **Iteration order:** insertion-ordered (`Set` semantics). Determinism
-	 * follows from single-threaded JS execution; nested re-entry from inside
-	 * a guard body (push/pop while iterating) is undefined-but-survivable.
-	 */
-	_pushGuard(guard: NodeGuard): () => void {
-		if (this._extraGuards == null) this._extraGuards = new Set();
-		this._extraGuards.add(guard);
-		return () => {
-			this._extraGuards?.delete(guard);
-			if (this._extraGuards?.size === 0) this._extraGuards = undefined;
-		};
-	}
-
-	allowsObserve(actor: Actor): boolean {
-		if (this._guard == null && this._extraGuards == null) return true;
-		const a = normalizeActor(actor);
-		if (this._guard != null && !this._guard(a, "observe")) return false;
-		if (this._extraGuards != null) {
-			for (const eg of this._extraGuards) {
-				if (!eg(a, "observe")) return false;
-			}
-		}
-		return true;
-	}
-
-	// --- Guard helper ---
-
-	private _checkGuard(options?: NodeTransportOptions): void {
-		if (options?.internal) return;
-		const hasGuard = this._guard != null || this._extraGuards != null;
-		const hasActor = options?.actor != null;
-		// Skip work entirely when there's nothing to check or attribute.
-		if (!hasGuard && !hasActor) return;
-		const actor = normalizeActor(options?.actor);
-		const action: GuardAction = options?.delivery === "signal" ? "signal" : "write";
-		if (this._guard != null && !this._guard(actor, action)) {
-			throw new GuardDenied({ actor, action, nodeName: this.name });
-		}
-		if (this._extraGuards != null) {
-			for (const eg of this._extraGuards) {
-				if (!eg(actor, action)) {
-					throw new GuardDenied({ actor, action, nodeName: this.name });
-				}
-			}
-		}
-		// Populate `_lastMutation` whenever guards ran OR an explicit actor was
-		// passed — `auditTrail` (roadmap §9.2) relies on this for attribution
-		// on graphs without ABAC. Internal writes (no actor, no guard) skip
-		// attribution to avoid recording derived recompute storms.
-		this._lastMutation = { actor, timestamp_ns: wallClockNs() };
-	}
-
-	// --- Public transport ---
-
-	down(messageOrMessages: Message | Messages, options?: NodeTransportOptions): void {
-		const messages = normalizeMessages(messageOrMessages);
-		if (messages.length === 0) return;
-		this._checkGuard(options);
-		this._emit(messages);
-	}
-
-	emit(value: T | undefined | null, options?: NodeTransportOptions): void {
-		this._checkGuard(options);
-		this._emit([[DATA, value] as Message]);
-	}
-
-	/**
-	 * Upstream forward (spec §1.4). Carries control-plane tiers only —
-	 * DIRTY (tier 1), PAUSE / RESUME (tier 2), INVALIDATE (tier 4),
-	 * TEARDOWN (tier 6) — and rejects tier-3 (DATA / RESOLVED) and tier-5
-	 * (COMPLETE / ERROR) per `_validateUpTiers` — downstream-only by
-	 * protocol.
-	 *
-	 * **Upstream-origin PAUSE applies at the PARENT's lockset via the parent's
-	 * own `up()`, not at this source's `_pauseLocks` when `_deps.length === 0`.**
-	 * At a leaf source, `up()` is a no-op: a subscription that calls
-	 * `sink.up([[PAUSE, lockId]])` expecting the source itself to pause is
-	 * NOT honored today. TLA+ `DeliverUp` encodes the target contract (source
-	 * applies its own lock); the runtime falls short. No in-tree caller relies
-	 * on upstream-origin PAUSE at a leaf, so this is documented as intentional
-	 * for now (option (c) in docs/optimizations.md "Up-direction PAUSE
-	 * semantics"). A future option (a) would tighten the runtime here; any
-	 * new consumer needing leaf-source upstream PAUSE is the trigger.
-	 *
-	 * **LockId uniqueness is the caller's responsibility.** Locks are stored
-	 * in a `Set<unknown>`; `Pause(n, 10)` and an upstream `UpPause(child, 10)`
-	 * that reaches `n` insert the SAME element — one `Resume(n, 10)` clears
-	 * both origins. Distinct pauser identities must use distinct lockIds.
-	 * Surfaced by the rigor-infra TLC audit (docs/optimizations.md "LockId
-	 * collision across up() and down() origin").
-	 */
-	up(messageOrMessages: Message | Messages, options?: NodeTransportOptions): void {
-		if (this._deps.length === 0) return;
-		const messages = normalizeMessages(messageOrMessages);
-		if (messages.length === 0) return;
-		this._checkGuard(options);
-		const forwardOpts: NodeTransportOptions = options ?? { internal: true };
-		// Validate tier constraint before fanning out (B1.4 option a).
-		this._validateUpTiers(messages);
-		for (const d of this._deps) {
-			d.node.up?.(messages, forwardOpts);
-		}
-	}
-
-	/**
-	 * @internal Internal up-path used by `actions.up(...)` from inside fn.
-	 * Same tier validation as public `up`, but bypasses the guard check
-	 * since the fn context is already inside an authorized operation.
-	 */
-	private _emitUp(messages: Messages): void {
-		if (this._deps.length === 0) return;
-		if (messages.length === 0) return;
-		this._validateUpTiers(messages);
-		for (const d of this._deps) {
-			d.node.up?.(messages, { internal: true });
-		}
-	}
-
-	/**
-	 * @internal Enforce spec §1.2 — up-direction messages are restricted to
-	 * the control-plane tiers (START, DIRTY, PAUSE, RESUME, INVALIDATE,
-	 * TEARDOWN). Tier 3 (DATA/RESOLVED) and tier 5 (COMPLETE/ERROR) are
-	 * downstream-only. Emitting them via `up` would bypass equals
-	 * substitution and cache advance entirely and is a protocol bug.
-	 *
-	 * Post-DS-13.5.A: INVALIDATE is tier 4 and IS allowed upstream — it is
-	 * a settle-class control signal whose role for `_dirtyDepCount` mirrors
-	 * RESOLVED. Only tier 3 (value settle) and tier 5 (terminal lifecycle)
-	 * are rejected.
-	 */
-	private _validateUpTiers(messages: Messages): void {
-		const tierOf = this._config.tierOf;
-		for (const m of messages) {
-			const tier = tierOf(m[0]);
-			if (tier === 3 || tier === 5) {
-				throw new Error(
-					`Node "${this.name}": tier-${tier} messages cannot flow up — ` +
-						"DATA/RESOLVED/COMPLETE/ERROR are downstream-only. Use " +
-						"`down(...)` for value delivery; `up(...)` is for control " +
-						"signals (DIRTY, INVALIDATE, PAUSE, RESUME, TEARDOWN).",
-				);
-			}
-		}
-	}
-
-	subscribe(sink: NodeSink, actor?: Actor): () => void {
-		if (actor != null && this._guard != null) {
-			const a = normalizeActor(actor);
-			if (!this._guard(a, "observe")) {
-				throw new GuardDenied({ actor: a, action: "observe", nodeName: this.name });
-			}
-		}
-
-		// R2.2.7.b (D118, 2026-05-10): non-resubscribable + terminal →
-		// reject. The stream is permanently over; late subscribers get an
-		// honest error instead of a courtesy replay of past lifecycle
-		// events. Operators (zip / concat / race / take_until / switch_map
-		// / merge_map / etc.) that subscribe to upstream sources MUST
-		// handle this by skipping the source. The previous behavior
-		// (replay [START, DATA?, COMPLETE|ERROR, TEARDOWN?]) was a
-		// courtesy that conflated "subscribe to a live stream" with
-		// "receive a replay of past events"; R2.2.7.b makes the contract
-		// explicit.
-		if (this._isTerminal && !this._resubscribable) {
-			throw new TornDownError(this.name ?? "<anonymous>", this._status);
-		}
-
-		// R2.2.7.a (D118, 2026-05-10): resubscribable + terminal → reset
-		// to fresh lifecycle. TEARDOWN does NOT block reset — TEARDOWN is
-		// the cleanup signal of the prior activation cycle, not permanent
-		// destruction. `_resetForFreshLifecycle` clears `_teardownDone`
-		// along with the rest of the per-lifecycle state.
-		const wasTerminal = this._isTerminal;
-		const afterTerminalReset = wasTerminal && this._resubscribable;
-		if (afterTerminalReset) {
-			this._resetForFreshLifecycle();
-		}
-
-		this._sinkCount += 1;
-
-		// Subscribe ceremony via singleton.
-		// Rollback on throw: undo the sinkCount bump — sink is not yet registered,
-		// no _activate() has run, nothing else to clean up.
-		let subCleanup: (() => void) | undefined;
-		try {
-			subCleanup = this._config.onSubscribe(
-				this as unknown as NodeCtx,
-				sink,
-				{ sinkCount: this._sinkCount, afterTerminalReset },
-				this._actions,
-			);
-		} catch (err) {
-			this._sinkCount -= 1;
-			throw err;
-		}
-
-		// Register sink AFTER START delivery (spec §2.2).
-		if (this._sinks == null) {
-			this._sinks = sink;
-		} else if (typeof this._sinks === "function") {
-			this._sinks = new Set<NodeSink>([this._sinks, sink]);
-		} else {
-			this._sinks.add(sink);
-		}
-
-		// First-subscriber activation.
-		// Rollback on throw: undo sink registration, sinkCount bump, and subCleanup.
-		// _activate() rolls back its own partial dep subscriptions before re-throwing.
-		const isTerminalNow = this._isTerminal;
-		if (this._sinkCount === 1 && !isTerminalNow) {
-			// DS-13.5.A Q16 defensive reset: clear `_teardownDone` whenever a
-			// node comes alive on first-subscriber activation. `_deactivate`
-			// already clears it on last-sink-detach, but a non-resubscribable
-			// node that was re-added to a different graph (or any path that
-			// reaches `_sinkCount === 0` without `_deactivate` running) would
-			// otherwise carry a stale `_teardownDone=true` into the new
-			// lifecycle, permanently wedging fn re-runs at the
-			// `_maybeRunFnOnSettlement` early-return guard.
-			this._teardownDone = false;
-			try {
-				this._activate();
-			} catch (err) {
-				this._sinkCount -= 1;
-				this._removeSink(sink);
-				// Restore status: onSubscribe emitted START which set _status to
-				// "pending". With zero sinks the node is back to its pre-subscribe
-				// state; reset so node.status reflects no active subscription.
-				if (this._sinkCount === 0) this._status = "sentinel";
-				if (typeof subCleanup === "function") {
-					try {
-						subCleanup();
-					} catch {
-						/* best-effort: subCleanup errors are secondary */
-					}
-				}
-				throw err;
-			}
-		}
-
-		// Reflect "activated but no value yet" as pending.
-		if (this._status === "sentinel" && this._cached === undefined) {
-			this._status = "pending";
-		}
-
-		let removed = false;
-		return (): void => {
-			if (removed) return;
-			removed = true;
-			this._sinkCount -= 1;
-			this._removeSink(sink);
-			if (typeof subCleanup === "function") subCleanup();
-			if (this._sinks == null) this._deactivate();
-		};
-	}
-
-	private _removeSink(sink: NodeSink): void {
-		if (this._sinks === sink) {
-			this._sinks = null;
-		} else if (this._sinks != null && typeof this._sinks !== "function") {
-			this._sinks.delete(sink);
-			if (this._sinks.size === 1) {
-				const [only] = this._sinks;
-				this._sinks = only;
-			} else if (this._sinks.size === 0) {
-				this._sinks = null;
-			}
-		}
-	}
-
-	/**
-	 * @internal Clear all per-lifecycle state so a subsequent activation (or
-	 * existing subscriber's next wave) sees a fresh node — same shape as the
-	 * `subscribe()` `afterTerminalReset` path, but does NOT disconnect deps.
-	 *
-	 * Two callers:
-	 * 1. `subscribe()` when `wasTerminal && _resubscribable` — first new
-	 *    subscriber after a terminal-resubscribable reaches a clean state.
-	 * 2. `_updateState`'s INVALIDATE branch when `_isTerminal && _resubscribable`
-	 *    — INVALIDATE on a terminal-resubscribable is a lifecycle boundary
-	 *    (DS-13.5.A pass-3, N1 fix). Without this, a multi-subscriber
-	 *    resubscribable node that goes terminal, then has one sink unsub
-	 *    (skipping `_deactivate`), then receives INVALIDATE, would carry
-	 *    stale `_hasCalledFnOnce` / `_dirtyDepCount` / DepRecord state into
-	 *    the next wave — fn would compute against ghost `prevData`.
-	 *
-	 * The reset does NOT touch `_sinks`, `_deps[i].unsub`, or `_cleanup` —
-	 * those are owned by `_activate`/`_deactivate`. Existing subscribers
-	 * stay attached; existing dep subscriptions stay live; pending cleanup
-	 * (e.g. an `invalidate?` hook on object-form cleanup) fires through the
-	 * caller's normal path after this returns.
-	 *
-	 * Phase 13.6.B QA D1 — fires `onResubscribableReset` (named-hook only)
-	 * on the active cleanup BEFORE clearing internal state. This is the
-	 * lifecycle hook for one-shot store-flag operators (`frozenContext`,
-	 * `take`, `last` etc.) that need to clear their flag whenever the
-	 * node enters a fresh lifecycle, even when `_deactivate` did not run
-	 * (multi-sub-stayed case). The hook fires AT MOST once per reset —
-	 * it's nulled out after firing so a follow-up `_deactivate` on the
-	 * same lifecycle instance doesn't re-fire it.
-	 */
-	private _resetForFreshLifecycle(): void {
-		// QA D1: fire `onResubscribableReset` BEFORE clearing internal
-		// state so the user hook sees a coherent pre-reset world (e.g.,
-		// `_cached` still populated for any "I am being torn down with
-		// value V" introspection). Only the named-hook
-		// `onResubscribableReset` slot fires on a lifecycle-reset boundary;
-		// sites that only wire `onDeactivation` / `onRerun` are deliberately
-		// NOT fired here, so a reset never overfires their teardown body.
-		const c = this._cleanup;
-		if (c != null) {
-			const hook = c.onResubscribableReset;
-			if (typeof hook === "function") {
-				c.onResubscribableReset = undefined;
-				try {
-					hook();
-				} catch {
-					/* best-effort — instrumentation must not break the data plane */
-				}
-			}
-		}
-		this._cached = undefined;
-		this._status = "sentinel";
-		// Lock 6.D (Phase 13.6.B): `ctx.store` PRESERVES across lifecycle
-		// boundaries by default. Operators that depend on per-lifecycle
-		// reset (`take(n)` restart-from-zero, `scan` restart-from-seed,
-		// per-stream parser buffers) clear via `onDeactivation` (last-
-		// sink-detach / TEARDOWN) AND/OR `onResubscribableReset`
-		// (multi-sub-stayed terminal-resubscribable boundary, fired
-		// from this method above). See G.20 in COMPOSITION-GUIDE-GRAPH.
-		this._hasCalledFnOnce = false;
-		this._waveHasNewData = false;
-		this._hasNewTerminal = false;
-		this._waveHasInvalidate = false;
-		this._teardownDone = false;
-		this._paused = false;
-		this._pendingWave = false;
-		this._pendingRerun = false;
-		this._isExecutingFn = false;
-		this._rerunDepth = 0;
-		this._dirtyDepCount = 0;
-		// C0: clear pause state so a new subscriber after terminal-reset
-		// starts from a clean pause lockset — otherwise a lockId from
-		// the previous lifecycle would leave the node stuck paused and
-		// swallow every emit.
-		this._pauseLocks = null;
-		this._pauseBuffer = null;
-		this._prePauseSnapshot = null; // Lock 2.C
-		// D282 /qa F1: clear batch-rollback bookkeeping for the same reason
-		// as in `_deactivate` — a lifecycle reset mid-batch would otherwise
-		// leave a stale `_preBatchSnapshot` pointing at the pre-reset state
-		// of a now-fresh-lifecycle node, partially resurrecting it on outer
-		// throw.
-		this._batchPendingMessages = null;
-		this._preBatchSnapshot = null;
-		this._pendingDeactivateAfterBatch = false;
-		// Lock 6.A: clear pause-cycle bookkeeping so a resubscribable node
-		// coming back from terminal-overflow doesn't carry stale
-		// `_pauseOverflowed = true` (which would swallow the next cycle's
-		// overflow ERROR) or stale `_pauseStartNs` (which would yield a
-		// nonsense `lockHeldDurationMs`).
-		this._pauseStartNs = undefined;
-		this._pauseDroppedCount = 0;
-		this._pauseOverflowed = false;
-		// Lock 6.G (spec §2.5): terminal-resubscribable lifecycle reset
-		// drops replay history. The next subscription cycle starts fresh —
-		// matches the TLA+ model's `replaySnapshot' = <<>>` clear in
-		// `Resubscribe` (formal model batch 6 G).
-		this._replayBuffer = null;
-		for (const d of this._deps) resetDepRecord(d);
-		// Defensive invariant: the first-run gate (§2.7) assumes
-		// `_hasCalledFnOnce === false` above AND every DepRecord in
-		// sentinel shape below were reset together. A future refactor
-		// that reorders these two resets (or skips `resetDepRecord` for
-		// any dep) would let the gate see a dep as "settled" from the
-		// prior lifecycle and release on first partial settlement with
-		// stale data. This assert catches the coupling in tests before
-		// users hit it in production.
-		if (this._partial === false) {
-			for (const d of this._deps) {
-				if (
-					d.prevData !== undefined ||
-					d.dataBatch.length !== 0 ||
-					d.terminal !== undefined ||
-					d.dirty
-				) {
-					throw new Error(
-						`resubscribable-reset invariant: DepRecord not fully reset for node ${
-							this._optsName ?? "(anonymous)"
-						}`,
-					);
-				}
-			}
-		}
-	}
-
-	// --- Lifecycle ---
-
-	/**
-	 * @internal First-sink activation. For a producer (no deps + fn),
-	 * invokes fn once. For a compute node (has deps), subscribes to every
-	 * dep with the pre-set-dirty trick so the first-run gate waits for
-	 * every dep to settle at least once.
-	 */
-	_activate(): void {
-		if (this._deps.length === 0) {
-			if (this._fn) this._execFn();
-			return;
-		}
-		// Pre-set every dep as sentinel BEFORE subscribing. If the first dep
-		// delivers DATA synchronously during its subscribe callback, the
-		// sentinel gate holds fn until all deps have contributed at least one
-		// value. _dirtyDepCount starts at 0 — actual DIRTY messages from deps
-		// drive it; pre-dirtying all deps would cause any dep that only delivers
-		// [[START]] (no DATA) to appear permanently "mid-wave", which blocks
-		// terminal propagation from other deps incorrectly.
-		this._dirtyDepCount = 0;
-		// Capture the initial length BEFORE subscribing. `_addDep` can fire
-		// synchronously during a dep's subscribe callback (e.g., via
-		// `autoTrackNode` discovery in `_execFn`) and push new DepRecords.
-		// Iterating `this._deps.length` live would mean this loop also
-		// subscribes the new dep that `_addDep` already subscribed — a
-		// double-subscribe bug. Snapshot the length instead; `_addDep`
-		// owns the subscribe + counter bump for any dep it adds.
-		const initialLen = this._deps.length;
-		// subscribedCount tracks how many deps were successfully subscribed.
-		// On failure, only those deps need to be rolled back.
-		let subscribedCount = 0;
-		try {
-			for (let i = 0; i < initialLen; i++) {
-				const dep = this._deps[i];
-				// Phase 13.8 QA G2-H: re-check Q1 terminal-non-resubscribable
-				// at activation time. `_setDeps` and `_addDepInternal` validate
-				// upfront, but on an inactive node the actual `subscribe()` is
-				// deferred to here — the dep may have transitioned to non-
-				// resubscribable terminal in the interim. `defaultOnSubscribe`
-				// would silently no-op, leaving the edge wedged. Re-check now.
-				const depImpl = dep.node as NodeImpl;
-				if (
-					(depImpl._status === "completed" || depImpl._status === "errored") &&
-					!depImpl._resubscribable
-				) {
-					throw new Error(
-						`_activate: dep "${depImpl.name}" entered non-resubscribable terminal state (${depImpl._status}) between dep declaration and first activation; the subscribe handshake would silently no-op and wedge node "${this.name}". Use a resubscribable dep, a fresh node, or remove the edge before activation.`,
-					);
-				}
-				// Pre-set to noopUnsub so the liveness check inside the callback
-				// passes during synchronous push-on-subscribe (dep.unsub is non-null),
-				// while still blocking stale drainPhase2 closures that fire after
-				// _deactivate sets dep.unsub = null.
-				dep.unsub = noopUnsub;
-				dep.unsub = dep.node.subscribe((msgs) => {
-					// Liveness check: dep.unsub === null means this subscription was
-					// cancelled by _deactivate. Drop deliveries from stale drainPhase2
-					// closures that outlived the subscription.
-					if (dep.unsub === null) return;
-					// Phase 13.8: dispatch via current index of this DepRecord in
-					// `_deps`, not a closure-captured index. Surgical `_setDeps`
-					// may shift kept deps' positions; binding via record reference
-					// keeps stale closures impossible. `indexOf` is O(N) but N is
-					// typically small; promote to a Map cache if profiling demands.
-					const depIdx = this._deps.indexOf(dep);
-					if (depIdx === -1) return; // record evicted by `_setDeps`
-					// Track whether any tier-3+ settlement-class message arrived
-					// (DATA/RESOLVED at tier 3, INVALIDATE at tier 4,
-					// COMPLETE/ERROR at tier 5). Fire
-					// `_maybeRunFnOnSettlement` once at the end of the iteration
-					// loop when at least one settlement was seen — one invocation
-					// per dep batch, not per message, so `fn` sees the full wave
-					// (Bug 1 fix, 2026-04-17). Guarded by `config.tierOf(m[0])
-					// >= 3` per spec §5.11 — never hardcode message-type checks.
-					const tierOf = this._config.tierOf;
-					let sawSettlement = false;
-					for (const m of msgs) {
-						if (tierOf(m[0]) >= 3) sawSettlement = true;
-						this._config.onMessage(
-							this as unknown as NodeCtx,
-							m,
-							{ direction: "down-in", depIndex: depIdx },
-							this._actions,
-						);
-					}
-					if (sawSettlement) this._maybeRunFnOnSettlement();
-				});
-				subscribedCount++;
-			}
-		} catch (err) {
-			// Dep at index `subscribedCount` failed — its dep.unsub is still noopUnsub.
-			// Mark it null so the liveness check treats any queued closures as stale.
-			this._deps[subscribedCount].unsub = null;
-			// Unsubscribe all deps that DID subscribe successfully (0..subscribedCount-1).
-			for (let j = 0; j < subscribedCount; j++) {
-				const d = this._deps[j];
-				if (d.unsub != null) {
-					const u = d.unsub;
-					d.unsub = null;
-					try {
-						u();
-					} catch {
-						/* best-effort: dep unsub errors are secondary */
-					}
-					resetDepRecord(d);
-				}
-			}
-			this._dirtyDepCount = 0;
-			throw err;
-		}
-	}
-
-	/**
-	 * @internal **Substrate-level dep append** (no validation guards).
-	 * Used by `autoTrackNode` (runtime dep discovery) and `Graph.connect()`
-	 * (post-construction wiring) — both of which need cycle/self-dep/mid-fn
-	 * checks intentionally bypassed (autoTrackNode runs from inside
-	 * `_execFn`, where the public `addDep` would reject).
-	 *
-	 * **External callers** (Phase 13.8 `Graph._addDep`, harness/AI rewrite
-	 * code) should use {@link addDep} which layers validation on top of
-	 * this primitive.
-	 *
-	 * **Dedup:** idempotent on duplicate `depNode`.
-	 *
-	 * **Q1 terminal-non-resubscribable rejection** stays here (correctness
-	 * fix for a pre-existing wedge bug, applies regardless of caller).
-	 *
-	 * **Subscribe ordering (Phase 13.8 QA D):** the synthetic `[DIRTY]`
-	 * downstream emit happens AFTER the dep subscribe succeeds, so a
-	 * subscribe-throw never leaves an orphan DIRTY downstream (spec
-	 * §5.11 R1.3.1.a — DIRTY without a follow-up DATA/RESOLVED is invalid).
-	 */
-	_addDepInternal(depNode: Node, opts?: { fn?: NodeFn }): number {
-		// Dedup: idempotent on repeated adds of the same dep. Matches
-		// reference equality — the DepRecord is keyed by `node` identity,
-		// so a caller with a fresh `depNode` that observes as equal but
-		// is a distinct object is treated as a new dep.
-		for (let i = 0; i < this._deps.length; i++) {
-			if (this._deps[i].node === depNode) {
-				// Idempotent on dep, but still apply fn swap if requested.
-				if (opts?.fn !== undefined) this._fn = opts.fn;
-				return i;
-			}
-		}
-		// Phase 13.8 Q1: reject non-resubscribable terminal deps.
-		// `defaultOnSubscribe` silently no-ops on terminal non-resubscribable
-		// nodes — adding one would wedge N (no DATA, no terminal, no
-		// auto-cascade). Resubscribable terminals are accepted because
-		// `subscribe()` triggers `_resetForFreshLifecycle` on them.
-		const depImpl = depNode as NodeImpl;
-		if (
-			(depImpl._status === "completed" || depImpl._status === "errored") &&
-			!depImpl._resubscribable
-		) {
-			throw new Error(
-				`_addDep: cannot add non-resubscribable terminal dep "${depImpl.name}" (status=${depImpl._status}). The subscribe handshake is silent for terminal non-resubscribable nodes, which would leave the new edge wedged.`,
-			);
-		}
-		const depIdx = this._deps.length;
-		const record = createDepRecord(depNode);
-		this._deps.push(record);
-
-		// Phase 13.8: optional fn replacement. Land before any subscribe so
-		// the next `_execFn` (possibly triggered by push-on-subscribe below)
-		// uses the new fn.
-		if (opts?.fn !== undefined) this._fn = opts.fn;
-
-		// If the node is inactive (no subscribers yet), defer subscribe to
-		// _activate(). Subscribing here would create a duplicate subscription
-		// because _activate() unconditionally subscribes to all _deps entries.
-		// _activate() resets _dirtyDepCount to 0 before subscribing, so pre-
-		// dirtying is wasted work and causes counter underflow on the first DATA.
-		if (this._sinks == null) return depIdx;
-
-		record.dirty = true;
-		// New dep starts dirty — bump the A3 counter to match the pre-set flag.
-		// Skipping the helper here because the record isn't in the array yet when
-		// the helper would early-return on `dep.dirty === true`.
-		this._dirtyDepCount++;
-		// Topology change → downstream sees a new wave. Skip when already
-		// dirty (we're inside an in-flight wave and have already emitted).
-		// `_depDirtied` can't do this for us because `record.dirty` was
-		// pre-set above, which short-circuits its DIRTY-emit path.
-		const dirtyEmitted = this._status !== "dirty";
-		if (dirtyEmitted) this._emit(DIRTY_ONLY_BATCH);
-		record.unsub = noopUnsub;
-		try {
-			record.unsub = depNode.subscribe((msgs) => {
-				if (record.unsub === null) return;
-				// Phase 13.8: dispatch via current index of this DepRecord
-				// (see `_activate` callback for full rationale).
-				const idx = this._deps.indexOf(record);
-				if (idx === -1) return;
-				// Tier-3+ classification via central `tierOf` per spec §5.11
-				// (Bug 1 fix — see _activate for details).
-				const tierOf = this._config.tierOf;
-				let sawSettlement = false;
-				for (const m of msgs) {
-					if (tierOf(m[0]) >= 3) sawSettlement = true;
-					this._config.onMessage(
-						this as unknown as NodeCtx,
-						m,
-						{ direction: "down-in", depIndex: idx },
-						this._actions,
-					);
-				}
-				if (sawSettlement) this._maybeRunFnOnSettlement();
-			});
-		} catch (err) {
-			// Phase 13.8 QA D: rollback AND close the orphan DIRTY downstream.
-			// Previously the comment claimed `_execFn`'s catch would emit
-			// ERROR — but that only holds when called from autoTrackNode
-			// inside `_execFn`. For external callers (`Graph._addDep`), the
-			// DIRTY would orphan downstream. Emit ERROR explicitly so the
-			// wave closes deterministically.
-			record.unsub = null;
-			this._deps.pop();
-			this._dirtyDepCount--;
-			if (dirtyEmitted) {
-				this._emit([[ERROR, err]]);
-			}
-			throw err;
-		}
-		return depIdx;
-	}
-
-	/**
-	 * Append a dep post-construction with full validation guards. Public
-	 * dynamic-topology primitive (see {@link Node.addDep}); wraps
-	 * {@link _addDepInternal}.
-	 *
-	 * **Rejects** (symmetric with `setDeps`/`removeDep`):
-	 * - Self-dep (`depNode === this`).
-	 * - Cycle introduction (`depNode` already transitively depends on `this`).
-	 * - Mid-fn (`_isExecutingFn === true`).
-	 * - Terminal `this` (`_status` ∈ `{completed, errored}`).
-	 * - Reentrant call (another `_setDeps`/`_addDep`/`_removeDep` is in
-	 *   flight on `this`).
-	 *
-	 * `autoTrackNode` and other internal autoTrack/connect-time callers must
-	 * use {@link _addDepInternal} directly — they intentionally run from
-	 * inside `_execFn` and rely on the substrate-level discovery semantics.
-	 *
-	 * **Required `fn` parameter (Phase 13.8 lock).** Appending a dep grows
-	 * `data.length` by 1; the caller must declare the fn that consumes
-	 * the new shape — even if it's the same as the prior fn. Old cleanup's
-	 * `onRerun` fires on the next `_execFn` invocation, NOT at swap time.
-	 * If no further `_execFn` runs (e.g., immediate deactivation),
-	 * `onRerun` is silently dropped — `onDeactivation` still fires.
-	 *
-	 * @returns The index of the new dep in `_deps`, or the existing index
-	 *   if the dep was already present.
-	 */
-	addDep(depNode: Node, fn: NodeFn, _opts?: Record<string, never>): number {
-		if (this._status === "completed" || this._status === "errored") {
-			throw new Error(
-				`addDep: cannot add dep on node "${this.name}" in terminal state "${this._status}"`,
-			);
-		}
-		if (this._isExecutingFn) {
-			throw new Error(
-				`addDep: cannot add dep on node "${this.name}" while its fn is executing (mid-fn topology mutation). Use _addDepInternal for autoTrackNode-style discovery from inside fn.`,
-			);
-		}
-		if (this._inDepMutation) {
-			throw new Error(
-				`addDep: reentrant dep mutation rejected on node "${this.name}". Another setDeps/addDep/removeDep is in flight (likely a synchronous re-entry from a subscribe handshake or topology subscriber).`,
-			);
-		}
-		if (depNode === (this as unknown as Node)) {
-			throw new Error(
-				`addDep: self-dependency rejected for node "${this.name}" — passing this node as its own dep is not supported`,
-			);
-		}
-		// Cycle reject — DFS through transitive `_deps[*].node` looking for
-		// `this`. If reachable, adding the edge `depNode → this` would close
-		// a cycle. Skip when dep is already present (dedup will catch it
-		// inside `_addDepInternal` anyway, and the existing edge can't
-		// introduce a new cycle).
-		if (
-			!this._deps.some((r) => r.node === depNode) &&
-			_reachableUpstream(depNode, this as unknown as Node)
-		) {
-			throw new Error(
-				`addDep: would create cycle — dep "${(depNode as NodeImpl).name}" already transitively depends on "${this.name}"`,
-			);
-		}
-		this._inDepMutation = true;
-		try {
-			return this._addDepInternal(depNode, { fn });
-		} finally {
-			this._inDepMutation = false;
-		}
-	}
-
-	/**
-	 * Remove a dep. Public dynamic-topology primitive (see
-	 * {@link Node.removeDep}); symmetric counterpart to `addDep`.
-	 *
-	 * Idempotent — if
-	 * `depNode` is not currently in `_deps`, this is a no-op (still
-	 * applies the fn swap). Removing the last dep is allowed; N becomes
-	 * a degenerate fn-with-no-deps shape (cache preserved per Q7; no
-	 * further fires until a fresh wave arrives).
-	 *
-	 * **Required `fn` parameter (Phase 13.8 lock).** Removing a dep
-	 * shrinks `data.length`; the caller must declare the fn that consumes
-	 * the new shape. Even when the dep is absent (idempotent path), the
-	 * fn swap still applies — the API enforces fn-deps pairing at every
-	 * call site.
-	 *
-	 * **Auto-settle.** If the removed dep was the sole DIRTY contributor
-	 * and the node was waiting on it, the wave settles via the standard
-	 * settlement path (Q6). DepRecord state for surviving deps is
-	 * preserved (DepRecord-ref dispatch handles position shifts).
-	 *
-	 * **Rejects:**
-	 * - Mid-fn (`_isExecutingFn === true`).
-	 * - Terminal `this` (`_status` ∈ `{completed, errored}`).
-	 *
-	 * @param depNode — the dep Node to remove.
-	 * @param fn — transform fn for the post-remove shape; replaces `this._fn`.
-	 * @param _opts — reserved for future expansion.
-	 */
-	removeDep(depNode: Node, fn: NodeFn, _opts?: Record<string, never>): void {
-		if (this._status === "completed" || this._status === "errored") {
-			throw new Error(
-				`removeDep: cannot remove dep on node "${this.name}" in terminal state "${this._status}"`,
-			);
-		}
-		if (this._isExecutingFn) {
-			throw new Error(
-				`removeDep: cannot remove dep on node "${this.name}" while its fn is executing (mid-fn topology mutation)`,
-			);
-		}
-		if (this._inDepMutation) {
-			throw new Error(
-				`removeDep: reentrant dep mutation rejected on node "${this.name}". Another setDeps/addDep/removeDep is in flight.`,
-			);
-		}
-		this._inDepMutation = true;
-		try {
-			const idx = this._deps.findIndex((r) => r.node === depNode);
-			if (idx === -1) {
-				// Not present — idempotent on the dep, but fn swap still lands
-				// (Phase 13.8 lock: fn-deps pairing is required at every call).
-				this._fn = fn;
-				return;
-			}
-			const rec = this._deps[idx];
-			if (rec.unsub != null) {
-				const u = rec.unsub;
-				rec.unsub = null;
-				try {
-					u();
-				} catch {
-					/* best-effort: dep unsub errors are secondary */
-				}
-			}
-			const removedDirtyContributor = rec.dirty;
-			if (rec.dirty) this._dirtyDepCount--;
-			this._deps.splice(idx, 1);
-			this._fn = fn;
-			// Q6 auto-settle: if the only dirty contributor was the removed
-			// dep and the wave is now empty, fire fn settlement so downstream
-			// sees a coherent close-of-wave.
-			if (
-				removedDirtyContributor &&
-				this._dirtyDepCount === 0 &&
-				this._status === "dirty" &&
-				this._sinks != null
-			) {
-				this._maybeRunFnOnSettlement();
-			}
-		} finally {
-			this._inDepMutation = false;
-		}
-	}
-
-	/**
-	 * Replace this node's upstream deps atomically. Public
-	 * dynamic-topology primitive (see {@link Node.setDeps}); also wrapped
-	 * by `Graph._rewire(name, newDeps)`. Supports AI self-pruning of
-	 * harness topology (per `project_rewire_gap` memory).
-	 *
-	 * **Variant: surgical (kept deps untouched).** A dep that appears in
-	 * BOTH the old and new dep sets is left completely alone — its
-	 * subscription stays attached, its DepRecord (`prevData`, `dirty`,
-	 * `dataBatch`, `terminal`) is unchanged, the dep does not see N
-	 * unsub-then-resub. Only **removed** deps are unsubscribed (and their
-	 * DepRecord discarded), and only **added** deps get a fresh DepRecord
-	 * + subscription.
-	 *
-	 * **Reorder + interior-remove are allowed.** Subscription callbacks
-	 * bind to the DepRecord reference (Phase 13.8 Option C); they look
-	 * up the current index dynamically via `_deps.indexOf(record)` at
-	 * dispatch time. So kept deps may shift position freely without
-	 * needing to re-subscribe. The user's `newDeps` order determines
-	 * `_deps` order verbatim.
-	 *
-	 * **Preserves** (per Q2/Q3/Q7 of rewire-design-notes.md + the surgical
-	 * lock):
-	 * - `_cached` (compute-node cache survives rewire — Q7)
-	 * - `_hasCalledFnOnce` (first-run gate not re-armed — Q2)
-	 * - `_pauseLocks` / `_pauseBuffer` (Q3 — N's outgoing pause state)
-	 * - `_replayBuffer` (N's outgoing replay history)
-	 * - `_store` / `_cleanup` (per-node scratch + cleanup hooks)
-	 * - **Kept deps' DepRecords** — `prevData`, `dirty`, `dataBatch`,
-	 *   `terminal` all carry through verbatim.
-	 *
-	 * **Discards** — only state owned by removed deps' DepRecords.
-	 *
-	 * **Rejects** (per `rewire-design-notes.md` post-design resolutions):
-	 * - Self-rewire (`this` ∈ `newDeps`).
-	 * - Cycle introduction (DFS through transitive `_deps`).
-	 * - Mid-fn rewire (`_isExecutingFn === true`).
-	 * - Terminal `this` (`_status` ∈ `{completed, errored}`).
-	 * - **Phase 13.8 design pass:** any `newDeps` entry that is currently
-	 *   in non-resubscribable terminal state. (`defaultOnSubscribe`
-	 *   silently no-ops on terminal non-resubscribable nodes — adding
-	 *   one would wedge N. Resubscribable terminals ARE allowed because
-	 *   `subscribe()` triggers `_resetForFreshLifecycle` on them.)
-	 *
-	 * **Required `fn` parameter (Phase 13.8 lock).** Every dep mutation
-	 * MUST pair with an explicit fn — even if it's the same as the old
-	 * one. Rationale: user fns read `data[i]` / `prevData[i]` positionally;
-	 * dep-shape changes (count or order) silently misroute reads unless
-	 * the caller acknowledges the fn-deps pairing at every call site.
-	 * Forcing fn at the API boundary makes the audit step mandatory.
-	 *
-	 * The next `_execFn` invocation fires the old cleanup's `onRerun` hook
-	 * (clean wrap-up) and runs the new fn. `_store`, `_hasCalledFnOnce`,
-	 * cache, replay buffer, and pause locks are all preserved.
-	 *
-	 * Callers that want to keep the prior fn must hold a reference to it
-	 * (define fns as named consts rather than inline lambdas, or read
-	 * `(node as NodeImpl)._fn` for ad-hoc retrieval).
-	 *
-	 * @param newDeps — full new dep set (deduplicated by reference identity).
-	 * @param fn — transform fn for the rewired node; replaces `this._fn`
-	 *   atomically with the dep mutation. Pass the existing fn ref to
-	 *   preserve behavior when only the dep set changes.
-	 * @param _opts — reserved for future expansion.
-	 */
-	setDeps(newDeps: readonly Node[], fn: NodeFn, _opts?: Record<string, never>): void {
-		// --- Validation: this-side ---
-		if (this._status === "completed" || this._status === "errored") {
-			throw new Error(
-				`setDeps: cannot rewire node "${this.name}" in terminal state "${this._status}"`,
-			);
-		}
-		if (this._isExecutingFn) {
-			throw new Error(
-				`setDeps: cannot rewire node "${this.name}" while its fn is executing (mid-fn topology mutation)`,
-			);
-		}
-		if (this._inDepMutation) {
-			throw new Error(
-				`setDeps: reentrant dep mutation rejected on node "${this.name}". Another setDeps/addDep/removeDep is in flight (likely a synchronous re-entry from a subscribe handshake or topology subscriber).`,
-			);
-		}
-
-		// Dedupe by reference identity (mirrors `addDep`).
-		const seen = new Set<Node>();
-		const dedupedNewDeps: Node[] = [];
-		for (const d of newDeps) {
-			if (seen.has(d)) continue;
-			seen.add(d);
-			dedupedNewDeps.push(d);
-		}
-		if (seen.has(this as unknown as Node)) {
-			throw new Error(
-				`setDeps: self-dependency rejected for node "${this.name}" — pass a deps array that does not include this node`,
-			);
-		}
-
-		// --- Cycle reject ---
-		for (const d of dedupedNewDeps) {
-			if (_reachableUpstream(d, this as unknown as Node)) {
-				throw new Error(
-					`setDeps: would create cycle — dep "${(d as NodeImpl).name}" already transitively depends on "${this.name}"`,
-				);
-			}
-		}
-
-		// --- Diff: compute removed, added, kept ---
-		// Map each old dep node to its DepRecord for O(1) lookup. Kept deps
-		// can shift position freely because subscription callbacks bind to
-		// the DepRecord reference, not the index (Phase 13.8 Option C).
-		const oldRecordByNode = new Map<Node, DepRecord>();
-		for (const rec of this._deps) {
-			oldRecordByNode.set(rec.node, rec);
-		}
-
-		// --- Validation: terminal-non-resubscribable on added deps ---
-		// Resubscribable terminals are accepted: subscribe() triggers
-		// `_resetForFreshLifecycle` on them, putting them in a clean
-		// sentinel state for the new edge.
-		for (const d of dedupedNewDeps) {
-			if (oldRecordByNode.has(d)) continue; // kept, no new subscription
-			const impl = d as NodeImpl;
-			if ((impl._status === "completed" || impl._status === "errored") && !impl._resubscribable) {
-				throw new Error(
-					`setDeps: cannot add non-resubscribable terminal dep "${impl.name}" (status=${impl._status}). The subscribe handshake is silent for terminal non-resubscribable nodes, which would leave the new edge wedged. Either remove the dep from the rewire, mark the dep as resubscribable, or add a fresh node.`,
-				);
-			}
-		}
-
-		this._inDepMutation = true;
-		try {
-			// --- Phase 1: disconnect removed deps ---
-			// Walk old `_deps`; whatever is no longer present in newDeps gets
-			// unsubscribed and its DepRecord state cleaned up. Track whether
-			// we removed a dirty contributor — if so we may need to settle.
-			const newDepsSet = seen; // already populated above
-			let removedDirtyContributor = false;
-			for (const oldRec of this._deps) {
-				if (newDepsSet.has(oldRec.node)) continue; // kept
-				// removed
-				if (oldRec.unsub != null) {
-					const u = oldRec.unsub;
-					oldRec.unsub = null;
-					try {
-						u();
-					} catch {
-						/* best-effort: dep unsub errors are secondary on rewire */
-					}
-				}
-				if (oldRec.dirty) {
-					removedDirtyContributor = true;
-					this._dirtyDepCount--;
-				}
-				// DepRecord garbage-collected when we replace `_deps` below.
-			}
-
-			// --- Phase 2: build new _deps array ---
-			// Reuse existing DepRecords for kept deps (preserving prevData,
-			// dirty, dataBatch, terminal). Create fresh DepRecords for added.
-			// Kept deps may end up at a different index than before — that's
-			// fine because subscription callbacks bind to record references.
-			const newRecords: DepRecord[] = new Array(dedupedNewDeps.length);
-			const addedIndices: number[] = [];
-			for (let i = 0; i < dedupedNewDeps.length; i++) {
-				const d = dedupedNewDeps[i];
-				const existing = oldRecordByNode.get(d);
-				if (existing !== undefined) {
-					newRecords[i] = existing;
-				} else {
-					newRecords[i] = createDepRecord(d);
-					addedIndices.push(i);
-				}
-			}
-			this._deps = newRecords;
-
-			// --- Phase 2.5: required fn replacement (Phase 13.8 lock) ---
-			// Land the new fn BEFORE any auto-settle / re-fire path so the next
-			// `_execFn` call uses it. Old cleanup stays attached; the existing
-			// rerun-cleanup path in `_execFn` will fire its `onRerun` hook
-			// before invoking the new fn (clean wrap-up of old fn's last run).
-			// `fn` is required at the API boundary — same fn is fine, but the
-			// caller must always declare what fn the new dep set pairs with.
-			this._fn = fn;
-
-			// --- Phase 3: subscribe added deps ---
-			// Inactive node (`_sinks == null`): defer. `_activate()` will
-			// subscribe every `_deps` entry from scratch on first sink.
-			if (this._sinks == null) {
-				// Honor the auto-settle Q6 case here too, even though we
-				// haven't subscribed: if the only dirty contributors got
-				// removed and the node was waiting for them, the wave is
-				// already settled in spirit.
-				if (
-					removedDirtyContributor &&
-					addedIndices.length === 0 &&
-					this._dirtyDepCount === 0 &&
-					this._status === "dirty"
-				) {
-					this._maybeRunFnOnSettlement();
-				}
-				return;
-			}
-
-			// Pre-dirty added deps so the wave gate accounts for them. Mirror
-			// `_addDepInternal`'s pre-dirty + counter bump.
-			const hadAdded = addedIndices.length > 0;
-			let dirtyEmitted = false;
-			if (hadAdded) {
-				for (const i of addedIndices) {
-					const rec = this._deps[i];
-					rec.dirty = true;
-					this._dirtyDepCount++;
-				}
-				// Topology change introducing new in-flight deps → emit DIRTY
-				// downstream once if not already in a wave. Mirrors `_addDepInternal`.
-				if (this._status !== "dirty") {
-					this._emit(DIRTY_ONLY_BATCH);
-					dirtyEmitted = true;
-				}
-			}
-
-			// Subscribe each added dep. Closure binds to the DepRecord; index
-			// looked up dynamically via `_deps.indexOf(record)` so future
-			// `_setDeps` calls that shift this dep's position remain correct.
-			// Kept deps' subscriptions remain in place untouched.
-			let subscribedCount = 0;
-			try {
-				for (const i of addedIndices) {
-					const rec = this._deps[i];
-					rec.unsub = noopUnsub;
-					rec.unsub = rec.node.subscribe((msgs) => {
-						if (rec.unsub === null) return;
-						const idx = this._deps.indexOf(rec);
-						if (idx === -1) return;
-						const tierOf = this._config.tierOf;
-						let sawSettlement = false;
-						for (const m of msgs) {
-							if (tierOf(m[0]) >= 3) sawSettlement = true;
-							this._config.onMessage(
-								this as unknown as NodeCtx,
-								m,
-								{ direction: "down-in", depIndex: idx },
-								this._actions,
-							);
-						}
-						if (sawSettlement) this._maybeRunFnOnSettlement();
-					});
-					subscribedCount++;
-				}
-			} catch (err) {
-				// Phase 13.8 QA D: rollback the partially-subscribed state
-				// AND emit a settlement downstream to close the orphan DIRTY
-				// (R1.3.1.a — DIRTY without follow-up DATA/RESOLVED is a spec
-				// violation). Strategy:
-				//   1. Null `unsub` on every not-yet-successfully-subscribed
-				//      record so any drainPhase2 closures dropped.
-				//   2. Splice failed records out of `_deps` so `indexOf`
-				//      returns -1 in any in-flight callback AND so the next
-				//      `_setDeps` call doesn't see them as "kept-and-live".
-				//   3. Decrement `_dirtyDepCount` for the dropped records.
-				//   4. If we already emitted DIRTY downstream, emit ERROR
-				//      downstream so the wave closes deterministically.
-				const failedIndices: number[] = [];
-				for (let k = subscribedCount; k < addedIndices.length; k++) {
-					failedIndices.push(addedIndices[k]);
-				}
-				for (const idx of failedIndices) {
-					const failedRec = this._deps[idx];
-					if (failedRec == null) continue;
-					failedRec.unsub = null;
-					if (failedRec.dirty) {
-						failedRec.dirty = false;
-						this._dirtyDepCount--;
-					}
-				}
-				if (failedIndices.length > 0) {
-					const failedSet = new Set(failedIndices);
-					this._deps = this._deps.filter((_, idx) => !failedSet.has(idx));
-				}
-				if (dirtyEmitted) {
-					// Close the orphan DIRTY downstream with an ERROR carrying
-					// the cause. Emit BEFORE rethrow so subscribers see a
-					// well-formed wave: DIRTY → ERROR.
-					this._emit([[ERROR, err]]);
-				}
-				throw err;
-			}
-
-			// Q6 auto-settle: if the only dirty contributors were removed
-			// and no added deps replaced them, and the wave is empty but
-			// the node is still marked dirty — let the settlement path
-			// decide whether to fire fn (e.g. with stale prevData).
-			if (
-				removedDirtyContributor &&
-				!hadAdded &&
-				this._dirtyDepCount === 0 &&
-				this._status === "dirty"
-			) {
-				this._maybeRunFnOnSettlement();
-			}
-		} finally {
-			this._inDepMutation = false;
-		}
-	}
-
-	/**
-	 * @internal Unsubscribes from deps, fires fn cleanup (both shapes),
-	 * clears wave/store state, and (for compute nodes) drops `_cached` per
-	 * the ROM/RAM rule. Idempotent: second call is a no-op.
-	 *
-	 * @param skipStatusUpdate — When `true`, the caller takes responsibility
-	 *   for setting `_status` after deactivation (e.g. TEARDOWN always sets
-	 *   `"sentinel"` unconditionally). When `false` (default), deactivation
-	 *   applies the ROM rule: compute nodes → `"sentinel"`, state nodes
-	 *   preserve their current status.
-	 */
-	_deactivate(skipStatusUpdate = false): void {
-		// Fn cleanup — fires the `onDeactivation` hook (Lock 4.A; named-hook
-		// object form only — the legacy function-form leg was removed).
-		// Note on cleanup-throw ERRORs: when deactivation runs as part of
-		// last-sink-unsubscribe, `_sinks` is already `null` by the time this
-		// method is reached, so any ERROR emitted here lands on
-		// `_deliverToSinks`'s null-guard and is dropped by design. Cleanup
-		// errors during teardown are best-effort — callers that need to
-		// observe them should install a host-level error channel via
-		// `configure()`.
-		const cleanup = this._cleanup;
-		this._cleanup = undefined;
-		if (cleanup != null) {
-			const hook = cleanup.onDeactivation;
-			if (typeof hook === "function") {
-				try {
-					hook();
-				} catch (err) {
-					this._emit([[ERROR, this._wrapFnError("cleanup.onDeactivation threw", err)]]);
-				}
-			}
-		}
-
-		// Disconnect from deps.
-		for (const d of this._deps) {
-			if (d.unsub != null) {
-				const u = d.unsub;
-				d.unsub = null;
-				try {
-					u();
-				} catch {
-					/* best-effort teardown of upstream subscription */
-				}
-			}
-			resetDepRecord(d);
-		}
-
-		// Clear wave state.
-		this._waveHasNewData = false;
-		this._hasNewTerminal = false;
-		this._waveHasInvalidate = false;
-		this._hasCalledFnOnce = false;
-		this._paused = false;
-		this._pendingWave = false;
-		this._pendingRerun = false;
-		this._rerunDepth = 0;
-		// D282 /qa F1: clear batch-rollback bookkeeping. If `_deactivate`
-		// fires from outside the emit pipeline (last-subscriber-detach at
-		// line ~1540) mid-batch, the stale `_preBatchSnapshot` would
-		// otherwise partially resurrect a deactivated node when the outer
-		// batch throws. Mirrors the `_prePauseSnapshot = null` pattern in
-		// `_resetForFreshLifecycle`. The `_pendingDeactivateAfterBatch`
-		// flag is also cleared since this method IS the deactivation that
-		// the flag would have triggered.
-		this._batchPendingMessages = null;
-		this._preBatchSnapshot = null;
-		this._pendingDeactivateAfterBatch = false;
-		// Lock 6.D (Phase 13.6.B): `ctx.store` is NO LONGER wiped on
-		// deactivation. Preserve-across-deactivation is the new default
-		// (G.20 flip). Operators requiring auto-wipe (`take(n)`, `scan`,
-		// `pairwise`, parser-state operators, etc.) must explicitly clear
-		// in `onDeactivation`. The cleanup-hook firing path above (in
-		// `_deactivate`) gives them the hook; the store is left
-		// untouched here so user-installed `onDeactivation` runs first
-		// and decides what (if anything) to wipe.
-		// A3 counter reset with DepRecord bulk-reset.
-		this._dirtyDepCount = 0;
-		// DS-13.5.A Q16 idempotency: clear `_teardownDone` so a resubscribable
-		// node that received TEARDOWN can re-arm Q16 on the next lifecycle.
-		// Without this, the `_maybeRunFnOnSettlement` early-return at the
-		// `_teardownDone` guard would permanently wedge fn after the first
-		// TEARDOWN — breaking compat layers (`compat/jotai`, `compat/nanostores`,
-		// `compat/signals`) that rely on `resubscribable: true`.
-		this._teardownDone = false;
-		// C0 pause state: TEARDOWN is a hard reset. Buffered tier-3/4
-		// messages from a paused `resumeAll` node are DISCARDED rather than
-		// drained, matching "teardown wipes in-flight state" semantics.
-		// Clearing both structures also prevents a memory leak on
-		// non-resubscribable teardown, and guarantees a resubscribable
-		// re-activation starts from `_paused === false` with no stale
-		// lockset carried over from the previous lifecycle.
-		this._pauseLocks = null;
-		this._pauseBuffer = null;
-		this._prePauseSnapshot = null; // Lock 2.C
-		// Lock 6.A: clear pause-cycle bookkeeping symmetric with the
-		// resubscribable-reset path so a resubscribable node coming back
-		// from terminal-overflow starts its next pause cycle clean.
-		this._pauseStartNs = undefined;
-		this._pauseDroppedCount = 0;
-		this._pauseOverflowed = false;
-		// Lock 6.G (spec §2.5): TEARDOWN / last-sink-detach is a hard
-		// reset — drop the replay history so a resubscribable node
-		// coming back into a fresh lifecycle doesn't ship pre-teardown
-		// values to its new subscribers. Mirrors `_pauseBuffer` clear
-		// above and the formal-model `replaySnapshot' = <<>>` clear in
-		// `Resubscribe` (TLA+ batch 6 G).
-		this._replayBuffer = null;
-
-		// ROM/RAM: compute nodes clear cache; pure state nodes preserve it.
-		if (this._fn != null) {
-			this._cached = undefined;
-		}
-
-		if (!skipStatusUpdate) {
-			// Compute nodes → "sentinel" (cache cleared, no value).
-			// - Non-terminal: always reset.
-			// - Terminal + resubscribable: reset (resubscribable means
-			//   "can be re-activated after terminal" — the terminal state
-			//   doesn't persist across subscription cycles).
-			// - Terminal + non-resubscribable: preserve (stream is over).
-			// State nodes preserve status (ROM rule, value is intrinsic).
-			if (this._fn != null || this._deps.length > 0) {
-				if (!this._isTerminal || this._resubscribable) {
-					this._status = "sentinel";
-				}
-			}
-		}
-	}
-
-	// --- Dep message dispatch (§3.5 singleton default) ---
-
-	/**
-	 * @internal Default per-tier dispatch for incoming dep messages. Called
-	 * by `defaultOnMessage`. Updates the DepRecord, triggers wave
-	 * completion, and forwards passthrough traffic.
-	 */
-	_onDepMessage(depIndex: number, msg: Message): void {
-		const dep = this._deps[depIndex];
-		const t = msg[0];
-
-		// Fire inspector hooks before default dispatch. Common case: no hooks
-		// (undefined slot). Multiple observers can attach simultaneously.
-		if (this._inspectorHooks != null) {
-			const ev: NodeInspectorHookEvent = { kind: "dep_message", depIndex, message: msg };
-			for (const hook of this._inspectorHooks) hook(ev);
-		}
-
-		// Tier 0 (START) — informational, no state change.
-		if (t === START) return;
-
-		// Tier 1
-		if (t === DIRTY) {
-			this._depDirtied(dep);
-			return;
-		}
-		if (t === INVALIDATE) {
-			this._depInvalidated(dep);
-			// **INVARIANT (DS-13.5.A diamond fan-in):** `_depInvalidated`
-			// runs UNCONDITIONALLY before this `_cached === undefined`
-			// idempotency guard. Second-arrival counter-correctness depends
-			// on `_depInvalidated`'s own `if (dep.dirty)` pre-check
-			// (line ~1670) — first arrival flips dep.dirty to false so the
-			// second arrival's decrement is gated out. Any future refactor
-			// that relaxes that pre-check (e.g. unconditional dirty toggle)
-			// will silently underflow `_dirtyDepCount` on diamond second
-			// arrivals. Keep the dep.dirty pre-check load-bearing.
-			//
-			// Diamond fan-in guard (TLA+ batch 5 B parity, 2026-04-23): when a
-			// second INVALIDATE arrives at a node whose cache was already reset
-			// by an earlier arrival this wave (e.g. topology `A → {B, C} → D`
-			// where D receives INVALIDATE from both parents), skip the self
-			// self-processing — there's no cached value to clean up and
-			// downstream children were already notified by the first arrival.
-			// Without this guard, an object-form cleanup with an `invalidate`
-			// hook (e.g. `src/utils/ai/prompts/frozen-context.ts`) would fire
-			// twice, and the redundant re-broadcast would cascade through the
-			// subgraph. Matches the TLA+ `CleanupWitnessNotSentinel` invariant's
-			// guard in `DeliverInvalidate`.
-			//
-			// Caveat (batch 7 QA, Option B for BH-2/ECH-2): `_cached === undefined`
-			// overloads TWO semantics — "cache was reset this wave" (the diamond
-			// case above) AND "cache was never populated" (mid-chain derived
-			// that received DIRTY but not DATA yet, or a node with no `initial`).
-			// In the second case, a FIRST-time INVALIDATE arrival is also
-			// skipped: no cleanup hook fires (correct — nothing to clean up)
-			// and no downstream forward happens. This means an observer via
-			// `graph.observe()` on a never-populated mid-chain derived will
-			// NOT see INVALIDATE propagate through that node. Semantically
-			// this is "INVALIDATE at undefined ≈ no-op" — the observable
-			// state at downstream is unchanged regardless. Accepted as a
-			// design simplification rather than introducing a per-wave
-			// `_invalidatedThisWave` flag whose clear-point would add
-			// tracking burden; matches the TLA+ model's analogous
-			// `cache = DefaultInitial` guard.
-			if (this._cached === undefined) return;
-			this._emit(INVALIDATE_ONLY_BATCH);
-			return;
-		}
-
-		// Tier 2 — PAUSE / RESUME flow downstream (spec §1.2). Lock bookkeeping
-		// happens inside `_emit` so both `_onDepMessage` (PAUSE received from
-		// a dep) and external `node.down([[PAUSE, lockId]])` (source
-		// directly issuing PAUSE) hit the same path. Here we just forward —
-		// `_emit` will consume the lock, update `_paused`, and broadcast.
-		if (t === PAUSE || t === RESUME) {
-			this._emit([msg]);
-			return;
-		}
-
-		// Tier 6
-		if (t === TEARDOWN) {
-			this._emit(TEARDOWN_ONLY_BATCH);
-			return;
-		}
-
-		// Tier 3 / 4 — centralized transitions keep the settlement counters
-		// (`_dirtyDepCount`, `_sentinelDepCount`) in sync with the flags on
-		// every DepRecord. A3 optimization: the two counters let
-		// `_maybeRunFnOnSettlement` check wave completion in O(1) instead
-		// of two `every(...)` scans.
-		if (t === DATA) {
-			this._depSettledAsData(dep, msg[1]);
-		} else if (t === RESOLVED) {
-			this._depSettledAsResolved(dep);
-		} else if (t === COMPLETE) {
-			this._depSettledAsTerminal(dep, true);
-		} else if (t === ERROR) {
-			this._depSettledAsTerminal(dep, msg[1]);
-		} else {
-			// Unknown type: forward as-is (spec §1.3.6 forward-compat).
-			this._emit([msg]);
-			return;
-		}
-
-		if (!this._fn) {
-			// Passthrough: forward DATA/RESOLVED 1:1 through the unified
-			// emit pipeline. `_emit` owns tier sort + synthetic DIRTY
-			// prefix + equals substitution uniformly — no manual framing.
-			if (t === DATA || t === RESOLVED) {
-				this._emit([msg]);
-			}
-			if (t === COMPLETE || t === ERROR) {
-				this._maybeAutoTerminalAfterWave();
-			}
-			return;
-		}
-
-		// NOTE: `_maybeRunFnOnSettlement()` is intentionally NOT called here.
-		// It fires at the end of the dep-subscribe callback's message-iteration
-		// loop in `_activate`/`_addDep`, guarded by `config.tierOf(m[0]) >= 3`
-		// — one invocation per dep batch so `fn` sees the full wave (Bug 1).
-	}
-
-	// --- Centralized dep-state transitions (A3 settlement counters) ---
-	//
-	// Every mutation to `DepRecord.dirty` / `DepRecord.prevData` /
-	// `DepRecord.terminal` must go through one of these helpers so the
-	// `_dirtyDepCount` and `_sentinelDepCount` counters stay in sync with
-	// the per-record flags. `_maybeRunFnOnSettlement` reads the counters
-	// and never re-scans the `_deps` array.
-
-	/**
-	 * Called when a dep transitions `dirty: false → true` (either from an
-	 * incoming DIRTY, or pre-set during `_activate` / `_addDep` /
-	 * `_depInvalidated`). No-op if the dep is already dirty. Fires the
-	 * downstream DIRTY emit if we're the first to dirty this wave.
-	 */
-	private _depDirtied(dep: DepRecord): void {
-		if (dep.dirty) return;
-		dep.dirty = true;
-		dep.involvedThisWave = true;
-		this._dirtyDepCount++;
-		// First dep to dirty this wave → propagate DIRTY to our own sinks.
-		if (this._status !== "dirty") {
-			this._emit(DIRTY_ONLY_BATCH);
-		}
-	}
-
-	/**
-	 * Called when a dep delivers new DATA: clears dirty, stores the payload,
-	 * marks wave-has-data, and — if this is the dep's first DATA — clears
-	 * its sentinel slot so the first-run gate can open.
-	 */
-	private _depSettledAsData(dep: DepRecord, value: unknown): void {
-		if (dep.dirty) {
-			dep.dirty = false;
-			this._dirtyDepCount--;
-		}
-		dep.involvedThisWave = true;
-		dep.dataBatch.push(value);
-		this._waveHasNewData = true;
-	}
-
-	/**
-	 * Called when a dep emits RESOLVED (wave settled, value unchanged).
-	 * Clears dirty; does NOT touch `prevData` / `terminal` / sentinel
-	 * count — sentinel only exits on first DATA or terminal, not RESOLVED.
-	 */
-	private _depSettledAsResolved(dep: DepRecord): void {
-		if (dep.dirty) {
-			dep.dirty = false;
-			this._dirtyDepCount--;
-		}
-	}
-
-	/**
-	 * Called when a dep delivers COMPLETE (`terminal = true`) or ERROR
-	 * (`terminal = errorPayload`). Clears dirty, stores the terminal, and
-	 * — if the dep had never contributed a DATA yet — leaves sentinel
-	 * since the gate treats "terminated without data" as gate-open too.
-	 */
-	private _depSettledAsTerminal(dep: DepRecord, terminal: unknown): void {
-		if (dep.dirty) {
-			dep.dirty = false;
-			this._dirtyDepCount--;
-		}
-		dep.terminal = terminal;
-		dep.involvedThisWave = true;
-		this._hasNewTerminal = true;
-	}
-
-	/**
-	 * Called when a dep emits INVALIDATE.
-	 *
-	 * **DS-13.5.A invariant:** INVALIDATE settles a wave for this dep — same
-	 * `_dirtyDepCount` accounting role as RESOLVED. A single `[[INVALIDATE]]`
-	 * arrival on a previously-dirty dep clears the dirty flag and decrements
-	 * the counter; a single arrival on a clean dep is a no-op for the
-	 * counter (the dep was never participating in the wave). Either way, the
-	 * dep's per-wave state — `prevData`, `terminal`, `dataBatch` — clears so
-	 * the next fn run sees the dep in SENTINEL state.
-	 *
-	 * `involvedThisWave` is left `false`: INVALIDATE is not a "fn-must-run"
-	 * trigger by itself. The `invalidateWhenDepsInvalidate` cascade default
-	 * (Q12, deferred) will track involvement separately when implemented.
-	 */
-	private _depInvalidated(dep: DepRecord): void {
-		dep.prevData = undefined;
-		dep.terminal = undefined;
-		dep.dataBatch.length = 0;
-		if (dep.dirty) {
-			dep.dirty = false;
-			this._dirtyDepCount--;
-		}
-		dep.involvedThisWave = false;
-		// DS-13.5.A: mark the wave as having seen an INVALIDATE so
-		// `_maybeRunFnOnSettlement` doesn't re-fire RESOLVED or fn after
-		// the cascade (`_emit(INVALIDATE_ONLY_BATCH)` already settled the
-		// downstream wave via INVALIDATE).
-		this._waveHasInvalidate = true;
-	}
-
-	private _maybeRunFnOnSettlement(): void {
-		if (this._isTerminal && !this._resubscribable) return;
-		// DS-13.5.A Q16 idempotency: a node that has fully torn down (TEARDOWN
-		// processed once, deps disconnected, cleanup fired) must not re-run
-		// fn even when subsequent dep cascades carry settlement-class
-		// messages. Without this guard, the synthetic [[COMPLETE], [TEARDOWN]]
-		// pair Q16 emits on the FIRST teardown delivery floats `_hasNewTerminal`
-		// for downstream consumers; their `_maybeRunFnOnSettlement` then
-		// falls through to `_execFn`, which re-establishes `_cleanup`,
-		// causing a second cleanup invocation on the next TEARDOWN delivery.
-		if (this._teardownDone) return;
-		// O(1) gate: `_dirtyDepCount === 0` means every dep has delivered its
-		// settlement for this wave (DATA, RESOLVED, or terminal).
-		if (this._dirtyDepCount > 0) return;
-		// Spec §2.7 first-run gate. Applied only until fn has fired once
-		// (`_hasCalledFnOnce`, R2.7.3), so `_addDep` post-activation,
-		// subsequent waves, and INVALIDATE do not re-gate. Terminal reset on a
-		// resubscribable node clears `_hasCalledFnOnce` and re-arms.
-		// Scan is O(N) on declared-dep count, fires at most once per
-		// activation cycle — cheaper than maintaining a dedicated counter
-		// in lockstep across `_depSettledAsData` / `_depSettledAsTerminal`
-		// / `_depInvalidated` / `_addDep` / reset paths. `_maybeAutoTerminalAfterWave`
-		// is still called so ERROR propagates even while fn is gated.
-		//
-		// Settle predicate (R2.7.0 + R2.7.1, DS-2.7.A 2026-05-19):
-		//   hasRealData     = d.dataBatch.length > 0 || d.prevData !== undefined
-		//   settledByTerm   = _terminalAsRealInput && d.terminal !== undefined
-		//   isSentinel      = !hasRealData && !settledByTerm
-		// RESOLVED never settles (a dep that only ever emits RESOLVED holds the
-		// gate forever — equals-substituted into RESOLVED never advances
-		// `prevData`). Terminal settles only when the operator opts in via
-		// `NodeOptions.terminalAsRealInput` (Reduce-class: `reduce`/`scan`/
-		// `last`/`take`/`takeWhile`).
-		if (!this._partial && !this._hasCalledFnOnce) {
-			for (let i = 0; i < this._deps.length; i++) {
-				const d = this._deps[i];
-				const hasRealData = d.dataBatch.length > 0 || d.prevData !== undefined;
-				const settledByTerminal = this._terminalAsRealInput && d.terminal !== undefined;
-				if (!hasRealData && !settledByTerminal) {
-					this._maybeAutoTerminalAfterWave();
-					return;
-				}
-			}
-		}
-		if (this._paused) {
-			this._pendingWave = true;
-			return;
-		}
-		// DS-13.5.A: a pure-INVALIDATE wave (no DATA, no terminal, but at
-		// least one dep emitted INVALIDATE) is already settled via the
-		// cascade in `_onDepMessage`'s INVALIDATE branch
-		// (`_emit(INVALIDATE_ONLY_BATCH)` cleared `_cached`, set
-		// `_status = "sentinel"`, and forwarded INVALIDATE to sinks).
-		// Re-firing pre-fn skip RESOLVED here would deliver a
-		// "value-unchanged" claim that contradicts the just-cleared cache,
-		// and re-running fn would compute on cleared `prevData` slots
-		// (e.g. `undefined * 2 = NaN`). Settle silently.
-		if (
-			this._waveHasInvalidate &&
-			!this._waveHasNewData &&
-			!this._hasNewTerminal &&
-			this._hasCalledFnOnce
-		) {
-			this._clearWaveFlags();
-			this._maybeAutoTerminalAfterWave();
-			return;
-		}
-		// Pre-fn skip: when no dep sent DATA this wave (all RESOLVED), skip
-		// fn and emit RESOLVED directly. Transitive-skip optimization — leaf
-		// fn is not re-run when a mid-chain node produces the same value.
-		if (!this._waveHasNewData && !this._hasNewTerminal && this._hasCalledFnOnce) {
-			this._clearWaveFlags();
-			this._emit(RESOLVED_ONLY_BATCH);
-			this._maybeAutoTerminalAfterWave();
-			return;
-		}
-		if (this._fn) this._execFn();
-		this._maybeAutoTerminalAfterWave();
-	}
-
-	private _maybeAutoTerminalAfterWave(): void {
-		if (this._deps.length === 0) return;
-		if (this._isTerminal) return;
-		// ERROR always propagates (unless rescue operator opts out via
-		// errorWhenDepsError: false). Checked independently of _autoComplete
-		// so operators with completeWhenDepsComplete: false still get
-		// automatic error forwarding.
-		const erroredDep = this._deps.find((d) => d.terminal !== undefined && d.terminal !== true);
-		if (erroredDep != null) {
-			if (this._autoError) {
-				this._emit([[ERROR, erroredDep.terminal]]);
-			}
-			return;
-		}
-		// COMPLETE only when autoComplete is true and ALL deps are terminal.
-		if (this._autoComplete && this._deps.every((d) => d.terminal !== undefined)) {
-			this._emit(COMPLETE_ONLY_BATCH);
-		}
-	}
-
-	// --- Fn execution ---
-
-	/**
-	 * @internal Runs the node fn once.
-	 *
-	 * Cleanup firing:
-	 * - Function-form cleanup — fires here (pre-run) AND on deactivation AND
-	 *   on INVALIDATE. Cleared before the new fn runs.
-	 * - Object-form cleanup — only `beforeRun` fires here; `deactivate` and
-	 *   `invalidate` hooks survive across re-runs. The cleanup reference
-	 *   itself is preserved so `deactivate`/`invalidate` still fire later.
-	 */
-	private _execFn(): void {
-		if (!this._fn) return;
-		if (this._isTerminal && !this._resubscribable) return;
-		// Re-entrance guard: if fn is currently executing (e.g. _addDep
-		// triggered a synchronous DATA delivery → _maybeRunFnOnSettlement
-		// → _execFn), defer the re-run until the current fn returns.
-		if (this._isExecutingFn) {
-			this._pendingRerun = true;
-			return;
-		}
-
-		// Pre-run cleanup — fires the `onRerun` hook (Lock 4.A). The cleanup
-		// object itself is preserved so `onDeactivation`/`onInvalidate`
-		// survive re-runs; the `onRerun` slot is nulled out before
-		// invocation so a throw doesn't leave the hook armed for the next
-		// run (violating the "fires exactly once on its named transition"
-		// contract).
-		// Named-hook object form only (Lock 4.A; function-form leg removed).
-		const prevCleanup = this._cleanup;
-		if (prevCleanup != null) {
-			const hook = prevCleanup.onRerun;
-			if (typeof hook === "function") {
-				prevCleanup.onRerun = undefined;
-				try {
-					hook();
-				} catch (err) {
-					this._emit([[ERROR, this._wrapFnError("cleanup.onRerun threw", err)]]);
-					return;
-				}
-			}
-		}
-
-		// Snapshot dep state BEFORE clearing wave flags so the snapshot
-		// reflects "this wave" rather than "next wave".
-		// dataBatch is copied here because _clearWaveFlags truncates the live
-		// array in-place (length = 0) — the fn must see the full wave batch.
-		const batchData: (readonly unknown[] | undefined)[] = this._deps.map((d) =>
-			!d.involvedThisWave ? undefined : d.dataBatch.length > 0 ? [...d.dataBatch] : [],
-		);
-		// Snapshot prevData BEFORE committing this wave's values — fn sees the
-		// stable values from the end of the previous wave, not the current wave.
-		// undefined = "never sent DATA". null is a valid DATA value.
-		const prevData: unknown[] = this._deps.map((d) => d.prevData);
-		// Commit: advance each dep's prevData to this wave's last DATA so the
-		// NEXT wave's fn snapshot sees the current wave as "previous".
-		// Use the already-copied batchData rather than dep.dataBatch to avoid
-		// any ordering dependency with _clearWaveFlags.
-		for (let i = 0; i < this._deps.length; i++) {
-			const batch = batchData[i];
-			if (batch != null && batch.length > 0) {
-				this._deps[i].prevData = batch[batch.length - 1] as unknown;
-			}
-		}
-		const terminalDeps = this._deps.map((d) => d.terminal);
-		const ctx: FnCtx = { prevData, terminalDeps, store: this._store };
-
-		this._hasCalledFnOnce = true;
-		this._clearWaveFlags();
-
-		// Fire inspector hooks before fn runs — for Graph.observe causal traces.
-		if (this._inspectorHooks != null) {
-			const ev: NodeInspectorHookEvent = { kind: "run", batchData, prevData };
-			for (const hook of this._inspectorHooks) hook(ev);
-		}
-
-		this._isExecutingFn = true;
-		try {
-			const result = this._fn(batchData, this._actions, ctx);
-			// Lock 4.A: the named-hook object form is the ONLY accepted
-			// cleanup shape (the legacy `() => void` shorthand was removed
-			// entirely — type, firing sites, and call sites).
-			if (result != null && typeof result === "object") {
-				const o = result as {
-					onRerun?: unknown;
-					onDeactivation?: unknown;
-					onInvalidate?: unknown;
-					onResubscribableReset?: unknown;
-				};
-				if (
-					typeof o.onRerun === "function" ||
-					typeof o.onDeactivation === "function" ||
-					typeof o.onInvalidate === "function" ||
-					typeof o.onResubscribableReset === "function"
-				) {
-					this._cleanup = result as NodeFnCleanup;
-				}
-			}
-		} catch (err) {
-			this._emit([[ERROR, this._wrapFnError("fn threw", err)]]);
-		} finally {
-			this._isExecutingFn = false;
-			// Run any pending rerun BEFORE clearing wave flags so the
-			// rerun's settlement check sees "this wave had new data" and
-			// skips the pre-fn-skip optimization. Without this ordering,
-			// autoTrackNode discovery's second pass gets swallowed by
-			// the pre-fn-skip path.
-			if (this._pendingRerun) {
-				this._pendingRerun = false;
-				this._rerunDepth += 1;
-				// Lock 2.F′ (Phase 13.6.A): cap is read from
-				// `cfg.maxFnRerunDepth` so users can tune it at app startup
-				// (`configure((cfg) => cfg.maxFnRerunDepth = N)`) or per
-				// isolated config instance. Default 100.
-				const maxDepth = this._config.maxFnRerunDepth;
-				if (this._rerunDepth > maxDepth) {
-					const lastDiscoveredDeps =
-						this._deps.length > 0
-							? this._deps.map((d) => (d.node as Node).name ?? "<unnamed>")
-							: undefined;
-					this._rerunDepth = 0;
-					const detail: Record<string, unknown> = {
-						nodeId: this.name,
-						currentDepth: maxDepth + 1,
-						configuredLimit: maxDepth,
-					};
-					if (lastDiscoveredDeps != null) detail.lastDiscoveredDeps = lastDiscoveredDeps;
-					const err = new Error(
-						`Node "${this.name}": _pendingRerun depth exceeded cfg.maxFnRerunDepth (${maxDepth}) — likely a reactive cycle`,
-					);
-					(err as Error & { detail?: unknown }).detail = detail;
-					this._emit([[ERROR, err]]);
-				} else {
-					this._maybeRunFnOnSettlement();
-				}
-			} else {
-				// Chain converged — reset the depth counter for the next wave.
-				this._rerunDepth = 0;
-			}
-			// Clear flags after rerun so any involvedThisWave/dataBatch set by
-			// fn's _addDep subscribe handshakes doesn't leak into the next
-			// wave's snapshot. The inner _execFn (if any) already did
-			// its own pre-snapshot clear; this is for the case where
-			// fn added deps but no rerun fired.
-			this._clearWaveFlags();
-		}
-	}
-
-	private _clearWaveFlags(): void {
-		this._waveHasNewData = false;
-		this._hasNewTerminal = false;
-		this._waveHasInvalidate = false;
-		for (const d of this._deps) {
-			d.involvedThisWave = false;
-			d.dataBatch.length = 0;
-		}
-	}
-
-	private _wrapFnError(label: string, err: unknown): Error {
-		const msg = err instanceof Error ? err.message : String(err);
-		return new Error(`Node "${this.name}": ${label}: ${msg}`, { cause: err });
-	}
-
-	// --- Framing (tier sort + synthetic DIRTY prefix) ---
-
-	/**
-	 * @internal Stable tier sort + synthetic DIRTY prefix for an outgoing
-	 * batch. Fast path: already-monotone single-tier batches (the common
-	 * case from interned singletons like `DIRTY_ONLY_BATCH`) return the
-	 * input unchanged. General path: decorate-sort-undecorate into a new
-	 * array, then prepend `[DIRTY]` after any tier-0 START entries when
-	 * a tier-3 payload is present and the node isn't already dirty.
-	 *
-	 * Single source of truth for the spec §1.3.1 framing invariant. Every
-	 * outgoing path hits `_frameBatch` exactly once via `_emit`.
-	 */
-	private _frameBatch(messages: Messages): Messages {
-		const tierOf = this._config.tierOf;
-		// Fast path: single message.
-		if (messages.length === 1) {
-			const t0 = messages[0][0];
-			const t = tierOf(t0);
-			if (t === 3 && this._status !== "dirty") {
-				return [DIRTY_MSG, messages[0]];
-			}
-			// DS-13.5.A Q15 extension of Rule 1.5: tier-4 INVALIDATE also
-			// gets the synthetic DIRTY auto-prefix when the node isn't
-			// already dirty. This guarantees consumers see DIRTY → INVALIDATE
-			// in order, so dep-side `_depDirtied` increments `_dirtyDepCount`
-			// before `_depInvalidated` decrements it — preserving wave-
-			// settlement accounting for any node that mixes INVALIDATE with
-			// other settle-class signals on sibling deps.
-			if (t === 4 && this._status !== "dirty") {
-				return [DIRTY_MSG, messages[0]];
-			}
-			// DS-13.5.A Q16: TEARDOWN auto-precedes with [COMPLETE] when the
-			// node hasn't yet emitted a terminal lifecycle signal. Idempotent
-			// via `_teardownDone` so redundant TEARDOWN deliveries (e.g.
-			// `Graph.destroy` broadcast + dep cascade) don't re-emit
-			// `[[COMPLETE], [TEARDOWN]]` pairs to sinks. State nodes that
-			// never delivered DATA (status="sentinel") still get the synthetic
-			// COMPLETE so bridge subscribers (firstWhere/firstValueFrom)
-			// reject cleanly instead of hanging on a TEARDOWN-only wave.
-			if (t0 === TEARDOWN && !this._teardownDone && !this._isTerminal) {
-				return [COMPLETE_MSG, messages[0]];
-			}
-			return messages;
-		}
-		// Check monotonicity, settle-slice presence (tier 3 or tier 4),
-		// terminal-lifecycle presence, TEARDOWN presence, and INVALIDATE
-		// count in a single pass — used for DIRTY auto-prefix (§1.3.1
-		// + Q15 extension), Q16 COMPLETE auto-prefix, and DS-13.5.A §2.4a
-		// same-wave merge rules.
-		let monotone = true;
-		let hasSettleSlice = false;
-		let hasDirty = false;
-		let hasTerminalLifecycle = false;
-		let hasTeardown = false;
-		let invalidateCount = 0;
-		let prevTier = -1;
-		for (const m of messages) {
-			const t = m[0];
-			const tier = tierOf(t);
-			if (tier < prevTier) monotone = false;
-			if (tier === 3 || tier === 4) hasSettleSlice = true;
-			if (t === DIRTY) hasDirty = true;
-			else if (t === COMPLETE || t === ERROR) hasTerminalLifecycle = true;
-			else if (t === TEARDOWN) hasTeardown = true;
-			if (t === INVALIDATE) invalidateCount++;
-			prevTier = tier;
-		}
-		let sorted: Messages = messages;
-		if (!monotone) {
-			// Stable sort via index-keyed decoration.
-			const indexed = messages.map((m, i) => ({ m, i, tier: tierOf(m[0]) }));
-			indexed.sort((a, b) => a.tier - b.tier || a.i - b.i);
-			sorted = indexed.map((x) => x.m);
-		}
-		// DS-13.5.A §2.4a merge rules — INVALIDATE wins by natural tier-sort.
-		// With INVALIDATE at tier 4 (after tier-3 DATA/RESOLVED), the sorted
-		// wave walks DIRTY → DATA(v) → INVALIDATE. `_updateState` advances
-		// `_cached` to v on DATA, then INVALIDATE clears it back to
-		// `undefined`. Final cache state matches user intent: a wave that
-		// carries an INVALIDATE leaves the cache cleared, regardless of
-		// whether DATA/RESOLVED also rode the same wave. Subscribers observe
-		// the full sequence (`[DIRTY, DATA(v), INVALIDATE]` etc.) so they
-		// can distinguish "we got a value briefly then it was invalidated"
-		// from "no DATA arrived this wave."
-		//
-		// Q9 — INVALIDATE + INVALIDATE collapse to one. Idempotent: multiple
-		// INVALIDATEs in the same wave express the same intent; collapsing
-		// keeps the wire compact and prevents duplicate cleanup-hook firing.
-		if (invalidateCount > 1) {
-			let firstInvalidateKept = false;
-			const merged: Message[] = [];
-			for (const m of sorted) {
-				if (m[0] === INVALIDATE) {
-					if (firstInvalidateKept) continue;
-					firstInvalidateKept = true;
-				}
-				merged.push(m);
-			}
-			sorted = merged as unknown as Messages;
-		}
-		// DIRTY auto-prefix (§1.3.1 + DS-13.5.A Q15 extension to tier-4).
-		// Triggers when the wave carries any settle-class payload (tier-3
-		// DATA/RESOLVED OR tier-4 INVALIDATE) and the node isn't already
-		// in `dirty` status.
-		if (hasSettleSlice && !hasDirty && this._status !== "dirty") {
-			// Insert DIRTY after any tier-0 START entries to preserve
-			// monotonicity.
-			let insertAt = 0;
-			while (insertAt < sorted.length && tierOf(sorted[insertAt][0]) === 0) insertAt++;
-			sorted =
-				insertAt === 0
-					? [DIRTY_MSG, ...sorted]
-					: [...sorted.slice(0, insertAt), DIRTY_MSG, ...sorted.slice(insertAt)];
-		}
-		// DS-13.5.A Q16: TEARDOWN auto-precedes with [COMPLETE] when the node
-		// hasn't yet emitted a terminal lifecycle signal AND no terminal
-		// signal is already present in this wave. Idempotent via
-		// `_teardownDone` so redundant TEARDOWN deliveries don't re-fire.
-		// Sentinel-status state nodes still get the prefix — bridge
-		// subscribers need the COMPLETE to settle on streams that never
-		// delivered DATA.
-		if (hasTeardown && !hasTerminalLifecycle && !this._teardownDone && !this._isTerminal) {
-			let teardownIdx = 0;
-			while (teardownIdx < sorted.length && sorted[teardownIdx][0] !== TEARDOWN) teardownIdx++;
-			sorted =
-				teardownIdx === 0
-					? [COMPLETE_MSG, ...sorted]
-					: [...sorted.slice(0, teardownIdx), COMPLETE_MSG, ...sorted.slice(teardownIdx)];
-		}
-		return sorted;
-	}
-
-	// --- Emit pipeline ---
-
-	/**
-	 * @internal The unified dispatch waist — one call = one wave.
-	 * See `GRAPHREFLY-SPEC.md` §1.3.1 for protocol context — the stages
-	 * below are the implementation order.
-	 *
-	 * Pipeline stages, in order:
-	 *
-	 *   1. Terminal filter — post-COMPLETE/ERROR only TEARDOWN/INVALIDATE
-	 *      still propagate so graph teardown and cache-clear still work.
-	 *   2. Tier sort (stable) — the batch can be in any order when it
-	 *      arrives; the walker downstream (`downWithBatch`) assumes
-	 *      ascending tier monotone, and so does `_updateState`'s tier-3
-	 *      slice walk. This is the single source of truth for ordering.
-	 *   3. Synthetic DIRTY prefix — if a tier-3 payload is present, no
-	 *      DIRTY is already in the batch, and the node isn't already in
-	 *      `"dirty"` status, prepend `[DIRTY]` after any tier-0 START
-	 *      entries. Guarantees spec §1.3.1 (DIRTY precedes DATA within
-	 *      the same batch) uniformly across every entry point.
-	 *   4. PAUSE/RESUME lock bookkeeping (C0) — update `_pauseLocks`,
-	 *      derive `_paused`, filter unknown-lockId RESUME, replay
-	 *      bufferAll buffer on final lock release.
-	 *   5. Meta TEARDOWN fan-out — notify meta children before
-	 *      `_updateState`'s TEARDOWN branch calls `_deactivate`. Hoisted
-	 *      out of the walk to keep `_updateState` re-entrance-free.
-	 *   6. `_updateState` — walk the batch in tier order, advancing
-	 *      `_cached` / `_status` / `_versioning` and running equals
-	 *      substitution on tier-3 DATA (§3.5.1). Returns
-	 *      `{finalMessages, equalsError?}`.
-	 *   7. `downWithBatch` dispatch (or bufferAll capture if paused with
-	 *      `pausable: "resumeAll"`).
-	 *   8. Recursive ERROR emission if equals threw mid-walk.
-	 */
-	_emit(messages: Messages): void {
-		if (messages.length === 0) return;
-
-		// Spec §1.2 — `[ERROR, payload]` requires a non-`undefined` payload.
-		// `undefined` is reserved as the protocol-internal "never sent" sentinel
-		// and would collide with `DepRecord.terminal === undefined` ("dep is
-		// live"), making the ERROR indistinguishable from no termination at
-		// downstream sinks and breaking the `_maybeAutoTerminalAfterWave`
-		// ERROR-propagation check (`d.terminal !== undefined`). Reject at the
-		// dispatch boundary with a developer-facing error — pass real error
-		// values (`new Error(reason)` / domain-tag strings).
-		for (let i = 0; i < messages.length; i++) {
-			const m = messages[i];
-			if (m[0] === ERROR && m[1] === undefined) {
-				throw new TypeError(
-					`[ERROR, payload] requires a non-undefined payload (spec §1.2). Pass an Error object or domain tag instead — e.g. node.down([[ERROR, new Error("reason")]])`,
-				);
-			}
-		}
-
-		// D282 R4.3.2 throw-rollback snapshot capture (hoisted to TOP of
-		// `_emit` per /qa F3). Captured BEFORE the PAUSE/RESUME lock
-		// bookkeeping, meta TEARDOWN fan-out, `_updateState`, and
-		// `_pushReplayBuffer` — every state-mutating sub-path of the emit
-		// pipeline must be downstream of this capture for the
-		// "post-rollback observable state ≡ pre-batch observable state"
-		// invariant to hold. `isExplicitlyBatching()` excludes drain-time
-		// re-entries (R1.3.6.c). `_preBatchSnapshot === null` makes
-		// capture idempotent per batch session — subsequent emits within
-		// the same outer batch (incl. nested-batch emits at batchDepth>1)
-		// re-use the original pre-batch snapshot.
-		if (isExplicitlyBatching() && this._preBatchSnapshot === null) {
-			this._captureBatchSnapshot();
-		}
-
-		// Terminal filter: after COMPLETE/ERROR (non-resubscribable), only
-		// TEARDOWN / INVALIDATE still propagate so graph teardown and cache-
-		// clear still work.
-		let deliverable = messages;
-		const terminal = this._isTerminal;
-		if (terminal && !this._resubscribable) {
-			const pass = messages.filter((m) => m[0] === TEARDOWN || m[0] === INVALIDATE);
-			if (pass.length === 0) return;
-			deliverable = pass;
-		}
-
-		// Tier sort + synthetic DIRTY prefix (stages 3 + 4 of the emit
-		// pipeline). `_frameBatch` is a no-op for pre-sorted single-msg
-		// batches (the common case from the tuple-interning A2 call sites);
-		// otherwise it produces a stable tier-sorted copy with `[DIRTY]`
-		// auto-prepended after any tier-0 messages when a tier-3 payload
-		// is present and the node isn't already dirty.
-		deliverable = this._frameBatch(deliverable);
-
-		// C0 — PAUSE/RESUME lock tracking. Every tier-2 tuple MUST carry a
-		// `lockId` payload. Each PAUSE / RESUME updates `_pauseLocks` and
-		// derives `_paused` from set size — multi-pauser correctness
-		// guarantees a node only resumes when every lock it holds is
-		// released. All tier-2 messages are forwarded unconditionally so
-		// downstream nodes on the propagation path keep their own lock
-		// sets consistent (subscribers that joined the graph before any
-		// PAUSE see the full lock history). `pausable: false` sources
-		// forward PAUSE/RESUME but do not track locks — appropriate for
-		// reactive timers that must keep ticking. Unknown-lockId RESUME
-		// is swallowed to keep `dispose()` idempotent.
-		let filtered: Message[] | null = null;
-		for (let i = 0; i < deliverable.length; i++) {
-			const m = deliverable[i];
-			const t = m[0];
-			if (t !== PAUSE && t !== RESUME) {
-				if (filtered != null) filtered.push(m);
-				continue;
-			}
-			if (m.length < 2) {
-				throw new Error(
-					`Node "${this.name}": [[${t === PAUSE ? "PAUSE" : "RESUME"}]] must ` +
-						"carry a lockId payload — bare PAUSE/RESUME is a protocol " +
-						"violation (C0 rule). Use `[[PAUSE, lockId]]` / " +
-						"`[[RESUME, lockId]]`.",
-				);
-			}
-			let forward = true;
-			if (this._pausable !== false) {
-				const lockId = m[1];
-				if (t === PAUSE) {
-					const wasPaused = this._paused;
-					if (this._pauseLocks == null) this._pauseLocks = new Set();
-					this._pauseLocks.add(lockId);
-					this._paused = true;
-					if (this._pausable === "resumeAll" && this._pauseBuffer == null) {
-						this._pauseBuffer = [];
-					}
-					// Lock 6.A: track pause-cycle start for `lockHeldDurationMs`
-					// in overflow diagnostics. First lock starts the cycle;
-					// subsequent locks while already paused don't reset.
-					if (!wasPaused) {
-						this._pauseStartNs = monotonicNs();
-						this._pauseDroppedCount = 0;
-						this._pauseOverflowed = false;
-						// Lock 2.C: snapshot the pre-pause baseline on the
-						// first PAUSE of the cycle — SAME `!wasPaused` gate as
-						// `_pauseStartNs` so a mid-drain re-pause (drain set
-						// `_paused = false` then replays; a subscriber's PAUSE
-						// reaction sees `wasPaused === false`) RE-captures the
-						// new cycle's baseline. Keying this off
-						// `_pauseBuffer == null` would miss it (the drain
-						// leaves `_pauseBuffer = []`, not `null`). The RESUME
-						// drain restores this so replayed waves re-derive
-						// equals + version from the conceptual timeline, not
-						// the mid-pause-advanced cache.
-						if (this._pausable === "resumeAll") {
-							const v = this._versioning;
-							this._prePauseSnapshot = {
-								cached: this._cached,
-								status: this._status,
-								versioning:
-									v == null
-										? undefined
-										: "cid" in v
-											? { version: v.version, cid: v.cid, prev: v.prev }
-											: { version: v.version },
-							};
-						}
-					}
-				} else {
-					// RESUME
-					if (this._pauseLocks == null || !this._pauseLocks.has(lockId)) {
-						// Unknown lockId — swallow to keep dispose idempotent.
-						forward = false;
-					} else {
-						this._pauseLocks.delete(lockId);
-						if (this._pauseLocks.size === 0) {
-							this._paused = false;
-							// Lock 2.C / 2.C′ (Phase 13.6.A): replay buffered
-							// waves through `_emit` BEFORE forwarding RESUME so
-							// subscribers observe the deferred settle slices
-							// as part of the pre-RESUME wake-up.
-							//
-							// One `_emit(wave)` per buffered wave preserves
-							// Lock 1.D wave-content invariants across the
-							// pause boundary: multi-DATA waves stay
-							// multi-DATA (no equals substitution; spec §1.3.3
-							// + Lock 1.D); single-DATA waves see equals
-							// against the cache shaped by all prior buffered
-							// waves having "happened" in the conceptual
-							// timeline; single-RESOLVED and single-INVALIDATE
-							// waves replay verbatim. The pre-13.6.A flat
-							// `Message[]` buffer + per-message replay would
-							// collapse multi-DATA waves into per-DATA single-
-							// DATA waves, wrongly applying equals substitution
-							// (Lock 2.C′ refactor target).
-							//
-							// Lock 2.C / spec R2.6.1 (amended 2026-05-17):
-							// the restore below rolls `_cached`/`_status`/
-							// `_versioning` back to the pre-pause baseline
-							// FIRST, so each replayed wave's `_updateState`
-							// equals reference is "the cache as at the end of
-							// the previous buffered wave, starting pre-pause"
-							// — wave 1 vs pre-pause cache, wave N vs cache
-							// shaped by waves 1..N-1. This RETIRES the old D2
-							// (2026-04-13) "absorbed pulse" semantic where
-							// `_cached` was already mid-pause-advanced at drain
-							// time so every same-value pulse collapsed to
-							// RESOLVED. Now only a genuine no-op write (same
-							// value vs the conceptual-timeline cache) collapses.
-							// Producers wanting EVERY write observable
-							// regardless of value still set
-							// `equals: () => false` on the node.
-							if (this._pauseBuffer != null && this._pauseBuffer.length > 0) {
-								const drain = this._pauseBuffer;
-								this._pauseBuffer = [];
-								// Lock 2.C: restore the pre-pause baseline so
-								// each replayed wave's `_updateState`
-								// re-derives equals/version from the
-								// conceptual timeline (wave 1 vs pre-pause
-								// cache; wave N vs cache shaped by waves
-								// 1..N-1) — NOT the mid-pause-advanced cache
-								// (the old D2 "absorbed pulse" collapse).
-								// Skip the restore if the node went terminal
-								// mid-pause: a buffered tier-3/4 replay is
-								// already a post-terminal no-op, and rolling
-								// `_status` back would resurrect a dead node.
-								const snap = this._prePauseSnapshot;
-								if (snap != null && this._status !== "completed" && this._status !== "errored") {
-									this._cached = snap.cached;
-									this._status = snap.status;
-									const sv = snap.versioning;
-									const lv = this._versioning;
-									if (sv != null && lv != null) {
-										// Identity-stable across the synchronous
-										// pause cycle (no mid-pause upgrade) —
-										// roll back the mutable counter, and the
-										// V1 linked-history (`cid`/`prev`) so the
-										// replayed waves rebuild the chain off
-										// the pre-pause cid, not a mid-pause one.
-										lv.version = sv.version;
-										if ("cid" in lv && sv.cid !== undefined) {
-											const v1 = lv as { cid: string; prev: string | null };
-											v1.cid = sv.cid;
-											v1.prev = sv.prev ?? null;
-										}
-									}
-								}
-								for (const wave of drain) {
-									this._emit(wave);
-								}
-							}
-							// Lock 6.A: clear the pause-cycle bookkeeping so
-							// the next pause cycle starts with a fresh
-							// dropped-count + overflow flag.
-							//
-							// Re-pause guard: if a downstream subscriber's
-							// reaction to one of the replayed waves issued an
-							// `up.pause(lockId2)` mid-drain — re-entering the
-							// node into a NEW pause cycle whose
-							// `_pauseStartNs` was just initialised by the
-							// `wasPaused === false` check above — clearing
-							// here would clobber the fresh cycle's
-							// bookkeeping. Only clear when the node has
-							// genuinely exited the paused state.
-							if (!this._paused) {
-								this._pauseStartNs = undefined;
-								this._pauseDroppedCount = 0;
-								this._pauseOverflowed = false;
-								// Lock 2.C: drop the snapshot on final RESUME.
-								// Guarded by the same re-pause check — a
-								// mid-drain re-pause already captured a fresh
-								// snapshot for the new cycle (the PAUSE branch
-								// fires with `_pauseBuffer == null`), so we
-								// must not null it here.
-								this._prePauseSnapshot = null;
-							}
-							// Kick the held wave forward if one was pending.
-							if (this._pendingWave) {
-								this._pendingWave = false;
-								this._maybeRunFnOnSettlement();
-							}
-						}
-					}
-				}
-			}
-			if (!forward) {
-				if (filtered == null) filtered = deliverable.slice(0, i) as Message[];
-			} else if (filtered != null) {
-				filtered.push(m);
-			}
-		}
-		if (filtered != null) {
-			if (filtered.length === 0) return;
-			deliverable = filtered;
-		}
-
-		// Meta TEARDOWN fan-out happens BEFORE `_updateState` so the walk
-		// stays re-entrance-free: a meta node's own dispatch must not
-		// re-enter the parent's outgoing pipeline while `this._cached` /
-		// `this._status` are mid-commit. This preserves the spec ordering
-		// "meta propagates before deactivation" — `_updateState`'s TEARDOWN
-		// branch still runs `_deactivate` AFTER the meta children
-		// have already been notified here.
-		if (this._hasMeta && deliverable.some((m) => m[0] === TEARDOWN)) {
-			for (const k of Object.keys(this.meta)) {
-				try {
-					(this.meta[k] as NodeImpl)._emit(TEARDOWN_ONLY_BATCH);
-				} catch {
-					/* best-effort */
-				}
-			}
-		}
-
-		// (D282 snapshot capture moved to TOP of `_emit` per /qa F3 — see
-		// `_captureBatchSnapshot` below.)
-
-		// State update + equals substitution (§3.5.1 invariant). Returns the
-		// possibly-rewritten batch and an optional equals-throw error. When
-		// equals throws mid-walk we still deliver the successfully-walked
-		// prefix to sinks before emitting ERROR, preserving cache/wire
-		// coherence (user P2 option (i)).
-		const { finalMessages, equalsError } = this._updateState(deliverable);
-
-		// Global inspector fan-out (Redux-DevTools-style tracer). Fires once
-		// per outgoing batch, gated by `inspectorEnabled` so production paths
-		// pay one boolean check. Hook errors are swallowed — instrumentation
-		// must not break the data plane.
-		if (finalMessages.length > 0 && this._config.inspectorEnabled) {
-			const inspector = this._config.globalInspector;
-			if (inspector != null) {
-				try {
-					inspector({ kind: "emit", node: this, messages: finalMessages });
-				} catch {
-					/* best-effort */
-				}
-			}
-		}
-
-		if (finalMessages.length > 0) {
-			// BufferAll: while paused with `pausable: "resumeAll"`, buffer
-			// the settle slice — tier-3 (DATA/RESOLVED) and tier-4 (INVALIDATE,
-			// per DS-13.5.A Q7) — as one **wave entry** per `_emit` call,
-			// preserving wave shape for replay (Lock 2.C + 2.C′ + 2.C′-pre).
-			// Everything else — tier 0–2 (START/DIRTY/PAUSE/RESUME), tier 5
-			// (COMPLETE/ERROR), and tier 6 (TEARDOWN) — dispatches
-			// synchronously so subscribers, downstream pausers, and graph
-			// teardown observe them regardless of flow control. Tier-5
-			// stream-lifecycle signals must reach subscribers even when a
-			// controller holds a lock and never issues RESUME — the
-			// alternative strands observers without an end-of-stream signal
-			// (leaked-controller + source-terminates = subscriber waits
-			// indefinitely). Cache/status advance has already happened via
-			// `_updateState`, so the replay later just re-walks the deferred
-			// wave through `_emit` (which calls `_updateState` again,
-			// idempotently advancing cache to the same value). Spec §2.6
-			// bufferAll.
-			if (this._paused && this._pausable === "resumeAll" && this._pauseBuffer != null) {
-				const tierOf = this._config.tierOf;
-				const settleSlice: Message[] = [];
-				const immediate: Message[] = [];
-				for (const m of finalMessages) {
-					const tier = tierOf(m[0]);
-					if (tier === 3 || tier === 4) {
-						settleSlice.push(m);
-					} else {
-						immediate.push(m);
-					}
-				}
-				if (settleSlice.length > 0) {
-					this._pauseBuffer.push(settleSlice as Messages);
-					// Lock 6.A: enforce the configured cap. Drop oldest
-					// waves while over-cap; emit one ERROR per pause cycle
-					// (gated on `_pauseOverflowed`) carrying cumulative
-					// drop count so a producer pushing thousands of waves
-					// over the cap doesn't spam ERROR.
-					const max = this._config.pauseBufferMax;
-					if (this._pauseBuffer.length > max) {
-						const dropped = this._pauseBuffer.length - max;
-						this._pauseBuffer.splice(0, dropped);
-						this._pauseDroppedCount += dropped;
-						if (!this._pauseOverflowed) {
-							this._pauseOverflowed = true;
-							const lockHeldDurationMs =
-								this._pauseStartNs != null
-									? Math.trunc((monotonicNs() - this._pauseStartNs) / 1_000_000)
-									: 0;
-							// Build the overflow error directly (no
-							// `_wrapFnError` wrapping — that would double the
-							// `Node "X":` prefix that the inner message
-							// already carries).
-							const overflowError = new Error(
-								`Node "${this.name ?? "<unnamed>"}": pause-replay buffer ` +
-									`exceeded pauseBufferMax (${max} waves) — dropping oldest ` +
-									"buffered wave(s). Bump `cfg.pauseBufferMax` if a higher " +
-									"sustained backlog is expected, or release pause locks " +
-									"sooner.",
-							);
-							(overflowError as Error & { detail?: unknown }).detail = {
-								nodeId: this.name,
-								droppedCount: this._pauseDroppedCount,
-								configuredMax: max,
-								lockHeldDurationMs,
-							};
-							// Lock 6.A semantic: "The error propagates
-							// downstream per default error semantics (rule
-							// 1.4)." Rule 1.4 makes ERROR a terminal
-							// lifecycle signal — the source transitions to
-							// `"errored"` and stops accepting further DATA.
-							// Route through a recursive `_emit` so the ERROR
-							// goes through `_updateState` (which sets
-							// `_status = "errored"`) and the standard
-							// terminal-message dispatch path. The recursive
-							// call dispatches synchronously even while paused
-							// (tier-5 bypasses the buffer below).
-							//
-							// Buffered waves still pending in `_pauseBuffer`
-							// remain there; they will NOT replay because
-							// post-terminal `_emit` is a no-op for non-
-							// terminal-class messages. This is a design
-							// trade-off: heavy-hand termination on overflow
-							// guarantees no silent shedding past the first
-							// drop. Bump `cfg.pauseBufferMax` if your
-							// producer's sustained pause backlog exceeds the
-							// default 10_000.
-							this._emit([[ERROR, overflowError]]);
-						}
-					}
-				}
-				if (immediate.length > 0) {
-					this._dispatchOrAccumulate(immediate);
-				}
-			} else {
-				// Lock 6.G (spec §2.5): push outgoing DATA into the replay
-				// buffer at the dispatch point — NOT inside `_updateState`.
-				// Reasoning: the spec mandates "last N **outgoing** DATA",
-				// i.e. values subscribers actually observed. Pushing inside
-				// `_updateState` would (a) count cache-advances mid-pause
-				// (which never reach sinks) and (b) re-push during RESUME
-				// drain when buffered waves are replayed through `_emit`
-				// and re-walk the cache. Both would corrupt the
-				// "values-seen" semantic. Pause-buffered tier-3 traffic
-				// reaches this branch only after RESUME drain dispatches
-				// it, at which point it gets pushed correctly.
-				this._pushReplayBuffer(finalMessages);
-				this._dispatchOrAccumulate(finalMessages);
-			}
-		}
-
-		if (equalsError != null) {
-			this._emit([[ERROR, equalsError]]);
-		}
-	}
-
-	/**
-	 * @internal Walk an outgoing (already-framed) batch, updating own
-	 * cache / status / versioning and running equals substitution on
-	 * every tier-3 DATA (§3.5.1). Framing — tier sort and synthetic
-	 * DIRTY prefix — has already happened upstream in `_frameBatch`.
-	 * This walk trusts the input is in monotone tier order and that the
-	 * spec §1.3.1 DIRTY/RESOLVED precedence invariant is already
-	 * satisfied by the frame.
-	 *
-	 * Equals substitution: every DATA payload is compared against the
-	 * live `_cached`; when equal, the tuple is rewritten to `[RESOLVED]`
-	 * in a per-call copy and cache is not re-advanced. `.cache` remains
-	 * coherent with "the last DATA payload this node actually sent
-	 * downstream".
-	 *
-	 * Returns `{ finalMessages, equalsError? }`:
-	 * - `finalMessages` — the array to deliver to sinks (may be
-	 *   `messages` unchanged, a rewritten copy with DATA→RESOLVED
-	 *   substitutions, or a truncated prefix when equals throws mid-walk).
-	 * - `equalsError` — present only when the configured `equals` function
-	 *   threw on some DATA message. `_emit` delivers the prefix first,
-	 *   then emits a fresh ERROR batch via a recursive `_emit` call so
-	 *   subscribers observe `[...walked_prefix, ERROR]` in order.
-	 */
-	private _updateState(messages: Messages): {
-		finalMessages: Messages;
-		equalsError?: Error;
-	} {
-		const tierOf = this._config.tierOf;
-		let rewritten: Message[] | undefined;
-		let equalsError: Error | undefined;
-		let abortedAt = -1;
-		// Count tier-3 messages (DATA + RESOLVED) in the batch. Equals
-		// substitution is only worthwhile for a single tier-3 message —
-		// an unchanged value can be rewritten to RESOLVED, enabling the
-		// downstream pre-fn skip. With multiple tier-3 messages the
-		// downstream fn must run regardless, so equals on each is wasted.
-		let dataCount = 0;
-		for (const m of messages) {
-			if (tierOf(m[0]) === 3) dataCount++;
-		}
-		const checkEquals = dataCount <= 1;
-		// Version advances once per batch wave, not per DATA in the batch.
-		// _cached only retains the last DATA value, so intermediate version
-		// entries would reference values that can never be retrieved from cache.
-		// Pre-scan for the last DATA index so we know when to fire advanceVersion.
-		let lastDataIdx = -1;
-		if (this._versioning != null && dataCount > 1) {
-			for (let i = messages.length - 1; i >= 0; i--) {
-				if (messages[i][0] === DATA) {
-					lastDataIdx = i;
-					break;
-				}
-			}
-		}
-
-		for (let i = 0; i < messages.length; i++) {
-			const m = messages[i];
-			const t = m[0];
-			if (t === DATA) {
-				if (m.length >= 2) {
-					let unchanged = false;
-					if (checkEquals && this._cached !== undefined) {
-						try {
-							unchanged = this._equals(this._cached as T, m[1] as T);
-						} catch (err) {
-							// Lock 2.A (Phase 13.6.A): branch on
-							// `cfg.equalsThrowPolicy`.
-							//
-							// `"rethrow"` (dev default) — abort the walk,
-							// deliver the successfully-walked prefix, then
-							// `_emit` emits a fresh ERROR batch annotated with
-							// node id + wave context. The buggy `equals`
-							// surfaces immediately to the developer.
-							//
-							// `"log-and-continue"` (prod default) — log once
-							// per node lifetime, treat as `unchanged === false`
-							// (emit DATA verbatim; the wire stays alive). One
-							// bad equals doesn't kill the wave or cascade an
-							// ERROR through every downstream consumer.
-							if (this._config.equalsThrowPolicy === "log-and-continue") {
-								if (!this._equalsErrorLogged) {
-									this._equalsErrorLogged = true;
-									console.error(
-										`Node "${this.name ?? "<unnamed>"}": equals threw — falling back to verbatim emit. ` +
-											"Subsequent equals throws on this node will be silently ignored. " +
-											'Set `cfg.equalsThrowPolicy = "rethrow"` to surface them.',
-										err,
-									);
-								}
-								// unchanged stays false → fall through to the
-								// DATA emission path below, which advances cache
-								// and emits the value verbatim.
-							} else {
-								equalsError = this._wrapFnError("equals threw", err);
-								abortedAt = i;
-								break;
-							}
-						}
-					}
-					if (unchanged) {
-						if (rewritten == null) rewritten = messages.slice(0, i) as Message[];
-						rewritten.push(RESOLVED_MSG);
-						this._status = "resolved";
-						continue;
-					}
-					this._cached = m[1] as T;
-					if (this._versioning != null) {
-						// dataCount <= 1: lastDataIdx is -1; advance unconditionally
-						// (single DATA, correct as before).
-						// dataCount > 1: only advance on the last DATA in the batch.
-						if (lastDataIdx < 0 || i === lastDataIdx) {
-							advanceVersion(this._versioning, m[1], this._hashFn);
-						}
-					}
-				}
-				this._status = "settled";
-				if (rewritten != null) rewritten.push(m);
-			} else {
-				if (rewritten != null) rewritten.push(m);
-				if (t === DIRTY) {
-					this._status = "dirty";
-				} else if (t === RESOLVED) {
-					this._status = "resolved";
-				} else if (t === COMPLETE) {
-					this._status = "completed";
-					// Rigor-infra ghost-state hook (TLC #25 mirror): classify
-					// the terminal transition. `hasDeps === true && _autoComplete
-					// === true` ≈ TLA+ "dep-cascade-complete"; otherwise
-					// "self-source-terminate". Zero production cost when unset.
-					{
-						const rec = this._config.rigorRecorder;
-						if (rec != null) {
-							try {
-								rec.onTerminalTransition(
-									this,
-									"completed",
-									this._autoComplete,
-									this._autoError,
-									this._deps.length > 0,
-								);
-							} catch {
-								/* best-effort */
-							}
-						}
-					}
-				} else if (t === ERROR) {
-					this._status = "errored";
-					// Rigor-infra ghost-state hook (TLC #25 mirror): same shape
-					// as the COMPLETE branch above, classifying ERROR.
-					{
-						const rec = this._config.rigorRecorder;
-						if (rec != null) {
-							try {
-								rec.onTerminalTransition(
-									this,
-									"errored",
-									this._autoComplete,
-									this._autoError,
-									this._deps.length > 0,
-								);
-							} catch {
-								/* best-effort */
-							}
-						}
-					}
-				} else if (t === INVALIDATE) {
-					// Rigor-infra ghost-state hook (TLC #19 / #24 / #26 mirrors):
-					// record the non-vacuous INVALIDATE site — the pre-reset
-					// `_cached` is the cleanup-witness value. Covers both the
-					// dep-cascade path (`_onDepMessage` INVALIDATE handler,
-					// which delegates here via `_emit(INVALIDATE_ONLY_BATCH)`)
-					// and the direct-origination path (`.down([[INVALIDATE]])`
-					// on a source or mid-chain node). Guarded on `_cached !==
-					// undefined` so vacuous invalidates (diamond fan-in second
-					// arrival, already-reset node) don't fire. Zero production
-					// cost when `rigorRecorder` is unset.
-					if (this._cached !== undefined) {
-						const rec = this._config.rigorRecorder;
-						if (rec != null) {
-							try {
-								rec.onNonVacuousInvalidate(this, this._cached);
-							} catch {
-								/* best-effort — instrumentation must not break data plane */
-							}
-						}
-					}
-					// DS-13.5.A pass-3 (N1 fix): INVALIDATE on a
-					// terminal-resubscribable node is a lifecycle boundary —
-					// run the full lifecycle reset so any subscribers that
-					// kept the node alive past terminal (multi-sub case where
-					// `_deactivate` did NOT run) don't carry stale
-					// `_hasCalledFnOnce` / `_dirtyDepCount` / DepRecord state
-					// into the next wave. Without this, fn computes against
-					// ghost `prevData` after INVALIDATE clears caches.
-					// `_resetForFreshLifecycle` clears `_cached` + sets status
-					// to `"sentinel"` itself, so this is the single
-					// state-mutation entry on the resubscribable path.
-					if (this._isTerminal && this._resubscribable) {
-						this._resetForFreshLifecycle();
-					} else {
-						this._cached = undefined;
-						// DS-13.5.A: INVALIDATE is settle-class (decrements
-						// `_dirtyDepCount` on consumers like RESOLVED). It
-						// does NOT leave the emitting node in `"dirty"`
-						// status — `"dirty"` means "value about to change"
-						// but INVALIDATE has just cleared the cache outright
-						// with no new value pending. Transition to
-						// `"sentinel"` ("no value, nothing pending").
-						// Critically, `defaultOnSubscribe`'s
-						// push-on-subscribe sees `"sentinel"` + `_cached ===
-						// undefined` and pushes only `[START]` to new
-						// subscribers, rather than `[START, DIRTY]` for
-						// `"dirty"` status — that DIRTY-inheritance was the
-						// regression source for agentLoop's abort path (a
-						// freshly-attached `_terminalResult` had its
-						// `lastResponseState` dep slot permanently dirty,
-						// never settled, fn never re-ran).
-						this._status = "sentinel";
-					}
-					// Cleanup firing on INVALIDATE — fires the `onInvalidate`
-					// hook (Lock 4.A). The cleanup object itself is preserved
-					// so `onDeactivation` still fires later if the node
-					// deactivates; the `onInvalidate` slot is nulled before
-					// invocation so:
-					//   (a) a throw inside the hook doesn't leave it armed for
-					//       a second fire (consistent with `onRerun`'s
-					//       null-out-on-fire pattern in `_execFn`);
-					//   (b) when an INVALIDATE wave is buffered through
-					//       `pausable: "resumeAll"` and replayed on RESUME
-					//       (Lock 2.C′-pre), the replay walk's INVALIDATE does
-					//       NOT re-fire the hook a second time;
-					//   (c) two INVALIDATE waves arriving without a fn rerun
-					//       between them (rare cross-wave case) only fire the
-					//       hook once — semantically correct since the second
-					//       INVALIDATE arrives at an already-`"sentinel"` node
-					//       with `_cached === undefined`.
-					// Named-hook object form only (Lock 4.A; the legacy
-					// function-form leg was removed).
-					const c = this._cleanup;
-					if (c != null) {
-						const hook = c.onInvalidate;
-						if (typeof hook === "function") {
-							c.onInvalidate = undefined;
-							try {
-								hook();
-							} catch {
-								/* best-effort */
-							}
-						}
-					}
-				} else if (t === TEARDOWN) {
-					if (this._resetOnTeardown) this._cached = undefined;
-					// Meta TEARDOWN fan-out was already performed by `_emit`
-					// before this walk. Deactivate now that meta children
-					// have been notified.
-					//
-					// /qa F4(c): when inside an explicit `batch()` scope, the
-					// irreversible side effects of `_deactivate()` (dep
-					// unsubscribe + `onDeactivation` fire) MUST be deferred to
-					// `_flushBatchPending` so a batch throw can roll back the
-					// node into a still-live state. The 4 in-tree multi-channel-
-					// atomic-terminate callers (`base/composition/external-
-					// register.ts` x3 + `base/io/sqlite.ts` x1) depend on this
-					// — emitting TEARDOWN inside `batch(fn)` is a supported
-					// pattern. Status mutations (`_status="sentinel"`,
-					// `_teardownDone=true`) stay in `_preBatchSnapshot`'s scope
-					// and roll back via `_rollbackBatchPending`.
-					if (isExplicitlyBatching()) {
-						this._pendingDeactivateAfterBatch = true;
-					} else {
-						this._deactivate(/* skipStatusUpdate */ true);
-					}
-					// TEARDOWN is a hard reset — unconditionally "sentinel",
-					// even if the node was previously completed/errored.
-					this._status = "sentinel";
-					// DS-13.5.A Q16 idempotency: subsequent TEARDOWN deliveries
-					// must not re-fire the synthetic [COMPLETE] auto-prefix.
-					this._teardownDone = true;
-				}
-			}
-		}
-
-		const base: Messages =
-			abortedAt >= 0
-				? ((rewritten ?? (messages.slice(0, abortedAt) as Messages)) as Messages)
-				: (rewritten ?? messages);
-		return equalsError != null ? { finalMessages: base, equalsError } : { finalMessages: base };
-	}
-
-	/**
-	 * @internal Lock 6.G (spec §2.5) — append outgoing DATA payloads from
-	 * `finalMessages` into `_replayBuffer`, dropping oldest on overflow.
-	 * No-op when `_replayBufferCapacity === 0`. RESOLVED entries are NOT
-	 * pushed (only DATA), per spec.
-	 *
-	 * Allocates the buffer lazily on first push so unused-buffer nodes
-	 * (the common case) pay no per-instance allocation cost.
-	 */
-	private _pushReplayBuffer(finalMessages: Messages): void {
-		if (this._replayBufferCapacity === 0) return;
-		for (const m of finalMessages) {
-			if (m[0] !== DATA || m.length < 2) continue;
-			if (this._replayBuffer == null) this._replayBuffer = [];
-			this._replayBuffer.push(m[1] as T);
-			// Drop-oldest on overflow. `shift()` is O(N) but N is the
-			// configured capacity (typical 1–50); for larger N a true ring
-			// buffer with head/tail pointers would beat this — flag in
-			// optimizations.md if a workload demands it.
-			if (this._replayBuffer.length > this._replayBufferCapacity) {
-				this._replayBuffer.shift();
-			}
-		}
-	}
-
-	private _deliverToSinks = (messages: Messages): void => {
-		if (this._sinks == null) return;
-		if (typeof this._sinks === "function") {
-			this._sinks(messages);
-			return;
-		}
-		// Snapshot: a sink callback may unsubscribe itself or others
-		// mid-iteration. Iterating the live Set would skip not-yet-visited
-		// sinks that were removed.
-		const snapshot = [...this._sinks];
-		for (const sink of snapshot) sink(messages);
-	};
-
-	/**
-	 * @internal Dispatch entry point that respects the per-batch emit
-	 * accumulator (Bug 2). Inside an explicit `batch()` scope, append to
-	 * `_batchPendingMessages`. Outside batch — or during a drain (where
-	 * `flushInProgress` is true but `batchDepth` is 0) — dispatch
-	 * synchronously through `downWithBatch`.
-	 *
-	 * The paired flush/rollback hook + `_preBatchSnapshot` are registered
-	 * in `_emit` directly (before `_updateState`), NOT here — this keeps
-	 * the rollback guarantee even when `_updateState` filters all
-	 * messages out (no `finalMessages` left to accumulate but state has
-	 * still potentially mutated).
-	 *
-	 * Per-emit state updates (`_frameBatch`, `_updateState`) have already
-	 * happened by the time we reach here; only the **downstream delivery**
-	 * is coalesced. Cache, version, and status are visible mid-batch on
-	 * the emitting node itself.
-	 */
-	private _dispatchOrAccumulate(messages: Messages): void {
-		if (isExplicitlyBatching()) {
-			if (this._batchPendingMessages === null) this._batchPendingMessages = [];
-			for (const m of messages) this._batchPendingMessages.push(m);
-			return;
-		}
-		downWithBatch(this._deliverToSinks, messages, this._config.tierOf);
-	}
-
-	/**
-	 * @internal Captures the pre-batch observable state and registers the
-	 * paired flush/rollback hook with `batch.ts`. Called at the TOP of
-	 * `_emit` (after the protocol-`undefined` payload check) on first
-	 * state-touch inside an explicit `batch()` scope. /qa F3 hoisted this
-	 * from its prior position before `_updateState` so PAUSE/RESUME lock
-	 * mutations, meta TEARDOWN fan-out, and `_pushReplayBuffer` are all
-	 * downstream of the snapshot.
-	 *
-	 * Snapshot details — see {@link _preBatchSnapshot} for the field-by-
-	 * field rationale and the user-locked "post-rollback observable state
-	 * ≡ pre-batch observable state" invariant.
-	 */
-	private _captureBatchSnapshot(): void {
-		const v = this._versioning;
-		this._preBatchSnapshot = {
-			cached: this._cached,
-			status: this._status,
-			versioning:
-				v == null
-					? undefined
-					: "cid" in v
-						? { version: v.version, cid: v.cid, prev: v.prev }
-						: { version: v.version },
-			hasCalledFnOnce: this._hasCalledFnOnce,
-			teardownDone: this._teardownDone,
-			waveHasNewData: this._waveHasNewData,
-			hasNewTerminal: this._hasNewTerminal,
-			waveHasInvalidate: this._waveHasInvalidate,
-			// /qa F5: shallow content copy, not length. Buffer at-cap with a
-			// mid-batch eviction would otherwise have its head silently lost.
-			replayBuffer: this._replayBuffer == null ? null : [...this._replayBuffer],
-			// /qa F7: latches once per node lifetime — restoring is the
-			// "once per lifetime" semantic when the latch fired only inside
-			// the rolled-back wave.
-			equalsErrorLogged: this._equalsErrorLogged,
-			// /qa F4(c): defer-flag for TEARDOWN-inside-batch.
-			pendingDeactivateAfterBatch: this._pendingDeactivateAfterBatch,
-			// /qa F3: pause sub-snapshot. `null` when pause state was
-			// untouched at capture; otherwise clone the live state so the
-			// PAUSE/RESUME branch at line ~3270 can mutate without
-			// corrupting the snapshot. Capture-by-value of immutable
-			// scalars; clone Set + array; the `_prePauseSnapshot` object
-			// is captured by reference (it's never mutated after capture
-			// — see Lock 2.C semantics at line ~3186).
-			pause:
-				this._pauseLocks == null &&
-				this._pauseBuffer == null &&
-				!this._paused &&
-				this._pauseStartNs === undefined &&
-				this._pauseDroppedCount === 0 &&
-				!this._pauseOverflowed &&
-				this._prePauseSnapshot == null
-					? null
-					: {
-							locks: this._pauseLocks == null ? null : new Set(this._pauseLocks),
-							paused: this._paused,
-							buffer: this._pauseBuffer == null ? null : [...this._pauseBuffer],
-							startNs: this._pauseStartNs,
-							droppedCount: this._pauseDroppedCount,
-							overflowed: this._pauseOverflowed,
-							prePauseSnapshot: this._prePauseSnapshot,
-						},
-		};
-		registerBatchHook({
-			flush: () => this._flushBatchPending(),
-			rollback: () => this._rollbackBatchPending(),
-		});
-	}
-
-	/**
-	 * @internal Flushes the accumulated batch through `downWithBatch` and
-	 * clears the pending state + `_preBatchSnapshot` (single-use per
-	 * batch session). Idempotent — safe to call when pending is already
-	 * null or empty.
-	 *
-	 * Also fires any deferred `_deactivate()` (per /qa F4(c)): TEARDOWN
-	 * inside batch defers the irreversible dep-unsubscribe + `onDeactivation`
-	 * side effects to here, so the rollback path can keep the node alive
-	 * if the batch throws.
-	 *
-	 * Critical: the accumulated batch is interleaved per-emit framings like
-	 * `[DIRTY, DATA(1), DIRTY, DATA(2)]` — non-monotone tier order. We must
-	 * re-frame to sort by tier before handing to `downWithBatch`, which
-	 * assumes pre-sorted input. `_frameBatch` also handles the synthetic
-	 * DIRTY prepend rule (no-op here — `hasDirty` is true since each
-	 * accumulated emit already carries its own DIRTY prefix).
-	 */
-	private _flushBatchPending(): void {
-		const pending = this._batchPendingMessages;
-		const deferredDeactivate = this._pendingDeactivateAfterBatch;
-		this._batchPendingMessages = null;
-		this._preBatchSnapshot = null;
-		this._pendingDeactivateAfterBatch = false;
-		if (pending !== null && pending.length > 0) {
-			const framed = this._frameBatch(pending);
-			downWithBatch(this._deliverToSinks, framed, this._config.tierOf);
-		}
-		// /qa F4(c): fire the deferred `_deactivate` AFTER dispatch so
-		// subscribers see the TEARDOWN wave before deps are unsubscribed.
-		// `skipStatusUpdate=true` mirrors the original synchronous
-		// in-`_updateState` call at line ~3819 — status was already set
-		// to "sentinel" + `_teardownDone=true` mid-batch.
-		if (deferredDeactivate) {
-			this._deactivate(/* skipStatusUpdate */ true);
-		}
-	}
-
-	/**
-	 * @internal D282 R4.3.2 throw-rollback handler. Restores the node to
-	 * its pre-batch observable state from `_preBatchSnapshot` and clears
-	 * `_batchPendingMessages` WITHOUT dispatching to sinks. Converges to
-	 * the Rust substrate's `discard_wave_cleanup` +
-	 * `restore_wave_cache_snapshots` semantic at
-	 * `graphrefly-rs/crates/graphrefly-core/src/batch.rs:3693`.
-	 *
-	 * `_versioning` restore mutates fields in place on the live object
-	 * (object identity is preserved across the batch window — same
-	 * precedent as Lock 2.C `_prePauseSnapshot` restore). Restoring fields
-	 * onto a fresh object would break consumers that captured the
-	 * `_versioning` reference earlier.
-	 *
-	 * /qa F2: V1 `cid`/`prev` restoration is UNCONDITIONAL when the live
-	 * `_versioning` has the V1 shape — restoring only when the snapshot
-	 * value was defined (pre-/qa) would leak newly-set hashes whose
-	 * pre-batch value was `undefined`.
-	 *
-	 * /qa F5: `_replayBuffer` is restored from the shallow content copy
-	 * (not a length truncation) so a mid-batch eviction at capacity
-	 * doesn't silently lose the pre-batch head.
-	 *
-	 * /qa F3: pause state restoration if `snap.pause != null`. Set is
-	 * re-cloned to break aliasing; buffer is replaced (length-and-content);
-	 * `_prePauseSnapshot` reference restored verbatim (Lock 2.C). When
-	 * `snap.pause === null`, the node was guaranteed pause-untouched at
-	 * capture — clear all pause fields defensively in case a mid-batch
-	 * PAUSE mutated them.
-	 *
-	 * /qa F4(c): clears the pending-`_deactivate` flag so the deferred
-	 * TEARDOWN-side-effect never fires. Deps remain subscribed and
-	 * `onDeactivation` is NOT called.
-	 *
-	 * Idempotent — safe to call when `_preBatchSnapshot === null` (no-op).
-	 */
-	private _rollbackBatchPending(): void {
-		const snap = this._preBatchSnapshot;
-		this._batchPendingMessages = null;
-		this._preBatchSnapshot = null;
-		this._pendingDeactivateAfterBatch = false;
-		if (snap === null) return;
-		this._cached = snap.cached;
-		this._status = snap.status;
-		if (snap.versioning != null && this._versioning != null) {
-			// Mutate in place — preserve object identity (same precedent
-			// as the Lock 2.C pre-pause restore at line ~3186).
-			this._versioning.version = snap.versioning.version;
-			if ("cid" in this._versioning) {
-				// /qa F2: unconditional restore. Versioning level cannot
-				// change mid-batch (object identity + level are stable
-				// across the batch window per Lock 2.C), so if `_versioning`
-				// is V1 now, the snapshot captured V1 fields — `cid` and
-				// `prev` are guaranteed non-undefined. The non-null
-				// assertion encodes that class invariant.
-				this._versioning.cid = snap.versioning.cid as string;
-				this._versioning.prev = snap.versioning.prev as string | null;
-			}
-		}
-		this._hasCalledFnOnce = snap.hasCalledFnOnce;
-		this._teardownDone = snap.teardownDone;
-		this._waveHasNewData = snap.waveHasNewData;
-		this._hasNewTerminal = snap.hasNewTerminal;
-		this._waveHasInvalidate = snap.waveHasInvalidate;
-		// /qa F7: restore the once-per-lifetime equals-error log latch.
-		this._equalsErrorLogged = snap.equalsErrorLogged;
-		// /qa F5: restore buffer contents (not just length). Pre-cap
-		// eviction during the batch would otherwise leave the head lost.
-		if (snap.replayBuffer === null) {
-			this._replayBuffer = null;
-		} else {
-			if (this._replayBuffer === null) {
-				this._replayBuffer = [...snap.replayBuffer];
-			} else {
-				this._replayBuffer.length = 0;
-				this._replayBuffer.push(...snap.replayBuffer);
-			}
-		}
-		// /qa F3: restore pause state.
-		if (snap.pause === null) {
-			// Pre-batch the node was pause-untouched. Defensive clear in
-			// case PAUSE/RESUME branches mutated mid-batch.
-			this._pauseLocks = null;
-			this._paused = false;
-			this._pauseBuffer = null;
-			this._pauseStartNs = undefined;
-			this._pauseDroppedCount = 0;
-			this._pauseOverflowed = false;
-			this._prePauseSnapshot = null;
-		} else {
-			this._pauseLocks = snap.pause.locks === null ? null : new Set(snap.pause.locks);
-			this._paused = snap.pause.paused;
-			this._pauseBuffer = snap.pause.buffer === null ? null : [...snap.pause.buffer];
-			this._pauseStartNs = snap.pause.startNs;
-			this._pauseDroppedCount = snap.pause.droppedCount;
-			this._pauseOverflowed = snap.pause.overflowed;
-			this._prePauseSnapshot = snap.pause.prePauseSnapshot;
-		}
-	}
-}
-
-// ---------------------------------------------------------------------------
-// Factory
-// ---------------------------------------------------------------------------
-
-const isNodeArray = (value: unknown): value is readonly Node[] => Array.isArray(value);
-const isNodeOptionsObject = (value: unknown): value is NodeOptions<unknown> =>
-	typeof value === "object" && value != null && !Array.isArray(value);
-
-/**
- * Creates a reactive {@link Node} — the single GraphReFly primitive (§2).
- *
- * Typical shapes:
- * - `node([])` / `node({ initial: v })` — a manual source (state node).
- * - `node(producerFn, opts)` — a producer that runs on first-subscribe.
- * - `node(deps, computeFn, opts)` — a derived / effect node.
- *
- * For value-returning computations, prefer the sugar factories in `sugar.ts`
- * (`state`, `derived`, `effect`, `producer`, `dynamicNode`), which wrap user
- * fns with `actions.emit(userFn(data))`. Calling `node()` directly gives you
- * the raw `NodeFn` contract: explicit emission via `actions`, cleanup return.
- */
-export function node<T = unknown>(
-	depsOrFn?: readonly Node[] | NodeFn | NodeOptions<T>,
-	fnOrOpts?: NodeFn | NodeOptions<T>,
-	optsArg?: NodeOptions<T>,
-): Node<T> {
-	const deps: readonly Node[] = isNodeArray(depsOrFn) ? depsOrFn : [];
-	const fn: NodeFn | undefined =
-		typeof depsOrFn === "function"
-			? depsOrFn
-			: typeof fnOrOpts === "function"
-				? fnOrOpts
-				: undefined;
-	let opts: NodeOptions<T> = {};
-	if (isNodeArray(depsOrFn)) {
-		opts = ((isNodeOptionsObject(fnOrOpts) ? fnOrOpts : optsArg) ?? {}) as NodeOptions<T>;
-	} else if (isNodeOptionsObject(depsOrFn)) {
-		opts = depsOrFn as NodeOptions<T>;
-	} else {
-		opts = ((isNodeOptionsObject(fnOrOpts) ? fnOrOpts : optsArg) ?? {}) as NodeOptions<T>;
-	}
-	return new NodeImpl<T>(deps, fn, opts);
-}
diff --git a/packages/pure-ts/src/core/subscribe-error.ts b/packages/pure-ts/src/core/subscribe-error.ts
deleted file mode 100644
index 1e5ffbc9..00000000
--- a/packages/pure-ts/src/core/subscribe-error.ts
+++ /dev/null
@@ -1,158 +0,0 @@
-/**
- * Thrown by {@link Node.subscribe} when the target node is
- * non-resubscribable AND has terminated (per canonical spec R2.2.7.b,
- * D118 / 2026-05-10). The stream is permanently over; the late
- * subscriber receives no handshake.
- *
- * Operators that subscribe to upstream sources (zip, concat, race,
- * `takeUntil`, mergeMap, switchMap, exhaustMap, concatMap, buffer,
- * throttle, debounce, sample, etc.) MUST handle this rejection by
- * skipping the dead source (e.g., concat advances to the next source;
- * zip self-completes since no tuple can ever form; merge_map decrements
- * its active count). See operator docs for per-operator semantics.
- *
- * Mirrors Rust `SubscribeError::TornDown { node }` for cross-impl parity.
- *
- * @example
- * ```ts
- * import { TornDownError } from "@graphrefly/pure-ts";
- * try {
- *   const unsub = deadNode.subscribe(sink);
- * } catch (e) {
- *   if (e instanceof TornDownError) {
- *     // Source is permanently over; handle per operator semantics.
- *   } else {
- *     throw e;
- *   }
- * }
- * ```
- */
-export class TornDownError extends Error {
-	readonly nodeName: string;
-	readonly status: string;
-
-	constructor(nodeName: string, status: string, message?: string) {
-		super(
-			message ??
-				`subscribe(${nodeName}): node is non-resubscribable and has terminated; the stream is permanently over (R2.2.7.b)`,
-		);
-		this.name = "TornDownError";
-		this.nodeName = nodeName;
-		this.status = status;
-	}
-}
-
-/**
- * Discriminator helper for matching the rejection branch without
- * `instanceof` (useful in minified / cross-realm setups where the
- * `Error` constructor differs across realms).
- */
-export function isTornDownError(err: unknown): err is TornDownError {
-	return (
-		err != null &&
-		typeof err === "object" &&
-		"name" in err &&
-		(err as { name: unknown }).name === "TornDownError"
-	);
-}
-
-/**
- * Outcome of {@link trySubscribeOrDead} — operators that want
- * per-op dead-source semantics inspect this rather than relying on
- * try/catch boilerplate.
- *
- * Mirrors Rust `SubscribeOutcome` for cross-impl parity. Three
- * variants:
- *
- * - `{ kind: "live", unsub }` — sink installed; call `unsub()` to
- *   detach.
- * - `{ kind: "dead", node }` — source is non-resubscribable +
- *   terminal (R2.2.7.b). Sink was NOT installed. Operators should
- *   treat the source as Complete-equivalent for their lifecycle.
- *
- * Note: TS does not have a separate "Deferred" outcome — TS is
- * single-threaded so the Phase H+ ascending-order defer path
- * doesn't apply. The Rust enum's `Deferred` variant has no TS
- * analog.
- */
-export type SubscribeOutcome = { kind: "live"; unsub: () => void } | { kind: "dead"; node: string };
-
-/**
- * Subscribe with R2.2.7.b rejection translated to a typed outcome
- * rather than a thrown {@link TornDownError}. Operators that want
- * Dead-source-aware behavior (zip self-completes, concat advances,
- * race marks completed, take_until self-completes, etc.) match on
- * the outcome instead of using try/catch.
- *
- * @example
- * ```ts
- * import { trySubscribeOrDead } from "@graphrefly/pure-ts";
- *
- * const outcome = trySubscribeOrDead(source, sink);
- * if (outcome.kind === "dead") {
- *   // R2.2.7.b: source is permanently over. Per-op handling
- *   // (e.g., zip self-completes; concat advances; etc.)
- * } else {
- *   // outcome.kind === "live"; sink installed.
- *   subs.push(outcome.unsub);
- * }
- * ```
- */
-export function trySubscribeOrDead<T>(
-	source: { subscribe: (sink: (msgs: readonly unknown[]) => void) => () => void; name?: string },
-	sink: (msgs: readonly T[]) => void,
-): SubscribeOutcome {
-	try {
-		const unsub = source.subscribe(sink as (msgs: readonly unknown[]) => void);
-		return { kind: "live", unsub };
-	} catch (err) {
-		if (isTornDownError(err)) {
-			return { kind: "dead", node: err.nodeName };
-		}
-		throw err;
-	}
-}
-
-/**
- * Convenience helper for operators that want to wrap a subscribe site
- * with R2.2.7.b Dead-source handling but don't want the verbose
- * `match outcome.kind === "dead"` boilerplate.
- *
- * On a live subscribe, returns the unsub function (drop-in
- * replacement for `source.subscribe(sink)`). On a Dead subscribe,
- * invokes `onDead` (per-op semantics — typically
- * `actions.down([[COMPLETE]])` for stream-transforming operators
- * that have nothing to emit when the source is permanently over) and
- * returns a no-op unsub function so the caller's cleanup chain stays
- * uniform.
- *
- * @example
- * ```ts
- * const srcUnsub = subscribeOr(source, (msgs) => {
- *   // normal sink body
- * }, () => {
- *   // Dead source: per-op handling (e.g., self-Complete).
- *   a.down([[COMPLETE]]);
- * });
- * ```
- *
- * @param source - The upstream node.
- * @param sink - Message-handling closure (matches the source's
- *   `subscribe` callback shape).
- * @param onDead - Called when the source rejects with `TornDownError`
- *   (non-resubscribable + terminal). Per-op handlers go here.
- * @returns Unsubscribe function. No-op when source was Dead; the
- *   real `() => void` from `subscribe` otherwise.
- */
-export function subscribeOr<T>(
-	source: { subscribe: (sink: (msgs: readonly unknown[]) => void) => () => void; name?: string },
-	sink: (msgs: readonly T[]) => void,
-	onDead: () => void,
-): () => void {
-	const outcome = trySubscribeOrDead<T>(source, sink);
-	if (outcome.kind === "dead") {
-		onDead();
-		return () => {};
-	}
-	return outcome.unsub;
-}
diff --git a/packages/pure-ts/src/core/sugar.ts b/packages/pure-ts/src/core/sugar.ts
deleted file mode 100644
index 498a5ab2..00000000
--- a/packages/pure-ts/src/core/sugar.ts
+++ /dev/null
@@ -1,283 +0,0 @@
-/**
- * Remaining sugar constructors over the raw `node()` primitive.
- *
- * `state`, `derived`, `effect`, `producer` (and typed variants `derivedT`,
- * `effectT`) have been removed from core. Their equivalents live as
- * restricted-signature methods on `Graph` (see `graph.ts`):
- *   - `graph.state(name, initial?, opts?)`
- *   - `graph.derived(name, depPaths, fn, opts?)`
- *   - `graph.effect(name, depPaths, fn, opts?)`
- *   - `graph.producer(name, setupFn, opts?)`
- *
- * What remains here:
- *   - `dynamicNode` — track-proxy wrapper (no Graph equivalent yet)
- *   - `autoTrackNode` — runtime dep discovery (Jotai/signals compat)
- *   - `pipe` — left-to-right operator composition
- *   - `NodeValues` — tuple-mapped type utility (used by compat layers)
- */
-
-import {
-	type DepRecord,
-	type FnCtx,
-	type Node,
-	type NodeFn,
-	NodeImpl,
-	type NodeOptions,
-	node,
-} from "./node.js";
-
-// ---------------------------------------------------------------------------
-// NodeValues — tuple-mapped type utility
-// ---------------------------------------------------------------------------
-
-/**
- * Maps a tuple of `Node<V>`s to a tuple of `V`s. Used by compat layers
- * and typed APIs to propagate dep value types into callback parameters.
- */
-export type NodeValues<TDeps extends readonly Node<unknown>[]> = {
-	readonly [K in keyof TDeps]: TDeps[K] extends Node<infer V> ? V : never;
-};
-
-// ---------------------------------------------------------------------------
-// dynamicNode — track-proxy wrapper
-// ---------------------------------------------------------------------------
-
-/**
- * Proxy handed to a {@link DynamicFn}. `track(dep)` returns the dep's
- * latest DATA payload, as delivered through the protocol. Reading from
- * `track` does NOT bypass the message protocol — it reads the internal
- * `DepRecord.prevData` (the stable end-of-previous-wave value) that
- * `_onDepMessage` already populated. If a dep has not yet sent DATA,
- * `track` returns `undefined`.
- */
-export type TrackFn = (dep: Node) => unknown;
-
-/** User-level dynamicNode compute. */
-export type DynamicFn<T> = (track: TrackFn, ctx: FnCtx) => T | undefined | null;
-
-/**
- * Exposes dep values via a `track(dep)` proxy instead of positional
- * `data[i]`. All declared `allDeps` participate in wave tracking; unused
- * deps that update just re-run fn, and `equals` absorbs unchanged outputs
- * as RESOLVED.
- *
- * **First-run gate (Lock 6.C′):** `dynamicNode` defaults `partial: true`.
- * fn runs as soon as the wave machinery has any data to compute on; deps
- * that have not yet emitted return `undefined` via `track(dep)`. The fn
- * must handle `undefined` for those deps. Pass `{ partial: false }` to
- * opt into core's first-run gate (spec §2.7) when you need to wait for
- * every declared dep to settle before fn fires.
- *
- * P3-compliant: `track(dep)` reads from the framework-managed
- * `DepRecord.prevData` populated by the protocol, never from
- * `dep.cache`.
- *
- * @example
- * ```ts
- * const a = node<number>([], { initial: 1 });
- * const b = node<number>([], { initial: 10 });
- * const sum = dynamicNode([a, b], (track) => (track(a) as number) + (track(b) as number));
- * ```
- */
-export function dynamicNode<T = unknown>(
-	allDeps: readonly Node[],
-	fn: DynamicFn<T>,
-	opts?: NodeOptions<T> & { partial?: boolean },
-): Node<T> {
-	const depIndex = new Map<Node, number>();
-	allDeps.forEach((d, i) => {
-		depIndex.set(d, i);
-	});
-	const wrapped: NodeFn = (batchData, actions, ctx) => {
-		const data = batchData.map((batch, i) =>
-			batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-		);
-		const track: TrackFn = (dep) => {
-			const i = depIndex.get(dep);
-			if (i == null) {
-				throw new Error(`dynamicNode: untracked dep "${dep.name ?? "<unnamed>"}"`);
-			}
-			return data[i];
-		};
-		actions.emit(fn(track, ctx));
-		return undefined;
-	};
-	// Lock 6.C′ (Phase 13.6.A): `dynamicNode` defaults `partial: true` — the
-	// "selective deps" use case (read whichever subset is relevant for the
-	// current branch) does not fit gate-all-deps semantics. Users can still
-	// pass `partial: false` to opt into the first-run gate.
-	return node<T>(allDeps, wrapped, { describeKind: "derived", partial: true, ...opts });
-}
-
-// ---------------------------------------------------------------------------
-// autoTrackNode — runtime dep discovery (Jotai/signals compat)
-// ---------------------------------------------------------------------------
-
-/**
- * Like {@link dynamicNode} but deps are discovered at runtime via `track()`
- * calls — no upfront `allDeps` array needed. Designed for pull-based compat
- * layers (Jotai atoms, TC39 Signals) where deps are unknown until fn runs.
- *
- * **Two-phase discovery:**
- * 1. fn runs. Each `track(dep)` for an unknown dep: subscribes immediately
- *    via `_addDep`, returns `dep.cache` as a stub (P3 boundary exception).
- *    Result is discarded (discovery run).
- * 2. New deps settle (DATA from subscribe handshake). Wave machinery
- *    re-triggers fn. `track(dep)` now returns protocol-delivered `data[i]`.
- *    If MORE unknown deps appear, repeat step 1.
- * 3. Converges when no new deps found → real run → `actions.emit(result)`.
- *
- * P3 violation is limited to discovery runs. Once all deps are known,
- * subsequent waves use protocol-delivered values exclusively.
- *
- * Re-entrance safety: `_addDep` subscribes immediately. If the dep delivers
- * DATA synchronously during fn execution, `_execFn`'s re-entrance guard
- * defers the re-run to after the current fn returns.
- *
- * @param opts - Optional {@link AutoTrackOptions}. Pass `{ partial: true }` to
- *   allow fn to run before all known deps have delivered their first value
- *   (useful for optional/secondary deps).
- *
- * @example
- * ```ts
- * const a = node<number>([], { initial: 1 });
- * const b = node<number>([], { initial: 2 });
- * const sum = autoTrackNode((track) => track(a) + track(b));
- * // deps [a, b] discovered automatically on first run
- * ```
- */
-/**
- * Options for {@link autoTrackNode}.
- */
-export interface AutoTrackOptions<T> extends NodeOptions<T> {
-	/**
-	 * When `true` (default for `autoTrackNode` per Lock 6.C′), fn may run
-	 * before all known deps have delivered their first DATA. Unknown deps
-	 * return `undefined` via `track()`, which the fn must handle explicitly.
-	 * This matches `autoTrackNode`'s discovery semantics: deps are unknown
-	 * until fn runs, so a gate-all-declared-deps wait would deadlock.
-	 *
-	 * Pass `partial: false` to opt into core's first-run gate (spec §2.7) —
-	 * fn is held until every declared dep has delivered at least one DATA
-	 * value. Useful only for compat layers that pre-declare all deps in
-	 * `opts.deps` (rare). Note: the gate is first-run-only
-	 * (`_hasCalledFnOnce`), so INVALIDATE on a dep does NOT re-gate after fn
-	 * has fired once. Pull-based compat layers (Signals, Jotai) that rely on
-	 * "consistent compute across INVALIDATE" should explicitly wrap their
-	 * dep reads with null/undefined handling in fn.
-	 *
-	 * @default true
-	 */
-	partial?: boolean;
-}
-
-export function autoTrackNode<T = unknown>(
-	fn: (track: TrackFn, ctx: FnCtx) => T | undefined | null,
-	opts?: AutoTrackOptions<T>,
-): Node<T> {
-	let implRef: NodeImpl<T>;
-	// Phase 13.8: cache `Node → DepRecord` (not `Node → index`). Surgical
-	// `_setDeps` may shift kept-deps' positions in `_deps`; the DepRecord
-	// reference is stable across reorders, but a cached numeric index isn't.
-	// At track-time we resolve the current index dynamically via
-	// `_deps.indexOf(record)` — same pattern as the substrate's subscribe
-	// callbacks.
-	const depRecordMap = new Map<Node, DepRecord>();
-
-	const wrappedFn: NodeFn = (batchData, actions, ctx) => {
-		let foundNew = false;
-		const track: TrackFn = (dep) => {
-			const record = depRecordMap.get(dep);
-			if (record !== undefined) {
-				// Known dep — re-resolve the current index. If the dep was
-				// removed via `_setDeps` between waves, `indexOf` returns -1
-				// and we fall back to dep.cache.
-				const idx = implRef._deps.indexOf(record);
-				if (idx !== -1 && idx < batchData.length) {
-					const batch = batchData[idx];
-					if (batch != null && batch.length > 0) return batch.at(-1);
-					return ctx.prevData[idx];
-				}
-				return dep.cache;
-			}
-			// Unknown dep — discovery phase. Use `_addDepInternal` to skip
-			// the public `_addDep` validation guards: autoTrackNode runs from
-			// inside `_execFn` (where `_isExecutingFn === true`), which the
-			// public `_addDep` deliberately rejects.
-			foundNew = true;
-			const newIdx = implRef._addDepInternal(dep);
-			depRecordMap.set(dep, implRef._deps[newIdx]);
-			return dep.cache; // P3 boundary exception (discovery stub)
-		};
-
-		// First-run gate for pre-discovery sentinel deps is now enforced by
-		// core (§2.7, `NodeOptions.partial`). The previous inline
-		// sentinel-on-every-wave guard (which also re-gated on INVALIDATE) was
-		// removed 2026-04-23 to align with the unified gate semantics. Users
-		// who need consistent compute across INVALIDATE should handle
-		// `undefined` / `null` dep values in their fn body — `track()` returns
-		// `ctx.prevData[idx]` which is `undefined` for a just-invalidated dep.
-
-		try {
-			const result = fn(track, ctx);
-			if (!foundNew) {
-				// Real run — all deps known, protocol-delivered values.
-				actions.emit(result);
-				// Clear any stale discovery error from a prior run.
-				if (ctx.store.__autoTrackLastDiscoveryError != null) {
-					delete ctx.store.__autoTrackLastDiscoveryError;
-				}
-			}
-			// Discovery run — result discarded. New deps are subscribed via
-			// _addDep. Their DATA delivery triggers _maybeRunFnOnSettlement
-			// via the _pendingRerun mechanism, which will re-call fn.
-		} catch (err) {
-			if (!foundNew) throw err;
-			// Discovery run threw — most likely a stale `.cache` read (P3
-			// boundary exception), which the protocol-delivered retry will
-			// not hit. Preserve the error on `ctx.store` for inspection; if
-			// the retry succeeds, the flag is cleared above. If fn has a
-			// real bug unrelated to cache, the non-discovery retry will
-			// re-throw it out of `_execFn`.
-			ctx.store.__autoTrackLastDiscoveryError = err;
-		}
-		return undefined;
-	};
-
-	// Lock 6.C′ (Phase 13.6.A): `autoTrackNode` defaults `partial: true` —
-	// runtime dep discovery requires fn to run before deps are known, so a
-	// gate-all-declared-deps semantic doesn't fit. Users can still pass
-	// `partial: false` to opt into the first-run gate (rare; typically only
-	// for compat layers that pre-declare all deps in `opts`).
-	implRef = new NodeImpl<T>([], wrappedFn, {
-		describeKind: "derived",
-		partial: true,
-		...opts,
-	});
-	return implRef;
-}
-
-// ---------------------------------------------------------------------------
-// pipe — left-to-right operator composition
-// ---------------------------------------------------------------------------
-
-/** Unary operator used by {@link pipe}. */
-export type PipeOperator = (n: Node) => Node;
-
-/**
- * Composes unary operators left-to-right; returns the final node.
- *
- * @example
- * ```ts
- * const out = pipe(
- *   source,
- *   (n) => map(n, (x) => x + 1),
- *   (n) => filter(n, (x) => x > 0),
- * );
- * ```
- */
-export function pipe(source: Node, ...ops: PipeOperator[]): Node {
-	let current = source;
-	for (const op of ops) current = op(current);
-	return current;
-}
diff --git a/packages/pure-ts/src/core/versioning.ts b/packages/pure-ts/src/core/versioning.ts
deleted file mode 100644
index b0d87e0c..00000000
--- a/packages/pure-ts/src/core/versioning.ts
+++ /dev/null
@@ -1,297 +0,0 @@
-/**
- * Node versioning — GRAPHREFLY-SPEC §7.
- *
- * Progressive, optional versioning for node identity and change tracking.
- *
- * - **V0**: `id` + `version` — identity & change detection (~16 bytes overhead)
- * - **V1**: + `cid` + `prev` — content addressing & linked history (~60 bytes overhead)
- *
- * **Lifecycle notes:**
- * - Version advances only on DATA (not RESOLVED, INVALIDATE, or TEARDOWN).
- * - `resetOnTeardown` clears the cached value but does NOT reset versioning state.
- *   After teardown, `v.cid` still reflects the last DATA value, not the cleared cache.
- *   The invariant `hash(node.cache) === v.cid` only holds in `settled`/`resolved` status.
- * - Resubscribable nodes preserve versioning across subscription lifetimes (monotonic counter).
- */
-
-// Runtime-agnostic — no `node:crypto` import. `randomUUID` comes from Web
-// Crypto (`globalThis.crypto.randomUUID()`), available in Node 14.17+,
-// browsers, Deno, Bun, and Cloudflare Workers. The default content hash is a
-// vendored sync SHA-256 (see `sha256Hex` below) so versioning stays callable
-// from any runtime — `crypto.subtle.digest` is async and can't back a
-// synchronous `defaultHash`.
-
-// ---------------------------------------------------------------------------
-// Types
-// ---------------------------------------------------------------------------
-
-/** V0: identity + monotonic version counter. */
-export type V0 = {
-	readonly id: string;
-	version: number;
-};
-
-/** V1: V0 + content-addressed identifier + previous cid link. */
-export type V1 = V0 & {
-	cid: string;
-	prev: string | null;
-};
-
-/** Union of all versioning info shapes. */
-export type NodeVersionInfo = V0 | V1;
-
-/** Supported versioning levels (extensible to 2, 3 later). */
-export type VersioningLevel = 0 | 1;
-
-/** Function that hashes a value to a hex string (for V1 cid). */
-export type HashFn = (value: unknown) => string;
-
-// ---------------------------------------------------------------------------
-// Options
-// ---------------------------------------------------------------------------
-
-export interface VersioningOptions {
-	/** Override auto-generated id. */
-	id?: string;
-	/** Custom hash function for V1 cid (default: SHA-256 truncated to 16 hex chars). */
-	hash?: HashFn;
-}
-
-// ---------------------------------------------------------------------------
-// Default hash
-// ---------------------------------------------------------------------------
-
-/**
- * Canonicalize a value for deterministic cross-language hashing.
- *
- * - Integer-valued floats normalize to integer strings (`1.0` → `1`).
- * - `NaN`, `Infinity`, `-Infinity` are rejected (no JSON equivalent).
- * - `undefined` normalizes to `null`.
- * - Object keys are sorted lexicographically.
- *
- * This ensures TS `JSON.stringify` and Python `json.dumps(sort_keys=True)`
- * produce identical output for the same logical value.
- */
-export function canonicalizeForHash(value: unknown): unknown {
-	if (value === undefined) return null;
-	if (typeof value === "number") {
-		if (!Number.isFinite(value)) {
-			throw new TypeError(`Cannot hash non-finite number: ${value}`);
-		}
-		if (Number.isInteger(value) && !Number.isSafeInteger(value)) {
-			throw new TypeError(
-				`Cannot hash integer outside safe range (|n| > 2^53-1): ${value}. ` +
-					"Cross-language cid parity is not guaranteed for unsafe integers.",
-			);
-		}
-		return value;
-	}
-	if (typeof value === "string" || typeof value === "boolean" || value === null) {
-		return value;
-	}
-	if (Array.isArray(value)) {
-		return value.map(canonicalizeForHash);
-	}
-	if (typeof value === "object" && value !== null) {
-		const sorted: Record<string, unknown> = {};
-		for (const k of Object.keys(value as Record<string, unknown>).sort()) {
-			sorted[k] = canonicalizeForHash((value as Record<string, unknown>)[k]);
-		}
-		return sorted;
-	}
-	// Fallback: coerce to null (bigint, symbol, function)
-	return null;
-}
-
-// SHA-256 round constants (FIPS 180-4).
-const SHA256_K = /* @__PURE__ */ new Uint32Array([
-	0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
-	0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
-	0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
-	0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
-	0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
-	0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
-	0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
-	0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2,
-]);
-
-const UTF8_ENCODER = /* @__PURE__ */ new TextEncoder();
-
-/**
- * Sync SHA-256 of a UTF-8 string, returned as a lowercase hex digest. Matches
- * Node `crypto.createHash("sha256").update(msg).digest("hex")` byte-for-byte.
- *
- * Runtime-agnostic (no `node:crypto`, no `crypto.subtle`). Small enough to
- * inline rather than pulling a dependency; called only from `defaultHash`,
- * which runs once per DATA on versioned nodes, so per-call allocation is
- * acceptable. Callers that need a faster path override via
- * `NodeOptions.versioningHash`.
- */
-function sha256Hex(msg: string): string {
-	const bytes = UTF8_ENCODER.encode(msg);
-	const msgLen = bytes.length;
-	const bitLen = msgLen * 8;
-	// Pad to multiple of 64: 0x80 byte + zeros + 8-byte big-endian bit length.
-	const totalLen = (msgLen + 9 + 63) & ~63;
-	const padded = new Uint8Array(totalLen);
-	padded.set(bytes);
-	padded[msgLen] = 0x80;
-	const dv = new DataView(padded.buffer);
-	// Bit length as big-endian 64-bit int. JS numbers are 53-bit safe, so we
-	// split into two 32-bit halves; messages up to 2^53 bits are supported.
-	dv.setUint32(totalLen - 4, bitLen >>> 0, false);
-	dv.setUint32(totalLen - 8, Math.floor(bitLen / 0x100000000) >>> 0, false);
-
-	// Initial hash values (first 32 bits of fractional parts of sqrt of first 8 primes).
-	let h0 = 0x6a09e667;
-	let h1 = 0xbb67ae85;
-	let h2 = 0x3c6ef372;
-	let h3 = 0xa54ff53a;
-	let h4 = 0x510e527f;
-	let h5 = 0x9b05688c;
-	let h6 = 0x1f83d9ab;
-	let h7 = 0x5be0cd19;
-
-	const W = new Uint32Array(64);
-	const rotr = (x: number, n: number): number => (x >>> n) | (x << (32 - n));
-
-	for (let off = 0; off < totalLen; off += 64) {
-		for (let i = 0; i < 16; i++) W[i] = dv.getUint32(off + i * 4, false);
-		for (let i = 16; i < 64; i++) {
-			const w15 = W[i - 15];
-			const w2 = W[i - 2];
-			const s0 = rotr(w15, 7) ^ rotr(w15, 18) ^ (w15 >>> 3);
-			const s1 = rotr(w2, 17) ^ rotr(w2, 19) ^ (w2 >>> 10);
-			W[i] = (W[i - 16] + s0 + W[i - 7] + s1) >>> 0;
-		}
-
-		let a = h0;
-		let b = h1;
-		let c = h2;
-		let d = h3;
-		let e = h4;
-		let f = h5;
-		let g = h6;
-		let h = h7;
-
-		for (let i = 0; i < 64; i++) {
-			const S1 = rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25);
-			const ch = (e & f) ^ (~e & g);
-			const t1 = (h + S1 + ch + SHA256_K[i] + W[i]) >>> 0;
-			const S0 = rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22);
-			const mj = (a & b) ^ (a & c) ^ (b & c);
-			const t2 = (S0 + mj) >>> 0;
-			h = g;
-			g = f;
-			f = e;
-			e = (d + t1) >>> 0;
-			d = c;
-			c = b;
-			b = a;
-			a = (t1 + t2) >>> 0;
-		}
-
-		h0 = (h0 + a) >>> 0;
-		h1 = (h1 + b) >>> 0;
-		h2 = (h2 + c) >>> 0;
-		h3 = (h3 + d) >>> 0;
-		h4 = (h4 + e) >>> 0;
-		h5 = (h5 + f) >>> 0;
-		h6 = (h6 + g) >>> 0;
-		h7 = (h7 + h) >>> 0;
-	}
-
-	const toHex = (x: number): string => x.toString(16).padStart(8, "0");
-	return (
-		toHex(h0) + toHex(h1) + toHex(h2) + toHex(h3) + toHex(h4) + toHex(h5) + toHex(h6) + toHex(h7)
-	);
-}
-
-/**
- * Default content hash: SHA-256 of deterministic JSON, truncated to 16 hex
- * chars (~64-bit). Uses {@link canonicalizeForHash} for cross-language parity
- * with Python `default_hash`.
- */
-export function defaultHash(value: unknown): string {
-	const canonical = canonicalizeForHash(value ?? null);
-	const json = JSON.stringify(canonical);
-	return sha256Hex(json).slice(0, 16);
-}
-
-/**
- * Cross-runtime UUID generator. Uses Web Crypto (`globalThis.crypto.randomUUID`)
- * when available. Falls back to a tiny `Math.random`-seeded RFC 4122 v4
- * generator for environments that omit `crypto.randomUUID` — identity only,
- * not cryptographic.
- */
-function randomUuid(): string {
-	const c = (globalThis as { crypto?: { randomUUID?: () => string } }).crypto;
-	if (c?.randomUUID) return c.randomUUID();
-	// Fallback (extremely rare — only hits on very old runtimes that expose no
-	// Web Crypto at all). Not cryptographically strong.
-	const r = () =>
-		Math.floor(Math.random() * 0x100000000)
-			.toString(16)
-			.padStart(8, "0");
-	const hex = r() + r() + r() + r();
-	return (
-		`${hex.slice(0, 8)}-${hex.slice(8, 12)}-4${hex.slice(13, 16)}-` +
-		`${((parseInt(hex.slice(16, 17), 16) & 0x3) | 0x8).toString(16)}${hex.slice(17, 20)}-${hex.slice(20, 32)}`
-	);
-}
-
-// ---------------------------------------------------------------------------
-// Factory
-// ---------------------------------------------------------------------------
-
-/**
- * Create initial versioning state for a node.
- *
- * @param level - 0 for V0, 1 for V1.
- * @param initialValue - The node's initial cached value (used for V1 cid).
- * @param opts - Optional overrides (id, hash).
- */
-export function createVersioning(
-	level: VersioningLevel,
-	initialValue: unknown,
-	opts?: VersioningOptions,
-): NodeVersionInfo {
-	const id = opts?.id ?? randomUuid();
-	if (level === 0) {
-		return { id, version: 0 } satisfies V0;
-	}
-	const hash = opts?.hash ?? defaultHash;
-	const cid = hash(initialValue);
-	return { id, version: 0, cid, prev: null } satisfies V1;
-}
-
-// ---------------------------------------------------------------------------
-// Advance
-// ---------------------------------------------------------------------------
-
-/**
- * Advance versioning state after a DATA emission (value changed).
- *
- * Mutates `info` in place for performance (called on every DATA).
- * Only call when the cached value has actually changed (not on RESOLVED).
- *
- * @param info - The node's current versioning state.
- * @param newValue - The new cached value.
- * @param hashFn - Hash function (only used for V1).
- */
-export function advanceVersion(info: NodeVersionInfo, newValue: unknown, hashFn: HashFn): void {
-	info.version += 1;
-	if ("cid" in info) {
-		(info as V1).prev = (info as V1).cid;
-		(info as V1).cid = hashFn(newValue);
-	}
-}
-
-// ---------------------------------------------------------------------------
-// Guards
-// ---------------------------------------------------------------------------
-
-/** Type guard: is this V1 versioning info? */
-export function isV1(info: NodeVersionInfo): info is V1 {
-	return "cid" in info;
-}
diff --git a/packages/pure-ts/src/extra/browser.ts b/packages/pure-ts/src/extra/browser.ts
deleted file mode 100644
index 08581939..00000000
--- a/packages/pure-ts/src/extra/browser.ts
+++ /dev/null
@@ -1,21 +0,0 @@
-/**
- * Browser-only barrel for the extra substrate surface.
- *
- * Consumers that need DOM-bound storage (`indexedDbKv`) import
- * from `@graphrefly/pure-ts/extra/browser`. The universal
- * `@graphrefly/pure-ts/extra` entry stays DOM-free.
- *
- * Presentation-layer browser sources (fromEvent, fromRaf, fromIDBRequest,
- * fromIDBTransaction) are in `@graphrefly/graphrefly/extra/browser`
- * (root shim), not here.
- *
- * @module
- */
-
-export {
-	type IndexedDbBackendSpec,
-	indexedDbAppendLog,
-	indexedDbBackend,
-	indexedDbKv,
-	indexedDbSnapshot,
-} from "./storage/tiers-browser.js";
diff --git a/packages/pure-ts/src/extra/composition/index.ts b/packages/pure-ts/src/extra/composition/index.ts
deleted file mode 100644
index 415f6846..00000000
--- a/packages/pure-ts/src/extra/composition/index.ts
+++ /dev/null
@@ -1,20 +0,0 @@
-/**
- * Composition barrel — substrate-only composition helpers (cleave A2+A3, 2026-05-14).
- *
- * After the cleave, only substrate composition helpers remain here:
- * - stratify (reactive branch routing)
- * - topology-diff (pure structural diff over GraphDescribeOutput)
- *
- * Presentation helpers (verifiable, distill, pubsub, backpressure, composite,
- * externalProducer, materialize, observable, audited-success-tracker) moved to
- * root src/base/composition/. pubsub was confirmed presentation-only (no
- * substrate core/graph dependency) and moved in A3.
- */
-
-export * from "./stratify.js";
-export type {
-	DescribeChangeset,
-	DescribeEvent,
-	Meta as DescribeNodeMeta,
-} from "./topology-diff.js";
-export { topologyDiff } from "./topology-diff.js";
diff --git a/packages/pure-ts/src/extra/composition/stratify.ts b/packages/pure-ts/src/extra/composition/stratify.ts
deleted file mode 100644
index 5eecafdc..00000000
--- a/packages/pure-ts/src/extra/composition/stratify.ts
+++ /dev/null
@@ -1,270 +0,0 @@
-/**
- * stratify — reactive branch routing over a classifier rule set.
- *
- * Protocol-level primitive (no domain assumptions) that routes a source value
- * to independent branch subgraphs. Rules are reactive — update the `"rules"`
- * state node to rewrite classification at runtime. Rule updates affect
- * **future items only** (streaming semantics, not retroactive).
- *
- * @module
- */
-
-import type { NodeActions } from "../../core/config.js";
-import {
-	COMPLETE,
-	DATA,
-	DIRTY,
-	ERROR,
-	type Message,
-	RESOLVED,
-	TEARDOWN,
-} from "../../core/messages.js";
-import { factoryTag } from "../../core/meta.js";
-import { type Node, type NodeOptions, node } from "../../core/node.js";
-import { Graph, type GraphOptions } from "../../graph/graph.js";
-
-/** A single routing rule for {@link stratify}. */
-export type StratifyRule<T> = {
-	/** Branch name (used as node name under `branch/<name>`). */
-	name: string;
-	/** Classifier: returns `true` if the value belongs to this branch. */
-	classify: (value: T) => boolean;
-	/** Optional operator chain applied to the branch after classification. */
-	ops?: (n: Node<T>) => Node;
-};
-
-/** Options for {@link stratify}. */
-export type StratifyOptions = GraphOptions & {
-	meta?: Record<string, unknown>;
-};
-
-/**
- * Route input to different branches based on classifier functions.
- *
- * Each branch gets an independent operator chain. Branch nodes are structural —
- * created at construction time and persist for the graph's lifetime. If a rule
- * name is removed from the rules array, the corresponding branch silently
- * drops items (classifier not found). To tear down a dead branch, call
- * `graph.remove("branch/<name>")`.
- *
- * @param name - Graph name.
- * @param source - Input node (registered as `"source"`).
- * @param rules - Initial routing rules.
- * @param opts - Optional graph/meta options.
- * @returns Graph with `"source"`, `"rules"`, and `"branch/<name>"` nodes.
- *
- * @category extra
- */
-export function stratify<T>(
-	name: string,
-	source: Node<T>,
-	rules: ReadonlyArray<StratifyRule<T>>,
-	opts?: StratifyOptions,
-): Graph {
-	const g = new Graph(name, opts);
-
-	// C3 — wrap the foreign source in a local proxy derived. The proxy is
-	// owned by `g`; downstream branches subscribe to the proxy (not the
-	// foreign Node) so the cross-graph ownership invariant holds. The proxy
-	// also keeps `describe(g)` self-contained: the source path resolves
-	// inside `g` while the dep edge preserves the causal chain back to the
-	// foreign source.
-	const sourceProxy = node<T>(
-		[source as Node<unknown>],
-		(batchData, actions) => {
-			const batch0 = batchData[0];
-			if (batch0 == null || batch0.length === 0) return;
-			for (const v of batch0) actions.emit(v as T);
-		},
-		{
-			describeKind: "derived",
-			meta: factoryTag("proxy"),
-		},
-	);
-	g.add(sourceProxy as Node<unknown>, { name: "source" });
-	const rulesNode = node<ReadonlyArray<StratifyRule<T>>>([], {
-		initial: rules,
-		meta: { kind: "stratify_rules" },
-	});
-	g.add(rulesNode as Node<unknown>, { name: "rules" });
-
-	for (const rule of rules) {
-		_addBranch(g, sourceProxy, rulesNode, rule);
-	}
-
-	return g;
-}
-
-/**
- * Substrate operator: per-branch routing under a reactive rules cache.
- *
- * Internally used by {@link stratify} to construct one routing
- * operator per rule, with a closure that captures the rule name +
- * predicate. Exposed as a public substrate function so the Rust port
- * (`graphrefly_operators::stratify_branch`, D199 of
- * `archive/docs/SESSION-rust-port-layer-boundary.md`) has a cross-impl
- * parity surface — both substrate impls (`@graphrefly/pure-ts` and
- * `@graphrefly/native`) implement the same shape.
- *
- * Semantics:
- * - Subscribes to BOTH `source` and `rules`.
- * - `rules` DATA: caches the rules value (no downstream emission —
- *   "future items only").
- * - `source` DATA: invokes `classifier(rules, value)`. If `true`,
- *   emits `value`; if `false`, drops silently. Throws are caught and
- *   treated as `false`.
- * - `source` COMPLETE / ERROR / TEARDOWN: forwarded.
- * - `rules` COMPLETE / ERROR / TEARDOWN: silently absorbed (branch
- *   keeps its last-seen rules cache).
- * - Two-dep gating: DIRTY from either dep is buffered until both
- *   settle in the same wave, eliminating the stale-rules race when
- *   both update inside the same `batch()`.
- *
- * @category extra
- */
-export function stratifyBranch<T, R>(
-	source: Node<T>,
-	rules: Node<R>,
-	classifier: (rules: R, value: T) => boolean,
-	opts?: { branchMeta?: Record<string, unknown> },
-): Node<T> {
-	const _noValue: unique symbol = Symbol("noValue");
-	let sourceDirty = false;
-	let rulesDirty = false;
-	let sourcePhase2 = false;
-	let sourceValue: T | typeof _noValue = _noValue;
-	let pendingDirty = false;
-	let latestRules: R | typeof _noValue =
-		(rules.cache as R | undefined) === undefined ? _noValue : (rules.cache as R);
-
-	function resolve(actions: NodeActions): void {
-		if (sourcePhase2) {
-			sourcePhase2 = false;
-			const value = sourceValue;
-			sourceValue = _noValue;
-			if (value !== _noValue) {
-				let matches = false;
-				if (latestRules !== _noValue) {
-					try {
-						matches = classifier(latestRules as R, value);
-					} catch {
-						matches = false;
-					}
-				}
-				if (matches) {
-					pendingDirty = false;
-					actions.emit(value);
-				} else if (pendingDirty) {
-					pendingDirty = false;
-					actions.down([[DIRTY], [RESOLVED]]);
-				}
-			} else if (pendingDirty) {
-				pendingDirty = false;
-				actions.down([[DIRTY], [RESOLVED]]);
-			} else {
-				actions.down([[RESOLVED]]);
-			}
-		}
-	}
-
-	function handle(msg: Message, depIndex: number, actions: NodeActions): boolean {
-		const t = msg[0];
-
-		if (t === DIRTY) {
-			if (depIndex === 0) {
-				sourceDirty = true;
-				pendingDirty = true;
-			} else {
-				rulesDirty = true;
-			}
-			return true;
-		}
-
-		if (t === DATA || t === RESOLVED) {
-			if (depIndex === 0) {
-				sourceDirty = false;
-				sourcePhase2 = true;
-				sourceValue = t === DATA ? (msg[1] as T) : _noValue;
-			} else {
-				if (t === DATA) {
-					latestRules = msg[1] as R;
-				}
-				rulesDirty = false;
-			}
-
-			if (sourceDirty || rulesDirty) return true;
-
-			resolve(actions);
-			return true;
-		}
-
-		if (t === COMPLETE || t === ERROR || t === TEARDOWN) {
-			sourceDirty = false;
-			rulesDirty = false;
-			sourcePhase2 = false;
-			sourceValue = _noValue;
-			pendingDirty = false;
-			if (depIndex === 0) {
-				actions.down([msg]);
-			}
-			return true;
-		}
-
-		if (depIndex === 1) return true;
-
-		return false;
-	}
-
-	return node<T>(
-		[],
-		(_data, filterActions) => {
-			const srcUnsub = (source as Node).subscribe((msgs) => {
-				for (const msg of msgs) {
-					handle(msg, 0, filterActions);
-				}
-			});
-			const rulesUnsub = (rules as Node).subscribe((msgs) => {
-				for (const msg of msgs) {
-					handle(msg, 1, filterActions);
-				}
-			});
-			return {
-				onDeactivation: () => {
-					srcUnsub();
-					rulesUnsub();
-				},
-			};
-		},
-		{
-			describeKind: "derived",
-			meta: { kind: "stratify_branch", ...(opts?.branchMeta ?? {}) },
-			completeWhenDepsComplete: false,
-		} as NodeOptions<T>,
-	);
-}
-
-function _addBranch<T>(
-	graph: Graph,
-	source: Node<T>,
-	rulesNode: Node<ReadonlyArray<StratifyRule<T>>>,
-	rule: StratifyRule<T>,
-): void {
-	const branchName = `branch/${rule.name}`;
-	const filterNode = stratifyBranch(
-		source,
-		rulesNode,
-		(rules, value) => {
-			const current = rules.find((r) => r.name === rule.name);
-			return current?.classify(value) ?? false;
-		},
-		{ branchMeta: { branch: rule.name } },
-	);
-
-	graph.add(filterNode as Node<unknown>, { name: branchName });
-
-	if (rule.ops) {
-		const transformed = rule.ops(filterNode);
-		const transformedName = `branch/${rule.name}/out`;
-		graph.add(transformed as Node<unknown>, { name: transformedName });
-	}
-}
diff --git a/packages/pure-ts/src/extra/composition/topology-diff.ts b/packages/pure-ts/src/extra/composition/topology-diff.ts
deleted file mode 100644
index 1baac151..00000000
--- a/packages/pure-ts/src/extra/composition/topology-diff.ts
+++ /dev/null
@@ -1,200 +0,0 @@
-/**
- * Pure structural diff over `GraphDescribeOutput` snapshots.
- *
- * Produces a {@link DescribeChangeset} of {@link DescribeEvent}s describing the
- * topology delta from `prev` → `next`. Used by `Graph.describe({ reactive:
- * "diff" })` internally and re-exported here for static-snapshot diffing
- * (e.g. computing the topology delta between two persisted snapshots without
- * spinning up a live graph).
- *
- * Topology-only — no value/state events. The data layer lives in
- * `Graph.observe`. Per Tier 1.5.1 (locked Session A.1), `DescribeEvent` and
- * {@link ObserveEvent} have disjoint type sets so a consumer can route both
- * streams without ambiguity.
- *
- * `flushedAt_ns` is taken from `core/clock.ts`'s `monotonicNs()` so callers can
- * order changesets across the same process without wall-clock skew.
- *
- * @module
- */
-
-import { monotonicNs } from "../../core/clock.js";
-import type { DescribeNodeOutput } from "../../core/meta.js";
-import type { GraphDescribeOutput } from "../../graph/graph.js";
-
-/**
- * Meta dictionary attached to a node, as surfaced by
- * {@link DescribeNodeOutput.meta}. Aliased here so {@link DescribeEvent}'s
- * `node-meta-changed` variant has a stable, narrow type.
- */
-export type Meta = Record<string, unknown>;
-
-/**
- * One topology delta between two `describe()` snapshots. Disjoint from
- * `ObserveEvent` (the data-layer envelope).
- */
-export type DescribeEvent =
-	| { type: "node-added"; path: string; node: DescribeNodeOutput }
-	| { type: "node-removed"; path: string }
-	| { type: "node-meta-changed"; path: string; prevMeta: Meta; nextMeta: Meta }
-	| { type: "edge-added"; from: string; to: string }
-	| { type: "edge-removed"; from: string; to: string }
-	| { type: "subgraph-mounted"; path: string }
-	| { type: "subgraph-unmounted"; path: string };
-
-/**
- * Coalesced batch of {@link DescribeEvent}s emitted as a single DATA wave by
- * `Graph.describe({ reactive: "diff" })` per outermost batch flush.
- *
- * `flushedAt_ns` is monotonic (from `core/clock.ts`); compare against another
- * changeset's `flushedAt_ns` to order them. `events` is empty only when
- * `topologyDiff` is called with two structurally identical snapshots; reactive
- * variants suppress empty changesets so consumers don't see no-op DATA waves.
- */
-export type DescribeChangeset = {
-	events: ReadonlyArray<DescribeEvent>;
-	flushedAt_ns: number;
-};
-
-/**
- * Structural deep equality, scoped to plain JSON-shaped `meta` values.
- *
- * `meta` dictionaries from `describe()` are JSON-shaped per spec Appendix B
- * (string keys, JSON values). Cycles, BigInt, Map/Set/Date/RegExp do not
- * appear in normalized describe output, so this small walker is sufficient
- * here — the heavier `deepEqual` in `graph.ts` (used by `Graph.diff` over raw
- * node values) is not needed for the meta-changed comparison.
- *
- * Identical references short-circuit; nulls + primitives use `Object.is` so
- * `NaN === NaN` and `-0 !== 0`. Arrays are order-sensitive.
- */
-function metaEqual(a: unknown, b: unknown): boolean {
-	if (Object.is(a, b)) return true;
-	if (a == null || b == null || typeof a !== "object" || typeof b !== "object") return false;
-	if (Array.isArray(a)) {
-		if (!Array.isArray(b) || a.length !== b.length) return false;
-		for (let i = 0; i < a.length; i++) {
-			if (!metaEqual(a[i], b[i])) return false;
-		}
-		return true;
-	}
-	if (Array.isArray(b)) return false;
-	const ka = Object.keys(a as Record<string, unknown>);
-	const kb = Object.keys(b as Record<string, unknown>);
-	if (ka.length !== kb.length) return false;
-	const seen = new Set(kb);
-	for (const k of ka) {
-		if (!seen.has(k)) return false;
-		if (!metaEqual((a as Record<string, unknown>)[k], (b as Record<string, unknown>)[k])) {
-			return false;
-		}
-	}
-	return true;
-}
-
-function edgeKey(from: string, to: string): string {
-	return `${from} ${to}`;
-}
-
-/**
- * Pure topology delta from `prev` → `next`. No I/O, no node references — purely
- * over the JSON shape `Graph.describe()` returns.
- *
- * Event ordering within a changeset:
- *   1. `subgraph-mounted` (added subgraphs first — their nodes follow)
- *   2. `node-added`
- *   3. `node-meta-changed`
- *   4. `edge-added`
- *   5. `edge-removed`
- *   6. `node-removed`
- *   7. `subgraph-unmounted` (last — node removals already reported)
- *
- * Each group is emitted in code-point sort order on the path / `${from}->${to}`
- * key so the changeset is deterministic across runs (useful for snapshot
- * tests and golden-output assertions).
- */
-export function topologyDiff(
-	prev: GraphDescribeOutput,
-	next: GraphDescribeOutput,
-): DescribeChangeset {
-	const events: DescribeEvent[] = [];
-
-	const prevSubgraphs = new Set(prev.subgraphs);
-	const nextSubgraphs = new Set(next.subgraphs);
-
-	// 1. Subgraph mounts (sorted).
-	const mounted: string[] = [];
-	for (const sg of nextSubgraphs) if (!prevSubgraphs.has(sg)) mounted.push(sg);
-	mounted.sort();
-	for (const path of mounted) events.push({ type: "subgraph-mounted", path });
-
-	const prevNodeKeys = new Set(Object.keys(prev.nodes));
-	const nextNodeKeys = new Set(Object.keys(next.nodes));
-
-	// 2. Node adds (sorted).
-	const added: string[] = [];
-	for (const k of nextNodeKeys) if (!prevNodeKeys.has(k)) added.push(k);
-	added.sort();
-	for (const path of added) {
-		// QA F11: shallow copy of the node entry so a downstream consumer
-		// mutating `next.nodes[path]` (or the producer reusing the snapshot)
-		// can't tear the changeset's payload. Comment previously claimed
-		// defensive copy but was a reference assignment.
-		events.push({ type: "node-added", path, node: { ...next.nodes[path]! } });
-	}
-
-	// 3. Meta changes on still-present nodes (sorted).
-	const metaChanged: string[] = [];
-	for (const k of nextNodeKeys) {
-		if (!prevNodeKeys.has(k)) continue;
-		const prevMeta = prev.nodes[k]?.meta;
-		const nextMeta = next.nodes[k]?.meta;
-		// Treat absent meta as `{}` so a `meta: { x: 1 }` → `meta: undefined`
-		// transition still surfaces a change. Both undefined → no event.
-		if (prevMeta == null && nextMeta == null) continue;
-		if (!metaEqual(prevMeta ?? {}, nextMeta ?? {})) metaChanged.push(k);
-	}
-	metaChanged.sort();
-	for (const path of metaChanged) {
-		events.push({
-			type: "node-meta-changed",
-			path,
-			prevMeta: (prev.nodes[path]?.meta ?? {}) as Meta,
-			nextMeta: (next.nodes[path]?.meta ?? {}) as Meta,
-		});
-	}
-
-	// 4 + 5. Edges. Compare on `${from}\0${to}` keys.
-	const prevEdges = new Map<string, { from: string; to: string }>();
-	for (const e of prev.edges) prevEdges.set(edgeKey(e.from, e.to), e);
-	const nextEdges = new Map<string, { from: string; to: string }>();
-	for (const e of next.edges) nextEdges.set(edgeKey(e.from, e.to), e);
-
-	const edgeAdds: Array<{ from: string; to: string }> = [];
-	for (const [k, e] of nextEdges) if (!prevEdges.has(k)) edgeAdds.push(e);
-	edgeAdds.sort((a, b) =>
-		a.from < b.from ? -1 : a.from > b.from ? 1 : a.to < b.to ? -1 : a.to > b.to ? 1 : 0,
-	);
-	for (const e of edgeAdds) events.push({ type: "edge-added", from: e.from, to: e.to });
-
-	const edgeRemoves: Array<{ from: string; to: string }> = [];
-	for (const [k, e] of prevEdges) if (!nextEdges.has(k)) edgeRemoves.push(e);
-	edgeRemoves.sort((a, b) =>
-		a.from < b.from ? -1 : a.from > b.from ? 1 : a.to < b.to ? -1 : a.to > b.to ? 1 : 0,
-	);
-	for (const e of edgeRemoves) events.push({ type: "edge-removed", from: e.from, to: e.to });
-
-	// 6. Node removes (sorted).
-	const removed: string[] = [];
-	for (const k of prevNodeKeys) if (!nextNodeKeys.has(k)) removed.push(k);
-	removed.sort();
-	for (const path of removed) events.push({ type: "node-removed", path });
-
-	// 7. Subgraph unmounts (sorted).
-	const unmounted: string[] = [];
-	for (const sg of prevSubgraphs) if (!nextSubgraphs.has(sg)) unmounted.push(sg);
-	unmounted.sort();
-	for (const path of unmounted) events.push({ type: "subgraph-unmounted", path });
-
-	return { events, flushedAt_ns: monotonicNs() };
-}
diff --git a/packages/pure-ts/src/extra/data-structures/change.ts b/packages/pure-ts/src/extra/data-structures/change.ts
deleted file mode 100644
index 0a8d3f73..00000000
--- a/packages/pure-ts/src/extra/data-structures/change.ts
+++ /dev/null
@@ -1,177 +0,0 @@
-/**
- * Universal change envelope (Phase 14 — DS-14 locked 2026-05-05).
- *
- * Two-level discriminant: envelope-level `structure` for cross-structure
- * narrowing; payload-level `kind` for per-structure verb narrowing.
- *
- * @module
- */
-
-import type { DescribeNodeOutput } from "../../core/meta.js";
-
-// ── Universal envelope ──────────────────────────────────────────────────────
-
-/**
- * Universal change envelope. Every reactive primitive's delta log emits
- * records conforming to this shape.
- *
- * - `structure` — open string namespace per structure variant.
- * - `version` — monotonic identity. `number` for V0 (counter); `string` for
- *   V1+ (cid). Mixed-type unions are user-resolved.
- * - `t_ns` — wall-clock at mutation entry (wallClockNs()).
- * - `seq` — optional cursor seq for joining with audit logs.
- * - `lifecycle` — scope discriminant for diff-restore boundary safety.
- * - `change` — structure-specific delta payload (discriminated by `kind`).
- */
-export interface BaseChange<T> {
-	readonly structure: string;
-	readonly version: number | string;
-	readonly t_ns: number;
-	readonly seq?: number;
-	readonly lifecycle: ChangeLifecycle;
-	readonly change: T;
-}
-
-export type ChangeLifecycle = "spec" | "data" | "ownership";
-
-// ── "data" lifecycle — per-structure payload unions ─────────────────────────
-
-/** Map structure change payloads. */
-export type MapChangePayload<K, V> =
-	| { readonly kind: "set"; readonly key: K; readonly value: V }
-	| {
-			readonly kind: "delete";
-			readonly key: K;
-			readonly previous: V;
-			readonly reason: "expired" | "lru-evict" | "archived" | "explicit";
-	  }
-	| { readonly kind: "clear"; readonly count: number };
-
-export type MapChange<K, V> = BaseChange<MapChangePayload<K, V>>;
-
-/** List structure change payloads. */
-export type ListChangePayload<T> =
-	| { readonly kind: "append"; readonly value: T }
-	| { readonly kind: "appendMany"; readonly values: readonly T[] }
-	| { readonly kind: "insert"; readonly index: number; readonly value: T }
-	| { readonly kind: "insertMany"; readonly index: number; readonly values: readonly T[] }
-	| { readonly kind: "pop"; readonly index: number; readonly value: T }
-	| { readonly kind: "clear"; readonly count: number };
-
-export type ListChange<T> = BaseChange<ListChangePayload<T>>;
-
-/** Log (append-only) structure change payloads. */
-export type LogChangePayload<T> =
-	| { readonly kind: "append"; readonly value: T }
-	| { readonly kind: "appendMany"; readonly values: readonly T[] }
-	| { readonly kind: "clear"; readonly count: number }
-	| { readonly kind: "trimHead"; readonly n: number };
-
-export type LogChange<T> = BaseChange<LogChangePayload<T>>;
-
-/** Index structure change payloads. */
-export type IndexChangePayload<K, V> =
-	| { readonly kind: "upsert"; readonly primary: K; readonly secondary: unknown; readonly value: V }
-	| { readonly kind: "delete"; readonly primary: K }
-	| { readonly kind: "deleteMany"; readonly primaries: readonly K[] }
-	| { readonly kind: "clear"; readonly count: number };
-
-export type IndexChange<K, V> = BaseChange<IndexChangePayload<K, V>>;
-
-/** PubSub structure change payloads. */
-export type PubSubChangePayload<T = unknown> =
-	| { readonly kind: "publish"; readonly value: T }
-	| { readonly kind: "ack"; readonly count: number; readonly cursor: number }
-	| { readonly kind: "remove"; readonly name: string };
-
-export type PubSubChange<T = unknown> = BaseChange<PubSubChangePayload<T>>;
-
-/** Lens flow structure change payloads. */
-export type LensFlowChangePayload =
-	| { readonly kind: "tick"; readonly path: string; readonly count: number }
-	| { readonly kind: "evict"; readonly path: string };
-
-export type LensFlowChange = BaseChange<LensFlowChangePayload>;
-
-// ── "spec" lifecycle ────────────────────────────────────────────────────────
-
-export type SpecChangePayload =
-	| {
-			readonly kind: "graph.add";
-			readonly nodeId: string;
-			readonly tag?: string;
-			/**
-			 * Full node slice (Phase 14.6 — DS-14-storage Q1). Carried so WAL
-			 * replay can reconstruct nodes added between full anchors without a
-			 * follow-on "set value" frame. Optional for non-WAL emitters that
-			 * only need topology auditing.
-			 */
-			readonly slice?: DescribeNodeOutput;
-	  }
-	| { readonly kind: "graph.mount"; readonly path: string; readonly subgraphId: string }
-	| { readonly kind: "graph.remove"; readonly nodeId: string }
-	| {
-			/**
-			 * Subgraph unmount (Phase 14.6 — distinct from `graph.remove` which
-			 * targets a single node by `nodeId`).
-			 */
-			readonly kind: "graph.unmount";
-			readonly path: string;
-	  }
-	| { readonly kind: "schema.upgrade"; readonly level: number };
-
-export type SpecChange = BaseChange<SpecChangePayload>;
-
-// ── "data" lifecycle — graph-level value changes ────────────────────────────
-
-/**
- * Graph-level value change payloads (Phase 14.6 — DS-14-storage Q2 lock A).
- * Distinct from per-bundle change payloads (`MapChange`, `LogChange`, etc.) —
- * these target nodes addressed by their qualified graph path rather than
- * bundle-local keys.
- *
- * Emitted by `Graph.attachSnapshotStorage` when a tier flushes a `mode:"diff"`
- * record: every value drift in the graph snapshot decomposes into one
- * `node.set` frame; every V0 version bump decomposes into one
- * `node.versionBump` frame. Lifecycle scope is `"data"`.
- */
-export type GraphValueChangePayload =
-	| { readonly kind: "node.set"; readonly path: string; readonly value: unknown }
-	| {
-			/**
-			 * INVALIDATE-as-frame (Phase 14.6 — DS-14-storage Q7 §8.7.6).
-			 * Replays as `graph.invalidate(path)`; restores the SENTINEL slot
-			 * so downstream `prevData[i] === undefined` detectors work
-			 * deterministically post-replay.
-			 */
-			readonly kind: "node.invalidate";
-			readonly path: string;
-	  }
-	| {
-			readonly kind: "node.versionBump";
-			readonly path: string;
-			readonly id: string;
-			readonly version: number;
-	  };
-
-export type GraphValueChange = BaseChange<GraphValueChangePayload>;
-
-// ── "ownership" lifecycle ───────────────────────────────────────────────────
-
-export type OwnershipChangePayload =
-	| {
-			readonly kind: "claim";
-			readonly subgraphId: string;
-			readonly actor: string;
-			readonly level: "L0" | "L1" | "L2" | "L3";
-	  }
-	| { readonly kind: "release"; readonly subgraphId: string; readonly actor: string }
-	| {
-			readonly kind: "override";
-			readonly subgraphId: string;
-			readonly actor: string;
-			readonly previousActor: string;
-			readonly reason: string;
-	  };
-
-export type OwnershipChange = BaseChange<OwnershipChangePayload>;
diff --git a/packages/pure-ts/src/extra/data-structures/index.ts b/packages/pure-ts/src/extra/data-structures/index.ts
deleted file mode 100644
index 576bac0a..00000000
--- a/packages/pure-ts/src/extra/data-structures/index.ts
+++ /dev/null
@@ -1,18 +0,0 @@
-/**
- * Reactive data-structures barrel — keyed maps, positional lists, append-only
- * logs, and secondary indexes.
- *
- * Per the consolidation plan §2, this folder gathers the existing
- * `reactive-*` files for category-level discoverability. Physical files
- * remain at `src/extra/reactive-{map,list,log,index}.ts` (deferred move).
- *
- * `reactiveSink` is intentionally NOT included here — it is a network sink
- * primitive and lives in `extra/io/sink.ts`.
- */
-
-export * from "./change.js";
-export * from "./log-ops.js";
-export * from "./reactive-index.js";
-export * from "./reactive-list.js";
-export * from "./reactive-log.js";
-export * from "./reactive-map.js";
diff --git a/packages/pure-ts/src/extra/data-structures/log-ops.ts b/packages/pure-ts/src/extra/data-structures/log-ops.ts
deleted file mode 100644
index 7c47f20b..00000000
--- a/packages/pure-ts/src/extra/data-structures/log-ops.ts
+++ /dev/null
@@ -1,22 +0,0 @@
-/**
- * Standalone operators over {@link ReactiveLogBundle} (Phase 14.4).
- *
- * @module
- */
-
-import type { Node } from "../../core/node.js";
-import type { ReactiveLogBundle } from "./reactive-log.js";
-
-/**
- * Standalone incremental scan over a reactive log. Equivalent to
- * `log.scan(initial, step)` — provided for pipe-builder composition.
- *
- * O(1) per append; full rescan on trim/clear.
- */
-export function scanLog<T, TAcc>(
-	log: ReactiveLogBundle<T>,
-	initial: TAcc,
-	step: (acc: TAcc, value: T) => TAcc,
-): Node<TAcc> {
-	return log.scan(initial, step);
-}
diff --git a/packages/pure-ts/src/extra/data-structures/reactive-index.ts b/packages/pure-ts/src/extra/data-structures/reactive-index.ts
deleted file mode 100644
index e62b04b8..00000000
--- a/packages/pure-ts/src/extra/data-structures/reactive-index.ts
+++ /dev/null
@@ -1,598 +0,0 @@
-/**
- * Dual-key sorted index (roadmap §3.2) — unique primary key, rows ordered by `(secondary, primary)`.
- *
- * Emits `readonly IndexRow[]` snapshots directly — no `Versioned` wrapper (spec §5.12).
- *
- * **Wave 4 pilot (2026-04-15):** Introduces the `IndexBackend<K, V>` pluggable-backend interface.
- * The default `NativeIndexBackend` maintains a parallel `Map<K, IndexRow>` for O(1) `has`/`get`
- * and eliminates the O(n) filter pass during `upsert`/`delete`. A monotonic `version` counter
- * on the backend tracks mutations — foundation for post-1.0 op-log changesets.
- */
-import { batch } from "../../core/batch.js";
-import { wallClockNs } from "../../core/clock.js";
-import { DATA, DIRTY } from "../../core/messages.js";
-import { type Node, node } from "../../core/node.js";
-import type { VersioningLevel } from "../../core/versioning.js";
-import type { IndexChange, IndexChangePayload } from "./change.js";
-import { type ReactiveLogBundle, reactiveLog } from "./reactive-log.js";
-
-export type IndexRow<K, V = unknown> = {
-	readonly primary: K;
-	readonly secondary: unknown;
-	readonly value: V;
-};
-
-export type ReactiveIndexOptions<K, V = unknown> = {
-	/** Optional registry name for `describe()` / debugging. */
-	name?: string;
-	/**
-	 * Storage backend. Defaults to `NativeIndexBackend` (flat array + parallel `Map<K,IndexRow>`).
-	 * Users can plug in persistent / B-tree backends via the {@link IndexBackend} interface.
-	 */
-	backend?: IndexBackend<K, V>;
-	/**
-	 * Optional versioning level for the underlying `ordered` state node. Set at
-	 * construction time; cannot be changed later. Pass `0` for V0 identity +
-	 * monotonic version counter, or `1` for V1 + content-addressed cid.
-	 * (The `byPrimary` derived node inherits through the dep graph.)
-	 */
-	versioning?: VersioningLevel;
-	/**
-	 * Default row-equality used to short-circuit idempotent upserts. When
-	 * provided, every `upsert` / `upsertMany` that finds an existing primary
-	 * compares the stored and candidate rows via `equals(existing, next)` —
-	 * on `true` the call is a no-op (no version bump, no emission). Per-call
-	 * `UpsertOptions.equals` overrides this default. Analogous to
-	 * `NodeOptions.equals` on the core `node()` primitive.
-	 */
-	equals?: (existing: IndexRow<K, V>, next: IndexRow<K, V>) => boolean;
-	/**
-	 * Enable the `mutationLog` delta companion log. When set, every mutation
-	 * appends a typed `IndexChange<K, V>` record in the same batch frame as
-	 * the snapshot emission (same-wave consistency).
-	 *
-	 * - `true` — creates a log with default options.
-	 * - `{ maxSize?, name? }` — forwards to the inner `reactiveLog`.
-	 */
-	mutationLog?: true | { maxSize?: number; name?: string };
-};
-
-export type ReactiveIndexBundle<K, V = unknown> = {
-	/** Rows sorted by `(secondary, primary)`. */
-	readonly ordered: Node<readonly IndexRow<K, V>[]>;
-	/** Map from primary key to stored value. */
-	readonly byPrimary: Node<ReadonlyMap<K, V>>;
-	/** O(1) primary-key existence check. */
-	has: (primary: K) => boolean;
-	/** O(1) value lookup by primary key. */
-	get: (primary: K) => V | undefined;
-	/**
-	 * F20 (D205). Values whose **primary key** sorts within `[start, end)`
-	 * (inclusive start, exclusive end), in ascending primary-key order.
-	 * `start >= end` (or no matches) → `[]`. Independent of the secondary
-	 * sort axis.
-	 */
-	rangeByPrimary: (start: K, end: K) => V[];
-	/** Number of rows currently in the index (O(1)). */
-	readonly size: number;
-	/**
-	 * Upserts a row. When `opts.equals(existing, next)` returns `true` for an
-	 * existing primary key, the upsert is a no-op (no version bump, no emission).
-	 * Useful for idempotent writes.
-	 *
-	 * @returns `true` if a new row was inserted (primary key was absent),
-	 *   `false` if the primary key was already present (updated in place OR
-	 *   skipped idempotently via `opts.equals`). D5(a).
-	 */
-	upsert: (primary: K, secondary: unknown, value: V, opts?: UpsertOptions<K, V>) => boolean;
-	/**
-	 * Bulk upsert — emits one snapshot for the whole batch. `opts.equals` applied
-	 * per-row. No-op if empty or all rows skipped.
-	 *
-	 * **Iterable consumption:** Consumes `rows` once (single-pass).
-	 */
-	upsertMany: (
-		rows: Iterable<{ primary: K; secondary: unknown; value: V }>,
-		opts?: UpsertOptions<K, V>,
-	) => void;
-	delete: (primary: K) => void;
-	/**
-	 * Bulk delete — emits one snapshot for the whole batch. No-op if nothing was removed.
-	 *
-	 * **Iterable consumption:** Consumes `primaries` once (single-pass).
-	 */
-	deleteMany: (primaries: Iterable<K>) => void;
-	clear: () => void;
-	/**
-	 * Delta companion log. Present iff `mutationLog` option was configured.
-	 * Each mutation appends a typed `IndexChange<K, V>` record in the same
-	 * batch frame as the snapshot emission (same-wave consistency).
-	 */
-	readonly mutationLog?: ReactiveLogBundle<IndexChange<K, V>>;
-	/**
-	 * Releases internal keepalive subscriptions (on `byPrimary`) so the bundle
-	 * can be GC'd. Safe to call more than once (subsequent calls are no-ops).
-	 * Subsequent mutations after `dispose()` still execute on the backend but
-	 * `byPrimary` may stop updating if no external subscriber is attached.
-	 * D6(a).
-	 */
-	dispose: () => void;
-};
-
-// ── Ordering ──────────────────────────────────────────────────────────────
-
-/** Lexicographic ordering for index keys (mirrors Python tuple compare for typical primitives). */
-function cmpOrd(a: unknown, b: unknown): number {
-	if (a === b) return 0;
-	const ta = typeof a;
-	const tb = typeof b;
-	if (ta === tb && (ta === "number" || ta === "string" || ta === "boolean" || ta === "bigint")) {
-		const ax = a as number | string | boolean | bigint;
-		const bx = b as number | string | boolean | bigint;
-		if (ax < bx) return -1;
-		if (ax > bx) return 1;
-		return 0;
-	}
-	return String(a).localeCompare(String(b));
-}
-
-function compareKeys<K>(a: [unknown, K], b: [unknown, K]): number {
-	const c = cmpOrd(a[0], b[0]);
-	if (c !== 0) return c;
-	return cmpOrd(a[1], b[1]);
-}
-
-function rowKey<K, V>(row: IndexRow<K, V>): [unknown, K] {
-	return [row.secondary, row.primary];
-}
-
-function bisectLeft<K, V>(rows: readonly IndexRow<K, V>[], row: IndexRow<K, V>): number {
-	const k = rowKey(row);
-	let lo = 0;
-	let hi = rows.length;
-	while (lo < hi) {
-		const mid = (lo + hi) >> 1;
-		if (compareKeys(k, rowKey(rows[mid]!)) > 0) lo = mid + 1;
-		else hi = mid;
-	}
-	return lo;
-}
-
-// ── Backend interface ─────────────────────────────────────────────────────
-
-/**
- * Storage contract for {@link reactiveIndex}. Implementations own the mutable state and
- * expose a monotonic `version` counter that increments on every structural change.
- *
- * The reactive layer reads `version` to decide when to emit; it does not inspect
- * internal representation. Users can plug in B-tree / skip-list / persistent backends
- * without touching the reactive emission logic.
- *
- * @remarks Post-1.0 op-log changesets will extend this interface with a
- * `changesSince(version: number): Iterable<Change>` method. Current consumers
- * should treat all methods here as stable.
- *
- * @category extra
- */
-/**
- * Optional per-call options for {@link IndexBackend.upsert} and bulk upsert.
- *
- * @category extra
- */
-export type UpsertOptions<K, V> = {
-	/**
-	 * Skip the upsert if an existing row is considered equal to the proposed row.
-	 * Default: no skip — every upsert advances `version`. Provide for idempotent
-	 * keys (e.g., `(a, b) => a.secondary === b.secondary && a.value === b.value`).
-	 */
-	equals?: (existing: IndexRow<K, V>, next: IndexRow<K, V>) => boolean;
-};
-
-export interface IndexBackend<K, V = unknown> {
-	/** Monotonic mutation counter; increments on every upsert/delete/clear that changes state. */
-	readonly version: number;
-	/** Number of rows currently stored. */
-	readonly size: number;
-	/** O(1) primary-key existence check. */
-	has(primary: K): boolean;
-	/** Value lookup by primary key. */
-	get(primary: K): V | undefined;
-	/** Full row lookup by primary key. */
-	getRow(primary: K): IndexRow<K, V> | undefined;
-	/**
-	 * Insert or replace a row. Returns `true` if a row was inserted (primary
-	 * didn't exist), `false` otherwise (updated OR skipped via `opts.equals`).
-	 *
-	 * **Atomicity contract:** Either fully succeeds or throws before any state
-	 * change; `version` advances only on state change.
-	 */
-	upsert(primary: K, secondary: unknown, value: V, opts?: UpsertOptions<K, V>): boolean;
-	/**
-	 * Atomic bulk upsert. Returns the number of rows that caused a state change
-	 * (inserts + non-skipped updates). Advances `version` at most once.
-	 * No-op if iterable is empty or all rows skipped by `opts.equals`.
-	 *
-	 * **Consumes `rows` once** — pass an array for multi-shot consumers.
-	 */
-	upsertMany(
-		rows: Iterable<{ primary: K; secondary: unknown; value: V }>,
-		opts?: UpsertOptions<K, V>,
-	): number;
-	/** Remove a row by primary key. Returns `true` if the row existed. Advances `version` only if true. */
-	delete(primary: K): boolean;
-	/**
-	 * Atomic bulk delete. Returns count removed. Advances `version` at most once.
-	 * No-op if no keys were present. Consumes `primaries` once.
-	 */
-	deleteMany(primaries: Iterable<K>): number;
-	/** Remove all rows. Returns the number removed. Advances `version` only if non-zero. */
-	clear(): number;
-	/** Rows in sorted `(secondary, primary)` order — fresh snapshot suitable for emission. */
-	toArray(): readonly IndexRow<K, V>[];
-	/** Primary-key → value map — fresh snapshot. */
-	toPrimaryMap(): ReadonlyMap<K, V>;
-}
-
-/**
- * Default flat-array backend. Maintains `buf: IndexRow[]` sorted by `(secondary, primary)`
- * and a parallel `Map<K, IndexRow>` for O(1) primary-key lookup.
- *
- * **Complexity:**
- * - `has`, `get`: O(1)
- * - `upsert`: up to 2× O(log n) bisect (locate old + locate new) + up to 2× O(n) splice (remove-old + insert-new) = O(n)
- * - `upsertMany(k rows)`: O(k log n) bisect + O(k·n) splice worst case; single version bump
- * - `delete`: O(log n) bisect + O(n) splice = O(n)
- * - `deleteMany(k keys)`: O(k log n) + O(k·n) splice worst case; single version bump
- * - `clear`: O(1)
- * - `toArray`, `toPrimaryMap`: O(n)
- *
- * @category extra
- */
-export class NativeIndexBackend<K, V = unknown> implements IndexBackend<K, V> {
-	private _version = 0;
-	private readonly _buf: IndexRow<K, V>[] = [];
-	private readonly _byPrimary = new Map<K, IndexRow<K, V>>();
-
-	get version(): number {
-		return this._version;
-	}
-
-	get size(): number {
-		return this._buf.length;
-	}
-
-	has(primary: K): boolean {
-		return this._byPrimary.has(primary);
-	}
-
-	get(primary: K): V | undefined {
-		return this._byPrimary.get(primary)?.value;
-	}
-
-	getRow(primary: K): IndexRow<K, V> | undefined {
-		return this._byPrimary.get(primary);
-	}
-
-	upsert(primary: K, secondary: unknown, value: V, opts?: UpsertOptions<K, V>): boolean {
-		const existing = this._byPrimary.get(primary);
-		const row: IndexRow<K, V> = { primary, secondary, value };
-		if (existing !== undefined && opts?.equals?.(existing, row)) {
-			// Idempotent — no state change, no version advance.
-			return false;
-		}
-		if (existing !== undefined) {
-			// Remove from current sorted position via bisect on the stored row.
-			const oldPos = bisectLeft(this._buf, existing);
-			this._buf.splice(oldPos, 1);
-		}
-		const newPos = bisectLeft(this._buf, row);
-		this._buf.splice(newPos, 0, row);
-		this._byPrimary.set(primary, row);
-		this._version += 1;
-		return existing === undefined;
-	}
-
-	upsertMany(
-		rows: Iterable<{ primary: K; secondary: unknown; value: V }>,
-		opts?: UpsertOptions<K, V>,
-	): number {
-		let changed = 0;
-		try {
-			for (const r of rows) {
-				const existing = this._byPrimary.get(r.primary);
-				const row: IndexRow<K, V> = {
-					primary: r.primary,
-					secondary: r.secondary,
-					value: r.value,
-				};
-				if (existing !== undefined && opts?.equals?.(existing, row)) {
-					continue;
-				}
-				if (existing !== undefined) {
-					const oldPos = bisectLeft(this._buf, existing);
-					this._buf.splice(oldPos, 1);
-				}
-				const newPos = bisectLeft(this._buf, row);
-				this._buf.splice(newPos, 0, row);
-				this._byPrimary.set(r.primary, row);
-				changed += 1;
-			}
-		} finally {
-			// D3: surface partial commits on iterator throw; "at most once" preserved.
-			if (changed > 0) this._version += 1;
-		}
-		return changed;
-	}
-
-	delete(primary: K): boolean {
-		const existing = this._byPrimary.get(primary);
-		if (existing === undefined) return false;
-		const pos = bisectLeft(this._buf, existing);
-		this._buf.splice(pos, 1);
-		this._byPrimary.delete(primary);
-		this._version += 1;
-		return true;
-	}
-
-	deleteMany(primaries: Iterable<K>): number {
-		let removed = 0;
-		try {
-			for (const primary of primaries) {
-				const existing = this._byPrimary.get(primary);
-				if (existing === undefined) continue;
-				const pos = bisectLeft(this._buf, existing);
-				this._buf.splice(pos, 1);
-				this._byPrimary.delete(primary);
-				removed += 1;
-			}
-		} finally {
-			if (removed > 0) this._version += 1;
-		}
-		return removed;
-	}
-
-	clear(): number {
-		const n = this._buf.length;
-		if (n === 0) return 0;
-		this._buf.length = 0;
-		this._byPrimary.clear();
-		this._version += 1;
-		return n;
-	}
-
-	toArray(): readonly IndexRow<K, V>[] {
-		return [...this._buf];
-	}
-
-	toPrimaryMap(): ReadonlyMap<K, V> {
-		const m = new Map<K, V>();
-		for (const r of this._buf) m.set(r.primary, r.value);
-		return m;
-	}
-}
-
-// ── Reactive wrapper ──────────────────────────────────────────────────────
-
-function keepaliveDerived(n: Node<unknown>): () => void {
-	return n.subscribe(() => {});
-}
-
-/**
- * Creates a reactive index: unique primary key per row, rows sorted by `(secondary, primary)` for ordered scans.
- *
- * @param options - Optional `name` for `describe()` / debugging, and optional `backend` (see {@link IndexBackend}).
- * @returns Bundle with `ordered` (sorted rows), `byPrimary` (map), O(1) `has` / `get` / `size`,
- *   imperative `upsert` / `upsertMany` / `delete` / `deleteMany` / `clear`.
- *
- * @remarks
- * **Ordering:** `secondary` and `primary` are compared via a small total order: same primitive `typeof` uses
- * numeric/string/boolean/bigint comparison; mixed or object keys fall back to `String(a).localeCompare(String(b))`
- * (not identical to Python's rich comparison for exotic types).
- *
- * **Backend:** The default {@link NativeIndexBackend} offers O(1) primary-key lookups and O(n) upserts.
- * For scale beyond a few thousand rows, supply a user-pluggable persistent/B-tree backend via the
- * `backend` option — reactive emission semantics are unchanged.
- *
- * @example
- * ```ts
- * import { reactiveIndex } from "@graphrefly/pure-ts";
- *
- * const idx = reactiveIndex<string, string>();
- * idx.upsert("id1", 10, "row-a");
- * idx.upsert("id2", 5, "row-b");
- * ```
- *
- * @category extra
- */
-export function reactiveIndex<K, V = unknown>(
-	options: ReactiveIndexOptions<K, V> = {},
-): ReactiveIndexBundle<K, V> {
-	const {
-		name,
-		versioning,
-		equals: defaultEquals,
-		backend: userBackend,
-		mutationLog: mutLogOpt,
-	} = options;
-	const backend: IndexBackend<K, V> = userBackend ?? new NativeIndexBackend<K, V>();
-
-	// ── Mutations companion log (Phase 14.3) ─────────────────────────────────
-	const mutLog: ReactiveLogBundle<IndexChange<K, V>> | undefined = mutLogOpt
-		? reactiveLog<IndexChange<K, V>>(undefined, {
-				name: mutLogOpt === true ? (name ? `${name}.mutationLog` : undefined) : mutLogOpt.name,
-				maxSize: mutLogOpt === true ? undefined : mutLogOpt.maxSize,
-			})
-		: undefined;
-	let mutVersion = 0;
-	let pendingChanges: IndexChangePayload<K, V>[] = [];
-	function enqueueChange(payload: IndexChangePayload<K, V>): void {
-		if (!mutLog) return;
-		pendingChanges.push(payload);
-	}
-
-	// F1 override: merge factory-level `equals` into per-call UpsertOptions
-	// so callers who set it once at construction get idempotent-key semantics
-	// on every upsert without repeating the predicate.
-	function withDefaultEquals(opts?: UpsertOptions<K, V>): UpsertOptions<K, V> | undefined {
-		if (opts?.equals !== undefined) return opts;
-		if (defaultEquals === undefined) return opts;
-		return { ...opts, equals: defaultEquals };
-	}
-
-	const ordered = node<readonly IndexRow<K, V>[]>([], {
-		initial: [],
-		name,
-		describeKind: "state",
-		equals: (a, b) => a === b,
-		...(versioning != null ? { versioning } : {}),
-	});
-
-	const byPrimary = node<ReadonlyMap<K, V>>(
-		[ordered],
-		(batchData, actions, ctx) => {
-			const batch0 = batchData[0];
-			const s = batch0 != null && batch0.length > 0 ? batch0.at(-1) : ctx.prevData[0];
-			const rows = s as readonly IndexRow<K, V>[];
-			const m = new Map<K, V>();
-			for (const r of rows) m.set(r.primary, r.value);
-			actions.emit(m);
-		},
-		{ initial: backend.toPrimaryMap(), describeKind: "derived" },
-	);
-	const disposeByPrimaryKeepalive = keepaliveDerived(byPrimary);
-	let disposed = false;
-
-	function pushSnapshot(): void {
-		const snapshot = backend.toArray();
-		const changes = pendingChanges;
-		pendingChanges = [];
-		batch(() => {
-			ordered.down([[DIRTY]]);
-			ordered.down([[DATA, snapshot]]);
-			for (const c of changes) {
-				mutLog!.append({
-					structure: "index",
-					version: ++mutVersion,
-					t_ns: wallClockNs(),
-					lifecycle: "data",
-					change: c,
-				});
-			}
-		});
-	}
-
-	/**
-	 * Defense-in-depth emission guard: compares `version` before/after `op` and
-	 * emits a snapshot if advanced. `try/finally` surfaces partial-mutation
-	 * state from non-atomic custom backends even on thrown ops; native backends
-	 * are atomic by contract and won't reach the finally with a changed version.
-	 */
-	function wrapMutation<R>(op: () => R): R {
-		const prev = backend.version;
-		try {
-			return op();
-		} finally {
-			if (backend.version !== prev) pushSnapshot();
-			else pendingChanges.length = 0;
-		}
-	}
-
-	return {
-		ordered,
-		byPrimary,
-
-		has(primary: K): boolean {
-			return backend.has(primary);
-		},
-
-		get(primary: K): V | undefined {
-			return backend.get(primary);
-		},
-
-		rangeByPrimary(start: K, end: K): V[] {
-			if (cmpOrd(start, end) >= 0) return [];
-			const rows = [...backend.toPrimaryMap().entries()].filter(
-				([p]) => cmpOrd(p, start) >= 0 && cmpOrd(p, end) < 0,
-			);
-			rows.sort(([a], [b]) => cmpOrd(a, b));
-			return rows.map(([, v]) => v);
-		},
-
-		get size(): number {
-			return backend.size;
-		},
-
-		upsert(primary: K, secondary: unknown, value: V, opts?: UpsertOptions<K, V>): boolean {
-			return wrapMutation(() => {
-				const result = backend.upsert(primary, secondary, value, withDefaultEquals(opts));
-				enqueueChange({ kind: "upsert", primary, secondary, value });
-				return result;
-			});
-		},
-
-		upsertMany(
-			rows: Iterable<{ primary: K; secondary: unknown; value: V }>,
-			opts?: UpsertOptions<K, V>,
-		): void {
-			const list = [...rows];
-			if (list.length === 0) return;
-			wrapMutation(() => {
-				const mergedOpts = withDefaultEquals(opts);
-				// Pre-filter idempotent rows so mutation log only records effective changes.
-				const effective = mergedOpts?.equals
-					? list.filter((r) => {
-							const existing = backend.getRow(r.primary);
-							if (existing === undefined) return true;
-							return !mergedOpts.equals!(existing, {
-								primary: r.primary,
-								secondary: r.secondary,
-								value: r.value,
-							});
-						})
-					: list;
-				if (effective.length === 0) return;
-				backend.upsertMany(effective, mergedOpts);
-				for (const r of effective) {
-					enqueueChange({
-						kind: "upsert",
-						primary: r.primary,
-						secondary: r.secondary,
-						value: r.value,
-					});
-				}
-			});
-		},
-
-		delete(primary: K): void {
-			wrapMutation(() => {
-				backend.delete(primary);
-				enqueueChange({ kind: "delete", primary });
-			});
-		},
-
-		deleteMany(primaries: Iterable<K>): void {
-			const list = [...primaries];
-			if (list.length === 0) return;
-			wrapMutation(() => {
-				backend.deleteMany(list);
-				enqueueChange({ kind: "deleteMany", primaries: list });
-			});
-		},
-
-		clear(): void {
-			wrapMutation(() => {
-				const count = backend.clear();
-				if (count > 0) enqueueChange({ kind: "clear", count });
-			});
-		},
-
-		mutationLog: mutLog,
-
-		dispose(): void {
-			if (disposed) return;
-			disposed = true;
-			disposeByPrimaryKeepalive();
-			if (mutLog) mutLog.dispose();
-		},
-	};
-}
diff --git a/packages/pure-ts/src/extra/data-structures/reactive-list.ts b/packages/pure-ts/src/extra/data-structures/reactive-list.ts
deleted file mode 100644
index 34312e36..00000000
--- a/packages/pure-ts/src/extra/data-structures/reactive-list.ts
+++ /dev/null
@@ -1,374 +0,0 @@
-/**
- * Reactive positional list (roadmap §3.2) — emits `readonly T[]` snapshots directly.
- *
- * Internal version counter drives efficient equality without leaking `Versioned`
- * into the public API (spec §5.12).
- *
- * **Wave 4 refactor (2026-04-15):** Introduces the `ListBackend<T>` pluggable-backend
- * interface. The default `NativeListBackend` uses a mutable array with a monotonic
- * `version` counter. No `maxSize` cap — bounded append-heavy workloads should use
- * `reactiveLog` (head-trim under cap is unambiguous for append-only; insert-anywhere
- * with a cap is not).
- */
-import { batch } from "../../core/batch.js";
-import { wallClockNs } from "../../core/clock.js";
-import { DATA, DIRTY } from "../../core/messages.js";
-import { type Node, node } from "../../core/node.js";
-import type { VersioningLevel } from "../../core/versioning.js";
-import type { ListChange, ListChangePayload } from "./change.js";
-import { type ReactiveLogBundle, reactiveLog } from "./reactive-log.js";
-
-export type ReactiveListOptions<T> = {
-	name?: string;
-	/**
-	 * Storage backend. Defaults to `NativeListBackend` (flat mutable array).
-	 * Users can plug in persistent / RRB-tree backends via the {@link ListBackend} interface.
-	 */
-	backend?: ListBackend<T>;
-	/**
-	 * Optional versioning level for the underlying `items` state node. Set at
-	 * construction time; cannot be changed later. Pass `0` for V0 identity +
-	 * monotonic version counter, or `1` for V1 + content-addressed cid.
-	 */
-	versioning?: VersioningLevel;
-	/**
-	 * Enable the `mutationLog` delta companion log. When set, every mutation
-	 * appends a typed `ListChange<T>` record in the same batch frame as
-	 * the snapshot emission (same-wave consistency).
-	 *
-	 * - `true` — creates a log with default options.
-	 * - `{ maxSize?, name? }` — forwards to the inner `reactiveLog`.
-	 */
-	mutationLog?: true | { maxSize?: number; name?: string };
-};
-
-export type ReactiveListBundle<T> = {
-	/** Emits `readonly T[]` on each structural change (two-phase). */
-	readonly items: Node<readonly T[]>;
-	/** Current entry count (O(1)). */
-	readonly size: number;
-	/** Positional access (O(1)); supports negative indices (Python-style). Returns `undefined` on out-of-range. */
-	at: (index: number) => T | undefined;
-	append: (value: T) => void;
-	/** Push all values, emit one snapshot. No-op if `values` is empty. */
-	appendMany: (values: readonly T[]) => void;
-	/** Insert a value at `index`. Throws `RangeError` on out-of-range. */
-	insert: (index: number, value: T) => void;
-	/** Insert all values at `index` as one bulk op; emits one snapshot. No-op if `values` is empty. */
-	insertMany: (index: number, values: readonly T[]) => void;
-	/** Remove and return the value at `index` (default: last). Negative indices Python-style. Throws on empty / out-of-range. */
-	pop: (index?: number) => T;
-	clear: () => void;
-	/**
-	 * Delta companion log. Present iff `mutationLog` option was configured.
-	 * Each mutation appends a typed `ListChange<T>` record in the same
-	 * batch frame as the snapshot emission (same-wave consistency).
-	 */
-	readonly mutationLog?: ReactiveLogBundle<ListChange<T>>;
-	/**
-	 * Releases any internal keepalive subscriptions so the bundle can be
-	 * GC'd. `reactiveList` currently holds none (no internal derived nodes),
-	 * so `dispose()` is a no-op today — exposed for API parity with
-	 * `reactiveIndex.dispose` / `reactiveMap.dispose` / `reactiveLog.dispose`.
-	 * Idempotent. D6(a).
-	 */
-	dispose: () => void;
-};
-
-// ── Backend interface ─────────────────────────────────────────────────────
-
-/**
- * Storage contract for {@link reactiveList}. Implementations own the mutable state
- * and expose a monotonic `version` counter that increments on every structural change.
- *
- * The reactive layer reads `version` before and after each backend call; when it
- * advances, a snapshot is emitted.
- *
- * @remarks Post-1.0 op-log changesets will extend this interface with a
- * `changesSince(version: number): Iterable<Change>` method. Current consumers
- * should treat all methods here as stable.
- *
- * @category extra
- */
-export interface ListBackend<T> {
-	/** Monotonic mutation counter; increments on every structural change. */
-	readonly version: number;
-	/** Number of items currently stored. */
-	readonly size: number;
-	/** Positional access; `undefined` on out-of-range. */
-	at(index: number): T | undefined;
-	/** Append a single value. Advances `version`. */
-	append(value: T): void;
-	/** Append a batch. Advances `version` once. No-op if empty. */
-	appendMany(values: readonly T[]): void;
-	/** Insert at index; throws `RangeError` on out-of-range `0 <= index <= size`. Advances `version`. */
-	insert(index: number, value: T): void;
-	/** Bulk insert at index; throws on out-of-range. Advances `version` once. No-op if `values` empty. */
-	insertMany(index: number, values: readonly T[]): void;
-	/** Remove and return value at index; throws on empty / out-of-range. Advances `version`. */
-	pop(index: number): T;
-	/** Clear all entries. Returns count removed. Advances `version` only if non-zero. */
-	clear(): number;
-	/** Full snapshot as a fresh array. */
-	toArray(): readonly T[];
-}
-
-/**
- * Default mutable-array backend.
- *
- * **Complexity:**
- * - `at`, `size`: O(1)
- * - `append`: O(1) amortized
- * - `appendMany(values)`, `insertMany(index, values)`: O(n + k) where k = values.length
- * - `insert`, `pop` (middle): O(n) due to splice
- * - `pop` (last): O(1)
- * - `clear`: O(1)
- * - `toArray`: O(n)
- *
- * @category extra
- */
-export class NativeListBackend<T> implements ListBackend<T> {
-	private _version = 0;
-	private readonly _buf: T[];
-
-	constructor(initial?: readonly T[]) {
-		this._buf = initial ? [...initial] : [];
-	}
-
-	get version(): number {
-		return this._version;
-	}
-
-	get size(): number {
-		return this._buf.length;
-	}
-
-	at(index: number): T | undefined {
-		if (!Number.isInteger(index)) return undefined;
-		const i = index >= 0 ? index : this._buf.length + index;
-		if (i < 0 || i >= this._buf.length) return undefined;
-		return this._buf[i];
-	}
-
-	append(value: T): void {
-		this._buf.push(value);
-		this._version += 1;
-	}
-
-	appendMany(values: readonly T[]): void {
-		if (values.length === 0) return;
-		// Extra: avoid `this._buf.push(...values)` — spread-push has an
-		// engine-dependent stack-argument limit (typically ~100k–500k), so
-		// very large bulk inserts can throw "Maximum call stack size exceeded".
-		// Indexed write is O(n) and has no spread limit.
-		const oldLen = this._buf.length;
-		this._buf.length = oldLen + values.length;
-		for (let i = 0; i < values.length; i++) {
-			this._buf[oldLen + i] = values[i] as T;
-		}
-		this._version += 1;
-	}
-
-	insert(index: number, value: T): void {
-		if (!Number.isInteger(index) || index < 0 || index > this._buf.length) {
-			throw new RangeError(`insert: index ${index} out of range [0, ${this._buf.length}]`);
-		}
-		this._buf.splice(index, 0, value);
-		this._version += 1;
-	}
-
-	insertMany(index: number, values: readonly T[]): void {
-		if (!Number.isInteger(index) || index < 0 || index > this._buf.length) {
-			throw new RangeError(`insertMany: index ${index} out of range [0, ${this._buf.length}]`);
-		}
-		if (values.length === 0) return;
-		this._buf.splice(index, 0, ...values);
-		this._version += 1;
-	}
-
-	pop(index: number): T {
-		if (this._buf.length === 0) {
-			throw new RangeError("pop from empty list");
-		}
-		if (!Number.isInteger(index)) {
-			throw new RangeError(`pop: index ${index} must be an integer`);
-		}
-		const i = index >= 0 ? index : this._buf.length + index;
-		if (i < 0 || i >= this._buf.length) {
-			throw new RangeError(`pop: index ${index} out of range`);
-		}
-		const [v] = this._buf.splice(i, 1);
-		this._version += 1;
-		return v as T;
-	}
-
-	clear(): number {
-		const n = this._buf.length;
-		if (n === 0) return 0;
-		this._buf.length = 0;
-		this._version += 1;
-		return n;
-	}
-
-	toArray(): readonly T[] {
-		return [...this._buf];
-	}
-}
-
-// ── Reactive wrapper ──────────────────────────────────────────────────────
-
-/**
- * Creates a reactive list with immutable array snapshots.
- *
- * @param initial - Optional initial items (copied).
- * @param options - Optional `name` for `describe()` / debugging, or pluggable `backend`.
- * @returns Bundle with `items` (state node), `size` / `at`, `append` / `appendMany` / `insert` /
- *   `insertMany` / `pop` / `clear`.
- *
- * @remarks
- * **No `maxSize`:** insert/pop-anywhere semantics make eviction-under-cap ambiguous.
- * For bounded append-heavy workloads use `reactiveLog` (head-trim is well-defined for
- * append-only).
- *
- * **Backend:** Default {@link NativeListBackend}. For persistent / RRB-tree semantics
- * supply a custom {@link ListBackend}. If you provide a `backend`, `initial` is ignored
- * — seed the backend directly.
- *
- * @example
- * ```ts
- * import { reactiveList } from "@graphrefly/pure-ts";
- *
- * const list = reactiveList<string>(["a"], { name: "queue" });
- * list.append("b");
- * list.insertMany(1, ["x", "y"]);
- * ```
- *
- * @category extra
- */
-export function reactiveList<T>(
-	initial?: readonly T[],
-	options: ReactiveListOptions<T> = {},
-): ReactiveListBundle<T> {
-	const { name, versioning, backend: userBackend, mutationLog: mutLogOpt } = options;
-	const backend: ListBackend<T> = userBackend ?? new NativeListBackend<T>(initial);
-
-	// ── Mutations companion log (Phase 14.3) ─────────────────────────────────
-	const mutLog: ReactiveLogBundle<ListChange<T>> | undefined = mutLogOpt
-		? reactiveLog<ListChange<T>>(undefined, {
-				name: mutLogOpt === true ? (name ? `${name}.mutationLog` : undefined) : mutLogOpt.name,
-				maxSize: mutLogOpt === true ? undefined : mutLogOpt.maxSize,
-			})
-		: undefined;
-	let mutVersion = 0;
-	let pendingChanges: ListChangePayload<T>[] = [];
-	function enqueueChange(payload: ListChangePayload<T>): void {
-		if (!mutLog) return;
-		pendingChanges.push(payload);
-	}
-
-	const items = node<readonly T[]>([], {
-		initial: backend.toArray(),
-		name,
-		describeKind: "state",
-		equals: (a, b) => a === b,
-		...(versioning != null ? { versioning } : {}),
-	});
-
-	function pushSnapshot(): void {
-		const snapshot = backend.toArray();
-		const changes = pendingChanges;
-		pendingChanges = [];
-		batch(() => {
-			items.down([[DIRTY]]);
-			items.down([[DATA, snapshot]]);
-			for (const c of changes) {
-				mutLog!.append({
-					structure: "list",
-					version: ++mutVersion,
-					t_ns: wallClockNs(),
-					lifecycle: "data",
-					change: c,
-				});
-			}
-		});
-	}
-
-	/**
-	 * D4(a): try/finally defense-in-depth — if a custom backend op throws
-	 * mid-mutation, surface the partial state via pushSnapshot so subscribers
-	 * don't see a stale cache. Native ops are atomic by contract; this only
-	 * matters for user-supplied backends. Mirrors the pattern in reactive-map,
-	 * reactive-index, and reactive-log.
-	 */
-	function wrapMutation<R>(op: () => R): R {
-		const prev = backend.version;
-		try {
-			return op();
-		} finally {
-			if (backend.version !== prev) pushSnapshot();
-			else pendingChanges.length = 0;
-		}
-	}
-
-	return {
-		items,
-
-		get size(): number {
-			return backend.size;
-		},
-
-		at(index: number): T | undefined {
-			return backend.at(index);
-		},
-
-		append(value: T): void {
-			wrapMutation(() => {
-				backend.append(value);
-				enqueueChange({ kind: "append", value });
-			});
-		},
-
-		appendMany(values: readonly T[]): void {
-			wrapMutation(() => {
-				backend.appendMany(values);
-				if (values.length > 0) enqueueChange({ kind: "appendMany", values });
-			});
-		},
-
-		insert(index: number, value: T): void {
-			wrapMutation(() => {
-				backend.insert(index, value);
-				enqueueChange({ kind: "insert", index, value });
-			});
-		},
-
-		insertMany(index: number, values: readonly T[]): void {
-			wrapMutation(() => {
-				backend.insertMany(index, values);
-				if (values.length > 0) enqueueChange({ kind: "insertMany", index, values });
-			});
-		},
-
-		pop(index = -1): T {
-			return wrapMutation(() => {
-				const resolvedIndex = index < 0 ? backend.size + index : index;
-				const value = backend.pop(index);
-				enqueueChange({ kind: "pop", index: resolvedIndex, value });
-				return value;
-			});
-		},
-
-		clear(): void {
-			wrapMutation(() => {
-				const count = backend.clear();
-				if (count > 0) enqueueChange({ kind: "clear", count });
-			});
-		},
-
-		mutationLog: mutLog,
-
-		dispose(): void {
-			if (mutLog) mutLog.dispose();
-		},
-	};
-}
diff --git a/packages/pure-ts/src/extra/data-structures/reactive-log.ts b/packages/pure-ts/src/extra/data-structures/reactive-log.ts
deleted file mode 100644
index 7f6e1265..00000000
--- a/packages/pure-ts/src/extra/data-structures/reactive-log.ts
+++ /dev/null
@@ -1,1032 +0,0 @@
-/**
- * Reactive append-only log (roadmap §3.2) — emits `readonly T[]` snapshots directly.
- *
- * Internal version counter drives efficient equality without leaking `Versioned`
- * into the public API (spec §5.12).
- *
- * **Audit 1 (2026-04-24):** Adds `view(spec)` consolidated views, `withLatest()`
- * with `meta.lastValue` companion node, `attach(upstream)`
- * for drain-from-source wiring, factory-level `mergeReactiveLogs(logs)` for
- * fan-in, `guard?` option on `entries`, and `attachStorage(tiers)` integration
- * with the Audit 4 storage layer. {@link LogBackend} gains `snapshot()` /
- * `restore()` for cold-tier load on startup.
- *
- * **Lock 5.A (Phase 13.6.B B8):** `T` no longer permits `undefined`. The
- * SENTINEL family collapse retired the `T | undefined` exception that
- * justified the `hasLatest` companion. Concrete API impact:
- * - `lastValue` is now `Node<T>` (was `Node<T | undefined>`). `.cache`
- *   still returns `T | undefined` at the protocol level when the log is
- *   empty (sentinel state) — the type narrowing rules out *appending*
- *   `undefined`, which is enforced via runtime guard in `append` /
- *   `appendMany`.
- * - `hasLatest` is REMOVED. Empty-vs-non-empty is unambiguous from the
- *   wave shape: `[[RESOLVED]]` (R2 use, empty log) vs `[[DATA, v]]`
- *   (non-empty). Callers that need a boolean reactively should derive
- *   from `entries.length > 0`.
- * - `append(undefined as T)` throws — same applies to `appendMany`.
- */
-import { batch } from "../../core/batch.js";
-import { wallClockNs } from "../../core/clock.js";
-import type { NodeGuard } from "../../core/guard.js";
-import { COMPLETE, DATA, DIRTY, ERROR, RESOLVED } from "../../core/messages.js";
-import { type Node, node } from "../../core/node.js";
-import type { VersioningLevel } from "../../core/versioning.js";
-import { fromTimer, keepalive } from "../sources/index.js";
-import type { AppendLogStorageTier } from "../storage/tiers.js";
-import type { LogChange, LogChangePayload } from "./change.js";
-
-export type ReactiveLogOptions<T> = {
-	name?: string;
-	maxSize?: number;
-	/**
-	 * Optional versioning level for the underlying `entries` state node. Set
-	 * at construction time; cannot be changed later. Pass `0` for V0 identity
-	 * + monotonic version counter, or `1` for V1 + content-addressed cid.
-	 */
-	versioning?: VersioningLevel;
-	/**
-	 * Optional guard policy applied to the `entries` node. Use to deny
-	 * external `write` while permitting `observe` / `signal` — eliminates the
-	 * passthrough-derived pattern in CQRS event streams (Audit 1 #7).
-	 */
-	guard?: NodeGuard;
-	/**
-	 * Storage backend. Defaults to `NativeLogBackend` (ring buffer if `maxSize` is set,
-	 * flat array otherwise). Users can plug in persistent / RRB-tree backends via
-	 * the {@link LogBackend} interface.
-	 */
-	backend?: LogBackend<T>;
-	/**
-	 * Enable the `mutationLog` delta companion log. When set, every mutation
-	 * appends a typed `LogChange<T>` record in the same batch frame as
-	 * the snapshot emission (same-wave consistency).
-	 *
-	 * - `true` — creates a companion log with default options.
-	 * - `{ maxSize?, name? }` — forwards to the inner companion log.
-	 */
-	mutationLog?: true | { maxSize?: number; name?: string };
-};
-
-/**
- * Discriminated view spec for {@link ReactiveLogBundle.view}. New `kind`s
- * (e.g. `"filter"`, `"windowByTime"`) layer in without new methods.
- */
-export type ViewSpec<_T = unknown> =
-	| { kind: "tail"; n: number }
-	| { kind: "slice"; start: number; stop?: number }
-	| { kind: "fromCursor"; cursor: Node<number> };
-
-export type ReactiveLogBundle<T> = {
-	/** Emits `readonly T[]` on each append/clear/trim (two-phase). */
-	readonly entries: Node<readonly T[]>;
-	/** Current entry count (O(1)). */
-	readonly size: number;
-	/** Positional access (O(1)); returns `undefined` on out-of-range. Supports negative indices. */
-	at: (index: number) => T | undefined;
-	append: (value: T) => void;
-	/** Push all values, emit one snapshot. No-op if `values` is empty. */
-	appendMany: (values: readonly T[]) => void;
-	clear: () => void;
-	/** Remove the first `n` entries (clamped to `size`). */
-	trimHead: (n: number) => void;
-	/**
-	 * Activate the {@link ReactiveLogBundle.lastValue} companion node (lazy —
-	 * installed on first call, reused thereafter). Returns `entries` so
-	 * chaining reads naturally.
-	 *
-	 * **Companion-node access is on the bundle** (not `entries.meta`) because
-	 * `Node.meta` is frozen at construction; bundle-level lazy properties
-	 * give the same semantics with simpler ergonomics.
-	 */
-	withLatest: () => Node<readonly T[]>;
-	/**
-	 * Most-recently-appended value. Accessing this property activates the
-	 * companion lazily — same as calling {@link ReactiveLogBundle.withLatest}.
-	 *
-	 * **Empty-log path emits `RESOLVED`, not `DATA(undefined)`.** When the log
-	 * holds no entries, `lastValue` settles via `[[RESOLVED]]` (R2 dual-role
-	 * — wave settled, no value to advertise). The §1.2 "DATA(undefined) is
-	 * not a valid emission" invariant stands.
-	 *
-	 * **Lock 5.A (Phase 13.6.B B8):** `T` excludes `undefined`. Empty-vs-
-	 * non-empty distinguishes from the wave shape — RESOLVED for empty,
-	 * DATA(value) for non-empty. The pre-Lock-5.A `hasLatest` companion
-	 * was retired because the dual-role RESOLVED already disambiguates.
-	 *
-	 * Note: `.cache` may still return `undefined` when the log is empty
-	 * (sentinel state) — that's the protocol-level "never sent" signal,
-	 * not a valid `T` payload.
-	 */
-	readonly lastValue: Node<T>;
-	/**
-	 * Reactive view per discriminated `ViewSpec`. Memoized per-spec — repeat
-	 * calls with identical spec return the same node.
-	 */
-	view: (spec: ViewSpec<T>) => Node<readonly T[]>;
-	/**
-	 * Subscribe to `upstream` and append every DATA into this log. Returns a
-	 * disposer. ERROR / COMPLETE on `upstream` propagate through the disposer
-	 * (caller is responsible for terminal handling on the log).
-	 *
-	 * **Push-on-subscribe caveat:** subscribing replays the upstream's
-	 * subscribe-handshake frame — its cached value, or the *full* `replayBuffer`
-	 * if one is configured (spec §2.2 / §2.5) — so that history is appended at
-	 * attach time, double-counting if `upstream` already fed this log before
-	 * `attach`. Pass `{ skipCachedReplay: true }` to drop the **entire
-	 * subscribe-handshake frame** (cached value *or* full replay buffer);
-	 * subsequent live emissions are appended. The drop is keyed off the first
-	 * sink delivery, not a synchronous window, so it works even when `attach`
-	 * runs inside `batch()` (the handshake DATA is `downWithBatch`-deferred).
-	 */
-	attach: (upstream: Node<T>, opts?: { skipCachedReplay?: boolean }) => () => void;
-	/**
-	 * Wire one or more append-log storage tiers. Each tier receives entries on
-	 * every append wave; tier-internal flush/rollback honors the wave-as-
-	 * transaction model (Audit 4). Returns a disposer.
-	 */
-	attachStorage: (tiers: readonly AppendLogStorageTier<T>[]) => () => void;
-	/**
-	 * Incremental running aggregate over the log. O(1) per append — only
-	 * applies `step` to entries appended since the last emission. Returns a
-	 * `Node<TAcc>` that emits the current accumulator on every log mutation.
-	 *
-	 * Replay via the log's `replayBuffer: N` per Lock 6.G (no scan-internal
-	 * buffering). Returns `Node<TAcc>` per Lock 5.A (no `| undefined`).
-	 */
-	scan: <TAcc>(initial: TAcc, step: (acc: TAcc, value: T) => TAcc) => Node<TAcc>;
-	/**
-	 * Delta companion log. Present iff `mutationLog` option was configured.
-	 * Each mutation appends a typed `LogChange<T>` record in the same
-	 * batch frame as the snapshot emission (same-wave consistency).
-	 */
-	readonly mutationLog?: ReactiveLogBundle<LogChange<T>>;
-	/** Releases all cached views (tail + slice + fromCursor). */
-	disposeAllViews: () => void;
-	/** Releases all internal keepalives. Idempotent. */
-	dispose: () => void;
-};
-
-// ── Backend interface ─────────────────────────────────────────────────────
-
-/**
- * Storage contract for {@link reactiveLog}. Implementations own the mutable state and
- * expose a monotonic `version` counter that increments on every structural change.
- *
- * **Audit 1:** `snapshot()` returns an immutable readonly view (codec encodes
- * at the storage tier boundary). `restore(values)` replaces backend state on
- * cold-tier startup load — fires one DATA emission for the restored shape.
- *
- * @category extra
- */
-export interface LogBackend<T> {
-	readonly version: number;
-	readonly size: number;
-	at(index: number): T | undefined;
-	append(value: T): void;
-	appendMany(values: readonly T[]): void;
-	clear(): number;
-	trimHead(n: number): number;
-	slice(start: number, stop?: number): readonly T[];
-	tail(n: number): readonly T[];
-	toArray(): readonly T[];
-	/** Immutable snapshot for codec serialization. Equivalent to `toArray()`. */
-	snapshot(): readonly T[];
-	/** Replace backend state with `values` (used by cold-tier restore). */
-	restore(values: readonly T[]): void;
-}
-
-/**
- * Default append-only log backend.
- *
- * - When `maxSize` is set: uses a **ring buffer** with `_head` index and circular
- *   modular arithmetic. Append and trim become O(1); snapshot is O(size) unrolling.
- * - When `maxSize` is unset: uses a flat array with standard push/splice.
- *
- * @category extra
- */
-export class NativeLogBackend<T> implements LogBackend<T> {
-	private _version = 0;
-	private readonly _maxSize?: number;
-	private readonly _buf: T[];
-	private _head = 0;
-	private _size = 0;
-
-	constructor(initial?: readonly T[], maxSize?: number) {
-		if (maxSize !== undefined && maxSize < 1) {
-			throw new RangeError("maxSize must be >= 1");
-		}
-		this._maxSize = maxSize;
-		if (maxSize !== undefined) {
-			this._buf = new Array(maxSize);
-			if (initial && initial.length > 0) {
-				const take = Math.min(initial.length, maxSize);
-				const start = initial.length - take;
-				for (let i = 0; i < take; i++) {
-					this._buf[i] = initial[start + i]!;
-				}
-				this._size = take;
-			}
-		} else {
-			this._buf = initial ? [...initial] : [];
-			this._size = this._buf.length;
-		}
-	}
-
-	get version(): number {
-		return this._version;
-	}
-
-	get size(): number {
-		return this._size;
-	}
-
-	at(index: number): T | undefined {
-		if (!Number.isInteger(index)) return undefined;
-		const i = index >= 0 ? index : this._size + index;
-		if (i < 0 || i >= this._size) return undefined;
-		if (this._maxSize !== undefined) {
-			return this._buf[(this._head + i) % this._maxSize];
-		}
-		return this._buf[i];
-	}
-
-	append(value: T): void {
-		this._rawAppend(value);
-		this._version += 1;
-	}
-
-	appendMany(values: readonly T[]): void {
-		if (values.length === 0) return;
-		const start =
-			this._maxSize !== undefined && values.length > this._maxSize
-				? values.length - this._maxSize
-				: 0;
-		for (let i = start; i < values.length; i++) {
-			this._rawAppend(values[i] as T);
-		}
-		this._version += 1;
-	}
-
-	clear(): number {
-		if (this._size === 0) return 0;
-		const n = this._size;
-		if (this._maxSize === undefined) {
-			this._buf.length = 0;
-		} else {
-			for (let i = 0; i < n; i++) {
-				this._buf[(this._head + i) % this._maxSize] = undefined as unknown as T;
-			}
-		}
-		this._head = 0;
-		this._size = 0;
-		this._version += 1;
-		return n;
-	}
-
-	trimHead(n: number): number {
-		if (!Number.isInteger(n) || n < 0) {
-			throw new RangeError(`trimHead: n must be a non-negative integer (got ${n})`);
-		}
-		if (n === 0 || this._size === 0) return 0;
-		const removed = Math.min(n, this._size);
-		if (this._maxSize === undefined) {
-			this._buf.splice(0, removed);
-		} else {
-			for (let i = 0; i < removed; i++) {
-				this._buf[(this._head + i) % this._maxSize] = undefined as unknown as T;
-			}
-			this._head = (this._head + removed) % this._maxSize;
-		}
-		this._size -= removed;
-		this._version += 1;
-		return removed;
-	}
-
-	slice(start: number, stop?: number): readonly T[] {
-		if (!Number.isInteger(start) || start < 0) {
-			throw new RangeError(`slice: start must be a non-negative integer (got ${start})`);
-		}
-		if (stop !== undefined && (!Number.isInteger(stop) || stop < 0)) {
-			throw new RangeError(`slice: stop must be a non-negative integer or undefined (got ${stop})`);
-		}
-		const end = stop === undefined ? this._size : Math.min(Math.max(stop, 0), this._size);
-		const s = Math.min(start, this._size);
-		if (s >= end) return [];
-		const len = end - s;
-		if (this._maxSize === undefined) {
-			return this._buf.slice(s, end);
-		}
-		const out: T[] = new Array(len);
-		for (let i = 0; i < len; i++) {
-			out[i] = this._buf[(this._head + s + i) % this._maxSize]!;
-		}
-		return out;
-	}
-
-	tail(n: number): readonly T[] {
-		if (!Number.isInteger(n) || n < 0) {
-			throw new RangeError(`tail: n must be a non-negative integer (got ${n})`);
-		}
-		if (n === 0 || this._size === 0) return [];
-		const take = Math.min(n, this._size);
-		return this.slice(this._size - take, this._size);
-	}
-
-	toArray(): readonly T[] {
-		if (this._maxSize === undefined) {
-			return [...this._buf];
-		}
-		const out: T[] = new Array(this._size);
-		for (let i = 0; i < this._size; i++) {
-			out[i] = this._buf[(this._head + i) % this._maxSize]!;
-		}
-		return out;
-	}
-
-	snapshot(): readonly T[] {
-		return this.toArray();
-	}
-
-	restore(values: readonly T[]): void {
-		if (this._maxSize === undefined) {
-			this._buf.length = 0;
-			for (let i = 0; i < values.length; i++) this._buf.push(values[i] as T);
-			this._size = this._buf.length;
-		} else {
-			const cap = this._maxSize;
-			for (let i = 0; i < cap; i++) this._buf[i] = undefined as unknown as T;
-			this._head = 0;
-			const take = Math.min(values.length, cap);
-			const start = values.length - take;
-			for (let i = 0; i < take; i++) {
-				this._buf[i] = values[start + i] as T;
-			}
-			this._size = take;
-		}
-		this._version += 1;
-	}
-
-	private _rawAppend(value: T): void {
-		if (this._maxSize === undefined) {
-			this._buf.push(value);
-			this._size = this._buf.length;
-			return;
-		}
-		if (this._size < this._maxSize) {
-			this._buf[(this._head + this._size) % this._maxSize] = value;
-			this._size += 1;
-		} else {
-			this._buf[this._head] = value;
-			this._head = (this._head + 1) % this._maxSize;
-		}
-	}
-}
-
-// ── Reactive wrapper ──────────────────────────────────────────────────────
-
-function keepaliveDerived(n: Node<unknown>): () => void {
-	return n.subscribe(() => {});
-}
-
-/** Default cap on the LRU view cache for `tail(n)` / `slice(start, stop?)`. */
-const DEFAULT_VIEW_CACHE_MAX = 64;
-
-/**
- * Creates an append-only reactive log that emits immutable `readonly T[]` snapshots.
- *
- * Each structural mutation (`append`, `appendMany`, `clear`, `trimHead`) triggers
- * a two-phase `[DIRTY, DATA]` emission on the `entries` node so downstream
- * derived nodes update reactively. Views (`tail`, `slice`, `fromCursor`) are
- * memoized derived nodes — subscribe once and they stay live.
- *
- * @param initial - Optional initial entries loaded into the log at construction.
- * @param options - Optional name, max size (ring buffer), versioning level, guard policy, and custom backend.
- * @returns `ReactiveLogBundle<T>` with `entries`, `append`, `appendMany`, `clear`, `trimHead`, `view`, `attach`, `attachStorage`, and disposal methods.
- *
- * @example
- * ```ts
- * import { reactiveLog } from "@graphrefly/graphrefly/extra";
- *
- * const log = reactiveLog<string>([], { name: "messages" });
- * log.entries.subscribe((msgs) => {
- *   for (const m of msgs) {
- *     if (m[0] === 1) console.log("entries:", m[1]);
- *   }
- * });
- * log.append("hello");
- * log.append("world");
- * ```
- *
- * @remarks
- * **Ring buffer:** Pass `maxSize` to cap the log length; older entries are evicted on overflow.
- * **Storage:** Call `attachStorage(tiers)` to wire one or more `AppendLogStorageTier` instances for persistence.
- *
- * @category extra
- */
-export function reactiveLog<T>(
-	initial?: readonly T[],
-	options: ReactiveLogOptions<T> = {},
-): ReactiveLogBundle<T> {
-	const {
-		name,
-		maxSize,
-		versioning,
-		guard,
-		backend: userBackend,
-		mutationLog: mutLogOpt,
-	} = options;
-	const backend: LogBackend<T> = userBackend ?? new NativeLogBackend<T>(initial, maxSize);
-
-	// ── Mutations companion log (Phase 14.3) ─────────────────────────────────
-	// Uses a separate `reactiveLog` instance (never recurses — companion logs
-	// are always created WITHOUT their own `mutationLog` option).
-	const mutLog: ReactiveLogBundle<LogChange<T>> | undefined = mutLogOpt
-		? reactiveLog<LogChange<T>>(undefined, {
-				name: mutLogOpt === true ? (name ? `${name}.mutationLog` : undefined) : mutLogOpt.name,
-				maxSize: mutLogOpt === true ? undefined : mutLogOpt.maxSize,
-			})
-		: undefined;
-	let mutVersion = 0;
-	let pendingChanges: LogChangePayload<T>[] = [];
-	function enqueueChange(payload: LogChangePayload<T>): void {
-		if (!mutLog) return;
-		pendingChanges.push(payload);
-	}
-
-	const entries = node<readonly T[]>([], {
-		initial: backend.toArray(),
-		name,
-		describeKind: "state",
-		equals: (a, b) => a === b,
-		...(versioning != null ? { versioning } : {}),
-		...(guard != null ? { guard } : {}),
-	});
-
-	function pushSnapshot(): void {
-		const snapshot = backend.toArray();
-		const changes = pendingChanges;
-		pendingChanges = [];
-		batch(() => {
-			// `internal: true` so deny-write guards (e.g., Audit 2's
-			// DEFAULT_AUDIT_GUARD on audit logs) don't reject the log's own
-			// internal pipeline. Guards apply only to external `entries.emit`.
-			entries.down([[DIRTY]], { internal: true });
-			entries.down([[DATA, snapshot]], { internal: true });
-			for (const c of changes) {
-				mutLog!.append({
-					structure: "log",
-					version: ++mutVersion,
-					t_ns: wallClockNs(),
-					lifecycle: "data",
-					change: c,
-				});
-			}
-		});
-	}
-
-	type ViewEntry = { node: Node<readonly T[]>; dispose: () => void };
-	const tailCache = new Map<number, ViewEntry>();
-	const sliceCache = new Map<string, ViewEntry>();
-	// M6: use Map (not WeakMap) so disposeAllViews can iterate + release
-	// each cursor view's keepalive subscription. Cursor cache size grows with
-	// distinct cursor Nodes the bundle has been viewed by — bounded by user.
-	const cursorCache = new Map<Node<number>, ViewEntry>();
-
-	function sliceKey(start: number, stop?: number): string {
-		return `${start}:${stop === undefined ? "END" : stop}`;
-	}
-
-	function evictOldestIfFull<K>(cache: Map<K, ViewEntry>): void {
-		if (cache.size < DEFAULT_VIEW_CACHE_MAX) return;
-		const first = cache.keys().next();
-		if (first.done) return;
-		const oldest = cache.get(first.value);
-		if (oldest !== undefined) oldest.dispose();
-		cache.delete(first.value);
-	}
-
-	function wrapMutation<R>(op: () => R): R {
-		const prev = backend.version;
-		try {
-			return op();
-		} finally {
-			if (backend.version !== prev) pushSnapshot();
-			else pendingChanges.length = 0;
-		}
-	}
-
-	function tailView(n: number): Node<readonly T[]> {
-		if (!Number.isInteger(n) || n < 0) {
-			throw new RangeError(`tail: n must be a non-negative integer (got ${n})`);
-		}
-		const hit = tailCache.get(n);
-		if (hit !== undefined) {
-			tailCache.delete(n);
-			tailCache.set(n, hit);
-			return hit.node;
-		}
-		evictOldestIfFull(tailCache);
-		const node_ = node(
-			[entries],
-			(batchData, actions, ctx) => {
-				const batch0 = batchData[0];
-				const s = batch0 != null && batch0.length > 0 ? batch0.at(-1) : ctx.prevData[0];
-				const list = s as readonly T[];
-				if (n === 0 || list.length === 0) {
-					actions.emit([] as unknown as readonly T[]);
-					return;
-				}
-				actions.emit(list.slice(Math.max(0, list.length - n)));
-			},
-			{ initial: backend.tail(n), describeKind: "derived" },
-		);
-		const dispose = keepaliveDerived(node_);
-		tailCache.set(n, { node: node_, dispose });
-		return node_;
-	}
-
-	function sliceView(start: number, stop?: number): Node<readonly T[]> {
-		if (!Number.isInteger(start) || start < 0) {
-			throw new RangeError(`slice: start must be a non-negative integer (got ${start})`);
-		}
-		if (stop !== undefined && (!Number.isInteger(stop) || stop < 0)) {
-			throw new RangeError(`slice: stop must be a non-negative integer or undefined (got ${stop})`);
-		}
-		const key = sliceKey(start, stop);
-		const hit = sliceCache.get(key);
-		if (hit !== undefined) {
-			sliceCache.delete(key);
-			sliceCache.set(key, hit);
-			return hit.node;
-		}
-		evictOldestIfFull(sliceCache);
-		const node_ = node(
-			[entries],
-			(batchData, actions, ctx) => {
-				const batch0 = batchData[0];
-				const s = batch0 != null && batch0.length > 0 ? batch0.at(-1) : ctx.prevData[0];
-				const list = s as readonly T[];
-				actions.emit(stop === undefined ? list.slice(start) : list.slice(start, stop));
-			},
-			{ initial: backend.slice(start, stop), describeKind: "derived" },
-		);
-		const dispose = keepaliveDerived(node_);
-		sliceCache.set(key, { node: node_, dispose });
-		return node_;
-	}
-
-	function fromCursorView(cursor: Node<number>): Node<readonly T[]> {
-		const hit = cursorCache.get(cursor);
-		if (hit !== undefined) return hit.node;
-		const node_ = node(
-			[entries, cursor],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				const arr = data[0] as readonly T[];
-				const start = Math.max(0, Math.trunc((data[1] as number) ?? 0));
-				actions.emit(arr.slice(start));
-			},
-			{ initial: [], describeKind: "derived" },
-		);
-		const dispose = keepaliveDerived(node_);
-		cursorCache.set(cursor, { node: node_, dispose });
-		return node_;
-	}
-
-	// withLatest companion activation (lazy, idempotent)
-	let lastValueCached: Node<T> | undefined;
-	function activateMeta(): void {
-		if (lastValueCached !== undefined) return;
-		// M1: emit RESOLVED instead of DATA(undefined) when log is empty —
-		// `[[DATA, undefined]]` is a §1.2 protocol violation. Empty log
-		// means "nothing to advertise as latest", which is the RESOLVED
-		// semantic: this wave settled, no value change. Lock 5.A retired
-		// the `hasLatest` companion in favor of the wave-shape disambiguation
-		// (RESOLVED = empty, DATA(v) = non-empty).
-		lastValueCached = node<T>(
-			[entries],
-			(batchData, actions, ctx) => {
-				const batch0 = batchData[0];
-				const snapshot = batch0 != null && batch0.length > 0 ? batch0.at(-1) : ctx.prevData[0];
-				const arr = snapshot as readonly T[] | undefined;
-				if (arr == null || arr.length === 0) {
-					actions.down([[RESOLVED]]);
-					return;
-				}
-				actions.emit(arr[arr.length - 1] as T);
-			},
-			{
-				name: name != null ? `${name}::lastValue` : "lastValue",
-				describeKind: "derived",
-				// `initial` is `T | null` per `NodeOptions.initial` typing —
-				// when the log is empty we leave it absent (sentinel state)
-				// rather than fabricating a value.
-				...(backend.size === 0 ? {} : { initial: backend.at(backend.size - 1) as T }),
-			},
-		);
-		keepaliveDerived(lastValueCached);
-	}
-
-	const bundle: ReactiveLogBundle<T> = {
-		entries,
-
-		get size(): number {
-			return backend.size;
-		},
-
-		at(index: number): T | undefined {
-			return backend.at(index);
-		},
-
-		append(value: T): void {
-			// Lock 5.A (Phase 13.6.B B8): `T` excludes `undefined`. A literal
-			// `undefined` would corrupt the empty-vs-non-empty wave-shape
-			// disambiguation that replaced the retired `hasLatest` companion.
-			if (value === undefined) {
-				throw new TypeError(
-					"reactiveLog.append(undefined) — `T` excludes undefined per Lock 5.A. " +
-						"Use `T | null` for an explicit null payload.",
-				);
-			}
-			wrapMutation(() => {
-				backend.append(value);
-				enqueueChange({ kind: "append", value });
-			});
-		},
-
-		appendMany(values: readonly T[]): void {
-			if (values.length === 0) return;
-			// Lock 5.A: same `undefined` rejection at the bulk path.
-			for (let i = 0; i < values.length; i++) {
-				if (values[i] === undefined) {
-					throw new TypeError(
-						`reactiveLog.appendMany — values[${i}] is undefined; \`T\` excludes ` +
-							"undefined per Lock 5.A. Use `T | null` for explicit null payloads.",
-					);
-				}
-			}
-			wrapMutation(() => {
-				backend.appendMany(values);
-				enqueueChange({ kind: "appendMany", values });
-			});
-		},
-
-		clear(): void {
-			wrapMutation(() => {
-				const count = backend.clear();
-				if (count > 0) enqueueChange({ kind: "clear", count });
-			});
-		},
-
-		trimHead(n: number): void {
-			wrapMutation(() => {
-				const trimmed = backend.trimHead(n);
-				if (trimmed > 0) enqueueChange({ kind: "trimHead", n: trimmed });
-			});
-		},
-
-		withLatest(): Node<readonly T[]> {
-			activateMeta();
-			return entries;
-		},
-
-		get lastValue(): Node<T> {
-			activateMeta();
-			return lastValueCached!;
-		},
-
-		view(spec): Node<readonly T[]> {
-			switch (spec.kind) {
-				case "tail":
-					return tailView(spec.n);
-				case "slice":
-					return sliceView(spec.start, spec.stop);
-				case "fromCursor":
-					return fromCursorView(spec.cursor);
-			}
-		},
-
-		attach(upstream, opts): () => void {
-			// `defaultOnSubscribe` replays the cached value / full replay buffer
-			// as the handshake. `downWithBatch` splits that frame by tier:
-			// `[START]` lands phase-1 (always synchronous), the replay `[DATA…]`
-			// lands phase-2 as ONE slice (synchronous, or `batch()`-deferred to
-			// the drain). Live emissions are later, separate deliveries. So:
-			// skip the FIRST data-bearing delivery — but only when the upstream
-			// actually holds a cached value (`cache !== undefined`, the spec
-			// SENTINEL), exactly the condition under which `defaultOnSubscribe`
-			// pushes the replay. Cold upstream → nothing to skip, so the first
-			// live emission is NOT dropped. (Niche: a post-INVALIDATE upstream
-			// whose replay buffer outlives its cleared cache is not detected
-			// here — `cache` is the only public signal.)
-			let pendingHandshakeSkip = opts?.skipCachedReplay === true && upstream.cache !== undefined;
-			const sub = upstream.subscribe((msgs) => {
-				let hasData = false;
-				for (const m of msgs) {
-					if (m[0] === DATA) {
-						hasData = true;
-						break;
-					}
-				}
-				if (pendingHandshakeSkip && hasData) {
-					// The single replay slice — drop it whole, then resume.
-					pendingHandshakeSkip = false;
-					return;
-				}
-				for (const m of msgs) {
-					if (m[0] === DATA) bundle.append(m[1] as T);
-				}
-			});
-			return () => sub();
-		},
-
-		attachStorage(tiers): () => void {
-			if (tiers.length === 0) return () => {};
-			// `attachStorage` ships per-wave DELTAS (`arr.slice(last)`), relying
-			// on the tier to accumulate. An `appendLogStorage({ mode:
-			// "overwrite" })` tier does NOT accumulate — each flush replaces the
-			// key with only that flush's entries — so feeding it deltas would
-			// silently truncate the log to the last wave (the memo:Re-P0
-			// failure class). Reject up front rather than lose data silently.
-			for (const t of tiers) {
-				if ((t as { mode?: string }).mode === "overwrite") {
-					throw new Error(
-						`reactiveLog.attachStorage: tier "${t.name}" has mode:"overwrite", ` +
-							`which is incompatible with attachStorage's per-wave delta shipping ` +
-							`(it would truncate the log to the last wave). Use mode:"append" ` +
-							`(the default) for attachStorage, or drive the overwrite tier ` +
-							`directly with the full entry set each flush.`,
-					);
-				}
-			}
-			// Track delivered count per tier so we only ship deltas. Initialised
-			// to current backend.size below; the post-restore IIFE updates the
-			// restored-from tier so we don't double-write its own data back.
-			const delivered = new Map<AppendLogStorageTier<T>, number>();
-			for (const t of tiers) delivered.set(t, backend.size);
-			// Pre-load: best-effort restore from first tier with loadEntries support.
-			void (async () => {
-				for (const tier of tiers) {
-					if (typeof tier.loadEntries !== "function") continue;
-					try {
-						const result = await Promise.resolve(tier.loadEntries());
-						if (result.entries.length > 0 && backend.size === 0) {
-							backend.restore(result.entries);
-							// C2: mark restored-from tier as already in sync so
-							// the post-restore pushSnapshot doesn't ship the
-							// restored block back as a "delta". Other tiers
-							// stay at 0 — they'll receive the restored block
-							// as a forward write (correct).
-							delivered.set(tier, result.entries.length);
-							pushSnapshot();
-						}
-						break;
-					} catch {
-						/* try next tier */
-					}
-				}
-			})();
-			const sub = entries.subscribe((msgs) => {
-				for (const m of msgs) {
-					if (m[0] !== DATA) continue;
-					const arr = m[1] as readonly T[];
-					for (const tier of tiers) {
-						const last = delivered.get(tier) ?? 0;
-						if (arr.length < last) {
-							// M9: length decreased — `trimHead`/`clear` happened.
-							// Re-ship the full post-trim snapshot. Append-log
-							// tiers should be idempotent (or use `keyOf` to
-							// dedupe partition writes); we accept the re-send
-							// over silent loss of subsequent appends.
-							try {
-								const result = tier.appendEntries(arr);
-								if (result instanceof Promise) result.catch(() => {});
-							} catch {
-								/* tier write error swallowed */
-							}
-							delivered.set(tier, arr.length);
-							continue;
-						}
-						if (arr.length === last) continue;
-						const fresh = arr.slice(last);
-						delivered.set(tier, arr.length);
-						try {
-							const result = tier.appendEntries(fresh);
-							if (result instanceof Promise) result.catch(() => {});
-						} catch {
-							/* tier write error swallowed; surface via tier.flush */
-						}
-					}
-				}
-			});
-			// F9 (QA, option A): a tier with `debounceMs > 0` buffers entries
-			// in its own `pending` and has NO internal flush timer; the
-			// per-wave auto-flush path is suppressed for it and `attachStorage`
-			// never calls `flush()` itself → without a driver it buffers
-			// forever (silent data loss on teardown). Drive each debounced
-			// tier's `flush()` from a reactive timer (spec §5.8 no-polling /
-			// §5.10 no raw setTimeout — `fromTimer` is the sanctioned reactive
-			// timer source; `flush()` is the IO-sink boundary, fire-and-forget
-			// with catch, mirroring the per-wave appendEntries pattern above).
-			const timerUnsubs: Array<() => void> = [];
-			for (const tier of tiers) {
-				const d = tier.debounceMs ?? 0;
-				if (d <= 0 || typeof tier.flush !== "function") continue;
-				const ticks = fromTimer(d, { period: d });
-				const tsub = ticks.subscribe((msgs) => {
-					for (const m of msgs) {
-						if (m[0] !== DATA) continue;
-						try {
-							const r = tier.flush?.();
-							if (r instanceof Promise) r.catch(() => {});
-						} catch {
-							/* flush error swallowed; surfaced via explicit flush() */
-						}
-					}
-				});
-				timerUnsubs.push(tsub);
-			}
-			return () => {
-				sub();
-				for (const u of timerUnsubs) u();
-				// Final best-effort drain so the last buffered debounce window
-				// isn't lost on teardown (disposer is sync; the flush() promise
-				// is fire-and-forget — graph async-dispose awaits via its own
-				// storage-disposer path, see Graph.destroyAsync).
-				for (const tier of tiers) {
-					if ((tier.debounceMs ?? 0) <= 0 || typeof tier.flush !== "function") {
-						continue;
-					}
-					try {
-						const r = tier.flush();
-						if (r instanceof Promise) r.catch(() => {});
-					} catch {
-						/* swallowed */
-					}
-				}
-			};
-		},
-
-		scan<TAcc>(initial: TAcc, step: (acc: TAcc, value: T) => TAcc): Node<TAcc> {
-			let acc = initial;
-			let lastProcessedSize = 0;
-			return node<TAcc>([entries], (data, actions, ctx) => {
-				// `data[0]` is the BATCH of `entries` snapshots emitted this
-				// wave (`NodeFn` contract), not a single snapshot. Unwrap to
-				// the latest snapshot; fall back to `ctx.prevData[0]` when the
-				// wave carried no new DATA (`undefined` = entries never
-				// emitted → empty-log branch).
-				const batch = data[0];
-				const arr = (
-					batch !== undefined && batch.length > 0 ? batch[batch.length - 1] : ctx.prevData[0]
-				) as readonly T[] | null | undefined;
-				if (arr == null || arr.length === 0) {
-					// Log cleared or empty — reset accumulator.
-					acc = initial;
-					lastProcessedSize = 0;
-					actions.emit(acc);
-					return;
-				}
-				const currentSize = arr.length;
-				if (currentSize < lastProcessedSize) {
-					// Log was trimmed/cleared — full rescan.
-					acc = initial;
-					for (let i = 0; i < currentSize; i++) {
-						acc = step(acc, arr[i]!);
-					}
-					lastProcessedSize = currentSize;
-				} else {
-					// Incremental — apply only new entries.
-					for (let i = lastProcessedSize; i < currentSize; i++) {
-						acc = step(acc, arr[i]!);
-					}
-					lastProcessedSize = currentSize;
-				}
-				actions.emit(acc);
-			});
-		},
-
-		mutationLog: mutLog,
-
-		disposeAllViews(): void {
-			for (const entry of tailCache.values()) entry.dispose();
-			tailCache.clear();
-			for (const entry of sliceCache.values()) entry.dispose();
-			sliceCache.clear();
-			for (const entry of cursorCache.values()) entry.dispose();
-			cursorCache.clear();
-		},
-
-		dispose(): void {
-			for (const entry of tailCache.values()) entry.dispose();
-			tailCache.clear();
-			for (const entry of sliceCache.values()) entry.dispose();
-			sliceCache.clear();
-			for (const entry of cursorCache.values()) entry.dispose();
-			cursorCache.clear();
-			if (mutLog) mutLog.dispose();
-		},
-	};
-
-	return bundle;
-}
-
-// ── mergeReactiveLogs ─────────────────────────────────────────────────────
-
-/**
- * Bundle returned by {@link mergeReactiveLogs}. `node` is the merged output;
- * `dispose()` releases the internal subscriptions to all input logs and the
- * keepalive on `node`. After dispose the merge stops responding to inputs
- * but `node`'s last cached value remains queryable.
- *
- * @category extra
- */
-export interface MergedReactiveLog<T> {
-	readonly node: Node<readonly T[]>;
-	dispose(): void;
-}
-
-const mergeMemo = new WeakMap<readonly Node<readonly unknown[]>[], MergedReactiveLog<unknown>>();
-
-/**
- * Fan-in helper that merges N reactive logs into a single time-ordered output
- * by concatenation. Returns `{ node, dispose }`. Producer-pattern: subscribes
- * to each input internally; COMPLETE on an input drops it from the active
- * set; ERROR propagates per spec §2.2. Memoized by reference identity on the
- * `logs` array — repeat calls with the same reference return the same bundle.
- *
- * Internal subscriptions are invisible in `describe()` (sanctioned per §24);
- * `explain()` across the merge surfaces only the merged stream. Caller must
- * `dispose()` when done to release subscriptions to input logs (no auto-GC
- * because of the memoization map).
- *
- * @category extra
- */
-export function mergeReactiveLogs<T>(logs: readonly Node<readonly T[]>[]): MergedReactiveLog<T> {
-	const cached = mergeMemo.get(logs as unknown as readonly Node<readonly unknown[]>[]);
-	if (cached) return cached as unknown as MergedReactiveLog<T>;
-
-	const seedSnapshots = logs.map((n) => (n.cache as readonly T[] | undefined) ?? []);
-	const initial = seedSnapshots.flat() as readonly T[];
-
-	// Use a producer-pattern derived: we subscribe to inputs internally (not
-	// declared as deps) to keep the merge invisible to describe per Audit 1 #4.
-	const out = node<readonly T[]>([], {
-		initial,
-		name: "mergeReactiveLogs",
-		describeKind: "state",
-		equals: (a, b) => a === b,
-	});
-
-	const lastBuckets: T[][] = logs.map((_, i) => [...(seedSnapshots[i] ?? [])]);
-	// Per-input subscription handles. `subs[idx] = undefined` after COMPLETE so
-	// dispose() iterates only live subscriptions and a stray DATA from an
-	// already-completed input is impossible (the sub is gone).
-	const subs: Array<(() => void) | undefined> = [];
-	for (let i = 0; i < logs.length; i++) {
-		const idx = i;
-		const sub = logs[idx]!.subscribe((msgs) => {
-			for (const m of msgs) {
-				if (m[0] === DATA) {
-					lastBuckets[idx] = [...(m[1] as readonly T[])];
-					out.emit(lastBuckets.flat());
-				} else if (m[0] === COMPLETE) {
-					// Drop the input from the active set: clear its bucket AND
-					// release the subscription so any post-COMPLETE DATA from
-					// the (misbehaving) input cannot reach the merged stream.
-					lastBuckets[idx] = [];
-					const u = subs[idx];
-					if (u !== undefined) {
-						subs[idx] = undefined;
-						u();
-					}
-				} else if (m[0] === ERROR) {
-					out.down([[ERROR, m[1]]]);
-				}
-			}
-		});
-		subs.push(sub);
-	}
-	const keepDispose = keepalive(out);
-
-	let disposed = false;
-	const bundle: MergedReactiveLog<T> = {
-		node: out as Node<readonly T[]>,
-		dispose() {
-			if (disposed) return;
-			disposed = true;
-			for (const u of subs) u?.();
-			subs.length = 0;
-			keepDispose();
-			mergeMemo.delete(logs as unknown as readonly Node<readonly unknown[]>[]);
-		},
-	};
-
-	mergeMemo.set(
-		logs as unknown as readonly Node<readonly unknown[]>[],
-		bundle as MergedReactiveLog<unknown>,
-	);
-	return bundle;
-}
diff --git a/packages/pure-ts/src/extra/data-structures/reactive-map.ts b/packages/pure-ts/src/extra/data-structures/reactive-map.ts
deleted file mode 100644
index 966add6a..00000000
--- a/packages/pure-ts/src/extra/data-structures/reactive-map.ts
+++ /dev/null
@@ -1,765 +0,0 @@
-/**
- * Reactive key–value map (roadmap §3.2) — emits `ReadonlyMap` snapshots directly.
- *
- * Internal version counter drives efficient equality without leaking `Versioned`
- * into the public API (spec §5.12).
- *
- * **Wave 4 refactor (2026-04-15):** Introduces the `MapBackend<K, V>` pluggable-backend
- * interface. The default `NativeMapBackend` owns LRU ordering, TTL expiry, and a
- * monotonic `version` counter. Reads that discover expired entries prune them and
- * emit (fixes the former `size`-getter stale-snapshot gap).
- */
-import { batch } from "../../core/batch.js";
-import { monotonicNs, wallClockNs } from "../../core/clock.js";
-import { DATA, DIRTY } from "../../core/messages.js";
-import { type Node, type NodeOptions, node } from "../../core/node.js";
-import type { VersioningLevel } from "../../core/versioning.js";
-import type { MapChange, MapChangePayload } from "./change.js";
-import { type ReactiveLogBundle, reactiveLog } from "./reactive-log.js";
-
-export type ReactiveMapOptions<K, V> = {
-	/** Optional registry name for `describe()` / debugging. */
-	name?: string;
-	/**
-	 * LRU cap. When set, evicts least-recently-used keys after inserts that exceed this size.
-	 * Forwarded to the default `NativeMapBackend`. Ignored if a custom `backend` is provided.
-	 *
-	 * **Mutually exclusive with `retention`** — the LRU cap is "youngest-access wins,"
-	 * score-based retention is "highest-score wins." Configuring both would make
-	 * eviction nondeterministic; construction throws if both are set.
-	 */
-	maxSize?: number;
-	/**
-	 * Default TTL in seconds. Used when `set`/`setMany` omits per-call `ttl`.
-	 * Forwarded to the default `NativeMapBackend`. Ignored if a custom `backend` is provided.
-	 */
-	defaultTtl?: number;
-	/**
-	 * Storage backend. Defaults to `NativeMapBackend`. Users can plug in persistent
-	 * (HAMT / Immutable.js) or shared-state backends via the {@link MapBackend} interface.
-	 */
-	backend?: MapBackend<K, V>;
-	/**
-	 * Optional versioning level for the underlying `entries` state node. Set at
-	 * construction time; cannot be changed later. Pass `0` for V0 identity +
-	 * monotonic version counter, or `1` for V1 + content-addressed cid.
-	 */
-	versioning?: VersioningLevel;
-	/**
-	 * Score-based retention policy. After every mutation, each live entry is
-	 * scored; entries below `archiveThreshold` and / or over `maxSize` (lowest-
-	 * scored first) are archived via `onArchive` before being removed.
-	 *
-	 * Retention replaces the ad-hoc "tierClassifier effect writing back to its
-	 * own store dep" pattern — the feedback cycle is gone because archival is
-	 * part of the atomic mutation, not a second reactive wave.
-	 *
-	 * Mutually exclusive with top-level `maxSize` (LRU). Pass one or the other.
-	 */
-	retention?: ReactiveMapRetention<K, V>;
-	/**
-	 * Enable the `mutationLog` delta companion log. When set, every mutation
-	 * appends a typed `MapChange<K, V>` record in the same batch frame as
-	 * the snapshot emission (same-wave consistency).
-	 *
-	 * - `true` — creates a log with default options.
-	 * - `{ maxSize?, name? }` — forwards to the inner `reactiveLog`.
-	 */
-	mutationLog?: true | { maxSize?: number; name?: string };
-} & Omit<NodeOptions, "initial" | "describeKind" | "equals" | "versioning">;
-
-/**
- * Score-based retention policy for {@link reactiveMap}. Evaluated synchronously
- * on every successful mutation (`set` / `setMany` / `delete` / `clear` /
- * `pruneExpired`). Entries are archived in ascending score order until the
- * map satisfies both constraints:
- *
- * 1. Every remaining entry has `score >= archiveThreshold` (if set).
- * 2. Total entry count `<= maxSize` (if set).
- *
- * At least one of `archiveThreshold` / `maxSize` must be set; otherwise there's
- * no eviction trigger.
- *
- * **Archival order.** When multiple entries are candidates for archival in the
- * same mutation, they are archived in ascending score order (lowest first). On
- * score ties, iteration order (insertion order in the default backend) is the
- * tiebreak.
- *
- * **No recursion.** Archival deletes happen on the backend directly — they do
- * NOT re-enter the retention evaluator. The one-pass scan collects archival
- * candidates against the post-mutation snapshot before removing them.
- *
- * @category extra
- */
-export type ReactiveMapRetention<K, V> = {
-	/** Score entry — higher is kept. Should be a pure function of `(key, value)`. */
-	score: (key: K, value: V) => number;
-	/** Below-threshold entries are archived. Omit for pure `maxSize`-based retention. */
-	archiveThreshold?: number;
-	/**
-	 * Cap on live entry count. Over this, the lowest-scored entries are
-	 * archived until the size fits. Omit for pure threshold-based retention.
-	 */
-	maxSize?: number;
-	/**
-	 * Synchronous callback fired **before** archival deletion. Receives the
-	 * key, value, and computed score. Callers typically persist the entry to
-	 * a cold tier here (`await permanent.set(key, value)` — async is fine but
-	 * the archival deletion happens synchronously after this callback
-	 * returns).
-	 */
-	onArchive?: (key: K, value: V, score: number) => void;
-};
-
-export type ReactiveMapBundle<K, V> = {
-	/** Emits `ReadonlyMap<K, V>` on each structural change (two-phase). */
-	entries: Node<ReadonlyMap<K, V>>;
-	/**
-	 * Checks existence. O(1) for live keys. If the key is expired, prunes it AND
-	 * emits a snapshot so the reactive surface stays consistent with the return
-	 * value. Reads on expired keys are therefore **observable side effects**.
-	 *
-	 * **LRU touch (F4):** When `maxSize` is configured, a live-key `has` also
-	 * marks the entry as most-recently-used — which rearranges internal insertion
-	 * order without bumping `version` or emitting. If you care about iteration
-	 * order in a downstream subscriber, rely on the `entries` snapshot (a fresh
-	 * `ReadonlyMap` per mutation) rather than iterating the backend directly.
-	 */
-	has: (key: K) => boolean;
-	/**
-	 * Gets value. O(1) for live keys. If the key is expired, prunes it AND emits
-	 * a snapshot. Reads on expired keys are therefore **observable side effects**.
-	 *
-	 * **LRU touch (F4):** When `maxSize` is configured, a live-key `get` also
-	 * marks the entry as most-recently-used (no version bump, no emission). See
-	 * `has` for the full note on iteration order.
-	 */
-	get: (key: K) => V | undefined;
-	/**
-	 * Sets value with optional TTL (seconds). Throws on `ttl <= 0`. Applies LRU eviction
-	 * if `maxSize` is set. Always emits.
-	 */
-	set: (key: K, value: V, opts?: { ttl?: number }) => void;
-	/**
-	 * Bulk set — emits one snapshot for the whole batch. Applies `opts.ttl` (falls back
-	 * to `defaultTtl`) to every entry. No-op if `entries` is empty.
-	 *
-	 * **Iterable consumption:** Consumes `entries` once (single-pass). Pass an array
-	 * or `Set` for multi-shot consumers. If the iterator throws mid-iteration,
-	 * entries already applied remain committed and a snapshot IS emitted (via the
-	 * wrapper's finally-block).
-	 */
-	setMany: (entries: Iterable<readonly [K, V]>, opts?: { ttl?: number }) => void;
-	delete: (key: K) => void;
-	/**
-	 * Bulk delete — emits one snapshot. No-op if no keys were present.
-	 *
-	 * **Iterable consumption:** Consumes `keys` once (single-pass).
-	 */
-	deleteMany: (keys: Iterable<K>) => void;
-	clear: () => void;
-	/**
-	 * Current entry count — O(1), **pure read** (no emission). May include
-	 * expired entries on TTL maps until a mutation or explicit
-	 * `pruneExpired()` / `has(key)` / `get(key)` prunes them. Call
-	 * `pruneExpired()` first if you need a live count.
-	 */
-	readonly size: number;
-	/** Explicitly prunes all expired entries. Emits if any were removed. */
-	pruneExpired: () => void;
-	/**
-	 * Delta companion log. Present iff `mutationLog` option was configured.
-	 * Each mutation appends a typed `MapChange<K, V>` record in the same
-	 * batch frame as the snapshot emission (same-wave consistency).
-	 */
-	readonly mutationLog?: ReactiveLogBundle<MapChange<K, V>>;
-	/**
-	 * Releases any internal keepalive subscriptions so the bundle can be
-	 * GC'd. `reactiveMap` currently holds none (the `entries` node lives only
-	 * as long as external subscribers keep it alive), so `dispose()` is a
-	 * no-op today — exposed for API parity with `reactiveIndex.dispose` /
-	 * `reactiveList.dispose` / `reactiveLog.dispose`. Idempotent. D6(a).
-	 */
-	dispose: () => void;
-};
-
-// ── Backend interface ─────────────────────────────────────────────────────
-
-/**
- * Storage contract for {@link reactiveMap}. Implementations own the mutable state,
- * including optional TTL and LRU semantics, and expose a monotonic `version` counter
- * that increments on every change to visible state.
- *
- * The reactive layer reads `version` before and after each backend call; when it
- * advances, a snapshot is emitted. Reads (`has`, `get`) may internally prune the
- * target key if expired and advance `version` — in which case the layer emits so
- * subscribers see state consistent with the read's return value.
- *
- * @remarks Post-1.0 op-log changesets will extend this interface with a
- * `changesSince(version: number): Iterable<Change>` method. Current consumers
- * should treat all methods here as stable.
- *
- * @category extra
- */
-export interface MapBackend<K, V> {
-	/** Monotonic mutation counter; increments on every visible state change. */
-	readonly version: number;
-	/** Raw entry count (may include expired entries until a read / prune removes them). */
-	readonly size: number;
-	/** Checks existence. May prune target key if expired; advances `version` if pruned. */
-	has(key: K): boolean;
-	/** Gets value. May prune target key if expired; advances `version` if pruned. */
-	get(key: K): V | undefined;
-	/**
-	 * Sets a value with optional TTL (seconds). Throws `RangeError` if `ttl <= 0`.
-	 * Applies LRU eviction if `maxSize` is configured. Advances `version`.
-	 *
-	 * **Atomicity contract:** Either fully succeeds or throws before any state
-	 * change; `version` advances only on success.
-	 */
-	set(key: K, value: V, ttl?: number): void;
-	/**
-	 * Atomic bulk set. Pre-validates TTL once, then applies all entries. Advances
-	 * `version` at most once (even for N entries). No-op if iterable is empty.
-	 *
-	 * **Consumes `entries` once** — pass an array if you want repeatability.
-	 *
-	 * **Atomicity contract:** TTL validation throws before any mutation. If the
-	 * iterable itself throws mid-iteration, entries committed before the throw
-	 * remain persisted AND `version` is bumped once (surfaced via finally) so
-	 * the reactive wrapper emits a snapshot reflecting the partial state. "At
-	 * most once" invariant is preserved.
-	 */
-	setMany(entries: Iterable<readonly [K, V]>, ttl?: number): void;
-	/** Removes a key. Returns `true` if the key existed. Advances `version` only if true. */
-	delete(key: K): boolean;
-	/**
-	 * Atomic bulk delete. Returns count removed. Advances `version` at most once
-	 * (even for N keys). No-op if no keys were present. Consumes `keys` once.
-	 */
-	deleteMany(keys: Iterable<K>): number;
-	/** Removes all entries. Returns count removed. Advances `version` only if non-zero. */
-	clear(): number;
-	/** Removes all expired entries. Returns count removed. Advances `version` only if non-zero. */
-	pruneExpired(): number;
-	/** Fresh snapshot of non-expired entries (does NOT mutate state). */
-	toMap(): ReadonlyMap<K, V>;
-	/**
-	 * DS14R1 — drains internal-prune change records (TTL-expiry, LRU-eviction)
-	 * buffered since the last drain, resetting the buffer. The reactive wrapper
-	 * calls this on every `version` advance and folds the records into
-	 * `mutationLog` so the delta stream stays in sync with `entries` snapshots.
-	 *
-	 * Optional. Backends that don't track internal prunes — custom backends, or
-	 * {@link NativeMapBackend} when `mutationLog` was not configured — omit it
-	 * (or return an empty iterable). Without it, `mutationLog` is missing
-	 * `reason:"expired"|"lru-evict"` delete records on read-time TTL prune / LRU
-	 * eviction (the prunes still apply correctly to `entries`; only the delta
-	 * stream desyncs). Same optionality posture as the post-1.0 `changesSince`.
-	 */
-	drainPruneRecords?(): Iterable<MapChangePayload<K, V>>;
-}
-
-export type NativeMapBackendOptions = {
-	maxSize?: number;
-	/** Default TTL in seconds. */
-	defaultTtl?: number;
-	/**
-	 * DS14R1 — when `true`, buffer `{kind:"delete",reason:"expired"|"lru-evict"}`
-	 * records on internal TTL prune / LRU eviction so {@link drainPruneRecords}
-	 * can hand them to the reactive layer's `mutationLog`. Default `false` — the
-	 * reactive wrapper enables it only when `mutationLog` is configured, so maps
-	 * without a delta companion pay zero buffering cost.
-	 */
-	trackPrunes?: boolean;
-};
-
-type MapEntry<V> = { value: V; expiresAt?: number };
-
-/**
- * Default `Map<K, {value, expiresAt}>` backend with optional per-key TTL and LRU cap.
- *
- * **Complexity:**
- * - `has`, `get`, `delete`, `size`: O(1)
- * - `set`: O(1) amortized (LRU touch + eviction)
- * - `pruneExpired`, `toMap`: O(n)
- *
- * LRU order uses native `Map` insertion order. `get` / `has` on a live key "touches"
- * it by delete-then-reinsert (moving it to the end). This touch does NOT advance
- * `version` — it's an internal optimization; the externally visible snapshot
- * preserves iteration order as of the last mutation. **Note:** because touch
- * reorders the internal `_store` without emitting, an in-process consumer iterating
- * `_store` directly (custom subclasses) could observe changing order; external
- * subscribers only see `toMap()` snapshots which are defensively copied and stable.
- *
- * @category extra
- */
-export class NativeMapBackend<K, V> implements MapBackend<K, V> {
-	private _version = 0;
-	private readonly _store = new Map<K, MapEntry<V>>();
-	private readonly _maxSize?: number;
-	private readonly _defaultTtl?: number;
-	private readonly _trackPrunes: boolean;
-	/** DS14R1 — internal-prune change buffer; drained by {@link drainPruneRecords}. */
-	private _pruneBuf: MapChangePayload<K, V>[] = [];
-
-	constructor(options: NativeMapBackendOptions = {}) {
-		const { maxSize, defaultTtl, trackPrunes } = options;
-		if (maxSize !== undefined && maxSize < 1) {
-			throw new RangeError("maxSize must be >= 1");
-		}
-		if (defaultTtl !== undefined && defaultTtl <= 0) {
-			throw new RangeError("defaultTtl must be positive");
-		}
-		this._maxSize = maxSize;
-		this._defaultTtl = defaultTtl;
-		this._trackPrunes = trackPrunes ?? false;
-	}
-
-	get version(): number {
-		return this._version;
-	}
-
-	get size(): number {
-		return this._store.size;
-	}
-
-	has(key: K): boolean {
-		const e = this._store.get(key);
-		if (e === undefined) return false;
-		if (this._isExpired(e)) {
-			if (this._trackPrunes) {
-				this._pruneBuf.push({ kind: "delete", key, previous: e.value, reason: "expired" });
-			}
-			this._store.delete(key);
-			this._version += 1;
-			return false;
-		}
-		this._touchLru(key, e);
-		return true;
-	}
-
-	get(key: K): V | undefined {
-		const e = this._store.get(key);
-		if (e === undefined) return undefined;
-		if (this._isExpired(e)) {
-			if (this._trackPrunes) {
-				this._pruneBuf.push({ kind: "delete", key, previous: e.value, reason: "expired" });
-			}
-			this._store.delete(key);
-			this._version += 1;
-			return undefined;
-		}
-		this._touchLru(key, e);
-		return e.value;
-	}
-
-	set(key: K, value: V, ttl?: number): void {
-		const expiresAt = this._resolveExpiresAt(ttl);
-		// Delete-then-insert to place key at LRU end.
-		if (this._store.has(key)) this._store.delete(key);
-		this._store.set(key, { value, expiresAt });
-		this._evictLruWhileOver();
-		this._version += 1;
-	}
-
-	setMany(entries: Iterable<readonly [K, V]>, ttl?: number): void {
-		// Pre-validate TTL once (throws before any mutation).
-		const expiresAt = this._resolveExpiresAt(ttl);
-		let count = 0;
-		try {
-			for (const [key, value] of entries) {
-				if (this._store.has(key)) this._store.delete(key);
-				this._store.set(key, { value, expiresAt });
-				count += 1;
-			}
-		} finally {
-			// D3: if the iterable threw mid-iteration, entries committed before
-			// the throw must still advance `version` so subscribers see the
-			// partial state consistently. "At most once" is preserved.
-			if (count > 0) {
-				this._evictLruWhileOver();
-				this._version += 1;
-			}
-		}
-	}
-
-	delete(key: K): boolean {
-		const had = this._store.delete(key);
-		if (had) this._version += 1;
-		return had;
-	}
-
-	deleteMany(keys: Iterable<K>): number {
-		let removed = 0;
-		try {
-			for (const k of keys) {
-				if (this._store.delete(k)) removed += 1;
-			}
-		} finally {
-			if (removed > 0) this._version += 1;
-		}
-		return removed;
-	}
-
-	clear(): number {
-		const n = this._store.size;
-		if (n === 0) return 0;
-		this._store.clear();
-		this._version += 1;
-		return n;
-	}
-
-	pruneExpired(): number {
-		const now = monotonicNs();
-		let removed = 0;
-		for (const [k, e] of this._store) {
-			if (this._isExpired(e, now)) {
-				if (this._trackPrunes) {
-					this._pruneBuf.push({ kind: "delete", key: k, previous: e.value, reason: "expired" });
-				}
-				this._store.delete(k);
-				removed += 1;
-			}
-		}
-		if (removed > 0) this._version += 1;
-		return removed;
-	}
-
-	toMap(): ReadonlyMap<K, V> {
-		const now = monotonicNs();
-		const out = new Map<K, V>();
-		for (const [k, e] of this._store) {
-			if (!this._isExpired(e, now)) out.set(k, e.value);
-		}
-		return out;
-	}
-
-	private _resolveExpiresAt(ttl?: number): number | undefined {
-		const effectiveTtl = ttl ?? this._defaultTtl;
-		if (effectiveTtl === undefined) return undefined;
-		if (!Number.isFinite(effectiveTtl) || effectiveTtl <= 0) {
-			throw new RangeError(
-				`MapBackend: ttl must be a positive finite number (got ${effectiveTtl})`,
-			);
-		}
-		return monotonicNs() + effectiveTtl * 1_000_000_000;
-	}
-
-	private _isExpired(e: MapEntry<V>, now?: number): boolean {
-		if (e.expiresAt === undefined) return false;
-		return (now ?? monotonicNs()) >= e.expiresAt;
-	}
-
-	private _touchLru(key: K, entry: MapEntry<V>): void {
-		// Move to LRU end. Does NOT advance `version` — internal optimization.
-		this._store.delete(key);
-		this._store.set(key, entry);
-	}
-
-	private _evictLruWhileOver(): void {
-		if (this._maxSize === undefined) return;
-		while (this._store.size > this._maxSize) {
-			const first = this._store.keys().next().value as K | undefined;
-			if (first === undefined) break;
-			if (this._trackPrunes) {
-				const e = this._store.get(first);
-				if (e !== undefined) {
-					this._pruneBuf.push({
-						kind: "delete",
-						key: first,
-						previous: e.value,
-						reason: "lru-evict",
-					});
-				}
-			}
-			this._store.delete(first);
-		}
-	}
-
-	/**
-	 * DS14R1 — returns and clears the internal-prune buffer (TTL-expiry +
-	 * LRU-eviction records accumulated since the last drain). Returns an empty
-	 * array when `trackPrunes` is off (the reactive wrapper still calls it
-	 * unconditionally; the cost is one empty-array allocation).
-	 */
-	drainPruneRecords(): Iterable<MapChangePayload<K, V>> {
-		if (this._pruneBuf.length === 0) return [];
-		const out = this._pruneBuf;
-		this._pruneBuf = [];
-		return out;
-	}
-}
-
-// ── Reactive wrapper ──────────────────────────────────────────────────────
-
-/**
- * Creates a reactive `Map` with optional per-key TTL and optional LRU max size.
- *
- * @param options - `name`, `maxSize`, `defaultTtl` (seconds), or custom `backend`.
- * @returns `ReactiveMapBundle` — imperative methods (`has`/`get`/`set`/`setMany`/`delete`/
- *   `deleteMany`/`clear`/`pruneExpired`), reactive `entries` node, and O(1)-ish `size`.
- *
- * @remarks
- * **TTL:** Expiry is checked on `get`, `has`, `size`, `pruneExpired`, and before each
- * snapshot emission (expired keys are pruned first). Reads that discover expired keys
- * emit a snapshot so subscribers see state consistent with the read's return value.
- * There is no background timer; monotonic-clock expiry is immune to wall-clock changes.
- *
- * **LRU:** Uses native `Map` insertion order — `get` / `has` refreshes position via
- * delete-then-reinsert; under `maxSize` pressure the first key in iteration order is
- * evicted. LRU touching does NOT trigger emission (internal optimization).
- *
- * **Backend:** The default {@link NativeMapBackend} owns LRU/TTL. For persistent /
- * HAMT / shared-state semantics plug in a custom {@link MapBackend}. `maxSize` and
- * `defaultTtl` on the options object are only applied to the default backend — if
- * you supply `backend`, configure those on your backend directly.
- *
- * @example
- * ```ts
- * import { reactiveMap } from "@graphrefly/pure-ts";
- *
- * const m = reactiveMap<string, number>({ name: "cache", maxSize: 100, defaultTtl: 60 });
- * m.set("x", 1);
- * m.setMany([["y", 2], ["z", 3]]);
- * m.entries.subscribe((msgs) => { console.log(msgs); });
- * ```
- *
- * @category extra
- */
-export function reactiveMap<K, V>(options: ReactiveMapOptions<K, V> = {}): ReactiveMapBundle<K, V> {
-	const {
-		name,
-		maxSize,
-		defaultTtl,
-		versioning,
-		backend: userBackend,
-		retention,
-		mutationLog: mutLogOpt,
-	} = options;
-	if (retention && maxSize !== undefined) {
-		throw new RangeError(
-			"reactiveMap: `maxSize` (LRU) and `retention` (score-based) are mutually exclusive. Pick one eviction policy.",
-		);
-	}
-	if (retention && retention.archiveThreshold === undefined && retention.maxSize === undefined) {
-		throw new RangeError(
-			"reactiveMap: `retention` requires at least one of `archiveThreshold` or `maxSize` to trigger archival.",
-		);
-	}
-	const backend: MapBackend<K, V> =
-		userBackend ??
-		new NativeMapBackend<K, V>({ maxSize, defaultTtl, trackPrunes: mutLogOpt != null });
-
-	// ── Mutation log companion (Phase 14.3) ──────────────────────────────────
-	const mutLog: ReactiveLogBundle<MapChange<K, V>> | undefined = mutLogOpt
-		? reactiveLog<MapChange<K, V>>(undefined, {
-				name: mutLogOpt === true ? (name ? `${name}.mutationLog` : undefined) : mutLogOpt.name,
-				maxSize: mutLogOpt === true ? undefined : mutLogOpt.maxSize,
-			})
-		: undefined;
-	let mutVersion = 0;
-	let pendingChanges: MapChangePayload<K, V>[] = [];
-	function enqueueChange(payload: MapChangePayload<K, V>): void {
-		if (!mutLog) return;
-		pendingChanges.push(payload);
-	}
-
-	const n = node<ReadonlyMap<K, V>>([], {
-		initial: backend.toMap(),
-		name,
-		describeKind: "state",
-		equals: (a, b) => a === b,
-		...(versioning != null ? { versioning } : {}),
-	});
-
-	function pushSnapshot(): void {
-		const map = backend.toMap();
-		const changes = pendingChanges;
-		pendingChanges = [];
-		batch(() => {
-			n.down([[DIRTY]]);
-			n.down([[DATA, map]]);
-			for (const c of changes) {
-				mutLog!.append({
-					structure: "map",
-					version: ++mutVersion,
-					t_ns: wallClockNs(),
-					lifecycle: "data",
-					change: c,
-				});
-			}
-		});
-	}
-
-	/**
-	 * Run score-based retention over the current live entries. Called right
-	 * before snapshot emission so subscribers see the final post-archival
-	 * state in a single wave. Archived entries fire `onArchive` synchronously
-	 * before deletion. Does not recurse — archival deletions bypass
-	 * `wrapMutation` / retention.
-	 */
-	function applyRetention(): void {
-		if (!retention) return;
-		const live = backend.toMap();
-		const threshold = retention.archiveThreshold;
-		const cap = retention.maxSize;
-		const scored: Array<{ key: K; value: V; score: number }> = [];
-		for (const [key, value] of live) {
-			scored.push({ key, value, score: retention.score(key, value) });
-		}
-		// Ascending score — lowest first, archived first.
-		scored.sort((a, b) => a.score - b.score);
-		const archiveSet = new Set<K>();
-		// 1) Threshold: archive anything below.
-		if (threshold !== undefined) {
-			for (const s of scored) {
-				if (s.score < threshold) archiveSet.add(s.key);
-				else break; // scored is ascending — first >= threshold ends the sweep.
-			}
-		}
-		// 2) maxSize: archive additional lowest-scored entries until under cap.
-		if (cap !== undefined && scored.length - archiveSet.size > cap) {
-			for (const s of scored) {
-				if (scored.length - archiveSet.size <= cap) break;
-				if (!archiveSet.has(s.key)) archiveSet.add(s.key);
-			}
-		}
-		if (archiveSet.size === 0) return;
-		for (const s of scored) {
-			if (!archiveSet.has(s.key)) continue;
-			retention.onArchive?.(s.key, s.value, s.score);
-			backend.delete(s.key);
-			enqueueChange({ kind: "delete", key: s.key, previous: s.value, reason: "archived" });
-		}
-	}
-
-	/**
-	 * Defense-in-depth emission guard: compares `version` before/after `op` and
-	 * emits a snapshot if advanced. Uses `try/finally` so partial-mutation state
-	 * from a custom non-atomic backend is still surfaced to subscribers if the
-	 * op throws mid-way (native backends are atomic by contract and won't trip
-	 * this path).
-	 *
-	 * `kind` gates retention: `"mutation"` paths (set/setMany/delete/…) run
-	 * retention eviction; `"read"` paths (has/get) do NOT — a pure read that
-	 * happens to prune an expired TTL entry should emit a consistency
-	 * snapshot, but should NOT fire `onArchive` side-effects for unrelated
-	 * low-scored entries. Users reading a TTL map expect read-time expiry
-	 * pruning; they do NOT expect a `.get(x)` call to archive key `y`.
-	 *
-	 * **Distinguish from `mutate` in `src/extra/mutation/index.ts`:**
-	 * that factory is the public Phase-4 audit framework — orchestration-tier
-	 * batch + freeze + audit-record stamping. This `wrapMutation` is a file-
-	 * private snapshot-delivery guard for the reactiveMap version counter.
-	 * Different concern.
-	 */
-	function wrapMutation<T>(op: () => T, kind: "mutation" | "read" = "mutation"): T {
-		const prev = backend.version;
-		try {
-			return op();
-		} finally {
-			if (backend.version !== prev) {
-				// DS14R1: fold backend-internal prunes (TTL-expiry / LRU-evict)
-				// into the same wave's change set BEFORE retention + snapshot, so
-				// `mutationLog` replays to exactly the emitted `entries` state.
-				// `enqueueChange` no-ops when no `mutationLog` is configured.
-				if (backend.drainPruneRecords) {
-					for (const rec of backend.drainPruneRecords()) enqueueChange(rec);
-				}
-				if (kind === "mutation") applyRetention();
-				pushSnapshot();
-			} else {
-				pendingChanges.length = 0;
-			}
-		}
-	}
-
-	return {
-		entries: n,
-
-		has(key: K): boolean {
-			return wrapMutation(() => backend.has(key), "read");
-		},
-
-		get(key: K): V | undefined {
-			return wrapMutation(() => backend.get(key), "read");
-		},
-
-		set(key: K, value: V, opts?: { ttl?: number }): void {
-			wrapMutation(() => {
-				backend.set(key, value, opts?.ttl);
-				enqueueChange({ kind: "set", key, value });
-			});
-		},
-
-		setMany(entries: Iterable<readonly [K, V]>, opts?: { ttl?: number }): void {
-			wrapMutation(() => {
-				// Materialize so we can emit per-entry changes.
-				const arr = Array.isArray(entries) ? entries : [...entries];
-				backend.setMany(arr, opts?.ttl);
-				for (const [k, v] of arr) enqueueChange({ kind: "set", key: k, value: v });
-			});
-		},
-
-		delete(key: K): void {
-			wrapMutation(() => {
-				const previous = backend.get(key);
-				const removed = backend.delete(key);
-				if (removed && previous !== undefined) {
-					enqueueChange({ kind: "delete", key, previous, reason: "explicit" });
-				}
-			});
-		},
-
-		deleteMany(keys: Iterable<K>): void {
-			wrapMutation(() => {
-				const arr = Array.isArray(keys) ? keys : [...keys];
-				// Capture previous values before deletion.
-				const prevs: Array<{ key: K; previous: V }> = [];
-				for (const k of arr) {
-					const v = backend.get(k);
-					if (v !== undefined) prevs.push({ key: k, previous: v });
-				}
-				backend.deleteMany(arr);
-				for (const p of prevs) {
-					enqueueChange({ kind: "delete", key: p.key, previous: p.previous, reason: "explicit" });
-				}
-			});
-		},
-
-		clear(): void {
-			wrapMutation(() => {
-				const count = backend.clear();
-				if (count > 0) enqueueChange({ kind: "clear", count });
-			});
-		},
-
-		pruneExpired(): void {
-			wrapMutation(() => backend.pruneExpired());
-		},
-
-		/**
-		 * Current raw entry count — O(1), **pure read**. May include
-		 * not-yet-pruned expired entries on TTL maps until the next mutation
-		 * or an explicit `pruneExpired()` / `has` / `get` triggers a prune.
-		 *
-		 * Previously this getter ran `pruneExpired()` inline and emitted a
-		 * snapshot as a side effect — that violated spec §5.8 "no
-		 * side-effectful reads" and created a re-entrancy hazard when a
-		 * subscriber to `entries` read `.size` from its own callback. D2(a).
-		 *
-		 * For a live count that excludes expired entries, call
-		 * `bundle.pruneExpired()` first.
-		 */
-		get size(): number {
-			return backend.size;
-		},
-
-		mutationLog: mutLog,
-
-		dispose(): void {
-			if (mutLog) mutLog.dispose();
-		},
-	};
-}
diff --git a/packages/pure-ts/src/extra/index.ts b/packages/pure-ts/src/extra/index.ts
deleted file mode 100644
index 14c0092d..00000000
--- a/packages/pure-ts/src/extra/index.ts
+++ /dev/null
@@ -1,55 +0,0 @@
-/**
- * Extra layer — substrate-only universal barrel (cleave A2+A3, 2026-05-14).
- *
- * After the cleave, @graphrefly/pure-ts/extra exports substrate-only APIs
- * that are browser + Node safe (no `node:*` builtins, no DOM globals):
- * - operators (protocol-level transforms)
- * - data-structures (reactiveMap, reactiveList, reactiveLog, reactiveIndex)
- * - storage/core (StorageHandle, jsonCodec, etc.)
- * - storage/tiers (memoryBackend, memorySnapshot, memoryKv, memoryAppendLog)
- * - storage/wal (walFrameChecksum, etc.)
- * - storage/cascading-cache (cascadingCache)
- * - storage/content-addressed (contentAddressedStorage, canonicalJson)
- * - composition/stratify (reactive branch routing)
- * - composition/topology-diff (topologyDiff, DescribeChangeset)
- * - sources/sync (fromIter, of, empty, never, throwError)
- * - sources/event/timer (fromTimer)
- * - sources/async (fromPromise, fromAsyncIter, fromAny)
- * - sources/_keepalive (keepalive)
- * - sources/_internal types (NodeInput, AsyncSourceOpts)
- *
- * pubsub moved to @graphrefly/graphrefly/base/composition (cleave A3 — no
- * substrate core/graph dependency found; presentation-layer placement confirmed).
- *
- * Node-only APIs: @graphrefly/pure-ts/extra/node (file/sqlite storage tiers)
- * Browser-only APIs: @graphrefly/pure-ts/extra/browser (IndexedDB storage tiers)
- * Presentation APIs: @graphrefly/graphrefly (root src/)
- */
-
-// Composition — substrate only (stratify + topology-diff)
-export * from "./composition/stratify.js";
-export * from "./composition/topology-diff.js";
-// Data structures — substrate
-export * from "./data-structures/index.js";
-// Operators — substrate
-export * from "./operators/index.js";
-export {
-	type AsyncSourceOpts,
-	escapeRegexChar,
-	globToRegExp,
-	matchesAnyPattern,
-	type NodeInput,
-	sourceOpts,
-} from "./sources/_internal.js";
-export * from "./sources/_keepalive.js";
-export * from "./sources/async.js";
-export * from "./sources/event/timer.js";
-// Sources — substrate (sync + async + timer + keepalive)
-export * from "./sources/sync/iter.js";
-export * from "./storage/cascading-cache.js";
-export * from "./storage/content-addressed.js";
-// Storage — substrate (universal: core + memory tiers + WAL + cascading + content-addressed)
-// NOTE: tiers-node.js and tiers-browser.js are NOT included here (use /extra/node and /extra/browser)
-export * from "./storage/core.js";
-export * from "./storage/tiers.js";
-export * from "./storage/wal.js";
diff --git a/packages/pure-ts/src/extra/node.ts b/packages/pure-ts/src/extra/node.ts
deleted file mode 100644
index f19e36f6..00000000
--- a/packages/pure-ts/src/extra/node.ts
+++ /dev/null
@@ -1,23 +0,0 @@
-/**
- * Node-only barrel for the extra substrate surface.
- *
- * Consumers that need Node-only storage backends (`fileKv`, `sqliteKv`) import
- * from `@graphrefly/pure-ts/extra/node`. The universal `@graphrefly/pure-ts/extra`
- * entry stays browser-safe.
- *
- * Presentation-layer Node sources (fromGitHook, fromFSWatch, fromSpawn) are
- * in `@graphrefly/graphrefly/extra/node` (root shim), not here.
- *
- * @module
- */
-
-export {
-	fileAppendLog,
-	fileBackend,
-	fileKv,
-	fileSnapshot,
-	sqliteAppendLog,
-	sqliteBackend,
-	sqliteKv,
-	sqliteSnapshot,
-} from "./storage/tiers-node.js";
diff --git a/packages/pure-ts/src/extra/operators/_internal.ts b/packages/pure-ts/src/extra/operators/_internal.ts
deleted file mode 100644
index bdfafc53..00000000
--- a/packages/pure-ts/src/extra/operators/_internal.ts
+++ /dev/null
@@ -1,85 +0,0 @@
-/**
- * Internal helpers shared by operator sub-files.
- *
- * `operatorOpts` / `partialOperatorOpts` / `gatedOperatorOpts` thread the
- * correct `describeKind: "derived"` plus `partial` flag combinations through
- * every sub-file's `node()` calls so describe-graph output stays consistent.
- */
-
-import type { NodeOptions } from "../../core/node.js";
-
-export type ExtraOpts = Omit<NodeOptions<unknown>, "describeKind">;
-
-/**
- * DS-14.5 / AB-2 + AB-3 — `abortInFlight` opt shared by `valve` and the
- * `*Map` higher-order family. When the operator cancels an in-flight inner
- * (gate close for `valve`; supersede / source-ERROR / deactivation teardown
- * for `switchMap`/`exhaustMap`/`concatMap`/`mergeMap`), it fires this so the
- * underlying async boundary (e.g. an `adapter.invoke({ signal })` LLM call)
- * actually stops instead of burning tokens past the cut.
- *
- * - **Bare `AbortController`** (AB-2): the controller `valve`/`*Map` aborts
- *   on the cancel edge. One-shot — once aborted it stays aborted; re-mint
- *   for the next cycle (or use the factory form).
- * - **Factory `() => AbortController | undefined`** (AB-3): called on every
- *   cancel edge to obtain the controller to abort. Lets the caller hand the
- *   operator "the controller currently wired into the in-flight call" each
- *   cycle without re-constructing the operator — fixes the panic-toggle
- *   (open→closed→open→closed) re-mint ergonomics. Returning `undefined`
- *   (nothing in flight) is a no-op.
- */
-export type AbortInFlightOpt = AbortController | (() => AbortController | undefined);
-
-/**
- * Fires an {@link AbortInFlightOpt} on a cancel edge. Resolves the factory
- * form, skips already-aborted / absent controllers (idempotent — aborting a
- * settled request is a harmless no-op per the `AbortController` spec, so
- * callers may invoke this on every teardown without distinguishing
- * natural-completion from force-cancel).
- */
-export function fireAbortInFlight(a: AbortInFlightOpt | undefined): void {
-	if (a == null) return;
-	const ctrl = typeof a === "function" ? a() : a;
-	if (ctrl != null && !ctrl.signal.aborted) ctrl.abort();
-}
-
-export function operatorOpts<T = unknown>(opts?: ExtraOpts): NodeOptions<T> {
-	return { describeKind: "derived", ...opts } as NodeOptions<T>;
-}
-
-/**
- * Like {@link operatorOpts} but declares `partial: true` — use for operators
- * whose fn body deliberately handles partial-dep waves (fires on primary
- * alone, emits RESOLVED when a required peer is still sentinel, etc.). Opts
- * out of the core §2.7 first-run gate. User `opts.partial = false` override
- * wins via the spread, but this is rare — the gate-on default only makes
- * sense for fns that expect all deps to have delivered.
- */
-export function partialOperatorOpts<T = unknown>(opts?: ExtraOpts): NodeOptions<T> {
-	return { describeKind: "derived", partial: true, ...opts } as NodeOptions<T>;
-}
-
-/**
- * Like {@link partialOperatorOpts} but declares `partial: false` — first-run
- * gate ON. Use for operators that DO need to wait for every dep to deliver
- * real DATA before firing the first time, but want the standard derived/
- * effect "operator" describeKind for describe() output.
- *
- * Phase 10.5 (2026-04-29; `archive/docs/SESSION-graph-narrow-waist.md` §
- * "Phase 10.5"): introduced when `withLatestFrom` flipped from `partial:
- * true` to `partial: false`. The first-run gate fixes the documented W1
- * initial-pair drop without breaking post-warmup semantics (the gate is
- * `_hasCalledFnOnce === false` only — once fn fires, subsequent waves are
- * gate-free).
- *
- * **Caller override:** the spread order is `{ ..., ...opts }`, so a
- * user-supplied `opts.partial = true` silently overrides the helper's
- * default. Same shape as {@link partialOperatorOpts}'s override behavior.
- * If you want to FORCE `partial: false` on a specific operator regardless
- * of caller opts, write the helper inline at the call site (e.g.
- * `{ describeKind: "derived", ...opts, partial: false }`) so the override
- * is rejected.
- */
-export function gatedOperatorOpts<T = unknown>(opts?: ExtraOpts): NodeOptions<T> {
-	return { describeKind: "derived", partial: false, ...opts } as NodeOptions<T>;
-}
diff --git a/packages/pure-ts/src/extra/operators/buffer.ts b/packages/pure-ts/src/extra/operators/buffer.ts
deleted file mode 100644
index 56a836e7..00000000
--- a/packages/pure-ts/src/extra/operators/buffer.ts
+++ /dev/null
@@ -1,482 +0,0 @@
-/**
- * Buffer / window operators (roadmap §2.1) — group emissions into batches or
- * sub-streams.
- *
- * `buffer` (notifier-driven flush), `bufferCount` (size-driven), `bufferTime`
- * (time-driven), `window` / `windowCount` / `windowTime` (each emit a fresh
- * sub-`Node<T>` per partition).
- */
-
-import { COMPLETE, DATA, ERROR, type Messages } from "../../core/messages.js";
-import { factoryTag } from "../../core/meta.js";
-import { type Node, node } from "../../core/node.js";
-import { subscribeOr } from "../../core/subscribe-error.js";
-import { type ExtraOpts, operatorOpts } from "./_internal.js";
-
-/**
- * Buffers source `DATA` values; flushes an array when `notifier` settles (`buffer`).
- *
- * @param source - Upstream node.
- * @param notifier - Flush trigger on each settlement.
- * @param opts - Optional {@link NodeOptions} (excluding `describeKind`).
- * @returns `Node<T[]>` - Emits buffered arrays (may be empty-handled via `RESOLVED` when nothing buffered).
- * @example
- * ```ts
- * import { buffer, state } from "@graphrefly/pure-ts";
- *
- * buffer(state(0), state(0));
- * ```
- *
- * @category extra
- */
-export function buffer<T>(source: Node<T>, notifier: Node<unknown>, opts?: ExtraOpts): Node<T[]> {
-	return node<T[]>((_data, a) => {
-		const buf: T[] = [];
-
-		// R2.2.7.b: Dead source → flush any buffered + self-COMPLETE
-		// (source is permanently over; no more DATA can ever arrive
-		// to buffer).
-		const srcUnsub = subscribeOr<unknown>(
-			source as Node,
-			(msgs) => {
-				for (const m of msgs as Messages) {
-					if (m[0] === DATA) {
-						buf.push(m[1] as T);
-					} else if (m[0] === COMPLETE) {
-						if (buf.length > 0) a.emit([...buf]);
-						buf.length = 0;
-						a.down([[COMPLETE]]);
-					} else if (m[0] === ERROR) {
-						a.down([m]);
-					}
-				}
-			},
-			() => {
-				if (buf.length > 0) {
-					a.emit([...buf]);
-					buf.length = 0;
-				}
-				a.down([[COMPLETE]]);
-			},
-		);
-
-		// R2.2.7.b: Dead notifier → operator reduces to "buffer until
-		// source completes" — no notifier signal will ever fire, so
-		// no flushes happen mid-stream. Source's COMPLETE path still
-		// emits the final buffer.
-		const notUnsub = subscribeOr<unknown>(
-			notifier as Node,
-			(msgs) => {
-				for (const m of msgs as Messages) {
-					if (m[0] === DATA) {
-						if (buf.length > 0) {
-							a.emit([...buf]);
-							buf.length = 0;
-						}
-					} else if (m[0] === COMPLETE) {
-						// Notifier complete — forward
-						a.down([[COMPLETE]]);
-					} else if (m[0] === ERROR) {
-						a.down([m]);
-					}
-				}
-			},
-			() => {
-				// no-op — notifier signal never fires; passthrough source.
-			},
-		);
-
-		return {
-			onDeactivation: () => {
-				srcUnsub();
-				notUnsub();
-				buf.length = 0;
-			},
-		};
-	}, operatorOpts(opts));
-}
-
-/**
- * Batches consecutive `DATA` values into arrays of length `count` (`bufferCount` / `windowCount`).
- *
- * @param source - Upstream node.
- * @param count - Buffer size before emit; must be > 0.
- * @param opts - Optional {@link NodeOptions} (excluding `describeKind`).
- * @returns `Node<T[]>` - Emits fixed-size arrays; remainder flushes on `COMPLETE`.
- * @example
- * ```ts
- * import { bufferCount, state } from "@graphrefly/pure-ts";
- *
- * bufferCount(state(0), 3);
- * ```
- *
- * @category extra
- */
-export function bufferCount<T>(source: Node<T>, count: number, opts?: ExtraOpts): Node<T[]> {
-	if (count <= 0) throw new RangeError("bufferCount expects count > 0");
-	return node<T[]>((_data, a) => {
-		const buf: T[] = [];
-
-		// R2.2.7.b: Dead source → flush remainder + self-COMPLETE.
-		const srcUnsub = subscribeOr<unknown>(
-			source as Node,
-			(msgs) => {
-				for (const m of msgs as Messages) {
-					if (m[0] === DATA) {
-						buf.push(m[1] as T);
-						if (buf.length >= count) {
-							a.emit(buf.splice(0, buf.length));
-						}
-					} else if (m[0] === COMPLETE) {
-						if (buf.length > 0) a.emit([...buf]);
-						buf.length = 0;
-						a.down([[COMPLETE]]);
-					} else if (m[0] === ERROR) {
-						a.down([m]);
-					}
-				}
-			},
-			() => {
-				if (buf.length > 0) {
-					a.emit([...buf]);
-					buf.length = 0;
-				}
-				a.down([[COMPLETE]]);
-			},
-		);
-
-		return {
-			onDeactivation: () => {
-				srcUnsub();
-				buf.length = 0;
-			},
-		};
-	}, operatorOpts(opts));
-}
-
-/**
- * Splits source `DATA` into sub-nodes of `count` values each. Each sub-node completes after `count` items or when source completes.
- *
- * @param source - Upstream node.
- * @param count - Items per window.
- * @param opts - Optional {@link NodeOptions} (excluding `describeKind`).
- * @returns `Node<Node<T>>` - Each emission is a sub-node carrying that window's values.
- *
- * @example
- * ```ts
- * import { windowCount, state } from "@graphrefly/pure-ts";
- *
- * windowCount(state(0), 3);
- * ```
- *
- * @category extra
- */
-export function windowCount<T>(source: Node<T>, count: number, opts?: ExtraOpts): Node<Node<T>> {
-	if (count <= 0) throw new RangeError("windowCount expects count > 0");
-
-	return node<Node<T>>((_data, a) => {
-		let winDown: ((msgs: Messages) => void) | undefined;
-		let n = 0;
-
-		function openWindow(): void {
-			const s = node<T>((_data2, actions) => {
-				winDown = actions.down.bind(actions);
-				return {
-					onDeactivation: () => {
-						winDown = undefined;
-					},
-				};
-			}, operatorOpts());
-			n = 0;
-			a.emit(s);
-		}
-
-		// R2.2.7.b: Dead source → close current window + self-COMPLETE.
-		const srcUnsub = subscribeOr<unknown>(
-			source as Node,
-			(msgs) => {
-				for (const m of msgs as Messages) {
-					if (m[0] === DATA) {
-						if (!winDown) openWindow();
-						winDown?.([[DATA, m[1]]]);
-						n += 1;
-						if (n >= count) {
-							winDown?.([[COMPLETE]]);
-							winDown = undefined;
-						}
-					} else if (m[0] === COMPLETE) {
-						winDown?.([[COMPLETE]]);
-						winDown = undefined;
-						a.down([[COMPLETE]]);
-					} else if (m[0] === ERROR) {
-						winDown?.([m]);
-						winDown = undefined;
-						a.down([m]);
-					}
-				}
-			},
-			() => {
-				winDown?.([[COMPLETE]]);
-				winDown = undefined;
-				a.down([[COMPLETE]]);
-			},
-		);
-
-		return {
-			onDeactivation: () => {
-				srcUnsub();
-				winDown?.([[COMPLETE]]);
-				winDown = undefined;
-			},
-		};
-	}, operatorOpts(opts));
-}
-
-/**
- * Flushes buffered `DATA` values every `ms` (`bufferTime` / `windowTime`).
- *
- * @param source - Upstream node.
- * @param ms - Flush interval in milliseconds.
- * @param opts - Optional {@link NodeOptions} (excluding `describeKind`).
- * @returns `Node<T[]>` - Time-windowed batches.
- * @example
- * ```ts
- * import { bufferTime, state } from "@graphrefly/pure-ts";
- *
- * bufferTime(state(0), 250);
- * ```
- *
- * @category extra
- */
-export function bufferTime<T>(source: Node<T>, ms: number, opts?: ExtraOpts): Node<T[]> {
-	return node<T[]>(
-		(_data, a) => {
-			const buf: T[] = [];
-
-			const iv = setInterval(() => {
-				if (buf.length > 0) {
-					a.emit([...buf]);
-					buf.length = 0;
-				}
-			}, ms);
-
-			// R2.2.7.b: Dead source → cancel interval, flush remainder,
-			// self-COMPLETE.
-			const srcUnsub = subscribeOr<unknown>(
-				source as Node,
-				(msgs) => {
-					for (const m of msgs as Messages) {
-						if (m[0] === DATA) {
-							buf.push(m[1] as T);
-						} else if (m[0] === COMPLETE) {
-							clearInterval(iv);
-							if (buf.length > 0) a.emit([...buf]);
-							buf.length = 0;
-							a.down([[COMPLETE]]);
-						} else if (m[0] === ERROR) {
-							clearInterval(iv);
-							a.down([m]);
-						}
-						// DIRTY from source is NOT forwarded — bufferTime
-						// transforms the timeline. a.emit(buf) handles full
-						// DIRTY+DATA framing when the interval fires.
-					}
-				},
-				() => {
-					clearInterval(iv);
-					if (buf.length > 0) {
-						a.emit([...buf]);
-						buf.length = 0;
-					}
-					a.down([[COMPLETE]]);
-				},
-			);
-
-			return {
-				onDeactivation: () => {
-					srcUnsub();
-					clearInterval(iv);
-					buf.length = 0;
-				},
-			};
-		},
-		{
-			...operatorOpts(opts),
-			meta: { ...factoryTag("bufferTime", { ms }), ...(opts?.meta ?? {}) },
-		},
-	);
-}
-
-/**
- * Splits source `DATA` into time-windowed sub-nodes; each window lasts `ms`.
- *
- * @param source - Upstream node.
- * @param ms - Window duration in milliseconds.
- * @param opts - Optional {@link NodeOptions} (excluding `describeKind`).
- * @returns `Node<Node<T>>` - Each emission is a sub-node carrying that window's values.
- *
- * @example
- * ```ts
- * import { windowTime, state } from "@graphrefly/pure-ts";
- *
- * windowTime(state(0), 500);
- * ```
- *
- * @category extra
- */
-export function windowTime<T>(source: Node<T>, ms: number, opts?: ExtraOpts): Node<Node<T>> {
-	return node<Node<T>>((_data, a) => {
-		let winDown: ((msgs: Messages) => void) | undefined;
-
-		function closeWindow(): void {
-			winDown?.([[COMPLETE]]);
-			winDown = undefined;
-		}
-
-		function openWindow(): void {
-			const s = node<T>((_data2, actions) => {
-				winDown = actions.down.bind(actions);
-				return {
-					onDeactivation: () => {
-						winDown = undefined;
-					},
-				};
-			}, operatorOpts());
-			a.emit(s);
-		}
-
-		openWindow();
-		const iv = setInterval(() => {
-			closeWindow();
-			openWindow();
-		}, ms);
-
-		// R2.2.7.b: Dead source → cancel interval, close window,
-		// self-COMPLETE.
-		const srcUnsub = subscribeOr<unknown>(
-			source as Node,
-			(msgs) => {
-				for (const m of msgs as Messages) {
-					if (m[0] === DATA) {
-						winDown?.([[DATA, m[1]]]);
-					} else if (m[0] === COMPLETE) {
-						clearInterval(iv);
-						closeWindow();
-						a.down([[COMPLETE]]);
-					} else if (m[0] === ERROR) {
-						clearInterval(iv);
-						winDown?.([m]);
-						closeWindow();
-						a.down([m]);
-					}
-				}
-			},
-			() => {
-				clearInterval(iv);
-				closeWindow();
-				a.down([[COMPLETE]]);
-			},
-		);
-
-		return {
-			onDeactivation: () => {
-				srcUnsub();
-				clearInterval(iv);
-				closeWindow();
-			},
-		};
-	}, operatorOpts(opts));
-}
-
-/**
- * Splits source `DATA` into sub-nodes, opening a new window each time `notifier` emits `DATA`.
- *
- * @param source - Upstream node.
- * @param notifier - Each `DATA` from `notifier` closes the current window and opens a new one.
- * @param opts - Optional {@link NodeOptions} (excluding `describeKind`).
- * @returns `Node<Node<T>>` - Each emission is a sub-node carrying that window's values.
- *
- * @example
- * ```ts
- * import { state, window } from "@graphrefly/pure-ts";
- *
- * window(state(0), state(0));
- * ```
- *
- * @category extra
- */
-export function window<T>(
-	source: Node<T>,
-	notifier: Node<unknown>,
-	opts?: ExtraOpts,
-): Node<Node<T>> {
-	return node<Node<T>>((_data, a) => {
-		let winDown: ((msgs: Messages) => void) | undefined;
-
-		function closeWindow(): void {
-			winDown?.([[COMPLETE]]);
-			winDown = undefined;
-		}
-
-		function openWindow(): void {
-			const s = node<T>((_data2, actions) => {
-				winDown = actions.down.bind(actions);
-				return {
-					onDeactivation: () => {
-						winDown = undefined;
-					},
-				};
-			}, operatorOpts());
-			a.emit(s);
-		}
-
-		// R2.2.7.b: Dead source → close window + self-COMPLETE.
-		const srcUnsub = subscribeOr<unknown>(
-			source as Node,
-			(msgs) => {
-				for (const m of msgs as Messages) {
-					if (m[0] === DATA) {
-						if (!winDown) openWindow();
-						winDown?.([[DATA, m[1]]]);
-					} else if (m[0] === COMPLETE) {
-						closeWindow();
-						a.down([[COMPLETE]]);
-					} else if (m[0] === ERROR) {
-						winDown?.([m]);
-						winDown = undefined;
-						a.down([m]);
-					}
-				}
-			},
-			() => {
-				closeWindow();
-				a.down([[COMPLETE]]);
-			},
-		);
-
-		// R2.2.7.b: Dead notifier → no-op (no window transitions will
-		// fire; operator passes source through as one open window).
-		const notUnsub = subscribeOr<unknown>(
-			notifier as Node,
-			(msgs) => {
-				for (const m of msgs as Messages) {
-					if (m[0] === DATA) {
-						closeWindow();
-						openWindow();
-					}
-				}
-			},
-			() => {
-				// no-op — notifier never fires.
-			},
-		);
-
-		return {
-			onDeactivation: () => {
-				srcUnsub();
-				notUnsub();
-				closeWindow();
-			},
-		};
-	}, operatorOpts(opts));
-}
diff --git a/packages/pure-ts/src/extra/operators/combine.ts b/packages/pure-ts/src/extra/operators/combine.ts
deleted file mode 100644
index 813ad7d2..00000000
--- a/packages/pure-ts/src/extra/operators/combine.ts
+++ /dev/null
@@ -1,578 +0,0 @@
-/**
- * Combine operators (roadmap §2.1) — multi-source combinators.
- *
- * `combine` / `combineLatest` (latest tuple), `withLatestFrom` (paired emit
- * gated on primary), `merge` (interleave any), `zip` (one DATA per source per
- * cycle), `concat` (sequential), `race` (first DATA wins).
- */
-
-import { COMPLETE, DATA, ERROR, type Messages, RESOLVED } from "../../core/messages.js";
-import { factoryTag } from "../../core/meta.js";
-import { type Node, node } from "../../core/node.js";
-import { subscribeOr } from "../../core/subscribe-error.js";
-import { type ExtraOpts, gatedOperatorOpts, operatorOpts } from "./_internal.js";
-
-/**
- * Combines the latest value from each dependency whenever any dep settles (combineLatest).
- *
- * @param sources - Nodes to combine (variadic).
- * @returns `Node<T>` - Tuple of latest values.
- *
- * @example
- * ```ts
- * import { combine, state } from "@graphrefly/pure-ts";
- *
- * const n = combine(state(1), state("a"));
- * ```
- *
- * @remarks
- * Unlike RxJS `combineLatest`, this is named `combine`. Use the {@link combineLatest} alias
- * if you prefer the RxJS name. Seed is always required for `scan`/`reduce` (no seedless mode).
- *
- * @category extra
- */
-export function combine<const T extends readonly unknown[]>(
-	...sources: { [K in keyof T]: Node<T[K]> }
-): Node<T> {
-	const deps = [...sources] as unknown as Node[];
-	return node<T>(
-		deps,
-		(batchData, actions, ctx) => {
-			const vals = batchData.map((batch, i) =>
-				batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-			);
-			actions.emit(vals as unknown as T);
-		},
-		{
-			...operatorOpts<T>(),
-			equals: (a, b) => {
-				if (a.length !== b.length) return false;
-				for (let i = 0; i < a.length; i++) {
-					if (!Object.is(a[i], b[i])) return false;
-				}
-				return true;
-			},
-		},
-	);
-}
-
-/**
- * When `primary` settles, emits `[primary, latestSecondary]`. `secondary` alone updates cache only.
- *
- * @param primary - Main stream.
- * @param secondary - Latest value is paired on each primary emission.
- * @param opts - Optional {@link NodeOptions} (excluding `describeKind`).
- * @returns `Node<readonly [A, B]>` - Paired stream.
- *
- * @example
- * ```ts
- * import { state, withLatestFrom } from "@graphrefly/pure-ts";
- *
- * const n = withLatestFrom(state(1), state("x"));
- * ```
- *
- * @category extra
- */
-export function withLatestFrom<A, B>(
-	primary: Node<A>,
-	secondary: Node<B>,
-	opts?: ExtraOpts,
-): Node<readonly [A, B]> {
-	// **Phase 10.5 (2026-04-29; see `archive/docs/SESSION-graph-narrow-waist.md`
-	// § "Phase 10.5 — `partial: false` is the actual fix"):** flipped from
-	// `partial: true` to `partial: false`. Previously withLatestFrom opted
-	// out of the §2.7 first-run gate to admit partial-dep waves; the side
-	// effect was that on initial activation with state+state-cached deps,
-	// the paired emission was dropped (W1 — see [optimizations.md "Multi-dep
-	// push-on-subscribe ordering"](../../../docs/optimizations.md), and
-	// COMPOSITION-GUIDE §28). With `partial: false` the gate holds during
-	// activation until both deps deliver real DATA, then fires once with
-	// `[primary, latestSecondary]` populated. The gate scope is
-	// `_hasCalledFnOnce === false` only ([core/node.ts:1642-1645]) — once
-	// fn fires, subsequent waves are gate-free and the "fire on primary
-	// alone after warmup" semantic is preserved. Behavior diff vs the prior
-	// `partial: true`: at activation when one dep is sentinel forever, fn
-	// no longer emits a RESOLVED; it stays silent until the missing dep
-	// delivers real DATA. **Audit (in-tree `withLatestFrom` consumers):**
-	// `harness-loop.ts:511 triageInput` (both deps state-cached, gate
-	// releases at activation), `harness-loop.ts:547 routerInput` (both deps
-	// sentinel until first triage cycle, gate holds in both pre and post
-	// Phase 10.5 — equivalent), `suggest-strategy.ts:176 paired`
-	// (sentinel-forever-secondary case: pre-Phase-10.5 dispatched RESOLVED
-	// but RESOLVED does not release downstream first-run gates per
-	// [core/node.ts:1651-1660], so end state is identical). Flipping
-	// individually in this fn (not via `partialOperatorOpts`) so `valve`
-	// (which deliberately needs `partial: true` for control-alone-on-
-	// activation) and any other partial-dep operators remain unaffected.
-	return node<readonly [A, B]>(
-		[primary as Node, secondary as Node],
-		(data, a, ctx) => {
-			const batch0 = data[0];
-			const batch1 = data[1];
-			// Current secondary value: this wave's last DATA if secondary fired,
-			// otherwise last known value from ctx.prevData (previous wave).
-			const secondaryVal = (
-				batch1 != null && batch1.length > 0 ? batch1.at(-1) : ctx.prevData[1]
-			) as B | undefined;
-
-			// Only emit when primary (dep 0) sent DATA this wave.
-			if (batch0 != null && batch0.length > 0) {
-				// secondary has never produced DATA — undefined is the protocol
-				// sentinel for "never sent DATA"; null is a valid DATA value.
-				// With `partial: false` the gate holds during activation until
-				// secondary delivers real DATA, so this branch is dead on the
-				// first wave. It IS reachable post-warmup if secondary
-				// INVALIDATEs (which clears `prevData[1]` to undefined per
-				// `_depInvalidated` at [core/node.ts:1624-1635]) and then
-				// primary fires before secondary re-delivers. INVALIDATE does
-				// NOT re-arm the first-run gate ([core/node.ts:269] "Subsequent
-				// waves, INVALIDATE, and `_addDep` do not re-gate"), so this
-				// guard catches that re-delivery-pending window. (Terminal
-				// settlement on secondary leaves `prevData[1]` populated per
-				// `_depSettledAsTerminal` at [core/node.ts:1609-1617] — that
-				// path doesn't reach this branch.)
-				if (!(batch1 != null && batch1.length > 0) && ctx.prevData[1] === undefined) {
-					a.down([[RESOLVED]]);
-					return;
-				}
-				for (const v of batch0 as A[]) {
-					a.emit([v, secondaryVal]);
-				}
-			} else {
-				// Secondary update only (or both RESOLVED) — no downstream DATA.
-				a.down([[RESOLVED]]);
-			}
-		},
-		{
-			...gatedOperatorOpts<readonly [A, B]>(opts),
-			meta: { ...factoryTag("withLatestFrom"), ...(opts?.meta ?? {}) },
-		},
-	);
-}
-
-/**
- * Merges **`DATA`** from any source with correct two-phase dirty tracking. **`COMPLETE`** after **all** sources complete (spec §1.3.5).
- *
- * @param sources - Nodes to merge (variadic; empty completes immediately).
- * Pass an optional trailing {@link ExtraOpts} to override `meta` (e.g. layer
- * a `metric:` companion onto the default `factoryTag("merge")`) or thread
- * core node options like `name` / `equals` / `versioning`.
- * @returns `Node<T>` - Merged stream.
- *
- * @remarks
- * **Ordering:** DIRTY/RESOLVED rules follow multi-source semantics in `~/src/graphrefly/GRAPHREFLY-SPEC.md`.
- *
- * **F-15 (2026-04-30):** `merge` accepts an optional trailing options object.
- * The runtime distinguishes a trailing opts argument from a `Node` via duck
- * typing (`subscribe` + `down` function shape) — caller-supplied opts that
- * happen to look like a `Node` are not supported (none in practice; the opts
- * shape is `{ meta?, name?, … }`).
- *
- * @example
- * ```ts
- * import { merge, state } from "@graphrefly/pure-ts";
- *
- * const n = merge(state(1), state(2));
- * const tagged = merge(state(1), state(2), { meta: { metric: "events" } });
- * ```
- *
- * @category extra
- */
-export function merge<T>(...sources: readonly Node<T>[]): Node<T>;
-export function merge<T>(...args: readonly [...Node<T>[], ExtraOpts]): Node<T>;
-export function merge<T>(...args: ReadonlyArray<Node<T> | ExtraOpts | undefined>): Node<T> {
-	// Trailing opts detection: last arg is a non-Node object. A `Node` carries
-	// `subscribe` + `down` function members; a supported `ExtraOpts` carries
-	// neither. A trailing `undefined` (idiomatic optional pass-through, e.g.
-	// `merge(a, b, opts ?? undefined)`) is treated as "no opts" and dropped
-	// from sources before the active-merge loop.
-	let opts: ExtraOpts | undefined;
-	let sources: readonly Node<T>[];
-	const last = args.length > 0 ? args[args.length - 1] : undefined;
-	if (last === undefined) {
-		// No opts; drop trailing undefined so the source loop doesn't crash.
-		sources = (
-			args.length > 0 && args[args.length - 1] === undefined ? args.slice(0, -1) : args
-		) as readonly Node<T>[];
-	} else if (
-		typeof last === "object" &&
-		!(
-			typeof (last as { subscribe?: unknown }).subscribe === "function" &&
-			typeof (last as { down?: unknown }).down === "function"
-		)
-	) {
-		opts = last as ExtraOpts;
-		sources = args.slice(0, -1) as Node<T>[];
-	} else {
-		sources = args as readonly Node<T>[];
-	}
-
-	if (sources.length === 0) {
-		return node<T>(
-			(_data, a) => {
-				a.down([[COMPLETE]]);
-			},
-			{ ...operatorOpts(opts), meta: { ...factoryTag("merge"), ...(opts?.meta ?? {}) } },
-		);
-	}
-	// producer pattern: node() cannot be used here because the sentinel gate
-	// would block the fn until ALL sources have sent their first DATA, which
-	// defeats the purpose of merge (forward whichever source fires first).
-	return node<T>(
-		(_data, a) => {
-			const n = sources.length;
-			let completed = 0;
-			let terminated = false;
-			const unsubs: (() => void)[] = [];
-			for (const src of sources) {
-				// /qa F5 (2026-05-10): guard the subscribe loop with
-				// `terminated` so a synchronous Dead-handler fired by
-				// the all-completed branch doesn't leave subsequent
-				// iterations subscribing into an already-completed
-				// operator (which would leak unsubs not pushed into
-				// `unsubs` due to the synchronous re-entry).
-				if (terminated) break;
-				// R2.2.7.b: Dead source counts as Complete for merge's
-				// completion tracking (no DATA will ever flow); if all
-				// sources are Dead/Complete, self-COMPLETE.
-				const u = subscribeOr<unknown>(
-					src as Node,
-					(msgs) => {
-						for (const m of msgs as Messages) {
-							if (m[0] === DATA) {
-								a.emit(m[1] as T);
-							} else if (m[0] === COMPLETE) {
-								completed += 1;
-								if (completed >= n && !terminated) {
-									terminated = true;
-									a.down([[COMPLETE]]);
-								}
-							} else if (m[0] === ERROR) {
-								if (!terminated) {
-									terminated = true;
-									a.down([m]);
-								}
-							}
-							// DIRTY, RESOLVED, START silently absorbed
-						}
-					},
-					() => {
-						completed += 1;
-						if (completed >= n && !terminated) {
-							terminated = true;
-							a.down([[COMPLETE]]);
-						}
-					},
-				);
-				unsubs.push(u);
-			}
-			return {
-				onDeactivation: () => {
-					for (const u of unsubs) u();
-				},
-			};
-		},
-		{ ...operatorOpts(opts), meta: { ...factoryTag("merge"), ...(opts?.meta ?? {}) } },
-	);
-}
-
-/**
- * Zips one **`DATA`** from each source per cycle into a tuple. Only **`DATA`** enqueues (spec §1.3.3).
- *
- * @param sources - Nodes to zip (variadic).
- * @returns `Node<T>` - Zipped tuples.
- *
- * @example
- * ```ts
- * import { state, zip } from "@graphrefly/pure-ts";
- *
- * const n = zip(state(1), state(2));
- * ```
- *
- * @category extra
- */
-export function zip<const T extends readonly unknown[]>(
-	...sources: { [K in keyof T]: Node<T[K]> }
-): Node<T> {
-	const n = sources.length;
-	// R5.7.x — zip requires ≥1 source; vacuous-tuple semantics rejected.
-	if (n === 0) {
-		throw new Error("zip(): requires at least one source");
-	}
-	// Producer pattern: manage queues internally.
-	return node<T>((_data, a) => {
-		const queues: unknown[][] = Array.from({ length: n }, () => []);
-		let active = n;
-
-		function tryEmit(): void {
-			while (queues.every((q) => q.length > 0)) {
-				const tuple = queues.map((q) => q.shift()!) as unknown as T;
-				a.emit(tuple);
-			}
-		}
-
-		const unsubs: (() => void)[] = [];
-		let zipTerminated = false;
-		for (let i = 0; i < n; i++) {
-			if (zipTerminated) break;
-			const idx = i;
-			// R2.2.7.b: Dead source → zip can never form a tuple (this
-			// source's queue will be permanently empty), self-COMPLETE.
-			const u = subscribeOr<unknown>(
-				sources[i] as Node,
-				(msgs) => {
-					for (const m of msgs as Messages) {
-						if (zipTerminated) return;
-						if (m[0] === DATA) {
-							queues[idx].push(m[1]);
-							tryEmit();
-						} else if (m[0] === COMPLETE) {
-							// /qa F4 (2026-05-10): check `zipTerminated`
-							// so a prior Dead-source's COMPLETE doesn't
-							// race with this live-source's COMPLETE
-							// (would otherwise emit COMPLETE twice).
-							active -= 1;
-							if (!zipTerminated && (active === 0 || queues[idx].length === 0)) {
-								zipTerminated = true;
-								a.down([[COMPLETE]]);
-							}
-						} else if (m[0] === ERROR) {
-							if (!zipTerminated) {
-								zipTerminated = true;
-								a.down([m]);
-							}
-						}
-					}
-				},
-				() => {
-					if (!zipTerminated) {
-						zipTerminated = true;
-						a.down([[COMPLETE]]);
-					}
-				},
-			);
-			unsubs.push(u);
-		}
-		return {
-			onDeactivation: () => {
-				for (const u of unsubs) u();
-			},
-		};
-	}, operatorOpts());
-}
-
-/**
- * Plays all of `firstSrc`, then all of `secondSrc`. **`DATA`** from `secondSrc` during phase one is buffered until handoff.
- *
- * @param firstSrc - First segment.
- * @param secondSrc - Second segment.
- * @param opts - Optional {@link NodeOptions} (excluding `describeKind`).
- * @returns `Node<T>` - Concatenated stream.
- *
- * @example
- * ```ts
- * import { concat, state } from "@graphrefly/pure-ts";
- *
- * const n = concat(state(1), state(2));
- * ```
- *
- * @category extra
- */
-export function concat<T>(firstSrc: Node<T>, secondSrc: Node<T>, opts?: ExtraOpts): Node<T> {
-	// producer pattern: node() cannot be used here because the sentinel gate
-	// would block the fn until ALL sources have sent their first DATA, which
-	// defeats the purpose of concat (start forwarding firstSrc immediately,
-	// regardless of secondSrc state).
-	return node<T>((_data, a) => {
-		let phase: 0 | 1 = 0;
-		const pending: unknown[] = [];
-		let firstUnsub: (() => void) | undefined;
-		let secondUnsub: (() => void) | undefined;
-		let secondCompleted = false;
-
-		// R2.2.7.b: Dead secondSrc → mark second-completed flag; if
-		// first eventually completes, immediately self-COMPLETE
-		// (mirrors Rust concat's `second_completed` D041 fix).
-		secondUnsub = subscribeOr<unknown>(
-			secondSrc as Node,
-			(msgs) => {
-				for (const m of msgs as Messages) {
-					if (phase === 0) {
-						if (m[0] === DATA) pending.push(m[1]);
-						else if (m[0] === COMPLETE) secondCompleted = true;
-						else if (m[0] === ERROR) a.down([m]);
-					} else {
-						// phase 1 — forward everything from second
-						if (m[0] === DATA) a.emit(m[1] as T);
-						else if (m[0] === COMPLETE || m[0] === ERROR) a.down([m]);
-					}
-				}
-			},
-			() => {
-				secondCompleted = true;
-			},
-		);
-
-		// R2.2.7.b: Dead firstSrc → advance phase immediately, drain
-		// pending, and if second is also done, self-COMPLETE.
-		firstUnsub = subscribeOr<unknown>(
-			firstSrc as Node,
-			(msgs) => {
-				for (const m of msgs as Messages) {
-					if (phase === 0) {
-						if (m[0] === DATA) {
-							a.emit(m[1] as T);
-						} else if (m[0] === COMPLETE) {
-							phase = 1;
-							// Flush buffered second-source DATA
-							for (const v of pending) {
-								a.emit(v as T);
-							}
-							pending.length = 0;
-							if (secondCompleted) a.down([[COMPLETE]]);
-						} else if (m[0] === ERROR) {
-							a.down([m]);
-						}
-					}
-					// phase 1: ignore further first-source messages
-				}
-			},
-			() => {
-				if (phase === 0) {
-					phase = 1;
-					for (const v of pending) {
-						a.emit(v as T);
-					}
-					pending.length = 0;
-					if (secondCompleted) a.down([[COMPLETE]]);
-				}
-			},
-		);
-
-		return {
-			onDeactivation: () => {
-				firstUnsub?.();
-				secondUnsub?.();
-			},
-		};
-	}, operatorOpts(opts));
-}
-
-/**
- * First source to emit **`DATA`** wins; later traffic follows only the winner (Rx-style `race`).
- *
- * @param sources - Contestants (variadic; throws at construction when empty; one node is identity).
- * @returns `Node<T>` - Winning stream.
- *
- * @example
- * ```ts
- * import { race, state } from "@graphrefly/pure-ts";
- *
- * const n = race(state(1), state(2));
- * ```
- *
- * @category extra
- */
-export function race<T>(...sources: readonly Node<T>[]): Node<T> {
-	// R5.7.x — race requires ≥1 source; no-winner-possible rejected at construction.
-	if (sources.length === 0) {
-		throw new Error("race(): requires at least one source");
-	}
-	if (sources.length === 1) {
-		// Identity passthrough — full batch iteration, not derived's .at(-1).
-		return node<T>(
-			[sources[0] as Node],
-			(data, a) => {
-				const batch0 = data[0];
-				if (batch0 == null || batch0.length === 0) {
-					a.down([[RESOLVED]]);
-					return;
-				}
-				for (const v of batch0) a.emit(v as T);
-			},
-			operatorOpts<T>(),
-		);
-	}
-	// Producer pattern: first DATA wins.
-	return node<T>((_data, a) => {
-		let winner: number | null = null;
-		// /qa F3 (2026-05-10): tracks both Dead-at-subscribe AND
-		// live-COMPLETE-without-DATA. Pre-fix this was `completedDead`
-		// and only flipped from the onDead path, so mixed Dead+live
-		// scenarios where a live source completed without ever
-		// emitting DATA wouldn't trigger the all-completed self-Complete.
-		// /qa F6 (2026-05-12): replaced per-index boolean array +
-		// `completed.every()` O(n) check with a counter for O(1).
-		let completedCount = 0;
-		let raceTerminated = false;
-		const unsubs: (() => void)[] = [];
-		for (let i = 0; i < sources.length; i++) {
-			if (raceTerminated) break;
-			const idx = i;
-			// R2.2.7.b: Dead source → increment completedCount; if all
-			// sources are Dead or have completed-without-DATA, self-COMPLETE.
-			const u = subscribeOr<unknown>(
-				sources[i] as Node,
-				(msgs) => {
-					for (const m of msgs as Messages) {
-						if (raceTerminated) return;
-						if (winner !== null && idx !== winner) return;
-						if (m[0] === DATA) {
-							if (winner === null) winner = idx;
-							a.emit(m[1] as T);
-						} else if (m[0] === COMPLETE) {
-							if (winner === null || idx === winner) {
-								completedCount += 1;
-								if (winner === idx) {
-									// Winner completed; race is over.
-									raceTerminated = true;
-									a.down([m]);
-								} else if (winner === null && completedCount >= sources.length) {
-									// All sources completed-without-DATA; no
-									// winner; self-COMPLETE.
-									raceTerminated = true;
-									a.down([m]);
-								}
-							}
-						} else if (m[0] === ERROR) {
-							if (winner === null || idx === winner) {
-								raceTerminated = true;
-								a.down([m]);
-							}
-						}
-					}
-				},
-				() => {
-					completedCount += 1;
-					if (winner === null && !raceTerminated && completedCount >= sources.length) {
-						raceTerminated = true;
-						a.down([[COMPLETE]]);
-					}
-				},
-			);
-			unsubs.push(u);
-		}
-		return {
-			onDeactivation: () => {
-				for (const u of unsubs) u();
-			},
-		};
-	}, operatorOpts());
-}
-
-/**
- * RxJS-named alias for {@link combine} — emits when any dep updates with latest tuple of values.
- *
- * @param sources - Upstream nodes as separate arguments (same calling shape as `combine`).
- * @returns Combined node; signature matches `combine`.
- *
- * @example
- * ```ts
- * import { combineLatest, state } from "@graphrefly/pure-ts";
- *
- * const n = combineLatest(state(1), state("a"));
- * ```
- *
- * @category extra
- */
-export const combineLatest = combine;
diff --git a/packages/pure-ts/src/extra/operators/control.ts b/packages/pure-ts/src/extra/operators/control.ts
deleted file mode 100644
index 884810fb..00000000
--- a/packages/pure-ts/src/extra/operators/control.ts
+++ /dev/null
@@ -1,718 +0,0 @@
-/**
- * Control operators (roadmap §2.1) — gate, recover, repeat, observe.
- *
- * `valve` (boolean control), `rescue` / `catchError` (recover from ERROR),
- * `pausable` (deprecated identity), `repeat` (sequential resubscribe), `tap`
- * (side-effect passthrough with optional observer object),
- * `onFirstData` / `tapFirst` (one-shot first-DATA tap), `timeout` (idle
- * watchdog).
- */
-
-import type { Message, Messages } from "../../core/messages.js";
-import { COMPLETE, DATA, ERROR, RESOLVED } from "../../core/messages.js";
-import { factoryTag } from "../../core/meta.js";
-import { type Node, node } from "../../core/node.js";
-import { subscribeOr } from "../../core/subscribe-error.js";
-import {
-	type AbortInFlightOpt,
-	type ExtraOpts,
-	fireAbortInFlight,
-	operatorOpts,
-	partialOperatorOpts,
-} from "./_internal.js";
-
-/**
- * Observer shape for {@link tap} — side effects for data, error, and/or complete.
- */
-export type TapObserver<T> = {
-	data?: (value: T) => void;
-	error?: (err: unknown) => void;
-	complete?: () => void;
-};
-
-/**
- * Invokes side effects; values pass through unchanged.
- *
- * Accepts either a function (called on each DATA) or an observer object
- * `{ data?, error?, complete? }` for lifecycle-aware side effects.
- *
- * @param source - Upstream node.
- * @param fnOrObserver - Side effect function or observer object.
- * @param opts - Optional {@link NodeOptions} (excluding `describeKind`).
- * @returns `Node<T>` - Passthrough node.
- *
- * @example
- * ```ts
- * import { tap, state } from "@graphrefly/pure-ts";
- *
- * // Function form (DATA only)
- * tap(state(1), (x) => console.log(x));
- *
- * // Observer form (DATA + ERROR + COMPLETE)
- * tap(state(1), { data: console.log, error: console.error, complete: () => console.log("done") });
- * ```
- *
- * @category extra
- */
-export function tap<T>(
-	source: Node<T>,
-	fnOrObserver: ((value: T) => void) | TapObserver<T>,
-	opts?: ExtraOpts,
-): Node<T> {
-	if (typeof fnOrObserver === "function") {
-		return node<T>(
-			[source as Node],
-			(data, a) => {
-				const batch0 = data[0];
-				if (batch0 == null || batch0.length === 0) {
-					a.down([[RESOLVED]]);
-					return;
-				}
-				for (const v of batch0) {
-					fnOrObserver(v as T);
-					a.emit(v as T);
-				}
-			},
-			{
-				...operatorOpts(opts),
-				meta: { ...factoryTag("tap"), ...(opts?.meta ?? {}) },
-			},
-		);
-	}
-	const obs = fnOrObserver;
-	return node<T>(
-		[source as Node],
-		(data, a, ctx) => {
-			// Check for terminal events
-			if (ctx.terminalDeps[0] !== undefined) {
-				if (ctx.terminalDeps[0] === true) {
-					obs.complete?.();
-					a.down([[COMPLETE]]);
-				} else {
-					obs.error?.(ctx.terminalDeps[0]);
-					a.down([[ERROR, ctx.terminalDeps[0]]]);
-				}
-				return;
-			}
-			const batch0 = data[0];
-			if (batch0 == null || batch0.length === 0) {
-				a.down([[RESOLVED]]);
-				return;
-			}
-			for (const v of batch0) {
-				obs.data?.(v as T);
-				a.emit(v as T);
-			}
-		},
-		{
-			...operatorOpts(opts),
-			completeWhenDepsComplete: false,
-			meta: { ...factoryTag("tap"), ...(opts?.meta ?? {}) },
-		},
-	);
-}
-
-/**
- * Invokes `fn` exactly once on the first qualifying DATA emission, then passes
- * all values (including subsequent DATA) through unchanged.
- *
- * Motivation: call-boundary instrumentation (record stats, debit budget, log
- * first-token latency) where the wrapper is re-subscribed by downstream
- * composition (push-on-subscribe §2.2 would otherwise re-deliver the cached
- * value and re-fire the side effect). The closure guard is scoped to the node
- * instance, so the side effect fires exactly once per node lifetime.
- *
- * By default `null` / `undefined` values pass through WITHOUT counting as
- * "first" — matches the SENTINEL convention (COMPOSITION-GUIDE §8) used by
- * `promptNode`, `fromAny(Promise)`, and friends where a cached `null` means
- * "not yet settled." Pass `where` to override with a custom predicate.
- *
- * @param source - Upstream node.
- * @param fn - Side effect invoked once on the first qualifying value.
- * @param opts - Optional {@link NodeOptions} plus `where` predicate. Default
- *   `where: (v) => v != null`.
- * @returns `Node<T>` - Passthrough node.
- *
- * @example
- * ```ts
- * import { onFirstData, fromAny } from "@graphrefly/pure-ts";
- *
- * const tap = onFirstData(fromAny(adapter.invoke(msgs)), (resp) => recordStats(resp));
- * ```
- *
- * @category extra
- */
-export function onFirstData<T>(
-	source: Node<T>,
-	fn: (value: T) => void,
-	opts?: ExtraOpts & { where?: (value: T) => boolean },
-): Node<T> {
-	const where = opts?.where ?? ((v: T) => v != null);
-	let fired = false;
-	return node<T>(
-		[source as Node],
-		(data, a) => {
-			const batch0 = data[0];
-			if (batch0 == null || batch0.length === 0) {
-				a.down([[RESOLVED]]);
-				return;
-			}
-			for (const v of batch0) {
-				if (!fired && where(v as T)) {
-					fired = true;
-					fn(v as T);
-				}
-				a.emit(v as T);
-			}
-		},
-		operatorOpts(opts),
-	);
-}
-
-/**
- * Alias for {@link onFirstData}. Parallels `tap` naming for discoverability —
- * `tapFirst` is the one-shot companion of `tap`.
- *
- * @category extra
- */
-export const tapFirst = onFirstData;
-
-/**
- * Errors if no `DATA` arrives within `ms` after subscribe or after the previous `DATA`.
- *
- * @param source - Upstream node.
- * @param ms - Idle budget in milliseconds.
- * @param opts - Optional {@link NodeOptions} (excluding `describeKind`) and `with` for a custom error payload.
- * @returns `Node<T>` - Pass-through with idle watchdog.
- * @example
- * ```ts
- * import { timeout, state } from "@graphrefly/pure-ts";
- *
- * timeout(state(0), 5_000);
- * ```
- *
- * @category extra
- */
-export function timeout<T>(
-	source: Node<T>,
-	ms: number,
-	opts?: ExtraOpts & { with?: unknown },
-): Node<T> {
-	const { with: withPayload, ...timeoutNodeOpts } = opts ?? {};
-	const err = withPayload ?? new Error("timeout");
-
-	return node<T>((_data, a) => {
-		let timer: ReturnType<typeof setTimeout> | undefined;
-
-		function arm(): void {
-			clearTimeout(timer);
-			timer = setTimeout(() => {
-				timer = undefined;
-				a.down([[ERROR, err]]);
-			}, ms);
-		}
-
-		// Arm immediately on subscribe
-		arm();
-
-		// R2.2.7.b: Dead source → cancel timer, self-COMPLETE.
-		const srcUnsub = subscribeOr<unknown>(
-			source as Node,
-			(msgs) => {
-				for (const m of msgs as Messages) {
-					if (m[0] === DATA) {
-						arm();
-						a.emit(m[1] as T);
-					} else if (m[0] === COMPLETE || m[0] === ERROR) {
-						clearTimeout(timer);
-						a.down([m]);
-					}
-				}
-			},
-			() => {
-				clearTimeout(timer);
-				a.down([[COMPLETE]]);
-			},
-		);
-
-		return {
-			onDeactivation: () => {
-				srcUnsub();
-				clearTimeout(timer);
-			},
-		};
-	}, operatorOpts(timeoutNodeOpts));
-}
-
-/**
- * Subscribes to `source` repeatedly (`count` times, sequentially). Best with a fresh or `resubscribable` source.
- *
- * @param source - Upstream node to replay.
- * @param count - Number of subscription rounds.
- * @param opts - Optional {@link NodeOptions} (excluding `describeKind`).
- * @returns `Node<T>` - Forwards each round then completes after the last inner `COMPLETE`.
- * @example
- * ```ts
- * import { repeat, state } from "@graphrefly/pure-ts";
- *
- * repeat(state(1, { resubscribable: true }), 2);
- * ```
- *
- * @category extra
- */
-export function repeat<T>(source: Node<T>, count: number, opts?: ExtraOpts): Node<T> {
-	if (count <= 0) throw new RangeError("repeat expects count > 0");
-	return node<T>((_data, a) => {
-		let remaining = count;
-		let innerU: (() => void) | undefined;
-
-		const start = (): void => {
-			innerU?.();
-			// R2.2.7.b: Dead source → cannot replay, self-COMPLETE.
-			// (source went terminal mid-repeat between rounds; remaining
-			// rounds are unreachable.)
-			innerU = subscribeOr<unknown>(
-				source as Node,
-				(msgs) => {
-					let completed = false;
-					const fwd: Message[] = [];
-					for (const m of msgs as Messages) {
-						if (m[0] === COMPLETE) completed = true;
-						else fwd.push(m);
-					}
-					if (fwd.length > 0) a.down(fwd as unknown as Messages);
-					if (completed) {
-						innerU?.();
-						innerU = undefined;
-						remaining -= 1;
-						if (remaining > 0) start();
-						else a.down([[COMPLETE]]);
-					}
-				},
-				() => {
-					innerU = undefined;
-					a.down([[COMPLETE]]);
-				},
-			);
-		};
-
-		start();
-		return {
-			onDeactivation: () => {
-				innerU?.();
-			},
-		};
-	}, operatorOpts(opts));
-}
-
-/**
- * Identity passthrough — `pausable()` has been promoted to default node behavior in v5 (§4).
- *
- * @deprecated Default node behavior now handles PAUSE/RESUME. This operator is a no-op
- * identity passthrough kept only for migration compatibility.
- *
- * @param source - Upstream node.
- * @param opts - Optional {@link NodeOptions} (excluding `describeKind`).
- * @returns `Node<T>` - Pass-through (identity).
- * @example
- * ```ts
- * import { pausable, state } from "@graphrefly/pure-ts";
- *
- * // No longer needed — default nodes handle PAUSE/RESUME.
- * const s = state(0);
- * pausable(s); // identity passthrough
- * ```
- *
- * @category extra
- */
-export function pausable<T>(source: Node<T>, opts?: ExtraOpts): Node<T> {
-	return node<T>(
-		[source as Node],
-		(data, a) => {
-			const batch0 = data[0];
-			if (batch0 == null || batch0.length === 0) {
-				a.down([[RESOLVED]]);
-				return;
-			}
-			for (const v of batch0) a.emit(v as T);
-		},
-		operatorOpts<T>(opts),
-	);
-}
-
-/**
- * Replaces an upstream `ERROR` with a recovered value (`catchError`-style).
- *
- * @param source - Upstream node.
- * @param recover - Maps the error payload to a replacement value; if it throws, `ERROR` is forwarded.
- * @param opts - Optional {@link NodeOptions} (excluding `describeKind`).
- * @returns `Node<T>` - Recovered stream.
- * @example
- * ```ts
- * import { rescue, state } from "@graphrefly/pure-ts";
- *
- * rescue(state(0), () => 0);
- * ```
- *
- * @category extra
- */
-export function rescue<T>(
-	source: Node<T>,
-	recover: (err: unknown) => T,
-	opts?: ExtraOpts,
-): Node<T> {
-	return node<T>((_data, a) => {
-		// R2.2.7.b: Dead source → no DATA / ERROR can ever flow through
-		// recover; self-COMPLETE.
-		const srcUnsub = subscribeOr<unknown>(
-			source as Node,
-			(msgs) => {
-				for (const m of msgs as Messages) {
-					if (m[0] === DATA) {
-						a.emit(m[1] as T);
-					} else if (m[0] === ERROR) {
-						try {
-							a.emit(recover(m[1]));
-						} catch (recoverErr) {
-							a.down([[ERROR, recoverErr]]);
-						}
-					} else if (m[0] === COMPLETE) {
-						a.down([[COMPLETE]]);
-					}
-				}
-			},
-			() => {
-				a.down([[COMPLETE]]);
-			},
-		);
-		return {
-			onDeactivation: () => {
-				srcUnsub();
-			},
-		};
-	}, operatorOpts(opts));
-}
-
-/**
- * Options for {@link valve}.
- *
- * Extends {@link ExtraOpts} with `abortInFlight` (Phase 13.E / DS-13.E).
- */
-export type ValveOpts = ExtraOpts & {
-	/**
-	 * Optional `AbortController`. When supplied AND the `control` node flips
-	 * from truthy → falsy, `valve` calls `controller.abort()` automatically.
-	 * Useful for "panic stop" / "kill in-flight LLM call" patterns where
-	 * cutting reactive propagation alone leaves an in-flight async boundary
-	 * (HTTP, fetch, adapter call) burning resources.
-	 *
-	 * **Caller contract.** The caller threads `controller.signal` into the
-	 * async boundary they want to cancel (e.g. `adapter.invoke({ signal })`).
-	 * `valve` only fires `controller.abort()` — it does not own the
-	 * controller's lifecycle.
-	 *
-	 * **AB-3 factory form.** Pass `() => AbortController | undefined` instead
-	 * of a bare controller to fix the panic-toggle (open→closed→open→closed)
-	 * re-mint ergonomics: `valve` calls the factory on each truthy→falsy edge
-	 * to obtain the controller currently wired into the in-flight call, so
-	 * the caller can mint a fresh controller per cycle without re-constructing
-	 * the valve. Returning `undefined` (nothing in flight) is a no-op.
-	 *
-	 * **Edge cases.**
-	 * - Already-aborted controller: `valve` calls `abort()` again, which is a
-	 *   no-op per `AbortController` spec.
-	 * - Control node never delivers DATA (stays SENTINEL): no abort fires,
-	 *   even though `control` is "effectively closed" — the abort triggers
-	 *   on the falsy *transition*, not on the closed state itself. Pass an
-	 *   explicit `state(false)` if you want activation-time abort.
-	 * - Source emits ERROR or COMPLETE: `valve` does not auto-abort; the
-	 *   caller's signal handling on the async boundary already covers
-	 *   terminal-error cases.
-	 */
-	abortInFlight?: AbortInFlightOpt;
-};
-
-/**
- * Forwards upstream `DATA` only while `control.get()` is truthy; when closed, emits `RESOLVED`
- * instead of repeating the last value (value-level valve). For protocol pause/resume, use default
- * node PAUSE/RESUME behavior.
- *
- * **`abortInFlight` (Phase 13.E).** Pass an `AbortController` in `opts` to
- * have `valve` call `controller.abort()` automatically when the gate flips
- * from truthy → falsy. Pairs with `adapter.invoke({ signal })` so closing
- * the valve cancels the in-flight async boundary in addition to cutting
- * reactive propagation.
- *
- * @param source - Upstream value node.
- * @param control - Boolean node; when falsy, output stays "closed" for that tick.
- * @param opts - Optional {@link ValveOpts}.
- * @returns `Node<T>` gated by `control`.
- *
- * @example
- * ```ts
- * import { valve, state } from "@graphrefly/pure-ts";
- *
- * const data = state(1);
- * const open = state(true);
- * valve(data, open);
- *
- * // With abortInFlight — close-the-gate cancels the LLM call:
- * const ctrl = new AbortController();
- * adapter.invoke(messages, { signal: ctrl.signal });
- * valve(streamTopic.latest, open, { abortInFlight: ctrl });
- * open.emit(false); // → ctrl.abort() fires
- * ```
- *
- * @category extra
- */
-export function valve<T>(source: Node<T>, control: Node<boolean>, opts?: ValveOpts): Node<T> {
-	const { abortInFlight, ...nodeOpts } = opts ?? {};
-	// Track previous control state so we can detect the truthy → falsy edge.
-	// `undefined` (initial) is treated as "closed-but-no-prior-state" — we
-	// only fire `abort()` on a real DATA-driven transition, never on
-	// activation. This matches the JSDoc edge-case contract.
-	let prevControlValue: boolean | undefined;
-	return node<T>(
-		[source as Node, control as Node],
-		(data, a, ctx) => {
-			const batch1 = data[1];
-			// undefined = control never sent DATA (gate closed); falsy = explicitly closed.
-			const controlValue = batch1 != null && batch1.length > 0 ? batch1.at(-1) : ctx.prevData[1];
-			if (abortInFlight != null) {
-				// Truthy → falsy edge: fire abort. Skip if the prior state was
-				// also falsy (no edge) or undefined (activation, no prior).
-				if (prevControlValue === true && !controlValue) {
-					fireAbortInFlight(abortInFlight);
-				}
-				prevControlValue = controlValue ? true : controlValue == null ? undefined : false;
-			}
-			// Source-side terminal forwarding (D3, 2026-05-01):
-			// `completeWhenDepsComplete: false` is set on the node opts so
-			// control termination does NOT auto-complete the valve (gate
-			// completion ≠ source termination). Source termination DOES
-			// matter — explicitly forward COMPLETE / ERROR from source so
-			// downstream sees natural termination.
-			if (ctx.terminalDeps[0] !== undefined) {
-				const termType = ctx.terminalDeps[0];
-				if (termType === COMPLETE) {
-					a.down([[COMPLETE]]);
-					return;
-				}
-				if (termType === ERROR) {
-					// Source errored — propagate. ERROR payload comes via
-					// data[0] which the framework folds into a single ERROR
-					// for the dependent. We re-emit a generic ERROR; the
-					// original payload is preserved in the source's terminal
-					// event for upstream observability.
-					a.down([[ERROR, new Error("valve: source errored")]]);
-					return;
-				}
-			}
-			if (!controlValue) {
-				a.down([[RESOLVED]]);
-				return;
-			}
-			const batch0 = data[0];
-			if (batch0 != null && batch0.length > 0) {
-				// Source data this wave: forward it.
-				for (const v of batch0) a.emit(v as T);
-				return;
-			}
-			// Control just opened this wave but source didn't fire this wave.
-			// Re-emit the last known source value so downstream sees the current
-			// value when the gate opens (only when source has a prior value).
-			if (batch1 != null && batch1.length > 0 && ctx.prevData[0] !== undefined) {
-				a.emit(ctx.prevData[0] as T);
-				return;
-			}
-			a.down([[RESOLVED]]);
-		},
-		// valve fires on either source-alone (forwards) or control-alone
-		// (re-emits prior source when gate opens). Needs partial firing so
-		// the control wave can reach fn before source has ever delivered.
-		// **Asymmetry vs `withLatestFrom` (Phase 10.5, 2026-04-29):**
-		// `withLatestFrom` flipped to `partial: false` to fix the W1
-		// initial-pair drop. `valve` cannot make the same flip — its
-		// control-alone-on-activation semantic explicitly requires firing
-		// before `source` delivers. Consequence: `valve(stateSource,
-		// stateControl)` may drop the initial paired emission when both
-		// deps are state-cached at activation, same shape as the pre-fix
-		// `withLatestFrom`. Callers that need the initial-pair guarantee
-		// should use the §28 closure-mirror pattern (capture
-		// `source.cache` + `control.cache` at wiring time, read inside a
-		// downstream fn). See COMPOSITION-GUIDE §28.
-		//
-		// **D3 lock (2026-05-01):** `completeWhenDepsComplete: false` so
-		// control termination does NOT auto-complete the valve — future
-		// "permanently close gate" patterns (caller wants gateOpen to
-		// complete without source termination) work cleanly. Source
-		// termination is forwarded explicitly via the `terminalDeps[0]`
-		// branch above.
-		{ ...partialOperatorOpts(nodeOpts), completeWhenDepsComplete: false },
-	);
-}
-
-/**
- * RxJS-named alias for {@link rescue} — replaces upstream `ERROR` with a recovered value.
- *
- * @param source - Upstream node.
- * @param recover - Maps error payload to replacement value.
- * @param opts - Optional node options (excluding `describeKind`).
- * @returns Recovered stream; behavior matches `rescue`.
- *
- * @example
- * ```ts
- * import { catchError, state } from "@graphrefly/pure-ts";
- *
- * catchError(state(0), () => 0);
- * ```
- *
- * @category extra
- */
-export const catchError = rescue;
-
-// ---------------------------------------------------------------------------
-// settle (Phase 13.L / DS-13.L) — convergence detector
-// ---------------------------------------------------------------------------
-
-/**
- * Options for {@link settle}.
- */
-export type SettleOpts<T> = ExtraOpts & {
-	/**
-	 * Consecutive upstream waves with no DATA (or with DATA equal to the
-	 * previous DATA via {@link SettleOpts.equals}) that must elapse before
-	 * `settle` declares the source converged and emits `COMPLETE`. Required.
-	 *
-	 * "Wave" is one upstream emission round — a `DATA` batch, or a bare
-	 * `RESOLVED` end-of-wave marker. Each call to `settle`'s fn body counts
-	 * as one wave.
-	 */
-	quietWaves: number;
-	/**
-	 * Optional hard cap on total waves before forced completion. When the
-	 * upstream fires `maxWaves` times without converging, `settle` emits
-	 * `COMPLETE` carrying the last-seen DATA (if any). Useful as a
-	 * runaway-loop guard for shared-state termination patterns where the
-	 * source might never settle on its own.
-	 */
-	maxWaves?: number;
-	/**
-	 * Optional value-equality comparator. When provided, an upstream `DATA`
-	 * whose value satisfies `equals(prev, next)` does NOT reset the quiet
-	 * counter — it is considered a "no-change" wave. Without `equals`, ANY
-	 * `DATA` resets the counter (strict "no-DATA-arrival" semantics).
-	 *
-	 * Use `Object.is` for SameValue equality; `(a, b) => a === b` for
-	 * strict-equality; lodash `isEqual` for deep equality.
-	 */
-	equals?: (a: T, b: T) => boolean;
-};
-
-/**
- * Reactive operator form of `awaitSettled` — emits each upstream `DATA`
- * unchanged, watches for convergence, and emits `COMPLETE` once the source
- * has been quiet for `quietWaves` consecutive waves.
- *
- * **Boundary vs `awaitSettled`** (the existing one-shot Promise sugar in
- * `extra/sources`): `awaitSettled` resolves a `Promise<T>` once the source
- * settles to a matching value. `settle` is the operator-level reactive form
- * — it stays in the graph, can complete on convergence, and (optionally,
- * not yet shipped) re-arms if upstream resumes.
- *
- * **Use cases.**
- * - Shared-state pattern termination: parent waits for "no new updates on
- *   the blackboard for N reactive waves" → emit final state and complete.
- * - Multi-agent quiescence: hub topic stops carrying spawn requests for N
- *   waves → harness considers the run done.
- * - Streaming aggregator: stop accumulating when the source stops producing.
- *
- * **Topology.** `settle(source)` exposes a single edge in `describe()` —
- * the operator forwards every DATA, so consumers see live values up to the
- * `COMPLETE`. The convergence counter is internal closure state (visible
- * to inspection only via the operator's own meta).
- *
- * **Spec compliance.**
- * - No polling (spec §5.8): the wave counter advances only on real upstream
- *   waves; no `setTimeout` or busy-wait.
- * - No imperative trigger (spec §5.9): the operator emits via the standard
- *   reactive `actions` API.
- * - Wave is the unit of progress (spec §1.3): "no DATA for N waves" means
- *   N consecutive operator-fn invocations where the upstream batch had no
- *   DATA (or DATA equal to prior, when `equals` is supplied).
- *
- * @param source - Upstream node.
- * @param opts - {@link SettleOpts}.
- * @returns `Node<T>` that forwards each upstream DATA and emits COMPLETE on
- *   convergence (or on `maxWaves` exhaustion).
- *
- * @example
- * ```ts
- * import { settle, state } from "@graphrefly/pure-ts";
- *
- * const board = state<Update>({ ... });
- * const final = settle(board, { quietWaves: 3, equals: deepEqual });
- * // After 3 consecutive waves with no new (deep-different) update,
- * // `final` completes carrying the last-stable Update value.
- * ```
- *
- * @category extra
- */
-export function settle<T>(source: Node<T>, opts: SettleOpts<T>): Node<T> {
-	const { quietWaves, maxWaves, equals, ...nodeOpts } = opts;
-	if (!Number.isInteger(quietWaves) || quietWaves < 1) {
-		throw new RangeError(
-			`settle: quietWaves must be a positive integer (got ${String(quietWaves)})`,
-		);
-	}
-	if (maxWaves != null && (!Number.isInteger(maxWaves) || maxWaves < 1)) {
-		throw new RangeError(
-			`settle: maxWaves must be a positive integer when set (got ${String(maxWaves)})`,
-		);
-	}
-	let lastValue: T | undefined;
-	let hasValue = false;
-	let quietCount = 0;
-	let waveCount = 0;
-	let completed = false;
-	return node<T>(
-		[source as Node],
-		(data, a) => {
-			if (completed) {
-				a.down([[RESOLVED]]);
-				return;
-			}
-			waveCount += 1;
-			const batch0 = data[0];
-			let sawChange = false;
-			if (batch0 != null && batch0.length > 0) {
-				for (const v of batch0) {
-					const next = v as T;
-					const isChange = !hasValue || equals == null || !equals(lastValue as T, next);
-					if (isChange) sawChange = true;
-					lastValue = next;
-					hasValue = true;
-					a.emit(next);
-				}
-			}
-			if (sawChange) {
-				quietCount = 0;
-			} else {
-				quietCount += 1;
-			}
-			const settled = hasValue && quietCount >= quietWaves;
-			const exhausted = maxWaves != null && waveCount >= maxWaves;
-			if (settled || exhausted) {
-				completed = true;
-				a.down([[COMPLETE]]);
-				return;
-			}
-			// No DATA forwarded this wave AND not yet settled — emit RESOLVED so
-			// downstream sees the wave (rather than a "stuck DIRTY").
-			if (batch0 == null || batch0.length === 0) {
-				a.down([[RESOLVED]]);
-			}
-		},
-		partialOperatorOpts(nodeOpts),
-	);
-}
diff --git a/packages/pure-ts/src/extra/operators/higher-order.ts b/packages/pure-ts/src/extra/operators/higher-order.ts
deleted file mode 100644
index 204009ff..00000000
--- a/packages/pure-ts/src/extra/operators/higher-order.ts
+++ /dev/null
@@ -1,561 +0,0 @@
-/**
- * Higher-order operators (roadmap §2.2) — operators whose project fn returns
- * a `NodeInput<R>` for each outer DATA. The shared `forwardInner` helper
- * subscribes to each inner node and folds its lifecycle (`COMPLETE` → finish,
- * `ERROR` → finish + propagate, `INVALIDATE`/`PAUSE`/`RESUME`/`TEARDOWN` →
- * intentionally dropped) into the outer's emit stream.
- *
- * `switchMap` (cancel-on-new), `exhaustMap` (drop-during-active), `concatMap`
- * (sequential queue), `mergeMap` / `flatMap` (parallel up to `concurrent`).
- */
-
-import type { NodeActions } from "../../core/config.js";
-import {
-	COMPLETE,
-	DATA,
-	DIRTY,
-	ERROR,
-	type Messages,
-	RESOLVED,
-	START,
-} from "../../core/messages.js";
-import { factoryTag } from "../../core/meta.js";
-import { type Node, node } from "../../core/node.js";
-import { trySubscribeOrDead } from "../../core/subscribe-error.js";
-import { fromAny, type NodeInput } from "../sources/index.js";
-import {
-	type AbortInFlightOpt,
-	type ExtraOpts,
-	fireAbortInFlight,
-	operatorOpts,
-} from "./_internal.js";
-
-/** DS-14.5 / AB-2 — shared `*Map` opts: `ExtraOpts` + `abortInFlight`. */
-export type HigherOrderOpts = ExtraOpts & {
-	/**
-	 * AB-2/AB-3 — fired when the operator force-tears an in-flight inner
-	 * (supersede / source-ERROR / deactivation), so an inner that wraps an
-	 * `adapter.invoke({ signal })` LLM call actually stops instead of burning
-	 * tokens past the cut. Bare `AbortController` or factory `() =>
-	 * AbortController | undefined` (see {@link AbortInFlightOpt}). Natural
-	 * inner completion does NOT fire it.
-	 *
-	 * **`mergeMap` + `concurrent > 1` caveat:** `clearAll()` fires
-	 * `abortInFlight` ONCE for the whole batch, so the factory form yields a
-	 * single controller — only one of N concurrent in-flight calls is
-	 * cancelled. For per-inner cancellation under concurrency, thread a
-	 * distinct signal into each inner inside the `project` fn instead of
-	 * relying on this opt.
-	 */
-	abortInFlight?: AbortInFlightOpt;
-};
-
-/**
- * Forward an inner node's messages into the outer operator's actions.
- *
- * Returns `() => void` on a live inner subscription (caller stores in
- * its `innerUnsub` slot); returns `undefined` when the inner is Dead
- * at subscribe time (R2.2.7.b — non-resubscribable + terminal). In the
- * Dead case `onInnerComplete()` fires SYNCHRONOUSLY before returning so
- * the outer operator's tracker (switchMap's `innerUnsub`, mergeMap's
- * `innerStops` set, concatMap's queue, etc.) sees the "inner is done"
- * state before observing `undefined` as the return — i.e., when the
- * caller assigns the return value to its slot, the slot was ALREADY
- * cleared by `onInnerComplete`'s `clearInner()` / equivalent. The
- * undefined return preserves that cleared state.
- *
- * Prior shape (subscribeOr-based) had a critical bug: subscribeOr
- * returned `() => {}` no-op on Dead, which the caller assigned to its
- * `innerUnsub` slot AFTER `clearInner()` had nilled it during the
- * synchronous Dead path. Result: `innerUnsub` ended up truthy
- * (no-op closure), breaking switchMap's "source done && no inner →
- * COMPLETE" check, exhaustMap's "no inner → start next" gate, and
- * concatMap's queue-pump guard. Fix: return `undefined` so the
- * cleared state propagates to the caller's slot.
- */
-function forwardInner<R>(
-	inner: Node<R>,
-	a: NodeActions,
-	onInnerComplete: () => void,
-): (() => void) | undefined {
-	let finished = false;
-	const finish = (): void => {
-		if (finished) return;
-		finished = true;
-		onInnerComplete();
-	};
-
-	// R2.2.7.b: Dead inner → treat as immediate inner-Complete so the
-	// *Map operator advances (mergeMap decrements active, switchMap
-	// looks for the next outer DATA, concatMap drains queue, etc.).
-	// Mirrors Rust higher_order.rs `on_complete_for_dead` plumbing.
-	let unsubLive: (() => void) | undefined;
-	const outcome = trySubscribeOrDead<unknown>(inner as Node, (msgs) => {
-		let sawComplete = false;
-		let sawError = false;
-		for (const m of msgs as Messages) {
-			if (m[0] === START) continue;
-			if (m[0] === DATA) {
-				a.emit(m[1] as R);
-			} else if (m[0] === COMPLETE) {
-				sawComplete = true;
-			} else if (m[0] === ERROR) {
-				sawError = true;
-				a.down([m]);
-			} else if (m[0] === DIRTY || m[0] === RESOLVED) {
-				// Reactive wave signals forwarded to outer output.
-				a.down([m]);
-			}
-			// INVALIDATE, PAUSE, RESUME, TEARDOWN from inner are intentionally
-			// dropped. Inner lifecycle and flow-control signals are internal to
-			// the *Map operator. INVALIDATE is dropped because the inner will
-			// follow up with DIRTY+DATA when it recomputes — forwarding
-			// INVALIDATE to the outer output's sinks is redundant and wrong for
-			// mergeMap (one inner's cache state must not invalidate the whole
-			// merged output). PAUSE/RESUME/TEARDOWN: RxJS/callbag precedent —
-			// no backpressure forwarding in merge-style operators.
-		}
-		if (sawError) {
-			unsubLive?.();
-			unsubLive = undefined;
-			finish();
-		} else if (sawComplete) {
-			finish();
-		}
-	});
-
-	if (outcome.kind === "dead") {
-		// Dead inner → fire onInnerComplete synchronously, no live
-		// subscription, no cleanup closure to return.
-		finish();
-		return undefined;
-	}
-
-	unsubLive = outcome.unsub;
-	// P4 START handshake guarantees: subscribe delivers [[START], [DATA, cache]]
-	// synchronously for settled nodes. Any relevant state is already handled by
-	// the callback above — no post-subscribe .status/.cache reads needed.
-	return () => {
-		unsubLive?.();
-		unsubLive = undefined;
-	};
-}
-
-/**
- * Maps each settled value to an inner node; unsubscribes the previous inner (Rx-style `switchMap`).
- *
- * @param source - Upstream node.
- * @param project - Maps each outer value to an inner source shape (`Node`, scalar, `PromiseLike`, `Iterable`, or `AsyncIterable`) coerced via {@link fromAny}.
- * @param opts - Optional {@link NodeOptions} (excluding `describeKind`).
- * @returns `Node<R>` - Emissions from the active inner subscription.
- * @example
- * ```ts
- * import { switchMap, state } from "@graphrefly/pure-ts";
- *
- * const src = state(0);
- * switchMap(src, (n) => state((n as number) * 2));
- * ```
- *
- * @category extra
- */
-export function switchMap<T, R>(
-	source: Node<T>,
-	project: (value: T) => NodeInput<R>,
-	opts?: HigherOrderOpts,
-): Node<R> {
-	const { abortInFlight, ...nodeOpts } = opts ?? {};
-	let innerUnsub: (() => void) | undefined;
-	let sourceDone = false;
-
-	function clearInner(): void {
-		innerUnsub?.();
-		innerUnsub = undefined;
-	}
-	/** Tear an in-flight inner due to force-cancel (supersede / deactivation). */
-	function cancelInner(): void {
-		if (innerUnsub) fireAbortInFlight(abortInFlight);
-		clearInner();
-	}
-
-	return node<R>(
-		[source as Node],
-		(data, a, ctx) => {
-			// Source ERROR: force-cancel inner, autoError forwards
-			if (ctx.terminalDeps[0] != null && ctx.terminalDeps[0] !== true) {
-				cancelInner();
-				return;
-			}
-			// Source COMPLETE
-			if (ctx.terminalDeps[0] === true) {
-				sourceDone = true;
-				if (!innerUnsub) a.down([[COMPLETE]]);
-				// inner active: onInnerComplete will fire COMPLETE later
-				return;
-			}
-
-			const batch0 = data[0];
-			if (batch0 == null || batch0.length === 0) return;
-
-			// Switch: only the latest value matters; skip to the last in the
-			// batch to avoid creating and immediately discarding N-1 inners.
-			// cancelInner() supersedes any prior-wave inner — fires
-			// abortInFlight so its in-flight async boundary (LLM call) stops.
-			cancelInner();
-			innerUnsub = forwardInner(
-				fromAny(project(batch0[batch0.length - 1] as T), { iter: true }),
-				a,
-				() => {
-					clearInner();
-					if (sourceDone) a.down([[COMPLETE]]);
-				},
-			);
-
-			// Deactivate-only cleanup: must NOT fire before fn reruns
-			// because the terminal wave needs to see innerUnsub intact.
-			return {
-				onDeactivation: () => {
-					cancelInner();
-					sourceDone = false;
-				},
-			};
-		},
-		{
-			...operatorOpts(nodeOpts),
-			completeWhenDepsComplete: false,
-			// R2.7.1 opt-in: source COMPLETE / ERROR alone must release the
-			// first-run gate so the empty-outer terminal path forwards
-			// `[[COMPLETE]]` / `[[ERROR]]` downstream. Without this an outer
-			// that COMPLETEs without ever emitting DATA holds the gate forever
-			// and downstream never settles.
-			terminalAsRealInput: true,
-			meta: { ...factoryTag("switchMap"), ...(nodeOpts.meta ?? {}) },
-		},
-	);
-}
-
-/**
- * Like {@link switchMap}, but ignores outer `DATA` while an inner subscription is active (`exhaustMap`).
- *
- * @param source - Upstream node.
- * @param project - Maps each outer value to an inner source shape (`Node`, scalar, `PromiseLike`, `Iterable`, or `AsyncIterable`) coerced via {@link fromAny}.
- * @param opts - Optional {@link NodeOptions} (excluding `describeKind`).
- * @returns `Node<R>` - Emissions from the active inner while it runs.
- * @example
- * ```ts
- * import { exhaustMap, state } from "@graphrefly/pure-ts";
- *
- * exhaustMap(state(0), () => state(1));
- * ```
- *
- * @category extra
- */
-export function exhaustMap<T, R>(
-	source: Node<T>,
-	project: (value: T) => NodeInput<R>,
-	opts?: HigherOrderOpts,
-): Node<R> {
-	const { abortInFlight, ...nodeOpts } = opts ?? {};
-	let innerUnsub: (() => void) | undefined;
-	let sourceDone = false;
-
-	function clearInner(): void {
-		innerUnsub?.();
-		innerUnsub = undefined;
-	}
-	function cancelInner(): void {
-		if (innerUnsub) fireAbortInFlight(abortInFlight);
-		clearInner();
-	}
-
-	return node<R>(
-		[source as Node],
-		(data, a, ctx) => {
-			if (ctx.terminalDeps[0] != null && ctx.terminalDeps[0] !== true) {
-				cancelInner();
-				return;
-			}
-			if (ctx.terminalDeps[0] === true) {
-				sourceDone = true;
-				if (!innerUnsub) a.down([[COMPLETE]]);
-				return;
-			}
-
-			const batch0 = data[0];
-			if (batch0 == null || batch0.length === 0) return;
-
-			if (innerUnsub === undefined) {
-				// First value in batch wins (FIFO exhaustMap gate)
-				innerUnsub = forwardInner(fromAny(project(batch0[0] as T), { iter: true }), a, () => {
-					clearInner();
-					if (sourceDone) a.down([[COMPLETE]]);
-				});
-			} else {
-				// Inner active — drop, settle the dep-wave
-				a.down([[RESOLVED]]);
-			}
-
-			return {
-				onDeactivation: () => {
-					cancelInner();
-					sourceDone = false;
-				},
-			};
-		},
-		{
-			...operatorOpts(nodeOpts),
-			completeWhenDepsComplete: false,
-			// R2.7.1 — see switchMap above; empty-outer COMPLETE must forward.
-			terminalAsRealInput: true,
-		},
-	);
-}
-
-/**
- * Enqueues each outer value and subscribes to inners one at a time (`concatMap`).
- *
- * @param source - Upstream node.
- * @param project - Maps each outer value to an inner source shape (`Node`, scalar, `PromiseLike`, `Iterable`, or `AsyncIterable`) coerced via {@link fromAny}.
- * @param opts - Optional {@link NodeOptions} (excluding `describeKind`).
- * @returns `Node<R>` - Sequential concatenation of inner streams.
- * @example
- * ```ts
- * import { concatMap, state } from "@graphrefly/pure-ts";
- *
- * concatMap(state(0), (n) => state((n as number) + 1));
- * ```
- *
- * @category extra
- */
-export function concatMap<T, R>(
-	source: Node<T>,
-	project: (value: T) => NodeInput<R>,
-	opts?: HigherOrderOpts & { maxBuffer?: number },
-): Node<R> {
-	const { maxBuffer: maxBuf, abortInFlight, ...concatNodeOpts } = opts ?? {};
-	const queue: T[] = [];
-	let innerUnsub: (() => void) | undefined;
-	let sourceDone = false;
-	let actions: NodeActions | undefined;
-
-	function clearInner(): void {
-		innerUnsub?.();
-		innerUnsub = undefined;
-	}
-	function cancelInner(): void {
-		if (innerUnsub) fireAbortInFlight(abortInFlight);
-		clearInner();
-	}
-
-	function tryPump(): void {
-		if (!actions || innerUnsub !== undefined) return;
-		if (queue.length === 0) {
-			if (sourceDone) actions.down([[COMPLETE]]);
-			return;
-		}
-		const v = queue.shift()!;
-		innerUnsub = forwardInner(fromAny(project(v), { iter: true }), actions, () => {
-			clearInner();
-			tryPump();
-		});
-	}
-
-	function enqueue(v: T): void {
-		if (maxBuf && maxBuf > 0 && queue.length >= maxBuf) queue.shift();
-		queue.push(v);
-		tryPump();
-	}
-
-	return node<R>(
-		[source as Node],
-		(data, a, ctx) => {
-			actions = a;
-
-			if (ctx.terminalDeps[0] != null && ctx.terminalDeps[0] !== true) {
-				cancelInner();
-				queue.length = 0;
-				return;
-			}
-			if (ctx.terminalDeps[0] === true) {
-				sourceDone = true;
-				tryPump();
-				return;
-			}
-
-			const batch0 = data[0];
-			if (batch0 == null || batch0.length === 0) return;
-
-			for (const v of batch0 as T[]) {
-				enqueue(v as T);
-			}
-
-			return {
-				onDeactivation: () => {
-					cancelInner();
-					queue.length = 0;
-					sourceDone = false;
-				},
-			};
-		},
-		{
-			...operatorOpts(concatNodeOpts),
-			completeWhenDepsComplete: false,
-			// R2.7.1 — see switchMap above; empty-outer COMPLETE must forward
-			// (queue is empty, tryPump emits COMPLETE).
-			terminalAsRealInput: true,
-		},
-	);
-}
-
-/** Options for {@link mergeMap}. */
-export type MergeMapOptions = HigherOrderOpts & {
-	/** Maximum number of concurrent inner subscriptions. Default: `Infinity` (unbounded). */
-	concurrent?: number;
-};
-
-/**
- * Subscribes to inner nodes in parallel (up to `concurrent`) and merges outputs (`mergeMap` / `flatMap`).
- *
- * @param source - Upstream node.
- * @param project - Maps each outer value to an inner source shape (`Node`, scalar, `PromiseLike`, `Iterable`, or `AsyncIterable`) coerced via {@link fromAny}.
- * @param opts - Optional options including `concurrent` limit.
- * @returns `Node<R>` - Merged output of all active inners; completes when the outer and every inner complete.
- *
- * @remarks
- * **ERROR handling:** An `ERROR` from the outer source cancels all active inner
- * subscriptions and propagates the error downstream. An `ERROR` from an inner
- * subscription propagates downstream immediately but does **not** cancel sibling
- * inner subscriptions — other active inners continue until they complete or the
- * outer errors/completes. This is intentional: for parallel work, isolating
- * failures per-inner is more useful than Rx-style "first error cancels all."
- *
- * @example
- * ```ts
- * import { mergeMap, state } from "@graphrefly/pure-ts";
- *
- * // Unbounded (default)
- * mergeMap(state(0), (n) => state((n as number) + 1));
- *
- * // Limited concurrency
- * mergeMap(state(0), (n) => state((n as number) + 1), { concurrent: 3 });
- * ```
- *
- * @category extra
- */
-export function mergeMap<T, R>(
-	source: Node<T>,
-	project: (value: T) => NodeInput<R>,
-	opts?: MergeMapOptions,
-): Node<R> {
-	const { concurrent: concurrentOpt, abortInFlight, ...mergeNodeOpts } = opts ?? {};
-	const maxConcurrent =
-		concurrentOpt != null && concurrentOpt > 0 ? concurrentOpt : Number.POSITIVE_INFINITY;
-
-	let active = 0;
-	let sourceDone = false;
-	const innerStops = new Set<() => void>();
-	const buffer: T[] = [];
-	let actions: NodeActions | undefined;
-
-	function tryComplete(): void {
-		if (sourceDone && active === 0 && buffer.length === 0 && actions) {
-			actions.down([[COMPLETE]]);
-		}
-	}
-
-	function spawn(v: T): void {
-		if (!actions) return;
-		active++;
-		// Use `let` (not `const`) so the closure can reference `stop` safely even
-		// if onInnerComplete fires synchronously (e.g. already-completed inner node).
-		let stop: (() => void) | undefined;
-		stop = forwardInner(fromAny(project(v), { iter: true }), actions, () => {
-			if (stop) innerStops.delete(stop);
-			active--;
-			drainBuffer();
-			tryComplete();
-		});
-		// forwardInner returns `undefined` for Dead inners (R2.2.7.b);
-		// the onInnerComplete callback has already decremented `active`
-		// and run drainBuffer/tryComplete synchronously. Nothing to
-		// register in `innerStops`.
-		if (stop) innerStops.add(stop);
-	}
-
-	function drainBuffer(): void {
-		while (buffer.length > 0 && active < maxConcurrent) {
-			spawn(buffer.shift()!);
-		}
-	}
-
-	function enqueue(v: T): void {
-		if (active < maxConcurrent) spawn(v);
-		else buffer.push(v);
-	}
-
-	function clearAll(): void {
-		// Force-teardown of all active inners (source-ERROR / deactivation) —
-		// fire abortInFlight so their in-flight async boundaries stop.
-		if (innerStops.size > 0) fireAbortInFlight(abortInFlight);
-		for (const u of innerStops) u();
-		innerStops.clear();
-		active = 0;
-		buffer.length = 0;
-	}
-
-	return node<R>(
-		[source as Node],
-		(data, a, ctx) => {
-			actions = a;
-
-			if (ctx.terminalDeps[0] != null && ctx.terminalDeps[0] !== true) {
-				clearAll();
-				return;
-			}
-			if (ctx.terminalDeps[0] === true) {
-				sourceDone = true;
-				tryComplete();
-				return;
-			}
-
-			const batch0 = data[0];
-			if (batch0 == null || batch0.length === 0) return;
-
-			for (const v of batch0 as T[]) {
-				enqueue(v as T);
-			}
-
-			return {
-				onDeactivation: () => {
-					clearAll();
-					sourceDone = false;
-				},
-			};
-		},
-		{
-			...operatorOpts(mergeNodeOpts),
-			completeWhenDepsComplete: false,
-			// R2.7.1 — see switchMap above; empty-outer COMPLETE must forward
-			// (active===0 + buffer empty → tryComplete emits COMPLETE).
-			terminalAsRealInput: true,
-		},
-	);
-}
-
-/**
- * RxJS-named alias for {@link mergeMap} — projects each `DATA` to an inner node and merges outputs.
- *
- * @param source - Upstream node.
- * @param project - Returns an inner `Node<R>` per value.
- * @param opts - Optional concurrency cap and node options (excluding `describeKind`).
- * @returns Merged projection; behavior matches `mergeMap`.
- *
- * @example
- * ```ts
- * import { flatMap, state } from "@graphrefly/pure-ts";
- *
- * flatMap(state(0), (n) => state(n));
- * ```
- *
- * @category extra
- */
-export const flatMap = mergeMap;
diff --git a/packages/pure-ts/src/extra/operators/index.ts b/packages/pure-ts/src/extra/operators/index.ts
deleted file mode 100644
index c77c64a8..00000000
--- a/packages/pure-ts/src/extra/operators/index.ts
+++ /dev/null
@@ -1,30 +0,0 @@
-/**
- * Tier 1 sync operators (roadmap §2.1) and Tier 2 async/dynamic operators
- * (roadmap §2.2).
- *
- * Thin barrel — every operator lives in a category sub-file:
- * - `transform.ts` — `map`, `filter`, `scan`, `reduce`,
- *   `distinctUntilChanged`, `pairwise`
- * - `take.ts` — `take`, `skip`, `takeWhile`, `takeUntil`, `first`, `last`,
- *   `find`, `elementAt`
- * - `combine.ts` — `combine` / `combineLatest`, `withLatestFrom`, `merge`,
- *   `zip`, `concat`, `race`
- * - `higher-order.ts` — `switchMap`, `exhaustMap`, `concatMap`,
- *   `mergeMap` / `flatMap`
- * - `time.ts` — `delay`, `debounce` / `debounceTime`, `throttle` /
- *   `throttleTime`, `sample`, `audit`, `interval`
- * - `buffer.ts` — `buffer`, `bufferCount`, `bufferTime`, `window`,
- *   `windowCount`, `windowTime`
- * - `control.ts` — `valve`, `rescue` / `catchError`, `pausable`, `repeat`,
- *   `tap`, `onFirstData` / `tapFirst`, `timeout`
- * - `_internal.ts` — shared `operatorOpts` / `partialOperatorOpts` /
- *   `gatedOperatorOpts` helpers and `ExtraOpts` alias.
- */
-
-export * from "./buffer.js";
-export * from "./combine.js";
-export * from "./control.js";
-export * from "./higher-order.js";
-export * from "./take.js";
-export * from "./time.js";
-export * from "./transform.js";
diff --git a/packages/pure-ts/src/extra/operators/take.ts b/packages/pure-ts/src/extra/operators/take.ts
deleted file mode 100644
index 445ca2d4..00000000
--- a/packages/pure-ts/src/extra/operators/take.ts
+++ /dev/null
@@ -1,486 +0,0 @@
-/**
- * Take / skip / find operators — bounded subsets of a stream.
- *
- * `take`, `skip`, `takeWhile`, `takeUntil`, `first`, `last`, `find`,
- * `elementAt` — counts and predicates that gate which `DATA` reaches the
- * downstream output.
- */
-
-import {
-	COMPLETE,
-	DATA,
-	ERROR,
-	type Message,
-	type Messages,
-	RESOLVED,
-} from "../../core/messages.js";
-import { factoryTag } from "../../core/meta.js";
-import { type Node, node } from "../../core/node.js";
-import { subscribeOr } from "../../core/subscribe-error.js";
-import { type ExtraOpts, operatorOpts } from "./_internal.js";
-import { filter } from "./transform.js";
-
-/**
- * Emits at most `count` **`DATA`** values, then **`COMPLETE`**. `RESOLVED` does not advance the counter.
- *
- * @param source - Upstream node.
- * @param count - Maximum `DATA` emissions (≤0 completes immediately).
- * @param opts - Optional {@link NodeOptions} (excluding `describeKind`).
- * @returns `Node<T>` - Limited stream.
- *
- * @example
- * ```ts
- * import { take, state } from "@graphrefly/pure-ts";
- *
- * const n = take(state(0), 3);
- * ```
- *
- * @category extra
- */
-export function take<T>(source: Node<T>, count: number, opts?: ExtraOpts): Node<T> {
-	if (count <= 0) {
-		// Lock 6.D (Phase 13.6.B): `ctx.store` no longer auto-wipes on
-		// deactivation. `take` semantically restarts on resubscribe, so
-		// install an `onDeactivation` cleanup that clears the
-		// `completed` flag.
-		let cleanup: { onDeactivation: () => void } | undefined;
-		return node<T>(
-			[source as Node],
-			(_d, a, ctx) => {
-				if (cleanup === undefined) {
-					const store = ctx.store;
-					cleanup = {
-						onDeactivation: () => {
-							delete store.completed;
-						},
-					};
-				}
-				if (ctx.store.completed) return cleanup;
-				ctx.store.completed = true;
-				a.down([[COMPLETE]]);
-				return cleanup;
-			},
-			{
-				...operatorOpts(opts),
-				completeWhenDepsComplete: false,
-				// Spec §2.7 R2.7.1 — Reduce-class. `take(0)` fires its own
-				// `[[COMPLETE]]` on first activation regardless of upstream
-				// state, so the gate must release even when source is
-				// CONFIGURED via an `empty()`-style COMPLETE-only producer.
-				terminalAsRealInput: true,
-				meta: { ...factoryTag("take", { count }), ...(opts?.meta ?? {}) },
-			},
-		);
-	}
-	// Lock 6.D: restart-from-zero semantic — clear `taken` / `done` on
-	// deactivation so a resubscribable `take(n)` cycle starts fresh.
-	let cleanup: { onDeactivation: () => void } | undefined;
-	return node<T>(
-		[source as Node],
-		(data, a, ctx) => {
-			if (cleanup === undefined) {
-				const store = ctx.store;
-				cleanup = {
-					onDeactivation: () => {
-						delete store.taken;
-						delete store.done;
-					},
-				};
-			}
-			if (!("taken" in ctx.store)) ctx.store.taken = 0;
-			if (ctx.store.done) {
-				a.down([[RESOLVED]]);
-				return cleanup;
-			}
-			// Upstream COMPLETE before count reached → forward COMPLETE.
-			if (ctx.terminalDeps[0] === true) {
-				ctx.store.done = true;
-				a.down([[COMPLETE]]);
-				return cleanup;
-			}
-			const batch0 = data[0];
-			if (batch0 == null || batch0.length === 0) {
-				a.down([[RESOLVED]]);
-				return cleanup;
-			}
-			// DATA wave: iterate full batch, stop at count
-			for (const v of batch0) {
-				(ctx.store.taken as number)++;
-				a.emit(v as T);
-				if ((ctx.store.taken as number) >= count) {
-					ctx.store.done = true;
-					a.down([[COMPLETE]]);
-					return cleanup;
-				}
-			}
-			return cleanup;
-		},
-		{
-			...operatorOpts(opts),
-			completeWhenDepsComplete: false,
-			// Spec §2.7 R2.7.1 — Reduce-class. `take(n>0)` forwards an
-			// upstream-COMPLETE-before-count-reached from inside fn via
-			// `ctx.terminalDeps[0] === true` → `[[COMPLETE]]`. Required so
-			// `take(empty(), n)` actually emits COMPLETE downstream
-			// (without the opt-in, `completeWhenDepsComplete: false` + gate
-			// holding on terminal-only = node stays alive forever).
-			terminalAsRealInput: true,
-			meta: { ...factoryTag("take", { count }), ...(opts?.meta ?? {}) },
-		},
-	);
-}
-
-/**
- * Skips the first `count` **`DATA`** emissions. `RESOLVED` does not advance the counter.
- *
- * @param source - Upstream node.
- * @param count - Number of `DATA` values to drop.
- * @param opts - Optional {@link NodeOptions} (excluding `describeKind`).
- * @returns `Node<T>` - Skipped stream.
- *
- * @example
- * ```ts
- * import { skip, state } from "@graphrefly/pure-ts";
- *
- * const n = skip(state(0), 2);
- * ```
- *
- * @category extra
- */
-export function skip<T>(source: Node<T>, count: number, opts?: ExtraOpts): Node<T> {
-	// Lock 6.D: clear skip counter on deactivation so resubscribe starts
-	// over at zero (skip-window applies again on re-attach).
-	let cleanup: { onDeactivation: () => void } | undefined;
-	return node<T>(
-		[source as Node],
-		(data, a, ctx) => {
-			if (cleanup === undefined) {
-				const store = ctx.store;
-				cleanup = {
-					onDeactivation: () => {
-						delete store.skipped;
-					},
-				};
-			}
-			if (!("skipped" in ctx.store)) ctx.store.skipped = 0;
-			const batch0 = data[0];
-			if (batch0 == null || batch0.length === 0) {
-				// RESOLVED wave — pass through
-				a.down([[RESOLVED]]);
-				return cleanup;
-			}
-			let emitted = false;
-			for (const v of batch0) {
-				(ctx.store.skipped as number)++;
-				if ((ctx.store.skipped as number) <= count) {
-					// Still in skip window
-				} else {
-					a.emit(v as T);
-					emitted = true;
-				}
-			}
-			if (!emitted) a.down([[RESOLVED]]);
-			return cleanup;
-		},
-		operatorOpts(opts),
-	);
-}
-
-/**
- * Emits while `predicate` holds; on first false, sends **`COMPLETE`**.
- *
- * @param source - Upstream node.
- * @param predicate - Continuation test.
- * @param opts - Optional {@link NodeOptions} (excluding `describeKind`).
- * @returns `Node<T>` - Truncated stream.
- *
- * @example
- * ```ts
- * import { takeWhile, state } from "@graphrefly/pure-ts";
- *
- * const n = takeWhile(state(1), (x) => x < 10);
- * ```
- *
- * @category extra
- */
-export function takeWhile<T>(
-	source: Node<T>,
-	predicate: (value: T) => boolean,
-	opts?: ExtraOpts,
-): Node<T> {
-	// Lock 6.D: restart predicate-gate semantic on resubscribe — clear
-	// `done` on deactivation.
-	let cleanup: { onDeactivation: () => void } | undefined;
-	return node<T>(
-		[source as Node],
-		(data, a, ctx) => {
-			if (cleanup === undefined) {
-				const store = ctx.store;
-				cleanup = {
-					onDeactivation: () => {
-						delete store.done;
-					},
-				};
-			}
-			if (ctx.store.done) {
-				a.down([[RESOLVED]]);
-				return cleanup;
-			}
-			// Upstream COMPLETE before predicate failed → forward COMPLETE.
-			// Mirrors `take`'s pattern (`take.ts:91`); needed because
-			// `completeWhenDepsComplete: false` disables auto-COMPLETE, so
-			// without an explicit forward `takeWhile(empty(), pred)` would
-			// never terminate downstream. (QA F1, DS-2.7.A `/qa` 2026-05-20.)
-			if (ctx.terminalDeps[0] === true) {
-				ctx.store.done = true;
-				a.down([[COMPLETE]]);
-				return cleanup;
-			}
-			const batch0 = data[0];
-			if (batch0 == null || batch0.length === 0) {
-				a.down([[RESOLVED]]);
-				return cleanup;
-			}
-			for (const v of batch0) {
-				if (!predicate(v as T)) {
-					ctx.store.done = true;
-					a.down([[COMPLETE]]);
-					return cleanup;
-				}
-				a.emit(v as T);
-			}
-			return cleanup;
-		},
-		{
-			...operatorOpts(opts),
-			completeWhenDepsComplete: false,
-			// Spec §2.7 R2.7.1 — Reduce-class. `takeWhile` forwards an
-			// upstream-COMPLETE-before-predicate-fail via `ctx.terminalDeps[0]`
-			// → `[[COMPLETE]]` (added in QA F1 alongside this opt-in). Required
-			// so `takeWhile(empty(), pred)` actually propagates COMPLETE
-			// downstream — without both the opt-in AND the terminal branch,
-			// `completeWhenDepsComplete: false` + gate-holding-on-terminal
-			// would leave the node alive forever.
-			terminalAsRealInput: true,
-		},
-	);
-}
-
-/**
- * Forwards `source` until `notifier` matches `predicate` (default: notifier **`DATA`**), then **`COMPLETE`**.
- *
- * @param source - Main upstream.
- * @param notifier - Triggers completion when `predicate(msg)` is true.
- * @param opts - Optional {@link NodeOptions}, plus `predicate` for custom notifier matching.
- * @returns `Node<T>` - Truncated stream.
- *
- * @example
- * ```ts
- * import { producer, takeUntil, state } from "@graphrefly/pure-ts";
- *
- * const src = state(1);
- * const stop = producer((_d, a) => a.emit(undefined));
- * const n = takeUntil(src, stop);
- * ```
- *
- * @category extra
- */
-export function takeUntil<T>(
-	source: Node<T>,
-	notifier: Node,
-	opts?: ExtraOpts & { predicate?: (msg: Message) => boolean },
-): Node<T> {
-	const pred = opts?.predicate ?? ((m: Message) => m[0] === DATA);
-	const { predicate: _, ...restOpts } = opts ?? {};
-	// Use producer pattern — subscribe to both manually for message-level control.
-	return node<T>(
-		(_data, a) => {
-			let stopped = false;
-			// R2.2.7.b: Dead source → take_until has nothing to forward,
-			// self-COMPLETE.
-			const srcUnsub = subscribeOr<unknown>(
-				source as Node,
-				(msgs) => {
-					if (stopped) return;
-					for (const m of msgs as Messages) {
-						if (stopped) return;
-						if (m[0] === DATA) a.emit(m[1] as T);
-						else if (m[0] === COMPLETE || m[0] === ERROR) {
-							stopped = true;
-							a.down([m]);
-						}
-					}
-				},
-				() => {
-					if (!stopped) {
-						stopped = true;
-						a.down([[COMPLETE]]);
-					}
-				},
-			);
-			// R2.2.7.b: Dead notifier → operator reduces to passthrough
-			// of source (notifier signal never fires).
-			const notUnsub = subscribeOr<unknown>(
-				notifier as Node,
-				(msgs) => {
-					if (stopped) return;
-					for (const m of msgs as Messages) {
-						if (stopped) return;
-						if (pred(m)) {
-							stopped = true;
-							a.down([[COMPLETE]]);
-							return;
-						}
-					}
-				},
-				() => {
-					// no-op — notifier signal never fires; passthrough source.
-				},
-			);
-			return {
-				onDeactivation: () => {
-					srcUnsub();
-					notUnsub();
-				},
-			};
-		},
-		operatorOpts(restOpts as ExtraOpts),
-	);
-}
-
-/**
- * Emits the first **`DATA`** then **`COMPLETE`** (same as `take(source, 1)`).
- *
- * @param source - Upstream node.
- * @param opts - Optional {@link NodeOptions} (excluding `describeKind`).
- * @returns `Node<T>` - Single-value stream.
- *
- * @example
- * ```ts
- * import { first, state } from "@graphrefly/pure-ts";
- *
- * const n = first(state(42));
- * ```
- *
- * @category extra
- */
-export function first<T>(source: Node<T>, opts?: ExtraOpts): Node<T> {
-	return take(source, 1, opts);
-}
-
-/**
- * Buffers values and emits the last **`DATA`** on **`COMPLETE`**; optional `defaultValue` if none arrived.
- *
- * @param source - Upstream node.
- * @param options - Optional {@link NodeOptions} and `defaultValue` when empty.
- * @returns `Node<T>` - Last-or-default node.
- *
- * @example
- * ```ts
- * import { last, state } from "@graphrefly/pure-ts";
- *
- * const n = last(state(1), { defaultValue: 0 });
- * ```
- *
- * @category extra
- */
-export function last<T>(source: Node<T>, options?: ExtraOpts & { defaultValue?: T }): Node<T> {
-	const { defaultValue, ...rest } = options ?? {};
-	const useDefault = options != null && Object.hasOwn(options, "defaultValue");
-	// Lock 6.D: clear accumulated last-value on deactivation so a fresh
-	// subscription cycle doesn't ship a stale "previous run's last".
-	let cleanup: { onDeactivation: () => void } | undefined;
-	return node<T>(
-		[source as Node],
-		(data, a, ctx) => {
-			if (cleanup === undefined) {
-				const store = ctx.store;
-				cleanup = {
-					onDeactivation: () => {
-						delete store.has;
-						delete store.latest;
-					},
-				};
-			}
-			// COMPLETE (terminal === true): emit latest or default, then COMPLETE.
-			// ERROR: autoError propagates automatically.
-			if (ctx.terminalDeps[0] === true) {
-				if (ctx.store.has) {
-					a.emit(ctx.store.latest as T);
-				} else if (useDefault) {
-					a.emit(defaultValue as T);
-				}
-				a.down([[COMPLETE]]);
-				return cleanup;
-			}
-			const batch0 = data[0];
-			// RESOLVED wave: propagate RESOLVED. Covers first-wave case; after first
-			// call the pre-fn skip handles this automatically.
-			if (batch0 == null || batch0.length === 0) {
-				a.down([[RESOLVED]]);
-				return cleanup;
-			}
-			// DATA: accumulate latest — emit nothing until COMPLETE.
-			ctx.store.latest = batch0.at(-1) as T;
-			ctx.store.has = true;
-			return cleanup;
-		},
-		{
-			...operatorOpts(rest),
-			completeWhenDepsComplete: false,
-			// Spec §2.7 R2.7.1 — Reduce-class. `last` must fire fn on
-			// upstream COMPLETE to emit the latest stored value (or
-			// `defaultValue`, if provided) followed by `[[COMPLETE]]`.
-			// Required because `completeWhenDepsComplete: false` means
-			// auto-COMPLETE is OFF — without the opt-in, a never-DATA
-			// source's COMPLETE never propagates downstream.
-			terminalAsRealInput: true,
-		},
-	);
-}
-
-/**
- * Emits the first value matching `predicate`, then **`COMPLETE`**.
- *
- * @param source - Upstream node.
- * @param predicate - Match test.
- * @param opts - Optional {@link NodeOptions} (excluding `describeKind`).
- * @returns `Node<T>` - First-match stream.
- *
- * @example
- * ```ts
- * import { find, state } from "@graphrefly/pure-ts";
- *
- * const n = find(state(1), (x) => x > 0);
- * ```
- *
- * @category extra
- */
-export function find<T>(
-	source: Node<T>,
-	predicate: (value: T) => boolean,
-	opts?: ExtraOpts,
-): Node<T> {
-	return take(filter(source, predicate, opts), 1, opts);
-}
-
-/**
- * Emits the `index`th **`DATA`** (zero-based), then **`COMPLETE`**.
- *
- * @param source - Upstream node.
- * @param index - Zero-based emission index.
- * @param opts - Optional {@link NodeOptions} (excluding `describeKind`).
- * @returns `Node<T>` - Single indexed value.
- *
- * @example
- * ```ts
- * import { elementAt, state } from "@graphrefly/pure-ts";
- *
- * const n = elementAt(state(0), 2);
- * ```
- *
- * @category extra
- */
-export function elementAt<T>(source: Node<T>, index: number, opts?: ExtraOpts): Node<T> {
-	return take(skip(source, index, opts), 1, opts);
-}
diff --git a/packages/pure-ts/src/extra/operators/time.ts b/packages/pure-ts/src/extra/operators/time.ts
deleted file mode 100644
index 0dac0676..00000000
--- a/packages/pure-ts/src/extra/operators/time.ts
+++ /dev/null
@@ -1,535 +0,0 @@
-/**
- * Time-aware operators (roadmap §2.1) — `delay`, `debounce`, `throttle`,
- * `sample`, `audit`, and the `interval` source-source.
- *
- * All time scheduling uses raw `setTimeout` / `setInterval` with monotonic
- * `monotonicNs` reads where the operator's contract requires elapsed-time
- * arithmetic (per spec §5.10's resilience-operator carve-out).
- */
-
-import { monotonicNs } from "../../core/clock.js";
-import { COMPLETE, DATA, ERROR, type Messages } from "../../core/messages.js";
-import { factoryTag } from "../../core/meta.js";
-import { type Node, node } from "../../core/node.js";
-import { subscribeOr } from "../../core/subscribe-error.js";
-
-// Inlined during cleave A2 (was imported from resilience/backoff.ts, which
-// moved to the presentation package — substrate must not import upward).
-// Keep in sync with the canonical NS_PER_MS in src/base/resilience/backoff.ts.
-const NS_PER_MS = 1_000_000;
-
-import { type ExtraOpts, operatorOpts } from "./_internal.js";
-
-/**
- * Delays phase-2 emissions by `ms` (timers). `DIRTY` still forwards immediately.
- *
- * @param source - Upstream node.
- * @param ms - Delay in milliseconds.
- * @param opts - Optional {@link NodeOptions} (excluding `describeKind`).
- * @returns `Node<T>` - Same values, shifted in time.
- * @example
- * ```ts
- * import { delay, state } from "@graphrefly/pure-ts";
- *
- * delay(state(1), 100);
- * ```
- *
- * @category extra
- */
-export function delay<T>(source: Node<T>, ms: number, opts?: ExtraOpts): Node<T> {
-	return node<T>((_data, a) => {
-		const timers = new Set<ReturnType<typeof setTimeout>>();
-		function clearAll(): void {
-			for (const id of timers) clearTimeout(id);
-			timers.clear();
-		}
-
-		// R2.2.7.b: Dead source → no more DATA possible, self-COMPLETE
-		// (after any in-flight delayed timers drain via their own
-		// callbacks).
-		const srcUnsub = subscribeOr<unknown>(
-			source as Node,
-			(msgs) => {
-				for (const m of msgs as Messages) {
-					if (m[0] === DATA) {
-						const id = setTimeout(() => {
-							timers.delete(id);
-							a.emit(m[1] as T);
-						}, ms);
-						timers.add(id);
-					} else if (m[0] === COMPLETE) {
-						// Wait for all pending timers, then complete
-						const id = setTimeout(() => {
-							timers.delete(id);
-							a.down([[COMPLETE]]);
-						}, ms);
-						timers.add(id);
-					} else if (m[0] === ERROR) {
-						clearAll();
-						a.down([m]);
-					}
-					// DIRTY from source is NOT forwarded — delay transforms the
-					// timeline. a.emit(v) in the timer callback handles full
-					// DIRTY+DATA framing atomically at the delayed time.
-				}
-			},
-			() => {
-				clearAll();
-				a.down([[COMPLETE]]);
-			},
-		);
-
-		return {
-			onDeactivation: () => {
-				srcUnsub();
-				clearAll();
-			},
-		};
-	}, operatorOpts(opts));
-}
-
-/**
- * Emits the latest value only after `ms` quiet time since the last trigger (`debounce`).
- *
- * @param source - Upstream node.
- * @param ms - Quiet window in milliseconds.
- * @param opts - Optional {@link NodeOptions} (excluding `describeKind`).
- * @returns `Node<T>` - Debounced stream.
- * @example
- * ```ts
- * import { debounce, state } from "@graphrefly/pure-ts";
- *
- * debounce(state(0), 50);
- * ```
- *
- * @category extra
- */
-export function debounce<T>(source: Node<T>, ms: number, opts?: ExtraOpts): Node<T> {
-	return node<T>(
-		(_data, a) => {
-			let timer: ReturnType<typeof setTimeout> | undefined;
-			let pending: T | undefined;
-
-			function clearTimer(): void {
-				if (timer !== undefined) {
-					clearTimeout(timer);
-					timer = undefined;
-				}
-			}
-
-			// R2.2.7.b: Dead source → flush pending if any, self-COMPLETE.
-			const srcUnsub = subscribeOr<unknown>(
-				source as Node,
-				(msgs) => {
-					for (const m of msgs as Messages) {
-						if (m[0] === DATA) {
-							clearTimer();
-							pending = m[1] as T;
-							timer = setTimeout(() => {
-								timer = undefined;
-								a.emit(pending as T);
-							}, ms);
-						} else if (m[0] === COMPLETE) {
-							if (timer !== undefined) {
-								clearTimer();
-								a.emit(pending as T);
-							}
-							a.down([[COMPLETE]]);
-						} else if (m[0] === ERROR) {
-							clearTimer();
-							a.down([m]);
-						}
-					}
-				},
-				() => {
-					if (timer !== undefined) {
-						clearTimer();
-						a.emit(pending as T);
-					}
-					a.down([[COMPLETE]]);
-				},
-			);
-
-			return {
-				onDeactivation: () => {
-					srcUnsub();
-					clearTimer();
-				},
-			};
-		},
-		{
-			...operatorOpts(opts),
-			meta: { ...factoryTag("debounce", { ms }), ...(opts?.meta ?? {}) },
-		},
-	);
-}
-
-export type ThrottleOptions = { leading?: boolean; trailing?: boolean };
-
-/**
- * Rate-limits emissions to at most once per `ms` window (`throttleTime`).
- *
- * When `trailing: true`, pending trailing values are flushed on source
- * COMPLETE (and on Dead-source R2.2.7.b). This intentionally diverges from
- * RxJS `throttleTime` v7 (which drops trailing pending on COMPLETE) for
- * symmetry with `debounce`'s live-COMPLETE behavior.
- *
- * @param source - Upstream node.
- * @param ms - Minimum spacing in milliseconds.
- * @param opts - Optional {@link NodeOptions} (excluding `describeKind`) plus `leading` / `trailing`.
- * @returns `Node<T>` - Throttled stream.
- * @example
- * ```ts
- * import { throttle, state } from "@graphrefly/pure-ts";
- *
- * throttle(state(0), 1_000, { trailing: false });
- * ```
- *
- * @category extra
- */
-export function throttle<T>(
-	source: Node<T>,
-	ms: number,
-	opts?: ExtraOpts & ThrottleOptions,
-): Node<T> {
-	const { leading: leadingOpt, trailing: trailingOpt, ...throttleNodeOpts } = opts ?? {};
-	const leading = leadingOpt !== false;
-	const trailing = trailingOpt === true;
-	const windowNs = ms * NS_PER_MS;
-
-	return node<T>(
-		(_data, a) => {
-			let timer: ReturnType<typeof setTimeout> | undefined;
-			let lastEmitNs = -Infinity;
-			let pending: T | undefined;
-			let hasPending = false;
-
-			function clearTimer(): void {
-				if (timer !== undefined) {
-					clearTimeout(timer);
-					timer = undefined;
-				}
-			}
-
-			// R2.2.7.b: Dead source → flush trailing pending if any,
-			// self-COMPLETE.
-			const srcUnsub = subscribeOr<unknown>(
-				source as Node,
-				(msgs) => {
-					for (const m of msgs as Messages) {
-						if (m[0] === DATA) {
-							const v = m[1] as T;
-							const nowNs = monotonicNs();
-							if (leading && nowNs - lastEmitNs >= windowNs) {
-								lastEmitNs = nowNs;
-								a.emit(v);
-								clearTimer();
-								if (trailing) {
-									timer = setTimeout(() => {
-										timer = undefined;
-										if (hasPending) {
-											lastEmitNs = monotonicNs();
-											a.emit(pending as T);
-											hasPending = false;
-										}
-									}, ms);
-								}
-							} else if (trailing) {
-								pending = v;
-								hasPending = true;
-								if (timer === undefined) {
-									const elapsedMs = (nowNs - lastEmitNs) / NS_PER_MS;
-									timer = setTimeout(
-										() => {
-											timer = undefined;
-											if (hasPending) {
-												lastEmitNs = monotonicNs();
-												a.emit(pending as T);
-												hasPending = false;
-											}
-										},
-										Math.max(0, ms - elapsedMs),
-									);
-								}
-							}
-						} else if (m[0] === COMPLETE) {
-							// /qa m21 (2026-05-10): flush trailing pending
-							// on live-COMPLETE for symmetry with the Dead
-							// branch and with `debounce`'s live-COMPLETE
-							// behavior. Pre-fix the live-COMPLETE path
-							// silently discarded any trailing-mode pending
-							// value, which diverged from the Dead branch
-							// (and from user intuition: throttle's
-							// trailing-mode contract is "emit the latest
-							// value seen in each window", so the final
-							// pending should flush on terminal).
-							clearTimer();
-							if (hasPending) {
-								a.emit(pending as T);
-								hasPending = false;
-							}
-							a.down([m]);
-						} else if (m[0] === ERROR) {
-							clearTimer();
-							a.down([m]);
-						}
-					}
-				},
-				() => {
-					clearTimer();
-					if (hasPending) {
-						a.emit(pending as T);
-						hasPending = false;
-					}
-					a.down([[COMPLETE]]);
-				},
-			);
-
-			return {
-				onDeactivation: () => {
-					srcUnsub();
-					clearTimer();
-				},
-			};
-		},
-		{
-			...operatorOpts(throttleNodeOpts),
-			meta: {
-				...factoryTag("throttle", { ms, leading, trailing }),
-				...(throttleNodeOpts.meta ?? {}),
-			},
-		},
-	);
-}
-
-/**
- * Emits the most recent source value whenever `notifier` emits `DATA` (`sample`).
- *
- * Source `COMPLETE` stops sampling (clears held value); notifier `COMPLETE` terminates the
- * operator. `ERROR` from either dep terminates immediately. At most one terminal message is
- * emitted downstream (latch). Supports `resubscribable` — `ctx.store` resets automatically.
- *
- * @param source - Node whose latest value is sampled.
- * @param notifier - When this node emits `DATA`, a sample is taken.
- * @param opts - Optional {@link NodeOptions} (excluding `describeKind`).
- * @returns `Node<T>` - Sampled snapshots of `source`.
- * @example
- * ```ts
- * import { sample, state } from "@graphrefly/pure-ts";
- *
- * sample(state(1), state(0));
- * ```
- *
- * @category extra
- */
-export function sample<T>(source: Node<T>, notifier: Node<unknown>, opts?: ExtraOpts): Node<T> {
-	return node<T>((_data, a) => {
-		let lastSourceValue: { v: T } | undefined;
-		let terminated = false;
-		let sourceCompleted = false;
-
-		// R2.2.7.b: Dead source → no value to sample; mark source-
-		// completed so notifier fires become no-ops.
-		const srcUnsub = subscribeOr<unknown>(
-			source as Node,
-			(msgs) => {
-				if (terminated) return;
-				for (const m of msgs as Messages) {
-					if (terminated) return;
-					if (m[0] === DATA) {
-						lastSourceValue = { v: m[1] as T };
-					} else if (m[0] === ERROR) {
-						terminated = true;
-						a.down([m]);
-					} else if (m[0] === COMPLETE) {
-						sourceCompleted = true;
-						lastSourceValue = undefined;
-					}
-				}
-			},
-			() => {
-				sourceCompleted = true;
-				lastSourceValue = undefined;
-			},
-		);
-
-		// R2.2.7.b: Dead notifier → no sampling triggers will ever
-		// fire; self-COMPLETE (operator has no further work).
-		const notUnsub = subscribeOr<unknown>(
-			notifier as Node,
-			(msgs) => {
-				if (terminated) return;
-				for (const m of msgs as Messages) {
-					if (terminated) return;
-					if (m[0] === DATA) {
-						if (lastSourceValue !== undefined && !sourceCompleted) {
-							a.emit(lastSourceValue.v);
-						}
-					} else if (m[0] === ERROR) {
-						terminated = true;
-						a.down([m]);
-					} else if (m[0] === COMPLETE) {
-						terminated = true;
-						a.down([[COMPLETE]]);
-					}
-				}
-			},
-			() => {
-				if (!terminated) {
-					terminated = true;
-					a.down([[COMPLETE]]);
-				}
-			},
-		);
-
-		return {
-			onDeactivation: () => {
-				srcUnsub();
-				notUnsub();
-			},
-		};
-	}, operatorOpts(opts));
-}
-
-/**
- * After each source `DATA`, waits `ms` then emits the latest value if another `DATA` has not arrived (`auditTime` / trailing window).
- *
- * @param source - Upstream node.
- * @param ms - Window in milliseconds after each `DATA`.
- * @param opts - Optional {@link NodeOptions} (excluding `describeKind`).
- * @returns `Node<T>` - Trailing-edge sampled stream.
- * @example
- * ```ts
- * import { audit, state } from "@graphrefly/pure-ts";
- *
- * audit(state(0), 100);
- * ```
- *
- * @category extra
- */
-export function audit<T>(source: Node<T>, ms: number, opts?: ExtraOpts): Node<T> {
-	return node<T>((_data, a) => {
-		let timer: ReturnType<typeof setTimeout> | undefined;
-		let latest: T | undefined;
-		let has = false;
-
-		function clearTimer(): void {
-			if (timer !== undefined) {
-				clearTimeout(timer);
-				timer = undefined;
-			}
-		}
-
-		// R2.2.7.b: Dead source → emit any pending latest, self-COMPLETE.
-		const srcUnsub = subscribeOr<unknown>(
-			source as Node,
-			(msgs) => {
-				for (const m of msgs as Messages) {
-					if (m[0] === DATA) {
-						latest = m[1] as T;
-						has = true;
-						clearTimer();
-						timer = setTimeout(() => {
-							timer = undefined;
-							if (has) {
-								has = false;
-								a.emit(latest as T);
-							}
-						}, ms);
-					} else if (m[0] === COMPLETE || m[0] === ERROR) {
-						clearTimer();
-						a.down([m]);
-					}
-				}
-			},
-			() => {
-				clearTimer();
-				if (has) {
-					has = false;
-					a.emit(latest as T);
-				}
-				a.down([[COMPLETE]]);
-			},
-		);
-
-		return {
-			onDeactivation: () => {
-				srcUnsub();
-				clearTimer();
-			},
-		};
-	}, operatorOpts(opts));
-}
-
-/**
- * Increments on each tick (`interval`); uses `setInterval` via {@link producer}.
- *
- * @param periodMs - Time between ticks.
- * @param opts - Optional {@link NodeOptions} (excluding `describeKind`).
- * @returns `Node<number>` - Emits `0`, `1`, `2`, … while subscribed.
- * @example
- * ```ts
- * import { interval } from "@graphrefly/pure-ts";
- *
- * interval(1_000);
- * ```
- *
- * @category extra
- */
-export function interval(periodMs: number, opts?: ExtraOpts): Node<number> {
-	return node<number>((_data, a, ctx) => {
-		if (!("n" in ctx.store)) ctx.store.n = 0;
-		const id = setInterval(() => {
-			a.emit(ctx.store.n as number);
-			ctx.store.n = (ctx.store.n as number) + 1;
-		}, periodMs);
-		// Lock 6.D (Phase 13.6.B): clear `n` on deactivation so a
-		// resubscribable interval restarts at 0 on the next cycle.
-		// Pre-flip this came for free via `_deactivate`'s store wipe.
-		const store = ctx.store;
-		return {
-			onDeactivation: () => {
-				clearInterval(id);
-				delete store.n;
-			},
-		};
-	}, operatorOpts(opts));
-}
-
-/**
- * RxJS-named alias for {@link debounce} — drops rapid `DATA` until `ms` of quiet.
- *
- * @param source - Upstream node.
- * @param ms - Quiet period in milliseconds.
- * @param opts - Optional node options (excluding `describeKind`).
- * @returns Debounced node; behavior matches `debounce`.
- *
- * @example
- * ```ts
- * import { debounceTime, state } from "@graphrefly/pure-ts";
- *
- * debounceTime(state(0), 100);
- * ```
- *
- * @category extra
- */
-export const debounceTime = debounce;
-
-/**
- * RxJS-named alias for {@link throttle} — emits on leading/trailing edges within `ms`.
- *
- * @param source - Upstream node.
- * @param ms - Minimum spacing in milliseconds.
- * @param opts - Optional throttle shape (`leading` / `trailing`) and node options.
- * @returns Throttled node; behavior matches `throttle`.
- *
- * @example
- * ```ts
- * import { throttleTime, state } from "@graphrefly/pure-ts";
- *
- * throttleTime(state(0), 100);
- * ```
- *
- * @category extra
- */
-export const throttleTime = throttle;
diff --git a/packages/pure-ts/src/extra/operators/transform.ts b/packages/pure-ts/src/extra/operators/transform.ts
deleted file mode 100644
index c58d7f18..00000000
--- a/packages/pure-ts/src/extra/operators/transform.ts
+++ /dev/null
@@ -1,368 +0,0 @@
-/**
- * Transform operators (roadmap §2.1) — element-wise mappings and folds.
- *
- * `map`, `filter`, `scan`, `reduce`, `distinctUntilChanged`, `pairwise` —
- * each derives a new node from a single upstream by walking each settled
- * batch and emitting via `actions.emit()`.
- */
-
-import { COMPLETE, RESOLVED } from "../../core/messages.js";
-import { factoryTag } from "../../core/meta.js";
-import { type Node, node } from "../../core/node.js";
-import { type ExtraOpts, operatorOpts } from "./_internal.js";
-
-/**
- * Maps each settled value from `source` through `project`.
- *
- * @param source - Upstream node.
- * @param project - Transform for each value.
- * @param opts - Optional {@link NodeOptions} (excluding `describeKind`).
- * @returns `Node<R>` - Derived node emitting mapped values.
- *
- * @example
- * ```ts
- * import { map, state } from "@graphrefly/pure-ts";
- *
- * const n = map(state(2), (x) => x * 3);
- * ```
- *
- * @category extra
- */
-export function map<T, R>(source: Node<T>, project: (value: T) => R, opts?: ExtraOpts): Node<R> {
-	return node<R>(
-		[source as Node],
-		(data, a) => {
-			const batch0 = data[0];
-			if (batch0 == null || batch0.length === 0) {
-				a.down([[RESOLVED]]);
-				return;
-			}
-			for (const v of batch0) {
-				a.emit(project(v as T));
-			}
-		},
-		{
-			...operatorOpts<R>(opts),
-			meta: { ...factoryTag("map"), ...(opts?.meta ?? {}) },
-		},
-	);
-}
-
-/**
- * Forwards values that satisfy `predicate`; otherwise emits `RESOLVED` with no `DATA` (two-phase semantics).
- *
- * **Wave-exclusivity contract** (COMPOSITION-GUIDE §41 / spec §1.3.3): the
- * `RESOLVED` is emitted only when the entire wave produces zero passing
- * values — never per-dropped-item, never trailing a wave that already
- * emitted `DATA`. Mixed-batch inputs like `[v_pass, v_fail, v_pass2]`
- * forward `[DATA, v_pass]` and `[DATA, v_pass2]` with no `RESOLVED` for
- * the dropped middle entry. Consumers needing per-input drain accounting
- * count upstream of `filter`, not on its output.
- *
- * @param source - Upstream node.
- * @param predicate - Inclusion test.
- * @param opts - Optional {@link NodeOptions} (excluding `describeKind`).
- * @returns `Node<T>` - Filtered node.
- *
- * @example
- * ```ts
- * import { filter, state } from "@graphrefly/pure-ts";
- *
- * const n = filter(state(1), (x) => x > 0);
- * ```
- *
- * @category extra
- */
-export function filter<T>(
-	source: Node<T>,
-	predicate: (value: T) => boolean,
-	opts?: ExtraOpts,
-): Node<T> {
-	return node<T>(
-		[source as Node],
-		(data, a) => {
-			const batch0 = data[0];
-			if (batch0 == null || batch0.length === 0) {
-				a.down([[RESOLVED]]);
-				return;
-			}
-			let emitted = false;
-			for (const v of batch0) {
-				if (predicate(v as T)) {
-					a.emit(v as T);
-					emitted = true;
-				}
-			}
-			if (!emitted) a.down([[RESOLVED]]);
-		},
-		{
-			...operatorOpts(opts),
-			meta: { ...factoryTag("filter"), ...(opts?.meta ?? {}) },
-		},
-	);
-}
-
-/**
- * Folds each upstream value into an accumulator; emits the new accumulator every time.
- *
- * Unlike RxJS, `seed` is always required — there is no seedless mode where the first
- * value silently becomes the accumulator.
- *
- * @param source - Upstream node.
- * @param reducer - `(acc, value) => nextAcc`.
- * @param seed - Initial accumulator (required).
- * @param opts - Optional {@link NodeOptions} (excluding `describeKind`).
- * @returns `Node<R>` - Scan node.
- *
- * @example
- * ```ts
- * import { scan, state } from "@graphrefly/pure-ts";
- *
- * const n = scan(state(1), (a, x) => a + x, 0);
- * ```
- *
- * @category extra
- */
-export function scan<T, R>(
-	source: Node<T>,
-	reducer: (acc: R, value: T) => R,
-	seed: R,
-	opts?: ExtraOpts,
-): Node<R> {
-	// Lock 6.D (Phase 13.6.B): clear `acc` on deactivation so a
-	// resubscribable scan restarts from `seed` on the next cycle.
-	let cleanup: { onDeactivation: () => void } | undefined;
-	return node<R>(
-		[source as Node],
-		(data, a, ctx) => {
-			if (cleanup === undefined) {
-				const store = ctx.store;
-				cleanup = {
-					onDeactivation: () => {
-						delete store.acc;
-					},
-				};
-			}
-			if (!("acc" in ctx.store)) ctx.store.acc = seed;
-			const batch0 = data[0];
-			if (batch0 == null || batch0.length === 0) {
-				a.down([[RESOLVED]]);
-				return cleanup;
-			}
-			for (const v of batch0) {
-				ctx.store.acc = reducer(ctx.store.acc as R, v as T);
-				a.emit(ctx.store.acc as R);
-			}
-			return cleanup;
-		},
-		{
-			...operatorOpts(opts),
-			initial: seed,
-			resetOnTeardown: true,
-			// Spec §2.7 R2.7.1 — Reduce-class: fire on upstream-COMPLETE-only
-			// so the auto-COMPLETE wave gets a leading RESOLVED before the
-			// auto-COMPLETE propagates. Without this opt-in, the gate holds
-			// when source COMPLETEs without ever emitting DATA.
-			terminalAsRealInput: true,
-			meta: { ...factoryTag("scan", { initial: seed }), ...(opts?.meta ?? {}) },
-		},
-	);
-}
-
-/**
- * Reduces to one value emitted when `source` completes; if no `DATA` arrived, emits `seed`.
- *
- * Unlike RxJS, `seed` is always required. If the source completes without emitting
- * DATA, the seed value is emitted (RxJS would throw without a seed).
- *
- * @param source - Upstream node.
- * @param reducer - `(acc, value) => nextAcc`.
- * @param seed - Empty-completion default and initial accumulator (required).
- * @param opts - Optional {@link NodeOptions} (excluding `describeKind`).
- * @returns `Node<R>` - Node that emits once on completion.
- *
- * @example
- * ```ts
- * import { reduce, state } from "@graphrefly/pure-ts";
- *
- * const n = reduce(state(1), (a, x) => a + x, 0);
- * ```
- *
- * @category extra
- */
-export function reduce<T, R>(
-	source: Node<T>,
-	reducer: (acc: R, value: T) => R,
-	seed: R,
-	opts?: ExtraOpts,
-): Node<R> {
-	// Lock 6.D: clear acc on deactivation so a resubscribable reduce
-	// starts over with `seed` on the next cycle.
-	let cleanup: { onDeactivation: () => void } | undefined;
-	return node<R>(
-		[source as Node],
-		(data, a, ctx) => {
-			if (cleanup === undefined) {
-				const store = ctx.store;
-				cleanup = {
-					onDeactivation: () => {
-						delete store.acc;
-					},
-				};
-			}
-			if (!("acc" in ctx.store)) ctx.store.acc = seed;
-			// COMPLETE: emit accumulated value then COMPLETE.
-			// ERROR: autoError propagates automatically; nothing to emit.
-			if (ctx.terminalDeps[0] === true) {
-				a.emit(ctx.store.acc as R);
-				a.down([[COMPLETE]]);
-				return cleanup;
-			}
-			const batch0 = data[0];
-			// RESOLVED wave (empty batch): propagate RESOLVED. After fn has run once
-			// the pre-fn skip handles this; this guard covers the first-wave case.
-			if (batch0 == null || batch0.length === 0) {
-				a.down([[RESOLVED]]);
-				return cleanup;
-			}
-			// DATA: accumulate silently — emit nothing until COMPLETE.
-			for (const v of batch0) {
-				ctx.store.acc = reducer(ctx.store.acc as R, v as T);
-			}
-			return cleanup;
-		},
-		{
-			...operatorOpts(opts),
-			completeWhenDepsComplete: false,
-			// Spec §2.7 R2.7.1 — Reduce-class. Required because reduce's
-			// `completeWhenDepsComplete: false` means it MUST fire fn on
-			// upstream COMPLETE to emit the accumulated value + own
-			// `[[COMPLETE]]`. Without the opt-in, a source that COMPLETEs
-			// without ever emitting DATA holds the gate and reduce stays
-			// alive forever (no downstream COMPLETE).
-			terminalAsRealInput: true,
-			meta: { ...factoryTag("reduce", { initial: seed }), ...(opts?.meta ?? {}) },
-		},
-	);
-}
-
-/**
- * Suppresses adjacent duplicates using `equals` (default `Object.is`).
- *
- * @param source - Upstream node.
- * @param equals - Optional equality for consecutive values.
- * @param opts - Optional {@link NodeOptions} (excluding `describeKind`).
- * @returns `Node<T>` - Deduped stream.
- *
- * @example
- * ```ts
- * import { distinctUntilChanged, state } from "@graphrefly/pure-ts";
- *
- * const n = distinctUntilChanged(state(1));
- * ```
- *
- * @category extra
- */
-export function distinctUntilChanged<T>(
-	source: Node<T>,
-	equals: (a: T, b: T) => boolean = Object.is,
-	opts?: ExtraOpts,
-): Node<T> {
-	// Lock 6.D: clear prev/hasPrev on deactivation so a resubscribable
-	// dedupe doesn't suppress the next cycle's first DATA against a stale
-	// "previous" value from the prior cycle.
-	let cleanup: { onDeactivation: () => void } | undefined;
-	return node<T>(
-		[source as Node],
-		(data, a, ctx) => {
-			if (cleanup === undefined) {
-				const store = ctx.store;
-				cleanup = {
-					onDeactivation: () => {
-						delete store.prev;
-						delete store.hasPrev;
-					},
-				};
-			}
-			const batch0 = data[0];
-			if (batch0 == null || batch0.length === 0) {
-				a.down([[RESOLVED]]);
-				return cleanup;
-			}
-			let emitted = false;
-			for (const val of batch0 as T[]) {
-				if (ctx.store.hasPrev && equals(ctx.store.prev as T, val)) {
-					// Suppressed — same as previous
-				} else {
-					ctx.store.prev = val;
-					ctx.store.hasPrev = true;
-					a.emit(val);
-					emitted = true;
-				}
-			}
-			if (!emitted) a.down([[RESOLVED]]);
-			return cleanup;
-		},
-		{
-			...operatorOpts(opts),
-			meta: { ...factoryTag("distinctUntilChanged"), ...(opts?.meta ?? {}) },
-		},
-	);
-}
-
-/**
- * Emits `[previous, current]` pairs starting after the second value (first pair uses `RESOLVED` only).
- *
- * @param source - Upstream node.
- * @param opts - Optional {@link NodeOptions} (excluding `describeKind`).
- * @returns `Node<readonly [T, T]>` - Pair stream.
- *
- * @example
- * ```ts
- * import { pairwise, state } from "@graphrefly/pure-ts";
- *
- * const n = pairwise(state(0));
- * ```
- *
- * @category extra
- */
-export function pairwise<T>(source: Node<T>, opts?: ExtraOpts): Node<readonly [T, T]> {
-	// Lock 6.D: clear prev/hasPrev on deactivation so a resubscribable
-	// pairwise restarts the "first value, no pair yet" state on each cycle.
-	let cleanup: { onDeactivation: () => void } | undefined;
-	return node<readonly [T, T]>(
-		[source as Node],
-		(data, a, ctx) => {
-			if (cleanup === undefined) {
-				const store = ctx.store;
-				cleanup = {
-					onDeactivation: () => {
-						delete store.prev;
-						delete store.hasPrev;
-					},
-				};
-			}
-			const batch0 = data[0];
-			if (batch0 == null || batch0.length === 0) {
-				a.down([[RESOLVED]]);
-				return cleanup;
-			}
-			let emitted = false;
-			for (const x of batch0 as T[]) {
-				if (!ctx.store.hasPrev) {
-					ctx.store.prev = x;
-					ctx.store.hasPrev = true;
-					// First value — no pair yet
-				} else {
-					const pair = [ctx.store.prev as T, x] as const;
-					ctx.store.prev = x;
-					a.emit(pair);
-					emitted = true;
-				}
-			}
-			if (!emitted) a.down([[RESOLVED]]);
-			return cleanup;
-		},
-		operatorOpts(opts),
-	);
-}
diff --git a/packages/pure-ts/src/extra/render/index.ts b/packages/pure-ts/src/extra/render/index.ts
deleted file mode 100644
index 7cacccd9..00000000
--- a/packages/pure-ts/src/extra/render/index.ts
+++ /dev/null
@@ -1,13 +0,0 @@
-/**
- * Render barrel — re-exports from root src/base/render/ (presentation layer).
- *
- * The render functions were moved to root src/base/render/ during cleave A2
- * (2026-05-14) since they are presentation, not substrate.
- *
- * This stub preserves the old import path so substrate tests that haven't
- * been migrated to root src/__tests__/ yet continue to work.
- *
- * Tests importing from here should be migrated to src/__tests__/ with imports
- * updated to use the presentation package path.
- */
-export * from "../../../../../src/base/render/index.js";
diff --git a/packages/pure-ts/src/extra/sources-fs.ts b/packages/pure-ts/src/extra/sources-fs.ts
deleted file mode 100644
index ac123ce0..00000000
--- a/packages/pure-ts/src/extra/sources-fs.ts
+++ /dev/null
@@ -1,256 +0,0 @@
-/**
- * Filesystem-watching source. Isolated from `./sources.ts` so bundlers
- * targeting the browser can import browser-safe sources (`fromTimer`,
- * `fromRaf`, etc.) without pulling in `node:fs`/`node:path`.
- */
-
-import { existsSync, statSync, watch } from "node:fs";
-import { readdir } from "node:fs/promises";
-import { join, resolve as resolvePath } from "node:path";
-import { wallClockNs } from "../core/clock.js";
-import { DATA, ERROR, type Message } from "../core/messages.js";
-import { type Node, type NodeOptions, node } from "../core/node.js";
-import { globToRegExp, matchesAnyPattern } from "./sources.js";
-
-type ExtraOpts = Omit<NodeOptions<unknown>, "describeKind">;
-
-function sourceOpts<T = unknown>(opts?: ExtraOpts): NodeOptions<T> {
-	return { describeKind: "producer", ...opts } as NodeOptions<T>;
-}
-
-export type FSEventType = "change" | "rename" | "create" | "delete";
-export type FSEvent = {
-	type: FSEventType;
-	path: string;
-	root: string;
-	relative_path: string;
-	src_path?: string;
-	dest_path?: string;
-	timestamp_ns: number;
-};
-
-export type FromFSWatchOptions = ExtraOpts & {
-	recursive?: boolean;
-	debounce?: number;
-	include?: string[];
-	exclude?: string[];
-};
-
-/**
- * Watches filesystem paths and emits debounced change events.
- *
- * On startup the node scans existing files and emits a `create` event for
- * each match, giving subscribers a complete initial snapshot. Events that
- * arrive from `fs.watch` during the scan are buffered and flushed once the
- * scan completes, so no changes are silently dropped during OS watcher
- * activation.
- *
- * Uses `fs.watch` only (no polling fallback). Teardown closes all watchers.
- *
- * @category extra
- */
-export function fromFSWatch(paths: string | string[], opts?: FromFSWatchOptions): Node<FSEvent> {
-	const list = Array.isArray(paths) ? paths : [paths];
-	if (list.length === 0) {
-		throw new RangeError("fromFSWatch expects at least one path");
-	}
-	const { recursive = true, debounce = 100, include, exclude, ...rest } = opts ?? {};
-	const includePatterns = include?.map(globToRegExp) ?? [];
-	const excludePatterns = (exclude ?? ["**/node_modules/**", "**/.git/**", "**/dist/**"]).map(
-		globToRegExp,
-	);
-
-	/** Returns true if `relForMatch` + `normalized` pass include/exclude. */
-	function matchesFilters(normalized: string, relForMatch: string): boolean {
-		const included =
-			includePatterns.length === 0 ||
-			matchesAnyPattern(normalized, includePatterns) ||
-			matchesAnyPattern(relForMatch, includePatterns);
-		if (!included) return false;
-		return !(
-			matchesAnyPattern(normalized, excludePatterns) ||
-			matchesAnyPattern(relForMatch, excludePatterns)
-		);
-	}
-
-	return node<FSEvent>((_data, a) => {
-		const pending = new Map<string, FSEvent>();
-		const buffered = new Map<string, FSEvent>();
-		const watchers: ReturnType<typeof watch>[] = [];
-		let stopped = false;
-		let terminalEmitted = false;
-		let generation = 0;
-		let ready = false;
-
-		const closeWatchers = () => {
-			for (const watcher of watchers.splice(0)) watcher.close();
-		};
-		const emitError = (err: unknown) => {
-			if (terminalEmitted) return;
-			terminalEmitted = true;
-			stopped = true;
-			if (timer !== undefined) clearTimeout(timer);
-			timer = undefined;
-			pending.clear();
-			buffered.clear();
-			closeWatchers();
-			a.down([[ERROR, err]]);
-		};
-		let timer: ReturnType<typeof setTimeout> | undefined;
-		const flush = (token: number) => {
-			timer = undefined;
-			if (stopped || terminalEmitted) return;
-			if (pending.size === 0) return;
-			const batchMessages: Message[] = [];
-			for (const evt of pending.values()) batchMessages.push([DATA, evt]);
-			pending.clear();
-			if (stopped || terminalEmitted || token !== generation) return;
-			a.down(batchMessages);
-		};
-
-		/** Transition to ready — move buffered events into the debounce queue. */
-		const becomeReady = () => {
-			if (ready) return;
-			ready = true;
-			if (stopped || terminalEmitted) return;
-			for (const [k, v] of buffered) pending.set(k, v);
-			buffered.clear();
-			if (pending.size > 0) {
-				if (timer !== undefined) clearTimeout(timer);
-				const token = generation;
-				timer = setTimeout(() => flush(token), debounce);
-			}
-		};
-
-		const onWatchEvent = (
-			basePath: string,
-			eventType: "rename" | "change",
-			fileName: string | Buffer | null,
-		) => {
-			if (stopped || terminalEmitted) return;
-			if (fileName == null) return;
-			const rel = String(fileName).replaceAll("\\", "/");
-			const abs = resolvePath(basePath, String(fileName));
-			const normalized = abs.replaceAll("\\", "/");
-			const root = resolvePath(basePath).replaceAll("\\", "/");
-			const relForMatch = rel.startsWith("./") ? rel.slice(2) : rel;
-			if (!matchesFilters(normalized, relForMatch)) return;
-
-			let kind: FSEventType = "change";
-			if (eventType === "rename") {
-				try {
-					kind = existsSync(normalized) ? "create" : "delete";
-				} catch {
-					kind = "rename";
-				}
-			}
-			const evt: FSEvent = {
-				type: kind,
-				path: normalized,
-				root,
-				relative_path: relForMatch,
-				timestamp_ns: wallClockNs(),
-			};
-
-			if (!ready) {
-				buffered.set(normalized, evt);
-				return;
-			}
-
-			pending.set(normalized, evt);
-			if (timer !== undefined) clearTimeout(timer);
-			const token = generation;
-			timer = setTimeout(() => flush(token), debounce);
-		};
-
-		// --- Phase 1: register watchers synchronously ---
-		try {
-			for (const basePath of list) {
-				const watcher = watch(basePath, { recursive }, (eventType, fileName) =>
-					onWatchEvent(basePath, eventType, fileName),
-				);
-				watcher.on("error", (err) => emitError(err));
-				watchers.push(watcher);
-			}
-		} catch (err) {
-			emitError(err);
-			return { onDeactivation: () => {} };
-		}
-
-		// --- Phase 2: async init (scan existing files, then become ready) ---
-		// The scan serves two purposes:
-		// 1. Emits `create` events for all pre-existing matching files.
-		// 2. Covers the OS watcher activation window — by the time readdir
-		//    finishes, fs.watch has had time to become live. Any events that
-		//    arrive during the scan are buffered and flushed on becomeReady().
-		// F1 /qa (2026-05-12): inner try/catch guards the scan IIFE so
-		// a throw from a.down() (e.g. downstream node throwing
-		// synchronously) surfaces as ERROR rather than an unhandled
-		// rejection. Using inner try/catch (not .catch() on the
-		// promise) to avoid microtask-scheduling changes that affect
-		// FSEvents timing in tests.
-		(async () => {
-			try {
-				if (stopped || terminalEmitted) return;
-
-				const scanMessages: Message[] = [];
-				for (const basePath of list) {
-					try {
-						const resolved = resolvePath(basePath);
-						let isDir: boolean;
-						try {
-							isDir = statSync(resolved).isDirectory();
-						} catch {
-							isDir = false;
-						}
-						if (!isDir) continue;
-						const entries = await readdir(resolved, { recursive });
-						for (const entry of entries) {
-							if (stopped || terminalEmitted) return;
-							const rel = String(entry).replaceAll("\\", "/");
-							const abs = join(resolved, String(entry));
-							const normalized = abs.replaceAll("\\", "/");
-							const relForMatch = rel.startsWith("./") ? rel.slice(2) : rel;
-							if (!matchesFilters(normalized, relForMatch)) continue;
-							try {
-								if (!statSync(abs).isFile()) continue;
-							} catch {
-								continue;
-							}
-							scanMessages.push([
-								DATA,
-								{
-									type: "create" as FSEventType,
-									path: normalized,
-									root: resolved.replaceAll("\\", "/"),
-									relative_path: relForMatch,
-									timestamp_ns: wallClockNs(),
-								},
-							]);
-						}
-					} catch {
-						// readdir failed (permission, path gone) — skip silently.
-					}
-				}
-				if (stopped || terminalEmitted) return;
-				if (scanMessages.length > 0) a.down(scanMessages);
-
-				becomeReady();
-			} catch (err) {
-				if (!stopped && !terminalEmitted) emitError(err);
-			}
-		})();
-
-		return {
-			onDeactivation: () => {
-				stopped = true;
-				generation += 1;
-				if (timer !== undefined) clearTimeout(timer);
-				timer = undefined;
-				closeWatchers();
-				pending.clear();
-				buffered.clear();
-			},
-		};
-	}, sourceOpts(rest));
-}
diff --git a/packages/pure-ts/src/extra/sources/_internal.ts b/packages/pure-ts/src/extra/sources/_internal.ts
deleted file mode 100644
index e3947d34..00000000
--- a/packages/pure-ts/src/extra/sources/_internal.ts
+++ /dev/null
@@ -1,76 +0,0 @@
-/**
- * Internal helpers shared by source sub-files.
- *
- * Type aliases (`ExtraOpts`, `AsyncSourceOpts`, `NodeInput`) and shape-test
- * helpers used across `iter.ts`, `event.ts`, `async.ts`, and `settled.ts` live
- * here so each sub-file can import only what it needs.
- *
- * `escapeRegexChar` / `globToRegExp` / `matchesAnyPattern` are also surfaced
- * through `extra/adapters.ts` and `extra/sources-fs.ts` for shared glob
- * matching — keep them as named exports.
- */
-
-import type { Node, NodeOptions } from "../../core/node.js";
-
-export type ExtraOpts = Omit<NodeOptions<unknown>, "describeKind">;
-
-export function sourceOpts<T = unknown>(opts?: ExtraOpts): NodeOptions<T> {
-	return { describeKind: "producer", ...opts } as NodeOptions<T>;
-}
-
-/** Options for {@link fromTimer} / {@link fromPromise} / {@link fromAsyncIter}. */
-export type AsyncSourceOpts = ExtraOpts & { signal?: AbortSignal };
-
-/**
- * Values accepted by {@link fromAny}.
- *
- * @category extra
- */
-export type NodeInput<T> = Node<T> | PromiseLike<T> | AsyncIterable<T> | Iterable<T> | T;
-
-/** @internal Shared with adapters.ts and sources-fs.ts for glob matching. */
-export function escapeRegexChar(ch: string): string {
-	return /[\\^$+?.()|[\]{}]/.test(ch) ? `\\${ch}` : ch;
-}
-
-/** @internal */
-export function globToRegExp(glob: string): RegExp {
-	let out = "^";
-	for (let i = 0; i < glob.length; i += 1) {
-		const ch = glob[i];
-		if (ch === "*") {
-			const next = glob[i + 1];
-			if (next === "*") {
-				out += ".*";
-				i += 1;
-			} else {
-				out += "[^/]*";
-			}
-			continue;
-		}
-		out += escapeRegexChar(ch);
-	}
-	out += "$";
-	return new RegExp(out);
-}
-
-/** @internal */
-export function matchesAnyPattern(path: string, patterns: RegExp[]): boolean {
-	for (const pattern of patterns) {
-		if (pattern.test(path)) return true;
-	}
-	return false;
-}
-
-export function isThenable(x: unknown): x is PromiseLike<unknown> {
-	return x != null && typeof (x as PromiseLike<unknown>).then === "function";
-}
-
-export function isNode(x: unknown): x is Node {
-	return (
-		x != null &&
-		typeof x === "object" &&
-		"cache" in x &&
-		typeof (x as Node).subscribe === "function"
-	);
-}
diff --git a/packages/pure-ts/src/extra/sources/_keepalive.ts b/packages/pure-ts/src/extra/sources/_keepalive.ts
deleted file mode 100644
index b83f692e..00000000
--- a/packages/pure-ts/src/extra/sources/_keepalive.ts
+++ /dev/null
@@ -1,25 +0,0 @@
-/**
- * keepalive — empty subscription to keep derived nodes wired.
- *
- * Substrate primitive (pure-ts). Presentation-layer wrapper lives in
- * root src/base/meta/keepalive.ts; this module is the substrate copy so
- * graph.ts (substrate) can depend on it without a cross-layer import.
- */
-
-import type { Node } from "../../core/node.js";
-
-/**
- * Activate a compute node's upstream wiring without a real sink.
- *
- * Derived/effect nodes are lazy — they don't compute until at least one
- * subscriber exists (COMPOSITION-GUIDE §5). `keepalive` subscribes with an
- * empty sink so the node stays wired for `.cache` and upstream propagation.
- *
- * Returns the unsubscribe handle. Common usage:
- * `graph.addDisposer(keepalive(node))`.
- *
- * @category extra
- */
-export function keepalive(n: Node<unknown>): () => void {
-	return n.subscribe(() => {});
-}
diff --git a/packages/pure-ts/src/extra/sources/async.ts b/packages/pure-ts/src/extra/sources/async.ts
deleted file mode 100644
index d78c4f1d..00000000
--- a/packages/pure-ts/src/extra/sources/async.ts
+++ /dev/null
@@ -1,141 +0,0 @@
-/**
- * Async source adapters (substrate tier).
- *
- * `fromPromise`, `fromAsyncIter`, and `fromAny` are substrate-level because
- * higher-order operators (switchMap, mergeMap, concatMap, exhaustMap) need
- * `fromAny` to coerce `NodeInput<T>` project-function returns.
- *
- * @module
- */
-
-import { COMPLETE, ERROR } from "../../core/messages.js";
-import { type Node, node } from "../../core/node.js";
-import {
-	type AsyncSourceOpts,
-	isNode,
-	isThenable,
-	type NodeInput,
-	sourceOpts,
-} from "./_internal.js";
-import { fromIter, of } from "./sync/iter.js";
-
-/**
- * Lifts a Promise (or thenable) to a single-value stream: one `DATA` then
- * `COMPLETE`, or `ERROR` on rejection.
- *
- * @param p - Promise to await.
- * @param opts - Producer options plus optional `signal` for abort → `ERROR`.
- * @returns `Node<T>` — settles once.
- *
- * @category extra
- */
-export function fromPromise<T>(p: Promise<T> | PromiseLike<T>, opts?: AsyncSourceOpts): Node<T> {
-	const { signal, ...rest } = opts ?? {};
-	return node<T>((_data, a) => {
-		let settled = false;
-		const onAbort = () => {
-			if (settled) return;
-			settled = true;
-			a.down([[ERROR, signal!.reason]]);
-		};
-		if (signal?.aborted) {
-			onAbort();
-			return;
-		}
-		signal?.addEventListener("abort", onAbort, { once: true });
-		void Promise.resolve(p).then(
-			(v) => {
-				if (settled) return;
-				settled = true;
-				signal?.removeEventListener("abort", onAbort);
-				a.emit(v as T);
-				a.down([[COMPLETE]]);
-			},
-			(e) => {
-				if (settled) return;
-				settled = true;
-				signal?.removeEventListener("abort", onAbort);
-				a.down([[ERROR, e]]);
-			},
-		);
-		return {
-			onDeactivation: () => {
-				settled = true;
-				signal?.removeEventListener("abort", onAbort);
-			},
-		};
-	}, sourceOpts(rest));
-}
-
-/**
- * Reads an async iterable; each `next()` value becomes `DATA`; `COMPLETE`
- * when done; `ERROR` on failure.
- *
- * @param iterable - Async source (`for await` shape).
- * @param opts - Producer options plus optional `signal` to abort the pump.
- * @returns `Node<T>` — async pull stream.
- *
- * @category extra
- */
-export function fromAsyncIter<T>(iterable: AsyncIterable<T>, opts?: AsyncSourceOpts): Node<T> {
-	const { signal: outerSignal, ...rest } = opts ?? {};
-	return node<T>((_data, a) => {
-		const ac = new AbortController();
-		const onOuterAbort = () => ac.abort(outerSignal?.reason);
-		outerSignal?.addEventListener("abort", onOuterAbort, { once: true });
-
-		let done = false;
-		const pump = async () => {
-			try {
-				for await (const v of iterable) {
-					if (ac.signal.aborted) break;
-					a.emit(v);
-				}
-				if (!ac.signal.aborted) a.down([[COMPLETE]]);
-			} catch (e) {
-				if (!ac.signal.aborted) a.down([[ERROR, e]]);
-			} finally {
-				done = true;
-			}
-		};
-		void pump();
-		return {
-			onDeactivation: () => {
-				if (!done) ac.abort();
-				outerSignal?.removeEventListener("abort", onOuterAbort);
-			},
-		};
-	}, sourceOpts(rest));
-}
-
-/**
- * Coerces a `NodeInput<T>` (Node, scalar, Promise, Iterable, or AsyncIterable)
- * to a `Node<T>`. Used by higher-order operators to normalise project returns.
- *
- * Pass `{ iter: true }` to opt into {@link fromIter} dispatch for Iterables
- * (otherwise Iterables are treated as single-value scalars via `of`).
- *
- * @category extra
- */
-export function fromAny<T>(
-	input: NodeInput<T>,
-	opts?: AsyncSourceOpts & { iter?: boolean },
-): Node<T> {
-	if (isNode(input)) {
-		return input as Node<T>;
-	}
-	if (isThenable(input)) {
-		return fromPromise(input as PromiseLike<T>, opts);
-	}
-	if (input !== null && input !== undefined) {
-		const candidate = input as { [Symbol.asyncIterator]?: unknown; [Symbol.iterator]?: unknown };
-		if (typeof candidate[Symbol.asyncIterator] === "function") {
-			return fromAsyncIter(input as AsyncIterable<T>, opts);
-		}
-		if (opts?.iter === true && typeof candidate[Symbol.iterator] === "function") {
-			return fromIter(input as Iterable<T>, opts);
-		}
-	}
-	// Default: treat as single value.
-	return of(input as T);
-}
diff --git a/packages/pure-ts/src/extra/sources/event/timer.ts b/packages/pure-ts/src/extra/sources/event/timer.ts
deleted file mode 100644
index c7a5c6ae..00000000
--- a/packages/pure-ts/src/extra/sources/event/timer.ts
+++ /dev/null
@@ -1,71 +0,0 @@
-/**
- * Timer-based reactive source (substrate — stays in @graphrefly/pure-ts).
- *
- * Extracted from extra/sources/event.ts during cleave A2.
- * Presentation sources (fromRaf, fromCron, fromEvent) moved to
- * root src/base/sources/event/{dom,cron}.ts.
- */
-
-import { COMPLETE, ERROR } from "../../../core/messages.js";
-import { type Node, node } from "../../../core/node.js";
-import { type AsyncSourceOpts, sourceOpts } from "../_internal.js";
-
-/**
- * Builds a timer-driven source: one-shot (first tick then `COMPLETE`) or periodic (`0`, `1`, `2`, …).
- *
- * @param ms - Milliseconds before the first emission.
- * @param opts - Producer options plus optional `period` for repeating ticks and optional `signal` (`AbortSignal`) to cancel with `ERROR`.
- * @returns `Node<number>` — tick counter from `0`; teardown clears timers.
- *
- * @example
- * ```ts
- * import { fromTimer } from "@graphrefly/pure-ts";
- *
- * fromTimer(250, { period: 1_000 });
- * ```
- *
- * @category extra
- */
-export function fromTimer(ms: number, opts?: AsyncSourceOpts & { period?: number }): Node<number> {
-	const { signal, period, ...rest } = opts ?? {};
-	return node<number>((_data, a) => {
-		let done = false;
-		let count = 0;
-		let t: ReturnType<typeof setTimeout> | undefined;
-		let iv: ReturnType<typeof setInterval> | undefined;
-		const cleanup = () => {
-			done = true;
-			if (t !== undefined) clearTimeout(t);
-			if (iv !== undefined) clearInterval(iv);
-			signal?.removeEventListener("abort", onAbort);
-		};
-		const finish = () => {
-			if (done) return;
-			if (period != null) {
-				a.emit(count++);
-				iv = setInterval(() => {
-					if (done) return;
-					a.emit(count++);
-				}, period);
-			} else {
-				// One-shot: mark done, emit, complete synchronously.
-				done = true;
-				signal?.removeEventListener("abort", onAbort);
-				a.emit(count++);
-				a.down([[COMPLETE]]);
-			}
-		};
-		const onAbort = () => {
-			if (done) return;
-			cleanup();
-			a.down([[ERROR, signal!.reason]]);
-		};
-		if (signal?.aborted) {
-			onAbort();
-			return;
-		}
-		t = setTimeout(finish, ms);
-		signal?.addEventListener("abort", onAbort, { once: true });
-		return { onDeactivation: cleanup };
-	}, sourceOpts(rest));
-}
diff --git a/packages/pure-ts/src/extra/sources/index.ts b/packages/pure-ts/src/extra/sources/index.ts
deleted file mode 100644
index 231cf116..00000000
--- a/packages/pure-ts/src/extra/sources/index.ts
+++ /dev/null
@@ -1,31 +0,0 @@
-/**
- * Substrate sources barrel (cleave A2, 2026-05-14).
- *
- * Exports substrate-only sources after the cleave:
- * - sync/iter (fromIter, of, empty, never, throwError)
- * - event/timer (fromTimer)
- * - _internal (NodeInput, AsyncSourceOpts, etc.)
- *
- * Presentation sources (async, settled, fromCron, fromEvent, fromRaf,
- * singleFromAny, keepalive, reactiveCounter) moved to root src/base/sources/.
- */
-
-// DO NOT re-export ./git.js or ./fs.js here — they are Node-only and were
-// moved to root src/base/sources/node/ as presentation sources.
-
-// Substrate shared types — stay in pure-ts
-export {
-	type AsyncSourceOpts,
-	escapeRegexChar,
-	globToRegExp,
-	matchesAnyPattern,
-	type NodeInput,
-} from "./_internal.js";
-// keepalive — substrate (graph.ts depends on this)
-export * from "./_keepalive.js";
-// Async sources — substrate (higher-order operators depend on fromAny)
-export * from "./async.js";
-// Timer source — substrate
-export * from "./event/timer.js";
-// Sync sources — substrate
-export * from "./sync/iter.js";
diff --git a/packages/pure-ts/src/extra/sources/sync/iter.ts b/packages/pure-ts/src/extra/sources/sync/iter.ts
deleted file mode 100644
index 2a5ad2d4..00000000
--- a/packages/pure-ts/src/extra/sources/sync/iter.ts
+++ /dev/null
@@ -1,130 +0,0 @@
-/**
- * Iterable / value sources — synchronous bridges and constructors.
- *
- * `fromIter` drains a sync iterable; `of` lifts a finite arglist; `empty` /
- * `never` / `throwError` are the cold "constant terminal" sources used as
- * graph endpoints in tests and composition.
- */
-
-import { COMPLETE, ERROR } from "../../../core/messages.js";
-import { type Node, node } from "../../../core/node.js";
-import { type ExtraOpts, sourceOpts } from "../_internal.js";
-
-/**
- * Drains a synchronous iterable; each item is `DATA`, then `COMPLETE`, or `ERROR` if iteration throws.
- *
- * @param iterable - Values to emit in order.
- * @param opts - Optional producer options.
- * @returns `Node<T>` — one emission per element.
- *
- * @example
- * ```ts
- * import { fromIter } from "@graphrefly/pure-ts";
- *
- * fromIter([1, 2, 3]);
- * ```
- *
- * @category extra
- */
-export function fromIter<T>(iterable: Iterable<T>, opts?: ExtraOpts): Node<T> {
-	return node<T>((_data, a) => {
-		let cancelled = false;
-		try {
-			for (const x of iterable) {
-				if (cancelled) return;
-				a.emit(x);
-			}
-			if (!cancelled) a.down([[COMPLETE]]);
-		} catch (e) {
-			if (!cancelled) a.down([[ERROR, e]]);
-		}
-		return {
-			onDeactivation: () => {
-				cancelled = true;
-			},
-		};
-	}, sourceOpts(opts));
-}
-
-/**
- * Emits each argument as `DATA` in order, then `COMPLETE` (implemented via {@link fromIter}).
- *
- * @param values - Values to emit.
- * @returns `Node<T>` — finite sequence.
- *
- * @example
- * ```ts
- * import { of } from "@graphrefly/pure-ts";
- *
- * of(1, 2, 3);
- * ```
- *
- * @category extra
- */
-export function of<T>(...values: T[]): Node<T> {
-	return fromIter(values, undefined);
-}
-
-/**
- * Completes immediately with no `DATA` (cold `EMPTY` analogue).
- *
- * @param opts - Optional producer options.
- * @returns `Node<T>` — terminal `COMPLETE` only.
- *
- * @example
- * ```ts
- * import { empty } from "@graphrefly/pure-ts";
- *
- * empty();
- * ```
- *
- * @category extra
- */
-export function empty<T = never>(opts?: ExtraOpts): Node<T> {
-	return node<T>((_data, a) => {
-		a.down([[COMPLETE]]);
-		return undefined;
-	}, sourceOpts(opts));
-}
-
-/**
- * Never emits and never completes until teardown (cold `NEVER` analogue).
- *
- * @param opts - Optional producer options.
- * @returns `Node<T>` — silent until unsubscribed.
- *
- * @example
- * ```ts
- * import { never } from "@graphrefly/pure-ts";
- *
- * never();
- * ```
- *
- * @category extra
- */
-export function never<T = never>(opts?: ExtraOpts): Node<T> {
-	return node<T>(() => undefined, sourceOpts(opts));
-}
-
-/**
- * Emits `ERROR` as soon as the producer starts (cold error source).
- *
- * @param err - Error payload forwarded as `ERROR` data.
- * @param opts - Optional producer options.
- * @returns `Node<never>` — terminates with `ERROR`.
- *
- * @example
- * ```ts
- * import { throwError } from "@graphrefly/pure-ts";
- *
- * throwError(new Error("fail"));
- * ```
- *
- * @category extra
- */
-export function throwError(err: unknown, opts?: ExtraOpts): Node<never> {
-	return node<never>((_data, a) => {
-		a.down([[ERROR, err]]);
-		return undefined;
-	}, sourceOpts(opts));
-}
diff --git a/packages/pure-ts/src/extra/storage/cascading-cache.ts b/packages/pure-ts/src/extra/storage/cascading-cache.ts
deleted file mode 100644
index db546828..00000000
--- a/packages/pure-ts/src/extra/storage/cascading-cache.ts
+++ /dev/null
@@ -1,333 +0,0 @@
-/**
- * N-tier cascading cache — roadmap §3.1c.
- *
- * Each cached entry is a `state()` node. On miss, tiers are tried in order
- * (tier 0 = hottest). Hits auto-promote to faster tiers. Supports eviction
- * policy and write-through.
- *
- * Consumes {@link KvStorageTier} — no separate `CacheTier` interface. Async
- * tiers participate via `Promise<unknown>` returns from `load`; sync tiers
- * stay zero-microtask (the cascade inspects the return type and branches).
- */
-import { DATA, TEARDOWN } from "../../core/messages.js";
-import { type Node, node } from "../../core/node.js";
-import type { KvStorageTier } from "./tiers.js";
-
-// ——————————————————————————————————————————————————————————————
-//  Eviction policy
-// ——————————————————————————————————————————————————————————————
-
-/** Pluggable eviction policy for {@link cascadingCache}. */
-export interface CacheEvictionPolicy<K> {
-	insert(key: K): void;
-	touch(key: K): void;
-	delete(key: K): void;
-	evict(count: number): K[];
-	size(): number;
-}
-
-/**
- * LRU eviction policy backed by a doubly-linked list + Map.
- *
- * @returns An {@link CacheEvictionPolicy} that evicts least-recently-used entries.
- *
- * @category extra
- */
-export function lru<K>(): CacheEvictionPolicy<K> {
-	type LNode = { key: K; prev: LNode | null; next: LNode | null };
-	const map = new Map<K, LNode>();
-	let head: LNode | null = null;
-	let tail: LNode | null = null;
-
-	function unlink(n: LNode): void {
-		if (n.prev) n.prev.next = n.next;
-		else head = n.next;
-		if (n.next) n.next.prev = n.prev;
-		else tail = n.prev;
-		n.prev = null;
-		n.next = null;
-	}
-
-	function pushFront(n: LNode): void {
-		n.next = head;
-		n.prev = null;
-		if (head) head.prev = n;
-		head = n;
-		if (tail === null) tail = n;
-	}
-
-	return {
-		insert(key: K): void {
-			if (map.has(key)) {
-				this.touch(key);
-				return;
-			}
-			const n: LNode = { key, prev: null, next: null };
-			map.set(key, n);
-			pushFront(n);
-		},
-		touch(key: K): void {
-			const n = map.get(key);
-			if (!n) return;
-			unlink(n);
-			pushFront(n);
-		},
-		delete(key: K): void {
-			const n = map.get(key);
-			if (!n) return;
-			unlink(n);
-			map.delete(key);
-		},
-		evict(count: number): K[] {
-			const victims: K[] = [];
-			for (let i = 0; i < count && tail !== null; i++) {
-				const n = tail;
-				victims.push(n.key);
-				unlink(n);
-				map.delete(n.key);
-			}
-			return victims;
-		},
-		size(): number {
-			return map.size;
-		},
-	};
-}
-
-// ——————————————————————————————————————————————————————————————
-//  CascadingCache
-// ——————————————————————————————————————————————————————————————
-
-export interface CascadingCacheOptions {
-	/** Max entries before eviction. 0 = unlimited (default). */
-	maxSize?: number;
-	/** Eviction policy. Default: LRU. Only used when maxSize > 0. */
-	eviction?: CacheEvictionPolicy<string>;
-	/** Write-through: save() writes to all tiers, not just tier 0. Default: false. */
-	writeThrough?: boolean;
-}
-
-export interface CascadingCache<V> {
-	/** Get or create a singleton state node for this key. Cascades tiers on miss. */
-	load(key: string): Node<V | undefined>;
-	/** Write value to tier(s) and update cache node in-place. */
-	save(key: string, value: V): void;
-	/** Re-cascade tiers into the existing cache node (subscribers see the update). */
-	invalidate(key: string): void;
-	/** Remove from all tiers, teardown the node, and delete cache entry. */
-	delete(key: string): void;
-	/** Check if key exists in cache map. */
-	has(key: string): boolean;
-	/** Number of cached entries. */
-	readonly size: number;
-}
-
-function isPromiseLike(v: unknown): v is Promise<unknown> {
-	return v != null && typeof (v as Promise<unknown>).then === "function";
-}
-
-function fireAndForget(result: void | Promise<void>): void {
-	if (isPromiseLike(result)) {
-		(result as Promise<void>).catch(() => {
-			/* ignore — users opt into onError via attachSnapshotStorage, not cache */
-		});
-	}
-}
-
-/**
- * Creates a singleton reactive cache with N-tier cascading lookup.
- *
- * Each cached entry is a `state()` node. On cache miss, tiers are tried in order
- * (index 0 = hottest/fastest). When a lower tier hits, the value is auto-promoted
- * to all faster tiers. Concurrent loads for the same key share the same state
- * instance — natural dedup.
- *
- * **Sync vs async tiers:** if `tier.load` returns a plain value, the cache node
- * cache is populated synchronously (`c.load("k").cache` is readable immediately).
- * If it returns a `Promise`, the node emits `DATA` when the promise resolves.
- *
- * **Miss sentinel:** `undefined` and `null` are both treated as misses — the
- * cascade continues to the next tier.
- *
- * @param tiers - Ordered lookup tiers, hottest first.
- * @param opts - Optional configuration (maxSize, eviction policy, writeThrough).
- * @returns A reactive cache where each entry is a `Node<V | undefined>`.
- *
- * @example
- * ```ts
- * import { cascadingCache, memoryKv, fileKv } from "@graphrefly/pure-ts";
- *
- * const cache = cascadingCache<User>([memoryKv(), fileKv("../cache")]);
- * const user = cache.load("user:42"); // Node<User | undefined>
- * user.subscribe(msgs => console.log(msgs));
- * ```
- *
- * @category extra
- */
-export function cascadingCache<V = unknown>(
-	tiers: readonly KvStorageTier[],
-	opts?: CascadingCacheOptions,
-): CascadingCache<V> {
-	const entries = new Map<string, Node<V | undefined>>();
-	const maxSize = opts?.maxSize ?? 0;
-	const policy = maxSize > 0 ? (opts?.eviction ?? lru<string>()) : null;
-	const writeThrough = opts?.writeThrough ?? false;
-
-	function promote(key: string, value: V, hitTierIndex: number): void {
-		for (let i = 0; i < hitTierIndex; i++) {
-			try {
-				fireAndForget(tiers[i]!.save(key, value));
-			} catch {
-				/* ignore promote failures — cache still serves this request */
-			}
-		}
-	}
-
-	/**
-	 * Cascade from `startTier` onward. Sync tiers resolve inline; async tiers
-	 * yield control via Promise chaining and recurse on miss. Both paths end
-	 * by emitting `[[DATA, value]]` on `nd` and promoting to faster tiers.
-	 */
-	function cascade(key: string, nd: Node<V | undefined>, startTier = 0): void {
-		for (let tierIndex = startTier; tierIndex < tiers.length; tierIndex++) {
-			let result: unknown;
-			try {
-				result = tiers[tierIndex]!.load(key);
-			} catch {
-				continue; // sync throw — next tier
-			}
-			if (isPromiseLike(result)) {
-				const captured = tierIndex;
-				(result as Promise<unknown>).then(
-					(val) => {
-						if (val !== undefined) {
-							nd.down([[DATA, val]]);
-							promote(key, val as V, captured);
-						} else {
-							cascade(key, nd, captured + 1);
-						}
-					},
-					() => {
-						cascade(key, nd, captured + 1);
-					},
-				);
-				return; // async branch continues the cascade
-			}
-			if (result !== undefined) {
-				nd.down([[DATA, result]]);
-				promote(key, result as V, tierIndex);
-				return;
-			}
-		}
-		// all tiers missed — value stays undefined
-	}
-
-	function evictIfNeeded(): void {
-		if (!policy || maxSize <= 0) return;
-		while (policy.size() >= maxSize) {
-			const victims = policy.evict(1);
-			if (victims.length === 0) break;
-			for (const key of victims) {
-				const nd = entries.get(key);
-				if (nd) {
-					const value = nd.cache;
-					if (nd.status !== "sentinel" && tiers.length > 0) {
-						// Demote to last tier, clear faster tiers.
-						const lastIndex = tiers.length - 1;
-						try {
-							fireAndForget(tiers[lastIndex]!.save(key, value as V));
-						} catch {
-							/* ignore */
-						}
-						for (let j = 0; j < lastIndex; j++) {
-							try {
-								const deleteFn = tiers[j]!.delete;
-								if (deleteFn) fireAndForget(deleteFn.call(tiers[j], key));
-							} catch {
-								/* ignore */
-							}
-						}
-					}
-					nd.down([[TEARDOWN]]);
-				}
-				entries.delete(key);
-			}
-		}
-	}
-
-	return {
-		load(key: string): Node<V | undefined> {
-			const existing = entries.get(key);
-			if (existing) {
-				policy?.touch(key);
-				return existing;
-			}
-			if (policy && maxSize > 0 && policy.size() >= maxSize) {
-				evictIfNeeded();
-			}
-			const nd = node<V | undefined>([], { initial: undefined });
-			entries.set(key, nd);
-			policy?.insert(key);
-			cascade(key, nd);
-			return nd;
-		},
-
-		save(key: string, value: V): void {
-			if (writeThrough) {
-				for (const tier of tiers) {
-					try {
-						fireAndForget(tier.save(key, value));
-					} catch {
-						/* ignore */
-					}
-				}
-			} else if (tiers[0]) {
-				try {
-					fireAndForget(tiers[0].save(key, value));
-				} catch {
-					/* ignore */
-				}
-			}
-			const existing = entries.get(key);
-			if (existing) {
-				existing.down([[DATA, value]]);
-				policy?.touch(key);
-			} else {
-				if (policy && maxSize > 0 && policy.size() >= maxSize) {
-					evictIfNeeded();
-				}
-				const nd = node<V | undefined>([], { initial: value });
-				entries.set(key, nd);
-				policy?.insert(key);
-			}
-		},
-
-		invalidate(key: string): void {
-			const existing = entries.get(key);
-			if (existing) cascade(key, existing);
-		},
-
-		delete(key: string): void {
-			policy?.delete(key);
-			const nd = entries.get(key);
-			if (nd) nd.down([[TEARDOWN]]);
-			entries.delete(key);
-			for (const tier of tiers) {
-				try {
-					const deleteFn = tier.delete;
-					if (deleteFn) fireAndForget(deleteFn.call(tier, key));
-				} catch {
-					/* ignore */
-				}
-			}
-		},
-
-		has(key: string): boolean {
-			return entries.has(key);
-		},
-
-		get size(): number {
-			return entries.size;
-		},
-	};
-}
diff --git a/packages/pure-ts/src/extra/storage/content-addressed.ts b/packages/pure-ts/src/extra/storage/content-addressed.ts
deleted file mode 100644
index e4742bd5..00000000
--- a/packages/pure-ts/src/extra/storage/content-addressed.ts
+++ /dev/null
@@ -1,197 +0,0 @@
-/**
- * Content-addressed storage substrate — a generic lookup / store helper over
- * any {@link StorageTier}. Hashes an arbitrary context object via
- * {@link canonicalJson} + sha256 to produce a stable key, then reads or writes
- * the record from the underlying tier.
- *
- * Substrate shared by LLM adapters (`withReplayCache`, `fallbackAdapter`) —
- * the LLM-specific shape (key prefix, `ChatMessage` + `LLMInvokeOptions`
- * context) lives in a thin wrapper inside `@graphrefly/graphrefly` presentation
- * (`src/utils/ai/adapters/_internal/`).
- * Any consumer that wants "memoize by content hash over a pluggable tier"
- * (tool result caches, embedding caches, deterministic function memoization,
- * fixtures for replay tests) can use this primitive directly.
- *
- * Universal tier — browser + Node safe. `sha256Hex` is pulled from
- * `core/hash.ts` (Web Crypto), `canonicalJson` is a pure function in this
- * module.
- *
- * @module
- */
-
-import { sha256Hex } from "../../core/hash.js";
-import type { KvStorageTier } from "./tiers.js";
-
-/**
- * Read / write / read-write / read-strict.
- *
- * - `"read"` — lookups hit storage; misses fall through to the caller.
- * - `"write"` — store only; lookups always return `undefined`.
- * - `"read-write"` — lookups hit storage, misses are writable by the caller.
- * - `"read-strict"` — lookups hit storage, misses throw (no fallthrough).
- *   Used by fixture-based replay flows where a missing fixture is a test bug.
- *
- * @category extra
- */
-export type ContentAddressedMode = "read" | "write" | "read-write" | "read-strict";
-
-/** Error thrown when `read-strict` mode misses. */
-export class ContentAddressedMissError extends Error {
-	constructor(
-		public readonly key: string,
-		public readonly context: unknown,
-	) {
-		super(`content-addressed lookup miss in read-strict mode: ${key}`);
-		this.name = "ContentAddressedMissError";
-	}
-}
-
-/**
- * Options for {@link contentAddressedStorage}.
- *
- * @category extra
- */
-export type ContentAddressedStorageOptions<Ctx> = {
-	/** Underlying storage tier (any `KvStorageTier` — memoryKv, fileKv, indexedDbKv). */
-	storage: KvStorageTier;
-	/**
-	 * Derive the hashable context from `ctx`. Defaults to `ctx` itself.
-	 * Use when the caller's `ctx` carries fields that should NOT participate in
-	 * the key (e.g. an `AbortSignal`, a retry count).
-	 */
-	keyContext?: (ctx: Ctx) => unknown;
-	/**
-	 * Optional key prefix — applied as `${prefix}:${hex}` so multiple consumers
-	 * can share one storage tier without collisions.
-	 */
-	keyPrefix?: string;
-	/** Mode — see {@link ContentAddressedMode}. Default `"read-write"`. */
-	mode?: ContentAddressedMode;
-};
-
-/**
- * Handle returned by {@link contentAddressedStorage}.
- *
- * @category extra
- */
-export type ContentAddressedStorage<Ctx, V> = {
-	/**
-	 * Compute the content-addressed key for `ctx` — useful when a caller needs
-	 * to thread the same key through a singleflight / dedup stage without
-	 * re-hashing.
-	 */
-	keyFor(ctx: Ctx): Promise<string>;
-	/**
-	 * Look up a value by hashing `ctx`. In `read-strict` mode, throws
-	 * {@link ContentAddressedMissError} on miss.
-	 */
-	lookup(ctx: Ctx): Promise<V | undefined>;
-	/** Store `value` under the hash of `ctx`. No-op in `"read"` mode. */
-	store(ctx: Ctx, value: V): Promise<void>;
-	/** Clear the entry for `ctx`. No-op in `"read"` or `"write"` mode, or when the tier lacks `clear()`. */
-	forget(ctx: Ctx): Promise<void>;
-};
-
-/**
- * Canonical JSON — sorts object keys for stable sha256 while detecting true
- * cycles (not sibling shared refs).
- *
- * We recurse manually with a **path stack** (`seen` contains only the current
- * ancestor chain, not every previously-visited object). On enter we push; on
- * exit we pop. Back-edges to ancestors serialize as `{"__cycle": true}`;
- * siblings that share the same reference serialize normally, producing
- * identical hashes to a freshly-reconstructed equivalent.
- *
- * @category extra
- */
-export function canonicalJson(value: unknown): string {
-	const ancestors = new Set<object>();
-
-	const canon = (v: unknown): unknown => {
-		if (v === null || typeof v !== "object") return v;
-		const obj = v as object;
-		if (ancestors.has(obj)) return { __cycle: true };
-		ancestors.add(obj);
-		try {
-			if (Array.isArray(v)) {
-				return (v as readonly unknown[]).map(canon);
-			}
-			const out: Record<string, unknown> = {};
-			for (const k of Object.keys(v as Record<string, unknown>).sort()) {
-				out[k] = canon((v as Record<string, unknown>)[k]);
-			}
-			return out;
-		} finally {
-			ancestors.delete(obj);
-		}
-	};
-
-	return JSON.stringify(canon(value));
-}
-
-/**
- * Creates a content-addressed lookup / store handle over `storage`. The key
- * is `sha256Hex(canonicalJson(keyContext(ctx)))`, optionally prefixed by
- * `keyPrefix`.
- *
- * @example
- * ```ts
- * import { contentAddressedStorage, memoryKv } from "@graphrefly/pure-ts";
- *
- * const cache = contentAddressedStorage<{ query: string }, { answer: string }>({
- *   storage: memoryKv(),
- *   keyPrefix: "qa",
- *   mode: "read-write",
- * });
- *
- * const hit = await cache.lookup({ query: "what is graphrefly?" });
- * if (!hit) {
- *   const ans = await computeAnswer({ query: "what is graphrefly?" });
- *   await cache.store({ query: "what is graphrefly?" }, { answer: ans.text });
- * }
- * ```
- *
- * @category extra
- */
-export function contentAddressedStorage<Ctx, V>(
-	opts: ContentAddressedStorageOptions<Ctx>,
-): ContentAddressedStorage<Ctx, V> {
-	const { storage, keyContext, keyPrefix, mode = "read-write" } = opts;
-	const extract = keyContext ?? ((c: Ctx) => c as unknown);
-
-	async function keyFor(ctx: Ctx): Promise<string> {
-		const canonical = canonicalJson(extract(ctx));
-		const hex = await sha256Hex(canonical);
-		return keyPrefix ? `${keyPrefix}:${hex}` : hex;
-	}
-
-	return {
-		keyFor,
-
-		async lookup(ctx: Ctx): Promise<V | undefined> {
-			if (mode === "write") return undefined;
-			const key = await keyFor(ctx);
-			const raw = await storage.load(key);
-			if (raw === undefined) {
-				if (mode === "read-strict") {
-					throw new ContentAddressedMissError(key, ctx);
-				}
-				return undefined;
-			}
-			return raw as V;
-		},
-
-		async store(ctx: Ctx, value: V): Promise<void> {
-			if (mode === "read") return;
-			const key = await keyFor(ctx);
-			await storage.save(key, value as unknown);
-		},
-
-		async forget(ctx: Ctx): Promise<void> {
-			if (mode === "read" || mode === "write") return;
-			if (!storage.delete) return;
-			const key = await keyFor(ctx);
-			await storage.delete(key);
-		},
-	};
-}
diff --git a/packages/pure-ts/src/extra/storage/core.ts b/packages/pure-ts/src/extra/storage/core.ts
deleted file mode 100644
index 677ecdd6..00000000
--- a/packages/pure-ts/src/extra/storage/core.ts
+++ /dev/null
@@ -1,39 +0,0 @@
-/**
- * Storage core — browser-safe shared helpers.
- *
- * This module exposes only the stable shared utilities (`StorageHandle`,
- * `sortJsonValue`, `stableJsonString`). The old `StorageTier` interface and
- * its in-memory factories (`memoryStorage`, `dictStorage`) have been removed
- * — use `KvStorageTier` + `memoryKv` / `dictKv` from `./storage-tiers.js`
- * instead (Audit 4, 2026-04-24).
- *
- * Node-only backends (`fileKv`, `sqliteKv`) live in `./storage-tiers-node.js`;
- * browser-only ones (`indexedDbKv`) live in `./storage-tiers-browser.js`.
- *
- * @module
- */
-
-/** Handle returned by `Graph.attachSnapshotStorage` — dispose to stop observing. */
-export interface StorageHandle {
-	dispose(): void | Promise<void>;
-}
-
-/** Recursively sort object keys so `JSON.stringify` output is order-independent. */
-export function sortJsonValue(value: unknown): unknown {
-	if (value === null || typeof value !== "object") return value;
-	if (Array.isArray(value)) return value.map(sortJsonValue);
-	const obj = value as Record<string, unknown>;
-	const keys = Object.keys(obj).sort();
-	const out: Record<string, unknown> = {};
-	for (const k of keys) out[k] = sortJsonValue(obj[k]);
-	return out;
-}
-
-/**
- * Stable JSON encoding (no trailing newline). Tiers that want POSIX newline
- * convention (e.g. `fileKv`) append their own; in-database tiers (`sqliteKv`)
- * keep the payload byte-identical for cross-tier hash/CID comparison.
- */
-export function stableJsonString(data: unknown): string {
-	return JSON.stringify(sortJsonValue(data), undefined, 0);
-}
diff --git a/packages/pure-ts/src/extra/storage/index.ts b/packages/pure-ts/src/extra/storage/index.ts
deleted file mode 100644
index 51c71169..00000000
--- a/packages/pure-ts/src/extra/storage/index.ts
+++ /dev/null
@@ -1,19 +0,0 @@
-/**
- * Storage barrel — persistence tiers (memory/file/sqlite/IDB), codecs,
- * content-addressed storage, cascading cache.
- *
- * Per the consolidation plan §2, this folder gathers the existing
- * `storage-*` and related files for category-level discoverability. Physical
- * files remain at `src/extra/storage-*.ts`, `cascading-cache.ts`, and
- * `content-addressed-storage.ts` (deferred move).
- *
- * Browser-only (`tiers-browser.ts`) and Node-only (`tiers-node.ts`) are
- * intentionally NOT re-exported from this barrel — keep those subpaths
- * environment-scoped to preserve the universal/node/browser split.
- */
-
-export * from "./cascading-cache.js";
-export * from "./content-addressed.js";
-export * from "./core.js";
-export * from "./tiers.js";
-export * from "./wal.js";
diff --git a/packages/pure-ts/src/extra/storage/tiers-browser.ts b/packages/pure-ts/src/extra/storage/tiers-browser.ts
deleted file mode 100644
index d9e0aee0..00000000
--- a/packages/pure-ts/src/extra/storage/tiers-browser.ts
+++ /dev/null
@@ -1,219 +0,0 @@
-/**
- * Browser-only Audit 4 storage backend + convenience factories.
- *
- * Uses DOM `IndexedDB`. Browser-safe consumers should import from this module;
- * Node consumers should not import here without the DOM lib in their tsconfig.
- *
- * @module
- */
-/// <reference lib="dom" />
-
-import {
-	type AppendLogStorageOptions,
-	type AppendLogStorageTier,
-	appendLogStorage,
-	type KvStorageOptions,
-	type KvStorageTier,
-	kvStorage,
-	type SnapshotStorageOptions,
-	type SnapshotStorageTier,
-	type StorageBackend,
-	snapshotStorage,
-} from "./tiers.js";
-
-export type IndexedDbBackendSpec = {
-	dbName: string;
-	storeName: string;
-	version?: number;
-};
-
-function openDb(spec: IndexedDbBackendSpec): Promise<IDBDatabase> {
-	return new Promise<IDBDatabase>((resolve, reject) => {
-		if (typeof indexedDB === "undefined") {
-			reject(new TypeError("indexedDB is not available in this environment"));
-			return;
-		}
-		const req = indexedDB.open(spec.dbName, spec.version ?? 1);
-		req.onupgradeneeded = () => {
-			const db = req.result;
-			if (!db.objectStoreNames.contains(spec.storeName)) {
-				db.createObjectStore(spec.storeName);
-			}
-		};
-		req.onsuccess = () => resolve(req.result);
-		req.onerror = () =>
-			reject(req.error ?? new Error(`indexedDbBackend: open(${spec.dbName}) failed`));
-	});
-}
-
-/**
- * Creates an IndexedDB backend for browser-based persistent storage.
- *
- * All operations (`read`, `write`, `delete`, `list`) are async and return
- * `Promise`. The backing object store is created automatically on first open
- * if it does not already exist.
- *
- * @param spec - Database name, object store name, and optional schema version.
- * @returns `StorageBackend` backed by an IndexedDB object store.
- *
- * @example
- * ```ts
- * import { indexedDbBackend, snapshotStorage } from "@graphrefly/graphrefly/extra/browser";
- *
- * const backend = indexedDbBackend({ dbName: "my-app", storeName: "snapshots" });
- * const tier = snapshotStorage(backend, { name: "graph1" });
- * await tier.save({ name: "graph1", state: {} });
- * ```
- *
- * @category extra
- */
-export function indexedDbBackend(spec: IndexedDbBackendSpec): StorageBackend {
-	const cache = openDb(spec);
-	return {
-		name: `idb:${spec.dbName}/${spec.storeName}`,
-		async read(key) {
-			const db = await cache;
-			return new Promise<Uint8Array | undefined>((resolve, reject) => {
-				const tx = db.transaction(spec.storeName, "readonly");
-				const store = tx.objectStore(spec.storeName);
-				const req = store.get(key);
-				req.onsuccess = () => {
-					const raw = req.result;
-					if (raw === undefined || raw === null) resolve(undefined);
-					else if (raw instanceof Uint8Array) resolve(raw);
-					else if (raw instanceof ArrayBuffer) resolve(new Uint8Array(raw));
-					else resolve(undefined);
-				};
-				req.onerror = () => reject(req.error);
-			});
-		},
-		async write(key, bytes) {
-			const db = await cache;
-			await new Promise<void>((resolve, reject) => {
-				const tx = db.transaction(spec.storeName, "readwrite");
-				const store = tx.objectStore(spec.storeName);
-				store.put(bytes, key);
-				tx.oncomplete = () => resolve();
-				tx.onerror = () => reject(tx.error);
-				tx.onabort = () => reject(tx.error ?? new Error("indexedDbBackend: write aborted"));
-			});
-		},
-		async delete(key) {
-			const db = await cache;
-			await new Promise<void>((resolve, reject) => {
-				const tx = db.transaction(spec.storeName, "readwrite");
-				const store = tx.objectStore(spec.storeName);
-				store.delete(key);
-				tx.oncomplete = () => resolve();
-				tx.onerror = () => reject(tx.error);
-			});
-		},
-		async list(prefix) {
-			const db = await cache;
-			return new Promise<readonly string[]>((resolve, reject) => {
-				const tx = db.transaction(spec.storeName, "readonly");
-				const store = tx.objectStore(spec.storeName);
-				const req = store.getAllKeys();
-				req.onsuccess = () => {
-					const keys = (req.result as IDBValidKey[]).map((k) => String(k));
-					resolve(
-						prefix === undefined ? keys.sort() : keys.filter((k) => k.startsWith(prefix)).sort(),
-					);
-				};
-				req.onerror = () => reject(req.error);
-			});
-		},
-	};
-}
-
-/**
- * Creates an IndexedDB snapshot tier backed by an `indexedDbBackend`.
- *
- * Convenience wrapper for `snapshotStorage(indexedDbBackend(spec), opts)`.
- * All reads and writes are async via IndexedDB. Requires a browser or
- * browser-compatible environment.
- *
- * @param spec - Database name, object store name, and optional schema version.
- * @param opts - Optional snapshot storage options (name, codec, filter, keyOf, debounce, compactEvery).
- * @returns `SnapshotStorageTier<T>` backed by IndexedDB.
- *
- * @example
- * ```ts
- * import { indexedDbSnapshot } from "@graphrefly/graphrefly/extra/browser";
- *
- * const tier = indexedDbSnapshot<{ count: number }>(
- *   { dbName: "my-app", storeName: "snapshots" },
- *   { name: "counter" },
- * );
- * await tier.save({ count: 1 });
- * ```
- *
- * @category extra
- */
-export function indexedDbSnapshot<T>(
-	spec: IndexedDbBackendSpec,
-	opts?: Omit<SnapshotStorageOptions<T>, "name"> & { name?: string },
-): SnapshotStorageTier<T> {
-	return snapshotStorage<T>(indexedDbBackend(spec), opts);
-}
-
-/**
- * Creates an IndexedDB append-log tier backed by an `indexedDbBackend`.
- *
- * Convenience wrapper for `appendLogStorage(indexedDbBackend(spec), opts)`.
- * All reads and writes are async via IndexedDB. Requires a browser or
- * browser-compatible environment.
- *
- * @param spec - Database name, object store name, and optional schema version.
- * @param opts - Optional append-log storage options (name, codec, keyOf, debounce, compactEvery).
- * @returns `AppendLogStorageTier<T>` backed by IndexedDB.
- *
- * @example
- * ```ts
- * import { indexedDbAppendLog } from "@graphrefly/graphrefly/extra/browser";
- *
- * const tier = indexedDbAppendLog<{ type: string }>(
- *   { dbName: "my-app", storeName: "events" },
- * );
- * await tier.appendEntries([{ type: "init" }]);
- * ```
- *
- * @category extra
- */
-export function indexedDbAppendLog<T>(
-	spec: IndexedDbBackendSpec,
-	opts?: Omit<AppendLogStorageOptions<T>, "name"> & { name?: string },
-): AppendLogStorageTier<T> {
-	return appendLogStorage<T>(indexedDbBackend(spec), opts);
-}
-
-/**
- * Creates an IndexedDB key-value tier backed by an `indexedDbBackend`.
- *
- * Convenience wrapper for `kvStorage(indexedDbBackend(spec), opts)`.
- * All reads and writes are async via IndexedDB. Requires a browser or
- * browser-compatible environment.
- *
- * @param spec - Database name, object store name, and optional schema version.
- * @param opts - Optional kv storage options (name, codec, filter, debounce, compactEvery).
- * @returns `KvStorageTier<T>` backed by IndexedDB.
- *
- * @example
- * ```ts
- * import { indexedDbKv } from "@graphrefly/graphrefly/extra/browser";
- *
- * const kv = indexedDbKv<{ score: number }>(
- *   { dbName: "my-app", storeName: "scores" },
- * );
- * await kv.save("player1", { score: 100 });
- * const val = await kv.load("player1");
- * ```
- *
- * @category extra
- */
-export function indexedDbKv<T>(
-	spec: IndexedDbBackendSpec,
-	opts?: Omit<KvStorageOptions<T>, "name"> & { name?: string },
-): KvStorageTier<T> {
-	return kvStorage<T>(indexedDbBackend(spec), opts);
-}
diff --git a/packages/pure-ts/src/extra/storage/tiers-node.ts b/packages/pure-ts/src/extra/storage/tiers-node.ts
deleted file mode 100644
index ea12922f..00000000
--- a/packages/pure-ts/src/extra/storage/tiers-node.ts
+++ /dev/null
@@ -1,396 +0,0 @@
-/**
- * Node-only Audit 4 storage backends + convenience factories.
- *
- * Imports `node:fs`, `node:path`, `node:crypto`, `node:sqlite`. Browser-safe
- * consumers should not import this module.
- *
- * @module
- */
-
-import { randomBytes } from "node:crypto";
-import {
-	mkdirSync,
-	readdirSync,
-	readFileSync,
-	renameSync,
-	unlinkSync,
-	writeFileSync,
-} from "node:fs";
-import { basename, dirname, join } from "node:path";
-import { DatabaseSync } from "node:sqlite";
-import {
-	type AppendLogStorageOptions,
-	type AppendLogStorageTier,
-	appendLogStorage,
-	type KvStorageOptions,
-	type KvStorageTier,
-	kvStorage,
-	type SnapshotStorageOptions,
-	type SnapshotStorageTier,
-	type StorageBackend,
-	snapshotStorage,
-} from "./tiers.js";
-
-// ── File backend ─────────────────────────────────────────────────────────
-
-/**
- * Creates a filesystem backend that maps each key to a file under `dir`.
- *
- * Writes are atomic via temp + rename. Keys are percent-encoded to safe
- * filenames; `list(prefix)` enumerates `.bin` files in the directory.
- *
- * @param dir - Directory path where key files are stored (created on first write).
- * @returns `StorageBackend` backed by the filesystem under `dir`.
- *
- * @example
- * ```ts
- * import { fileBackend, snapshotStorage } from "@graphrefly/graphrefly/extra/node";
- *
- * const backend = fileBackend("../checkpoints");
- * const tier = snapshotStorage(backend, { name: "my-graph" });
- * await tier.save({ name: "my-graph", state: { count: 1 } });
- * ```
- *
- * @category extra
- */
-export function fileBackend(dir: string): StorageBackend {
-	const encoder = new TextEncoder();
-	const decoder = new TextDecoder("utf-8", { fatal: true });
-	const pathFor = (key: string): string => {
-		let out = "";
-		for (const ch of key) {
-			if (ch.length === 1 && /[a-zA-Z0-9_-]/.test(ch)) {
-				out += ch;
-				continue;
-			}
-			for (const byte of encoder.encode(ch)) {
-				out += `%${byte.toString(16).padStart(2, "0")}`;
-			}
-		}
-		return join(dir, `${out}.bin`);
-	};
-	const keyFromFilename = (filename: string): string | null => {
-		if (!filename.endsWith(".bin")) return null;
-		const stem = filename.slice(0, -".bin".length);
-		const bytes: number[] = [];
-		const encodeAscii = (s: string): void => {
-			for (let i = 0; i < s.length; i++) bytes.push(s.charCodeAt(i));
-		};
-		let i = 0;
-		while (i < stem.length) {
-			const ch = stem[i]!;
-			if (ch === "%" && i + 2 < stem.length) {
-				const hex = stem.slice(i + 1, i + 3);
-				if (/^[0-9a-f]{2}$/i.test(hex)) {
-					bytes.push(Number.parseInt(hex, 16));
-					i += 3;
-					continue;
-				}
-			}
-			encodeAscii(ch);
-			i += 1;
-		}
-		try {
-			return decoder.decode(new Uint8Array(bytes));
-		} catch {
-			return null;
-		}
-	};
-	return {
-		name: `file:${dir}`,
-		read(key) {
-			try {
-				const buf = readFileSync(pathFor(key));
-				return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
-			} catch {
-				return undefined;
-			}
-		},
-		write(key, bytes) {
-			mkdirSync(dir, { recursive: true });
-			const filePath = pathFor(key);
-			const base = basename(filePath);
-			const d = dirname(filePath);
-			const tmp = join(d, `.${base}.${randomBytes(8).toString("hex")}.tmp`);
-			try {
-				writeFileSync(tmp, bytes);
-				renameSync(tmp, filePath);
-			} catch (e) {
-				try {
-					unlinkSync(tmp);
-				} catch {
-					/* ignore */
-				}
-				throw e;
-			}
-		},
-		delete(key) {
-			try {
-				unlinkSync(pathFor(key));
-			} catch (e) {
-				if ((e as NodeJS.ErrnoException).code !== "ENOENT") throw e;
-			}
-		},
-		list(prefix) {
-			try {
-				const entries = readdirSync(dir);
-				const keys: string[] = [];
-				for (const entry of entries) {
-					if (entry.startsWith(".")) continue;
-					const k = keyFromFilename(entry);
-					if (k === null) continue;
-					if (prefix !== undefined && !k.startsWith(prefix)) continue;
-					keys.push(k);
-				}
-				return keys.sort();
-			} catch (e) {
-				if ((e as NodeJS.ErrnoException).code === "ENOENT") return [];
-				throw e;
-			}
-		},
-	};
-}
-
-// ── SQLite backend ───────────────────────────────────────────────────────
-
-/**
- * Creates a SQLite backend using Node 22.5+ `node:sqlite`.
- *
- * Stores byte values under string keys in a single `graphrefly_storage` table.
- * The caller owns the connection lifetime — call `.close()` for explicit teardown.
- * Requires Node 22.5 or later for `node:sqlite`.
- *
- * @param path - Filesystem path to the SQLite database file (created if absent).
- * @returns `StorageBackend` with an extra `close()` method for explicit teardown.
- *
- * @example
- * ```ts
- * import { sqliteBackend, snapshotStorage } from "@graphrefly/graphrefly/extra/node";
- *
- * const backend = sqliteBackend("../state.db");
- * const tier = snapshotStorage(backend, { name: "my-graph" });
- * await tier.save({ name: "my-graph", state: { count: 1 } });
- * backend.close();
- * ```
- *
- * @category extra
- */
-export function sqliteBackend(path: string): StorageBackend & { close(): void } {
-	const db = new DatabaseSync(path);
-	db.exec(`CREATE TABLE IF NOT EXISTS graphrefly_storage (k TEXT PRIMARY KEY, v BLOB NOT NULL)`);
-	return {
-		name: `sqlite:${path}`,
-		read(key) {
-			const row = db.prepare(`SELECT v FROM graphrefly_storage WHERE k = ?`).get(key) as
-				| { v: Uint8Array }
-				| undefined;
-			return row?.v;
-		},
-		write(key, bytes) {
-			db.prepare(`INSERT OR REPLACE INTO graphrefly_storage (k, v) VALUES (?, ?)`).run(key, bytes);
-		},
-		delete(key) {
-			db.prepare(`DELETE FROM graphrefly_storage WHERE k = ?`).run(key);
-		},
-		list(prefix) {
-			if (prefix === undefined) {
-				const rows = db.prepare(`SELECT k FROM graphrefly_storage ORDER BY k`).all() as {
-					k: string;
-				}[];
-				return rows.map((r) => r.k);
-			}
-			// M7: escape SQLite LIKE wildcards (`%` and `_`) and the escape
-			// char itself so a user-supplied prefix can't match more rows
-			// than intended (e.g. prefix `"snap%"` should NOT match `"snapXshot"`).
-			const escaped = prefix.replace(/[\\%_]/g, "\\$&");
-			const rows = db
-				.prepare(`SELECT k FROM graphrefly_storage WHERE k LIKE ? ESCAPE '\\' ORDER BY k`)
-				.all(`${escaped}%`) as { k: string }[];
-			return rows.map((r) => r.k);
-		},
-		close() {
-			try {
-				db.close();
-			} catch {
-				/* already closed */
-			}
-		},
-	};
-}
-
-// ── Convenience factories ───────────────────────────────────────────────
-
-/**
- * Creates a filesystem snapshot tier backed by a `fileBackend` under `dir`.
- *
- * Convenience wrapper for `snapshotStorage(fileBackend(dir), opts)`.
- * Writes are atomic (temp + rename). Requires Node.js with filesystem access.
- *
- * @param dir - Directory path where snapshot files are stored.
- * @param opts - Optional snapshot storage options (name, codec, filter, keyOf, debounce, compactEvery).
- * @returns `SnapshotStorageTier<T>` backed by the filesystem.
- *
- * @example
- * ```ts
- * import { fileSnapshot } from "@graphrefly/graphrefly/extra/node";
- *
- * const tier = fileSnapshot<{ count: number }>("../checkpoints", { name: "counter" });
- * await tier.save({ count: 1 });
- * ```
- *
- * @category extra
- */
-export function fileSnapshot<T>(
-	dir: string,
-	opts?: Omit<SnapshotStorageOptions<T>, "name"> & { name?: string },
-): SnapshotStorageTier<T> {
-	return snapshotStorage<T>(fileBackend(dir), opts);
-}
-
-/**
- * Creates a filesystem append-log tier backed by a `fileBackend` under `dir`.
- *
- * Convenience wrapper for `appendLogStorage(fileBackend(dir), opts)`.
- * Writes are atomic (temp + rename). Requires Node.js with filesystem access.
- *
- * @param dir - Directory path where append-log files are stored.
- * @param opts - Optional append-log storage options (name, codec, keyOf, debounce, compactEvery).
- * @returns `AppendLogStorageTier<T>` backed by the filesystem.
- *
- * @example
- * ```ts
- * import { fileAppendLog } from "@graphrefly/graphrefly/extra/node";
- *
- * const tier = fileAppendLog<{ type: string; id: number }>("../events");
- * await tier.appendEntries([{ type: "created", id: 1 }]);
- * ```
- *
- * @category extra
- */
-export function fileAppendLog<T>(
-	dir: string,
-	opts?: Omit<AppendLogStorageOptions<T>, "name"> & { name?: string },
-): AppendLogStorageTier<T> {
-	return appendLogStorage<T>(fileBackend(dir), opts);
-}
-
-/**
- * Creates a SQLite snapshot tier; caller owns the connection lifetime.
- *
- * Convenience wrapper for `snapshotStorage(sqliteBackend(path), opts)`.
- * The returned tier exposes an extra `close()` method — call it for explicit
- * teardown of the underlying SQLite connection.
- *
- * @param path - Filesystem path to the SQLite database file.
- * @param opts - Optional snapshot storage options (name, codec, filter, keyOf, debounce, compactEvery).
- * @returns `SnapshotStorageTier<T>` with a `close()` method for connection teardown.
- *
- * @example
- * ```ts
- * import { sqliteSnapshot } from "@graphrefly/graphrefly/extra/node";
- *
- * const tier = sqliteSnapshot<{ count: number }>("../state.db", { name: "counter" });
- * await tier.save({ count: 42 });
- * tier.close();
- * ```
- *
- * @category extra
- */
-export function sqliteSnapshot<T>(
-	path: string,
-	opts?: Omit<SnapshotStorageOptions<T>, "name"> & { name?: string },
-): SnapshotStorageTier<T> & { close(): void } {
-	const backend = sqliteBackend(path);
-	const tier = snapshotStorage<T>(backend, opts);
-	return Object.assign(tier, { close: () => backend.close() });
-}
-
-/**
- * Creates a SQLite append-log tier; caller owns the connection lifetime.
- *
- * Convenience wrapper for `appendLogStorage(sqliteBackend(path), opts)`.
- * The returned tier exposes an extra `close()` method — call it for explicit
- * teardown of the underlying SQLite connection.
- *
- * @param path - Filesystem path to the SQLite database file.
- * @param opts - Optional append-log storage options (name, codec, keyOf, debounce, compactEvery).
- * @returns `AppendLogStorageTier<T>` with a `close()` method for connection teardown.
- *
- * @example
- * ```ts
- * import { sqliteAppendLog } from "@graphrefly/graphrefly/extra/node";
- *
- * const tier = sqliteAppendLog<{ type: string }>("../events.db", { name: "events" });
- * await tier.appendEntries([{ type: "created" }]);
- * tier.close();
- * ```
- *
- * @category extra
- */
-export function sqliteAppendLog<T>(
-	path: string,
-	opts?: Omit<AppendLogStorageOptions<T>, "name"> & { name?: string },
-): AppendLogStorageTier<T> & { close(): void } {
-	const backend = sqliteBackend(path);
-	const tier = appendLogStorage<T>(backend, opts);
-	return Object.assign(tier, { close: () => backend.close() });
-}
-
-/**
- * Creates a filesystem key-value tier backed by a `fileBackend` under `dir`.
- *
- * Convenience wrapper for `kvStorage(fileBackend(dir), opts)`.
- * Each key is stored as a separate file; writes are atomic (temp + rename).
- *
- * @param dir - Directory path where key files are stored.
- * @param opts - Optional kv storage options (name, codec, filter, debounce, compactEvery).
- * @returns `KvStorageTier<T>` backed by the filesystem.
- *
- * @example
- * ```ts
- * import { fileKv } from "@graphrefly/graphrefly/extra/node";
- *
- * const kv = fileKv<{ score: number }>("../scores");
- * await kv.save("player1", { score: 100 });
- * const val = await kv.load("player1");
- * ```
- *
- * @category extra
- */
-export function fileKv<T>(
-	dir: string,
-	opts?: Omit<KvStorageOptions<T>, "name"> & { name?: string },
-): KvStorageTier<T> {
-	return kvStorage<T>(fileBackend(dir), opts);
-}
-
-/**
- * Creates a SQLite key-value tier; caller owns the connection lifetime.
- *
- * Convenience wrapper for `kvStorage(sqliteBackend(path), opts)`.
- * The returned tier exposes an extra `close()` method — call it for explicit
- * teardown of the underlying SQLite connection.
- *
- * @param path - Filesystem path to the SQLite database file.
- * @param opts - Optional kv storage options (name, codec, filter, debounce, compactEvery).
- * @returns `KvStorageTier<T>` with a `close()` method for connection teardown.
- *
- * @example
- * ```ts
- * import { sqliteKv } from "@graphrefly/graphrefly/extra/node";
- *
- * const kv = sqliteKv<{ score: number }>("../scores.db");
- * await kv.save("player1", { score: 100 });
- * kv.close();
- * ```
- *
- * @category extra
- */
-export function sqliteKv<T>(
-	path: string,
-	opts?: Omit<KvStorageOptions<T>, "name"> & { name?: string },
-): KvStorageTier<T> & { close(): void } {
-	const backend = sqliteBackend(path);
-	const tier = kvStorage<T>(backend, opts);
-	return Object.assign(tier, { close: () => backend.close() });
-}
diff --git a/packages/pure-ts/src/extra/storage/tiers.ts b/packages/pure-ts/src/extra/storage/tiers.ts
deleted file mode 100644
index 392f5a2d..00000000
--- a/packages/pure-ts/src/extra/storage/tiers.ts
+++ /dev/null
@@ -1,1128 +0,0 @@
-/**
- * Storage tier architecture (Audit 4 — locked 2026-04-24).
- *
- * Three-layer design:
- *
- * - **Layer 1 — {@link StorageBackend}:** generic bytes-level kv I/O. One
- *   `read(key) → Uint8Array | undefined`, `write(key, bytes)`, optional
- *   `delete(key)` / `list(prefix)`. No tier-level concerns (debounce, codec).
- * - **Layer 2 — Tier specializations** layered over a backend, parametric over
- *   `T`: {@link SnapshotStorageTier} (one snapshot under one key) and
- *   {@link AppendLogStorageTier} (sequential entries, optional partition via
- *   `keyOf`). Both extend {@link BaseStorageTier} which carries
- *   `flush?` / `rollback?` for the wave-as-transaction model.
- * - **Layer 3 — High-level wiring:** `Graph.attachSnapshotStorage(tiers)`,
- *   `reactiveLog.attachStorage(tiers)`, `cqrsGraph.attachEventStorage(tiers)`,
- *   `jobQueueGraph.attachEventStorage(tiers)`. These layers consume tier
- *   specializations directly — they don't see the backend.
- *
- * Browser-safe by default. {@link memoryBackend} + the in-memory factories
- * live here; Node-only (`fileBackend` / `sqliteBackend`) lives in
- * `extra/storage-node.ts`; browser-only (`indexedDbBackend`) lives in
- * `extra/storage-browser.ts`.
- *
- * @module
- */
-
-import { sortJsonValue, stableJsonString } from "./core.js";
-import { StorageError } from "./wal.js";
-
-// ── Layer 1 — StorageBackend (bytes I/O) ──────────────────────────────────
-
-/**
- * Bytes-level kv backend. One responsibility: read/write byte ranges under
- * string keys. Tier specializations layer on top.
- *
- * @category extra
- */
-export interface StorageBackend {
-	/** Diagnostic name (e.g., `"memory"`, `"file:./checkpoints"`). */
-	readonly name: string;
-	/** Read raw bytes; returns `undefined` on miss. */
-	read(key: string): Uint8Array | undefined | Promise<Uint8Array | undefined>;
-	/** Write raw bytes. Sync backends return `void`; async return `Promise<void>`. */
-	write(key: string, bytes: Uint8Array): void | Promise<void>;
-	/** Optional delete-by-key. */
-	delete?(key: string): void | Promise<void>;
-	/** Optional enumeration; `prefix` filters keys. */
-	list?(prefix?: string): readonly string[] | Promise<readonly string[]>;
-	/** Optional drain hook — adapter authors implement when buffering writes. */
-	flush?(): Promise<void>;
-}
-
-// ── Codec system ──────────────────────────────────────────────────────────
-
-/**
- * Codec for tier serialization. Tiers call `encode(value) → bytes` before
- * `backend.write` and `decode(bytes) → value` after `backend.read`.
- *
- * @category extra
- */
-export interface Codec<T = unknown> {
-	readonly name: string;
-	readonly version: number;
-	encode(value: T): Uint8Array;
-	decode(bytes: Uint8Array): T;
-}
-
-const textEncoder = new TextEncoder();
-const textDecoder = new TextDecoder("utf-8", { fatal: true });
-
-/**
- * Default JSON codec — UTF-8 text, stable key order (via `stableJsonString`).
- * Any value JSON-serializable is supported.
- *
- * @category extra
- */
-export const jsonCodec: Codec<unknown> = {
-	name: "json",
-	version: 1,
-	encode(value): Uint8Array {
-		return textEncoder.encode(stableJsonString(value));
-	},
-	decode(bytes): unknown {
-		return JSON.parse(textDecoder.decode(bytes)) as unknown;
-	},
-};
-
-/**
- * Returns the default `jsonCodec` cast to `Codec<T>`.
- *
- * Pure typing helper — no runtime overhead. Use when a generic API requires a
- * `Codec<T>` and the value is known to be JSON-serializable.
- *
- * @returns `Codec<T>` backed by the shared `jsonCodec` (UTF-8 JSON, stable key order).
- *
- * @example
- * ```ts
- * import { memoryBackend, snapshotStorage, jsonCodecFor } from "@graphrefly/graphrefly/extra";
- *
- * type MyState = { count: number; label: string };
- * const tier = snapshotStorage<MyState>(memoryBackend(), {
- *   codec: jsonCodecFor<MyState>(),
- * });
- * ```
- *
- * @category extra
- */
-export function jsonCodecFor<T>(): Codec<T> {
-	return jsonCodec as unknown as Codec<T>;
-}
-
-/**
- * Sentinel key used to tag a serialized `bigint`. A value `123n` round-trips
- * as the single-key object `{"$bigint":"123"}`.
- */
-const BIGINT_TAG = "$bigint";
-/** Exactly what `BigInt.prototype.toString()` (radix 10) can produce. */
-const BIGINT_DECIMAL_RE = /^-?(?:0|[1-9]\d*)$/;
-
-function bigintReplacer(_key: string, value: unknown): unknown {
-	return typeof value === "bigint" ? { [BIGINT_TAG]: value.toString() } : value;
-}
-
-function bigintReviver(_key: string, value: unknown): unknown {
-	if (value === null || typeof value !== "object" || Array.isArray(value)) {
-		return value;
-	}
-	const obj = value as Record<string, unknown>;
-	const tag = obj[BIGINT_TAG];
-	// Only revive a value WE produced: single-key `$bigint` whose string is a
-	// canonical base-10 integer. A non-matching string (collision / tamper)
-	// falls through UNCHANGED — never `BigInt("notnum")` (throws, crashes the
-	// whole decode) and never `BigInt("0x1f")`/`BigInt("")` (silent wrong/zero).
-	if (typeof tag === "string" && Object.keys(obj).length === 1 && BIGINT_DECIMAL_RE.test(tag)) {
-		return BigInt(tag);
-	}
-	return value;
-}
-
-/**
- * BigInt-safe JSON codec — same UTF-8 / stable-key-order contract as
- * {@link jsonCodec}, but `bigint` fields round-trip losslessly via a tagged
- * `{"$bigint":"<decimal>"}` envelope (plain `JSON.stringify` throws on
- * `bigint`).
- *
- * Use this for any state carrying `bigint` fields — notably the DS-14.7
- * {@link reactiveFactStore} `MemoryFragment` (`t_ns` / `validFrom` /
- * `validTo`). The injected envelope has a single fixed key, so
- * `stableJsonString`'s order-independence is preserved.
- *
- * **Collision caveat:** a literal user object of the exact shape
- * `{ "$bigint": "<canonical-base-10-int>" }` (one key, e.g. `{"$bigint":"42"}`)
- * decodes back to a `BigInt`. The reviver is strict — a non-decimal tag value
- * (`"0x1f"`, `"1e3"`, `""`, `"notnum"`) falls through **unchanged** (never
- * throws, never coerces). Still, since `MemoryFragment<T>` embeds arbitrary
- * user `payload`, only use this codec when that payload cannot contain a
- * single-key `$bigint`-with-decimal-string object; otherwise such a value
- * round-trips to a `BigInt`.
- *
- * @category extra
- */
-export const bigintJsonCodec: Codec<unknown> = {
-	name: "json-bigint",
-	version: 1,
-	encode(value): Uint8Array {
-		return textEncoder.encode(JSON.stringify(sortJsonValue(value), bigintReplacer, 0));
-	},
-	decode(bytes): unknown {
-		return JSON.parse(textDecoder.decode(bytes), bigintReviver) as unknown;
-	},
-};
-
-/**
- * Returns the {@link bigintJsonCodec} cast to `Codec<T>`. Pure typing helper —
- * no runtime overhead. Use when a generic tier API requires a `Codec<T>` and
- * `T` carries `bigint` fields.
- *
- * @example
- * ```ts
- * import { memoryBackend, snapshotStorage, bigintJsonCodecFor } from "@graphrefly/pure-ts/extra";
- *
- * const tier = snapshotStorage<FactStore>(memoryBackend(), {
- *   codec: bigintJsonCodecFor<FactStore>(),
- * });
- * ```
- *
- * @category extra
- */
-export function bigintJsonCodecFor<T>(): Codec<T> {
-	return bigintJsonCodec as unknown as Codec<T>;
-}
-
-// ── Layer 2 — Tier specializations ────────────────────────────────────────
-
-/**
- * Lock 4.D (Phase 13.6.B B8) — canonical default values that every tier
- * implementation honors when its corresponding option is omitted. Single
- * source of truth so the COMPOSITION-GUIDE-GRAPH §27 defaults table doesn't
- * drift from runtime behavior.
- *
- * Per-tier sub-rules describe **deviations** from these defaults; common
- * behavior is described once here.
- *
- * - `debounceMs: 0` — sync-through flush at wave close. Set `>0` to batch
- *   writes across a debounce window.
- * - `compactEvery: undefined` — no forced flush cap (Lock 6.E). When set
- *   to a positive integer N, the tier dispatches `flush()` every Nth
- *   accepted write regardless of the debounce timer. Useful as a uniform
- *   overflow guard on debounced tiers.
- * - `filter: undefined` — save everything (snapshot / kv tiers only;
- *   append-log tiers skip filtering).
- * - `codec: jsonCodec` — built-in JSON codec; replaceable via tier opts
- *   for binary / dag-cbor / zstd combinations.
- * - `keyOf: undefined` — primitive-default key resolution per tier
- *   (snapshot uses `() => name ?? "snapshot"`; append-log uses `() => name
- *   ?? "append-log"`; kv tiers use the entry's natural key).
- *
- * Per-tier transaction model + atomicity (Lock 2.D) apply uniformly:
- * each tier owns its own transaction; cross-tier atomicity is
- * best-effort.
- */
-export const defaultTierOpts = Object.freeze({
-	debounceMs: 0,
-	compactEvery: undefined as number | undefined,
-	filter: undefined as ((value: unknown) => boolean) | undefined,
-	codec: jsonCodec,
-	keyOf: undefined as ((value: unknown) => string) | undefined,
-}) as Readonly<{
-	debounceMs: number;
-	compactEvery: number | undefined;
-	filter: ((value: unknown) => boolean) | undefined;
-	codec: Codec<unknown>;
-	keyOf: ((value: unknown) => string) | undefined;
-}>;
-
-/**
- * Common tier surface: name + cadence knobs + transaction lifecycle.
- *
- * Lifecycle hooks (`flush` / `rollback`) implement Audit 4's "one wave = one
- * transaction" model. Framework integration:
- *  - After every wave (and on `batch()` close), framework iterates attached
- *    tiers and calls `tier.flush()` if exposed.
- *  - On wave-throw (per C.2 F rollback policy), framework calls
- *    `tier.rollback()` if exposed — pending writes discarded.
- *  - Cross-tier atomicity is best-effort. Each tier is its own transaction.
- *
- * Defaults: see {@link defaultTierOpts} (Lock 4.D / 6.E).
- *
- * @category extra
- */
-export interface BaseStorageTier {
-	readonly name: string;
-	/**
-	 * Debounce window (ms). `0` = sync-through (default per
-	 * {@link defaultTierOpts}); `>0` batches across waves.
-	 */
-	readonly debounceMs?: number;
-	/**
-	 * Force flush every Nth write regardless of debounce. `undefined`
-	 * (default per {@link defaultTierOpts}) = no cap. Lock 6.E uniform
-	 * overflow guard for debounced tiers.
-	 */
-	readonly compactEvery?: number;
-	/** Commit pending; framework calls at wave-close / debounce-fire. */
-	flush?(): Promise<void>;
-	/** Discard pending; framework calls on wave-throw. */
-	rollback?(): Promise<void>;
-	/**
-	 * Lazily enumerate records under a literal byte-prefix (Phase 14.6 —
-	 * DS-14-storage Q5 lock). Frames yield in lex-ASC key order; for the
-	 * canonical WAL key format `${prefix}/${frame_seq.padStart(20)}` that
-	 * coincides with numeric `frame_seq` ASC up to `frame_seq < 10^20`.
-	 *
-	 * Backends without `list?` should throw a `StorageError` with code
-	 * `"backend-no-list-support"` on first iteration (lazy throw — caller
-	 * sees it at consumption time, not at attach).
-	 *
-	 * Optional: tiers that don't carry replay-able state (snapshot tiers
-	 * holding one record per key) can omit it.
-	 */
-	listByPrefix?<T>(prefix: string): AsyncIterable<{ key: string; value: T }>;
-	/**
-	 * Force a `mode:"full"` baseline immediately (Phase 14.6 — DS-14-storage
-	 * Q8 lock). Bypasses `compactEvery` cadence; useful at deploy boundaries,
-	 * end-of-process drains, or test fixtures. Tier owners that don't write
-	 * baselines (kv tiers, append-log tiers) can omit.
-	 */
-	compact?(): Promise<void>;
-}
-
-/**
- * Snapshot tier — writes a single record per `save(snapshot)` call.
- *
- * The tier maps the snapshot to a backend key via `keyOf(snapshot)` (default
- * `() => name ?? "snapshot"`). For `Graph.attachSnapshotStorage`, the framework
- * supplies a closure that pulls the graph name out of the record envelope.
- *
- * @category extra
- */
-export interface SnapshotStorageTier<T = unknown> extends BaseStorageTier {
-	save(snapshot: T): void | Promise<void>;
-	load?(): T | Promise<T | undefined> | undefined;
-	/** Skip-save policy — return `false` to skip persisting this snapshot. */
-	filter?: (snapshot: T) => boolean;
-	/** Extract the backend key per-snapshot; default `() => name ?? "snapshot"`. */
-	keyOf?: (snapshot: T) => string;
-}
-
-/**
- * Append-log tier — bulk-friendly entry persistence with optional partitioning.
- *
- * Entries are appended to a logical stream; `keyOf?` partitions across backend
- * keys (e.g., `(e) => `${e.type}::${e.aggregateId}`` for CQRS).
- *
- * @category extra
- */
-export interface AppendLogStorageTier<T = unknown> extends BaseStorageTier {
-	appendEntries(entries: readonly T[]): void | Promise<void>;
-	loadEntries?(opts?: {
-		cursor?: AppendCursor;
-		pageSize?: number;
-		keyFilter?: string;
-	}): AppendLoadResult<T> | Promise<AppendLoadResult<T>>;
-	/** Partition key per-entry (default `() => name ?? "append-log"`). */
-	keyOf?: (entry: T) => string;
-	/**
-	 * Persistence mode (see {@link AppendLogStorageOptions.mode}). Exposed so
-	 * delta-shipping drivers (e.g. `ReactiveLogBundle.attachStorage`) can
-	 * reject an `"overwrite"` tier — feeding per-wave deltas into an
-	 * overwrite tier silently truncates the log to the last wave.
-	 */
-	readonly mode?: "append" | "overwrite";
-}
-
-/** Opaque cursor for windowed `loadEntries` pagination. */
-export type AppendCursor = Readonly<{ position: number; tag?: string }> & {
-	readonly __brand: "AppendCursor";
-};
-
-export type AppendLoadResult<T> = {
-	entries: readonly T[];
-	cursor: AppendCursor | undefined;
-};
-
-// ── Layer 1 reference: in-memory backend ─────────────────────────────────
-
-/**
- * Creates an in-process bytes backend backed by `Map<string, Uint8Array>`.
- *
- * Useful for tests, hot tiers, and as the default backend for the convenience
- * factories in this module. All operations are synchronous.
- *
- * @returns `StorageBackend` instance backed by an in-memory `Map`.
- *
- * @example
- * ```ts
- * import { memoryBackend, snapshotStorage } from "@graphrefly/graphrefly/extra";
- *
- * const backend = memoryBackend();
- * const tier = snapshotStorage(backend, { name: "my-graph" });
- * await tier.save({ name: "my-graph", data: { count: 1 } });
- * ```
- *
- * @category extra
- */
-export function memoryBackend(): StorageBackend {
-	const data = new Map<string, Uint8Array>();
-	return {
-		name: "memory",
-		read(key) {
-			const v = data.get(key);
-			return v === undefined ? undefined : new Uint8Array(v);
-		},
-		write(key, bytes) {
-			data.set(key, new Uint8Array(bytes));
-		},
-		delete(key) {
-			data.delete(key);
-		},
-		list(prefix) {
-			const keys = [...data.keys()];
-			return prefix ? keys.filter((k) => k.startsWith(prefix)).sort() : keys.sort();
-		},
-	};
-}
-
-// ── Layer 2 reference: snapshot + append-log factories ───────────────────
-
-export type SnapshotStorageOptions<T> = {
-	name?: string;
-	codec?: Codec<T>;
-	debounceMs?: number;
-	compactEvery?: number;
-	filter?: (snapshot: T) => boolean;
-	keyOf?: (snapshot: T) => string;
-};
-
-/**
- * Wraps a `StorageBackend` as a typed snapshot tier.
- *
- * Buffer model: `save(snapshot)` accumulates one pending snapshot in memory.
- * `flush()` encodes via codec and writes to the backend under
- * `keyOf(snapshot)` (default `name ?? "snapshot"`). `rollback()` discards
- * the pending write.
- *
- * @param backend - Bytes-level backend to persist snapshots into.
- * @param opts - Optional name, codec, debounce window, compaction interval, pre-save filter, and key extractor.
- * @returns `SnapshotStorageTier<T>` that buffers one pending snapshot and flushes on wave-close.
- *
- * @example
- * ```ts
- * import { memoryBackend, snapshotStorage } from "@graphrefly/graphrefly/extra";
- *
- * const backend = memoryBackend();
- * const tier = snapshotStorage<{ count: number }>(backend, { name: "counter" });
- * await tier.save({ count: 42 });
- * // Load back:
- * const loaded = await tier.load?.();
- * ```
- *
- * @category extra
- */
-export function snapshotStorage<T>(
-	backend: StorageBackend,
-	opts: SnapshotStorageOptions<T> = {},
-): SnapshotStorageTier<T> {
-	const codec = (opts.codec ?? jsonCodec) as Codec<T>;
-	const name = opts.name ?? backend.name ?? "snapshot";
-	// Default keyOf: prefer snapshot.name (GraphCheckpointRecord carries name),
-	// then opts.name, then backend.name, then "snapshot". This lets Graph
-	// per-graph keying work automatically when tiers are created with
-	// snapshotStorage(backend, { keyOf: r => r.name }) or when the record has a
-	// `name` field (as GraphCheckpointRecord does).
-	const keyOf =
-		opts.keyOf ??
-		((v: T) => (v as { name?: string }).name ?? opts.name ?? backend.name ?? "snapshot");
-	let pending: { snapshot: T } | undefined;
-	let writeCount = 0;
-	const compactEvery = opts.compactEvery;
-	let _lastSavedKey: string | undefined;
-
-	const tier: SnapshotStorageTier<T> = {
-		name,
-		debounceMs: opts.debounceMs,
-		compactEvery,
-		filter: opts.filter,
-		keyOf,
-		save(snapshot) {
-			if (opts.filter && !opts.filter(snapshot)) return;
-			pending = { snapshot };
-			// /qa F2 (D138-followup, 2026-05-10): boundary-crossing trigger
-			// matches the Rust-side fix. Pre-fix used strict modulo
-			// (`writeCount % compactEvery === 0`); a batch of N saves jumping
-			// the boundary by multiple multiples would still trigger only on
-			// exact divisibility. Snapshot does single-save so this is
-			// semantically equivalent for snapshot, but kept symmetric with
-			// appendLog and kv where batch increments matter.
-			const prev = writeCount;
-			writeCount += 1;
-			if (
-				compactEvery !== undefined &&
-				Math.floor(prev / compactEvery) !== Math.floor(writeCount / compactEvery)
-			) {
-				return flushNow();
-			}
-			if (!opts.debounceMs) {
-				return flushNow();
-			}
-			return undefined;
-		},
-		load() {
-			const key = _lastSavedKey ?? name;
-			const result = backend.read(key);
-			if (result === undefined) return undefined;
-			if (result instanceof Uint8Array) {
-				return result.length === 0 ? undefined : codec.decode(result);
-			}
-			return Promise.resolve(result).then((bytes) =>
-				bytes === undefined || bytes.length === 0 ? undefined : codec.decode(bytes),
-			);
-		},
-		async flush() {
-			await flushNow();
-		},
-		async rollback() {
-			pending = undefined;
-		},
-	};
-
-	function flushNow(): void | Promise<void> {
-		const slot = pending;
-		if (!slot) return;
-		pending = undefined;
-		const key = keyOf(slot.snapshot);
-		const bytes = codec.encode(slot.snapshot);
-		const result = backend.write(key, bytes);
-		if (result instanceof Promise) {
-			return result.then(() => {
-				_lastSavedKey = key;
-			});
-		}
-		_lastSavedKey = key;
-		return undefined;
-	}
-
-	return tier;
-}
-
-export type AppendLogStorageOptions<T> = {
-	name?: string;
-	codec?: Codec<readonly T[]>;
-	keyOf?: (entry: T) => string;
-	debounceMs?: number;
-	compactEvery?: number;
-	/**
-	 * Per-key persistence semantics. Default `"append"`.
-	 *
-	 * - `"append"` — accumulate: each flush read-merges the backend's existing
-	 *   entries for the key and writes `[...prior, ...pending]`. The key grows
-	 *   monotonically across flushes; a *fresh* tier over an existing key
-	 *   continues the accumulation. This is a true logical append log.
-	 * - `"overwrite"` — snapshot: each flush writes only that flush's buffered
-	 *   entries, replacing the key (no read-merge). Use when the upstream
-	 *   already supplies the full set each wave and you don't want unbounded
-	 *   growth.
-	 */
-	mode?: "append" | "overwrite";
-};
-
-/**
- * Wraps a `StorageBackend` as a typed append-log tier.
- *
- * Buffer model: `appendEntries(entries)` accumulates per-key buckets in
- * memory. `flush()` encodes each bucket as a JSON array via codec and writes
- * under that bucket key. `rollback()` discards pending appends.
- *
- * Storage shape & semantics: each backend key holds a JSON array of entries
- * for that partition. This is a true **logical append log** — `mode:"append"`
- * (default) read-merges the key's existing array and persists
- * `[...prior, ...pending]`, so the key accumulates monotonically and a
- * *fresh* tier over an existing key continues the accumulation (no entries
- * lost). The *physical* write rewrites the whole per-key array each flush
- * (not a byte-level backend append); that is an implementation detail, not a
- * semantic limitation — callers do **not** need to layer their own tier for
- * append semantics. Set `mode:"overwrite"` for snapshot semantics (each flush
- * replaces the key with only that flush's entries, no read-merge).
- *
- * @param backend - Bytes-level backend to persist log entries into.
- * @param opts - Optional name, codec, per-entry key extractor, debounce window, and compaction interval.
- * @returns `AppendLogStorageTier<T>` that buffers pending entries and flushes per-key buckets on wave-close.
- *
- * @example
- * ```ts
- * import { memoryBackend, appendLogStorage } from "@graphrefly/graphrefly/extra";
- *
- * const backend = memoryBackend();
- * const tier = appendLogStorage<{ type: string; payload: unknown }>(backend, { name: "events" });
- * await tier.appendEntries([{ type: "created", payload: { id: 1 } }]);
- * const result = await tier.loadEntries?.();
- * ```
- *
- * @category extra
- */
-export function appendLogStorage<T>(
-	backend: StorageBackend,
-	opts: AppendLogStorageOptions<T> = {},
-): AppendLogStorageTier<T> {
-	const codec = (opts.codec ?? jsonCodec) as Codec<readonly T[]>;
-	const name = opts.name ?? backend.name ?? "append-log";
-	const keyOf = opts.keyOf ?? ((_e: T) => name);
-	const compactEvery = opts.compactEvery;
-	const overwrite = opts.mode === "overwrite";
-	let pending: Map<string, T[]> = new Map();
-	let appendCount = 0;
-	// C3: serialize concurrent flushes against a per-tier promise chain.
-	// Without this, two flushes in flight against an async backend can both
-	// read the same key before either write completes — second write loses
-	// the first's contribution. Sync backends never wait, so the chain is
-	// essentially a no-op for them.
-	let flushChain: Promise<void> | undefined;
-	// Strong-rollback generation token (QA): `rollback()` bumps this; a
-	// `doFlush` whose buckets were captured under an older epoch is skipped at
-	// entry. Aborts in-flight chained writes scheduled BEFORE the rollback;
-	// writes scheduled after get the new epoch and proceed. Best-effort: a
-	// `backend.write` already past the entry check cannot be un-sent.
-	let rollbackEpoch = 0;
-
-	const tier: AppendLogStorageTier<T> = {
-		name,
-		debounceMs: opts.debounceMs,
-		compactEvery,
-		mode: overwrite ? "overwrite" : "append",
-		keyOf,
-		appendEntries(entries) {
-			if (entries.length === 0) return;
-			for (const entry of entries) {
-				const k = keyOf(entry);
-				let bucket = pending.get(k);
-				if (!bucket) {
-					bucket = [];
-					pending.set(k, bucket);
-				}
-				bucket.push(entry);
-			}
-			// /qa F2 (D138-followup, 2026-05-10): boundary-crossing trigger
-			// matches the Rust-side fix. Pre-fix `appendCount % compactEvery
-			// === 0` would miss the trigger when a batch jumped multiple
-			// compactEvery boundaries — e.g. compactEvery=3 + batch of 5
-			// bumps appendCount 0→5; `5 % 3 !== 0` so no flush fired even
-			// though we crossed the boundary at 3.
-			const prev = appendCount;
-			appendCount += entries.length;
-			if (
-				compactEvery !== undefined &&
-				Math.floor(prev / compactEvery) !== Math.floor(appendCount / compactEvery)
-			) {
-				return flushNow();
-			}
-			if (!opts.debounceMs) {
-				return flushNow();
-			}
-			return undefined;
-		},
-		async loadEntries(loadOpts) {
-			const filter = loadOpts?.keyFilter;
-			const keys =
-				backend.list === undefined
-					? filter !== undefined
-						? [filter]
-						: [name]
-					: await Promise.resolve(backend.list(filter));
-			// Windowed pagination over the flattened entry stream. `position`
-			// is an absolute offset into the concatenation of every key's
-			// decoded entries, in `backend.list()` order.
-			//
-			// CONTRACT: paginated `loadEntries` is forward-only over a
-			// **stable, append-only** log — the absolute offset is meaningful
-			// only if `backend.list()` returns a stable key order across the
-			// paged calls AND the log is not compacted/reordered between
-			// pages. All shipped backends sort their keys (`memoryBackend`,
-			// `fileKv`, `sqliteKv`, `indexedDbKv`), so the in-tree path is
-			// safe; a custom `BackendStore` whose `list()` is unstable, OR
-			// compaction between page calls, breaks the offset (gaps/dups).
-			// (Cross-track-ledger §2 carries the same obligation for the
-			// native `@graphrefly/native` mirror.)
-			//
-			// - `pageSize` undefined/≤0/non-integer → whole-log path: return
-			//   the tail from `cursor.position` (default 0) + `cursor:
-			//   undefined`. A bare `loadEntries()` (no opts) is byte-for-byte
-			//   the prior behaviour. `loadEntries({ cursor })` without a
-			//   `pageSize` now honors `cursor.position` (forward-only tail) —
-			//   pre-change `cursor` was never returned without `pageSize`, so
-			//   no prior caller could observe the old cursor-ignored shape.
-			// - `pageSize` a positive integer → return `[start, start+pageSize)`
-			//   and a forward-only cursor; `cursor: undefined` signals "no
-			//   more entries" so callers loop until done.
-			//
-			// Decoding short-circuits one entry past the requested window
-			// (`want = start + pageSize + 1` lookahead) so a *partitioned*
-			// multi-key log does not decode keys beyond the window. A
-			// single-key log still decodes its one array blob in full —
-			// inherent to the per-key codec-blob model; pagination here bounds
-			// the *consumer's* per-page working set, not the tier's per-key
-			// decode. (Backend-level windowing would need a streaming codec /
-			// per-entry framing — tracked separately, not in scope.)
-			const start = loadOpts?.cursor?.position ?? 0;
-			const pageSize = loadOpts?.pageSize;
-			// Only a positive integer pages; fractional/`Infinity`/`NaN`/≤0
-			// degrade to the whole-tail path for a predictable contract
-			// (avoids `slice` silently truncating a float window).
-			const paged =
-				pageSize !== undefined && Number.isInteger(pageSize) && (pageSize as number) > 0;
-			const want = paged ? start + (pageSize as number) + 1 : undefined;
-			const all: T[] = [];
-			for (const k of keys) {
-				if (want !== undefined && all.length >= want) break;
-				const result = await Promise.resolve(backend.read(k));
-				if (result === undefined || result.length === 0) continue;
-				const entries = codec.decode(result) as readonly T[];
-				if (Array.isArray(entries)) all.push(...entries);
-			}
-			if (!paged) {
-				return {
-					entries: start > 0 ? all.slice(start) : all,
-					cursor: undefined,
-				};
-			}
-			const size = pageSize as number;
-			const page = all.slice(start, start + size);
-			const nextPos = start + page.length;
-			const hasMore = all.length > start + size;
-			return {
-				entries: page,
-				cursor: hasMore
-					? ({ position: nextPos, __brand: "AppendCursor" } as AppendCursor)
-					: undefined,
-			};
-		},
-		async flush() {
-			await flushNow();
-		},
-		async rollback() {
-			rollbackEpoch++; // invalidate any in-flight doFlush scheduled pre-rollback
-			pending = new Map();
-		},
-	};
-
-	function flushNow(): void | Promise<void> {
-		// Nothing newly buffered, but prior appendEntries() calls may have
-		// scheduled microtask-chained doFlush()es still in flight (no-debounce
-		// tiers schedule one per append wave; attachStorage fire-and-forgets
-		// the returned chain by design). flush() must await them — callers
-		// expect durability on resolve — so return the outstanding chain tail
-		// rather than undefined.
-		if (pending.size === 0) return flushChain;
-		const buckets = pending;
-		pending = new Map();
-		// Chain this flush after any prior in-flight flush so reads/writes
-		// don't interleave. Sync backends short-circuit (the chained `.then`
-		// resolves immediately if `doFlush` returned undefined).
-		// Capture the rollback epoch at schedule time; doFlush skips if a
-		// rollback() bumped it before this chained task actually runs.
-		const scheduledEpoch = rollbackEpoch;
-		const next: Promise<void> = (flushChain ?? Promise.resolve()).then(
-			() => {
-				const w = doFlush(buckets, scheduledEpoch);
-				return w instanceof Promise ? w : Promise.resolve();
-			},
-			// Previous flush rejected — already surfaced; don't block this one.
-			() => {
-				const w = doFlush(buckets, scheduledEpoch);
-				return w instanceof Promise ? w : Promise.resolve();
-			},
-		);
-		// Compare against the assigned `.finally` promise (NOT `next`) — the
-		// guard must reference the value actually stored in `flushChain`, so an
-		// idle chain clears to `undefined` (bounded; the `flush()` empty-pending
-		// path returns `undefined` when fully drained instead of a stale tail).
-		const chained: Promise<void> = next.finally(() => {
-			if (flushChain === chained) flushChain = undefined;
-		});
-		flushChain = chained;
-		// Sync fast-path: if no async work was queued by `doFlush`, return
-		// undefined so callers don't `await` an unnecessary microtask.
-		// We can't probe doFlush's sync-ness without running it; the awaitable
-		// chain is correct either way.
-		return flushChain;
-	}
-
-	function doFlush(buckets: Map<string, T[]>, scheduledEpoch: number): void | Promise<void> {
-		// Strong rollback: a rollback() after this task was scheduled bumped
-		// the epoch — discard these buckets instead of persisting rolled-back
-		// entries (the chain still settles so flush() resolves correctly).
-		if (scheduledEpoch !== rollbackEpoch) return;
-		const promises: Promise<void>[] = [];
-		for (const [key, bucket] of buckets) {
-			// Overwrite mode: snapshot — write only this flush's entries, no
-			// read-merge (skips the backend read entirely).
-			if (overwrite) {
-				const w = backend.write(key, codec.encode(bucket));
-				if (w instanceof Promise) promises.push(w);
-				continue;
-			}
-			// Append mode: read existing, accumulate, write back.
-			const prev = backend.read(key);
-			const merge = (existing: Uint8Array | undefined): void | Promise<void> => {
-				const prior =
-					existing === undefined || existing.length === 0
-						? []
-						: ((codec.decode(existing) as readonly T[]) ?? []);
-				const merged = [...prior, ...bucket];
-				const next = codec.encode(merged);
-				return backend.write(key, next);
-			};
-			if (prev instanceof Promise) {
-				promises.push(
-					prev.then(async (existing) => {
-						const w = merge(existing);
-						if (w instanceof Promise) await w;
-					}),
-				);
-			} else {
-				const w = merge(prev);
-				if (w instanceof Promise) promises.push(w);
-			}
-		}
-		if (promises.length > 0) return Promise.all(promises).then(() => undefined);
-		return undefined;
-	}
-
-	return tier;
-}
-
-// ── Layer 2 — KvStorageTier ───────────────────────────────────────────────
-
-/**
- * Key-value tier — typed records under arbitrary string keys with codec
- * serialization at the storage-tier boundary. Use for content-addressed
- * caches (replay), multi-record archives (snapshot index, AI memory), and
- * fixture stores. Snapshot tier is "one record"; append-log is "sequential
- * entries"; kv is "many records, addressable by key".
- *
- * @category extra
- */
-export interface KvStorageTier<T = unknown> extends BaseStorageTier {
-	load(key: string): T | undefined | Promise<T | undefined>;
-	save(key: string, value: T): void | Promise<void>;
-	delete?(key: string): void | Promise<void>;
-	list?(prefix?: string): readonly string[] | Promise<readonly string[]>;
-	/** Pre-save filter — return `false` to skip persisting this record. */
-	filter?: (key: string, value: T) => boolean;
-}
-
-export type KvStorageOptions<T> = {
-	name?: string;
-	codec?: Codec<T>;
-	debounceMs?: number;
-	compactEvery?: number;
-	filter?: (key: string, value: T) => boolean;
-};
-
-/**
- * Wraps a `StorageBackend` as a typed key-value tier.
- *
- * Buffer model: `save(k, v)` encodes via codec and writes to the backend
- * unless debounced. Pending writes are committed on `flush()` and discarded
- * on `rollback()` — the wave-as-transaction model.
- *
- * @param backend - Bytes-level backend to persist records into.
- * @param opts - Optional name, codec, debounce window, compaction interval, and pre-save filter.
- * @returns `KvStorageTier<T>` that supports `save`, `load`, `delete`, and `list` operations.
- *
- * @example
- * ```ts
- * import { memoryBackend, kvStorage } from "@graphrefly/graphrefly/extra";
- *
- * const backend = memoryBackend();
- * const kv = kvStorage<{ score: number }>(backend, { name: "scores" });
- * await kv.save("player1", { score: 100 });
- * const val = await kv.load("player1");
- * ```
- *
- * @category extra
- */
-export function kvStorage<T>(
-	backend: StorageBackend,
-	opts: KvStorageOptions<T> = {},
-): KvStorageTier<T> {
-	const codec = (opts.codec ?? jsonCodec) as Codec<T>;
-	const name = opts.name ?? backend.name ?? "kv";
-	const compactEvery = opts.compactEvery;
-	let pending: Map<string, T> = new Map();
-	let writeCount = 0;
-
-	const tier: KvStorageTier<T> = {
-		name,
-		debounceMs: opts.debounceMs,
-		compactEvery,
-		filter: opts.filter,
-
-		save(key: string, value: T): void | Promise<void> {
-			if (opts.filter && !opts.filter(key, value)) return;
-			pending.set(key, value);
-			// /qa F2 (D138-followup, 2026-05-10): boundary-crossing trigger
-			// matches the Rust-side fix. Single-save is semantically
-			// equivalent to the prior modulo check (count goes prev → prev+1,
-			// boundary crosses only at exact multiples), but pinned this way
-			// so future batch-save APIs inherit the right semantic.
-			const prev = writeCount;
-			writeCount += 1;
-			if (
-				compactEvery !== undefined &&
-				Math.floor(prev / compactEvery) !== Math.floor(writeCount / compactEvery)
-			) {
-				return flushNow();
-			}
-			if (!opts.debounceMs) {
-				return flushNow();
-			}
-			return undefined;
-		},
-
-		load(key: string): T | undefined | Promise<T | undefined> {
-			const result = backend.read(key);
-			if (result === undefined) return undefined;
-			if (result instanceof Uint8Array) {
-				return result.length === 0 ? undefined : codec.decode(result);
-			}
-			return Promise.resolve(result).then((bytes) =>
-				bytes === undefined || bytes.length === 0 ? undefined : codec.decode(bytes),
-			);
-		},
-
-		delete(key: string): void | Promise<void> {
-			pending.delete(key);
-			if (!backend.delete) return;
-			return backend.delete(key);
-		},
-
-		list(prefix?: string): readonly string[] | Promise<readonly string[]> {
-			if (!backend.list) return [];
-			return backend.list(prefix);
-		},
-
-		async *listByPrefix<U>(prefix: string): AsyncIterable<{ key: string; value: U }> {
-			// Lazy implementation per Phase 14.6 / DS-14-storage Q5: pull keys
-			// in the backend's natural order, then read+decode one at a time.
-			// Backends without `list?` produce no entries and surface the
-			// missing-capability via a thrown `StorageError` so callers don't
-			// silently iterate empty.
-			if (!backend.list) {
-				throw new StorageError(
-					"backend-no-list-support",
-					`storage tier "${name}" backend "${backend.name}" does not implement list(); WAL replay requires it`,
-					{ tier: name, backend: backend.name },
-				);
-			}
-			const keys = await Promise.resolve(backend.list(prefix));
-			// `list?` may return non-prefixed entries from older backends;
-			// re-filter so the lazy contract is exact (lex-ASC over prefix
-			// matches by literal byte-equality).
-			const ordered = [...keys].filter((k) => k.startsWith(prefix)).sort();
-			for (const key of ordered) {
-				const raw = await Promise.resolve(backend.read(key));
-				if (raw === undefined || raw.length === 0) continue;
-				const value = codec.decode(raw) as unknown as U;
-				yield { key, value };
-			}
-		},
-
-		async flush() {
-			await flushNow();
-		},
-
-		async rollback() {
-			pending = new Map();
-		},
-	};
-
-	function flushNow(): void | Promise<void> {
-		if (pending.size === 0) return;
-		const entries = pending;
-		pending = new Map();
-		const promises: Promise<void>[] = [];
-		for (const [key, value] of entries) {
-			const bytes = codec.encode(value);
-			const result = backend.write(key, bytes);
-			if (result instanceof Promise) promises.push(result);
-		}
-		if (promises.length > 0) return Promise.all(promises).then(() => undefined);
-		return undefined;
-	}
-
-	return tier;
-}
-
-// ── Convenience factories — memory ────────────────────────────────────────
-
-/**
- * Creates an in-memory snapshot tier backed by a fresh `memoryBackend`.
- *
- * Convenience wrapper for `snapshotStorage(memoryBackend(), opts)`. All writes
- * are synchronous and in-process — useful for tests and hot-path caching.
- *
- * @param opts - Optional snapshot storage options (name, codec, filter, keyOf, debounce, compactEvery).
- * @returns `SnapshotStorageTier<T>` backed by an in-memory store.
- *
- * @example
- * ```ts
- * import { memorySnapshot } from "@graphrefly/graphrefly/extra";
- *
- * const tier = memorySnapshot<{ count: number }>({ name: "counter" });
- * await tier.save({ count: 1 });
- * ```
- *
- * @category extra
- */
-export function memorySnapshot<T>(
-	opts?: Omit<SnapshotStorageOptions<T>, "name"> & { name?: string },
-): SnapshotStorageTier<T> {
-	return snapshotStorage<T>(memoryBackend(), opts);
-}
-
-/**
- * Creates an in-memory append-log tier backed by a fresh `memoryBackend`.
- *
- * Convenience wrapper for `appendLogStorage(memoryBackend(), opts)`. All writes
- * are synchronous and in-process — useful for tests and hot-path event buffering.
- *
- * @param opts - Optional append-log storage options (name, codec, keyOf, debounce, compactEvery).
- * @returns `AppendLogStorageTier<T>` backed by an in-memory store.
- *
- * @example
- * ```ts
- * import { memoryAppendLog } from "@graphrefly/graphrefly/extra";
- *
- * const tier = memoryAppendLog<{ type: string }>({ name: "events" });
- * await tier.appendEntries([{ type: "init" }]);
- * ```
- *
- * @category extra
- */
-export function memoryAppendLog<T>(
-	opts?: Omit<AppendLogStorageOptions<T>, "name"> & { name?: string },
-): AppendLogStorageTier<T> {
-	return appendLogStorage<T>(memoryBackend(), opts);
-}
-
-/**
- * Creates an in-memory key-value tier backed by a fresh `memoryBackend`.
- *
- * Convenience wrapper for `kvStorage(memoryBackend(), opts)`. All writes are
- * synchronous and in-process — useful for tests and ephemeral record caches.
- *
- * @param opts - Optional kv storage options (name, codec, filter, debounce, compactEvery).
- * @returns `KvStorageTier<T>` backed by an in-memory store.
- *
- * @example
- * ```ts
- * import { memoryKv } from "@graphrefly/graphrefly/extra";
- *
- * const kv = memoryKv<{ value: number }>();
- * await kv.save("key1", { value: 42 });
- * const loaded = await kv.load("key1");
- * ```
- *
- * @category extra
- */
-export function memoryKv<T>(
-	opts?: Omit<KvStorageOptions<T>, "name"> & { name?: string },
-): KvStorageTier<T> {
-	return kvStorage<T>(memoryBackend(), opts);
-}
-
-/**
- * Creates a kv tier backed by a caller-owned plain object (`Record<string, Uint8Array>`).
- *
- * Useful for embedding storage inside a parent state shape or for tests that
- * need direct access to the raw bytes. The dict stores raw encoded bytes as
- * `Uint8Array`. Use `opts.name` to control the tier's diagnostic name
- * (defaults to `"dict-kv"`).
- *
- * @param storage - Caller-owned `Record<string, Uint8Array>` to use as the backing store.
- * @param opts - Optional kv storage options (name, codec, filter, debounce, compactEvery).
- * @returns `KvStorageTier<T>` backed by the provided dict object.
- *
- * @example
- * ```ts
- * import { dictKv } from "@graphrefly/graphrefly/extra";
- *
- * const store: Record<string, Uint8Array> = {};
- * const tier = dictKv<{ score: number }>(store);
- * await tier.save("player1", { score: 100 });
- * ```
- *
- * @category extra
- */
-export function dictKv<T>(
-	storage: Record<string, Uint8Array>,
-	opts?: Omit<KvStorageOptions<T>, "name"> & { name?: string },
-): KvStorageTier<T> {
-	const backend: StorageBackend = {
-		name: opts?.name ?? "dict-kv",
-		read(key) {
-			return storage[key];
-		},
-		write(key, bytes) {
-			storage[key] = new Uint8Array(bytes);
-		},
-		delete(key) {
-			delete storage[key];
-		},
-		list(prefix) {
-			const keys = Object.keys(storage).sort();
-			return prefix ? keys.filter((k) => k.startsWith(prefix)) : keys;
-		},
-	};
-	return kvStorage<T>(backend, opts);
-}
-
-/**
- * Creates a snapshot tier backed by a caller-owned plain object (`Record<string, Uint8Array>`).
- *
- * Useful for embedding checkpoints inside a parent state shape or for tests
- * that need direct access to the raw bytes. The dict stores raw JSON bytes as
- * `Uint8Array`. Use `opts.name` to control the storage key (defaults to
- * `"snapshot"`).
- *
- * @param storage - Caller-owned `Record<string, Uint8Array>` to use as the backing store.
- * @param opts - Optional snapshot storage options (name, codec, filter, keyOf, debounce, compactEvery).
- * @returns `SnapshotStorageTier<T>` backed by the provided dict object.
- *
- * @example
- * ```ts
- * import { dictKv, dictSnapshot } from "@graphrefly/graphrefly/extra";
- *
- * const store: Record<string, Uint8Array> = {};
- * // Phase 14.6 paired-tier shape — pair with a kv tier for WAL replay,
- * // or omit `wal` for baseline-only persistence.
- * graph.attachSnapshotStorage([
- *   { snapshot: dictSnapshot(store, { name: graph.name }), wal: dictKv(store) },
- * ]);
- * ```
- *
- * @category extra
- */
-export function dictSnapshot<T>(
-	storage: Record<string, Uint8Array>,
-	opts?: Omit<SnapshotStorageOptions<T>, "name"> & { name?: string },
-): SnapshotStorageTier<T> {
-	const backend: StorageBackend = {
-		name: "dict",
-		read(key) {
-			return storage[key];
-		},
-		write(key, bytes) {
-			storage[key] = new Uint8Array(bytes);
-		},
-		delete(key) {
-			delete storage[key];
-		},
-		list(prefix) {
-			const keys = Object.keys(storage).sort();
-			return prefix ? keys.filter((k) => k.startsWith(prefix)) : keys;
-		},
-	};
-	return snapshotStorage<T>(backend, opts);
-}
diff --git a/packages/pure-ts/src/extra/storage/wal.ts b/packages/pure-ts/src/extra/storage/wal.ts
deleted file mode 100644
index 86d7bb4c..00000000
--- a/packages/pure-ts/src/extra/storage/wal.ts
+++ /dev/null
@@ -1,354 +0,0 @@
-/**
- * WAL substrate (Phase 14.6 — DS-14-storage locked 2026-05-08).
- *
- * `attachSnapshotStorage` writes a stream of `WALFrame<T>` records between
- * `mode:"full"` baselines so {@link Graph.restoreSnapshot} can rebuild
- * intermediate state via lifecycle-aware replay (DS-14 Q9). Each frame
- * decomposes a single graph diff into one DS-14 `BaseChange<T>` envelope per
- * structural-or-value change, scoped by `lifecycle` (`"spec" | "data" |
- * "ownership"`) so callers can scope rewinds.
- *
- * The full session lock lives at
- * `archive/docs/SESSION-DS-14-storage-wal-replay.md` (Q1–Q9).
- *
- * **Q1 deviation — checksum function:** the locked decision specified BLAKE3
- * 32-byte. We ship SHA-256 32-byte instead so the package stays
- * zero-dependency (no BLAKE3 in WebCrypto; pulling `@noble/hashes` for the
- * single use case isn't worth the dep). BLAKE3 returns when the
- * post-1.0 DagCbor IPLD content-addressing codec lands and there's a real
- * ecosystem reason to match it byte-for-byte. M4 Rust impl matches with the
- * `sha2` crate. See {@link walFrameChecksum} for the canonical computation.
- *
- * @module
- */
-
-import { stableJsonString } from "./core.js";
-import type { BaseStorageTier } from "./tiers.js";
-
-// ── WAL frame envelope ──────────────────────────────────────────────────────
-
-/**
- * On-disk WAL frame (DS-14-storage Q1 lock — checksum substituted SHA-256
- * per the deviation noted in the module header).
- *
- * Two seq fields and two timestamp fields are intentional:
- *
- * - `frame_seq` ≠ `change.seq` — `change.seq` is the bundle's `mutations`
- *   cursor (DS-14 T1); `frame_seq` is the WAL tier's own cursor (this
- *   record's position in the WAL stream). Replay uses `frame_seq` for
- *   ordering; `change.seq` is only relevant for bundle-level cursor
- *   restoration.
- * - `frame_t_ns` ≠ `change.t_ns` — `change.t_ns` is the wall clock at
- *   mutation entry; `frame_t_ns` is the wall clock at WAL-write time. Under
- *   debounced tiers they differ by `debounceMs`. Forensics + drift detection
- *   want both.
- *
- * The bridge wire format (DS-14 PART 5 worker bridge) is the schema-narrowed
- * subset `{ t:"c", lifecycle, path, change }` — `WALFrame<T>` is the
- * persistence-tier superset (L3 lock).
- *
- * @category extra
- */
-export interface WALFrame<T = unknown> {
-	/** Bridge tag — discriminator shared with DS-14 worker-bridge wire format. */
-	readonly t: "c";
-	/** Lifecycle scope (DS-14 PART 4). Determines replay phase ordering. */
-	readonly lifecycle: "spec" | "data" | "ownership";
-	/** Target node / bundle path (per-graph qualified path). */
-	readonly path: string;
-	/** DS-14 universal `BaseChange<T>` envelope — structure-tagged delta. */
-	readonly change: WALBaseChange<T>;
-	/** WAL-tier monotonic cursor (uniquely owned by the WAL tier writer). */
-	readonly frame_seq: number;
-	/** Wall clock at WAL-write time (`wallClockNs()`). */
-	readonly frame_t_ns: number;
-	/**
-	 * SHA-256 over the canonical-JSON encoding of the frame body
-	 * (everything except `checksum` itself), encoded as a 64-char lowercase
-	 * hex string for codec-friendliness. Equality is exact-string match
-	 * across impls because the canonical JSON is byte-identical.
-	 *
-	 * Q1 deviation: BLAKE3 in the locked design; SHA-256 in this impl. See
-	 * module header. Hex (vs raw bytes) is a TS-side encoding choice — the
-	 * `jsonCodec` default would corrupt `Uint8Array` to a numeric-key dict
-	 * on roundtrip; M4 Rust impl matches via `hex` crate output.
-	 */
-	readonly checksum: string;
-	/**
-	 * Codec version tag (canonical spec §"format_version extends from
-	 * `GraphCheckpointRecord` to `WALFrame` per-tier"). All current frames
-	 * are version `1` (JSON codec); codec migration is a baseline rewrite,
-	 * not in-place upgrade.
-	 *
-	 * **Excluded from the checksum body** ({@link walFrameChecksum} hashes
-	 * `{t, lifecycle, path, change, frame_seq, frame_t_ns}` only) — the tag
-	 * describes the encoding, not the integrity-protected payload, so a
-	 * codec bump never invalidates the stored checksum. Parity-locked with
-	 * the Rust impl's `#[serde(default = "default_format_version")] u32`
-	 * (`graphrefly-storage/src/wal.rs`), whose `ChecksumBody` likewise omits
-	 * it.
-	 */
-	readonly format_version: number;
-}
-
-/**
- * Current WAL codec version. Bump only on a breaking on-disk encoding
- * change; a bump implies a baseline rewrite (no in-place frame migration).
- *
- * @category extra
- */
-export const WAL_FORMAT_VERSION = 1;
-
-/**
- * Minimal `BaseChange<T>` shape this module references. The full canonical
- * type lives at [extra/data-structures/change.ts](../data-structures/change.ts);
- * this re-statement avoids the cross-folder import cycle for the typed-only
- * frame envelope.
- *
- * @internal
- */
-export interface WALBaseChange<T> {
-	readonly structure: string;
-	readonly version: number | string;
-	readonly t_ns: number;
-	readonly seq?: number;
-	readonly lifecycle: "spec" | "data" | "ownership";
-	readonly change: T;
-}
-
-// ── Key format ──────────────────────────────────────────────────────────────
-
-/**
- * Default WAL prefix relative to a `graph.name`. Frames land at
- * `${graph.name}/${WAL_KEY_SEGMENT}/${frame_seq.padStart(20)}`.
- *
- * @category extra
- */
-export const WAL_KEY_SEGMENT = "wal";
-
-/**
- * Pad width for `frame_seq` in WAL keys. 20 digits keeps lex-ASC = numeric
- * ASC up to `frame_seq < 10^20` (safe — `frame_seq` is JS `number`, capped
- * at `Number.MAX_SAFE_INTEGER` < 10^16).
- */
-export const WAL_FRAME_SEQ_PAD = 20;
-
-/**
- * Build the canonical WAL frame key. `prefix` is the WAL-prefix portion
- * (e.g. `"my-graph/wal"` for a graph named `my-graph`). `frame_seq` is the
- * per-frame WAL cursor.
- *
- * Lex-ASC string sort = numeric ASC frame_seq sort by zero-padding.
- *
- * @category extra
- */
-export function walFrameKey(prefix: string, frame_seq: number): string {
-	if (!Number.isInteger(frame_seq) || frame_seq < 0) {
-		throw new RangeError(`walFrameKey: frame_seq must be a non-negative integer, got ${frame_seq}`);
-	}
-	return `${prefix}/${frame_seq.toString().padStart(WAL_FRAME_SEQ_PAD, "0")}`;
-}
-
-/** Default WAL key prefix for a graph by `graph.name`. */
-export function graphWalPrefix(graphName: string): string {
-	return `${graphName}/${WAL_KEY_SEGMENT}`;
-}
-
-// ── Checksum ────────────────────────────────────────────────────────────────
-
-/**
- * Canonical-JSON encoding of the frame body sans `checksum`. Used by the
- * checksum step at write time and by the verify step at replay. Stability
- * is critical — both impls must agree byte-for-byte.
- */
-function canonicalFrameBody(frame: Omit<WALFrame, "checksum">): string {
-	return stableJsonString({
-		t: frame.t,
-		lifecycle: frame.lifecycle,
-		path: frame.path,
-		change: frame.change,
-		frame_seq: frame.frame_seq,
-		frame_t_ns: frame.frame_t_ns,
-	});
-}
-
-const HEX_TABLE: string[] = (() => {
-	const out: string[] = new Array(256);
-	for (let i = 0; i < 256; i++) out[i] = i.toString(16).padStart(2, "0");
-	return out;
-})();
-
-function bytesToHex(bytes: Uint8Array): string {
-	let hex = "";
-	for (let i = 0; i < bytes.length; i++) hex += HEX_TABLE[bytes[i] as number];
-	return hex;
-}
-
-/**
- * Compute the SHA-256 checksum over a frame body and return it as a
- * 64-char lowercase hex string. Async because `crypto.subtle.digest` is
- * async on every supported runtime (Node 18+, browsers, Cloudflare Workers,
- * Deno). Sync alternatives would require `node:crypto` (Node-only) or a
- * pure-JS shim.
- *
- * The frame's `checksum` field is set to the result of this call before the
- * frame is written to the WAL tier.
- *
- * @category extra
- */
-export async function walFrameChecksum(frame: Omit<WALFrame, "checksum">): Promise<string> {
-	const bytes = new TextEncoder().encode(canonicalFrameBody(frame));
-	const buf = await globalThis.crypto.subtle.digest("SHA-256", bytes);
-	return bytesToHex(new Uint8Array(buf));
-}
-
-/**
- * Verify a frame's checksum. Returns `true` on match. Used by the replay
- * path; mismatch triggers Q3 torn-write handling.
- *
- * @category extra
- */
-export async function verifyWalFrameChecksum(frame: WALFrame): Promise<boolean> {
-	const expected = await walFrameChecksum(frame);
-	return frame.checksum === expected;
-}
-
-// ── Errors ──────────────────────────────────────────────────────────────────
-
-/** Discriminants surfaced by tier-level WAL operations. */
-export type StorageErrorCode = "backend-no-list-support" | "codec-mismatch" | "backend-error";
-
-/**
- * Thrown by the storage tier when a precondition fails (backend lacks
- * required capability, codec doesn't match, etc.). Distinct from
- * {@link RestoreError} which is replay-time.
- *
- * @category extra
- */
-export class StorageError extends Error {
-	readonly code: StorageErrorCode;
-	readonly details: Readonly<Record<string, unknown>>;
-
-	constructor(
-		code: StorageErrorCode,
-		message: string,
-		details: Readonly<Record<string, unknown>> = {},
-	) {
-		super(message);
-		this.name = "StorageError";
-		this.code = code;
-		this.details = details;
-	}
-}
-
-/** Discriminants surfaced by `Graph.restoreSnapshot({ mode: "diff" })`. */
-export type RestoreErrorCode =
-	| "phase-failed"
-	| "torn-write-mid-stream"
-	| "baseline-missing"
-	| "codec-mismatch"
-	| "wal-tier-required";
-
-/**
- * Thrown by `Graph.restoreSnapshot({ mode: "diff" })` when replay can't
- * complete (a phase's `batch()` rejected, a mid-stream frame's checksum
- * failed, no baseline was found, etc.). Distinct from {@link StorageError}
- * which is tier-level.
- *
- * @category extra
- */
-export class RestoreError extends Error {
-	readonly code: RestoreErrorCode;
-	readonly details: Readonly<Record<string, unknown>>;
-
-	constructor(
-		code: RestoreErrorCode,
-		message: string,
-		details: Readonly<Record<string, unknown>> = {},
-	) {
-		super(message);
-		this.name = "RestoreError";
-		this.code = code;
-		this.details = details;
-	}
-}
-
-// ── Restore result ──────────────────────────────────────────────────────────
-
-/**
- * Telemetry returned by `Graph.restoreSnapshot({ mode: "diff" })`. Inspection-as-
- * test-harness shape — every field is observable for tests + dry-run audit
- * per CLAUDE.md "Dry-run equivalence rule".
- *
- * @category extra
- */
-export interface RestoreResult {
-	/** Total frames applied (across all phases). */
-	readonly replayedFrames: number;
-	/** Frames that failed checksum at WAL tail and were dropped per Q3. */
-	readonly skippedFrames: number;
-	/** Highest `frame_seq` applied. Zero if no frames were replayed. */
-	readonly finalSeq: number;
-	/** Per-lifecycle phase breakdown (in cross-scope replay order). */
-	readonly phases: readonly {
-		readonly lifecycle: "spec" | "data" | "ownership";
-		readonly frames: number;
-	}[];
-}
-
-// ── Replay helpers ──────────────────────────────────────────────────────────
-
-/**
- * Cross-scope replay order (DS-14 PART 4 lock — `spec → data → ownership`).
- * Exported so the replay implementation and parity tests share one source of
- * truth.
- */
-export const REPLAY_ORDER: readonly ("spec" | "data" | "ownership")[] = Object.freeze([
-	"spec",
-	"data",
-	"ownership",
-] as const);
-
-/**
- * Iterate WAL frames under a prefix in `frame_seq` ASC order. Wraps a tier's
- * {@link BaseStorageTier.listByPrefix} with the contract this module
- * requires (lazy iteration, ordered keys, decode-on-yield).
- *
- * Throws {@link StorageError} `backend-no-list-support` on first yield if
- * the tier doesn't expose `listByPrefix`.
- *
- * @category extra
- */
-export async function* iterateWalFrames<T = unknown>(
-	tier: BaseStorageTier,
-	prefix: string,
-): AsyncIterable<{ key: string; frame: WALFrame<T> }> {
-	const listByPrefix = tier.listByPrefix;
-	if (typeof listByPrefix !== "function") {
-		throw new StorageError(
-			"backend-no-list-support",
-			`storage tier "${tier.name}" does not implement listByPrefix; WAL replay requires it`,
-			{ tier: tier.name },
-		);
-	}
-	for await (const entry of listByPrefix.call(tier, prefix) as AsyncIterable<{
-		key: string;
-		value: unknown;
-	}>) {
-		const frame = entry.value as WALFrame<T>;
-		// QA-P7-B: mirror Rust's `#[serde(default = "default_format_version")]`
-		// (`graphrefly-storage/src/wal.rs`). A frame written before this
-		// field existed (or by a non-TS author) deserializes without the
-		// key; default it on read so the required-`number` type is honest
-		// and cross-impl byte-parity holds. Present-field frames (every
-		// frame this impl writes) pass through by identity — no per-frame
-		// realloc on the common path.
-		yield {
-			key: entry.key,
-			frame:
-				frame.format_version === undefined
-					? { ...frame, format_version: WAL_FORMAT_VERSION }
-					: frame,
-		};
-	}
-}
diff --git a/packages/pure-ts/src/graph/changeset.ts b/packages/pure-ts/src/graph/changeset.ts
deleted file mode 100644
index b621f4e0..00000000
--- a/packages/pure-ts/src/graph/changeset.ts
+++ /dev/null
@@ -1,229 +0,0 @@
-/**
- * Live changeset stream for `Graph.observe({ changeset: true })`.
- *
- * D2 — Three-layer view (`docs/optimizations.md` line "D — Three-layer view").
- *
- * The changeset stream emits one discrete {@link GraphChange} event per
- * underlying graph change. Variants cover three categories:
- *
- * 1. **Core data flow** — `data` (with edge attribution via `fromPath` +
- *    `fromDepIndex`), `dirty`, `resolved`, `error`, `complete`, `teardown`.
- * 2. **Topology** — `node-added`, `node-removed`, `mount`, `unmount`.
- * 3. **Batch boundaries** — `batch-start`, `batch-end` (groups changes into
- *    one frame for animation / per-batch reconciliation).
- *
- * Future-extensible variants are reserved in the discriminated union but not
- * implemented yet: `pause`, `resume`, `invalidate`, `trace`, `resubscribe`,
- * `snapshot`. Adding them later is a non-breaking append.
- *
- * The {@link GraphChangeEnvelope} fields (`version`, `timestamp_ns`, `scope`)
- * are common to every variant. Designed to be share-shape with future
- * post-1.0 store-level `StoreOp` variants on the same stream
- * (§8.7 Delta checkpoints & WAL).
- *
- * @module
- */
-
-import type { Actor } from "../core/actor.js";
-
-// ---------------------------------------------------------------------------
-// Envelope
-// ---------------------------------------------------------------------------
-
-/**
- * Common fields for every {@link GraphChange} variant.
- *
- * - `version` — monotonic counter, **per observe handle**. Comparisons are only
- *   valid within a single subscription; different concurrent observers of the
- *   same graph see independent counter sequences (their `version` values may
- *   coincide for the same underlying event). Strictly increasing across all
- *   events from a single handle regardless of variant.
- * - `timestamp_ns` — monotonic nanosecond timestamp from `core/clock.ts`
- *   `monotonicNs()`. Use for ordering / animation timing only — NOT comparable
- *   to wall-clock or to `lastMutation.timestamp_ns` semantics elsewhere in the
- *   codebase. Strictly use within a single observe handle's stream.
- * - `scope` — the `::`-delimited path that scopes this change. For node-level
- *   variants this is the node's qualified path; for graph-level topology
- *   events (`node-added` / `node-removed` / `mount` / `unmount`) this is the
- *   newly-affected segment qualified relative to the observed root. Batch
- *   boundary events use `scope: ""` (graph-level).
- */
-export interface GraphChangeEnvelope {
-	readonly version: number;
-	readonly timestamp_ns: number;
-	readonly scope: string;
-}
-
-// ---------------------------------------------------------------------------
-// Variants — core data flow
-// ---------------------------------------------------------------------------
-
-/**
- * A `DATA` flowed into the scoped node. `fromPath` + `fromDepIndex` attribute
- * the edge that delivered this DATA: `fromPath` is the qualified path of the
- * upstream dep that triggered the recomputation; `fromDepIndex` is its
- * positional index in the scoped node's declared deps.
- *
- * For source nodes (no upstream deps — e.g. `state`/`producer`) the
- * `fromPath` is the scoped node itself and `fromDepIndex` is `-1`.
- *
- * `actor` mirrors `Graph.observe()`'s `data` event attribution: present when
- * the originating `node.down(...)` supplied an actor, else `DEFAULT_ACTOR`.
- *
- * **Production note.** Edge attribution is sourced from the inspector hook,
- * which only attaches when `cfg.inspectorEnabled` is true. The default in
- * production builds is `false` (see `src/core/config.ts`). With the inspector
- * disabled, `fromPath` falls back to `scope` (the consuming node) and
- * `fromDepIndex` is `-1`. Enable inspector via `cfg.inspectorEnabled = true`
- * (or rely on the dev-mode default) when accurate attribution matters.
- */
-export interface GraphChangeData extends GraphChangeEnvelope {
-	readonly type: "data";
-	readonly value: unknown;
-	readonly fromPath: string;
-	readonly fromDepIndex: number;
-	readonly actor?: Actor;
-}
-
-export interface GraphChangeDirty extends GraphChangeEnvelope {
-	readonly type: "dirty";
-}
-
-export interface GraphChangeResolved extends GraphChangeEnvelope {
-	readonly type: "resolved";
-}
-
-export interface GraphChangeError extends GraphChangeEnvelope {
-	readonly type: "error";
-	readonly error: unknown;
-	readonly actor?: Actor;
-}
-
-export interface GraphChangeComplete extends GraphChangeEnvelope {
-	readonly type: "complete";
-}
-
-export interface GraphChangeTeardown extends GraphChangeEnvelope {
-	readonly type: "teardown";
-}
-
-// ---------------------------------------------------------------------------
-// Variants — topology
-// ---------------------------------------------------------------------------
-
-export interface GraphChangeNodeAdded extends GraphChangeEnvelope {
-	readonly type: "node-added";
-	/** `"state" | "derived" | "producer" | "effect"` per `NodeDescribeKind`. */
-	readonly nodeKind?: string;
-}
-
-export interface GraphChangeNodeRemoved extends GraphChangeEnvelope {
-	readonly type: "node-removed";
-}
-
-export interface GraphChangeMount extends GraphChangeEnvelope {
-	readonly type: "mount";
-}
-
-export interface GraphChangeUnmount extends GraphChangeEnvelope {
-	readonly type: "unmount";
-}
-
-// ---------------------------------------------------------------------------
-// Variants — batch boundaries
-// ---------------------------------------------------------------------------
-
-export interface GraphChangeBatchStart extends GraphChangeEnvelope {
-	readonly type: "batch-start";
-}
-
-export interface GraphChangeBatchEnd extends GraphChangeEnvelope {
-	readonly type: "batch-end";
-}
-
-// ---------------------------------------------------------------------------
-// Variants — future-extensible (RESERVED, do NOT emit)
-// ---------------------------------------------------------------------------
-
-/**
- * Future variants reserved in the discriminated union so consumers can
- * exhaustively switch without compile errors when these land later. Adding a
- * runtime emission for any of these is a non-breaking append. Do NOT emit
- * these from the current observe pipeline.
- */
-export interface GraphChangePause extends GraphChangeEnvelope {
-	readonly type: "pause";
-	readonly lockId: unknown;
-}
-
-export interface GraphChangeResume extends GraphChangeEnvelope {
-	readonly type: "resume";
-	readonly lockId: unknown;
-}
-
-export interface GraphChangeInvalidate extends GraphChangeEnvelope {
-	readonly type: "invalidate";
-}
-
-export interface GraphChangeTrace extends GraphChangeEnvelope {
-	readonly type: "trace";
-	readonly annotation: string;
-	readonly actor?: Actor;
-}
-
-export interface GraphChangeResubscribe extends GraphChangeEnvelope {
-	readonly type: "resubscribe";
-}
-
-export interface GraphChangeSnapshot extends GraphChangeEnvelope {
-	readonly type: "snapshot";
-	readonly cid?: string;
-}
-
-// ---------------------------------------------------------------------------
-// Discriminated union
-// ---------------------------------------------------------------------------
-
-/**
- * Discriminated union of every changeset event variant **emitted by the
- * runtime today**. Consumers can exhaustively `switch (c.type)` over this
- * union and trust every branch corresponds to an actually-fired event.
- *
- * /qa F-16 (2026-04-30): the reserved variants (pause / resume / invalidate /
- * trace / resubscribe / snapshot) live in {@link GraphChangeReserved} —
- * separate so a `switch` over `GraphChange` doesn't mandate dead branches.
- * If a future runtime extension promotes a reserved variant, it migrates
- * from {@link GraphChangeReserved} into this `GraphChange` union (a
- * non-breaking append).
- */
-export type GraphChange =
-	| GraphChangeData
-	| GraphChangeDirty
-	| GraphChangeResolved
-	| GraphChangeError
-	| GraphChangeComplete
-	| GraphChangeTeardown
-	| GraphChangeNodeAdded
-	| GraphChangeNodeRemoved
-	| GraphChangeMount
-	| GraphChangeUnmount
-	| GraphChangeBatchStart
-	| GraphChangeBatchEnd;
-
-/**
- * Reserved (not emitted by the current runtime). Forward-compatible — adding
- * runtime emission for any reserved variant migrates it into {@link GraphChange}
- * as a non-breaking append. Consumers building inspector pipelines that want
- * to handle every possible future variant can switch over `GraphChange |
- * GraphChangeReserved`.
- */
-export type GraphChangeReserved =
-	| GraphChangePause
-	| GraphChangeResume
-	| GraphChangeInvalidate
-	| GraphChangeTrace
-	| GraphChangeResubscribe
-	| GraphChangeSnapshot;
-
-/** Tier name extracted from the `type` discriminator (emitted variants only). */
-export type GraphChangeType = GraphChange["type"];
diff --git a/packages/pure-ts/src/graph/codec.ts b/packages/pure-ts/src/graph/codec.ts
deleted file mode 100644
index 05b0d410..00000000
--- a/packages/pure-ts/src/graph/codec.ts
+++ /dev/null
@@ -1,403 +0,0 @@
-/**
- * GraphCodec — pluggable serialization for graph snapshots (Phase 8.6).
- *
- * Design reference: `archive/docs/SESSION-serialization-memory-footprint.md`
- *
- * The codec interface decouples snapshot format from graph internals.
- * Default is JSON (current behavior). DAG-CBOR and compressed variants
- * ship as optional codecs. FlatBuffers/Arrow for advanced tiers.
- *
- * Tiered representation:
- *   HOT  — JS objects (live propagation, no codec involved)
- *   WARM — DAG-CBOR in-memory buffer (lazy hydration, delta checkpoints)
- *   COLD — Arrow/Parquet (bulk storage, ML pipelines, archival)
- *   PEEK — FlatBuffers (zero-copy read from dormant graph)
- *
- * Wire-protocol envelope (v1):
- *
- *   [envelope_v=1: u8][name_len: u8][name: utf8][codec_v: u16 BE][payload: rest]
- *
- * `graph.snapshot({format: "bytes", codec: name})` wraps the codec's
- * `encode` output in this envelope; `Graph.decode(bytes)` auto-dispatches
- * via the config's codec registry — no out-of-band content-type needed.
- */
-
-import type { GraphReFlyConfig } from "../core/config.js";
-import type { GraphCheckpointRecord, GraphPersistSnapshot } from "./graph.js";
-
-// ---------------------------------------------------------------------------
-// Core codec interface
-// ---------------------------------------------------------------------------
-
-/**
- * Encode/decode graph snapshots to/from binary.
- *
- * Implementations must be deterministic: `encode(x)` always produces the
- * same bytes for the same input. This is critical for CID computation (V1)
- * and snapshot hash-comparison.
- */
-export interface GraphCodec {
-	/** Human-readable name; used as the lookup key in the envelope and config registry. */
-	readonly name: string;
-
-	/**
-	 * Codec version. Bumps on breaking wire format changes; `decode` receives
-	 * this via the envelope so codecs can dispatch on historical layouts.
-	 * Must fit in a `u16` (0–65535).
-	 */
-	readonly version: number;
-
-	/** MIME-like content type identifier (e.g. `"application/dag-cbor+zstd"`). */
-	readonly contentType: string;
-
-	/** Encode a snapshot to binary. */
-	encode(snapshot: GraphPersistSnapshot): Uint8Array;
-
-	/**
-	 * Decode binary back to a snapshot.
-	 *
-	 * `codecVersion` is the version that produced `buffer` (read from the
-	 * envelope). Omit when the caller is sure of the version (tests, one-shot
-	 * round-trips). Codecs that support multiple historical layouts dispatch
-	 * on this value.
-	 *
-	 * For lazy codecs, this may return a proxy that decodes nodes on access
-	 * (see {@link LazyGraphCodec}).
-	 */
-	decode(buffer: Uint8Array, codecVersion?: number): GraphPersistSnapshot;
-}
-
-/**
- * Extended codec that supports lazy (on-demand) node decoding.
- *
- * `decodeLazy` returns a snapshot where `nodes` is a Proxy — individual
- * nodes are decoded only when accessed. This enables near-zero cold-start
- * for large graphs (decode envelope + topology, skip node values until read).
- */
-export interface LazyGraphCodec extends GraphCodec {
-	/** Decode envelope and topology; defer node value decoding to access time. */
-	decodeLazy(buffer: Uint8Array, codecVersion?: number): GraphPersistSnapshot;
-}
-
-// ---------------------------------------------------------------------------
-// Delta checkpoint types (requires V0 — Phase 6.0)
-// ---------------------------------------------------------------------------
-
-/**
- * WAL entry. Unified with {@link GraphCheckpointRecord} — every record
- * already carries `mode` / `seq` / `timestamp_ns` / `format_version`, so the
- * WAL is just an ordered list of records. `replayWAL` walks this list.
- */
-export type WALEntry = GraphCheckpointRecord;
-
-// ---------------------------------------------------------------------------
-// Eviction policy (dormant subgraph management)
-// ---------------------------------------------------------------------------
-
-/**
- * Policy for evicting dormant subgraphs to reduce memory.
- *
- * When a subgraph hasn't propagated for `idleTimeoutMs`, it is serialized
- * using the graph's codec and JS objects are released. Re-hydrated on next
- * access (read, propagation, describe).
- */
-export interface EvictionPolicy {
-	/** Milliseconds of inactivity before eviction. */
-	idleTimeoutMs: number;
-	/** Codec to use for serializing evicted subgraphs (default: graph's codec). */
-	codec?: GraphCodec;
-}
-
-/** Metadata about an evicted subgraph, exposed via describe(). */
-export interface EvictedSubgraphInfo {
-	/** True if currently evicted (serialized, JS objects released). */
-	evicted: true;
-	/** Wall-clock ns of last propagation before eviction. */
-	lastActiveNs: bigint;
-	/** Size of serialized buffer in bytes. */
-	serializedBytes: number;
-	/** Codec used for serialization. */
-	codecName: string;
-}
-
-// ---------------------------------------------------------------------------
-// JSON codec (default — wraps current behavior)
-// ---------------------------------------------------------------------------
-
-/**
- * Default JSON codec. Wraps `JSON.stringify`/`JSON.parse` with deterministic
- * key ordering (matching current `snapshot()` behavior).
- */
-export const JsonCodec: GraphCodec = {
-	name: "json",
-	version: 1,
-	contentType: "application/json",
-
-	encode(snapshot: GraphPersistSnapshot): Uint8Array {
-		// Deterministic: snapshot() already sorts keys.
-		const json = JSON.stringify(snapshot);
-		return new TextEncoder().encode(json);
-	},
-
-	decode(buffer: Uint8Array, _codecVersion?: number): GraphPersistSnapshot {
-		const json = new TextDecoder().decode(buffer);
-		return JSON.parse(json) as GraphPersistSnapshot;
-	},
-};
-
-// ---------------------------------------------------------------------------
-// DAG-CBOR codec (factory — requires @ipld/dag-cbor DI)
-// ---------------------------------------------------------------------------
-
-/**
- * Create a DAG-CBOR codec.
- *
- * Requires `@ipld/dag-cbor` as a peer dependency. ~40-50% smaller than JSON,
- * deterministic encoding (required for V1 CID), CID links as native type.
- *
- * @example
- * ```ts
- * import * as dagCbor from "@ipld/dag-cbor";
- * const codec = createDagCborCodec(dagCbor);
- * config.registerCodec(codec);
- * const bytes = graph.snapshot({ format: "bytes", codec: "dag-cbor" });
- * ```
- */
-export function createDagCborCodec(dagCbor: {
-	encode: (value: unknown) => Uint8Array;
-	decode: (bytes: Uint8Array) => unknown;
-}): GraphCodec {
-	return {
-		name: "dag-cbor",
-		version: 1,
-		contentType: "application/dag-cbor",
-		encode: (snapshot) => dagCbor.encode(snapshot),
-		decode: (buffer, _codecVersion) => dagCbor.decode(buffer) as GraphPersistSnapshot,
-	};
-}
-
-/**
- * Create a DAG-CBOR + zstd codec. ~80-90% smaller than JSON.
- *
- * Requires `@ipld/dag-cbor` and a zstd implementation (e.g. `fzstd` for
- * browser, `node:zlib` for Node.js).
- *
- * @example
- * ```ts
- * import * as dagCbor from "@ipld/dag-cbor";
- * import { compressSync, decompressSync } from "fzstd";
- * const codec = createDagCborZstdCodec(dagCbor, { compressSync, decompressSync });
- * config.registerCodec(codec);
- * ```
- */
-export function createDagCborZstdCodec(
-	dagCbor: {
-		encode: (value: unknown) => Uint8Array;
-		decode: (bytes: Uint8Array) => unknown;
-	},
-	zstd: {
-		compressSync: (data: Uint8Array) => Uint8Array;
-		decompressSync: (data: Uint8Array) => Uint8Array;
-	},
-): GraphCodec {
-	return {
-		name: "dag-cbor-zstd",
-		version: 1,
-		contentType: "application/dag-cbor+zstd",
-		encode: (snapshot) => zstd.compressSync(dagCbor.encode(snapshot)),
-		decode: (buffer, _codecVersion) =>
-			dagCbor.decode(zstd.decompressSync(buffer)) as GraphPersistSnapshot,
-	};
-}
-
-// ---------------------------------------------------------------------------
-// Envelope (v1) — self-describing codec metadata prepended to payload bytes
-// ---------------------------------------------------------------------------
-
-/** Current envelope format version. Bump on breaking layout changes. */
-export const ENVELOPE_VERSION = 1;
-
-const ENVELOPE_MIN_LEN = 4; // env_v(1) + name_len(1) + codec_v(2) + name/payload(≥0)
-
-/**
- * Prepend the v1 envelope to `payload` identifying `codec`. The resulting
- * bytes are self-describing — any caller with access to the registering
- * {@link GraphReFlyConfig} can {@link decodeEnvelope} without knowing the
- * codec up front.
- *
- * Layout:
- * `[envelope_v=1: u8][name_len: u8][name: utf8][codec_v: u16 BE][payload: rest]`
- *
- * @throws If `codec.name` encodes to more than 255 UTF-8 bytes or
- *   `codec.version` doesn't fit in a u16.
- */
-export function encodeEnvelope(
-	codec: Pick<GraphCodec, "name" | "version">,
-	payload: Uint8Array,
-): Uint8Array {
-	const nameBytes = new TextEncoder().encode(codec.name);
-	if (nameBytes.length === 0 || nameBytes.length > 255) {
-		throw new Error(
-			`encodeEnvelope: codec name "${codec.name}" encodes to ${nameBytes.length} bytes (must be 1–255)`,
-		);
-	}
-	const cv = codec.version;
-	if (!Number.isInteger(cv) || cv < 0 || cv > 0xffff) {
-		throw new Error(
-			`encodeEnvelope: codec.version ${cv} out of u16 range (expected integer 0–65535)`,
-		);
-	}
-	// Guard against RangeError-on-alloc for very large payloads — we need
-	// `Number.isSafeInteger` math on `1 + 1 + nameBytes.length + 2 +
-	// payload.length` and the resulting Uint8Array must fit within the
-	// platform limit (2³² − 1 bytes on 64-bit JS engines).
-	const totalLen = 1 + 1 + nameBytes.length + 2 + payload.length;
-	if (totalLen > 0xffffffff) {
-		throw new Error(
-			`encodeEnvelope: total envelope size ${totalLen} exceeds 2^32-1 bytes (payload ${payload.length} bytes)`,
-		);
-	}
-	const out = new Uint8Array(totalLen);
-	let i = 0;
-	out[i++] = ENVELOPE_VERSION;
-	out[i++] = nameBytes.length;
-	out.set(nameBytes, i);
-	i += nameBytes.length;
-	out[i++] = (cv >>> 8) & 0xff;
-	out[i++] = cv & 0xff;
-	out.set(payload, i);
-	return out;
-}
-
-/**
- * Inverse of {@link encodeEnvelope}. Reads the header, resolves the codec
- * via `config.lookupCodec(name)`, and returns the codec + its version + the
- * inner payload slice. The caller feeds `payload` to `codec.decode(payload,
- * codecVersion)` — or uses {@link Graph.decode} which does both steps.
- *
- * @throws If the envelope is truncated, the version is unsupported, or the
- *   named codec isn't registered on `config`.
- */
-export function decodeEnvelope(
-	bytes: Uint8Array,
-	config: GraphReFlyConfig,
-): { codec: GraphCodec; codecVersion: number; payload: Uint8Array } {
-	if (bytes.length < ENVELOPE_MIN_LEN) {
-		throw new Error(`decodeEnvelope: bytes too short (${bytes.length} < ${ENVELOPE_MIN_LEN})`);
-	}
-	let i = 0;
-	const envVersion = bytes[i++]!;
-	if (envVersion !== ENVELOPE_VERSION) {
-		throw new Error(
-			`decodeEnvelope: unsupported envelope version ${envVersion} (expected ${ENVELOPE_VERSION})`,
-		);
-	}
-	const nameLen = bytes[i++]!;
-	if (nameLen === 0) {
-		throw new Error("decodeEnvelope: name_len must be >= 1");
-	}
-	if (i + nameLen + 2 > bytes.length) {
-		throw new Error(
-			`decodeEnvelope: envelope truncated (need ${i + nameLen + 2} bytes, have ${bytes.length})`,
-		);
-	}
-	const name = new TextDecoder().decode(bytes.subarray(i, i + nameLen));
-	i += nameLen;
-	const codecVersion = ((bytes[i]! << 8) | bytes[i + 1]!) >>> 0;
-	i += 2;
-	const payload = bytes.subarray(i);
-	const codec = config.lookupCodec<GraphCodec>(name);
-	if (codec == null) {
-		throw new Error(
-			`decodeEnvelope: codec "${name}" not registered (envelope codec_v=${codecVersion})`,
-		);
-	}
-	return { codec, codecVersion, payload };
-}
-
-/**
- * Register the built-in {@link JsonCodec} on a config. Called once on
- * `defaultConfig` at module load so `graph.snapshot({format: "bytes", codec:
- * "json"})` works out of the box. Test / isolated configs should call this
- * manually before the first node is created.
- */
-export function registerBuiltinCodecs(config: GraphReFlyConfig): void {
-	config.registerCodec(JsonCodec);
-}
-
-// ---------------------------------------------------------------------------
-// WAL helpers
-// ---------------------------------------------------------------------------
-
-/**
- * Reconstruct a snapshot from a WAL (sequence of {@link GraphCheckpointRecord}s).
- *
- * - Must start with a `"full"` record carrying a baseline snapshot — that's
- *   the anchor {@link Graph.attachSnapshotStorage} always emits on the first flush
- *   of any tier (and every `compactEvery`-th flush thereafter).
- * - Subsequent `"full"` entries (compaction points) **replace** the result
- *   wholesale.
- * - `"diff"` entries roll forward by applying the structural diff —
- *   added nodes (via `nodesAddedFull`), removed nodes, and changed fields
- *   are reflected into the accumulated snapshot.
- *
- * Validates monotonic `seq` progression across entries.
- */
-export function replayWAL(entries: readonly WALEntry[]): GraphPersistSnapshot {
-	if (entries.length === 0) {
-		throw new Error("WAL is empty — need at least one full snapshot");
-	}
-
-	const first = entries[0]!;
-	if (first.mode !== "full") {
-		throw new Error("WAL must start with a full record carrying a baseline snapshot");
-	}
-
-	let result: GraphPersistSnapshot = JSON.parse(JSON.stringify(first.snapshot));
-	let prevSeq: number = first.seq;
-
-	for (let i = 1; i < entries.length; i++) {
-		const entry = entries[i]!;
-		if (entry.seq <= prevSeq) {
-			throw new Error(
-				`WAL chain broken at index ${i}: seq=${entry.seq} must exceed prev seq=${prevSeq}`,
-			);
-		}
-
-		if (entry.mode === "full") {
-			// Replace baseline wholesale (Unit 23 D fix — Object.assign left
-			// stale keys from pre-compact state visible).
-			result = JSON.parse(JSON.stringify(entry.snapshot));
-			prevSeq = entry.seq;
-			continue;
-		}
-
-		// mode === "diff": apply structural diff to the accumulated snapshot.
-		const diff = entry.diff;
-		// Apply removes first so a path reused across a remove+add in a single
-		// diff lands on the `nodesAddedFull` slice rather than being wiped.
-		for (const path of diff.nodesRemoved) {
-			delete result.nodes[path];
-		}
-		// Reinstate added nodes from the full-slice payload carried by
-		// GraphWALDiff. Deep-clone so later mutations don't alias the WAL
-		// entry's source slice.
-		const addedFull = diff.nodesAddedFull;
-		if (addedFull != null) {
-			for (const [path, slice] of Object.entries(addedFull)) {
-				result.nodes[path] = JSON.parse(JSON.stringify(slice));
-			}
-		}
-		for (const change of diff.nodesChanged) {
-			const existing = result.nodes[change.path];
-			if (existing == null) continue;
-			(existing as Record<string, unknown>)[change.field] = change.to;
-		}
-
-		// Edges are derived from node `_deps` at restore time (Unit 7) — no
-		// separate edge-patch pass.
-		prevSeq = entry.seq;
-	}
-
-	return result;
-}
diff --git a/packages/pure-ts/src/graph/explain.ts b/packages/pure-ts/src/graph/explain.ts
deleted file mode 100644
index 3a2e73d5..00000000
--- a/packages/pure-ts/src/graph/explain.ts
+++ /dev/null
@@ -1,473 +0,0 @@
-/**
- * Causal walkback over a {@link Graph.describe} snapshot (roadmap §9.2).
- *
- * `explainPath` finds the shortest dep-chain from `from` to `to` and returns a
- * step-by-step {@link CausalChain} enriched with each node's current value,
- * status, last-mutation actor, and any `graph.trace()` reasoning annotation.
- *
- * Pure function over the snapshot — peer to {@link reachable}. The
- * {@link Graph.explain} instance method auto-passes `describe({detail:"standard"})`
- * plus runtime annotations and `lastMutation` so callers get rich output by
- * default.
- *
- * @module
- */
-import type { Actor } from "../core/actor.js";
-import type { DescribeNodeOutput } from "../core/meta.js";
-import type { GraphDescribeOutput } from "./graph.js";
-
-/** One node along the causal chain returned by {@link explainPath}. */
-export interface CausalStep {
-	/** Qualified node path. */
-	path: string;
-	/** Node kind (`state` / `derived` / `producer` / etc.). */
-	type: DescribeNodeOutput["type"];
-	/** Status as of the source snapshot. */
-	status?: DescribeNodeOutput["status"];
-	/** Cached value at snapshot time (omitted when describe didn't include it). */
-	value?: unknown;
-	/** Hop distance from `from` (0 = `from`, N = `to`). */
-	hop: number;
-	/** Annotation set via `graph.trace(path, annotation)` or `graph.add(node, { name: path, annotation })`, when present. */
-	annotation?: string;
-	/** Most recent guarded mutation, when known. */
-	lastMutation?: Readonly<{ actor: Actor; timestamp_ns: number }>;
-	/** V0/V1 versioning info, when present. */
-	v?: DescribeNodeOutput["v"];
-	/** Index of this step in the next step's `deps` (i.e. which dep slot fed forward). */
-	dep_index?: number;
-	/**
-	 * All dep slots when the same dep appears multiple times in the next
-	 * step's `deps`. Present only for multi-edge connections; `dep_index`
-	 * always equals `dep_indices[0]` when set.
-	 */
-	dep_indices?: number[];
-	/**
-	 * `true` when the outgoing edge to the next step is a "soft forward
-	 * edge" declared via `meta.attachTarget` (e.g.
-	 * `topicBridge.attach → targetTopic.events`). Wave propagation flows
-	 * via the imperative attach in the factory body, NOT a declared dep —
-	 * so `dep_index` / `dep_indices` are absent for soft hops. See
-	 * `src/base/meta/attach-edge-meta.ts` for the convention.
-	 */
-	via_attach_edge?: boolean;
-}
-
-/** Outcome of an {@link explainPath} call. */
-export interface CausalChain {
-	from: string;
-	to: string;
-	/** True when a path was found. */
-	found: boolean;
-	/** Why the chain may be empty/incomplete. `"ok"` when `found` is true.
-	 * `"pending"` is the reactive-explain sentinel emitted while reactive args
-	 * are waiting for their first DATA (qa D5). */
-	reason: "ok" | "no-such-from" | "no-such-to" | "no-path" | "max-depth-exceeded" | "pending";
-	/** Ordered steps — first element is `from`, last is `to`. Empty when `!found`. */
-	steps: readonly CausalStep[];
-	/** Pretty multi-line rendering. Always present, even on failure (one-line message). */
-	text: string;
-	/** JSON-serializable form (drops `text` to keep payloads compact). */
-	toJSON(): {
-		from: string;
-		to: string;
-		found: boolean;
-		reason: CausalChain["reason"];
-		steps: readonly CausalStep[];
-	};
-}
-
-/** Options for {@link explainPath}. */
-export interface ExplainPathOptions {
-	/** Maximum hop distance to search. Omit for unbounded. */
-	maxDepth?: number;
-	/** Per-path reasoning annotations (typically `graph.trace()` output map). */
-	annotations?: ReadonlyMap<string, string>;
-	/** Per-path `lastMutation` map (overrides describe-derived values). */
-	lastMutations?: ReadonlyMap<string, Readonly<{ actor: Actor; timestamp_ns: number }>>;
-	/**
-	 * When `true` and `from === to`, search for a non-trivial cycle (path
-	 * back to `from` through ≥1 other node) instead of returning the trivial
-	 * single-step. Use when debugging feedback loops (COMPOSITION-GUIDE §7).
-	 * If no real cycle exists, falls back to the trivial single-step. Default
-	 * `false` — backward-compatible.
-	 */
-	findCycle?: boolean;
-}
-
-/**
- * Walks backward from `to` through `deps` to find the shortest path to `from`,
- * then assembles an ordered, enriched {@link CausalChain}.
- *
- * @param described - `graph.describe()` output (any detail level; richer detail → richer steps).
- * @param from - Path of the upstream node (the cause).
- * @param to - Path of the downstream node (the effect).
- * @param opts - Optional `maxDepth` and per-path annotation overlays.
- * @returns A {@link CausalChain} — `found:false` with a `reason` when no path exists.
- *
- * @example
- * ```ts
- * import { explainPath } from "@graphrefly/pure-ts";
- * const chain = explainPath(graph.describe({ detail: "standard" }), "input", "result");
- * console.log(chain.text);
- * ```
- */
-export function explainPath(
-	described: GraphDescribeOutput,
-	from: string,
-	to: string,
-	opts: ExplainPathOptions = {},
-): CausalChain {
-	const fromExists = from in described.nodes;
-	const toExists = to in described.nodes;
-	if (!fromExists) return makeFailure(from, to, "no-such-from");
-	if (!toExists) return makeFailure(from, to, "no-such-to");
-
-	const maxDepth = opts.maxDepth;
-	if (maxDepth != null && (!Number.isInteger(maxDepth) || maxDepth < 0)) {
-		throw new Error(`explainPath: maxDepth must be an integer >= 0`);
-	}
-
-	const softReversePred = buildSoftReversePred(described);
-
-	if (from === to) {
-		// findCycle: search for shortest non-trivial cycle (a path of ≥2 hops
-		// back to `from` through other nodes). Falls back to trivial single
-		// step if no real cycle exists.
-		if (opts.findCycle === true) {
-			const cycle = findShortestCycle(described, from, opts, softReversePred);
-			if (cycle != null) return cycle;
-		}
-		const step = buildStep(from, described.nodes[from]!, 0, opts);
-		return makeSuccess(from, to, [step]);
-	}
-
-	if (maxDepth === 0) return makeFailure(from, to, "no-path");
-
-	const result = bfsShortestPath(described, from, to, maxDepth, softReversePred);
-	if (!result.found) {
-		return makeFailure(from, to, result.truncated ? "max-depth-exceeded" : "no-path");
-	}
-	return makeSuccess(from, to, materializeSteps(described, result.pathOrder, opts));
-}
-
-// ── BFS helpers ──────────────────────────────────────────────────────────
-
-type StepPlan = { path: string; depIndices?: number[]; viaAttachEdge?: boolean };
-
-interface BfsResult {
-	found: boolean;
-	pathOrder: StepPlan[];
-	truncated: boolean;
-}
-
-/**
- * Reverse index for soft forward edges declared via `meta.attachTarget`
- * (see `src/base/meta/attach-edge-meta.ts`). Keys are target paths; values
- * are the list of nodes whose `meta.attachTarget` resolved to that target.
- *
- * Wave propagation does NOT follow soft edges — they exist purely so
- * `explainPath` can walk past imperative subscribe-and-publish hops
- * (e.g. `topicBridge.attach → dst::events`) that have no declared dep.
- */
-type SoftReversePred = ReadonlyMap<string, readonly string[]>;
-
-function buildSoftReversePred(described: GraphDescribeOutput): SoftReversePred {
-	const map = new Map<string, string[]>();
-	for (const [path, n] of Object.entries(described.nodes)) {
-		const at = n.meta?.attachTarget;
-		if (typeof at !== "string" || at === "") continue;
-		let arr = map.get(at);
-		if (arr == null) {
-			arr = [];
-			map.set(at, arr);
-		}
-		arr.push(path);
-	}
-	return map;
-}
-
-/**
- * Backward BFS from `to` to `from`. Returns the ordered chain `from → … → to`
- * with `depIndices` annotating each non-final step (which slot(s) in the next
- * step's `deps` list connect us — typically a single index, but multi-edges
- * preserve every matching slot).
- *
- * Walks both declared `deps` AND soft forward edges (`meta.attachTarget`) —
- * the latter via {@link buildSoftReversePred}. Soft hops set `viaAttachEdge`
- * on the outgoing step and leave `depIndices` empty (no dep slot exists).
- */
-function bfsShortestPath(
-	described: GraphDescribeOutput,
-	from: string,
-	to: string,
-	maxDepth: number | undefined,
-	softReversePred: SoftReversePred,
-): BfsResult {
-	type Pred = { from: string; depIndices: number[]; viaAttachEdge: boolean };
-	const pred = new Map<string, Pred>();
-	const queue: Array<{ path: string; depth: number }> = [{ path: to, depth: 0 }];
-	const visited = new Set<string>([to]);
-	let head = 0;
-	let truncated = false;
-
-	while (head < queue.length) {
-		const cur = queue[head++]!;
-		if (cur.path === from) break;
-		const softPreds = softReversePred.get(cur.path) ?? [];
-		if (maxDepth != null && cur.depth >= maxDepth) {
-			const node = described.nodes[cur.path];
-			const hasDeps = node?.deps != null && node.deps.length > 0;
-			if (hasDeps || softPreds.length > 0) truncated = true;
-			continue;
-		}
-		const node = described.nodes[cur.path];
-		if (node == null) continue;
-		const deps = node.deps ?? [];
-		// Aggregate all dep-slot indices for each unique dep — preserves
-		// multi-edge information when the same dep appears twice.
-		const slots = new Map<string, number[]>();
-		for (let i = 0; i < deps.length; i++) {
-			const dep = deps[i]!;
-			if (!dep) continue;
-			let arr = slots.get(dep);
-			if (arr == null) {
-				arr = [];
-				slots.set(dep, arr);
-			}
-			arr.push(i);
-		}
-		for (const [dep, indices] of slots) {
-			if (visited.has(dep)) continue;
-			visited.add(dep);
-			pred.set(dep, { from: cur.path, depIndices: indices, viaAttachEdge: false });
-			queue.push({ path: dep, depth: cur.depth + 1 });
-		}
-		// Soft forward edges: nodes whose meta.attachTarget resolved to
-		// `cur.path` are predecessors here. The outgoing edge from each
-		// such soft-pred to `cur.path` is the attach-meta edge — no dep
-		// slot exists, so depIndices stays empty.
-		for (const softPred of softPreds) {
-			if (visited.has(softPred)) continue;
-			visited.add(softPred);
-			pred.set(softPred, { from: cur.path, depIndices: [], viaAttachEdge: true });
-			queue.push({ path: softPred, depth: cur.depth + 1 });
-		}
-	}
-
-	if (!pred.has(from)) {
-		return { found: false, pathOrder: [], truncated };
-	}
-
-	// Reconstruct: walk pred from `from` forward to `to`.
-	const pathOrder: StepPlan[] = [{ path: from }];
-	let cursor = from;
-	while (cursor !== to) {
-		const p = pred.get(cursor);
-		if (p == null) return { found: false, pathOrder: [], truncated: false };
-		// Attach depIndices + viaAttachEdge to the step we just came from
-		// (cursor) — both describe the OUTGOING edge from this step to the
-		// next.
-		pathOrder[pathOrder.length - 1]!.depIndices = p.depIndices;
-		if (p.viaAttachEdge) pathOrder[pathOrder.length - 1]!.viaAttachEdge = true;
-		pathOrder.push({ path: p.from });
-		cursor = p.from;
-	}
-	return { found: true, pathOrder, truncated: false };
-}
-
-/**
- * Find the shortest cycle starting and ending at `start`, excluding the
- * trivial 0-hop "self-step" case. Returns a {@link CausalChain} success when
- * a cycle of length ≥2 exists, otherwise `null`. Handles direct self-loops
- * (`start ∈ deps(start)`) and multi-hop cycles uniformly.
- *
- * **Mixed-edge cycles.** The BFS follows BOTH declared `deps` AND soft
- * forward edges (`meta.attachTarget`, see
- * `src/base/meta/attach-edge-meta.ts`). A returned cycle may therefore
- * include hops that wave propagation cannot traverse — soft edges are an
- * explainability concern, not a protocol-level dep. Consumers debugging
- * **wave feedback loops** should check `step.via_attach_edge` on each
- * returned step and treat any cycle containing a soft hop as
- * non-wave-traversable (the protocol cannot infinite-loop through it).
- *
- * **Seed limitation.** The BFS is seeded from each entry in `start`'s
- * declared `deps` only. A node with zero declared deps and only soft
- * outgoing edges (`attachTarget`) cannot start a cycle search here — no
- * cycle will be found even if one exists through soft hops. Today's only
- * soft emitter (`topicBridge.attach`) has a declared dep on `output`, so
- * this is latent; a pure-soft-outgoing factory would need a forward
- * soft-index alongside the existing reverse one.
- */
-function findShortestCycle(
-	described: GraphDescribeOutput,
-	start: string,
-	opts: ExplainPathOptions,
-	softReversePred: SoftReversePred,
-): CausalChain | null {
-	const startNode = described.nodes[start];
-	if (startNode == null) return null;
-	const startDeps = startNode.deps ?? [];
-
-	// Direct self-loop: start ∈ deps(start). Return [start, start] with
-	// dep_index pointing at the matching slot(s).
-	const selfSlots: number[] = [];
-	for (let i = 0; i < startDeps.length; i++) if (startDeps[i] === start) selfSlots.push(i);
-	if (selfSlots.length > 0) {
-		const step0 = buildStep(start, startNode, 0, opts);
-		step0.dep_index = selfSlots[0]!;
-		const step1 = buildStep(start, startNode, 1, opts);
-		return makeSuccess(start, start, [step0, step1]);
-	}
-
-	// Multi-hop cycle: BFS from each direct dep of start back to start.
-	// Soft forward edges participate in cycle detection too — if a node
-	// soft-attaches to `start` AND a declared-dep path returns from that
-	// node to `start`, that's a real (mixed-edge) cycle.
-	let best: BfsResult | null = null;
-	for (let i = 0; i < startDeps.length; i++) {
-		const dep = startDeps[i]!;
-		if (!dep || dep === start) continue;
-		const sub = bfsShortestPath(described, dep, start, opts.maxDepth, softReversePred);
-		if (!sub.found) continue;
-		if (best == null || sub.pathOrder.length < best.pathOrder.length) {
-			best = sub;
-			// Prepend `start` so the cycle reads: start → dep → … → start.
-			// The slot index from start to its first dep needs preserving.
-			best = {
-				found: true,
-				pathOrder: [{ path: start, depIndices: [i] }, ...sub.pathOrder],
-				truncated: false,
-			};
-		}
-	}
-	if (best == null) return null;
-	return makeSuccess(start, start, materializeSteps(described, best.pathOrder, opts));
-}
-
-function materializeSteps(
-	described: GraphDescribeOutput,
-	pathOrder: readonly StepPlan[],
-	opts: ExplainPathOptions,
-): CausalStep[] {
-	return pathOrder.map((entry, i) => {
-		const node = described.nodes[entry.path]!;
-		const step = buildStep(entry.path, node, i, opts);
-		if (entry.depIndices != null && entry.depIndices.length > 0) {
-			step.dep_index = entry.depIndices[0]!;
-			if (entry.depIndices.length > 1) step.dep_indices = [...entry.depIndices];
-		}
-		if (entry.viaAttachEdge) step.via_attach_edge = true;
-		return step;
-	});
-}
-
-function buildStep(
-	path: string,
-	node: DescribeNodeOutput,
-	hop: number,
-	opts: ExplainPathOptions,
-): CausalStep {
-	const step: CausalStep = {
-		path,
-		type: node.type,
-		hop,
-	};
-	if (node.status !== undefined) step.status = node.status;
-	if ("value" in node) step.value = node.value;
-	if (node.v != null) step.v = node.v;
-	const annotation = opts.annotations?.get(path) ?? node.annotation;
-	if (annotation != null) step.annotation = annotation;
-	const lastMutation = opts.lastMutations?.get(path) ?? node.lastMutation;
-	if (lastMutation != null) step.lastMutation = lastMutation;
-	return step;
-}
-
-function makeSuccess(from: string, to: string, steps: readonly CausalStep[]): CausalChain {
-	return finalize(from, to, true, "ok", steps);
-}
-
-function makeFailure(from: string, to: string, reason: CausalChain["reason"]): CausalChain {
-	return finalize(from, to, false, reason, []);
-}
-
-function finalize(
-	from: string,
-	to: string,
-	found: boolean,
-	reason: CausalChain["reason"],
-	steps: readonly CausalStep[],
-): CausalChain {
-	const text = renderChain(from, to, found, reason, steps);
-	return {
-		from,
-		to,
-		found,
-		reason,
-		steps,
-		text,
-		toJSON() {
-			return { from, to, found, reason, steps };
-		},
-	};
-}
-
-function renderChain(
-	from: string,
-	to: string,
-	found: boolean,
-	reason: CausalChain["reason"],
-	steps: readonly CausalStep[],
-): string {
-	if (!found) {
-		switch (reason) {
-			case "no-such-from":
-				return `explainPath: no node named "${from}"`;
-			case "no-such-to":
-				return `explainPath: no node named "${to}"`;
-			case "max-depth-exceeded":
-				return `explainPath: no path from "${from}" to "${to}" within maxDepth`;
-			default:
-				return `explainPath: no path from "${from}" to "${to}"`;
-		}
-	}
-	const lines: string[] = [`Causal path: ${from} → ${to} (${steps.length} step(s))`];
-	for (let i = 0; i < steps.length; i++) {
-		const step = steps[i]!;
-		// Arrow style reflects the INCOMING edge into this step:
-		// - hop 0: `·` (origin marker, no incoming edge)
-		// - prev step's `via_attach_edge`: `↝` (soft forward edge, wave
-		//   propagation does NOT follow this hop — see
-		//   `src/base/meta/attach-edge-meta.ts`)
-		// - else: `↓` (declared dep edge)
-		const prevSoft = i > 0 && steps[i - 1]!.via_attach_edge === true;
-		const arrow = step.hop === 0 ? "·" : prevSoft ? "↝" : "↓";
-		const softSuffix = prevSoft ? " (via attach-edge)" : "";
-		const head = `  ${arrow} ${step.path} (${step.type}${step.status ? `/${step.status}` : ""})${softSuffix}`;
-		lines.push(head);
-		if ("value" in step) {
-			lines.push(`      value: ${formatValue(step.value)}`);
-		}
-		if (step.annotation != null) {
-			lines.push(`      annotation: ${step.annotation}`);
-		}
-		if (step.lastMutation != null) {
-			const a = step.lastMutation.actor;
-			lines.push(`      actor: ${a.type}${a.id ? `:${a.id}` : ""}`);
-		}
-	}
-	return lines.join("\n");
-}
-
-function formatValue(v: unknown): string {
-	if (v === undefined) return "<sentinel>";
-	if (v === null) return "null";
-	if (typeof v === "string") return JSON.stringify(v);
-	if (typeof v === "number" || typeof v === "boolean" || typeof v === "bigint") return String(v);
-	try {
-		const s = JSON.stringify(v);
-		return s.length > 80 ? `${s.slice(0, 77)}...` : s;
-	} catch {
-		return String(v);
-	}
-}
diff --git a/packages/pure-ts/src/graph/graph.ts b/packages/pure-ts/src/graph/graph.ts
deleted file mode 100644
index f2571678..00000000
--- a/packages/pure-ts/src/graph/graph.ts
+++ /dev/null
@@ -1,7110 +0,0 @@
-import { RingBuffer } from "../core/_internal/ring-buffer.js";
-import { ResettableTimer } from "../core/_internal/timer.js";
-import { type Actor, DEFAULT_ACTOR } from "../core/actor.js";
-import { batch, isBatching, registerBatchFlushHook } from "../core/batch.js";
-import { monotonicNs, wallClockNs } from "../core/clock.js";
-import type { GraphReFlyConfig } from "../core/config.js";
-import { GuardDenied } from "../core/guard.js";
-import {
-	COMPLETE,
-	DATA,
-	DIRTY,
-	ERROR,
-	INVALIDATE,
-	type Messages,
-	PAUSE,
-	RESOLVED,
-	RESOLVED_ONLY_BATCH,
-	RESUME,
-	TEARDOWN,
-} from "../core/messages.js";
-import {
-	type DescribeDetail,
-	type DescribeField,
-	type DescribeNodeOutput,
-	describeNode,
-	resolveDescribeFields,
-} from "../core/meta.js";
-import {
-	defaultConfig,
-	type FnCtx,
-	type Node,
-	type NodeFn,
-	type NodeFnCleanup,
-	NodeImpl,
-	type NodeOptions,
-	type NodeSink,
-	type NodeTransportOptions,
-	node,
-} from "../core/node.js";
-import type { VersioningLevel } from "../core/versioning.js";
-import { type DescribeChangeset, topologyDiff } from "../extra/composition/topology-diff.js";
-import type {
-	GraphValueChange,
-	GraphValueChangePayload,
-	SpecChange,
-	SpecChangePayload,
-} from "../extra/data-structures/change.js";
-import {
-	type ReactiveIndexBundle,
-	type ReactiveIndexOptions,
-	reactiveIndex,
-} from "../extra/data-structures/reactive-index.js";
-import {
-	type ReactiveListBundle,
-	type ReactiveListOptions,
-	reactiveList,
-} from "../extra/data-structures/reactive-list.js";
-import {
-	type ReactiveLogBundle,
-	type ReactiveLogOptions,
-	reactiveLog,
-} from "../extra/data-structures/reactive-log.js";
-import {
-	type ReactiveMapBundle,
-	type ReactiveMapOptions,
-	reactiveMap,
-} from "../extra/data-structures/reactive-map.js";
-import { keepalive } from "../extra/sources/_keepalive.js";
-import type { StorageHandle } from "../extra/storage/core.js";
-import type { BaseStorageTier, SnapshotStorageTier } from "../extra/storage/tiers.js";
-import {
-	graphWalPrefix,
-	iterateWalFrames,
-	REPLAY_ORDER,
-	RestoreError,
-	type RestoreResult,
-	type StorageError,
-	verifyWalFrameChecksum,
-	WAL_FORMAT_VERSION,
-	type WALFrame,
-	walFrameChecksum,
-	walFrameKey,
-} from "../extra/storage/wal.js";
-import type {
-	GraphChange,
-	GraphChangeBatchEnd,
-	GraphChangeBatchStart,
-	GraphChangeComplete,
-	GraphChangeData,
-	GraphChangeDirty,
-	GraphChangeError,
-	GraphChangeMount,
-	GraphChangeNodeAdded,
-	GraphChangeNodeRemoved,
-	GraphChangeResolved,
-	GraphChangeTeardown,
-	GraphChangeUnmount,
-} from "./changeset.js";
-import { decodeEnvelope, encodeEnvelope, type GraphCodec } from "./codec.js";
-import { type CausalChain, type CausalStep, explainPath } from "./explain.js";
-import { type GraphProfileOptions, type GraphProfileResult, graphProfile } from "./profile.js";
-import { watchTopologyTree } from "./topology-tree.js";
-
-/** The separator used for qualified paths in {@link Graph.resolve} et al. */
-const PATH_SEP = "::";
-
-/**
- * Reserved segment for meta companion paths: `nodeName::__meta__::metaKey` (GRAPHREFLY-SPEC §3.6).
- * Forbidden as a local node or mount name.
- */
-export const GRAPH_META_SEGMENT = "__meta__";
-
-/**
- * Options for {@link Graph}. Named fields documented below; the open index
- * signature is preserved so callers can stash extension data on the graph
- * without losing type discipline on the reserved names.
- *
- * - `config` — bind this graph to a specific {@link GraphReFlyConfig} for
- *   tier/metaPassthrough/inspector lookups. Defaults to the singleton
- *   `defaultConfig` exported from `core/node.ts`.
- * - `versioning` — convenience for `graph.setVersioning(level)` at
- *   construction time. Monotonic bulk-apply; see {@link Graph.setVersioning}.
- * - `factories` — reserved for future per-graph factory registration;
- *   currently factories flow through `Graph.fromSnapshot(data, {factories})`.
- */
-export interface GraphOptions {
-	config?: GraphReFlyConfig;
-	versioning?: VersioningLevel;
-	factories?: Record<string, GraphNodeFactory>;
-	/**
-	 * Capacity of the reasoning-trace ring buffer. Default: `1000`. Set lower
-	 * to reduce memory; higher for audit-heavy workloads. Set at construction
-	 * time — not mutable afterward (ring buffers can't resize cleanly).
-	 */
-	traceCapacity?: number;
-	/**
-	 * Tier 1.5.3 Phase 2.5 (Session A.1 lock + Phase 2.5 design DG1=B, 2026-04-27).
-	 * Top-level factory identifier for Graph-returning factories (`agentMemory`,
-	 * `harnessLoop`, `pipelineGraph`, etc.). When set, `describe()` surfaces
-	 * `factory` + `factoryArgs` at the top of `GraphDescribeOutput` so consumers
-	 * can identify provenance, and `compileSpec` can delegate reconstruction to
-	 * `catalog.graphFactories[factory]` with `factoryArgs`. Prefer the
-	 * post-construction `Graph.prototype.tagFactory(name, args?)` mutator inside
-	 * the factory body over passing here directly.
-	 */
-	factory?: string;
-	/**
-	 * JSON-serializable subset of the construction args. For non-JSON fields
-	 * (LLMAdapter, callbacks, embedders), prefer the {@link placeholderArgs}
-	 * helper which substitutes descriptive `"<Node>"` / `"<function>"` strings
-	 * (DG2 = ii). Catalog `graphFactories` recipients receive this back during
-	 * `compileSpec` to recreate the graph with the user-supplied runtime ctx.
-	 */
-	factoryArgs?: unknown;
-	[key: string]: unknown;
-}
-
-// ---------------------------------------------------------------------------
-// Graph-level restricted fn types (narrow waist — SESSION-graph-narrow-waist.md)
-// ---------------------------------------------------------------------------
-
-/**
- * Context for {@link Graph.derived} fns. Matches raw {@link FnCtx} shape
- * (prevData / terminalDeps / store) plus the node's own previous emit.
- *
- * - `prevData[i]` — last DATA from dep `i` (end of prior wave).
- *   `undefined` means dep `i` has never produced DATA (sentinel).
- * - `terminalDeps[i]` — `undefined` (live), `true` (COMPLETE), or the
- *   ERROR payload. See {@link FnCtx}.
- * - `store` — mutable bag persisting across fn runs within one
- *   activation cycle.
- * - `cache` — the node's own previous emit. `undefined` when no
- *   prior emit (sentinel or first run), `null` when the prior emit
- *   was `null`, otherwise `T`.
- */
-export interface FnCtxDerived<T = unknown> extends FnCtx {
-	readonly cache: T | null | undefined;
-}
-
-/**
- * Restricted fn for {@link Graph.derived}. Receives the raw per-dep
- * batch shape (matching {@link NodeFn}) and returns an array of values
- * to emit this wave:
- * - `[v]` — single emit (common case).
- * - `[]` — no emit (settled unchanged → RESOLVED).
- * - `[v1, v2, ...]` — multi-emit in one wave.
- *
- * `data[i]` shape:
- * - `undefined` — dep `i` was not involved this wave (no DIRTY).
- * - `[]` — dep `i` was involved but settled as RESOLVED. Read
- *   `ctx.prevData[i]` for its last known value.
- * - `[v1, v2, ...]` — dep `i` sent one or more DATA values.
- *
- * Common scalar read (collapse multi-emit to "latest of dep i"):
- *   `data[i] != null && data[i].length > 0 ? data[i].at(-1) : ctx.prevData[i]`
- * Do NOT use `data[i]?.at(-1) ?? ctx.prevData[i]` — `null` is a valid DATA
- * payload and `??` would incorrectly fall through to `prevData` on it.
- *
- * `undefined` is excluded from the return type — SENTINEL stays
- * protocol-only.
- */
-export type GraphDerivedFn<T> = (
-	data: readonly (readonly unknown[] | undefined)[],
-	ctx: FnCtxDerived<T>,
-) => readonly (T | null)[];
-
-/**
- * Upstream-only actions for {@link Graph.effect} fns. No `emit` /
- * `down` — effects that need downstream emission use
- * {@link Graph.producer} or drop to raw `node() + graph.add()`.
- */
-export interface NodeUpActions {
-	/** Pause upstream deps. `lockId` is required per spec §2.6. */
-	pause(lockId: unknown): void;
-	/** Resume upstream deps. Must match a prior `pause` lockId. */
-	resume(lockId: unknown): void;
-}
-
-/**
- * Context for {@link Graph.effect} fns. Matches raw {@link FnCtx} shape:
- *
- * - `prevData[i]` — last DATA from dep `i` (end of prior wave).
- * - `terminalDeps[i]` — `undefined` (live), `true` (COMPLETE), or the
- *   ERROR payload. Effects can branch on dep terminals (e.g. log on
- *   COMPLETE, escalate on ERROR) without needing access to `actions`.
- * - `store` — mutable bag persisting across fn runs within one
- *   activation cycle. Use for cross-run accumulators (counters, last-
- *   seen timestamps) without closure `let` vars.
- */
-export type FnCtxEffect = FnCtx;
-
-/**
- * Restricted fn for {@link Graph.effect}. Pure sink — no downstream
- * dispatch possible. Receives raw per-dep batch shape (matching
- * {@link NodeFn}) so authors can observe multi-emit waves, RESOLVED
- * (involved but no new DATA), and not-involved deps.
- *
- * `data[i]` shape: see {@link GraphDerivedFn}.
- *
- * Return a cleanup function or granular hooks.
- */
-export type GraphEffectFn = (
-	data: readonly (readonly unknown[] | undefined)[],
-	up: NodeUpActions,
-	ctx: FnCtxEffect,
-	// biome-ignore lint/suspicious/noConfusingVoidType: cleanup return.
-) => NodeFnCleanup | void;
-
-/**
- * Restricted context for {@link Graph.producer} setup fns.
- *
- * - `store` — mutable bag persisting across activation cycles.
- */
-export interface FnCtxProducer {
-	readonly store: Record<string, unknown>;
-}
-
-/**
- * Setup fn for {@link Graph.producer}. Receives a `push` channel
- * with the same array-emission shape as {@link GraphDerivedFn}:
- * - `push([v])` — single DATA.
- * - `push([v1, v2])` — multi-DATA in one wave.
- *
- * Return a cleanup function or granular hooks for teardown.
- */
-export type GraphProducerSetupFn<T> = (
-	push: (values: readonly (T | null)[]) => void,
-	ctx: FnCtxProducer,
-	// biome-ignore lint/suspicious/noConfusingVoidType: cleanup return.
-) => NodeFnCleanup | void;
-
-/**
- * Input-side {@link NodeOptions} fields exposed by Graph methods. Excludes
- * `name` (handled via the explicit `name` arg) and `describeKind` (set
- * internally per Graph method to `"state"` / `"derived"` / `"effect"` /
- * `"producer"`). All other fields — `equals`, `initial`, `meta`, `guard`,
- * `partial`, `pausable`, `versioning*`, `completeWhenDepsComplete`,
- * `errorWhenDepsError`, `resubscribable`, `resetOnTeardown`, `config` — flow
- * through the underlying `node()` call unchanged.
- *
- * The narrow-waist promise (Phase 11) is symmetry on the input side: any
- * option valid on raw `node()` is valid on `graph.derived/effect/state/producer`,
- * so guarded compute / authz / lifecycle options never force authors to drop
- * back to raw `node() + graph.add()`. Restriction is purely on the OUTPUT
- * side (return shape, ctx) — see {@link GraphDerivedFn} / {@link GraphEffectFn}.
- */
-type SharedNodeOpts<T> = Omit<NodeOptions<T>, "name" | "describeKind">;
-
-/**
- * Options for {@link Graph.state}.
- *
- * Inherits all input-side {@link NodeOptions} (see {@link SharedNodeOpts})
- * except `initial` (which is the explicit second positional arg of
- * {@link Graph.state}) plus graph-specific extras (`signal`, `annotation`).
- */
-export interface GraphStateOptions<T> extends Omit<SharedNodeOpts<T>, "initial"> {
-	signal?: AbortSignal;
-	annotation?: string;
-}
-
-/**
- * Options for {@link Graph.derived}.
- *
- * Inherits all input-side {@link NodeOptions} (`equals`, `initial`, `meta`,
- * `guard`, `partial`, `pausable`, `versioning*`, …) plus graph-specific
- * extras:
- *
- * - `keepAlive: true` — installs an internal subscription so the node
- *   stays activated and `.cache` stays current for **external consumers**
- *   (UI render, debug snapshot, audit log). The subscription self-prunes
- *   on the node's terminal and is drained by {@link Graph.destroy}.
- *
- *   **Do not read `node.cache` from inside another reactive fn** (spec
- *   §5.12) — declare the node as a real dep instead.
- * - `signal` — when aborted, removes this node from the graph.
- * - `annotation` — forwarded to {@link Graph.add}.
- *
- * **F-15 (2026-04-30):** `equals: undefined` is filtered at the spread (the
- * impl uses `equals != null` to gate the node-options pass-through), so
- * passing `undefined` is functionally identical to omitting the field — the
- * underlying `node()` falls back to its default `Object.is` dedup.
- */
-export interface GraphDerivedOptions<T> extends SharedNodeOpts<T> {
-	keepAlive?: boolean;
-	signal?: AbortSignal;
-	annotation?: string;
-}
-
-/**
- * Options for {@link Graph.effect}.
- *
- * Inherits all input-side {@link NodeOptions} (`meta`, `guard`, `partial`,
- * `pausable`, `versioning*`, …) plus graph-specific extras (`keepAlive`,
- * `signal`, `annotation`). Output side stays restricted via
- * {@link GraphEffectFn} — `up.pause` / `up.resume` only, no `emit` / `down`.
- */
-export interface GraphEffectOptions extends SharedNodeOpts<unknown> {
-	/**
-	 * When `true`, installs an internal subscription so the effect stays
-	 * activated even without an external subscriber. Symmetric with
-	 * {@link GraphDerivedOptions.keepAlive}. Self-prunes on terminal; drained
-	 * by {@link Graph.destroy}. Default `false` — effects without external
-	 * subscribers are dormant unless this flag is set or the caller wires
-	 * their own `keepalive(...)` from `extra/sources`.
-	 */
-	keepAlive?: boolean;
-	signal?: AbortSignal;
-	annotation?: string;
-}
-
-/**
- * Options for {@link Graph.producer}.
- *
- * Inherits all input-side {@link NodeOptions} (no deps, so dep-gating
- * fields like `partial` / `completeWhenDepsComplete` / `errorWhenDepsError`
- * are inert but type-valid) plus graph-specific extras (`signal`,
- * `annotation`).
- */
-export interface GraphProducerOptions<T> extends SharedNodeOpts<T> {
-	signal?: AbortSignal;
-	annotation?: string;
-}
-
-/** Filter for {@link Graph.describe} — object-style partial match or predicate. */
-export type DescribeFilter =
-	| Partial<Pick<DescribeNodeOutput, "type" | "status">>
-	| {
-			type?: DescribeNodeOutput["type"];
-			status?: DescribeNodeOutput["status"];
-			/** Keep nodes whose `deps` includes this qualified path. */
-			depsIncludes?: string;
-			/** Snake-case alias for `depsIncludes` (Python parity). */
-			deps_includes?: string;
-			/** Keep nodes whose `meta` contains this key. */
-			metaHas?: string;
-			/** Snake-case alias for `metaHas` (Python parity). */
-			meta_has?: string;
-	  }
-	| ((node: DescribeNodeOutput) => boolean)
-	| ((nodePath: string, node: DescribeNodeOutput) => boolean);
-
-/** Options for {@link Graph.signal} and {@link Graph.set} (actor context, internal lifecycle). */
-export type GraphActorOptions = {
-	actor?: Actor;
-	/**
-	 * When `true`, skips node guards (graph lifecycle TEARDOWN, unmount teardown, etc.).
-	 */
-	internal?: boolean;
-};
-
-/** Options for {@link Graph.describe} (Phase 3.3b progressive disclosure). */
-export type GraphDescribeOptions = {
-	/**
-	 * Scope `describe()` to what `actor` is allowed to observe. Accepts a
-	 * static {@link Actor} (resolved at call time) or a `Node<Actor | null>` —
-	 * when a Node is passed and `reactive: true` is set, the reactive describe
-	 * handle subscribes to the actor node and re-derives whenever the actor
-	 * changes, so harnesses that bind a reactive actor (e.g. per-turn
-	 * `currentActor` state) get a single live describe Node instead of
-	 * re-calling `describe({ actor })` per turn. The `| null` in the Node
-	 * type is first-class: a `null` cache means "no actor configured" → **no
-	 * scoping** (full visibility), the same as `undefined` cache. This lets
-	 * callers bridge through a `Node<Actor | null>` (e.g. `guardedExecution`'s
-	 * `_actorNode`) without an unsound `as Node<Actor>` cast (F8).
-	 *
-	 * **Cache-undefined/null semantics:** when a `Node<Actor | null>` is
-	 * supplied whose `cache` is `undefined` (e.g. a `producer` that has not
-	 * yet emitted) **or `null`**, describe is treated identically to
-	 * `actor: undefined` — i.e. **no scoping** (full visibility). This matches every other Node-cache read in
-	 * the codebase, but means a not-yet-active actor node degrades to "describe
-	 * everything." Activate the actor node (subscribe + emit, or seed via
-	 * `state(initial)`) before calling `describe` if you rely on guard
-	 * scoping. In `reactive: true` mode the describe re-derives once the
-	 * actor node populates.
-	 *
-	 * **Terminal-type handling:** if the supplied `Node<Actor>` emits
-	 * `COMPLETE`, `ERROR`, or `TEARDOWN`, the reactive describe releases the
-	 * actor subscription and re-derives one last time against the final
-	 * `actor.cache` value. Subsequent describe outputs reflect that frozen
-	 * cache until `handle.dispose()` runs.
-	 */
-	actor?: Actor | Node<Actor | null>;
-	/**
-	 * Node filter. Filters operate on whatever fields the chosen `detail` level
-	 * provides. For `metaHas` and `status` filters, use `detail: "standard"` or
-	 * higher — at `"minimal"` those fields are absent and the filter silently
-	 * excludes all nodes.
-	 */
-	filter?: DescribeFilter;
-	/**
-	 * Detail level (Phase 3.3b). Default: `"minimal"`.
-	 * - `"minimal"` — type + deps only
-	 * - `"standard"` — type, status, value, deps, meta, versioning (`v`)
-	 * - `"full"` — standard + guard, lastMutation
-	 */
-	detail?: DescribeDetail;
-	/**
-	 * Explicit field selection (GraphQL-style). Overrides `detail` when provided.
-	 * Dotted paths like `"meta.label"` select specific meta keys.
-	 */
-	fields?: DescribeField[];
-	/**
-	 * Reactive describe (D2):
-	 * - `true` — return `{ node, dispose }` where `node` emits a fresh
-	 *   `GraphDescribeOutput` every time the graph state settles. Same
-	 *   coalescing as `describe({ explain, reactive: true })`.
-	 * - `"diff"` — return `{ node, dispose }` where `node` emits a
-	 *   {@link DescribeChangeset} per topology change. Empty changesets are
-	 *   suppressed; the initial cache is a synthetic full-add diff so a fresh
-	 *   subscriber sees the current topology as adds via push-on-subscribe.
-	 *   (Tier 1.5.1 — Session A.1 lock).
-	 */
-	reactive?: boolean | "diff";
-	/**
-	 * Reactive-only: name for the backing derived node (default `"describe"`).
-	 *
-	 * In `{ explain: {...}, reactive: true }` mode the equivalent slot is
-	 * `name` (default `"explain"`); `reactiveName` is honored as a fallback
-	 * for callers migrating from `describe({reactive})` muscle memory. If
-	 * both `name` and `reactiveName` are set in explain-mode, `name` wins.
-	 */
-	reactiveName?: string;
-	/**
-	 * Enforce the DF1 compound-factory tagging requirement (default `true`).
-	 *
-	 * Compound factories that emit `parent::child` topology MUST stamp
-	 * `meta.factory` on the parent node (via {@link factoryTag}) so
-	 * `decompileSpec` / `compileSpec` can round-trip the factory's internals
-	 * without surfacing them as top-level spec nodes. When `true`,
-	 * `describe()` walks the resolved node set and throws a clear
-	 * `TypeError` if any `parent::child` path's parent is registered on the
-	 * graph but lacks `meta.factory`. The failure surfaces at inspection
-	 * time — not at construction — so a graph that won't round-trip is
-	 * caught before its first describe() / decompileSpec() rather than at
-	 * graph build.
-	 *
-	 * Set to `false` for legacy / debug graphs that intentionally use `::`
-	 * in node names without compound-factory semantics. The decompileSpec
-	 * pre-pass enforces the same invariant — disabling the describe-walk
-	 * assertion does not opt out of decompile-time validation.
-	 */
-	strictFactoryTags?: boolean;
-};
-
-/** Handle returned by {@link Graph.describe} with `{ reactive: true }`. */
-export interface ReactiveDescribeHandle<T> {
-	readonly node: Node<T>;
-	dispose(): void;
-}
-
-/**
- * Explain-mode argument for {@link Graph.describe}. Passing
- * `{ explain: {...} }` reshapes the call into a causal-chain query (returns
- * {@link CausalChain} or `{ node: Node<CausalChain>; dispose }` when paired
- * with `reactive: true`).
- *
- * Tier 3.5 reactive-arg carve-out (F.9): `from`, `to`, `maxDepth`, and
- * `findCycle` accept `Node<...>` in addition to their plain types. When mixed,
- * static args pass through unchanged; reactive args drive recompute via the
- * same coalescer as the rest of `describe({ reactive: true })`.
- */
-export interface GraphDescribeExplainInput {
-	/** Upstream node path (the cause). `string | Node<string>`. */
-	from: string | Node<string>;
-	/** Downstream node path (the effect). `string | Node<string>`. */
-	to: string | Node<string>;
-	/** Maximum hop depth for the dep-walk (`number | Node<number>`). */
-	maxDepth?: number | Node<number>;
-	/**
-	 * When `true` and `from === to`, returns the shortest cycle through other
-	 * nodes (useful for diagnosing feedback loops, COMPOSITION-GUIDE §7).
-	 */
-	findCycle?: boolean | Node<boolean>;
-}
-
-/**
- * Reachable-mode argument for {@link Graph.describe}. Passing
- * `{ reachable: {...} }` reshapes the call into a reachability query — returns
- * `string[]` (paths sorted lexicographically) or {@link ReachableResult} when
- * `withDetail: true`.
- */
-export interface GraphDescribeReachableInput {
-	/** Start path (qualified node path). */
-	from: string;
-	/** Traversal direction. Ignored when `both: true`. */
-	direction: ReachableDirection;
-	/** Maximum hop depth from `from` (0 returns `[]`). */
-	maxDepth?: number;
-	/** Traverse both directions in one pass (union of upstream + downstream). */
-	both?: boolean;
-	/** Return the {@link ReachableResult} shape (paths + depths + truncation). */
-	withDetail?: boolean;
-}
-
-/** JSON snapshot from {@link Graph.describe} (GRAPHREFLY-SPEC §3.6, Appendix B). */
-export type GraphDescribeOutput = {
-	name: string;
-	nodes: Record<string, DescribeNodeOutput>;
-	edges: ReadonlyArray<{ from: string; to: string }>;
-	subgraphs: string[];
-	/**
-	 * Top-level factory identifier (Tier 1.5.3 Phase 2.5 — DG1=B). Present when
-	 * the graph was constructed by a Graph-returning factory that called
-	 * `Graph.prototype.tagFactory(name, args?)` (or set `GraphOptions.factory`).
-	 * Used by `compileSpec` for catalog-based reconstruction via
-	 * `catalog.graphFactories[factory]`.
-	 */
-	factory?: string;
-	/** JSON-serializable construction args paired with `factory`. */
-	factoryArgs?: unknown;
-	/**
-	 * Re-read the live graph with higher detail (Phase 3.3b).
-	 * Returns a new `GraphDescribeOutput`; the original remains a snapshot.
-	 * Present on live describe results; absent on deserialized snapshots.
-	 */
-	expand?: (detailOrFields: DescribeDetail | DescribeField[]) => GraphDescribeOutput;
-};
-
-/**
- * Persisted graph snapshot: {@link GraphDescribeOutput} plus optional format version
- * ({@link Graph.snapshot}, {@link Graph.restore}, {@link Graph.fromSnapshot}, {@link Graph.toObject},
- * {@link Graph.toJSONString} — §3.8).
- */
-export type GraphPersistSnapshot = GraphDescribeOutput & {
-	version?: number;
-};
-
-export type GraphFactoryContext = {
-	path: string;
-	type: DescribeNodeOutput["type"];
-	value: unknown;
-	meta: Record<string, unknown>;
-	deps: readonly string[];
-	resolvedDeps: readonly Node[];
-};
-
-export type GraphNodeFactory = (name: string, context: GraphFactoryContext) => Node;
-
-/**
- * Checkpoint record shape passed to `SnapshotStorageTier.save`. Written by
- * {@link Graph.attachSnapshotStorage} per-tier according to each tier's
- * `compactEvery` cadence.
- *
- * `mode: "full"` → full snapshot. Baseline anchor emitted on the first save
- *   and every `compactEvery`-th save thereafter. Sufficient to recover state
- *   on its own without WAL replay.
- * `mode: "diff"` → delta payload only, relative to this tier's most recent
- *   `"full"` baseline. Between compacts. Wire-efficient; requires WAL replay
- *   over the preceding `"full"` record to reconstruct state.
- *
- * Every record includes `seq` (per-tier monotonic counter), `timestamp_ns`
- * (wall-clock at flush time), and `format_version` (envelope version for
- * cross-version WAL replay).
- */
-export type GraphCheckpointRecord = {
-	name: string;
-	seq: number;
-	timestamp_ns: number;
-	format_version: number;
-	/**
-	 * DS-14.5.A delta #7 (Q3/Q8) — lifecycle scope tag. Absent / `"data"` for
-	 * the value-driven baseline+WAL path (the existing Phase 14.6 behavior;
-	 * lifecycle is then carried per-`WALFrame`). `"spec"` marks a
-	 * topology-version-triggered spec snapshot: a `mode:"full"` record whose
-	 * `snapshot` is the `describe({ detail:"spec" })` projection, written at
-	 * wave boundary only when `_topologyVersion` advanced (Q8 squelch). Restore
-	 * filters these via `restoreSnapshot({ lifecycle:["spec"] })`.
-	 */
-	lifecycle?: "spec" | "data";
-} & ({ mode: "full"; snapshot: GraphPersistSnapshot } | { mode: "diff"; diff: GraphWALDiff });
-
-/**
- * Paired tier slot for {@link Graph.attachSnapshotStorage} (Phase 14.6 —
- * DS-14-storage Q3 lock B).
- *
- * `snapshot` holds the `mode:"full"` baseline records (one per `compactEvery`
- * window). `wal` is the optional companion that captures intermediate
- * `WALFrame<T>` records between baselines so `Graph.restoreSnapshot({ mode:
- * "diff" })` can replay state at frame-level granularity. When `wal` is
- * omitted, the slot writes only baselines (effectively `compactEvery=1`) —
- * intermediate state is unrecoverable but the latest snapshot always is.
- */
-export type AttachSnapshotTierPair = {
-	snapshot: SnapshotStorageTier<GraphCheckpointRecord>;
-	/**
-	 * WAL companion. Must implement {@link BaseStorageTier.listByPrefix}
-	 * (the default `kvStorage` factory does). Omit to skip WAL emission and
-	 * fall back to baseline-only persistence.
-	 */
-	wal?: BaseStorageTier;
-};
-
-/**
- * Options for {@link Graph.restoreSnapshot} (Phase 14.6 — DS-14-storage Q9
- * lock).
- *
- * @category graph
- */
-export type GraphRestoreSnapshotOptions = {
-	/** Replay mode. Currently only `"diff"` (WAL replay) is implemented. */
-	readonly mode: "diff";
-	/**
-	 * Source of frames. Two forms:
-	 * - Pre-collected `AsyncIterable<WALFrame>` — caller assembled the WAL
-	 *   externally (fixture stream, network replay). Frame ordering must be
-	 *   stable across iterations and `frame_seq` values must be unique
-	 *   per stream — cross-tier merging without an explicit total-order
-	 *   resolver isn't supported in Phase 14.6.
-	 * - Tier handle `{ tier, walTier }` — load the latest `mode:"full"`
-	 *   baseline from `tier`, then enumerate WAL frames via
-	 *   `walTier.listByPrefix`. Both fields are required (Phase 14.6 fix
-	 *   B1 — the snapshot tier doesn't expose `listByPrefix`, so the
-	 *   former `walTier ?? tier` fallback was misleading).
-	 */
-	readonly source:
-		| AsyncIterable<WALFrame>
-		| {
-				readonly tier: SnapshotStorageTier<GraphCheckpointRecord>;
-				readonly walTier: BaseStorageTier;
-		  };
-	/**
-	 * DS-14 lifecycle filter. Default: full set `("spec" | "data" |
-	 * "ownership")`. Pass narrower set to scope the rewind ("spec-only",
-	 * "data-only", etc. — DS-14 PART 4).
-	 */
-	readonly lifecycle?: readonly ("spec" | "data" | "ownership")[];
-	/**
-	 * Point-in-time recovery — replay up to a specific `frame_seq` ceiling
-	 * (inclusive). Default: WAL tail.
-	 */
-	readonly targetSeq?: number;
-	/**
-	 * Torn-frame policy. Returns `"skip"` to drop the frame and continue,
-	 * `"abort"` to throw `RestoreError("torn-write-mid-stream")`. Default
-	 * (when omitted) is `"skip"` at WAL tail and `"abort"` mid-stream
-	 * (Q3 lock).
-	 */
-	readonly onTornWrite?: (info: {
-		readonly frame_seq: number;
-		readonly reason: string;
-	}) => "skip" | "abort";
-};
-
-/** Options for {@link Graph.attachSnapshotStorage}. */
-export type GraphAttachStorageOptions = {
-	/**
-	 * Before the first save, attempt to restore from the first tier whose
-	 * `load(graph.name)` hits. Runs asynchronously in the background for
-	 * async tiers; errors surface via `onError`. Default `false`.
-	 */
-	autoRestore?: boolean;
-	/**
-	 * Limit the subscription surface (scoped observe). By default
-	 * `attachSnapshotStorage` observes every node in the graph tree; on large graphs
-	 * that's thousands of subscriptions just for tier-gating. Pass a path
-	 * list (or a single glob) to observe only those nodes.
-	 */
-	paths?: readonly string[] | string;
-	/** Pre-save path-level filter — skip records triggered by paths that fail this predicate. */
-	filter?: (name: string, described: DescribeNodeOutput) => boolean;
-	/** Surfaced on tier save errors and autoRestore failures. */
-	onError?: (error: unknown, tier: SnapshotStorageTier<GraphCheckpointRecord>) => void;
-};
-
-/**
- * Event emitted by {@link Graph.topology} on every structural change to the
- * graph's own registry. Does NOT include value mutations (use `observe()` for
- * those) or transitively nested subgraph events (subscribe to each mounted
- * child's `topology` for that).
- *
- * - `"added"` — `name` is the local key registered via {@link Graph.add}
- *   (`nodeKind: "node"`) or {@link Graph.mount} (`nodeKind: "mount"`).
- * - `"removed"` — emitted AFTER {@link Graph.remove} completes teardown.
- *   `audit` is the full {@link GraphRemoveAudit} returned to the caller.
- */
-export type TopologyEvent =
-	| { kind: "added"; name: string; nodeKind: "node" | "mount" }
-	| {
-			kind: "removed";
-			name: string;
-			nodeKind: "node" | "mount";
-			audit: GraphRemoveAudit;
-	  }
-	| {
-			/**
-			 * @experimental Phase 13.8 — emitted by {@link Graph._rewire}.
-			 * Internal-only; surface may change.
-			 */
-			kind: "rewired";
-			name: string;
-			audit: GraphRewireAudit;
-	  };
-
-/**
- * Direction options for diagram exports. Mirrors `DiagramDirection` from
- * `@graphrefly/graphrefly/extra/render` (the renderers consume their own
- * structurally-identical type) — re-exported here so callers building
- * options for `Graph` ergonomics don't need a separate import.
- */
-export type GraphDiagramDirection = "TD" | "LR" | "BT" | "RL";
-
-/**
- * Snapshot format version (§3.8). Exported so the surface layer's
- * `saveSnapshot` writes the same `format_version` as
- * `Graph.attachSnapshotStorage` — one source of truth prevents silent wire
- * drift between auto-checkpoint and one-shot persistence paths.
- */
-export const SNAPSHOT_VERSION = 1;
-
-/**
- * Drain a disposer set iteratively — pop, remove, run. Disposers registered
- * mid-drain are picked up by the next iteration. Capped to guard against a
- * disposer that re-registers itself in an infinite loop. Exceptions are
- * surfaced via `console.error` rather than silently swallowed so leaks in
- * cleanup code remain visible.
- */
-function drainDisposers(set: Set<() => void | Promise<void>>, graphName: string): void {
-	const cap = Math.max(16, set.size * 4);
-	let iterations = 0;
-	while (set.size > 0) {
-		if (iterations++ >= cap) {
-			console.error(
-				`[Graph "${graphName}".destroy] disposer drain exceeded cap (${cap}); ${set.size} disposer(s) discarded`,
-			);
-			set.clear();
-			return;
-		}
-		const it = set.values().next();
-		if (it.done) return;
-		const dispose = it.value;
-		set.delete(dispose);
-		try {
-			dispose();
-		} catch (err) {
-			console.error(`[Graph "${graphName}".destroy] disposer threw:`, err);
-		}
-	}
-}
-
-/**
- * Async sibling of {@link drainDisposers}: `await`s each disposer's returned
- * Promise so in-flight async cleanup (e.g. a storage tier draining pending
- * WAL saves) completes before the drain returns. Used by
- * {@link Graph.destroyAsync}; the sync {@link Graph.destroy} keeps using
- * {@link drainDisposers} (fire-and-forget) for callers that don't await.
- */
-async function drainDisposersAsync(
-	set: Set<() => void | Promise<void>>,
-	graphName: string,
-): Promise<void> {
-	const cap = Math.max(16, set.size * 4);
-	let iterations = 0;
-	while (set.size > 0) {
-		if (iterations++ >= cap) {
-			console.error(
-				`[Graph "${graphName}".destroyAsync] disposer drain exceeded cap (${cap}); ${set.size} disposer(s) discarded`,
-			);
-			set.clear();
-			return;
-		}
-		const it = set.values().next();
-		if (it.done) return;
-		const dispose = it.value;
-		set.delete(dispose);
-		try {
-			await dispose();
-		} catch (err) {
-			console.error(`[Graph "${graphName}".destroyAsync] disposer threw:`, err);
-		}
-	}
-}
-
-/**
- * Duck-type a `Node<unknown>` from the `Actor | Node<Actor>` union so
- * {@link Graph.describe} can accept either form. Mirrors the local helpers in
- * `src/extra/resilience.ts:886` and `src/extra/sources.ts:509`, but also tests
- * for `down` so a user-defined `Actor` that happens to carry `cache` and a
- * function called `subscribe` cannot pass the test ({@link Actor} is
- * `{ type, id } & Record<string, unknown>` — open shape, so `subscribe` and
- * `cache` alone are not load-bearing).
- */
-function isActorNode(x: Actor | Node<Actor | null> | undefined): x is Node<Actor | null> {
-	return (
-		x != null &&
-		typeof x === "object" &&
-		"cache" in x &&
-		typeof (x as Node<Actor | null>).subscribe === "function" &&
-		typeof (x as Node<Actor | null>).down === "function"
-	);
-}
-
-/**
- * Resolve an `actor?: Actor | Node<Actor | null>` describe option to a plain
- * `Actor | undefined`. When a Node is supplied its current `cache` is read;
- * a `null`/`undefined` cache resolves to `undefined` (no scoping — full
- * visibility), so a `Node<Actor | null>` is sound without a cast (F8).
- * Static actors pass through. The `_describeReactive` path subscribes to the
- * node separately so describe re-derives on actor change.
- */
-function resolveActorOption(actor: Actor | Node<Actor | null> | undefined): Actor | undefined {
-	if (actor == null) return undefined;
-	if (isActorNode(actor)) return (actor.cache as Actor | null | undefined) ?? undefined;
-	return actor;
-}
-
-/**
- * Tier 3.5 (F.9 reactive primitive carve-out): generic Node-shape duck check
- * for `describe({ explain })` reactive args (`from`/`to: string | Node<string>`,
- * `maxDepth: number | Node<number>`, `findCycle: boolean | Node<boolean>`).
- * Mirrors `isActorNode` — tests for `subscribe` AND `cache` AND `down` so a
- * primitive value cannot accidentally pass as a Node.
- */
-function isExplainArgNode<T>(x: T | Node<T> | undefined): x is Node<T> {
-	return (
-		x != null &&
-		typeof x === "object" &&
-		"cache" in x &&
-		typeof (x as Node<T>).subscribe === "function" &&
-		typeof (x as Node<T>).down === "function"
-	);
-}
-
-function resolveExplainPath(p: string | Node<string>): string {
-	if (isExplainArgNode<string>(p)) return (p.cache as string | undefined) ?? "";
-	return p;
-}
-
-function resolveExplainNumber(n: number | Node<number>): number {
-	if (isExplainArgNode<number>(n)) return (n.cache as number | undefined) ?? 0;
-	return n;
-}
-
-function resolveExplainBoolean(b: boolean | Node<boolean>): boolean {
-	if (isExplainArgNode<boolean>(b)) return (b.cache as boolean | undefined) ?? false;
-	return b;
-}
-
-/**
- * Cheap graph-level V0 version fingerprint: concatenate `v.id@v.version` for
- * every node that carries V0 info. Used by {@link Graph.attachSnapshotStorage} to
- * short-circuit per-tier flushes when nothing versioned has changed since
- * the tier's last save. Non-versioned graphs produce an empty string so the
- * shortcut is a no-op for them (every scheduled flush writes).
- */
-function computeVersionFingerprint(nodes: Record<string, DescribeNodeOutput>): string {
-	const parts: string[] = [];
-	for (const path of Object.keys(nodes).sort()) {
-		const v = nodes[path]!.v;
-		if (v != null) parts.push(`${path}\t${v.id}\t${v.version}`);
-	}
-	return parts.join("\n");
-}
-
-/**
- * Validate the snapshot envelope: version, required keys, types. Aligned with
- * Python `_parse_snapshot_envelope`. Throws on invalid data.
- */
-function parseSnapshotEnvelope(data: GraphPersistSnapshot): void {
-	if (data.version !== SNAPSHOT_VERSION) {
-		throw new Error(
-			`unsupported snapshot version ${String(data.version)} (expected ${SNAPSHOT_VERSION})`,
-		);
-	}
-	for (const key of ["name", "nodes", "edges", "subgraphs"] as const) {
-		if (!(key in data)) {
-			throw new Error(`snapshot missing required key "${key}"`);
-		}
-	}
-	if (typeof data.name !== "string") {
-		throw new TypeError(`snapshot 'name' must be a string`);
-	}
-	if (typeof data.nodes !== "object" || data.nodes === null || Array.isArray(data.nodes)) {
-		throw new TypeError(`snapshot 'nodes' must be an object`);
-	}
-	if (!Array.isArray(data.edges)) {
-		throw new TypeError(`snapshot 'edges' must be an array`);
-	}
-	if (!Array.isArray(data.subgraphs)) {
-		throw new TypeError(`snapshot 'subgraphs' must be an array`);
-	}
-}
-
-/**
- * Structural deep equality — handles cycles, BigInt, Map, Set, Date, RegExp,
- * TypedArray, and nested objects/arrays. Used by `Graph.diff` to compare
- * node values without the cycle/BigInt/Map/Set footguns of `JSON.stringify`.
- *
- * Semantics: `Object.is` on primitives (so `NaN === NaN`, `-0 !== 0`), same
- * constructor required for object types, key-order-insensitive for plain
- * objects, order-sensitive for arrays + TypedArrays, unordered for Set,
- * key-equality for Map.
- */
-function deepEqual(a: unknown, b: unknown): boolean {
-	const seen = new WeakMap<object, WeakSet<object>>();
-	const walk = (x: unknown, y: unknown): boolean => {
-		if (Object.is(x, y)) return true;
-		if (x == null || y == null || typeof x !== "object" || typeof y !== "object") return false;
-		// Cycle handling: assume equal on re-encounter (cycles match iff they
-		// correspond structurally — standard "optimistic" deep-equal rule).
-		let seenRhs = seen.get(x as object);
-		if (seenRhs == null) {
-			seenRhs = new WeakSet();
-			seen.set(x as object, seenRhs);
-		}
-		if (seenRhs.has(y as object)) return true;
-		seenRhs.add(y as object);
-
-		const ctorA = (x as object).constructor;
-		const ctorB = (y as object).constructor;
-		if (ctorA !== ctorB) return false;
-
-		if (x instanceof Date) return (x as Date).getTime() === (y as Date).getTime();
-		if (x instanceof RegExp)
-			return (
-				(x as RegExp).source === (y as RegExp).source && (x as RegExp).flags === (y as RegExp).flags
-			);
-		if (Array.isArray(x)) {
-			const arrB = y as unknown[];
-			if ((x as unknown[]).length !== arrB.length) return false;
-			for (let i = 0; i < (x as unknown[]).length; i++) {
-				if (!walk((x as unknown[])[i], arrB[i])) return false;
-			}
-			return true;
-		}
-		if (x instanceof Map) {
-			const mB = y as Map<unknown, unknown>;
-			if ((x as Map<unknown, unknown>).size !== mB.size) return false;
-			for (const [k, v] of x as Map<unknown, unknown>) {
-				if (!mB.has(k) || !walk(v, mB.get(k))) return false;
-			}
-			return true;
-		}
-		if (x instanceof Set) {
-			const sB = y as Set<unknown>;
-			if ((x as Set<unknown>).size !== sB.size) return false;
-			// O(n²) fallback — Sets have no ordering, and walking each pair
-			// is the only way to support structural equality on non-primitive
-			// members. Acceptable: diff scale is describe-output-sized.
-			for (const v of x as Set<unknown>) {
-				let found = false;
-				for (const w of sB) {
-					if (walk(v, w)) {
-						found = true;
-						break;
-					}
-				}
-				if (!found) return false;
-			}
-			return true;
-		}
-		if (ArrayBuffer.isView(x)) {
-			const taA = x as unknown as { length: number; [i: number]: number };
-			const taB = y as unknown as { length: number; [i: number]: number };
-			if (taA.length !== taB.length) return false;
-			for (let i = 0; i < taA.length; i++) if (taA[i] !== taB[i]) return false;
-			return true;
-		}
-		// Plain object: same key-set, same values (key order irrelevant).
-		const keysA = Object.keys(x as Record<string, unknown>);
-		const keysB = Object.keys(y as Record<string, unknown>);
-		if (keysA.length !== keysB.length) return false;
-		const setB = new Set(keysB);
-		for (const k of keysA) {
-			if (!setB.has(k)) return false;
-			if (!walk((x as Record<string, unknown>)[k], (y as Record<string, unknown>)[k])) return false;
-		}
-		return true;
-	};
-	return walk(a, b);
-}
-
-// ---------------------------------------------------------------------------
-//  describe()-format renderers — moved to `src/extra/render/` per Tier 2.1 A2.
-//
-//  The ex-`describe({ format: ... })` dispatch is gone. Use the pure
-//  renderers (`graphSpecToMermaid`, `graphSpecToD2`, `graphSpecToAscii`,
-//  `graphSpecToPretty`, `graphSpecToJson`, `graphSpecToMermaidUrl`) from
-//  `@graphrefly/graphrefly/extra/render` directly on a describe snapshot,
-//  or wrap with `derived` for live formatted output.
-// ---------------------------------------------------------------------------
-
-function escapeRegexLiteral(value: string): string {
-	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-
-function globToRegex(pattern: string): RegExp {
-	let re = "^";
-	for (let i = 0; i < pattern.length; i += 1) {
-		const ch = pattern[i]!;
-		if (ch === "*") {
-			re += ".*";
-			continue;
-		}
-		if (ch === "?") {
-			re += ".";
-			continue;
-		}
-		if (ch === "[") {
-			const end = pattern.indexOf("]", i + 1);
-			if (end <= i + 1) {
-				re += "\\[";
-				continue;
-			}
-			let cls = pattern.slice(i + 1, end);
-			if (cls.startsWith("!")) cls = `^${cls.slice(1)}`;
-			cls = cls.replace(/\\/g, "\\\\");
-			re += `[${cls}]`;
-			i = end;
-			continue;
-		}
-		re += escapeRegexLiteral(ch);
-	}
-	re += "$";
-	return new RegExp(re);
-}
-
-const OBSERVE_ANSI_THEME: Required<ObserveTheme> = {
-	data: "\u001b[32m",
-	dirty: "\u001b[33m",
-	resolved: "\u001b[36m",
-	invalidate: "\u001b[93m",
-	pause: "\u001b[90m",
-	resume: "\u001b[96m",
-	complete: "\u001b[34m",
-	error: "\u001b[31m",
-	teardown: "\u001b[91m",
-	derived: "\u001b[35m",
-	path: "\u001b[90m",
-	reset: "\u001b[0m",
-};
-
-const OBSERVE_NO_COLOR_THEME: Required<ObserveTheme> = {
-	data: "",
-	dirty: "",
-	resolved: "",
-	invalidate: "",
-	pause: "",
-	resume: "",
-	complete: "",
-	error: "",
-	teardown: "",
-	derived: "",
-	path: "",
-	reset: "",
-};
-
-function describeData(value: unknown): string {
-	if (typeof value === "string") return JSON.stringify(value);
-	if (typeof value === "number" || typeof value === "boolean" || value == null)
-		return String(value);
-	try {
-		return JSON.stringify(value);
-	} catch {
-		return "[unserializable]";
-	}
-}
-
-function resolveObserveTheme(theme: ObserveOptions["theme"]): Required<ObserveTheme> {
-	if (theme === "none") return OBSERVE_NO_COLOR_THEME;
-	if (theme === "ansi" || theme == null) return OBSERVE_ANSI_THEME;
-	return {
-		data: theme.data ?? "",
-		dirty: theme.dirty ?? "",
-		resolved: theme.resolved ?? "",
-		invalidate: theme.invalidate ?? "",
-		pause: theme.pause ?? "",
-		resume: theme.resume ?? "",
-		complete: theme.complete ?? "",
-		error: theme.error ?? "",
-		teardown: theme.teardown ?? "",
-		derived: theme.derived ?? "",
-		path: theme.path ?? "",
-		reset: theme.reset ?? "",
-	};
-}
-
-/** Resolve observe `detail` level into effective boolean flags. */
-function resolveObserveDetail(opts?: ObserveOptions): ObserveOptions {
-	if (opts == null) return {};
-	const detail = opts.detail;
-	if (detail === "full") {
-		return {
-			...opts,
-			structured: opts.structured ?? true,
-			timeline: opts.timeline ?? true,
-			causal: opts.causal ?? true,
-			derived: opts.derived ?? true,
-		};
-	}
-	if (detail === "minimal") {
-		return { ...opts, structured: opts.structured ?? true };
-	}
-	// `stage-log` format is pipeline-oriented — needs elapsed-time stamps on
-	// every event, so auto-enable `timeline` unless the caller opts out.
-	if (opts.format === "stage-log") {
-		return { ...opts, structured: opts.structured ?? true, timeline: opts.timeline ?? true };
-	}
-	return opts;
-}
-
-/**
- * Option shapes that trigger structured-mode dispatch in {@link Graph.observe}.
- * Presence of any of these fields (truthy) → returns {@link ObserveResult};
- * otherwise `observe()` returns the raw-stream variants.
- */
-export type StructuredTriggers = {
-	structured?: true;
-	timeline?: true;
-	causal?: true;
-	derived?: true;
-	format?: "pretty" | "json" | "stage-log";
-	detail?: "minimal" | "full";
-};
-
-/** {@link Graph.observe} on a single node or meta path — sink receives plain message batches. */
-export type GraphObserveOne = {
-	subscribe(sink: NodeSink): () => void;
-	/** Send messages upstream toward the observed node's sources (e.g. PAUSE/RESUME). */
-	up(messages: Messages): void;
-};
-
-/**
- * {@link Graph.observe} on the whole graph — sink receives each batch with the qualified source path.
- * Subscription order follows code-point sort on paths (mounts-first walk, then sorted locals/meta).
- */
-export type GraphObserveAll = {
-	subscribe(sink: (nodePath: string, messages: Messages) => void): () => void;
-	/** Send messages upstream toward a specific observed node's sources (e.g. PAUSE/RESUME). */
-	up(path: string, messages: Messages): void;
-};
-
-/**
- * Detail level for `observe()` progressive disclosure (Phase 3.3b).
- * - `"minimal"` — DATA events only, no timestamps, no causal info.
- * - `"standard"` — all message types (DATA, DIRTY, RESOLVED, INVALIDATE,
- *   PAUSE, RESUME, COMPLETE, ERROR, TEARDOWN).
- * - `"full"` — standard + timeline + causal + derived.
- */
-export type ObserveDetail = "minimal" | "standard" | "full";
-
-/**
- * Tier name for {@link ObserveEvent} filtering. Aligns with spec §1.2 message
- * tier semantics — each `ObserveTier` corresponds to one or more protocol
- * message types. Used by {@link ObserveOptions.tiers} to scope observation to
- * a subset of event categories (e.g. `tiers: ["error", "complete", "teardown"]`
- * for failure-only health monitoring).
- */
-export type ObserveTier = ObserveEvent["type"];
-
-/**
- * Coalesced batch of {@link ObserveEvent}s emitted as one DATA wave per
- * outermost batch flush by `Graph.observe({ reactive: true })`.
- *
- * Disjoint from `DescribeChangeset` (the topology-layer envelope). Each event
- * carries its own `path` so consumers route per-path without unwrapping the
- * envelope first. `flushedAt_ns` is monotonic via `core/clock.ts`.
- */
-export type ObserveChangeset = {
-	events: ReadonlyArray<ObserveEvent>;
-	flushedAt_ns: number;
-};
-
-/** Options for structured observation modes on {@link Graph.observe}. */
-export type ObserveOptions = {
-	actor?: Actor;
-	/** Return an {@link ObserveResult} accumulator instead of a raw stream. */
-	structured?: boolean;
-	/** Include causal trace info (which dep triggered each recomputation). */
-	causal?: boolean;
-	/** Include timestamps and batch context on each event. */
-	timeline?: boolean;
-	/** Include per-evaluation dep snapshots for compute/derived nodes. */
-	derived?: boolean;
-	/**
-	 * Detail level (Phase 3.3b). Individual flags (`causal`, `timeline`, `derived`)
-	 * override. `"full"` implies all three plus structured.
-	 * `"minimal"` filters to DATA-only events.
-	 */
-	detail?: ObserveDetail;
-	/**
-	 * Filter observed events to these tiers only. When omitted, all event types
-	 * are delivered. Applies to both the structured callback and the reactive
-	 * variants (`observe({ reactive: true })`).
-	 *
-	 * Example: `tiers: ["error", "complete", "teardown"]` for failure-only
-	 * health monitoring; `tiers: ["data"]` for value-flow tracking.
-	 */
-	tiers?: readonly ObserveTier[];
-	/**
-	 * Return a `Node<ObserveChangeset>` that emits one DATA wave per outermost
-	 * batch flush, with all observed events for that flush coalesced into a
-	 * single changeset. Auto-enables structured mode (the reactive variant
-	 * delivers {@link ObserveEvent}s, not raw messages).
-	 *
-	 * Coalescing matches `describe({ reactive: true })`'s `registerBatchFlushHook`
-	 * mechanism — N events in one batch → one changeset DATA wave at flush.
-	 */
-	reactive?: boolean;
-	/** Optional name for the reactive changeset node when `reactive: true`. */
-	reactiveName?: string;
-	/**
-	 * Tier 1.5.D2 — return a `Node<GraphChange>` that emits one DATA per
-	 * discrete graph change event (data flow, topology, batch boundaries).
-	 *
-	 * Disjoint from `reactive: true` (which returns coalesced
-	 * `ObserveChangeset`s of `ObserveEvent`s) — `changeset: true` emits a
-	 * different stream shape. The two modes are not combinable in one call;
-	 * setting both throws.
-	 *
-	 * Each event is a {@link GraphChange} carrying a common envelope
-	 * (`version`, `timestamp_ns`, `scope`) plus variant-specific payload.
-	 * Variants:
-	 * - **Core data flow:** `data` (with `fromPath` + `fromDepIndex` edge
-	 *   attribution), `dirty`, `resolved`, `error`, `complete`, `teardown`.
-	 * - **Topology:** `node-added`, `node-removed`, `mount`, `unmount`.
-	 * - **Batch boundaries:** `batch-start`, `batch-end`. A `batch-start`
-	 *   precedes the first event inside a batch; `batch-end` follows the
-	 *   last event when the batch flushes.
-	 *
-	 * The envelope shape is forward-compatible with post-1.0 store-level
-	 * `StoreOp` variants (§8.7 Delta checkpoints & WAL) — adding more
-	 * variants is a non-breaking append.
-	 *
-	 * Designed as the input layer for `topologyView` (Tier 1.5.D3): combine
-	 * `node-added` / `node-removed` for layout invalidation with `data` events
-	 * for per-frame edge highlighting.
-	 */
-	changeset?: boolean;
-	/** Optional name for the changeset node when `changeset: true`. */
-	changesetName?: string;
-
-	// ——— Format / logging (merged from spy) ———
-
-	/**
-	 * When set, auto-enables structured mode and attaches a logger.
-	 * - `"pretty"` — colored one-line output per event.
-	 * - `"json"` — one JSON object per event.
-	 * - `"stage-log"` — pipeline-stage-labeled output for multi-node
-	 *   observers. Auto-enables `timeline: true` so each line carries an
-	 *   elapsed-seconds offset from the subscription. Provide a
-	 *   {@link stageLabels} map to label each observed path; paths without a
-	 *   mapping fall back to the path string.
-	 */
-	format?: "pretty" | "json" | "stage-log";
-	/** Sink for rendered lines (`console.log` by default). Only used when `format` is set. */
-	logger?: (line: string, event: ObserveEvent) => void;
-	/** Keep only these event types in formatted output. Only used when `format` is set. */
-	includeTypes?: ObserveEvent["type"][];
-	/** Exclude these event types from formatted output. Only used when `format` is set. */
-	excludeTypes?: ObserveEvent["type"][];
-	/** Built-in color preset (`ansi` default) or explicit color tokens. Only used when `format` is set. */
-	theme?: ObserveThemeName | ObserveTheme;
-	/**
-	 * Stage labels for `format: "stage-log"`. Keys are observe paths; values
-	 * are short stage names (e.g. `{ "intake::latest": "INTAKE" }`). Paths
-	 * without a mapping render under the path string itself. Ignored for
-	 * other formats.
-	 */
-	stageLabels?: Record<string, string>;
-	/**
-	 * Cap the `events` buffer. When set, the result uses a {@link RingBuffer}
-	 * under the hood: oldest events are dropped on overflow. Unbounded when
-	 * omitted (default).
-	 */
-	maxEvents?: number;
-};
-
-/** Accumulated observation result (structured mode). */
-export type ObserveResult<T = unknown> = AsyncIterable<ObserveEvent> & {
-	/** Latest DATA value by observed path. */
-	readonly values: Record<string, T>;
-	/** Number of DIRTY messages received. */
-	readonly dirtyCount: number;
-	/** Number of RESOLVED messages received. */
-	readonly resolvedCount: number;
-	/** Number of INVALIDATE messages received (tier 1 cache-clear). */
-	readonly invalidateCount: number;
-	/** Number of PAUSE messages received (tier 2 backpressure). */
-	readonly pauseCount: number;
-	/** Number of RESUME messages received (tier 2 backpressure). */
-	readonly resumeCount: number;
-	/** Number of TEARDOWN messages received (tier 5 permanent cleanup). */
-	readonly teardownCount: number;
-	/**
-	 * All events in order — ring-buffered when `options.maxEvents` is set,
-	 * unbounded otherwise. Always materialized as an `ObserveEvent[]`
-	 * snapshot on read.
-	 */
-	readonly events: ObserveEvent[];
-	/** True if any observed node sent COMPLETE without prior ERROR on that node. */
-	readonly anyCompletedCleanly: boolean;
-	/** True if any observed node sent ERROR. */
-	readonly anyErrored: boolean;
-	/** True if at least one COMPLETE received and no ERROR from any observed node. */
-	readonly completedWithoutErrors: boolean;
-	/**
-	 * Attach a live listener that fires for each event as it arrives.
-	 * Returns an unsubscribe fn. Independent of the `events` buffer.
-	 */
-	onEvent(listener: (event: ObserveEvent) => void): () => void;
-	/** Stop observing. */
-	dispose(): void;
-	/**
-	 * Resubscribe with higher detail (Phase 3.3b).
-	 * Disposes current observation, returns new `ObserveResult` with merged options.
-	 */
-	expand(
-		extra: Partial<Pick<ObserveOptions, "causal" | "timeline" | "derived">> | ObserveDetail,
-	): ObserveResult<T>;
-};
-
-/** Fields common to every {@link ObserveEvent} variant. */
-export interface ObserveEventBase {
-	path?: string;
-	/** Optional `timeline` context — wall-clock when `options.timeline === true`. */
-	timestamp_ns?: number;
-	in_batch?: boolean;
-	/** Monotonically increasing counter per subscribe-callback invocation. All events in one delivery share the same id. */
-	batch_id?: number;
-	/**
-	 * Attribution for `data`/`error` events (B9 — actor threading). When
-	 * the originating `node.down(...)` call supplied an `actor` via
-	 * `NodeTransportOptions`, it's forwarded here as read from
-	 * `Node.lastMutation`. Internal / unattributed writes stamp the
-	 * library's `DEFAULT_ACTOR` (`{type: "system", id: ""}`) rather than
-	 * being silently dropped, so downstream policy/audit consumers can
-	 * evaluate policies against a well-formed actor in every case.
-	 *
-	 * Not populated for tier-1/tier-2 protocol events (`dirty`, `resolved`,
-	 * `pause`, `resume`, `invalidate`, `teardown`) — those don't carry
-	 * caller attribution.
-	 */
-	actor?: Actor;
-}
-
-/** Optional `causal` context present on `data`/`resolved`/`derived` events. */
-export interface ObserveCausalContext {
-	trigger_dep_index?: number;
-	trigger_dep_name?: string;
-	/**
-	 * V0 version of the triggering dep at observation time (§6.0b).
-	 * This is the dep's post-emission version (after its own `advanceVersion`),
-	 * not the pre-emission version that caused this node's recomputation.
-	 */
-	trigger_version?: { id: string; version: number };
-	/**
-	 * One scalar per dep: the last value that arrived in the current wave,
-	 * or the pre-wave cached value for deps that didn't fire. Convenient
-	 * for single-value-wave tooling (the common case).
-	 */
-	dep_values?: unknown[];
-	/**
-	 * Full per-dep batches for the wave that fired the fn — `dep_batches[i]`
-	 * is the array of values dep `i` delivered this wave (`undefined` for
-	 * deps that didn't fire). Use this to distinguish a single-value wave
-	 * from a multi-value wave; `dep_values` compresses each batch to its
-	 * last element and hides that difference.
-	 */
-	dep_batches?: ReadonlyArray<ReadonlyArray<unknown> | undefined>;
-}
-
-/** A single event in the structured observation log (discriminated on `type`). */
-export type ObserveEvent =
-	| (ObserveEventBase & ObserveCausalContext & { type: "data"; data: unknown })
-	| (ObserveEventBase & { type: "dirty" })
-	| (ObserveEventBase & ObserveCausalContext & { type: "resolved" })
-	| (ObserveEventBase & { type: "invalidate" })
-	| (ObserveEventBase & { type: "pause"; lockId: unknown })
-	| (ObserveEventBase & { type: "resume"; lockId: unknown })
-	| (ObserveEventBase & { type: "complete" })
-	| (ObserveEventBase & { type: "error"; data: unknown })
-	| (ObserveEventBase & { type: "teardown" })
-	| (ObserveEventBase & ObserveCausalContext & { type: "derived"; dep_values: unknown[] });
-
-/** Built-in color preset names for observe `format` rendering. */
-export type ObserveThemeName = "none" | "ansi";
-
-/** ANSI/style overrides for observe `format` event rendering. */
-export type ObserveTheme = Partial<Record<ObserveEvent["type"] | "path" | "reset", string>>;
-
-/**
- * Reject characters that would collide with internal serialization or path
- * grammar. Control chars (0x00–0x1F, 0x7F) break `describe()` key stability,
- * diagram rendering, and any tab-delimited log/trace format. Keep the test
- * tight so the error message points at the first offending code point.
- */
-function assertNoControlChars(name: string, graphName: string, label: string): void {
-	for (let i = 0; i < name.length; i++) {
-		const c = name.charCodeAt(i);
-		if (c < 0x20 || c === 0x7f) {
-			throw new Error(
-				`Graph "${graphName}": ${label} "${name}" must not contain control character (U+${c.toString(16).padStart(4, "0").toUpperCase()} at index ${i})`,
-			);
-		}
-	}
-}
-
-/**
- * Validate a registerable local name (`add`, `mount`, `remove` inputs):
- * non-empty, no `::` separator, not the reserved `__meta__` segment, and no
- * control characters.
- */
-function assertRegisterableName(name: string, graphName: string, label: string): void {
-	if (name === "") {
-		throw new Error(`Graph "${graphName}": ${label} name must be non-empty`);
-	}
-	if (name.includes(PATH_SEP)) {
-		throw new Error(
-			`Graph "${graphName}": ${label} "${name}" must not contain '${PATH_SEP}' (path separator)`,
-		);
-	}
-	if (name === GRAPH_META_SEGMENT) {
-		throw new Error(
-			`Graph "${graphName}": ${label} name "${GRAPH_META_SEGMENT}" is reserved for meta companion paths`,
-		);
-	}
-	assertNoControlChars(name, graphName, label);
-}
-
-function splitPath(path: string, graphName: string): string[] {
-	if (path === "") {
-		throw new Error(`Graph "${graphName}": resolve path must be non-empty`);
-	}
-	const segments = path.split(PATH_SEP);
-	for (const s of segments) {
-		if (s === "") {
-			throw new Error(`Graph "${graphName}": resolve path has empty segment`);
-		}
-	}
-	return segments;
-}
-
-/**
- * Strip messages that are not marked `metaPassthrough` on the given config
- * (spec §2.3 Companion lifecycle). Built-ins: `INVALIDATE`, `COMPLETE`,
- * `ERROR`, `TEARDOWN` are registered `metaPassthrough: false` in
- * `registerBuiltins`. Custom types default to `true` (meta receives them).
- *
- * To target a meta node directly without the filter, call `meta.down(...)`.
- *
- * Returns empty array when nothing remains.
- */
-function filterMetaMessages(messages: Messages, config: GraphReFlyConfig): Messages {
-	// Fast path: if every message is metaPassthrough, reuse the input array.
-	let anyFiltered = false;
-	for (const m of messages) {
-		if (!config.isMetaPassthrough(m[0])) {
-			anyFiltered = true;
-			break;
-		}
-	}
-	if (!anyFiltered) return messages;
-	const kept = messages.filter((m) => config.isMetaPassthrough(m[0]));
-	return kept as unknown as Messages;
-}
-
-/**
- * TEARDOWN every node in a mounted graph tree (depth-first into mounts).
- * Errors from individual node teardowns are swallowed — a single bad handler
- * must not abort cleanup of the rest of the subtree.
- */
-function teardownMountedGraph(root: Graph): void {
-	for (const child of root._mounts.values()) {
-		teardownMountedGraph(child);
-	}
-	for (const n of root._nodes.values()) {
-		try {
-			n.down([[TEARDOWN]] satisfies Messages, { internal: true });
-		} catch {
-			/* resilience: keep tearing down siblings */
-		}
-	}
-	// A1 (QA fix 2026-05-01): release C3 ownership stamps and mark
-	// `_destroyed = true` on the unmounted root + its descendant subtree.
-	// Without this, every node inside the unmounted subgraph keeps
-	// `GRAPH_OWNER === root` even though the user's intent on
-	// `parent.remove(name)` is "this child is fully detached." Re-adding
-	// any of those nodes to a different Graph would otherwise throw
-	// `cross-graph-ownership` despite the manifest detachment. Affects
-	// `processManager.dispose()` (via `cqrsGraph.remove(mountName)`) and
-	// any other dispose path that tears down a mounted child.
-	root._releaseOwnershipStampsPublic();
-	root._markDestroyed();
-}
-
-/**
- * Named container for nodes and explicit edges (GRAPHREFLY-SPEC §3.1–§3.7).
- *
- * Qualified paths use `::` as the segment separator (for example `parent::child::node`).
- *
- * Edges are pure wires: `connect` only validates wiring — the target must already list the source in
- * its dependency array; no transforms run on the edge.
- *
- * @example
- * ```ts
- * import { Graph, state } from "@graphrefly/pure-ts";
- *
- * const g = new Graph("app");
- * g.add(state(0, { name: "counter" }));
- * ```
- *
- * @category graph
- */
-/**
- * @internal Module-scoped ownership stamp (C3 — cross-graph Node ownership).
- *
- * A Node may belong to **at most one** non-destroyed Graph at a time. Set on
- * {@link Graph.add} (and during {@link Graph.mount}'s defensive child-walk),
- * cleared synchronously on {@link Graph.remove} of that name and on
- * {@link Graph.destroy} / `_destroyClearOnly` for the owning graph. Cleared
- * BEFORE the TEARDOWN cascade so a "freshly-detached" Node can be re-registered
- * on a different Graph in the same tick without surprising the caller.
- *
- * Standalone `node([], fn)` usage that never goes through any `Graph.add`
- * carries no stamp and is unaffected.
- */
-const GRAPH_OWNER = new WeakMap<Node, Graph>();
-
-export class Graph {
-	readonly name: string;
-	readonly opts: Readonly<GraphOptions>;
-	/** Protocol config bound to this graph (defaults to `defaultConfig`). */
-	readonly config: GraphReFlyConfig;
-	/** @internal — exposed for {@link teardownMountedGraph} and cross-graph helpers. */
-	readonly _nodes = new Map<string, Node>();
-	/**
-	 * @internal Reverse lookup for duplicate-instance detection in
-	 * {@link Graph.add} — O(1) replacement for an O(n) scan of `_nodes`.
-	 * Weak so nodes can be GC'd after `remove()` even if a caller keeps the
-	 * map alive via some unusual pattern.
-	 */
-	private readonly _nodeToName = new WeakMap<Node, string>();
-	/** @internal — exposed for {@link teardownMountedGraph}. */
-	readonly _mounts = new Map<string, Graph>();
-	/**
-	 * @internal Parent graph if this instance is mounted. `undefined` when
-	 * this is the root or when the graph has been unmounted. Used for
-	 * reparenting rejection + O(depth) ancestor walks.
-	 */
-	_parent: Graph | undefined = undefined;
-	private readonly _storageDisposers = new Set<() => void | Promise<void>>();
-	private readonly _disposers = new Set<() => void>();
-	/** @internal Set in {@link destroy} / `_destroyClearOnly`; surfaced via {@link destroyed}. */
-	private _destroyed = false;
-	/**
-	 * @internal Lazy `TopologyEvent` producer. Created on first `.topology`
-	 * access. Zero cost until something subscribes — producer fn only runs when
-	 * the first sink attaches, registering one handler into
-	 * {@link Graph._topologyEmitters}.
-	 */
-	private _topology: Node<TopologyEvent> | undefined;
-	/**
-	 * @internal Active emit handlers for the topology producer. Each entry is
-	 * the closure registered by the producer fn on activation; cleared on
-	 * deactivation. `_emitTopology` broadcasts through every entry (there is at
-	 * most one per activation cycle of the producer).
-	 */
-	private readonly _topologyEmitters = new Set<(event: TopologyEvent) => void>();
-
-	/**
-	 * @param name - Non-empty graph id (must not contain `::` and must not
-	 *   equal the reserved meta segment `__meta__`).
-	 * @param opts - See {@link GraphOptions}. Stored frozen on the instance.
-	 */
-	/** Tier 1.5.3 Phase 2.5 — top-level factory tag for Graph-returning factories. */
-	private _factory?: string;
-	private _factoryArgs?: unknown;
-
-	/**
-	 * Monotonic topology-mutation counter (DS-14.5.A Q1 lock; spec-snapshot
-	 * trigger). Bumped O(1) at every structural mutation: `add`, `remove`
-	 * (node + mount-cycle/unmount path), `mount`, `tagFactory`, and
-	 * `setDeps`/`_setDeps` rewire. Read at wave boundary by
-	 * `attachSnapshotStorage`'s spec-snapshot hook (Q8 squelch:
-	 * `_topologyVersion === lastPersistedSpecVersion` → skip).
-	 *
-	 * **Distinct from `_versioningLevel` / `_schemaVersion`** (V0 codec /
-	 * migration concerns) — this counter tracks *shape* drift only, never
-	 * value or schema. Not persisted in the snapshot envelope; it is a
-	 * runtime-local dirty signal, recomputed from zero on a fresh process.
-	 */
-	private _topologyVersion = 0;
-
-	/**
-	 * @internal O(1) topology-version bump. Called from every structural
-	 * mutation site. Pure increment — no allocation, no emission (the
-	 * spec-snapshot consumer reads this lazily at wave boundary; eager
-	 * emission here would re-introduce the per-wave noise Q8 rejects).
-	 */
-	private _bumpTopologyVersion(): void {
-		this._topologyVersion += 1;
-	}
-
-	/**
-	 * Current topology-mutation version (DS-14.5.A Q1). Increments by 1 per
-	 * structural mutation. Inspection / test surface for the spec-snapshot
-	 * trigger; consumers gate persistence on equality with their last
-	 * persisted value rather than diffing the graph.
-	 *
-	 * @category observability
-	 */
-	get topologyVersion(): number {
-		return this._topologyVersion;
-	}
-
-	constructor(name: string, opts?: GraphOptions) {
-		if (name === "") {
-			throw new Error("Graph name must be non-empty");
-		}
-		if (name.includes(PATH_SEP)) {
-			throw new Error(`Graph name must not contain '${PATH_SEP}' (got "${name}")`);
-		}
-		if (name === GRAPH_META_SEGMENT) {
-			throw new Error(`Graph name "${GRAPH_META_SEGMENT}" is reserved for meta companion paths`);
-		}
-		this.name = name;
-		this.opts = Object.freeze({ ...(opts ?? {}) });
-		this.config = opts?.config ?? defaultConfig;
-		this._traceRing = new RingBuffer<TraceEntry>(opts?.traceCapacity ?? 1000);
-		if (opts?.versioning != null) {
-			// No nodes yet, but keep the API consistent — apply at construction
-			// so opts.versioning is honored as a startup default via this helper.
-			this.setVersioning(opts.versioning);
-		}
-		if (typeof opts?.factory === "string") {
-			this._factory = opts.factory;
-			if (opts.factoryArgs !== undefined) this._factoryArgs = opts.factoryArgs;
-		}
-	}
-
-	/**
-	 * Tag this graph with its constructing factory's identifier and args.
-	 * Used by Graph-returning factories (`agentMemory`, `harnessLoop`,
-	 * `pipelineGraph`, etc.) so `describe()` exposes provenance and
-	 * `compileSpec` can delegate reconstruction to
-	 * `catalog.graphFactories[factory]`. Tier 1.5.3 Phase 2.5 (DG1=B).
-	 *
-	 * `factoryArgs` should be JSON-serializable. For non-JSON fields
-	 * (LLMAdapter, callbacks, etc.), use {@link placeholderArgs} to
-	 * substitute descriptive strings (DG2=ii).
-	 *
-	 * Returns `this` for fluent chaining inside factory bodies.
-	 */
-	tagFactory(factory: string, factoryArgs?: unknown): this {
-		this._factory = factory;
-		// QA F8: always assign — second call without args clears stale args
-		// (otherwise `tagFactory("a", {x:1})` then `tagFactory("b")` keeps {x:1}
-		// paired with "b", which is mismatched provenance).
-		this._factoryArgs = factoryArgs;
-		// DS-14.5.A Q1 — `tagFactory` mutates the spec projection (`meta.factory`
-		// surfaces in `describe({detail:"spec"})`), so it is a topology-dirty
-		// site even though it emits no `TopologyEvent`.
-		this._bumpTopologyVersion();
-		return this;
-	}
-
-	/**
-	 * Walk ancestors up through `_parent`. Returns the chain starting at this
-	 * instance, ending at the root (a graph with no parent). O(depth).
-	 *
-	 * @param includeSelf - Include `this` in the chain (default `true`).
-	 */
-	ancestors(includeSelf = true): Graph[] {
-		const out: Graph[] = [];
-		let p: Graph | undefined = includeSelf ? this : this._parent;
-		while (p != null) {
-			out.push(p);
-			p = p._parent;
-		}
-		return out;
-	}
-
-	// ——————————————————————————————————————————————————————————————
-	//  Topology companion (structural-change event stream)
-	// ——————————————————————————————————————————————————————————————
-
-	/**
-	 * Reactive stream of structural changes to this graph's own registry
-	 * (add / mount / remove). Value mutations live on `observe()`; this
-	 * companion only fires when the topology shape changes.
-	 *
-	 * Lazy: the underlying node is created on first access and activates when
-	 * something subscribes. No emission replay — late subscribers do not
-	 * receive historical events and should snapshot via {@link Graph.describe}
-	 * before listening for incremental changes. Events that fire while the
-	 * producer has zero subscribers are dropped (no retention).
-	 *
-	 * Own-graph only: a parent's `topology` does NOT emit for structural
-	 * changes inside a mounted child. Transitive consumers subscribe to each
-	 * child's topology separately (recurse through `topology`'s own "added"
-	 * events with `nodeKind: "mount"` to discover new children).
-	 *
-	 * See {@link TopologyEvent} for payload shape.
-	 *
-	 * @category observability
-	 */
-	get topology(): Node<TopologyEvent> {
-		if (this._topology == null) {
-			this._topology = node<TopologyEvent>(
-				(_data, actions) => {
-					const handler = (event: TopologyEvent): void => {
-						actions.emit(event);
-					};
-					this._topologyEmitters.add(handler);
-					return {
-						onDeactivation: () => {
-							this._topologyEmitters.delete(handler);
-						},
-					};
-				},
-				{ name: `${this.name}_topology`, describeKind: "producer" },
-			);
-		}
-		return this._topology;
-	}
-
-	/**
-	 * @internal Fire a {@link TopologyEvent} to every active subscriber of
-	 * `this.topology`. No-op when the topology node has never been accessed or
-	 * currently has no sinks — zero cost for graphs nobody observes.
-	 */
-	private _emitTopology(event: TopologyEvent): void {
-		if (this._topologyEmitters.size === 0) return;
-		// Snapshot to array so handler additions during iteration don't visit
-		// the freshly-added handler in this same loop (e.g., `_observeReactive`
-		// late-subscribe path may register/unregister handlers indirectly).
-		for (const h of [...this._topologyEmitters]) h(event);
-	}
-
-	// ——————————————————————————————————————————————————————————————
-	//  Node registry
-	// ——————————————————————————————————————————————————————————————
-
-	/**
-	 * Registers a node under a local name. Fails if the name is already used,
-	 * reserved by a mount, the same node instance is already registered, or
-	 * the node is torn down.
-	 *
-	 * Returns the registered node so callers can chain:
-	 * `const counter = g.add(state(0, { name: "counter" }))`.
-	 *
-	 * **Signature:** `add(node, { name?, annotation? })`. Name lives in opts;
-	 * falls back to `node.name` from the node's own options. Throws if neither
-	 * is a non-empty string.
-	 *
-	 * The optional `opts.annotation` installs an initial
-	 * `graph.trace(name, annotation)` entry — same effect as calling
-	 * `graph.trace` right after, but reads naturally next to the registration.
-	 *
-	 * **C3 — cross-graph ownership.** A Node instance may belong to at most
-	 * one non-destroyed Graph at a time. Calling `add` for a Node already
-	 * registered on a different Graph throws a `TypeError` with
-	 * `code === "cross-graph-ownership"` (the message names both graphs and the
-	 * original registration name). **Detection contract:** prefer
-	 * `err.code === "cross-graph-ownership"` over `err instanceof TypeError`
-	 * — the `code` property is realm-stable, while `instanceof TypeError`
-	 * is realm-bound and breaks when the throw happens in a different vm /
-	 * iframe / worker context than the catch (A6 lock 2026-05-01). To migrate
-	 * a Node between graphs, the previous owner must release it first via
-	 * {@link Graph.remove} or {@link Graph.destroy}; the stamp is dropped
-	 * synchronously in the same call as the TEARDOWN cascade, so a
-	 * `freshly-detached` Node may be re-registered on another Graph in the
-	 * same tick:
-	 *
-	 * ```ts
-	 * g1.add(n, { name: "x" });
-	 * g1.remove("x");      // releases the stamp
-	 * g2.add(n, { name: "y" }); // succeeds — n is freshly-detached
-	 * ```
-	 *
-	 * Standalone `node([], fn)` usage without any `add` carries no stamp and
-	 * is unaffected. To compose foreign Nodes across Graphs without taking
-	 * ownership, wrap them in a local proxy derived (see the `proxy` factory
-	 * pattern used by `pipelineGraph.approvalGate` / `gatedStream` /
-	 * `stratify`).
-	 *
-	 * **TEARDOWN sink re-register caveat (R3.7.3 ordering, Slice W).** During
-	 * a `remove()`-triggered TEARDOWN cascade, the cross-graph ownership
-	 * stamp is released BEFORE the TEARDOWN sink fires (so cross-graph
-	 * `g2.add(node, ...)` from inside the sink works), but `_nodes` /
-	 * `_nodeToName` clear AFTER the cascade (so `g1.nameOf(node)` stays
-	 * resolvable inside the sink, per canonical R3.7.3). Consequence:
-	 * **same-graph re-register under a NEW name from inside the TEARDOWN
-	 * sink is NOT supported** — `g1.add(node, {name: "y"})` from within the
-	 * sink throws `"node instance already registered as 'x'"`. Do same-graph
-	 * re-registration after `remove()` returns (the namespace clear is
-	 * complete by then).
-	 *
-	 * @param node - Node instance to own.
-	 * @param opts - `{ name?, annotation? }`.
-	 * @throws {TypeError} `code: "cross-graph-ownership"` when the Node is
-	 *   already registered on a different non-destroyed Graph.
-	 */
-	/**
-	 * O(1) reverse lookup — returns the name the given Node was registered
-	 * under via {@link Graph.add}, or `undefined` if it isn't registered here.
-	 *
-	 * Audit 2 (2026-04-24): replaces the orchestration's `findRegisteredNodePath`
-	 * O(nodes²) describe-scan with direct `WeakMap<Node, string>` lookup.
-	 */
-	nameOf(node: Node): string | undefined {
-		return this._nodeToName.get(node);
-	}
-
-	add<T extends Node>(node: T, opts?: { name?: string; annotation?: string }): T {
-		const fallback = (node as unknown as { name?: string }).name;
-		const resolved = opts?.name ?? fallback;
-		if (resolved == null || resolved === "") {
-			throw new Error(
-				`Graph "${this.name}": graph.add requires a non-empty name — pass via opts.name or set it on the node (e.g. state(0, { name: "x" }))`,
-			);
-		}
-		const name = resolved;
-		const annotation = opts?.annotation;
-		assertRegisterableName(name, this.name, "add");
-		if (this._mounts.has(name)) {
-			throw new Error(`Graph "${this.name}": name "${name}" is already a mount point`);
-		}
-		if (this._nodes.has(name)) {
-			throw new Error(`Graph "${this.name}": node "${name}" already exists`);
-		}
-		const existingName = this._nodeToName.get(node);
-		if (existingName !== undefined) {
-			throw new Error(
-				`Graph "${this.name}": node instance already registered as "${existingName}"`,
-			);
-		}
-		// C3 — cross-graph ownership stamp (see GRAPH_OWNER above + JSDoc).
-		// At this point we know the node isn't already registered on `this`
-		// (the `_nodeToName` check above ruled that out), so any non-undefined
-		// `GRAPH_OWNER` entry necessarily points at a *different* Graph.
-		const owner = GRAPH_OWNER.get(node);
-		if (owner !== undefined && owner !== this && !owner.destroyed) {
-			const ownerName = owner.name !== "" ? owner.name : "<unnamed>";
-			const thisName = this.name !== "" ? this.name : "<unnamed>";
-			const ownerRegName = owner._nodeToName.get(node) ?? "<unknown>";
-			const err = new TypeError(
-				`Graph "${thisName}": node already owned by Graph "${ownerName}" (registered there as "${ownerRegName}"). ` +
-					`A Node may belong to at most one Graph; release it via ${ownerName}.remove("${ownerRegName}") or ${ownerName}.destroy() first, ` +
-					`or wrap it in a local proxy derived (see Graph.add JSDoc).`,
-			) as TypeError & { code: string };
-			err.code = "cross-graph-ownership";
-			throw err;
-		}
-		this._nodes.set(name, node);
-		this._nodeToName.set(node, name);
-		GRAPH_OWNER.set(node, this);
-		// Edges are derived on demand from node `_deps` (see `edges()`) — no
-		// stored registry to keep in sync. See Unit 7 of the graph review.
-		this._bumpTopologyVersion(); // DS-14.5.A Q1
-		this._emitTopology({ kind: "added", name, nodeKind: "node" });
-		// Install the initial annotation, if supplied. The `_annotations` map
-		// always gets the entry so annotations aren't silently lost when the
-		// inspector is disabled at construction time (reads via `trace(path)`
-		// stay cheap either way). Only the chronological ring-buffer push is
-		// gated on `inspectorEnabled`, since that buffer is the "debug log"
-		// half of the feature.
-		if (annotation != null) {
-			this._annotations.set(name, annotation);
-			if (this.config.inspectorEnabled) {
-				this._traceRing.push({
-					path: name,
-					annotation,
-					timestamp_ns: monotonicNs(),
-				});
-			}
-		}
-		return node;
-	}
-
-	/**
-	 * Bulk-apply a minimum versioning level to every currently-registered node
-	 * in this graph (roadmap §6.0). `_applyVersioning` is monotonic — nodes
-	 * already at a higher level are untouched. The method refuses to run
-	 * mid-wave; invoke at setup time before any external subscribers attach.
-	 *
-	 * **Not** a default-for-future-adds mechanism — that's what
-	 * `config.defaultVersioning` is for. Nodes added after this call do NOT
-	 * automatically inherit `level`; register new nodes with their own
-	 * `opts.versioning` or set `config.defaultVersioning` before construction.
-	 *
-	 * **Scope:** local only. Does not propagate to mounted subgraphs.
-	 *
-	 * @param level - `0` for V0, `1` for V1, or `undefined` to no-op.
-	 */
-	setVersioning(level: VersioningLevel | undefined): void {
-		if (level == null) return;
-		for (const node of this._nodes.values()) {
-			if (node instanceof NodeImpl) {
-				node._applyVersioning(level);
-			}
-		}
-	}
-
-	/**
-	 * Unregisters a node or unmounts a subgraph and sends `[[TEARDOWN]]` to the
-	 * removed node or recursively through the mounted subtree (§3.2).
-	 *
-	 * @param name - Local mount or node name.
-	 * @returns Audit record of what was removed: `{kind, nodes, mounts}`.
-	 *   `kind: "node"` → `nodes: [name]`, `mounts: []`. `kind: "mount"` →
-	 *   `nodes` lists every primary node torn down across the subtree (sorted
-	 *   qualified paths relative to the unmounted subgraph) and `mounts` lists
-	 *   the mounted subgraphs in depth-first order including `name` itself.
-	 */
-	remove(name: string): GraphRemoveAudit {
-		assertRegisterableName(name, this.name, "remove");
-
-		// Case 1: unmount a subgraph
-		const child = this._mounts.get(name);
-		if (child) {
-			const audit: GraphRemoveAudit = { kind: "mount", nodes: [], mounts: [] };
-			const targets: [string, Node][] = [];
-			child._collectObserveTargets("", targets);
-			for (const [p, n] of targets) {
-				// Only primary nodes (not meta companions) — meta cascades via
-				// the primary's TEARDOWN.
-				if (!p.includes(`${PATH_SEP}${GRAPH_META_SEGMENT}${PATH_SEP}`)) {
-					audit.nodes.push(p);
-				}
-				void n;
-			}
-			audit.nodes.sort();
-			audit.mounts.push(name);
-			audit.mounts.push(...child._collectSubgraphs(`${name}${PATH_SEP}`));
-			this._mounts.delete(name);
-			child._parent = undefined;
-			teardownMountedGraph(child);
-			this._bumpTopologyVersion(); // DS-14.5.A Q1 (unmount path)
-			this._emitTopology({ kind: "removed", name, nodeKind: "mount", audit });
-			return audit;
-		}
-
-		// Case 2: remove a local node
-		const node = this._nodes.get(name);
-		if (!node) {
-			throw new Error(`Graph "${this.name}": unknown node or mount "${name}"`);
-		}
-		// R3.7.3 — clear namespace AFTER TEARDOWN cascade so sinks can still
-		// resolve `nameOf(node)` from inside their TEARDOWN handler. Mirrors
-		// canonical "After cascade, graph internal registries are cleared"
-		// (matches Rust port Slice F /qa P1 ordering).
-		// C3 — release the cross-graph ownership stamp BEFORE TEARDOWN so a
-		// TEARDOWN sink that re-registers the node on another Graph in the
-		// same tick succeeds (the namespace-clear-after-cascade preserves
-		// `nameOf` resolvability, but ownership transfer needs the stamp gone).
-		if (GRAPH_OWNER.get(node) === this) {
-			GRAPH_OWNER.delete(node);
-		}
-		// `finally` guarantees registry cleanup even if a TEARDOWN sink throws
-		// (otherwise the registry would be left with a torn-down node still
-		// indexed under `name`).
-		try {
-			node.down([[TEARDOWN]] satisfies Messages, { internal: true });
-		} finally {
-			this._nodes.delete(name);
-			this._nodeToName.delete(node);
-		}
-		const audit: GraphRemoveAudit = { kind: "node", nodes: [name], mounts: [] };
-		this._bumpTopologyVersion(); // DS-14.5.A Q1
-		this._emitTopology({ kind: "removed", name, nodeKind: "node", audit });
-		return audit;
-	}
-
-	/**
-	 * Iterable over locally-registered `[localName, Node]` pairs (sorted).
-	 * Does not recurse into mounts.
-	 */
-	[Symbol.iterator](): IterableIterator<[string, Node]> {
-		const sorted = [...this._nodes.keys()].sort();
-		const nodes = this._nodes;
-		let i = 0;
-		return {
-			[Symbol.iterator]() {
-				return this;
-			},
-			next(): IteratorResult<[string, Node]> {
-				if (i >= sorted.length) return { value: undefined, done: true };
-				const name = sorted[i++];
-				return { value: [name, nodes.get(name)!], done: false };
-			},
-		};
-	}
-
-	/**
-	 * Returns a node by local name or `::` qualified path.
-	 * Local names are looked up directly; paths with `::` delegate to {@link resolve}.
-	 *
-	 * @param name - Local name or qualified path.
-	 */
-	node(name: string): Node {
-		if (name === "") {
-			throw new Error(`Graph "${this.name}": node name must be non-empty`);
-		}
-		if (name.includes(PATH_SEP)) {
-			return this.resolve(name);
-		}
-		const n = this._nodes.get(name);
-		if (!n) {
-			throw new Error(`Graph "${this.name}": unknown node "${name}"`);
-		}
-		return n;
-	}
-
-	/**
-	 * Shorthand for `graph.node(name).down([[DATA, value]], { actor })` — accepts `::` qualified paths (§3.2).
-	 *
-	 * @param name - Local name or qualified path.
-	 * @param value - Next `DATA` payload.
-	 * @param options - Optional `actor` and `internal` guard bypass.
-	 */
-	set(name: string, value: unknown, options?: GraphActorOptions): void {
-		const internal = options?.internal === true;
-		this.node(name).down([[DATA, value]] satisfies Messages, {
-			actor: options?.actor,
-			internal,
-			delivery: "write",
-		});
-	}
-
-	/**
-	 * Emit a single `[[INVALIDATE]]` (tier 4) on a node. Thin wrapper over
-	 * `node.down([[INVALIDATE]], …)` matching the {@link Graph.set} ergonomics.
-	 */
-	invalidate(name: string, options?: GraphActorOptions): void {
-		const internal = options?.internal === true;
-		this.node(name).down([[INVALIDATE]] satisfies Messages, {
-			actor: options?.actor,
-			internal,
-			delivery: "write",
-		});
-	}
-
-	/**
-	 * Emit a single `[[ERROR, err]]` (tier 5) on a node.
-	 */
-	error(name: string, err: unknown, options?: GraphActorOptions): void {
-		const internal = options?.internal === true;
-		this.node(name).down([[ERROR, err]] satisfies Messages, {
-			actor: options?.actor,
-			internal,
-			delivery: "write",
-		});
-	}
-
-	/**
-	 * Emit a single `[[COMPLETE]]` (tier 5) on a node, declaring the stream
-	 * cleanly finished. Distinct from {@link Graph.remove} (which emits
-	 * TEARDOWN and unregisters the node).
-	 */
-	complete(name: string, options?: GraphActorOptions): void {
-		const internal = options?.internal === true;
-		this.node(name).down([[COMPLETE]] satisfies Messages, {
-			actor: options?.actor,
-			internal,
-			delivery: "write",
-		});
-	}
-
-	/**
-	 * @experimental Phase 13.8 — Atomically replace the upstream deps of a
-	 * registered node. Internal/exploratory API; NOT exported publicly.
-	 *
-	 * **Variant: surgical (Phase 13.8 lock).** Kept deps untouched —
-	 * subscription stays attached, DepRecord state survives. Only removed
-	 * deps are unsubscribed and only added deps get fresh subscriptions.
-	 * Subscription callbacks bind to DepRecord references (Option C), so
-	 * reorder + interior-remove are allowed without re-subscribing kept
-	 * deps. See `NodeImpl.setDeps` and `docs/research/rewire-design-notes.md`.
-	 *
-	 * **Path resolution.** `name` accepts a local name or a `mount::leaf`
-	 * qualified path. Each `newDeps` entry is either a Node instance or a
-	 * path string (resolved via {@link Graph.resolve}). Cycle detection
-	 * runs on resolved Node identity at the `_setDeps` substrate, so
-	 * cross-mount cycles ARE caught.
-	 *
-	 * **Optional fn replacement (`opts.fn`).** When the dep shape change
-	 * would break the existing fn's positional reads, pass a fresh fn.
-	 * Old cleanup's `onRerun` fires on the next `_execFn` invocation.
-	 *
-	 * **Audit emission.** Returns a {@link GraphRewireAudit} listing the
-	 * dep diff. Also emits a `TopologyEvent { kind: "rewired" }` on
-	 * `this.topology`.
-	 *
-	 * **Errors.** Surfaces `_setDeps` errors verbatim (self-rewire, cycle,
-	 * mid-fn, terminal, terminal-non-resubscribable-newDep). Throws if
-	 * `name` resolves to a foreign Node not registered on this graph or
-	 * any reachable mount.
-	 *
-	 * @param name - Local name or `::` qualified path of the node to rewire.
-	 * @param newDeps - Full new dep set; entries may be Node instances or
-	 *   path strings. Order is preserved (modulo dedupe by reference).
-	 * @param fn - Required new transform fn for the rewired node. Pass the
-	 *   existing fn ref to preserve behavior; pass a fresh fn when the dep
-	 *   shape change requires it. The API enforces fn-deps pairing — see
-	 *   `NodeImpl.setDeps` JSDoc for rationale.
-	 * @returns Audit record describing the dep set diff.
-	 */
-	_rewire(name: string, newDeps: readonly (Node | string)[], fn: NodeFn): GraphRewireAudit {
-		const target = this.node(name);
-		if (!(target instanceof NodeImpl)) {
-			throw new Error(
-				`Graph "${this.name}": _rewire target "${name}" is not a NodeImpl — only NodeImpl-backed nodes can be rewired`,
-			);
-		}
-		const resolvedDeps: Node[] = newDeps.map((d) => (typeof d === "string" ? this.resolve(d) : d));
-		const oldDeps = (target as NodeImpl)._deps.map((dr) => dr.node);
-		const oldSet = new Set(oldDeps);
-		const newSet = new Set(resolvedDeps);
-		const removedNodes = oldDeps.filter((n) => !newSet.has(n));
-		const addedNodes = resolvedDeps.filter((n) => !oldSet.has(n));
-		const keptNodes = oldDeps.filter((n) => newSet.has(n));
-
-		// Fire substrate primitive — performs validation, surgical diff,
-		// required fn swap.
-		(target as NodeImpl).setDeps(resolvedDeps, fn);
-
-		const labelOf = (n: Node): string => {
-			const local = this._nodeToName.get(n);
-			if (local != null) return local;
-			// Walk mounts for a qualified path.
-			for (const [mountName, child] of this._mounts) {
-				const found = child._findNamePath(n);
-				if (found != null) return `${mountName}${PATH_SEP}${found}`;
-			}
-			return "<unregistered>";
-		};
-		const audit: GraphRewireAudit = {
-			name,
-			removed: removedNodes.map(labelOf).sort(),
-			added: addedNodes.map(labelOf).sort(),
-			kept: keptNodes.map(labelOf).sort(),
-		};
-		// DS-14.5.A Q1 — bump BEFORE the isolated emit: the rewire already
-		// landed in `_setDeps`, so the spec projection is dirty regardless of
-		// whether a topology subscriber throws.
-		this._bumpTopologyVersion();
-		// Phase 13.8 QA L: topology emission runs AFTER `_setDeps` mutated
-		// state. If a subscriber throws, we must not propagate — the rewire
-		// has already landed and the caller would see a misleading exception
-		// suggesting it was rolled back. Best-effort isolate.
-		try {
-			this._emitTopology({ kind: "rewired", name, audit });
-		} catch {
-			/* topology subscriber errors are observability-layer faults;
-			   do not leak them through the substrate mutation path */
-		}
-		return audit;
-	}
-
-	/**
-	 * @internal Recursive helper for `_rewire` to find a Node's qualified
-	 * path inside a mounted subgraph. Returns the mount-relative path or
-	 * `undefined` if not found at any depth.
-	 */
-	private _findNamePath(n: Node): string | undefined {
-		const local = this._nodeToName.get(n);
-		if (local != null) return local;
-		for (const [mountName, child] of this._mounts) {
-			const found = child._findNamePath(n);
-			if (found != null) return `${mountName}${PATH_SEP}${found}`;
-		}
-		return undefined;
-	}
-
-	/**
-	 * @experimental Phase 13.8 — append a dep to a registered node.
-	 * Internal/exploratory API. Wraps `NodeImpl.addDep`.
-	 *
-	 * @param name - Local name or qualified path of the node to extend.
-	 * @param dep - Node instance or path string for the dep to append.
-	 * @param fn - Required new transform fn (see `_addDep` for fn-swap
-	 *   semantics — old cleanup's `onRerun` fires on next `_execFn` run).
-	 *   Pass the existing fn ref to preserve behavior.
-	 * @returns Index of the new dep in the target's `_deps`, or the existing
-	 *   index if the dep was already present (idempotent).
-	 */
-	_addDep(name: string, dep: Node | string, fn: NodeFn): number {
-		const target = this.node(name);
-		if (!(target instanceof NodeImpl)) {
-			throw new Error(
-				`Graph "${this.name}": _addDep target "${name}" is not a NodeImpl — only NodeImpl-backed nodes can be edited`,
-			);
-		}
-		const resolved = typeof dep === "string" ? this.resolve(dep) : dep;
-		const idx = (target as NodeImpl).addDep(resolved, fn);
-		// DS-14.5.A Q1 (F1) — `addDep` mutates `_deps` shape, so the spec
-		// projection is dirty. Bump AFTER the substrate call returns, mirroring
-		// `_rewire`'s placement (the edit has already landed).
-		this._bumpTopologyVersion();
-		return idx;
-	}
-
-	/**
-	 * @experimental Phase 13.8 — remove a dep from a registered node.
-	 * Internal/exploratory API. Wraps `NodeImpl.removeDep`.
-	 *
-	 * Idempotent — if `dep` is not currently a dep of `name`, this is a
-	 * no-op for the dep set (the fn swap still applies).
-	 *
-	 * @param name - Local name or qualified path of the node to edit.
-	 * @param dep - Node instance or path string for the dep to remove.
-	 * @param fn - Required new transform fn (removed dep shrinks
-	 *   `data.length`; declare the fn that consumes the new shape).
-	 */
-	_removeDep(name: string, dep: Node | string, fn: NodeFn): void {
-		const target = this.node(name);
-		if (!(target instanceof NodeImpl)) {
-			throw new Error(
-				`Graph "${this.name}": _removeDep target "${name}" is not a NodeImpl — only NodeImpl-backed nodes can be edited`,
-			);
-		}
-		const resolved = typeof dep === "string" ? this.resolve(dep) : dep;
-		(target as NodeImpl).removeDep(resolved, fn);
-		// DS-14.5.A Q1 (F1) — `removeDep` mutates `_deps` shape (spec
-		// projection drift); bump AFTER the substrate call, mirroring `_rewire`.
-		this._bumpTopologyVersion();
-	}
-
-	// ——————————————————————————————————————————————————————————————
-	//  Composition (narrow-waist API for pattern authors — spec §5.12)
-	// ——————————————————————————————————————————————————————————————
-
-	/**
-	 * Internal: register a self-pruning keepalive subscription. The sink
-	 * watches for terminal messages (`COMPLETE`/`ERROR`/`TEARDOWN`) on `n`
-	 * and removes the disposer from `_disposers` when one arrives, so
-	 * repeated `graph.remove(name)` cycles do not accumulate stale
-	 * disposers (qa B3).
-	 */
-	private _registerSelfPruningKeepalive(n: Node<unknown>): void {
-		let unsub: (() => void) | undefined;
-		let removeFromDisposers: (() => void) | undefined;
-		const cleanup = (): void => {
-			unsub?.();
-			unsub = undefined;
-			removeFromDisposers?.();
-			removeFromDisposers = undefined;
-		};
-		unsub = n.subscribe((msgs) => {
-			for (const m of msgs) {
-				const t = m[0];
-				if (t === TEARDOWN || t === COMPLETE || t === ERROR) {
-					cleanup();
-					return;
-				}
-			}
-		});
-		removeFromDisposers = this.addDisposer(cleanup);
-	}
-
-	/**
-	 * Internal: wire an `AbortSignal` so its abort triggers
-	 * `graph.remove(name)`. Already-aborted signals trigger removal
-	 * synchronously. The abort listener is itself registered as a graph
-	 * disposer so it gets cleaned up if `destroy()` runs first (qa B4).
-	 */
-	private _wireSignalToRemove(name: string, signal: AbortSignal | undefined): void {
-		if (signal == null) return;
-		const onAbort = (): void => {
-			try {
-				this.remove(name);
-			} catch {
-				// Already removed or graph destroyed — no-op.
-			}
-		};
-		if (signal.aborted) {
-			onAbort();
-			return;
-		}
-		signal.addEventListener("abort", onAbort, { once: true });
-		this.addDisposer(() => signal.removeEventListener("abort", onAbort));
-	}
-
-	/**
-	 * Reactive derivation over a mix of `::`-qualified paths and direct
-	 * Node refs. Resolves each entry in `deps`, builds a node with
-	 * restricted {@link GraphDerivedFn}, registers it on this graph, and
-	 * returns the registered Node.
-	 *
-	 * **Deps shape.** Each entry is either a `string` (resolved at
-	 * construction time via {@link Graph.resolve}) or a `Node` (used as
-	 * the dep directly without registering on this graph). Mixed arrays
-	 * are supported — typical pattern is `[localPath, externalNodeRef]`
-	 * for nodes that live on a separate graph or are intentionally
-	 * unmounted (e.g. `reactiveLog().entries`). Node-ref deps appear in
-	 * `describe().edges` only when the dep's owning Node is itself
-	 * mounted somewhere reachable; otherwise they show up as unresolved
-	 * upstream edges (matching raw `node([nodeRef], …)` semantics).
-	 *
-	 * **Array-return semantics.** fn returns `readonly (T | null)[]`:
-	 * - `[v]` — single emit (common case).
-	 * - `[]` — no change, settle as RESOLVED.
-	 * - `[v1, v2, ...]` — multi-emit in one wave.
-	 *
-	 * **First-run gate.** fn does not fire until every dep has delivered
-	 * at least one real DATA (spec §2.7, `partial: false`). A SENTINEL
-	 * dep holds activation; `null` is valid DATA and releases the gate.
-	 * **Empty `deps` is a vacuous gate** — fn fires once synchronously
-	 * on first activation. For async sources prefer {@link Graph.producer}.
-	 *
-	 * **`ctx.cache`** — the node's own previous emit (`undefined` when
-	 * no prior emit, `null` when the prior emit was `null`, otherwise `T`).
-	 *
-	 * **`keepAlive: true`** — installs an internal subscription so the
-	 * node stays activated and `.cache` stays current for external
-	 * consumers. Self-prunes on terminal; drained by {@link Graph.destroy}.
-	 *
-	 * **`signal`** — when aborted, removes this node from the graph.
-	 *
-	 * @param name - Local registration name (must be unique on this graph).
-	 * @param deps - Mix of `::`-qualified path strings (resolved at
-	 *   construction time) and direct `Node` refs (used as-is). **String
-	 *   deps freeze at construction**: `derived("d", ["mount::leaf"], …)`
-	 *   captures the live `mount::leaf` Node once and stores the ref. If
-	 *   `mount` is later removed (`graph.remove("mount")`), the captured
-	 *   Node is now an orphan — `describe()` cannot locate it under any
-	 *   path, but it stays activated as long as `d` is subscribed and
-	 *   continues to flow values into `fn`. Symptom: emissions land in a
-	 *   derived whose construction-time path no longer resolves.
-	 *
-	 *   **Workarounds** (pick by need): (a) for short-lived mounts, pass a
-	 *   direct `Node` ref instead of a path string and explicitly drop the
-	 *   subscription before unmounting; (b) for hot-swap topologies, rebuild
-	 *   the derived after `remove`/`add` of the mount, or use
-	 *   {@link Node.setDeps} on the substrate `Node` (pre-1.0; public on
-	 *   `@graphrefly/pure-ts` since 2026-05-18 and on `@graphrefly/native`
-	 *   since 2026-05-20 per D264) to atomically swap the dep slot. (c) For
-	 *   strict invariants, wrap `graph.remove` with a pre-check that no
-	 *   `derived` has the doomed mount in its construction-time deps.
-	 *
-	 *   This freeze is a by-design property of path resolution at
-	 *   construction time; closed as `optimizations.md` C4 on 2026-05-22.
-	 *   A `describe()`-time `orphaned` marker would require a new
-	 *   per-`Node` field to distinguish string-resolved deps from
-	 *   anonymous `Node`-ref deps; tracked as a cross-track-ledger §2
-	 *   follow-on if a consumer surfaces.
-	 * @param fn - Restricted compute — see {@link GraphDerivedFn}.
-	 * @param opts - {@link GraphDerivedOptions}.
-	 * @returns The registered `Node<T>`.
-	 */
-	derived<T>(
-		name: string,
-		deps: readonly (string | Node<unknown>)[],
-		fn: GraphDerivedFn<T>,
-		opts?: GraphDerivedOptions<T>,
-	): Node<T> {
-		const resolvedDeps = deps.map((d) => (typeof d === "string" ? this.resolve(d) : d));
-		const { keepAlive, annotation, signal, ...nodeOpts } = opts ?? {};
-
-		// Wrap restricted GraphDerivedFn → raw NodeFn.
-		// Pass batchData and full ctx straight through; restriction is
-		// only on the OUTPUT side (return array, no actions).
-		// Closure captures `nodeRef` so the wrapper can read `.cache` for
-		// the ctx.cache field (same pattern as autoTrackNode).
-		let nodeRef: Node<T> | undefined;
-		const wrapped: NodeFn = (batchData, actions, ctx) => {
-			const derivedCtx: FnCtxDerived<T> = {
-				prevData: ctx.prevData,
-				terminalDeps: ctx.terminalDeps,
-				store: ctx.store,
-				cache: nodeRef?.cache,
-			};
-			const result = fn(batchData, derivedCtx);
-			if (result.length === 0) {
-				// Empty array → no change → settle as RESOLVED.
-				actions.down(RESOLVED_ONLY_BATCH);
-			} else {
-				for (const v of result) {
-					actions.emit(v);
-				}
-			}
-			return undefined;
-		};
-
-		const n = node<T>(resolvedDeps, wrapped, {
-			...nodeOpts,
-			name,
-			describeKind: "derived",
-		});
-		nodeRef = n;
-		this.add(n, { name, ...(annotation != null ? { annotation } : {}) });
-		if (keepAlive === true) {
-			this._registerSelfPruningKeepalive(n);
-		}
-		this._wireSignalToRemove(name, signal);
-		return n;
-	}
-
-	/**
-	 * Managed side effect over a mix of `::`-qualified paths and direct
-	 * Node refs. Resolves each entry in `deps`, builds a node with
-	 * restricted {@link GraphEffectFn}, registers it on this graph, and
-	 * returns the registered Node.
-	 *
-	 * **Deps shape.** Each entry is either a `string` (resolved at
-	 * construction time via {@link Graph.resolve}) or a `Node` (used as
-	 * the dep directly without registering on this graph). See
-	 * {@link Graph.derived} for full mixed-deps semantics.
-	 *
-	 * **Pure sink.** fn has no `emit`/`down` — effects that need
-	 * downstream emission use {@link Graph.producer} or drop to raw
-	 * `node() + graph.add()`. fn receives `up.pause(lockId)` /
-	 * `up.resume(lockId)` for upstream backpressure only.
-	 *
-	 * **Cleanup.** Return granular hooks
-	 * (`{ onRerun?, onDeactivation?, onInvalidate? }`) — see
-	 * {@link NodeFnCleanup}. Graph teardown triggers `onDeactivation`.
-	 *
-	 * **`keepAlive: true`** — installs an internal subscription so the
-	 * effect stays activated even without an external subscriber.
-	 * Symmetric with {@link Graph.derived}'s `keepAlive`. Without it, an
-	 * effect with no external subscriber is dormant — its fn never fires.
-	 * Self-prunes on terminal; drained by {@link Graph.destroy}.
-	 *
-	 * **`signal`** — when aborted, removes this node from the graph.
-	 *
-	 * @param name - Local registration name (must be unique on this graph).
-	 * @param deps - Mix of `::`-qualified path strings (resolved at
-	 *   construction time) and direct `Node` refs (used as-is).
-	 * @param fn - Restricted side-effect — see {@link GraphEffectFn}.
-	 * @param opts - {@link GraphEffectOptions}.
-	 * @returns The registered `Node<unknown>`.
-	 */
-	effect(
-		name: string,
-		deps: readonly (string | Node<unknown>)[],
-		fn: GraphEffectFn,
-		opts?: GraphEffectOptions,
-	): Node<unknown> {
-		const resolvedDeps = deps.map((d) => (typeof d === "string" ? this.resolve(d) : d));
-		const { keepAlive, annotation, signal, ...nodeOpts } = opts ?? {};
-
-		// Wrap restricted GraphEffectFn → raw NodeFn.
-		// Pass batchData and full ctx straight through; restriction is
-		// only on the OUTPUT side (up.pause/resume only, no emit/down).
-		const wrapped: NodeFn = (batchData, actions, ctx) => {
-			const up: NodeUpActions = {
-				pause: (lockId) => actions.up([PAUSE, lockId]),
-				resume: (lockId) => actions.up([RESUME, lockId]),
-			};
-			return fn(batchData, up, ctx) ?? undefined;
-		};
-
-		const n = node(resolvedDeps, wrapped, {
-			...nodeOpts,
-			name,
-			describeKind: "effect",
-		});
-		this.add(n, { name, ...(annotation != null ? { annotation } : {}) });
-		if (keepAlive === true) {
-			this._registerSelfPruningKeepalive(n);
-		}
-		this._wireSignalToRemove(name, signal);
-		return n;
-	}
-
-	/**
-	 * Creates a named state node — a dep-free node with an initial value.
-	 * State nodes are the primary entry points for external data into the
-	 * graph. Emit new values via `node.emit(v)` or protocol-level
-	 * `down([[DATA, v]])`.
-	 *
-	 * **`signal`** — when aborted, removes this node from the graph.
-	 *
-	 * @param name - Local registration name (must be unique on this graph).
-	 * @param initial - Initial value. `null` is valid; `undefined` is
-	 *   sentinel and means "no initial value".
-	 * @param opts - {@link GraphStateOptions}.
-	 * @returns The registered `Node<T>`.
-	 */
-	state<T>(name: string, initial?: T | null, opts?: GraphStateOptions<T>): Node<T> {
-		const { annotation, signal, ...nodeOpts } = opts ?? {};
-		const n = node<T>([], {
-			...nodeOpts,
-			name,
-			describeKind: "state",
-			...(initial !== undefined ? { initial } : {}),
-		});
-		this.add(n, { name, ...(annotation != null ? { annotation } : {}) });
-		this._wireSignalToRemove(name, signal);
-		return n;
-	}
-
-	/**
-	 * Creates a named producer node — a dep-free source with a setup
-	 * function that receives a `push` channel for emitting values.
-	 *
-	 * The setup fn runs once when the first subscriber connects.
-	 * `push` follows the same array-emission shape as
-	 * {@link GraphDerivedFn}: `push([v])` for single DATA,
-	 * `push([v1, v2])` for multi-DATA.
-	 *
-	 * Return a cleanup function or granular hooks for teardown.
-	 *
-	 * **`signal`** — when aborted, removes this node from the graph
-	 * (fires the producer's `deactivate` cleanup).
-	 *
-	 * @param name - Local registration name (must be unique on this graph).
-	 * @param setupFn - {@link GraphProducerSetupFn}.
-	 * @param opts - {@link GraphProducerOptions}.
-	 * @returns The registered `Node<T>`.
-	 */
-	producer<T>(
-		name: string,
-		setupFn: GraphProducerSetupFn<T>,
-		opts?: GraphProducerOptions<T>,
-	): Node<T> {
-		const { annotation, signal, ...nodeOpts } = opts ?? {};
-
-		// Wrap GraphProducerSetupFn → raw NodeFn.
-		// The push channel is built from actions.emit in the NodeFn body.
-		const wrapped: NodeFn = (_data, actions, ctx) => {
-			const push = (values: readonly (T | null)[]): void => {
-				for (const v of values) {
-					actions.emit(v);
-				}
-			};
-			const producerCtx: FnCtxProducer = { store: ctx.store };
-			return setupFn(push, producerCtx) ?? undefined;
-		};
-
-		const n = node<T>(wrapped, {
-			...nodeOpts,
-			name,
-			describeKind: "producer",
-		});
-		this.add(n, { name, ...(annotation != null ? { annotation } : {}) });
-		this._wireSignalToRemove(name, signal);
-		return n;
-	}
-
-	// ——————————————————————————————————————————————————————————————
-	//  Reactive structure sugar (Phase 2–3 data-structures)
-	// ——————————————————————————————————————————————————————————————
-
-	/**
-	 * Creates a {@link ReactiveLogBundle} and registers its `entries` node
-	 * under `name` on this graph. The `name` option is set automatically;
-	 * remaining options forwarded to `reactiveLog()`.
-	 */
-	log<T>(name: string, opts?: Omit<ReactiveLogOptions<T>, "name">): ReactiveLogBundle<T> {
-		const full: ReactiveLogOptions<T> = { ...(opts as ReactiveLogOptions<T>), name };
-		const bundle = reactiveLog<T>(undefined, full);
-		this.add(bundle.entries, { name });
-		return bundle;
-	}
-
-	/**
-	 * Creates a {@link ReactiveListBundle} and registers its `items` node
-	 * under `name` on this graph. When the `mutationLog` option is set, the
-	 * companion log's `entries` node is also registered under
-	 * `name + "/mutationLog"`. Remaining options forwarded to `reactiveList()`.
-	 */
-	list<T>(name: string, opts?: Omit<ReactiveListOptions<T>, "name">): ReactiveListBundle<T> {
-		const full: ReactiveListOptions<T> = { ...(opts as ReactiveListOptions<T>), name };
-		const bundle = reactiveList<T>(undefined, full);
-		this.add(bundle.items, { name });
-		if (bundle.mutationLog) {
-			this.add(bundle.mutationLog.entries, { name: `${name}/mutationLog` });
-		}
-		return bundle;
-	}
-
-	/**
-	 * Creates a {@link ReactiveMapBundle} and registers its `entries` node
-	 * under `name` on this graph. When the `mutationLog` option is set, the
-	 * companion log's `entries` node is also registered under
-	 * `name + "/mutationLog"`. Remaining options forwarded to `reactiveMap()`.
-	 */
-	map<K, V>(name: string, opts?: Omit<ReactiveMapOptions<K, V>, "name">): ReactiveMapBundle<K, V> {
-		const full: ReactiveMapOptions<K, V> = { ...(opts as ReactiveMapOptions<K, V>), name };
-		const bundle = reactiveMap<K, V>(full);
-		this.add(bundle.entries, { name });
-		if (bundle.mutationLog) {
-			this.add(bundle.mutationLog.entries, { name: `${name}/mutationLog` });
-		}
-		return bundle;
-	}
-
-	/**
-	 * Creates a {@link ReactiveIndexBundle} and registers its `ordered` node
-	 * under `name` on this graph. The `byPrimary` companion is registered
-	 * under `name + "/byPrimary"`, and when `mutationLog` is set, the log's
-	 * `entries` node is registered under `name + "/mutationLog"`. Remaining
-	 * options forwarded to `reactiveIndex()`.
-	 */
-	index<K, V = unknown>(
-		name: string,
-		opts?: Omit<ReactiveIndexOptions<K, V>, "name">,
-	): ReactiveIndexBundle<K, V> {
-		const full: ReactiveIndexOptions<K, V> = { ...(opts as ReactiveIndexOptions<K, V>), name };
-		const bundle = reactiveIndex<K, V>(full);
-		this.add(bundle.ordered, { name });
-		this.add(bundle.byPrimary, { name: `${name}/byPrimary` });
-		if (bundle.mutationLog) {
-			this.add(bundle.mutationLog.entries, { name: `${name}/mutationLog` });
-		}
-		return bundle;
-	}
-
-	/**
-	 * Atomic multi-mutation. Same semantics as core {@link batch}: DATA and
-	 * RESOLVED emissions inside `fn` defer, DIRTY propagates immediately, and
-	 * downstream consumers see one coalesced wave (spec §1.3 invariant 7).
-	 * Exposed on `Graph` for discoverability and import hygiene — pattern
-	 * authors can reach for `graph.batch(...)` without importing `batch` from
-	 * the core entry. Shares one global frame with the core import; nesting
-	 * either way is supported.
-	 *
-	 * **Caveat:** if `fn` throws, deferred DATA is discarded but DIRTY
-	 * messages already propagated synchronously, leaving downstream nodes
-	 * in `dirty` status with stale `.cache`. Catch and emit compensating
-	 * INVALIDATE/RESET if you need to recover.
-	 */
-	batch(fn: () => void): void {
-		batch(fn);
-	}
-
-	// ——————————————————————————————————————————————————————————————
-	//  Edges (derived on-demand from node `_deps`)
-	// ——————————————————————————————————————————————————————————————
-
-	/**
-	 * Returns the full edge list for this graph tree, derived on demand from
-	 * each registered node's `_deps` (no stored registry). Local-only
-	 * (non-recursive) by default to match the historical `edges()` surface;
-	 * pass `{recursive: true}` to include mounted subgraphs with qualified
-	 * paths relative to this graph.
-	 *
-	 * Use {@link Graph.describe} for full-tree snapshots with edges already
-	 * qualified and paired with node metadata.
-	 */
-	edges(opts?: { recursive?: boolean }): ReadonlyArray<[string, string]> {
-		const recursive = opts?.recursive === true;
-		const nodeToLocal = new Map<Node, string>();
-		if (!recursive) {
-			for (const [localName, n] of this._nodes) nodeToLocal.set(n, localName);
-			const result: [string, string][] = [];
-			for (const [localName, n] of this._nodes) {
-				if (!(n instanceof NodeImpl)) continue;
-				for (const dep of n._deps) {
-					const from = nodeToLocal.get(dep.node);
-					if (from != null) result.push([from, localName]);
-				}
-			}
-			result.sort((a, b) =>
-				a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : a[1] < b[1] ? -1 : a[1] > b[1] ? 1 : 0,
-			);
-			return result;
-		}
-		const targets: [string, Node][] = [];
-		this._collectObserveTargets("", targets);
-		const nodeToPath = new Map<Node, string>();
-		for (const [p, n] of targets) nodeToPath.set(n, p);
-		const result: [string, string][] = [];
-		for (const [path, n] of targets) {
-			if (!(n instanceof NodeImpl)) continue;
-			for (const dep of n._deps) {
-				const from = nodeToPath.get(dep.node);
-				if (from != null) result.push([from, path]);
-			}
-		}
-		result.sort((a, b) =>
-			a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : a[1] < b[1] ? -1 : a[1] > b[1] ? 1 : 0,
-		);
-		return result;
-	}
-
-	// ——————————————————————————————————————————————————————————————
-	//  Composition
-	// ——————————————————————————————————————————————————————————————
-
-	/**
-	 * Embed a child graph at a local mount name (§3.4). Child nodes are reachable via
-	 * {@link Graph.resolve} using `::` delimited paths (§3.5). Lifecycle
-	 * {@link Graph.signal} visits mounted subgraphs recursively.
-	 *
-	 * Rejects: same name as existing node or mount, self-mount, mount cycles,
-	 * and the same child graph instance mounted twice on one parent.
-	 *
-	 * @param name - Local mount point.
-	 * @param child - Nested `Graph` instance.
-	 * @returns The mounted `child`, for chaining.
-	 */
-	mount<G extends Graph>(name: string, child: G): G;
-	mount(name: string): Graph;
-	mount(name: string, builder: (sub: Graph) => void): Graph;
-	mount<G extends Graph>(name: string, childOrBuilder?: G | ((sub: Graph) => void)): Graph {
-		// Builder-form overloads (Audit A.1): create a fresh plain Graph and
-		// run an optional builder on it BEFORE mount, so `describe()` shows a
-		// populated subgraph at the moment of mount.
-		if (childOrBuilder === undefined) {
-			const fresh = new Graph(name);
-			return this.mount(name, fresh);
-		}
-		if (typeof childOrBuilder === "function") {
-			const fresh = new Graph(name);
-			(childOrBuilder as (sub: Graph) => void)(fresh);
-			return this.mount(name, fresh);
-		}
-		const child = childOrBuilder as G;
-		assertRegisterableName(name, this.name, "mount");
-		if (this._nodes.has(name)) {
-			throw new Error(
-				`Graph "${this.name}": cannot mount at "${name}" — node with that name exists`,
-			);
-		}
-		if (this._mounts.has(name)) {
-			throw new Error(`Graph "${this.name}": mount "${name}" already exists`);
-		}
-		if ((child as Graph) === this) {
-			throw new Error(`Graph "${this.name}": cannot mount a graph into itself`);
-		}
-		// Reject reparenting (Unit 6 B): same child instance may only be
-		// mounted once across the entire tree. Cheap O(1) check via the
-		// back-pointer (replaces both the "mounted twice on this parent"
-		// loop AND the O(G) cycle DFS).
-		if (child._parent != null) {
-			throw new Error(
-				`Graph "${this.name}": this child graph is already mounted on "${child._parent.name}"`,
-			);
-		}
-		// Cycle rejection — walk UP from `this` to detect if we are already in
-		// `child`'s descendant tree. O(depth), independent of tree size.
-		for (let p: Graph | undefined = this; p != null; p = p._parent) {
-			if (p === (child as Graph)) {
-				throw new Error(`Graph "${this.name}": mount("${name}", …) would create a mount cycle`);
-			}
-		}
-		// C3 — defensive child-walk. Mount lineage stays innermost-owned: the
-		// child's nodes remain owned by the child, NOT by the parent. This
-		// loop catches direct mutation of `child._nodes` that bypassed
-		// `child.add` (the bypass would have skipped the stamp). Reject
-		// unconditionally if a node is already owned by a *different* graph
-		// than the child (or any of the child's transitive mounts) — a
-		// mounted child carrying a foreign Node violates the single-owner
-		// invariant just like a direct dual-add.
-		// A2 (QA fix 2026-05-01): recurse into `child._mounts` so foreign-
-		// owned nodes nested deeper (a grandchild mount carrying a foreign
-		// Node) are caught too. The previous shallow walk only covered
-		// `child._nodes` directly.
-		const walkMountSubtree = (g: Graph): void => {
-			for (const n of g._nodes.values()) {
-				const owner = GRAPH_OWNER.get(n);
-				if (owner === undefined) {
-					GRAPH_OWNER.set(n, g);
-				} else if (owner !== g && !owner.destroyed) {
-					const ownerName = owner.name !== "" ? owner.name : "<unnamed>";
-					const childName = (child as Graph).name !== "" ? (child as Graph).name : "<unnamed>";
-					const ownerRegName = owner._nodeToName.get(n) ?? "<unknown>";
-					const err = new TypeError(
-						`Graph "${this.name}": cannot mount "${name}" — child graph "${childName}" (or its descendant) carries a node already owned by Graph "${ownerName}" (registered there as "${ownerRegName}").`,
-					) as TypeError & { code: string };
-					err.code = "cross-graph-ownership";
-					throw err;
-				}
-			}
-			for (const grandchild of g._mounts.values()) {
-				walkMountSubtree(grandchild);
-			}
-		};
-		walkMountSubtree(child as Graph);
-		this._mounts.set(name, child);
-		child._parent = this;
-		this._bumpTopologyVersion(); // DS-14.5.A Q1
-		this._emitTopology({ kind: "added", name, nodeKind: "mount" });
-		return child;
-	}
-
-	/**
-	 * Look up a node by qualified path (§3.5). Segments are separated by `::`.
-	 *
-	 * If the first segment equals this graph's {@link Graph.name} **and** more
-	 * segments follow, it is stripped (so `root.resolve("app::a")` works when
-	 * `root.name === "app"`). The strip is applied **recursively** when
-	 * descending into mounted children, so `child.resolve("child::x")` also
-	 * works when `child.name === "child"`.
-	 *
-	 * **Self-resolve fix (2026-04-30):** a single-segment path matching the
-	 * graph name is treated as a local-node lookup. This unblocks topics
-	 * named after their internal child node (e.g. `topic("events").resolve(
-	 * "events")` returns the events log instead of throwing). If no local
-	 * node matches, the standard "unknown name" error fires.
-	 *
-	 * @param path - Qualified `::` path or local name.
-	 * @returns The resolved `Node`.
-	 */
-	resolve(path: string): Node {
-		const segments = splitPath(path, this.name);
-		return this._resolveFromSegments(segments);
-	}
-
-	/**
-	 * Non-throwing {@link Graph.resolve}. Returns `undefined` instead of
-	 * throwing when the path does not resolve to a node.
-	 */
-	tryResolve(path: string): Node | undefined {
-		try {
-			return this.resolve(path);
-		} catch {
-			return undefined;
-		}
-	}
-
-	/**
-	 * Predicate counterpart to {@link Graph.tryResolve} for **mounts** (subgraphs).
-	 * Returns `true` iff `name` is a directly-mounted subgraph of this graph
-	 * (NOT a node, NOT a deeply-nested mount). Use when you need to
-	 * distinguish "mount exists" from "node exists" — `tryResolve` returns
-	 * `undefined` for both unknown names and subgraph mounts (per §3.5: a
-	 * path ending at a subgraph is not a node), so it cannot make this
-	 * distinction.
-	 *
-	 * @param name - Local mount name (must not contain `::`).
-	 */
-	hasMount(name: string): boolean {
-		return this._mounts.has(name);
-	}
-
-	/**
-	 * Get a directly-mounted subgraph by local `name`, or `undefined` if no
-	 * such mount exists. Companion to {@link Graph.hasMount}. Does not walk
-	 * nested paths — pass a child-local name only.
-	 *
-	 * @param name - Local mount name (must not contain `::`).
-	 */
-	getMount(name: string): Graph | undefined {
-		return this._mounts.get(name);
-	}
-
-	private _resolveFromSegments(segments: readonly string[]): Node {
-		// Recursive self-name strip: if the first segment equals this graph's
-		// own name AND more segments follow, peel it off. Applied at every
-		// recursion level so nested resolution of `child::x` inside `child`
-		// works uniformly. Single-segment paths matching the graph name fall
-		// through to local-node lookup (a topic named "events" with an internal
-		// "events" log node resolves correctly via `.resolve("events")`).
-		let seg = segments;
-		if (seg.length > 1 && seg[0] === this.name) {
-			seg = seg.slice(1);
-		}
-		const head = seg[0] as string;
-		const rest = seg.slice(1);
-
-		if (rest.length === 0) {
-			const n = this._nodes.get(head);
-			if (n) return n;
-			if (this._mounts.has(head)) {
-				throw new Error(
-					`Graph "${this.name}": path ends at subgraph "${head}" — not a node (GRAPHREFLY-SPEC §3.5)`,
-				);
-			}
-			throw new Error(`Graph "${this.name}": unknown name "${head}"`);
-		}
-
-		const localN = this._nodes.get(head);
-		if (localN && rest.length > 0 && rest[0] === GRAPH_META_SEGMENT) {
-			return this._resolveMetaChainFromNode(localN, rest, seg.join(PATH_SEP));
-		}
-
-		const child = this._mounts.get(head);
-		if (!child) {
-			if (this._nodes.has(head)) {
-				throw new Error(
-					`Graph "${this.name}": "${head}" is a node; trailing path "${rest.join(PATH_SEP)}" is invalid`,
-				);
-			}
-			throw new Error(`Graph "${this.name}": unknown mount or node "${head}"`);
-		}
-
-		return child.resolve(rest.join(PATH_SEP));
-	}
-
-	/**
-	 * Resolve `::__meta__::key` segments from a registered primary node (possibly chained).
-	 */
-	private _resolveMetaChainFromNode(n: Node, parts: readonly string[], fullPath: string): Node {
-		let current = n;
-		let i = 0;
-		const p = [...parts];
-		while (i < p.length) {
-			if (p[i] !== GRAPH_META_SEGMENT) {
-				throw new Error(
-					`Graph "${this.name}": expected ${GRAPH_META_SEGMENT} segment in meta path "${fullPath}"`,
-				);
-			}
-			if (i + 1 >= p.length) {
-				throw new Error(
-					`Graph "${this.name}": meta path requires a key after ${GRAPH_META_SEGMENT} in "${fullPath}"`,
-				);
-			}
-			const key = p[i + 1] as string;
-			const next = current.meta[key];
-			if (!next) {
-				throw new Error(`Graph "${this.name}": unknown meta "${key}" in path "${fullPath}"`);
-			}
-			current = next;
-			i += 2;
-		}
-		return current;
-	}
-
-	/**
-	 * Deliver a message batch to every registered node in this graph and, recursively,
-	 * in mounted child graphs (§3.7). Recurses into mounts first, then delivers to
-	 * local nodes (sorted by name). Each {@link Node} receives at most one delivery
-	 * per call (deduped by reference).
-	 *
-	 * **Primary-vs-meta filter asymmetry (intentional):** primary nodes receive the
-	 * unfiltered `messages` batch — that's the canonical data-plane flow. Companion
-	 * `meta` nodes receive a filtered subset keyed by the per-type `metaPassthrough`
-	 * flag on {@link GraphReFlyConfig}. Built-in defaults: PAUSE / RESUME / DATA /
-	 * RESOLVED pass through to meta; INVALIDATE / COMPLETE / ERROR / TEARDOWN do
-	 * not.
-	 *
-	 * **Where lifecycle terminals reach meta:**
-	 * - **TEARDOWN** — primary's `_emit` cascades to meta children directly (see
-	 *   `core/node.ts` "Meta TEARDOWN fan-out" block) so meta is torn down with
-	 *   its primary regardless of the signal-level filter.
-	 * - **COMPLETE / ERROR / INVALIDATE** — scoped to primaries on the broadcast
-	 *   path. Meta companions are an attribution side-channel, not a lifecycle
-	 *   participant; address meta directly via `meta.down(...)` if you need to
-	 *   forward these. Audit confirmed 2026-04-17: no current meta consumer
-	 *   relies on broadcast COMPLETE/ERROR/INVALIDATE delivery.
-	 *
-	 * @param messages - Batch to deliver to every registered node (and mounts, recursively).
-	 * @param options - Optional `actor` / `internal` for transport.
-	 */
-	signal(messages: Messages, options?: GraphActorOptions): void {
-		// Reject tier 3 (DATA / RESOLVED) when called externally — destroy()
-		// routes through signal with `{internal: true}` which bypasses this
-		// check. Broadcasting per-flow values to every node in the tree is
-		// almost always a mistake.
-		if (options?.internal !== true) {
-			for (const m of messages) {
-				const tier = this.config.messageTier(m[0]);
-				// Tier 3 (DATA / RESOLVED) is per-flow state — broadcasting it
-				// to every node overwrites unrelated caches. Tier 4 INVALIDATE,
-				// tier 5 COMPLETE/ERROR, and tier 6 TEARDOWN all stay allowed:
-				// they have legitimate broadcast use (cache reset, graceful
-				// shutdown, error cascade, teardown).
-				if (tier === 3) {
-					throw new Error(
-						`Graph "${this.name}": Graph.signal() rejects tier-3 messages (DATA / RESOLVED). ` +
-							`Broadcast is for control-plane (START / DIRTY / PAUSE / RESUME / INVALIDATE) and lifecycle (COMPLETE / ERROR / TEARDOWN) tiers. ` +
-							`For per-node value writes, use Graph.set or graph.node(name).down(...).`,
-					);
-				}
-			}
-		}
-		const errors: unknown[] = [];
-		this._signalDeliver(messages, options ?? {}, new Set(), errors);
-		// Surface the first collected error so callers see failures without
-		// aborting the rest of the broadcast. Guard denials are re-thrown
-		// immediately in _signalDeliver (deliberate access-control rejections).
-		if (errors.length > 0) throw errors[0];
-	}
-
-	private _signalDeliver(
-		messages: Messages,
-		opts: GraphActorOptions,
-		vis: Set<Node>,
-		errors: unknown[],
-	): void {
-		for (const sub of this._mounts.values()) {
-			sub._signalDeliver(messages, opts, vis, errors);
-		}
-		const internal = opts.internal === true;
-		const downOpts: NodeTransportOptions = internal
-			? { internal: true }
-			: { actor: opts.actor, delivery: "signal" };
-		const metaMessages = filterMetaMessages(messages, this.config);
-		for (const localName of [...this._nodes.keys()].sort()) {
-			const n = this._nodes.get(localName)!;
-			if (vis.has(n)) continue;
-			vis.add(n);
-			try {
-				n.down(messages, downOpts);
-			} catch (err) {
-				// Guard denials bubble — they're deliberate rejections, not
-				// resilience failures. Other errors collect so one bad handler
-				// doesn't abort the rest of the broadcast.
-				if (err instanceof GuardDenied) throw err;
-				errors.push(err);
-			}
-			if (metaMessages.length === 0) continue;
-			this._signalMetaSubtree(n, metaMessages, vis, downOpts, errors);
-		}
-	}
-
-	private _signalMetaSubtree(
-		root: Node,
-		messages: Messages,
-		vis: Set<Node>,
-		downOpts: NodeTransportOptions,
-		errors: unknown[],
-	): void {
-		for (const mk of Object.keys(root.meta).sort()) {
-			const mnode = root.meta[mk];
-			if (vis.has(mnode)) continue;
-			vis.add(mnode);
-			try {
-				mnode.down(messages, downOpts);
-			} catch (err) {
-				if (err instanceof GuardDenied) throw err;
-				errors.push(err);
-			}
-			this._signalMetaSubtree(mnode, messages, vis, downOpts, errors);
-		}
-	}
-
-	/**
-	 * Static structure snapshot: qualified node keys, edges, mount names (GRAPHREFLY-SPEC §3.6, Appendix B).
-	 *
-	 * Returns the {@link GraphDescribeOutput} object directly (or a
-	 * `ReactiveDescribeHandle` when `{ reactive: true | "diff" }` is set).
-	 *
-	 * For formatted output (Mermaid / D2 / ASCII / pretty / JSON text), pass
-	 * the snapshot to one of the pure renderers in
-	 * `@graphrefly/graphrefly/extra/render`:
-	 *
-	 * ```ts
-	 * import { graphSpecToMermaid, graphSpecToAscii } from "@graphrefly/graphrefly/extra/render";
-	 *
-	 * const mermaid = graphSpecToMermaid(graph.describe());
-	 * const ascii = graphSpecToAscii(graph.describe(), { direction: "TD" });
-	 * ```
-	 *
-	 * For live formatted output, compose with `derived`:
-	 *
-	 * ```ts
-	 * import { derived } from "@graphrefly/pure-ts";
-	 * import { graphSpecToMermaid } from "@graphrefly/graphrefly/extra/render";
-	 *
-	 * const live = derived(
-	 *   [graph.describe({ reactive: true }).node],
-	 *   ([g]) => graphSpecToMermaid(g),
-	 * );
-	 * ```
-	 *
-	 * For the spec projection (type + deps + meta, strip runtime status/value),
-	 * pass `detail: "spec"`.
-	 *
-	 * @param options - Optional `actor` for guard-scoped visibility, `filter`
-	 *   for selective output, `detail` / `fields` for projection, `reactive`
-	 *   for the live handle.
-	 *
-	 * @example
-	 * ```ts
-	 * graph.describe()                                         // full snapshot object
-	 * graph.describe({ filter: { status: "errored" } })        // filtered object
-	 * graph.describe({ detail: "spec" })                       // GraphSpec projection
-	 * graph.describe({ reactive: true })                       // live snapshot Node
-	 * ```
-	 */
-	describe(
-		options: GraphDescribeOptions & { reactive: "diff" },
-	): ReactiveDescribeHandle<DescribeChangeset>;
-	describe(
-		options: GraphDescribeOptions & { reactive: true },
-	): ReactiveDescribeHandle<GraphDescribeOutput>;
-	describe(options?: GraphDescribeOptions): GraphDescribeOutput;
-	/**
-	 * Explain mode — causal-chain walkback from `from` to `to`. Wraps
-	 * {@link explainPath}; previously a top-level `Graph.explain` method,
-	 * folded into describe so all topology queries route through one entry
-	 * point. Accepts the same Tier 3.5 reactive-arg carve-out (F.9) as the
-	 * pre-fold method: `from`/`to`/`maxDepth`/`findCycle` may be Node-typed.
-	 *
-	 * Mutually exclusive with `detail`/`fields`/`filter`/`actor` and with
-	 * `reachable` — the runtime throws `TypeError` on any conflict.
-	 */
-	// DF13 — narrowed overloads. The static form REJECTS `reactive: true` by
-	// excluding the `true` literal (only `false | undefined` accepted) AND by
-	// rejecting `name` / `reactiveName` (those only apply in reactive mode).
-	// The reactive form REQUIRES `reactive: true` literal so callers cannot
-	// silently fall back to the static return when they meant a live Node.
-	describe(options: {
-		explain: GraphDescribeExplainInput;
-		reactive?: false | undefined;
-		reactiveName?: never;
-		name?: never;
-	}): CausalChain;
-	describe(options: {
-		explain: GraphDescribeExplainInput;
-		reactive: true;
-		reactiveName?: string;
-		name?: string;
-	}): { node: Node<CausalChain>; dispose: () => void };
-	/**
-	 * Reachable mode — sorted path list (or rich {@link ReachableResult}
-	 * when `withDetail: true`) for the dep-walk rooted at `from`. Wraps the
-	 * standalone {@link reachable} fn over `this.describe()`. Static-only
-	 * (no reactive form); for live reachability compose
-	 * `derived([describe({reactive: true}).node], (g) => reachable(g, ...))`.
-	 *
-	 * Mutually exclusive with `detail`/`fields`/`filter`/`actor` and with
-	 * `explain` — the runtime throws `TypeError` on any conflict.
-	 */
-	describe(options: {
-		reachable: GraphDescribeReachableInput & { withDetail: true };
-	}): ReachableResult;
-	describe(options: { reachable: GraphDescribeReachableInput & { withDetail?: false } }): string[];
-	describe(
-		options?:
-			| GraphDescribeOptions
-			| {
-					explain: GraphDescribeExplainInput;
-					reactive?: boolean;
-					reactiveName?: string;
-					name?: string;
-			  }
-			| { reachable: GraphDescribeReachableInput },
-	):
-		| GraphDescribeOutput
-		| ReactiveDescribeHandle<unknown>
-		| CausalChain
-		| { node: Node<CausalChain>; dispose: () => void }
-		| string[]
-		| ReachableResult {
-		// Explain / reachable mode dispatch (folded from former top-level
-		// Graph.explain / Graph.reachable methods). Mutually exclusive with
-		// the topology options below — A6 detail/fields exclusivity precedent.
-		if (options != null && typeof options === "object") {
-			const hasExplain = "explain" in options && (options as { explain?: unknown }).explain != null;
-			const hasReachable =
-				"reachable" in options && (options as { reachable?: unknown }).reachable != null;
-			if (hasExplain || hasReachable) {
-				if (hasExplain && hasReachable) {
-					throw new TypeError(
-						"Graph.describe(): pass either `explain` or `reachable`, not both. " +
-							"They are mutually exclusive query modes.",
-					);
-				}
-				const opts = options as Record<string, unknown>;
-				for (const conflicting of ["detail", "fields", "filter", "actor"]) {
-					if (opts[conflicting] !== undefined) {
-						throw new TypeError(
-							`Graph.describe(): \`${hasExplain ? "explain" : "reachable"}\` mode does ` +
-								`not accept \`${conflicting}\` — those options shape the topology ` +
-								"snapshot, not the query result. Pass them on a separate `describe()` call.",
-						);
-					}
-				}
-				if (hasExplain) {
-					const ex = (options as { explain: GraphDescribeExplainInput }).explain;
-					const reactive = (options as { reactive?: boolean }).reactive === true;
-					if ((options as { reactive?: boolean | "diff" }).reactive === "diff") {
-						throw new TypeError(
-							'Graph.describe(): `explain` mode does not support `reactive: "diff"`. ' +
-								"Use `reactive: true` for a live causal chain or omit `reactive` for a snapshot.",
-						);
-					}
-					if (reactive) {
-						const explainOpts: {
-							maxDepth?: number | Node<number>;
-							findCycle?: boolean | Node<boolean>;
-							name?: string;
-						} = {};
-						if (ex.maxDepth !== undefined) explainOpts.maxDepth = ex.maxDepth;
-						if (ex.findCycle !== undefined) explainOpts.findCycle = ex.findCycle;
-						const nameOpt =
-							(options as { name?: string; reactiveName?: string }).name ??
-							(options as { reactiveName?: string }).reactiveName;
-						if (nameOpt !== undefined) explainOpts.name = nameOpt;
-						return this._explainReactive(ex.from, ex.to, explainOpts);
-					}
-					return this._explainStatic(resolveExplainPath(ex.from), resolveExplainPath(ex.to), {
-						...(ex.maxDepth !== undefined ? { maxDepth: resolveExplainNumber(ex.maxDepth) } : {}),
-						...(ex.findCycle !== undefined
-							? { findCycle: resolveExplainBoolean(ex.findCycle) }
-							: {}),
-					});
-				}
-				// Reachable mode. Static-only — `reactive: true` and
-				// `reactive: "diff"` are rejected; explicit `reactive: false`
-				// and `reactive: undefined` are accepted as no-ops so callers
-				// using spread-style defaults (`{ ...defaults, reachable: ... }`
-				// where defaults may carry `reactive: false`) don't trip a
-				// TypeError on the implicit-default value (qa BH1/EC8 — match
-				// the explain-mode asymmetry where `reactive: false` is also
-				// a no-op).
-				const reachableReactive = (options as { reactive?: unknown }).reactive;
-				if (reachableReactive === true || reachableReactive === "diff") {
-					throw new TypeError(
-						"Graph.describe(): `reachable` mode is static-only. For live reachability, " +
-							"compose `derived([describe({ reactive: true }).node], (g) => reachable(g, ...))`.",
-					);
-				}
-				const r = (options as { reachable: GraphDescribeReachableInput }).reachable;
-				if (r.withDetail === true) {
-					return reachable(this.describe(), r.from, r.direction, {
-						...r,
-						withDetail: true,
-					});
-				}
-				return reachable(this.describe(), r.from, r.direction, r);
-			}
-		}
-		const topologyOptions = options as GraphDescribeOptions | undefined;
-		if (topologyOptions?.reactive === "diff") return this._describeReactiveDiff(topologyOptions);
-		if (topologyOptions?.reactive === true) return this._describeReactive(topologyOptions);
-		const actor = resolveActorOption(topologyOptions?.actor);
-		const filter = topologyOptions?.filter;
-		// `detail` and `fields` are mutually exclusive. Mixing them was
-		// permissive at one point but produced ambiguous spec-mode semantics
-		// (e.g. `{detail: "spec", fields: [...]}` had `isSpec: true` but
-		// non-spec field projection — see review session findings A6).
-		if (topologyOptions?.detail != null && topologyOptions?.fields != null) {
-			throw new TypeError(
-				"Graph.describe(): pass either `detail` or `fields`, not both. " +
-					"`detail: 'spec'` is the canonical spec projection; " +
-					"use `fields` only when you need a custom subset.",
-			);
-		}
-		const includeFields = resolveDescribeFields(topologyOptions?.detail, topologyOptions?.fields);
-		// `detail: "spec"` is the canonical spec-projection mode (Tier 1.5.3
-		// Phase 1 — replaces the old `format: "spec"` alias). Strips
-		// annotations from the output so the result round-trips through
-		// GraphSpec via `decompileSpec`. Phase 3 also gates `value` to
-		// state nodes only — passed to `describeNode` as the third arg.
-		const isSpec = topologyOptions?.detail === "spec";
-		const effectiveFields = includeFields;
-
-		const targets: [string, Node][] = [];
-		this._collectObserveTargets("", targets);
-		const nodeToPath = new Map<Node, string>();
-		for (const [p, n] of targets) {
-			nodeToPath.set(n, p);
-		}
-
-		// Transitive-deps expansion. Factories like `promptNode` create
-		// unnamed derived helpers (the `::messages` node, switchMap internals)
-		// and only expose their terminal output via `graph.add`. Those helpers
-		// still show up as real `_deps` pointers on their downstream consumer,
-		// so without this walk `describe()` emits dangling path strings that
-		// don't resolve to any entry in `.nodes` — breaking `explainPath` and
-		// any other snapshot walker. Per COMPOSITION-GUIDE §24 ("edges are
-		// derived, not declared — if describe shows an edge, there is a real
-		// protocol subscription"), every dep surfaced as an edge must also be
-		// described. This BFS walks upstream through `_deps` from every
-		// registered member, assigns each orphan a stable path (from its
-		// `meta.name` if unique, else `${name}#N`, else a synthetic
-		// `__internal__/...` key), and feeds them to the existing describe
-		// loop below.
-		const additionalTargets: [string, Node][] = [];
-		{
-			const queue: Node[] = targets.map(([, n]) => n);
-			const usedPaths = new Set(nodeToPath.values());
-			let synthetic = 0;
-			while (queue.length > 0) {
-				const current = queue.shift() as Node;
-				if (!(current instanceof NodeImpl)) continue;
-				for (const dep of current._deps) {
-					const dn = dep.node;
-					if (nodeToPath.has(dn)) continue;
-					// Assign a path. Prefer meta.name so the string matches the
-					// dangling pointer that the consumer's `deps` already
-					// showed — callers who previously saw `"brief::messages"`
-					// in `deps[]` now find a matching entry under that key.
-					const metaName = (dn as { name?: string }).name ?? "";
-					let path = metaName;
-					if (!path || usedPaths.has(path)) {
-						if (metaName) {
-							let n = 2;
-							while (usedPaths.has(`${metaName}#${n}`)) n++;
-							path = `${metaName}#${n}`;
-						} else {
-							path = `__internal__/${synthetic++}`;
-							while (usedPaths.has(path)) path = `__internal__/${synthetic++}`;
-						}
-					}
-					nodeToPath.set(dn, path);
-					usedPaths.add(path);
-					additionalTargets.push([path, dn]);
-					queue.push(dn);
-				}
-			}
-		}
-		const allTargets: [string, Node][] = [...targets, ...additionalTargets];
-
-		const nodes: Record<string, DescribeNodeOutput> = {};
-		for (const [p, n] of allTargets) {
-			if (actor != null && !n.allowsObserve(actor)) continue;
-			const raw = describeNode(n, effectiveFields, isSpec);
-			const deps =
-				n instanceof NodeImpl
-					? n._deps.map((d) => nodeToPath.get(d.node) ?? d.node.name ?? "")
-					: [];
-			const { name: _name, ...rest } = raw;
-			const entry: DescribeNodeOutput = { ...rest, deps };
-			// Resolve `meta.attachTarget` Node refs to their qualified path
-			// in the snapshot — same mechanism as `deps` resolves Node refs
-			// via `nodeToPath`. Soft forward edges
-			// (src/base/meta/attach-edge-meta.ts) surface in `explainPath`
-			// so causal chains can walk past imperative subscribe-and-
-			// publish hops (e.g. topicBridge → target.events) that have no
-			// declared dep. Wave propagation is unchanged — soft edges are
-			// an explainability concern only.
-			if (entry.meta != null) {
-				const at = (entry.meta as Record<string, unknown>).attachTarget;
-				if (
-					at != null &&
-					typeof at === "object" &&
-					typeof (at as { subscribe?: unknown }).subscribe === "function" &&
-					"cache" in (at as Record<string, unknown>)
-				) {
-					const targetNode = at as Node;
-					const resolved = nodeToPath.get(targetNode) ?? targetNode.name ?? "";
-					entry.meta = { ...entry.meta, attachTarget: resolved };
-				}
-			}
-			// Attach annotation from `trace(path, annotation)` or from
-			// `graph.add(node, { name: path, annotation })` when one exists. Skipped
-			// for the `"spec"` format (input-schema use case — annotations
-			// don't round-trip through GraphSpec).
-			if (!isSpec) {
-				const annotation = this._annotations.get(p);
-				if (annotation != null) entry.annotation = annotation;
-			}
-			if (filter != null) {
-				if (typeof filter === "function") {
-					const fn = filter as
-						| ((nodePath: string, node: DescribeNodeOutput) => boolean)
-						| ((node: DescribeNodeOutput) => boolean);
-					const pass =
-						fn.length >= 2
-							? (fn as (nodePath: string, node: DescribeNodeOutput) => boolean)(p, entry)
-							: (fn as (node: DescribeNodeOutput) => boolean)(entry);
-					if (!pass) continue;
-				} else {
-					let match = true;
-					for (const [fk, fv] of Object.entries(filter)) {
-						const normalizedKey =
-							fk === "deps_includes" ? "depsIncludes" : fk === "meta_has" ? "metaHas" : fk;
-						if (normalizedKey === "depsIncludes") {
-							if (!entry.deps.includes(String(fv))) {
-								match = false;
-								break;
-							}
-							continue;
-						}
-						if (normalizedKey === "metaHas") {
-							if (!Object.hasOwn(entry.meta ?? {}, String(fv))) {
-								match = false;
-								break;
-							}
-							continue;
-						}
-						if ((entry as Record<string, unknown>)[normalizedKey] !== fv) {
-							match = false;
-							break;
-						}
-					}
-					if (!match) continue;
-				}
-			}
-			nodes[p] = entry;
-		}
-		const nodeKeys = new Set(Object.keys(nodes));
-		// Edges derived from node `_deps` over the expanded `nodeToPath` (so
-		// transitive-deps entries — e.g. `brief::messages` — have edges to
-		// their own upstream + from their downstream consumer, not just the
-		// registered-member-only subset `this.edges({recursive: true})` would
-		// give). Sorted to match the old contract.
-		const edgeList: [string, string][] = [];
-		for (const [path, n] of allTargets) {
-			if (!(n instanceof NodeImpl)) continue;
-			for (const dep of n._deps) {
-				const from = nodeToPath.get(dep.node);
-				if (from != null) edgeList.push([from, path]);
-			}
-		}
-		edgeList.sort((a, b) =>
-			a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : a[1] < b[1] ? -1 : a[1] > b[1] ? 1 : 0,
-		);
-		let edges: { from: string; to: string }[] = edgeList.map(([from, to]) => ({ from, to }));
-		if (actor != null || filter != null) {
-			edges = edges.filter((e) => nodeKeys.has(e.from) && nodeKeys.has(e.to));
-		}
-		const allSubgraphs = this._collectSubgraphs("");
-		const subgraphs =
-			actor != null || filter != null
-				? allSubgraphs.filter((sg) => {
-						const prefix = `${sg}${PATH_SEP}`;
-						return [...nodeKeys].some((k) => k === sg || k.startsWith(prefix));
-					})
-				: allSubgraphs;
-
-		// DF1 (Tier 5, 2026-04-30 lock — `docs/optimizations.md` "DF1"). Compound
-		// factories that emit `parent::child` topology MUST stamp `meta.factory`
-		// on the parent so `decompileSpec` / `compileSpec` can round-trip the
-		// factory's internals. The decompileSpec pre-pass enforces this at
-		// spec-projection time, but a graph that won't round-trip is a graph
-		// that can't be inspected via the standard tools — surface the failure
-		// at every describe() call so the offending factory author fixes it
-		// before it lands in a snapshot or a `compileSpec` round-trip.
-		//
-		// Walk the FULL set of resolved paths (not the post-filter `nodes` map)
-		// so an `actor` / `filter` projection can't hide a violation. Skip
-		// known internal prefixes (meta companions, feedback / bridge
-		// infrastructure, transitive-deps `__internal__/...`) and parents that
-		// are subgraph mounts (those carry their factory tag on the Graph
-		// itself via `tagFactory`, and the local `_nodes` map of a mount does
-		// not include the mount's own name as a node entry).
-		const strictFactoryTags = topologyOptions?.strictFactoryTags !== false;
-		if (strictFactoryTags) {
-			const allPathsMap = new Map<string, Node>();
-			for (const [p, n] of allTargets) allPathsMap.set(p, n);
-			const subgraphPaths = new Set(allSubgraphs);
-			for (const [path, _node] of allPathsMap) {
-				const sepIdx = path.indexOf(PATH_SEP);
-				if (sepIdx <= 0) continue;
-				const parent = path.slice(0, sepIdx);
-				// Skip meta-companion paths (`name::__meta__::key`) — meta is
-				// not a factory output by definition.
-				if (path.includes(`${PATH_SEP}${GRAPH_META_SEGMENT}${PATH_SEP}`)) continue;
-				// Skip well-known internal prefixes (feedback / bridge /
-				// transitive-deps synthetic paths). Mirrors decompileSpec.
-				// A10 (QA fix 2026-05-01): tightened from `startsWith` to anchored
-				// regex so a user-typed name like `__internal__/evil` or
-				// `__feedback_effect_attacker` can't opt itself out of the strict
-				// factory-tag check. Synthetic IDs are numeric per graph.ts:
-				// `__internal__/<digits>`, `__feedback_effect_<digits>`,
-				// `__bridge_<digits>`. Anything off-pattern falls through to
-				// the assertion.
-				if (/^__internal__\/\d+($|::)/.test(path)) continue;
-				if (/^__feedback_effect_\d+($|::)/.test(path)) continue;
-				if (/^__bridge_\d+($|::)/.test(path)) continue;
-				// Parent is a subgraph mount — tagged via Graph.tagFactory, not
-				// node meta. The mount itself is not a node entry, so the
-				// `allPathsMap.has(parent)` check below already skips this case
-				// most of the time, but guard explicitly for clarity.
-				if (subgraphPaths.has(parent)) continue;
-				const parentNode = allPathsMap.get(parent);
-				// Parent isn't a registered node — treat as a regular `::`-named
-				// node, not a compound factory. Allowed (e.g. naming convention
-				// in user code).
-				if (parentNode == null) continue;
-				// Parent IS in the graph — check `meta.factory`.
-				const parentMeta = parentNode.meta as Record<string, Node> | undefined;
-				const factoryNode = parentMeta?.factory;
-				const hasFactory = factoryNode != null && typeof factoryNode.cache === "string";
-				if (hasFactory) continue;
-				throw new TypeError(
-					`Graph "${this.name}".describe(): untagged compound factory at "${parent}" ` +
-						`(child: "${path}"). Compound factories that ship \`parent::child\` topology ` +
-						"MUST stamp `meta.factory` on the parent so decompileSpec/compileSpec can " +
-						"reconstruct the internals. Add " +
-						`\`{ meta: factoryTag("${parent}", placeholderArgs(opts)) }\` to the parent's ` +
-						'constructor (see docs/optimizations.md "DF1" and ' +
-						"COMPOSITION-GUIDE.md §38). To opt out for legacy/debug graphs, pass " +
-						"`describe({ strictFactoryTags: false })`.",
-				);
-			}
-		}
-
-		// Capture graph ref and base options for expand()
-		const graph = this;
-		const baseOpts = topologyOptions;
-
-		const struct: GraphDescribeOutput = {
-			name: this.name,
-			nodes,
-			edges,
-			subgraphs,
-			...(this._factory !== undefined ? { factory: this._factory } : {}),
-			...(this._factoryArgs !== undefined ? { factoryArgs: this._factoryArgs } : {}),
-			expand(detailOrFields: DescribeDetail | DescribeField[]): GraphDescribeOutput {
-				const merged: GraphDescribeOptions = { ...baseOpts };
-				if (Array.isArray(detailOrFields)) {
-					merged.fields = detailOrFields;
-					merged.detail = undefined;
-				} else {
-					merged.detail = detailOrFields;
-					merged.fields = undefined;
-				}
-				return graph.describe(merged);
-			},
-		};
-
-		// Tier 2.1 A2: `format` option dropped — use the pure renderers in
-		// `@graphrefly/graphrefly/extra/render` (`graphSpecToMermaid`,
-		// `graphSpecToAscii`, `graphSpecToD2`, `graphSpecToPretty`,
-		// `graphSpecToJson`, `graphSpecToMermaidUrl`) on the returned
-		// snapshot, or compose
-		// `derived([describe({reactive:true}).node], graphSpecToMermaid)` for
-		// live formatted output.
-		return struct;
-	}
-
-	private _collectSubgraphs(prefix: string): string[] {
-		const out: string[] = [];
-		for (const m of [...this._mounts.keys()].sort()) {
-			const q = prefix === "" ? m : `${prefix}${m}`;
-			out.push(q);
-			out.push(...this._mounts.get(m)!._collectSubgraphs(`${q}${PATH_SEP}`));
-		}
-		return out;
-	}
-
-	/**
-	 * Snapshot-based resource profile: per-node stats, orphan effect detection,
-	 * memory hotspots. Zero runtime overhead — walks nodes on demand.
-	 *
-	 * @param opts - Optional `topN` for hotspot limit (default 10).
-	 * @returns Aggregate profile with per-node details, hotspots, and orphan effects.
-	 */
-	resourceProfile(opts?: GraphProfileOptions): GraphProfileResult {
-		return graphProfile(this, opts);
-	}
-
-	private _explainStatic(
-		from: string,
-		to: string,
-		opts?: { maxDepth?: number; findCycle?: boolean },
-	): CausalChain {
-		// `detail: "full"` includes `value`, `status`, `lastMutation`, `v`, etc.
-		// — everything `explainPath` enriches each step with.
-		const described = this.describe({ detail: "full" });
-		const annotations = new Map<string, string>(this._annotations);
-		const lastMutations = new Map<string, Readonly<{ actor: Actor; timestamp_ns: number }>>();
-		for (const [path, n] of Object.entries(described.nodes)) {
-			if (n.lastMutation != null) lastMutations.set(path, n.lastMutation);
-		}
-		return explainPath(described, from, to, {
-			...(opts?.maxDepth != null ? { maxDepth: opts.maxDepth } : {}),
-			...(opts?.findCycle === true ? { findCycle: true as const } : {}),
-			annotations,
-			lastMutations,
-		});
-	}
-
-	private _describeReactive(
-		options: GraphDescribeOptions,
-	): ReactiveDescribeHandle<GraphDescribeOutput> {
-		// Strip the `reactive` flag so the inner recompute returns the
-		// snapshot object, not another reactive handle.
-		const innerOpts: GraphDescribeOptions = { ...options, reactive: false };
-		const name = options.reactiveName ?? "describe";
-		let v = 0;
-		const version = node<number>([], { initial: v, name: `${name}_version` });
-		const handle = this.observe({ timeline: true, structured: true });
-		let pendingBump = false;
-		let disposed = false;
-		const bump = (): void => {
-			if (pendingBump || disposed) return;
-			pendingBump = true;
-			// Same coalescer as _explainReactive (D5) — N events per batch → 1
-			// recompute at head of next drain. Outside a batch the hook fires
-			// immediately, preserving sync-wave behavior.
-			registerBatchFlushHook(() => {
-				pendingBump = false;
-				if (disposed) return;
-				v += 1;
-				version.emit(v);
-			});
-		};
-		const off = handle.onEvent((event) => {
-			const t = event.type;
-			if (t !== "data" && t !== "error" && t !== "complete" && t !== "teardown") return;
-			bump();
-		});
-
-		// Describe must reflect the FULL subtree (`_collectSubgraphs` walks
-		// mounted children), so the reactive variant subscribes to each
-		// mounted graph's `topology` too — `topology` is own-graph only
-		// per its JSDoc, so a parent's emitter never fires for structural
-		// changes inside a child. Walk at subscribe time, then listen for
-		// `added` events with `nodeKind: "mount"` to discover subgraphs that
-		// land after subscription and subscribe transitively.
-		const topoUnsubs: Array<() => void> = [];
-		const subscribedGraphs = new WeakSet<Graph>();
-		const subscribeToTopology = (g: Graph): void => {
-			if (subscribedGraphs.has(g) || disposed) return;
-			subscribedGraphs.add(g);
-			const unsub = g.topology.subscribe((msgs) => {
-				for (const m of msgs) {
-					if (m[0] !== DATA) continue;
-					const event = m[1] as TopologyEvent;
-					bump();
-					// A newly-mounted child's own topology events won't surface
-					// here — subscribe to it too. `added` is the only variant
-					// that exposes a mount; `removed` drops the mount entirely
-					// and disposes its internals.
-					if (event.kind === "added" && event.nodeKind === "mount") {
-						const child = g._mounts.get(event.name);
-						if (child != null) subscribeToTopology(child);
-					}
-				}
-			});
-			topoUnsubs.push(unsub);
-			// Seed with already-mounted children — topology does not replay
-			// historical events to late subscribers (per §3.6).
-			for (const childName of g._mounts.keys()) {
-				const child = g._mounts.get(childName);
-				if (child != null) subscribeToTopology(child);
-			}
-		};
-		subscribeToTopology(this);
-
-		// Reactive-actor binding (B.1 / Unit 6). When `options.actor` is a
-		// `Node<Actor>`, subscribe to it and route DATA emits through the same
-		// `bump()` coalescer as topology / observe events — so a coordinated
-		// actor change + structural change still produces exactly one
-		// recompute. The inner static `describe(innerOpts)` resolves the
-		// actor's current cache on each recompute (via `resolveActorOption`),
-		// so no per-recompute opts mutation is needed.
-		//
-		// On terminal types (`COMPLETE`/`ERROR`/`TEARDOWN`), release the
-		// actor subscription and trigger one final `bump()` so describe
-		// snapshots the last-known actor cache. Subsequent describe outputs
-		// reflect that frozen cache until `handle.dispose()` runs.
-		let actorUnsub: (() => void) | undefined;
-		const actorOpt = options.actor;
-		if (isActorNode(actorOpt)) {
-			actorUnsub = actorOpt.subscribe((msgs) => {
-				let sawData = false;
-				let terminated = false;
-				for (const m of msgs) {
-					const t = m[0];
-					if (t === DATA) sawData = true;
-					else if (t === COMPLETE || t === ERROR || t === TEARDOWN) terminated = true;
-				}
-				if (sawData) bump();
-				if (terminated) {
-					actorUnsub?.();
-					actorUnsub = undefined;
-					bump();
-				}
-			});
-		}
-
-		let reactiveDescNode: Node<GraphDescribeOutput>;
-		try {
-			reactiveDescNode = node<GraphDescribeOutput>(
-				[version],
-				(_data, actions) => {
-					actions.emit(this.describe(innerOpts) as GraphDescribeOutput);
-				},
-				{
-					name,
-					describeKind: "derived",
-					meta: { domain: "audit", kind: "describe" } as const,
-					// Reference-only equals is fine — describe() rebuilds a fresh
-					// object every call. Users who want structural dedup can wrap
-					// with their own derived + structural `equals`.
-					equals: (a: GraphDescribeOutput, b: GraphDescribeOutput) => a === b,
-				},
-			);
-		} catch (err) {
-			off();
-			actorUnsub?.();
-			for (const u of topoUnsubs) u();
-			handle.dispose();
-			throw err;
-		}
-		const stopKeepalive = keepalive(reactiveDescNode);
-
-		return {
-			node: reactiveDescNode,
-			dispose() {
-				disposed = true;
-				off();
-				actorUnsub?.();
-				for (const u of topoUnsubs) u();
-				topoUnsubs.length = 0;
-				handle.dispose();
-				stopKeepalive();
-			},
-		};
-	}
-
-	/**
-	 * Reactive topology-diff variant of `describe()`. Wraps `_describeReactive`'s
-	 * snapshot stream and emits a `DescribeChangeset` per change, suppressing
-	 * empty changesets. The initial cache is a synthetic full-add diff so a
-	 * fresh subscriber sees the current topology as a single `node-added` /
-	 * `edge-added` / `subgraph-mounted` payload via push-on-subscribe.
-	 */
-	private _describeReactiveDiff(
-		options: GraphDescribeOptions,
-	): ReactiveDescribeHandle<DescribeChangeset> {
-		const innerOpts: GraphDescribeOptions = {
-			...options,
-			reactive: false,
-		};
-		const name = options.reactiveName ?? "describe-diff";
-
-		// Synthetic empty snapshot — used as the "from" for the initial diff so
-		// fresh subscribers see the current topology as adds via push-on-subscribe.
-		const empty: GraphDescribeOutput = {
-			name: this.name,
-			nodes: {},
-			edges: [],
-			subgraphs: [],
-		};
-		let prev = this.describe(innerOpts) as GraphDescribeOutput;
-		const initialDiff = topologyDiff(empty, prev);
-
-		const diffNode = node<DescribeChangeset>([], {
-			initial: initialDiff,
-			name,
-			meta: { domain: "audit", kind: "describe-diff" } as const,
-			// Reference equals — every changeset is a fresh object; downstream
-			// consumers wanting structural dedup wrap with their own equals.
-			equals: (a: DescribeChangeset, b: DescribeChangeset) => a === b,
-		});
-
-		// Reuse `_describeReactive` for the bump-on-topology-change machinery
-		// (topology subscription, observe-driven recompute, actor binding,
-		// batch-flush coalescing). Strip `reactiveName` so the snapshot node
-		// gets a default name; we own `name` for the diff node.
-		const snapshotHandle = this._describeReactive({
-			...options,
-			reactiveName: undefined,
-		});
-
-		let disposed = false;
-		const unsub = snapshotHandle.node.subscribe((msgs) => {
-			if (disposed) return;
-			for (const m of msgs) {
-				if (m[0] !== DATA) continue;
-				const next = m[1] as GraphDescribeOutput;
-				const changeset = topologyDiff(prev, next);
-				prev = next;
-				// Suppress empty changesets — consumers should not see no-op DATA.
-				if (changeset.events.length === 0) continue;
-				diffNode.emit(changeset);
-			}
-		});
-
-		const stopKeepalive = keepalive(diffNode);
-
-		return {
-			node: diffNode,
-			dispose() {
-				disposed = true;
-				unsub();
-				snapshotHandle.dispose();
-				// QA F10: settle `diffNode` with TEARDOWN so downstream
-				// subscribers receive a terminal — was previously stuck waiting
-				// indefinitely after dispose() since cleanup only released
-				// internal subs.
-				diffNode.down([[TEARDOWN, "describe-diff disposed"]]);
-				stopKeepalive();
-			},
-		};
-	}
-
-	private _explainReactive(
-		from: string | Node<string>,
-		to: string | Node<string>,
-		opts?: {
-			maxDepth?: number | Node<number>;
-			findCycle?: boolean | Node<boolean>;
-			name?: string;
-		},
-	): { node: Node<CausalChain>; dispose: () => void } {
-		// Closure-held version counter (COMPOSITION-GUIDE §28 / spec §3.6
-		// sanctioned pattern). Every settled observe event bumps `v`, which
-		// drives the derived to recompute.
-		//
-		// Debouncing (D5): without coalescing, each of N graph events inside an
-		// outer batch produces N version bumps — the derived's equals dedupes the
-		// steady state, but the recompute work amplifies with graph traffic.
-		// `registerBatchFlushHook` defers the single bump to the head of the
-		// outermost drain, so N events in one batch collapse to exactly one
-		// recompute. Outside a batch the hook fires immediately (see
-		// `registerBatchFlushHook` contract) — no change to sync-wave behavior.
-		let v = 0;
-		const version = node<number>([], { initial: v, name: "explain_version" });
-		const handle = this.observe({ timeline: true, structured: true });
-		let pendingBump = false;
-		let disposed = false;
-		const bump = (): void => {
-			if (pendingBump || disposed) return;
-			pendingBump = true;
-			registerBatchFlushHook(() => {
-				pendingBump = false;
-				if (disposed) return;
-				v += 1;
-				version.emit(v);
-			});
-		};
-		const off = handle.onEvent((event) => {
-			const t = event.type;
-			if (t !== "data" && t !== "error" && t !== "complete" && t !== "teardown") return;
-			bump();
-		});
-
-		// Tier 3.5 (F.9 reactive primitive carve-out): collect reactive args so
-		// the derived can gate its first emit until they all settle, AND so an
-		// emission bumps the version counter through the same coalescer. Static
-		// args pass through with no subscription. Mirrors the `Node<Actor>`
-		// subscription wired in `_describeReactive`.
-		//
-		// Subscriptions are wired AFTER `derived(...) + keepalive(node)` below
-		// (memory feedback_subscribe_before_kick) — wiring before would mean a
-		// push-on-subscribe DATA bumps version while no one is subscribed to it
-		// yet, and although state's cache holds the value, the explicit ordering
-		// matches the established actor precedent (`_describeReactive`).
-		const reactiveArgs: Array<Node<unknown>> = [];
-		if (from != null && isExplainArgNode<string>(from)) reactiveArgs.push(from as Node<unknown>);
-		if (to != null && isExplainArgNode<string>(to)) reactiveArgs.push(to as Node<unknown>);
-		if (opts?.maxDepth != null && isExplainArgNode<number>(opts.maxDepth))
-			reactiveArgs.push(opts.maxDepth as Node<unknown>);
-		if (opts?.findCycle != null && isExplainArgNode<boolean>(opts.findCycle))
-			reactiveArgs.push(opts.findCycle as Node<unknown>);
-
-		// Gate first emit until every reactive arg has settled. Without this,
-		// an unsettled `Node<string>` for `from` would resolve to `""` (via
-		// `resolveExplainPath` cache fallback) and `_explainStatic` would emit
-		// a noise `{found:false, reason:"no source"}` chain BEFORE the first
-		// real arg DATA. The regression matches the deleted `reactiveExplainPath`
-		// behavior more closely (it never observed an unsettled arg).
-		const allReactiveArgsSettled = (): boolean => {
-			for (const arg of reactiveArgs) {
-				if (arg.cache === undefined) return false;
-			}
-			return true;
-		};
-		// Sentinel chain returned while waiting for reactive args — equals()
-		// dedupes repeated settled states once arg DATA arrives. The
-		// `"pending"` reason was added to CausalChain's reason union for
-		// this case (qa D5).
-		const buildPendingChain = (): CausalChain => {
-			const f = resolveExplainPath(from);
-			const t = resolveExplainPath(to);
-			return {
-				from: f,
-				to: t,
-				found: false,
-				reason: "pending",
-				steps: [],
-				text: "(awaiting reactive args)",
-				toJSON: () => ({ from: f, to: t, found: false, reason: "pending", steps: [] }),
-			};
-		};
-
-		// Try to construct the reactive derived; if it throws (invalid options
-		// etc.), release the observe handle + onEvent listener so we don't
-		// leak resources. Nominal path: push the try-catch out-of-band.
-		//
-		// Resolve reactive args INSIDE the fn so each recompute reads the
-		// latest cache. Static args close over directly.
-		let explainNode: Node<CausalChain>;
-		try {
-			explainNode = node<CausalChain>(
-				[version],
-				(_data, actions) => {
-					if (!allReactiveArgsSettled()) {
-						actions.emit(buildPendingChain());
-					} else {
-						const currentFrom = resolveExplainPath(from);
-						const currentTo = resolveExplainPath(to);
-						const currentOpts = {
-							...(opts?.maxDepth !== undefined
-								? { maxDepth: resolveExplainNumber(opts.maxDepth) }
-								: {}),
-							...(opts?.findCycle !== undefined
-								? { findCycle: resolveExplainBoolean(opts.findCycle) }
-								: {}),
-						};
-						actions.emit(this._explainStatic(currentFrom, currentTo, currentOpts));
-					}
-				},
-				{
-					name: opts?.name ?? "explain",
-					describeKind: "derived",
-					meta: {
-						domain: "audit",
-						kind: "explain_path",
-						from: resolveExplainPath(from),
-						to: resolveExplainPath(to),
-					} as const,
-					equals: (a: CausalChain, b: CausalChain) =>
-						a.found === b.found &&
-						a.reason === b.reason &&
-						a.steps.length === b.steps.length &&
-						causalStepsEqual(a.steps, b.steps),
-				},
-			);
-		} catch (err) {
-			off();
-			handle.dispose();
-			throw err;
-		}
-		const stopKeepalive = keepalive(explainNode);
-
-		// Now wire reactive-arg subscriptions (after derived + keepalive). Each
-		// subscription holder is captured so the terminal handler can self-clear
-		// (matches `_describeReactive`'s actor-handler precedent: drop the unsub
-		// once the arg is terminal because `arg.cache` is frozen at the last
-		// settled value and subsequent recomputes still see it).
-		const argUnsubs: Array<(() => void) | undefined> = [];
-		const subscribeReactiveArg = (arg: Node<unknown>): (() => void) => {
-			let unsub: (() => void) | undefined;
-			unsub = arg.subscribe((msgs) => {
-				let sawData = false;
-				let terminated = false;
-				for (const m of msgs) {
-					const t = m[0];
-					if (t === DATA) sawData = true;
-					else if (t === COMPLETE || t === ERROR || t === TEARDOWN) terminated = true;
-				}
-				// Single bump per wave — covers DATA, terminal, or both.
-				if (sawData || terminated) bump();
-				if (terminated && unsub) {
-					unsub();
-					unsub = undefined;
-				}
-			});
-			return () => {
-				if (unsub) {
-					unsub();
-					unsub = undefined;
-				}
-			};
-		};
-		for (const arg of reactiveArgs) argUnsubs.push(subscribeReactiveArg(arg));
-
-		return {
-			node: explainNode,
-			dispose() {
-				disposed = true;
-				off();
-				for (const u of argUnsubs) u?.();
-				argUnsubs.length = 0;
-				handle.dispose();
-				stopKeepalive();
-			},
-		};
-	}
-
-	/**
-	 * @internal Collect all qualified paths in this graph tree matching a
-	 * glob pattern. Used by scoped autoCheckpoint subscription.
-	 */
-	private _pathsMatching(glob: string): string[] {
-		const re = globToRegex(glob);
-		const targets: [string, Node][] = [];
-		this._collectObserveTargets("", targets);
-		return targets.map(([p]) => p).filter((p) => re.test(p));
-	}
-
-	private _collectObserveTargets(prefix: string, out: [string, Node][]): void {
-		for (const m of [...this._mounts.keys()].sort()) {
-			const p2 = prefix === "" ? m : `${prefix}${PATH_SEP}${m}`;
-			this._mounts.get(m)!._collectObserveTargets(p2, out);
-		}
-		for (const loc of [...this._nodes.keys()].sort()) {
-			const n = this._nodes.get(loc)!;
-			const p = prefix === "" ? loc : `${prefix}${PATH_SEP}${loc}`;
-			out.push([p, n]);
-			this._appendMetaObserveTargets(p, n, out);
-		}
-	}
-
-	private _appendMetaObserveTargets(basePath: string, n: Node, out: [string, Node][]): void {
-		for (const mk of Object.keys(n.meta).sort()) {
-			const m = n.meta[mk];
-			const mp = `${basePath}${PATH_SEP}${GRAPH_META_SEGMENT}${PATH_SEP}${mk}`;
-			out.push([mp, m]);
-			this._appendMetaObserveTargets(mp, m, out);
-		}
-	}
-
-	/**
-	 * Live message stream from one node (or meta path), or from the whole graph (§3.6).
-	 *
-	 * Two modes dispatched on first argument:
-	 * - `observe(path, options?)` — one node. Returns {@link GraphObserveOne}
-	 *   (raw stream), or {@link ObserveResult} when `options` requests structured
-	 *   accumulation (`structured`, `timeline`, `causal`, `derived`, `format`,
-	 *   `detail: "minimal"|"full"`).
-	 * - `observe(options?)` — all nodes. Returns {@link GraphObserveAll} (raw),
-	 *   or {@link ObserveResult} under the same structured trigger conditions.
-	 *
-	 * Structured mode subscribes in sorted path order (code-point). Inspector
-	 * extras (`causal`/`derived`) require `graph.config.inspectorEnabled`;
-	 * when disabled, those fields silently drop and the rest still works.
-	 *
-	 * `ObserveResult` is also an `AsyncIterable<ObserveEvent>` — use
-	 * `for await (const ev of result)` for pull-based consumption.
-	 *
-	 * **Reactive variants:**
-	 * - `observe({ reactive: true })` — returns `Node<ObserveChangeset>`,
-	 *   coalescing all observed events for one outermost batch flush into a
-	 *   single `ObserveChangeset` DATA wave.
-	 * - `observe({ changeset: true })` — returns `Node<GraphChange>`, emitting
-	 *   one DATA per discrete change (data flow + topology + batch boundaries)
-	 *   with edge attribution (`fromPath` + `fromDepIndex`) on each `data`
-	 *   event. Designed as the input layer for `topologyView` (D2 — Three-
-	 *   layer view, see `docs/optimizations.md`). Mutually exclusive with
-	 *   `reactive: true`.
-	 */
-	observe(path: string, options: ObserveOptions & { changeset: true }): Node<GraphChange>;
-	observe(options: ObserveOptions & { changeset: true }): Node<GraphChange>;
-	observe(path: string, options: ObserveOptions & { reactive: true }): Node<ObserveChangeset>;
-	observe(options: ObserveOptions & { reactive: true }): Node<ObserveChangeset>;
-	observe(path: string, options?: ObserveOptions & StructuredTriggers): ObserveResult;
-	observe(path: string, options?: ObserveOptions): GraphObserveOne;
-	observe(options: ObserveOptions & StructuredTriggers): ObserveResult;
-	observe(options?: ObserveOptions): GraphObserveAll;
-	observe(
-		pathOrOpts?: string | ObserveOptions,
-		options?: ObserveOptions,
-	):
-		| GraphObserveOne
-		| GraphObserveAll
-		| ObserveResult
-		| Node<ObserveChangeset>
-		| Node<GraphChange> {
-		const isPath = typeof pathOrOpts === "string";
-		const rawOpts = isPath ? options : (pathOrOpts as ObserveOptions | undefined);
-		const resolved = resolveObserveDetail(rawOpts);
-		// Changeset variant — discrete `GraphChange` events with edge
-		// attribution + topology + batch boundaries. Disjoint from
-		// `reactive: true` (different stream shape).
-		if (resolved.changeset === true) {
-			if (resolved.reactive === true) {
-				throw new TypeError(
-					"Graph.observe(): `changeset: true` and `reactive: true` are mutually exclusive — pick one stream shape.",
-				);
-			}
-			return this._observeChangeset(isPath ? (pathOrOpts as string) : undefined, resolved);
-		}
-		// Reactive variant — coalesces all observed events for a batch into one
-		// `ObserveChangeset` DATA per batch flush. Auto-uses the structured
-		// observer for {@link ObserveEvent} access; tier filter (if set) applies.
-		if (resolved.reactive === true) {
-			return this._observeReactive(isPath ? (pathOrOpts as string) : undefined, resolved);
-		}
-		const wantsStructured =
-			resolved.structured === true ||
-			resolved.timeline === true ||
-			resolved.causal === true ||
-			resolved.derived === true ||
-			resolved.detail === "minimal" ||
-			resolved.detail === "full" ||
-			resolved.format != null;
-		const actor = resolved.actor;
-
-		if (isPath) {
-			const path = pathOrOpts as string;
-			const target = this.resolve(path);
-			if (actor != null && !target.allowsObserve(actor)) {
-				throw new GuardDenied({ actor, action: "observe", nodeName: path });
-			}
-			if (wantsStructured) return this._buildStructuredObserver([[path, target]], resolved, "one");
-			return {
-				subscribe(sink: NodeSink) {
-					return target.subscribe(sink);
-				},
-				up(messages: Messages) {
-					try {
-						target.up?.(messages);
-					} catch (err) {
-						if (err instanceof GuardDenied) return;
-						throw err;
-					}
-				},
-			};
-		}
-
-		const collected: [string, Node][] = [];
-		this._collectObserveTargets("", collected);
-		collected.sort((a, b) => (a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0));
-		const picked =
-			actor == null ? collected : collected.filter(([, nd]) => nd.allowsObserve(actor));
-		if (wantsStructured) return this._buildStructuredObserver(picked, resolved, "all");
-		return {
-			subscribe: (sink: (nodePath: string, messages: Messages) => void) => {
-				const unsubs = picked.map(([p, nd]) =>
-					nd.subscribe((msgs) => {
-						sink(p, msgs);
-					}),
-				);
-				return () => {
-					for (const u of unsubs) u();
-				};
-			},
-			up: (upPath: string, messages: Messages) => {
-				try {
-					const nd = this.resolve(upPath);
-					nd.up?.(messages);
-				} catch (err) {
-					if (err instanceof GuardDenied) return;
-					throw err;
-				}
-			},
-		};
-	}
-
-	/**
-	 * Reactive observe variant — wraps the structured observer and emits one
-	 * `ObserveChangeset` DATA per outermost batch flush, with all observed
-	 * events for that flush coalesced into a single envelope. Tier filter
-	 * (`options.tiers`) drops out-of-scope events before accumulation.
-	 *
-	 * Cleanup is producer-bound: the structured observer is torn down when the
-	 * last consumer of the returned node unsubscribes.
-	 */
-	private _observeReactive(
-		path: string | undefined,
-		options: ObserveOptions,
-	): Node<ObserveChangeset> {
-		const tiers = options.tiers;
-		const tierSet = tiers != null ? new Set(tiers) : null;
-		const name = options.reactiveName ?? "observe";
-
-		return node<ObserveChangeset>(
-			(_data, actions) => {
-				const events: ObserveEvent[] = [];
-				let pendingFlush = false;
-				let disposed = false;
-
-				const flush = (): void => {
-					if (events.length === 0 || disposed) return;
-					const changeset: ObserveChangeset = {
-						events: events.slice(),
-						flushedAt_ns: monotonicNs(),
-					};
-					events.length = 0;
-					actions.emit(changeset);
-				};
-
-				// Strip `reactive` so we get a structured ObserveResult, not
-				// recursion into ourselves. Force `timeline: true` so events
-				// carry timestamps for downstream tooling, and `structured: true`
-				// so we get an `ObserveResult` with `onEvent`.
-				// QA F12: tier filter is applied at the inner `recordEvent`
-				// funnel — keep `tiers` in `obsOpts` and DROP the redundant
-				// outer-listener filter (was double-filtering).
-				const obsOpts: ObserveOptions = {
-					...options,
-					reactive: false,
-					structured: true,
-					timeline: true,
-				};
-				// `obsOpts.structured: true` forces the structured-observer path,
-				// which returns `ObserveResult`. The signature dispatch can't
-				// narrow on runtime values, so cast through `unknown`.
-				const handle =
-					path != null
-						? (this.observe(path, obsOpts) as unknown as ObserveResult)
-						: (this.observe(obsOpts) as unknown as ObserveResult);
-
-				const onEventListener = (event: ObserveEvent): void => {
-					if (disposed) return;
-					events.push(event);
-					if (pendingFlush) return;
-					pendingFlush = true;
-					registerBatchFlushHook(() => {
-						pendingFlush = false;
-						flush();
-					});
-				};
-
-				// QA F2: replay any events the inner structured observer already
-				// captured before our listener attached (push-on-subscribe DATA
-				// from cached state nodes lands in `handle.events` synchronously
-				// during the `this.observe` call above). Drain through the same
-				// listener so the first changeset includes them.
-				for (const ev of handle.events) onEventListener(ev);
-				const off = handle.onEvent(onEventListener);
-				// Tier filter is unused at this layer (handled by inner
-				// `recordEvent`), but retain the closure-scoped `tierSet` so
-				// future per-listener filtering is one move away.
-				void tierSet;
-
-				// R3.6.2 reactive mode — auto-subscribe to nodes added AFTER
-				// the initial namespace snapshot. Only applies when no path is
-				// given (mode === "all"). Mirrors Rust port's
-				// `GraphObserveAllReactive` topology subscription (Slice V3 D2).
-				// Limitation: mounts added after subscribe don't recurse into
-				// their interiors (each mount would need its own topology
-				// listener); track if a real consumer needs it.
-				//
-				// Map keyed by name so:
-				//   - `removed` events dispose the matching late handle (no
-				//     accumulation in long-lived dynamic graphs).
-				//   - re-add of the same name dedupes (no duplicate
-				//     subscription if a name churns add → remove → add).
-				const lateHandles = new Map<string, { handle: ObserveResult; off: () => void }>();
-				let topoDetach: (() => void) | undefined;
-				if (path == null) {
-					const topoHandler = (event: TopologyEvent): void => {
-						if (disposed) return;
-						if (event.kind === "rewired" || event.nodeKind !== "node") return;
-						if (event.kind === "added") {
-							const targetName = event.name;
-							if (lateHandles.has(targetName)) return;
-							const lateHandle = this.observe(targetName, obsOpts) as unknown as ObserveResult;
-							for (const ev of lateHandle.events) onEventListener(ev);
-							const lateOff = lateHandle.onEvent(onEventListener);
-							lateHandles.set(targetName, { handle: lateHandle, off: lateOff });
-						} else if (event.kind === "removed") {
-							const entry = lateHandles.get(event.name);
-							if (entry) {
-								entry.off();
-								entry.handle.dispose();
-								lateHandles.delete(event.name);
-							}
-						}
-					};
-					this._topologyEmitters.add(topoHandler);
-					topoDetach = () => this._topologyEmitters.delete(topoHandler);
-				}
-
-				return {
-					onDeactivation: () => {
-						disposed = true;
-						// Detach topology handler FIRST so no new lateHandles
-						// accumulate between `disposed = true` and the dispose pass.
-						if (topoDetach) topoDetach();
-						off();
-						handle.dispose();
-						for (const entry of lateHandles.values()) {
-							entry.off();
-							entry.handle.dispose();
-						}
-						lateHandles.clear();
-					},
-				};
-			},
-			{
-				name,
-				describeKind: "producer",
-				meta: { domain: "audit", kind: "observe-reactive" } as const,
-			},
-		);
-	}
-
-	/**
-	 * Tier 1.5.D2 — discrete `GraphChange` stream.
-	 *
-	 * Returns a `Node<GraphChange>` that emits one DATA per change event.
-	 * Variants:
-	 * - **Core data flow** — `data` (with `fromPath`/`fromDepIndex`),
-	 *   `dirty`, `resolved`, `error`, `complete`, `teardown`. Sourced from
-	 *   per-node subscriptions over the picked observe targets.
-	 * - **Topology** — `node-added`, `node-removed`, `mount`, `unmount`.
-	 *   Sourced from `watchTopologyTree` — covers transitive nested mounts.
-	 * - **Batch boundaries** — `batch-start` / `batch-end` wrap each
-	 *   delivery wave (the per-`(msgs)` sink callback). Inside an explicit
-	 *   `batch(() => …)`, the runtime delivers each upstream node's
-	 *   coalesced multi-message batch as one wave; each such wave gets one
-	 *   batch-start / batch-end pair on this stream. Outside a batch (sync
-	 *   single-emit path), no boundary events fire.
-	 *
-	 * `version` is a per-stream monotonic counter (sourced via the V0 version
-	 * convention from `core/versioning.ts`). `timestamp_ns` is from
-	 * `core/clock.ts` `monotonicNs()`. `scope` is the qualified path the change
-	 * applies to; for batch boundaries, `scope = ""` (graph-level).
-	 *
-	 * Cleanup is producer-bound: every per-node subscription + the topology
-	 * watcher tear down when the last consumer of the returned node
-	 * unsubscribes.
-	 */
-	private _observeChangeset(path: string | undefined, options: ObserveOptions): Node<GraphChange> {
-		const name = options.changesetName ?? "observe-changeset";
-		const tierSet = options.tiers != null ? new Set(options.tiers) : null;
-
-		// Subscribe directly to picked targets (no inner structured observer)
-		// so the per-target sink callback boundary defines a delivery wave —
-		// each wave gets exactly one batch-start / batch-end pair. Topology
-		// events flow through `watchTopologyTree`, which surfaces the same
-		// per-emission boundary via the topology producer's own sink.
-		return node<GraphChange>(
-			(_data, actions) => {
-				let disposed = false;
-				let version = 0;
-				const stamp = (
-					scope: string,
-				): { version: number; timestamp_ns: number; scope: string } => ({
-					version: version++,
-					timestamp_ns: monotonicNs(),
-					scope,
-				});
-
-				type Envelope = { version: number; timestamp_ns: number; scope: string };
-
-				const emitNow = (build: (env: Envelope) => GraphChange, scope: string): void => {
-					if (disposed) return;
-					actions.emit(build(stamp(scope)));
-				};
-
-				// /qa F-4: separate tier whitelist for the full GraphChange
-				// type-set (including topology + batch frame variants). Casting
-				// to `ObserveEvent["type"]` silently dropped node-added /
-				// node-removed / mount / unmount / batch-start / batch-end.
-				const inTier = (type: GraphChange["type"]): boolean =>
-					tierSet == null || (tierSet as Set<string>).has(type);
-
-				/**
-				 * Wrap a sink-loop body in a batch-start/batch-end pair when the
-				 * current call site is batching (`isBatching()` true), otherwise
-				 * deliver synchronously without boundary events. The body runs
-				 * once and emits zero or more events via `emitOne`.
-				 */
-				const wrapWave = (body: (emitOne: typeof emitNow) => void): void => {
-					if (disposed) return;
-					if (!isBatching()) {
-						body(emitNow);
-						return;
-					}
-					let opened = false;
-					const open = (): void => {
-						if (opened) return;
-						opened = true;
-						if (!inTier("batch-start")) return;
-						emitNow((env) => ({ type: "batch-start", ...env }) satisfies GraphChangeBatchStart, "");
-					};
-					const wrappedEmit = (build: (env: Envelope) => GraphChange, scope: string): void => {
-						if (disposed) return;
-						open();
-						emitNow(build, scope);
-					};
-					body(wrappedEmit);
-					if (opened && inTier("batch-end")) {
-						emitNow((env) => ({ type: "batch-end", ...env }) satisfies GraphChangeBatchEnd, "");
-					}
-				};
-
-				// ---- Build the observe-target reverse index for `fromPath`
-				// resolution. Walk the same tree the structured observer walks
-				// (sorted, with nested mount prefixes). The map is updated
-				// dynamically as nodes are added/removed via the watchTopologyTree
-				// callback (/qa F-1).
-				const initialTargets: [string, Node][] = [];
-				this._collectObserveTargets("", initialTargets);
-				const nodeToPath = new Map<Node, string>();
-				for (const [p, nd] of initialTargets) nodeToPath.set(nd, p);
-
-				const actor = options.actor;
-
-				// /qa F-19: capture the upstream Node ref directly at hook fire
-				// time (not via _deps[idx] later) so attribution survives
-				// dynamicNode/autoTrackNode `_deps` mutation between fire and
-				// event emit.
-				const lastTriggerDep = new Map<Node, { node: Node; depIndex: number }>();
-				const inspectorOn = this.config.inspectorEnabled;
-
-				// /qa F-1 + F-21: keyed-by-path so we can attach/detach
-				// symmetrically in the watchTopologyTree callback.
-				const subscriptionsByPath = new Map<string, () => void>();
-				const inspectorDetachesByPath = new Map<string, () => void>();
-
-				const subscribeTarget = (targetPath: string, target: Node): void => {
-					if (subscriptionsByPath.has(targetPath)) return;
-					if (actor != null && !target.allowsObserve(actor)) return;
-
-					if (inspectorOn && target instanceof NodeImpl) {
-						const detach = target._setInspectorHook((ev) => {
-							if (ev.kind === "dep_message") {
-								// Capture the upstream Node directly from the
-								// hook event when available; fall back to
-								// `_deps[idx]` for inspector implementations
-								// that don't surface the node ref.
-								const upstream = target._deps[ev.depIndex]?.node ?? undefined;
-								if (upstream != null) {
-									lastTriggerDep.set(target, { node: upstream, depIndex: ev.depIndex });
-								}
-							}
-						});
-						inspectorDetachesByPath.set(targetPath, detach);
-					}
-
-					const unsub = target.subscribe((msgs) => {
-						if (disposed) return;
-						wrapWave((emitOne) => {
-							for (const m of msgs) {
-								const t = m[0];
-								if (t === DATA) {
-									if (!inTier("data")) continue;
-									const trig = lastTriggerDep.get(target);
-									let fromPath = targetPath;
-									let fromDepIndex = -1;
-									if (trig != null) {
-										fromDepIndex = trig.depIndex;
-										// /qa F-20: distinguish self-source from
-										// anonymous-upstream by using a sentinel
-										// when the upstream isn't a registered
-										// observe target and has no `.name`.
-										const resolved = nodeToPath.get(trig.node) ?? trig.node.name ?? "<anonymous>";
-										fromPath = resolved;
-									}
-									const attribution =
-										target instanceof NodeImpl
-											? (target.lastMutation?.actor ?? DEFAULT_ACTOR)
-											: DEFAULT_ACTOR;
-									const value = m[1];
-									emitOne(
-										(env): GraphChangeData => ({
-											type: "data",
-											value,
-											fromPath,
-											fromDepIndex,
-											actor: attribution,
-											...env,
-										}),
-										targetPath,
-									);
-								} else if (t === DIRTY) {
-									if (!inTier("dirty")) continue;
-									emitOne((env): GraphChangeDirty => ({ type: "dirty", ...env }), targetPath);
-								} else if (t === RESOLVED) {
-									if (!inTier("resolved")) continue;
-									emitOne((env): GraphChangeResolved => ({ type: "resolved", ...env }), targetPath);
-								} else if (t === ERROR) {
-									if (!inTier("error")) continue;
-									const attribution =
-										target instanceof NodeImpl
-											? (target.lastMutation?.actor ?? DEFAULT_ACTOR)
-											: DEFAULT_ACTOR;
-									const errVal = m[1];
-									emitOne(
-										(env): GraphChangeError => ({
-											type: "error",
-											error: errVal,
-											actor: attribution,
-											...env,
-										}),
-										targetPath,
-									);
-								} else if (t === COMPLETE) {
-									if (!inTier("complete")) continue;
-									emitOne((env): GraphChangeComplete => ({ type: "complete", ...env }), targetPath);
-								} else if (t === TEARDOWN) {
-									if (!inTier("teardown")) continue;
-									emitOne((env): GraphChangeTeardown => ({ type: "teardown", ...env }), targetPath);
-								}
-								// PAUSE / RESUME / INVALIDATE: reserved future
-								// variants — current implementation skips them.
-							}
-						});
-					});
-					subscriptionsByPath.set(targetPath, unsub);
-				};
-
-				const unsubscribeTarget = (targetPath: string): void => {
-					const unsub = subscriptionsByPath.get(targetPath);
-					if (unsub != null) {
-						unsub();
-						subscriptionsByPath.delete(targetPath);
-					}
-					const detach = inspectorDetachesByPath.get(targetPath);
-					if (detach != null) {
-						detach();
-						inspectorDetachesByPath.delete(targetPath);
-					}
-				};
-
-				// Initial subscribe pass (filtered by actor + path).
-				for (const [targetPath, target] of initialTargets) {
-					if (path != null && targetPath !== path) continue;
-					subscribeTarget(targetPath, target);
-				}
-
-				// ---- Topology events via watchTopologyTree ----
-				// Transitive: covers the root graph + every mounted child
-				// (including children mounted/unmounted dynamically). Names
-				// arrive as `event.name`; `prefix` is the qualified prefix
-				// from the root, so `prefix + name` is the full scope path.
-				//
-				// /qa F-1: on `added` + nodeKind==="node" we resolve the new
-				// node and append a fresh subscription + inspector hook. On
-				// `removed` we detach symmetrically.
-				const offTopology = watchTopologyTree(this, (event, _emitter, prefix) => {
-					if (disposed) return;
-					const qualified = `${prefix}${event.name}`;
-
-					wrapWave((emitOne) => {
-						if (event.kind === "added") {
-							if (event.nodeKind === "node") {
-								// /qa F-1: subscribe + inspector for the new node.
-								// Path-scoped observers only subscribe to nodes
-								// matching the path filter.
-								if (path == null || qualified === path) {
-									const newNode = this.tryResolve(qualified);
-									if (newNode != null) {
-										nodeToPath.set(newNode, qualified);
-										subscribeTarget(qualified, newNode);
-									}
-								}
-
-								// /qa F-3: populate `nodeKind` with the resolved
-								// describeKind (state | derived | producer |
-								// effect) per the type's documented contract.
-								const resolved = this.tryResolve(qualified);
-								const kind = resolved instanceof NodeImpl ? resolved._describeKind : undefined;
-								if (!inTier("node-added")) return;
-								emitOne(
-									(env): GraphChangeNodeAdded =>
-										kind != null
-											? { type: "node-added", nodeKind: kind, ...env }
-											: { type: "node-added", ...env },
-									qualified,
-								);
-							} else {
-								if (!inTier("mount")) return;
-								emitOne((env): GraphChangeMount => ({ type: "mount", ...env }), qualified);
-							}
-						} else if (event.kind === "rewired") {
-							// Phase 13.8 experimental: observe-tree currently
-							// ignores rewire events. Subscriptions follow nodes,
-							// not edges, so a rewired node's identity is stable
-							// — existing inspector/sink hooks remain valid. Edge
-							// observers are not part of the observe-tree contract;
-							// surfaces `topology.subscribe` directly for callers
-							// that need rewire visibility.
-							return;
-						} else {
-							// removed
-							if (event.nodeKind === "node") {
-								// /qa F-21: detach subscription + inspector hook
-								// before emitting `node-removed` so consumers
-								// don't see further DATA from the dead node.
-								unsubscribeTarget(qualified);
-								if (!inTier("node-removed")) return;
-								emitOne(
-									(env): GraphChangeNodeRemoved => ({ type: "node-removed", ...env }),
-									qualified,
-								);
-							} else {
-								if (!inTier("unmount")) return;
-								emitOne((env): GraphChangeUnmount => ({ type: "unmount", ...env }), qualified);
-							}
-						}
-					});
-				});
-
-				return {
-					onDeactivation: () => {
-						disposed = true;
-						for (const unsub of subscriptionsByPath.values()) unsub();
-						for (const detach of inspectorDetachesByPath.values()) detach();
-						subscriptionsByPath.clear();
-						inspectorDetachesByPath.clear();
-						offTopology();
-					},
-				};
-			},
-			{
-				name,
-				describeKind: "producer",
-				meta: { domain: "audit", kind: "observe-changeset" } as const,
-			},
-		);
-	}
-
-	/** Dispatch helper — builds a unified observer + its expand closure. */
-	private _buildStructuredObserver<T>(
-		targets: ReadonlyArray<[string, Node]>,
-		options: ObserveOptions,
-		mode: "one" | "all",
-	): ObserveResult<T> {
-		const firstPath = mode === "one" ? targets[0]?.[0] : undefined;
-		const expand = (merged: ObserveOptions): ObserveResult<T> => {
-			if (mode === "one" && firstPath != null) {
-				const target = this.resolve(firstPath);
-				return this._buildStructuredObserver([[firstPath, target]], merged, "one");
-			}
-			const collected: [string, Node][] = [];
-			this._collectObserveTargets("", collected);
-			collected.sort((a, b) => (a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0));
-			const actor = merged.actor;
-			const picked =
-				actor == null ? collected : collected.filter(([, nd]) => nd.allowsObserve(actor));
-			return this._buildStructuredObserver(picked, merged, "all");
-		};
-		return this._createObserveResult<T>(targets, options, expand);
-	}
-
-	/**
-	 * Unified observer builder — replaces the four ex-creators
-	 * (`_createObserveResult` / `...ForAll` / `_createFallback…`). Accepts a
-	 * list of `[path, node]` targets (single-element for one-node observe,
-	 * N-element for all-nodes). Inspector hooks attach per-target when
-	 * `causal`/`derived` requested AND `config.inspectorEnabled`; otherwise
-	 * those fields gracefully drop.
-	 *
-	 * Events flow through a `recordEvent()` helper so the format logger,
-	 * ring-buffer, and async-iterable hooks all share one push path.
-	 */
-	private _createObserveResult<T>(
-		targets: ReadonlyArray<[string, Node]>,
-		options: ObserveOptions,
-		expand: (merged: ObserveOptions) => ObserveResult<T>,
-	): ObserveResult<T> {
-		const timeline = options.timeline === true;
-		const causal = options.causal === true;
-		const derived = options.derived === true;
-		const minimal = options.detail === "minimal";
-		const inspectorOn = this.config.inspectorEnabled;
-		const wantInspector = (causal || derived) && inspectorOn;
-
-		// Event buffer: unbounded array, or RingBuffer when maxEvents capped.
-		const maxEvents = options.maxEvents;
-		const ring =
-			maxEvents != null && maxEvents > 0 ? new RingBuffer<ObserveEvent>(maxEvents) : null;
-		const events: ObserveEvent[] = [];
-
-		// Listener set — format logger, async iterable, and user `onEvent` hooks.
-		const listeners = new Set<(event: ObserveEvent) => void>();
-
-		// Tier filter (Tier 1.5.2 — Session A.4 lock). When set, events whose
-		// `type` is not in the set are dropped before they hit the events buffer
-		// or any listener — applies uniformly to the structured callback,
-		// `events` array, async iterable, and format logger.
-		const tierSet = options.tiers != null ? new Set(options.tiers) : null;
-
-		const values: Record<string, T> = {};
-		const nodeErrored = new Set<string>();
-		let dirtyCount = 0;
-		let resolvedCount = 0;
-		let invalidateCount = 0;
-		let pauseCount = 0;
-		let resumeCount = 0;
-		let teardownCount = 0;
-		let anyCompletedCleanly = false;
-		let anyErrored = false;
-		let batchSeq = 0;
-
-		// Per-target causal context (keyed by target index).
-		const lastTriggerDepIndex = new Map<Node, number>();
-		const lastRunDepValues = new Map<Node, readonly unknown[]>();
-		const lastRunDepBatches = new Map<Node, ReadonlyArray<ReadonlyArray<unknown> | undefined>>();
-
-		const recordEvent = (event: ObserveEvent): void => {
-			if (tierSet != null && !tierSet.has(event.type)) return;
-			if (ring) ring.push(event);
-			else events.push(event);
-			for (const listener of listeners) listener(event);
-		};
-
-		// QA F3: tier filter applies to counters too — `dirtyCount`, `resolvedCount`,
-		// `anyErrored`, etc. would otherwise reflect full-stream traffic regardless
-		// of `tiers: [...]`. With this helper, counters and event buffer stay
-		// coherent.
-		const inTier = (name: ObserveEvent["type"]): boolean => tierSet == null || tierSet.has(name);
-
-		const baseMeta = (): Partial<ObserveEventBase> =>
-			timeline ? { timestamp_ns: monotonicNs(), in_batch: isBatching(), batch_id: batchSeq } : {};
-
-		const attachInspector = (target: Node, path: string): (() => void) | undefined => {
-			if (!wantInspector || !(target instanceof NodeImpl)) return undefined;
-			return target._setInspectorHook((ev) => {
-				if (ev.kind === "dep_message") {
-					lastTriggerDepIndex.set(target, ev.depIndex);
-				} else if (ev.kind === "run") {
-					const effective = ev.batchData.map((b, i) =>
-						b != null && b.length > 0 ? b.at(-1) : ev.prevData[i],
-					);
-					lastRunDepValues.set(target, effective);
-					// Snapshot the full per-dep batches so multi-value waves stay
-					// visible to observers. `ev.batchData` references run-local
-					// arrays, so clone the outer array (inner arrays are
-					// effectively immutable from the observer's POV).
-					const batches: ReadonlyArray<ReadonlyArray<unknown> | undefined> = ev.batchData.map(
-						(b) => (b != null ? [...b] : undefined),
-					);
-					lastRunDepBatches.set(target, batches);
-					if (derived) {
-						recordEvent({
-							type: "derived",
-							path,
-							dep_values: effective,
-							dep_batches: batches,
-							...baseMeta(),
-						} as ObserveEvent);
-					}
-				}
-			});
-		};
-
-		const buildCausal = (target: Node): ObserveCausalContext => {
-			const idx = lastTriggerDepIndex.get(target);
-			const depValues = lastRunDepValues.get(target);
-			if (!causal || depValues == null) return {};
-			const triggerDep =
-				idx != null && idx >= 0 && target instanceof NodeImpl ? target._deps[idx] : undefined;
-			const triggerNode = triggerDep?.node;
-			const tv = triggerNode?.v;
-			const depBatches = lastRunDepBatches.get(target);
-			return {
-				trigger_dep_index: idx,
-				trigger_dep_name: triggerNode?.name,
-				...(tv != null ? { trigger_version: { id: tv.id, version: tv.version } } : {}),
-				dep_values: [...depValues],
-				...(depBatches != null ? { dep_batches: depBatches } : {}),
-			};
-		};
-
-		const inspectorDetaches: Array<() => void> = [];
-		const unsubs: Array<() => void> = [];
-		for (const [path, target] of targets) {
-			const detach = attachInspector(target, path);
-			if (detach) inspectorDetaches.push(detach);
-			unsubs.push(
-				target.subscribe((msgs) => {
-					batchSeq++;
-					for (const m of msgs) {
-						const t = m[0];
-						const base = baseMeta();
-						if (t === DATA) {
-							// `values` is updated regardless of tier filter — it
-							// reflects the latest cache snapshot, which is a
-							// data-flow observation independent of event scoping.
-							values[path] = m[1] as T;
-							// B9: thread attribution onto the event so audit
-							// consumers can evaluate policy against every
-							// write. Unattributed writes stamp DEFAULT_ACTOR.
-							const attr =
-								target instanceof NodeImpl
-									? (target.lastMutation?.actor ?? DEFAULT_ACTOR)
-									: DEFAULT_ACTOR;
-							recordEvent({
-								type: "data",
-								path,
-								data: m[1],
-								actor: attr,
-								...base,
-								...buildCausal(target),
-							} as ObserveEvent);
-						} else if (minimal) {
-							// QA F3: tier-filter counters too.
-							if (t === DIRTY) {
-								if (inTier("dirty")) dirtyCount++;
-							} else if (t === RESOLVED) {
-								if (inTier("resolved")) resolvedCount++;
-							} else if (t === INVALIDATE) {
-								if (inTier("invalidate")) invalidateCount++;
-							} else if (t === PAUSE) {
-								if (inTier("pause")) pauseCount++;
-							} else if (t === RESUME) {
-								if (inTier("resume")) resumeCount++;
-							} else if (t === TEARDOWN) {
-								if (inTier("teardown")) teardownCount++;
-							} else if (t === COMPLETE && !nodeErrored.has(path)) {
-								if (inTier("complete")) anyCompletedCleanly = true;
-							} else if (t === ERROR) {
-								if (inTier("error")) {
-									anyErrored = true;
-									nodeErrored.add(path);
-								}
-							}
-						} else if (t === DIRTY) {
-							if (inTier("dirty")) dirtyCount++;
-							recordEvent({ type: "dirty", path, ...base } as ObserveEvent);
-						} else if (t === RESOLVED) {
-							if (inTier("resolved")) resolvedCount++;
-							recordEvent({
-								type: "resolved",
-								path,
-								...base,
-								...buildCausal(target),
-							} as ObserveEvent);
-						} else if (t === INVALIDATE) {
-							if (inTier("invalidate")) invalidateCount++;
-							recordEvent({ type: "invalidate", path, ...base } as ObserveEvent);
-						} else if (t === PAUSE) {
-							if (inTier("pause")) pauseCount++;
-							recordEvent({ type: "pause", path, lockId: m[1], ...base } as ObserveEvent);
-						} else if (t === RESUME) {
-							if (inTier("resume")) resumeCount++;
-							recordEvent({ type: "resume", path, lockId: m[1], ...base } as ObserveEvent);
-						} else if (t === COMPLETE) {
-							if (inTier("complete") && !nodeErrored.has(path)) anyCompletedCleanly = true;
-							recordEvent({ type: "complete", path, ...base } as ObserveEvent);
-						} else if (t === ERROR) {
-							if (inTier("error")) {
-								anyErrored = true;
-								nodeErrored.add(path);
-							}
-							const attr =
-								target instanceof NodeImpl
-									? (target.lastMutation?.actor ?? DEFAULT_ACTOR)
-									: DEFAULT_ACTOR;
-							recordEvent({
-								type: "error",
-								path,
-								data: m[1],
-								actor: attr,
-								...base,
-							} as ObserveEvent);
-						} else if (t === TEARDOWN) {
-							if (inTier("teardown")) teardownCount++;
-							recordEvent({ type: "teardown", path, ...base } as ObserveEvent);
-						}
-					}
-				}),
-			);
-		}
-
-		let disposed = false;
-		const dispose = (): void => {
-			if (disposed) return;
-			disposed = true;
-			for (const u of unsubs) u();
-			for (const d of inspectorDetaches) d();
-			for (const resolve of asyncResolvers) resolve({ value: undefined, done: true });
-			asyncResolvers.length = 0;
-		};
-
-		// AsyncIterator plumbing: queue events until a pull arrives, or wake
-		// a pending pull when a new event lands.
-		const asyncQueue: ObserveEvent[] = [];
-		const asyncResolvers: Array<(r: IteratorResult<ObserveEvent>) => void> = [];
-		listeners.add((ev) => {
-			const resolve = asyncResolvers.shift();
-			if (resolve) resolve({ value: ev, done: false });
-			else asyncQueue.push(ev);
-		});
-
-		const result: ObserveResult<T> = {
-			get values() {
-				return values;
-			},
-			get dirtyCount() {
-				return dirtyCount;
-			},
-			get resolvedCount() {
-				return resolvedCount;
-			},
-			get invalidateCount() {
-				return invalidateCount;
-			},
-			get pauseCount() {
-				return pauseCount;
-			},
-			get resumeCount() {
-				return resumeCount;
-			},
-			get teardownCount() {
-				return teardownCount;
-			},
-			get events() {
-				return ring ? ring.toArray() : [...events];
-			},
-			get anyCompletedCleanly() {
-				return anyCompletedCleanly;
-			},
-			get anyErrored() {
-				return anyErrored;
-			},
-			get completedWithoutErrors() {
-				return anyCompletedCleanly && !anyErrored;
-			},
-			onEvent(listener) {
-				listeners.add(listener);
-				return () => listeners.delete(listener);
-			},
-			dispose,
-			expand(extra) {
-				dispose();
-				const merged: ObserveOptions = { ...options };
-				if (typeof extra === "string") {
-					merged.detail = extra;
-				} else {
-					Object.assign(merged, extra);
-				}
-				return expand(resolveObserveDetail(merged));
-			},
-			[Symbol.asyncIterator](): AsyncIterator<ObserveEvent> {
-				return {
-					next(): Promise<IteratorResult<ObserveEvent>> {
-						if (asyncQueue.length > 0) {
-							return Promise.resolve({ value: asyncQueue.shift()!, done: false });
-						}
-						if (disposed) return Promise.resolve({ value: undefined, done: true });
-						return new Promise((resolve) => asyncResolvers.push(resolve));
-					},
-					return(): Promise<IteratorResult<ObserveEvent>> {
-						dispose();
-						return Promise.resolve({ value: undefined, done: true });
-					},
-				};
-			},
-		};
-
-		// Format logger: subscribes to event stream, renders via theme/format.
-		if (options.format != null) this._attachFormatLogger(result, options);
-
-		return result;
-	}
-
-	/**
-	 * Attach format-rendering logger to an ObserveResult by subscribing to its
-	 * event stream (no monkey-patching). Renders each event per `format` and
-	 * `theme`, filtered by `includeTypes` / `excludeTypes`.
-	 */
-	private _attachFormatLogger(result: ObserveResult, options: ObserveOptions): void {
-		const format = options.format;
-		if (format == null) return;
-		const logger = options.logger ?? ((line: string) => console.log(line));
-		// Compile include/exclude predicates once.
-		const include = options.includeTypes ? new Set(options.includeTypes) : null;
-		const exclude = options.excludeTypes ? new Set(options.excludeTypes) : null;
-		const shouldLog =
-			include == null && exclude == null
-				? () => true
-				: (type: ObserveEvent["type"]): boolean =>
-						(include == null || include.has(type)) && (exclude == null || !exclude.has(type));
-		const theme = resolveObserveTheme(options.theme);
-		// stage-log: anchor elapsed timestamps to subscription time. Each event
-		// renders `[Xs] STAGE ← preview` / `✗ err` / `■ complete`. No color,
-		// since this is a pipeline-diagnostic format — predictable + greppable.
-		const stageStartNs = format === "stage-log" ? monotonicNs() : 0;
-		const stageLabelFor = (path: string | undefined): string => {
-			if (path == null) return "";
-			return options.stageLabels?.[path] ?? path;
-		};
-		const truncate = (s: string, max: number): string =>
-			s.length > max ? `${s.slice(0, max - 1)}…` : s;
-		const stagePreview = (event: ObserveEvent): string => {
-			if (event.type === "data" || event.type === "error") {
-				return truncate(describeData((event as { data: unknown }).data), 120);
-			}
-			return "";
-		};
-
-		const renderEvent = (event: ObserveEvent): string => {
-			if (format === "stage-log") {
-				const elapsedS = (monotonicNs() - stageStartNs) / 1e9;
-				const stage = stageLabelFor(event.path).padEnd(9);
-				if (event.type === "data") {
-					const body = stagePreview(event);
-					return `[${elapsedS.toFixed(3)}s] ${stage} ←${body ? ` ${body}` : ""}`;
-				}
-				if (event.type === "error") {
-					const body = stagePreview(event);
-					return `[${elapsedS.toFixed(3)}s] ${stage} ✗${body ? ` ${body}` : ""}`;
-				}
-				if (event.type === "complete") {
-					return `[${elapsedS.toFixed(3)}s] ${stage} ■ complete`;
-				}
-				return `[${elapsedS.toFixed(3)}s] ${stage} ${event.type}`;
-			}
-			if (format === "json") {
-				try {
-					return JSON.stringify(event);
-				} catch {
-					return JSON.stringify({
-						type: event.type,
-						path: event.path,
-						data: "[unserializable]",
-					});
-				}
-			}
-			const color = theme[event.type] ?? "";
-			const pathPart = event.path ? `${theme.path}${event.path}${theme.reset} ` : "";
-			const isDataBearing = event.type === "data" || event.type === "error";
-			const isLockBearing = event.type === "pause" || event.type === "resume";
-			const dataPart = isDataBearing
-				? ` ${describeData((event as { data: unknown }).data)}`
-				: isLockBearing
-					? ` ${describeData((event as { lockId: unknown }).lockId)}`
-					: "";
-			const causal =
-				event.type === "data" || event.type === "resolved" || event.type === "derived"
-					? (event as ObserveCausalContext)
-					: undefined;
-			const triggerPart =
-				causal?.trigger_dep_name != null
-					? ` <- ${causal.trigger_dep_name}`
-					: causal?.trigger_dep_index != null
-						? ` <- #${causal.trigger_dep_index}`
-						: "";
-			const batchPart = event.in_batch ? " [batch]" : "";
-			return `${pathPart}${color}${event.type.toUpperCase()}${theme.reset}${dataPart}${triggerPart}${batchPart}`;
-		};
-
-		result.onEvent((event) => {
-			if (shouldLog(event.type)) logger(renderEvent(event), event);
-		});
-	}
-
-	// Tier 2.1 A2: ex-`describe({ format })` renderers
-	// (`graphSpecToMermaid`, `graphSpecToD2`, `graphSpecToAscii`,
-	// `graphSpecToPretty`, `graphSpecToJson`, `graphSpecToMermaidUrl`) live
-	// in `@graphrefly/graphrefly/extra/render` — pure functions over a
-	// `GraphDescribeOutput` snapshot (no Graph instance dependency).
-
-	// ——————————————————————————————————————————————————————————————
-	//  Lifecycle & persistence (§3.7–§3.8)
-	// ——————————————————————————————————————————————————————————————
-
-	/**
-	 * Register a cleanup function to be called on {@link Graph.destroy}.
-	 *
-	 * Factories use this to attach teardown logic for internal nodes, keepalive
-	 * subscriptions, or other resources that are not registered on the graph and
-	 * would otherwise leak on repeated create/destroy cycles.
-	 *
-	 * Returns a removal function — call it to unregister the disposer early.
-	 *
-	 * @remarks
-	 * **B5a — safe to call mid-constructor.** `_disposers` is initialised as a
-	 * class-field initializer, which runs before any subclass constructor body
-	 * (per the ECMAScript class semantics). Subclasses can therefore call
-	 * `this.addDisposer(...)` from within their own constructor — even before
-	 * the `super()` body finishes wiring substrate — and the disposer will be
-	 * registered against a live `Set`. {@link AgentMemoryGraph} relies on this
-	 * to register `keepalive` cleanup handlers for inner reactive bundles
-	 * during construction.
-	 */
-	addDisposer(fn: () => void): () => void {
-		this._disposers.add(fn);
-		return () => {
-			this._disposers.delete(fn);
-		};
-	}
-
-	/**
-	 * Drains disposers (registered via {@link addDisposer}), then sends `[[TEARDOWN]]` to all
-	 * nodes and clears registries on this graph and every mounted subgraph (§3.7).
-	 * The instance is left empty and may be reused with {@link Graph.add}.
-	 */
-	destroy(): void {
-		// Drain disposers (keepalive unsubs etc.) BEFORE TEARDOWN so that
-		// internal effect nodes are disconnected before the cascade fires.
-		// Drain iteratively so disposers registered mid-drain also run; cap
-		// iterations to guard against a disposer that re-registers itself.
-		drainDisposers(this._disposers, this.name);
-		// C3 — release this graph's own ownership stamps SYNCHRONOUSLY in
-		// the same call as the TEARDOWN cascade so a freshly-detached Node
-		// may be re-registered on another Graph in the same tick (see
-		// Graph.add JSDoc). Mounted children's stamps are released by the
-		// `child._destroyClearOnly()` loop below — A14 fix (2026-05-01)
-		// avoids the redundant recursive walk here that would re-traverse
-		// every grandchild a second time.
-		for (const node of this._nodes.values()) {
-			if (GRAPH_OWNER.get(node) === this) {
-				GRAPH_OWNER.delete(node);
-			}
-		}
-		// TEARDOWN is tier 6 — above `attachSnapshotStorage`'s `tier < 6` gate, so no
-		// final checkpoint fires; storage disposers unsubscribe after TEARDOWN
-		// has propagated through the subscription pipeline.
-		this.signal([[TEARDOWN]] satisfies Messages, { internal: true });
-		drainDisposers(this._storageDisposers, this.name);
-		for (const child of [...this._mounts.values()]) {
-			child._parent = undefined;
-			child._destroyClearOnly();
-		}
-		this._mounts.clear();
-		this._nodes.clear();
-		this._parent = undefined;
-		this._destroyed = true;
-	}
-
-	/**
-	 * Async {@link destroy}. Identical teardown, but `await`s storage
-	 * disposers so in-flight async cleanup (e.g. a snapshot/WAL tier
-	 * draining pending saves) completes before the Promise resolves.
-	 *
-	 * `destroy()` drains `_storageDisposers` via the sync
-	 * {@link drainDisposers}, which invokes each `async` disposer but
-	 * discards the returned Promise — so in-flight WAL saves are abandoned
-	 * when a graph with attached storage is torn down. Callers that need
-	 * the persisted state to be durable (graceful shutdown, test
-	 * teardown that then asserts on the backend) must `await
-	 * graph.destroyAsync()` instead. Mounted children with their own
-	 * attached storage are drained recursively and also awaited.
-	 */
-	async destroyAsync(): Promise<void> {
-		drainDisposers(this._disposers, this.name);
-		for (const node of this._nodes.values()) {
-			if (GRAPH_OWNER.get(node) === this) {
-				GRAPH_OWNER.delete(node);
-			}
-		}
-		this.signal([[TEARDOWN]] satisfies Messages, { internal: true });
-		await drainDisposersAsync(this._storageDisposers, this.name);
-		for (const child of [...this._mounts.values()]) {
-			child._parent = undefined;
-			await child._destroyClearOnlyAsync();
-		}
-		this._mounts.clear();
-		this._nodes.clear();
-		this._parent = undefined;
-		this._destroyed = true;
-	}
-
-	/**
-	 * @internal C3 — drop the cross-graph ownership stamp for every locally
-	 * registered node whose stamp still points at `this`. Recurses into mounted
-	 * children so the entire subtree releases ownership in one synchronous
-	 * pass. Idempotent: nodes whose stamp already points elsewhere are skipped.
-	 */
-	private _releaseOwnershipStamps(): void {
-		for (const node of this._nodes.values()) {
-			if (GRAPH_OWNER.get(node) === this) {
-				GRAPH_OWNER.delete(node);
-			}
-		}
-		for (const child of this._mounts.values()) {
-			child._releaseOwnershipStamps();
-		}
-	}
-
-	/** @internal A1 (2026-05-01) — exposed for `teardownMountedGraph` (free fn). */
-	_releaseOwnershipStampsPublic(): void {
-		this._releaseOwnershipStamps();
-	}
-
-	/** @internal A1 (2026-05-01) — exposed for `teardownMountedGraph` (free fn). */
-	_markDestroyed(): void {
-		this._destroyed = true;
-		for (const child of this._mounts.values()) {
-			child._markDestroyed();
-		}
-	}
-
-	/**
-	 * `true` once {@link destroy} has run on this graph. Useful for reactive
-	 * consumers that hold a Graph reference and want to fail fast / skip
-	 * work if the graph went away mid-flight (e.g. a `switchMap` over a
-	 * destroyable graph reference). Set after the destroy cascade completes;
-	 * stays `true` even if the instance is later reused via {@link add}.
-	 */
-	get destroyed(): boolean {
-		return this._destroyed;
-	}
-
-	/**
-	 * Clear structure after parent already signaled TEARDOWN through this subtree.
-	 *
-	 * Drains both `_disposers` and `_storageDisposers` to mirror the full
-	 * {@link destroy} path — child mounts that registered disposers via
-	 * {@link addDisposer} (audit trails, log dispose hooks, off-event
-	 * callbacks, attached storage) would otherwise leak when destruction
-	 * reaches the subtree via the parent's TEARDOWN cascade rather than a
-	 * direct `destroy()` call (EH-2). Disposers run BEFORE structure clear
-	 * so cleanups can still resolve node paths if needed.
-	 */
-	private _destroyClearOnly(): void {
-		drainDisposers(this._disposers, this.name);
-		// C3 — symmetric with destroy(): release ownership stamps for the
-		// subtree before clearing structure.
-		this._releaseOwnershipStamps();
-		drainDisposers(this._storageDisposers, this.name);
-		for (const child of [...this._mounts.values()]) {
-			child._parent = undefined;
-			child._destroyClearOnly();
-		}
-		this._mounts.clear();
-		this._nodes.clear();
-		this._parent = undefined;
-		this._destroyed = true;
-	}
-
-	/**
-	 * Async mirror of {@link _destroyClearOnly} — used by
-	 * {@link destroyAsync} so a subtree reached via the parent's TEARDOWN
-	 * cascade still awaits its own attached-storage disposers.
-	 */
-	private async _destroyClearOnlyAsync(): Promise<void> {
-		drainDisposers(this._disposers, this.name);
-		this._releaseOwnershipStamps();
-		await drainDisposersAsync(this._storageDisposers, this.name);
-		for (const child of [...this._mounts.values()]) {
-			child._parent = undefined;
-			await child._destroyClearOnlyAsync();
-		}
-		this._mounts.clear();
-		this._nodes.clear();
-		this._parent = undefined;
-		this._destroyed = true;
-	}
-
-	/**
-	 * Serializes structure and current values to JSON-shaped data (§3.8). Same
-	 * information as {@link Graph.describe} plus a `version` field for format
-	 * evolution.
-	 *
-	 * The overload path supports three outputs:
-	 * - no arg → `GraphPersistSnapshot` (plain JS object).
-	 * - `{format: "json-string"}` → deterministic JSON `string`
-	 *   (key-sorted; safe for hashing or file write).
-	 * - `{format: "bytes", codec: name}` → `Uint8Array` wrapped in the v1
-	 *   envelope from {@link encodeEnvelope}. The codec must be registered
-	 *   on this graph's {@link GraphReFlyConfig} via `config.registerCodec`.
-	 *   Paired with {@link Graph.decode} for auto-dispatch on the read side.
-	 */
-	snapshot(): GraphPersistSnapshot;
-	snapshot(opts: { format: "json-string" }): string;
-	snapshot(opts: { format: "bytes"; codec: string }): Uint8Array;
-	snapshot(opts?: {
-		format?: "json-string" | "bytes";
-		codec?: string;
-	}): GraphPersistSnapshot | string | Uint8Array {
-		const { expand: _, ...d } = this.describe({ detail: "full" });
-		// Explicit key sorting for deterministic output — don't rely on
-		// describe() iteration order (audit batch-3, §3.8).
-		// Strip non-restorable fields (runtime attribution) so snapshot → restore → snapshot
-		// is idempotent. Use describe({ detail: "full" }) for audit snapshots instead.
-		const sortedNodes: Record<string, DescribeNodeOutput> = {};
-		for (const key of Object.keys(d.nodes).sort()) {
-			const { lastMutation: _lm, guard: _g, ...node } = d.nodes[key]!;
-			sortedNodes[key] = node;
-		}
-		const sortedSubgraphs = [...d.subgraphs].sort();
-		const snap: GraphPersistSnapshot = {
-			...d,
-			version: 1,
-			nodes: sortedNodes,
-			subgraphs: sortedSubgraphs,
-		};
-		if (opts?.format == null) return snap;
-		if (opts.format === "json-string") return JSON.stringify(snap);
-		if (opts.format === "bytes") {
-			if (opts.codec == null) {
-				throw new Error("snapshot({format: 'bytes'}) requires a `codec` name");
-			}
-			const codec = this.config.lookupCodec<GraphCodec>(opts.codec);
-			if (codec == null) {
-				throw new Error(
-					`snapshot: codec "${opts.codec}" is not registered on this graph's config. ` +
-						`Call config.registerCodec(...) before creating nodes.`,
-				);
-			}
-			return encodeEnvelope(codec, codec.encode(snap));
-		}
-		throw new Error(`snapshot: unknown format "${String(opts.format)}"`);
-	}
-
-	/**
-	 * Auto-dispatch a byte buffer produced by {@link Graph.snapshot} with
-	 * `{format: "bytes", codec: name}`. Reads the v1 envelope, resolves the
-	 * named codec on `config` (defaults to `defaultConfig`), and returns the
-	 * decoded snapshot. Combine with {@link Graph.fromSnapshot} to rehydrate
-	 * a full graph topology from bytes.
-	 *
-	 * @throws If the envelope is malformed or the named codec isn't
-	 *   registered on the target config.
-	 */
-	static decode(bytes: Uint8Array, opts?: { config?: GraphReFlyConfig }): GraphPersistSnapshot {
-		const cfg = opts?.config ?? defaultConfig;
-		const { codec, codecVersion, payload } = decodeEnvelope(bytes, cfg);
-		return codec.decode(payload, codecVersion);
-	}
-
-	/**
-	 * Apply persisted values onto an existing graph whose topology matches the snapshot
-	 * (§3.8). Only {@link DescribeNodeOutput.type} `state` entries with a `value` field
-	 * are written by default; `derived` / `operator` / `effect` are always skipped so
-	 * deps drive recomputation. `producer` entries are skipped unless `includeProducers`
-	 * is set (producers recompute on activation, so restoring is usually a no-op
-	 * overwritten on the next wave — opt in for audit / forensic round-trip use cases).
-	 * Unknown paths are ignored.
-	 *
-	 * @param data - Snapshot envelope with matching `name` and node slices.
-	 * @throws If `data.name` does not equal {@link Graph.name}.
-	 */
-	restore(
-		data: GraphPersistSnapshot,
-		options?: {
-			only?: string | readonly string[];
-			/**
-			 * Fires per failing write. Default behavior (omitted) is silent —
-			 * missing paths and guard denials are swallowed to match the
-			 * historical semantics. Provide a callback to surface failures
-			 * without aborting the remaining restores.
-			 */
-			onError?: (path: string, err: unknown) => void;
-			/**
-			 * Restore `producer` node values alongside `state`. Default `false`:
-			 * producers are reactive sources whose value recomputes on
-			 * activation, so restoring from a snapshot is usually a no-op
-			 * overwritten on the next wave. Audit / forensic round-trip use
-			 * cases that need the stored value to survive restoration can
-			 * opt in. Does not change `derived` / `effect` handling — those
-			 * are always skipped.
-			 */
-			includeProducers?: boolean;
-		},
-	): void {
-		parseSnapshotEnvelope(data);
-		if (data.name !== this.name) {
-			throw new Error(
-				`Graph "${this.name}": restore snapshot name "${data.name}" does not match this graph`,
-			);
-		}
-		const onlyPatterns =
-			options?.only == null
-				? null
-				: (Array.isArray(options.only) ? options.only : [options.only]).map((p) => globToRegex(p));
-		const includeProducers = options?.includeProducers === true;
-		for (const path of Object.keys(data.nodes).sort()) {
-			if (onlyPatterns !== null && !onlyPatterns.some((re) => re.test(path))) continue;
-			const slice = data.nodes[path];
-			if (slice === undefined) continue;
-			if (!("value" in slice) || slice.value === undefined) {
-				// Value absent (valid slice with no snapshotted value) or
-				// value === undefined (malformed — undefined is the global
-				// SENTINEL per spec §2.5, not valid DATA). Surface the
-				// malformed case so torn snapshots don't round-trip silently.
-				if ("value" in slice && slice.value === undefined) {
-					options?.onError?.(
-						path,
-						new Error(
-							`restore: slice.value is undefined for "${path}" (undefined is the global SENTINEL; not valid DATA)`,
-						),
-					);
-				}
-				continue;
-			}
-			if (slice.type === "derived" || slice.type === "effect") {
-				continue;
-			}
-			if (slice.type === "producer" && !includeProducers) {
-				// Reactive producers recompute on activation — restoring would
-				// be overwritten on the first wave. Opt in via
-				// `{includeProducers: true}` for audit use cases.
-				continue;
-			}
-			// V0 shortcut: if the snapshot slice and the live node both carry
-			// matching versioning info (`v.id` + `v.version`), skip the
-			// `set()` — the state is already what the snapshot represents.
-			// Avoids redundant DATA waves on idempotent restores.
-			if (slice.v != null) {
-				const live = this.tryResolve(path);
-				const lv = live?.v;
-				if (lv != null && lv.id === slice.v.id && lv.version === slice.v.version) {
-					continue;
-				}
-			}
-			try {
-				this.set(path, slice.value);
-			} catch (err) {
-				options?.onError?.(path, err);
-			}
-		}
-	}
-
-	/**
-	 * Creates a graph named from the snapshot, optionally runs `build` to register nodes
-	 * and mounts, then {@link Graph.restore} values (§3.8).
-	 *
-	 * @param data - Snapshot envelope (`version` checked).
-	 * @param opts - Either a legacy `build(g)` callback, or an options object:
-	 *   - `build?` — topology constructor; skips auto-hydration when present.
-	 *   - `factories?` — map from glob pattern to {@link GraphNodeFactory},
-	 *     used by auto-hydration to reconstruct non-state nodes. Per-call (no
-	 *     process-global registry). First matching pattern wins.
-	 * @returns Hydrated `Graph` instance.
-	 */
-	static fromSnapshot(
-		data: GraphPersistSnapshot,
-		opts?:
-			| ((g: Graph) => void)
-			| { build?: (g: Graph) => void; factories?: Record<string, GraphNodeFactory> },
-	): Graph {
-		parseSnapshotEnvelope(data);
-		const build = typeof opts === "function" ? opts : opts?.build;
-		const factoryMap = typeof opts === "function" ? undefined : opts?.factories;
-		const g = new Graph(data.name);
-		if (build) {
-			build(g);
-			g.restore(data);
-			return g;
-		}
-		// Auto-create mount hierarchy from subgraphs.
-		for (const mount of [...data.subgraphs].sort((a, b) => {
-			const da = a.split(PATH_SEP).length;
-			const db = b.split(PATH_SEP).length;
-			if (da !== db) return da - db;
-			if (a < b) return -1;
-			if (a > b) return 1;
-			return 0;
-		})) {
-			const parts = mount.split(PATH_SEP);
-			let target: Graph = g;
-			for (const seg of parts) {
-				if (!target._mounts.has(seg)) {
-					target.mount(seg, new Graph(seg));
-				}
-				target = target._mounts.get(seg)!;
-			}
-		}
-
-		// Compile factory glob patterns once. First match in insertion order wins.
-		const factories = factoryMap
-			? Object.entries(factoryMap).map(([pattern, factory]) => ({
-					re: globToRegex(pattern),
-					factory,
-				}))
-			: [];
-		const factoryForPath = (path: string): GraphNodeFactory | undefined => {
-			for (const entry of factories) {
-				if (entry.re.test(path)) return entry.factory;
-			}
-			return undefined;
-		};
-
-		// Resolve the owning graph + local name for a qualified snapshot path.
-		const ownerForPath = (path: string): [Graph, string] => {
-			const segments = path.split(PATH_SEP);
-			const local = segments.pop();
-			if (local == null || local.length === 0) {
-				throw new Error(`invalid snapshot path "${path}"`);
-			}
-			let owner: Graph = g;
-			for (const seg of segments) {
-				const next = owner._mounts.get(seg);
-				if (!next) throw new Error(`unknown mount "${seg}" in path "${path}"`);
-				owner = next;
-			}
-			return [owner, local];
-		};
-
-		const primaryEntries = Object.entries(data.nodes)
-			.filter(([path]) => !path.includes(`${PATH_SEP}${GRAPH_META_SEGMENT}${PATH_SEP}`))
-			.sort((a, b) => (a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0));
-		const pending = new Map(primaryEntries);
-		const created = new Map<string, Node>();
-
-		let progressed = true;
-		while (pending.size > 0 && progressed) {
-			progressed = false;
-			for (const [path, slice] of [...pending.entries()]) {
-				const deps = slice?.deps ?? [];
-				if (!deps.every((dep) => created.has(dep))) continue;
-				const [owner, localName] = ownerForPath(path);
-				const meta: Record<string, unknown> = { ...(slice?.meta ?? {}) };
-				const factory = factoryForPath(path);
-				let n: Node;
-				if (slice?.type === "state") {
-					n = node([], { initial: slice.value, meta });
-				} else {
-					if (factory == null) continue;
-					n = factory(localName, {
-						path,
-						type: slice.type,
-						value: slice.value,
-						meta,
-						deps,
-						resolvedDeps: deps.map((dep) => created.get(dep)!),
-					});
-				}
-				owner.add(n, { name: localName });
-				created.set(path, n);
-				pending.delete(path);
-				progressed = true;
-			}
-		}
-		if (pending.size > 0) {
-			const unresolved = [...pending.keys()].sort().join(", ");
-			throw new Error(
-				`Graph.fromSnapshot could not reconstruct nodes without build callback: ${unresolved}. ` +
-					`Pass matching factories via fromSnapshot(data, { factories: { pattern: factoryFn } }).`,
-			);
-		}
-		// Edges are derived from node `_deps` reconstructed during node
-		// creation above — no explicit edge replay needed (Unit 7).
-		g.restore(data);
-		return g;
-	}
-
-	/**
-	 * ECMAScript `JSON.stringify` hook — returns the same object as
-	 * {@link Graph.snapshot}. Makes `JSON.stringify(graph)` "just work"
-	 * without double-encoding.
-	 */
-	toJSON(): GraphPersistSnapshot {
-		return this.snapshot();
-	}
-
-	/**
-	 * Unified persistence surface (§3.8). Cascades snapshot records through
-	 * one or more paired-tier slots, each with its own `debounceMs` /
-	 * `compactEvery` cadence and independent diff baseline.
-	 *
-	 * **Paired tier shape (Phase 14.6 — DS-14-storage Q3 lock B).** Each
-	 * `AttachSnapshotTierPair` pairs a snapshot tier (holds `mode:"full"`
-	 * baselines under `${graph.name}`) with an optional WAL companion
-	 * (holds `WALFrame<T>` records under `${graph.name}/wal/...`). Diff
-	 * records no longer overwrite the snapshot tier; they decompose into
-	 * one DS-14 `BaseChange<T>`-wrapped frame per discrete change and route
-	 * to the WAL tier. Replay via {@link Graph.restoreSnapshot} filters
-	 * `frame_seq > baseline.seq` against either tier's shared per-slot
-	 * counter. Omitting `wal` falls back to baseline-only persistence —
-	 * intermediate state isn't recoverable, but every flush writes a full.
-	 *
-	 * Subscription gates on {@link messageTier} ≥ 3 (DATA/RESOLVED/terminal),
-	 * never on tier-0/1/2 control waves (START/DIRTY/INVALIDATE/PAUSE/RESUME)
-	 * or tier-5 TEARDOWN (graceful shutdown is the caller's responsibility).
-	 *
-	 * Per-slot cadence lets the hot tier stay sync while cold tiers absorb
-	 * async writes without blocking the hot path. Each slot holds its own
-	 * `{lastSnapshot, lastFingerprint, seq}` so cold-tier diff baselines
-	 * aren't polluted by hot-tier flushes. Slots with `debounceMs === 0`
-	 * share a single snapshot computation per observe event; debounced slots
-	 * compute their own snapshot when their timer fires.
-	 *
-	 * **Cross-tier atomicity is best-effort** (Phase 14 STRONG DEFER). M4
-	 * Rust impl with `redb` write-transactions wraps snapshot+WAL atomically;
-	 * pure-TS impl is best-effort under crash. See
-	 * `archive/docs/SESSION-DS-14-storage-wal-replay.md` Q3+Q6.
-	 *
-	 * @category graph
-	 */
-	attachSnapshotStorage(
-		pairs: readonly AttachSnapshotTierPair[],
-		options: GraphAttachStorageOptions = {},
-	): StorageHandle {
-		type TierState = {
-			snapshotTier: SnapshotStorageTier<GraphCheckpointRecord>;
-			walTier: BaseStorageTier | undefined;
-			walPrefix: string;
-			debounceMs: number;
-			compactEvery: number;
-			timer: ResettableTimer | undefined;
-			/**
-			 * Shared write-cursor (Phase 14.6 — DS-14-storage Q1+Q3 lock).
-			 * Increments by 1 per `mode:"full"` baseline write OR per WAL
-			 * frame written. Frames carry `frame_seq = seq` at write time;
-			 * baselines carry `seq` so replay can filter
-			 * `frame_seq > baseline.seq`.
-			 */
-			seq: number;
-			/** Per-flush counter — drives `compactEvery` cadence independent of seq. */
-			flushCount: number;
-			lastSnapshot: GraphPersistSnapshot | undefined;
-			lastFingerprint: string;
-			disposed: boolean;
-			savePending: Promise<void> | undefined;
-			/** Resolves once `seq` has been bootstrapped from existing WAL frames. */
-			bootstrap: Promise<void> | undefined;
-			/**
-			 * DS-14.5.A delta #7 (Q8 squelch) — the `_topologyVersion` value at
-			 * the last `lifecycle:"spec"` snapshot write for this tier. The
-			 * wave-boundary hook skips when `graph._topologyVersion ===
-			 * lastPersistedSpecVersion` (no shape drift since last spec write).
-			 * Seeded to `graph._topologyVersion` at attach time — the spec at
-			 * attach is the implicit reference baseline, so only post-attach
-			 * topology drift is persisted (Q8). Advanced to the version
-			 * actually written on each spec flush.
-			 */
-			lastPersistedSpecVersion: number;
-		};
-		const states: TierState[] = pairs.map((pair) => ({
-			snapshotTier: pair.snapshot,
-			walTier: pair.wal,
-			walPrefix: graphWalPrefix(this.name),
-			debounceMs: Math.max(0, pair.snapshot.debounceMs ?? 0),
-			compactEvery: Math.max(1, pair.snapshot.compactEvery ?? 10),
-			timer: undefined,
-			seq: 0,
-			flushCount: 0,
-			lastSnapshot: undefined,
-			lastFingerprint: "",
-			disposed: false,
-			savePending: undefined,
-			bootstrap: undefined,
-			// DS-14.5.A Q8 — the spec at attach time is the implicit
-			// reference baseline; only topology DRIFT *after* attach is
-			// persisted as a spec snapshot. Seeding to the current version
-			// (not -1) prevents an attach-time spurious spec write that would
-			// otherwise collide with the value baseline on a shared tier.
-			lastPersistedSpecVersion: this._topologyVersion,
-		}));
-
-		const snapshotTiers = pairs.map((p) => p.snapshot);
-
-		// Phase 14.6 fix C — validate WAL tiers expose save(key, value) at
-		// attach time, not lazily inside writeFrames. A misconfigured tier
-		// surfaces immediately rather than after the first flush attempt.
-		for (const pair of pairs) {
-			if (pair.wal == null) continue;
-			const walSave = (
-				pair.wal as BaseStorageTier & {
-					save?: (key: string, value: unknown) => void | Promise<void>;
-				}
-			).save;
-			if (typeof walSave !== "function") {
-				throw new TypeError(
-					`Graph.attachSnapshotStorage: WAL tier "${pair.wal.name}" does not expose save(key, value); use kvStorage(...) or an equivalent BaseStorageTier with save(key, value).`,
-				);
-			}
-		}
-
-		if (options.autoRestore === true) {
-			// Fire-and-forget cascade restore; errors surface via onError with
-			// the specific tier that failed.
-			void this._cascadeRestore(snapshotTiers, options.onError);
-		}
-
-		// Eager-bootstrap each tier's `seq` from existing WAL frames so a
-		// re-attach to a populated tier never collides with prior writes.
-		// On bootstrap failure we poison the slot (`s.disposed = true`) — we
-		// have no valid starting `seq` and any further write risks
-		// overwriting prior frames at low frame_seq values. Users see the
-		// error via `options.onError` and can re-attach with fresh state.
-		for (const s of states) {
-			if (s.walTier == null) continue;
-			const walTier = s.walTier;
-			s.bootstrap = (async () => {
-				try {
-					let highest = 0;
-					for await (const entry of iterateWalFrames(walTier, s.walPrefix)) {
-						const fseq = entry.frame.frame_seq;
-						if (fseq > highest) highest = fseq;
-					}
-					if (highest > s.seq) s.seq = highest;
-				} catch (err) {
-					options.onError?.(err, s.snapshotTier);
-					s.disposed = true;
-				}
-			})();
-		}
-
-		// Phase 14.6 fix A — `runFlush` serializes the entire body through
-		// `s.savePending` so back-to-back flushes never race on `s.seq` /
-		// `s.flushCount` / `s.lastSnapshot`. The async `performWork` is
-		// invoked AFTER `prev` resolves (not concurrently), and it awaits
-		// `s.bootstrap` at the top so first-flush-on-re-attach reads the
-		// correct starting `seq`. State mutations only commit after the
-		// underlying tier write resolves; on failure none of `seq`,
-		// `flushCount`, `lastSnapshot`, or `lastFingerprint` advance, so the
-		// next flush retries against the last persisted state.
-		const runFlush = (s: TierState, snapshot: GraphPersistSnapshot): void => {
-			if (s.disposed) return;
-
-			const performWork = async (): Promise<void> => {
-				if (s.bootstrap) await s.bootstrap;
-				if (s.disposed) return;
-
-				const fingerprint = computeVersionFingerprint(snapshot.nodes);
-				if (s.lastSnapshot != null && fingerprint !== "" && fingerprint === s.lastFingerprint) {
-					return;
-				}
-				const timestamp_ns = wallClockNs();
-				const isFirst = s.lastSnapshot == null;
-				const nextFlushCount = s.flushCount + 1;
-				// Compact when this slot has no WAL companion (no other
-				// channel captures intermediate state), on first write (need
-				// a baseline before any frames), or on the configured
-				// cadence.
-				const shouldCompact = isFirst || s.walTier == null || nextFlushCount % s.compactEvery === 0;
-
-				if (shouldCompact) {
-					const baselineSeq = s.seq + 1;
-					const record: GraphCheckpointRecord = {
-						name: this.name,
-						mode: "full",
-						snapshot,
-						seq: baselineSeq,
-						timestamp_ns,
-						format_version: SNAPSHOT_VERSION,
-					};
-					if (s.snapshotTier.filter && !s.snapshotTier.filter(record)) {
-						return;
-					}
-					try {
-						await Promise.resolve(s.snapshotTier.save(record));
-					} catch (error) {
-						options.onError?.(error, s.snapshotTier);
-						return;
-					}
-					if (s.disposed) return;
-					s.seq = baselineSeq;
-					s.flushCount = nextFlushCount;
-					s.lastSnapshot = snapshot;
-					s.lastFingerprint = fingerprint;
-					return;
-				}
-
-				// WAL path.
-				const walTier = s.walTier;
-				if (walTier == null) return;
-				const diff = diffForWAL(s.lastSnapshot!, snapshot);
-				const frames = decomposeDiffToFrames(diff, timestamp_ns);
-				if (frames.length === 0) {
-					s.flushCount = nextFlushCount;
-					s.lastSnapshot = snapshot;
-					s.lastFingerprint = fingerprint;
-					return;
-				}
-				const walSave = (
-					walTier as BaseStorageTier & {
-						save: (key: string, value: unknown) => void | Promise<void>;
-					}
-				).save;
-				// `walSave` validated at attach time per fix C above.
-				let localSeq = s.seq;
-				for (const partial of frames) {
-					if (s.disposed) return;
-					localSeq += 1;
-					const bodied: Omit<WALFrame, "checksum"> = {
-						t: "c",
-						lifecycle: partial.lifecycle,
-						path: partial.path,
-						change: partial.change,
-						frame_seq: localSeq,
-						frame_t_ns: timestamp_ns,
-						format_version: WAL_FORMAT_VERSION,
-					};
-					const checksum = await walFrameChecksum(bodied);
-					const frame: WALFrame = { ...bodied, checksum };
-					await Promise.resolve(walSave.call(walTier, walFrameKey(s.walPrefix, localSeq), frame));
-				}
-				if (s.disposed) return;
-				// Advance state atomically AFTER all frames in the batch
-				// landed. On partial-tear failure none of these advance and
-				// the next flush re-emits frames at higher seqs (idempotent
-				// for `node.set` / `node.invalidate`); see §3.8 "WAL replay"
-				// best-effort caveat.
-				s.seq = localSeq;
-				s.flushCount = nextFlushCount;
-				s.lastSnapshot = snapshot;
-				s.lastFingerprint = fingerprint;
-			};
-
-			const prev = s.savePending ?? Promise.resolve();
-			// Calling `performWork()` inside the `then` callbacks (rather
-			// than passing an already-running Promise) guarantees the work
-			// only starts after `prev` resolves. This is the linchpin of fix
-			// A — without it back-to-back `runFlush` invocations spawn
-			// concurrent IIFEs that race on `s.seq` and `s.flushCount`.
-			const next = prev.then(
-				() => performWork(),
-				() => performWork(),
-			);
-			s.savePending = next
-				.catch((err) => {
-					// Final safety net — `performWork` already routes tier
-					// save failures through `onError`; this catches checksum /
-					// codec / unexpected throws so the chain stays alive.
-					options.onError?.(err, s.snapshotTier);
-				})
-				.finally(() => {
-					if (s.savePending === next) s.savePending = undefined;
-				});
-		};
-
-		const flushTier = (s: TierState, snapshot: GraphPersistSnapshot): void => {
-			try {
-				runFlush(s, snapshot);
-			} catch (error) {
-				options.onError?.(error, s.snapshotTier);
-			}
-		};
-
-		// DS-14.5.A delta #7 — spec-snapshot write (Q3/Q8). A
-		// topology-version-triggered `mode:"full"`, `lifecycle:"spec"` record
-		// whose `snapshot` is the `describe({detail:"spec"})` projection.
-		// Serialized through the SAME `s.savePending` chain as `runFlush` so a
-		// value flush and a spec flush never race on `s.seq`. Q8 squelch: the
-		// caller (`maybeFlushSpec`) only invokes this when `_topologyVersion`
-		// advanced past `s.lastPersistedSpecVersion`; this fn re-reads the
-		// version at write commit time so the recorded watermark reflects the
-		// actual persisted shape (handles same-wave bump-and-collapse).
-		const runSpecFlush = (s: TierState): void => {
-			if (s.disposed) return;
-			const performWork = async (): Promise<void> => {
-				if (s.bootstrap) await s.bootstrap;
-				if (s.disposed) return;
-				const versionAtWrite = this._topologyVersion;
-				// Re-check under serialization: an earlier queued spec flush in
-				// this same chain may have already persisted this version.
-				if (versionAtWrite === s.lastPersistedSpecVersion) return;
-				const { expand: _e, ...spec } = this.describe({ detail: "spec" });
-				const specSnapshot = { ...spec, version: 1 } as GraphPersistSnapshot;
-				const baselineSeq = s.seq + 1;
-				const record: GraphCheckpointRecord = {
-					name: this.name,
-					mode: "full",
-					lifecycle: "spec",
-					snapshot: specSnapshot,
-					seq: baselineSeq,
-					timestamp_ns: wallClockNs(),
-					format_version: SNAPSHOT_VERSION,
-				};
-				if (s.snapshotTier.filter && !s.snapshotTier.filter(record)) {
-					// Filtered out — still advance the watermark so we don't
-					// re-attempt the identical filtered write every wave.
-					s.lastPersistedSpecVersion = versionAtWrite;
-					return;
-				}
-				try {
-					await Promise.resolve(s.snapshotTier.save(record));
-				} catch (error) {
-					options.onError?.(error, s.snapshotTier);
-					return;
-				}
-				if (s.disposed) return;
-				s.seq = baselineSeq;
-				s.lastPersistedSpecVersion = versionAtWrite;
-			};
-			const prev = s.savePending ?? Promise.resolve();
-			const next = prev.then(
-				() => performWork(),
-				() => performWork(),
-			);
-			s.savePending = next
-				.catch((err) => {
-					options.onError?.(err, s.snapshotTier);
-				})
-				.finally(() => {
-					if (s.savePending === next) s.savePending = undefined;
-				});
-		};
-
-		// Q8 squelch gate — skip the spec write when no topology mutation has
-		// landed since this tier's last spec snapshot. O(1) integer compare;
-		// no graph diff.
-		const maybeFlushSpec = (s: TierState): void => {
-			if (s.disposed) return;
-			if (this._topologyVersion === s.lastPersistedSpecVersion) return;
-			try {
-				runSpecFlush(s);
-			} catch (error) {
-				options.onError?.(error, s.snapshotTier);
-			}
-		};
-
-		// Wave-boundary coalescer (Q8 — NO timer, reuse the `_describeReactive`
-		// `registerBatchFlushHook` pattern). Subscribing to `this.topology`
-		// fires the producer for every structural mutation; we coalesce N
-		// per-wave topology events into ONE spec-version check at the head of
-		// the next drain. Outside an explicit batch the hook fires immediately
-		// (sync-wave parity). `tagFactory` emits no `TopologyEvent`, so a
-		// dedicated check also runs at dispose and is reachable via the
-		// version compare on the next topology event; callers needing an
-		// immediate spec flush after a lone `tagFactory` can dispose the
-		// handle (dispose drains pending saves).
-		let specBumpPending = false;
-		const scheduleSpecCheck = (): void => {
-			if (specBumpPending) return;
-			specBumpPending = true;
-			registerBatchFlushHook(() => {
-				specBumpPending = false;
-				for (const s of states) maybeFlushSpec(s);
-			});
-		};
-		const specTopoUnsub = this.topology.subscribe((msgs) => {
-			for (const m of msgs) {
-				if (m[0] === DATA) {
-					scheduleSpecCheck();
-					return;
-				}
-			}
-		});
-
-		const onEvent = (path: string, messages: Messages): void => {
-			const triggeredByTier = messages.some((m) => {
-				const tier = this.config.messageTier(m[0]);
-				// Include DATA/RESOLVED (3), INVALIDATE (4), COMPLETE/ERROR (5);
-				// exclude TEARDOWN (6) — graph teardown skips the final checkpoint.
-				return tier >= 3 && tier < 6;
-			});
-			if (!triggeredByTier) return;
-			if (options.filter) {
-				const nd = this.tryResolve(path);
-				if (nd == null) return;
-				const described = describeNode(nd, resolveDescribeFields("standard"));
-				if (!options.filter(path, described)) return;
-			}
-			// Shared snapshot for all sync (debounceMs=0) tiers firing on this event.
-			let sharedSnapshot: GraphPersistSnapshot | undefined;
-			const getSnapshot = (): GraphPersistSnapshot => {
-				if (sharedSnapshot == null) sharedSnapshot = this.snapshot();
-				return sharedSnapshot;
-			};
-			for (const s of states) {
-				if (s.disposed) continue;
-				if (s.debounceMs === 0) {
-					flushTier(s, getSnapshot());
-				} else {
-					if (s.timer == null) s.timer = new ResettableTimer();
-					s.timer.start(s.debounceMs, () => {
-						if (s.disposed) return;
-						flushTier(s, this.snapshot());
-					});
-				}
-			}
-		};
-
-		let off: () => void;
-		if (options.paths != null) {
-			const paths =
-				typeof options.paths === "string"
-					? this._pathsMatching(options.paths)
-					: (options.paths as readonly string[]);
-			const unsubs = paths.map((p) => {
-				const nd = this.tryResolve(p);
-				if (nd == null) return () => {};
-				return nd.subscribe((msgs) => onEvent(p, msgs));
-			});
-			off = () => {
-				for (const u of unsubs) u();
-			};
-		} else {
-			off = this.observe().subscribe((path, messages) => onEvent(path, messages));
-		}
-
-		const dispose = async () => {
-			off();
-			specTopoUnsub();
-			// DS-14.5.A delta #7 — final spec-version reconciliation. Covers
-			// the lone-`tagFactory` case (emits no `TopologyEvent`, so the
-			// wave-boundary subscriber never fired) and any pending coalesced
-			// bump: persist the current shape before draining if it drifted.
-			for (const s of states) maybeFlushSpec(s);
-			// Drain in-flight saves before marking disposed so late
-			// performWork() calls don't bail on the disposed guard
-			// while frames are still being written (race with
-			// crypto.subtle.digest in walFrameChecksum).
-			const pending = states.map((s) => s.savePending).filter((p): p is Promise<void> => p != null);
-			if (pending.length > 0) await Promise.all(pending);
-			for (const s of states) {
-				s.disposed = true;
-				s.timer?.cancel();
-			}
-			this._storageDisposers.delete(dispose);
-		};
-		this._storageDisposers.add(dispose);
-		return { dispose };
-	}
-
-	/**
-	 * Replay a WAL stream onto this graph (Phase 14.6 — DS-14-storage Q9
-	 * lock). Apply intermediate {@link WALFrame}s in cross-scope order
-	 * `spec → data → ownership` per DS-14 PART 4; within a scope, frames
-	 * apply in `frame_seq` ASC. Each lifecycle phase runs inside one
-	 * `graph.batch()` so a phase failure rolls back its own writes without
-	 * tearing down earlier phases (Q2 lock).
-	 *
-	 * **Source forms.** `source` may be either a pre-collected
-	 * `AsyncIterable<WALFrame>` (caller assembled the WAL externally for
-	 * tests, network replays, or fixtures) or a tier handle
-	 * `{ tier, walTier }`. With the tier-handle form the latest
-	 * `mode:"full"` baseline is loaded from `tier`, applied as the starting
-	 * state, then frames with `frame_seq > baseline.seq` are replayed from
-	 * `walTier`. Both fields are required — Phase 14.6 fix B1 dropped the
-	 * `walTier ?? tier` fallback because the snapshot tier doesn't expose
-	 * `listByPrefix`.
-	 *
-	 * **Pre-collected stream constraints.** `frame_seq` values must be
-	 * unique across the AsyncIterable; cross-tier merging requires an
-	 * explicit total-order resolver and isn't supported in Phase 14.6.
-	 *
-	 * **Torn-write handling.** Each frame's checksum is verified before
-	 * apply. On mismatch at the WAL tail (no later frame in the stream) the
-	 * default policy is `"skip"` — drop the frame, count it in
-	 * `skippedFrames`, and continue. Mid-stream mismatches default to
-	 * `"abort"` and throw `RestoreError("torn-write-mid-stream")`. Override
-	 * either via the `onTornWrite` callback (Q3 lock).
-	 *
-	 * **Replay-vs-active-storage caveat.** Replay applies frames via
-	 * `graph.set` / `graph.invalidate` inside `graph.batch()`. If
-	 * `attachSnapshotStorage` is currently attached on this graph, those
-	 * mutations also fire observe events that schedule fresh WAL writes.
-	 * Disposing the existing handle (or calling `restoreSnapshot` BEFORE
-	 * `attachSnapshotStorage`) keeps the WAL stream from echoing replayed
-	 * frames back into itself.
-	 *
-	 * **Phase 14.6 deferred limitations.** `applyWalFrame` is best-effort
-	 * within each lifecycle: only state-typed `graph.add` slices and
-	 * `node.set` / `node.invalidate` apply on replay. Subgraph mounts
-	 * (`graph.mount` / `graph.unmount`), non-state node reconstruction,
-	 * `graph.connect` / rewire frames, and V0 `node.versionBump` are all
-	 * persisted but skipped on apply — surface them via factories on a
-	 * fresh `Graph.fromSnapshot(baseline, { factories })` if you need full
-	 * topology fidelity.
-	 *
-	 * **Payload constraints.** `node.set` frames serialize the value via
-	 * the WAL tier's codec (`jsonCodec` default per Q4). User payloads
-	 * must round-trip through that codec — `Map`, `Set`, `Date`, `BigInt`,
-	 * and circular structures don't survive `jsonCodec` and will silently
-	 * lose fidelity. Use a binary codec (DagCbor when the post-1.0 IPLD
-	 * substrate ships) for non-JSON payloads.
-	 *
-	 * **Best-effort caveat.** Cross-tier atomicity is NOT guaranteed in the
-	 * pure-TS impl (Phase 14 STRONG DEFER). M4 Rust impl with `redb`
-	 * write-transactions wraps snapshot+WAL atomically. See
-	 * `archive/docs/SESSION-DS-14-storage-wal-replay.md` Q3+Q6.
-	 *
-	 * @category graph
-	 */
-	async restoreSnapshot(opts: GraphRestoreSnapshotOptions): Promise<RestoreResult> {
-		if (opts.mode !== "diff") {
-			throw new RestoreError(
-				"baseline-missing",
-				`Graph.restoreSnapshot: only mode:"diff" is implemented. For mode:"full" use Graph.restore(snapshot) directly or Graph.fromStorage(name, tiers).`,
-				{ mode: opts.mode as string },
-			);
-		}
-
-		// DS-14.5.A delta #7 — spec-only restore fast path. A
-		// `lifecycle:"spec"` checkpoint is a `mode:"full"` baseline (the
-		// `describe({detail:"spec"})` projection), NOT a diff stream — replay
-		// it by applying the full snapshot, skipping the WAL walk entirely.
-		//
-		// Engages ONLY when (a) the filter is exactly `["spec"]`, (b) the
-		// source is a tier handle, AND (c) the tier's latest record is
-		// actually a `lifecycle:"spec"` full baseline. When the tier holds a
-		// normal value baseline (no `lifecycle` tag, or `"data"`), this is a
-		// `["spec"]`-scoped *diff* replay over a value baseline — fall through
-		// to the existing WAL-diff path, which applies the value baseline then
-		// filters WAL frames to the spec lifecycle (the pre-existing Phase
-		// 14.6 semantic). Peeking `load()` here is cheap and idempotent
-		// (the diff path re-loads it).
-		if (
-			opts.lifecycle != null &&
-			opts.lifecycle.length === 1 &&
-			opts.lifecycle[0] === "spec" &&
-			!(Symbol.asyncIterator in (opts.source as object))
-		) {
-			const handle = opts.source as {
-				tier: SnapshotStorageTier<GraphCheckpointRecord>;
-			};
-			let raw: unknown;
-			try {
-				raw = await Promise.resolve(handle.tier.load?.());
-			} catch {
-				raw = undefined; // defer error semantics to the diff path below
-			}
-			if (raw != null && typeof raw === "object" && !Array.isArray(raw)) {
-				const record = raw as GraphCheckpointRecord;
-				if (record.mode === "full" && record.lifecycle === "spec") {
-					this.restore(record.snapshot);
-					return {
-						replayedFrames: 0,
-						skippedFrames: 0,
-						finalSeq: record.seq,
-						phases: [{ lifecycle: "spec", frames: 0 }],
-					};
-				}
-			}
-			// else: not a spec baseline — fall through to the diff path.
-		}
-
-		// Phase 14.6 fix J — `lifecycle: []` silently no-ops (filter rejects
-		// every frame), masking a likely caller bug. Omit the field for the
-		// default full set, or include at least one of "spec" / "data" /
-		// "ownership" to scope the rewind.
-		if (opts.lifecycle != null && opts.lifecycle.length === 0) {
-			throw new RestoreError(
-				"phase-failed",
-				'Graph.restoreSnapshot: empty lifecycle filter [] would replay no frames; omit `lifecycle` for the default full set, or include at least one of "spec" | "data" | "ownership".',
-				{},
-			);
-		}
-		const lifecycleFilter = new Set(opts.lifecycle ?? REPLAY_ORDER);
-		const targetSeq = opts.targetSeq ?? Number.POSITIVE_INFINITY;
-		const onTornWrite = opts.onTornWrite;
-
-		// Phase 1 — resolve source + (when applicable) load + apply baseline.
-		let baselineSeq = 0;
-		const collected: WALFrame[] = [];
-		if (Symbol.asyncIterator in (opts.source as object)) {
-			for await (const frame of opts.source as AsyncIterable<WALFrame>) {
-				if (frame.frame_seq > targetSeq) continue;
-				collected.push(frame);
-			}
-		} else {
-			const handle = opts.source as {
-				tier: SnapshotStorageTier<GraphCheckpointRecord>;
-				walTier: BaseStorageTier;
-			};
-			if (handle.walTier == null) {
-				throw new RestoreError(
-					"wal-tier-required",
-					'Graph.restoreSnapshot({ mode: "diff", source: { tier, walTier } }): walTier is required for tier-handle source. The snapshot tier does not expose listByPrefix; pass an explicit BaseStorageTier (e.g. kvStorage(...)) for the WAL companion.',
-					{ tier: handle.tier.name },
-				);
-			}
-			const walTier = handle.walTier;
-			let raw: unknown;
-			try {
-				raw = await Promise.resolve(handle.tier.load?.());
-			} catch (err) {
-				throw new RestoreError(
-					"baseline-missing",
-					`Graph.restoreSnapshot: snapshot tier "${handle.tier.name}" load() threw — cannot establish baseline.`,
-					{ tier: handle.tier.name, cause: err instanceof Error ? err.message : String(err) },
-				);
-			}
-			if (raw == null || typeof raw !== "object" || Array.isArray(raw)) {
-				throw new RestoreError(
-					"baseline-missing",
-					`Graph.restoreSnapshot: snapshot tier "${handle.tier.name}" returned no record; cannot replay WAL without a baseline.`,
-					{ tier: handle.tier.name },
-				);
-			}
-			const record = raw as GraphCheckpointRecord;
-			if (record.mode !== "full") {
-				throw new RestoreError(
-					"baseline-missing",
-					`Graph.restoreSnapshot: snapshot tier "${handle.tier.name}" holds a non-full record; baselines must be mode:"full".`,
-					{ tier: handle.tier.name, mode: record.mode },
-				);
-			}
-			// DS-14.5.A F6 — a `lifecycle:"spec"` record's `snapshot` is a
-			// `describe({detail:"spec"})` topology projection, NOT a value
-			// baseline; `this.restore()` on it would corrupt graph state. The
-			// spec-only fast path above (filter exactly `["spec"]`) is the ONLY
-			// sanctioned consumer of a spec baseline. Reaching here with a spec
-			// record means the tier mixes spec + value lifecycles on one tier
-			// without a `["spec"]` filter — spec snapshots require a dedicated
-			// snapshot tier. Fail fast rather than load a projection as values.
-			if (record.lifecycle === "spec") {
-				throw new RestoreError(
-					"baseline-missing",
-					`Graph.restoreSnapshot: snapshot tier "${handle.tier.name}" holds a lifecycle:"spec" baseline, which is a topology projection — not a value baseline. Use restoreSnapshot({ lifecycle:["spec"] }) for the spec-only fast path, or give spec snapshots a dedicated tier separate from value baselines.`,
-					{ tier: handle.tier.name, lifecycle: record.lifecycle },
-				);
-			}
-			// Phase 14.6 fix D — point-in-time recovery up to a `targetSeq`
-			// strictly older than the latest baseline isn't expressible in
-			// this API: replay would restore the (newer) baseline and then
-			// filter every frame, leaving the user at a state more recent
-			// than they asked for. Surface explicitly so callers either
-			// stage their own older baseline or drop `targetSeq`.
-			if (record.seq > targetSeq) {
-				throw new RestoreError(
-					"phase-failed",
-					`Graph.restoreSnapshot: targetSeq=${targetSeq} is below baseline.seq=${record.seq}; the snapshot tier holds a newer baseline than the requested point-in-time. Stage an older baseline or omit targetSeq.`,
-					{ targetSeq, baselineSeq: record.seq, tier: handle.tier.name },
-				);
-			}
-			this.restore(record.snapshot);
-			baselineSeq = record.seq;
-
-			let listError: unknown;
-			try {
-				for await (const entry of iterateWalFrames(walTier, graphWalPrefix(this.name))) {
-					const fseq = entry.frame.frame_seq;
-					if (fseq <= baselineSeq) continue;
-					if (fseq > targetSeq) continue;
-					collected.push(entry.frame);
-				}
-			} catch (err) {
-				listError = err;
-			}
-			if (listError != null) {
-				const code: "wal-tier-required" | "phase-failed" =
-					(listError as StorageError | undefined)?.name === "StorageError"
-						? "wal-tier-required"
-						: "phase-failed";
-				throw new RestoreError(
-					code,
-					`Graph.restoreSnapshot: WAL tier "${walTier.name}" listByPrefix failed; cannot enumerate frames.`,
-					{
-						tier: walTier.name,
-						cause: listError instanceof Error ? listError.message : String(listError),
-					},
-				);
-			}
-		}
-
-		// Phase 2 — verify checksums + classify torn writes; preserve
-		// frame_seq order (lex-ASC keys already align numerically up to
-		// 10^20, but pre-collected streams may be unordered).
-		collected.sort((a, b) => a.frame_seq - b.frame_seq);
-		const verified: WALFrame[] = [];
-		let skippedFrames = 0;
-		for (let i = 0; i < collected.length; i++) {
-			const frame = collected[i] as WALFrame;
-			const ok = await verifyWalFrameChecksum(frame);
-			if (ok) {
-				verified.push(frame);
-				continue;
-			}
-			const isTail = i === collected.length - 1;
-			const policy =
-				onTornWrite?.({ frame_seq: frame.frame_seq, reason: "checksum-mismatch" }) ??
-				(isTail ? "skip" : "abort");
-			if (policy === "abort" || (!isTail && policy !== "skip")) {
-				throw new RestoreError(
-					"torn-write-mid-stream",
-					`Graph.restoreSnapshot: frame at frame_seq=${frame.frame_seq} failed checksum mid-stream; aborting per Q3 lock.`,
-					{ frame_seq: frame.frame_seq, isTail },
-				);
-			}
-			skippedFrames++;
-		}
-
-		// Phase 3 — group by lifecycle, apply per-phase via batch().
-		const grouped: Record<"spec" | "data" | "ownership", WALFrame[]> = {
-			spec: [],
-			data: [],
-			ownership: [],
-		};
-		for (const frame of verified) {
-			if (!lifecycleFilter.has(frame.lifecycle)) continue;
-			grouped[frame.lifecycle].push(frame);
-		}
-
-		const phaseResults: Array<{
-			lifecycle: "spec" | "data" | "ownership";
-			frames: number;
-		}> = [];
-		let highestSeq = baselineSeq;
-		let replayedFrames = 0;
-
-		for (const lifecycle of REPLAY_ORDER) {
-			const lifeFrames = grouped[lifecycle];
-			if (lifeFrames.length === 0) {
-				phaseResults.push({ lifecycle, frames: 0 });
-				continue;
-			}
-			try {
-				this.batch(() => {
-					for (const frame of lifeFrames) {
-						applyWalFrame(this, frame);
-						if (frame.frame_seq > highestSeq) highestSeq = frame.frame_seq;
-					}
-				});
-				replayedFrames += lifeFrames.length;
-				phaseResults.push({ lifecycle, frames: lifeFrames.length });
-			} catch (err) {
-				throw new RestoreError(
-					"phase-failed",
-					`Graph.restoreSnapshot: lifecycle "${lifecycle}" replay phase failed; ${
-						err instanceof Error ? err.message : String(err)
-					}`,
-					{
-						lifecycle,
-						cause: err instanceof Error ? err.message : String(err),
-					},
-				);
-			}
-		}
-
-		return {
-			replayedFrames,
-			skippedFrames,
-			finalSeq: highestSeq,
-			phases: phaseResults,
-		};
-	}
-
-	/**
-	 * Try tiers in order (hottest first); apply the first record that hits
-	 * via {@link Graph.restore}. Returns `true` if any tier produced a
-	 * restorable snapshot, `false` if all missed.
-	 *
-	 * Resilience: a tier that returns data which cannot be restored (load
-	 * throws, shape unrecognized, or `restore()` itself throws) does not abort
-	 * the cascade — the error is routed through `onError` (if supplied) and
-	 * the next colder tier is tried. This mirrors how a multi-tier cache
-	 * falls through on a corrupt hot entry.
-	 *
-	 * Note: `restore()` mutates state incrementally. If a restore throws
-	 * partway through, the graph may hold a mixed state (some slices from
-	 * the bad tier, some pre-existing). A subsequent successful tier's
-	 * `restore()` overwrites the overlapping slices.
-	 *
-	 * Internal helper shared by {@link Graph.attachSnapshotStorage}'s `autoRestore`
-	 * option and the static {@link Graph.fromStorage} factory.
-	 */
-	private async _cascadeRestore(
-		tiers: readonly SnapshotStorageTier<GraphCheckpointRecord>[],
-		onError?: (err: unknown, tier: SnapshotStorageTier<GraphCheckpointRecord>) => void,
-	): Promise<boolean> {
-		for (const tier of tiers) {
-			let raw: unknown;
-			try {
-				raw = await tier.load?.();
-			} catch (err) {
-				onError?.(err, tier);
-				continue;
-			}
-			if (raw == null) continue;
-			if (typeof raw !== "object" || Array.isArray(raw)) continue;
-			const record = raw as Record<string, unknown>;
-			try {
-				// Accept both a `GraphCheckpointRecord` envelope
-				// (`mode === "full"`) and a bare `GraphPersistSnapshot` (the
-				// shape written by `saveGraphCheckpoint`). Bare snapshots
-				// carry `version: 1`.
-				if (record.mode === "full" && record.snapshot != null) {
-					this.restore(record.snapshot as GraphPersistSnapshot);
-					return true;
-				}
-				if (record.version === SNAPSHOT_VERSION && record.nodes != null) {
-					this.restore(record as GraphPersistSnapshot);
-					return true;
-				}
-			} catch (err) {
-				onError?.(err, tier);
-				// Fall through to the next tier.
-			}
-		}
-		return false;
-	}
-
-	/**
-	 * Construct a fresh {@link Graph} pre-hydrated from the first tier that
-	 * hits. Delegates topology reconstruction to {@link Graph.fromSnapshot}
-	 * on `"full"` records and direct {@link Graph.restore} on bare snapshots.
-	 *
-	 * Always asynchronous — awaits `tier.load()` for async tier support even
-	 * when all tiers are sync. Callers that know they only pass sync tiers
-	 * can safely `await` immediately.
-	 *
-	 * @throws If no tier holds a restorable record matching `name` *and* no
-	 *   `factories` override is provided for dynamic nodes.
-	 */
-	static async fromStorage(
-		name: string,
-		tiers: readonly SnapshotStorageTier<GraphCheckpointRecord>[],
-		opts?: GraphOptions & {
-			factories?: Record<string, GraphNodeFactory>;
-			/**
-			 * Called when a tier throws during `load()` or when
-			 * {@link Graph.fromSnapshot} rejects a tier's record. The cascade
-			 * falls through to the next colder tier regardless.
-			 */
-			onError?: (err: unknown, tier: SnapshotStorageTier<GraphCheckpointRecord>) => void;
-		},
-	): Promise<Graph> {
-		for (const tier of tiers) {
-			let raw: unknown;
-			try {
-				raw = await tier.load?.();
-			} catch (err) {
-				opts?.onError?.(err, tier);
-				continue;
-			}
-			if (raw == null) continue;
-			if (typeof raw !== "object" || Array.isArray(raw)) continue;
-			const record = raw as Record<string, unknown>;
-			const snapshot: GraphPersistSnapshot | undefined =
-				record.mode === "full" && record.snapshot != null
-					? (record.snapshot as GraphPersistSnapshot)
-					: record.version === SNAPSHOT_VERSION && record.nodes != null
-						? (record as GraphPersistSnapshot)
-						: undefined;
-			if (snapshot == null) continue;
-			try {
-				return Graph.fromSnapshot(snapshot, opts);
-			} catch (err) {
-				opts?.onError?.(err, tier);
-				// Fall through to colder tier.
-			}
-		}
-		throw new Error(
-			`Graph.fromStorage: no tier held a restorable record for "${name}" across ${tiers.length} tier(s)`,
-		);
-	}
-
-	// ——————————————————————————————————————————————————————————————
-	//  Inspector (roadmap 3.3) — reasoning trace, overhead gating
-	// ——————————————————————————————————————————————————————————————
-
-	// Inspector gating lives on `this.config.inspectorEnabled` (see
-	// `core/config.ts`). Default: `true` outside `NODE_ENV === "production"`.
-
-	private _annotations = new Map<string, string>();
-	private readonly _traceRing: RingBuffer<TraceEntry>;
-
-	/**
-	 * Unified reasoning trace: write annotations or read the ring buffer.
-	 *
-	 * - `graph.trace("path", "annotation")` — attaches a reasoning annotation
-	 *   to a node, capturing *why* an AI agent set a value. Overwrites the
-	 *   current annotation (if any) and appends to the chronological ring.
-	 *   Unknown paths are silently dropped (matching `observe` resilience).
-	 *   No-op when `config.inspectorEnabled` is `false`.
-	 * - `graph.trace("path")` — returns the current annotation for `path`,
-	 *   or `undefined` if none. Precedence: most recent `trace(path, ...)`
-	 *   wins; if no trace call, whatever `graph.add(node, { name: "path", annotation })`
-	 *   installed; otherwise `undefined`.
-	 * - `graph.trace()` — returns a chronological log of all write entries.
-	 *   Returns `[]` when `config.inspectorEnabled` is `false`.
-	 */
-	trace(path: string, annotation: string, opts?: { actor?: Actor }): void;
-	trace(path: string): string | undefined;
-	trace(): readonly TraceEntry[];
-	trace(
-		path?: string,
-		annotation?: string,
-		opts?: { actor?: Actor },
-	): string | undefined | readonly TraceEntry[] {
-		// Write: (path, annotation[, opts])
-		// Write: (path, annotation[, opts])
-		if (path != null && annotation != null) {
-			// Silent-drop unknown paths — matches `observe` resilience. Callers
-			// with robust path-hygiene needs can pre-check via `tryResolve`.
-			if (this.tryResolve(path) == null) return;
-			// The `_annotations` map is always kept current so reads don't
-			// lose annotations installed before the inspector flag flipped.
-			// Only the chronological ring-buffer push is gated on inspector.
-			this._annotations.set(path, annotation);
-			if (this.config.inspectorEnabled) {
-				const entry: TraceEntry = {
-					path,
-					annotation,
-					timestamp_ns: monotonicNs(),
-					...(opts?.actor != null ? { actor: opts.actor } : {}),
-				};
-				this._traceRing.push(entry);
-			}
-			return;
-		}
-		// Read single: (path). Symmetric with read-all — short-circuit when
-		// inspector is disabled so callers treat both overloads identically.
-		if (path != null) {
-			if (!this.config.inspectorEnabled) return undefined;
-			return this._annotations.get(path);
-		}
-		// Read all: ()
-		if (!this.config.inspectorEnabled) return [];
-		return this._traceRing.toArray();
-	}
-
-	/**
-	 * Latest annotation attached to `path` — via {@link Graph.trace} or via
-	 * {@link Graph.add}'s `{annotation}` option. Returns `undefined` if none.
-	 * `describe()` surfaces this via the `annotation` field on each node entry
-	 * (when present). Equivalent to `graph.trace(path)`.
-	 */
-	annotation(path: string): string | undefined {
-		return this._annotations.get(path);
-	}
-
-	/**
-	 * Clear all reasoning-trace state (both the per-path annotations map and
-	 * the ring buffer). Useful for long-running processes that want periodic
-	 * resets, or tests that need a clean slate.
-	 */
-	clearTrace(): void {
-		this._annotations.clear();
-		this._traceRing.clear();
-	}
-
-	/**
-	 * Remove trace entries matching `predicate`. Returns the number of
-	 * entries removed. Does not touch the per-path annotations map — call
-	 * {@link Graph.clearTrace} for a full reset.
-	 */
-	pruneTrace(predicate: (entry: TraceEntry) => boolean): number {
-		const kept = this._traceRing.toArray().filter((e) => !predicate(e));
-		const removed = this._traceRing.size - kept.length;
-		this._traceRing.clear();
-		for (const e of kept) this._traceRing.push(e);
-		return removed;
-	}
-
-	/**
-	 * Computes structural + value diff between two {@link Graph.describe} snapshots.
-	 *
-	 * @param a - Earlier describe output.
-	 * @param b - Later describe output.
-	 * @returns Added/removed nodes, changed fields, and edge deltas.
-	 */
-	static diff(a: GraphDescribeOutput, b: GraphDescribeOutput): GraphDiffResult {
-		const aKeys = new Set(Object.keys(a.nodes));
-		const bKeys = new Set(Object.keys(b.nodes));
-
-		const nodesAdded = [...bKeys].filter((k) => !aKeys.has(k)).sort();
-		const nodesRemoved = [...aKeys].filter((k) => !bKeys.has(k)).sort();
-		const nodesChanged: GraphDiffChange[] = [];
-		const versionChanges: GraphVersionChange[] = [];
-
-		for (const key of aKeys) {
-			if (!bKeys.has(key)) continue;
-			const na = a.nodes[key];
-			const nb = b.nodes[key];
-			const av = na.v;
-			const bv = nb.v;
-			// Surface version bumps (even if value is identical, the bump itself
-			// is meaningful for audit / wire-efficient sync).
-			if (av != null && bv != null && av.id === bv.id && av.version !== bv.version) {
-				versionChanges.push({
-					path: key,
-					id: av.id,
-					from: av.version,
-					to: bv.version,
-				});
-			}
-			const versionMatches =
-				av != null && bv != null && av.id === bv.id && av.version === bv.version;
-			// V0 fast path: when versions match, skip value / meta compare —
-			// upstream is guaranteed unchanged by protocol. Only type/status
-			// (cheap string compare) + sentinel flip are possible.
-			for (const field of ["type", "status", "sentinel"] as const) {
-				const va = (na as Record<string, unknown>)[field];
-				const vb = (nb as Record<string, unknown>)[field];
-				if (va !== vb) {
-					nodesChanged.push({ path: key, field, from: va, to: vb });
-				}
-			}
-			if (versionMatches) continue;
-			// Full slow-path: deep-equal on value + meta.
-			for (const field of ["value", "meta"] as const) {
-				const va = (na as Record<string, unknown>)[field];
-				const vb = (nb as Record<string, unknown>)[field];
-				if (!deepEqual(va, vb)) {
-					nodesChanged.push({ path: key, field, from: va, to: vb });
-				}
-			}
-		}
-
-		const edgeKey = (e: { from: string; to: string }) => `${e.from}\t${e.to}`;
-		const aEdges = new Set(a.edges.map(edgeKey));
-		const bEdges = new Set(b.edges.map(edgeKey));
-
-		const edgesAdded = b.edges.filter((e) => !aEdges.has(edgeKey(e)));
-		const edgesRemoved = a.edges.filter((e) => !bEdges.has(edgeKey(e)));
-		const aSubgraphs = new Set(a.subgraphs);
-		const bSubgraphs = new Set(b.subgraphs);
-		const subgraphsAdded = [...bSubgraphs].filter((s) => !aSubgraphs.has(s)).sort();
-		const subgraphsRemoved = [...aSubgraphs].filter((s) => !bSubgraphs.has(s)).sort();
-
-		return {
-			nodesAdded,
-			nodesRemoved,
-			nodesChanged,
-			versionChanges,
-			edgesAdded,
-			edgesRemoved,
-			subgraphsAdded,
-			subgraphsRemoved,
-		};
-	}
-}
-
-/** Entry in the reasoning trace ring buffer (roadmap 3.3). */
-export type TraceEntry = {
-	path: string;
-	annotation: string;
-	timestamp_ns: number;
-	/**
-	 * Actor that produced the annotation (optional). Enables multi-agent
-	 * attribution: distinguish "LLM set this rootCause" from "human approved
-	 * this intervention" in the trace log.
-	 */
-	actor?: Actor;
-};
-
-/** Result of {@link Graph.diff}. */
-export type GraphDiffResult = {
-	nodesAdded: string[];
-	nodesRemoved: string[];
-	nodesChanged: GraphDiffChange[];
-	/**
-	 * V0 version bumps (same `v.id`, different `v.version`). Surfaced even
-	 * when values are identical — the bump itself is audit-meaningful.
-	 */
-	versionChanges: GraphVersionChange[];
-	edgesAdded: Array<{ from: string; to: string }>;
-	edgesRemoved: Array<{ from: string; to: string }>;
-	subgraphsAdded: string[];
-	subgraphsRemoved: string[];
-};
-
-/**
- * WAL-oriented diff — extends {@link GraphDiffResult} with the full node
- * slice for each added path so {@link replayWAL} can reconstruct nodes added
- * between full anchors (topology mutations inside a `compactEvery` window).
- *
- * `Graph.diff()` returns the audit shape (no payload); `attachSnapshotStorage` writes
- * this WAL shape. The two shapes stay structurally compatible — `GraphWALDiff`
- * is a superset.
- */
-export type GraphWALDiff = GraphDiffResult & {
-	/**
-	 * Full node slices for every path in `nodesAdded`, keyed by path. Applied
-	 * verbatim to `snapshot.nodes[path]` during replay.
-	 */
-	nodesAddedFull: Record<string, DescribeNodeOutput>;
-};
-
-/**
- * Build a WAL-ready diff between two snapshots: the structural diff from
- * {@link Graph.diff} plus the full node slice for each added path (pulled
- * from `b.nodes`). Callers that only need the audit shape should use
- * `Graph.diff` directly.
- */
-export function diffForWAL(a: GraphDescribeOutput, b: GraphDescribeOutput): GraphWALDiff {
-	const base = Graph.diff(a, b);
-	const nodesAddedFull: Record<string, DescribeNodeOutput> = {};
-	for (const path of base.nodesAdded) {
-		const slice = b.nodes[path];
-		if (slice != null) nodesAddedFull[path] = slice;
-	}
-	return { ...base, nodesAddedFull };
-}
-
-/**
- * One element of {@link decomposeDiffToFrames}'s output: the bridge-shape
- * subset of a {@link WALFrame} (Phase 14.6 — DS-14-storage Q2 lock A).
- *
- * Drops `frame_seq` / `frame_t_ns` / `checksum` — those are filled in by
- * the WAL writer at write time so a single decomposition can be checksummed
- * with the wall clock at flush time.
- */
-type DecomposedFrame =
-	| {
-			readonly lifecycle: "spec";
-			readonly path: string;
-			readonly change: SpecChange;
-	  }
-	| {
-			readonly lifecycle: "data";
-			readonly path: string;
-			readonly change: GraphValueChange;
-	  };
-
-/**
- * Decompose a {@link GraphWALDiff} into one DS-14 `BaseChange<T>`-wrapped
- * frame per discrete change (Phase 14.6 — DS-14-storage Q2 lock A). The WAL
- * writer fills `frame_seq` + `frame_t_ns` + `checksum` per element at write
- * time.
- *
- * Lifecycle scoping (DS-14 PART 4):
- * - Topology mutations (`nodesAdded` / `nodesRemoved` / `subgraphsAdded` /
- *   `subgraphsRemoved`) → `"spec"`
- * - Value drift (`nodesChanged` field=`value`, `versionChanges`) → `"data"`
- *
- * `edgesAdded` / `edgesRemoved` are intentionally NOT decomposed — edges
- * follow structurally from node `_deps`; the rewire path emits topology
- * changes via Phase 13.8's `_rewire` audit which is `@experimental` and
- * deferred to a follow-up frame kind.
- */
-function decomposeDiffToFrames(
-	diff: GraphWALDiff,
-	timestamp_ns: number,
-): readonly DecomposedFrame[] {
-	const frames: DecomposedFrame[] = [];
-	const wrap = <T>(structure: string, lifecycle: "spec" | "data", payload: T) => ({
-		structure,
-		version: SNAPSHOT_VERSION,
-		t_ns: timestamp_ns,
-		lifecycle,
-		change: payload,
-	});
-
-	for (const nodeId of diff.nodesAdded) {
-		const slice = diff.nodesAddedFull[nodeId];
-		const payload: SpecChangePayload =
-			slice != null ? { kind: "graph.add", nodeId, slice } : { kind: "graph.add", nodeId };
-		frames.push({
-			lifecycle: "spec",
-			path: nodeId,
-			change: wrap("graph.spec", "spec", payload) as SpecChange,
-		});
-	}
-	for (const nodeId of diff.nodesRemoved) {
-		const payload: SpecChangePayload = { kind: "graph.remove", nodeId };
-		frames.push({
-			lifecycle: "spec",
-			path: nodeId,
-			change: wrap("graph.spec", "spec", payload) as SpecChange,
-		});
-	}
-	for (const path of diff.subgraphsAdded) {
-		// Subgraph identity is not retrievable from the diff alone — we emit
-		// a placeholder `subgraphId` so replay can opt-in to a factories map
-		// keyed by `path`. Tracked as a Phase 14.6+ follow-up.
-		const payload: SpecChangePayload = { kind: "graph.mount", path, subgraphId: path };
-		frames.push({
-			lifecycle: "spec",
-			path,
-			change: wrap("graph.spec", "spec", payload) as SpecChange,
-		});
-	}
-	for (const path of diff.subgraphsRemoved) {
-		const payload: SpecChangePayload = { kind: "graph.unmount", path };
-		frames.push({
-			lifecycle: "spec",
-			path,
-			change: wrap("graph.spec", "spec", payload) as SpecChange,
-		});
-	}
-	for (const change of diff.nodesChanged) {
-		// Only `field === "value"` round-trips through replay (other field
-		// drift like `meta.tag` mutations decomposes via separate frames in
-		// the meta sub-namespace, which Phase 14.6 doesn't cover yet). Skip.
-		if (change.field !== "value") continue;
-		// INVALIDATE persistence (Q7 §8.7.6): a transition to `undefined`
-		// (the global SENTINEL per spec §2.5) is INVALIDATE on the wire,
-		// not a `node.set(undefined)`. Emit a dedicated invalidate frame so
-		// replay restores the SENTINEL slot with `graph.invalidate(path)`.
-		const payload: GraphValueChangePayload =
-			change.to === undefined
-				? { kind: "node.invalidate", path: change.path }
-				: { kind: "node.set", path: change.path, value: change.to };
-		frames.push({
-			lifecycle: "data",
-			path: change.path,
-			change: wrap("graph.value", "data", payload) as GraphValueChange,
-		});
-	}
-	for (const v of diff.versionChanges) {
-		const payload: GraphValueChangePayload = {
-			kind: "node.versionBump",
-			path: v.path,
-			id: v.id,
-			version: v.to,
-		};
-		frames.push({
-			lifecycle: "data",
-			path: v.path,
-			change: wrap("graph.value", "data", payload) as GraphValueChange,
-		});
-	}
-	return frames;
-}
-
-/**
- * Module-local predicate: does `graph` carry a registered local NODE with
- * `name`? Used by `applyWalFrame`'s `graph.mount` arm to keep the apply
- * best-effort when a frame would otherwise collide with an existing node
- * slot (cf. F1 / B4-QA). `Graph._nodes` is `private` so the type cast is
- * required; access pattern mirrors the existing module-local idiom inside
- * `Graph.fromSnapshot` (target._nodes / target._mounts walks). Kept narrow
- * (predicate-only) so the public surface still routes through
- * {@link Graph.hasMount} / {@link Graph.getMount}.
- */
-function _hasLocalNode(graph: Graph, name: string): boolean {
-	return (graph as unknown as { _nodes: Map<string, unknown> })._nodes.has(name);
-}
-
-/**
- * Apply a single {@link WALFrame} onto a {@link Graph} (Phase 14.6 —
- * DS-14-storage Q9 replay path). Best-effort within the lifecycle: kinds
- * that still need additional context (factories for non-state nodes) are
- * silently skipped — callers that need full-fidelity spec replay should
- * hydrate via {@link Graph.fromSnapshot} + factories before invoking
- * `restoreSnapshot`. `graph.mount` / `graph.unmount` are applied
- * idempotently against the existing mount tree (B4 / D275, 2026-05-22 —
- * mirrors graphrefly-rs `apply_wal_frame`).
- *
- * @internal
- */
-function applyWalFrame(graph: Graph, frame: WALFrame): void {
-	const envelope = frame.change as unknown;
-	if (envelope == null || typeof envelope !== "object") return;
-	const inner = (envelope as { change?: unknown }).change;
-	if (inner == null || typeof inner !== "object") return;
-	const payload = inner as { kind?: string };
-
-	if (frame.lifecycle === "spec") {
-		switch (payload.kind) {
-			case "graph.add": {
-				const p = payload as SpecChangePayload & { kind: "graph.add" };
-				if (graph.tryResolve(p.nodeId) != null) return; // already present
-				const slice = p.slice;
-				if (slice == null || slice.type !== "state") return; // skip non-state for now
-				const initial = "value" in slice ? (slice as { value: unknown }).value : undefined;
-				const n = node([], { initial, name: p.nodeId });
-				graph.add(n, { name: p.nodeId });
-				return;
-			}
-			case "graph.remove": {
-				const p = payload as SpecChangePayload & { kind: "graph.remove" };
-				if (graph.tryResolve(p.nodeId) != null) graph.remove(p.nodeId);
-				return;
-			}
-			case "graph.mount": {
-				// Mirrors Rust D275 (graphrefly-rs `apply_wal_frame` `Lifecycle::Spec`
-				// → `"graph.mount"` arm). Path is the qualified mount path from the
-				// snapshotted graph's root; walk down auto-creating missing
-				// intermediate mounts so out-of-order frames still converge. At
-				// each segment: skip if already mounted (idempotent — Rust's
-				// `child_names()` guard); skip if a NODE already owns the slot
-				// (best-effort — `Graph.mount` would throw on the node collision
-				// and abort the whole spec phase; QA F1 lock 2026-05-22).
-				const p = payload as SpecChangePayload & { kind: "graph.mount" };
-				const segments = p.path.split(PATH_SEP);
-				if (segments.length === 0 || segments.some((s) => s.length === 0)) return;
-				let owner: Graph = graph;
-				for (let i = 0; i < segments.length; i++) {
-					const seg = segments[i] as string;
-					const existing = owner.getMount(seg);
-					if (existing != null) {
-						owner = existing;
-						continue;
-					}
-					if (_hasLocalNode(owner, seg)) return; // QA F1: best-effort skip
-					owner.mount(seg);
-					owner = owner.getMount(seg) as Graph;
-				}
-				return;
-			}
-			case "graph.unmount": {
-				// Mirrors Rust D275 — `Graph.remove(name)` handles unmount for a
-				// subgraph leaf. Idempotent skip if path is absent, intermediate
-				// parent is missing, or the leaf is a node rather than a mount.
-				const p = payload as SpecChangePayload & { kind: "graph.unmount" };
-				const segments = p.path.split(PATH_SEP);
-				if (segments.length === 0 || segments.some((s) => s.length === 0)) return;
-				const leaf = segments.pop() as string;
-				let owner: Graph = graph;
-				for (const seg of segments) {
-					const next = owner.getMount(seg);
-					if (next == null) return; // intermediate parent absent → nothing to unmount
-					owner = next;
-				}
-				if (owner.hasMount(leaf)) owner.remove(leaf);
-				return;
-			}
-			// schema.upgrade — Phase 14.6+ deferred
-			default:
-				return;
-		}
-	}
-
-	if (frame.lifecycle === "data") {
-		switch (payload.kind) {
-			case "node.set": {
-				const p = payload as GraphValueChangePayload & { kind: "node.set" };
-				if (graph.tryResolve(p.path) != null) graph.set(p.path, p.value);
-				return;
-			}
-			case "node.invalidate": {
-				const p = payload as GraphValueChangePayload & { kind: "node.invalidate" };
-				if (graph.tryResolve(p.path) != null) graph.invalidate(p.path);
-				return;
-			}
-			// node.versionBump — V0 versioning is internal; replay deferred
-			default:
-				return;
-		}
-	}
-
-	// ownership lifecycle — Phase 13 ownership-bundle work; out of scope here
-}
-
-/** A single field change within a diff. */
-export type GraphDiffChange = {
-	path: string;
-	field: string;
-	from: unknown;
-	to: unknown;
-};
-
-/** A single V0 version bump within a diff. */
-export type GraphVersionChange = {
-	path: string;
-	id: string;
-	from: number;
-	to: number;
-};
-
-/** Audit record returned by {@link Graph.remove}. */
-export type GraphRemoveAudit = {
-	/** Whether the removed entry was a local node or a mount. */
-	kind: "node" | "mount";
-	/**
-	 * Primary nodes torn down by this `remove()`. For `kind: "node"` contains
-	 * just the removed name; for `kind: "mount"` lists every primary node in
-	 * the unmounted subtree (qualified paths relative to the mount point,
-	 * sorted).
-	 */
-	nodes: string[];
-	/**
-	 * Mounted subgraphs that were unmounted. For `kind: "node"` this is empty;
-	 * for `kind: "mount"` starts with the top-level mount name and lists its
-	 * descendants in depth-first order.
-	 */
-	mounts: string[];
-};
-
-/**
- * @experimental Phase 13.8 — Audit record returned by {@link Graph._rewire}.
- *
- * Reports the dep set diff. `name` is the resolved qualified path of the
- * rewired node. `removed` / `added` / `kept` are sorted lists of dep
- * descriptors (qualified path when the dep was registered on `this` graph
- * or a reachable mount; `<unregistered>` when the dep is a foreign Node
- * not owned by the graph).
- */
-export type GraphRewireAudit = {
-	name: string;
-	removed: string[];
-	added: string[];
-	kept: string[];
-};
-
-/** Direction for {@link reachable} graph traversal. */
-export type ReachableDirection = "upstream" | "downstream";
-
-/** Options for {@link reachable}. */
-export type ReachableOptions = {
-	/** Maximum hop depth from `from` (0 returns `[]`). Omit for unbounded traversal. */
-	maxDepth?: number;
-	/**
-	 * Traverse both directions in one pass (union of upstream + downstream).
-	 * Ignores the `direction` arg when set.
-	 */
-	both?: boolean;
-	/**
-	 * Return the richer {@link ReachableResult} shape (paths + per-path
-	 * hop depth + truncation flag) instead of the flat sorted string array.
-	 */
-	withDetail?: boolean;
-};
-
-/** Rich reachable result (opt-in via `{withDetail: true}`). */
-export type ReachableResult = {
-	/** Reachable paths, sorted lexicographically. */
-	paths: string[];
-	/** Hop depth from `from` to each reachable path. */
-	depths: Map<string, number>;
-	/** True when traversal hit `maxDepth` and some neighbors were not explored. */
-	truncated: boolean;
-};
-
-/**
- * Reachability query over a {@link Graph.describe} snapshot.
- *
- * Traversal follows `deps` (upstream) and reverse-`deps` (downstream). Edges
- * are derived from deps post Unit 7, so `edges[]` in the snapshot is
- * redundant with deps — it's walked defensively in case a caller supplied a
- * pre-Unit-7 snapshot.
- *
- * @param described - `graph.describe()` output to traverse.
- * @param from - Start path (qualified node path).
- * @param direction - Traversal direction (ignored when `opts.both` is `true`).
- * @param options - Optional `maxDepth`, `both`, `withDetail`.
- * @returns Sorted paths (flat) — or {@link ReachableResult} when `withDetail: true`.
- */
-export function reachable(
-	described: GraphDescribeOutput,
-	from: string,
-	direction: ReachableDirection,
-	options?: ReachableOptions & { withDetail: true },
-): ReachableResult;
-export function reachable(
-	described: GraphDescribeOutput,
-	from: string,
-	direction: ReachableDirection,
-	options?: ReachableOptions,
-): string[];
-export function reachable(
-	described: GraphDescribeOutput,
-	from: string,
-	direction: ReachableDirection,
-	options: ReachableOptions = {},
-): string[] | ReachableResult {
-	const empty: ReachableResult = { paths: [], depths: new Map(), truncated: false };
-	if (!from) return options.withDetail ? empty : [];
-	if (!options.both && direction !== "upstream" && direction !== "downstream") {
-		throw new Error(`reachable: direction must be "upstream" or "downstream"`);
-	}
-	const maxDepth = options.maxDepth;
-	if (maxDepth != null && (!Number.isInteger(maxDepth) || maxDepth < 0)) {
-		throw new Error(`reachable: maxDepth must be an integer >= 0`);
-	}
-	if (maxDepth === 0) return options.withDetail ? empty : [];
-
-	const depsByPath = new Map<string, readonly string[]>();
-	const reverseDeps = new Map<string, Set<string>>();
-	const incomingEdges = new Map<string, Set<string>>();
-	const outgoingEdges = new Map<string, Set<string>>();
-	const universe = new Set<string>();
-
-	for (const [path, node] of Object.entries(described.nodes)) {
-		if (!path) continue;
-		universe.add(path);
-		const deps = node.deps ?? [];
-		depsByPath.set(path, deps);
-		for (const dep of deps) {
-			if (!dep) continue;
-			universe.add(dep);
-			if (!reverseDeps.has(dep)) reverseDeps.set(dep, new Set());
-			reverseDeps.get(dep)!.add(path);
-		}
-	}
-	// Edges are normally derived from deps post Unit 7, but synthetic snapshots
-	// (e.g. test fixtures) may declare edges independently — walk both for
-	// compatibility. Minimal null/string checks for malformed JSON.
-	for (const edge of described.edges) {
-		if (edge == null || typeof edge !== "object") continue;
-		const from = typeof edge.from === "string" ? edge.from : "";
-		const to = typeof edge.to === "string" ? edge.to : "";
-		if (!from || !to) continue;
-		universe.add(from);
-		universe.add(to);
-		if (!outgoingEdges.has(from)) outgoingEdges.set(from, new Set());
-		outgoingEdges.get(from)!.add(to);
-		if (!incomingEdges.has(to)) incomingEdges.set(to, new Set());
-		incomingEdges.get(to)!.add(from);
-	}
-
-	if (!universe.has(from)) return options.withDetail ? empty : [];
-
-	const doBoth = options.both === true;
-	const visit = (path: string): readonly string[] => {
-		if (doBoth) {
-			const up = depsByPath.get(path) ?? [];
-			const upEdges = incomingEdges.get(path);
-			const down = reverseDeps.get(path);
-			const downEdges = outgoingEdges.get(path);
-			const acc: string[] = [...up];
-			if (upEdges) acc.push(...upEdges);
-			if (down) acc.push(...down);
-			if (downEdges) acc.push(...downEdges);
-			return acc;
-		}
-		if (direction === "upstream") {
-			const up = depsByPath.get(path) ?? [];
-			const upEdges = incomingEdges.get(path);
-			if (!upEdges) return up;
-			return [...up, ...upEdges];
-		}
-		const down = reverseDeps.get(path);
-		const downEdges = outgoingEdges.get(path);
-		const acc: string[] = down ? [...down] : [];
-		if (downEdges) acc.push(...downEdges);
-		return acc;
-	};
-
-	// Head-index BFS — avoids O(n²) from `Array.prototype.shift`.
-	const visited = new Set<string>([from]);
-	const depths = new Map<string, number>();
-	const queue: Array<{ path: string; depth: number }> = [{ path: from, depth: 0 }];
-	let head = 0;
-	let truncated = false;
-	while (head < queue.length) {
-		const next = queue[head++]!;
-		if (maxDepth != null && next.depth >= maxDepth) {
-			// Flag truncation only if this node actually has unexplored neighbors.
-			if (visit(next.path).length > 0) truncated = true;
-			continue;
-		}
-		for (const nb of visit(next.path)) {
-			if (!nb || visited.has(nb)) continue;
-			visited.add(nb);
-			depths.set(nb, next.depth + 1);
-			queue.push({ path: nb, depth: next.depth + 1 });
-		}
-	}
-
-	const paths = [...depths.keys()].sort((a, b) => (a < b ? -1 : a > b ? 1 : 0));
-	if (options.withDetail) return { paths, depths, truncated };
-	return paths;
-}
-
-/**
- * Structural equals for a causal-chain step sequence, used by
- * `describe({ explain })` in reactive mode to suppress RESOLVED re-emits when
- * the chain is unchanged between observe events.
- */
-function causalStepsEqual(a: readonly CausalStep[], b: readonly CausalStep[]): boolean {
-	if (a.length !== b.length) return false;
-	for (let i = 0; i < a.length; i++) {
-		const x = a[i]!;
-		const y = b[i]!;
-		if (x.path !== y.path) return false;
-		if (x.type !== y.type) return false;
-		if (x.status !== y.status) return false;
-		if (x.hop !== y.hop) return false;
-		if (x.dep_index !== y.dep_index) return false;
-		if (x.annotation !== y.annotation) return false;
-		// Value identity — derived snapshots reuse same refs unless changed.
-		if (x.value !== y.value) return false;
-		// `lastMutation` is replaced on every write, so identity compare is sufficient.
-		if (x.lastMutation !== y.lastMutation) return false;
-		const xv = x.v;
-		const yv = y.v;
-		if (xv !== yv) {
-			if (xv == null || yv == null) return false;
-			if (xv.id !== yv.id || xv.version !== yv.version) return false;
-		}
-	}
-	return true;
-}
diff --git a/packages/pure-ts/src/graph/index.ts b/packages/pure-ts/src/graph/index.ts
deleted file mode 100644
index bf7e04a0..00000000
--- a/packages/pure-ts/src/graph/index.ts
+++ /dev/null
@@ -1,111 +0,0 @@
-/**
- * Graph container: registry, wiring, introspection (Phase 1).
- */
-
-export { OVERHEAD as SIZEOF_OVERHEAD, SIZEOF_SYMBOL, sizeof } from "../core/_internal/sizeof.js";
-export type {
-	GraphChange,
-	GraphChangeBatchEnd,
-	GraphChangeBatchStart,
-	GraphChangeComplete,
-	GraphChangeData,
-	GraphChangeDirty,
-	GraphChangeEnvelope,
-	GraphChangeError,
-	GraphChangeInvalidate,
-	GraphChangeMount,
-	GraphChangeNodeAdded,
-	GraphChangeNodeRemoved,
-	GraphChangePause,
-	GraphChangeReserved,
-	GraphChangeResolved,
-	GraphChangeResubscribe,
-	GraphChangeResume,
-	GraphChangeSnapshot,
-	GraphChangeTeardown,
-	GraphChangeTrace,
-	GraphChangeType,
-	GraphChangeUnmount,
-} from "./changeset.js";
-export {
-	createDagCborCodec,
-	createDagCborZstdCodec,
-	decodeEnvelope,
-	ENVELOPE_VERSION,
-	type EvictedSubgraphInfo,
-	type EvictionPolicy,
-	encodeEnvelope,
-	type GraphCodec,
-	JsonCodec,
-	type LazyGraphCodec,
-	registerBuiltinCodecs,
-	replayWAL,
-	type WALEntry,
-} from "./codec.js";
-export {
-	type CausalChain,
-	type CausalStep,
-	type ExplainPathOptions,
-	explainPath,
-} from "./explain.js";
-export {
-	type DescribeFilter,
-	diffForWAL,
-	type FnCtxDerived,
-	type FnCtxEffect,
-	type FnCtxProducer,
-	GRAPH_META_SEGMENT,
-	Graph,
-	type GraphActorOptions,
-	type GraphAttachStorageOptions,
-	type GraphCheckpointRecord,
-	type GraphDerivedFn,
-	type GraphDerivedOptions,
-	type GraphDescribeOptions,
-	type GraphDescribeOutput,
-	type GraphDiagramDirection,
-	type GraphDiffChange,
-	type GraphDiffResult,
-	type GraphEffectFn,
-	type GraphEffectOptions,
-	type GraphFactoryContext,
-	type GraphNodeFactory,
-	type GraphObserveAll,
-	type GraphObserveOne,
-	type GraphOptions,
-	type GraphPersistSnapshot,
-	type GraphProducerOptions,
-	type GraphProducerSetupFn,
-	type GraphStateOptions,
-	type GraphVersionChange,
-	type GraphWALDiff,
-	type NodeUpActions,
-	type ObserveChangeset,
-	type ObserveDetail,
-	type ObserveEvent,
-	type ObserveOptions,
-	type ObserveResult,
-	type ObserveTheme,
-	type ObserveThemeName,
-	type ObserveTier,
-	type ReachableDirection,
-	type ReachableOptions,
-	reachable,
-	SNAPSHOT_VERSION,
-	type TopologyEvent,
-	type TraceEntry,
-} from "./graph.js";
-export {
-	type GraphProfileOptions,
-	type GraphProfileResult,
-	graphProfile,
-	type NodeProfile,
-} from "./profile.js";
-export { watchTopologyTree } from "./topology-tree.js";
-export {
-	type IslandReport,
-	type ValidateNoIslandsResult,
-	validateNoIslands,
-} from "./validate-no-islands.js";
-// validateGraphObservability moved to root src/base/validate-observability.ts (cleave A2)
-// It depends on render (presentation layer) so it cannot live in the substrate.
diff --git a/packages/pure-ts/src/graph/profile.ts b/packages/pure-ts/src/graph/profile.ts
deleted file mode 100644
index 528cb174..00000000
--- a/packages/pure-ts/src/graph/profile.ts
+++ /dev/null
@@ -1,177 +0,0 @@
-/**
- * Graph profiling and inspection utilities.
- *
- * Provides per-node memory estimation, connectivity stats, and hotspot
- * detection. Non-invasive — reads from `describe()` and node internals
- * without modifying state.
- *
- * @module
- */
-
-import { sizeof } from "../core/_internal/sizeof.js";
-import { type Node, NodeImpl } from "../core/node.js";
-import type { Graph, GraphDescribeOutput } from "./graph.js";
-
-// ---------------------------------------------------------------------------
-// Types
-// ---------------------------------------------------------------------------
-
-/** Per-node profile entry. */
-export interface NodeProfile {
-	/** Qualified path within the graph. */
-	path: string;
-	/** Node type (state, derived, producer, effect). */
-	type: string;
-	/** Node status (disconnected, dirty, settled, errored, completed). */
-	status: string;
-	/** Approximate retained bytes for the node's cached value. */
-	valueSizeBytes: number;
-	/** Number of downstream subscribers (sinks). */
-	subscriberCount: number;
-	/** Number of upstream dependencies. */
-	depCount: number;
-	/**
-	 * True if this is an effect node with no external subscribers — a classic
-	 * leak pattern. See {@link GraphProfileResult.orphans} for the broader
-	 * orphan-node detection across `derived` / `producer` / `effect`.
-	 */
-	isOrphanEffect: boolean;
-	/**
-	 * Orphan category (batch 8 Unit 13 D). `null` when the node is healthy.
-	 * - `"orphan-effect"` — effect with zero subscribers (pre-existing class).
-	 * - `"idle-derived"` — derived with zero subscribers (wasted compute path
-	 *   if it ever activates; may indicate a factory forgot keepalive).
-	 * - `"idle-producer"` — producer with zero subscribers (no external
-	 *   consumer; may be an over-eager factory or forgotten cleanup).
-	 */
-	orphanKind: "orphan-effect" | "idle-derived" | "idle-producer" | null;
-}
-
-/** Aggregate graph profile. */
-export interface GraphProfileResult {
-	/** Total node count. */
-	nodeCount: number;
-	/** Total edge count. */
-	edgeCount: number;
-	/** Subgraph count. */
-	subgraphCount: number;
-	/** All node profiles. */
-	nodes: NodeProfile[];
-	/** Total approximate value memory across all nodes. */
-	totalValueSizeBytes: number;
-	/**
-	 * Top-N hotspots by dimension. Each list is sorted descending. See
-	 * {@link GraphProfileOptions.topN} for the cap (default 10).
-	 */
-	hotspots: {
-		byValueSize: NodeProfile[];
-		bySubscriberCount: NodeProfile[];
-		byDepCount: NodeProfile[];
-	};
-	/**
-	 * Every orphan across types — `effect`, `derived`, `producer` with zero
-	 * subscribers. See {@link NodeProfile.orphanKind} for category.
-	 */
-	orphans: NodeProfile[];
-	/** Effect nodes with no external subscribers (legacy; subset of `orphans`). */
-	orphanEffects: NodeProfile[];
-}
-
-/** Options for {@link graphProfile}. */
-export interface GraphProfileOptions {
-	/** Limit hotspot list (default 10). */
-	topN?: number;
-}
-
-// ---------------------------------------------------------------------------
-// Implementation
-// ---------------------------------------------------------------------------
-
-/**
- * Profile a graph's memory and connectivity characteristics.
- *
- * Uses `describe({ detail: "standard" })` for node metadata and direct
- * `NodeImpl` access for subscriber counts and cached values.
- *
- * @param graph - The graph to profile.
- * @param opts - Optional configuration.
- * @returns Aggregate profile with per-node details, hotspots (multi-dim), and orphans.
- */
-export function graphProfile(graph: Graph, opts?: GraphProfileOptions): GraphProfileResult {
-	const topN = opts?.topN ?? 10;
-
-	const desc: GraphDescribeOutput = graph.describe({ detail: "standard" });
-
-	// Build path→Node lookup via _collectObserveTargets (same as describe uses).
-	// Runtime guard: if the internal method is missing (refactored), degrade
-	// gracefully — profiles will show 0 for valueSizeBytes and subscriberCount.
-	const targets: [string, Node][] = [];
-	const collector = (
-		graph as unknown as { _collectObserveTargets?: (prefix: string, out: [string, Node][]) => void }
-	)._collectObserveTargets;
-	if (typeof collector === "function") {
-		collector.call(graph, "", targets);
-	}
-	const pathToNode = new Map<string, Node>();
-	for (const [p, n] of targets) pathToNode.set(p, n);
-
-	const profiles: NodeProfile[] = [];
-
-	for (const [path, nodeDesc] of Object.entries(desc.nodes)) {
-		const nd = pathToNode.get(path);
-		const impl = nd instanceof NodeImpl ? nd : null;
-
-		const valueSizeBytes = impl ? sizeof(impl.cache) : 0;
-		const subscriberCount = impl ? impl._sinkCount : 0;
-		const depCount = nodeDesc.deps?.length ?? 0;
-
-		const isOrphanEffect = nodeDesc.type === "effect" && subscriberCount === 0;
-		const orphanKind: NodeProfile["orphanKind"] =
-			subscriberCount === 0
-				? nodeDesc.type === "effect"
-					? "orphan-effect"
-					: nodeDesc.type === "derived"
-						? "idle-derived"
-						: nodeDesc.type === "producer"
-							? "idle-producer"
-							: null
-				: null;
-
-		profiles.push({
-			path,
-			type: nodeDesc.type,
-			status: nodeDesc.status ?? "unknown",
-			valueSizeBytes,
-			subscriberCount,
-			depCount,
-			isOrphanEffect,
-			orphanKind,
-		});
-	}
-
-	const totalValueSizeBytes = profiles.reduce((sum, p) => sum + p.valueSizeBytes, 0);
-
-	const topBy = <K extends keyof NodeProfile>(
-		key: K,
-		cmp?: (a: NodeProfile, b: NodeProfile) => number,
-	): NodeProfile[] =>
-		[...profiles].sort(cmp ?? ((a, b) => (b[key] as number) - (a[key] as number))).slice(0, topN);
-
-	const orphans = profiles.filter((p) => p.orphanKind != null);
-	const orphanEffects = profiles.filter((p) => p.isOrphanEffect);
-
-	return {
-		nodeCount: profiles.length,
-		edgeCount: desc.edges.length,
-		subgraphCount: desc.subgraphs.length,
-		nodes: profiles,
-		totalValueSizeBytes,
-		hotspots: {
-			byValueSize: topBy("valueSizeBytes"),
-			bySubscriberCount: topBy("subscriberCount"),
-			byDepCount: topBy("depCount"),
-		},
-		orphans,
-		orphanEffects,
-	};
-}
diff --git a/packages/pure-ts/src/graph/topology-tree.ts b/packages/pure-ts/src/graph/topology-tree.ts
deleted file mode 100644
index 57c5a439..00000000
--- a/packages/pure-ts/src/graph/topology-tree.ts
+++ /dev/null
@@ -1,103 +0,0 @@
-/**
- * Transitive structural-change subscription helper.
- *
- * Subscribes to a graph's {@link Graph.topology} event stream AND recurses
- * into every mounted subgraph, auto-wiring new mounts when they appear
- * (via parent `added: mount` events) and tearing down subscriptions for
- * unmounted subgraphs (via `removed: mount` events + the audit record).
- *
- * Lives in `graph/` rather than `patterns/` because it depends only on
- * the `Graph` primitive and the `TopologyEvent` type — no domain-layer
- * factories. Consumers that need full-tree dynamic coverage (e.g.
- * `policyGate`, `graphLens`) import from here to avoid circular
- * references between audit/lens modules.
- *
- * @module
- */
-import { DATA } from "../core/messages.js";
-import type { TopologyEvent } from "./graph.js";
-import { Graph } from "./graph.js";
-
-/**
- * Subscribe to structural changes across `graph` and every transitively
- * mounted subgraph. `cb` fires on every {@link TopologyEvent} from any
- * graph in the tree. Newly-mounted subgraphs are auto-wired when their
- * parent emits `{kind: "added", nodeKind: "mount"}`; newly-unmounted
- * subgraphs' subscriptions are disposed via the parent's
- * `{kind: "removed", nodeKind: "mount"}` event plus the returned
- * `GraphRemoveAudit`.
- *
- * The callback receives a third argument `prefix`: the `::`-delimited
- * path from the root watched graph to the emitter, ending with `"::"`
- * (empty string when the event comes from the root itself). Compute
- * a qualified path for an added/removed entry as `prefix + event.name`.
- *
- * @param graph - Root graph to watch.
- * @param cb - Receives `(event, emitterGraph, prefix)`.
- * @returns Dispose function — tears down every active subscription.
- *
- * @category observability
- */
-export function watchTopologyTree(
-	graph: Graph,
-	cb: (event: TopologyEvent, emitter: Graph, prefix: string) => void,
-): () => void {
-	// Tracks every wired graph with its qualified prefix (path from root).
-	// Prefix is used for both qualified-path emission to `cb` AND prefix-match
-	// disposal when a mount is removed — more robust than relying on
-	// `_parent == null` which only nulls on the direct child, not on
-	// grandchildren within an unmounted subtree.
-	type Entry = { off: () => void; prefix: string };
-	const subs = new Map<Graph, Entry>();
-
-	const wire = (g: Graph, prefix: string): void => {
-		if (subs.has(g)) return;
-		// Placeholder entry set BEFORE subscribe so any synchronous reentry
-		// (e.g. a mount-added handler firing during subscribe's initial push)
-		// sees this graph as already wired and skips rewiring.
-		const placeholder: Entry = { off: () => {}, prefix };
-		subs.set(g, placeholder);
-		const off = g.topology.subscribe((msgs) => {
-			for (const m of msgs) {
-				if (m[0] !== DATA) continue;
-				const event = m[1] as TopologyEvent;
-				cb(event, g, prefix);
-				if (event.kind === "added" && event.nodeKind === "mount") {
-					const child = g._mounts.get(event.name);
-					if (child instanceof Graph) {
-						const childPrefix = `${prefix}${event.name}::`;
-						wire(child, childPrefix);
-					}
-				} else if (event.kind === "removed" && event.nodeKind === "mount") {
-					// Dispose every tracked sub whose prefix is under the removed
-					// mount. Matches on qualified-prefix rather than `_parent`
-					// so deep descendants are released even when their parent
-					// pointers haven't been nulled.
-					const removedPrefix = `${prefix}${event.name}::`;
-					for (const [trackedGraph, trackedEntry] of Array.from(subs.entries())) {
-						if (trackedGraph === graph) continue;
-						if (trackedEntry.prefix.startsWith(removedPrefix)) {
-							trackedEntry.off();
-							subs.delete(trackedGraph);
-						}
-					}
-				}
-			}
-		});
-		placeholder.off = off;
-		// Recursively wire any children already mounted when this call runs.
-		for (const [mountName, child] of g._mounts) {
-			if (child instanceof Graph) {
-				const childPrefix = `${prefix}${mountName}::`;
-				wire(child, childPrefix);
-			}
-		}
-	};
-
-	wire(graph, "");
-
-	return () => {
-		for (const entry of subs.values()) entry.off();
-		subs.clear();
-	};
-}
diff --git a/packages/pure-ts/src/graph/validate-no-islands.ts b/packages/pure-ts/src/graph/validate-no-islands.ts
deleted file mode 100644
index d700dc89..00000000
--- a/packages/pure-ts/src/graph/validate-no-islands.ts
+++ /dev/null
@@ -1,136 +0,0 @@
-/**
- * Topology check: detect "island" nodes with no in-edges AND no out-edges.
- *
- * Companion to {@link validateGraphObservability} for user validation. Catches
- * the kind of disconnected-node smell flagged in the pagerduty-demo audit
- * ("decisions/log not linked to any other nodes", "tokens only by itself") —
- * the visible symptom of imperative writes or closure-held state that bypassed
- * the reactive edge graph.
- *
- * **What counts as an island.** A node is an island when:
- *   - it has zero declared deps (zero **in-edges**), AND
- *   - no other node in the graph declares it as a dep (zero **out-edges**).
- *
- * Source nodes (producers / state nodes that act as roots) typically have zero
- * in-edges but ≥1 out-edge — those are NOT islands. Sink nodes (effects that
- * terminate a chain) have ≥1 in-edge but zero out-edges — also NOT islands.
- * Only nodes that satisfy BOTH conditions are reported.
- *
- * **Sub-graph paths.** When the graph mounts subgraphs, the check walks the
- * full path-qualified node table from `graph.describe({ detail: "minimal" })`
- * — both top-level and mounted children participate.
- *
- * **False-positive caveat (D7 /qa lock).** A `state(0, { name: "metric" })`
- * whose only consumer is an external (non-graph) subscriber — e.g. a React /
- * Vue / CLI subscription that calls `.subscribe(...)` directly — looks like
- * an island from `describe()`'s perspective: zero declared in-edges, and no
- * other node lists it as a dep. The check WILL flag it. Treat
- * `validateNoIslands` as a smell-detector, not a definitive correctness gate;
- * complement with `graph.observe(...)` instrumentation when external
- * consumers are part of the design. If you have known external-consumer
- * roots, filter them from `result.orphans` before deciding what to act on.
- *
- * **Synthetic `__internal__/` paths (EH-9).** Compound factories sometimes
- * surface unnamed helper nodes under the `__internal__/` namespace
- * (auto-generated when a producer / derived is added without a `name` and
- * the registrar falls back to a synthetic prefix). These never represent
- * user-authored topology and should not surface as actionable orphans;
- * `validateNoIslands` filters them out before reporting. If a real factory
- * regression accidentally leaks a user-meaningful node under this prefix,
- * the fix is to give the node a real name — not to remove the filter.
- *
- * **Non-throwing by default.** Returns a structured result so callers
- * (dry-run blocks, CI smoke tests) can exit non-zero with a diagnostic
- * instead of crashing.
- *
- * @module
- */
-
-import type { Graph } from "./graph.js";
-
-/** A reported island node, surfacing both path and node kind for triage. */
-export interface IslandReport {
-	/** Path-qualified node name (mounted children included). */
-	readonly path: string;
-	/** `describe()` node `type` — `"state"` / `"derived"` / `"effect"` etc. Helps distinguish "forgot to wire" from "compositional bug". */
-	readonly kind: string;
-}
-
-/** Result returned by {@link validateNoIslands}. */
-export interface ValidateNoIslandsResult {
-	/** `true` when the graph has zero island nodes. */
-	readonly ok: boolean;
-	/**
-	 * Path-qualified names + kinds of nodes that are both zero-in and
-	 * zero-out. Sorted ASCII-asc by `path` for deterministic output.
-	 */
-	readonly orphans: readonly IslandReport[];
-	/** Single-line summary suitable for `process.stderr`. */
-	summary(): string;
-}
-
-/**
- * Walk the graph's describe output and report island nodes (zero in + zero out edges).
- *
- * @example
- * ```ts
- * const result = validateNoIslands(graph);
- * if (!result.ok) {
- *   console.error(result.summary());
- *   for (const o of result.orphans) console.error(`  - ${o.path} (${o.kind})`);
- *   process.exit(3);
- * }
- * ```
- */
-export function validateNoIslands(graph: Graph): ValidateNoIslandsResult {
-	const desc = graph.describe({ detail: "minimal" });
-	const allPaths = Object.keys(desc.nodes);
-
-	// Build the set of paths that appear as a dep on at least one OTHER node —
-	// i.e. paths that have ≥1 incoming edge from the perspective of the
-	// dep-pointer. (`deps` on node X means X receives DATA FROM each entry;
-	// each entry's referenced path therefore has an out-edge into X.)
-	const referencedAsDep = new Set<string>();
-	for (const path of allPaths) {
-		const entry = desc.nodes[path];
-		if (!entry) continue;
-		const deps = (entry.deps as readonly string[] | undefined) ?? [];
-		for (const dep of deps) {
-			referencedAsDep.add(dep);
-		}
-	}
-
-	const orphans: IslandReport[] = [];
-	for (const path of allPaths) {
-		const entry = desc.nodes[path];
-		if (!entry) continue;
-		// EH-9: synthetic `__internal__/` paths are factory bookkeeping, not
-		// user topology. Suppress before edge-counting so they never surface.
-		if (path.startsWith("__internal__/")) continue;
-		const deps = (entry.deps as readonly string[] | undefined) ?? [];
-		const inEdges = deps.length;
-		// `hasOutEdge` is a 0/1 indicator (not a count) — `validateNoIslands`
-		// only needs the boolean answer to "does any other node depend on
-		// this path?".
-		const hasOutEdge = referencedAsDep.has(path);
-		if (inEdges === 0 && !hasOutEdge) {
-			const kind = (entry.type as string | undefined) ?? "unknown";
-			orphans.push({ path, kind });
-		}
-	}
-
-	orphans.sort((a, b) => (a.path < b.path ? -1 : a.path > b.path ? 1 : 0));
-
-	return {
-		ok: orphans.length === 0,
-		orphans,
-		summary(): string {
-			if (orphans.length === 0) return "validateNoIslands: ok (no islands)";
-			const head = orphans
-				.slice(0, 3)
-				.map((o) => `${o.path} (${o.kind})`)
-				.join(", ");
-			return `validateNoIslands: ${orphans.length} island node(s) — ${head}${orphans.length > 3 ? ", …" : ""}`;
-		},
-	};
-}
diff --git a/packages/pure-ts/src/index.ts b/packages/pure-ts/src/index.ts
deleted file mode 100644
index fa48a07d..00000000
--- a/packages/pure-ts/src/index.ts
+++ /dev/null
@@ -1,28 +0,0 @@
-/**
- * GraphRefly pure-TS substrate — public API surface (cleave A2, 2026-05-14).
- *
- * Exports only the substrate layers:
- * - core/ (message protocol, node primitive, batch, sugar constructors)
- * - graph/ (Graph container, describe/observe, snapshot)
- * - extra/ (operators, data-structures, storage, stratify, sync sources, fromTimer, keepalive)
- *
- * Presentation APIs (base/, utils/, presets/, solutions/, compat/) live in
- * `@graphrefly/graphrefly` (repo root `src/`).
- */
-/**
- * Package version. Build-time injected from `package.json` via the tsup
- * `define` for `process.env.GRAPHREFLY_PKG_VERSION` (D4) so there is one
- * source of truth. Unbuilt source consumers (parity-tests' src alias,
- * evals' tsx) see `"0.0.0-dev"` — an honest "running unbuilt source"
- * sentinel, not a misleading real-looking `"0.0.0"`.
- */
-export const version: string = process.env.GRAPHREFLY_PKG_VERSION ?? "0.0.0-dev";
-
-// Named re-exports enable finer-grained tree-shaking for consumers.
-export * from "./core/index.js";
-// Keep namespace exports for ergonomic grouped imports.
-export * as core from "./core/index.js";
-export * from "./extra/index.js";
-export * as extra from "./extra/index.js";
-export * from "./graph/index.js";
-export * as graph from "./graph/index.js";
diff --git a/packages/pure-ts/src/testing/assertions.ts b/packages/pure-ts/src/testing/assertions.ts
deleted file mode 100644
index e65ff756..00000000
--- a/packages/pure-ts/src/testing/assertions.ts
+++ /dev/null
@@ -1,116 +0,0 @@
-/**
- * Lock 3.B (Phase 13.6.B B9) — DIRTY-precedes-terminal-DATA assertion helper.
- *
- * Replaces ad-hoc test assertions like "DIRTY precedes any DATA globally,"
- * which fail for accumulating operators where the initial activation
- * `[RESOLVED]` has no preceding DIRTY (P.25). Encoding the rule in a helper
- * means tests can't accidentally write the wrong predicate.
- *
- * Helper checks: for every **terminal-emission DATA** (the last DATA in a
- * wave settling the operator's value), there exists a `[DIRTY]` earlier
- * in the message sequence within that wave's preamble. Initial-activation
- * `[RESOLVED]` (P.25 ceremony) is skipped.
- */
-
-import { DATA, DIRTY, type Message, type Messages, RESOLVED, START } from "../core/messages.js";
-
-/**
- * Assertion helper: every settling DATA in the message stream is preceded by
- * a `[DIRTY]` in the same wave preamble.
- *
- * - Walks the message sequence linearly. Maintains `pending` = `DIRTY count
- *   − settlement count`, where settlements include DATA and RESOLVED.
- * - **Push-on-subscribe handshake carve-out** (extends P.25). When the
- *   stream starts with `[START]`, every immediately-following DATA /
- *   RESOLVED is treated as part of the handshake until the first
- *   non-handshake message (typically `[DIRTY]`) opens the post-handshake
- *   window. This admits both:
- *   - the legacy P.25 shape `[START, RESOLVED]` (initial-activation
- *     ceremony with no value to advertise);
- *   - the Lock 6.G `replayBuffer: N` shape `[START, DATA, …, DATA,
- *     DIRTY?]` (late subscriber receiving N replayed values plus an
- *     optional trailing DIRTY when the node's status is `"dirty"` at
- *     subscribe time).
- *   When the stream lacks a leading `[START]`, only a single leading
- *   `[RESOLVED]` is admitted (legacy P.25 shape preserved for callers
- *   that strip START before passing the messages in).
- * - Throws `Error` with a descriptive message on the first violation.
- *
- * ```ts
- * import { assertDirtyPrecedesTerminalData } from "@graphrefly/graphrefly/testing";
- *
- * const messages: Messages = collect(node, { flat: true }).messages;
- * assertDirtyPrecedesTerminalData(messages);
- * ```
- *
- * @param messages - Flattened message sequence captured from a node's
- *   subscribe callback. May begin with `[START]`.
- *
- * @throws {Error} when a settlement (DATA or non-handshake RESOLVED) arrives
- *   without an outstanding DIRTY ahead of it in the same wave.
- */
-export function assertDirtyPrecedesTerminalData(messages: Messages): void {
-	let pending = 0;
-	let inLeadingHandshake = false;
-	let firstMessage = true;
-	for (let i = 0; i < messages.length; i++) {
-		const m = messages[i];
-		const t = m[0];
-		if (t === START) {
-			// Push-on-subscribe handshake opens; subsequent DATA/RESOLVED
-			// are part of the handshake (cache push and/or Lock 6.G
-			// replay buffer) until the first non-DATA/RESOLVED message.
-			inLeadingHandshake = true;
-			firstMessage = false;
-			continue;
-		}
-		if (firstMessage && t === RESOLVED) {
-			// Legacy P.25 carve-out for callers that strip START before
-			// passing messages in: single leading RESOLVED is the
-			// initial-activation ceremony and admits without DIRTY.
-			firstMessage = false;
-			continue;
-		}
-		firstMessage = false;
-		if (inLeadingHandshake && (t === DATA || t === RESOLVED)) {
-			// Inside the handshake window — these are buffered DATAs
-			// (replayBuffer) and/or the cache-DATA push, neither of
-			// which carries a preceding DIRTY by spec.
-			continue;
-		}
-		// First non-handshake message ends the leading window.
-		inLeadingHandshake = false;
-		if (t === DIRTY) {
-			pending += 1;
-			continue;
-		}
-		if (t === DATA || t === RESOLVED) {
-			if (pending <= 0) {
-				const ctx = describeMessageWindow(messages, i);
-				throw new Error(
-					`assertDirtyPrecedesTerminalData: settlement at index ${i} (` +
-						`${describeType(t)}) arrived without an outstanding DIRTY in the ` +
-						`same wave preamble (P.25 protocol §1.3 violation). ` +
-						`Window: ${ctx}`,
-				);
-			}
-			pending -= 1;
-		}
-		// Other message types (ERROR / COMPLETE / INVALIDATE / PAUSE /
-		// RESUME / TEARDOWN) don't affect the DIRTY/settlement balance.
-	}
-}
-
-function describeMessageWindow(messages: Messages, around: number): string {
-	const start = Math.max(0, around - 3);
-	const end = Math.min(messages.length, around + 4);
-	const slice: Message[] = messages.slice(start, end) as Message[];
-	const parts = slice.map((m, j) => `${start + j === around ? "→ " : "  "}[${describeType(m[0])}]`);
-	return parts.join(", ");
-}
-
-function describeType(t: symbol): string {
-	const desc = t.description ?? "";
-	const slash = desc.lastIndexOf("/");
-	return slash >= 0 ? desc.slice(slash + 1) : desc;
-}
diff --git a/packages/pure-ts/src/testing/index.ts b/packages/pure-ts/src/testing/index.ts
deleted file mode 100644
index fa872129..00000000
--- a/packages/pure-ts/src/testing/index.ts
+++ /dev/null
@@ -1,9 +0,0 @@
-/**
- * `@graphrefly/graphrefly/testing` — public testing utilities.
- *
- * Phase 13.6.B B9 (Lock 3.B) seeds this surface with the
- * `assertDirtyPrecedesTerminalData` helper. Future additions per
- * Phase 14.5.3: `mockLLM` promotion, scenario-scripted fixtures.
- */
-
-export { assertDirtyPrecedesTerminalData } from "./assertions.js";
diff --git a/packages/pure-ts/tsconfig.json b/packages/pure-ts/tsconfig.json
deleted file mode 100644
index 05b91250..00000000
--- a/packages/pure-ts/tsconfig.json
+++ /dev/null
@@ -1,16 +0,0 @@
-{
-	"compilerOptions": {
-		"target": "ES2022",
-		"module": "ES2022",
-		"moduleResolution": "bundler",
-		"declaration": true,
-		"outDir": "dist",
-		"rootDir": "src",
-		"strict": true,
-		"esModuleInterop": true,
-		"skipLibCheck": true,
-		"forceConsistentCasingInFileNames": true
-	},
-	"include": ["src"],
-	"exclude": ["node_modules", "dist", "**/*.test.ts"]
-}
diff --git a/packages/pure-ts/tsup.config.ts b/packages/pure-ts/tsup.config.ts
deleted file mode 100644
index 4ce1a300..00000000
--- a/packages/pure-ts/tsup.config.ts
+++ /dev/null
@@ -1,406 +0,0 @@
-import { readFileSync } from "node:fs";
-import { readdir, readFile, writeFile } from "node:fs/promises";
-import { join } from "node:path";
-import { defineConfig } from "tsup";
-
-// D4 (post-rustImpl-activation parity cleanup): the published `version`
-// export is build-time injected from package.json so there is ONE source
-// of truth. `src/index.ts` keeps a `process.env.GRAPHREFLY_PKG_VERSION`
-// indirection with a `"0.0.0-dev"` fallback for unbuilt source consumers
-// (parity-tests' src alias, evals' tsx) — no source consumer reads
-// `.version`, and the `define` below strips the `process.env` reference
-// from every shipped chunk (so `assertBrowserSafeBundles` stays clean).
-const PKG_VERSION = (
-	JSON.parse(readFileSync(new URL("./package.json", import.meta.url), "utf8")) as {
-		version: string;
-	}
-).version;
-// QA-P6: fail the build LOUD if version is absent/empty. Without this,
-// `JSON.stringify(undefined)` makes the esbuild `define` a no-op →
-// `process.env.GRAPHREFLY_PKG_VERSION` survives into shipped chunks,
-// silently breaking BOTH the `version` export and the browser-safety
-// invariant the define is responsible for.
-if (!PKG_VERSION || typeof PKG_VERSION !== "string") {
-	throw new Error(
-		`tsup.config: package.json "version" is missing/empty (got ${JSON.stringify(
-			PKG_VERSION,
-		)}). The version-inject define cannot proceed.`,
-	);
-}
-
-// Which built-in modules we import from source — esbuild strips the `node:`
-// prefix at bundle time (evanw/esbuild#2535) even with `platform: "node"` and
-// `external` listing, so we restore it post-build across every emitted chunk.
-// Keep this list in sync with Node's full builtin set — a missing entry means
-// the bundle ships a bare `require("<name>")` that bypasses both
-// `restoreNodePrefix` (nothing to rewrite) and `assertBrowserSafeBundles`
-// (only matches `node:*` specifiers).
-const NODE_BUILTINS = [
-	"assert",
-	"assert/strict",
-	"async_hooks",
-	"buffer",
-	"child_process",
-	"cluster",
-	"console",
-	"constants",
-	"crypto",
-	"dgram",
-	"diagnostics_channel",
-	"dns",
-	"dns/promises",
-	"domain",
-	"events",
-	"fs",
-	"fs/promises",
-	"http",
-	"http2",
-	"https",
-	"inspector",
-	"inspector/promises",
-	"module",
-	"net",
-	"os",
-	"path",
-	"path/posix",
-	"path/win32",
-	"perf_hooks",
-	"process",
-	"punycode",
-	"querystring",
-	"readline",
-	"readline/promises",
-	"repl",
-	"sqlite",
-	"stream",
-	"stream/consumers",
-	"stream/promises",
-	"stream/web",
-	"string_decoder",
-	"sys",
-	"test",
-	"timers",
-	"timers/promises",
-	"tls",
-	"trace_events",
-	"tty",
-	"url",
-	"util",
-	"util/types",
-	"v8",
-	"vm",
-	"wasi",
-	"worker_threads",
-	"zlib",
-];
-
-async function restoreNodePrefix(dir: string): Promise<void> {
-	const entries = await readdir(dir, { withFileTypes: true });
-	for (const e of entries) {
-		const p = join(dir, e.name);
-		if (e.isDirectory()) {
-			await restoreNodePrefix(p);
-			continue;
-		}
-		if (!/\.(js|cjs|mjs)$/.test(e.name)) continue;
-		let src = await readFile(p, "utf8");
-		let changed = false;
-		for (const name of NODE_BUILTINS) {
-			const esc = name.replace(/\//g, "\\/");
-			// Matches `from "fs"` / `from 'fs'` / `require("fs")` (not `node:fs`).
-			const patterns = [
-				new RegExp(`(from\\s+["'])(${esc})(["'])`, "g"),
-				new RegExp(`(require\\(["'])(${esc})(["']\\))`, "g"),
-			];
-			for (const re of patterns) {
-				const next = src.replace(re, (_m, a, b, c) => `${a}node:${b}${c}`);
-				if (next !== src) {
-					src = next;
-					changed = true;
-				}
-			}
-		}
-		if (changed) await writeFile(p, src);
-	}
-}
-
-// Authoritative list of entry points — the guardrail uses this to distinguish
-// real entries from shared chunks without relying on filename heuristics.
-//
-// Post-cleave A2 (2026-05-14): pure-ts ships the SUBSTRATE ONLY.
-// Presentation layer (patterns, compat, io adapters, framework bindings)
-// lives in `@graphrefly/graphrefly` (root shim). See CLAUDE.md § Layout.
-const ENTRY_POINTS = [
-	// Root barrel (substrate surface)
-	"src/index.ts",
-	// Core layer: node primitive, messages, batch, sugar constructors
-	"src/core/index.ts",
-	// Phase 13.6.B B9 (Lock 3.B): public testing utilities subpath —
-	// browser-safe by default; consumers add to their test runner only.
-	"src/testing/index.ts",
-	// Extra: operators, sources, data-structures, storage (substrate only)
-	"src/extra/index.ts",
-	// Node-only extra: file/sqlite storage backends
-	"src/extra/node.ts",
-	// Browser-only extra: IndexedDB storage backends
-	"src/extra/browser.ts",
-	// Operators subpath (substrate operators)
-	"src/extra/operators/index.ts",
-	// Sources subpath (substrate sources: iter, timer, async, keepalive)
-	"src/extra/sources/index.ts",
-	// Storage subpaths (substrate storage tiers)
-	"src/extra/storage/index.ts",
-	"src/extra/storage/tiers-node.ts",
-	"src/extra/storage/tiers-browser.ts",
-	"src/extra/storage/wal.ts",
-	// Graph layer: Graph container, describe, observe, snapshot
-	"src/graph/index.ts",
-];
-
-export default defineConfig({
-	entry: ENTRY_POINTS,
-	format: ["esm", "cjs"],
-	dts: true,
-	clean: true,
-	define: {
-		"process.env.GRAPHREFLY_PKG_VERSION": JSON.stringify(PKG_VERSION),
-	},
-	sourcemap: process.env.NODE_ENV !== "production",
-	minify: process.env.NODE_ENV === "production",
-	platform: "node",
-	target: "node22",
-	external: [
-		"@nestjs/common",
-		"@nestjs/core",
-		"@nestjs/microservices",
-		"@nestjs/platform-express",
-		"@nestjs/websockets",
-		"rxjs",
-		"reflect-metadata",
-		"react",
-		"react-dom",
-		"vue",
-		"solid-js",
-		"svelte",
-	],
-	async onSuccess() {
-		await restoreNodePrefix("dist");
-		await assertBrowserSafeBundles("dist");
-	},
-});
-
-/**
- * Post-build regression check: browser-safe entry points MUST NOT contain
- * `from "node:..."` imports NOR an unsubstituted `GRAPHREFLY_PKG_*`
- * version-define token (D2 defense-in-depth, 2026-05-17). Node-only
- * entries are explicitly allow-listed.
- *
- * Any universal entry whose dist chunks transitively import a `node:*`
- * builtin OR carry a surviving `GRAPHREFLY_PKG` env token fails the build
- * — this is the guardrail behind the formal browser/node split in the
- * exports map and the D4 version-`define` browser-safety claim. (Generic
- * `process.env.NODE_ENV` / CJS-interop `process` refs are intentionally
- * NOT flagged — they are bundler-emitted and browser-safe.)
- */
-async function assertBrowserSafeBundles(dir: string): Promise<void> {
-	// Entry points (relative to `dist/`, no ext) that are allowed to transitively
-	// reach `node:*` builtins. Everything else MUST be browser-safe.
-	//
-	// These correspond to tsup entries whose source file is itself Node-only.
-	// Keep in sync with `ENTRY_POINTS` (strip `src/` prefix + `.ts`).
-	// IMPORTANT: keep aligned with ENTRY_POINTS Node-only entries even if the
-	// source path moves to a sub-folder. Future contributors moving a Node-only
-	// entry to a sub-folder must update both lists or assertBrowserSafeBundles
-	// will silently pass.
-	const nodeOnlyEntries = new Set<string>([
-		// Node-only substrate entries (may import node:* builtins)
-		"extra/node",
-		"extra/storage/tiers-node",
-	]);
-
-	// Derive the canonical set of entry paths (no ext) from `ENTRY_POINTS` so
-	// `isEntry` doesn't rely on filename heuristics. Chunks emitted by tsup
-	// (shared code between entries) don't appear in this set.
-	const entryPaths = new Set(ENTRY_POINTS.map((p) => p.replace(/^src\//, "").replace(/\.ts$/, "")));
-
-	type FileInfo = {
-		abs: string;
-		rel: string;
-		ext: "js" | "cjs" | "mjs";
-		imports: string[];
-		nodeBuiltins: string[];
-		/**
-		 * D2 defense-in-depth (gate blind-spot follow-up, 2026-05-17): a
-		 * **residual version-define token** in a universal chunk. The D4
-		 * browser-safety claim rests entirely on the shared tsup
-		 * `defineConfig` substituting the `GRAPHREFLY_PKG_VERSION` env token
-		 * to a string literal at build time; an entry built OUTSIDE that
-		 * config would ship the unsubstituted token (a `process` reference
-		 * that breaks browser bundles + a wrong `version` export).
-		 *
-		 * Scoped to the `GRAPHREFLY_PKG_*` token family ON PURPOSE — a
-		 * generic `process.env` match is NOT a browser-safety violation
-		 * (esbuild legitimately emits guarded / DCE-eligible
-		 * `process.env.NODE_ENV` reads + CJS-interop `process` refs in
-		 * every chunk; flagging those is all false-positives). The precise
-		 * invariant D4 protects is "the version define ran", and that is
-		 * exactly what this detects.
-		 */
-		hasResidualVersionToken: boolean;
-	};
-	const files = new Map<string, FileInfo>();
-	await walkBuild(dir, async (abs) => {
-		const m = abs.match(/\.(js|cjs|mjs)$/);
-		if (!m) return;
-		const ext = m[1] as "js" | "cjs" | "mjs";
-		const rel = abs.slice(dir.length + 1);
-		const src = await readFile(abs, "utf8");
-		const imports = extractImportSpecs(src);
-		// Match both `node:*` (what `restoreNodePrefix` produces) and bare
-		// builtin names — guards against a future regression where
-		// `restoreNodePrefix`'s NODE_BUILTINS list is incomplete.
-		const nodeBuiltins = imports.filter((p) => p.startsWith("node:") || BUILTIN_SET.has(p));
-		// `define` substitutes the version token to a string literal at
-		// build time; a surviving `GRAPHREFLY_PKG_*` env reference in dist
-		// means the define did NOT run for this entry (the D4 leak).
-		const hasResidualVersionToken = /process\s*\.\s*env\s*\.\s*GRAPHREFLY_PKG/.test(src);
-		files.set(rel, { abs, rel, ext, imports, nodeBuiltins, hasResidualVersionToken });
-	});
-
-	// Resolve a specifier against the calling file's directory. Keep ESM/CJS
-	// trees disjoint: a `.cjs` file resolves to `.cjs` candidates only;
-	// `.js`/`.mjs` resolve to `.js`/`.mjs` candidates. Prevents a CJS require
-	// from accidentally resolving to the ESM twin of a node-only module.
-	function resolveSpec(
-		fromRel: string,
-		fromExt: "js" | "cjs" | "mjs",
-		spec: string,
-	): string | null {
-		if (spec.startsWith("node:") || !spec.startsWith(".")) return null;
-		const baseDir = fromRel.includes("/") ? fromRel.slice(0, fromRel.lastIndexOf("/")) : "";
-		const parts = (baseDir ? `${baseDir}/${spec}` : spec).split("/");
-		const stack: string[] = [];
-		for (const p of parts) {
-			if (p === "" || p === ".") continue;
-			if (p === "..") stack.pop();
-			else stack.push(p);
-		}
-		const joined = stack.join("/");
-		const exts = fromExt === "cjs" ? ["cjs"] : ["js", "mjs"];
-		const candidates: string[] = [];
-		// If the specifier carries an extension, try it first (same-format).
-		if (/\.(js|cjs|mjs)$/.test(joined)) candidates.push(joined);
-		for (const e of exts) candidates.push(`${joined}.${e}`);
-		// Directory-as-index resolution (`./foo` → `./foo/index.js`).
-		for (const e of exts) candidates.push(`${joined}/index.${e}`);
-		for (const cand of candidates) {
-			if (files.has(cand)) return cand;
-		}
-		return null;
-	}
-
-	// Universal entries = dist files whose no-ext path is a declared entry
-	// but NOT on the node-only allow-list. Chunks aren't in `entryPaths`, so
-	// they're traversed during BFS but never seeded as roots.
-	const universalEntries: string[] = [];
-	for (const rel of files.keys()) {
-		const noExt = rel.replace(/\.(js|cjs|mjs)$/, "");
-		if (!entryPaths.has(noExt)) continue;
-		if (nodeOnlyEntries.has(noExt)) continue;
-		universalEntries.push(rel);
-	}
-
-	const offenders: Array<{ entry: string; chain: string[]; builtin: string }> = [];
-	for (const entry of universalEntries) {
-		const visited = new Set<string>();
-		const queue: Array<{ rel: string; chain: string[] }> = [{ rel: entry, chain: [entry] }];
-		while (queue.length > 0) {
-			const { rel, chain } = queue.shift()!;
-			if (visited.has(rel)) continue;
-			visited.add(rel);
-			const info = files.get(rel);
-			if (!info) continue;
-			if (info.nodeBuiltins.length > 0) {
-				offenders.push({ entry, chain, builtin: info.nodeBuiltins[0] });
-				break;
-			}
-			if (info.hasResidualVersionToken) {
-				offenders.push({
-					entry,
-					chain,
-					builtin: "unsubstituted GRAPHREFLY_PKG version token (D2 guard)",
-				});
-				break;
-			}
-			for (const spec of info.imports) {
-				const resolved = resolveSpec(rel, info.ext, spec);
-				if (resolved && !visited.has(resolved)) {
-					queue.push({ rel: resolved, chain: [...chain, resolved] });
-				}
-			}
-		}
-	}
-
-	if (offenders.length > 0) {
-		const msg = offenders
-			.map(
-				({ entry, chain, builtin }) =>
-					`  entry ${entry} → ${builtin}\n    via ${chain.join(" → ")}`,
-			)
-			.join("\n");
-		throw new Error(
-			`Browser-safety regression: universal entries transitively reach a Node-only token.\n${msg}\n` +
-				"Fix (node:* builtin): route the node-only dependency through an `extra/node` or " +
-				"`patterns/<x>/node` subpath, or add the entry to `nodeOnlyEntries` if it is genuinely " +
-				"Node-only.\nFix (D2 version-token guard): the entry shipped an unsubstituted " +
-				"`GRAPHREFLY_PKG_*` token — it was built outside the shared tsup `defineConfig` " +
-				"`define`. Route the entry through that config so the version is inlined.",
-		);
-	}
-}
-
-// Pre-computed builtin lookup for `assertBrowserSafeBundles`. Mirrors
-// NODE_BUILTINS as a Set for O(1) membership and catches bare
-// `require("<builtin>")` emissions that slipped past `restoreNodePrefix`.
-const BUILTIN_SET = new Set<string>(NODE_BUILTINS);
-
-/**
- * Extract module specifiers from a bundled JS/CJS/MJS source string.
- *
- * Handles:
- *   - `import { x } from "foo"` / `import{x}from"foo"` (any whitespace around `from`)
- *   - `import "foo"` (side-effect import)
- *   - `export { x } from "foo"` / `export*from"foo"` (re-export, minified or not)
- *   - `import("foo")` / `require("foo")` / `__require("foo")` (dynamic / CJS / esbuild wrapper)
- */
-function extractImportSpecs(src: string): string[] {
-	const specs: string[] = [];
-	const patterns: RegExp[] = [
-		// `import ... from "X"` / `export ... from "X"` — whitespace around
-		// `from` is optional so minified output (`from"X"`) matches.
-		/\b(?:import|export)\b[\s\S]*?\bfrom\s*["']([^"']+)["']/g,
-		// Side-effect import: `import "X"` (no bindings, no `from`).
-		/\bimport\s*["']([^"']+)["']/g,
-		// Dynamic `import()` and CJS `require()`. `\brequire` also matches
-		// esbuild's `__require("X")` wrapper via the word boundary at `r`.
-		/\b(?:import|require)\s*\(\s*["']([^"']+)["']\s*\)/g,
-	];
-	for (const re of patterns) {
-		for (const m of src.matchAll(re)) {
-			specs.push(m[1]);
-		}
-	}
-	return specs;
-}
-
-async function walkBuild(dir: string, visit: (absPath: string) => Promise<void>): Promise<void> {
-	const entries = await readdir(dir, { withFileTypes: true });
-	for (const e of entries) {
-		const p = join(dir, e.name);
-		if (e.isDirectory()) {
-			await walkBuild(p, visit);
-		} else if (e.isFile()) {
-			await visit(p);
-		}
-	}
-}
diff --git a/packages/pure-ts/vitest.config.ts b/packages/pure-ts/vitest.config.ts
deleted file mode 100644
index e8445573..00000000
--- a/packages/pure-ts/vitest.config.ts
+++ /dev/null
@@ -1,73 +0,0 @@
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-import { defineConfig } from "vitest/config";
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-// Root of the monorepo (parent of packages/pure-ts)
-const ROOT = path.resolve(__dirname, "../..");
-const ROOT_SRC = path.resolve(ROOT, "src");
-
-export default defineConfig({
-	resolve: {
-		alias: [
-			// ── Package aliases ────────────────────────────────────────────
-			{
-				find: /^@graphrefly\/pure-ts\/(.+)$/,
-				replacement: path.resolve(__dirname, "src/$1"),
-			},
-			{ find: "@graphrefly/pure-ts", replacement: path.resolve(__dirname, "src/index.ts") },
-			// Legacy alias (pre-cleave package name used by some tests)
-			{
-				find: /^@graphrefly\/graphrefly-ts\/(.+)$/,
-				replacement: path.resolve(__dirname, "src/$1"),
-			},
-			{ find: "@graphrefly/graphrefly-ts", replacement: path.resolve(__dirname, "src/index.ts") },
-
-			// ── Presentation layer paths (tests that weren't yet moved) ────
-			// These tests in __tests__/ still reference presentation modules
-			// that live in the root src/. Alias them so substrate tests work
-			// until the test files are migrated to root src/__tests__/.
-			{
-				// Resolve extra/render/index.js references from pure-ts tests
-				find: /^(\.\.\/)*extra\/render\/index\.js$/,
-				replacement: path.resolve(ROOT_SRC, "base/render/index.ts"),
-			},
-			{
-				// Resolve ../../../../src/base/* references from pure-ts tests
-				// (the extra ../../ levels path is wrong but vitest resolves file-relative)
-				find: /^(\.\.\/)*src\/base\/(.+)$/,
-				replacement: path.resolve(ROOT_SRC, "base/$2"),
-			},
-			{
-				// Resolve ../../../../src/utils/* references from pure-ts tests
-				find: /^(\.\.\/)*src\/utils\/(.+)$/,
-				replacement: path.resolve(ROOT_SRC, "utils/$2"),
-			},
-		],
-	},
-	test: {
-		// Colocated *.test.ts or src/__tests__/**/*.test.ts (see docs/test-guidance.md)
-		include: ["src/**/*.test.ts"],
-		exclude: [
-			"**/node_modules/**",
-			"dist/**",
-			"**/*.bench.ts",
-			// Presentation-layer test moved to root src/__tests__/ by A2 cleave;
-			// pre-cleave substrate sources test (extra/sources.test.ts) was deleted
-			// in the post-cleave /qa pass (superseded by root sources test).
-			"src/__tests__/extra/session1-foundation.test.ts",
-		],
-		environment: "node",
-	},
-	benchmark: {
-		// CI-eligible benches use the `*.bench.ts` suffix.
-		// Maintainer-local profiling tools that hardcode
-		// `/Users/davidchenallio/src/graphrefly-rs/target/release/...` paths
-		// or run as standalone scripts (without `bench()` blocks) use the
-		// `*.bench.local.ts` suffix and are excluded from this glob. Run them
-		// directly via `vitest bench src/__bench__/<file>` after
-		// `pnpm --filter @graphrefly/native build`.
-		include: ["src/__bench__/**/*.bench.ts"],
-		environment: "node",
-	},
-});
diff --git a/packages/cli/LICENSE b/packages/ts/LICENSE
similarity index 100%
rename from packages/cli/LICENSE
rename to packages/ts/LICENSE
diff --git a/packages/ts/README.md b/packages/ts/README.md
new file mode 100644
index 00000000..e086958a
--- /dev/null
+++ b/packages/ts/README.md
@@ -0,0 +1,135 @@
+# @graphrefly/ts
+
+Clean-slate TypeScript implementation of GraphReFly: substrate, graph, operators,
+sources, storage, messaging, work queues, orchestration, CQRS, render, and tests.
+
+The graph core is synchronous. Async work should live at source, adapter, executor,
+worker, or wire-bridge boundaries and return to the graph as visible facts or
+commands.
+
+## Concurrent WorkQueue Workers
+
+`workQueue` supports parallel workers by separating queue lifecycle from async
+execution:
+
+1. The queue emits graph-visible `work-admitted` and `work-claimed` records.
+2. A boundary runner observes claimed work and starts async tasks.
+3. The runner reports results through the queue command front door:
+   `complete`, `fail`, or `release`.
+
+Do not keep a node `ctx` and call `ctx.down(...)` from a later promise callback.
+Promise callbacks are fine in the boundary runner; the important part is that
+their results re-enter the graph as explicit queue commands or outcome facts.
+
+The smallest concurrent HTTP worker looks like this:
+
+```ts
+import {
+  graph,
+  messageBus,
+  workQueue,
+  type WorkQueue,
+  type WorkQueueRecord,
+} from "@graphrefly/ts";
+
+type HttpTask = {
+  readonly url: string;
+};
+
+const g = graph({ name: "http-work" });
+const bus = messageBus(g, { topics: ["http-work"] });
+const queue = workQueue<HttpTask>(g, {
+  queueId: "http",
+  bus,
+  topic: "http-work",
+  subscriptionId: "http-worker-input",
+});
+
+queue.submit({ url: "https://example.com/a.json" }, { workId: "url-1" });
+queue.submit({ url: "https://example.com/b.json" }, { workId: "url-2" });
+
+function startHttpWorker(
+  queue: WorkQueue<HttpTask>,
+  opts: { readonly workerId: string; readonly concurrency: number },
+): () => void {
+  const payloads = new Map<string, HttpTask>();
+  const inFlight = new Set<string>();
+
+  const refill = () => {
+    const availableSlots = opts.concurrency - inFlight.size;
+    if (availableSlots > 0) {
+      queue.claim({ workerId: opts.workerId, limit: availableSlots });
+    }
+  };
+
+  const unsubscribe = queue.records.subscribe((msg) => {
+    if (msg[0] !== "DATA") return;
+    const record = msg[1] as WorkQueueRecord<HttpTask>;
+
+    if (record.kind === "work-admitted") {
+      payloads.set(record.workId, record.payload);
+      refill();
+      return;
+    }
+
+    if (record.kind !== "work-claimed" || record.workerId !== opts.workerId) return;
+    const task = payloads.get(record.workId);
+    if (task === undefined) {
+      queue.release({
+        workId: record.workId,
+        leaseId: record.leaseId,
+        attempt: record.attempt,
+        workerId: opts.workerId,
+        reason: "missing-payload",
+      });
+      return;
+    }
+
+    inFlight.add(record.workId);
+    void fetch(task.url)
+      .then(async (response) => {
+        if (!response.ok) throw new Error(`HTTP ${response.status}`);
+        return response.json() as Promise<unknown>;
+      })
+      .then((result) => {
+        queue.complete({
+          workId: record.workId,
+          leaseId: record.leaseId,
+          attempt: record.attempt,
+          workerId: opts.workerId,
+          result,
+        });
+      })
+      .catch((error) => {
+        queue.fail({
+          workId: record.workId,
+          leaseId: record.leaseId,
+          attempt: record.attempt,
+          workerId: opts.workerId,
+          error,
+          retryable: true,
+        });
+      })
+      .finally(() => {
+        inFlight.delete(record.workId);
+        refill();
+      });
+  });
+
+  refill();
+  return unsubscribe;
+}
+
+const stopWorker = startHttpWorker(queue, { workerId: "http-worker-1", concurrency: 2 });
+```
+
+This uses one worker identity, but it can keep multiple leases in flight. The
+queue remains responsible for claim/lease/retry/dead-letter facts; the runner is
+responsible for ordinary JavaScript concurrency.
+
+For orchestration and CQRS recipes, keep the same boundary:
+
+- orchestration work produces effect/request/evidence/status facts;
+- CQRS work produces command/status/event/error facts;
+- worker results return through explicit outcome facts or queue disposition
+  commands, not through a stale graph `ctx`.
diff --git a/packages/ts/package.json b/packages/ts/package.json
new file mode 100644
index 00000000..2d6fd9aa
--- /dev/null
+++ b/packages/ts/package.json
@@ -0,0 +1,604 @@
+{
+	"name": "@graphrefly/ts",
+	"version": "0.0.1",
+	"description": "GraphReFly clean-slate TypeScript package — substrate, graph, operators, sources, storage, render, and testing.",
+	"type": "module",
+	"sideEffects": false,
+	"main": "dist/index.cjs",
+	"module": "dist/index.js",
+	"types": "dist/index.d.ts",
+	"exports": {
+		".": {
+			"import": {
+				"types": "./dist/index.d.ts",
+				"default": "./dist/index.js"
+			},
+			"require": {
+				"types": "./dist/index.d.cts",
+				"default": "./dist/index.cjs"
+			}
+		},
+		"./adapters": {
+			"import": {
+				"types": "./dist/adapters/index.d.ts",
+				"default": "./dist/adapters/index.js"
+			},
+			"require": {
+				"types": "./dist/adapters/index.d.cts",
+				"default": "./dist/adapters/index.cjs"
+			}
+		},
+		"./adapters/nestjs": {
+			"import": {
+				"types": "./dist/adapters/nestjs.d.ts",
+				"default": "./dist/adapters/nestjs.js"
+			},
+			"require": {
+				"types": "./dist/adapters/nestjs.d.cts",
+				"default": "./dist/adapters/nestjs.cjs"
+			}
+		},
+		"./adapters/nestjs/microservices": {
+			"import": {
+				"types": "./dist/adapters/nestjs/microservices.d.ts",
+				"default": "./dist/adapters/nestjs/microservices.js"
+			},
+			"require": {
+				"types": "./dist/adapters/nestjs/microservices.d.cts",
+				"default": "./dist/adapters/nestjs/microservices.cjs"
+			}
+		},
+		"./adapters/nestjs/native": {
+			"import": {
+				"types": "./dist/adapters/nestjs/native.d.ts",
+				"default": "./dist/adapters/nestjs/native.js"
+			},
+			"require": {
+				"types": "./dist/adapters/nestjs/native.d.cts",
+				"default": "./dist/adapters/nestjs/native.cjs"
+			}
+		},
+		"./adapters/nestjs/websockets": {
+			"import": {
+				"types": "./dist/adapters/nestjs/websockets.d.ts",
+				"default": "./dist/adapters/nestjs/websockets.js"
+			},
+			"require": {
+				"types": "./dist/adapters/nestjs/websockets.d.cts",
+				"default": "./dist/adapters/nestjs/websockets.cjs"
+			}
+		},
+		"./adapters/observe-storage": {
+			"import": {
+				"types": "./dist/adapters/observe-storage.d.ts",
+				"default": "./dist/adapters/observe-storage.js"
+			},
+			"require": {
+				"types": "./dist/adapters/observe-storage.d.cts",
+				"default": "./dist/adapters/observe-storage.cjs"
+			}
+		},
+		"./adapters/react": {
+			"import": {
+				"types": "./dist/adapters/react.d.ts",
+				"default": "./dist/adapters/react.js"
+			},
+			"require": {
+				"types": "./dist/adapters/react.d.cts",
+				"default": "./dist/adapters/react.cjs"
+			}
+		},
+		"./adapters/solid": {
+			"import": {
+				"types": "./dist/adapters/solid.d.ts",
+				"default": "./dist/adapters/solid.js"
+			},
+			"require": {
+				"types": "./dist/adapters/solid.d.cts",
+				"default": "./dist/adapters/solid.cjs"
+			}
+		},
+		"./adapters/svelte": {
+			"import": {
+				"types": "./dist/adapters/svelte.d.ts",
+				"default": "./dist/adapters/svelte.js"
+			},
+			"require": {
+				"types": "./dist/adapters/svelte.d.cts",
+				"default": "./dist/adapters/svelte.cjs"
+			}
+		},
+		"./adapters/vue": {
+			"import": {
+				"types": "./dist/adapters/vue.d.ts",
+				"default": "./dist/adapters/vue.js"
+			},
+			"require": {
+				"types": "./dist/adapters/vue.d.cts",
+				"default": "./dist/adapters/vue.cjs"
+			}
+		},
+		"./composition": {
+			"import": {
+				"types": "./dist/composition/index.d.ts",
+				"default": "./dist/composition/index.js"
+			},
+			"require": {
+				"types": "./dist/composition/index.d.cts",
+				"default": "./dist/composition/index.cjs"
+			}
+		},
+		"./cqrs": {
+			"import": {
+				"types": "./dist/cqrs/index.d.ts",
+				"default": "./dist/cqrs/index.js"
+			},
+			"require": {
+				"types": "./dist/cqrs/index.d.cts",
+				"default": "./dist/cqrs/index.cjs"
+			}
+		},
+		"./cqrs/messaging": {
+			"import": {
+				"types": "./dist/cqrs/messaging.d.ts",
+				"default": "./dist/cqrs/messaging.js"
+			},
+			"require": {
+				"types": "./dist/cqrs/messaging.d.cts",
+				"default": "./dist/cqrs/messaging.cjs"
+			}
+		},
+		"./cqrs/work-queue": {
+			"import": {
+				"types": "./dist/cqrs/work-queue.d.ts",
+				"default": "./dist/cqrs/work-queue.js"
+			},
+			"require": {
+				"types": "./dist/cqrs/work-queue.d.cts",
+				"default": "./dist/cqrs/work-queue.cjs"
+			}
+		},
+		"./data": {
+			"import": {
+				"types": "./dist/data/index.d.ts",
+				"default": "./dist/data/index.js"
+			},
+			"require": {
+				"types": "./dist/data/index.d.cts",
+				"default": "./dist/data/index.cjs"
+			}
+		},
+		"./core": {
+			"import": {
+				"types": "./dist/core/index.d.ts",
+				"default": "./dist/core/index.js"
+			},
+			"require": {
+				"types": "./dist/core/index.d.cts",
+				"default": "./dist/core/index.cjs"
+			}
+		},
+		"./data-structures": {
+			"import": {
+				"types": "./dist/data-structures/index.d.ts",
+				"default": "./dist/data-structures/index.js"
+			},
+			"require": {
+				"types": "./dist/data-structures/index.d.cts",
+				"default": "./dist/data-structures/index.cjs"
+			}
+		},
+		"./graph": {
+			"import": {
+				"types": "./dist/graph/index.d.ts",
+				"default": "./dist/graph/index.js"
+			},
+			"require": {
+				"types": "./dist/graph/index.d.cts",
+				"default": "./dist/graph/index.cjs"
+			}
+		},
+		"./executors/work-queue": {
+			"import": {
+				"types": "./dist/executors/work-queue.d.ts",
+				"default": "./dist/executors/work-queue.js"
+			},
+			"require": {
+				"types": "./dist/executors/work-queue.d.cts",
+				"default": "./dist/executors/work-queue.cjs"
+			}
+		},
+		"./executors/tool-provider-runtime": {
+			"import": {
+				"types": "./dist/executors/tool-provider-runtime.d.ts",
+				"default": "./dist/executors/tool-provider-runtime.js"
+			},
+			"require": {
+				"types": "./dist/executors/tool-provider-runtime.d.cts",
+				"default": "./dist/executors/tool-provider-runtime.cjs"
+			}
+		},
+		"./executors/tool-provider": {
+			"import": {
+				"types": "./dist/executors/tool-provider.d.ts",
+				"default": "./dist/executors/tool-provider.js"
+			},
+			"require": {
+				"types": "./dist/executors/tool-provider.d.cts",
+				"default": "./dist/executors/tool-provider.cjs"
+			}
+		},
+		"./executors/tool-provider-adapters": {
+			"import": {
+				"types": "./dist/executors/tool-provider-adapters.d.ts",
+				"default": "./dist/executors/tool-provider-adapters.js"
+			},
+			"require": {
+				"types": "./dist/executors/tool-provider-adapters.d.cts",
+				"default": "./dist/executors/tool-provider-adapters.cjs"
+			}
+		},
+		"./inspection/boundary": {
+			"import": {
+				"types": "./dist/inspection/boundary.d.ts",
+				"default": "./dist/inspection/boundary.js"
+			},
+			"require": {
+				"types": "./dist/inspection/boundary.d.cts",
+				"default": "./dist/inspection/boundary.cjs"
+			}
+		},
+		"./messaging": {
+			"import": {
+				"types": "./dist/messaging/index.d.ts",
+				"default": "./dist/messaging/index.js"
+			},
+			"require": {
+				"types": "./dist/messaging/index.d.cts",
+				"default": "./dist/messaging/index.cjs"
+			}
+		},
+		"./work-queue": {
+			"import": {
+				"types": "./dist/work-queue/index.d.ts",
+				"default": "./dist/work-queue/index.js"
+			},
+			"require": {
+				"types": "./dist/work-queue/index.d.cts",
+				"default": "./dist/work-queue/index.cjs"
+			}
+		},
+		"./operators": {
+			"import": {
+				"types": "./dist/operators/index.d.ts",
+				"default": "./dist/operators/index.js"
+			},
+			"require": {
+				"types": "./dist/operators/index.d.cts",
+				"default": "./dist/operators/index.cjs"
+			}
+		},
+		"./orchestration": {
+			"import": {
+				"types": "./dist/orchestration/index.d.ts",
+				"default": "./dist/orchestration/index.js"
+			},
+			"require": {
+				"types": "./dist/orchestration/index.d.cts",
+				"default": "./dist/orchestration/index.cjs"
+			}
+		},
+		"./orchestration/messaging": {
+			"import": {
+				"types": "./dist/orchestration/messaging.d.ts",
+				"default": "./dist/orchestration/messaging.js"
+			},
+			"require": {
+				"types": "./dist/orchestration/messaging.d.cts",
+				"default": "./dist/orchestration/messaging.cjs"
+			}
+		},
+		"./orchestration/work-queue": {
+			"import": {
+				"types": "./dist/orchestration/work-queue.d.ts",
+				"default": "./dist/orchestration/work-queue.js"
+			},
+			"require": {
+				"types": "./dist/orchestration/work-queue.d.cts",
+				"default": "./dist/orchestration/work-queue.cjs"
+			}
+		},
+		"./patterns": {
+			"import": {
+				"types": "./dist/patterns/index.d.ts",
+				"default": "./dist/patterns/index.js"
+			},
+			"require": {
+				"types": "./dist/patterns/index.d.cts",
+				"default": "./dist/patterns/index.cjs"
+			}
+		},
+		"./patterns/event-flow": {
+			"import": {
+				"types": "./dist/patterns/event-flow.d.ts",
+				"default": "./dist/patterns/event-flow.js"
+			},
+			"require": {
+				"types": "./dist/patterns/event-flow.d.cts",
+				"default": "./dist/patterns/event-flow.cjs"
+			}
+		},
+		"./render": {
+			"import": {
+				"types": "./dist/render/index.d.ts",
+				"default": "./dist/render/index.js"
+			},
+			"require": {
+				"types": "./dist/render/index.d.cts",
+				"default": "./dist/render/index.cjs"
+			}
+		},
+		"./sources": {
+			"import": {
+				"types": "./dist/sources/index.d.ts",
+				"default": "./dist/sources/index.js"
+			},
+			"require": {
+				"types": "./dist/sources/index.d.cts",
+				"default": "./dist/sources/index.cjs"
+			}
+		},
+		"./sources/browser": {
+			"browser": {
+				"import": {
+					"types": "./dist/sources/browser.d.ts",
+					"default": "./dist/sources/browser.js"
+				},
+				"require": {
+					"types": "./dist/sources/browser.d.cts",
+					"default": "./dist/sources/browser.cjs"
+				}
+			},
+			"import": {
+				"types": "./dist/sources/browser.d.ts",
+				"default": "./dist/sources/browser.js"
+			},
+			"require": {
+				"types": "./dist/sources/browser.d.cts",
+				"default": "./dist/sources/browser.cjs"
+			}
+		},
+		"./sources/node": {
+			"import": {
+				"types": "./dist/sources/node.d.ts",
+				"default": "./dist/sources/node.js"
+			},
+			"require": {
+				"types": "./dist/sources/node.d.cts",
+				"default": "./dist/sources/node.cjs"
+			}
+		},
+		"./storage": {
+			"import": {
+				"types": "./dist/storage/index.d.ts",
+				"default": "./dist/storage/index.js"
+			},
+			"require": {
+				"types": "./dist/storage/index.d.cts",
+				"default": "./dist/storage/index.cjs"
+			}
+		},
+		"./storage/node": {
+			"import": {
+				"types": "./dist/storage/node.d.ts",
+				"default": "./dist/storage/node.js"
+			},
+			"require": {
+				"types": "./dist/storage/node.d.cts",
+				"default": "./dist/storage/node.cjs"
+			}
+		},
+		"./storage/browser": {
+			"import": {
+				"types": "./dist/storage/browser.d.ts",
+				"default": "./dist/storage/browser.js"
+			},
+			"require": {
+				"types": "./dist/storage/browser.d.cts",
+				"default": "./dist/storage/browser.cjs"
+			}
+		},
+		"./solutions": {
+			"import": {
+				"types": "./dist/solutions/index.d.ts",
+				"default": "./dist/solutions/index.js"
+			},
+			"require": {
+				"types": "./dist/solutions/index.d.cts",
+				"default": "./dist/solutions/index.cjs"
+			}
+		},
+		"./solutions/work-item/work-queue": {
+			"import": {
+				"types": "./dist/solutions/work-item/work-queue.d.ts",
+				"default": "./dist/solutions/work-item/work-queue.js"
+			},
+			"require": {
+				"types": "./dist/solutions/work-item/work-queue.d.cts",
+				"default": "./dist/solutions/work-item/work-queue.cjs"
+			}
+		},
+		"./solutions/work-item/actions": {
+			"import": {
+				"types": "./dist/solutions/work-item/actions.d.ts",
+				"default": "./dist/solutions/work-item/actions.js"
+			},
+			"require": {
+				"types": "./dist/solutions/work-item/actions.d.cts",
+				"default": "./dist/solutions/work-item/actions.cjs"
+			}
+		},
+		"./solutions/work-item/scheduling": {
+			"import": {
+				"types": "./dist/solutions/work-item/scheduling.d.ts",
+				"default": "./dist/solutions/work-item/scheduling.js"
+			},
+			"require": {
+				"types": "./dist/solutions/work-item/scheduling.d.cts",
+				"default": "./dist/solutions/work-item/scheduling.cjs"
+			}
+		},
+		"./solutions/reactive-layout": {
+			"import": {
+				"types": "./dist/solutions/reactive-layout/index.d.ts",
+				"default": "./dist/solutions/reactive-layout/index.js"
+			},
+			"require": {
+				"types": "./dist/solutions/reactive-layout/index.d.cts",
+				"default": "./dist/solutions/reactive-layout/index.cjs"
+			}
+		},
+		"./solutions/reactive-layout/browser": {
+			"browser": {
+				"import": {
+					"types": "./dist/solutions/reactive-layout/browser/index.d.ts",
+					"default": "./dist/solutions/reactive-layout/browser/index.js"
+				},
+				"require": {
+					"types": "./dist/solutions/reactive-layout/browser/index.d.cts",
+					"default": "./dist/solutions/reactive-layout/browser/index.cjs"
+				}
+			},
+			"import": {
+				"types": "./dist/solutions/reactive-layout/browser/index.d.ts",
+				"default": "./dist/solutions/reactive-layout/browser/index.js"
+			},
+			"require": {
+				"types": "./dist/solutions/reactive-layout/browser/index.d.cts",
+				"default": "./dist/solutions/reactive-layout/browser/index.cjs"
+			}
+		},
+		"./solutions/reactive-layout/node-canvas": {
+			"node": {
+				"import": {
+					"types": "./dist/solutions/reactive-layout/node-canvas/index.d.ts",
+					"default": "./dist/solutions/reactive-layout/node-canvas/index.js"
+				},
+				"require": {
+					"types": "./dist/solutions/reactive-layout/node-canvas/index.d.cts",
+					"default": "./dist/solutions/reactive-layout/node-canvas/index.cjs"
+				}
+			},
+			"import": {
+				"types": "./dist/solutions/reactive-layout/node-canvas/index.d.ts",
+				"default": "./dist/solutions/reactive-layout/node-canvas/index.js"
+			},
+			"require": {
+				"types": "./dist/solutions/reactive-layout/node-canvas/index.d.cts",
+				"default": "./dist/solutions/reactive-layout/node-canvas/index.cjs"
+			}
+		},
+		"./solutions/reactive-layout/react-native": {
+			"react-native": {
+				"import": {
+					"types": "./dist/solutions/reactive-layout/react-native/index.d.ts",
+					"default": "./dist/solutions/reactive-layout/react-native/index.js"
+				},
+				"require": {
+					"types": "./dist/solutions/reactive-layout/react-native/index.d.cts",
+					"default": "./dist/solutions/reactive-layout/react-native/index.cjs"
+				}
+			},
+			"import": {
+				"types": "./dist/solutions/reactive-layout/react-native/index.d.ts",
+				"default": "./dist/solutions/reactive-layout/react-native/index.js"
+			},
+			"require": {
+				"types": "./dist/solutions/reactive-layout/react-native/index.d.cts",
+				"default": "./dist/solutions/reactive-layout/react-native/index.cjs"
+			}
+		},
+		"./solutions/reactive-layout/skia": {
+			"import": {
+				"types": "./dist/solutions/reactive-layout/skia/index.d.ts",
+				"default": "./dist/solutions/reactive-layout/skia/index.js"
+			},
+			"require": {
+				"types": "./dist/solutions/reactive-layout/skia/index.d.cts",
+				"default": "./dist/solutions/reactive-layout/skia/index.cjs"
+			}
+		},
+		"./testing": {
+			"import": {
+				"types": "./dist/testing/index.d.ts",
+				"default": "./dist/testing/index.js"
+			},
+			"require": {
+				"types": "./dist/testing/index.d.cts",
+				"default": "./dist/testing/index.cjs"
+			}
+		}
+	},
+	"files": [
+		"dist",
+		"LICENSE"
+	],
+	"publishConfig": {
+		"access": "public"
+	},
+	"scripts": {
+		"build": "tsup && node ../../scripts/check-ts-package-exports.mjs",
+		"test": "vitest run",
+		"test:watch": "vitest"
+	},
+	"license": "MIT",
+	"peerDependencies": {
+		"@nestjs/common": "^11.0.0",
+		"@nestjs/core": "^11.0.0",
+		"@nestjs/microservices": "^11.0.0",
+		"@nestjs/websockets": "^11.0.0",
+		"canvas": "^3.2.3",
+		"react": "^18.0.0 || ^19.0.0",
+		"rxjs": "^7.8.0",
+		"solid-js": "^1.9.0",
+		"svelte": "^5.0.0",
+		"vue": "^3.5.0"
+	},
+	"peerDependenciesMeta": {
+		"@nestjs/common": {
+			"optional": true
+		},
+		"@nestjs/core": {
+			"optional": true
+		},
+		"@nestjs/microservices": {
+			"optional": true
+		},
+		"@nestjs/websockets": {
+			"optional": true
+		},
+		"canvas": {
+			"optional": true
+		},
+		"react": {
+			"optional": true
+		},
+		"rxjs": {
+			"optional": true
+		},
+		"solid-js": {
+			"optional": true
+		},
+		"svelte": {
+			"optional": true
+		},
+		"vue": {
+			"optional": true
+		}
+	},
+	"devDependencies": {
+		"tsup": "^8.5.1",
+		"typescript": "^5.7.0",
+		"vitest": "^3.0.0"
+	}
+}
diff --git a/packages/ts/src/__bench__/b49-probe.ts b/packages/ts/src/__bench__/b49-probe.ts
new file mode 100644
index 00000000..32cbbfd6
--- /dev/null
+++ b/packages/ts/src/__bench__/b49-probe.ts
@@ -0,0 +1,232 @@
+/**
+ * B49 TypeScript probe.
+ *
+ * Informational, not a CI gate. It measures the TS-local costs B49/D76 calls out before
+ * considering any no-double-bookkeeping propagation/frontier rewrite.
+ *
+ * Run from repo root:
+ *   pnpm run probe:b49:ts
+ */
+
+import { performance } from "node:perf_hooks";
+import {
+	batch,
+	depLatest,
+	graph,
+	type Message,
+	type Node,
+	type NodeFn,
+	node,
+	type StateNode,
+} from "../index.js";
+
+interface ProbeResult {
+	name: string;
+	repeats: number;
+	medianMs: number;
+	minMs: number;
+	maxMs: number;
+	notes: string;
+}
+
+interface ProbeOpts {
+	repeats?: number;
+	warmups?: number;
+}
+
+const fmt = (n: number) => n.toLocaleString("en-US", { maximumFractionDigits: 3 });
+
+function expectEqual(label: string, actual: number, expected: number): string {
+	if (actual !== expected) {
+		throw new Error(`${label}: expected ${expected}, got ${actual}`);
+	}
+	return `${label}=${actual}/${expected}`;
+}
+
+function median(xs: number[]): number {
+	const sorted = [...xs].sort((a, b) => a - b);
+	const mid = Math.floor(sorted.length / 2);
+	return sorted.length % 2 === 0 ? (sorted[mid - 1]! + sorted[mid]!) / 2 : sorted[mid]!;
+}
+
+function measure(name: string, run: () => string, opts: ProbeOpts = {}): ProbeResult {
+	const repeats = opts.repeats ?? 5;
+	const warmups = opts.warmups ?? 1;
+	for (let i = 0; i < warmups; i++) run();
+	const times: number[] = [];
+	let notes = "";
+	for (let i = 0; i < repeats; i++) {
+		const t0 = performance.now();
+		notes = run();
+		times.push(performance.now() - t0);
+	}
+	return {
+		name,
+		repeats,
+		medianMs: median(times),
+		minMs: Math.min(...times),
+		maxMs: Math.max(...times),
+		notes,
+	};
+}
+
+function subscribeCounts(n: Node<unknown>): {
+	dataCount: () => number;
+	invalidateCount: () => number;
+	unsubscribe: () => void;
+} {
+	let dataCount = 0;
+	let invalidateCount = 0;
+	const unsubscribe = n.subscribe((m: Message) => {
+		if (m[0] === "DATA") dataCount++;
+		if (m[0] === "INVALIDATE") invalidateCount++;
+	});
+	return { dataCount: () => dataCount, invalidateCount: () => invalidateCount, unsubscribe };
+}
+
+function fanoutProbe(fanout = 512, waves = 2_000): string {
+	const g = graph();
+	const src = g.state(0);
+	const sinks = Array.from({ length: fanout }, () => {
+		const d = g.derived([src], (v) => (v as number) + 1);
+		return subscribeCounts(d);
+	});
+	for (const s of sinks) s.dataCount(); // force activation before measurement assertions.
+	for (let i = 1; i <= waves; i++) src.set(i);
+	const delivered = sinks.reduce((sum, s) => sum + s.dataCount(), 0);
+	const expected = fanout * (waves + 1); // includes activation push from initial state.
+	for (const s of sinks) s.unsubscribe();
+	return `fanout=${fanout}, waves=${waves}, ${expectEqual("DATA deliveries", delivered, expected)}`;
+}
+
+function invalidateSetOnlyProbe(fanout = 256, waves = 2_000): string {
+	const { src, sinks } = makeInvalidateTopology(fanout);
+	for (let i = 1; i <= waves; i++) src.set(i);
+	const delivered = sinks.reduce((sum, s) => sum + s.dataCount(), 0);
+	const expected = fanout * (waves + 1);
+	for (const s of sinks) s.unsubscribe();
+	return `fanout=${fanout}, set waves=${waves}, ${expectEqual("DATA deliveries", delivered, expected)}`;
+}
+
+function invalidateSetPlusInvalidateProbe(fanout = 256, waves = 2_000): string {
+	const { src, sinks } = makeInvalidateTopology(fanout);
+	let invalidates = 0;
+	const invalidateSink = src.subscribe((m) => {
+		if (m[0] === "INVALIDATE") invalidates++;
+	});
+	for (let i = 1; i <= waves; i++) {
+		src.set(i);
+		src.up([["INVALIDATE"]]);
+	}
+	const delivered = sinks.reduce((sum, s) => sum + s.dataCount(), 0);
+	const sinkInvalidates = sinks.reduce((sum, s) => sum + s.invalidateCount(), 0);
+	const expectedData = fanout * (waves + 1);
+	const expectedSinkInvalidates = fanout * waves;
+	for (const s of sinks) s.unsubscribe();
+	invalidateSink();
+	return [
+		`fanout=${fanout}`,
+		`set+invalidate waves=${waves}`,
+		expectEqual("DATA deliveries", delivered, expectedData),
+		expectEqual("source INVALIDATE", invalidates, waves),
+		expectEqual("sink INVALIDATE", sinkInvalidates, expectedSinkInvalidates),
+	].join(", ");
+}
+
+function makeInvalidateTopology(fanout: number): {
+	src: StateNode<number>;
+	sinks: Array<{
+		dataCount: () => number;
+		invalidateCount: () => number;
+		unsubscribe: () => void;
+	}>;
+} {
+	const g = graph();
+	const src = g.state(0);
+	const sinks = Array.from({ length: fanout }, () => {
+		const d = g.derived([src], (v) => v as number);
+		return subscribeCounts(d);
+	});
+	return { src, sinks };
+}
+
+function diamondProbe(legs = 128, waves = 2_000): string {
+	const g = graph();
+	const src = g.state(0);
+	const mids = Array.from({ length: legs }, (_, i) => g.derived([src], (v) => (v as number) + i));
+	const join = g.derived(mids, (...vals) => vals.reduce((sum, v) => sum + (v as number), 0));
+	const sink = subscribeCounts(join);
+	for (let i = 1; i <= waves; i++) src.set(i);
+	const expected = waves + 1;
+	const delivered = sink.dataCount();
+	sink.unsubscribe();
+	return `legs=${legs}, waves=${waves}, ${expectEqual("join DATA deliveries", delivered, expected)}`;
+}
+
+function rewireChurnProbe(turns = 10_000): string {
+	const g = graph();
+	const a = g.state(1);
+	const b = g.state(2);
+	const body: NodeFn = (ctx) => {
+		ctx.down([["DATA", (depLatest(ctx, 0) as number) + 1]]);
+	};
+	const d = g.node<number>([a], body);
+	const sink = subscribeCounts(d);
+	for (let i = 0; i < turns; i++) d.replaceDeps([i % 2 === 0 ? b : a], body);
+	const delivered = sink.dataCount();
+	const expected = turns + 1;
+	sink.unsubscribe();
+	return `turns=${turns}, ${expectEqual("DATA deliveries", delivered, expected)}`;
+}
+
+function boundaryFifoProbe(tasks = 20_000): string {
+	const g = graph();
+	const owner = g.state(0);
+	let ran = 0;
+	batch(() => {
+		for (let i = 0; i < tasks; i++) owner.__deferBoundary(() => ran++);
+	});
+	return `tasks=${tasks}, ${expectEqual("drained", ran, tasks)}`;
+}
+
+function retainedLifecycleProbe(nodes = 2_500, payloadBytes = 4_096): string {
+	let cleanupBytes = 0;
+	for (let i = 0; i < nodes; i++) {
+		const src = node<number>([], null, { initial: i });
+		const payload = new Uint8Array(payloadBytes);
+		const d = node<number>([src], (ctx) => {
+			ctx.onDeactivation(() => {
+				cleanupBytes += payload.byteLength;
+			});
+			ctx.down([["DATA", depLatest(ctx, 0)]]);
+		});
+		const unsubscribe = d.subscribe(() => {});
+		unsubscribe();
+	}
+	const expectedBytes = nodes * payloadBytes;
+	return `nodes=${nodes}, payload=${payloadBytes} bytes, ${expectEqual("cleanup bytes", cleanupBytes, expectedBytes)}`;
+}
+
+const probes: Array<[string, () => string, ProbeOpts?]> = [
+	["boundary FIFO queue", () => boundaryFifoProbe(), { repeats: 7, warmups: 2 }],
+	["fanout DATA push", () => fanoutProbe(), { repeats: 5, warmups: 1 }],
+	["INVALIDATE set-only baseline", () => invalidateSetOnlyProbe(), { repeats: 5, warmups: 1 }],
+	[
+		"INVALIDATE set+invalidate",
+		() => invalidateSetPlusInvalidateProbe(),
+		{ repeats: 5, warmups: 1 },
+	],
+	["diamond pending join", () => diamondProbe(), { repeats: 5, warmups: 1 }],
+	["rewire churn", () => rewireChurnProbe(), { repeats: 5, warmups: 1 }],
+	["active lifecycle retained cleanup", () => retainedLifecycleProbe(), { repeats: 5, warmups: 1 }],
+];
+
+const results = probes.map(([name, run, opts]) => measure(name, run, opts));
+
+console.log("B49 TypeScript probe (informational, not a CI gate)");
+console.log(`node=${process.version}`);
+for (const r of results) {
+	console.log(
+		`${r.name}: median=${fmt(r.medianMs)} ms, min=${fmt(r.minMs)} ms, max=${fmt(r.maxMs)} ms, repeats=${r.repeats}; ${r.notes}`,
+	);
+}
diff --git a/packages/ts/src/__tests__/adapters.nestjs.e2e.test.ts b/packages/ts/src/__tests__/adapters.nestjs.e2e.test.ts
new file mode 100644
index 00000000..f8e93489
--- /dev/null
+++ b/packages/ts/src/__tests__/adapters.nestjs.e2e.test.ts
@@ -0,0 +1,707 @@
+import "reflect-metadata";
+import type { AddressInfo } from "node:net";
+import { Controller, type INestApplication, Module, Post } from "@nestjs/common";
+import { NestFactory } from "@nestjs/core";
+import {
+	type ClientProxy,
+	ClientProxyFactory,
+	MessagePattern,
+	Transport,
+} from "@nestjs/microservices";
+import { WsAdapter } from "@nestjs/platform-ws";
+import { SubscribeMessage, WebSocketGateway } from "@nestjs/websockets";
+import { firstValueFrom } from "rxjs";
+import { afterEach, describe, expect, it } from "vitest";
+import {
+	fromNestMessage,
+	GRAPHREFLY_NEST_MESSAGE_BRIDGE,
+	GraphMessage,
+	type GraphMessageBridge,
+	GraphMessageReply,
+	provideGraphMessageProviders,
+} from "../adapters/nestjs/microservices.js";
+import { provideGraphBoundaryInterceptor } from "../adapters/nestjs/native.js";
+import {
+	fromNestWs,
+	GRAPHREFLY_NEST_WS_BRIDGE,
+	GraphWs,
+	GraphWsAck,
+	type GraphWsBridge,
+	GraphWsReply,
+	provideGraphWsProviders,
+} from "../adapters/nestjs/websockets.js";
+import {
+	fromNestReq,
+	GraphHttpReply,
+	GraphReq,
+	type NestBoundaryEnvelope,
+	type NestReplyEnvelope,
+} from "../adapters/nestjs.js";
+import { depLatest } from "../ctx/types.js";
+import { graph } from "../graph/index.js";
+
+interface E2eHttpHost {
+	readonly requestId: string;
+	readonly body: { readonly orderId?: string; readonly hidden?: unknown };
+	readonly headers?: Record<string, string | string[] | undefined>;
+}
+
+interface E2eWsHost {
+	readonly requestId: string;
+	readonly payload: { readonly orderId: string };
+	readonly client: object;
+	readonly ack: (payload: unknown, envelope: NestReplyEnvelope<unknown>) => void;
+}
+
+interface E2eMessageHost {
+	readonly requestId: string;
+	readonly payload: { readonly orderId: string };
+	readonly context: object;
+}
+
+interface E2eNestHarness {
+	readonly app: INestApplication;
+	readonly url: string;
+	readonly tcpPort: number;
+	readonly wsGateway: {
+		handle(
+			bodyOrClient: WsMessageBody | object,
+			clientOrBody: object | WsMessageBody,
+			ack?: E2eWsHost["ack"],
+		): unknown;
+		pending(body: WsMessageBody, client: object, ack: E2eWsHost["ack"]): unknown;
+		handleDisconnect(client: object): void;
+	};
+	readonly messageController: {
+		handle(body: MessagePatternBody, context: object): unknown;
+		pending(body: MessagePatternBody, context: object): unknown;
+	};
+	readonly wsBridge: GraphWsBridge<E2eWsHost>;
+	readonly messageBridge: GraphMessageBridge<E2eMessageHost>;
+	readonly httpSeen: NestBoundaryEnvelope[];
+	readonly wsSeen: NestBoundaryEnvelope[];
+	readonly messageSeen: NestBoundaryEnvelope[];
+	readonly graphJson: () => string;
+	readonly close: () => Promise<void>;
+}
+
+interface WsMessageBody {
+	readonly requestId: string;
+	readonly payload: { readonly orderId: string };
+}
+
+interface MessagePatternBody {
+	readonly requestId: string;
+	readonly payload: { readonly orderId: string };
+}
+
+const openHarnesses: E2eNestHarness[] = [];
+const openClients: ClientProxy[] = [];
+
+afterEach(async () => {
+	for (const client of openClients.splice(0).reverse()) client.close();
+	for (const harness of openHarnesses.splice(0).reverse()) await harness.close();
+});
+
+describe("NestJS v1 e2e wiring (D488/D489)", () => {
+	it("runs HTTP, WebSocket, and message-pattern bridges without host handle DATA", async () => {
+		const harness = await createE2eNestHarness();
+		openHarnesses.push(harness);
+
+		const response = await fetch(`${harness.url}/orders`, {
+			method: "POST",
+			headers: {
+				"content-type": "application/json",
+				"x-request-id": "req-http-1",
+			},
+			body: JSON.stringify({ orderId: "ord-http-1", hidden: "selected-out" }),
+		});
+		const body = await response.json();
+
+		expect(response.status).toBe(201);
+		expect(body).toEqual({
+			ok: true,
+			kind: "http",
+			orderId: "ord-http-1",
+			requestId: "req-http-1",
+		});
+		expect(harness.httpSeen).toEqual([
+			{
+				bindingId: "http.e2e.in",
+				version: 1,
+				requestId: "req-http-1",
+				payload: { orderId: "ord-http-1" },
+			},
+		]);
+		expect(JSON.stringify(harness.httpSeen[0])).not.toContain("headers");
+		expect(JSON.stringify(harness.httpSeen[0])).not.toContain("hidden");
+
+		const ackCalls: unknown[] = [];
+		const socket = { id: "socket-e2e" };
+		const wsReply = await harness.wsGateway.handle(
+			{ requestId: "req-ws-1", payload: { orderId: "ord-ws-1" } },
+			socket,
+			(payload, envelope) => ackCalls.push({ payload, envelope }),
+		);
+
+		expect(ackCalls).toEqual([
+			{
+				payload: { accepted: true, orderId: "ord-ws-1" },
+				envelope: {
+					bindingId: "ws.e2e.ack",
+					version: 1,
+					requestId: "req-ws-1",
+					payload: { accepted: true, orderId: "ord-ws-1" },
+				},
+			},
+		]);
+		expect(wsReply).toEqual({ ok: true, kind: "ws", orderId: "ord-ws-1" });
+		expect(harness.wsSeen).toEqual([
+			{
+				bindingId: "ws.e2e.in",
+				version: 1,
+				requestId: "req-ws-1",
+				payload: { orderId: "ord-ws-1" },
+			},
+		]);
+		expect(JSON.stringify(harness.wsSeen[0])).not.toContain("socket-e2e");
+		expect(JSON.stringify(harness.wsSeen[0])).not.toContain("ack");
+		expect(harness.wsBridge.diagnostics().map((diagnostic) => diagnostic.kind)).toEqual([
+			"binding-mismatch",
+			"stale-egress",
+		]);
+
+		const messageReply = await harness.messageController.handle(
+			{ requestId: "req-message-1", payload: { orderId: "ord-message-1" } },
+			{ id: "message-context" },
+		);
+
+		expect(messageReply).toEqual({
+			ok: true,
+			kind: "message",
+			orderId: "ord-message-1",
+		});
+		expect(harness.messageSeen).toEqual([
+			{
+				bindingId: "message.e2e.in",
+				version: 1,
+				requestId: "req-message-1",
+				payload: { orderId: "ord-message-1" },
+			},
+		]);
+		expect(JSON.stringify(harness.messageSeen[0])).not.toContain("message-context");
+		expect(harness.messageBridge.diagnostics().map((diagnostic) => diagnostic.kind)).toEqual([
+			"binding-mismatch",
+			"stale-egress",
+		]);
+		expect(harness.graphJson()).not.toContain("socket-e2e");
+		expect(harness.graphJson()).not.toContain("message-context");
+
+		const disconnectSocket = { id: "socket-disconnect" };
+		const disconnected = harness.wsGateway.pending(
+			{ requestId: "req-ws-disconnect", payload: { orderId: "ord-ws-disconnect" } },
+			disconnectSocket,
+			() => undefined,
+		);
+		harness.wsGateway.handleDisconnect(disconnectSocket);
+		await expect(disconnected).rejects.toThrow(/disconnected/);
+		expect(harness.wsBridge.diagnostics().map((diagnostic) => diagnostic.kind)).toContain(
+			"dispose-pending",
+		);
+
+		const wsPending = harness.wsGateway.pending(
+			{ requestId: "req-ws-close", payload: { orderId: "ord-ws-close" } },
+			{ id: "socket-close" },
+			() => undefined,
+		);
+		const messagePending = harness.messageController.pending(
+			{ requestId: "req-message-close", payload: { orderId: "ord-message-close" } },
+			{ id: "message-close-context" },
+		);
+		const wsPendingRejected = expect(wsPending).rejects.toThrow(/disposed/);
+		const messagePendingRejected = expect(messagePending).rejects.toThrow(/disposed/);
+		await harness.close();
+		await wsPendingRejected;
+		await messagePendingRejected;
+	});
+
+	it("accepts live WebSocket and TCP transport traffic as test-only coverage over existing APIs", async () => {
+		const harness = await createE2eNestHarness();
+		openHarnesses.push(harness);
+
+		const socket = await openWebSocket(harness.url);
+		try {
+			const liveWsReply = nextWebSocketJson(socket);
+			socket.send(
+				JSON.stringify({
+					event: "orders",
+					data: {
+						requestId: "req-ws-live",
+						payload: { orderId: "ord-ws-live" },
+					},
+				}),
+			);
+
+			await expect(liveWsReply).resolves.toEqual({
+				ok: true,
+				kind: "ws",
+				orderId: "ord-ws-live",
+			});
+		} finally {
+			socket.close();
+		}
+
+		expect(harness.wsSeen).toEqual([
+			{
+				bindingId: "ws.e2e.in",
+				version: 1,
+				requestId: "req-ws-live",
+				payload: { orderId: "ord-ws-live" },
+			},
+		]);
+		expect(harness.graphJson()).not.toContain("WebSocket");
+		expect(harness.graphJson()).not.toContain("readyState");
+
+		const client = ClientProxyFactory.create({
+			transport: Transport.TCP,
+			options: { host: "127.0.0.1", port: harness.tcpPort },
+		});
+		openClients.push(client);
+		await client.connect();
+		const liveMessageReply = await firstValueFrom(
+			client.send("orders.e2e", {
+				requestId: "req-message-live",
+				payload: { orderId: "ord-message-live" },
+			}),
+		);
+
+		expect(liveMessageReply).toEqual({
+			ok: true,
+			kind: "message",
+			orderId: "ord-message-live",
+		});
+		expect(harness.messageSeen).toEqual([
+			{
+				bindingId: "message.e2e.in",
+				version: 1,
+				requestId: "req-message-live",
+				payload: { orderId: "ord-message-live" },
+			},
+		]);
+		expect(harness.graphJson()).not.toContain("message-context");
+	});
+});
+
+async function createE2eNestHarness(): Promise<E2eNestHarness> {
+	const g = graph({ name: "nestjs-e2e" });
+	const httpSeen: NestBoundaryEnvelope[] = [];
+	const wsSeen: NestBoundaryEnvelope[] = [];
+	const messageSeen: NestBoundaryEnvelope[] = [];
+
+	const httpIn = fromNestReq<E2eHttpHost, { readonly orderId?: string }>(g, {
+		bindingId: "node.http.e2e.in",
+	});
+	httpIn.node.subscribe((msg) => msg[0] === "DATA" && httpSeen.push(msg[1]));
+	const httpReply = g.node<NestReplyEnvelope<unknown>>(
+		[httpIn.node],
+		(ctx) => {
+			const envelope = depLatest(ctx, 0) as NestBoundaryEnvelope<{ readonly orderId?: string }>;
+			if (envelope.requestId === undefined) return;
+			ctx.down([
+				[
+					"DATA",
+					{
+						bindingId: "http.e2e.wrong",
+						version: 1,
+						requestId: envelope.requestId,
+						payload: { status: 599, body: { wrong: true } },
+					},
+				],
+				[
+					"DATA",
+					{
+						bindingId: "http.e2e.out",
+						version: 1,
+						requestId: envelope.requestId,
+						payload: {
+							status: 201,
+							body: {
+								ok: true,
+								kind: "http",
+								orderId: envelope.payload.orderId,
+								requestId: envelope.requestId,
+							},
+						},
+					},
+				],
+			]);
+		},
+		{ name: "http.e2e.out" },
+	);
+
+	const wsIn = fromNestWs<E2eWsHost, { readonly orderId: string }>(g, {
+		bindingId: "node.ws.e2e.in",
+	});
+	wsIn.node.subscribe((msg) => msg[0] === "DATA" && wsSeen.push(msg[1]));
+	const wsAck = g.node<NestReplyEnvelope<unknown>>(
+		[wsIn.node],
+		(ctx) => {
+			const envelope = depLatest(ctx, 0) as NestBoundaryEnvelope<{ readonly orderId: string }>;
+			if (envelope.requestId === undefined) return;
+			ctx.down([
+				[
+					"DATA",
+					{
+						bindingId: "ws.e2e.other",
+						version: 1,
+						requestId: envelope.requestId,
+						payload: { ignored: true },
+					},
+				],
+				[
+					"DATA",
+					{
+						bindingId: "ws.e2e.ack",
+						version: 1,
+						requestId: "req-ws-stale",
+						payload: { stale: true },
+					},
+				],
+				[
+					"DATA",
+					{
+						bindingId: "ws.e2e.ack",
+						version: 1,
+						requestId: envelope.requestId,
+						payload: { accepted: true, orderId: envelope.payload.orderId },
+					},
+				],
+			]);
+		},
+		{ name: "ws.e2e.ack" },
+	);
+	const wsReply = g.node<NestReplyEnvelope<unknown>>(
+		[wsIn.node],
+		(ctx) => {
+			const envelope = depLatest(ctx, 0) as NestBoundaryEnvelope<{ readonly orderId: string }>;
+			if (envelope.requestId === undefined) return;
+			ctx.down([
+				[
+					"DATA",
+					{
+						bindingId: "ws.e2e.reply",
+						version: 1,
+						requestId: envelope.requestId,
+						payload: { ok: true, kind: "ws", orderId: envelope.payload.orderId },
+					},
+				],
+			]);
+		},
+		{ name: "ws.e2e.reply" },
+	);
+
+	const messageIn = fromNestMessage<E2eMessageHost, { readonly orderId: string }>(g, {
+		bindingId: "node.message.e2e.in",
+	});
+	messageIn.node.subscribe((msg) => msg[0] === "DATA" && messageSeen.push(msg[1]));
+	const messageReply = g.node<NestReplyEnvelope<unknown>>(
+		[messageIn.node],
+		(ctx) => {
+			const envelope = depLatest(ctx, 0) as NestBoundaryEnvelope<{ readonly orderId: string }>;
+			if (envelope.requestId === undefined) return;
+			ctx.down([
+				[
+					"DATA",
+					{
+						bindingId: "message.e2e.other",
+						version: 1,
+						requestId: envelope.requestId,
+						payload: { ignored: true },
+					},
+				],
+				[
+					"DATA",
+					{
+						bindingId: "message.e2e.reply",
+						version: 1,
+						requestId: "req-message-stale",
+						payload: { stale: true },
+					},
+				],
+				[
+					"DATA",
+					{
+						bindingId: "message.e2e.reply",
+						version: 1,
+						requestId: envelope.requestId,
+						payload: { ok: true, kind: "message", orderId: envelope.payload.orderId },
+					},
+				],
+			]);
+		},
+		{ name: "message.e2e.reply" },
+	);
+	const wsPendingIn = fromNestWs<E2eWsHost, { readonly orderId: string }>(g, {
+		bindingId: "node.ws.e2e.pending.in",
+	});
+	const wsPendingReply = g.node<NestReplyEnvelope<unknown>>([], null, {
+		name: "ws.e2e.pending.reply",
+	});
+	const messagePendingIn = fromNestMessage<E2eMessageHost, { readonly orderId: string }>(g, {
+		bindingId: "node.message.e2e.pending.in",
+	});
+	const messagePendingReply = g.node<NestReplyEnvelope<unknown>>([], null, {
+		name: "message.e2e.pending.reply",
+	});
+
+	class E2eHttpController {
+		create(): void {}
+	}
+
+	class E2eWsGateway {
+		bridge?: GraphWsBridge<E2eWsHost>;
+
+		handle(
+			bodyOrClient: WsMessageBody | object,
+			clientOrBody: object | WsMessageBody,
+			ack: E2eWsHost["ack"] = () => undefined,
+		): unknown {
+			if (this.bridge === undefined) throw new Error("GraphWsBridge was not attached");
+			const [client, body] = isWsMessageBody(bodyOrClient)
+				? [clientOrBody as object, bodyOrClient]
+				: [bodyOrClient, clientOrBody as WsMessageBody];
+			return this.bridge.handleMessage(E2eWsGateway, "handle", {
+				requestId: body.requestId,
+				payload: body.payload,
+				client,
+				ack,
+			});
+		}
+
+		pending(body: WsMessageBody, client: object, ack: E2eWsHost["ack"]): unknown {
+			if (this.bridge === undefined) throw new Error("GraphWsBridge was not attached");
+			return this.bridge.handleMessage(E2eWsGateway, "pending", {
+				requestId: body.requestId,
+				payload: body.payload,
+				client,
+				ack,
+			});
+		}
+
+		handleDisconnect(client: object): void {
+			if (this.bridge === undefined) throw new Error("GraphWsBridge was not attached");
+			this.bridge.handleDisconnect(client);
+		}
+	}
+
+	class E2eMessageController {
+		bridge?: GraphMessageBridge<E2eMessageHost>;
+
+		handle(body: MessagePatternBody, context: object): unknown {
+			if (this.bridge === undefined) throw new Error("GraphMessageBridge was not attached");
+			return this.bridge.handleMessage(E2eMessageController, "handle", {
+				requestId: body.requestId,
+				payload: body.payload,
+				context,
+			});
+		}
+
+		pending(body: MessagePatternBody, context: object): unknown {
+			if (this.bridge === undefined) throw new Error("GraphMessageBridge was not attached");
+			return this.bridge.handleMessage(E2eMessageController, "pending", {
+				requestId: body.requestId,
+				payload: body.payload,
+				context,
+			});
+		}
+	}
+
+	applyClassDecorator(Controller(), E2eHttpController);
+	applyMethodDecorators(
+		E2eHttpController.prototype,
+		"create",
+		Post("orders"),
+		GraphReq(httpIn, {
+			bindingId: "http.e2e.in",
+			requestId: (host: E2eHttpHost) => host.requestId,
+			payload: (host: E2eHttpHost) => ({ orderId: host.body.orderId }),
+		}),
+		GraphHttpReply(httpReply, { bindingId: "http.e2e.out" }),
+	);
+
+	applyClassDecorator(WebSocketGateway(), E2eWsGateway);
+	applyMethodDecorators(
+		E2eWsGateway.prototype,
+		"handle",
+		SubscribeMessage("orders"),
+		GraphWs(wsIn, {
+			bindingId: "ws.e2e.in",
+			requestId: (host: E2eWsHost) => host.requestId,
+			payload: (host: E2eWsHost) => host.payload,
+		}),
+		GraphWsAck(wsAck, { bindingId: "ws.e2e.ack" }),
+		GraphWsReply(wsReply, { bindingId: "ws.e2e.reply" }),
+	);
+	applyMethodDecorators(
+		E2eWsGateway.prototype,
+		"pending",
+		SubscribeMessage("orders.pending"),
+		GraphWs(wsPendingIn, {
+			bindingId: "ws.e2e.pending.in",
+			requestId: (host: E2eWsHost) => host.requestId,
+			payload: (host: E2eWsHost) => host.payload,
+		}),
+		GraphWsReply(wsPendingReply, { bindingId: "ws.e2e.pending.reply" }),
+	);
+
+	applyClassDecorator(Controller(), E2eMessageController);
+	applyMethodDecorators(
+		E2eMessageController.prototype,
+		"handle",
+		MessagePattern("orders.e2e"),
+		GraphMessage(messageIn, {
+			bindingId: "message.e2e.in",
+			requestId: (host: E2eMessageHost) => host.requestId,
+			payload: (host: E2eMessageHost) => host.payload,
+		}),
+		GraphMessageReply(messageReply, { bindingId: "message.e2e.reply" }),
+	);
+	applyMethodDecorators(
+		E2eMessageController.prototype,
+		"pending",
+		MessagePattern("orders.e2e.pending"),
+		GraphMessage(messagePendingIn, {
+			bindingId: "message.e2e.pending.in",
+			requestId: (host: E2eMessageHost) => host.requestId,
+			payload: (host: E2eMessageHost) => host.payload,
+		}),
+		GraphMessageReply(messagePendingReply, { bindingId: "message.e2e.pending.reply" }),
+	);
+
+	class E2eAppModule {}
+	applyClassDecorator(
+		Module({
+			controllers: [E2eHttpController, E2eMessageController],
+			providers: [
+				E2eWsGateway,
+				provideGraphBoundaryInterceptor({
+					host: (context) => {
+						const req = context.switchToHttp().getRequest<{
+							body?: E2eHttpHost["body"];
+							headers?: E2eHttpHost["headers"];
+						}>();
+						const requestId = req.headers?.["x-request-id"];
+						return {
+							requestId: Array.isArray(requestId) ? requestId[0] : (requestId ?? "req-http"),
+							body: req.body ?? {},
+							headers: req.headers,
+						};
+					},
+					requestId: (host: E2eHttpHost) => host.requestId,
+				}),
+				...provideGraphWsProviders<E2eWsHost>({
+					bridge: {
+						ack: (host) => host.ack,
+						client: (host) => host.client,
+					},
+				}),
+				...provideGraphMessageProviders<E2eMessageHost>(),
+			],
+		}),
+		E2eAppModule,
+	);
+
+	const app = await NestFactory.create(E2eAppModule, { logger: false });
+	const attachWsAdapter = app.useWebSocketAdapter.bind(app);
+	attachWsAdapter(new WsAdapter(app));
+	const microservice = app.connectMicroservice({
+		transport: Transport.TCP,
+		options: { host: "127.0.0.1", port: 0 },
+	});
+	await app.startAllMicroservices();
+	const tcpPort = tcpPortFor(microservice.unwrap());
+	await app.listen(0, "127.0.0.1");
+	const wsGateway = app.get(E2eWsGateway);
+	const messageController = app.get(E2eMessageController, { strict: false });
+	const wsBridge = app.get<GraphWsBridge<E2eWsHost>>(GRAPHREFLY_NEST_WS_BRIDGE);
+	const messageBridge = app.get<GraphMessageBridge<E2eMessageHost>>(GRAPHREFLY_NEST_MESSAGE_BRIDGE);
+	wsGateway.bridge = wsBridge;
+	messageController.bridge = messageBridge;
+
+	let closed = false;
+	return {
+		app,
+		url: await app.getUrl(),
+		tcpPort,
+		wsGateway,
+		messageController,
+		wsBridge,
+		messageBridge,
+		httpSeen,
+		wsSeen,
+		messageSeen,
+		graphJson: () => JSON.stringify(g.describe()),
+		close: async () => {
+			if (closed) return;
+			closed = true;
+			await app.close();
+		},
+	};
+}
+
+function isWsMessageBody(value: unknown): value is WsMessageBody {
+	return value !== null && typeof value === "object" && "requestId" in value && "payload" in value;
+}
+
+function tcpPortFor(server: unknown): number {
+	const address =
+		server !== null && typeof server === "object" && "address" in server
+			? (server as { address: () => AddressInfo | string | null }).address()
+			: undefined;
+	if (address === null || address === undefined || typeof address === "string") {
+		throw new Error("Nest TCP live acceptance test could not resolve a random TCP port");
+	}
+	return address.port;
+}
+
+async function openWebSocket(baseUrl: string): Promise<WebSocket> {
+	const url = baseUrl.replace(/^http:/, "ws:").replace(/^https:/, "wss:");
+	const socket = new WebSocket(url);
+	await new Promise<void>((resolve, reject) => {
+		socket.addEventListener("open", () => resolve(), { once: true });
+		socket.addEventListener("error", () => reject(new Error("WebSocket connection failed")), {
+			once: true,
+		});
+	});
+	return socket;
+}
+
+function nextWebSocketJson(socket: WebSocket): Promise<unknown> {
+	return new Promise((resolve, reject) => {
+		socket.addEventListener(
+			"message",
+			(event) => {
+				try {
+					resolve(JSON.parse(String(event.data)));
+				} catch (error) {
+					reject(error);
+				}
+			},
+			{ once: true },
+		);
+	});
+}
+
+function applyClassDecorator(decorator: ClassDecorator, target: abstract new () => unknown): void {
+	decorator(target);
+}
+
+function applyMethodDecorators(
+	prototype: object,
+	methodKey: string,
+	...decorators: MethodDecorator[]
+): void {
+	const descriptor = Object.getOwnPropertyDescriptor(prototype, methodKey);
+	if (descriptor === undefined) throw new Error(`Missing descriptor for ${methodKey}`);
+	for (const decorator of decorators) decorator(prototype, methodKey, descriptor);
+}
diff --git a/packages/ts/src/__tests__/adapters.test.ts b/packages/ts/src/__tests__/adapters.test.ts
new file mode 100644
index 00000000..ed2821d8
--- /dev/null
+++ b/packages/ts/src/__tests__/adapters.test.ts
@@ -0,0 +1,2779 @@
+import { APP_FILTER, APP_GUARD, APP_INTERCEPTOR } from "@nestjs/core";
+import { describe, expect, it, vi } from "vitest";
+import {
+	externalStore,
+	jotaiAtom,
+	nanoAtom,
+	nodeSnapshot,
+	readableStore,
+	recordReadableStore,
+	signalFromNode,
+	subscribeNodeValues,
+	writableStore,
+	zustandStore,
+} from "../adapters/index.js";
+import {
+	createGraphMessageBridge,
+	fromNestMessage,
+	GRAPHREFLY_NEST_MESSAGE_BRIDGE,
+	GraphMessage,
+	type GraphMessageBridge,
+	GraphMessageReply,
+	provideGraphMessageProviders,
+} from "../adapters/nestjs/microservices.js";
+import {
+	createGraphCronController,
+	createGraphExceptionFilter,
+	createGraphGuardDeniedFilter,
+	GraphGuardDeniedException,
+	GraphGuardDeniedFilter,
+	graphCronTarget,
+	graphLifecycleTarget,
+	isGraphGuardDeniedException,
+	provideGraphBoundaryInterceptor,
+	provideGraphCronScheduler,
+	provideGraphExceptionFilter,
+	provideGraphGuard,
+	provideGraphGuardDeniedFilter,
+	provideGraphLifecycleHooks,
+	provideGraphNativeHttpProviders,
+	provideGraphNativeProviders,
+} from "../adapters/nestjs/native.js";
+import {
+	createGraphWsBridge,
+	fromNestWs,
+	GRAPHREFLY_NEST_WS_BRIDGE,
+	GraphWs,
+	GraphWsAck,
+	type GraphWsBridge,
+	GraphWsReply,
+	provideGraphWsProviders,
+} from "../adapters/nestjs/websockets.js";
+import {
+	createNestGraphBoundaryInterceptor,
+	createNestGraphBoundaryRunner,
+	fromNestCron,
+	fromNestDiagnostics,
+	fromNestError,
+	fromNestGuard,
+	fromNestIntercept,
+	fromNestLifecycle,
+	fromNestReq,
+	GRAPHREFLY_REQUEST_GRAPH,
+	GRAPHREFLY_ROOT_GRAPH,
+	GraphCron,
+	GraphError,
+	GraphFilter,
+	GraphGuard,
+	GraphGuardDecision,
+	type GraphGuardDecision as GraphGuardDecisionPayload,
+	GraphHttpReply,
+	GraphInterval,
+	GraphLifecycle,
+	GraphReq,
+	getGraphToken,
+	getNestBoundaryBindings,
+	getNestBoundaryToken,
+	getNodeToken,
+	type HttpDataIssue,
+	issueResponse,
+	lowerHttpReplyPayload,
+	lowerProtocolError,
+	NEST_BOUNDARY_BINDINGS,
+	CRON_HANDLERS as NEST_CRON_HANDLERS,
+	EVENT_HANDLERS as NEST_EVENT_HANDLERS,
+	INTERVAL_HANDLERS as NEST_INTERVAL_HANDLERS,
+	type NestBoundaryEnvelope,
+	type NestDiagnosticIngressBoundary,
+	type NestReplyEnvelope,
+	nestProvider,
+	OnGraphEvent,
+	protocolError,
+	sanitizeNestDiagnostic,
+	toNestHttp,
+} from "../adapters/nestjs.js";
+import { depLatest } from "../ctx/types.js";
+import { graph } from "../graph/index.js";
+
+describe("framework-neutral store adapters (B61)", () => {
+	it("adapts a node to a readable store with one immediate snapshot", () => {
+		const g = graph();
+		const count = g.state(1);
+		const store = readableStore(count);
+		const seen: Array<number | undefined> = [];
+
+		const unsubscribe = store.subscribe((value) => seen.push(value));
+		count.set(2);
+		unsubscribe();
+		count.set(3);
+
+		expect(store.get()).toBe(3);
+		expect(seen).toEqual([1, 2]);
+		expect(nodeSnapshot(count)).toBe(3);
+	});
+
+	it("adapts a StateNode to a writable store", () => {
+		const g = graph();
+		const count = g.state(1);
+		const store = writableStore(count);
+		const seen: Array<number | undefined> = [];
+
+		const unsubscribe = store.subscribe((value) => seen.push(value));
+		store.set(2);
+		store.update((value) => (value ?? 0) + 3);
+		unsubscribe();
+
+		expect(store.get()).toBe(5);
+		expect(count.cache).toBe(5);
+		expect(seen).toEqual([1, 2, 5]);
+	});
+
+	it("supports change-only value subscriptions", () => {
+		const g = graph();
+		const count = g.state(1);
+		const seen: Array<number | undefined> = [];
+
+		const unsubscribe = subscribeNodeValues(count, (value) => seen.push(value), {
+			changesOnly: true,
+		});
+		count.set(2);
+		unsubscribe();
+		count.set(3);
+
+		expect(seen).toEqual([2]);
+	});
+
+	it("keeps activation DATA while suppressing cached and replayed subscribe history", () => {
+		const g = graph();
+		const count = g.state(2);
+		const doubled = g.derived([count], (value) => value * 2);
+		const coldSeen: Array<number | undefined> = [];
+
+		const unsubscribeCold = readableStore(doubled).subscribe((value) => coldSeen.push(value));
+		unsubscribeCold();
+
+		const replayed = g.node<number>([], null, { replayBuffer: 3 });
+		replayed.down([
+			["DATA", 1],
+			["DATA", 2],
+			["DATA", 3],
+		]);
+		const changes: Array<number | undefined> = [];
+		const unsubscribeChanges = subscribeNodeValues(replayed, (value) => changes.push(value), {
+			changesOnly: true,
+		});
+		replayed.down([["DATA", 4]]);
+		unsubscribeChanges();
+
+		expect(coldSeen).toEqual([undefined, 4]);
+		expect(changes).toEqual([4]);
+	});
+
+	it("routes ERROR and COMPLETE lifecycle messages without exposing protocol internals as values", () => {
+		const g = graph();
+		const source = g.node<number>([], null, { resubscribable: true });
+		const values: Array<number | undefined> = [];
+		const errors: unknown[] = [];
+		const complete = vi.fn();
+
+		const unsubscribe = subscribeNodeValues(source, (value) => values.push(value), {
+			onError: (error) => errors.push(error),
+			onComplete: complete,
+		});
+
+		source.down([["DATA", 1]]);
+		const err = new Error("boom");
+		source.down([["ERROR", err]]);
+
+		expect(values).toEqual([1]);
+		expect(errors).toEqual([err]);
+		expect(complete).not.toHaveBeenCalled();
+
+		unsubscribe();
+
+		const next = g.node<number>([], null);
+		subscribeNodeValues(next, (value) => values.push(value), { onComplete: complete });
+		next.down([["COMPLETE"]]);
+		expect(complete).toHaveBeenCalledTimes(1);
+	});
+
+	it("builds a React-compatible external-store shape without importing React", () => {
+		const g = graph();
+		const count = g.state(1);
+		const store = externalStore(count);
+		const changed = vi.fn();
+
+		const unsubscribe = store.subscribe(changed);
+		expect(store.getSnapshot()).toBe(1);
+		expect(store.getServerSnapshot()).toBe(1);
+
+		count.set(2);
+		unsubscribe();
+		count.set(3);
+
+		expect(changed).toHaveBeenCalledTimes(1);
+		expect(store.getSnapshot()).toBe(3);
+	});
+
+	it("builds a keyed record store without framework hooks", () => {
+		const g = graph();
+		const keys = g.state<readonly string[]>(["a"]);
+		const a = g.state(1);
+		const b = g.state(2);
+		const values: Record<string, typeof a> = { a, b };
+		const store = recordReadableStore(keys, (key) => ({ value: values[key] }));
+		const seen: Array<Record<string, { value: number }>> = [];
+
+		const unsubscribe = store.subscribe((snapshot) => {
+			seen.push(snapshot as Record<string, { value: number }>);
+		});
+		values.a.set(3);
+		keys.set(["a", "b"]);
+		values.b.set(4);
+		unsubscribe();
+		values.a.set(5);
+
+		expect(seen).toEqual([
+			{ a: { value: 1 } },
+			{ a: { value: 3 } },
+			{ a: { value: 3 }, b: { value: 2 } },
+			{ a: { value: 3 }, b: { value: 4 } },
+		]);
+	});
+
+	it("builds Zustand/Jotai/Nanostores/signals-style facades over caller-owned nodes", () => {
+		const g = graph();
+		const state = g.state({ count: 1 });
+		const zustand = zustandStore(state);
+		const zustandSeen: Array<readonly [number, number]> = [];
+		const unsubZustand = zustand.subscribe((next, prev) => {
+			zustandSeen.push([next.count, prev.count]);
+		});
+
+		zustand.setState((prev) => ({ count: prev.count + 1 }));
+		zustand.setState({ count: 10 }, true);
+		unsubZustand();
+
+		const jotai = jotaiAtom(state);
+		const nano = nanoAtom(state);
+		const signal = signalFromNode(state);
+		const jotaiSeen: Array<number | undefined> = [];
+		const nanoSeen: Array<number | undefined> = [];
+		const signalSeen: Array<number | undefined> = [];
+
+		const unsubJotai = jotai.subscribe((value) => jotaiSeen.push(value?.count));
+		const unsubNano = nano.listen((value) => nanoSeen.push(value?.count));
+		const unsubSignal = signal.subscribe((value) => signalSeen.push(value?.count));
+
+		jotai.set({ count: 11 });
+		nano.update((value) => ({ count: (value?.count ?? 0) + 1 }));
+		signal.set({ count: 13 });
+		unsubJotai();
+		unsubNano();
+		unsubSignal();
+		zustand.destroy();
+
+		expect(zustandSeen).toEqual([
+			[2, 1],
+			[10, 2],
+		]);
+		expect(jotai.get()?.count).toBe(13);
+		expect(nano.get()?.count).toBe(13);
+		expect(signal.get()?.count).toBe(13);
+		expect(jotaiSeen).toEqual([11, 12, 13]);
+		expect(nanoSeen).toEqual([11, 12, 13]);
+		expect(signalSeen).toEqual([11, 12, 13]);
+	});
+
+	it("delivers custom Zustand snapshots to subscribers instead of raw node DATA", () => {
+		const g = graph();
+		const state = g.state({ count: 1 });
+		const store = zustandStore(
+			state,
+			{ count: 1, inc: () => {} },
+			{
+				getSnapshot: () => ({
+					count: state.cache?.count ?? 0,
+					inc: () => store.setState((prev) => ({ count: prev.count + 1 })),
+				}),
+				write: (_node, value) => state.set({ count: value.count }),
+			},
+		);
+		const seen: Array<{ count: number; hasInc: boolean }> = [];
+		const unsub = store.subscribe((next) => {
+			seen.push({ count: next.count, hasInc: typeof next.inc === "function" });
+		});
+
+		store.setState((prev) => ({ count: prev.count + 1 }));
+		unsub();
+		store.destroy();
+
+		expect(seen).toEqual([{ count: 2, hasInc: true }]);
+	});
+
+	it("requires writable facades to use StateNode.set or an explicit write bridge", () => {
+		const g = graph();
+		const readonly = g.node<number>([], null);
+		const readonlyObject = g.node<{ count: number }>([], null);
+		const unsafeWritableStore = writableStore as unknown as (node: typeof readonly) => unknown;
+		const unsafeZustandStore = zustandStore as unknown as (
+			node: typeof readonlyObject,
+			initialState: { count: number },
+		) => unknown;
+
+		expect(() => unsafeWritableStore(readonly)).toThrow(/set\(value\) or opts\.write/);
+		expect(() => unsafeZustandStore(readonlyObject, { count: 0 })).toThrow(
+			/set\(value\) or opts\.write/,
+		);
+
+		const written: number[] = [];
+		const explicit = writableStore(readonly, {
+			write: (_node, value) => {
+				written.push(value);
+			},
+		});
+		explicit.set(7);
+
+		expect(written).toEqual([7]);
+	});
+
+	it("exposes dependency-free NestJS tokens and method metadata helpers", () => {
+		class Service {
+			handle() {}
+			interval() {}
+		}
+		const eventInitializers: Array<(this: unknown) => void> = [];
+
+		OnGraphEvent("orders::created")(Service.prototype.handle, {
+			name: "handle",
+			addInitializer(fn: (this: unknown) => void) {
+				eventInitializers.push(fn);
+			},
+		} as ClassMethodDecoratorContext);
+		GraphInterval(1000)(Service.prototype, "interval", {
+			value: Service.prototype.interval,
+		});
+
+		const service = new Service();
+		eventInitializers.forEach((fn) => {
+			fn.call(service);
+			fn.call(service);
+		});
+
+		expect(GRAPHREFLY_ROOT_GRAPH).toBe(Symbol.for("graphrefly:root-graph"));
+		expect(GRAPHREFLY_REQUEST_GRAPH).toBe(Symbol.for("graphrefly:request-graph"));
+		expect(getGraphToken("orders")).toBe(Symbol.for("graphrefly:graph:orders"));
+		expect(getNodeToken("orders::created")).toBe(Symbol.for("graphrefly:node:orders::created"));
+		expect(NEST_EVENT_HANDLERS.get(Service)).toEqual([
+			{ nodeName: "orders::created", methodKey: "handle" },
+		]);
+		expect(NEST_CRON_HANDLERS.get(Service)).toBeUndefined();
+		expect(NEST_INTERVAL_HANDLERS.get(Service)).toEqual([{ ms: 1000, methodKey: "interval" }]);
+	});
+
+	it("records concrete D478 GraphReq and GraphHttpReply binding metadata", () => {
+		const g = graph();
+		const req = fromNestReq(g, { bindingId: "node.http.in" });
+		const reply = g.node<NestReplyEnvelope<{ readonly ok: true }>>([], null, {
+			name: "reply/node",
+		});
+		class Controller {
+			post() {}
+		}
+		const initializers: Array<(this: unknown) => void> = [];
+
+		GraphReq(req, { bindingId: "http.orders.create.in" })(Controller.prototype.post, {
+			name: "post",
+			addInitializer(fn: (this: unknown) => void) {
+				initializers.push(fn);
+			},
+		} as ClassMethodDecoratorContext);
+		GraphHttpReply(reply, { bindingId: "http.orders.create.out" })(Controller.prototype.post, {
+			name: "post",
+			addInitializer(fn: (this: unknown) => void) {
+				initializers.push(fn);
+			},
+		} as ClassMethodDecoratorContext);
+
+		const controller = new Controller();
+		initializers.forEach((fn) => {
+			fn.call(controller);
+		});
+
+		const token = getNestBoundaryToken("orders.http");
+		expect(token).toBe(Symbol.for("graphrefly:nest-boundary:orders.http"));
+		expect(nestProvider(token, "value")).toEqual({ provide: token, useValue: "value" });
+		expect(NEST_BOUNDARY_BINDINGS.get(Controller)).toEqual([
+			expect.objectContaining({
+				direction: "ingress",
+				kind: "request",
+				bindingId: "http.orders.create.in",
+				methodKey: "post",
+				boundary: req,
+			}),
+			expect.objectContaining({
+				direction: "egress",
+				kind: "http",
+				bindingId: "http.orders.create.out",
+				methodKey: "post",
+				replyNode: reply,
+			}),
+		]);
+		expect(() => GraphReq(fromNestGuard(g))).toThrow(/expected a request boundary/);
+		expect(() => GraphHttpReply(reply, {} as { readonly bindingId: string })).toThrow(/bindingId/);
+	});
+
+	it("builds keyed Nest ingress envelopes with stable explicit binding ids", () => {
+		const g = graph();
+		const req = fromNestReq<
+			{ requestId: string; body: { readonly orderId: string } },
+			{ readonly orderId: string }
+		>(g, {
+			bindingId: "orders.create",
+			payload: (host) => host.body,
+		});
+		const seen: NestBoundaryEnvelope<{ readonly orderId: string }>[] = [];
+		const unsubscribe = req.node.subscribe((msg) => {
+			if (msg[0] === "DATA")
+				seen.push(msg[1] as NestBoundaryEnvelope<{ readonly orderId: string }>);
+		});
+
+		const envelope = req.emit({ requestId: "req-1", body: { orderId: "o-1" } });
+		unsubscribe();
+
+		expect(req.bindingId).toBe("orders.create");
+		expect(envelope).toEqual({
+			requestId: "req-1",
+			bindingId: "orders.create",
+			version: 1,
+			payload: { orderId: "o-1" },
+		});
+		expect(seen).toEqual([envelope]);
+		expect(g.describe().nodes.some((node) => node.meta?.bindingId === "orders.create")).toBe(true);
+	});
+
+	it("allows lifecycle and cron ingress envelopes without fake request ids", () => {
+		const g = graph();
+		const lifecycle = fromNestLifecycle(g, {
+			bindingId: "lifecycle.app.in",
+			payload: (host: { readonly event: string }) => ({ event: host.event }),
+		});
+		const cron = fromNestCron(g, {
+			bindingId: "cron.daily.in",
+			payload: (host: { readonly tick: string }) => ({ tick: host.tick }),
+		});
+
+		expect(lifecycle.emit({ event: "module-destroy" })).toEqual({
+			bindingId: "lifecycle.app.in",
+			version: 1,
+			payload: { event: "module-destroy" },
+		});
+		expect(cron.emit({ tick: "midnight" })).toEqual({
+			bindingId: "cron.daily.in",
+			version: 1,
+			payload: { tick: "midnight" },
+		});
+	});
+
+	it("uses deterministic non-random binding ids for Nest ingress fallbacks", () => {
+		const g = graph();
+
+		expect(fromNestGuard(g).bindingId).toBe("nestjs.guard");
+		expect(fromNestIntercept(g, { name: "orders.intercept" }).bindingId).toBe("orders.intercept");
+		expect(fromNestError(g, { bindingId: "orders.error" }).bindingId).toBe("orders.error");
+		expect(fromNestLifecycle(g, { bindingId: "app.lifecycle" }).bindingId).toBe("app.lifecycle");
+	});
+
+	it("keeps host-private HTTP handles out of graph DATA and resolves only matching request ids", () => {
+		const g = graph();
+		const egress = g.node<NestReplyEnvelope<{ readonly status: number; readonly body: string }>>(
+			[],
+			null,
+			{ name: "nestjs/http/orders.out" },
+		);
+		const http = toNestHttp(egress, { bindingId: "orders.http" });
+		const resolved: unknown[] = [];
+		const handle = {
+			secret: { socket: true },
+			resolve(payload: unknown) {
+				resolved.push(payload);
+			},
+			reject: vi.fn(),
+		};
+
+		http.attach({ requestId: "req-1", handle });
+		egress.down([
+			[
+				"DATA",
+				{
+					requestId: "req-stale",
+					bindingId: "orders.http",
+					version: 1,
+					payload: { status: 200, body: "stale" },
+				},
+			],
+		]);
+		egress.down([
+			[
+				"DATA",
+				{
+					requestId: "req-1",
+					bindingId: "other.http",
+					version: 1,
+					payload: { status: 200, body: "wrong binding" },
+				},
+			],
+		]);
+		egress.down([
+			[
+				"DATA",
+				{
+					requestId: "req-1",
+					bindingId: "orders.http",
+					version: 1,
+					payload: { status: 201, body: "created" },
+				},
+			],
+		]);
+
+		expect(resolved).toEqual([{ status: 201, body: "created" }]);
+		expect(http.pendingCount()).toBe(0);
+		expect(http.diagnostics().map((diagnostic) => diagnostic.kind)).toEqual([
+			"stale-egress",
+			"binding-mismatch",
+		]);
+		(http.diagnostics() as unknown[]).length = 0;
+		expect(http.diagnostics().map((diagnostic) => diagnostic.kind)).toEqual([
+			"stale-egress",
+			"binding-mismatch",
+		]);
+		expect(JSON.stringify(resolved)).not.toContain("socket");
+		http.dispose();
+	});
+
+	it("matches Nest HTTP egress by request id by default and scopes by binding id only when requested", () => {
+		const g = graph();
+		const egress = g.node<NestReplyEnvelope<{ readonly ok: true }>>([], null, {
+			name: "nestjs/http/default.out",
+		});
+		const http = toNestHttp(egress);
+		const resolved: unknown[] = [];
+
+		http.attach({
+			requestId: "req-1",
+			handle: {
+				resolve(payload) {
+					resolved.push(payload);
+				},
+				reject: vi.fn(),
+			},
+		});
+		egress.down([
+			[
+				"DATA",
+				{ requestId: "req-1", bindingId: "caller.binding", version: 1, payload: { ok: true } },
+			],
+		]);
+
+		expect(resolved).toEqual([{ ok: true }]);
+		expect(http.diagnostics()).toEqual([]);
+		http.dispose();
+	});
+
+	it("rejects future Nest HTTP attaches after terminal egress", () => {
+		const g = graph();
+		const egress = g.node<NestReplyEnvelope<{ readonly ok: true }>>([], null, {
+			name: "nestjs/http/terminal.out",
+		});
+		const http = toNestHttp(egress, { bindingId: "terminal.http" });
+		const error = new Error("terminal boom");
+		const firstRejected: unknown[] = [];
+		const laterRejected: unknown[] = [];
+
+		http.attach({
+			requestId: "req-1",
+			handle: {
+				resolve: vi.fn(),
+				reject(rejected) {
+					firstRejected.push(rejected);
+				},
+			},
+		});
+		egress.down([["ERROR", error]]);
+		const cleanup = http.attach({
+			requestId: "req-2",
+			handle: {
+				resolve: vi.fn(),
+				reject(rejected) {
+					laterRejected.push(rejected);
+				},
+			},
+		});
+
+		expect(firstRejected).toEqual([error]);
+		expect(laterRejected).toEqual([error]);
+		expect(cleanup()).toBe(false);
+		expect(http.pendingCount()).toBe(0);
+		expect(http.diagnostics().map((diagnostic) => diagnostic.kind)).toEqual([
+			"terminal-egress",
+			"terminal-egress",
+		]);
+		http.dispose();
+	});
+
+	it("brackets decorator-bound attach, emit, and cleanup in the high-level runner", async () => {
+		const g = graph();
+		const req = fromNestReq<
+			{ readonly requestId: string; readonly body: { readonly ok: true }; readonly fail?: boolean },
+			{ readonly ok: true }
+		>(g, {
+			bindingId: "node.orders.in",
+			requestId: (host) => host.requestId,
+			payload: (host) => {
+				if (host.fail) throw new Error("payload failed");
+				return host.body;
+			},
+		});
+		const reply = g.node<NestReplyEnvelope<{ readonly ok: true }>>(
+			[req.node],
+			(ctx) => {
+				const envelope = depLatest(ctx, 0) as NestBoundaryEnvelope<{ readonly ok: true }>;
+				if (envelope.requestId === undefined) return;
+				ctx.down([
+					[
+						"DATA",
+						{
+							requestId: envelope.requestId,
+							bindingId: "http.orders.out",
+							version: 1,
+							payload: envelope.payload,
+						},
+					],
+				]);
+			},
+			{ name: "http.orders.out" },
+		);
+		class Controller {
+			post() {}
+		}
+		GraphReq(req, { bindingId: "http.orders.in" })(Controller.prototype, "post", {
+			value: Controller.prototype.post,
+		});
+		GraphHttpReply(reply, { bindingId: "http.orders.out" })(Controller.prototype, "post", {
+			value: Controller.prototype.post,
+		});
+		const runner = createNestGraphBoundaryRunner();
+
+		expect(() =>
+			runner.run(Controller, "post", { requestId: "req-1", body: { ok: true }, fail: true }),
+		).toThrow(/payload failed/);
+		await expect(
+			runner.run(Controller, "post", { requestId: "req-1", body: { ok: true } }),
+		).resolves.toEqual({ ok: true });
+		expect(() => runner.run(Controller, "post", { body: { ok: true } })).toThrow(
+			/GraphHttpReply requires/,
+		);
+		runner.dispose();
+	});
+
+	it("uses binding-level request ids when attaching high-level HTTP replies", async () => {
+		const g = graph();
+		const req = fromNestReq<
+			{ readonly routeRequestId: string; readonly body: { readonly ok: true } },
+			{ readonly ok: true }
+		>(g, {
+			bindingId: "node.binding-request.in",
+			payload: (host) => host.body,
+		});
+		const reply = g.node<NestReplyEnvelope<{ readonly ok: true }>>([req.node], (ctx) => {
+			const envelope = depLatest(ctx, 0) as NestBoundaryEnvelope<{ readonly ok: true }>;
+			if (envelope.requestId === undefined) return;
+			ctx.down([
+				[
+					"DATA",
+					{
+						requestId: envelope.requestId,
+						bindingId: "http.binding-request.out",
+						version: 1,
+						payload: envelope.payload,
+					},
+				],
+			]);
+		});
+		class Controller {
+			post() {}
+		}
+		GraphReq(req, {
+			bindingId: "http.binding-request.in",
+			requestId: (host) => host.routeRequestId,
+		})(Controller.prototype, "post", { value: Controller.prototype.post });
+		GraphHttpReply(reply, { bindingId: "http.binding-request.out" })(Controller.prototype, "post", {
+			value: Controller.prototype.post,
+		});
+		const runner = createNestGraphBoundaryRunner();
+
+		await expect(
+			runner.run(Controller, "post", {
+				routeRequestId: "req-binding",
+				body: { ok: true },
+			}),
+		).resolves.toEqual({ ok: true });
+		runner.dispose();
+	});
+
+	it("limits the high-level interceptor runner to request/interceptor ingress and HTTP egress", () => {
+		const g = graph();
+		const req = fromNestReq<{ readonly requestId: string }, { readonly ok: true }>(g, {
+			bindingId: "node.phase.request.in",
+			payload: () => ({ ok: true }),
+		});
+		const guard = fromNestGuard<{ readonly requestId: string }, { readonly guard: true }>(g, {
+			bindingId: "node.phase.guard.in",
+			payload: () => ({ guard: true }),
+		});
+		const decision = g.node<NestReplyEnvelope<GraphGuardDecisionPayload>>([], null);
+		const requestSeen: unknown[] = [];
+		const guardSeen: unknown[] = [];
+		req.node.subscribe((msg) => msg[0] === "DATA" && requestSeen.push(msg[1]));
+		guard.node.subscribe((msg) => msg[0] === "DATA" && guardSeen.push(msg[1]));
+		class Controller {
+			post() {}
+		}
+		GraphReq(req, { bindingId: "http.phase.request.in" })(Controller.prototype, "post", {
+			value: Controller.prototype.post,
+		});
+		GraphGuard(guard, { bindingId: "guard.phase.in" })(Controller.prototype, "post", {
+			value: Controller.prototype.post,
+		});
+		GraphGuardDecision(decision, { bindingId: "guard.phase.out" })(Controller.prototype, "post", {
+			value: Controller.prototype.post,
+		});
+		const runner = createNestGraphBoundaryRunner();
+
+		expect(runner.run(Controller, "post", { requestId: "req-phase" })).toBeUndefined();
+		expect(requestSeen).toHaveLength(1);
+		expect(guardSeen).toHaveLength(0);
+		runner.dispose();
+	});
+
+	it("fails fast when GraphHttpReply is configured without a matching ingress binding", () => {
+		const g = graph();
+		const reply = g.node<NestReplyEnvelope<{ readonly ok: true }>>([], null, {
+			name: "http.reply-only.out",
+		});
+		class Controller {
+			post() {}
+		}
+		GraphHttpReply(reply, { bindingId: "http.reply-only.out" })(Controller.prototype, "post", {
+			value: Controller.prototype.post,
+		});
+		const runner = createNestGraphBoundaryRunner();
+
+		expect(() => runner.run(Controller, "post", { requestId: "req-reply-only" })).toThrow(
+			/requires at least one ingress/,
+		);
+		runner.dispose();
+	});
+
+	it("does not emit ingress when high-level reply attach fails", () => {
+		const g = graph();
+		const req = fromNestReq<{ readonly requestId: string }, { readonly ok: true }>(g, {
+			bindingId: "node.duplicate.in",
+			payload: () => ({ ok: true }),
+		});
+		const reply = g.node<NestReplyEnvelope<{ readonly ok: true }>>([], null, {
+			name: "http.duplicate.out",
+		});
+		const seen: unknown[] = [];
+		const unsubscribe = req.node.subscribe((msg) => {
+			if (msg[0] === "DATA") seen.push(msg[1]);
+		});
+		class Controller {
+			post() {}
+		}
+		GraphReq(req, { bindingId: "http.duplicate.in" })(Controller.prototype, "post", {
+			value: Controller.prototype.post,
+		});
+		GraphHttpReply(reply, { bindingId: "http.duplicate.out" })(Controller.prototype, "post", {
+			value: Controller.prototype.post,
+		});
+		const runner = createNestGraphBoundaryRunner();
+		const pending = runner.run(Controller, "post", { requestId: "req-dup" });
+		if (pending) pending.catch(() => undefined);
+
+		expect(() => runner.run(Controller, "post", { requestId: "req-dup" })).toThrow(
+			/duplicate pending/,
+		);
+		expect(seen).toHaveLength(1);
+		unsubscribe();
+		runner.dispose();
+	});
+
+	it("resolves inherited Nest boundary metadata for subclass controllers", async () => {
+		const g = graph();
+		const req = fromNestReq<{ readonly requestId: string }, { readonly ok: true }>(g, {
+			bindingId: "node.inherited.in",
+			payload: () => ({ ok: true }),
+		});
+		const reply = g.node<NestReplyEnvelope<{ readonly ok: true }>>(
+			[req.node],
+			(ctx) => {
+				const envelope = depLatest(ctx, 0) as NestBoundaryEnvelope<{ readonly ok: true }>;
+				if (envelope.requestId === undefined) return;
+				ctx.down([
+					[
+						"DATA",
+						{
+							requestId: envelope.requestId,
+							bindingId: "http.inherited.out",
+							version: 1,
+							payload: envelope.payload,
+						},
+					],
+				]);
+			},
+			{ name: "http.inherited.out" },
+		);
+		class BaseController {
+			post() {}
+		}
+		class ChildController extends BaseController {}
+		GraphReq(req, { bindingId: "http.inherited.in" })(BaseController.prototype, "post", {
+			value: BaseController.prototype.post,
+		});
+		GraphHttpReply(reply, { bindingId: "http.inherited.out" })(BaseController.prototype, "post", {
+			value: BaseController.prototype.post,
+		});
+		const runner = createNestGraphBoundaryRunner();
+
+		await expect(
+			runner.run(ChildController, "post", { requestId: "req-inherited" }),
+		).resolves.toEqual({ ok: true });
+		runner.dispose();
+	});
+
+	it("derives a default request id in the high-level interceptor for plain Nest HTTP requests", async () => {
+		const g = graph();
+		const req = fromNestReq<{ readonly requestId: string }, { readonly ok: true }>(g, {
+			bindingId: "node.default-interceptor.in",
+			payload: () => ({ ok: true }),
+		});
+		const reply = g.node<NestReplyEnvelope<{ readonly ok: true }>>(
+			[req.node],
+			(ctx) => {
+				const envelope = depLatest(ctx, 0) as NestBoundaryEnvelope<{ readonly ok: true }>;
+				if (envelope.requestId === undefined) return;
+				ctx.down([
+					[
+						"DATA",
+						{
+							requestId: envelope.requestId,
+							bindingId: "http.default-interceptor.out",
+							version: 1,
+							payload: envelope.payload,
+						},
+					],
+				]);
+			},
+			{ name: "http.default-interceptor.out" },
+		);
+		class Controller {
+			post() {}
+		}
+		GraphReq(req, { bindingId: "http.default-interceptor.in" })(Controller.prototype, "post", {
+			value: Controller.prototype.post,
+		});
+		GraphHttpReply(reply, { bindingId: "http.default-interceptor.out" })(
+			Controller.prototype,
+			"post",
+			{ value: Controller.prototype.post },
+		);
+		const interceptor = createNestGraphBoundaryInterceptor();
+		const context = {
+			getClass: () => Controller,
+			getHandler: () => Controller.prototype.post,
+			switchToHttp: () => ({
+				getRequest: () => ({ headers: { "x-request-id": "header-req" } }),
+			}),
+		};
+
+		await expect(interceptor.intercept(context)).resolves.toEqual({ ok: true });
+		interceptor.dispose();
+	});
+
+	it("ignores lifecycle-only metadata in the interceptor phase bridge", () => {
+		const g = graph();
+		const lifecycle = fromNestLifecycle<unknown, { readonly event: string }>(g, {
+			bindingId: "node.lifecycle.only",
+			payload: () => ({ event: "teardown" }),
+		});
+		const seen: NestBoundaryEnvelope<{ readonly event: string }>[] = [];
+		const unsubscribe = lifecycle.node.subscribe((msg) => {
+			if (msg[0] === "DATA") seen.push(msg[1] as NestBoundaryEnvelope<{ readonly event: string }>);
+		});
+		class Controller {
+			teardown() {}
+		}
+		GraphLifecycle(lifecycle, { bindingId: "lifecycle.only" })(Controller.prototype, "teardown", {
+			value: Controller.prototype.teardown,
+		});
+		const interceptor = createNestGraphBoundaryInterceptor();
+		const context = {
+			getClass: () => Controller,
+			getHandler: () => Controller.prototype.teardown,
+			switchToHttp: () => ({
+				getRequest: () => ({ headers: {} }),
+			}),
+		};
+
+		expect(interceptor.intercept(context, { handle: () => "next" })).toBe("next");
+		expect(seen).toEqual([]);
+		unsubscribe();
+		interceptor.dispose();
+	});
+
+	it("guards Nest HTTP pending lifecycle and low-level diagnostic retention", () => {
+		const g = graph();
+		const egress = g.node<NestReplyEnvelope<{ readonly ok: boolean }>>([], null, {
+			name: "nestjs/http/guarded.out",
+		});
+		const http = toNestHttp(egress, {
+			bindingId: "orders.http",
+			maxDiagnostics: 2,
+		});
+		const handle = { resolve: vi.fn(), reject: vi.fn() };
+
+		http.attach({ requestId: "req-1", handle });
+		expect(() => http.attach({ requestId: "req-1", handle })).toThrow(/duplicate pending/);
+
+		egress.down([
+			[
+				"DATA",
+				{ requestId: "stale-1", bindingId: "orders.http", version: 1, payload: { ok: false } },
+			],
+			[
+				"DATA",
+				{ requestId: "stale-2", bindingId: "orders.http", version: 1, payload: { ok: false } },
+			],
+			[
+				"DATA",
+				{ requestId: "stale-3", bindingId: "orders.http", version: 1, payload: { ok: false } },
+			],
+		]);
+
+		expect(http.diagnostics().map((diagnostic) => diagnostic.kind)).toEqual([
+			"stale-egress",
+			"stale-egress",
+		]);
+		const cleanup = http.attach({ requestId: "req-2", handle });
+		expect(cleanup()).toBe(true);
+		expect(cleanup()).toBe(false);
+		http.dispose();
+		expect(() => http.attach({ requestId: "req-3", handle })).toThrow(/disposed/);
+	});
+
+	it("rejects pending Nest HTTP handles on terminal egress and dispose", () => {
+		const g = graph();
+		const egress = g.node<NestReplyEnvelope<{ readonly ok: boolean }>>([], null, {
+			name: "nestjs/http/terminal.out",
+		});
+		const http = toNestHttp(egress, { bindingId: "orders.http" });
+		const terminalHandle = { resolve: vi.fn(), reject: vi.fn() };
+		const disposeHandle = { resolve: vi.fn(), reject: vi.fn() };
+
+		http.attach({ requestId: "req-terminal", handle: terminalHandle });
+		egress.down([["ERROR", new Error("egress closed")]]);
+
+		expect(terminalHandle.resolve).not.toHaveBeenCalled();
+		expect(terminalHandle.reject).toHaveBeenCalledTimes(1);
+		expect(http.pendingCount()).toBe(0);
+		expect(http.diagnostics().map((diagnostic) => diagnostic.kind)).toContain("terminal-egress");
+
+		const terminalCleanup = http.attach({ requestId: "req-after-terminal", handle: disposeHandle });
+		http.dispose();
+
+		expect(disposeHandle.resolve).not.toHaveBeenCalled();
+		expect(disposeHandle.reject).toHaveBeenCalledTimes(1);
+		expect(terminalCleanup()).toBe(false);
+		expect(http.pendingCount()).toBe(0);
+		expect(http.diagnostics().map((diagnostic) => diagnostic.kind)).not.toContain(
+			"dispose-pending",
+		);
+
+		const disposeEgress = g.node<NestReplyEnvelope<{ readonly ok: boolean }>>([], null, {
+			name: "nestjs/http/dispose.out",
+		});
+		const disposeHttp = toNestHttp(disposeEgress, { bindingId: "orders.dispose" });
+		const liveDisposeHandle = { resolve: vi.fn(), reject: vi.fn() };
+
+		disposeHttp.attach({ requestId: "req-dispose", handle: liveDisposeHandle });
+		disposeHttp.dispose();
+
+		expect(liveDisposeHandle.resolve).not.toHaveBeenCalled();
+		expect(liveDisposeHandle.reject).toHaveBeenCalledTimes(1);
+		expect(disposeHttp.pendingCount()).toBe(0);
+		expect(disposeHttp.diagnostics().map((diagnostic) => diagnostic.kind)).toContain(
+			"dispose-pending",
+		);
+	});
+
+	it("rejects non-data Nest boundary payload material on ingress and egress", () => {
+		const g = graph();
+		const req = fromNestReq(g, { bindingId: "orders.strict", maxPayloadBytes: 24 });
+		const sparse = [] as unknown[];
+		sparse[1] = "hole";
+		const hidden = { ok: true } as { ok: boolean; runtime?: unknown };
+		Object.defineProperty(hidden, "runtime", {
+			enumerable: false,
+			value: () => undefined,
+		});
+		const accessorArray: unknown[] = [];
+		Object.defineProperty(accessorArray, "0", {
+			enumerable: true,
+			get() {
+				throw new Error("getter executed");
+			},
+		});
+
+		expect(() => req.emit({ requestId: "req-1" }, { payload: sparse })).toThrow(/sparse/);
+		expect(() => req.emit({ requestId: "req-1" }, { payload: accessorArray })).toThrow(
+			/enumerable plain data/,
+		);
+		expect(() => req.emit({ requestId: "req-1" }, { payload: hidden })).toThrow(
+			/enumerable plain data/,
+		);
+		expect(() =>
+			req.emit({ requestId: "req-1" }, { payload: { text: "this is too large" } }),
+		).toThrow(/exceeds/);
+		expect(() => req.emit({ requestId: "req-1" }, { payload: Number.NaN })).toThrow(/finite/);
+		expect(() => fromNestReq(g, { bindingId: "bad.version", version: 0 })).toThrow(/must be 1/);
+		expect(() => fromNestReq(g, { bindingId: "future.version", version: 2 })).toThrow(/must be 1/);
+		expect(() => req.emit({ requestId: "req-1" }, { version: Number.NaN, payload: null })).toThrow(
+			/must be 1/,
+		);
+
+		const egress = g.node<NestReplyEnvelope<unknown>>([], null, {
+			name: "nestjs/http/strict.out",
+		});
+		const http = toNestHttp(egress, { bindingId: "orders.strict", maxPayloadBytes: 24 });
+		const handle = { resolve: vi.fn(), reject: vi.fn() };
+
+		http.attach({ requestId: "req-1", handle });
+		egress.down([
+			["DATA", { bindingId: "orders.strict", version: 1, payload: { ok: true } }],
+			["DATA", { requestId: "req-1", bindingId: "orders.strict", version: 1, payload: undefined }],
+			[
+				"DATA",
+				{
+					requestId: "req-1",
+					bindingId: "orders.strict",
+					version: 1,
+					payload: { socket: () => undefined },
+				},
+			],
+			[
+				"DATA",
+				{
+					requestId: "req-1",
+					bindingId: "orders.strict",
+					version: 2,
+					payload: { ok: true },
+				},
+			],
+		]);
+
+		expect(handle.resolve).not.toHaveBeenCalled();
+		expect(handle.reject).toHaveBeenCalledTimes(1);
+		expect(http.pendingCount()).toBe(0);
+		expect(http.diagnostics().map((diagnostic) => diagnostic.kind)).toEqual([
+			"malformed-egress",
+			"malformed-egress",
+			"malformed-egress",
+			"malformed-egress",
+		]);
+		http.dispose();
+	});
+
+	it("guards Nest ingress payloads against host runtime objects", () => {
+		const g = graph();
+		const req = fromNestReq(g, { bindingId: "orders.raw" });
+
+		expect(() =>
+			req.emit({ requestId: "req-1" }, { payload: { body: "ok", response: () => undefined } }),
+		).toThrow(/data-only/);
+		expect(() =>
+			req.emit({ requestId: "req-1" }, { payload: { socket: new Map<string, string>() } }),
+		).toThrow(/plain data object/);
+	});
+
+	it("lets binding-level payload and requestId override factory defaults", () => {
+		const g = graph();
+		const req = fromNestReq<{ requestId: string; body: { value: string } }, { value: string }>(g, {
+			bindingId: "node.shared.in",
+			payload: () => ({ value: "factory" }),
+			requestId: "factory-req",
+		});
+		const seen: unknown[] = [];
+		req.node.subscribe((msg) => msg[0] === "DATA" && seen.push(msg[1]));
+		class Controller {
+			a() {}
+			b() {}
+		}
+		GraphReq(req, {
+			bindingId: "route.a",
+			payload: (host) => host.body,
+			requestId: (host) => host.requestId,
+			order: 2,
+		})(Controller.prototype, "a", { value: Controller.prototype.a });
+		GraphReq(req, {
+			bindingId: "route.b",
+			payload: () => ({ value: "binding-b" }),
+			requestId: "route-b-req",
+			order: 1,
+		})(Controller.prototype, "b", { value: Controller.prototype.b });
+
+		const runner = createNestGraphBoundaryRunner();
+		runner.run(Controller, "a", { requestId: "route-a-req", body: { value: "binding-a" } });
+		runner.run(Controller, "b", { requestId: "ignored", body: { value: "ignored" } });
+
+		expect(seen).toEqual([
+			{
+				bindingId: "route.a",
+				version: 1,
+				requestId: "route-a-req",
+				payload: { value: "binding-a" },
+			},
+			{
+				bindingId: "route.b",
+				version: 1,
+				requestId: "route-b-req",
+				payload: { value: "binding-b" },
+			},
+		]);
+		expect(getNestBoundaryBindings(Controller, "a")[0]).toMatchObject({
+			bindingId: "route.a",
+			order: 2,
+		});
+		runner.dispose();
+	});
+
+	it("records GraphFilter, GraphError sugar, GraphGuardDecision, and lowerers", () => {
+		const g = graph();
+		const error = fromNestError(g, { bindingId: "node.error.in" });
+		const guard = fromNestGuard(g, { bindingId: "node.guard.in" });
+		const decision = g.node<NestReplyEnvelope<GraphGuardDecisionPayload>>([], null);
+		class Controller {
+			filtered() {}
+			guarded() {}
+		}
+
+		GraphFilter(error, { bindingId: "filter.generic", mode: "observe", order: 1 })(
+			Controller.prototype,
+			"filtered",
+			{ value: Controller.prototype.filtered },
+		);
+		GraphError(error, { bindingId: "filter.error", mode: "handle", order: 2 })(
+			Controller.prototype,
+			"filtered",
+			{ value: Controller.prototype.filtered },
+		);
+		GraphGuard(guard, { bindingId: "guard.in" })(Controller.prototype, "guarded", {
+			value: Controller.prototype.guarded,
+		});
+		GraphGuardDecision(decision, { bindingId: "guard.out" })(Controller.prototype, "guarded", {
+			value: Controller.prototype.guarded,
+		});
+
+		expect(
+			getNestBoundaryBindings(Controller, "filtered").map((binding) => binding.bindingId),
+		).toEqual(["filter.generic", "filter.error"]);
+		expect(getNestBoundaryBindings(Controller, "guarded").map((binding) => binding.kind)).toEqual([
+			"guard",
+			"guard-decision",
+		]);
+
+		const httpIssue: HttpDataIssue = {
+			kind: "issue",
+			code: "orders.closed",
+			message: "Orders are closed.",
+			status: 409,
+			body: { ok: false },
+			headers: { "x-graphrefly-issue": "orders.closed" },
+		};
+		expect(issueResponse(httpIssue)).toEqual({
+			status: 409,
+			body: { ok: false },
+			headers: { "x-graphrefly-issue": "orders.closed" },
+		});
+		expect(lowerHttpReplyPayload({ status: 202, body: { ok: true } }, {})).toEqual({
+			status: 202,
+			body: { ok: true },
+		});
+		expect(lowerHttpReplyPayload({ kind: "issue", code: "bad", message: "Bad" }, {})).toEqual({
+			status: 400,
+			body: { code: "bad", message: "Bad" },
+		});
+		expect(protocolError(new Error("secret")).status).toBe(500);
+		expect(
+			lowerProtocolError("boom", {}, { protocolError: () => ({ status: 599, body: "masked" }) }),
+		).toEqual({ status: 599, body: "masked" });
+	});
+
+	it("exports Nest-native provider bridge objects without leaking them through the generic barrel", () => {
+		expect(provideGraphBoundaryInterceptor()).toMatchObject({ provide: expect.anything() });
+		expect(provideGraphGuard()).toMatchObject({ provide: expect.anything() });
+		expect(typeof createGraphExceptionFilter({ target: () => undefined }).catch).toBe("function");
+		expect(provideGraphExceptionFilter({ target: () => undefined })).toMatchObject({
+			provide: expect.anything(),
+		});
+		const guardDeniedProvider = provideGraphGuardDeniedFilter();
+		expect(createGraphGuardDeniedFilter()).toBeInstanceOf(GraphGuardDeniedFilter);
+		expect(guardDeniedProvider).toBe(GraphGuardDeniedFilter);
+		expect(guardDeniedProvider).not.toBe(APP_FILTER);
+		expect(provideGraphExceptionFilter({ target: () => undefined }).provide).not.toBe(APP_FILTER);
+		expect(provideGraphCronScheduler({ targets: [] })).toMatchObject({
+			provide: expect.any(Symbol),
+		});
+		expect(provideGraphLifecycleHooks({ targets: [] })).toMatchObject({
+			provide: expect.any(Symbol),
+		});
+		expect("GraphReq" in ({} as typeof import("../adapters/index.js"))).toBe(false);
+	});
+
+	it("builds explicit native provider bundles without scanning or creating graphs", () => {
+		const target = () => ({ target: class Target {}, methodKey: "handle" });
+		const httpProviders = provideGraphNativeHttpProviders({
+			boundaryInterceptor: { host: () => ({ requestId: "req-1" }) },
+			guard: {},
+			exceptionFilter: { target },
+		});
+
+		expect(
+			httpProviders.map((provider) =>
+				typeof provider === "function" ? provider : provider.provide,
+			),
+		).toEqual([APP_INTERCEPTOR, APP_GUARD, GraphGuardDeniedFilter, expect.any(Symbol)]);
+		expect(provideGraphNativeHttpProviders({ guardDeniedFilter: false })).toHaveLength(2);
+
+		class Controller {
+			tick() {}
+			stop() {}
+		}
+		const cronTarget = graphCronTarget(Controller, "tick", {
+			expr: "* * * * *",
+			timezone: "UTC",
+			target: class WrongCronTarget {},
+			methodKey: "wrong",
+		} as Parameters<typeof graphCronTarget>[2]);
+		const lifecycleTarget = graphLifecycleTarget(Controller, "stop", {
+			event: "module-destroy",
+			target: class WrongLifecycleTarget {},
+			methodKey: "wrong",
+		});
+		const nativeProviders = provideGraphNativeProviders({
+			http: false,
+			cronScheduler: { targets: [cronTarget] },
+			lifecycleHooks: { targets: [lifecycleTarget] },
+		});
+
+		expect(cronTarget).toMatchObject({ target: Controller, methodKey: "tick" });
+		expect(lifecycleTarget).toMatchObject({ target: Controller, methodKey: "stop" });
+		expect(nativeProviders).toHaveLength(2);
+		expect(nativeProviders.every((provider) => typeof provider !== "function")).toBe(true);
+	});
+
+	it("builds D495 focused WebSocket and message provider bundles over explicit bridge options", async () => {
+		vi.useFakeTimers();
+		try {
+			const g = graph();
+			const diagnostics = fromNestDiagnostics(g, {
+				bindingId: "node.transport.bundle.diagnostics",
+			});
+			const seenDiagnostics: unknown[] = [];
+			diagnostics.node.subscribe((msg) => {
+				if (msg[0] === "DATA") seenDiagnostics.push((msg[1] as NestBoundaryEnvelope).payload);
+			});
+
+			const wsIngress = fromNestWs(g, {
+				bindingId: "node.bundle.ws.in",
+				payload: (host: { readonly payload: unknown }) => host.payload,
+			});
+			const wsReply = g.node<NestReplyEnvelope<unknown>>([], null, {
+				name: "bundle.ws.reply",
+			});
+			class BundleGateway {
+				handle() {}
+			}
+			GraphWs(wsIngress, {
+				bindingId: "bundle.ws.in",
+				requestId: (host: { readonly requestId: string }) => host.requestId,
+				payload: (host: { readonly payload: unknown }) => host.payload,
+			})(BundleGateway.prototype, "handle", { value: BundleGateway.prototype.handle });
+			GraphWsReply(wsReply, { bindingId: "bundle.ws.reply" })(BundleGateway.prototype, "handle", {
+				value: BundleGateway.prototype.handle,
+			});
+
+			const wsProviders = provideGraphWsProviders({
+				bridge: {
+					diagnosticBoundary: diagnostics,
+					maxDiagnostics: 1,
+					timeoutMs: 20,
+				},
+			});
+			expect(wsProviders.map((provider) => provider.provide)).toEqual([GRAPHREFLY_NEST_WS_BRIDGE]);
+			expect(provideGraphWsProviders({ bridge: false })).toEqual([]);
+			const wsProvider = wsProviders[0];
+			if (wsProvider === undefined || !("useValue" in wsProvider)) {
+				throw new Error("Expected GraphWs provider bundle to return an explicit useValue provider");
+			}
+			const wsBridge = wsProvider.useValue as GraphWsBridge<{
+				readonly requestId: string;
+				readonly payload: unknown;
+			}>;
+			const wsPending = wsBridge.handleMessage(BundleGateway, "handle", {
+				requestId: "req-bundle-ws",
+				payload: { ok: true },
+			});
+			vi.advanceTimersByTime(20);
+			await expect(wsPending).rejects.toThrow(/timed out/);
+			expect(wsBridge.diagnostics().map((diagnostic) => diagnostic.kind)).toEqual(["timeout"]);
+
+			const messageIngress = fromNestMessage(g, {
+				bindingId: "node.bundle.message.in",
+				payload: (host: { readonly payload: unknown }) => host.payload,
+			});
+			const messageReply = g.node<NestReplyEnvelope<unknown>>([], null, {
+				name: "bundle.message.reply",
+			});
+			class BundleMessageController {
+				handle() {}
+			}
+			GraphMessage(messageIngress, {
+				bindingId: "bundle.message.in",
+				requestId: (host: { readonly requestId: string }) => host.requestId,
+				payload: (host: { readonly payload: unknown }) => host.payload,
+			})(BundleMessageController.prototype, "handle", {
+				value: BundleMessageController.prototype.handle,
+			});
+			GraphMessageReply(messageReply, { bindingId: "bundle.message.reply" })(
+				BundleMessageController.prototype,
+				"handle",
+				{ value: BundleMessageController.prototype.handle },
+			);
+
+			const messageProviders = provideGraphMessageProviders({
+				bridge: {
+					diagnosticBoundary: diagnostics,
+					maxDiagnostics: 1,
+					timeoutMs: 20,
+				},
+			});
+			expect(messageProviders.map((provider) => provider.provide)).toEqual([
+				GRAPHREFLY_NEST_MESSAGE_BRIDGE,
+			]);
+			expect(provideGraphMessageProviders({ bridge: false })).toEqual([]);
+			const messageProvider = messageProviders[0];
+			if (messageProvider === undefined || !("useValue" in messageProvider)) {
+				throw new Error(
+					"Expected GraphMessage provider bundle to return an explicit useValue provider",
+				);
+			}
+			const messageBridge = messageProvider.useValue as GraphMessageBridge<{
+				readonly requestId: string;
+				readonly payload: unknown;
+			}>;
+			const messagePending = messageBridge.handleMessage(BundleMessageController, "handle", {
+				requestId: "req-bundle-message",
+				payload: { ok: true },
+			});
+			vi.advanceTimersByTime(20);
+			await expect(messagePending).rejects.toThrow(/timed out/);
+			expect(messageBridge.diagnostics().map((diagnostic) => diagnostic.kind)).toEqual(["timeout"]);
+
+			expect(seenDiagnostics).toEqual([
+				expect.objectContaining({
+					kind: "timeout",
+					phase: "ws",
+					requestId: "req-bundle-ws",
+				}),
+				expect.objectContaining({
+					kind: "timeout",
+					phase: "message",
+					requestId: "req-bundle-message",
+				}),
+			]);
+			wsBridge.dispose();
+			messageBridge.dispose();
+		} finally {
+			vi.useRealTimers();
+		}
+	});
+
+	it("emits graph-visible Nest diagnostics only through an explicit sanitized boundary", () => {
+		const g = graph();
+		const diagnostics = fromNestDiagnostics(g, {
+			bindingId: "node.nest.diagnostics",
+			phase: "http",
+		});
+		const seen: unknown[] = [];
+		diagnostics.node.subscribe((msg) => {
+			if (msg[0] === "DATA") seen.push((msg[1] as NestBoundaryEnvelope).payload);
+		});
+		const reply = g.node<NestReplyEnvelope<{ readonly ok: true }>>([], null, {
+			name: "nestjs/diagnostic/reply",
+		});
+		const hiddenHandle = { socket: { id: "raw" }, callback: () => undefined };
+		const error = Object.assign(new Error("private failure"), hiddenHandle);
+		const http = toNestHttp(reply, {
+			bindingId: "http.diagnostics.out",
+			diagnosticBoundary: diagnostics,
+		});
+		http.attach({
+			requestId: "req-diagnostic",
+			bindingId: "http.diagnostics.out",
+			handle: {
+				resolve: vi.fn(),
+				reject: vi.fn(),
+			},
+		});
+
+		reply.down([["ERROR", error]]);
+
+		expect(http.diagnostics().map((diagnostic) => diagnostic.kind)).toEqual(["terminal-egress"]);
+		expect(seen).toEqual([
+			{
+				kind: "terminal-egress",
+				phase: "http",
+				bindingId: "http.diagnostics.out",
+				message: "toNestHttp(http.diagnostics.out) rejected pending requests after ERROR",
+				error: { name: "Error", message: "private failure" },
+			},
+		]);
+		expect(JSON.stringify(seen)).not.toContain("socket");
+		expect(JSON.stringify(seen)).not.toContain("callback");
+	});
+
+	it("keeps host cleanup alive when explicit diagnostic ingress rejects DATA", () => {
+		const g = graph();
+		const diagnostics = fromNestDiagnostics(g, {
+			bindingId: "node.nest.tight-diagnostics",
+			maxPayloadBytes: 1,
+		});
+		const reply = g.node<NestReplyEnvelope<{ readonly ok: true }>>([], null);
+		const reject = vi.fn();
+		const http = toNestHttp(reply, {
+			bindingId: "http.tight-diagnostics.out",
+			diagnosticBoundary: diagnostics,
+		});
+		http.attach({
+			requestId: "req-tight",
+			bindingId: "http.tight-diagnostics.out",
+			handle: {
+				resolve: vi.fn(),
+				reject,
+			},
+		});
+
+		expect(() =>
+			reply.down([["ERROR", new Error("too large for diagnostic ingress")]]),
+		).not.toThrow();
+		expect(reject).toHaveBeenCalledOnce();
+		expect(http.diagnostics().map((diagnostic) => diagnostic.kind)).toEqual(["terminal-egress"]);
+	});
+
+	it("passes sanitized diagnostics into structural diagnostic boundaries", () => {
+		const g = graph();
+		const reply = g.node<NestReplyEnvelope<{ readonly ok: true }>>([], null);
+		const emitted: Array<{ readonly host: unknown; readonly payload: unknown }> = [];
+		const diagnosticBoundary: NestDiagnosticIngressBoundary = {
+			kind: "diagnostics",
+			bindingId: "custom.diagnostics",
+			version: 1,
+			node: fromNestDiagnostics(g).node,
+			envelope(host, opts) {
+				return {
+					bindingId: opts?.bindingId ?? "custom.diagnostics",
+					version: opts?.version ?? 1,
+					payload: opts?.payload ?? host,
+				};
+			},
+			emit(host, opts) {
+				emitted.push({ host, payload: opts?.payload });
+				return this.envelope(host, opts);
+			},
+		};
+		const http = toNestHttp(reply, {
+			bindingId: "http.custom-diagnostics.out",
+			diagnosticBoundary,
+		});
+
+		reply.down([["ERROR", Object.assign(new Error("masked"), { socket: { id: "raw" } })]]);
+
+		expect(http.diagnostics().map((diagnostic) => diagnostic.kind)).toEqual(["terminal-egress"]);
+		expect(emitted).toEqual([
+			{
+				host: {
+					kind: "terminal-egress",
+					phase: "http",
+					bindingId: "http.custom-diagnostics.out",
+					message: "toNestHttp(http.custom-diagnostics.out) rejected pending requests after ERROR",
+					error: { name: "Error", message: "masked" },
+				},
+				payload: {
+					kind: "terminal-egress",
+					phase: "http",
+					bindingId: "http.custom-diagnostics.out",
+					message: "toNestHttp(http.custom-diagnostics.out) rejected pending requests after ERROR",
+					error: { name: "Error", message: "masked" },
+				},
+			},
+		]);
+		expect(JSON.stringify(emitted)).not.toContain("socket");
+	});
+
+	it("keeps Nest diagnostics as host snapshots by default", () => {
+		const g = graph();
+		const diagnostics = fromNestDiagnostics(g, { bindingId: "node.unwired.diagnostics" });
+		const seen: unknown[] = [];
+		diagnostics.node.subscribe((msg) => msg[0] === "DATA" && seen.push(msg[1]));
+		const reply = g.node<NestReplyEnvelope<{ readonly ok: true }>>([], null);
+		const http = toNestHttp(reply, { bindingId: "http.host-snapshot.out" });
+
+		reply.down([
+			[
+				"DATA",
+				{
+					requestId: "stale",
+					bindingId: "http.host-snapshot.out",
+					version: 1,
+					payload: { ok: true },
+				},
+			],
+		]);
+
+		expect(http.diagnostics().map((diagnostic) => diagnostic.kind)).toEqual(["stale-egress"]);
+		expect(seen).toEqual([]);
+		expect(sanitizeNestDiagnostic({ kind: "timeout", message: "late", error: "deadline" })).toEqual(
+			{
+				kind: "timeout",
+				phase: "adapter",
+				message: "late",
+				error: { message: "deadline" },
+			},
+		);
+		expect(
+			sanitizeNestDiagnostic({
+				kind: "timeout",
+				message: "opaque",
+				error: {
+					get message() {
+						throw new Error("hostile getter");
+					},
+					toString() {
+						throw new Error("hostile toString");
+					},
+				},
+			}),
+		).toEqual({
+			kind: "timeout",
+			phase: "adapter",
+			message: "opaque",
+			error: { message: "opaque diagnostic error" },
+		});
+		function hiddenCallback() {
+			return "host-private source";
+		}
+		hiddenCallback.toString = () => {
+			throw new Error("hostile function toString");
+		};
+		expect(
+			sanitizeNestDiagnostic({
+				kind: "timeout",
+				message: "function",
+				error: hiddenCallback,
+			}),
+		).toEqual({
+			kind: "timeout",
+			phase: "adapter",
+			message: "function",
+			error: { message: "opaque diagnostic function" },
+		});
+	});
+
+	it("targeted guard-denial filter rethrows ordinary exceptions", () => {
+		const filter = createGraphGuardDeniedFilter();
+		const host = {
+			switchToHttp: () => ({
+				getResponse: () => ({
+					status: vi.fn(),
+					json: vi.fn(),
+				}),
+			}),
+		} as Parameters<GraphGuardDeniedFilter["catch"]>[1];
+
+		expect(() => filter.catch(new Error("ordinary"), host)).toThrow("ordinary");
+		const denial = new GraphGuardDeniedException({ status: 403, body: { denied: true } });
+		expect(isGraphGuardDeniedException(denial)).toBe(true);
+	});
+
+	it("native guard provider consumes GraphGuard and GraphGuardDecision metadata", async () => {
+		const g = graph();
+		const guard = fromNestGuard<
+			{ readonly requestId: string; readonly allow: boolean },
+			{ allow: boolean }
+		>(g, { bindingId: "node.native.guard.in" });
+		const decision = g.node<NestReplyEnvelope<GraphGuardDecisionPayload>>([guard.node], (ctx) => {
+			const envelope = depLatest(ctx, 0) as NestBoundaryEnvelope<{ allow: boolean }>;
+			if (envelope.requestId === undefined) return;
+			ctx.down([
+				[
+					"DATA",
+					{
+						requestId: envelope.requestId,
+						bindingId: "native.guard.out",
+						version: 1,
+						payload: envelope.payload.allow
+							? { kind: "allow" }
+							: {
+									kind: "deny",
+									status: 409,
+									body: { accepted: false },
+									headers: { "x-graphrefly-guard": "denied" },
+								},
+					},
+				],
+			]);
+		});
+		class Controller {
+			guarded() {}
+		}
+		GraphGuard(guard, {
+			bindingId: "native.guard.in",
+			payload: (host) => ({ allow: host.allow }),
+			requestId: (host) => host.requestId,
+		})(Controller.prototype, "guarded", { value: Controller.prototype.guarded });
+		GraphGuardDecision(decision, { bindingId: "native.guard.out" })(
+			Controller.prototype,
+			"guarded",
+			{
+				value: Controller.prototype.guarded,
+			},
+		);
+		const bridge = provideGraphGuard({
+			host: () => ({ requestId: "req-allow", allow: true }),
+			requestId: (host) => host.requestId,
+		}).useValue as { canActivate(context: unknown): Promise<boolean>; onModuleDestroy(): void };
+		const context = {
+			getClass: () => Controller,
+			getHandler: () => Controller.prototype.guarded,
+			switchToHttp: () => ({ getRequest: () => ({}) }),
+		};
+
+		await expect(bridge.canActivate(context)).resolves.toBe(true);
+		const denyBridge = provideGraphGuard({
+			host: () => ({ requestId: "req-deny", allow: false }),
+			requestId: (host) => host.requestId,
+		}).useValue as typeof bridge;
+		try {
+			await denyBridge.canActivate(context);
+			throw new Error("expected guard denial to throw");
+		} catch (error) {
+			expect(isGraphGuardDeniedException(error)).toBe(true);
+			expect((error as { getStatus?: () => number }).getStatus?.()).toBe(409);
+			expect((error as { getResponse?: () => unknown }).getResponse?.()).toEqual({
+				accepted: false,
+			});
+			const headers: Record<string, string> = {};
+			const statuses: number[] = [];
+			const bodies: unknown[] = [];
+			const guardHost = {
+				switchToHttp: () => ({
+					getResponse: () => ({
+						setHeader(name: string, value: string) {
+							headers[name] = value;
+						},
+						status(value: number) {
+							statuses.push(value);
+						},
+						json(value: unknown) {
+							bodies.push(value);
+							return value;
+						},
+					}),
+				}),
+			} as Parameters<GraphGuardDeniedFilter["catch"]>[1];
+			createGraphGuardDeniedFilter().catch(error, guardHost);
+			expect(headers).toEqual({ "x-graphrefly-guard": "denied" });
+			expect(statuses).toEqual([409]);
+			expect(bodies).toEqual([{ accepted: false }]);
+		}
+		bridge.onModuleDestroy();
+		denyBridge.onModuleDestroy();
+	});
+
+	it("native guard provider correlates each guard binding with its own request id", async () => {
+		const g = graph();
+		type GuardHost = {
+			readonly leftRequestId: string;
+			readonly rightRequestId: string;
+		};
+		const leftGuard = fromNestGuard<GuardHost, { readonly side: "left" }>(g, {
+			bindingId: "node.native.guard.left.in",
+		});
+		const rightGuard = fromNestGuard<GuardHost, { readonly side: "right" }>(g, {
+			bindingId: "node.native.guard.right.in",
+		});
+		const decision = g.node<NestReplyEnvelope<GraphGuardDecisionPayload>>(
+			[leftGuard.node, rightGuard.node],
+			(ctx) => {
+				const envelopes = [depLatest(ctx, 0), depLatest(ctx, 1)] as Array<
+					NestBoundaryEnvelope<{ readonly side: "left" | "right" }> | undefined
+				>;
+				const messages = envelopes
+					.filter(
+						(envelope): envelope is NestBoundaryEnvelope<{ readonly side: "left" | "right" }> =>
+							envelope?.requestId !== undefined,
+					)
+					.map(
+						(envelope) =>
+							[
+								"DATA",
+								{
+									requestId: envelope.requestId,
+									bindingId: "native.guard.multi.out",
+									version: 1,
+									payload: { kind: "allow", metadata: { side: envelope.payload.side } },
+								},
+							] as const,
+					);
+				if (messages.length > 0) ctx.down(messages);
+			},
+		);
+		class Controller {
+			guarded() {}
+		}
+		GraphGuard(leftGuard, {
+			bindingId: "native.guard.left.in",
+			payload: () => ({ side: "left" }),
+			requestId: (host) => host.leftRequestId,
+		})(Controller.prototype, "guarded", { value: Controller.prototype.guarded });
+		GraphGuard(rightGuard, {
+			bindingId: "native.guard.right.in",
+			payload: () => ({ side: "right" }),
+			requestId: (host) => host.rightRequestId,
+		})(Controller.prototype, "guarded", { value: Controller.prototype.guarded });
+		GraphGuardDecision(decision, { bindingId: "native.guard.multi.out" })(
+			Controller.prototype,
+			"guarded",
+			{ value: Controller.prototype.guarded },
+		);
+		const bridge = provideGraphGuard({
+			host: () => ({ leftRequestId: "req-left", rightRequestId: "req-right" }),
+			requestId: () => "provider-fallback",
+		}).useValue as { canActivate(context: unknown): Promise<boolean>; onModuleDestroy(): void };
+		const context = {
+			getClass: () => Controller,
+			getHandler: () => Controller.prototype.guarded,
+			switchToHttp: () => ({ getRequest: () => ({}) }),
+		};
+
+		await expect(bridge.canActivate(context)).resolves.toBe(true);
+		bridge.onModuleDestroy();
+	});
+
+	it("native guard denial lowers HttpDataIssue headers through the targeted filter", async () => {
+		const g = graph();
+		const guard = fromNestGuard<{ readonly requestId: string }, { readonly apiKey: string }>(g, {
+			bindingId: "node.native.guard.issue.in",
+		});
+		const issue: HttpDataIssue = {
+			kind: "issue",
+			code: "orders.forbidden",
+			message: "Orders require a valid key.",
+			status: 451,
+			body: { accepted: false, code: "orders.forbidden" },
+			headers: { "x-graphrefly-issue": "orders.forbidden" },
+		};
+		const decision = g.node<NestReplyEnvelope<GraphGuardDecisionPayload>>([guard.node], (ctx) => {
+			const envelope = depLatest(ctx, 0) as NestBoundaryEnvelope<{ readonly apiKey: string }>;
+			if (envelope.requestId === undefined) return;
+			ctx.down([
+				[
+					"DATA",
+					{
+						requestId: envelope.requestId,
+						bindingId: "native.guard.issue.out",
+						version: 1,
+						payload: { kind: "deny", issue },
+					},
+				],
+			]);
+		});
+		class Controller {
+			guarded() {}
+		}
+		GraphGuard(guard, {
+			bindingId: "native.guard.issue.in",
+			payload: () => ({ apiKey: "bad" }),
+			requestId: (host) => host.requestId,
+		})(Controller.prototype, "guarded", { value: Controller.prototype.guarded });
+		GraphGuardDecision(decision, { bindingId: "native.guard.issue.out" })(
+			Controller.prototype,
+			"guarded",
+			{ value: Controller.prototype.guarded },
+		);
+		const bridge = provideGraphGuard({
+			host: () => ({ requestId: "req-issue" }),
+			requestId: (host) => host.requestId,
+		}).useValue as { canActivate(context: unknown): Promise<boolean>; onModuleDestroy(): void };
+		const context = {
+			getClass: () => Controller,
+			getHandler: () => Controller.prototype.guarded,
+			switchToHttp: () => ({ getRequest: () => ({}) }),
+		};
+		const statuses: number[] = [];
+		const bodies: unknown[] = [];
+		const headers: Record<string, string> = {};
+		const host = {
+			switchToHttp: () => ({
+				getResponse: () => ({
+					header(name: string, value: string) {
+						headers[name] = value;
+					},
+					status(value: number) {
+						statuses.push(value);
+					},
+					json(value: unknown) {
+						bodies.push(value);
+						return value;
+					},
+				}),
+			}),
+		} as Parameters<GraphGuardDeniedFilter["catch"]>[1];
+
+		await expect(bridge.canActivate(context)).rejects.toBeInstanceOf(GraphGuardDeniedException);
+		try {
+			await bridge.canActivate(context);
+			throw new Error("expected guard denial to throw");
+		} catch (error) {
+			createGraphGuardDeniedFilter().catch(error, host);
+		}
+
+		expect(statuses).toEqual([451]);
+		expect(headers).toEqual({ "x-graphrefly-issue": "orders.forbidden" });
+		expect(bodies).toEqual([{ accepted: false, code: "orders.forbidden" }]);
+		bridge.onModuleDestroy();
+	});
+
+	it("native guard decision protocol ERROR uses binding-level protocol-error lowering", async () => {
+		const g = graph();
+		const guard = fromNestGuard<{ readonly requestId: string }, { readonly value: string }>(g, {
+			bindingId: "node.native.guard.protocol.in",
+		});
+		const decision = g.node<NestReplyEnvelope<GraphGuardDecisionPayload>>([guard.node], (ctx) => {
+			const envelope = depLatest(ctx, 0) as NestBoundaryEnvelope<{ readonly value: string }>;
+			if (envelope.requestId === undefined) return;
+			ctx.down([["ERROR", new Error(`secret:${envelope.payload.value}`)]]);
+		});
+		class Controller {
+			guarded() {}
+		}
+		GraphGuard(guard, {
+			bindingId: "native.guard.protocol.in",
+			payload: () => ({ value: "hidden" }),
+			requestId: (host) => host.requestId,
+		})(Controller.prototype, "guarded", { value: Controller.prototype.guarded });
+		GraphGuardDecision(decision, {
+			bindingId: "native.guard.protocol.out",
+			protocolError: () => ({
+				status: 599,
+				body: { code: "guard.binding.protocol", message: "binding wins" },
+			}),
+		})(Controller.prototype, "guarded", { value: Controller.prototype.guarded });
+		const bridge = provideGraphGuard({
+			host: () => ({ requestId: "req-guard-protocol" }),
+			protocolError: () => ({
+				status: 598,
+				body: { code: "guard.provider.protocol", message: "provider loses" },
+			}),
+			requestId: (host) => host.requestId,
+		}).useValue as { canActivate(context: unknown): Promise<boolean>; onModuleDestroy(): void };
+		const context = {
+			getClass: () => Controller,
+			getHandler: () => Controller.prototype.guarded,
+			switchToHttp: () => ({ getRequest: () => ({}) }),
+		};
+
+		try {
+			await bridge.canActivate(context);
+			throw new Error("expected guard protocol error to throw");
+		} catch (error) {
+			expect(isGraphGuardDeniedException(error)).toBe(false);
+			expect((error as { getStatus?: () => number }).getStatus?.()).toBe(599);
+			expect((error as { getResponse?: () => unknown }).getResponse?.()).toEqual({
+				code: "guard.binding.protocol",
+				message: "binding wins",
+			});
+		}
+		bridge.onModuleDestroy();
+	});
+
+	it("native exception filter handles GraphError with HTTP DATA lowering", async () => {
+		const g = graph();
+		const errorIn = fromNestError<
+			{ readonly requestId: string; readonly exception: Error },
+			{ message: string }
+		>(g, { bindingId: "node.native.error.in" });
+		const errorOut = g.node<NestReplyEnvelope<{ status: number; body: { message: string } }>>(
+			[errorIn.node],
+			(ctx) => {
+				const envelope = depLatest(ctx, 0) as NestBoundaryEnvelope<{ message: string }>;
+				if (envelope.requestId === undefined) return;
+				ctx.down([
+					[
+						"DATA",
+						{
+							requestId: envelope.requestId,
+							bindingId: "native.error.out",
+							version: 1,
+							payload: { status: 418, body: { message: envelope.payload.message } },
+						},
+					],
+				]);
+			},
+		);
+		class Controller {
+			handled() {}
+		}
+		GraphError(errorIn, {
+			bindingId: "native.error.in",
+			payload: (host) => ({ message: host.exception.message }),
+			requestId: (host) => host.requestId,
+		})(Controller.prototype, "handled", { value: Controller.prototype.handled });
+		GraphHttpReply(errorOut, { bindingId: "native.error.out" })(Controller.prototype, "handled", {
+			value: Controller.prototype.handled,
+		});
+		const statuses: number[] = [];
+		const bodies: unknown[] = [];
+		const filter = provideGraphExceptionFilter({
+			target: () => ({ target: Controller, methodKey: "handled" }),
+			host: (_host, exception) => ({
+				requestId: "req-error",
+				exception: exception instanceof Error ? exception : new Error(String(exception)),
+			}),
+			requestId: (host) => host.requestId,
+		}).useValue as {
+			catch(exception: unknown, host: unknown): Promise<unknown>;
+			onModuleDestroy(): void;
+		};
+		const host = {
+			switchToHttp: () => ({
+				getRequest: () => ({}),
+				getResponse: () => ({
+					status(value: number) {
+						statuses.push(value);
+					},
+					json(value: unknown) {
+						bodies.push(value);
+						return value;
+					},
+				}),
+			}),
+		};
+
+		await filter.catch(new Error("handled"), host);
+
+		expect(statuses).toEqual([418]);
+		expect(bodies).toEqual([{ message: "handled" }]);
+		filter.onModuleDestroy();
+	});
+
+	it("native exception filter lowers reply protocol ERROR through the safe 500 fallback", () => {
+		const g = graph();
+		const errorIn = fromNestError<
+			{ readonly requestId: string; readonly exception: Error },
+			{ message: string }
+		>(g, { bindingId: "node.native.error.protocol.in" });
+		const errorOut = g.node<NestReplyEnvelope<unknown>>([errorIn.node], (ctx) => {
+			const envelope = depLatest(ctx, 0) as NestBoundaryEnvelope<{ message: string }>;
+			if (envelope.requestId === undefined) return;
+			ctx.down([["ERROR", new Error(`secret:${envelope.payload.message}`)]]);
+		});
+		class Controller {
+			handled() {}
+		}
+		GraphError(errorIn, {
+			bindingId: "native.error.protocol.in",
+			payload: (host) => ({ message: host.exception.message }),
+			requestId: (host) => host.requestId,
+		})(Controller.prototype, "handled", { value: Controller.prototype.handled });
+		GraphHttpReply(errorOut, { bindingId: "native.error.protocol.out" })(
+			Controller.prototype,
+			"handled",
+			{ value: Controller.prototype.handled },
+		);
+		const statuses: number[] = [];
+		const bodies: unknown[] = [];
+		const filter = createGraphExceptionFilter({
+			target: () => ({ target: Controller, methodKey: "handled" }),
+			host: (_host, exception) => ({
+				requestId: "req-error-protocol",
+				exception: exception instanceof Error ? exception : new Error(String(exception)),
+			}),
+			requestId: (host) => host.requestId,
+		}) as { catch(exception: unknown, host: unknown): unknown; onModuleDestroy(): void };
+		const host = {
+			switchToHttp: () => ({
+				getRequest: () => ({}),
+				getResponse: () => ({
+					status(value: number) {
+						statuses.push(value);
+					},
+					json(value: unknown) {
+						bodies.push(value);
+						return value;
+					},
+				}),
+			}),
+		};
+
+		filter.catch(new Error("handled"), host);
+
+		expect(statuses).toEqual([500]);
+		expect(bodies).toEqual([
+			{ code: "graphrefly.protocol_error", message: "GraphReFly reply pipeline failed" },
+		]);
+		filter.onModuleDestroy();
+	});
+
+	it("native exception filter lowers directly when no handling filter has a request id", () => {
+		const g = graph();
+		const errorIn = fromNestError<{ readonly exception: Error }, { message: string }>(g, {
+			bindingId: "node.native.error.no-request.in",
+		});
+		class Controller {
+			handled() {}
+		}
+		GraphError(errorIn, {
+			bindingId: "native.error.no-request.in",
+			payload: (host) => ({ message: host.exception.message }),
+		})(Controller.prototype, "handled", { value: Controller.prototype.handled });
+		const statuses: number[] = [];
+		const bodies: unknown[] = [];
+		const filter = createGraphExceptionFilter({
+			target: () => ({ target: Controller, methodKey: "handled" }),
+			host: (_host, exception) => ({
+				exception: exception instanceof Error ? exception : new Error(String(exception)),
+			}),
+		}) as { catch(exception: unknown, host: unknown): unknown; onModuleDestroy(): void };
+		const host = {
+			switchToHttp: () => ({
+				getRequest: () => ({}),
+				getResponse: () => ({
+					status(value: number) {
+						statuses.push(value);
+					},
+					json(value: unknown) {
+						bodies.push(value);
+						return value;
+					},
+				}),
+			}),
+		};
+
+		filter.catch(new Error("handled"), host);
+
+		expect(statuses).toEqual([500]);
+		expect(bodies).toEqual([
+			{ code: "graphrefly.protocol_error", message: "GraphReFly reply pipeline failed" },
+		]);
+		filter.onModuleDestroy();
+	});
+
+	it("native exception filter emits request-correlated observe filters before direct lowering", () => {
+		const g = graph();
+		const errorIn = fromNestError<
+			{ readonly requestId: string; readonly exception: Error },
+			{ readonly message: string }
+		>(g, {
+			bindingId: "node.native.error.observe.in",
+		});
+		const seen: string[] = [];
+		errorIn.node.subscribe((msg) => {
+			if (msg[0] === "DATA") seen.push(msg[1].bindingId);
+		});
+		class Controller {
+			handled() {}
+		}
+		GraphFilter(errorIn, {
+			bindingId: "native.error.observe.in",
+			mode: "observe",
+			payload: (host) => ({ message: host.exception.message }),
+			requestId: (host) => host.requestId,
+			order: 1,
+		})(Controller.prototype, "handled", { value: Controller.prototype.handled });
+		GraphError(errorIn, {
+			bindingId: "native.error.handle.in",
+			payload: (host) => ({ message: host.exception.message }),
+			requestId: (host) => host.requestId,
+			order: 2,
+		})(Controller.prototype, "handled", { value: Controller.prototype.handled });
+		const statuses: number[] = [];
+		const filter = createGraphExceptionFilter({
+			target: () => ({ target: Controller, methodKey: "handled" }),
+			host: (_host, exception) => ({
+				requestId: "err-observe",
+				exception: exception instanceof Error ? exception : new Error(String(exception)),
+			}),
+		}) as { catch(exception: unknown, host: unknown): unknown; onModuleDestroy(): void };
+		const host = {
+			switchToHttp: () => ({
+				getRequest: () => ({}),
+				getResponse: () => ({
+					status(value: number) {
+						statuses.push(value);
+					},
+					json(value: unknown) {
+						return value;
+					},
+				}),
+			}),
+		};
+
+		filter.catch(new Error("handled"), host);
+
+		expect(seen).toEqual(["native.error.observe.in", "native.error.handle.in"]);
+		expect(statuses).toEqual([500]);
+		filter.onModuleDestroy();
+	});
+
+	it("native websocket bridge correlates ack/reply by requestId and bindingId without handle DATA", async () => {
+		const g = graph();
+		const ingress = fromNestWs<
+			{
+				readonly requestId: string;
+				readonly body: string;
+				readonly socket: unknown;
+				readonly ack: unknown;
+			},
+			{ readonly body: string }
+		>(g, { bindingId: "node.ws.orders.in" });
+		const ack = g.node<NestReplyEnvelope<{ readonly accepted: true }>>([], null, {
+			name: "nestjs/ws/orders.ack",
+		});
+		const reply = g.node<NestReplyEnvelope<{ readonly ok: true }>>([], null, {
+			name: "nestjs/ws/orders.reply",
+		});
+		const seen: NestBoundaryEnvelope[] = [];
+		ingress.node.subscribe((msg) => msg[0] === "DATA" && seen.push(msg[1]));
+		class Gateway {
+			handle() {}
+		}
+		GraphWs(ingress, {
+			bindingId: "ws.orders.in",
+			requestId: (host) => host.requestId,
+			payload: (host) => ({ body: host.body }),
+		})(Gateway.prototype, "handle", { value: Gateway.prototype.handle });
+		GraphWsAck(ack, { bindingId: "ws.orders.ack" })(Gateway.prototype, "handle", {
+			value: Gateway.prototype.handle,
+		});
+		GraphWsReply(reply, { bindingId: "ws.orders.reply" })(Gateway.prototype, "handle", {
+			value: Gateway.prototype.handle,
+		});
+		const ackFn = vi.fn();
+		const bridge = createGraphWsBridge({
+			ack: (host) => host.ack as (payload: unknown) => void,
+		});
+
+		const result = bridge.handleMessage(Gateway, "handle", {
+			requestId: "req-ws-1",
+			body: "create",
+			socket: { send: vi.fn() },
+			ack: ackFn,
+		});
+
+		expect(seen).toEqual([
+			{
+				bindingId: "ws.orders.in",
+				version: 1,
+				requestId: "req-ws-1",
+				payload: { body: "create" },
+			},
+		]);
+		expect(JSON.stringify(seen[0])).not.toContain("socket");
+		expect(JSON.stringify(seen[0])).not.toContain("ack");
+
+		ack.down([
+			[
+				"DATA",
+				{
+					bindingId: "ws.orders.ack",
+					version: 1,
+					requestId: "req-ws-1",
+					payload: { accepted: true },
+				},
+			],
+		]);
+		expect(ackFn).toHaveBeenCalledWith({ accepted: true }, expect.any(Object));
+		reply.down([
+			[
+				"DATA",
+				{
+					bindingId: "ws.orders.reply",
+					version: 1,
+					requestId: "req-ws-1",
+					payload: { ok: true },
+				},
+			],
+		]);
+
+		await expect(result).resolves.toEqual({ ok: true });
+		expect(bridge.diagnostics()).toEqual([]);
+		bridge.dispose();
+	});
+
+	it("native websocket bridge diagnoses wrong/stale/malformed/terminal egress and timeout cleanup", async () => {
+		vi.useFakeTimers();
+		try {
+			const g = graph();
+			const ingress = fromNestWs(g, {
+				bindingId: "node.ws.strict.in",
+				payload: (host: { readonly payload: unknown }) => host.payload,
+			});
+			const reply = g.node<NestReplyEnvelope<unknown>>([], null, {
+				name: "nestjs/ws/strict.reply",
+			});
+			class Gateway {
+				handle() {}
+			}
+			GraphWs(ingress, {
+				bindingId: "ws.strict.in",
+				requestId: (host: { readonly requestId: string }) => host.requestId,
+				payload: (host: { readonly payload: unknown }) => host.payload,
+			})(Gateway.prototype, "handle", { value: Gateway.prototype.handle });
+			GraphWsReply(reply, { bindingId: "ws.strict.reply" })(Gateway.prototype, "handle", {
+				value: Gateway.prototype.handle,
+			});
+			const bridge = createGraphWsBridge({ timeoutMs: 20 });
+			const terminal = bridge.handleMessage(Gateway, "handle", {
+				requestId: "req-ws-terminal",
+				payload: { ok: true },
+			});
+			reply.down([
+				[
+					"DATA",
+					{
+						bindingId: "ws.other.reply",
+						version: 1,
+						requestId: "req-ws-terminal",
+						payload: { wrong: true },
+					},
+				],
+				[
+					"DATA",
+					{
+						bindingId: "ws.strict.reply",
+						version: 1,
+						requestId: "req-stale",
+						payload: { stale: true },
+					},
+				],
+				[
+					"DATA",
+					{
+						bindingId: "ws.strict.reply",
+						version: 1,
+						requestId: "req-ws-terminal",
+						payload: { socket: () => undefined },
+					},
+				],
+				["COMPLETE"],
+			]);
+			await expect(terminal).rejects.toThrow(/data-only/);
+			expect(bridge.diagnostics().map((diagnostic) => diagnostic.kind)).toEqual([
+				"binding-mismatch",
+				"stale-egress",
+				"malformed-egress",
+				"terminal-egress",
+			]);
+			bridge.dispose();
+
+			const timeoutReply = g.node<NestReplyEnvelope<unknown>>([], null, {
+				name: "nestjs/ws/timeout.reply",
+			});
+			class TimeoutGateway {
+				handle() {}
+			}
+			GraphWs(ingress, {
+				bindingId: "ws.strict.in",
+				requestId: (host: { readonly requestId: string }) => host.requestId,
+				payload: (host: { readonly payload: unknown }) => host.payload,
+			})(TimeoutGateway.prototype, "handle", { value: TimeoutGateway.prototype.handle });
+			GraphWsReply(timeoutReply, { bindingId: "ws.timeout.reply" })(
+				TimeoutGateway.prototype,
+				"handle",
+				{ value: TimeoutGateway.prototype.handle },
+			);
+			const timeoutBridge = createGraphWsBridge({ timeoutMs: 20 });
+			const timeout = timeoutBridge.handleMessage(TimeoutGateway, "handle", {
+				requestId: "req-ws-timeout",
+				payload: { ok: true },
+			});
+			vi.advanceTimersByTime(20);
+			await expect(timeout).rejects.toThrow(/timed out/);
+			expect(timeoutBridge.diagnostics().map((diagnostic) => diagnostic.kind)).toEqual(["timeout"]);
+			timeoutBridge.dispose();
+		} finally {
+			vi.useRealTimers();
+		}
+	});
+
+	it("native websocket bridge cleans earlier pending registrations when terminal setup settles", async () => {
+		const g = graph();
+		const ingress = fromNestWs(g, {
+			bindingId: "node.ws.cleanup.in",
+			payload: (host: { readonly payload: unknown }) => host.payload,
+		});
+		const ack = g.node<NestReplyEnvelope<unknown>>([], null, {
+			name: "nestjs/ws/cleanup.ack",
+		});
+		const terminalReply = g.node<NestReplyEnvelope<unknown>>([], null, {
+			name: "nestjs/ws/cleanup.terminal",
+		});
+		const seen: NestBoundaryEnvelope[] = [];
+		ingress.node.subscribe((msg) => msg[0] === "DATA" && seen.push(msg[1]));
+		class Gateway {
+			handle() {}
+		}
+		GraphWs(ingress, {
+			bindingId: "ws.cleanup.in",
+			requestId: (host: { readonly requestId: string }) => host.requestId,
+			payload: (host: { readonly payload: unknown }) => host.payload,
+		})(Gateway.prototype, "handle", { value: Gateway.prototype.handle });
+		GraphWsAck(ack, { bindingId: "ws.cleanup.ack" })(Gateway.prototype, "handle", {
+			value: Gateway.prototype.handle,
+		});
+		GraphWsReply(terminalReply, { bindingId: "ws.cleanup.terminal" })(Gateway.prototype, "handle", {
+			value: Gateway.prototype.handle,
+		});
+		const ackFn = vi.fn();
+		const bridge = createGraphWsBridge({
+			ack: (host: { readonly ack: (payload: unknown) => void }) => host.ack,
+		});
+		terminalReply.down([["COMPLETE"]]);
+
+		await expect(
+			bridge.handleMessage(Gateway, "handle", {
+				requestId: "req-ws-cleanup",
+				payload: { ok: true },
+				ack: ackFn,
+				socket: {},
+			}),
+		).rejects.toThrow();
+		expect(seen.filter((entry) => entry.requestId === "req-ws-cleanup")).toEqual([]);
+
+		ack.down([
+			[
+				"DATA",
+				{
+					bindingId: "ws.cleanup.ack",
+					version: 1,
+					requestId: "req-ws-cleanup",
+					payload: { accepted: true },
+				},
+			],
+		]);
+		expect(ackFn).not.toHaveBeenCalled();
+		expect(bridge.diagnostics().map((diagnostic) => diagnostic.kind)).toContain("stale-egress");
+		bridge.dispose();
+	});
+
+	it("native websocket bridge rejects unsafe defaults and cleans up on disconnect/dispose", async () => {
+		const g = graph();
+		const rawIngress = fromNestWs(g, { bindingId: "node.ws.raw.in" });
+		const safeIngress = fromNestWs(g, {
+			bindingId: "node.ws.safe.in",
+			payload: (host: { readonly payload: unknown }) => host.payload,
+		});
+		const reply = g.node<NestReplyEnvelope<{ readonly ok: true }>>([], null, {
+			name: "nestjs/ws/lifecycle.reply",
+		});
+		const seen: NestBoundaryEnvelope[] = [];
+		rawIngress.node.subscribe((msg) => msg[0] === "DATA" && seen.push(msg[1]));
+		safeIngress.node.subscribe((msg) => msg[0] === "DATA" && seen.push(msg[1]));
+		class RawGateway {
+			handle() {}
+		}
+		class SafeGateway {
+			handle() {}
+		}
+		GraphWs(rawIngress, {
+			bindingId: "ws.raw.in",
+			requestId: (host: { readonly requestId: string }) => host.requestId,
+		})(RawGateway.prototype, "handle", { value: RawGateway.prototype.handle });
+		GraphWs(safeIngress, {
+			bindingId: "ws.safe.in",
+			requestId: (host: { readonly requestId: string }) => host.requestId,
+			payload: (host: { readonly payload: unknown }) => host.payload,
+		})(SafeGateway.prototype, "handle", { value: SafeGateway.prototype.handle });
+		GraphWsReply(reply, { bindingId: "ws.lifecycle.reply" })(SafeGateway.prototype, "handle", {
+			value: SafeGateway.prototype.handle,
+		});
+		const bridge = createGraphWsBridge();
+		expect(() =>
+			bridge.handleMessage(RawGateway, "handle", {
+				requestId: "req-ws-raw",
+				socket: { id: "socket-1" },
+			}),
+		).toThrow(/payload selector/);
+		expect(seen).toEqual([]);
+
+		const socket = { id: "socket-2" };
+		const pending = bridge.handleMessage(SafeGateway, "handle", {
+			requestId: "req-ws-disconnect",
+			payload: { ok: true },
+			socket,
+		});
+		bridge.handleDisconnect(socket);
+		await expect(pending).rejects.toThrow(/disconnected/);
+		expect(bridge.diagnostics().map((diagnostic) => diagnostic.kind)).toContain("dispose-pending");
+
+		bridge.dispose();
+		expect(() =>
+			bridge.handleMessage(SafeGateway, "handle", {
+				requestId: "req-ws-after-dispose",
+				payload: { ok: true },
+				socket: {},
+			}),
+		).toThrow(/disposed/);
+		expect(seen.filter((entry) => entry.requestId === "req-ws-after-dispose")).toEqual([]);
+	});
+
+	it("native message bridge correlates replies and dispose cleanup without message-context DATA", async () => {
+		const g = graph();
+		const ingress = fromNestMessage<
+			{ readonly requestId: string; readonly message: string; readonly context: unknown },
+			{ readonly message: string }
+		>(g, { bindingId: "node.message.orders.in" });
+		const reply = g.node<NestReplyEnvelope<{ readonly result: string }>>([], null, {
+			name: "nestjs/message/orders.reply",
+		});
+		const seen: NestBoundaryEnvelope[] = [];
+		ingress.node.subscribe((msg) => msg[0] === "DATA" && seen.push(msg[1]));
+		class Controller {
+			handle() {}
+		}
+		GraphMessage(ingress, {
+			bindingId: "message.orders.in",
+			requestId: (host) => host.requestId,
+			payload: (host) => ({ message: host.message }),
+		})(Controller.prototype, "handle", { value: Controller.prototype.handle });
+		GraphMessageReply(reply, { bindingId: "message.orders.reply" })(
+			Controller.prototype,
+			"handle",
+			{ value: Controller.prototype.handle },
+		);
+		const bridge = createGraphMessageBridge();
+		const result = bridge.handleMessage(Controller, "handle", {
+			requestId: "req-message-1",
+			message: "reserve",
+			context: { ack: vi.fn() },
+		});
+
+		expect(seen).toEqual([
+			{
+				bindingId: "message.orders.in",
+				version: 1,
+				requestId: "req-message-1",
+				payload: { message: "reserve" },
+			},
+		]);
+		expect(JSON.stringify(seen[0])).not.toContain("context");
+		reply.down([
+			[
+				"DATA",
+				{
+					bindingId: "message.orders.reply",
+					version: 1,
+					requestId: "req-message-1",
+					payload: { result: "ok" },
+				},
+			],
+		]);
+		await expect(result).resolves.toEqual({ result: "ok" });
+
+		const pending = bridge.handleMessage(Controller, "handle", {
+			requestId: "req-message-dispose",
+			message: "reserve",
+			context: {},
+		});
+		bridge.dispose();
+		await expect(pending).rejects.toThrow(/disposed/);
+		expect(bridge.diagnostics().map((diagnostic) => diagnostic.kind)).toContain("dispose-pending");
+	});
+
+	it("native message bridge rejects unsafe defaults and suppresses ingress after terminal reply setup", async () => {
+		const g = graph();
+		const rawIngress = fromNestMessage(g, { bindingId: "node.message.raw.in" });
+		const safeIngress = fromNestMessage(g, {
+			bindingId: "node.message.safe.in",
+			payload: (host: { readonly payload: unknown }) => host.payload,
+		});
+		const terminalReply = g.node<NestReplyEnvelope<unknown>>([], null, {
+			name: "nestjs/message/terminal.reply",
+		});
+		const seen: NestBoundaryEnvelope[] = [];
+		rawIngress.node.subscribe((msg) => msg[0] === "DATA" && seen.push(msg[1]));
+		safeIngress.node.subscribe((msg) => msg[0] === "DATA" && seen.push(msg[1]));
+		class RawController {
+			handle() {}
+		}
+		class SafeController {
+			handle() {}
+		}
+		GraphMessage(rawIngress, {
+			bindingId: "message.raw.in",
+			requestId: (host: { readonly requestId: string }) => host.requestId,
+		})(RawController.prototype, "handle", { value: RawController.prototype.handle });
+		GraphMessage(safeIngress, {
+			bindingId: "message.safe.in",
+			requestId: (host: { readonly requestId: string }) => host.requestId,
+			payload: (host: { readonly payload: unknown }) => host.payload,
+		})(SafeController.prototype, "handle", { value: SafeController.prototype.handle });
+		GraphMessageReply(terminalReply, { bindingId: "message.terminal.reply" })(
+			SafeController.prototype,
+			"handle",
+			{ value: SafeController.prototype.handle },
+		);
+		const bridge = createGraphMessageBridge();
+		expect(() =>
+			bridge.handleMessage(RawController, "handle", {
+				requestId: "req-message-raw",
+				context: { pattern: "orders" },
+			}),
+		).toThrow(/payload selector/);
+		expect(seen).toEqual([]);
+
+		terminalReply.down([["COMPLETE"]]);
+		await expect(
+			bridge.handleMessage(SafeController, "handle", {
+				requestId: "req-message-terminal",
+				payload: { ok: true },
+			}),
+		).rejects.toThrow();
+		expect(seen.filter((entry) => entry.requestId === "req-message-terminal")).toEqual([]);
+		bridge.dispose();
+		expect(() =>
+			bridge.handleMessage(SafeController, "handle", {
+				requestId: "req-message-after-dispose",
+				payload: { ok: true },
+			}),
+		).toThrow(/disposed/);
+	});
+
+	it("native message bridge cleans earlier pending registrations when terminal setup settles", async () => {
+		const g = graph();
+		const ingress = fromNestMessage(g, {
+			bindingId: "node.message.cleanup.in",
+			payload: (host: { readonly payload: unknown }) => host.payload,
+		});
+		const firstReply = g.node<NestReplyEnvelope<unknown>>([], null, {
+			name: "nestjs/message/cleanup.first",
+		});
+		const terminalReply = g.node<NestReplyEnvelope<unknown>>([], null, {
+			name: "nestjs/message/cleanup.terminal",
+		});
+		const seen: NestBoundaryEnvelope[] = [];
+		ingress.node.subscribe((msg) => msg[0] === "DATA" && seen.push(msg[1]));
+		class Controller {
+			handle() {}
+		}
+		GraphMessage(ingress, {
+			bindingId: "message.cleanup.in",
+			requestId: (host: { readonly requestId: string }) => host.requestId,
+			payload: (host: { readonly payload: unknown }) => host.payload,
+		})(Controller.prototype, "handle", { value: Controller.prototype.handle });
+		GraphMessageReply(firstReply, { bindingId: "message.cleanup.first" })(
+			Controller.prototype,
+			"handle",
+			{ value: Controller.prototype.handle },
+		);
+		GraphMessageReply(terminalReply, { bindingId: "message.cleanup.terminal" })(
+			Controller.prototype,
+			"handle",
+			{ value: Controller.prototype.handle },
+		);
+		const bridge = createGraphMessageBridge();
+		terminalReply.down([["COMPLETE"]]);
+
+		await expect(
+			bridge.handleMessage(Controller, "handle", {
+				requestId: "req-message-cleanup",
+				payload: { ok: true },
+			}),
+		).rejects.toThrow();
+		expect(seen.filter((entry) => entry.requestId === "req-message-cleanup")).toEqual([]);
+
+		firstReply.down([
+			[
+				"DATA",
+				{
+					bindingId: "message.cleanup.first",
+					version: 1,
+					requestId: "req-message-cleanup",
+					payload: { ok: true },
+				},
+			],
+		]);
+		expect(bridge.diagnostics().map((diagnostic) => diagnostic.kind)).toContain("stale-egress");
+		bridge.dispose();
+	});
+
+	it("native cron provider starts and stops timers while emitting GraphCron ingress", () => {
+		vi.useFakeTimers();
+		vi.setSystemTime(new Date("2026-01-05T08:30:00.000Z"));
+		const g = graph();
+		const cron = fromNestCron<{ readonly timestamp_ns: string }, { tick: string }>(g, {
+			bindingId: "node.native.cron.in",
+		});
+		const seen: unknown[] = [];
+		cron.node.subscribe((msg) => msg[0] === "DATA" && seen.push(msg[1]));
+		class Controller {
+			tick() {}
+		}
+		GraphCron(cron, {
+			bindingId: "native.cron.in",
+			payload: (host) => ({ tick: host.timestamp_ns }),
+		})(Controller.prototype, "tick", { value: Controller.prototype.tick });
+		const scheduler = provideGraphCronScheduler({
+			targets: [
+				{
+					target: Controller,
+					methodKey: "tick",
+					expr: "30 8 * * 1",
+					tickMs: 1000,
+					timezone: "UTC",
+				},
+			],
+		}).useValue as { onModuleInit(): void; onModuleDestroy(): void };
+
+		scheduler.onModuleInit();
+
+		expect(seen).toHaveLength(1);
+		expect(vi.getTimerCount()).toBe(1);
+		scheduler.onModuleDestroy();
+		expect(vi.getTimerCount()).toBe(0);
+		vi.useRealTimers();
+	});
+
+	it("native cron provider dedupes by current wall-clock minute without blocking later days", () => {
+		vi.useFakeTimers();
+		try {
+			vi.setSystemTime(new Date("2026-01-05T08:30:00.000Z"));
+			const g = graph();
+			const cron = fromNestCron<{ readonly timestamp_ms: number }, { readonly tick: number }>(g, {
+				bindingId: "node.native.cron.daily.in",
+			});
+			const seen: unknown[] = [];
+			cron.node.subscribe((msg) => msg[0] === "DATA" && seen.push(msg[1]));
+			class Controller {
+				tick() {}
+			}
+			GraphCron(cron, {
+				bindingId: "native.cron.daily.in",
+				payload: (host) => ({ tick: host.timestamp_ms }),
+			})(Controller.prototype, "tick", { value: Controller.prototype.tick });
+			const scheduler = provideGraphCronScheduler({
+				targets: [
+					{
+						target: Controller,
+						methodKey: "tick",
+						expr: "30 8 * * *",
+						tickMs: 1000,
+						timezone: "UTC",
+					},
+				],
+			}).useValue as { onModuleInit(): void; onModuleDestroy(): void };
+
+			scheduler.onModuleInit();
+			vi.advanceTimersByTime(30_000);
+			vi.setSystemTime(new Date("2026-01-06T08:30:00.000Z"));
+			vi.advanceTimersByTime(1_000);
+			scheduler.onModuleDestroy();
+
+			expect(seen).toHaveLength(2);
+		} finally {
+			vi.useRealTimers();
+		}
+	});
+
+	it("manual cron controller checks current time deterministically without catch-up DATA", () => {
+		const g = graph();
+		const cron = fromNestCron<{ readonly timestamp_ms: number }, { readonly tick: number }>(g, {
+			bindingId: "node.native.cron.manual.in",
+		});
+		const seen: unknown[] = [];
+		cron.node.subscribe((msg) => msg[0] === "DATA" && seen.push(msg[1]));
+		class Controller {
+			tick() {}
+		}
+		GraphCron(cron, {
+			bindingId: "native.cron.manual.in",
+			payload: (host) => ({ tick: host.timestamp_ms }),
+		})(Controller.prototype, "tick", { value: Controller.prototype.tick });
+		const controller = createGraphCronController({
+			targets: [
+				graphCronTarget(Controller, "tick", {
+					expr: "30 8 * * 1",
+					timezone: "UTC",
+				}),
+			],
+		});
+
+		controller.check(new Date("2026-01-05T08:29:00.000Z"));
+		controller.check(new Date("2026-01-05T08:30:00.000Z"));
+		controller.check(new Date("2026-01-05T08:30:59.000Z"));
+		controller.check(new Date("2026-01-12T08:30:00.000Z"));
+
+		expect(seen).toEqual([
+			{
+				bindingId: "native.cron.manual.in",
+				version: 1,
+				payload: { tick: Date.parse("2026-01-05T08:30:00.000Z") },
+			},
+			{
+				bindingId: "native.cron.manual.in",
+				version: 1,
+				payload: { tick: Date.parse("2026-01-12T08:30:00.000Z") },
+			},
+		]);
+		expect(() =>
+			createGraphCronController({
+				targets: [graphCronTarget(Controller, "tick", { expr: "0 30 8 * * 1" })],
+			}),
+		).toThrow(/expected 5 fields/);
+	});
+
+	it("native cron provider rolls back timers when module init fails partway", () => {
+		vi.useFakeTimers();
+		try {
+			vi.setSystemTime(new Date("2026-01-05T08:30:00.000Z"));
+			class Controller {
+				tick() {}
+				bad() {}
+			}
+			const scheduler = provideGraphCronScheduler({
+				targets: [
+					{ target: Controller, methodKey: "tick", expr: "* * * * *", tickMs: 1000 },
+					{ target: Controller, methodKey: "bad", expr: "* * * * *", tickMs: 0 },
+				],
+			}).useValue as { onModuleInit(): void; onModuleDestroy(): void };
+
+			expect(() => scheduler.onModuleInit()).toThrow(/tickMs/);
+			expect(vi.getTimerCount()).toBe(0);
+			scheduler.onModuleDestroy();
+		} finally {
+			vi.useRealTimers();
+		}
+	});
+});
diff --git a/packages/ts/src/__tests__/agent-runtime.part-01.test.ts b/packages/ts/src/__tests__/agent-runtime.part-01.test.ts
new file mode 100644
index 00000000..57e271a0
--- /dev/null
+++ b/packages/ts/src/__tests__/agent-runtime.part-01.test.ts
@@ -0,0 +1,891 @@
+import { describe, expect, it } from "vitest";
+import { graph } from "../graph/graph.js";
+import {
+	type AgentDecisionContinue,
+	type AgentRequestFact,
+	type AgentRequestIssued,
+	type AgentRequestStatusChanged,
+	admitAgentRequestProposal,
+	agentRequestProposalFromDecision,
+	buildToolProviderAdapterInputs,
+	type ContextContribution,
+	type EffectRun,
+	type EffectRunResult,
+	type ExecutorOutcome,
+	type ExecutorProfile,
+	type ExecutorRoute,
+	effectRun,
+	effectRunCompletionProjector,
+	executorOutcomeViewProjector,
+	fakeExecutorFailure,
+	fakeExecutorResult,
+	issueAgentRequest,
+	localBuiltinToolProviderCatalog,
+	type PromptBundle,
+	requestSatisfactionProjector,
+	resolveToolProviderExecutionPolicies,
+	structuredAgentDecisionInterpreter,
+	type ToolProviderAdapterInput,
+	type ToolProviderExecutionPolicy,
+	validateToolProviderExecutionPolicy,
+} from "../orchestration/agent-runtime.js";
+import {
+	type WorkItemDomainActionAdmissionDecision,
+	type WorkItemDomainActionProposal,
+	type WorkItemEffectRequested,
+	type WorkItemEvidenceRecorded,
+	type WorkItemSeed,
+	workItemEffectResultMapper,
+	workItemEffectRunProjector,
+} from "../orchestration/work-item-runtime.js";
+
+function issued(
+	requestId: string,
+	operationId: string,
+	requestKind: AgentRequestIssued["requestKind"],
+	inputKind?: string,
+): AgentRequestIssued {
+	return {
+		kind: "issued",
+		requestId,
+		operationId,
+		effectRunId: "run-1",
+		requestKind,
+		required: true,
+		input:
+			inputKind === undefined
+				? undefined
+				: { inputId: `${requestId}:input`, inputKind, dataMode: "summary", summary: inputKind },
+	};
+}
+
+function toolRequest(
+	requestId: string,
+	operationId: string,
+	toolName: string,
+	operation?: string,
+): AgentRequestIssued {
+	return {
+		kind: "issued",
+		requestId,
+		operationId,
+		effectRunId: "run-1",
+		requestKind: "executor",
+		required: true,
+		input: {
+			inputId: `${requestId}:input`,
+			inputKind: "tool-call",
+			dataMode: "inline",
+			value: {
+				kind: "tool-call",
+				toolName,
+				operation,
+				arguments: { path: "README.md" },
+			},
+		},
+	};
+}
+
+const forbiddenRetentionPayloadPattern =
+	/SCORER_SECRET|SCORER_RAW|rawResponse|stdout|stderr|stack|apiKey|password|arguments|providerClient|oauthState|subprocessHandle|transport|sdkObject/i;
+
+const retentionScorerEntryKeys: Record<string, readonly string[]> = {
+	adapterInputs: [
+		"adapterInputId",
+		"executorId",
+		"insertedAtMs",
+		"key",
+		"operationId",
+		"profileId",
+		"providerId",
+		"requestId",
+		"routeId",
+		"sequence",
+		"status",
+	],
+	runRequests: [
+		"adapterInputId",
+		"attempt",
+		"executorId",
+		"key",
+		"operationId",
+		"profileId",
+		"providerId",
+		"reason",
+		"requestId",
+		"requestedAtMs",
+		"routeId",
+		"runId",
+		"sequence",
+	],
+	executions: [
+		"adapterInputId",
+		"attempt",
+		"executorId",
+		"key",
+		"occurredAtMs",
+		"operationId",
+		"outcomeId",
+		"profileId",
+		"providerId",
+		"reason",
+		"requestId",
+		"routeId",
+		"runId",
+		"sequence",
+		"status",
+	],
+	runStatuses: [
+		"adapterInputId",
+		"attempt",
+		"issueCode",
+		"key",
+		"occurredAtMs",
+		"operationId",
+		"outcomeId",
+		"requestId",
+		"runId",
+		"sequence",
+		"status",
+	],
+	runIssues: [
+		"adapterInputId",
+		"attempt",
+		"issueCode",
+		"key",
+		"occurredAtMs",
+		"operationId",
+		"requestId",
+		"runId",
+		"sequence",
+		"severity",
+		"subjectId",
+	],
+	retentionEvidence: [
+		"adapterInputId",
+		"attemptHighWater",
+		"evidenceKind",
+		"key",
+		"occurredAtMs",
+		"reason",
+		"sequence",
+	],
+};
+
+function _expectRetentionScorerEntryPayloadSafe(index: string, entry: unknown): void {
+	expect(entry).toBeTypeOf("object");
+	expect(Array.isArray(entry)).toBe(false);
+	const record = entry as Record<string, unknown>;
+	const allowed = retentionScorerEntryKeys[index];
+	expect(allowed, `unknown retention scorer index ${index}`).toBeDefined();
+	for (const [key, value] of Object.entries(record)) {
+		expect(allowed).toContain(key);
+		expect(value === undefined || typeof value === "string" || typeof value === "number").toBe(
+			true,
+		);
+		if (key === "key") expect(value).toEqual(expect.stringMatching(/^key:[a-z0-9]+:\d+$/));
+	}
+	expectNoForbiddenRetentionPayload(record);
+}
+
+function expectNoForbiddenRetentionPayload(value: unknown): void {
+	expect(JSON.stringify(value)).not.toMatch(forbiddenRetentionPayloadPattern);
+}
+
+function _readyToolProviderAdapterInput(
+	providerId: string,
+	requestId: string,
+): ToolProviderAdapterInput {
+	const catalog = localBuiltinToolProviderCatalog({ providerId });
+	const profile = catalog.profiles[0];
+	if (profile === undefined) throw new Error("expected profile");
+	const request = toolRequest(requestId, `${requestId}-op`, "file.read", "read");
+	const route: ExecutorRoute = {
+		kind: "executor-route",
+		routeId: `${requestId}-route`,
+		requestId: request.requestId,
+		operationId: request.operationId,
+		executorId: profile.executorId,
+		profileId: profile.profileId,
+		inputKind: "tool-call",
+	};
+	const resolutions = resolveToolProviderExecutionPolicies({
+		request,
+		routes: [route],
+		catalogs: [catalog],
+	});
+	const input = buildToolProviderAdapterInputs({
+		requests: [request],
+		routes: [route],
+		catalogs: [catalog],
+		resolutions,
+	})[0];
+	if (input === undefined || input.status !== "ready") throw new Error("expected ready input");
+	return input;
+}
+
+function _workItemSeed(workItemId: string): WorkItemSeed {
+	return {
+		kind: "work-item",
+		workItemId,
+		sourceRefs: [{ kind: "work-item", id: workItemId }],
+		workItemKind: "issue",
+		lifecycleStatus: "open",
+	};
+}
+
+function _workItemActionProposal(
+	proposalId: string,
+	actionKind: string,
+	opts: Partial<WorkItemDomainActionProposal> = {},
+): WorkItemDomainActionProposal {
+	return {
+		kind: "work-item-domain-action-proposal",
+		proposalId,
+		workItemId: opts.workItemId ?? "wi-1",
+		actionKind,
+		effectRunId: opts.effectRunId ?? "run-1",
+		effectRunResultId: opts.effectRunResultId ?? "run-1:result",
+		evidenceId: opts.evidenceId ?? "wi-1:run-1:run-1:result",
+		policyId: opts.policyId ?? "policy-propose",
+		sourceRefs: opts.sourceRefs,
+		metadata: opts.metadata,
+	};
+}
+
+function _workItemAdmissionDecision(
+	decisionId: string,
+	admissionId: string,
+	proposalId: string,
+	outcome: WorkItemDomainActionAdmissionDecision["outcome"],
+	opts: Partial<WorkItemDomainActionAdmissionDecision> = {},
+): WorkItemDomainActionAdmissionDecision {
+	return {
+		kind: "work-item-domain-action-admission-decision",
+		decisionId,
+		admissionId,
+		proposalId,
+		outcome,
+		policyId: opts.policyId,
+		reason: opts.reason,
+		targetProposalId: opts.targetProposalId,
+		targetAdmissionId: opts.targetAdmissionId,
+		sourceRefs: opts.sourceRefs,
+		decidedAtMs: opts.decidedAtMs,
+		metadata: opts.metadata,
+	};
+}
+
+describe("CSP-8 experimental agent runtime kernel (D236) — part 1", () => {
+	it("projects ExecutorOutcome views with bounded agent-observation material", () => {
+		const g = graph();
+		const outcomes = g.node<ExecutorOutcome>([], null, { name: "outcomes" });
+		const views = executorOutcomeViewProjector(g, {
+			outcomes,
+			policy: { maxSummaryChars: 20, includeIssues: true, includeUsage: true },
+		});
+		const projected: unknown[] = [];
+		const issues: unknown[] = [];
+		const audit: unknown[] = [];
+		views.views.subscribe((msg) => msg[0] === "DATA" && projected.push(msg[1]));
+		views.issues.subscribe((msg) => msg[0] === "DATA" && issues.push(msg[1]));
+		views.audit.subscribe((msg) => msg[0] === "DATA" && audit.push(msg[1]));
+
+		outcomes.down([
+			[
+				"DATA",
+				fakeExecutorFailure({
+					outcomeId: "outcome-1",
+					requestId: "request-1",
+					operationId: "op-1",
+					routeId: "route-1",
+					executorId: "exec-1",
+					profileId: "profile-1",
+					attempt: 1,
+					retryable: true,
+					error: {
+						kind: "issue",
+						code: "provider-failed",
+						message: "Provider returned a long failure message for compact projection",
+					},
+					usage: { inputTokens: 10, outputTokens: 2 },
+					evidenceRefs: [{ kind: "executor-outcome", id: "outcome-1" }],
+				}),
+			],
+		]);
+
+		expect(projected.at(-1)).toMatchObject({
+			kind: "executor-outcome-view",
+			audience: "agent-observation",
+			status: "failure",
+			errorKind: "provider-failed",
+			retryable: true,
+			nextActions: ["retry-or-route"],
+			summaryTruncated: true,
+			summaryLimitChars: 20,
+			usage: { inputTokens: 10, outputTokens: 2 },
+		});
+		expect((projected.at(-1) as { summary: string }).summary.length).toBeLessThanOrEqual(20);
+		expect(issues).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({ code: "provider-failed" }),
+				expect.objectContaining({
+					code: "executor-outcome-view-summary-truncated",
+					severity: "warning",
+					subjectId: "request-1",
+				}),
+			]),
+		);
+		expect(audit.at(-1)).toMatchObject({
+			kind: "executor-outcome-view-projected",
+			subjectId: "request-1",
+		});
+	});
+
+	it("maps WorkItemEffectRequested through EffectRun completion into WorkItemEvidenceRecorded", () => {
+		const g = graph();
+		const workItems = g.node<WorkItemSeed>([], null, { name: "workItems" });
+		const effectRequests = g.node<WorkItemEffectRequested>([], null, {
+			name: "workItemEffectRequests",
+		});
+		const requestFacts = g.node<AgentRequestFact>([], null, { name: "requestFacts" });
+		const profiles = g.node<ExecutorProfile>([], null, { name: "profiles" });
+		const routes = g.node<ExecutorRoute>([], null, { name: "routes" });
+		const outcomes = g.node<ExecutorOutcome>([], null, { name: "outcomes" });
+		const workItemRuns = workItemEffectRunProjector(g, { workItems, effectRequests });
+		const satisfaction = requestSatisfactionProjector(g, {
+			requestFacts,
+			executorProfiles: [profiles],
+			executorRoutes: [routes],
+			executorOutcomes: [outcomes],
+		});
+		const interpreter = structuredAgentDecisionInterpreter(g, outcomes, {
+			requestFacts: [requestFacts],
+		});
+		const completion = effectRunCompletionProjector(g, {
+			effectRuns: workItemRuns.effectRuns,
+			decisions: [interpreter.decisions],
+			requestStatuses: [satisfaction.status],
+			requestFacts: [requestFacts],
+			now: () => 700,
+		});
+		const mapper = workItemEffectResultMapper(g, {
+			workItems,
+			effectRuns: workItemRuns.effectRuns,
+			effectRunResults: completion.results,
+			effectRequests,
+			now: () => 800,
+		});
+		const seededRuns: EffectRun[] = [];
+		const evidence: WorkItemEvidenceRecorded[] = [];
+		const views: unknown[] = [];
+		workItemRuns.effectRuns.subscribe(
+			(msg) => msg[0] === "DATA" && seededRuns.push(msg[1] as EffectRun),
+		);
+		interpreter.decisions.subscribe(() => {});
+		completion.results.subscribe(() => {});
+		mapper.evidence.subscribe(
+			(msg) => msg[0] === "DATA" && evidence.push(msg[1] as WorkItemEvidenceRecorded),
+		);
+		mapper.views.subscribe((msg) => msg[0] === "DATA" && views.push(msg[1]));
+
+		workItems.down([
+			[
+				"DATA",
+				{
+					kind: "work-item",
+					workItemId: "wi-1",
+					sourceRefs: [{ kind: "work-item", id: "wi-1" }],
+					workItemKind: "issue",
+					lifecycleStatus: "open",
+				},
+			],
+		]);
+		effectRequests.down([
+			[
+				"DATA",
+				{
+					kind: "work-item-effect-requested",
+					requestId: "wi-effect-1",
+					workItemId: "wi-1",
+					effectRunId: "run-1",
+					effectKind: "verification",
+					goal: { kind: "verify", summary: "check acceptance" },
+					sourceRefs: [{ kind: "acceptance-criteria", id: "ac-1" }],
+				},
+			],
+		]);
+		expect(seededRuns.at(-1)).toMatchObject({
+			effectRunId: "run-1",
+			subjectRefs: [{ kind: "work-item", id: "wi-1" }],
+			sourceRefs: [
+				{ kind: "work-item", id: "wi-1" },
+				{ kind: "work-item-effect-request", id: "wi-effect-1" },
+				{ kind: "acceptance-criteria", id: "ac-1" },
+			],
+		});
+
+		const continueDecision: AgentDecisionContinue = {
+			kind: "continue",
+			decisionId: "decision-continue",
+			effectRunId: "run-1",
+			agentRunId: "agent-1",
+			source: { requestId: "seed", operationId: "seed-op", outcomeId: "seed-outcome" },
+			next: [],
+		};
+		const proposal = agentRequestProposalFromDecision(continueDecision, {
+			proposalId: "proposal-1",
+			requestKind: "executor",
+			required: true,
+			input: { inputId: "input-1", inputKind: "llm-call", dataMode: "ref", ref: "prompt:p-1" },
+		});
+		const admitted = admitAgentRequestProposal(proposal, {
+			requestId: "request-1",
+			operationId: "op-1",
+			sourceRefs: [{ kind: "agent-decision", id: "decision-continue" }],
+		});
+		const issued = issueAgentRequest(proposal, admitted);
+		requestFacts.down([
+			["DATA", proposal],
+			["DATA", admitted],
+			["DATA", issued],
+		]);
+		profiles.down([
+			[
+				"DATA",
+				{
+					profileId: "profile-1",
+					executorId: "exec-1",
+					kind: "llm",
+					acceptedInputKinds: ["llm-call"],
+				},
+			],
+		]);
+		routes.down([
+			[
+				"DATA",
+				{
+					kind: "executor-route",
+					routeId: "route-1",
+					requestId: "request-1",
+					operationId: "op-1",
+					inputId: "input-1",
+					inputKind: "llm-call",
+					executorId: "exec-1",
+					profileId: "profile-1",
+				},
+			],
+		]);
+		outcomes.down([
+			[
+				"DATA",
+				fakeExecutorResult({
+					outcomeId: "outcome-1",
+					requestId: "request-1",
+					operationId: "op-1",
+					routeId: "route-1",
+					executorId: "exec-1",
+					profileId: "profile-1",
+					attempt: 1,
+					inputId: "input-1",
+					inputKind: "llm-call",
+					result: {
+						kind: "agent-decision",
+						value: {
+							kind: "agent-decision",
+							schemaRef: "graphrefly.agent-decision.v0",
+							decision: {
+								kind: "final",
+								decisionId: "decision-final",
+								effectRunId: "run-1",
+								agentRunId: "agent-1",
+								source: {
+									requestId: "request-1",
+									operationId: "op-1",
+									outcomeId: "outcome-1",
+								},
+								output: { kind: "verified", value: { ok: true } },
+							},
+						},
+					},
+				}),
+			],
+		]);
+
+		expect(evidence.at(-1)).toMatchObject({
+			kind: "work-item-evidence-recorded",
+			workItemId: "wi-1",
+			effectRunId: "run-1",
+			status: "completed",
+			output: { kind: "verified", value: { ok: true } },
+			recordedAtMs: 800,
+		});
+		expect(evidence.at(-1)?.sourceRefs).toEqual(
+			expect.arrayContaining([
+				{ kind: "work-item", id: "wi-1" },
+				{ kind: "work-item-effect-request", id: "wi-effect-1" },
+				{ kind: "acceptance-criteria", id: "ac-1" },
+				{ kind: "effect-run", id: "run-1" },
+				{ kind: "effect-run-result", id: "run-1:result" },
+				{ kind: "agent-decision", id: "decision-final" },
+				{ kind: "executor-outcome", id: "outcome-1" },
+			]),
+		);
+		const latestView = views.at(-1) as {
+			evidenceByWorkItem: Map<string, readonly WorkItemEvidenceRecorded[]>;
+			latestEvidenceByEffectRun: Map<string, WorkItemEvidenceRecorded>;
+			pendingEffectRequests: readonly WorkItemEffectRequested[];
+		};
+		expect(latestView.evidenceByWorkItem.get("wi-1")).toHaveLength(1);
+		expect(latestView.latestEvidenceByEffectRun.get("run-1")?.status).toBe("completed");
+		expect(latestView.pendingEffectRequests).toEqual([]);
+	});
+
+	it("runs the deterministic EffectRun -> request -> fake outcome -> final result path", () => {
+		const g = graph();
+		const effectRuns = g.node<EffectRun>([], null, { name: "effectRuns" });
+		const requestFacts = g.node<AgentRequestFact>([], null, { name: "requestFacts" });
+		const profiles = g.node<ExecutorProfile>([], null, { name: "profiles" });
+		const routes = g.node<ExecutorRoute>([], null, { name: "routes" });
+		const outcomes = g.node<ExecutorOutcome>([], null, { name: "outcomes" });
+		const satisfaction = requestSatisfactionProjector(g, {
+			name: "satisfaction",
+			requestFacts,
+			executorProfiles: [profiles],
+			executorRoutes: [routes],
+			executorOutcomes: [outcomes],
+		});
+		const interpreter = structuredAgentDecisionInterpreter(g, outcomes, {
+			requestFacts: [requestFacts],
+		});
+		const completion = effectRunCompletionProjector(g, {
+			name: "completion",
+			effectRuns,
+			decisions: [interpreter.decisions],
+			requestStatuses: [satisfaction.status],
+			requestFacts: [requestFacts],
+			now: () => 500,
+		});
+		const statuses: AgentRequestStatusChanged[] = [];
+		const results: EffectRunResult[] = [];
+		satisfaction.status.subscribe(
+			(msg) => msg[0] === "DATA" && statuses.push(msg[1] as AgentRequestStatusChanged),
+		);
+		interpreter.decisions.subscribe(() => {});
+		completion.results.subscribe(
+			(msg) => msg[0] === "DATA" && results.push(msg[1] as EffectRunResult),
+		);
+
+		effectRuns.down([
+			[
+				"DATA",
+				effectRun({
+					effectRunId: "run-1",
+					agentRunId: "agent-1",
+					subjectRefs: [{ kind: "work-item", id: "wi-1" }],
+					goal: { kind: "verify", summary: "check acceptance" },
+				}),
+			],
+		]);
+		const continueDecision: AgentDecisionContinue = {
+			kind: "continue",
+			decisionId: "decision-continue",
+			effectRunId: "run-1",
+			agentRunId: "agent-1",
+			source: { requestId: "seed", operationId: "seed-op", outcomeId: "seed-outcome" },
+			next: [],
+		};
+		const proposal = agentRequestProposalFromDecision(continueDecision, {
+			proposalId: "proposal-1",
+			requestKind: "executor",
+			required: true,
+			input: { inputId: "input-1", inputKind: "llm-call", dataMode: "ref", ref: "prompt:p-1" },
+		});
+		const admitted = admitAgentRequestProposal(proposal, {
+			requestId: "request-1",
+			operationId: "op-1",
+			sourceRefs: [{ kind: "agent-decision", id: "decision-continue" }],
+		});
+		const issued = issueAgentRequest(proposal, admitted);
+		requestFacts.down([
+			["DATA", proposal],
+			["DATA", admitted],
+			["DATA", issued],
+		]);
+		profiles.down([
+			[
+				"DATA",
+				{
+					profileId: "profile-1",
+					executorId: "exec-1",
+					kind: "llm",
+					acceptedInputKinds: ["llm-call"],
+				},
+			],
+		]);
+		routes.down([
+			[
+				"DATA",
+				{
+					kind: "executor-route",
+					routeId: "route-1",
+					requestId: "request-1",
+					operationId: "op-1",
+					inputId: "input-1",
+					inputKind: "llm-call",
+					executorId: "exec-1",
+					profileId: "profile-1",
+				},
+			],
+		]);
+		outcomes.down([
+			[
+				"DATA",
+				fakeExecutorResult({
+					outcomeId: "outcome-1",
+					requestId: "request-1",
+					operationId: "op-1",
+					routeId: "route-1",
+					executorId: "exec-1",
+					profileId: "profile-1",
+					attempt: 1,
+					inputId: "input-1",
+					inputKind: "llm-call",
+					result: {
+						kind: "agent-decision",
+						value: {
+							kind: "agent-decision",
+							schemaRef: "graphrefly.agent-decision.v0",
+							decision: {
+								kind: "final",
+								decisionId: "decision-final",
+								effectRunId: "run-1",
+								agentRunId: "agent-1",
+								source: {
+									requestId: "request-1",
+									operationId: "op-1",
+									outcomeId: "outcome-1",
+								},
+								output: { kind: "verified", value: { ok: true } },
+							},
+						},
+					},
+				}),
+			],
+		]);
+
+		expect(statuses.map((s) => s.status)).toContain("awaiting-provider");
+		expect(statuses.at(-1)).toMatchObject({ requestId: "request-1", status: "completed" });
+		expect(results.at(-1)).toMatchObject({
+			kind: "effect-run-result",
+			effectRunId: "run-1",
+			status: "completed",
+			completedAtMs: 500,
+			output: { kind: "verified", value: { ok: true } },
+			sourceRefs: [
+				{ kind: "agent-decision", id: "decision-final" },
+				{ kind: "executor-outcome", id: "outcome-1" },
+			],
+		});
+	});
+
+	it("matches context, prompt, and executor satisfaction by requestId and operationId", () => {
+		const g = graph();
+		const requestFacts = g.node<AgentRequestFact>([], null, { name: "requestFacts" });
+		const context = g.node<ContextContribution>([], null, { name: "context" });
+		const prompts = g.node<PromptBundle>([], null, { name: "prompts" });
+		const profiles = g.node<ExecutorProfile>([], null, { name: "profiles" });
+		const routes = g.node<ExecutorRoute>([], null, { name: "routes" });
+		const outcomes = g.node<ExecutorOutcome>([], null, { name: "outcomes" });
+		const satisfaction = requestSatisfactionProjector(g, {
+			requestFacts,
+			contextContributions: [context],
+			promptBundles: [prompts],
+			executorProfiles: [profiles],
+			executorRoutes: [routes],
+			executorOutcomes: [outcomes],
+		});
+		const statuses: AgentRequestStatusChanged[] = [];
+		satisfaction.status.subscribe(
+			(msg) => msg[0] === "DATA" && statuses.push(msg[1] as AgentRequestStatusChanged),
+		);
+		const contextReq = issued("context-1", "ctx-op", "context");
+		const promptReq = issued("prompt-1", "prompt-op", "prompt");
+		const executorReq = issued("exec-1", "exec-op", "executor", "tool-call");
+
+		requestFacts.down([
+			["DATA", contextReq],
+			["DATA", promptReq],
+			["DATA", executorReq],
+		]);
+		context.down([
+			[
+				"DATA",
+				{
+					kind: "context-contribution",
+					contributionId: "ctx-1",
+					requestId: "context-1",
+					operationId: "ctx-op",
+					status: "ready",
+					frameId: "frame-1",
+				},
+			],
+		]);
+		prompts.down([
+			[
+				"DATA",
+				{
+					kind: "prompt-bundle",
+					promptId: "prompt-bundle-1",
+					requestId: "prompt-1",
+					operationId: "prompt-op",
+					status: "ready",
+					sourceFrameIds: ["frame-1"],
+				},
+			],
+		]);
+		profiles.down([["DATA", { profileId: "tool-profile", executorId: "tool-exec", kind: "tool" }]]);
+		routes.down([
+			[
+				"DATA",
+				{
+					kind: "executor-route",
+					routeId: "tool-route",
+					requestId: "exec-1",
+					operationId: "exec-op",
+					inputKind: "tool-call",
+					executorId: "tool-exec",
+					profileId: "tool-profile",
+				},
+			],
+		]);
+		outcomes.down([
+			[
+				"DATA",
+				fakeExecutorResult({
+					outcomeId: "tool-outcome",
+					requestId: "exec-1",
+					operationId: "exec-op",
+					routeId: "tool-route",
+					executorId: "tool-exec",
+					profileId: "tool-profile",
+					attempt: 1,
+					inputKind: "tool-call",
+					result: { kind: "tool-result", value: { ok: true } },
+				}),
+			],
+		]);
+
+		expect(
+			statuses
+				.filter((s) => s.status === "completed")
+				.map((s) => s.requestId)
+				.sort(),
+		).toEqual(["context-1", "exec-1", "prompt-1"]);
+	});
+
+	it("uses local builtin tool catalog facts without adding provider handles to WorkItem core", () => {
+		const g = graph();
+		const requestFacts = g.node<AgentRequestFact>([], null, { name: "requestFacts" });
+		const profiles = g.node<ExecutorProfile>([], null, { name: "profiles" });
+		const routes = g.node<ExecutorRoute>([], null, { name: "routes" });
+		const outcomes = g.node<ExecutorOutcome>([], null, { name: "outcomes" });
+		const satisfaction = requestSatisfactionProjector(g, {
+			requestFacts,
+			executorProfiles: [profiles],
+			executorRoutes: [routes],
+			executorOutcomes: [outcomes],
+		});
+		const statuses: AgentRequestStatusChanged[] = [];
+		satisfaction.status.subscribe(
+			(msg) => msg[0] === "DATA" && statuses.push(msg[1] as AgentRequestStatusChanged),
+		);
+		const catalog = localBuiltinToolProviderCatalog({
+			providerId: "local",
+			limits: { timeoutMs: 1000 },
+		});
+		const profile = catalog.profiles[0];
+		if (profile === undefined) throw new Error("expected local builtin tool profile");
+		const policy = catalog.policies?.[0];
+		if (policy === undefined) throw new Error("expected default tool provider policy");
+		expect(catalog.tools.map((tool) => tool.toolName)).toEqual(
+			expect.arrayContaining(["file.read", "bash.run", "url.fetch"]),
+		);
+		expect(policy).toMatchObject({
+			kind: "tool-provider-execution-policy",
+			providerId: "local",
+			profileIds: [profile.profileId],
+			toolNames: expect.arrayContaining(["file.read", "bash.run", "url.fetch"]),
+			operations: expect.arrayContaining(["read", "run", "fetch"]),
+			timeout: { timeoutMs: 30_000 },
+			redaction: { mode: "summary" },
+			filesystem: { cwd: ".", allowRead: true, allowWrite: false },
+			approval: {
+				mode: "require",
+				requiredForToolNames: expect.arrayContaining(["file.edit/apply-patch", "bash.run"]),
+			},
+			artifacts: { defaultDataMode: "summary" },
+			network: { mode: "custom", protocols: ["https:"] },
+		} satisfies Partial<ToolProviderExecutionPolicy>);
+		expect(policy.sizeCapacity?.limits).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({ unit: "chars", perRequest: true }),
+				expect.objectContaining({ unit: "bytes", perArtifact: true }),
+				expect.objectContaining({ unit: "lines", perStream: true }),
+			]),
+		);
+		expect(validateToolProviderExecutionPolicy(policy)).toEqual([]);
+		expect(catalog.policyRefs).toEqual([
+			{ kind: "tool-provider-execution-policy", id: policy.policyId },
+		]);
+		expect(profile.policyRefs).toEqual(catalog.policyRefs);
+		for (const tool of catalog.tools) expect(tool.policyRefs).toEqual(catalog.policyRefs);
+		expect(profile).toMatchObject({
+			kind: "tool",
+			acceptedInputKinds: ["tool-call"],
+			limits: { timeoutMs: 1000 },
+		});
+		expect(JSON.stringify(catalog)).not.toMatch(
+			/apiKey|secret|client|transport|subprocess|sdk|oauth|credential/i,
+		);
+
+		requestFacts.down([["DATA", issued("tool-req", "tool-op", "executor", "tool-call")]]);
+		profiles.down([["DATA", profile]]);
+		routes.down([
+			[
+				"DATA",
+				{
+					kind: "executor-route",
+					routeId: "tool-route",
+					requestId: "tool-req",
+					operationId: "tool-op",
+					inputKind: "tool-call",
+					executorId: profile.executorId,
+					profileId: profile.profileId,
+				},
+			],
+		]);
+		outcomes.down([
+			[
+				"DATA",
+				fakeExecutorResult({
+					outcomeId: "tool-outcome",
+					requestId: "tool-req",
+					operationId: "tool-op",
+					routeId: "tool-route",
+					executorId: profile.executorId,
+					profileId: profile.profileId,
+					attempt: 1,
+					inputKind: "tool-call",
+					result: {
+						kind: "tool-result",
+						summary: "read complete",
+						refs: [{ kind: "artifact", id: "artifact:file-read:1" }],
+					},
+				}),
+			],
+		]);
+
+		expect(statuses.at(-1)).toMatchObject({ requestId: "tool-req", status: "completed" });
+	});
+});
diff --git a/packages/ts/src/__tests__/agent-runtime.part-02.test.ts b/packages/ts/src/__tests__/agent-runtime.part-02.test.ts
new file mode 100644
index 00000000..76352242
--- /dev/null
+++ b/packages/ts/src/__tests__/agent-runtime.part-02.test.ts
@@ -0,0 +1,935 @@
+import { describe, expect, it } from "vitest";
+import type { DataIssue } from "../data/index.js";
+import { graph } from "../graph/graph.js";
+import {
+	type AgentDecisionContinue,
+	type AgentRequestIssued,
+	type AgentRequestStatusChanged,
+	admitAgentRequestProposal,
+	agentRequestProposalFromDecision,
+	buildToolProviderAdapterInputs,
+	type ExecutorOutcome,
+	type ExecutorRoute,
+	issueAgentRequest,
+	localBuiltinToolProviderCatalog,
+	resolveToolProviderExecutionPolicies,
+	type SourceRef,
+	type ToolProviderAdapterInput,
+	type ToolProviderAdapterRunResult,
+	type ToolProviderCatalog,
+	type ToolProviderExecutionPolicy,
+} from "../orchestration/agent-runtime.js";
+import { attachToolProviderAdapterRuntime } from "../orchestration/agent-runtime-adapter-runtime.js";
+import type { ToolProviderAdapterBinding } from "../orchestration/agent-runtime-types-tool.js";
+import type {
+	WorkItemDomainActionAdmissionDecision,
+	WorkItemDomainActionProposal,
+	WorkItemSeed,
+} from "../orchestration/work-item-runtime.js";
+
+function _issued(
+	requestId: string,
+	operationId: string,
+	requestKind: AgentRequestIssued["requestKind"],
+	inputKind?: string,
+): AgentRequestIssued {
+	return {
+		kind: "issued",
+		requestId,
+		operationId,
+		effectRunId: "run-1",
+		requestKind,
+		required: true,
+		input:
+			inputKind === undefined
+				? undefined
+				: { inputId: `${requestId}:input`, inputKind, dataMode: "summary", summary: inputKind },
+	};
+}
+
+function toolRequest(
+	requestId: string,
+	operationId: string,
+	toolName: string,
+	operation?: string,
+): AgentRequestIssued {
+	return {
+		kind: "issued",
+		requestId,
+		operationId,
+		effectRunId: "run-1",
+		requestKind: "executor",
+		required: true,
+		input: {
+			inputId: `${requestId}:input`,
+			inputKind: "tool-call",
+			dataMode: "inline",
+			value: {
+				kind: "tool-call",
+				toolName,
+				operation,
+				arguments: { path: "README.md" },
+			},
+		},
+	};
+}
+
+const forbiddenRetentionPayloadPattern =
+	/SCORER_SECRET|SCORER_RAW|rawResponse|stdout|stderr|stack|apiKey|password|arguments|providerClient|oauthState|subprocessHandle|transport|sdkObject/i;
+
+const retentionScorerEntryKeys: Record<string, readonly string[]> = {
+	adapterInputs: [
+		"adapterInputId",
+		"executorId",
+		"insertedAtMs",
+		"key",
+		"operationId",
+		"profileId",
+		"providerId",
+		"requestId",
+		"routeId",
+		"sequence",
+		"status",
+	],
+	runRequests: [
+		"adapterInputId",
+		"attempt",
+		"executorId",
+		"key",
+		"operationId",
+		"profileId",
+		"providerId",
+		"reason",
+		"requestId",
+		"requestedAtMs",
+		"routeId",
+		"runId",
+		"sequence",
+	],
+	executions: [
+		"adapterInputId",
+		"attempt",
+		"executorId",
+		"key",
+		"occurredAtMs",
+		"operationId",
+		"outcomeId",
+		"profileId",
+		"providerId",
+		"reason",
+		"requestId",
+		"routeId",
+		"runId",
+		"sequence",
+		"status",
+	],
+	runStatuses: [
+		"adapterInputId",
+		"attempt",
+		"issueCode",
+		"key",
+		"occurredAtMs",
+		"operationId",
+		"outcomeId",
+		"requestId",
+		"runId",
+		"sequence",
+		"status",
+	],
+	runIssues: [
+		"adapterInputId",
+		"attempt",
+		"issueCode",
+		"key",
+		"occurredAtMs",
+		"operationId",
+		"requestId",
+		"runId",
+		"sequence",
+		"severity",
+		"subjectId",
+	],
+	retentionEvidence: [
+		"adapterInputId",
+		"attemptHighWater",
+		"evidenceKind",
+		"key",
+		"occurredAtMs",
+		"reason",
+		"sequence",
+	],
+};
+
+function _expectRetentionScorerEntryPayloadSafe(index: string, entry: unknown): void {
+	expect(entry).toBeTypeOf("object");
+	expect(Array.isArray(entry)).toBe(false);
+	const record = entry as Record<string, unknown>;
+	const allowed = retentionScorerEntryKeys[index];
+	expect(allowed, `unknown retention scorer index ${index}`).toBeDefined();
+	for (const [key, value] of Object.entries(record)) {
+		expect(allowed).toContain(key);
+		expect(value === undefined || typeof value === "string" || typeof value === "number").toBe(
+			true,
+		);
+		if (key === "key") expect(value).toEqual(expect.stringMatching(/^key:[a-z0-9]+:\d+$/));
+	}
+	expectNoForbiddenRetentionPayload(record);
+}
+
+function expectNoForbiddenRetentionPayload(value: unknown): void {
+	expect(JSON.stringify(value)).not.toMatch(forbiddenRetentionPayloadPattern);
+}
+
+function readyToolProviderAdapterInput(
+	providerId: string,
+	requestId: string,
+): ToolProviderAdapterInput {
+	const catalog = localBuiltinToolProviderCatalog({ providerId });
+	const profile = catalog.profiles[0];
+	if (profile === undefined) throw new Error("expected profile");
+	const request = toolRequest(requestId, `${requestId}-op`, "file.read", "read");
+	const route: ExecutorRoute = {
+		kind: "executor-route",
+		routeId: `${requestId}-route`,
+		requestId: request.requestId,
+		operationId: request.operationId,
+		executorId: profile.executorId,
+		profileId: profile.profileId,
+		inputKind: "tool-call",
+	};
+	const resolutions = resolveToolProviderExecutionPolicies({
+		request,
+		routes: [route],
+		catalogs: [catalog],
+	});
+	const input = buildToolProviderAdapterInputs({
+		requests: [request],
+		routes: [route],
+		catalogs: [catalog],
+		resolutions,
+	})[0];
+	if (input === undefined || input.status !== "ready") throw new Error("expected ready input");
+	return input;
+}
+
+function _workItemSeed(workItemId: string): WorkItemSeed {
+	return {
+		kind: "work-item",
+		workItemId,
+		sourceRefs: [{ kind: "work-item", id: workItemId }],
+		workItemKind: "issue",
+		lifecycleStatus: "open",
+	};
+}
+
+function _workItemActionProposal(
+	proposalId: string,
+	actionKind: string,
+	opts: Partial<WorkItemDomainActionProposal> = {},
+): WorkItemDomainActionProposal {
+	return {
+		kind: "work-item-domain-action-proposal",
+		proposalId,
+		workItemId: opts.workItemId ?? "wi-1",
+		actionKind,
+		effectRunId: opts.effectRunId ?? "run-1",
+		effectRunResultId: opts.effectRunResultId ?? "run-1:result",
+		evidenceId: opts.evidenceId ?? "wi-1:run-1:run-1:result",
+		policyId: opts.policyId ?? "policy-propose",
+		sourceRefs: opts.sourceRefs,
+		metadata: opts.metadata,
+	};
+}
+
+function _workItemAdmissionDecision(
+	decisionId: string,
+	admissionId: string,
+	proposalId: string,
+	outcome: WorkItemDomainActionAdmissionDecision["outcome"],
+	opts: Partial<WorkItemDomainActionAdmissionDecision> = {},
+): WorkItemDomainActionAdmissionDecision {
+	return {
+		kind: "work-item-domain-action-admission-decision",
+		decisionId,
+		admissionId,
+		proposalId,
+		outcome,
+		policyId: opts.policyId,
+		reason: opts.reason,
+		targetProposalId: opts.targetProposalId,
+		targetAdmissionId: opts.targetAdmissionId,
+		sourceRefs: opts.sourceRefs,
+		decidedAtMs: opts.decidedAtMs,
+		metadata: opts.metadata,
+	};
+}
+
+describe("CSP-8 experimental agent runtime kernel (D236) — part 2", () => {
+	it("scopes D360 tool policy refs and omits stale default policy sections", () => {
+		const scopedCatalog = localBuiltinToolProviderCatalog({
+			providerId: "scoped",
+			tools: [
+				{ toolName: "file.read", operation: "read" },
+				{ toolName: "bash.run", operation: "run" },
+			],
+			policies: [
+				{
+					kind: "tool-provider-execution-policy",
+					policyId: "scoped:policy:file-read",
+					providerId: "scoped",
+					toolNames: ["file.read"],
+					operations: ["read"],
+					sizeCapacity: { limits: [{ unit: "chars", hardLimit: 100 }] },
+				},
+				{
+					kind: "tool-provider-execution-policy",
+					policyId: "scoped:policy:bash",
+					providerId: "scoped",
+					toolNames: ["bash.run"],
+					operations: ["run"],
+					timeout: { timeoutMs: 1000 },
+				},
+			],
+		});
+		expect(scopedCatalog.profiles[0]?.policyRefs).toEqual([
+			{ kind: "tool-provider-execution-policy", id: "scoped:policy:file-read" },
+			{ kind: "tool-provider-execution-policy", id: "scoped:policy:bash" },
+		]);
+		expect(scopedCatalog.tools.find((tool) => tool.toolName === "file.read")?.policyRefs).toEqual([
+			{ kind: "tool-provider-execution-policy", id: "scoped:policy:file-read" },
+		]);
+		expect(scopedCatalog.tools.find((tool) => tool.toolName === "bash.run")?.policyRefs).toEqual([
+			{ kind: "tool-provider-execution-policy", id: "scoped:policy:bash" },
+		]);
+
+		const dateOnlyCatalog = localBuiltinToolProviderCatalog({
+			providerId: "date-only",
+			tools: [{ toolName: "date.now", operation: "read" }],
+		});
+		expect(dateOnlyCatalog.policies?.[0]?.toolNames).toEqual(["date.now"]);
+		expect(dateOnlyCatalog.policies?.[0]?.network).toBeUndefined();
+		expect(dateOnlyCatalog.policies?.[0]?.filesystem).toBeUndefined();
+		expect(dateOnlyCatalog.policies?.[0]?.approval).toMatchObject({ mode: "auto" });
+
+		const invalidCatalog = localBuiltinToolProviderCatalog({
+			providerId: "invalid",
+			policyOverrides: {
+				metadata: {
+					apiKey: "do-not-publish",
+					rawResponse: "RAW_POLICY_SHOULD_NOT_PROJECT",
+				},
+			},
+		});
+		expect(invalidCatalog.status).toBe("misconfigured");
+		expect(invalidCatalog.policies).toEqual([]);
+		expect(invalidCatalog.issues).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({ code: "tool-provider-policy-forbidden-runtime-material" }),
+			]),
+		);
+		expect(JSON.stringify(invalidCatalog)).not.toMatch(
+			/apiKey|secret|client|transport|subprocess|sdk|oauth|credential|rawResponse|RAW_POLICY_SHOULD_NOT_PROJECT/i,
+		);
+		const malformedCatalog = localBuiltinToolProviderCatalog({
+			providerId: "malformed",
+			policies: [
+				{
+					kind: "tool-provider-execution-policy",
+					policyId: "malformed:policy",
+					providerId: "malformed",
+					sizeCapacity: { limits: [{ unit: "bytes", softLimit: 2, hardLimit: 1 }] },
+				},
+			],
+		});
+		expect(malformedCatalog.status).toBe("misconfigured");
+		expect(malformedCatalog.policies).toEqual([]);
+		expect(malformedCatalog.issues).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({ code: "tool-provider-policy-invalid-size-limit" }),
+			]),
+		);
+	});
+
+	it("sanitizes issued request material before it reaches graph-visible ledgers", () => {
+		const decision: AgentDecisionContinue = {
+			kind: "continue",
+			decisionId: "decision-issue-sanitize",
+			effectRunId: "run-issue-sanitize",
+			agentRunId: "agent-issue-sanitize",
+			source: { requestId: "seed", operationId: "seed-op", outcomeId: "seed-outcome" },
+			next: [],
+		};
+		const proposal = agentRequestProposalFromDecision(decision, {
+			proposalId: "proposal-issue-sanitize",
+			requestKind: "executor",
+			input: {
+				inputId: "input-issue-sanitize",
+				inputKind: "tool-call",
+				dataMode: "inline",
+				value: { rawResponse: "RAW_REQUEST_INPUT_SHOULD_NOT_PROJECT" },
+				subjectRefs: [
+					{
+						kind: "provider-raw",
+						id: "input-ref",
+						metadata: { stdout: "RAW_REQUEST_INPUT_REF_SHOULD_NOT_PROJECT" },
+						client: "RAW_REQUEST_INPUT_REF_EXTRA_SHOULD_NOT_PROJECT",
+					} as unknown as SourceRef,
+				],
+				metadata: { apiKey: "REQUEST_INPUT_SECRET" },
+			},
+			payload: { providerRaw: "RAW_REQUEST_PAYLOAD_SHOULD_NOT_PROJECT" },
+			metadata: { rawResponse: "RAW_REQUEST_METADATA_SHOULD_NOT_PROJECT" },
+		});
+		const admitted = admitAgentRequestProposal(proposal, {
+			requestId: "request-issue-sanitize",
+			operationId: "op-issue-sanitize",
+			reason: `${"admit-reason-".repeat(80)}RAW_ADMISSION_REASON_SHOULD_NOT_PROJECT`,
+			sourceRefs: [
+				{
+					kind: "provider-raw",
+					id: "admission-ref",
+					metadata: { stderr: "RAW_REQUEST_SOURCE_REF_SHOULD_NOT_PROJECT" },
+					rawResponse: "RAW_REQUEST_SOURCE_REF_EXTRA_SHOULD_NOT_PROJECT",
+				} as unknown as SourceRef,
+			],
+			metadata: { rawResponse: "RAW_ADMISSION_METADATA_SHOULD_NOT_PROJECT" },
+		});
+
+		const issuedRequest = issueAgentRequest(proposal, admitted);
+
+		expect(admitted.reason?.length).toBeLessThanOrEqual(512);
+		expect(admitted.sourceRefs).toEqual([{ kind: "provider-raw", id: "admission-ref" }]);
+		expect(admitted).not.toHaveProperty("metadata");
+		expect(issuedRequest.input).toMatchObject({
+			inputId: "input-issue-sanitize",
+			inputKind: "tool-call",
+			dataMode: "inline",
+		});
+		expect(issuedRequest.input).not.toHaveProperty("value");
+		expect(issuedRequest.input).not.toHaveProperty("metadata");
+		expect(issuedRequest.input?.subjectRefs).toEqual([{ kind: "provider-raw", id: "input-ref" }]);
+		expect(issuedRequest).not.toHaveProperty("payload");
+		expect(issuedRequest).not.toHaveProperty("metadata");
+		expect(issuedRequest.sourceRefs).toEqual([{ kind: "provider-raw", id: "admission-ref" }]);
+		expect(JSON.stringify(issuedRequest)).not.toMatch(
+			/RAW_REQUEST_|RAW_ADMISSION_|rawResponse|providerRaw|stdout|stderr|client|apiKey|REQUEST_INPUT_SECRET/,
+		);
+		expect(JSON.stringify(admitted)).not.toMatch(/RAW_ADMISSION_|rawResponse|stderr/);
+
+		const mutablePayload = { nested: { public: "ok" } };
+		const safeProposal = agentRequestProposalFromDecision(decision, {
+			proposalId: "proposal-mutable-issue-sanitize",
+			requestKind: "executor",
+			payload: mutablePayload,
+		});
+		const mutableIssued = issueAgentRequest(safeProposal, {
+			...admitted,
+			proposalId: safeProposal.proposalId,
+			requestId: "request-mutable-issue-sanitize",
+		});
+		mutablePayload.nested = {
+			public: "ok",
+			rawResponse: "RAW_MUTATED_REQUEST_PAYLOAD_SHOULD_NOT_PROJECT",
+		} as typeof mutablePayload.nested;
+		expect(JSON.stringify(mutableIssued)).not.toMatch(/RAW_MUTATED_REQUEST_PAYLOAD|rawResponse/);
+		expect(mutableIssued.payload).toEqual({ nested: { public: "ok" } });
+	});
+
+	it("keeps local builtin catalog caller material data-only and provider-scoped", () => {
+		const leakyCatalog = localBuiltinToolProviderCatalog({
+			providerId: "leaky",
+			metadata: { apiKey: "do-not-publish", rawResponse: "RAW_CATALOG_METADATA" },
+			capabilities: { client: "do-not-publish", stdout: "RAW_CATALOG_CAPABILITY" },
+			tools: [
+				{
+					toolName: "file.read",
+					operation: "read",
+					metadata: { secret: "do-not-publish", stderr: "RAW_TOOL_METADATA" },
+					capabilities: { transport: "do-not-publish", rawResponse: "RAW_TOOL_CAPABILITY" },
+					policyRefs: [{ kind: "foreign-policy", id: "stale" }],
+				},
+			],
+			policyOverrides: {
+				providerId: "foreign",
+				policyId: "secret-policy-id",
+			} as Partial<Omit<ToolProviderExecutionPolicy, "kind" | "policyId" | "providerId">>,
+		});
+		expect(leakyCatalog.status).toBe("misconfigured");
+		expect(leakyCatalog.policies?.[0]).toMatchObject({
+			policyId: "leaky:policy:default",
+			providerId: "leaky",
+		});
+		expect(leakyCatalog.tools[0]?.policyRefs).toEqual(leakyCatalog.policyRefs);
+		expect(leakyCatalog.metadata).toBeUndefined();
+		expect(leakyCatalog.profiles[0]?.capabilities).toEqual({ toolNames: ["file.read"] });
+		expect(leakyCatalog.tools[0]?.metadata).toBeUndefined();
+		expect(leakyCatalog.tools[0]?.capabilities).toBeUndefined();
+		expect(leakyCatalog.issues).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({
+					code: "tool-provider-catalog-forbidden-runtime-material",
+				}),
+			]),
+		);
+		expect(JSON.stringify(leakyCatalog)).not.toMatch(
+			/apiKey|secret|client|transport|subprocess|sdk|oauth|credential|rawResponse|RAW_/i,
+		);
+
+		const foreignPolicyCatalog = localBuiltinToolProviderCatalog({
+			providerId: "provider-a",
+			policies: [
+				{
+					kind: "tool-provider-execution-policy",
+					policyId: "foreign-policy",
+					providerId: "provider-b",
+					timeout: { timeoutMs: 1000 },
+				},
+			],
+		});
+		expect(foreignPolicyCatalog.status).toBe("misconfigured");
+		expect(foreignPolicyCatalog.policies).toEqual([]);
+		expect(foreignPolicyCatalog.issues).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({ code: "tool-provider-policy-provider-mismatch" }),
+			]),
+		);
+	});
+
+	it("resolves D360 policy material for routed tool-call requests without executing tools", () => {
+		const catalog = localBuiltinToolProviderCatalog({ providerId: "resolver" });
+		const profile = catalog.profiles[0];
+		if (profile === undefined) throw new Error("expected profile");
+		const request = toolRequest("tool-req", "tool-op", "file.read", "read");
+		const route: ExecutorRoute = {
+			kind: "executor-route",
+			routeId: "tool-route",
+			requestId: request.requestId,
+			operationId: request.operationId,
+			executorId: profile.executorId,
+			profileId: profile.profileId,
+			inputKind: "tool-call",
+		};
+
+		expect(resolveToolProviderExecutionPolicies({ request, catalogs: [catalog] })).toEqual([
+			expect.objectContaining({
+				kind: "tool-provider-policy-resolution",
+				status: "pending-route",
+				requestId: "tool-req",
+				toolName: "file.read",
+			}),
+		]);
+		expect(
+			resolveToolProviderExecutionPolicies({ request, routes: [route], catalogs: [catalog] }),
+		).toEqual([
+			expect.objectContaining({
+				kind: "tool-provider-policy-resolution",
+				status: "resolved",
+				routeId: "tool-route",
+				providerId: "resolver",
+				policyRefs: catalog.tools.find((tool) => tool.toolName === "file.read")?.policyRefs,
+			}),
+		]);
+
+		const wrongKindCatalog: ToolProviderCatalog = {
+			...catalog,
+			tools: catalog.tools.map((tool) =>
+				tool.toolName === "file.read"
+					? {
+							...tool,
+							policyRefs: [{ kind: "other-policy", id: catalog.policies?.[0]?.policyId ?? "" }],
+						}
+					: tool,
+			),
+		};
+		expect(
+			resolveToolProviderExecutionPolicies({
+				request,
+				routes: [route],
+				catalogs: [wrongKindCatalog],
+			}),
+		).toEqual([
+			expect.objectContaining({
+				status: "invalid-policy",
+				issues: expect.arrayContaining([
+					expect.objectContaining({ code: "tool-provider-policy-invalid-ref-kind" }),
+				]),
+			}),
+		]);
+	});
+
+	it("builds ready D360 adapter inputs from routed tool-call policy resolutions", () => {
+		const catalog = localBuiltinToolProviderCatalog({ providerId: "adapter" });
+		const profile = catalog.profiles[0];
+		if (profile === undefined) throw new Error("expected profile");
+		const request = toolRequest("adapter-req", "adapter-op", "file.read", "read");
+		const route: ExecutorRoute = {
+			kind: "executor-route",
+			routeId: "adapter-route",
+			requestId: request.requestId,
+			operationId: request.operationId,
+			executorId: profile.executorId,
+			profileId: profile.profileId,
+			inputKind: "tool-call",
+			allowedParams: { cwd: ".", timeoutMs: 1000 },
+		};
+		const resolutions = resolveToolProviderExecutionPolicies({
+			request,
+			routes: [route],
+			catalogs: [catalog],
+		});
+
+		const inputs = buildToolProviderAdapterInputs({
+			requests: [request],
+			routes: [route],
+			catalogs: [catalog],
+			resolutions,
+		});
+
+		expect(inputs).toEqual([
+			expect.objectContaining({
+				kind: "tool-provider-adapter-input",
+				status: "ready",
+				requestId: "adapter-req",
+				operationId: "adapter-op",
+				routeId: "adapter-route",
+				providerId: "adapter",
+				executorId: profile.executorId,
+				profileId: profile.profileId,
+				toolName: "file.read",
+				operation: "read",
+				toolCall: expect.objectContaining({ kind: "tool-call", toolName: "file.read" }),
+				policies: catalog.policies,
+				policyRefs: catalog.tools.find((tool) => tool.toolName === "file.read")?.policyRefs,
+			}),
+		]);
+		expect(inputs[0]?.input).toBe(request.input);
+		expect(inputs[0]?.route).toBe(route);
+		expect(inputs[0]?.policies?.[0]).toBe(catalog.policies?.[0]);
+		expect(JSON.stringify(inputs)).not.toMatch(
+			/apiKey|secret|client|transport|subprocess|sdk|oauth|credential/i,
+		);
+	});
+
+	it("attaches runtime-private tool provider bindings and publishes neutral outcomes", () => {
+		const g = graph();
+		const inputs = g.node<ToolProviderAdapterInput>([], null, { name: "runtime-inputs" });
+		const ready = readyToolProviderAdapterInput("runtime-provider", "runtime-req");
+		const calls: ToolProviderAdapterInput[] = [];
+		const binding: ToolProviderAdapterBinding = {
+			providerId: "runtime-provider",
+			run(input) {
+				calls.push(input);
+				return {
+					kind: "result",
+					result: {
+						kind: "tool-output",
+						value: { ok: true },
+						summary: "fake adapter result",
+					},
+					usage: { latencyMs: 7 },
+				};
+			},
+		};
+		const runtime = attachToolProviderAdapterRuntime(g, {
+			inputs,
+			bindings: [binding],
+			now: () => 123,
+		});
+		const outcomes: ExecutorOutcome[] = [];
+		const status: AgentRequestStatusChanged[] = [];
+		const issues: unknown[] = [];
+		const audit: unknown[] = [];
+		runtime.outcomes.subscribe(
+			(msg) => msg[0] === "DATA" && outcomes.push(msg[1] as ExecutorOutcome),
+		);
+		runtime.status.subscribe(
+			(msg) => msg[0] === "DATA" && status.push(msg[1] as AgentRequestStatusChanged),
+		);
+		runtime.issues.subscribe((msg) => msg[0] === "DATA" && issues.push(msg[1]));
+		runtime.audit.subscribe((msg) => msg[0] === "DATA" && audit.push(msg[1]));
+
+		inputs.down([["DATA", { ...ready, status: "missing-policy" }]]);
+		inputs.down([["DATA", ready]]);
+
+		expect(calls).toEqual([ready]);
+		expect(status.map((fact) => fact.status)).toEqual(["in-flight", "completed"]);
+		expect(outcomes).toEqual([
+			expect.objectContaining({
+				kind: "result",
+				requestId: "runtime-req",
+				operationId: "runtime-req-op",
+				routeId: "runtime-req-route",
+				executorId: ready.executorId,
+				profileId: ready.profileId,
+				attempt: 1,
+				occurredAtMs: 123,
+				usage: { latencyMs: 7 },
+				result: expect.objectContaining({ summary: "fake adapter result" }),
+			}),
+		]);
+		expect(issues).toEqual([]);
+		expect(audit).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({ kind: "tool-provider-adapter-runtime-started" }),
+				expect.objectContaining({ kind: "tool-provider-adapter-runtime-finished" }),
+			]),
+		);
+		runtime.dispose();
+	});
+
+	it("reports missing tool provider runtime bindings as blocked outcomes", () => {
+		const g = graph();
+		const inputs = g.node<ToolProviderAdapterInput>([], null, { name: "runtime-missing-inputs" });
+		const runtime = attachToolProviderAdapterRuntime(g, { inputs, bindings: [] });
+		const ready = readyToolProviderAdapterInput("missing-runtime-provider", "missing-runtime-req");
+		const outcomes: ExecutorOutcome[] = [];
+		const status: AgentRequestStatusChanged[] = [];
+		const issues: unknown[] = [];
+		runtime.outcomes.subscribe(
+			(msg) => msg[0] === "DATA" && outcomes.push(msg[1] as ExecutorOutcome),
+		);
+		runtime.status.subscribe(
+			(msg) => msg[0] === "DATA" && status.push(msg[1] as AgentRequestStatusChanged),
+		);
+		runtime.issues.subscribe((msg) => msg[0] === "DATA" && issues.push(msg[1]));
+
+		inputs.down([["DATA", ready]]);
+
+		expect(outcomes).toEqual([
+			expect.objectContaining({
+				kind: "blocked",
+				requestId: "missing-runtime-req",
+				needs: [expect.objectContaining({ kind: "tool-provider-binding" })],
+			}),
+		]);
+		expect(status.at(-1)).toMatchObject({ status: "blocked" });
+		expect(issues).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({ code: "tool-provider-adapter-runtime-missing-binding" }),
+			]),
+		);
+	});
+
+	it("blocks runtime-private material returned by tool provider bindings", () => {
+		const g = graph();
+		const inputs = g.node<ToolProviderAdapterInput>([], null, { name: "runtime-leak-inputs" });
+		const ready = readyToolProviderAdapterInput("runtime-leak-provider", "runtime-leak-req");
+		const runtime = attachToolProviderAdapterRuntime(g, {
+			inputs,
+			bindings: [
+				{
+					providerId: "runtime-leak-provider",
+					run() {
+						return {
+							kind: "result",
+							result: {
+								kind: "tool-output",
+								value: { accessToken: "secret-token" },
+							},
+						};
+					},
+				},
+			],
+		});
+		const outcomes: ExecutorOutcome[] = [];
+		const issues: unknown[] = [];
+		runtime.outcomes.subscribe(
+			(msg) => msg[0] === "DATA" && outcomes.push(msg[1] as ExecutorOutcome),
+		);
+		runtime.issues.subscribe((msg) => msg[0] === "DATA" && issues.push(msg[1]));
+
+		inputs.down([["DATA", ready]]);
+
+		expect(outcomes).toEqual([
+			expect.objectContaining({
+				kind: "failure",
+				error: expect.objectContaining({
+					code: "tool-provider-adapter-runtime-forbidden-runtime-material",
+				}),
+			}),
+		]);
+		expect(issues).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({
+					code: "tool-provider-adapter-runtime-forbidden-runtime-material",
+				}),
+			]),
+		);
+		expect(JSON.stringify({ outcomes, issues })).not.toMatch(/accessToken|secret-token/i);
+	});
+
+	it("blocks non-plain runtime objects returned by tool provider bindings", () => {
+		class RuntimeClient {}
+		const g = graph();
+		const inputs = g.node<ToolProviderAdapterInput>([], null, { name: "runtime-object-inputs" });
+		const ready = readyToolProviderAdapterInput("runtime-object-provider", "runtime-object-req");
+		const runtime = attachToolProviderAdapterRuntime(g, {
+			inputs,
+			bindings: [
+				{
+					providerId: "runtime-object-provider",
+					run() {
+						return {
+							kind: "result",
+							result: {
+								kind: "tool-output",
+								value: new RuntimeClient(),
+							},
+						};
+					},
+				},
+			],
+		});
+		const outcomes: ExecutorOutcome[] = [];
+		const issues: DataIssue[] = [];
+		runtime.outcomes.subscribe(
+			(msg) => msg[0] === "DATA" && outcomes.push(msg[1] as ExecutorOutcome),
+		);
+		runtime.issues.subscribe((msg) => msg[0] === "DATA" && issues.push(msg[1] as DataIssue));
+
+		inputs.down([["DATA", ready]]);
+
+		expect(outcomes).toEqual([
+			expect.objectContaining({
+				kind: "failure",
+				error: expect.objectContaining({
+					code: "tool-provider-adapter-runtime-forbidden-runtime-material",
+				}),
+			}),
+		]);
+		expect(issues.at(-1)).toMatchObject({
+			code: "tool-provider-adapter-runtime-forbidden-runtime-material",
+		});
+	});
+
+	it("does not expose thrown adapter error messages as graph material", () => {
+		const g = graph();
+		const inputs = g.node<ToolProviderAdapterInput>([], null, { name: "runtime-throw-inputs" });
+		const ready = readyToolProviderAdapterInput("runtime-throw-provider", "runtime-throw-req");
+		const runtime = attachToolProviderAdapterRuntime(g, {
+			inputs,
+			bindings: [
+				{
+					providerId: "runtime-throw-provider",
+					run() {
+						throw new Error("secret-token should stay runtime-private");
+					},
+				},
+			],
+		});
+		const outcomes: ExecutorOutcome[] = [];
+		const issues: unknown[] = [];
+		runtime.outcomes.subscribe(
+			(msg) => msg[0] === "DATA" && outcomes.push(msg[1] as ExecutorOutcome),
+		);
+		runtime.issues.subscribe((msg) => msg[0] === "DATA" && issues.push(msg[1]));
+
+		inputs.down([["DATA", ready]]);
+
+		expect(outcomes).toEqual([
+			expect.objectContaining({
+				kind: "failure",
+				error: expect.objectContaining({ code: "tool-provider-adapter-runtime-threw" }),
+			}),
+		]);
+		expect(issues).toEqual([
+			expect.objectContaining({ code: "tool-provider-adapter-runtime-threw" }),
+		]);
+		expect(JSON.stringify({ outcomes, issues })).not.toContain("secret-token");
+	});
+
+	it("rejects async adapter results without subscribing to hidden runtime work", () => {
+		const g = graph();
+		const inputs = g.node<ToolProviderAdapterInput>([], null, { name: "runtime-reject-inputs" });
+		const ready = readyToolProviderAdapterInput("runtime-reject-provider", "runtime-reject-req");
+		const runtime = attachToolProviderAdapterRuntime(g, {
+			inputs,
+			bindings: [
+				{
+					providerId: "runtime-reject-provider",
+					run() {
+						const thenKey = ["th", "en"].join("");
+						return Object.defineProperty({}, thenKey, {
+							value() {
+								throw new Error("provider raw stack secret should not project");
+							},
+						}) as unknown as ToolProviderAdapterRunResult;
+					},
+				},
+			],
+		});
+		const outcomes: ExecutorOutcome[] = [];
+		const issues: unknown[] = [];
+		runtime.outcomes.subscribe(
+			(msg) => msg[0] === "DATA" && outcomes.push(msg[1] as ExecutorOutcome),
+		);
+		runtime.issues.subscribe((msg) => msg[0] === "DATA" && issues.push(msg[1]));
+
+		inputs.down([["DATA", ready]]);
+
+		expect(outcomes).toEqual([
+			expect.objectContaining({
+				kind: "failure",
+				error: expect.objectContaining({
+					code: "tool-provider-adapter-runtime-async-result-unsupported",
+				}),
+			}),
+		]);
+		expect(issues).toEqual([
+			expect.objectContaining({
+				code: "tool-provider-adapter-runtime-async-result-unsupported",
+			}),
+		]);
+		expect(JSON.stringify({ outcomes, issues })).not.toMatch(/provider raw stack secret/i);
+	});
+
+	it("does not let a hostile thenable getter strand an execution proof", () => {
+		const g = graph();
+		const inputs = g.node<ToolProviderAdapterInput>([], null, {
+			name: "runtime-hostile-thenable-inputs",
+		});
+		const ready = readyToolProviderAdapterInput(
+			"runtime-hostile-thenable-provider",
+			"runtime-hostile-thenable-req",
+		);
+		const runtime = attachToolProviderAdapterRuntime(g, {
+			inputs,
+			bindings: [
+				{
+					providerId: "runtime-hostile-thenable-provider",
+					run() {
+						const thenKey = ["th", "en"].join("");
+						return Object.defineProperty({}, thenKey, {
+							get() {
+								throw new Error("raw then getter secret");
+							},
+						}) as unknown as ToolProviderAdapterRunResult;
+					},
+				},
+			],
+		});
+		const outcomes: ExecutorOutcome[] = [];
+		const issues: DataIssue[] = [];
+		runtime.outcomes.subscribe(
+			(msg) => msg[0] === "DATA" && outcomes.push(msg[1] as ExecutorOutcome),
+		);
+		runtime.issues.subscribe((msg) => msg[0] === "DATA" && issues.push(msg[1] as DataIssue));
+
+		inputs.down([["DATA", ready]]);
+
+		expect(outcomes).toEqual([
+			expect.objectContaining({
+				kind: "failure",
+				error: expect.objectContaining({
+					code: "tool-provider-adapter-runtime-async-result-unsupported",
+				}),
+			}),
+		]);
+		expect(issues).toEqual([
+			expect.objectContaining({
+				code: "tool-provider-adapter-runtime-async-result-unsupported",
+			}),
+		]);
+		expect(JSON.stringify({ outcomes, issues })).not.toContain("raw then getter secret");
+	});
+});
diff --git a/packages/ts/src/__tests__/agent-runtime.part-03.test.ts b/packages/ts/src/__tests__/agent-runtime.part-03.test.ts
new file mode 100644
index 00000000..f4aa95f8
--- /dev/null
+++ b/packages/ts/src/__tests__/agent-runtime.part-03.test.ts
@@ -0,0 +1,856 @@
+import { describe, expect, it } from "vitest";
+import type { DataIssue } from "../data/index.js";
+import type { ToolProviderAdapterRuntimeStatus } from "../executors/tool-provider-runtime.js";
+import { attachToolProviderAdapterRuntime } from "../executors/tool-provider-runtime.js";
+import { graph } from "../graph/graph.js";
+import {
+	type AgentRequestIssued,
+	buildToolProviderAdapterInputs,
+	buildToolProviderExecutorOutcome,
+	type ExecutorOutcome,
+	type ExecutorRoute,
+	localBuiltinToolProviderCatalog,
+	requestToolProviderAdapterRun,
+	resolveToolProviderExecutionPolicies,
+	type ToolProviderAdapterInput,
+	type ToolProviderAdapterRunRequested,
+	type ToolProviderAdapterRunStatus,
+} from "../orchestration/agent-runtime.js";
+import type {
+	WorkItemDomainActionAdmissionDecision,
+	WorkItemDomainActionProposal,
+	WorkItemSeed,
+} from "../orchestration/work-item-runtime.js";
+
+function _issued(
+	requestId: string,
+	operationId: string,
+	requestKind: AgentRequestIssued["requestKind"],
+	inputKind?: string,
+): AgentRequestIssued {
+	return {
+		kind: "issued",
+		requestId,
+		operationId,
+		effectRunId: "run-1",
+		requestKind,
+		required: true,
+		input:
+			inputKind === undefined
+				? undefined
+				: { inputId: `${requestId}:input`, inputKind, dataMode: "summary", summary: inputKind },
+	};
+}
+
+function toolRequest(
+	requestId: string,
+	operationId: string,
+	toolName: string,
+	operation?: string,
+): AgentRequestIssued {
+	return {
+		kind: "issued",
+		requestId,
+		operationId,
+		effectRunId: "run-1",
+		requestKind: "executor",
+		required: true,
+		input: {
+			inputId: `${requestId}:input`,
+			inputKind: "tool-call",
+			dataMode: "inline",
+			value: {
+				kind: "tool-call",
+				toolName,
+				operation,
+				arguments: { path: "README.md" },
+			},
+		},
+	};
+}
+
+const forbiddenRetentionPayloadPattern =
+	/SCORER_SECRET|SCORER_RAW|rawResponse|stdout|stderr|stack|apiKey|password|arguments|providerClient|oauthState|subprocessHandle|transport|sdkObject/i;
+
+const retentionScorerEntryKeys: Record<string, readonly string[]> = {
+	adapterInputs: [
+		"adapterInputId",
+		"executorId",
+		"insertedAtMs",
+		"key",
+		"operationId",
+		"profileId",
+		"providerId",
+		"requestId",
+		"routeId",
+		"sequence",
+		"status",
+	],
+	runRequests: [
+		"adapterInputId",
+		"attempt",
+		"executorId",
+		"key",
+		"operationId",
+		"profileId",
+		"providerId",
+		"reason",
+		"requestId",
+		"requestedAtMs",
+		"routeId",
+		"runId",
+		"sequence",
+	],
+	executions: [
+		"adapterInputId",
+		"attempt",
+		"executorId",
+		"key",
+		"occurredAtMs",
+		"operationId",
+		"outcomeId",
+		"profileId",
+		"providerId",
+		"reason",
+		"requestId",
+		"routeId",
+		"runId",
+		"sequence",
+		"status",
+	],
+	runStatuses: [
+		"adapterInputId",
+		"attempt",
+		"issueCode",
+		"key",
+		"occurredAtMs",
+		"operationId",
+		"outcomeId",
+		"requestId",
+		"runId",
+		"sequence",
+		"status",
+	],
+	runIssues: [
+		"adapterInputId",
+		"attempt",
+		"issueCode",
+		"key",
+		"occurredAtMs",
+		"operationId",
+		"requestId",
+		"runId",
+		"sequence",
+		"severity",
+		"subjectId",
+	],
+	retentionEvidence: [
+		"adapterInputId",
+		"attemptHighWater",
+		"evidenceKind",
+		"key",
+		"occurredAtMs",
+		"reason",
+		"sequence",
+	],
+};
+
+function _expectRetentionScorerEntryPayloadSafe(index: string, entry: unknown): void {
+	expect(entry).toBeTypeOf("object");
+	expect(Array.isArray(entry)).toBe(false);
+	const record = entry as Record<string, unknown>;
+	const allowed = retentionScorerEntryKeys[index];
+	expect(allowed, `unknown retention scorer index ${index}`).toBeDefined();
+	for (const [key, value] of Object.entries(record)) {
+		expect(allowed).toContain(key);
+		expect(value === undefined || typeof value === "string" || typeof value === "number").toBe(
+			true,
+		);
+		if (key === "key") expect(value).toEqual(expect.stringMatching(/^key:[a-z0-9]+:\d+$/));
+	}
+	expectNoForbiddenRetentionPayload(record);
+}
+
+function expectNoForbiddenRetentionPayload(value: unknown): void {
+	expect(JSON.stringify(value)).not.toMatch(forbiddenRetentionPayloadPattern);
+}
+
+function readyToolProviderAdapterInput(
+	providerId: string,
+	requestId: string,
+): ToolProviderAdapterInput {
+	const catalog = localBuiltinToolProviderCatalog({ providerId });
+	const profile = catalog.profiles[0];
+	if (profile === undefined) throw new Error("expected profile");
+	const request = toolRequest(requestId, `${requestId}-op`, "file.read", "read");
+	const route: ExecutorRoute = {
+		kind: "executor-route",
+		routeId: `${requestId}-route`,
+		requestId: request.requestId,
+		operationId: request.operationId,
+		executorId: profile.executorId,
+		profileId: profile.profileId,
+		inputKind: "tool-call",
+	};
+	const resolutions = resolveToolProviderExecutionPolicies({
+		request,
+		routes: [route],
+		catalogs: [catalog],
+	});
+	const input = buildToolProviderAdapterInputs({
+		requests: [request],
+		routes: [route],
+		catalogs: [catalog],
+		resolutions,
+	})[0];
+	if (input === undefined || input.status !== "ready") throw new Error("expected ready input");
+	return input;
+}
+
+function _workItemSeed(workItemId: string): WorkItemSeed {
+	return {
+		kind: "work-item",
+		workItemId,
+		sourceRefs: [{ kind: "work-item", id: workItemId }],
+		workItemKind: "issue",
+		lifecycleStatus: "open",
+	};
+}
+
+function _workItemActionProposal(
+	proposalId: string,
+	actionKind: string,
+	opts: Partial<WorkItemDomainActionProposal> = {},
+): WorkItemDomainActionProposal {
+	return {
+		kind: "work-item-domain-action-proposal",
+		proposalId,
+		workItemId: opts.workItemId ?? "wi-1",
+		actionKind,
+		effectRunId: opts.effectRunId ?? "run-1",
+		effectRunResultId: opts.effectRunResultId ?? "run-1:result",
+		evidenceId: opts.evidenceId ?? "wi-1:run-1:run-1:result",
+		policyId: opts.policyId ?? "policy-propose",
+		sourceRefs: opts.sourceRefs,
+		metadata: opts.metadata,
+	};
+}
+
+function _workItemAdmissionDecision(
+	decisionId: string,
+	admissionId: string,
+	proposalId: string,
+	outcome: WorkItemDomainActionAdmissionDecision["outcome"],
+	opts: Partial<WorkItemDomainActionAdmissionDecision> = {},
+): WorkItemDomainActionAdmissionDecision {
+	return {
+		kind: "work-item-domain-action-admission-decision",
+		decisionId,
+		admissionId,
+		proposalId,
+		outcome,
+		policyId: opts.policyId,
+		reason: opts.reason,
+		targetProposalId: opts.targetProposalId,
+		targetAdmissionId: opts.targetAdmissionId,
+		sourceRefs: opts.sourceRefs,
+		decidedAtMs: opts.decidedAtMs,
+		metadata: opts.metadata,
+	};
+}
+
+describe("CSP-8 experimental agent runtime kernel (D236) — part 3", () => {
+	it("bounds provider-returned public text on runtime outcomes", () => {
+		const g = graph();
+		const inputs = g.node<ToolProviderAdapterInput>([], null, { name: "runtime-text-inputs" });
+		const ready = readyToolProviderAdapterInput("runtime-text-provider", "runtime-text-req");
+		const longSummary = "summary-".repeat(20);
+		const longMetadata = "metadata-".repeat(20);
+		const runtime = attachToolProviderAdapterRuntime(g, {
+			inputs,
+			publicText: {
+				maxSummaryChars: 16,
+				maxMessageChars: 18,
+				maxReasonChars: 14,
+				maxMetadataStringChars: 12,
+			},
+			bindings: [
+				{
+					providerId: "runtime-text-provider",
+					run() {
+						return {
+							kind: "result",
+							result: {
+								kind: "tool-output",
+								summary: longSummary,
+								metadata: { note: longMetadata },
+							},
+							metadata: { small: longMetadata },
+						};
+					},
+				},
+			],
+		});
+		const outcomes: ExecutorOutcome[] = [];
+		const issues: DataIssue[] = [];
+		runtime.outcomes.subscribe(
+			(msg) => msg[0] === "DATA" && outcomes.push(msg[1] as ExecutorOutcome),
+		);
+		runtime.issues.subscribe((msg) => msg[0] === "DATA" && issues.push(msg[1] as DataIssue));
+
+		inputs.down([["DATA", ready]]);
+
+		const outcome = outcomes.at(-1);
+		expect(outcome).toMatchObject({
+			kind: "result",
+			result: { summary: expect.any(String), metadata: { note: expect.any(String) } },
+			metadata: { small: expect.any(String) },
+			issues: expect.arrayContaining([
+				expect.objectContaining({
+					code: "tool-provider-adapter-runtime-public-text-truncated",
+				}),
+			]),
+		});
+		if (outcome?.kind !== "result") throw new Error("expected result outcome");
+		expect(outcome.result.summary?.length).toBeLessThanOrEqual(16);
+		expect((outcome.result.metadata as { note: string }).note.length).toBeLessThanOrEqual(12);
+		expect((outcome.metadata as { small: string }).small.length).toBeLessThanOrEqual(12);
+		expect(issues).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({
+					code: "tool-provider-adapter-runtime-public-text-truncated",
+				}),
+			]),
+		);
+	});
+
+	it("emits truncation evidence when only metadata strings are bounded", () => {
+		const ready = readyToolProviderAdapterInput(
+			"runtime-metadata-text-provider",
+			"runtime-metadata-text-req",
+		);
+		const outcome = buildToolProviderExecutorOutcome(
+			ready,
+			{
+				kind: "result",
+				result: { kind: "tool-output" },
+				metadata: { note: "metadata-only-".repeat(20) },
+			},
+			{ publicText: { maxMetadataStringChars: 15 } },
+		);
+
+		expect(outcome).toMatchObject({
+			kind: "result",
+			metadata: { note: expect.any(String) },
+			issues: expect.arrayContaining([
+				expect.objectContaining({
+					code: "tool-provider-adapter-runtime-public-text-truncated",
+					details: expect.objectContaining({ field: "metadata" }),
+				}),
+			]),
+		});
+		expect(((outcome.metadata as { note: string })?.note ?? "").length).toBeLessThanOrEqual(15);
+	});
+
+	it("bounds failure messages and canceled reasons from provider-returned public text", () => {
+		const ready = readyToolProviderAdapterInput(
+			"runtime-build-text-provider",
+			"runtime-build-text-req",
+		);
+		const failure = buildToolProviderExecutorOutcome(
+			ready,
+			{
+				kind: "failure",
+				error: {
+					kind: "issue",
+					code: "provider-failed",
+					message: "failure-message-".repeat(20),
+					details: { response: "failure-detail-".repeat(20) },
+				},
+				retryable: false,
+			},
+			{ publicText: { maxMessageChars: 20, maxMetadataStringChars: 18 } },
+		);
+		const canceled = buildToolProviderExecutorOutcome(
+			ready,
+			{ kind: "canceled", reason: "cancel-reason-".repeat(20) },
+			{ publicText: { maxReasonChars: 18 } },
+		);
+
+		expect(failure).toMatchObject({
+			kind: "failure",
+			error: {
+				code: "provider-failed",
+				details: expect.objectContaining({
+					truncated: true,
+					measurementSource: "js-string-length",
+				}),
+			},
+		});
+		if (failure.kind !== "failure") throw new Error("expected failure outcome");
+		expect(failure.error.message.length).toBeLessThanOrEqual(20);
+		expect((failure.error.details as { response: string }).response.length).toBeLessThanOrEqual(18);
+		expect(failure.error.details).toMatchObject({
+			detailsTruncated: true,
+			measurementSource: "js-string-length",
+		});
+		expect(canceled).toMatchObject({
+			kind: "canceled",
+			issues: expect.arrayContaining([
+				expect.objectContaining({ code: "tool-provider-adapter-runtime-public-text-truncated" }),
+			]),
+		});
+		if (canceled.kind !== "canceled") throw new Error("expected canceled outcome");
+		expect(canceled.reason?.length).toBeLessThanOrEqual(18);
+	});
+
+	it("rejects raw metadata and oversized inline result values without leaking them", () => {
+		const ready = readyToolProviderAdapterInput("runtime-raw-provider", "runtime-raw-req");
+		const rawRunRequest = requestToolProviderAdapterRun(ready, {
+			runId: "raw-run-request",
+			metadata: { rawResponse: "RAW_RUN_REQUEST_SHOULD_NOT_PROJECT" },
+		});
+		const rawMetadataOutcome = buildToolProviderExecutorOutcome(
+			ready,
+			{
+				kind: "result",
+				result: { kind: "tool-output", summary: "small summary" },
+				metadata: { rawResponse: "RAW_PROVIDER_RESPONSE_SHOULD_NOT_PROJECT" },
+			},
+			{ runId: "raw-run" },
+		);
+		const rawFailureDetailsOutcome = buildToolProviderExecutorOutcome(
+			ready,
+			{
+				kind: "failure",
+				error: {
+					kind: "issue",
+					code: "provider-raw-failure",
+					message: "provider failed",
+					details: { rawResponse: "RAW_FAILURE_DETAIL_SHOULD_NOT_PROJECT" },
+				},
+			},
+			{ runId: "raw-failure-run" },
+		);
+		const blockedNeedMetadataOutcome = buildToolProviderExecutorOutcome(
+			ready,
+			{
+				kind: "blocked",
+				needs: [
+					{
+						kind: "permission",
+						message: "needs permission",
+						metadata: { rawResponse: "RAW_NEED_METADATA_SHOULD_NOT_PROJECT" },
+					},
+				],
+			},
+			{ runId: "raw-need-run" },
+		);
+		const oversizedValueOutcome = buildToolProviderExecutorOutcome(
+			ready,
+			{
+				kind: "result",
+				result: { kind: "tool-output", value: { content: "large-content-".repeat(60) } },
+			},
+			{ runId: "value-run", publicText: { maxSummaryChars: 20 } },
+		);
+
+		expect(rawRunRequest.metadata).toBeUndefined();
+		expect(rawMetadataOutcome).toMatchObject({
+			kind: "result",
+			issues: expect.arrayContaining([
+				expect.objectContaining({
+					code: "tool-provider-adapter-runtime-metadata-redacted",
+				}),
+			]),
+		});
+		expect(rawMetadataOutcome.metadata).not.toMatchObject({ rawResponse: expect.anything() });
+		expect(rawFailureDetailsOutcome).toMatchObject({
+			kind: "failure",
+			error: {
+				details: { redacted: true, reason: "forbidden-runtime-material" },
+			},
+		});
+		expect(blockedNeedMetadataOutcome).toMatchObject({
+			kind: "blocked",
+			needs: [expect.not.objectContaining({ metadata: expect.anything() })],
+			issues: expect.arrayContaining([
+				expect.objectContaining({
+					code: "tool-provider-adapter-runtime-metadata-redacted",
+				}),
+			]),
+		});
+		expect(oversizedValueOutcome).toMatchObject({
+			kind: "failure",
+			outcomeId: expect.stringContaining("value-run"),
+			error: expect.objectContaining({
+				code: "tool-provider-adapter-runtime-forbidden-runtime-material",
+			}),
+		});
+		expect(
+			JSON.stringify({
+				rawRunRequest,
+				rawMetadataOutcome,
+				rawFailureDetailsOutcome,
+				blockedNeedMetadataOutcome,
+				oversizedValueOutcome,
+			}),
+		).not.toMatch(
+			/RAW_RUN_REQUEST_SHOULD_NOT_PROJECT|RAW_PROVIDER_RESPONSE_SHOULD_NOT_PROJECT|RAW_FAILURE_DETAIL_SHOULD_NOT_PROJECT|RAW_NEED_METADATA_SHOULD_NOT_PROJECT|large-content-/,
+		);
+	});
+
+	it("falls back to finite public text bounds for invalid policy limits", () => {
+		const ready = readyToolProviderAdapterInput("runtime-limit-provider", "runtime-limit-req");
+		const outcome = buildToolProviderExecutorOutcome(
+			ready,
+			{
+				kind: "result",
+				result: { kind: "tool-output", summary: "summary-".repeat(100) },
+				metadata: { note: "metadata-".repeat(100) },
+			},
+			{
+				publicText: {
+					maxSummaryChars: Number.POSITIVE_INFINITY,
+					maxMetadataStringChars: Number.NaN,
+				},
+			},
+		);
+
+		expect(outcome).toMatchObject({
+			kind: "result",
+			issues: expect.arrayContaining([
+				expect.objectContaining({
+					code: "tool-provider-adapter-runtime-public-text-truncated",
+				}),
+			]),
+		});
+		if (outcome.kind !== "result") throw new Error("expected result outcome");
+		expect(outcome.result.summary?.length).toBeLessThanOrEqual(512);
+		expect((outcome.metadata as { note: string }).note.length).toBeLessThanOrEqual(256);
+	});
+
+	it("does not hide a repeated auto-run attempt when adapterInputId is unchanged", () => {
+		const g = graph();
+		const inputs = g.node<ToolProviderAdapterInput>([], null, { name: "runtime-update-inputs" });
+		const ready = readyToolProviderAdapterInput("runtime-update-provider", "runtime-update-req");
+		const updated = {
+			...ready,
+			sourceRefs: [
+				...(ready.sourceRefs ?? []),
+				{ kind: "tool-provider-policy", id: "runtime-update-policy-v2" },
+			],
+		} satisfies ToolProviderAdapterInput;
+		const calls: ToolProviderAdapterInput[] = [];
+		const runtime = attachToolProviderAdapterRuntime(g, {
+			inputs,
+			bindings: [
+				{
+					providerId: "runtime-update-provider",
+					run(input) {
+						calls.push(input);
+						return {
+							kind: "result",
+							result: { kind: "tool-output", value: { ok: true } },
+						};
+					},
+				},
+			],
+		});
+		const issues: DataIssue[] = [];
+		runtime.outcomes.subscribe(() => undefined);
+		runtime.issues.subscribe((msg) => msg[0] === "DATA" && issues.push(msg[1] as DataIssue));
+
+		inputs.down([["DATA", ready]]);
+		inputs.down([["DATA", ready]]);
+		inputs.down([["DATA", updated]]);
+
+		expect(calls.map((input) => input.sourceRefs?.at(-1)?.id)).toEqual([
+			ready.sourceRefs?.at(-1)?.id,
+		]);
+		expect(issues).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({
+					code: "tool-provider-adapter-runtime-duplicate-execution-coordinate",
+				}),
+			]),
+		);
+	});
+
+	it("executes explicit visible run requests as distinct attempts for unchanged adapter input", () => {
+		const g = graph();
+		const inputs = g.node<ToolProviderAdapterInput>([], null, {
+			name: "runtime-run-request-inputs",
+		});
+		const runRequests = g.node<ToolProviderAdapterRunRequested>([], null, {
+			name: "runtime-run-requests",
+		});
+		const ready = readyToolProviderAdapterInput("runtime-run-provider", "runtime-run-req");
+		const longReason = `${"provider-reason-".repeat(60)}RAW_REASON_TAIL_SHOULD_NOT_PROJECT`;
+		const attempts: number[] = [];
+		const reasons: (string | undefined)[] = [];
+		const runtime = attachToolProviderAdapterRuntime(g, {
+			inputs,
+			runRequests: [runRequests],
+			autoRunReadyInputs: false,
+			publicText: { maxReasonChars: 32 },
+			bindings: [
+				{
+					providerId: "runtime-run-provider",
+					run(_input, ctx) {
+						attempts.push(ctx.attempt);
+						reasons.push(ctx.reason);
+						return {
+							kind: "result",
+							result: { kind: "tool-output", summary: `attempt ${ctx.attempt}` },
+						};
+					},
+				},
+			],
+		});
+		const outcomes: ExecutorOutcome[] = [];
+		const emittedRequests: ToolProviderAdapterRunRequested[] = [];
+		const runStatus: ToolProviderAdapterRunStatus[] = [];
+		const audit: unknown[] = [];
+		runtime.outcomes.subscribe(
+			(msg) => msg[0] === "DATA" && outcomes.push(msg[1] as ExecutorOutcome),
+		);
+		runtime.runRequests.subscribe(
+			(msg) => msg[0] === "DATA" && emittedRequests.push(msg[1] as ToolProviderAdapterRunRequested),
+		);
+		runtime.runStatus.subscribe(
+			(msg) => msg[0] === "DATA" && runStatus.push(msg[1] as ToolProviderAdapterRunStatus),
+		);
+		runtime.audit.subscribe((msg) => msg[0] === "DATA" && audit.push(msg[1]));
+		const firstRunRequest = {
+			...requestToolProviderAdapterRun(ready, {
+				runId: "run-shared",
+				attempt: 1,
+				reason: "manual",
+			}),
+			reason: longReason,
+		} satisfies ToolProviderAdapterRunRequested;
+
+		inputs.down([["DATA", ready]]);
+		runRequests.down([
+			["DATA", firstRunRequest],
+			[
+				"DATA",
+				requestToolProviderAdapterRun(ready, {
+					runId: "run-shared",
+					attempt: 2,
+					reason: "retry",
+					retryOfOutcomeId: "run-1:outcome",
+				}),
+			],
+		]);
+		const rawFirstRequest = emittedRequests[0];
+		expect(rawFirstRequest).toBeDefined();
+
+		expect(attempts).toEqual([1, 2]);
+		expect(reasons[0]?.length).toBeLessThanOrEqual(32);
+		expect(reasons[1]).toBe("retry");
+		expect(outcomes.map((outcome) => outcome.attempt)).toEqual([1, 2]);
+		expect(outcomes.map((outcome) => outcome.outcomeId)).toEqual([
+			expect.stringContaining("run-shared:attempt-1"),
+			expect.stringContaining("run-shared:attempt-2"),
+		]);
+		expect(outcomes.map((outcome) => outcome.metadata)).toEqual([
+			expect.objectContaining({ runId: "run-shared" }),
+			expect.objectContaining({ runId: "run-shared" }),
+		]);
+		expect(
+			runStatus.filter((status) => status.status === "requested").map((status) => status.attempt),
+		).toEqual([1, 2]);
+		expect(
+			runStatus.filter((status) => status.status === "result").map((status) => status.attempt),
+		).toEqual([1, 2]);
+		expect(rawFirstRequest?.reason.length).toBeLessThanOrEqual(32);
+		expect(JSON.stringify({ audit, emittedRequests, reasons })).not.toContain(
+			"RAW_REASON_TAIL_SHOULD_NOT_PROJECT",
+		);
+	});
+
+	it("sanitizes fallback invalid-shape run request status and audit material", () => {
+		const g = graph();
+		const inputs = g.node<ToolProviderAdapterInput>([], null, {
+			name: "runtime-invalid-run-request-inputs",
+		});
+		const runRequests = g.node<ToolProviderAdapterRunRequested>([], null, {
+			name: "runtime-invalid-run-requests",
+		});
+		const runtime = attachToolProviderAdapterRuntime(g, {
+			inputs,
+			runRequests: [runRequests],
+			autoRunReadyInputs: false,
+			publicText: { maxReasonChars: 24, maxMetadataStringChars: 20 },
+			bindings: [],
+		});
+		const runStatus: ToolProviderAdapterRunStatus[] = [];
+		const issues: DataIssue[] = [];
+		const audit: unknown[] = [];
+		runtime.runStatus.subscribe(
+			(msg) => msg[0] === "DATA" && runStatus.push(msg[1] as ToolProviderAdapterRunStatus),
+		);
+		runtime.issues.subscribe((msg) => msg[0] === "DATA" && issues.push(msg[1] as DataIssue));
+		runtime.audit.subscribe((msg) => msg[0] === "DATA" && audit.push(msg[1]));
+
+		runRequests.down([
+			[
+				"DATA",
+				{
+					kind: "tool-provider-adapter-run-requested",
+					runId: "invalid-run",
+					adapterInputId: "invalid-input",
+					requestId: "invalid-request",
+					attempt: 1,
+					reason: `${"invalid-reason-".repeat(20)}RAW_INVALID_REASON_SHOULD_NOT_PROJECT`,
+					sourceRefs: [
+						{
+							kind: "provider-raw",
+							id: "raw-source",
+							metadata: { stdout: "RAW_INVALID_SOURCE_REF_SHOULD_NOT_PROJECT" },
+						},
+					],
+					metadata: { rawResponse: "RAW_INVALID_METADATA_SHOULD_NOT_PROJECT" },
+				} as unknown as ToolProviderAdapterRunRequested,
+			],
+		]);
+
+		expect(runStatus).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({
+					runId: "invalid-run",
+					adapterInputId: "invalid-input",
+					requestId: "invalid-request",
+					operationId: "<invalid-operation>",
+					status: "mismatched-request",
+					attempt: 1,
+					sourceRefs: [
+						{ kind: "tool-provider-adapter-run", id: "invalid-run" },
+						{ kind: "provider-raw", id: "raw-source" },
+					],
+					issues: [
+						expect.objectContaining({
+							code: "tool-provider-adapter-run-request-invalid-shape",
+						}),
+					],
+				}),
+			]),
+		);
+		expect(issues).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({
+					code: "tool-provider-adapter-run-request-invalid-shape",
+				}),
+			]),
+		);
+		expect(audit).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({
+					kind: "tool-provider-adapter-run-request-invalid-shape",
+					sourceRefs: [
+						{ kind: "tool-provider-adapter-run", id: "invalid-run" },
+						{ kind: "provider-raw", id: "raw-source" },
+					],
+					metadata: expect.objectContaining({
+						runId: "invalid-run",
+						adapterInputId: "invalid-input",
+						issueCode: "tool-provider-adapter-run-request-invalid-shape",
+					}),
+				}),
+			]),
+		);
+		expect(JSON.stringify({ runStatus, issues, audit })).not.toMatch(
+			/RAW_INVALID_|rawResponse|stdout|stderr|apiKey/,
+		);
+	});
+
+	it("bounds execution proofs, gaps trimmed replay, and still allows explicit attempt 2", () => {
+		const g = graph();
+		const inputs = g.node<ToolProviderAdapterInput>([], null, {
+			name: "runtime-retention-execution-inputs",
+		});
+		const runRequests = g.node<ToolProviderAdapterRunRequested>([], null, {
+			name: "runtime-retention-execution-runs",
+		});
+		const ready = readyToolProviderAdapterInput(
+			"runtime-retention-execution-provider",
+			"runtime-retention-execution-req",
+		);
+		const attempts: number[] = [];
+		const runtime = attachToolProviderAdapterRuntime(g, {
+			name: "runtimeRetentionExecution",
+			inputs,
+			runRequests: [runRequests],
+			autoRunReadyInputs: false,
+			retention: { executions: { maxSize: 1 } },
+			bindings: [
+				{
+					providerId: "runtime-retention-execution-provider",
+					run(_input, ctx) {
+						attempts.push(ctx.attempt);
+						return { kind: "result", result: { kind: "tool-output", summary: "ok" } };
+					},
+				},
+			],
+		});
+		const runStatus: ToolProviderAdapterRunStatus[] = [];
+		const runtimeStatus: ToolProviderAdapterRuntimeStatus[] = [];
+		const issues: DataIssue[] = [];
+		runtime.runStatus.subscribe(
+			(msg) => msg[0] === "DATA" && runStatus.push(msg[1] as ToolProviderAdapterRunStatus),
+		);
+		runtime.runtimeStatus.subscribe(
+			(msg) => msg[0] === "DATA" && runtimeStatus.push(msg[1] as ToolProviderAdapterRuntimeStatus),
+		);
+		runtime.issues.subscribe((msg) => msg[0] === "DATA" && issues.push(msg[1] as DataIssue));
+
+		inputs.down([["DATA", ready]]);
+		runRequests.down([
+			["DATA", requestToolProviderAdapterRun(ready, { runId: "run-a", attempt: 1 })],
+			[
+				"DATA",
+				requestToolProviderAdapterRun(ready, { runId: "run-a", attempt: 2, reason: "retry" }),
+			],
+			["DATA", requestToolProviderAdapterRun(ready, { runId: "run-replay", attempt: 1 })],
+		]);
+
+		expect(attempts).toEqual([1, 2]);
+		expect(runtimeStatus).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({ status: "retention-trimmed", index: "executions" }),
+				expect.objectContaining({
+					status: "retention-gap",
+					index: "executions",
+					issueCode: "tool-provider-adapter-runtime-retention-gap",
+					metadata: expect.objectContaining({
+						gapKind: "execution-proof-trimmed",
+						evidenceKind: "execution-high-water",
+					}),
+				}),
+			]),
+		);
+		expect(runtimeStatus.map((status) => status.status)).toEqual(
+			expect.arrayContaining(["retention-trimmed", "retention-gap"]),
+		);
+		expect(
+			runtimeStatus.every((status) =>
+				["retention-trimmed", "retention-gap", "invalid-retention-policy"].includes(status.status),
+			),
+		).toBe(true);
+		expect(runStatus).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({ runId: "run-replay", status: "retention-gap", attempt: 1 }),
+			]),
+		);
+		expect(runStatus).not.toEqual(
+			expect.arrayContaining([expect.objectContaining({ status: "retention-trimmed" })]),
+		);
+		expect(issues).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({ code: "tool-provider-adapter-runtime-retention-gap" }),
+			]),
+		);
+	});
+});
diff --git a/packages/ts/src/__tests__/agent-runtime.part-04.test.ts b/packages/ts/src/__tests__/agent-runtime.part-04.test.ts
new file mode 100644
index 00000000..fea364f2
--- /dev/null
+++ b/packages/ts/src/__tests__/agent-runtime.part-04.test.ts
@@ -0,0 +1,814 @@
+import { describe, expect, it } from "vitest";
+import type { DataIssue } from "../data/index.js";
+import { graph } from "../graph/graph.js";
+import {
+	type AgentRequestIssued,
+	buildToolProviderAdapterInputs,
+	type ExecutorRoute,
+	localBuiltinToolProviderCatalog,
+	requestToolProviderAdapterRun,
+	resolveToolProviderExecutionPolicies,
+	type ToolProviderAdapterInput,
+	type ToolProviderAdapterRunRequested,
+	type ToolProviderAdapterRunStatus,
+} from "../orchestration/agent-runtime.js";
+import { attachToolProviderAdapterRuntime } from "../orchestration/agent-runtime-adapter-runtime.js";
+import type { ToolProviderAdapterRuntimeStatus } from "../orchestration/agent-runtime-types-tool.js";
+import type {
+	WorkItemDomainActionAdmissionDecision,
+	WorkItemDomainActionProposal,
+	WorkItemSeed,
+} from "../orchestration/work-item-runtime.js";
+
+function _issued(
+	requestId: string,
+	operationId: string,
+	requestKind: AgentRequestIssued["requestKind"],
+	inputKind?: string,
+): AgentRequestIssued {
+	return {
+		kind: "issued",
+		requestId,
+		operationId,
+		effectRunId: "run-1",
+		requestKind,
+		required: true,
+		input:
+			inputKind === undefined
+				? undefined
+				: { inputId: `${requestId}:input`, inputKind, dataMode: "summary", summary: inputKind },
+	};
+}
+
+function toolRequest(
+	requestId: string,
+	operationId: string,
+	toolName: string,
+	operation?: string,
+): AgentRequestIssued {
+	return {
+		kind: "issued",
+		requestId,
+		operationId,
+		effectRunId: "run-1",
+		requestKind: "executor",
+		required: true,
+		input: {
+			inputId: `${requestId}:input`,
+			inputKind: "tool-call",
+			dataMode: "inline",
+			value: {
+				kind: "tool-call",
+				toolName,
+				operation,
+				arguments: { path: "README.md" },
+			},
+		},
+	};
+}
+
+const forbiddenRetentionPayloadPattern =
+	/SCORER_SECRET|SCORER_RAW|rawResponse|stdout|stderr|stack|apiKey|password|arguments|providerClient|oauthState|subprocessHandle|transport|sdkObject/i;
+
+const retentionScorerEntryKeys: Record<string, readonly string[]> = {
+	adapterInputs: [
+		"adapterInputId",
+		"executorId",
+		"insertedAtMs",
+		"key",
+		"operationId",
+		"profileId",
+		"providerId",
+		"requestId",
+		"routeId",
+		"sequence",
+		"status",
+	],
+	runRequests: [
+		"adapterInputId",
+		"attempt",
+		"executorId",
+		"key",
+		"operationId",
+		"profileId",
+		"providerId",
+		"reason",
+		"requestId",
+		"requestedAtMs",
+		"routeId",
+		"runId",
+		"sequence",
+	],
+	executions: [
+		"adapterInputId",
+		"attempt",
+		"executorId",
+		"key",
+		"occurredAtMs",
+		"operationId",
+		"outcomeId",
+		"profileId",
+		"providerId",
+		"reason",
+		"requestId",
+		"routeId",
+		"runId",
+		"sequence",
+		"status",
+	],
+	runStatuses: [
+		"adapterInputId",
+		"attempt",
+		"issueCode",
+		"key",
+		"occurredAtMs",
+		"operationId",
+		"outcomeId",
+		"requestId",
+		"runId",
+		"sequence",
+		"status",
+	],
+	runIssues: [
+		"adapterInputId",
+		"attempt",
+		"issueCode",
+		"key",
+		"occurredAtMs",
+		"operationId",
+		"requestId",
+		"runId",
+		"sequence",
+		"severity",
+		"subjectId",
+	],
+	retentionEvidence: [
+		"adapterInputId",
+		"attemptHighWater",
+		"evidenceKind",
+		"key",
+		"occurredAtMs",
+		"reason",
+		"sequence",
+	],
+};
+
+function _expectRetentionScorerEntryPayloadSafe(index: string, entry: unknown): void {
+	expect(entry).toBeTypeOf("object");
+	expect(Array.isArray(entry)).toBe(false);
+	const record = entry as Record<string, unknown>;
+	const allowed = retentionScorerEntryKeys[index];
+	expect(allowed, `unknown retention scorer index ${index}`).toBeDefined();
+	for (const [key, value] of Object.entries(record)) {
+		expect(allowed).toContain(key);
+		expect(value === undefined || typeof value === "string" || typeof value === "number").toBe(
+			true,
+		);
+		if (key === "key") expect(value).toEqual(expect.stringMatching(/^key:[a-z0-9]+:\d+$/));
+	}
+	expectNoForbiddenRetentionPayload(record);
+}
+
+function expectNoForbiddenRetentionPayload(value: unknown): void {
+	expect(JSON.stringify(value)).not.toMatch(forbiddenRetentionPayloadPattern);
+}
+
+function readyToolProviderAdapterInput(
+	providerId: string,
+	requestId: string,
+): ToolProviderAdapterInput {
+	const catalog = localBuiltinToolProviderCatalog({ providerId });
+	const profile = catalog.profiles[0];
+	if (profile === undefined) throw new Error("expected profile");
+	const request = toolRequest(requestId, `${requestId}-op`, "file.read", "read");
+	const route: ExecutorRoute = {
+		kind: "executor-route",
+		routeId: `${requestId}-route`,
+		requestId: request.requestId,
+		operationId: request.operationId,
+		executorId: profile.executorId,
+		profileId: profile.profileId,
+		inputKind: "tool-call",
+	};
+	const resolutions = resolveToolProviderExecutionPolicies({
+		request,
+		routes: [route],
+		catalogs: [catalog],
+	});
+	const input = buildToolProviderAdapterInputs({
+		requests: [request],
+		routes: [route],
+		catalogs: [catalog],
+		resolutions,
+	})[0];
+	if (input === undefined || input.status !== "ready") throw new Error("expected ready input");
+	return input;
+}
+
+function _workItemSeed(workItemId: string): WorkItemSeed {
+	return {
+		kind: "work-item",
+		workItemId,
+		sourceRefs: [{ kind: "work-item", id: workItemId }],
+		workItemKind: "issue",
+		lifecycleStatus: "open",
+	};
+}
+
+function _workItemActionProposal(
+	proposalId: string,
+	actionKind: string,
+	opts: Partial<WorkItemDomainActionProposal> = {},
+): WorkItemDomainActionProposal {
+	return {
+		kind: "work-item-domain-action-proposal",
+		proposalId,
+		workItemId: opts.workItemId ?? "wi-1",
+		actionKind,
+		effectRunId: opts.effectRunId ?? "run-1",
+		effectRunResultId: opts.effectRunResultId ?? "run-1:result",
+		evidenceId: opts.evidenceId ?? "wi-1:run-1:run-1:result",
+		policyId: opts.policyId ?? "policy-propose",
+		sourceRefs: opts.sourceRefs,
+		metadata: opts.metadata,
+	};
+}
+
+function _workItemAdmissionDecision(
+	decisionId: string,
+	admissionId: string,
+	proposalId: string,
+	outcome: WorkItemDomainActionAdmissionDecision["outcome"],
+	opts: Partial<WorkItemDomainActionAdmissionDecision> = {},
+): WorkItemDomainActionAdmissionDecision {
+	return {
+		kind: "work-item-domain-action-admission-decision",
+		decisionId,
+		admissionId,
+		proposalId,
+		outcome,
+		policyId: opts.policyId,
+		reason: opts.reason,
+		targetProposalId: opts.targetProposalId,
+		targetAdmissionId: opts.targetAdmissionId,
+		sourceRefs: opts.sourceRefs,
+		decidedAtMs: opts.decidedAtMs,
+		metadata: opts.metadata,
+	};
+}
+
+describe("CSP-8 experimental agent runtime kernel (D236) — part 4", () => {
+	it("rejects same adapterInputId and attempt under a different runId without executing twice", () => {
+		const g = graph();
+		const inputs = g.node<ToolProviderAdapterInput>([], null, {
+			name: "runtime-retention-coordinate-inputs",
+		});
+		const runRequests = g.node<ToolProviderAdapterRunRequested>([], null, {
+			name: "runtime-retention-coordinate-runs",
+		});
+		const ready = readyToolProviderAdapterInput(
+			"runtime-retention-coordinate-provider",
+			"runtime-retention-coordinate-req",
+		);
+		const calls: string[] = [];
+		const runtime = attachToolProviderAdapterRuntime(g, {
+			inputs,
+			runRequests: [runRequests],
+			autoRunReadyInputs: false,
+			retention: { executions: { maxSize: 2 } },
+			bindings: [
+				{
+					providerId: "runtime-retention-coordinate-provider",
+					run(_input, ctx) {
+						calls.push(ctx.runId ?? "");
+						return { kind: "result", result: { kind: "tool-output" } };
+					},
+				},
+			],
+		});
+		const runStatus: ToolProviderAdapterRunStatus[] = [];
+		const runtimeStatus: ToolProviderAdapterRuntimeStatus[] = [];
+		const issues: DataIssue[] = [];
+		const audit: unknown[] = [];
+		runtime.runStatus.subscribe(
+			(msg) => msg[0] === "DATA" && runStatus.push(msg[1] as ToolProviderAdapterRunStatus),
+		);
+		runtime.runtimeStatus.subscribe(
+			(msg) => msg[0] === "DATA" && runtimeStatus.push(msg[1] as ToolProviderAdapterRuntimeStatus),
+		);
+		runtime.issues.subscribe((msg) => msg[0] === "DATA" && issues.push(msg[1] as DataIssue));
+		runtime.audit.subscribe((msg) => msg[0] === "DATA" && audit.push(msg[1]));
+
+		inputs.down([["DATA", ready]]);
+		runRequests.down([
+			["DATA", requestToolProviderAdapterRun(ready, { runId: "run-once", attempt: 1 })],
+			["DATA", requestToolProviderAdapterRun(ready, { runId: "run-twice", attempt: 1 })],
+		]);
+
+		expect(calls).toEqual(["run-once"]);
+		expect(issues).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({
+					code: "tool-provider-adapter-runtime-duplicate-execution-coordinate",
+				}),
+			]),
+		);
+		expect(runStatus).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({ runId: "run-twice", status: "mismatched-request" }),
+			]),
+		);
+		expect(runtimeStatus).not.toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({
+					status: "retention-gap",
+					issueCode: "tool-provider-adapter-runtime-duplicate-execution-coordinate",
+				}),
+			]),
+		);
+		expect(audit).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({
+					kind: "tool-provider-adapter-runtime-duplicate-execution-coordinate",
+					metadata: expect.objectContaining({
+						adapterInputId: ready.adapterInputId,
+						attempt: 1,
+						key: expect.stringMatching(/^key:[a-z0-9]+:\d+$/),
+					}),
+				}),
+			]),
+		);
+		expect(JSON.stringify({ audit, runtimeStatus, issues })).not.toContain(
+			`${ready.adapterInputId}:1`,
+		);
+	});
+
+	it("keeps retained duplicate coordinates ahead of execution high-water gaps", () => {
+		const g = graph();
+		const inputs = g.node<ToolProviderAdapterInput>([], null, {
+			name: "runtime-retention-coordinate-high-water-inputs",
+		});
+		const runRequests = g.node<ToolProviderAdapterRunRequested>([], null, {
+			name: "runtime-retention-coordinate-high-water-runs",
+		});
+		const ready = readyToolProviderAdapterInput(
+			"runtime-retention-coordinate-high-water-provider",
+			"runtime-retention-coordinate-high-water-req",
+		);
+		const calls: string[] = [];
+		const runtime = attachToolProviderAdapterRuntime(g, {
+			inputs,
+			runRequests: [runRequests],
+			autoRunReadyInputs: false,
+			retention: {
+				executions: {
+					maxSize: 2,
+					score(entry) {
+						return entry.attempt === 1 || entry.attempt === 3 ? 10 : 0;
+					},
+				},
+			},
+			bindings: [
+				{
+					providerId: "runtime-retention-coordinate-high-water-provider",
+					run(_input, ctx) {
+						calls.push(`${ctx.runId}:${ctx.attempt}`);
+						return { kind: "result", result: { kind: "tool-output" } };
+					},
+				},
+			],
+		});
+		const runStatus: ToolProviderAdapterRunStatus[] = [];
+		const runtimeStatus: ToolProviderAdapterRuntimeStatus[] = [];
+		const issues: DataIssue[] = [];
+		runtime.runStatus.subscribe(
+			(msg) => msg[0] === "DATA" && runStatus.push(msg[1] as ToolProviderAdapterRunStatus),
+		);
+		runtime.runtimeStatus.subscribe(
+			(msg) => msg[0] === "DATA" && runtimeStatus.push(msg[1] as ToolProviderAdapterRuntimeStatus),
+		);
+		runtime.issues.subscribe((msg) => msg[0] === "DATA" && issues.push(msg[1] as DataIssue));
+
+		inputs.down([["DATA", ready]]);
+		runRequests.down([
+			["DATA", requestToolProviderAdapterRun(ready, { runId: "coord-keep-1", attempt: 1 })],
+			["DATA", requestToolProviderAdapterRun(ready, { runId: "coord-trim-2", attempt: 2 })],
+			["DATA", requestToolProviderAdapterRun(ready, { runId: "coord-keep-3", attempt: 3 })],
+			["DATA", requestToolProviderAdapterRun(ready, { runId: "coord-duplicate-1", attempt: 1 })],
+		]);
+
+		expect(calls).toEqual(["coord-keep-1:1", "coord-trim-2:2", "coord-keep-3:3"]);
+		expect(runtimeStatus).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({ status: "retention-trimmed", index: "executions" }),
+			]),
+		);
+		expect(runStatus).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({ runId: "coord-duplicate-1", status: "mismatched-request" }),
+			]),
+		);
+		expect(runStatus.filter((status) => status.runId === "coord-duplicate-1")).not.toEqual(
+			expect.arrayContaining([expect.objectContaining({ status: "retention-gap" })]),
+		);
+		expect(issues).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({
+					code: "tool-provider-adapter-runtime-duplicate-execution-coordinate",
+				}),
+			]),
+		);
+	});
+
+	it("bounds retention evidence horizon and fails closed after high-water proof is evicted", () => {
+		const g = graph();
+		const inputs = g.node<ToolProviderAdapterInput>([], null, {
+			name: "runtime-retention-evidence-inputs",
+		});
+		const runRequests = g.node<ToolProviderAdapterRunRequested>([], null, {
+			name: "runtime-retention-evidence-runs",
+		});
+		const first = readyToolProviderAdapterInput(
+			"runtime-retention-evidence-provider",
+			"runtime-retention-evidence-req-a",
+		);
+		const second = readyToolProviderAdapterInput(
+			"runtime-retention-evidence-provider",
+			"runtime-retention-evidence-req-b",
+		);
+		const calls: string[] = [];
+		const evidenceScorerEntries: unknown[] = [];
+		const runtime = attachToolProviderAdapterRuntime(g, {
+			inputs,
+			runRequests: [runRequests],
+			autoRunReadyInputs: false,
+			retention: {
+				executions: { maxSize: 1 },
+				retentionEvidence: {
+					maxSize: 1,
+					score(entry) {
+						evidenceScorerEntries.push(entry);
+						return entry.adapterInputId === second.adapterInputId ? 10 : 0;
+					},
+				},
+			},
+			bindings: [
+				{
+					providerId: "runtime-retention-evidence-provider",
+					run(input, ctx) {
+						calls.push(`${input.adapterInputId}:${ctx.attempt}`);
+						return { kind: "result", result: { kind: "tool-output" } };
+					},
+				},
+			],
+		});
+		const runStatus: ToolProviderAdapterRunStatus[] = [];
+		const runtimeStatus: ToolProviderAdapterRuntimeStatus[] = [];
+		const issues: DataIssue[] = [];
+		const audit: unknown[] = [];
+		runtime.runStatus.subscribe(
+			(msg) => msg[0] === "DATA" && runStatus.push(msg[1] as ToolProviderAdapterRunStatus),
+		);
+		runtime.runtimeStatus.subscribe(
+			(msg) => msg[0] === "DATA" && runtimeStatus.push(msg[1] as ToolProviderAdapterRuntimeStatus),
+		);
+		runtime.issues.subscribe((msg) => msg[0] === "DATA" && issues.push(msg[1] as DataIssue));
+		runtime.audit.subscribe((msg) => msg[0] === "DATA" && audit.push(msg[1]));
+
+		inputs.down([
+			["DATA", first],
+			["DATA", second],
+		]);
+		runRequests.down([
+			["DATA", requestToolProviderAdapterRun(first, { runId: "evidence-first", attempt: 1 })],
+			["DATA", requestToolProviderAdapterRun(first, { runId: "evidence-first", attempt: 2 })],
+			["DATA", requestToolProviderAdapterRun(second, { runId: "evidence-second", attempt: 1 })],
+			["DATA", requestToolProviderAdapterRun(second, { runId: "evidence-second", attempt: 2 })],
+			["DATA", requestToolProviderAdapterRun(first, { runId: "evidence-replay", attempt: 1 })],
+		]);
+		inputs.down([["DATA", first]]);
+		runRequests.down([
+			[
+				"DATA",
+				requestToolProviderAdapterRun(first, {
+					runId: "evidence-replay-after-input-reemit",
+					attempt: 1,
+				}),
+			],
+		]);
+
+		expect(calls).toEqual([
+			`${first.adapterInputId}:1`,
+			`${first.adapterInputId}:2`,
+			`${second.adapterInputId}:1`,
+			`${second.adapterInputId}:2`,
+		]);
+		expect(runtimeStatus).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({
+					status: "retention-trimmed",
+					index: "retentionEvidence",
+					adapterInputId: first.adapterInputId,
+					issueCode: "tool-provider-adapter-runtime-retention-evidence-trimmed",
+					metadata: expect.objectContaining({ evidenceKind: "execution-high-water" }),
+				}),
+				expect.objectContaining({
+					status: "retention-gap",
+					index: "retentionEvidence",
+					adapterInputId: first.adapterInputId,
+					runId: "evidence-replay",
+					issueCode: "tool-provider-adapter-runtime-retention-evidence-horizon-closed",
+					metadata: expect.objectContaining({ gapKind: "evidence-horizon-closed" }),
+				}),
+				expect.objectContaining({
+					status: "retention-gap",
+					index: "retentionEvidence",
+					adapterInputId: first.adapterInputId,
+					runId: "evidence-replay-after-input-reemit",
+					issueCode: "tool-provider-adapter-runtime-retention-evidence-horizon-closed",
+					metadata: expect.objectContaining({ gapKind: "evidence-horizon-closed" }),
+				}),
+			]),
+		);
+		expect(runStatus).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({ runId: "evidence-replay", status: "retention-gap" }),
+				expect.objectContaining({
+					runId: "evidence-replay-after-input-reemit",
+					status: "retention-gap",
+				}),
+			]),
+		);
+		expect(issues).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({
+					code: "tool-provider-adapter-runtime-retention-evidence-horizon-closed",
+					subjectId: first.adapterInputId,
+					details: expect.objectContaining({ gapKind: "evidence-horizon-closed" }),
+				}),
+			]),
+		);
+		expect(audit).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({
+					issueCode: "tool-provider-adapter-runtime-retention-evidence-horizon-closed",
+				}),
+			]),
+		);
+		expect(JSON.stringify(evidenceScorerEntries)).not.toMatch(/tool-output|arguments|raw/i);
+		expect(evidenceScorerEntries).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({
+					key: expect.any(String),
+					sequence: expect.any(Number),
+					adapterInputId: first.adapterInputId,
+					evidenceKind: "execution-high-water",
+					attemptHighWater: expect.any(Number),
+					reason: "execution-proof-retention",
+				}),
+			]),
+		);
+	});
+
+	it("emits visible global fail-closed diagnostics after closed retentionEvidence marker overflow", () => {
+		const g = graph();
+		const inputs = g.node<ToolProviderAdapterInput>([], null, {
+			name: "runtime-retention-evidence-global-inputs",
+		});
+		const runRequests = g.node<ToolProviderAdapterRunRequested>([], null, {
+			name: "runtime-retention-evidence-global-runs",
+		});
+		const first = readyToolProviderAdapterInput(
+			"runtime-retention-evidence-global-provider",
+			"runtime-retention-evidence-global-req-a",
+		);
+		const second = readyToolProviderAdapterInput(
+			"runtime-retention-evidence-global-provider",
+			"runtime-retention-evidence-global-req-b",
+		);
+		const third = readyToolProviderAdapterInput(
+			"runtime-retention-evidence-global-provider",
+			"runtime-retention-evidence-global-req-c",
+		);
+		const freshAfterGlobal = readyToolProviderAdapterInput(
+			"runtime-retention-evidence-global-provider",
+			"runtime-retention-evidence-global-req-d",
+		);
+		const calls: string[] = [];
+		const runtime = attachToolProviderAdapterRuntime(g, {
+			inputs,
+			runRequests: [runRequests],
+			autoRunReadyInputs: true,
+			retention: {
+				executions: { maxSize: 1 },
+				retentionEvidence: { maxSize: 1 },
+			},
+			bindings: [
+				{
+					providerId: "runtime-retention-evidence-global-provider",
+					run(input, ctx) {
+						calls.push(`${input.adapterInputId}:${ctx.attempt}`);
+						return { kind: "result", result: { kind: "tool-output", value: "hidden-result" } };
+					},
+				},
+			],
+		});
+		const runtimeStatus: ToolProviderAdapterRuntimeStatus[] = [];
+		const runStatus: ToolProviderAdapterRunStatus[] = [];
+		const issues: DataIssue[] = [];
+		const audit: unknown[] = [];
+		runtime.runtimeStatus.subscribe(
+			(msg) => msg[0] === "DATA" && runtimeStatus.push(msg[1] as ToolProviderAdapterRuntimeStatus),
+		);
+		runtime.runStatus.subscribe(
+			(msg) => msg[0] === "DATA" && runStatus.push(msg[1] as ToolProviderAdapterRunStatus),
+		);
+		runtime.issues.subscribe((msg) => msg[0] === "DATA" && issues.push(msg[1] as DataIssue));
+		runtime.audit.subscribe((msg) => msg[0] === "DATA" && audit.push(msg[1]));
+
+		inputs.down([["DATA", first]]);
+		runRequests.down([
+			["DATA", requestToolProviderAdapterRun(first, { runId: "global-a-2", attempt: 2 })],
+		]);
+		inputs.down([["DATA", second]]);
+		runRequests.down([
+			["DATA", requestToolProviderAdapterRun(second, { runId: "global-b-2", attempt: 2 })],
+		]);
+		inputs.down([["DATA", third]]);
+		runRequests.down([
+			["DATA", requestToolProviderAdapterRun(third, { runId: "global-c-2", attempt: 2 })],
+		]);
+
+		expect(runtimeStatus).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({
+					status: "retention-gap",
+					index: "retentionEvidence",
+					issueCode: "tool-provider-adapter-runtime-retention-evidence-horizon-closed",
+					metadata: expect.objectContaining({
+						gapKind: "evidence-horizon-closed",
+					}),
+				}),
+			]),
+		);
+		expect(issues).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({
+					code: "tool-provider-adapter-runtime-retention-evidence-horizon-closed",
+				}),
+			]),
+		);
+		expect(audit).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({
+					kind: "tool-provider-adapter-runtime-retention-evidence-horizon-closed",
+					issueCode: "tool-provider-adapter-runtime-retention-evidence-horizon-closed",
+				}),
+			]),
+		);
+
+		inputs.down([["DATA", freshAfterGlobal]]);
+		runRequests.down([
+			["DATA", requestToolProviderAdapterRun(first, { runId: "global-a-3", attempt: 3 })],
+		]);
+
+		expect(calls).toEqual([
+			`${first.adapterInputId}:1`,
+			`${first.adapterInputId}:2`,
+			`${second.adapterInputId}:1`,
+			`${second.adapterInputId}:2`,
+			`${third.adapterInputId}:1`,
+		]);
+		expect(runStatus).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({
+					adapterInputId: first.adapterInputId,
+					status: "result",
+					attempt: 1,
+				}),
+				expect.objectContaining({
+					adapterInputId: second.adapterInputId,
+					status: "result",
+					attempt: 1,
+				}),
+				expect.objectContaining({
+					runId: "global-c-2",
+					status: "retention-gap",
+					attempt: 2,
+				}),
+				expect.objectContaining({
+					adapterInputId: freshAfterGlobal.adapterInputId,
+					status: "retention-gap",
+				}),
+				expect.objectContaining({
+					runId: "global-a-3",
+					status: "retention-gap",
+					attempt: 3,
+				}),
+			]),
+		);
+		expect(
+			runStatus.filter((status) => status.adapterInputId === freshAfterGlobal.adapterInputId),
+		).not.toEqual(expect.arrayContaining([expect.objectContaining({ status: "missing-input" })]));
+		expect(runStatus.filter((status) => status.runId === "global-a-3")).not.toEqual(
+			expect.arrayContaining([expect.objectContaining({ status: "missing-input" })]),
+		);
+		expect(runtimeStatus).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({
+					status: "retention-gap",
+					index: "retentionEvidence",
+					adapterInputId: freshAfterGlobal.adapterInputId,
+					issueCode: "tool-provider-adapter-runtime-retention-evidence-horizon-closed",
+					metadata: expect.objectContaining({ gapKind: "evidence-horizon-closed" }),
+				}),
+				expect.objectContaining({
+					status: "retention-gap",
+					index: "retentionEvidence",
+					adapterInputId: first.adapterInputId,
+					runId: "global-a-3",
+					attempt: 3,
+					issueCode: "tool-provider-adapter-runtime-retention-evidence-horizon-closed",
+					metadata: expect.objectContaining({ gapKind: "evidence-horizon-closed" }),
+				}),
+			]),
+		);
+		expect(JSON.stringify({ runtimeStatus, issues, audit })).not.toMatch(
+			/hidden-result|arguments|rawResponse|stdout|stderr|stack/i,
+		);
+	});
+
+	it("uses score-based retention over bounded public run request entries", () => {
+		const g = graph();
+		const inputs = g.node<ToolProviderAdapterInput>([], null, {
+			name: "runtime-retention-score-inputs",
+		});
+		const runRequests = g.node<ToolProviderAdapterRunRequested>([], null, {
+			name: "runtime-retention-score-runs",
+		});
+		const ready = readyToolProviderAdapterInput(
+			"runtime-retention-score-provider",
+			"runtime-retention-score-req",
+		);
+		const scorerEntries: unknown[] = [];
+		const runtime = attachToolProviderAdapterRuntime(g, {
+			inputs,
+			runRequests: [runRequests],
+			autoRunReadyInputs: false,
+			retention: {
+				runRequests: {
+					maxSize: 1,
+					score(entry) {
+						scorerEntries.push(entry);
+						return entry.runId === "keep-run" ? 10 : 0;
+					},
+				},
+			},
+			bindings: [
+				{
+					providerId: "runtime-retention-score-provider",
+					run() {
+						return { kind: "result", result: { kind: "tool-output" } };
+					},
+				},
+			],
+		});
+		const runtimeStatus: ToolProviderAdapterRuntimeStatus[] = [];
+		runtime.runtimeStatus.subscribe(
+			(msg) => msg[0] === "DATA" && runtimeStatus.push(msg[1] as ToolProviderAdapterRuntimeStatus),
+		);
+
+		inputs.down([["DATA", ready]]);
+		runRequests.down([
+			[
+				"DATA",
+				requestToolProviderAdapterRun(ready, {
+					runId: "drop-run",
+					attempt: 1,
+					metadata: { rawResponse: "RAW_SHOULD_NOT_REACH_SCORER" },
+				}),
+			],
+			["DATA", requestToolProviderAdapterRun(ready, { runId: "keep-run", attempt: 2 })],
+		]);
+
+		expect(runtimeStatus).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({ status: "retention-trimmed", index: "runRequests" }),
+			]),
+		);
+		expect(JSON.stringify(scorerEntries)).not.toMatch(/rawResponse|RAW_SHOULD_NOT_REACH_SCORER/);
+		expect(scorerEntries).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({
+					key: expect.any(String),
+					sequence: expect.any(Number),
+					runId: "drop-run",
+					adapterInputId: ready.adapterInputId,
+					attempt: 1,
+					requestId: ready.requestId,
+					operationId: ready.operationId,
+				}),
+			]),
+		);
+	});
+});
diff --git a/packages/ts/src/__tests__/agent-runtime.part-05.test.ts b/packages/ts/src/__tests__/agent-runtime.part-05.test.ts
new file mode 100644
index 00000000..613bfad7
--- /dev/null
+++ b/packages/ts/src/__tests__/agent-runtime.part-05.test.ts
@@ -0,0 +1,900 @@
+import { describe, expect, it } from "vitest";
+import type { DataIssue } from "../data/index.js";
+import { graph } from "../graph/graph.js";
+import {
+	type AgentRequestIssued,
+	buildToolProviderAdapterInputs,
+	type ExecutorRoute,
+	localBuiltinToolProviderCatalog,
+	requestToolProviderAdapterRun,
+	resolveToolProviderExecutionPolicies,
+	type ToolProviderAdapterInput,
+	type ToolProviderAdapterRunRequested,
+	type ToolProviderAdapterRunStatus,
+} from "../orchestration/agent-runtime.js";
+import { attachToolProviderAdapterRuntime } from "../orchestration/agent-runtime-adapter-runtime.js";
+import type { ToolProviderAdapterRuntimeStatus } from "../orchestration/agent-runtime-types-tool.js";
+import type {
+	WorkItemDomainActionAdmissionDecision,
+	WorkItemDomainActionProposal,
+	WorkItemSeed,
+} from "../orchestration/work-item-runtime.js";
+
+function _issued(
+	requestId: string,
+	operationId: string,
+	requestKind: AgentRequestIssued["requestKind"],
+	inputKind?: string,
+): AgentRequestIssued {
+	return {
+		kind: "issued",
+		requestId,
+		operationId,
+		effectRunId: "run-1",
+		requestKind,
+		required: true,
+		input:
+			inputKind === undefined
+				? undefined
+				: { inputId: `${requestId}:input`, inputKind, dataMode: "summary", summary: inputKind },
+	};
+}
+
+function toolRequest(
+	requestId: string,
+	operationId: string,
+	toolName: string,
+	operation?: string,
+): AgentRequestIssued {
+	return {
+		kind: "issued",
+		requestId,
+		operationId,
+		effectRunId: "run-1",
+		requestKind: "executor",
+		required: true,
+		input: {
+			inputId: `${requestId}:input`,
+			inputKind: "tool-call",
+			dataMode: "inline",
+			value: {
+				kind: "tool-call",
+				toolName,
+				operation,
+				arguments: { path: "README.md" },
+			},
+		},
+	};
+}
+
+const forbiddenRetentionPayloadPattern =
+	/SCORER_SECRET|SCORER_RAW|rawResponse|stdout|stderr|stack|apiKey|password|arguments|providerClient|oauthState|subprocessHandle|transport|sdkObject/i;
+
+const retentionScorerEntryKeys: Record<string, readonly string[]> = {
+	adapterInputs: [
+		"adapterInputId",
+		"executorId",
+		"insertedAtMs",
+		"key",
+		"operationId",
+		"profileId",
+		"providerId",
+		"requestId",
+		"routeId",
+		"sequence",
+		"status",
+	],
+	runRequests: [
+		"adapterInputId",
+		"attempt",
+		"executorId",
+		"key",
+		"operationId",
+		"profileId",
+		"providerId",
+		"reason",
+		"requestId",
+		"requestedAtMs",
+		"routeId",
+		"runId",
+		"sequence",
+	],
+	executions: [
+		"adapterInputId",
+		"attempt",
+		"executorId",
+		"key",
+		"occurredAtMs",
+		"operationId",
+		"outcomeId",
+		"profileId",
+		"providerId",
+		"reason",
+		"requestId",
+		"routeId",
+		"runId",
+		"sequence",
+		"status",
+	],
+	runStatuses: [
+		"adapterInputId",
+		"attempt",
+		"issueCode",
+		"key",
+		"occurredAtMs",
+		"operationId",
+		"outcomeId",
+		"requestId",
+		"runId",
+		"sequence",
+		"status",
+	],
+	runIssues: [
+		"adapterInputId",
+		"attempt",
+		"issueCode",
+		"key",
+		"occurredAtMs",
+		"operationId",
+		"requestId",
+		"runId",
+		"sequence",
+		"severity",
+		"subjectId",
+	],
+	retentionEvidence: [
+		"adapterInputId",
+		"attemptHighWater",
+		"evidenceKind",
+		"key",
+		"occurredAtMs",
+		"reason",
+		"sequence",
+	],
+};
+
+function expectRetentionScorerEntryPayloadSafe(index: string, entry: unknown): void {
+	expect(entry).toBeTypeOf("object");
+	expect(Array.isArray(entry)).toBe(false);
+	const record = entry as Record<string, unknown>;
+	const allowed = retentionScorerEntryKeys[index];
+	expect(allowed, `unknown retention scorer index ${index}`).toBeDefined();
+	for (const [key, value] of Object.entries(record)) {
+		expect(allowed).toContain(key);
+		expect(value === undefined || typeof value === "string" || typeof value === "number").toBe(
+			true,
+		);
+		if (key === "key") expect(value).toEqual(expect.stringMatching(/^key:[a-z0-9]+:\d+$/));
+	}
+	expectNoForbiddenRetentionPayload(record);
+}
+
+function expectNoForbiddenRetentionPayload(value: unknown): void {
+	expect(JSON.stringify(value)).not.toMatch(forbiddenRetentionPayloadPattern);
+}
+
+function readyToolProviderAdapterInput(
+	providerId: string,
+	requestId: string,
+): ToolProviderAdapterInput {
+	const catalog = localBuiltinToolProviderCatalog({ providerId });
+	const profile = catalog.profiles[0];
+	if (profile === undefined) throw new Error("expected profile");
+	const request = toolRequest(requestId, `${requestId}-op`, "file.read", "read");
+	const route: ExecutorRoute = {
+		kind: "executor-route",
+		routeId: `${requestId}-route`,
+		requestId: request.requestId,
+		operationId: request.operationId,
+		executorId: profile.executorId,
+		profileId: profile.profileId,
+		inputKind: "tool-call",
+	};
+	const resolutions = resolveToolProviderExecutionPolicies({
+		request,
+		routes: [route],
+		catalogs: [catalog],
+	});
+	const input = buildToolProviderAdapterInputs({
+		requests: [request],
+		routes: [route],
+		catalogs: [catalog],
+		resolutions,
+	})[0];
+	if (input === undefined || input.status !== "ready") throw new Error("expected ready input");
+	return input;
+}
+
+function _workItemSeed(workItemId: string): WorkItemSeed {
+	return {
+		kind: "work-item",
+		workItemId,
+		sourceRefs: [{ kind: "work-item", id: workItemId }],
+		workItemKind: "issue",
+		lifecycleStatus: "open",
+	};
+}
+
+function _workItemActionProposal(
+	proposalId: string,
+	actionKind: string,
+	opts: Partial<WorkItemDomainActionProposal> = {},
+): WorkItemDomainActionProposal {
+	return {
+		kind: "work-item-domain-action-proposal",
+		proposalId,
+		workItemId: opts.workItemId ?? "wi-1",
+		actionKind,
+		effectRunId: opts.effectRunId ?? "run-1",
+		effectRunResultId: opts.effectRunResultId ?? "run-1:result",
+		evidenceId: opts.evidenceId ?? "wi-1:run-1:run-1:result",
+		policyId: opts.policyId ?? "policy-propose",
+		sourceRefs: opts.sourceRefs,
+		metadata: opts.metadata,
+	};
+}
+
+function _workItemAdmissionDecision(
+	decisionId: string,
+	admissionId: string,
+	proposalId: string,
+	outcome: WorkItemDomainActionAdmissionDecision["outcome"],
+	opts: Partial<WorkItemDomainActionAdmissionDecision> = {},
+): WorkItemDomainActionAdmissionDecision {
+	return {
+		kind: "work-item-domain-action-admission-decision",
+		decisionId,
+		admissionId,
+		proposalId,
+		outcome,
+		policyId: opts.policyId,
+		reason: opts.reason,
+		targetProposalId: opts.targetProposalId,
+		targetAdmissionId: opts.targetAdmissionId,
+		sourceRefs: opts.sourceRefs,
+		decidedAtMs: opts.decidedAtMs,
+		metadata: opts.metadata,
+	};
+}
+
+describe("CSP-8 experimental agent runtime kernel (D236) — part 5", () => {
+	it("keeps retention scorer entries bounded and payload-free across every runtime index", () => {
+		const g = graph();
+		const inputs = g.node<ToolProviderAdapterInput>([], null, {
+			name: "runtime-retention-all-score-inputs",
+		});
+		const runRequests = g.node<ToolProviderAdapterRunRequested>([], null, {
+			name: "runtime-retention-all-score-runs",
+		});
+		const first = readyToolProviderAdapterInput(
+			"runtime-retention-all-score-provider",
+			"runtime-retention-all-score-req-a",
+		);
+		const second = readyToolProviderAdapterInput(
+			"runtime-retention-all-score-provider",
+			"runtime-retention-all-score-req-b",
+		);
+		const oversizedRunId = `all-score-oversized-${"x".repeat(500)}`;
+		const firstWithPayload = {
+			...first,
+			toolCall: {
+				...first.toolCall,
+				arguments: {
+					path: "README.md",
+					password: "SCORER_SECRET_ARGUMENT",
+					rawResponse: "SCORER_RAW_ARGUMENT",
+				},
+			},
+			metadata: { apiKey: "SCORER_SECRET_INPUT_METADATA" },
+			sourceRefs: [
+				...(first.sourceRefs ?? []),
+				{
+					kind: "provider-raw",
+					id: "raw-input-ref",
+					metadata: { stdout: "SCORER_RAW_SOURCE_REF" },
+				},
+			],
+		} satisfies ToolProviderAdapterInput;
+		const entries = {
+			adapterInputs: [] as unknown[],
+			runRequests: [] as unknown[],
+			executions: [] as unknown[],
+			runStatuses: [] as unknown[],
+			runIssues: [] as unknown[],
+			retentionEvidence: [] as unknown[],
+		};
+		const runtime = attachToolProviderAdapterRuntime(g, {
+			inputs,
+			runRequests: [runRequests],
+			autoRunReadyInputs: false,
+			retention: {
+				adapterInputs: {
+					maxSize: 1,
+					score(entry) {
+						entries.adapterInputs.push(entry);
+						return entry.adapterInputId === second.adapterInputId ? 10 : 0;
+					},
+				},
+				runRequests: {
+					maxSize: 1,
+					score(entry) {
+						entries.runRequests.push(entry);
+						return entry.runId.startsWith("all-score-b") ? 10 : 0;
+					},
+				},
+				executions: {
+					maxSize: 1,
+					score(entry) {
+						entries.executions.push(entry);
+						return entry.adapterInputId === second.adapterInputId ? 10 : 0;
+					},
+				},
+				runStatuses: {
+					maxSize: 1,
+					score(entry) {
+						entries.runStatuses.push(entry);
+						return entry.runId === undefined || entry.runId.startsWith("all-score-b") ? 10 : 0;
+					},
+				},
+				runIssues: {
+					maxSize: 1,
+					score(entry) {
+						entries.runIssues.push(entry);
+						return entry.subjectId === second.requestId ? 10 : 0;
+					},
+				},
+				retentionEvidence: {
+					maxSize: 1,
+					score(entry) {
+						entries.retentionEvidence.push(entry);
+						return entry.adapterInputId === second.adapterInputId ? 10 : 0;
+					},
+				},
+			},
+			bindings: [
+				{
+					providerId: "runtime-retention-all-score-provider",
+					run() {
+						return {
+							kind: "result",
+							result: {
+								kind: "tool-output",
+								value: { stdout: "SCORER_RAW_STDOUT_VALUE" },
+							},
+							metadata: { rawResponse: "SCORER_RAW_PROVIDER_RESPONSE" },
+						};
+					},
+				},
+			],
+		});
+		const runtimeStatus: ToolProviderAdapterRuntimeStatus[] = [];
+		const issues: DataIssue[] = [];
+		const audit: unknown[] = [];
+		runtime.runtimeStatus.subscribe(
+			(msg) => msg[0] === "DATA" && runtimeStatus.push(msg[1] as ToolProviderAdapterRuntimeStatus),
+		);
+		runtime.issues.subscribe((msg) => msg[0] === "DATA" && issues.push(msg[1] as DataIssue));
+		runtime.audit.subscribe((msg) => msg[0] === "DATA" && audit.push(msg[1]));
+
+		inputs.down([["DATA", firstWithPayload]]);
+		runRequests.down([
+			[
+				"DATA",
+				requestToolProviderAdapterRun(firstWithPayload, {
+					runId: oversizedRunId,
+					attempt: 1,
+				}),
+			],
+		]);
+		inputs.down([["DATA", second]]);
+		runRequests.down([
+			["DATA", requestToolProviderAdapterRun(second, { runId: "all-score-b", attempt: 1 })],
+		]);
+
+		expect(runtimeStatus).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({ status: "retention-trimmed", index: "adapterInputs" }),
+				expect.objectContaining({ status: "retention-trimmed", index: "runRequests" }),
+				expect.objectContaining({ status: "retention-trimmed", index: "executions" }),
+				expect.objectContaining({ status: "retention-trimmed", index: "runStatuses" }),
+				expect.objectContaining({ status: "retention-trimmed", index: "runIssues" }),
+				expect.objectContaining({ status: "retention-trimmed", index: "retentionEvidence" }),
+			]),
+		);
+		for (const [index, captured] of Object.entries(entries)) {
+			expect(captured.length, `${index} scorer should run`).toBeGreaterThan(0);
+			for (const entry of captured) expectRetentionScorerEntryPayloadSafe(index, entry);
+		}
+		expect(
+			(entries.runRequests as { readonly runId?: string }[]).some(
+				(entry) =>
+					typeof entry.runId === "string" &&
+					entry.runId.startsWith("bounded:") &&
+					entry.runId.endsWith(`:${oversizedRunId.length}`),
+			),
+		).toBe(true);
+		expectNoForbiddenRetentionPayload({ entries, runtimeStatus, issues, audit });
+	});
+
+	it("makes Node-valued retention maxSize describe-visible and downsizing trims", () => {
+		const g = graph();
+		const maxSize = g.state(2, { name: "retentionMax" });
+		const inputs = g.node<ToolProviderAdapterInput>([], null, {
+			name: "runtime-retention-node-inputs",
+		});
+		const runRequests = g.node<ToolProviderAdapterRunRequested>([], null, {
+			name: "runtime-retention-node-runs",
+		});
+		const ready = readyToolProviderAdapterInput(
+			"runtime-retention-node-provider",
+			"runtime-retention-node-req",
+		);
+		const runtime = attachToolProviderAdapterRuntime(g, {
+			name: "runtimeRetentionNode",
+			inputs,
+			runRequests: [runRequests],
+			autoRunReadyInputs: false,
+			retention: { executions: { maxSize } },
+			bindings: [
+				{
+					providerId: "runtime-retention-node-provider",
+					run() {
+						return { kind: "result", result: { kind: "tool-output" } };
+					},
+				},
+			],
+		});
+		const runtimeStatus: ToolProviderAdapterRuntimeStatus[] = [];
+		runtime.runtimeStatus.subscribe(
+			(msg) => msg[0] === "DATA" && runtimeStatus.push(msg[1] as ToolProviderAdapterRuntimeStatus),
+		);
+		const described = g.describe();
+		expect(
+			described.nodes.find((node) => node.id === "runtimeRetentionNode/retentionPolicy")?.factory,
+		).toBe("toolProviderAdapterRuntimeRetentionPolicy");
+		expect(described.edges).toContainEqual({
+			from: "retentionMax",
+			to: "runtimeRetentionNode/retentionPolicy",
+		});
+
+		inputs.down([["DATA", ready]]);
+		runRequests.down([
+			["DATA", requestToolProviderAdapterRun(ready, { runId: "node-run", attempt: 1 })],
+			["DATA", requestToolProviderAdapterRun(ready, { runId: "node-run", attempt: 2 })],
+		]);
+		maxSize.set(1);
+
+		expect(runtimeStatus).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({ status: "retention-trimmed", index: "executions" }),
+			]),
+		);
+	});
+
+	it("keeps last-known-good retention policy for invalid maxSize/order/scorer without leaking throws", () => {
+		const g = graph();
+		const maxSize = g.state(2, { name: "invalidRetentionMax" });
+		const inputs = g.node<ToolProviderAdapterInput>([], null, {
+			name: "runtime-retention-invalid-inputs",
+		});
+		const runRequests = g.node<ToolProviderAdapterRunRequested>([], null, {
+			name: "runtime-retention-invalid-runs",
+		});
+		const ready = readyToolProviderAdapterInput(
+			"runtime-retention-invalid-provider",
+			"runtime-retention-invalid-req",
+		);
+		const runtime = attachToolProviderAdapterRuntime(g, {
+			inputs,
+			runRequests: [runRequests],
+			autoRunReadyInputs: false,
+			retention: {
+				executions: { maxSize },
+				runStatuses: { maxSize: 1 },
+				runRequests: {
+					maxSize: 1,
+					score() {
+						throw new Error("secret-score-throw");
+					},
+				},
+			},
+			bindings: [
+				{
+					providerId: "runtime-retention-invalid-provider",
+					run() {
+						return { kind: "result", result: { kind: "tool-output" } };
+					},
+				},
+			],
+		});
+		const runtimeStatus: ToolProviderAdapterRuntimeStatus[] = [];
+		const issues: DataIssue[] = [];
+		const audit: unknown[] = [];
+		runtime.runtimeStatus.subscribe(
+			(msg) => msg[0] === "DATA" && runtimeStatus.push(msg[1] as ToolProviderAdapterRuntimeStatus),
+		);
+		runtime.issues.subscribe((msg) => msg[0] === "DATA" && issues.push(msg[1] as DataIssue));
+		runtime.audit.subscribe((msg) => msg[0] === "DATA" && audit.push(msg[1]));
+
+		inputs.down([["DATA", ready]]);
+		runRequests.down([
+			["DATA", requestToolProviderAdapterRun(ready, { runId: "invalid-run", attempt: 1 })],
+			["DATA", requestToolProviderAdapterRun(ready, { runId: "invalid-run", attempt: 2 })],
+		]);
+		maxSize.set(0);
+		runRequests.down([
+			["DATA", requestToolProviderAdapterRun(ready, { runId: "invalid-run", attempt: 3 })],
+		]);
+
+		expect(runtimeStatus).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({ status: "invalid-retention-policy" }),
+				expect.objectContaining({ status: "retention-trimmed", index: "runStatuses" }),
+			]),
+		);
+		expect(issues).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({
+					code: "tool-provider-adapter-runtime-invalid-retention-policy",
+				}),
+				expect.objectContaining({
+					code: "tool-provider-adapter-retention-score-invalid",
+				}),
+			]),
+		);
+		expect(JSON.stringify({ runtimeStatus, issues, audit })).not.toContain("secret-score-throw");
+
+		const orderGraph = graph();
+		const orderInputs = orderGraph.node<ToolProviderAdapterInput>([], null, {
+			name: "runtime-retention-order-inputs",
+		});
+		const orderRuntime = attachToolProviderAdapterRuntime(orderGraph, {
+			inputs: orderInputs,
+			autoRunReadyInputs: false,
+			retention: { runStatuses: { maxSize: 1, order: "lifo" as "fifo" } },
+			bindings: [],
+		});
+		const orderIssues: DataIssue[] = [];
+		orderRuntime.issues.subscribe(
+			(msg) => msg[0] === "DATA" && orderIssues.push(msg[1] as DataIssue),
+		);
+		expect(orderIssues).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({
+					code: "tool-provider-adapter-runtime-invalid-retention-policy",
+				}),
+			]),
+		);
+
+		const evidenceGraph = graph();
+		const evidenceInputs = evidenceGraph.node<ToolProviderAdapterInput>([], null, {
+			name: "runtime-retention-evidence-score-inputs",
+		});
+		const evidenceRunRequests = evidenceGraph.node<ToolProviderAdapterRunRequested>([], null, {
+			name: "runtime-retention-evidence-score-runs",
+		});
+		const evidenceFirst = readyToolProviderAdapterInput(
+			"runtime-retention-evidence-score-provider",
+			"runtime-retention-evidence-score-req-a",
+		);
+		const evidenceSecond = readyToolProviderAdapterInput(
+			"runtime-retention-evidence-score-provider",
+			"runtime-retention-evidence-score-req-b",
+		);
+		const evidenceScorerEntries: unknown[] = [];
+		const evidenceRuntime = attachToolProviderAdapterRuntime(evidenceGraph, {
+			inputs: evidenceInputs,
+			runRequests: [evidenceRunRequests],
+			autoRunReadyInputs: false,
+			retention: {
+				executions: { maxSize: 1 },
+				retentionEvidence: {
+					maxSize: 1,
+					score(entry) {
+						evidenceScorerEntries.push(entry);
+						throw new Error("secret-evidence-score-throw");
+					},
+				},
+			},
+			bindings: [
+				{
+					providerId: "runtime-retention-evidence-score-provider",
+					run() {
+						return { kind: "result", result: { kind: "tool-output", value: "hidden" } };
+					},
+				},
+			],
+		});
+		const evidenceRuntimeStatus: ToolProviderAdapterRuntimeStatus[] = [];
+		const evidenceIssues: DataIssue[] = [];
+		const evidenceAudit: unknown[] = [];
+		evidenceRuntime.runtimeStatus.subscribe(
+			(msg) =>
+				msg[0] === "DATA" && evidenceRuntimeStatus.push(msg[1] as ToolProviderAdapterRuntimeStatus),
+		);
+		evidenceRuntime.issues.subscribe(
+			(msg) => msg[0] === "DATA" && evidenceIssues.push(msg[1] as DataIssue),
+		);
+		evidenceRuntime.audit.subscribe((msg) => msg[0] === "DATA" && evidenceAudit.push(msg[1]));
+
+		evidenceInputs.down([
+			["DATA", evidenceFirst],
+			["DATA", evidenceSecond],
+		]);
+		evidenceRunRequests.down([
+			[
+				"DATA",
+				requestToolProviderAdapterRun(evidenceFirst, {
+					runId: "evidence-score-a-1",
+					attempt: 1,
+				}),
+			],
+			[
+				"DATA",
+				requestToolProviderAdapterRun(evidenceFirst, {
+					runId: "evidence-score-a-2",
+					attempt: 2,
+				}),
+			],
+			[
+				"DATA",
+				requestToolProviderAdapterRun(evidenceSecond, {
+					runId: "evidence-score-b-1",
+					attempt: 1,
+				}),
+			],
+			[
+				"DATA",
+				requestToolProviderAdapterRun(evidenceSecond, {
+					runId: "evidence-score-b-2",
+					attempt: 2,
+				}),
+			],
+		]);
+
+		expect(evidenceRuntimeStatus).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({
+					status: "invalid-retention-policy",
+					index: "retentionEvidence",
+					issueCode: "tool-provider-adapter-retention-score-invalid",
+				}),
+			]),
+		);
+		expect(evidenceIssues).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({
+					code: "tool-provider-adapter-retention-score-invalid",
+				}),
+			]),
+		);
+		expect(JSON.stringify({ evidenceRuntimeStatus, evidenceIssues, evidenceAudit })).not.toContain(
+			"secret-evidence-score-throw",
+		);
+		expect(JSON.stringify(evidenceScorerEntries)).not.toMatch(/tool-output|arguments|raw/i);
+	});
+
+	it("does not recursively feed runIssues when its retention scorer is invalid", () => {
+		const g = graph();
+		const inputs = g.node<ToolProviderAdapterInput>([], null, {
+			name: "runtime-retention-run-issues-score-inputs",
+		});
+		const runRequests = g.node<ToolProviderAdapterRunRequested>([], null, {
+			name: "runtime-retention-run-issues-score-runs",
+		});
+		const ready = readyToolProviderAdapterInput(
+			"runtime-retention-run-issues-score-provider",
+			"runtime-retention-run-issues-score-req",
+		);
+		const runtime = attachToolProviderAdapterRuntime(g, {
+			inputs,
+			runRequests: [runRequests],
+			autoRunReadyInputs: false,
+			retention: {
+				runIssues: {
+					maxSize: 1,
+					score() {
+						throw new Error("recursive-score-secret");
+					},
+				},
+			},
+			bindings: [],
+		});
+		const issues: DataIssue[] = [];
+		const runtimeStatus: ToolProviderAdapterRuntimeStatus[] = [];
+		runtime.issues.subscribe((msg) => msg[0] === "DATA" && issues.push(msg[1] as DataIssue));
+		runtime.runtimeStatus.subscribe(
+			(msg) => msg[0] === "DATA" && runtimeStatus.push(msg[1] as ToolProviderAdapterRuntimeStatus),
+		);
+
+		inputs.down([["DATA", ready]]);
+		expect(() =>
+			runRequests.down([
+				[
+					"DATA",
+					{
+						...requestToolProviderAdapterRun(ready, { runId: "run-issues-score-invalid" }),
+						requestId: "stale-request",
+					},
+				],
+			]),
+		).not.toThrow();
+
+		expect(
+			issues.filter((issue) => issue.code === "tool-provider-adapter-retention-score-invalid"),
+		).toHaveLength(1);
+		expect(runtimeStatus).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({
+					status: "invalid-retention-policy",
+					index: "runIssues",
+					issueCode: "tool-provider-adapter-retention-score-invalid",
+				}),
+			]),
+		);
+		expect(JSON.stringify({ issues, runtimeStatus })).not.toContain("recursive-score-secret");
+	});
+
+	it("gaps explicit run requests after adapterInputs retention trims the input cache", () => {
+		const g = graph();
+		const inputs = g.node<ToolProviderAdapterInput>([], null, {
+			name: "runtime-retention-input-cache-inputs",
+		});
+		const runRequests = g.node<ToolProviderAdapterRunRequested>([], null, {
+			name: "runtime-retention-input-cache-runs",
+		});
+		const first = readyToolProviderAdapterInput(
+			"runtime-retention-input-cache-provider",
+			"runtime-retention-input-cache-req-a",
+		);
+		const second = readyToolProviderAdapterInput(
+			"runtime-retention-input-cache-provider",
+			"runtime-retention-input-cache-req-b",
+		);
+		const calls: string[] = [];
+		const runtime = attachToolProviderAdapterRuntime(g, {
+			inputs,
+			runRequests: [runRequests],
+			autoRunReadyInputs: false,
+			retention: { adapterInputs: { maxSize: 1 } },
+			bindings: [
+				{
+					providerId: "runtime-retention-input-cache-provider",
+					run(input) {
+						calls.push(input.adapterInputId);
+						return { kind: "result", result: { kind: "tool-output" } };
+					},
+				},
+			],
+		});
+		const runStatus: ToolProviderAdapterRunStatus[] = [];
+		const runtimeStatus: ToolProviderAdapterRuntimeStatus[] = [];
+		const emittedRequests: ToolProviderAdapterRunRequested[] = [];
+		const audit: unknown[] = [];
+		runtime.runRequests.subscribe(
+			(msg) => msg[0] === "DATA" && emittedRequests.push(msg[1] as ToolProviderAdapterRunRequested),
+		);
+		runtime.runStatus.subscribe(
+			(msg) => msg[0] === "DATA" && runStatus.push(msg[1] as ToolProviderAdapterRunStatus),
+		);
+		runtime.runtimeStatus.subscribe(
+			(msg) => msg[0] === "DATA" && runtimeStatus.push(msg[1] as ToolProviderAdapterRuntimeStatus),
+		);
+		runtime.audit.subscribe((msg) => msg[0] === "DATA" && audit.push(msg[1]));
+
+		inputs.down([
+			["DATA", first],
+			["DATA", second],
+		]);
+		runRequests.down([
+			[
+				"DATA",
+				{
+					...requestToolProviderAdapterRun(first, { runId: "trimmed-input" }),
+					metadata: { rawResponse: "RAW_RETAINED_REQUEST_METADATA" },
+					sourceRefs: [
+						{
+							kind: "provider-raw",
+							id: "raw-retained-request",
+							metadata: { stdout: "RAW_RETAINED_REQUEST_SOURCE_REF" },
+						},
+					],
+					rawResponse: "RAW_RETAINED_REQUEST_TOP_LEVEL",
+				} as unknown as ToolProviderAdapterRunRequested,
+			],
+		]);
+
+		expect(calls).toEqual([]);
+		expect(emittedRequests).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({
+					runId: "trimmed-input",
+					adapterInputId: first.adapterInputId,
+					requestId: first.requestId,
+				}),
+			]),
+		);
+		expect(runtimeStatus).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({ status: "retention-trimmed", index: "adapterInputs" }),
+				expect.objectContaining({
+					status: "retention-gap",
+					index: "adapterInputs",
+					issueCode: "tool-provider-adapter-runtime-retention-gap",
+					metadata: expect.objectContaining({
+						gapKind: "adapter-input-trimmed",
+						evidenceKind: "adapter-input-trimmed",
+					}),
+				}),
+			]),
+		);
+		expect(runStatus).toEqual(
+			expect.arrayContaining([expect.objectContaining({ status: "retention-gap" })]),
+		);
+		expect(runStatus.filter((status) => status.runId === "trimmed-input")).toEqual(
+			expect.arrayContaining([expect.objectContaining({ status: "retention-gap" })]),
+		);
+		expect(runStatus.filter((status) => status.runId === "trimmed-input")).not.toEqual(
+			expect.arrayContaining([expect.objectContaining({ status: "missing-input" })]),
+		);
+		expect(JSON.stringify({ emittedRequests, audit, runStatus, runtimeStatus })).not.toMatch(
+			/RAW_RETAINED_REQUEST|rawResponse|stdout/,
+		);
+	});
+
+	it("refreshes FIFO retention order when an adapter input is re-emitted", () => {
+		const g = graph();
+		const inputs = g.node<ToolProviderAdapterInput>([], null, {
+			name: "runtime-retention-refresh-inputs",
+		});
+		const runRequests = g.node<ToolProviderAdapterRunRequested>([], null, {
+			name: "runtime-retention-refresh-runs",
+		});
+		const first = readyToolProviderAdapterInput(
+			"runtime-retention-refresh-provider",
+			"runtime-retention-refresh-req-a",
+		);
+		const second = readyToolProviderAdapterInput(
+			"runtime-retention-refresh-provider",
+			"runtime-retention-refresh-req-b",
+		);
+		const calls: string[] = [];
+		const runtime = attachToolProviderAdapterRuntime(g, {
+			inputs,
+			runRequests: [runRequests],
+			autoRunReadyInputs: false,
+			retention: { adapterInputs: { maxSize: 1 } },
+			bindings: [
+				{
+					providerId: "runtime-retention-refresh-provider",
+					run(input) {
+						calls.push(input.adapterInputId);
+						return { kind: "result", result: { kind: "tool-output" } };
+					},
+				},
+			],
+		});
+		const runStatus: ToolProviderAdapterRunStatus[] = [];
+		runtime.runStatus.subscribe(
+			(msg) => msg[0] === "DATA" && runStatus.push(msg[1] as ToolProviderAdapterRunStatus),
+		);
+
+		inputs.down([
+			["DATA", first],
+			["DATA", second],
+			["DATA", first],
+		]);
+		runRequests.down([
+			["DATA", requestToolProviderAdapterRun(first, { runId: "refreshed-first" })],
+			["DATA", requestToolProviderAdapterRun(second, { runId: "trimmed-second" })],
+		]);
+
+		expect(calls).toEqual([first.adapterInputId]);
+		expect(runStatus).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({ runId: "refreshed-first", status: "started" }),
+				expect.objectContaining({ runId: "trimmed-second", status: "retention-gap" }),
+			]),
+		);
+	});
+});
diff --git a/packages/ts/src/__tests__/agent-runtime.part-06.test.ts b/packages/ts/src/__tests__/agent-runtime.part-06.test.ts
new file mode 100644
index 00000000..b7140901
--- /dev/null
+++ b/packages/ts/src/__tests__/agent-runtime.part-06.test.ts
@@ -0,0 +1,855 @@
+import { describe, expect, it } from "vitest";
+import type { DataIssue } from "../data/index.js";
+import { graph } from "../graph/graph.js";
+import {
+	type AgentRequestFact,
+	type AgentRequestIssued,
+	type AgentRequestStatusChanged,
+	buildToolProviderAdapterInputs,
+	buildToolProviderExecutorOutcome,
+	type ExecutorRoute,
+	localBuiltinToolProviderCatalog,
+	requestToolProviderAdapterRun,
+	resolveToolProviderExecutionPolicies,
+	type ToolProviderAdapterInput,
+	type ToolProviderAdapterRunRequested,
+	type ToolProviderAdapterRunStatus,
+	type ToolProviderCatalog,
+	type ToolProviderPolicyResolution,
+	toolProviderPolicyResolutionProjector,
+} from "../orchestration/agent-runtime.js";
+import { attachToolProviderAdapterRuntime } from "../orchestration/agent-runtime-adapter-runtime.js";
+import type { ToolProviderAdapterRuntimeStatus } from "../orchestration/agent-runtime-types-tool.js";
+import type {
+	WorkItemDomainActionAdmissionDecision,
+	WorkItemDomainActionProposal,
+	WorkItemSeed,
+} from "../orchestration/work-item-runtime.js";
+
+function _issued(
+	requestId: string,
+	operationId: string,
+	requestKind: AgentRequestIssued["requestKind"],
+	inputKind?: string,
+): AgentRequestIssued {
+	return {
+		kind: "issued",
+		requestId,
+		operationId,
+		effectRunId: "run-1",
+		requestKind,
+		required: true,
+		input:
+			inputKind === undefined
+				? undefined
+				: { inputId: `${requestId}:input`, inputKind, dataMode: "summary", summary: inputKind },
+	};
+}
+
+function toolRequest(
+	requestId: string,
+	operationId: string,
+	toolName: string,
+	operation?: string,
+): AgentRequestIssued {
+	return {
+		kind: "issued",
+		requestId,
+		operationId,
+		effectRunId: "run-1",
+		requestKind: "executor",
+		required: true,
+		input: {
+			inputId: `${requestId}:input`,
+			inputKind: "tool-call",
+			dataMode: "inline",
+			value: {
+				kind: "tool-call",
+				toolName,
+				operation,
+				arguments: { path: "README.md" },
+			},
+		},
+	};
+}
+
+const forbiddenRetentionPayloadPattern =
+	/SCORER_SECRET|SCORER_RAW|rawResponse|stdout|stderr|stack|apiKey|password|arguments|providerClient|oauthState|subprocessHandle|transport|sdkObject/i;
+
+const retentionScorerEntryKeys: Record<string, readonly string[]> = {
+	adapterInputs: [
+		"adapterInputId",
+		"executorId",
+		"insertedAtMs",
+		"key",
+		"operationId",
+		"profileId",
+		"providerId",
+		"requestId",
+		"routeId",
+		"sequence",
+		"status",
+	],
+	runRequests: [
+		"adapterInputId",
+		"attempt",
+		"executorId",
+		"key",
+		"operationId",
+		"profileId",
+		"providerId",
+		"reason",
+		"requestId",
+		"requestedAtMs",
+		"routeId",
+		"runId",
+		"sequence",
+	],
+	executions: [
+		"adapterInputId",
+		"attempt",
+		"executorId",
+		"key",
+		"occurredAtMs",
+		"operationId",
+		"outcomeId",
+		"profileId",
+		"providerId",
+		"reason",
+		"requestId",
+		"routeId",
+		"runId",
+		"sequence",
+		"status",
+	],
+	runStatuses: [
+		"adapterInputId",
+		"attempt",
+		"issueCode",
+		"key",
+		"occurredAtMs",
+		"operationId",
+		"outcomeId",
+		"requestId",
+		"runId",
+		"sequence",
+		"status",
+	],
+	runIssues: [
+		"adapterInputId",
+		"attempt",
+		"issueCode",
+		"key",
+		"occurredAtMs",
+		"operationId",
+		"requestId",
+		"runId",
+		"sequence",
+		"severity",
+		"subjectId",
+	],
+	retentionEvidence: [
+		"adapterInputId",
+		"attemptHighWater",
+		"evidenceKind",
+		"key",
+		"occurredAtMs",
+		"reason",
+		"sequence",
+	],
+};
+
+function _expectRetentionScorerEntryPayloadSafe(index: string, entry: unknown): void {
+	expect(entry).toBeTypeOf("object");
+	expect(Array.isArray(entry)).toBe(false);
+	const record = entry as Record<string, unknown>;
+	const allowed = retentionScorerEntryKeys[index];
+	expect(allowed, `unknown retention scorer index ${index}`).toBeDefined();
+	for (const [key, value] of Object.entries(record)) {
+		expect(allowed).toContain(key);
+		expect(value === undefined || typeof value === "string" || typeof value === "number").toBe(
+			true,
+		);
+		if (key === "key") expect(value).toEqual(expect.stringMatching(/^key:[a-z0-9]+:\d+$/));
+	}
+	expectNoForbiddenRetentionPayload(record);
+}
+
+function expectNoForbiddenRetentionPayload(value: unknown): void {
+	expect(JSON.stringify(value)).not.toMatch(forbiddenRetentionPayloadPattern);
+}
+
+function readyToolProviderAdapterInput(
+	providerId: string,
+	requestId: string,
+): ToolProviderAdapterInput {
+	const catalog = localBuiltinToolProviderCatalog({ providerId });
+	const profile = catalog.profiles[0];
+	if (profile === undefined) throw new Error("expected profile");
+	const request = toolRequest(requestId, `${requestId}-op`, "file.read", "read");
+	const route: ExecutorRoute = {
+		kind: "executor-route",
+		routeId: `${requestId}-route`,
+		requestId: request.requestId,
+		operationId: request.operationId,
+		executorId: profile.executorId,
+		profileId: profile.profileId,
+		inputKind: "tool-call",
+	};
+	const resolutions = resolveToolProviderExecutionPolicies({
+		request,
+		routes: [route],
+		catalogs: [catalog],
+	});
+	const input = buildToolProviderAdapterInputs({
+		requests: [request],
+		routes: [route],
+		catalogs: [catalog],
+		resolutions,
+	})[0];
+	if (input === undefined || input.status !== "ready") throw new Error("expected ready input");
+	return input;
+}
+
+function _workItemSeed(workItemId: string): WorkItemSeed {
+	return {
+		kind: "work-item",
+		workItemId,
+		sourceRefs: [{ kind: "work-item", id: workItemId }],
+		workItemKind: "issue",
+		lifecycleStatus: "open",
+	};
+}
+
+function _workItemActionProposal(
+	proposalId: string,
+	actionKind: string,
+	opts: Partial<WorkItemDomainActionProposal> = {},
+): WorkItemDomainActionProposal {
+	return {
+		kind: "work-item-domain-action-proposal",
+		proposalId,
+		workItemId: opts.workItemId ?? "wi-1",
+		actionKind,
+		effectRunId: opts.effectRunId ?? "run-1",
+		effectRunResultId: opts.effectRunResultId ?? "run-1:result",
+		evidenceId: opts.evidenceId ?? "wi-1:run-1:run-1:result",
+		policyId: opts.policyId ?? "policy-propose",
+		sourceRefs: opts.sourceRefs,
+		metadata: opts.metadata,
+	};
+}
+
+function _workItemAdmissionDecision(
+	decisionId: string,
+	admissionId: string,
+	proposalId: string,
+	outcome: WorkItemDomainActionAdmissionDecision["outcome"],
+	opts: Partial<WorkItemDomainActionAdmissionDecision> = {},
+): WorkItemDomainActionAdmissionDecision {
+	return {
+		kind: "work-item-domain-action-admission-decision",
+		decisionId,
+		admissionId,
+		proposalId,
+		outcome,
+		policyId: opts.policyId,
+		reason: opts.reason,
+		targetProposalId: opts.targetProposalId,
+		targetAdmissionId: opts.targetAdmissionId,
+		sourceRefs: opts.sourceRefs,
+		decidedAtMs: opts.decidedAtMs,
+		metadata: opts.metadata,
+	};
+}
+
+describe("CSP-8 experimental agent runtime kernel (D236) — part 6", () => {
+	it("caps runRequests emission keys without deleting already emitted request facts", () => {
+		const g = graph();
+		const inputs = g.node<ToolProviderAdapterInput>([], null, {
+			name: "runtime-retention-run-request-key-inputs",
+		});
+		const runRequests = g.node<ToolProviderAdapterRunRequested>([], null, {
+			name: "runtime-retention-run-request-key-runs",
+		});
+		const ready = readyToolProviderAdapterInput(
+			"runtime-retention-run-request-key-provider",
+			"runtime-retention-run-request-key-req",
+		);
+		const longRunA = `request-key-a-${"x".repeat(40)}-runtime-status-key-tail`;
+		const longRunB = `request-key-b-${"y".repeat(40)}-runtime-status-key-tail`;
+		const runtime = attachToolProviderAdapterRuntime(g, {
+			inputs,
+			runRequests: [runRequests],
+			autoRunReadyInputs: false,
+			retention: { runRequests: { maxSize: 1 } },
+			publicText: { maxMetadataStringChars: 24 },
+			bindings: [
+				{
+					providerId: "runtime-retention-run-request-key-provider",
+					run() {
+						return { kind: "result", result: { kind: "tool-output" } };
+					},
+				},
+			],
+		});
+		const emittedRequests: ToolProviderAdapterRunRequested[] = [];
+		const runtimeStatus: ToolProviderAdapterRuntimeStatus[] = [];
+		const issues: DataIssue[] = [];
+		const audit: Record<string, unknown>[] = [];
+		runtime.runRequests.subscribe(
+			(msg) => msg[0] === "DATA" && emittedRequests.push(msg[1] as ToolProviderAdapterRunRequested),
+		);
+		runtime.runtimeStatus.subscribe(
+			(msg) => msg[0] === "DATA" && runtimeStatus.push(msg[1] as ToolProviderAdapterRuntimeStatus),
+		);
+		runtime.issues.subscribe((msg) => msg[0] === "DATA" && issues.push(msg[1] as DataIssue));
+		runtime.audit.subscribe(
+			(msg) => msg[0] === "DATA" && audit.push(msg[1] as Record<string, unknown>),
+		);
+
+		inputs.down([["DATA", ready]]);
+		runRequests.down([
+			[
+				"DATA",
+				requestToolProviderAdapterRun(ready, {
+					runId: longRunA,
+					attempt: 1,
+					sourceRefs: [
+						{
+							kind: "provider-raw",
+							id: "raw-run-request-ref",
+							metadata: { stdout: "RAW_RUN_REQUEST_REPLAY_REF_SHOULD_NOT_PROJECT" },
+						},
+					],
+					metadata: { rawResponse: "RAW_RUN_REQUEST_REPLAY_METADATA_SHOULD_NOT_PROJECT" },
+				}),
+			],
+			["DATA", requestToolProviderAdapterRun(ready, { runId: longRunB, attempt: 2 })],
+			[
+				"DATA",
+				requestToolProviderAdapterRun(ready, {
+					runId: longRunA,
+					attempt: 1,
+					sourceRefs: [
+						{
+							kind: "provider-raw",
+							id: "raw-run-request-ref",
+							metadata: { stdout: "RAW_RUN_REQUEST_REPLAY_REF_SHOULD_NOT_PROJECT" },
+						},
+					],
+					metadata: { rawResponse: "RAW_RUN_REQUEST_REPLAY_METADATA_SHOULD_NOT_PROJECT" },
+				}),
+			],
+		]);
+
+		const replayed = emittedRequests.filter((request) => request.runId === longRunA);
+		expect(replayed).toHaveLength(2);
+		expect(replayed).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({
+					sourceRefs: expect.arrayContaining([{ kind: "provider-raw", id: "raw-run-request-ref" }]),
+				}),
+			]),
+		);
+		expect(replayed.every((request) => request.metadata === undefined)).toBe(true);
+		const trimmedStatus = runtimeStatus.find(
+			(status) => status.status === "retention-trimmed" && status.index === "runRequests",
+		);
+		expect(trimmedStatus).toMatchObject({
+			status: "retention-trimmed",
+			index: "runRequests",
+			sourceRefs: [{ kind: "tool-provider-adapter-runtime-retention-index", id: "runRequests" }],
+			metadata: expect.objectContaining({ index: "runRequests", key: expect.any(String) }),
+		});
+		expect((trimmedStatus?.key ?? "").length).toBeLessThanOrEqual(24);
+		expect(
+			((trimmedStatus?.metadata as { key?: string } | undefined)?.key ?? "").length,
+		).toBeLessThanOrEqual(24);
+		expect(trimmedStatus?.key).toMatch(/^key:[a-z0-9]+:\d+$/);
+		expect((trimmedStatus?.metadata as { key?: string } | undefined)?.key).toMatch(
+			/^key:[a-z0-9]+:\d+$/,
+		);
+		const trimmedIssue = issues.find(
+			(issue) => issue.code === "tool-provider-adapter-runtime-retention-trimmed",
+		);
+		expect((trimmedIssue?.details as { key?: string } | undefined)?.key).toMatch(
+			/^key:[a-z0-9]+:\d+$/,
+		);
+		const trimmedAudit = audit.find(
+			(record) => record.kind === "tool-provider-adapter-runtime-retention-trimmed",
+		);
+		expect((trimmedAudit?.metadata as { key?: string } | undefined)?.key).toMatch(
+			/^key:[a-z0-9]+:\d+$/,
+		);
+		expect(
+			JSON.stringify({
+				statusKey: trimmedStatus?.key,
+				statusMetadata: trimmedStatus?.metadata,
+				issueDetails: trimmedIssue?.details,
+				auditMetadata: trimmedAudit?.metadata,
+			}),
+		).not.toContain("runtime-status-key-tail");
+		expect(JSON.stringify({ emittedRequests, runtimeStatus })).not.toMatch(
+			/RAW_RUN_REQUEST_REPLAY|rawResponse|stdout/,
+		);
+	});
+
+	it("caps runStatuses and runIssues indexes without deleting already emitted facts", () => {
+		const g = graph();
+		const inputs = g.node<ToolProviderAdapterInput>([], null, {
+			name: "runtime-retention-emission-inputs",
+		});
+		const runRequests = g.node<ToolProviderAdapterRunRequested>([], null, {
+			name: "runtime-retention-emission-runs",
+		});
+		const ready = readyToolProviderAdapterInput(
+			"runtime-retention-emission-provider",
+			"runtime-retention-emission-req",
+		);
+		const runtime = attachToolProviderAdapterRuntime(g, {
+			inputs,
+			runRequests: [runRequests],
+			autoRunReadyInputs: false,
+			retention: {
+				runStatuses: { maxSize: 1 },
+				runIssues: { maxSize: 1 },
+			},
+			bindings: [],
+		});
+		const runStatus: ToolProviderAdapterRunStatus[] = [];
+		const issues: DataIssue[] = [];
+		const runtimeStatus: ToolProviderAdapterRuntimeStatus[] = [];
+		runtime.runStatus.subscribe(
+			(msg) => msg[0] === "DATA" && runStatus.push(msg[1] as ToolProviderAdapterRunStatus),
+		);
+		runtime.issues.subscribe((msg) => msg[0] === "DATA" && issues.push(msg[1] as DataIssue));
+		runtime.runtimeStatus.subscribe(
+			(msg) => msg[0] === "DATA" && runtimeStatus.push(msg[1] as ToolProviderAdapterRuntimeStatus),
+		);
+
+		inputs.down([["DATA", ready]]);
+		runRequests.down([
+			[
+				"DATA",
+				{
+					...requestToolProviderAdapterRun(ready, { runId: "bad-run-a", attempt: 1 }),
+					requestId: "stale-a",
+				},
+			],
+			[
+				"DATA",
+				{
+					...requestToolProviderAdapterRun(ready, { runId: "bad-run-b", attempt: 2 }),
+					requestId: "stale-b",
+				},
+			],
+		]);
+		runRequests.down([
+			[
+				"DATA",
+				{
+					...requestToolProviderAdapterRun(ready, { runId: "bad-run-a", attempt: 1 }),
+					requestId: "stale-a",
+				},
+			],
+		]);
+
+		expect(runStatus.length).toBeGreaterThan(1);
+		expect(issues.length).toBeGreaterThan(1);
+		expect(runtimeStatus).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({ status: "retention-trimmed", index: "runStatuses" }),
+				expect.objectContaining({ status: "retention-trimmed", index: "runIssues" }),
+			]),
+		);
+		for (const index of ["runStatuses", "runIssues"] as const) {
+			const trimmedStatus = runtimeStatus.find(
+				(status) => status.status === "retention-trimmed" && status.index === index,
+			);
+			expect(trimmedStatus).toMatchObject({
+				sourceRefs: [{ kind: "tool-provider-adapter-runtime-retention-index", id: index }],
+				metadata: expect.objectContaining({ index, key: expect.any(String) }),
+			});
+		}
+		expect(runStatus).toEqual(
+			expect.arrayContaining([expect.objectContaining({ runId: "bad-run-a" })]),
+		);
+		expect(runStatus.filter((status) => status.runId === "bad-run-a")).toHaveLength(2);
+		expect(issues).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({ code: "tool-provider-adapter-run-request-stale-request" }),
+			]),
+		);
+		expect(
+			issues.filter(
+				(issue) =>
+					issue.code === "tool-provider-adapter-run-request-stale-request" &&
+					issue.subjectId === ready.requestId,
+			),
+		).toHaveLength(3);
+	});
+
+	it("emits DataIssue and run status for missing or stale run requests without protocol ERROR", () => {
+		const g = graph();
+		const inputs = g.node<ToolProviderAdapterInput>([], null, { name: "runtime-stale-inputs" });
+		const runRequests = g.node<ToolProviderAdapterRunRequested>([], null, {
+			name: "runtime-stale-requests",
+		});
+		const ready = readyToolProviderAdapterInput("runtime-stale-provider", "runtime-stale-req");
+		const calls: ToolProviderAdapterInput[] = [];
+		const runtime = attachToolProviderAdapterRuntime(g, {
+			inputs,
+			runRequests: [runRequests],
+			autoRunReadyInputs: false,
+			bindings: [
+				{
+					providerId: "runtime-stale-provider",
+					run(input) {
+						calls.push(input);
+						return { kind: "result", result: { kind: "tool-output" } };
+					},
+				},
+			],
+		});
+		const issues: DataIssue[] = [];
+		const runStatus: ToolProviderAdapterRunStatus[] = [];
+		const runtimeStatus: ToolProviderAdapterRuntimeStatus[] = [];
+		const audit: unknown[] = [];
+		const protocolErrors: unknown[] = [];
+		runtime.issues.subscribe((msg) => {
+			if (msg[0] === "DATA") issues.push(msg[1] as DataIssue);
+			if (msg[0] === "ERROR") protocolErrors.push(msg[1]);
+		});
+		runtime.runStatus.subscribe((msg) => {
+			if (msg[0] === "DATA") runStatus.push(msg[1] as ToolProviderAdapterRunStatus);
+			if (msg[0] === "ERROR") protocolErrors.push(msg[1]);
+		});
+		runtime.runtimeStatus.subscribe(
+			(msg) => msg[0] === "DATA" && runtimeStatus.push(msg[1] as ToolProviderAdapterRuntimeStatus),
+		);
+		runtime.audit.subscribe((msg) => msg[0] === "DATA" && audit.push(msg[1]));
+
+		inputs.down([["DATA", ready]]);
+		runRequests.down([
+			[
+				"DATA",
+				{
+					...requestToolProviderAdapterRun(ready, { runId: "stale-run", attempt: 2 }),
+					requestId: "other-request",
+				},
+			],
+			[
+				"DATA",
+				{
+					...requestToolProviderAdapterRun(ready, { runId: "missing-run", attempt: 1 }),
+					adapterInputId: "missing-adapter-input",
+				},
+			],
+			[
+				"DATA",
+				{
+					kind: "tool-provider-adapter-run-requested",
+					adapterInputId: ready.adapterInputId,
+					requestId: ready.requestId,
+				} as unknown as ToolProviderAdapterRunRequested,
+			],
+			[
+				"DATA",
+				{
+					...requestToolProviderAdapterRun(ready, { runId: "raw-request", attempt: 3 }),
+					metadata: { rawResponse: "RAW_RUN_REQUEST_SHOULD_NOT_PROJECT" },
+					sourceRefs: [
+						{
+							kind: "provider-raw",
+							id: "raw-explicit-request",
+							metadata: { stdout: "RAW_RUN_REQUEST_SOURCE_REF_SHOULD_NOT_PROJECT" },
+						},
+					],
+				},
+			],
+		]);
+
+		expect(calls).toEqual([]);
+		expect(issues).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({ code: "tool-provider-adapter-run-request-stale-request" }),
+				expect.objectContaining({ code: "tool-provider-adapter-run-request-missing-input" }),
+				expect.objectContaining({ code: "tool-provider-adapter-run-request-invalid-shape" }),
+				expect.objectContaining({
+					code: "tool-provider-adapter-run-request-forbidden-runtime-material",
+				}),
+			]),
+		);
+		expect(runStatus).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({ status: "mismatched-request" }),
+				expect.objectContaining({ status: "missing-input" }),
+			]),
+		);
+		expect(runStatus.filter((status) => status.runId === "missing-run")).toEqual(
+			expect.arrayContaining([expect.objectContaining({ status: "missing-input" })]),
+		);
+		expect(runStatus.filter((status) => status.runId === "missing-run")).not.toEqual(
+			expect.arrayContaining([expect.objectContaining({ status: "retention-gap" })]),
+		);
+		expect(issues).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({
+					code: "tool-provider-adapter-run-request-missing-input",
+					subjectId: "missing-adapter-input",
+				}),
+			]),
+		);
+		expect(runtimeStatus).not.toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({
+					status: "retention-gap",
+					adapterInputId: "missing-adapter-input",
+				}),
+			]),
+		);
+		expect(
+			runStatus.find((status) => status.runId === `${ready.adapterInputId}:invalid-run`),
+		).toMatchObject({
+			adapterInputId: ready.adapterInputId,
+			requestId: ready.requestId,
+			operationId: "<invalid-operation>",
+			status: "mismatched-request",
+			attempt: 1,
+			sourceRefs: [
+				{ kind: "tool-provider-adapter-run", id: `${ready.adapterInputId}:invalid-run` },
+			],
+		});
+		expect(protocolErrors).toEqual([]);
+		expect(JSON.stringify({ audit, issues, runStatus })).not.toMatch(
+			/RAW_RUN_REQUEST_SHOULD_NOT_PROJECT|RAW_RUN_REQUEST_SOURCE_REF_SHOULD_NOT_PROJECT|rawResponse|stdout/,
+		);
+	});
+
+	it("emits DataIssue when ready inputs have no visible run request source", () => {
+		const g = graph();
+		const inputs = g.node<ToolProviderAdapterInput>([], null, {
+			name: "runtime-missing-run-request-inputs",
+		});
+		const ready = readyToolProviderAdapterInput(
+			"runtime-missing-run-provider",
+			"runtime-missing-run-req",
+		);
+		const runtime = attachToolProviderAdapterRuntime(g, {
+			inputs,
+			autoRunReadyInputs: false,
+			bindings: [
+				{
+					providerId: "runtime-missing-run-provider",
+					run() {
+						return { kind: "result", result: { kind: "tool-output" } };
+					},
+				},
+			],
+		});
+		const issues: DataIssue[] = [];
+		const runStatus: ToolProviderAdapterRunStatus[] = [];
+		const protocolErrors: unknown[] = [];
+		runtime.issues.subscribe((msg) => {
+			if (msg[0] === "DATA") issues.push(msg[1] as DataIssue);
+			if (msg[0] === "ERROR") protocolErrors.push(msg[1]);
+		});
+		runtime.runStatus.subscribe((msg) => {
+			if (msg[0] === "DATA") runStatus.push(msg[1] as ToolProviderAdapterRunStatus);
+			if (msg[0] === "ERROR") protocolErrors.push(msg[1]);
+		});
+
+		inputs.down([["DATA", ready]]);
+
+		expect(issues).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({ code: "tool-provider-adapter-run-request-missing" }),
+			]),
+		);
+		expect(runStatus).toEqual(
+			expect.arrayContaining([expect.objectContaining({ status: "missing-request" })]),
+		);
+		expect(runStatus).not.toEqual(
+			expect.arrayContaining([expect.objectContaining({ status: "retention-gap" })]),
+		);
+		expect(protocolErrors).toEqual([]);
+	});
+
+	it("copies adapter failure errors into status issues for auditability", () => {
+		const g = graph();
+		const inputs = g.node<ToolProviderAdapterInput>([], null, { name: "runtime-failure-inputs" });
+		const ready = readyToolProviderAdapterInput("runtime-failure-provider", "runtime-failure-req");
+		const runtime = attachToolProviderAdapterRuntime(g, {
+			inputs,
+			bindings: [
+				{
+					providerId: "runtime-failure-provider",
+					run() {
+						return {
+							kind: "failure",
+							error: {
+								kind: "issue",
+								code: "tool-provider-adapter-runtime-failed",
+								message: "Adapter failed.",
+								subjectId: "runtime-failure-req",
+							},
+							retryable: false,
+						};
+					},
+				},
+			],
+		});
+		const status: AgentRequestStatusChanged[] = [];
+		const issues: DataIssue[] = [];
+		runtime.status.subscribe(
+			(msg) => msg[0] === "DATA" && status.push(msg[1] as AgentRequestStatusChanged),
+		);
+		runtime.issues.subscribe((msg) => msg[0] === "DATA" && issues.push(msg[1] as DataIssue));
+
+		inputs.down([["DATA", ready]]);
+
+		expect(status.at(-1)).toMatchObject({
+			status: "failed",
+			issues: [expect.objectContaining({ code: "tool-provider-adapter-runtime-failed" })],
+		});
+		expect(issues).toEqual([
+			expect.objectContaining({ code: "tool-provider-adapter-runtime-failed" }),
+		]);
+	});
+
+	it("builds provider-neutral ExecutorOutcome facts from adapter run results", () => {
+		const ready = readyToolProviderAdapterInput("build-runtime-provider", "build-runtime-req");
+		const mutableValue = { ok: true, nested: { note: "safe" } };
+		const outcome = buildToolProviderExecutorOutcome(
+			ready,
+			{
+				kind: "timeout",
+				timeoutMs: 10,
+				retryable: true,
+				usage: { latencyMs: 10 },
+			},
+			{ attempt: 2, occurredAtMs: 456 },
+		);
+
+		expect(outcome).toMatchObject({
+			kind: "timeout",
+			requestId: "build-runtime-req",
+			operationId: "build-runtime-req-op",
+			routeId: "build-runtime-req-route",
+			executorId: ready.executorId,
+			profileId: ready.profileId,
+			attempt: 2,
+			timeoutMs: 10,
+			retryable: true,
+			usage: { latencyMs: 10 },
+			occurredAtMs: 456,
+		});
+		expect(outcome.evidenceRefs).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({
+					kind: "tool-provider-adapter-input",
+					id: ready.adapterInputId,
+				}),
+				expect.objectContaining({ kind: "tool-provider-policy-resolution" }),
+			]),
+		);
+		const cloned = buildToolProviderExecutorOutcome(ready, {
+			kind: "result",
+			result: { kind: "tool-output", value: mutableValue },
+		});
+		mutableValue.nested = { note: "RAW_MUTATED_PROVIDER_MATERIAL_SHOULD_NOT_PROJECT" };
+		(mutableValue as Record<string, unknown>).rawResponse =
+			"RAW_MUTATED_PROVIDER_MATERIAL_SHOULD_NOT_PROJECT";
+		expect(JSON.stringify(cloned)).not.toMatch(/RAW_MUTATED_PROVIDER_MATERIAL|rawResponse/);
+		expect(Object.isFrozen((cloned as { result: { value: unknown } }).result.value)).toBe(true);
+	});
+
+	it("projects D360 policy resolution issues as DATA facts", () => {
+		const g = graph();
+		const requestFacts = g.node<AgentRequestFact>([], null, { name: "requests" });
+		const routes = g.node<ExecutorRoute>([], null, { name: "routes" });
+		const catalogs = g.node<ToolProviderCatalog>([], null, { name: "catalogs" });
+		const projector = toolProviderPolicyResolutionProjector(g, {
+			requestFacts,
+			executorRoutes: [routes],
+			toolProviderCatalogs: [catalogs],
+		});
+		const resolutions: ToolProviderPolicyResolution[] = [];
+		const issues: unknown[] = [];
+		const audit: unknown[] = [];
+		projector.resolutions.subscribe(
+			(msg) => msg[0] === "DATA" && resolutions.push(msg[1] as ToolProviderPolicyResolution),
+		);
+		projector.issues.subscribe((msg) => msg[0] === "DATA" && issues.push(msg[1]));
+		projector.audit.subscribe((msg) => msg[0] === "DATA" && audit.push(msg[1]));
+
+		const request = toolRequest("policy-req", "policy-op", "file.read", "read");
+		const catalog: ToolProviderCatalog = {
+			kind: "tool-provider-catalog",
+			providerId: "bare",
+			providerKind: "local-builtin",
+			status: "ready",
+			profiles: [
+				{
+					profileId: "bare-profile",
+					executorId: "bare-exec",
+					kind: "tool",
+					acceptedInputKinds: ["tool-call"],
+				},
+			],
+			tools: [
+				{
+					kind: "tool-catalog-entry",
+					providerId: "bare",
+					toolName: "file.read",
+					operation: "read",
+					inputKind: "tool-call",
+					profileId: "bare-profile",
+					executorId: "bare-exec",
+				},
+			],
+			policies: [],
+			policyRefs: [],
+		};
+		requestFacts.down([["DATA", request]]);
+		catalogs.down([["DATA", catalog]]);
+		expect(resolutions.at(-1)).toMatchObject({
+			status: "pending-route",
+			requestId: "policy-req",
+		});
+		routes.down([
+			[
+				"DATA",
+				{
+					kind: "executor-route",
+					routeId: "policy-route",
+					requestId: "policy-req",
+					operationId: "policy-op",
+					executorId: "bare-exec",
+					profileId: "bare-profile",
+					inputKind: "tool-call",
+				},
+			],
+		]);
+
+		expect(resolutions.at(-1)).toMatchObject({
+			status: "missing-policy",
+			requestId: "policy-req",
+			routeId: "policy-route",
+			providerId: "bare",
+		});
+		expect(issues).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({
+					kind: "issue",
+					code: "tool-provider-policy-missing-policy-ref",
+				}),
+			]),
+		);
+		expect(audit.at(-1)).toMatchObject({
+			kind: "tool-provider-policy-resolution",
+			subjectId: "policy-req",
+		});
+	});
+});
diff --git a/packages/ts/src/__tests__/agent-runtime.part-07.test.ts b/packages/ts/src/__tests__/agent-runtime.part-07.test.ts
new file mode 100644
index 00000000..7b255806
--- /dev/null
+++ b/packages/ts/src/__tests__/agent-runtime.part-07.test.ts
@@ -0,0 +1,903 @@
+import { describe, expect, it } from "vitest";
+import { graph } from "../graph/graph.js";
+import {
+	type AgentRequestFact,
+	type AgentRequestIssued,
+	buildToolProviderAdapterInputs,
+	type ExecutorRoute,
+	localBuiltinToolProviderCatalog,
+	resolveToolProviderExecutionPolicies,
+	type ToolProviderAdapterInput,
+	type ToolProviderCatalog,
+	type ToolProviderPolicyResolution,
+	toolProviderAdapterInputProjector,
+	toolProviderPolicyResolutionProjector,
+	validateToolProviderExecutionPolicy,
+} from "../orchestration/agent-runtime.js";
+import type {
+	WorkItemDomainActionAdmissionDecision,
+	WorkItemDomainActionProposal,
+	WorkItemSeed,
+} from "../orchestration/work-item-runtime.js";
+
+function _issued(
+	requestId: string,
+	operationId: string,
+	requestKind: AgentRequestIssued["requestKind"],
+	inputKind?: string,
+): AgentRequestIssued {
+	return {
+		kind: "issued",
+		requestId,
+		operationId,
+		effectRunId: "run-1",
+		requestKind,
+		required: true,
+		input:
+			inputKind === undefined
+				? undefined
+				: { inputId: `${requestId}:input`, inputKind, dataMode: "summary", summary: inputKind },
+	};
+}
+
+function toolRequest(
+	requestId: string,
+	operationId: string,
+	toolName: string,
+	operation?: string,
+): AgentRequestIssued {
+	return {
+		kind: "issued",
+		requestId,
+		operationId,
+		effectRunId: "run-1",
+		requestKind: "executor",
+		required: true,
+		input: {
+			inputId: `${requestId}:input`,
+			inputKind: "tool-call",
+			dataMode: "inline",
+			value: {
+				kind: "tool-call",
+				toolName,
+				operation,
+				arguments: { path: "README.md" },
+			},
+		},
+	};
+}
+
+const forbiddenRetentionPayloadPattern =
+	/SCORER_SECRET|SCORER_RAW|rawResponse|stdout|stderr|stack|apiKey|password|arguments|providerClient|oauthState|subprocessHandle|transport|sdkObject/i;
+
+const retentionScorerEntryKeys: Record<string, readonly string[]> = {
+	adapterInputs: [
+		"adapterInputId",
+		"executorId",
+		"insertedAtMs",
+		"key",
+		"operationId",
+		"profileId",
+		"providerId",
+		"requestId",
+		"routeId",
+		"sequence",
+		"status",
+	],
+	runRequests: [
+		"adapterInputId",
+		"attempt",
+		"executorId",
+		"key",
+		"operationId",
+		"profileId",
+		"providerId",
+		"reason",
+		"requestId",
+		"requestedAtMs",
+		"routeId",
+		"runId",
+		"sequence",
+	],
+	executions: [
+		"adapterInputId",
+		"attempt",
+		"executorId",
+		"key",
+		"occurredAtMs",
+		"operationId",
+		"outcomeId",
+		"profileId",
+		"providerId",
+		"reason",
+		"requestId",
+		"routeId",
+		"runId",
+		"sequence",
+		"status",
+	],
+	runStatuses: [
+		"adapterInputId",
+		"attempt",
+		"issueCode",
+		"key",
+		"occurredAtMs",
+		"operationId",
+		"outcomeId",
+		"requestId",
+		"runId",
+		"sequence",
+		"status",
+	],
+	runIssues: [
+		"adapterInputId",
+		"attempt",
+		"issueCode",
+		"key",
+		"occurredAtMs",
+		"operationId",
+		"requestId",
+		"runId",
+		"sequence",
+		"severity",
+		"subjectId",
+	],
+	retentionEvidence: [
+		"adapterInputId",
+		"attemptHighWater",
+		"evidenceKind",
+		"key",
+		"occurredAtMs",
+		"reason",
+		"sequence",
+	],
+};
+
+function _expectRetentionScorerEntryPayloadSafe(index: string, entry: unknown): void {
+	expect(entry).toBeTypeOf("object");
+	expect(Array.isArray(entry)).toBe(false);
+	const record = entry as Record<string, unknown>;
+	const allowed = retentionScorerEntryKeys[index];
+	expect(allowed, `unknown retention scorer index ${index}`).toBeDefined();
+	for (const [key, value] of Object.entries(record)) {
+		expect(allowed).toContain(key);
+		expect(value === undefined || typeof value === "string" || typeof value === "number").toBe(
+			true,
+		);
+		if (key === "key") expect(value).toEqual(expect.stringMatching(/^key:[a-z0-9]+:\d+$/));
+	}
+	expectNoForbiddenRetentionPayload(record);
+}
+
+function expectNoForbiddenRetentionPayload(value: unknown): void {
+	expect(JSON.stringify(value)).not.toMatch(forbiddenRetentionPayloadPattern);
+}
+
+function _readyToolProviderAdapterInput(
+	providerId: string,
+	requestId: string,
+): ToolProviderAdapterInput {
+	const catalog = localBuiltinToolProviderCatalog({ providerId });
+	const profile = catalog.profiles[0];
+	if (profile === undefined) throw new Error("expected profile");
+	const request = toolRequest(requestId, `${requestId}-op`, "file.read", "read");
+	const route: ExecutorRoute = {
+		kind: "executor-route",
+		routeId: `${requestId}-route`,
+		requestId: request.requestId,
+		operationId: request.operationId,
+		executorId: profile.executorId,
+		profileId: profile.profileId,
+		inputKind: "tool-call",
+	};
+	const resolutions = resolveToolProviderExecutionPolicies({
+		request,
+		routes: [route],
+		catalogs: [catalog],
+	});
+	const input = buildToolProviderAdapterInputs({
+		requests: [request],
+		routes: [route],
+		catalogs: [catalog],
+		resolutions,
+	})[0];
+	if (input === undefined || input.status !== "ready") throw new Error("expected ready input");
+	return input;
+}
+
+function _workItemSeed(workItemId: string): WorkItemSeed {
+	return {
+		kind: "work-item",
+		workItemId,
+		sourceRefs: [{ kind: "work-item", id: workItemId }],
+		workItemKind: "issue",
+		lifecycleStatus: "open",
+	};
+}
+
+function _workItemActionProposal(
+	proposalId: string,
+	actionKind: string,
+	opts: Partial<WorkItemDomainActionProposal> = {},
+): WorkItemDomainActionProposal {
+	return {
+		kind: "work-item-domain-action-proposal",
+		proposalId,
+		workItemId: opts.workItemId ?? "wi-1",
+		actionKind,
+		effectRunId: opts.effectRunId ?? "run-1",
+		effectRunResultId: opts.effectRunResultId ?? "run-1:result",
+		evidenceId: opts.evidenceId ?? "wi-1:run-1:run-1:result",
+		policyId: opts.policyId ?? "policy-propose",
+		sourceRefs: opts.sourceRefs,
+		metadata: opts.metadata,
+	};
+}
+
+function _workItemAdmissionDecision(
+	decisionId: string,
+	admissionId: string,
+	proposalId: string,
+	outcome: WorkItemDomainActionAdmissionDecision["outcome"],
+	opts: Partial<WorkItemDomainActionAdmissionDecision> = {},
+): WorkItemDomainActionAdmissionDecision {
+	return {
+		kind: "work-item-domain-action-admission-decision",
+		decisionId,
+		admissionId,
+		proposalId,
+		outcome,
+		policyId: opts.policyId,
+		reason: opts.reason,
+		targetProposalId: opts.targetProposalId,
+		targetAdmissionId: opts.targetAdmissionId,
+		sourceRefs: opts.sourceRefs,
+		decidedAtMs: opts.decidedAtMs,
+		metadata: opts.metadata,
+	};
+}
+
+describe("CSP-8 experimental agent runtime kernel (D236) — part 7", () => {
+	it("projects adapter inputs, issues, and audit without executing real tool providers", () => {
+		const g = graph();
+		const requestFacts = g.node<AgentRequestFact>([], null, { name: "requests" });
+		const routes = g.node<ExecutorRoute>([], null, { name: "routes" });
+		const catalogs = g.node<ToolProviderCatalog>([], null, { name: "catalogs" });
+		const resolutions = toolProviderPolicyResolutionProjector(g, {
+			requestFacts,
+			executorRoutes: [routes],
+			toolProviderCatalogs: [catalogs],
+		});
+		const adapterInputs = toolProviderAdapterInputProjector(g, {
+			requestFacts,
+			executorRoutes: [routes],
+			toolProviderCatalogs: [catalogs],
+			policyResolutions: [resolutions.resolutions],
+		});
+		const inputs: ToolProviderAdapterInput[] = [];
+		const issues: unknown[] = [];
+		const audit: unknown[] = [];
+		const protocolErrors: unknown[] = [];
+		adapterInputs.inputs.subscribe((msg) => {
+			if (msg[0] === "DATA") inputs.push(msg[1] as ToolProviderAdapterInput);
+			if (msg[0] === "ERROR") protocolErrors.push(msg[1]);
+		});
+		adapterInputs.issues.subscribe((msg) => {
+			if (msg[0] === "DATA") issues.push(msg[1]);
+			if (msg[0] === "ERROR") protocolErrors.push(msg[1]);
+		});
+		adapterInputs.audit.subscribe((msg) => msg[0] === "DATA" && audit.push(msg[1]));
+		const catalog = localBuiltinToolProviderCatalog({ providerId: "adapter-projector" });
+		const profile = catalog.profiles[0];
+		if (profile === undefined) throw new Error("expected profile");
+		const request = toolRequest("adapter-proj-req", "adapter-proj-op", "file.read", "read");
+
+		requestFacts.down([["DATA", request]]);
+		catalogs.down([["DATA", catalog]]);
+		routes.down([
+			[
+				"DATA",
+				{
+					kind: "executor-route",
+					routeId: "adapter-proj-route",
+					requestId: "adapter-proj-req",
+					operationId: "adapter-proj-op",
+					executorId: profile.executorId,
+					profileId: profile.profileId,
+					inputKind: "tool-call",
+				},
+			],
+		]);
+
+		expect(inputs).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({
+					status: "ready",
+					requestId: "adapter-proj-req",
+					routeId: "adapter-proj-route",
+					providerId: "adapter-projector",
+					toolName: "file.read",
+					policies: catalog.policies,
+				}),
+			]),
+		);
+		expect(audit.at(-1)).toMatchObject({
+			kind: "tool-provider-adapter-input",
+			subjectId: "adapter-proj-req",
+		});
+		expect(protocolErrors).toEqual([]);
+		expect(JSON.stringify({ inputs, issues, audit })).not.toMatch(
+			/apiKey|secret|client|transport|subprocess|sdk|oauth|credential/i,
+		);
+
+		const bareCatalog: ToolProviderCatalog = {
+			kind: "tool-provider-catalog",
+			providerId: "adapter-bare",
+			providerKind: "local-builtin",
+			status: "ready",
+			profiles: [
+				{
+					profileId: "adapter-bare-profile",
+					executorId: "adapter-bare-exec",
+					kind: "tool",
+					acceptedInputKinds: ["tool-call"],
+				},
+			],
+			tools: [
+				{
+					kind: "tool-catalog-entry",
+					providerId: "adapter-bare",
+					toolName: "file.read",
+					operation: "read",
+					inputKind: "tool-call",
+					profileId: "adapter-bare-profile",
+					executorId: "adapter-bare-exec",
+				},
+			],
+			policies: [],
+			policyRefs: [],
+		};
+		const missingPolicyRequest = toolRequest(
+			"adapter-issue-req",
+			"adapter-issue-op",
+			"file.read",
+			"read",
+		);
+		requestFacts.down([["DATA", missingPolicyRequest]]);
+		catalogs.down([["DATA", bareCatalog]]);
+		routes.down([
+			[
+				"DATA",
+				{
+					kind: "executor-route",
+					routeId: "adapter-issue-route",
+					requestId: "adapter-issue-req",
+					operationId: "adapter-issue-op",
+					executorId: "adapter-bare-exec",
+					profileId: "adapter-bare-profile",
+					inputKind: "tool-call",
+				},
+			],
+		]);
+
+		expect(inputs).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({
+					status: "missing-policy",
+					requestId: "adapter-issue-req",
+					routeId: "adapter-issue-route",
+					input: undefined,
+					toolCall: undefined,
+					policies: undefined,
+				}),
+			]),
+		);
+		expect(issues).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({ code: "tool-provider-policy-missing-policy-ref" }),
+			]),
+		);
+		expect(protocolErrors).toEqual([]);
+	});
+
+	it("blocks runtime-private keys from adapter inputs as DataIssue material", () => {
+		const catalog = localBuiltinToolProviderCatalog({ providerId: "adapter-scan" });
+		const profile = catalog.profiles[0];
+		if (profile === undefined) throw new Error("expected profile");
+		const request: AgentRequestIssued = {
+			...toolRequest("adapter-scan-req", "adapter-scan-op", "file.read", "read"),
+			input: {
+				inputId: "adapter-scan-input",
+				inputKind: "tool-call",
+				dataMode: "inline",
+				value: {
+					kind: "tool-call",
+					toolName: "file.read",
+					operation: "read",
+					arguments: {
+						path: "README.md",
+						accessToken: "do-not-project",
+						rawResponse: "RAW_REQUEST_ARGUMENTS",
+					},
+				},
+			},
+		};
+		const route: ExecutorRoute = {
+			kind: "executor-route",
+			routeId: "adapter-scan-route",
+			requestId: request.requestId,
+			operationId: request.operationId,
+			executorId: profile.executorId,
+			profileId: profile.profileId,
+			inputKind: "tool-call",
+		};
+		const resolutions = resolveToolProviderExecutionPolicies({
+			request,
+			routes: [route],
+			catalogs: [catalog],
+		});
+		const inputs = buildToolProviderAdapterInputs({
+			requests: [request],
+			routes: [route],
+			catalogs: [catalog],
+			resolutions,
+		});
+
+		expect(inputs[0]).toMatchObject({
+			status: "invalid-policy",
+			input: undefined,
+			toolCall: undefined,
+			route: undefined,
+			tool: undefined,
+			policies: undefined,
+			issues: expect.arrayContaining([
+				expect.objectContaining({
+					code: "tool-provider-adapter-input-forbidden-runtime-material",
+					details: expect.objectContaining({ area: "request-input" }),
+				}),
+			]),
+		});
+		expect(JSON.stringify(inputs)).not.toMatch(/do-not-project|RAW_REQUEST_ARGUMENTS|rawResponse/);
+
+		const routeOnlyRequest = toolRequest(
+			"adapter-route-scan-req",
+			"adapter-route-scan-op",
+			"file.read",
+			"read",
+		);
+		const routeOnlyRoute: ExecutorRoute = {
+			kind: "executor-route",
+			routeId: "adapter-route-scan-route",
+			requestId: routeOnlyRequest.requestId,
+			operationId: routeOnlyRequest.operationId,
+			executorId: profile.executorId,
+			profileId: profile.profileId,
+			inputKind: "tool-call",
+			metadata: { stdout: "RAW_ROUTE_METADATA" },
+		};
+		const routeOnlyResolutions = resolveToolProviderExecutionPolicies({
+			request: routeOnlyRequest,
+			routes: [routeOnlyRoute],
+			catalogs: [catalog],
+		});
+		const routeOnlyInputs = buildToolProviderAdapterInputs({
+			requests: [routeOnlyRequest],
+			routes: [routeOnlyRoute],
+			catalogs: [catalog],
+			resolutions: routeOnlyResolutions,
+		});
+		expect(routeOnlyInputs[0]).toMatchObject({
+			status: "invalid-policy",
+			issues: expect.arrayContaining([
+				expect.objectContaining({
+					code: "tool-provider-adapter-input-forbidden-runtime-material",
+					details: expect.objectContaining({ area: "route-metadata" }),
+				}),
+			]),
+		});
+		expect(JSON.stringify(routeOnlyInputs)).not.toMatch(/RAW_ROUTE_METADATA|stdout/);
+	});
+
+	it("rejects stale adapter-input route identities and unavailable catalogs", () => {
+		const readyCatalog = localBuiltinToolProviderCatalog({ providerId: "adapter-stale" });
+		const profile = readyCatalog.profiles[0];
+		if (profile === undefined) throw new Error("expected profile");
+		const request = toolRequest("adapter-stale-req", "adapter-stale-op", "file.read", "read");
+		const staleRoute: ExecutorRoute = {
+			kind: "executor-route",
+			routeId: "adapter-stale-route",
+			requestId: request.requestId,
+			operationId: "other-op",
+			executorId: profile.executorId,
+			profileId: profile.profileId,
+			inputKind: "tool-call",
+		};
+		const forgedResolution: ToolProviderPolicyResolution = {
+			kind: "tool-provider-policy-resolution",
+			resolutionId: "adapter-stale-resolution",
+			status: "resolved",
+			requestId: request.requestId,
+			operationId: request.operationId,
+			routeId: staleRoute.routeId,
+			providerId: readyCatalog.providerId,
+			executorId: profile.executorId,
+			profileId: profile.profileId,
+			toolName: "file.read",
+			operation: "read",
+			policyRefs: readyCatalog.tools.find((tool) => tool.toolName === "file.read")?.policyRefs,
+		};
+		const staleInputs = buildToolProviderAdapterInputs({
+			requests: [request],
+			routes: [staleRoute],
+			catalogs: [readyCatalog],
+			resolutions: [forgedResolution],
+		});
+
+		expect(staleInputs[0]).toMatchObject({
+			status: "invalid-policy",
+			input: undefined,
+			route: undefined,
+			issues: expect.arrayContaining([
+				expect.objectContaining({
+					code: "tool-provider-adapter-input-stale-route-operation",
+				}),
+			]),
+		});
+
+		const unavailableCatalog: ToolProviderCatalog = {
+			...readyCatalog,
+			status: "unavailable",
+			issues: [
+				{
+					kind: "issue",
+					code: "provider-down",
+					message: "Provider is unavailable",
+					severity: "error",
+					details: { password: "do-not-project" },
+				},
+			],
+		};
+		const route: ExecutorRoute = {
+			...staleRoute,
+			operationId: request.operationId,
+		};
+		const unavailableInputs = buildToolProviderAdapterInputs({
+			requests: [request],
+			routes: [route],
+			catalogs: [unavailableCatalog],
+			resolutions: [{ ...forgedResolution, resolutionId: "adapter-unavailable-resolution" }],
+		});
+
+		expect(unavailableInputs[0]).toMatchObject({
+			status: "invalid-policy",
+			input: undefined,
+			policies: undefined,
+			issues: expect.arrayContaining([
+				expect.objectContaining({
+					code: "tool-provider-adapter-input-catalog-unavailable",
+				}),
+				expect.objectContaining({
+					code: "provider-down",
+					details: { redacted: true, reason: "forbidden-runtime-material" },
+				}),
+			]),
+		});
+		expect(JSON.stringify(unavailableInputs)).not.toMatch(/do-not-project/);
+	});
+
+	it("does not trust resolved adapter-input resolutions without D360 policy material", () => {
+		const request = toolRequest("adapter-forged-req", "adapter-forged-op", "file.read", "read");
+		const route: ExecutorRoute = {
+			kind: "executor-route",
+			routeId: "adapter-forged-route",
+			requestId: request.requestId,
+			operationId: request.operationId,
+			executorId: "adapter-forged-exec",
+			profileId: "adapter-forged-profile",
+			inputKind: "tool-call",
+		};
+		const catalog: ToolProviderCatalog = {
+			kind: "tool-provider-catalog",
+			providerId: "adapter-forged",
+			providerKind: "local-builtin",
+			status: "ready",
+			profiles: [
+				{
+					profileId: "adapter-forged-profile",
+					executorId: "adapter-forged-exec",
+					kind: "tool",
+					acceptedInputKinds: ["tool-call"],
+				},
+			],
+			tools: [
+				{
+					kind: "tool-catalog-entry",
+					providerId: "adapter-forged",
+					toolName: "file.read",
+					operation: "read",
+					inputKind: "tool-call",
+					profileId: "adapter-forged-profile",
+					executorId: "adapter-forged-exec",
+				},
+			],
+			policies: [],
+		};
+		const forgedResolved: ToolProviderPolicyResolution = {
+			kind: "tool-provider-policy-resolution",
+			resolutionId: "adapter-forged-resolution",
+			status: "resolved",
+			requestId: request.requestId,
+			operationId: request.operationId,
+			routeId: route.routeId,
+			providerId: catalog.providerId,
+			executorId: route.executorId,
+			profileId: route.profileId,
+			toolName: "file.read",
+			operation: "read",
+			policyRefs: [],
+		};
+		const missingMaterial: ToolProviderPolicyResolution = {
+			...forgedResolved,
+			resolutionId: "adapter-forged-missing-material",
+			policyRefs: [{ kind: "tool-provider-execution-policy", id: "missing" }],
+		};
+
+		const inputs = buildToolProviderAdapterInputs({
+			requests: [request],
+			routes: [route],
+			catalogs: [catalog],
+			resolutions: [forgedResolved, missingMaterial],
+		});
+
+		expect(inputs[0]).toMatchObject({
+			status: "missing-policy",
+			input: undefined,
+			policies: undefined,
+			issues: expect.arrayContaining([
+				expect.objectContaining({ code: "tool-provider-adapter-input-missing-policy-ref" }),
+			]),
+		});
+		expect(inputs[1]).toMatchObject({
+			status: "invalid-policy",
+			input: undefined,
+			policies: undefined,
+			issues: expect.arrayContaining([
+				expect.objectContaining({
+					code: "tool-provider-adapter-input-policy-ref-missing-material",
+				}),
+			]),
+		});
+	});
+
+	it("sanitizes incoming resolution issues before adapter-input projection", () => {
+		const request = toolRequest(
+			"adapter-issue-sanitize-req",
+			"adapter-issue-sanitize-op",
+			"file.read",
+			"read",
+		);
+		const resolution: ToolProviderPolicyResolution = {
+			kind: "tool-provider-policy-resolution",
+			resolutionId: "adapter-issue-sanitize-resolution",
+			status: "invalid-policy",
+			requestId: request.requestId,
+			operationId: request.operationId,
+			issues: [
+				{
+					kind: "issue",
+					code: "raw-provider-issue",
+					message: "Provider issue",
+					severity: "error",
+					details: { authorization: "do-not-project" },
+				},
+			],
+		};
+
+		const inputs = buildToolProviderAdapterInputs({
+			requests: [request],
+			resolutions: [resolution],
+		});
+
+		expect(inputs[0]?.issues).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({
+					code: "raw-provider-issue",
+					details: { redacted: true, reason: "forbidden-runtime-material" },
+				}),
+			]),
+		);
+		expect(JSON.stringify(inputs)).not.toMatch(/do-not-project/);
+	});
+
+	it("emits updated adapter input material when same policy refs change", () => {
+		const g = graph();
+		const requestFacts = g.node<AgentRequestFact>([], null, { name: "requests" });
+		const routes = g.node<ExecutorRoute>([], null, { name: "routes" });
+		const catalogs = g.node<ToolProviderCatalog>([], null, { name: "catalogs" });
+		const resolutions = toolProviderPolicyResolutionProjector(g, {
+			requestFacts,
+			executorRoutes: [routes],
+			toolProviderCatalogs: [catalogs],
+		});
+		const adapterInputs = toolProviderAdapterInputProjector(g, {
+			requestFacts,
+			executorRoutes: [routes],
+			toolProviderCatalogs: [catalogs],
+			policyResolutions: [resolutions.resolutions],
+		});
+		const inputs: ToolProviderAdapterInput[] = [];
+		adapterInputs.inputs.subscribe(
+			(msg) => msg[0] === "DATA" && inputs.push(msg[1] as ToolProviderAdapterInput),
+		);
+		const catalogV1 = localBuiltinToolProviderCatalog({
+			providerId: "adapter-revision",
+			policyOverrides: { timeout: { timeoutMs: 1000 } },
+		});
+		const profile = catalogV1.profiles[0];
+		if (profile === undefined) throw new Error("expected profile");
+		const request = toolRequest("adapter-revision-req", "adapter-revision-op", "file.read", "read");
+
+		requestFacts.down([["DATA", request]]);
+		catalogs.down([["DATA", catalogV1]]);
+		routes.down([
+			[
+				"DATA",
+				{
+					kind: "executor-route",
+					routeId: "adapter-revision-route",
+					requestId: request.requestId,
+					operationId: request.operationId,
+					executorId: profile.executorId,
+					profileId: profile.profileId,
+					inputKind: "tool-call",
+				},
+			],
+		]);
+		const catalogV2 = localBuiltinToolProviderCatalog({
+			providerId: "adapter-revision",
+			policyOverrides: { timeout: { timeoutMs: 2000 } },
+		});
+		catalogs.down([["DATA", catalogV2]]);
+
+		expect(
+			inputs
+				.filter((input) => input.status === "ready" && input.requestId === "adapter-revision-req")
+				.map((input) => input.policies?.[0]?.timeout?.timeoutMs),
+		).toEqual([1000, 2000]);
+	});
+
+	it("scrubs returned refs before marking adapter input ready", () => {
+		const catalog = localBuiltinToolProviderCatalog({ providerId: "adapter-route-scan" });
+		const profile = catalog.profiles[0];
+		if (profile === undefined) throw new Error("expected profile");
+		const request = toolRequest(
+			"adapter-route-scan-req",
+			"adapter-route-scan-op",
+			"file.read",
+			"read",
+		);
+		const route: ExecutorRoute = {
+			kind: "executor-route",
+			routeId: "adapter-route-scan-route",
+			requestId: request.requestId,
+			operationId: request.operationId,
+			executorId: profile.executorId,
+			profileId: profile.profileId,
+			inputKind: "tool-call",
+			evidenceRefs: [{ kind: "runtime", id: "route", metadata: { client: "do-not-project" } }],
+		};
+		const resolutions = resolveToolProviderExecutionPolicies({
+			request,
+			routes: [route],
+			catalogs: [catalog],
+		}).map((resolution) => ({
+			...resolution,
+			sourceRefs: [
+				...(resolution.sourceRefs ?? []),
+				{ kind: "runtime", id: "resolution", metadata: { oauth: "do-not-project" } },
+			],
+			policyRefs: (resolution.policyRefs ?? []).map((policyRef) => ({
+				...policyRef,
+				metadata: { secret: "do-not-project" },
+			})),
+		}));
+		const inputs = buildToolProviderAdapterInputs({
+			requests: [request],
+			routes: [route],
+			catalogs: [catalog],
+			resolutions,
+		});
+
+		expect(inputs[0]).toMatchObject({
+			status: "invalid-policy",
+			route: undefined,
+			input: undefined,
+			issues: expect.arrayContaining([
+				expect.objectContaining({
+					code: "tool-provider-adapter-input-forbidden-runtime-material",
+				}),
+			]),
+		});
+		expect(JSON.stringify(inputs)).not.toMatch(/do-not-project/);
+	});
+
+	it("validates malformed D360 tool provider policies as DataIssue facts", () => {
+		const issues = validateToolProviderExecutionPolicy({
+			kind: "tool-provider-execution-policy",
+			policyId: "",
+			providerId: "",
+			sizeCapacity: {
+				limits: [{ unit: "bytes", softLimit: 20, hardLimit: 10 }, { softLimit: Number.NaN }],
+			},
+			timeout: { timeoutMs: -1, idleTimeoutMs: Number.POSITIVE_INFINITY },
+			metadata: { apiKey: "do-not-store", rawResponse: "RAW_POLICY_VALIDATION" },
+		});
+		expect(issues).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({
+					kind: "issue",
+					code: "tool-provider-policy-missing-policy-id",
+				}),
+				expect.objectContaining({
+					kind: "issue",
+					code: "tool-provider-policy-missing-provider-id",
+				}),
+				expect.objectContaining({
+					kind: "issue",
+					code: "tool-provider-policy-invalid-size-limit",
+				}),
+				expect.objectContaining({
+					kind: "issue",
+					code: "tool-provider-policy-invalid-timeout",
+				}),
+				expect.objectContaining({
+					kind: "issue",
+					code: "tool-provider-policy-forbidden-runtime-material",
+				}),
+			]),
+		);
+		expect(issues.every((issue) => issue.kind === "issue")).toBe(true);
+		expect(JSON.stringify(issues)).not.toMatch(/do-not-store|RAW_POLICY_VALIDATION|rawResponse/);
+
+		expect(
+			validateToolProviderExecutionPolicy({
+				kind: "tool-provider-execution-policy",
+				policyId: "policy-empty",
+				providerId: "local",
+			}),
+		).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({
+					kind: "issue",
+					code: "tool-provider-policy-missing-material",
+				}),
+			]),
+		);
+		expect(validateToolProviderExecutionPolicy({ sizeCapacity: {} })).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({ code: "tool-provider-policy-invalid-kind" }),
+				expect.objectContaining({ code: "tool-provider-policy-missing-policy-id" }),
+				expect.objectContaining({ code: "tool-provider-policy-missing-provider-id" }),
+				expect.objectContaining({ code: "tool-provider-policy-invalid-size-capacity" }),
+			]),
+		);
+		expect(
+			validateToolProviderExecutionPolicy({
+				kind: "tool-provider-execution-policy",
+				policyId: "bad-timeout",
+				providerId: "local",
+				timeout: { timeoutMs: "fast" },
+			}),
+		).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({ code: "tool-provider-policy-invalid-timeout" }),
+			]),
+		);
+		expect(validateToolProviderExecutionPolicy(null)).toEqual([
+			expect.objectContaining({
+				kind: "issue",
+				code: "tool-provider-policy-invalid-shape",
+			}),
+		]);
+	});
+});
diff --git a/packages/ts/src/__tests__/agent-runtime.part-08.test.ts b/packages/ts/src/__tests__/agent-runtime.part-08.test.ts
new file mode 100644
index 00000000..c2730058
--- /dev/null
+++ b/packages/ts/src/__tests__/agent-runtime.part-08.test.ts
@@ -0,0 +1,892 @@
+import { describe, expect, it } from "vitest";
+import { graph } from "../graph/graph.js";
+import {
+	type AgentDecision,
+	type AgentRequestFact,
+	type AgentRequestIssued,
+	type AgentRequestStatusChanged,
+	buildToolProviderAdapterInputs,
+	type EffectRun,
+	type EffectRunResult,
+	type ExecutorOutcome,
+	type ExecutorProfile,
+	type ExecutorRoute,
+	effectRun,
+	effectRunCompletionProjector,
+	executorOutcomeViewProjector,
+	fakeExecutorResult,
+	localBuiltinToolProviderCatalog,
+	type PromptBundle,
+	requestSatisfactionProjector,
+	resolveToolProviderExecutionPolicies,
+	type ToolProviderAdapterInput,
+} from "../orchestration/agent-runtime.js";
+import type {
+	WorkItemDomainActionAdmissionDecision,
+	WorkItemDomainActionProposal,
+	WorkItemSeed,
+} from "../orchestration/work-item-runtime.js";
+
+function issued(
+	requestId: string,
+	operationId: string,
+	requestKind: AgentRequestIssued["requestKind"],
+	inputKind?: string,
+): AgentRequestIssued {
+	return {
+		kind: "issued",
+		requestId,
+		operationId,
+		effectRunId: "run-1",
+		requestKind,
+		required: true,
+		input:
+			inputKind === undefined
+				? undefined
+				: { inputId: `${requestId}:input`, inputKind, dataMode: "summary", summary: inputKind },
+	};
+}
+
+function toolRequest(
+	requestId: string,
+	operationId: string,
+	toolName: string,
+	operation?: string,
+): AgentRequestIssued {
+	return {
+		kind: "issued",
+		requestId,
+		operationId,
+		effectRunId: "run-1",
+		requestKind: "executor",
+		required: true,
+		input: {
+			inputId: `${requestId}:input`,
+			inputKind: "tool-call",
+			dataMode: "inline",
+			value: {
+				kind: "tool-call",
+				toolName,
+				operation,
+				arguments: { path: "README.md" },
+			},
+		},
+	};
+}
+
+const forbiddenRetentionPayloadPattern =
+	/SCORER_SECRET|SCORER_RAW|rawResponse|stdout|stderr|stack|apiKey|password|arguments|providerClient|oauthState|subprocessHandle|transport|sdkObject/i;
+
+const retentionScorerEntryKeys: Record<string, readonly string[]> = {
+	adapterInputs: [
+		"adapterInputId",
+		"executorId",
+		"insertedAtMs",
+		"key",
+		"operationId",
+		"profileId",
+		"providerId",
+		"requestId",
+		"routeId",
+		"sequence",
+		"status",
+	],
+	runRequests: [
+		"adapterInputId",
+		"attempt",
+		"executorId",
+		"key",
+		"operationId",
+		"profileId",
+		"providerId",
+		"reason",
+		"requestId",
+		"requestedAtMs",
+		"routeId",
+		"runId",
+		"sequence",
+	],
+	executions: [
+		"adapterInputId",
+		"attempt",
+		"executorId",
+		"key",
+		"occurredAtMs",
+		"operationId",
+		"outcomeId",
+		"profileId",
+		"providerId",
+		"reason",
+		"requestId",
+		"routeId",
+		"runId",
+		"sequence",
+		"status",
+	],
+	runStatuses: [
+		"adapterInputId",
+		"attempt",
+		"issueCode",
+		"key",
+		"occurredAtMs",
+		"operationId",
+		"outcomeId",
+		"requestId",
+		"runId",
+		"sequence",
+		"status",
+	],
+	runIssues: [
+		"adapterInputId",
+		"attempt",
+		"issueCode",
+		"key",
+		"occurredAtMs",
+		"operationId",
+		"requestId",
+		"runId",
+		"sequence",
+		"severity",
+		"subjectId",
+	],
+	retentionEvidence: [
+		"adapterInputId",
+		"attemptHighWater",
+		"evidenceKind",
+		"key",
+		"occurredAtMs",
+		"reason",
+		"sequence",
+	],
+};
+
+function _expectRetentionScorerEntryPayloadSafe(index: string, entry: unknown): void {
+	expect(entry).toBeTypeOf("object");
+	expect(Array.isArray(entry)).toBe(false);
+	const record = entry as Record<string, unknown>;
+	const allowed = retentionScorerEntryKeys[index];
+	expect(allowed, `unknown retention scorer index ${index}`).toBeDefined();
+	for (const [key, value] of Object.entries(record)) {
+		expect(allowed).toContain(key);
+		expect(value === undefined || typeof value === "string" || typeof value === "number").toBe(
+			true,
+		);
+		if (key === "key") expect(value).toEqual(expect.stringMatching(/^key:[a-z0-9]+:\d+$/));
+	}
+	expectNoForbiddenRetentionPayload(record);
+}
+
+function expectNoForbiddenRetentionPayload(value: unknown): void {
+	expect(JSON.stringify(value)).not.toMatch(forbiddenRetentionPayloadPattern);
+}
+
+function _readyToolProviderAdapterInput(
+	providerId: string,
+	requestId: string,
+): ToolProviderAdapterInput {
+	const catalog = localBuiltinToolProviderCatalog({ providerId });
+	const profile = catalog.profiles[0];
+	if (profile === undefined) throw new Error("expected profile");
+	const request = toolRequest(requestId, `${requestId}-op`, "file.read", "read");
+	const route: ExecutorRoute = {
+		kind: "executor-route",
+		routeId: `${requestId}-route`,
+		requestId: request.requestId,
+		operationId: request.operationId,
+		executorId: profile.executorId,
+		profileId: profile.profileId,
+		inputKind: "tool-call",
+	};
+	const resolutions = resolveToolProviderExecutionPolicies({
+		request,
+		routes: [route],
+		catalogs: [catalog],
+	});
+	const input = buildToolProviderAdapterInputs({
+		requests: [request],
+		routes: [route],
+		catalogs: [catalog],
+		resolutions,
+	})[0];
+	if (input === undefined || input.status !== "ready") throw new Error("expected ready input");
+	return input;
+}
+
+function _workItemSeed(workItemId: string): WorkItemSeed {
+	return {
+		kind: "work-item",
+		workItemId,
+		sourceRefs: [{ kind: "work-item", id: workItemId }],
+		workItemKind: "issue",
+		lifecycleStatus: "open",
+	};
+}
+
+function _workItemActionProposal(
+	proposalId: string,
+	actionKind: string,
+	opts: Partial<WorkItemDomainActionProposal> = {},
+): WorkItemDomainActionProposal {
+	return {
+		kind: "work-item-domain-action-proposal",
+		proposalId,
+		workItemId: opts.workItemId ?? "wi-1",
+		actionKind,
+		effectRunId: opts.effectRunId ?? "run-1",
+		effectRunResultId: opts.effectRunResultId ?? "run-1:result",
+		evidenceId: opts.evidenceId ?? "wi-1:run-1:run-1:result",
+		policyId: opts.policyId ?? "policy-propose",
+		sourceRefs: opts.sourceRefs,
+		metadata: opts.metadata,
+	};
+}
+
+function _workItemAdmissionDecision(
+	decisionId: string,
+	admissionId: string,
+	proposalId: string,
+	outcome: WorkItemDomainActionAdmissionDecision["outcome"],
+	opts: Partial<WorkItemDomainActionAdmissionDecision> = {},
+): WorkItemDomainActionAdmissionDecision {
+	return {
+		kind: "work-item-domain-action-admission-decision",
+		decisionId,
+		admissionId,
+		proposalId,
+		outcome,
+		policyId: opts.policyId,
+		reason: opts.reason,
+		targetProposalId: opts.targetProposalId,
+		targetAdmissionId: opts.targetAdmissionId,
+		sourceRefs: opts.sourceRefs,
+		decidedAtMs: opts.decidedAtMs,
+		metadata: opts.metadata,
+	};
+}
+
+describe("CSP-8 experimental agent runtime kernel (D236) — part 8", () => {
+	it("projects compact ExecutorOutcome views without inlining raw result payloads", () => {
+		const g = graph();
+		const outcomes = g.node<ExecutorOutcome>([], null, { name: "outcomes" });
+		const projector = executorOutcomeViewProjector(g, {
+			outcomes,
+			policy: { maxSummaryChars: 18, includeMetadata: true },
+		});
+		const views: unknown[] = [];
+		const audit: unknown[] = [];
+		projector.views.subscribe((msg) => msg[0] === "DATA" && views.push(msg[1]));
+		projector.audit.subscribe((msg) => msg[0] === "DATA" && audit.push(msg[1]));
+
+		outcomes.down([
+			[
+				"DATA",
+				fakeExecutorResult({
+					outcomeId: "outcome-large",
+					requestId: "request-large",
+					operationId: "op-large",
+					routeId: "route-large",
+					executorId: "exec-tool",
+					profileId: "profile-tool",
+					attempt: 1,
+					inputKind: "tool-call",
+					result: {
+						kind: "tool-result",
+						summary: "stdout contained a very long failure explanation",
+						value: { stdout: "RAW_STDOUT_SHOULD_NOT_APPEAR".repeat(20) },
+						refs: [{ kind: "artifact", id: "stdout-summary-ref" }],
+					},
+					evidenceRefs: [{ kind: "executor-route", id: "route-large" }],
+					metadata: { rawResponse: "raw-123" },
+				}),
+			],
+		]);
+
+		expect(views).toHaveLength(1);
+		expect(views.at(-1)).toMatchObject({
+			kind: "executor-outcome-view",
+			audience: "agent-observation",
+			outcomeId: "outcome-large",
+			status: "result",
+			materialRefs: [{ kind: "artifact", id: "stdout-summary-ref" }],
+			sourceRefs: [
+				{ kind: "executor-outcome", id: "outcome-large" },
+				{ kind: "executor-route", id: "route-large" },
+			],
+		});
+		expect(views.at(-1)).not.toHaveProperty("metadata");
+		expect((views.at(-1) as { summary: string }).summary).toMatch(/^stdout/);
+		expect((views.at(-1) as { summary: string }).summary.length).toBeLessThanOrEqual(18);
+		expect(JSON.stringify(views.at(-1))).not.toContain("RAW_STDOUT_SHOULD_NOT_APPEAR");
+		expect(JSON.stringify(views.at(-1))).not.toContain("raw-123");
+		expect(audit.at(-1)).toMatchObject({
+			kind: "executor-outcome-view-projected",
+			subjectId: "request-large",
+		});
+	});
+
+	it("emits DataIssue for stale operationId and does not satisfy the request", () => {
+		const g = graph();
+		const requestFacts = g.node<AgentRequestFact>([], null, { name: "requestFacts" });
+		const profiles = g.node<ExecutorProfile>([], null, { name: "profiles" });
+		const routes = g.node<ExecutorRoute>([], null, { name: "routes" });
+		const outcomes = g.node<ExecutorOutcome>([], null, { name: "outcomes" });
+		const satisfaction = requestSatisfactionProjector(g, {
+			requestFacts,
+			executorProfiles: [profiles],
+			executorRoutes: [routes],
+			executorOutcomes: [outcomes],
+		});
+		const statuses: AgentRequestStatusChanged[] = [];
+		const issues: unknown[] = [];
+		satisfaction.status.subscribe(
+			(msg) => msg[0] === "DATA" && statuses.push(msg[1] as AgentRequestStatusChanged),
+		);
+		satisfaction.issues.subscribe((msg) => msg[0] === "DATA" && issues.push(msg[1]));
+
+		requestFacts.down([["DATA", issued("request-1", "op-good", "executor", "llm-call")]]);
+		profiles.down([["DATA", { profileId: "profile-1", executorId: "exec-1", kind: "llm" }]]);
+		routes.down([
+			[
+				"DATA",
+				{
+					kind: "executor-route",
+					routeId: "route-1",
+					requestId: "request-1",
+					operationId: "op-good",
+					inputKind: "llm-call",
+					executorId: "exec-1",
+					profileId: "profile-1",
+				},
+			],
+		]);
+		outcomes.down([
+			[
+				"DATA",
+				fakeExecutorResult({
+					outcomeId: "stale",
+					requestId: "request-1",
+					operationId: "op-stale",
+					routeId: "route-1",
+					executorId: "exec-1",
+					profileId: "profile-1",
+					attempt: 1,
+					inputKind: "llm-call",
+					result: { kind: "value", value: true },
+				}),
+			],
+		]);
+
+		expect(issues.at(-1)).toMatchObject({ kind: "issue", code: "stale-outcome-operation" });
+		expect(statuses.map((s) => s.status)).not.toContain("completed");
+	});
+
+	it("keeps ExecutorRoute nonterminal and reports incompatible routes as DataIssue", () => {
+		const g = graph();
+		const requestFacts = g.node<AgentRequestFact>([], null, { name: "requestFacts" });
+		const profiles = g.node<ExecutorProfile>([], null, { name: "profiles" });
+		const routes = g.node<ExecutorRoute>([], null, { name: "routes" });
+		const satisfaction = requestSatisfactionProjector(g, {
+			requestFacts,
+			executorProfiles: [profiles],
+			executorRoutes: [routes],
+		});
+		const statuses: AgentRequestStatusChanged[] = [];
+		const issues: unknown[] = [];
+		satisfaction.status.subscribe(
+			(msg) => msg[0] === "DATA" && statuses.push(msg[1] as AgentRequestStatusChanged),
+		);
+		satisfaction.issues.subscribe((msg) => msg[0] === "DATA" && issues.push(msg[1]));
+
+		requestFacts.down([["DATA", issued("request-1", "op-1", "executor", "llm-call")]]);
+		profiles.down([["DATA", { profileId: "profile-1", executorId: "exec-1", kind: "llm" }]]);
+		routes.down([
+			[
+				"DATA",
+				{
+					kind: "executor-route",
+					routeId: "route-1",
+					requestId: "request-1",
+					operationId: "op-1",
+					inputKind: "llm-call",
+					executorId: "exec-1",
+					profileId: "profile-1",
+				},
+			],
+		]);
+		expect(statuses.at(-1)).toMatchObject({ status: "awaiting-provider" });
+		expect(statuses.map((s) => s.status)).not.toContain("completed");
+
+		requestFacts.down([["DATA", issued("request-2", "op-2", "executor", "tool-call")]]);
+		routes.down([
+			[
+				"DATA",
+				{
+					kind: "executor-route",
+					routeId: "route-2",
+					requestId: "request-2",
+					operationId: "op-2",
+					inputKind: "tool-call",
+					executorId: "exec-1",
+					profileId: "profile-1",
+				},
+			],
+		]);
+		expect(issues.at(-1)).toMatchObject({
+			kind: "issue",
+			code: "profile-kind-input-incompatible",
+		});
+	});
+
+	it("rejects route input-kind rewrites and mismatched executor outcomes", () => {
+		const g = graph();
+		const requestFacts = g.node<AgentRequestFact>([], null, { name: "requestFacts" });
+		const profiles = g.node<ExecutorProfile>([], null, { name: "profiles" });
+		const routes = g.node<ExecutorRoute>([], null, { name: "routes" });
+		const outcomes = g.node<ExecutorOutcome>([], null, { name: "outcomes" });
+		const satisfaction = requestSatisfactionProjector(g, {
+			requestFacts,
+			executorProfiles: [profiles],
+			executorRoutes: [routes],
+			executorOutcomes: [outcomes],
+		});
+		const statuses: AgentRequestStatusChanged[] = [];
+		const issues: unknown[] = [];
+		satisfaction.status.subscribe(
+			(msg) => msg[0] === "DATA" && statuses.push(msg[1] as AgentRequestStatusChanged),
+		);
+		satisfaction.issues.subscribe((msg) => msg[0] === "DATA" && issues.push(msg[1]));
+
+		requestFacts.down([["DATA", issued("request-1", "op-1", "executor", "llm-call")]]);
+		profiles.down([
+			["DATA", { profileId: "llm-profile", executorId: "llm-exec", kind: "llm" }],
+			["DATA", { profileId: "tool-profile", executorId: "tool-exec", kind: "tool" }],
+		]);
+		routes.down([
+			[
+				"DATA",
+				{
+					kind: "executor-route",
+					routeId: "bad-route",
+					requestId: "request-1",
+					operationId: "op-1",
+					inputKind: "tool-call",
+					executorId: "tool-exec",
+					profileId: "tool-profile",
+				},
+			],
+			[
+				"DATA",
+				{
+					kind: "executor-route",
+					routeId: "good-route",
+					requestId: "request-1",
+					operationId: "op-1",
+					inputKind: "llm-call",
+					executorId: "llm-exec",
+					profileId: "llm-profile",
+				},
+			],
+		]);
+		outcomes.down([
+			[
+				"DATA",
+				fakeExecutorResult({
+					outcomeId: "spoofed",
+					requestId: "request-1",
+					operationId: "op-1",
+					routeId: "good-route",
+					executorId: "tool-exec",
+					profileId: "llm-profile",
+					attempt: 1,
+					inputKind: "llm-call",
+					result: { kind: "value", value: true },
+				}),
+			],
+		]);
+
+		expect(issues).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({ code: "route-input-kind-mismatch" }),
+				expect.objectContaining({ code: "outcome-route-executor-mismatch" }),
+			]),
+		);
+		expect(statuses.map((s) => s.status)).not.toContain("completed");
+	});
+
+	it("keeps multiple compatible routes valid by routeId", () => {
+		const g = graph();
+		const requestFacts = g.node<AgentRequestFact>([], null, { name: "requestFacts" });
+		const profiles = g.node<ExecutorProfile>([], null, { name: "profiles" });
+		const routes = g.node<ExecutorRoute>([], null, { name: "routes" });
+		const outcomes = g.node<ExecutorOutcome>([], null, { name: "outcomes" });
+		const satisfaction = requestSatisfactionProjector(g, {
+			requestFacts,
+			executorProfiles: [profiles],
+			executorRoutes: [routes],
+			executorOutcomes: [outcomes],
+		});
+		const statuses: AgentRequestStatusChanged[] = [];
+		const issues: unknown[] = [];
+		satisfaction.status.subscribe(
+			(msg) => msg[0] === "DATA" && statuses.push(msg[1] as AgentRequestStatusChanged),
+		);
+		satisfaction.issues.subscribe((msg) => msg[0] === "DATA" && issues.push(msg[1]));
+
+		requestFacts.down([["DATA", issued("request-1", "op-1", "executor", "llm-call")]]);
+		profiles.down([
+			["DATA", { profileId: "profile-1", executorId: "exec-1", kind: "llm" }],
+			["DATA", { profileId: "profile-2", executorId: "exec-2", kind: "llm" }],
+		]);
+		routes.down([
+			[
+				"DATA",
+				{
+					kind: "executor-route",
+					routeId: "route-1",
+					requestId: "request-1",
+					operationId: "op-1",
+					inputKind: "llm-call",
+					executorId: "exec-1",
+					profileId: "profile-1",
+				},
+			],
+			[
+				"DATA",
+				{
+					kind: "executor-route",
+					routeId: "route-2",
+					requestId: "request-1",
+					operationId: "op-1",
+					inputKind: "llm-call",
+					executorId: "exec-2",
+					profileId: "profile-2",
+				},
+			],
+		]);
+		outcomes.down([
+			[
+				"DATA",
+				fakeExecutorResult({
+					outcomeId: "outcome-1",
+					requestId: "request-1",
+					operationId: "op-1",
+					routeId: "route-1",
+					executorId: "exec-1",
+					profileId: "profile-1",
+					attempt: 1,
+					inputKind: "llm-call",
+					result: { kind: "value", value: true },
+				}),
+			],
+		]);
+
+		expect(issues).not.toContainEqual(
+			expect.objectContaining({ code: "missing-compatible-route" }),
+		);
+		expect(statuses.at(-1)).toMatchObject({ requestId: "request-1", status: "completed" });
+	});
+
+	it("replays out-of-order route and outcome facts once the request/profile arrives", () => {
+		const g = graph();
+		const requestFacts = g.node<AgentRequestFact>([], null, { name: "requestFacts" });
+		const profiles = g.node<ExecutorProfile>([], null, { name: "profiles" });
+		const routes = g.node<ExecutorRoute>([], null, { name: "routes" });
+		const outcomes = g.node<ExecutorOutcome>([], null, { name: "outcomes" });
+		const satisfaction = requestSatisfactionProjector(g, {
+			requestFacts,
+			executorProfiles: [profiles],
+			executorRoutes: [routes],
+			executorOutcomes: [outcomes],
+		});
+		const statuses: AgentRequestStatusChanged[] = [];
+		satisfaction.status.subscribe(
+			(msg) => msg[0] === "DATA" && statuses.push(msg[1] as AgentRequestStatusChanged),
+		);
+
+		routes.down([
+			[
+				"DATA",
+				{
+					kind: "executor-route",
+					routeId: "route-1",
+					requestId: "request-1",
+					operationId: "op-1",
+					inputKind: "llm-call",
+					executorId: "exec-1",
+					profileId: "profile-1",
+				},
+			],
+		]);
+		outcomes.down([
+			[
+				"DATA",
+				fakeExecutorResult({
+					outcomeId: "outcome-1",
+					requestId: "request-1",
+					operationId: "op-1",
+					routeId: "route-1",
+					executorId: "exec-1",
+					profileId: "profile-1",
+					attempt: 1,
+					inputKind: "llm-call",
+					result: { kind: "value", value: true },
+				}),
+			],
+		]);
+		requestFacts.down([["DATA", issued("request-1", "op-1", "executor", "llm-call")]]);
+		profiles.down([["DATA", { profileId: "profile-1", executorId: "exec-1", kind: "llm" }]]);
+
+		expect(statuses.at(-1)).toMatchObject({ requestId: "request-1", status: "completed" });
+	});
+
+	it("does not let late nonterminal prompt facts reopen a terminal request", () => {
+		const g = graph();
+		const requestFacts = g.node<AgentRequestFact>([], null, { name: "requestFacts" });
+		const prompts = g.node<PromptBundle>([], null, { name: "prompts" });
+		const satisfaction = requestSatisfactionProjector(g, {
+			requestFacts,
+			promptBundles: [prompts],
+		});
+		const statuses: AgentRequestStatusChanged[] = [];
+		satisfaction.status.subscribe(
+			(msg) => msg[0] === "DATA" && statuses.push(msg[1] as AgentRequestStatusChanged),
+		);
+
+		requestFacts.down([["DATA", issued("prompt-1", "op-1", "prompt")]]);
+		prompts.down([
+			[
+				"DATA",
+				{
+					kind: "prompt-bundle",
+					promptId: "prompt-ready",
+					requestId: "prompt-1",
+					operationId: "op-1",
+					status: "ready",
+				},
+			],
+			[
+				"DATA",
+				{
+					kind: "prompt-bundle",
+					promptId: "prompt-late",
+					requestId: "prompt-1",
+					operationId: "op-1",
+					status: "partial",
+				},
+			],
+		]);
+
+		expect(statuses.map((s) => s.status)).toContain("completed");
+		expect(
+			statuses.slice(statuses.findIndex((s) => s.status === "completed") + 1),
+		).not.toContainEqual(expect.objectContaining({ status: "awaiting-prompt" }));
+	});
+
+	it("represents retry exhaustion only as graph-visible status facts", () => {
+		const g = graph();
+		const effectRuns = g.node<EffectRun>([], null, { name: "effectRuns" });
+		const requestFacts = g.node<AgentRequestFact>([], null, { name: "requestFacts" });
+		const completion = effectRunCompletionProjector(g, {
+			effectRuns,
+			requestFacts: [requestFacts],
+		});
+		const status: unknown[] = [];
+		completion.status.subscribe((msg) => msg[0] === "DATA" && status.push(msg[1]));
+		effectRuns.down([["DATA", effectRun({ effectRunId: "run-1", goal: { kind: "retry-test" } })]]);
+		requestFacts.down([
+			["DATA", issued("request-1", "op-1", "executor", "llm-call")],
+			[
+				"DATA",
+				{
+					kind: "status",
+					requestId: "request-1",
+					operationId: "op-1",
+					effectRunId: "run-1",
+					status: "retry-exhausted",
+				},
+			],
+		]);
+
+		expect(status.at(-1)).toMatchObject({ effectRunId: "run-1", state: "pending" });
+	});
+
+	it("consumes terminal AgentRequestFact ledger statuses for EffectRun completion", () => {
+		const g = graph();
+		const effectRuns = g.node<EffectRun>([], null, { name: "effectRuns" });
+		const requestFacts = g.node<AgentRequestFact>([], null, { name: "requestFacts" });
+		const decisions = g.node<AgentDecision>([], null, { name: "decisions" });
+		const completion = effectRunCompletionProjector(g, {
+			effectRuns,
+			requestFacts: [requestFacts],
+			decisions: [decisions],
+			now: () => 1000,
+		});
+		const results: EffectRunResult[] = [];
+		completion.results.subscribe(
+			(msg) => msg[0] === "DATA" && results.push(msg[1] as EffectRunResult),
+		);
+
+		effectRuns.down([["DATA", effectRun({ effectRunId: "run-1", goal: { kind: "test" } })]]);
+		requestFacts.down([["DATA", issued("request-1", "op-1", "executor", "llm-call")]]);
+		decisions.down([
+			[
+				"DATA",
+				{
+					kind: "final",
+					decisionId: "decision-final",
+					effectRunId: "run-1",
+					agentRunId: "agent-1",
+					source: { requestId: "request-1", operationId: "op-1", outcomeId: "outcome-1" },
+					output: { kind: "done", value: true },
+				},
+			],
+		]);
+		expect(results).toEqual([]);
+
+		requestFacts.down([
+			[
+				"DATA",
+				{
+					kind: "status",
+					requestId: "request-1",
+					operationId: "op-1",
+					effectRunId: "run-1",
+					status: "completed",
+				},
+			],
+		]);
+
+		expect(results.at(-1)).toMatchObject({
+			effectRunId: "run-1",
+			status: "completed",
+			completedAtMs: 1000,
+		});
+	});
+
+	it("rejects stale request status identities for completion", () => {
+		const g = graph();
+		const effectRuns = g.node<EffectRun>([], null, { name: "effectRuns" });
+		const requestFacts = g.node<AgentRequestFact>([], null, { name: "requestFacts" });
+		const decisions = g.node<AgentDecision>([], null, { name: "decisions" });
+		const completion = effectRunCompletionProjector(g, {
+			effectRuns,
+			requestFacts: [requestFacts],
+			decisions: [decisions],
+		});
+		const results: EffectRunResult[] = [];
+		const issues: unknown[] = [];
+		completion.results.subscribe(
+			(msg) => msg[0] === "DATA" && results.push(msg[1] as EffectRunResult),
+		);
+		completion.issues.subscribe((msg) => msg[0] === "DATA" && issues.push(msg[1]));
+
+		effectRuns.down([["DATA", effectRun({ effectRunId: "run-1", goal: { kind: "test" } })]]);
+		requestFacts.down([
+			["DATA", issued("request-1", "op-1", "executor", "llm-call")],
+			[
+				"DATA",
+				{
+					kind: "status",
+					requestId: "request-1",
+					operationId: "op-stale",
+					effectRunId: "run-1",
+					status: "completed",
+				},
+			],
+		]);
+		decisions.down([
+			[
+				"DATA",
+				{
+					kind: "final",
+					decisionId: "decision-final",
+					effectRunId: "run-1",
+					agentRunId: "agent-1",
+					source: { requestId: "request-1", operationId: "op-1", outcomeId: "outcome-1" },
+					output: { kind: "done", value: true },
+				},
+			],
+		]);
+
+		expect(issues.at(-1)).toMatchObject({ code: "stale-request-status" });
+		expect(results).toEqual([]);
+	});
+
+	it("emits DataIssue and audit for late conflicting EffectRunResult candidates", () => {
+		const g = graph();
+		const effectRuns = g.node<EffectRun>([], null, { name: "effectRuns" });
+		const candidates = g.node<EffectRunResult>([], null, { name: "candidates" });
+		const completion = effectRunCompletionProjector(g, {
+			effectRuns,
+			resultCandidates: [candidates],
+		});
+		const results: EffectRunResult[] = [];
+		const issues: unknown[] = [];
+		const audit: unknown[] = [];
+		completion.results.subscribe(
+			(msg) => msg[0] === "DATA" && results.push(msg[1] as EffectRunResult),
+		);
+		completion.issues.subscribe((msg) => msg[0] === "DATA" && issues.push(msg[1]));
+		completion.audit.subscribe((msg) => msg[0] === "DATA" && audit.push(msg[1]));
+		effectRuns.down([["DATA", effectRun({ effectRunId: "run-1", goal: { kind: "test" } })]]);
+		candidates.down([
+			[
+				"DATA",
+				{
+					kind: "effect-run-result",
+					resultId: "run-1:result",
+					status: "completed",
+					effectRunId: "run-1",
+					output: { kind: "ok" },
+				},
+			],
+			[
+				"DATA",
+				{
+					kind: "effect-run-result",
+					resultId: "run-1:other",
+					status: "failed",
+					effectRunId: "run-1",
+					error: { kind: "issue", code: "failed", message: "failed" },
+				},
+			],
+		]);
+
+		expect(results).toHaveLength(1);
+		expect(issues.at(-1)).toMatchObject({ kind: "issue", code: "conflicting-effect-run-result" });
+		expect(audit.at(-1)).toMatchObject({ kind: "effect-run-result-conflict" });
+	});
+
+	it("rejects EffectRunResult candidates for unknown EffectRuns", () => {
+		const g = graph();
+		const effectRuns = g.node<EffectRun>([], null, { name: "effectRuns" });
+		const candidates = g.node<EffectRunResult>([], null, { name: "candidates" });
+		const completion = effectRunCompletionProjector(g, {
+			effectRuns,
+			resultCandidates: [candidates],
+		});
+		const results: EffectRunResult[] = [];
+		const issues: unknown[] = [];
+		completion.results.subscribe(
+			(msg) => msg[0] === "DATA" && results.push(msg[1] as EffectRunResult),
+		);
+		completion.issues.subscribe((msg) => msg[0] === "DATA" && issues.push(msg[1]));
+		effectRuns.down([["DATA", effectRun({ effectRunId: "run-1", goal: { kind: "test" } })]]);
+
+		candidates.down([
+			[
+				"DATA",
+				{
+					kind: "effect-run-result",
+					resultId: "missing-run:result",
+					status: "completed",
+					effectRunId: "missing-run",
+					output: { kind: "ok" },
+				},
+			],
+		]);
+
+		expect(results).toEqual([]);
+		expect(issues.at(-1)).toMatchObject({ code: "unknown-effect-run-result-candidate" });
+	});
+});
diff --git a/packages/ts/src/__tests__/agent-runtime.part-09.test.ts b/packages/ts/src/__tests__/agent-runtime.part-09.test.ts
new file mode 100644
index 00000000..3854eadb
--- /dev/null
+++ b/packages/ts/src/__tests__/agent-runtime.part-09.test.ts
@@ -0,0 +1,995 @@
+import { describe, expect, it } from "vitest";
+import type { DataIssue } from "../data/index.js";
+import { graph } from "../graph/graph.js";
+import {
+	type AgentDecision,
+	type AgentRequestFact,
+	type AgentRequestIssued,
+	type AgentRequestStatusChanged,
+	type AgentRequestViews,
+	agentRequestLedgerViews,
+	buildToolProviderAdapterInputs,
+	type EffectRun,
+	type EffectRunResult,
+	type ExecutorOutcome,
+	type ExecutorRoute,
+	effectRun,
+	effectRunCompletionProjector,
+	fakeExecutorFailure,
+	fakeExecutorResult,
+	localBuiltinToolProviderCatalog,
+	resolveToolProviderExecutionPolicies,
+	structuredAgentDecisionInterpreter,
+	type ToolProviderAdapterInput,
+} from "../orchestration/agent-runtime.js";
+import {
+	type WorkItemDomainActionAdmissionDecision,
+	type WorkItemDomainActionProposal,
+	type WorkItemEvidenceRecorded,
+	type WorkItemSeed,
+	workItemEffectResultMapper,
+} from "../orchestration/work-item-runtime.js";
+
+function issued(
+	requestId: string,
+	operationId: string,
+	requestKind: AgentRequestIssued["requestKind"],
+	inputKind?: string,
+): AgentRequestIssued {
+	return {
+		kind: "issued",
+		requestId,
+		operationId,
+		effectRunId: "run-1",
+		requestKind,
+		required: true,
+		input:
+			inputKind === undefined
+				? undefined
+				: { inputId: `${requestId}:input`, inputKind, dataMode: "summary", summary: inputKind },
+	};
+}
+
+function toolRequest(
+	requestId: string,
+	operationId: string,
+	toolName: string,
+	operation?: string,
+): AgentRequestIssued {
+	return {
+		kind: "issued",
+		requestId,
+		operationId,
+		effectRunId: "run-1",
+		requestKind: "executor",
+		required: true,
+		input: {
+			inputId: `${requestId}:input`,
+			inputKind: "tool-call",
+			dataMode: "inline",
+			value: {
+				kind: "tool-call",
+				toolName,
+				operation,
+				arguments: { path: "README.md" },
+			},
+		},
+	};
+}
+
+const forbiddenRetentionPayloadPattern =
+	/SCORER_SECRET|SCORER_RAW|rawResponse|stdout|stderr|stack|apiKey|password|arguments|providerClient|oauthState|subprocessHandle|transport|sdkObject/i;
+
+const retentionScorerEntryKeys: Record<string, readonly string[]> = {
+	adapterInputs: [
+		"adapterInputId",
+		"executorId",
+		"insertedAtMs",
+		"key",
+		"operationId",
+		"profileId",
+		"providerId",
+		"requestId",
+		"routeId",
+		"sequence",
+		"status",
+	],
+	runRequests: [
+		"adapterInputId",
+		"attempt",
+		"executorId",
+		"key",
+		"operationId",
+		"profileId",
+		"providerId",
+		"reason",
+		"requestId",
+		"requestedAtMs",
+		"routeId",
+		"runId",
+		"sequence",
+	],
+	executions: [
+		"adapterInputId",
+		"attempt",
+		"executorId",
+		"key",
+		"occurredAtMs",
+		"operationId",
+		"outcomeId",
+		"profileId",
+		"providerId",
+		"reason",
+		"requestId",
+		"routeId",
+		"runId",
+		"sequence",
+		"status",
+	],
+	runStatuses: [
+		"adapterInputId",
+		"attempt",
+		"issueCode",
+		"key",
+		"occurredAtMs",
+		"operationId",
+		"outcomeId",
+		"requestId",
+		"runId",
+		"sequence",
+		"status",
+	],
+	runIssues: [
+		"adapterInputId",
+		"attempt",
+		"issueCode",
+		"key",
+		"occurredAtMs",
+		"operationId",
+		"requestId",
+		"runId",
+		"sequence",
+		"severity",
+		"subjectId",
+	],
+	retentionEvidence: [
+		"adapterInputId",
+		"attemptHighWater",
+		"evidenceKind",
+		"key",
+		"occurredAtMs",
+		"reason",
+		"sequence",
+	],
+};
+
+function _expectRetentionScorerEntryPayloadSafe(index: string, entry: unknown): void {
+	expect(entry).toBeTypeOf("object");
+	expect(Array.isArray(entry)).toBe(false);
+	const record = entry as Record<string, unknown>;
+	const allowed = retentionScorerEntryKeys[index];
+	expect(allowed, `unknown retention scorer index ${index}`).toBeDefined();
+	for (const [key, value] of Object.entries(record)) {
+		expect(allowed).toContain(key);
+		expect(value === undefined || typeof value === "string" || typeof value === "number").toBe(
+			true,
+		);
+		if (key === "key") expect(value).toEqual(expect.stringMatching(/^key:[a-z0-9]+:\d+$/));
+	}
+	expectNoForbiddenRetentionPayload(record);
+}
+
+function expectNoForbiddenRetentionPayload(value: unknown): void {
+	expect(JSON.stringify(value)).not.toMatch(forbiddenRetentionPayloadPattern);
+}
+
+function _readyToolProviderAdapterInput(
+	providerId: string,
+	requestId: string,
+): ToolProviderAdapterInput {
+	const catalog = localBuiltinToolProviderCatalog({ providerId });
+	const profile = catalog.profiles[0];
+	if (profile === undefined) throw new Error("expected profile");
+	const request = toolRequest(requestId, `${requestId}-op`, "file.read", "read");
+	const route: ExecutorRoute = {
+		kind: "executor-route",
+		routeId: `${requestId}-route`,
+		requestId: request.requestId,
+		operationId: request.operationId,
+		executorId: profile.executorId,
+		profileId: profile.profileId,
+		inputKind: "tool-call",
+	};
+	const resolutions = resolveToolProviderExecutionPolicies({
+		request,
+		routes: [route],
+		catalogs: [catalog],
+	});
+	const input = buildToolProviderAdapterInputs({
+		requests: [request],
+		routes: [route],
+		catalogs: [catalog],
+		resolutions,
+	})[0];
+	if (input === undefined || input.status !== "ready") throw new Error("expected ready input");
+	return input;
+}
+
+function workItemSeed(workItemId: string): WorkItemSeed {
+	return {
+		kind: "work-item",
+		workItemId,
+		sourceRefs: [{ kind: "work-item", id: workItemId }],
+		workItemKind: "issue",
+		lifecycleStatus: "open",
+	};
+}
+
+function _workItemActionProposal(
+	proposalId: string,
+	actionKind: string,
+	opts: Partial<WorkItemDomainActionProposal> = {},
+): WorkItemDomainActionProposal {
+	return {
+		kind: "work-item-domain-action-proposal",
+		proposalId,
+		workItemId: opts.workItemId ?? "wi-1",
+		actionKind,
+		effectRunId: opts.effectRunId ?? "run-1",
+		effectRunResultId: opts.effectRunResultId ?? "run-1:result",
+		evidenceId: opts.evidenceId ?? "wi-1:run-1:run-1:result",
+		policyId: opts.policyId ?? "policy-propose",
+		sourceRefs: opts.sourceRefs,
+		metadata: opts.metadata,
+	};
+}
+
+function _workItemAdmissionDecision(
+	decisionId: string,
+	admissionId: string,
+	proposalId: string,
+	outcome: WorkItemDomainActionAdmissionDecision["outcome"],
+	opts: Partial<WorkItemDomainActionAdmissionDecision> = {},
+): WorkItemDomainActionAdmissionDecision {
+	return {
+		kind: "work-item-domain-action-admission-decision",
+		decisionId,
+		admissionId,
+		proposalId,
+		outcome,
+		policyId: opts.policyId,
+		reason: opts.reason,
+		targetProposalId: opts.targetProposalId,
+		targetAdmissionId: opts.targetAdmissionId,
+		sourceRefs: opts.sourceRefs,
+		decidedAtMs: opts.decidedAtMs,
+		metadata: opts.metadata,
+	};
+}
+
+describe("CSP-8 experimental agent runtime kernel (D236) — part 9", () => {
+	it("does not reprocess accepted final decisions into false conflicts", () => {
+		const g = graph();
+		const effectRuns = g.node<EffectRun>([], null, { name: "effectRuns" });
+		const requestFacts = g.node<AgentRequestFact>([], null, { name: "requestFacts" });
+		const decisions = g.node<AgentDecision>([], null, { name: "decisions" });
+		let clock = 1000;
+		const completion = effectRunCompletionProjector(g, {
+			effectRuns,
+			requestFacts: [requestFacts],
+			decisions: [decisions],
+			now: () => clock++,
+		});
+		const results: EffectRunResult[] = [];
+		const issues: unknown[] = [];
+		completion.results.subscribe(
+			(msg) => msg[0] === "DATA" && results.push(msg[1] as EffectRunResult),
+		);
+		completion.issues.subscribe((msg) => msg[0] === "DATA" && issues.push(msg[1]));
+
+		effectRuns.down([["DATA", effectRun({ effectRunId: "run-1", goal: { kind: "test" } })]]);
+		requestFacts.down([
+			["DATA", issued("request-1", "op-1", "executor", "llm-call")],
+			[
+				"DATA",
+				{
+					kind: "status",
+					requestId: "request-1",
+					operationId: "op-1",
+					effectRunId: "run-1",
+					status: "completed",
+				},
+			],
+		]);
+		decisions.down([
+			[
+				"DATA",
+				{
+					kind: "final",
+					decisionId: "decision-final",
+					effectRunId: "run-1",
+					agentRunId: "agent-1",
+					source: { requestId: "request-1", operationId: "op-1", outcomeId: "outcome-1" },
+					output: { kind: "done", value: true },
+				},
+			],
+		]);
+		effectRuns.down([["DATA", effectRun({ effectRunId: "run-2", goal: { kind: "unrelated" } })]]);
+
+		expect(results).toHaveLength(1);
+		expect(issues).not.toContainEqual(
+			expect.objectContaining({ code: "conflicting-effect-run-result" }),
+		);
+	});
+
+	it("rejects prose and malformed structured agent-decision output", () => {
+		const g = graph();
+		const outcomes = g.node<ExecutorOutcome>([], null, { name: "outcomes" });
+		const interpreter = structuredAgentDecisionInterpreter(g, outcomes);
+		const decisions: unknown[] = [];
+		const issues: unknown[] = [];
+		interpreter.decisions.subscribe((msg) => msg[0] === "DATA" && decisions.push(msg[1]));
+		interpreter.issues.subscribe((msg) => msg[0] === "DATA" && issues.push(msg[1]));
+		const base = {
+			requestId: "request-1",
+			operationId: "op-1",
+			routeId: "route-1",
+			executorId: "exec-1",
+			profileId: "profile-1",
+			attempt: 1,
+		};
+
+		outcomes.down([
+			[
+				"DATA",
+				fakeExecutorResult({
+					...base,
+					outcomeId: "prose",
+					result: { kind: "text", value: "please ask a human to look at this" },
+				}),
+			],
+			[
+				"DATA",
+				fakeExecutorResult({
+					...base,
+					outcomeId: "malformed",
+					result: {
+						kind: "agent-decision",
+						value: { kind: "agent-decision", decision: { kind: "final" } },
+					},
+				}),
+			],
+		]);
+
+		expect(decisions).toEqual([]);
+		expect(issues).toHaveLength(2);
+		expect(issues.map((issue) => (issue as { code: string }).code)).toEqual([
+			"malformed-agent-decision",
+			"missing-agent-decision-schema",
+		]);
+	});
+
+	it("rejects malformed structured decision arrays and does not fabricate completion", () => {
+		const g = graph();
+		const effectRuns = g.node<EffectRun>([], null, { name: "effectRuns" });
+		const requestFacts = g.node<AgentRequestFact>([], null, { name: "requestFacts" });
+		const outcomes = g.node<ExecutorOutcome>([], null, { name: "outcomes" });
+		const interpreter = structuredAgentDecisionInterpreter(g, outcomes, {
+			requestFacts: [requestFacts],
+		});
+		const completion = effectRunCompletionProjector(g, {
+			effectRuns,
+			decisions: [interpreter.decisions],
+			requestFacts: [requestFacts],
+		});
+		const decisions: unknown[] = [];
+		const results: unknown[] = [];
+		const issues: unknown[] = [];
+		interpreter.decisions.subscribe((msg) => msg[0] === "DATA" && decisions.push(msg[1]));
+		interpreter.issues.subscribe((msg) => msg[0] === "DATA" && issues.push(msg[1]));
+		completion.results.subscribe((msg) => msg[0] === "DATA" && results.push(msg[1]));
+		effectRuns.down([["DATA", effectRun({ effectRunId: "run-1", goal: { kind: "test" } })]]);
+		requestFacts.down([["DATA", issued("request-1", "op-1", "executor", "llm-call")]]);
+		outcomes.down([
+			[
+				"DATA",
+				fakeExecutorResult({
+					outcomeId: "bad-next",
+					requestId: "request-1",
+					operationId: "op-1",
+					routeId: "route-1",
+					executorId: "exec-1",
+					profileId: "profile-1",
+					attempt: 1,
+					result: {
+						kind: "agent-decision",
+						value: {
+							kind: "agent-decision",
+							schemaRef: "graphrefly.agent-decision.v0",
+							decision: {
+								kind: "continue",
+								decisionId: "decision-1",
+								effectRunId: "run-1",
+								agentRunId: "agent-1",
+								source: {
+									requestId: "request-1",
+									operationId: "op-1",
+									outcomeId: "bad-next",
+								},
+								next: [null],
+							},
+						},
+					},
+				}),
+			],
+		]);
+
+		expect(decisions).toEqual([]);
+		expect(issues.at(-1)).toMatchObject({ code: "malformed-agent-decision" });
+		expect(results).toEqual([]);
+	});
+
+	it("rejects continue decisions with malformed or cross-run request proposals", () => {
+		const g = graph();
+		const requestFacts = g.node<AgentRequestFact>([], null, { name: "requestFacts" });
+		const outcomes = g.node<ExecutorOutcome>([], null, { name: "outcomes" });
+		const interpreter = structuredAgentDecisionInterpreter(g, outcomes, {
+			requestFacts: [requestFacts],
+		});
+		const decisions: unknown[] = [];
+		const issues: unknown[] = [];
+		interpreter.decisions.subscribe((msg) => msg[0] === "DATA" && decisions.push(msg[1]));
+		interpreter.issues.subscribe((msg) => msg[0] === "DATA" && issues.push(msg[1]));
+		requestFacts.down([["DATA", issued("request-1", "op-1", "executor", "llm-call")]]);
+
+		outcomes.down([
+			[
+				"DATA",
+				fakeExecutorResult({
+					outcomeId: "bad-proposal",
+					requestId: "request-1",
+					operationId: "op-1",
+					routeId: "route-1",
+					executorId: "exec-1",
+					profileId: "profile-1",
+					attempt: 1,
+					result: {
+						kind: "agent-decision",
+						value: {
+							kind: "agent-decision",
+							schemaRef: "graphrefly.agent-decision.v0",
+							decision: {
+								kind: "continue",
+								decisionId: "decision-continue",
+								effectRunId: "run-1",
+								agentRunId: "agent-1",
+								source: {
+									requestId: "request-1",
+									operationId: "op-1",
+									outcomeId: "bad-proposal",
+								},
+								next: [
+									{
+										kind: "proposal",
+										proposalId: "proposal-1",
+										effectRunId: "other-run",
+										requestKind: "executor",
+									},
+								],
+							},
+						},
+					},
+				}),
+			],
+		]);
+
+		expect(decisions).toEqual([]);
+		expect(issues.at(-1)).toMatchObject({ code: "malformed-agent-decision" });
+	});
+
+	it("projects a small AgentRequest ledger default view set", () => {
+		const g = graph();
+		const requestFacts = g.node<AgentRequestFact>([], null, { name: "requestFacts" });
+		const ledger = agentRequestLedgerViews(g, requestFacts);
+		const views: unknown[] = [];
+		ledger.views.subscribe((msg) => msg[0] === "DATA" && views.push(msg[1]));
+
+		requestFacts.down([
+			["DATA", issued("request-1", "op-1", "executor", "llm-call")],
+			[
+				"DATA",
+				{
+					kind: "status",
+					requestId: "request-1",
+					operationId: "op-1",
+					effectRunId: "run-1",
+					status: "awaiting-provider",
+				},
+			],
+		]);
+		requestFacts.down([
+			[
+				"DATA",
+				{
+					kind: "status",
+					requestId: "request-1",
+					operationId: "op-1",
+					effectRunId: "run-1",
+					status: "completed",
+				},
+			],
+		]);
+
+		const latest = views.at(-1) as {
+			requestsById: Map<string, AgentRequestIssued>;
+			requestsByEffectRun: Map<string, readonly string[]>;
+			statusByRequest: Map<string, AgentRequestStatusChanged>;
+			pending: readonly AgentRequestIssued[];
+			awaitingProvider: readonly AgentRequestIssued[];
+			audit: readonly { readonly kind: string }[];
+		};
+		expect(latest.requestsById.get("request-1")).toMatchObject({ operationId: "op-1" });
+		expect(latest.requestsByEffectRun.get("run-1")).toEqual(["request-1"]);
+		expect(latest.statusByRequest.get("request-1")?.status).toBe("completed");
+		expect(latest.pending).toHaveLength(0);
+		expect(latest.awaitingProvider).toHaveLength(0);
+		expect(latest.audit.map((record) => record.kind)).toEqual([
+			"agent-request-issued",
+			"agent-request-status",
+			"agent-request-status",
+		]);
+	});
+
+	it("sanitizes rejected and status issues before storing AgentRequest ledger views", () => {
+		const g = graph();
+		const requestFacts = g.node<AgentRequestFact>([], null, { name: "requestFacts" });
+		const ledger = agentRequestLedgerViews(g, requestFacts);
+		const views: AgentRequestViews[] = [];
+		const issues: DataIssue[] = [];
+		ledger.views.subscribe((msg) => msg[0] === "DATA" && views.push(msg[1] as AgentRequestViews));
+		ledger.issues.subscribe((msg) => msg[0] === "DATA" && issues.push(msg[1] as DataIssue));
+
+		requestFacts.down([
+			["DATA", issued("request-raw-issue", "op-raw-issue", "executor", "tool-call")],
+			[
+				"DATA",
+				{
+					kind: "status",
+					requestId: "request-raw-issue",
+					operationId: "op-raw-issue",
+					effectRunId: "run-1",
+					status: "failed",
+					sourceRefs: [
+						{
+							kind: "provider-raw",
+							id: "status-ref",
+							metadata: { stdout: "RAW_LEDGER_STATUS_REF_SHOULD_NOT_PROJECT" },
+						},
+					],
+					issues: [
+						{
+							kind: "issue",
+							code: "raw-status-issue",
+							source: "runtime-status",
+							message: "raw status issue",
+							correlationId: "corr-status-issue",
+							path: ["status", 0],
+							retryable: true,
+							details: { rawResponse: "RAW_LEDGER_STATUS_ISSUE_SHOULD_NOT_PROJECT" },
+							metadata: { summary: "safe status issue metadata" },
+						},
+					],
+					metadata: { apiKey: "RAW_LEDGER_STATUS_METADATA_SHOULD_NOT_PROJECT" },
+				} satisfies AgentRequestStatusChanged,
+			],
+			[
+				"DATA",
+				{
+					kind: "rejected",
+					proposalId: "proposal-raw-issue",
+					effectRunId: "run-1",
+					issue: {
+						kind: "issue",
+						code: "raw-rejected-issue",
+						message: "raw rejected issue",
+						details: { stderr: "RAW_LEDGER_REJECTED_ISSUE_SHOULD_NOT_PROJECT" },
+					},
+				},
+			],
+		]);
+
+		const latest = views.at(-1);
+		expect(latest?.issues).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({
+					code: "raw-status-issue",
+					source: "runtime-status",
+					correlationId: "corr-status-issue",
+					path: ["status", 0],
+					retryable: true,
+					details: expect.objectContaining({
+						redacted: true,
+						reason: "forbidden-runtime-material",
+					}),
+					metadata: { summary: "safe status issue metadata" },
+				}),
+				expect.objectContaining({
+					code: "raw-rejected-issue",
+					details: expect.objectContaining({
+						redacted: true,
+						reason: "forbidden-runtime-material",
+					}),
+				}),
+			]),
+		);
+		expect(latest?.statusByRequest.get("request-raw-issue")?.sourceRefs).toEqual([
+			{ kind: "provider-raw", id: "status-ref" },
+		]);
+		expect(latest?.statusByRequest.get("request-raw-issue")).not.toHaveProperty("metadata");
+		expect(issues).toEqual(latest?.issues);
+		expect(JSON.stringify({ views, issues })).not.toMatch(
+			/RAW_LEDGER_|rawResponse|stdout|stderr|apiKey/,
+		);
+	});
+
+	it("keeps fake ExecutorOutcome fixtures provider-neutral", () => {
+		expect(
+			fakeExecutorFailure({
+				outcomeId: "failure-1",
+				requestId: "request-1",
+				operationId: "op-1",
+				routeId: "route-1",
+				executorId: "exec-1",
+				profileId: "profile-1",
+				attempt: 1,
+				error: { kind: "issue", code: "adapter-failure", message: "adapter failed" },
+			}),
+		).toMatchObject({
+			kind: "failure",
+			error: { kind: "issue", code: "adapter-failure" },
+		});
+	});
+
+	it("maps every terminal EffectRunResult status to WorkItem evidence, status, issues, and audit", () => {
+		const g = graph();
+		const workItems = g.node<WorkItemSeed>([], null, { name: "workItems" });
+		const effectRuns = g.node<EffectRun>([], null, { name: "effectRuns" });
+		const results = g.node<EffectRunResult>([], null, { name: "results" });
+		const mapper = workItemEffectResultMapper(g, {
+			workItems,
+			effectRuns,
+			effectRunResults: results,
+			now: () => 900,
+		});
+		const evidence: WorkItemEvidenceRecorded[] = [];
+		const statuses: unknown[] = [];
+		const issues: unknown[] = [];
+		const audit: unknown[] = [];
+		mapper.evidence.subscribe(
+			(msg) => msg[0] === "DATA" && evidence.push(msg[1] as WorkItemEvidenceRecorded),
+		);
+		mapper.status.subscribe((msg) => msg[0] === "DATA" && statuses.push(msg[1]));
+		mapper.issues.subscribe((msg) => msg[0] === "DATA" && issues.push(msg[1]));
+		mapper.audit.subscribe((msg) => msg[0] === "DATA" && audit.push(msg[1]));
+		workItems.down([["DATA", workItemSeed("wi-1")]]);
+
+		const terminalResults: EffectRunResult[] = [
+			{
+				kind: "effect-run-result",
+				resultId: "run-completed:result",
+				status: "completed",
+				effectRunId: "run-completed",
+				output: { kind: "ok", value: true },
+			},
+			{
+				kind: "effect-run-result",
+				resultId: "run-failed:result",
+				status: "failed",
+				effectRunId: "run-failed",
+				error: { kind: "issue", code: "failed", message: "failed" },
+				issues: [{ kind: "issue", code: "detail", message: "detail" }],
+			},
+			{
+				kind: "effect-run-result",
+				resultId: "run-blocked:result",
+				status: "blocked",
+				effectRunId: "run-blocked",
+				needs: [{ kind: "human-review", message: "needs review" }],
+			},
+			{
+				kind: "effect-run-result",
+				resultId: "run-timeout:result",
+				status: "timeout",
+				effectRunId: "run-timeout",
+				timeoutMs: 1000,
+			},
+			{
+				kind: "effect-run-result",
+				resultId: "run-canceled:result",
+				status: "canceled",
+				effectRunId: "run-canceled",
+				reason: "user canceled",
+			},
+			{
+				kind: "effect-run-result",
+				resultId: "run-waived:result",
+				status: "waived",
+				effectRunId: "run-waived",
+				reason: "not needed",
+			},
+		];
+		for (const result of terminalResults) {
+			effectRuns.down([
+				[
+					"DATA",
+					effectRun({
+						effectRunId: result.effectRunId,
+						subjectRefs: [{ kind: "work-item", id: "wi-1" }],
+						goal: { kind: "verify" },
+					}),
+				],
+			]);
+			results.down([["DATA", result]]);
+		}
+
+		expect(evidence.map((fact) => fact.status)).toEqual([
+			"completed",
+			"failed",
+			"blocked",
+			"timeout",
+			"canceled",
+			"waived",
+		]);
+		expect(evidence.find((fact) => fact.status === "failed")?.error).toMatchObject({
+			code: "failed",
+		});
+		expect(evidence.find((fact) => fact.status === "blocked")?.needs).toEqual([
+			{ kind: "human-review", message: "needs review" },
+		]);
+		expect(evidence.find((fact) => fact.status === "timeout")?.timeoutMs).toBe(1000);
+		expect(evidence.find((fact) => fact.status === "waived")?.reason).toBe("not needed");
+		expect(statuses).toHaveLength(6);
+		expect(issues).toEqual([]);
+		expect(audit).toHaveLength(6);
+		expect(statuses).not.toContainEqual(expect.objectContaining({ state: "closed" }));
+		expect(statuses).not.toContainEqual(expect.objectContaining({ state: "resolved" }));
+	});
+
+	it("clones evidence arrays and redacts oversized WorkItem output values", () => {
+		const g = graph();
+		const workItems = g.node<WorkItemSeed>([], null, { name: "workItems" });
+		const effectRuns = g.node<EffectRun>([], null, { name: "effectRuns" });
+		const results = g.node<EffectRunResult>([], null, { name: "results" });
+		const mapper = workItemEffectResultMapper(g, {
+			workItems,
+			effectRuns,
+			effectRunResults: results,
+			now: () => 901,
+		});
+		const evidence: WorkItemEvidenceRecorded[] = [];
+		mapper.evidence.subscribe(
+			(msg) => msg[0] === "DATA" && evidence.push(msg[1] as WorkItemEvidenceRecorded),
+		);
+		mapper.issues.subscribe(() => {});
+		workItems.down([["DATA", workItemSeed("wi-1")]]);
+		for (const runId of ["run-oversized", "run-mutable"]) {
+			effectRuns.down([
+				[
+					"DATA",
+					effectRun({
+						effectRunId: runId,
+						subjectRefs: [{ kind: "work-item", id: "wi-1" }],
+						goal: { kind: "verify" },
+					}),
+				],
+			]);
+		}
+
+		results.down([
+			[
+				"DATA",
+				{
+					kind: "effect-run-result",
+					resultId: "run-oversized:result",
+					status: "completed",
+					effectRunId: "run-oversized",
+					output: {
+						kind: "tool-output",
+						value: { content: "large-content-".repeat(80) },
+					},
+				},
+			],
+		]);
+
+		const auditRefs = ["audit-1"];
+		const issueRefs = ["issue-ref-1"];
+		const issuePath: (string | number)[] = ["error", 0];
+		const issue: DataIssue = {
+			kind: "issue",
+			code: "provider-failed",
+			message: "provider failed",
+			refs: issueRefs,
+			path: issuePath,
+		};
+		results.down([
+			[
+				"DATA",
+				{
+					kind: "effect-run-result",
+					resultId: "run-mutable:result",
+					status: "failed",
+					effectRunId: "run-mutable",
+					auditRefs,
+					error: issue,
+					issues: [issue],
+				},
+			],
+		]);
+		auditRefs.push("audit-mutated");
+		issueRefs.push("issue-ref-mutated");
+		issuePath.push("mutated");
+
+		const oversized = evidence.find((fact) => fact.effectRunId === "run-oversized");
+		expect(oversized?.output).toEqual({ kind: "tool-output", value: undefined });
+		expect(oversized?.issues).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({
+					code: "work-item-evidence-public-material-redacted",
+					details: expect.objectContaining({
+						area: "output.value.content",
+						reason: "oversized-inline-text",
+					}),
+				}),
+			]),
+		);
+		expect(JSON.stringify(oversized)).not.toContain("large-content-");
+
+		const mutable = evidence.find((fact) => fact.effectRunId === "run-mutable");
+		expect(mutable?.auditRefs).toEqual(["audit-1"]);
+		expect(mutable?.error?.refs).toEqual(["issue-ref-1"]);
+		expect(mutable?.error?.path).toEqual(["error", 0]);
+		expect(mutable?.issues?.[0]?.refs).toEqual(["issue-ref-1"]);
+		expect(mutable?.issues?.[0]?.path).toEqual(["error", 0]);
+		expect(Object.isFrozen(mutable?.auditRefs)).toBe(true);
+		expect(Object.isFrozen(mutable?.error?.refs)).toBe(true);
+		expect(Object.isFrozen(mutable?.error?.path)).toBe(true);
+	});
+
+	it("emits DataIssue instead of evidence for stale or unknown WorkItem/effectRun refs", () => {
+		const g = graph();
+		const workItems = g.node<WorkItemSeed>([], null, { name: "workItems" });
+		const effectRuns = g.node<EffectRun>([], null, { name: "effectRuns" });
+		const results = g.node<EffectRunResult>([], null, { name: "results" });
+		const mapper = workItemEffectResultMapper(g, {
+			workItems,
+			effectRuns,
+			effectRunResults: results,
+		});
+		const evidence: unknown[] = [];
+		const issues: unknown[] = [];
+		mapper.evidence.subscribe((msg) => msg[0] === "DATA" && evidence.push(msg[1]));
+		mapper.issues.subscribe((msg) => msg[0] === "DATA" && issues.push(msg[1]));
+		workItems.down([["DATA", workItemSeed("wi-1")]]);
+		effectRuns.down([
+			[
+				"DATA",
+				effectRun({
+					effectRunId: "run-1",
+					subjectRefs: [{ kind: "work-item", id: "wi-1" }],
+					goal: { kind: "verify" },
+				}),
+			],
+		]);
+
+		results.down([
+			[
+				"DATA",
+				{
+					kind: "effect-run-result",
+					resultId: "wrong-work-item",
+					status: "completed",
+					effectRunId: "run-1",
+					subjectRefs: [{ kind: "work-item", id: "wi-2" }],
+					output: { kind: "ok" },
+				},
+			],
+			[
+				"DATA",
+				{
+					kind: "effect-run-result",
+					resultId: "wrong-effect-run-ref",
+					status: "completed",
+					effectRunId: "run-1",
+					sourceRefs: [{ kind: "effect-run", id: "other-run" }],
+					output: { kind: "ok" },
+				},
+			],
+			[
+				"DATA",
+				{
+					kind: "effect-run-result",
+					resultId: "unknown-run",
+					status: "completed",
+					effectRunId: "missing-run",
+					output: { kind: "ok" },
+				},
+			],
+			[
+				"DATA",
+				{
+					kind: "effect-run-result",
+					resultId: "wrong-work-item-source-ref",
+					status: "completed",
+					effectRunId: "run-1",
+					sourceRefs: [{ kind: "work-item", id: "wi-2" }],
+					output: { kind: "ok" },
+				},
+			],
+			[
+				"DATA",
+				{
+					kind: "effect-run-result",
+					resultId: "ambiguous-work-item-subjects",
+					status: "completed",
+					effectRunId: "run-1",
+					subjectRefs: [
+						{ kind: "work-item", id: "wi-1" },
+						{ kind: "work-item", id: "wi-2" },
+					],
+					output: { kind: "ok" },
+				},
+			],
+		]);
+
+		expect(evidence).toEqual([]);
+		expect(issues.map((issue) => (issue as { code: string }).code)).toEqual([
+			"stale-work-item-source-ref",
+			"stale-effect-run-source-ref",
+			"unknown-effect-run-result",
+			"stale-work-item-source-ref",
+			"stale-work-item-source-ref",
+		]);
+	});
+
+	it("requires explicit WorkItem seed facts before recording evidence", () => {
+		const g = graph();
+		const workItems = g.node<WorkItemSeed>([], null, { name: "workItems" });
+		const effectRuns = g.node<EffectRun>([], null, { name: "effectRuns" });
+		const results = g.node<EffectRunResult>([], null, { name: "results" });
+		const mapper = workItemEffectResultMapper(g, {
+			workItems,
+			effectRuns,
+			effectRunResults: results,
+		});
+		const evidence: unknown[] = [];
+		const issues: unknown[] = [];
+		mapper.evidence.subscribe((msg) => msg[0] === "DATA" && evidence.push(msg[1]));
+		mapper.issues.subscribe((msg) => msg[0] === "DATA" && issues.push(msg[1]));
+		workItems.down([["DATA", workItemSeed("wi-other")]]);
+		effectRuns.down([
+			[
+				"DATA",
+				effectRun({
+					effectRunId: "run-1",
+					subjectRefs: [{ kind: "work-item", id: "wi-missing" }],
+					goal: { kind: "verify" },
+				}),
+			],
+		]);
+		results.down([
+			[
+				"DATA",
+				{
+					kind: "effect-run-result",
+					resultId: "run-1:result",
+					status: "completed",
+					effectRunId: "run-1",
+					output: { kind: "ok" },
+				},
+			],
+		]);
+
+		expect(evidence).toEqual([]);
+		expect(issues.at(-1)).toMatchObject({ code: "unknown-work-item-evidence-target" });
+	});
+});
diff --git a/packages/ts/src/__tests__/agent-runtime.part-10.test.ts b/packages/ts/src/__tests__/agent-runtime.part-10.test.ts
new file mode 100644
index 00000000..3a89617b
--- /dev/null
+++ b/packages/ts/src/__tests__/agent-runtime.part-10.test.ts
@@ -0,0 +1,872 @@
+import { describe, expect, it } from "vitest";
+import { graph } from "../graph/graph.js";
+import {
+	type AgentRequestIssued,
+	buildToolProviderAdapterInputs,
+	type EffectRun,
+	type EffectRunResult,
+	type ExecutorRoute,
+	effectRun,
+	localBuiltinToolProviderCatalog,
+	resolveToolProviderExecutionPolicies,
+	type ToolProviderAdapterInput,
+} from "../orchestration/agent-runtime.js";
+import {
+	type WorkItemDomainActionAdmissionDecision,
+	type WorkItemDomainActionProposal,
+	type WorkItemEffectMappingPolicy,
+	type WorkItemEffectRequested,
+	type WorkItemEvidenceRecorded,
+	type WorkItemSeed,
+	workItemDomainActionProposalProjector,
+	workItemEffectResultMapper,
+} from "../orchestration/work-item-runtime.js";
+
+function _issued(
+	requestId: string,
+	operationId: string,
+	requestKind: AgentRequestIssued["requestKind"],
+	inputKind?: string,
+): AgentRequestIssued {
+	return {
+		kind: "issued",
+		requestId,
+		operationId,
+		effectRunId: "run-1",
+		requestKind,
+		required: true,
+		input:
+			inputKind === undefined
+				? undefined
+				: { inputId: `${requestId}:input`, inputKind, dataMode: "summary", summary: inputKind },
+	};
+}
+
+function toolRequest(
+	requestId: string,
+	operationId: string,
+	toolName: string,
+	operation?: string,
+): AgentRequestIssued {
+	return {
+		kind: "issued",
+		requestId,
+		operationId,
+		effectRunId: "run-1",
+		requestKind: "executor",
+		required: true,
+		input: {
+			inputId: `${requestId}:input`,
+			inputKind: "tool-call",
+			dataMode: "inline",
+			value: {
+				kind: "tool-call",
+				toolName,
+				operation,
+				arguments: { path: "README.md" },
+			},
+		},
+	};
+}
+
+const forbiddenRetentionPayloadPattern =
+	/SCORER_SECRET|SCORER_RAW|rawResponse|stdout|stderr|stack|apiKey|password|arguments|providerClient|oauthState|subprocessHandle|transport|sdkObject/i;
+
+const retentionScorerEntryKeys: Record<string, readonly string[]> = {
+	adapterInputs: [
+		"adapterInputId",
+		"executorId",
+		"insertedAtMs",
+		"key",
+		"operationId",
+		"profileId",
+		"providerId",
+		"requestId",
+		"routeId",
+		"sequence",
+		"status",
+	],
+	runRequests: [
+		"adapterInputId",
+		"attempt",
+		"executorId",
+		"key",
+		"operationId",
+		"profileId",
+		"providerId",
+		"reason",
+		"requestId",
+		"requestedAtMs",
+		"routeId",
+		"runId",
+		"sequence",
+	],
+	executions: [
+		"adapterInputId",
+		"attempt",
+		"executorId",
+		"key",
+		"occurredAtMs",
+		"operationId",
+		"outcomeId",
+		"profileId",
+		"providerId",
+		"reason",
+		"requestId",
+		"routeId",
+		"runId",
+		"sequence",
+		"status",
+	],
+	runStatuses: [
+		"adapterInputId",
+		"attempt",
+		"issueCode",
+		"key",
+		"occurredAtMs",
+		"operationId",
+		"outcomeId",
+		"requestId",
+		"runId",
+		"sequence",
+		"status",
+	],
+	runIssues: [
+		"adapterInputId",
+		"attempt",
+		"issueCode",
+		"key",
+		"occurredAtMs",
+		"operationId",
+		"requestId",
+		"runId",
+		"sequence",
+		"severity",
+		"subjectId",
+	],
+	retentionEvidence: [
+		"adapterInputId",
+		"attemptHighWater",
+		"evidenceKind",
+		"key",
+		"occurredAtMs",
+		"reason",
+		"sequence",
+	],
+};
+
+function _expectRetentionScorerEntryPayloadSafe(index: string, entry: unknown): void {
+	expect(entry).toBeTypeOf("object");
+	expect(Array.isArray(entry)).toBe(false);
+	const record = entry as Record<string, unknown>;
+	const allowed = retentionScorerEntryKeys[index];
+	expect(allowed, `unknown retention scorer index ${index}`).toBeDefined();
+	for (const [key, value] of Object.entries(record)) {
+		expect(allowed).toContain(key);
+		expect(value === undefined || typeof value === "string" || typeof value === "number").toBe(
+			true,
+		);
+		if (key === "key") expect(value).toEqual(expect.stringMatching(/^key:[a-z0-9]+:\d+$/));
+	}
+	expectNoForbiddenRetentionPayload(record);
+}
+
+function expectNoForbiddenRetentionPayload(value: unknown): void {
+	expect(JSON.stringify(value)).not.toMatch(forbiddenRetentionPayloadPattern);
+}
+
+function _readyToolProviderAdapterInput(
+	providerId: string,
+	requestId: string,
+): ToolProviderAdapterInput {
+	const catalog = localBuiltinToolProviderCatalog({ providerId });
+	const profile = catalog.profiles[0];
+	if (profile === undefined) throw new Error("expected profile");
+	const request = toolRequest(requestId, `${requestId}-op`, "file.read", "read");
+	const route: ExecutorRoute = {
+		kind: "executor-route",
+		routeId: `${requestId}-route`,
+		requestId: request.requestId,
+		operationId: request.operationId,
+		executorId: profile.executorId,
+		profileId: profile.profileId,
+		inputKind: "tool-call",
+	};
+	const resolutions = resolveToolProviderExecutionPolicies({
+		request,
+		routes: [route],
+		catalogs: [catalog],
+	});
+	const input = buildToolProviderAdapterInputs({
+		requests: [request],
+		routes: [route],
+		catalogs: [catalog],
+		resolutions,
+	})[0];
+	if (input === undefined || input.status !== "ready") throw new Error("expected ready input");
+	return input;
+}
+
+function workItemSeed(workItemId: string): WorkItemSeed {
+	return {
+		kind: "work-item",
+		workItemId,
+		sourceRefs: [{ kind: "work-item", id: workItemId }],
+		workItemKind: "issue",
+		lifecycleStatus: "open",
+	};
+}
+
+function _workItemActionProposal(
+	proposalId: string,
+	actionKind: string,
+	opts: Partial<WorkItemDomainActionProposal> = {},
+): WorkItemDomainActionProposal {
+	return {
+		kind: "work-item-domain-action-proposal",
+		proposalId,
+		workItemId: opts.workItemId ?? "wi-1",
+		actionKind,
+		effectRunId: opts.effectRunId ?? "run-1",
+		effectRunResultId: opts.effectRunResultId ?? "run-1:result",
+		evidenceId: opts.evidenceId ?? "wi-1:run-1:run-1:result",
+		policyId: opts.policyId ?? "policy-propose",
+		sourceRefs: opts.sourceRefs,
+		metadata: opts.metadata,
+	};
+}
+
+function _workItemAdmissionDecision(
+	decisionId: string,
+	admissionId: string,
+	proposalId: string,
+	outcome: WorkItemDomainActionAdmissionDecision["outcome"],
+	opts: Partial<WorkItemDomainActionAdmissionDecision> = {},
+): WorkItemDomainActionAdmissionDecision {
+	return {
+		kind: "work-item-domain-action-admission-decision",
+		decisionId,
+		admissionId,
+		proposalId,
+		outcome,
+		policyId: opts.policyId,
+		reason: opts.reason,
+		targetProposalId: opts.targetProposalId,
+		targetAdmissionId: opts.targetAdmissionId,
+		sourceRefs: opts.sourceRefs,
+		decidedAtMs: opts.decidedAtMs,
+		metadata: opts.metadata,
+	};
+}
+
+describe("CSP-8 experimental agent runtime kernel (D236) — part 10", () => {
+	it("emits DataIssue and audit for duplicate WorkItem evidence mapping", () => {
+		const g = graph();
+		const workItems = g.node<WorkItemSeed>([], null, { name: "workItems" });
+		const effectRuns = g.node<EffectRun>([], null, { name: "effectRuns" });
+		const results = g.node<EffectRunResult>([], null, { name: "results" });
+		const mapper = workItemEffectResultMapper(g, {
+			workItems,
+			effectRuns,
+			effectRunResults: results,
+		});
+		const evidence: unknown[] = [];
+		const issues: unknown[] = [];
+		const audit: unknown[] = [];
+		mapper.evidence.subscribe((msg) => msg[0] === "DATA" && evidence.push(msg[1]));
+		mapper.issues.subscribe((msg) => msg[0] === "DATA" && issues.push(msg[1]));
+		mapper.audit.subscribe((msg) => msg[0] === "DATA" && audit.push(msg[1]));
+		workItems.down([["DATA", workItemSeed("wi-1")]]);
+		effectRuns.down([
+			[
+				"DATA",
+				effectRun({
+					effectRunId: "run-1",
+					subjectRefs: [{ kind: "work-item", id: "wi-1" }],
+					goal: { kind: "verify" },
+				}),
+			],
+		]);
+		const result: EffectRunResult = {
+			kind: "effect-run-result",
+			resultId: "run-1:result",
+			status: "completed",
+			effectRunId: "run-1",
+			output: { kind: "ok" },
+		};
+		results.down([["DATA", result]]);
+		results.down([["DATA", result]]);
+
+		expect(evidence).toHaveLength(1);
+		expect(issues.at(-1)).toMatchObject({ code: "duplicate-work-item-evidence" });
+		expect(audit.at(-1)).toMatchObject({ kind: "work-item-evidence-mapping-issue" });
+	});
+
+	it("records evidence when WorkItemEffectRequested explicitly references a record mapping policy", () => {
+		const g = graph();
+		const workItems = g.node<WorkItemSeed>([], null, { name: "workItems" });
+		const effectRuns = g.node<EffectRun>([], null, { name: "effectRuns" });
+		const results = g.node<EffectRunResult>([], null, { name: "results" });
+		const effectRequests = g.node<WorkItemEffectRequested>([], null, {
+			name: "workItemEffectRequests",
+		});
+		const policies = g.node<WorkItemEffectMappingPolicy>([], null, { name: "policies" });
+		const mapper = workItemEffectResultMapper(g, {
+			workItems,
+			effectRuns,
+			effectRunResults: results,
+			effectRequests,
+			mappingPolicies: [policies],
+			now: () => 950,
+		});
+		const evidence: WorkItemEvidenceRecorded[] = [];
+		const issues: unknown[] = [];
+		mapper.evidence.subscribe(
+			(msg) => msg[0] === "DATA" && evidence.push(msg[1] as WorkItemEvidenceRecorded),
+		);
+		mapper.issues.subscribe((msg) => msg[0] === "DATA" && issues.push(msg[1]));
+		workItems.down([["DATA", workItemSeed("wi-1")]]);
+		policies.down([
+			[
+				"DATA",
+				{
+					kind: "work-item-effect-mapping-policy",
+					policyId: "policy-record-verification",
+					effectKinds: ["verification"],
+					evidence: { behavior: "record" },
+				},
+			],
+		]);
+		effectRequests.down([
+			[
+				"DATA",
+				{
+					kind: "work-item-effect-requested",
+					requestId: "wi-effect-1",
+					workItemId: "wi-1",
+					effectRunId: "run-1",
+					effectKind: "verification",
+					goal: { kind: "verify" },
+					policyRefs: [
+						{ kind: "work-item-effect-mapping-policy", id: "policy-record-verification" },
+					],
+				},
+			],
+		]);
+		effectRuns.down([
+			[
+				"DATA",
+				effectRun({
+					effectRunId: "run-1",
+					subjectRefs: [{ kind: "work-item", id: "wi-1" }],
+					goal: { kind: "verify" },
+				}),
+			],
+		]);
+		results.down([
+			[
+				"DATA",
+				{
+					kind: "effect-run-result",
+					resultId: "run-1:result",
+					status: "completed",
+					effectRunId: "run-1",
+					output: { kind: "ok" },
+				},
+			],
+		]);
+
+		expect(issues).toEqual([]);
+		expect(evidence.at(-1)).toMatchObject({
+			workItemId: "wi-1",
+			effectRunId: "run-1",
+			status: "completed",
+			recordedAtMs: 950,
+		});
+	});
+
+	it("rejects a missing referenced WorkItemEffectMappingPolicy and clears pending effect request", () => {
+		const g = graph();
+		const workItems = g.node<WorkItemSeed>([], null, { name: "workItems" });
+		const effectRuns = g.node<EffectRun>([], null, { name: "effectRuns" });
+		const results = g.node<EffectRunResult>([], null, { name: "results" });
+		const effectRequests = g.node<WorkItemEffectRequested>([], null, {
+			name: "workItemEffectRequests",
+		});
+		const policies = g.node<WorkItemEffectMappingPolicy>([], null, { name: "policies" });
+		const mapper = workItemEffectResultMapper(g, {
+			workItems,
+			effectRuns,
+			effectRunResults: results,
+			effectRequests,
+			mappingPolicies: [policies],
+		});
+		const evidence: unknown[] = [];
+		const issues: unknown[] = [];
+		const views: unknown[] = [];
+		mapper.evidence.subscribe((msg) => msg[0] === "DATA" && evidence.push(msg[1]));
+		mapper.issues.subscribe((msg) => msg[0] === "DATA" && issues.push(msg[1]));
+		mapper.views.subscribe((msg) => msg[0] === "DATA" && views.push(msg[1]));
+		workItems.down([["DATA", workItemSeed("wi-1")]]);
+		policies.down([
+			[
+				"DATA",
+				{
+					kind: "work-item-effect-mapping-policy",
+					policyId: "other-policy",
+					effectKinds: ["verification"],
+					evidence: { behavior: "record" },
+				},
+			],
+		]);
+		effectRequests.down([
+			[
+				"DATA",
+				{
+					kind: "work-item-effect-requested",
+					requestId: "wi-effect-1",
+					workItemId: "wi-1",
+					effectRunId: "run-1",
+					effectKind: "verification",
+					goal: { kind: "verify" },
+					policyRefs: [{ kind: "work-item-effect-mapping-policy", id: "missing-policy" }],
+				},
+			],
+		]);
+		effectRuns.down([
+			[
+				"DATA",
+				effectRun({
+					effectRunId: "run-1",
+					subjectRefs: [{ kind: "work-item", id: "wi-1" }],
+					goal: { kind: "verify" },
+				}),
+			],
+		]);
+		results.down([
+			[
+				"DATA",
+				{
+					kind: "effect-run-result",
+					resultId: "run-1:result",
+					status: "completed",
+					effectRunId: "run-1",
+					output: { kind: "ok" },
+				},
+			],
+		]);
+
+		expect(evidence).toEqual([]);
+		expect(issues.at(-1)).toMatchObject({ code: "missing-work-item-effect-mapping-policy" });
+		expect(
+			(views.at(-1) as { pendingEffectRequests: readonly WorkItemEffectRequested[] })
+				.pendingEffectRequests,
+		).toEqual([]);
+	});
+
+	it("rejects unsupported WorkItemEffectMappingPolicy behavior without lifecycle side effects", () => {
+		const g = graph();
+		const workItems = g.node<WorkItemSeed>([], null, { name: "workItems" });
+		const effectRuns = g.node<EffectRun>([], null, { name: "effectRuns" });
+		const results = g.node<EffectRunResult>([], null, { name: "results" });
+		const effectRequests = g.node<WorkItemEffectRequested>([], null, {
+			name: "workItemEffectRequests",
+		});
+		const policies = g.node<WorkItemEffectMappingPolicy>([], null, { name: "policies" });
+		const mapper = workItemEffectResultMapper(g, {
+			workItems,
+			effectRuns,
+			effectRunResults: results,
+			effectRequests,
+			mappingPolicies: [policies],
+		});
+		const evidence: unknown[] = [];
+		const statuses: unknown[] = [];
+		const issues: unknown[] = [];
+		mapper.evidence.subscribe((msg) => msg[0] === "DATA" && evidence.push(msg[1]));
+		mapper.status.subscribe((msg) => msg[0] === "DATA" && statuses.push(msg[1]));
+		mapper.issues.subscribe((msg) => msg[0] === "DATA" && issues.push(msg[1]));
+		workItems.down([["DATA", workItemSeed("wi-1")]]);
+		policies.down([
+			[
+				"DATA",
+				{
+					kind: "work-item-effect-mapping-policy",
+					policyId: "policy-close",
+					effectKinds: ["verification"],
+					evidence: { behavior: "close" },
+				} as unknown as WorkItemEffectMappingPolicy,
+			],
+		]);
+		effectRequests.down([
+			[
+				"DATA",
+				{
+					kind: "work-item-effect-requested",
+					requestId: "wi-effect-1",
+					workItemId: "wi-1",
+					effectRunId: "run-1",
+					effectKind: "verification",
+					goal: { kind: "verify" },
+					policyRefs: [{ kind: "work-item-effect-mapping-policy", id: "policy-close" }],
+				},
+			],
+		]);
+		effectRuns.down([
+			[
+				"DATA",
+				effectRun({
+					effectRunId: "run-1",
+					subjectRefs: [{ kind: "work-item", id: "wi-1" }],
+					goal: { kind: "verify" },
+				}),
+			],
+		]);
+		results.down([
+			[
+				"DATA",
+				{
+					kind: "effect-run-result",
+					resultId: "run-1:result",
+					status: "completed",
+					effectRunId: "run-1",
+					output: { kind: "ok" },
+				},
+			],
+		]);
+
+		expect(evidence).toEqual([]);
+		expect(issues.at(-1)).toMatchObject({ code: "unsupported-work-item-evidence-behavior" });
+		expect(statuses.at(-1)).toMatchObject({ state: "mapping-issue" });
+		expect(statuses).not.toContainEqual(expect.objectContaining({ state: "closed" }));
+		expect(statuses).not.toContainEqual(expect.objectContaining({ state: "resolved" }));
+	});
+
+	it("validates EffectRun policyRefs when raw WorkItemEffectRequested facts are not supplied", () => {
+		const g = graph();
+		const workItems = g.node<WorkItemSeed>([], null, { name: "workItems" });
+		const effectRuns = g.node<EffectRun>([], null, { name: "effectRuns" });
+		const results = g.node<EffectRunResult>([], null, { name: "results" });
+		const policies = g.node<WorkItemEffectMappingPolicy>([], null, { name: "policies" });
+		const mapper = workItemEffectResultMapper(g, {
+			workItems,
+			effectRuns,
+			effectRunResults: results,
+			mappingPolicies: [policies],
+		});
+		const evidence: unknown[] = [];
+		const issues: unknown[] = [];
+		mapper.evidence.subscribe((msg) => msg[0] === "DATA" && evidence.push(msg[1]));
+		mapper.issues.subscribe((msg) => msg[0] === "DATA" && issues.push(msg[1]));
+		workItems.down([["DATA", workItemSeed("wi-1")]]);
+		policies.down([
+			[
+				"DATA",
+				{
+					kind: "work-item-effect-mapping-policy",
+					policyId: "other-policy",
+					effectKinds: ["verification"],
+					evidence: { behavior: "record" },
+				},
+			],
+		]);
+		effectRuns.down([
+			[
+				"DATA",
+				effectRun({
+					effectRunId: "run-1",
+					subjectRefs: [{ kind: "work-item", id: "wi-1" }],
+					sourceRefs: [{ kind: "work-item-effect-request", id: "wi-effect-1" }],
+					goal: { kind: "verify" },
+					policyRefs: [{ kind: "work-item-effect-mapping-policy", id: "missing-policy" }],
+					metadata: { effectKind: "verification" },
+				}),
+			],
+		]);
+		results.down([
+			[
+				"DATA",
+				{
+					kind: "effect-run-result",
+					resultId: "run-1:result",
+					status: "completed",
+					effectRunId: "run-1",
+					output: { kind: "ok" },
+				},
+			],
+		]);
+
+		expect(evidence).toEqual([]);
+		expect(issues.at(-1)).toMatchObject({ code: "missing-work-item-effect-mapping-policy" });
+	});
+
+	it("rejects ambiguous WorkItemEffectRequested policy joins for duplicate EffectRun ids", () => {
+		const g = graph();
+		const workItems = g.node<WorkItemSeed>([], null, { name: "workItems" });
+		const effectRuns = g.node<EffectRun>([], null, { name: "effectRuns" });
+		const results = g.node<EffectRunResult>([], null, { name: "results" });
+		const effectRequests = g.node<WorkItemEffectRequested>([], null, {
+			name: "workItemEffectRequests",
+		});
+		const mapper = workItemEffectResultMapper(g, {
+			workItems,
+			effectRuns,
+			effectRunResults: results,
+			effectRequests,
+		});
+		const evidence: unknown[] = [];
+		const issues: unknown[] = [];
+		const views: unknown[] = [];
+		mapper.evidence.subscribe((msg) => msg[0] === "DATA" && evidence.push(msg[1]));
+		mapper.issues.subscribe((msg) => msg[0] === "DATA" && issues.push(msg[1]));
+		mapper.views.subscribe((msg) => msg[0] === "DATA" && views.push(msg[1]));
+		workItems.down([["DATA", workItemSeed("wi-1")]]);
+		effectRequests.down([
+			[
+				"DATA",
+				{
+					kind: "work-item-effect-requested",
+					requestId: "wi-effect-1",
+					workItemId: "wi-1",
+					effectRunId: "run-1",
+					effectKind: "verification",
+					goal: { kind: "verify" },
+				},
+			],
+			[
+				"DATA",
+				{
+					kind: "work-item-effect-requested",
+					requestId: "wi-effect-2",
+					workItemId: "wi-1",
+					effectRunId: "run-1",
+					effectKind: "verification",
+					goal: { kind: "verify-again" },
+				},
+			],
+		]);
+		effectRuns.down([
+			[
+				"DATA",
+				effectRun({
+					effectRunId: "run-1",
+					subjectRefs: [{ kind: "work-item", id: "wi-1" }],
+					goal: { kind: "verify" },
+				}),
+			],
+		]);
+		results.down([
+			[
+				"DATA",
+				{
+					kind: "effect-run-result",
+					resultId: "run-1:result",
+					status: "completed",
+					effectRunId: "run-1",
+					output: { kind: "ok" },
+				},
+			],
+		]);
+
+		expect(evidence).toEqual([]);
+		expect(issues).toContainEqual(
+			expect.objectContaining({ code: "duplicate-work-item-effect-request" }),
+		);
+		expect(
+			(views.at(-1) as { pendingEffectRequests: readonly WorkItemEffectRequested[] })
+				.pendingEffectRequests,
+		).toEqual([]);
+	});
+
+	it("keeps evidence-only default mapping when a WorkItemEffectRequested has no policyRefs", () => {
+		const g = graph();
+		const workItems = g.node<WorkItemSeed>([], null, { name: "workItems" });
+		const effectRuns = g.node<EffectRun>([], null, { name: "effectRuns" });
+		const results = g.node<EffectRunResult>([], null, { name: "results" });
+		const effectRequests = g.node<WorkItemEffectRequested>([], null, {
+			name: "workItemEffectRequests",
+		});
+		const policies = g.node<WorkItemEffectMappingPolicy>([], null, { name: "policies" });
+		const mapper = workItemEffectResultMapper(g, {
+			workItems,
+			effectRuns,
+			effectRunResults: results,
+			effectRequests,
+			mappingPolicies: [policies],
+		});
+		const evidence: unknown[] = [];
+		const issues: unknown[] = [];
+		mapper.evidence.subscribe((msg) => msg[0] === "DATA" && evidence.push(msg[1]));
+		mapper.issues.subscribe((msg) => msg[0] === "DATA" && issues.push(msg[1]));
+		workItems.down([["DATA", workItemSeed("wi-1")]]);
+		policies.down([
+			[
+				"DATA",
+				{
+					kind: "work-item-effect-mapping-policy",
+					policyId: "unreferenced-policy",
+					effectKinds: ["different-kind"],
+					evidence: { behavior: "record" },
+				},
+			],
+		]);
+		effectRequests.down([
+			[
+				"DATA",
+				{
+					kind: "work-item-effect-requested",
+					requestId: "wi-effect-1",
+					workItemId: "wi-1",
+					effectRunId: "run-1",
+					effectKind: "verification",
+					goal: { kind: "verify" },
+				},
+			],
+		]);
+		effectRuns.down([
+			[
+				"DATA",
+				effectRun({
+					effectRunId: "run-1",
+					subjectRefs: [{ kind: "work-item", id: "wi-1" }],
+					goal: { kind: "verify" },
+				}),
+			],
+		]);
+		results.down([
+			[
+				"DATA",
+				{
+					kind: "effect-run-result",
+					resultId: "run-1:result",
+					status: "completed",
+					effectRunId: "run-1",
+					output: { kind: "ok" },
+				},
+			],
+		]);
+
+		expect(issues).toEqual([]);
+		expect(evidence).toHaveLength(1);
+	});
+
+	it("proposes WorkItem domain actions only from explicit mapping-policy evidence", () => {
+		const g = graph();
+		const workItems = g.node<WorkItemSeed>([], null, { name: "workItems" });
+		const effectRuns = g.node<EffectRun>([], null, { name: "effectRuns" });
+		const results = g.node<EffectRunResult>([], null, { name: "results" });
+		const policies = g.node<WorkItemEffectMappingPolicy>([], null, { name: "policies" });
+		const mapper = workItemEffectResultMapper(g, {
+			workItems,
+			effectRuns,
+			effectRunResults: results,
+			mappingPolicies: [policies],
+			now: () => 1000,
+		});
+		const proposals = workItemDomainActionProposalProjector(g, {
+			workItems,
+			evidence: mapper.evidence,
+			effectRunResults: results,
+			mappingPolicies: [policies],
+			now: () => 1100,
+		});
+		const emitted: WorkItemDomainActionProposal[] = [];
+		const statuses: unknown[] = [];
+		const issues: unknown[] = [];
+		const views: unknown[] = [];
+		mapper.evidence.subscribe(() => {});
+		proposals.proposals.subscribe(
+			(msg) => msg[0] === "DATA" && emitted.push(msg[1] as WorkItemDomainActionProposal),
+		);
+		proposals.status.subscribe((msg) => msg[0] === "DATA" && statuses.push(msg[1]));
+		proposals.issues.subscribe((msg) => msg[0] === "DATA" && issues.push(msg[1]));
+		proposals.views.subscribe((msg) => msg[0] === "DATA" && views.push(msg[1]));
+		workItems.down([["DATA", workItemSeed("wi-1")]]);
+		policies.down([
+			[
+				"DATA",
+				{
+					kind: "work-item-effect-mapping-policy",
+					policyId: "policy-propose-verification",
+					effectKinds: ["verification"],
+					evidence: { behavior: "record" },
+					actionProposals: [
+						{
+							actionKind: "mark-verification-ready",
+							statuses: ["completed"],
+							outputKinds: ["verified"],
+							payloadFrom: "output",
+							reason: "verified output may justify an explicit domain action",
+						},
+					],
+				},
+			],
+		]);
+		effectRuns.down([
+			[
+				"DATA",
+				effectRun({
+					effectRunId: "run-1",
+					subjectRefs: [{ kind: "work-item", id: "wi-1" }],
+					goal: { kind: "verify" },
+					policyRefs: [
+						{ kind: "work-item-effect-mapping-policy", id: "policy-propose-verification" },
+					],
+					metadata: { effectKind: "verification" },
+				}),
+			],
+		]);
+		results.down([
+			[
+				"DATA",
+				{
+					kind: "effect-run-result",
+					resultId: "run-1:result",
+					status: "completed",
+					effectRunId: "run-1",
+					output: { kind: "verified", value: { ok: true } },
+					metadata: { effectKind: "verification" },
+				},
+			],
+		]);
+
+		expect(issues).toEqual([]);
+		expect(emitted.at(-1)).toMatchObject({
+			kind: "work-item-domain-action-proposal",
+			workItemId: "wi-1",
+			actionKind: "mark-verification-ready",
+			effectRunId: "run-1",
+			effectRunResultId: "run-1:result",
+			policyId: "policy-propose-verification",
+			payload: { kind: "verified", value: { ok: true } },
+			proposedAtMs: 1100,
+		});
+		expect(emitted.at(-1)?.proposalId).toBe(
+			"wi-1:run-1:run-1:result:policy-propose-verification:0:mark-verification-ready",
+		);
+		expect(emitted.at(-1)?.sourceRefs).toEqual(
+			expect.arrayContaining([
+				{ kind: "work-item", id: "wi-1" },
+				{ kind: "effect-run", id: "run-1" },
+				{ kind: "effect-run-result", id: "run-1:result" },
+				{ kind: "work-item-effect-mapping-policy", id: "policy-propose-verification" },
+			]),
+		);
+		expect(statuses.at(-1)).toMatchObject({
+			state: "domain-action-proposed",
+			proposalId: emitted.at(-1)?.proposalId,
+		});
+		expect(statuses).not.toContainEqual(expect.objectContaining({ state: "closed" }));
+		expect(statuses).not.toContainEqual(expect.objectContaining({ state: "resolved" }));
+		expect(statuses).not.toContainEqual(expect.objectContaining({ state: "approved" }));
+		expect(statuses).not.toContainEqual(expect.objectContaining({ state: "verified" }));
+		const latestView = views.at(-1) as {
+			proposalsByWorkItem: Map<string, readonly WorkItemDomainActionProposal[]>;
+			proposalsByEvidence: Map<string, readonly WorkItemDomainActionProposal[]>;
+		};
+		expect(latestView.proposalsByWorkItem.get("wi-1")).toHaveLength(1);
+		expect(latestView.proposalsByEvidence.get("wi-1:run-1:run-1:result")?.[0].actionKind).toBe(
+			"mark-verification-ready",
+		);
+	});
+});
diff --git a/packages/ts/src/__tests__/agent-runtime.part-11.test.ts b/packages/ts/src/__tests__/agent-runtime.part-11.test.ts
new file mode 100644
index 00000000..1464a46c
--- /dev/null
+++ b/packages/ts/src/__tests__/agent-runtime.part-11.test.ts
@@ -0,0 +1,893 @@
+import { describe, expect, it } from "vitest";
+import { graph } from "../graph/graph.js";
+import {
+	type AgentRequestIssued,
+	buildToolProviderAdapterInputs,
+	type EffectRunResult,
+	type ExecutorRoute,
+	localBuiltinToolProviderCatalog,
+	resolveToolProviderExecutionPolicies,
+	type ToolProviderAdapterInput,
+} from "../orchestration/agent-runtime.js";
+import {
+	type WorkItemDomainActionAdmission,
+	type WorkItemDomainActionAdmissionDecision,
+	type WorkItemDomainActionAdmissionPolicy,
+	type WorkItemDomainActionProposal,
+	type WorkItemEffectMappingPolicy,
+	type WorkItemEffectRequested,
+	type WorkItemEvidenceRecorded,
+	type WorkItemSeed,
+	workItemDomainActionAdmissionProjector,
+	workItemDomainActionProposalProjector,
+	workItemEffectRunProjector,
+} from "../orchestration/work-item-runtime.js";
+
+function _issued(
+	requestId: string,
+	operationId: string,
+	requestKind: AgentRequestIssued["requestKind"],
+	inputKind?: string,
+): AgentRequestIssued {
+	return {
+		kind: "issued",
+		requestId,
+		operationId,
+		effectRunId: "run-1",
+		requestKind,
+		required: true,
+		input:
+			inputKind === undefined
+				? undefined
+				: { inputId: `${requestId}:input`, inputKind, dataMode: "summary", summary: inputKind },
+	};
+}
+
+function toolRequest(
+	requestId: string,
+	operationId: string,
+	toolName: string,
+	operation?: string,
+): AgentRequestIssued {
+	return {
+		kind: "issued",
+		requestId,
+		operationId,
+		effectRunId: "run-1",
+		requestKind: "executor",
+		required: true,
+		input: {
+			inputId: `${requestId}:input`,
+			inputKind: "tool-call",
+			dataMode: "inline",
+			value: {
+				kind: "tool-call",
+				toolName,
+				operation,
+				arguments: { path: "README.md" },
+			},
+		},
+	};
+}
+
+const forbiddenRetentionPayloadPattern =
+	/SCORER_SECRET|SCORER_RAW|rawResponse|stdout|stderr|stack|apiKey|password|arguments|providerClient|oauthState|subprocessHandle|transport|sdkObject/i;
+
+const retentionScorerEntryKeys: Record<string, readonly string[]> = {
+	adapterInputs: [
+		"adapterInputId",
+		"executorId",
+		"insertedAtMs",
+		"key",
+		"operationId",
+		"profileId",
+		"providerId",
+		"requestId",
+		"routeId",
+		"sequence",
+		"status",
+	],
+	runRequests: [
+		"adapterInputId",
+		"attempt",
+		"executorId",
+		"key",
+		"operationId",
+		"profileId",
+		"providerId",
+		"reason",
+		"requestId",
+		"requestedAtMs",
+		"routeId",
+		"runId",
+		"sequence",
+	],
+	executions: [
+		"adapterInputId",
+		"attempt",
+		"executorId",
+		"key",
+		"occurredAtMs",
+		"operationId",
+		"outcomeId",
+		"profileId",
+		"providerId",
+		"reason",
+		"requestId",
+		"routeId",
+		"runId",
+		"sequence",
+		"status",
+	],
+	runStatuses: [
+		"adapterInputId",
+		"attempt",
+		"issueCode",
+		"key",
+		"occurredAtMs",
+		"operationId",
+		"outcomeId",
+		"requestId",
+		"runId",
+		"sequence",
+		"status",
+	],
+	runIssues: [
+		"adapterInputId",
+		"attempt",
+		"issueCode",
+		"key",
+		"occurredAtMs",
+		"operationId",
+		"requestId",
+		"runId",
+		"sequence",
+		"severity",
+		"subjectId",
+	],
+	retentionEvidence: [
+		"adapterInputId",
+		"attemptHighWater",
+		"evidenceKind",
+		"key",
+		"occurredAtMs",
+		"reason",
+		"sequence",
+	],
+};
+
+function _expectRetentionScorerEntryPayloadSafe(index: string, entry: unknown): void {
+	expect(entry).toBeTypeOf("object");
+	expect(Array.isArray(entry)).toBe(false);
+	const record = entry as Record<string, unknown>;
+	const allowed = retentionScorerEntryKeys[index];
+	expect(allowed, `unknown retention scorer index ${index}`).toBeDefined();
+	for (const [key, value] of Object.entries(record)) {
+		expect(allowed).toContain(key);
+		expect(value === undefined || typeof value === "string" || typeof value === "number").toBe(
+			true,
+		);
+		if (key === "key") expect(value).toEqual(expect.stringMatching(/^key:[a-z0-9]+:\d+$/));
+	}
+	expectNoForbiddenRetentionPayload(record);
+}
+
+function expectNoForbiddenRetentionPayload(value: unknown): void {
+	expect(JSON.stringify(value)).not.toMatch(forbiddenRetentionPayloadPattern);
+}
+
+function _readyToolProviderAdapterInput(
+	providerId: string,
+	requestId: string,
+): ToolProviderAdapterInput {
+	const catalog = localBuiltinToolProviderCatalog({ providerId });
+	const profile = catalog.profiles[0];
+	if (profile === undefined) throw new Error("expected profile");
+	const request = toolRequest(requestId, `${requestId}-op`, "file.read", "read");
+	const route: ExecutorRoute = {
+		kind: "executor-route",
+		routeId: `${requestId}-route`,
+		requestId: request.requestId,
+		operationId: request.operationId,
+		executorId: profile.executorId,
+		profileId: profile.profileId,
+		inputKind: "tool-call",
+	};
+	const resolutions = resolveToolProviderExecutionPolicies({
+		request,
+		routes: [route],
+		catalogs: [catalog],
+	});
+	const input = buildToolProviderAdapterInputs({
+		requests: [request],
+		routes: [route],
+		catalogs: [catalog],
+		resolutions,
+	})[0];
+	if (input === undefined || input.status !== "ready") throw new Error("expected ready input");
+	return input;
+}
+
+function workItemSeed(workItemId: string): WorkItemSeed {
+	return {
+		kind: "work-item",
+		workItemId,
+		sourceRefs: [{ kind: "work-item", id: workItemId }],
+		workItemKind: "issue",
+		lifecycleStatus: "open",
+	};
+}
+
+function workItemActionProposal(
+	proposalId: string,
+	actionKind: string,
+	opts: Partial<WorkItemDomainActionProposal> = {},
+): WorkItemDomainActionProposal {
+	return {
+		kind: "work-item-domain-action-proposal",
+		proposalId,
+		workItemId: opts.workItemId ?? "wi-1",
+		actionKind,
+		effectRunId: opts.effectRunId ?? "run-1",
+		effectRunResultId: opts.effectRunResultId ?? "run-1:result",
+		evidenceId: opts.evidenceId ?? "wi-1:run-1:run-1:result",
+		policyId: opts.policyId ?? "policy-propose",
+		sourceRefs: opts.sourceRefs,
+		metadata: opts.metadata,
+	};
+}
+
+function workItemAdmissionDecision(
+	decisionId: string,
+	admissionId: string,
+	proposalId: string,
+	outcome: WorkItemDomainActionAdmissionDecision["outcome"],
+	opts: Partial<WorkItemDomainActionAdmissionDecision> = {},
+): WorkItemDomainActionAdmissionDecision {
+	return {
+		kind: "work-item-domain-action-admission-decision",
+		decisionId,
+		admissionId,
+		proposalId,
+		outcome,
+		policyId: opts.policyId,
+		reason: opts.reason,
+		targetProposalId: opts.targetProposalId,
+		targetAdmissionId: opts.targetAdmissionId,
+		sourceRefs: opts.sourceRefs,
+		decidedAtMs: opts.decidedAtMs,
+		metadata: opts.metadata,
+	};
+}
+
+describe("CSP-8 experimental agent runtime kernel (D236) — part 11", () => {
+	it("keeps WorkItem domain action proposals disabled without a referenced policy", () => {
+		const g = graph();
+		const workItems = g.node<WorkItemSeed>([], null, { name: "workItems" });
+		const evidence = g.node<WorkItemEvidenceRecorded>([], null, { name: "evidence" });
+		const results = g.node<EffectRunResult>([], null, { name: "results" });
+		const policies = g.node<WorkItemEffectMappingPolicy>([], null, { name: "policies" });
+		const projector = workItemDomainActionProposalProjector(g, {
+			workItems,
+			evidence,
+			effectRunResults: results,
+			mappingPolicies: [policies],
+		});
+		const proposals: unknown[] = [];
+		const issues: unknown[] = [];
+		projector.proposals.subscribe((msg) => msg[0] === "DATA" && proposals.push(msg[1]));
+		projector.issues.subscribe((msg) => msg[0] === "DATA" && issues.push(msg[1]));
+		workItems.down([["DATA", workItemSeed("wi-1")]]);
+		policies.down([
+			[
+				"DATA",
+				{
+					kind: "work-item-effect-mapping-policy",
+					policyId: "unreferenced-action-policy",
+					actionProposals: [{ actionKind: "close-work-item", statuses: ["completed"] }],
+				},
+			],
+		]);
+		results.down([
+			[
+				"DATA",
+				{
+					kind: "effect-run-result",
+					resultId: "run-1:result",
+					status: "completed",
+					effectRunId: "run-1",
+					sourceRefs: [
+						{ kind: "work-item-effect-mapping-policy", id: "unreferenced-action-policy" },
+					],
+					output: { kind: "verified" },
+				},
+			],
+		]);
+		evidence.down([
+			[
+				"DATA",
+				{
+					kind: "work-item-evidence-recorded",
+					evidenceId: "evidence-1",
+					workItemId: "wi-1",
+					effectRunId: "run-1",
+					effectRunResultId: "run-1:result",
+					status: "completed",
+					output: { kind: "verified" },
+				},
+			],
+		]);
+
+		expect(proposals).toEqual([]);
+		expect(issues).toEqual([]);
+	});
+
+	it("emits DataIssue for stale or missing WorkItem action proposal policy inputs", () => {
+		const g = graph();
+		const workItems = g.node<WorkItemSeed>([], null, { name: "workItems" });
+		const evidence = g.node<WorkItemEvidenceRecorded>([], null, { name: "evidence" });
+		const results = g.node<EffectRunResult>([], null, { name: "results" });
+		const policies = g.node<WorkItemEffectMappingPolicy>([], null, { name: "policies" });
+		const projector = workItemDomainActionProposalProjector(g, {
+			workItems,
+			evidence,
+			effectRunResults: results,
+			mappingPolicies: [policies],
+		});
+		const proposals: unknown[] = [];
+		const issues: unknown[] = [];
+		projector.proposals.subscribe((msg) => msg[0] === "DATA" && proposals.push(msg[1]));
+		projector.issues.subscribe((msg) => msg[0] === "DATA" && issues.push(msg[1]));
+		workItems.down([["DATA", workItemSeed("wi-1")]]);
+		evidence.down([
+			[
+				"DATA",
+				{
+					kind: "work-item-evidence-recorded",
+					evidenceId: "missing-result-evidence",
+					workItemId: "wi-1",
+					effectRunId: "missing-run",
+					effectRunResultId: "missing-run:result",
+					status: "completed",
+					sourceRefs: [{ kind: "work-item-effect-mapping-policy", id: "policy-propose-missing" }],
+					output: { kind: "verified" },
+				},
+			],
+		]);
+		results.down([
+			[
+				"DATA",
+				{
+					kind: "effect-run-result",
+					resultId: "run-1:result",
+					status: "failed",
+					effectRunId: "run-1",
+					error: { kind: "issue", code: "failed", message: "failed" },
+				},
+			],
+		]);
+		evidence.down([
+			[
+				"DATA",
+				{
+					kind: "work-item-evidence-recorded",
+					evidenceId: "stale-evidence",
+					workItemId: "wi-1",
+					effectRunId: "run-1",
+					effectRunResultId: "run-1:result",
+					status: "completed",
+					sourceRefs: [{ kind: "work-item-effect-mapping-policy", id: "policy-propose-missing" }],
+					output: { kind: "verified" },
+				},
+			],
+		]);
+		results.down([
+			[
+				"DATA",
+				{
+					kind: "effect-run-result",
+					resultId: "run-2:result",
+					status: "completed",
+					effectRunId: "run-2",
+					output: { kind: "verified" },
+				},
+			],
+		]);
+		evidence.down([
+			[
+				"DATA",
+				{
+					kind: "work-item-evidence-recorded",
+					evidenceId: "missing-policy-evidence",
+					workItemId: "wi-1",
+					effectRunId: "run-2",
+					effectRunResultId: "run-2:result",
+					status: "completed",
+					sourceRefs: [{ kind: "work-item-effect-mapping-policy", id: "policy-propose-missing" }],
+					output: { kind: "verified" },
+				},
+			],
+		]);
+
+		expect(proposals).toEqual([]);
+		expect(issues).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({ code: "missing-work-item-action-proposal-result" }),
+				expect.objectContaining({ code: "stale-work-item-action-proposal-result" }),
+				expect.objectContaining({ code: "missing-work-item-action-proposal-policy" }),
+			]),
+		);
+	});
+
+	it("emits DataIssue for duplicate WorkItem action proposal evidence ids", () => {
+		const g = graph();
+		const workItems = g.node<WorkItemSeed>([], null, { name: "workItems" });
+		const evidence = g.node<WorkItemEvidenceRecorded>([], null, { name: "evidence" });
+		const results = g.node<EffectRunResult>([], null, { name: "results" });
+		const policies = g.node<WorkItemEffectMappingPolicy>([], null, { name: "policies" });
+		const projector = workItemDomainActionProposalProjector(g, {
+			workItems,
+			evidence,
+			effectRunResults: results,
+			mappingPolicies: [policies],
+		});
+		const proposals: unknown[] = [];
+		const issues: unknown[] = [];
+		projector.proposals.subscribe((msg) => msg[0] === "DATA" && proposals.push(msg[1]));
+		projector.issues.subscribe((msg) => msg[0] === "DATA" && issues.push(msg[1]));
+		workItems.down([["DATA", workItemSeed("wi-1")]]);
+		policies.down([
+			[
+				"DATA",
+				{
+					kind: "work-item-effect-mapping-policy",
+					policyId: "policy-propose",
+					actionProposals: [{ actionKind: "mark-ready", statuses: ["completed"] }],
+				},
+			],
+		]);
+		results.down([
+			[
+				"DATA",
+				{
+					kind: "effect-run-result",
+					resultId: "run-1:result",
+					status: "completed",
+					effectRunId: "run-1",
+					output: { kind: "verified" },
+				},
+			],
+		]);
+		const firstEvidence: WorkItemEvidenceRecorded = {
+			kind: "work-item-evidence-recorded",
+			evidenceId: "evidence-1",
+			workItemId: "wi-1",
+			effectRunId: "run-1",
+			effectRunResultId: "run-1:result",
+			status: "completed",
+			sourceRefs: [{ kind: "work-item-effect-mapping-policy", id: "policy-propose" }],
+			output: { kind: "verified" },
+		};
+		evidence.down([["DATA", firstEvidence]]);
+		evidence.down([
+			[
+				"DATA",
+				{
+					...firstEvidence,
+					output: { kind: "verified", value: { replacement: true } },
+				},
+			],
+		]);
+
+		expect(proposals).toHaveLength(1);
+		expect(issues.at(-1)).toMatchObject({
+			code: "duplicate-work-item-action-proposal-evidence",
+		});
+	});
+
+	it("emits DataIssue for duplicate WorkItem action proposal result ids", () => {
+		const g = graph();
+		const workItems = g.node<WorkItemSeed>([], null, { name: "workItems" });
+		const evidence = g.node<WorkItemEvidenceRecorded>([], null, { name: "evidence" });
+		const results = g.node<EffectRunResult>([], null, { name: "results" });
+		const policies = g.node<WorkItemEffectMappingPolicy>([], null, { name: "policies" });
+		const projector = workItemDomainActionProposalProjector(g, {
+			workItems,
+			evidence,
+			effectRunResults: results,
+			mappingPolicies: [policies],
+		});
+		const proposals: unknown[] = [];
+		const issues: unknown[] = [];
+		projector.proposals.subscribe((msg) => msg[0] === "DATA" && proposals.push(msg[1]));
+		projector.issues.subscribe((msg) => msg[0] === "DATA" && issues.push(msg[1]));
+		workItems.down([["DATA", workItemSeed("wi-1")]]);
+		policies.down([
+			[
+				"DATA",
+				{
+					kind: "work-item-effect-mapping-policy",
+					policyId: "policy-propose",
+					actionProposals: [{ actionKind: "mark-ready", statuses: ["completed"] }],
+				},
+			],
+		]);
+		results.down([
+			[
+				"DATA",
+				{
+					kind: "effect-run-result",
+					resultId: "run-1:result",
+					status: "completed",
+					effectRunId: "run-1",
+					output: { kind: "verified" },
+				},
+			],
+		]);
+		evidence.down([
+			[
+				"DATA",
+				{
+					kind: "work-item-evidence-recorded",
+					evidenceId: "evidence-1",
+					workItemId: "wi-1",
+					effectRunId: "run-1",
+					effectRunResultId: "run-1:result",
+					status: "completed",
+					sourceRefs: [{ kind: "work-item-effect-mapping-policy", id: "policy-propose" }],
+					output: { kind: "verified" },
+				},
+			],
+		]);
+		results.down([
+			[
+				"DATA",
+				{
+					kind: "effect-run-result",
+					resultId: "run-1:result",
+					status: "failed",
+					effectRunId: "run-1",
+					error: { kind: "issue", code: "failed", message: "replacement" },
+				},
+			],
+		]);
+
+		expect(proposals).toHaveLength(1);
+		expect(issues.at(-1)).toMatchObject({
+			code: "duplicate-work-item-action-proposal-result",
+		});
+	});
+
+	it("keeps WorkItem action proposal payloads compact and explicit", () => {
+		const g = graph();
+		const workItems = g.node<WorkItemSeed>([], null, { name: "workItems" });
+		const evidence = g.node<WorkItemEvidenceRecorded>([], null, { name: "evidence" });
+		const results = g.node<EffectRunResult>([], null, { name: "results" });
+		const policies = g.node<WorkItemEffectMappingPolicy>([], null, { name: "policies" });
+		const projector = workItemDomainActionProposalProjector(g, {
+			workItems,
+			evidence,
+			effectRunResults: results,
+			mappingPolicies: [policies],
+		});
+		const proposals: WorkItemDomainActionProposal[] = [];
+		projector.proposals.subscribe(
+			(msg) => msg[0] === "DATA" && proposals.push(msg[1] as WorkItemDomainActionProposal),
+		);
+		workItems.down([["DATA", workItemSeed("wi-1")]]);
+		policies.down([
+			[
+				"DATA",
+				{
+					kind: "work-item-effect-mapping-policy",
+					policyId: "policy-propose",
+					actionProposals: [
+						{ actionKind: "default-payload" },
+						{ actionKind: "result-ref", payloadFrom: "effect-run-result" },
+						{ actionKind: "static-payload", payload: { approvedByPolicy: true } },
+					],
+				},
+			],
+		]);
+		results.down([
+			[
+				"DATA",
+				{
+					kind: "effect-run-result",
+					resultId: "run-1:result",
+					status: "completed",
+					effectRunId: "run-1",
+					output: { kind: "verified", value: { ok: true } },
+				},
+			],
+		]);
+		evidence.down([
+			[
+				"DATA",
+				{
+					kind: "work-item-evidence-recorded",
+					evidenceId: "evidence-1",
+					workItemId: "wi-1",
+					effectRunId: "run-1",
+					effectRunResultId: "run-1:result",
+					status: "completed",
+					sourceRefs: [{ kind: "work-item-effect-mapping-policy", id: "policy-propose" }],
+					output: { kind: "verified", value: { ok: true } },
+				},
+			],
+		]);
+
+		expect(proposals.find((proposal) => proposal.actionKind === "default-payload")?.payload).toBe(
+			undefined,
+		);
+		expect(proposals.find((proposal) => proposal.actionKind === "result-ref")?.payload).toEqual({
+			kind: "effect-run-result-ref",
+			resultId: "run-1:result",
+		});
+		expect(proposals.find((proposal) => proposal.actionKind === "static-payload")?.payload).toEqual(
+			{
+				approvedByPolicy: true,
+			},
+		);
+	});
+
+	it("does not seed EffectRun for WorkItemEffectRequested targeting unknown WorkItem", () => {
+		const g = graph();
+		const workItems = g.node<WorkItemSeed>([], null, { name: "workItems" });
+		const effectRequests = g.node<WorkItemEffectRequested>([], null, {
+			name: "workItemEffectRequests",
+		});
+		const workItemRuns = workItemEffectRunProjector(g, { workItems, effectRequests });
+		const seededRuns: unknown[] = [];
+		const issues: unknown[] = [];
+		const views: unknown[] = [];
+		workItemRuns.effectRuns.subscribe((msg) => msg[0] === "DATA" && seededRuns.push(msg[1]));
+		workItemRuns.issues.subscribe((msg) => msg[0] === "DATA" && issues.push(msg[1]));
+		workItemRuns.views.subscribe((msg) => msg[0] === "DATA" && views.push(msg[1]));
+		workItems.down([["DATA", workItemSeed("wi-other")]]);
+
+		effectRequests.down([
+			[
+				"DATA",
+				{
+					kind: "work-item-effect-requested",
+					requestId: "wi-effect-1",
+					workItemId: "wi-missing",
+					effectRunId: "run-1",
+					effectKind: "verification",
+					goal: { kind: "verify" },
+				},
+			],
+		]);
+
+		expect(seededRuns).toEqual([]);
+		expect(issues.at(-1)).toMatchObject({ code: "unknown-work-item-effect-request" });
+		expect(
+			(views.at(-1) as { pendingEffectRequests: readonly WorkItemEffectRequested[] })
+				.pendingEffectRequests,
+		).toEqual([]);
+
+		workItems.down([["DATA", workItemSeed("wi-missing")]]);
+		expect(seededRuns).toEqual([]);
+		expect(
+			(views.at(-1) as { pendingEffectRequests: readonly WorkItemEffectRequested[] })
+				.pendingEffectRequests,
+		).toEqual([]);
+	});
+
+	it("rejects duplicate WorkItemEffectRequested facts that reuse an EffectRun id", () => {
+		const g = graph();
+		const workItems = g.node<WorkItemSeed>([], null, { name: "workItems" });
+		const effectRequests = g.node<WorkItemEffectRequested>([], null, {
+			name: "workItemEffectRequests",
+		});
+		const workItemRuns = workItemEffectRunProjector(g, { workItems, effectRequests });
+		const seededRuns: unknown[] = [];
+		const issues: unknown[] = [];
+		const views: unknown[] = [];
+		workItemRuns.effectRuns.subscribe((msg) => msg[0] === "DATA" && seededRuns.push(msg[1]));
+		workItemRuns.issues.subscribe((msg) => msg[0] === "DATA" && issues.push(msg[1]));
+		workItemRuns.views.subscribe((msg) => msg[0] === "DATA" && views.push(msg[1]));
+		workItems.down([["DATA", workItemSeed("wi-1")]]);
+
+		effectRequests.down([
+			[
+				"DATA",
+				{
+					kind: "work-item-effect-requested",
+					requestId: "wi-effect-1",
+					workItemId: "wi-1",
+					effectRunId: "run-1",
+					effectKind: "verification",
+					goal: { kind: "verify" },
+				},
+			],
+			[
+				"DATA",
+				{
+					kind: "work-item-effect-requested",
+					requestId: "wi-effect-2",
+					workItemId: "wi-1",
+					effectRunId: "run-1",
+					effectKind: "verification",
+					goal: { kind: "verify-again" },
+				},
+			],
+		]);
+
+		expect(seededRuns).toHaveLength(1);
+		expect(issues.at(-1)).toMatchObject({ code: "duplicate-work-item-effect-run" });
+		expect(
+			(views.at(-1) as { pendingEffectRequests: readonly WorkItemEffectRequested[] })
+				.pendingEffectRequests,
+		).toEqual([]);
+	});
+
+	it("admits WorkItem domain action proposals as a no-op visible ledger", () => {
+		const g = graph();
+		const proposals = g.node<WorkItemDomainActionProposal>([], null, { name: "proposals" });
+		const decisions = g.node<WorkItemDomainActionAdmissionDecision>([], null, {
+			name: "decisions",
+		});
+		const policies = g.node<WorkItemDomainActionAdmissionPolicy>([], null, { name: "policies" });
+		const projector = workItemDomainActionAdmissionProjector(g, {
+			proposals,
+			decisions,
+			admissionPolicies: [policies],
+			now: () => 1200,
+		});
+		const admissions: WorkItemDomainActionAdmission[] = [];
+		const statuses: unknown[] = [];
+		const issues: unknown[] = [];
+		const audit: unknown[] = [];
+		const views: unknown[] = [];
+		projector.admissions.subscribe(
+			(msg) => msg[0] === "DATA" && admissions.push(msg[1] as WorkItemDomainActionAdmission),
+		);
+		projector.status.subscribe((msg) => msg[0] === "DATA" && statuses.push(msg[1]));
+		projector.issues.subscribe((msg) => msg[0] === "DATA" && issues.push(msg[1]));
+		projector.audit.subscribe((msg) => msg[0] === "DATA" && audit.push(msg[1]));
+		projector.views.subscribe((msg) => msg[0] === "DATA" && views.push(msg[1]));
+
+		policies.down([
+			[
+				"DATA",
+				{
+					kind: "work-item-domain-action-admission-policy",
+					policyId: "admit-ready",
+					actionKinds: ["mark-ready"],
+					allowedOutcomes: ["admit"],
+				},
+			],
+		]);
+		proposals.down([["DATA", workItemActionProposal("proposal-1", "mark-ready")]]);
+		decisions.down([
+			[
+				"DATA",
+				workItemAdmissionDecision("decision-1", "admission-1", "proposal-1", "admit", {
+					policyId: "admit-ready",
+					decidedAtMs: 1199,
+					sourceRefs: [
+						{ kind: "work-item-domain-action-proposal", id: "proposal-1" },
+						{ kind: "work-item-domain-action-admission-policy", id: "admit-ready" },
+					],
+				}),
+			],
+		]);
+
+		expect(issues).toEqual([]);
+		expect(admissions).toEqual([
+			expect.objectContaining({
+				kind: "work-item-domain-action-admission",
+				admissionId: "admission-1",
+				proposalId: "proposal-1",
+				workItemId: "wi-1",
+				actionKind: "mark-ready",
+				state: "admitted",
+				decisionId: "decision-1",
+				policyId: "admit-ready",
+				admittedAtMs: 1199,
+			}),
+		]);
+		expect(admissions.at(-1)?.sourceRefs).toEqual(
+			expect.arrayContaining([
+				{ kind: "work-item-domain-action-proposal", id: "proposal-1" },
+				{ kind: "work-item-domain-action-admission-policy", id: "admit-ready" },
+				{ kind: "work-item-domain-action-admission-decision", id: "decision-1" },
+			]),
+		);
+		expect(statuses.at(-1)).toMatchObject({
+			state: "domain-action-admitted",
+			proposalId: "proposal-1",
+		});
+		expect(statuses).not.toContainEqual(expect.objectContaining({ state: "closed" }));
+		expect(statuses).not.toContainEqual(expect.objectContaining({ state: "resolved" }));
+		expect(statuses).not.toContainEqual(expect.objectContaining({ state: "approved" }));
+		expect(statuses).not.toContainEqual(expect.objectContaining({ state: "verified" }));
+		expect(Object.keys(projector)).toEqual(["admissions", "status", "issues", "audit", "views"]);
+		expect(audit.at(-1)).toMatchObject({ kind: "work-item-domain-action-admitted" });
+		const latestView = views.at(-1) as {
+			admissionsByProposal: Map<string, WorkItemDomainActionAdmission>;
+			admissionsByWorkItem: Map<string, readonly WorkItemDomainActionAdmission[]>;
+		};
+		expect(latestView.admissionsByProposal.get("proposal-1")?.state).toBe("admitted");
+		expect(latestView.admissionsByWorkItem.get("wi-1")?.[0].admissionId).toBe("admission-1");
+	});
+
+	it("records rejected, deferred, and merged WorkItem domain action admissions without applying them", () => {
+		const g = graph();
+		const proposals = g.node<WorkItemDomainActionProposal>([], null, { name: "proposals" });
+		const decisions = g.node<WorkItemDomainActionAdmissionDecision>([], null, {
+			name: "decisions",
+		});
+		const projector = workItemDomainActionAdmissionProjector(g, { proposals, decisions });
+		const admissions: WorkItemDomainActionAdmission[] = [];
+		const statuses: unknown[] = [];
+		projector.admissions.subscribe(
+			(msg) => msg[0] === "DATA" && admissions.push(msg[1] as WorkItemDomainActionAdmission),
+		);
+		projector.status.subscribe((msg) => msg[0] === "DATA" && statuses.push(msg[1]));
+
+		proposals.down([
+			["DATA", workItemActionProposal("proposal-reject", "mark-ready")],
+			["DATA", workItemActionProposal("proposal-defer", "mark-ready")],
+			["DATA", workItemActionProposal("proposal-merge-target", "mark-ready")],
+			["DATA", workItemActionProposal("proposal-merge", "mark-ready")],
+		]);
+		decisions.down([
+			[
+				"DATA",
+				workItemAdmissionDecision(
+					"decision-reject",
+					"admission-reject",
+					"proposal-reject",
+					"reject",
+				),
+			],
+			[
+				"DATA",
+				workItemAdmissionDecision("decision-defer", "admission-defer", "proposal-defer", "defer"),
+			],
+			[
+				"DATA",
+				workItemAdmissionDecision(
+					"decision-merge-target",
+					"admission-merge-target",
+					"proposal-merge-target",
+					"admit",
+				),
+			],
+			[
+				"DATA",
+				workItemAdmissionDecision("decision-merge", "admission-merge", "proposal-merge", "merge", {
+					targetProposalId: "proposal-merge-target",
+					sourceRefs: [
+						{ kind: "work-item-domain-action-proposal", id: "proposal-merge" },
+						{ kind: "work-item-domain-action-proposal", id: "proposal-merge-target" },
+					],
+				}),
+			],
+		]);
+
+		expect(admissions.map((admission) => admission.state)).toEqual([
+			"rejected",
+			"deferred",
+			"admitted",
+			"merged",
+		]);
+		expect(admissions.at(-1)).toMatchObject({
+			state: "merged",
+			targetProposalId: "proposal-merge-target",
+		});
+		expect(statuses.map((status) => (status as { state: string }).state)).toEqual([
+			"domain-action-rejected",
+			"domain-action-deferred",
+			"domain-action-admitted",
+			"domain-action-merged",
+		]);
+		expect(statuses).not.toContainEqual(expect.objectContaining({ state: "closed" }));
+		expect(statuses).not.toContainEqual(expect.objectContaining({ state: "resolved" }));
+		expect(statuses).not.toContainEqual(expect.objectContaining({ state: "approved" }));
+		expect(statuses).not.toContainEqual(expect.objectContaining({ state: "verified" }));
+	});
+});
diff --git a/packages/ts/src/__tests__/agent-runtime.part-12.test.ts b/packages/ts/src/__tests__/agent-runtime.part-12.test.ts
new file mode 100644
index 00000000..1b12e5bc
--- /dev/null
+++ b/packages/ts/src/__tests__/agent-runtime.part-12.test.ts
@@ -0,0 +1,499 @@
+import { describe, expect, it } from "vitest";
+import { graph } from "../graph/graph.js";
+import {
+	type AgentRequestIssued,
+	buildToolProviderAdapterInputs,
+	type ExecutorRoute,
+	localBuiltinToolProviderCatalog,
+	resolveToolProviderExecutionPolicies,
+	type ToolProviderAdapterInput,
+} from "../orchestration/agent-runtime.js";
+import {
+	type WorkItemDomainActionAdmission,
+	type WorkItemDomainActionAdmissionDecision,
+	type WorkItemDomainActionAdmissionPolicy,
+	type WorkItemDomainActionProposal,
+	type WorkItemSeed,
+	workItemDomainActionAdmissionProjector,
+} from "../orchestration/work-item-runtime.js";
+
+function _issued(
+	requestId: string,
+	operationId: string,
+	requestKind: AgentRequestIssued["requestKind"],
+	inputKind?: string,
+): AgentRequestIssued {
+	return {
+		kind: "issued",
+		requestId,
+		operationId,
+		effectRunId: "run-1",
+		requestKind,
+		required: true,
+		input:
+			inputKind === undefined
+				? undefined
+				: { inputId: `${requestId}:input`, inputKind, dataMode: "summary", summary: inputKind },
+	};
+}
+
+function toolRequest(
+	requestId: string,
+	operationId: string,
+	toolName: string,
+	operation?: string,
+): AgentRequestIssued {
+	return {
+		kind: "issued",
+		requestId,
+		operationId,
+		effectRunId: "run-1",
+		requestKind: "executor",
+		required: true,
+		input: {
+			inputId: `${requestId}:input`,
+			inputKind: "tool-call",
+			dataMode: "inline",
+			value: {
+				kind: "tool-call",
+				toolName,
+				operation,
+				arguments: { path: "README.md" },
+			},
+		},
+	};
+}
+
+const forbiddenRetentionPayloadPattern =
+	/SCORER_SECRET|SCORER_RAW|rawResponse|stdout|stderr|stack|apiKey|password|arguments|providerClient|oauthState|subprocessHandle|transport|sdkObject/i;
+
+const retentionScorerEntryKeys: Record<string, readonly string[]> = {
+	adapterInputs: [
+		"adapterInputId",
+		"executorId",
+		"insertedAtMs",
+		"key",
+		"operationId",
+		"profileId",
+		"providerId",
+		"requestId",
+		"routeId",
+		"sequence",
+		"status",
+	],
+	runRequests: [
+		"adapterInputId",
+		"attempt",
+		"executorId",
+		"key",
+		"operationId",
+		"profileId",
+		"providerId",
+		"reason",
+		"requestId",
+		"requestedAtMs",
+		"routeId",
+		"runId",
+		"sequence",
+	],
+	executions: [
+		"adapterInputId",
+		"attempt",
+		"executorId",
+		"key",
+		"occurredAtMs",
+		"operationId",
+		"outcomeId",
+		"profileId",
+		"providerId",
+		"reason",
+		"requestId",
+		"routeId",
+		"runId",
+		"sequence",
+		"status",
+	],
+	runStatuses: [
+		"adapterInputId",
+		"attempt",
+		"issueCode",
+		"key",
+		"occurredAtMs",
+		"operationId",
+		"outcomeId",
+		"requestId",
+		"runId",
+		"sequence",
+		"status",
+	],
+	runIssues: [
+		"adapterInputId",
+		"attempt",
+		"issueCode",
+		"key",
+		"occurredAtMs",
+		"operationId",
+		"requestId",
+		"runId",
+		"sequence",
+		"severity",
+		"subjectId",
+	],
+	retentionEvidence: [
+		"adapterInputId",
+		"attemptHighWater",
+		"evidenceKind",
+		"key",
+		"occurredAtMs",
+		"reason",
+		"sequence",
+	],
+};
+
+function _expectRetentionScorerEntryPayloadSafe(index: string, entry: unknown): void {
+	expect(entry).toBeTypeOf("object");
+	expect(Array.isArray(entry)).toBe(false);
+	const record = entry as Record<string, unknown>;
+	const allowed = retentionScorerEntryKeys[index];
+	expect(allowed, `unknown retention scorer index ${index}`).toBeDefined();
+	for (const [key, value] of Object.entries(record)) {
+		expect(allowed).toContain(key);
+		expect(value === undefined || typeof value === "string" || typeof value === "number").toBe(
+			true,
+		);
+		if (key === "key") expect(value).toEqual(expect.stringMatching(/^key:[a-z0-9]+:\d+$/));
+	}
+	expectNoForbiddenRetentionPayload(record);
+}
+
+function expectNoForbiddenRetentionPayload(value: unknown): void {
+	expect(JSON.stringify(value)).not.toMatch(forbiddenRetentionPayloadPattern);
+}
+
+function _readyToolProviderAdapterInput(
+	providerId: string,
+	requestId: string,
+): ToolProviderAdapterInput {
+	const catalog = localBuiltinToolProviderCatalog({ providerId });
+	const profile = catalog.profiles[0];
+	if (profile === undefined) throw new Error("expected profile");
+	const request = toolRequest(requestId, `${requestId}-op`, "file.read", "read");
+	const route: ExecutorRoute = {
+		kind: "executor-route",
+		routeId: `${requestId}-route`,
+		requestId: request.requestId,
+		operationId: request.operationId,
+		executorId: profile.executorId,
+		profileId: profile.profileId,
+		inputKind: "tool-call",
+	};
+	const resolutions = resolveToolProviderExecutionPolicies({
+		request,
+		routes: [route],
+		catalogs: [catalog],
+	});
+	const input = buildToolProviderAdapterInputs({
+		requests: [request],
+		routes: [route],
+		catalogs: [catalog],
+		resolutions,
+	})[0];
+	if (input === undefined || input.status !== "ready") throw new Error("expected ready input");
+	return input;
+}
+
+function _workItemSeed(workItemId: string): WorkItemSeed {
+	return {
+		kind: "work-item",
+		workItemId,
+		sourceRefs: [{ kind: "work-item", id: workItemId }],
+		workItemKind: "issue",
+		lifecycleStatus: "open",
+	};
+}
+
+function workItemActionProposal(
+	proposalId: string,
+	actionKind: string,
+	opts: Partial<WorkItemDomainActionProposal> = {},
+): WorkItemDomainActionProposal {
+	return {
+		kind: "work-item-domain-action-proposal",
+		proposalId,
+		workItemId: opts.workItemId ?? "wi-1",
+		actionKind,
+		effectRunId: opts.effectRunId ?? "run-1",
+		effectRunResultId: opts.effectRunResultId ?? "run-1:result",
+		evidenceId: opts.evidenceId ?? "wi-1:run-1:run-1:result",
+		policyId: opts.policyId ?? "policy-propose",
+		sourceRefs: opts.sourceRefs,
+		metadata: opts.metadata,
+	};
+}
+
+function workItemAdmissionDecision(
+	decisionId: string,
+	admissionId: string,
+	proposalId: string,
+	outcome: WorkItemDomainActionAdmissionDecision["outcome"],
+	opts: Partial<WorkItemDomainActionAdmissionDecision> = {},
+): WorkItemDomainActionAdmissionDecision {
+	return {
+		kind: "work-item-domain-action-admission-decision",
+		decisionId,
+		admissionId,
+		proposalId,
+		outcome,
+		policyId: opts.policyId,
+		reason: opts.reason,
+		targetProposalId: opts.targetProposalId,
+		targetAdmissionId: opts.targetAdmissionId,
+		sourceRefs: opts.sourceRefs,
+		decidedAtMs: opts.decidedAtMs,
+		metadata: opts.metadata,
+	};
+}
+
+describe("CSP-8 experimental agent runtime kernel (D236) — part 12", () => {
+	it("emits DataIssue for duplicate and stale WorkItem admission inputs while preserving first facts", () => {
+		const g = graph();
+		const proposals = g.node<WorkItemDomainActionProposal>([], null, { name: "proposals" });
+		const decisions = g.node<WorkItemDomainActionAdmissionDecision>([], null, {
+			name: "decisions",
+		});
+		const policies = g.node<WorkItemDomainActionAdmissionPolicy>([], null, { name: "policies" });
+		const projector = workItemDomainActionAdmissionProjector(g, {
+			proposals,
+			decisions,
+			admissionPolicies: [policies],
+		});
+		const admissions: WorkItemDomainActionAdmission[] = [];
+		const issues: unknown[] = [];
+		projector.admissions.subscribe(
+			(msg) => msg[0] === "DATA" && admissions.push(msg[1] as WorkItemDomainActionAdmission),
+		);
+		projector.issues.subscribe((msg) => msg[0] === "DATA" && issues.push(msg[1]));
+		policies.down([
+			[
+				"DATA",
+				{
+					kind: "work-item-domain-action-admission-policy",
+					policyId: "admit-ready",
+					actionKinds: ["mark-ready"],
+					allowedOutcomes: ["admit"],
+				},
+			],
+		]);
+
+		proposals.down([
+			["DATA", workItemActionProposal("proposal-1", "mark-ready")],
+			["DATA", workItemActionProposal("proposal-1", "mark-ready")],
+			["DATA", workItemActionProposal("proposal-2", "mark-ready")],
+			["DATA", workItemActionProposal("proposal-3", "mark-ready")],
+			["DATA", workItemActionProposal("proposal-4", "other-action")],
+			["DATA", workItemActionProposal("proposal-5", "mark-ready")],
+		]);
+		decisions.down([
+			[
+				"DATA",
+				workItemAdmissionDecision("decision-ok", "admission-1", "proposal-1", "admit", {
+					policyId: "admit-ready",
+				}),
+			],
+			[
+				"DATA",
+				workItemAdmissionDecision(
+					"decision-duplicate-admission",
+					"admission-1",
+					"proposal-2",
+					"admit",
+				),
+			],
+			[
+				"DATA",
+				workItemAdmissionDecision("decision-stale", "admission-stale", "proposal-3", "admit", {
+					sourceRefs: [{ kind: "work-item-domain-action-proposal", id: "proposal-other" }],
+				}),
+			],
+			[
+				"DATA",
+				workItemAdmissionDecision(
+					"decision-missing",
+					"admission-missing",
+					"proposal-missing",
+					"admit",
+				),
+			],
+			[
+				"DATA",
+				workItemAdmissionDecision(
+					"decision-policy-mismatch",
+					"admission-mismatch",
+					"proposal-4",
+					"admit",
+					{
+						policyId: "admit-ready",
+					},
+				),
+			],
+			[
+				"DATA",
+				workItemAdmissionDecision("decision-ok", "admission-5", "proposal-5", "admit", {
+					policyId: "admit-ready",
+				}),
+			],
+		]);
+
+		expect(admissions).toHaveLength(1);
+		expect(admissions.at(-1)).toMatchObject({
+			admissionId: "admission-1",
+			proposalId: "proposal-1",
+		});
+		expect(issues.map((issue) => (issue as { code: string }).code)).toEqual(
+			expect.arrayContaining([
+				"duplicate-work-item-domain-action-proposal",
+				"duplicate-work-item-domain-action-admission",
+				"duplicate-work-item-domain-action-admission-decision",
+				"stale-work-item-domain-action-admission-proposal-ref",
+				"missing-work-item-domain-action-admission-proposal",
+				"work-item-domain-action-admission-policy-mismatch",
+			]),
+		);
+	});
+
+	it("rejects ambiguous WorkItem admission merge targets and unknown policy refs", () => {
+		const g = graph();
+		const proposals = g.node<WorkItemDomainActionProposal>([], null, { name: "proposals" });
+		const decisions = g.node<WorkItemDomainActionAdmissionDecision>([], null, {
+			name: "decisions",
+		});
+		const policies = g.node<WorkItemDomainActionAdmissionPolicy>([], null, { name: "policies" });
+		const projector = workItemDomainActionAdmissionProjector(g, {
+			proposals,
+			decisions,
+			admissionPolicies: [policies],
+		});
+		const admissions: WorkItemDomainActionAdmission[] = [];
+		const issues: unknown[] = [];
+		projector.admissions.subscribe(
+			(msg) => msg[0] === "DATA" && admissions.push(msg[1] as WorkItemDomainActionAdmission),
+		);
+		projector.issues.subscribe((msg) => msg[0] === "DATA" && issues.push(msg[1]));
+		proposals.down([
+			["DATA", workItemActionProposal("proposal-1", "mark-ready")],
+			["DATA", workItemActionProposal("proposal-2", "mark-ready")],
+			["DATA", workItemActionProposal("proposal-3", "mark-ready")],
+		]);
+		decisions.down([
+			[
+				"DATA",
+				workItemAdmissionDecision(
+					"decision-missing-policy",
+					"admission-missing-policy",
+					"proposal-1",
+					"admit",
+					{
+						policyId: "missing-policy",
+					},
+				),
+			],
+			[
+				"DATA",
+				workItemAdmissionDecision(
+					"decision-stale-policy",
+					"admission-stale-policy",
+					"proposal-2",
+					"admit",
+					{
+						policyId: "missing-policy",
+						sourceRefs: [{ kind: "work-item-domain-action-admission-policy", id: "other-policy" }],
+					},
+				),
+			],
+			[
+				"DATA",
+				workItemAdmissionDecision(
+					"decision-ambiguous-merge",
+					"admission-ambiguous-merge",
+					"proposal-3",
+					"merge",
+					{
+						targetProposalId: "proposal-1",
+						targetAdmissionId: "admission-1",
+					},
+				),
+			],
+		]);
+
+		expect(admissions).toEqual([]);
+		expect(issues.map((issue) => (issue as { code: string }).code)).toEqual([
+			"missing-work-item-domain-action-admission-policy",
+			"stale-work-item-domain-action-admission-policy-ref",
+			"ambiguous-work-item-domain-action-admission-merge-target",
+		]);
+	});
+
+	it("replays pending WorkItem admission decisions when proposal, policy, or target admission facts arrive later", () => {
+		const g = graph();
+		const proposals = g.node<WorkItemDomainActionProposal>([], null, { name: "proposals" });
+		const decisions = g.node<WorkItemDomainActionAdmissionDecision>([], null, {
+			name: "decisions",
+		});
+		const policies = g.node<WorkItemDomainActionAdmissionPolicy>([], null, { name: "policies" });
+		const projector = workItemDomainActionAdmissionProjector(g, {
+			proposals,
+			decisions,
+			admissionPolicies: [policies],
+		});
+		const admissions: WorkItemDomainActionAdmission[] = [];
+		const issues: unknown[] = [];
+		projector.admissions.subscribe(
+			(msg) => msg[0] === "DATA" && admissions.push(msg[1] as WorkItemDomainActionAdmission),
+		);
+		projector.issues.subscribe((msg) => msg[0] === "DATA" && issues.push(msg[1]));
+
+		decisions.down([
+			[
+				"DATA",
+				workItemAdmissionDecision("decision-admit", "admission-admit", "proposal-admit", "admit", {
+					policyId: "late-policy",
+				}),
+			],
+			[
+				"DATA",
+				workItemAdmissionDecision("decision-merge", "admission-merge", "proposal-merge", "merge", {
+					targetAdmissionId: "admission-admit",
+				}),
+			],
+		]);
+		expect(admissions).toEqual([]);
+		expect(issues.map((issue) => (issue as { code: string }).code)).toEqual(
+			expect.arrayContaining(["missing-work-item-domain-action-admission-proposal"]),
+		);
+
+		policies.down([
+			[
+				"DATA",
+				{
+					kind: "work-item-domain-action-admission-policy",
+					policyId: "late-policy",
+					actionKinds: ["mark-ready"],
+					allowedOutcomes: ["admit"],
+				},
+			],
+		]);
+		proposals.down([
+			["DATA", workItemActionProposal("proposal-merge", "mark-ready")],
+			["DATA", workItemActionProposal("proposal-admit", "mark-ready")],
+		]);
+
+		expect(admissions.map((admission) => admission.admissionId)).toEqual([
+			"admission-admit",
+			"admission-merge",
+		]);
+		expect(admissions.at(-1)).toMatchObject({
+			state: "merged",
+			targetAdmissionId: "admission-admit",
+		});
+	});
+});
diff --git a/packages/ts/src/__tests__/agent-runtime.part-13.test.ts b/packages/ts/src/__tests__/agent-runtime.part-13.test.ts
new file mode 100644
index 00000000..ac789fc0
--- /dev/null
+++ b/packages/ts/src/__tests__/agent-runtime.part-13.test.ts
@@ -0,0 +1,860 @@
+import { afterEach, describe, expect, it } from "vitest";
+import type { DataIssue } from "../data/index.js";
+import type {
+	ToolProviderAdapterBinding,
+	ToolProviderAdapterRuntimeStatus,
+} from "../executors/tool-provider-runtime.js";
+import { attachToolProviderAdapterRuntime } from "../executors/tool-provider-runtime.js";
+import { type Graph, graph } from "../graph/graph.js";
+import type { Node } from "../node/node.js";
+import {
+	type AgentRequestFact,
+	type AgentRequestIssued,
+	type AgentRequestStatus,
+	type AgentRequestStatusChanged,
+	type AgentRuntimeAuditRecord,
+	type EffectRunResult,
+	type ExecutorOutcome,
+	type ExecutorRoute,
+	effectRunCompletionProjector,
+	localBuiltinToolProviderCatalog,
+	requestToolProviderAdapterRun,
+	resolveToolProviderExecutionPolicies,
+	type SourceRef,
+	type ToolProviderAdapterInput,
+	type ToolProviderAdapterRunRequested,
+	type ToolProviderAdapterRunResult,
+	type ToolProviderAdapterRunStatus,
+	toolProviderAdapterInputProjector,
+} from "../orchestration/agent-runtime.js";
+import {
+	type WorkItemEffectRequested,
+	type WorkItemEvidenceRecorded,
+	type WorkItemSeed,
+	workItemEffectResultMapper,
+	workItemEffectRunProjector,
+} from "../orchestration/work-item-runtime.js";
+
+const forbiddenProviderPayloadPattern =
+	/rawResponse|stdout|stderr|stack|apiKey|password|token|credential|cookie|authorization|authHeader|bearer|privateKey|secret|providerClient|oauthState|subprocessHandle|transport|sdkObject|SECRET_RUNTIME/i;
+
+const activeHarnessDisposers: (() => void)[] = [];
+
+afterEach(() => {
+	for (const dispose of activeHarnessDisposers.splice(0)) dispose();
+});
+
+function workItemSeed(workItemId = "wi-dogfood"): WorkItemSeed {
+	return {
+		kind: "work-item",
+		workItemId,
+		workItemKind: "issue",
+		lifecycleStatus: "open",
+		sourceRefs: [{ kind: "work-item", id: workItemId }],
+	};
+}
+
+function workItemEffectRequest(
+	opts: {
+		readonly requestId?: string;
+		readonly workItemId?: string;
+		readonly effectRunId?: string;
+	} = {},
+): WorkItemEffectRequested {
+	return {
+		kind: "work-item-effect-requested",
+		requestId: opts.requestId ?? "wi-effect-dogfood",
+		workItemId: opts.workItemId ?? "wi-dogfood",
+		effectRunId: opts.effectRunId ?? "effect-dogfood",
+		effectKind: "tool-provider-dogfood",
+		executionInputRevision: 1,
+		planId: "plan-dogfood",
+		planMemberId: "tool-member",
+		sourceRefs: [{ kind: "acceptance-criteria", id: "csp-8-dogfood" }],
+		goal: {
+			kind: "tool-provider-dogfood",
+			summary: "prove WorkItem evidence through explicit tool adapter runtime",
+		},
+		agentRunId: "agent-dogfood",
+	};
+}
+
+function toolRequest(
+	opts: {
+		readonly requestId?: string;
+		readonly operationId?: string;
+		readonly effectRunId?: string;
+		readonly providerId?: string;
+		readonly toolName?: string;
+		readonly operation?: string;
+	} = {},
+): AgentRequestIssued {
+	const requestId = opts.requestId ?? "tool-request-dogfood";
+	return {
+		kind: "issued",
+		requestId,
+		operationId: opts.operationId ?? "tool-op-dogfood",
+		effectRunId: opts.effectRunId ?? "effect-dogfood",
+		agentRunId: "agent-dogfood",
+		requestKind: "executor",
+		required: true,
+		input: {
+			inputId: `${requestId}:input`,
+			inputKind: "tool-call",
+			dataMode: "inline",
+			value: {
+				kind: "tool-call",
+				toolName: opts.toolName ?? "file.read",
+				operation: opts.operation ?? "read",
+				arguments: { path: "README.md" },
+			},
+			subjectRefs: [{ kind: "work-item", id: "wi-dogfood" }],
+		},
+		sourceRefs: [{ kind: "work-item", id: "wi-dogfood" }],
+	};
+}
+
+function routeFor(
+	request: AgentRequestIssued,
+	profile: { executorId: string; profileId: string },
+): ExecutorRoute {
+	return {
+		kind: "executor-route",
+		routeId: `${request.requestId}:route`,
+		requestId: request.requestId,
+		operationId: request.operationId,
+		inputId: request.input?.inputId,
+		inputKind: "tool-call",
+		executorId: profile.executorId,
+		profileId: profile.profileId,
+	};
+}
+
+function effectRunStatusForOutcome(outcome: ExecutorOutcome): EffectRunResult["status"] {
+	if (outcome.kind === "result") return "completed";
+	if (outcome.kind === "failure") return "failed";
+	if (outcome.kind === "blocked") return "blocked";
+	return outcome.kind;
+}
+
+function terminalRequestStatusForOutcome(outcome: ExecutorOutcome): AgentRequestStatus {
+	if (outcome.kind === "result") return "completed";
+	if (outcome.kind === "failure") return "failed";
+	if (outcome.kind === "blocked") return "blocked";
+	return outcome.kind;
+}
+
+function visibleOutcomeResultCandidates(
+	g: Graph,
+	opts: {
+		readonly outcomes: Node<ExecutorOutcome>;
+		readonly requestStatus: Node<AgentRequestStatusChanged>;
+		readonly issues: Node<DataIssue>;
+		readonly audit: Node<AgentRuntimeAuditRecord>;
+	},
+): { readonly candidates: Node<EffectRunResult>; readonly dispose: () => void } {
+	const candidates = g.node<EffectRunResult>([], null, {
+		name: "dogfoodVisibleOutcomeResultCandidates",
+	});
+	const state = {
+		outcomes: new Map<string, ExecutorOutcome>(),
+		statusByRequest: new Map<string, AgentRequestStatusChanged>(),
+		issuesByRequest: new Map<string, DataIssue[]>(),
+		auditByRequest: new Map<string, string[]>(),
+		auditByOutcome: new Map<string, string[]>(),
+		emitted: new Set<string>(),
+	};
+	function tryEmit(): void {
+		for (const outcome of state.outcomes.values()) {
+			if (state.emitted.has(outcome.outcomeId)) continue;
+			const status = state.statusByRequest.get(outcome.requestId);
+			const outcomeAuditRefs = state.auditByOutcome.get(outcome.outcomeId);
+			if (
+				status === undefined ||
+				outcomeAuditRefs === undefined ||
+				status.operationId !== outcome.operationId ||
+				status.status !== terminalRequestStatusForOutcome(outcome)
+			) {
+				continue;
+			}
+			const base = {
+				kind: "effect-run-result",
+				resultId: `${status.effectRunId}:${outcome.outcomeId}:result`,
+				effectRunId: status.effectRunId,
+				status: effectRunStatusForOutcome(outcome),
+				operationId: outcome.operationId,
+				subjectRefs: [{ kind: "work-item", id: "wi-dogfood" }],
+				sourceRefs: uniqueRefs([
+					{ kind: "executor-outcome", id: outcome.outcomeId },
+					{ kind: "agent-request", id: outcome.requestId },
+					{ kind: "tool-provider-adapter-run", id: runtimeRunId(outcome) },
+					...(outcome.evidenceRefs ?? []),
+					...(status.sourceRefs ?? []),
+				]),
+				issues: uniqueIssues([
+					...(outcome.issues ?? []),
+					...(status.issues ?? []),
+					...(state.issuesByRequest.get(outcome.requestId) ?? []),
+				]),
+				auditRefs: uniqueStrings([
+					...(state.auditByRequest.get(outcome.requestId) ?? []),
+					...outcomeAuditRefs,
+				]),
+				completedAtMs: outcome.occurredAtMs,
+				metadata: { outcomeId: outcome.outcomeId, requestStatus: status.status },
+			} satisfies Omit<EffectRunResult, "output" | "error" | "needs" | "reason" | "timeoutMs">;
+			const result =
+				outcome.kind === "result"
+					? ({ ...base, output: outcome.result } satisfies EffectRunResult)
+					: outcome.kind === "failure"
+						? ({ ...base, error: outcome.error } satisfies EffectRunResult)
+						: outcome.kind === "blocked"
+							? ({ ...base, needs: outcome.needs } satisfies EffectRunResult)
+							: outcome.kind === "timeout"
+								? ({ ...base, timeoutMs: outcome.timeoutMs } satisfies EffectRunResult)
+								: ({ ...base, reason: outcome.reason } satisfies EffectRunResult);
+			state.emitted.add(outcome.outcomeId);
+			candidates.down([["DATA", result]]);
+		}
+	}
+	const unsubscribes = [
+		opts.outcomes.subscribe((msg) => {
+			if (msg[0] !== "DATA") return;
+			const outcome = msg[1] as ExecutorOutcome;
+			state.outcomes.set(outcome.outcomeId, outcome);
+			tryEmit();
+		}),
+		opts.requestStatus.subscribe((msg) => {
+			if (msg[0] !== "DATA") return;
+			const status = msg[1] as AgentRequestStatusChanged;
+			state.statusByRequest.set(status.requestId, status);
+			tryEmit();
+		}),
+		opts.issues.subscribe((msg) => {
+			if (msg[0] !== "DATA") return;
+			const issue = msg[1] as DataIssue;
+			if (issue.subjectId !== undefined) {
+				const bucket = state.issuesByRequest.get(issue.subjectId) ?? [];
+				bucket.push(issue);
+				state.issuesByRequest.set(issue.subjectId, bucket);
+			}
+			tryEmit();
+		}),
+		opts.audit.subscribe((msg) => {
+			if (msg[0] !== "DATA") return;
+			const audit = msg[1] as AgentRuntimeAuditRecord;
+			if (audit.subjectId !== undefined) {
+				const bucket = state.auditByRequest.get(audit.subjectId) ?? [];
+				bucket.push(audit.id);
+				state.auditByRequest.set(audit.subjectId, bucket);
+			}
+			const outcomeId = audit.metadata?.outcomeId;
+			if (typeof outcomeId === "string") {
+				const bucket = state.auditByOutcome.get(outcomeId) ?? [];
+				bucket.push(audit.id);
+				state.auditByOutcome.set(outcomeId, bucket);
+			}
+			tryEmit();
+		}),
+	];
+	return {
+		candidates,
+		dispose() {
+			for (const unsubscribe of unsubscribes) unsubscribe();
+		},
+	};
+}
+
+function runtimeRunId(outcome: ExecutorOutcome): string {
+	const runId = outcome.metadata?.runId;
+	if (typeof runId !== "string") {
+		throw new Error("expected explicit runId in ExecutorOutcome metadata");
+	}
+	return runId;
+}
+
+function uniqueStrings(values: readonly string[]): readonly string[] | undefined {
+	const unique = Array.from(new Set(values));
+	return unique.length === 0 ? undefined : unique;
+}
+
+function uniqueRefs(refs: readonly SourceRef[]): readonly SourceRef[] {
+	const seen = new Set<string>();
+	const out: SourceRef[] = [];
+	for (const ref of refs) {
+		const key = `${ref.kind}:${ref.id}:${JSON.stringify(ref.metadata ?? {})}`;
+		if (seen.has(key)) continue;
+		seen.add(key);
+		out.push(ref);
+	}
+	return out;
+}
+
+function uniqueIssues(issues: readonly DataIssue[]): readonly DataIssue[] | undefined {
+	const seen = new Set<string>();
+	const out: DataIssue[] = [];
+	for (const issue of issues) {
+		const key = `${issue.code}:${issue.subjectId ?? ""}:${issue.message}`;
+		if (seen.has(key)) continue;
+		seen.add(key);
+		out.push(issue);
+	}
+	return out.length === 0 ? undefined : out;
+}
+
+function createDogfoodHarness(
+	binding: ToolProviderAdapterBinding,
+	opts: {
+		readonly retention?: Parameters<typeof attachToolProviderAdapterRuntime>[1]["retention"];
+		readonly publicText?: Parameters<typeof attachToolProviderAdapterRuntime>[1]["publicText"];
+	} = {},
+) {
+	const g = graph();
+	const workItems = g.node<WorkItemSeed>([], null, { name: "dogfood-work-items" });
+	const effectRequests = g.node<WorkItemEffectRequested>([], null, {
+		name: "dogfood-effect-requests",
+	});
+	const requestFacts = g.node<AgentRequestFact>([], null, { name: "dogfood-request-facts" });
+	const routes = g.node<ExecutorRoute>([], null, { name: "dogfood-routes" });
+	const catalogs = g.node<ReturnType<typeof localBuiltinToolProviderCatalog>>([], null, {
+		name: "dogfood-catalogs",
+	});
+	const resolutions = g.node<ReturnType<typeof resolveToolProviderExecutionPolicies>[number]>(
+		[],
+		null,
+		{ name: "dogfood-resolutions" },
+	);
+	const runRequests = g.node<ToolProviderAdapterRunRequested>([], null, {
+		name: "dogfood-run-requests",
+	});
+	const effectRuns = workItemEffectRunProjector(g, { workItems, effectRequests });
+	const adapterInputs = toolProviderAdapterInputProjector(g, {
+		requestFacts,
+		executorRoutes: [routes],
+		toolProviderCatalogs: [catalogs],
+		policyResolutions: [resolutions],
+	});
+	const runtime = attachToolProviderAdapterRuntime(g, {
+		inputs: adapterInputs.inputs,
+		runRequests: [runRequests],
+		autoRunReadyInputs: false,
+		bindings: [binding],
+		retention: opts.retention,
+		publicText: opts.publicText,
+		now: () => 1000,
+	});
+	const resultCandidates = visibleOutcomeResultCandidates(g, {
+		outcomes: runtime.outcomes,
+		requestStatus: runtime.status,
+		issues: runtime.issues,
+		audit: runtime.audit,
+	});
+	const completion = effectRunCompletionProjector(g, {
+		effectRuns: effectRuns.effectRuns,
+		requestFacts: [requestFacts],
+		requestStatuses: [runtime.status],
+		resultCandidates: [resultCandidates.candidates],
+		now: () => 1001,
+	});
+	const evidenceMapper = workItemEffectResultMapper(g, {
+		workItems,
+		effectRuns: effectRuns.effectRuns,
+		effectRunResults: completion.results,
+		effectRequests,
+		now: () => 1002,
+	});
+	const seen = {
+		inputs: [] as ToolProviderAdapterInput[],
+		outcomes: [] as ExecutorOutcome[],
+		agentStatus: [] as AgentRequestStatusChanged[],
+		runStatus: [] as ToolProviderAdapterRunStatus[],
+		runtimeStatus: [] as ToolProviderAdapterRuntimeStatus[],
+		issues: [] as DataIssue[],
+		audit: [] as AgentRuntimeAuditRecord[],
+		results: [] as EffectRunResult[],
+		resultCandidates: [] as EffectRunResult[],
+		evidence: [] as WorkItemEvidenceRecorded[],
+	};
+	const unsubscribes = [
+		adapterInputs.inputs.subscribe((msg) => msg[0] === "DATA" && seen.inputs.push(msg[1])),
+		runtime.outcomes.subscribe((msg) => msg[0] === "DATA" && seen.outcomes.push(msg[1])),
+		runtime.status.subscribe((msg) => msg[0] === "DATA" && seen.agentStatus.push(msg[1])),
+		runtime.runStatus.subscribe((msg) => msg[0] === "DATA" && seen.runStatus.push(msg[1])),
+		runtime.runtimeStatus.subscribe((msg) => msg[0] === "DATA" && seen.runtimeStatus.push(msg[1])),
+		runtime.issues.subscribe((msg) => msg[0] === "DATA" && seen.issues.push(msg[1])),
+		runtime.audit.subscribe((msg) => msg[0] === "DATA" && seen.audit.push(msg[1])),
+		resultCandidates.candidates.subscribe(
+			(msg) => msg[0] === "DATA" && seen.resultCandidates.push(msg[1]),
+		),
+		completion.results.subscribe((msg) => msg[0] === "DATA" && seen.results.push(msg[1])),
+		evidenceMapper.evidence.subscribe((msg) => msg[0] === "DATA" && seen.evidence.push(msg[1])),
+		evidenceMapper.views.subscribe(() => {}),
+	];
+	let disposed = false;
+
+	function publishBaseFacts(request: AgentRequestIssued): void {
+		workItems.down([["DATA", workItemSeed()]]);
+		effectRequests.down([["DATA", workItemEffectRequest({ effectRunId: request.effectRunId })]]);
+		requestFacts.down([["DATA", request]]);
+	}
+
+	function seed(request: AgentRequestIssued = toolRequest()): ToolProviderAdapterInput {
+		const catalog = localBuiltinToolProviderCatalog({ providerId: binding.providerId });
+		const profile = catalog.profiles[0];
+		if (profile === undefined) throw new Error("expected profile");
+		const route = routeFor(request, profile);
+		const [resolution] = resolveToolProviderExecutionPolicies({
+			request,
+			routes: [route],
+			catalogs: [catalog],
+		});
+		if (resolution === undefined) throw new Error("expected policy resolution");
+		publishBaseFacts(request);
+		catalogs.down([["DATA", catalog]]);
+		routes.down([["DATA", route]]);
+		resolutions.down([["DATA", resolution]]);
+		const input = seen.inputs.at(-1);
+		if (input === undefined || input.status !== "ready") throw new Error("expected ready input");
+		return input;
+	}
+
+	function seedPendingRoute(request: AgentRequestIssued): ToolProviderAdapterInput {
+		const catalog = localBuiltinToolProviderCatalog({ providerId: binding.providerId });
+		const [resolution] = resolveToolProviderExecutionPolicies({
+			request,
+			routes: [],
+			catalogs: [catalog],
+		});
+		if (resolution === undefined) throw new Error("expected pending route resolution");
+		publishBaseFacts(request);
+		catalogs.down([["DATA", catalog]]);
+		resolutions.down([["DATA", resolution]]);
+		const input = seen.inputs.at(-1);
+		if (input === undefined || input.status === "ready") {
+			throw new Error("expected non-ready adapter input");
+		}
+		return input;
+	}
+
+	const harness = {
+		g,
+		runRequests,
+		runtime,
+		seen,
+		seed,
+		seedPendingRoute,
+		request(
+			input: ToolProviderAdapterInput,
+			opts: Pick<ToolProviderAdapterRunRequested, "runId" | "attempt" | "reason"> & {
+				readonly sourceRefs?: readonly SourceRef[];
+				readonly metadata?: Record<string, unknown>;
+			},
+		) {
+			const request = requestToolProviderAdapterRun(input, {
+				runId: opts.runId,
+				attempt: opts.attempt,
+				reason: opts.reason,
+				sourceRefs: opts.sourceRefs,
+				metadata: opts.metadata,
+			});
+			runRequests.down([["DATA", request]]);
+			return request;
+		},
+		dispose() {
+			if (disposed) return;
+			disposed = true;
+			runtime.dispose();
+			resultCandidates.dispose();
+			for (const unsubscribe of unsubscribes) unsubscribe();
+		},
+	};
+	activeHarnessDisposers.push(() => harness.dispose());
+	return harness;
+}
+
+describe("CSP-8 dogfood evidence integration through explicit tool adapter runs (D359-D362/D371/D387/D389/D392-D394)", () => {
+	it("maps a successful explicit tool run through ExecutorOutcome into WorkItem evidence", () => {
+		const calls: ToolProviderAdapterInput[] = [];
+		const harness = createDogfoodHarness({
+			providerId: "dogfood-provider",
+			run(input) {
+				calls.push(input);
+				return {
+					kind: "result",
+					result: {
+						kind: "tool-output",
+						value: { ok: true },
+						refs: [{ kind: "artifact", id: "artifact-success" }],
+						summary: "fake bounded provider-neutral result",
+						metadata: { source: "fake-provider" },
+					},
+					metadata: { providerSummary: "bounded metadata" },
+					usage: { latencyMs: 5 },
+				};
+			},
+		});
+		const input = harness.seed();
+		harness.request(input, { runId: "run-success", attempt: 1, reason: "manual" });
+
+		expect(calls).toEqual([input]);
+		expect(harness.seen.outcomes).toEqual([
+			expect.objectContaining({
+				kind: "result",
+				outcomeId: expect.stringContaining("run-success"),
+			}),
+		]);
+		expect(harness.seen.agentStatus.map((status) => status.status)).toEqual([
+			"in-flight",
+			"completed",
+		]);
+		expect(harness.seen.results).toEqual([
+			expect.objectContaining({ status: "completed", effectRunId: "effect-dogfood" }),
+		]);
+		expect(harness.seen.evidence).toEqual([
+			expect.objectContaining({
+				workItemId: "wi-dogfood",
+				status: "completed",
+				output: expect.objectContaining({ summary: "fake bounded provider-neutral result" }),
+				sourceRefs: expect.arrayContaining([
+					{ kind: "executor-outcome", id: harness.seen.outcomes[0]?.outcomeId },
+					{ kind: "tool-provider-adapter-run", id: "run-success" },
+					{ kind: "tool-provider-adapter-input", id: input.adapterInputId },
+				]),
+			}),
+		]);
+		expect(
+			JSON.stringify({
+				outcomes: harness.seen.outcomes,
+				results: harness.seen.results,
+				evidence: harness.seen.evidence,
+				agentStatus: harness.seen.agentStatus,
+				runStatus: harness.seen.runStatus,
+				runtimeStatus: harness.seen.runtimeStatus,
+				issues: harness.seen.issues,
+				audit: harness.seen.audit,
+			}),
+		).not.toMatch(forbiddenProviderPayloadPattern);
+		harness.dispose();
+	});
+
+	it.each([
+		[
+			"failure",
+			{
+				kind: "failure",
+				error: {
+					kind: "issue",
+					code: "fake-provider-failure",
+					message: "provider-declared public failure",
+					severity: "error",
+				},
+				retryable: false,
+			} satisfies ToolProviderAdapterRunResult,
+			"failed",
+		],
+		[
+			"blocked",
+			{
+				kind: "blocked",
+				needs: [{ kind: "approval", message: "needs explicit approval" }],
+			} satisfies ToolProviderAdapterRunResult,
+			"blocked",
+		],
+		[
+			"timeout",
+			{ kind: "timeout", timeoutMs: 25, retryable: true } satisfies ToolProviderAdapterRunResult,
+			"timeout",
+		],
+		[
+			"canceled",
+			{ kind: "canceled", reason: "user canceled" } satisfies ToolProviderAdapterRunResult,
+			"canceled",
+		],
+	])("maps provider %s through visible outcome/status/issues/audit facts before WorkItem evidence", (_name, result, expectedEvidenceStatus) => {
+		const calls: ToolProviderAdapterInput[] = [];
+		const harness = createDogfoodHarness({
+			providerId: "dogfood-provider",
+			run(input) {
+				calls.push(input);
+				return result;
+			},
+		});
+		const input = harness.seed(
+			toolRequest({ requestId: `tool-request-${expectedEvidenceStatus}` }),
+		);
+		expect(harness.seen.evidence).toEqual([]);
+		harness.request(input, {
+			runId: `run-${expectedEvidenceStatus}`,
+			attempt: 1,
+			reason: "manual",
+		});
+
+		expect(calls).toHaveLength(1);
+		expect(harness.seen.outcomes.at(-1)?.kind).toBe(result.kind);
+		expect(harness.seen.agentStatus.at(-1)?.status).toBe(
+			expectedEvidenceStatus === "failed" ? "failed" : expectedEvidenceStatus,
+		);
+		expect(harness.seen.audit).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({ kind: "tool-provider-adapter-runtime-finished" }),
+			]),
+		);
+		expect(harness.seen.evidence).toEqual([
+			expect.objectContaining({ status: expectedEvidenceStatus }),
+		]);
+		harness.dispose();
+	});
+
+	it("keeps missing-input and stale/mismatched request outcomes out of WorkItem evidence", () => {
+		const calls: ToolProviderAdapterInput[] = [];
+		const harness = createDogfoodHarness({
+			providerId: "dogfood-provider",
+			run(input) {
+				calls.push(input);
+				return { kind: "result", result: { kind: "tool-output", summary: "should not run" } };
+			},
+		});
+		const validInput = harness.seed(toolRequest({ requestId: "tool-request-valid" }));
+		const notReadyInput = harness.seedPendingRoute(
+			toolRequest({ requestId: "tool-request-not-ready" }),
+		);
+
+		harness.runRequests.down([
+			[
+				"DATA",
+				{
+					kind: "tool-provider-adapter-run-requested",
+					runId: "run-missing-input",
+					adapterInputId: "missing-adapter-input",
+					requestId: validInput.requestId,
+					operationId: validInput.operationId,
+					attempt: 1,
+					reason: "manual",
+				},
+			],
+			[
+				"DATA",
+				requestToolProviderAdapterRun(validInput, {
+					runId: "run-valid-control",
+					attempt: 1,
+					reason: "manual",
+				}),
+			],
+			[
+				"DATA",
+				requestToolProviderAdapterRun(notReadyInput, {
+					runId: "run-not-ready-request",
+					attempt: 1,
+					reason: "manual",
+				}),
+			],
+			[
+				"DATA",
+				{
+					...requestToolProviderAdapterRun(validInput, {
+						runId: "run-stale-request",
+						attempt: 2,
+						reason: "manual",
+					}),
+					requestId: "different-request",
+				},
+			],
+		]);
+
+		expect(calls).toHaveLength(1);
+		expect(harness.seen.runStatus).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({ runId: "run-missing-input", status: "missing-input" }),
+				expect.objectContaining({ runId: "run-not-ready-request", status: "mismatched-request" }),
+				expect.objectContaining({ runId: "run-stale-request", status: "mismatched-request" }),
+			]),
+		);
+		for (const invalidRunId of ["run-not-ready-request", "run-stale-request"]) {
+			expect(harness.seen.runStatus).not.toEqual(
+				expect.arrayContaining([
+					expect.objectContaining({ runId: invalidRunId, status: "retention-gap" }),
+				]),
+			);
+		}
+		expect(harness.seen.issues).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({ code: "tool-provider-adapter-run-request-missing-input" }),
+				expect.objectContaining({ code: "tool-provider-adapter-run-request-input-not-ready" }),
+				expect.objectContaining({ code: "tool-provider-adapter-run-request-stale-request" }),
+			]),
+		);
+		expect(harness.seen.evidence).toHaveLength(1);
+		const evidenceRefs = harness.seen.evidence[0]?.sourceRefs ?? [];
+		expect(evidenceRefs).toEqual(
+			expect.arrayContaining([{ kind: "tool-provider-adapter-run", id: "run-valid-control" }]),
+		);
+		for (const invalidRunId of [
+			"run-missing-input",
+			"run-not-ready-request",
+			"run-stale-request",
+		]) {
+			expect(evidenceRefs).not.toEqual(
+				expect.arrayContaining([{ kind: "tool-provider-adapter-run", id: invalidRunId }]),
+			);
+		}
+		harness.dispose();
+	});
+
+	it("reports retention-gap without executing binding or recording WorkItem evidence", () => {
+		const calls: ToolProviderAdapterInput[] = [];
+		const harness = createDogfoodHarness(
+			{
+				providerId: "dogfood-provider",
+				run(input) {
+					calls.push(input);
+					return { kind: "result", result: { kind: "tool-output", summary: "should not run" } };
+				},
+			},
+			{ retention: { adapterInputs: { order: "fifo", maxSize: 1 } } },
+		);
+		const first = harness.seed(toolRequest({ requestId: "tool-request-retained-1" }));
+		harness.seed(toolRequest({ requestId: "tool-request-retained-2" }));
+
+		harness.request(first, { runId: "run-retention-gap", attempt: 1, reason: "manual" });
+
+		expect(calls).toEqual([]);
+		expect(harness.seen.outcomes).toEqual([]);
+		expect(harness.seen.evidence).toEqual([]);
+		expect(harness.seen.runStatus).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({ runId: "run-retention-gap", status: "retention-gap" }),
+			]),
+		);
+		expect(harness.seen.runtimeStatus).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({
+					status: "retention-gap",
+					adapterInputId: first.adapterInputId,
+				}),
+			]),
+		);
+		expect(harness.seen.issues).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({
+					code: "tool-provider-adapter-runtime-retention-gap",
+				}),
+			]),
+		);
+		harness.dispose();
+	});
+
+	it("rejects repeated same adapterInputId/attempt with different runId without a second execution", () => {
+		const calls: ToolProviderAdapterInput[] = [];
+		const harness = createDogfoodHarness({
+			providerId: "dogfood-provider",
+			run(input) {
+				calls.push(input);
+				return { kind: "result", result: { kind: "tool-output", summary: "first run only" } };
+			},
+		});
+		const input = harness.seed();
+		harness.request(input, { runId: "run-coordinate-1", attempt: 1, reason: "manual" });
+		harness.request(input, { runId: "run-coordinate-2", attempt: 1, reason: "manual" });
+
+		expect(calls).toHaveLength(1);
+		expect(harness.seen.evidence).toHaveLength(1);
+		expect(harness.seen.runStatus).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({
+					runId: "run-coordinate-2",
+					status: "mismatched-request",
+				}),
+			]),
+		);
+		const duplicateStatuses = harness.seen.runStatus.filter(
+			(status) => status.runId === "run-coordinate-2",
+		);
+		expect(duplicateStatuses).toEqual(
+			expect.arrayContaining([expect.objectContaining({ status: "mismatched-request" })]),
+		);
+		for (const forbiddenStatus of [
+			"retention-gap",
+			"result",
+			"failure",
+			"blocked",
+			"timeout",
+			"canceled",
+		]) {
+			expect(duplicateStatuses.map((status) => status.status)).not.toContain(forbiddenStatus);
+		}
+		expect(harness.seen.issues).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({
+					code: "tool-provider-adapter-runtime-duplicate-execution-coordinate",
+				}),
+			]),
+		);
+		harness.dispose();
+	});
+
+	it("bounds fake provider public material and keeps runtime-private keys out of evidence", () => {
+		const harness = createDogfoodHarness(
+			{
+				providerId: "dogfood-provider",
+				run() {
+					return {
+						kind: "result",
+						result: {
+							kind: "tool-output",
+							value: { ok: true },
+							refs: [
+								{
+									kind: "artifact",
+									id: "artifact-safe",
+									metadata: { rawResponse: "SECRET_RUNTIME_REF" },
+								},
+							],
+							summary: "summary text that should be truncated",
+							metadata: { note: "metadata text that should be truncated" },
+						},
+						evidenceRefs: [
+							{
+								kind: "artifact",
+								id: "evidence-safe",
+								metadata: { stdout: "SECRET_RUNTIME_EVIDENCE" },
+							},
+						],
+						metadata: { providerSummary: "metadata text that should be truncated" },
+					};
+				},
+			},
+			{ publicText: { maxSummaryChars: 12, maxMetadataStringChars: 10 } },
+		);
+		const input = harness.seed();
+		harness.request(input, { runId: "run-sanitized", attempt: 1, reason: "manual" });
+
+		const outcome = harness.seen.outcomes[0];
+		if (outcome?.kind !== "result") throw new Error("expected result outcome");
+		expect(outcome.result.summary).toBe("summary t...");
+		expect(outcome.result.metadata).toEqual({ note: "metadat..." });
+		expect(outcome.result.refs).toEqual([{ kind: "artifact", id: "artifact-safe" }]);
+		expect(outcome.evidenceRefs).toEqual([{ kind: "artifact", id: "evidence-safe" }]);
+		expect(harness.seen.evidence[0]?.output).toEqual(outcome.result);
+		expect(harness.seen.evidence[0]?.issues).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({
+					code: "tool-provider-adapter-runtime-public-text-truncated",
+				}),
+			]),
+		);
+		expect(
+			JSON.stringify({
+				outcome,
+				evidence: harness.seen.evidence,
+				results: harness.seen.results,
+				resultCandidates: harness.seen.resultCandidates,
+				agentStatus: harness.seen.agentStatus,
+				runStatus: harness.seen.runStatus,
+				runtimeStatus: harness.seen.runtimeStatus,
+				issues: harness.seen.issues,
+				audit: harness.seen.audit,
+			}),
+		).not.toMatch(forbiddenProviderPayloadPattern);
+		harness.dispose();
+	});
+});
diff --git a/packages/ts/src/__tests__/batch-dynamic.test.ts b/packages/ts/src/__tests__/batch-dynamic.test.ts
new file mode 100644
index 00000000..3a43ac11
--- /dev/null
+++ b/packages/ts/src/__tests__/batch-dynamic.test.ts
@@ -0,0 +1,100 @@
+import { describe, expect, it } from "vitest";
+import type { Ctx, Message } from "../index.js";
+import { batch, depLatest, dynamicNode, node } from "../index.js";
+
+function collect(n: { subscribe(s: (m: Message) => void): () => void }) {
+	const msgs: Message[] = [];
+	const unsub = n.subscribe((m) => msgs.push(m));
+	return { msgs, unsub };
+}
+const types = (msgs: Message[]) => msgs.map((m) => m[0]);
+
+describe("batch (R-batch-coalesce / D12)", () => {
+	it("coalesces a diamond join to ONE recompute when both sources change", () => {
+		let fires = 0;
+		const a = node<number>([], null, { initial: 1 });
+		const b = node<number>([], null, { initial: 1 });
+		const d = node<number>([a, b], (ctx: Ctx) => {
+			fires++;
+			ctx.down([["DATA", (depLatest(ctx, 0) as number) + (depLatest(ctx, 1) as number)]]);
+		});
+		collect(d);
+		expect(d.cache).toBe(2);
+
+		fires = 0;
+		batch(() => {
+			a.down([["DATA", 10]]);
+			b.down([["DATA", 20]]);
+		});
+		expect(fires).toBe(1); // one recompute, not two
+		expect(d.cache).toBe(30);
+	});
+
+	it("defers DATA to commit: downstream sees DIRTY during the batch, DATA after", () => {
+		const a = node<number>([], null, { initial: 1 });
+		const { msgs } = collect(a);
+		msgs.length = 0;
+		batch(() => {
+			a.down([["DATA", 9]]);
+			// inside the batch: DIRTY emitted, DATA still deferred
+			expect(types(msgs)).toEqual(["DIRTY"]);
+			expect(a.cache).toBe(1); // not yet committed
+		});
+		expect(types(msgs)).toEqual(["DIRTY", "DATA"]);
+		expect(a.cache).toBe(9);
+	});
+
+	it("rollback on throw discards deferred emissions (downstream un-dirties)", () => {
+		const a = node<number>([], null, { initial: 1 });
+		const { msgs } = collect(a);
+		msgs.length = 0;
+		expect(() =>
+			batch(() => {
+				a.down([["DATA", 99]]);
+				throw new Error("abort");
+			}),
+		).toThrow("abort");
+		expect(a.cache).toBe(1); // unchanged
+		expect(types(msgs)).toEqual(["DIRTY", "RESOLVED"]); // dirty balanced by resolved
+	});
+
+	it("bctx.rollback() is the explicit escape hatch", () => {
+		const a = node<number>([], null, { initial: 1 });
+		collect(a);
+		batch((bctx) => {
+			a.down([["DATA", 50]]);
+			bctx.rollback();
+		});
+		expect(a.cache).toBe(1);
+	});
+});
+
+describe("dynamicNode (R-dynamic-node / D35; D49 — no equals-absorption)", () => {
+	it("reads a selected dep; an unread dep's change re-emits the value as DATA (D49)", () => {
+		const sel = node<"a" | "b">([], null, { initial: "a" });
+		const a = node<number>([], null, { initial: 100 });
+		const b = node<number>([], null, { initial: 200 });
+		const router = dynamicNode<number>([sel, a, b], (ctx: Ctx) => {
+			const which = ctx.track?.(0) as "a" | "b";
+			const value = which === "a" ? (ctx.track?.(1) as number) : (ctx.track?.(2) as number);
+			ctx.down([["DATA", value]]);
+		});
+		const { msgs } = collect(router);
+		expect(router.cache).toBe(100); // sel="a" -> reads a
+		msgs.length = 0;
+
+		// change the UNREAD dep b -> fn fires, re-emits the (unchanged) value 100. D49 removed
+		// equals-absorption: an occurrence is always DATA, never collapsed to RESOLVED. Pair with
+		// distinctUntilChanged if unread-dep silence is required (dedup is opt-in).
+		b.down([["DATA", 999]]);
+		expect(router.cache).toBe(100);
+		expect(types(msgs)).toEqual(["DIRTY", "DATA"]);
+		expect(msgs).toContainEqual(["DATA", 100]);
+
+		// change the READ dep a -> recompute with the new value
+		msgs.length = 0;
+		a.down([["DATA", 111]]);
+		expect(router.cache).toBe(111);
+		expect(msgs).toContainEqual(["DATA", 111]);
+	});
+});
diff --git a/packages/ts/src/__tests__/capability-admission.test.ts b/packages/ts/src/__tests__/capability-admission.test.ts
new file mode 100644
index 00000000..9b0a0bff
--- /dev/null
+++ b/packages/ts/src/__tests__/capability-admission.test.ts
@@ -0,0 +1,331 @@
+import { describe, expect, it } from "vitest";
+import { graph } from "../graph/graph.js";
+import type { BoundaryCapabilityRef } from "../inspection/boundary.js";
+import {
+	type CapabilityAdmission,
+	type CapabilityAdmissionDecision,
+	type CapabilityAdmissionPolicy,
+	type CapabilityAdmissionProposal,
+	type CapabilityAdmissionStatus,
+	capabilityAdmissionProjector,
+	capabilityAdmissionProposal,
+} from "../solutions/capability-admission.js";
+
+describe("solution capability admission (D357)", () => {
+	it("projects product-owned capability admission facts instead of AutoPanel security", () => {
+		const setup = admissionSetup();
+
+		setup.policies.down([
+			[
+				"DATA",
+				{
+					kind: "capability-admission-policy",
+					policyId: "github-auth-policy",
+					capabilityKinds: ["auth"],
+					requiredOnly: true,
+					allowedOutcomes: ["allow", "block"],
+				},
+			],
+		]);
+		setup.proposals.down([
+			[
+				"DATA",
+				capabilityAdmissionProposal({
+					proposalId: "proposal-1",
+					subjectId: "boundary:token",
+					boundaryName: "token",
+					role: "input",
+					capability: authCapability,
+					sourceRefs: [{ kind: "boundary-node", id: "token" }],
+				}),
+			],
+		]);
+		setup.decisions.down([
+			[
+				"DATA",
+				{
+					kind: "capability-admission-decision",
+					decisionId: "decision-1",
+					admissionId: "admission-1",
+					proposalId: "proposal-1",
+					outcome: "block",
+					policyId: "github-auth-policy",
+					reason: "Product registry says OAuth is not ready",
+					decidedAtMs: 123,
+				},
+			],
+		]);
+
+		expect(setup.issues).toEqual([]);
+		expect(setup.admissions).toEqual([
+			expect.objectContaining({
+				kind: "capability-admission",
+				admissionId: "admission-1",
+				proposalId: "proposal-1",
+				subjectId: "boundary:token",
+				state: "blocked",
+				policyId: "github-auth-policy",
+				admittedAtMs: 123,
+			}),
+		]);
+		expect(setup.status.at(-1)).toMatchObject({
+			kind: "capability-admission-status",
+			state: "capability-admission-blocked",
+			capabilityId: "github-oauth",
+			capabilityKind: "auth",
+		});
+		expect(setup.views.at(-1)?.admissionsByProposal.get("proposal-1")?.state).toBe("blocked");
+		expect(setup.views.at(-1)?.admissionsBySubject.get("boundary:token")?.[0].state).toBe(
+			"blocked",
+		);
+	});
+
+	it("surfaces missing policy/proposal as DATA-level issues, not protocol ERROR", () => {
+		const setup = admissionSetup();
+		const issueMsgs = collectMessages(setup.bundle.issues);
+		const statusMsgs = collectMessages(setup.bundle.status);
+
+		setup.proposals.down([
+			[
+				"DATA",
+				capabilityAdmissionProposal({
+					proposalId: "proposal-1",
+					subjectId: "boundary:token",
+					capability: authCapability,
+				}),
+			],
+		]);
+		setup.decisions.down([
+			[
+				"DATA",
+				{
+					kind: "capability-admission-decision",
+					decisionId: "decision-missing-policy",
+					admissionId: "admission-missing-policy",
+					proposalId: "proposal-1",
+					outcome: "allow",
+					policyId: "missing-policy",
+				},
+			],
+			[
+				"DATA",
+				{
+					kind: "capability-admission-decision",
+					decisionId: "decision-missing-proposal",
+					admissionId: "admission-missing-proposal",
+					proposalId: "missing-proposal",
+					outcome: "block",
+				},
+			],
+		]);
+
+		expect(setup.admissions).toEqual([]);
+		expect(setup.issues.map((issue) => issue.code)).toEqual([
+			"missing-capability-admission-policy",
+			"missing-capability-admission-proposal",
+		]);
+		expect(issueMsgs.filter((msg) => msg[0] === "DATA")).toHaveLength(2);
+		expect(statusMsgs.filter((msg) => msg[0] === "DATA")).toHaveLength(2);
+		expect([...issueMsgs, ...statusMsgs].some((msg) => msg[0] === "ERROR")).toBe(false);
+	});
+
+	it("keeps provider/OAuth/config-form registry data out of capability policy vocabulary", () => {
+		const setup = admissionSetup();
+
+		setup.policies.down([
+			[
+				"DATA",
+				{
+					kind: "capability-admission-policy",
+					policyId: "resource-only",
+					capabilityKinds: ["resource"],
+					allowedOutcomes: ["allow"],
+					metadata: {
+						// Product-owned evidence may be referenced, but this helper does not interpret it
+						// as a provider registry, OAuth flow, or config form schema.
+						productRegistryRef: "registry:github",
+					},
+				},
+			],
+		]);
+		setup.proposals.down([
+			[
+				"DATA",
+				capabilityAdmissionProposal({
+					proposalId: "proposal-1",
+					subjectId: "boundary:token",
+					capability: authCapability,
+				}),
+			],
+		]);
+		setup.decisions.down([
+			[
+				"DATA",
+				{
+					kind: "capability-admission-decision",
+					decisionId: "decision-1",
+					admissionId: "admission-1",
+					proposalId: "proposal-1",
+					outcome: "allow",
+					policyId: "resource-only",
+				},
+			],
+		]);
+
+		expect(setup.admissions).toEqual([]);
+		expect(setup.issues.at(-1)).toMatchObject({
+			code: "capability-admission-policy-mismatch",
+		});
+		expect(setup.status.at(-1)).toMatchObject({
+			state: "capability-admission-issue",
+		});
+	});
+
+	it("rejects malformed and duplicate policy/decision facts as visible DataIssue records", () => {
+		const setup = admissionSetup();
+
+		setup.proposals.down([
+			[
+				"DATA",
+				{
+					kind: "capability-admission-proposal",
+					subjectId: "boundary:token-a",
+					capability: authCapability,
+				} as unknown as CapabilityAdmissionProposal,
+			],
+			[
+				"DATA",
+				{
+					kind: "capability-admission-proposal",
+					subjectId: "boundary:token-b",
+					capability: authCapability,
+				} as unknown as CapabilityAdmissionProposal,
+			],
+			[
+				"DATA",
+				capabilityAdmissionProposal({
+					proposalId: "proposal-1",
+					subjectId: "boundary:token",
+					capability: authCapability,
+				}),
+			],
+		]);
+		setup.policies.down([
+			[
+				"DATA",
+				{
+					kind: "capability-admission-policy",
+					policyId: "auth-policy",
+					capabilityKinds: ["auth"],
+					allowedOutcomes: ["allow"],
+				},
+			],
+			[
+				"DATA",
+				{
+					kind: "capability-admission-policy",
+					policyId: "auth-policy",
+					capabilityKinds: ["resource"],
+					allowedOutcomes: ["block"],
+				},
+			],
+			[
+				"DATA",
+				{
+					kind: "capability-admission-policy",
+					policyId: "",
+					capabilityKinds: ["provider"],
+				} as unknown as CapabilityAdmissionPolicy,
+			],
+		]);
+		setup.decisions.down([
+			[
+				"DATA",
+				{
+					kind: "capability-admission-decision",
+					decisionId: "",
+					admissionId: "bad-admission",
+					proposalId: "proposal-1",
+					outcome: "allow",
+				} as unknown as CapabilityAdmissionDecision,
+			],
+			[
+				"DATA",
+				{
+					kind: "capability-admission-decision",
+					decisionId: "decision-ok",
+					admissionId: "admission-ok",
+					proposalId: "proposal-1",
+					outcome: "allow",
+					policyId: "auth-policy",
+				},
+			],
+		]);
+
+		expect(setup.issues.map((issue) => issue.code)).toEqual([
+			"malformed-capability-admission-proposal",
+			"malformed-capability-admission-proposal",
+			"duplicate-capability-admission-policy",
+			"malformed-capability-admission-policy",
+			"malformed-capability-admission-decision",
+		]);
+		expect(setup.admissions).toEqual([
+			expect.objectContaining({
+				admissionId: "admission-ok",
+				state: "allowed",
+				policyId: "auth-policy",
+			}),
+		]);
+	});
+});
+
+const authCapability = {
+	id: "github-oauth",
+	kind: "auth",
+	required: true,
+	sourceRefs: ["github"],
+} satisfies BoundaryCapabilityRef;
+
+function admissionSetup() {
+	const g = graph();
+	const proposals = g.node<CapabilityAdmissionProposal>([], null, { name: "proposals" });
+	const decisions = g.node<CapabilityAdmissionDecision>([], null, { name: "decisions" });
+	const policies = g.node<CapabilityAdmissionPolicy>([], null, { name: "policies" });
+	const bundle = capabilityAdmissionProjector(g, {
+		proposals,
+		decisions,
+		admissionPolicies: [policies],
+		now: () => 456,
+	});
+	return {
+		proposals,
+		decisions,
+		policies,
+		bundle,
+		admissions: collectData<CapabilityAdmission>(bundle.admissions),
+		status: collectData<CapabilityAdmissionStatus>(bundle.status),
+		issues: collectData(bundle.issues),
+		audit: collectData(bundle.audit),
+		views: collectData(bundle.views),
+	};
+}
+
+function collectData<T>(node: {
+	subscribe(sink: (msg: readonly [string, unknown]) => void): () => void;
+}) {
+	const values: T[] = [];
+	node.subscribe((msg) => {
+		if (msg[0] === "DATA") values.push(msg[1] as T);
+	});
+	return values;
+}
+
+function collectMessages<T>(node: {
+	subscribe(sink: (msg: readonly [string, T?]) => void): () => void;
+}) {
+	const messages: readonly [string, T?][] = [];
+	node.subscribe((msg) => {
+		messages.push(msg);
+	});
+	return messages;
+}
diff --git a/packages/ts/src/__tests__/combinators.test.ts b/packages/ts/src/__tests__/combinators.test.ts
new file mode 100644
index 00000000..feedd529
--- /dev/null
+++ b/packages/ts/src/__tests__/combinators.test.ts
@@ -0,0 +1,314 @@
+import { describe, expect, it } from "vitest";
+import {
+	buffer,
+	bufferCount,
+	combine,
+	combineLatest,
+	concat,
+	fromIter,
+	graph,
+	type Message,
+	race,
+	sample,
+	takeUntil,
+	withLatestFrom,
+	zip,
+} from "../index.js";
+
+const data = (msgs: Message[]) =>
+	msgs.filter((m) => m[0] === "DATA").map((m) => (m as ["DATA", unknown])[1]);
+const lastType = (msgs: Message[]) => msgs[msgs.length - 1]?.[0];
+
+// CSP-2.7 Slice 2 (D40 / D45): multi-source combinators + notifier-driven operators as
+// declared-dep nodes (NOT the frozen reference's banned internal-subscribe islands).
+describe("Slice 2 — multi-source combinators (CSP-2.7 / D45)", () => {
+	it("combine emits a tuple of latest values when any dep updates", () => {
+		const g = graph();
+		const a = g.state(1);
+		const b = g.state("x");
+		const c = g.initNode(combine<[number, string]>(), [a, b]);
+		const msgs: Message[] = [];
+		c.subscribe((m) => msgs.push(m));
+		expect(data(msgs)).toEqual([[1, "x"]]);
+		a.set(2);
+		b.set("y");
+		expect(data(msgs)).toEqual([
+			[1, "x"],
+			[2, "x"],
+			[2, "y"],
+		]);
+	});
+
+	it("combineLatest is the combine alias", () => {
+		expect(combineLatest).toBe(combine);
+	});
+
+	it("withLatestFrom pairs primary with the latest secondary (initial pair not dropped)", () => {
+		const g = graph();
+		const p = g.state(1);
+		const s = g.state("a");
+		const w = g.initNode(withLatestFrom<number, string>(), [p, s]);
+		const msgs: Message[] = [];
+		w.subscribe((m) => msgs.push(m));
+		expect(data(msgs)).toEqual([[1, "a"]]); // W1 fix — initial pair emitted
+		p.set(2);
+		s.set("b"); // secondary-only → no emit
+		p.set(3);
+		expect(data(msgs)).toEqual([
+			[1, "a"],
+			[2, "a"],
+			[3, "b"],
+		]);
+	});
+
+	it("withLatestFrom ignores secondary COMPLETE but propagates secondary ERROR", () => {
+		const completeCase = graph();
+		const primary = completeCase.state(1);
+		const secondary = completeCase.state("a");
+		const paired = completeCase.initNode(withLatestFrom<number, string>(), [primary, secondary]);
+		const completeMsgs: Message[] = [];
+		paired.subscribe((m) => completeMsgs.push(m));
+
+		secondary.down([["COMPLETE"]]);
+		primary.set(2);
+		expect(data(completeMsgs)).toEqual([
+			[1, "a"],
+			[2, "a"],
+		]);
+		expect(paired.status).not.toBe("completed");
+
+		const errorCase = graph();
+		const primary2 = errorCase.state(1);
+		const secondary2 = errorCase.state("a");
+		const paired2 = errorCase.initNode(withLatestFrom<number, string>(), [primary2, secondary2]);
+		const errorMsgs: Message[] = [];
+		paired2.subscribe((m) => errorMsgs.push(m));
+		const err = new Error("secondary boom");
+		secondary2.down([["ERROR", err]]);
+		expect(errorMsgs.at(-1)).toEqual(["ERROR", err]);
+		expect(paired2.status).toBe("errored");
+	});
+
+	it("withLatestFrom completes only when the primary completes", () => {
+		const g = graph();
+		const primary = g.state(1);
+		const secondary = g.state("a");
+		const paired = g.initNode(withLatestFrom<number, string>(), [primary, secondary]);
+		const msgs: Message[] = [];
+		paired.subscribe((m) => msgs.push(m));
+
+		secondary.set("b");
+		expect(paired.status).not.toBe("completed");
+		primary.down([["COMPLETE"]]);
+
+		expect(data(msgs)).toEqual([[1, "a"]]);
+		expect(msgs.at(-1)?.[0]).toBe("COMPLETE");
+		expect(paired.status).toBe("completed");
+	});
+
+	it("zip combines one value from each dep in lockstep, completes with the shorter", () => {
+		const g = graph();
+		const a = g.initNode(fromIter([1, 2, 3]), []);
+		const b = g.initNode(fromIter(["a", "b"]), []);
+		const z = g.initNode(zip<[number, string]>(), [a, b]);
+		const msgs: Message[] = [];
+		z.subscribe((m) => msgs.push(m));
+		expect(data(msgs)).toEqual([
+			[1, "a"],
+			[2, "b"],
+		]);
+		expect(lastType(msgs)).toBe("COMPLETE");
+	});
+
+	it("zip with no deps completes immediately", () => {
+		const g = graph();
+		const z = g.initNode(zip<[]>(), []);
+		const msgs: Message[] = [];
+		z.subscribe((m) => msgs.push(m));
+		expect(data(msgs)).toEqual([]);
+		expect(lastType(msgs)).toBe("COMPLETE");
+		expect(z.status).toBe("completed");
+	});
+
+	it("concat plays all of dep 0 then all of dep 1, then COMPLETE", () => {
+		const g = graph();
+		const a = g.initNode(fromIter([1, 2]), []);
+		const b = g.initNode(fromIter([3, 4]), []);
+		const c = g.initNode(concat<number>(), [a, b]);
+		const msgs: Message[] = [];
+		c.subscribe((m) => msgs.push(m));
+		expect(data(msgs)).toEqual([1, 2, 3, 4]);
+		expect(lastType(msgs)).toBe("COMPLETE");
+	});
+
+	it("race forwards only the first dep to deliver DATA", () => {
+		const g = graph();
+		const a = g.initNode(fromIter([1, 2]), []);
+		const b = g.initNode(fromIter([10, 20]), []);
+		const r = g.initNode(race<number>(), [a, b]);
+		const msgs: Message[] = [];
+		r.subscribe((m) => msgs.push(m));
+		expect(data(msgs)).toEqual([1, 2]); // a subscribed first → wins; b ignored
+		expect(lastType(msgs)).toBe("COMPLETE");
+	});
+
+	it("race (n>=3): a live dep can still win after others terminate empty (QA: no double-count)", () => {
+		// Regression for the cross-wave terminal double-count: with 3 deps, two completing empty in
+		// separate waves must NOT prematurely COMPLETE the race while the 3rd is still live.
+		const g = graph();
+		const a = g.node<number>([], null); // manual sources, silent until .down
+		const b = g.node<number>([], null);
+		const c = g.node<number>([], null);
+		const r = g.initNode(race<number>(), [a, b, c]);
+		const msgs: Message[] = [];
+		r.subscribe((m) => msgs.push(m));
+		a.down([["COMPLETE"]]); // 1 terminal
+		b.down([["COMPLETE"]]); // 2 terminal — OLD code: 1+2=3>=n → premature COMPLETE
+		expect(r.status).not.toBe("completed"); // c still live → race open
+		c.down([["DATA", 99]]); // c wins
+		c.down([["DATA", 100]]);
+		expect(data(msgs)).toEqual([99, 100]);
+		c.down([["COMPLETE"]]); // winner terminal → COMPLETE
+		expect(r.status).toBe("completed");
+	});
+
+	it("race COMPLETEs when EVERY dep terminates without any DATA", () => {
+		const g = graph();
+		const a = g.node<number>([], null);
+		const b = g.node<number>([], null);
+		const c = g.node<number>([], null);
+		const r = g.initNode(race<number>(), [a, b, c]);
+		const msgs: Message[] = [];
+		r.subscribe((m) => msgs.push(m));
+		a.down([["COMPLETE"]]);
+		b.down([["COMPLETE"]]);
+		expect(r.status).not.toBe("completed");
+		c.down([["COMPLETE"]]); // all terminal, no winner → COMPLETE
+		expect(data(msgs)).toEqual([]);
+		expect(r.status).toBe("completed");
+	});
+});
+
+describe("Slice 2 — notifier-driven (D46 first-cut)", () => {
+	it("buffer flushes accumulated source DATA on each notifier signal", () => {
+		const g = graph();
+		const src = g.state(1);
+		const notify = g.state(false);
+		const b = g.initNode(buffer<number>(), [src, notify]);
+		const msgs: Message[] = [];
+		b.subscribe((m) => msgs.push(m));
+		expect(data(msgs)).toEqual([[1]]); // notifier's initial flushes [1]
+		src.set(2);
+		src.set(3);
+		notify.set(true);
+		expect(data(msgs)).toEqual([[1], [2, 3]]);
+	});
+
+	it("bufferCount batches into fixed-size arrays, flushes remainder on COMPLETE", () => {
+		const g = graph();
+		const src = g.initNode(fromIter([1, 2, 3, 4, 5]), []);
+		const b = g.initNode(bufferCount<number>(2), [src]);
+		const msgs: Message[] = [];
+		b.subscribe((m) => msgs.push(m));
+		expect(data(msgs)).toEqual([[1, 2], [3, 4], [5]]);
+		expect(lastType(msgs)).toBe("COMPLETE");
+	});
+
+	it("sample emits the latest source value on each notifier signal", () => {
+		const g = graph();
+		const src = g.state(1);
+		const notify = g.state(false);
+		const s = g.initNode(sample<number>(), [src, notify]);
+		const msgs: Message[] = [];
+		s.subscribe((m) => msgs.push(m));
+		expect(data(msgs)).toEqual([1]); // notifier initial samples the latest source (1)
+		src.set(2);
+		notify.set(true);
+		expect(data(msgs)).toEqual([1, 2]);
+	});
+
+	it("sample clears the held source value on source COMPLETE and completes on notifier COMPLETE", () => {
+		const g = graph();
+		const src = g.state(1);
+		const notify = g.node<boolean>([]);
+		const sampled = g.initNode(sample<number>(), [src, notify]);
+		const msgs: Message[] = [];
+		sampled.subscribe((m) => msgs.push(m));
+
+		src.set(2);
+		src.down([["COMPLETE"]]);
+		notify.down([["DATA", true]]);
+		expect(data(msgs)).toEqual([]); // source COMPLETE clears the held value; no flush.
+
+		notify.down([["COMPLETE"]]);
+		expect(msgs.at(-1)?.[0]).toBe("COMPLETE");
+		expect(sampled.status).toBe("completed");
+	});
+
+	it("sample forwards ERROR from either source or notifier", () => {
+		const sourceCase = graph();
+		const src = sourceCase.state(1);
+		const notify = sourceCase.node<boolean>([]);
+		const sampled = sourceCase.initNode(sample<number>(), [src, notify]);
+		const sourceMsgs: Message[] = [];
+		sampled.subscribe((m) => sourceMsgs.push(m));
+		const sourceErr = new Error("source boom");
+		src.down([["ERROR", sourceErr]]);
+		expect(sourceMsgs.at(-1)).toEqual(["ERROR", sourceErr]);
+		expect(sampled.status).toBe("errored");
+
+		const notifierCase = graph();
+		const src2 = notifierCase.state(1);
+		const notify2 = notifierCase.node<boolean>([]);
+		const sampled2 = notifierCase.initNode(sample<number>(), [src2, notify2]);
+		const notifierMsgs: Message[] = [];
+		sampled2.subscribe((m) => notifierMsgs.push(m));
+		const notifierErr = new Error("notifier boom");
+		notify2.down([["ERROR", notifierErr]]);
+		expect(notifierMsgs.at(-1)).toEqual(["ERROR", notifierErr]);
+		expect(sampled2.status).toBe("errored");
+	});
+
+	it("takeUntil forwards source DATA until the notifier delivers, then COMPLETE", () => {
+		const g = graph();
+		const src = g.state(1);
+		const stop = g.node<boolean>([]); // silent until .down (no initial → SENTINEL)
+		const tu = g.initNode(takeUntil<number>(), [src, stop]);
+		const msgs: Message[] = [];
+		tu.subscribe((m) => msgs.push(m));
+		src.set(2);
+		stop.down([["DATA", true]]); // notifier fires → stop
+		src.set(3); // terminated, ignored
+		expect(data(msgs)).toEqual([1, 2]);
+		expect(tu.status).toBe("completed");
+	});
+
+	it("takeUntil ignores notifier COMPLETE without DATA and still forwards source COMPLETE", () => {
+		const g = graph();
+		const src = g.state(1);
+		const stop = g.node<boolean>([]);
+		const tu = g.initNode(takeUntil<number>(), [src, stop]);
+		const msgs: Message[] = [];
+		tu.subscribe((m) => msgs.push(m));
+
+		stop.down([["COMPLETE"]]);
+		src.set(2);
+		expect(data(msgs)).toEqual([1, 2]);
+		expect(tu.status).not.toBe("completed");
+
+		src.down([["COMPLETE"]]);
+		expect(msgs.at(-1)?.[0]).toBe("COMPLETE");
+		expect(tu.status).toBe("completed");
+	});
+
+	it("describe shows the combinator factory names (D6)", () => {
+		const g = graph();
+		const a = g.state(1, { name: "a" });
+		const b = g.state(2, { name: "b" });
+		g.initNode(combine<[number, number]>(), [a, b], { name: "c" });
+		g.initNode(zip<[number, number]>(), [a, b], { name: "z" });
+		const byId = Object.fromEntries(g.describe().nodes.map((n) => [n.id, n]));
+		expect(byId.c.factory).toBe("combine");
+		expect(byId.z.factory).toBe("zip");
+	});
+});
diff --git a/packages/ts/src/__tests__/composition.test.ts b/packages/ts/src/__tests__/composition.test.ts
new file mode 100644
index 00000000..265227b7
--- /dev/null
+++ b/packages/ts/src/__tests__/composition.test.ts
@@ -0,0 +1,345 @@
+/**
+ * CSP-2.8 composition helpers (D56): topologyDiff + static stratify/stratifyBranch.
+ *
+ * D56 authority: composition is per-language graph-layer sugar; topology only through declared deps
+ * (no internal subscribe island), and dynamic branch add/remove is deferred.
+ */
+
+import { describe, expect, it } from "vitest";
+import type { Message, Node } from "../index.js";
+import {
+	type DescribeSnapshot,
+	filter,
+	graph,
+	map,
+	pipe,
+	stratify,
+	stratifyBranch,
+	topologyDiff,
+} from "../index.js";
+
+const data = <T>(msgs: Message[]): T[] =>
+	msgs.filter((x) => x[0] === "DATA").map((x) => (x as readonly ["DATA", T])[1]);
+
+function collect(n: { subscribe(s: (m: Message) => void): () => void }) {
+	const msgs: Message[] = [];
+	const unsub = n.subscribe((m) => msgs.push(m));
+	return { msgs, unsub };
+}
+
+describe("topologyDiff (D56)", () => {
+	it("diffs D39 describe snapshots without old-core deps", () => {
+		const prev: DescribeSnapshot = {
+			nodes: [
+				{ id: "a", factory: "state", status: "settled", deps: [], meta: { role: "old" } },
+				{ id: "b", factory: "map", status: "sentinel", deps: ["a"] },
+			],
+			edges: [{ from: "a", to: "b" }],
+		};
+		const next: DescribeSnapshot = {
+			nodes: [
+				{ id: "a", factory: "state", status: "settled", deps: [], meta: { role: "new" } },
+				{ id: "c", factory: "filter", status: "sentinel", deps: ["a"] },
+			],
+			edges: [{ from: "a", to: "c" }],
+		};
+
+		expect(topologyDiff(prev, next).events).toEqual([
+			{ type: "node-added", id: "c", node: next.nodes[1] },
+			{ type: "node-meta-changed", id: "a", prevMeta: { role: "old" }, nextMeta: { role: "new" } },
+			{ type: "edge-added", from: "a", to: "c" },
+			{ type: "edge-removed", from: "a", to: "b" },
+			{ type: "node-removed", id: "b" },
+		]);
+	});
+
+	it("detects mounted subgraph paths from prefixed child node ids", () => {
+		const prev: DescribeSnapshot = { nodes: [], edges: [] };
+		const next: DescribeSnapshot = {
+			nodes: [],
+			edges: [],
+			subgraphs: [
+				{ nodes: [{ id: "child::x", factory: "state", status: "settled", deps: [] }], edges: [] },
+			],
+		};
+		expect(topologyDiff(prev, next).events[0]).toEqual({
+			type: "subgraph-mounted",
+			path: "child",
+		});
+	});
+
+	it("detects nested mounted subgraph paths without collapsing to the parent", () => {
+		const prev: DescribeSnapshot = { nodes: [], edges: [] };
+		const next: DescribeSnapshot = {
+			nodes: [],
+			edges: [],
+			subgraphs: [
+				{
+					nodes: [{ id: "parent::child::x", factory: "state", status: "settled", deps: [] }],
+					edges: [],
+				},
+			],
+		};
+		expect(topologyDiff(prev, next).events[0]).toEqual({
+			type: "subgraph-mounted",
+			path: "parent::child",
+		});
+	});
+});
+
+describe("pipe (operator composition helper)", () => {
+	it("registers each operator through the graph init funnel with real factory names", () => {
+		const g = graph();
+		const source = g.state(1, { name: "source" });
+		const out = pipe(
+			g,
+			source,
+			map((n: number) => n + 1),
+			filter((n: number) => n % 2 === 0),
+			map((n: number) => `v${n}`),
+		);
+		const { msgs } = collect(out);
+
+		source.set(2);
+		source.set(3);
+
+		expect(data(msgs)).toEqual(["v2", "v4"]);
+		const snap = g.describe();
+		expect(snap.nodes.map((n) => [n.id, n.factory])).toContainEqual(["map#0", "map"]);
+		expect(snap.nodes.map((n) => [n.id, n.factory])).toContainEqual(["filter#1", "filter"]);
+		expect(snap.nodes.map((n) => [n.id, n.factory])).toContainEqual(["map#2", "map"]);
+		expect(snap.edges).toContainEqual({ from: "source", to: "map#0" });
+		expect(snap.edges).toContainEqual({ from: "map#0", to: "filter#1" });
+		expect(snap.edges).toContainEqual({ from: "filter#1", to: "map#2" });
+	});
+
+	it("with zero operators returns the original source node", () => {
+		const g = graph();
+		const source = g.state(1, { name: "source" });
+		expect(pipe(g, source)).toBe(source);
+	});
+
+	it("keeps a typed fallback for chains longer than the precise overload set", () => {
+		const g = graph();
+		const source = g.state(0, { name: "source" });
+		const out = pipe(
+			g,
+			source,
+			map((n: number) => n + 1),
+			map((n: number) => n + 1),
+			map((n: number) => n + 1),
+			map((n: number) => n + 1),
+			map((n: number) => n + 1),
+			map((n: number) => n + 1),
+			map((n: number) => n + 1),
+		);
+		const { msgs } = collect(out);
+
+		source.set(1);
+
+		expect(data(msgs)).toEqual([7, 8]);
+		expect(g.describe().nodes.filter((n) => n.factory === "map")).toHaveLength(7);
+	});
+});
+
+describe("stratifyBranch (D56)", () => {
+	it("routes source values through declared deps [source, rules]", () => {
+		const g = graph();
+		const source = g.state(0, { name: "source" });
+		const rules = g.state({ mod: 0 }, { name: "rules" });
+		const branch = stratifyBranch(
+			source as Node<number>,
+			rules,
+			(rule: { mod: number }, value: number) => value % 2 === rule.mod,
+		);
+		const { msgs } = collect(branch);
+
+		source.set(1);
+		source.set(2);
+		rules.set({ mod: 1 });
+		source.set(3);
+
+		expect(data(msgs)).toEqual([0, 2, 3]);
+		expect(branch.deps).toEqual([source, rules]);
+	});
+
+	it("drops source values while rules are still SENTINEL", () => {
+		const g = graph();
+		const source = g.node<number>([], null, { name: "source" });
+		const rules = g.node<{ pass: boolean }>([], null, { name: "rules" });
+		const branch = stratifyBranch(
+			source as Node<number>,
+			rules,
+			(rule: { pass: boolean }, _value: number) => rule.pass,
+		);
+		const { msgs } = collect(branch);
+
+		source.down([
+			["DATA", 1],
+			["DATA", 2],
+		]);
+
+		expect(data(msgs)).toEqual([]);
+	});
+
+	it("absorbs rules COMPLETE and keeps classifying with cached rules", () => {
+		const g = graph();
+		const source = g.node<number>([], null, { name: "source" });
+		const rules = g.state({ mod: 2 }, { name: "rules" });
+		const branch = stratifyBranch(
+			source as Node<number>,
+			rules,
+			(rule: { mod: number }, value: number) => value % rule.mod === 0,
+		);
+		const { msgs } = collect(branch);
+
+		source.down([["DATA", 2]]);
+		rules.down([["COMPLETE"]]);
+		source.down([["DATA", 4]]);
+
+		expect(data(msgs)).toEqual([2, 4]);
+		expect(msgs.some((m) => m[0] === "COMPLETE")).toBe(false);
+	});
+
+	it("forwards same-wave DATA before source terminal", () => {
+		const g = graph();
+		const source = g.node<number>([], null, { name: "source" });
+		const rules = g.state({ pass: true }, { name: "rules" });
+		const branch = stratifyBranch(
+			source as Node<number>,
+			rules,
+			(rule: { pass: boolean }, _value: number) => rule.pass,
+		);
+		const { msgs } = collect(branch);
+
+		source.down([["DATA", 7], ["COMPLETE"]]);
+
+		expect(data(msgs)).toEqual([7]);
+		expect(msgs.at(-1)?.[0]).toBe("COMPLETE");
+	});
+
+	it("forwards source ERROR while ignoring rules terminal state", () => {
+		const g = graph();
+		const source = g.node<number>([], null, { name: "source" });
+		const rules = g.state({ pass: true }, { name: "rules" });
+		const branch = stratifyBranch(
+			source as Node<number>,
+			rules,
+			(rule: { pass: boolean }, _value: number) => rule.pass,
+		);
+		const { msgs } = collect(branch);
+
+		rules.down([["COMPLETE"]]);
+		source.down([["ERROR", "boom"]]);
+
+		expect(msgs.at(-1)).toEqual(["ERROR", "boom"]);
+	});
+
+	it("keeps multiple branches over one source independent", () => {
+		const g = graph();
+		const source = g.node<number>([], null, { name: "source" });
+		const rules = g.state({ mod: 3 }, { name: "rules" });
+		const zeros = stratifyBranch(
+			source as Node<number>,
+			rules,
+			(rule: { mod: number }, value: number) => value % rule.mod === 0,
+		);
+		const ones = stratifyBranch(
+			source as Node<number>,
+			rules,
+			(rule: { mod: number }, value: number) => value % rule.mod === 1,
+		);
+		const twos = stratifyBranch(
+			source as Node<number>,
+			rules,
+			(rule: { mod: number }, value: number) => value % rule.mod === 2,
+		);
+		const z = collect(zeros);
+		const o = collect(ones);
+		const t = collect(twos);
+
+		for (const n of [0, 1, 2, 3, 4, 5, 6, 7, 8]) source.down([["DATA", n]]);
+
+		expect(data(z.msgs)).toEqual([0, 3, 6]);
+		expect(data(o.msgs)).toEqual([1, 4, 7]);
+		expect(data(t.msgs)).toEqual([2, 5, 8]);
+	});
+});
+
+describe("stratify (D56)", () => {
+	it("builds static branch nodes registered in describe with real factory names", () => {
+		const g = graph();
+		const source = g.state(1, { name: "source" });
+		const routed = stratify(
+			g,
+			source,
+			[
+				{ name: "even", rule: { mod: 0 } },
+				{ name: "odd", rule: { mod: 1 } },
+			],
+			(rule, value: number) => value % 2 === rule.mod,
+		);
+		const even = collect(routed.branches.even as Node<number>);
+		const odd = collect(routed.branches.odd as Node<number>);
+
+		source.set(2);
+		source.set(3);
+		routed.rules.set([
+			{ name: "even", rule: { mod: 1 } },
+			{ name: "odd", rule: { mod: 0 } },
+		]);
+		source.set(5);
+
+		expect(data(even.msgs)).toEqual([2, 5]);
+		expect(data(odd.msgs)).toEqual([1, 3]);
+
+		const snap = g.describe();
+		const evenNode = snap.nodes.find((n) => n.id === "branch/even");
+		expect(evenNode?.factory).toBe("stratifyBranch");
+		expect(evenNode?.deps).toEqual(["source", "branch/rules"]);
+		expect(snap.edges).toContainEqual({ from: "source", to: "branch/even" });
+		expect(snap.edges).toContainEqual({ from: "branch/rules", to: "branch/even" });
+	});
+
+	it("rejects duplicate rule names before registering colliding branch ids", () => {
+		const g = graph();
+		const source = g.state(1, { name: "source" });
+		expect(() =>
+			stratify(
+				g,
+				source,
+				[
+					{ name: "same", rule: { mod: 0 } },
+					{ name: "same", rule: { mod: 1 } },
+				],
+				(rule, value: number) => value % 2 === rule.mod,
+			),
+		).toThrow(/duplicate rule name/);
+	});
+
+	it("preserves reserved stratify metadata while merging caller meta", () => {
+		const g = graph();
+		const source = g.state(1, { name: "source" });
+		stratify(
+			g,
+			source,
+			[{ name: "even", rule: { mod: 0 }, meta: { ruleMeta: true } }],
+			(rule, value: number) => value % 2 === rule.mod,
+			{
+				rules: { meta: { owner: "qa" } },
+				branches: { even: { meta: { owner: "branch" } } },
+			},
+		);
+
+		const snap = g.describe();
+		expect(snap.nodes.find((n) => n.id === "branch/rules")?.meta).toEqual({
+			kind: "stratify_rules",
+			owner: "qa",
+		});
+		expect(snap.nodes.find((n) => n.id === "branch/even")?.meta).toEqual({
+			branch: "even",
+			ruleMeta: true,
+			owner: "branch",
+		});
+	});
+});
diff --git a/packages/ts/src/__tests__/conformance.part-01.test.ts b/packages/ts/src/__tests__/conformance.part-01.test.ts
new file mode 100644
index 00000000..640a493b
--- /dev/null
+++ b/packages/ts/src/__tests__/conformance.part-01.test.ts
@@ -0,0 +1,736 @@
+/**
+ * Behavioral conformance — TS arm of ~/src/graphrefly/spec/conformance.jsonl (D24).
+ *
+ * Each test is the TS adapter for a language-agnostic scenario: it builds the scenario's
+ * topology, drives its input wave sequence, and asserts the expected OBSERVABLE wave output.
+ *
+ * C-1 (cross-graph diamond) is NOT here — it requires the wire bridge (backlog B2). The
+ * in-process diamond core it leans on is green in core.test.ts (R-diamond/R-two-phase).
+ */
+
+import { describe, expect, it } from "vitest";
+import type { Ctx, Message, NodeFn } from "../index.js";
+import {
+	depBatch,
+	depCount,
+	depLatest,
+	depTerminal,
+	distinctUntilChanged,
+	filter,
+	fromIter,
+	graph,
+	isTerminalComplete,
+	type Node,
+	node,
+	take,
+} from "../index.js";
+
+const types = (msgs: Message[]) => msgs.map((m) => m[0]);
+const data = (msgs: Message[]) =>
+	msgs.filter((m) => m[0] === "DATA").map((m) => (m as ["DATA", unknown])[1]);
+const _flush = () => new Promise((r) => setTimeout(r, 0));
+function collect(n: { subscribe(s: (m: Message) => void): () => void }) {
+	const msgs: Message[] = [];
+	const unsub = n.subscribe((m) => msgs.push(m));
+	return { msgs, unsub };
+}
+
+describe("C-2 async-result arriving at paused node (R-async-paused, R-pause-lockset)", () => {
+	it("buffers the async result while paused, replays it on final-lock RESUME", () => {
+		let cctx: Ctx | null = null;
+		const trigger = node<number>([], null, { initial: 0 });
+		// async-pool node: the fn stashes its ctx and resolves later (simulated async).
+		const n = node<number>(
+			[trigger],
+			(ctx: Ctx) => {
+				cctx = ctx;
+			},
+			{ pool: "async" },
+		);
+		const { msgs } = collect(n);
+		expect(cctx).not.toBeNull(); // fn ran on activation, no emit yet
+
+		const L = Symbol("pause");
+		n.up([["PAUSE", L]]);
+
+		msgs.length = 0;
+		// async result resolves WHILE paused -> buffered, not delivered (DR-3).
+		(cctx as Ctx).down([["DATA", 42]]);
+		expect(msgs).toEqual([]);
+		expect(n.cache).toBeUndefined();
+
+		n.up([["RESUME", L]]); // final-lock RESUME -> replay the buffered settle slice
+		expect(types(msgs)).toEqual(["DIRTY", "DATA"]);
+		expect(msgs.at(-1)).toEqual(["DATA", 42]);
+		expect(n.cache).toBe(42);
+	});
+});
+
+describe("C-3 INVALIDATE × ctx.state × onInvalidate (R-invalidate-idempotent, R-ctx-state)", () => {
+	it("cascades once, fires onInvalidate, preserves ctx.state, resets dep cached latest", () => {
+		const statesAtRun: unknown[] = [];
+		let onInv = 0;
+		const s = node<number>([], null, { initial: 1 });
+		const d = node<number>([s], (ctx: Ctx) => {
+			statesAtRun.push(ctx.state.get()); // prior state visible at run time
+			ctx.state.set("kept");
+			ctx.onInvalidate(() => {
+				onInv++;
+			});
+			ctx.down([["DATA", (depLatest(ctx, 0) as number) * 2]]);
+		});
+		const { msgs } = collect(d);
+		expect(d.cache).toBe(2);
+		expect(statesAtRun).toEqual([undefined]); // first run: fresh state
+
+		msgs.length = 0;
+		s.down([["INVALIDATE"]]);
+		expect(types(msgs)).toEqual(["INVALIDATE"]); // cascaded downstream exactly once
+		expect(onInv).toBe(1);
+		expect(d.cache).toBeUndefined();
+		expect(d.status).toBe("sentinel");
+
+		// idempotent: a second INVALIDATE on an already-reset upstream is a no-op
+		msgs.length = 0;
+		s.down([["INVALIDATE"]]);
+		expect(msgs).toEqual([]);
+		expect(onInv).toBe(1);
+
+		// ctx.state preserved across INVALIDATE (lifecycle-continue, NOT fresh-lifecycle)
+		s.down([["DATA", 5]]);
+		expect(statesAtRun).toEqual([undefined, "kept"]);
+		expect(d.cache).toBe(10);
+	});
+});
+
+describe("C-4 mixed sync/async diamond (R-diamond, R-two-phase, R-first-run-gate, R-dirty-before-data)", () => {
+	it("joins exactly once after BOTH legs settle, re-emitting DIRTY before DATA on the next wave", () => {
+		let dRuns = 0;
+		let cctx: Ctx | null = null;
+		const a = node<number>([], null, { initial: 1 });
+		const b = node<number>([a], (ctx: Ctx) =>
+			ctx.down([["DATA", (depLatest(ctx, 0) as number) + 10]]),
+		); // sync leg
+		const c = node<number>(
+			[a],
+			(ctx: Ctx) => {
+				cctx = ctx; // async leg: defer the emit
+			},
+			{ pool: "async" },
+		);
+		const d = node<number>([b, c], (ctx: Ctx) => {
+			dRuns++;
+			ctx.down([["DATA", (depLatest(ctx, 0) as number) + (depLatest(ctx, 1) as number)]]);
+		});
+
+		const { msgs } = collect(d);
+		// b settled synchronously (11); the async leg is deferred -> first-run gate holds d
+		expect(dRuns).toBe(0);
+		expect(d.cache).toBeUndefined();
+
+		(cctx as Ctx).down([["DATA", 21]]); // async leg resolves -> first join (activation)
+		expect(dRuns).toBe(1); // joined exactly once
+		expect(d.cache).toBe(32); // 11 + 21
+
+		// R-dirty-before-data: a non-activation tier-3 emission is preceded by a synthesized
+		// DIRTY in the same wave (the join fn calls ctx.down([["DATA",...]]) only). Drive a
+		// second settle through both legs so we observe d past its first-run exemption.
+		msgs.length = 0;
+		a.down([["DATA", 2]]); // re-drives b (sync, 12) and c (async, deferred again)
+		expect(dRuns).toBe(1); // still gated on the async leg
+		(cctx as Ctx).down([["DATA", 30]]); // async leg re-resolves
+		expect(dRuns).toBe(2);
+		expect(d.cache).toBe(42); // 12 + 30
+		expect(types(msgs)).toEqual(["DIRTY", "DATA"]); // DIRTY precedes DATA, glitch-free two-phase
+		expect(msgs.at(-1)).toEqual(["DATA", 42]);
+	});
+});
+
+describe("C-5 PAUSE lockset multi-source (R-pause-lockset, R-pause-modes)", () => {
+	it("stays paused until every lock RESUMEs; dup PAUSE + unknown RESUME are no-ops", () => {
+		let runs = 0;
+		const s = node<number>([], null, { initial: 0 });
+		const n = node<number>([s], (ctx: Ctx) => {
+			runs++;
+			ctx.down([["DATA", depLatest(ctx, 0) as number]]);
+		});
+		collect(n);
+		expect(n.cache).toBe(0);
+		runs = 0;
+
+		const LA = Symbol("A");
+		const LB = Symbol("B");
+		n.up([["PAUSE", LA]]);
+		n.up([["PAUSE", LB]]);
+		n.up([["PAUSE", LA]]); // duplicate -> idempotent (lockset)
+
+		s.down([["DATA", 1]]); // dep changes while paused
+		expect(runs).toBe(0); // fn held
+		expect(n.cache).toBe(0);
+
+		n.up([["RESUME", LA]]); // release A — LB still held
+		expect(runs).toBe(0); // STILL paused
+		expect(n.cache).toBe(0);
+
+		n.up([["RESUME", Symbol("unknown")]]); // unknown id -> no-op
+		expect(runs).toBe(0);
+
+		n.up([["RESUME", LB]]); // last lock released -> resume, fire once with latest
+		expect(runs).toBe(1);
+		expect(n.cache).toBe(1);
+	});
+});
+
+describe("C-6 synchronous feedback cycle → ERROR (R-reentrancy / D37)", () => {
+	it("rejects a sync feedback cycle as ERROR (no hang, no _pending desync)", () => {
+		// state S → derived D (=n+1) → effect E; E writes back to S, closing S→D→E→S.
+		const g = graph();
+		const s = g.state(0);
+		const d = g.derived([s], (n) => (n as number) + 1);
+		const e = g.effect([d], (n) => {
+			s.set(n as number); // feedback → re-enters the wave
+		});
+		let escaped = false;
+		try {
+			e.subscribe(() => {});
+		} catch {
+			escaped = true; // the substrate throw must NOT escape — the graph layer catches it (D30)
+		}
+		expect(escaped).toBe(false);
+		// R-reentrancy: ERROR lands on a node ON the cycle — the value-level catch nearest the
+		// throw on the unwind (impl-determined, d or e), not necessarily the re-entered node.
+		expect([d.status, e.status]).toContain("errored");
+	});
+});
+
+describe("C-7 upstream control at a depless source (R-up-at-source / D38)", () => {
+	const make = () => {
+		const s = node<number>([], null, { initial: 5 });
+		const d = node<number>([s], (ctx: Ctx) => ctx.down([["DATA", depLatest(ctx, 0) as number]]));
+		const { msgs } = collect(d);
+		msgs.length = 0;
+		return { s, d, msgs };
+	};
+
+	it("INVALIDATE-up is HONORED: source self-invalidates + cascades down", () => {
+		const { s, d, msgs } = make();
+		d.up([["INVALIDATE"]]); // forwards to the depless terminus S → self _invalidate
+		expect(s.cache).toBeUndefined();
+		expect(s.status).toBe("sentinel");
+		expect(types(msgs)).toContain("INVALIDATE");
+		expect(d.cache).toBeUndefined();
+	});
+
+	it("DIRTY-up is DROPPED at the source (untouched, no down-cascade)", () => {
+		const { s, d, msgs } = make();
+		d.up([["DIRTY"]]);
+		expect(s.cache).toBe(5);
+		expect(s.status).toBe("settled");
+		expect(msgs).toEqual([]);
+	});
+
+	it("TEARDOWN-up is DROPPED at the source (not terminated, no down-cascade)", () => {
+		const { s, d, msgs } = make();
+		d.up([["TEARDOWN"]]);
+		expect(s.status).toBe("settled");
+		expect(msgs).toEqual([]);
+	});
+});
+
+describe("C-8 intra-graph runtime rewire (R-rewire / D42)", () => {
+	it("surgical subscribeDep (push-on-subscribe) → unsubscribeDep (drain) → idempotent replaceDeps; cache preserved", () => {
+		const a = node<number>([], null, { initial: 1 });
+		const b = node<number>([], null, { initial: 100 }); // B carries cached DATA
+		const aOnly = (ctx: Ctx) => ctx.down([["DATA", depLatest(ctx, 0) as number]]);
+		const sum = (ctx: Ctx) =>
+			ctx.down([["DATA", (depLatest(ctx, 0) as number) + (depLatest(ctx, 1) as number)]]);
+		const d = node<number>([a], aOnly);
+		collect(d);
+		expect(d.cache).toBe(1); // (1) A settled → D ran
+
+		d.subscribeDep(b, sum); // (2) subscribeDep(B): B cached → push-on-subscribe → D recomputes
+		expect(d.cache).toBe(101); // 1 + 100
+
+		b.down([["DATA", 50]]); // (3) B drives D
+		expect(d.cache).toBe(51); // 1 + 50
+
+		d.unsubscribeDep(a, aOnly); // (4) unsubscribeDep(A) → deps = [B]
+		expect(d.cache).toBe(51); // cache PRESERVED (A was not dirty — no recompute)
+
+		a.down([["DATA", 9]]); // (5) A no longer drives D — its edge is drained
+		expect(d.cache).toBe(51);
+
+		b.down([["DATA", 7]]); // B is dep0 now → drives D
+		expect(d.cache).toBe(7);
+
+		let runs = 0;
+		const f = (ctx: Ctx) => {
+			runs++;
+			ctx.down([["DATA", depLatest(ctx, 0) as number]]);
+		};
+		d.replaceDeps([b], f); // (6) replaceDeps to the current set → idempotent
+		expect(runs).toBe(0); // no spurious recompute
+		expect(d.cache).toBe(7);
+	});
+
+	it("rejects rewire on a terminal node (throw → graph-layer ERROR, D30)", () => {
+		const a = node<number>([], null, { initial: 1 });
+		const id = (ctx: Ctx) => ctx.down([["DATA", depLatest(ctx, 0) as number]]);
+		const d = node<number>([a], id, { completeWhenDepsComplete: false });
+		collect(d);
+		d.down([["COMPLETE"]]); // D terminal
+		expect(() => d.replaceDeps([a], id)).toThrow(/terminal/);
+	});
+});
+
+describe("C-9 pausable:false async source ignores PAUSE (R-pause-modes / R-async-paused / D44)", () => {
+	it("delivers its async production immediately under PAUSE — never buffers (resolves B20)", () => {
+		let cctx: Ctx | null = null;
+		// depless async LEAF source, pausable:false (timer/interval-class).
+		const s = node<number>(
+			[],
+			(ctx: Ctx) => {
+				cctx = ctx;
+			},
+			{ pool: "async", pausable: false },
+		);
+		const { msgs } = collect(s);
+		expect(cctx).not.toBeNull(); // fn ran on activation, no emit yet
+
+		const L = Symbol("pause");
+		s.up([["PAUSE", L]]); // pausable:false ⇒ lockset never consulted
+		msgs.length = 0;
+
+		(cctx as Ctx).down([["DATA", 42]]); // async production WHILE "paused" → delivered immediately
+		expect(types(msgs)).toEqual(["DIRTY", "DATA"]); // NOT buffered (contrast C-2's compute node)
+		expect(msgs.at(-1)).toEqual(["DATA", 42]);
+		expect(s.cache).toBe(42);
+	});
+});
+
+describe("C-10 true-mode async leaf source delivers immediately under PAUSE (R-pause-modes / R-async-paused / D44)", () => {
+	it("a depless async source's own production is not gated in true (default) mode (B20's twin)", () => {
+		let cctx: Ctx | null = null;
+		// depless async LEAF source, pausable:true default (fromPromise/fromAsyncIter-class).
+		const s = node<number>(
+			[],
+			(ctx: Ctx) => {
+				cctx = ctx;
+			},
+			{ pool: "async" },
+		);
+		const { msgs } = collect(s);
+		expect(cctx).not.toBeNull();
+
+		const L = Symbol("pause");
+		s.up([["PAUSE", L]]);
+		msgs.length = 0;
+
+		(cctx as Ctx).down([["DATA", 7]]); // leaf source's OWN production → delivered immediately
+		expect(types(msgs)).toEqual(["DIRTY", "DATA"]); // NOT buffered (a COMPUTE node WOULD buffer — C-2)
+		expect(msgs.at(-1)).toEqual(["DATA", 7]);
+		expect(s.cache).toBe(7);
+	});
+});
+
+// C-11 (D47 / R-rewire-deferred): a node fn's SELF-triggered dep-set mutation via ctx.rewireNext
+// is deferred to the committed wave boundary (never mutating _deps mid-run, never the D37 in-fn
+// reject), drained as a fresh wave; added cached inners push [DIRTY,DATA] without re-arming the
+// gate; removed inners are drained + _deactivate (onDeactivation = abortInFlight). D62: queued
+// rewireNext still drains if OP goes terminal; terminal seals output, not topology. The substrate
+// prerequisite for the higher-order *Map operators. Distinct from C-8 (external/immediate rewire).
+describe("C-11 higher-order inner rewire at the wave boundary (R-rewire-deferred / D47/D62)", () => {
+	// Inners are leaf sources whose activation + deactivation are observable (cancellation visible).
+	function makeInner(seed?: number) {
+		let ictx: Ctx | null = null;
+		let activated = false;
+		let deactivated = false;
+		const n = node<number>([], (ctx) => {
+			ictx = ctx;
+			activated = true;
+			ctx.onDeactivation(() => {
+				deactivated = true;
+			});
+			if (seed !== undefined) ctx.down([["DATA", seed]]);
+		});
+		return {
+			node: n,
+			emit: (v: number) => (ictx as Ctx).down([["DATA", v]]),
+			complete: () => (ictx as Ctx).down([["COMPLETE"]]),
+			isActivated: () => activated,
+			isDeactivated: () => deactivated,
+		};
+	}
+
+	// A merge-style OP: spawn+add an inner per S DATA, forward inner DATA, remove a completed inner.
+	function mergeOp(s: Node<number>) {
+		const inners: Node<number>[] = [];
+		const opFn: NodeFn = (ctx) => {
+			const removals: Node<number>[] = [];
+			for (let i = 1; i < depCount(ctx); i++) {
+				const b = depBatch(ctx, i);
+				if (b) for (const v of b) ctx.down([["DATA", v as number]]);
+				if (isTerminalComplete(depTerminal(ctx, i))) removals.push(inners[i - 1]);
+			}
+			const sv = depBatch(ctx, 0);
+			if (sv && sv.length > 0) {
+				const inner = makeInner((sv[sv.length - 1] as number) * 10);
+				inners.push(inner.node);
+				ctx.rewireNext.subscribeDep(inner.node, opFn);
+			}
+			for (const r of removals) {
+				inners.splice(inners.indexOf(r), 1);
+				ctx.rewireNext.unsubscribeDep(r, opFn);
+			}
+		};
+		return node<number>([s], opFn, {
+			completeWhenDepsComplete: false,
+			terminalAsRealInput: true,
+		});
+	}
+
+	it("(steps 1-3) subscribeDep deferred to the boundary; added cached inner pushes [DIRTY,DATA], gate not re-armed", () => {
+		const s = node<number>([], null);
+		let opRuns = 0;
+		const inners: Node<number>[] = [];
+		const opFn: NodeFn = (ctx) => {
+			opRuns++;
+			for (let i = 1; i < depCount(ctx); i++) {
+				const b = depBatch(ctx, i);
+				if (b) for (const v of b) ctx.down([["DATA", v as number]]);
+			}
+			const sv = depBatch(ctx, 0);
+			if (sv && sv.length > 0) {
+				const inner = makeInner((sv[sv.length - 1] as number) * 10);
+				inners.push(inner.node);
+				// mid-run: _deps is NOT mutated — the inner is not yet wired/activated.
+				expect(inner.isActivated()).toBe(false);
+				ctx.rewireNext.subscribeDep(inner.node, opFn);
+				expect(inner.isActivated()).toBe(false); // still deferred after the request
+			}
+		};
+		const op = node<number>([s], opFn, {
+			completeWhenDepsComplete: false,
+			terminalAsRealInput: true,
+		});
+		const { msgs } = collect(op);
+
+		s.down([["DATA", 1]]); // step 1: request subscribeDep(innerA); step 2: drain wires it; step 3: forward
+		expect(types(msgs)).toContain("DIRTY"); // step 2 boundary wave is two-phase…
+		expect(data(msgs)).toEqual([10]); // …innerA's seed (1*10) forwarded as DATA
+
+		opRuns = 0;
+		s.down([["DATA", 2]]); // gate NOT re-armed: S alone re-drives the fn (and adds innerB)
+		expect(opRuns).toBeGreaterThan(0);
+	});
+
+	it("(step 7) an inner COMPLETE removes it (bounding); OP does not COMPLETE while S is live", () => {
+		const s = node<number>([], null);
+		const op = mergeOp(s);
+		const { msgs } = collect(op);
+
+		s.down([["DATA", 5]]); // add innerA (seed 50 forwarded)
+		expect(data(msgs)).toContain(50);
+		msgs.length = 0;
+
+		s.down([["DATA", 6]]); // add innerB (seed 60 forwarded)
+		expect(data(msgs)).toContain(60);
+
+		// OP stays live: S is still live, completeWhenDepsComplete:false → no terminal cascade.
+		expect(op.status).not.toBe("completed");
+		expect(types(msgs)).not.toContain("COMPLETE");
+	});
+
+	it("(steps 4-6, switch) replaceDeps tears down the superseded inner's source and forwards only the new one", () => {
+		const s = node<number>([], null);
+		const innerA = makeInner(10);
+		const innerB = makeInner(20);
+		let current: Node<number> | null = null;
+		const opFn: NodeFn = (ctx) => {
+			for (let i = 1; i < depCount(ctx); i++) {
+				const b = depBatch(ctx, i);
+				if (b) for (const v of b) ctx.down([["DATA", v as number]]);
+			}
+			const sv = depBatch(ctx, 0);
+			if (sv && sv.length > 0) {
+				current = (sv[sv.length - 1] as number) === 1 ? innerA.node : innerB.node;
+				ctx.rewireNext.replaceDeps([s, current], opFn);
+			}
+		};
+		const op = node<number>([s], opFn, {
+			completeWhenDepsComplete: false,
+			terminalAsRealInput: true,
+		});
+		const { msgs } = collect(op);
+
+		s.down([["DATA", 1]]); // → innerA live (seed 10 forwarded)
+		expect(data(msgs)).toContain(10);
+		expect(innerA.isActivated()).toBe(true);
+		msgs.length = 0;
+
+		s.down([["DATA", 2]]); // switch → innerB; innerA's SOURCE torn down (not masked)
+		expect(innerB.isActivated()).toBe(true);
+		expect(innerA.isDeactivated()).toBe(true);
+		expect(data(msgs)).toEqual([20]); // ONLY the current inner forwarded
+		msgs.length = 0;
+
+		innerA.emit(999); // the superseded inner is DRAINED — no stale forward survives
+		expect(data(msgs)).toEqual([]);
+	});
+
+	it("(variant) an IMMEDIATE in-fn self-rewire is the D37 feedback cycle → graph-layer ERROR (not rewireNext)", () => {
+		const g = graph();
+		const a = g.state(1);
+		const x = g.state(9);
+		let op: Node<number>;
+		// g.derived carries the D30 value-throw→ERROR boundary; the fn does an IMMEDIATE self-subscribeDep
+		// (NOT ctx.rewireNext) mid-run → the D37 reject throws → graph layer converts it to ERROR.
+		op = g.derived([a], (av) => {
+			op.subscribeDep(x, (c) => c.down([["DATA", depLatest(c, 0) as number]]));
+			return av as number;
+		});
+		let escaped = false;
+		try {
+			op.subscribe(() => {});
+		} catch {
+			escaped = true; // the substrate throw must be caught by the graph layer (D30), not escape
+		}
+		expect(escaped).toBe(false);
+		expect(op.status).toBe("errored");
+	});
+
+	it("(variant) a terminal OP still drains its pending rewireNext queue; terminal seals output", () => {
+		const s = node<number>([], null);
+		const inner = makeInner(1);
+		const opFn: NodeFn = (ctx) => {
+			if (depBatch(ctx, 0)) {
+				ctx.rewireNext.subscribeDep(inner.node, opFn); // queued…
+				ctx.down([["COMPLETE"]]); // …then OP goes terminal THIS wave
+			}
+		};
+		const op = node<number>([s], opFn, {
+			completeWhenDepsComplete: false,
+			terminalAsRealInput: true,
+		});
+		const { msgs } = collect(op);
+		s.down([["DATA", 1]]);
+		expect(op.status).toBe("completed");
+		expect(inner.isActivated()).toBe(true); // D62: queued subscribeDep drains after terminal
+		expect(op.deps).toContain(inner.node);
+		msgs.length = 0;
+		inner.emit(2);
+		expect(msgs).toEqual([]); // terminal output guard: no post-terminal DATA escapes
+	});
+
+	it("(variant) a terminal OP drains a queued unsubscribeDep, releasing helper-owned work", () => {
+		const s = node<number>([], null);
+		const inner = makeInner(1);
+		let added = false;
+		const opFn: NodeFn = (ctx) => {
+			if (!added && depBatch(ctx, 0)) {
+				added = true;
+				ctx.rewireNext.subscribeDep(inner.node, opFn);
+				return;
+			}
+			if (isTerminalComplete(depTerminal(ctx, 0))) {
+				ctx.rewireNext.unsubscribeDep(inner.node, opFn);
+				ctx.down([["COMPLETE"]]);
+			}
+		};
+		const op = node<number>([s], opFn, {
+			completeWhenDepsComplete: false,
+			terminalAsRealInput: true,
+		});
+		collect(op);
+		s.down([["DATA", 1]]);
+		expect(inner.isActivated()).toBe(true);
+		s.down([["COMPLETE"]]);
+		expect(op.status).toBe("completed");
+		expect(op.deps).not.toContain(inner.node);
+		expect(inner.isDeactivated()).toBe(true);
+	});
+
+	it("(variant) a no-net-change rewireNext is a no-op (no drain loop)", () => {
+		const a = node<number>([], null, { initial: 1 });
+		let runs = 0;
+		const op = node<number>([a], function opFn(ctx) {
+			runs++;
+			if (runs < 5) ctx.rewireNext.replaceDeps([a], opFn); // identical dep set every run
+			ctx.down([["DATA", depLatest(ctx, 0) as number]]);
+		});
+		collect(op);
+		expect(runs).toBe(1); // the idempotent replaceDeps changes nothing → no fresh wave → no loop
+		expect(op.cache).toBe(1);
+	});
+});
+
+// C-12 (D49 / R-resolved-undirty, supersedes D15/R-equals): every value-occurrence is DATA
+// (no auto-equals-substitution); RESOLVED is the substrate-SYNTHESIZED undirty-only signal;
+// dedup is opt-in at the operator layer. Folds the former _probe.test.ts probes (the
+// fromIter([1,1,1]) / take(3) / state.set-same cases that surfaced D49).
+describe("C-12 occurrences stay DATA; RESOLVED is undirty-only (R-resolved-undirty / D49)", () => {
+	it("(a) a repeated value is N distinct DATA occurrences, never collapsed to RESOLVED", () => {
+		const g = graph();
+		const src = g.initNode(fromIter<number>([1, 1, 1]), []);
+		const { msgs } = collect(src);
+		expect(types(msgs)).toEqual(["START", "DATA", "DATA", "DATA", "COMPLETE"]);
+		expect(data(msgs)).toEqual([1, 1, 1]); // not [1] — the pre-D49 equals-absorption bug
+	});
+
+	it("(b) take(3) counts occurrences, not distinct values → [1,1,1]", () => {
+		const g = graph();
+		const src = g.initNode(fromIter<number>([1, 1, 1]), []);
+		const t = g.initNode(take<number>(3), [src]);
+		const { msgs } = collect(t);
+		expect(data(msgs)).toEqual([1, 1, 1]);
+		expect(t.status).toBe("completed");
+	});
+
+	it("(c) filter-reject: the substrate synthesizes one undirty RESOLVED — no DATA, no wedge", () => {
+		const g = graph();
+		const s = g.state(50);
+		const f = g.initNode(
+			filter((n: number) => n >= 100),
+			[s],
+		);
+		const { msgs } = collect(f);
+		// activation: 50 rejected, f never produced — no DIRTY on activation, no synth
+		expect(f.status).toBe("sentinel");
+		expect(f.cache).toBeUndefined();
+		msgs.length = 0;
+
+		s.set(60); // rejected: DIRTY'd but no value → substrate-synthesized undirty RESOLVED
+		expect(types(msgs)).toEqual(["DIRTY", "RESOLVED"]); // un-dirtied, no DATA, not wedged
+		expect(f.status).toBe("sentinel"); // never valued
+		msgs.length = 0;
+
+		s.set(150); // accepted → real DATA occurrence
+		expect(types(msgs)).toEqual(["DIRTY", "DATA"]);
+		expect(f.cache).toBe(150);
+		msgs.length = 0;
+
+		s.set(70); // rejected, but f now carries 150 → undirty RESOLVED, status resolved
+		expect(types(msgs)).toEqual(["DIRTY", "RESOLVED"]);
+		expect(f.status).toBe("resolved");
+		expect(f.cache).toBe(150); // cache preserved across the undirty wave
+	});
+
+	it("(c') a downstream recompute un-dirties as DATA (occurrence), never wedges", () => {
+		const g = graph();
+		const s = g.state(100); // accepted by the filter
+		const f = g.initNode(
+			filter((n: number) => n >= 100),
+			[s],
+		);
+		const d = g.derived([f], (v: number) => v * 2);
+		const { msgs } = collect(d);
+		expect(d.cache).toBe(200); // f=100 → d=200
+		msgs.length = 0;
+
+		s.set(50); // rejected by f → f synthesizes RESOLVED → d clears + recomputes f's cached 100
+		expect(types(msgs)).toEqual(["DIRTY", "DATA"]); // d un-dirtied via a (same-value) DATA, no wedge
+		expect(d.cache).toBe(200);
+	});
+
+	it("(d) distinctUntilChanged is the OPT-IN dedup (operator's job, not substrate)", () => {
+		const g = graph();
+		const s = g.state(1);
+		const duc = g.initNode(distinctUntilChanged<number>(), [s]);
+		const { msgs } = collect(duc);
+		s.set(1); // dup → operator returns without emitting → substrate synthesizes RESOLVED
+		s.set(2);
+		s.set(2); // dup → suppressed
+		s.set(3);
+		expect(data(msgs)).toEqual([1, 2, 3]);
+	});
+
+	it("a state node re-set to the same value emits DATA, not RESOLVED (no substrate equals)", () => {
+		const g = graph();
+		const s = g.state(1);
+		const { msgs } = collect(s);
+		msgs.length = 0;
+		s.set(1); // same value
+		expect(types(msgs)).toEqual(["DIRTY", "DATA"]); // occurrence, NOT equals-absorbed
+		expect(s.cache).toBe(1);
+		msgs.length = 0;
+		s.set(2);
+		expect(types(msgs)).toEqual(["DIRTY", "DATA"]);
+	});
+
+	it("the tier-3 exclusivity guard stays: a wave cannot mix DATA and RESOLVED", () => {
+		const s = node<number>([], null, { initial: 1 });
+		collect(s);
+		expect(() => s.down([["DATA", 2], ["RESOLVED"]])).toThrow(/tier-3 exclusivity/);
+	});
+});
+
+describe("C-13 INVALIDATE arriving at a paused compute node (R-paused-invalidate / D50)", () => {
+	it("(a) a sole-dep INVALIDATE supersedes the buffered paused dep-wave → no recompute on RESUME", () => {
+		let runs = 0;
+		const d1 = node<number>([], null, { initial: 0 });
+		const n = node<number>([d1], (ctx: Ctx) => {
+			runs++;
+			ctx.down([["DATA", (depLatest(ctx, 0) as number) + 1]]); // non-guarding
+		});
+		const { msgs } = collect(n);
+		expect(n.cache).toBe(1);
+		runs = 0;
+		msgs.length = 0;
+
+		const L = Symbol("p");
+		n.up([["PAUSE", L]]);
+		d1.down([["DATA", 5]]); // buffered while paused (no recompute)
+		expect(runs).toBe(0);
+		d1.down([["INVALIDATE"]]); // supersedes the buffered wave → cancels the paused recompute
+		n.up([["RESUME", L]]); // RESUME must NOT recompute against the SENTINEL dep
+
+		expect(runs).toBe(0); // the superseded paused dep-wave does not recompute (D50)
+		expect(n.cache).toBeUndefined(); // stays SENTINEL (own INVALIDATE) — no garbage recompute
+		expect(msgs.some((m) => m[0] === "DATA")).toBe(false); // no spurious recompute DATA after INVALIDATE
+	});
+
+	it("(b) a DATA after the INVALIDATE re-arms the buffer → RESUME recomputes with the new value", () => {
+		let runs = 0;
+		const d1 = node<number>([], null, { initial: 0 });
+		const n = node<number>([d1], (ctx: Ctx) => {
+			runs++;
+			ctx.down([["DATA", (depLatest(ctx, 0) as number) + 100]]);
+		});
+		collect(n);
+		runs = 0;
+
+		const L = Symbol("p");
+		n.up([["PAUSE", L]]);
+		d1.down([["DATA", 5]]); // buffered
+		d1.down([["INVALIDATE"]]); // supersede v1
+		d1.down([["DATA", 7]]); // re-arm with v2
+		n.up([["RESUME", L]]);
+
+		expect(runs).toBe(1); // recomputes once with the re-armed value
+		expect(n.cache).toBe(107); // 7 + 100 (v2, not the superseded v1)
+	});
+
+	it("(c) a multi-dep INVALIDATE does NOT cancel a surviving dep's buffered update", () => {
+		let runs = 0;
+		const d1 = node<number>([], null, { initial: 0 });
+		const d2 = node<number>([], null, { initial: 0 });
+		const n = node<number>([d1, d2], (ctx: Ctx) => {
+			runs++;
+			const a = (depLatest(ctx, 0) as number | undefined) ?? 0; // guards D1 SENTINEL
+			const b = depLatest(ctx, 1) as number;
+			ctx.down([["DATA", a + b]]);
+		});
+		collect(n);
+		runs = 0;
+
+		const L = Symbol("p");
+		n.up([["PAUSE", L]]);
+		d1.down([["DATA", 5]]); // buffered
+		d2.down([["DATA", 9]]); // buffered (the survivor)
+		d1.down([["INVALIDATE"]]); // D1 superseded; D2's buffered wave survives
+		n.up([["RESUME", L]]);
+
+		expect(runs).toBe(1); // still recomputes for the surviving dep (no lost update)
+		expect(n.cache).toBe(9); // D1=SENTINEL→0, D2=9
+	});
+});
diff --git a/packages/ts/src/__tests__/conformance.part-02.test.ts b/packages/ts/src/__tests__/conformance.part-02.test.ts
new file mode 100644
index 00000000..6928c6bc
--- /dev/null
+++ b/packages/ts/src/__tests__/conformance.part-02.test.ts
@@ -0,0 +1,655 @@
+/**
+ * Behavioral conformance — TS arm of ~/src/graphrefly/spec/conformance.jsonl (D24).
+ *
+ * Each test is the TS adapter for a language-agnostic scenario: it builds the scenario's
+ * topology, drives its input wave sequence, and asserts the expected OBSERVABLE wave output.
+ *
+ * C-1 (cross-graph diamond) is NOT here — it requires the wire bridge (backlog B2). The
+ * in-process diamond core it leans on is green in core.test.ts (R-diamond/R-two-phase).
+ */
+
+import { describe, expect, it } from "vitest";
+import type { Ctx, Message, NodeFn } from "../index.js";
+import {
+	batch,
+	defaultRestoreRegistry,
+	define,
+	depBatch,
+	depCount,
+	depLatest,
+	depTerminal,
+	graph,
+	isTerminalError,
+	map,
+	type Node,
+	node,
+	restoreGraph,
+	restoreRegistry,
+} from "../index.js";
+
+const types = (msgs: Message[]) => msgs.map((m) => m[0]);
+const data = (msgs: Message[]) =>
+	msgs.filter((m) => m[0] === "DATA").map((m) => (m as ["DATA", unknown])[1]);
+const _flush = () => new Promise((r) => setTimeout(r, 0));
+function collect(n: { subscribe(s: (m: Message) => void): () => void }) {
+	const msgs: Message[] = [];
+	const unsub = n.subscribe((m) => msgs.push(m));
+	return { msgs, unsub };
+}
+
+describe("C-14 cleanup hooks are per-run (cleared + re-registered each fn run) (R-cleanup-hooks / D28)", () => {
+	it("after K runs, onInvalidate + onDeactivation fire ONCE (the latest run's), not K times", () => {
+		let flush = 0;
+		let cleanup = 0;
+		const s = node<number>([], null, { initial: 0 });
+		const d = node<number>([s], (ctx: Ctx) => {
+			ctx.onInvalidate(() => flush++);
+			ctx.onDeactivation(() => cleanup++);
+			ctx.down([["DATA", depLatest(ctx, 0) as number]]);
+		});
+		const { unsub } = collect(d); // run 1 (activation, s=0)
+		s.down([["DATA", 1]]); // run 2 — re-registers (prior run's hooks cleared)
+		s.down([["DATA", 2]]); // run 3 — re-registers (D has now run 3×)
+
+		s.down([["INVALIDATE"]]); // fires onInvalidate ONCE (run-3's), not 3× (the accumulation bug)
+		expect(flush).toBe(1);
+
+		unsub(); // D deactivates → fires onDeactivation ONCE (run-3's), not 3×
+		expect(cleanup).toBe(1);
+	});
+
+	it("a single-run node keeps its one registration (no re-run → no clear)", () => {
+		let cleanup = 0;
+		const s = node<number>([], null, { initial: 5 });
+		const d = node<number>([s], (ctx: Ctx) => {
+			ctx.onDeactivation(() => cleanup++);
+			ctx.down([["DATA", depLatest(ctx, 0) as number]]);
+		});
+		const { unsub } = collect(d); // run 1 only
+		unsub();
+		expect(cleanup).toBe(1);
+	});
+});
+
+// C-15 (R-terminal-settles-dirty / B35): a dep's terminal (COMPLETE/ERROR) releases its
+// outstanding in-wave DIRTY contribution — the exactly-one-settle invariant — exactly as
+// DATA/RESOLVED/INVALIDATE do, so a DIRTY-then-terminal-without-DATA dep never strands the
+// join node's pending and wedges it. The terminal analogue of the INVALIDATE wedge-guard.
+describe("C-15 a dep's terminal releases its in-wave DIRTY contribution (R-terminal-settles-dirty / D-none)", () => {
+	const sum2 = (ctx: Ctx) =>
+		ctx.down([
+			["DATA", ((depLatest(ctx, 0) as number) ?? 0) + ((depLatest(ctx, 1) as number) ?? 0)],
+		]);
+
+	it("(a) COMPLETE-mid-dirty: D joins ONCE on the live leg, not wedged", () => {
+		const b = node<number>([], null, { initial: 1 });
+		const c = node<number>([], null, { initial: 10 });
+		const d = node<number>([b, c], sum2, { completeWhenDepsComplete: false });
+		const { msgs } = collect(d);
+		expect(d.cache).toBe(11); // first join (activation): 1 + 10
+		msgs.length = 0;
+
+		b.down([["DIRTY"]]); // B signals a change toward D (phase 1) → D dirty, pending=1
+		expect(d.status).toBe("dirty");
+		c.down([["DATA", 20]]); // C delivers a real value — but D is gated on B's pending
+		expect(d.cache).toBe(11); // not yet (B still dirty)
+		b.down([["COMPLETE"]]); // B COMPLETEs with NO DATA → releases B's dirty → D joins on C
+
+		expect(types(msgs)).toEqual(["DIRTY", "DATA"]); // joined EXACTLY once, glitch-free, no wedge
+		expect(d.cache).toBe(21); // B's last value (1) + C's new value (20)
+		expect(d.status).not.toBe("completed"); // C is still live (completeWhenDepsComplete:false)
+	});
+
+	it("(b) sole-dirty: B's COMPLETE drains pending → D un-dirties via RESOLVED (no fabricated DATA)", () => {
+		const b = node<number>([], null, { initial: 1 });
+		const c = node<number>([], null, { initial: 10 });
+		const d = node<number>([b, c], sum2, { completeWhenDepsComplete: false });
+		const { msgs } = collect(d);
+		expect(d.cache).toBe(11);
+		msgs.length = 0;
+
+		b.down([["DIRTY"]]); // B the SOLE dirty contributor (C unchanged this wave)
+		b.down([["COMPLETE"]]); // COMPLETEs with no value → no occurrence → undirty RESOLVED
+
+		expect(types(msgs)).toEqual(["DIRTY", "RESOLVED"]); // un-dirtied, NOT a fabricated DATA
+		expect(d.cache).toBe(11); // cache preserved (a terminal, unlike INVALIDATE, keeps the value)
+		expect(d.status).toBe("resolved"); // undirty-RESOLVED convention (hasData → resolved), not "settled"
+	});
+
+	it("(c) rescue: an absorbed ERROR releases the dirty + the fn reads the terminal, no wedge", () => {
+		const b = node<number>([], null, { initial: 1 });
+		const c = node<number>([], null, { initial: 10 });
+		const rescue = (ctx: Ctx) => {
+			const bt = depTerminal(ctx, 0);
+			const bv = isTerminalError(bt) ? 0 : ((depLatest(ctx, 0) as number) ?? 0);
+			ctx.down([["DATA", bv + ((depLatest(ctx, 1) as number) ?? 0)]]);
+		};
+		const d = node<number>([b, c], rescue, {
+			errorWhenDepsError: false,
+			terminalAsRealInput: true,
+		});
+		const { msgs } = collect(d);
+		expect(d.cache).toBe(11);
+		msgs.length = 0;
+
+		b.down([["DIRTY"]]); // B dirties D
+		b.down([["ERROR", new Error("boom")]]); // rescued (errorWhenDepsError:false) → fn reads terminal
+
+		expect(d.status).not.toBe("errored"); // NOT propagated — rescued
+		expect(data(msgs)).toEqual([10]); // B rescued to 0 + C(10); released dirty, no stranded pending
+	});
+
+	it("(d) gate-holds: a dirtied dep completing-empty on a PRE-first-run multi-dep node un-dirties, never wedges", () => {
+		// QA gate-holds corner (mutation-verified): node not yet first-run; C dirties then COMPLETEs
+		// with NO value while B has DATA — but the first-run gate STILL holds (C never delivered,
+		// terminalAsRealInput:false). The fn cannot run, yet the broadcast DIRTY must be balanced by
+		// a RESOLVED, else downstream wedges (the B35 class missed by the naive sawData→_maybeRun).
+		let runs = 0;
+		const b = node<number>([], null); // no initial — delivers only when driven
+		const c = node<number>([], null);
+		const d = node<number>(
+			[b, c],
+			(ctx: Ctx) => {
+				runs++;
+				ctx.down([
+					["DATA", ((depLatest(ctx, 0) as number) ?? 0) + ((depLatest(ctx, 1) as number) ?? 0)],
+				]);
+			},
+			{ completeWhenDepsComplete: false },
+		);
+		const { msgs } = collect(d);
+		expect(runs).toBe(0); // gate holds — neither dep delivered yet
+		msgs.length = 0;
+
+		c.down([["DIRTY"]]); // C signals a change → D dirty, broadcasts DIRTY (pending=1)
+		b.down([["DATA", 5]]); // B delivers a value, but the gate still needs C → D gated
+		expect(runs).toBe(0);
+		c.down([["COMPLETE"]]); // C COMPLETEs with NO value → releases dirty; gate STILL holds
+
+		expect(runs).toBe(0); // fn never ran (C never delivered data, terminalAsRealInput:false)
+		expect(types(msgs)).toEqual(["DIRTY", "RESOLVED"]); // un-dirtied downstream, NOT wedged
+		expect(d.cache).toBeUndefined(); // never produced a value
+	});
+});
+
+// C-16 (R-pull / R-up-routing / D269): a pull-mode node (NodeOptions.pullId:<Symbol>) is QUIET by
+// default — ABSORBS an upstream DIRTY without relaying it (the wedge fix), no push-on-subscribe (START
+// only). A DEMAND = a cone-routed PULL({pullId, params?}) (demand-if-holder-else-forward-up;
+// no node reference): fires EXACTLY ONE delivery (DIRTY-before-DATA) then re-quiets (1:1);
+// content = pausable mode (true→latest / resumeAll→backlog). A SELF-demand defers via ctx.upNext
+// (R-rewire-deferred); an immediate in-fn demand whose delivery loops back is the D37 feedback cycle.
+// pullId disambiguates siblings; pullId+pausable:false is rejected.
+describe("C-16 pull-mode node: quiet absorbs DIRTY + cone-routed demand delivers once then re-quiets (R-pull / R-up-routing / D269)", () => {
+	const PSNAP = Symbol("snapshot"); // the author-supplied pullId, shared between the pull node + the demander
+	// SNAP = a pull node over an accumulator ACC, projecting ACC's latest as the "snapshot".
+	const snapFn = (ctx: Ctx) => ctx.down([["DATA", depLatest(ctx, 0) as number]]);
+	const fwd: NodeFn = (ctx) => {
+		// a non-pull intermediate: forward any dep DATA downstream (relays a routed demand's delivery).
+		for (let i = 0; i < depCount(ctx); i++) {
+			const b = depBatch(ctx, i);
+			if (b) for (const v of b) ctx.down([["DATA", v]]);
+		}
+	};
+
+	it("(quiet/absorb + no push-on-subscribe) ACC changes never relay a DIRTY to SNAP's sink", () => {
+		const acc = node<number>([], null, { initial: 0 });
+		const snap = node<number>([acc], snapFn, { pullId: PSNAP }); // pausable defaults true
+		const { msgs } = collect(snap);
+		expect(types(msgs)).toEqual(["START"]); // quiet: cached value NOT pushed on subscribe (START only)
+		expect(snap.pullId).toBe(PSNAP); // the pullId is the author's value (inspection accessor)
+		msgs.length = 0;
+
+		acc.down([["DATA", 1]]); // ACC changes while SNAP is quiet
+		acc.down([["DATA", 2]]);
+		expect(msgs).toEqual([]); // absorbed — no DIRTY, no DATA relayed → a downstream is NEVER wedged
+	});
+
+	it("(demand true) one routed PULL({pullId}) delivers the coalesced LATEST as DIRTY→DATA, re-quiets (1:1)", () => {
+		const acc = node<number>([], null, { initial: 0 });
+		const snap = node<number>([acc], snapFn, { pullId: PSNAP });
+		const { msgs } = collect(snap);
+		msgs.length = 0;
+		acc.down([["DATA", 1]]);
+		acc.down([["DATA", 2]]); // two changes while quiet → coalesced
+
+		snap.up([["PULL", { pullId: PSNAP }]]); // DEMAND — direct on SNAP for this unit edge
+		expect(types(msgs)).toEqual(["DIRTY", "DATA"]); // DIRTY-before-DATA on the demand wave
+		expect(data(msgs)).toEqual([2]); // the coalesced LATEST (one DATA), not [1,2]
+		msgs.length = 0;
+
+		snap.up([["PULL", { pullId: PSNAP }]]); // D278: raw holder invokes even with no intervening change
+		expect(types(msgs)).toEqual(["DIRTY", "DATA"]);
+		expect(data(msgs)).toEqual([2]);
+		msgs.length = 0;
+
+		acc.down([["DATA", 3]]); // re-quiet held: a further change is again absorbed silently
+		expect(msgs).toEqual([]);
+	});
+
+	it("(demand resumeAll) one PULL drains the buffered BACKLOG incl. the activation value", () => {
+		const acc = node<number>([], null, { initial: 0 });
+		const snap = node<number>([acc], snapFn, { pullId: PSNAP, pausable: "resumeAll" });
+		const { msgs } = collect(snap);
+		msgs.length = 0;
+		acc.down([["DATA", 1]]);
+		acc.down([["DATA", 2]]);
+
+		snap.up([["PULL", { pullId: PSNAP }]]); // DEMAND
+		expect(data(msgs)).toEqual([0, 1, 2]); // activation value 0 + the backlog 1,2 (per-entry replay)
+		expect(types(msgs).filter((t) => t === "DIRTY").length).toBeGreaterThan(0); // DIRTY-before-DATA
+		msgs.length = 0;
+
+		snap.up([["PULL", { pullId: PSNAP }]]); // D278: raw holder invokes even with no intervening change
+		expect(types(msgs)).toEqual(["DIRTY", "DATA"]);
+		expect(data(msgs)).toEqual([2]);
+	});
+
+	it("(reject) pullId + pausable:false throws at construction", () => {
+		expect(() => node<number>([], null, { pullId: PSNAP, pausable: false })).toThrow(/pull/);
+	});
+
+	it("(routing: no-reference SELF-demand via ctx.upNext applies at the boundary — no D37, end-to-end)", () => {
+		const acc = node<number>([], null, { initial: 0 });
+		const snap = node<number>([acc], snapFn, { pullId: PSNAP });
+		const stream = node<number>([], null); // cheap delta-notification source
+		const received: number[] = [];
+		const cFn: NodeFn = (ctx) => {
+			const snapB = depBatch(ctx, 1);
+			if (snapB) for (const v of snapB) received.push(v as number);
+			const streamB = depBatch(ctx, 0);
+			// boundary-deferred self-demand: a cone-routed PULL({pullId}), NO snap reference held.
+			if (streamB && streamB.length > 0) ctx.upNext([["PULL", { pullId: PSNAP }]]);
+		};
+		const c = node<number>([stream, snap], cFn, { partial: true });
+		collect(c); // C is NOT wedged by the quiet snapshot
+		acc.down([["DATA", 7]]); // ACC change — absorbed by quiet SNAP
+		expect(received).toEqual([]); // no snapshot yet
+
+		stream.down([["DATA", 1]]); // a delta → C demands up the cone; the boundary drain delivers it
+		expect(received).toEqual([7]); // got the coalesced latest, no D37, no hang
+	});
+
+	it("(routing: pullId disambiguates siblings) a cone-routed PULL reaches ONLY the matching holder", () => {
+		// D → G(non-pull, forwards) → { Fsnap(pullId PF), Hsnap(pullId PH) } ; F,H are pull-over-acc.
+		const PF = Symbol("F");
+		const PH = Symbol("H");
+		const accF = node<number>([], null, { initial: 100 });
+		const accH = node<number>([], null, { initial: 200 });
+		const fSnap = node<number>([accF], snapFn, { pullId: PF });
+		const hSnap = node<number>([accH], snapFn, { pullId: PH });
+		const g = node<number>([fSnap, hSnap], fwd, { partial: true }); // intermediate forwards
+		const received: number[] = [];
+		const d = node<number>([g], (ctx) => {
+			const b = depBatch(ctx, 0);
+			if (b) for (const v of b) received.push(v as number);
+		});
+		collect(d);
+
+		d.up([["PULL", { pullId: PF }]]); // demand F up the cone (D→G→{F,H}); only F (holds PF) fires, H forwards+drops
+		expect(received).toEqual([100]); // F's value, NOT H's 200 — disambiguated by pullId identity
+		received.length = 0;
+
+		d.up([["PULL", { pullId: PH }]]); // now demand H — the sibling
+		expect(received).toEqual([200]); // only H fires
+	});
+
+	it("(routing: towardDep prunes) a directed demand reaches the pull dep but not the other branch", () => {
+		const acc = node<number>([], null, { initial: 5 });
+		const snap = node<number>([acc], snapFn, { pullId: PSNAP });
+		const stream = node<number>([], null);
+		const received: number[] = [];
+		const cFn: NodeFn = (ctx) => {
+			const snapB = depBatch(ctx, 1); // snap is dep index 1
+			if (snapB) for (const v of snapB) received.push(v as number);
+		};
+		const c = node<number>([stream, snap], cFn, { partial: true });
+		collect(c);
+
+		// directed toward dep 0 (stream) — routes AWAY from snap → snap never reached → silent
+		c.up([["PULL", { pullId: PSNAP }]], 0);
+		expect(received).toEqual([]);
+
+		// directed toward dep 1 (snap) — reaches the pull holder → delivers
+		c.up([["PULL", { pullId: PSNAP }]], 1);
+		expect(received).toEqual([5]);
+	});
+
+	it("(immediate) an in-fn demand whose delivery loops back to the consumer is the D37 feedback cycle", () => {
+		const acc = node<number>([], null, { initial: 0 });
+		const snap = node<number>([acc], snapFn, { pullId: PSNAP });
+		const stream = node<number>([], null);
+		const cFn: NodeFn = (ctx) => {
+			const streamB = depBatch(ctx, 0);
+			// IMMEDIATE (non-deferred) demand: SNAP's delivery loops straight back → re-enters C mid-wave.
+			if (streamB && streamB.length > 0) ctx.up([["PULL", { pullId: PSNAP }]]);
+		};
+		const c = node<number>([stream, snap], cFn, { partial: true });
+		collect(c);
+		acc.down([["DATA", 7]]);
+		expect(() => stream.down([["DATA", 1]])).toThrow(/feedback cycle|reentrancy/i);
+	});
+});
+
+// C-17 (R-deps-terminal / B42): an ABSORBED error (errorWhenDepsError:false) counts as TERMINAL for
+// the completeWhenDepsComplete auto-COMPLETE cascade — order-independent (whichever terminal lands
+// last fires it). The COMPLETION analogue of C-15's DIRTY-release. NOT hit by the landed catalog
+// (rescue/race/sample use completeWhenDepsComplete:false) — a pure latent-wedge fix.
+describe("C-17 — absorbed-error dep counts as terminal for auto-COMPLETE (B42 / R-deps-terminal)", () => {
+	const fwd: NodeFn = (ctx) => {
+		for (let i = 0; i < depCount(ctx); i++) {
+			const b = depBatch(ctx, i);
+			if (b) for (const v of b) ctx.down([["DATA", v]]);
+		}
+	};
+
+	it("(a) error-then-complete: C errors (absorbed), then B completes → D auto-COMPLETEs", () => {
+		const g = graph();
+		const b = g.node<number>([], null); // manual source
+		const c = g.node<number>([], null);
+		const d = g.node([b, c], fwd, { errorWhenDepsError: false }); // absorbs C's error, stays live
+		collect(d);
+		c.down([["ERROR", new Error("boom")]]); // absorbed; B still live → not yet all-terminal
+		expect(d.status).not.toBe("completed");
+		expect(d.status).not.toBe("errored"); // errorWhenDepsError:false → no auto-ERROR
+		b.down([["DATA", 1], ["COMPLETE"]]); // B terminal → ALL deps terminal (C errored) → COMPLETE
+		expect(d.status).toBe("completed");
+	});
+
+	it("(b) complete-then-error: B completes, then C errors LAST → D still auto-COMPLETEs (ERROR-arm mirror)", () => {
+		const g = graph();
+		const b = g.node<number>([], null);
+		const c = g.node<number>([], null);
+		const d = g.node([b, c], fwd, { errorWhenDepsError: false });
+		collect(d);
+		b.down([["DATA", 1], ["COMPLETE"]]); // B terminal; C still live → not yet all-terminal
+		expect(d.status).not.toBe("completed");
+		c.down([["ERROR", new Error("boom")]]); // C absorbed-error LANDS LAST → all terminal → COMPLETE
+		expect(d.status).toBe("completed"); // the ERROR-absorbed arm mirrors the COMPLETE arm (B42)
+	});
+
+	it("(c) errorWhenDepsError:true (default) auto-ERRORs on a dep error (absorbed path gated off)", () => {
+		const g = graph();
+		const b = g.node<number>([], null);
+		const c = g.node<number>([], null);
+		const d = g.node([b, c], fwd); // defaults: errorWhenDepsError:true
+		collect(d);
+		c.down([["ERROR", new Error("boom")]]); // auto-cascade → ERROR before any complete-check
+		expect(d.status).toBe("errored");
+	});
+});
+
+// C-18 (R-up-routing-diamond / D63): a routed broadcast PULL over a diamond can reach the same
+// pull holder through multiple upstream paths, but that holder fires at most once for the wave.
+describe("C-18 — routed pull demand over a diamond is holder-idempotent (R-up-routing-diamond / D63)", () => {
+	it("broadcast PULL over D→G1/G2→SNAP invokes SNAP's demand handler once", () => {
+		const PSNAP = Symbol("snapshot");
+		const acc = node<number>([], null, { initial: 0 });
+		const snap = node<number>([acc], (ctx) => ctx.down([["DATA", depLatest(ctx, 0) as number]]), {
+			pullId: PSNAP,
+		});
+		let demands = 0;
+		const snapProbe = snap as unknown as {
+			_onDemand: () => void;
+		};
+		const originalOnDemand = snapProbe._onDemand.bind(snap);
+		snapProbe._onDemand = () => {
+			demands++;
+			originalOnDemand();
+		};
+
+		const fwd: NodeFn = (ctx) => {
+			for (let i = 0; i < depCount(ctx); i++) {
+				const b = depBatch(ctx, i);
+				if (b) for (const v of b) ctx.down([["DATA", v]]);
+			}
+		};
+		const g1 = node<number>([snap], fwd, { partial: true });
+		const g2 = node<number>([snap], fwd, { partial: true });
+		const d = node<number>([g1, g2], fwd, { partial: true });
+		collect(d);
+
+		acc.down([["DATA", 1]]); // quiet SNAP absorbs the change
+		d.up([["PULL", { pullId: PSNAP }]]); // D broadcasts through both G1 and G2 to the same holder
+
+		expect(demands).toBe(1);
+	});
+});
+
+// C-19 (R-undirty-settle-timing / D64): substrate-synthesized undirty RESOLVED from non-fn settle
+// arms must use the normal down path, so pause resumeAll and batch timing apply.
+describe("C-19 — undirty RESOLVED from non-fn settle arms respects pause and batch (R-undirty-settle-timing / D64)", () => {
+	it("resumeAll buffers a never-valued INVALIDATE un-dirty until RESUME", () => {
+		const b = node<number>([], null, { initial: 1 });
+		const c = node<number>([], null);
+		const d = node<number>(
+			[b, c],
+			(ctx) =>
+				ctx.down([
+					["DATA", ((depLatest(ctx, 0) as number) ?? 0) + ((depLatest(ctx, 1) as number) ?? 0)],
+				]),
+			{ pausable: "resumeAll" },
+		);
+		const { msgs } = collect(d);
+		msgs.length = 0;
+
+		const L = Symbol("pause");
+		d.up([["PAUSE", L]]);
+		b.down([["DIRTY"]]);
+		b.down([["INVALIDATE"]]);
+		expect(types(msgs)).toEqual(["DIRTY"]);
+
+		d.up([["RESUME", L]]);
+		expect(types(msgs)).toEqual(["DIRTY", "RESOLVED"]);
+		expect(d.status).toBe("sentinel");
+	});
+
+	it("batch commit emits the un-dirty only after the batch body closes", () => {
+		const b = node<number>([], null, { initial: 1 });
+		const c = node<number>([], null);
+		const d = node<number>([b, c], (ctx) =>
+			ctx.down([
+				["DATA", ((depLatest(ctx, 0) as number) ?? 0) + ((depLatest(ctx, 1) as number) ?? 0)],
+			]),
+		);
+		const { msgs } = collect(d);
+		msgs.length = 0;
+
+		batch(() => {
+			b.down([["DIRTY"]]);
+			b.down([["INVALIDATE"]]);
+			expect(types(msgs)).toEqual(["DIRTY"]);
+		});
+
+		expect(types(msgs)).toEqual(["DIRTY", "RESOLVED"]);
+	});
+});
+
+// C-20 (R-teardown-terminal-relay / D65): COMPLETE/ERROR seal value output, but they do not block
+// a later upstream TEARDOWN needed to unwind downstream lifecycle.
+describe("C-20 — TEARDOWN relays through a terminal intermediate (R-teardown-terminal-relay / D65)", () => {
+	it("a completed node relays later upstream TEARDOWN without re-completing", () => {
+		const s = node<number>([], null, { initial: 1 });
+		const mid = node<number>([s], (ctx) => ctx.down([["DATA", depLatest(ctx, 0) as number]]), {
+			completeWhenDepsComplete: false,
+		});
+		const { msgs } = collect(mid);
+		mid.down([["COMPLETE"]]);
+		msgs.length = 0;
+
+		s.down([["TEARDOWN"]]);
+
+		expect(types(msgs)).toEqual(["TEARDOWN"]);
+	});
+
+	it("a terminal relay forwards repeated upstream TEARDOWNs without re-completing", () => {
+		const s = node<number>([], null, { initial: 1 });
+		const mid = node<number>([s], (ctx) => ctx.down([["DATA", depLatest(ctx, 0) as number]]), {
+			completeWhenDepsComplete: false,
+		});
+		const { msgs } = collect(mid);
+		mid.down([["COMPLETE"]]);
+		msgs.length = 0;
+
+		s.down([["TEARDOWN"]]);
+		s.down([["TEARDOWN"]]);
+
+		expect(types(msgs)).toEqual(["TEARDOWN", "TEARDOWN"]);
+	});
+});
+
+// C-21 (R-rewire-async-live-edge / D66): async ctx objects are allowed to keep the old dep input
+// snapshot for reads, but their late up/down emissions target the node's live topology.
+describe("C-21 — late async ctx emission uses live deps after rewire (R-rewire-async-live-edge / D66)", () => {
+	it("a ctx captured before rewire routes ctx.up through the node's current deps", () => {
+		let captured: Ctx | null = null;
+		const a = node<number>([], null, { initial: 1 });
+		const b = node<number>([], null, { initial: 2 });
+		const d = node<number>(
+			[a],
+			(ctx) => {
+				captured = ctx;
+			},
+			{ pool: "async" },
+		);
+		collect(d);
+
+		d.replaceDeps([b], () => {});
+		(captured as Ctx).up([["INVALIDATE"]]);
+
+		expect(a.cache).toBe(1);
+		expect(b.cache).toBeUndefined();
+	});
+});
+
+// C-22 (R-rewire-batch-boundary / D67): if a node has an uncommitted batched settle slice, an
+// external rewire request waits until the batch commits, so the old slice is not overwritten.
+describe("C-22 — batch commit precedes rewire requested during the open batch (R-rewire-batch-boundary / D67)", () => {
+	it("commits the old batched DATA before applying the rewire's fresh DATA", () => {
+		const a = node<number>([], null, { initial: 1 });
+		const b = node<number>([], null, { initial: 10 });
+		const fwd: NodeFn = (ctx) => ctx.down([["DATA", depLatest(ctx, 0) as number]]);
+		const d = node<number>([a], fwd);
+		const { msgs } = collect(d);
+		msgs.length = 0;
+
+		batch(() => {
+			d.down([["DATA", 2]]);
+			d.replaceDeps([b], fwd);
+			expect(d.deps[0]).toBe(a);
+			expect(data(msgs)).toEqual([]);
+		});
+
+		expect(data(msgs)).toEqual([2, 10]);
+		expect(d.deps[0]).toBe(b);
+		expect(d.cache).toBe(10);
+	});
+
+	it("does not apply a deferred rewire when the batch rolls back", () => {
+		const a = node<number>([], null, { initial: 1 });
+		const b = node<number>([], null, { initial: 10 });
+		const fwd: NodeFn = (ctx) => ctx.down([["DATA", depLatest(ctx, 0) as number]]);
+		const d = node<number>([a], fwd);
+		const { msgs } = collect(d);
+		msgs.length = 0;
+
+		batch((bctx) => {
+			d.down([["DATA", 2]]);
+			d.replaceDeps([b], fwd);
+			bctx.rollback();
+		});
+
+		expect(d.deps[0]).toBe(a);
+		expect(data(msgs)).toEqual([]);
+		expect(d.cache).toBe(1);
+	});
+
+	it("applies an accepted rewire after a terminal batch slice while terminal output stays sealed", () => {
+		const a = node<number>([], null, { initial: 1 });
+		const b = node<number>([], null, { initial: 10 });
+		const fwd: NodeFn = (ctx) => ctx.down([["DATA", depLatest(ctx, 0) as number]]);
+		const d = node<number>([a], fwd, { completeWhenDepsComplete: false });
+		const { msgs } = collect(d);
+		msgs.length = 0;
+
+		batch(() => {
+			d.down([["COMPLETE"]]);
+			d.replaceDeps([b], fwd);
+			expect(d.deps[0]).toBe(a);
+		});
+
+		expect(d.status).toBe("completed");
+		expect(d.deps[0]).toBe(b);
+		expect(types(msgs)).toEqual(["DIRTY", "COMPLETE"]);
+		msgs.length = 0;
+		b.down([["DATA", 11]]);
+		expect(msgs).toEqual([]);
+	});
+
+	it("returns the future index for an subscribeDep deferred behind a batch commit", () => {
+		const a = node<number>([], null, { initial: 1 });
+		const b = node<number>([], null, { initial: 10 });
+		const sum: NodeFn = (ctx) =>
+			ctx.down([
+				["DATA", ((depLatest(ctx, 0) as number) ?? 0) + ((depLatest(ctx, 1) as number) ?? 0)],
+			]);
+		const d = node<number>([a], (ctx) => ctx.down([["DATA", depLatest(ctx, 0) as number]]));
+		collect(d);
+
+		let idx = -2;
+		batch(() => {
+			d.down([["DATA", 2]]);
+			idx = d.subscribeDep(b, sum);
+			expect(d.deps).toEqual([a]);
+		});
+
+		expect(idx).toBe(1);
+		expect(d.deps).toEqual([a, b]);
+	});
+});
+
+// C-24 (R-snapshot/R-restore, D83/D117): restore is state-preserving. A restored dep-bearing
+// node's first post-restore activation wires deps, but the restored deps' push-on-subscribe DATA
+// is only bookkeeping seed data; it must not recompute over or clear the restored cache.
+describe("C-24 snapshot restore preserves graph state and rejects local-only factories (R-restore / D117)", () => {
+	it("late subscriber observes restored derived cache; dep activation does not recompute", () => {
+		const original = graph();
+		const src = original.state(1, { name: "src" });
+		const inc = define<number, number>("c24.inc", (n) => n + 1);
+		const mapped = original.initNode(map(inc), [src], { name: "mapped" });
+		collect(mapped);
+		expect(mapped.cache).toBe(2);
+
+		const reloadedInc = define<number, number>("c24.inc", (n) => n + 100);
+		const restored = restoreGraph(original.checkpoint(), {
+			registry: restoreRegistry([reloadedInc], defaultRestoreRegistry),
+		});
+		const restoredMapped = restored.find("mapped") as Node<number>;
+		const restoredSrc = restored.find("src") as { set(v: number): void };
+		const { msgs } = collect(restoredMapped);
+
+		expect(types(msgs)).toEqual(["START", "DATA"]);
+		expect(data(msgs)).toEqual([2]);
+		expect(restoredMapped.cache).toBe(2);
+		expect(restored.describe().edges).toContainEqual({ from: "src", to: "mapped" });
+
+		msgs.length = 0;
+		restoredSrc.set(2);
+		expect(data(msgs)).toEqual([102]);
+		expect(restoredMapped.cache).toBe(102);
+	});
+
+	it("fails honestly for local-only and missing registry factories", () => {
+		const localOnly = graph();
+		const src = localOnly.state(1, { name: "src" });
+		localOnly.derived([src], (n) => n, { name: "derived" });
+		expect(() =>
+			restoreGraph(localOnly.checkpoint(), { registry: defaultRestoreRegistry }),
+		).toThrow(/local-only/);
+
+		const missing = graph();
+		missing.state(1, { name: "src" });
+		expect(() => restoreGraph(missing.checkpoint(), { registry: {} })).toThrow(
+			/missing registry descriptor/,
+		);
+	});
+});
diff --git a/packages/ts/src/__tests__/conformance.part-03.test.ts b/packages/ts/src/__tests__/conformance.part-03.test.ts
new file mode 100644
index 00000000..3bed6ab2
--- /dev/null
+++ b/packages/ts/src/__tests__/conformance.part-03.test.ts
@@ -0,0 +1,588 @@
+/**
+ * Behavioral conformance — TS arm of ~/src/graphrefly/spec/conformance.jsonl (D24).
+ *
+ * Each test is the TS adapter for a language-agnostic scenario: it builds the scenario's
+ * topology, drives its input wave sequence, and asserts the expected OBSERVABLE wave output.
+ *
+ * C-1 (cross-graph diamond) is NOT here — it requires the wire bridge (backlog B2). The
+ * in-process diamond core it leans on is green in core.test.ts (R-diamond/R-two-phase).
+ */
+
+import { describe, expect, it } from "vitest";
+import type { Ctx, Message, NodeFn } from "../index.js";
+import { batch, depBatch, depLatest, dynamicNode, fromPromise, graph, node } from "../index.js";
+
+const types = (msgs: Message[]) => msgs.map((m) => m[0]);
+const data = (msgs: Message[]) =>
+	msgs.filter((m) => m[0] === "DATA").map((m) => (m as ["DATA", unknown])[1]);
+const flush = () => new Promise((r) => setTimeout(r, 0));
+function collect(n: { subscribe(s: (m: Message) => void): () => void }) {
+	const msgs: Message[] = [];
+	const unsub = n.subscribe((m) => msgs.push(m));
+	return { msgs, unsub };
+}
+
+// C-25 (R-rewire-deferred-committed-boundary / D110): ctx.rewireNext/ctx.upNext tasks apply only
+// after the owner reaches a committed, unpaused boundary view. Rollback drops the tasks caused by
+// that batch; it does not let subscribeDep/unsubscribeDep/replaceDeps/upNext leak a hidden committed effect.
+describe("C-25 — deferred self-boundary tasks require committed + unpaused boundary", () => {
+	function makeHelper(seed: number) {
+		let hctx: Ctx | null = null;
+		let activated = false;
+		let deactivated = false;
+		const n = node<number>([], (ctx) => {
+			hctx = ctx;
+			activated = true;
+			ctx.onDeactivation(() => {
+				deactivated = true;
+			});
+			ctx.down([["DATA", seed]]);
+		});
+		return {
+			node: n,
+			emit: (v: number) => (hctx as Ctx).down([["DATA", v]]),
+			isActivated: () => activated,
+			isDeactivated: () => deactivated,
+		};
+	}
+
+	it("batch commit settles the old shape before draining a queued subscribeDep", () => {
+		const s = node<number>([], null);
+		const helper = makeHelper(42);
+		const opFn: NodeFn = (ctx) => {
+			const h = depBatch(ctx, 1);
+			if (h) for (const v of h) ctx.down([["DATA", `helper:${v}`]]);
+			const sv = depBatch(ctx, 0);
+			if (sv && sv.length > 0) {
+				ctx.rewireNext.subscribeDep(helper.node, opFn);
+				ctx.down([["DATA", `source:${sv.at(-1)}`]]);
+				expect(helper.isActivated()).toBe(false);
+			}
+		};
+		const op = node<string>([s], opFn, {
+			completeWhenDepsComplete: false,
+			terminalAsRealInput: true,
+		});
+		const { msgs } = collect(op);
+		msgs.length = 0;
+
+		batch(() => {
+			s.down([["DATA", 1]]);
+			expect(op.deps).toEqual([s]);
+			expect(helper.isActivated()).toBe(false);
+			expect(data(msgs)).toEqual([]);
+		});
+
+		expect(op.deps).toEqual([s, helper.node]);
+		expect(helper.isActivated()).toBe(true);
+		expect(data(msgs)).toEqual(["source:1", "helper:42"]);
+	});
+
+	it("rollback drops a queued subscribeDep: helper cache does not activate and deps stay old-shape", () => {
+		const s = node<number>([], null, { initial: 1 });
+		const helper = makeHelper(10);
+		const opFn: NodeFn = (ctx) => {
+			if (depBatch(ctx, 0)) ctx.rewireNext.subscribeDep(helper.node, opFn);
+		};
+		const op = node<number>([s], opFn, { completeWhenDepsComplete: false });
+
+		batch((bctx) => {
+			collect(op); // activation inside the open batch queues the task under that batch
+			expect(op.deps).toEqual([s]);
+			expect(helper.isActivated()).toBe(false);
+			bctx.rollback();
+		});
+
+		expect(op.deps).toEqual([s]);
+		expect(helper.isActivated()).toBe(false);
+	});
+
+	it("rollback drops a queued unsubscribeDep cleanup: helper stays subscribed and live", () => {
+		const s = node<number>([], null, { initial: 1 });
+		const helper = makeHelper(20);
+		const opFn: NodeFn = (ctx) => {
+			if (depBatch(ctx, 0)) ctx.rewireNext.unsubscribeDep(helper.node, opFn);
+			const h = depBatch(ctx, 1);
+			if (h) for (const v of h) ctx.down([["DATA", v as number]]);
+		};
+		const op = node<number>([s, helper.node], opFn, {
+			completeWhenDepsComplete: false,
+			terminalAsRealInput: true,
+		});
+		let msgs: Message[] = [];
+
+		batch((bctx) => {
+			msgs = collect(op).msgs; // activation queues unsubscribeDep under the open batch
+			expect(helper.isActivated()).toBe(true);
+			bctx.rollback();
+		});
+
+		expect(op.deps).toEqual([s, helper.node]);
+		expect(helper.isDeactivated()).toBe(false);
+		msgs.length = 0;
+		helper.emit(21);
+		expect(data(msgs)).toEqual([21]);
+	});
+
+	it("rollback drops a queued replaceDeps: replacement helper never activates", () => {
+		const s = node<number>([], null, { initial: 1 });
+		const oldHelper = makeHelper(30);
+		const newHelper = makeHelper(31);
+		const opFn: NodeFn = (ctx) => {
+			if (depBatch(ctx, 0)) ctx.rewireNext.replaceDeps([s, newHelper.node], opFn);
+			const h = depBatch(ctx, 1);
+			if (h) for (const v of h) ctx.down([["DATA", v as number]]);
+		};
+		const op = node<number>([s, oldHelper.node], opFn, {
+			completeWhenDepsComplete: false,
+			terminalAsRealInput: true,
+		});
+
+		batch((bctx) => {
+			collect(op); // activation queues replaceDeps under the open batch
+			expect(oldHelper.isActivated()).toBe(true);
+			bctx.rollback();
+		});
+
+		expect(op.deps).toEqual([s, oldHelper.node]);
+		expect(oldHelper.isDeactivated()).toBe(false);
+		expect(newHelper.isActivated()).toBe(false);
+	});
+
+	it("rollback drops ctx.upNext self-demand: no pull delivery routes after the batch", () => {
+		const pullId = Symbol("c25-pull");
+		const acc = node<number>([], null, { initial: 7 });
+		const snap = node<number>([acc], (ctx) => ctx.down([["DATA", depLatest(ctx, 0) as number]]), {
+			pullId,
+		});
+		const stream = node<number>([], null, { initial: 1 });
+		const received: number[] = [];
+		const consumer = node<number>(
+			[stream, snap],
+			(ctx) => {
+				const snapB = depBatch(ctx, 1);
+				if (snapB) for (const v of snapB) received.push(v as number);
+				if (depBatch(ctx, 0)) ctx.upNext([["PULL", { pullId }]]);
+			},
+			{ partial: true },
+		);
+
+		batch((bctx) => {
+			collect(consumer);
+			bctx.rollback();
+		});
+
+		expect(received).toEqual([]);
+	});
+
+	it("a paused owner holds queued subscribeDep until the final RESUME", () => {
+		const s = node<number>([], null);
+		const helper = makeHelper(50);
+		const l1 = Symbol("pause-1");
+		const l2 = Symbol("pause-2");
+		const opFn: NodeFn = (ctx) => {
+			if (depBatch(ctx, 0)) {
+				ctx.rewireNext.subscribeDep(helper.node, opFn);
+				ctx.down([["DATA", 1]]);
+			}
+		};
+		const op = node<number>([s], opFn, { completeWhenDepsComplete: false });
+		op.subscribe((m) => {
+			if (m[0] === "DATA") {
+				op.up([
+					["PAUSE", l1],
+					["PAUSE", l2],
+				]);
+			}
+		});
+
+		s.down([["DATA", 1]]);
+		expect(helper.isActivated()).toBe(false);
+		op.up([["RESUME", l1]]);
+		expect(helper.isActivated()).toBe(false);
+		op.up([["RESUME", l2]]);
+		expect(helper.isActivated()).toBe(true);
+	});
+
+	it("combined batch+pause: commit before resume does not drain until resume", () => {
+		const s = node<number>([], null);
+		const helper = makeHelper(60);
+		const lock = Symbol("pause");
+		const opFn: NodeFn = (ctx) => {
+			if (depBatch(ctx, 0)) {
+				ctx.rewireNext.subscribeDep(helper.node, opFn);
+				ctx.down([["DATA", 1]]);
+			}
+		};
+		const op = node<number>([s], opFn, { completeWhenDepsComplete: false });
+		op.subscribe((m) => {
+			if (m[0] === "DATA") op.up([["PAUSE", lock]]);
+		});
+
+		batch(() => s.down([["DATA", 1]]));
+		expect(helper.isActivated()).toBe(false);
+		op.up([["RESUME", lock]]);
+		expect(helper.isActivated()).toBe(true);
+	});
+
+	it("combined batch+pause: resume before commit still waits for batch commit", () => {
+		const s = node<number>([], null, { initial: 1 });
+		const helper = makeHelper(70);
+		const lock = Symbol("pause");
+		const opFn: NodeFn = (ctx) => {
+			if (depBatch(ctx, 0)) {
+				ctx.rewireNext.subscribeDep(helper.node, opFn);
+				ctx.down([["DATA", 1]]);
+			}
+		};
+		const op = node<number>([s], opFn, { completeWhenDepsComplete: false });
+		op.subscribe((m) => {
+			if (m[0] === "DATA") op.up([["PAUSE", lock]]);
+		});
+
+		batch(() => {
+			expect(helper.isActivated()).toBe(false);
+			op.up([["RESUME", lock]]);
+			expect(helper.isActivated()).toBe(false);
+		});
+		expect(helper.isActivated()).toBe(true);
+	});
+});
+
+// C-26 (R-msg-closed-set / R-tier / R-ctx-up / R-pull / R-up-routing): D269 makes PULL the
+// explicit demand message with holder-visible params; RESUME remains pause-lock release only.
+describe("C-26 — PULL is explicit demand with params; RESUME remains pause-only", () => {
+	it("routes PULL params, drops unknown PULL, rejects DATA-up, and keeps latest owed params", () => {
+		const pullId = Symbol("c26-pull");
+		const acc = node<number>([], null, { initial: 0 });
+		const seen: unknown[] = [];
+		const snap = node<number>(
+			[acc],
+			(ctx) => {
+				seen.push(ctx.pull?.params);
+				ctx.down([["DATA", depLatest(ctx, 0) as number]]);
+			},
+			{ pullId },
+		);
+		const { msgs } = collect(snap);
+		msgs.length = 0;
+
+		acc.down([["DATA", 1]]);
+		snap.up([["PULL", { pullId, params: { cursor: 7, limit: 2 } }]]);
+		expect(seen).toEqual([{ cursor: 7, limit: 2 }]);
+		expect(data(msgs)).toEqual([1]);
+
+		msgs.length = 0;
+		acc.down([["DATA", 2]]);
+		snap.up([["RESUME", pullId]]);
+		expect(msgs).toEqual([]);
+		expect(seen).toHaveLength(1);
+
+		expect(() =>
+			snap.up([["PULL", { pullId: Symbol("missing"), params: { cursor: 9 } }]]),
+		).not.toThrow();
+		expect(msgs).toEqual([]);
+		expect(() => snap.up([["DATA", 3] as Message])).toThrow(/ctx\.up|control|demand|DATA/i);
+
+		acc.down([["DIRTY"]]);
+		snap.up([["PULL", { pullId, params: { cursor: 1 } }]]);
+		snap.up([["PULL", { pullId, params: { cursor: 2 } }]]);
+		acc.down([["DATA", 5]]);
+		expect(seen.at(-1)).toEqual({ cursor: 2 });
+		expect(data(msgs)).toEqual([5]);
+	});
+
+	it("ordinary pause locks still release through RESUME without acting as pull demand", () => {
+		const s = node<number>([], null, { initial: 1 });
+		const n = node<number>([s], (ctx) => ctx.down([["DATA", depLatest(ctx, 0) as number]]));
+		const { msgs } = collect(n);
+		msgs.length = 0;
+		const lock = Symbol("pause");
+
+		n.up([["PAUSE", lock]]);
+		s.down([["DATA", 2]]);
+		expect(msgs).toEqual([["DIRTY"]]);
+		n.up([["RESUME", lock]]);
+		expect(types(msgs)).toEqual(["DIRTY", "DATA"]);
+		expect(data(msgs)).toEqual([2]);
+	});
+});
+
+// C-27 (R-pull / R-fn-contract / R-ctx-up): no-change PULL reaches the holder; downstream DATA is
+// the helper's ordinary output decision, so params may drive retained output while plain helpers may stay silent.
+describe("C-27 — PULL invokes holder without dep change and params may drive retained output", () => {
+	it("invokes a retained-view holder twice over stable state and lets params change the emitted page", () => {
+		const pullId = Symbol("c27-page");
+		const source = node<readonly number[]>([], null, { initial: [1, 2, 3] });
+		const seen: unknown[] = [];
+		const page = node<readonly number[]>(
+			[source],
+			(ctx) => {
+				seen.push(ctx.pull?.params);
+				const limit = ((ctx.pull?.params as { limit?: number } | undefined)?.limit ?? 3) as number;
+				ctx.down([["DATA", (depLatest(ctx, 0) as readonly number[]).slice(0, limit)]]);
+			},
+			{ pullId },
+		);
+		const { msgs } = collect(page);
+		msgs.length = 0;
+
+		page.up([["PULL", { pullId, params: { limit: 1 } }]]);
+		page.up([["PULL", { pullId, params: { limit: 2 } }]]);
+
+		expect(seen).toEqual([{ limit: 1 }, { limit: 2 }]);
+		expect(data(msgs)).toEqual([[1], [1, 2]]);
+	});
+
+	it("allows a plain helper to invoke on no-change PULL yet emit nothing, and RESUME is negative control", () => {
+		const pullId = Symbol("c27-plain");
+		const source = node<number>([], null, { initial: 10 });
+		const seen: unknown[] = [];
+		const plain = node<number>(
+			[source],
+			(ctx) => {
+				seen.push(ctx.pull?.params);
+				if (ctx.state.get() === "served") return;
+				ctx.state.set("served");
+				ctx.down([["DATA", depLatest(ctx, 0) as number]]);
+			},
+			{ pullId },
+		);
+		const { msgs } = collect(plain);
+		msgs.length = 0;
+
+		plain.up([["PULL", { pullId, params: { limit: 1 } }]]);
+		expect(data(msgs)).toEqual([10]);
+		msgs.length = 0;
+		plain.up([["PULL", { pullId, params: { limit: 2 } }]]);
+		expect(msgs).toEqual([]);
+		plain.up([["RESUME", pullId]]);
+
+		expect(seen).toEqual([{ limit: 1 }, { limit: 2 }]);
+		expect(msgs).toEqual([]);
+	});
+});
+
+describe("QA — synthesized no-emit RESOLVED uses normal timing", () => {
+	it("buffers a sync fn's synthesized RESOLVED while paused in resumeAll mode", () => {
+		const s = node<number>([], null, { initial: 1 });
+		const f = node<number>(
+			[s],
+			(ctx) => {
+				const value = depLatest(ctx, 0) as number;
+				if (value >= 10) ctx.down([["DATA", value]]);
+			},
+			{ pausable: "resumeAll" },
+		);
+		const { msgs } = collect(f);
+		msgs.length = 0;
+
+		const L = Symbol("pause");
+		f.up([["PAUSE", L]]);
+		s.down([["DATA", 2]]);
+
+		expect(types(msgs)).toEqual(["DIRTY"]);
+		f.up([["RESUME", L]]);
+		expect(types(msgs)).toEqual(["DIRTY", "DIRTY", "RESOLVED"]);
+	});
+});
+
+describe("C-23 raw ctx waveData is the only dep-value input (R-fn-contract / R-ctx-wave-data / R-data-payload / D77/D78)", () => {
+	const cloneWaveData = (ctx: Ctx) => ctx.waveData.map((waves) => waves.map((w) => [...w]));
+
+	it("exposes waveData/terminal, not depRecords/latest/prevData aliases", () => {
+		let seen: { waveData: unknown[][][]; terminal: unknown[]; hasDepRecords: boolean } | null =
+			null;
+		const a = node<number>([], null);
+		const n = node<number>(
+			[a],
+			(ctx) => {
+				seen = {
+					waveData: cloneWaveData(ctx),
+					terminal: [...ctx.terminal],
+					hasDepRecords: "depRecords" in ctx,
+				};
+			},
+			{ partial: true },
+		);
+		collect(n);
+
+		a.down([["DATA", 1]]);
+
+		expect(seen).toEqual({
+			waveData: [[[1]]],
+			terminal: [false],
+			hasDepRecords: false,
+		});
+	});
+
+	it("distinguishes no-wave, RESOLVED-only, DATA+INVALIDATE, null, and empty-array payloads", () => {
+		const captures: unknown[][][][] = [];
+		const a = node<unknown>([], null);
+		const b = node<unknown>([], null);
+		const n = node<unknown>(
+			[a, b],
+			(ctx) => {
+				captures.push(cloneWaveData(ctx));
+			},
+			{ partial: true },
+		);
+		collect(n);
+
+		b.down([["DATA", "b"]]);
+		expect(captures.at(-1)).toEqual([[], [["b"]]]);
+
+		a.down([["DIRTY"]]);
+		a.down([["RESOLVED"]]);
+		expect(captures.at(-1)).toEqual([[[]], []]);
+
+		a.down([["DATA", 1], ["DATA", 2], ["INVALIDATE"]]);
+		expect(captures.at(-1)).toEqual([[[1, 2, undefined]], []]);
+
+		a.down([["DATA", null]]);
+		expect(captures.at(-1)).toEqual([[[null]], []]);
+
+		a.down([["DATA", []]]);
+		expect(captures.at(-1)).toEqual([[[[]]], []]);
+	});
+
+	it("keeps COMPLETE/ERROR out of waveData and in ctx.terminal", () => {
+		const terminals: unknown[][] = [];
+		const waves: unknown[][][][] = [];
+		const a = node<number>([], null);
+		const n = node<number>(
+			[a],
+			(ctx) => {
+				waves.push(cloneWaveData(ctx));
+				terminals.push([...ctx.terminal]);
+			},
+			{
+				partial: true,
+				completeWhenDepsComplete: false,
+				errorWhenDepsError: false,
+				terminalAsRealInput: true,
+			},
+		);
+		collect(n);
+
+		a.down([["COMPLETE"]]);
+		expect(waves.at(-1)).toEqual([[]]);
+		expect(terminals.at(-1)).toEqual([true]);
+
+		const e = new Error("boom");
+		const b = node<number>([], null);
+		const m = node<number>(
+			[b],
+			(ctx) => {
+				waves.push(cloneWaveData(ctx));
+				terminals.push([...ctx.terminal]);
+			},
+			{
+				partial: true,
+				completeWhenDepsComplete: false,
+				errorWhenDepsError: false,
+				terminalAsRealInput: true,
+			},
+		);
+		collect(m);
+		b.down([["ERROR", e]]);
+		expect(waves.at(-1)).toEqual([[]]);
+		expect(terminals.at(-1)).toEqual([e]);
+
+		const c = node<number>([], null);
+		const p = node<number>(
+			[c],
+			(ctx) => {
+				waves.push(cloneWaveData(ctx));
+				terminals.push([...ctx.terminal]);
+			},
+			{
+				partial: true,
+				completeWhenDepsComplete: false,
+				errorWhenDepsError: false,
+				terminalAsRealInput: true,
+			},
+		);
+		collect(p);
+		c.down([["ERROR", null]]);
+		expect(waves.at(-1)).toEqual([[]]);
+		expect(terminals.at(-1)).toEqual([null]);
+	});
+
+	it("exposes terminal metadata only for the invocation that observed the terminal", () => {
+		const captures: Array<{ waveData: unknown[][][]; terminal: unknown[] }> = [];
+		const a = node<number>([], null);
+		const b = node<number>([], null);
+		const n = node<number>(
+			[a, b],
+			(ctx) => {
+				captures.push({
+					waveData: cloneWaveData(ctx),
+					terminal: [...ctx.terminal],
+				});
+			},
+			{
+				partial: true,
+				completeWhenDepsComplete: false,
+				terminalAsRealInput: true,
+			},
+		);
+		collect(n);
+
+		a.down([["COMPLETE"]]);
+		expect(captures.at(-1)).toEqual({ waveData: [[], []], terminal: [true, false] });
+
+		b.down([["DATA", 1]]);
+		expect(captures.at(-1)).toEqual({ waveData: [[], [[1]]], terminal: [false, false] });
+	});
+
+	it("rejects boolean ERROR payloads at the protocol boundary and coerces host-source failures", async () => {
+		const s = node<number>([], null);
+		const msgs: Message[] = [];
+		s.subscribe((m) => msgs.push(m));
+		msgs.length = 0;
+		expect(() => s.down([["ERROR", undefined]])).toThrow(/non-SENTINEL/);
+		expect(() => s.down([["ERROR", false]])).toThrow(/non-boolean/);
+		expect(() => s.down([["ERROR", true]])).toThrow(/non-boolean/);
+		expect(() =>
+			s.down([
+				["DATA", 1],
+				["ERROR", false],
+			]),
+		).toThrow(/non-boolean/);
+		expect(msgs).toEqual([]);
+
+		const g = graph();
+		for (const reason of [undefined, false, true]) {
+			const n = g.initNode(fromPromise(Promise.reject(reason)), []);
+			const msgs: Message[] = [];
+			n.subscribe((m) => msgs.push(m));
+			await flush();
+			const last = msgs.at(-1);
+			expect(last?.[0]).toBe("ERROR");
+			expect((last as ["ERROR", unknown])[1]).toBeInstanceOf(Error);
+		}
+	});
+
+	it("lets dynamicNode inspect waveData to stay quiet on an unread-dep-only wave", () => {
+		const a = node<number>([], null, { initial: 1 });
+		const b = node<number>([], null);
+		const captures: unknown[][][][] = [];
+		const d = dynamicNode<number>(
+			[a, b],
+			(ctx) => {
+				captures.push(cloneWaveData(ctx));
+				if (ctx.waveData[1]?.length) return;
+				ctx.down([["DATA", ctx.track?.(0) as number]]);
+			},
+			{ partial: true },
+		);
+		const { msgs } = collect(d);
+		msgs.length = 0;
+
+		b.down([["DATA", 2]]);
+
+		expect(captures.at(-1)).toEqual([[], [[2]]]);
+		expect(types(msgs)).toEqual(["DIRTY", "RESOLVED"]);
+	});
+});
diff --git a/packages/ts/src/__tests__/control.test.ts b/packages/ts/src/__tests__/control.test.ts
new file mode 100644
index 00000000..d37dfae4
--- /dev/null
+++ b/packages/ts/src/__tests__/control.test.ts
@@ -0,0 +1,154 @@
+import { describe, expect, it } from "vitest";
+import type { Ctx, Message } from "../index.js";
+import { depLatest, node } from "../index.js";
+
+function collect(n: { subscribe(s: (m: Message) => void): () => void }) {
+	const msgs: Message[] = [];
+	const unsub = n.subscribe((m) => msgs.push(m));
+	return { msgs, unsub };
+}
+const types = (msgs: Message[]) => msgs.map((m) => m[0]);
+
+describe("PAUSE/RESUME lockset (R-pause-lockset, R-pause-modes default)", () => {
+	it("multi-source lockset: releasing one lock does not resume while another holds (C-5)", () => {
+		const a = node<number>([], null, { initial: 1 });
+		let runs = 0;
+		const d = node<number>([a], (ctx: Ctx) => {
+			runs++;
+			ctx.down([["DATA", (depLatest(ctx, 0) as number) + 1]]);
+		});
+		collect(d);
+		expect(d.cache).toBe(2);
+
+		const LA = Symbol("LA");
+		const LB = Symbol("LB");
+		d.up([["PAUSE", LA]]);
+		d.up([["PAUSE", LA]]); // same-id repeat is idempotent
+		d.up([["PAUSE", LB]]);
+
+		runs = 0;
+		a.down([["DATA", 10]]); // dep wave while paused -> default mode skips fn
+		expect(runs).toBe(0);
+		expect(d.cache).toBe(2); // not recomputed yet
+
+		d.up([["RESUME", LA]]); // LB still held -> stay paused
+		expect(runs).toBe(0);
+		d.up([["RESUME", Symbol("unknown")]]); // unknown id -> no-op
+		expect(runs).toBe(0);
+
+		d.up([["RESUME", LB]]); // final release -> fire once with latest
+		expect(runs).toBe(1);
+		expect(d.cache).toBe(11);
+	});
+
+	it("pausable:false ignores PAUSE/RESUME (timer-source semantics)", () => {
+		const a = node<number>([], null, { initial: 1 });
+		let runs = 0;
+		const d = node<number>(
+			[a],
+			(ctx: Ctx) => {
+				runs++;
+				ctx.down([["DATA", (depLatest(ctx, 0) as number) + 1]]);
+			},
+			{ pausable: false },
+		);
+		collect(d);
+		runs = 0;
+		d.up([["PAUSE", Symbol()]]);
+		a.down([["DATA", 5]]);
+		expect(runs).toBe(1); // not gated
+		expect(d.cache).toBe(6);
+	});
+
+	it("resumeAll buffers a compute DATA without synthesizing a mid-pause RESOLVED (B36)", () => {
+		const a = node<number>([], null, { initial: 1 });
+		const d = node<number>(
+			[a],
+			(ctx: Ctx) => {
+				ctx.down([["DATA", (depLatest(ctx, 0) as number) + 1]]);
+			},
+			{ pausable: "resumeAll" },
+		);
+		const { msgs } = collect(d);
+		expect(d.cache).toBe(2);
+		msgs.length = 0;
+
+		const L = Symbol("L");
+		d.up([["PAUSE", L]]);
+		a.down([["DATA", 10]]);
+
+		expect(d.cache).toBe(2); // DATA is buffered, not applied while paused
+		expect(types(msgs)).toEqual(["DIRTY"]); // no synthetic RESOLVED may pierce the pause
+
+		d.up([["RESUME", L]]);
+		expect(d.cache).toBe(11);
+		// Replaying the buffered DATA emits a fresh DIRTY-before-DATA wave; the important B36
+		// invariant is that no RESOLVED pierced the pause before this replay.
+		expect(types(msgs)).toEqual(["DIRTY", "DIRTY", "DATA"]);
+	});
+});
+
+describe("async pool (R-sync-core async label, R8 late-emit pairing)", () => {
+	it("a late ctx.down from an async fn pairs DIRTY+DATA downstream", () => {
+		const a = node<number>([], null, { initial: 3 });
+		let resolve: (() => void) | null = null;
+		const dbl = node<number>(
+			[a],
+			(ctx: Ctx) => {
+				const v = depLatest(ctx, 0) as number;
+				resolve = () => ctx.down([["DATA", v * 2]]);
+			},
+			{ pool: "async" },
+		);
+		const { msgs } = collect(dbl);
+		// fn ran synchronously (set resolve) but emitted nothing yet.
+		expect(dbl.cache).toBeUndefined();
+		expect(types(msgs)).toEqual(["START"]);
+
+		resolve?.();
+		expect(dbl.cache).toBe(6);
+		expect(types(msgs)).toEqual(["START", "DIRTY", "DATA"]);
+	});
+});
+
+describe("async-result at a paused node (R-async-paused / C-2)", () => {
+	it("buffers the result while paused, replays on final RESUME", () => {
+		const a = node<number>([], null, { initial: 3 });
+		let resolve: (() => void) | null = null;
+		const an = node<number>(
+			[a],
+			(ctx: Ctx) => {
+				const v = depLatest(ctx, 0) as number;
+				resolve = () => ctx.down([["DATA", v * 2]]);
+			},
+			{ pool: "async" },
+		);
+		const { msgs } = collect(an);
+		msgs.length = 0;
+
+		const L = Symbol("L");
+		an.up([["PAUSE", L]]);
+		resolve?.(); // async result arrives while paused -> buffered, not delivered
+		expect(an.cache).toBeUndefined();
+		expect(types(msgs)).toEqual([]);
+
+		an.up([["RESUME", L]]); // final RESUME -> replay buffered result
+		expect(an.cache).toBe(6);
+		expect(types(msgs)).toEqual(["DIRTY", "DATA"]);
+	});
+});
+
+describe("replayBuffer (R-replay-buffer)", () => {
+	it("late subscriber receives the last N DATA after START", () => {
+		const s = node<number>([], null, { replayBuffer: 3 });
+		collect(s);
+		s.down([["DATA", 1]]);
+		s.down([["DATA", 2]]);
+		s.down([["DATA", 3]]);
+		s.down([["DATA", 4]]);
+
+		const { msgs } = collect(s);
+		expect(types(msgs)).toEqual(["START", "DATA", "DATA", "DATA"]);
+		expect(msgs.slice(1).map((m) => m[1])).toEqual([2, 3, 4]);
+	});
+});
diff --git a/packages/ts/src/__tests__/core.test.ts b/packages/ts/src/__tests__/core.test.ts
new file mode 100644
index 00000000..f863941e
--- /dev/null
+++ b/packages/ts/src/__tests__/core.test.ts
@@ -0,0 +1,721 @@
+import { describe, expect, it } from "vitest";
+import type { Ctx, Message } from "../index.js";
+import {
+	batch,
+	Dispatcher,
+	defaultNodeVersionHash,
+	depBatch,
+	depLatest,
+	graph,
+	initNode,
+	node,
+	strictCanonicalJsonBytes,
+	strictJsonCodec,
+} from "../index.js";
+
+function collect(n: { subscribe(s: (m: Message) => void): () => void }) {
+	const msgs: Message[] = [];
+	const unsub = n.subscribe((m) => msgs.push(m));
+	return { msgs, unsub };
+}
+
+const types = (msgs: Message[]) => msgs.map((m) => m[0]);
+const TEST_JSON_DECODER = new TextDecoder();
+const decodeTestJsonBytes = (bytes: Uint8Array) => TEST_JSON_DECODER.decode(bytes);
+const testHash = (bytes: Uint8Array) => `h:${decodeTestJsonBytes(bytes)}`;
+
+describe("state node (manual source)", () => {
+	it("push-on-subscribe delivers START then cached DATA (R-push-subscribe, R-initial)", () => {
+		const s = node<number>([], null, { initial: 5 });
+		const { msgs } = collect(s);
+		expect(msgs).toEqual([["START"], ["DATA", 5]]);
+		expect(s.cache).toBe(5);
+		expect(s.status).toBe("settled");
+	});
+
+	it("uncached subscribe delivers only START", () => {
+		const s = node<number>([], null);
+		const { msgs } = collect(s);
+		expect(msgs).toEqual([["START"]]);
+		expect(s.cache).toBeUndefined();
+		expect(s.status).toBe("sentinel");
+	});
+
+	it("external down emits DIRTY before DATA (R-dirty-before-data, two-phase)", () => {
+		const s = node<number>([], null, { initial: 1 });
+		const { msgs } = collect(s);
+		msgs.length = 0;
+		s.down([["DATA", 2]]);
+		expect(types(msgs)).toEqual(["DIRTY", "DATA"]);
+		expect(msgs[1]).toEqual(["DATA", 2]);
+		expect(s.cache).toBe(2);
+	});
+
+	it("null is a valid DATA value (R-data-payload)", () => {
+		const s = node<number | null>([], null, { initial: null });
+		const { msgs } = collect(s);
+		expect(msgs).toEqual([["START"], ["DATA", null]]);
+		expect(s.cache).toBeNull();
+	});
+});
+
+describe("occurrences stay DATA (R-resolved-undirty / D49, supersedes R-equals)", () => {
+	it("re-emitting the same value yields DATA, not RESOLVED (no equals-substitution)", () => {
+		const s = node<number>([], null, { initial: 5 });
+		const { msgs } = collect(s);
+		msgs.length = 0;
+		s.down([["DATA", 5]]); // same value is still a distinct occurrence
+		expect(types(msgs)).toEqual(["DIRTY", "DATA"]);
+		expect(s.cache).toBe(5);
+	});
+
+	it("a changed value yields DATA", () => {
+		const s = node<number>([], null, { initial: 5 });
+		const { msgs } = collect(s);
+		msgs.length = 0;
+		s.down([["DATA", 6]]);
+		expect(types(msgs)).toEqual(["DIRTY", "DATA"]);
+		expect(s.cache).toBe(6);
+	});
+
+	it("a multi-DATA wave passes every occurrence as DATA", () => {
+		const s = node<number>([], null, { initial: 5 });
+		const { msgs } = collect(s);
+		msgs.length = 0;
+		s.down([
+			["DATA", 5],
+			["DATA", 5],
+		]);
+		expect(types(msgs)).toEqual(["DIRTY", "DATA", "DATA"]);
+	});
+});
+
+describe("compute node (derived)", () => {
+	it("computes from a dep and recomputes on change", () => {
+		const count = node<number>([], null, { initial: 2 });
+		const doubled = node<number>([count], (ctx: Ctx) => {
+			ctx.down([["DATA", (depLatest(ctx, 0) as number) * 2]]);
+		});
+		const { msgs } = collect(doubled);
+		expect(doubled.cache).toBe(4);
+		expect(msgs).toContainEqual(["DATA", 4]);
+
+		msgs.length = 0;
+		count.down([["DATA", 10]]);
+		expect(doubled.cache).toBe(20);
+		expect(types(msgs)).toEqual(["DIRTY", "DATA"]);
+		expect(msgs[1]).toEqual(["DATA", 20]);
+	});
+});
+
+describe("diamond (R-diamond, glitch-free join)", () => {
+	it("join node computes exactly once per upstream change, after both deps settle", () => {
+		let fireCount = 0;
+		const a = node<number>([], null, { initial: 1 });
+		const b = node<number>([a], (ctx: Ctx) =>
+			ctx.down([["DATA", (depLatest(ctx, 0) as number) + 10]]),
+		);
+		const c = node<number>([a], (ctx: Ctx) =>
+			ctx.down([["DATA", (depLatest(ctx, 0) as number) + 20]]),
+		);
+		const d = node<number>([b, c], (ctx: Ctx) => {
+			fireCount++;
+			ctx.down([["DATA", (depLatest(ctx, 0) as number) + (depLatest(ctx, 1) as number)]]);
+		});
+
+		collect(d);
+		expect(d.cache).toBe(32); // (1+10) + (1+20)
+		expect(fireCount).toBe(1); // joined once, not once per leg
+
+		fireCount = 0;
+		a.down([["DATA", 2]]);
+		expect(d.cache).toBe(34); // (2+10) + (2+20)
+		expect(fireCount).toBe(1); // recomputed exactly once
+	});
+});
+
+describe("first-run gate (R-first-run-gate)", () => {
+	it("partial:false holds fn until every dep has settled", () => {
+		let fired = false;
+		const a = node<number>([], null, { initial: 1 });
+		const b = node<number>([], null); // uncached — never settles
+		node<number>([a, b], () => {
+			fired = true;
+		});
+		collect(node<number>([a, b], () => {})); // force-activate a separate gate path
+
+		// Build the gated node explicitly and activate it:
+		fired = false;
+		const gated = node<number>([a, b], () => {
+			fired = true;
+		});
+		gated.subscribe(() => {});
+		expect(fired).toBe(false); // b never delivered real DATA -> gate holds
+		b.down([["DATA", 9]]);
+		expect(fired).toBe(true); // now both settled -> fires once
+	});
+
+	it("partial:true fires without waiting for all deps", () => {
+		let fired = false;
+		const a = node<number>([], null, { initial: 1 });
+		const b = node<number>([], null); // uncached
+		const g = node<number>(
+			[a, b],
+			(ctx: Ctx) => {
+				fired = true;
+				// fn body guards SENTINEL per dep (R-first-run-gate partial contract)
+				const bv = depLatest(ctx, 1);
+				ctx.down([["DATA", bv === undefined ? -1 : (bv as number)]]);
+			},
+			{ partial: true },
+		);
+		g.subscribe(() => {});
+		expect(fired).toBe(true);
+		expect(g.cache).toBe(-1);
+	});
+});
+
+describe("ctx.up direction guard (R-ctx-up)", () => {
+	it("throws on a down-only tier", () => {
+		const a = node<number>([], null, { initial: 1 });
+		const d = node<number>([a], (ctx: Ctx) => ctx.down([["DATA", 1]]));
+		d.subscribe(() => {});
+		expect(() => d.up([["DATA", 5]])).toThrow(/down-only/);
+		expect(() => d.up([["COMPLETE"]])).toThrow(/down-only/);
+		expect(() => d.up([["INVALIDATE"]])).not.toThrow();
+	});
+});
+
+describe("B49 core-slot migration", () => {
+	const coreOf = (n: object) => (n as unknown as Record<string, unknown>)._core;
+	const occupied = (xs: unknown[]) => xs.filter((x) => x !== undefined).length;
+	const slotCount = (core: unknown) =>
+		occupied((core as Record<string, unknown>).slots as unknown[]);
+	const sideTableCounts = (core: unknown) => {
+		const c = core as Record<string, unknown>;
+		return [
+			"depStates",
+			"lifecycles",
+			"values",
+			"waves",
+			"controls",
+			"privateStates",
+			"hooks",
+			"syncCtxs",
+			"versionStates",
+		].map((k) => occupied(c[k] as unknown[]));
+	};
+	const boundaryTaskCount = (core: unknown) => {
+		const boundary = (core as Record<string, unknown>).boundary as {
+			queue: unknown[];
+			head: number;
+		};
+		return boundary.queue.length - boundary.head;
+	};
+
+	it("stores wave bookkeeping behind the Node view, without old direct-field shims", () => {
+		const s = node<number>([], null, { initial: 1, factory: "probe" });
+		const view = s as unknown as Record<string, unknown>;
+
+		expect(Object.hasOwn(view, "_core")).toBe(true);
+		expect(Object.hasOwn(view, "_id")).toBe(true);
+		expect(Object.hasOwn(view, "_slot")).toBe(true);
+		const slot = view._slot as Record<string, unknown>;
+		for (const oldField of [
+			"_deps",
+			"_depBatch",
+			"_depPrev",
+			"_depDirty",
+			"_pending",
+			"_cache",
+			"_status",
+			"_subscribers",
+			"_pauseLockset",
+			"_depRecords",
+		]) {
+			expect(Object.hasOwn(view, oldField), oldField).toBe(false);
+		}
+		for (const sideTableField of [
+			"value",
+			"wave",
+			"control",
+			"subscribers",
+			"activated",
+			"dep",
+			"privateState",
+			"hooks",
+			"syncCtx",
+			"version",
+		]) {
+			expect(Object.hasOwn(slot, sideTableField), sideTableField).toBe(false);
+		}
+		expect(sideTableCounts(coreOf(s))).toEqual([1, 1, 1, 1, 1, 1, 1, 1, 1]);
+
+		expect(s.cache).toBe(1);
+		expect(s.status).toBe("settled");
+		expect(s.factory).toBe("probe");
+	});
+
+	it("uses packed NodeId-indexed arrays for B49 side tables", () => {
+		const g = graph();
+		const a = g.state(1);
+		const b = g.derived([a], (v) => v + 1);
+		const core = coreOf(a) as Record<string, unknown>;
+		const idOf = (n: object) => (n as unknown as Record<string, unknown>)._id as number;
+		const slotOf = (n: object) => (n as unknown as Record<string, unknown>)._slot;
+
+		for (const table of [
+			"slots",
+			"depStates",
+			"lifecycles",
+			"values",
+			"waves",
+			"controls",
+			"privateStates",
+			"hooks",
+			"syncCtxs",
+			"versionStates",
+		]) {
+			expect(Array.isArray(core[table]), table).toBe(true);
+			expect((core[table] as unknown[]).length, table).toBe(2);
+		}
+		expect((core.slots as unknown[])[idOf(a)]).toBe(slotOf(a));
+		expect((core.slots as unknown[])[idOf(b)]).toBe(slotOf(b));
+		expect(slotCount(core)).toBe(2);
+		expect(sideTableCounts(core)).toEqual([2, 2, 2, 2, 2, 2, 2, 2, 2]);
+	});
+
+	it("does not add a parallel frontier or adjacency transport over subscriber propagation", () => {
+		const s = node<number>([], null, { initial: 1 });
+		const coreKeys = Reflect.ownKeys(coreOf(s)).map((key) => String(key));
+		const knownCoreFields = new Set([
+			"nextId",
+			"slots",
+			"values",
+			"waves",
+			"controls",
+			"lifecycles",
+			"depStates",
+			"privateStates",
+			"hooks",
+			"syncCtxs",
+			"versionStates",
+			"boundary",
+		]);
+		const forbiddenTransportName = /adjacency|edge|frontier|queue|work/i;
+
+		for (const key of coreKeys) {
+			if (knownCoreFields.has(key)) continue;
+			expect(
+				key,
+				"new core fields must not smuggle B50-B52 adjacency/frontier/work transport",
+			).not.toMatch(forbiddenTransportName);
+		}
+	});
+
+	it("uses one graph-local core for graph-created nodes while standalone nodes stay isolated", () => {
+		const g1 = graph();
+		const a = g1.state(1);
+		const b = g1.derived([a], (v) => v + 1);
+		const c = g1.initNode(
+			{
+				factory: "probeOp",
+				body: (ctx: Ctx) => ctx.down([["DATA", depLatest(ctx, 0)]]),
+			},
+			[b],
+		);
+
+		const g2 = graph();
+		const otherGraphNode = g2.state(1);
+		const bare = node<number>([], null, { initial: 1 });
+		const bareOp = initNode(
+			{
+				factory: "bareProbe",
+				body: (ctx: Ctx) => ctx.down([["DATA", 1]]),
+			},
+			[],
+		);
+
+		expect(coreOf(a)).toBe(coreOf(b));
+		expect(coreOf(b)).toBe(coreOf(c));
+		expect(coreOf(a)).not.toBe(coreOf(otherGraphNode));
+		expect(coreOf(a)).not.toBe(coreOf(bare));
+		expect(coreOf(a)).not.toBe(coreOf(bareOp));
+
+		const seen: number[] = [];
+		c.subscribe((msg) => {
+			if (msg[0] === "DATA") seen.push(msg[1] as number);
+		});
+		a.set(2);
+		expect(seen.at(-1)).toBe(3);
+	});
+
+	it("does not retain a failed cross-graph graph-node construction in the target core", () => {
+		const g1 = graph();
+		const anchor = g1.state(1);
+		const before = slotCount(coreOf(anchor));
+		const foreign = graph().state(2);
+
+		expect(() => g1.derived([foreign], (v) => v)).toThrow(/different graph/);
+		expect(slotCount(coreOf(anchor))).toBe(before);
+	});
+
+	it("keeps the graph core hook one-shot when dispatcher registration constructs another node", () => {
+		let nested: object | undefined;
+		class NestedDispatcher extends Dispatcher {
+			override register(fn: (ctx: Ctx) => void, pool?: "sync" | "async" | number) {
+				nested ??= node<number>([], null, { initial: 7 });
+				return pool === undefined ? super.register(fn) : super.register(fn, pool);
+			}
+		}
+
+		const g = graph({ dispatcher: new NestedDispatcher() });
+		const src = g.state(1);
+		const d = g.derived([src], (v) => v + 1);
+
+		expect(nested).toBeDefined();
+		expect(coreOf(d)).toBe(coreOf(src));
+		expect(coreOf(nested as object)).not.toBe(coreOf(src));
+	});
+
+	it("rejects public rewire from a graph-owned node to a different graph's node", () => {
+		const g1 = graph();
+		const a = g1.state(1);
+		const d = g1.derived([a], (v) => v + 1);
+		const foreign = graph().state(2);
+
+		expect(() =>
+			d.subscribeDep(foreign, (ctx: Ctx) => ctx.down([["DATA", depLatest(ctx, 0)]])),
+		).toThrow(/different graph/);
+		expect(d.deps).toEqual([a]);
+	});
+
+	it("stores deferred-boundary work on the owning core and drains it at the wave boundary", () => {
+		const g = graph();
+		const trigger = g.state(0);
+		const inner = node<number>([], (ctx) => ctx.down([["DATA", 7]]));
+		let queuedInsideRun = -1;
+		const op = g.node<number>(
+			[trigger],
+			function opFn(ctx) {
+				if (depLatest(ctx, 0) === 1) {
+					ctx.rewireNext.subscribeDep(inner, opFn);
+					queuedInsideRun = boundaryTaskCount(coreOf(op));
+				}
+			},
+			{ completeWhenDepsComplete: false, terminalAsRealInput: true },
+		);
+		op.subscribe(() => {});
+		trigger.set(1);
+
+		expect(queuedInsideRun).toBe(1);
+		expect(boundaryTaskCount(coreOf(op))).toBe(0);
+		expect(op.deps).toContain(inner);
+		expect(inner.cache).toBe(7);
+	});
+
+	it("preserves enqueue FIFO when deferred tasks span multiple cores", () => {
+		const order: string[] = [];
+		const sourceA = node<number>([], null);
+		const sourceB = node<number>([], null);
+		const innerA1 = node<number>([], (ctx) => {
+			order.push("A1");
+			ctx.down([["DATA", 1]]);
+		});
+		const innerA2 = node<number>([], (ctx) => {
+			order.push("A2");
+			ctx.down([["DATA", 2]]);
+		});
+		const innerB1 = node<number>([], (ctx) => {
+			order.push("B1");
+			ctx.down([["DATA", 1]]);
+		});
+		const opA = node<number>(
+			[sourceA],
+			function opAFn(ctx) {
+				if (depBatch(ctx, 0)) ctx.rewireNext.subscribeDep(innerA1, opAFn);
+				if (depBatch(ctx, 1)) ctx.rewireNext.subscribeDep(innerA2, opAFn);
+			},
+			{ completeWhenDepsComplete: false, terminalAsRealInput: true },
+		);
+		const opB = node<number>([sourceB], function opBFn(ctx) {
+			if (depBatch(ctx, 0)) ctx.rewireNext.subscribeDep(innerB1, opBFn);
+		});
+		opA.subscribe(() => {});
+		opB.subscribe(() => {});
+
+		batch(() => {
+			sourceA.down([["DATA", 1]]);
+			sourceB.down([["DATA", 1]]);
+		});
+
+		expect(order).toEqual(["A1", "B1", "A2"]);
+	});
+});
+
+describe("D109 node runtime versioning", () => {
+	it("defaults free-standing nodes to nodev0 and advances only on DATA", () => {
+		const s = node<number>([], null, { initial: 1 });
+		expect(s.version).toEqual({ level: 0, counter: 0 });
+
+		s.down([["RESOLVED"]]);
+		expect(s.version).toEqual({ level: 0, counter: 0 });
+
+		s.down([["DATA", 2]]);
+		expect(s.version).toEqual({ level: 0, counter: 1 });
+
+		s.down([
+			["DATA", 3],
+			["DATA", 4],
+		]);
+		expect(s.version).toEqual({ level: 0, counter: 3 });
+
+		s.down([["INVALIDATE"]]);
+		expect(s.version).toEqual({ level: 0, counter: 3 });
+
+		s.down([["COMPLETE"]]);
+		expect(s.version).toEqual({ level: 0, counter: 3 });
+
+		const errored = node<number>([], null, { initial: 1 });
+		errored.down([["ERROR", "boom"]]);
+		expect(errored.version).toEqual({ level: 0, counter: 0 });
+	});
+
+	it("supports graph default V1, per-node overrides, and versioning:false absence", () => {
+		const hash = testHash;
+		const g = graph({ versioning: { level: 1, hash } });
+		const inherited = g.state({ n: 1 }, { name: "inherited" });
+		const overridden = g.state(1, { name: "overridden", versioning: 0 });
+		const disabled = g.state(1, { name: "disabled", versioning: false });
+
+		expect(inherited.version).toEqual({
+			level: 1,
+			counter: 0,
+			cid: 'h:{"n":1}',
+			prev: null,
+		});
+		inherited.set({ n: 2 });
+		expect(inherited.version).toEqual({
+			level: 1,
+			counter: 1,
+			cid: 'h:{"n":2}',
+			prev: 'h:{"n":1}',
+		});
+		expect(overridden.version).toEqual({ level: 0, counter: 0 });
+		expect(disabled.version).toBeUndefined();
+
+		const byId = Object.fromEntries(g.describe().nodes.map((n) => [n.id, n]));
+		expect(byId.inherited?.version).toEqual(inherited.version);
+		expect(byId.overridden?.version).toEqual({ level: 0, counter: 0 });
+		expect(byId.disabled?.version).toBeUndefined();
+	});
+
+	it("keeps returned version objects immutable snapshots", () => {
+		const s = node<number>([], null, { initial: 1 });
+		const v = s.version as { counter: number };
+		expect(Object.isFrozen(v)).toBe(true);
+		expect(() => {
+			v.counter = 99;
+		}).toThrow();
+		expect(s.version).toEqual({ level: 0, counter: 0 });
+	});
+
+	it("uses the default V1 hash over stable JSON-compatible data", () => {
+		const s = node<{ b: number; a: number }>([], null, {
+			initial: { b: 2, a: 1 },
+			versioning: 1,
+		});
+		expect(s.version).toEqual({
+			level: 1,
+			counter: 0,
+			cid: defaultNodeVersionHash(strictCanonicalJsonBytes({ a: 1, b: 2 })),
+			prev: null,
+		});
+		expect(defaultNodeVersionHash(strictCanonicalJsonBytes({ b: 2, a: 1 }))).toBe(
+			defaultNodeVersionHash(strictJsonCodec.encode({ a: 1, b: 2 })),
+		);
+	});
+
+	it("passes strict canonical JSON UTF-8 bytes to custom V1 hash callbacks (D112)", () => {
+		const calls: Uint8Array[] = [];
+		const hash = (bytes: Uint8Array) => {
+			expect(bytes).toBeInstanceOf(Uint8Array);
+			calls.push(Uint8Array.from(bytes));
+			return `bytes:${decodeTestJsonBytes(bytes)}`;
+		};
+		const s = node<Record<string, number>>([], null, {
+			initial: { b: 2, a: 1 },
+			versioning: { level: 1, hash },
+		});
+
+		expect(calls.map(decodeTestJsonBytes)).toEqual(['{"a":1,"b":2}']);
+		expect(s.version).toEqual({
+			level: 1,
+			counter: 0,
+			cid: 'bytes:{"a":1,"b":2}',
+			prev: null,
+		});
+	});
+
+	it("uses equivalent canonical bytes for V1 payloads with different key insertion order (D112)", () => {
+		const calls: string[] = [];
+		const hash = (bytes: Uint8Array) => {
+			const canonical = decodeTestJsonBytes(bytes);
+			calls.push(canonical);
+			return `h:${canonical}`;
+		};
+		const s = node<Record<string, number>>([], null, {
+			initial: JSON.parse('{"b":2,"a":1}') as Record<string, number>,
+			versioning: { level: 1, hash },
+		});
+		const initialCid = s.version?.level === 1 ? s.version.cid : undefined;
+
+		s.down([["DATA", JSON.parse('{"a":1,"b":2}') as Record<string, number>]]);
+
+		expect(calls).toEqual(['{"a":1,"b":2}', '{"a":1,"b":2}']);
+		expect(s.version).toEqual({
+			level: 1,
+			counter: 1,
+			cid: initialCid,
+			prev: initialCid,
+		});
+	});
+
+	it("V1 rejects non-strict-JSON DATA before mutating cache or version", () => {
+		const s = node<number | bigint>([], null, { initial: 1, versioning: 1 });
+		const downstream = node<number | bigint>([s], (ctx) => {
+			ctx.down([["DATA", depLatest(ctx, 0)]]);
+		});
+		const { msgs } = collect(s);
+		const downstreamMsgs = collect(downstream).msgs;
+		msgs.length = 0;
+		downstreamMsgs.length = 0;
+		const before = s.version;
+		expect(() => s.down([["DATA", 2n]])).toThrow(/not JSON-encodable/);
+		expect(s.version).toEqual(before);
+		expect(s.cache).toBe(1);
+		expect(s.status).toBe("settled");
+		expect(msgs).toEqual([]);
+		expect(downstreamMsgs).toEqual([]);
+
+		s.down([["DATA", 2]]);
+		expect(types(msgs)).toEqual(["DIRTY", "DATA"]);
+		expect(types(downstreamMsgs)).toEqual(["DIRTY", "DATA"]);
+		expect(s.version).toMatchObject({ level: 1, counter: 1 });
+		expect(s.cache).toBe(2);
+
+		const customHash = (bytes: Uint8Array) => `custom:${decodeTestJsonBytes(bytes)}`;
+		const custom = node<unknown>([], null, {
+			initial: 1,
+			versioning: { level: 1, hash: customHash },
+		});
+		const customBefore = custom.version;
+		expect(() => custom.down([["DATA", new Date(0)]])).toThrow(/non-plain object/);
+		expect(custom.version).toEqual(customBefore);
+		expect(custom.cache).toBe(1);
+
+		const terminal = node<unknown>([], null, { initial: 1, versioning: 1 });
+		terminal.down([["COMPLETE"]]);
+		const terminalBefore = terminal.version;
+		expect(() => terminal.down([["DATA", 2n]])).toThrow(/not JSON-encodable/);
+		expect(terminal.version).toEqual(terminalBefore);
+		expect(terminal.cache).toBe(1);
+		expect(terminal.status).toBe("completed");
+	});
+
+	it("V1 rejects deferred batch/pause DATA before DIRTY, buffering, cache, or version changes", () => {
+		const batched = node<unknown>([], null, { initial: 1, versioning: 1 });
+		const batchedMsgs = collect(batched).msgs;
+		batchedMsgs.length = 0;
+		const batchedBefore = batched.version;
+
+		expect(() => batch(() => batched.down([["DATA", 2n]]))).toThrow(/not JSON-encodable/);
+		expect(batchedMsgs).toEqual([]);
+		expect(batched.version).toEqual(batchedBefore);
+		expect(batched.cache).toBe(1);
+		expect(batched.status).toBe("settled");
+
+		const batchedSnapshot = node<Record<string, unknown>>([], null, {
+			initial: { a: 0 },
+			versioning: { level: 1, hash: testHash },
+		});
+		const batchedSnapshotMsgs = collect(batchedSnapshot).msgs;
+		batchedSnapshotMsgs.length = 0;
+		const batchedPayload: Record<string, unknown> = { a: 1 };
+		batch(() => {
+			batchedSnapshot.down([["DATA", batchedPayload]]);
+			batchedPayload.a = 2;
+			batchedPayload.bad = 2n;
+		});
+		expect(types(batchedSnapshotMsgs)).toEqual(["DIRTY", "DATA"]);
+		expect(batchedSnapshotMsgs[1]).toEqual(["DATA", { a: 1 }]);
+		expect(batchedSnapshot.cache).toEqual({ a: 1 });
+		expect(batchedSnapshot.version).toMatchObject({
+			level: 1,
+			counter: 1,
+			cid: 'h:{"a":1}',
+		});
+
+		const paused = node<Record<string, unknown>>([], null, {
+			initial: { a: 0 },
+			versioning: { level: 1, hash: testHash },
+			pausable: "resumeAll",
+		});
+		const pausedMsgs = collect(paused).msgs;
+		pausedMsgs.length = 0;
+		const pausedBefore = paused.version;
+		const lock = Symbol("lock");
+		paused.up([["PAUSE", lock]]);
+		pausedMsgs.length = 0;
+
+		expect(() => paused.down([["DATA", new Date(0)]])).toThrow(/non-plain object/);
+		expect(pausedMsgs).toEqual([]);
+		expect(paused.version).toEqual(pausedBefore);
+		expect(paused.cache).toEqual({ a: 0 });
+		expect(paused.status).toBe("settled");
+
+		const pausedPayload: Record<string, unknown> = { a: 1 };
+		paused.down([["DATA", pausedPayload]]);
+		expect(pausedMsgs).toEqual([]);
+		pausedPayload.a = 2;
+		pausedPayload.bad = 2n;
+		expect(paused.cache).toEqual({ a: 0 });
+		paused.up([["RESUME", lock]]);
+		expect(types(pausedMsgs)).toEqual(["DIRTY", "DATA"]);
+		expect(paused.version).toMatchObject({ level: 1, counter: 1 });
+		expect(paused.cache).toEqual({ a: 1 });
+		expect(pausedMsgs[1]).toEqual(["DATA", { a: 1 }]);
+	});
+
+	it("does not apply the D112 strict JSON preflight to V0 or versioning:false", () => {
+		const v0 = node<unknown>([], null, { initial: 1, versioning: 0 });
+		const v0Msgs = collect(v0).msgs;
+		v0Msgs.length = 0;
+		v0.down([["DATA", 2n]]);
+		expect(v0.version).toEqual({ level: 0, counter: 1 });
+		expect(v0.cache).toBe(2n);
+		expect(types(v0Msgs)).toEqual(["DIRTY", "DATA"]);
+
+		const disabled = node<unknown>([], null, { initial: 1, versioning: false });
+		const disabledMsgs = collect(disabled).msgs;
+		disabledMsgs.length = 0;
+		disabled.down([["DATA", new Date(0)]]);
+		expect(disabled.version).toBeUndefined();
+		expect(disabled.cache).toEqual(new Date(0));
+		expect(types(disabledMsgs)).toEqual(["DIRTY", "DATA"]);
+	});
+
+	it("V1 rejects non-strict-JSON initial values at construction", () => {
+		expect(() => node<unknown>([], null, { initial: 2n, versioning: 1 })).toThrow(
+			/not JSON-encodable/,
+		);
+		const g = graph({ versioning: 1 });
+		expect(() => g.state(new Date(0), { name: "bad-date" })).toThrow(/non-plain object/);
+	});
+
+	it("fails honestly for unapproved V2/V3 levels", () => {
+		expect(() => node([], null, { versioning: { level: 2 } as unknown as 1 })).toThrow(/V2\/V3/);
+		const g = graph({ versioning: { level: 3 } as unknown as 1 });
+		expect(() => g.state(1)).toThrow(/V2\/V3/);
+	});
+});
diff --git a/packages/ts/src/__tests__/cqrs-work-queue-recipes.test.ts b/packages/ts/src/__tests__/cqrs-work-queue-recipes.test.ts
new file mode 100644
index 00000000..3a32a309
--- /dev/null
+++ b/packages/ts/src/__tests__/cqrs-work-queue-recipes.test.ts
@@ -0,0 +1,289 @@
+import { describe, expect, it } from "vitest";
+import type { CqrsStatus } from "../cqrs/index.js";
+import {
+	type CqrsQueuedCommandPayload,
+	type CqrsWorkQueueAttempt,
+	cqrsWorkQueueDispositionCommand,
+	cqrsWorkQueueRecipe,
+} from "../cqrs/work-queue.js";
+import { graph } from "../graph/graph.js";
+import type { WorkQueueRecord } from "../work-queue/index.js";
+
+describe("CQRS workQueue recipe (D350/D352/D353)", () => {
+	it("maps a queue claim to a CQRS command fact, then accepted status to queue complete", () => {
+		const g = graph();
+		const records = g.node<WorkQueueRecord<CqrsQueuedCommandPayload>>([], null, {
+			name: "queueRecords",
+		});
+		const status = g.node<CqrsStatus>([], null, { name: "cqrsStatus" });
+		const recipe = cqrsWorkQueueRecipe(g, { records, status, workerId: "worker-1" });
+		const dispatches = collectData(recipe.dispatches);
+		const commands = collectData(recipe.commands);
+
+		records.down([
+			["DATA", admittedRecord()],
+			[
+				"DATA",
+				{
+					kind: "work-claimed",
+					recordSeq: 2,
+					queueId: "q",
+					workId: "work-1",
+					leaseId: "lease-1",
+					attempt: 1,
+					workerId: "worker-1",
+					claimedAtMs: 110,
+					leaseExpiresAtMs: 210,
+					recordedAtMs: 110,
+				} satisfies WorkQueueRecord<CqrsQueuedCommandPayload>,
+			],
+		]);
+		status.down([["DATA", statusFact("accepted", 2)]]);
+
+		expect(dispatches.at(-1)).toEqual(payload().command);
+		expect(commands.at(-1)).toEqual(
+			expect.objectContaining({
+				kind: "complete",
+				workId: "work-1",
+				leaseId: "lease-1",
+				result: expect.objectContaining({
+					kind: "cqrs-accepted-result",
+					eventCount: 2,
+				}),
+			}),
+		);
+	});
+
+	it("keeps the D352 outcome matrix on queue disposition helpers", () => {
+		const attempt = attemptFact();
+
+		expect(
+			cqrsWorkQueueDispositionCommand(attempt, {
+				kind: "accepted",
+				status: statusFact("accepted", 0),
+			}),
+		).toEqual(
+			expect.objectContaining({
+				kind: "complete",
+				result: expect.objectContaining({ kind: "cqrs-accepted-result", eventCount: 0 }),
+			}),
+		);
+		expect(
+			cqrsWorkQueueDispositionCommand(attempt, {
+				kind: "rejected",
+				status: statusFact("rejected", 0, "unknown-command"),
+			}),
+		).toEqual(
+			expect.objectContaining({
+				kind: "complete",
+				result: expect.objectContaining({
+					kind: "cqrs-rejected-result",
+					errorCode: "unknown-command",
+				}),
+			}),
+		);
+		expect(
+			cqrsWorkQueueDispositionCommand(attempt, {
+				kind: "rejected",
+				status: statusFact("rejected", 0, "handler-threw"),
+			}),
+		).toEqual(expect.objectContaining({ kind: "fail", retryable: true }));
+		expect(
+			cqrsWorkQueueDispositionCommand(attempt, {
+				kind: "rejected",
+				status: statusFact("rejected", 0, "clock-threw"),
+			}),
+		).toEqual(expect.objectContaining({ kind: "fail", retryable: true }));
+		expect(
+			cqrsWorkQueueDispositionCommand(attempt, { kind: "release", reason: "shutdown" }),
+		).toEqual(expect.objectContaining({ kind: "release", reason: "shutdown" }));
+	});
+
+	it("allows a retry claim for the same CQRS command id to produce its own disposition", () => {
+		const g = graph();
+		const records = g.node<WorkQueueRecord<CqrsQueuedCommandPayload>>([], null, {
+			name: "queueRecords",
+		});
+		const status = g.node<CqrsStatus>([], null, { name: "cqrsStatus" });
+		const recipe = cqrsWorkQueueRecipe(g, { records, status });
+		const commands = collectData(recipe.commands);
+
+		records.down([
+			["DATA", admittedRecord()],
+			["DATA", claimedRecord(2, "lease-1", 1)],
+		]);
+		status.down([["DATA", statusFact("rejected", 0, "handler-threw")]]);
+		records.down([["DATA", claimedRecord(4, "lease-2", 2)]]);
+		status.down([["DATA", statusFact("accepted", 1)]]);
+
+		expect(commands).toEqual([
+			expect.objectContaining({ kind: "fail", leaseId: "lease-1", retryable: true }),
+			expect.objectContaining({ kind: "complete", leaseId: "lease-2" }),
+		]);
+		expect(commands[0]?.commandId).not.toEqual(commands[1]?.commandId);
+	});
+
+	it("does not use a stale pre-claim CQRS status as a later queue disposition", () => {
+		const g = graph();
+		const records = g.node<WorkQueueRecord<CqrsQueuedCommandPayload>>([], null, {
+			name: "queueRecords",
+		});
+		const status = g.node<CqrsStatus>([], null, { name: "cqrsStatus" });
+		const recipe = cqrsWorkQueueRecipe(g, { records, status });
+		const commands = collectData(recipe.commands);
+		const issues = collectData(recipe.issues);
+
+		status.down([["DATA", statusFact("accepted", 1)]]);
+		records.down([
+			["DATA", admittedRecord()],
+			["DATA", claimedRecord(2, "lease-1", 1)],
+		]);
+
+		expect(commands).toEqual([]);
+		expect(issues.at(-1)).toEqual(
+			expect.objectContaining({ code: "cqrs-status-without-active-queue-claim" }),
+		);
+
+		status.down([["DATA", statusFact("accepted", 1)]]);
+
+		expect(commands.at(-1)).toEqual(
+			expect.objectContaining({ kind: "complete", workId: "work-1", leaseId: "lease-1" }),
+		);
+	});
+
+	it("uses lease-scoped disposition command ids for repeated retryable failures", () => {
+		const g = graph();
+		const records = g.node<WorkQueueRecord<CqrsQueuedCommandPayload>>([], null, {
+			name: "queueRecords",
+		});
+		const status = g.node<CqrsStatus>([], null, { name: "cqrsStatus" });
+		const recipe = cqrsWorkQueueRecipe(g, { records, status });
+		const commands = collectData(recipe.commands);
+
+		records.down([
+			["DATA", admittedRecord()],
+			["DATA", claimedRecord(2, "lease-1", 1)],
+		]);
+		status.down([["DATA", statusFact("rejected", 0, "handler-threw")]]);
+		records.down([["DATA", claimedRecord(4, "lease-2", 2)]]);
+		status.down([["DATA", statusFact("rejected", 0, "handler-threw")]]);
+
+		expect(commands).toEqual([
+			expect.objectContaining({
+				kind: "fail",
+				leaseId: "lease-1",
+				commandId: "cmd-1:work-1:lease-1:1:cqrs-queue-fail",
+			}),
+			expect.objectContaining({
+				kind: "fail",
+				leaseId: "lease-2",
+				commandId: "cmd-1:work-1:lease-2:2:cqrs-queue-fail",
+			}),
+		]);
+	});
+
+	it("releases a claim when dispatch was not attempted because payload is missing", () => {
+		const g = graph();
+		const records = g.node<WorkQueueRecord<CqrsQueuedCommandPayload>>([], null, {
+			name: "queueRecords",
+		});
+		const status = g.node<CqrsStatus>([], null, { name: "cqrsStatus" });
+		const recipe = cqrsWorkQueueRecipe(g, { records, status });
+		const commands = collectData(recipe.commands);
+		const issues = collectData(recipe.issues);
+
+		records.down([["DATA", claimedRecord(1, "lease-missing", 1)]]);
+
+		expect(issues.at(-1)).toEqual(expect.objectContaining({ code: "cqrs-claim-without-payload" }));
+		expect(commands.at(-1)).toEqual(
+			expect.objectContaining({
+				kind: "release",
+				workId: "work-1",
+				leaseId: "lease-missing",
+				reason: "cqrs-claim-without-payload",
+			}),
+		);
+	});
+});
+
+function collectData<T>(node: {
+	subscribe(sink: (msg: readonly [string, unknown?]) => void): unknown;
+}): T[] {
+	const out: T[] = [];
+	node.subscribe((msg) => {
+		if (msg[0] === "DATA") out.push(msg[1] as T);
+	});
+	return out;
+}
+
+function payload(): CqrsQueuedCommandPayload {
+	return {
+		kind: "cqrs-queued-command",
+		command: { id: "cmd-1", type: "create", payload: { title: "one" } },
+		sourceRefs: ["message:1"],
+	};
+}
+
+function admittedRecord(): WorkQueueRecord<CqrsQueuedCommandPayload> {
+	return {
+		kind: "work-admitted",
+		recordSeq: 1,
+		queueId: "q",
+		workId: "work-1",
+		commandId: "admit-1",
+		recordedAtMs: 100,
+		payload: payload(),
+		messageBus: { topic: "work", seq: 1, subscriptionId: "sub" },
+	};
+}
+
+function claimedRecord(
+	recordSeq: number,
+	leaseId: string,
+	attempt: number,
+): WorkQueueRecord<CqrsQueuedCommandPayload> {
+	return {
+		kind: "work-claimed",
+		recordSeq,
+		queueId: "q",
+		workId: "work-1",
+		leaseId,
+		attempt,
+		workerId: "worker-1",
+		claimedAtMs: 110 + recordSeq,
+		leaseExpiresAtMs: 210 + recordSeq,
+		recordedAtMs: 110 + recordSeq,
+	};
+}
+
+function attemptFact(): CqrsWorkQueueAttempt {
+	return {
+		kind: "cqrs-work-queue-attempt",
+		workId: "work-1",
+		leaseId: "lease-1",
+		queueAttempt: 1,
+		workerId: "worker-1",
+		command: payload().command,
+		payload: payload(),
+	};
+}
+
+function statusFact(
+	state: CqrsStatus["state"],
+	eventCount: number,
+	errorCode?: CqrsStatus["errorCode"],
+): CqrsStatus {
+	return {
+		state,
+		commandId: "cmd-1",
+		commandType: "create",
+		eventCount,
+		errorCode,
+		cursor: {
+			eventSeq: eventCount,
+			commandCount: 1,
+			errorCount: state === "rejected" ? 1 : 0,
+			auditSeq: 1,
+		},
+	};
+}
diff --git a/packages/ts/src/__tests__/cqrs.test.ts b/packages/ts/src/__tests__/cqrs.test.ts
new file mode 100644
index 00000000..5863c0d0
--- /dev/null
+++ b/packages/ts/src/__tests__/cqrs.test.ts
@@ -0,0 +1,635 @@
+import { describe, expect, it } from "vitest";
+import { cqrs, cqrsCommandHandler, cqrsProjection } from "../cqrs/index.js";
+import { graph } from "../graph/graph.js";
+
+describe("CQRS application infrastructure (B63 / D125 / D129)", () => {
+	it("dispatches commands as graph-owned command facts and emits audit/status facts", () => {
+		const g = graph();
+		const app = cqrs(g, {
+			name: "orders",
+			events: ["OrderPlaced"],
+			now: () => 10,
+			handlers: [
+				cqrsCommandHandler("PlaceOrder", (command) => [
+					{ type: "OrderPlaced", payload: command.payload },
+				]),
+			],
+		});
+		const commands: unknown[] = [];
+		const audit: unknown[] = [];
+		const status: unknown[] = [];
+		app.command.subscribe((msg) => commands.push(msg));
+		app.audit.subscribe((msg) => audit.push(msg));
+		app.status.subscribe((msg) => status.push(msg));
+
+		app.dispatch({ id: "cmd-1", type: "PlaceOrder", payload: { id: "o1" } });
+
+		expect(commands.at(-1)).toEqual([
+			"DATA",
+			{ id: "cmd-1", type: "PlaceOrder", payload: { id: "o1" } },
+		]);
+		expect(audit.at(-1)).toEqual([
+			"DATA",
+			{
+				seq: 1,
+				commandId: "cmd-1",
+				commandType: "PlaceOrder",
+				outcome: "success",
+				eventIds: ["cmd-1:1"],
+				eventTypes: ["OrderPlaced"],
+				cursor: { eventSeq: 1, commandCount: 1, errorCount: 0, auditSeq: 1 },
+			},
+		]);
+		expect(status.at(-1)).toEqual([
+			"DATA",
+			{
+				state: "accepted",
+				commandId: "cmd-1",
+				commandType: "PlaceOrder",
+				eventCount: 1,
+				cursor: { eventSeq: 1, commandCount: 1, errorCount: 0, auditSeq: 0 },
+			},
+		]);
+	});
+
+	it("keeps public fact nodes active before external observers subscribe", () => {
+		const g = graph();
+		const app = cqrs(g, {
+			name: "orders",
+			events: ["OrderPlaced"],
+			now: () => 15,
+			handlers: [
+				cqrsCommandHandler("PlaceOrder", (command) => [
+					{ type: "OrderPlaced", payload: command.payload },
+				]),
+			],
+		});
+
+		app.dispatch({ id: "cmd-1", type: "PlaceOrder", payload: { id: "o1" } });
+
+		const events: unknown[] = [];
+		const audit: unknown[] = [];
+		const status: unknown[] = [];
+		const cursor: unknown[] = [];
+		app.events.subscribe((msg) => events.push(msg));
+		app.audit.subscribe((msg) => audit.push(msg));
+		app.status.subscribe((msg) => status.push(msg));
+		app.cursor.subscribe((msg) => cursor.push(msg));
+
+		expect(events.at(-1)).toEqual([
+			"DATA",
+			expect.objectContaining({
+				id: "cmd-1:1",
+				type: "OrderPlaced",
+				commandId: "cmd-1",
+				timestampMs: 15,
+			}),
+		]);
+		expect(audit.at(-1)).toEqual([
+			"DATA",
+			expect.objectContaining({ commandId: "cmd-1", outcome: "success" }),
+		]);
+		expect(status.at(-1)).toEqual([
+			"DATA",
+			expect.objectContaining({ commandId: "cmd-1", state: "accepted" }),
+		]);
+		expect(cursor.at(-1)).toEqual([
+			"DATA",
+			{ eventSeq: 1, commandCount: 1, errorCount: 0, auditSeq: 1 },
+		]);
+	});
+
+	it("orders handler-emitted event facts", () => {
+		const g = graph();
+		const app = cqrs(g, {
+			name: "orders",
+			events: ["OrderPlaced", "OrderConfirmed"],
+			now: () => 20,
+			handlers: [
+				cqrsCommandHandler("PlaceOrder", (command) => [
+					{ type: "OrderPlaced", payload: command.payload },
+					{ type: "OrderConfirmed", payload: { id: (command.payload as { id: string }).id } },
+				]),
+			],
+		});
+		const events: unknown[] = [];
+		const cursor: unknown[] = [];
+		app.events.subscribe((msg) => events.push(msg));
+		app.cursor.subscribe((msg) => cursor.push(msg));
+
+		app.dispatch({ id: "cmd-1", type: "PlaceOrder", payload: { id: "o1" } });
+
+		expect(events.filter((msg) => (msg as unknown[])[0] === "DATA")).toEqual([
+			[
+				"DATA",
+				{
+					id: "cmd-1:1",
+					type: "OrderPlaced",
+					seq: 1,
+					cursor: 1,
+					runtimeCursor: { eventSeq: 1, commandCount: 1, errorCount: 0, auditSeq: 0 },
+					commandId: "cmd-1",
+					commandType: "PlaceOrder",
+					payload: { id: "o1" },
+					timestampMs: 20,
+				},
+			],
+			[
+				"DATA",
+				{
+					id: "cmd-1:2",
+					type: "OrderConfirmed",
+					seq: 2,
+					cursor: 2,
+					runtimeCursor: { eventSeq: 2, commandCount: 1, errorCount: 0, auditSeq: 0 },
+					commandId: "cmd-1",
+					commandType: "PlaceOrder",
+					payload: { id: "o1" },
+					timestampMs: 20,
+				},
+			],
+		]);
+		expect(cursor.at(-1)).toEqual([
+			"DATA",
+			{ eventSeq: 2, commandCount: 1, errorCount: 0, auditSeq: 1 },
+		]);
+	});
+
+	it("routes duplicate and unknown command/event cases to graph-visible errors", () => {
+		const g = graph();
+		let duplicateEvent = false;
+		const app = cqrs(g, {
+			name: "orders",
+			events: ["OrderPlaced"],
+			now: () => 30,
+			handlers: [
+				cqrsCommandHandler("PlaceOrder", () => [
+					{
+						id: duplicateEvent ? "event-1" : undefined,
+						type: "OrderPlaced",
+						payload: { ok: true },
+					},
+				]),
+				cqrsCommandHandler("EmitUnknown", () => [{ type: "OrderRouted", payload: {} }]),
+			],
+		});
+		const errors: unknown[] = [];
+		const events: unknown[] = [];
+		app.errors.subscribe((msg) => errors.push(msg));
+		app.events.subscribe((msg) => events.push(msg));
+
+		app.dispatch({ id: "cmd-1", type: "Missing", payload: {} });
+		app.dispatch({ id: "cmd-1", type: "Missing", payload: {} });
+		app.dispatch({ id: "cmd-2", type: "EmitUnknown", payload: {} });
+		duplicateEvent = true;
+		app.dispatch({ id: "cmd-3", type: "PlaceOrder", payload: {} });
+		app.dispatch({ id: "cmd-4", type: "PlaceOrder", payload: {} });
+		app.dispatch({ id: "cmd-3", type: "PlaceOrder", payload: {} });
+
+		expect(errors).toContainEqual([
+			"DATA",
+			expect.objectContaining({ code: "unknown-command", commandId: "cmd-1" }),
+		]);
+		expect(errors).toContainEqual([
+			"DATA",
+			expect.objectContaining({ code: "duplicate-command", commandId: "cmd-1" }),
+		]);
+		expect(errors).toContainEqual([
+			"DATA",
+			expect.objectContaining({ code: "unknown-event", commandId: "cmd-2" }),
+		]);
+		expect(errors).toContainEqual([
+			"DATA",
+			expect.objectContaining({ code: "duplicate-event", commandId: "cmd-4" }),
+		]);
+		expect(errors).toContainEqual([
+			"DATA",
+			expect.objectContaining({ code: "duplicate-command", commandId: "cmd-3" }),
+		]);
+		expect(events.filter((msg) => (msg as unknown[])[0] === "DATA")).toHaveLength(1);
+	});
+
+	it("bounds command and event dedupe windows explicitly (D142)", () => {
+		const g = graph();
+		const app = cqrs(g, {
+			name: "orders",
+			events: ["OrderPlaced"],
+			dedupe: {
+				commands: { maxEntries: 1 },
+				events: { maxEntries: 1 },
+			},
+			handlers: [
+				cqrsCommandHandler("PlaceOrder", (command) => [
+					{
+						id: (command.payload as { eventId: string }).eventId,
+						type: "OrderPlaced",
+						payload: command.payload,
+					},
+				]),
+			],
+		});
+		const events: unknown[] = [];
+		const errors: unknown[] = [];
+		const cursor: unknown[] = [];
+		app.events.subscribe((msg) => events.push(msg));
+		app.errors.subscribe((msg) => errors.push(msg));
+		app.cursor.subscribe((msg) => cursor.push(msg));
+
+		app.dispatch({ id: "cmd-1", type: "PlaceOrder", payload: { eventId: "event-1" } });
+		app.dispatch({ id: "cmd-2", type: "PlaceOrder", payload: { eventId: "event-2" } });
+		app.dispatch({ id: "cmd-1", type: "PlaceOrder", payload: { eventId: "event-1" } });
+		app.dispatch({ id: "cmd-1", type: "PlaceOrder", payload: { eventId: "event-3" } });
+
+		expect(events.filter((msg) => (msg as unknown[])[0] === "DATA")).toHaveLength(3);
+		expect(errors.at(-1)).toEqual([
+			"DATA",
+			expect.objectContaining({
+				code: "duplicate-command",
+				commandId: "cmd-1",
+				cursor: expect.objectContaining({
+					dedupe: {
+						commandIdsRetained: 1,
+						eventIdsRetained: 1,
+						commandIdsEvicted: 2,
+						eventIdsEvicted: 2,
+					},
+				}),
+			}),
+		]);
+		expect(cursor.at(-1)).toEqual([
+			"DATA",
+			expect.objectContaining({
+				dedupe: {
+					commandIdsRetained: 1,
+					eventIdsRetained: 1,
+					commandIdsEvicted: 2,
+					eventIdsEvicted: 2,
+				},
+			}),
+		]);
+	});
+
+	it("keeps default CQRS dedupe as unbounded id membership, not a shared engine (D151)", () => {
+		const g = graph();
+		const app = cqrs(g, {
+			name: "orders",
+			events: ["OrderPlaced"],
+			handlers: [
+				cqrsCommandHandler("PlaceOrder", (command) => [
+					{
+						id: (command.payload as { eventId: string }).eventId,
+						type: "OrderPlaced",
+						payload: command.payload,
+					},
+				]),
+			],
+		});
+		const events: unknown[] = [];
+		const errors: unknown[] = [];
+		const cursor: unknown[] = [];
+		app.events.subscribe((msg) => events.push(msg));
+		app.errors.subscribe((msg) => errors.push(msg));
+		app.cursor.subscribe((msg) => cursor.push(msg));
+
+		app.dispatch({ id: "cmd-1", type: "PlaceOrder", payload: { eventId: "event-1" } });
+		app.dispatch({ id: "cmd-2", type: "PlaceOrder", payload: { eventId: "event-2" } });
+		app.dispatch({ id: "cmd-3", type: "PlaceOrder", payload: { eventId: "event-3" } });
+		app.dispatch({ id: "cmd-1", type: "PlaceOrder", payload: { eventId: "event-4" } });
+
+		expect(events.filter((msg) => (msg as unknown[])[0] === "DATA")).toHaveLength(3);
+		expect(errors.at(-1)).toEqual([
+			"DATA",
+			expect.objectContaining({ code: "duplicate-command", commandId: "cmd-1" }),
+		]);
+		expect(cursor.at(-1)).toEqual([
+			"DATA",
+			{ eventSeq: 3, commandCount: 4, errorCount: 1, auditSeq: 4 },
+		]);
+	});
+
+	it("does not partially commit events when command validation fails", () => {
+		const g = graph();
+		const app = cqrs(g, {
+			name: "orders",
+			events: ["OrderPlaced"],
+			handlers: [
+				cqrsCommandHandler("PlaceOrder", () => [
+					{ type: "OrderPlaced", payload: { id: "o1" } },
+					{ type: "OrderRouted", payload: { id: "o1" } },
+				]),
+			],
+		});
+		const events: unknown[] = [];
+		const audit: unknown[] = [];
+		app.events.subscribe((msg) => events.push(msg));
+		app.audit.subscribe((msg) => audit.push(msg));
+
+		app.dispatch({ id: "cmd-1", type: "PlaceOrder", payload: {} });
+
+		expect(events.filter((msg) => (msg as unknown[])[0] === "DATA")).toEqual([]);
+		expect(audit.at(-1)).toEqual([
+			"DATA",
+			expect.objectContaining({
+				commandId: "cmd-1",
+				outcome: "failure",
+				eventIds: [],
+				eventTypes: [],
+				errorCode: "unknown-event",
+			}),
+		]);
+	});
+
+	it("routes timestamp provider failures to graph-visible CQRS errors", () => {
+		const g = graph();
+		const app = cqrs(g, {
+			name: "orders",
+			events: ["OrderPlaced"],
+			now: () => {
+				throw new Error("clock down");
+			},
+			handlers: [
+				cqrsCommandHandler("PlaceOrder", (command) => [
+					{ type: "OrderPlaced", payload: command.payload },
+				]),
+			],
+		});
+		const events: unknown[] = [];
+		const errors: unknown[] = [];
+		const audit: unknown[] = [];
+		app.events.subscribe((msg) => events.push(msg));
+		app.errors.subscribe((msg) => errors.push(msg));
+		app.audit.subscribe((msg) => audit.push(msg));
+
+		app.dispatch({ id: "cmd-1", type: "PlaceOrder", payload: {} });
+
+		expect(events.filter((msg) => (msg as unknown[])[0] === "DATA")).toEqual([]);
+		expect(errors.at(-1)).toEqual([
+			"DATA",
+			expect.objectContaining({
+				code: "clock-threw",
+				message: "cqrs: now() threw: clock down",
+				commandId: "cmd-1",
+			}),
+		]);
+		expect(audit.at(-1)).toEqual([
+			"DATA",
+			expect.objectContaining({
+				commandId: "cmd-1",
+				outcome: "failure",
+				errorCode: "clock-threw",
+			}),
+		]);
+	});
+
+	it("derives projections from declared event deps and reports reducer throws as error facts", () => {
+		const g = graph();
+		const app = cqrs(g, {
+			name: "orders",
+			events: ["OrderPlaced", "OrderFailed"],
+			handlers: [
+				cqrsCommandHandler("PlaceOrder", (command) => [
+					{
+						type: (command.payload as { fail?: boolean }).fail ? "OrderFailed" : "OrderPlaced",
+						payload: command.payload,
+					},
+				]),
+			],
+		});
+		const projection = cqrsProjection(g, app, {
+			name: "orders/count",
+			events: ["OrderPlaced", "OrderFailed"],
+			initial: { placed: 0 },
+			reducer(state, event) {
+				if (event.type === "OrderFailed") throw new Error("projection failed");
+				return { placed: state.placed + 1 };
+			},
+		});
+		const values: unknown[] = [];
+		const projectionErrors: unknown[] = [];
+		const protocolErrors: unknown[] = [];
+		projection.value.subscribe((msg) => values.push(msg));
+		projection.errors.subscribe((msg) => projectionErrors.push(msg));
+		projection.frames.subscribe((msg) => protocolErrors.push(msg));
+
+		app.dispatch({ id: "cmd-1", type: "PlaceOrder", payload: { id: "o1" } });
+		app.dispatch({ id: "cmd-2", type: "PlaceOrder", payload: { id: "o2", fail: true } });
+
+		expect(values.filter((msg) => (msg as unknown[])[0] === "DATA").at(-1)).toEqual([
+			"DATA",
+			{ placed: 1 },
+		]);
+		expect(projectionErrors.at(-1)).toEqual([
+			"DATA",
+			expect.objectContaining({
+				code: "projection-threw",
+				message: "projection failed",
+				eventId: "cmd-2:1",
+				eventType: "OrderFailed",
+			}),
+		]);
+		expect(protocolErrors).not.toContainEqual(["ERROR", expect.anything()]);
+	});
+
+	it("keeps a projection's successful prefix when a later event in the same batch throws", () => {
+		const g = graph();
+		const app = cqrs(g, {
+			name: "orders",
+			events: ["OrderPlaced", "OrderFailed"],
+			handlers: [
+				cqrsCommandHandler("PlaceOrder", (command) => [
+					{ type: "OrderPlaced", payload: command.payload },
+					{ type: "OrderFailed", payload: command.payload },
+				]),
+			],
+		});
+		const projection = cqrsProjection(g, app, {
+			name: "orders/count",
+			events: ["OrderPlaced", "OrderFailed"],
+			initial: { placed: 0 },
+			reducer(state, event) {
+				if (event.type === "OrderFailed") throw new Error("projection failed");
+				return { placed: state.placed + 1 };
+			},
+		});
+		const values: unknown[] = [];
+		const errors: unknown[] = [];
+		projection.value.subscribe((msg) => values.push(msg));
+		projection.errors.subscribe((msg) => errors.push(msg));
+
+		app.dispatch({ id: "cmd-1", type: "PlaceOrder", payload: { id: "o1" } });
+
+		expect(values.filter((msg) => (msg as unknown[])[0] === "DATA")).toContainEqual([
+			"DATA",
+			{ placed: 1 },
+		]);
+		expect(errors.at(-1)).toEqual([
+			"DATA",
+			expect.objectContaining({
+				code: "projection-threw",
+				eventId: "cmd-1:2",
+				eventType: "OrderFailed",
+			}),
+		]);
+	});
+
+	it("does not downgrade protocol reentrancy from command handlers into CQRS error facts", () => {
+		const g = graph();
+		let app!: ReturnType<typeof cqrs>;
+		app = cqrs(g, {
+			name: "orders",
+			events: ["OrderPlaced"],
+			handlers: [
+				cqrsCommandHandler("PlaceOrder", (command) => {
+					if (command.id === "cmd-1") {
+						app.dispatch({ id: "cmd-2", type: "PlaceOrder", payload: {} });
+					}
+					return [{ type: "OrderPlaced", payload: command.payload }];
+				}),
+			],
+		});
+		const errors: unknown[] = [];
+		app.errors.subscribe((msg) => errors.push(msg));
+
+		expect(() => app.dispatch({ id: "cmd-1", type: "PlaceOrder", payload: {} })).toThrow(
+			/R-reentrancy|D37|feedback cycle/i,
+		);
+		expect(errors).not.toContainEqual(["DATA", expect.objectContaining({ code: "handler-threw" })]);
+	});
+
+	it("does not downgrade graph-domain violations from command handlers into CQRS facts", () => {
+		const g = graph();
+		const other = graph();
+		const foreign = other.state(1, { name: "foreign" });
+		const app = cqrs(g, {
+			name: "orders",
+			events: ["OrderPlaced"],
+			handlers: [
+				cqrsCommandHandler("PlaceOrder", (command) => {
+					g.derived([foreign], (value) => value, { name: "illegal-cross-graph" });
+					return [{ type: "OrderPlaced", payload: command.payload }];
+				}),
+			],
+		});
+		const errors: unknown[] = [];
+		app.errors.subscribe((msg) => errors.push(msg));
+
+		expect(() => app.dispatch({ id: "cmd-1", type: "PlaceOrder", payload: {} })).toThrow(
+			/different graph|cross-graph|R-graph-domain|wire bridge/i,
+		);
+		expect(errors).not.toContainEqual(["DATA", expect.objectContaining({ code: "handler-threw" })]);
+	});
+
+	it("does not downgrade protocol reentrancy from projection reducers into projection facts", () => {
+		const g = graph();
+		const app = cqrs(g, {
+			name: "orders",
+			events: ["OrderPlaced"],
+			handlers: [
+				cqrsCommandHandler("PlaceOrder", (command) => [
+					{ type: "OrderPlaced", payload: command.payload },
+				]),
+			],
+		});
+		const projection = cqrsProjection(g, app, {
+			name: "orders/count",
+			events: ["OrderPlaced"],
+			initial: 0,
+			reducer(state, event) {
+				if (event.commandId === "cmd-1") {
+					app.dispatch({ id: "cmd-2", type: "PlaceOrder", payload: {} });
+				}
+				return state + 1;
+			},
+		});
+		const projectionErrors: unknown[] = [];
+		projection.errors.subscribe((msg) => projectionErrors.push(msg));
+
+		expect(() => app.dispatch({ id: "cmd-1", type: "PlaceOrder", payload: {} })).toThrow(
+			/R-reentrancy|D37|feedback cycle/i,
+		);
+		expect(projectionErrors).not.toContainEqual([
+			"DATA",
+			expect.objectContaining({ code: "projection-threw" }),
+		]);
+	});
+
+	it("keeps runtime state checkpoint/JSON friendly", () => {
+		const g = graph();
+		const app = cqrs(g, {
+			name: "orders",
+			events: ["OrderPlaced"],
+			handlers: [
+				cqrsCommandHandler("PlaceOrder", () => [
+					{ id: "event-1", type: "OrderPlaced", payload: {} },
+				]),
+			],
+		});
+
+		app.dispatch({ id: "cmd-1", type: "PlaceOrder", payload: {} });
+
+		const checkpoint = g.checkpoint();
+		expect(() => JSON.stringify(checkpoint)).not.toThrow();
+		const runtime = checkpoint.nodes.find((node) => node.id === "orders/runtime");
+		expect(runtime?.ctxState).toEqual({
+			persist: true,
+			value: {
+				kind: "DATA",
+				data: {
+					eventSeq: 1,
+					commandCount: 1,
+					errorCount: 0,
+					auditSeq: 1,
+					seenCommandIds: ["cmd-1"],
+					seenEventIds: ["event-1"],
+				},
+			},
+		});
+	});
+
+	it("shows command/event/projection nodes and declared deps in describe", () => {
+		const g = graph();
+		const app = cqrs(g, {
+			name: "orders",
+			events: ["OrderPlaced"],
+			handlers: [cqrsCommandHandler("PlaceOrder", () => [{ type: "OrderPlaced", payload: {} }])],
+		});
+		cqrsProjection(g, app, {
+			name: "orders/count",
+			events: ["OrderPlaced"],
+			initial: 0,
+			reducer: (state) => state + 1,
+		});
+
+		const snap = g.describe();
+
+		expect(snap.nodes.map((node) => [node.id, node.factory])).toEqual(
+			expect.arrayContaining([
+				["orders/command", "cqrsCommand"],
+				["orders/runtime", "cqrsRuntime"],
+				["orders/events", "cqrsEvents"],
+				["orders/status", "cqrsStatus"],
+				["orders/errors", "cqrsErrors"],
+				["orders/audit", "cqrsAudit"],
+				["orders/cursor", "cqrsCursor"],
+				["orders/count", "cqrsProjection"],
+				["orders/count/value", "cqrsProjectionValue"],
+				["orders/count/errors", "cqrsProjectionErrors"],
+				["orders/count/status", "cqrsProjectionStatus"],
+			]),
+		);
+		expect(snap.edges).toEqual(
+			expect.arrayContaining([
+				{ from: "orders/command", to: "orders/runtime" },
+				{ from: "orders/runtime", to: "orders/events" },
+				{ from: "orders/runtime", to: "orders/status" },
+				{ from: "orders/runtime", to: "orders/errors" },
+				{ from: "orders/runtime", to: "orders/audit" },
+				{ from: "orders/runtime", to: "orders/cursor" },
+				{ from: "orders/events", to: "orders/count" },
+				{ from: "orders/count", to: "orders/count/value" },
+				{ from: "orders/count", to: "orders/count/errors" },
+				{ from: "orders/count", to: "orders/count/status" },
+			]),
+		);
+	});
+});
diff --git a/packages/ts/src/__tests__/data-structures.part-01.test.ts b/packages/ts/src/__tests__/data-structures.part-01.test.ts
new file mode 100644
index 00000000..b074a949
--- /dev/null
+++ b/packages/ts/src/__tests__/data-structures.part-01.test.ts
@@ -0,0 +1,716 @@
+/**
+ * CSP-2.8 reactive data structures (D54/D60) — reactiveList/Map/Index/Log + the shared core.
+ *
+ * Covers the two-port shape (D60): the always-on DELTA stream (O(1)/mutation) + the lazy pull
+ * SNAPSHOT node (materialized only on a cone-routed PULL demand, R-pull/D269/C-16), the D54
+ * `Node<T>` widening (declared-dep input fold), each structure's specialization (Map lazy-TTL +
+ * LRU + delete-reason; Index Z reverse-lookup; Log incremental view/scan + SENTINEL reject +
+ * declared-dep merge), and real factory names (D6).
+ *
+ * Authority: ~/src/graphrefly/decisions/decisions.jsonl D54/D60, spec/rules.jsonl R-pull/R-rom-ram.
+ */
+
+import { describe, expect, it, vi } from "vitest";
+import { reactiveList } from "../graph/data-structures/reactive-list.js";
+import { reactiveMap } from "../graph/data-structures/reactive-map.js";
+import { graph } from "../graph/graph.js";
+import { selectRetentionVictims } from "../graph/policies/collection.js";
+import { Dispatcher, type Message } from "../index.js";
+import type { Node } from "../node/node.js";
+
+const types = (m: Message[]) => m.map((x) => x[0]);
+const data = <T>(m: Message[]): T[] =>
+	m.filter((x) => x[0] === "DATA").map((x) => (x as readonly ["DATA", T])[1]);
+
+function collect(n: { subscribe(s: (m: Message) => void): () => void }) {
+	const msgs: Message[] = [];
+	const unsub = n.subscribe((m) => msgs.push(m));
+	return { msgs, unsub };
+}
+
+class _CountingDispatcher extends Dispatcher {
+	register(...args: Parameters<Dispatcher["register"]>): ReturnType<Dispatcher["register"]> {
+		this.registerCount += 1;
+		return super.register(...args);
+	}
+	registerCount = 0;
+}
+
+/** Demand the snapshot directly (the substrate cone-routed PULL of its pullId, R-pull/D269). */
+function demand(snapshot: Node<unknown>, pullId: symbol): void {
+	snapshot.up([["PULL", { pullId }]]);
+}
+
+describe("collectionCore two-port shape (D60) via reactiveList", () => {
+	it("DELTA stream emits one change per mutation (O(1)/mutation)", () => {
+		const list = reactiveList<number>();
+		const { msgs } = collect(list.delta);
+		list.append(1);
+		list.append(2);
+		list.appendMany([3, 4]);
+		list.pop();
+		list.clear();
+		expect(data(msgs)).toEqual([
+			{ kind: "append", value: 1 },
+			{ kind: "append", value: 2 },
+			{ kind: "appendMany", values: [3, 4] },
+			{ kind: "pop", index: 3, value: 4 }, // [1,2,3,4] pop(-1) → resolved index 3, value 4
+
+			{ kind: "clear", count: 3 },
+		]);
+	});
+
+	it("bulk list deltas carry defensive copies", () => {
+		const list = reactiveList<number>();
+		const { msgs } = collect(list.delta);
+		const appended = [1, 2];
+		const inserted = [3, 4];
+		list.appendMany(appended);
+		list.insertMany(0, inserted);
+		appended[0] = 99;
+		inserted[0] = 88;
+		expect(data(msgs)).toEqual([
+			{ kind: "appendMany", values: [1, 2] },
+			{ kind: "insertMany", index: 0, values: [3, 4] },
+		]);
+	});
+
+	it("empty list bulk ops are no-op deltas where the array bulk API exists", () => {
+		const list = reactiveList<number>([1]);
+		const { msgs } = collect(list.delta);
+		msgs.length = 0;
+		list.appendMany([]);
+		list.insertMany(1, []);
+		expect(msgs).toEqual([]);
+		expect(list.toArray()).toEqual([1]);
+	});
+
+	it("SNAPSHOT pull node is quiet (START only, no push-on-subscribe), absorbs delta DIRTY", () => {
+		const list = reactiveList<number>([10]);
+		const { msgs } = collect(list.snapshot);
+		expect(types(msgs)).toEqual(["START"]);
+		list.append(20);
+		expect(types(msgs)).toEqual(["START"]); // delta DIRTY absorbed, no wedge (R-pull)
+	});
+
+	it("a demand delivers the CURRENT snapshot once, then re-quiets (1:1, lazy O(n))", () => {
+		const list = reactiveList<number>();
+		const { msgs } = collect(list.snapshot);
+		list.append(1);
+		list.append(2);
+		demand(list.snapshot as Node<unknown>, list.pullId);
+		expect(types(msgs)).toEqual(["START", "DIRTY", "DATA"]);
+		expect(data(msgs)).toEqual([[1, 2]]);
+	});
+
+	it("demand-on-no-change emits no duplicate DATA (collection coalesce)", () => {
+		const list = reactiveList<number>();
+		const { msgs } = collect(list.snapshot);
+		list.append(1);
+		demand(list.snapshot as Node<unknown>, list.pullId);
+		const afterFirst = msgs.length;
+		demand(list.snapshot as Node<unknown>, list.pullId);
+		expect(types(msgs).slice(afterFirst)).toEqual([]);
+		expect(data(msgs)).toEqual([[1]]);
+	});
+
+	it("a second demand after a new mutation delivers the fresh snapshot", () => {
+		const list = reactiveList<number>();
+		const { msgs } = collect(list.snapshot);
+		list.append(1);
+		demand(list.snapshot as Node<unknown>, list.pullId);
+		list.append(2);
+		demand(list.snapshot as Node<unknown>, list.pullId);
+		expect(data(msgs)).toEqual([[1], [1, 2]]);
+	});
+
+	it("synchronous quick-reads are the non-reactive peek (at/size/toArray)", () => {
+		const list = reactiveList<string>(["a", "b"]);
+		list.append("c");
+		expect(list.size).toBe(3);
+		expect(list.at(0)).toBe("a");
+		expect(list.at(-1)).toBe("c");
+		expect(list.at(99)).toBeUndefined();
+		expect(list.toArray()).toEqual(["a", "b", "c"]);
+	});
+
+	it("insert/pop edge cases throw RangeError out of range", () => {
+		const list = reactiveList<number>([1, 2]);
+		expect(() => list.insert(5, 9)).toThrow(RangeError);
+		expect(() => reactiveList<number>().pop()).toThrow(RangeError);
+	});
+
+	it("D72 maxSize head-trims on overflow and emits trimHead deltas", () => {
+		const list = reactiveList<number>([], { maxSize: 2 });
+		const { msgs } = collect(list.delta);
+		list.append(1);
+		list.append(2);
+		list.append(3);
+		expect(data(msgs)).toEqual([
+			{ kind: "append", value: 1 },
+			{ kind: "append", value: 2 },
+			{ kind: "append", value: 3 },
+			{ kind: "trimHead", n: 1 },
+		]);
+		expect(list.toArray()).toEqual([2, 3]);
+	});
+
+	it("D72 Node-valued list maxSize is a declared policy dep and trims on policy change", () => {
+		const g = graph();
+		const max = g.state(3, { name: "max" });
+		const list = reactiveList<number>([], { graph: g, name: "list", maxSize: max });
+		const { msgs } = collect(list.delta);
+		list.appendMany([1, 2, 3]);
+		max.set(1);
+		expect(data(msgs)).toEqual([
+			{ kind: "appendMany", values: [1, 2, 3] },
+			{ kind: "trimHead", n: 2 },
+		]);
+		expect(list.toArray()).toEqual([3]);
+		expect(g.describe().edges).toContainEqual({ from: "max", to: "list.capacityPolicy" });
+		expect(g.describe().nodes.find((n) => n.id === "list.capacityPolicy")?.factory).toBe(
+			"reactiveList.capacityPolicy",
+		);
+	});
+
+	it("D72 Node-valued list maxSize requires graph binding", () => {
+		const g = graph();
+		const max = g.state(1);
+		expect(() => reactiveList<number>([], { maxSize: max })).toThrow(/requires options.graph/);
+	});
+
+	it("D72 Node policy + appendFrom share one graph-visible apply path", () => {
+		const g = graph();
+		const max = g.state(2, { name: "max" });
+		const src = g.state(0, { name: "src" });
+		const list = reactiveList<number>([], { graph: g, name: "list", maxSize: max });
+		const { msgs } = collect(list.delta);
+		list.appendFrom(src);
+		src.set(1);
+		src.set(2);
+		max.set(1);
+		expect(data(msgs)).toEqual([
+			{ kind: "append", value: 0 },
+			{ kind: "append", value: 1 },
+			{ kind: "append", value: 2 },
+			{ kind: "trimHead", n: 1 },
+			{ kind: "trimHead", n: 1 },
+		]);
+		expect(g.describe().edges).toContainEqual({ from: "max", to: "list.capacityPolicy" });
+		expect(g.describe().edges).toContainEqual({ from: "list.bind#0", to: "list.capacityPolicy" });
+	});
+});
+
+describe("D54 Node<T> widening — in-graph producer drives the structure (declared-dep fold)", () => {
+	it("appendFrom folds a source's values into the list (no imperative glue)", () => {
+		const g = graph();
+		const src = g.state<number>(0, { name: "src" });
+		const list = reactiveList<number>([], { graph: g, name: "list" });
+		const { msgs } = collect(list.delta);
+		list.appendFrom(src as unknown as Node<number>);
+		src.set(1);
+		src.set(2);
+		expect(data(msgs)).toEqual([
+			{ kind: "append", value: 0 }, // state node pushes its initial on subscribe (R-initial)
+			{ kind: "append", value: 1 },
+			{ kind: "append", value: 2 },
+		]);
+		expect(list.toArray()).toEqual([0, 1, 2]);
+		expect(g.describe().edges).toContainEqual({ from: "src", to: "list.bind#0" });
+		expect(g.describe().nodes.find((n) => n.id === "list.bind#0")?.factory).toBe(
+			"reactiveList.bindSource",
+		);
+	});
+});
+
+describe("reactiveMap (D60 #3) — lazy TTL + LRU + delete-reason", () => {
+	it("set/delete emit deltas with the right reason; snapshot reflects state", () => {
+		const m = reactiveMap<string, number>();
+		const { msgs } = collect(m.delta);
+		m.set("a", 1);
+		m.set("b", 2);
+		m.delete("a");
+		expect(data(msgs)).toEqual([
+			{ kind: "set", key: "a", value: 1 },
+			{ kind: "set", key: "b", value: 2 },
+			{ kind: "delete", key: "a", previous: 1, reason: "explicit" },
+		]);
+		expect([...m.toMap()]).toEqual([["b", 2]]);
+	});
+
+	it("empty setMany/deleteMany are no-op deltas", () => {
+		const m = reactiveMap<string, number>();
+		const { msgs } = collect(m.delta);
+		msgs.length = 0;
+		m.setMany([]);
+		m.deleteMany([]);
+		expect(msgs).toEqual([]);
+		expect([...m.toMap()]).toEqual([]);
+	});
+
+	it("setMany/deleteMany accept generator inputs and ignore missing deletes", () => {
+		function* entries(): Generator<readonly [string, number]> {
+			yield ["a", 1];
+			yield ["b", 2];
+		}
+		function* keys(): Generator<string> {
+			yield "missing";
+			yield "a";
+			yield "also-missing";
+		}
+
+		const m = reactiveMap<string, number>();
+		const { msgs } = collect(m.delta);
+		m.setMany(entries());
+		m.deleteMany(keys());
+
+		expect(data(msgs)).toEqual([
+			{ kind: "set", key: "a", value: 1 },
+			{ kind: "set", key: "b", value: 2 },
+			{ kind: "delete", key: "a", previous: 1, reason: "explicit" },
+		]);
+		expect([...m.toMap()]).toEqual([["b", 2]]);
+	});
+
+	it("setMany applies per-call TTL to every generated entry", () => {
+		let t = 0;
+		function* entries(): Generator<readonly [string, number]> {
+			yield ["a", 1];
+			yield ["b", 2];
+		}
+
+		const m = reactiveMap<string, number>({ now: () => t });
+		const { msgs } = collect(m.delta);
+		m.setMany(entries(), { ttl: 10 });
+
+		t = 9;
+		expect(m.get("a")).toBe(1);
+		expect(m.get("b")).toBe(2);
+
+		t = 10;
+		expect(m.get("a")).toBeUndefined();
+		expect(m.get("b")).toBeUndefined();
+		expect(data(msgs)).toEqual([
+			{ kind: "set", key: "a", value: 1 },
+			{ kind: "set", key: "b", value: 2 },
+			{ kind: "delete", key: "a", previous: 1, reason: "expired" },
+			{ kind: "delete", key: "b", previous: 2, reason: "expired" },
+		]);
+	});
+
+	it("lazy TTL: a read that materializes expiry emits delete(reason:'expired') (D61)", () => {
+		let t = 1000;
+		const m = reactiveMap<string, number>({ defaultTtl: 100, now: () => t });
+		const { msgs } = collect(m.delta);
+		m.set("x", 1);
+		expect(m.get("x")).toBe(1);
+		t = 1200;
+		expect(m.get("x")).toBeUndefined(); // read prunes and emits the normal expired delete delta
+		expect(data(msgs)).toEqual([
+			{ kind: "set", key: "x", value: 1 },
+			{ kind: "delete", key: "x", previous: 1, reason: "expired" },
+		]);
+		expect(m.toMap().size).toBe(0);
+	});
+
+	it("lazy TTL: pruneExpired/toMap emit expired deletes for materialized expiry (D61)", () => {
+		let t = 0;
+		const m = reactiveMap<string, number>({ defaultTtl: 5, now: () => t });
+		const { msgs } = collect(m.delta);
+		m.set("a", 1);
+		m.set("b", 2);
+		t = 10;
+		m.pruneExpired();
+		expect(data(msgs)).toEqual([
+			{ kind: "set", key: "a", value: 1 },
+			{ kind: "set", key: "b", value: 2 },
+			{ kind: "delete", key: "a", previous: 1, reason: "expired" },
+			{ kind: "delete", key: "b", previous: 2, reason: "expired" },
+		]);
+
+		m.set("c", 3);
+		t = 20;
+		expect([...m.toMap()]).toEqual([]);
+		expect(data(msgs).at(-1)).toEqual({
+			kind: "delete",
+			key: "c",
+			previous: 3,
+			reason: "expired",
+		});
+	});
+
+	it("LRU maxSize evicts the oldest with reason:'lru-evict'", () => {
+		const m = reactiveMap<string, number>({ maxSize: 2 });
+		const { msgs } = collect(m.delta);
+		m.set("a", 1);
+		m.set("b", 2);
+		m.set("c", 3); // evicts "a"
+		expect(data(msgs)).toEqual([
+			{ kind: "set", key: "a", value: 1 },
+			{ kind: "set", key: "b", value: 2 },
+			{ kind: "set", key: "c", value: 3 },
+			{ kind: "delete", key: "a", previous: 1, reason: "lru-evict" },
+		]);
+		expect([...m.toMap()].map(([k]) => k)).toEqual(["b", "c"]);
+	});
+
+	it("D68 static TTL/LRU shorthands install graph-visible policy/apply nodes", () => {
+		const g = graph();
+		const m = reactiveMap<string, number>({ graph: g, name: "map", maxSize: 2, defaultTtl: 5 });
+		m.set("a", 1);
+		const snap = g.describe();
+		expect(snap.nodes.find((n) => n.id === "map.apply")?.factory).toBe("reactiveMap.apply");
+		expect(snap.nodes.find((n) => n.id === "map.delta")?.factory).toBe("reactiveMap.delta");
+		expect(snap.nodes.find((n) => n.id === "map.intent")?.factory).toBe("reactiveMap.intent");
+		expect(snap.nodes.find((n) => n.id === "map.lruPolicy")?.factory).toBe("reactiveMap.lruPolicy");
+		expect(snap.nodes.find((n) => n.id === "map.ttlPolicy")?.factory).toBe("reactiveMap.ttlPolicy");
+		expect(snap.edges).toContainEqual({ from: "map.intent", to: "map.apply" });
+		expect(snap.edges).toContainEqual({ from: "map.lruPolicy", to: "map.apply" });
+		expect(snap.edges).toContainEqual({ from: "map.ttlPolicy", to: "map.apply" });
+	});
+
+	it("D68 Node-valued maxSize is a declared policy dep and can evict on policy change", () => {
+		const g = graph();
+		const max = g.state(2, { name: "max" });
+		const m = reactiveMap<string, number>({ graph: g, name: "map", maxSize: max });
+		const { msgs } = collect(m.delta);
+		m.set("a", 1);
+		m.set("b", 2);
+		m.set("c", 3);
+		max.set(1); // lowering the policy is itself a policy-driven backend mutation (D68)
+		expect(data(msgs)).toEqual([
+			{ kind: "set", key: "a", value: 1 },
+			{ kind: "set", key: "b", value: 2 },
+			{ kind: "set", key: "c", value: 3 },
+			{ kind: "delete", key: "a", previous: 1, reason: "lru-evict" },
+			{ kind: "delete", key: "b", previous: 2, reason: "lru-evict" },
+		]);
+		expect([...m.toMap()]).toEqual([["c", 3]]);
+		expect(g.describe().edges).toContainEqual({ from: "max", to: "map.apply" });
+	});
+
+	it("D68 Node-valued defaultTtl is a declared policy dep for subsequent sets", () => {
+		let t = 0;
+		const g = graph();
+		const ttl = g.state(5, { name: "ttl" });
+		const m = reactiveMap<string, number>({
+			graph: g,
+			name: "map",
+			defaultTtl: ttl,
+			now: () => t,
+		});
+		m.set("a", 1);
+		t = 6;
+		expect(m.get("a")).toBeUndefined();
+		ttl.set(20);
+		m.set("b", 2);
+		t = 16;
+		expect(m.get("b")).toBe(2);
+		t = 27;
+		expect(m.get("b")).toBeUndefined();
+		expect(g.describe().edges).toContainEqual({ from: "ttl", to: "map.apply" });
+	});
+
+	it("D68 Node-valued policy opts require graph binding", () => {
+		const g = graph();
+		const max = g.state(1);
+		expect(() => reactiveMap<string, number>({ maxSize: max })).toThrow(/requires options.graph/);
+		expect(() => reactiveMap<string, number>({ defaultTtl: max })).toThrow(
+			/requires options.graph/,
+		);
+	});
+
+	it("D72 retention archives lowest scores with reason:'archived'", () => {
+		const m = reactiveMap<string, number>({
+			retention: { maxSize: 2, score: ({ value }) => value },
+		});
+		const { msgs } = collect(m.delta);
+		m.set("a", 10);
+		m.set("b", 1);
+		m.set("c", 5);
+		expect(data(msgs)).toEqual([
+			{ kind: "set", key: "a", value: 10 },
+			{ kind: "set", key: "b", value: 1 },
+			{ kind: "set", key: "c", value: 5 },
+			{ kind: "delete", key: "b", previous: 1, reason: "archived" },
+		]);
+		expect([...m.toMap()]).toEqual([
+			["a", 10],
+			["c", 5],
+		]);
+	});
+
+	it("D72 static retention maxSize installs a graph-visible policy/apply edge", () => {
+		const g = graph();
+		const m = reactiveMap<string, number>({
+			graph: g,
+			name: "map",
+			retention: { maxSize: 2, score: ({ value }) => value },
+		});
+		m.set("a", 1);
+		const snap = g.describe();
+		expect(snap.nodes.find((n) => n.id === "map.retentionPolicy")?.factory).toBe(
+			"reactiveMap.retentionPolicy",
+		);
+		expect(snap.edges).toContainEqual({ from: "map.retentionPolicy", to: "map.apply" });
+	});
+
+	it("D72 Node-valued retention.maxSize is a declared policy dep and archives on policy change", () => {
+		const g = graph();
+		const keep = g.state(3, { name: "keep" });
+		const m = reactiveMap<string, number>({
+			graph: g,
+			name: "map",
+			retention: { maxSize: keep, score: ({ value }) => value },
+		});
+		const { msgs } = collect(m.delta);
+		m.set("a", 1);
+		m.set("b", 2);
+		m.set("c", 3);
+		keep.set(1);
+		expect(data(msgs)).toEqual([
+			{ kind: "set", key: "a", value: 1 },
+			{ kind: "set", key: "b", value: 2 },
+			{ kind: "set", key: "c", value: 3 },
+			{ kind: "delete", key: "a", previous: 1, reason: "archived" },
+			{ kind: "delete", key: "b", previous: 2, reason: "archived" },
+		]);
+		expect([...m.toMap()]).toEqual([["c", 3]]);
+		expect(g.describe().edges).toContainEqual({ from: "keep", to: "map.apply" });
+	});
+
+	it("D72 Node-valued retention.maxSize requires graph binding", () => {
+		const g = graph();
+		const keep = g.state(1);
+		expect(() =>
+			reactiveMap<string, number>({
+				retention: { maxSize: keep, score: ({ value }) => value },
+			}),
+		).toThrow(/requires options.graph/);
+	});
+
+	it("D68 graph-bound Node policy/input opts reject foreign graph nodes", () => {
+		const g1 = graph();
+		const g2 = graph();
+		const foreignMax = g1.state(1, { name: "max" });
+		expect(() =>
+			reactiveMap<string, number>({ graph: g2, name: "map", maxSize: foreignMax }),
+		).toThrow(/different graph/);
+
+		const foreignSrc = g1.state<readonly [string, number]>(["x", 1], { name: "src" });
+		const m = reactiveMap<string, number>({ graph: g2, name: "map2" });
+		expect(() => m.setFrom(foreignSrc as Node<readonly [string, number]>)).toThrow(
+			/different graph/,
+		);
+	});
+
+	it("D68 active TTL uses one internal timer path to prune without a read", () => {
+		vi.useFakeTimers();
+		try {
+			const m = reactiveMap<string, number>({ defaultTtl: 10 });
+			const { msgs } = collect(m.delta);
+			m.set("a", 1);
+			vi.advanceTimersByTime(9);
+			expect(data(msgs)).toEqual([{ kind: "set", key: "a", value: 1 }]);
+			vi.advanceTimersByTime(1);
+			expect(data(msgs)).toEqual([
+				{ kind: "set", key: "a", value: 1 },
+				{ kind: "delete", key: "a", previous: 1, reason: "expired" },
+			]);
+		} finally {
+			vi.useRealTimers();
+		}
+	});
+
+	it("pull snapshot delivers a ReadonlyMap on demand", () => {
+		const m = reactiveMap<string, number>();
+		const { msgs } = collect(m.snapshot);
+		m.set("a", 1);
+		m.set("b", 2);
+		demand(m.snapshot as Node<unknown>, m.pullId);
+		const snap = data<ReadonlyMap<string, number>>(msgs)[0];
+		expect([...snap]).toEqual([
+			["a", 1],
+			["b", 2],
+		]);
+	});
+
+	it("pull snapshot demand prunes expired entries and emits expired deletes through public delta", () => {
+		let t = 0;
+		const m = reactiveMap<string, number>({ defaultTtl: 5, now: () => t });
+		const deltas = collect(m.delta);
+		const snaps = collect(m.snapshot);
+		m.set("live", 1, { ttl: 20 });
+		m.set("old", 2);
+		t = 10;
+		demand(m.snapshot as Node<unknown>, m.pullId);
+		expect([...data<ReadonlyMap<string, number>>(snaps.msgs).at(-1)!]).toEqual([["live", 1]]);
+		expect(data(deltas.msgs).at(-1)).toEqual({
+			kind: "delete",
+			key: "old",
+			previous: 2,
+			reason: "expired",
+		});
+	});
+
+	it("pull snapshot demand with no expired entries does not emit delta DATA", () => {
+		let t = 0;
+		const m = reactiveMap<string, number>({ defaultTtl: 50, now: () => t });
+		const deltas = collect(m.delta);
+		const snaps = collect(m.snapshot);
+		m.set("a", 1);
+		const before = data(deltas.msgs).length;
+		t = 10;
+		demand(m.snapshot as Node<unknown>, m.pullId);
+		expect([...data<ReadonlyMap<string, number>>(snaps.msgs).at(-1)!]).toEqual([["a", 1]]);
+		expect(data(deltas.msgs)).toHaveLength(before);
+	});
+
+	it("select(predicate) is a D121 light view with forwarded delta + pulled snapshot", () => {
+		const m = reactiveMap<string, number>();
+		const isEven = (value: number) => value % 2 === 0;
+		const view = m.select(isEven);
+		const deltaMsgs = collect(view.delta);
+		const snapshotMsgs = collect(view.snapshot);
+
+		m.set("a", 1);
+		m.set("b", 2);
+		m.set("c", 4);
+
+		expect(data(deltaMsgs.msgs).at(-1)).toEqual({ kind: "set", key: "c", value: 4 });
+		demand(view.snapshot as Node<unknown>, view.pullId);
+		expect([...data<ReadonlyMap<string, number>>(snapshotMsgs.msgs).at(-1)!]).toEqual([
+			["b", 2],
+			["c", 4],
+		]);
+		expect(m.select(isEven)).toBe(view);
+		expect(() => m.select(null as never)).toThrow(TypeError);
+		view.dispose();
+		expect(m.select(isEven)).not.toBe(view);
+		expect(() => view.delta.subscribe(() => {})).toThrow(/released from its graph lifecycle/);
+		expect(() => demand(view.snapshot as Node<unknown>, view.pullId)).toThrow(
+			/released from its graph lifecycle/,
+		);
+	});
+
+	it("select snapshot predicate failures surface as ERROR waves", () => {
+		const m = reactiveMap<string, number>();
+		m.set("a", 1);
+		const view = m.select(() => {
+			throw new Error("select boom");
+		});
+		const snapshotMsgs = collect(view.snapshot);
+
+		demand(view.snapshot as Node<unknown>, view.pullId);
+
+		const errors = snapshotMsgs.msgs.filter((msg) => msg[0] === "ERROR");
+		expect(errors).toHaveLength(1);
+		expect((errors[0]?.[1] as Error).message).toBe("select boom");
+		expect(data(snapshotMsgs.msgs)).toEqual([]);
+	});
+
+	it("select light views register through the graph funnel when options.graph is present", () => {
+		const g = graph();
+		const m = reactiveMap<string, number>({ graph: g, name: "map" });
+		const view = m.select((value) => value > 1);
+
+		const snap = g.describe();
+		expect(snap.nodes.find((n) => n.id === "map.delta")?.factory).toBe("reactiveMap.delta");
+		expect(snap.nodes.find((n) => n.id === "map.select#0.delta")?.factory).toBe(
+			"reactiveMap.select.delta",
+		);
+		expect(snap.nodes.find((n) => n.id === "map.select#0.snapshot")?.factory).toBe(
+			"reactiveMap.select.snapshot",
+		);
+		expect(snap.edges).toContainEqual({ from: "map.delta", to: "map.select#0.delta" });
+		expect(snap.edges).toContainEqual({
+			from: "map.select#0.delta",
+			to: "map.select#0.snapshot",
+		});
+		view.dispose();
+		const after = g.describe();
+		expect(after.edges).not.toContainEqual({
+			from: "map.delta",
+			to: "map.select#0.delta",
+		});
+		expect(after.nodes.map((n) => n.id)).not.toContain("map.select#0.delta");
+		expect(after.nodes.map((n) => n.id)).not.toContain("map.select#0.snapshot");
+	});
+
+	it("select viewCache evicts only memo refs, not live D121 view nodes", () => {
+		const g = graph();
+		const m = reactiveMap<string, number>({ graph: g, name: "map", viewCache: { maxEntries: 1 } });
+		const gt0 = (value: number) => value > 0;
+		const gt1 = (value: number) => value > 1;
+
+		const first = m.select(gt0);
+		const second = m.select(gt1);
+
+		expect(m.select(gt1)).toBe(second);
+		expect(m.select(gt0)).not.toBe(first);
+		expect(g.find("map.select#0.delta")).toBe(first.delta);
+		expect(g.find("map.select#1.delta")).toBe(second.delta);
+		first.dispose();
+		expect(g.find("map.select#0.delta")).toBeUndefined();
+		m.dispose();
+		expect(
+			g
+				.describe()
+				.nodes.map((n) => n.id)
+				.filter((id) => id.includes(".select#")),
+		).toEqual([]);
+	});
+
+	it("rejects invalid select viewCache policies", () => {
+		expect(() => reactiveMap<string, number>({ viewCache: { maxEntries: -1 } })).toThrow(
+			/viewCache\.maxEntries/,
+		);
+	});
+
+	it("undefined is a valid map value: has/delete use presence, not value !== undefined", () => {
+		const m = reactiveMap<string, number | undefined>();
+		const { msgs } = collect(m.delta);
+		m.set("u", undefined);
+		expect(m.has("u")).toBe(true);
+		expect(m.get("u")).toBeUndefined();
+		expect([...m.toMap()]).toEqual([["u", undefined]]);
+		m.delete("u");
+		expect(data(msgs)).toEqual([
+			{ kind: "set", key: "u", value: undefined },
+			{ kind: "delete", key: "u", previous: undefined, reason: "explicit" },
+		]);
+	});
+
+	it("setFrom routes malformed input errors to the folder ERROR boundary", () => {
+		const g = graph();
+		const src = g.node<readonly [string, number]>([], null, { name: "src" });
+		const m = reactiveMap<string, number>({ graph: g, name: "map" });
+		m.setFrom(src as Node<readonly [string, number]>);
+
+		expect(() => src.down([["DATA", 1 as unknown as readonly [string, number]]])).not.toThrow();
+		expect(m.size).toBe(0);
+		expect(g.describe().edges).toContainEqual({ from: "src", to: "map.bind#0" });
+		expect(g.describe().edges).toContainEqual({ from: "map.bind#0", to: "map.apply" });
+		expect(g.describe().nodes.find((n) => n.id === "map.bind#0")?.factory).toBe(
+			"reactiveMap.bindSource",
+		);
+	});
+});
+
+describe("internal collection policy helpers (D70)", () => {
+	it("selectRetentionVictims is selection-only and stable by lowest score", () => {
+		const scored = [
+			{ entry: "keep-high", score: 10 },
+			{ entry: "drop-low-a", score: 1 },
+			{ entry: "drop-low-b", score: 1 },
+			{ entry: "keep-mid", score: 5 },
+		];
+		expect(selectRetentionVictims(scored, { maxSize: 2 })).toEqual(["drop-low-a", "drop-low-b"]);
+		expect(scored.map((x) => x.entry)).toEqual([
+			"keep-high",
+			"drop-low-a",
+			"drop-low-b",
+			"keep-mid",
+		]);
+	});
+});
diff --git a/packages/ts/src/__tests__/data-structures.part-02.test.ts b/packages/ts/src/__tests__/data-structures.part-02.test.ts
new file mode 100644
index 00000000..62800ffb
--- /dev/null
+++ b/packages/ts/src/__tests__/data-structures.part-02.test.ts
@@ -0,0 +1,695 @@
+/**
+ * CSP-2.8 reactive data structures (D54/D60) — reactiveList/Map/Index/Log + the shared core.
+ *
+ * Covers the two-port shape (D60): the always-on DELTA stream (O(1)/mutation) + the lazy pull
+ * SNAPSHOT node (materialized only on a cone-routed PULL demand, R-pull/D269/C-16), the D54
+ * `Node<T>` widening (declared-dep input fold), each structure's specialization (Map lazy-TTL +
+ * LRU + delete-reason; Index Z reverse-lookup; Log incremental view/scan + SENTINEL reject +
+ * declared-dep merge), and real factory names (D6).
+ *
+ * Authority: ~/src/graphrefly/decisions/decisions.jsonl D54/D60, spec/rules.jsonl R-pull/R-rom-ram.
+ */
+
+import { describe, expect, it } from "vitest";
+import { combine } from "../graph/combinators.js";
+import { reactiveIndex } from "../graph/data-structures/reactive-index.js";
+import { reactiveList } from "../graph/data-structures/reactive-list.js";
+import { mergeReactiveLogs, reactiveLog, scanLog } from "../graph/data-structures/reactive-log.js";
+import { graph } from "../graph/graph.js";
+import { Dispatcher, type Message } from "../index.js";
+import type { Node } from "../node/node.js";
+
+const _types = (m: Message[]) => m.map((x) => x[0]);
+const data = <T>(m: Message[]): T[] =>
+	m.filter((x) => x[0] === "DATA").map((x) => (x as readonly ["DATA", T])[1]);
+
+function collect(n: { subscribe(s: (m: Message) => void): () => void }) {
+	const msgs: Message[] = [];
+	const unsub = n.subscribe((m) => msgs.push(m));
+	return { msgs, unsub };
+}
+
+class CountingDispatcher extends Dispatcher {
+	register(...args: Parameters<Dispatcher["register"]>): ReturnType<Dispatcher["register"]> {
+		this.registerCount += 1;
+		return super.register(...args);
+	}
+	registerCount = 0;
+}
+
+/** Demand the snapshot directly (the substrate cone-routed PULL of its pullId, R-pull/D269). */
+function demand(snapshot: Node<unknown>, pullId: symbol): void {
+	snapshot.up([["PULL", { pullId }]]);
+}
+
+describe("reactiveIndex (D60 #4) — ordered snapshot + Z reverse-lookup", () => {
+	it("rows are ordered by (secondary, primary); sync has/get are point reads", () => {
+		const idx = reactiveIndex<string, string>();
+		idx.upsert("id2", 5, "b");
+		idx.upsert("id1", 10, "a");
+		idx.upsert("id3", 5, "c");
+		const { msgs } = collect(idx.snapshot);
+		demand(idx.snapshot as Node<unknown>, idx.pullId);
+		const rows = data<readonly { primary: string }[]>(msgs)[0];
+		expect(rows.map((r) => r.primary)).toEqual(["id2", "id3", "id1"]); // (5,id2),(5,id3),(10,id1)
+		expect(idx.has("id1")).toBe(true);
+		expect(idx.get("id1")).toBe("a");
+		expect(idx.get("nope")).toBeUndefined();
+		expect(idx.size).toBe(3);
+	});
+
+	it("upsert returns insert-vs-update; rangeByPrimary scans the primary axis (Z sync read)", () => {
+		const idx = reactiveIndex<string, number>();
+		expect(idx.upsert("b", 1, 2)).toBe(true);
+		expect(idx.upsert("b", 1, 3)).toBe(false);
+		idx.upsert("a", 1, 1);
+		idx.upsert("c", 1, 3);
+		expect(idx.rangeByPrimary("a", "c")).toEqual([1, 3]); // a,b in [a,c)
+	});
+
+	it("range(start,end) is a D121 light view with forwarded delta + pulled snapshot", () => {
+		const idx = reactiveIndex<string, number>();
+		const view = idx.range("a", "c");
+		const { msgs: deltaMsgs } = collect(view.delta);
+		const { msgs: snapshotMsgs } = collect(view.snapshot);
+
+		idx.upsert("b", 1, 2);
+		idx.upsert("d", 1, 4);
+		idx.upsert("a", 1, 1);
+
+		expect(data(deltaMsgs).at(-1)).toEqual({
+			kind: "upsert",
+			primary: "a",
+			secondary: 1,
+			value: 1,
+		});
+		demand(view.snapshot as Node<unknown>, view.pullId);
+		expect(data(snapshotMsgs).at(-1)).toEqual([1, 2]);
+		expect(idx.range("a", "c")).toBe(view);
+		const numeric = reactiveIndex<number, number>();
+		expect(numeric.range(0, 1)).toBe(numeric.range(-0, 1));
+		view.dispose();
+		expect(idx.range("a", "c")).not.toBe(view);
+	});
+
+	it("range light views register through the graph funnel when options.graph is present", () => {
+		const g = graph();
+		const idx = reactiveIndex<string, number>({ graph: g, name: "idx" });
+		idx.range("a", "z");
+
+		const snap = g.describe();
+		expect(snap.nodes.find((n) => n.id === "idx.delta")?.factory).toBe("reactiveIndex.delta");
+		expect(snap.nodes.find((n) => n.id === "idx.range#0.delta")?.factory).toBe(
+			"reactiveIndex.range.delta",
+		);
+		expect(snap.nodes.find((n) => n.id === "idx.range#0.snapshot")?.factory).toBe(
+			"reactiveIndex.range.snapshot",
+		);
+		expect(snap.edges).toContainEqual({ from: "idx.delta", to: "idx.range#0.delta" });
+		expect(snap.edges).toContainEqual({
+			from: "idx.range#0.delta",
+			to: "idx.range#0.snapshot",
+		});
+		idx.range("a", "z").dispose();
+		const after = g.describe();
+		expect(after.edges).not.toContainEqual({ from: "idx.delta", to: "idx.range#0.delta" });
+		expect(after.nodes.map((n) => n.id)).not.toContain("idx.range#0.delta");
+		expect(after.nodes.map((n) => n.id)).not.toContain("idx.range#0.snapshot");
+	});
+
+	it("range viewCache evicts only memo refs, not live D121 view nodes", () => {
+		const g = graph();
+		const idx = reactiveIndex<string, number>({
+			graph: g,
+			name: "idx",
+			viewCache: { maxEntries: 1 },
+		});
+
+		const first = idx.range("a", "c");
+		const second = idx.range("c", "z");
+
+		expect(idx.range("c", "z")).toBe(second);
+		expect(idx.range("a", "c")).not.toBe(first);
+		expect(g.find("idx.range#0.delta")).toBe(first.delta);
+		expect(g.find("idx.range#1.delta")).toBe(second.delta);
+		first.dispose();
+		expect(g.find("idx.range#0.delta")).toBeUndefined();
+		idx.dispose();
+		expect(
+			g
+				.describe()
+				.nodes.map((n) => n.id)
+				.filter((id) => id.includes(".range#")),
+		).toEqual([]);
+	});
+
+	it("empty upsertMany/deleteMany are no-op deltas", () => {
+		const idx = reactiveIndex<string, number>();
+		const { msgs } = collect(idx.delta);
+		msgs.length = 0;
+		idx.upsertMany([]);
+		idx.deleteMany([]);
+		expect(msgs).toEqual([]);
+		expect(idx.toArray()).toEqual([]);
+	});
+
+	it("upsertMany/deleteMany accept generator inputs and ignore missing deletes", () => {
+		function* rows(): Generator<{ primary: string; secondary: number; value: number }> {
+			yield { primary: "b", secondary: 2, value: 20 };
+			yield { primary: "a", secondary: 1, value: 10 };
+		}
+		function* primaries(): Generator<string> {
+			yield "missing";
+			yield "b";
+			yield "also-missing";
+		}
+
+		const idx = reactiveIndex<string, number>();
+		const { msgs } = collect(idx.delta);
+		idx.upsertMany(rows());
+		idx.deleteMany(primaries());
+
+		expect(data(msgs)).toEqual([
+			{ kind: "upsert", primary: "b", secondary: 2, value: 20 },
+			{ kind: "upsert", primary: "a", secondary: 1, value: 10 },
+			{ kind: "deleteMany", primaries: ["b"] },
+		]);
+		expect(idx.toArray().map((r) => r.primary)).toEqual(["a"]);
+	});
+
+	it("updating comparator-equal primary objects removes the exact existing row", () => {
+		const idx = reactiveIndex<object, string>();
+		const a = { id: 1 };
+		const b = { id: 2 };
+		idx.upsert(a, 1, "a");
+		idx.upsert(b, 1, "b");
+		expect(idx.upsert(b, 1, "bb")).toBe(false);
+		expect(idx.get(a)).toBe("a");
+		expect(idx.get(b)).toBe("bb");
+		expect(idx.toArray()).toHaveLength(2);
+	});
+
+	it("byPrimary is an OPTIONAL reactive derived (pushed primary→value map)", () => {
+		const idx = reactiveIndex<string, number>();
+		const { msgs } = collect(idx.byPrimary);
+		idx.upsert("a", 1, 10);
+		idx.upsert("b", 2, 20);
+		const last = data<ReadonlyMap<string, number>>(msgs).at(-1);
+		expect([...(last ?? new Map())]).toEqual([
+			["a", 10],
+			["b", 20],
+		]);
+	});
+
+	it("D73 secondary capacity evicts by (secondary,primary) order (primary tie-break)", () => {
+		const idx = reactiveIndex<string, number>({
+			capacity: { maxSize: 2, order: "secondary" },
+		});
+		const { msgs } = collect(idx.delta);
+		idx.upsert("id2", 5, 2);
+		idx.upsert("id3", 5, 3);
+		idx.upsert("id1", 5, 1); // same secondary: smallest primary ("id1") evicts first
+		expect(data(msgs)).toEqual([
+			{ kind: "upsert", primary: "id2", secondary: 5, value: 2 },
+			{ kind: "upsert", primary: "id3", secondary: 5, value: 3 },
+			{ kind: "upsert", primary: "id1", secondary: 5, value: 1 },
+			{ kind: "delete", primary: "id1" },
+		]);
+		expect(idx.toArray().map((r) => r.primary)).toEqual(["id2", "id3"]);
+	});
+
+	it("D73 primary capacity evicts by primary key order, independent from secondary order", () => {
+		const idx = reactiveIndex<string, number>({
+			capacity: { maxSize: 2, order: "primary" },
+		});
+		const { msgs } = collect(idx.delta);
+		idx.upsert("a", 100, 1);
+		idx.upsert("c", 0, 3);
+		idx.upsert("b", 999, 2); // overflow -> evict smallest primary ("a")
+		expect(data(msgs)).toEqual([
+			{ kind: "upsert", primary: "a", secondary: 100, value: 1 },
+			{ kind: "upsert", primary: "c", secondary: 0, value: 3 },
+			{ kind: "upsert", primary: "b", secondary: 999, value: 2 },
+			{ kind: "delete", primary: "a" },
+		]);
+		expect(idx.toArray().map((r) => r.primary)).toEqual(["c", "b"]); // snapshot order still by secondary
+	});
+
+	it("D73 lru capacity touches on upsert/get/has, but NOT rangeByPrimary", () => {
+		const idx = reactiveIndex<string, number>({
+			capacity: { maxSize: 2, order: "lru" },
+		});
+		const { msgs } = collect(idx.delta);
+		idx.upsert("a", 1, 1);
+		idx.upsert("b", 2, 2);
+		expect(idx.get("a")).toBe(1); // touch a, so b becomes LRU
+		idx.upsert("c", 3, 3); // evict b
+		expect(idx.has("a")).toBe(true); // touch a again, so c becomes LRU
+		expect(idx.rangeByPrimary("a", "z")).toEqual([1, 3]); // must not affect LRU
+		idx.upsert("d", 4, 4); // evict c if rangeByPrimary is non-touching
+		expect(data(msgs)).toEqual([
+			{ kind: "upsert", primary: "a", secondary: 1, value: 1 },
+			{ kind: "upsert", primary: "b", secondary: 2, value: 2 },
+			{ kind: "upsert", primary: "c", secondary: 3, value: 3 },
+			{ kind: "delete", primary: "b" },
+			{ kind: "upsert", primary: "d", secondary: 4, value: 4 },
+			{ kind: "delete", primary: "c" },
+		]);
+		expect(idx.has("b")).toBe(false);
+		expect(idx.has("c")).toBe(false);
+		expect(idx.has("a")).toBe(true);
+		expect(idx.has("d")).toBe(true);
+	});
+
+	it("D73 lru capacity treats an existing-key upsert as a touch", () => {
+		const idx = reactiveIndex<string, number>({
+			capacity: { maxSize: 2, order: "lru" },
+		});
+		const { msgs } = collect(idx.delta);
+		idx.upsert("a", 1, 1);
+		idx.upsert("b", 2, 2);
+		expect(idx.upsert("a", 1, 10)).toBe(false); // update should refresh "a"
+		idx.upsert("c", 3, 3);
+		expect(data(msgs)).toEqual([
+			{ kind: "upsert", primary: "a", secondary: 1, value: 1 },
+			{ kind: "upsert", primary: "b", secondary: 2, value: 2 },
+			{ kind: "upsert", primary: "a", secondary: 1, value: 10 },
+			{ kind: "upsert", primary: "c", secondary: 3, value: 3 },
+			{ kind: "delete", primary: "b" },
+		]);
+		expect(idx.toArray().map((r) => [r.primary, r.value])).toEqual([
+			["a", 10],
+			["c", 3],
+		]);
+	});
+
+	it("D73 static capacity maxSize installs a graph-visible policy/apply edge", () => {
+		const g = graph();
+		const idx = reactiveIndex<string, number>({
+			graph: g,
+			name: "idx",
+			capacity: { maxSize: 2, order: "secondary" },
+		});
+		idx.upsert("a", 1, 1);
+		const snap = g.describe();
+		expect(snap.nodes.find((n) => n.id === "idx.maxSizePolicy")?.factory).toBe(
+			"reactiveIndex.maxSizePolicy",
+		);
+		expect(snap.nodes.find((n) => n.id === "idx.capacityPolicy")?.factory).toBe(
+			"reactiveIndex.capacityPolicy",
+		);
+		expect(snap.edges).toContainEqual({ from: "idx.maxSizePolicy", to: "idx.capacityPolicy" });
+	});
+
+	it("D73 Node-valued capacity maxSize is describe-visible and downsizing emits per-row delete", () => {
+		const g = graph();
+		const max = g.state(3, { name: "max" });
+		const idx = reactiveIndex<string, number>({
+			graph: g,
+			name: "idx",
+			capacity: { maxSize: max, order: "primary" },
+		});
+		const { msgs } = collect(idx.delta);
+		idx.upsert("a", 1, 1);
+		idx.upsert("b", 2, 2);
+		idx.upsert("c", 3, 3);
+		max.set(1);
+		expect(data(msgs)).toEqual([
+			{ kind: "upsert", primary: "a", secondary: 1, value: 1 },
+			{ kind: "upsert", primary: "b", secondary: 2, value: 2 },
+			{ kind: "upsert", primary: "c", secondary: 3, value: 3 },
+			{ kind: "delete", primary: "a" },
+			{ kind: "delete", primary: "b" },
+		]);
+		expect(idx.toArray().map((r) => r.primary)).toEqual(["c"]);
+		expect(g.describe().edges).toContainEqual({ from: "max", to: "idx.capacityPolicy" });
+		expect(g.describe().nodes.find((n) => n.id === "idx.capacityPolicy")?.factory).toBe(
+			"reactiveIndex.capacityPolicy",
+		);
+	});
+
+	it("D73 per-row capacity deletes expose intermediate byPrimary states", () => {
+		const g = graph();
+		const max = g.state(3, { name: "max" });
+		const idx = reactiveIndex<string, number>({
+			graph: g,
+			name: "idx",
+			capacity: { maxSize: max, order: "primary" },
+		});
+		const { msgs } = collect(idx.byPrimary);
+		idx.upsert("a", 1, 1);
+		idx.upsert("b", 2, 2);
+		idx.upsert("c", 3, 3);
+		max.set(1);
+		expect(data<ReadonlyMap<string, number>>(msgs).map((m) => [...m.keys()])).toEqual([
+			["a"],
+			["a", "b"],
+			["a", "b", "c"],
+			["b", "c"],
+			["c"],
+		]);
+	});
+
+	it("D73 Node-valued capacity maxSize requires graph binding", () => {
+		const g = graph();
+		const max = g.state(1);
+		expect(() =>
+			reactiveIndex<string, number>({ capacity: { maxSize: max, order: "secondary" } }),
+		).toThrow(/requires options.graph/);
+	});
+
+	it("D73 Node-valued capacity maxSize rejects foreign-graph deps", () => {
+		const g1 = graph();
+		const foreign = g1.state(2, { name: "foreignMax" });
+		const g2 = graph();
+		expect(() =>
+			reactiveIndex<string, number>({
+				graph: g2,
+				name: "idx",
+				capacity: { maxSize: foreign, order: "secondary" },
+			}),
+		).toThrow(/different graph/);
+	});
+
+	it("D73 Node policy + upsertFrom share one graph-visible apply path", () => {
+		const g = graph();
+		const max = g.state(2, { name: "max" });
+		const src = g.state({ primary: "seed", secondary: 0, value: 0 }, { name: "src" });
+		const idx = reactiveIndex<string, number>({
+			graph: g,
+			name: "idx",
+			capacity: { maxSize: max, order: "primary" },
+		});
+		const { msgs } = collect(idx.delta);
+		idx.upsertFrom(src);
+		src.set({ primary: "a", secondary: 1, value: 1 });
+		src.set({ primary: "b", secondary: 2, value: 2 });
+		max.set(1);
+		expect(data(msgs)).toEqual([
+			{ kind: "upsert", primary: "seed", secondary: 0, value: 0 },
+			{ kind: "upsert", primary: "a", secondary: 1, value: 1 },
+			{ kind: "upsert", primary: "b", secondary: 2, value: 2 },
+			{ kind: "delete", primary: "a" },
+			{ kind: "delete", primary: "b" },
+		]);
+		expect(g.describe().edges).toContainEqual({ from: "max", to: "idx.capacityPolicy" });
+		expect(g.describe().edges).toContainEqual({ from: "idx.bind#0", to: "idx.capacityPolicy" });
+	});
+});
+
+describe("reactiveLog (D60 #5) — incremental view/scan + SENTINEL reject + declared-dep merge", () => {
+	it("append emits deltas; snapshot delivers the full array on demand", () => {
+		const log = reactiveLog<string>();
+		const { msgs } = collect(log.snapshot);
+		log.append("a");
+		log.append("b");
+		demand(log.snapshot as Node<unknown>, log.pullId);
+		expect(data(msgs)).toEqual([["a", "b"]]);
+	});
+
+	it("tail(n) is an incremental derived on the delta backbone", () => {
+		const log = reactiveLog<number>();
+		const { msgs } = collect(log.tail(2));
+		log.append(1);
+		log.append(2);
+		log.append(3);
+		expect(data(msgs).at(-1)).toEqual([2, 3]);
+	});
+
+	it("slice(start, stop?) is an incremental positional view on the delta backbone", () => {
+		const log = reactiveLog<number>([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
+		const window = log.slice(2, 5);
+		const toEnd = log.slice(7);
+		const { msgs: windowMsgs } = collect(window);
+		const { msgs: toEndMsgs } = collect(toEnd);
+
+		expect(data(windowMsgs)).toEqual([]);
+		expect(data(toEndMsgs)).toEqual([]);
+
+		log.append(10);
+		expect(data(windowMsgs).at(-1)).toEqual([2, 3, 4]);
+		expect(data(toEndMsgs).at(-1)).toEqual([7, 8, 9, 10]);
+	});
+
+	it("page(offset,limit) is a D121 light view with forwarded delta + pulled snapshot", () => {
+		const log = reactiveLog<number>([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
+		const page = log.page(2, 3);
+		const { msgs: deltaMsgs } = collect(page.delta);
+		const { msgs: snapshotMsgs } = collect(page.snapshot);
+
+		log.append(10);
+
+		expect(data(deltaMsgs).at(-1)).toEqual({ kind: "append", value: 10 });
+		demand(page.snapshot as Node<unknown>, page.pullId);
+		expect(data(snapshotMsgs).at(-1)).toEqual([2, 3, 4]);
+		expect(log.page(2, 3)).toBe(page);
+		page.dispose();
+		expect(log.page(2, 3)).not.toBe(page);
+		expect(() => log.page(-1, 3)).toThrow(RangeError);
+		expect(() => log.page(0, -1)).toThrow(RangeError);
+	});
+
+	it("page light views register through the graph funnel when options.graph is present", () => {
+		const g = graph();
+		const log = reactiveLog<number>([], { graph: g, name: "log" });
+		const page = log.page(0, 2);
+
+		const snap = g.describe();
+		expect(snap.nodes.find((n) => n.id === "log.delta")?.factory).toBe("reactiveLog.delta");
+		expect(snap.nodes.find((n) => n.id === "log.page#0.delta")?.factory).toBe(
+			"reactiveLog.page.delta",
+		);
+		expect(snap.nodes.find((n) => n.id === "log.page#0.snapshot")?.factory).toBe(
+			"reactiveLog.page.snapshot",
+		);
+		expect(snap.edges).toContainEqual({ from: "log.delta", to: "log.page#0.delta" });
+		expect(snap.edges).toContainEqual({
+			from: "log.page#0.delta",
+			to: "log.page#0.snapshot",
+		});
+		page.dispose();
+		const after = g.describe();
+		expect(after.edges).not.toContainEqual({ from: "log.delta", to: "log.page#0.delta" });
+		expect(after.nodes.map((n) => n.id)).not.toContain("log.page#0.delta");
+		expect(after.nodes.map((n) => n.id)).not.toContain("log.page#0.snapshot");
+		expect(g.find("log.page#0.delta")).toBeUndefined();
+		expect(g.checkpoint().nodes.map((n) => n.id)).not.toContain("log.page#0.delta");
+		expect(() => g.node([], null, { name: "log.page#0.delta" })).toThrow(
+			/released and cannot be reused/,
+		);
+		expect(() => page.delta.subscribe(() => {})).toThrow(/released from its graph lifecycle/);
+	});
+
+	it("page viewCache evicts only memo refs, not live D121 view nodes", () => {
+		const g = graph();
+		const log = reactiveLog<number>([0, 1, 2, 3], {
+			graph: g,
+			name: "log",
+			viewCache: { maxEntries: 1 },
+		});
+
+		const first = log.page(0, 1);
+		const second = log.page(1, 1);
+
+		expect(log.page(1, 1)).toBe(second);
+		expect(log.page(0, 1)).not.toBe(first);
+		expect(g.find("log.page#0.delta")).toBe(first.delta);
+		expect(g.find("log.page#1.delta")).toBe(second.delta);
+		first.dispose();
+		expect(g.find("log.page#0.delta")).toBeUndefined();
+		log.dispose();
+		expect(
+			g
+				.describe()
+				.nodes.map((n) => n.id)
+				.filter((id) => id.includes(".page#")),
+		).toEqual([]);
+	});
+
+	it("graph-bound view dispose rejects registered downstream deps outside the release group", () => {
+		const g = graph();
+		const log = reactiveLog<number>([], { graph: g, name: "log" });
+		const page = log.page(0, 2);
+		const downstream = g.node([page.snapshot as Node<unknown>], null, { name: "consumer" });
+
+		expect(() => page.dispose()).toThrow(/consumer.*still depends.*log\.page#0\.snapshot/);
+		expect(g.describe().nodes.map((n) => n.id)).toContain("log.page#0.snapshot");
+
+		downstream.replaceDeps([], () => {});
+		page.dispose();
+		const after = g.describe();
+		expect(after.nodes.map((n) => n.id)).not.toContain("log.page#0.delta");
+		expect(after.nodes.map((n) => n.id)).not.toContain("log.page#0.snapshot");
+		expect(after.nodes.map((n) => n.id).some((id) => id.startsWith("~reactiveLog.page"))).toBe(
+			false,
+		);
+	});
+
+	it("slice(start, stop) is memoized by range and validates non-negative integer bounds", () => {
+		const log = reactiveLog<number>();
+		const a = log.slice(1, 3);
+		const b = log.slice(1, 3);
+		const c = log.slice(1);
+		expect(a).toBe(b);
+		expect(a).not.toBe(c);
+		expect(() => log.slice(-1, 3)).toThrow(RangeError);
+		expect(() => log.slice(0, -1)).toThrow(RangeError);
+		expect(() => log.slice(1.5, 3)).toThrow(RangeError);
+	});
+
+	it("slice(start, stop) remains positional after trimHead shifts the backend", () => {
+		const log = reactiveLog<number>([10, 20, 30, 40, 50, 60, 70, 80]);
+		const window = log.slice(2, 5);
+		const { msgs } = collect(window);
+		expect(data(msgs)).toEqual([]);
+
+		log.trimHead(3);
+
+		expect(data(msgs).at(-1)).toEqual([60, 70, 80]);
+	});
+
+	it("tail and slice do not replay stale construction snapshots when subscribed cold", () => {
+		const log = reactiveLog<number>([1, 2, 3]);
+		const tail = log.tail(2);
+		const slice = log.slice(1);
+
+		log.append(4);
+
+		const { msgs: tailMsgs } = collect(tail);
+		const { msgs: sliceMsgs } = collect(slice);
+
+		expect(data(tailMsgs)).toEqual([[3, 4]]);
+		expect(data(sliceMsgs)).toEqual([[2, 3, 4]]);
+	});
+
+	it("tail and slice views settle consistently from the same delta diamond", () => {
+		const g = graph();
+		const log = reactiveLog<number>();
+		const tail = log.tail(2);
+		const slice = log.slice(0, 3);
+		const joined = g.initNode(combine<readonly [readonly number[], readonly number[]]>(), [
+			tail,
+			slice,
+		]);
+		const { msgs } = collect(joined);
+
+		log.appendMany([10, 20, 30, 40, 50]);
+
+		expect(data(msgs).at(-1)).toEqual([
+			[40, 50],
+			[10, 20, 30],
+		]);
+	});
+
+	it("tail/slice/scan helpers bind to the collection dispatcher (D80 vocabulary only; runtime stays structure-owned)", () => {
+		const dispatcher = new CountingDispatcher();
+		const log = reactiveLog<number>([], { dispatcher });
+		expect(dispatcher.registerCount).toBe(1); // collectionCore snapshot pull node
+
+		log.tail(2);
+		log.slice(1, 3);
+		log.scan(0, (acc, value) => acc + value);
+
+		expect(dispatcher.registerCount).toBe(4);
+	});
+
+	it("scan folds incrementally; resets on clear", () => {
+		const log = reactiveLog<number>();
+		const sum = log.scan(0, (acc, v) => acc + v);
+		const { msgs } = collect(sum);
+		log.append(1);
+		log.append(2);
+		log.append(3);
+		expect(data(msgs).at(-1)).toBe(6);
+		log.clear();
+		expect(data(msgs).at(-1)).toBe(0);
+	});
+
+	it("scanLog is the standalone composition helper for log.scan", () => {
+		const log = reactiveLog<number>();
+		const product = scanLog(log, 1, (acc, v) => acc * v);
+		const { msgs } = collect(product);
+
+		log.appendMany([2, 3, 4]);
+		log.clear();
+
+		expect(data(msgs)).toEqual([24, 1]);
+		expect((product as Node<unknown> & { factory?: string }).factory).toBe("reactiveLog.scan");
+	});
+
+	it("scan refolds when maxSize overwrites the head without increasing length", () => {
+		const log = reactiveLog<number>([], { maxSize: 2 });
+		const sum = log.scan(0, (acc, v) => acc + v);
+		const { msgs } = collect(sum);
+		log.append(1);
+		log.append(2);
+		log.append(3);
+		expect(log.toArray()).toEqual([2, 3]);
+		expect(data(msgs).at(-1)).toBe(5);
+	});
+
+	it("append(undefined) throws — undefined is the substrate SENTINEL (R-data-payload)", () => {
+		const log = reactiveLog<number | undefined>();
+		expect(() => log.append(undefined)).toThrow(TypeError);
+		expect(() => log.appendMany([1, undefined as unknown as number])).toThrow(TypeError);
+	});
+
+	it("maxSize ring-buffer head-trims on overflow", () => {
+		const log = reactiveLog<number>([], { maxSize: 2 });
+		log.append(1);
+		log.append(2);
+		log.append(3); // evicts 1
+		expect(log.toArray()).toEqual([2, 3]);
+	});
+
+	it("bulk log deltas carry defensive copies", () => {
+		const log = reactiveLog<number>();
+		const { msgs } = collect(log.delta);
+		const values = [1, 2];
+		log.appendMany(values);
+		values[0] = 99;
+		expect(data(msgs)).toEqual([{ kind: "appendMany", values: [1, 2] }]);
+	});
+
+	it("empty log appendMany is a no-op delta where the array bulk API exists", () => {
+		const log = reactiveLog<number>([1]);
+		const { msgs } = collect(log.delta);
+		msgs.length = 0;
+		log.appendMany([]);
+		expect(msgs).toEqual([]);
+		expect(log.toArray()).toEqual([1]);
+	});
+
+	it("trimHead removes the oldest n", () => {
+		const log = reactiveLog<number>([1, 2, 3, 4]);
+		const { msgs } = collect(log.delta);
+		log.trimHead(2);
+		expect(data(msgs)).toEqual([{ kind: "trimHead", n: 2 }]);
+		expect(log.toArray()).toEqual([3, 4]);
+	});
+
+	it("mergeReactiveLogs is a DECLARED-DEP merge of N delta streams (no island, D45)", () => {
+		const a = reactiveLog<string>();
+		const b = reactiveLog<string>();
+		const merged = mergeReactiveLogs([a, b]);
+		const { msgs } = collect(merged);
+		a.append("a1");
+		b.append("b1");
+		a.append("a2");
+		expect(data(msgs)).toEqual([
+			{ kind: "append", value: "a1" },
+			{ kind: "append", value: "b1" },
+			{ kind: "append", value: "a2" },
+		]);
+	});
+});
+
+describe("real factory names (D6/D60)", () => {
+	it("the snapshot/delta nodes carry reactiveList.* factory names", () => {
+		const list = reactiveList<number>();
+		expect((list.delta as Node<unknown> & { factory?: string }).factory).toBe("reactiveList.delta");
+		expect((list.snapshot as Node<unknown> & { factory?: string }).factory).toBe(
+			"reactiveList.snapshot",
+		);
+	});
+});
diff --git a/packages/ts/src/__tests__/dispatcher.test.ts b/packages/ts/src/__tests__/dispatcher.test.ts
new file mode 100644
index 00000000..bd392ec7
--- /dev/null
+++ b/packages/ts/src/__tests__/dispatcher.test.ts
@@ -0,0 +1,91 @@
+import { describe, expect, it } from "vitest";
+import type { Ctx } from "../index.js";
+import { Dispatcher } from "../index.js";
+
+// invoke only forwards ctx to the fn; these probe fns ignore it.
+const ctx = {} as unknown as Ctx;
+
+describe("dispatcher handle GC (B15 / R-dispatch-all)", () => {
+	it("unregister frees the slot — the old handle is dead, invoking it throws", () => {
+		const d = new Dispatcher();
+		let ran = 0;
+		const h = d.register(() => {
+			ran++;
+		}, "sync");
+		d.invoke(h, ctx);
+		expect(ran).toBe(1);
+
+		d.unregister(h);
+		expect(() => d.invoke(h, ctx)).toThrow(); // freed slot → dead handle, not silently ran
+		expect(ran).toBe(1); // the dropped fn never runs again
+	});
+
+	it("register reuses a freed id → the fn table stays bounded under repeated fn-swap", () => {
+		const d = new Dispatcher();
+		const h1 = d.register(() => {}, "sync");
+		d.unregister(h1);
+		const h2 = d.register(() => {}, "sync");
+		expect(h2.handleId).toBe(h1.handleId); // reused the freed slot, did not grow
+		expect(h2.poolId).toBe(h1.poolId);
+
+		// 100 swaps (register new, free old) stay bounded to peak-live, not +100 (the B15 leak).
+		let peak = h2.handleId;
+		let cur = h2;
+		for (let i = 0; i < 100; i++) {
+			const next = d.register(() => {}, "sync");
+			d.unregister(cur);
+			peak = Math.max(peak, next.handleId);
+			cur = next;
+		}
+		expect(peak).toBeLessThanOrEqual(h1.handleId + 1); // bounded, not h1.handleId + 100
+	});
+
+	it("unregister is idempotent and pool-scoped", () => {
+		const d = new Dispatcher();
+		let ranAsync = 0;
+		const hs = d.register(() => {}, "sync");
+		const ha = d.register(() => {
+			ranAsync++;
+		}, "async");
+		d.unregister(hs);
+		d.unregister(hs); // idempotent → no throw on a double free
+		d.invoke(ha, ctx); // the async pool is untouched by the sync-pool unregister
+		expect(ranAsync).toBe(1);
+		expect(ha.poolId).not.toBe(hs.poolId);
+	});
+
+	it("a reused handle id does not inherit the previous tenant's profile stat", () => {
+		const d = new Dispatcher();
+		d.setRecording(true);
+		const h1 = d.register(() => {}, "sync");
+		d.invoke(h1, ctx);
+		d.invoke(h1, ctx);
+		expect(d.statFor(h1)?.invokes).toBe(2);
+
+		d.unregister(h1); // clears the stat too
+		const h2 = d.register(() => {}, "sync");
+		expect(h2.handleId).toBe(h1.handleId); // same id reused
+		expect(d.statFor(h2)?.invokes ?? 0).toBe(0); // fresh counters, not the stale 2
+	});
+
+	it("QA F2.1: unregister clears the stat even when recording is OFF (no later inheritance)", () => {
+		// The stale-stat trap: recording is OFF at unregister time, so a naive `if (recording)`
+		// delete would leave the key — then a reused id inherits it once recording resumes.
+		const d = new Dispatcher();
+		d.setRecording(true);
+		const h1 = d.register(() => {}, "sync");
+		d.invoke(h1, ctx);
+		d.invoke(h1, ctx);
+		expect(d.statFor(h1)?.invokes).toBe(2);
+
+		d.setRecording(false); // recording paused around the rewire/unregister window
+		d.unregister(h1); // must STILL drop the stat (unconditional delete, QA F2.1)
+		const h2 = d.register(() => {}, "sync");
+		expect(h2.handleId).toBe(h1.handleId); // free-list reused the id
+
+		d.setRecording(true); // resume — h2 must NOT see h1's stale count of 2
+		expect(d.statFor(h2)?.invokes ?? 0).toBe(0);
+		d.invoke(h2, ctx);
+		expect(d.statFor(h2)?.invokes).toBe(1); // counts from 0, not from the stale 2 → 3
+	});
+});
diff --git a/packages/ts/src/__tests__/environment-adapters.test.ts b/packages/ts/src/__tests__/environment-adapters.test.ts
new file mode 100644
index 00000000..d1d56a00
--- /dev/null
+++ b/packages/ts/src/__tests__/environment-adapters.test.ts
@@ -0,0 +1,605 @@
+import { describe, expect, it, vi } from "vitest";
+import { toHttp, webSocketSession } from "../adapters/index.js";
+import {
+	EnvironmentDrivers,
+	type HttpRequest,
+	type HttpResponse,
+	type WebSocketDriverEvent,
+	type WebSocketRequest,
+	type WebSocketSend,
+	type WebSocketSendResult,
+	type WebSocketSessionHandle,
+} from "../graph/environment.js";
+import { graph } from "../graph/graph.js";
+import { retryPolicy } from "../graph/resilience.js";
+
+describe("environment outbound adapters (D130/D132)", () => {
+	it("routes outbound HTTP attempts and results through graph-visible nodes", () => {
+		const calls: Array<{
+			request: HttpRequest;
+			callback: (result: { ok: true; value: HttpResponse } | { ok: false; error: unknown }) => void;
+		}> = [];
+		const http = {
+			request(
+				request: HttpRequest,
+				callback: (
+					result: { ok: true; value: HttpResponse } | { ok: false; error: unknown },
+				) => void,
+			) {
+				calls.push({ request, callback });
+				return () => {};
+			},
+		};
+		const g = graph({ environment: new EnvironmentDrivers({ http }) });
+		const source = g.node<string>([], null, { name: "source" });
+		const bundle = toHttp(g, source, (value) => ({ method: "POST", url: "/events", body: value }), {
+			name: "egress",
+		});
+		const events: unknown[] = [];
+		const statuses: unknown[] = [];
+		bundle.events.subscribe((msg) => events.push(msg));
+		bundle.status.subscribe((msg) => statuses.push(msg));
+
+		source.down([["DATA", "alpha"]]);
+		expect(calls.map((call) => call.request)).toEqual([
+			{ method: "POST", url: "/events", body: "alpha" },
+		]);
+		calls[0]?.callback({
+			ok: true,
+			value: { status: 202, headers: [], body: new Uint8Array([1]) },
+		});
+
+		expect(events).toContainEqual(["DATA", { kind: "attempt", value: "alpha", attempt: 1 }]);
+		expect(events).toContainEqual([
+			"DATA",
+			{
+				kind: "sent",
+				value: "alpha",
+				attempt: 1,
+				result: { status: 202, headers: [], body: new Uint8Array([1]) },
+			},
+		]);
+		expect(statuses.at(-1)).toEqual([
+			"DATA",
+			{ state: "succeeded", inFlight: 0, attempt: 1, sent: 1, failed: 0 },
+		]);
+		const snap = g.describe();
+		expect(snap.edges).toContainEqual({ from: "source", to: "egress" });
+		expect(snap.edges).toContainEqual({ from: "egress", to: "egress/status" });
+	});
+
+	it("closes the status ledger when a send capability is missing", () => {
+		const g = graph();
+		const source = g.node<string>([], null, { name: "source" });
+		const bundle = toHttp(g, source, (value) => ({ method: "POST", url: "/events", body: value }), {
+			name: "egress",
+		});
+		const events: unknown[] = [];
+		const statuses: unknown[] = [];
+		bundle.events.subscribe((msg) => events.push(msg));
+		bundle.status.subscribe((msg) => statuses.push(msg));
+
+		source.down([["DATA", "alpha"]]);
+
+		expect(events).toContainEqual(["DATA", { kind: "attempt", value: "alpha", attempt: 1 }]);
+		expect(events).toContainEqual([
+			"DATA",
+			{
+				kind: "exhausted",
+				value: "alpha",
+				attempt: 1,
+				error: "egress: missing environment driver capability",
+			},
+		]);
+		expect(statuses).toContainEqual([
+			"DATA",
+			{ state: "exhausted", inFlight: 0, attempt: 1, sent: 0, failed: 1 },
+		]);
+	});
+
+	it("does not retain cancel handles after a synchronous driver callback completes", () => {
+		let canceled = 0;
+		const http = {
+			request(
+				_request: HttpRequest,
+				callback: (
+					result: { ok: true; value: HttpResponse } | { ok: false; error: unknown },
+				) => void,
+			) {
+				callback({ ok: true, value: { status: 204, headers: [] } });
+				return () => {
+					canceled++;
+				};
+			},
+		};
+		const g = graph({ environment: new EnvironmentDrivers({ http }) });
+		const source = g.node<string>([], null, { name: "source" });
+		const bundle = toHttp(g, source, (value) => ({ method: "POST", url: "/events", body: value }), {
+			name: "egress",
+		});
+		const unsubscribe = bundle.events.subscribe(() => {});
+
+		source.down([["DATA", "alpha"]]);
+		unsubscribe();
+
+		expect(canceled).toBe(0);
+	});
+});
+
+describe("environment session adapters (D133)", () => {
+	it("exposes a describe-visible WebSocket SessionBundle over command facts", () => {
+		const connects: Array<{
+			request: WebSocketRequest;
+			callback: (event: WebSocketDriverEvent) => void;
+		}> = [];
+		const sends: Array<{
+			request: WebSocketRequest;
+			message: WebSocketSend;
+			callback: (
+				result: { ok: true; value: WebSocketSendResult } | { ok: false; error: unknown },
+			) => void;
+		}> = [];
+		let canceled = 0;
+		const closes: Array<{ code?: number; reason?: string }> = [];
+		const websocket = {
+			connectSession(request: WebSocketRequest, callback: (event: WebSocketDriverEvent) => void) {
+				connects.push({ request, callback });
+				const handle: WebSocketSessionHandle = {
+					send(message, sendCallback) {
+						sends.push({ request, message, callback: sendCallback });
+						return () => {};
+					},
+					close(code, reason) {
+						closes.push({ code, reason });
+					},
+					cancel() {
+						canceled++;
+					},
+				};
+				return handle;
+			},
+		};
+		const g = graph({ environment: new EnvironmentDrivers({ websocket }) });
+		const bundle = webSocketSession(g, { url: "ws://example.test/socket" }, { name: "session" });
+		const inbound: unknown[] = [];
+		const lifecycle: unknown[] = [];
+		const outbound: unknown[] = [];
+		const statuses: unknown[] = [];
+		const attempts: unknown[] = [];
+		const errors: unknown[] = [];
+		bundle.inbound.subscribe((msg) => inbound.push(msg));
+		bundle.lifecycle.subscribe((msg) => lifecycle.push(msg));
+		bundle.outbound.subscribe((msg) => outbound.push(msg));
+		bundle.status.subscribe((msg) => statuses.push(msg));
+		bundle.attempts.subscribe((msg) => attempts.push(msg));
+		bundle.errors.subscribe((msg) => {
+			if (msg[0] === "DATA") errors.push(msg);
+		});
+
+		bundle.start();
+		connects[0]?.callback({ kind: "event", event: { kind: "open" } });
+		bundle.send("hello");
+		sends[0]?.callback({ ok: true, value: { sent: true } });
+		connects[0]?.callback({ kind: "event", event: { kind: "text", data: "world" } });
+		bundle.close(1000, "done");
+
+		expect(connects.map((call) => call.request)).toEqual([{ url: "ws://example.test/socket" }]);
+		expect(sends.map((call) => call.message)).toEqual([{ data: "hello" }]);
+		expect(closes).toEqual([{ code: 1000, reason: "done" }]);
+		expect(attempts).toContainEqual(["DATA", 1]);
+		expect(lifecycle).toContainEqual(["DATA", { kind: "starting", attempt: 1, maxAttempts: 1 }]);
+		expect(lifecycle).toContainEqual(["DATA", { kind: "open", attempt: 1 }]);
+		expect(lifecycle).toContainEqual(["DATA", { kind: "sent", message: { data: "hello" } }]);
+		expect(outbound).toContainEqual([
+			"DATA",
+			{ kind: "sending", seq: 0, message: { data: "hello" } },
+		]);
+		expect(outbound).toContainEqual(["DATA", { kind: "sent", seq: 0, message: { data: "hello" } }]);
+		expect(lifecycle).toContainEqual(["DATA", { kind: "closing", code: 1000, reason: "done" }]);
+		expect(lifecycle).toContainEqual(["DATA", { kind: "closed", code: 1000, reason: "done" }]);
+		expect(inbound).toContainEqual(["DATA", { kind: "text", data: "world" }]);
+		expect(statuses.at(-1)).toEqual([
+			"DATA",
+			{
+				state: "closed",
+				attempt: 1,
+				maxAttempts: 1,
+				sent: 1,
+				received: 1,
+				errors: 0,
+				lastDelayMs: undefined,
+			},
+		]);
+		expect(errors).toEqual([]);
+		expect(canceled).toBe(0);
+		const snap = g.describe();
+		expect(snap.nodes.map((node) => node.id).sort()).toEqual([
+			"session/attempts",
+			"session/command",
+			"session/errors",
+			"session/events",
+			"session/inbound",
+			"session/lifecycle",
+			"session/outbound",
+			"session/status",
+		]);
+		expect(snap.edges).toContainEqual({ from: "session/command", to: "session/events" });
+		expect(snap.edges).toContainEqual({ from: "session/events", to: "session/inbound" });
+		expect(snap.edges).toContainEqual({ from: "session/events", to: "session/lifecycle" });
+		expect(snap.edges).toContainEqual({ from: "session/events", to: "session/outbound" });
+		expect(snap.edges).toContainEqual({ from: "session/events", to: "session/status" });
+		expect(snap.edges).toContainEqual({ from: "session/events", to: "session/errors" });
+		expect(snap.edges).toContainEqual({ from: "session/events", to: "session/attempts" });
+	});
+
+	it("keeps convenience start/send/close as command fact publishers", () => {
+		const connects: WebSocketRequest[] = [];
+		const websocket = {
+			connectSession(request: WebSocketRequest, _callback: (event: WebSocketDriverEvent) => void) {
+				connects.push(request);
+				return {
+					send() {
+						return () => {};
+					},
+					close() {},
+					cancel() {},
+				} satisfies WebSocketSessionHandle;
+			},
+		};
+		const g = graph({ environment: new EnvironmentDrivers({ websocket }) });
+		const bundle = webSocketSession(g, { url: "ws://example.test/socket" }, { name: "session" });
+		const commands: unknown[] = [];
+		bundle.command.subscribe((msg) => {
+			if (msg[0] === "DATA") commands.push(msg);
+		});
+
+		bundle.start();
+		bundle.send({ data: "hello" });
+		bundle.close(1001, "bye");
+
+		expect(commands).toEqual([
+			["DATA", { kind: "start" }],
+			["DATA", { kind: "send", message: { data: "hello" } }],
+			["DATA", { kind: "close", code: 1001, reason: "bye" }],
+		]);
+		expect(connects).toEqual([]);
+	});
+
+	it("rejects send-before-open by default through errors and outbound facts", () => {
+		const sends: WebSocketSend[] = [];
+		const websocket = {
+			connectSession(_request: WebSocketRequest, _callback: (event: WebSocketDriverEvent) => void) {
+				return {
+					send(message, sendCallback) {
+						sends.push(message);
+						sendCallback({ ok: true, value: { sent: true } });
+						return () => {};
+					},
+					close() {},
+					cancel() {},
+				} satisfies WebSocketSessionHandle;
+			},
+		};
+		const g = graph({ environment: new EnvironmentDrivers({ websocket }) });
+		const bundle = webSocketSession(g, { url: "ws://example.test/socket" }, { name: "session" });
+		const outbound: unknown[] = [];
+		const errors: unknown[] = [];
+		const statuses: unknown[] = [];
+		bundle.outbound.subscribe((msg) => outbound.push(msg));
+		bundle.errors.subscribe((msg) => errors.push(msg));
+		bundle.status.subscribe((msg) => statuses.push(msg));
+
+		bundle.send("early");
+
+		expect(sends).toEqual([]);
+		expect(outbound).toContainEqual([
+			"DATA",
+			{
+				kind: "rejected",
+				seq: 0,
+				message: { data: "early" },
+				error: "session: session is not open",
+			},
+		]);
+		expect(errors).toContainEqual(["DATA", "session: session is not open"]);
+		expect(statuses.at(-1)).toEqual([
+			"DATA",
+			{
+				state: "errored",
+				attempt: 0,
+				maxAttempts: 1,
+				sent: 0,
+				received: 0,
+				errors: 1,
+			},
+		]);
+	});
+
+	it("buffers send-before-open only when bounded opt-in policy is declared", () => {
+		const sends: Array<{
+			message: WebSocketSend;
+			callback: (
+				result: { ok: true; value: WebSocketSendResult } | { ok: false; error: unknown },
+			) => void;
+		}> = [];
+		let connectCallback: ((event: WebSocketDriverEvent) => void) | undefined;
+		const websocket = {
+			connectSession(_request: WebSocketRequest, callback: (event: WebSocketDriverEvent) => void) {
+				connectCallback = callback;
+				return {
+					send(message, sendCallback) {
+						sends.push({ message, callback: sendCallback });
+						return () => {};
+					},
+					close() {},
+					cancel() {},
+				} satisfies WebSocketSessionHandle;
+			},
+		};
+		const g = graph({ environment: new EnvironmentDrivers({ websocket }) });
+		const bundle = webSocketSession(
+			g,
+			{ url: "ws://example.test/socket" },
+			{ name: "session", sendPolicy: { kind: "buffer", maxPending: 2 } },
+		);
+		const outbound: unknown[] = [];
+		bundle.outbound.subscribe((msg) => outbound.push(msg));
+
+		bundle.send("a");
+		bundle.send("b");
+		bundle.send("c");
+		bundle.start();
+
+		expect(sends).toEqual([]);
+		expect(outbound).toContainEqual(["DATA", { kind: "queued", seq: 0, message: { data: "a" } }]);
+		expect(outbound).toContainEqual(["DATA", { kind: "queued", seq: 1, message: { data: "b" } }]);
+		expect(outbound).toContainEqual([
+			"DATA",
+			{
+				kind: "rejected",
+				seq: 2,
+				message: { data: "c" },
+				error: "session: outbound buffer full",
+			},
+		]);
+
+		connectCallback?.({ kind: "event", event: { kind: "open" } });
+		expect(sends.map((send) => send.message)).toEqual([{ data: "a" }, { data: "b" }]);
+		sends[0]?.callback({ ok: true, value: { sent: true } });
+		sends[1]?.callback({ ok: true, value: { sent: true } });
+
+		expect(outbound).toContainEqual(["DATA", { kind: "sending", seq: 0, message: { data: "a" } }]);
+		expect(outbound).toContainEqual(["DATA", { kind: "sending", seq: 1, message: { data: "b" } }]);
+		expect(outbound).toContainEqual(["DATA", { kind: "sent", seq: 0, message: { data: "a" } }]);
+		expect(outbound).toContainEqual(["DATA", { kind: "sent", seq: 1, message: { data: "b" } }]);
+		expect(outbound.some((msg) => msg[0] === "DATA" && msg[1]?.kind === "ack")).toBe(false);
+		expect(outbound.some((msg) => msg[0] === "DATA" && msg[1]?.kind === "nack")).toBe(false);
+	});
+
+	it("surfaces bounded reconnect attempts, status, and errors", () => {
+		vi.useFakeTimers();
+		try {
+			const boom = new Error("boom");
+			const connects: Array<(event: WebSocketDriverEvent) => void> = [];
+			const websocket = {
+				connectSession(
+					_request: WebSocketRequest,
+					callback: (event: WebSocketDriverEvent) => void,
+				) {
+					connects.push(callback);
+					if (connects.length === 1) callback({ kind: "error", error: boom });
+					else callback({ kind: "event", event: { kind: "open" } });
+					return {
+						send() {
+							return () => {};
+						},
+						close() {},
+						cancel() {},
+					} satisfies WebSocketSessionHandle;
+				},
+			};
+			const g = graph({ environment: new EnvironmentDrivers({ websocket }) });
+			const bundle = webSocketSession(
+				g,
+				{ url: "ws://example.test/socket" },
+				{ name: "session", retry: retryPolicy(2, { kind: "constant", delayMs: 0 }) },
+			);
+			const attempts: unknown[] = [];
+			const statuses: unknown[] = [];
+			const errors: unknown[] = [];
+			bundle.attempts.subscribe((msg) => attempts.push(msg));
+			bundle.status.subscribe((msg) => statuses.push(msg));
+			bundle.errors.subscribe((msg) => errors.push(msg));
+
+			bundle.start();
+			expect(connects).toHaveLength(1);
+			expect(attempts).toContainEqual(["DATA", 1]);
+			expect(errors).toContainEqual(["DATA", boom]);
+			expect(statuses.at(-1)).toEqual([
+				"DATA",
+				{
+					state: "waiting",
+					attempt: 1,
+					maxAttempts: 2,
+					sent: 0,
+					received: 0,
+					errors: 1,
+					lastDelayMs: 0,
+				},
+			]);
+
+			vi.runOnlyPendingTimers();
+
+			expect(connects).toHaveLength(2);
+			expect(attempts).toContainEqual(["DATA", 2]);
+			expect(statuses.at(-1)).toEqual([
+				"DATA",
+				{
+					state: "open",
+					attempt: 2,
+					maxAttempts: 2,
+					sent: 0,
+					received: 0,
+					errors: 1,
+					lastDelayMs: undefined,
+				},
+			]);
+		} finally {
+			vi.useRealTimers();
+		}
+	});
+
+	it("suppresses late send callbacks after close", () => {
+		let sendCallback:
+			| ((result: { ok: true; value: WebSocketSendResult } | { ok: false; error: unknown }) => void)
+			| undefined;
+		const websocket = {
+			connectSession(_request: WebSocketRequest, callback: (event: WebSocketDriverEvent) => void) {
+				callback({ kind: "event", event: { kind: "open" } });
+				return {
+					send(_message, cb) {
+						sendCallback = cb;
+						return () => {};
+					},
+					close() {},
+					cancel() {},
+				} satisfies WebSocketSessionHandle;
+			},
+		};
+		const g = graph({ environment: new EnvironmentDrivers({ websocket }) });
+		const bundle = webSocketSession(g, { url: "ws://example.test/socket" }, { name: "session" });
+		const lifecycle: unknown[] = [];
+		const outbound: unknown[] = [];
+		const statuses: unknown[] = [];
+		bundle.lifecycle.subscribe((msg) => lifecycle.push(msg));
+		bundle.outbound.subscribe((msg) => outbound.push(msg));
+		bundle.status.subscribe((msg) => statuses.push(msg));
+
+		bundle.start();
+		bundle.send("late");
+		bundle.close(1000, "done");
+		sendCallback?.({ ok: true, value: { sent: true } });
+
+		expect(lifecycle).not.toContainEqual(["DATA", { kind: "sent", message: { data: "late" } }]);
+		expect(outbound).toContainEqual([
+			"DATA",
+			{ kind: "sending", seq: 0, message: { data: "late" } },
+		]);
+		expect(outbound).toContainEqual([
+			"DATA",
+			{
+				kind: "canceled",
+				seq: 0,
+				message: { data: "late" },
+				reason: "session: session closed",
+			},
+		]);
+		expect(outbound).not.toContainEqual([
+			"DATA",
+			{ kind: "sent", seq: 0, message: { data: "late" } },
+		]);
+		expect(statuses.at(-1)).toEqual([
+			"DATA",
+			{
+				state: "closed",
+				attempt: 1,
+				maxAttempts: 1,
+				sent: 0,
+				received: 0,
+				errors: 0,
+				lastDelayMs: undefined,
+			},
+		]);
+	});
+
+	it("cleans up remote closes and does not classify normal close as an error", () => {
+		let canceled = 0;
+		let connectCallback: ((event: WebSocketDriverEvent) => void) | undefined;
+		const websocket = {
+			connectSession(_request: WebSocketRequest, callback: (event: WebSocketDriverEvent) => void) {
+				connectCallback = callback;
+				return {
+					send() {
+						return () => {};
+					},
+					close() {},
+					cancel() {
+						canceled++;
+					},
+				} satisfies WebSocketSessionHandle;
+			},
+		};
+		const g = graph({ environment: new EnvironmentDrivers({ websocket }) });
+		const bundle = webSocketSession(g, { url: "ws://example.test/socket" }, { name: "session" });
+		const statuses: unknown[] = [];
+		const errors: unknown[] = [];
+		bundle.status.subscribe((msg) => statuses.push(msg));
+		bundle.errors.subscribe((msg) => {
+			if (msg[0] === "DATA") errors.push(msg);
+		});
+
+		bundle.start();
+		connectCallback?.({ kind: "event", event: { kind: "open" } });
+		connectCallback?.({ kind: "event", event: { kind: "close", code: 1000, reason: "ok" } });
+
+		expect(canceled).toBe(1);
+		expect(errors).toEqual([]);
+		expect(statuses.at(-1)).toEqual([
+			"DATA",
+			{
+				state: "closed",
+				attempt: 1,
+				maxAttempts: 1,
+				sent: 0,
+				received: 0,
+				errors: 0,
+				lastDelayMs: undefined,
+			},
+		]);
+	});
+
+	it("ignores explicit start while a retry timer is pending", () => {
+		vi.useFakeTimers();
+		try {
+			const connects: Array<(event: WebSocketDriverEvent) => void> = [];
+			const websocket = {
+				connectSession(
+					_request: WebSocketRequest,
+					callback: (event: WebSocketDriverEvent) => void,
+				) {
+					connects.push(callback);
+					if (connects.length === 1) callback({ kind: "error", error: "boom" });
+					return {
+						send() {
+							return () => {};
+						},
+						close() {},
+						cancel() {},
+					} satisfies WebSocketSessionHandle;
+				},
+			};
+			const g = graph({ environment: new EnvironmentDrivers({ websocket }) });
+			const bundle = webSocketSession(
+				g,
+				{ url: "ws://example.test/socket" },
+				{ name: "session", retry: retryPolicy(2, { kind: "constant", delayMs: 10 }) },
+			);
+			const attempts: unknown[] = [];
+			bundle.attempts.subscribe((msg) => attempts.push(msg));
+
+			bundle.start();
+			bundle.start();
+			expect(connects).toHaveLength(1);
+
+			vi.advanceTimersByTime(10);
+
+			expect(connects).toHaveLength(2);
+			expect(attempts.filter((msg) => msg[0] === "DATA")).toEqual([
+				["DATA", 1],
+				["DATA", 2],
+			]);
+		} finally {
+			vi.useRealTimers();
+		}
+	});
+});
diff --git a/packages/ts/src/__tests__/event-flow.test.ts b/packages/ts/src/__tests__/event-flow.test.ts
new file mode 100644
index 00000000..9d9799e3
--- /dev/null
+++ b/packages/ts/src/__tests__/event-flow.test.ts
@@ -0,0 +1,195 @@
+import { describe, expect, it } from "vitest";
+import { graph, type Node } from "../index.js";
+import {
+	type EventMessage,
+	eventMessage,
+	type MessageBusAvailablePage,
+	messageBus,
+} from "../messaging/index.js";
+import { type EventFlowRecord, eventFlow, eventFlowProjection } from "../patterns/event-flow.js";
+
+function collect<T>(node: Node<T>): T[] {
+	const seen: T[] = [];
+	node.subscribe((msg) => {
+		if (msg[0] === "DATA") seen.push(msg[1] as T);
+	});
+	return seen;
+}
+
+describe("eventFlow pattern (D326/D329/D331)", () => {
+	it("keeps EventMessage passive and validates only the vocabulary shape", () => {
+		const event = eventMessage("user.created", { userId: "u1" }, { id: "evt-1" });
+
+		expect(event).toEqual({
+			id: "evt-1",
+			type: "user.created",
+			payload: { userId: "u1" },
+		});
+	});
+
+	it("records direct EventMessage sources with projection high-water", () => {
+		const g = graph();
+		const source = g.state<unknown>(eventMessage("ignored", {}, { id: "initial" }), {
+			name: "events",
+		});
+		const flow = eventFlow(g, {
+			flowId: "orders",
+			name: "ordersFlow",
+			sources: [{ source: "direct", node: source }],
+			now: () => 100,
+		});
+		const records = collect(flow.records);
+		const highWater = collect(flow.highWater);
+		records.length = 0;
+		highWater.length = 0;
+
+		source.set(eventMessage("order.created", { orderId: "o1" }, { id: "evt-2" }));
+
+		expect(records).toEqual([
+			expect.objectContaining({
+				recordSeq: 2,
+				flowId: "orders",
+				observedAtMs: 100,
+				event: expect.objectContaining({ id: "evt-2", type: "order.created" }),
+				source: { source: "direct", messageId: "evt-2" },
+			}),
+		]);
+		expect(highWater.at(-1)).toEqual({
+			flowId: "orders",
+			recordSeq: 2,
+			auditSeq: 2,
+			sources: [{ source: "direct", messageId: "evt-2", recordSeq: 2 }],
+		});
+	});
+
+	it("emits DataIssue facts for malformed source facts instead of owning dead-letter policy", () => {
+		const g = graph();
+		const source = g.state<unknown>(eventMessage("ok", {}, { id: "initial" }));
+		const flow = eventFlow(g, {
+			flowId: "audit",
+			sources: [{ source: "direct", node: source }],
+			now: () => 10,
+		});
+		const issues = collect(flow.issues);
+		const status = collect(flow.status);
+		issues.length = 0;
+		status.length = 0;
+
+		source.set({ id: "broken" });
+
+		expect(issues).toEqual([
+			expect.objectContaining({
+				kind: "issue",
+				code: "malformed-event-message",
+				source: "eventFlow",
+			}),
+		]);
+		expect(status.at(-1)).toEqual(
+			expect.objectContaining({
+				kind: "rejected",
+				flowId: "audit",
+				issueCode: "malformed-event-message",
+			}),
+		);
+	});
+
+	it("consumes messageBus envelopes without owning subscription cursors", () => {
+		const g = graph();
+		const bus = messageBus(g, { topics: ["events"], now: () => 1 });
+		const sub = bus.subscription<EventMessage>({
+			topic: "events",
+			subscriptionId: "eventFlow-reader",
+		});
+		const flow = eventFlow(g, {
+			flowId: "busFlow",
+			sources: [{ source: "messageBus", node: bus.messages }],
+			now: () => 2,
+		});
+		const records = collect(flow.records);
+		const pages = collect<MessageBusAvailablePage<EventMessage>>(sub.available);
+
+		bus.publish("events", eventMessage("order.created", { orderId: "o1" }, { id: "evt-1" }));
+		sub.available.up([["PULL", { pullId: sub.availablePullId }]]);
+
+		expect(records).toEqual([
+			expect.objectContaining({
+				recordSeq: 1,
+				source: {
+					source: "messageBus",
+					topic: "events",
+					seq: 1,
+					messageId: "evt-1",
+				},
+			}),
+		]);
+		expect(pages.at(-1)?.cursor.nextSeq).toBe(1);
+		expect(pages.at(-1)?.messages).toHaveLength(1);
+	});
+
+	it("projects eventFlow records with projector high-water", () => {
+		const g = graph();
+		const source = g.state<unknown>(eventMessage("ignored", {}, { id: "initial" }));
+		const flow = eventFlow(g, {
+			flowId: "counts",
+			sources: [{ source: "direct", node: source }],
+			now: () => 1,
+		});
+		const projection = eventFlowProjection(g, flow, {
+			projectionId: "eventCounts",
+			initial: {} as Record<string, number>,
+			reduce(state, record: EventFlowRecord) {
+				return { ...state, [record.event.type]: (state[record.event.type] ?? 0) + 1 };
+			},
+			now: () => 2,
+		});
+		const snapshots = collect(projection.snapshot);
+		const highWater = collect(projection.highWater);
+		snapshots.length = 0;
+		highWater.length = 0;
+
+		source.set(eventMessage("order.created", {}, { id: "evt-1" }));
+		source.set(eventMessage("order.created", {}, { id: "evt-2" }));
+
+		expect(snapshots.at(-1)).toEqual({ ignored: 1, "order.created": 2 });
+		expect(highWater.at(-1)).toEqual(
+			expect.objectContaining({ flowId: "eventCounts", recordSeq: 3 }),
+		);
+	});
+
+	it("keeps projector high-water for every observed source coordinate", () => {
+		const g = graph();
+		const orders = g.state<unknown>(eventMessage("order.initial", {}, { id: "order-0" }));
+		const payments = g.state<unknown>(eventMessage("payment.initial", {}, { id: "payment-0" }));
+		const flow = eventFlow(g, {
+			flowId: "multi",
+			sources: [
+				{ source: "orders", node: orders },
+				{ source: "payments", node: payments },
+			],
+			now: () => 1,
+		});
+		const projection = eventFlowProjection(g, flow, {
+			projectionId: "multiProjection",
+			initial: [] as string[],
+			reduce(state, record: EventFlowRecord) {
+				return [...state, record.event.id];
+			},
+			now: () => 2,
+		});
+		const highWater = collect(projection.highWater);
+		highWater.length = 0;
+
+		orders.set(eventMessage("order.created", {}, { id: "order-1" }));
+		payments.set(eventMessage("payment.created", {}, { id: "payment-1" }));
+
+		expect(highWater.at(-1)).toEqual({
+			flowId: "multiProjection",
+			recordSeq: 4,
+			auditSeq: 0,
+			sources: [
+				{ source: "orders", messageId: "order-1", recordSeq: 3 },
+				{ source: "payments", messageId: "payment-1", recordSeq: 4 },
+			],
+		});
+	});
+});
diff --git a/packages/ts/src/__tests__/fixtures/protobuf/README.md b/packages/ts/src/__tests__/fixtures/protobuf/README.md
new file mode 100644
index 00000000..125ca208
--- /dev/null
+++ b/packages/ts/src/__tests__/fixtures/protobuf/README.md
@@ -0,0 +1,7 @@
+These protobuf golden vectors are vendored test fixtures copied from the
+language-neutral authority at:
+
+`~/src/graphrefly/spec/fixtures/protobuf/`
+
+They are kept here so the TypeScript package test suite is self-contained in
+CI. Update them only by syncing from the authority fixture set.
diff --git a/packages/ts/src/__tests__/fixtures/protobuf/wire_bridge_envelope.v1.jsonl b/packages/ts/src/__tests__/fixtures/protobuf/wire_bridge_envelope.v1.jsonl
new file mode 100644
index 00000000..b346e911
--- /dev/null
+++ b/packages/ts/src/__tests__/fixtures/protobuf/wire_bridge_envelope.v1.jsonl
@@ -0,0 +1,26 @@
+{"schema":"graphrefly.protobuf.golden.v1","id":"positive.data.value","message":"WireBridgeEnvelope","description":"DATA envelope with opaque StrictJsonFixtureValueV1 bytes","hex":"0a0273311215080110001a0473313a312001280142057265712d3122090a077b226e223a317d","canonical":true,"expect":{"payload":"data.value"}}
+{"schema":"graphrefly.protobuf.golden.v1","id":"positive.data.wire_edge_dirty","message":"WireBridgeEnvelope","description":"DATA envelope carrying WireEdgeFrame DIRTY with no value","hex":"0a027331120e080210011a0473313a32200128012215121308011206656467652d611a0763617573652d31","canonical":true,"expect":{"payload":"data.wire_edge.dirty"}}
+{"schema":"graphrefly.protobuf.golden.v1","id":"positive.data.wire_edge_data","message":"WireBridgeEnvelope","description":"DATA envelope carrying WireEdgeFrame DATA with value","hex":"0a027331120e080310021a0473313a33200128012222122008021206656467652d611a0763617573652d31220b7b226f6b223a747275657d","canonical":true,"expect":{"payload":"data.wire_edge.data"}}
+{"schema":"graphrefly.protobuf.golden.v1","id":"positive.ack","message":"WireBridgeEnvelope","description":"ACK envelope with metadata ack_for_seq and empty ack payload","hex":"0a0273311210080410031a0473313a342001280138032a00","canonical":true,"expect":{"payload":"ack"}}
+{"schema":"graphrefly.protobuf.golden.v1","id":"positive.nack","message":"WireBridgeEnvelope","description":"NACK envelope with ack_for_seq and opaque error fact bytes","hex":"0a0273311210080510031a0473313a3520012801380332120a107b226572726f72223a2262757379227d","canonical":true,"expect":{"payload":"nack"}}
+{"schema":"graphrefly.protobuf.golden.v1","id":"positive.data.empty_value","message":"WireBridgeEnvelope","description":"DATA envelope with present opaque value bytes of length zero; presence distinguishes DATA from missing body","hex":"0a027331120f081510001a0573313a32312001280122020a00","canonical":true,"expect":{"payload":"data.value"}}
+{"schema":"graphrefly.protobuf.golden.v1","id":"positive.data.wire_edge_data_empty_value","message":"WireBridgeEnvelope","description":"DATA envelope carrying WireEdgeFrame DATA with present value bytes of length zero","hex":"0a027331120f081610001a0573313a3232200128012217121508021206656467652d611a0763617573652d312200","canonical":true,"expect":{"payload":"data.wire_edge.data"}}
+{"schema":"graphrefly.protobuf.golden.v1","id":"negative.unknown_field","message":"WireBridgeEnvelope","description":"Unknown field appended to envelope","hex":"0a0273311215080110001a0473313a312001280142057265712d3122090a077b226e223a317d9a060178","canonical":false,"errorCategory":"unknown_field"}
+{"schema":"graphrefly.protobuf.golden.v1","id":"negative.duplicate_singular","message":"WireBridgeEnvelope","description":"Duplicate singular session_id","hex":"0a0273310a027332120e080110001a0473313a31200128011a00","canonical":false,"errorCategory":"duplicate_singular"}
+{"schema":"graphrefly.protobuf.golden.v1","id":"negative.noncanonical_order","message":"WireBridgeEnvelope","description":"Known fields out of canonical order","hex":"120e080110001a0473313a31200128010a0273311a00","canonical":false,"errorCategory":"noncanonical_bytes"}
+{"schema":"graphrefly.protobuf.golden.v1","id":"negative.default_optional_emission","message":"WireBridgeEnvelope","description":"Optional timestamp_ms encoded as zero default","hex":"0a0273311210080610001a0473313a362001280130001a00","canonical":false,"errorCategory":"default_emission"}
+{"schema":"graphrefly.protobuf.golden.v1","id":"negative.invalid_envelope_oneof","message":"WireBridgeEnvelope","description":"Envelope carries two payload oneof cases","hex":"0a0273311210080710001a0473313a372001280138011a002a00","canonical":false,"errorCategory":"invalid_oneof"}
+{"schema":"graphrefly.protobuf.golden.v1","id":"negative.invalid_data_oneof","message":"WireBridgeEnvelope","description":"WireBridgeDataPayload carries both value and wire_edge","hex":"0a027331120e080810001a0473313a3820012801221e0a077b226e223a317d121308011206656467652d611a0763617573652d32","canonical":false,"errorCategory":"invalid_oneof"}
+{"schema":"graphrefly.protobuf.golden.v1","id":"negative.data_missing_body","message":"WireBridgeEnvelope","description":"DATA envelope has WireBridgeDataPayload with no body","hex":"0a027331120e080910001a0473313a39200128012200","canonical":false,"errorCategory":"missing_required"}
+{"schema":"graphrefly.protobuf.golden.v1","id":"negative.ack_missing_ack_for_seq","message":"WireBridgeEnvelope","description":"ACK envelope lacks metadata.ack_for_seq","hex":"0a027331120f080a10001a0573313a3130200128012a00","canonical":false,"errorCategory":"missing_required"}
+{"schema":"graphrefly.protobuf.golden.v1","id":"negative.wire_edge_dirty_with_value","message":"WireBridgeEnvelope","description":"WireEdgeFrame DIRTY carries a value","hex":"0a027331120f080b10001a0573313a313120012801221e121c08011206656467652d611a0763617573652d3322077b226e223a317d","canonical":false,"errorCategory":"invalid_wire_edge"}
+{"schema":"graphrefly.protobuf.golden.v1","id":"negative.wire_edge_data_without_value","message":"WireBridgeEnvelope","description":"WireEdgeFrame DATA lacks value","hex":"0a027331120f080c10001a0573313a3132200128012215121308021206656467652d611a0763617573652d33","canonical":false,"errorCategory":"invalid_wire_edge"}
+{"schema":"graphrefly.protobuf.golden.v1","id":"negative.wire_edge_unspecified_kind","message":"WireBridgeEnvelope","description":"WireEdgeFrame uses WIRE_EDGE_KIND_UNSPECIFIED","hex":"0a027331120f080d10001a0573313a3133200128012215121308001206656467652d611a0763617573652d34","canonical":false,"errorCategory":"invalid_wire_edge"}
+{"schema":"graphrefly.protobuf.golden.v1","id":"negative.wire_edge_missing_edge_id","message":"WireBridgeEnvelope","description":"WireEdgeFrame has no edge_id","hex":"0a027331120f080e10001a0573313a313420012801220d120b08011a0763617573652d35","canonical":false,"errorCategory":"missing_required"}
+{"schema":"graphrefly.protobuf.golden.v1","id":"negative.wire_edge_missing_cause_id","message":"WireBridgeEnvelope","description":"WireEdgeFrame has no cause_id","hex":"0a027331120f080f10001a0573313a313520012801220c120a08011206656467652d61","canonical":false,"errorCategory":"missing_required"}
+{"schema":"graphrefly.protobuf.golden.v1","id":"negative.invalid_utf8_session_id","message":"WireBridgeEnvelope","description":"session_id bytes are not valid UTF-8","hex":"0a01ff120f081010001a0573313a3136200128011a00","canonical":false,"errorCategory":"malformed"}
+{"schema":"graphrefly.protobuf.golden.v1","id":"negative.nack_empty_optional_error","message":"WireBridgeEnvelope","description":"NACK optional error bytes are present as empty default bytes","hex":"0a0273311211081110001a0573313a313720012801380332020a00","canonical":false,"errorCategory":"default_emission"}
+{"schema":"graphrefly.protobuf.golden.v1","id":"negative.close_empty_optional_reason","message":"WireBridgeEnvelope","description":"CLOSE optional reason bytes are present as empty default bytes","hex":"0a027331120f081210001a0573313a3138200128014a020a00","canonical":false,"errorCategory":"default_emission"}
+{"schema":"graphrefly.protobuf.golden.v1","id":"negative.status_empty_required_bytes","message":"WireBridgeEnvelope","description":"STATUS payload bytes are required semantic fact bytes and must be non-empty","hex":"0a027331120f081310001a0573313a3139200128013a020a00","canonical":false,"errorCategory":"missing_required"}
+{"schema":"graphrefly.protobuf.golden.v1","id":"negative.error_empty_required_bytes","message":"WireBridgeEnvelope","description":"ERROR payload bytes are required semantic fact bytes and must be non-empty","hex":"0a027331120f081410001a0573313a32302001280142020a00","canonical":false,"errorCategory":"missing_required"}
+{"schema":"graphrefly.protobuf.golden.v1","id":"negative.old_wireframe_shape","message":"WireBridgeEnvelope","description":"Old WireFrame-style body field is unknown, not tolerated","hex":"0a027331120f080d10001a0573313a3133200128012209520767726170682d61","canonical":false,"errorCategory":"unknown_field"}
diff --git a/packages/ts/src/__tests__/fixtures/protobuf/wire_edge_frame.v1.jsonl b/packages/ts/src/__tests__/fixtures/protobuf/wire_edge_frame.v1.jsonl
new file mode 100644
index 00000000..d45dc0d5
--- /dev/null
+++ b/packages/ts/src/__tests__/fixtures/protobuf/wire_edge_frame.v1.jsonl
@@ -0,0 +1,12 @@
+{"schema":"graphrefly.protobuf.golden.v1","id":"positive.wire_edge.dirty","message":"WireEdgeFrame","description":"WireEdgeFrame DIRTY with edge_id and cause_id only","hex":"08011206656467652d611a0763617573652d31","canonical":true,"expect":{"kind":"dirty"}}
+{"schema":"graphrefly.protobuf.golden.v1","id":"positive.wire_edge.data","message":"WireEdgeFrame","description":"WireEdgeFrame DATA with StrictJsonFixtureValueV1 bytes","hex":"08021206656467652d611a0763617573652d31220b7b226f6b223a747275657d","canonical":true,"expect":{"kind":"data"}}
+{"schema":"graphrefly.protobuf.golden.v1","id":"positive.wire_edge.data_empty_value","message":"WireEdgeFrame","description":"WireEdgeFrame DATA with present value bytes of length zero; presence distinguishes DATA from missing value","hex":"08021206656467652d611a0763617573652d312200","canonical":true,"expect":{"kind":"data"}}
+{"schema":"graphrefly.protobuf.golden.v1","id":"negative.wire_edge.unknown_field","message":"WireEdgeFrame","description":"Unknown field appended to WireEdgeFrame","hex":"08011206656467652d611a0763617573652d319a060178","canonical":false,"errorCategory":"unknown_field"}
+{"schema":"graphrefly.protobuf.golden.v1","id":"negative.wire_edge.duplicate_singular","message":"WireEdgeFrame","description":"Duplicate singular kind field","hex":"080108021206656467652d611a0763617573652d31","canonical":false,"errorCategory":"duplicate_singular"}
+{"schema":"graphrefly.protobuf.golden.v1","id":"negative.wire_edge.noncanonical_order","message":"WireEdgeFrame","description":"Known WireEdgeFrame fields out of canonical order","hex":"1206656467652d6108011a0763617573652d31","canonical":false,"errorCategory":"noncanonical_bytes"}
+{"schema":"graphrefly.protobuf.golden.v1","id":"negative.wire_edge.unspecified_kind","message":"WireEdgeFrame","description":"WIRE_EDGE_KIND_UNSPECIFIED is not semantic DATA or DIRTY","hex":"08001206656467652d611a0763617573652d31","canonical":false,"errorCategory":"invalid_wire_edge"}
+{"schema":"graphrefly.protobuf.golden.v1","id":"negative.wire_edge.dirty_with_value","message":"WireEdgeFrame","description":"DIRTY frame must not carry value","hex":"08011206656467652d611a0763617573652d3122077b226e223a317d","canonical":false,"errorCategory":"invalid_wire_edge"}
+{"schema":"graphrefly.protobuf.golden.v1","id":"negative.wire_edge.data_without_value","message":"WireEdgeFrame","description":"DATA frame requires value","hex":"08021206656467652d611a0763617573652d31","canonical":false,"errorCategory":"invalid_wire_edge"}
+{"schema":"graphrefly.protobuf.golden.v1","id":"negative.wire_edge.missing_edge_id","message":"WireEdgeFrame","description":"WireEdgeFrame has no edge_id","hex":"08011a0763617573652d31","canonical":false,"errorCategory":"missing_required"}
+{"schema":"graphrefly.protobuf.golden.v1","id":"negative.wire_edge.missing_cause_id","message":"WireEdgeFrame","description":"WireEdgeFrame has no cause_id","hex":"08011206656467652d61","canonical":false,"errorCategory":"missing_required"}
+{"schema":"graphrefly.protobuf.golden.v1","id":"negative.wire_edge.invalid_utf8_edge_id","message":"WireEdgeFrame","description":"edge_id bytes are not valid UTF-8","hex":"08011201ff1a0763617573652d31","canonical":false,"errorCategory":"malformed"}
diff --git a/packages/ts/src/__tests__/framework-adapters.test.ts b/packages/ts/src/__tests__/framework-adapters.test.ts
new file mode 100644
index 00000000..abafa8f7
--- /dev/null
+++ b/packages/ts/src/__tests__/framework-adapters.test.ts
@@ -0,0 +1,115 @@
+import { describe, expect, expectTypeOf, it } from "vitest";
+import { nodeWritable } from "../adapters/svelte.js";
+import { graph } from "../graph/index.js";
+import { type BoundaryCapabilityRef, boundaryManifest } from "../inspection/boundary.js";
+
+describe("D238 framework adapter subpaths", () => {
+	it("derives a framework-neutral boundary manifest from describe topology", () => {
+		const g = graph({ name: "boundary" });
+		const amount = g.state(0, { name: "amount" });
+		const taxed = g.derived([amount], (value) => value + 1, { name: "taxed" });
+		g.derived([taxed], (value) => value * 2, { name: "total" });
+
+		const manifest = boundaryManifest(g);
+
+		expect(manifest.inputs.map((node) => node.name)).toEqual(["amount"]);
+		expect(manifest.outputs.map((node) => node.name)).toEqual(["total"]);
+		expect(manifest.inputs[0].role).toBe("input");
+		expect(manifest.inputs[0].type).toBe("state");
+		expect(manifest.inputs[0].node).toBe(amount);
+		expect(manifest.outputs[0].role).toBe("output");
+	});
+
+	it("derives mounted subgraph boundary nodes with live handles", () => {
+		const parent = graph({ name: "parent" });
+		const child = graph({ name: "child" });
+		const amount = child.state(1, { name: "amount" });
+		child.derived([amount], (value) => value * 2, { name: "total" });
+		parent.mount(child, { at: "child" });
+
+		const manifest = boundaryManifest(parent);
+
+		expect(parent.find("child::amount")).toBe(amount);
+		expect(manifest.inputs.map((node) => node.name)).toEqual(["child::amount"]);
+		expect(manifest.outputs.map((node) => node.name)).toEqual(["child::total"]);
+		expect(manifest.inputs[0].node).toBe(amount);
+	});
+
+	it("exposes only D348 generic capability refs without changing boundary roles", () => {
+		const g = graph({ name: "capabilities" });
+		const token = g.state("", {
+			name: "token",
+			meta: {
+				boundaryCapabilities: [
+					{ id: "github-oauth", kind: "auth", required: true, sourceRefs: ["github"] },
+					{ id: "repo-scope", kind: "permission", required: false },
+				],
+			},
+		});
+		const total = g.derived([token], (value) => value.length, {
+			name: "total",
+			meta: {
+				boundaryCapabilities: [
+					{ id: "repo-config", kind: "config", required: true },
+					{ id: "bad-widget", kind: "widget", required: true },
+					{ id: "bad-source-refs", kind: "resource", required: true, sourceRefs: [1] },
+				],
+			},
+		});
+
+		const manifest = boundaryManifest(g);
+
+		expect(manifest.inputs.map((node) => node.name)).toEqual(["token"]);
+		expect(manifest.outputs.map((node) => node.name)).toEqual(["total"]);
+		expect(manifest.inputs[0].node).toBe(token);
+		expect(manifest.outputs[0].node).toBe(total);
+		expect(manifest.inputs[0].capabilities).toEqual([
+			{ id: "github-oauth", kind: "auth", required: true, sourceRefs: ["github"] },
+			{ id: "repo-scope", kind: "permission", required: false },
+		]);
+		expect(manifest.outputs[0].capabilities).toEqual([
+			{ id: "repo-config", kind: "config", required: true },
+		]);
+		expectTypeOf(manifest.inputs[0].capabilities).toEqualTypeOf<
+			readonly BoundaryCapabilityRef[] | undefined
+		>();
+	});
+
+	it("does not surface product capability objects as boundary refs", () => {
+		const g = graph({ name: "product-capability" });
+		g.state(0, {
+			name: "amount",
+			meta: {
+				boundaryCapabilities: [
+					{ id: "ok", kind: "resource", required: true },
+					{ id: "oauth-flow", kind: "auth", required: true, provider: "github" },
+					{ id: "config-form", kind: "config", required: true, formSchema: { title: "Repo" } },
+				],
+			},
+		});
+
+		const manifest = boundaryManifest(g);
+
+		expect(manifest.inputs[0].capabilities).toEqual([
+			{ id: "ok", kind: "resource", required: true },
+		]);
+		expect(manifest.inputs[0].capabilities).not.toContainEqual(
+			expect.objectContaining({ id: "oauth-flow" }),
+		);
+		expect(manifest.inputs[0].capabilities).not.toContainEqual(
+			expect.objectContaining({ id: "config-form" }),
+		);
+	});
+
+	it("does not write undefined as ordinary DATA through writable helpers", () => {
+		const g = graph();
+		const count = g.state(1);
+		const writable = nodeWritable(count);
+
+		expect(() => {
+			(writable.set as (value: undefined) => void)(undefined);
+		}).toThrow(/SENTINEL\/no DATA/);
+
+		expect(count.cache).toBe(1);
+	});
+});
diff --git a/packages/ts/src/__tests__/graph-diagnostics.test.ts b/packages/ts/src/__tests__/graph-diagnostics.test.ts
new file mode 100644
index 00000000..87ae772d
--- /dev/null
+++ b/packages/ts/src/__tests__/graph-diagnostics.test.ts
@@ -0,0 +1,133 @@
+import { describe, expect, it } from "vitest";
+import {
+	type DescribeSnapshot,
+	explainPath,
+	graph,
+	reachable,
+	validateNoIslands,
+} from "../index.js";
+
+describe("graph diagnostics over DescribeSnapshot (D39/R-describe)", () => {
+	it("reachable walks upstream, downstream, and max-depth frontiers deterministically", () => {
+		const g = graph();
+		const a = g.state(1, { name: "a" });
+		const b = g.derived([a], (x) => x + 1, { name: "b" });
+		g.derived([b], (x) => x + 1, { name: "c" });
+		const sink = g.effect([a], () => {}, { name: "sink" });
+		sink.subscribe(() => {});
+
+		const snap = g.describe();
+		expect(reachable(snap, "c", "upstream")).toEqual(["a", "b"]);
+		expect(reachable(snap, "a", "downstream")).toEqual(["b", "c", "sink"]);
+		expect(reachable(snap, "b", "upstream", { both: true })).toEqual(["a", "c", "sink"]);
+
+		const detailed = reachable(snap, "a", "downstream", {
+			maxDepth: 1,
+			withDetail: true,
+		});
+		expect(detailed).toEqual({
+			paths: ["b", "sink"],
+			depths: { b: 1, sink: 1 },
+			truncated: true,
+		});
+		expect(reachable(snap, "a", "downstream", { maxDepth: 0, withDetail: true })).toEqual({
+			paths: [],
+			depths: {},
+			truncated: true,
+		});
+	});
+
+	it("explainPath returns a rich shortest causal chain without changing describe shape", () => {
+		const g = graph();
+		const a = g.state(1, { name: "a" });
+		const b = g.derived([a], (x) => x + 1, { name: "b" });
+		g.derived([b], (x) => x + 1, { name: "c" });
+
+		const snap = g.describe();
+		const chain = explainPath(snap, "a", "c");
+		expect(chain.found).toBe(true);
+		expect(chain.reason).toBe("ok");
+		expect(chain.steps.map((s) => s.id)).toEqual(["a", "b", "c"]);
+		expect(chain.steps.map((s) => s.hop)).toEqual([0, 1, 2]);
+		expect(chain.steps[0]).toMatchObject({ factory: "state", depIndex: 0 });
+		expect(chain.steps[1]).toMatchObject({ factory: "derived", depIndex: 0 });
+		expect(chain.text).toBe("a -> b -> c");
+		expect(chain.toJSON()).toMatchObject({ from: "a", to: "c", found: true });
+
+		expect(explainPath(snap, "missing", "c").reason).toBe("no-such-from");
+		expect(explainPath(snap, "a", "missing").reason).toBe("no-such-to");
+		expect(explainPath(snap, "c", "a", { maxDepth: 1 }).reason).toBe("no-path");
+	});
+
+	it("validateNoIslands reports mount-aware nodes with zero deps and zero dependents", () => {
+		const parent = graph();
+		const root = parent.state(0, { name: "root" });
+		parent.derived([root], (x) => x, { name: "rootD" });
+
+		const child = graph();
+		const leaf = child.state(1, { name: "leaf" });
+		child.derived([leaf], (x) => x, { name: "leafD" });
+		child.state(9, { name: "orphan" });
+		parent.mount(child, { at: "child" });
+
+		const result = validateNoIslands(parent.describe());
+		expect(result.ok).toBe(false);
+		expect(result.orphans).toEqual([{ id: "child::orphan", factory: "state" }]);
+		expect(result.summary()).toBe("validateNoIslands: 1 island node(s) - child::orphan (state)");
+	});
+
+	it("diagnostics also accept synthetic snapshots without requiring a Graph instance", () => {
+		const snap: DescribeSnapshot = {
+			nodes: [
+				{ id: "x", factory: "state", status: "sentinel", deps: [] },
+				{ id: "y", factory: "derived", status: "sentinel", deps: [] },
+			],
+			edges: [{ from: "x", to: "y" }],
+		};
+		expect(reachable(snap, "x", "downstream")).toEqual(["y"]);
+		expect(explainPath(snap, "x", "y").steps.map((s) => s.id)).toEqual(["x", "y"]);
+		expect(validateNoIslands(snap).ok).toBe(true);
+
+		const dangling: DescribeSnapshot = {
+			nodes: [
+				{ id: "x", factory: "state", status: "sentinel", deps: ["missing"] },
+				{ id: "y", factory: "derived", status: "sentinel", deps: [] },
+			],
+			edges: [
+				{ from: "x", to: "missing" },
+				{ from: "missing", to: "y" },
+			],
+		};
+		expect(reachable(dangling, "x", "downstream")).toEqual([]);
+		expect(explainPath(dangling, "x", "y").reason).toBe("no-path");
+	});
+
+	it("explainPath findCycle searches for a non-trivial self path in synthetic snapshots", () => {
+		const snap: DescribeSnapshot = {
+			nodes: [
+				{ id: "a", factory: "node", status: "sentinel", deps: ["b"] },
+				{ id: "b", factory: "node", status: "sentinel", deps: ["a"] },
+			],
+			edges: [
+				{ from: "b", to: "a" },
+				{ from: "a", to: "b" },
+			],
+		};
+		expect(explainPath(snap, "a", "a", { findCycle: true }).steps.map((s) => s.id)).toEqual([
+			"a",
+			"b",
+			"a",
+		]);
+		expect(explainPath(snap, "a", "a", { findCycle: true, maxDepth: 1 }).reason).toBe(
+			"max-depth-exceeded",
+		);
+
+		const selfLoop: DescribeSnapshot = {
+			nodes: [{ id: "a", factory: "node", status: "sentinel", deps: ["a"] }],
+			edges: [{ from: "a", to: "a" }],
+		};
+		expect(explainPath(selfLoop, "a", "a", { findCycle: true, maxDepth: 0 }).reason).toBe(
+			"max-depth-exceeded",
+		);
+	});
+});
diff --git a/packages/ts/src/__tests__/graph.part-01.test.ts b/packages/ts/src/__tests__/graph.part-01.test.ts
new file mode 100644
index 00000000..ddeafdaf
--- /dev/null
+++ b/packages/ts/src/__tests__/graph.part-01.test.ts
@@ -0,0 +1,458 @@
+import { describe, expect, expectTypeOf, it } from "vitest";
+import { depLatest } from "../ctx/types.js";
+import type {
+	GraphBlueprintJson,
+	GraphCheckpointJson,
+	GraphTopologySnapshot,
+	Message,
+	StrictJsonValue,
+} from "../index.js";
+import {
+	canonicalTopologyBytes,
+	canonicalTopologyJson,
+	GRAPH_BLUEPRINT_VERSION,
+	graph,
+	graphBlueprintDiagnostics,
+	type Node,
+	normalizeTopology,
+	strictCanonicalJsonBytes,
+	withBlueprintHash,
+	withBlueprintProvenance,
+} from "../index.js";
+
+function collect(n: { subscribe(s: (m: Message) => void): () => void }) {
+	const msgs: Message[] = [];
+	n.subscribe((m) => msgs.push(m));
+	return msgs;
+}
+function _demand(snapshot: Node<unknown>, pullId: symbol): void {
+	snapshot.up([["PULL", { pullId }]]);
+}
+const types = (msgs: Message[]) => msgs.map((m) => m[0]);
+const TEST_JSON_DECODER = new TextDecoder();
+const decodeTestJsonBytes = (bytes: Uint8Array) => TEST_JSON_DECODER.decode(bytes);
+const testHash = (bytes: Uint8Array) => `h:${decodeTestJsonBytes(bytes)}`;
+
+describe("Graph — 8-verb sugar (CSP-2)", () => {
+	it("state + derived: value-level fn computes from dep values (D27)", () => {
+		const g = graph();
+		const count = g.state(0);
+		const doubled = g.derived([count], (n) => n * 2);
+		collect(doubled);
+		expect(doubled.cache).toBe(0);
+		count.set(5);
+		expect(doubled.cache).toBe(10);
+	});
+
+	it("derived over multiple deps receives typed values in order", () => {
+		const g = graph();
+		const a = g.state(2);
+		const b = g.state(3);
+		const sum = g.derived([a, b], (x, y) => x + y);
+		collect(sum);
+		expect(sum.cache).toBe(5);
+		b.set(10);
+		expect(sum.cache).toBe(12);
+	});
+
+	it("effect runs on dep settle and registers a deactivation cleanup", () => {
+		const g = graph();
+		const s = g.state(1);
+		const seen: number[] = [];
+		let cleaned = 0;
+		const e = g.effect([s], (n) => {
+			seen.push(n);
+			return () => {
+				cleaned++;
+			};
+		});
+		const unsub = e.subscribe(() => {});
+		expect(seen).toEqual([1]);
+		s.set(2);
+		expect(seen).toEqual([1, 2]);
+		unsub(); // last subscriber → deactivate → cleanup
+		expect(cleaned).toBe(1);
+	});
+
+	it("D30: a value-level fn that throws emits ERROR downstream (not a crash)", () => {
+		const g = graph();
+		const s = g.state(1);
+		const bad = g.derived([s], (n) => {
+			if (n > 0) throw new Error("boom");
+			return n;
+		});
+		const msgs = collect(bad);
+		expect(types(msgs)).toContain("ERROR");
+		expect(bad.status).toBe("errored");
+	});
+
+	it("R-reentrancy via graph (D37): a synchronous feedback cycle yields ERROR, not a hang", () => {
+		const g = graph();
+		const s = g.state(0);
+		const d = g.derived([s], (n) => n + 1);
+		const seen: Message[] = [];
+		// effect feeds back into s → S→D→E→S cycle. The substrate rejects the re-entry
+		// (throw); the graph layer's value-level boundary catches it → ERROR. No hang.
+		const e = g.effect([d], (n) => {
+			s.set(n as number);
+		});
+		expect(() => e.subscribe((m) => seen.push(m))).not.toThrow(); // caught, not escaped
+		// R-reentrancy: the ERROR lands on a node ON the cycle — the value-level catch nearest
+		// the throw on the synchronous unwind (impl-determined, d or e), NOT necessarily the
+		// re-entered node. Assert SOME cycle node errored, not which (per the amended spec).
+		expect([d.status, e.status]).toContain("errored");
+	});
+});
+
+describe("Graph.describe — snapshot shape (R-describe / D39)", () => {
+	it("emits a flat snapshot with ids, factory names, status, value, deps, edges", () => {
+		const g = graph({ name: "demo" });
+		const count = g.state(0, { name: "count" });
+		const doubled = g.derived([count], (n) => n * 2, { name: "doubled" });
+		collect(doubled);
+		count.set(5);
+
+		const snap = g.describe();
+		expect(snap.name).toBe("demo");
+		const byId = Object.fromEntries(snap.nodes.map((n) => [n.id, n]));
+		expect(byId.count.factory).toBe("state");
+		expect(byId.count.value).toBe(5);
+		expect(byId.count.status).toBe("settled");
+		expect(byId.doubled.factory).toBe("derived");
+		expect(byId.doubled.value).toBe(10);
+		expect(byId.doubled.deps).toEqual(["count"]);
+		expect(snap.edges).toContainEqual({ from: "count", to: "doubled" });
+	});
+
+	it("absent value field = SENTINEL (never-emitted)", () => {
+		const g = graph();
+		const s = g.state(0, { name: "s" });
+		g.derived([s], (n) => n, { name: "d" }); // not subscribed → never runs
+		const snap = g.describe();
+		const dNode = snap.nodes.find((n) => n.id === "d");
+		expect(dNode && "value" in dNode).toBe(false); // SENTINEL → field absent
+	});
+
+	it("explain mode filters to the causal chain from→to", () => {
+		const g = graph();
+		const a = g.state(1, { name: "a" });
+		const b = g.derived([a], (x) => x + 1, { name: "b" });
+		const c = g.derived([b], (x) => x + 1, { name: "c" });
+		const side = g.state(9, { name: "side" }); // off the a→c chain
+		collect(c);
+		collect(g.derived([side], (x) => x, { name: "sideD" }));
+
+		const snap = g.describe({ explain: { from: "a", to: "c" } });
+		const ids = snap.nodes.map((n) => n.id).sort();
+		expect(ids).toEqual(["a", "b", "c"]);
+	});
+
+	it("mount nests a subgraph under a :: prefixed path", () => {
+		const parent = graph({ name: "p" });
+		parent.state(0, { name: "root" });
+		const child = graph({ name: "c" });
+		child.state(1, { name: "leaf" });
+		parent.mount(child, { at: "sub" });
+
+		const snap = parent.describe();
+		expect(snap.subgraphs?.[0].nodes.some((n) => n.id === "sub::leaf")).toBe(true);
+	});
+});
+
+describe("Graph.topology — pure structure snapshot (D173)", () => {
+	it("projects describe's live truth source without runtime status/value/version", () => {
+		const g = graph({ name: "demo" });
+		const count = g.state(0, { name: "count", meta: { role: { kind: "input" } } });
+		const doubled = g.derived([count], (n) => n * 2, { name: "doubled" });
+		collect(doubled);
+		count.set(5);
+
+		const topology: GraphTopologySnapshot = g.topology();
+		expect(topology.name).toBe("demo");
+		const byId = Object.fromEntries(topology.nodes.map((n) => [n.id, n]));
+		expect(byId.count).toEqual({
+			id: "count",
+			name: "count",
+			factory: "state",
+			deps: [],
+			meta: { role: { kind: "input" } },
+		});
+		((byId.count.meta as Record<string, unknown>).role as { kind: string }).kind = "changed";
+		expect(g.topology().nodes.find((node) => node.id === "count")?.meta).toEqual({
+			role: { kind: "input" },
+		});
+		expect(byId.doubled).toEqual({
+			id: "doubled",
+			name: "doubled",
+			factory: "derived",
+			deps: ["count"],
+		});
+		expect("status" in byId.count).toBe(false);
+		expect("value" in byId.count).toBe(false);
+		expect("version" in byId.count).toBe(false);
+		expect(topology.edges).toContainEqual({ from: "count", to: "doubled" });
+	});
+
+	it("reflects current live deps after rewire, matching D51 describe truthfulness", () => {
+		const g = graph();
+		const a = g.state(1, { name: "a" });
+		const b = g.state(2, { name: "b" });
+		const d = g.node([a], (ctx) => ctx.down([["DATA", depLatest(ctx, 0)]]), { name: "d" });
+
+		d.replaceDeps([b], (ctx) => ctx.down([["DATA", depLatest(ctx, 0)]]));
+
+		const topology = g.topology();
+		expect(topology.nodes.find((node) => node.id === "d")?.deps).toEqual(["b"]);
+		expect(topology.edges).toContainEqual({ from: "b", to: "d" });
+		expect(topology.edges).not.toContainEqual({ from: "a", to: "d" });
+	});
+
+	it("recursively projects mounted subgraphs without describe-only runtime fields", () => {
+		const parent = graph({ name: "parent" });
+		const child = graph({ name: "child" });
+		child.state(1, { name: "leaf" });
+		parent.mount(child, { at: "sub" });
+
+		const topology = parent.topology();
+		const leaf = topology.subgraphs?.[0]?.nodes.find((node) => node.id === "sub::leaf");
+		expect(leaf).toEqual({
+			id: "sub::leaf",
+			name: "leaf",
+			factory: "state",
+			deps: [],
+		});
+		expect(leaf && "status" in leaf).toBe(false);
+	});
+
+	it("rejects non-JSON-compatible metadata instead of aliasing host objects", () => {
+		const g = graph();
+
+		expect(() => g.state(0, { name: "bad", meta: { tags: new Set(["a"]) } })).toThrow(
+			/graph node 'bad' meta: graph meta must be strict JSON-compatible data/,
+		);
+	});
+
+	it("rejects sparse metadata arrays instead of normalizing holes", () => {
+		const g = graph();
+		const xs = new Array<string>(2);
+		xs[1] = "x";
+
+		expect(() => g.state(0, { name: "bad", meta: { xs } })).toThrow(/sparse array hole/);
+		expect(() =>
+			g.node([], () => undefined, { name: "badFn", meta: { f: () => undefined } }),
+		).toThrow(/graph node 'badFn' meta: graph meta must be strict JSON-compatible data/);
+	});
+});
+
+describe("Graph.blueprint — sync audit envelope (D173/D177)", () => {
+	it("returns a versioned normalized topology envelope without describe runtime fields", () => {
+		const parent = graph({ name: "parent" });
+		const count = parent.state(0, { name: "count", meta: { role: "input" } });
+		const doubled = parent.derived([count], (n) => n * 2, { name: "doubled" });
+		const child = graph({ name: "child" });
+		child.state(1, { name: "leaf" });
+		parent.mount(child, { at: "sub" });
+		collect(doubled);
+		count.set(5);
+
+		const blueprint = parent.blueprint();
+		expect(blueprint.version).toBe(GRAPH_BLUEPRINT_VERSION);
+		expect(blueprint.diagnostics).toBeUndefined();
+		expect(blueprint.topology.nodes.map((node) => node.id)).toEqual(["count", "doubled"]);
+		const countNode = blueprint.topology.nodes.find((node) => node.id === "count");
+		expect(countNode).toEqual({
+			id: "count",
+			name: "count",
+			factory: "state",
+			deps: [],
+			meta: { role: "input" },
+		});
+		expect(countNode && "status" in countNode).toBe(false);
+		expect(countNode && "value" in countNode).toBe(false);
+		expect(countNode && "version" in countNode).toBe(false);
+		const leaf = blueprint.topology.subgraphs?.[0]?.nodes.find((node) => node.id === "sub::leaf");
+		expect(leaf).toEqual({
+			id: "sub::leaf",
+			name: "leaf",
+			factory: "state",
+			deps: [],
+		});
+		expect(leaf && "status" in leaf).toBe(false);
+		expect(leaf && "value" in leaf).toBe(false);
+	});
+
+	it("canonicalizes topology ordering independently of registration order", () => {
+		const left = graph();
+		const leftB = left.state(2, { name: "b" });
+		const leftA = left.state(1, { name: "a" });
+		left.derived([leftB, leftA], (b, a) => a + b, { name: "sum" });
+
+		const right = graph();
+		const rightA = right.state(1, { name: "a" });
+		const rightB = right.state(2, { name: "b" });
+		right.derived([rightB, rightA], (b, a) => a + b, { name: "sum" });
+
+		expect(left.blueprint().topology.nodes.map((node) => node.id)).toEqual(["a", "b", "sum"]);
+		expect(left.blueprint().topology.edges).toEqual([
+			{ from: "a", to: "sum" },
+			{ from: "b", to: "sum" },
+		]);
+		expect(canonicalTopologyJson(left.topology())).toBe(canonicalTopologyJson(right.topology()));
+		expect(canonicalTopologyJson(left.blueprint().topology)).toBe(
+			canonicalTopologyJson(right.blueprint().topology),
+		);
+	});
+
+	it("exposes canonical topology bytes for cross-language hash input", () => {
+		const g = graph();
+		const b = g.state(2, { name: "b" });
+		const a = g.state(1, { name: "a" });
+		g.derived([b, a], (right, left) => left + right, { name: "sum" });
+
+		const bytes = canonicalTopologyBytes(g.topology());
+
+		expect(bytes).toEqual(strictCanonicalJsonBytes(g.blueprint().topology));
+		expect(decodeTestJsonBytes(bytes)).toBe(canonicalTopologyJson(g.topology()));
+	});
+
+	it("adds helper-only topology hash metadata without hashing provenance", async () => {
+		const g = graph();
+		const count = g.state(1, { name: "count" });
+		g.derived([count], (n) => n + 1, { name: "next" });
+
+		const base = g.blueprint();
+		const withFirstProvenance = withBlueprintProvenance(base, {
+			source: "unit-test",
+			env: { b: 2, a: 1 },
+		});
+		const withSecondProvenance = withBlueprintProvenance(base, { source: "other" });
+		const first = await withBlueprintHash(withFirstProvenance, {
+			algorithm: "test-hash",
+			hash: testHash,
+		});
+		const second = await withBlueprintHash(withSecondProvenance, {
+			algorithm: "test-hash",
+			hash: testHash,
+		});
+
+		expect(withFirstProvenance.provenance).toEqual({
+			env: { a: 1, b: 2 },
+			source: "unit-test",
+		});
+		expect(first.hash).toEqual({
+			kind: "topology",
+			algorithm: "test-hash",
+			input: "strictCanonicalTopologyBytes",
+			value: `h:${canonicalTopologyJson(base.topology)}`,
+		});
+		expect(second.hash?.value).toBe(first.hash?.value);
+		expect(Reflect.get(base, "hash")).toBeUndefined();
+	});
+
+	it("rejects malformed helper hash metadata", () => {
+		const g = graph();
+		g.state(1, { name: "count" });
+		const base = g.blueprint();
+
+		expect(() => withBlueprintHash(base, { algorithm: "", hash: testHash })).toThrow(
+			/algorithm must be a non-empty string/,
+		);
+		expect(() =>
+			withBlueprintHash(base, {
+				algorithm: "bad",
+				hash: () => null as unknown as string,
+			}),
+		).toThrow(/hash value must be a non-empty string/);
+		expect(() =>
+			withBlueprintHash(base, {
+				algorithm: "bad",
+				hash: () => "",
+			}),
+		).toThrow(/hash value must be a non-empty string/);
+	});
+
+	it("keeps graph blueprint JSON aliases on the shared strict JSON vocabulary", () => {
+		expectTypeOf<GraphBlueprintJson>().toEqualTypeOf<StrictJsonValue>();
+		expectTypeOf<GraphCheckpointJson>().toEqualTypeOf<StrictJsonValue>();
+	});
+
+	it("adds only caller-supplied provenance and optional graph-local diagnostics", () => {
+		const g = graph();
+		g.state(0, { name: "island" });
+
+		const blueprint = g.blueprint({
+			diagnostics: true,
+			provenance: { source: "unit-test", nested: { b: 2, a: 1 } },
+		});
+
+		expect(blueprint.provenance).toEqual({ nested: { a: 1, b: 2 }, source: "unit-test" });
+		expect(blueprint.diagnostics).toEqual({
+			ok: true,
+			issues: [
+				{
+					severity: "warning",
+					code: "island-node",
+					nodeId: "island",
+					message: "node 'island' has no deps and no dependents",
+				},
+			],
+		});
+		expect(Reflect.get(blueprint, "hash")).toBeUndefined();
+	});
+
+	it("reports dangling deps and duplicate ids for topology helper callers", () => {
+		const diagnostics = graphBlueprintDiagnostics(
+			normalizeTopology({
+				nodes: [
+					{ id: "a", factory: "state", deps: [] },
+					{ id: "a", factory: "state", deps: [] },
+					{ id: "b", factory: "derived", deps: ["missing"] },
+				],
+				edges: [],
+			}),
+		);
+
+		expect(diagnostics.ok).toBe(false);
+		expect(diagnostics.issues.map((issue) => issue.code)).toEqual([
+			"dangling-dep",
+			"duplicate-node-id",
+			"island-node",
+			"island-node",
+		]);
+	});
+
+	it("rejects malformed topology helper input before canonicalization", () => {
+		const sparseNodes = new Array<{ id: string; factory: string; deps: string[] }>(1);
+		expect(() => normalizeTopology({ nodes: sparseNodes, edges: [] })).toThrow(/sparse array hole/);
+
+		const sparseDeps = new Array<string>(1);
+		expect(() =>
+			normalizeTopology({ nodes: [{ id: "bad", factory: "node", deps: sparseDeps }], edges: [] }),
+		).toThrow(/sparse array hole/);
+		expect(() =>
+			normalizeTopology({
+				nodes: [
+					{ id: 1, factory: "node", deps: [] } as unknown as GraphTopologySnapshot["nodes"][0],
+				],
+				edges: [],
+			}),
+		).toThrow(/nodes\[0\]\.id must be a string/);
+		expect(() =>
+			normalizeTopology({
+				nodes: [{ id: "bad", factory: "node", deps: [1] as unknown as string[] }],
+				edges: [],
+			}),
+		).toThrow(/deps\[0\] must be a string/);
+		expect(() =>
+			normalizeTopology({
+				name: 1 as unknown as string,
+				nodes: [],
+				edges: [],
+			}),
+		).toThrow(/name must be a string/);
+
+		const cyclic: GraphTopologySnapshot = { nodes: [], edges: [] };
+		cyclic.subgraphs = [cyclic];
+		expect(() => normalizeTopology(cyclic)).toThrow(/circular subgraph reference/);
+	});
+});
diff --git a/packages/ts/src/__tests__/graph.part-02.test.ts b/packages/ts/src/__tests__/graph.part-02.test.ts
new file mode 100644
index 00000000..fd3f80c2
--- /dev/null
+++ b/packages/ts/src/__tests__/graph.part-02.test.ts
@@ -0,0 +1,663 @@
+import { readFileSync } from "node:fs";
+import { describe, expect, it } from "vitest";
+import { depLatest } from "../ctx/types.js";
+import { releaseGraphNodes } from "../graph/graph.js";
+import type { Message, TopologyEvent } from "../index.js";
+import {
+	Dispatcher,
+	defaultRestoreRegistry,
+	GRAPH_CHECKPOINT_VERSION,
+	graph,
+	Node,
+	reactiveIndex,
+	reactiveList,
+	reactiveLog,
+	reactiveMap,
+	restoreGraph,
+	strictJsonCodec,
+} from "../index.js";
+
+function collect(n: { subscribe(s: (m: Message) => void): () => void }) {
+	const msgs: Message[] = [];
+	n.subscribe((m) => msgs.push(m));
+	return msgs;
+}
+function demand(snapshot: Node<unknown>, pullId: symbol): void {
+	snapshot.up([["PULL", { pullId }]]);
+}
+const _types = (msgs: Message[]) => msgs.map((m) => m[0]);
+const TEST_JSON_DECODER = new TextDecoder();
+const decodeTestJsonBytes = (bytes: Uint8Array) => TEST_JSON_DECODER.decode(bytes);
+const _testHash = (bytes: Uint8Array) => `h:${decodeTestJsonBytes(bytes)}`;
+
+describe("Graph.observeTopology — read-only topology egress (D145)", () => {
+	it("emits node-registered events from the existing graph registry", () => {
+		const g = graph();
+		const events: TopologyEvent[] = [];
+		const unsub = g.observeTopology().subscribe((event) => events.push(event));
+
+		const source = g.state(1, { name: "source" });
+		g.derived([source], (n) => n + 1, { name: "derived" });
+
+		unsub();
+		expect(events).toEqual([
+			{ kind: "node-registered", path: "source", deps: [], factory: "state", seq: 0 },
+			{
+				kind: "node-registered",
+				path: "derived",
+				deps: ["source"],
+				factory: "derived",
+				seq: 1,
+			},
+		]);
+	});
+
+	it("emits deps-changed events that match describe-visible live edges", () => {
+		const g = graph();
+		const a = g.state(1, { name: "a" });
+		const b = g.state(2, { name: "b" });
+		const d = g.node([a], (ctx) => ctx.down([["DATA", depLatest(ctx, 0)]]), { name: "d" });
+		const events: TopologyEvent[] = [];
+		const unsub = g.observeTopology("d").subscribe((event) => events.push(event));
+
+		d.replaceDeps([b], (ctx) => ctx.down([["DATA", depLatest(ctx, 0)]]));
+
+		unsub();
+		expect(events).toEqual([
+			{ kind: "deps-changed", path: "d", prevDeps: ["a"], deps: ["b"], seq: 0 },
+		]);
+		const snap = g.describe();
+		expect(snap.nodes.find((node) => node.id === "d")?.deps).toEqual(["b"]);
+		expect(snap.edges).toContainEqual({ from: "b", to: "d" });
+		expect(snap.edges).not.toContainEqual({ from: "a", to: "d" });
+	});
+
+	it("emits mount-changed events from the parent graph without creating protocol data", () => {
+		const parent = graph();
+		const child = graph();
+		const events: TopologyEvent[] = [];
+		const unsub = parent.observeTopology("sub").subscribe((event) => events.push(event));
+
+		parent.mount(child, { at: "sub" });
+
+		unsub();
+		expect(events).toEqual([
+			{ kind: "mount-changed", path: "sub", deps: [], factory: "mount", seq: 0 },
+		]);
+		expect(parent.describe().subgraphs?.[0].name).toBeUndefined();
+		expect(parent.describe().subgraphs?.[0].nodes).toEqual([]);
+	});
+
+	it("forwards mounted child topology events through mount-aware parent paths", () => {
+		const parent = graph();
+		const child = graph();
+		parent.mount(child, { at: "sub" });
+		const events: TopologyEvent[] = [];
+		const unsub = parent.observeTopology("sub").subscribe((event) => events.push(event));
+
+		const a = child.state(1, { name: "a" });
+		const b = child.state(2, { name: "b" });
+		const d = child.node([a], (ctx) => ctx.down([["DATA", depLatest(ctx, 0)]]), {
+			name: "d",
+		});
+		d.replaceDeps([b], (ctx) => ctx.down([["DATA", depLatest(ctx, 0)]]));
+
+		unsub();
+		expect(events).toEqual([
+			{ kind: "node-registered", path: "sub::a", deps: [], factory: "state", seq: 0 },
+			{ kind: "node-registered", path: "sub::b", deps: [], factory: "state", seq: 1 },
+			{
+				kind: "node-registered",
+				path: "sub::d",
+				deps: ["sub::a"],
+				factory: "node",
+				seq: 2,
+			},
+			{
+				kind: "deps-changed",
+				path: "sub::d",
+				prevDeps: ["sub::a"],
+				deps: ["sub::b"],
+				seq: 3,
+			},
+		]);
+		const snap = parent.describe();
+		expect(snap.subgraphs?.[0].nodes.find((node) => node.id === "sub::d")?.deps).toEqual([
+			"sub::b",
+		]);
+	});
+
+	it("stops forwarding mounted child topology events after parent unsubscribe", () => {
+		const parent = graph();
+		const child = graph();
+		parent.mount(child, { at: "sub" });
+		const events: TopologyEvent[] = [];
+		const unsub = parent.observeTopology().subscribe((event) => events.push(event));
+		unsub();
+
+		child.state(1, { name: "leaf" });
+
+		expect(events).toEqual([]);
+	});
+
+	it("does not activate nodes or publish protocol DATA through topology observation", () => {
+		const g = graph();
+		let runs = 0;
+		const cold = g.producer(
+			(ctx) => {
+				runs += 1;
+				ctx.down([["DATA", "ran"]]);
+			},
+			{ name: "cold" },
+		);
+		const topologyEvents: string[] = [];
+		const protocolEvents: string[] = [];
+		const topologyUnsub = g.observeTopology().subscribe((event) => topologyEvents.push(event.kind));
+
+		topologyUnsub();
+		expect(runs).toBe(0);
+		expect(cold.cache).toBeUndefined();
+		expect(topologyEvents).toEqual([]);
+
+		const observeUnsub = g.observe("cold").subscribe((event) => protocolEvents.push(event.msg[0]));
+		observeUnsub();
+		expect(runs).toBe(1);
+		expect(protocolEvents).toContain("DATA");
+		expect(topologyEvents).toEqual([]);
+	});
+
+	it("stops producing topology events after unsubscribe", () => {
+		const g = graph();
+		const events: string[] = [];
+		const unsub = g.observeTopology().subscribe((event) => events.push(event.path));
+		unsub();
+
+		g.state(1, { name: "later" });
+
+		expect(events).toEqual([]);
+	});
+
+	it("delivers nested topology events FIFO and isolates observer failures", () => {
+		const g = graph();
+		const first: string[] = [];
+		const second: string[] = [];
+		const late: string[] = [];
+		let added = false;
+		g.observeTopology().subscribe((event) => {
+			first.push(`${event.path}:${event.seq}`);
+			try {
+				(event as { path: string }).path = "mutated";
+			} catch {
+				// Event snapshots are immutable read-only egress.
+			}
+			try {
+				(event.deps as unknown as string[]).push("mutated");
+			} catch {
+				// Event snapshots are immutable read-only egress.
+			}
+			if (!added) {
+				added = true;
+				g.observeTopology().subscribe((lateEvent) =>
+					late.push(`${lateEvent.path}:${lateEvent.seq}`),
+				);
+				g.state(2, { name: "nested" });
+			}
+		});
+		g.observeTopology().subscribe((event) => {
+			second.push(`${event.path}:${event.seq}`);
+			throw new Error("observer failure must not veto topology mutation");
+		});
+
+		expect(() => g.state(1, { name: "root" })).not.toThrow();
+		expect(g.find("root")).toBeDefined();
+		expect(g.find("nested")).toBeDefined();
+		expect(first).toEqual(["root:0", "nested:1"]);
+		expect(second).toEqual(["root:0", "nested:1"]);
+		expect(late).toEqual(["nested:1"]);
+	});
+
+	it("does not call a topology observer unsubscribed earlier in the same delivery", () => {
+		const g = graph();
+		const second: string[] = [];
+		let unsubscribeSecond = () => {};
+		g.observeTopology().subscribe(() => unsubscribeSecond());
+		unsubscribeSecond = g.observeTopology().subscribe((event) => second.push(event.path));
+
+		g.state(1, { name: "root" });
+
+		expect(second).toEqual([]);
+	});
+
+	it("emits node-released only after quiescent atomic graph release commits", () => {
+		const g = graph();
+		const source = g.state(1, { name: "source" });
+		const group = g.topologyGroup({ name: "view" });
+		const derived = group.derived([source], (n) => n + 1, { name: "derived" });
+		const events: TopologyEvent[] = [];
+		const unsub = g.observeTopology("derived").subscribe((event) => events.push(event));
+
+		group.release();
+
+		unsub();
+		expect(events).toEqual([
+			{
+				kind: "node-released",
+				path: "derived",
+				deps: ["source"],
+				factory: "derived",
+				seq: 0,
+			},
+		]);
+		expect(g.find("derived")).toBeUndefined();
+		expect(g.describe().nodes.map((node) => node.id)).not.toContain("derived");
+		expect(g.checkpoint().nodes.map((node) => node.id)).not.toContain("derived");
+		expect(() => derived.subscribe(() => {})).toThrow(/released from its graph lifecycle/);
+	});
+
+	it("does not emit node-released or hide topology when release is not quiescent", () => {
+		const g = graph();
+		const source = g.state(1, { name: "source" });
+		const group = g.topologyGroup({ name: "view" });
+		const derived = group.derived([source], (n) => n + 1, { name: "derived" });
+		g.derived([derived], (n) => n + 1, { name: "consumer" });
+		const events: TopologyEvent[] = [];
+		const unsub = g.observeTopology().subscribe((event) => events.push(event));
+
+		expect(() => group.release()).toThrow(/consumer.*still depends.*derived/);
+
+		unsub();
+		expect(events).toEqual([]);
+		expect(g.find("derived")).toBe(derived);
+		expect(g.describe().nodes.map((node) => node.id)).toContain("derived");
+		expect(g.checkpoint().nodes.map((node) => node.id)).toContain("derived");
+	});
+
+	it("emits node-released for committed releases even when cleanup later throws", () => {
+		const g = graph();
+		const panic = g.state(1, { name: "panic" });
+		const later = g.state(2, { name: "later" });
+		const panicInternals = panic as unknown as {
+			_lifecycle: { activated: boolean };
+			_hooks: { onDeactivation: Array<() => void> };
+		};
+		const laterInternals = later as unknown as {
+			_lifecycle: { activated: boolean };
+			_hooks: { onDeactivation: Array<() => void> };
+		};
+		let laterCleanupRan = false;
+		panicInternals._lifecycle.activated = true;
+		panicInternals._hooks.onDeactivation.push(() => {
+			throw new Error("cleanup boom");
+		});
+		laterInternals._lifecycle.activated = true;
+		laterInternals._hooks.onDeactivation.push(() => {
+			laterCleanupRan = true;
+		});
+		const events: TopologyEvent[] = [];
+		const unsub = g.observeTopology().subscribe((event) => events.push(event));
+
+		expect(() => releaseGraphNodes(g, [panic, later])).toThrow(/cleanup boom/);
+
+		unsub();
+		expect(events.map((event) => event.kind)).toEqual(["node-released", "node-released"]);
+		expect(events.map((event) => event.path)).toEqual(["panic", "later"]);
+		expect(events.map((event) => event.factory)).toEqual(["state", "state"]);
+		expect(events.map((event) => event.deps)).toEqual([[], []]);
+		expect(events.map((event) => event.seq)).toEqual([0, 1]);
+		expect(laterCleanupRan).toBe(true);
+		expect(g.find("panic")).toBeUndefined();
+		expect(g.find("later")).toBeUndefined();
+		expect(g.describe().nodes.map((node) => node.id)).not.toContain("panic");
+		expect(g.describe().nodes.map((node) => node.id)).not.toContain("later");
+		expect(() => panic.subscribe(() => {})).toThrow(/released from its graph lifecycle/);
+	});
+
+	it("rejects release while a node's own status is dirty", () => {
+		const g = graph();
+		const group = g.topologyGroup({ name: "view" });
+		const dirty = group.node([], null, { name: "dirty" });
+		const events: TopologyEvent[] = [];
+		const unsub = g.observeTopology().subscribe((event) => events.push(event));
+
+		dirty.down([["DIRTY"]]);
+
+		expect(dirty.status).toBe("dirty");
+		expect(() => group.release()).toThrow(/not runtime-quiescent/);
+		unsub();
+		expect(events).toEqual([]);
+		expect(g.find("dirty")).toBe(dirty);
+		expect(g.describe().nodes.map((node) => node.id)).toContain("dirty");
+	});
+});
+
+describe("Graph.topologyGroup — graph-owned dynamic topology release (D152/D153)", () => {
+	it("creates registered child nodes and releases them atomically from inspection surfaces", () => {
+		const g = graph({ dispatcher: new Dispatcher(), profile: true });
+		const source = g.state(1, { name: "source" });
+		const events: TopologyEvent[] = [];
+		const unsub = g.observeTopology().subscribe((event) => events.push(event));
+		const group = g.topologyGroup({ name: "view" });
+
+		const delta = group.derived([source], (n) => n + 1, { name: "view.delta" });
+		const snapshot = group.derived([delta], (n) => n * 2, { name: "view.snapshot" });
+
+		expect(g.find("view.delta")).toBe(delta);
+		expect(g.find("view.snapshot")).toBe(snapshot);
+		expect(g.describe().nodes.map((node) => node.id)).toEqual(
+			expect.arrayContaining(["source", "view.delta", "view.snapshot"]),
+		);
+		expect(Object.keys(g.profile().nodes)).toEqual(
+			expect.arrayContaining(["source", "view.delta", "view.snapshot"]),
+		);
+		expect(g.checkpoint().nodes.map((node) => node.id)).toEqual(
+			expect.arrayContaining(["source", "view.delta", "view.snapshot"]),
+		);
+
+		group.release();
+		group.release();
+		unsub();
+
+		expect(group.released).toBe(true);
+		expect(events).toEqual([
+			{
+				kind: "node-registered",
+				path: "view.delta",
+				deps: ["source"],
+				factory: "derived",
+				seq: 0,
+			},
+			{
+				kind: "node-registered",
+				path: "view.snapshot",
+				deps: ["view.delta"],
+				factory: "derived",
+				seq: 1,
+			},
+			{
+				kind: "node-released",
+				path: "view.delta",
+				deps: ["source"],
+				factory: "derived",
+				seq: 2,
+			},
+			{
+				kind: "node-released",
+				path: "view.snapshot",
+				deps: ["view.delta"],
+				factory: "derived",
+				seq: 3,
+			},
+		]);
+		expect(g.find("view.delta")).toBeUndefined();
+		expect(g.find("view.snapshot")).toBeUndefined();
+		expect(g.describe().nodes.map((node) => node.id)).not.toContain("view.delta");
+		expect(Object.keys(g.profile().nodes)).not.toContain("view.delta");
+		expect(g.checkpoint().nodes.map((node) => node.id)).not.toContain("view.delta");
+		expect(() => g.state(0, { name: "view.delta" })).toThrow(/released/);
+		expect(() => group.node([], null, { name: "late" })).toThrow(/released/);
+		expect(g.find("late")).toBeUndefined();
+	});
+
+	it("add only accepts ordinary graph-registered nodes from the owning graph", () => {
+		const g = graph();
+		const group = g.topologyGroup({ name: "view" });
+		const registered = g.state(1, { name: "registered" });
+		expect(group.add(registered)).toBe(registered);
+		expect(group.add(registered)).toBe(registered);
+
+		const other = graph().state(1, { name: "other" });
+		expect(() => group.add(other)).toThrow(/different graph/);
+
+		const bare = new Node([], null);
+		expect(() => group.add(bare)).toThrow(/not a registered graph node/);
+	});
+
+	it("rejects release while an external live subscriber points into the group and can retry", () => {
+		const g = graph();
+		const group = g.topologyGroup({ name: "view" });
+		const child = group.state(1, { name: "view.child" });
+		const unsub = child.subscribe(() => {});
+
+		expect(() => group.release()).toThrow(/live subscribers/);
+		expect(group.released).toBe(false);
+		expect(g.find("view.child")).toBe(child);
+
+		unsub();
+		group.release();
+		expect(group.released).toBe(true);
+		expect(g.find("view.child")).toBeUndefined();
+	});
+});
+
+describe("Graph.checkpoint — public data shape (R-snapshot / D83 / D90)", () => {
+	it("returns a versioned strict-JSON-compatible checkpoint with live topology and mounts", () => {
+		const parent = graph({ name: "parent" });
+		const count = parent.state(0, { name: "count" });
+		const doubled = parent.derived([count], (n) => n * 2, { name: "doubled" });
+		collect(doubled);
+		count.set(5);
+		const child = graph({ name: "child" });
+		child.state(null, { name: "nil" });
+		parent.mount(child, { at: "child" });
+
+		const checkpoint = parent.checkpoint();
+		expect(checkpoint.version).toBe(GRAPH_CHECKPOINT_VERSION);
+		expect(() => strictJsonCodec.encode(checkpoint)).not.toThrow();
+		const byId = Object.fromEntries(checkpoint.nodes.map((n) => [n.id, n]));
+		expect(byId.count.factory).toEqual({ kind: "registry-ref", ref: "state" });
+		expect(byId.count.value).toEqual({ kind: "DATA", data: 5 });
+		expect(byId.doubled.factory.kind).toBe("local-only");
+		expect(byId.doubled.value).toEqual({ kind: "DATA", data: 10 });
+		expect(byId.doubled.deps).toEqual(["count"]);
+		expect(byId.doubled.lifecycle.hasCalledFnOnce).toBe(true);
+		expect(checkpoint.edges).toContainEqual({ from: "count", to: "doubled" });
+		expect(checkpoint.mounts?.[0].at).toBe("child");
+		expect(checkpoint.mounts?.[0].checkpoint.nodes[0]).toMatchObject({
+			id: "nil",
+			value: { kind: "DATA", data: null },
+		});
+	});
+
+	it("captures ran-but-SENTINEL lifecycle state explicitly", () => {
+		const g = graph();
+		const quiet = g.producer(() => {}, { name: "quiet" });
+		collect(quiet);
+
+		const node = g.checkpoint().nodes.find((n) => n.id === "quiet");
+		expect(node?.value).toEqual({ kind: "SENTINEL" });
+		expect(node?.lifecycle).toEqual({ activated: true, hasCalledFnOnce: true });
+	});
+
+	it("uses explicit SENTINEL/DATA discriminants for absence, null, and empty arrays", () => {
+		const g = graph();
+		const src = g.state(0, { name: "src" });
+		g.derived([src], (n) => n, { name: "cold" });
+		g.state(null, { name: "nil" });
+		g.state([], { name: "empty" });
+
+		const byId = Object.fromEntries(g.checkpoint().nodes.map((n) => [n.id, n]));
+		expect(byId.cold.value).toEqual({ kind: "SENTINEL" });
+		expect(byId.nil.value).toEqual({ kind: "DATA", data: null });
+		expect(byId.empty.value).toEqual({ kind: "DATA", data: [] });
+	});
+
+	it("captures node-private ctx.state even when the state is non-persist", () => {
+		const g = graph();
+		const src = g.state(1, { name: "src" });
+		const memo = g.node(
+			[src],
+			(ctx) => {
+				ctx.state.set({ latest: depLatest(ctx, 0), runs: 1 });
+				ctx.down([["DATA", "ok"]]);
+			},
+			{ name: "memo" },
+		);
+		collect(memo);
+
+		const node = g.checkpoint().nodes.find((n) => n.id === "memo");
+		expect(node?.ctxState).toEqual({
+			persist: false,
+			value: { kind: "DATA", data: { latest: 1, runs: 1 } },
+		});
+	});
+
+	it("discriminates COMPLETE and ERROR terminal state when represented", () => {
+		const g = graph();
+		const done = g.state(1, { name: "done" });
+		const failed = g.state(2, { name: "failed" });
+		done.down([["COMPLETE"]]);
+		failed.down([["ERROR", "boom"]]);
+
+		const byId = Object.fromEntries(g.checkpoint().nodes.map((n) => [n.id, n]));
+		expect(byId.done.terminal).toEqual({ kind: "COMPLETE" });
+		expect(byId.failed.terminal).toEqual({ kind: "ERROR", error: "boom" });
+	});
+
+	it("fails honestly for non-strict-JSON cache, ctx.state, and terminal payloads", () => {
+		const badCache = graph();
+		badCache.state(1n, { name: "big" });
+		expect(() => badCache.checkpoint()).toThrow(/strict JSON compatible/);
+
+		const badString = graph();
+		badString.state("\ud800", { name: "surrogate" });
+		expect(() => badString.checkpoint()).toThrow(/strict JSON compatible/);
+
+		const badName = graph();
+		badName.state(1, { name: "\ud800" });
+		expect(() => badName.checkpoint()).toThrow(/strict JSON compatible/);
+
+		const badCtxState = graph();
+		const src = badCtxState.state(1, { name: "src" });
+		const memo = badCtxState.node(
+			[src],
+			(ctx) => {
+				ctx.state.set(Symbol("nope"));
+				ctx.down([["DATA", "ok"]]);
+			},
+			{ name: "memo" },
+		);
+		collect(memo);
+		expect(() => badCtxState.checkpoint()).toThrow(/strict JSON compatible/);
+
+		const badTerminal = graph();
+		const failed = badTerminal.state(1, { name: "failed" });
+		failed.down([["ERROR", new Error("not-json")]]);
+		expect(() => badTerminal.checkpoint()).toThrow(/strict JSON compatible/);
+	});
+
+	it("rejects duplicate ids and cyclic mounts instead of producing ambiguous checkpoints", () => {
+		const duplicate = graph();
+		duplicate.state(1, { name: "same" });
+		expect(() => duplicate.state(2, { name: "same" })).toThrow(/duplicate node id/);
+
+		const cyclic = graph();
+		cyclic.mount(cyclic, { at: "self" });
+		expect(() => cyclic.checkpoint()).toThrow(/cyclic graph mount/);
+	});
+
+	it("rejects non-quiescent checkpoint statuses that cannot be restored yet", () => {
+		const g = graph();
+		const source = g.state(1, { name: "source" });
+		source.down([["DIRTY"]]);
+
+		expect(() => g.checkpoint()).toThrow(/non-quiescent status 'dirty'/);
+	});
+
+	it("keeps graph checkpoint strict JSON validation independent from storage codecs (D96)", () => {
+		const source = readFileSync(new URL("../graph/checkpoint.ts", import.meta.url), "utf8");
+		expect(source).not.toContain("../storage/codec.js");
+	});
+
+	it("captures D160 collection backendState without mirroring it into ctx.state", () => {
+		const g = graph();
+		const list = reactiveList<number>([1], { graph: g, name: "list" });
+		list.append(2);
+		const index = reactiveIndex<string, number>({ graph: g, name: "idx" });
+		index.upsert("b", 2, 20);
+		index.upsert("a", 1, 10);
+		const log = reactiveLog<string>(["a"], { graph: g, name: "log", maxSize: 3 });
+		log.append("b");
+
+		const byId = Object.fromEntries(g.checkpoint().nodes.map((n) => [n.id, n]));
+		expect(byId["list.delta"].factory).toEqual({
+			kind: "registry-ref",
+			ref: "reactiveList.delta",
+		});
+		expect(byId["list.delta"].backendState).toEqual([1, 2]);
+		expect(byId["list.delta"].ctxState.value).toEqual({ kind: "SENTINEL" });
+		expect(byId["list.snapshot"].factory).toEqual({
+			kind: "registry-ref",
+			ref: "reactiveList.snapshot",
+		});
+		expect(byId["list.snapshot"].backendState).toBeUndefined();
+
+		expect(byId["idx.delta"].backendState).toEqual([
+			{ primary: "a", secondary: 1, value: 10 },
+			{ primary: "b", secondary: 2, value: 20 },
+		]);
+		expect(byId["log.delta"].factory).toEqual({
+			kind: "registry-ref",
+			ref: "reactiveLog.delta",
+			config: { maxSize: 3 },
+		});
+		expect(byId["log.delta"].backendState).toEqual(["a", "b"]);
+	});
+
+	it("treats D160 collection snapshot caches as non-authoritative checkpoint state", () => {
+		const g = graph();
+		const list = reactiveList<number>([1], { graph: g, name: "list" });
+		const mapCollection = reactiveMap<string, number>({ graph: g, name: "map" });
+		mapCollection.set("k", 42);
+		collect(list.snapshot);
+		collect(mapCollection.snapshot);
+		demand(list.snapshot as Node<unknown>, list.pullId);
+		demand(mapCollection.snapshot as Node<unknown>, mapCollection.pullId);
+
+		const checkpoint = g.checkpoint();
+		expect(() => strictJsonCodec.encode(checkpoint)).not.toThrow();
+		const byId = Object.fromEntries(checkpoint.nodes.map((n) => [n.id, n]));
+		expect(byId["list.delta"].backendState).toEqual([1]);
+		expect(byId["list.snapshot"].value).toEqual({ kind: "SENTINEL" });
+		expect(byId["map.intent"].backendState).toEqual([["k", 42]]);
+		expect(byId["map.snapshotPrep"].value).toEqual({ kind: "SENTINEL" });
+		expect(byId["map.snapshot"].value).toEqual({ kind: "SENTINEL" });
+	});
+
+	it("fails honestly when a collection backendState is not strict JSON", () => {
+		const g = graph();
+		reactiveList([1n], { graph: g, name: "big" });
+
+		expect(() => g.checkpoint()).toThrow(/big\.delta\.backendState.*strict JSON compatible/);
+	});
+
+	it("fails honestly when a reactiveIndex primary key cannot restore through D160", () => {
+		const g = graph();
+		const index = reactiveIndex<{ id: string }, number>({ graph: g, name: "idx" });
+		index.upsert({ id: "a" }, 1, 10);
+
+		expect(() => g.checkpoint()).toThrow(/backendState\[0\]\.primary.*JSON primitive/);
+	});
+
+	it("marks deferred collection policy variants local-only instead of advertising restore", () => {
+		const g = graph();
+		reactiveList<number>([], { graph: g, name: "capped", maxSize: 2 });
+		reactiveIndex<string, number>({
+			graph: g,
+			name: "limited",
+			capacity: { order: "primary", maxSize: 2 },
+		});
+
+		const byId = Object.fromEntries(g.checkpoint().nodes.map((n) => [n.id, n]));
+		expect(byId["capped.delta"].factory).toMatchObject({
+			kind: "local-only",
+			reason: expect.stringMatching(/no backend checkpoint restore metadata/),
+		});
+		expect(byId["limited.delta"].factory).toMatchObject({
+			kind: "local-only",
+			reason: expect.stringMatching(/no backend checkpoint restore metadata/),
+		});
+		expect(() => restoreGraph(g.checkpoint(), { registry: defaultRestoreRegistry })).toThrow(
+			/local-only/,
+		);
+	});
+});
diff --git a/packages/ts/src/__tests__/graph.restoregraph-fresh-graph-restore-r-restore-d94-d95.test.ts b/packages/ts/src/__tests__/graph.restoregraph-fresh-graph-restore-r-restore-d94-d95.test.ts
new file mode 100644
index 00000000..4baf55a7
--- /dev/null
+++ b/packages/ts/src/__tests__/graph.restoregraph-fresh-graph-restore-r-restore-d94-d95.test.ts
@@ -0,0 +1,916 @@
+import { describe, expect, expectTypeOf, it } from "vitest";
+import { depLatest } from "../ctx/types.js";
+import type { Ctx, GraphRestoreDescriptor, Message, RestoreGraphOptions } from "../index.js";
+import {
+	Dispatcher,
+	defaultRestoreRegistry,
+	define,
+	graph,
+	map,
+	type Node,
+	reactiveIndex,
+	reactiveList,
+	reactiveLog,
+	reactiveMap,
+	restoreGraph,
+	restoreRegistry,
+	take,
+	timer,
+} from "../index.js";
+
+function collect(n: { subscribe(s: (m: Message) => void): () => void }) {
+	const msgs: Message[] = [];
+	n.subscribe((m) => msgs.push(m));
+	return msgs;
+}
+function _demand(snapshot: Node<unknown>, pullId: symbol): void {
+	snapshot.up([["PULL", { pullId }]]);
+}
+const types = (msgs: Message[]) => msgs.map((m) => m[0]);
+const TEST_JSON_DECODER = new TextDecoder();
+const decodeTestJsonBytes = (bytes: Uint8Array) => TEST_JSON_DECODER.decode(bytes);
+const testHash = (bytes: Uint8Array) => `h:${decodeTestJsonBytes(bytes)}`;
+
+describe("restoreGraph — fresh graph restore (R-restore / D94 / D95)", () => {
+	it("restores named state DATA and pushes it on subscribe after restore", () => {
+		const g = graph({ name: "source" });
+		const count = g.state(0, { name: "count", meta: { role: "counter" } });
+		count.set(7);
+
+		const restored = restoreGraph(g.checkpoint(), { registry: defaultRestoreRegistry });
+		const node = restored.find("count");
+		expect(node?.cache).toBe(7);
+		expect(restored.describe().nodes.find((n) => n.id === "count")).toMatchObject({
+			id: "count",
+			name: "count",
+			factory: "state",
+			value: 7,
+			meta: { role: "counter" },
+		});
+
+		const msgs = collect(node as { subscribe(s: (m: Message) => void): () => void });
+		expect(msgs).toEqual([["START"], ["DATA", 7]]);
+	});
+
+	it("preserves SENTINEL absence separately from DATA null and empty array", () => {
+		const checkpoint = graph().checkpoint();
+		checkpoint.nodes = [
+			{
+				id: "cold",
+				name: "cold",
+				factory: { kind: "registry-ref", ref: "state" },
+				status: "sentinel",
+				deps: [],
+				value: { kind: "SENTINEL" },
+				terminal: { kind: "none" },
+				lifecycle: { activated: false, hasCalledFnOnce: false },
+				ctxState: { persist: false, value: { kind: "SENTINEL" } },
+			},
+			{
+				id: "nil",
+				name: "nil",
+				factory: { kind: "registry-ref", ref: "state" },
+				status: "settled",
+				deps: [],
+				value: { kind: "DATA", data: null },
+				terminal: { kind: "none" },
+				lifecycle: { activated: false, hasCalledFnOnce: false },
+				ctxState: { persist: false, value: { kind: "SENTINEL" } },
+			},
+			{
+				id: "empty",
+				name: "empty",
+				factory: { kind: "registry-ref", ref: "state" },
+				status: "settled",
+				deps: [],
+				value: { kind: "DATA", data: [] },
+				terminal: { kind: "none" },
+				lifecycle: { activated: false, hasCalledFnOnce: false },
+				ctxState: { persist: false, value: { kind: "SENTINEL" } },
+			},
+		];
+		checkpoint.edges = [];
+
+		const restored = restoreGraph(checkpoint, { registry: defaultRestoreRegistry });
+		expect(restored.find("cold")?.cache).toBeUndefined();
+		expect(
+			collect(restored.find("cold") as { subscribe(s: (m: Message) => void): () => void }),
+		).toEqual([["START"]]);
+		expect(restored.find("nil")?.cache).toBeNull();
+		expect(restored.find("empty")?.cache).toEqual([]);
+	});
+
+	it("constructs deps in topological order and restores non-persist ctx.state before the first subscriber", () => {
+		const original = graph();
+		const src = original.state(1, { name: "src" });
+		const memo = original.node(
+			[src],
+			(ctx) => {
+				const previous = (ctx.state.get<{ runs: number }>() ?? { runs: 0 }).runs;
+				const runs = previous + 1;
+				ctx.state.set({ runs });
+				ctx.down([["DATA", { runs }]]);
+			},
+			{
+				name: "memo",
+				restore: { ref: "memo", config: { mode: "runs" }, configVersion: "1" },
+			},
+		);
+		collect(memo);
+		const checkpoint = original.checkpoint();
+		const memoNode = checkpoint.nodes.find((n) => n.id === "memo");
+		expect(memoNode?.factory).toEqual({
+			kind: "registry-ref",
+			ref: "memo",
+			config: { mode: "runs" },
+			configVersion: "1",
+		});
+		checkpoint.nodes.reverse();
+
+		const memoDescriptor: GraphRestoreDescriptor = {
+			ref: "memo",
+			validateConfig(config, configVersion) {
+				expect(config).toEqual({ mode: "runs" });
+				expect(configVersion).toBe("1");
+				return config;
+			},
+			create(ctx) {
+				return ctx.registerNode(
+					"memo",
+					ctx.deps,
+					(runCtx) => {
+						const previous = (runCtx.state.get<{ runs: number }>() ?? { runs: 0 }).runs;
+						const runs = previous + 1;
+						runCtx.state.set({ runs });
+						runCtx.down([["DATA", { runs }]]);
+					},
+					{ name: ctx.name },
+				);
+			},
+		};
+
+		const restored = restoreGraph(checkpoint, {
+			registry: { ...defaultRestoreRegistry, memo: memoDescriptor },
+		});
+		const restoredMemo = restored.find("memo");
+		expect(restoredMemo?.cache).toEqual({ runs: 1 });
+		const msgs = collect(restoredMemo as { subscribe(s: (m: Message) => void): () => void });
+		expect(msgs.filter((m) => m[0] === "DATA").map((m) => m[1])).toEqual([{ runs: 1 }]);
+		expect(restoredMemo?.cache).toEqual({ runs: 1 });
+		(restored.find("src") as { set(v: number): void }).set(2);
+		expect(restoredMemo?.cache).toEqual({ runs: 2 });
+	});
+
+	it("restores a named function map using D101 define checkpoints", () => {
+		const original = graph();
+		const src = original.state(1, { name: "src" });
+		const inc = define<number, number>("inc", (n) => n + 1);
+		const mapped = original.initNode(map(inc), [src], { name: "mapped" });
+		collect(mapped);
+
+		const checkpoint = original.checkpoint();
+		expect(checkpoint.nodes.find((n) => n.id === "mapped")?.factory).toEqual({
+			kind: "registry-ref",
+			ref: "map",
+			config: { fn: "inc" },
+		});
+
+		const reloadedInc = define<number, number>("inc", (n) => n + 10);
+		const registry = restoreRegistry([reloadedInc], defaultRestoreRegistry);
+		const restored = restoreGraph(checkpoint, { registry });
+		expect(restored.find("mapped")?.cache).toBe(2);
+
+		collect(restored.find("mapped") as { subscribe(s: (m: Message) => void): () => void });
+		(restored.find("src") as { set(v: number): void }).set(2);
+		expect(restored.find("mapped")?.cache).toBe(12);
+	});
+
+	it("seeds a restored terminal dep without reopening or throwing from that dep", () => {
+		const original = graph();
+		const src = original.state(1, { name: "src" });
+		const memo = original.node([src], (ctx) => ctx.down([["DATA", depLatest(ctx, 0) as number]]), {
+			name: "memo",
+			restore: { ref: "memo" },
+			completeWhenDepsComplete: false,
+		});
+		collect(memo);
+		src.down([["COMPLETE"]]);
+		expect(memo.cache).toBe(1);
+
+		const memoDescriptor: GraphRestoreDescriptor = {
+			ref: "memo",
+			create(ctx) {
+				return ctx.registerNode(
+					"memo",
+					ctx.deps,
+					(runCtx) => runCtx.down([["DATA", depLatest(runCtx, 0) as number]]),
+					{
+						name: ctx.name,
+						completeWhenDepsComplete: false,
+					},
+				);
+			},
+		};
+
+		const restored = restoreGraph(original.checkpoint(), {
+			registry: { ...defaultRestoreRegistry, memo: memoDescriptor },
+		});
+		const msgs = collect(
+			restored.find("memo") as { subscribe(s: (m: Message) => void): () => void },
+		);
+
+		expect(types(msgs)).toEqual(["START", "DATA"]);
+		expect(restored.find("memo")?.cache).toBe(1);
+	});
+
+	it("does not seed restored pull dep cache as if it crossed the edge", () => {
+		const pullId = Symbol("restore-pull");
+		const original = graph();
+		original.state(5, { name: "pull", pullId, restore: { ref: "pullState" } });
+		original.node([], null, { name: "trigger", restore: { ref: "cold" } });
+		original.node(
+			[original.find("pull") as never, original.find("trigger") as never],
+			(ctx) => {
+				ctx.down([["DATA", (depLatest(ctx, 0) as number) + (depLatest(ctx, 1) as number)]]);
+			},
+			{ name: "joined", restore: { ref: "join" } },
+		);
+
+		const pullDescriptor: GraphRestoreDescriptor = {
+			ref: "pullState",
+			create(ctx) {
+				return ctx.registerState({ name: ctx.name, pullId });
+			},
+		};
+		const coldDescriptor: GraphRestoreDescriptor = {
+			ref: "cold",
+			create(ctx) {
+				return ctx.registerNode("cold", [], null, { name: ctx.name });
+			},
+		};
+		const joinDescriptor: GraphRestoreDescriptor = {
+			ref: "join",
+			create(ctx) {
+				return ctx.registerNode("join", ctx.deps, (runCtx) => {
+					runCtx.down([
+						["DATA", (depLatest(runCtx, 0) as number) + (depLatest(runCtx, 1) as number)],
+					]);
+				});
+			},
+		};
+
+		const restored = restoreGraph(original.checkpoint(), {
+			registry: {
+				...defaultRestoreRegistry,
+				pullState: pullDescriptor,
+				cold: coldDescriptor,
+				join: joinDescriptor,
+			},
+		});
+		const joined = restored.find("joined");
+		const msgs = collect(joined as { subscribe(s: (m: Message) => void): () => void });
+		expect(types(msgs)).toEqual(["START"]);
+
+		(restored.find("trigger") as { down(msgs: Message[]): void }).down([["DATA", 7]]);
+		expect(joined?.cache).toBeUndefined();
+	});
+
+	it("lets a restored SENTINEL dep's first activation emit a real post-commit wave", () => {
+		const original = graph();
+		original.node([], (ctx) => ctx.down([["DATA", 1]]), {
+			name: "src",
+			restore: { ref: "coldSource" },
+		});
+		original.node(
+			[original.find("src") as never],
+			(ctx) => ctx.down([["DATA", (depLatest(ctx, 0) as number) + 1]]),
+			{ name: "mapped", restore: { ref: "mapped" } },
+		);
+
+		const coldSource: GraphRestoreDescriptor = {
+			ref: "coldSource",
+			create(ctx) {
+				return ctx.registerNode("coldSource", [], (runCtx) => runCtx.down([["DATA", 1]]), {
+					name: ctx.name,
+				});
+			},
+		};
+		const mappedDescriptor: GraphRestoreDescriptor = {
+			ref: "mapped",
+			create(ctx) {
+				return ctx.registerNode("mapped", ctx.deps, (runCtx) => {
+					runCtx.down([["DATA", (depLatest(runCtx, 0) as number) + 1]]);
+				});
+			},
+		};
+
+		const restored = restoreGraph(original.checkpoint(), {
+			registry: { ...defaultRestoreRegistry, coldSource, mapped: mappedDescriptor },
+		});
+		const msgs = collect(
+			restored.find("mapped") as { subscribe(s: (m: Message) => void): () => void },
+		);
+
+		expect(types(msgs)).toEqual(["START", "DATA"]);
+		expect(restored.find("mapped")?.cache).toBe(2);
+	});
+
+	it("treats deps added by post-restore pre-activation rewire as fresh deps", () => {
+		const original = graph();
+		const src = original.state(1, { name: "src" });
+		const inc = define<number, number>("restore-rewire.inc", (n) => n + 1);
+		const mapped = original.initNode(map(inc), [src], { name: "mapped" });
+		collect(mapped);
+		expect(mapped.cache).toBe(2);
+
+		const restored = restoreGraph(original.checkpoint(), {
+			registry: restoreRegistry([inc], defaultRestoreRegistry),
+		});
+		const src2 = restored.state(10, { name: "src2" });
+		const restoredMapped = restored.find("mapped") as {
+			replaceDeps(deps: unknown[], fn: (ctx: Ctx) => void): void;
+			subscribe(s: (m: Message) => void): () => void;
+		};
+		restoredMapped.replaceDeps([src2], (ctx) => {
+			ctx.down([["DATA", 11]]);
+		});
+		const msgs = collect(restoredMapped);
+
+		expect(types(msgs)).toEqual(["START", "DATA", "DATA"]);
+		expect(msgs.filter((m) => m[0] === "DATA").map((m) => m[1])).toEqual([2, 11]);
+		expect(restored.find("mapped")?.cache).toBe(11);
+	});
+
+	it("rejects duplicate definition refs in restore registry (D101)", () => {
+		const first = define<number, number>("same", (n) => n + 1);
+		const duplicate = define<number, number>("same", (n) => n + 2);
+		expect(() => restoreRegistry([first, duplicate], defaultRestoreRegistry)).toThrow(
+			/duplicate ref 'same'/,
+		);
+	});
+
+	it("fails honestly when a restored map config references a missing function definition (D101)", () => {
+		const base = graph();
+		base.state(1, { name: "src" });
+		const checkpoint = base.checkpoint();
+		checkpoint.nodes.push({
+			id: "mapped",
+			name: "mapped",
+			factory: { kind: "registry-ref", ref: "map", config: { fn: "missing.inc" } },
+			status: "sentinel",
+			deps: ["src"],
+			value: { kind: "SENTINEL" },
+			terminal: { kind: "none" },
+			lifecycle: { activated: false, hasCalledFnOnce: false },
+			ctxState: { persist: false, value: { kind: "SENTINEL" } },
+		});
+		checkpoint.edges.push({ from: "src", to: "mapped" });
+
+		expect(() => restoreGraph(checkpoint, { registry: defaultRestoreRegistry })).toThrow(
+			/missing function definition for 'missing\.inc'/,
+		);
+	});
+
+	it("keeps inline closure map local-only while static built-in operators stamp config", () => {
+		const g = graph();
+		const src = g.state(1, { name: "src" });
+		const inline = g.initNode(
+			map((n: number) => n + 1),
+			[src],
+			{ name: "inline" },
+		);
+		const limited = g.initNode(take<number>(2), [src], { name: "limited" });
+		const optOut = g.initNode(take<number>(1), [src], {
+			name: "optOut",
+			restore: undefined,
+		});
+		g.initNode(timer(5), [], { name: "once" });
+		g.initNode(timer(6, {}), [], { name: "onceDefaultOpts" });
+		collect(inline);
+		collect(limited);
+		collect(optOut);
+
+		const checkpoint = g.checkpoint();
+		expect(checkpoint.nodes.find((n) => n.id === "inline")?.factory.kind).toBe("local-only");
+		expect(checkpoint.nodes.find((n) => n.id === "optOut")?.factory.kind).toBe("local-only");
+		expect(checkpoint.nodes.find((n) => n.id === "limited")?.factory).toEqual({
+			kind: "registry-ref",
+			ref: "take",
+			config: { n: 2 },
+		});
+		expect(checkpoint.nodes.find((n) => n.id === "once")?.factory).toEqual({
+			kind: "registry-ref",
+			ref: "timer",
+			config: { ms: 5 },
+		});
+		expect(checkpoint.nodes.find((n) => n.id === "onceDefaultOpts")?.factory).toEqual({
+			kind: "registry-ref",
+			ref: "timer",
+			config: { ms: 6 },
+		});
+		expect(() => restoreGraph(checkpoint, { registry: defaultRestoreRegistry })).toThrow(
+			/local-only/,
+		);
+
+		const restorable = graph();
+		const rsrc = restorable.state(1, { name: "src" });
+		const rtake = restorable.initNode(take<number>(1), [rsrc], { name: "limited" });
+		collect(rtake);
+		const restored = restoreGraph(restorable.checkpoint(), { registry: defaultRestoreRegistry });
+		expect(restored.find("limited")?.cache).toBe(1);
+	});
+
+	it("restores built-in take and timer from checkpoint descriptors", () => {
+		const restorable = graph();
+		const src = restorable.state(1, { name: "src" });
+		const limited = restorable.initNode(take<number>(2), [src], { name: "limited" });
+		collect(limited);
+		restorable.initNode(timer(7), [], { name: "once" });
+		restorable.initNode(timer(8, {}), [], { name: "onceDefaultOpts" });
+		const checkpoint = restorable.checkpoint();
+
+		expect(checkpoint.nodes.find((n) => n.id === "limited")?.factory).toEqual({
+			kind: "registry-ref",
+			ref: "take",
+			config: { n: 2 },
+		});
+		expect(checkpoint.nodes.find((n) => n.id === "once")?.factory).toEqual({
+			kind: "registry-ref",
+			ref: "timer",
+			config: { ms: 7 },
+		});
+		expect(checkpoint.nodes.find((n) => n.id === "onceDefaultOpts")?.factory).toEqual({
+			kind: "registry-ref",
+			ref: "timer",
+			config: { ms: 8 },
+		});
+
+		const restored = restoreGraph(checkpoint, { registry: defaultRestoreRegistry });
+		const restoredLimited = restored.find("limited");
+		const restoredSrc = restored.find("src") as { set(v: number): void };
+		const msgs = collect(restoredLimited as { subscribe(s: (m: Message) => void): () => void });
+		const restoredOnce = restored.find("once");
+
+		expect(msgs.length >= 1).toBe(true);
+		expect(restoredOnce).toBeDefined();
+		expect(restoredLimited?.cache).toBe(1);
+		restoredSrc.set(2);
+		expect(restoredLimited?.cache).toBe(2);
+	});
+
+	it("uses restoreGraph dispatcher option for the fresh restored graph (D100)", () => {
+		const original = graph();
+		const src = original.state(1, { name: "src" });
+		const inc = define<number, number>("inc.dispatcher", (n) => n + 1);
+		collect(original.initNode(map(inc), [src], { name: "mapped" }));
+		const dispatcher = new Dispatcher();
+		dispatcher.setRecording(true);
+
+		const restored = restoreGraph(original.checkpoint(), {
+			registry: restoreRegistry([inc], defaultRestoreRegistry),
+			dispatcher,
+		});
+		collect(restored.find("mapped") as { subscribe(s: (m: Message) => void): () => void });
+		(restored.find("src") as { set(v: number): void }).set(2);
+		expect(restored.find("mapped")?.cache).toBe(3);
+		expect(dispatcher.totalInvokes).toBeGreaterThan(0);
+	});
+
+	it("restores terminal COMPLETE and ERROR state without reopening terminal nodes", () => {
+		const g = graph();
+		const done = g.state(1, { name: "done" });
+		const failed = g.state(2, { name: "failed" });
+		done.down([["COMPLETE"]]);
+		failed.down([["ERROR", "boom"]]);
+
+		const restored = restoreGraph(g.checkpoint(), { registry: defaultRestoreRegistry });
+		expect(restored.find("done")?.status).toBe("completed");
+		expect(restored.find("failed")?.status).toBe("errored");
+		expect(() => restored.find("done")?.subscribe(() => {})).toThrow(/non-resubscribable/);
+		expect(() => restored.find("failed")?.subscribe(() => {})).toThrow(/non-resubscribable/);
+	});
+
+	it("checkpoints and restores D109 node runtime versions", () => {
+		const hash = testHash;
+		const g = graph({ versioning: { level: 1, hash } });
+		const src = g.state(1, { name: "src" });
+		const v0 = g.state(1, { name: "v0", versioning: 0 });
+		const disabled = g.state(1, { name: "disabled", versioning: false });
+		src.set(2);
+		v0.set(2);
+		expect(disabled.version).toBeUndefined();
+
+		const checkpoint = g.checkpoint();
+		expect(checkpoint.nodes.find((n) => n.id === "src")?.version).toEqual({
+			level: 1,
+			counter: 1,
+			cid: "h:2",
+			prev: "h:1",
+		});
+		expect(checkpoint.nodes.find((n) => n.id === "v0")?.version).toEqual({
+			level: 0,
+			counter: 1,
+		});
+		expect(checkpoint.nodes.find((n) => n.id === "disabled")?.version).toBeUndefined();
+
+		expect(() => restoreGraph(checkpoint, { registry: defaultRestoreRegistry })).toThrow(
+			/matching node versioning policy/,
+		);
+		const restored = restoreGraph(checkpoint, {
+			registry: defaultRestoreRegistry,
+			versioning: { level: 1, hash },
+		});
+		expect(restored.find("src")?.version).toEqual({
+			level: 1,
+			counter: 1,
+			cid: "h:2",
+			prev: "h:1",
+		});
+		expect(restored.find("v0")?.version).toEqual({ level: 0, counter: 1 });
+		expect(restored.find("disabled")?.version).toBeUndefined();
+
+		(restored.find("src") as { set(v: number): void }).set(3);
+		expect(restored.find("src")?.version).toEqual({
+			level: 1,
+			counter: 2,
+			cid: "h:3",
+			prev: "h:2",
+		});
+		(restored.find("v0") as { set(v: number): void }).set(3);
+		expect(restored.find("v0")?.version).toEqual({ level: 0, counter: 2 });
+		(restored.find("disabled") as { set(v: number): void }).set(3);
+		expect(restored.find("disabled")?.version).toBeUndefined();
+	});
+
+	it("rejects non-portable V1 DATA before hash, cache, or version mutation (D88/D112)", () => {
+		const calls: string[] = [];
+		const hash = (bytes: Uint8Array) => {
+			const text = decodeTestJsonBytes(bytes);
+			calls.push(text);
+			return `h:${text}`;
+		};
+		const g = graph({ versioning: { level: 1, hash } });
+		const src = g.state(1, { name: "src" });
+		const before = src.version;
+
+		expect(calls).toEqual(["1"]);
+		expect(() => src.set(Number.MAX_SAFE_INTEGER + 1)).toThrow(/safe range/);
+		expect(src.cache).toBe(1);
+		expect(src.version).toEqual(before);
+		expect(calls).toEqual(["1"]);
+	});
+
+	it("restores V0 checkpoints without requiring a V1 hash lane (D109)", () => {
+		const g = graph();
+		const src = g.state(1, { name: "src" });
+		src.set(2);
+
+		const restored = restoreGraph(g.checkpoint(), { registry: defaultRestoreRegistry });
+		expect(restored.find("src")?.version).toEqual({ level: 0, counter: 1 });
+
+		(restored.find("src") as { set(v: number): void }).set(3);
+		expect(restored.find("src")?.version).toEqual({ level: 0, counter: 2 });
+	});
+
+	it("fails honestly when V1 restore uses the wrong hash lane (D109)", () => {
+		const hash = testHash;
+		const g = graph({ versioning: { level: 1, hash } });
+		g.state({ n: 1 }, { name: "src" });
+		const checkpoint = g.checkpoint();
+
+		expect(() =>
+			restoreGraph(checkpoint, {
+				registry: defaultRestoreRegistry,
+				versioning: { level: 1, hash: (bytes) => `other:${decodeTestJsonBytes(bytes)}` },
+			}),
+		).toThrow(/hash policy/);
+	});
+
+	it("distinguishes V1 checkpoint absence from DATA null during restore (D109 / R-restore)", () => {
+		const hash = testHash;
+		const absentGraph = graph({ versioning: { level: 1, hash } });
+		absentGraph.node([], () => {}, { name: "cold" });
+		const absentCheckpoint = absentGraph.checkpoint();
+		const cold = absentCheckpoint.nodes.find((n) => n.id === "cold");
+		if (cold === undefined) throw new Error("missing test node");
+		cold.factory = { kind: "registry-ref", ref: "state" };
+		cold.value = { kind: "DATA", data: null };
+
+		expect(() =>
+			restoreGraph(absentCheckpoint, {
+				registry: defaultRestoreRegistry,
+				versioning: { level: 1, hash },
+			}),
+		).toThrow(/hash policy/);
+
+		const nullGraph = graph({ versioning: { level: 1, hash } });
+		nullGraph.state(null, { name: "nil" });
+		const nullCheckpoint = nullGraph.checkpoint();
+		const nil = nullCheckpoint.nodes.find((n) => n.id === "nil");
+		if (nil === undefined) throw new Error("missing test node");
+		nil.value = { kind: "SENTINEL" };
+
+		expect(() =>
+			restoreGraph(nullCheckpoint, {
+				registry: defaultRestoreRegistry,
+				versioning: { level: 1, hash },
+			}),
+		).toThrow(/hash policy/);
+	});
+
+	it("rejects absent post-DATA V1 checkpoints because the hash lane is unverifiable (D109)", () => {
+		const hash = testHash;
+		const g = graph({ versioning: { level: 1, hash } });
+		const src = g.state(1, { name: "src" });
+		src.set(2);
+		src.down([["INVALIDATE"]]);
+		const checkpoint = g.checkpoint();
+		const srcCheckpoint = checkpoint.nodes.find((n) => n.id === "src");
+		expect(srcCheckpoint?.value).toEqual({ kind: "SENTINEL" });
+		expect(srcCheckpoint?.version).toEqual({
+			level: 1,
+			counter: 1,
+			cid: "h:2",
+			prev: "h:1",
+		});
+
+		expect(() =>
+			restoreGraph(checkpoint, {
+				registry: defaultRestoreRegistry,
+				versioning: { level: 1, hash },
+			}),
+		).toThrow(/cannot be verified/);
+	});
+
+	it("rejects impossible V1 counter/prev checkpoint metadata (D109)", () => {
+		const hash = testHash;
+		const g = graph({ versioning: { level: 1, hash } });
+		g.state(1, { name: "src" });
+		const checkpoint = g.checkpoint();
+		const src = checkpoint.nodes.find((n) => n.id === "src");
+		if (src === undefined) throw new Error("missing test node");
+
+		src.version = { level: 1, counter: 0, cid: "h:1", prev: "h:0" };
+		expect(() =>
+			restoreGraph(checkpoint, {
+				registry: defaultRestoreRegistry,
+				versioning: { level: 1, hash },
+			}),
+		).toThrow(/prev must be null/);
+
+		src.version = { level: 1, counter: 1, cid: "h:1", prev: null };
+		expect(() =>
+			restoreGraph(checkpoint, {
+				registry: defaultRestoreRegistry,
+				versioning: { level: 1, hash },
+			}),
+		).toThrow(/prev must be a string/);
+
+		src.version = { level: 2, counter: 0 } as unknown as typeof src.version;
+		expect(() =>
+			restoreGraph(checkpoint, {
+				registry: defaultRestoreRegistry,
+				versioning: { level: 1, hash },
+			}),
+		).toThrow(/level must be 0 or 1/);
+	});
+
+	it("restores mounted fresh graphs from child-local checkpoints without double-prefixing", () => {
+		const parent = graph({ name: "parent" });
+		parent.state(1, { name: "root" });
+		const child = graph({ name: "child" });
+		child.state(2, { name: "leaf" });
+		parent.mount(child, { at: "child" });
+
+		const checkpoint = parent.checkpoint();
+		expect(checkpoint.mounts?.[0].checkpoint.nodes.map((n) => n.id)).toEqual(["leaf"]);
+		const restored = restoreGraph(checkpoint, { registry: defaultRestoreRegistry });
+		expect(restored.describe().subgraphs?.[0].nodes.map((n) => n.id)).toEqual(["child::leaf"]);
+		expect(restored.describe().subgraphs?.[0].nodes[0]?.value).toBe(2);
+	});
+
+	it("rejects missing refs, local-only factories, unknown restore options, duplicate ids, missing deps, and edge mismatches", () => {
+		expectTypeOf<RestoreGraphOptions>().not.toHaveProperty("graph");
+		const localOnly = graph();
+		const src = localOnly.state(1, { name: "src" });
+		localOnly.derived([src], (n) => n, { name: "derived" });
+		expect(() =>
+			restoreGraph(localOnly.checkpoint(), { registry: defaultRestoreRegistry }),
+		).toThrow(/local-only/);
+
+		const missingRef = graph();
+		missingRef.state(1, { name: "src" });
+		expect(() => restoreGraph(missingRef.checkpoint(), { registry: {} })).toThrow(
+			/missing registry/,
+		);
+		expect(() =>
+			restoreGraph(missingRef.checkpoint(), {
+				dispatcher: new Dispatcher(),
+			} as RestoreGraphOptions),
+		).toThrow(/registry is required/);
+
+		const target = graph();
+		target.state(0, { name: "untouched" });
+		expect(() =>
+			restoreGraph(missingRef.checkpoint(), {
+				registry: defaultRestoreRegistry,
+				graph: target,
+			} as unknown as RestoreGraphOptions),
+		).toThrow(/unknown option 'graph'/);
+		expect(target.find("untouched")?.cache).toBe(0);
+
+		const duplicate = missingRef.checkpoint();
+		duplicate.nodes.push({ ...duplicate.nodes[0] });
+		expect(() => restoreGraph(duplicate, { registry: defaultRestoreRegistry })).toThrow(
+			/duplicate node id/,
+		);
+
+		const missingDep = missingRef.checkpoint();
+		missingDep.nodes[0].deps = ["nope"];
+		expect(() => restoreGraph(missingDep, { registry: defaultRestoreRegistry })).toThrow(
+			/missing dep/,
+		);
+
+		const edgeMismatch = missingRef.checkpoint();
+		edgeMismatch.edges = [{ from: "src", to: "src" }];
+		expect(() => restoreGraph(edgeMismatch, { registry: defaultRestoreRegistry })).toThrow(
+			/not present in target deps/,
+		);
+
+		const duplicateEdgeGraph = graph();
+		const duplicateEdgeSource = duplicateEdgeGraph.state(1, { name: "src" });
+		duplicateEdgeGraph.initNode(take<number>(1), [duplicateEdgeSource], { name: "limited" });
+		const duplicateEdge = duplicateEdgeGraph.checkpoint();
+		duplicateEdge.edges.push({ ...duplicateEdge.edges[0] });
+		expect(() => restoreGraph(duplicateEdge, { registry: defaultRestoreRegistry })).toThrow(
+			/duplicate edge/,
+		);
+
+		const nonQuiescent = missingRef.checkpoint();
+		nonQuiescent.nodes[0].status = "pending";
+		expect(() => restoreGraph(nonQuiescent, { registry: defaultRestoreRegistry })).toThrow(
+			/non-quiescent status 'pending'/,
+		);
+
+		const terminalMismatch = missingRef.checkpoint();
+		terminalMismatch.nodes[0].status = "completed";
+		terminalMismatch.nodes[0].terminal = { kind: "none" };
+		expect(() => restoreGraph(terminalMismatch, { registry: defaultRestoreRegistry })).toThrow(
+			/terminal status requires terminal state/,
+		);
+
+		const badMountPrefix = graph();
+		const child = graph();
+		child.state(1, { name: "leaf" });
+		badMountPrefix.mount(child, { at: "child" });
+		const badMountCheckpoint = badMountPrefix.checkpoint();
+		if (badMountCheckpoint.mounts)
+			badMountCheckpoint.mounts[0].checkpoint.nodes[0].id = "child::leaf";
+		expect(() => restoreGraph(badMountCheckpoint, { registry: defaultRestoreRegistry })).toThrow(
+			/child-local node id/,
+		);
+
+		const emptyMountPath = badMountPrefix.checkpoint();
+		if (emptyMountPath.mounts) emptyMountPath.mounts[0].at = "";
+		expect(() => restoreGraph(emptyMountPath, { registry: defaultRestoreRegistry })).toThrow(
+			/mount path must not be empty/,
+		);
+	});
+
+	it("rejects descriptor output whose registered deps do not match the checkpoint", () => {
+		const original = graph();
+		const src = original.state(1, { name: "src" });
+		const memo = original.node([src], (ctx) => ctx.down([["DATA", depLatest(ctx, 0)]]), {
+			name: "memo",
+			restore: { ref: "memo" },
+		});
+		collect(memo);
+
+		const badDescriptor: GraphRestoreDescriptor = {
+			ref: "memo",
+			create(ctx) {
+				return ctx.registerNode("memo", [], (runCtx) => {
+					runCtx.down([["DATA", "bad"]]);
+				});
+			},
+		};
+
+		expect(() =>
+			restoreGraph(original.checkpoint(), {
+				registry: { ...defaultRestoreRegistry, memo: badDescriptor },
+			}),
+		).toThrow(/deps that do not match/);
+	});
+
+	it("restores D160 collection backendState while preserving checkpointed runtime", () => {
+		const original = graph();
+		const list = reactiveList<number>([1], { graph: original, name: "list" });
+		list.append(2);
+		const index = reactiveIndex<string, number>({ graph: original, name: "idx" });
+		index.upsert("a", 1, 10);
+		const log = reactiveLog<string>(["a"], { graph: original, name: "log" });
+		log.append("b");
+		const mapCollection = reactiveMap<string, number>({ graph: original, name: "map" });
+		mapCollection.set("k", 42);
+
+		const checkpoint = original.checkpoint();
+
+		const restored = restoreGraph(checkpoint, { registry: defaultRestoreRegistry });
+		const byId = Object.fromEntries(restored.checkpoint().nodes.map((n) => [n.id, n]));
+
+		expect(byId["list.delta"].backendState).toEqual([1, 2]);
+		expect(byId["list.delta"].value).toEqual({ kind: "SENTINEL" });
+		expect(byId["list.snapshot"].value).toEqual({ kind: "SENTINEL" });
+		expect(byId["idx.delta"].backendState).toEqual([{ primary: "a", secondary: 1, value: 10 }]);
+		expect(byId["idx.delta"].value).toEqual({ kind: "SENTINEL" });
+		expect(byId["idx.snapshot"].value).toEqual({ kind: "SENTINEL" });
+		expect(byId["log.delta"].backendState).toEqual(["a", "b"]);
+		expect(byId["log.delta"].value).toEqual({ kind: "SENTINEL" });
+		expect(byId["log.snapshot"].value).toEqual({ kind: "SENTINEL" });
+		expect(byId["map.intent"].backendState).toEqual([["k", 42]]);
+		expect(byId["map.intent"].value).toEqual({ kind: "SENTINEL" });
+		expect(byId["map.delta"].value).toEqual({ kind: "SENTINEL" });
+		expect(byId["map.delta"].deps).toEqual(["map.apply", "map.snapshotPrep"]);
+		expect(byId["map.snapshot"].deps).toEqual(["map.snapshotPrep"]);
+		expect(byId["list.delta"].ctxState.value).toEqual({ kind: "SENTINEL" });
+		expect(types(collect(restored.find("list.delta") as Node<unknown>))).toEqual(["START"]);
+	});
+
+	it("ignores D160 collection snapshot cache when backendState is authoritative", () => {
+		const original = graph();
+		const list = reactiveList<number>([1], { graph: original, name: "list" });
+		list.append(2);
+		const checkpoint = original.checkpoint();
+		const listSnapshot = checkpoint.nodes.find((n) => n.id === "list.snapshot");
+		if (!listSnapshot) throw new Error("missing list snapshot");
+		listSnapshot.value = { kind: "DATA", data: ["not-authority"] };
+
+		const restored = restoreGraph(checkpoint, { registry: defaultRestoreRegistry });
+		const byId = Object.fromEntries(restored.checkpoint().nodes.map((n) => [n.id, n]));
+		expect(byId["list.delta"].backendState).toEqual([1, 2]);
+		expect(byId["list.snapshot"].value).toEqual({ kind: "SENTINEL" });
+	});
+
+	it("rejects malformed D160 collection backendState instead of normalizing it", () => {
+		const original = graph();
+		const index = reactiveIndex<string, number>({ graph: original, name: "idx" });
+		index.upsert("a", 1, 10);
+		reactiveLog<string>(["a", "b"], { graph: original, name: "log", maxSize: 2 });
+		const checkpoint = original.checkpoint();
+		const idxDelta = checkpoint.nodes.find((n) => n.id === "idx.delta");
+		const logDelta = checkpoint.nodes.find((n) => n.id === "log.delta");
+		if (!idxDelta || !logDelta) throw new Error("missing collection nodes");
+
+		idxDelta.backendState = [
+			{ primary: "a", secondary: 1, value: 10 },
+			{ primary: "a", secondary: 2, value: 20 },
+		];
+		expect(() => restoreGraph(checkpoint, { registry: defaultRestoreRegistry })).toThrow(
+			/duplicates an earlier index row/,
+		);
+
+		idxDelta.backendState = [{ primary: "a", secondary: 1, value: 10 }];
+		logDelta.backendState = ["a", "b", "c"];
+		expect(() => restoreGraph(checkpoint, { registry: defaultRestoreRegistry })).toThrow(
+			/backendState exceeds config\.maxSize/,
+		);
+	});
+
+	it("rejects malformed D160 reactiveMap backendState instead of normalizing it", () => {
+		const g = graph();
+		reactiveMap<string, number>({ graph: g, name: "map" });
+		const checkpoint = g.checkpoint();
+		const mapIntent = checkpoint.nodes.find((n) => n.id === "map.intent");
+		if (!mapIntent) throw new Error("missing map intent");
+
+		mapIntent.backendState = [["a", 1, "extra"]];
+		expect(() => restoreGraph(checkpoint, { registry: defaultRestoreRegistry })).toThrow(
+			/must be a \[key, value\] map entry/,
+		);
+
+		mapIntent.backendState = [
+			["a", 1],
+			["a", 2],
+		];
+		expect(() => restoreGraph(checkpoint, { registry: defaultRestoreRegistry })).toThrow(
+			/duplicates an earlier map key/,
+		);
+	});
+
+	it("fails honestly when D160 reactiveMap checkpoint would lose per-entry TTL", () => {
+		const g = graph();
+		const mapCollection = reactiveMap<string, number>({ graph: g, name: "map" });
+		mapCollection.set("ttl", 1, { ttl: 1000 });
+
+		expect(() => g.checkpoint()).toThrow(/cannot preserve per-entry TTL/);
+	});
+
+	it("fails honestly when D160 reactiveMap checkpoint has duplicate strict-JSON keys", () => {
+		const g = graph();
+		const mapCollection = reactiveMap<{ id: number }, string>({ graph: g, name: "map" });
+		mapCollection.set({ id: 1 }, "first");
+		mapCollection.set({ id: 1 }, "second");
+
+		expect(() => g.checkpoint()).toThrow(/duplicate strict-JSON keys/);
+	});
+});
diff --git a/packages/ts/src/__tests__/higher-order.test.ts b/packages/ts/src/__tests__/higher-order.test.ts
new file mode 100644
index 00000000..5aefde34
--- /dev/null
+++ b/packages/ts/src/__tests__/higher-order.test.ts
@@ -0,0 +1,681 @@
+/**
+ * Higher-order operators — switchMap / mergeMap / concatMap / exhaustMap / flatMap
+ * (D47 / R-rewire-deferred / CSP-2.7). Per-language sugar (D6/D24); built on the deferred
+ * self-rewire substrate (ctx.rewireNext) + the g.initNode funnel (D43). Each test drives a
+ * controllable inner "subject" so the flatten policy + inner-lifecycle folding are observable.
+ */
+
+import { describe, expect, it } from "vitest";
+import type { Ctx, Message } from "../index.js";
+import {
+	concatMap,
+	Dispatcher,
+	depLatest,
+	exhaustMap,
+	flatMap,
+	graph,
+	initNode,
+	map,
+	mergeMap,
+	node,
+	of,
+	repeat,
+	switchMap,
+} from "../index.js";
+
+function collect(n: { subscribe(s: (m: Message) => void): () => void }) {
+	const msgs: Message[] = [];
+	const unsub = n.subscribe((m) => msgs.push(m));
+	return { msgs, unsub };
+}
+const data = (m: Message[]) =>
+	m.filter((x) => x[0] === "DATA").map((x) => (x as ["DATA", unknown])[1]);
+const coreOf = (n: object) => (n as unknown as Record<string, unknown>)._core;
+
+class CountingDispatcher extends Dispatcher {
+	register(...args: Parameters<Dispatcher["register"]>): ReturnType<Dispatcher["register"]> {
+		this.registerCount += 1;
+		return super.register(...args);
+	}
+	registerCount = 0;
+}
+
+/** A controllable inner source whose activation + deactivation (cancellation) are observable. */
+function subject() {
+	let ctxRef: Ctx | null = null;
+	let activated = false;
+	let deactivated = false;
+	const n = node<number>([], (ctx) => {
+		ctxRef = ctx;
+		activated = true;
+		ctx.onDeactivation(() => {
+			deactivated = true;
+		});
+	});
+	return {
+		node: n,
+		next: (v: number) => (ctxRef as Ctx).down([["DATA", v]]),
+		complete: () => (ctxRef as Ctx).down([["COMPLETE"]]),
+		error: (e: unknown) => (ctxRef as Ctx).down([["ERROR", e]]),
+		emit: (msgs: Message[]) => (ctxRef as Ctx).down(msgs),
+		isActivated: () => activated,
+		isDeactivated: () => deactivated,
+	};
+}
+
+describe("mergeMap (D47 / R-rewire-deferred)", () => {
+	it("binds coerced runtime inners to the owning graph dispatcher/core (B34b / D22)", () => {
+		const dispatcher = new CountingDispatcher();
+		const g = graph({ dispatcher });
+		const s = g.node<number>([], null);
+		const op = g.initNode(
+			mergeMap((v: number) => [v, v + 1]),
+			[s],
+		);
+
+		expect(dispatcher.registerCount).toBe(1); // the mergeMap operator body itself
+		const { msgs } = collect(op);
+		s.down([["DATA", 1]]);
+
+		expect(dispatcher.registerCount).toBeGreaterThan(1); // the fromAny/fromIter inner
+		expect(data(msgs)).toEqual([1, 2]);
+	});
+
+	it("does not let coercion-time user getters consume the graph core binding (B34b)", () => {
+		const dispatcher = new CountingDispatcher();
+		const g = graph({ dispatcher });
+		const s = g.node<number>([], null);
+		let trapNode: object | null = null;
+		const target = {};
+		const thenKey = "th" + "en";
+		Object.defineProperty(target, thenKey, { value: () => undefined });
+		const input = new Proxy(target, {
+			get(target, prop, receiver) {
+				if (prop === thenKey && trapNode === null) trapNode = node<number>([], null);
+				return Reflect.get(target, prop, receiver);
+			},
+		}) as PromiseLike<number>;
+		const op = g.initNode(
+			mergeMap(() => input),
+			[s],
+		);
+
+		collect(op);
+		s.down([["DATA", 1]]);
+		const inner = op.deps[1];
+
+		expect(trapNode).not.toBeNull();
+		expect(coreOf(trapNode as object)).not.toBe(coreOf(op));
+		expect(inner).toBeDefined();
+		expect(coreOf(inner as object)).toBe(coreOf(op));
+		expect(dispatcher.registerCount).toBeGreaterThan(1);
+	});
+
+	it("keeps all inners live and interleaves their emissions; a completed inner is bounded", () => {
+		const a = subject();
+		const b = subject();
+		const g = graph();
+		const s = g.node([], null); // manual source
+		const op = g.initNode(
+			mergeMap((v: number) => (v === 1 ? a.node : b.node)),
+			[s],
+		);
+		const { msgs } = collect(op);
+
+		s.down([["DATA", 1]]); // → inner a added
+		s.down([["DATA", 2]]); // → inner b added (a stays live — merge)
+		expect(a.isActivated()).toBe(true);
+		expect(b.isActivated()).toBe(true);
+
+		a.next(10);
+		b.next(20);
+		a.next(11);
+		expect(data(msgs)).toEqual([10, 20, 11]); // interleaved (concurrent inners)
+
+		a.complete(); // inner a done → unsubscribeDep → deactivated (bounding); b unaffected
+		expect(a.isDeactivated()).toBe(true);
+		expect(b.isDeactivated()).toBe(false);
+
+		b.next(21);
+		expect(data(msgs)).toEqual([10, 20, 11, 21]);
+	});
+
+	it("limits mergeMap concurrency by queueing outer values until an inner completes", () => {
+		const inners: ReturnType<typeof subject>[] = [];
+		const g = graph();
+		const s = g.node([], null);
+		const op = g.initNode(
+			mergeMap(
+				(_v: number) => {
+					const inner = subject();
+					inners.push(inner);
+					return inner.node;
+				},
+				{ concurrent: 2 },
+			),
+			[s],
+		);
+		const { msgs } = collect(op);
+
+		s.down([["DATA", 1], ["DATA", 2], ["DATA", 3], ["COMPLETE"]]);
+		expect(inners).toHaveLength(2);
+		expect(inners[0].isActivated()).toBe(true);
+		expect(inners[1].isActivated()).toBe(true);
+		inners[0].next(10);
+		inners[1].next(20);
+		expect(data(msgs)).toEqual([10, 20]);
+		expect(op.status).not.toBe("completed");
+
+		inners[0].complete();
+		expect(inners).toHaveLength(3);
+		expect(inners[2].isActivated()).toBe(true);
+		inners[2].next(30);
+		expect(data(msgs)).toEqual([10, 20, 30]);
+		expect(op.status).not.toBe("completed");
+
+		inners[1].complete();
+		inners[2].complete();
+		expect(op.status).toBe("completed");
+	});
+
+	it("rejects non-positive mergeMap concurrency", () => {
+		expect(() => mergeMap((v: number) => v, { concurrent: 0 })).toThrow(RangeError);
+		expect(() => mergeMap((v: number) => v, { concurrent: 1.5 })).toThrow(RangeError);
+	});
+
+	it("does not re-add a just-completed inner while draining bounded mergeMap queue", () => {
+		const inner = subject();
+		const g = graph();
+		const s = g.node([], null);
+		const op = g.initNode(
+			mergeMap(() => inner.node, { concurrent: 1 }),
+			[s],
+		);
+		collect(op);
+
+		s.down([["DATA", 1], ["DATA", 2], ["COMPLETE"]]);
+		expect(inner.isActivated()).toBe(true);
+		expect(op.status).not.toBe("completed");
+
+		inner.complete();
+		expect(inner.isDeactivated()).toBe(true);
+		expect(op.status).toBe("completed");
+	});
+
+	it("a projector returning an ALREADY-LIVE inner is merged once (no inners↔deps desync)", () => {
+		// QA fix (mutation-verified): subscribeDep is set-idempotent, so a duplicate-projected Node must
+		// not be double-tracked in `inners` — otherwise the inners[i]↔deps[i+1] map skews by one and
+		// a LATER inner COMPLETE removes the WRONG (already-gone) inner, leaking the real one. The
+		// leak only surfaces on a subsequent removal, so we drive X (twice → dup), then a distinct Y,
+		// then complete both and assert Y is actually torn down.
+		const x = subject();
+		const y = subject();
+		const g = graph();
+		const s = g.node([], null);
+		const op = g.initNode(
+			mergeMap((v: number) => (v === 3 ? y.node : x.node)),
+			[s],
+		);
+		collect(op);
+
+		s.down([["DATA", 1]]); // add x
+		s.down([["DATA", 2]]); // re-project x → already live → skipped (no double-track)
+		s.down([["DATA", 3]]); // add a DISTINCT inner y
+		x.complete(); // remove x → deps=[S,y]
+		y.complete(); // remove y — only correct if inners stayed aligned (else x's stale slot is hit)
+		expect(x.isDeactivated()).toBe(true);
+		expect(y.isDeactivated()).toBe(true); // WITHOUT the dedup guard this stays false (wrong slot removed)
+	});
+
+	it("flatMap is an alias of mergeMap", () => {
+		const a = subject();
+		const g = graph();
+		const s = g.node([], null);
+		const op = g.initNode(
+			flatMap((_v: number) => a.node),
+			[s],
+		);
+		const { msgs } = collect(op);
+		s.down([["DATA", 1]]);
+		a.next(7);
+		expect(data(msgs)).toEqual([7]);
+	});
+
+	it("COMPLETEs when the source is done AND every inner has completed", () => {
+		const a = subject();
+		const g = graph();
+		const s = g.node([], null);
+		const op = g.initNode(
+			mergeMap((_v: number) => a.node),
+			[s],
+		);
+		const { msgs } = collect(op);
+
+		s.down([["DATA", 1]]); // add inner a
+		s.down([["COMPLETE"]]); // source done, but inner a still live → NOT complete yet
+		expect(op.status).not.toBe("completed");
+
+		a.next(9);
+		a.complete(); // last inner done + source done → op COMPLETEs
+		expect(data(msgs)).toEqual([9]);
+		expect(op.status).toBe("completed");
+	});
+
+	it("a throwing projector → ERROR (D30, self-catch survives rewire)", () => {
+		const g = graph();
+		const s = g.node([], null);
+		const op = g.initNode(
+			mergeMap((_v: number) => {
+				throw new Error("boom");
+			}),
+			[s],
+		);
+		collect(op);
+		s.down([["DATA", 1]]);
+		expect(op.status).toBe("errored");
+	});
+
+	it("source ERROR detaches every live inner before emitting ERROR (D81)", () => {
+		const a = subject();
+		const b = subject();
+		const g = graph();
+		const s = g.node([], null);
+		const op = g.initNode(
+			mergeMap((v: number) => (v === 1 ? a.node : b.node)),
+			[s],
+		);
+		const { msgs } = collect(op);
+
+		s.down([["DATA", 1]]);
+		s.down([["DATA", 2]]);
+		a.next(10);
+		const err = new Error("source boom");
+		s.down([["ERROR", err]]);
+
+		expect(op.status).toBe("errored");
+		expect(msgs.at(-1)).toEqual(["ERROR", err]);
+		expect(a.isDeactivated()).toBe(true);
+		expect(b.isDeactivated()).toBe(true);
+		expect(op.deps).toEqual([s]);
+		expect(a.node.status).not.toBe("completed");
+		expect(a.node.status).not.toBe("errored");
+		expect(b.node.status).not.toBe("completed");
+		expect(b.node.status).not.toBe("errored");
+
+		const afterError = msgs.length;
+		a.next(11);
+		b.next(20);
+		s.down([["DATA", 3]]);
+		expect(msgs).toHaveLength(afterError);
+	});
+
+	it("inner ERROR detaches sibling inners before emitting ERROR (D81)", () => {
+		const a = subject();
+		const b = subject();
+		const g = graph();
+		const s = g.node([], null);
+		const op = g.initNode(
+			mergeMap((v: number) => (v === 1 ? a.node : b.node)),
+			[s],
+		);
+		const { msgs } = collect(op);
+
+		s.down([["DATA", 1]]);
+		s.down([["DATA", 2]]);
+		b.next(20);
+		const err = new Error("inner boom");
+		a.error(err);
+
+		expect(op.status).toBe("errored");
+		expect(msgs.at(-1)).toEqual(["ERROR", err]);
+		expect(a.isDeactivated()).toBe(true);
+		expect(b.isDeactivated()).toBe(true);
+		expect(op.deps).toEqual([s]);
+		expect(b.node.status).not.toBe("completed");
+		expect(b.node.status).not.toBe("errored");
+
+		const afterError = msgs.length;
+		b.next(21);
+		s.down([["DATA", 3]]);
+		expect(msgs).toHaveLength(afterError);
+		expect(msgs.some((m) => m[0] === "COMPLETE")).toBe(false);
+	});
+
+	it("inner DATA in the same wave before ERROR is forwarded before cleanup (D81)", () => {
+		const a = subject();
+		const g = graph();
+		const s = g.node([], null);
+		const op = g.initNode(
+			mergeMap((_v: number) => a.node),
+			[s],
+		);
+		const { msgs } = collect(op);
+		const err = new Error("inner boom");
+
+		s.down([["DATA", 1]]);
+		a.emit([
+			["DATA", 10],
+			["ERROR", err],
+		]);
+
+		expect(data(msgs)).toEqual([10]);
+		expect(msgs.at(-1)).toEqual(["ERROR", err]);
+		expect(a.isDeactivated()).toBe(true);
+		expect(op.deps).toEqual([s]);
+	});
+
+	it("projector ERROR detaches previously-live inners and seals later output (D81)", () => {
+		const a = subject();
+		const g = graph();
+		const s = g.node([], null);
+		const op = g.initNode(
+			mergeMap((v: number) => {
+				if (v === 2) throw new Error("projector boom");
+				return a.node;
+			}),
+			[s],
+		);
+		const { msgs } = collect(op);
+
+		s.down([["DATA", 1]]);
+		a.next(10);
+		s.down([["DATA", 2]]);
+
+		expect(op.status).toBe("errored");
+		expect(msgs.at(-1)?.[0]).toBe("ERROR");
+		expect(a.isDeactivated()).toBe(true);
+		expect(op.deps).toEqual([s]);
+		expect(a.node.status).not.toBe("completed");
+		expect(a.node.status).not.toBe("errored");
+
+		const afterError = msgs.length;
+		a.next(11);
+		s.down([["DATA", 3]]);
+		expect(msgs).toHaveLength(afterError);
+	});
+});
+
+describe("switchMap (D47)", () => {
+	it("cancels the in-flight inner on a new source value (abortInFlight) and forwards only the current", () => {
+		const a = subject();
+		const b = subject();
+		const g = graph();
+		const s = g.node([], null);
+		const op = g.initNode(
+			switchMap((v: number) => (v === 1 ? a.node : b.node)),
+			[s],
+		);
+		const { msgs } = collect(op);
+
+		s.down([["DATA", 1]]); // → inner a
+		a.next(10);
+		expect(data(msgs)).toEqual([10]);
+
+		s.down([["DATA", 2]]); // switch → inner b; a is CANCELLED (source torn down)
+		expect(a.isDeactivated()).toBe(true);
+		expect(b.isActivated()).toBe(true);
+
+		a.next(99); // the superseded inner is drained — no stale forward
+		b.next(20);
+		expect(data(msgs)).toEqual([10, 20]);
+	});
+
+	it("re-projecting the same live inner does not cancel or duplicate it", () => {
+		const inner = subject();
+		const g = graph();
+		const s = g.node([], null);
+		const op = g.initNode(
+			switchMap((_v: number) => inner.node),
+			[s],
+		);
+		const { msgs } = collect(op);
+
+		s.down([["DATA", 1]]);
+		expect(inner.isActivated()).toBe(true);
+		expect(op.deps).toEqual([s, inner.node]);
+
+		s.down([["DATA", 2]]);
+		expect(inner.isDeactivated()).toBe(false);
+		expect(op.deps).toEqual([s, inner.node]);
+
+		inner.next(10);
+		expect(data(msgs)).toEqual([10]);
+	});
+});
+
+describe("concatMap (D47)", () => {
+	it("runs inners one at a time in source order; later source values queue", () => {
+		const a = subject();
+		const b = subject();
+		const g = graph();
+		const s = g.node([], null);
+		const op = g.initNode(
+			concatMap((v: number) => (v === 1 ? a.node : b.node)),
+			[s],
+		);
+		const { msgs } = collect(op);
+
+		s.down([["DATA", 1]]); // activate inner a
+		s.down([["DATA", 2]]); // QUEUED — a is still active (b not yet activated)
+		expect(a.isActivated()).toBe(true);
+		expect(b.isActivated()).toBe(false);
+
+		a.next(10);
+		a.complete(); // a done → activate the queued b
+		expect(b.isActivated()).toBe(true);
+		b.next(20);
+		expect(data(msgs)).toEqual([10, 20]); // order preserved
+	});
+
+	it("source ERROR clears queued values and detaches the active inner (D81)", () => {
+		const a = subject();
+		const b = subject();
+		const g = graph();
+		const s = g.node([], null);
+		const op = g.initNode(
+			concatMap((v: number) => (v === 1 ? a.node : b.node)),
+			[s],
+		);
+		const { msgs } = collect(op);
+
+		s.down([["DATA", 1]]);
+		s.down([["DATA", 2]]); // queued behind a
+		const err = new Error("source boom");
+		s.down([["ERROR", err]]);
+
+		expect(op.status).toBe("errored");
+		expect(msgs.at(-1)).toEqual(["ERROR", err]);
+		expect(a.isDeactivated()).toBe(true);
+		expect(b.isActivated()).toBe(false);
+		expect(op.deps).toEqual([s]);
+
+		a.complete();
+		expect(b.isActivated()).toBe(false);
+		expect(msgs.filter((m) => m[0] === "DATA")).toEqual([]);
+	});
+});
+
+describe("exhaustMap (D47)", () => {
+	it("drops source values that arrive while an inner is active", () => {
+		const a = subject();
+		const b = subject();
+		const c = subject();
+		const g = graph();
+		const s = g.node([], null);
+		const project = (v: number) => (v === 1 ? a.node : v === 2 ? b.node : c.node);
+		const op = g.initNode(exhaustMap(project), [s]);
+		const { msgs } = collect(op);
+
+		s.down([["DATA", 1]]); // activate inner a
+		s.down([["DATA", 2]]); // DROPPED — a is active
+		expect(a.isActivated()).toBe(true);
+		expect(b.isActivated()).toBe(false); // value 2 never projected
+
+		a.next(10);
+		a.complete(); // a done → exhaust free again
+		s.down([["DATA", 3]]); // now accepted → inner c
+		expect(c.isActivated()).toBe(true);
+		c.next(30);
+		expect(data(msgs)).toEqual([10, 30]); // the value-2 inner never contributed
+	});
+});
+
+describe("repeat (D47 self-rewire, factory-based — clean-slate complete design)", () => {
+	it("plays a fresh factory()-minted source `count` times in sequence, then COMPLETE", () => {
+		const g = graph();
+		// factory mints a FRESH source each round (clean-slate hot nodes can't be re-run in place);
+		// `() => [1, 2]` → fromAny(iter) → fromIter([1,2]) → emits 1,2,COMPLETE per round.
+		const r = g.initNode(
+			repeat<number>(() => [1, 2], 3),
+			[],
+		);
+		const { msgs } = collect(r);
+		expect(data(msgs)).toEqual([1, 2, 1, 2, 1, 2]);
+		expect(msgs[msgs.length - 1][0]).toBe("COMPLETE");
+		expect(r.status).toBe("completed");
+	});
+
+	it("count=1 plays the source exactly once", () => {
+		const g = graph();
+		const r = g.initNode(
+			repeat<number>(() => [7], 1),
+			[],
+		);
+		const { msgs } = collect(r);
+		expect(data(msgs)).toEqual([7]);
+		expect(r.status).toBe("completed");
+	});
+
+	it("an inner ERROR aborts repeat (errorWhenDepsError)", () => {
+		const g = graph();
+		// round 1 errors via a throwing projector inner (a derived that throws → D30 ERROR).
+		const r = g.initNode(
+			repeat<number>(() => {
+				const gg = graph();
+				const s = gg.state(0);
+				return gg.derived([s], () => {
+					throw new Error("inner boom");
+				});
+			}, 3),
+			[],
+		);
+		const { msgs } = collect(r);
+		expect(r.status).toBe("errored");
+		expect(msgs.some((m) => m[0] === "ERROR")).toBe(true);
+	});
+
+	it("a throwing repeat factory is caught and emitted as ERROR", () => {
+		const g = graph();
+		const boom = new Error("repeat factory boom");
+		const r = g.initNode(
+			repeat<number>(() => {
+				throw boom;
+			}, 2),
+			[],
+		);
+
+		const { msgs } = collect(r);
+		expect(msgs.at(-1)).toEqual(["ERROR", boom]);
+		expect(r.status).toBe("errored");
+	});
+
+	it("describe shows repeat's real factory name + its live inner (D6/D51)", () => {
+		const g = graph();
+		g.initNode(
+			repeat<number>(() => [1], 2),
+			[],
+			{ name: "rep" },
+		);
+		const snap = g.describe();
+		const rep = snap.nodes.find((dn) => dn.id === "rep");
+		expect(rep?.factory).toBe("repeat");
+	});
+});
+
+describe("higher-order — describe (D39 / D51): real factory name + LIVE inner topology", () => {
+	it("records the operator's real factory name; before any source value, only the construction edge", () => {
+		const a = subject();
+		const g = graph();
+		const s = g.node([], null, { name: "src" });
+		g.initNode(
+			switchMap((_v: number) => a.node),
+			[s],
+			{ name: "sw" },
+		);
+		const snap = g.describe();
+		const sw = snap.nodes.find((dn) => dn.id === "sw");
+		expect(sw?.factory).toBe("switchMap"); // D6/R-describe: REAL operator name, not "node"
+		expect(sw?.deps).toEqual(["src"]); // no inner wired yet — just the construction edge
+		expect(snap.edges).toContainEqual({ from: "src", to: "sw" });
+	});
+
+	it("shows a LIVE runtime inner after the operator wires it (D51 live-dep snapshot, no dangling '?')", () => {
+		const a = subject();
+		const g = graph();
+		const s = g.node([], null, { name: "src" });
+		const sw = g.initNode(
+			switchMap((_v: number) => a.node),
+			[s],
+			{ name: "sw" },
+		);
+		collect(sw);
+		expect(g.describe().edges).toEqual([{ from: "src", to: "sw" }]); // before: construction only
+
+		s.down([["DATA", 1]]); // switchMap wires inner `a` as a live dep (deferred rewire drains)
+		const snap = g.describe();
+		// sw's live deps now include the inner; the inner is auto-discovered as a REAL snapshot node.
+		const innerEdge = snap.edges.find((e) => e.to === "sw" && e.from !== "src");
+		expect(innerEdge).toBeDefined(); // a live edge inner→sw (truthful, not a dangling "?")
+		const innerNode = snap.nodes.find((dn) => dn.id === innerEdge?.from);
+		expect(innerNode).toBeDefined(); // the inner IS emitted as a node (D51/B38 auto-discovery)
+		expect(innerNode?.deps).toEqual([]); // subject() has no live deps, so it remains a leaf.
+		expect(snap.nodes.find((dn) => dn.id === "sw")?.deps).toContain("src"); // S still a live dep
+	});
+
+	it("auto-discovers an unregistered live dep (a bare initNode source) WITH its factory (D51 B2 / D43)", () => {
+		const g = graph();
+		const inner = initNode(of(42), []); // BARE (free initNode, not g.*) → unregistered, factory "of"
+		const d = g.node([inner], (ctx) => ctx.down([["DATA", depLatest(ctx, 0) as number]]), {
+			name: "d",
+		});
+		collect(d);
+		const snap = g.describe();
+		const dNode = snap.nodes.find((n) => n.id === "d");
+		expect(dNode?.deps).toHaveLength(1); // d's single live dep = the bare inner
+		const innerId = dNode?.deps[0] as string;
+		const innerNode = snap.nodes.find((n) => n.id === innerId);
+		expect(innerNode).toBeDefined(); // emitted as a node, NOT a dangling "?" edge
+		expect(innerNode?.factory).toBe("of"); // named via NodeOptions.factory (D43-reserved, D51)
+		expect(snap.edges).toContainEqual({ from: innerId, to: "d" });
+	});
+
+	it("auto-discovers transitive unregistered live deps (B38)", () => {
+		const g = graph();
+		const s = g.node([], null, { name: "src" });
+		const innerLeaf = subject();
+		const innerParent = initNode(
+			map((n: number) => n + 1),
+			[innerLeaf.node],
+		);
+		const sw = g.initNode(
+			switchMap((_v: number) => innerParent),
+			[s],
+			{ name: "sw" },
+		);
+		collect(sw);
+		s.down([["DATA", 1]]);
+		innerLeaf.next(41);
+		const snap = g.describe();
+		const swNode = snap.nodes.find((n) => n.id === "sw");
+		const parentId = swNode?.deps.find((id) => id !== "src");
+		expect(parentId).toBeDefined();
+		const parentNode = snap.nodes.find((n) => n.id === parentId);
+		expect(parentNode?.factory).toBe("map");
+		expect(parentNode?.deps.length).toBe(1);
+		const leafId = parentNode?.deps[0];
+		expect(leafId).toBeDefined();
+		const leafNode = snap.nodes.find((n) => n.id === leafId);
+		expect(leafNode).toBeDefined();
+		expect(snap.edges).toContainEqual({ from: leafId as string, to: parentId as string });
+	});
+});
diff --git a/packages/ts/src/__tests__/inspect.test.ts b/packages/ts/src/__tests__/inspect.test.ts
new file mode 100644
index 00000000..7f17c1aa
--- /dev/null
+++ b/packages/ts/src/__tests__/inspect.test.ts
@@ -0,0 +1,142 @@
+import { describe, expect, it } from "vitest";
+import type { ObserveEvent, ObserveStream } from "../index.js";
+import { coalesceObserve, Dispatcher, filterObserve, graph } from "../index.js";
+
+describe("observe — read-only enveloped egress (R-observe / D39)", () => {
+	it("streams ObserveEvents with path/msg/tier/seq; cached node pushes on subscribe", () => {
+		const g = graph();
+		const count = g.state(0, { name: "count" });
+		const doubled = g.derived([count], (n) => n * 2, { name: "doubled" });
+		doubled.subscribe(() => {}); // activate so it has a cache
+
+		const events: ObserveEvent[] = [];
+		const stop = g.observe("doubled").subscribe((e) => events.push(e));
+		// push-on-subscribe: the cached DATA arrives immediately
+		expect(events.some((e) => e.path === "doubled" && e.msg[0] === "DATA")).toBe(true);
+
+		count.set(5);
+		const data = events.filter((e) => e.msg[0] === "DATA").map((e) => e.msg[1]);
+		expect(data).toContain(10);
+		// envelope carries tier + a monotonic seq
+		const last = events[events.length - 1];
+		expect(typeof last.seq).toBe("number");
+		expect(last.tier).toBe(3); // DATA tier
+		stop();
+	});
+
+	it("whole-graph observe (no path) taps every node; observe is NOT itself a node", () => {
+		const g = graph();
+		const a = g.state(1, { name: "a" });
+		g.derived([a], (n) => n + 1, { name: "b" });
+		const events: ObserveEvent[] = [];
+		g.observe().subscribe((e) => events.push(e));
+		a.set(2);
+		const paths = new Set(events.map((e) => e.path));
+		expect(paths.has("a")).toBe(true);
+		expect(paths.has("b")).toBe(true);
+		// observing did not add a node to the graph (egress, not a node)
+		expect(
+			g
+				.describe()
+				.nodes.map((n) => n.id)
+				.sort(),
+		).toEqual(["a", "b"]);
+	});
+});
+
+describe("observe helpers — read-only egress sugar (R-observe / D39)", () => {
+	function observeFrom(events: readonly ObserveEvent[], onUnsubscribe?: () => void): ObserveStream {
+		return {
+			subscribe(sink) {
+				for (const event of events) {
+					sink(event);
+				}
+				return () => onUnsubscribe?.();
+			},
+		};
+	}
+
+	it("filterObserve forwards matching events and preserves source unsubscribe", () => {
+		const events: ObserveEvent[] = [
+			{ path: "a", msg: ["DIRTY"], tier: 2, seq: 1 },
+			{ path: "a", msg: ["DATA", 1], tier: 3, seq: 2 },
+			{ path: "b", msg: ["DATA", 2], tier: 3, seq: 3 },
+			{ path: "a", msg: ["DATA", 3], tier: 3, seq: 4 },
+		];
+		let unsubscribes = 0;
+		const seen: ObserveEvent[] = [];
+
+		const stop = filterObserve(
+			observeFrom(events, () => {
+				unsubscribes += 1;
+			}),
+			(event) => event.path === "a" && event.msg[0] === "DATA",
+		).subscribe((event) => seen.push(event));
+
+		expect(seen.map((event) => event.seq)).toEqual([2, 4]);
+		stop();
+		expect(unsubscribes).toBe(1);
+	});
+
+	it("coalesceObserve suppresses adjacent duplicates without reordering retained seq values", () => {
+		const events: ObserveEvent[] = [
+			{ path: "a", msg: ["DATA", 1], tier: 3, seq: 1 },
+			{ path: "a", msg: ["DATA", 1], tier: 3, seq: 2 },
+			{ path: "a", msg: ["DATA", 2], tier: 3, seq: 3 },
+			{ path: "b", msg: ["DATA", 2], tier: 3, seq: 4 },
+			{ path: "b", msg: ["DATA", 2], tier: 3, seq: 5 },
+			{ path: "a", msg: ["DATA", 1], tier: 3, seq: 6 },
+			{ path: "a", msg: ["DIRTY"], tier: 2, seq: 7 },
+			{ path: "a", msg: ["DIRTY"], tier: 2, seq: 8 },
+		];
+		const seen: ObserveEvent[] = [];
+
+		coalesceObserve(observeFrom(events)).subscribe((event) => seen.push(event));
+
+		expect(seen.map((event) => event.seq)).toEqual([1, 3, 4, 6, 7]);
+		expect(seen.map((event) => event.msg[0])).toEqual(["DATA", "DATA", "DATA", "DATA", "DIRTY"]);
+	});
+
+	it("coalesceObserve accepts a caller-owned equality for narrower egress coalescing", () => {
+		const events: ObserveEvent[] = [
+			{ path: "a", msg: ["DATA", 1], tier: 3, seq: 1 },
+			{ path: "a", msg: ["DATA", 2], tier: 3, seq: 2 },
+			{ path: "b", msg: ["DATA", 2], tier: 3, seq: 3 },
+		];
+		const seen: ObserveEvent[] = [];
+
+		coalesceObserve(observeFrom(events), (prev, next) => prev.path === next.path).subscribe(
+			(event) => seen.push(event),
+		);
+
+		expect(seen.map((event) => event.seq)).toEqual([1, 3]);
+	});
+});
+
+describe("profile — dispatcher-backed counters, never on the thin node (R-profile / D39)", () => {
+	it("counts invokes per node when profiling is enabled (opt-in)", () => {
+		const g = graph({ dispatcher: new Dispatcher(), profile: true });
+		const s = g.state(0, { name: "s" });
+		const d = g.derived([s], (n) => n + 1, { name: "d" });
+		d.subscribe(() => {});
+		s.set(1);
+		s.set(2);
+		const p = g.profile();
+		// d's fn ran: once on activation + once per set = 3
+		expect(p.nodes.d.invokes).toBe(3);
+		expect(p.nodes.d.status).toBe("settled");
+		// state node has no fn → no invokes
+		expect(p.nodes.s.invokes).toBe(0);
+		expect(p.totalInvokes).toBeGreaterThanOrEqual(3);
+	});
+
+	it("default graph does not record (zero overhead, F-PERF)", () => {
+		const g = graph({ dispatcher: new Dispatcher() }); // profile not enabled
+		const s = g.state(0, { name: "s" });
+		const d = g.derived([s], (n) => n + 1, { name: "d" });
+		d.subscribe(() => {});
+		s.set(1);
+		expect(g.profile().nodes.d.invokes).toBe(0); // not recorded
+		expect(g.profile().totalInvokes).toBe(0);
+	});
+});
diff --git a/packages/ts/src/__tests__/lifecycle.test.ts b/packages/ts/src/__tests__/lifecycle.test.ts
new file mode 100644
index 00000000..a09738bd
--- /dev/null
+++ b/packages/ts/src/__tests__/lifecycle.test.ts
@@ -0,0 +1,211 @@
+import { describe, expect, it } from "vitest";
+import type { Ctx, Message } from "../index.js";
+import { depLatest, node } from "../index.js";
+
+function collect(n: { subscribe(s: (m: Message) => void): () => void }) {
+	const msgs: Message[] = [];
+	const unsub = n.subscribe((m) => msgs.push(m));
+	return { msgs, unsub };
+}
+const types = (msgs: Message[]) => msgs.map((m) => m[0]);
+
+describe("terminal (R-terminal, R-deps-terminal)", () => {
+	it("auto-COMPLETE when ALL deps complete", () => {
+		const a = node<number>([], null, { initial: 1 });
+		const d = node<number>([a], (ctx: Ctx) =>
+			ctx.down([["DATA", (depLatest(ctx, 0) as number) + 1]]),
+		);
+		const { msgs } = collect(d);
+		msgs.length = 0;
+		a.down([["COMPLETE"]]);
+		expect(types(msgs)).toEqual(["COMPLETE"]);
+		expect(d.status).toBe("completed");
+	});
+
+	it("requires ALL deps complete, not ANY", () => {
+		const a = node<number>([], null, { initial: 1 });
+		const b = node<number>([], null, { initial: 2 });
+		const d = node<number>([a, b], (ctx: Ctx) =>
+			ctx.down([["DATA", (depLatest(ctx, 0) as number) + (depLatest(ctx, 1) as number)]]),
+		);
+		const { msgs } = collect(d);
+		msgs.length = 0;
+		a.down([["COMPLETE"]]);
+		expect(types(msgs)).not.toContain("COMPLETE"); // only one dep complete
+		b.down([["COMPLETE"]]);
+		expect(types(msgs)).toContain("COMPLETE"); // now all complete
+		expect(d.status).toBe("completed");
+	});
+
+	it("auto-ERROR when any dep errors (errorWhenDepsError)", () => {
+		const a = node<number>([], null, { initial: 1 });
+		const d = node<number>([a], (ctx: Ctx) => ctx.down([["DATA", 1]]));
+		const { msgs } = collect(d);
+		msgs.length = 0;
+		const err = new Error("boom");
+		a.down([["ERROR", err]]);
+		expect(msgs).toContainEqual(["ERROR", err]);
+		expect(d.status).toBe("errored");
+	});
+
+	it("ERROR with undefined or boolean payload is rejected (R-data-payload)", () => {
+		const s = node<number>([], null, { initial: 1 });
+		collect(s);
+		expect(() => s.down([["ERROR", undefined]])).toThrow(/non-SENTINEL/);
+		expect(() => s.down([["ERROR", false]])).toThrow(/non-boolean/);
+		expect(() => s.down([["ERROR", true]])).toThrow(/non-boolean/);
+	});
+
+	it("non-resubscribable terminal rejects late subscribe (R2.2.7.b)", () => {
+		const s = node<number>([], null, { initial: 1 });
+		collect(s);
+		s.down([["COMPLETE"]]);
+		expect(() => s.subscribe(() => {})).toThrow(/non-resubscribable/);
+	});
+
+	it("resubscribable terminal resets on late subscribe (R2.2.7.a)", () => {
+		const s = node<number>([], null, { initial: 1, resubscribable: true });
+		collect(s);
+		s.down([["COMPLETE"]]);
+		expect(s.status).toBe("completed");
+		const { msgs } = collect(s); // resets, then push-on-subscribe
+		expect(s.status).toBe("settled");
+		expect(msgs).toContainEqual(["DATA", 1]);
+	});
+
+	it("resubscribable reset detaches terminal-era subscribers (R-terminal fresh lifecycle)", () => {
+		const s = node<number>([], null, { initial: 1, resubscribable: true });
+		const old = collect(s);
+		s.down([["COMPLETE"]]);
+		old.msgs.length = 0;
+
+		const fresh = collect(s); // resets, then attaches this subscriber to the fresh lifecycle
+		fresh.msgs.length = 0;
+		s.down([["DATA", 2]]);
+
+		expect(old.msgs).toEqual([]);
+		expect(types(fresh.msgs)).toEqual(["DIRTY", "DATA"]);
+		expect(fresh.msgs.at(-1)).toEqual(["DATA", 2]);
+	});
+
+	it("B30: terminal-is-forever on SELF-emit — set()/down() after terminal is a no-op", () => {
+		// The upstream path (_receiveFromDep) already drops on terminal; B30 closes the
+		// self-emit gap in _down (a post-terminal state.set / ctx.down must not resurrect),
+		// matching the Rust arm's Core::down blanket guard (R-terminal / D17).
+		const s = node<number>([], null, { initial: 1 });
+		const { msgs } = collect(s);
+		s.down([["COMPLETE"]]);
+		expect(s.status).toBe("completed");
+		msgs.length = 0;
+
+		s.down([["DATA", 42]]); // self-emit in a LATER wave after terminal → no-op
+		expect(msgs).toEqual([]); // nothing emitted
+		expect(s.cache).toBe(1); // cache NOT overwritten by 42
+		expect(s.status).toBe("completed"); // still terminal
+
+		// also a no-op after ERROR (DATA + INVALIDATE both dropped)
+		const e = node<number>([], null, { initial: 7 });
+		const ce = collect(e);
+		e.down([["ERROR", new Error("boom")]]);
+		ce.msgs.length = 0;
+		e.down([["DATA", 99]]);
+		e.down([["INVALIDATE"]]);
+		expect(ce.msgs).toEqual([]); // neither DATA nor INVALIDATE escapes
+		expect(e.cache).toBe(7); // cache preserved (errored node)
+		expect(e.status).toBe("errored");
+	});
+});
+
+describe("INVALIDATE (R-invalidate-idempotent, R-cleanup-hooks)", () => {
+	it("clears cache, fires onInvalidate, cascades — and is idempotent", () => {
+		const a = node<number>([], null, { initial: 5 });
+		let flushed = 0;
+		const d = node<number>([a], (ctx: Ctx) => {
+			ctx.onInvalidate(() => flushed++);
+			ctx.down([["DATA", (depLatest(ctx, 0) as number) * 2]]);
+		});
+		const { msgs } = collect(d);
+		expect(d.cache).toBe(10);
+		msgs.length = 0;
+
+		a.down([["INVALIDATE"]]);
+		expect(flushed).toBe(1);
+		expect(d.cache).toBeUndefined();
+		expect(types(msgs)).toContain("INVALIDATE");
+
+		// second INVALIDATE: cache already reset -> no-op (no second flush/cascade)
+		msgs.length = 0;
+		a.down([["INVALIDATE"]]);
+		expect(flushed).toBe(1);
+		expect(types(msgs)).not.toContain("INVALIDATE");
+	});
+
+	it("never-populated INVALIDATE is a no-op", () => {
+		const s = node<number>([], null); // no cache
+		const { msgs } = collect(s);
+		msgs.length = 0;
+		s.down([["INVALIDATE"]]);
+		expect(msgs).toEqual([]);
+	});
+});
+
+describe("same-wave merge (R-same-wave-merge)", () => {
+	it("DATA + INVALIDATE: cache advances then clears", () => {
+		const s = node<number>([], null, { initial: 1 });
+		const { msgs } = collect(s);
+		msgs.length = 0;
+		s.down([["DATA", 9], ["INVALIDATE"]]);
+		expect(types(msgs)).toEqual(["DIRTY", "DATA", "INVALIDATE"]);
+		expect(s.cache).toBeUndefined();
+	});
+
+	it("INVALIDATE + INVALIDATE collapse to one (Q9)", () => {
+		const s = node<number>([], null, { initial: 1 });
+		const { msgs } = collect(s);
+		msgs.length = 0;
+		s.down([["INVALIDATE"], ["INVALIDATE"]]);
+		expect(types(msgs)).toEqual(["INVALIDATE"]);
+	});
+});
+
+describe("TEARDOWN (R-teardown-complete)", () => {
+	it("non-terminal TEARDOWN synthesizes a COMPLETE prefix", () => {
+		const s = node<number>([], null, { initial: 1 });
+		const { msgs } = collect(s);
+		msgs.length = 0;
+		s.down([["TEARDOWN"]]);
+		expect(types(msgs)).toEqual(["COMPLETE", "TEARDOWN"]);
+	});
+
+	it("does not stack COMPLETE when the wave already has one", () => {
+		const s = node<number>([], null, { initial: 1 });
+		const { msgs } = collect(s);
+		msgs.length = 0;
+		s.down([["COMPLETE"], ["TEARDOWN"]]);
+		expect(types(msgs)).toEqual(["COMPLETE", "TEARDOWN"]);
+	});
+});
+
+describe("ROM/RAM + cleanup (R-rom-ram, R-cleanup-hooks)", () => {
+	it("compute node clears cache on deactivation and fires onDeactivation", () => {
+		const a = node<number>([], null, { initial: 1 });
+		let cleaned = 0;
+		const d = node<number>([a], (ctx: Ctx) => {
+			ctx.onDeactivation(() => cleaned++);
+			ctx.down([["DATA", 1]]);
+		});
+		const { unsub } = collect(d);
+		expect(d.cache).toBe(1);
+		unsub();
+		expect(cleaned).toBe(1);
+		expect(d.cache).toBeUndefined(); // RAM
+		expect(d.status).toBe("sentinel");
+	});
+
+	it("state node retains cache across disconnect (ROM)", () => {
+		const s = node<number>([], null, { initial: 7 });
+		const { unsub } = collect(s);
+		unsub();
+		expect(s.cache).toBe(7);
+	});
+});
diff --git a/packages/ts/src/__tests__/messaging-recipes.test.ts b/packages/ts/src/__tests__/messaging-recipes.test.ts
new file mode 100644
index 00000000..593d8224
--- /dev/null
+++ b/packages/ts/src/__tests__/messaging-recipes.test.ts
@@ -0,0 +1,263 @@
+import { describe, expect, it } from "vitest";
+import type { CqrsStatus } from "../cqrs/index.js";
+import { cqrsMessagingRecipe } from "../cqrs/messaging.js";
+import { graph } from "../graph/graph.js";
+import type {
+	MessageBusAvailablePage,
+	MessageBusCommand,
+	MessageBusMessage,
+} from "../messaging/index.js";
+import type { ProcessStatus } from "../orchestration/index.js";
+import { orchestrationMessagingRecipe } from "../orchestration/messaging.js";
+
+describe("messaging recipes (D349-D351/D353)", () => {
+	it("does not ack orchestration retained delivery until a visible ProcessStatus exists", () => {
+		const g = graph();
+		const deliveries = g.node<MessageBusAvailablePage>([], null, { name: "deliveries" });
+		const status = g.node<ProcessStatus>([], null, { name: "processStatus" });
+		const recipe = orchestrationMessagingRecipe(g, { deliveries, status });
+		const commands = collectData(recipe.commands);
+		const acks = collectData<MessageBusCommand>(recipe.ackCommands);
+
+		deliveries.down([["DATA", page("sub-1", [message("cmd-1", 7)])]]);
+
+		expect(commands.at(-1)).toEqual(
+			expect.objectContaining({ id: "cmd-1", type: "start", payload: { ok: true } }),
+		);
+		expect(acks).toEqual([]);
+
+		status.down([
+			[
+				"DATA",
+				{
+					state: "accepted",
+					commandId: "cmd-1",
+					commandType: "start",
+					eventCount: 1,
+					effectCount: 0,
+					cursor: { eventSeq: 1, effectSeq: 0, commandCount: 1, errorCount: 0, auditSeq: 1 },
+				} satisfies ProcessStatus,
+			],
+		]);
+
+		expect(acks.at(-1)).toEqual(
+			expect.objectContaining({
+				kind: "ack",
+				topic: "commands",
+				subscriptionId: "sub-1",
+				seq: 7,
+			}),
+		);
+	});
+
+	it("does not ack CQRS retained delivery until visible accepted/rejected material exists", () => {
+		const g = graph();
+		const deliveries = g.node<MessageBusAvailablePage>([], null, { name: "deliveries" });
+		const status = g.node<CqrsStatus>([], null, { name: "cqrsStatus" });
+		const recipe = cqrsMessagingRecipe(g, { deliveries, status });
+		const acks = collectData<MessageBusCommand>(recipe.ackCommands);
+
+		deliveries.down([["DATA", page("sub-2", [message("cmd-2", 7)])]]);
+		expect(acks).toEqual([]);
+
+		status.down([
+			[
+				"DATA",
+				{
+					state: "rejected",
+					commandId: "cmd-2",
+					commandType: "start",
+					eventCount: 0,
+					errorCode: "unknown-command",
+					cursor: { eventSeq: 0, commandCount: 1, errorCount: 1, auditSeq: 1 },
+				} satisfies CqrsStatus,
+			],
+		]);
+
+		expect(acks.at(-1)).toEqual(
+			expect.objectContaining({
+				kind: "ack",
+				topic: "commands",
+				subscriptionId: "sub-2",
+				seq: 7,
+			}),
+		);
+	});
+
+	it("acks duplicate retained command ids in delivery order instead of overwriting cursors", () => {
+		const g = graph();
+		const deliveries = g.node<MessageBusAvailablePage>([], null, { name: "deliveries" });
+		const status = g.node<CqrsStatus>([], null, { name: "cqrsStatus" });
+		const recipe = cqrsMessagingRecipe(g, { deliveries, status });
+		const acks = collectData<MessageBusCommand>(recipe.ackCommands);
+
+		deliveries.down([["DATA", page("sub-dup", [message("cmd-dup", 7), message("cmd-dup", 8)])]]);
+		status.down([
+			["DATA", cqrsStatus("cmd-dup", "accepted")],
+			["DATA", cqrsStatus("cmd-dup", "rejected")],
+		]);
+
+		expect(acks.map((ack) => ack.seq)).toEqual([7, 8]);
+		expect(acks.every((ack) => ack.subscriptionId === "sub-dup")).toBe(true);
+		expect(new Set(acks.map((ack) => ack.commandId)).size).toBe(2);
+	});
+
+	it("acks CQRS retained delivery by the actual lowered policy command id", () => {
+		const g = graph();
+		const deliveries = g.node<MessageBusAvailablePage>([], null, { name: "deliveries" });
+		const status = g.node<CqrsStatus>([], null, { name: "cqrsStatus" });
+		const recipe = cqrsMessagingRecipe(g, {
+			deliveries,
+			status,
+			policy: {
+				command: () => ({ id: "mapped-cmd", type: "mapped", payload: { mapped: true } }),
+			},
+		});
+		const commands = collectData(recipe.commands);
+		const acks = collectData<MessageBusCommand>(recipe.ackCommands);
+
+		deliveries.down([["DATA", page("sub-policy", [message("payload-cmd", 9)])]]);
+		status.down([["DATA", cqrsStatus("payload-cmd", "accepted")]]);
+		expect(acks).toEqual([]);
+
+		status.down([["DATA", cqrsStatus("mapped-cmd", "accepted")]]);
+
+		expect(commands.at(-1)).toEqual(
+			expect.objectContaining({
+				id: "mapped-cmd",
+				metadata: {
+					messageBus: expect.objectContaining({
+						topic: "commands",
+						subscriptionId: "sub-policy",
+						seq: 9,
+					}),
+				},
+			}),
+		);
+		expect(acks.at(-1)).toEqual(
+			expect.objectContaining({
+				kind: "ack",
+				topic: "commands",
+				subscriptionId: "sub-policy",
+				seq: 9,
+				commandId: "cqrs:commands:sub-policy:9:status-ack",
+			}),
+		);
+	});
+
+	it("acks orchestration retained delivery by the actual lowered policy command id", () => {
+		const g = graph();
+		const deliveries = g.node<MessageBusAvailablePage>([], null, { name: "deliveries" });
+		const status = g.node<ProcessStatus>([], null, { name: "processStatus" });
+		const recipe = orchestrationMessagingRecipe(g, {
+			deliveries,
+			status,
+			policy: {
+				command: () => ({ id: "mapped-process", type: "mapped", payload: { mapped: true } }),
+			},
+		});
+		const acks = collectData<MessageBusCommand>(recipe.ackCommands);
+
+		deliveries.down([["DATA", page("sub-process-policy", [message("payload-process", 10)])]]);
+		status.down([
+			[
+				"DATA",
+				{
+					state: "accepted",
+					commandId: "payload-process",
+					commandType: "mapped",
+					eventCount: 1,
+					effectCount: 0,
+					cursor: { eventSeq: 1, effectSeq: 0, commandCount: 1, errorCount: 0, auditSeq: 1 },
+				} satisfies ProcessStatus,
+			],
+		]);
+		expect(acks).toEqual([]);
+
+		status.down([
+			[
+				"DATA",
+				{
+					state: "accepted",
+					commandId: "mapped-process",
+					commandType: "mapped",
+					eventCount: 1,
+					effectCount: 0,
+					cursor: { eventSeq: 1, effectSeq: 0, commandCount: 1, errorCount: 0, auditSeq: 1 },
+				} satisfies ProcessStatus,
+			],
+		]);
+
+		expect(acks.at(-1)).toEqual(
+			expect.objectContaining({
+				kind: "ack",
+				topic: "commands",
+				subscriptionId: "sub-process-policy",
+				seq: 10,
+				commandId: "orchestration:commands:sub-process-policy:10:status-ack",
+			}),
+		);
+	});
+});
+
+function collectData<T>(node: {
+	subscribe(sink: (msg: readonly [string, unknown?]) => void): unknown;
+}): T[] {
+	const out: T[] = [];
+	node.subscribe((msg) => {
+		if (msg[0] === "DATA") out.push(msg[1] as T);
+	});
+	return out;
+}
+
+function message(id: string, seq: number): MessageBusMessage {
+	return {
+		topic: "commands",
+		seq,
+		payload: {
+			id,
+			type: "start",
+			payload: { ok: true },
+		},
+		timestampMs: 100,
+		commandId: `${id}:publish`,
+	};
+}
+
+function page(
+	subscriptionId: string,
+	messages: readonly MessageBusMessage[],
+): MessageBusAvailablePage {
+	return {
+		topic: "commands",
+		subscriptionId,
+		cursor: {
+			topic: "commands",
+			subscriptionId,
+			nextSeq: messages[0]?.seq ?? 0,
+			closed: false,
+			retentionGap: false,
+			headSeq: messages[0]?.seq ?? 0,
+		},
+		messages,
+		fromSeq: messages[0]?.seq ?? 0,
+		throughSeq: messages.at(-1)?.seq,
+		hasMore: false,
+	};
+}
+
+function cqrsStatus(commandId: string, state: CqrsStatus["state"]): CqrsStatus {
+	return {
+		state,
+		commandId,
+		commandType: "start",
+		eventCount: state === "accepted" ? 1 : 0,
+		errorCode: state === "rejected" ? "unknown-command" : undefined,
+		cursor: {
+			eventSeq: state === "accepted" ? 1 : 0,
+			commandCount: 1,
+			errorCount: state === "rejected" ? 1 : 0,
+			auditSeq: 1,
+		},
+	};
+}
diff --git a/packages/ts/src/__tests__/messaging.test.ts b/packages/ts/src/__tests__/messaging.test.ts
new file mode 100644
index 00000000..0e8892f1
--- /dev/null
+++ b/packages/ts/src/__tests__/messaging.test.ts
@@ -0,0 +1,374 @@
+import { describe, expect, expectTypeOf, it } from "vitest";
+import { graph } from "../graph/graph.js";
+import {
+	CONTEXT_TOPIC,
+	DEFERRED_TOPIC,
+	fromTopic,
+	INJECTIONS_TOPIC,
+	type JsonSchema,
+	messageBus,
+	PROMPTS_TOPIC,
+	RESPONSES_TOPIC,
+	SPAWNS_TOPIC,
+	STANDARD_TOPICS,
+	type StandardTopic,
+	TODOS_TOPIC,
+	type TopicMessage,
+	toTopic,
+} from "../messaging/index.js";
+
+describe("messaging passive vocabulary (D125/D132)", () => {
+	it("exports standard topic constants and a passive topic message envelope", () => {
+		expect(STANDARD_TOPICS).toEqual([
+			PROMPTS_TOPIC,
+			RESPONSES_TOPIC,
+			INJECTIONS_TOPIC,
+			DEFERRED_TOPIC,
+			SPAWNS_TOPIC,
+			CONTEXT_TOPIC,
+			TODOS_TOPIC,
+		]);
+		expect(Object.isFrozen(STANDARD_TOPICS)).toBe(true);
+		expectTypeOf<StandardTopic>().toEqualTypeOf<
+			"prompts" | "responses" | "injections" | "deferred" | "spawns" | "context" | "todos"
+		>();
+		expectTypeOf<TopicMessage<{ prompt: string }>["schema"]>().toEqualTypeOf<
+			JsonSchema | undefined
+		>();
+	});
+});
+
+describe("messageBus clean-slate retained topic log (D279/D282/D284/D285/D325)", () => {
+	it("exposes commands/messages/status/issues and has no dynamicHub facade", async () => {
+		const messaging = await import("../messaging/index.js");
+		const g = graph();
+		messageBus(g, { topics: ["orders"], name: "bus", now: () => 10 });
+
+		expect(g.describe().nodes.map((node) => [node.id, node.factory])).toEqual(
+			expect.arrayContaining([
+				["bus/commands", "messageBusCommands"],
+				["bus/messages", "messageBusMessages"],
+				["bus/status", "messageBusStatus"],
+				["bus/issues", "messageBusIssues"],
+			]),
+		);
+		expect("dynamicHub" in messaging).toBe(false);
+	});
+
+	it("uses strict unknown-topic default and surfaces DataIssue/dead-letter material", () => {
+		const g = graph();
+		const bus = messageBus(g, { topics: ["orders"], name: "bus", now: () => 20 });
+		const issues: unknown[] = [];
+		bus.issues.subscribe((msg) => issues.push(msg));
+
+		bus.publish("missing", { id: "x" }, { commandId: "cmd-1" });
+
+		expect(issues.at(-1)).toEqual([
+			"DATA",
+			expect.objectContaining({
+				kind: "issue",
+				code: "unknown-topic",
+				source: "messageBus",
+			}),
+		]);
+		const catalog = bus.catalog();
+		catalog.snapshot.up([["PULL", { pullId: catalog.snapshotPullId }]]);
+		expect(catalog.snapshot.cache?.topics.map((topic) => topic.topic)).not.toContain("missing");
+	});
+
+	it("rejects unknown command kinds as DataIssue facts instead of throwing", () => {
+		const g = graph();
+		const bus = messageBus(g, { topics: ["orders"], name: "bus", now: () => 25 });
+		const issues: unknown[] = [];
+		bus.issues.subscribe((msg) => issues.push(msg));
+
+		expect(() =>
+			bus.commands.down([
+				["DATA", { kind: "bogus", topic: "orders", commandId: "bad-1" } as never],
+			]),
+		).not.toThrow();
+
+		expect(issues.at(-1)).toEqual([
+			"DATA",
+			expect.objectContaining({ code: "malformed-command", source: "messageBus" }),
+		]);
+
+		expect(() => bus.commands.down([["DATA", null as never]])).not.toThrow();
+		expect(issues.at(-1)).toEqual([
+			"DATA",
+			expect.objectContaining({ code: "malformed-command", source: "messageBus" }),
+		]);
+	});
+
+	it("dedupes publish commands by idempotencyKey", () => {
+		const g = graph();
+		const bus = messageBus(g, { topics: ["orders"], name: "bus", now: () => 27 });
+		const messages: unknown[] = [];
+		const status: unknown[] = [];
+		bus.messages.subscribe((msg) => messages.push(msg));
+		bus.status.subscribe((msg) => status.push(msg));
+
+		bus.publish("orders", { id: "o1" }, { commandId: "cmd-1", idempotencyKey: "idem-1" });
+		bus.publish("orders", { id: "o2" }, { commandId: "cmd-2", idempotencyKey: "idem-1" });
+
+		expect(messages.filter((msg) => msg[0] === "DATA")).toEqual([
+			[
+				"DATA",
+				expect.objectContaining({
+					payload: { id: "o1" },
+					idempotencyKey: "idem-1",
+				}),
+			],
+		]);
+		expect(status).toContainEqual([
+			"DATA",
+			expect.objectContaining({ kind: "duplicate-command", commandId: "cmd-2" }),
+		]);
+	});
+
+	it("publishes retained messages only after ensure-topic and supports toTopic command sugar", () => {
+		const g = graph();
+		const bus = messageBus(g, { topics: ["orders"], name: "bus", now: () => 30 });
+		const source = g.node<{ id: string }>([], null, { name: "source" });
+		const sink = toTopic(g, source, bus, "orders", {
+			name: "orders/out",
+			keyOf: (value) => (value as { id: string }).id,
+		});
+		const commands: unknown[] = [];
+		const messages: unknown[] = [];
+		sink.commands.subscribe((msg) => commands.push(msg));
+		bus.messages.subscribe((msg) => messages.push(msg));
+
+		source.down([["DATA", { id: "o1" }]]);
+
+		expect(commands.at(-1)).toEqual([
+			"DATA",
+			{ kind: "publish", topic: "orders", payload: { id: "o1" }, key: "o1" },
+		]);
+		expect(messages.at(-1)).toEqual([
+			"DATA",
+			{ topic: "orders", seq: 1, payload: { id: "o1" }, key: "o1", timestampMs: 30 },
+		]);
+		const snap = g.describe();
+		expect(snap.edges).toContainEqual({ from: "source", to: "orders/out" });
+		expect(snap.edges).toContainEqual({ from: "orders/out", to: "bus/commands" });
+	});
+
+	it("toTopic release removes the command-source edge from the bus", () => {
+		const g = graph();
+		const bus = messageBus(g, { topics: ["orders"], name: "bus", now: () => 35 });
+		const source = g.node<{ id: string }>([], null, { name: "source" });
+		const sink = toTopic(g, source, bus, "orders", { name: "orders/out" });
+		const messages: unknown[] = [];
+		bus.messages.subscribe((msg) => messages.push(msg));
+
+		source.down([["DATA", { id: "o1" }]]);
+		sink.release();
+		source.down([["DATA", { id: "o2" }]]);
+
+		expect(messages).toContainEqual(["DATA", expect.objectContaining({ payload: { id: "o1" } })]);
+		expect(messages).not.toContainEqual([
+			"DATA",
+			expect.objectContaining({ payload: { id: "o2" } }),
+		]);
+		expect(g.describe().edges).not.toContainEqual({ from: "orders/out", to: "bus/commands" });
+	});
+
+	it("catalog/topic/deadLetter projections answer explicit PULL params", () => {
+		const g = graph();
+		const bus = messageBus(g, { topics: ["orders"], name: "bus", now: () => 40 });
+		bus.ensureTopic("returns");
+		bus.publish("orders", { id: "o1" });
+		bus.publish("missing", "bad");
+		const catalog = bus.catalog();
+		const topic = bus.topic<{ id: string }>("orders");
+		const dead = bus.deadLetter();
+		const catalogMsgs: unknown[] = [];
+		const topicMsgs: unknown[] = [];
+		const deadMsgs: unknown[] = [];
+		catalog.snapshot.subscribe((msg) => catalogMsgs.push(msg));
+		topic.snapshot.subscribe((msg) => topicMsgs.push(msg));
+		dead.snapshot.subscribe((msg) => deadMsgs.push(msg));
+
+		catalog.snapshot.up([["PULL", { pullId: catalog.snapshotPullId, params: { limit: 1 } }]]);
+		topic.snapshot.up([["PULL", { pullId: topic.snapshotPullId, params: { limit: 1 } }]]);
+		dead.snapshot.up([
+			["PULL", { pullId: dead.snapshotPullId, params: { code: "unknown-topic" } }],
+		]);
+
+		expect(catalogMsgs.at(-1)).toEqual([
+			"DATA",
+			{
+				topics: [expect.objectContaining({ topic: "orders" })],
+				nextAfterTopic: "orders",
+				hasMore: true,
+			},
+		]);
+		expect(topicMsgs.at(-1)).toEqual([
+			"DATA",
+			expect.objectContaining({ topic: "orders", messages: [expect.objectContaining({ seq: 1 })] }),
+		]);
+		expect(deadMsgs.at(-1)).toEqual([
+			"DATA",
+			expect.objectContaining({
+				entries: [expect.objectContaining({ entrySeq: 1, topic: "missing" })],
+				hasMore: false,
+			}),
+		]);
+	});
+
+	it("subscription available PULL is read-only; ack/seek/close move the cursor", () => {
+		const g = graph();
+		const bus = messageBus(g, { topics: ["orders"], name: "bus", now: () => 50 });
+		bus.publish("orders", { id: "o1" });
+		bus.publish("orders", { id: "o2" });
+		const sub = bus.subscription<{ id: string }>({
+			topic: "orders",
+			subscriptionId: "worker-a",
+		});
+		const available: unknown[] = [];
+		const cursor: unknown[] = [];
+		sub.available.subscribe((msg) => available.push(msg));
+		sub.cursor.subscribe((msg) => cursor.push(msg));
+
+		sub.available.up([["PULL", { pullId: sub.availablePullId, params: { limit: 1 } }]]);
+		expect(available.at(-1)).toEqual([
+			"DATA",
+			expect.objectContaining({
+				cursor: expect.objectContaining({ nextSeq: 1 }),
+				messages: [expect.objectContaining({ seq: 1 })],
+				nextAfterSeq: 1,
+			}),
+		]);
+
+		sub.available.up([["PULL", { pullId: sub.availablePullId, params: { afterSeq: 1 } }]]);
+		expect(available.at(-1)).toEqual([
+			"DATA",
+			expect.objectContaining({
+				cursor: expect.objectContaining({ nextSeq: 1 }),
+				messages: [expect.objectContaining({ seq: 2 })],
+			}),
+		]);
+		sub.ack(1);
+		expect(cursor.at(-1)).toEqual([
+			"DATA",
+			expect.objectContaining({ topic: "orders", subscriptionId: "worker-a", nextSeq: 2 }),
+		]);
+		sub.seek(1);
+		expect(cursor.at(-1)).toEqual([
+			"DATA",
+			expect.objectContaining({ topic: "orders", subscriptionId: "worker-a", nextSeq: 1 }),
+		]);
+		sub.close();
+		expect(cursor.at(-1)).toEqual([
+			"DATA",
+			expect.objectContaining({ topic: "orders", subscriptionId: "worker-a", closed: true }),
+		]);
+	});
+
+	it("retention trimming advances headSeq and reports retention gaps", () => {
+		const g = graph();
+		const bus = messageBus(g, {
+			topics: ["orders"],
+			name: "bus",
+			now: () => 60,
+			retention: { maxMessages: 1 },
+		});
+		const sub = bus.subscription({ topic: "orders", subscriptionId: "s1" });
+		const issues: unknown[] = [];
+		const cursor: unknown[] = [];
+		bus.issues.subscribe((msg) => issues.push(msg));
+		sub.cursor.subscribe((msg) => cursor.push(msg));
+
+		bus.publish("orders", "a");
+		bus.publish("orders", "b");
+		sub.available.up([["PULL", { pullId: sub.availablePullId }]]);
+
+		expect(issues.at(-1)).toEqual(["DATA", expect.objectContaining({ code: "retention-gap" })]);
+		expect(sub.available.cache?.cursor).toEqual(
+			expect.objectContaining({ headSeq: 2, retentionGap: true }),
+		);
+		expect(sub.available.cache?.messages).toEqual([]);
+		expect(cursor.at(-1)).toEqual([
+			"DATA",
+			expect.objectContaining({ headSeq: 2, retentionGap: true }),
+		]);
+		const cursorDataBeforeAck = cursor.filter((msg) => Array.isArray(msg) && msg[0] === "DATA");
+		sub.ack(2);
+		expect(cursor.filter((msg) => Array.isArray(msg) && msg[0] === "DATA")).toEqual(
+			cursorDataBeforeAck,
+		);
+		expect(cursorDataBeforeAck.at(-1)).toEqual([
+			"DATA",
+			expect.objectContaining({ headSeq: 2, retentionGap: true }),
+		]);
+		sub.seek(2);
+		expect(cursor.at(-1)).toEqual([
+			"DATA",
+			expect.objectContaining({ nextSeq: 2, retentionGap: false }),
+		]);
+	});
+
+	it("rejects invalid cursor commands without creating subscriptions or skipping messages", () => {
+		const g = graph();
+		const bus = messageBus(g, { topics: ["orders"], name: "bus", now: () => 65 });
+		const issues: unknown[] = [];
+		bus.issues.subscribe((msg) => issues.push(msg));
+		bus.publish("orders", "a");
+
+		bus.commands.down([
+			["DATA", { kind: "ack", topic: "orders", subscriptionId: "missing", seq: 1 }],
+		]);
+		expect(issues.at(-1)).toEqual([
+			"DATA",
+			expect.objectContaining({ code: "unknown-subscription" }),
+		]);
+
+		const sub = bus.subscription({ topic: "orders", subscriptionId: "s1" });
+		sub.ack(2);
+		expect(issues.at(-1)).toEqual([
+			"DATA",
+			expect.objectContaining({ code: "cursor-out-of-range" }),
+		]);
+		sub.available.up([["PULL", { pullId: sub.availablePullId }]]);
+		expect(sub.available.cache?.cursor.nextSeq).toBe(1);
+		expect(sub.available.cache?.messages.map((msg) => msg.seq)).toEqual([1]);
+	});
+
+	it("closed subscriptions do not receive later retention-gap updates", () => {
+		const g = graph();
+		const bus = messageBus(g, {
+			topics: ["orders"],
+			name: "bus",
+			now: () => 66,
+			retention: { maxMessages: 1 },
+		});
+		const sub = bus.subscription({ topic: "orders", subscriptionId: "s1" });
+		const issues: unknown[] = [];
+		bus.issues.subscribe((msg) => issues.push(msg));
+
+		sub.close();
+		bus.publish("orders", "a");
+		bus.publish("orders", "b");
+
+		expect(issues).not.toContainEqual(["DATA", expect.objectContaining({ code: "retention-gap" })]);
+	});
+});
+
+describe("messageBus topic projection sugar", () => {
+	it("fromTopic returns the pull snapshot node for a topic projection", () => {
+		const g = graph();
+		const bus = messageBus(g, { topics: ["orders"], name: "bus", now: () => 70 });
+		bus.publish("orders", { id: "o1" });
+		const snapshot = fromTopic<{ id: string }>(bus, "orders");
+		const msgs: unknown[] = [];
+		snapshot.subscribe((msg) => msgs.push(msg));
+
+		snapshot.up([["PULL", { pullId: snapshot.pullId as symbol }]]);
+
+		expect(msgs.at(-1)).toEqual([
+			"DATA",
+			expect.objectContaining({ topic: "orders", messages: [expect.objectContaining({ seq: 1 })] }),
+		]);
+	});
+});
diff --git a/packages/ts/src/__tests__/operators-tap.test.ts b/packages/ts/src/__tests__/operators-tap.test.ts
new file mode 100644
index 00000000..c2d28f3a
--- /dev/null
+++ b/packages/ts/src/__tests__/operators-tap.test.ts
@@ -0,0 +1,42 @@
+import { describe, expect, it, vi } from "vitest";
+import type { Message, ObserveEvent } from "../index.js";
+import { fromIter, graph, tap, throwError } from "../index.js";
+
+describe("tap observer terminal edges (Worker C)", () => {
+	it("tap({ error }) observes an upstream ERROR and forwards the ERROR unchanged", () => {
+		const g = graph();
+		const err = new Error("boom");
+		const src = g.initNode(throwError(err), [], { name: "src" });
+		const onError = vi.fn();
+		const t = g.initNode(tap<never>({ error: onError }), [src], { name: "tap" });
+		const msgs: Message[] = [];
+
+		t.subscribe((m) => msgs.push(m));
+
+		expect(onError).toHaveBeenCalledOnce();
+		expect(onError).toHaveBeenCalledWith(err);
+		expect(msgs).toContainEqual(["ERROR", err]);
+		expect(msgs.at(-1)).toEqual(["ERROR", err]);
+		expect(t.status).toBe("errored");
+	});
+});
+
+describe("observe terminal egress (Worker C)", () => {
+	it("observe() sees terminal events at whole-graph scope", () => {
+		const g = graph();
+		const err = new Error("whole graph boom");
+		g.initNode(fromIter([1]), [], { name: "done" });
+		g.initNode(throwError(err), [], { name: "failed" });
+		const events: ObserveEvent[] = [];
+
+		g.observe().subscribe((e) => events.push(e));
+
+		expect(events).toContainEqual(
+			expect.objectContaining({ path: "done", msg: ["COMPLETE"], tier: 5 }),
+		);
+		expect(events).toContainEqual(
+			expect.objectContaining({ path: "failed", msg: ["ERROR", err], tier: 5 }),
+		);
+		expect(new Set(events.map((e) => e.path))).toEqual(new Set(["done", "failed"]));
+	});
+});
diff --git a/packages/ts/src/__tests__/operators.test.ts b/packages/ts/src/__tests__/operators.test.ts
new file mode 100644
index 00000000..fc4e3ac9
--- /dev/null
+++ b/packages/ts/src/__tests__/operators.test.ts
@@ -0,0 +1,643 @@
+import { describe, expect, it, vi } from "vitest";
+import type { Message } from "../index.js";
+import {
+	catchError,
+	distinctUntilChanged,
+	elementAt,
+	filter,
+	find,
+	first,
+	fromIter,
+	graph,
+	initNode,
+	last,
+	map,
+	merge,
+	node,
+	onFirstData,
+	pairwise,
+	reduce,
+	rescue,
+	scan,
+	settle,
+	skip,
+	take,
+	takeWhile,
+	tap,
+	tapFirst,
+	valve,
+} from "../index.js";
+
+const data = (msgs: Message[]) =>
+	msgs.filter((m) => m[0] === "DATA").map((m) => (m as ["DATA", unknown])[1]);
+const lastType = (msgs: Message[]) => msgs[msgs.length - 1]?.[0];
+
+// D43: operators are free-standing factory definitions instantiated via the generic
+// g.initNode funnel (config folded into the factory; fn params annotated). describe still
+// shows the real factory name (D6) — recorded at initNode→_add, node stays thin.
+describe("core operators (free-standing factories via g.initNode, D43/D6)", () => {
+	it("map emits fn(value)", () => {
+		const g = graph();
+		const s = g.state(1);
+		const m = g.initNode(
+			map((n: number) => n * 2),
+			[s],
+		);
+		const msgs: Message[] = [];
+		m.subscribe((x) => msgs.push(x));
+		expect(m.cache).toBe(2);
+		s.set(3);
+		expect(m.cache).toBe(6);
+		expect(data(msgs)).toEqual([2, 6]);
+	});
+
+	it("a tap callback throw becomes operator ERROR instead of escaping (D30)", () => {
+		const g = graph();
+		const s = g.state(1);
+		const boom = new Error("tap boom");
+		const t = g.initNode(
+			tap<number>(() => {
+				throw boom;
+			}),
+			[s],
+		);
+		const msgs: Message[] = [];
+		t.subscribe((m) => msgs.push(m));
+
+		expect(data(msgs)).toEqual([]);
+		expect(msgs.at(-1)).toEqual(["ERROR", boom]);
+		expect(t.status).toBe("errored");
+	});
+
+	it("map consumes every DATA occurrence in one dep-batch (B43 / D49)", () => {
+		const g = graph();
+		const src = g.initNode(fromIter([1, 2, 3]), []);
+		const m = g.initNode(
+			map((n: number) => n * 10),
+			[src],
+		);
+		const msgs: Message[] = [];
+		m.subscribe((x) => msgs.push(x));
+		expect(data(msgs)).toEqual([10, 20, 30]);
+	});
+
+	it("map does not treat same-wave INVALIDATE SENTINEL as DATA (D77/R-sentinel)", () => {
+		const s = node<number>([], null, { initial: 1 });
+		const m = initNode(
+			map((n: number) => n * 2),
+			[s],
+		);
+		const msgs: Message[] = [];
+		m.subscribe((x) => msgs.push(x));
+		msgs.length = 0;
+
+		s.down([["DATA", 9], ["INVALIDATE"]]);
+
+		expect(msgs).toEqual([["DIRTY"], ["DATA", 18], ["INVALIDATE"]]);
+		expect(m.cache).toBeUndefined();
+		expect(m.status).toBe("sentinel");
+	});
+
+	it("filter emits only when pred holds", () => {
+		const g = graph();
+		const s = g.state(2);
+		const evens = g.initNode(
+			filter((n: number) => n % 2 === 0),
+			[s],
+		);
+		const msgs: Message[] = [];
+		evens.subscribe((x) => msgs.push(x));
+		s.set(3); // filtered out
+		s.set(4);
+		expect(data(msgs)).toEqual([2, 4]);
+		expect(evens.cache).toBe(4);
+	});
+
+	it("filter consumes every DATA occurrence in one dep-batch (B43 / D49)", () => {
+		const g = graph();
+		const src = g.initNode(fromIter([1, 2, 3, 4]), []);
+		const evens = g.initNode(
+			filter((n: number) => n % 2 === 0),
+			[src],
+		);
+		const msgs: Message[] = [];
+		evens.subscribe((x) => msgs.push(x));
+		expect(data(msgs)).toEqual([2, 4]);
+	});
+
+	it("downstream map does not re-emit stale DATA on upstream RESOLVED (B43)", () => {
+		const g = graph();
+		const s = g.state(2);
+		const evens = g.initNode(
+			filter((n: number) => n % 2 === 0),
+			[s],
+		);
+		const m = g.initNode(
+			map((n: number) => n * 10),
+			[evens],
+		);
+		const msgs: Message[] = [];
+		m.subscribe((x) => msgs.push(x));
+		s.set(3); // filtered out => evens settles with RESOLVED, no new DATA
+		expect(data(msgs)).toEqual([20]);
+	});
+
+	it("scan accumulates with a seed", () => {
+		const g = graph();
+		const s = g.state(1);
+		const sum = g.initNode(
+			scan((acc: number, v: number) => acc + v, 0),
+			[s],
+		);
+		const msgs: Message[] = [];
+		sum.subscribe((x) => msgs.push(x));
+		s.set(2);
+		s.set(3);
+		expect(data(msgs)).toEqual([1, 3, 6]);
+	});
+
+	it("scan accumulates every DATA occurrence in one dep-batch (B43 / D49)", () => {
+		const g = graph();
+		const src = g.initNode(fromIter([1, 2, 3]), []);
+		const sum = g.initNode(
+			scan((acc: number, v: number) => acc + v, 0),
+			[src],
+		);
+		const msgs: Message[] = [];
+		sum.subscribe((x) => msgs.push(x));
+		expect(data(msgs)).toEqual([1, 3, 6]);
+	});
+
+	it("take emits the first n then COMPLETE (terminal-is-forever)", () => {
+		const g = graph();
+		const s = g.state(1);
+		const first2 = g.initNode(take<number>(2), [s]);
+		const msgs: Message[] = [];
+		first2.subscribe((x) => msgs.push(x));
+		s.set(2); // 2nd value → DATA + COMPLETE (a DIRTY precedes the DATA, two-phase)
+		s.set(3); // ignored (terminated)
+		expect(data(msgs)).toEqual([1, 2]);
+		expect(msgs[msgs.length - 1][0]).toBe("COMPLETE");
+		expect(first2.status).toBe("completed");
+	});
+
+	it("take counts occurrences inside one dep-batch (B43 / D49)", () => {
+		const g = graph();
+		const src = g.initNode(fromIter([1, 2, 3]), []);
+		const first2 = g.initNode(take<number>(2), [src]);
+		const msgs: Message[] = [];
+		first2.subscribe((m) => msgs.push(m));
+		expect(data(msgs)).toEqual([1, 2]);
+		expect(first2.status).toBe("completed");
+	});
+
+	it("take(0) emits no DATA and completes immediately", () => {
+		const g = graph();
+		const s = g.state(1);
+		const none = g.initNode(take<number>(0), [s]);
+		const msgs: Message[] = [];
+		none.subscribe((m) => msgs.push(m));
+		const terminalMsgs = [...msgs];
+		s.set(2); // ignored after terminal completion
+		expect(data(msgs)).toEqual([]);
+		expect(lastType(msgs)).toBe("COMPLETE");
+		expect(msgs).toEqual(terminalMsgs);
+		expect(none.status).toBe("completed");
+	});
+
+	it("take completes quietly when upstream completes before n", () => {
+		const g = graph();
+		const src = g.initNode(fromIter([1, 2]), []);
+		const first5 = g.initNode(take<number>(5), [src]);
+		const msgs: Message[] = [];
+		first5.subscribe((m) => msgs.push(m));
+		expect(data(msgs)).toEqual([1, 2]);
+		expect(lastType(msgs)).toBe("COMPLETE");
+		expect(first5.status).toBe("completed");
+	});
+
+	it("distinctUntilChanged suppresses repeats", () => {
+		const g = graph();
+		const s = g.state(1);
+		const d = g.initNode(distinctUntilChanged<number>(), [s]);
+		const msgs: Message[] = [];
+		d.subscribe((x) => msgs.push(x));
+		s.set(1); // same → suppressed
+		s.set(2);
+		s.set(2); // same → suppressed
+		s.set(3);
+		expect(data(msgs)).toEqual([1, 2, 3]);
+	});
+
+	it("distinctUntilChanged handles repeats within one dep-batch (B43)", () => {
+		const g = graph();
+		const src = g.initNode(fromIter([1, 1, 2, 2, 3]), []);
+		const d = g.initNode(distinctUntilChanged<number>(), [src]);
+		const msgs: Message[] = [];
+		d.subscribe((x) => msgs.push(x));
+		expect(data(msgs)).toEqual([1, 2, 3]);
+	});
+
+	it("merge interleaves several sources (partial — fires on any)", () => {
+		const g = graph();
+		const a = g.state(1);
+		const b = g.state(2);
+		const m = g.initNode(merge<number>(), [a, b]);
+		const vals: unknown[] = [];
+		m.subscribe((msg) => {
+			if (msg[0] === "DATA") vals.push(msg[1]);
+		});
+		expect(vals).toContain(1);
+		expect(vals).toContain(2);
+		a.set(10);
+		expect(vals).toContain(10);
+		b.set(20);
+		expect(vals).toContain(20);
+	});
+
+	it("describe shows the real operator factory name (D6), not 'derived'", () => {
+		const g = graph();
+		const s = g.state(0, { name: "s" });
+		g.initNode(
+			map((n: number) => n + 1),
+			[s],
+			{ name: "inc" },
+		);
+		g.initNode(
+			filter((n: number) => n > 0),
+			[s],
+			{ name: "pos" },
+		);
+		const snap = g.describe();
+		const byId = Object.fromEntries(snap.nodes.map((n) => [n.id, n]));
+		expect(byId.inc.factory).toBe("map");
+		expect(byId.pos.factory).toBe("filter");
+	});
+
+	it("operators work bare (no Graph) via the free initNode", () => {
+		const g = graph();
+		const s = g.state(5);
+		// Bare-node path (D43): the free initNode builds a working Node with NO graph
+		// registration (s is created on g, the bare operator just subscribes to it).
+		const doubled = initNode(
+			map((n: number) => n * 2),
+			[s],
+		);
+		const msgs: Message[] = [];
+		doubled.subscribe((x) => msgs.push(x));
+		expect(doubled.cache).toBe(10);
+		s.set(6);
+		expect(doubled.cache).toBe(12);
+		expect(data(msgs)).toEqual([10, 12]);
+	});
+});
+
+// CSP-2.7 catalog re-derive (D40): Slice 1 (single-dep transform/take/control) + Slice 3
+// (error-handling). Per-language sugar (D6/D24, never in parity). Terminal-emitting operators read
+// depTerminal(ctx, 0) (R-deps-terminal). D49: every occurrence is DATA; a no-emit wave →
+// substrate-synthesized undirty RESOLVED.
+describe("Slice 1 — single-dep transform/take/control (CSP-2.7)", () => {
+	it("reduce emits the final accumulator on source COMPLETE", () => {
+		const g = graph();
+		const src = g.initNode(fromIter([1, 2, 3]), []);
+		const r = g.initNode(
+			reduce((acc: number, v: number) => acc + v, 0),
+			[src],
+		);
+		const msgs: Message[] = [];
+		r.subscribe((m) => msgs.push(m));
+		expect(data(msgs)).toEqual([6]);
+		expect(lastType(msgs)).toBe("COMPLETE");
+		expect(r.status).toBe("completed");
+	});
+
+	it("reduce on an empty source emits the seed", () => {
+		const g = graph();
+		const empty = g.initNode(fromIter<number>([]), []);
+		const r = g.initNode(
+			reduce((acc: number, v: number) => acc + v, 42),
+			[empty],
+		);
+		const msgs: Message[] = [];
+		r.subscribe((m) => msgs.push(m));
+		expect(data(msgs)).toEqual([42]);
+		expect(lastType(msgs)).toBe("COMPLETE");
+	});
+
+	it("pairwise emits consecutive [prev, curr]; first value produces no pair", () => {
+		const g = graph();
+		const s = g.state(1);
+		const p = g.initNode(pairwise<number>(), [s]);
+		const msgs: Message[] = [];
+		p.subscribe((m) => msgs.push(m));
+		s.set(2);
+		s.set(3);
+		expect(data(msgs)).toEqual([
+			[1, 2],
+			[2, 3],
+		]);
+	});
+
+	it("pairwise emits in-batch consecutive pairs (B43)", () => {
+		const g = graph();
+		const src = g.initNode(fromIter([1, 2, 3, 4]), []);
+		const p = g.initNode(pairwise<number>(), [src]);
+		const msgs: Message[] = [];
+		p.subscribe((m) => msgs.push(m));
+		expect(data(msgs)).toEqual([
+			[1, 2],
+			[2, 3],
+			[3, 4],
+		]);
+	});
+
+	it("skip drops the first n DATA", () => {
+		const g = graph();
+		const s = g.state(1);
+		const sk = g.initNode(skip<number>(2), [s]);
+		const msgs: Message[] = [];
+		sk.subscribe((m) => msgs.push(m));
+		s.set(2); // skipped (count 1)
+		s.set(3); // emitted
+		s.set(4); // emitted
+		expect(data(msgs)).toEqual([3, 4]);
+	});
+
+	it("skip drops occurrences inside one dep-batch (B43)", () => {
+		const g = graph();
+		const src = g.initNode(fromIter([1, 2, 3, 4]), []);
+		const sk = g.initNode(skip<number>(2), [src]);
+		const msgs: Message[] = [];
+		sk.subscribe((m) => msgs.push(m));
+		expect(data(msgs)).toEqual([3, 4]);
+	});
+
+	it("skip can swallow the full upstream window without leaking DATA", () => {
+		const g = graph();
+		const src = g.initNode(fromIter([1, 2]), []);
+		const sk = g.initNode(skip<number>(2), [src]);
+		const msgs: Message[] = [];
+		sk.subscribe((m) => msgs.push(m));
+		expect(data(msgs)).toEqual([]);
+		expect(lastType(msgs)).toBe("COMPLETE");
+		expect(sk.status).toBe("completed");
+	});
+
+	it("takeWhile emits while pred holds, then COMPLETE (non-inclusive)", () => {
+		const g = graph();
+		const s = g.state(1);
+		const tw = g.initNode(
+			takeWhile((n: number) => n < 3),
+			[s],
+		);
+		const msgs: Message[] = [];
+		tw.subscribe((m) => msgs.push(m));
+		s.set(2);
+		s.set(3); // fails pred → COMPLETE, not emitted
+		s.set(4); // terminated, ignored
+		expect(data(msgs)).toEqual([1, 2]);
+		expect(tw.status).toBe("completed");
+	});
+
+	it("takeWhile processes each in-batch occurrence and completes at first failing item (B43)", () => {
+		const g = graph();
+		const src = g.initNode(fromIter([1, 2, 3, 4]), []);
+		const tw = g.initNode(
+			takeWhile((n: number) => n < 3),
+			[src],
+		);
+		const msgs: Message[] = [];
+		tw.subscribe((m) => msgs.push(m));
+		expect(data(msgs)).toEqual([1, 2]);
+		expect(tw.status).toBe("completed");
+	});
+
+	it("first emits the first matching value then COMPLETE", () => {
+		const g = graph();
+		const s = g.state(1);
+		const f = g.initNode(
+			first((n: number) => n > 2),
+			[s],
+		);
+		const msgs: Message[] = [];
+		f.subscribe((m) => msgs.push(m));
+		s.set(2); // no match
+		s.set(5); // first match
+		s.set(6); // terminated
+		expect(data(msgs)).toEqual([5]);
+		expect(f.status).toBe("completed");
+	});
+
+	it("first picks the earliest matching occurrence in one dep-batch (B43)", () => {
+		const g = graph();
+		const src = g.initNode(fromIter([1, 2, 3, 4]), []);
+		const f = g.initNode(
+			first((n: number) => n > 1),
+			[src],
+		);
+		const msgs: Message[] = [];
+		f.subscribe((m) => msgs.push(m));
+		expect(data(msgs)).toEqual([2]);
+		expect(f.status).toBe("completed");
+	});
+
+	it("last emits the last matching value on COMPLETE", () => {
+		const g = graph();
+		const src = g.initNode(fromIter([1, 2, 3, 4]), []);
+		const l = g.initNode(
+			last((n: number) => n % 2 === 0),
+			[src],
+		);
+		const msgs: Message[] = [];
+		l.subscribe((m) => msgs.push(m));
+		expect(data(msgs)).toEqual([4]);
+		expect(lastType(msgs)).toBe("COMPLETE");
+	});
+
+	it("last no-match completes without emitting DATA", () => {
+		const g = graph();
+		const src = g.initNode(fromIter([1, 3]), []);
+		const l = g.initNode(
+			last((n: number) => n % 2 === 0),
+			[src],
+		);
+		const msgs: Message[] = [];
+		l.subscribe((m) => msgs.push(m));
+		expect(data(msgs)).toEqual([]);
+		expect(lastType(msgs)).toBe("COMPLETE");
+		expect(l.status).toBe("completed");
+	});
+
+	it("find emits the first matching value then COMPLETE", () => {
+		const g = graph();
+		const src = g.initNode(fromIter([1, 2, 3, 4]), []);
+		const fd = g.initNode(
+			find((n: number) => n > 2),
+			[src],
+		);
+		const msgs: Message[] = [];
+		fd.subscribe((m) => msgs.push(m));
+		expect(data(msgs)).toEqual([3]);
+		expect(fd.status).toBe("completed");
+	});
+
+	it("find not-found → bare COMPLETE (no undefined emit, SENTINEL edge)", () => {
+		const g = graph();
+		const src = g.initNode(fromIter([1, 2]), []);
+		const fd = g.initNode(
+			find((n: number) => n > 100),
+			[src],
+		);
+		const msgs: Message[] = [];
+		fd.subscribe((m) => msgs.push(m));
+		expect(data(msgs)).toEqual([]);
+		expect(lastType(msgs)).toBe("COMPLETE");
+	});
+
+	it("elementAt emits the value at the index then COMPLETE", () => {
+		const g = graph();
+		const src = g.initNode(fromIter([10, 20, 30]), []);
+		const e = g.initNode(elementAt<number>(1), [src]);
+		const msgs: Message[] = [];
+		e.subscribe((m) => msgs.push(m));
+		expect(data(msgs)).toEqual([20]);
+		expect(e.status).toBe("completed");
+	});
+
+	it("tap (function form) runs the side effect and passes values through", () => {
+		const g = graph();
+		const s = g.state(1);
+		const spy = vi.fn();
+		const t = g.initNode(tap<number>(spy), [s]);
+		const msgs: Message[] = [];
+		t.subscribe((m) => msgs.push(m));
+		s.set(2);
+		expect(data(msgs)).toEqual([1, 2]);
+		expect(spy.mock.calls).toEqual([[1], [2]]);
+	});
+
+	it("tap (observer form) observes data + complete", () => {
+		const g = graph();
+		const src = g.initNode(fromIter([7, 8]), []);
+		const onData = vi.fn();
+		const onComplete = vi.fn();
+		const t = g.initNode(tap<number>({ data: onData, complete: onComplete }), [src]);
+		const msgs: Message[] = [];
+		t.subscribe((m) => msgs.push(m));
+		expect(data(msgs)).toEqual([7, 8]);
+		expect(onData.mock.calls).toEqual([[7], [8]]);
+		expect(onComplete).toHaveBeenCalledOnce();
+		expect(lastType(msgs)).toBe("COMPLETE");
+	});
+
+	it("onFirstData fires once on the first qualifying value", () => {
+		const g = graph();
+		const s = g.state(1);
+		const spy = vi.fn();
+		const o = g.initNode(onFirstData<number>(spy), [s]);
+		const msgs: Message[] = [];
+		o.subscribe((m) => msgs.push(m));
+		s.set(2);
+		s.set(3);
+		expect(data(msgs)).toEqual([1, 2, 3]);
+		expect(spy).toHaveBeenCalledOnce();
+		expect(spy).toHaveBeenCalledWith(1);
+	});
+
+	it("settle forwards DATA and COMPLETEs after quietWaves of no change", () => {
+		const g = graph();
+		const s = g.state(1);
+		const st = g.initNode(settle<number>({ quietWaves: 2, equals: (a, b) => a === b }), [s]);
+		const msgs: Message[] = [];
+		st.subscribe((m) => msgs.push(m));
+		s.set(1); // no change → quiet 1
+		s.set(1); // no change → quiet 2 → COMPLETE
+		expect(data(msgs)).toEqual([1, 1, 1]);
+		expect(st.status).toBe("completed");
+	});
+
+	it("describe shows the real catalog factory names (D6)", () => {
+		const g = graph();
+		const s = g.state(0, { name: "s" });
+		g.initNode(skip<number>(1), [s], { name: "sk" });
+		g.initNode(pairwise<number>(), [s], { name: "pw" });
+		const byId = Object.fromEntries(g.describe().nodes.map((n) => [n.id, n]));
+		expect(byId.sk.factory).toBe("skip");
+		expect(byId.pw.factory).toBe("pairwise");
+	});
+});
+
+describe("Slice 3 — error-handling control (CSP-2.7)", () => {
+	// A source that ERRORs on a sentinel value (D30 throw→ERROR at the derived boundary).
+	const flakyChain = (g: ReturnType<typeof graph>) => {
+		const s = g.state(1);
+		const bad = g.derived([s], (v: number) => {
+			if (v === 2) throw new Error("boom");
+			return v * 10;
+		});
+		return { s, bad };
+	};
+
+	it("rescue replaces an upstream ERROR with a recovered value (stream stays live)", () => {
+		const g = graph();
+		const { s, bad } = flakyChain(g);
+		const r = g.initNode(
+			rescue<number>(() => -1),
+			[bad],
+		);
+		const msgs: Message[] = [];
+		r.subscribe((m) => msgs.push(m));
+		expect(data(msgs)).toEqual([10]);
+		s.set(2); // bad throws → ERROR → rescue recovers → -1
+		expect(data(msgs)).toEqual([10, -1]);
+		expect(r.status).not.toBe("errored");
+	});
+
+	it("rescue forwards a normal source COMPLETE", () => {
+		const g = graph();
+		const src = g.initNode(fromIter([1, 2]), []);
+		const r = g.initNode(
+			rescue<number>(() => -1),
+			[src],
+		);
+		const msgs: Message[] = [];
+		r.subscribe((m) => msgs.push(m));
+		expect(data(msgs)).toEqual([1, 2]);
+		expect(lastType(msgs)).toBe("COMPLETE");
+	});
+
+	it("catchError is the rescue alias", () => {
+		expect(catchError).toBe(rescue);
+	});
+
+	it("tapFirst is the onFirstData alias", () => {
+		expect(tapFirst).toBe(onFirstData);
+	});
+
+	it("valve gates DATA on a boolean control, re-emits on gate open", () => {
+		const g = graph();
+		const src = g.state(1);
+		const open = g.state(true);
+		const v = g.initNode(valve<number>(), [src, open]);
+		const msgs: Message[] = [];
+		v.subscribe((m) => msgs.push(m));
+		expect(data(msgs)).toEqual([1]); // open at activation → forwards
+		open.set(false); // close
+		src.set(2); // gated out
+		expect(data(msgs)).toEqual([1]);
+		open.set(true); // re-open → re-emit last source value (2)
+		expect(data(msgs)).toEqual([1, 2]);
+	});
+
+	it("valve fires abortInFlight on the truthy→falsy edge only", () => {
+		const g = graph();
+		const src = g.state(1);
+		const open = g.state(true);
+		const ctrl = new AbortController();
+		const v = g.initNode(valve<number>({ abortInFlight: ctrl }), [src, open]);
+		v.subscribe(() => {});
+		expect(ctrl.signal.aborted).toBe(false);
+		open.set(false); // truthy→falsy edge → abort
+		expect(ctrl.signal.aborted).toBe(true);
+	});
+});
diff --git a/packages/ts/src/__tests__/orchestration-work-queue-recipes.test.ts b/packages/ts/src/__tests__/orchestration-work-queue-recipes.test.ts
new file mode 100644
index 00000000..fab4e6e9
--- /dev/null
+++ b/packages/ts/src/__tests__/orchestration-work-queue-recipes.test.ts
@@ -0,0 +1,138 @@
+import { describe, expect, it } from "vitest";
+import { graph } from "../graph/graph.js";
+import type { ProcessEffectRequest } from "../orchestration/index.js";
+import {
+	type OrchestrationQueuedEffectPayload,
+	orchestrationWorkQueueRecipe,
+} from "../orchestration/work-queue.js";
+import type { WorkQueueRecord } from "../work-queue/index.js";
+
+describe("orchestration workQueue recipe (D349/D353)", () => {
+	it("maps terminal queue records to recipe evidence, not ProcessBundle status truth", () => {
+		const g = graph();
+		const records = g.node<WorkQueueRecord<OrchestrationQueuedEffectPayload>>([], null, {
+			name: "queueRecords",
+		});
+		const recipe = orchestrationWorkQueueRecipe(g, { records });
+		const evidence = collectData(recipe.evidence);
+		const status = collectData(recipe.status);
+
+		records.down([
+			["DATA", admittedRecord()],
+			[
+				"DATA",
+				{
+					kind: "work-completed",
+					recordSeq: 2,
+					queueId: "q",
+					workId: "work-1",
+					leaseId: "lease-1",
+					attempt: 1,
+					workerId: "worker-1",
+					result: { ok: true },
+					recordedAtMs: 120,
+				} satisfies WorkQueueRecord<OrchestrationQueuedEffectPayload>,
+			],
+		]);
+
+		expect(evidence.at(-1)).toEqual(
+			expect.objectContaining({
+				kind: "orchestration-queue-evidence",
+				effectId: "effect-1",
+				queueRecordKind: "work-completed",
+			}),
+		);
+		expect(status.at(-1)).toEqual(
+			expect.objectContaining({
+				kind: "orchestration-queue-status",
+				state: "evidence-recorded",
+				effectId: "effect-1",
+			}),
+		);
+		expect(Object.hasOwn(status.at(-1) ?? {}, "eventCount")).toBe(false);
+	});
+
+	it("surfaces malformed admitted payloads as recipe issues", () => {
+		const g = graph();
+		const records = g.node<WorkQueueRecord<OrchestrationQueuedEffectPayload>>([], null, {
+			name: "queueRecords",
+		});
+		const recipe = orchestrationWorkQueueRecipe(g, { records });
+		const issues = collectData(recipe.issues);
+		const status = collectData(recipe.status);
+		const audit = collectData(recipe.audit);
+
+		records.down([["DATA", malformedAdmittedRecord()]]);
+
+		expect(issues.at(-1)).toEqual(
+			expect.objectContaining({ code: "orchestration-queue-malformed-payload" }),
+		);
+		expect(status.at(-1)).toEqual(
+			expect.objectContaining({
+				kind: "orchestration-queue-status",
+				state: "mapping-issue",
+				workId: "work-bad",
+				queueRecordKind: "work-admitted",
+			}),
+		);
+		expect(audit.at(-1)).toEqual(
+			expect.objectContaining({
+				kind: "orchestration-queue-audit",
+				outcome: "issue",
+				workId: "work-bad",
+			}),
+		);
+	});
+});
+
+function collectData<T>(node: {
+	subscribe(sink: (msg: readonly [string, unknown?]) => void): unknown;
+}): T[] {
+	const out: T[] = [];
+	node.subscribe((msg) => {
+		if (msg[0] === "DATA") out.push(msg[1] as T);
+	});
+	return out;
+}
+
+function effect(): ProcessEffectRequest {
+	return {
+		id: "effect-1",
+		type: "send-email",
+		seq: 1,
+		cursor: 1,
+		commandId: "cmd-1",
+		commandType: "start",
+		payload: { to: "team@example.com" },
+		timestampMs: 100,
+	};
+}
+
+function admittedRecord(): WorkQueueRecord<OrchestrationQueuedEffectPayload> {
+	return {
+		kind: "work-admitted",
+		recordSeq: 1,
+		queueId: "q",
+		workId: "work-1",
+		commandId: "admit-1",
+		recordedAtMs: 100,
+		payload: {
+			kind: "orchestration-queued-effect",
+			effect: effect(),
+		},
+		messageBus: { topic: "work", seq: 1, subscriptionId: "sub" },
+	};
+}
+
+function malformedAdmittedRecord(): WorkQueueRecord<OrchestrationQueuedEffectPayload> {
+	return {
+		kind: "work-admitted",
+		recordSeq: 1,
+		queueId: "q",
+		workId: "work-bad",
+		commandId: "admit-bad",
+		recordedAtMs: 100,
+		payload: null,
+		messageBus: { topic: "work", seq: 1, subscriptionId: "sub" },
+	} as unknown as WorkQueueRecord<OrchestrationQueuedEffectPayload>;
+}
diff --git a/packages/ts/src/__tests__/orchestration.test.ts b/packages/ts/src/__tests__/orchestration.test.ts
new file mode 100644
index 00000000..f3de38ab
--- /dev/null
+++ b/packages/ts/src/__tests__/orchestration.test.ts
@@ -0,0 +1,593 @@
+import { describe, expect, it } from "vitest";
+import { graph } from "../graph/graph.js";
+import {
+	backoffDelayMs,
+	breakerBundle,
+	type ProcessEffectCommandPayload,
+	type ProcessEffectOutcome,
+	processBundle,
+	processEffectRunner,
+	rateLimitBundle,
+	retryPolicy,
+	retryStatusBundle,
+} from "../orchestration/index.js";
+
+describe("graph-visible resilience bundles (D132)", () => {
+	it("shares bounded retry/backoff policy semantics", () => {
+		const policy = retryPolicy(3, {
+			kind: "linear",
+			initialMs: 10,
+			stepMs: 5,
+			maxMs: 18,
+		});
+		expect(backoffDelayMs(policy.backoff, 1)).toBe(10);
+		expect(backoffDelayMs(policy.backoff, 3)).toBe(18);
+	});
+
+	it("projects retry and breaker status from graph-visible event facts", () => {
+		const g = graph();
+		const events = g.node<{
+			kind: "attempt" | "failure" | "success";
+			attempt?: number;
+			error?: unknown;
+		}>([], null, { name: "resilience/events" });
+		const retry = retryStatusBundle(g, events, {
+			name: "retry",
+			policy: retryPolicy(2, { kind: "constant", delayMs: 25 }),
+		});
+		const breaker = breakerBundle(g, events, {
+			name: "breaker",
+			failureThreshold: 1,
+			now: () => 100,
+		});
+		const retryStatuses: unknown[] = [];
+		const breakerStatuses: unknown[] = [];
+		retry.status.subscribe((msg) => retryStatuses.push(msg));
+		breaker.status.subscribe((msg) => breakerStatuses.push(msg));
+
+		events.down([["DATA", { kind: "attempt", attempt: 1 }]]);
+		events.down([["DATA", { kind: "failure", attempt: 1, error: "nope" }]]);
+
+		expect(retryStatuses.at(-1)).toEqual([
+			"DATA",
+			{ state: "failed", attempt: 1, maxAttempts: 2, delayMs: 25 },
+		]);
+		expect(breakerStatuses.at(-1)).toEqual([
+			"DATA",
+			{ state: "open", failures: 1, openedAtMs: 100 },
+		]);
+	});
+
+	it("rate-limits DATA while exposing allowed/dropped/status nodes", () => {
+		let now = 0;
+		const g = graph();
+		const source = g.node<number>([], null, { name: "source" });
+		const bundle = rateLimitBundle(g, source, {
+			name: "limit",
+			max: 2,
+			windowMs: 100,
+			now: () => now,
+		});
+		const allowed: unknown[] = [];
+		const dropped: unknown[] = [];
+		const statuses: unknown[] = [];
+		bundle.allowed.subscribe((msg) => allowed.push(msg));
+		bundle.dropped.subscribe((msg) => dropped.push(msg));
+		bundle.status.subscribe((msg) => statuses.push(msg));
+
+		source.down([
+			["DATA", 1],
+			["DATA", 2],
+			["DATA", 3],
+		]);
+		now = 101;
+		source.down([["DATA", 4]]);
+
+		expect(allowed.filter((msg) => Array.isArray(msg) && msg[0] === "DATA")).toEqual([
+			["DATA", 1],
+			["DATA", 2],
+			["DATA", 4],
+		]);
+		expect(dropped).toContainEqual(["DATA", 3]);
+		expect(statuses.at(-1)).toEqual([
+			"DATA",
+			{ allowed: 3, dropped: 1, remaining: 1, resetAtMs: 201 },
+		]);
+	});
+});
+
+describe("ProcessBundle — graph-visible facts-plus-reducer orchestration (D136)", () => {
+	it("reduces commands into visible state, events, effects, status, audit, and cursor facts", () => {
+		const g = graph();
+		const process = processBundle<
+			{ amount?: number },
+			{ total: number },
+			{ total: number },
+			{ url: string }
+		>(g, {
+			name: "order",
+			initialState: { total: 0 },
+			now: () => 123,
+			reduce(command, state) {
+				const total = state.total + (command.payload.amount ?? 0);
+				return {
+					state: { total },
+					events: [{ type: "amount-added", payload: { total } }],
+					effects: [{ type: "notify", payload: { url: `/orders/${command.processId}` } }],
+				};
+			},
+		});
+
+		process.dispatch({
+			id: "cmd-1",
+			type: "add",
+			processId: "p-1",
+			payload: { amount: 7 },
+		});
+
+		expect(process.state.cache).toEqual({ total: 7 });
+		expect(process.events.cache).toMatchObject({
+			id: "cmd-1:event:1",
+			type: "amount-added",
+			seq: 1,
+			cursor: 1,
+			commandId: "cmd-1",
+			commandType: "add",
+			payload: { total: 7 },
+			timestampMs: 123,
+		});
+		expect(process.effectRequests.cache).toMatchObject({
+			id: "cmd-1:effect:1",
+			type: "notify",
+			seq: 1,
+			cursor: 1,
+			commandId: "cmd-1",
+			commandType: "add",
+			payload: { url: "/orders/p-1" },
+			timestampMs: 123,
+		});
+		expect(process.status.cache).toEqual({
+			state: "accepted",
+			commandId: "cmd-1",
+			commandType: "add",
+			eventCount: 1,
+			effectCount: 1,
+			cursor: { eventSeq: 1, effectSeq: 1, commandCount: 1, errorCount: 0, auditSeq: 0 },
+		});
+		expect(process.audit.cache).toEqual({
+			seq: 1,
+			commandId: "cmd-1",
+			commandType: "add",
+			outcome: "success",
+			eventIds: ["cmd-1:event:1"],
+			eventTypes: ["amount-added"],
+			effectIds: ["cmd-1:effect:1"],
+			effectTypes: ["notify"],
+			cursor: { eventSeq: 1, effectSeq: 1, commandCount: 1, errorCount: 0, auditSeq: 1 },
+		});
+		expect(process.cursor.cache).toEqual({
+			eventSeq: 1,
+			effectSeq: 1,
+			commandCount: 1,
+			errorCount: 0,
+			auditSeq: 1,
+		});
+		expect(process.errors.cache).toBeUndefined();
+	});
+
+	it("keeps process.cursor as the final command-attempt high-water, not a read offset", () => {
+		const g = graph();
+		const process = processBundle<
+			{ ok: boolean },
+			{ count: number },
+			{ ok: boolean },
+			{ task: string }
+		>(g, {
+			name: "process",
+			initialState: { count: 0 },
+			reduce(command, state) {
+				if (!command.payload.ok) throw new Error("nope");
+				return {
+					state: { count: state.count + 1 },
+					events: [{ type: "accepted", payload: { ok: true } }],
+					effects: [{ type: "notify", payload: { task: command.id } }],
+				};
+			},
+		});
+
+		process.dispatch({ id: "cmd-1", type: "run", payload: { ok: true } });
+		expect(process.events.cache?.cursor).toBe(1);
+		expect(process.effectRequests.cache?.cursor).toBe(1);
+		expect(process.status.cache?.cursor).toEqual({
+			eventSeq: 1,
+			effectSeq: 1,
+			commandCount: 1,
+			errorCount: 0,
+			auditSeq: 0,
+		});
+		expect(process.cursor.cache).toEqual({
+			eventSeq: 1,
+			effectSeq: 1,
+			commandCount: 1,
+			errorCount: 0,
+			auditSeq: 1,
+		});
+
+		process.dispatch({ id: "cmd-2", type: "run", payload: { ok: false } });
+		expect(process.errors.cache?.cursor).toEqual({
+			eventSeq: 1,
+			effectSeq: 1,
+			commandCount: 2,
+			errorCount: 1,
+			auditSeq: 1,
+		});
+		expect(process.cursor.cache).toEqual({
+			eventSeq: 1,
+			effectSeq: 1,
+			commandCount: 2,
+			errorCount: 1,
+			auditSeq: 2,
+		});
+	});
+
+	it("keeps the ProcessBundle topology describe-visible with declared graph deps", () => {
+		const g = graph();
+		processBundle(g, {
+			name: "process",
+			initialState: { open: true },
+			reduce: (_command, state) => ({ state }),
+		});
+
+		const snap = g.describe();
+		const byId = Object.fromEntries(snap.nodes.map((node) => [node.id, node]));
+		expect(byId["process/command"].factory).toBe("processCommand");
+		expect(byId["process/runtime"].deps).toEqual(["process/command"]);
+		expect(byId["process/state"].deps).toEqual(["process/runtime"]);
+		expect(byId["process/effectRequests"].deps).toEqual(["process/runtime"]);
+		expect(snap.edges).toContainEqual({ from: "process/command", to: "process/runtime" });
+		expect(snap.edges).toContainEqual({ from: "process/runtime", to: "process/state" });
+	});
+
+	it("surfaces reducer failures as process error/status/audit DATA facts without mutating state", () => {
+		const g = graph();
+		const process = processBundle<{ ok: boolean }, { count: number }>(g, {
+			name: "process",
+			initialState: { count: 0 },
+			reduce(command, state) {
+				if (!command.payload.ok) throw new Error("process failed");
+				return { state: { count: state.count + 1 } };
+			},
+		});
+
+		process.dispatch({ id: "bad", type: "run", payload: { ok: false } });
+
+		expect(process.state.cache).toBeUndefined();
+		expect(process.errors.cache).toMatchObject({
+			code: "reducer-threw",
+			message: "process failed",
+			commandId: "bad",
+			commandType: "run",
+			cursor: { eventSeq: 0, effectSeq: 0, commandCount: 1, errorCount: 1, auditSeq: 0 },
+		});
+		expect(process.status.cache).toEqual({
+			state: "rejected",
+			commandId: "bad",
+			commandType: "run",
+			eventCount: 0,
+			effectCount: 0,
+			errorCode: "reducer-threw",
+			cursor: { eventSeq: 0, effectSeq: 0, commandCount: 1, errorCount: 1, auditSeq: 0 },
+		});
+		expect(process.audit.cache).toEqual({
+			seq: 1,
+			commandId: "bad",
+			commandType: "run",
+			outcome: "failure",
+			eventIds: [],
+			eventTypes: [],
+			effectIds: [],
+			effectTypes: [],
+			errorCode: "reducer-threw",
+			errorMessage: "process failed",
+			cursor: { eventSeq: 0, effectSeq: 0, commandCount: 1, errorCount: 1, auditSeq: 1 },
+		});
+		expect(process.cursor.cache).toEqual({
+			eventSeq: 0,
+			effectSeq: 0,
+			commandCount: 1,
+			errorCount: 1,
+			auditSeq: 1,
+		});
+	});
+
+	it("fails honestly for malformed commands and undefined visible state", () => {
+		const g = graph();
+		expect(() =>
+			processBundle(g, {
+				name: "bad",
+				initialState: undefined,
+				reduce: (_command, state) => ({ state }),
+			}),
+		).toThrow(/initialState/);
+
+		const process = processBundle<{ ok: boolean }, { count: number }>(g, {
+			name: "process",
+			initialState: { count: 0 },
+			reduce: (command, state) => (command.payload.ok ? { state } : { state: undefined as never }),
+		});
+		process.command.down([["DATA", { type: "missing-id", payload: { ok: true } } as never]]);
+		expect(process.errors.cache).toMatchObject({
+			code: "malformed-command",
+			message: "processBundle: command id must be a non-empty string",
+		});
+
+		process.dispatch({ id: "undef", type: "run", payload: { ok: false } });
+		expect(process.errors.cache).toMatchObject({
+			code: "malformed-state",
+			message: "processBundle: reducer state must not be undefined",
+			commandId: "undef",
+		});
+	});
+
+	it("does not let failed reducer attempts mutate hidden process state", () => {
+		const g = graph();
+		const process = processBundle<{ ok: boolean }, { count: number }>(g, {
+			name: "process",
+			initialState: { count: 0 },
+			reduce(command, state) {
+				state.count += 100;
+				if (!command.payload.ok) throw new Error("boom");
+				return { state: { count: state.count + 1 } };
+			},
+		});
+
+		process.dispatch({ id: "bad", type: "run", payload: { ok: false } });
+		process.dispatch({ id: "good", type: "run", payload: { ok: true } });
+
+		expect(process.state.cache).toEqual({ count: 101 });
+		expect(process.status.cache).toMatchObject({ state: "accepted", commandId: "good" });
+	});
+
+	it("keeps public state cache mutations from aliasing the next reducer input", () => {
+		const g = graph();
+		const process = processBundle<{ amount: number }, { count: number }>(g, {
+			name: "process",
+			initialState: { count: 0 },
+			reduce(command, state) {
+				return { state: { count: state.count + command.payload.amount } };
+			},
+		});
+
+		process.dispatch({ id: "cmd-1", type: "add", payload: { amount: 1 } });
+		(process.state.cache as { count: number }).count = 1000;
+		process.dispatch({ id: "cmd-2", type: "add", payload: { amount: 1 } });
+
+		expect(process.state.cache).toEqual({ count: 2 });
+	});
+
+	it("accepts primitive string process state without confusing it for clone failure", () => {
+		const g = graph();
+		const process = processBundle<{ suffix: string }, string>(g, {
+			name: "process",
+			initialState: "start",
+			reduce(command, state) {
+				return { state: `${state}:${command.payload.suffix}` };
+			},
+		});
+
+		process.dispatch({ id: "cmd-1", type: "append", payload: { suffix: "next" } });
+
+		expect(process.state.cache).toBe("start:next");
+		expect(process.errors.cache).toBeUndefined();
+	});
+
+	it("rejects duplicate event and effect ids across command reductions", () => {
+		const g = graph();
+		const process = processBundle<{ mode: "event" | "effect" }, { count: number }>(g, {
+			name: "process",
+			initialState: { count: 0 },
+			reduce(command, state) {
+				return command.payload.mode === "event"
+					? {
+							state: { count: state.count + 1 },
+							events: [{ id: "same", type: "seen", payload: {} }],
+						}
+					: {
+							state: { count: state.count + 1 },
+							effects: [{ id: "same-effect", type: "call", payload: {} }],
+						};
+			},
+		});
+
+		process.dispatch({ id: "event-1", type: "run", payload: { mode: "event" } });
+		process.dispatch({ id: "event-2", type: "run", payload: { mode: "event" } });
+		expect(process.errors.cache).toMatchObject({
+			code: "malformed-event",
+			message: "processBundle: duplicate event 'same'",
+			commandId: "event-2",
+		});
+		expect(process.state.cache).toEqual({ count: 1 });
+
+		process.dispatch({ id: "effect-1", type: "run", payload: { mode: "effect" } });
+		process.dispatch({ id: "effect-2", type: "run", payload: { mode: "effect" } });
+		expect(process.errors.cache).toMatchObject({
+			code: "malformed-effect",
+			message: "processBundle: duplicate effect 'same-effect'",
+			commandId: "effect-2",
+		});
+		expect(process.state.cache).toEqual({ count: 2 });
+	});
+
+	it("release drops graph-owned retain roots and helper topology without exposing runtime", () => {
+		const g = graph();
+		const process = processBundle(g, {
+			name: "process",
+			initialState: { count: 0 },
+			reduce: (_command, state) => ({ state }),
+		});
+		expect(Object.hasOwn(process, "runtime")).toBe(false);
+
+		process.release();
+		process.release();
+		expect(g.find("process/command")).toBeUndefined();
+		expect(g.find("process/runtime")).toBeUndefined();
+		expect(g.find("process/state")).toBeUndefined();
+		expect(() => process.dispatch({ id: "late", type: "run", payload: {} })).toThrow(/released/);
+	});
+
+	it("keeps ProcessBundle release retryable when external subscribers block topology release", () => {
+		const g = graph();
+		const process = processBundle(g, {
+			name: "process",
+			initialState: { count: 0 },
+			reduce: (_command, state) => ({ state }),
+		});
+		const unsub = process.state.subscribe(() => {});
+
+		expect(() => process.release()).toThrow(/live subscribers/);
+		expect(g.find("process/state")).toBe(process.state);
+
+		unsub();
+		process.release();
+		expect(g.find("process/state")).toBeUndefined();
+	});
+});
+
+describe("ProcessBundle effect runner — visible outcome-command adapter (D156)", () => {
+	it("projects effect outcomes into visible ProcessCommand facts over declared graph deps", () => {
+		type CommandPayload = { orderId: string } | ProcessEffectCommandPayload<{ delivered: boolean }>;
+		const g = graph();
+		const process = processBundle<
+			CommandPayload,
+			{ notified: boolean },
+			{ kind: string },
+			{ url: string }
+		>(g, {
+			name: "order",
+			initialState: { notified: false },
+			reduce(command, state) {
+				if (command.type === "start") {
+					return {
+						state,
+						effects: [
+							{
+								type: "notify",
+								payload: { url: `/orders/${(command.payload as { orderId: string }).orderId}` },
+								processId: command.processId,
+								correlationId: command.correlationId,
+							},
+						],
+					};
+				}
+				if (command.type === "effect.result") {
+					return {
+						state: {
+							notified: (
+								command.payload as ProcessEffectCommandPayload<{ delivered: boolean }> & {
+									kind: "result";
+								}
+							).value.delivered,
+						},
+						events: [{ type: "notified", payload: { kind: "effect-result" } }],
+					};
+				}
+				return { state };
+			},
+		});
+		const outcomes = g.node<ProcessEffectOutcome<{ delivered: boolean }>>([], null, {
+			name: "notify/outcomeFacts",
+			factory: "testEffectOutcomes",
+		});
+		const runner = processEffectRunner(g, process, { name: "notify", outcomes: [outcomes] });
+
+		process.dispatch({
+			id: "cmd-1",
+			type: "start",
+			payload: { orderId: "o-1" },
+			processId: "p-1",
+			correlationId: "corr-1",
+		});
+		expect(runner.requests.cache).toMatchObject({
+			id: "cmd-1:effect:1",
+			type: "notify",
+			processId: "p-1",
+			correlationId: "corr-1",
+		});
+		outcomes.down([
+			[
+				"DATA",
+				{
+					kind: "result",
+					effectId: "cmd-1:effect:1",
+					effectType: "notify",
+					value: { delivered: true },
+					processId: "p-1",
+					correlationId: "corr-1",
+				},
+			],
+		]);
+
+		expect(runner.commands.cache).toEqual({
+			id: "cmd-1:effect:1:effect.result",
+			type: "effect.result",
+			payload: {
+				kind: "result",
+				effectId: "cmd-1:effect:1",
+				effectType: "notify",
+				value: { delivered: true },
+				processId: "p-1",
+				correlationId: "corr-1",
+				causationId: undefined,
+				metadata: undefined,
+			},
+			processId: "p-1",
+			correlationId: "corr-1",
+			causationId: undefined,
+			metadata: undefined,
+		});
+		expect(process.state.cache).toEqual({ notified: true });
+		const snap = g.describe();
+		expect(snap.edges).toContainEqual({ from: "order/effectRequests", to: "notify/requests" });
+		expect(snap.edges).toContainEqual({ from: "notify/outcomeFacts", to: "notify/runtime" });
+		expect(snap.edges).toContainEqual({ from: "notify/commands", to: "order/command" });
+	});
+
+	it("retries release without losing the process.command edge when the runner is not quiescent", () => {
+		type CommandPayload = { run: boolean } | ProcessEffectCommandPayload<string>;
+		const g = graph();
+		const process = processBundle<CommandPayload, { done: number }, never, { task: string }>(g, {
+			name: "process",
+			initialState: { done: 0 },
+			reduce(command, state) {
+				if (command.type === "run") {
+					return { state, effects: [{ type: "work", payload: { task: "one" } }] };
+				}
+				if (command.type === "effect.result") return { state: { done: state.done + 1 } };
+				return { state };
+			},
+		});
+		const outcomes = g.node<ProcessEffectOutcome<string>>([], null, { name: "work/outcomeFacts" });
+		const runner = processEffectRunner(g, process, { name: "work", outcomes: [outcomes] });
+		const unsub = runner.status.subscribe(() => {});
+
+		expect(() => runner.release()).toThrow(/live subscribers/);
+		outcomes.down([
+			[
+				"DATA",
+				{
+					kind: "result",
+					effectId: "effect-1",
+					effectType: "work",
+					value: "ok",
+				},
+			],
+		]);
+		expect(process.state.cache).toEqual({ done: 1 });
+
+		unsub();
+		runner.release();
+		runner.release();
+		expect(g.find("work/commands")).toBeUndefined();
+		expect(g.describe().edges).not.toContainEqual({ from: "work/commands", to: "process/command" });
+	});
+});
diff --git a/packages/ts/src/__tests__/patterns-semantic-memory.test.ts b/packages/ts/src/__tests__/patterns-semantic-memory.test.ts
new file mode 100644
index 00000000..2ba6e4c0
--- /dev/null
+++ b/packages/ts/src/__tests__/patterns-semantic-memory.test.ts
@@ -0,0 +1,576 @@
+import { describe, expect, expectTypeOf, it } from "vitest";
+import { graph } from "../graph/graph.js";
+import type {
+	MemoryAnswer,
+	MemoryRetrievalError,
+	MemoryRetrievalStatus,
+} from "../patterns/index.js";
+import {
+	admissionFilter3D,
+	admissionScored,
+	type FactId,
+	filterMemoryFragments,
+	isMemoryFragment,
+	type KnowledgeAssertion,
+	type KnowledgeGraphError,
+	type KnowledgeGraphStatus,
+	knowledgeGraphReducerBundle,
+	type MemoryFragment,
+	type MemoryQuery,
+	memoryFragmentMatchesQuery,
+	memoryFragmentValidAt,
+	memoryRetrievalBundle,
+	shardByTenant,
+	validateMemoryFragment,
+} from "../patterns/index.js";
+import { cosineSimilarity } from "../patterns/semantic-memory.js";
+import type { Message } from "../protocol/messages.js";
+
+const fragment = (patch: Partial<MemoryFragment<string>> = {}): MemoryFragment<string> => ({
+	id: "fact-1",
+	payload: "payload",
+	tNs: 10n,
+	confidence: 0.8,
+	tags: ["project", "policy"],
+	sources: [],
+	...patch,
+});
+
+const data = <T>(messages: Message[]): T[] =>
+	messages.filter((m) => m[0] === "DATA").map((m) => (m as readonly ["DATA", T])[1]);
+
+function collect(node: { subscribe(sink: (messages: Message) => void): () => void }) {
+	const messages: Message[] = [];
+	const unsubscribe = node.subscribe((message) => messages.push(message));
+	return { messages, unsubscribe };
+}
+
+describe("semantic memory passive vocabulary (D158)", () => {
+	it("validates the passive MemoryFragment shape without owning runtime behavior", () => {
+		const ok = fragment({ embedding: [1, 0, 1], parentFragmentId: "parent" });
+		expect(validateMemoryFragment(ok)).toEqual({ ok: true, errors: [] });
+		expect(isMemoryFragment(ok)).toBe(true);
+		expectTypeOf<MemoryFragment<{ note: string }>["id"]>().toEqualTypeOf<FactId>();
+
+		const invalid = validateMemoryFragment({
+			id: "",
+			tNs: 1,
+			confidence: Number.NaN,
+			tags: ["ok", 1],
+			sources: [null],
+		});
+		expect(invalid.ok).toBe(false);
+		expect(invalid.errors).toEqual([
+			"id must be a non-empty string",
+			"payload must be present",
+			"tNs must be a bigint",
+			"confidence must be a finite number in [0, 1]",
+			"tags must be a readonly string array",
+			"sources must be a readonly string array",
+		]);
+
+		expect(
+			validateMemoryFragment({
+				id: "bad-range",
+				payload: undefined,
+				tNs: 1n,
+				confidence: 0.5,
+				tags: [],
+				sources: [],
+				validFrom: 10n,
+				validTo: 5n,
+			}).errors,
+		).toContain("validFrom must be earlier than validTo");
+
+		const sparseTags = ["ok"];
+		delete sparseTags[0];
+		expect(
+			validateMemoryFragment({
+				id: "sparse",
+				payload: "x",
+				tNs: 1n,
+				confidence: 0.5,
+				tags: sparseTags,
+				sources: [],
+			}).errors,
+		).toContain("tags must be a readonly string array");
+	});
+
+	it("filters structured memory queries with bi-temporal validity", () => {
+		const live = fragment({ id: "live", tNs: 20n, confidence: 0.7 });
+		const old = fragment({
+			id: "old",
+			tNs: 30n,
+			confidence: 0.9,
+			validFrom: 1n,
+			validTo: 8n,
+			tags: ["archive"],
+		});
+		const future = fragment({ id: "future", validFrom: 40n });
+		const weak = fragment({ id: "weak", confidence: 0.2, tags: ["project"] });
+
+		expect(memoryFragmentValidAt(live)).toBe(true);
+		expect(memoryFragmentValidAt(old)).toBe(false);
+		expect(memoryFragmentValidAt(future)).toBe(false);
+		expect(memoryFragmentValidAt(future, 41n)).toBe(true);
+		expect(memoryFragmentValidAt(old, 4n)).toBe(true);
+		expect(memoryFragmentMatchesQuery(live, { tags: ["project"], minConfidence: 0.5 })).toBe(true);
+		expect(memoryFragmentMatchesQuery(weak, { minConfidence: 0.5 })).toBe(false);
+
+		const query: MemoryQuery = { asOf: 4n, minConfidence: 0.5, limit: 1 };
+		expect(filterMemoryFragments([live, old, weak], query).map((item) => item.id)).toEqual(["old"]);
+	});
+
+	it("exports deterministic scoring and admission helpers", () => {
+		expect(cosineSimilarity([1, 0], [1, 0])).toBe(1);
+		expect(cosineSimilarity([1, 0], [0, 1])).toBe(0);
+		expect(cosineSimilarity([0, 0], [1, 1])).toBe(0);
+		expect(cosineSimilarity([Number.POSITIVE_INFINITY], [1])).toBe(0);
+
+		const scored = admissionScored({
+			scoreFn: (raw: { relevance?: number }) => ({ relevance: raw.relevance ?? Number.NaN }),
+			thresholds: { relevance: 0.5 },
+		});
+		expect(scored({ relevance: 0.6 })).toBe(true);
+		expect(scored({ relevance: 0.4 })).toBe(false);
+		expect(scored({})).toBe(false);
+
+		const threeD = admissionFilter3D({
+			scoreFn: (raw) => raw as { persistence: number; structure: number; personalValue: number },
+			requireStructured: true,
+		});
+		expect(threeD({ persistence: 0.5, structure: 0.1, personalValue: 0.5 })).toBe(true);
+		expect(threeD({ persistence: 0.5, structure: 0, personalValue: 0.5 })).toBe(false);
+
+		let calls = 0;
+		const singleCall = admissionFilter3D({
+			scoreFn: () => {
+				calls += 1;
+				return { persistence: 0.5, structure: 0.5, personalValue: 0.5 };
+			},
+			requireStructured: true,
+		});
+		expect(singleCall("x")).toBe(true);
+		expect(calls).toBe(1);
+	});
+
+	it("builds passive tenant sharding configs", () => {
+		const strict = shardByTenant((f: MemoryFragment<{ tenant: string }>) => f.payload.tenant, {
+			tenants: ["acme", "globex", "acme"],
+		});
+		expect(strict.shardCount).toBe(3);
+		expect(strict.shardBy(fragment({ payload: { tenant: "acme" } }))).toBe(0);
+		expect(strict.shardBy(fragment({ payload: { tenant: "other" } }))).toBe(2);
+
+		const soft = shardByTenant((f: MemoryFragment<{ tenant: string }>) => f.payload.tenant, {
+			shardCount: 0,
+		});
+		expect(soft.shardCount).toBe(1);
+		expect(soft.shardBy(fragment({ payload: { tenant: "acme" } }))).toBe("acme");
+
+		const invalidShardCount = shardByTenant(
+			(f: MemoryFragment<{ tenant: string }>) => f.payload.tenant,
+			{ shardCount: Number.NaN },
+		);
+		expect(invalidShardCount.shardCount).toBe(4);
+	});
+});
+
+describe("memoryRetrievalBundle graph pattern (D158)", () => {
+	it("exposes declared fragment/query deps and graph-visible retrieval facts", () => {
+		const g = graph();
+		const fragments = g.state<readonly unknown[]>([], { name: "fragments" });
+		const query = g.state({ tags: ["policy"] }, { name: "query" });
+		const bundle = memoryRetrievalBundle<string>(g, { name: "memory", fragments, query });
+
+		expect(g.describe().edges).toEqual(
+			expect.arrayContaining([
+				{ from: "fragments", to: "memory/snapshot" },
+				{ from: "query", to: "memory/snapshot" },
+				{ from: "memory/snapshot", to: "memory/fragments" },
+				{ from: "memory/snapshot", to: "memory/indexed" },
+				{ from: "memory/snapshot", to: "memory/ranked" },
+				{ from: "memory/snapshot", to: "memory/status" },
+				{ from: "memory/snapshot", to: "memory/errors" },
+				{ from: "memory/snapshot", to: "memory/cursor" },
+			]),
+		);
+		expect(g.describe().nodes.find((node) => node.id === "memory/snapshot")?.factory).toBe(
+			"memoryRetrievalSnapshot",
+		);
+		expect(bundle.input.fragments).toBe(fragments);
+		expect(bundle.input.query).toBe(query);
+	});
+
+	it("recomputes ranked answers when the query changes", () => {
+		const g = graph();
+		const fragments = g.state<readonly unknown[]>(
+			[
+				fragment({ id: "near", confidence: 0.6, embedding: [1, 0], tags: ["policy"] }),
+				fragment({ id: "far", confidence: 0.95, embedding: [0, 1], tags: ["policy"] }),
+				fragment({ id: "other", confidence: 1, embedding: [1, 0], tags: ["other"] }),
+			],
+			{ name: "fragments" },
+		);
+		const query = g.state({ tags: ["policy"], vector: [1, 0], limit: 2 }, { name: "query" });
+		const bundle = memoryRetrievalBundle<string>(g, { name: "memory", fragments, query });
+		const ranked = collect(bundle.ranked);
+		const status = collect(bundle.status);
+		const cursor = collect(bundle.cursor);
+		ranked.messages.length = 0;
+		status.messages.length = 0;
+		cursor.messages.length = 0;
+
+		query.set({ tags: ["policy"], vector: [1, 0], limit: 2 });
+		expect(
+			data<MemoryAnswer<string>>(ranked.messages)
+				.at(-1)
+				?.results.map((item) => item.id),
+		).toEqual(["near", "far"]);
+		expect(data<MemoryRetrievalStatus>(status.messages).at(-1)?.state).toBe("ready");
+		expect(data(cursor.messages).at(-1)).toMatchObject({ resultCount: 2, validFragments: 3 });
+
+		query.set({ tags: ["other"], vector: [1, 0] });
+		expect(
+			data<MemoryAnswer<string>>(ranked.messages)
+				.at(-1)
+				?.results.map((item) => item.id),
+		).toEqual(["other"]);
+	});
+
+	it("serves cached retrieval facts to projections that subscribe after runtime activation", () => {
+		const g = graph();
+		const fragments = g.state<readonly unknown[]>([fragment({ id: "cached" })], {
+			name: "fragments",
+		});
+		const query = g.state({}, { name: "query" });
+		const bundle = memoryRetrievalBundle<string>(g, { name: "memory", fragments, query });
+
+		const ranked = collect(bundle.ranked);
+		expect(
+			data<MemoryAnswer<string>>(ranked.messages)
+				.at(-1)
+				?.results.map((item) => item.id),
+		).toEqual(["cached"]);
+
+		const status = collect(bundle.status);
+		const errors = collect(bundle.errors);
+		expect(data<MemoryRetrievalStatus>(status.messages).at(-1)).toMatchObject({
+			state: "ready",
+			cursor: { resultCount: 1, validFragments: 1 },
+		});
+		const latestStatus = data<MemoryRetrievalStatus>(status.messages).at(-1);
+		expect(Object.isFrozen(latestStatus?.cursor)).toBe(true);
+		expect(() => {
+			(latestStatus?.cursor as { resultCount: number }).resultCount = 99;
+		}).toThrow(TypeError);
+		expect(bundle.status.cache?.cursor.resultCount).toBe(1);
+		expect(data<readonly MemoryRetrievalError[]>(errors.messages).at(-1)).toEqual([]);
+	});
+
+	it("emits invalid fragments as DATA error/status facts instead of hidden state or protocol ERROR", () => {
+		const g = graph();
+		const fragments = g.state<readonly unknown[]>([], { name: "fragments" });
+		const query = g.state({}, { name: "query" });
+		const bundle = memoryRetrievalBundle<string>(g, { name: "memory", fragments, query });
+		const errors = collect(bundle.errors);
+		const status = collect(bundle.status);
+		const ranked = collect(bundle.ranked);
+		errors.messages.length = 0;
+		status.messages.length = 0;
+		ranked.messages.length = 0;
+
+		fragments.set([fragment({ id: "ok" }), { id: "", tNs: 1, confidence: Number.NaN }]);
+
+		expect(errors.messages.map((message) => message[0])).toEqual(["DIRTY", "DATA"]);
+		const latestErrors = data<readonly MemoryRetrievalError[]>(errors.messages).at(-1);
+		expect(latestErrors?.[0]).toMatchObject({
+			code: "invalid-fragment",
+			index: 1,
+			validationErrors: expect.arrayContaining([
+				"id must be a non-empty string",
+				"payload must be present",
+				"tNs must be a bigint",
+				"confidence must be a finite number in [0, 1]",
+				"tags must be a readonly string array",
+				"sources must be a readonly string array",
+			]),
+		});
+		expect(Object.isFrozen(latestErrors?.[0]?.validationErrors)).toBe(true);
+		expect(status.messages.some((message) => message[0] === "ERROR")).toBe(false);
+		expect(data<MemoryRetrievalStatus>(status.messages).at(-1)).toMatchObject({
+			state: "partial",
+			cursor: { validFragments: 1, invalidFragments: 1, resultCount: 1 },
+		});
+		expect(
+			data<MemoryAnswer<string>>(ranked.messages)
+				.at(-1)
+				?.results.map((item) => item.id),
+		).toEqual(["ok"]);
+	});
+
+	it("emits malformed queries as graph-visible DATA errors without ranking", () => {
+		const g = graph();
+		const fragments = g.state<readonly unknown[]>([fragment({ id: "ok", embedding: [1, 0] })], {
+			name: "fragments",
+		});
+		const query = g.state({ vector: [1, 0] }, { name: "query" });
+		const bundle = memoryRetrievalBundle<string>(g, { name: "memory", fragments, query });
+		const errors = collect(bundle.errors);
+		const status = collect(bundle.status);
+		const ranked = collect(bundle.ranked);
+		errors.messages.length = 0;
+		status.messages.length = 0;
+		ranked.messages.length = 0;
+
+		query.set({ tags: "policy", vector: {} } as never);
+
+		expect(errors.messages.map((message) => message[0])).toEqual(["DIRTY", "DATA"]);
+		expect(
+			data<readonly MemoryRetrievalError[]>(errors.messages)
+				.at(-1)
+				?.map((error) => error.code),
+		).toEqual(["invalid-query", "invalid-query-vector"]);
+		expect(data<MemoryRetrievalStatus>(status.messages).at(-1)).toMatchObject({
+			state: "error",
+			cursor: { validFragments: 1, invalidFragments: 0, resultCount: 0 },
+		});
+		expect(data<MemoryAnswer<string>>(ranked.messages).at(-1)?.results).toEqual([]);
+		expect(status.messages.some((message) => message[0] === "ERROR")).toBe(false);
+	});
+
+	it("turns throwing query and fragment access into graph-visible DATA errors", () => {
+		const g = graph();
+		const badFragment = {
+			get id() {
+				throw new Error("id exploded");
+			},
+		};
+		const badQuery = {
+			get tags() {
+				throw new Error("tags exploded");
+			},
+		};
+		const fragments = g.state<readonly unknown[]>([badFragment], { name: "fragments" });
+		const query = g.state(badQuery as never, { name: "query" });
+		const bundle = memoryRetrievalBundle<string>(g, { name: "memory", fragments, query });
+		const errors = collect(bundle.errors);
+		const status = collect(bundle.status);
+		const ranked = collect(bundle.ranked);
+
+		expect(data<readonly MemoryRetrievalError[]>(errors.messages).at(-1)).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({ code: "invalid-query" }),
+				expect.objectContaining({ code: "invalid-fragment", index: 0 }),
+			]),
+		);
+		expect(data<MemoryRetrievalStatus>(status.messages).at(-1)?.state).toBe("error");
+		expect(data<MemoryAnswer<string>>(ranked.messages).at(-1)?.results).toEqual([]);
+		expect(status.messages.some((message) => message[0] === "ERROR")).toBe(false);
+	});
+
+	it("snapshots query and fragment metadata so later caller mutation is invisible", () => {
+		const g = graph();
+		const mutableFragment = fragment({
+			id: "stable",
+			tags: ["policy"],
+			sources: ["source"],
+			embedding: [1, 0],
+		}) as MemoryFragment<string> & {
+			id: string;
+			tags: string[];
+			sources: string[];
+			embedding: number[];
+		};
+		const mutableQuery = { tags: ["policy"], vector: [1, 0] };
+		const fragments = g.state<readonly unknown[]>([mutableFragment], { name: "fragments" });
+		const query = g.state(mutableQuery, { name: "query" });
+		const bundle = memoryRetrievalBundle<string>(g, { name: "memory", fragments, query });
+		const ranked = collect(bundle.ranked);
+		const indexed = collect(bundle.indexed);
+		const status = collect(bundle.status);
+
+		mutableFragment.id = "mutated";
+		mutableFragment.tags.push("mutated");
+		mutableFragment.sources.push("mutated-source");
+		mutableFragment.embedding[0] = 0;
+		mutableQuery.tags.push("mutated-query");
+		mutableQuery.vector[0] = 0;
+
+		const answer = data<MemoryAnswer<string>>(ranked.messages).at(-1);
+		const index = data(indexed.messages).at(-1) as {
+			ids: readonly string[];
+			byId: Record<string, MemoryFragment<string>>;
+		};
+		const latestStatus = data<MemoryRetrievalStatus>(status.messages).at(-1);
+		expect(answer?.query).toMatchObject({ tags: ["policy"], vector: [1, 0] });
+		expect(answer?.results[0]).toMatchObject({
+			id: "stable",
+			tags: ["policy"],
+			sources: ["source"],
+			embedding: [1, 0],
+		});
+		expect(index.ids).toEqual(["stable"]);
+		expect(index.byId.stable.id).toBe("stable");
+		expect(latestStatus?.query).toMatchObject({ tags: ["policy"], vector: [1, 0] });
+	});
+
+	it("clears errors on clean reruns and rejects duplicate fragment ids", () => {
+		const g = graph();
+		const fragments = g.state<readonly unknown[]>([], { name: "fragments" });
+		const query = g.state({}, { name: "query" });
+		const bundle = memoryRetrievalBundle<string>(g, { name: "memory", fragments, query });
+		const errors = collect(bundle.errors);
+		const indexed = collect(bundle.indexed);
+		const ranked = collect(bundle.ranked);
+		const status = collect(bundle.status);
+		errors.messages.length = 0;
+		indexed.messages.length = 0;
+		ranked.messages.length = 0;
+		status.messages.length = 0;
+
+		fragments.set([fragment({ id: "dup", payload: "a" }), fragment({ id: "dup", payload: "b" })]);
+		expect(data<readonly MemoryRetrievalError[]>(errors.messages).at(-1)?.[0]).toMatchObject({
+			code: "duplicate-fragment-id",
+			index: 1,
+		});
+		expect(data(indexed.messages).at(-1)).toMatchObject({
+			ids: ["dup"],
+		});
+		expect(
+			data<MemoryAnswer<string>>(ranked.messages)
+				.at(-1)
+				?.results.map((item) => item.id),
+		).toEqual(["dup"]);
+		expect(data<MemoryRetrievalStatus>(status.messages).at(-1)?.state).toBe("partial");
+
+		fragments.set([fragment({ id: "clean" })]);
+		expect(data<readonly MemoryRetrievalError[]>(errors.messages).at(-1)).toEqual([]);
+		expect(data(indexed.messages).at(-1)).toMatchObject({
+			ids: ["clean"],
+		});
+	});
+
+	it("keeps storage/restore outside the retrieval bundle surface", () => {
+		const g = graph();
+		const fragments = g.state<readonly unknown[]>([], { name: "fragments" });
+		const query = g.state({}, { name: "query" });
+		const bundle = memoryRetrievalBundle(g, { fragments, query });
+
+		expect(Object.hasOwn(bundle, "flush")).toBe(false);
+		expect(Object.hasOwn(bundle, "dispose")).toBe(false);
+		expect(Object.hasOwn(bundle, "restore")).toBe(false);
+	});
+});
+
+describe("knowledgeGraphReducerBundle graph pattern (D170)", () => {
+	const assertion = (patch: Partial<KnowledgeAssertion> = {}): KnowledgeAssertion => ({
+		id: "a1",
+		subject: { id: "person:ada", type: "person" },
+		predicate: "works_on",
+		object: { kind: "entity", id: "project:graphrefly", type: "project" },
+		confidence: 0.9,
+		sources: ["f1"],
+		...patch,
+	});
+
+	it("materializes assertions into deterministic entity/relation/topic facts with visible topology", () => {
+		const g = graph();
+		const assertions = g.state<readonly unknown[]>(
+			[
+				assertion(),
+				assertion({
+					id: "a2",
+					subject: { id: "person:ada", type: "person" },
+					predicate: "prefers",
+					object: { kind: "value", value: "quiet tools" },
+				}),
+			],
+			{ name: "assertions" },
+		);
+		const policy = g.state({ allowedPredicates: ["prefers", "works_on"] }, { name: "policy" });
+		const bundle = knowledgeGraphReducerBundle(g, { name: "kg", assertions, policy });
+		const entities = collect(bundle.entities);
+		const relations = collect(bundle.relations);
+		const topics = collect(bundle.topics);
+		const status = collect(bundle.status);
+
+		expect(g.describe().edges).toEqual(
+			expect.arrayContaining([
+				{ from: "assertions", to: "kg/snapshot" },
+				{ from: "policy", to: "kg/snapshot" },
+				{ from: "kg/snapshot", to: "kg/entities" },
+				{ from: "kg/snapshot", to: "kg/relations" },
+				{ from: "kg/snapshot", to: "kg/topics" },
+				{ from: "kg/snapshot", to: "kg/index" },
+				{ from: "kg/snapshot", to: "kg/status" },
+				{ from: "kg/snapshot", to: "kg/errors" },
+				{ from: "kg/snapshot", to: "kg/cursor" },
+			]),
+		);
+		expect(g.describe().nodes.find((node) => node.id === "kg/snapshot")?.factory).toBe(
+			"knowledgeGraphReducerSnapshot",
+		);
+		expect(
+			data(entities.messages)
+				.at(-1)
+				?.map((entity) => entity.id),
+		).toEqual(["person:ada", "project:graphrefly"]);
+		expect(
+			data(relations.messages)
+				.at(-1)
+				?.map((relation) => relation.assertionId),
+		).toEqual(["a1", "a2"]);
+		expect(
+			data(topics.messages)
+				.at(-1)
+				?.map((topic) => topic.predicate),
+		).toEqual(["prefers", "works_on"]);
+		expect(data<KnowledgeGraphStatus>(status.messages).at(-1)).toMatchObject({
+			state: "ready",
+			cursor: { validAssertions: 2, entityCount: 2, relationCount: 2, predicateCount: 2 },
+		});
+	});
+
+	it("emits duplicate, malformed, and policy conflicts as DATA errors", () => {
+		const g = graph();
+		const assertions = g.state<readonly unknown[]>(
+			[
+				assertion(),
+				assertion({ id: "a1", predicate: "works_on" }),
+				assertion({
+					id: "bad",
+					subject: { id: "" },
+					object: { kind: "value", value: 1n } as never,
+				}),
+				assertion({ id: "blocked", predicate: "secret" }),
+				assertion({
+					id: "bad-type",
+					subject: { id: "person:ada", type: "" },
+					object: { kind: "entity", id: "project:graphrefly", type: 7 } as never,
+				}),
+			],
+			{ name: "assertions" },
+		);
+		const policy = g.state({ allowedPredicates: ["works_on"] }, { name: "policy" });
+		const bundle = knowledgeGraphReducerBundle(g, { name: "kg", assertions, policy });
+		const errors = collect(bundle.errors);
+		const status = collect(bundle.status);
+
+		expect(
+			data<readonly KnowledgeGraphError[]>(errors.messages)
+				.at(-1)
+				?.map((error) => error.code),
+		).toEqual([
+			"duplicate-assertion-id",
+			"invalid-assertion",
+			"invalid-assertion",
+			"invalid-assertion",
+		]);
+		expect(data<KnowledgeGraphStatus>(status.messages).at(-1)).toMatchObject({
+			state: "partial",
+			cursor: { validAssertions: 1, invalidAssertions: 4 },
+		});
+		expect(errors.messages.some((message) => message[0] === "ERROR")).toBe(false);
+	});
+});
diff --git a/packages/ts/src/__tests__/patterns.test.ts b/packages/ts/src/__tests__/patterns.test.ts
new file mode 100644
index 00000000..1a7b3c33
--- /dev/null
+++ b/packages/ts/src/__tests__/patterns.test.ts
@@ -0,0 +1,23 @@
+import { describe, expect, it } from "vitest";
+import { Dispatcher, graph } from "../index.js";
+import { profileSummary } from "../patterns/index.js";
+
+describe("patterns inspection helpers (B62 / D125)", () => {
+	it("profileSummary rolls up graph-local profile counters", () => {
+		const g = graph({ dispatcher: new Dispatcher(), profile: true });
+		const count = g.state(0, { name: "count" });
+		const doubled = g.derived([count], (n) => n * 2, { name: "doubled" });
+		doubled.subscribe(() => {});
+		count.set(1);
+		count.set(2);
+
+		const summary = profileSummary(g, { limit: 1 });
+
+		expect(summary.nodeCount).toBe(2);
+		expect(summary.totalInvokes).toBeGreaterThanOrEqual(3);
+		expect(summary.byStatus.settled).toBe(2);
+		expect(summary.hotNodes).toEqual([
+			expect.objectContaining({ path: "doubled", invokes: 3, status: "settled" }),
+		]);
+	});
+});
diff --git a/packages/ts/src/__tests__/pull.test.ts b/packages/ts/src/__tests__/pull.test.ts
new file mode 100644
index 00000000..6a268dc5
--- /dev/null
+++ b/packages/ts/src/__tests__/pull.test.ts
@@ -0,0 +1,210 @@
+/**
+ * R-pull (D269) + R-up-routing — pull-mode node (NodeOptions.pullId:<Symbol>) unit edges beyond
+ * the C-16 conformance scenario: the owed-demand machinery (a demand that can't fire immediately is
+ * deferred and fired when able) across its three triggers — pin-5 (a dep DIRTY in flight), F4/F5 (an
+ * external PAUSE lock co-holds the node), B1/F6 (an in-flight dep settles via INVALIDATE/terminal) —
+ * plus reactivation-restores-quiet, an unknown-pullId demand is a silent no-op, the multi-dep
+ * first-run-gate guard (QA-B2), and a pull node never push-on-subscribes (QA-B4).
+ *
+ * Authority: ~/src/graphrefly/spec/rules.jsonl R-pull / R-up-routing / R-pause-modes / R-rewire-deferred
+ * (D269/D272). The end-to-end quiet/absorb + cone-routing + reject/defer/immediate matrix is C-16.
+ */
+
+import { describe, expect, it } from "vitest";
+import type { Ctx, Message } from "../index.js";
+import { depLatest, node } from "../index.js";
+
+const types = (m: Message[]) => m.map((x) => x[0]);
+const data = (m: Message[]) =>
+	m.filter((x) => x[0] === "DATA").map((x) => (x as ["DATA", unknown])[1]);
+function collect(n: { subscribe(s: (m: Message) => void): () => void }) {
+	const msgs: Message[] = [];
+	const unsub = n.subscribe((m) => msgs.push(m));
+	return { msgs, unsub };
+}
+const snapFn = (ctx: Ctx) => ctx.down([["DATA", depLatest(ctx, 0) as number]]);
+const PID = Symbol("pullId"); // an author-supplied pullId, shared by the node + the demander
+
+describe("R-pull / R-up-routing (D269/D272) — pull-mode node finer edges", () => {
+	it("pin 5: a demand arriving while a dep DIRTY is in flight is OWED, fires once settle-ready (1:1)", () => {
+		const acc = node<number>([], null, { initial: 0 });
+		const snap = node<number>([acc], snapFn, { pullId: PID });
+		const { msgs } = collect(snap);
+		msgs.length = 0;
+
+		acc.down([["DIRTY"]]); // phase 1 only — an ACC change in flight, no settle yet (pending>0)
+		expect(msgs).toEqual([]); // absorbed while quiet
+		snap.up([["PULL", { pullId: PID }]]); // DEMAND while NOT settle-ready → OWED
+		expect(msgs).toEqual([]); // deferred — nothing delivered yet
+
+		acc.down([["DATA", 5]]); // ACC settles → settle-ready → the owed demand fires
+		expect(types(msgs)).toEqual(["DIRTY", "DATA"]); // one delivery, DIRTY-before-DATA
+		expect(data(msgs)).toEqual([5]);
+		msgs.length = 0;
+
+		snap.up([["PULL", { pullId: PID }]]); // D278: raw holder still invokes on no-change
+		expect(types(msgs)).toEqual(["DIRTY", "DATA"]);
+		expect(data(msgs)).toEqual([5]);
+	});
+
+	it("F4/F5: a demand arriving while the node is EXTERNALLY paused is OWED, fires on external resume", () => {
+		const acc = node<number>([], null, { initial: 0 });
+		const snap = node<number>([acc], snapFn, { pullId: PID });
+		const ext = Symbol("external-pause");
+		const { msgs } = collect(snap);
+		msgs.length = 0;
+		acc.down([["DATA", 9]]); // a change coalesced while quiet
+
+		snap.up([["PAUSE", ext]]); // an EXTERNAL party also pauses SNAP (lockset = {pullId, ext})
+		snap.up([["PULL", { pullId: PID }]]); // DEMAND while externally paused → cannot fire now → OWED
+		expect(msgs).toEqual([]); // not lost, not fired yet
+
+		snap.up([["RESUME", ext]]); // external resume → the owed demand fires (pull/pause orthogonal)
+		expect(types(msgs)).toEqual(["DIRTY", "DATA"]);
+		expect(data(msgs)).toEqual([9]);
+	});
+
+	it("D272: an external PAUSE may use the pullId token without colliding with pull quiet", () => {
+		const acc = node<number>([], null, { initial: 0 });
+		const snap = node<number>([acc], snapFn, { pullId: PID });
+		const { msgs } = collect(snap);
+		msgs.length = 0;
+		acc.down([["DATA", 11]]);
+
+		snap.up([["PAUSE", PID]]);
+		snap.up([["PULL", { pullId: PID }]]);
+		expect(msgs).toEqual([]);
+
+		snap.up([["RESUME", PID]]);
+		expect(types(msgs)).toEqual(["DIRTY", "DATA"]);
+		expect(data(msgs)).toEqual([11]);
+	});
+
+	it("B1/F6: an owed demand is serviced (not stranded) when the in-flight dep settles via INVALIDATE", () => {
+		const acc = node<number>([], null, { initial: 1 });
+		const snap = node<number>([acc], snapFn, { pullId: PID });
+		const { msgs } = collect(snap);
+		msgs.length = 0;
+
+		acc.down([["DIRTY"]]); // ACC change in flight (pending>0)
+		snap.up([["PULL", { pullId: PID }]]); // DEMAND → OWED
+		acc.down([["INVALIDATE"]]); // ACC's value is GONE — settles pending with NO new value
+		// the owed demand is serviced (silent — no coalesced value) and CLEARED, not stranded:
+		acc.down([["DATA", 8]]); // a fresh ACC value coalesces
+		snap.up([["PULL", { pullId: PID }]]); // a fresh demand → delivers the new value (node not stuck)
+		expect(data(msgs)).toEqual([8]); // exactly one delivery for the fresh demand (owed one didn't double-fire)
+	});
+
+	it("QA: a throwing pull fn does NOT leave the node permanently non-quiet (pullId re-held in finally)", () => {
+		const acc = node<number>([], null, { initial: 0 });
+		let boom = false;
+		const snap = node<number>(
+			[acc],
+			(ctx: Ctx) => {
+				if (boom) throw new Error("boom");
+				ctx.down([["DATA", depLatest(ctx, 0) as number]]);
+			},
+			{ pullId: PID },
+		);
+		collect(snap);
+		acc.down([["DATA", 1]]); // coalesced while quiet
+		boom = true;
+		expect(() => snap.up([["PULL", { pullId: PID }]])).toThrow(/boom/); // demand fires the fn → throws
+
+		// the finally re-held the pullId → the node is STILL quiet: a further ACC change is ABSORBED
+		// (the fn does NOT run, so no re-throw). With the bug (pullId left deleted) the node would be
+		// non-quiet → the change drives the fn → throws again.
+		expect(() => acc.down([["DATA", 2]])).not.toThrow();
+	});
+
+	it("reactivation restores QUIET (deactivate → re-subscribe = START only, demand still works)", () => {
+		const acc = node<number>([], null, { initial: 0 });
+		const snap = node<number>([acc], snapFn, { pullId: PID });
+		const first = collect(snap);
+		first.unsub(); // last subscriber gone → snap deactivates (lockset cleared, RAM cache dropped)
+
+		const { msgs } = collect(snap); // re-subscribe
+		expect(types(msgs)).toEqual(["START"]); // quiet restored — no cached push on re-subscribe
+		msgs.length = 0;
+
+		acc.down([["DATA", 9]]); // absorbed (quiet again, the wedge fix survives reactivation)
+		expect(msgs).toEqual([]);
+		snap.up([["PULL", { pullId: PID }]]); // demand still works after reactivation
+		expect(data(msgs)).toEqual([9]);
+	});
+
+	it("a cone-routed PULL whose pullId no node holds is a silent no-op (drops at the source terminus)", () => {
+		const src = node<number>([], null, { initial: 1 });
+		const mid = node<number>([src], (ctx: Ctx) => ctx.down([["DATA", depLatest(ctx, 0)]]));
+		const { msgs } = collect(mid);
+		msgs.length = 0;
+		// demand a pullId NO node up the cone holds → forwards up → drops at the depless source. No throw, no emit.
+		expect(() => mid.up([["PULL", { pullId: Symbol("nobody") }]])).not.toThrow();
+		expect(msgs).toEqual([]);
+	});
+
+	it("RESUME(pullId) releases only pause locks and does not demand pull delivery", () => {
+		const acc = node<number>([], null, { initial: 0 });
+		const snap = node<number>([acc], snapFn, { pullId: PID });
+		const { msgs } = collect(snap);
+		msgs.length = 0;
+		acc.down([["DATA", 3]]);
+
+		snap.up([["RESUME", PID]]);
+		expect(msgs).toEqual([]);
+
+		snap.up([["PULL", { pullId: PID }]]);
+		expect(types(msgs)).toEqual(["DIRTY", "DATA"]);
+		expect(data(msgs)).toEqual([3]);
+	});
+
+	it("ctx.pull carries the latest PULL params to the holder", () => {
+		const acc = node<number>([], null, { initial: 0 });
+		const seen: unknown[] = [];
+		const snap = node<number>(
+			[acc],
+			(ctx: Ctx) => {
+				seen.push(ctx.pull?.params);
+				ctx.down([["DATA", depLatest(ctx, 0) as number]]);
+			},
+			{ pullId: PID },
+		);
+		collect(snap);
+		acc.down([["DATA", 4]]);
+
+		snap.up([["PULL", { pullId: PID, params: { limit: 1 } }]]);
+		expect(seen).toEqual([{ limit: 1 }]);
+	});
+
+	it("QA-B2: a demand before a MULTI-dep pull node's first-run gate opens stays SILENT (no dangling DIRTY)", () => {
+		const a = node<number>([], null); // no initial — delivers only when driven
+		const b = node<number>([], null);
+		const sum = (ctx: Ctx) =>
+			ctx.down([
+				["DATA", ((depLatest(ctx, 0) as number) ?? 0) + ((depLatest(ctx, 1) as number) ?? 0)],
+			]);
+		const snap = node<number>([a, b], sum, { pullId: PID }); // non-partial → gate needs BOTH deps
+		const { msgs } = collect(snap);
+		msgs.length = 0;
+
+		a.down([["DATA", 10]]); // only A delivers while quiet → coalesced, but the gate still needs B
+		snap.up([["PULL", { pullId: PID }]]); // DEMAND before the gate opens
+		expect(msgs).toEqual([]); // SILENT — no value to deliver, and crucially NO dangling DIRTY (no wedge)
+
+		b.down([["DATA", 5]]); // B delivers → the gate is now open (snap still quiet, coalesces)
+		snap.up([["PULL", { pullId: PID }]]); // DEMAND now deliverable
+		expect(types(msgs)).toEqual(["DIRTY", "DATA"]);
+		expect(data(msgs)).toEqual([15]);
+	});
+
+	it("QA-B4: a pull node never push-on-subscribes its cache, incl. across reactivation (START only)", () => {
+		const src = node<number>([], null, { pullId: PID, initial: 42 }); // depless pull state node (has a cache)
+		const first = collect(src);
+		expect(types(first.msgs)).toEqual(["START"]); // quiet from birth — initial NOT pushed on subscribe
+		first.unsub(); // deactivate — a depless non-compute node PRESERVES its cache
+		expect(src.cache).toBe(42);
+
+		const { msgs } = collect(src); // re-subscribe
+		expect(types(msgs)).toEqual(["START"]); // STILL quiet — cache NOT leaked on reactivation (the B4 fix)
+	});
+});
diff --git a/packages/ts/src/__tests__/qa-fixes.test.ts b/packages/ts/src/__tests__/qa-fixes.test.ts
new file mode 100644
index 00000000..0a106c78
--- /dev/null
+++ b/packages/ts/src/__tests__/qa-fixes.test.ts
@@ -0,0 +1,77 @@
+import { describe, expect, it } from "vitest";
+import type { Ctx, Message } from "../index.js";
+import { node } from "../index.js";
+
+function collect(n: { subscribe(s: (m: Message) => void): () => void }) {
+	const msgs: Message[] = [];
+	const unsub = n.subscribe((m) => msgs.push(m));
+	return { msgs, unsub };
+}
+const types = (msgs: Message[]) => msgs.map((m) => m[0]);
+
+describe("QA fixes", () => {
+	it("EC1: rejects bare/undefined DATA payload (R-data-payload)", () => {
+		const s = node<number>([], null, { initial: 1 });
+		collect(s);
+		expect(() => s.down([["DATA", undefined as unknown as number]])).toThrow(/non-SENTINEL/);
+	});
+
+	it("EC2: rejects DATA + RESOLVED in one wave (R-resolved-undirty tier-3 exclusivity)", () => {
+		const s = node<number>([], null, { initial: 1 });
+		collect(s);
+		expect(() => s.down([["DATA", 2], ["RESOLVED"]])).toThrow(/tier-3 exclusivity/);
+	});
+
+	it("EC3: dep INVALIDATE after DIRTY (before any DATA) un-wedges downstream", () => {
+		const a = node<number>([], null, { initial: 1 });
+		const b = node<number>([], null); // uncached -> first-run gate holds d forever
+		const d = node<number>([a, b], (ctx: Ctx) => ctx.down([["DATA", 1]]));
+		const { msgs } = collect(d);
+		expect(d.cache).toBeUndefined(); // gate held (b never settled)
+		msgs.length = 0;
+
+		a.down([["DIRTY"]]); // d goes dirty, broadcasts DIRTY (pending=1)
+		expect(types(msgs)).toEqual(["DIRTY"]);
+
+		a.down([["INVALIDATE"]]); // a had data -> emits INVALIDATE to d -> d un-wedges
+		expect(types(msgs)).toEqual(["DIRTY", "RESOLVED"]); // downstream un-dirtied, not stuck
+		expect(d.status).toBe("sentinel");
+	});
+
+	it("BH3: terminal while paused discards the buffer (no post-terminal DATA on resume)", () => {
+		const s = node<number>([], null, { initial: 0, pausable: "resumeAll" });
+		const { msgs } = collect(s);
+		msgs.length = 0;
+		const L = Symbol("L");
+		s.up([["PAUSE", L]]);
+		s.down([["DATA", 1]]); // buffered (resumeAll)
+		s.down([["COMPLETE"]]); // terminal bypasses buffer + discards it
+		expect(types(msgs)).toContain("COMPLETE");
+		s.up([["RESUME", L]]); // resume -> terminal guard -> no drain
+		expect(types(msgs)).not.toContain("DATA"); // buffered DATA never delivered post-terminal
+	});
+
+	it("BH6: INVALIDATE clears the replay buffer (no stale replay)", () => {
+		const s = node<number>([], null, { replayBuffer: 3 });
+		collect(s);
+		s.down([["DATA", 1]]);
+		s.down([["DATA", 2]]);
+		s.down([["INVALIDATE"]]);
+		const { msgs } = collect(s); // late subscriber
+		expect(types(msgs)).toEqual(["START"]); // no stale DATA replayed
+	});
+
+	it("WEDGE: a passthrough over a RESOLVED-only dep balances its DIRTY (R-resolved-undirty / D49)", () => {
+		// Regression for the D49-widened wedge: a passthrough wire (deps, no fn) that broadcast
+		// DIRTY then receives an undirty RESOLVED from its dep (no DATA in the batch) must emit a
+		// balancing RESOLVED, not leave a dangling DIRTY. Under D49 a dep emits a bare RESOLVED on
+		// every filter-reject / distinctUntilChanged-dup / no-emit fn, so this fires constantly.
+		const dep = node<number>([], null, { initial: 1 });
+		const pass = node<number>([dep], null); // passthrough wire (_handle === null)
+		const { msgs } = collect(pass);
+		msgs.length = 0;
+		dep.down([["RESOLVED"]]); // dep settles with no value → DIRTY then RESOLVED to the passthrough
+		expect(types(msgs)).toEqual(["DIRTY", "RESOLVED"]); // balanced, not a dangling ["DIRTY"]
+		expect(pass.status).not.toBe("dirty"); // un-wedged
+	});
+});
diff --git a/packages/ts/src/__tests__/reactive-cascading-cache.test.ts b/packages/ts/src/__tests__/reactive-cascading-cache.test.ts
new file mode 100644
index 00000000..c9186fe9
--- /dev/null
+++ b/packages/ts/src/__tests__/reactive-cascading-cache.test.ts
@@ -0,0 +1,341 @@
+import { describe, expect, it } from "vitest";
+import {
+	graph,
+	type KvStorageTier,
+	memoryKv,
+	reactiveCascadingCache,
+	requireKvVersioned,
+} from "../index.js";
+
+const flush = () => new Promise((resolve) => setTimeout(resolve, 0));
+
+function dataOf<T>(node: { subscribe: (sink: (msg: unknown[]) => void) => () => void }): T[] {
+	const out: T[] = [];
+	node.subscribe((msg) => {
+		if (msg[0] === "DATA") out.push(msg[1] as T);
+	});
+	return out;
+}
+
+describe("reactiveCascadingCache (D104/D105/D107)", () => {
+	it("exposes request, event, status, and value nodes in describe", async () => {
+		const g = graph();
+		const request = g.node<string>([], null, { name: "request" });
+		const hot = memoryKv<number>();
+		const cold = memoryKv<number>();
+		await cold.set("user:1", 7);
+
+		const cache = reactiveCascadingCache({
+			graph: g,
+			request,
+			tiers: [hot, cold],
+			tierNames: ["hot", "cold"],
+			name: "cache",
+		});
+
+		dataOf(cache.status);
+		dataOf(cache.value);
+		request.down([["DATA", "user:1"]]);
+		await flush();
+
+		const snap = g.describe();
+		expect(snap.nodes.map((n) => n.id).sort()).toEqual([
+			"cache.events",
+			"cache.status",
+			"cache.value",
+			"request",
+		]);
+		expect(snap.edges).toEqual(
+			expect.arrayContaining([
+				{ from: "request", to: "cache.events" },
+				{ from: "cache.events", to: "cache.status" },
+				{ from: "cache.events", to: "cache.value" },
+			]),
+		);
+	});
+
+	it("looks through tiers without storage promotion by default", async () => {
+		const g = graph();
+		const request = g.node<string>([], null, { name: "request" });
+		const hot = memoryKv<number>();
+		const cold = memoryKv<number>();
+		await cold.set("k", 42);
+		const cache = reactiveCascadingCache({
+			graph: g,
+			request,
+			tiers: [hot, cold],
+			tierNames: ["hot", "cold"],
+			name: "cache",
+		});
+		const statuses = dataOf(cache.status);
+		const values = dataOf(cache.value);
+		const events = dataOf(cache.events);
+
+		request.down([["DATA", "k"]]);
+		await flush();
+
+		expect(values).toEqual([42]);
+		expect(cache.value.cache).toBe(42);
+		expect(await hot.get("k")).toBeUndefined();
+		expect(statuses.at(-1)).toEqual({
+			kind: "hit",
+			key: "k",
+			requestSeq: 1,
+			tier: { index: 1, name: "cold" },
+		});
+		expect(events.map((event) => event.kind)).toEqual(["request", "lookup", "lookup", "fill"]);
+	});
+
+	it("promotes hits only when storage promotion is explicitly enabled", async () => {
+		const g = graph();
+		const request = g.node<string>([], null);
+		const hot = memoryKv<number>();
+		const cold = memoryKv<number>();
+		await cold.set("k", 42);
+		const cache = reactiveCascadingCache({
+			graph: g,
+			request,
+			tiers: [hot, cold],
+			tierNames: ["hot", "cold"],
+			promoteTo: [0],
+			name: "cache",
+		});
+		dataOf(cache.status);
+		dataOf(cache.value);
+		const events = dataOf(cache.events);
+
+		request.down([["DATA", "k"]]);
+		await flush();
+
+		expect(cache.value.cache).toBe(42);
+		expect(await hot.get("k")).toBe(42);
+		expect(events.map((event) => event.kind)).toEqual([
+			"request",
+			"lookup",
+			"lookup",
+			"promotion",
+			"fill",
+		]);
+	});
+
+	it("uses D108 versioned promotion to avoid overwriting newer tier values", async () => {
+		const g = graph();
+		const request = g.node<string>([], null);
+		const hot = memoryKv<number>();
+		const hotVersioned = requireKvVersioned(hot);
+		const hotTier: KvStorageTier<number> = {
+			...hot,
+			async getVersioned(key) {
+				const observed = await hotVersioned.getVersioned(key);
+				await hot.set(key, 1);
+				return observed;
+			},
+			setIfMatch: hotVersioned.setIfMatch.bind(hotVersioned),
+		};
+		const cold = memoryKv<number>();
+		await cold.set("k", 7);
+		const cache = reactiveCascadingCache({
+			graph: g,
+			request,
+			tiers: [hotTier, cold],
+			promoteTo: [0],
+			name: "cache",
+		});
+		dataOf(cache.status);
+		dataOf(cache.value);
+		const events = dataOf(cache.events);
+
+		request.down([["DATA", "k"]]);
+		await flush();
+
+		expect(cache.value.cache).toBe(7);
+		expect(await hot.get("k")).toBe(1);
+		expect(events.map((event) => event.kind)).toEqual([
+			"request",
+			"lookup",
+			"lookup",
+			"promotion",
+			"fill",
+		]);
+		expect(events.find((event) => event.kind === "promotion")).toMatchObject({
+			kind: "promotion",
+			ok: false,
+			tier: { index: 0 },
+		});
+	});
+
+	it("uses loader fills after tier misses", async () => {
+		const g = graph();
+		const request = g.node<string>([], null);
+		const hot = memoryKv<number>();
+		const cache = reactiveCascadingCache({
+			graph: g,
+			request,
+			tiers: [hot],
+			load: (key) => (key === "remote" ? 9 : undefined),
+			name: "cache",
+		});
+		const statuses = dataOf(cache.status);
+		const values = dataOf(cache.value);
+		const events = dataOf(cache.events);
+
+		request.down([["DATA", "remote"]]);
+		await flush();
+
+		expect(values).toEqual([9]);
+		expect(await hot.get("remote")).toBeUndefined();
+		expect(statuses.at(-1)).toEqual({
+			kind: "hit",
+			key: "remote",
+			requestSeq: 1,
+			tier: { index: -1, name: "load" },
+		});
+		expect(events.at(-1)).toMatchObject({ kind: "fill", status: "hit", requestSeq: 1 });
+	});
+
+	it("prevents an older async fill from overwriting a newer request", async () => {
+		const g = graph();
+		const request = g.node<string>([], null);
+		const hot = memoryKv<number>();
+		const resolvers = new Map<string, (value: number | undefined) => void>();
+		const cache = reactiveCascadingCache({
+			graph: g,
+			request,
+			tiers: [hot],
+			load: (key) =>
+				new Promise<number | undefined>((resolve) => {
+					resolvers.set(key, resolve);
+				}),
+			name: "cache",
+		});
+		dataOf(cache.status);
+		const values = dataOf(cache.value);
+		const events = dataOf(cache.events);
+
+		request.down([["DATA", "slow"]]);
+		request.down([["DATA", "fast"]]);
+		await flush();
+		resolvers.get("fast")?.(2);
+		await flush();
+		expect(cache.value.cache).toBe(2);
+
+		resolvers.get("slow")?.(1);
+		await flush();
+		expect(values).toEqual([2]);
+		expect(cache.value.cache).toBe(2);
+		expect(await hot.get("fast")).toBeUndefined();
+		expect(await hot.get("slow")).toBeUndefined();
+		expect(
+			events.filter((event) => event.kind === "fill").map((event) => event.requestSeq),
+		).toEqual([2, 1]);
+	});
+
+	it("invalidates visible value and blocks older fills until the invalidation lookup resolves", async () => {
+		const g = graph();
+		const request = g.node<string>([], null);
+		const invalidate = g.node<string>([], null);
+		const resolvers: Array<(value: number | undefined) => void> = [];
+		const cache = reactiveCascadingCache({
+			graph: g,
+			request,
+			invalidate,
+			tiers: [],
+			load: () =>
+				new Promise<number | undefined>((resolve) => {
+					resolvers.push(resolve);
+				}),
+			name: "cache",
+		});
+		const statuses = dataOf(cache.status);
+		const values = dataOf(cache.value);
+		dataOf(cache.events);
+
+		request.down([["DATA", "k"]]);
+		await flush();
+		resolvers[0]?.(9);
+		await flush();
+		expect(cache.value.cache).toBe(9);
+
+		request.down([["DATA", "k"]]);
+		invalidate.down([["DATA", "k"]]);
+		await flush();
+		await flush();
+		expect(cache.value.cache).toBeUndefined();
+
+		resolvers[1]?.(10);
+		await flush();
+		expect(cache.value.cache).toBeUndefined();
+
+		resolvers[2]?.(11);
+		await flush();
+		expect(values).toEqual([9, 11]);
+		expect(cache.value.cache).toBe(11);
+		expect(statuses.at(-1)).toEqual({
+			kind: "hit",
+			key: "k",
+			requestSeq: 3,
+			tier: { index: -1, name: "load" },
+		});
+	});
+
+	it("applies declared policy changes to the next lookup", async () => {
+		const g = graph();
+		const request = g.node<string>([], null);
+		const policy = g.node<{ promoteTo?: readonly number[] | false }>([], null);
+		const hot = memoryKv<number>();
+		const cold = memoryKv<number>();
+		await cold.set("k", 3);
+		const cache = reactiveCascadingCache({
+			graph: g,
+			request,
+			policy,
+			tiers: [hot, cold],
+			promoteTo: false,
+			name: "cache",
+		});
+		dataOf(cache.status);
+		dataOf(cache.value);
+
+		request.down([["DATA", "k"]]);
+		await flush();
+		expect(await hot.get("k")).toBeUndefined();
+
+		policy.down([["DATA", { promoteTo: [0] }]]);
+		await flush();
+		expect(await hot.get("k")).toBe(3);
+	});
+
+	it("drops in-flight fills after the cache bundle deactivates", async () => {
+		const g = graph();
+		const request = g.node<string>([], null);
+		let resolveLoad: ((value: number | undefined) => void) | undefined;
+		const cache = reactiveCascadingCache({
+			graph: g,
+			request,
+			tiers: [],
+			load: () =>
+				new Promise<number | undefined>((resolve) => {
+					resolveLoad = resolve;
+				}),
+			name: "cache",
+		});
+		const values: number[] = [];
+		const unsubscribe = cache.value.subscribe((msg) => {
+			if (msg[0] === "DATA") values.push(msg[1] as number);
+		});
+
+		request.down([["DATA", "k"]]);
+		await flush();
+		unsubscribe();
+		resolveLoad?.(99);
+		await flush();
+
+		expect(values).toEqual([]);
+		expect(cache.value.cache).toBeUndefined();
+	});
+});
+
+it("exports reactiveCascadingCache from the graph subpath barrel", async () => {
+	const graphLayer = await import("../graph/index.js");
+	expect(typeof graphLayer.reactiveCascadingCache).toBe("function");
+});
diff --git a/packages/ts/src/__tests__/reactive-collection-storage.d161-persistreactivecollection-and-openpersistentreactive.test.ts b/packages/ts/src/__tests__/reactive-collection-storage.d161-persistreactivecollection-and-openpersistentreactive.test.ts
new file mode 100644
index 00000000..572a672f
--- /dev/null
+++ b/packages/ts/src/__tests__/reactive-collection-storage.d161-persistreactivecollection-and-openpersistentreactive.test.ts
@@ -0,0 +1,596 @@
+import { describe, expect, it } from "vitest";
+import type {
+	IndexChange,
+	ListChange,
+	LogChange,
+	MapChange,
+} from "../graph/data-structures/change.js";
+import {
+	type AgenticMemoryRecord,
+	graph,
+	loadReactiveListState,
+	memoryAppendLog,
+	memoryKv,
+	openPersistentReactiveIndex,
+	openPersistentReactiveList,
+	openPersistentReactiveLog,
+	openPersistentReactiveMap,
+	persistReactiveCollection,
+	type ReactiveCollectionChangeFrame,
+	type ReactiveCollectionSnapshotFrame,
+	reactiveCollectionChangeFrame,
+	reactiveList,
+} from "../index.js";
+
+const flushMicrotasks = async (turns = 1) => {
+	for (let i = 0; i < turns; i += 1) await Promise.resolve();
+};
+
+const waitForMicrotaskState = async (predicate: () => boolean, turns = 50): Promise<void> => {
+	for (let i = 0; i < turns; i += 1) {
+		if (predicate()) return;
+		await Promise.resolve();
+	}
+	throw new Error("timed out waiting for microtask state");
+};
+
+const waitControl = (run: (done: () => void) => void): Promise<void> =>
+	new Promise<void>((resolve) => {
+		run(resolve);
+	});
+
+const _memoryRecord = (
+	id: string,
+	payload: string,
+): AgenticMemoryRecord<{ readonly text: string }> => ({
+	id: `record-${id}`,
+	kind: "semantic",
+	persistenceLevel: "project",
+	artifactKind: "insight",
+	fragment: {
+		id,
+		payload: { text: payload },
+		tNs: 10n,
+		confidence: 0.8,
+		tags: ["agentic"],
+		sources: [],
+	},
+});
+
+describe("D161 persistReactiveCollection and openPersistentReactive*", () => {
+	it("persists list deltas, exposes persistence.cursor facts, and stops on dispose", async () => {
+		const g = graph();
+		const snapshots = memoryKv<unknown>();
+		const changes =
+			memoryAppendLog<ReactiveCollectionChangeFrame<"reactiveList", ListChange<number>>>(
+				"persist-list",
+			);
+		const list = reactiveList<number>([1], { graph: g, name: "list" });
+		const persistence = persistReactiveCollection(g, list, {
+			kind: "reactiveList",
+			name: "list/persistence",
+			snapshotStore: snapshots,
+			snapshotKey: "list/snapshot",
+			changeLog: changes,
+		});
+
+		await waitControl((done) => persistence.flush(done));
+		list.append(2);
+		await waitControl((done) => persistence.flush(done));
+
+		expect(persistence.ready.cache).toBe(true);
+		expect(persistence.cursor.cache).toMatchObject({
+			kind: "persistence.cursor",
+			collection: "reactiveList",
+			changeSeq: 0,
+			changeWrites: 1,
+			snapshotWrites: 1,
+		});
+		expect(persistence.status.cache.pending).toBe(0);
+		expect((await changes.read()).map((entry) => entry.value.change)).toEqual([
+			{ kind: "append", value: 2 },
+		]);
+		expect(await snapshots.get("list/snapshot")).toMatchObject({
+			kind: "reactiveList",
+			changeCursor: -1,
+			snapshot: [1],
+		} satisfies Partial<ReactiveCollectionSnapshotFrame<"reactiveList", readonly number[]>>);
+
+		await waitControl((done) => persistence.dispose(done));
+		list.append(3);
+		await flushMicrotasks();
+		expect((await changes.read()).map((entry) => entry.value.change)).toEqual([
+			{ kind: "append", value: 2 },
+		]);
+		expect(persistence.ready.cache).toBe(false);
+
+		let disposedFlushCalled = false;
+		persistence.flush(() => {
+			disposedFlushCalled = true;
+		});
+		expect(disposedFlushCalled).toBe(true);
+	});
+
+	it("preflights strict JSON before writing default persistence frames", async () => {
+		const g = graph();
+		const snapshots = memoryKv<unknown>();
+		const list = reactiveList<unknown>([1n], { graph: g, name: "strictList" });
+		const persistence = persistReactiveCollection(g, list, {
+			kind: "reactiveList",
+			name: "strictList/persistence",
+			snapshotStore: snapshots,
+			snapshotKey: "strict/snapshot",
+		});
+
+		await waitControl((done) => persistence.flush(done));
+
+		expect(persistence.status.cache.errors).toBe(1);
+		expect(persistence.status.cache.state).toBe("errored");
+		expect(persistence.status.cache.pending).toBe(0);
+		expect(persistence.ready.cache).toBe(false);
+		expect(persistence.error.cache?.message).toMatch(/JSON/);
+		expect(await snapshots.get("strict/snapshot")).toBeUndefined();
+		await waitControl((done) => persistence.flush(done));
+		expect(persistence.status.cache.state).toBe("errored");
+		expect(persistence.ready.cache).toBe(false);
+		await waitControl((done) => persistence.dispose(done));
+	});
+
+	it("manual snapshots reset snapshotEveryChanges cadence", async () => {
+		const g = graph();
+		const baseSnapshots = memoryKv<unknown>();
+		let snapshotWrites = 0;
+		const snapshots = {
+			...baseSnapshots,
+			set(key: string, value: unknown) {
+				snapshotWrites += 1;
+				return baseSnapshots.set(key, value);
+			},
+		};
+		const list = reactiveList<number>([0], { graph: g, name: "cadence" });
+		const persistence = persistReactiveCollection(g, list, {
+			kind: "reactiveList",
+			name: "cadence/persistence",
+			snapshotStore: snapshots,
+			snapshotKey: "cadence/snapshot",
+			snapshotEveryChanges: 3,
+			snapshotOnAttach: false,
+		});
+
+		list.append(1);
+		list.append(2);
+		await waitControl((done) => persistence.snapshot(done));
+		expect(snapshotWrites).toBe(1);
+
+		list.append(3);
+		await waitControl((done) => persistence.flush(done));
+		expect(snapshotWrites).toBe(1);
+
+		list.append(4);
+		list.append(5);
+		await waitControl((done) => persistence.flush(done));
+		expect(snapshotWrites).toBe(2);
+		await waitControl((done) => persistence.dispose(done));
+	});
+
+	it("clears ready and pending after an async change write error", async () => {
+		const g = graph();
+		const snapshots = memoryKv<unknown>();
+		const changes = {
+			append() {
+				return Promise.reject(new Error("change write failed"));
+			},
+			read() {
+				return Promise.resolve([]);
+			},
+			truncateAfter() {
+				return Promise.resolve();
+			},
+			size() {
+				return Promise.resolve(0);
+			},
+		};
+		const list = reactiveList<number>([1], { graph: g, name: "errorList" });
+		const persistence = persistReactiveCollection(g, list, {
+			kind: "reactiveList",
+			name: "errorList/persistence",
+			snapshotStore: snapshots,
+			snapshotKey: "error/snapshot",
+			changeLog: changes,
+		});
+		await waitControl((done) => persistence.flush(done));
+		expect(persistence.ready.cache).toBe(true);
+
+		list.append(2);
+		await waitControl((done) => persistence.flush(done));
+
+		expect(persistence.ready.cache).toBe(false);
+		expect(persistence.status.cache).toMatchObject({
+			state: "errored",
+			pending: 0,
+			errors: 1,
+		});
+		expect(persistence.error.cache?.message).toMatch(/change write failed/);
+		await waitControl((done) => persistence.dispose(done));
+	});
+
+	it("dispose cancels queued snapshots after the running write settles", async () => {
+		const g = graph();
+		const snapshots = memoryKv<unknown>();
+		const releases: Array<() => void> = [];
+		let seq = 0;
+		const changes = {
+			append(value: ReactiveCollectionChangeFrame<"reactiveList", ListChange<number>>) {
+				return new Promise<{ key: string; seq: number; value: typeof value }>((resolve) => {
+					const nextSeq = seq;
+					seq += 1;
+					releases.push(() => resolve({ key: `controlled/${nextSeq}`, seq: nextSeq, value }));
+				});
+			},
+			read() {
+				return Promise.resolve([]);
+			},
+			truncateAfter() {
+				return Promise.resolve();
+			},
+			size() {
+				return Promise.resolve(0);
+			},
+		};
+		const list = reactiveList<number>([0], { graph: g, name: "disposeList" });
+		const persistence = persistReactiveCollection(g, list, {
+			kind: "reactiveList",
+			name: "disposeList/persistence",
+			snapshotStore: snapshots,
+			snapshotKey: "dispose/snapshot",
+			changeLog: changes,
+			snapshotOnAttach: false,
+		});
+
+		list.append(1);
+		let snapshotDone = false;
+		persistence.snapshot(() => {
+			snapshotDone = true;
+		});
+		const disposed = waitControl((done) => persistence.dispose(done));
+		expect(snapshotDone).toBe(true);
+		releases.shift()?.();
+		await disposed;
+
+		expect(await snapshots.get("dispose/snapshot")).toBeUndefined();
+		expect(persistence.status.cache.state).toBe("disposed");
+	});
+
+	it("preserves post-enqueue snapshot cadence counts when a queued snapshot settles", async () => {
+		const g = graph();
+		const snapshots = memoryKv<unknown>();
+		let snapshotWrites = 0;
+		let releaseFirstSnapshot: (() => void) | undefined;
+		const countedSnapshots = {
+			...snapshots,
+			set(key: string, value: unknown) {
+				snapshotWrites += 1;
+				if (snapshotWrites === 1) {
+					return new Promise<void>((resolve, reject) => {
+						releaseFirstSnapshot = () => {
+							snapshots.set(key, value).then(resolve, reject);
+						};
+					});
+				}
+				return snapshots.set(key, value);
+			},
+		};
+		const changes =
+			memoryAppendLog<ReactiveCollectionChangeFrame<"reactiveList", ListChange<number>>>(
+				"cadence-queued",
+			);
+		const list = reactiveList<number>([0], { graph: g, name: "cadenceQueued" });
+		const persistence = persistReactiveCollection(g, list, {
+			kind: "reactiveList",
+			name: "cadenceQueued/persistence",
+			snapshotStore: countedSnapshots,
+			snapshotKey: "cadenceQueued/snapshot",
+			changeLog: changes,
+			snapshotEveryChanges: 2,
+			snapshotOnAttach: false,
+		});
+
+		list.append(1);
+		list.append(2);
+		await waitForMicrotaskState(() => snapshotWrites === 1 && releaseFirstSnapshot !== undefined);
+		expect(snapshotWrites).toBe(1);
+		expect(releaseFirstSnapshot).toBeDefined();
+
+		list.append(3);
+		releaseFirstSnapshot?.();
+		await flushMicrotasks(4);
+
+		list.append(4);
+		await waitControl((done) => persistence.flush(done));
+
+		expect(snapshotWrites).toBe(2);
+		await waitControl((done) => persistence.dispose(done));
+	});
+
+	it("rejects a persistence sidecar over a collection owned by another graph", () => {
+		const owner = graph();
+		const other = graph();
+		const snapshots = memoryKv<unknown>();
+		const changes = memoryAppendLog<unknown>("crossGraph/changes");
+		const list = reactiveList<number>([], { graph: owner, name: "ownedList" });
+
+		expect(() =>
+			persistReactiveCollection(other, list, {
+				kind: "reactiveList",
+				name: "crossGraph/persistence",
+				snapshotStore: snapshots,
+				snapshotKey: "crossGraph/snapshot",
+				changeLog: changes,
+			}),
+		).toThrow(/different graph|cross-graph/);
+		expect(other.describe().nodes.map((node) => node.id)).not.toEqual(
+			expect.arrayContaining([
+				"crossGraph/persistence/ready",
+				"crossGraph/persistence/status",
+				"crossGraph/persistence/error",
+				"crossGraph/persistence/cursor",
+			]),
+		);
+		expect(owner.describe().nodes.map((node) => node.id)).not.toEqual(
+			expect.arrayContaining([
+				"crossGraph/persistence/ready",
+				"crossGraph/persistence/status",
+				"crossGraph/persistence/error",
+				"crossGraph/persistence/cursor",
+			]),
+		);
+		return Promise.all([snapshots.get("crossGraph/snapshot"), changes.size()]).then(
+			([snapshot, changeCount]) => {
+				expect(snapshot).toBeUndefined();
+				expect(changeCount).toBe(0);
+			},
+		);
+	});
+
+	it("queued snapshots capture enqueue-time state with the cursor after prior writes settle", async () => {
+		const g = graph();
+		const snapshots = memoryKv<unknown>();
+		const writes: Array<ReactiveCollectionChangeFrame<"reactiveList", ListChange<number>>> = [];
+		const releases: Array<() => void> = [];
+		let seq = 0;
+		const changes = {
+			append(value: ReactiveCollectionChangeFrame<"reactiveList", ListChange<number>>) {
+				return new Promise<{ key: string; seq: number; value: typeof value }>((resolve) => {
+					const nextSeq = seq;
+					seq += 1;
+					releases.push(() => {
+						writes.push(value);
+						resolve({ key: `controlled/${nextSeq}`, seq: nextSeq, value });
+					});
+				});
+			},
+			read(opts: { after?: number } = {}) {
+				const after = opts.after ?? -1;
+				return Promise.resolve(
+					writes
+						.map((value, i) => ({ key: `controlled/${i}`, seq: i, value }))
+						.filter((entry) => entry.seq > after),
+				);
+			},
+			truncateAfter() {
+				return Promise.resolve();
+			},
+			size() {
+				return Promise.resolve(writes.length);
+			},
+		};
+		const list = reactiveList<number>([0], { graph: g, name: "queued" });
+		const persistence = persistReactiveCollection(g, list, {
+			kind: "reactiveList",
+			name: "queued/persistence",
+			snapshotStore: snapshots,
+			snapshotKey: "queued/snapshot",
+			changeLog: changes,
+			snapshotOnAttach: false,
+		});
+
+		list.append(1);
+		let snapshotDone = false;
+		const snapshotBarrier = waitControl((done) =>
+			persistence.snapshot(() => {
+				snapshotDone = true;
+				done();
+			}),
+		);
+		list.append(2);
+		releases.shift()?.();
+		await snapshotBarrier;
+
+		expect(snapshotDone).toBe(true);
+		expect(await snapshots.get("queued/snapshot")).toMatchObject({
+			changeCursor: 0,
+			snapshot: [0, 1],
+		});
+
+		releases.shift()?.();
+		await waitControl((done) => persistence.flush(done));
+		const loaded = await loadReactiveListState<number>({
+			snapshotStore: snapshots,
+			snapshotKey: "queued/snapshot",
+			changeLog: changes,
+		});
+		expect(loaded.state).toEqual([0, 1, 2]);
+		await waitControl((done) => persistence.dispose(done));
+	});
+
+	it("openPersistentReactiveList composes load -> restore -> persist and uses initial only for explicit empty state", async () => {
+		const g = graph();
+		const snapshots = memoryKv<unknown>();
+		const changes =
+			memoryAppendLog<ReactiveCollectionChangeFrame<"reactiveList", ListChange<number>>>(
+				"open-list",
+			);
+
+		const opened = await openPersistentReactiveList<number>({
+			graph: g,
+			name: "list",
+			initial: [10],
+			snapshotStore: snapshots,
+			snapshotKey: "list/snapshot",
+			changeLog: changes,
+		});
+		await waitControl((done) => opened.persistence.flush(done));
+		opened.collection.append(20);
+		await waitControl((done) => opened.persistence.flush(done));
+		await waitControl((done) => opened.persistence.snapshot(done));
+
+		const reopened = await openPersistentReactiveList<number>({
+			graph: graph(),
+			name: "list",
+			initial: [999],
+			snapshotStore: snapshots,
+			snapshotKey: "list/snapshot",
+			changeLog: changes,
+		});
+
+		expect(opened.loaded.source).toBe("empty");
+		expect(opened.collection.toArray()).toEqual([10, 20]);
+		expect(reopened.loaded.source).toBe("snapshot");
+		expect(reopened.collection.toArray()).toEqual([10, 20]);
+		await waitControl((done) => opened.persistence.dispose(done));
+		await waitControl((done) => reopened.persistence.dispose(done));
+	});
+
+	it("openPersistentReactiveList uses one default snapshot key for load and persist", async () => {
+		const snapshots = memoryKv<unknown>();
+		const changes =
+			memoryAppendLog<ReactiveCollectionChangeFrame<"reactiveList", ListChange<number>>>(
+				"default-key-list",
+			);
+		const opened = await openPersistentReactiveList<number>({
+			graph: graph(),
+			name: "defaultList",
+			initial: [1],
+			snapshotStore: snapshots,
+			changeLog: changes,
+		});
+		await waitControl((done) => opened.persistence.flush(done));
+		opened.collection.append(2);
+		await waitControl((done) => opened.persistence.flush(done));
+		await waitControl((done) => opened.persistence.snapshot(done));
+		await waitControl((done) => opened.persistence.dispose(done));
+
+		const reopened = await openPersistentReactiveList<number>({
+			graph: graph(),
+			name: "defaultList",
+			initial: [999],
+			snapshotStore: snapshots,
+			changeLog: changes,
+		});
+
+		expect(reopened.loaded.source).toBe("snapshot");
+		expect(reopened.collection.toArray()).toEqual([1, 2]);
+		await waitControl((done) => reopened.persistence.flush(done));
+		await waitControl((done) => reopened.persistence.dispose(done));
+
+		const third = await openPersistentReactiveList<number>({
+			graph: graph(),
+			name: "defaultList",
+			initial: [999],
+			snapshotStore: snapshots,
+			changeLog: changes,
+		});
+		expect(third.collection.toArray()).toEqual([1, 2]);
+		await waitControl((done) => third.persistence.dispose(done));
+	});
+
+	it("openPersistentReactiveLog folds log changes and honors maxSize through restore options", async () => {
+		const snapshots = memoryKv<unknown>();
+		const changes =
+			memoryAppendLog<ReactiveCollectionChangeFrame<"reactiveLog", LogChange<string>>>("open-log");
+		await changes.append(
+			reactiveCollectionChangeFrame("reactiveLog", {
+				kind: "appendMany",
+				values: ["a", "b", "c"],
+			}),
+		);
+
+		const opened = await openPersistentReactiveLog<string>({
+			graph: graph(),
+			name: "log",
+			initial: ["ignored"],
+			snapshotStore: snapshots,
+			snapshotKey: "log/snapshot",
+			changeLog: changes,
+			collection: { maxSize: 2 },
+		});
+
+		expect(opened.loaded.source).toBe("changes");
+		expect(opened.collection.toArray()).toEqual(["b", "c"]);
+		await waitControl((done) => opened.persistence.dispose(done));
+	});
+
+	it("openPersistentReactiveMap and openPersistentReactiveIndex compose load -> restore -> persist", async () => {
+		const mapSnapshots = memoryKv<unknown>();
+		const mapChanges =
+			memoryAppendLog<ReactiveCollectionChangeFrame<"reactiveMap", MapChange<string, number>>>(
+				"open-map",
+			);
+		const openedMap = await openPersistentReactiveMap<string, number>({
+			graph: graph(),
+			name: "map",
+			initial: [["a", 1]],
+			snapshotStore: mapSnapshots,
+			snapshotKey: "map/snapshot",
+			changeLog: mapChanges,
+		});
+		await waitControl((done) => openedMap.persistence.flush(done));
+		openedMap.collection.set("b", 2);
+		await waitControl((done) => openedMap.persistence.flush(done));
+		await waitControl((done) => openedMap.persistence.snapshot(done));
+		await waitControl((done) => openedMap.persistence.dispose(done));
+
+		const reopenedMap = await openPersistentReactiveMap<string, number>({
+			graph: graph(),
+			name: "map",
+			initial: [["ignored", 999]],
+			snapshotStore: mapSnapshots,
+			snapshotKey: "map/snapshot",
+			changeLog: mapChanges,
+		});
+		expect(reopenedMap.collection.get("a")).toBe(1);
+		expect(reopenedMap.collection.get("b")).toBe(2);
+		await waitControl((done) => reopenedMap.persistence.dispose(done));
+
+		const indexSnapshots = memoryKv<unknown>();
+		const indexChanges =
+			memoryAppendLog<ReactiveCollectionChangeFrame<"reactiveIndex", IndexChange<string, number>>>(
+				"open-index",
+			);
+		const openedIndex = await openPersistentReactiveIndex<string, number>({
+			graph: graph(),
+			name: "index",
+			initial: [{ primary: "a", secondary: 1, value: 10 }],
+			snapshotStore: indexSnapshots,
+			snapshotKey: "index/snapshot",
+			changeLog: indexChanges,
+		});
+		await waitControl((done) => openedIndex.persistence.flush(done));
+		openedIndex.collection.upsert("b", 2, 20);
+		await waitControl((done) => openedIndex.persistence.flush(done));
+		await waitControl((done) => openedIndex.persistence.snapshot(done));
+		await waitControl((done) => openedIndex.persistence.dispose(done));
+
+		const reopenedIndex = await openPersistentReactiveIndex<string, number>({
+			graph: graph(),
+			name: "index",
+			initial: [{ primary: "ignored", secondary: 0, value: 999 }],
+			snapshotStore: indexSnapshots,
+			snapshotKey: "index/snapshot",
+			changeLog: indexChanges,
+		});
+		expect(reopenedIndex.collection.get("a")).toBe(10);
+		expect(reopenedIndex.collection.get("b")).toBe(20);
+		await waitControl((done) => reopenedIndex.persistence.dispose(done));
+	});
+});
diff --git a/packages/ts/src/__tests__/reactive-collection-storage.part-01.test.ts b/packages/ts/src/__tests__/reactive-collection-storage.part-01.test.ts
new file mode 100644
index 00000000..a1b5ecc2
--- /dev/null
+++ b/packages/ts/src/__tests__/reactive-collection-storage.part-01.test.ts
@@ -0,0 +1,526 @@
+import { describe, expect, it } from "vitest";
+import type { IndexChange, ListChange, MapChange } from "../graph/data-structures/change.js";
+import type { IndexRow } from "../graph/data-structures/reactive-index.js";
+import {
+	type AgenticMemoryRecord,
+	agenticMemoryRecordChangeFrame,
+	agenticMemoryRecordSnapshotFrame,
+	agenticMemoryRecordsSnapshotKey,
+	graph,
+	loadAgenticMemoryRecordsState,
+	loadReactiveIndexState,
+	loadReactiveListState,
+	loadReactiveLogState,
+	loadReactiveMapState,
+	memoryAppendLog,
+	memoryKv,
+	openPersistentAgenticMemoryRecords,
+	persistAgenticMemoryRecords,
+	type ReactiveCollectionChangeFrame,
+	reactiveCollectionChangeFrame,
+	reactiveCollectionSnapshotFrame,
+	restoreReactiveIndex,
+	restoreReactiveList,
+	restoreReactiveLog,
+	restoreReactiveMap,
+} from "../index.js";
+
+const _flushMicrotasks = async (turns = 1) => {
+	for (let i = 0; i < turns; i += 1) await Promise.resolve();
+};
+
+const _waitForMicrotaskState = async (predicate: () => boolean, turns = 50): Promise<void> => {
+	for (let i = 0; i < turns; i += 1) {
+		if (predicate()) return;
+		await Promise.resolve();
+	}
+	throw new Error("timed out waiting for microtask state");
+};
+
+const waitControl = (run: (done: () => void) => void): Promise<void> =>
+	new Promise<void>((resolve) => {
+		run(resolve);
+	});
+
+const memoryRecord = (
+	id: string,
+	payload: string,
+): AgenticMemoryRecord<{ readonly text: string }> => ({
+	id: `record-${id}`,
+	kind: "semantic",
+	persistenceLevel: "project",
+	artifactKind: "insight",
+	fragment: {
+		id,
+		payload: { text: payload },
+		tNs: 10n,
+		confidence: 0.8,
+		tags: ["agentic"],
+		sources: [],
+	},
+});
+
+describe("D161 reactive collection storage frames and passive load/fold", () => {
+	it("folds a reactiveList snapshot plus changes after the snapshot cursor", async () => {
+		const snapshots = memoryKv<unknown>();
+		const changes = memoryAppendLog<unknown>("list-changes");
+
+		await changes.append(
+			reactiveCollectionChangeFrame("reactiveList", {
+				kind: "append",
+				value: "old",
+			} satisfies ListChange<string>),
+		);
+		await snapshots.set(
+			"list/snapshot",
+			reactiveCollectionSnapshotFrame("reactiveList", ["base"], { changeCursor: 0 }),
+		);
+		await changes.append(
+			reactiveCollectionChangeFrame("reactiveList", {
+				kind: "insert",
+				index: 1,
+				value: "new",
+			} satisfies ListChange<string>),
+		);
+
+		const state = await loadReactiveListState<string>({
+			snapshotStore: snapshots,
+			snapshotKey: "list/snapshot",
+			changeLog: changes,
+		});
+
+		expect(state).toMatchObject({
+			kind: "reactiveList",
+			source: "snapshot+changes",
+			snapshot: { found: true, changeCursor: 0 },
+			changes: { applied: 1, cursor: 1 },
+		});
+		expect(state.state).toEqual(["base", "new"]);
+	});
+
+	it("treats missing snapshot plus missing/empty change log as explicit empty state", async () => {
+		const snapshots = memoryKv<unknown>();
+		const emptyList = await loadReactiveListState<number>({
+			snapshotStore: snapshots,
+			storagePrefix: "empty-list",
+		});
+		const emptyLog = await loadReactiveLogState<number>({
+			snapshotStore: snapshots,
+			storagePrefix: "empty-log",
+			changeLog: memoryAppendLog<unknown>("empty-log-changes"),
+		});
+
+		expect(emptyList.source).toBe("empty");
+		expect(emptyList.state).toEqual([]);
+		expect(emptyLog.source).toBe("empty");
+		expect(emptyLog.state).toEqual([]);
+	});
+
+	it("rejects corrupt snapshot and change frames honestly", async () => {
+		const snapshots = memoryKv<unknown>();
+		const changes = memoryAppendLog<unknown>("bad-list");
+		await snapshots.set("bad/snapshot", {
+			...reactiveCollectionSnapshotFrame("reactiveList", []),
+			restore: true,
+		});
+		await changes.append({
+			...reactiveCollectionChangeFrame("reactiveList", { kind: "append", value: 1 }),
+			version: 2,
+		});
+
+		await expect(
+			loadReactiveListState({ snapshotStore: snapshots, snapshotKey: "bad/snapshot" }),
+		).rejects.toThrow(/unexpected frame fields|invalid version/);
+
+		const cleanSnapshots = memoryKv<unknown>();
+		await expect(
+			loadReactiveListState({ snapshotStore: cleanSnapshots, changeLog: changes }),
+		).rejects.toThrow(/invalid version/);
+
+		const malformedChanges = memoryAppendLog<unknown>("bad-list-shape");
+		await malformedChanges.append(
+			reactiveCollectionChangeFrame("reactiveList", {
+				value: 1,
+			} as unknown as ListChange<number>),
+		);
+		await expect(
+			loadReactiveListState({ snapshotStore: cleanSnapshots, changeLog: malformedChanges }),
+		).rejects.toThrow(/kind/);
+	});
+
+	it("rejects change-log seq holes instead of folding a false state", async () => {
+		const snapshots = memoryKv<unknown>();
+		const gapLog = {
+			append(value: unknown) {
+				return Promise.resolve({ key: "gap/1", seq: 1, value });
+			},
+			read() {
+				return Promise.resolve([
+					{
+						key: "gap/1",
+						seq: 1,
+						value: reactiveCollectionChangeFrame("reactiveList", {
+							kind: "append",
+							value: "lost baseline",
+						}),
+					},
+				]);
+			},
+			truncateAfter() {
+				return Promise.resolve();
+			},
+			size() {
+				return Promise.resolve(1);
+			},
+		};
+
+		await expect(
+			loadReactiveListState<string>({ snapshotStore: snapshots, changeLog: gapLog }),
+		).rejects.toThrow(/non-contiguous/);
+	});
+
+	it("rejects impossible list/log change folds instead of normalizing them", async () => {
+		const listSnapshots = memoryKv<unknown>();
+		const listChanges = memoryAppendLog<unknown>("bad-list-fold");
+		await listSnapshots.set(
+			"list/snapshot",
+			reactiveCollectionSnapshotFrame("reactiveList", [1], { changeCursor: -1 }),
+		);
+		await listChanges.append(
+			reactiveCollectionChangeFrame("reactiveList", { kind: "trimHead", n: 2 }),
+		);
+		await expect(
+			loadReactiveListState({
+				snapshotStore: listSnapshots,
+				snapshotKey: "list/snapshot",
+				changeLog: listChanges,
+			}),
+		).rejects.toThrow(/trimHead/);
+
+		const logSnapshots = memoryKv<unknown>();
+		const logChanges = memoryAppendLog<unknown>("bad-log-fold");
+		await logSnapshots.set(
+			"log/snapshot",
+			reactiveCollectionSnapshotFrame("reactiveLog", ["a"], { changeCursor: -1 }),
+		);
+		await logChanges.append(
+			reactiveCollectionChangeFrame("reactiveLog", { kind: "clear", count: 2 }),
+		);
+		await expect(
+			loadReactiveLogState({
+				snapshotStore: logSnapshots,
+				snapshotKey: "log/snapshot",
+				changeLog: logChanges,
+			}),
+		).rejects.toThrow(/clear/);
+	});
+
+	it("folds reactiveMap and reactiveIndex snapshots plus strict change logs", async () => {
+		const mapSnapshots = memoryKv<unknown>();
+		const mapChanges =
+			memoryAppendLog<ReactiveCollectionChangeFrame<"reactiveMap", MapChange<string, number>>>(
+				"map-changes",
+			);
+		await mapSnapshots.set(
+			"map/snapshot",
+			reactiveCollectionSnapshotFrame("reactiveMap", [["a", 1]], { changeCursor: -1 }),
+		);
+		await mapChanges.append(
+			reactiveCollectionChangeFrame("reactiveMap", {
+				kind: "set",
+				key: "b",
+				value: 2,
+			}),
+		);
+		await mapChanges.append(
+			reactiveCollectionChangeFrame("reactiveMap", {
+				kind: "delete",
+				key: "a",
+				previous: 1,
+				reason: "explicit",
+			}),
+		);
+
+		const indexSnapshots = memoryKv<unknown>();
+		const indexChanges =
+			memoryAppendLog<ReactiveCollectionChangeFrame<"reactiveIndex", IndexChange<string, number>>>(
+				"index-changes",
+			);
+		await indexSnapshots.set(
+			"index/snapshot",
+			reactiveCollectionSnapshotFrame("reactiveIndex", [
+				{ primary: "b", secondary: 2, value: 20 },
+			] satisfies readonly IndexRow<string, number>[]),
+		);
+		await indexChanges.append(
+			reactiveCollectionChangeFrame("reactiveIndex", {
+				kind: "upsert",
+				primary: "a",
+				secondary: 1,
+				value: 10,
+			}),
+		);
+
+		const mapState = await loadReactiveMapState<string, number>({
+			snapshotStore: mapSnapshots,
+			snapshotKey: "map/snapshot",
+			changeLog: mapChanges,
+		});
+		const indexState = await loadReactiveIndexState<string, number>({
+			snapshotStore: indexSnapshots,
+			snapshotKey: "index/snapshot",
+			changeLog: indexChanges,
+		});
+
+		expect(mapState.state).toEqual([["b", 2]]);
+		expect(indexState.state).toEqual([
+			{ primary: "a", secondary: 1, value: 10 },
+			{ primary: "b", secondary: 2, value: 20 },
+		]);
+	});
+
+	it("rejects duplicate reactiveMap keys and reactiveIndex primaries in snapshots", async () => {
+		const mapSnapshots = memoryKv<unknown>();
+		await mapSnapshots.set(
+			"map/snapshot",
+			reactiveCollectionSnapshotFrame("reactiveMap", [
+				[{ id: 1 }, "first"],
+				[{ id: 1 }, "second"],
+			]),
+		);
+		await expect(
+			loadReactiveMapState<object, string>({
+				snapshotStore: mapSnapshots,
+				snapshotKey: "map/snapshot",
+			}),
+		).rejects.toThrow(/duplicates an earlier key/);
+
+		const indexSnapshots = memoryKv<unknown>();
+		await indexSnapshots.set(
+			"index/snapshot",
+			reactiveCollectionSnapshotFrame("reactiveIndex", [
+				{ primary: { id: 1 }, secondary: 1, value: "first" },
+				{ primary: { id: 1 }, secondary: 2, value: "second" },
+			]),
+		);
+		await expect(
+			loadReactiveIndexState<object, string>({
+				snapshotStore: indexSnapshots,
+				snapshotKey: "index/snapshot",
+			}),
+		).rejects.toThrow(/duplicates an earlier primary/);
+	});
+});
+
+describe("D172 agentic memory record persistence sidecar", () => {
+	it("loads snapshot plus replaceAll change frames without mutating a graph", async () => {
+		const snapshots = memoryKv<unknown>();
+		const changes = memoryAppendLog<unknown>("agentic-records");
+		await snapshots.set(
+			agenticMemoryRecordsSnapshotKey("agentic"),
+			agenticMemoryRecordSnapshotFrame([memoryRecord("base", "base")], { changeCursor: -1 }),
+		);
+		await changes.append(agenticMemoryRecordChangeFrame([memoryRecord("next", "next")]));
+
+		const loaded = await loadAgenticMemoryRecordsState<{ readonly text: string }>({
+			snapshotStore: snapshots,
+			storagePrefix: "agentic",
+			changeLog: changes,
+		});
+
+		expect(loaded.source).toBe("snapshot+changes");
+		expect(loaded.records.map((record) => record.id)).toEqual(["record-next"]);
+		expect(loaded.records[0]?.fragment.tNs).toBe(10n);
+		expect(loaded.changes).toEqual({ applied: 1, cursor: 0 });
+	});
+
+	it("reads agentic record changes after the snapshot cursor and rejects sparse frames", async () => {
+		const snapshot = agenticMemoryRecordSnapshotFrame([memoryRecord("base", "base")], {
+			changeCursor: 0,
+		});
+		const next = agenticMemoryRecordChangeFrame([memoryRecord("next", "next")]);
+		const loaded = await loadAgenticMemoryRecordsState<{ readonly text: string }>({
+			snapshotStore: {
+				get: () => Promise.resolve(snapshot),
+			} as never,
+			changeLog: {
+				read: (opts = {}) => {
+					expect(opts).toEqual({ after: 0 });
+					return Promise.resolve([{ key: "changes/1", seq: 1, value: next }]);
+				},
+			} as never,
+		});
+
+		expect(loaded.records.map((record) => record.id)).toEqual(["record-next"]);
+		const sparseRecords = [] as unknown[];
+		sparseRecords.length = 1;
+		await expect(
+			loadAgenticMemoryRecordsState({
+				snapshotStore: {
+					get: () =>
+						Promise.resolve({
+							format: "graphrefly.agenticMemory.records.snapshot",
+							version: 1,
+							changeCursor: -1,
+							records: sparseRecords,
+						}),
+				} as never,
+			}),
+		).rejects.toThrow(/sparse array hole/);
+	});
+
+	it("persists records as passive frames and exposes persistence.cursor facts", async () => {
+		const g = graph();
+		const snapshots = memoryKv<unknown>();
+		const changes = memoryAppendLog<unknown>("agentic-sidecar");
+		const records = g.state<readonly AgenticMemoryRecord<{ readonly text: string }>[]>(
+			[memoryRecord("a", "a")],
+			{ name: "records" },
+		);
+		const persistence = persistAgenticMemoryRecords(g, records, {
+			name: "agentic/persistence",
+			snapshotStore: snapshots,
+			storagePrefix: "agentic-sidecar",
+			changeLog: changes,
+			snapshotEveryChanges: 2,
+		});
+		await waitControl((done) => persistence.flush(done));
+		const nextRecords = [memoryRecord("b", "b")];
+		records.set(nextRecords);
+		nextRecords[0] = memoryRecord("mutated", "mutated");
+		await waitControl((done) => persistence.flush(done));
+
+		expect(persistence.ready.cache).toBe(true);
+		expect(persistence.cursor.cache).toMatchObject({
+			kind: "persistence.cursor",
+			changeSeq: 0,
+			snapshotWrites: 1,
+			changeWrites: 1,
+		});
+		expect(g.describe().nodes).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({ id: "agentic/persistence/ready" }),
+				expect.objectContaining({ id: "agentic/persistence/status" }),
+				expect.objectContaining({ id: "agentic/persistence/error" }),
+				expect.objectContaining({ id: "agentic/persistence/cursor" }),
+			]),
+		);
+		const loaded = await loadAgenticMemoryRecordsState<{ readonly text: string }>({
+			snapshotStore: snapshots,
+			storagePrefix: "agentic-sidecar",
+			changeLog: changes,
+		});
+		expect(loaded.records.map((record) => record.id)).toEqual(["record-b"]);
+		const writtenChange = (await changes.read()).at(0)?.value as
+			| ReturnType<typeof agenticMemoryRecordChangeFrame>
+			| undefined;
+		expect(writtenChange?.change.records[0]?.record.id).toBe("record-b");
+		await waitControl((done) => persistence.dispose(done));
+	});
+
+	it("opens persistent records with initial values and fails corrupt frames honestly", async () => {
+		const snapshots = memoryKv<unknown>();
+		const changes = memoryAppendLog<unknown>("agentic-open");
+		const g = graph();
+		const opened = await openPersistentAgenticMemoryRecords({
+			graph: g,
+			name: "agenticRecords",
+			snapshotStore: snapshots,
+			changeLog: changes,
+			initial: [memoryRecord("initial", "initial")],
+		});
+		expect(opened.records.cache?.map((record) => record.id)).toEqual(["record-initial"]);
+		await waitControl((done) => opened.persistence.flush(done));
+		await waitControl((done) => opened.persistence.dispose(done));
+
+		await snapshots.set(agenticMemoryRecordsSnapshotKey("bad"), {
+			...agenticMemoryRecordSnapshotFrame([memoryRecord("ok", "ok")]),
+			storageTier: "cold",
+		});
+		await expect(
+			loadAgenticMemoryRecordsState({ snapshotStore: snapshots, storagePrefix: "bad" }),
+		).rejects.toThrow(/unexpected frame fields/);
+	});
+});
+
+describe("D161 synchronous restore helpers", () => {
+	it("restoreReactiveList and restoreReactiveLog seed graphless collections without storage reads", () => {
+		const list = restoreReactiveList({
+			kind: "reactiveList",
+			state: [1, 2],
+			source: "snapshot",
+			snapshot: { found: true, changeCursor: -1 },
+			changes: { applied: 0, cursor: -1 },
+		});
+		const log = restoreReactiveLog({
+			kind: "reactiveLog",
+			state: ["a"],
+			source: "changes",
+			snapshot: { found: false, changeCursor: -1 },
+			changes: { applied: 1, cursor: 0 },
+		});
+
+		list.append(3);
+		log.append("b");
+
+		expect(list.toArray()).toEqual([1, 2, 3]);
+		expect(log.toArray()).toEqual(["a", "b"]);
+	});
+
+	it("restoreReactiveList can register graph/name collection ports", () => {
+		const g = graph();
+		const list = restoreReactiveList([1], { graph: g, name: "list" });
+
+		expect(list.toArray()).toEqual([1]);
+		expect(g.describe().nodes.map((node) => node.id)).toEqual(
+			expect.arrayContaining(["list.delta", "list.snapshot"]),
+		);
+	});
+
+	it("restoreReactiveList and restoreReactiveLog reject wrong-kind restore states", () => {
+		const logState = {
+			kind: "reactiveLog",
+			state: ["x"],
+			source: "snapshot",
+			snapshot: { found: true, changeCursor: -1 },
+			changes: { applied: 0, cursor: -1 },
+		} as unknown as Parameters<typeof restoreReactiveList<string>>[0];
+		const listState = {
+			kind: "reactiveList",
+			state: ["x"],
+			source: "snapshot",
+			snapshot: { found: true, changeCursor: -1 },
+			changes: { applied: 0, cursor: -1 },
+		} as unknown as Parameters<typeof restoreReactiveLog<string>>[0];
+
+		expect(() => restoreReactiveList(logState)).toThrow(/reactiveList/);
+		expect(() => restoreReactiveLog(listState)).toThrow(/reactiveLog/);
+	});
+
+	it("restoreReactiveMap and restoreReactiveIndex seed graph-registered backends", () => {
+		const g = graph();
+		const map = restoreReactiveMap<string, number>([["a", 1]], { graph: g, name: "map" });
+		const index = restoreReactiveIndex<string, number>(
+			[
+				{ primary: "b", secondary: 2, value: 20 },
+				{ primary: "a", secondary: 1, value: 10 },
+			],
+			{ graph: g, name: "index" },
+		);
+
+		map.set("b", 2);
+		index.upsert("c", 3, 30);
+
+		expect(map.get("a")).toBe(1);
+		expect(map.get("b")).toBe(2);
+		expect(index.get("a")).toBe(10);
+		expect(index.toArray()).toEqual([
+			{ primary: "a", secondary: 1, value: 10 },
+			{ primary: "b", secondary: 2, value: 20 },
+			{ primary: "c", secondary: 3, value: 30 },
+		]);
+		expect(g.describe().nodes.map((node) => node.id)).toEqual(
+			expect.arrayContaining(["map.delta", "map.snapshot", "index.delta", "index.snapshot"]),
+		);
+	});
+});
diff --git a/packages/ts/src/__tests__/reentrancy.test.ts b/packages/ts/src/__tests__/reentrancy.test.ts
new file mode 100644
index 00000000..89502d41
--- /dev/null
+++ b/packages/ts/src/__tests__/reentrancy.test.ts
@@ -0,0 +1,41 @@
+import { describe, expect, it } from "vitest";
+import type { Ctx } from "../index.js";
+import { depLatest, node } from "../index.js";
+
+const plus1 = (ctx: Ctx) => ctx.down([["DATA", (depLatest(ctx, 0) as number) + 1]]);
+
+describe("R-reentrancy (D37) — synchronous feedback cycle is rejected", () => {
+	it("a fn that re-drives its own dep mid-wave throws (cycle detected node-locally)", () => {
+		// state S → derived D (=n+1) → effect E; E feeds back into S, closing S→D→E→S.
+		// Activating the chain drives the cycle synchronously and must reject.
+		const s = node<number>([], null, { initial: 0 });
+		const d = node<number>([s], plus1);
+		const e = node<number>([d], (ctx: Ctx) => {
+			// feedback write back to S (an indirect dep of E) — re-enters the wave.
+			s.down([["DATA", depLatest(ctx, 0) as number]]);
+		});
+		expect(() => e.subscribe(() => {})).toThrow(/feedback cycle|R-reentrancy/i);
+	});
+
+	it("an acyclic chain does NOT throw (the guard does not false-positive)", () => {
+		const s = node<number>([], null, { initial: 1 });
+		const d = node<number>([s], plus1);
+		const e = node<number>([d], (ctx: Ctx) => ctx.down([["DATA", depLatest(ctx, 0) as number]]));
+		expect(() => e.subscribe(() => {})).not.toThrow();
+		expect(e.cache).toBe(2);
+	});
+
+	it("a rejected cycle leaves other graphs usable (try/finally resets the flag on unwind)", () => {
+		const s = node<number>([], null, { initial: 0 });
+		const d = node<number>([s], plus1);
+		const e = node<number>([d], (ctx: Ctx) => {
+			s.down([["DATA", depLatest(ctx, 0) as number]]);
+		});
+		expect(() => e.subscribe(() => {})).toThrow();
+		// A fresh, independent chain still computes — no node left with a stuck in-wave flag.
+		const a = node<number>([], null, { initial: 7 });
+		const b = node<number>([a], plus1);
+		b.subscribe(() => {});
+		expect(b.cache).toBe(8);
+	});
+});
diff --git a/packages/ts/src/__tests__/render.test.ts b/packages/ts/src/__tests__/render.test.ts
new file mode 100644
index 00000000..906ecfc7
--- /dev/null
+++ b/packages/ts/src/__tests__/render.test.ts
@@ -0,0 +1,308 @@
+/**
+ * CSP-2.8 render first-cut (D39/D40): pure functions over DescribeSnapshot.
+ */
+
+import { describe, expect, it } from "vitest";
+import {
+	type DescribeSnapshot,
+	describeToAscii,
+	describeToD2,
+	describeToJson,
+	describeToMermaid,
+	describeToMermaidUrl,
+	describeToPretty,
+	graph,
+	mermaidLiveUrl,
+} from "../index.js";
+
+describe("describe renderers (D39/D40)", () => {
+	const renderSmokeOutputs = (snap: DescribeSnapshot) => ({
+		mermaid: describeToMermaid(snap),
+		d2: describeToD2(snap),
+		pretty: describeToPretty(snap),
+		ascii: describeToAscii(snap),
+		json: describeToJson(snap, { indent: 0 }),
+	});
+
+	it("renders Mermaid from a flat + mounted describe snapshot", () => {
+		const parent = graph({ name: "demo" });
+		const count = parent.state(0, { name: "count" });
+		const doubled = parent.derived([count], (n) => n * 2, { name: "doubled" });
+		doubled.subscribe(() => {});
+		count.set(5);
+
+		const child = graph();
+		const leaf = child.state("ready", { name: 'leaf "quoted"' });
+		leaf.subscribe(() => {});
+		parent.mount(child, { at: "child" });
+
+		expect(describeToMermaid(parent.describe(), { direction: "TD" })).toBe(
+			[
+				"flowchart TD",
+				'  n0["child::leaf \\"quoted\\""]',
+				'  n1["count"]',
+				'  n2["doubled"]',
+				"  n1 --> n2",
+			].join("\n"),
+		);
+	});
+
+	it("renders D2 with deterministic ids and direction mapping", () => {
+		const snap: DescribeSnapshot = {
+			nodes: [
+				{ id: "b", factory: "derived", status: "sentinel", deps: ["a"] },
+				{ id: "a", factory: "state", status: "settled", deps: [], value: 1 },
+			],
+			edges: [{ from: "a", to: "b" }],
+		};
+
+		expect(describeToD2(snap, { direction: "RL" })).toBe(
+			["direction: left", 'n0: "a"', 'n1: "b"', "n0 -> n1"].join("\n"),
+		);
+	});
+
+	it("renders pretty text with SENTINEL absence", () => {
+		const snap: DescribeSnapshot = {
+			name: "pretty",
+			nodes: [
+				{ id: "source", factory: "state", status: "settled", deps: [], value: { ok: true } },
+				{ id: "quiet", factory: "filter", status: "sentinel", deps: ["source"] },
+			],
+			edges: [{ from: "source", to: "quiet" }],
+		};
+
+		const text = describeToPretty(snap);
+
+		expect(text).toBe(
+			[
+				"Graph pretty",
+				"Nodes:",
+				"- quiet (filter/sentinel): <SENTINEL>",
+				'- source (state/settled): {"ok":true}',
+				"Edges:",
+				"- source -> quiet",
+			].join("\n"),
+		);
+	});
+
+	it("renders compact ASCII adjacency with optional values", () => {
+		const snap: DescribeSnapshot = {
+			name: "ascii",
+			nodes: [
+				{ id: "b", factory: "derived", status: "sentinel", deps: ["a"] },
+				{ id: "a", factory: "state", status: "settled", deps: [], value: 1 },
+				{ id: "c", factory: "effect", status: "sentinel", deps: [] },
+			],
+			edges: [{ from: "a", to: "b" }],
+		};
+
+		expect(describeToAscii(snap, { includeValues: true })).toBe(
+			[
+				"Graph ascii",
+				"a [state/settled 1] -> b",
+				"b [derived/sentinel <SENTINEL>] -> -",
+				"c [effect/sentinel <SENTINEL>] -> -",
+			].join("\n"),
+		);
+	});
+
+	it("renders deterministic JSON and can omit edges", () => {
+		const snap: DescribeSnapshot = {
+			nodes: [
+				{
+					id: "z",
+					factory: "node",
+					status: "settled",
+					deps: [],
+					meta: { b: 2, a: 1 },
+					value: { y: 2, x: 1 },
+				},
+			],
+			edges: [{ from: "a", to: "z" }],
+		};
+
+		expect(describeToJson(snap, { includeEdges: false, indent: 0 })).toBe(
+			'{"edges":[],"nodes":[{"deps":[],"factory":"node","id":"z","meta":{"a":1,"b":2},"status":"settled","value":{"x":1,"y":2}}]}',
+		);
+	});
+
+	it("sorts labels deterministically without locale collation", () => {
+		const snap: DescribeSnapshot = {
+			nodes: [
+				{ id: "a", factory: "state", status: "sentinel", deps: [] },
+				{ id: "A", factory: "state", status: "sentinel", deps: [] },
+				{ id: "á", factory: "state", status: "sentinel", deps: [] },
+			],
+			edges: [],
+		};
+
+		expect(describeToAscii(snap)).toBe(
+			[
+				"Graph (anonymous)",
+				"A [state/sentinel] -> -",
+				"a [state/sentinel] -> -",
+				"á [state/sentinel] -> -",
+			].join("\n"),
+		);
+	});
+
+	it("escapes diagram labels without introducing physical control-character lines", () => {
+		const snap: DescribeSnapshot = {
+			nodes: [{ id: 'line\nbreak "quoted"', factory: "state", status: "sentinel", deps: [] }],
+			edges: [],
+		};
+
+		expect(describeToMermaid(snap)).toBe('flowchart LR\n  n0["line\\nbreak \\"quoted\\""]');
+		expect(describeToD2(snap)).toBe('direction: right\nn0: "line\\nbreak \\"quoted\\""');
+	});
+
+	it("renders cyclic and bigint values in deterministic JSON", () => {
+		const circular: Record<string, unknown> = { z: 1 };
+		circular.self = circular;
+		const snap: DescribeSnapshot = {
+			nodes: [
+				{
+					id: "cyclic",
+					factory: "state",
+					status: "settled",
+					deps: [],
+					value: { circular, id: 1n },
+				},
+			],
+			edges: [],
+		};
+
+		expect(describeToJson(snap, { indent: 0 })).toBe(
+			'{"edges":[],"nodes":[{"deps":[],"factory":"state","id":"cyclic","status":"settled","value":{"circular":{"self":"[Circular]","z":1},"id":"1"}}]}',
+		);
+	});
+
+	it("smoke-renders duplicate edges without crashing and dedupes deterministically", () => {
+		const snap: DescribeSnapshot = {
+			name: "duplicate edges",
+			nodes: [
+				{ id: "sink", factory: "derived", status: "sentinel", deps: ["source"] },
+				{ id: "source", factory: "state", status: "settled", deps: [], value: 1 },
+			],
+			edges: [
+				{ from: "source", to: "sink" },
+				{ from: "source", to: "sink" },
+				{ from: "source", to: "sink" },
+			],
+		};
+
+		const outputs = renderSmokeOutputs(snap);
+
+		expect(outputs).toEqual({
+			mermaid: ["flowchart LR", '  n0["sink"]', '  n1["source"]', "  n1 --> n0"].join("\n"),
+			d2: ["direction: right", 'n0: "sink"', 'n1: "source"', "n1 -> n0"].join("\n"),
+			pretty: [
+				"Graph duplicate edges",
+				"Nodes:",
+				"- sink (derived/sentinel): <SENTINEL>",
+				"- source (state/settled): 1",
+				"Edges:",
+				"- source -> sink",
+			].join("\n"),
+			ascii: [
+				"Graph duplicate edges",
+				"sink [derived/sentinel] -> -",
+				"source [state/settled] -> sink",
+			].join("\n"),
+			json: '{"edges":[{"from":"source","to":"sink"}],"name":"duplicate edges","nodes":[{"deps":["source"],"factory":"derived","id":"sink","status":"sentinel"},{"deps":[],"factory":"state","id":"source","status":"settled","value":1}]}',
+		});
+	});
+
+	it("smoke-renders edges with missing endpoints without crashing", () => {
+		const snap: DescribeSnapshot = {
+			name: "missing endpoints",
+			nodes: [
+				{ id: "a", factory: "state", status: "settled", deps: [], value: "ready" },
+				{ id: "b", factory: "effect", status: "sentinel", deps: ["ghost"] },
+			],
+			edges: [
+				{ from: "ghost", to: "b" },
+				{ from: "a", to: "missing" },
+			],
+		};
+
+		const outputs = renderSmokeOutputs(snap);
+
+		expect(outputs).toEqual({
+			mermaid: ["flowchart LR", '  n0["a"]', '  n1["b"]'].join("\n"),
+			d2: ["direction: right", 'n0: "a"', 'n1: "b"'].join("\n"),
+			pretty: [
+				"Graph missing endpoints",
+				"Nodes:",
+				'- a (state/settled): "ready"',
+				"- b (effect/sentinel): <SENTINEL>",
+				"Edges:",
+				"- a -> missing",
+				"- ghost -> b",
+			].join("\n"),
+			ascii: [
+				"Graph missing endpoints",
+				"a [state/settled] -> missing",
+				"b [effect/sentinel] -> -",
+			].join("\n"),
+			json: '{"edges":[{"from":"a","to":"missing"},{"from":"ghost","to":"b"}],"name":"missing endpoints","nodes":[{"deps":[],"factory":"state","id":"a","status":"settled","value":"ready"},{"deps":["ghost"],"factory":"effect","id":"b","status":"sentinel"}]}',
+		});
+	});
+
+	it("smoke-renders cyclic-looking back-edge snapshots without recursive traversal", () => {
+		const snap: DescribeSnapshot = {
+			name: "back edge",
+			nodes: [
+				{ id: "tail", factory: "node", status: "settled", deps: ["head"], value: 2 },
+				{ id: "head", factory: "node", status: "settled", deps: ["tail"], value: 1 },
+			],
+			edges: [
+				{ from: "tail", to: "head" },
+				{ from: "head", to: "tail" },
+			],
+		};
+
+		const outputs = renderSmokeOutputs(snap);
+
+		expect(outputs).toEqual({
+			mermaid: ["flowchart LR", '  n0["head"]', '  n1["tail"]', "  n0 --> n1", "  n1 --> n0"].join(
+				"\n",
+			),
+			d2: ["direction: right", 'n0: "head"', 'n1: "tail"', "n0 -> n1", "n1 -> n0"].join("\n"),
+			pretty: [
+				"Graph back edge",
+				"Nodes:",
+				"- head (node/settled): 1",
+				"- tail (node/settled): 2",
+				"Edges:",
+				"- head -> tail",
+				"- tail -> head",
+			].join("\n"),
+			ascii: ["Graph back edge", "head [node/settled] -> tail", "tail [node/settled] -> head"].join(
+				"\n",
+			),
+			json: '{"edges":[{"from":"head","to":"tail"},{"from":"tail","to":"head"}],"name":"back edge","nodes":[{"deps":["tail"],"factory":"node","id":"head","status":"settled","value":1},{"deps":["head"],"factory":"node","id":"tail","status":"settled","value":2}]}',
+		});
+	});
+
+	it("rejects invalid diagram directions", () => {
+		const snap: DescribeSnapshot = { nodes: [], edges: [] };
+		expect(() => describeToMermaid(snap, { direction: "SIDEWAYS" as never })).toThrow(
+			/invalid diagram direction/,
+		);
+	});
+
+	it("encodes Mermaid source and describe snapshots as mermaid.live URLs", () => {
+		expect(mermaidLiveUrl("flowchart LR", { theme: "dark", autoSync: false })).toBe(
+			"https://mermaid.live/edit#base64:eyJjb2RlIjoiZmxvd2NoYXJ0IExSIiwibWVybWFpZCI6eyJ0aGVtZSI6ImRhcmsifSwiYXV0b1N5bmMiOmZhbHNlfQ",
+		);
+
+		const snap: DescribeSnapshot = {
+			nodes: [{ id: "你好", factory: "state", status: "settled", deps: [], value: 1 }],
+			edges: [],
+		};
+		const url = describeToMermaidUrl(snap, { direction: "TD", theme: "forest" });
+		expect(url).toMatch(/^https:\/\/mermaid\.live\/edit#base64:/);
+		expect(url).not.toContain("=");
+	});
+});
diff --git a/packages/ts/src/__tests__/rewire-deferred.test.ts b/packages/ts/src/__tests__/rewire-deferred.test.ts
new file mode 100644
index 00000000..beda0ecc
--- /dev/null
+++ b/packages/ts/src/__tests__/rewire-deferred.test.ts
@@ -0,0 +1,327 @@
+/**
+ * Deferred SELF-rewire — ctx.rewireNext (R-rewire-deferred / D47 / CSP-2.7).
+ *
+ * Focused substrate units for the wave-boundary-deferred dep-set mutation that higher-order
+ * operators (switchMap/mergeMap/...) build on: defer-not-immediate, drain at the committed
+ * boundary, added cached inner pushes [DIRTY,DATA] with the gate NOT re-armed, removed inner
+ * drains + deactivates (onDeactivation = abortInFlight), terminal-drains-queue (D62), no-net-change
+ * no-op, and the immediate in-fn path still throwing (D37). The exhaustive interleavings are the
+ * TLA+ model (~/src/graphrefly/formal/wave_rewire_deferred.tla); the canonical scenario is C-11.
+ */
+
+import { describe, expect, it } from "vitest";
+import type { Ctx, Message, NodeFn } from "../index.js";
+import {
+	batch,
+	depBatch,
+	depCount,
+	depLatest,
+	depTerminal,
+	graph,
+	isTerminalComplete,
+	type Node,
+	node,
+} from "../index.js";
+
+function collect(n: Node) {
+	const msgs: Message[] = [];
+	const unsub = n.subscribe((m) => msgs.push(m));
+	return { msgs, unsub };
+}
+const types = (m: Message[]) => m.map((x) => x[0]);
+const data = (m: Message[]) =>
+	m.filter((x) => x[0] === "DATA").map((x) => (x as ["DATA", unknown])[1]);
+
+/** A leaf-source inner whose activation + deactivation are observable (cancellation visible). */
+function makeInner(seed?: number) {
+	let ictx: Ctx | null = null;
+	let activated = false;
+	let deactivated = false;
+	const n = node<number>([], (ctx) => {
+		ictx = ctx;
+		activated = true;
+		ctx.onDeactivation(() => {
+			deactivated = true;
+		});
+		if (seed !== undefined) ctx.down([["DATA", seed]]);
+	});
+	return {
+		node: n,
+		emit: (v: number) => (ictx as Ctx).down([["DATA", v]]),
+		complete: () => (ictx as Ctx).down([["COMPLETE"]]),
+		isActivated: () => activated,
+		isDeactivated: () => deactivated,
+	};
+}
+
+describe("ctx.rewireNext — defer + drain (R-rewire-deferred / D47)", () => {
+	it("defers subscribeDep to the boundary — NOT applied in place during the fn run", () => {
+		const inner = makeInner(99);
+		const s = node<number>([], null); // no initial → op's fn first-runs on the driven DATA
+		let deferredCorrectly = false;
+		const op: Node<number> = node<number>(
+			[s],
+			function opFn(ctx) {
+				if (depBatch(ctx, 0)) {
+					ctx.rewireNext.subscribeDep(inner.node, opFn);
+					// still inside the fn run: the dep must NOT be wired yet (inner not activated).
+					deferredCorrectly = !inner.isActivated();
+				}
+			},
+			{ completeWhenDepsComplete: false, terminalAsRealInput: true },
+		);
+		collect(op);
+
+		s.down([["DATA", 1]]); // drives op's fn → requests subscribeDep → drains at this call's boundary
+		expect(deferredCorrectly).toBe(true); // mid-fn: inner was NOT yet a live dep
+		expect(inner.isActivated()).toBe(true); // post-boundary: drained → inner wired + activated
+	});
+
+	it("the added cached inner pushes [DIRTY,DATA] and is forwarded; the gate is NOT re-armed", () => {
+		const inner = makeInner(); // no seed — emits on demand
+		const s = node<number>([], null); // no initial
+		let opRuns = 0;
+		const op: Node<number> = node<number>(
+			[s],
+			function opFn(ctx) {
+				opRuns++;
+				for (let i = 1; i < depCount(ctx); i++) {
+					const b = depBatch(ctx, i);
+					if (b) for (const v of b) ctx.down([["DATA", v as number]]);
+				}
+				if (depBatch(ctx, 0)) ctx.rewireNext.subscribeDep(inner.node, opFn);
+			},
+			{ completeWhenDepsComplete: false, terminalAsRealInput: true },
+		);
+		const { msgs } = collect(op);
+		s.down([["DATA", 1]]); // spawn + add inner (SENTINEL inner → START only, no forward yet)
+		msgs.length = 0;
+		opRuns = 0;
+
+		inner.emit(7); // inner DATA → op forwards as a two-phase wave
+		expect(types(msgs)).toEqual(["DIRTY", "DATA"]); // glitch-free, R-dirty-before-data
+		expect(data(msgs)).toEqual([7]);
+
+		// gate NOT re-armed: S alone re-drives op without waiting on the added inner again.
+		opRuns = 0;
+		s.down([["DATA", 2]]); // also spawns a SECOND inner (deferred); the fn still ran on S alone
+		expect(opRuns).toBeGreaterThan(0);
+	});
+
+	it("unsubscribeDep at the boundary drains the inner + fires onDeactivation (abortInFlight)", () => {
+		const inner = makeInner(5);
+		const s = node<number>([], null); // no initial
+		const inners: Node<number>[] = [];
+		const op: Node<number> = node<number>(
+			[s],
+			function opFn(ctx) {
+				const removals: Node<number>[] = [];
+				for (let i = 1; i < depCount(ctx); i++) {
+					const b = depBatch(ctx, i);
+					if (b) for (const v of b) ctx.down([["DATA", v as number]]);
+					if (isTerminalComplete(depTerminal(ctx, i))) removals.push(inners[i - 1]);
+				}
+				if (depBatch(ctx, 0)) {
+					inners.push(inner.node);
+					ctx.rewireNext.subscribeDep(inner.node, opFn);
+				}
+				for (const r of removals) {
+					inners.splice(inners.indexOf(r), 1);
+					ctx.rewireNext.unsubscribeDep(r, opFn);
+				}
+			},
+			{ completeWhenDepsComplete: false, terminalAsRealInput: true },
+		);
+		const { msgs } = collect(op);
+		s.down([["DATA", 1]]); // add inner (seed 5 forwarded on activation)
+		expect(inner.isActivated()).toBe(true);
+		expect(data(msgs)).toContain(5);
+
+		inner.complete(); // inner COMPLETE → op requests unsubscribeDep → drains → inner deactivates
+		expect(inner.isDeactivated()).toBe(true); // input-side teardown observable
+	});
+});
+
+describe("ctx.rewireNext — switch (replaceDeps) + terminal + no-net-change (D47/D62)", () => {
+	it("replaceDeps atomically tears down the superseded inner and wires the new one", () => {
+		const innerA = makeInner(10);
+		const innerB = makeInner(20);
+		const s = node<number>([], null); // no initial
+		let current: Node<number> | null = null;
+		const op: Node<number> = node<number>(
+			[s],
+			function opFn(ctx) {
+				for (let i = 1; i < depCount(ctx); i++) {
+					const b = depBatch(ctx, i);
+					if (b) for (const v of b) ctx.down([["DATA", v as number]]);
+				}
+				const sv = depBatch(ctx, 0);
+				if (sv && sv.length > 0) {
+					current = (sv[sv.length - 1] as number) === 1 ? innerA.node : innerB.node;
+					ctx.rewireNext.replaceDeps([s, current], opFn); // switch: one atomic op
+				}
+			},
+			{ completeWhenDepsComplete: false, terminalAsRealInput: true },
+		);
+		const { msgs } = collect(op);
+
+		s.down([["DATA", 1]]); // → inner = innerA (seed 10 forwarded)
+		expect(data(msgs)).toContain(10);
+		expect(innerA.isActivated()).toBe(true);
+		msgs.length = 0;
+
+		s.down([["DATA", 2]]); // switch → innerB; innerA torn down (cancelled)
+		expect(innerB.isActivated()).toBe(true);
+		expect(innerA.isDeactivated()).toBe(true); // superseded inner's SOURCE torn down, not masked
+		expect(data(msgs)).toContain(20); // only the new inner forwarded
+		msgs.length = 0;
+
+		innerA.emit(999); // the cancelled inner is DRAINED — no stale forward
+		expect(data(msgs)).toEqual([]);
+	});
+
+	it("a terminal OP still drains pending rewireNext subscribeDep, but later inner output is sealed", () => {
+		const inner = makeInner(1);
+		const s = node<number>([], null, { initial: 0 });
+		const op: Node<number> = node<number>(
+			[s],
+			function opFn(ctx) {
+				if (depBatch(ctx, 0)) {
+					ctx.rewireNext.subscribeDep(inner.node, opFn); // queued…
+					ctx.down([["COMPLETE"]]); // …then the OP goes terminal THIS wave
+				}
+			},
+			{ completeWhenDepsComplete: false, terminalAsRealInput: true },
+		);
+		collect(op);
+		s.down([["DATA", 1]]);
+		expect(op.status).toBe("completed");
+		expect(inner.isActivated()).toBe(true); // D62: queued subscribeDep drains after terminal
+		expect(op.deps).toContain(inner.node);
+		inner.emit(2);
+		expect(op.cache).toBeUndefined(); // terminal output guard: no post-terminal DATA escapes
+	});
+
+	it("a terminal OP drains pending unsubscribeDep and deactivates the helper dep", () => {
+		const inner = makeInner(1);
+		const s = node<number>([], null);
+		let added = false;
+		const op: Node<number> = node<number>(
+			[s],
+			function opFn(ctx) {
+				if (!added && depBatch(ctx, 0)) {
+					added = true;
+					ctx.rewireNext.subscribeDep(inner.node, opFn);
+					return;
+				}
+				if (isTerminalComplete(depTerminal(ctx, 0))) {
+					ctx.rewireNext.unsubscribeDep(inner.node, opFn);
+					ctx.down([["COMPLETE"]]);
+				}
+			},
+			{ completeWhenDepsComplete: false, terminalAsRealInput: true },
+		);
+		collect(op);
+		s.down([["DATA", 1]]);
+		expect(inner.isActivated()).toBe(true);
+		s.down([["COMPLETE"]]);
+		expect(op.status).toBe("completed");
+		expect(op.deps).not.toContain(inner.node);
+		expect(inner.isDeactivated()).toBe(true);
+	});
+
+	it("a no-net-change rewireNext is a no-op (no recompute, no drain loop)", () => {
+		const a = node<number>([], null, { initial: 1 });
+		let runs = 0;
+		const op: Node<number> = node<number>([a], function opFn(ctx) {
+			runs++;
+			if (runs < 5) ctx.rewireNext.replaceDeps([a], opFn); // same dep set every run
+			ctx.down([["DATA", depLatest(ctx, 0) as number]]);
+		});
+		collect(op);
+		// activation ran once; the idempotent replaceDeps drains but changes nothing → no fresh
+		// settle wave → no re-run. (A net-changing op re-issued every boundary WOULD loop —
+		// that is a user-level runaway, not asserted here.)
+		expect(runs).toBe(1);
+		expect(op.cache).toBe(1);
+	});
+
+	it("the immediate in-fn path still throws (D37) — rewireNext is the only legal self-rewire", () => {
+		const a = node<number>([], null, { initial: 1 });
+		const x = node<number>([], null, { initial: 9 });
+		const op: Node<number> = node<number>([a], function opFn(ctx) {
+			op.subscribeDep(x, opFn); // IMMEDIATE self-rewire mid-fn → feedback cycle
+			ctx.down([["DATA", depLatest(ctx, 0) as number]]);
+		});
+		expect(() => collect(op)).toThrow(/mid-fn|feedback/);
+	});
+});
+
+describe("ctx.rewireNext — drain robustness (QA: per-thunk isolation)", () => {
+	it("a throwing thunk (error-route hits a throwing sink) does NOT strand a sibling's rewire", () => {
+		// QA fix: _applyRewireNext catches an invalid op and routes [[ERROR,e]] down; if that ERROR
+		// broadcast reaches a throwing external sink, the escape must NOT abandon the rest of the
+		// global drain queue (else a sibling's queued rewire would silently fire at a LATER wave).
+		const sA = node<number>([], null);
+		const sB = node<number>([], null);
+		const innerB = makeInner(7);
+		// opA: its deferred op is invalid (self-dep) → _rewire throws → _applyRewireNext routes ERROR.
+		const opA: Node<number> = node<number>(
+			[sA],
+			function fnA(ctx) {
+				if (depBatch(ctx, 0)) ctx.rewireNext.subscribeDep(opA, fnA); // self-dep → throws at apply
+			},
+			{ completeWhenDepsComplete: false, terminalAsRealInput: true },
+		);
+		// an external sink on opA that THROWS on ERROR → forces the error-route _down to escape apply().
+		opA.subscribe((m) => {
+			if (m[0] === "ERROR") throw new Error("sink boom");
+		});
+		// opB: a perfectly valid deferred subscribeDep, queued AFTER opA's in the same drain.
+		const opB: Node<number> = node<number>(
+			[sB],
+			function fnB(ctx) {
+				if (depBatch(ctx, 0)) ctx.rewireNext.subscribeDep(innerB.node, fnB);
+			},
+			{ completeWhenDepsComplete: false, terminalAsRealInput: true },
+		);
+		collect(opB);
+
+		// one batch → both fns run at commit → both thunks queue → drained together at the boundary.
+		expect(() =>
+			batch(() => {
+				sA.down([["DATA", 1]]); // opA's thunk queued first
+				sB.down([["DATA", 1]]); // opB's thunk queued second
+			}),
+		).toThrow(/sink boom/); // the first escape re-surfaces after the queue drains
+		expect(innerB.isActivated()).toBe(true); // opB's rewire STILL applied despite opA's throw
+	});
+});
+
+describe("ctx.rewireNext — batch boundary (D47 / B24)", () => {
+	it("a rewireNext issued during batch commit drains AFTER the commit", () => {
+		const g = graph();
+		const inner = makeInner(42);
+		const s = g.node([], null); // manual source, no initial (op's fn first-runs on the driven DATA)
+		const op: Node<number> = g.node(
+			[s],
+			function opFn(ctx: Ctx) {
+				for (let i = 1; i < depCount(ctx); i++) {
+					const b = depBatch(ctx, i);
+					if (b) for (const v of b) ctx.down([["DATA", v as number]]);
+				}
+				if (depBatch(ctx, 0)) ctx.rewireNext.subscribeDep(inner.node, opFn as NodeFn);
+			},
+			{ completeWhenDepsComplete: false, terminalAsRealInput: true },
+		);
+		const { msgs } = collect(op);
+
+		batch(() => {
+			s.down([["DATA", 1]]); // deferred to commit; op's fn runs at commit → requests subscribeDep
+			expect(inner.isActivated()).toBe(false); // NOT applied mid-batch (un-committed view)
+		});
+		// after the batch boundary (post-commit): drained → inner wired + its seed forwarded
+		expect(inner.isActivated()).toBe(true);
+		expect(data(msgs)).toContain(42);
+	});
+});
diff --git a/packages/ts/src/__tests__/rewire.test.ts b/packages/ts/src/__tests__/rewire.test.ts
new file mode 100644
index 00000000..9df42476
--- /dev/null
+++ b/packages/ts/src/__tests__/rewire.test.ts
@@ -0,0 +1,280 @@
+/**
+ * Intra-graph runtime rewire — replaceDeps/subscribeDep/unsubscribeDep (R-rewire / D42 / CSP-2.5).
+ *
+ * Focused substrate unit tests: each Q-semantic (push-on-subscribe, gate-preserve,
+ * cache-preserve, drain, reorder, idempotent, zero-deps) + each reject (self / cycle /
+ * terminal-this / non-resubscribable-terminal-dep / mid-fn). The exhaustive mid-wave
+ * interleavings are covered by the TLA+ model (~/src/graphrefly/formal/wave_rewire.tla).
+ */
+
+import { describe, expect, it } from "vitest";
+import type { Ctx, Message } from "../index.js";
+import { Dispatcher, depLatest, type Node, node } from "../index.js";
+
+function collect(n: Node) {
+	const msgs: Message[] = [];
+	const unsub = n.subscribe((m) => msgs.push(m));
+	return { msgs, unsub };
+}
+const num = (ctx: Ctx, i: number): number => depLatest(ctx, i) as number;
+const types = (m: Message[]) => m.map((x) => x[0]);
+
+describe("rewire — Q-semantics (R-rewire / D42)", () => {
+	it("subscribeDep wires a cached dep via push-on-subscribe and recomputes", () => {
+		const a = node<number>([], null, { initial: 1 });
+		const b = node<number>([], null, { initial: 100 });
+		const d = node<number>([a], (ctx) => ctx.down([["DATA", num(ctx, 0)]]));
+		collect(d);
+		expect(d.cache).toBe(1);
+
+		d.subscribeDep(b, (ctx) => ctx.down([["DATA", num(ctx, 0) + num(ctx, 1)]]));
+		expect(d.cache).toBe(101); // 1 + 100 — b's cached DATA pushed on subscribe (R-push-subscribe)
+	});
+
+	it("subscribeDep of a never-emitted (SENTINEL) dep does not re-arm the first-run gate (Q2)", () => {
+		const a = node<number>([], null, { initial: 1 });
+		const b = node<number>([], null); // no initial → SENTINEL, never emits
+		let runs = 0;
+		const d = node<number>([a], (ctx) => {
+			runs++;
+			ctx.down([["DATA", num(ctx, 0) * 10]]);
+		});
+		collect(d);
+		expect(d.cache).toBe(10);
+		runs = 0;
+
+		d.subscribeDep(b, (ctx) => {
+			runs++;
+			const bv = depLatest(ctx, 1); // SENTINEL = undefined — fn guards it
+			ctx.down([["DATA", num(ctx, 0) * 10 + (bv === undefined ? 0 : (bv as number))]]);
+		});
+		expect(runs).toBe(0); // a SENTINEL added dep delivers START only — no recompute
+
+		a.down([["DATA", 2]]); // gate NOT re-armed: a alone re-drives d without waiting for b
+		expect(runs).toBe(1);
+		expect(d.cache).toBe(20); // 2*10 + 0 (b still SENTINEL)
+	});
+
+	it("unsubscribeDep drains the removed dep + preserves cache (Q3/Q7)", () => {
+		const a = node<number>([], null, { initial: 1 });
+		const b = node<number>([], null, { initial: 2 });
+		const sumAB = (ctx: Ctx) => ctx.down([["DATA", num(ctx, 0) + num(ctx, 1)]]);
+		const aOnly = (ctx: Ctx) => ctx.down([["DATA", num(ctx, 0)]]);
+		const d = node<number>([a, b], sumAB);
+		collect(d);
+		expect(d.cache).toBe(3);
+
+		d.unsubscribeDep(b, aOnly);
+		expect(d.cache).toBe(3); // cache preserved — unsubscribeDep of a non-dirty dep does not recompute
+
+		b.down([["DATA", 99]]); // removed dep must NOT drive d (drained)
+		expect(d.cache).toBe(3);
+
+		a.down([["DATA", 5]]); // d recomputes with the swapped (a-only) fn
+		expect(d.cache).toBe(5);
+	});
+
+	it("unsubscribeDep to zero deps → inert fn-no-deps, cache preserved (D42 SD-3)", () => {
+		const a = node<number>([], null, { initial: 7 });
+		let runs = 0;
+		const d = node<number>([a], (ctx) => {
+			runs++;
+			ctx.down([["DATA", num(ctx, 0)]]);
+		});
+		collect(d);
+		expect(d.cache).toBe(7);
+		runs = 0;
+
+		d.unsubscribeDep(a, (ctx) => {
+			runs++;
+			ctx.down([["DATA", -1]]);
+		});
+		expect(d.cache).toBe(7); // preserved
+		expect(runs).toBe(0); // inert — does not fire
+
+		a.down([["DATA", 8]]); // a is no longer a dep
+		expect(d.cache).toBe(7);
+		expect(runs).toBe(0);
+	});
+
+	it("replaceDeps reorders kept deps without losing their state (Option-C, DepRecord-ref dispatch)", () => {
+		const a = node<number>([], null, { initial: 10 });
+		const b = node<number>([], null, { initial: 20 });
+		const f = (ctx: Ctx) => ctx.down([["DATA", num(ctx, 0) * 100 + num(ctx, 1)]]);
+		const d = node<number>([a, b], f);
+		collect(d);
+		expect(d.cache).toBe(1020); // dep0=a=10, dep1=b=20 → 1020
+
+		d.replaceDeps([b, a], f); // reorder; kept-dep state (a=10, b=20) preserved
+		a.down([["DATA", 11]]); // a is now dep1; reroutes correctly
+		expect(d.cache).toBe(2011); // dep0=b=20, dep1=a=11 → 20*100+11
+	});
+
+	it("replaceDeps to the current dep set is idempotent — no spurious recompute", () => {
+		const a = node<number>([], null, { initial: 1 });
+		let runs = 0;
+		const f = (ctx: Ctx) => {
+			runs++;
+			ctx.down([["DATA", num(ctx, 0)]]);
+		};
+		const d = node<number>([a], f);
+		collect(d);
+		expect(d.cache).toBe(1);
+		runs = 0;
+
+		d.replaceDeps([a], f);
+		expect(runs).toBe(0);
+		expect(d.cache).toBe(1);
+	});
+
+	it("subscribeDep returns the new dep index", () => {
+		const a = node<number>([], null, { initial: 1 });
+		const b = node<number>([], null, { initial: 2 });
+		const f = (ctx: Ctx) => ctx.down([["DATA", num(ctx, 0)]]);
+		const d = node<number>([a], f);
+		collect(d);
+		expect(d.subscribeDep(b, f)).toBe(1);
+		expect(d.subscribeDep(b, f)).toBe(1); // already present → still index 1 (fn swap only)
+	});
+});
+
+describe("rewire — rejects (R-rewire / D42)", () => {
+	it("rejects a self-dependency", () => {
+		const a = node<number>([], null, { initial: 1 });
+		const d = node<number>([a], (ctx) => ctx.down([["DATA", num(ctx, 0)]]));
+		collect(d);
+		expect(() => d.replaceDeps([d as Node<unknown>], (ctx) => ctx.down([["DATA", 0]]))).toThrow(
+			/self-dependency/,
+		);
+	});
+
+	it("rejects a cycle", () => {
+		const a = node<number>([], null, { initial: 1 });
+		const d = node<number>([a], (ctx) => ctx.down([["DATA", num(ctx, 0)]]));
+		const e = node<number>([d], (ctx) => ctx.down([["DATA", num(ctx, 0)]]));
+		collect(e); // e depends on d (→ a)
+		// adding e as a dep of d would close d→e→d
+		expect(() => d.subscribeDep(e, (ctx) => ctx.down([["DATA", num(ctx, 0)]]))).toThrow(/cycle/);
+	});
+
+	it("rejects rewire on a terminal node", () => {
+		const a = node<number>([], null, { initial: 1 });
+		const d = node<number>([a], (ctx) => ctx.down([["DATA", num(ctx, 0)]]), {
+			completeWhenDepsComplete: false,
+		});
+		collect(d);
+		d.down([["COMPLETE"]]); // d terminal
+		expect(() => d.replaceDeps([a], (ctx) => ctx.down([["DATA", 0]]))).toThrow(/terminal/);
+	});
+
+	it("rejects adding a non-resubscribable terminal dep", () => {
+		const term = node<number>([], (ctx) => ctx.down([["COMPLETE"]])); // producer → terminal on activation
+		collect(term);
+		expect(term.status).toBe("completed");
+
+		const a = node<number>([], null, { initial: 1 });
+		const d = node<number>([a], (ctx) => ctx.down([["DATA", num(ctx, 0)]]));
+		collect(d);
+		expect(() => d.subscribeDep(term, (ctx) => ctx.down([["DATA", num(ctx, 0)]]))).toThrow(
+			/terminal dep/,
+		);
+	});
+
+	it("rejects mid-fn rewire (a fn mutating its own deps mid-wave = D37 feedback cycle)", () => {
+		const a = node<number>([], null, { initial: 1 });
+		const x = node<number>([], null, { initial: 9 });
+		let dh: Node<number> | undefined;
+		dh = node<number>([a], (ctx) => {
+			dh?.subscribeDep(x, (c) => c.down([["DATA", num(c, 0)]]));
+			ctx.down([["DATA", num(ctx, 0)]]);
+		});
+		expect(() => collect(dh as Node)).toThrow(/mid-fn|feedback/);
+	});
+});
+
+describe("rewire — QA fixes (atomic settle, DIRTY-before-DATA, pause/batch-safe)", () => {
+	it("replaceDeps adding ≥2 cached deps settles ATOMICALLY — fn fires once, never on a partial view (P2)", () => {
+		const a = node<number>([], null, { initial: 1 });
+		const b = node<number>([], null, { initial: 10 });
+		const c = node<number>([], null, { initial: 100 });
+		let runs = 0;
+		const sawPartial: boolean[] = [];
+		const d = node<number>([a], (ctx) => ctx.down([["DATA", num(ctx, 0)]]));
+		collect(d);
+		runs = 0;
+
+		const sum3 = (ctx: Ctx) => {
+			runs++;
+			// a SENTINEL added dep at invocation = the fn fired on a partial view (the bug)
+			sawPartial.push(depLatest(ctx, 1) === undefined || depLatest(ctx, 2) === undefined);
+			ctx.down([["DATA", num(ctx, 0) + num(ctx, 1) + num(ctx, 2)]]);
+		};
+		d.replaceDeps([a, b, c], sum3); // add b AND c (both cached) in one rewire
+		expect(runs).toBe(1); // ONE atomic settle, not one fire per added dep
+		expect(sawPartial).toEqual([false]); // never fired with an added dep still SENTINEL
+		expect(d.cache).toBe(111); // 1 + 10 + 100
+	});
+
+	it("a rewire-triggered settle emits DIRTY before DATA downstream (D1 / R-dirty-before-data)", () => {
+		const a = node<number>([], null, { initial: 1 });
+		const b = node<number>([], null, { initial: 100 });
+		const d = node<number>([a], (ctx) => ctx.down([["DATA", num(ctx, 0)]]));
+		const { msgs } = collect(d);
+		msgs.length = 0; // isolate the rewire wave
+
+		d.subscribeDep(b, (ctx) => ctx.down([["DATA", num(ctx, 0) + num(ctx, 1)]]));
+		expect(types(msgs)).toEqual(["DIRTY", "DATA"]); // two-phase, glitch-free
+		expect(msgs.at(-1)).toEqual(["DATA", 101]);
+	});
+
+	it("unsubscribeDep of the sole dirty dep to zero deps un-dirties downstream via RESOLVED (Q6 / P1)", () => {
+		let cctx: Ctx | null = null;
+		const a = node<number>([], null, { initial: 1 });
+		const c = node<number>(
+			[a],
+			(ctx: Ctx) => {
+				cctx = ctx; // async leg: defer the emit
+			},
+			{ pool: "async" },
+		);
+		const d = node<number>([c], (ctx) => ctx.down([["DATA", num(ctx, 0)]]));
+		const { msgs } = collect(d);
+		(cctx as Ctx).down([["DATA", 5]]); // c settles once → d caches 5
+		expect(d.cache).toBe(5);
+
+		msgs.length = 0;
+		a.down([["DATA", 2]]); // a→c DIRTY/DATA; c (async) defers → c emits DIRTY to d → d dirty
+		expect(d.status).toBe("dirty");
+		expect(types(msgs)).toContain("DIRTY");
+
+		msgs.length = 0;
+		d.unsubscribeDep(c, (ctx) => ctx.down([["DATA", num(ctx, 0)]])); // remove sole dirty dep → zero deps
+		expect(types(msgs)).toEqual(["RESOLVED"]); // un-dirtied downstream (not a stray DATA)
+		expect(d.cache).toBe(5); // cache preserved (Q7), no recompute
+	});
+
+	it("B15: a rewire fn-swap frees the old dispatcher handle (registry stays bounded)", () => {
+		// Each replaceDeps/subscribeDep/unsubscribeDep re-registers the fn → a new handle. Before B15 the old
+		// handle leaked (the pool fn-table grew by one per swap), unbounded for a rewire-heavy
+		// graph (CSP-2.7 *Map). Now _rewire unregisters the old handle, so the table is bounded
+		// to peak-live size and freed ids are reused. Observed via a probe registration on a
+		// dedicated dispatcher: after N swaps a fresh register reuses a freed slot (small id),
+		// not ~N (the leak). Mutation-verified: disabling the unregister in _rewire fails this.
+		const disp = new Dispatcher();
+		const a = node<number>([], null, { initial: 1, dispatcher: disp });
+		const id = (ctx: Ctx) => ctx.down([["DATA", num(ctx, 0)]]);
+		const d = node<number>([a], id, { dispatcher: disp });
+		collect(d);
+
+		const N = 50;
+		for (let i = 0; i < N; i++) {
+			// idempotent dep-set, but SD-1 still swaps the fn each call → register + free old.
+			d.replaceDeps([a], (ctx) => ctx.down([["DATA", num(ctx, 0)]]));
+		}
+		expect(d.cache).toBe(1); // still correct after 50 swaps
+
+		// A fresh registration reuses a freed slot → bounded handleId, NOT ~N (the leak).
+		const probe = disp.register(() => {}, "sync");
+		expect(probe.handleId).toBeLessThanOrEqual(2);
+	});
+});
diff --git a/packages/ts/src/__tests__/scheduled-readiness.test.ts b/packages/ts/src/__tests__/scheduled-readiness.test.ts
new file mode 100644
index 00000000..67491afc
--- /dev/null
+++ b/packages/ts/src/__tests__/scheduled-readiness.test.ts
@@ -0,0 +1,328 @@
+import { describe, expect, it } from "vitest";
+import type { DataIssue } from "../data/index.js";
+import { graph } from "../graph/graph.js";
+import type {
+	ScheduledReadinessClock,
+	ScheduledReadinessOverdue,
+	ScheduledReadinessPending,
+	ScheduledReadinessReady,
+	ScheduledReadinessRequested,
+	ScheduledReadinessStatus,
+	ScheduledReadinessViews,
+} from "../orchestration/index.js";
+import { scheduledReadinessProjector } from "../orchestration/index.js";
+
+describe("scheduledReadinessProjector (D424)", () => {
+	it("keeps a schedule pending until an explicit clock reaches readyAtMs", () => {
+		const harness = createHarness();
+		const schedule = readiness("sched-pending", 1_000);
+
+		harness.schedules.down([["DATA", schedule]]);
+		expect(harness.seen.pending).toEqual([
+			expect.objectContaining({ scheduleId: "sched-pending", readyAtMs: 1_000 }),
+		]);
+		expect(harness.seen.ready).toEqual([]);
+
+		harness.clocks.down([["DATA", clock(999)]]);
+		expect(harness.seen.ready).toEqual([]);
+		harness.clocks.down([["DATA", clock(999.5)]]);
+		expect(harness.seen.ready).toEqual([]);
+		expect(
+			harness.seen.status.filter(
+				(status) => status.scheduleId === "sched-pending" && status.state === "pending",
+			),
+		).toHaveLength(3);
+		expect(
+			harness.seen.status
+				.filter((status) => status.scheduleId === "sched-pending" && status.state === "pending")
+				.map((status) => status.nowMs),
+		).toEqual([undefined, 999, 999.5]);
+		expect(harness.seen.status).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({ scheduleId: "sched-pending", state: "pending" }),
+			]),
+		);
+		expect(harness.seen.views.at(-1)?.statusById.get("sched-pending")).toEqual(
+			expect.objectContaining({ scheduleId: "sched-pending", state: "pending", nowMs: 999.5 }),
+		);
+
+		harness.clocks.down([["DATA", clock(1_000)]]);
+		expect(harness.seen.ready).toEqual([
+			expect.objectContaining({ scheduleId: "sched-pending", readyAtMs: 1_000, nowMs: 1_000 }),
+		]);
+	});
+
+	it("emits ready once when schedules or clocks replay", () => {
+		const harness = createHarness();
+		const schedule = readiness("sched-replay", 10);
+
+		harness.schedules.down([["DATA", schedule]]);
+		harness.clocks.down([["DATA", clock(10)]]);
+		harness.schedules.down([["DATA", schedule]]);
+		harness.clocks.down([["DATA", clock(10)]]);
+
+		expect(harness.seen.ready).toHaveLength(1);
+		expect(harness.seen.status.filter((status) => status.state === "ready")).toHaveLength(1);
+		expect(
+			harness.seen.audit.filter((audit) => audit.kind === "scheduled-readiness-ready"),
+		).toHaveLength(1);
+	});
+
+	it("handles clock before schedule and schedule before clock", () => {
+		const first = createHarness();
+		first.clocks.down([["DATA", clock(100)]]);
+		first.schedules.down([["DATA", readiness("clock-first", 100)]]);
+		expect(first.seen.ready).toEqual([expect.objectContaining({ scheduleId: "clock-first" })]);
+
+		const second = createHarness();
+		second.schedules.down([["DATA", readiness("schedule-first", 100)]]);
+		second.clocks.down([["DATA", clock(100)]]);
+		expect(second.seen.ready).toEqual([expect.objectContaining({ scheduleId: "schedule-first" })]);
+	});
+
+	it("does not un-ready or duplicate ready after clock rollback", () => {
+		const harness = createHarness();
+		harness.schedules.down([["DATA", readiness("rollback", 100)]]);
+		harness.clocks.down([["DATA", clock(100)]]);
+		harness.clocks.down([["DATA", clock(90, "clock-rollback")]]);
+		harness.clocks.down([["DATA", clock(110)]]);
+
+		expect(harness.seen.ready).toHaveLength(1);
+		expect(harness.seen.issues).toEqual([
+			expect.objectContaining({ code: "scheduled-readiness-clock-rollback" }),
+		]);
+		expect(harness.seen.views.at(-1)?.readyById.has("rollback")).toBe(true);
+	});
+
+	it("emits visible issue/status for malformed schedules and no ready fact", () => {
+		const harness = createHarness();
+		harness.schedules.down([
+			[
+				"DATA",
+				{
+					kind: "scheduled-readiness-requested",
+					scheduleId: "bad-schedule",
+					sourceRefs: [{ kind: "source", id: "bad" }],
+				} as ScheduledReadinessRequested,
+			],
+		]);
+		harness.clocks.down([["DATA", clock(100)]]);
+
+		expect(harness.seen.ready).toEqual([]);
+		expect(harness.seen.issues).toEqual([
+			expect.objectContaining({ code: "scheduled-readiness-malformed-schedule" }),
+		]);
+		expect(harness.seen.status).toEqual([
+			expect.objectContaining({ scheduleId: "bad-schedule", state: "issue" }),
+		]);
+	});
+
+	it("emits visible issues for non-object schedule and clock facts", () => {
+		const harness = createHarness();
+		harness.schedules.down([["DATA", null as unknown as ScheduledReadinessRequested]]);
+		harness.clocks.down([["DATA", null as unknown as ScheduledReadinessClock]]);
+
+		expect(harness.seen.issues).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({ code: "scheduled-readiness-malformed-schedule" }),
+				expect.objectContaining({ code: "scheduled-readiness-malformed-clock" }),
+			]),
+		);
+		expect(harness.seen.status).toEqual([
+			expect.objectContaining({ scheduleId: "unknown-scheduled-readiness", state: "issue" }),
+		]);
+	});
+
+	it("fails closed for non-object malformed schedule and clock facts", () => {
+		const harness = createHarness();
+
+		harness.schedules.down([["DATA", null as unknown as ScheduledReadinessRequested]]);
+		harness.clocks.down([["DATA", null as unknown as ScheduledReadinessClock]]);
+
+		expect(harness.seen.ready).toEqual([]);
+		expect(harness.seen.issues).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({ code: "scheduled-readiness-malformed-schedule" }),
+				expect.objectContaining({ code: "scheduled-readiness-malformed-clock" }),
+			]),
+		);
+	});
+
+	it("fails closed for malformed schedule and clock ref fields", () => {
+		const harness = createHarness();
+
+		harness.schedules.down([
+			[
+				"DATA",
+				{
+					...readiness("bad-refs", 10),
+					sourceRefs: { kind: "not-array", id: "bad" },
+				} as unknown as ScheduledReadinessRequested,
+			],
+		]);
+		harness.clocks.down([
+			[
+				"DATA",
+				{
+					...clock(10),
+					sourceRefs: { kind: "not-array", id: "bad-clock" },
+				} as unknown as ScheduledReadinessClock,
+			],
+		]);
+
+		expect(harness.seen.ready).toEqual([]);
+		expect(harness.seen.issues).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({ code: "scheduled-readiness-malformed-schedule" }),
+				expect.objectContaining({ code: "scheduled-readiness-malformed-clock" }),
+			]),
+		);
+	});
+
+	it("rejects stale subjectRef and notBeforeMs aliases", () => {
+		const harness = createHarness();
+
+		harness.schedules.down([
+			[
+				"DATA",
+				{
+					kind: "scheduled-readiness-requested",
+					scheduleId: "stale-aliases",
+					subjectRef: { kind: "subject", id: "stale-aliases" },
+					notBeforeMs: 10,
+				} as unknown as ScheduledReadinessRequested,
+			],
+		]);
+		harness.clocks.down([["DATA", clock(10)]]);
+
+		expect(harness.seen.ready).toEqual([]);
+		expect(harness.seen.issues).toEqual([
+			expect.objectContaining({ code: "scheduled-readiness-malformed-schedule" }),
+		]);
+	});
+
+	it("keeps the first valid schedule when a scheduleId replays with conflicting material", () => {
+		const harness = createHarness();
+		harness.schedules.down([["DATA", readiness("conflict", 10)]]);
+		harness.clocks.down([["DATA", clock(10)]]);
+
+		harness.schedules.down([["DATA", readiness("conflict", 20)]]);
+
+		expect(harness.seen.ready).toHaveLength(1);
+		expect(harness.seen.ready[0]).toEqual(
+			expect.objectContaining({ scheduleId: "conflict", readyAtMs: 10 }),
+		);
+		expect(harness.seen.issues).toEqual([
+			expect.objectContaining({ code: "scheduled-readiness-schedule-conflict" }),
+		]);
+		expect(harness.seen.status).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({
+					scheduleId: "conflict",
+					state: "issue",
+					issueCodes: ["scheduled-readiness-schedule-conflict"],
+				}),
+			]),
+		);
+		expect(harness.seen.views.at(-1)?.readyById.get("conflict")).toEqual(
+			expect.objectContaining({ readyAtMs: 10 }),
+		);
+	});
+
+	it("emits overdue without executing, claiming, admitting, or requesting work", () => {
+		const harness = createHarness();
+		harness.schedules.down([
+			["DATA", { ...readiness("overdue", 100), deadlineMs: 90, reason: "retry-backoff" }],
+		]);
+		harness.clocks.down([["DATA", clock(100)]]);
+
+		expect(harness.seen.ready).toHaveLength(1);
+		expect(harness.seen.overdue).toEqual([
+			expect.objectContaining({ scheduleId: "overdue", deadlineMs: 90, nowMs: 100 }),
+		]);
+		const serialized = JSON.stringify({
+			pending: harness.seen.pending,
+			ready: harness.seen.ready,
+			overdue: harness.seen.overdue,
+			status: harness.seen.status,
+		});
+		expect(serialized).not.toContain("tool-provider-adapter-run-requested");
+		expect(serialized).not.toContain("claim");
+		expect(serialized).not.toContain("admission");
+	});
+
+	it("bounds public metadata and source refs", () => {
+		const harness = createHarness();
+		const raw = "x".repeat(10_000);
+		harness.schedules.down([
+			[
+				"DATA",
+				{
+					...readiness("redaction", 1),
+					sourceRefs: [{ kind: "source", id: "redaction", metadata: { apiKey: "SECRET" } }],
+					metadata: { rawResponseBody: raw, small: "ok" },
+				},
+			],
+		]);
+		harness.clocks.down([["DATA", clock(1)]]);
+
+		const serialized = JSON.stringify(harness.seen.ready[0]);
+		expect(serialized).not.toContain("SECRET");
+		expect(serialized).not.toContain(raw);
+		expect(serialized.length).toBeLessThan(2_000);
+		expect(harness.seen.ready[0]?.metadata).toEqual({ small: "ok" });
+	});
+});
+
+function createHarness() {
+	const g = graph();
+	const schedules = g.node<ScheduledReadinessRequested>([], null, {
+		name: "scheduled-readiness-schedules",
+	});
+	const clocks = g.node<ScheduledReadinessClock>([], null, {
+		name: "scheduled-readiness-clocks",
+	});
+	const bundle = scheduledReadinessProjector(g, { schedules: [schedules], clocks: [clocks] });
+	return {
+		schedules,
+		clocks,
+		seen: {
+			pending: collectData<ScheduledReadinessPending>(bundle.pending),
+			ready: collectData<ScheduledReadinessReady>(bundle.ready),
+			overdue: collectData<ScheduledReadinessOverdue>(bundle.overdue),
+			status: collectData<ScheduledReadinessStatus>(bundle.status),
+			issues: collectData<DataIssue>(bundle.issues),
+			audit: collectData<{ readonly kind: string }>(bundle.audit),
+			views: collectData<ScheduledReadinessViews>(bundle.views),
+		},
+	};
+}
+
+function readiness(scheduleId: string, readyAtMs: number): ScheduledReadinessRequested {
+	return {
+		kind: "scheduled-readiness-requested",
+		scheduleId,
+		subjectRefs: [{ kind: "subject", id: scheduleId }],
+		readyAtMs,
+		sourceRefs: [{ kind: "test", id: scheduleId }],
+	};
+}
+
+function clock(nowMs: number, clockId = "test-clock"): ScheduledReadinessClock {
+	return {
+		kind: "scheduled-readiness-clock",
+		clockId,
+		nowMs,
+		sourceRefs: [{ kind: "clock", id: clockId }],
+	};
+}
+
+function collectData<T>(node: {
+	subscribe(sink: (msg: readonly [string, unknown?]) => void): unknown;
+}): T[] {
+	const out: T[] = [];
+	node.subscribe((msg) => {
+		if (msg[0] === "DATA") out.push(msg[1] as T);
+	});
+	return out;
+}
diff --git a/packages/ts/src/__tests__/solutions-agentic-memory.part-01.test.ts b/packages/ts/src/__tests__/solutions-agentic-memory.part-01.test.ts
new file mode 100644
index 00000000..9c724c0b
--- /dev/null
+++ b/packages/ts/src/__tests__/solutions-agentic-memory.part-01.test.ts
@@ -0,0 +1,793 @@
+import { describe, expect, expectTypeOf, it } from "vitest";
+import { graph } from "../graph/graph.js";
+import type {
+	MemoryFragment,
+	MemoryRetrievalError,
+	MemoryRetrievalStatus,
+} from "../patterns/index.js";
+import type { Message } from "../protocol/messages.js";
+import {
+	type AgenticMemoryBundle,
+	type AgenticMemoryConsolidationRequest,
+	type AgenticMemoryContext,
+	type AgenticMemoryError,
+	type AgenticMemoryKgAssertionDraft,
+	type AgenticMemoryKgProjectionError,
+	type AgenticMemoryKgProjectionStatus,
+	type AgenticMemoryRecord,
+	type AgenticMemoryRecordFrame,
+	type AgenticMemoryRetentionCommand,
+	type AgenticMemoryRetentionError,
+	type AgenticMemoryRetentionStatus,
+	type AgenticMemorySourceProjection,
+	type AgenticMemoryStatus,
+	agenticMemoryBundle,
+	agenticMemoryKgProjectionBundle,
+	agenticMemoryRecordCodec,
+	agenticMemoryRecordFrame,
+	agenticMemoryRecordFrameCodec,
+	agenticMemoryRetentionBundle,
+} from "../solutions/index.js";
+
+const fragment = <T = string>(patch: Partial<MemoryFragment<T>> = {}): MemoryFragment<T> => ({
+	id: "fact-1",
+	payload: "payload" as T,
+	tNs: 10n,
+	confidence: 0.8,
+	tags: ["project", "policy"],
+	sources: [],
+	...patch,
+});
+
+const record = <T = string>(
+	patch: Partial<AgenticMemoryRecord<T>> = {},
+): AgenticMemoryRecord<T> => ({
+	id: "record-1",
+	kind: "semantic",
+	persistenceLevel: "project",
+	artifactKind: "insight",
+	scope: { sessionId: "session-1", projectId: "project-1" },
+	fragment: fragment<T>(),
+	...patch,
+});
+
+const data = <T>(messages: Message[]): T[] =>
+	messages.filter((m) => m[0] === "DATA").map((m) => (m as readonly ["DATA", T])[1]);
+
+function collect(node: { subscribe(sink: (messages: Message) => void): () => void }) {
+	const messages: Message[] = [];
+	const unsubscribe = node.subscribe((message) => messages.push(message));
+	return { messages, unsubscribe };
+}
+
+describe("agenticMemoryBundle solution (D164)", () => {
+	it("exposes static records -> projection -> retrieval -> context topology", () => {
+		const g = graph();
+		const records = g.state<readonly AgenticMemoryRecord<string>[]>([], { name: "records" });
+		const query = g.state({ tags: ["policy"] }, { name: "query" });
+		const bundle = agenticMemoryBundle<string>(g, { name: "memory", records, query });
+
+		expectTypeOf(bundle).toMatchTypeOf<AgenticMemoryBundle<string>>();
+		expect(bundle.input.records).toBe(records);
+		expect(bundle.input.query).toBe(query);
+		expect(bundle.retrieval.snapshot).toBe(bundle.retrievalSnapshot);
+		expect(bundle.retrieval.errors).toBe(bundle.retrievalErrors);
+
+		expect(g.describe().edges).toEqual(
+			expect.arrayContaining([
+				{ from: "records", to: "memory/projection" },
+				{ from: "memory/projection", to: "memory/records" },
+				{ from: "memory/projection", to: "memory/fragments" },
+				{ from: "memory/projection", to: "memory/status" },
+				{ from: "memory/projection", to: "memory/errors" },
+				{ from: "memory/projection", to: "memory/sources" },
+				{ from: "memory/fragments", to: "memory/retrieval/snapshot" },
+				{ from: "query", to: "memory/retrieval/snapshot" },
+				{ from: "memory/retrieval/snapshot", to: "memory/retrieval/fragments" },
+				{ from: "memory/retrieval/snapshot", to: "memory/retrieval/indexed" },
+				{ from: "memory/retrieval/snapshot", to: "memory/retrieval/ranked" },
+				{ from: "memory/retrieval/snapshot", to: "memory/retrieval/status" },
+				{ from: "memory/retrieval/snapshot", to: "memory/retrieval/errors" },
+				{ from: "memory/retrieval/snapshot", to: "memory/retrieval/cursor" },
+				{ from: "memory/projection", to: "memory/context" },
+				{ from: "memory/retrieval/snapshot", to: "memory/context" },
+			]),
+		);
+		expect(g.describe().nodes).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({
+					id: "memory/projection",
+					factory: "agenticMemoryProjection",
+				}),
+				expect.objectContaining({ id: "memory/fragments", factory: "agenticMemoryFragments" }),
+				expect.objectContaining({
+					id: "memory/retrieval/snapshot",
+					factory: "memoryRetrievalSnapshot",
+				}),
+				expect.objectContaining({ id: "memory/context", factory: "agenticMemoryContext" }),
+			]),
+		);
+	});
+
+	it("validates records, projects valid fragments, and includes record metadata in context", () => {
+		const g = graph();
+		const records = g.state<readonly AgenticMemoryRecord<string>[]>(
+			[
+				record({
+					id: "record-far",
+					kind: "episodic",
+					persistenceLevel: "session",
+					artifactKind: "raw",
+					scope: { sessionId: "session-1", tenantId: "tenant-1" },
+					fragment: fragment({
+						id: "far",
+						payload: "distant",
+						confidence: 0.95,
+						embedding: [0, 1],
+						tags: ["policy"],
+						sources: ["seed"],
+						provenance: "fixture",
+					}),
+				}),
+				record({
+					id: "record-near",
+					kind: "procedural",
+					persistenceLevel: "longTerm",
+					artifactKind: "procedure",
+					scope: { projectId: "project-1", userId: "user-1" },
+					fragment: fragment({
+						id: "near",
+						payload: "close",
+						confidence: 0.6,
+						embedding: [1, 0],
+						tags: ["policy"],
+						sources: ["seed", "note"],
+						parentFragmentId: "seed",
+					}),
+				}),
+			],
+			{ name: "records" },
+		);
+		const query = g.state({ tags: ["policy"], vector: [1, 0], limit: 2 }, { name: "query" });
+		const bundle = agenticMemoryBundle<string>(g, { name: "memory", records, query });
+		const projected = collect(bundle.fragments);
+		const context = collect(bundle.context);
+		const sources = collect(bundle.sources);
+		const status = collect(bundle.status);
+		context.messages.length = 0;
+
+		query.set({ tags: ["policy"], vector: [1, 0], limit: 2 });
+
+		expect(
+			data<readonly MemoryFragment<string>[]>(projected.messages)
+				.at(-1)
+				?.map((item) => item.id),
+		).toEqual(["far", "near"]);
+		expect(data<AgenticMemoryStatus>(status.messages).at(-1)).toMatchObject({
+			state: "ready",
+			cursor: { validRecords: 2, invalidRecords: 0, projectedFragments: 2 },
+		});
+		expect(
+			data<AgenticMemoryContext<string>>(context.messages)
+				.at(-1)
+				?.entries.map((entry) => ({
+					fragmentId: entry.fragmentId,
+					recordId: entry.record?.recordId,
+					kind: entry.record?.kind,
+					persistenceLevel: entry.record?.persistenceLevel,
+					artifactKind: entry.record?.artifactKind,
+					scope: entry.record?.scope,
+				})),
+		).toEqual([
+			{
+				fragmentId: "near",
+				recordId: "record-near",
+				kind: "procedural",
+				persistenceLevel: "longTerm",
+				artifactKind: "procedure",
+				scope: { projectId: "project-1", userId: "user-1" },
+			},
+			{
+				fragmentId: "far",
+				recordId: "record-far",
+				kind: "episodic",
+				persistenceLevel: "session",
+				artifactKind: "raw",
+				scope: { sessionId: "session-1", tenantId: "tenant-1" },
+			},
+		]);
+		expect(data<AgenticMemorySourceProjection[]>(sources.messages).at(-1)).toEqual([
+			{
+				fragmentId: "far",
+				record: {
+					recordId: "record-far",
+					kind: "episodic",
+					persistenceLevel: "session",
+					artifactKind: "raw",
+					scope: { sessionId: "session-1", tenantId: "tenant-1" },
+				},
+				sources: ["seed"],
+				provenance: "fixture",
+			},
+			{
+				fragmentId: "near",
+				record: {
+					recordId: "record-near",
+					kind: "procedural",
+					persistenceLevel: "longTerm",
+					artifactKind: "procedure",
+					scope: { projectId: "project-1", userId: "user-1" },
+				},
+				sources: ["seed", "note"],
+				parentFragmentId: "seed",
+			},
+		]);
+		expect(data<AgenticMemoryContext<string>>(context.messages).at(-1)).toMatchObject({
+			state: "ready",
+			contextReady: true,
+			errors: [],
+			retrievalErrors: [],
+		});
+	});
+
+	it("emits invalid enum, scope, and fragment records as solution-level DATA errors", () => {
+		const g = graph();
+		const records = g.state<readonly AgenticMemoryRecord<string>[]>([], { name: "records" });
+		const query = g.state({}, { name: "query" });
+		const bundle = agenticMemoryBundle<string>(g, { name: "memory", records, query });
+		const errors = collect(bundle.errors);
+		const status = collect(bundle.status);
+		const context = collect(bundle.context);
+		errors.messages.length = 0;
+		status.messages.length = 0;
+		context.messages.length = 0;
+
+		records.set([
+			{
+				id: "bad-record",
+				kind: "archive",
+				persistenceLevel: "cold",
+				artifactKind: "summary",
+				scope: { sessionId: "", storageKey: "nope" },
+				fragment: { id: "", tNs: 1, confidence: Number.NaN, tags: [], sources: [] },
+				scheduler: "nope",
+			} as never,
+		]);
+
+		expect(errors.messages.map((message) => message[0])).toEqual(["DIRTY", "DATA"]);
+		expect(
+			data<readonly AgenticMemoryError[]>(errors.messages)
+				.at(-1)
+				?.map((error) => error.code),
+		).toEqual([
+			"invalid-record-kind",
+			"invalid-persistence-level",
+			"invalid-artifact-kind",
+			"invalid-scope",
+			"invalid-fragment",
+			"invalid-record",
+		]);
+		expect(data<AgenticMemoryStatus>(status.messages).at(-1)).toMatchObject({
+			state: "error",
+			cursor: { validRecords: 0, invalidRecords: 1, projectedFragments: 0 },
+		});
+		expect(data<AgenticMemoryContext<string>>(context.messages).at(-1)).toMatchObject({
+			state: "error",
+			contextReady: false,
+			entries: [],
+		});
+		expect(status.messages.some((message) => message[0] === "ERROR")).toBe(false);
+	});
+
+	it("does not let invalid records reserve ids and reports duplicate valid record ids", () => {
+		const g = graph();
+		const records = g.state<readonly AgenticMemoryRecord<string>[]>([], { name: "records" });
+		const query = g.state({}, { name: "query" });
+		const bundle = agenticMemoryBundle<string>(g, { name: "memory", records, query });
+		const errors = collect(bundle.errors);
+		const projected = collect(bundle.fragments);
+		const context = collect(bundle.context);
+		errors.messages.length = 0;
+		projected.messages.length = 0;
+		context.messages.length = 0;
+
+		records.set([
+			record({ id: "dup", kind: "archive" as never }),
+			record({ id: "dup", fragment: fragment({ id: "kept", payload: "kept" }) }),
+			record({ id: "dup", fragment: fragment({ id: "dropped", payload: "dropped" }) }),
+		]);
+
+		expect(
+			data<readonly AgenticMemoryError[]>(errors.messages)
+				.at(-1)
+				?.map((error) => error.code),
+		).toEqual(["invalid-record-kind", "duplicate-record-id"]);
+		expect(data<readonly AgenticMemoryError[]>(errors.messages).at(-1)?.[1]).toMatchObject({
+			code: "duplicate-record-id",
+			index: 2,
+			recordId: "dup",
+		});
+		expect(
+			data<readonly MemoryFragment<string>[]>(projected.messages)
+				.at(-1)
+				?.map((item) => item.id),
+		).toEqual(["kept"]);
+		expect(
+			data<AgenticMemoryContext<string>>(context.messages)
+				.at(-1)
+				?.entries.map((entry) => [entry.fragmentId, entry.payload, entry.record?.recordId]),
+		).toEqual([["kept", "kept", "dup"]]);
+	});
+
+	it("rejects duplicate projected fragment ids before source metadata can drift", () => {
+		const g = graph();
+		const records = g.state<readonly AgenticMemoryRecord<string>[]>([], { name: "records" });
+		const query = g.state({}, { name: "query" });
+		const bundle = agenticMemoryBundle<string>(g, { name: "memory", records, query });
+		const errors = collect(bundle.errors);
+		const projected = collect(bundle.fragments);
+		const sources = collect(bundle.sources);
+		errors.messages.length = 0;
+		projected.messages.length = 0;
+		sources.messages.length = 0;
+
+		records.set([
+			record({ id: "record-a", fragment: fragment({ id: "same", payload: "a" }) }),
+			record({ id: "record-b", fragment: fragment({ id: "same", payload: "b" }) }),
+		]);
+
+		expect(data<readonly AgenticMemoryError[]>(errors.messages).at(-1)?.[0]).toMatchObject({
+			code: "duplicate-fragment-id",
+			index: 1,
+			recordId: "record-b",
+			fragmentId: "same",
+		});
+		expect(
+			data<readonly MemoryFragment<string>[]>(projected.messages)
+				.at(-1)
+				?.map((item) => [item.id, item.payload]),
+		).toEqual([["same", "a"]]);
+		expect(data<AgenticMemorySourceProjection[]>(sources.messages).at(-1)).toMatchObject([
+			{ fragmentId: "same", record: { recordId: "record-a" } },
+		]);
+	});
+
+	it("turns throwing record access into solution-level DATA errors", () => {
+		const g = graph();
+		const badRecord = {
+			get id() {
+				throw new Error("id exploded");
+			},
+		};
+		const records = g.state<readonly AgenticMemoryRecord<string>[]>([badRecord as never], {
+			name: "records",
+		});
+		const query = g.state({}, { name: "query" });
+		const bundle = agenticMemoryBundle<string>(g, { name: "memory", records, query });
+		const errors = collect(bundle.errors);
+		const status = collect(bundle.status);
+
+		expect(data<readonly AgenticMemoryError[]>(errors.messages).at(-1)?.[0]).toMatchObject({
+			code: "invalid-record",
+			index: 0,
+			validationErrors: ["record access failed"],
+		});
+		expect(data<AgenticMemoryStatus>(status.messages).at(-1)).toMatchObject({
+			state: "error",
+			cursor: { validRecords: 0, invalidRecords: 1, projectedFragments: 0 },
+		});
+		expect(status.messages.some((message) => message[0] === "ERROR")).toBe(false);
+	});
+
+	it("forwards invalid query vectors to the lower retrieval error surface", () => {
+		const g = graph();
+		const records = g.state<readonly AgenticMemoryRecord<string>[]>(
+			[record({ id: "record-ok", fragment: fragment({ id: "ok", embedding: [1, 0] }) })],
+			{ name: "records" },
+		);
+		const query = g.state({}, { name: "query" });
+		const bundle = agenticMemoryBundle<string>(g, { name: "memory", records, query });
+		const solutionErrors = collect(bundle.errors);
+		const retrievalErrors = collect(bundle.retrievalErrors);
+		const retrievalStatus = collect(bundle.retrievalStatus);
+		const context = collect(bundle.context);
+		retrievalErrors.messages.length = 0;
+		retrievalStatus.messages.length = 0;
+		context.messages.length = 0;
+
+		query.set({ vector: [1, Number.NaN] });
+
+		expect(data<readonly AgenticMemoryError[]>(solutionErrors.messages).at(-1)).toEqual([]);
+		expect(
+			data<readonly MemoryRetrievalError[]>(retrievalErrors.messages).at(-1)?.[0],
+		).toMatchObject({ code: "invalid-query-vector" });
+		expect(data<MemoryRetrievalStatus>(retrievalStatus.messages).at(-1)).toMatchObject({
+			state: "error",
+			cursor: { validFragments: 1, invalidFragments: 0, resultCount: 0 },
+		});
+		expect(data<AgenticMemoryContext<string>>(context.messages).at(-1)).toMatchObject({
+			state: "error",
+			contextReady: false,
+			entries: [],
+			errors: [],
+			retrievalErrors: [expect.objectContaining({ code: "invalid-query-vector" })],
+		});
+	});
+});
+
+describe("agentic memory KG projection (D165)", () => {
+	it("projects valid KG assertions with record metadata and visible topology", () => {
+		const g = graph();
+		const records = g.state<readonly AgenticMemoryRecord<string>[]>(
+			[
+				record({
+					id: "record-kg",
+					kind: "semantic",
+					persistenceLevel: "longTerm",
+					fragment: fragment({
+						id: "fragment-kg",
+						payload: "Ada works on GraphReFly",
+						sources: ["note-1"],
+					}),
+				}),
+			],
+			{ name: "records" },
+		);
+		const drafts = g.state<readonly AgenticMemoryKgAssertionDraft[]>(
+			[
+				{
+					id: "assertion-1",
+					recordId: "record-kg",
+					fragmentId: "fragment-kg",
+					subject: { id: "person:ada", type: "person" },
+					predicate: "works_on",
+					object: { kind: "entity", id: "project:graphrefly", type: "project" },
+					confidence: 0.9,
+					sources: ["fragment-kg", "note-1"],
+					provenance: "fixture",
+				},
+			],
+			{ name: "drafts" },
+		);
+		const bundle = agenticMemoryKgProjectionBundle(g, { name: "kg", records, drafts });
+		const assertions = collect(bundle.assertions);
+		const status = collect(bundle.status);
+		const errors = collect(bundle.errors);
+
+		expect(g.describe().edges).toEqual(
+			expect.arrayContaining([
+				{ from: "records", to: "kg/projection" },
+				{ from: "drafts", to: "kg/projection" },
+				{ from: "kg/projection", to: "kg/assertions" },
+				{ from: "kg/projection", to: "kg/status" },
+				{ from: "kg/projection", to: "kg/errors" },
+				{ from: "kg/projection", to: "kg/cursor" },
+			]),
+		);
+		expect(g.describe().nodes).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({ id: "kg/projection", factory: "agenticMemoryKgProjection" }),
+			]),
+		);
+		expect(data<readonly AgenticMemoryKgProjectionError[]>(errors.messages).at(-1)).toEqual([]);
+		expect(data<AgenticMemoryKgProjectionStatus>(status.messages).at(-1)).toMatchObject({
+			state: "ready",
+			cursor: { validRecords: 1, validDrafts: 1, projectedAssertions: 1 },
+		});
+		expect(data(assertions.messages).at(-1)).toEqual([
+			{
+				id: "assertion-1",
+				recordId: "record-kg",
+				fragmentId: "fragment-kg",
+				subject: { id: "person:ada", type: "person" },
+				predicate: "works_on",
+				object: { kind: "entity", id: "project:graphrefly", type: "project" },
+				confidence: 0.9,
+				sources: ["fragment-kg", "note-1"],
+				provenance: "fixture",
+			},
+		]);
+	});
+
+	it("emits invalid refs, fragment mismatches, duplicate assertion ids, and shape errors as DATA", () => {
+		const g = graph();
+		const records = g.state<readonly AgenticMemoryRecord<string>[]>(
+			[
+				record({ id: "record-a", fragment: fragment({ id: "fragment-a" }) }),
+				record({ id: "record-b", fragment: fragment({ id: "fragment-b" }) }),
+			],
+			{ name: "records" },
+		);
+		const drafts = g.state<readonly AgenticMemoryKgAssertionDraft[]>(
+			[
+				{
+					id: "assertion-ok",
+					recordId: "record-a",
+					fragmentId: "fragment-a",
+					subject: { id: "s" },
+					predicate: "p",
+					object: { kind: "value", value: "ok" },
+				},
+				{
+					id: "assertion-ok",
+					recordId: "record-b",
+					fragmentId: "fragment-b",
+					subject: { id: "s" },
+					predicate: "p",
+					object: { kind: "value", value: "dupe" },
+				},
+				{
+					id: "missing-record",
+					recordId: "missing",
+					fragmentId: "fragment-a",
+					subject: { id: "s" },
+					predicate: "p",
+					object: { kind: "value", value: 1 },
+				},
+				{
+					id: "missing-fragment",
+					recordId: "record-a",
+					fragmentId: "missing-fragment",
+					subject: { id: "s" },
+					predicate: "p",
+					object: { kind: "value", value: true },
+				},
+				{
+					id: "mismatch",
+					recordId: "record-a",
+					fragmentId: "fragment-b",
+					subject: { id: "s" },
+					predicate: "p",
+					object: { kind: "entity", id: "entity-b" },
+				},
+				{
+					id: "bad-shape",
+					recordId: "record-a",
+					fragmentId: "fragment-a",
+					subject: { id: "" },
+					predicate: "",
+					object: { kind: "value", value: 1n },
+				} as never,
+			],
+			{ name: "drafts" },
+		);
+		const bundle = agenticMemoryKgProjectionBundle(g, { name: "kg", records, drafts });
+		const assertions = collect(bundle.assertions);
+		const errors = collect(bundle.errors);
+		const status = collect(bundle.status);
+
+		expect(
+			data<readonly AgenticMemoryKgProjectionError[]>(errors.messages)
+				.at(-1)
+				?.map((error) => error.code),
+		).toEqual([
+			"duplicate-assertion-id",
+			"missing-record-ref",
+			"missing-fragment-ref",
+			"fragment-record-mismatch",
+			"invalid-assertion-shape",
+		]);
+		expect(
+			data<readonly unknown[]>(assertions.messages)
+				.at(-1)
+				?.map((item) => (item as { id: string }).id),
+		).toEqual(["assertion-ok"]);
+		expect(data<AgenticMemoryKgProjectionStatus>(status.messages).at(-1)).toMatchObject({
+			state: "partial",
+			cursor: { validDrafts: 1, invalidDrafts: 5, projectedAssertions: 1 },
+		});
+		expect(errors.messages.some((message) => message[0] === "ERROR")).toBe(false);
+	});
+});
+
+describe("agentic memory record codec (D166)", () => {
+	it("roundtrips strict JSON record frames and bigint fields", () => {
+		const codec = agenticMemoryRecordCodec();
+		const original = record({
+			id: "record-codec",
+			kind: "episodic",
+			persistenceLevel: "permanent",
+			artifactKind: "raw",
+			scope: { tenantId: "tenant-1" },
+			fragment: fragment({
+				id: "fragment-codec",
+				payload: { text: "hello", nested: [1, true, null] },
+				tNs: 12345678901234567890n,
+				validFrom: 10000000000000000000n,
+				validTo: 20000000000000000000n,
+			}),
+		});
+		const decoded = codec.decode(codec.encode(original));
+
+		expect(decoded.fragment.tNs).toBe(12345678901234567890n);
+		expect(decoded.fragment.validFrom).toBe(10000000000000000000n);
+		expect(decoded.fragment.validTo).toBe(20000000000000000000n);
+		expect(decoded).toEqual(original);
+	});
+
+	it("fails honestly for unknown fields, corrupt bytes, invalid enums, and non-strict payloads", () => {
+		const frame = agenticMemoryRecordFrame(record({ fragment: fragment({ payload: "ok" }) }));
+		const frameCodec = agenticMemoryRecordFrameCodec();
+		const recordCodec = agenticMemoryRecordCodec();
+
+		expect(() => frameCodec.encode({ ...frame, storageTier: "cold" } as never)).toThrow(
+			/unexpected fields/,
+		);
+		expect(() => frameCodec.decode(new TextEncoder().encode("{"))).toThrow();
+		expect(() =>
+			frameCodec.encode({
+				...frame,
+				record: { ...frame.record, kind: "archive" },
+			} as unknown as AgenticMemoryRecordFrame),
+		).toThrow(/invalid memory kind/);
+		expect(() =>
+			frameCodec.encode({
+				...frame,
+				record: {
+					...frame.record,
+					fragment: { ...frame.record.fragment, tNs: "-0" },
+				},
+			} as unknown as AgenticMemoryRecordFrame),
+		).toThrow(/canonical decimal bigint string/);
+		const tags = ["project"] as string[] & { extra?: string };
+		tags.extra = "unknown";
+		expect(() =>
+			recordCodec.encode(
+				record({
+					fragment: fragment({ tags }),
+				}),
+			),
+		).toThrow(/strict JSON/);
+		const scopeWithSymbol = { tenantId: "tenant-1" } as AgenticMemoryRecord["scope"] & {
+			readonly [key: symbol]: string;
+		};
+		Object.defineProperty(scopeWithSymbol, Symbol("hidden"), {
+			value: "unknown",
+			enumerable: true,
+		});
+		expect(() =>
+			recordCodec.encode(
+				record({
+					scope: scopeWithSymbol,
+				}),
+			),
+		).toThrow(/strict JSON|symbol/);
+		expect(() =>
+			recordCodec.encode(
+				record({
+					fragment: fragment({ payload: { impossible: undefined } as never }),
+				}),
+			),
+		).toThrow(/strict JSON/);
+	});
+});
+
+describe("agentic memory retention bundle (D167)", () => {
+	it("projects archive, restore, setPersistenceLevel, and consolidation requests", () => {
+		const g = graph();
+		const records = g.state<readonly AgenticMemoryRecord<string>[]>(
+			[
+				record({ id: "record-a", persistenceLevel: "project", fragment: fragment({ id: "a" }) }),
+				record({ id: "record-b", persistenceLevel: "archived", fragment: fragment({ id: "b" }) }),
+			],
+			{ name: "records" },
+		);
+		const commands = g.state<readonly AgenticMemoryRetentionCommand[]>(
+			[
+				{ id: "cmd-archive", kind: "archive", recordId: "record-a", reason: "done" },
+				{
+					id: "cmd-restore",
+					kind: "restore",
+					recordId: "record-b",
+					persistenceLevel: "longTerm",
+				},
+				{
+					id: "cmd-set",
+					kind: "setPersistenceLevel",
+					recordId: "record-b",
+					persistenceLevel: "permanent",
+				},
+				{
+					id: "cmd-consolidate",
+					kind: "requestConsolidation",
+					recordIds: ["record-a", "record-b"],
+					requestId: "consolidate-1",
+					reason: "merge",
+				},
+			],
+			{ name: "commands" },
+		);
+		const bundle = agenticMemoryRetentionBundle(g, { name: "retention", records, commands });
+		const active = collect(bundle.activeRecords);
+		const archived = collect(bundle.archivedRecords);
+		const requests = collect(bundle.consolidationRequests);
+		const errors = collect(bundle.errors);
+		const status = collect(bundle.status);
+
+		expect(g.describe().edges).toEqual(
+			expect.arrayContaining([
+				{ from: "records", to: "retention/projection" },
+				{ from: "commands", to: "retention/projection" },
+				{ from: "retention/projection", to: "retention/activeRecords" },
+				{ from: "retention/projection", to: "retention/archivedRecords" },
+				{ from: "retention/projection", to: "retention/consolidationRequests" },
+				{ from: "retention/projection", to: "retention/status" },
+				{ from: "retention/projection", to: "retention/errors" },
+				{ from: "retention/projection", to: "retention/cursor" },
+			]),
+		);
+		expect(data<readonly AgenticMemoryRetentionError[]>(errors.messages).at(-1)).toEqual([]);
+		expect(
+			data<readonly AgenticMemoryRecord<string>[]>(active.messages)
+				.at(-1)
+				?.map((item) => [item.id, item.persistenceLevel]),
+		).toEqual([["record-b", "permanent"]]);
+		expect(
+			data<readonly AgenticMemoryRecord<string>[]>(archived.messages)
+				.at(-1)
+				?.map((item) => [item.id, item.persistenceLevel]),
+		).toEqual([["record-a", "archived"]]);
+		expect(data<readonly AgenticMemoryConsolidationRequest[]>(requests.messages).at(-1)).toEqual([
+			{
+				id: "consolidate-1",
+				commandId: "cmd-consolidate",
+				recordIds: ["record-a", "record-b"],
+				reason: "merge",
+			},
+		]);
+		expect(data<AgenticMemoryRetentionStatus>(status.messages).at(-1)).toMatchObject({
+			state: "ready",
+			cursor: { validCommands: 4, invalidCommands: 0, consolidationRequests: 1 },
+		});
+	});
+
+	it("emits invalid retention commands as DATA errors", () => {
+		const g = graph();
+		const records = g.state<readonly AgenticMemoryRecord<string>[]>(
+			[record({ id: "record-a", fragment: fragment({ id: "a" }) })],
+			{ name: "records" },
+		);
+		const commands = g.state<readonly AgenticMemoryRetentionCommand[]>(
+			[
+				{ id: "cmd-a", kind: "archive", recordId: "record-a" },
+				{ id: "cmd-a", kind: "restore", recordId: "record-a" },
+				{ id: "cmd-missing", kind: "archive", recordId: "missing" },
+				{ id: "cmd-retry", kind: "archive", recordId: "missing" },
+				{
+					id: "cmd-retry",
+					kind: "setPersistenceLevel",
+					recordId: "record-a",
+					persistenceLevel: "project",
+				},
+				{
+					id: "cmd-bad",
+					kind: "setPersistenceLevel",
+					recordId: "record-a",
+					persistenceLevel: "cold",
+				},
+				{ id: "cmd-empty", kind: "requestConsolidation", recordIds: [] },
+			] as never,
+			{ name: "commands" },
+		);
+		const bundle = agenticMemoryRetentionBundle(g, { name: "retention", records, commands });
+		const errors = collect(bundle.errors);
+		const status = collect(bundle.status);
+
+		expect(
+			data<readonly AgenticMemoryRetentionError[]>(errors.messages)
+				.at(-1)
+				?.map((error) => error.code),
+		).toEqual([
+			"duplicate-command-id",
+			"missing-record-ref",
+			"missing-record-ref",
+			"invalid-command",
+			"invalid-command",
+		]);
+		expect(data<AgenticMemoryRetentionStatus>(status.messages).at(-1)).toMatchObject({
+			state: "partial",
+			cursor: { validCommands: 2, invalidCommands: 5 },
+		});
+		expect(errors.messages.some((message) => message[0] === "ERROR")).toBe(false);
+	});
+});
diff --git a/packages/ts/src/__tests__/solutions-agentic-memory.part-02.test.ts b/packages/ts/src/__tests__/solutions-agentic-memory.part-02.test.ts
new file mode 100644
index 00000000..74a0a94d
--- /dev/null
+++ b/packages/ts/src/__tests__/solutions-agentic-memory.part-02.test.ts
@@ -0,0 +1,531 @@
+import { describe, expect, it } from "vitest";
+import { graph } from "../graph/graph.js";
+import type { MemoryAnswer, MemoryFragment } from "../patterns/index.js";
+import type { Message } from "../protocol/messages.js";
+import {
+	type AgenticMemoryConsolidationCommand,
+	type AgenticMemoryConsolidationError,
+	type AgenticMemoryConsolidationOutcome,
+	type AgenticMemoryConsolidationRequest,
+	type AgenticMemoryConsolidationStatus,
+	type AgenticMemoryContext,
+	type AgenticMemoryContextPackingError,
+	type AgenticMemoryContextPackingPolicy,
+	type AgenticMemoryContextPackingStatus,
+	type AgenticMemoryContextText,
+	type AgenticMemoryKgAssertionDraft,
+	type AgenticMemoryKgProjectionError,
+	type AgenticMemoryPackedContext,
+	type AgenticMemoryRecord,
+	type AgenticMemoryRetentionCommand,
+	type AgenticMemoryRetentionError,
+	type AgenticMemorySourceProjection,
+	agenticMemoryBundle,
+	agenticMemoryConsolidationBundle,
+	agenticMemoryContextPackingBundle,
+	agenticMemoryKgProjectionBundle,
+	agenticMemoryRetentionBundle,
+} from "../solutions/index.js";
+
+const fragment = <T = string>(patch: Partial<MemoryFragment<T>> = {}): MemoryFragment<T> => ({
+	id: "fact-1",
+	payload: "payload" as T,
+	tNs: 10n,
+	confidence: 0.8,
+	tags: ["project", "policy"],
+	sources: [],
+	...patch,
+});
+
+const record = <T = string>(
+	patch: Partial<AgenticMemoryRecord<T>> = {},
+): AgenticMemoryRecord<T> => ({
+	id: "record-1",
+	kind: "semantic",
+	persistenceLevel: "project",
+	artifactKind: "insight",
+	scope: { sessionId: "session-1", projectId: "project-1" },
+	fragment: fragment<T>(),
+	...patch,
+});
+
+const data = <T>(messages: Message[]): T[] =>
+	messages.filter((m) => m[0] === "DATA").map((m) => (m as readonly ["DATA", T])[1]);
+
+function collect(node: { subscribe(sink: (messages: Message) => void): () => void }) {
+	const messages: Message[] = [];
+	const unsubscribe = node.subscribe((message) => messages.push(message));
+	return { messages, unsubscribe };
+}
+
+describe("agentic memory consolidation bundle (D171)", () => {
+	it("projects external consolidation outcomes into result, draft, and command DATA facts", () => {
+		const g = graph();
+		const records = g.state<readonly AgenticMemoryRecord<string>[]>(
+			[
+				record({ id: "record-a", fragment: fragment({ id: "a" }) }),
+				record({ id: "record-b", fragment: fragment({ id: "b" }) }),
+			],
+			{ name: "records" },
+		);
+		const requests = g.state<readonly AgenticMemoryConsolidationRequest[]>(
+			[
+				{
+					id: "request-1",
+					commandId: "cmd-1",
+					recordIds: ["record-a", "record-b"],
+					reason: "merge",
+				},
+			],
+			{ name: "requests" },
+		);
+		const outcomes = g.state<readonly AgenticMemoryConsolidationOutcome<string>[]>(
+			[
+				{
+					id: "outcome-1",
+					requestId: "request-1",
+					kind: "proposedRecords",
+					records: [
+						record({
+							id: "record-merged",
+							artifactKind: "insight",
+							fragment: fragment({ id: "merged", payload: "merged insight" }),
+						}),
+					],
+					provenance: "external-executor",
+				},
+			],
+			{ name: "outcomes" },
+		);
+		const bundle = agenticMemoryConsolidationBundle(g, {
+			name: "consolidation",
+			records,
+			requests,
+			outcomes,
+		});
+		const drafts = collect(bundle.proposedRecordDrafts);
+		const commands = collect(bundle.commands);
+		const status = collect(bundle.status);
+		const errors = collect(bundle.errors);
+
+		expect(g.describe().edges).toEqual(
+			expect.arrayContaining([
+				{ from: "records", to: "consolidation/projection" },
+				{ from: "requests", to: "consolidation/projection" },
+				{ from: "outcomes", to: "consolidation/projection" },
+				{ from: "consolidation/projection", to: "consolidation/results" },
+				{ from: "consolidation/projection", to: "consolidation/proposedRecordDrafts" },
+				{ from: "consolidation/projection", to: "consolidation/commands" },
+			]),
+		);
+		expect(data(errors.messages).at(-1)).toEqual([]);
+		expect(data(status.messages).at(-1)).toMatchObject({
+			state: "ready",
+			cursor: { validOutcomes: 1, invalidOutcomes: 0, proposedRecordDrafts: 1 },
+		});
+		expect(data(drafts.messages).at(-1)).toEqual([
+			expect.objectContaining({
+				id: "request-1:outcome-1:record-merged",
+				requestId: "request-1",
+				outcomeId: "outcome-1",
+				record: expect.objectContaining({ id: "record-merged" }),
+			}),
+		]);
+		expect(data<readonly AgenticMemoryConsolidationCommand[]>(commands.messages).at(-1)).toEqual([
+			{
+				id: "request-1:outcome-1:proposeRecords",
+				kind: "proposeRecords",
+				requestId: "request-1",
+				outcomeId: "outcome-1",
+				draftIds: ["request-1:outcome-1:record-merged"],
+			},
+		]);
+	});
+
+	it("keeps invalid consolidation outcomes on the DATA error path", () => {
+		const g = graph();
+		const records = g.state<readonly AgenticMemoryRecord<string>[]>(
+			[record({ id: "record-a", fragment: fragment({ id: "a" }) })],
+			{ name: "records" },
+		);
+		const requests = g.state<readonly AgenticMemoryConsolidationRequest[]>(
+			[{ id: "request-1", commandId: "cmd-1", recordIds: ["record-a"] }],
+			{ name: "requests" },
+		);
+		const outcomes = g.state(
+			[
+				{ id: "missing", requestId: "missing-request", kind: "failed", message: "nope" },
+				{
+					id: "bad-record",
+					requestId: "request-1",
+					kind: "proposedRecords",
+					records: [record({ id: "", fragment: fragment({ id: "" }) })],
+				},
+			] as never,
+			{ name: "outcomes" },
+		);
+		const bundle = agenticMemoryConsolidationBundle(g, {
+			name: "consolidation",
+			records,
+			requests,
+			outcomes,
+		});
+		const errors = collect(bundle.errors);
+		const status = collect(bundle.status);
+
+		expect(
+			data<readonly AgenticMemoryConsolidationError[]>(errors.messages)
+				.at(-1)
+				?.map((error) => error.code),
+		).toEqual(["missing-request-ref", "invalid-proposed-record"]);
+		expect(data<AgenticMemoryConsolidationStatus>(status.messages).at(-1)).toMatchObject({
+			state: "error",
+			cursor: { validOutcomes: 0, invalidOutcomes: 2 },
+		});
+		expect(errors.messages.some((message) => message[0] === "ERROR")).toBe(false);
+	});
+
+	it("rejects duplicate proposed record ids and hostile outcome arrays as DATA errors", () => {
+		const g = graph();
+		const records = g.state<readonly AgenticMemoryRecord<string>[]>(
+			[record({ id: "record-a", fragment: fragment({ id: "a" }) })],
+			{ name: "records" },
+		);
+		const requests = g.state<readonly AgenticMemoryConsolidationRequest[]>(
+			[{ id: "request-1", commandId: "cmd-1", recordIds: ["record-a"] }],
+			{ name: "requests" },
+		);
+		const outcomes = [
+			{
+				id: "dupe-records",
+				requestId: "request-1",
+				kind: "proposedRecords",
+				records: [
+					record({ id: "record-merged", fragment: fragment({ id: "merged-a" }) }),
+					record({ id: "record-merged", fragment: fragment({ id: "merged-b" }) }),
+				],
+			},
+			{
+				id: "unreadable",
+				requestId: "request-1",
+				kind: "failed",
+				message: "unreachable",
+			},
+		] as unknown[];
+		Object.defineProperty(outcomes, "1", {
+			get() {
+				throw new Error("outcome getter exploded");
+			},
+		});
+		const outcomeNode = g.state(outcomes as never, { name: "outcomes" });
+		const bundle = agenticMemoryConsolidationBundle(g, {
+			name: "consolidation",
+			records,
+			requests,
+			outcomes: outcomeNode,
+		});
+		const errors = collect(bundle.errors);
+		const status = collect(bundle.status);
+
+		expect(
+			data<readonly AgenticMemoryConsolidationError[]>(errors.messages)
+				.at(-1)
+				?.map((error) => error.code),
+		).toEqual(["invalid-proposed-record", "invalid-outcome"]);
+		expect(
+			data<readonly AgenticMemoryConsolidationError[]>(errors.messages).at(-1)?.[0]
+				?.validationErrors,
+		).toEqual(["records[1]: duplicate proposed record id 'record-merged'"]);
+		expect(data<AgenticMemoryConsolidationStatus>(status.messages).at(-1)).toMatchObject({
+			state: "error",
+			cursor: { validOutcomes: 0, invalidOutcomes: 2, proposedRecordDrafts: 0 },
+		});
+		expect(errors.messages.some((message) => message[0] === "ERROR")).toBe(false);
+	});
+});
+
+describe("agentic memory context packing (D168)", () => {
+	const contextFact = (): AgenticMemoryContext<string> => ({
+		state: "ready",
+		query: {},
+		entries: [
+			{
+				fragmentId: "f1",
+				payload: "one",
+				confidence: 0.9,
+				tags: ["a"],
+				sources: [],
+				record: {
+					recordId: "r1",
+					kind: "semantic",
+					persistenceLevel: "project",
+					artifactKind: "insight",
+				},
+				fragment: fragment({ id: "f1", payload: "one" }),
+			},
+			{
+				fragmentId: "f2",
+				payload: "two",
+				confidence: 0.8,
+				tags: ["a"],
+				sources: [],
+				fragment: fragment({ id: "f2", payload: "two" }),
+			},
+			{
+				fragmentId: "f3",
+				payload: "three",
+				confidence: 0.7,
+				tags: ["a"],
+				sources: [],
+				fragment: fragment({ id: "f3", payload: "three" }),
+			},
+		],
+		cursor: { evaluation: 1, validFragments: 3, invalidFragments: 0, resultCount: 3 },
+		errors: [],
+		retrievalErrors: [],
+		contextReady: true,
+	});
+
+	it("packs explicit text in context order with maxEntries/maxChars/maxCost and metadata inclusion", () => {
+		const g = graph();
+		const context = g.state(contextFact(), { name: "context" });
+		const texts = g.state<readonly AgenticMemoryContextText[]>(
+			[
+				{ fragmentId: "f1", text: "aaa", cost: 1, metadata: { role: "evidence" } },
+				{ fragmentId: "f2", text: "bbbb", cost: 3, metadata: { role: "procedure" } },
+			],
+			{ name: "texts" },
+		);
+		const policy = g.state<AgenticMemoryContextPackingPolicy>(
+			{ maxEntries: 2, maxChars: 9, maxCost: 4, includeMetadata: true },
+			{ name: "policy" },
+		);
+		const bundle = agenticMemoryContextPackingBundle(g, {
+			name: "packing",
+			context,
+			texts,
+			policy,
+		});
+		const packed = collect(bundle.packedContext);
+		const errors = collect(bundle.errors);
+		const status = collect(bundle.status);
+
+		expect(g.describe().edges).toEqual(
+			expect.arrayContaining([
+				{ from: "context", to: "packing/projection" },
+				{ from: "texts", to: "packing/projection" },
+				{ from: "policy", to: "packing/projection" },
+				{ from: "packing/projection", to: "packing/packedContext" },
+				{ from: "packing/projection", to: "packing/status" },
+				{ from: "packing/projection", to: "packing/errors" },
+				{ from: "packing/projection", to: "packing/cursor" },
+			]),
+		);
+		expect(data<AgenticMemoryPackedContext>(packed.messages).at(-1)).toMatchObject({
+			text: "aaa\n\nbbbb",
+			totalChars: 9,
+			totalCost: 4,
+			truncated: true,
+			entries: [
+				{ fragmentId: "f1", metadata: { role: "evidence" }, record: { recordId: "r1" } },
+				{ fragmentId: "f2", metadata: { role: "procedure" } },
+			],
+		});
+		expect(data<readonly AgenticMemoryContextPackingError[]>(errors.messages).at(-1)).toEqual([
+			expect.objectContaining({ code: "missing-text", fragmentId: "f3" }),
+		]);
+		expect(data<AgenticMemoryContextPackingStatus>(status.messages).at(-1)).toMatchObject({
+			state: "partial",
+			cursor: { packedEntries: 2, omittedEntries: 1, totalChars: 9, totalCost: 4 },
+		});
+
+		policy.set({ maxEntries: 1, includeMetadata: true });
+		expect(
+			data<AgenticMemoryPackedContext>(packed.messages)
+				.at(-1)
+				?.entries.map((entry) => entry.fragmentId),
+		).toEqual(["f1"]);
+		policy.set({ maxChars: 6 });
+		expect(
+			data<AgenticMemoryPackedContext>(packed.messages)
+				.at(-1)
+				?.entries.map((entry) => entry.fragmentId),
+		).toEqual(["f1"]);
+		policy.set({ maxCost: 3 });
+		expect(
+			data<AgenticMemoryPackedContext>(packed.messages)
+				.at(-1)
+				?.entries.map((entry) => entry.fragmentId),
+		).toEqual(["f1"]);
+	});
+
+	it("turns malformed context and text metadata into DATA errors", () => {
+		const g = graph();
+		const context = g.state(
+			{
+				...contextFact(),
+				entries: [null, { fragmentId: "" }, { fragmentId: "f1", record: { recordId: "r1" } }],
+			} as never,
+			{ name: "context" },
+		);
+		const texts = g.state<readonly AgenticMemoryContextText[]>(
+			[{ fragmentId: "f1", text: "ok", metadata: ["not", "a", "record"] as never }],
+			{ name: "texts" },
+		);
+		const policy = g.state({ includeMetadata: true }, { name: "policy" });
+		const bundle = agenticMemoryContextPackingBundle(g, {
+			name: "packing",
+			context,
+			texts,
+			policy,
+		});
+		const packed = collect(bundle.packedContext);
+		const errors = collect(bundle.errors);
+
+		expect(data<AgenticMemoryPackedContext>(packed.messages).at(-1)?.entries).toEqual([]);
+		expect(
+			data<readonly AgenticMemoryContextPackingError[]>(errors.messages)
+				.at(-1)
+				?.map((error) => error.code),
+		).toEqual(["invalid-context", "invalid-context", "invalid-context", "invalid-text"]);
+		expect(errors.messages.some((message) => message[0] === "ERROR")).toBe(false);
+	});
+
+	it("keeps throwing context and policy getters on the DATA error path", () => {
+		const g = graph();
+		const hostileContext = { entries: [{ fragmentId: "f1" }] };
+		Object.defineProperty(hostileContext, "query", {
+			get() {
+				throw new Error("query boom");
+			},
+			enumerable: true,
+		});
+		const hostilePolicy = {};
+		Object.defineProperty(hostilePolicy, "maxChars", {
+			get() {
+				throw new Error("policy boom");
+			},
+			enumerable: true,
+		});
+		const context = g.state(hostileContext as never, { name: "context" });
+		const texts = g.state<readonly AgenticMemoryContextText[]>([{ fragmentId: "f1", text: "ok" }], {
+			name: "texts",
+		});
+		const policy = g.state<AgenticMemoryContextPackingPolicy>(hostilePolicy as never, {
+			name: "policy",
+		});
+		const bundle = agenticMemoryContextPackingBundle(g, {
+			name: "packing",
+			context,
+			texts,
+			policy,
+		});
+		const packed = collect(bundle.packedContext);
+		const errors = collect(bundle.errors);
+
+		expect(data<AgenticMemoryPackedContext>(packed.messages).at(-1)?.entries).toEqual([]);
+		expect(
+			data<readonly AgenticMemoryContextPackingError[]>(errors.messages)
+				.at(-1)
+				?.map((error) => error.code),
+		).toEqual(["invalid-policy"]);
+		expect(errors.messages.some((message) => message[0] === "ERROR")).toBe(false);
+
+		policy.set({ includeMetadata: true });
+		expect(data<AgenticMemoryPackedContext>(packed.messages).at(-1)?.text).toBe("ok");
+	});
+});
+
+describe("agentic memory duplicate fragment ownership (D169)", () => {
+	it("excludes duplicate fragment records from retrieval, context, metadata, and downstream bundles", () => {
+		const g = graph();
+		const records = g.state<readonly AgenticMemoryRecord<string>[]>(
+			[
+				record({ id: "record-a", fragment: fragment({ id: "same", payload: "kept" }) }),
+				record({ id: "record-b", fragment: fragment({ id: "same", payload: "dropped" }) }),
+			],
+			{ name: "records" },
+		);
+		const query = g.state({}, { name: "query" });
+		const memory = agenticMemoryBundle(g, { name: "memory", records, query });
+		const drafts = g.state<readonly AgenticMemoryKgAssertionDraft[]>(
+			[
+				{
+					id: "assert-kept",
+					recordId: "record-a",
+					fragmentId: "same",
+					subject: { id: "s" },
+					predicate: "p",
+					object: { kind: "value", value: "kept" },
+				},
+				{
+					id: "assert-dropped",
+					recordId: "record-b",
+					fragmentId: "same",
+					subject: { id: "s" },
+					predicate: "p",
+					object: { kind: "value", value: "dropped" },
+				},
+			],
+			{ name: "drafts" },
+		);
+		const kg = agenticMemoryKgProjectionBundle(g, { name: "kg", records, drafts });
+		const commands = g.state<readonly AgenticMemoryRetentionCommand[]>(
+			[
+				{ id: "archive-dropped", kind: "archive", recordId: "record-b" },
+				{ id: "consolidate-dropped", kind: "requestConsolidation", recordIds: ["record-b"] },
+			],
+			{ name: "commands" },
+		);
+		const retention = agenticMemoryRetentionBundle(g, { name: "retention", records, commands });
+		const projected = collect(memory.fragments);
+		const ranked = collect(memory.ranked);
+		const context = collect(memory.context);
+		const sources = collect(memory.sources);
+		const kgAssertions = collect(kg.assertions);
+		const kgErrors = collect(kg.errors);
+		const active = collect(retention.activeRecords);
+		const retentionErrors = collect(retention.errors);
+
+		query.set({});
+
+		expect(
+			data<readonly MemoryFragment<string>[]>(projected.messages)
+				.at(-1)
+				?.map((item) => [item.id, item.payload]),
+		).toEqual([["same", "kept"]]);
+		expect(
+			data<MemoryAnswer<string>>(ranked.messages)
+				.at(-1)
+				?.results.map((item) => [item.id, item.payload]),
+		).toEqual([["same", "kept"]]);
+		expect(
+			data<AgenticMemoryContext<string>>(context.messages)
+				.at(-1)
+				?.entries.map((entry) => [entry.fragmentId, entry.payload, entry.record?.recordId]),
+		).toEqual([["same", "kept", "record-a"]]);
+		expect(data<AgenticMemorySourceProjection[]>(sources.messages).at(-1)).toMatchObject([
+			{ fragmentId: "same", record: { recordId: "record-a" } },
+		]);
+		expect(
+			data<readonly unknown[]>(kgAssertions.messages)
+				.at(-1)
+				?.map((item) => (item as { id: string }).id),
+		).toEqual(["assert-kept"]);
+		expect(
+			data<readonly AgenticMemoryKgProjectionError[]>(kgErrors.messages)
+				.at(-1)
+				?.map((error) => error.code),
+		).toEqual(["duplicate-fragment-id", "missing-record-ref"]);
+		expect(
+			data<readonly AgenticMemoryRecord<string>[]>(active.messages)
+				.at(-1)
+				?.map((item) => item.id),
+		).toEqual(["record-a"]);
+		expect(
+			data<readonly AgenticMemoryRetentionError[]>(retentionErrors.messages)
+				.at(-1)
+				?.map((error) => error.code),
+		).toEqual(["duplicate-fragment-id", "missing-record-ref", "missing-record-ref"]);
+	});
+});
diff --git a/packages/ts/src/__tests__/solutions-reactive-layout.reactive-layout-solution-d181-part-01.test.ts b/packages/ts/src/__tests__/solutions-reactive-layout.reactive-layout-solution-d181-part-01.test.ts
new file mode 100644
index 00000000..c543001d
--- /dev/null
+++ b/packages/ts/src/__tests__/solutions-reactive-layout.reactive-layout-solution-d181-part-01.test.ts
@@ -0,0 +1,901 @@
+import { describe, expect, expectTypeOf, it } from "vitest";
+import { graph } from "../graph/graph.js";
+import type { Message } from "../protocol/messages.js";
+import {
+	analyzeAndMeasure,
+	type BlockAdapters,
+	CellMeasureAdapter,
+	capabilityTextMeasurements,
+	carveTextLineSlots,
+	cellTextMeasurements,
+	computeCharPositions,
+	computeLineBreaks,
+	IMAGE_SIZE_MEASUREMENT_KIND,
+	type ImageSizeMeasurementTarget,
+	InjectedMeasureAdapter,
+	imageSizeMeasurements,
+	type LineBreaksResult,
+	layoutNextLine,
+	type MeasurementAdapter,
+	type MeasurementReadiness,
+	type MeasurementResult,
+	type Measurements,
+	PrecomputedMeasureAdapter,
+	type PreparedSegment,
+	precomputedTextMeasurements,
+	READINESS_MEASUREMENT_KIND,
+	reactiveLayout,
+	readinessMeasurements,
+	readinessTextMeasurements,
+	SVG_BOUNDS_MEASUREMENT_KIND,
+	SvgBoundsAdapter,
+	type SvgBoundsMeasurementTarget,
+	svgBoundsMeasurements,
+	type TextMeasureCapability,
+	type TextSegmentsMeasurement,
+	textMeasurementProvider,
+} from "../solutions/index.js";
+import * as reactiveLayoutNodeCanvas from "../solutions/reactive-layout/node-canvas/index.js";
+import * as reactiveLayoutReactNative from "../solutions/reactive-layout/react-native/index.js";
+import * as reactiveLayoutSkia from "../solutions/reactive-layout/skia/index.js";
+
+const fixedAdapter: MeasurementAdapter = {
+	measureSegment(text) {
+		return { width: Array.from(text).length * 10 };
+	},
+};
+
+const fixedAdapters: BlockAdapters = { text: fixedAdapter };
+
+const data = <T>(messages: readonly Message[]): T[] =>
+	messages.filter((m) => m[0] === "DATA").map((m) => (m as readonly ["DATA", T])[1]);
+
+function collect(node: { subscribe(sink: (messages: Message) => void): () => void }) {
+	const messages: Message[] = [];
+	const unsubscribe = node.subscribe((message) => messages.push(message));
+	return { messages, unsubscribe };
+}
+
+function adapterNode(g: ReturnType<typeof graph>, name = "measure-capability") {
+	return g.state<MeasurementAdapter>(fixedAdapter, { name });
+}
+
+function _blockAdaptersNode(g: ReturnType<typeof graph>, name = "block-adapters") {
+	return g.state<BlockAdapters>(fixedAdapters, { name });
+}
+
+describe("reactive-layout solution (D181) — part 1", () => {
+	it("prepares measured segments and computes greedy line breaks", () => {
+		const cache = new Map<string, Map<string, number>>();
+		const segments = analyzeAndMeasure("hello world", "test", fixedAdapter, cache);
+
+		expectTypeOf(segments).toMatchTypeOf<PreparedSegment[]>();
+		expect(segments.map((segment) => [segment.text, segment.kind, segment.width])).toEqual([
+			["hello", "text", 50],
+			[" ", "space", 10],
+			["world", "text", 50],
+		]);
+
+		const breaks = computeLineBreaks(segments, 60);
+
+		expectTypeOf(breaks).toMatchTypeOf<LineBreaksResult>();
+		expect(breaks).toEqual({
+			lineCount: 2,
+			lines: [
+				{
+					text: "hello ",
+					width: 50,
+					startSegment: 0,
+					startGrapheme: 0,
+					endSegment: 2,
+					endGrapheme: 0,
+				},
+				{
+					text: "world",
+					width: 50,
+					startSegment: 2,
+					startGrapheme: 0,
+					endSegment: 3,
+					endGrapheme: 0,
+				},
+			],
+		});
+	});
+
+	it("preserves every grapheme when a single segment spans multiple lines", () => {
+		const cache = new Map<string, Map<string, number>>();
+		const segments = analyzeAndMeasure("abcdef", "test", fixedAdapter, cache);
+		const breaks = computeLineBreaks(segments, 20);
+
+		expect(breaks.lines.map((line) => line.text)).toEqual(["ab", "cd", "ef"]);
+		expect(breaks.lines.map((line) => line.width)).toEqual([20, 20, 20]);
+	});
+
+	it("consumes hard breaks and continues after whole-word grapheme fallback", () => {
+		const hardBreakCache = new Map<string, Map<string, number>>();
+		const hardBreakSegments = analyzeAndMeasure("a\nb", "test", fixedAdapter, hardBreakCache);
+		const hardBreaks = computeLineBreaks(hardBreakSegments, 20, {
+			hyphenWidth: fixedAdapter.measureSegment("-", "test").width,
+		});
+
+		expect(hardBreaks.lines.map((line) => line.text)).toEqual(["a", "b"]);
+
+		const kernedAdapter: MeasurementAdapter = {
+			measureSegment(text) {
+				return { width: text === "abcde" ? 100 : Array.from(text).length * 10 };
+			},
+		};
+		const kernedCache = new Map<string, Map<string, number>>();
+		const kernedSegments = analyzeAndMeasure("abcde f", "test", kernedAdapter, kernedCache);
+		const kernedBreaks = computeLineBreaks(kernedSegments, 50, {
+			hyphenWidth: kernedAdapter.measureSegment("-", "test").width,
+		});
+
+		expect(kernedBreaks.lines.map((line) => line.text)).toEqual(["abcde ", "f"]);
+	});
+
+	it("lays out the next line from a cursor and carves text slots", () => {
+		const cache = new Map<string, Map<string, number>>();
+		const segments = analyzeAndMeasure("abcd ef", "test", fixedAdapter, cache);
+
+		expect(layoutNextLine(segments, { segmentIndex: 0, graphemeIndex: 0 }, 30)).toEqual({
+			text: "abc",
+			width: 30,
+			start: { segmentIndex: 0, graphemeIndex: 0 },
+			end: { segmentIndex: 0, graphemeIndex: 3 },
+		});
+		expect(carveTextLineSlots({ left: 0, right: 100 }, [{ left: 20, right: 40 }], 10)).toEqual([
+			{ left: 0, right: 20 },
+			{ left: 40, right: 100 },
+		]);
+	});
+
+	it("computes per-grapheme positions from line breaks", () => {
+		const cache = new Map<string, Map<string, number>>();
+		const segments = analyzeAndMeasure("ab cd", "test", fixedAdapter, cache);
+		const breaks = computeLineBreaks(segments, 30);
+
+		expect(computeCharPositions(breaks, segments, 12)).toEqual([
+			{ x: 0, y: 0, width: 10, height: 12, line: 0 },
+			{ x: 10, y: 0, width: 10, height: 12, line: 0 },
+			{ x: 20, y: 0, width: 10, height: 12, line: 0 },
+			{ x: 0, y: 12, width: 10, height: 12, line: 1 },
+			{ x: 10, y: 12, width: 10, height: 12, line: 1 },
+		]);
+	});
+
+	it("builds a graph-visible reactiveLayout bundle without hidden subscribe islands", () => {
+		const g = graph({ name: "reactive-layout" });
+		const text = g.state("one two", { name: "text" });
+		const font = g.state("test", { name: "font" });
+		const measurements = textMeasurementProvider({
+			graph: g,
+			text,
+			font,
+			adapter: adapterNode(g),
+		});
+		const bundle = reactiveLayout({
+			graph: g,
+			measurements,
+			lineHeight: 12,
+			maxWidth: 40,
+		});
+		const breaks = collect(bundle.lineBreaks);
+		const height = collect(bundle.height);
+		const positions = collect(bundle.charPositions);
+
+		expect(bundle.graph.describe().edges).toEqual(
+			expect.arrayContaining([
+				{ from: "text", to: "text-measurements" },
+				{ from: "font", to: "text-measurements" },
+				{ from: "measure-capability", to: "text-measurements" },
+				{ from: "text-measurements", to: "reactive-layout:segments" },
+				{ from: "reactive-layout:segments", to: "reactive-layout:line-breaks" },
+				{ from: "reactive-layout:max-width", to: "reactive-layout:line-breaks" },
+				{ from: "text-measurements", to: "reactive-layout:line-breaks" },
+				{ from: "reactive-layout:line-breaks", to: "reactive-layout:height" },
+				{ from: "reactive-layout:line-height", to: "reactive-layout:height" },
+				{ from: "reactive-layout:line-breaks", to: "reactive-layout:char-positions" },
+				{ from: "reactive-layout:segments", to: "reactive-layout:char-positions" },
+				{ from: "reactive-layout:line-height", to: "reactive-layout:char-positions" },
+			]),
+		);
+
+		bundle.setMaxWidth(30);
+
+		expect(
+			data<LineBreaksResult>(breaks.messages)
+				.at(-1)
+				?.lines.map((line) => line.text),
+		).toEqual(["one ", "two"]);
+		expect(data<number>(height.messages).at(-1)).toBe(24);
+		expect(data<readonly unknown[]>(positions.messages).at(-1)?.length).toBe(7);
+
+		breaks.unsubscribe();
+		height.unsubscribe();
+		positions.unsubscribe();
+	});
+
+	it("clamps non-finite and negative numeric controls", () => {
+		const g = graph({ name: "reactive-layout" });
+		const text = g.state("one", { name: "text" });
+		const font = g.state("test", { name: "font" });
+		const measurements = textMeasurementProvider({
+			graph: g,
+			text,
+			font,
+			adapter: adapterNode(g),
+		});
+		const bundle = reactiveLayout({
+			graph: g,
+			measurements,
+			lineHeight: -1,
+			maxWidth: Number.NaN,
+		});
+		const height = collect(bundle.height);
+
+		expect(data<number>(height.messages).at(-1)).toBe(0);
+
+		bundle.setLineHeight(Number.NaN);
+		expect(data<number>(height.messages).at(-1)).toBe(0);
+
+		height.unsubscribe();
+	});
+
+	it("sanitizes external numeric Node inputs at layout consumption", () => {
+		const g = graph({ name: "reactive-layout-node-controls" });
+		const text = g.state("one", { name: "text" });
+		const font = g.state("test", { name: "font" });
+		const lineHeight = g.state(Number.NaN, { name: "line-height" });
+		const maxWidth = g.state(-10, { name: "max-width" });
+		const measurements = textMeasurementProvider({
+			graph: g,
+			text,
+			font,
+			adapter: adapterNode(g),
+		});
+		const bundle = reactiveLayout({
+			graph: g,
+			measurements,
+			lineHeight,
+			maxWidth,
+		});
+		const height = collect(bundle.height);
+		const positions = collect(bundle.charPositions);
+
+		const latestHeight = data<number>(height.messages).at(-1);
+		expect(Number.isFinite(latestHeight)).toBe(true);
+		expect(latestHeight).toBeGreaterThanOrEqual(0);
+		expect(data<readonly { readonly height: number }[]>(positions.messages).at(-1)).toEqual(
+			expect.arrayContaining([]),
+		);
+
+		lineHeight.set(-5);
+		maxWidth.set(Number.NaN);
+
+		const nextHeight = data<number>(height.messages).at(-1);
+		expect(Number.isFinite(nextHeight)).toBe(true);
+		expect(nextHeight).toBeGreaterThanOrEqual(0);
+
+		height.unsubscribe();
+		positions.unsubscribe();
+	});
+
+	it("clears text measurement cache when the adapter identity changes", () => {
+		const g = graph({ name: "text-adapter-swap" });
+		const text = g.state("aa", { name: "text" });
+		const font = g.state("font", { name: "font" });
+		const adapterA: MeasurementAdapter = {
+			measureSegment(segment) {
+				return { width: segment === "-" ? 1 : segment.length * 5 };
+			},
+		};
+		const adapterB: MeasurementAdapter = {
+			measureSegment(segment) {
+				return { width: segment === "-" ? 2 : segment.length * 9 };
+			},
+		};
+		const adapter = g.state<MeasurementAdapter>(adapterA, { name: "measure-capability" });
+		const measurements = textMeasurementProvider({ graph: g, text, font, adapter });
+		const facts = collect(measurements);
+
+		expect(
+			(data<Measurements>(facts.messages).at(-1)?.[0] as MeasurementResult<TextSegmentsMeasurement>)
+				.value.segments[0]?.width,
+		).toBe(10);
+
+		adapter.set(adapterB);
+
+		expect(
+			(data<Measurements>(facts.messages).at(-1)?.[0] as MeasurementResult<TextSegmentsMeasurement>)
+				.value.segments[0]?.width,
+		).toBe(18);
+		facts.unsubscribe();
+	});
+
+	it("keeps segment facts when only hyphen measurement fails", () => {
+		const g = graph({ name: "hyphen-fallback" });
+		const text = g.state("word", { name: "text" });
+		const font = g.state("font", { name: "font" });
+		const adapter: MeasurementAdapter = {
+			measureSegment(segment) {
+				if (segment === "-") throw new Error("hyphen unavailable");
+				return { width: segment.length * 10 };
+			},
+		};
+		const measurements = textMeasurementProvider({
+			graph: g,
+			text,
+			font,
+			adapter: g.state(adapter, { name: "measure-capability" }),
+		});
+		const facts = collect(measurements);
+		const latest = data<Measurements>(facts.messages).at(-1);
+
+		expect(latest?.[0]).toMatchObject({
+			kind: "ok",
+			targetId: "text",
+			measurementKind: "text-segments",
+		});
+		expect((latest?.[0] as MeasurementResult<TextSegmentsMeasurement>).value).not.toHaveProperty(
+			"hyphenWidth",
+		);
+		expect((latest?.[0] as MeasurementResult<TextSegmentsMeasurement>).value.segments).toEqual([
+			{ text: "word", width: 40, kind: "text", graphemeWidths: [10, 10, 10, 10] },
+		]);
+		expect(latest?.[1]).toMatchObject({
+			kind: "issue",
+			code: "measurement.hyphen.failed",
+			subjectId: "text",
+		});
+		expect(facts.messages.some((message) => message[0] === "ERROR")).toBe(false);
+		facts.unsubscribe();
+	});
+
+	it("provides universal sync measurement providers", () => {
+		let calls = 0;
+		const injected = new InjectedMeasureAdapter(
+			(text) => {
+				calls += 1;
+				return text.length * 7;
+			},
+			{ cache: true },
+		);
+		expect(injected.measureSegment("aa", "font")).toEqual({ width: 14 });
+		expect(injected.measureSegment("aa", "font")).toEqual({ width: 14 });
+		expect(calls).toBe(1);
+		injected.clearCache();
+		expect(injected.measureSegment("aa", "font")).toEqual({ width: 14 });
+		expect(calls).toBe(2);
+
+		const precomputed = new PrecomputedMeasureAdapter({
+			metrics: { aa: 13 },
+			fallback: "per-char",
+			cellWidth: 5,
+		});
+		expect(precomputed.measureSegment("aa", "font")).toEqual({ width: 13 });
+		expect(precomputed.measureSegment("bbb", "font")).toEqual({ width: 15 });
+		expect(() =>
+			new PrecomputedMeasureAdapter({ metrics: {} }).measureSegment("missing", "font"),
+		).toThrow(/No precomputed metric/);
+
+		expect(
+			new CellMeasureAdapter({ cellWidth: 4, wideCellWidth: 9 }).measureSegment("a界"),
+		).toEqual({
+			width: 13,
+		});
+		expect(new CellMeasureAdapter({ cellWidth: 4, tabCells: 3 }).measureSegment("\t")).toEqual({
+			width: 12,
+		});
+
+		const g = graph({ name: "measurement-providers" });
+		const text = g.state("aa", { name: "text" });
+		const font = g.state("font", { name: "font" });
+		const cellFacts = collect(cellTextMeasurements({ graph: g, text, font, cellWidth: 4 }));
+		expect(data<Measurements>(cellFacts.messages).at(-1)).toEqual([
+			{
+				kind: "ok",
+				targetId: "text",
+				measurementKind: "text-segments",
+				source: "cellTextMeasurements",
+				value: {
+					segments: [{ text: "aa", width: 8, kind: "text", graphemeWidths: [4, 4] }],
+					hyphenWidth: 4,
+				},
+				metadata: undefined,
+			},
+		]);
+		cellFacts.unsubscribe();
+
+		const missing = collect(
+			precomputedTextMeasurements({
+				graph: g,
+				text,
+				font,
+				metrics: {},
+				name: "precomputed-measurements",
+			}),
+		);
+		expect(data<Measurements>(missing.messages).at(-1)?.[0]).toMatchObject({
+			kind: "issue",
+			code: "measurement.failed",
+			subjectId: "text",
+			measurementKind: "text-segments",
+		});
+		expect(missing.messages.some((message) => message[0] === "ERROR")).toBe(false);
+		missing.unsubscribe();
+	});
+
+	it("provides caller-injected capability and readiness-gated text measurement helpers", () => {
+		const g = graph({ name: "d203-provider-helpers" });
+		const text = g.state("aa", { name: "text" });
+		const font = g.state("font", { name: "font" });
+		const capability = g.state<TextMeasureCapability>(
+			{
+				measureText(segment: string) {
+					return { width: segment === "-" ? 1 : segment.length * 6 };
+				},
+			},
+			{ name: "native-text-capability" },
+		);
+		const capabilityFacts = collect(
+			capabilityTextMeasurements({ graph: g, text, font, capability }),
+		);
+
+		expect(
+			(
+				data<Measurements>(capabilityFacts.messages).at(
+					-1,
+				)?.[0] as MeasurementResult<TextSegmentsMeasurement>
+			).value.segments[0]?.width,
+		).toBe(12);
+		capabilityFacts.unsubscribe();
+
+		const readiness = g.state<MeasurementReadiness>(
+			{ ready: false, code: "font.loading", metadata: { fontFace: "test" } },
+			{ name: "font-ready" },
+		);
+		const readyFacts = collect(
+			readinessTextMeasurements({
+				graph: g,
+				text,
+				font,
+				adapter: adapterNode(g, "ready-measure-capability"),
+				readiness,
+				name: "ready-text-measurements",
+			}),
+		);
+
+		expect(data<Measurements>(readyFacts.messages).at(-1)?.[0]).toMatchObject({
+			kind: "issue",
+			code: "font.loading",
+			measurementKind: "text-segments",
+			metadata: { fontFace: "test" },
+		});
+
+		readiness.set({ ready: true });
+
+		expect(data<Measurements>(readyFacts.messages).at(-1)?.[0]).toMatchObject({
+			kind: "ok",
+			targetId: "text",
+			measurementKind: "text-segments",
+		});
+		readyFacts.unsubscribe();
+
+		let width = 6;
+		const cachedAdapter: MeasurementAdapter = {
+			measureSegment(segment) {
+				return { width: segment === "-" ? 1 : segment.length * width };
+			},
+		};
+		const readinessCache = g.state<MeasurementReadiness>(
+			{ ready: true },
+			{ name: "cache-font-ready" },
+		);
+		const cachedFacts = collect(
+			readinessTextMeasurements({
+				graph: g,
+				text,
+				font,
+				adapter: g.state(cachedAdapter, { name: "cached-ready-measure-capability" }),
+				readiness: readinessCache,
+				name: "cached-ready-text-measurements",
+			}),
+		);
+
+		expect(
+			(
+				data<Measurements>(cachedFacts.messages).at(
+					-1,
+				)?.[0] as MeasurementResult<TextSegmentsMeasurement>
+			).value.segments[0]?.width,
+		).toBe(12);
+
+		width = 9;
+		readinessCache.set({ ready: false, code: "font.reloading" });
+		readinessCache.set({ ready: true });
+
+		expect(
+			(
+				data<Measurements>(cachedFacts.messages).at(
+					-1,
+				)?.[0] as MeasurementResult<TextSegmentsMeasurement>
+			).value.segments[0]?.width,
+		).toBe(18);
+		cachedFacts.unsubscribe();
+	});
+
+	it("emits standalone readiness, image, and SVG measurement facts as DATA", () => {
+		const readinessGraph = graph({ name: "standalone-readiness-provider" });
+		const readiness = readinessGraph.state<MeasurementReadiness>(
+			{ ready: false, code: "font.loading", metadata: { family: "Inter" } },
+			{ name: "font-ready" },
+		);
+		const readinessFacts = collect(
+			readinessMeasurements({
+				graph: readinessGraph,
+				readiness,
+				targetId: "font:Inter",
+				source: "font-loader",
+			}),
+		);
+
+		expect(data<Measurements>(readinessFacts.messages).at(-1)?.[0]).toMatchObject({
+			kind: "issue",
+			code: "font.loading",
+			subjectId: "font:Inter",
+			measurementKind: READINESS_MEASUREMENT_KIND,
+			source: "font-loader",
+			metadata: { family: "Inter" },
+		});
+
+		readiness.set({ ready: true, source: "font-face-set", metadata: { family: "Inter" } });
+
+		expect(data<Measurements>(readinessFacts.messages).at(-1)?.[0]).toMatchObject({
+			kind: "ok",
+			targetId: "font:Inter",
+			measurementKind: READINESS_MEASUREMENT_KIND,
+			source: "font-face-set",
+			value: { ready: true, source: "font-face-set", metadata: { family: "Inter" } },
+		});
+		expect(readinessFacts.messages.some((message) => message[0] === "ERROR")).toBe(false);
+		readinessFacts.unsubscribe();
+
+		const imageGraph = graph({ name: "image-size-provider" });
+		const imageTargets = [
+			{ id: "hero", src: "hero", metadata: { role: "cover" } },
+			{ src: "inline" },
+			{ id: "bad-size", src: "bad-size" },
+		] as Array<ImageSizeMeasurementTarget | undefined>;
+		imageTargets.length = 4;
+		const imageMeasurer = {
+			measureImage(src: string) {
+				if (src === "hero") return { width: 300, height: 150 };
+				if (src === "inline") return { width: 120, height: 80 };
+				if (src === "bad-size") return { width: Number.NaN, height: -5 };
+				throw new Error(`missing image ${src}`);
+			},
+		};
+		const imageFacts = collect(
+			imageSizeMeasurements({
+				graph: imageGraph,
+				images: imageGraph.state(imageTargets as readonly ImageSizeMeasurementTarget[], {
+					name: "images",
+				}),
+				measurer: imageGraph.state(imageMeasurer, { name: "image-size-capability" }),
+			}),
+		);
+		const latestImages = data<Measurements>(imageFacts.messages).at(-1);
+
+		expect(latestImages?.[0]).toMatchObject({
+			kind: "ok",
+			targetId: "hero",
+			measurementKind: IMAGE_SIZE_MEASUREMENT_KIND,
+			value: { width: 300, height: 150 },
+			metadata: { role: "cover" },
+		});
+		expect(latestImages?.[1]).toMatchObject({
+			kind: "ok",
+			targetId: "inline",
+			measurementKind: IMAGE_SIZE_MEASUREMENT_KIND,
+			value: { width: 120, height: 80 },
+		});
+		expect(latestImages?.[2]).toMatchObject({
+			kind: "issue",
+			code: "measurement.image-size.failed",
+			subjectId: "bad-size",
+			measurementKind: IMAGE_SIZE_MEASUREMENT_KIND,
+		});
+		expect(latestImages?.[3]).toMatchObject({
+			kind: "issue",
+			code: "measurement.image-size.failed",
+			subjectId: "image:3",
+			measurementKind: IMAGE_SIZE_MEASUREMENT_KIND,
+		});
+		expect(imageFacts.messages.some((message) => message[0] === "ERROR")).toBe(false);
+		imageFacts.unsubscribe();
+
+		const svgGraph = graph({ name: "svg-bounds-provider" });
+		const svgTargets = [
+			{ id: "mark", svg: '<svg viewBox="0 0 40 20"></svg>' },
+			{ id: "bad-size", svg: "<svg data-bad-size></svg>" },
+			{ id: "broken", svg: "<g></g>" },
+		] satisfies SvgBoundsMeasurementTarget[];
+		const svgAdapter = new SvgBoundsAdapter();
+		const svgMeasurer = {
+			measureSvg(svgText: string) {
+				if (svgText.includes("data-bad-size")) {
+					return { width: Number.POSITIVE_INFINITY, height: 10 };
+				}
+				return svgAdapter.measureSvg(svgText);
+			},
+		};
+		const svgFacts = collect(
+			svgBoundsMeasurements({
+				graph: svgGraph,
+				svgs: svgGraph.state(svgTargets, { name: "svgs" }),
+				measurer: svgGraph.state(svgMeasurer, { name: "svg-bounds-capability" }),
+			}),
+		);
+		const latestSvgs = data<Measurements>(svgFacts.messages).at(-1);
+
+		expect(latestSvgs?.[0]).toMatchObject({
+			kind: "ok",
+			targetId: "mark",
+			measurementKind: SVG_BOUNDS_MEASUREMENT_KIND,
+			value: { width: 40, height: 20 },
+		});
+		expect(latestSvgs?.[1]).toMatchObject({
+			kind: "issue",
+			code: "measurement.svg-bounds.failed",
+			subjectId: "bad-size",
+			measurementKind: SVG_BOUNDS_MEASUREMENT_KIND,
+		});
+		expect(latestSvgs?.[2]).toMatchObject({
+			kind: "issue",
+			code: "measurement.svg-bounds.failed",
+			subjectId: "broken",
+			measurementKind: SVG_BOUNDS_MEASUREMENT_KIND,
+		});
+		expect(svgFacts.messages.some((message) => message[0] === "ERROR")).toBe(false);
+		svgFacts.unsubscribe();
+	});
+
+	it("provides focused platform subpath text measurement helpers without native imports", () => {
+		const nodeCanvasGraph = graph({ name: "node-canvas-provider" });
+		const text = nodeCanvasGraph.state("abcd", { name: "text" });
+		const font = nodeCanvasGraph.state("12px test", { name: "font" });
+		const contextValue: reactiveLayoutNodeCanvas.NodeCanvasTextContextLike = {
+			font: "previous font",
+			measureText(segment: string) {
+				return { width: segment.length * (this.font.includes("12px") ? 4 : 7) };
+			},
+		};
+		const context = nodeCanvasGraph.state<reactiveLayoutNodeCanvas.NodeCanvasTextContextLike>(
+			contextValue,
+			{ name: "node-canvas-context" },
+		);
+		const nodeCanvasFacts = collect(
+			reactiveLayoutNodeCanvas.nodeCanvasTextMeasurements({
+				graph: nodeCanvasGraph,
+				text,
+				font,
+				context,
+			}),
+		);
+
+		expect(
+			(
+				data<Measurements>(nodeCanvasFacts.messages).at(
+					-1,
+				)?.[0] as MeasurementResult<TextSegmentsMeasurement>
+			).value.segments[0]?.width,
+		).toBe(16);
+		expect(contextValue.font).toBe("previous font");
+		nodeCanvasFacts.unsubscribe();
+
+		const concreteGraph = graph({ name: "node-canvas-package-provider" });
+		const concreteText = concreteGraph.state("abc", { name: "text" });
+		const concreteFont = concreteGraph.state("10px package", { name: "font" });
+		let createdCanvas: readonly [number, number] | null = null;
+		const concreteFacts = collect(
+			reactiveLayoutNodeCanvas.nodeCanvasPackageTextMeasurements({
+				graph: concreteGraph,
+				text: concreteText,
+				font: concreteFont,
+				width: 2,
+				height: 3,
+				canvas: {
+					createCanvas(width, height) {
+						createdCanvas = [width, height];
+						return {
+							getContext(type) {
+								expect(type).toBe("2d");
+								return {
+									font: "old",
+									measureText(segment: string) {
+										return {
+											width: segment.length * (this.font.includes("package") ? 5 : 1),
+										};
+									},
+								};
+							},
+						};
+					},
+				},
+			}),
+		);
+		expect(createdCanvas).toEqual([2, 3]);
+		expect(
+			(
+				data<Measurements>(concreteFacts.messages).at(
+					-1,
+				)?.[0] as MeasurementResult<TextSegmentsMeasurement>
+			).value.segments[0]?.width,
+		).toBe(15);
+		concreteFacts.unsubscribe();
+
+		const failingGraph = graph({ name: "node-canvas-package-failure" });
+		const failingFacts = collect(
+			reactiveLayoutNodeCanvas.nodeCanvasPackageTextMeasurements({
+				graph: failingGraph,
+				text: failingGraph.state("abc", { name: "text" }),
+				font: failingGraph.state("10px package", { name: "font" }),
+				canvas: {
+					createCanvas() {
+						throw new Error("canvas unavailable");
+					},
+				},
+			}),
+		);
+		expect(data<Measurements>(failingFacts.messages).at(-1)?.[0]).toMatchObject({
+			kind: "issue",
+			code: "measurement.failed",
+			subjectId: "text",
+			measurementKind: "text-segments",
+		});
+		expect(failingFacts.messages.some((message) => message[0] === "ERROR")).toBe(false);
+		failingFacts.unsubscribe();
+
+		const capabilityGraph = graph({ name: "focused-platform-provider" });
+		const platformText = capabilityGraph.state("xy", { name: "text" });
+		const platformFont = capabilityGraph.state("font", { name: "font" });
+		const capability = capabilityGraph.state<TextMeasureCapability>(
+			{
+				measureText(segment: string) {
+					return { width: segment.length * 8 };
+				},
+			},
+			{ name: "platform-capability" },
+		);
+
+		for (const [name, helper] of [
+			["skia", reactiveLayoutSkia.skiaTextMeasurements],
+			["react-native", reactiveLayoutReactNative.reactNativeTextMeasurements],
+		] as const) {
+			const facts = collect(
+				helper({
+					graph: capabilityGraph,
+					text: platformText,
+					font: platformFont,
+					capability,
+					name,
+				}),
+			);
+			expect(
+				(
+					data<Measurements>(facts.messages).at(
+						-1,
+					)?.[0] as MeasurementResult<TextSegmentsMeasurement>
+				).value.segments[0]?.width,
+			).toBe(16);
+			facts.unsubscribe();
+		}
+
+		const skiaGraph = graph({ name: "skia-ready-provider" });
+		const skiaText = skiaGraph.state("ready", { name: "text" });
+		const skiaFont = skiaGraph.state("Inter", { name: "font" });
+		const readiness = skiaGraph.state<MeasurementReadiness>(
+			{ ready: false, code: "font.loading" },
+			{ name: "skia-font-ready" },
+		);
+		const paragraphCapability = reactiveLayoutSkia.skiaParagraphTextMeasureCapability({
+			Skia: {
+				ParagraphBuilder: {
+					Make() {
+						let textValue = "";
+						return {
+							pushStyle() {
+								return this;
+							},
+							addText(next: string) {
+								textValue += next;
+								return this;
+							},
+							pop() {
+								return this;
+							},
+							build() {
+								return {
+									layout(width: number) {
+										expect(width).toBe(Number.MAX_SAFE_INTEGER);
+									},
+									getLongestLine() {
+										return textValue.length * 6;
+									},
+								};
+							},
+						};
+					},
+				},
+			},
+			textStyleForFont(fontValue) {
+				return { fontFamilies: [fontValue], fontSize: 12 };
+			},
+		});
+		const skiaFacts = collect(
+			reactiveLayoutSkia.skiaReadyTextMeasurements({
+				graph: skiaGraph,
+				text: skiaText,
+				font: skiaFont,
+				capability: skiaGraph.state(paragraphCapability, { name: "skia-capability" }),
+				readiness,
+			}),
+		);
+		expect(data<Measurements>(skiaFacts.messages).at(-1)?.[0]).toMatchObject({
+			kind: "issue",
+			code: "font.loading",
+			subjectId: "text",
+		});
+		readiness.set({ ready: true, source: "useFonts" });
+		expect(
+			(
+				data<Measurements>(skiaFacts.messages).at(
+					-1,
+				)?.[0] as MeasurementResult<TextSegmentsMeasurement>
+			).value.segments[0]?.width,
+		).toBe(30);
+		skiaFacts.unsubscribe();
+	});
+
+	it("projects React Native async layout probes as measurement facts", () => {
+		const g = graph({ name: "react-native-layout-probes" });
+		const probes = g.state<readonly reactiveLayoutReactNative.ReactNativeLayoutProbe[]>(
+			[
+				{ id: "card", width: 120, height: 40, source: "onLayout" },
+				{ id: "title", ready: false, code: "layout.pending" },
+				{ id: "bad", width: Number.NaN, height: 20 },
+			],
+			{ name: "layout-probes" },
+		);
+		const facts = collect(
+			reactiveLayoutReactNative.reactNativeLayoutMeasurements({ graph: g, probes }),
+		);
+
+		const latest = data<Measurements>(facts.messages).at(-1);
+		expect(latest?.[0]).toMatchObject({
+			kind: "ok",
+			targetId: "card",
+			measurementKind: reactiveLayoutReactNative.REACT_NATIVE_LAYOUT_MEASUREMENT_KIND,
+			value: { width: 120, height: 40 },
+			source: "onLayout",
+		});
+		expect(latest?.[1]).toMatchObject({
+			kind: "issue",
+			code: "layout.pending",
+			subjectId: "title",
+		});
+		expect(latest?.[2]).toMatchObject({
+			kind: "issue",
+			code: "measurement.react-native-layout.pending",
+			subjectId: "bad",
+		});
+		probes.set([{ id: "title", width: 80, height: 18 }]);
+		expect(data<Measurements>(facts.messages).at(-1)?.[0]).toMatchObject({
+			kind: "ok",
+			targetId: "title",
+			value: { width: 80, height: 18 },
+		});
+		facts.unsubscribe();
+	});
+});
diff --git a/packages/ts/src/__tests__/solutions-reactive-layout.reactive-layout-solution-d181-part-02.test.ts b/packages/ts/src/__tests__/solutions-reactive-layout.reactive-layout-solution-d181-part-02.test.ts
new file mode 100644
index 00000000..cdd9f41f
--- /dev/null
+++ b/packages/ts/src/__tests__/solutions-reactive-layout.reactive-layout-solution-d181-part-02.test.ts
@@ -0,0 +1,664 @@
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { describe, expect, it } from "vitest";
+import { graph } from "../graph/graph.js";
+import type { Message } from "../protocol/messages.js";
+import {
+	analyzeAndMeasure,
+	type BlockAdapters,
+	type BlocksMeasurement,
+	blockAdaptersProvider,
+	blockMeasurementProvider,
+	type ContentBlock,
+	cellTextMeasurements,
+	circleIntervalForBand,
+	computeBlockFlow,
+	computeFlowLines,
+	computeTotalHeight,
+	type FlowColumns,
+	type FlowContainer,
+	IMAGE_SIZE_MEASUREMENT_KIND,
+	ImageSizeAdapter,
+	type ImageSizeLookup,
+	imageSizeMeasurements,
+	type MeasurementAdapter,
+	type MeasurementReadiness,
+	type MeasurementResult,
+	type Measurements,
+	measureBlock,
+	measureBlocks,
+	mergeMeasurements,
+	type Obstacle,
+	type PreparedSegment,
+	READINESS_MEASUREMENT_KIND,
+	reactiveBlockLayout,
+	reactiveFlowLayout,
+	reactiveLayout,
+	readinessMeasurements,
+	rectIntervalForBand,
+	SVG_BOUNDS_MEASUREMENT_KIND,
+	SvgBoundsAdapter,
+	svgBoundsMeasurements,
+	textMeasurementProvider,
+} from "../solutions/index.js";
+import * as reactiveLayoutBrowser from "../solutions/reactive-layout/browser/index.js";
+import * as reactiveLayoutCore from "../solutions/reactive-layout/index.js";
+
+const fixedAdapter: MeasurementAdapter = {
+	measureSegment(text) {
+		return { width: Array.from(text).length * 10 };
+	},
+};
+
+const fixedAdapters: BlockAdapters = { text: fixedAdapter };
+
+const data = <T>(messages: readonly Message[]): T[] =>
+	messages.filter((m) => m[0] === "DATA").map((m) => (m as readonly ["DATA", T])[1]);
+
+function collect(node: { subscribe(sink: (messages: Message) => void): () => void }) {
+	const messages: Message[] = [];
+	const unsubscribe = node.subscribe((message) => messages.push(message));
+	return { messages, unsubscribe };
+}
+
+function adapterNode(g: ReturnType<typeof graph>, name = "measure-capability") {
+	return g.state<MeasurementAdapter>(fixedAdapter, { name });
+}
+
+function blockAdaptersNode(g: ReturnType<typeof graph>, name = "block-adapters") {
+	return g.state<BlockAdapters>(fixedAdapters, { name });
+}
+
+describe("reactive-layout solution (D181) — part 2", () => {
+	it("merges text, readiness, image, and SVG provider facts into one measurements node", () => {
+		const g = graph({ name: "merged-measurement-providers" });
+		const text = g.state("hello", { name: "text" });
+		const font = g.state("font", { name: "font" });
+		const readiness = g.state<MeasurementReadiness>(
+			{ ready: true, source: "font-face-set", metadata: { family: "Inter" } },
+			{ name: "font-ready" },
+		);
+		const textFacts = cellTextMeasurements({
+			graph: g,
+			text,
+			font,
+			cellWidth: 4,
+			targetId: "copy",
+			name: "copy-text",
+		});
+		const readinessFacts = readinessMeasurements({
+			graph: g,
+			readiness,
+			targetId: "font:Inter",
+			name: "font-readiness",
+		});
+		const imageFacts = imageSizeMeasurements({
+			graph: g,
+			images: g.state([{ id: "hero", src: "hero" }], { name: "images" }),
+			measurer: g.state(new ImageSizeAdapter({ hero: { width: 300, height: 150 } }), {
+				name: "image-capability",
+			}),
+		});
+		const svgFacts = svgBoundsMeasurements({
+			graph: g,
+			svgs: g.state([{ id: "mark", svg: '<svg width="80" height="20"></svg>' }], {
+				name: "svgs",
+			}),
+			measurer: g.state(new SvgBoundsAdapter(), { name: "svg-capability" }),
+		});
+		const sources = [readinessFacts, textFacts, imageFacts, svgFacts];
+		const measurements = mergeMeasurements({
+			graph: g,
+			sources,
+			name: "measurements",
+		});
+		sources.length = 0;
+		const layout = reactiveLayout({
+			graph: g,
+			measurements,
+			targetId: "copy",
+			maxWidth: 100,
+			lineHeight: 10,
+		});
+		const mergedFacts = collect(measurements);
+		const height = collect(layout.height);
+
+		expect(
+			data<Measurements>(mergedFacts.messages)
+				.at(-1)
+				?.map((fact) => [
+					fact.kind,
+					"targetId" in fact ? fact.targetId : fact.subjectId,
+					fact.measurementKind,
+				]),
+		).toEqual([
+			["ok", "font:Inter", READINESS_MEASUREMENT_KIND],
+			["ok", "copy", "text-segments"],
+			["ok", "hero", IMAGE_SIZE_MEASUREMENT_KIND],
+			["ok", "mark", SVG_BOUNDS_MEASUREMENT_KIND],
+		]);
+		expect(data<number>(height.messages).at(-1)).toBe(10);
+		readiness.set({ ready: false, code: "font.reloading" });
+		expect(data<Measurements>(mergedFacts.messages).at(-1)?.[0]).toMatchObject({
+			kind: "issue",
+			code: "font.reloading",
+			subjectId: "font:Inter",
+		});
+		mergedFacts.unsubscribe();
+		height.unsubscribe();
+	});
+
+	it("measures SVG and image blocks without DOM or implicit loading", () => {
+		const svg = new SvgBoundsAdapter();
+		const readonlySizes: ImageSizeLookup = {
+			get(key: string) {
+				return key === "hero" ? { width: 300, height: 150 } : undefined;
+			},
+		};
+		const images = new ImageSizeAdapter(readonlySizes);
+
+		expect(svg.measureSvg('<svg viewBox="0 0 40 20"></svg>')).toEqual({ width: 40, height: 20 });
+		expect(svg.measureSvg('<svg stroke-width="2" width="100" height="50"></svg>')).toEqual({
+			width: 100,
+			height: 50,
+		});
+		expect(() => svg.measureSvg('<svg width="100"><rect height="5"/></svg>')).toThrow(
+			/Cannot measure SVG/,
+		);
+		expect(images.measureImage("hero")).toEqual({ width: 300, height: 150 });
+		expect(() => images.measureImage("missing")).toThrow(/No image size registered/);
+	});
+
+	it("measures and stacks heterogeneous blocks with pure helpers", () => {
+		const cache = new Map<string, Map<string, number>>();
+		const text = measureBlock(
+			{ kind: "text", id: "copy", text: "hello world", lineHeight: 10 },
+			{ adapter: fixedAdapter, font: "test", maxWidth: 60, cache },
+		);
+		const blocks = measureBlocks(
+			[
+				{ kind: "text", id: "title", text: "abc", lineHeight: 10 },
+				{ kind: "image", id: "hero", src: "hero" },
+				{ kind: "svg", id: "mark", svg: '<svg width="80" height="20"></svg>' },
+			],
+			{
+				adapter: fixedAdapter,
+				adapters: {
+					image: new ImageSizeAdapter({ hero: { width: 200, height: 100 } }),
+					svg: new SvgBoundsAdapter(),
+				},
+				font: "test",
+				maxWidth: 100,
+			},
+		);
+		const flow = computeBlockFlow(blocks, 5);
+
+		expect(text.lineBreaks?.lines.map((line) => line.text)).toEqual(["hello ", "world"]);
+		expect(text.height).toBe(20);
+		expect(blocks.map((block) => [block.id, block.width, block.height])).toEqual([
+			["title", 30, 10],
+			["hero", 100, 50],
+			["mark", 80, 20],
+		]);
+		expect(flow.map((block) => [block.id, block.y])).toEqual([
+			["title", 0],
+			["hero", 15],
+			["mark", 70],
+		]);
+		expect(computeTotalHeight(flow)).toBe(90);
+	});
+
+	it("builds a graph-visible reactiveBlockLayout bundle", () => {
+		const g = graph({ name: "reactive-block-layout" });
+		const blocks = g.state<readonly ContentBlock[]>(
+			[
+				{ kind: "text", id: "one", text: "a", lineHeight: 10 },
+				{ kind: "text", id: "two", text: "b", lineHeight: 10 },
+			],
+			{ name: "blocks" },
+		);
+		const maxWidth = g.state(100, { name: "max-width" });
+		const measurements = blockMeasurementProvider({
+			graph: g,
+			blocks,
+			maxWidth,
+			adapters: blockAdaptersNode(g),
+			font: g.state("test", { name: "font" }),
+		});
+		const bundle = reactiveBlockLayout({
+			graph: g,
+			measurements,
+			gap: 5,
+		});
+		const totalHeight = collect(bundle.totalHeight);
+
+		expect(bundle.graph.describe().edges).toEqual(
+			expect.arrayContaining([
+				{ from: "blocks", to: "blocks-measurements" },
+				{ from: "max-width", to: "blocks-measurements" },
+				{ from: "block-adapters", to: "blocks-measurements" },
+				{ from: "font", to: "blocks-measurements" },
+				{ from: "blocks-measurements", to: "reactive-block-layout:measured-blocks" },
+				{
+					from: "reactive-block-layout:measured-blocks",
+					to: "reactive-block-layout:block-flow",
+				},
+				{ from: "reactive-block-layout:gap", to: "reactive-block-layout:block-flow" },
+				{
+					from: "reactive-block-layout:block-flow",
+					to: "reactive-block-layout:total-height",
+				},
+			]),
+		);
+		expect(data<number>(totalHeight.messages).at(-1)).toBe(25);
+
+		bundle.setGap(2);
+		expect(data<number>(totalHeight.messages).at(-1)).toBe(22);
+
+		totalHeight.unsubscribe();
+	});
+
+	it("clears block measurement cache when the text adapter identity changes", () => {
+		const g = graph({ name: "block-adapter-swap" });
+		const blocks = g.state<readonly ContentBlock[]>(
+			[{ kind: "text", id: "copy", text: "aa", lineHeight: 10 }],
+			{ name: "blocks" },
+		);
+		const maxWidth = g.state(100, { name: "max-width" });
+		const adapterA: MeasurementAdapter = {
+			measureSegment(segment) {
+				return { width: segment === "-" ? 1 : segment.length * 5 };
+			},
+		};
+		const adapterB: MeasurementAdapter = {
+			measureSegment(segment) {
+				return { width: segment === "-" ? 2 : segment.length * 9 };
+			},
+		};
+		const textAdapter = g.state<MeasurementAdapter>(adapterA, { name: "text-adapter" });
+		const measurements = blockMeasurementProvider({
+			graph: g,
+			blocks,
+			maxWidth,
+			adapters: blockAdaptersProvider({ graph: g, text: textAdapter }),
+			font: g.state("font", { name: "font" }),
+		});
+		const facts = collect(measurements);
+
+		expect(
+			(data<Measurements>(facts.messages).at(-1)?.[0] as MeasurementResult<BlocksMeasurement>).value
+				.blocks[0]?.width,
+		).toBe(10);
+
+		textAdapter.set(adapterB);
+
+		expect(
+			(data<Measurements>(facts.messages).at(-1)?.[0] as MeasurementResult<BlocksMeasurement>).value
+				.blocks[0]?.width,
+		).toBe(18);
+		facts.unsubscribe();
+	});
+
+	it("keeps successfully measured blocks when one block fails", () => {
+		const g = graph({ name: "partial-block-measurements" });
+		const blocks = g.state<readonly ContentBlock[]>(
+			[
+				{ kind: "text", id: "ok", text: "aa", lineHeight: 10 },
+				{ kind: "image", id: "missing", src: "missing" },
+			],
+			{ name: "blocks" },
+		);
+		const measurements = blockMeasurementProvider({
+			graph: g,
+			blocks,
+			maxWidth: g.state(100, { name: "max-width" }),
+			adapters: blockAdaptersNode(g),
+			font: g.state("font", { name: "font" }),
+		});
+		const facts = collect(measurements);
+		const latest = data<Measurements>(facts.messages).at(-1);
+
+		expect((latest?.[0] as MeasurementResult<BlocksMeasurement>).value.blocks).toHaveLength(1);
+		expect((latest?.[0] as MeasurementResult<BlocksMeasurement>).value.blocks[0]?.id).toBe("ok");
+		expect(latest?.[1]).toMatchObject({
+			kind: "issue",
+			code: "measurement.block.failed",
+			subjectId: "missing",
+		});
+		expect(facts.messages.some((message) => message[0] === "ERROR")).toBe(false);
+		facts.unsubscribe();
+	});
+
+	it("keeps block facts visible for hyphen and sparse-block issues", () => {
+		const hyphenGraph = graph({ name: "block-hyphen-issue" });
+		const hyphenBlocks = hyphenGraph.state<readonly ContentBlock[]>(
+			[{ kind: "text", id: "copy", text: "a\u00ADb", lineHeight: 10 }],
+			{ name: "blocks" },
+		);
+		let hyphenMeasurements = 0;
+		const hyphenAdapter: MeasurementAdapter = {
+			measureSegment(segment) {
+				if (segment === "-") {
+					hyphenMeasurements += 1;
+					throw new Error("hyphen unavailable");
+				}
+				return { width: segment.length * 10 };
+			},
+		};
+		const hyphenFacts = collect(
+			blockMeasurementProvider({
+				graph: hyphenGraph,
+				blocks: hyphenBlocks,
+				maxWidth: hyphenGraph.state(100, { name: "max-width" }),
+				adapters: hyphenGraph.state<BlockAdapters>(
+					{ text: hyphenAdapter },
+					{ name: "block-adapters" },
+				),
+				font: hyphenGraph.state("font", { name: "font" }),
+			}),
+		);
+		const latestHyphen = data<Measurements>(hyphenFacts.messages).at(-1);
+
+		expect((latestHyphen?.[0] as MeasurementResult<BlocksMeasurement>).value.blocks).toHaveLength(
+			1,
+		);
+		expect(latestHyphen?.[1]).toMatchObject({
+			kind: "issue",
+			code: "measurement.hyphen.failed",
+			subjectId: "copy",
+			measurementKind: "blocks",
+		});
+		expect(hyphenMeasurements).toBe(1);
+		hyphenFacts.unsubscribe();
+
+		const sparseGraph = graph({ name: "sparse-block-measurements" });
+		const sparseBlocks = [{ kind: "text", id: "ok", text: "aa", lineHeight: 10 }] as Array<
+			ContentBlock | undefined
+		>;
+		sparseBlocks.length = 2;
+		const sparseFacts = collect(
+			blockMeasurementProvider({
+				graph: sparseGraph,
+				blocks: sparseGraph.state<readonly ContentBlock[]>(
+					sparseBlocks as readonly ContentBlock[],
+					{ name: "blocks" },
+				),
+				maxWidth: sparseGraph.state(100, { name: "max-width" }),
+				adapters: blockAdaptersNode(sparseGraph),
+				font: sparseGraph.state("font", { name: "font" }),
+			}),
+		);
+		const latestSparse = data<Measurements>(sparseFacts.messages).at(-1);
+
+		expect((latestSparse?.[0] as MeasurementResult<BlocksMeasurement>).value.blocks).toHaveLength(
+			1,
+		);
+		expect(latestSparse?.[1]).toMatchObject({
+			kind: "issue",
+			code: "measurement.block.failed",
+			subjectId: "blocks:1",
+		});
+		expect(sparseFacts.messages.some((message) => message[0] === "ERROR")).toBe(false);
+		sparseFacts.unsubscribe();
+	});
+
+	it("sanitizes block and flow numeric Node inputs at consumption", () => {
+		const blockGraph = graph({ name: "block-node-controls" });
+		const blockMeasurements = blockGraph.state<Measurements>(
+			[
+				{
+					kind: "ok",
+					targetId: "blocks",
+					measurementKind: "blocks",
+					value: {
+						blocks: [
+							{
+								block: { kind: "text", id: "copy", text: "aa" },
+								kind: "text",
+								id: "copy",
+								width: 10,
+								height: 10,
+								marginTop: 0,
+								marginBottom: 0,
+							},
+						],
+					},
+				},
+			],
+			{ name: "block-measurements" },
+		);
+		const gap = blockGraph.state(Number.NaN, { name: "gap" });
+		const block = reactiveBlockLayout({ graph: blockGraph, measurements: blockMeasurements, gap });
+		const totalHeight = collect(block.totalHeight);
+
+		expect(data<number>(totalHeight.messages).at(-1)).toBe(10);
+
+		const flowGraph = graph({ name: "flow-node-controls" });
+		const text = flowGraph.state("aa", { name: "text" });
+		const font = flowGraph.state("font", { name: "font" });
+		const flowMeasurements = textMeasurementProvider({
+			graph: flowGraph,
+			text,
+			font,
+			adapter: adapterNode(flowGraph),
+		});
+		const flow = reactiveFlowLayout({
+			graph: flowGraph,
+			measurements: flowMeasurements,
+			lineHeight: flowGraph.state(Number.NaN, { name: "line-height" }),
+			container: flowGraph.state<FlowContainer>(
+				{ width: Number.NaN, height: -1 },
+				{ name: "container" },
+			),
+			columns: flowGraph.state<FlowColumns>({ count: -3, gap: Number.NaN }, { name: "columns" }),
+			obstacles: flowGraph.state<readonly Obstacle[]>(
+				[{ kind: "rect", x: -5, y: Number.NaN, width: -10, height: -2 }],
+				{ name: "obstacles" },
+			),
+		});
+		const flowLines = collect(flow.flowLines);
+		const latestFlow = data<{ readonly lines: readonly unknown[] }>(flowLines.messages).at(-1);
+
+		expect(latestFlow?.lines).toEqual([]);
+		expect(flowLines.messages.some((message) => message[0] === "ERROR")).toBe(false);
+
+		totalHeight.unsubscribe();
+		flowLines.unsubscribe();
+	});
+
+	it("keeps missing measurement as DATA issues and layout no-ops by default", () => {
+		const throwingAdapter: MeasurementAdapter = {
+			measureSegment() {
+				throw new Error("measure exploded");
+			},
+		};
+		const g = graph({ name: "measurement-issues" });
+		const text = g.state("boom", { name: "text" });
+		const font = g.state("test", { name: "font" });
+		const measurements = textMeasurementProvider({
+			graph: g,
+			text,
+			font,
+			adapter: g.state<MeasurementAdapter>(throwingAdapter, { name: "measure-capability" }),
+		});
+		const layout = reactiveLayout({
+			graph: g,
+			measurements,
+		});
+		const measurementFacts = collect(measurements);
+		const segments = collect(layout.segments);
+
+		expect(data<Measurements>(measurementFacts.messages).at(-1)?.[0]).toMatchObject({
+			kind: "issue",
+			code: "measurement.failed",
+			subjectId: "text",
+			measurementKind: "text-segments",
+		});
+		expect(data<readonly PreparedSegment[]>(segments.messages).at(-1)).toEqual([]);
+		expect(measurementFacts.messages.some((message) => message[0] === "ERROR")).toBe(false);
+		expect(segments.messages.some((message) => message[0] === "ERROR")).toBe(false);
+		measurementFacts.unsubscribe();
+		segments.unsubscribe();
+
+		const blockGraph = graph({ name: "block-measurement-issues" });
+		const blocks = blockGraph.state<readonly ContentBlock[]>([{ kind: "text", text: "boom" }], {
+			name: "blocks",
+		});
+		const maxWidth = blockGraph.state(100, { name: "max-width" });
+		const blockMeasurements = blockMeasurementProvider({
+			graph: blockGraph,
+			blocks,
+			maxWidth,
+			adapters: blockGraph.state<BlockAdapters>(
+				{ text: throwingAdapter },
+				{ name: "block-adapters" },
+			),
+		});
+		const block = reactiveBlockLayout({
+			graph: blockGraph,
+			measurements: blockMeasurements,
+		});
+		const blockFacts = collect(blockMeasurements);
+		const measuredBlocks = collect(block.measuredBlocks);
+
+		const latestBlockFacts = data<Measurements>(blockFacts.messages).at(-1);
+		expect(latestBlockFacts?.[0]).toMatchObject({
+			kind: "ok",
+			targetId: "blocks",
+			measurementKind: "blocks",
+			value: { blocks: [] },
+		});
+		expect(latestBlockFacts?.[1]).toMatchObject({
+			kind: "issue",
+			code: "measurement.block.failed",
+			subjectId: "blocks:0",
+			measurementKind: "blocks",
+		});
+		expect(data<readonly unknown[]>(measuredBlocks.messages).at(-1)).toEqual([]);
+		expect(blockFacts.messages.some((message) => message[0] === "ERROR")).toBe(false);
+		expect(measuredBlocks.messages.some((message) => message[0] === "ERROR")).toBe(false);
+		blockFacts.unsubscribe();
+		measuredBlocks.unsubscribe();
+
+		const flowGraph = graph({ name: "flow-measurement-issues" });
+		const flowText = flowGraph.state("boom", { name: "text" });
+		const flowFont = flowGraph.state("test", { name: "font" });
+		const flowMeasurements = textMeasurementProvider({
+			graph: flowGraph,
+			text: flowText,
+			font: flowFont,
+			adapter: flowGraph.state<MeasurementAdapter>(throwingAdapter, {
+				name: "measure-capability",
+			}),
+		});
+		const flow = reactiveFlowLayout({
+			graph: flowGraph,
+			measurements: flowMeasurements,
+		});
+		const flowSegments = collect(flow.segments);
+
+		expect(data<readonly PreparedSegment[]>(flowSegments.messages).at(-1)).toEqual([]);
+		expect(flowSegments.messages.some((message) => message[0] === "ERROR")).toBe(false);
+		flowSegments.unsubscribe();
+	});
+
+	it("computes multi-column flow lines around pure obstacle intervals", () => {
+		const cache = new Map<string, Map<string, number>>();
+		const segments = analyzeAndMeasure("abcd efgh", "test", fixedAdapter, cache);
+
+		expect(
+			rectIntervalForBand({ kind: "rect", x: 20, y: 0, width: 20, height: 10 }, 0, 10),
+		).toEqual({
+			left: 20,
+			right: 40,
+		});
+		expect(circleIntervalForBand({ kind: "circle", cx: 50, cy: 5, r: 5 }, 0, 10)).toEqual({
+			left: 45,
+			right: 55,
+		});
+
+		const flow = computeFlowLines(segments, {
+			container: { width: 80, height: 30 },
+			lineHeight: 10,
+			obstacles: [{ kind: "rect", x: 20, y: 0, width: 20, height: 10 }],
+			hyphenWidth: fixedAdapter.measureSegment("-", "test").width,
+		});
+
+		expect(flow.lines.slice(0, 2).map((line) => [line.text, line.x, line.slotWidth])).toEqual([
+			["ab", 0, 20],
+			["cd ", 40, 40],
+		]);
+		expect(flow.done).toBe(true);
+	});
+
+	it("builds a graph-visible reactiveFlowLayout bundle", () => {
+		const g = graph({ name: "reactive-flow-layout" });
+		const text = g.state("abcd ef", { name: "text" });
+		const font = g.state("test", { name: "font" });
+		const measurements = textMeasurementProvider({
+			graph: g,
+			text,
+			font,
+			adapter: adapterNode(g),
+		});
+		const bundle = reactiveFlowLayout({
+			graph: g,
+			measurements,
+			lineHeight: 10,
+			container: { width: 40, height: 40 },
+		});
+		const flow = collect(bundle.flowLines);
+
+		expect(bundle.graph.describe().edges).toEqual(
+			expect.arrayContaining([
+				{ from: "text", to: "text-measurements" },
+				{ from: "font", to: "text-measurements" },
+				{ from: "measure-capability", to: "text-measurements" },
+				{ from: "text-measurements", to: "reactive-flow-layout:segments" },
+				{ from: "reactive-flow-layout:segments", to: "reactive-flow-layout:flow-lines" },
+				{
+					from: "reactive-flow-layout:line-height",
+					to: "reactive-flow-layout:flow-lines",
+				},
+				{ from: "reactive-flow-layout:container", to: "reactive-flow-layout:flow-lines" },
+				{ from: "reactive-flow-layout:columns", to: "reactive-flow-layout:flow-lines" },
+				{ from: "reactive-flow-layout:obstacles", to: "reactive-flow-layout:flow-lines" },
+				{ from: "text-measurements", to: "reactive-flow-layout:flow-lines" },
+			]),
+		);
+		expect(data<{ readonly lines: readonly unknown[] }>(flow.messages).at(-1)?.lines.length).toBe(
+			2,
+		);
+
+		bundle.setObstacles([{ kind: "rect", x: 0, y: 0, width: 20, height: 10 }]);
+		expect(
+			data<{ readonly lines: readonly { readonly x: number }[] }>(flow.messages).at(-1)?.lines[0]
+				?.x,
+		).toBe(20);
+
+		bundle.setObstacles([{ kind: "rect", x: -10, y: 0, width: 20, height: 10 }]);
+		expect(
+			data<{ readonly lines: readonly { readonly x: number }[] }>(flow.messages).at(-1)?.lines[0]
+				?.x,
+		).toBe(10);
+
+		flow.unsubscribe();
+	});
+
+	it("keeps CanvasMeasureAdapter behind the browser subpath", () => {
+		expect(Object.hasOwn(reactiveLayoutCore, "CanvasMeasureAdapter")).toBe(false);
+		expect(Object.hasOwn(reactiveLayoutBrowser, "CanvasMeasureAdapter")).toBe(true);
+
+		const sourcePath = join(
+			dirname(fileURLToPath(import.meta.url)),
+			"..",
+			"solutions",
+			"reactive-layout",
+			"index.ts",
+		);
+		const source = readFileSync(sourcePath, "utf8");
+
+		expect(source).not.toMatch(/\b(?:OffscreenCanvas|document|window)\b/);
+	});
+});
diff --git a/packages/ts/src/__tests__/sources-browser.test.ts b/packages/ts/src/__tests__/sources-browser.test.ts
new file mode 100644
index 00000000..4f7d4168
--- /dev/null
+++ b/packages/ts/src/__tests__/sources-browser.test.ts
@@ -0,0 +1,176 @@
+import { describe, expect, it } from "vitest";
+import type { Message } from "../index.js";
+import { graph } from "../index.js";
+import {
+	type AnimationFrameHandle,
+	type AnimationFrameScheduler,
+	fromIDBRequest,
+	fromIDBTransaction,
+	fromRaf,
+	type IDBRequestLike,
+	type IDBTransactionLike,
+	type VisibilityDocumentLike,
+} from "../sources/browser.js";
+
+const data = (msgs: Message[]) =>
+	msgs.filter((m) => m[0] === "DATA").map((m) => (m as ["DATA", unknown])[1]);
+
+describe("browser source adapters", () => {
+	it("fromRaf emits frame timestamps and cancels the pending host frame on unsubscribe", () => {
+		let nextHandle = 0;
+		const callbacks = new Map<AnimationFrameHandle, (time: number) => void>();
+		const canceled: AnimationFrameHandle[] = [];
+		const scheduler: AnimationFrameScheduler = {
+			requestAnimationFrame(callback) {
+				const handle = ++nextHandle;
+				callbacks.set(handle, callback);
+				return handle;
+			},
+			cancelAnimationFrame(handle) {
+				canceled.push(handle);
+				callbacks.delete(handle);
+			},
+		};
+		const n = graph().initNode(fromRaf({ scheduler }), [], { name: "frames" });
+		const msgs: Message[] = [];
+		const unsubscribe = n.subscribe((msg) => msgs.push(msg));
+
+		const first = callbacks.get(1);
+		callbacks.delete(1);
+		first?.(12.5);
+		const second = callbacks.get(2);
+		callbacks.delete(2);
+		second?.(24);
+		unsubscribe();
+		callbacks.get(3)?.(48);
+
+		expect(data(msgs)).toEqual([12.5, 24]);
+		expect(canceled).toEqual([3]);
+	});
+
+	it("fromRaf can park while the visibility document is hidden", () => {
+		let nextHandle = 0;
+		const callbacks = new Map<AnimationFrameHandle, (time: number) => void>();
+		let visibilityListener: (() => void) | undefined;
+		let visibilityState = "hidden";
+		const scheduler: AnimationFrameScheduler = {
+			requestAnimationFrame(callback) {
+				const handle = ++nextHandle;
+				callbacks.set(handle, callback);
+				return handle;
+			},
+			cancelAnimationFrame(handle) {
+				callbacks.delete(handle);
+			},
+		};
+		const visibilityDocument: VisibilityDocumentLike = {
+			get visibilityState() {
+				return visibilityState;
+			},
+			addEventListener(type, listener) {
+				if (type === "visibilitychange") visibilityListener = listener;
+			},
+			removeEventListener(type, listener) {
+				if (type === "visibilitychange" && visibilityListener === listener) {
+					visibilityListener = undefined;
+				}
+			},
+		};
+		const n = graph().initNode(
+			fromRaf({ scheduler, pauseWhenHidden: true, document: visibilityDocument }),
+			[],
+		);
+		const msgs: Message[] = [];
+		const unsubscribe = n.subscribe((msg) => msgs.push(msg));
+
+		expect(callbacks.size).toBe(0);
+		visibilityState = "visible";
+		visibilityListener?.();
+		const first = callbacks.get(1);
+		callbacks.delete(1);
+		first?.(10);
+		visibilityState = "hidden";
+		visibilityListener?.();
+		callbacks.get(2)?.(20);
+		unsubscribe();
+
+		expect(data(msgs)).toEqual([10]);
+		expect(callbacks.size).toBe(0);
+		expect(visibilityListener).toBeUndefined();
+	});
+
+	it("fromIDBRequest emits request result then COMPLETE", () => {
+		const request: IDBRequestLike<number> = {
+			result: 42,
+			error: null,
+			onsuccess: null,
+			onerror: null,
+		};
+		const n = graph().initNode(fromIDBRequest(request), []);
+		const msgs: Message[] = [];
+		n.subscribe((msg) => msgs.push(msg));
+
+		request.onsuccess?.call(request, { type: "success" });
+
+		expect(data(msgs)).toEqual([42]);
+		expect(msgs.at(-1)?.[0]).toBe("COMPLETE");
+		expect(request.onsuccess).toBeNull();
+		expect(request.onerror).toBeNull();
+	});
+
+	it("fromIDBRequest coerces undefined request result to ERROR", () => {
+		const request: IDBRequestLike<undefined> = {
+			result: undefined,
+			error: null,
+			onsuccess: null,
+			onerror: null,
+		};
+		const n = graph().initNode(fromIDBRequest(request), []);
+		const msgs: Message[] = [];
+		n.subscribe((msg) => msgs.push(msg));
+
+		request.onsuccess?.call(request, { type: "success" });
+
+		expect(data(msgs)).toEqual([]);
+		expect(msgs.at(-1)?.[0]).toBe("ERROR");
+		expect((msgs.at(-1) as ["ERROR", unknown])[1]).toBeInstanceOf(TypeError);
+	});
+
+	it("fromIDBTransaction completes without DATA on success", () => {
+		const transaction: IDBTransactionLike = {
+			error: null,
+			oncomplete: null,
+			onerror: null,
+			onabort: null,
+		};
+		const n = graph().initNode(fromIDBTransaction(transaction), []);
+		const msgs: Message[] = [];
+		n.subscribe((msg) => msgs.push(msg));
+
+		transaction.oncomplete?.call(transaction, { type: "complete" });
+
+		expect(data(msgs)).toEqual([]);
+		expect(msgs.at(-1)?.[0]).toBe("COMPLETE");
+		expect(transaction.oncomplete).toBeNull();
+		expect(transaction.onerror).toBeNull();
+		expect(transaction.onabort).toBeNull();
+	});
+
+	it("fromIDBTransaction emits ERROR on abort", () => {
+		const transaction: IDBTransactionLike = {
+			error: new Error("abort"),
+			oncomplete: null,
+			onerror: null,
+			onabort: null,
+		};
+		const n = graph().initNode(fromIDBTransaction(transaction), []);
+		const msgs: Message[] = [];
+		n.subscribe((msg) => msgs.push(msg));
+
+		transaction.onabort?.call(transaction, { type: "abort" });
+
+		expect(data(msgs)).toEqual([]);
+		expect(msgs.at(-1)?.[0]).toBe("ERROR");
+		expect((msgs.at(-1) as ["ERROR", unknown])[1]).toBe(transaction.error);
+	});
+});
diff --git a/packages/ts/src/__tests__/sources-node.test.ts b/packages/ts/src/__tests__/sources-node.test.ts
new file mode 100644
index 00000000..39964b8a
--- /dev/null
+++ b/packages/ts/src/__tests__/sources-node.test.ts
@@ -0,0 +1,328 @@
+import { execFileSync } from "node:child_process";
+import { existsSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { toProcess } from "../adapters/index.js";
+import type { Message } from "../index.js";
+import { EnvironmentDrivers, fromProcess, graph } from "../index.js";
+import {
+	type FSEvent,
+	fromFSWatch,
+	fromGitHook,
+	fromSpawn,
+	type GitEvent,
+	nodeProcessDriver,
+	type ProcessResult,
+	runProcess,
+	type SpawnEvent,
+} from "../sources/node.js";
+
+const dirs: string[] = [];
+
+beforeEach(() => {
+	vi.useRealTimers();
+});
+
+afterEach(() => {
+	vi.useRealTimers();
+	for (const dir of dirs.splice(0)) rmSync(dir, { recursive: true, force: true });
+});
+
+const data = <T = FSEvent>(msgs: Message[]): T[] =>
+	msgs.filter((m) => m[0] === "DATA").map((m) => (m as ["DATA", T])[1]);
+
+async function waitFor(predicate: () => boolean): Promise<void> {
+	for (let i = 0; i < 200; i += 1) {
+		if (predicate()) return;
+		await new Promise((resolve) => setTimeout(resolve, 10));
+	}
+	expect(predicate()).toBe(true);
+}
+
+describe("node-only filesystem sources", () => {
+	it("fromFSWatch is an inspectable node-only source factory with explicit initial scan", async () => {
+		const dir = mkdtempSync(join(tmpdir(), "graphrefly-fs-"));
+		dirs.push(dir);
+		writeFileSync(join(dir, "a.txt"), "a");
+		writeFileSync(join(dir, "skip.log"), "skip");
+		const g = graph();
+		const watched = g.initNode(
+			fromFSWatch(dir, { debounceMs: 0, include: ["*.txt"], initialScan: true }),
+			[],
+			{ name: "fs" },
+		);
+		const msgs: Message[] = [];
+		const unsubscribe = watched.subscribe((msg) => msgs.push(msg));
+
+		await waitFor(() => data(msgs).length === 1);
+		unsubscribe();
+
+		const event = data(msgs)[0];
+		expect(event.type).toBe("create");
+		expect(event.path.endsWith("/a.txt")).toBe(true);
+		expect(event.relativePath).toBe("a.txt");
+		expect(g.describe().nodes.find((node) => node.id === "fs")?.factory).toBe("fromFSWatch");
+	});
+
+	it("fromFSWatch rejects an empty path list before constructing an operator", () => {
+		expect(() => fromFSWatch([])).toThrow(RangeError);
+	});
+});
+
+describe("node-only process sources", () => {
+	it("fromSpawn streams stdout/stderr and completes with an exit event", async () => {
+		const n = graph().initNode(
+			fromSpawn(process.execPath, [
+				"-e",
+				"process.stdout.write('out'); process.stderr.write('err');",
+			]),
+			[],
+		);
+		const msgs: Message[] = [];
+		n.subscribe((msg) => msgs.push(msg));
+
+		await waitFor(() => msgs.some((msg) => msg[0] === "COMPLETE"));
+
+		const events = data<SpawnEvent>(msgs);
+		expect(
+			events.some((event) => event.kind === "stdout" && event.chunk.toString() === "out"),
+		).toBe(true);
+		expect(
+			events.some((event) => event.kind === "stderr" && event.chunk.toString() === "err"),
+		).toBe(true);
+		expect(events.at(-1)).toEqual({ kind: "exit", code: 0, signal: null });
+	});
+
+	it("runProcess emits aggregate output once", async () => {
+		const n = graph().initNode(
+			runProcess(process.execPath, [
+				"-e",
+				"process.stdout.write('out'); process.stderr.write('err');",
+			]),
+			[],
+		);
+		const msgs: Message[] = [];
+		n.subscribe((msg) => msgs.push(msg));
+
+		await waitFor(() => msgs.some((msg) => msg[0] === "COMPLETE"));
+
+		expect(data<ProcessResult>(msgs)).toEqual([
+			{ stdout: "out", stderr: "err", exitCode: 0, signal: null },
+		]);
+	});
+
+	it("nodeProcessDriver backs graph-local fromProcess sources", async () => {
+		const g = graph({
+			environment: EnvironmentDrivers.empty().withProcess(nodeProcessDriver()),
+		});
+		const n = g.initNode(
+			fromProcess(process.execPath, [
+				"-e",
+				"process.stdout.write('driver-out'); process.stderr.write('driver-err');",
+			]),
+			[],
+			{ name: "driver_process" },
+		);
+		const msgs: Message[] = [];
+		n.subscribe((msg) => msgs.push(msg));
+
+		await waitFor(() => msgs.some((msg) => msg[0] === "COMPLETE"));
+
+		expect(data<ProcessResult>(msgs)).toEqual([
+			{ stdout: "driver-out", stderr: "driver-err", exitCode: 0, signal: null },
+		]);
+		expect(g.describe().nodes.find((node) => node.id === "driver_process")?.factory).toBe(
+			"fromProcess",
+		);
+	});
+
+	it("nodeProcessDriver backs graph-visible toProcess outbound bundles", async () => {
+		const g = graph({
+			environment: EnvironmentDrivers.empty().withProcess(nodeProcessDriver()),
+		});
+		const source = g.node<string>([], null, { name: "source" });
+		const bundle = toProcess(
+			g,
+			source,
+			(value) => ({
+				program: process.execPath,
+				args: ["-e", `process.stdout.write(${JSON.stringify(value)});`],
+			}),
+			{ name: "egress_process" },
+		);
+		const events: Message[] = [];
+		const statuses: Message[] = [];
+		bundle.events.subscribe((msg) => events.push(msg));
+		bundle.status.subscribe((msg) => statuses.push(msg));
+
+		source.down([["DATA", "adapter-out"]]);
+		await waitFor(() =>
+			events.some(
+				(msg) =>
+					msg[0] === "DATA" &&
+					(msg[1] as { kind?: string }).kind === "sent" &&
+					((msg[1] as { result?: ProcessResult }).result?.stdout ?? "") === "adapter-out",
+			),
+		);
+
+		expect(events).toContainEqual(["DATA", { kind: "attempt", value: "adapter-out", attempt: 1 }]);
+		expect(statuses.at(-1)).toEqual([
+			"DATA",
+			{ state: "succeeded", inFlight: 0, attempt: 1, sent: 1, failed: 0 },
+		]);
+		expect(g.describe().edges).toContainEqual({ from: "source", to: "egress_process" });
+		expect(g.describe().edges).toContainEqual({
+			from: "egress_process",
+			to: "egress_process/status",
+		});
+	});
+
+	it("nodeProcessDriver closes stdin for stdin-draining commands", async () => {
+		const driver = nodeProcessDriver();
+		let result:
+			| { readonly ok: true; readonly value: ProcessResult }
+			| { readonly ok: false; readonly error: unknown }
+			| undefined;
+		const cancel = driver.run(
+			{
+				program: process.execPath,
+				args: [
+					"-e",
+					[
+						"let stdin = '';",
+						"process.stdin.setEncoding('utf8');",
+						"process.stdin.on('data', (chunk) => { stdin += chunk; });",
+						"process.stdin.on('end', () => process.stdout.write('stdin-ended:' + stdin.length));",
+						"process.stdin.resume();",
+					].join(""),
+				],
+			},
+			(r) => {
+				result = r;
+			},
+		);
+
+		await waitFor(() => result !== undefined);
+		cancel();
+
+		expect(result).toEqual({
+			ok: true,
+			value: { stdout: "stdin-ended:0", stderr: "", exitCode: 0, signal: null },
+		});
+	});
+
+	it("nodeProcessDriver reports ERROR when captured output exceeds maxBufferBytes", async () => {
+		const driver = nodeProcessDriver({ killGraceMs: 20, maxBufferBytes: 3 });
+		let result:
+			| { readonly ok: true; readonly value: ProcessResult }
+			| { readonly ok: false; readonly error: unknown }
+			| undefined;
+		const cancel = driver.run(
+			{
+				program: process.execPath,
+				args: ["-e", "process.stdout.write('abcdef'); setInterval(() => {}, 1000);"],
+			},
+			(r) => {
+				result = r;
+			},
+		);
+
+		await waitFor(() => result !== undefined);
+		cancel();
+
+		expect(result?.ok).toBe(false);
+		expect(String(result && !result.ok ? result.error : "")).toContain("maxBufferBytes");
+	});
+
+	it("nodeProcessDriver cancellation terminates a long-running child", async () => {
+		const dir = mkdtempSync(join(tmpdir(), "graphrefly-driver-process-"));
+		dirs.push(dir);
+		const ready = join(dir, "ready.txt");
+		const marker = join(dir, "alive.txt");
+		const script = [
+			"process.on('SIGTERM', () => {});",
+			`require('node:fs').writeFileSync(${JSON.stringify(ready)}, 'ready');`,
+			`setTimeout(() => require('node:fs').writeFileSync(${JSON.stringify(marker)}, 'alive'), 200);`,
+			"setInterval(() => {}, 1000);",
+		].join("");
+		const driver = nodeProcessDriver({ killGraceMs: 20 });
+		const cancel = driver.run({ program: process.execPath, args: ["-e", script] }, () => {
+			throw new Error("canceled process should not callback");
+		});
+
+		await waitFor(() => existsSync(ready));
+		cancel();
+		await new Promise((resolve) => setTimeout(resolve, 300));
+
+		expect(existsSync(marker)).toBe(false);
+	});
+
+	it("fromSpawn escalates teardown when a child ignores SIGTERM", async () => {
+		const dir = mkdtempSync(join(tmpdir(), "graphrefly-spawn-"));
+		dirs.push(dir);
+		const marker = join(dir, "alive.txt");
+		const script = [
+			"process.stdout.write('ready');",
+			"process.on('SIGTERM', () => {});",
+			`setTimeout(() => require('node:fs').writeFileSync(${JSON.stringify(marker)}, 'alive'), 200);`,
+			"setInterval(() => {}, 1000);",
+		].join("");
+		const n = graph().initNode(
+			fromSpawn(process.execPath, ["-e", script], { killGraceMs: 20 }),
+			[],
+		);
+		const msgs: Message[] = [];
+		const unsubscribe = n.subscribe((msg) => msgs.push(msg));
+
+		await waitFor(() =>
+			data<SpawnEvent>(msgs).some(
+				(event) => event.kind === "stdout" && event.chunk.toString() === "ready",
+			),
+		);
+		unsubscribe();
+		await new Promise((resolve) => setTimeout(resolve, 300));
+
+		expect(existsSync(marker)).toBe(false);
+	});
+});
+
+function git(dir: string, args: readonly string[]): void {
+	execFileSync("git", [...args], { cwd: dir, stdio: "ignore" });
+}
+
+describe("node-only git sources", () => {
+	it("fromGitHook records the first poll as baseline and emits later commits", async () => {
+		const dir = mkdtempSync(join(tmpdir(), "graphrefly-git-"));
+		dirs.push(dir);
+		git(dir, ["init"]);
+		git(dir, ["config", "user.email", "test@example.com"]);
+		git(dir, ["config", "user.name", "GraphReFly Test"]);
+		writeFileSync(join(dir, "a.txt"), "a");
+		git(dir, ["add", "a.txt"]);
+		git(dir, ["commit", "-m", "initial"]);
+
+		const n = graph().initNode(
+			fromGitHook(dir, { pollMs: 50, include: ["*.txt"], exclude: ["skip*"] }),
+			[],
+		);
+		const msgs: Message[] = [];
+		const unsubscribe = n.subscribe((msg) => msgs.push(msg));
+		expect(data<GitEvent>(msgs)).toEqual([]);
+
+		writeFileSync(join(dir, " spaced .txt"), "b");
+		writeFileSync(join(dir, "skip.log"), "skip");
+		git(dir, ["add", "--", " spaced .txt", "skip.log"]);
+		git(dir, ["commit", "-m", "second"]);
+
+		await waitFor(() => data<GitEvent>(msgs).length === 1);
+		unsubscribe();
+
+		const event = data<GitEvent>(msgs)[0];
+		expect(event.hook).toBe("post-commit");
+		expect(event.files).toEqual([" spaced .txt"]);
+		expect(event.message).toBe("second");
+		expect(event.author).toBe("GraphReFly Test");
+		expect(typeof event.timestamp_ns).toBe("string");
+	});
+});
diff --git a/packages/ts/src/__tests__/sources.part-01.test.ts b/packages/ts/src/__tests__/sources.part-01.test.ts
new file mode 100644
index 00000000..61025457
--- /dev/null
+++ b/packages/ts/src/__tests__/sources.part-01.test.ts
@@ -0,0 +1,715 @@
+import { afterEach, beforeEach, describe, expect, expectTypeOf, it, vi } from "vitest";
+import { CTX_NODE_BINDING } from "../ctx/types.js";
+import type { Message } from "../index.js";
+import {
+	EnvironmentDrivers,
+	type FromCronOptions,
+	fromCron,
+	fromHttp,
+	fromHttpWithOptions,
+	fromProcess,
+	fromSSE,
+	fromSSEWithOptions,
+	fromTimer,
+	fromWebhook,
+	fromWebhookWithOptions,
+	fromWebSocket,
+	fromWebSocketWithOptions,
+	graph,
+	type HttpRequest,
+	type HttpResponse,
+	initNode,
+	interval,
+	type LocalHttpDriver,
+	type LocalProcessDriver,
+	type LocalSseDriver,
+	type LocalWebhookDriver,
+	type LocalWebSocketDriver,
+	matchesCron,
+	type Node,
+	type Operator,
+	type ProcessCommand,
+	type ProcessResult,
+	parseCron,
+	runProcess,
+	runProcessWithOptions,
+	type SseDriverEvent,
+	type SseEvent,
+	type SseRequest,
+	timer,
+	type WebhookDriverEvent,
+	type WebhookEvent,
+	type WebhookRegistration,
+	type WebSocketDriverEvent,
+	type WebSocketEvent,
+	type WebSocketRequest,
+} from "../index.js";
+
+const data = (msgs: Message[]) =>
+	msgs.filter((m) => m[0] === "DATA").map((m) => (m as ["DATA", unknown])[1]);
+
+const _flush = () => new Promise((r) => setTimeout(r, 0));
+
+class _FakeEventTarget {
+	readonly calls: Array<readonly ["add" | "remove", string, unknown]> = [];
+	private readonly listeners = new Map<string, Set<(event: unknown) => void>>();
+
+	addEventListener(type: string, listener: (event: unknown) => void, options?: unknown): void {
+		this.calls.push(["add", type, options]);
+		const listeners = this.listeners.get(type) ?? new Set<(event: unknown) => void>();
+		listeners.add(listener);
+		this.listeners.set(type, listeners);
+	}
+
+	removeEventListener(type: string, listener: (event: unknown) => void, options?: unknown): void {
+		this.calls.push(["remove", type, options]);
+		this.listeners.get(type)?.delete(listener);
+	}
+
+	emit(type: string, event: unknown): void {
+		for (const listener of this.listeners.get(type) ?? []) listener(event);
+	}
+}
+
+class ManualProcessDriver implements LocalProcessDriver {
+	readonly runs: Array<{
+		command: ProcessCommand;
+		active: { value: boolean };
+		callback: (result: { ok: true; value: ProcessResult } | { ok: false; error: unknown }) => void;
+	}> = [];
+
+	run(
+		command: ProcessCommand,
+		callback: (result: { ok: true; value: ProcessResult } | { ok: false; error: unknown }) => void,
+	): () => void {
+		const active = { value: true };
+		this.runs.push({ command, active, callback });
+		return () => {
+			active.value = false;
+		};
+	}
+
+	finish(result: { ok: true; value: ProcessResult } | { ok: false; error: unknown }): void {
+		const run = this.runs.shift();
+		if (run?.active.value) run.callback(result);
+	}
+
+	finishIgnoringCancel(
+		result: { ok: true; value: ProcessResult } | { ok: false; error: unknown },
+	): void {
+		this.runs.shift()?.callback(result);
+	}
+
+	activeCount(): number {
+		return this.runs.filter((run) => run.active.value).length;
+	}
+}
+
+class ManualHttpDriver implements LocalHttpDriver {
+	readonly requests: Array<{
+		request: HttpRequest;
+		active: { value: boolean };
+		callback: (result: { ok: true; value: HttpResponse } | { ok: false; error: unknown }) => void;
+	}> = [];
+
+	request(
+		request: HttpRequest,
+		callback: (result: { ok: true; value: HttpResponse } | { ok: false; error: unknown }) => void,
+	): () => void {
+		const active = { value: true };
+		this.requests.push({ request, active, callback });
+		return () => {
+			active.value = false;
+		};
+	}
+
+	finish(result: { ok: true; value: HttpResponse } | { ok: false; error: unknown }): void {
+		const request = this.requests.shift();
+		if (request?.active.value) request.callback(result);
+	}
+}
+
+class ManualSseDriver implements LocalSseDriver {
+	readonly connections: Array<{
+		request: SseRequest;
+		active: { value: boolean };
+		callback: (event: SseDriverEvent) => void;
+	}> = [];
+
+	connect(request: SseRequest, callback: (event: SseDriverEvent) => void): () => void {
+		const active = { value: true };
+		this.connections.push({ request, active, callback });
+		return () => {
+			active.value = false;
+		};
+	}
+
+	emit(event: SseDriverEvent): void {
+		const connection = this.connections[0];
+		if (connection?.active.value) connection.callback(event);
+	}
+}
+
+class ManualWebSocketDriver implements LocalWebSocketDriver {
+	readonly connections: Array<{
+		request: WebSocketRequest;
+		active: { value: boolean };
+		callback: (event: WebSocketDriverEvent) => void;
+	}> = [];
+
+	connect(request: WebSocketRequest, callback: (event: WebSocketDriverEvent) => void): () => void {
+		const active = { value: true };
+		this.connections.push({ request, active, callback });
+		return () => {
+			active.value = false;
+		};
+	}
+
+	emit(event: WebSocketDriverEvent): void {
+		const connection = this.connections[0];
+		if (connection?.active.value) connection.callback(event);
+	}
+}
+
+class ManualWebhookDriver implements LocalWebhookDriver {
+	readonly registrations: Array<{
+		registration: WebhookRegistration;
+		active: { value: boolean };
+		callback: (event: WebhookDriverEvent) => void;
+	}> = [];
+
+	register(
+		registration: WebhookRegistration,
+		callback: (event: WebhookDriverEvent) => void,
+	): () => void {
+		const active = { value: true };
+		this.registrations.push({ registration, active, callback });
+		return () => {
+			active.value = false;
+		};
+	}
+
+	emit(event: WebhookDriverEvent): void {
+		const registration = this.registrations[0];
+		if (registration?.active.value) registration.callback(event);
+	}
+
+	emitIgnoringCancel(event: WebhookDriverEvent): void {
+		this.registrations[0]?.callback(event);
+	}
+
+	activeCount(): number {
+		return this.registrations.filter((registration) => registration.active.value).length;
+	}
+}
+
+// D43/D40: async sources are binding-layer producer sugar — depless Operator specs run once on
+// activation, schedule their work, and emit later via the captured ctx.down (R-no-raw-async:
+// setTimeout/Promise confined here). Instantiated via the generic g.initNode funnel.
+describe("timer / interval sources (fake timers, D43)", () => {
+	beforeEach(() => vi.useFakeTimers());
+	afterEach(() => vi.useRealTimers());
+
+	it("timer one-shot emits DATA(0) then COMPLETE", () => {
+		const g = graph();
+		const n = g.initNode(timer(50), []);
+		const msgs: Message[] = [];
+		n.subscribe((x) => msgs.push(x));
+		vi.advanceTimersByTime(50);
+		expect(data(msgs)).toEqual([0]);
+		expect(msgs[msgs.length - 1][0]).toBe("COMPLETE");
+		expect(n.status).toBe("completed");
+	});
+
+	it("timer one-shot is canceled by deactivation before its first tick", () => {
+		const g = graph();
+		const n = g.initNode(timer(50), []);
+		const msgs: Message[] = [];
+		const unsub = n.subscribe((x) => msgs.push(x));
+		expect(vi.getTimerCount()).toBe(1);
+
+		unsub();
+		expect(vi.getTimerCount()).toBe(0);
+		vi.advanceTimersByTime(50);
+
+		expect(data(msgs)).toEqual([]);
+		expect(msgs).toEqual([["START"]]);
+	});
+
+	it("fromTimer preserves the frozen source name and supports AbortSignal", () => {
+		const g = graph();
+		const ac = new AbortController();
+		const n = g.initNode(fromTimer(50, { signal: ac.signal }), [], { name: "clock" });
+		const msgs: Message[] = [];
+		n.subscribe((x) => msgs.push(x));
+		ac.abort(false);
+		vi.advanceTimersByTime(50);
+
+		const byId = Object.fromEntries(g.describe().nodes.map((node) => [node.id, node]));
+		const last = msgs[msgs.length - 1];
+		expect(byId.clock.factory).toBe("fromTimer");
+		expect(last[0]).toBe("ERROR");
+		expect((last as ["ERROR", unknown])[1]).toBeInstanceOf(Error);
+		expect(data(msgs)).toEqual([]);
+	});
+
+	it("fromTimer reports an already-aborted signal without scheduling DATA", () => {
+		const g = graph();
+		const ac = new AbortController();
+		ac.abort(false);
+		const n = g.initNode(fromTimer(50, { signal: ac.signal }), []);
+		const msgs: Message[] = [];
+		n.subscribe((x) => msgs.push(x));
+		vi.advanceTimersByTime(50);
+
+		const last = msgs[msgs.length - 1];
+		expect(last[0]).toBe("ERROR");
+		expect((last as ["ERROR", unknown])[1]).toBeInstanceOf(Error);
+		expect(data(msgs)).toEqual([]);
+		expect(n.status).toBe("errored");
+	});
+
+	it("fromTimer periodic mode stops emitting after abort", () => {
+		const g = graph();
+		const ac = new AbortController();
+		const n = g.initNode(fromTimer(50, { period: 100, signal: ac.signal }), []);
+		const msgs: Message[] = [];
+		n.subscribe((x) => msgs.push(x));
+		vi.advanceTimersByTime(50);
+		vi.advanceTimersByTime(100);
+		ac.abort(true);
+		vi.advanceTimersByTime(500);
+
+		const last = msgs[msgs.length - 1];
+		expect(data(msgs)).toEqual([0, 1]);
+		expect(last[0]).toBe("ERROR");
+		expect((last as ["ERROR", unknown])[1]).toBeInstanceOf(Error);
+		expect(n.status).toBe("errored");
+	});
+
+	it("interval emits periodic ticks 0,1,2,…", () => {
+		const g = graph();
+		const n = g.initNode(interval(100), []);
+		const vals: number[] = [];
+		const unsub = n.subscribe((m) => {
+			if (m[0] === "DATA") vals.push(m[1] as number);
+		});
+		vi.advanceTimersByTime(100); // first tick → 0
+		vi.advanceTimersByTime(100); // → 1
+		vi.advanceTimersByTime(100); // → 2
+		expect(vals).toEqual([0, 1, 2]);
+		unsub(); // deactivate → onDeactivation clears the interval (no leak)
+	});
+
+	it("interval preserves its real source factory name in describe (D6)", () => {
+		const g = graph();
+		g.initNode(interval(100), [], { name: "ticks" });
+		const byId = Object.fromEntries(g.describe().nodes.map((node) => [node.id, node]));
+		expect(byId.ticks.factory).toBe("interval");
+	});
+
+	it("deactivation stops the source — no emit after unsubscribe (cleanup contract)", () => {
+		const g = graph();
+		const n = g.initNode(interval(100), []);
+		const vals: number[] = [];
+		const unsub = n.subscribe((m) => {
+			if (m[0] === "DATA") vals.push(m[1] as number);
+		});
+		vi.advanceTimersByTime(100); // tick 0
+		unsub(); // deactivate → ctx.onDeactivation clears the interval (D28)
+		vi.advanceTimersByTime(500); // no live timer → no further ticks
+		expect(vals).toEqual([0]); // nothing emitted after deactivation
+	});
+});
+
+describe("cron sources (B60 source-boundary re-derive)", () => {
+	beforeEach(() => vi.useFakeTimers());
+	afterEach(() => vi.useRealTimers());
+
+	it("parseCron supports lists, ranges, and steps", () => {
+		const schedule = parseCron("0,30 9-17/2 * 1-3 1-5");
+
+		expect([...schedule.minutes]).toEqual([0, 30]);
+		expect([...schedule.hours]).toEqual([9, 11, 13, 15, 17]);
+		expect([...schedule.months]).toEqual([1, 2, 3]);
+		expect([...schedule.daysOfWeek]).toEqual([1, 2, 3, 4, 5]);
+		expect(() => parseCron("60 * * * *")).toThrow(RangeError);
+		expect(() => parseCron("* * * *")).toThrow(/expected 5 fields/);
+		expect(() => parseCron("0 * * * * *")).toThrow(/expected 5 fields/);
+		expect(() => parseCron("*/5foo * * * *")).toThrow(/Invalid cron step/);
+		expect(() => parseCron("1/2/3 * * * *")).toThrow(/Invalid cron step/);
+		expect(() => parseCron("8-12bar * * * *")).toThrow(/Invalid cron field/);
+	});
+
+	it("matchesCron checks the local five-field schedule", () => {
+		const schedule = parseCron("30 8 * * 1");
+		expect(matchesCron(schedule, new Date(2026, 2, 30, 8, 30))).toBe(true);
+		expect(matchesCron(schedule, new Date(2026, 2, 30, 8, 31))).toBe(false);
+	});
+
+	it("matchesCron projects dates through an IANA timezone", () => {
+		const schedule = parseCron("30 1 * * 0");
+
+		expect(
+			matchesCron(schedule, new Date("2026-03-08T09:30:00.000Z"), {
+				timezone: "America/Los_Angeles",
+			}),
+		).toBe(true);
+		expect(
+			matchesCron(parseCron("30 2 8 3 0"), new Date("2026-03-08T10:30:00.000Z"), {
+				timezone: "America/Los_Angeles",
+			}),
+		).toBe(false);
+	});
+
+	it("fromCron emits at most once per matching minute and tears down its interval", () => {
+		const now = new Date(2026, 2, 30, 8, 30, 0);
+		vi.setSystemTime(now);
+		const g = graph();
+		const n = g.initNode(fromCron("30 8 * * 1", { tickMs: 1000 }), [], { name: "cron" });
+		const msgs: Message[] = [];
+		const unsubscribe = n.subscribe((msg) => msgs.push(msg));
+
+		const expected = (BigInt(now.getTime()) * 1_000_000n).toString();
+		expect(data(msgs)).toEqual([expected]);
+		vi.advanceTimersByTime(30_000);
+		expect(data(msgs)).toEqual([expected]);
+		expect(vi.getTimerCount()).toBe(1);
+		unsubscribe();
+		expect(vi.getTimerCount()).toBe(0);
+		expect(g.describe().nodes.find((node) => node.id === "cron")?.factory).toBe("fromCron");
+	});
+
+	it("fromCron resumes from current time without catch-up or missed-status payloads", () => {
+		const first = new Date(2026, 2, 30, 8, 30, 0);
+		const resumed = new Date(2026, 2, 30, 8, 35, 0);
+		vi.setSystemTime(first);
+		const g = graph();
+		const n = g.initNode(fromCron("* * * * *", { tickMs: 1000, output: "timestamp_ms" }), []);
+		const msgs: Message[] = [];
+		const unsubscribe = n.subscribe((msg) => msgs.push(msg));
+
+		vi.setSystemTime(new Date(resumed.getTime() - 1000));
+		vi.advanceTimersByTime(1000);
+
+		expect(data(msgs)).toEqual([first.getTime(), resumed.getTime()]);
+		expect(data(msgs)).not.toHaveLength(6);
+		for (const payload of data(msgs)) {
+			expect(typeof payload).toBe("number");
+		}
+		unsubscribe();
+	});
+
+	it("fromCron can emit Date values", () => {
+		vi.setSystemTime(new Date(2026, 2, 30, 8, 30, 0));
+		const g = graph();
+		const n = g.initNode(fromCron("30 8 * * 1", { tickMs: 1000, output: "date" }), []);
+		const msgs: Message[] = [];
+		n.subscribe((msg) => msgs.push(msg));
+
+		expect(data(msgs)[0]).toBeInstanceOf(Date);
+	});
+
+	it("fromCron validates timezone and fires a repeated DST wall-clock minute once", () => {
+		const firstRepeated = new Date("2026-11-01T08:30:00.000Z");
+		vi.setSystemTime(firstRepeated);
+		const g = graph();
+		const n = g.initNode(
+			fromCron("30 1 1 11 0", { tickMs: 60 * 60 * 1000, timezone: "America/Los_Angeles" }),
+			[],
+		);
+		const msgs: Message[] = [];
+		const unsubscribe = n.subscribe((msg) => msgs.push(msg));
+
+		expect(data(msgs)).toEqual([(BigInt(firstRepeated.getTime()) * 1_000_000n).toString()]);
+		vi.advanceTimersByTime(60 * 60 * 1000);
+		expect(data(msgs)).toHaveLength(1);
+		expect(() => fromCron("* * * * *", { timezone: "Not/A_Zone" })).toThrow(/unsupported/);
+
+		unsubscribe();
+	});
+
+	it("fromCron accepts the exported FromCronOptions type", () => {
+		const opts: FromCronOptions =
+			Math.random() > 2
+				? { output: "date", timezone: "UTC", dst: { nonexistent: "skip", repeated: "once" } }
+				: { output: "timestamp_ns" };
+
+		expectTypeOf(fromCron("* * * * *", opts)).toEqualTypeOf<
+			Operator<never, Date | number | string>
+		>();
+	});
+});
+
+describe("environment driver-backed sources (D130/D131)", () => {
+	it("empty EnvironmentDrivers is frozen to protect graph-local defaults", () => {
+		expect(Object.isFrozen(EnvironmentDrivers.empty())).toBe(true);
+	});
+
+	it("GraphOptions.environment is visible from ctx.environment", () => {
+		const process = new ManualProcessDriver();
+		const env = EnvironmentDrivers.empty().withProcess(process);
+		const g = graph({ environment: env });
+		const n = g.producer<boolean>((ctx) => {
+			ctx.down([["DATA", ctx.environment().processDriver() === process], ["COMPLETE"]]);
+		});
+
+		const msgs: Message[] = [];
+		n.subscribe((msg) => msgs.push(msg));
+
+		expect(data(msgs)).toEqual([true]);
+	});
+
+	it("graph-local helper-created nodes inherit EnvironmentDrivers", () => {
+		const driver = new ManualHttpDriver();
+		const g = graph({ environment: EnvironmentDrivers.empty().withHttp(driver) });
+		let inner: Node<HttpResponse> | undefined;
+		const outer = g.producer((ctx) => {
+			const binding = ctx[CTX_NODE_BINDING];
+			if (binding === undefined) throw new Error("missing ctx node binding");
+			inner = binding.create(() =>
+				initNode(fromHttp("https://example.test/inner"), [], {
+					dispatcher: binding.dispatcher,
+				}),
+			);
+			ctx.down([["COMPLETE"]]);
+		});
+
+		outer.subscribe(() => {});
+		expect(inner).toBeDefined();
+		const msgs: Message[] = [];
+		inner?.subscribe((msg) => msgs.push(msg));
+
+		expect(driver.requests.map((request) => request.request)).toEqual([
+			{ method: "GET", url: "https://example.test/inner" },
+		]);
+		expect(msgs).toEqual([["START"]]);
+	});
+
+	it("driver-backed source factory names are stable in describe", () => {
+		const g = graph();
+		g.initNode(runProcess("echo", ["ok"]), [], { name: "run_process" });
+		g.initNode(fromProcess("echo", ["ok"]), [], { name: "from_process" });
+		g.initNode(fromHttp("https://example.invalid"), [], { name: "from_http" });
+		g.initNode(fromSSE("https://example.invalid/events"), [], { name: "from_sse" });
+		g.initNode(fromWebSocket("wss://example.invalid/socket"), [], { name: "from_websocket" });
+		g.initNode(fromWebhook("stripe"), [], { name: "from_webhook" });
+
+		const factories = Object.fromEntries(g.describe().nodes.map((node) => [node.id, node.factory]));
+		expect(factories.run_process).toBe("runProcess");
+		expect(factories.from_process).toBe("fromProcess");
+		expect(factories.from_http).toBe("fromHttp");
+		expect(factories.from_sse).toBe("fromSSE");
+		expect(factories.from_websocket).toBe("fromWebSocket");
+		expect(factories.from_webhook).toBe("fromWebhook");
+	});
+
+	it("missing environment drivers route source activation ERROR", () => {
+		const g = graph();
+		const cases: Array<readonly [Operator<never, unknown>, string]> = [
+			[runProcess("echo", ["ok"]), "runProcess: missing process driver"],
+			[fromHttp("https://example.invalid"), "fromHttp: missing http driver"],
+			[fromSSE("https://example.invalid/events"), "fromSSE: missing sse driver"],
+			[fromWebSocket("wss://example.invalid/socket"), "fromWebSocket: missing websocket driver"],
+			[fromWebhook("stripe"), "fromWebhook: missing webhook driver"],
+		];
+
+		for (const [op, expected] of cases) {
+			const node = g.initNode(op, []);
+			const msgs: Message[] = [];
+			node.subscribe((msg) => msgs.push(msg));
+			expect(msgs[msgs.length - 1]).toEqual(["ERROR", expected]);
+		}
+	});
+
+	it("runProcess/fromProcess use the graph-local process driver", () => {
+		const driver = new ManualProcessDriver();
+		const g = graph({ environment: EnvironmentDrivers.empty().withProcess(driver) });
+		const node = g.initNode(runProcessWithOptions({ program: "echo", args: ["ok"] }), []);
+		const msgs: Message[] = [];
+		node.subscribe((msg) => msgs.push(msg));
+
+		expect(driver.runs.map((run) => run.command)).toEqual([{ program: "echo", args: ["ok"] }]);
+		driver.finish({
+			ok: true,
+			value: { stdout: "ok\n", stderr: "", exitCode: 0, signal: null },
+		});
+
+		expect(data(msgs)).toEqual([{ stdout: "ok\n", stderr: "", exitCode: 0, signal: null }]);
+		expect(msgs[msgs.length - 1][0]).toBe("COMPLETE");
+
+		const alias = g.initNode(fromProcess("echo", ["again"]), []);
+		const aliasMsgs: Message[] = [];
+		alias.subscribe((msg) => aliasMsgs.push(msg));
+		expect(driver.runs.map((run) => run.command)).toEqual([{ program: "echo", args: ["again"] }]);
+		expect(aliasMsgs).toEqual([["START"]]);
+	});
+
+	it("driver cancel errors do not suppress one-shot terminal delivery", () => {
+		let callback:
+			| ((result: { ok: true; value: ProcessResult } | { ok: false; error: unknown }) => void)
+			| undefined;
+		const driver: LocalProcessDriver = {
+			run(_command, cb) {
+				callback = cb;
+				return () => {
+					throw new Error("cancel failed");
+				};
+			},
+		};
+		const g = graph({ environment: EnvironmentDrivers.empty().withProcess(driver) });
+		const node = g.initNode(runProcess("echo", ["ok"]), []);
+		const msgs: Message[] = [];
+		node.subscribe((msg) => msgs.push(msg));
+
+		callback?.({
+			ok: true,
+			value: { stdout: "ok\n", stderr: "", exitCode: 0, signal: null },
+		});
+
+		expect(data(msgs)).toEqual([{ stdout: "ok\n", stderr: "", exitCode: 0, signal: null }]);
+		expect(msgs[msgs.length - 1][0]).toBe("COMPLETE");
+	});
+
+	it("one-shot driver start errors route to graph-visible ERROR", () => {
+		const driver: LocalHttpDriver = {
+			request() {
+				throw new Error("request setup failed");
+			},
+		};
+		const g = graph({ environment: EnvironmentDrivers.empty().withHttp(driver) });
+		const node = g.initNode(fromHttp("https://example.test/fail"), []);
+		const msgs: Message[] = [];
+
+		expect(() => node.subscribe((msg) => msgs.push(msg))).not.toThrow();
+		expect(msgs[msgs.length - 1][0]).toBe("ERROR");
+	});
+
+	it("fromHttp uses the graph-local HTTP driver", () => {
+		const driver = new ManualHttpDriver();
+		const g = graph({ environment: EnvironmentDrivers.empty().withHttp(driver) });
+		const node = g.initNode(
+			fromHttpWithOptions({
+				method: "POST",
+				url: "https://example.test/resource",
+				headers: [["content-type", "application/json"]],
+				body: "{}",
+			}),
+			[],
+		);
+		const msgs: Message[] = [];
+		node.subscribe((msg) => msgs.push(msg));
+
+		expect(driver.requests.map((request) => request.request)).toEqual([
+			{
+				method: "POST",
+				url: "https://example.test/resource",
+				headers: [["content-type", "application/json"]],
+				body: "{}",
+			},
+		]);
+		const response: HttpResponse = {
+			status: 202,
+			headers: [["x-test", "yes"]],
+			body: new Uint8Array([1, 2, 3]),
+		};
+		driver.finish({ ok: true, value: response });
+
+		expect(data(msgs)).toEqual([response]);
+		expect(msgs[msgs.length - 1][0]).toBe("COMPLETE");
+	});
+
+	it("fromSSE and fromWebSocket emit stream driver events", () => {
+		const sseDriver = new ManualSseDriver();
+		const wsDriver = new ManualWebSocketDriver();
+		const g = graph({
+			environment: EnvironmentDrivers.empty().withSse(sseDriver).withWebSocket(wsDriver),
+		});
+		const sse = g.initNode(fromSSEWithOptions({ url: "https://example.test/events" }), []);
+		const ws = g.initNode(fromWebSocketWithOptions({ url: "wss://example.test/socket" }), []);
+		const sseMsgs: Message[] = [];
+		const wsMsgs: Message[] = [];
+		sse.subscribe((msg) => sseMsgs.push(msg));
+		ws.subscribe((msg) => wsMsgs.push(msg));
+
+		const sseEvent: SseEvent = { event: "message", data: "hello", id: "1", retryMs: 1000 };
+		const wsEvent: WebSocketEvent = { kind: "text", data: "hello" };
+		sseDriver.emit({ kind: "event", event: sseEvent });
+		sseDriver.emit({ kind: "complete" });
+		wsDriver.emit({ kind: "event", event: { kind: "open" } });
+		wsDriver.emit({ kind: "event", event: wsEvent });
+		wsDriver.emit({ kind: "complete" });
+
+		expect(data(sseMsgs)).toEqual([sseEvent]);
+		expect(sseMsgs[sseMsgs.length - 1][0]).toBe("COMPLETE");
+		expect(data(wsMsgs)).toEqual([{ kind: "open" }, wsEvent]);
+		expect(wsMsgs[wsMsgs.length - 1][0]).toBe("COMPLETE");
+	});
+
+	it("stream driver start errors route to graph-visible ERROR", () => {
+		const driver: LocalWebhookDriver = {
+			register() {
+				throw new Error("register setup failed");
+			},
+		};
+		const g = graph({ environment: EnvironmentDrivers.empty().withWebhook(driver) });
+		const node = g.initNode(fromWebhook("github"), []);
+		const msgs: Message[] = [];
+
+		expect(() => node.subscribe((msg) => msgs.push(msg))).not.toThrow();
+		expect(msgs[msgs.length - 1][0]).toBe("ERROR");
+	});
+
+	it("fromWebhook registers the graph-local webhook bridge and fences late callbacks", () => {
+		const driver = new ManualWebhookDriver();
+		const registration: WebhookRegistration = { id: "stripe", method: "POST", path: "/stripe" };
+		const g = graph({ environment: EnvironmentDrivers.empty().withWebhook(driver) });
+		const node = g.initNode(fromWebhookWithOptions(registration), []);
+		const msgs: Message[] = [];
+		node.subscribe((msg) => msgs.push(msg));
+
+		expect(driver.registrations.map((entry) => entry.registration)).toEqual([registration]);
+		const event: WebhookEvent = {
+			registrationId: "stripe",
+			method: "POST",
+			path: "/stripe",
+			headers: [["content-type", "application/json"]],
+			query: [["source", "test"]],
+			body: new Uint8Array([123, 125]),
+		};
+		driver.emit({ kind: "event", event });
+		driver.emit({ kind: "complete" });
+		expect(driver.activeCount()).toBe(0);
+		driver.emitIgnoringCancel({
+			kind: "event",
+			event: { ...event, body: new Uint8Array([108, 97, 116, 101]) },
+		});
+
+		expect(data(msgs)).toEqual([event]);
+		expect(msgs[msgs.length - 1][0]).toBe("COMPLETE");
+	});
+
+	it("fromWebhook unsubscribe cancels registration and suppresses late events", () => {
+		const driver = new ManualWebhookDriver();
+		const g = graph({ environment: EnvironmentDrivers.empty().withWebhook(driver) });
+		const node = g.initNode(fromWebhook("github"), []);
+		const msgs: Message[] = [];
+		const unsubscribe = node.subscribe((msg) => msgs.push(msg));
+
+		unsubscribe();
+		expect(driver.activeCount()).toBe(0);
+		driver.emitIgnoringCancel({
+			kind: "event",
+			event: {
+				registrationId: "github",
+				method: "POST",
+				path: "/github",
+				headers: [],
+				query: [],
+				body: new Uint8Array([1]),
+			},
+		});
+
+		expect(msgs).toEqual([["START"]]);
+	});
+});
diff --git a/packages/ts/src/__tests__/sources.part-02.test.ts b/packages/ts/src/__tests__/sources.part-02.test.ts
new file mode 100644
index 00000000..8ece1737
--- /dev/null
+++ b/packages/ts/src/__tests__/sources.part-02.test.ts
@@ -0,0 +1,654 @@
+import { describe, expect, it } from "vitest";
+import type { Message } from "../index.js";
+import {
+	empty,
+	firstValueFrom,
+	fromAny,
+	fromAsyncIter,
+	fromEvent,
+	fromIter,
+	fromPromise,
+	fromPushNotification,
+	graph,
+	type HttpRequest,
+	type HttpResponse,
+	type LocalHttpDriver,
+	type LocalProcessDriver,
+	type LocalSseDriver,
+	type LocalWebhookDriver,
+	type LocalWebSocketDriver,
+	never,
+	of,
+	type ProcessCommand,
+	type ProcessResult,
+	type SseDriverEvent,
+	type SseRequest,
+	singleFromAny,
+	throwError,
+	timer,
+	type WebhookDriverEvent,
+	type WebhookRegistration,
+	type WebSocketDriverEvent,
+	type WebSocketRequest,
+} from "../index.js";
+
+const data = (msgs: Message[]) =>
+	msgs.filter((m) => m[0] === "DATA").map((m) => (m as ["DATA", unknown])[1]);
+
+const flush = () => new Promise((r) => setTimeout(r, 0));
+
+class FakeEventTarget {
+	readonly calls: Array<readonly ["add" | "remove", string, unknown]> = [];
+	private readonly listeners = new Map<string, Set<(event: unknown) => void>>();
+
+	addEventListener(type: string, listener: (event: unknown) => void, options?: unknown): void {
+		this.calls.push(["add", type, options]);
+		const listeners = this.listeners.get(type) ?? new Set<(event: unknown) => void>();
+		listeners.add(listener);
+		this.listeners.set(type, listeners);
+	}
+
+	removeEventListener(type: string, listener: (event: unknown) => void, options?: unknown): void {
+		this.calls.push(["remove", type, options]);
+		this.listeners.get(type)?.delete(listener);
+	}
+
+	emit(type: string, event: unknown): void {
+		for (const listener of this.listeners.get(type) ?? []) listener(event);
+	}
+}
+
+class _ManualProcessDriver implements LocalProcessDriver {
+	readonly runs: Array<{
+		command: ProcessCommand;
+		active: { value: boolean };
+		callback: (result: { ok: true; value: ProcessResult } | { ok: false; error: unknown }) => void;
+	}> = [];
+
+	run(
+		command: ProcessCommand,
+		callback: (result: { ok: true; value: ProcessResult } | { ok: false; error: unknown }) => void,
+	): () => void {
+		const active = { value: true };
+		this.runs.push({ command, active, callback });
+		return () => {
+			active.value = false;
+		};
+	}
+
+	finish(result: { ok: true; value: ProcessResult } | { ok: false; error: unknown }): void {
+		const run = this.runs.shift();
+		if (run?.active.value) run.callback(result);
+	}
+
+	finishIgnoringCancel(
+		result: { ok: true; value: ProcessResult } | { ok: false; error: unknown },
+	): void {
+		this.runs.shift()?.callback(result);
+	}
+
+	activeCount(): number {
+		return this.runs.filter((run) => run.active.value).length;
+	}
+}
+
+class _ManualHttpDriver implements LocalHttpDriver {
+	readonly requests: Array<{
+		request: HttpRequest;
+		active: { value: boolean };
+		callback: (result: { ok: true; value: HttpResponse } | { ok: false; error: unknown }) => void;
+	}> = [];
+
+	request(
+		request: HttpRequest,
+		callback: (result: { ok: true; value: HttpResponse } | { ok: false; error: unknown }) => void,
+	): () => void {
+		const active = { value: true };
+		this.requests.push({ request, active, callback });
+		return () => {
+			active.value = false;
+		};
+	}
+
+	finish(result: { ok: true; value: HttpResponse } | { ok: false; error: unknown }): void {
+		const request = this.requests.shift();
+		if (request?.active.value) request.callback(result);
+	}
+}
+
+class _ManualSseDriver implements LocalSseDriver {
+	readonly connections: Array<{
+		request: SseRequest;
+		active: { value: boolean };
+		callback: (event: SseDriverEvent) => void;
+	}> = [];
+
+	connect(request: SseRequest, callback: (event: SseDriverEvent) => void): () => void {
+		const active = { value: true };
+		this.connections.push({ request, active, callback });
+		return () => {
+			active.value = false;
+		};
+	}
+
+	emit(event: SseDriverEvent): void {
+		const connection = this.connections[0];
+		if (connection?.active.value) connection.callback(event);
+	}
+}
+
+class _ManualWebSocketDriver implements LocalWebSocketDriver {
+	readonly connections: Array<{
+		request: WebSocketRequest;
+		active: { value: boolean };
+		callback: (event: WebSocketDriverEvent) => void;
+	}> = [];
+
+	connect(request: WebSocketRequest, callback: (event: WebSocketDriverEvent) => void): () => void {
+		const active = { value: true };
+		this.connections.push({ request, active, callback });
+		return () => {
+			active.value = false;
+		};
+	}
+
+	emit(event: WebSocketDriverEvent): void {
+		const connection = this.connections[0];
+		if (connection?.active.value) connection.callback(event);
+	}
+}
+
+class _ManualWebhookDriver implements LocalWebhookDriver {
+	readonly registrations: Array<{
+		registration: WebhookRegistration;
+		active: { value: boolean };
+		callback: (event: WebhookDriverEvent) => void;
+	}> = [];
+
+	register(
+		registration: WebhookRegistration,
+		callback: (event: WebhookDriverEvent) => void,
+	): () => void {
+		const active = { value: true };
+		this.registrations.push({ registration, active, callback });
+		return () => {
+			active.value = false;
+		};
+	}
+
+	emit(event: WebhookDriverEvent): void {
+		const registration = this.registrations[0];
+		if (registration?.active.value) registration.callback(event);
+	}
+
+	emitIgnoringCancel(event: WebhookDriverEvent): void {
+		this.registrations[0]?.callback(event);
+	}
+
+	activeCount(): number {
+		return this.registrations.filter((registration) => registration.active.value).length;
+	}
+}
+
+describe("promise / iterable / coercion sources (D43)", () => {
+	it("fromPromise resolves to DATA then COMPLETE", async () => {
+		const g = graph();
+		const n = g.initNode(fromPromise(Promise.resolve(7)), []);
+		const msgs: Message[] = [];
+		n.subscribe((x) => msgs.push(x));
+		await flush();
+		expect(data(msgs)).toEqual([7]);
+		expect(msgs[msgs.length - 1][0]).toBe("COMPLETE");
+	});
+
+	it("fromPromise unsubscribe suppresses late DATA + COMPLETE", async () => {
+		const g = graph();
+		let resolve!: (value: number) => void;
+		const p = new Promise<number>((r) => {
+			resolve = r;
+		});
+		const n = g.initNode(fromPromise(p), []);
+		const msgs: Message[] = [];
+		const unsub = n.subscribe((x) => msgs.push(x));
+
+		unsub();
+		resolve(7);
+		await flush();
+
+		expect(msgs).toEqual([["START"]]);
+		expect(data(msgs)).toEqual([]);
+	});
+
+	it("fromPromise rejects to ERROR", async () => {
+		const g = graph();
+		const boom = new Error("boom");
+		const n = g.initNode(fromPromise(Promise.reject(boom)), []);
+		const msgs: Message[] = [];
+		n.subscribe((x) => msgs.push(x));
+		await flush();
+		const last = msgs[msgs.length - 1];
+		expect(last[0]).toBe("ERROR");
+		expect((last as ["ERROR", unknown])[1]).toBe(boom);
+		expect(n.status).toBe("errored");
+	});
+
+	it("fromPromise rejecting with undefined/boolean → clean ERROR, never invalid ERROR payload", async () => {
+		const g = graph();
+		for (const reason of [undefined, false, true]) {
+			const n = g.initNode(fromPromise(Promise.reject(reason)), []);
+			const msgs: Message[] = [];
+			n.subscribe((x) => msgs.push(x));
+			await flush();
+			const last = msgs[msgs.length - 1];
+			expect(last[0]).toBe("ERROR");
+			expect((last as ["ERROR", unknown])[1]).toBeInstanceOf(Error);
+			expect(n.status).toBe("errored");
+		}
+	});
+
+	it("fromAsyncIter emits each value then COMPLETE", async () => {
+		async function* gen() {
+			yield 1;
+			yield 2;
+			yield 3;
+		}
+		const g = graph();
+		const n = g.initNode(fromAsyncIter(gen()), []);
+		const msgs: Message[] = [];
+		n.subscribe((x) => msgs.push(x));
+		await flush();
+		expect(data(msgs)).toEqual([1, 2, 3]);
+		expect(msgs[msgs.length - 1][0]).toBe("COMPLETE");
+	});
+
+	it("fromAsyncIter reports async iterator failure as ERROR after prior DATA", async () => {
+		async function* throwingGen() {
+			yield 1;
+			throw new Error("async iter boom");
+		}
+		const g = graph();
+		const n = g.initNode(fromAsyncIter(throwingGen()), []);
+		const msgs: Message[] = [];
+		n.subscribe((x) => msgs.push(x));
+		await flush();
+
+		expect(data(msgs)).toEqual([1]);
+		const last = msgs[msgs.length - 1];
+		expect(last[0]).toBe("ERROR");
+		expect((last as ["ERROR", unknown])[1]).toBeInstanceOf(Error);
+		expect((last as ["ERROR", Error])[1].message).toBe("async iter boom");
+		expect(n.status).toBe("errored");
+	});
+
+	it("of emits a single value then COMPLETE synchronously", () => {
+		const g = graph();
+		const n = g.initNode(of(42), []);
+		const msgs: Message[] = [];
+		n.subscribe((x) => msgs.push(x));
+		expect(data(msgs)).toEqual([42]);
+		expect(msgs[msgs.length - 1][0]).toBe("COMPLETE");
+	});
+
+	it("of emits variadic values; of() is terminal-only EMPTY", () => {
+		const g = graph();
+		const many = g.initNode(of(1, 2, 3), []);
+		const manyMsgs: Message[] = [];
+		many.subscribe((x) => manyMsgs.push(x));
+		expect(data(manyMsgs)).toEqual([1, 2, 3]);
+		expect(manyMsgs[manyMsgs.length - 1][0]).toBe("COMPLETE");
+
+		const none = g.initNode(of(), []);
+		const noneMsgs: Message[] = [];
+		none.subscribe((x) => noneMsgs.push(x));
+		expect(data(noneMsgs)).toEqual([]);
+		expect(noneMsgs[noneMsgs.length - 1][0]).toBe("COMPLETE");
+	});
+
+	it("fromIter emits each value then COMPLETE synchronously", () => {
+		const g = graph();
+		const n = g.initNode(fromIter([1, 2, 3]), []);
+		const vals: unknown[] = [];
+		n.subscribe((m) => {
+			if (m[0] === "DATA") vals.push(m[1]);
+		});
+		expect(vals).toEqual([1, 2, 3]);
+	});
+
+	it("fromIter reports a throwing iterator as ERROR after prior DATA", () => {
+		function* throwingIter() {
+			yield 1;
+			throw new Error("iter boom");
+		}
+		const g = graph();
+		const n = g.initNode(fromIter(throwingIter()), []);
+		const msgs: Message[] = [];
+		n.subscribe((x) => msgs.push(x));
+
+		expect(data(msgs)).toEqual([1]);
+		const last = msgs[msgs.length - 1];
+		expect(last[0]).toBe("ERROR");
+		expect((last as ["ERROR", unknown])[1]).toBeInstanceOf(Error);
+		expect((last as ["ERROR", Error])[1].message).toBe("iter boom");
+		expect(n.status).toBe("errored");
+	});
+
+	it("empty completes without DATA", () => {
+		const g = graph();
+		const n = g.initNode(empty<number>(), []);
+		const msgs: Message[] = [];
+		n.subscribe((x) => msgs.push(x));
+		expect(data(msgs)).toEqual([]);
+		expect(msgs[msgs.length - 1][0]).toBe("COMPLETE");
+		expect(n.status).toBe("completed");
+	});
+
+	it("never stays silent after START until deactivation", () => {
+		const g = graph();
+		const n = g.initNode(never<number>(), []);
+		const msgs: Message[] = [];
+		const unsub = n.subscribe((x) => msgs.push(x));
+		expect(msgs).toEqual([["START"]]);
+		expect(n.status).toBe("sentinel");
+		unsub();
+	});
+
+	it("throwError emits a valid ERROR payload on activation", () => {
+		const g = graph();
+		for (const err of [undefined, false, true]) {
+			const n = g.initNode(throwError(err), []);
+			const msgs: Message[] = [];
+			n.subscribe((x) => msgs.push(x));
+			const last = msgs[msgs.length - 1];
+			expect(last[0]).toBe("ERROR");
+			expect((last as ["ERROR", unknown])[1]).toBeInstanceOf(Error);
+			expect(n.status).toBe("errored");
+		}
+	});
+
+	it("fromAny passes an existing Node through", () => {
+		const g = graph();
+		const s = g.state(1);
+		expect(fromAny(s)).toBe(s);
+	});
+
+	it("fromAny lifts a Promise via fromPromise", async () => {
+		const n = fromAny(Promise.resolve(9));
+		const msgs: Message[] = [];
+		n.subscribe((x) => msgs.push(x));
+		await flush();
+		expect(data(msgs)).toEqual([9]);
+	});
+
+	it("fromAny lifts an async iterable before treating it as a scalar", async () => {
+		async function* gen() {
+			yield 1;
+			yield 2;
+		}
+		const n = fromAny(gen());
+		const msgs: Message[] = [];
+		n.subscribe((x) => msgs.push(x));
+		await flush();
+		expect(data(msgs)).toEqual([1, 2]);
+		expect(msgs[msgs.length - 1][0]).toBe("COMPLETE");
+	});
+
+	it("fromAny expands a sync iterable only with {iter:true}", () => {
+		const expanded = fromAny([1, 2, 3], { iter: true });
+		const vals: unknown[] = [];
+		expanded.subscribe((m) => {
+			if (m[0] === "DATA") vals.push(m[1]);
+		});
+		expect(vals).toEqual([1, 2, 3]);
+
+		// default: the array is a single scalar DATA value (of)
+		const scalar = fromAny([1, 2, 3]);
+		const got: unknown[] = [];
+		scalar.subscribe((m) => {
+			if (m[0] === "DATA") got.push(m[1]);
+		});
+		expect(got).toEqual([[1, 2, 3]]);
+	});
+
+	it("fromAny treats null as a valid scalar DATA value (R-data-payload)", () => {
+		const n = fromAny(null);
+		const msgs: Message[] = [];
+		n.subscribe((x) => msgs.push(x));
+
+		expect(data(msgs)).toEqual([null]);
+		expect(msgs[msgs.length - 1][0]).toBe("COMPLETE");
+		expect(n.status).toBe("completed");
+	});
+
+	it("fromAny rejects undefined as DATA because it is the protocol SENTINEL", () => {
+		const n = fromAny(undefined);
+		const msgs: Message[] = [];
+		n.subscribe((x) => msgs.push(x));
+
+		expect(data(msgs)).toEqual([]);
+		const last = msgs[msgs.length - 1];
+		expect(last[0]).toBe("ERROR");
+		expect((last as ["ERROR", unknown])[1]).toBeInstanceOf(Error);
+		expect(n.status).toBe("errored");
+	});
+
+	it("describe shows the source factory name (D6)", () => {
+		const g = graph();
+		g.initNode(timer(1000), [], { name: "clock" });
+		const snap = g.describe();
+		const byId = Object.fromEntries(snap.nodes.map((n) => [n.id, n]));
+		expect(byId.clock.factory).toBe("timer");
+	});
+
+	it("firstValueFrom resolves first DATA and unsubscribes safely from sync push", async () => {
+		const g = graph();
+		const n = g.state(42);
+
+		await expect(firstValueFrom(n)).resolves.toBe(42);
+	});
+
+	it("firstValueFrom rejects on ERROR or COMPLETE before DATA", async () => {
+		await expect(firstValueFrom(fromAny(undefined))).rejects.toThrow(/SENTINEL|valid value/);
+		await expect(firstValueFrom(fromAny([], { iter: true }))).rejects.toThrow(/without DATA/);
+	});
+
+	it("singleFromAny dedupes concurrent calls and clears the entry after settle", async () => {
+		let calls = 0;
+		let resolve!: (value: string) => void;
+		const fn = singleFromAny<string, string>((key) => {
+			calls += 1;
+			return new Promise<string>((r) => {
+				resolve = r;
+			}).then((value) => `${key}:${value}`);
+		});
+
+		const a = fn("x");
+		const b = fn("x");
+		expect(calls).toBe(1);
+
+		resolve("ok");
+		await expect(Promise.all([a, b])).resolves.toEqual(["x:ok", "x:ok"]);
+
+		let callsAfter = 0;
+		const sync = singleFromAny<string, number>((key) => {
+			callsAfter += 1;
+			return Number(key);
+		});
+		await sync("2");
+		await sync("2");
+		expect(callsAfter).toBe(2);
+	});
+
+	it("singleFromAny dedupes same-key synchronous reentrancy", async () => {
+		let calls = 0;
+		let fn!: (key: string) => Promise<string>;
+		fn = singleFromAny<string, string>((key) => {
+			calls += 1;
+			if (calls === 1) void fn(key);
+			return `${key}:outer`;
+		});
+
+		await expect(fn("x")).resolves.toBe("x:outer");
+		expect(calls).toBe(1);
+	});
+
+	it("singleFromAny uses identity keys by default and keyOf for structural dedupe", async () => {
+		let identityCalls = 0;
+		const identity = singleFromAny<{ id: number }, string>((key) => {
+			identityCalls += 1;
+			return `id:${key.id}`;
+		});
+		const shared = { id: 1 };
+		await Promise.all([identity(shared), identity(shared)]);
+		await Promise.all([identity({ id: 1 }), identity({ id: 1 })]);
+		expect(identityCalls).toBe(3);
+
+		let structuralCalls = 0;
+		const structural = singleFromAny<{ id: number }, string>(
+			(key) => {
+				structuralCalls += 1;
+				return `id:${key.id}`;
+			},
+			{ keyOf: (key) => key.id },
+		);
+		await Promise.all([structural({ id: 1 }), structural({ id: 1 })]);
+		expect(structuralCalls).toBe(1);
+	});
+
+	it("singleFromAny bridges Nodes, errors, and empty sources through firstValueFrom", async () => {
+		const g = graph();
+		const state = g.state(5);
+		const errorNode = g.initNode(throwError(new Error("boom")), []);
+		const emptyNode = g.initNode(empty<number>(), []);
+
+		await expect(singleFromAny<string, number>(() => state)("node")).resolves.toBe(5);
+		await expect(singleFromAny<string, number>(() => errorNode)("err")).rejects.toThrow("boom");
+		await expect(singleFromAny<string, number>(() => emptyNode)("empty")).rejects.toThrow(
+			/without DATA/,
+		);
+	});
+
+	it("singleFromAny treats sync iterables as scalar by default and first-value streams with iter:true", async () => {
+		const scalar = singleFromAny<string, number[]>(() => [1, 2, 3]);
+		await expect(scalar("a")).resolves.toEqual([1, 2, 3]);
+
+		const first = singleFromAny<string, number>(() => [1, 2, 3], { iter: true });
+		await expect(first("a")).resolves.toBe(1);
+	});
+
+	it("singleFromAny rejects undefined successes from async and iterable inputs", async () => {
+		const promiseValue = singleFromAny<string, undefined>(() => Promise.resolve(undefined));
+		await expect(promiseValue("promise")).rejects.toThrow(/SENTINEL/);
+
+		async function* asyncValues() {
+			yield undefined;
+		}
+		const asyncValue = singleFromAny<string, undefined>(() => asyncValues());
+		await expect(asyncValue("async")).rejects.toThrow(/SENTINEL/);
+
+		const iterValue = singleFromAny<string, undefined>(() => [undefined], { iter: true });
+		await expect(iterValue("iter")).rejects.toThrow(/SENTINEL/);
+	});
+
+	it("singleFromAny closes async iterables after the first value", async () => {
+		let closed = false;
+		async function* gen() {
+			try {
+				yield 1;
+				yield 2;
+			} finally {
+				closed = true;
+			}
+		}
+		const fn = singleFromAny<string, number>(() => gen());
+
+		await expect(fn("iter")).resolves.toBe(1);
+		expect(closed).toBe(true);
+	});
+
+	it("singleFromAny keeps the first iterable value when close fails after reading it", async () => {
+		const iterable = {
+			[Symbol.iterator](): Iterator<number> {
+				return {
+					next: () => ({ value: 1, done: false }),
+					return: () => {
+						throw new Error("close failed");
+					},
+				};
+			},
+		};
+		const syncValue = singleFromAny<string, number>(() => iterable, { iter: true });
+		await expect(syncValue("sync")).resolves.toBe(1);
+
+		const asyncIterable = {
+			[Symbol.asyncIterator](): AsyncIterator<number> {
+				return {
+					next: async () => ({ value: 2, done: false }),
+					return: async () => {
+						throw new Error("close failed");
+					},
+				};
+			},
+		};
+		const asyncValue = singleFromAny<string, number>(() => asyncIterable);
+		await expect(asyncValue("async")).resolves.toBe(2);
+	});
+});
+
+describe("external callback sources (D43)", () => {
+	it("fromEvent turns listener callbacks into DATA and removes the listener on deactivation", () => {
+		const target = new FakeEventTarget();
+		const opts = { capture: true, passive: true };
+		const g = graph();
+		const n = g.initNode(fromEvent<{ x: number }>(target, "message", opts), [], {
+			name: "events",
+		});
+		const msgs: Message[] = [];
+		const unsubscribe = n.subscribe((x) => msgs.push(x));
+
+		target.emit("message", { x: 1 });
+		target.emit("other", { x: 2 });
+		unsubscribe();
+		target.emit("message", { x: 3 });
+
+		expect(data(msgs)).toEqual([{ x: 1 }]);
+		expect(target.calls).toEqual([
+			["add", "message", opts],
+			["remove", "message", opts],
+		]);
+		expect(g.describe().nodes.find((node) => node.id === "events")?.factory).toBe("fromEvent");
+	});
+
+	it("fromPushNotification delivers host pushes and calls the returned unsubscribe", () => {
+		let deliver!: (payload: string) => void;
+		let unsubscribed = false;
+		const g = graph();
+		const n = g.initNode(
+			fromPushNotification<string>((next) => {
+				deliver = next;
+				return () => {
+					unsubscribed = true;
+				};
+			}),
+			[],
+			{ name: "pushes" },
+		);
+		const msgs: Message[] = [];
+		const unsubscribe = n.subscribe((x) => msgs.push(x));
+
+		deliver("a");
+		unsubscribe();
+		deliver("b");
+
+		expect(data(msgs)).toEqual(["a"]);
+		expect(unsubscribed).toBe(true);
+		expect(g.describe().nodes.find((node) => node.id === "pushes")?.factory).toBe(
+			"fromPushNotification",
+		);
+	});
+
+	it("fromEvent and fromPushNotification validate their host boundary inputs", () => {
+		expect(() => fromEvent({} as never, "message")).toThrow(TypeError);
+		expect(() => fromEvent(new FakeEventTarget(), "")).toThrow(TypeError);
+		expect(() => fromPushNotification(0 as never)).toThrow(TypeError);
+	});
+});
diff --git a/packages/ts/src/__tests__/storage-browser.test.ts b/packages/ts/src/__tests__/storage-browser.test.ts
new file mode 100644
index 00000000..b9999a9f
--- /dev/null
+++ b/packages/ts/src/__tests__/storage-browser.test.ts
@@ -0,0 +1,395 @@
+import { describe, expect, it } from "vitest";
+import * as storageBrowser from "../storage/browser.js";
+import { hasStorageVersioned, requireStorageVersioned } from "../storage/index.js";
+
+const flush = () => new Promise((resolve) => setTimeout(resolve, 0));
+
+const withIndexedDbUnavailable = async (fn: () => Promise<void>) => {
+	const descriptor = Reflect.getOwnPropertyDescriptor(globalThis, "indexedDB");
+	delete (globalThis as { indexedDB?: unknown }).indexedDB;
+	try {
+		await fn();
+	} finally {
+		if (descriptor) {
+			Object.defineProperty(globalThis, "indexedDB", descriptor);
+		} else {
+			delete (globalThis as { indexedDB?: unknown }).indexedDB;
+		}
+	}
+};
+
+const withIndexedDbMock = async (indexedDb: IDBFactory, fn: () => Promise<void>): Promise<void> => {
+	const descriptor = Reflect.getOwnPropertyDescriptor(globalThis, "indexedDB");
+	Object.defineProperty(globalThis, "indexedDB", {
+		configurable: true,
+		value: indexedDb,
+	});
+	try {
+		await fn();
+	} finally {
+		if (descriptor) {
+			Object.defineProperty(globalThis, "indexedDB", descriptor);
+		} else {
+			delete (globalThis as { indexedDB?: unknown }).indexedDB;
+		}
+	}
+};
+
+describe("storage/browser (D103/D106)", () => {
+	it("exports the passive browser IndexedDB storage helpers", () => {
+		expect(typeof storageBrowser.indexedDbBackend).toBe("function");
+		expect(typeof storageBrowser.indexedDbKv).toBe("function");
+		expect(typeof storageBrowser.indexedDbAppendLog).toBe("function");
+	});
+
+	it("formats backend.name as idb:{dbName}/{storeName}", () => {
+		const dbName = "gft-db";
+		const storeName = "gft-store";
+
+		const backend = storageBrowser.indexedDbBackend({ dbName, storeName });
+		expect(backend.name).toBe(`idb:${dbName}/${storeName}`);
+	});
+
+	it("does not claim D108 versioned support without IndexedDB generation metadata", () => {
+		const backend = storageBrowser.indexedDbBackend({ dbName: "gft-db", storeName: "kv" });
+
+		expect(hasStorageVersioned(backend)).toBe(false);
+		expect(() => requireStorageVersioned(backend, "indexedDbBackend")).toThrow(
+			/indexedDbBackend: backend does not support versioned get\/set-if-match/,
+		);
+	});
+
+	it("rejects with a clear error when indexedDB is unavailable", async () => {
+		await withIndexedDbUnavailable(async () => {
+			const backend = storageBrowser.indexedDbBackend({ dbName: "gft-db", storeName: "kv" });
+			await expect(backend.get("missing")).rejects.toThrow(
+				"indexedDbBackend: indexedDB is not available in this environment",
+			);
+		});
+	});
+
+	it("opens existing databases without forcing version 1 when version is omitted", async () => {
+		let openedVersion: number | undefined;
+		const fakeStore = {
+			get() {
+				const req: Partial<IDBRequest> = {};
+				queueMicrotask(() => {
+					req.result = undefined;
+					req.onsuccess?.call(req as IDBRequest, new Event("success"));
+				});
+				return req as IDBRequest;
+			},
+		};
+		const fakeDb = {
+			objectStoreNames: { contains: () => true },
+			transaction: () => ({
+				objectStore: () => fakeStore,
+			}),
+		};
+		const fakeIndexedDb = {
+			open(_name: string, version?: number) {
+				openedVersion = version;
+				const req: Partial<IDBOpenDBRequest> = {};
+				queueMicrotask(() => {
+					req.result = fakeDb as IDBDatabase;
+					req.onsuccess?.call(req as IDBOpenDBRequest, new Event("success"));
+				});
+				return req as IDBOpenDBRequest;
+			},
+		} as IDBFactory;
+
+		await withIndexedDbMock(fakeIndexedDb, async () => {
+			const backend = storageBrowser.indexedDbBackend({ dbName: "gft-db", storeName: "kv" });
+			await expect(backend.get("missing")).resolves.toBeUndefined();
+		});
+
+		expect(openedVersion).toBeUndefined();
+	});
+
+	it("does not cache a rejected IndexedDB open forever", async () => {
+		let opens = 0;
+		const fakeStore = {
+			get() {
+				const req: Partial<IDBRequest> = {};
+				queueMicrotask(() => {
+					req.result = undefined;
+					req.onsuccess?.call(req as IDBRequest, new Event("success"));
+				});
+				return req as IDBRequest;
+			},
+		};
+		const fakeDb = {
+			objectStoreNames: { contains: () => true },
+			transaction: () => ({
+				objectStore: () => fakeStore,
+			}),
+		};
+		const fakeIndexedDb = {
+			open() {
+				opens += 1;
+				const req: Partial<IDBOpenDBRequest> = {};
+				queueMicrotask(() => {
+					if (opens === 1) {
+						req.error = new Error("transient open failure") as DOMException;
+						req.onerror?.call(req as IDBOpenDBRequest, new Event("error"));
+						return;
+					}
+					req.result = fakeDb as IDBDatabase;
+					req.onsuccess?.call(req as IDBOpenDBRequest, new Event("success"));
+				});
+				return req as IDBOpenDBRequest;
+			},
+		} as IDBFactory;
+
+		await withIndexedDbMock(fakeIndexedDb, async () => {
+			const backend = storageBrowser.indexedDbBackend({ dbName: "gft-db", storeName: "kv" });
+			await expect(backend.get("missing")).rejects.toThrow("transient open failure");
+			await expect(backend.get("missing")).resolves.toBeUndefined();
+		});
+
+		expect(opens).toBe(2);
+	});
+
+	it("fails fast on non-string or ambiguous IndexedDB runtime keys", () => {
+		const backend = storageBrowser.indexedDbBackend({ dbName: "gft-db", storeName: "kv" });
+
+		expect(() => backend.get(1 as unknown as string)).toThrow(/key must be a string/);
+		expect(() => backend.put("bad\u0000key", new Uint8Array([1]))).toThrow(/U\+0000/);
+		expect(() => backend.putIfAbsent?.(1 as unknown as string, new Uint8Array([1]))).toThrow(
+			/key must be a string/,
+		);
+		expect(() => backend.delete(1 as unknown as string)).toThrow(/key must be a string/);
+		expect(() => backend.list("bad\u0000prefix")).toThrow(/U\+0000/);
+		expect(() => backend.list(1 as unknown as string)).toThrow(/list prefix must be a string/);
+	});
+
+	it("rejects malformed IndexedDB stored values as corruption", async () => {
+		const fakeStore = {
+			get() {
+				const req: Partial<IDBRequest> = {};
+				queueMicrotask(() => {
+					req.result = { bytes: [1, 2, 3] };
+					req.onsuccess?.call(req as IDBRequest, new Event("success"));
+				});
+				return req as IDBRequest;
+			},
+		};
+		const fakeDb = {
+			objectStoreNames: { contains: () => true },
+			transaction: () => ({
+				objectStore: () => fakeStore as unknown as IDBObjectStore,
+			}),
+		};
+		const fakeIndexedDb = {
+			open() {
+				const req: Partial<IDBOpenDBRequest> = {};
+				queueMicrotask(() => {
+					req.result = fakeDb as IDBDatabase;
+					req.onsuccess?.call(req as IDBOpenDBRequest, new Event("success"));
+				});
+				return req as IDBOpenDBRequest;
+			},
+		} as IDBFactory;
+
+		await withIndexedDbMock(fakeIndexedDb, async () => {
+			const backend = storageBrowser.indexedDbBackend({ dbName: "gft-db", storeName: "kv" });
+			await expect(backend.get("bad")).rejects.toThrow(/malformed stored bytes/);
+		});
+	});
+
+	it("rejects non-string IndexedDB list keys without String projection", async () => {
+		const fakeStore = {
+			getAllKeys() {
+				const req: Partial<IDBRequest> = {};
+				queueMicrotask(() => {
+					req.result = ["cache/1", 2, "cache/3"];
+					req.onsuccess?.call(req as IDBRequest, new Event("success"));
+				});
+				return req as IDBRequest;
+			},
+		};
+		const fakeDb = {
+			objectStoreNames: { contains: () => true },
+			transaction: () => ({
+				objectStore: () => fakeStore as unknown as IDBObjectStore,
+			}),
+		};
+		const fakeIndexedDb = {
+			open() {
+				const req: Partial<IDBOpenDBRequest> = {};
+				queueMicrotask(() => {
+					req.result = fakeDb as IDBDatabase;
+					req.onsuccess?.call(req as IDBOpenDBRequest, new Event("success"));
+				});
+				return req as IDBOpenDBRequest;
+			},
+		} as IDBFactory;
+
+		await withIndexedDbMock(fakeIndexedDb, async () => {
+			const backend = storageBrowser.indexedDbBackend({ dbName: "gft-db", storeName: "kv" });
+			await expect(backend.list("cache/")).rejects.toThrow(/stored key must be a string/);
+		});
+	});
+
+	it("sorts IndexedDB list results deterministically without prefix projection", async () => {
+		const fakeStore = {
+			getAllKeys() {
+				const req: Partial<IDBRequest> = {};
+				queueMicrotask(() => {
+					req.result = ["cache/2", "other/0", "cache/10", "cache/1"];
+					req.onsuccess?.call(req as IDBRequest, new Event("success"));
+				});
+				return req as IDBRequest;
+			},
+		};
+		const fakeDb = {
+			objectStoreNames: { contains: () => true },
+			transaction: () => ({
+				objectStore: () => fakeStore as unknown as IDBObjectStore,
+			}),
+		};
+		const fakeIndexedDb = {
+			open() {
+				const req: Partial<IDBOpenDBRequest> = {};
+				queueMicrotask(() => {
+					req.result = fakeDb as IDBDatabase;
+					req.onsuccess?.call(req as IDBOpenDBRequest, new Event("success"));
+				});
+				return req as IDBOpenDBRequest;
+			},
+		} as IDBFactory;
+
+		await withIndexedDbMock(fakeIndexedDb, async () => {
+			const backend = storageBrowser.indexedDbBackend({ dbName: "gft-db", storeName: "kv" });
+			await expect(backend.list("cache/")).resolves.toEqual(["cache/1", "cache/10", "cache/2"]);
+		});
+	});
+
+	it("rejects instead of hanging when an IndexedDB upgrade is blocked", async () => {
+		const existingDb = {
+			version: 1,
+			close() {
+				/* no-op */
+			},
+			objectStoreNames: { contains: () => false },
+		};
+		const fakeIndexedDb = {
+			open(_name: string, version?: number) {
+				const req: Partial<IDBOpenDBRequest> = {};
+				queueMicrotask(() => {
+					if (version === undefined) {
+						req.result = existingDb as IDBDatabase;
+						req.onsuccess?.call(req as IDBOpenDBRequest, new Event("success"));
+						return;
+					}
+					req.onblocked?.call(req as IDBOpenDBRequest, new Event("blocked"));
+				});
+				return req as IDBOpenDBRequest;
+			},
+		} as IDBFactory;
+
+		await withIndexedDbMock(fakeIndexedDb, async () => {
+			const backend = storageBrowser.indexedDbBackend({ dbName: "gft-db", storeName: "kv" });
+			await expect(backend.get("missing")).rejects.toThrow(
+				"indexedDbBackend: open blocked; close existing database connections and retry",
+			);
+		});
+	});
+
+	it("rejects putIfAbsent for non-conflict IndexedDB write failures", async () => {
+		const fakeStore = {
+			add() {
+				const req: Partial<IDBRequest> = {};
+				queueMicrotask(() => {
+					req.error = new DOMException("bad key", "DataError");
+					req.onerror?.call(req as IDBRequest, new Event("error"));
+				});
+				return req as IDBRequest;
+			},
+		};
+		const fakeDb = {
+			objectStoreNames: { contains: () => true },
+			transaction: () => {
+				const tx: Partial<IDBTransaction> = {
+					objectStore: () => fakeStore as unknown as IDBObjectStore,
+				};
+				queueMicrotask(() => {
+					tx.error = new DOMException("bad key", "DataError");
+					tx.onerror?.call(tx as IDBTransaction, new Event("error"));
+				});
+				return tx as IDBTransaction;
+			},
+		};
+		const fakeIndexedDb = {
+			open() {
+				const req: Partial<IDBOpenDBRequest> = {};
+				queueMicrotask(() => {
+					req.result = fakeDb as IDBDatabase;
+					req.onsuccess?.call(req as IDBOpenDBRequest, new Event("success"));
+				});
+				return req as IDBOpenDBRequest;
+			},
+		} as IDBFactory;
+
+		await withIndexedDbMock(fakeIndexedDb, async () => {
+			const backend = storageBrowser.indexedDbBackend({ dbName: "gft-db", storeName: "kv" });
+			await expect(backend.putIfAbsent?.("bad key", new Uint8Array([1]))).rejects.toThrow(
+				"bad key",
+			);
+		});
+	});
+
+	it("resolves putIfAbsent success only after the transaction commits", async () => {
+		let settled = false;
+		let tx: Partial<IDBTransaction> | undefined;
+		const fakeStore = {
+			add() {
+				const req: Partial<IDBRequest> = {};
+				queueMicrotask(() => {
+					req.onsuccess?.call(req as IDBRequest, new Event("success"));
+				});
+				return req as IDBRequest;
+			},
+		};
+		const fakeDb = {
+			objectStoreNames: { contains: () => true },
+			transaction: () => {
+				tx = {
+					objectStore: () => fakeStore as unknown as IDBObjectStore,
+				};
+				return tx as IDBTransaction;
+			},
+		};
+		const fakeIndexedDb = {
+			open() {
+				const req: Partial<IDBOpenDBRequest> = {};
+				queueMicrotask(() => {
+					req.result = fakeDb as IDBDatabase;
+					req.onsuccess?.call(req as IDBOpenDBRequest, new Event("success"));
+				});
+				return req as IDBOpenDBRequest;
+			},
+		} as IDBFactory;
+
+		await withIndexedDbMock(fakeIndexedDb, async () => {
+			const backend = storageBrowser.indexedDbBackend({ dbName: "gft-db", storeName: "kv" });
+			const result = backend.putIfAbsent?.("k", new Uint8Array([1])).then((value) => {
+				settled = true;
+				return value;
+			});
+			await flush();
+			expect(settled).toBe(false);
+
+			tx?.oncomplete?.call(tx as IDBTransaction, new Event("complete"));
+
+			await expect(result).resolves.toBe(true);
+			expect(settled).toBe(true);
+		});
+	});
+
+	it("does not export retired snapshot/WAL APIs", () => {
+		expect(Object.hasOwn(storageBrowser, "attachSnapshotStorage")).toBe(false);
+		expect(Object.hasOwn(storageBrowser, "restoreSnapshot")).toBe(false);
+		expect(Object.hasOwn(storageBrowser, "replayWal")).toBe(false);
+	});
+});
diff --git a/packages/ts/src/__tests__/storage.attachobservesink-observe-driven-storage-binding-d57-d74.test.ts b/packages/ts/src/__tests__/storage.attachobservesink-observe-driven-storage-binding-d57-d74.test.ts
new file mode 100644
index 00000000..737b03c4
--- /dev/null
+++ b/packages/ts/src/__tests__/storage.attachobservesink-observe-driven-storage-binding-d57-d74.test.ts
@@ -0,0 +1,365 @@
+import { mkdtempSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { describe, expect, it, vi } from "vitest";
+import { attachObserveSink, type ObserveSinkErrorContext } from "../adapters/observe-storage.js";
+import type { ObserveEvent } from "../index.js";
+import { graph } from "../index.js";
+
+interface TestStorage {
+	entries: Record<string, string>;
+	getItem(key: string): string | null;
+	setItem(key: string, value: string): void;
+	removeItem(key: string): void;
+	key(index: number): string | null;
+	length: number;
+}
+
+const _createStorage = (): TestStorage => {
+	const entries: Record<string, string> = {};
+	const storage: TestStorage = {
+		get entries() {
+			return entries;
+		},
+		getItem(key) {
+			return entries[key] ?? null;
+		},
+		setItem(key, value) {
+			entries[key] = value;
+		},
+		removeItem(key) {
+			delete entries[key];
+		},
+		key(index) {
+			const keys = Object.keys(entries).sort();
+			return keys[index] ?? null;
+		},
+		get length() {
+			return Object.keys(entries).length;
+		},
+	};
+	return storage;
+};
+
+const _makeTempDir = () => mkdtempSync(join(tmpdir(), "graphrefly-ts-storage-"));
+
+const flushMicrotasks = async (turns = 1) => {
+	for (let i = 0; i < turns; i += 1) await Promise.resolve();
+};
+
+const awaitDone = (run: (done: () => void) => void) =>
+	new Promise<void>((resolve) => {
+		run(resolve);
+	});
+
+const bytesToHex = (bytes: Uint8Array) =>
+	[...bytes].map((byte) => byte.toString(16).padStart(2, "0")).join("");
+
+const _sha256Hex = async (bytes: Uint8Array) =>
+	bytesToHex(new Uint8Array(await globalThis.crypto.subtle.digest("SHA-256", bytes)));
+
+describe("attachObserveSink — observe-driven storage binding (D57/D74)", () => {
+	it("writes filtered observe events in graph order", () => {
+		const g = graph();
+		const a = g.state(0, { name: "a" });
+		const _b = g.derived([a], (n) => n + 1, { name: "b" });
+		const events: ObserveEvent[] = [];
+
+		const handle = attachObserveSink(
+			g,
+			{ write: (event) => void events.push(event) },
+			{ path: "b" },
+		);
+
+		a.set(1);
+		a.set(2);
+		handle.flush();
+
+		expect(events.every((event) => event.path === "b")).toBe(true);
+		expect(events.map((event) => event.seq)).toEqual(
+			[...events.map((event) => event.seq)].sort((x, y) => x - y),
+		);
+		expect(events.filter((event) => event.msg[0] === "DATA").map((event) => event.msg[1])).toEqual([
+			1, 2, 3,
+		]);
+
+		handle.dispose();
+	});
+
+	it("serializes thenable writes so later events wait for earlier ones", async () => {
+		const g = graph();
+		const count = g.state(0, { name: "count" });
+		const started: number[] = [];
+		const finished: number[] = [];
+		const releases: Array<() => void> = [];
+
+		const handle = attachObserveSink(
+			g,
+			{
+				write: (value) => {
+					started.push(value);
+					return new Promise<void>((resolve) => {
+						releases.push(() => {
+							finished.push(value);
+							resolve();
+						});
+					});
+				},
+			},
+			{
+				path: "count",
+				map: (event) => (event.msg[0] === "DATA" ? (event.msg[1] as number) : undefined),
+			},
+		);
+
+		count.set(1);
+		count.set(2);
+		expect(started).toEqual([0]);
+
+		releases.shift()?.();
+		await flushMicrotasks();
+		expect(started).toEqual([0, 1]);
+
+		releases.shift()?.();
+		await flushMicrotasks();
+		expect(started).toEqual([0, 1, 2]);
+
+		const flushed = awaitDone((done) => handle.flush(done));
+		releases.shift()?.();
+		await flushed;
+		expect(finished).toEqual([0, 1, 2]);
+
+		handle.dispose();
+	});
+
+	it("routes sync throws and thenable rejections to onError and keeps draining", async () => {
+		const g = graph();
+		const count = g.state(0, { name: "count" });
+		const values: number[] = [];
+		const errors: Array<{ message: string; ctx: ObserveSinkErrorContext<number> }> = [];
+
+		const handle = attachObserveSink<number>(
+			g,
+			{
+				write: (value) => {
+					if (value === 1) throw new Error("sync boom");
+					if (value === 2) return Promise.reject(new Error("async boom"));
+					values.push(value);
+				},
+			},
+			{
+				path: "count",
+				map: (event) => (event.msg[0] === "DATA" ? (event.msg[1] as number) : undefined),
+				onError: (error, ctx) => {
+					errors.push({ message: (error as Error).message, ctx });
+				},
+			},
+		);
+
+		count.set(1);
+		count.set(2);
+		count.set(3);
+		await awaitDone((done) => handle.flush(done));
+
+		expect(values).toEqual([0, 3]);
+		expect(
+			errors.map(({ message, ctx }) => ({ message, phase: ctx.phase, value: ctx.value })),
+		).toEqual([
+			{ message: "sync boom", phase: "write", value: 1 },
+			{ message: "async boom", phase: "write", value: 2 },
+		]);
+
+		handle.dispose();
+	});
+
+	it("routes malformed thenables to onError without wedging the queue", async () => {
+		const g = graph();
+		const count = g.state(0, { name: "count" });
+		const values: number[] = [];
+		const errors: Array<{ message: string; ctx: ObserveSinkErrorContext<number> }> = [];
+
+		const handle = attachObserveSink<number>(
+			g,
+			{
+				write: (value) => {
+					if (value === 1) {
+						const malformed = {};
+						Object.defineProperty(malformed, ["th", "en"].join(""), {
+							get() {
+								throw new Error("bad then");
+							},
+						});
+						return malformed as PromiseLike<void>;
+					}
+					values.push(value);
+				},
+			},
+			{
+				path: "count",
+				map: (event) => (event.msg[0] === "DATA" ? (event.msg[1] as number) : undefined),
+				onError: (error, ctx) => {
+					errors.push({ message: (error as Error).message, ctx });
+				},
+			},
+		);
+
+		count.set(1);
+		count.set(2);
+		await awaitDone((done) => handle.flush(done));
+
+		expect(values).toEqual([0, 2]);
+		expect(
+			errors.map(({ message, ctx }) => ({ message, phase: ctx.phase, value: ctx.value })),
+		).toEqual([{ message: "bad then", phase: "write", value: 1 }]);
+
+		handle.dispose();
+	});
+
+	it("serializes flush/rollback/dispose and stops observing after dispose", async () => {
+		const g = graph();
+		const count = g.state(0, { name: "count" });
+		const calls: string[] = [];
+
+		const handle = attachObserveSink<number>(
+			g,
+			{
+				write: (value) => void calls.push(`write:${value}`),
+				flush: () => void calls.push("flush"),
+				rollback: () => void calls.push("rollback"),
+				dispose: () => void calls.push("dispose"),
+			},
+			{
+				path: "count",
+				map: (event) => (event.msg[0] === "DATA" ? (event.msg[1] as number) : undefined),
+			},
+		);
+
+		count.set(1);
+		const order: string[] = [];
+		handle.flush(() => order.push("flush.done"));
+		handle.rollback(() => order.push("rollback.done"));
+		await awaitDone((done) =>
+			handle.dispose(() => {
+				order.push("dispose.done");
+				done();
+			}),
+		);
+
+		expect(calls).toEqual(["write:0", "write:1", "flush", "rollback", "dispose"]);
+		expect(order).toEqual(["flush.done", "rollback.done", "dispose.done"]);
+
+		count.set(2);
+		handle.flush();
+		expect(calls).toEqual(["write:0", "write:1", "flush", "rollback", "dispose"]);
+	});
+
+	it("coalesces repeated dispose callbacks until pending work drains", async () => {
+		const g = graph();
+		const count = g.state(0, { name: "count" });
+		const started: number[] = [];
+		const releases: Array<() => void> = [];
+		const done: string[] = [];
+
+		const handle = attachObserveSink<number>(
+			g,
+			{
+				write: (value) => {
+					started.push(value);
+					return new Promise<void>((resolve) => {
+						releases.push(resolve);
+					});
+				},
+			},
+			{
+				path: "count",
+				map: (event) => (event.msg[0] === "DATA" ? (event.msg[1] as number) : undefined),
+			},
+		);
+
+		count.set(1);
+		handle.dispose(() => done.push("first"));
+		handle.dispose(() => done.push("second"));
+
+		expect(started).toEqual([0]);
+		expect(done).toEqual([]);
+
+		releases.shift()?.();
+		await flushMicrotasks();
+		expect(started).toEqual([0, 1]);
+		expect(done).toEqual([]);
+
+		releases.shift()?.();
+		await flushMicrotasks();
+		expect(done).toEqual(["first", "second"]);
+
+		handle.dispose(() => done.push("third"));
+		expect(done).toEqual(["first", "second", "third"]);
+	});
+
+	it("reports mapper failures without invoking sink.write", async () => {
+		const g = graph();
+		const count = g.state(0, { name: "count" });
+		const write = vi.fn((value: number) => void value);
+		const errors: ObserveSinkErrorContext<number>[] = [];
+
+		const handle = attachObserveSink<number>(
+			g,
+			{ write },
+			{
+				path: "count",
+				map: (event) => {
+					if (event.msg[0] !== "DATA") return undefined;
+					const value = event.msg[1] as number;
+					if (value === 1) throw new Error("bad map");
+					return value;
+				},
+				onError: (_error, ctx) => {
+					errors.push(ctx);
+				},
+			},
+		);
+
+		count.set(1);
+		count.set(2);
+		handle.flush();
+
+		expect(write.mock.calls.map(([value]) => value)).toEqual([0, 2]);
+		expect(errors).toEqual([{ phase: "map", event: expect.objectContaining({ path: "count" }) }]);
+
+		handle.dispose();
+	});
+
+	it("calls done even when adapter hooks reject or throw, while routing failures to onError", async () => {
+		const g = graph();
+		const count = g.state(0, { name: "count" });
+		const phases: string[] = [];
+
+		const handle = attachObserveSink<number>(
+			g,
+			{
+				write: (value) => {
+					if (value === 1) throw new Error("write fail");
+				},
+				flush: () => Promise.reject(new Error("flush fail")),
+				rollback: () => {
+					throw new Error("rollback fail");
+				},
+				dispose: () => Promise.reject(new Error("dispose fail")),
+			},
+			{
+				path: "count",
+				map: (event) => (event.msg[0] === "DATA" ? (event.msg[1] as number) : undefined),
+				onError: (_error, ctx) => {
+					phases.push(ctx.phase);
+				},
+			},
+		);
+
+		count.set(1);
+		await awaitDone((done) => handle.flush(done));
+		await awaitDone((done) => handle.rollback(done));
+		await awaitDone((done) => handle.dispose(done));
+
+		expect(phases).toEqual(["write", "flush", "rollback", "dispose"]);
+	});
+});
diff --git a/packages/ts/src/__tests__/storage.d82-storage-substrate-helpers-part-01.sub-01.test.ts b/packages/ts/src/__tests__/storage.d82-storage-substrate-helpers-part-01.sub-01.test.ts
new file mode 100644
index 00000000..d9bb9b47
--- /dev/null
+++ b/packages/ts/src/__tests__/storage.d82-storage-substrate-helpers-part-01.sub-01.test.ts
@@ -0,0 +1,619 @@
+import { mkdtempSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { describe, expect, it, vi } from "vitest";
+import type { KvStorageTier } from "../index.js";
+import {
+	assertDecimalIntegerString,
+	assertNonNegativeDecimalIntegerString,
+	assertStrictJsonObject,
+	assertStrictJsonValue,
+	bigIntToDecimalString,
+	bigIntToNonNegativeDecimalString,
+	ContentAddressedMissError,
+	changeEnvelopeCodec,
+	contentAddressedKv,
+	contentAddressedStorage,
+	decimalStringToBigInt,
+	envelopeChange,
+	isDecimalIntegerString,
+	isNonNegativeDecimalIntegerString,
+	jsonCodecFor,
+	kvStorage,
+	listByPrefix,
+	memoryKv,
+	nonNegativeDecimalStringToBigInt,
+	nowNs,
+	readThroughKv,
+	type StrictJsonObject,
+	type StrictJsonValue,
+	stableJsonString,
+	strictCanonicalJsonBytes,
+	strictJsonCodec,
+	strictJsonCodecFor,
+	tieredReadThrough,
+} from "../index.js";
+
+interface TestStorage {
+	entries: Record<string, string>;
+	getItem(key: string): string | null;
+	setItem(key: string, value: string): void;
+	removeItem(key: string): void;
+	key(index: number): string | null;
+	length: number;
+}
+
+const _createStorage = (): TestStorage => {
+	const entries: Record<string, string> = {};
+	const storage: TestStorage = {
+		get entries() {
+			return entries;
+		},
+		getItem(key) {
+			return entries[key] ?? null;
+		},
+		setItem(key, value) {
+			entries[key] = value;
+		},
+		removeItem(key) {
+			delete entries[key];
+		},
+		key(index) {
+			const keys = Object.keys(entries).sort();
+			return keys[index] ?? null;
+		},
+		get length() {
+			return Object.keys(entries).length;
+		},
+	};
+	return storage;
+};
+
+const _makeTempDir = () => mkdtempSync(join(tmpdir(), "graphrefly-ts-storage-"));
+
+const _flushMicrotasks = async (turns = 1) => {
+	for (let i = 0; i < turns; i += 1) await Promise.resolve();
+};
+
+const _awaitDone = (run: (done: () => void) => void) =>
+	new Promise<void>((resolve) => {
+		run(resolve);
+	});
+
+const bytesToHex = (bytes: Uint8Array) =>
+	[...bytes].map((byte) => byte.toString(16).padStart(2, "0")).join("");
+
+const sha256Hex = async (bytes: Uint8Array) =>
+	bytesToHex(new Uint8Array(await globalThis.crypto.subtle.digest("SHA-256", bytes)));
+
+describe("D82 storage substrate helpers — sub 1", () => {
+	it("stableJsonString sorts object keys deterministically", () => {
+		expect(stableJsonString({ b: 2, a: { d: 4, c: 3 } })).toBe('{"a":{"c":3,"d":4},"b":2}');
+	});
+
+	it("stableJsonString rejects unsupported top-level JSON values", () => {
+		expect(() => stableJsonString(undefined)).toThrow(/not JSON-encodable/);
+		expect(() => stableJsonString(() => undefined)).toThrow(/not JSON-encodable/);
+	});
+
+	it("stableJsonString rejects nested lossy JSON values and non-plain objects", () => {
+		const cyclic: { self?: unknown } = {};
+		cyclic.self = cyclic;
+		const sparse: unknown[] = [];
+		sparse[1] = "hole";
+		const arrayWithExtra = [1] as Array<unknown> & { extra?: number };
+		arrayWithExtra.extra = 2;
+		const arrayWithSymbol = [1] as Array<unknown> & { [key: symbol]: number };
+		arrayWithSymbol[Symbol("extra")] = 2;
+		const symbolKey = Symbol("secret");
+		expect(() => stableJsonString({ nested: undefined })).toThrow(/not JSON-encodable/);
+		expect(() => stableJsonString({ nested: 1n })).toThrow(/not JSON-encodable/);
+		expect(() => stableJsonString(cyclic)).toThrow(/circular/);
+		expect(() => stableJsonString({ sparse })).toThrow(/sparse array hole/);
+		expect(() => stableJsonString(arrayWithExtra)).toThrow(/non-index array property/);
+		expect(() => stableJsonString(arrayWithSymbol)).toThrow(/symbol-keyed/);
+		expect(() => stableJsonString({ [symbolKey]: 1 })).toThrow(/symbol-keyed/);
+		expect(() => stableJsonString(new Date(0))).toThrow(/non-plain object/);
+		expect(() => stableJsonString(Number.NaN)).toThrow(/non-finite/);
+	});
+
+	it("__proto__ remains ordinary data under stableJsonString", () => {
+		expect(stableJsonString(JSON.parse('{"__proto__":{"x":1},"a":2}'))).toBe(
+			'{"__proto__":{"x":1},"a":2}',
+		);
+	});
+
+	it("nowNs returns a D84 decimal timestamp string", () => {
+		const spy = vi.spyOn(Date, "now").mockReturnValue(1_700_000_000_123);
+		try {
+			const timestamp = nowNs();
+			expect(timestamp).toBe("1700000000123000000");
+			expect(BigInt(timestamp)).toBe(1_700_000_000_123_000_000n);
+			expect(timestamp).toMatch(/^(0|[1-9]\d*)$/);
+		} finally {
+			spy.mockRestore();
+		}
+	});
+
+	it("D88 decimal scalar helpers keep BigInt conversion explicit", () => {
+		expect(bigIntToDecimalString(-12n)).toBe("-12");
+		expect(bigIntToDecimalString(0n)).toBe("0");
+		expect(bigIntToNonNegativeDecimalString(12n)).toBe("12");
+		expect(() => bigIntToNonNegativeDecimalString(-1n)).toThrow(/non-negative/);
+
+		expect(decimalStringToBigInt("-12")).toBe(-12n);
+		expect(decimalStringToBigInt("0")).toBe(0n);
+		expect(nonNegativeDecimalStringToBigInt("12")).toBe(12n);
+		expect(() => nonNegativeDecimalStringToBigInt("-12")).toThrow(/non-negative/);
+		expect(assertDecimalIntegerString("-12")).toBe("-12");
+		expect(assertNonNegativeDecimalIntegerString("12")).toBe("12");
+		expect(() => assertDecimalIntegerString("01")).toThrow(/decimal integer/);
+		expect(() => assertNonNegativeDecimalIntegerString("-12")).toThrow(/non-negative/);
+		expect(isDecimalIntegerString("-12")).toBe(true);
+		expect(isDecimalIntegerString("-0")).toBe(false);
+		expect(isDecimalIntegerString("01")).toBe(false);
+		expect(isNonNegativeDecimalIntegerString("12")).toBe(true);
+		expect(isNonNegativeDecimalIntegerString("-12")).toBe(false);
+	});
+
+	it("envelopeChange defaults t_ns to a D84 string timestamp", () => {
+		const spy = vi.spyOn(Date, "now").mockReturnValue(42);
+		try {
+			const envelope = envelopeChange({ op: "set" }, { structure: "kv-change" });
+			expect(envelope.t_ns).toBe("42000000");
+			expect(typeof envelope.t_ns).toBe("string");
+		} finally {
+			spy.mockRestore();
+		}
+	});
+
+	it("envelopeChange rejects caller-supplied non-canonical t_ns", () => {
+		expect(() => envelopeChange({ op: "set" }, { structure: "kv-change", t_ns: "01" })).toThrow(
+			/t_ns/,
+		);
+	});
+
+	it("changeEnvelopeCodec rejects numeric, unsafe, and non-decimal t_ns", () => {
+		const codec = changeEnvelopeCodec<{ op: string }>();
+		const encodeRaw = (t_ns: unknown) =>
+			strictJsonCodec.encode({
+				lifecycle: "data",
+				structure: "kv-change",
+				version: 1,
+				t_ns,
+				change: { op: "set" },
+			});
+
+		for (const bad of [123, Number.MAX_SAFE_INTEGER + 1, "1.5", "1e3", "-1", "", "01"]) {
+			expect(() => codec.decode(encodeRaw(bad))).toThrow(/t_ns/);
+		}
+		expect(codec.decode(encodeRaw("1700000000123000000")).t_ns).toBe("1700000000123000000");
+	});
+
+	it("strictJsonCodec accepts canonical stable JSON bytes", () => {
+		const bytes = strictJsonCodec.encode({ b: 2, a: { d: 4, c: 3 } });
+		expect(new TextDecoder().decode(bytes)).toBe('{"a":{"c":3,"d":4},"b":2}');
+		expect(strictJsonCodec.decode(bytes)).toEqual({ a: { c: 3, d: 4 }, b: 2 });
+		expect(strictJsonCodecFor<{ a: number }>().decode(new TextEncoder().encode('{"a":1}'))).toEqual(
+			{
+				a: 1,
+			},
+		);
+	});
+
+	it("strictJsonCodec rejects non-portable JSON number values (D88/D112)", () => {
+		const encoder = new TextEncoder();
+		for (const bad of [-0, Number.MAX_SAFE_INTEGER + 1, Number.MIN_VALUE]) {
+			expect(() => stableJsonString(bad)).not.toThrow();
+			expect(() => jsonCodecFor<unknown>().encode(bad)).not.toThrow();
+			expect(() => strictJsonCodec.encode(bad)).toThrow(/non-canonical|safe range|subnormal/);
+			expect(() => strictCanonicalJsonBytes(bad)).toThrow(/non-canonical|safe range|subnormal/);
+		}
+		expect(() => strictJsonCodec.decode(encoder.encode("-0"))).toThrow(/canonical/);
+		expect(() => strictJsonCodec.decode(encoder.encode("9007199254740992"))).toThrow(/safe range/);
+		expect(() => strictJsonCodec.decode(encoder.encode("5e-324"))).toThrow(/subnormal/);
+		expect(strictJsonCodec.decode(encoder.encode("9007199254740991"))).toBe(
+			Number.MAX_SAFE_INTEGER,
+		);
+	});
+
+	it("strictCanonicalJsonBytes is the D113 neutral strict JSON byte helper", () => {
+		const value = { b: 2, a: { d: 4, c: 3 } };
+		const bytes = strictCanonicalJsonBytes(value);
+
+		expect(bytes).toEqual(strictJsonCodec.encode(value));
+		expect(new TextDecoder().decode(bytes)).toBe('{"a":{"c":3,"d":4},"b":2}');
+		expect(strictCanonicalJsonBytes({ a: 1, b: 2 })).toEqual(
+			strictCanonicalJsonBytes(JSON.parse('{"b":2,"a":1}')),
+		);
+		expect(() => strictCanonicalJsonBytes({ nested: undefined })).toThrow(/not JSON-encodable/);
+		expect(() => strictCanonicalJsonBytes("\uD800")).toThrow(/unpaired surrogate/);
+	});
+
+	it("strict JSON assert helpers share the public JSON vocabulary", () => {
+		const value: StrictJsonValue = assertStrictJsonValue({ b: 2, a: [true, null] });
+		const object: StrictJsonObject = assertStrictJsonObject({ b: 2, a: 1 });
+
+		expect(value).toEqual({ a: [true, null], b: 2 });
+		expect(object).toEqual({ a: 1, b: 2 });
+		expect(() => assertStrictJsonValue({ nested: undefined })).toThrow(/strict JSON compatible/);
+		expect(() => assertStrictJsonObject(["not", "object"])).toThrow(/strict JSON object/);
+	});
+
+	it("strictJsonCodec rejects non-canonical key order and whitespace bytes", () => {
+		const codec = strictJsonCodecFor<unknown>();
+		const encoder = new TextEncoder();
+
+		expect(() => codec.decode(encoder.encode('{"b":2,"a":1}'))).toThrow(/canonical/);
+		expect(() => codec.decode(encoder.encode('{ "a": 1 }'))).toThrow(/canonical/);
+	});
+
+	it("strictJsonCodec rejects duplicate object keys before JSON.parse last-wins", () => {
+		const encoder = new TextEncoder();
+
+		for (const raw of [
+			'{"a":1,"a":2}',
+			'{"a":1,"\\u0061":2}',
+			'{"a":{"b":1,"b":2}}',
+			'{"a":[{"b":1,"b":2}]}',
+		]) {
+			expect(() => strictJsonCodec.decode(encoder.encode(raw))).toThrow(/duplicate object key/);
+		}
+	});
+
+	it("strictJsonCodec rejects malformed UTF-8", () => {
+		expect(() => strictJsonCodec.decode(new Uint8Array([0xff]))).toThrow();
+	});
+
+	it("strictJsonCodec rejects unpaired surrogate strings and keys", () => {
+		const encoder = new TextEncoder();
+
+		expect(() => strictJsonCodec.encode("\uD800")).toThrow(/unpaired surrogate/);
+		expect(() => strictJsonCodec.encode({ "\uD800": "key" })).toThrow(/unpaired surrogate/);
+		expect(() => strictJsonCodec.decode(encoder.encode('"\\ud800"'))).toThrow(/unpaired surrogate/);
+	});
+
+	it("strictJsonCodec rejects lossy JSON values on encode", () => {
+		expect(() => strictJsonCodec.encode({ nested: undefined })).toThrow(/not JSON-encodable/);
+		expect(() => strictJsonCodec.encode({ nested: 1n })).toThrow(/not JSON-encodable/);
+		expect(() => strictJsonCodec.encode(Number.NaN)).toThrow(/non-finite/);
+	});
+
+	it("jsonCodecFor still decodes ordinary non-canonical JSON permissively", () => {
+		const decoded = jsonCodecFor<{ a: number; b: number }>().decode(
+			new TextEncoder().encode('{ "b": 2, "a": 1 }'),
+		);
+		expect(decoded).toEqual({ a: 1, b: 2 });
+	});
+
+	it("content-addressed KV keys are deterministic across object key order", async () => {
+		const kv = memoryKv<{ result: number }>();
+		const cache = contentAddressedKv({
+			kv,
+			keyPrefix: "calc",
+			keyContext: (ctx: { request: unknown }) => ctx.request,
+		});
+
+		const a = await cache.keyFor({ request: { b: 2, a: { d: 4, c: 3 } } });
+		const b = await cache.keyFor({ request: { a: { c: 3, d: 4 }, b: 2 } });
+
+		expect(a).toBe(b);
+		expect(a).toMatch(/^calc:[0-9a-f]{64}$/);
+		expect(a).toBe(
+			`calc:${await sha256Hex(strictCanonicalJsonBytes({ a: { c: 3, d: 4 }, b: 2 }))}`,
+		);
+	});
+
+	it("content-addressed KV snapshots canonical key bytes before async hashing", async () => {
+		const cache = contentAddressedKv<{ request: { value: number } }, { result: number }>({
+			kv: memoryKv(),
+			keyPrefix: "calc",
+			keyContext: (ctx) => ctx.request,
+		});
+		const ctx = { request: { value: 1 } };
+
+		const key = cache.keyFor(ctx);
+		ctx.request.value = 2;
+
+		await expect(key).resolves.toBe(
+			`calc:${await sha256Hex(strictCanonicalJsonBytes({ value: 1 }))}`,
+		);
+	});
+
+	it("content-addressed KV honors read, write, read-write, and read-strict modes", async () => {
+		const kv = memoryKv<{ answer: string }>();
+		const ctx = { prompt: "hello", opts: { temp: 0 } };
+
+		const writeOnly = contentAddressedKv({ kv, mode: "write" });
+		await writeOnly.store(ctx, { answer: "hi" });
+		expect(await writeOnly.lookup(ctx)).toBeUndefined();
+
+		const readOnly = contentAddressedKv({ kv, mode: "read" });
+		expect(await readOnly.lookup(ctx)).toEqual({ answer: "hi" });
+		await readOnly.store(ctx, { answer: "ignored" });
+		expect(await readOnly.lookup(ctx)).toEqual({ answer: "hi" });
+
+		const readWrite = contentAddressedStorage({ kv, mode: "read-write" });
+		await readWrite.store({ prompt: "bye" }, { answer: "goodbye" });
+		expect(await readWrite.lookup({ prompt: "bye" })).toEqual({ answer: "goodbye" });
+
+		const strict = contentAddressedKv({ kv, mode: "read-strict" });
+		await expect(strict.lookup({ prompt: "missing" })).rejects.toBeInstanceOf(
+			ContentAddressedMissError,
+		);
+	});
+
+	it("content-addressed KV reports strict miss details and rejects bad key contexts honestly", async () => {
+		const kv = memoryKv<unknown>();
+		const strict = contentAddressedKv({ kv, mode: "read-strict" });
+		const ctx = { prompt: "missing" };
+		const expectedKey = await strict.keyFor(ctx);
+
+		await expect(strict.lookup(ctx)).rejects.toMatchObject({
+			name: "ContentAddressedMissError",
+			key: expectedKey,
+			context: ctx,
+		});
+
+		const bad = contentAddressedKv<{ value: unknown }, unknown>({
+			kv,
+			keyContext: (value) => value,
+		});
+		const badCtx = { value: 1n };
+		await expect(bad.keyFor(badCtx)).rejects.toThrow(/not JSON-encodable/);
+		await expect(bad.lookup(badCtx)).rejects.toThrow(/not JSON-encodable/);
+		await expect(bad.store(badCtx, { ok: true })).rejects.toThrow(/not JSON-encodable/);
+		await expect(bad.forget(badCtx)).rejects.toThrow(/not JSON-encodable/);
+	});
+
+	it("content-addressed disallowed modes do not touch KV or validate skipped contexts", async () => {
+		const calls: string[] = [];
+		const kv: KvStorageTier<unknown> = {
+			get: (key) => {
+				calls.push(`get:${key}`);
+				return Promise.resolve(undefined);
+			},
+			set: (key) => {
+				calls.push(`set:${key}`);
+				return Promise.resolve();
+			},
+			delete: (key) => {
+				calls.push(`delete:${key}`);
+				return Promise.resolve();
+			},
+			list: () => Promise.resolve([]),
+		};
+		const cyclic: { self?: unknown } = {};
+		cyclic.self = cyclic;
+
+		await expect(contentAddressedKv({ kv, mode: "write" }).lookup(cyclic)).resolves.toBeUndefined();
+		await expect(
+			contentAddressedKv({ kv, mode: "read" }).store(cyclic, { value: 1 }),
+		).resolves.toBe(undefined);
+		await expect(contentAddressedKv({ kv, mode: "read" }).forget(cyclic)).resolves.toBeUndefined();
+		await expect(contentAddressedKv({ kv, mode: "write" }).forget(cyclic)).resolves.toBeUndefined();
+		expect(calls).toEqual([]);
+	});
+
+	it("content-addressed forget is a no-op when mode disallows it or delete is missing", async () => {
+		const kv = memoryKv<{ value: number }>();
+		const ctx = { id: 1 };
+		const cyclic: { self?: unknown } = {};
+		cyclic.self = cyclic;
+		const readWrite = contentAddressedKv({ kv });
+		await readWrite.store(ctx, { value: 1 });
+
+		await contentAddressedKv({ kv, mode: "read" }).forget(ctx);
+		expect(await readWrite.lookup(ctx)).toEqual({ value: 1 });
+
+		await contentAddressedKv({ kv, mode: "write" }).forget(ctx);
+		expect(await readWrite.lookup(ctx)).toEqual({ value: 1 });
+
+		await expect(contentAddressedKv({ kv, mode: "write" }).lookup(cyclic)).resolves.toBeUndefined();
+		await expect(
+			contentAddressedKv({ kv, mode: "read" }).store(cyclic, { value: 9 }),
+		).resolves.toBe(undefined);
+		await expect(contentAddressedKv({ kv, mode: "read" }).forget(cyclic)).resolves.toBeUndefined();
+
+		await readWrite.forget(ctx);
+		expect(await readWrite.lookup(ctx)).toBeUndefined();
+
+		const bytes = new Map<string, Uint8Array>();
+		const noDelete = kvStorage<{ value: number }>({
+			backend: {
+				get: (key) => bytes.get(key),
+				put: (key, value) => void bytes.set(key, value),
+			},
+		});
+		const noDeleteCache = contentAddressedKv({ kv: noDelete });
+		await noDeleteCache.store(ctx, { value: 2 });
+		await noDeleteCache.forget(ctx);
+		expect(await noDeleteCache.lookup(ctx)).toEqual({ value: 2 });
+	});
+
+	it("content-addressed key contexts reject lossy and cyclic JSON", async () => {
+		const cache = contentAddressedKv({ kv: memoryKv<unknown>() });
+		const cyclic: { self?: unknown } = {};
+		cyclic.self = cyclic;
+		const sparse: unknown[] = [];
+		sparse[1] = "hole";
+
+		await expect(cache.keyFor({ nested: undefined })).rejects.toThrow(/not JSON-encodable/);
+		await expect(cache.keyFor(cyclic)).rejects.toThrow(/circular/);
+		await expect(cache.keyFor({ sparse })).rejects.toThrow(/sparse array hole/);
+		await expect(cache.keyFor("\uD800")).rejects.toThrow(/unpaired surrogate/);
+	});
+
+	it("memoryKv stores encoded values and lists keys by prefix in order", async () => {
+		const kv = memoryKv<{ value: number }>();
+		await kv.set("items/002", { value: 2 });
+		await kv.set("other/001", { value: 9 });
+		await kv.set("items/001", { value: 1 });
+
+		expect(await kv.get("items/001")).toEqual({ value: 1 });
+		expect(await listByPrefix(kv, "items/")).toEqual(["items/001", "items/002"]);
+	});
+
+	it("tieredReadThrough checks tiers in order and promotes first tier-1 hit", async () => {
+		const calls: string[] = [];
+		const coldCalls: string[] = [];
+		const warmCalls: string[] = [];
+		const hotTier: KvStorageTier<{ value: number }> = {
+			get: (key) => {
+				calls.push(`hot:${key}`);
+				return Promise.resolve(undefined);
+			},
+			set: (key, value) => {
+				calls.push(`hot:set:${key}:${value.value}`);
+				return Promise.resolve();
+			},
+			delete: () => Promise.resolve(),
+			list: () => Promise.resolve([]),
+		};
+		const warmTier: KvStorageTier<{ value: number }> = {
+			get: (key) => {
+				warmCalls.push(key);
+				calls.push(`warm:${key}`);
+				return Promise.resolve({ value: 2 });
+			},
+			set: () => {
+				calls.push("warm:set");
+				return Promise.resolve();
+			},
+			delete: () => Promise.resolve(),
+			list: () => Promise.resolve([]),
+		};
+		const coldTier: KvStorageTier<{ value: number }> = {
+			get: (key) => {
+				coldCalls.push(key);
+				calls.push(`cold:${key}`);
+				return Promise.resolve({ value: 1 });
+			},
+			set: () => Promise.resolve(),
+			delete: () => Promise.resolve(),
+			list: () => Promise.resolve([]),
+		};
+
+		const result = await tieredReadThrough({
+			key: "k",
+			tiers: [hotTier, warmTier, coldTier],
+			tierNames: ["hot", "warm", "cold"],
+		});
+
+		expect(result.status).toBe("hit");
+		expect(result.value).toEqual({ value: 2 });
+		expect(result.hitTier).toEqual({ index: 1, name: "warm" });
+		expect(result.facts.map((fact) => fact.kind)).toEqual(["miss", "hit"]);
+		expect(result.facts[1]).toMatchObject({ key: "k", tier: { index: 1, name: "warm" } });
+		expect(result.promotions.map((promotion) => promotion.tier.index)).toEqual([0]);
+		expect(result.promotions[0]).toMatchObject({ ok: true, tier: { index: 0, name: "hot" } });
+		expect(warmCalls).toEqual(["k"]);
+		expect(coldCalls).toEqual([]);
+		expect(calls.filter((value) => value.startsWith("cold")).length).toEqual(0);
+		expect(calls.some((value) => value === "hot:set:k:2")).toBe(true);
+	});
+
+	it("tieredReadThrough loads on miss and writes-through to all tiers by default", async () => {
+		const setTargets: string[] = [];
+		const missTier: KvStorageTier<{ value: string }> = {
+			get: (_key) => Promise.resolve(undefined),
+			set: (key, value) => {
+				setTargets.push(`miss:${key}:${value.value}`);
+				return Promise.resolve();
+			},
+			delete: () => Promise.resolve(),
+			list: () => Promise.resolve([]),
+		};
+		const hitTier: KvStorageTier<{ value: string }> = {
+			get: (_key) => Promise.resolve(undefined),
+			set: (key, value) => {
+				setTargets.push(`hit:${key}:${value.value}`);
+				return Promise.resolve();
+			},
+			delete: () => Promise.resolve(),
+			list: () => Promise.resolve([]),
+		};
+
+		const result = await readThroughKv({
+			key: "user:1",
+			tiers: [missTier, hitTier],
+			load: () => ({ value: "loaded" }),
+			tierNames: ["miss", "hit"],
+		});
+
+		expect(result.status).toBe("hit");
+		expect(result.value).toEqual({ value: "loaded" });
+		expect(result.hitTier).toEqual({ index: -1, name: "load" });
+		expect(result.facts.map((fact) => fact.kind)).toEqual(["miss", "miss", "hit"]);
+		expect(setTargets).toEqual(["miss:user:1:loaded", "hit:user:1:loaded"]);
+	});
+
+	it("tieredReadThrough returns a miss fact without loader and does not throw", async () => {
+		const result = await tieredReadThrough<{ value: string }>({
+			key: "missing",
+			tiers: [
+				{
+					get: () => Promise.resolve(undefined),
+					set: () => Promise.resolve(),
+					delete: () => Promise.resolve(),
+					list: () => Promise.resolve([]),
+				},
+				{
+					get: () => Promise.resolve(undefined),
+					set: () => Promise.resolve(),
+					delete: () => Promise.resolve(),
+					list: () => Promise.resolve([]),
+				},
+			],
+		});
+
+		expect(result.status).toBe("miss");
+		expect(result.value).toBeUndefined();
+		expect(result.facts.map((fact) => fact.kind)).toEqual(["miss", "miss"]);
+		expect(result.facts.every((fact) => fact.tier.index >= 0)).toBe(true);
+	});
+
+	it("tieredReadThrough treats an empty tier list without a loader as a miss", async () => {
+		const result = await tieredReadThrough<{ value: string }>({
+			key: "nowhere",
+			tiers: [],
+		});
+
+		expect(result.status).toBe("miss");
+		expect(result.value).toBeUndefined();
+		expect(result.hitTier).toBeUndefined();
+		expect(result.facts).toEqual([]);
+		expect(result.promotions).toEqual([]);
+	});
+
+	it("tieredReadThrough captures get errors as facts and continues lookup", async () => {
+		const hitTier: KvStorageTier<{ value: number }> = {
+			get: (_key) => Promise.resolve({ value: 7 }),
+			set: () => Promise.resolve(),
+			delete: () => Promise.resolve(),
+			list: () => Promise.resolve([]),
+		};
+		const errors: string[] = [];
+		const result = await tieredReadThrough({
+			key: "err",
+			tiers: [
+				{
+					get: () => Promise.reject(new Error("read failed")),
+					set: () => Promise.resolve(),
+					delete: () => Promise.resolve(),
+					list: () => Promise.resolve([]),
+				},
+				hitTier,
+			],
+			onError: (ctx) => {
+				errors.push(String((ctx.error as Error).message ?? ctx.error));
+			},
+		});
+
+		expect(result.status).toBe("hit");
+		expect(result.value).toEqual({ value: 7 });
+		expect(result.facts.map((fact) => fact.kind)).toEqual(["error", "hit"]);
+		expect(errors).toContain("read failed");
+		expect(result.promotions).toEqual([expect.objectContaining({ tier: { index: 0 }, ok: true })]);
+	});
+});
diff --git a/packages/ts/src/__tests__/storage.d82-storage-substrate-helpers-part-01.sub-02.test.ts b/packages/ts/src/__tests__/storage.d82-storage-substrate-helpers-part-01.sub-02.test.ts
new file mode 100644
index 00000000..6aaadce2
--- /dev/null
+++ b/packages/ts/src/__tests__/storage.d82-storage-substrate-helpers-part-01.sub-02.test.ts
@@ -0,0 +1,422 @@
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { describe, expect, it } from "vitest";
+import type { KvStorageTier } from "../index.js";
+import {
+	hasStoragePutIfAbsent,
+	hasStorageVersioned,
+	memoryBackend,
+	memoryKv,
+	requireKvVersioned,
+	requireStoragePutIfAbsent,
+	requireStorageVersioned,
+	tieredReadThrough,
+	webStorageBackend,
+} from "../index.js";
+import { fileAppendLog, fileBackend, fileKv, sqliteBackend } from "../storage/node.js";
+
+interface TestStorage {
+	entries: Record<string, string>;
+	getItem(key: string): string | null;
+	setItem(key: string, value: string): void;
+	removeItem(key: string): void;
+	key(index: number): string | null;
+	length: number;
+}
+
+const createStorage = (): TestStorage => {
+	const entries: Record<string, string> = {};
+	const storage: TestStorage = {
+		get entries() {
+			return entries;
+		},
+		getItem(key) {
+			return entries[key] ?? null;
+		},
+		setItem(key, value) {
+			entries[key] = value;
+		},
+		removeItem(key) {
+			delete entries[key];
+		},
+		key(index) {
+			const keys = Object.keys(entries).sort();
+			return keys[index] ?? null;
+		},
+		get length() {
+			return Object.keys(entries).length;
+		},
+	};
+	return storage;
+};
+
+const makeTempDir = () => mkdtempSync(join(tmpdir(), "graphrefly-ts-storage-"));
+
+const _flushMicrotasks = async (turns = 1) => {
+	for (let i = 0; i < turns; i += 1) await Promise.resolve();
+};
+
+const _awaitDone = (run: (done: () => void) => void) =>
+	new Promise<void>((resolve) => {
+		run(resolve);
+	});
+
+const bytesToHex = (bytes: Uint8Array) =>
+	[...bytes].map((byte) => byte.toString(16).padStart(2, "0")).join("");
+
+const _sha256Hex = async (bytes: Uint8Array) =>
+	bytesToHex(new Uint8Array(await globalThis.crypto.subtle.digest("SHA-256", bytes)));
+
+describe("D82 storage substrate helpers — sub 2", () => {
+	it("tieredReadThrough reports all-miss-tier errors as error status", async () => {
+		const failures: unknown[] = [];
+		const result = await tieredReadThrough({
+			key: "all-fail",
+			tiers: [
+				{
+					get: () => Promise.reject(new Error("tier0 failed")),
+					set: () => Promise.resolve(),
+					delete: () => Promise.resolve(),
+					list: () => Promise.resolve([]),
+				},
+				{
+					get: () => Promise.reject(new Error("tier1 failed")),
+					set: () => Promise.resolve(),
+					delete: () => Promise.resolve(),
+					list: () => Promise.resolve([]),
+				},
+			],
+			onError: (ctx) => {
+				if (ctx.stage === "lookup") failures.push(ctx.error);
+			},
+		});
+
+		expect(result.status).toBe("error");
+		expect(result.facts.map((fact) => fact.kind)).toEqual(["error", "error"]);
+		expect(failures).toHaveLength(2);
+	});
+
+	it("tieredReadThrough reports mixed miss/error no-hit results as error status", async () => {
+		const result = await tieredReadThrough({
+			key: "partial-fail",
+			tiers: [
+				{
+					get: () => Promise.resolve(undefined),
+					set: () => Promise.resolve(),
+					delete: () => Promise.resolve(),
+					list: () => Promise.resolve([]),
+				},
+				{
+					get: () => Promise.reject(new Error("cold failed")),
+					set: () => Promise.resolve(),
+					delete: () => Promise.resolve(),
+					list: () => Promise.resolve([]),
+				},
+			],
+		});
+
+		expect(result.status).toBe("error");
+		expect(result.value).toBeUndefined();
+		expect(result.facts.map((fact) => fact.kind)).toEqual(["miss", "error"]);
+	});
+
+	it("tieredReadThrough captures promotion write failures as facts", async () => {
+		const errors: unknown[] = [];
+		const result = await tieredReadThrough({
+			key: "write-fail",
+			tiers: [
+				{
+					get: () => Promise.resolve(undefined),
+					set: () => Promise.reject(new Error("promotion failed")),
+					delete: () => Promise.resolve(),
+					list: () => Promise.resolve([]),
+				},
+				{
+					get: () => Promise.resolve({ value: 3 }),
+					set: () => Promise.resolve(),
+					delete: () => Promise.resolve(),
+					list: () => Promise.resolve([]),
+				},
+			],
+			promoteTo: [0],
+			tierNames: ["hot", "cold"],
+			onError: (ctx) => {
+				if (ctx.stage === "promotion") {
+					errors.push(ctx.error);
+				}
+			},
+		});
+
+		expect(result.status).toBe("hit");
+		expect(result.value).toEqual({ value: 3 });
+		expect(result.facts.map((fact) => fact.kind)).toEqual(["miss", "hit"]);
+		expect(result.promotions).toEqual([
+			expect.objectContaining({ tier: { index: 0, name: "hot" }, ok: false }),
+		]);
+		expect(String(result.promotions[0]?.error)).toContain("promotion failed");
+		expect(errors).toHaveLength(1);
+	});
+
+	it("tieredReadThrough uses D108 setIfMatch for stale-proof promotion when available", async () => {
+		const hot = memoryKv<number>();
+		const hotVersioned = requireKvVersioned(hot);
+		const hotTier: KvStorageTier<number> = {
+			...hot,
+			async getVersioned(key) {
+				const observed = await hotVersioned.getVersioned(key);
+				await hot.set(key, 1);
+				return observed;
+			},
+			setIfMatch: hotVersioned.setIfMatch.bind(hotVersioned),
+		};
+		const cold = memoryKv<number>();
+		await cold.set("k", 7);
+
+		const result = await tieredReadThrough({
+			key: "k",
+			tiers: [hotTier, cold],
+			promoteTo: [0],
+		});
+
+		expect(result.status).toBe("hit");
+		expect(result.value).toBe(7);
+		expect(result.facts.map((fact) => [fact.kind, fact.tier.index])).toEqual([
+			["miss", 0],
+			["hit", 1],
+		]);
+		expect(result.promotions).toEqual([{ tier: { index: 0 }, ok: false }]);
+		expect(await hot.get("k")).toBe(1);
+	});
+
+	it("tieredReadThrough does not bypass a versioned target when generation lookup failed", async () => {
+		const calls: string[] = [];
+		const errors: string[] = [];
+		const hotTier: KvStorageTier<number> = {
+			get: () => {
+				calls.push("get");
+				return Promise.resolve(undefined);
+			},
+			set: () => {
+				calls.push("set");
+				throw new Error("plain set must not run");
+			},
+			getVersioned: () => {
+				calls.push("getVersioned");
+				throw new Error("versioned read failed");
+			},
+			setIfMatch: () => {
+				calls.push("setIfMatch");
+				return Promise.resolve(true);
+			},
+			delete: () => Promise.resolve(),
+			list: () => Promise.resolve([]),
+		};
+		const cold = memoryKv<number>();
+		await cold.set("k", 9);
+
+		const result = await tieredReadThrough({
+			key: "k",
+			tiers: [hotTier, cold],
+			promoteTo: [0],
+			onError: (ctx) => {
+				errors.push(`${ctx.stage}:${String((ctx.error as Error).message ?? ctx.error)}`);
+			},
+		});
+
+		expect(result.status).toBe("hit");
+		expect(result.value).toBe(9);
+		expect(result.facts.map((fact) => [fact.kind, fact.tier.index])).toEqual([
+			["error", 0],
+			["hit", 1],
+		]);
+		expect(result.promotions).toEqual([
+			expect.objectContaining({
+				tier: { index: 0 },
+				ok: false,
+			}),
+		]);
+		expect(String(result.promotions[0]?.error)).toContain("not observed with a generation");
+		expect(calls).toEqual(["getVersioned"]);
+		expect(errors).toEqual([
+			"lookup:versioned read failed",
+			"promotion:tieredReadThrough: versioned promotion target was not observed with a generation",
+		]);
+	});
+
+	it("memoryBackend putIfAbsent creates once, preserves bytes, and clones", async () => {
+		const backend = memoryBackend();
+		const first = new Uint8Array([1, 2, 3]);
+		const second = new Uint8Array([9, 9, 9]);
+
+		expect(hasStoragePutIfAbsent(backend)).toBe(true);
+		expect(requireStoragePutIfAbsent(backend)).toBe(backend);
+		expect(await backend.putIfAbsent("k", first)).toBe(true);
+		first[0] = 7;
+
+		expect(await backend.putIfAbsent("k", second)).toBe(false);
+		second[1] = 8;
+		const stored = await backend.get("k");
+		expect([...stored!]).toEqual([1, 2, 3]);
+		stored![0] = 6;
+		expect([...(await backend.get("k"))!]).toEqual([1, 2, 3]);
+	});
+
+	it("memoryBackend supports D108 versioned present and absent observations", async () => {
+		const backend = requireStorageVersioned(memoryBackend());
+
+		expect(hasStorageVersioned(backend)).toBe(true);
+		const absent = await backend.getVersioned("k");
+		expect(absent.kind).toBe("miss");
+		expect(await backend.setIfMatch("k", new Uint8Array([1]), absent.generation)).toBe(true);
+		expect(await backend.setIfMatch("k", new Uint8Array([2]), absent.generation)).toBe(false);
+		expect(await backend.setIfMatch("other", new Uint8Array([9]), absent.generation)).toBe(false);
+		expect(await backend.get("k")).toEqual(new Uint8Array([1]));
+
+		const present = await backend.getVersioned("k");
+		expect(present.kind).toBe("hit");
+		if (present.kind === "hit") {
+			present.value[0] = 9;
+		}
+		expect(await backend.get("k")).toEqual(new Uint8Array([1]));
+
+		await backend.put("k", new Uint8Array([3]));
+		expect(await backend.setIfMatch("k", new Uint8Array([4]), present.generation)).toBe(false);
+		const fresh = await backend.getVersioned("k");
+		expect(await backend.setIfMatch("k", new Uint8Array([4]), fresh.generation)).toBe(true);
+		expect(await backend.get("k")).toEqual(new Uint8Array([4]));
+
+		backend.clear();
+		expect(await backend.setIfMatch("k", new Uint8Array([5]), fresh.generation)).toBe(false);
+	});
+
+	it("webStorageBackend stores hex bytes deterministically, lists by namespace, and rejects malformed data", () => {
+		const storage = createStorage();
+		const backend = webStorageBackend(storage, { namespace: "web" });
+
+		const raw = new Uint8Array([8, 9, 10]);
+		backend.put("cache/key", raw);
+		raw[0] = 1;
+
+		expect(storage.entries["web\u0000cache/key"]).toBe("08090a");
+		expect([...(backend.get("cache/key") ?? new Uint8Array())]).toEqual([8, 9, 10]);
+		expect(backend.list("cache")).toEqual(["cache/key"]);
+		expect(backend.list("other")).toEqual([]);
+
+		storage.setItem("web\u0000bad", "not-hex");
+		expect(() => backend.get("bad")).toThrow(/malformed stored bytes/);
+		expect(hasStorageVersioned(backend)).toBe(false);
+		expect(() => requireStorageVersioned(backend, "webStorageBackend")).toThrow(
+			/webStorageBackend: backend does not support versioned/,
+		);
+	});
+
+	it("webStorageBackend rejects ambiguous namespace separators and non-string runtime keys", () => {
+		const storage = createStorage();
+
+		expect(() => webStorageBackend(storage, { namespace: "ns\u0000bad" })).toThrow(/namespace/);
+		expect(() => webStorageBackend(storage, { namespace: null as unknown as string })).toThrow(
+			/namespace/,
+		);
+
+		const backend = webStorageBackend(storage, { namespace: "ns" });
+		expect(() => backend.put("bad\u0000key", new Uint8Array([1]))).toThrow(/U\+0000/);
+		expect(() => backend.get(1 as unknown as string)).toThrow(/key must be a string/);
+		expect(() => backend.list("bad\u0000prefix")).toThrow(/U\+0000/);
+		expect(() => backend.list(1 as unknown as string)).toThrow(/list prefix must be a string/);
+
+		storage.setItem("ns\u0000bad\u0000key", "01");
+		expect(() => backend.list()).toThrow(/malformed stored key/);
+	});
+
+	it("fileBackend persists bytes, lists logical keys, and supports putIfAbsent", async () => {
+		const dir = makeTempDir();
+		try {
+			const backend = fileBackend(dir, { namespace: "ns" });
+			await backend.put("", new Uint8Array([0]));
+			await backend.put("a", new Uint8Array([1, 2, 3]));
+			await backend.put("ab", new Uint8Array([9, 8, 7]));
+			expect(await backend.putIfAbsent?.("a", new Uint8Array([4]))).toBe(false);
+			expect(await backend.putIfAbsent?.("c", new Uint8Array([3]))).toBe(true);
+
+			const first = await backend.get("a");
+			const second = await backend.get("ab");
+			expect(first).toEqual(new Uint8Array([1, 2, 3]));
+			expect(second).toEqual(new Uint8Array([9, 8, 7]));
+
+			first![0] = 9;
+			expect(await backend.get("a")).toEqual(new Uint8Array([1, 2, 3]));
+
+			const listAll = await backend.list();
+			expect(listAll).toEqual(["", "a", "ab", "c"]);
+			expect(await backend.list("a")).toEqual(["a", "ab"]);
+
+			await backend.delete("ab");
+			expect(await backend.get("ab")).toBeUndefined();
+			expect(await backend.list()).toEqual(["", "a", "c"]);
+			expect(hasStorageVersioned(backend)).toBe(false);
+			expect(() => requireStorageVersioned(backend, "fileBackend")).toThrow(
+				/fileBackend: backend does not support versioned/,
+			);
+		} finally {
+			rmSync(dir, { recursive: true, force: true });
+		}
+	});
+
+	it("fileBackend rejects ambiguous namespace separators and non-string runtime keys", async () => {
+		const dir = makeTempDir();
+		try {
+			expect(() => fileBackend(dir, { namespace: "ns\u0000bad" })).toThrow(/namespace/);
+			expect(() => fileBackend(dir, { namespace: null as unknown as string })).toThrow(/namespace/);
+
+			const backend = fileBackend(dir, { namespace: "ns" });
+			expect(() => backend.put("bad\u0000key", new Uint8Array([1]))).toThrow(/U\+0000/);
+			expect(() => backend.get(1 as unknown as string)).toThrow(/key must be a string/);
+			expect(() => backend.list("bad\u0000prefix")).toThrow(/U\+0000/);
+			expect(() => backend.list(1 as unknown as string)).toThrow(/list prefix must be a string/);
+		} finally {
+			rmSync(dir, { recursive: true, force: true });
+		}
+	});
+
+	it("fileBackend rejects unsafe filename extensions", () => {
+		const dir = join(tmpdir(), "graphrefly-ts-storage-extension-negative");
+		expect(() => fileBackend(dir, { extension: "/../../x" })).toThrow(/extension/);
+		expect(() => fileBackend(dir, { extension: "..bin" })).toThrow(/extension/);
+		expect(() => fileBackend(dir, { extension: "" })).toThrow(/extension/);
+	});
+
+	it("fileKv and fileAppendLog stay passive typed wrappers over fileBackend", async () => {
+		const dir = makeTempDir();
+		try {
+			const kv = fileKv<{ value: string }>(dir, { namespace: "typed" });
+			await kv.set("a", { value: "one" });
+			expect(await kv.get("a")).toEqual({ value: "one" });
+			expect(await kv.list()).toEqual(["a"]);
+
+			const log = fileAppendLog<{ value: string }>(dir, {
+				namespace: "typed-log",
+				prefix: "events",
+			});
+			await log.append({ value: "first" });
+			await log.append({ value: "second" });
+			expect((await log.read()).map((entry) => [entry.seq, entry.value.value])).toEqual([
+				[0, "first"],
+				[1, "second"],
+			]);
+		} finally {
+			rmSync(dir, { recursive: true, force: true });
+		}
+	});
+
+	it("sqliteBackend validates table names before touching optional node:sqlite", () => {
+		expect(() => sqliteBackend(":memory:", { tableName: "bad-name" })).toThrow(/tableName/);
+		expect(() => sqliteBackend(":memory:", { tableName: "1bad" })).toThrow(/tableName/);
+		expect(() => sqliteBackend(":memory:", { namespace: "bad\u0000namespace" })).toThrow(
+			/namespace/,
+		);
+		expect(() => sqliteBackend(":memory:", { namespace: null as unknown as string })).toThrow(
+			/namespace/,
+		);
+	});
+});
diff --git a/packages/ts/src/__tests__/storage.d82-storage-substrate-helpers-part-02.test.ts b/packages/ts/src/__tests__/storage.d82-storage-substrate-helpers-part-02.test.ts
new file mode 100644
index 00000000..42209f26
--- /dev/null
+++ b/packages/ts/src/__tests__/storage.d82-storage-substrate-helpers-part-02.test.ts
@@ -0,0 +1,951 @@
+import { Buffer } from "node:buffer";
+import { mkdtempSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { describe, expect, it, vi } from "vitest";
+import { attachObserveEventLog } from "../adapters/observe-storage.js";
+import type { KvStorageTier, ObserveEventFrame, WalFrame } from "../index.js";
+import {
+	appendLogKey,
+	appendLogStorage,
+	assertWalFrame,
+	graph,
+	hasKvPutIfAbsent,
+	hasKvVersioned,
+	hasStorageVersioned,
+	kvStorage,
+	memoryAppendLog,
+	memoryBackend,
+	memoryKv,
+	memoryMultiWriterAppendLog,
+	multiWriterAppendLogStorage,
+	observeEventFrame,
+	readAppendLogPage,
+	readObserveEventLogPage,
+	requireKvPutIfAbsent,
+	requireKvVersioned,
+	requireStorageVersioned,
+	strictJsonCodec,
+	verifyWalFrameChecksum,
+	WAL_FORMAT_VERSION,
+	walFrame,
+	walFrameChecksum,
+	walFrameCodec,
+	walFrameKey,
+	walFramePrefix,
+} from "../index.js";
+import { sqliteBackend, sqliteKv } from "../storage/node.js";
+
+interface TestStorage {
+	entries: Record<string, string>;
+	getItem(key: string): string | null;
+	setItem(key: string, value: string): void;
+	removeItem(key: string): void;
+	key(index: number): string | null;
+	length: number;
+}
+
+const _createStorage = (): TestStorage => {
+	const entries: Record<string, string> = {};
+	const storage: TestStorage = {
+		get entries() {
+			return entries;
+		},
+		getItem(key) {
+			return entries[key] ?? null;
+		},
+		setItem(key, value) {
+			entries[key] = value;
+		},
+		removeItem(key) {
+			delete entries[key];
+		},
+		key(index) {
+			const keys = Object.keys(entries).sort();
+			return keys[index] ?? null;
+		},
+		get length() {
+			return Object.keys(entries).length;
+		},
+	};
+	return storage;
+};
+
+const _makeTempDir = () => mkdtempSync(join(tmpdir(), "graphrefly-ts-storage-"));
+
+const _flushMicrotasks = async (turns = 1) => {
+	for (let i = 0; i < turns; i += 1) await Promise.resolve();
+};
+
+const awaitDone = (run: (done: () => void) => void) =>
+	new Promise<void>((resolve) => {
+		run(resolve);
+	});
+
+const bytesToHex = (bytes: Uint8Array) =>
+	[...bytes].map((byte) => byte.toString(16).padStart(2, "0")).join("");
+
+const _sha256Hex = async (bytes: Uint8Array) =>
+	bytesToHex(new Uint8Array(await globalThis.crypto.subtle.digest("SHA-256", bytes)));
+
+describe("D82 storage substrate helpers — part 2", () => {
+	it("sqliteBackend exposes D108 versioned get/set-if-match when node:sqlite is available", async () => {
+		let backend: ReturnType<typeof sqliteBackend>;
+		try {
+			backend = sqliteBackend(":memory:", { namespace: "d108" });
+		} catch (error) {
+			expect(String((error as Error).message)).toContain("node:sqlite is not available");
+			return;
+		}
+		try {
+			const versioned = requireStorageVersioned(backend, "sqliteBackend");
+			expect(hasStorageVersioned(backend)).toBe(true);
+			expect(() => backend.put("bad\u0000key", new Uint8Array([1]))).toThrow(/U\+0000/);
+			expect(() => backend.get(1 as unknown as string)).toThrow(/key must be a string/);
+			expect(() => backend.list("bad\u0000prefix")).toThrow(/U\+0000/);
+			expect(() => backend.list(1 as unknown as string)).toThrow(/list prefix must be a string/);
+			expect(() =>
+				versioned.setIfMatch("bad\u0000key", new Uint8Array([1]), Object.freeze({})),
+			).toThrow(/U\+0000/);
+
+			const absent = await versioned.getVersioned("k");
+			expect(absent.kind).toBe("miss");
+			expect(await versioned.setIfMatch("k", new Uint8Array([1]), absent.generation)).toBe(true);
+			expect(await versioned.setIfMatch("k", new Uint8Array([2]), absent.generation)).toBe(false);
+			expect(await versioned.setIfMatch("other", new Uint8Array([9]), absent.generation)).toBe(
+				false,
+			);
+			expect(await backend.get("k")).toEqual(new Uint8Array([1]));
+
+			const otherBackend = sqliteBackend(":memory:", { namespace: "d108" });
+			try {
+				const otherVersioned = requireStorageVersioned(otherBackend, "sqliteBackend.other");
+				expect(await otherVersioned.setIfMatch("k", new Uint8Array([8]), absent.generation)).toBe(
+					false,
+				);
+				expect(await otherBackend.get("k")).toBeUndefined();
+			} finally {
+				otherBackend.close();
+			}
+
+			const present = await versioned.getVersioned("k");
+			expect(present.kind).toBe("hit");
+			if (present.kind === "hit") {
+				present.value[0] = 7;
+			}
+			expect(await backend.get("k")).toEqual(new Uint8Array([1]));
+			await backend.put("unrelated", new Uint8Array([9]));
+			expect(await versioned.setIfMatch("k", new Uint8Array([2]), present.generation)).toBe(true);
+			expect(await backend.get("k")).toEqual(new Uint8Array([2]));
+
+			await backend.put("k", new Uint8Array([3]));
+			expect(await versioned.setIfMatch("k", new Uint8Array([4]), present.generation)).toBe(false);
+
+			const missBeforeCycle = await versioned.getVersioned("cycle");
+			await backend.put("cycle", new Uint8Array([5]));
+			await backend.delete("cycle");
+			expect(
+				await versioned.setIfMatch("cycle", new Uint8Array([6]), missBeforeCycle.generation),
+			).toBe(false);
+
+			const fresh = await versioned.getVersioned("k");
+			expect(await versioned.setIfMatch("k", new Uint8Array([4]), fresh.generation)).toBe(true);
+			expect(await backend.get("k")).toEqual(new Uint8Array([4]));
+		} finally {
+			backend.close();
+		}
+	});
+
+	it("sqliteKv lifts D108 versioned support through the typed KV wrapper", async () => {
+		let kv: ReturnType<typeof sqliteKv<{ value: number }>>;
+		try {
+			kv = sqliteKv<{ value: number }>(":memory:", { namespace: "typed-d108" });
+		} catch (error) {
+			expect(String((error as Error).message)).toContain("node:sqlite is not available");
+			return;
+		}
+		try {
+			const versioned = requireKvVersioned(kv, "sqliteKv");
+			expect(hasKvVersioned(kv)).toBe(true);
+
+			const absent = await versioned.getVersioned("item");
+			expect(absent.kind).toBe("miss");
+			await expect(versioned.setIfMatch("item", { value: 1 }, absent.generation)).resolves.toBe(
+				true,
+			);
+			await expect(versioned.setIfMatch("item", { value: 2 }, absent.generation)).resolves.toBe(
+				false,
+			);
+			expect(await kv.get("item")).toEqual({ value: 1 });
+
+			const present = await versioned.getVersioned("item");
+			await kv.set("item", { value: 3 });
+			await expect(versioned.setIfMatch("item", { value: 4 }, present.generation)).resolves.toBe(
+				false,
+			);
+			expect(await kv.get("item")).toEqual({ value: 3 });
+		} finally {
+			kv.close();
+		}
+	});
+
+	it("memoryBackend clones Node Buffer inputs instead of storing shared views", async () => {
+		const backend = memoryBackend();
+		const input = Buffer.from([1, 2, 3]);
+
+		expect(await backend.putIfAbsent("buf", input)).toBe(true);
+		input[0] = 9;
+		const stored = await backend.get("buf");
+		expect([...stored!]).toEqual([1, 2, 3]);
+
+		stored![1] = 8;
+		expect([...(await backend.get("buf"))!]).toEqual([1, 2, 3]);
+	});
+
+	it("typed KV putIfAbsent respects codecs and preserves existing values", async () => {
+		const backend = memoryBackend();
+		const encoder = new TextEncoder();
+		const decoder = new TextDecoder();
+		const encode = vi.fn((value: { value: number }) => encoder.encode(`v:${value.value}`));
+		const kv = kvStorage({
+			backend,
+			codec: {
+				encode,
+				decode: (bytes) => ({ value: Number(decoder.decode(bytes).slice(2)) }),
+			},
+		});
+
+		expect(hasKvPutIfAbsent(kv)).toBe(true);
+		expect(requireKvPutIfAbsent(kv)).toBe(kv);
+		await expect(kv.putIfAbsent!("item", { value: 1 })).resolves.toBe(true);
+		await expect(kv.putIfAbsent!("item", { value: 2 })).resolves.toBe(false);
+
+		expect(encode.mock.calls.map(([value]) => value.value)).toEqual([1, 2]);
+		expect(await kv.get("item")).toEqual({ value: 1 });
+		expect(decoder.decode(await backend.get("item"))).toBe("v:1");
+	});
+
+	it("typed KV exposes D108 versioned capability only when the backend supports it", async () => {
+		const kv = memoryKv<{ value: number }>();
+		const versioned = requireKvVersioned(kv);
+
+		expect(hasKvVersioned(kv)).toBe(true);
+		const absent = await versioned.getVersioned("item");
+		expect(absent.kind).toBe("miss");
+		await expect(versioned.setIfMatch("item", { value: 1 }, absent.generation)).resolves.toBe(true);
+		await expect(versioned.setIfMatch("item", { value: 2 }, absent.generation)).resolves.toBe(
+			false,
+		);
+		expect(await kv.get("item")).toEqual({ value: 1 });
+
+		const present = await versioned.getVersioned("item");
+		expect(present).toMatchObject({ kind: "hit", value: { value: 1 } });
+		await kv.set("item", { value: 3 });
+		await expect(versioned.setIfMatch("item", { value: 4 }, present.generation)).resolves.toBe(
+			false,
+		);
+		expect(await kv.get("item")).toEqual({ value: 3 });
+	});
+
+	it("kvStorage routes sync backend and codec failures through the returned Promise", async () => {
+		const kv = kvStorage({
+			backend: {
+				get() {
+					throw new Error("get boom");
+				},
+				put() {
+					throw new Error("put boom");
+				},
+				list() {
+					throw new Error("list boom");
+				},
+			},
+		});
+
+		await expect(kv.get("x")).rejects.toThrow("get boom");
+		await expect(kv.set("x", { value: 1 })).rejects.toThrow("put boom");
+		await expect(kv.list()).rejects.toThrow("list boom");
+	});
+
+	it("kvStorage omits putIfAbsent when the byte backend lacks the capability", () => {
+		const kv = kvStorage({
+			backend: {
+				get: () => undefined,
+				put: () => undefined,
+				list: () => [],
+			},
+		});
+
+		expect(hasKvPutIfAbsent(kv)).toBe(false);
+		expect(hasKvVersioned(kv)).toBe(false);
+		expect(() => requireKvPutIfAbsent(kv)).toThrow(/does not support putIfAbsent/);
+		expect(() => requireKvVersioned(kv)).toThrow(/does not support versioned/);
+	});
+
+	it("append logs paginate by cursor and can truncate later entries", async () => {
+		const log = memoryAppendLog<{ value: string }>("changes");
+		await log.append({ value: "a" });
+		await log.append({ value: "b" });
+		await log.append({ value: "c" });
+
+		expect((await log.read({ limit: 2 })).map((entry) => entry.value.value)).toEqual(["a", "b"]);
+		expect((await log.read({ after: 0 })).map((entry) => entry.value.value)).toEqual(["b", "c"]);
+
+		await log.truncateAfter(0);
+		expect((await log.read()).map((entry) => [entry.seq, entry.value.value])).toEqual([[0, "a"]]);
+
+		await log.append({ value: "d" });
+		expect((await log.read()).map((entry) => [entry.seq, entry.value.value])).toEqual([
+			[0, "a"],
+			[1, "d"],
+		]);
+	});
+
+	it("readAppendLogPage returns ordered pages with an explicit cursor", async () => {
+		const log = memoryAppendLog<{ value: string }>("page");
+		await log.append({ value: "a" });
+		await log.append({ value: "b" });
+		await log.append({ value: "c" });
+
+		const first = await readAppendLogPage(log, { limit: 2 });
+		expect(first.entries.map((entry) => [entry.seq, entry.value.value])).toEqual([
+			[0, "a"],
+			[1, "b"],
+		]);
+		expect(first.nextAfter).toBe(1);
+		expect(first.done).toBe(false);
+
+		const second = await readAppendLogPage(log, { after: first.nextAfter, limit: 2 });
+		expect(second.entries.map((entry) => [entry.seq, entry.value.value])).toEqual([[2, "c"]]);
+		expect(second.nextAfter).toBe(2);
+		expect(second.done).toBe(true);
+		expect(await readAppendLogPage(log, { after: second.nextAfter, limit: 2 })).toEqual({
+			entries: [],
+			nextAfter: 2,
+			done: true,
+		});
+		expect(await readAppendLogPage(log, { after: 100, limit: 2 })).toEqual({
+			entries: [],
+			nextAfter: 100,
+			done: true,
+		});
+		expect(() => readAppendLogPage(log, { limit: 0 })).toThrow(/positive safe integer/);
+	});
+
+	it("readAppendLogPage sorts unordered backend listings by sequence", async () => {
+		const entries = new Map<string, { value: string }>([
+			[appendLogKey("unordered", 10), { value: "c" }],
+			[appendLogKey("unordered", 0), { value: "a" }],
+			[appendLogKey("unordered", 2), { value: "b" }],
+		]);
+		const kv: KvStorageTier<{ value: string }> = {
+			get: (key) => Promise.resolve(entries.get(key)),
+			set: (key, value) => {
+				entries.set(key, value);
+				return Promise.resolve();
+			},
+			delete: (key) => {
+				entries.delete(key);
+				return Promise.resolve();
+			},
+			list: (prefix = "") =>
+				Promise.resolve([...entries.keys()].filter((key) => key.startsWith(prefix))),
+		};
+		const log = appendLogStorage({ kv, prefix: "unordered" });
+
+		const first = await readAppendLogPage(log, { limit: 2 });
+		expect(first.entries.map((entry) => [entry.seq, entry.value.value])).toEqual([
+			[0, "a"],
+			[2, "b"],
+		]);
+		expect(first.nextAfter).toBe(2);
+		expect(first.done).toBe(false);
+
+		const second = await readAppendLogPage(log, { after: first.nextAfter, limit: 2 });
+		expect(second.entries.map((entry) => [entry.seq, entry.value.value])).toEqual([[10, "c"]]);
+		expect(second.done).toBe(true);
+	});
+
+	it("walFrameKey builds padded passive WAL storage keys", () => {
+		const prefix = walFramePrefix("graph/main");
+		expect(prefix).toBe("graph/main/wal");
+		expect(walFramePrefix("")).toBe("wal");
+		expect(walFrameKey(prefix, 7)).toBe("graph/main/wal/00000000000000000007");
+		expect(() => walFrameKey(prefix, -1)).toThrow(/non-negative safe integer/);
+		expect(() => walFrameKey(prefix, 1.5)).toThrow(/non-negative safe integer/);
+	});
+
+	it("walFrame produces stable checksums and detects tampering", async () => {
+		const body = {
+			t: "c",
+			lifecycle: "data",
+			path: "count",
+			change: { op: "set", value: 1 },
+			frame_seq: 2,
+			frame_t_ns: "123",
+			format_version: WAL_FORMAT_VERSION,
+		} as const;
+
+		const checksum = await walFrameChecksum(body);
+		expect(checksum).toMatch(/^[0-9a-f]{64}$/);
+		expect(await walFrameChecksum({ ...body })).toBe(checksum);
+		expect(
+			await walFrameChecksum({
+				...body,
+				change: JSON.parse('{"value":1,"op":"set"}') as { op: string; value: number },
+			}),
+		).toBe(checksum);
+
+		const frame = await walFrame({
+			path: body.path,
+			change: body.change,
+			frame_seq: body.frame_seq,
+			frame_t_ns: body.frame_t_ns,
+		});
+		expect(frame).toMatchObject({
+			t: "c",
+			lifecycle: "data",
+			path: "count",
+			change: { op: "set", value: 1 },
+			frame_seq: 2,
+			frame_t_ns: "123",
+			format_version: WAL_FORMAT_VERSION,
+			checksum: expect.stringMatching(/^[0-9a-f]{64}$/),
+		});
+		expect(await verifyWalFrameChecksum(frame)).toBe(true);
+		expect(await verifyWalFrameChecksum({ ...frame, path: "other" })).toBe(false);
+		expect(Object.keys(frame)).not.toEqual(
+			expect.arrayContaining(["snapshot", "restore", "checkpoint", "factory"]),
+		);
+	});
+
+	it("walFrameCodec validates passive frame shape without restore semantics", async () => {
+		const frame = await walFrame({ path: "node", change: { event: "DATA" }, frame_seq: 0 });
+		const codec = walFrameCodec<{ event: string }>();
+		expect(codec.decode(codec.encode(frame))).toEqual(frame);
+		expect(assertWalFrame(frame)).toEqual(frame);
+		expect(() => assertWalFrame({ ...frame, checksum: "BAD" })).toThrow(/checksum/);
+		expect(() =>
+			codec.decode(
+				strictJsonCodec.encode({
+					...frame,
+					t: "r",
+				}),
+			),
+		).toThrow(/t must be c/);
+		expect(() =>
+			codec.decode(
+				strictJsonCodec.encode({
+					...frame,
+					lifecycle: "restore",
+				}),
+			),
+		).toThrow(/lifecycle/);
+	});
+
+	it("walFrameCodec rejects malformed strict JSON bytes before shape validation", async () => {
+		const frame = await walFrame({ path: "node", change: { event: "DATA" }, frame_seq: 0 });
+		const codec = walFrameCodec<{ event: string }>();
+		const encoder = new TextEncoder();
+
+		expect(() => codec.decode(encoder.encode('{"checksum":"bad","checksum":"also-bad"}'))).toThrow(
+			/duplicate object key/,
+		);
+		expect(() =>
+			codec.decode(encoder.encode(`{"path":"node","checksum":"${frame.checksum}"}`)),
+		).toThrow(/canonical/);
+		expect(() => codec.decode(encoder.encode('"\\ud800"'))).toThrow(/unpaired surrogate/);
+	});
+
+	it("wal frame shape checks reject malformed passive frames", async () => {
+		const frame = await walFrame({ path: "node", change: { event: "DATA" }, frame_seq: 0 });
+		const { change: _change, checksum: _checksum, ...missingChange } = frame;
+
+		expect(() => assertWalFrame(missingChange)).toThrow(/change payload/);
+		expect(() => assertWalFrame({ ...frame, restore: true })).toThrow(/unknown field restore/);
+		expect(() => assertWalFrame({ ...frame, checkpoint: { nodes: [] } })).toThrow(
+			/unknown field checkpoint/,
+		);
+		expect(() => assertWalFrame({ ...frame, path: "" })).toThrow(/path/);
+		expect(() => assertWalFrame({ ...frame, lifecycle: "restore" })).toThrow(/lifecycle/);
+		expect(() => assertWalFrame({ ...frame, frame_seq: -1 })).toThrow(/frame_seq/);
+		expect(() => assertWalFrame({ ...frame, frame_t_ns: "01" })).toThrow(/frame_t_ns/);
+		expect(() => assertWalFrame({ ...frame, format_version: WAL_FORMAT_VERSION + 1 })).toThrow(
+			/format_version/,
+		);
+		expect(() => assertWalFrame({ ...frame, checksum: "BAD" })).toThrow(/checksum/);
+		await expect(walFrameChecksum({ ...frame, change: "\uD800" })).rejects.toThrow(
+			/unknown field checksum/,
+		);
+		await expect(walFrameChecksum({ ...missingChange, change: "\uD800" })).rejects.toThrow(
+			/unpaired surrogate/,
+		);
+	});
+
+	it("walFrameCodec rejects restore-shaped extra fields instead of stripping them", async () => {
+		const frame = await walFrame({ path: "node", change: { event: "DATA" }, frame_seq: 0 });
+		const codec = walFrameCodec<{ event: string }>();
+
+		expect(() => codec.decode(strictJsonCodec.encode({ ...frame, restore: true }))).toThrow(
+			/unknown field restore/,
+		);
+		await expect(verifyWalFrameChecksum({ ...frame, checkpoint: { nodes: [] } })).rejects.toThrow(
+			/unknown field checkpoint/,
+		);
+	});
+
+	it("wal frames store and page as ordinary append-log facts", async () => {
+		const log = memoryAppendLog<WalFrame<{ value: string }>>("wal-store");
+		await log.append(await walFrame({ path: "a", change: { value: "a" }, frame_seq: 0 }));
+		await log.append(await walFrame({ path: "b", change: { value: "b" }, frame_seq: 1 }));
+		await log.append(await walFrame({ path: "c", change: { value: "c" }, frame_seq: 2 }));
+
+		const page = await readAppendLogPage(log, { limit: 2 });
+		expect(
+			page.entries.map((entry) => [entry.seq, entry.value.frame_seq, entry.value.path]),
+		).toEqual([
+			[0, 0, "a"],
+			[1, 1, "b"],
+		]);
+		expect(page.done).toBe(false);
+		expect((await readAppendLogPage(log, { after: page.nextAfter })).entries[0]?.value.path).toBe(
+			"c",
+		);
+	});
+
+	it("append logs refresh sequence allocation across sequential shared handles", async () => {
+		const kv = memoryKv<{ value: string }>();
+		const a = appendLogStorage({ kv, prefix: "shared" });
+		const b = appendLogStorage({ kv, prefix: "shared" });
+
+		await a.append({ value: "a" });
+		await b.append({ value: "b" });
+
+		expect((await a.read()).map((entry) => [entry.seq, entry.value.value])).toEqual([
+			[0, "a"],
+			[1, "b"],
+		]);
+	});
+
+	it("plain append logs remain single-writer and can collide under competing handles", async () => {
+		const entries = new Map<string, { value: string }>();
+		const heldLists: Array<() => void> = [];
+		let heldListCount = 2;
+		const listKeys = (prefix = "") =>
+			[...entries.keys()].filter((key) => key.startsWith(prefix)).sort();
+		const kv: KvStorageTier<{ value: string }> = {
+			get: (key) => Promise.resolve(entries.get(key)),
+			set: (key, value) => {
+				entries.set(key, value);
+				return Promise.resolve();
+			},
+			delete: (key) => {
+				entries.delete(key);
+				return Promise.resolve();
+			},
+			list: (prefix = "") => {
+				if (heldListCount > 0) {
+					heldListCount -= 1;
+					return new Promise<readonly string[]>((resolve) => {
+						heldLists.push(() => resolve(listKeys(prefix)));
+					});
+				}
+				return Promise.resolve(listKeys(prefix));
+			},
+		};
+		const a = appendLogStorage({ kv, prefix: "race" });
+		const b = appendLogStorage({ kv, prefix: "race" });
+
+		const appendA = a.append({ value: "a" });
+		const appendB = b.append({ value: "b" });
+		await Promise.resolve();
+		expect(heldLists).toHaveLength(2);
+		for (const release of heldLists) release();
+
+		const written = await Promise.all([appendA, appendB]);
+		expect(written.map((entry) => entry.seq)).toEqual([0, 0]);
+		expect((await a.read()).map((entry) => entry.seq)).toEqual([0]);
+		expect(await a.size()).toBe(1);
+	});
+
+	it("append logs reject malformed keys under the log prefix", async () => {
+		const kv = memoryKv<{ value: string }>();
+		await kv.set("bad/meta", { value: "oops" });
+		const log = appendLogStorage({ kv, prefix: "bad" });
+
+		await expect(log.append({ value: "a" })).rejects.toThrow(/non-numeric sequence/);
+
+		const unpadded = memoryKv<{ value: string }>();
+		await unpadded.set("bad-pad/1", { value: "oops" });
+		await expect(appendLogStorage({ kv: unpadded, prefix: "bad-pad" }).read()).rejects.toThrow(
+			/padded digits/,
+		);
+		await expect(appendLogStorage({ kv: unpadded, prefix: "bad-pad" }).size()).rejects.toThrow(
+			/padded digits/,
+		);
+	});
+
+	it("append logs reject unsafe sequence allocation before writing", async () => {
+		const kv = memoryKv<{ value: string }>();
+		await kv.set(appendLogKey("max", Number.MAX_SAFE_INTEGER), { value: "max" });
+		const log = appendLogStorage({ kv, prefix: "max" });
+
+		await expect(log.append({ value: "overflow" })).rejects.toThrow(/safe integer/);
+		expect(await kv.list("max/")).toEqual([appendLogKey("max", Number.MAX_SAFE_INTEGER)]);
+	});
+
+	it("append-log reads validate cursors, limits, and listed key presence", async () => {
+		const kv = memoryKv<{ value: string }>();
+		const log = appendLogStorage({ kv, prefix: "opts" });
+		await log.append({ value: "a" });
+
+		await expect(log.read({ after: Number.NaN })).rejects.toThrow(/after/);
+		await expect(log.read({ after: 0.5 })).rejects.toThrow(/after/);
+		await expect(log.read({ limit: -1 })).rejects.toThrow(/limit/);
+		await expect(log.read({ limit: 0.5 })).rejects.toThrow(/limit/);
+		expect(await log.read({ limit: 0 })).toEqual([]);
+
+		const torn: KvStorageTier<{ value: string }> = {
+			get: () => Promise.resolve(undefined),
+			set: () => Promise.resolve(),
+			delete: () => Promise.resolve(),
+			list: () => Promise.resolve(["torn/00000000000000000000"]),
+		};
+		await expect(appendLogStorage({ kv: torn, prefix: "torn" }).read()).rejects.toThrow(
+			/listed key is missing/,
+		);
+	});
+
+	it("readAppendLogPage propagates malformed sequence keys and missing listed values", async () => {
+		const malformed = memoryKv<{ value: string }>();
+		await malformed.set(appendLogKey("strict-page", 0), { value: "a" });
+		await malformed.set("strict-page/not-a-sequence", { value: "bad" });
+		const malformedLog = appendLogStorage({ kv: malformed, prefix: "strict-page" });
+
+		await expect(readAppendLogPage(malformedLog)).rejects.toThrow(/non-numeric sequence/);
+
+		const torn: KvStorageTier<{ value: string }> = {
+			get: (key) =>
+				Promise.resolve(key === appendLogKey("strict-torn", 0) ? { value: "a" } : undefined),
+			set: () => Promise.resolve(),
+			delete: () => Promise.resolve(),
+			list: () => Promise.resolve([appendLogKey("strict-torn", 0), appendLogKey("strict-torn", 1)]),
+		};
+		const tornLog = appendLogStorage({ kv: torn, prefix: "strict-torn" });
+
+		await expect(readAppendLogPage(tornLog)).rejects.toThrow(/listed key is missing/);
+	});
+
+	it("readAppendLogPage continues deterministically across gaps after deletion between pages", async () => {
+		const kv = memoryKv<{ value: string }>();
+		const log = appendLogStorage({ kv, prefix: "gapped" });
+		await log.append({ value: "a" });
+		await log.append({ value: "b" });
+		await log.append({ value: "c" });
+		await log.append({ value: "d" });
+
+		const first = await readAppendLogPage(log, { limit: 1 });
+		expect(first.entries.map((entry) => [entry.seq, entry.value.value])).toEqual([[0, "a"]]);
+
+		await kv.delete(appendLogKey("gapped", 1));
+		const second = await readAppendLogPage(log, { after: first.nextAfter, limit: 2 });
+		expect(second.entries.map((entry) => [entry.seq, entry.value.value])).toEqual([
+			[2, "c"],
+			[3, "d"],
+		]);
+		expect(second.nextAfter).toBe(3);
+		expect(second.done).toBe(true);
+	});
+
+	it("append logs serialize concurrent appends without reusing a sequence", async () => {
+		const log = memoryAppendLog<{ value: string }>("concurrent");
+
+		await Promise.all([log.append({ value: "a" }), log.append({ value: "b" })]);
+
+		expect((await log.read()).map((entry) => entry.seq)).toEqual([0, 1]);
+		expect(await log.size()).toBe(2);
+	});
+
+	it("multi-writer append logs reject KV tiers without putIfAbsent clearly", () => {
+		const kv: KvStorageTier<{ value: string }> = {
+			get: () => Promise.resolve(undefined),
+			set: () => Promise.resolve(),
+			delete: () => Promise.resolve(),
+			list: () => Promise.resolve([]),
+		};
+
+		expect(() => multiWriterAppendLogStorage({ kv, prefix: "unsupported" })).toThrow(/putIfAbsent/);
+	});
+
+	it("multi-writer append logs reject kvStorage backed by plain byte KV", () => {
+		const kv = kvStorage<{ value: string }>({
+			backend: {
+				get: () => undefined,
+				put: () => undefined,
+				list: () => [],
+			},
+		});
+
+		expect(() => multiWriterAppendLogStorage({ kv, prefix: "plain-byte" })).toThrow(/putIfAbsent/);
+	});
+
+	it("multi-writer append logs retry conditional creates into unique ordered sequence keys", async () => {
+		const entries = new Map<string, { value: string }>();
+		const heldLists: Array<() => void> = [];
+		let heldListCount = 2;
+		const listKeys = (prefix = "") =>
+			[...entries.keys()].filter((key) => key.startsWith(prefix)).sort();
+		const kv: KvStorageTier<{ value: string }> = {
+			get: (key) => Promise.resolve(entries.get(key)),
+			set: (key, value) => {
+				entries.set(key, value);
+				return Promise.resolve();
+			},
+			putIfAbsent: (key, value) => {
+				if (entries.has(key)) return Promise.resolve(false);
+				entries.set(key, value);
+				return Promise.resolve(true);
+			},
+			delete: (key) => {
+				entries.delete(key);
+				return Promise.resolve();
+			},
+			list: (prefix = "") => {
+				if (heldListCount > 0) {
+					heldListCount -= 1;
+					return new Promise<readonly string[]>((resolve) => {
+						heldLists.push(() => resolve(listKeys(prefix)));
+					});
+				}
+				return Promise.resolve(listKeys(prefix));
+			},
+		};
+		const a = multiWriterAppendLogStorage({ kv, prefix: "mw" });
+		const b = multiWriterAppendLogStorage({ kv, prefix: "mw" });
+
+		const appendA = a.append({ value: "a" });
+		const appendB = b.append({ value: "b" });
+		await Promise.resolve();
+		expect(heldLists).toHaveLength(2);
+		for (const release of heldLists) release();
+
+		const written = await Promise.all([appendA, appendB]);
+		expect(written.map((entry) => entry.seq).sort((x, y) => x - y)).toEqual([0, 1]);
+		expect([...entries.keys()]).toEqual(["mw/00000000000000000000", "mw/00000000000000000001"]);
+		expect((await a.read()).map((entry) => [entry.seq, entry.value.value])).toEqual([
+			[0, "a"],
+			[1, "b"],
+		]);
+	});
+
+	it("multi-writer append logs refresh the listed tail after a retry window", async () => {
+		const entries = new Map<string, { value: string }>([
+			["refresh/00000000000000000000", { value: "existing-0" }],
+			["refresh/00000000000000000001", { value: "existing-1" }],
+		]);
+		let staleList = true;
+		const kv: KvStorageTier<{ value: string }> = {
+			get: (key) => Promise.resolve(entries.get(key)),
+			set: (key, value) => {
+				entries.set(key, value);
+				return Promise.resolve();
+			},
+			putIfAbsent: (key, value) => {
+				if (entries.has(key)) return Promise.resolve(false);
+				entries.set(key, value);
+				return Promise.resolve(true);
+			},
+			delete: (key) => {
+				entries.delete(key);
+				return Promise.resolve();
+			},
+			list: (prefix = "") => {
+				if (staleList) {
+					staleList = false;
+					return Promise.resolve([]);
+				}
+				return Promise.resolve([...entries.keys()].filter((key) => key.startsWith(prefix)).sort());
+			},
+		};
+		const log = multiWriterAppendLogStorage({ kv, prefix: "refresh", maxAttempts: 2 });
+
+		await expect(log.append({ value: "new" })).resolves.toMatchObject({
+			key: "refresh/00000000000000000002",
+			seq: 2,
+		});
+		expect((await log.read()).map((entry) => [entry.seq, entry.value.value])).toEqual([
+			[0, "existing-0"],
+			[1, "existing-1"],
+			[2, "new"],
+		]);
+	});
+
+	it("multi-writer append logs reject truncate without a stronger compaction capability", async () => {
+		const log = memoryMultiWriterAppendLog<{ value: string }>("mw-truncate");
+		await log.append({ value: "a" });
+
+		await expect(log.truncateAfter(0)).rejects.toThrow(/unsupported/);
+		expect((await log.read()).map((entry) => entry.value.value)).toEqual(["a"]);
+	});
+
+	it("memoryMultiWriterAppendLog uses putIfAbsent-backed allocation", async () => {
+		const log = memoryMultiWriterAppendLog<{ value: string }>("memory-mw");
+
+		await Promise.all([log.append({ value: "a" }), log.append({ value: "b" })]);
+
+		expect((await log.read()).map((entry) => entry.seq)).toEqual([0, 1]);
+	});
+
+	it("multi-writer append-log size rejects malformed listed sequence keys", async () => {
+		const kv = memoryKv<{ value: string }>();
+		await kv.set("mw-bad/1", { value: "oops" });
+		const log = multiWriterAppendLogStorage({ kv: requireKvPutIfAbsent(kv), prefix: "mw-bad" });
+
+		await expect(log.size()).rejects.toThrow(/padded digits/);
+	});
+
+	it("append-log reads are serialized before later mutations", async () => {
+		const entries = new Map<string, { value: string }>();
+		let holdNextList = false;
+		let releaseList: (() => void) | null = null;
+		const kv: KvStorageTier<{ value: string }> = {
+			get: (key) => Promise.resolve(entries.get(key)),
+			set: (key, value) => {
+				entries.set(key, value);
+				return Promise.resolve();
+			},
+			delete: (key) => {
+				entries.delete(key);
+				return Promise.resolve();
+			},
+			list: (prefix = "") => {
+				if (!holdNextList) {
+					return Promise.resolve(
+						[...entries.keys()].filter((key) => key.startsWith(prefix)).sort(),
+					);
+				}
+				holdNextList = false;
+				return new Promise<readonly string[]>((resolve) => {
+					releaseList = () =>
+						resolve([...entries.keys()].filter((key) => key.startsWith(prefix)).sort());
+				});
+			},
+		};
+		const log = appendLogStorage({ kv, prefix: "ordered" });
+		await log.append({ value: "a" });
+
+		holdNextList = true;
+		const read = log.read();
+		const append = log.append({ value: "b" });
+		await Promise.resolve();
+		expect(releaseList).not.toBeNull();
+		releaseList?.();
+
+		expect((await read).map((entry) => entry.value.value)).toEqual(["a"]);
+		await append;
+		expect((await log.read()).map((entry) => entry.value.value)).toEqual(["a", "b"]);
+	});
+
+	it("attachObserveEventLog persists observe DATA frames in observe sequence order", async () => {
+		const g = graph();
+		const count = g.state(0, { name: "count" });
+		const log = memoryAppendLog<ObserveEventFrame<number>>("observe");
+
+		const handle = attachObserveEventLog<number>(g, log, {
+			path: "count",
+			map: (event) => (event.msg[0] === "DATA" ? (event.msg[1] as number) : undefined),
+		});
+
+		count.set(1);
+		count.set(2);
+		await awaitDone((done) => handle.flush(done));
+
+		const frames = (await log.read()).map((entry) => entry.value);
+		expect(frames.map((frame) => frame.change)).toEqual([0, 1, 2]);
+		expect(frames.map((frame) => frame.path)).toEqual(["count", "count", "count"]);
+		expect(frames.map((frame) => frame.observeSeq)).toEqual(
+			[...frames.map((frame) => frame.observeSeq)].sort((a, b) => a - b),
+		);
+
+		await awaitDone((done) => handle.dispose(done));
+		count.set(3);
+		await awaitDone((done) => handle.flush(done));
+		expect((await log.read()).map((entry) => entry.value.change)).toEqual([0, 1, 2]);
+	});
+
+	it("readObserveEventLogPage returns ordered observe frames without projection", async () => {
+		const log = memoryAppendLog<ObserveEventFrame<number>>("observe-page");
+		await log.append(observeEventFrame({ path: "count", msg: ["DATA", 1], tier: 3, seq: 1 }, 1));
+		await log.append(observeEventFrame({ path: "count", msg: ["DATA", 2], tier: 3, seq: 2 }, 2));
+
+		const page = await readObserveEventLogPage(log, { limit: 1 });
+		expect(page.entries.map((entry) => entry.value.change)).toEqual([1]);
+		expect(page.entries[0]?.value.observeSeq).toBe(1);
+		expect(page.done).toBe(false);
+
+		const rest = await readObserveEventLogPage(log, { after: page.nextAfter, limit: 1 });
+		expect(rest.entries.map((entry) => entry.value.change)).toEqual([2]);
+		expect(rest.done).toBe(true);
+	});
+
+	it("readObserveEventLogPage orders by append sequence, not graph projection semantics", async () => {
+		const entries = new Map<string, ObserveEventFrame<number>>([
+			[
+				appendLogKey("observe-unordered", 10),
+				observeEventFrame({ path: "count", msg: ["DATA", 3], tier: 3, seq: 7 }, 3),
+			],
+			[
+				appendLogKey("observe-unordered", 0),
+				observeEventFrame({ path: "count", msg: ["DATA", 1], tier: 3, seq: 10 }, 1),
+			],
+			[
+				appendLogKey("observe-unordered", 2),
+				observeEventFrame({ path: "count", msg: ["DATA", 2], tier: 3, seq: 5 }, 2),
+			],
+		]);
+		const kv: KvStorageTier<ObserveEventFrame<number>> = {
+			get: (key) => Promise.resolve(entries.get(key)),
+			set: (key, value) => {
+				entries.set(key, value);
+				return Promise.resolve();
+			},
+			delete: (key) => {
+				entries.delete(key);
+				return Promise.resolve();
+			},
+			list: (prefix = "") =>
+				Promise.resolve([...entries.keys()].filter((key) => key.startsWith(prefix))),
+		};
+		const log = appendLogStorage({ kv, prefix: "observe-unordered" });
+
+		const page = await readObserveEventLogPage(log, { limit: 3 });
+		expect(page.entries.map((entry) => [entry.seq, entry.value.change])).toEqual([
+			[0, 1],
+			[2, 2],
+			[10, 3],
+		]);
+		expect(page.entries.map((entry) => entry.value.observeSeq)).toEqual([10, 5, 7]);
+		expect(page.done).toBe(true);
+	});
+
+	it("readObserveEventLogPage propagates append-log iteration failures", async () => {
+		const torn: KvStorageTier<ObserveEventFrame<number>> = {
+			get: () => Promise.resolve(undefined),
+			set: () => Promise.resolve(),
+			delete: () => Promise.resolve(),
+			list: () => Promise.resolve([appendLogKey("observe-torn", 0)]),
+		};
+		const tornLog = appendLogStorage({ kv: torn, prefix: "observe-torn" });
+
+		await expect(readObserveEventLogPage(tornLog)).rejects.toThrow(/listed key is missing/);
+
+		const malformed = memoryKv<ObserveEventFrame<number>>();
+		await malformed.set(
+			"observe-bad/not-a-sequence",
+			observeEventFrame({ path: "count", msg: ["DATA", 1], tier: 3, seq: 1 }, 1),
+		);
+		const malformedLog = appendLogStorage({ kv: malformed, prefix: "observe-bad" });
+
+		await expect(readObserveEventLogPage(malformedLog)).rejects.toThrow(/non-numeric sequence/);
+	});
+});
diff --git a/packages/ts/src/__tests__/storage.d82-storage-substrate-helpers-part-03.test.ts b/packages/ts/src/__tests__/storage.d82-storage-substrate-helpers-part-03.test.ts
new file mode 100644
index 00000000..09d68423
--- /dev/null
+++ b/packages/ts/src/__tests__/storage.d82-storage-substrate-helpers-part-03.test.ts
@@ -0,0 +1,241 @@
+import { mkdtempSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { describe, expect, it } from "vitest";
+import * as observeStorageExports from "../adapters/observe-storage.js";
+import { attachObserveEventLog, attachObserveSink } from "../adapters/observe-storage.js";
+import * as rootExports from "../index.js";
+import {
+	assertDecimalIntegerString,
+	assertNonNegativeDecimalIntegerString,
+	assertStrictJsonObject,
+	assertStrictJsonValue,
+	assertWalFrame,
+	bigIntToDecimalString,
+	bigIntToNonNegativeDecimalString,
+	changeEnvelopeCodec,
+	contentAddressedKv,
+	contentAddressedStorage,
+	decimalStringToBigInt,
+	graph,
+	hasKvPutIfAbsent,
+	hasKvVersioned,
+	hasStoragePutIfAbsent,
+	hasStorageVersioned,
+	isDecimalIntegerString,
+	isNonNegativeDecimalIntegerString,
+	memoryBackend,
+	memoryMultiWriterAppendLog,
+	multiWriterAppendLogStorage,
+	nonNegativeDecimalStringToBigInt,
+	nowNs,
+	observeEventFrame,
+	observeEventFrameCodec,
+	readAppendLogPage,
+	readObserveEventLogPage,
+	readThroughKv,
+	requireKvPutIfAbsent,
+	requireKvVersioned,
+	requireStoragePutIfAbsent,
+	requireStorageVersioned,
+	restoreGraph,
+	strictCanonicalJsonBytes,
+	strictJsonCodec,
+	strictJsonCodecFor,
+	tieredReadThrough,
+	verifyWalFrameChecksum,
+	walFrame,
+	walFrameChecksum,
+	walFrameCodec,
+	walFrameKey,
+	walFramePrefix,
+	webStorageBackend,
+} from "../index.js";
+import * as storageExports from "../storage/index.js";
+
+interface TestStorage {
+	entries: Record<string, string>;
+	getItem(key: string): string | null;
+	setItem(key: string, value: string): void;
+	removeItem(key: string): void;
+	key(index: number): string | null;
+	length: number;
+}
+
+const _createStorage = (): TestStorage => {
+	const entries: Record<string, string> = {};
+	const storage: TestStorage = {
+		get entries() {
+			return entries;
+		},
+		getItem(key) {
+			return entries[key] ?? null;
+		},
+		setItem(key, value) {
+			entries[key] = value;
+		},
+		removeItem(key) {
+			delete entries[key];
+		},
+		key(index) {
+			const keys = Object.keys(entries).sort();
+			return keys[index] ?? null;
+		},
+		get length() {
+			return Object.keys(entries).length;
+		},
+	};
+	return storage;
+};
+
+const _makeTempDir = () => mkdtempSync(join(tmpdir(), "graphrefly-ts-storage-"));
+
+const _flushMicrotasks = async (turns = 1) => {
+	for (let i = 0; i < turns; i += 1) await Promise.resolve();
+};
+
+const _awaitDone = (run: (done: () => void) => void) =>
+	new Promise<void>((resolve) => {
+		run(resolve);
+	});
+
+const bytesToHex = (bytes: Uint8Array) =>
+	[...bytes].map((byte) => byte.toString(16).padStart(2, "0")).join("");
+
+const _sha256Hex = async (bytes: Uint8Array) =>
+	bytesToHex(new Uint8Array(await globalThis.crypto.subtle.digest("SHA-256", bytes)));
+
+describe("D82 storage substrate helpers — part 3", () => {
+	it("change and observe-event codecs validate D82 storage frames only", () => {
+		const changeCodec = changeEnvelopeCodec<{ op: string }>();
+		const encodedChange = changeCodec.encode({
+			lifecycle: "data",
+			structure: "kv-change",
+			version: 1,
+			t_ns: "123",
+			seq: 0,
+			change: { op: "set" },
+		});
+		expect(changeCodec.decode(encodedChange).change).toEqual({ op: "set" });
+		expect(() =>
+			changeCodec.decode(
+				strictJsonCodec.encode({
+					lifecycle: "restore",
+					structure: "kv-change",
+					version: 1,
+					t_ns: "123",
+					change: {},
+				}),
+			),
+		).toThrow(/lifecycle/);
+		expect(() =>
+			changeCodec.decode(new TextEncoder().encode('{"change":{},"change":{"op":"set"}}')),
+		).toThrow(/duplicate object key/);
+		expect(() =>
+			changeCodec.decode(
+				new TextEncoder().encode(
+					'{"lifecycle":"data","structure":"kv-change","version":1,"t_ns":"123","change":{}}',
+				),
+			),
+		).toThrow(/canonical/);
+
+		const frame = observeEventFrame(
+			{ path: "count", msg: ["DATA", 1], tier: 3, seq: 7 },
+			{ value: 1 },
+			{ stream: "audit" },
+		);
+		const frameCodec = observeEventFrameCodec<{ value: number }>();
+		expect(frame).toMatchObject({
+			structure: "observe-event",
+			version: 1,
+			t_ns: expect.any(String),
+			stream: "audit",
+			observeSeq: 7,
+			path: "count",
+			change: { value: 1 },
+		});
+		expect(frame.t_ns).toMatch(/^(0|[1-9]\d*)$/);
+		expect(frameCodec.decode(frameCodec.encode(frame))).toEqual(frame);
+		expect(() =>
+			frameCodec.decode(new TextEncoder().encode('{"change":{},"change":{"value":1}}')),
+		).toThrow(/duplicate object key/);
+		expect(() =>
+			frameCodec.decode(
+				new TextEncoder().encode(
+					'{"lifecycle":"data","structure":"observe-event","version":1,"t_ns":"123","change":{},"observeSeq":1,"path":"count"}',
+				),
+			),
+		).toThrow(/canonical/);
+		expect(Object.keys(frame)).not.toEqual(
+			expect.arrayContaining(["snapshot", "restore", "checkpoint", "factory"]),
+		);
+	});
+
+	it("root and storage exports expose D82 helpers while storage-shaped snapshot/restore names stay absent", () => {
+		for (const exports of [rootExports, storageExports]) {
+			expect(exports.contentAddressedKv).toBe(contentAddressedKv);
+			expect(exports.contentAddressedStorage).toBe(contentAddressedStorage);
+			expect(exports.changeEnvelopeCodec).toBe(changeEnvelopeCodec);
+			expect(exports.observeEventFrameCodec).toBe(observeEventFrameCodec);
+			expect(exports.nowNs).toBe(nowNs);
+			expect(exports.assertDecimalIntegerString).toBe(assertDecimalIntegerString);
+			expect(exports.assertNonNegativeDecimalIntegerString).toBe(
+				assertNonNegativeDecimalIntegerString,
+			);
+			expect(exports.bigIntToDecimalString).toBe(bigIntToDecimalString);
+			expect(exports.bigIntToNonNegativeDecimalString).toBe(bigIntToNonNegativeDecimalString);
+			expect(exports.decimalStringToBigInt).toBe(decimalStringToBigInt);
+			expect(exports.isDecimalIntegerString).toBe(isDecimalIntegerString);
+			expect(exports.isNonNegativeDecimalIntegerString).toBe(isNonNegativeDecimalIntegerString);
+			expect(exports.nonNegativeDecimalStringToBigInt).toBe(nonNegativeDecimalStringToBigInt);
+			expect(exports.strictJsonCodec).toBe(strictJsonCodec);
+			expect(exports.strictJsonCodecFor).toBe(strictJsonCodecFor);
+			expect(exports.assertStrictJsonValue).toBe(assertStrictJsonValue);
+			expect(exports.assertStrictJsonObject).toBe(assertStrictJsonObject);
+			if (exports === rootExports) {
+				expect(Reflect.get(exports, "strictCanonicalJsonBytes")).toBe(strictCanonicalJsonBytes);
+			} else {
+				expect("strictCanonicalJsonBytes" in exports).toBe(false);
+			}
+			expect(exports.hasKvPutIfAbsent).toBe(hasKvPutIfAbsent);
+			expect(exports.hasStoragePutIfAbsent).toBe(hasStoragePutIfAbsent);
+			expect(exports.hasKvVersioned).toBe(hasKvVersioned);
+			expect(exports.hasStorageVersioned).toBe(hasStorageVersioned);
+			expect(exports.webStorageBackend).toBe(webStorageBackend);
+			expect(exports.memoryBackend).toBe(memoryBackend);
+			expect(exports.memoryMultiWriterAppendLog).toBe(memoryMultiWriterAppendLog);
+			expect(exports.multiWriterAppendLogStorage).toBe(multiWriterAppendLogStorage);
+			expect(exports.readAppendLogPage).toBe(readAppendLogPage);
+			expect(exports.readObserveEventLogPage).toBe(readObserveEventLogPage);
+			expect(exports.readThroughKv).toBe(readThroughKv);
+			expect(exports.tieredReadThrough).toBe(tieredReadThrough);
+			expect(exports.requireKvPutIfAbsent).toBe(requireKvPutIfAbsent);
+			expect(exports.requireStoragePutIfAbsent).toBe(requireStoragePutIfAbsent);
+			expect(exports.requireKvVersioned).toBe(requireKvVersioned);
+			expect(exports.requireStorageVersioned).toBe(requireStorageVersioned);
+			expect(exports.walFrame).toBe(walFrame);
+			expect(exports.walFrameChecksum).toBe(walFrameChecksum);
+			expect(exports.verifyWalFrameChecksum).toBe(verifyWalFrameChecksum);
+			expect(exports.walFrameCodec).toBe(walFrameCodec);
+			expect(exports.walFrameKey).toBe(walFrameKey);
+			expect(exports.walFramePrefix).toBe(walFramePrefix);
+			expect(exports.assertWalFrame).toBe(assertWalFrame);
+			expect("attachSnapshotStorage" in exports).toBe(false);
+			expect("restoreSnapshot" in exports).toBe(false);
+			expect("replayWal" in exports).toBe(false);
+			expect("GraphRestore" in exports).toBe(false);
+			expect("assertNodeVersionDataCompatible" in exports).toBe(false);
+			expect("snapshotNodeVersionData" in exports).toBe(false);
+		}
+		expect(rootExports.restoreGraph).toBe(restoreGraph);
+		expect("restoreGraph" in storageExports).toBe(false);
+		expect("attachObserveSink" in rootExports).toBe(false);
+		expect("attachObserveEventLog" in rootExports).toBe(false);
+		expect(observeStorageExports.attachObserveSink).toBe(attachObserveSink);
+		expect(observeStorageExports.attachObserveEventLog).toBe(attachObserveEventLog);
+		expect("attachObserveSink" in storageExports).toBe(false);
+		expect("attachObserveEventLog" in storageExports).toBe(false);
+		expect(typeof graph().checkpoint).toBe("function");
+		expect("restoreSnapshot" in graph()).toBe(false);
+	});
+});
diff --git a/packages/ts/src/__tests__/subpaths.test.ts b/packages/ts/src/__tests__/subpaths.test.ts
new file mode 100644
index 00000000..6965a2da
--- /dev/null
+++ b/packages/ts/src/__tests__/subpaths.test.ts
@@ -0,0 +1,1261 @@
+import { readdirSync, readFileSync, statSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { describe, expect, expectTypeOf, it } from "vitest";
+import * as adapters from "../adapters/index.js";
+import * as nestjsMicroservicesAdapters from "../adapters/nestjs/microservices.js";
+import * as nestjsNativeAdapters from "../adapters/nestjs/native.js";
+import * as nestjsWebsocketsAdapters from "../adapters/nestjs/websockets.js";
+import * as nestjsAdapters from "../adapters/nestjs.js";
+import * as observeStorage from "../adapters/observe-storage.js";
+import * as reactAdapters from "../adapters/react.js";
+import * as solidAdapters from "../adapters/solid.js";
+import * as svelteAdapters from "../adapters/svelte.js";
+import * as vueAdapters from "../adapters/vue.js";
+import * as composition from "../composition/index.js";
+import * as core from "../core/index.js";
+import * as cqrs from "../cqrs/index.js";
+import * as cqrsMessagingRecipe from "../cqrs/messaging.js";
+import * as cqrsWorkQueueRecipe from "../cqrs/work-queue.js";
+import type { DataIssue, DataResult } from "../data/index.js";
+import * as data from "../data/index.js";
+import type {
+	ReactiveOpt as DataStructuresReactiveOpt,
+	ReactiveView as DataStructuresReactiveView,
+	ViewCachePolicy as DataStructuresViewCachePolicy,
+} from "../data-structures/index.js";
+import * as dataStructures from "../data-structures/index.js";
+import * as executorToolProviderRecipe from "../executors/tool-provider.js";
+import * as executorToolProviderAdapters from "../executors/tool-provider-adapters.js";
+import * as executorToolProviderRuntime from "../executors/tool-provider-runtime.js";
+import * as executorWorkQueueRecipe from "../executors/work-queue.js";
+import * as graphLayer from "../graph/index.js";
+import type {
+	AgenticMemoryBundleOptions,
+	AgenticMemoryConsolidationBundleOptions,
+	AgenticMemoryContextPackingBundleOptions,
+	AgenticMemoryKgProjectionBundleOptions,
+	AgenticMemoryRecord,
+	AgenticMemoryRecordFrame,
+	AgenticMemoryRecordsPersistenceHandle,
+	AgenticMemoryRetentionBundleOptions,
+	AgenticMemoryScope,
+	AgenticMemoryStatus,
+	CapacityPolicy,
+	GraphCheckpoint,
+	KnowledgeAssertion,
+	KnowledgeGraphReducerBundleOptions,
+	MemoryFragment,
+	OrderedCapacityPolicy,
+	ReactiveIndexCapacityOrder,
+	ReactiveIndexCapacityPolicy,
+	ReactiveIndexOpt,
+	ReactiveIndexOptions,
+	ReactiveListOpt,
+	ReactiveLogOptions,
+	ReactiveMapOpt,
+	ReactiveMapOptions,
+	ReactiveMapRetentionEntry,
+	ReactiveMapRetentionPolicy,
+	ReactiveOpt,
+	ReactiveView,
+	RetentionPolicy,
+	TopologyGroup,
+	TopologyGroupOptions,
+	TopologyGroupReleaseOptions,
+	ViewCachePolicy,
+} from "../index.js";
+import * as rootPackage from "../index.js";
+import * as boundaryInspection from "../inspection/boundary.js";
+import * as messaging from "../messaging/index.js";
+import * as operators from "../operators/index.js";
+import type {
+	ExecutorArtifactMaterial,
+	ScheduledReadinessBundle,
+	ScheduledReadinessClock,
+	ScheduledReadinessReady,
+	ScheduledReadinessRequested,
+	ScheduledReadinessStatus,
+	SizeCapacityEvidence,
+	ToolProviderAdapterInput,
+	ToolProviderAdapterInputBundle,
+	ToolProviderAdapterInputStatus,
+	ToolProviderAdapterRunBundle,
+	ToolProviderAdapterRunRequested,
+	ToolProviderAdapterRunResult,
+	ToolProviderAdapterRunStatus,
+	ToolProviderExecutionPolicy,
+	ToolProviderPublicTextPolicy,
+	ToolProviderRunAdmissionBundle,
+	ToolProviderRunAdmissionDecision,
+	ToolProviderRunAdmissionProposal,
+	ToolProviderRunAdmissionStatus,
+	ToolProviderRunRetryBundle,
+	ToolProviderRunRetryPolicy,
+	ToolProviderRunRetryProposal,
+	ToolProviderRunRetryScheduled,
+	ToolProviderRunRetryStatus,
+} from "../orchestration/index.js";
+import * as orchestration from "../orchestration/index.js";
+import * as orchestrationMessagingRecipe from "../orchestration/messaging.js";
+import type {
+	WorkQueueLeaseExpirationCommandBundle,
+	WorkQueueReadinessHandoffBundle,
+	WorkQueueReadinessHandoffStatus,
+	WorkQueueScheduledReadinessBundle,
+	WorkQueueScheduledReadinessStatus,
+} from "../orchestration/work-queue.js";
+import * as orchestrationWorkQueueRecipe from "../orchestration/work-queue.js";
+import * as eventFlowPatterns from "../patterns/event-flow.js";
+import * as patterns from "../patterns/index.js";
+import * as render from "../render/index.js";
+import type { ImageSizeLookup } from "../solutions/index.js";
+import * as solutions from "../solutions/index.js";
+import * as reactiveLayoutBrowser from "../solutions/reactive-layout/browser/index.js";
+import * as reactiveLayoutCore from "../solutions/reactive-layout/index.js";
+import * as reactiveLayoutNodeCanvas from "../solutions/reactive-layout/node-canvas/index.js";
+import * as reactiveLayoutReactNative from "../solutions/reactive-layout/react-native/index.js";
+import * as reactiveLayoutSkia from "../solutions/reactive-layout/skia/index.js";
+import * as workItemActions from "../solutions/work-item/actions.js";
+import type {
+	WorkspaceProposalFamilyApplicationReadModelQuery,
+	WorkspaceProposalProjectionRelease,
+	WorkspaceProposalProjectionReleaseDiagnostic,
+	WorkspaceProposalRepairActionDescriptor,
+} from "../solutions/work-item/scheduling.js";
+import * as workItemScheduling from "../solutions/work-item/scheduling.js";
+import * as workItemWorkQueueRecipe from "../solutions/work-item/work-queue.js";
+import * as sourcesBrowser from "../sources/browser.js";
+import * as sources from "../sources/index.js";
+import * as sourcesNode from "../sources/node.js";
+import * as storageBrowser from "../storage/browser.js";
+import * as storage from "../storage/index.js";
+import * as storageNode from "../storage/node.js";
+import * as testing from "../testing/index.js";
+import * as workQueueModule from "../work-queue/index.js";
+
+const packageJsonPath = join(dirname(fileURLToPath(import.meta.url)), "..", "..", "package.json");
+const exportsJson = JSON.parse(readFileSync(packageJsonPath, "utf8")) as {
+	exports?: Record<string, unknown>;
+};
+
+function listTsFiles(dir: string): string[] {
+	const files: string[] = [];
+	for (const entry of readdirSync(dir)) {
+		const path = join(dir, entry);
+		const stat = statSync(path);
+		if (stat.isDirectory()) {
+			files.push(...listTsFiles(path));
+			continue;
+		}
+		if (entry.endsWith(".ts")) files.push(path);
+	}
+	return files;
+}
+
+function docsPath(...segments: string[]): string {
+	return join(
+		dirname(fileURLToPath(import.meta.url)),
+		"..",
+		"..",
+		"..",
+		"..",
+		"website",
+		...segments,
+	);
+}
+
+describe("package subpath barrels (D40/D41 intent parity)", () => {
+	it("publishes only the intended package subpaths", () => {
+		expect(Object.keys(exportsJson.exports ?? {}).sort()).toEqual([
+			".",
+			"./adapters",
+			"./adapters/nestjs",
+			"./adapters/nestjs/microservices",
+			"./adapters/nestjs/native",
+			"./adapters/nestjs/websockets",
+			"./adapters/observe-storage",
+			"./adapters/react",
+			"./adapters/solid",
+			"./adapters/svelte",
+			"./adapters/vue",
+			"./composition",
+			"./core",
+			"./cqrs",
+			"./cqrs/messaging",
+			"./cqrs/work-queue",
+			"./data",
+			"./data-structures",
+			"./executors/tool-provider",
+			"./executors/tool-provider-adapters",
+			"./executors/tool-provider-runtime",
+			"./executors/work-queue",
+			"./graph",
+			"./inspection/boundary",
+			"./messaging",
+			"./operators",
+			"./orchestration",
+			"./orchestration/messaging",
+			"./orchestration/work-queue",
+			"./patterns",
+			"./patterns/event-flow",
+			"./render",
+			"./solutions",
+			"./solutions/reactive-layout",
+			"./solutions/reactive-layout/browser",
+			"./solutions/reactive-layout/node-canvas",
+			"./solutions/reactive-layout/react-native",
+			"./solutions/reactive-layout/skia",
+			"./solutions/work-item/actions",
+			"./solutions/work-item/scheduling",
+			"./solutions/work-item/work-queue",
+			"./sources",
+			"./sources/browser",
+			"./sources/node",
+			"./storage",
+			"./storage/browser",
+			"./storage/node",
+			"./testing",
+			"./work-queue",
+		]);
+		expect(exportsJson.exports?.["./base"]).toBeUndefined();
+		expect(exportsJson.exports?.["./compat"]).toBeUndefined();
+		expect(exportsJson.exports?.["./canvas"]).toBeUndefined();
+		expect(exportsJson.exports?.["./solutions/canvas"]).toBeUndefined();
+		expect(exportsJson.exports?.["./workspace-intents"]).toBeUndefined();
+		expect(exportsJson.exports?.["./solutions/workspace-intents"]).toBeUndefined();
+		expect(exportsJson.exports?.["./presets"]).toBeUndefined();
+		expect(exportsJson.exports?.["./utils"]).toBeUndefined();
+		expect(exportsJson.exports?.["./graph/render"]).toBeUndefined();
+		expect(exportsJson.exports?.["./graph/sources"]).toBeUndefined();
+		expect(exportsJson.exports?.["./graph/operators"]).toBeUndefined();
+		expect(exportsJson.exports?.["./storage/wal"]).toBeUndefined();
+	});
+
+	it("keeps the integration matrix aligned with published package subpaths", () => {
+		const matrix = readFileSync(
+			docsPath("src", "content", "docs", "integrations", "matrix.md"),
+			"utf8",
+		);
+		const matrixEntries = matrix
+			.split("\n")
+			.filter((line) => line.startsWith("|"))
+			.map((line) => line.split("|").map((cell) => cell.trim())[3])
+			.filter((cell): cell is string => cell !== undefined);
+		const documentedSubpaths = Array.from(
+			matrixEntries
+				.filter((entry) => /^`@graphrefly\/ts(?:\/[\w./-]+)?`$/.test(entry))
+				.join("\n")
+				.matchAll(/`(@graphrefly\/ts(?:\/[\w./-]+)?)`/g),
+			(match) => match[1],
+		).map((specifier) =>
+			specifier === "@graphrefly/ts" ? "." : `.${specifier.slice("@graphrefly/ts".length)}`,
+		);
+
+		expect(documentedSubpaths.length).toBeGreaterThan(0);
+		for (const subpath of documentedSubpaths) {
+			expect(exportsJson.exports, subpath).toHaveProperty(subpath);
+		}
+		for (const subpath of Object.keys(exportsJson.exports ?? {})) {
+			expect(documentedSubpaths, subpath).toContain(subpath);
+		}
+		for (const staleEntry of [
+			"fromOTel",
+			"fromKafka",
+			"fromWebhook",
+			"toSSE",
+			"fromMCP",
+			"toPostgres",
+		]) {
+			expect(matrixEntries).not.toContain(`\`${staleEntry}\``);
+		}
+	});
+
+	it("exposes the clean-slate layer surfaces from source barrels", () => {
+		expect(typeof core.node).toBe("function");
+		expect(typeof graphLayer.Graph).toBe("function");
+		expect(typeof graphLayer.graph).toBe("function");
+		expect(typeof graphLayer.coalesceObserve).toBe("function");
+		expect(typeof graphLayer.domWebSocketDriver).toBe("function");
+		expect(typeof graphLayer.explainPath).toBe("function");
+		expect(typeof graphLayer.fetchHttpDriver).toBe("function");
+		expect(typeof graphLayer.filterObserve).toBe("function");
+		expect(typeof graphLayer.GRAPH_CHECKPOINT_VERSION).toBe("string");
+		expect(typeof graphLayer.reachable).toBe("function");
+		expect(typeof graphLayer.restoreGraph).toBe("function");
+		expect(typeof graphLayer.validateNoIslands).toBe("function");
+		expect(typeof operators.map).toBe("function");
+		expect(typeof operators.switchMap).toBe("function");
+		expect(typeof operators.repeat).toBe("function");
+		expect(typeof operators.audit).toBe("function");
+		expect(typeof operators.auditTime).toBe("function");
+		expect(typeof operators.bufferTime).toBe("function");
+		expect(typeof operators.timeout).toBe("function");
+		expect(typeof operators.define).toBe("function");
+		expect(typeof operators.restoreRegistry).toBe("function");
+		expect(typeof sources.fromAny).toBe("function");
+		expect(typeof sources.fromCron).toBe("function");
+		expect(typeof sources.fromEvent).toBe("function");
+		expect(typeof sources.fromPushNotification).toBe("function");
+		expect(typeof sources.firstValueFrom).toBe("function");
+		expect(typeof sources.matchesCron).toBe("function");
+		expect(typeof sources.parseCron).toBe("function");
+		expect(typeof sources.singleFromAny).toBe("function");
+		expect(typeof sources.timer).toBe("function");
+		expect(typeof sources.fromTimer).toBe("function");
+		expect(typeof sources.of).toBe("function");
+		expect(typeof sources.throwError).toBe("function");
+		expect(Object.hasOwn(sources, "fromFSWatch")).toBe(false);
+		expect(Object.hasOwn(sources, "fromRaf")).toBe(false);
+		expect(typeof composition.topologyDiff).toBe("function");
+		expect(typeof dataStructures.reactiveMap).toBe("function");
+		expect(typeof render.describeToJson).toBe("function");
+		expect(typeof render.describeToMermaidUrl).toBe("function");
+		expect(typeof adapters.jotaiAtom).toBe("function");
+		expect(typeof adapters.nanoAtom).toBe("function");
+		expect(typeof adapters.recordReadableStore).toBe("function");
+		expect(typeof adapters.signalFromNode).toBe("function");
+		expect(typeof adapters.externalStore).toBe("function");
+		expect(typeof adapters.readableStore).toBe("function");
+		expect(typeof adapters.subscribeNodeValues).toBe("function");
+		expect(Object.hasOwn(adapters, "fromNestReq")).toBe(false);
+		expect(Object.hasOwn(adapters, "toNestHttp")).toBe(false);
+		expect(Object.hasOwn(adapters, "reactExternalStore")).toBe(false);
+		expect(Object.hasOwn(adapters, "svelteReadableStore")).toBe(false);
+		expect(Object.hasOwn(adapters, "svelteWritableStore")).toBe(false);
+		expect(typeof reactAdapters.useNodeValue).toBe("function");
+		expect(typeof reactAdapters.useNodeInput).toBe("function");
+		expect(typeof reactAdapters.useNodeRecord).toBe("function");
+		expect(typeof vueAdapters.useNodeValue).toBe("function");
+		expect(typeof vueAdapters.useNodeInput).toBe("function");
+		expect(typeof vueAdapters.useNodeRecord).toBe("function");
+		expect(typeof solidAdapters.createNodeValue).toBe("function");
+		expect(typeof solidAdapters.createNodeInput).toBe("function");
+		expect(typeof solidAdapters.createNodeRecord).toBe("function");
+		expect(typeof svelteAdapters.nodeReadable).toBe("function");
+		expect(typeof svelteAdapters.nodeWritable).toBe("function");
+		expect(typeof svelteAdapters.nodeRecord).toBe("function");
+		expect(typeof boundaryInspection.boundaryManifest).toBe("function");
+		expect(typeof adapters.toHttp).toBe("function");
+		expect(typeof adapters.toProcess).toBe("function");
+		expect(typeof adapters.toWebSocket).toBe("function");
+		expect(typeof adapters.webSocketSession).toBe("function");
+		expect(typeof adapters.remoteCall).toBe("function");
+		expect(typeof adapters.remoteResponder).toBe("function");
+		expect(typeof adapters.remoteResponderHandler).toBe("function");
+		expect(typeof adapters.wireBridge).toBe("function");
+		expect(typeof adapters.wireBridgeEnvelope).toBe("function");
+		expect(typeof adapters.wireBridgeIdempotencyKey).toBe("function");
+		expect(Object.hasOwn(adapters, "dedupeReducer")).toBe(false);
+		expect(typeof adapters.writableStore).toBe("function");
+		expect(typeof adapters.zustandStore).toBe("function");
+		expect(typeof nestjsAdapters.fromNestReq).toBe("function");
+		expect(typeof nestjsAdapters.fromNestGuard).toBe("function");
+		expect(typeof nestjsAdapters.fromNestIntercept).toBe("function");
+		expect(typeof nestjsAdapters.fromNestError).toBe("function");
+		expect(typeof nestjsAdapters.fromNestLifecycle).toBe("function");
+		expect(typeof nestjsAdapters.fromNestCron).toBe("function");
+		expect(typeof nestjsAdapters.fromNestDiagnostics).toBe("function");
+		expect(typeof nestjsAdapters.sanitizeNestDiagnostic).toBe("function");
+		expect(typeof nestjsAdapters.toNestHttp).toBe("function");
+		expect(typeof nestjsAdapters.GraphFilter).toBe("function");
+		expect(typeof nestjsAdapters.GraphGuardDecision).toBe("function");
+		expect(typeof nestjsAdapters.getGraphToken).toBe("function");
+		expect(typeof nestjsAdapters.getNestBoundaryToken).toBe("function");
+		expect(typeof nestjsNativeAdapters.createGraphCronController).toBe("function");
+		expect(typeof nestjsNativeAdapters.graphCronTarget).toBe("function");
+		expect(typeof nestjsNativeAdapters.graphLifecycleTarget).toBe("function");
+		expect(typeof nestjsNativeAdapters.provideGraphBoundaryInterceptor).toBe("function");
+		expect(typeof nestjsNativeAdapters.provideGraphGuard).toBe("function");
+		expect(typeof nestjsNativeAdapters.createGraphExceptionFilter).toBe("function");
+		expect(typeof nestjsNativeAdapters.provideGraphExceptionFilter).toBe("function");
+		expect(typeof nestjsNativeAdapters.createGraphGuardDeniedFilter).toBe("function");
+		expect(typeof nestjsNativeAdapters.provideGraphGuardDeniedFilter).toBe("function");
+		expect(typeof nestjsNativeAdapters.provideGraphCronScheduler).toBe("function");
+		expect(typeof nestjsNativeAdapters.provideGraphLifecycleHooks).toBe("function");
+		expect(typeof nestjsNativeAdapters.provideGraphNativeHttpProviders).toBe("function");
+		expect(typeof nestjsNativeAdapters.provideGraphNativeProviders).toBe("function");
+		expect(typeof nestjsNativeAdapters.GRAPHREFLY_NEST_EXCEPTION_FILTER).toBe("symbol");
+		expect(typeof nestjsWebsocketsAdapters.fromNestWs).toBe("function");
+		expect(typeof nestjsWebsocketsAdapters.provideGraphWsProviders).toBe("function");
+		expect(typeof nestjsMicroservicesAdapters.fromNestMessage).toBe("function");
+		expect(typeof nestjsMicroservicesAdapters.provideGraphMessageProviders).toBe("function");
+		expect(typeof observeStorage.attachObserveEventLog).toBe("function");
+		expect(typeof observeStorage.attachObserveSink).toBe("function");
+		expect(typeof patterns.profileSummary).toBe("function");
+		expect(typeof patterns.eventFlow).toBe("function");
+		expect(typeof patterns.eventFlowProjection).toBe("function");
+		expect(typeof eventFlowPatterns.eventFlow).toBe("function");
+		expect(typeof eventFlowPatterns.eventFlowProjection).toBe("function");
+		expect(typeof patterns.cosineSimilarity).toBe("function");
+		expect(typeof patterns.admissionScored).toBe("function");
+		expect(typeof patterns.admissionFilter3D).toBe("function");
+		expect(typeof patterns.shardByTenant).toBe("function");
+		expect(typeof patterns.validateMemoryFragment).toBe("function");
+		expect(typeof patterns.filterMemoryFragments).toBe("function");
+		expect(typeof patterns.memoryRetrievalBundle).toBe("function");
+		expect(typeof patterns.knowledgeGraphReducerBundle).toBe("function");
+		expect(typeof adapters.persistAgenticMemoryRecords).toBe("function");
+		expect(typeof adapters.openPersistentAgenticMemoryRecords).toBe("function");
+		expect(typeof adapters.loadAgenticMemoryRecordsState).toBe("function");
+		expect(typeof storage.memoryKv).toBe("function");
+		expect(typeof storage.memoryAppendLog).toBe("function");
+		expect(typeof storage.multiWriterAppendLogStorage).toBe("function");
+		expect(typeof storage.memoryMultiWriterAppendLog).toBe("function");
+		expect(typeof storage.tieredReadThrough).toBe("function");
+		expect(typeof storage.readThroughKv).toBe("function");
+		expect(typeof storage.readAppendLogPage).toBe("function");
+		expect(typeof storage.readObserveEventLogPage).toBe("function");
+		expect(typeof storage.walFrame).toBe("function");
+		expect(typeof storage.walFrameKey).toBe("function");
+		expect(typeof testing.assertDirtyPrecedesTerminalData).toBe("function");
+		expect(Object.hasOwn(storage, "attachObserveSink")).toBe(false);
+		expect(Object.hasOwn(storage, "attachObserveEventLog")).toBe(false);
+		expectTypeOf<DataIssue>().toMatchTypeOf<{
+			readonly kind: "issue";
+			readonly code: string;
+			readonly message: string;
+		}>();
+		expectTypeOf<DataResult<number>>().toMatchTypeOf<
+			| { readonly kind: "ok"; readonly value: number }
+			| { readonly kind: "error"; readonly error: DataIssue }
+		>();
+		expect(Object.keys(data)).toEqual([]);
+		expect(typeof cqrs.cqrs).toBe("function");
+		expect(typeof cqrs.cqrsCommandHandler).toBe("function");
+		expect(typeof cqrs.cqrsProjection).toBe("function");
+		expect(Object.hasOwn(cqrs, "dedupeReducer")).toBe(false);
+		expect(typeof cqrsMessagingRecipe.cqrsMessagingRecipe).toBe("function");
+		expect(typeof cqrsWorkQueueRecipe.cqrsWorkQueueRecipe).toBe("function");
+		expect(Object.hasOwn(cqrs, "cqrsMessagingRecipe")).toBe(false);
+		expect(Object.hasOwn(cqrs, "cqrsWorkQueueRecipe")).toBe(false);
+		expect(typeof messaging.messageBus).toBe("function");
+		expect(typeof messaging.eventMessage).toBe("function");
+		expect(typeof messaging.isEventMessage).toBe("function");
+		expect(typeof messaging.fromTopic).toBe("function");
+		expect(typeof messaging.toTopic).toBe("function");
+		expect(Object.hasOwn(messaging, "dynamicHub")).toBe(false);
+		expect(Object.hasOwn(messaging, "fromHubTopic")).toBe(false);
+		expect(Object.hasOwn(messaging, "toHubTopic")).toBe(false);
+		expect(messaging.PROMPTS_TOPIC).toBe("prompts");
+		expect(messaging.STANDARD_TOPICS).toEqual([
+			"prompts",
+			"responses",
+			"injections",
+			"deferred",
+			"spawns",
+			"context",
+			"todos",
+		]);
+		expect(typeof workQueueModule.workQueue).toBe("function");
+		expect(typeof workItemActions.workItemDomainActionProposalIntakeProjector).toBe("function");
+		expect(typeof workItemActions.workItemDomainActionAdmissionProjector).toBe("function");
+		expect(typeof workItemActions.workItemDomainActionApplicationProjector).toBe("function");
+		expect(typeof workItemScheduling.workItemAuthoringProjector).toBe("function");
+		expect(typeof workItemScheduling.workItemEffectPlanProjector).toBe("function");
+		expect(typeof workItemScheduling.workItemVerificationRequestLowerer).toBe("function");
+		expect(typeof workItemScheduling.workItemVerificationResultMapper).toBe("function");
+		expect(typeof workItemScheduling.workItemCreatedFromDraft).toBe("function");
+		expect(typeof workItemScheduling.recordWorkspaceProposal).toBe("function");
+		expect(typeof workItemScheduling.decideWorkspaceProposalAdmission).toBe("function");
+		expect(typeof workItemScheduling.projectWorkspaceProposalApplicationStatus).toBe("function");
+		expect(typeof workItemScheduling.assertWorkspaceProposalDataOnly).toBe("function");
+		expect(
+			typeof workItemScheduling.workspaceProposalRequiredInputResponseApplicationProjector,
+		).toBe("function");
+		expect(typeof workItemScheduling.workspaceProposalWorkItemSpawnApplicationProjector).toBe(
+			"function",
+		);
+		expect(typeof workItemScheduling.workspaceProposalWorkItemLinkApplicationProjector).toBe(
+			"function",
+		);
+		expect(typeof workItemScheduling.workspaceProposalDomainActionApplicationProjector).toBe(
+			"function",
+		);
+		expect(typeof workItemScheduling.recordWorkspaceProposalRequiredInputResponseOutcome).toBe(
+			"function",
+		);
+		expect(typeof workItemScheduling.recordWorkspaceProposalWorkItemSpawnOutcome).toBe("function");
+		expect(typeof workItemScheduling.recordWorkspaceProposalWorkItemLinkOutcome).toBe("function");
+		expect(typeof workItemScheduling.recordWorkspaceProposalDomainActionOutcome).toBe("function");
+		expect(typeof workItemScheduling.projectWorkspaceProposalFamilyOutcomeIndex).toBe("function");
+		expect(typeof workItemScheduling.projectWorkspaceProposalFamilyApplicationDiagnostics).toBe(
+			"function",
+		);
+		expect(typeof workItemScheduling.workspaceProposalFamilyApplicationDiagnosticProjector).toBe(
+			"function",
+		);
+		expect(typeof workItemScheduling.projectWorkspaceProposalRepairReviewRequests).toBe("function");
+		expect(typeof workItemScheduling.workspaceProposalRepairReviewProjector).toBe("function");
+		expect(typeof workItemScheduling.recordWorkspaceProposalRepairReviewDecision).toBe("function");
+		expect(typeof workItemScheduling.projectWorkspaceProposalRepairReviewStatuses).toBe("function");
+		expect(typeof workItemScheduling.workspaceProposalRepairReviewStatusProjector).toBe("function");
+		expect(typeof workItemScheduling.projectWorkspaceProposalFamilyApplicationReadModel).toBe(
+			"function",
+		);
+		expect(typeof workItemScheduling.workspaceProposalFamilyApplicationReadModelProjector).toBe(
+			"function",
+		);
+		expect(typeof workItemScheduling.projectWorkspaceProposalFamilyApplicationReadModels).toBe(
+			"function",
+		);
+		expect(typeof workItemScheduling.workspaceProposalFamilyApplicationReadModelsProjector).toBe(
+			"function",
+		);
+		expect(typeof workItemScheduling.projectWorkspaceProposalFamilyOutcomeDetailSupplyResults).toBe(
+			"function",
+		);
+		expect(typeof workItemScheduling.workspaceProposalFamilyOutcomeDetailSupplyProjector).toBe(
+			"function",
+		);
+		expect(typeof workItemScheduling.projectWorkspaceProposalRepairActionDescriptors).toBe(
+			"function",
+		);
+		expect(typeof workItemScheduling.workspaceProposalRepairActionDescriptorProjector).toBe(
+			"function",
+		);
+		expect(typeof workItemScheduling.validateWorkspaceProposalRepairActionIntent).toBe("function");
+		expect(
+			typeof workItemScheduling.prepareWorkspaceProposalRepairReviewDecisionRecordingInput,
+		).toBe("function");
+		expect(
+			typeof workItemScheduling.projectWorkspaceProposalRepairSuccessorProposalIntakePreview,
+		).toBe("function");
+		expect(
+			typeof workItemScheduling.validateWorkspaceProposalRepairActionDisplayPolicyAdvisory,
+		).toBe("function");
+		expect(
+			typeof workItemScheduling.projectWorkspaceProposalRepairActionDisplayPolicyAdvisory,
+		).toBe("function");
+		expect(
+			typeof workItemScheduling.workspaceProposalRepairActionDisplayPolicyAdvisoryProjector,
+		).toBe("function");
+		expect(
+			typeof workItemScheduling.prepareWorkspaceProposalRepairSuccessorProposalReadyRequest,
+		).toBe("function");
+		expect(typeof workItemScheduling.workspaceProposalRepairActionIntentProjector).toBe("function");
+		expect(
+			typeof workItemScheduling.workspaceProposalRepairSuccessorProposalIntakePreviewProjector,
+		).toBe("function");
+		expect(
+			typeof workItemScheduling.workspaceProposalRepairSuccessorProposalReadyRequestPreparationProjector,
+		).toBe("function");
+		expect("isCanvasWorkspaceProposalProjectionSlotMaterial" in workItemScheduling).toBe(false);
+		expect("validateCanvasWorkspaceProposalProjectionSlotLifecycle" in workItemScheduling).toBe(
+			false,
+		);
+		expect("releaseWorkspaceProposalProjectionFromCanvasSlot" in workItemScheduling).toBe(false);
+		expect("canvasWorkspaceProposalProjectionSlotReleaseProjector" in workItemScheduling).toBe(
+			false,
+		);
+		expect(typeof workItemScheduling.isWorkspaceProposalProjectionReleaseMaterial).toBe("function");
+		expect(typeof workItemScheduling.validateWorkspaceProposalProjectionReleaseMaterial).toBe(
+			"function",
+		);
+		expect(typeof workItemScheduling.workspaceProposalProjectionReleaseDiagnosticProjector).toBe(
+			"function",
+		);
+		expectTypeOf<WorkspaceProposalFamilyApplicationReadModelQuery>()
+			.toHaveProperty("queryId")
+			.toEqualTypeOf<string>();
+		expectTypeOf<WorkspaceProposalProjectionRelease>()
+			.toHaveProperty("targetKind")
+			.toEqualTypeOf<
+				| "family-read-model-query"
+				| "outcome-detail-supply-request"
+				| "repair-action-advisory"
+				| "repair-action-intent"
+				| "repair-successor-preview"
+				| "repair-successor-preparation"
+			>();
+		expectTypeOf<WorkspaceProposalProjectionReleaseDiagnostic>()
+			.toHaveProperty("status")
+			.toEqualTypeOf<"blocked">();
+		expectTypeOf<WorkspaceProposalRepairActionDescriptor>()
+			.toHaveProperty("actionKind")
+			.toEqualTypeOf<
+				| "acknowledge-review"
+				| "withdraw-review"
+				| "mark-human-resolved"
+				| "supersede-review"
+				| "open-successor-proposal-flow"
+			>();
+		expectTypeOf<
+			import("../solutions/work-item/scheduling.js").WorkspaceProposalRepairActionIntent
+		>()
+			.toHaveProperty("descriptorId")
+			.toEqualTypeOf<string>();
+		expectTypeOf<
+			import("../solutions/work-item/scheduling.js").WorkspaceProposalRepairSuccessorProposalIntakePreview
+		>()
+			.toHaveProperty("previewId")
+			.toEqualTypeOf<string>();
+		expectTypeOf<
+			import("../solutions/work-item/scheduling.js").WorkspaceProposalRepairActionDisplayPolicyAdvisory
+		>()
+			.toHaveProperty("authority")
+			.toEqualTypeOf<"display-only-advisory">();
+		expectTypeOf<
+			import("../solutions/work-item/scheduling.js").WorkspaceProposalRepairSuccessorProposalReadyRequestPreparationInput
+		>()
+			.toHaveProperty("successorProposalId")
+			.toEqualTypeOf<string>();
+		expectTypeOf<
+			import("../solutions/work-item/scheduling.js").WorkspaceProposalFamilyOutcomeDetailSupplyRequest
+		>()
+			.toHaveProperty("supplyRequestId")
+			.toEqualTypeOf<string>();
+		expect(Object.hasOwn(solutions, "workItemAuthoringProjector")).toBe(false);
+		expect(Object.hasOwn(solutions, "recordWorkspaceProposal")).toBe(false);
+		expect(
+			Object.hasOwn(solutions, "workspaceProposalRequiredInputResponseApplicationProjector"),
+		).toBe(false);
+		expect(Object.hasOwn(solutions, "workspaceProposalFamilyApplicationDiagnosticProjector")).toBe(
+			false,
+		);
+		expect(Object.hasOwn(solutions, "projectWorkspaceProposalRepairReviewRequests")).toBe(false);
+		expect(Object.hasOwn(solutions, "recordWorkspaceProposalRepairReviewDecision")).toBe(false);
+		expect(Object.hasOwn(solutions, "projectWorkspaceProposalRepairReviewStatuses")).toBe(false);
+		expect(Object.hasOwn(solutions, "workspaceProposalFamilyApplicationReadModelProjector")).toBe(
+			false,
+		);
+		expect(Object.hasOwn(solutions, "workspaceProposalFamilyApplicationReadModelsProjector")).toBe(
+			false,
+		);
+		expect(Object.hasOwn(solutions, "workspaceProposalFamilyOutcomeDetailSupplyProjector")).toBe(
+			false,
+		);
+		expect(Object.hasOwn(solutions, "workspaceProposalRepairActionDescriptorProjector")).toBe(
+			false,
+		);
+		expect(Object.hasOwn(solutions, "validateWorkspaceProposalRepairActionIntent")).toBe(false);
+		expect(
+			Object.hasOwn(solutions, "projectWorkspaceProposalRepairSuccessorProposalIntakePreview"),
+		).toBe(false);
+		expect(
+			Object.hasOwn(solutions, "validateWorkspaceProposalRepairActionDisplayPolicyAdvisory"),
+		).toBe(false);
+		expect(
+			Object.hasOwn(solutions, "workspaceProposalRepairActionDisplayPolicyAdvisoryProjector"),
+		).toBe(false);
+		expect(
+			Object.hasOwn(solutions, "prepareWorkspaceProposalRepairSuccessorProposalReadyRequest"),
+		).toBe(false);
+		expect(
+			Object.hasOwn(
+				solutions,
+				"workspaceProposalRepairSuccessorProposalReadyRequestPreparationProjector",
+			),
+		).toBe(false);
+		expect(Object.hasOwn(solutions, "isCanvasWorkspaceProposalProjectionSlotMaterial")).toBe(false);
+		expect(Object.hasOwn(solutions, "validateCanvasWorkspaceProposalProjectionSlotLifecycle")).toBe(
+			false,
+		);
+		expect(Object.hasOwn(solutions, "releaseWorkspaceProposalProjectionFromCanvasSlot")).toBe(
+			false,
+		);
+		expect(Object.hasOwn(solutions, "canvasWorkspaceProposalProjectionSlotReleaseProjector")).toBe(
+			false,
+		);
+		expect(Object.hasOwn(solutions, "isWorkspaceProposalProjectionReleaseMaterial")).toBe(false);
+		expect(Object.hasOwn(solutions, "validateWorkspaceProposalProjectionReleaseMaterial")).toBe(
+			false,
+		);
+		expect(Object.hasOwn(solutions, "workspaceProposalProjectionReleaseDiagnosticProjector")).toBe(
+			false,
+		);
+		expect(
+			Object.hasOwn(rootPackage, "workspaceProposalFamilyApplicationDiagnosticProjector"),
+		).toBe(false);
+		expect(Object.hasOwn(rootPackage, "projectWorkspaceProposalRepairReviewRequests")).toBe(false);
+		expect(Object.hasOwn(rootPackage, "recordWorkspaceProposalRepairReviewDecision")).toBe(false);
+		expect(Object.hasOwn(rootPackage, "projectWorkspaceProposalRepairReviewStatuses")).toBe(false);
+		expect(Object.hasOwn(rootPackage, "workspaceProposalFamilyApplicationReadModelProjector")).toBe(
+			false,
+		);
+		expect(
+			Object.hasOwn(rootPackage, "workspaceProposalFamilyApplicationReadModelsProjector"),
+		).toBe(false);
+		expect(Object.hasOwn(rootPackage, "workspaceProposalFamilyOutcomeDetailSupplyProjector")).toBe(
+			false,
+		);
+		expect(Object.hasOwn(rootPackage, "workspaceProposalRepairActionDescriptorProjector")).toBe(
+			false,
+		);
+		expect(Object.hasOwn(rootPackage, "validateWorkspaceProposalRepairActionIntent")).toBe(false);
+		expect(
+			Object.hasOwn(rootPackage, "projectWorkspaceProposalRepairSuccessorProposalIntakePreview"),
+		).toBe(false);
+		expect(
+			Object.hasOwn(rootPackage, "validateWorkspaceProposalRepairActionDisplayPolicyAdvisory"),
+		).toBe(false);
+		expect(
+			Object.hasOwn(rootPackage, "workspaceProposalRepairActionDisplayPolicyAdvisoryProjector"),
+		).toBe(false);
+		expect(
+			Object.hasOwn(rootPackage, "prepareWorkspaceProposalRepairSuccessorProposalReadyRequest"),
+		).toBe(false);
+		expect(
+			Object.hasOwn(
+				rootPackage,
+				"workspaceProposalRepairSuccessorProposalReadyRequestPreparationProjector",
+			),
+		).toBe(false);
+		expect(Object.hasOwn(rootPackage, "isCanvasWorkspaceProposalProjectionSlotMaterial")).toBe(
+			false,
+		);
+		expect(
+			Object.hasOwn(rootPackage, "validateCanvasWorkspaceProposalProjectionSlotLifecycle"),
+		).toBe(false);
+		expect(Object.hasOwn(rootPackage, "releaseWorkspaceProposalProjectionFromCanvasSlot")).toBe(
+			false,
+		);
+		expect(
+			Object.hasOwn(rootPackage, "canvasWorkspaceProposalProjectionSlotReleaseProjector"),
+		).toBe(false);
+		expect(Object.hasOwn(rootPackage, "isWorkspaceProposalProjectionReleaseMaterial")).toBe(false);
+		expect(Object.hasOwn(rootPackage, "validateWorkspaceProposalProjectionReleaseMaterial")).toBe(
+			false,
+		);
+		expect(
+			Object.hasOwn(rootPackage, "workspaceProposalProjectionReleaseDiagnosticProjector"),
+		).toBe(false);
+		expect(Object.hasOwn(solutions, "recordWorkspaceProposalDomainActionOutcome")).toBe(false);
+		expect(Object.hasOwn(workItemActions, "workspaceProposalRepairActionDescriptorProjector")).toBe(
+			false,
+		);
+		expect(Object.hasOwn(workItemActions, "validateWorkspaceProposalRepairActionIntent")).toBe(
+			false,
+		);
+		expect(
+			Object.hasOwn(
+				workItemActions,
+				"projectWorkspaceProposalRepairSuccessorProposalIntakePreview",
+			),
+		).toBe(false);
+		expect(
+			Object.hasOwn(workItemActions, "prepareWorkspaceProposalRepairSuccessorProposalReadyRequest"),
+		).toBe(false);
+		expect(
+			Object.hasOwn(workItemActions, "projectWorkspaceProposalFamilyApplicationReadModels"),
+		).toBe(false);
+		expect(
+			Object.hasOwn(workItemActions, "workspaceProposalFamilyOutcomeDetailSupplyProjector"),
+		).toBe(false);
+		expect(
+			Object.hasOwn(workItemActions, "workspaceProposalRepairActionDisplayPolicyAdvisoryProjector"),
+		).toBe(false);
+		expect(Object.hasOwn(workItemActions, "isCanvasWorkspaceProposalProjectionSlotMaterial")).toBe(
+			false,
+		);
+		expect(
+			Object.hasOwn(workItemActions, "validateCanvasWorkspaceProposalProjectionSlotLifecycle"),
+		).toBe(false);
+		expect(Object.hasOwn(workItemActions, "releaseWorkspaceProposalProjectionFromCanvasSlot")).toBe(
+			false,
+		);
+		expect(
+			Object.hasOwn(workItemActions, "canvasWorkspaceProposalProjectionSlotReleaseProjector"),
+		).toBe(false);
+		expect(Object.hasOwn(workItemActions, "isWorkspaceProposalProjectionReleaseMaterial")).toBe(
+			false,
+		);
+		expect(
+			Object.hasOwn(workItemActions, "validateWorkspaceProposalProjectionReleaseMaterial"),
+		).toBe(false);
+		expect(
+			Object.hasOwn(workItemActions, "workspaceProposalProjectionReleaseDiagnosticProjector"),
+		).toBe(false);
+		expect(Object.hasOwn(solutions, "workItemDomainActionApplicationProjector")).toBe(false);
+		expect(typeof workItemWorkQueueRecipe.workItemWorkQueueRecipe).toBe("function");
+		expect(typeof workItemWorkQueueRecipe.workItemSubmitCommand).toBe("function");
+		expect(typeof executorWorkQueueRecipe.executorWorkQueueRecipe).toBe("function");
+		expect(typeof executorWorkQueueRecipe.executorSubmitCommand).toBe("function");
+		expect(typeof executorToolProviderRecipe.toolProviderExecutionRecipe).toBe("function");
+		expect(typeof executorToolProviderAdapters.localBuiltinToolProviderBinding).toBe("function");
+		expect(typeof executorToolProviderAdapters.localBuiltinToolProviderAdapterPack).toBe(
+			"function",
+		);
+		expect(typeof executorToolProviderAdapters.processToolProviderBinding).toBe("function");
+		expect(typeof executorToolProviderAdapters.processToolProviderAdapterPack).toBe("function");
+		expect(typeof executorToolProviderAdapters.processToolProviderCatalog).toBe("function");
+		expect(typeof executorToolProviderAdapters.httpToolProviderCatalog).toBe("function");
+		expect(typeof executorToolProviderAdapters.httpToolProviderRuntime).toBe("function");
+		expect(Object.hasOwn(executorToolProviderAdapters, "attachToolProviderAdapterRuntime")).toBe(
+			false,
+		);
+		expect(Object.hasOwn(executorToolProviderAdapters, "toolProviderExecutionRecipe")).toBe(false);
+		expect(typeof executorToolProviderRuntime.attachToolProviderAdapterRuntime).toBe("function");
+		expect(typeof orchestration.retryPolicy).toBe("function");
+		expect(typeof orchestration.retryStatusBundle).toBe("function");
+		expect(typeof orchestration.breakerBundle).toBe("function");
+		expect(typeof orchestration.processBundle).toBe("function");
+		expect(typeof orchestration.processEffectRunner).toBe("function");
+		expect(typeof orchestration.rateLimitBundle).toBe("function");
+		expect(typeof orchestration.timeoutBundle).toBe("function");
+		expect(typeof orchestration.requestSatisfactionProjector).toBe("function");
+		expect(typeof orchestration.effectRunCompletionProjector).toBe("function");
+		expect(typeof orchestration.localBuiltinToolProviderCatalog).toBe("function");
+		expect(typeof orchestration.executorOutcomeViewProjector).toBe("function");
+		expect(typeof orchestration.validateToolProviderExecutionPolicy).toBe("function");
+		expect(typeof orchestration.resolveToolProviderExecutionPolicies).toBe("function");
+		expect(typeof orchestration.toolProviderPolicyResolutionProjector).toBe("function");
+		expect(typeof orchestration.buildToolProviderAdapterInputs).toBe("function");
+		expect(typeof orchestration.toolProviderAdapterInputProjector).toBe("function");
+		expect(typeof orchestration.requestToolProviderAdapterRun).toBe("function");
+		expect(typeof orchestration.toolProviderAdapterRunProjector).toBe("function");
+		expect(typeof orchestration.toolProviderRunAdmissionProjector).toBe("function");
+		expect(typeof orchestration.toolProviderRunRetryProjector).toBe("function");
+		expect(typeof orchestration.scheduledReadinessProjector).toBe("function");
+		expect(typeof orchestration.buildToolProviderExecutorOutcome).toBe("function");
+		expect(Object.hasOwn(orchestration, "attachToolProviderAdapterRuntime")).toBe(false);
+		expectTypeOf<ToolProviderExecutionPolicy>().toMatchTypeOf<{
+			readonly kind: "tool-provider-execution-policy";
+			readonly policyId: string;
+			readonly providerId: string;
+		}>();
+		expectTypeOf<ToolProviderAdapterInputStatus>().toEqualTypeOf<
+			| "ready"
+			| "pending-route"
+			| "missing-tool-call"
+			| "missing-catalog"
+			| "ambiguous-catalog"
+			| "missing-tool"
+			| "missing-policy"
+			| "invalid-policy"
+		>();
+		expectTypeOf<ToolProviderAdapterInput>().toMatchTypeOf<{
+			readonly kind: "tool-provider-adapter-input";
+			readonly adapterInputId: string;
+			readonly status: ToolProviderAdapterInputStatus;
+			readonly requestId: string;
+			readonly operationId: string;
+		}>();
+		expectTypeOf<ToolProviderAdapterInputBundle>().toHaveProperty("inputs");
+		expectTypeOf<ToolProviderAdapterRunRequested>().toMatchTypeOf<{
+			readonly kind: "tool-provider-adapter-run-requested";
+			readonly runId: string;
+			readonly adapterInputId: string;
+			readonly attempt: number;
+		}>();
+		expectTypeOf<ToolProviderAdapterRunStatus>().toHaveProperty("status");
+		expectTypeOf<ToolProviderAdapterRunBundle>().toHaveProperty("requests");
+		expectTypeOf<ToolProviderRunAdmissionProposal>().toMatchTypeOf<{
+			readonly kind: "tool-provider-run-admission-proposal";
+			readonly proposalId: string;
+			readonly approvalMode: string;
+		}>();
+		expectTypeOf<ToolProviderRunAdmissionDecision>().toMatchTypeOf<{
+			readonly kind: "tool-provider-run-admission-decision";
+			readonly decisionId: string;
+			readonly proposalId: string;
+			readonly outcome: "admit" | "block" | "defer";
+		}>();
+		expectTypeOf<ToolProviderRunAdmissionStatus>().toHaveProperty("state");
+		expectTypeOf<ToolProviderRunAdmissionBundle>().toHaveProperty("approvedRunRequests");
+		expectTypeOf<ToolProviderRunRetryPolicy>().toMatchTypeOf<{
+			readonly kind: "tool-provider-run-retry-policy";
+			readonly policyId: string;
+		}>();
+		expectTypeOf<ToolProviderRunRetryProposal>().toMatchTypeOf<{
+			readonly kind: "tool-provider-run-retry-proposal";
+			readonly nextAttempt: number;
+			readonly nextRunId: string;
+		}>();
+		expectTypeOf<ToolProviderRunRetryScheduled>().toHaveProperty("retryAtMs");
+		expectTypeOf<ToolProviderRunRetryStatus>().toHaveProperty("state");
+		expectTypeOf<ToolProviderRunRetryBundle>().toHaveProperty("runRequests");
+		expectTypeOf<ScheduledReadinessRequested>().toMatchTypeOf<{
+			readonly kind: "scheduled-readiness-requested";
+			readonly scheduleId: string;
+			readonly subjectRefs: readonly unknown[];
+			readonly readyAtMs: number;
+		}>();
+		expectTypeOf<ScheduledReadinessClock>().toMatchTypeOf<{
+			readonly kind: "scheduled-readiness-clock";
+			readonly nowMs: number;
+		}>();
+		expectTypeOf<ScheduledReadinessReady>().toHaveProperty("readyAtMs");
+		expectTypeOf<ScheduledReadinessStatus>().toHaveProperty("state");
+		expectTypeOf<ScheduledReadinessBundle>().toHaveProperty("ready");
+		expectTypeOf<ToolProviderPublicTextPolicy>().toHaveProperty("maxSummaryChars");
+		expectTypeOf<ToolProviderAdapterRunResult>().toMatchTypeOf<{ readonly kind: string }>();
+		expectTypeOf<ExecutorArtifactMaterial>().toMatchTypeOf<{
+			readonly kind: string;
+			readonly dataMode: "inline" | "summary" | "ref" | (string & {});
+		}>();
+		expectTypeOf<SizeCapacityEvidence>().toHaveProperty("measurementSource");
+		expect(Object.hasOwn(orchestration, "workItemEffectRunProjector")).toBe(false);
+		expect(typeof orchestrationMessagingRecipe.orchestrationMessagingRecipe).toBe("function");
+		expect(typeof orchestrationWorkQueueRecipe.orchestrationWorkQueueRecipe).toBe("function");
+		expect(Object.hasOwn(orchestration, "orchestrationMessagingRecipe")).toBe(false);
+		expect(Object.hasOwn(orchestration, "orchestrationWorkQueueRecipe")).toBe(false);
+		expect(Object.hasOwn(orchestration, "workQueueScheduledReadinessProjector")).toBe(false);
+		expect(Object.hasOwn(orchestration, "workQueueReadinessHandoffProjector")).toBe(false);
+		expect(Object.hasOwn(orchestration, "workQueueLeaseExpirationCommandProjector")).toBe(false);
+		expect(Object.hasOwn(rootPackage, "workQueueScheduledReadinessProjector")).toBe(false);
+		expect(Object.hasOwn(rootPackage, "workQueueReadinessHandoffProjector")).toBe(false);
+		expect(Object.hasOwn(rootPackage, "workQueueLeaseExpirationCommandProjector")).toBe(false);
+		expect(typeof orchestrationWorkQueueRecipe.workQueueScheduledReadinessProjector).toBe(
+			"function",
+		);
+		expect(typeof orchestrationWorkQueueRecipe.workQueueReadinessHandoffProjector).toBe("function");
+		expect(typeof orchestrationWorkQueueRecipe.workQueueLeaseExpirationCommandProjector).toBe(
+			"function",
+		);
+		expectTypeOf<WorkQueueScheduledReadinessBundle>().toHaveProperty("readinessSchedules");
+		expectTypeOf<WorkQueueScheduledReadinessStatus>().toHaveProperty("readyAtMs");
+		expectTypeOf<WorkQueueReadinessHandoffBundle>().toHaveProperty("candidates");
+		expectTypeOf<WorkQueueReadinessHandoffStatus>().toHaveProperty("candidateKind");
+		expectTypeOf<WorkQueueLeaseExpirationCommandBundle>().toHaveProperty("commands");
+		expect(typeof solutions.agenticMemoryBundle).toBe("function");
+		expect(typeof solutions.capabilityAdmissionProjector).toBe("function");
+		expect(typeof solutions.capabilityAdmissionProposal).toBe("function");
+		expect(Object.hasOwn(solutions, "workItemWorkQueueRecipe")).toBe(false);
+		expect(typeof solutions.reactiveLayout).toBe("function");
+		expect(typeof solutions.reactiveBlockLayout).toBe("function");
+		expect(typeof solutions.reactiveFlowLayout).toBe("function");
+		expect(typeof solutions.analyzeAndMeasure).toBe("function");
+		expect(typeof solutions.computeLineBreaks).toBe("function");
+		expect(typeof solutions.layoutNextLine).toBe("function");
+		expect(typeof solutions.carveTextLineSlots).toBe("function");
+		expect(typeof solutions.computeCharPositions).toBe("function");
+		expect(typeof solutions.measureBlock).toBe("function");
+		expect(typeof solutions.measureBlocks).toBe("function");
+		expect(typeof solutions.computeBlockFlow).toBe("function");
+		expect(typeof solutions.computeTotalHeight).toBe("function");
+		expect(typeof solutions.computeFlowLines).toBe("function");
+		expect(typeof solutions.circleIntervalForBand).toBe("function");
+		expect(typeof solutions.rectIntervalForBand).toBe("function");
+		expect(typeof solutions.textMeasurementProvider).toBe("function");
+		expect(typeof solutions.injectedTextMeasurements).toBe("function");
+		expect(typeof solutions.precomputedTextMeasurements).toBe("function");
+		expect(typeof solutions.cellTextMeasurements).toBe("function");
+		expect(typeof solutions.capabilityTextMeasurements).toBe("function");
+		expect(typeof solutions.readinessTextMeasurements).toBe("function");
+		expect(typeof solutions.readinessMeasurements).toBe("function");
+		expect(typeof solutions.imageSizeMeasurements).toBe("function");
+		expect(typeof solutions.svgBoundsMeasurements).toBe("function");
+		expect(typeof solutions.blockAdaptersProvider).toBe("function");
+		expect(typeof solutions.blockMeasurementProvider).toBe("function");
+		expect(typeof solutions.InjectedMeasureAdapter).toBe("function");
+		expect(typeof solutions.PrecomputedMeasureAdapter).toBe("function");
+		expect(typeof solutions.CellMeasureAdapter).toBe("function");
+		expect(typeof solutions.CapabilityMeasureAdapter).toBe("function");
+		expect(typeof solutions.SvgBoundsAdapter).toBe("function");
+		expect(typeof solutions.ImageSizeAdapter).toBe("function");
+		expect(Object.hasOwn(solutions, "CanvasMeasureAdapter")).toBe(false);
+		expect(typeof reactiveLayoutCore.reactiveLayout).toBe("function");
+		expect(typeof reactiveLayoutCore.reactiveBlockLayout).toBe("function");
+		expect(typeof reactiveLayoutCore.reactiveFlowLayout).toBe("function");
+		expect(typeof reactiveLayoutCore.textMeasurementProvider).toBe("function");
+		expect(typeof reactiveLayoutCore.capabilityTextMeasurements).toBe("function");
+		expect(typeof reactiveLayoutCore.readinessTextMeasurements).toBe("function");
+		expect(typeof reactiveLayoutCore.readinessMeasurements).toBe("function");
+		expect(typeof reactiveLayoutCore.imageSizeMeasurements).toBe("function");
+		expect(typeof reactiveLayoutCore.svgBoundsMeasurements).toBe("function");
+		expect(typeof reactiveLayoutCore.blockAdaptersProvider).toBe("function");
+		expect(typeof reactiveLayoutCore.blockMeasurementProvider).toBe("function");
+		expect(typeof reactiveLayoutCore.CellMeasureAdapter).toBe("function");
+		expect(typeof reactiveLayoutCore.CapabilityMeasureAdapter).toBe("function");
+		expect(reactiveLayoutCore.READINESS_MEASUREMENT_KIND).toBe("readiness");
+		expect(reactiveLayoutCore.IMAGE_SIZE_MEASUREMENT_KIND).toBe("image-size");
+		expect(reactiveLayoutCore.SVG_BOUNDS_MEASUREMENT_KIND).toBe("svg-bounds");
+		expect(typeof reactiveLayoutCore.mergeMeasurements).toBe("function");
+		expect(Object.hasOwn(reactiveLayoutCore, "CanvasMeasureAdapter")).toBe(false);
+		expect(typeof reactiveLayoutBrowser.CanvasMeasureAdapter).toBe("function");
+		expect(typeof reactiveLayoutBrowser.canvasTextMeasurements).toBe("function");
+		expect(typeof reactiveLayoutNodeCanvas.nodeCanvasTextMeasurements).toBe("function");
+		expect(typeof reactiveLayoutNodeCanvas.nodeCanvasPackageTextMeasurements).toBe("function");
+		expect(typeof reactiveLayoutSkia.skiaTextMeasurements).toBe("function");
+		expect(typeof reactiveLayoutSkia.skiaReadyTextMeasurements).toBe("function");
+		expect(typeof reactiveLayoutSkia.skiaParagraphTextMeasureCapability).toBe("function");
+		expect(typeof reactiveLayoutReactNative.reactNativeTextMeasurements).toBe("function");
+		expect(typeof reactiveLayoutReactNative.reactNativeLayoutMeasurements).toBe("function");
+		expect(Object.hasOwn(reactiveLayoutCore, "nodeCanvasTextMeasurements")).toBe(false);
+		expect(Object.hasOwn(reactiveLayoutCore, "nodeCanvasPackageTextMeasurements")).toBe(false);
+		expect(Object.hasOwn(reactiveLayoutCore, "skiaTextMeasurements")).toBe(false);
+		expect(Object.hasOwn(reactiveLayoutCore, "skiaReadyTextMeasurements")).toBe(false);
+		expect(Object.hasOwn(reactiveLayoutCore, "reactNativeTextMeasurements")).toBe(false);
+		expect(Object.hasOwn(reactiveLayoutCore, "reactNativeLayoutMeasurements")).toBe(false);
+		expect(typeof solutions.agenticMemoryKgProjectionBundle).toBe("function");
+		expect(typeof solutions.agenticMemoryRecordFrame).toBe("function");
+		expect(typeof solutions.agenticMemoryRecordFrameCodec).toBe("function");
+		expect(typeof solutions.agenticMemoryRecordCodec).toBe("function");
+		expect(typeof solutions.agenticMemoryRetentionBundle).toBe("function");
+		expect(typeof solutions.agenticMemoryConsolidationBundle).toBe("function");
+		expect(typeof solutions.agenticMemoryContextPackingBundle).toBe("function");
+		expect(typeof graphLayer.workerDerived).toBe("function");
+		expect(Object.hasOwn(patterns, "guardedExecution")).toBe(false);
+		expect(Object.hasOwn(patterns, "inspect")).toBe(false);
+		expect(Object.hasOwn(patterns, "resilientPipeline")).toBe(false);
+		expect(Object.hasOwn(patterns, "openPersistentReactiveMap")).toBe(false);
+		expect(Object.hasOwn(patterns, "persistReactiveCollection")).toBe(false);
+		expect(Object.hasOwn(patterns, "persistAgenticMemoryRecords")).toBe(false);
+		expect(Object.hasOwn(solutions, "persistReactiveCollection")).toBe(false);
+		expect(Object.hasOwn(solutions, "persistAgenticMemoryRecords")).toBe(false);
+		expect(Object.hasOwn(solutions, "openPersistentReactiveMap")).toBe(false);
+		expect(Object.hasOwn(solutions, "Graph")).toBe(false);
+	});
+
+	it("keeps D488 NestJS WebSocket and microservice peers in focused subpaths", () => {
+		const sourceRoot = join(dirname(fileURLToPath(import.meta.url)), "..");
+		const nestRoot = join(sourceRoot, "adapters", "nestjs");
+		const websocketFile = join(nestRoot, "websockets.ts");
+		const microserviceFile = join(nestRoot, "microservices.ts");
+		const nestAdapterFiles = [join(sourceRoot, "adapters", "nestjs.ts"), ...listTsFiles(nestRoot)];
+
+		for (const file of nestAdapterFiles) {
+			const source = readFileSync(file, "utf8");
+			if (file === websocketFile) {
+				expect(source).toContain("@nestjs/websockets");
+				expect(source).not.toContain("@nestjs/microservices");
+				continue;
+			}
+			if (file === microserviceFile) {
+				expect(source).toContain("@nestjs/microservices");
+				expect(source).not.toContain("@nestjs/websockets");
+				continue;
+			}
+			expect(source, file).not.toContain("@nestjs/websockets");
+			expect(source, file).not.toContain("@nestjs/microservices");
+		}
+		expect(typeof nestjsAdapters.GraphWs).toBe("function");
+		expect(typeof nestjsAdapters.GraphMessage).toBe("function");
+		expect(typeof nestjsWebsocketsAdapters.createGraphWsBridge).toBe("function");
+		expect(typeof nestjsWebsocketsAdapters.provideGraphWsBridge).toBe("function");
+		expect(typeof nestjsWebsocketsAdapters.provideGraphWsProviders).toBe("function");
+		expect(typeof nestjsWebsocketsAdapters.GraphWsAck).toBe("function");
+		expect(typeof nestjsWebsocketsAdapters.GraphWsReply).toBe("function");
+		expect(typeof nestjsMicroservicesAdapters.createGraphMessageBridge).toBe("function");
+		expect(typeof nestjsMicroservicesAdapters.provideGraphMessageBridge).toBe("function");
+		expect(typeof nestjsMicroservicesAdapters.provideGraphMessageProviders).toBe("function");
+		expect(typeof nestjsMicroservicesAdapters.GraphMessageReply).toBe("function");
+		expect(Object.hasOwn(nestjsAdapters, "provideGraphWsProviders")).toBe(false);
+		expect(Object.hasOwn(nestjsAdapters, "provideGraphMessageProviders")).toBe(false);
+		expect(Object.hasOwn(nestjsNativeAdapters, "provideGraphWsProviders")).toBe(false);
+		expect(Object.hasOwn(nestjsNativeAdapters, "provideGraphMessageProviders")).toBe(false);
+	});
+
+	it("documents D486 cron misfire and catch-up default skip semantics", () => {
+		const docsPath = join(
+			dirname(fileURLToPath(import.meta.url)),
+			"..",
+			"..",
+			"..",
+			"..",
+			"website",
+			"src",
+			"content",
+			"docs",
+			"recipes",
+			"nestjs-integration.md",
+		);
+		const docs = readFileSync(docsPath, "utf8");
+
+		expect(docs).toContain("missed ticks");
+		expect(docs).toContain("skipped by default");
+		expect(docs).toContain("no missed-status or catch-up DATA");
+	});
+
+	it("documents D495 focused NestJS provider bundles and diagnostics recipe boundaries", () => {
+		const docsRoot = join(
+			dirname(fileURLToPath(import.meta.url)),
+			"..",
+			"..",
+			"..",
+			"..",
+			"website",
+			"src",
+			"content",
+			"docs",
+		);
+		const recipe = readFileSync(join(docsRoot, "recipes", "nestjs-integration.md"), "utf8");
+		const matrix = readFileSync(join(docsRoot, "integrations", "matrix.md"), "utf8");
+		const compat = readFileSync(join(docsRoot, "integrations", "compat.md"), "utf8");
+
+		for (const docs of [recipe, matrix, compat]) {
+			expect(docs).toContain("D495");
+			expect(docs).toContain("provider bundle");
+			expect(docs).toContain("diagnostics");
+		}
+		expect(recipe).toContain("provideGraphWsProviders");
+		expect(recipe).toContain("provideGraphMessageProviders");
+		expect(recipe).toContain("bridge: { diagnosticBoundary: nestDiagnostics }");
+		expect(recipe).toContain("There is no `onDiagnostic` callback or logging API");
+		expect(matrix).toContain("do not scan the container");
+		expect(matrix).toContain("do not create graphs");
+		expect(matrix).toContain("do not own retry, session, reconnect, or transport lifecycle policy");
+		expect(compat).toContain("hidden graph creation");
+		expect(compat).toContain("transport retry/session/reconnect ownership");
+	});
+
+	it("exports node-only sources as a package subpath without polluting universal sources", () => {
+		expect(exportsJson.exports?.["./sources/node"]).toBeDefined();
+		expect(typeof sourcesNode.fromFSWatch).toBe("function");
+		expect(typeof sourcesNode.fromGitHook).toBe("function");
+		expect(typeof sourcesNode.fromSpawn).toBe("function");
+		expect(typeof sourcesNode.nodeProcessDriver).toBe("function");
+		expect(typeof sourcesNode.runProcess).toBe("function");
+		expect(Object.hasOwn(sources, "fromFSWatch")).toBe(false);
+		expect(Object.hasOwn(sources, "fromGitHook")).toBe(false);
+		expect(Object.hasOwn(sources, "fromSpawn")).toBe(false);
+		expect(Object.hasOwn(sources, "nodeProcessDriver")).toBe(false);
+		expect(Object.hasOwn(sources, "runProcess")).toBe(false);
+	});
+
+	it("exports browser-safe sources as a package subpath without node-only adapters", () => {
+		expect(exportsJson.exports?.["./sources/browser"]).toBeDefined();
+		expect(typeof sourcesBrowser.fromAny).toBe("function");
+		expect(typeof sourcesBrowser.fromEvent).toBe("function");
+		expect(typeof sourcesBrowser.fromRaf).toBe("function");
+		expect(typeof sourcesBrowser.fromIDBRequest).toBe("function");
+		expect(typeof sourcesBrowser.fromIDBTransaction).toBe("function");
+		expect(Object.hasOwn(sourcesBrowser, "fromFSWatch")).toBe(false);
+		expect(Object.hasOwn(sourcesBrowser, "fromGitHook")).toBe(false);
+		expect(Object.hasOwn(sourcesBrowser, "fromSpawn")).toBe(false);
+		expect(Object.hasOwn(sourcesBrowser, "nodeProcessDriver")).toBe(false);
+		expect(Object.hasOwn(sourcesBrowser, "runProcess")).toBe(false);
+	});
+
+	it("does not resurrect retired window/storage surfaces through the subpaths", () => {
+		expect(Object.hasOwn(operators, "window")).toBe(false);
+		expect(Object.hasOwn(operators, "windowCount")).toBe(false);
+		expect(Object.hasOwn(operators, "windowTime")).toBe(false);
+		expect(Object.hasOwn(storage, "attachSnapshotStorage")).toBe(false);
+		expect(Object.hasOwn(storage, "restoreSnapshot")).toBe(false);
+		expect(Object.hasOwn(storage, "strictCanonicalJsonBytes")).toBe(false);
+		expect(Object.hasOwn(storage, "assertNodeVersionDataCompatible")).toBe(false);
+		expect(Object.hasOwn(storage, "snapshotNodeVersionData")).toBe(false);
+		expect(Object.hasOwn(graphLayer, "attachSnapshotStorage")).toBe(false);
+		expect(Object.hasOwn(graphLayer, "restoreSnapshot")).toBe(false);
+		expect(Object.hasOwn(core, "strictCanonicalJsonBytes")).toBe(false);
+		expect(Object.hasOwn(core, "assertNodeVersionDataCompatible")).toBe(false);
+		expect(Object.hasOwn(core, "snapshotNodeVersionData")).toBe(false);
+	});
+
+	it("exports storage/node as a package subpath", () => {
+		expect(exportsJson.exports?.["./storage/node"]).toBeDefined();
+		expect(typeof storageNode.fileBackend).toBe("function");
+		expect(typeof storageNode.fileKv).toBe("function");
+		expect(typeof storageNode.fileAppendLog).toBe("function");
+		expect(typeof storageNode.sqliteBackend).toBe("function");
+		expect(typeof storageNode.sqliteKv).toBe("function");
+		expect(typeof storageNode.sqliteAppendLog).toBe("function");
+		expect(Object.hasOwn(storageNode, "attachSnapshotStorage")).toBe(false);
+		expect(Object.hasOwn(storageNode, "restoreSnapshot")).toBe(false);
+		expect(Object.hasOwn(storageNode, "restoreFromStorage")).toBe(false);
+		expect(Object.hasOwn(storageNode, "hydrateGraph")).toBe(false);
+		expect(Object.hasOwn(storageNode, "replayWal")).toBe(false);
+	});
+
+	it("exports D161 reactive collection persistence from the right layers", () => {
+		expect(typeof storage.loadReactiveListState).toBe("function");
+		expect(typeof storage.loadReactiveLogState).toBe("function");
+		expect(typeof storage.loadReactiveMapState).toBe("function");
+		expect(typeof storage.loadReactiveIndexState).toBe("function");
+		expect(typeof storage.reactiveCollectionSnapshotFrame).toBe("function");
+		expect(typeof dataStructures.restoreReactiveList).toBe("function");
+		expect(typeof dataStructures.restoreReactiveLog).toBe("function");
+		expect(typeof dataStructures.restoreReactiveMap).toBe("function");
+		expect(typeof dataStructures.restoreReactiveIndex).toBe("function");
+		expect(typeof adapters.persistReactiveCollection).toBe("function");
+		expect(typeof adapters.openPersistentReactiveList).toBe("function");
+		expect(typeof adapters.openPersistentReactiveLog).toBe("function");
+		expect(typeof adapters.openPersistentReactiveMap).toBe("function");
+		expect(typeof adapters.openPersistentReactiveIndex).toBe("function");
+		expect(Object.hasOwn(storage, "persistReactiveCollection")).toBe(false);
+		expect(Object.hasOwn(storage, "openPersistentReactiveList")).toBe(false);
+		expect(Object.hasOwn(storage, "restoreGraph")).toBe(false);
+	});
+
+	it("exports storage/browser as a package subpath", () => {
+		expect(exportsJson.exports?.["./storage/browser"]).toBeDefined();
+		expect(typeof storageBrowser.indexedDbBackend).toBe("function");
+		expect(typeof storageBrowser.indexedDbKv).toBe("function");
+		expect(typeof storageBrowser.indexedDbAppendLog).toBe("function");
+		expect(Object.hasOwn(storageBrowser, "attachSnapshotStorage")).toBe(false);
+		expect(Object.hasOwn(storageBrowser, "restoreSnapshot")).toBe(false);
+		expect(Object.hasOwn(storageBrowser, "restoreFromStorage")).toBe(false);
+		expect(Object.hasOwn(storageBrowser, "hydrateGraph")).toBe(false);
+		expect(Object.hasOwn(storageBrowser, "replayWal")).toBe(false);
+	});
+
+	it("exposes the D80 policy vocabulary from public type barrels", () => {
+		expectTypeOf<ReactiveListOpt<number>>().toEqualTypeOf<ReactiveOpt<number>>();
+		expectTypeOf<ReactiveMapOpt<number>>().toEqualTypeOf<ReactiveOpt<number>>();
+		expectTypeOf<ReactiveIndexOpt<number>>().toEqualTypeOf<ReactiveOpt<number>>();
+		expectTypeOf<ReactiveIndexCapacityPolicy>().toMatchTypeOf<
+			OrderedCapacityPolicy<ReactiveIndexCapacityOrder>
+		>();
+		expectTypeOf<ReactiveMapRetentionPolicy<string, number>>().toMatchTypeOf<
+			RetentionPolicy<ReactiveMapRetentionEntry<string, number>>
+		>();
+		expectTypeOf<CapacityPolicy<"lru">>()
+			.toHaveProperty("maxSize")
+			.toEqualTypeOf<ReactiveOpt<number>>();
+		expectTypeOf<ViewCachePolicy>()
+			.toHaveProperty("maxEntries")
+			.toEqualTypeOf<number | undefined>();
+		expectTypeOf<ReactiveLogOptions>()
+			.toHaveProperty("viewCache")
+			.toEqualTypeOf<ViewCachePolicy | undefined>();
+		expectTypeOf<ReactiveMapOptions<string, number>>()
+			.toHaveProperty("viewCache")
+			.toEqualTypeOf<ViewCachePolicy | undefined>();
+		expectTypeOf<ReactiveIndexOptions>()
+			.toHaveProperty("viewCache")
+			.toEqualTypeOf<ViewCachePolicy | undefined>();
+		expectTypeOf<DataStructuresReactiveOpt<string>>().toEqualTypeOf<ReactiveOpt<string>>();
+		expectTypeOf<DataStructuresReactiveView<string, string>>().toEqualTypeOf<
+			ReactiveView<string, string>
+		>();
+		expectTypeOf<DataStructuresViewCachePolicy>().toEqualTypeOf<ViewCachePolicy>();
+		expectTypeOf<TopologyGroup>().toMatchTypeOf<{
+			readonly released: boolean;
+			release(opts?: TopologyGroupReleaseOptions): void;
+		}>();
+		expectTypeOf<TopologyGroupOptions>().toEqualTypeOf<{ name?: string }>();
+		expectTypeOf<GraphCheckpoint>()
+			.toHaveProperty("version")
+			.toEqualTypeOf<"graphrefly.checkpoint.v1">();
+		expectTypeOf<ImageSizeLookup>().toMatchTypeOf<{
+			get(src: string): unknown;
+		}>();
+		expectTypeOf<AgenticMemoryBundleOptions>()
+			.toHaveProperty("name")
+			.toEqualTypeOf<string | undefined>();
+		expectTypeOf<AgenticMemoryBundleOptions<string>>()
+			.toHaveProperty("records")
+			.toMatchTypeOf<unknown>();
+		expectTypeOf<AgenticMemoryRecord<string>>()
+			.toHaveProperty("fragment")
+			.toMatchTypeOf<MemoryFragment<string>>();
+		expectTypeOf<KnowledgeAssertion>().toHaveProperty("predicate").toEqualTypeOf<string>();
+		expectTypeOf<KnowledgeGraphReducerBundleOptions>()
+			.toHaveProperty("assertions")
+			.toMatchTypeOf<unknown>();
+		expectTypeOf<AgenticMemoryKgProjectionBundleOptions>()
+			.toHaveProperty("drafts")
+			.toMatchTypeOf<unknown>();
+		expectTypeOf<AgenticMemoryRecordFrame>().toHaveProperty("version").toEqualTypeOf<1>();
+		expectTypeOf<AgenticMemoryRetentionBundleOptions>()
+			.toHaveProperty("commands")
+			.toMatchTypeOf<unknown>();
+		expectTypeOf<AgenticMemoryConsolidationBundleOptions>()
+			.toHaveProperty("outcomes")
+			.toMatchTypeOf<unknown>();
+		expectTypeOf<AgenticMemoryRecordsPersistenceHandle>()
+			.toHaveProperty("cursor")
+			.toMatchTypeOf<unknown>();
+		expectTypeOf<AgenticMemoryContextPackingBundleOptions>()
+			.toHaveProperty("policy")
+			.toMatchTypeOf<unknown>();
+		expectTypeOf<AgenticMemoryScope>()
+			.toHaveProperty("tenantId")
+			.toEqualTypeOf<string | undefined>();
+		expectTypeOf<AgenticMemoryStatus>()
+			.toHaveProperty("state")
+			.toEqualTypeOf<"ready" | "empty" | "partial" | "error">();
+	});
+});
diff --git a/packages/ts/src/__tests__/testing.test.ts b/packages/ts/src/__tests__/testing.test.ts
new file mode 100644
index 00000000..1350c3dd
--- /dev/null
+++ b/packages/ts/src/__tests__/testing.test.ts
@@ -0,0 +1,57 @@
+import { describe, expect, it } from "vitest";
+import type { Message, Wave } from "../index.js";
+import { assertDirtyPrecedesTerminalData, node } from "../index.js";
+
+describe("testing assertions", () => {
+	it("accepts a normal DIRTY then DATA wave (R-dirty-before-data)", () => {
+		const messages: Wave[] = [[["DIRTY"], ["DATA", 1]]];
+		expect(() => assertDirtyPrecedesTerminalData(messages)).not.toThrow();
+	});
+
+	it("accepts multiple DATA occurrences covered by one DIRTY in the same wave (D49)", () => {
+		const messages: Wave[] = [[["DIRTY"], ["DATA", 1], ["DATA", 1]]];
+		expect(() => assertDirtyPrecedesTerminalData(messages)).not.toThrow();
+	});
+
+	it("accepts START handshake DATA/replay without a preceding DIRTY", () => {
+		const s = node<number>([], null, { initial: 5 });
+		const flat: Message[] = [];
+		const unsubscribe = s.subscribe((msg) => flat.push(msg));
+		unsubscribe();
+
+		expect(flat).toEqual([["START"], ["DATA", 5]]);
+		const messages: Wave[] = [flat];
+		expect(() => assertDirtyPrecedesTerminalData(messages)).not.toThrow();
+	});
+
+	it("rejects RESOLVED in a START handshake wave", () => {
+		const messages: Wave[] = [[["START"], ["RESOLVED"]]];
+		expect(() => assertDirtyPrecedesTerminalData(messages)).toThrow(/wave 0, index 1/);
+	});
+
+	it("rejects DATA without a preceding DIRTY outside the START handshake", () => {
+		const messages: Wave[] = [[["DATA", 1]]];
+		expect(() => assertDirtyPrecedesTerminalData(messages)).toThrow(/R-dirty-before-data/);
+	});
+
+	it("rejects a later wave DATA even when the previous wave had DIRTY", () => {
+		const messages: Wave[] = [[["DIRTY"], ["DATA", 1]], [["DATA", 2]]];
+		expect(() => assertDirtyPrecedesTerminalData(messages)).toThrow(/wave 1, index 0/);
+	});
+
+	it("rejects RESOLVED without a preceding DIRTY outside the START handshake", () => {
+		const messages: Wave[] = [[["DIRTY"], ["DATA", 1], ["COMPLETE"], ["RESOLVED"]]];
+		expect(() => assertDirtyPrecedesTerminalData(messages)).toThrow(/index 3/);
+	});
+
+	it("reports the wave for diagnostics", () => {
+		const messages: Wave[] = [[["DIRTY"], ["DATA", 1], ["COMPLETE"], ["DATA", 2]]];
+		try {
+			assertDirtyPrecedesTerminalData(messages);
+			expect.fail("expected assertion to throw");
+		} catch (error) {
+			expect((error as Error).message).toMatch(/Wave:/);
+			expect((error as Error).message).toMatch(/-> \[DATA\]/);
+		}
+	});
+});
diff --git a/packages/ts/src/__tests__/time.test.ts b/packages/ts/src/__tests__/time.test.ts
new file mode 100644
index 00000000..1782f085
--- /dev/null
+++ b/packages/ts/src/__tests__/time.test.ts
@@ -0,0 +1,283 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import {
+	audit,
+	auditTime,
+	bufferTime,
+	debounce,
+	debounceTime,
+	delay,
+	describeToAscii,
+	graph,
+	type Message,
+	map,
+	throttle,
+	throttleTime,
+	timeout,
+} from "../index.js";
+
+const data = (msgs: Message[]) =>
+	msgs.filter((m) => m[0] === "DATA").map((m) => (m as ["DATA", unknown])[1]);
+const types = (msgs: Message[]) => msgs.map((m) => m[0]);
+const timerCount = () => vi.getTimerCount();
+
+// CSP-2.7 Slice 4 (D52 / B23): wall-clock time operators as *Map + timer compositions — NO raw
+// setTimeout in operator bodies (R-no-raw-async). Driven with fake timers like the source tests.
+describe("Slice 4 — wall-clock time operators (D52, *Map + timer)", () => {
+	beforeEach(() => vi.useFakeTimers());
+	afterEach(() => vi.useRealTimers());
+
+	it("delay shifts every value by ms, keeping all (mergeMap + timer)", () => {
+		const g = graph();
+		const s = g.node<number>([], null); // manual source
+		const d = g.initNode(delay<number>(100), [s]);
+		const msgs: Message[] = [];
+		d.subscribe((m) => msgs.push(m));
+		s.down([["DATA", 1]]);
+		s.down([["DATA", 2]]);
+		expect(data(msgs)).toEqual([]); // nothing yet — both delayed
+		vi.advanceTimersByTime(100);
+		expect(data(msgs)).toEqual([1, 2]); // both fire after 100ms, in order
+	});
+
+	it("debounce emits only the latest value after ms of quiet (switchMap + timer cancel-restart)", () => {
+		const g = graph();
+		const s = g.node<number>([], null);
+		const d = g.initNode(debounce<number>(100), [s]);
+		const msgs: Message[] = [];
+		d.subscribe((m) => msgs.push(m));
+		s.down([["DATA", 1]]);
+		vi.advanceTimersByTime(50); // 1's timer not yet fired
+		s.down([["DATA", 2]]); // cancels 1's timer (onDeactivation clearTimeout), restarts
+		vi.advanceTimersByTime(50); // 50ms since 2 — still not quiet enough
+		expect(data(msgs)).toEqual([]);
+		vi.advanceTimersByTime(50); // now 100ms since 2 → emit 2 (1 was dropped)
+		expect(data(msgs)).toEqual([2]);
+	});
+
+	it("debounceTime is the debounce alias (real factory name in describe)", () => {
+		const g = graph();
+		const s = g.node<number>([], null, { name: "s" });
+		g.initNode(debounceTime<number>(50), [s], { name: "db" });
+		const byId = Object.fromEntries(g.describe().nodes.map((n) => [n.id, n]));
+		expect(byId.db.factory).toBe("debounceTime");
+	});
+
+	it("throttle emits the leading value, then ignores the source for ms (exhaustMap + window)", () => {
+		const g = graph();
+		const s = g.node<number>([], null);
+		const t = g.initNode(throttle<number>(100), [s]);
+		const msgs: Message[] = [];
+		t.subscribe((m) => msgs.push(m));
+		s.down([["DATA", 1]]); // leading edge → emit 1 immediately
+		s.down([["DATA", 2]]); // within the window → dropped
+		expect(data(msgs)).toEqual([1]);
+		vi.advanceTimersByTime(100); // window closes
+		s.down([["DATA", 3]]); // new window → emit 3
+		expect(data(msgs)).toEqual([1, 3]);
+	});
+
+	it("throttleTime is the throttle alias (real factory name)", () => {
+		const g = graph();
+		const s = g.node<number>([], null, { name: "s" });
+		g.initNode(throttleTime<number>(50), [s], { name: "th" });
+		const byId = Object.fromEntries(g.describe().nodes.map((n) => [n.id, n]));
+		expect(byId.th.factory).toBe("throttleTime");
+	});
+});
+
+// B41 tail (landed 2026-05-31): value-triggered audit/auditTime + subscribe-armed timeout/bufferTime.
+describe("B41 tail — audit / auditTime / timeout / bufferTime", () => {
+	beforeEach(() => vi.useFakeTimers());
+	afterEach(() => vi.useRealTimers());
+
+	it("auditTime emits the window's LATEST value at the window close (trailing throttle)", () => {
+		const g = graph();
+		const s = g.node<number>([], null);
+		const a = g.initNode(auditTime<number>(100), [s]);
+		const msgs: Message[] = [];
+		a.subscribe((m) => msgs.push(m));
+		s.down([["DATA", 1]]); // opens a 100ms window (latest=1)
+		s.down([["DATA", 2]]); // window open → latest=2 (no emit)
+		s.down([["DATA", 3]]); // latest=3
+		expect(data(msgs)).toEqual([]); // nothing yet — window still open
+		vi.advanceTimersByTime(100); // window closes → emit the LATEST (3), not the first
+		expect(data(msgs)).toEqual([3]);
+		s.down([["DATA", 4]]); // a fresh value opens a NEW window
+		vi.advanceTimersByTime(100);
+		expect(data(msgs)).toEqual([3, 4]);
+	});
+
+	it("audit flushes the pending latest on source COMPLETE (B44 flush-on-complete)", () => {
+		const g = graph();
+		const s = g.node<number>([], null);
+		const a = g.initNode(auditTime<number>(100), [s]);
+		const msgs: Message[] = [];
+		a.subscribe((m) => msgs.push(m));
+		s.down([["DATA", 1]]); // opens a window (latest=1)
+		s.down([["DATA", 2]]); // latest=2 (window still open)
+		s.down([["COMPLETE"]]); // source completes mid-window → flush latest=2, then COMPLETE
+		expect(data(msgs)).toEqual([2]);
+		expect(types(msgs)).toContain("COMPLETE");
+	});
+
+	it("audit removes its live notifier before forwarding source ERROR", () => {
+		const g = graph();
+		const s = g.node<number>([], null);
+		const a = g.initNode(auditTime<number>(100), [s]);
+		const msgs: Message[] = [];
+		a.subscribe((m) => msgs.push(m));
+		s.down([["DATA", 1]]); // opens a live timer notifier
+		expect(timerCount()).toBe(1);
+		s.down([["ERROR", new Error("boom")]]);
+		expect(types(msgs)).toContain("ERROR");
+		expect(timerCount()).toBe(0);
+	});
+
+	it("audit(selector) is the general form — the window closes when the selector's notifier fires", () => {
+		const g = graph();
+		const s = g.node<number>([], null);
+		let gate: ReturnType<typeof g.node<number>> | undefined;
+		// a value-triggered window whose duration is a manual gate node (the general notifier form).
+		const a = g.initNode(
+			audit<number>(() => {
+				gate = g.node<number>([], null);
+				return gate;
+			}),
+			[s],
+		);
+		const msgs: Message[] = [];
+		a.subscribe((m) => msgs.push(m));
+		s.down([["DATA", 1]]); // opens a window, selector mints `gate`
+		s.down([["DATA", 2]]); // latest=2 (still open)
+		expect(data(msgs)).toEqual([]);
+		gate?.down([["DATA", 0]]); // the duration notifier fires → emit the latest (2), close
+		expect(data(msgs)).toEqual([2]);
+	});
+
+	it("auditTime real factory name in describe", () => {
+		const g = graph();
+		const s = g.node<number>([], null, { name: "s" });
+		g.initNode(auditTime<number>(50), [s], { name: "au" });
+		const byId = Object.fromEntries(g.describe().nodes.map((n) => [n.id, n]));
+		expect(byId.au.factory).toBe("auditTime");
+	});
+
+	it("timeout errors if no first value arrives within ms (SUBSCRIBE-armed, RxJS-cold)", () => {
+		const g = graph();
+		const s = g.node<number>([], null);
+		const t = timeout<number>(s, 100);
+		const msgs: Message[] = [];
+		t.subscribe((m) => msgs.push(m));
+		expect(types(msgs)).not.toContain("ERROR"); // armed at subscribe, not yet fired
+		vi.advanceTimersByTime(100); // 100ms with no value at all → timeout ERROR
+		expect(types(msgs)).toContain("ERROR");
+	});
+
+	it("timeout forwards values + resets the idle timer; errors only on a gap > ms", () => {
+		const g = graph();
+		const s = g.node<number>([], null);
+		const t = timeout<number>(s, 100);
+		const msgs: Message[] = [];
+		t.subscribe((m) => msgs.push(m));
+		vi.advanceTimersByTime(50); // 50/100 of the initial window
+		s.down([["DATA", 1]]); // forward 1 + RESET the idle timer
+		vi.advanceTimersByTime(50); // 50ms since value 1 — fine
+		s.down([["DATA", 2]]); // forward 2 + reset
+		vi.advanceTimersByTime(50); // 50ms since 2 — fine
+		expect(data(msgs)).toEqual([1, 2]);
+		expect(types(msgs)).not.toContain("ERROR");
+		vi.advanceTimersByTime(50); // now 100ms since value 2 with no value → ERROR
+		expect(types(msgs)).toContain("ERROR");
+	});
+
+	it("timeout forwards source COMPLETE (no spurious timeout error)", () => {
+		const g = graph();
+		const s = g.node<number>([], null);
+		const t = timeout<number>(s, 100);
+		const msgs: Message[] = [];
+		t.subscribe((m) => msgs.push(m));
+		s.down([["DATA", 1]]);
+		expect(timerCount()).toBe(1);
+		s.down([["COMPLETE"]]); // source ends → forward COMPLETE
+		expect(timerCount()).toBe(0); // D62 terminal-drain removes the helper-owned timer now
+		vi.advanceTimersByTime(200); // the idle timer must NOT fire after COMPLETE
+		expect(data(msgs)).toEqual([1]);
+		expect(types(msgs)).toContain("COMPLETE");
+		expect(types(msgs)).not.toContain("ERROR");
+	});
+
+	it("timeout forwards source ERROR and clears its idle timer", () => {
+		const g = graph();
+		const s = g.node<number>([], null);
+		const t = timeout<number>(s, 100);
+		const msgs: Message[] = [];
+		t.subscribe((m) => msgs.push(m));
+		expect(timerCount()).toBe(1);
+		s.down([["ERROR", new Error("source failed")]]);
+		expect(types(msgs)).toContain("ERROR");
+		expect(timerCount()).toBe(0);
+	});
+
+	it("bufferTime flushes the buffer every ms; remainder + COMPLETE on source end", () => {
+		const g = graph();
+		const s = g.node<number>([], null);
+		const b = bufferTime<number>(s, 100);
+		const msgs: Message[] = [];
+		b.subscribe((m) => msgs.push(m));
+		s.down([["DATA", 1]]);
+		s.down([["DATA", 2]]);
+		vi.advanceTimersByTime(100); // interval ticks → flush [1,2]
+		expect(data(msgs)).toEqual([[1, 2]]);
+		s.down([["DATA", 3]]);
+		s.down([["COMPLETE"]]); // remainder [3] flushed + COMPLETE
+		expect(timerCount()).toBe(0); // terminal-drain releases the construction-time interval
+		vi.advanceTimersByTime(200);
+		expect(data(msgs)).toEqual([[1, 2], [3]]);
+		expect(types(msgs)).toContain("COMPLETE");
+	});
+
+	it("bufferTime forwards source ERROR and clears its interval without flushing the partial buffer", () => {
+		const g = graph();
+		const s = g.node<number>([], null);
+		const b = bufferTime<number>(s, 100);
+		const msgs: Message[] = [];
+		b.subscribe((m) => msgs.push(m));
+		expect(timerCount()).toBe(1);
+		s.down([["DATA", 1]]);
+		s.down([["ERROR", new Error("source failed")]]);
+		expect(types(msgs)).toContain("ERROR");
+		expect(data(msgs)).toEqual([]);
+		expect(timerCount()).toBe(0);
+	});
+
+	it("timeout / bufferTime self-carry their factory name (bare-node, D51)", () => {
+		const g = graph();
+		const s = g.node<number>([], null);
+		expect(timeout<number>(s, 100).factory).toBe("timeout");
+		expect(bufferTime<number>(s, 100).factory).toBe("bufferTime");
+	});
+
+	it("timeout exposes its live helper timer through describe/render, then removes it on terminal cleanup", () => {
+		const g = graph({ name: "time" });
+		const s = g.node<number>([], null, { name: "src" });
+		const t = timeout<number>(s, 100);
+		const watch = g.initNode(
+			map((v: number) => v),
+			[t],
+			{ name: "watch" },
+		);
+		const msgs: Message[] = [];
+
+		watch.subscribe((m) => msgs.push(m));
+		const armed = g.describe();
+		expect(armed.nodes.some((node) => node.factory === "timeout")).toBe(true);
+		expect(armed.nodes.some((node) => node.factory === "timer")).toBe(true);
+		expect(describeToAscii(armed)).toContain("timer");
+
+		s.down([["COMPLETE"]]); // terminal-drain releases timeout's helper-owned timer.
+		const completed = g.describe();
+		expect(types(msgs)).toContain("COMPLETE");
+		expect(completed.nodes.some((node) => node.factory === "timeout")).toBe(true);
+		expect(completed.nodes.some((node) => node.factory === "timer")).toBe(false);
+	});
+});
diff --git a/packages/ts/src/__tests__/tool-provider-adapters.test.ts b/packages/ts/src/__tests__/tool-provider-adapters.test.ts
new file mode 100644
index 00000000..a9a7388b
--- /dev/null
+++ b/packages/ts/src/__tests__/tool-provider-adapters.test.ts
@@ -0,0 +1,929 @@
+import { mkdirSync, mkdtempSync, rmSync, symlinkSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { basename, join } from "node:path";
+import { describe, expect, it } from "vitest";
+import { toolProviderExecutionRecipe } from "../executors/tool-provider.js";
+import {
+	type HttpToolProviderDriver,
+	httpToolProviderCatalog,
+	httpToolProviderRuntime,
+	localBuiltinToolProviderAdapterPack,
+	localBuiltinToolProviderBinding,
+	type ProcessToolArguments,
+	processToolProviderAdapterPack,
+	processToolProviderBinding,
+} from "../executors/tool-provider-adapters.js";
+import { graph } from "../graph/graph.js";
+import type {
+	AgentRequestFact,
+	AgentRequestIssued,
+	ExecutorRoute,
+	ToolCallInput,
+	ToolProviderAdapterInput,
+	ToolProviderAdapterRunRequested,
+	ToolProviderRunAdmissionDecision,
+} from "../orchestration/index.js";
+import {
+	requestToolProviderAdapterRun,
+	toolProviderRunAdmissionProjector,
+} from "../orchestration/index.js";
+
+describe("tool-provider concrete adapters (D283/D359-D362)", () => {
+	it("local builtin binding exposes deterministic pure tools without fallback tools", () => {
+		const binding = localBuiltinToolProviderBinding({ now: () => 1_700_000_000_000 });
+
+		expect(
+			binding.run(readyInput("local-builtin", "date.now"), { attempt: 1, sourceRefs: [] }),
+		).toEqual(
+			expect.objectContaining({
+				kind: "result",
+				result: expect.objectContaining({
+					kind: "json",
+					value: {
+						toolName: "date.now",
+						epochMs: 1_700_000_000_000,
+						iso: "2023-11-14T22:13:20.000Z",
+					},
+				}),
+			}),
+		);
+		expect(
+			binding.run(readyInput("local-builtin", "json.parse", { text: '{"ok":true}' }), {
+				attempt: 1,
+				sourceRefs: [],
+			}),
+		).toEqual(
+			expect.objectContaining({
+				kind: "result",
+				result: expect.objectContaining({
+					value: { toolName: "json.parse", value: { ok: true } },
+				}),
+			}),
+		);
+		expect(
+			binding.run(
+				readyInput("local-builtin", "text.concat", { parts: ["a", 2, "c"], separator: "-" }),
+				{ attempt: 1, sourceRefs: [] },
+			),
+		).toEqual(
+			expect.objectContaining({
+				kind: "result",
+				result: expect.objectContaining({
+					kind: "text",
+					value: { toolName: "text.concat", text: "a-2-c" },
+					summary: "a-2-c",
+				}),
+			}),
+		);
+		expect(
+			binding.run(readyInput("local-builtin", "bash.run"), { attempt: 1, sourceRefs: [] }),
+		).toEqual(expect.objectContaining({ kind: "blocked" }));
+	});
+
+	it("local builtin adapter pack plugs into the execution recipe", () => {
+		const g = graph();
+		const requestFacts = g.node<AgentRequestFact>([], null, { name: "agentRequestFacts" });
+		const routes = g.node<ExecutorRoute>([], null, { name: "executorRoutes" });
+		const pack = localBuiltinToolProviderAdapterPack({ now: () => 123 });
+		const profile = pack.catalogs[0]?.profiles[0];
+		const recipe = toolProviderExecutionRecipe(g, {
+			requestFacts,
+			executorRoutes: [routes],
+			catalogs: pack.catalogs,
+			bindings: pack.bindings,
+			now: () => 123,
+		});
+		const outcomes = collectData(recipe.outcomes);
+		const views = collectData(recipe.outcomeViews.views);
+
+		routes.down([["DATA", route("request-1", profile)]]);
+		requestFacts.down([["DATA", request("request-1", "date.now")]]);
+
+		expect(outcomes).toEqual([
+			expect.objectContaining({
+				kind: "result",
+				requestId: "request-1",
+				result: expect.objectContaining({
+					value: { toolName: "date.now", epochMs: 123, iso: "1970-01-01T00:00:00.123Z" },
+				}),
+			}),
+		]);
+		expect(views).toEqual([
+			expect.objectContaining({
+				kind: "executor-outcome-view",
+				audience: "agent-observation",
+				requestId: "request-1",
+				status: "result",
+			}),
+		]);
+		recipe.dispose();
+	});
+
+	it("process binding defaults deny and requires explicit argv allowlist", () => {
+		const denied = processToolProviderBinding();
+		expect(
+			denied.run(processInput({ command: "node", args: ["-e", "console.log('x')"] }), {
+				attempt: 1,
+				sourceRefs: [],
+			}),
+		).toEqual(expect.objectContaining({ kind: "blocked" }));
+
+		const allowed = processToolProviderBinding({
+			allowedCommands: [
+				{
+					command: "node",
+					executable: process.execPath,
+					allowArgs: (args) => args[0] === "-e",
+				},
+			],
+			baseEnv: {},
+			allowedEnvKeys: ["GRAPHREFLY_ALLOWED"],
+			maxOutputBytes: 1024,
+		});
+		const result = allowed.run(
+			processInput({
+				command: "node",
+				args: ["-e", "console.log(process.env.GRAPHREFLY_ALLOWED ?? 'missing')"],
+				env: { GRAPHREFLY_ALLOWED: "visible" },
+			}),
+			{ attempt: 1, sourceRefs: [] },
+		);
+
+		expect(result).toEqual(
+			expect.objectContaining({
+				kind: "result",
+				result: expect.objectContaining({
+					kind: "process-result",
+					value: expect.objectContaining({
+						command: "node",
+						exitCode: 0,
+						outputPreview: "visible\n",
+					}),
+					artifacts: expect.arrayContaining([
+						expect.objectContaining({
+							kind: "process-stdout",
+							dataMode: "inline",
+							value: "visible\n",
+							byteLength: 8,
+							sizeEvidence: [
+								expect.objectContaining({
+									kind: "size-capacity-evidence",
+									unit: "bytes",
+									quantity: 8,
+								}),
+							],
+						}),
+					]),
+				}),
+			}),
+		);
+		expect(
+			allowed.run(
+				processInput({
+					command: "node",
+					args: ["-e", "console.log(process.env.SECRET ?? 'missing')"],
+					env: { SECRET: "hidden" },
+				}),
+				{ attempt: 1, sourceRefs: [] },
+			),
+		).toEqual(expect.objectContaining({ kind: "blocked" }));
+	});
+
+	it("process adapter pack publishes pure catalog data and recipe-compatible binding", () => {
+		const g = graph();
+		const requestFacts = g.node<AgentRequestFact>([], null, { name: "processRequestFacts" });
+		const routes = g.node<ExecutorRoute>([], null, { name: "processExecutorRoutes" });
+		const pack = processToolProviderAdapterPack({
+			providerId: "process-test",
+			allowedCommands: [
+				{
+					command: "node",
+					executable: process.execPath,
+					allowArgs: (args) => args[0] === "-e",
+				},
+			],
+			baseEnv: {},
+			maxOutputBytes: 1024,
+		});
+		const profile = pack.catalogs[0]?.profiles[0];
+		const recipe = toolProviderExecutionRecipe(g, {
+			name: "processRecipe",
+			requestFacts,
+			executorRoutes: [routes],
+			catalogs: pack.catalogs,
+			bindings: pack.bindings,
+		});
+		const outcomes = collectData(recipe.outcomes);
+
+		expect(JSON.stringify(pack.catalogs)).not.toContain("execPath");
+		routes.down([["DATA", route("process-request", profile)]]);
+		requestFacts.down([
+			[
+				"DATA",
+				request("process-request", "process.execFile", {
+					command: "node",
+					args: ["-e", "console.log('adapter')"],
+				}),
+			],
+		]);
+
+		expect(outcomes).toEqual([
+			expect.objectContaining({
+				kind: "result",
+				requestId: "process-request",
+				result: expect.objectContaining({
+					value: expect.objectContaining({ outputPreview: "adapter\n" }),
+				}),
+			}),
+		]);
+		recipe.dispose();
+	});
+
+	it("process binding fails closed on output capacity", () => {
+		const binding = processToolProviderBinding({
+			allowedCommands: [
+				{
+					command: "node",
+					executable: process.execPath,
+					allowArgs: (args) => args[0] === "-e",
+				},
+			],
+			baseEnv: {},
+			maxOutputBytes: 8,
+		});
+
+		expect(
+			binding.run(
+				processInput({
+					command: "node",
+					args: ["-e", "process.stdout.write('12345'); process.stderr.write('67890')"],
+				}),
+				{ attempt: 1, sourceRefs: [] },
+			),
+		).toEqual(
+			expect.objectContaining({
+				kind: "failure",
+				error: expect.objectContaining({ code: "process-output-limit-exceeded" }),
+			}),
+		);
+	});
+
+	it("process binding resolves relative cwd under workingDirectory", () => {
+		const root = mkdtempSync(join(tmpdir(), "graphrefly-process-adapter-"));
+		const child = join(root, "child");
+		mkdirSync(child);
+		try {
+			const binding = processToolProviderBinding({
+				workingDirectory: root,
+				allowedWorkingDirectories: [root],
+				allowedCommands: [
+					{
+						command: "node",
+						executable: process.execPath,
+						allowArgs: (args) => args[0] === "-e",
+					},
+				],
+				baseEnv: {},
+				maxOutputBytes: 1024,
+			});
+
+			const result = binding.run(
+				processInput({
+					command: "node",
+					args: ["-e", "console.log(require('node:path').basename(process.cwd()))"],
+					cwd: "child",
+				}),
+				{ attempt: 1, sourceRefs: [] },
+			);
+
+			expect(result).toEqual(
+				expect.objectContaining({
+					kind: "result",
+					result: expect.objectContaining({
+						value: expect.objectContaining({
+							cwd: child,
+							outputPreview: `${basename(child)}\n`,
+						}),
+					}),
+				}),
+			);
+		} finally {
+			rmSync(root, { recursive: true, force: true });
+		}
+	});
+
+	it("process binding rejects cwd symlink escapes when followSymlinks is false", () => {
+		const root = mkdtempSync(join(tmpdir(), "graphrefly-process-adapter-"));
+		const outside = mkdtempSync(join(tmpdir(), "graphrefly-process-outside-"));
+		const link = join(root, "link-outside");
+		try {
+			try {
+				symlinkSync(outside, link, "dir");
+			} catch {
+				return;
+			}
+			const binding = processToolProviderBinding({
+				workingDirectory: root,
+				allowedWorkingDirectories: [root],
+				allowedCommands: [
+					{
+						command: "node",
+						executable: process.execPath,
+						allowArgs: (args) => args[0] === "-e",
+					},
+				],
+				baseEnv: {},
+				maxOutputBytes: 1024,
+			});
+
+			expect(
+				binding.run(
+					processInput({
+						command: "node",
+						args: ["-e", "console.log(process.cwd())"],
+						cwd: "link-outside",
+					}),
+					{ attempt: 1, sourceRefs: [] },
+				),
+			).toEqual(
+				expect.objectContaining({
+					kind: "blocked",
+					issues: expect.arrayContaining([
+						expect.objectContaining({ code: "process-cwd-not-allowed" }),
+					]),
+				}),
+			);
+		} finally {
+			rmSync(root, { recursive: true, force: true });
+			rmSync(outside, { recursive: true, force: true });
+		}
+	});
+
+	it("http runtime executes through visible run requests without async bindings", () => {
+		const g = graph();
+		const inputs = g.node<ToolProviderAdapterInput>([], null, { name: "httpInputs" });
+		const driver: HttpToolProviderDriver = {
+			fetch(request) {
+				return Promise.resolve({
+					url: request.url,
+					status: 200,
+					statusText: "OK",
+					headers: { "content-type": "application/json", server: "private" },
+					bodyText: '{"ok":true}',
+				});
+			},
+		};
+		const runtime = httpToolProviderRuntime(g, {
+			inputs,
+			providerId: "http-test",
+			allowedOrigins: ["https://api.example.test"],
+			exposedResponseHeaders: ["content-type"],
+			driver,
+			now: () => 123,
+		});
+		const outcomes = collectData(runtime.outcomes);
+		const statuses = collectData(runtime.runStatus);
+
+		inputs.down([
+			[
+				"DATA",
+				readyInput("http-test", "http.fetch", {
+					url: "https://api.example.test/data",
+				}),
+			],
+		]);
+
+		return Promise.resolve().then(() => {
+			expect(statuses).toEqual([
+				expect.objectContaining({ status: "requested" }),
+				expect.objectContaining({ status: "started" }),
+				expect.objectContaining({ status: "result" }),
+			]);
+			expect(outcomes).toEqual([
+				expect.objectContaining({
+					kind: "result",
+					result: expect.objectContaining({
+						kind: "http-result",
+						value: expect.objectContaining({
+							status: 200,
+							bodyText: '{"ok":true}',
+							headers: { "content-type": "application/json" },
+						}),
+						artifacts: [
+							expect.objectContaining({
+								kind: "http-response-body",
+								dataMode: "inline",
+								value: '{"ok":true}',
+								byteLength: 11,
+							}),
+						],
+					}),
+				}),
+			]);
+			runtime.dispose();
+		});
+	});
+
+	it("http runtime denies non-allowlisted origins and approval-required runs fail closed", () => {
+		const g = graph();
+		const inputs = g.node<ToolProviderAdapterInput>([], null, { name: "httpDeniedInputs" });
+		const runtime = httpToolProviderRuntime(g, {
+			inputs,
+			providerId: "http-test",
+			allowedOrigins: ["https://api.example.test"],
+			approvalMode: "require",
+			driver: {
+				fetch() {
+					throw new Error("should not execute");
+				},
+			},
+		});
+		const outcomes = collectData(runtime.outcomes);
+
+		inputs.down([
+			[
+				"DATA",
+				readyInput("http-test", "http.fetch", {
+					url: "https://api.example.test/data",
+				}),
+			],
+			[
+				"DATA",
+				{
+					...readyInput("http-test", "http.fetch", {
+						url: "https://evil.example.test/data",
+					}),
+					adapterInputId: "http-test:evil:input",
+					requestId: "http-test:evil:request",
+					operationId: "http-test:evil:op",
+					routeId: "http-test:evil:route",
+				},
+			],
+		]);
+
+		return Promise.resolve().then(() => {
+			expect(outcomes).toEqual([
+				expect.objectContaining({
+					kind: "blocked",
+					needs: expect.arrayContaining([
+						expect.objectContaining({ kind: "tool-provider-approval" }),
+					]),
+				}),
+				expect.objectContaining({
+					kind: "blocked",
+					issues: expect.arrayContaining([
+						expect.objectContaining({ code: "http-origin-not-allowed" }),
+					]),
+				}),
+			]);
+			runtime.dispose();
+		});
+	});
+
+	it("http runtime consumes D419-admitted run requests instead of auto-running explicit candidates", () => {
+		const g = graph();
+		const inputs = g.node<ToolProviderAdapterInput>([], null, { name: "httpAdmissionInputs" });
+		const candidateRuns = g.node<ToolProviderAdapterRunRequested>([], null, {
+			name: "httpAdmissionCandidateRuns",
+		});
+		const decisions = g.node<ToolProviderRunAdmissionDecision>([], null, {
+			name: "httpAdmissionDecisions",
+		});
+		const admission = toolProviderRunAdmissionProjector(g, {
+			inputs,
+			runRequests: [candidateRuns],
+			decisions: [decisions],
+		});
+		const calls: string[] = [];
+		const runtime = httpToolProviderRuntime(g, {
+			inputs,
+			runRequests: [admission.approvedRunRequests],
+			providerId: "http-test",
+			allowedOrigins: ["https://api.example.test"],
+			approvalMode: "require",
+			driver: {
+				fetch(request) {
+					calls.push(request.url);
+					return Promise.resolve({
+						url: request.url,
+						status: 200,
+						statusText: "OK",
+						bodyText: "approved",
+					});
+				},
+			},
+		});
+		const outcomes = collectData(runtime.outcomes);
+		const input = approvalInput(
+			readyInput("http-test", "http.fetch", {
+				url: "https://api.example.test/admitted",
+			}),
+			"require",
+		);
+
+		inputs.down([["DATA", input]]);
+
+		return Promise.resolve()
+			.then(() => {
+				expect(calls).toEqual([]);
+				candidateRuns.down([
+					["DATA", requestToolProviderAdapterRun(input, { runId: "candidate-http-approval" })],
+				]);
+				return Promise.resolve();
+			})
+			.then(() => {
+				expect(calls).toEqual([]);
+				decisions.down([
+					[
+						"DATA",
+						{
+							kind: "tool-provider-run-admission-decision",
+							decisionId: "http-approval-decision",
+							proposalId: "candidate-http-approval:admission-proposal",
+							admissionId: "http-approval-admission",
+							outcome: "admit",
+							approvedRunId: "approved-http-run",
+						},
+					],
+				]);
+				return Promise.resolve();
+			})
+			.then(() => {
+				expect(calls).toEqual(["https://api.example.test/admitted"]);
+				expect(outcomes).toEqual([
+					expect.objectContaining({
+						kind: "result",
+						result: expect.objectContaining({
+							value: expect.objectContaining({ bodyText: "approved" }),
+						}),
+					}),
+				]);
+				runtime.dispose();
+			});
+	});
+
+	it("default http driver disables automatic redirect following", () => {
+		const g = graph();
+		const inputs = g.node<ToolProviderAdapterInput>([], null, { name: "httpRedirectInputs" });
+		const originalFetch = globalThis.fetch;
+		let seenInit: RequestInit | undefined;
+		globalThis.fetch = ((_url: URL | RequestInfo, init?: RequestInit) => {
+			seenInit = init;
+			return Promise.resolve(new Response("ok", { status: 200, statusText: "OK" }));
+		}) as typeof fetch;
+		const runtime = httpToolProviderRuntime(g, {
+			inputs,
+			providerId: "http-test",
+			allowedOrigins: ["https://api.example.test"],
+		});
+
+		inputs.down([
+			[
+				"DATA",
+				readyInput("http-test", "http.fetch", {
+					url: "https://api.example.test/redirect",
+				}),
+			],
+		]);
+
+		return Promise.resolve()
+			.then(() => Promise.resolve())
+			.then(() => {
+				expect(seenInit).toEqual(expect.objectContaining({ redirect: "manual" }));
+				runtime.dispose();
+				globalThis.fetch = originalFetch;
+			})
+			.catch((error: unknown) => {
+				runtime.dispose();
+				globalThis.fetch = originalFetch;
+				throw error;
+			});
+	});
+
+	it("http runtime keeps ref-only bodies as ref artifacts instead of empty inline content", () => {
+		const g = graph();
+		const inputs = g.node<ToolProviderAdapterInput>([], null, { name: "httpRefInputs" });
+		const bodyRef = { kind: "artifact", id: "http-body-ref" };
+		const runtime = httpToolProviderRuntime(g, {
+			inputs,
+			providerId: "http-test",
+			allowedOrigins: ["https://api.example.test"],
+			driver: {
+				fetch(request) {
+					return Promise.resolve({
+						url: request.url,
+						status: 200,
+						statusText: "OK",
+						bodyRef,
+					});
+				},
+			},
+		});
+		const outcomes = collectData(runtime.outcomes);
+
+		inputs.down([
+			[
+				"DATA",
+				readyInput("http-test", "http.fetch", {
+					url: "https://api.example.test/ref",
+				}),
+			],
+		]);
+
+		return Promise.resolve().then(() => {
+			const value = outcomes[0]?.kind === "result" ? outcomes[0].result.value : undefined;
+			expect(value).toEqual(
+				expect.objectContaining({
+					dataMode: "ref",
+					bodyRef,
+				}),
+			);
+			expect(Object.hasOwn(value ?? {}, "bodyText")).toBe(false);
+			expect(outcomes[0]).toEqual(
+				expect.objectContaining({
+					result: expect.objectContaining({
+						artifacts: [
+							expect.objectContaining({
+								kind: "http-response-body",
+								dataMode: "ref",
+								ref: bodyRef,
+							}),
+						],
+					}),
+				}),
+			);
+			expect(
+				Object.hasOwn(
+					outcomes[0]?.kind === "result" ? (outcomes[0].result.artifacts?.[0] ?? {}) : {},
+					"value",
+				),
+			).toBe(false);
+			runtime.dispose();
+		});
+	});
+
+	it("http catalog is pure policy data for async runtime providers", () => {
+		expect(
+			httpToolProviderCatalog({
+				providerId: "http-test",
+				allowedOrigins: ["https://api.example.test"],
+				allowedMethods: ["GET", "POST"],
+				allowedRequestHeaders: ["authorization"],
+				maxResponseBytes: 10,
+			}),
+		).toEqual(
+			expect.objectContaining({
+				providerKind: "http",
+				status: "ready",
+				metadata: expect.objectContaining({ asyncRuntime: true }),
+				tools: [
+					expect.objectContaining({
+						toolName: "http.fetch",
+						capabilities: expect.objectContaining({ asyncRuntime: true }),
+					}),
+				],
+			}),
+		);
+	});
+
+	it("process binding fails closed on malformed argv and invalid allowlist argv", () => {
+		const binding = processToolProviderBinding({
+			allowedCommands: [
+				{
+					command: "node",
+					executable: process.execPath,
+					allowArgs: true,
+				},
+			],
+		});
+		const sparseArgs = [] as unknown[];
+		sparseArgs[1] = "-v";
+
+		expect(
+			binding.run(readyInput("process", "process.execFile", null), {
+				attempt: 1,
+				sourceRefs: [],
+			}),
+		).toEqual(expect.objectContaining({ kind: "blocked" }));
+		expect(
+			binding.run(
+				readyInput("process", "process.execFile", { command: "node", args: sparseArgs }),
+				{ attempt: 1, sourceRefs: [] },
+			),
+		).toEqual(expect.objectContaining({ kind: "blocked" }));
+		expect(
+			processToolProviderBinding({
+				allowedCommands: [
+					{
+						command: "node",
+						executable: process.execPath,
+						fixedArgs: [undefined as unknown as string],
+					},
+				],
+			}).run(processInput({ command: "node" }), { attempt: 1, sourceRefs: [] }),
+		).toEqual(
+			expect.objectContaining({
+				kind: "blocked",
+				issues: expect.arrayContaining([
+					expect.objectContaining({ code: "process-command-invalid-allowlist" }),
+				]),
+			}),
+		);
+	});
+
+	it("process catalog reports positive timeout and invalid allowlist policy", () => {
+		const pack = processToolProviderAdapterPack({
+			timeoutMs: 0,
+			allowedCommands: [
+				{
+					command: "node",
+					executable: process.execPath,
+					allowArgs: [undefined as unknown as string],
+				},
+			],
+		});
+
+		expect(pack.catalogs[0]?.policies?.[0]?.timeout).toEqual({ timeoutMs: 10_000 });
+		expect(pack.catalogs[0]).toEqual(
+			expect.objectContaining({
+				status: "misconfigured",
+				issues: expect.arrayContaining([
+					expect.objectContaining({ code: "process-tool-provider-invalid-allowlist" }),
+				]),
+			}),
+		);
+	});
+
+	it("process binding freezes allowlist entries and fails closed on duplicates", () => {
+		const allowedArgs = ["-e", "console.log('still copied')"];
+		const mutableCommand = {
+			command: "node",
+			executable: process.execPath,
+			allowArgs: allowedArgs,
+		};
+		const binding = processToolProviderBinding({
+			allowedCommands: [mutableCommand],
+			baseEnv: {},
+			maxOutputBytes: 1024,
+		});
+		allowedArgs[1] = "console.log('mutated')";
+		mutableCommand.executable = "definitely-not-node";
+
+		expect(
+			binding.run(
+				processInput({
+					command: "node",
+					args: ["-e", "console.log('still copied')"],
+				}),
+				{ attempt: 1, sourceRefs: [] },
+			),
+		).toEqual(
+			expect.objectContaining({
+				kind: "result",
+				result: expect.objectContaining({
+					value: expect.objectContaining({ outputPreview: "still copied\n" }),
+				}),
+			}),
+		);
+		expect(
+			binding.run(
+				processInput({
+					command: "node",
+					args: ["-p", "1 + 1"],
+				}),
+				{ attempt: 1, sourceRefs: [] },
+			),
+		).toEqual(expect.objectContaining({ kind: "blocked" }));
+
+		const duplicatePack = processToolProviderAdapterPack({
+			allowedCommands: [
+				{ command: "node", executable: process.execPath },
+				{ command: "node", executable: process.execPath, allowArgs: true },
+			],
+		});
+		expect(duplicatePack.catalogs[0]).toEqual(
+			expect.objectContaining({
+				status: "misconfigured",
+				issues: expect.arrayContaining([
+					expect.objectContaining({ code: "process-tool-provider-duplicate-allowlist" }),
+				]),
+			}),
+		);
+		expect(
+			duplicatePack.bindings[0]?.run(processInput({ command: "node" }), {
+				attempt: 1,
+				sourceRefs: [],
+			}),
+		).toEqual(
+			expect.objectContaining({
+				kind: "blocked",
+				issues: expect.arrayContaining([
+					expect.objectContaining({ code: "process-command-duplicate-allowlist" }),
+				]),
+			}),
+		);
+	});
+});
+
+function request(requestId: string, toolName: string, args?: unknown): AgentRequestIssued {
+	return {
+		kind: "issued",
+		requestId,
+		operationId: `${requestId}:op`,
+		effectRunId: `${requestId}:effect`,
+		requestKind: "executor",
+		required: true,
+		input: {
+			inputId: `${requestId}:input`,
+			inputKind: "tool-call",
+			value: {
+				kind: "tool-call",
+				toolName,
+				operation: toolName === "process.execFile" ? "run" : undefined,
+				...(args === undefined ? {} : { arguments: args }),
+			} satisfies ToolCallInput,
+		},
+	};
+}
+
+function route(
+	requestId: string,
+	profile:
+		| {
+				readonly executorId: string;
+				readonly profileId: string;
+		  }
+		| undefined,
+): ExecutorRoute {
+	if (profile === undefined) throw new Error("missing profile");
+	return {
+		kind: "executor-route",
+		routeId: `${requestId}:route`,
+		requestId,
+		operationId: `${requestId}:op`,
+		executorId: profile.executorId,
+		profileId: profile.profileId,
+	};
+}
+
+function readyInput(
+	providerId: string,
+	toolName: string,
+	args?: unknown,
+): ToolProviderAdapterInput {
+	return {
+		kind: "tool-provider-adapter-input",
+		adapterInputId: `${providerId}:${toolName}:input`,
+		status: "ready",
+		requestId: `${providerId}:${toolName}:request`,
+		operationId: `${providerId}:${toolName}:op`,
+		routeId: `${providerId}:${toolName}:route`,
+		providerId,
+		executorId: `${providerId}:tool-executor`,
+		profileId: `${providerId}:tool-profile`,
+		toolName,
+		operation: toolName === "process.execFile" ? "run" : undefined,
+		toolCall: {
+			kind: "tool-call",
+			toolName,
+			...(args === undefined ? {} : { arguments: args }),
+		},
+	};
+}
+
+function approvalInput(
+	input: ToolProviderAdapterInput,
+	mode: "auto" | "require" | "never",
+): ToolProviderAdapterInput {
+	const policyId = `${input.providerId}:approval-policy:${mode}`;
+	return {
+		...input,
+		policies: [
+			{
+				kind: "tool-provider-execution-policy",
+				policyId,
+				providerId: input.providerId ?? "provider",
+				approval: { mode },
+			},
+		],
+		policyRefs: [{ kind: "tool-provider-execution-policy", id: policyId }],
+	};
+}
+
+function processInput(args: ProcessToolArguments): ToolProviderAdapterInput<ProcessToolArguments> {
+	return readyInput(
+		"process",
+		"process.execFile",
+		args,
+	) as ToolProviderAdapterInput<ProcessToolArguments>;
+}
+
+function collectData<T>(node: {
+	subscribe(sink: (msg: readonly [string, unknown?]) => void): unknown;
+}): T[] {
+	const out: T[] = [];
+	node.subscribe((msg) => {
+		if (msg[0] === "DATA") out.push(msg[1] as T);
+	});
+	return out;
+}
diff --git a/packages/ts/src/__tests__/tool-provider-recipes.test.ts b/packages/ts/src/__tests__/tool-provider-recipes.test.ts
new file mode 100644
index 00000000..2aa0d152
--- /dev/null
+++ b/packages/ts/src/__tests__/tool-provider-recipes.test.ts
@@ -0,0 +1,147 @@
+import { describe, expect, it } from "vitest";
+import { toolProviderExecutionRecipe } from "../executors/tool-provider.js";
+import type { ToolProviderAdapterBinding } from "../executors/tool-provider-runtime.js";
+import { graph } from "../graph/graph.js";
+import {
+	type AgentRequestFact,
+	type AgentRequestIssued,
+	type ExecutorRoute,
+	localBuiltinToolProviderCatalog,
+	type ToolCallInput,
+} from "../orchestration/agent-runtime.js";
+
+describe("tool provider execution recipe (D283/D359-D362)", () => {
+	it("composes policy, adapter input, runtime, and outcome view over caller-owned bindings", () => {
+		const g = graph();
+		const requestFacts = g.node<AgentRequestFact>([], null, { name: "agentRequestFacts" });
+		const routes = g.node<ExecutorRoute>([], null, { name: "executorRoutes" });
+		const calls: readonly string[] = [];
+		const binding: ToolProviderAdapterBinding = {
+			providerId: "local-builtin",
+			run(input, ctx) {
+				calls.push(`${input.adapterInputId}:${ctx.attempt}`);
+				return {
+					kind: "result",
+					result: {
+						kind: "text",
+						value: `ran ${input.toolName}`,
+						summary: `ran ${input.toolName}`,
+					},
+					occurredAtMs: 123,
+				};
+			},
+		};
+		const recipe = toolProviderExecutionRecipe(g, {
+			requestFacts,
+			executorRoutes: [routes],
+			catalogs: [localBuiltinToolProviderCatalog()],
+			bindings: [binding],
+			now: () => 123,
+			outcomeViewPolicy: { maxSummaryChars: 64 },
+		});
+		const inputs = collectData(recipe.adapterInputs.inputs);
+		const outcomes = collectData(recipe.outcomes);
+		const views = collectData(recipe.outcomeViews.views);
+		const issues = [
+			...collectData(recipe.issues.policy),
+			...collectData(recipe.issues.adapterInputs),
+			...collectData(recipe.issues.runtime),
+			...collectData(recipe.issues.outcomeViews),
+		];
+
+		routes.down([["DATA", route()]]);
+		requestFacts.down([["DATA", request()]]);
+
+		expect(inputs).toEqual([
+			expect.objectContaining({
+				kind: "tool-provider-adapter-input",
+				status: "ready",
+				providerId: "local-builtin",
+				toolName: "date.now",
+			}),
+		]);
+		expect(calls).toEqual([`${inputs[0]?.adapterInputId}:1`]);
+		expect(outcomes).toEqual([
+			expect.objectContaining({
+				kind: "result",
+				requestId: "request-1",
+				result: expect.objectContaining({ summary: "ran date.now" }),
+			}),
+		]);
+		expect(views).toEqual([
+			expect.objectContaining({
+				kind: "executor-outcome-view",
+				audience: "agent-observation",
+				requestId: "request-1",
+				summary: "ran date.now",
+			}),
+		]);
+		expect(issues).toEqual([]);
+		expect(g.describe().nodes).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({
+					id: "toolProviderExecution/catalogs",
+					factory: "producer",
+				}),
+				expect.objectContaining({
+					id: "toolProviderExecution/policy/runtime",
+					factory: "toolProviderPolicyResolutionProjector",
+				}),
+				expect.objectContaining({
+					id: "toolProviderExecution/adapterInput/runtime",
+					factory: "toolProviderAdapterInputProjector",
+				}),
+				expect.objectContaining({
+					id: "toolProviderExecution/runtime/runs/runtime",
+					factory: "toolProviderAdapterRunProjector",
+				}),
+				expect.objectContaining({
+					id: "toolProviderExecution/outcomeView/runtime",
+					factory: "executorOutcomeViewProjector",
+				}),
+			]),
+		);
+		recipe.dispose();
+	});
+});
+
+function request(): AgentRequestIssued {
+	return {
+		kind: "issued",
+		requestId: "request-1",
+		operationId: "op-1",
+		effectRunId: "effect-run-1",
+		requestKind: "executor",
+		required: true,
+		input: {
+			inputId: "input-1",
+			inputKind: "tool-call",
+			value: {
+				kind: "tool-call",
+				toolName: "date.now",
+				operation: "read",
+			} satisfies ToolCallInput,
+		},
+	};
+}
+
+function route(): ExecutorRoute {
+	return {
+		kind: "executor-route",
+		routeId: "route-1",
+		requestId: "request-1",
+		operationId: "op-1",
+		executorId: "local-builtin:tool-executor",
+		profileId: "local-builtin:tool-profile",
+	};
+}
+
+function collectData<T>(node: {
+	subscribe(sink: (msg: readonly [string, unknown?]) => void): unknown;
+}): T[] {
+	const out: T[] = [];
+	node.subscribe((msg) => {
+		if (msg[0] === "DATA") out.push(msg[1] as T);
+	});
+	return out;
+}
diff --git a/packages/ts/src/__tests__/tool-provider-run-admission.test.ts b/packages/ts/src/__tests__/tool-provider-run-admission.test.ts
new file mode 100644
index 00000000..5b64c358
--- /dev/null
+++ b/packages/ts/src/__tests__/tool-provider-run-admission.test.ts
@@ -0,0 +1,313 @@
+import { describe, expect, it } from "vitest";
+import type { DataIssue } from "../data/index.js";
+import { graph } from "../graph/graph.js";
+import type {
+	ToolProviderAdapterInput,
+	ToolProviderAdapterRunRequested,
+	ToolProviderExecutionPolicy,
+	ToolProviderRunAdmission,
+	ToolProviderRunAdmissionDecision,
+	ToolProviderRunAdmissionProposal,
+	ToolProviderRunAdmissionStatus,
+	ToolProviderRunAdmissionViews,
+} from "../orchestration/agent-runtime.js";
+import {
+	requestToolProviderAdapterRun,
+	toolProviderRunAdmissionProjector,
+} from "../orchestration/agent-runtime.js";
+
+function readyInput(
+	opts: {
+		readonly requestId?: string;
+		readonly approvalMode?: "auto" | "require" | "never" | "custom";
+	} = {},
+): ToolProviderAdapterInput {
+	const requestId = opts.requestId ?? "tool-request-admission";
+	const policy =
+		opts.approvalMode === undefined
+			? undefined
+			: ({
+					kind: "tool-provider-execution-policy",
+					policyId: `${requestId}:policy`,
+					providerId: "provider-admission",
+					approval: {
+						mode: opts.approvalMode,
+						sourceRefs: [{ kind: "approval-policy", id: `${requestId}:approval` }],
+					},
+				} satisfies ToolProviderExecutionPolicy);
+	return {
+		kind: "tool-provider-adapter-input",
+		adapterInputId: `${requestId}:adapter-input`,
+		status: "ready",
+		requestId,
+		operationId: `${requestId}:operation`,
+		routeId: `${requestId}:route`,
+		providerId: "provider-admission",
+		executorId: "executor-admission",
+		profileId: "profile-admission",
+		toolName: "process.exec",
+		operation: "run",
+		policies: policy === undefined ? undefined : [policy],
+		policyRefs:
+			policy === undefined
+				? undefined
+				: [{ kind: "tool-provider-execution-policy", id: policy.policyId }],
+		sourceRefs: [{ kind: "agent-request", id: requestId }],
+	};
+}
+
+function createHarness() {
+	const g = graph();
+	const inputs = g.node<ToolProviderAdapterInput>([], null, {
+		name: "admission-inputs",
+	});
+	const runRequests = g.node<ToolProviderAdapterRunRequested>([], null, {
+		name: "admission-run-requests",
+	});
+	const decisions = g.node<ToolProviderRunAdmissionDecision>([], null, {
+		name: "admission-decisions",
+	});
+	const bundle = toolProviderRunAdmissionProjector(g, {
+		inputs,
+		runRequests: [runRequests],
+		decisions: [decisions],
+		now: () => 1234,
+	});
+	const seen = {
+		proposals: [] as ToolProviderRunAdmissionProposal[],
+		admissions: [] as ToolProviderRunAdmission[],
+		approved: [] as ToolProviderAdapterRunRequested[],
+		status: [] as ToolProviderRunAdmissionStatus[],
+		issues: [] as DataIssue[],
+		views: [] as ToolProviderRunAdmissionViews[],
+	};
+	bundle.proposals.subscribe(
+		(msg) => msg[0] === "DATA" && seen.proposals.push(msg[1] as ToolProviderRunAdmissionProposal),
+	);
+	bundle.admissions.subscribe(
+		(msg) => msg[0] === "DATA" && seen.admissions.push(msg[1] as ToolProviderRunAdmission),
+	);
+	bundle.approvedRunRequests.subscribe(
+		(msg) => msg[0] === "DATA" && seen.approved.push(msg[1] as ToolProviderAdapterRunRequested),
+	);
+	bundle.status.subscribe(
+		(msg) => msg[0] === "DATA" && seen.status.push(msg[1] as ToolProviderRunAdmissionStatus),
+	);
+	bundle.issues.subscribe((msg) => msg[0] === "DATA" && seen.issues.push(msg[1] as DataIssue));
+	bundle.views.subscribe(
+		(msg) => msg[0] === "DATA" && seen.views.push(msg[1] as ToolProviderRunAdmissionViews),
+	);
+	return { inputs, runRequests, decisions, seen };
+}
+
+describe("toolProviderRunAdmissionProjector (D419)", () => {
+	it("emits a visible admitted run request for auto approval without mutating the candidate", () => {
+		const harness = createHarness();
+		const input = readyInput({ requestId: "auto-run", approvalMode: "auto" });
+		const candidate = requestToolProviderAdapterRun(input, {
+			runId: "candidate-auto",
+			reason: "manual",
+		});
+
+		harness.inputs.down([["DATA", input]]);
+		harness.runRequests.down([["DATA", candidate]]);
+
+		expect(harness.seen.proposals).toEqual([
+			expect.objectContaining({
+				proposalId: "candidate-auto:admission-proposal",
+				approvalMode: "auto",
+				runId: "candidate-auto",
+			}),
+		]);
+		expect(harness.seen.admissions).toEqual([
+			expect.objectContaining({
+				state: "admitted",
+				runId: "candidate-auto",
+				approvedRunId: "candidate-auto:admitted",
+			}),
+		]);
+		expect(harness.seen.approved).toEqual([
+			expect.objectContaining({
+				runId: "candidate-auto:admitted",
+				adapterInputId: input.adapterInputId,
+				metadata: expect.objectContaining({
+					admissionId: "candidate-auto:admission-proposal:admission",
+					approvedFromRunId: "candidate-auto",
+				}),
+			}),
+		]);
+		expect(candidate.runId).toBe("candidate-auto");
+	});
+
+	it("waits for a graph-visible admission decision when approval is required", () => {
+		const harness = createHarness();
+		const input = readyInput({ requestId: "require-run", approvalMode: "require" });
+		const candidate = requestToolProviderAdapterRun(input, {
+			runId: "candidate-require",
+			reason: "manual",
+		});
+
+		harness.inputs.down([["DATA", input]]);
+		harness.runRequests.down([["DATA", candidate]]);
+
+		expect(harness.seen.status).toEqual([
+			expect.objectContaining({
+				proposalId: "candidate-require:admission-proposal",
+				state: "waiting",
+			}),
+		]);
+		expect(harness.seen.approved).toEqual([]);
+
+		harness.decisions.down([
+			[
+				"DATA",
+				{
+					kind: "tool-provider-run-admission-decision",
+					decisionId: "decision-approve",
+					proposalId: "candidate-require:admission-proposal",
+					admissionId: "admission-approve",
+					outcome: "admit",
+					approvedRunId: "approved-require-run",
+					decidedByRef: { kind: "human", id: "operator" },
+				},
+			],
+		]);
+
+		expect(harness.seen.admissions.at(-1)).toEqual(
+			expect.objectContaining({
+				admissionId: "admission-approve",
+				state: "admitted",
+				decisionId: "decision-approve",
+				approvedRunId: "approved-require-run",
+			}),
+		);
+		expect(harness.seen.approved).toEqual([
+			expect.objectContaining({
+				runId: "approved-require-run",
+				sourceRefs: expect.arrayContaining([
+					{ kind: "tool-provider-run-admission-decision", id: "decision-approve" },
+				]),
+			}),
+		]);
+	});
+
+	it("blocks never-approved runs without producing an executable run request", () => {
+		const harness = createHarness();
+		const input = readyInput({ requestId: "never-run", approvalMode: "never" });
+
+		harness.inputs.down([["DATA", input]]);
+		harness.runRequests.down([
+			[
+				"DATA",
+				requestToolProviderAdapterRun(input, {
+					runId: "candidate-never",
+					reason: "manual",
+				}),
+			],
+		]);
+
+		expect(harness.seen.admissions).toEqual([
+			expect.objectContaining({ runId: "candidate-never", state: "blocked" }),
+		]);
+		expect(harness.seen.status).toEqual([
+			expect.objectContaining({ runId: "candidate-never", state: "blocked" }),
+		]);
+		expect(harness.seen.issues).toEqual([
+			expect.objectContaining({ code: "tool-provider-run-admission-blocked" }),
+		]);
+		expect(harness.seen.approved).toEqual([]);
+	});
+
+	it("rejects stale run requests at the admission gate", () => {
+		const harness = createHarness();
+		const input = readyInput({ requestId: "stale-run", approvalMode: "auto" });
+		const stale = {
+			...requestToolProviderAdapterRun(input, { runId: "candidate-stale", reason: "manual" }),
+			requestId: "different-request",
+		} satisfies ToolProviderAdapterRunRequested;
+
+		harness.inputs.down([["DATA", input]]);
+		harness.runRequests.down([["DATA", stale]]);
+
+		expect(harness.seen.status).toEqual([
+			expect.objectContaining({ runId: "candidate-stale", state: "issue" }),
+		]);
+		expect(harness.seen.issues).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({ code: "tool-provider-adapter-run-request-stale-request" }),
+			]),
+		);
+		expect(harness.seen.approved).toEqual([]);
+	});
+
+	it("treats the first admission decision as terminal for a proposal", () => {
+		const harness = createHarness();
+		const input = readyInput({ requestId: "duplicate-decision", approvalMode: "require" });
+		const candidate = requestToolProviderAdapterRun(input, {
+			runId: "candidate-duplicate-decision",
+			reason: "manual",
+		});
+
+		harness.inputs.down([["DATA", input]]);
+		harness.runRequests.down([["DATA", candidate]]);
+		harness.decisions.down([
+			[
+				"DATA",
+				{
+					kind: "tool-provider-run-admission-decision",
+					decisionId: "decision-first",
+					proposalId: "candidate-duplicate-decision:admission-proposal",
+					admissionId: "admission-first",
+					outcome: "admit",
+					approvedRunId: "approved-first",
+				},
+			],
+			[
+				"DATA",
+				{
+					kind: "tool-provider-run-admission-decision",
+					decisionId: "decision-second",
+					proposalId: "candidate-duplicate-decision:admission-proposal",
+					admissionId: "admission-second",
+					outcome: "admit",
+					approvedRunId: "approved-second",
+				},
+			],
+		]);
+
+		expect(harness.seen.approved).toEqual([expect.objectContaining({ runId: "approved-first" })]);
+		expect(harness.seen.issues).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({ code: "tool-provider-run-admission-duplicate-decision" }),
+			]),
+		);
+		expect(harness.seen.status).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({
+					proposalId: "candidate-duplicate-decision:admission-proposal",
+					state: "issue",
+				}),
+			]),
+		);
+	});
+
+	it("keeps admission views deduped when a run request is replayed", () => {
+		const harness = createHarness();
+		const input = readyInput({ requestId: "replay-run", approvalMode: "auto" });
+		const candidate = requestToolProviderAdapterRun(input, {
+			runId: "candidate-replay",
+			reason: "manual",
+		});
+
+		harness.inputs.down([["DATA", input]]);
+		harness.runRequests.down([["DATA", candidate]]);
+		harness.runRequests.down([["DATA", candidate]]);
+
+		const latestView = harness.seen.views.at(-1);
+		expect(latestView?.proposalsByRun.get("candidate-replay")).toHaveLength(1);
+		expect(latestView?.admissionsByRun.get("candidate-replay")).toHaveLength(1);
+		expect(harness.seen.approved).toEqual([
+			expect.objectContaining({ runId: "candidate-replay:admitted" }),
+		]);
+	});
+});
diff --git a/packages/ts/src/__tests__/tool-provider-run-retry.test.ts b/packages/ts/src/__tests__/tool-provider-run-retry.test.ts
new file mode 100644
index 00000000..96ff2e16
--- /dev/null
+++ b/packages/ts/src/__tests__/tool-provider-run-retry.test.ts
@@ -0,0 +1,675 @@
+import { describe, expect, it } from "vitest";
+import type { DataIssue } from "../data/index.js";
+import { attachToolProviderAdapterRuntime } from "../executors/tool-provider-runtime.js";
+import { graph } from "../graph/graph.js";
+import { retryPolicy } from "../graph/resilience.js";
+import type {
+	ExecutorOutcome,
+	ScheduledReadinessReady,
+	ScheduledReadinessRequested,
+	SourceRef,
+	ToolProviderAdapterInput,
+	ToolProviderAdapterRunRequested,
+	ToolProviderRunAdmissionDecision,
+	ToolProviderRunRetryPolicy,
+	ToolProviderRunRetryProposal,
+	ToolProviderRunRetryScheduled,
+	ToolProviderRunRetryStatus,
+	ToolProviderRunRetryViews,
+} from "../orchestration/index.js";
+import {
+	toolProviderRunAdmissionProjector,
+	toolProviderRunRetryProjector,
+} from "../orchestration/index.js";
+
+describe("toolProviderRunRetryProjector (D422)", () => {
+	it("emits one immediate retry run request with attempt provenance", () => {
+		const harness = createRetryHarness();
+		const input = readyInput("retry-immediate");
+		const outcome = retryableFailure(input, { attempt: 1, runId: "run-1" });
+
+		harness.inputs.down([["DATA", input]]);
+		harness.policies.down([["DATA", retryPolicyFact("retry-policy", 3)]]);
+		harness.outcomes.down([["DATA", outcome]]);
+
+		expect(harness.seen.proposals).toEqual([
+			expect.objectContaining({
+				outcomeId: outcome.outcomeId,
+				fromRunId: "run-1",
+				fromAttempt: 1,
+				nextAttempt: 2,
+				nextRunId: "run-1:retry-2",
+			}),
+		]);
+		expect(harness.seen.runRequests).toEqual([
+			expect.objectContaining({
+				runId: "run-1:retry-2",
+				adapterInputId: input.adapterInputId,
+				attempt: 2,
+				reason: "retry",
+				retryOfOutcomeId: outcome.outcomeId,
+				policyRefs: expect.arrayContaining([
+					{ kind: "tool-provider-run-retry-policy", id: "retry-policy" },
+				]),
+				sourceRefs: expect.arrayContaining([
+					{ kind: "executor-outcome", id: outcome.outcomeId },
+					{ kind: "tool-provider-run-retry-proposal", id: `${outcome.outcomeId}:retry-proposal` },
+				]),
+			}),
+		]);
+		expect(harness.seen.status).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({ state: "ready", nextAttempt: 2, nextRunId: "run-1:retry-2" }),
+			]),
+		);
+	});
+
+	it("emits exhausted status and no run request after maxAttempts", () => {
+		const harness = createRetryHarness();
+		const input = readyInput("retry-exhausted");
+		const outcome = retryableFailure(input, { attempt: 2, runId: "run-2" });
+
+		harness.inputs.down([["DATA", input]]);
+		harness.policies.down([["DATA", retryPolicyFact("retry-policy", 2)]]);
+		harness.outcomes.down([["DATA", outcome]]);
+
+		expect(harness.seen.runRequests).toEqual([]);
+		expect(harness.seen.status).toEqual([
+			expect.objectContaining({
+				outcomeId: outcome.outcomeId,
+				state: "exhausted",
+				issueCodes: ["tool-provider-run-retry-exhausted"],
+			}),
+		]);
+		expect(harness.seen.issues).toEqual([
+			expect.objectContaining({ code: "tool-provider-run-retry-exhausted" }),
+		]);
+	});
+
+	it("does not duplicate retry proposals or requests when an outcome is replayed", () => {
+		const harness = createRetryHarness();
+		const input = readyInput("retry-replay");
+		const outcome = retryableFailure(input, { attempt: 1, runId: "run-replay" });
+
+		harness.inputs.down([["DATA", input]]);
+		harness.policies.down([["DATA", retryPolicyFact("retry-policy", 3)]]);
+		harness.outcomes.down([["DATA", outcome]]);
+		harness.outcomes.down([["DATA", outcome]]);
+
+		expect(harness.seen.proposals).toHaveLength(1);
+		expect(harness.seen.runRequests).toHaveLength(1);
+		expect(harness.seen.views.at(-1)?.nextRunRequestsByOutcome.get(outcome.outcomeId)).toEqual(
+			expect.objectContaining({ runId: "run-replay:retry-2" }),
+		);
+	});
+
+	it("uses the exact outcome input id when multiple adapter inputs share a request", () => {
+		const harness = createRetryHarness();
+		const firstInput = readyInput("retry-exact-first");
+		const secondInput = {
+			...readyInput("retry-exact-second"),
+			requestId: firstInput.requestId,
+			operationId: firstInput.operationId,
+		};
+		const outcome = retryableFailure(secondInput, { attempt: 1, runId: "run-exact-second" });
+
+		harness.inputs.down([["DATA", firstInput]]);
+		harness.inputs.down([["DATA", secondInput]]);
+		harness.policies.down([["DATA", retryPolicyFact("retry-policy", 3)]]);
+		harness.outcomes.down([["DATA", outcome]]);
+
+		expect(harness.seen.runRequests).toEqual([
+			expect.objectContaining({
+				adapterInputId: secondInput.adapterInputId,
+				requestId: firstInput.requestId,
+				runId: "run-exact-second:retry-2",
+			}),
+		]);
+	});
+
+	it("fails closed when request-only outcomes match multiple adapter inputs", () => {
+		const harness = createRetryHarness();
+		const firstInput = readyInput("retry-ambiguous-first");
+		const secondInput = {
+			...readyInput("retry-ambiguous-second"),
+			requestId: firstInput.requestId,
+			operationId: firstInput.operationId,
+		};
+		const outcomeWithoutInputId = {
+			...retryableFailure(firstInput, {
+				attempt: 1,
+				runId: "run-ambiguous",
+			}),
+		};
+		delete outcomeWithoutInputId.inputId;
+
+		harness.inputs.down([["DATA", firstInput]]);
+		harness.inputs.down([["DATA", secondInput]]);
+		harness.policies.down([["DATA", retryPolicyFact("retry-policy", 3)]]);
+		harness.outcomes.down([["DATA", outcomeWithoutInputId]]);
+
+		expect(harness.seen.runRequests).toEqual([]);
+		expect(harness.seen.issues).toEqual([
+			expect.objectContaining({ code: "tool-provider-run-retry-ambiguous-input" }),
+		]);
+		expect(harness.seen.status).toEqual([
+			expect.objectContaining({
+				state: "blocked",
+				issueCodes: ["tool-provider-run-retry-ambiguous-input"],
+			}),
+		]);
+	});
+
+	it("re-evaluates retained outcomes when input and policy facts arrive later", () => {
+		const harness = createRetryHarness();
+		const input = readyInput("retry-out-of-order");
+		const outcome = retryableFailure(input, { attempt: 1, runId: "run-out-of-order" });
+
+		harness.outcomes.down([["DATA", outcome]]);
+		expect(harness.seen.runRequests).toEqual([]);
+
+		harness.inputs.down([["DATA", input]]);
+		expect(harness.seen.runRequests).toEqual([]);
+
+		harness.policies.down([["DATA", retryPolicyFact("retry-policy", 3)]]);
+
+		expect(harness.seen.runRequests).toEqual([
+			expect.objectContaining({
+				runId: "run-out-of-order:retry-2",
+				attempt: 2,
+				retryOfOutcomeId: outcome.outcomeId,
+			}),
+		]);
+	});
+
+	it("keeps delayed retry pending until a visible nowMs fact reaches retryAtMs", () => {
+		const harness = createRetryHarness({ includeClock: true });
+		const input = readyInput("retry-delayed");
+		const outcome = retryableFailure(input, { attempt: 1, runId: "run-delayed" });
+
+		harness.inputs.down([["DATA", input]]);
+		harness.policies.down([
+			["DATA", retryPolicyFact("retry-policy", 3, { kind: "constant", delayMs: 50 })],
+		]);
+		harness.nowMs?.down([["DATA", 1_000]]);
+		harness.outcomes.down([["DATA", outcome]]);
+
+		expect(harness.seen.scheduled).toEqual([
+			expect.objectContaining({
+				outcomeId: outcome.outcomeId,
+				nextAttempt: 2,
+				readinessScheduleId: `${outcome.outcomeId}:retry-proposal:scheduled-readiness`,
+				retryAtMs: 1_050,
+				retryAfterMs: 50,
+			}),
+		]);
+		expect(harness.seen.readinessSchedules).toEqual([
+			expect.objectContaining({
+				kind: "scheduled-readiness-requested",
+				scheduleId: `${outcome.outcomeId}:retry-proposal:scheduled-readiness`,
+				readyAtMs: 1_050,
+				reason: "tool-provider-retry",
+			}),
+		]);
+		expect(harness.seen.runRequests).toEqual([]);
+
+		harness.nowMs?.down([["DATA", 1_049]]);
+		expect(harness.seen.runRequests).toEqual([]);
+
+		harness.nowMs?.down([["DATA", 1_050]]);
+		expect(harness.seen.runRequests).toEqual([
+			expect.objectContaining({
+				runId: "run-delayed:retry-2",
+				attempt: 2,
+				retryOfOutcomeId: outcome.outcomeId,
+			}),
+		]);
+	});
+
+	it("can consume shared scheduled-readiness ready facts for delayed retries", () => {
+		const harness = createRetryHarness({ includeClock: true, includeReadiness: true });
+		const input = readyInput("retry-shared-ready");
+		const outcome = retryableFailure(input, { attempt: 1, runId: "run-shared-ready" });
+
+		harness.inputs.down([["DATA", input]]);
+		harness.policies.down([
+			["DATA", retryPolicyFact("retry-policy", 3, { kind: "constant", delayMs: 50 })],
+		]);
+		harness.nowMs?.down([["DATA", 1_000]]);
+		harness.outcomes.down([["DATA", outcome]]);
+
+		expect(harness.seen.runRequests).toEqual([]);
+		const schedule = harness.seen.readinessSchedules[0];
+		expect(schedule).toEqual(
+			expect.objectContaining({
+				scheduleId: `${outcome.outcomeId}:retry-proposal:scheduled-readiness`,
+				readyAtMs: 1_050,
+			}),
+		);
+
+		harness.nowMs?.down([["DATA", 1_050]]);
+		expect(harness.seen.runRequests).toEqual([]);
+
+		harness.readiness?.down([
+			[
+				"DATA",
+				{
+					kind: "scheduled-readiness-ready",
+					scheduleId: schedule?.scheduleId ?? "missing",
+					subjectRefs: schedule?.subjectRefs ?? [],
+					readyAtMs: schedule?.readyAtMs ?? 0,
+					nowMs: 1_050,
+					sourceRefs: [
+						{ kind: "scheduled-readiness", id: schedule?.scheduleId ?? "missing" },
+						...(schedule?.sourceRefs ?? []),
+					],
+				},
+			],
+		]);
+
+		expect(harness.seen.runRequests).toEqual([
+			expect.objectContaining({
+				runId: "run-shared-ready:retry-2",
+				attempt: 2,
+				retryOfOutcomeId: outcome.outcomeId,
+				sourceRefs: expect.arrayContaining([
+					{ kind: "scheduled-readiness-ready", id: schedule?.scheduleId },
+				]),
+				metadata: expect.objectContaining({ readinessScheduleId: schedule?.scheduleId }),
+			}),
+		]);
+	});
+
+	it("rejects mismatched shared readiness facts without releasing a delayed retry early", () => {
+		const harness = createRetryHarness({ includeClock: true, includeReadiness: true });
+		const input = readyInput("retry-readiness-mismatch");
+		const outcome = retryableFailure(input, { attempt: 1, runId: "run-readiness-mismatch" });
+
+		harness.inputs.down([["DATA", input]]);
+		harness.policies.down([
+			["DATA", retryPolicyFact("retry-policy", 3, { kind: "constant", delayMs: 50 })],
+		]);
+		harness.nowMs?.down([["DATA", 1_000]]);
+		harness.outcomes.down([["DATA", outcome]]);
+		const schedule = harness.seen.readinessSchedules[0];
+
+		harness.readiness?.down([
+			[
+				"DATA",
+				{
+					kind: "scheduled-readiness-ready",
+					scheduleId: schedule?.scheduleId ?? "missing",
+					subjectRefs: schedule?.subjectRefs ?? [],
+					readyAtMs: 1_049,
+					nowMs: 1_049,
+					sourceRefs: [
+						{ kind: "scheduled-readiness", id: schedule?.scheduleId ?? "missing" },
+						...(schedule?.sourceRefs ?? []),
+					],
+				},
+			],
+		]);
+
+		expect(harness.seen.runRequests).toEqual([]);
+		expect(harness.seen.issues).toEqual([
+			expect.objectContaining({ code: "tool-provider-run-retry-readiness-mismatch" }),
+		]);
+	});
+
+	it("rejects malformed or unprovenanced shared readiness facts without releasing retry", () => {
+		const harness = createRetryHarness({ includeClock: true, includeReadiness: true });
+		const input = readyInput("retry-readiness-provenance");
+		const outcome = retryableFailure(input, { attempt: 1, runId: "run-readiness-provenance" });
+
+		harness.inputs.down([["DATA", input]]);
+		harness.policies.down([
+			["DATA", retryPolicyFact("retry-policy", 3, { kind: "constant", delayMs: 50 })],
+		]);
+		harness.nowMs?.down([["DATA", 1_000]]);
+		harness.outcomes.down([["DATA", outcome]]);
+		const schedule = harness.seen.readinessSchedules[0];
+
+		harness.readiness?.down([
+			[
+				"DATA",
+				{
+					kind: "scheduled-readiness-ready",
+					scheduleId: schedule?.scheduleId ?? "missing",
+					subjectRefs: schedule?.subjectRefs ?? [],
+					readyAtMs: schedule?.readyAtMs ?? 0,
+					nowMs: 1_050,
+					sourceRefs: { kind: "not-array", id: "bad" },
+				} as unknown as ScheduledReadinessReady,
+			],
+		]);
+		harness.readiness?.down([
+			[
+				"DATA",
+				{
+					kind: "scheduled-readiness-ready",
+					scheduleId: schedule?.scheduleId ?? "missing",
+					subjectRefs: schedule?.subjectRefs ?? [],
+					readyAtMs: schedule?.readyAtMs ?? 0,
+					nowMs: 1_050,
+					sourceRefs: [{ kind: "external-ready", id: "unprovenanced" }],
+				},
+			],
+		]);
+
+		expect(harness.seen.runRequests).toEqual([]);
+		expect(harness.seen.issues).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({ code: "tool-provider-run-retry-readiness-malformed" }),
+				expect.objectContaining({ code: "tool-provider-run-retry-readiness-mismatch" }),
+			]),
+		);
+	});
+
+	it("can schedule a delayed retry after the visible clock fact arrives later", () => {
+		const harness = createRetryHarness({ includeClock: true });
+		const input = readyInput("retry-clock-late");
+		const outcome = retryableFailure(input, { attempt: 1, runId: "run-clock-late" });
+
+		harness.inputs.down([["DATA", input]]);
+		harness.policies.down([
+			["DATA", retryPolicyFact("retry-policy", 3, { kind: "constant", delayMs: 25 })],
+		]);
+		harness.outcomes.down([["DATA", outcome]]);
+
+		expect(harness.seen.proposals).toHaveLength(1);
+		expect(harness.seen.scheduled).toEqual([]);
+		expect(harness.seen.runRequests).toEqual([]);
+
+		harness.nowMs?.down([["DATA", 2_000]]);
+
+		expect(harness.seen.scheduled).toEqual([
+			expect.objectContaining({ outcomeId: outcome.outcomeId, retryAtMs: 2_025 }),
+		]);
+		expect(harness.seen.runRequests).toEqual([]);
+
+		harness.nowMs?.down([["DATA", 2_025]]);
+		expect(harness.seen.runRequests).toEqual([
+			expect.objectContaining({ runId: "run-clock-late:retry-2", attempt: 2 }),
+		]);
+	});
+
+	it("routes approval-required retry candidates through D419 admission before runtime execution", () => {
+		const g = graph();
+		const inputs = g.node<ToolProviderAdapterInput>([], null, { name: "retry-admission-inputs" });
+		const outcomes = g.node<ExecutorOutcome>([], null, { name: "retry-admission-outcomes" });
+		const policies = g.node<ToolProviderRunRetryPolicy>([], null, {
+			name: "retry-admission-policies",
+		});
+		const decisions = g.node<ToolProviderRunAdmissionDecision>([], null, {
+			name: "retry-admission-decisions",
+		});
+		const retry = toolProviderRunRetryProjector(g, {
+			inputs,
+			outcomes,
+			policies: [policies],
+		});
+		const admission = toolProviderRunAdmissionProjector(g, {
+			inputs,
+			runRequests: [retry.runRequests],
+			decisions: [decisions],
+		});
+		const calls: number[] = [];
+		const runtime = attachToolProviderAdapterRuntime(g, {
+			inputs,
+			runRequests: [admission.approvedRunRequests],
+			autoRunReadyInputs: false,
+			bindings: [
+				{
+					providerId: "provider-retry",
+					run(_input, ctx) {
+						calls.push(ctx.attempt);
+						return {
+							kind: "result",
+							result: { kind: "text", value: "approved", summary: "approved" },
+						};
+					},
+				},
+			],
+		});
+		const input = withApproval(readyInput("retry-admission"), "require");
+		const outcome = retryableFailure(input, { attempt: 1, runId: "candidate-before-retry" });
+
+		inputs.down([["DATA", input]]);
+		policies.down([["DATA", retryPolicyFact("retry-policy", 3)]]);
+		outcomes.down([["DATA", outcome]]);
+
+		expect(calls).toEqual([]);
+
+		decisions.down([
+			[
+				"DATA",
+				{
+					kind: "tool-provider-run-admission-decision",
+					decisionId: "retry-admission-decision",
+					proposalId: "candidate-before-retry:retry-2:admission-proposal",
+					admissionId: "retry-admission",
+					outcome: "admit",
+					approvedRunId: "retry-approved-run",
+				},
+			],
+		]);
+
+		expect(calls).toEqual([2]);
+		runtime.dispose();
+	});
+
+	it("adapter runtime remains one-shot and does not internally retry retryable failures", () => {
+		const g = graph();
+		const inputs = g.node<ToolProviderAdapterInput>([], null, { name: "runtime-no-retry-inputs" });
+		const calls: number[] = [];
+		const runtime = attachToolProviderAdapterRuntime(g, {
+			inputs,
+			bindings: [
+				{
+					providerId: "provider-retry",
+					run(input, ctx) {
+						calls.push(ctx.attempt);
+						return {
+							kind: "failure",
+							error: issue("runtime-retryable-failure", input.requestId),
+							retryable: true,
+						};
+					},
+				},
+			],
+		});
+
+		inputs.down([["DATA", readyInput("runtime-no-retry")]]);
+
+		expect(calls).toEqual([1]);
+		runtime.dispose();
+	});
+
+	it("keeps artifact/ref material as provenance instead of inlining raw failure payloads", () => {
+		const harness = createRetryHarness();
+		const input = readyInput("retry-artifact");
+		const artifactRef = { kind: "artifact", id: "stdout-ref" };
+		const raw = "x".repeat(10_000);
+		const outcome = retryableFailure(input, {
+			attempt: 1,
+			runId: "run-artifact",
+			evidenceRefs: [artifactRef],
+			metadata: { runId: "run-artifact", rawResponseBody: raw },
+		});
+
+		harness.inputs.down([["DATA", input]]);
+		harness.policies.down([["DATA", retryPolicyFact("retry-policy", 3)]]);
+		harness.outcomes.down([["DATA", outcome]]);
+
+		const serialized = JSON.stringify(harness.seen.runRequests[0]);
+		expect(harness.seen.runRequests[0]?.sourceRefs).toEqual(
+			expect.arrayContaining([artifactRef, { kind: "executor-outcome", id: outcome.outcomeId }]),
+		);
+		expect(serialized).not.toContain(raw);
+		expect(serialized.length).toBeLessThan(4_000);
+	});
+
+	it("canonicalizes upstream source refs before retry facts reuse them", () => {
+		const harness = createRetryHarness();
+		const input = {
+			...readyInput("retry-ref-sanitize"),
+			sourceRefs: [
+				{
+					kind: "agent-request",
+					id: "retry-ref-sanitize:request",
+					metadata: { apiKey: "SECRET-INPUT-REF" },
+				},
+			],
+		};
+		const outcome = retryableFailure(input, {
+			attempt: 1,
+			runId: "run-ref-sanitize",
+			evidenceRefs: [
+				{
+					kind: "artifact",
+					id: "raw-response-ref",
+					metadata: { authorization: "SECRET-OUTCOME-REF" },
+				},
+			],
+		});
+
+		harness.inputs.down([["DATA", input]]);
+		harness.policies.down([["DATA", retryPolicyFact("retry-policy", 3)]]);
+		harness.outcomes.down([["DATA", outcome]]);
+
+		const serialized = JSON.stringify(harness.seen.runRequests[0]);
+		expect(serialized).not.toContain("SECRET-INPUT-REF");
+		expect(serialized).not.toContain("SECRET-OUTCOME-REF");
+		expect(harness.seen.runRequests[0]?.sourceRefs).toEqual(
+			expect.arrayContaining([
+				{ kind: "agent-request", id: "retry-ref-sanitize:request" },
+				{ kind: "artifact", id: "raw-response-ref" },
+			]),
+		);
+	});
+});
+
+function createRetryHarness(
+	opts: { readonly includeClock?: boolean; readonly includeReadiness?: boolean } = {},
+) {
+	const g = graph();
+	const inputs = g.node<ToolProviderAdapterInput>([], null, { name: "retry-inputs" });
+	const outcomes = g.node<ExecutorOutcome>([], null, { name: "retry-outcomes" });
+	const policies = g.node<ToolProviderRunRetryPolicy>([], null, { name: "retry-policies" });
+	const nowMs = opts.includeClock ? g.node<number>([], null, { name: "retry-now-ms" }) : undefined;
+	const readiness = opts.includeReadiness
+		? g.node<ScheduledReadinessReady>([], null, { name: "retry-readiness" })
+		: undefined;
+	const bundle = toolProviderRunRetryProjector(g, {
+		inputs,
+		outcomes,
+		policies: [policies],
+		...(nowMs === undefined ? {} : { nowMs }),
+		...(readiness === undefined ? {} : { readiness: [readiness] }),
+	});
+	return {
+		inputs,
+		outcomes,
+		policies,
+		nowMs,
+		readiness,
+		seen: {
+			proposals: collectData<ToolProviderRunRetryProposal>(bundle.proposals),
+			scheduled: collectData<ToolProviderRunRetryScheduled>(bundle.scheduled),
+			readinessSchedules: collectData<ScheduledReadinessRequested>(bundle.readinessSchedules),
+			runRequests: collectData<ToolProviderAdapterRunRequested>(bundle.runRequests),
+			status: collectData<ToolProviderRunRetryStatus>(bundle.status),
+			issues: collectData<DataIssue>(bundle.issues),
+			views: collectData<ToolProviderRunRetryViews>(bundle.views),
+		},
+	};
+}
+
+function readyInput(id: string): ToolProviderAdapterInput {
+	return {
+		kind: "tool-provider-adapter-input",
+		adapterInputId: `${id}:adapter-input`,
+		status: "ready",
+		requestId: `${id}:request`,
+		operationId: `${id}:operation`,
+		routeId: `${id}:route`,
+		providerId: "provider-retry",
+		executorId: "executor-retry",
+		profileId: "profile-retry",
+		toolName: "retry.tool",
+		operation: "run",
+		sourceRefs: [{ kind: "agent-request", id: `${id}:request` }],
+	};
+}
+
+function retryPolicyFact(
+	policyId: string,
+	maxAttempts: number,
+	backoff: Parameters<typeof retryPolicy>[1] = { kind: "none" },
+): ToolProviderRunRetryPolicy {
+	return {
+		kind: "tool-provider-run-retry-policy",
+		policyId,
+		retryPolicy: retryPolicy(maxAttempts, backoff),
+		sourceRefs: [{ kind: "retry-policy", id: policyId }],
+	};
+}
+
+function retryableFailure(
+	input: ToolProviderAdapterInput,
+	opts: {
+		readonly attempt: number;
+		readonly runId: string;
+		readonly evidenceRefs?: readonly SourceRef[];
+		readonly metadata?: Record<string, unknown>;
+	},
+): ExecutorOutcome {
+	return {
+		kind: "failure",
+		outcomeId: `${opts.runId}:outcome`,
+		requestId: input.requestId,
+		operationId: input.operationId,
+		routeId: input.routeId ?? "route",
+		executorId: input.executorId ?? "executor",
+		profileId: input.profileId ?? "profile",
+		attempt: opts.attempt,
+		inputId: input.adapterInputId,
+		...(opts.evidenceRefs === undefined ? {} : { evidenceRefs: opts.evidenceRefs }),
+		metadata: opts.metadata ?? { runId: opts.runId },
+		error: issue("retryable-failure", input.requestId),
+		retryable: true,
+	};
+}
+
+function withApproval(
+	input: ToolProviderAdapterInput,
+	mode: "auto" | "require" | "never",
+): ToolProviderAdapterInput {
+	const policyId = `${input.adapterInputId}:approval`;
+	return {
+		...input,
+		policies: [
+			{
+				kind: "tool-provider-execution-policy",
+				policyId,
+				providerId: input.providerId ?? "provider-retry",
+				approval: { mode },
+			},
+		],
+		policyRefs: [{ kind: "tool-provider-execution-policy", id: policyId }],
+	};
+}
+
+function issue(code: string, subjectId: string): DataIssue {
+	return { kind: "issue", code, message: code, subjectId };
+}
+
+function collectData<T>(node: {
+	subscribe(sink: (msg: readonly [string, unknown?]) => void): unknown;
+}): T[] {
+	const out: T[] = [];
+	node.subscribe((msg) => {
+		if (msg[0] === "DATA") out.push(msg[1] as T);
+	});
+	return out;
+}
diff --git a/packages/ts/src/__tests__/up-source.test.ts b/packages/ts/src/__tests__/up-source.test.ts
new file mode 100644
index 00000000..31185179
--- /dev/null
+++ b/packages/ts/src/__tests__/up-source.test.ts
@@ -0,0 +1,72 @@
+import { describe, expect, it } from "vitest";
+import type { Ctx, Message } from "../index.js";
+import { batch, depLatest, node } from "../index.js";
+
+// depless source S (cached) → derived D (passthrough) → sink. D originates ctx.up([msg]),
+// which forwards upstream to the terminus S (R-up-at-source / D38).
+function setup() {
+	const s = node<number>([], null, { initial: 5 });
+	const d = node<number>([s], (ctx: Ctx) => ctx.down([["DATA", depLatest(ctx, 0) as number]]));
+	const seen: Message[] = [];
+	d.subscribe((m) => seen.push(m));
+	return { s, d, seen };
+}
+
+describe("R-up-at-source (D38) — upstream control at a depless source", () => {
+	it("INVALIDATE-up is HONORED: source self-invalidates + cascades down", () => {
+		const { s, d, seen } = setup();
+		expect(s.cache).toBe(5);
+		seen.length = 0;
+		d.up([["INVALIDATE"]]); // → forwards to S (terminus) → self _invalidate → cascade down
+		expect(s.cache).toBeUndefined(); // SENTINEL
+		expect(s.status).toBe("sentinel");
+		expect(seen.map((m) => m[0])).toContain("INVALIDATE"); // D observed the down-cascade
+		expect(d.cache).toBeUndefined();
+	});
+
+	it("INVALIDATE-up fires the source's onInvalidate hook once", () => {
+		let flushed = 0;
+		// a source with a fn so it can register onInvalidate (producer-style depless node)
+		const s = node<number>([], (ctx: Ctx) => {
+			ctx.onInvalidate(() => {
+				flushed++;
+			});
+			ctx.down([["DATA", 9]]);
+		});
+		const d = node<number>([s], (ctx: Ctx) => ctx.down([["DATA", depLatest(ctx, 0) as number]]));
+		d.subscribe(() => {});
+		expect(s.cache).toBe(9);
+		d.up([["INVALIDATE"]]);
+		expect(flushed).toBe(1);
+		expect(s.cache).toBeUndefined();
+	});
+
+	it("DIRTY-up is DROPPED at the source: untouched, no down-cascade", () => {
+		const { s, d, seen } = setup();
+		seen.length = 0;
+		d.up([["DIRTY"]]); // D forwards DIRTY to S; S is the depless terminus → drop
+		expect(s.cache).toBe(5);
+		expect(s.status).toBe("settled");
+		expect(seen.length).toBe(0); // nothing propagated downstream
+	});
+
+	it("TEARDOWN-up is DROPPED at the source: not terminated, no down-cascade", () => {
+		const { s, d, seen } = setup();
+		seen.length = 0;
+		d.up([["TEARDOWN"]]); // forwarded to S → terminus → drop
+		expect(s.status).toBe("settled"); // not terminated
+		expect(s.cache).toBe(5);
+		expect(seen.length).toBe(0);
+	});
+
+	it("INVALIDATE-up defers inside a batch, cascades on commit (A-2: routed via _down)", () => {
+		const s = node<number>([], null, { initial: 5 });
+		const d = node<number>([s], (ctx: Ctx) => ctx.down([["DATA", depLatest(ctx, 0) as number]]));
+		d.subscribe(() => {});
+		batch(() => {
+			d.up([["INVALIDATE"]]); // forwarded to depless S → S._down → tier-4 deferred
+			expect(s.cache).toBe(5); // deferred — NOT yet applied mid-batch
+		});
+		expect(s.cache).toBeUndefined(); // committed → source self-invalidated
+	});
+});
diff --git a/packages/ts/src/__tests__/wire-bridge.protobuf-d497.test.ts b/packages/ts/src/__tests__/wire-bridge.protobuf-d497.test.ts
new file mode 100644
index 00000000..e6062b9d
--- /dev/null
+++ b/packages/ts/src/__tests__/wire-bridge.protobuf-d497.test.ts
@@ -0,0 +1,767 @@
+import { readFileSync } from "node:fs";
+import { describe, expect, it } from "vitest";
+import {
+	CanonicalProtobufError,
+	decodeCanonicalWireBridgeEnvelope,
+	decodeCanonicalWireEdgeFrame,
+	encodeCanonicalWireBridgeEnvelope,
+	encodeCanonicalWireEdgeFrame,
+	type WireBridgeProtobufData,
+	wireBridge,
+	wireBridgeEnvelope,
+	wireBridgeProtobuf,
+} from "../adapters/index.js";
+import { graph } from "../graph/graph.js";
+
+interface VectorRecord {
+	readonly schema: "graphrefly.protobuf.golden.v1";
+	readonly id: string;
+	readonly message: "WireBridgeEnvelope" | "WireEdgeFrame";
+	readonly description: string;
+	readonly hex: string;
+	readonly canonical: boolean;
+	readonly errorCategory?: string;
+	readonly expect?: { readonly payload?: string };
+}
+
+const envelopeFixtureUrl = new URL(
+	"./fixtures/protobuf/wire_bridge_envelope.v1.jsonl",
+	import.meta.url,
+);
+const wireEdgeFixtureUrl = new URL("./fixtures/protobuf/wire_edge_frame.v1.jsonl", import.meta.url);
+
+function vectors(fixtureUrl: URL, message: VectorRecord["message"]): VectorRecord[] {
+	return readFileSync(fixtureUrl, "utf8")
+		.trim()
+		.split("\n")
+		.map((line, index) => {
+			const record = JSON.parse(line) as VectorRecord;
+			expect(record.schema, `schema line ${index + 1}`).toBe("graphrefly.protobuf.golden.v1");
+			expect(record.message, `message line ${index + 1}`).toBe(message);
+			expect(record.id, `id line ${index + 1}`).toMatch(/^(positive|negative)\./);
+			expect(record.hex, `hex line ${index + 1}`).toMatch(/^(?:[0-9a-f]{2})+$/);
+			if (record.canonical) {
+				expect(record.errorCategory, `${record.id} must not declare an error`).toBeUndefined();
+			} else {
+				expect(record.errorCategory, `${record.id} must declare an error`).toBeTypeOf("string");
+			}
+			return record;
+		});
+}
+
+function fromHex(hex: string): Uint8Array {
+	const out = new Uint8Array(hex.length / 2);
+	for (let i = 0; i < out.length; i++) {
+		out[i] = Number.parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+	}
+	return out;
+}
+
+function toHex(bytes: Uint8Array): string {
+	return Buffer.from(bytes).toString("hex");
+}
+
+type TestMessage = readonly [string, ...unknown[]];
+
+function dataMessages(messages: readonly unknown[]): TestMessage[] {
+	return messages.filter((msg): msg is TestMessage => Array.isArray(msg) && msg[0] === "DATA");
+}
+
+function vectorById(message: VectorRecord["message"], id: string): VectorRecord {
+	const fixtureUrl = message === "WireBridgeEnvelope" ? envelopeFixtureUrl : wireEdgeFixtureUrl;
+	const record = vectors(fixtureUrl, message).find((candidate) => candidate.id === id);
+	if (record === undefined) throw new Error(`missing fixture ${id}`);
+	return record;
+}
+
+const canonicalInboundBytes = () =>
+	fromHex(vectorById("WireBridgeEnvelope", "positive.data.empty_value").hex);
+
+const malformedInboundBytes = () =>
+	fromHex(vectorById("WireBridgeEnvelope", "negative.old_wireframe_shape").hex);
+
+describe("D497 canonical protobuf wire bridge envelope vectors", () => {
+	it("parses fixture records with stable schema fields", () => {
+		const records = vectors(envelopeFixtureUrl, "WireBridgeEnvelope");
+		expect(records.some((record) => record.canonical)).toBe(true);
+		expect(records.some((record) => !record.canonical)).toBe(true);
+	});
+
+	it.each(
+		vectors(envelopeFixtureUrl, "WireBridgeEnvelope").filter((record) => record.canonical),
+	)("decodes, validates, and re-encodes $id byte-for-byte", (record) => {
+		const bytes = fromHex(record.hex);
+		const decoded = decodeCanonicalWireBridgeEnvelope(bytes);
+		const encoded = encodeCanonicalWireBridgeEnvelope(decoded);
+
+		expect(toHex(encoded)).toBe(record.hex);
+		if (record.expect?.payload === "data.value") {
+			expect(decoded.payload.kind).toBe("data");
+			expect(decoded.payload.kind === "data" && decoded.payload.body.kind).toBe("value");
+		}
+		if (record.expect?.payload === "data.wire_edge.dirty") {
+			expect(decoded.payload.kind).toBe("data");
+			expect(decoded.payload.kind === "data" && decoded.payload.body.kind).toBe("wire_edge");
+			if (decoded.payload.kind === "data" && decoded.payload.body.kind === "wire_edge") {
+				expect(decoded.payload.body.frame.kind).toBe("dirty");
+			}
+		}
+		if (record.expect?.payload === "data.wire_edge.data") {
+			expect(decoded.payload.kind).toBe("data");
+			expect(decoded.payload.kind === "data" && decoded.payload.body.kind).toBe("wire_edge");
+			if (decoded.payload.kind !== "data" || decoded.payload.body.kind !== "wire_edge") return;
+			expect(decoded.payload.body.frame.kind).toBe("data");
+			expect(decoded.payload.body.frame.value).toBeInstanceOf(Uint8Array);
+		}
+	});
+
+	it.each(
+		vectors(envelopeFixtureUrl, "WireBridgeEnvelope").filter((record) => !record.canonical),
+	)("rejects $id as $errorCategory", (record) => {
+		try {
+			decodeCanonicalWireBridgeEnvelope(fromHex(record.hex));
+		} catch (error) {
+			expect(error).toBeInstanceOf(CanonicalProtobufError);
+			expect((error as CanonicalProtobufError).category).toBe(record.errorCategory);
+			return;
+		}
+		throw new Error(`${record.id} unexpectedly decoded`);
+	});
+});
+
+describe("D497 canonical protobuf wire-edge frame vectors", () => {
+	it("parses standalone WireEdgeFrame fixture records", () => {
+		const records = vectors(wireEdgeFixtureUrl, "WireEdgeFrame");
+		expect(records.some((record) => record.canonical)).toBe(true);
+		expect(records.some((record) => !record.canonical)).toBe(true);
+	});
+
+	it.each(
+		vectors(wireEdgeFixtureUrl, "WireEdgeFrame").filter((record) => record.canonical),
+	)("decodes, validates, and re-encodes $id byte-for-byte", (record) => {
+		const bytes = fromHex(record.hex);
+		const decoded = decodeCanonicalWireEdgeFrame(bytes);
+		const encoded = encodeCanonicalWireEdgeFrame(decoded);
+
+		expect(toHex(encoded)).toBe(record.hex);
+	});
+
+	it.each(
+		vectors(wireEdgeFixtureUrl, "WireEdgeFrame").filter((record) => !record.canonical),
+	)("rejects $id as $errorCategory", (record) => {
+		try {
+			decodeCanonicalWireEdgeFrame(fromHex(record.hex));
+		} catch (error) {
+			expect(error).toBeInstanceOf(CanonicalProtobufError);
+			expect((error as CanonicalProtobufError).category).toBe(record.errorCategory);
+			return;
+		}
+		throw new Error(`${record.id} unexpectedly decoded`);
+	});
+
+	it("rejects invalid TS DTOs before writing bytes", () => {
+		expect(() =>
+			encodeCanonicalWireBridgeEnvelope({
+				sessionId: "s1",
+				metadata: {
+					seq: -1n,
+					cursor: 0n,
+					idempotencyKey: "s1:1",
+					attempt: 1,
+					maxAttempts: 1,
+				},
+				payload: { kind: "start" },
+			}),
+		).toThrow(CanonicalProtobufError);
+		expect(() =>
+			encodeCanonicalWireBridgeEnvelope({
+				sessionId: "s1",
+				metadata: {
+					seq: 1n,
+					cursor: 0n,
+					idempotencyKey: "s1:1",
+					attempt: -1,
+					maxAttempts: 1,
+				},
+				payload: { kind: "start" },
+			}),
+		).toThrow(CanonicalProtobufError);
+		expect(() =>
+			encodeCanonicalWireBridgeEnvelope({
+				sessionId: "s1",
+				metadata: {
+					seq: 1n,
+					cursor: 0n,
+					idempotencyKey: "s1:1",
+					attempt: 1,
+					maxAttempts: 1,
+				},
+				payload: { kind: "bogus" } as never,
+			}),
+		).toThrow(CanonicalProtobufError);
+		expect(() =>
+			encodeCanonicalWireBridgeEnvelope({
+				sessionId: "s1",
+				metadata: {
+					seq: 1n,
+					cursor: 0n,
+					idempotencyKey: "s1:1",
+					attempt: 1,
+					maxAttempts: 1,
+					ackForSeq: 1n,
+				},
+				payload: { kind: "nack", error: new Uint8Array() },
+			}),
+		).toThrow(CanonicalProtobufError);
+		expect(() =>
+			encodeCanonicalWireBridgeEnvelope({
+				sessionId: "s1",
+				metadata: {
+					seq: 1n,
+					cursor: 0n,
+					idempotencyKey: "s1:1",
+					attempt: 1,
+					maxAttempts: 1,
+				},
+				payload: { kind: "status", status: new Uint8Array() },
+			}),
+		).toThrow(CanonicalProtobufError);
+		expect(() =>
+			encodeCanonicalWireBridgeEnvelope({
+				sessionId: "s1",
+				metadata: {
+					seq: 1n,
+					cursor: 0n,
+					idempotencyKey: "s1:1",
+					attempt: 1,
+					maxAttempts: 1,
+				},
+				payload: { kind: "error", error: new Uint8Array() },
+			}),
+		).toThrow(CanonicalProtobufError);
+		expect(() =>
+			encodeCanonicalWireBridgeEnvelope({
+				sessionId: "s1",
+				metadata: {
+					seq: 1n,
+					cursor: 0n,
+					idempotencyKey: "s1:1",
+					attempt: 1,
+					maxAttempts: 1,
+				},
+				payload: { kind: "close", reason: new Uint8Array() },
+			}),
+		).toThrow(CanonicalProtobufError);
+		expect(() =>
+			encodeCanonicalWireEdgeFrame({
+				kind: "bogus" as never,
+				edgeId: "edge-a",
+				causeId: "cause-1",
+			}),
+		).toThrow(CanonicalProtobufError);
+		expect(() =>
+			encodeCanonicalWireBridgeEnvelope({
+				sessionId: "s1",
+				metadata: {
+					seq: 1n,
+					cursor: 0n,
+					idempotencyKey: "s1:1",
+					attempt: 1,
+					maxAttempts: 1,
+					ackForSeq: 1n,
+				},
+				payload: { kind: "nack", error: new Uint8Array() },
+			}),
+		).toThrow(CanonicalProtobufError);
+	});
+});
+
+describe("D498 wireBridgeProtobuf focused helper", () => {
+	it("decodes canonical inbound bytes into the existing semantic wireBridge inbound fact lane", () => {
+		const g = graph();
+		const bridge = wireBridge<WireBridgeProtobufData, WireBridgeProtobufData>(g, {
+			name: "bridge",
+			sessionId: "s1",
+		});
+		const protobuf = wireBridgeProtobuf(g, bridge, { name: "bridge/protobuf" });
+		const inbound: unknown[] = [];
+		const issues: unknown[] = [];
+		const status: unknown[] = [];
+		bridge.inbound.subscribe((msg) => inbound.push(msg));
+		protobuf.issues.subscribe((msg) => issues.push(msg));
+		protobuf.status.subscribe((msg) => status.push(msg));
+
+		protobuf.inboundBytes.down([["DATA", canonicalInboundBytes()]]);
+
+		expect(dataMessages(issues)).toEqual([]);
+		expect(dataMessages(inbound)).toContainEqual([
+			"DATA",
+			expect.objectContaining({
+				sessionId: "s1",
+				type: "data",
+				payload: { kind: "data", value: { kind: "value", value: new Uint8Array() } },
+			}),
+		]);
+		expect(dataMessages(status).at(-1)).toEqual([
+			"DATA",
+			{ decoded: 1, encoded: 0, issues: 0, state: "active" },
+		]);
+	});
+
+	it("emits one status fact for each protobuf observation in a multi-DATA wave", () => {
+		const g = graph();
+		const bridge = wireBridge<WireBridgeProtobufData, WireBridgeProtobufData>(g, {
+			name: "bridge",
+			sessionId: "s1",
+		});
+		const protobuf = wireBridgeProtobuf(g, bridge, { name: "bridge/protobuf" });
+		const status: unknown[] = [];
+		protobuf.status.subscribe((msg) => status.push(msg));
+
+		protobuf.inboundBytes.down([
+			["DATA", canonicalInboundBytes()],
+			["DATA", malformedInboundBytes()],
+		]);
+
+		expect(dataMessages(status)).toEqual([
+			["DATA", { decoded: 1, encoded: 0, issues: 0, state: "active" }],
+			[
+				"DATA",
+				{
+					decoded: 1,
+					encoded: 0,
+					issues: 1,
+					state: "issues",
+					lastIssue: expect.objectContaining({
+						direction: "inbound",
+						operation: "decode",
+						category: "unknown_field",
+					}),
+				},
+			],
+		]);
+	});
+
+	it("does not fabricate protobuf status facts for semantic bridge-only inbound activity", () => {
+		const g = graph();
+		const bridge = wireBridge<WireBridgeProtobufData, WireBridgeProtobufData>(g, {
+			name: "bridge",
+			sessionId: "s1",
+		});
+		const protobuf = wireBridgeProtobuf(g, bridge, { name: "bridge/protobuf" });
+		const status: unknown[] = [];
+		protobuf.status.subscribe((msg) => status.push(msg));
+
+		bridge.inbound.down([
+			[
+				"DATA",
+				wireBridgeEnvelope<WireBridgeProtobufData>({
+					sessionId: "s1",
+					type: "data",
+					seq: 1,
+					payload: { kind: "data", value: { kind: "value", value: new Uint8Array([1]) } },
+				}),
+			],
+		]);
+
+		expect(dataMessages(status)).toEqual([]);
+	});
+
+	it("turns malformed inbound bytes into issue and invalid facts, not protocol terminals", () => {
+		const g = graph();
+		const bridge = wireBridge<WireBridgeProtobufData, WireBridgeProtobufData>(g, {
+			name: "bridge",
+			sessionId: "s1",
+		});
+		const protobuf = wireBridgeProtobuf(g, bridge, { name: "bridge/protobuf" });
+		const bridgeErrors: unknown[] = [];
+		const bridgeEvents: unknown[] = [];
+		const issues: unknown[] = [];
+		const status: unknown[] = [];
+		bridge.errors.subscribe((msg) => bridgeErrors.push(msg));
+		bridge.events.subscribe((msg) => bridgeEvents.push(msg));
+		protobuf.issues.subscribe((msg) => issues.push(msg));
+		protobuf.status.subscribe((msg) => status.push(msg));
+
+		protobuf.inboundBytes.down([["DATA", malformedInboundBytes()]]);
+
+		expect(dataMessages(issues)).toContainEqual([
+			"DATA",
+			expect.objectContaining({
+				direction: "inbound",
+				operation: "decode",
+				category: "unknown_field",
+			}),
+		]);
+		expect(dataMessages(status).at(-1)).toEqual([
+			"DATA",
+			{
+				decoded: 0,
+				encoded: 0,
+				issues: 1,
+				state: "issues",
+				lastIssue: expect.objectContaining({
+					direction: "inbound",
+					operation: "decode",
+					category: "unknown_field",
+				}),
+			},
+		]);
+		expect(dataMessages(bridgeErrors)).toContainEqual([
+			"DATA",
+			expect.stringContaining("WireBridgeDataPayload contains unknown field 10"),
+		]);
+		expect(bridgeEvents).not.toContainEqual(["ERROR", expect.anything()]);
+		expect(bridgeEvents).not.toContainEqual(["COMPLETE"]);
+		expect(issues).not.toContainEqual(["ERROR", expect.anything()]);
+		expect(issues).not.toContainEqual(["COMPLETE"]);
+		expect(status).not.toContainEqual(["ERROR", expect.anything()]);
+		expect(status).not.toContainEqual(["COMPLETE"]);
+	});
+
+	it("keeps malformed inbound issue fanout when bridge inbound subscribes before protobuf side facts", () => {
+		const g = graph();
+		const bridge = wireBridge<WireBridgeProtobufData, WireBridgeProtobufData>(g, {
+			name: "bridge",
+			sessionId: "s1",
+		});
+		const protobuf = wireBridgeProtobuf(g, bridge, { name: "bridge/protobuf" });
+		const inbound: unknown[] = [];
+		const issues: unknown[] = [];
+		const status: unknown[] = [];
+		bridge.inbound.subscribe((msg) => inbound.push(msg));
+		protobuf.issues.subscribe((msg) => issues.push(msg));
+		protobuf.status.subscribe((msg) => status.push(msg));
+
+		protobuf.inboundBytes.down([["DATA", malformedInboundBytes()]]);
+
+		expect(dataMessages(inbound)).toContainEqual([
+			"DATA",
+			expect.objectContaining({ __wireBridgeInvalidIngress: true }),
+		]);
+		expect(dataMessages(issues)).toContainEqual([
+			"DATA",
+			expect.objectContaining({ direction: "inbound", operation: "decode" }),
+		]);
+		expect(dataMessages(status).at(-1)).toEqual([
+			"DATA",
+			expect.objectContaining({ issues: 1, state: "issues" }),
+		]);
+	});
+
+	it("keeps malformed inbound issue fanout when protobuf side facts subscribe before bridge inbound", () => {
+		const g = graph();
+		const bridge = wireBridge<WireBridgeProtobufData, WireBridgeProtobufData>(g, {
+			name: "bridge",
+			sessionId: "s1",
+		});
+		const protobuf = wireBridgeProtobuf(g, bridge, { name: "bridge/protobuf" });
+		const inbound: unknown[] = [];
+		const issues: unknown[] = [];
+		const status: unknown[] = [];
+		protobuf.issues.subscribe((msg) => issues.push(msg));
+		protobuf.status.subscribe((msg) => status.push(msg));
+		bridge.inbound.subscribe((msg) => inbound.push(msg));
+
+		protobuf.inboundBytes.down([["DATA", malformedInboundBytes()]]);
+
+		expect(dataMessages(inbound)).toContainEqual([
+			"DATA",
+			expect.objectContaining({ __wireBridgeInvalidIngress: true }),
+		]);
+		expect(dataMessages(issues)).toContainEqual([
+			"DATA",
+			expect.objectContaining({ direction: "inbound", operation: "decode" }),
+		]);
+		expect(dataMessages(status).at(-1)).toEqual([
+			"DATA",
+			expect.objectContaining({ issues: 1, state: "issues" }),
+		]);
+	});
+
+	it("lets protobuf issues/status alone activate malformed inbound decoding", () => {
+		const g = graph();
+		const bridge = wireBridge<WireBridgeProtobufData, WireBridgeProtobufData>(g, {
+			name: "bridge",
+			sessionId: "s1",
+		});
+		const protobuf = wireBridgeProtobuf(g, bridge, { name: "bridge/protobuf" });
+		const issues: unknown[] = [];
+		const status: unknown[] = [];
+		protobuf.issues.subscribe((msg) => issues.push(msg));
+		protobuf.status.subscribe((msg) => status.push(msg));
+
+		protobuf.inboundBytes.down([["DATA", malformedInboundBytes()]]);
+
+		expect(dataMessages(issues)).toContainEqual([
+			"DATA",
+			expect.objectContaining({ direction: "inbound", operation: "decode" }),
+		]);
+		expect(dataMessages(status).at(-1)).toEqual([
+			"DATA",
+			expect.objectContaining({ issues: 1, state: "issues" }),
+		]);
+	});
+
+	it("encodes outbound semantic byte payloads and preserves valid empty DATA bytes", () => {
+		const g = graph();
+		const bridge = wireBridge<WireBridgeProtobufData, WireBridgeProtobufData>(g, {
+			name: "bridge",
+			sessionId: "s1",
+			now: () => 1,
+		});
+		const protobuf = wireBridgeProtobuf(g, bridge, { name: "bridge/protobuf" });
+		const outboundBytes: unknown[] = [];
+		const issues: unknown[] = [];
+		protobuf.outboundBytes.subscribe((msg) => outboundBytes.push(msg));
+		protobuf.issues.subscribe((msg) => issues.push(msg));
+
+		bridge.send(new Uint8Array(), { requestId: "req-empty" });
+
+		expect(dataMessages(issues)).toEqual([]);
+		const bytes = dataMessages(outboundBytes).at(-1)?.[1] as Uint8Array;
+		const decoded = decodeCanonicalWireBridgeEnvelope(bytes);
+		expect(decoded.payload.kind).toBe("data");
+		if (decoded.payload.kind !== "data") return;
+		expect(decoded.payload.body).toEqual({ kind: "value", value: new Uint8Array() });
+		expect(toHex(encodeCanonicalWireBridgeEnvelope(decoded))).toBe(toHex(bytes));
+	});
+
+	it("encodes outbound wire-edge DTOs without introducing a WireEdgeGroup runtime", () => {
+		const g = graph();
+		const bridge = wireBridge<WireBridgeProtobufData, WireBridgeProtobufData>(g, {
+			name: "bridge",
+			sessionId: "s1",
+			now: () => 1,
+		});
+		const protobuf = wireBridgeProtobuf(g, bridge, { name: "bridge/protobuf" });
+		const outboundBytes: unknown[] = [];
+		protobuf.outboundBytes.subscribe((msg) => outboundBytes.push(msg));
+
+		bridge.send({
+			kind: "wire_edge",
+			frame: { kind: "data", edgeId: "edge-a", causeId: "cause-1", value: new Uint8Array() },
+		});
+
+		const decoded = decodeCanonicalWireBridgeEnvelope(
+			dataMessages(outboundBytes).at(-1)?.[1] as Uint8Array,
+		);
+		expect(decoded.payload.kind).toBe("data");
+		if (decoded.payload.kind !== "data") return;
+		expect(decoded.payload.body).toEqual({
+			kind: "wire_edge",
+			frame: {
+				kind: "data",
+				edgeId: "edge-a",
+				causeId: "cause-1",
+				value: new Uint8Array(),
+			},
+		});
+		expect(g.describe().nodes.map((node) => node.factory)).not.toContain("WireEdgeGroup");
+	});
+
+	it("reports outbound encode issues for non-canonical semantic payloads", () => {
+		const g = graph();
+		const bridge = wireBridge<WireBridgeProtobufData, WireBridgeProtobufData>(g, {
+			name: "bridge",
+			sessionId: "s1",
+		});
+		const protobuf = wireBridgeProtobuf(g, bridge, { name: "bridge/protobuf" });
+		const outboundBytes: unknown[] = [];
+		const issues: unknown[] = [];
+		const status: unknown[] = [];
+		protobuf.outboundBytes.subscribe((msg) => outboundBytes.push(msg));
+		protobuf.issues.subscribe((msg) => issues.push(msg));
+		protobuf.status.subscribe((msg) => status.push(msg));
+
+		bridge.send({ unsafe: true } as never);
+
+		expect(dataMessages(outboundBytes)).toEqual([]);
+		expect(dataMessages(issues)).toContainEqual([
+			"DATA",
+			expect.objectContaining({
+				direction: "outbound",
+				operation: "encode",
+				category: "malformed",
+			}),
+		]);
+		expect(dataMessages(status).at(-1)).toEqual([
+			"DATA",
+			{
+				decoded: 0,
+				encoded: 0,
+				issues: 1,
+				state: "issues",
+				lastIssue: expect.objectContaining({
+					direction: "outbound",
+					operation: "encode",
+					category: "malformed",
+				}),
+			},
+		]);
+	});
+
+	it("keeps helper describe shape focused beside bridge core nodes", () => {
+		const g = graph();
+		const bridge = wireBridge<WireBridgeProtobufData, WireBridgeProtobufData>(g, {
+			name: "bridge",
+			sessionId: "s1",
+		});
+		wireBridgeProtobuf(g, bridge, { name: "bridge/protobuf" });
+
+		const snap = g.describe();
+		expect(snap.nodes).toContainEqual(
+			expect.objectContaining({
+				id: "bridge/protobuf/inboundBytes",
+				factory: "wireBridgeProtobufInboundBytes",
+			}),
+		);
+		expect(snap.nodes).toContainEqual(
+			expect.objectContaining({ id: "bridge/inbound", factory: "wireBridgeInbound" }),
+		);
+		expect(snap.edges).toContainEqual({
+			from: "bridge/protobuf/inboundDecoded",
+			to: "bridge/inbound",
+		});
+		expect(snap.edges).toContainEqual({
+			from: "bridge/protobuf/inboundBytes",
+			to: "bridge/protobuf/inboundResults",
+		});
+		expect(snap.edges).toContainEqual({
+			from: "bridge/protobuf/inboundResults",
+			to: "bridge/protobuf/inboundEvents",
+		});
+		expect(snap.edges).toContainEqual({
+			from: "bridge/protobuf/inboundEvents",
+			to: "bridge/protobuf/issues",
+		});
+		expect(snap.edges).toContainEqual({
+			from: "bridge/protobuf/inboundEvents",
+			to: "bridge/protobuf/status",
+		});
+		expect(snap.edges).toContainEqual({
+			from: "bridge/outbound",
+			to: "bridge/protobuf/outboundResults",
+		});
+		expect(snap.edges).toContainEqual({
+			from: "bridge/protobuf/outboundResults",
+			to: "bridge/protobuf/outboundEvents",
+		});
+		expect(snap.edges).toContainEqual({
+			from: "bridge/protobuf/outboundEvents",
+			to: "bridge/protobuf/outboundBytes",
+		});
+		expect(snap.nodes.filter((node) => node.factory === "wireBridgeEvents")).toHaveLength(1);
+	});
+
+	it("describe explain shows protobuf issue/status causal paths through result and event lanes", () => {
+		const g = graph();
+		const bridge = wireBridge<WireBridgeProtobufData, WireBridgeProtobufData>(g, {
+			name: "bridge",
+			sessionId: "s1",
+		});
+		wireBridgeProtobuf(g, bridge, { name: "bridge/protobuf" });
+
+		const issuePath = g.describe({
+			explain: { from: "bridge/protobuf/inboundBytes", to: "bridge/protobuf/issues" },
+		});
+		expect(issuePath.nodes.map((node) => node.id)).toEqual(
+			expect.arrayContaining([
+				"bridge/protobuf/inboundBytes",
+				"bridge/protobuf/inboundEvents",
+				"bridge/protobuf/inboundResults",
+				"bridge/protobuf/issues",
+			]),
+		);
+		expect(issuePath.edges).toEqual(
+			expect.arrayContaining([
+				{ from: "bridge/protobuf/inboundBytes", to: "bridge/protobuf/inboundResults" },
+				{ from: "bridge/protobuf/inboundResults", to: "bridge/protobuf/inboundEvents" },
+				{ from: "bridge/protobuf/inboundEvents", to: "bridge/protobuf/issues" },
+			]),
+		);
+
+		const statusPath = g.describe({
+			explain: { from: "bridge/protobuf/inboundBytes", to: "bridge/protobuf/status" },
+		});
+		expect(statusPath.nodes.map((node) => node.id)).toEqual(
+			expect.arrayContaining([
+				"bridge/protobuf/inboundBytes",
+				"bridge/protobuf/inboundEvents",
+				"bridge/protobuf/inboundResults",
+				"bridge/protobuf/status",
+			]),
+		);
+		expect(statusPath.edges).toEqual(
+			expect.arrayContaining([
+				{ from: "bridge/protobuf/inboundBytes", to: "bridge/protobuf/inboundResults" },
+				{ from: "bridge/protobuf/inboundResults", to: "bridge/protobuf/inboundEvents" },
+				{ from: "bridge/protobuf/inboundEvents", to: "bridge/protobuf/status" },
+			]),
+		);
+
+		const outboundIssuePath = g.describe({
+			explain: { from: "bridge/outbound", to: "bridge/protobuf/issues" },
+		});
+		expect(outboundIssuePath.edges).toEqual(
+			expect.arrayContaining([
+				{ from: "bridge/outbound", to: "bridge/protobuf/outboundResults" },
+				{ from: "bridge/protobuf/outboundResults", to: "bridge/protobuf/outboundEvents" },
+				{ from: "bridge/protobuf/outboundEvents", to: "bridge/protobuf/issues" },
+			]),
+		);
+
+		const outboundStatusPath = g.describe({
+			explain: { from: "bridge/outbound", to: "bridge/protobuf/status" },
+		});
+		expect(outboundStatusPath.edges).toEqual(
+			expect.arrayContaining([
+				{ from: "bridge/outbound", to: "bridge/protobuf/outboundResults" },
+				{ from: "bridge/protobuf/outboundResults", to: "bridge/protobuf/outboundEvents" },
+				{ from: "bridge/protobuf/outboundEvents", to: "bridge/protobuf/status" },
+			]),
+		);
+	});
+
+	it("release detaches protobuf ingress without disabling semantic bridge ingress", () => {
+		const g = graph();
+		const bridge = wireBridge<WireBridgeProtobufData, WireBridgeProtobufData>(g, {
+			name: "bridge",
+			sessionId: "s1",
+		});
+		const protobuf = wireBridgeProtobuf(g, bridge, { name: "bridge/protobuf" });
+		const inbound: unknown[] = [];
+		bridge.inbound.subscribe((msg) => inbound.push(msg));
+
+		protobuf.inboundBytes.down([["DATA", canonicalInboundBytes()]]);
+		expect(dataMessages(inbound)).toContainEqual([
+			"DATA",
+			expect.objectContaining({ sessionId: "s1", type: "data" }),
+		]);
+
+		protobuf.release();
+		expect(g.describe().edges).not.toContainEqual({
+			from: "bridge/protobuf/inboundDecoded",
+			to: "bridge/inbound",
+		});
+		expect(() => protobuf.inboundBytes.down([["DATA", canonicalInboundBytes()]])).toThrow(
+			/released/,
+		);
+
+		bridge.inbound.down([
+			[
+				"DATA",
+				wireBridgeEnvelope<WireBridgeProtobufData>({
+					sessionId: "s1",
+					type: "data",
+					seq: 42,
+					payload: { kind: "data", value: { kind: "value", value: new Uint8Array([1]) } },
+				}),
+			],
+		]);
+		expect(dataMessages(inbound)).toContainEqual([
+			"DATA",
+			expect.objectContaining({ metadata: expect.objectContaining({ seq: 42 }) }),
+		]);
+	});
+});
diff --git a/packages/ts/src/__tests__/wire-bridge.remote-dispatcher-helpers-over-wirebridge-facts-d147.test.ts b/packages/ts/src/__tests__/wire-bridge.remote-dispatcher-helpers-over-wirebridge-facts-d147.test.ts
new file mode 100644
index 00000000..a9c6925d
--- /dev/null
+++ b/packages/ts/src/__tests__/wire-bridge.remote-dispatcher-helpers-over-wirebridge-facts-d147.test.ts
@@ -0,0 +1,963 @@
+import { describe, expect, it } from "vitest";
+import {
+	remoteCall,
+	remoteResponder,
+	remoteResponderHandler,
+	wireBridge,
+	wireBridgeEnvelope,
+} from "../adapters/index.js";
+import { graph } from "../graph/graph.js";
+import { batch } from "../index.js";
+
+describe("remote dispatcher helpers over wireBridge facts (D147)", () => {
+	it("remoteCall emits request facts and projects later response/status/error facts", () => {
+		const g = graph();
+		const bridge = wireBridge<
+			{ operation: string; requestId: string; payload: string },
+			{
+				kind: "result" | "error" | "status";
+				operation: string;
+				requestId: string;
+				payload?: string;
+				error?: string;
+				status?: string;
+			}
+		>(g, { name: "bridge", sessionId: "session-a" });
+		const remote = remoteCall<string, string>(g, bridge, { name: "rpc" });
+		const outbound: unknown[] = [];
+		const results: unknown[] = [];
+		const status: unknown[] = [];
+		const errors: unknown[] = [];
+		bridge.outbound.subscribe((msg) => outbound.push(msg));
+		remote.results.subscribe((msg) => results.push(msg));
+		remote.status.subscribe((msg) => status.push(msg));
+		remote.errors.subscribe((msg) => errors.push(msg));
+
+		remote.call("upper", "req-1", "hello");
+		expect(outbound.at(-1)).toEqual([
+			"DATA",
+			expect.objectContaining({
+				type: "data",
+				payload: {
+					kind: "data",
+					value: { operation: "upper", requestId: "req-1", payload: "hello" },
+				},
+				metadata: expect.objectContaining({ requestId: "req-1" }),
+			}),
+		]);
+		expect(status.at(-1)).toEqual([
+			"DATA",
+			{
+				state: "requested",
+				operation: "upper",
+				requestId: "req-1",
+				pending: 1,
+				completed: 0,
+				errors: 0,
+				timeouts: 0,
+			},
+		]);
+
+		bridge.inbound.down([
+			[
+				"DATA",
+				wireBridgeEnvelope({
+					sessionId: "session-a",
+					type: "data",
+					seq: 1,
+					cursor: 1,
+					payload: {
+						kind: "data",
+						value: { kind: "result", operation: "upper", requestId: "req-1", payload: "HELLO" },
+					},
+					requestId: "req-1",
+				}),
+			],
+		]);
+
+		expect(results).toContainEqual([
+			"DATA",
+			{ operation: "upper", requestId: "req-1", payload: "HELLO" },
+		]);
+		expect(status.at(-1)).toEqual([
+			"DATA",
+			{
+				state: "responded",
+				operation: "upper",
+				requestId: "req-1",
+				pending: 0,
+				completed: 1,
+				errors: 0,
+				timeouts: 0,
+			},
+		]);
+
+		remote.timeout("req-timeout", "upper", "local timeout");
+		expect(errors).toContainEqual([
+			"DATA",
+			{ operation: "upper", requestId: "req-timeout", error: "local timeout" },
+		]);
+	});
+
+	it("remoteCall ignores unknown responses instead of buffering them for future calls", () => {
+		const g = graph();
+		const bridge = wireBridge<
+			{ operation: string; requestId: string; payload: string },
+			{
+				kind: "result";
+				operation: string;
+				requestId: string;
+				payload: string;
+			}
+		>(g, { name: "bridge", sessionId: "session-a" });
+		const remote = remoteCall<string, string>(g, bridge, { name: "rpc" });
+		const results: unknown[] = [];
+		const errors: unknown[] = [];
+		const status: unknown[] = [];
+		remote.results.subscribe((msg) => results.push(msg));
+		remote.errors.subscribe((msg) => errors.push(msg));
+		remote.status.subscribe((msg) => status.push(msg));
+
+		bridge.inbound.down([
+			[
+				"DATA",
+				wireBridgeEnvelope({
+					sessionId: "session-a",
+					type: "data",
+					seq: 1,
+					cursor: 0,
+					payload: {
+						kind: "data",
+						value: {
+							kind: "result",
+							operation: "upper",
+							requestId: "req-1",
+							payload: "STALE",
+						},
+					},
+					requestId: "req-1",
+				}),
+			],
+		]);
+		remote.call("upper", "req-1", "hello");
+
+		expect(results).not.toContainEqual(["DATA", expect.anything()]);
+		expect(errors).toContainEqual([
+			"DATA",
+			{
+				operation: "upper",
+				requestId: "req-1",
+				error: "remoteCall: orphan response for unknown or completed request",
+			},
+		]);
+		expect(status).toContainEqual([
+			"DATA",
+			expect.objectContaining({
+				state: "errored",
+				operation: "upper",
+				requestId: "req-1",
+				pending: 0,
+				errors: 1,
+			}),
+		]);
+
+		bridge.inbound.down([
+			[
+				"DATA",
+				wireBridgeEnvelope({
+					sessionId: "session-a",
+					type: "data",
+					seq: 2,
+					cursor: 1,
+					payload: {
+						kind: "data",
+						value: {
+							kind: "result",
+							operation: "upper",
+							requestId: "req-1",
+							payload: "HELLO",
+						},
+					},
+					requestId: "req-1",
+				}),
+			],
+		]);
+
+		expect(results).toContainEqual([
+			"DATA",
+			{ operation: "upper", requestId: "req-1", payload: "HELLO" },
+		]);
+	});
+
+	it("remoteCall ignores same-wave stale responses that precede a new outbound request", () => {
+		const g = graph();
+		const bridge = wireBridge<
+			{ operation: string; requestId: string; payload: string },
+			{
+				kind: "result";
+				operation: string;
+				requestId: string;
+				payload: string;
+			}
+		>(g, { name: "bridge", sessionId: "session-a" });
+		const remote = remoteCall<string, string>(g, bridge, { name: "rpc" });
+		const results: unknown[] = [];
+		const errors: unknown[] = [];
+		const status: unknown[] = [];
+		remote.results.subscribe((msg) => results.push(msg));
+		remote.errors.subscribe((msg) => errors.push(msg));
+		remote.status.subscribe((msg) => status.push(msg));
+
+		batch(() => {
+			bridge.inbound.down([
+				[
+					"DATA",
+					wireBridgeEnvelope({
+						sessionId: "session-a",
+						type: "data",
+						seq: 1,
+						cursor: 0,
+						payload: {
+							kind: "data",
+							value: {
+								kind: "result",
+								operation: "upper",
+								requestId: "req-1",
+								payload: "STALE",
+							},
+						},
+						requestId: "req-1",
+					}),
+				],
+			]);
+			remote.call("upper", "req-1", "hello");
+		});
+
+		expect(results).not.toContainEqual(["DATA", expect.anything()]);
+		expect(errors).toContainEqual([
+			"DATA",
+			{
+				operation: "upper",
+				requestId: "req-1",
+				error: "remoteCall: orphan response for unknown or completed request",
+			},
+		]);
+		expect(status).toContainEqual([
+			"DATA",
+			expect.objectContaining({
+				state: "errored",
+				operation: "upper",
+				requestId: "req-1",
+				pending: 0,
+				errors: 1,
+			}),
+		]);
+
+		bridge.inbound.down([
+			[
+				"DATA",
+				wireBridgeEnvelope({
+					sessionId: "session-a",
+					type: "data",
+					seq: 2,
+					cursor: 1,
+					payload: {
+						kind: "data",
+						value: {
+							kind: "result",
+							operation: "upper",
+							requestId: "req-1",
+							payload: "HELLO",
+						},
+					},
+					requestId: "req-1",
+				}),
+			],
+		]);
+
+		expect(results).toContainEqual([
+			"DATA",
+			{ operation: "upper", requestId: "req-1", payload: "HELLO" },
+		]);
+	});
+
+	it("remoteCall requires operation correlation and keeps status responses non-terminal", () => {
+		const g = graph();
+		const bridge = wireBridge<
+			{ operation: string; requestId: string; payload: string },
+			{
+				kind: "result" | "status";
+				operation: string;
+				requestId: string;
+				payload?: string;
+				status?: string;
+			}
+		>(g, { name: "bridge", sessionId: "session-a" });
+		const remote = remoteCall<string, string>(g, bridge, { name: "rpc" });
+		const results: unknown[] = [];
+		const responses: unknown[] = [];
+		const errors: unknown[] = [];
+		const status: unknown[] = [];
+		remote.results.subscribe((msg) => results.push(msg));
+		remote.responses.subscribe((msg) => responses.push(msg));
+		remote.errors.subscribe((msg) => errors.push(msg));
+		remote.status.subscribe((msg) => status.push(msg));
+
+		remote.call("upper", "req-1", "hello");
+		bridge.inbound.down([
+			[
+				"DATA",
+				wireBridgeEnvelope({
+					sessionId: "session-a",
+					type: "data",
+					seq: 1,
+					cursor: 1,
+					payload: {
+						kind: "data",
+						value: {
+							kind: "result",
+							operation: "lower",
+							requestId: "req-1",
+							payload: "wrong",
+						},
+					},
+				}),
+			],
+		]);
+
+		expect(results).not.toContainEqual(["DATA", expect.anything()]);
+		expect(errors).toContainEqual([
+			"DATA",
+			{
+				operation: "upper",
+				requestId: "req-1",
+				error: "remoteCall: response operation 'lower' did not match pending operation 'upper'",
+			},
+		]);
+		expect(status).toContainEqual([
+			"DATA",
+			expect.objectContaining({
+				state: "errored",
+				operation: "upper",
+				requestId: "req-1",
+				pending: 1,
+				errors: 1,
+			}),
+		]);
+
+		bridge.inbound.down([
+			[
+				"DATA",
+				wireBridgeEnvelope({
+					sessionId: "session-a",
+					type: "data",
+					seq: 2,
+					cursor: 1,
+					payload: {
+						kind: "data",
+						value: {
+							kind: "status",
+							operation: "upper",
+							requestId: "req-1",
+							status: "working",
+						},
+					},
+				}),
+			],
+		]);
+
+		expect(responses).toContainEqual([
+			"DATA",
+			{ kind: "status", operation: "upper", requestId: "req-1", status: "working" },
+		]);
+		expect(status.at(-1)).toEqual([
+			"DATA",
+			{
+				state: "requested",
+				operation: "upper",
+				requestId: "req-1",
+				pending: 1,
+				completed: 0,
+				errors: 1,
+				timeouts: 0,
+			},
+		]);
+
+		bridge.inbound.down([
+			[
+				"DATA",
+				wireBridgeEnvelope({
+					sessionId: "session-a",
+					type: "data",
+					seq: 3,
+					cursor: 1,
+					payload: {
+						kind: "data",
+						value: {
+							kind: "result",
+							operation: "upper",
+							requestId: "req-1",
+							payload: "HELLO",
+						},
+					},
+				}),
+			],
+		]);
+
+		expect(results).toContainEqual([
+			"DATA",
+			{ operation: "upper", requestId: "req-1", payload: "HELLO" },
+		]);
+	});
+
+	it("remoteCall rejects duplicate in-flight request ids instead of replacing pending state", () => {
+		const g = graph();
+		const bridge = wireBridge<
+			{ operation: string; requestId: string; payload: string },
+			{ kind: "result"; operation: string; requestId: string; payload: string }
+		>(g, { name: "bridge", sessionId: "session-a" });
+		const remote = remoteCall<string, string>(g, bridge, { name: "rpc" });
+		const results: unknown[] = [];
+		const errors: unknown[] = [];
+		remote.results.subscribe((msg) => results.push(msg));
+		remote.errors.subscribe((msg) => errors.push(msg));
+
+		remote.call("upper", "req-1", "first");
+		remote.call("upper", "req-1", "second");
+
+		expect(errors).toContainEqual([
+			"DATA",
+			{
+				operation: "upper",
+				requestId: "req-1",
+				error: "remoteCall: duplicate in-flight requestId 'req-1'",
+			},
+		]);
+
+		bridge.inbound.down([
+			[
+				"DATA",
+				wireBridgeEnvelope({
+					sessionId: "session-a",
+					type: "data",
+					seq: 1,
+					cursor: 1,
+					payload: {
+						kind: "data",
+						value: {
+							kind: "result",
+							operation: "upper",
+							requestId: "req-1",
+							payload: "FIRST",
+						},
+					},
+				}),
+			],
+		]);
+
+		expect(results).toContainEqual([
+			"DATA",
+			{ operation: "upper", requestId: "req-1", payload: "FIRST" },
+		]);
+
+		bridge.inbound.down([
+			[
+				"DATA",
+				wireBridgeEnvelope({
+					sessionId: "session-a",
+					type: "data",
+					seq: 2,
+					cursor: 2,
+					payload: {
+						kind: "data",
+						value: {
+							kind: "result",
+							operation: "upper",
+							requestId: "req-1",
+							payload: "SECOND",
+						},
+					},
+				}),
+			],
+		]);
+
+		expect(results).not.toContainEqual([
+			"DATA",
+			{ operation: "upper", requestId: "req-1", payload: "SECOND" },
+		]);
+	});
+
+	it("remoteCall duplicate request NACK does not clear the original pending request", () => {
+		const g = graph();
+		const bridge = wireBridge<
+			{ operation: string; requestId: string; payload: string },
+			{ kind: "result"; operation: string; requestId: string; payload: string }
+		>(g, { name: "bridge", sessionId: "session-a" });
+		const remote = remoteCall<string, string>(g, bridge, { name: "rpc" });
+		const results: unknown[] = [];
+		const errors: unknown[] = [];
+		remote.results.subscribe((msg) => results.push(msg));
+		remote.errors.subscribe((msg) => errors.push(msg));
+
+		remote.call("upper", "req-1", "first");
+		remote.call("upper", "req-1", "second");
+
+		bridge.inbound.down([
+			[
+				"DATA",
+				wireBridgeEnvelope({
+					sessionId: "session-a",
+					type: "nack",
+					seq: 1,
+					cursor: 2,
+					ackForSeq: 2,
+					payload: { kind: "error", error: { message: "duplicate rejected remotely" } },
+					requestId: "req-1",
+				}),
+			],
+		]);
+
+		expect(errors).toContainEqual([
+			"DATA",
+			{
+				operation: "upper",
+				requestId: "req-1",
+				error: "remoteCall: duplicate in-flight requestId 'req-1'",
+			},
+		]);
+
+		bridge.inbound.down([
+			[
+				"DATA",
+				wireBridgeEnvelope({
+					sessionId: "session-a",
+					type: "data",
+					seq: 2,
+					cursor: 2,
+					payload: {
+						kind: "data",
+						value: {
+							kind: "result",
+							operation: "upper",
+							requestId: "req-1",
+							payload: "FIRST",
+						},
+					},
+					requestId: "req-1",
+				}),
+			],
+		]);
+
+		expect(results).toContainEqual([
+			"DATA",
+			{ operation: "upper", requestId: "req-1", payload: "FIRST" },
+		]);
+	});
+
+	it("remoteResponder dispatches sync handlers through bridge command facts", () => {
+		const g = graph();
+		const bridge = wireBridge<
+			{
+				kind: "result" | "error" | "status";
+				operation: string;
+				requestId: string;
+				payload?: string;
+				error?: string;
+				status?: string;
+			},
+			{ operation: string; requestId: string; payload: string }
+		>(g, { name: "bridge", sessionId: "session-a" });
+		const responder = remoteResponder<string, string>(g, bridge, {
+			name: "responder",
+			handlers: [remoteResponderHandler("upper", (request) => request.payload.toUpperCase())],
+			rejectUnknown: true,
+		});
+		const outbound: unknown[] = [];
+		const responseCommands: unknown[] = [];
+		const requests: unknown[] = [];
+		bridge.outbound.subscribe((msg) => outbound.push(msg));
+		responder.responseCommands.subscribe((msg) => responseCommands.push(msg));
+		responder.requests.subscribe((msg) => requests.push(msg));
+
+		bridge.inbound.down([
+			[
+				"DATA",
+				wireBridgeEnvelope({
+					sessionId: "session-a",
+					type: "data",
+					seq: 1,
+					cursor: 0,
+					payload: {
+						kind: "data",
+						value: { operation: "upper", requestId: "req-1", payload: "hello" },
+					},
+					requestId: "req-1",
+				}),
+			],
+		]);
+
+		expect(requests).toContainEqual([
+			"DATA",
+			{ operation: "upper", requestId: "req-1", payload: "hello" },
+		]);
+		expect(responseCommands).toContainEqual([
+			"DATA",
+			{
+				kind: "send",
+				payload: { kind: "result", operation: "upper", requestId: "req-1", payload: "HELLO" },
+				requestId: "req-1",
+			},
+		]);
+		expect(outbound).toContainEqual([
+			"DATA",
+			expect.objectContaining({
+				type: "data",
+				payload: {
+					kind: "data",
+					value: { kind: "result", operation: "upper", requestId: "req-1", payload: "HELLO" },
+				},
+				metadata: expect.objectContaining({ requestId: "req-1" }),
+			}),
+		]);
+
+		const snap = g.describe();
+		expect(snap.edges).toContainEqual({ from: "bridge/inbound", to: "responder/events" });
+		expect(snap.edges).toContainEqual({
+			from: "responder/responseCommands",
+			to: "bridge/command",
+		});
+		expect(snap.edges).toContainEqual({ from: "bridge/command", to: "bridge/events" });
+	});
+
+	it("remoteResponder release detaches responseCommands from a long-lived bridge", () => {
+		const g = graph();
+		const bridge = wireBridge<
+			{ kind: "result" | "error"; operation: string; requestId: string; payload?: string },
+			{ operation: string; requestId: string; payload: string }
+		>(g, { name: "bridge", sessionId: "session-a" });
+		const responder = remoteResponder<string, string>(g, bridge, {
+			name: "responder",
+			handlers: [remoteResponderHandler("upper", (request) => request.payload.toUpperCase())],
+		});
+		const outbound: unknown[] = [];
+		bridge.outbound.subscribe((msg) => outbound.push(msg));
+		expect(g.describe().edges).toContainEqual({
+			from: "responder/responseCommands",
+			to: "bridge/command",
+		});
+
+		responder.release();
+		responder.release();
+		expect(g.find("responder/responseCommands")).toBeUndefined();
+		expect(g.describe().edges).not.toContainEqual({
+			from: "responder/responseCommands",
+			to: "bridge/command",
+		});
+		bridge.inbound.down([
+			[
+				"DATA",
+				wireBridgeEnvelope({
+					sessionId: "session-a",
+					type: "data",
+					seq: 1,
+					cursor: 0,
+					payload: {
+						kind: "data",
+						value: { operation: "upper", requestId: "req-1", payload: "hello" },
+					},
+					requestId: "req-1",
+				}),
+			],
+		]);
+		expect(outbound.filter((msg) => Array.isArray(msg) && msg[0] === "DATA")).toEqual([]);
+	});
+
+	it("remoteResponder release is retryable when external subscribers block topology release", () => {
+		const g = graph();
+		const bridge = wireBridge<
+			{ kind: "result" | "error"; operation: string; requestId: string; payload?: string },
+			{ operation: string; requestId: string; payload: string }
+		>(g, { name: "bridge", sessionId: "session-a" });
+		const responder = remoteResponder<string, string>(g, bridge, {
+			name: "responder",
+			handlers: [remoteResponderHandler("upper", (request) => request.payload.toUpperCase())],
+		});
+		const outbound: unknown[] = [];
+		const unsub = responder.status.subscribe(() => {});
+		bridge.outbound.subscribe((msg) => outbound.push(msg));
+
+		expect(() => responder.release()).toThrow(/live subscribers/);
+		expect(g.describe().edges).toContainEqual({
+			from: "responder/responseCommands",
+			to: "bridge/command",
+		});
+		bridge.inbound.down([
+			[
+				"DATA",
+				wireBridgeEnvelope({
+					sessionId: "session-a",
+					type: "data",
+					seq: 1,
+					cursor: 0,
+					payload: {
+						kind: "data",
+						value: { operation: "upper", requestId: "req-1", payload: "hello" },
+					},
+					requestId: "req-1",
+				}),
+			],
+		]);
+		expect(outbound.filter((msg) => Array.isArray(msg) && msg[0] === "DATA")).toHaveLength(1);
+
+		unsub();
+		responder.release();
+		expect(g.find("responder/status")).toBeUndefined();
+	});
+
+	it("remoteResponder rejects wrong-session inbound requests before handler dispatch", () => {
+		const g = graph();
+		const bridge = wireBridge<
+			{ kind: "result" | "error"; operation: string; requestId: string; payload?: string },
+			{ operation: string; requestId: string; payload: string }
+		>(g, { name: "bridge", sessionId: "session-a" });
+		const handled: string[] = [];
+		const responder = remoteResponder<string, string>(g, bridge, {
+			name: "responder",
+			handlers: [
+				remoteResponderHandler("upper", (request) => {
+					handled.push(request.requestId);
+					return request.payload.toUpperCase();
+				}),
+			],
+		});
+		const errors: unknown[] = [];
+		const outbound: unknown[] = [];
+		responder.errors.subscribe((msg) => errors.push(msg));
+		bridge.outbound.subscribe((msg) => outbound.push(msg));
+
+		bridge.inbound.down([
+			[
+				"DATA",
+				wireBridgeEnvelope({
+					sessionId: "wrong-session",
+					type: "data",
+					seq: 1,
+					cursor: 0,
+					payload: {
+						kind: "data",
+						value: { operation: "upper", requestId: "req-1", payload: "hello" },
+					},
+				}),
+			],
+		]);
+
+		expect(handled).toEqual([]);
+		expect(outbound).not.toContainEqual(["DATA", expect.anything()]);
+		expect(errors).toContainEqual([
+			"DATA",
+			{
+				error: "remoteResponder: inbound session wrong-session did not match expected session-a",
+			},
+		]);
+	});
+
+	it("remoteCall surfaces malformed response payloads as visible errors", () => {
+		const g = graph();
+		const bridge = wireBridge<{ operation: string; requestId: string; payload: string }, unknown>(
+			g,
+			{ name: "bridge", sessionId: "session-a" },
+		);
+		const remote = remoteCall<string, string>(g, bridge, { name: "rpc" });
+		const errors: unknown[] = [];
+		const results: unknown[] = [];
+		const status: unknown[] = [];
+		remote.errors.subscribe((msg) => errors.push(msg));
+		remote.results.subscribe((msg) => results.push(msg));
+		remote.status.subscribe((msg) => status.push(msg));
+
+		remote.call("upper", "req-1", "hello");
+		bridge.inbound.down([
+			[
+				"DATA",
+				wireBridgeEnvelope({
+					sessionId: "session-a",
+					type: "data",
+					seq: 1,
+					cursor: 1,
+					payload: {
+						kind: "data",
+						value: { kind: "result", operation: "upper", requestId: "req-1" },
+					},
+				}),
+			],
+		]);
+
+		expect(results).not.toContainEqual(["DATA", expect.anything()]);
+		expect(errors).toContainEqual([
+			"DATA",
+			{
+				operation: "upper",
+				requestId: "req-1",
+				error: "remoteCall: response payload is malformed",
+			},
+		]);
+		expect(status).toContainEqual([
+			"DATA",
+			{
+				state: "errored",
+				operation: "upper",
+				requestId: "req-1",
+				pending: 0,
+				completed: 0,
+				errors: 1,
+				timeouts: 0,
+			},
+		]);
+	});
+
+	it("remoteCall surfaces malformed responses for unknown request ids without buffering", () => {
+		const g = graph();
+		const bridge = wireBridge<{ operation: string; requestId: string; payload: string }, unknown>(
+			g,
+			{ name: "bridge", sessionId: "session-a" },
+		);
+		const remote = remoteCall<string, string>(g, bridge, { name: "rpc" });
+		const errors: unknown[] = [];
+		const status: unknown[] = [];
+		remote.errors.subscribe((msg) => errors.push(msg));
+		remote.status.subscribe((msg) => status.push(msg));
+
+		bridge.inbound.down([
+			[
+				"DATA",
+				wireBridgeEnvelope({
+					sessionId: "session-a",
+					type: "data",
+					seq: 1,
+					cursor: 0,
+					payload: {
+						kind: "data",
+						value: { kind: "result", operation: "upper", requestId: "req-unknown" },
+					},
+				}),
+			],
+		]);
+
+		expect(errors).toContainEqual([
+			"DATA",
+			{
+				operation: "upper",
+				requestId: "req-unknown",
+				error: "remoteCall: response payload is malformed",
+			},
+		]);
+		expect(status).toContainEqual([
+			"DATA",
+			expect.objectContaining({
+				state: "errored",
+				operation: "upper",
+				requestId: "req-unknown",
+				pending: 0,
+				errors: 1,
+			}),
+		]);
+	});
+
+	it("remoteResponder rejects malformed request payloads before handler dispatch", () => {
+		const g = graph();
+		const bridge = wireBridge<
+			{ kind: "result" | "error"; operation: string; requestId: string; payload?: string },
+			unknown
+		>(g, { name: "bridge", sessionId: "session-a" });
+		const handled: string[] = [];
+		const responder = remoteResponder<string, string>(g, bridge, {
+			name: "responder",
+			handlers: [
+				remoteResponderHandler("upper", (request) => {
+					handled.push(request.requestId);
+					return request.payload.toUpperCase();
+				}),
+			],
+		});
+		const errors: unknown[] = [];
+		responder.errors.subscribe((msg) => errors.push(msg));
+
+		bridge.inbound.down([
+			[
+				"DATA",
+				wireBridgeEnvelope({
+					sessionId: "session-a",
+					type: "data",
+					seq: 1,
+					cursor: 0,
+					payload: { kind: "data", value: { operation: "upper" } },
+				}),
+			],
+		]);
+
+		expect(handled).toEqual([]);
+		expect(errors).toContainEqual([
+			"DATA",
+			{ error: "remoteResponder: request payload is malformed" },
+		]);
+	});
+
+	it("remoteResponder rejects async handler results in the sync first slice", () => {
+		const g = graph();
+		const bridge = wireBridge<
+			{ kind: "result" | "error"; operation: string; requestId: string; payload?: string },
+			{ operation: string; requestId: string; payload: string }
+		>(g, { name: "bridge", sessionId: "session-a" });
+		const responder = remoteResponder<string, unknown>(g, bridge, {
+			name: "responder",
+			handlers: [
+				remoteResponderHandler("upper", (request) =>
+					Promise.resolve(request.payload.toUpperCase()),
+				),
+			],
+		});
+		const errors: unknown[] = [];
+		const outbound: unknown[] = [];
+		responder.errors.subscribe((msg) => errors.push(msg));
+		bridge.outbound.subscribe((msg) => outbound.push(msg));
+
+		bridge.inbound.down([
+			[
+				"DATA",
+				wireBridgeEnvelope({
+					sessionId: "session-a",
+					type: "data",
+					seq: 1,
+					cursor: 0,
+					payload: {
+						kind: "data",
+						value: { operation: "upper", requestId: "req-1", payload: "hello" },
+					},
+				}),
+			],
+		]);
+
+		expect(errors).toContainEqual([
+			"DATA",
+			{
+				operation: "upper",
+				requestId: "req-1",
+				error: "remoteResponder: async handler results require a later adapter shape",
+			},
+		]);
+		expect(outbound).toContainEqual([
+			"DATA",
+			expect.objectContaining({
+				payload: {
+					kind: "data",
+					value: {
+						kind: "error",
+						operation: "upper",
+						requestId: "req-1",
+						error: "remoteResponder: async handler results require a later adapter shape",
+					},
+				},
+			}),
+		]);
+	});
+});
diff --git a/packages/ts/src/__tests__/wire-bridge.wire-bridge-envelopes-d134.test.ts b/packages/ts/src/__tests__/wire-bridge.wire-bridge-envelopes-d134.test.ts
new file mode 100644
index 00000000..4dd61dfc
--- /dev/null
+++ b/packages/ts/src/__tests__/wire-bridge.wire-bridge-envelopes-d134.test.ts
@@ -0,0 +1,1430 @@
+import { describe, expect, it, vi } from "vitest";
+import {
+	wireBridge,
+	wireBridgeAckDriver,
+	wireBridgeEnvelope,
+	wireBridgeIdempotencyKey,
+	wireEdgeGroup,
+} from "../adapters/index.js";
+import { batch } from "../batch/batch.js";
+import { graph } from "../graph/graph.js";
+import { retryPolicy } from "../graph/resilience.js";
+
+describe("wire bridge envelopes (D134)", () => {
+	it("creates ordered, idempotent envelope metadata", () => {
+		expect(wireBridgeIdempotencyKey("session-a", 7)).toBe("session-a:7");
+		expect(
+			wireBridgeEnvelope({
+				sessionId: "session-a",
+				type: "data",
+				seq: 7,
+				cursor: 3,
+				payload: { kind: "data", value: { ok: true } },
+				attempt: 2,
+				maxAttempts: 4,
+				requestId: "req-1",
+			}),
+		).toEqual({
+			sessionId: "session-a",
+			type: "data",
+			payload: { kind: "data", value: { ok: true } },
+			metadata: {
+				seq: 7,
+				cursor: 3,
+				idempotencyKey: "session-a:7",
+				attempt: 2,
+				maxAttempts: 4,
+				timestampMs: undefined,
+				ackForSeq: undefined,
+				requestId: "req-1",
+			},
+		});
+		expect(() => wireBridgeEnvelope({ sessionId: "session-a", type: "data", seq: 0 })).toThrow(
+			/seq/,
+		);
+		expect(() => wireBridgeEnvelope({ sessionId: "session-a", type: "data", seq: 1 })).toThrow(
+			/data envelope requires data payload/,
+		);
+		expect(() =>
+			wireBridgeEnvelope({
+				sessionId: "session-a",
+				type: "error",
+				seq: 1,
+				payload: { kind: "data", value: "wrong" },
+			}),
+		).toThrow(/error envelope requires error payload/);
+		expect(() =>
+			wireBridgeEnvelope({
+				sessionId: "session-a",
+				type: "error",
+				seq: 1,
+				payload: { kind: "error" } as never,
+			}),
+		).toThrow(/error envelope requires error payload/);
+		expect(() =>
+			wireBridgeEnvelope({ sessionId: "session-a", type: "ack", seq: 1, ackForSeq: 0 }),
+		).toThrow(/ackForSeq/);
+		expect(() => wireBridgeEnvelope({ sessionId: "session-a", type: "ack", seq: 1 })).toThrow(
+			/requires ackForSeq/,
+		);
+		expect(() =>
+			wireBridgeEnvelope({ sessionId: "session-a", type: "unknown" as never, seq: 1 }),
+		).toThrow(/type/);
+		expect(() =>
+			wireBridgeEnvelope({
+				sessionId: "session-a",
+				type: "data",
+				seq: Number.MAX_SAFE_INTEGER + 1,
+			}),
+		).toThrow(/seq/);
+	});
+
+	it("enforces D559 wire-admissible payloads and copies mutable bytes", () => {
+		const bytes = new Uint8Array([1, 2, 3]);
+		const envelope = wireBridgeEnvelope({
+			sessionId: "session-a",
+			type: "data",
+			seq: 1,
+			payload: { kind: "data", value: bytes },
+		});
+		bytes[0] = 9;
+		expect(envelope.payload).toEqual({ kind: "data", value: new Uint8Array([1, 2, 3]) });
+		expect(
+			wireBridgeEnvelope({
+				sessionId: "session-a",
+				type: "data",
+				seq: 1,
+				payload: { kind: "data", value: { kind: "value", value: "plain-json" } },
+			}).payload,
+		).toEqual({ kind: "data", value: { kind: "value", value: "plain-json" } });
+
+		const sparse: unknown[] = [];
+		sparse[1] = "hole";
+		const accessor = {};
+		Object.defineProperty(accessor, "secret", { get: () => "nope", enumerable: true });
+		const hidden = { ok: true };
+		Object.defineProperty(hidden, "secret", { value: "nope", enumerable: false });
+		const thenable = {};
+		const thenKey = "th" + "en";
+		Object.defineProperty(thenable, thenKey, { value: () => undefined, enumerable: true });
+		const dirtyWithValue = {
+			kind: "dirty",
+			edgeId: "edge-a",
+			causeId: "cause-a",
+			value: new Uint8Array([1]),
+		};
+		const dataWithoutValue = { kind: "data", edgeId: "edge-a", causeId: "cause-a" };
+		const canonicalAccessor = {};
+		Object.defineProperty(canonicalAccessor, "kind", {
+			get: () => "dirty",
+			enumerable: true,
+		});
+		Object.defineProperty(canonicalAccessor, "edgeId", { value: "edge-a", enumerable: true });
+		Object.defineProperty(canonicalAccessor, "causeId", { value: "cause-a", enumerable: true });
+		class HostObject {
+			readonly ok = true;
+		}
+		const forbidden = [
+			undefined,
+			Number.NaN,
+			Number.POSITIVE_INFINITY,
+			-0,
+			Number.MIN_VALUE,
+			Number.MAX_SAFE_INTEGER + 1,
+			1n,
+			Symbol("x"),
+			() => undefined,
+			accessor,
+			new HostObject(),
+			new Date(),
+			new Map(),
+			Promise.resolve("x"),
+			thenable,
+			sparse,
+			hidden,
+			dirtyWithValue,
+			dataWithoutValue,
+			canonicalAccessor,
+		];
+
+		for (const value of forbidden) {
+			expect(() =>
+				wireBridgeEnvelope({
+					sessionId: "session-a",
+					type: "data",
+					seq: 1,
+					payload: { kind: "data", value },
+				}),
+			).toThrow(/wire-admissible payload|strict JSON|stableJsonString|invalid canonical wire DTO/);
+		}
+
+		expect(() =>
+			wireBridgeEnvelope({
+				sessionId: "session-a",
+				type: "data",
+				seq: 1,
+				payload: 1 as never,
+			}),
+		).toThrow(/data envelope requires data payload/);
+		const payloadAccessor = {};
+		const getter = vi.fn(() => "data");
+		Object.defineProperty(payloadAccessor, "kind", { get: getter, enumerable: true });
+		Object.defineProperty(payloadAccessor, "value", { value: "ok", enumerable: true });
+		expect(() =>
+			wireBridgeEnvelope({
+				sessionId: "session-a",
+				type: "data",
+				seq: 1,
+				payload: payloadAccessor as never,
+			}),
+		).toThrow(/data envelope requires data payload/);
+		expect(getter).not.toHaveBeenCalled();
+	});
+
+	it("emits close without an undefined reason payload", () => {
+		const g = graph();
+		const bridge = wireBridge(g, { name: "bridge", sessionId: "session-a" });
+		const outbound: unknown[] = [];
+		const errors: unknown[] = [];
+		bridge.outbound.subscribe((msg) => outbound.push(msg));
+		bridge.errors.subscribe((msg) => errors.push(msg));
+
+		bridge.close();
+
+		expect(errors.filter((msg) => Array.isArray(msg) && msg[0] === "DATA")).toEqual([]);
+		expect(outbound.at(-1)).toEqual([
+			"DATA",
+			expect.objectContaining({
+				type: "close",
+				payload: { kind: "close" },
+			}),
+		]);
+	});
+
+	it("surfaces invalid outbound payloads as bridge issues without protocol terminals", () => {
+		const g = graph();
+		const bridge = wireBridge(g, { name: "bridge", sessionId: "session-a" });
+		const errors: unknown[] = [];
+		const outbound: unknown[] = [];
+		bridge.errors.subscribe((msg) => errors.push(msg));
+		bridge.outbound.subscribe((msg) => outbound.push(msg));
+
+		bridge.send({ socket: () => undefined });
+
+		expect(outbound.filter((msg) => Array.isArray(msg) && msg[0] === "DATA")).toEqual([]);
+		expect(errors).toContainEqual([
+			"DATA",
+			expect.stringMatching(
+				/wire-admissible payload|strict JSON|stableJsonString|invalid canonical wire DTO/,
+			),
+		]);
+		expect(bridge.errors.status).not.toBe("errored");
+		expect(bridge.outbound.status).not.toBe("errored");
+	});
+
+	it("exposes command, outbound, inbound, ack, cursor, status, and error nodes in describe", () => {
+		const g = graph();
+		const bridge = wireBridge<{ task: string }, { ok: boolean }>(g, {
+			name: "bridge",
+			sessionId: "session-a",
+		});
+		const outbound: unknown[] = [];
+		const acks: unknown[] = [];
+		const cursor: unknown[] = [];
+		const status: unknown[] = [];
+		bridge.outbound.subscribe((msg) => outbound.push(msg));
+		bridge.acks.subscribe((msg) => acks.push(msg));
+		bridge.cursor.subscribe((msg) => cursor.push(msg));
+		bridge.status.subscribe((msg) => status.push(msg));
+
+		bridge.send({ task: "compile" }, { requestId: "req-1" });
+		bridge.inbound.down([
+			[
+				"DATA",
+				wireBridgeEnvelope({
+					sessionId: "session-a",
+					type: "ack",
+					seq: 1,
+					cursor: 1,
+					ackForSeq: 1,
+				}),
+			],
+		]);
+
+		expect(outbound).toContainEqual([
+			"DATA",
+			{
+				sessionId: "session-a",
+				type: "data",
+				payload: { kind: "data", value: { task: "compile" } },
+				metadata: {
+					seq: 1,
+					cursor: 0,
+					idempotencyKey: "session-a:1",
+					attempt: 1,
+					maxAttempts: 1,
+					timestampMs: expect.any(Number),
+					ackForSeq: undefined,
+					requestId: "req-1",
+				},
+			},
+		]);
+		expect(acks).toContainEqual([
+			"DATA",
+			{
+				ackForSeq: 1,
+				envelope: wireBridgeEnvelope({
+					sessionId: "session-a",
+					type: "ack",
+					seq: 1,
+					cursor: 1,
+					ackForSeq: 1,
+				}),
+			},
+		]);
+		expect(cursor).toContainEqual(["DATA", 1]);
+		expect(status.at(-1)).toEqual([
+			"DATA",
+			{
+				sessionId: "session-a",
+				state: "open",
+				cursor: 1,
+				nextSeq: 2,
+				pending: 0,
+				attempts: 1,
+				acked: 1,
+				nacked: 0,
+				errors: 0,
+				lastSeq: 1,
+			},
+		]);
+		const snap = g.describe();
+		expect(snap.nodes.map((node) => node.id).sort()).toEqual([
+			"bridge/acks",
+			"bridge/attempts",
+			"bridge/command",
+			"bridge/cursor",
+			"bridge/errors",
+			"bridge/events",
+			"bridge/inbound",
+			"bridge/nacks",
+			"bridge/outbound",
+			"bridge/status",
+		]);
+		expect(snap.edges).toContainEqual({ from: "bridge/command", to: "bridge/events" });
+		expect(snap.edges).toContainEqual({ from: "bridge/inbound", to: "bridge/events" });
+		expect(snap.edges).toContainEqual({ from: "bridge/events", to: "bridge/outbound" });
+		expect(snap.edges).toContainEqual({ from: "bridge/events", to: "bridge/status" });
+	});
+
+	it("keeps convenience start/send/ack/nack/close as command fact publishers", () => {
+		const g = graph();
+		const bridge = wireBridge(g, { name: "bridge", sessionId: "session-a" });
+		const commands: unknown[] = [];
+		bridge.command.subscribe((msg) => {
+			if (msg[0] === "DATA") commands.push(msg);
+		});
+
+		bridge.start();
+		bridge.send("hello", { idempotencyKey: "custom", requestId: "req-1" });
+		bridge.ack(3);
+		bridge.nack(4, "bad");
+		bridge.close("done");
+
+		expect(commands).toEqual([
+			["DATA", { kind: "start" }],
+			["DATA", { kind: "send", payload: "hello", idempotencyKey: "custom", requestId: "req-1" }],
+			["DATA", { kind: "ack", ackForSeq: 3, idempotencyKey: undefined, requestId: undefined }],
+			[
+				"DATA",
+				{
+					kind: "nack",
+					ackForSeq: 4,
+					error: "bad",
+					idempotencyKey: undefined,
+					requestId: undefined,
+				},
+			],
+			["DATA", { kind: "close", reason: "done", idempotencyKey: undefined }],
+		]);
+	});
+
+	it("does not mutate through a hidden ack timer when no driver command arrives (D502)", () => {
+		vi.useFakeTimers();
+		try {
+			const g = graph();
+			const bridge = wireBridge<string, unknown>(g, {
+				name: "bridge",
+				sessionId: "session-a",
+				retry: retryPolicy(2, { kind: "constant", delayMs: 10 }),
+				now: () => 1000,
+			});
+			const outbound: unknown[] = [];
+			const errors: unknown[] = [];
+			const status: unknown[] = [];
+			bridge.outbound.subscribe((msg) => outbound.push(msg));
+			bridge.errors.subscribe((msg) => errors.push(msg));
+			bridge.status.subscribe((msg) => status.push(msg));
+
+			bridge.send("payload");
+			const beforeOutbound = [...outbound];
+			const beforeErrors = [...errors];
+			const beforeStatus = [...status];
+			vi.advanceTimersByTime(60_000);
+
+			expect(outbound).toEqual(beforeOutbound);
+			expect(errors).toEqual(beforeErrors);
+			expect(status).toEqual(beforeStatus);
+		} finally {
+			vi.useRealTimers();
+		}
+	});
+
+	it("retries only a matching pending ack-timeout seq and attempt (D502)", () => {
+		const g = graph();
+		const bridge = wireBridge<string, unknown>(g, {
+			name: "bridge",
+			sessionId: "session-a",
+			retry: retryPolicy(2, { kind: "constant", delayMs: 10 }),
+			now: () => 1000,
+		});
+		const outbound: unknown[] = [];
+		const events: unknown[] = [];
+		const status: unknown[] = [];
+		bridge.outbound.subscribe((msg) => outbound.push(msg));
+		bridge.events.subscribe((msg) => events.push(msg));
+		bridge.status.subscribe((msg) => status.push(msg));
+
+		bridge.send("payload");
+		bridge.command.down([["DATA", { kind: "ack-timeout", seq: 1, attempt: 2 }]]);
+		expect(outbound.filter((msg) => msg[0] === "DATA")).toHaveLength(1);
+		expect(events).not.toContainEqual(["DATA", { kind: "timeout", seq: 1, attempt: 2 }]);
+
+		bridge.command.down([["DATA", { kind: "ack-timeout", seq: 1, attempt: 1 }]]);
+
+		expect(events).toContainEqual(["DATA", { kind: "timeout", seq: 1, attempt: 1 }]);
+		expect(events).toContainEqual([
+			"DATA",
+			{
+				kind: "retry",
+				seq: 1,
+				attempt: 2,
+				delayMs: 10,
+				error: "session-a: ack timeout for seq 1",
+			},
+		]);
+		expect(outbound.filter((msg) => msg[0] === "DATA")).toEqual([
+			[
+				"DATA",
+				expect.objectContaining({
+					metadata: expect.objectContaining({ seq: 1, attempt: 1, maxAttempts: 2 }),
+				}),
+			],
+			[
+				"DATA",
+				expect.objectContaining({
+					metadata: expect.objectContaining({ seq: 1, attempt: 2, maxAttempts: 2 }),
+				}),
+			],
+		]);
+		expect(status.at(-1)).toEqual([
+			"DATA",
+			expect.objectContaining({
+				sessionId: "session-a",
+				state: "open",
+				pending: 1,
+				attempts: 2,
+				lastDelayMs: 10,
+			}),
+		]);
+	});
+
+	it("treats stale ack-timeout after ack as a fail-closed no-op (D502)", () => {
+		const g = graph();
+		const bridge = wireBridge<string, unknown>(g, {
+			name: "bridge",
+			sessionId: "session-a",
+			retry: retryPolicy(2, { kind: "constant", delayMs: 10 }),
+		});
+		const outbound: unknown[] = [];
+		const events: unknown[] = [];
+		bridge.outbound.subscribe((msg) => outbound.push(msg));
+		bridge.events.subscribe((msg) => events.push(msg));
+
+		bridge.send("payload");
+		bridge.inbound.down([
+			[
+				"DATA",
+				wireBridgeEnvelope({
+					sessionId: "session-a",
+					type: "ack",
+					seq: 1,
+					ackForSeq: 1,
+				}),
+			],
+		]);
+		bridge.command.down([["DATA", { kind: "ack-timeout", seq: 1, attempt: 1 }]]);
+
+		expect(outbound.filter((msg) => msg[0] === "DATA")).toHaveLength(1);
+		expect(events).not.toContainEqual(["DATA", { kind: "timeout", seq: 1, attempt: 1 }]);
+	});
+
+	it("surfaces malformed ack-timeout commands as invalid facts without protocol terminals (D502)", () => {
+		const g = graph();
+		const bridge = wireBridge<string, unknown>(g, { name: "bridge", sessionId: "session-a" });
+		const errors: unknown[] = [];
+		bridge.errors.subscribe((msg) => errors.push(msg));
+
+		bridge.command.down([["DATA", { kind: "ack-timeout", seq: 1, attempt: 0 } as never]]);
+
+		expect(errors).toContainEqual([
+			"DATA",
+			"wireBridge: ack-timeout command attempt must be a positive integer",
+		]);
+		expect(bridge.events.status).not.toBe("errored");
+		expect(bridge.status.status).not.toBe("errored");
+	});
+
+	it("keeps retry exhaustion graph-visible for matching ack-timeout commands (D502)", () => {
+		const g = graph();
+		const bridge = wireBridge<string, unknown>(g, {
+			name: "bridge",
+			sessionId: "session-a",
+			retry: retryPolicy(1, { kind: "constant", delayMs: 10 }),
+		});
+		const errors: unknown[] = [];
+		const status: unknown[] = [];
+		const events: unknown[] = [];
+		bridge.errors.subscribe((msg) => errors.push(msg));
+		bridge.status.subscribe((msg) => status.push(msg));
+		bridge.events.subscribe((msg) => events.push(msg));
+
+		bridge.send("payload");
+		bridge.command.down([["DATA", { kind: "ack-timeout", seq: 1, attempt: 1 }]]);
+
+		expect(events).toContainEqual(["DATA", { kind: "timeout", seq: 1, attempt: 1 }]);
+		expect(errors).toContainEqual(["DATA", "session-a: ack timeout for seq 1"]);
+		expect(status.at(-1)).toEqual([
+			"DATA",
+			expect.objectContaining({
+				sessionId: "session-a",
+				state: "exhausted",
+				pending: 0,
+				errors: 1,
+				lastSeq: 1,
+			}),
+		]);
+		expect(bridge.events.status).not.toBe("errored");
+		expect(bridge.status.status).not.toBe("errored");
+	});
+
+	it("derives ack-timeout commands from graph-visible clock facts and declared deps (D502)", () => {
+		const g = graph();
+		const clock = g.node<number>([], null, { name: "clock" });
+		const bridge = wireBridge<string, unknown>(g, {
+			name: "bridge",
+			sessionId: "session-a",
+			retry: retryPolicy(2, { kind: "constant", delayMs: 10 }),
+		});
+		const driver = wireBridgeAckDriver(g, bridge, { name: "ackDriver", clock, timeoutMs: 5 });
+		const commands: unknown[] = [];
+		const outbound: unknown[] = [];
+		const driverStatus: unknown[] = [];
+		driver.commands.subscribe((msg) => commands.push(msg));
+		driver.status.subscribe((msg) => driverStatus.push(msg));
+		bridge.outbound.subscribe((msg) => outbound.push(msg));
+
+		clock.down([["DATA", 1000]]);
+		bridge.send("payload");
+		clock.down([["DATA", 1004]]);
+		expect(commands.filter((msg) => msg[0] === "DATA")).toEqual([]);
+
+		clock.down([["DATA", 1005]]);
+
+		expect(commands).toContainEqual([
+			"DATA",
+			{ kind: "ack-timeout", seq: 1, attempt: 1, observedAtMs: 1005 },
+		]);
+		expect(outbound.filter((msg) => msg[0] === "DATA")).toHaveLength(1);
+		expect(driverStatus).toContainEqual([
+			"DATA",
+			expect.objectContaining({
+				state: "timed-out",
+				pending: 1,
+				commands: 1,
+				nowMs: 1005,
+			}),
+		]);
+		bridge.command.down([
+			["DATA", { kind: "ack-timeout", seq: 1, attempt: 1, observedAtMs: 1005 }],
+		]);
+		expect(outbound.filter((msg) => msg[0] === "DATA")).toHaveLength(1);
+		clock.down([["DATA", 1014]]);
+		expect(commands.filter((msg) => msg[0] === "DATA")).toHaveLength(1);
+		clock.down([["DATA", 1015]]);
+		expect(commands).toContainEqual([
+			"DATA",
+			{ kind: "ack-timeout", seq: 1, attempt: 1, observedAtMs: 1015 },
+		]);
+		bridge.command.down([
+			["DATA", { kind: "ack-timeout", seq: 1, attempt: 1, observedAtMs: 1015 }],
+		]);
+		expect(outbound.filter((msg) => msg[0] === "DATA")).toHaveLength(2);
+		const snap = g.describe();
+		expect(snap.edges).toContainEqual({ from: "clock", to: "ackDriver/events" });
+		expect(snap.edges).toContainEqual({ from: "bridge/attempts", to: "ackDriver/events" });
+		expect(snap.edges).toContainEqual({ from: "bridge/acks", to: "ackDriver/events" });
+		expect(snap.edges).toContainEqual({ from: "bridge/nacks", to: "ackDriver/events" });
+		expect(snap.edges).toContainEqual({ from: "bridge/status", to: "ackDriver/events" });
+		expect(snap.edges).toContainEqual({ from: "ackDriver/events", to: "ackDriver/commands" });
+		expect(snap.edges).not.toContainEqual({ from: "ackDriver/commands", to: "bridge/command" });
+	});
+
+	it("keeps stale explicit ack-timeout ingress as a bridge no-op after ack (D502)", () => {
+		const g = graph();
+		const clock = g.node<number>([], null, { name: "clock" });
+		const bridge = wireBridge<string, unknown>(g, {
+			name: "bridge",
+			sessionId: "session-a",
+			retry: retryPolicy(2, { kind: "constant", delayMs: 10 }),
+		});
+		const driver = wireBridgeAckDriver(g, bridge, { name: "ackDriver", clock, timeoutMs: 5 });
+		const commands: unknown[] = [];
+		const outbound: unknown[] = [];
+		driver.commands.subscribe((msg) => commands.push(msg));
+		bridge.outbound.subscribe((msg) => outbound.push(msg));
+
+		clock.down([["DATA", 1000]]);
+		bridge.send("payload");
+		batch(() => {
+			clock.down([["DATA", 1005]]);
+			bridge.inbound.down([
+				[
+					"DATA",
+					wireBridgeEnvelope({
+						sessionId: "session-a",
+						type: "ack",
+						seq: 1,
+						ackForSeq: 1,
+					}),
+				],
+			]);
+		});
+
+		expect(commands).toContainEqual([
+			"DATA",
+			{ kind: "ack-timeout", seq: 1, attempt: 1, observedAtMs: 1005 },
+		]);
+		bridge.command.down([
+			["DATA", { kind: "ack-timeout", seq: 1, attempt: 1, observedAtMs: 1005 }],
+		]);
+		expect(outbound.filter((msg) => msg[0] === "DATA")).toHaveLength(1);
+	});
+
+	it("releases the ack driver topology so late clocks cannot derive retry commands (D502)", () => {
+		const g = graph();
+		const clock = g.node<number>([], null, { name: "clock" });
+		const bridge = wireBridge<string, unknown>(g, {
+			name: "bridge",
+			sessionId: "session-a",
+			retry: retryPolicy(2, { kind: "constant", delayMs: 10 }),
+		});
+		const driver = wireBridgeAckDriver(g, bridge, { name: "ackDriver", clock, timeoutMs: 5 });
+		const outbound: unknown[] = [];
+		const commands: unknown[] = [];
+		const unsubscribe = driver.commands.subscribe((msg) => commands.push(msg));
+		bridge.outbound.subscribe((msg) => outbound.push(msg));
+
+		clock.down([["DATA", 1000]]);
+		bridge.send("payload");
+		unsubscribe();
+		driver.release();
+		clock.down([["DATA", 1005]]);
+
+		expect(commands.filter((msg) => msg[0] === "DATA")).toEqual([]);
+		expect(g.describe().edges).not.toContainEqual({ from: "clock", to: "ackDriver/events" });
+		expect(g.describe().edges).not.toContainEqual({
+			from: "ackDriver/commands",
+			to: "bridge/command",
+		});
+		expect(outbound.filter((msg) => msg[0] === "DATA")).toHaveLength(1);
+	});
+
+	it("close clears pending bridge status without emitting protocol terminal state", () => {
+		const g = graph();
+		const bridge = wireBridge<string, unknown>(g, { name: "bridge", sessionId: "session-a" });
+		const status: unknown[] = [];
+		bridge.status.subscribe((msg) => status.push(msg));
+
+		bridge.send("payload");
+		bridge.close("done");
+
+		expect(status.at(-1)).toEqual([
+			"DATA",
+			{
+				sessionId: "session-a",
+				state: "closed",
+				cursor: 0,
+				nextSeq: 3,
+				pending: 1,
+				attempts: 2,
+				acked: 0,
+				nacked: 0,
+				errors: 0,
+				lastSeq: 2,
+			},
+		]);
+		bridge.inbound.down([
+			[
+				"DATA",
+				wireBridgeEnvelope({
+					sessionId: "session-a",
+					type: "ack",
+					seq: 1,
+					ackForSeq: 2,
+				}),
+			],
+		]);
+		expect(status.at(-1)).toEqual([
+			"DATA",
+			{
+				sessionId: "session-a",
+				state: "closed",
+				cursor: 1,
+				nextSeq: 3,
+				pending: 0,
+				attempts: 2,
+				acked: 1,
+				nacked: 0,
+				errors: 0,
+				lastSeq: 1,
+			},
+		]);
+	});
+
+	it("rejects inbound envelopes from a different bridge session without advancing cursor", () => {
+		const g = graph();
+		const bridge = wireBridge(g, { name: "bridge", sessionId: "session-a" });
+		const errors: unknown[] = [];
+		const cursor: unknown[] = [];
+		const status: unknown[] = [];
+		bridge.errors.subscribe((msg) => errors.push(msg));
+		bridge.cursor.subscribe((msg) => cursor.push(msg));
+		bridge.status.subscribe((msg) => status.push(msg));
+
+		bridge.inbound.down([
+			[
+				"DATA",
+				wireBridgeEnvelope({
+					sessionId: "session-b",
+					type: "data",
+					seq: 1,
+					payload: { kind: "data", value: "wrong-session" },
+				}),
+			],
+		]);
+		bridge.inbound.down([
+			[
+				"DATA",
+				wireBridgeEnvelope({
+					sessionId: "session-a",
+					type: "data",
+					seq: 1,
+					payload: { kind: "data", value: "right-session" },
+				}),
+			],
+		]);
+
+		expect(errors).toContainEqual([
+			"DATA",
+			"bridge: inbound session session-b did not match expected session-a",
+		]);
+		expect(cursor).toContainEqual(["DATA", 1]);
+		expect(status.at(-1)).toEqual([
+			"DATA",
+			{
+				sessionId: "session-a",
+				state: "errored",
+				cursor: 1,
+				nextSeq: 1,
+				pending: 0,
+				attempts: 0,
+				acked: 0,
+				nacked: 0,
+				errors: 1,
+			},
+		]);
+	});
+
+	it("rejects malformed inbound metadata before it can poison the cursor", () => {
+		const g = graph();
+		const bridge = wireBridge(g, { name: "bridge", sessionId: "session-a" });
+		const errors: unknown[] = [];
+		const cursor: unknown[] = [];
+		bridge.errors.subscribe((msg) => errors.push(msg));
+		bridge.cursor.subscribe((msg) => cursor.push(msg));
+
+		bridge.inbound.down([
+			[
+				"DATA",
+				{
+					sessionId: "session-a",
+					type: "data",
+					payload: { kind: "data", value: "bad" },
+					metadata: {
+						seq: Number.NaN,
+						cursor: 0,
+						idempotencyKey: "bad",
+						attempt: 1,
+						maxAttempts: 1,
+					},
+				} as never,
+			],
+		]);
+		bridge.inbound.down([
+			[
+				"DATA",
+				wireBridgeEnvelope({
+					sessionId: "session-a",
+					type: "data",
+					seq: 1,
+					payload: { kind: "data", value: "good" },
+				}),
+			],
+		]);
+
+		expect(errors).toContainEqual([
+			"DATA",
+			"wireBridge: inbound envelope seq must be a positive integer",
+		]);
+		expect(cursor).toContainEqual(["DATA", 1]);
+	});
+
+	it("treats raw inbound protocol ERROR as local misuse without poisoning later inbound facts", () => {
+		const g = graph();
+		const bridge = wireBridge(g, { name: "bridge", sessionId: "session-a" });
+		const errors: unknown[] = [];
+		const cursor: unknown[] = [];
+		bridge.errors.subscribe((msg) => errors.push(msg));
+		bridge.cursor.subscribe((msg) => cursor.push(msg));
+
+		bridge.inbound.down([["ERROR", "remote protocol error"]]);
+		bridge.inbound.down([
+			[
+				"DATA",
+				wireBridgeEnvelope({
+					sessionId: "session-a",
+					type: "data",
+					seq: 1,
+					payload: { kind: "data", value: "still-live" },
+				}),
+			],
+		]);
+
+		expect(errors).toContainEqual([
+			"DATA",
+			"session-a: inbound protocol ERROR remote protocol error is local misuse; remote errors must arrive as DATA envelope facts",
+		]);
+		expect(cursor).toContainEqual(["DATA", 1]);
+		expect(bridge.events.status).not.toBe("errored");
+		expect(bridge.status.status).not.toBe("errored");
+	});
+
+	it("treats remote error and out-of-order receipt as inbound facts, not local terminal errors", () => {
+		const g = graph();
+		const bridge = wireBridge(g, { name: "bridge", sessionId: "session-a" });
+		const events: unknown[] = [];
+		const errors: unknown[] = [];
+		const status: unknown[] = [];
+		bridge.events.subscribe((msg) => events.push(msg));
+		bridge.errors.subscribe((msg) => errors.push(msg));
+		bridge.status.subscribe((msg) => status.push(msg));
+
+		bridge.inbound.down([
+			[
+				"DATA",
+				wireBridgeEnvelope({
+					sessionId: "session-a",
+					type: "error",
+					seq: 2,
+					payload: { kind: "error", error: "remote failed" },
+				}),
+			],
+		]);
+		bridge.inbound.down([
+			[
+				"DATA",
+				wireBridgeEnvelope({
+					sessionId: "session-a",
+					type: "error",
+					seq: 1,
+					payload: { kind: "error", error: "remote failed" },
+				}),
+			],
+		]);
+
+		expect(events).toContainEqual(["DATA", { kind: "out-of-order", seq: 2, expected: 1 }]);
+		expect(errors).toContainEqual(["DATA", "bridge: inbound seq 2 arrived before expected seq 1"]);
+		expect(errors).toContainEqual(["DATA", "remote failed"]);
+		expect(status.at(-1)).toEqual([
+			"DATA",
+			{
+				sessionId: "session-a",
+				state: "errored",
+				cursor: 1,
+				nextSeq: 1,
+				pending: 0,
+				attempts: 0,
+				acked: 0,
+				nacked: 0,
+				errors: 2,
+				lastSeq: 1,
+			},
+		]);
+		expect(bridge.status.status).not.toBe("errored");
+	});
+
+	it("requires ackForSeq on inbound ack/nack before advancing cursor", () => {
+		const g = graph();
+		const bridge = wireBridge<string, unknown>(g, { name: "bridge", sessionId: "session-a" });
+		const errors: unknown[] = [];
+		const cursor: unknown[] = [];
+		bridge.errors.subscribe((msg) => errors.push(msg));
+		bridge.cursor.subscribe((msg) => cursor.push(msg));
+
+		bridge.send("payload");
+		bridge.inbound.down([
+			[
+				"DATA",
+				{
+					sessionId: "session-a",
+					type: "ack",
+					metadata: {
+						seq: 1,
+						cursor: 0,
+						idempotencyKey: "bad-ack",
+						attempt: 1,
+						maxAttempts: 1,
+					},
+				} as never,
+			],
+		]);
+		bridge.inbound.down([
+			[
+				"DATA",
+				wireBridgeEnvelope({
+					sessionId: "session-a",
+					type: "ack",
+					seq: 1,
+					ackForSeq: 1,
+				}),
+			],
+		]);
+
+		expect(errors).toContainEqual(["DATA", "wireBridge: inbound ack envelope requires ackForSeq"]);
+		expect(cursor).toContainEqual(["DATA", 1]);
+	});
+
+	it("treats idempotencyKey as metadata and correlates receipts by ackForSeq (D151)", () => {
+		const g = graph();
+		const bridge = wireBridge<string, string>(g, { name: "bridge", sessionId: "session-a" });
+		const events: unknown[] = [];
+		const acks: unknown[] = [];
+		const cursor: unknown[] = [];
+		const status: unknown[] = [];
+		bridge.events.subscribe((msg) => events.push(msg));
+		bridge.acks.subscribe((msg) => acks.push(msg));
+		bridge.cursor.subscribe((msg) => cursor.push(msg));
+		bridge.status.subscribe((msg) => status.push(msg));
+
+		bridge.send("first", { idempotencyKey: "same-key" });
+		bridge.send("second", { idempotencyKey: "same-key" });
+		bridge.inbound.down([
+			[
+				"DATA",
+				wireBridgeEnvelope({
+					sessionId: "session-a",
+					type: "data",
+					seq: 1,
+					payload: { kind: "data", value: "remote-one" },
+					idempotencyKey: "same-key",
+				}),
+			],
+		]);
+		bridge.inbound.down([
+			[
+				"DATA",
+				wireBridgeEnvelope({
+					sessionId: "session-a",
+					type: "data",
+					seq: 2,
+					payload: { kind: "data", value: "remote-two" },
+					idempotencyKey: "same-key",
+				}),
+			],
+		]);
+		bridge.inbound.down([
+			[
+				"DATA",
+				wireBridgeEnvelope({
+					sessionId: "session-a",
+					type: "ack",
+					seq: 3,
+					ackForSeq: 2,
+					idempotencyKey: "different-correlation-key",
+				}),
+			],
+		]);
+
+		expect(
+			events.filter(
+				(msg) =>
+					(msg as unknown[])[0] === "DATA" &&
+					((msg as unknown[])[1] as { kind?: string }).kind === "duplicate",
+			),
+		).toEqual([]);
+		expect(cursor.filter((msg) => (msg as unknown[])[0] === "DATA")).toEqual([
+			["DATA", 1],
+			["DATA", 2],
+			["DATA", 3],
+		]);
+		expect(acks.at(-1)).toEqual([
+			"DATA",
+			expect.objectContaining({
+				ackForSeq: 2,
+				envelope: expect.objectContaining({
+					metadata: expect.objectContaining({
+						ackForSeq: 2,
+						idempotencyKey: "different-correlation-key",
+					}),
+				}),
+			}),
+		]);
+		expect(status.at(-1)).toEqual([
+			"DATA",
+			expect.objectContaining({ pending: 1, acked: 1, cursor: 3, lastSeq: 3 }),
+		]);
+	});
+
+	it("rejects inbound cursor regression before accepting the envelope", () => {
+		const g = graph();
+		const bridge = wireBridge(g, { name: "bridge", sessionId: "session-a" });
+		const errors: unknown[] = [];
+		const cursor: unknown[] = [];
+		bridge.errors.subscribe((msg) => errors.push(msg));
+		bridge.cursor.subscribe((msg) => cursor.push(msg));
+
+		bridge.inbound.down([
+			[
+				"DATA",
+				wireBridgeEnvelope({
+					sessionId: "session-a",
+					type: "data",
+					seq: 1,
+					cursor: 3,
+					payload: { kind: "data", value: "one" },
+				}),
+			],
+		]);
+		bridge.inbound.down([
+			[
+				"DATA",
+				wireBridgeEnvelope({
+					sessionId: "session-a",
+					type: "data",
+					seq: 2,
+					cursor: 2,
+					payload: { kind: "data", value: "two" },
+				}),
+			],
+		]);
+
+		expect(errors).toContainEqual(["DATA", "session-a: inbound cursor 2 regressed below 3"]);
+		expect(cursor.filter((msg) => msg[0] === "DATA")).toEqual([["DATA", 1]]);
+	});
+
+	it("updates status for a remote error envelope without protocol terminalizing locally", () => {
+		const g = graph();
+		const bridge = wireBridge(g, { name: "bridge", sessionId: "session-a" });
+		const errors: unknown[] = [];
+		const status: unknown[] = [];
+		bridge.errors.subscribe((msg) => errors.push(msg));
+		bridge.status.subscribe((msg) => status.push(msg));
+
+		bridge.inbound.down([
+			[
+				"DATA",
+				wireBridgeEnvelope({
+					sessionId: "session-a",
+					type: "error",
+					seq: 1,
+					payload: { kind: "error", error: "remote failed" },
+				}),
+			],
+		]);
+
+		expect(errors).toContainEqual(["DATA", "remote failed"]);
+		expect(status.at(-1)).toEqual([
+			"DATA",
+			{
+				sessionId: "session-a",
+				state: "errored",
+				cursor: 1,
+				nextSeq: 1,
+				pending: 0,
+				attempts: 0,
+				acked: 0,
+				nacked: 0,
+				errors: 1,
+				lastSeq: 1,
+			},
+		]);
+		expect(bridge.status.status).not.toBe("errored");
+	});
+
+	it("surfaces malformed command facts without treating them as close", () => {
+		const g = graph();
+		const bridge = wireBridge(g, { name: "bridge", sessionId: "session-a" });
+		const outbound: unknown[] = [];
+		const errors: unknown[] = [];
+		bridge.outbound.subscribe((msg) => outbound.push(msg));
+		bridge.errors.subscribe((msg) => errors.push(msg));
+
+		bridge.command.down([["DATA", { kind: "wat" } as never]]);
+		bridge.command.down([["DATA", { kind: "ack", ackForSeq: 0 } as never]]);
+		bridge.command.down([["DATA", { kind: "send", payload: "ok", idempotencyKey: "" } as never]]);
+		bridge.send("after-invalid");
+
+		expect(errors).toContainEqual(["DATA", "wireBridge: command kind is not recognized"]);
+		expect(errors).toContainEqual([
+			"DATA",
+			"wireBridge: ack command ackForSeq must be a positive integer",
+		]);
+		expect(errors).toContainEqual([
+			"DATA",
+			"wireBridgeEnvelope: idempotencyKey must be a non-empty string",
+		]);
+		expect(outbound.filter((msg) => msg[0] === "DATA")).toEqual([
+			[
+				"DATA",
+				{
+					sessionId: "session-a",
+					type: "data",
+					payload: { kind: "data", value: "after-invalid" },
+					metadata: {
+						seq: 1,
+						cursor: 0,
+						idempotencyKey: "session-a:1",
+						attempt: 1,
+						maxAttempts: 1,
+						timestampMs: expect.any(Number),
+						ackForSeq: undefined,
+						requestId: undefined,
+					},
+				},
+			],
+		]);
+	});
+
+	it("wireEdgeGroup D501 emits two-phase frames, gates release, fails closed, describes, and releases", () => {
+		const bytes = (...values: number[]) => new Uint8Array(values);
+		const dataValues = <T>(messages: T[][]): unknown[] =>
+			messages.filter((msg) => msg[0] === "DATA").map((msg) => msg[1]);
+		const g = graph();
+		const sourceA = g.node<Uint8Array>([], null, { name: "edge/a" });
+		const sourceB = g.node<Uint8Array>([], null, { name: "edge/b" });
+		const bridge = wireBridge(g, { name: "bridgeWeg", sessionId: "session-a" });
+		const group = wireEdgeGroup(g, bridge, {
+			name: "group",
+			edges: [
+				{ edgeId: "a", outbound: sourceA },
+				{ edgeId: "b", outbound: sourceB },
+			],
+		});
+		const outbound: unknown[][] = [];
+		bridge.outbound.subscribe((msg) => outbound.push(msg as unknown[]));
+		batch(() => {
+			sourceA.down([["DATA", bytes(1)]]);
+			sourceB.down([["DATA", bytes(2)]]);
+		});
+		expect(
+			dataValues(outbound).map(
+				(envelope) =>
+					(envelope as { payload?: { value?: { frame?: unknown } } }).payload?.value?.frame,
+			),
+		).toEqual([
+			{ kind: "dirty", edgeId: "a", causeId: "group:cause:1" },
+			{ kind: "dirty", edgeId: "b", causeId: "group:cause:1" },
+			{ kind: "data", edgeId: "a", causeId: "group:cause:1", value: bytes(1) },
+			{ kind: "data", edgeId: "b", causeId: "group:cause:1", value: bytes(2) },
+		]);
+		const inboundA = group.inbound.get("a");
+		const inbound: unknown[][] = [];
+		const issues: unknown[][] = [];
+		const status: unknown[][] = [];
+		inboundA?.subscribe((msg) => inbound.push(msg as unknown[]));
+		group.issues.subscribe((msg) => issues.push(msg as unknown[]));
+		group.status.subscribe((msg) => status.push(msg as unknown[]));
+		const edgeEnvelope = (seq: number, frame: Record<string, unknown>) =>
+			wireBridgeEnvelope({
+				sessionId: "session-a",
+				type: "data",
+				seq,
+				payload: { kind: "data", value: { kind: "wire_edge", frame } },
+			});
+		bridge.inbound.down([
+			["DATA", edgeEnvelope(1, { kind: "dirty", edgeId: "a", causeId: "c1" })],
+			["DATA", edgeEnvelope(2, { kind: "data", edgeId: "a", causeId: "c1", value: bytes(10) })],
+			[
+				"DATA",
+				wireBridgeEnvelope({
+					sessionId: "session-a",
+					type: "close",
+					seq: 3,
+					payload: { kind: "close" },
+				}),
+			],
+		]);
+		expect(dataValues(inbound)).toEqual([]);
+		bridge.inbound.down([
+			["DATA", edgeEnvelope(4, { kind: "dirty", edgeId: "a", causeId: "c2" })],
+			["DATA", edgeEnvelope(5, { kind: "dirty", edgeId: "b", causeId: "c2" })],
+			["DATA", edgeEnvelope(6, { kind: "data", edgeId: "a", causeId: "c2", value: bytes(10) })],
+			["DATA", edgeEnvelope(7, { kind: "data", edgeId: "b", causeId: "c2", value: bytes(20) })],
+		]);
+		expect(dataValues(inbound)).toEqual([bytes(10)]);
+		bridge.inbound.down([
+			["DATA", edgeEnvelope(8, { kind: "dirty", edgeId: "z", causeId: "bad" })],
+		]);
+		expect(dataValues(issues)).toContainEqual(
+			expect.objectContaining({ code: "wire-edge-group-unknown-edge" }),
+		);
+		expect(status.at(-1)).toEqual(["DATA", expect.objectContaining({ state: "issues" })]);
+		const snap = g.describe();
+		expect(
+			snap.edges.some(
+				(edge) => edge.to === "group/events" && edge.from.includes("wireBridgeInbound"),
+			),
+		).toBe(true);
+		expect(snap.edges).toContainEqual({ from: "group/events", to: "group/gate" });
+		expect(snap.edges).toContainEqual({ from: "group/gate", to: "group/inbound/a" });
+		expect(snap.edges).toContainEqual({ from: "group/commands", to: "bridgeWeg/command" });
+		const bridge2 = wireBridge(g, { name: "bridgeWeg2", sessionId: "session-b" });
+		const group2 = wireEdgeGroup(g, bridge2, {
+			name: "group2",
+			edges: [
+				{ edgeId: "a", outbound: sourceA },
+				{ edgeId: "b", outbound: sourceB },
+			],
+		});
+		group2.release();
+		expect(g.describe().edges).not.toContainEqual({
+			from: "group2/commands",
+			to: "bridgeWeg2/command",
+		});
+	});
+
+	it("wireEdgeGroup release restores bridge command source when topology release is blocked", () => {
+		const g = graph();
+		const bridge = wireBridge(g, { name: "bridgeRelease", sessionId: "session-a" });
+		const group = wireEdgeGroup(g, bridge, {
+			name: "releaseGroup",
+			edges: [{ edgeId: "a" }],
+		});
+		const unsubscribe = group.status.subscribe(() => {});
+
+		expect(() => group.release()).toThrow(/live subscribers/);
+		expect(g.describe().edges).toContainEqual({
+			from: "releaseGroup/commands",
+			to: "bridgeRelease/command",
+		});
+
+		unsubscribe();
+		group.release();
+		expect(g.describe().edges).not.toContainEqual({
+			from: "releaseGroup/commands",
+			to: "bridgeRelease/command",
+		});
+	});
+
+	it("wireEdgeGroup D501 fails closed for duplicate, data-before-dirty, competing, and incomplete causes", () => {
+		const bytes = (...values: number[]) => new Uint8Array(values);
+		const dataValues = <T>(messages: T[][]): unknown[] =>
+			messages.filter((msg) => msg[0] === "DATA").map((msg) => msg[1]);
+		const run = (name: string, frames: Record<string, unknown>[]) => {
+			const g = graph();
+			const bridge = wireBridge(g, { name: `${name}/bridge`, sessionId: "session-a" });
+			const group = wireEdgeGroup(g, bridge, {
+				name,
+				edges: [{ edgeId: "a" }, { edgeId: "b" }],
+			});
+			const inbound: unknown[][] = [];
+			const issues: unknown[][] = [];
+			const status: unknown[][] = [];
+			group.inbound.get("a")?.subscribe((msg) => inbound.push(msg as unknown[]));
+			group.issues.subscribe((msg) => issues.push(msg as unknown[]));
+			group.status.subscribe((msg) => status.push(msg as unknown[]));
+			const envelope = (seq: number, frame: Record<string, unknown>) =>
+				wireBridgeEnvelope({
+					sessionId: "session-a",
+					type: "data",
+					seq,
+					payload: { kind: "data", value: { kind: "wire_edge", frame } },
+				});
+			bridge.inbound.down(
+				frames.map((frame, index) =>
+					frame.kind === "close"
+						? [
+								"DATA",
+								wireBridgeEnvelope({
+									sessionId: "session-a",
+									type: "close",
+									seq: index + 1,
+									payload: { kind: "close" },
+								}),
+							]
+						: ["DATA", envelope(index + 1, frame)],
+				),
+			);
+			return { inbound, issues, status, group };
+		};
+		const cases: [string, string, Record<string, unknown>[]][] = [
+			[
+				"dup-dirty",
+				"wire-edge-group-duplicate-dirty",
+				[
+					{ kind: "dirty", edgeId: "a", causeId: "c1" },
+					{ kind: "dirty", edgeId: "a", causeId: "c1" },
+				],
+			],
+			[
+				"dup-data",
+				"wire-edge-group-duplicate-data",
+				[
+					{ kind: "dirty", edgeId: "a", causeId: "c1" },
+					{ kind: "dirty", edgeId: "b", causeId: "c1" },
+					{ kind: "data", edgeId: "a", causeId: "c1", value: bytes(1) },
+					{ kind: "data", edgeId: "a", causeId: "c1", value: bytes(2) },
+				],
+			],
+			[
+				"data-before-dirty",
+				"wire-edge-group-data-before-dirty",
+				[{ kind: "data", edgeId: "a", causeId: "c1", value: bytes(1) }],
+			],
+			[
+				"competing",
+				"wire-edge-group-competing-cause",
+				[
+					{ kind: "dirty", edgeId: "a", causeId: "c1" },
+					{ kind: "dirty", edgeId: "b", causeId: "c2" },
+				],
+			],
+			[
+				"incomplete",
+				"wire-edge-group-incomplete-cause",
+				[{ kind: "dirty", edgeId: "a", causeId: "c1" }, { kind: "close" }],
+			],
+		];
+		for (const [name, code, frames] of cases) {
+			const result = run(name, frames);
+			expect(dataValues(result.inbound)).toEqual([]);
+			expect(dataValues(result.issues)).toContainEqual(expect.objectContaining({ code }));
+			expect(result.status.at(-1)).toEqual(["DATA", expect.objectContaining({ state: "issues" })]);
+			expect(result.group.issues.status).not.toBe("errored");
+			expect(result.group.status.status).not.toBe("errored");
+		}
+	});
+
+	it("wireEdgeGroup D506 keeps only bounded recent replay tombstones", () => {
+		const bytes = (...values: number[]) => new Uint8Array(values);
+		const dataValues = <T>(messages: T[][]): unknown[] =>
+			messages.filter((msg) => msg[0] === "DATA").map((msg) => msg[1]);
+		const g = graph();
+		const bridge = wireBridge(g, { name: "replayBridge", sessionId: "session-a" });
+		const group = wireEdgeGroup(g, bridge, {
+			name: "replayGroup",
+			edges: [{ edgeId: "a" }],
+		});
+		const inbound: unknown[][] = [];
+		const issues: unknown[][] = [];
+		group.inbound.get("a")?.subscribe((msg) => inbound.push(msg as unknown[]));
+		group.issues.subscribe((msg) => issues.push(msg as unknown[]));
+		let seq = 1;
+		const envelope = (causeId: string, kind: "dirty" | "data", value?: Uint8Array) =>
+			wireBridgeEnvelope({
+				sessionId: "session-a",
+				type: "data",
+				seq: seq++,
+				payload: {
+					kind: "data",
+					value: {
+						kind: "wire_edge",
+						frame:
+							kind === "dirty"
+								? { kind, edgeId: "a", causeId }
+								: { kind, edgeId: "a", causeId, value: value ?? bytes(0) },
+					},
+				},
+			});
+		const release = (causeId: string, value: Uint8Array) => {
+			bridge.inbound.down([
+				["DATA", envelope(causeId, "dirty")],
+				["DATA", envelope(causeId, "data", value)],
+			]);
+		};
+
+		release("c1", bytes(1));
+		bridge.inbound.down([["DATA", envelope("c1", "dirty")]]);
+		expect(dataValues(issues)).toContainEqual(
+			expect.objectContaining({
+				code: "wire-edge-group-duplicate-dirty",
+				causeId: "c1",
+			}),
+		);
+
+		for (let i = 2; i <= 1026; i++) release(`c${i}`, bytes(i % 256));
+		const releaseCountBeforeOldReplay = dataValues(inbound).length;
+		release("c1", bytes(99));
+
+		expect(dataValues(inbound).length).toBe(releaseCountBeforeOldReplay + 1);
+		expect(dataValues(inbound).at(-1)).toEqual(bytes(99));
+	});
+
+	it("wireEdgeGroup D501 is stable when status/issues subscribe before inbound edges", () => {
+		const bytes = (...values: number[]) => new Uint8Array(values);
+		const dataValues = <T>(messages: T[][]): unknown[] =>
+			messages.filter((msg) => msg[0] === "DATA").map((msg) => msg[1]);
+		const g = graph();
+		const bridge = wireBridge(g, { name: "orderBridge", sessionId: "session-a" });
+		const group = wireEdgeGroup(g, bridge, {
+			name: "orderGroup",
+			edges: [{ edgeId: "a" }, { edgeId: "b" }],
+		});
+		const issues: unknown[][] = [];
+		const status: unknown[][] = [];
+		const inbound: unknown[][] = [];
+		group.status.subscribe((msg) => status.push(msg as unknown[]));
+		group.issues.subscribe((msg) => issues.push(msg as unknown[]));
+		group.inbound.get("a")?.subscribe((msg) => inbound.push(msg as unknown[]));
+		const envelope = (seq: number, frame: Record<string, unknown>) =>
+			wireBridgeEnvelope({
+				sessionId: "session-a",
+				type: "data",
+				seq,
+				payload: { kind: "data", value: { kind: "wire_edge", frame } },
+			});
+		bridge.inbound.down([
+			["DATA", envelope(1, { kind: "dirty", edgeId: "a", causeId: "c1" })],
+			["DATA", envelope(2, { kind: "dirty", edgeId: "b", causeId: "c1" })],
+			["DATA", envelope(3, { kind: "data", edgeId: "a", causeId: "c1", value: bytes(1) })],
+			["DATA", envelope(4, { kind: "data", edgeId: "b", causeId: "c1", value: bytes(2) })],
+		]);
+		expect(dataValues(inbound)).toEqual([bytes(1)]);
+		expect(dataValues(issues)).toEqual([]);
+		expect(status.at(-1)).toEqual([
+			"DATA",
+			expect.objectContaining({ state: "released", released: 2 }),
+		]);
+	});
+});
diff --git a/packages/ts/src/__tests__/work-item-actions.workitem-domain-action-admission-and-application-d239-d333-d343-part-01.sub-01.test.ts b/packages/ts/src/__tests__/work-item-actions.workitem-domain-action-admission-and-application-d239-d333-d343-part-01.sub-01.test.ts
new file mode 100644
index 00000000..8ac97c37
--- /dev/null
+++ b/packages/ts/src/__tests__/work-item-actions.workitem-domain-action-admission-and-application-d239-d333-d343-part-01.sub-01.test.ts
@@ -0,0 +1,651 @@
+import { describe, expect, it } from "vitest";
+import { depBatch } from "../ctx/types.js";
+import { graph } from "../graph/graph.js";
+import type { BoundaryCapabilityKind } from "../inspection/boundary.js";
+import type {
+	CapabilityAdmission,
+	CapabilityAdmissionStatus,
+} from "../solutions/capability-admission.js";
+import {
+	type WorkItemDomainActionAdmission,
+	type WorkItemDomainActionAdmissionDecision,
+	type WorkItemDomainActionApplyPolicy,
+	type WorkItemDomainActionCapabilityGuardPolicy,
+	type WorkItemDomainActionProposalInput,
+	workItemDomainActionAdmissionProjector,
+	workItemDomainActionApplicationProjector,
+	workItemDomainActionApplyPolicy,
+	workItemDomainActionCapabilityGuardProjector,
+	workItemDomainActionProposalIntake,
+	workItemDomainActionProposalIntakeProjector,
+} from "../solutions/work-item/actions.js";
+import {
+	type VerificationPlan,
+	type WorkItemAuthoringFact,
+	type WorkItemAuthoringInput,
+	type WorkItemProjection,
+	workItemAuthoringProjector,
+	workItemCreatedFromDraft,
+} from "../solutions/work-item/scheduling.js";
+
+function setupActions() {
+	const g = graph();
+	const seed = g.node<WorkItemAuthoringInput>([], null, { name: "authoringFacts" });
+	const proposals = g.node<WorkItemDomainActionProposalInput>([], null, { name: "proposals" });
+	const decisions = g.node<WorkItemDomainActionAdmissionDecision>([], null, {
+		name: "admissionDecisions",
+	});
+	const directAdmissions = g.node<WorkItemDomainActionAdmission>([], null, {
+		name: "directAdmissions",
+	});
+	const applyPolicies = g.node<WorkItemDomainActionApplyPolicy>([], null, {
+		name: "applyPolicies",
+	});
+	const authoring = workItemAuthoringProjector(g, { facts: seed });
+	const intake = workItemDomainActionProposalIntakeProjector(g, { proposals });
+	const admissions = workItemDomainActionAdmissionProjector(g, {
+		proposals: intake.proposals,
+		decisions,
+	});
+	const admissionUnion = g.node<WorkItemDomainActionAdmission>(
+		[admissions.admissions, directAdmissions],
+		(ctx) => {
+			for (const raw of depBatch(ctx, 0) ?? []) ctx.down([["DATA", raw]]);
+			for (const raw of depBatch(ctx, 1) ?? []) ctx.down([["DATA", raw]]);
+		},
+		{ name: "admissionUnion", partial: true },
+	);
+	const application = workItemDomainActionApplicationProjector(g, {
+		proposals: intake.proposals,
+		admissions: admissionUnion,
+		workItems: authoring.workItems,
+		applyPolicies,
+	});
+	return {
+		seed,
+		proposals,
+		decisions,
+		directAdmissions,
+		applyPolicies,
+		workItems: collectData<WorkItemProjection>(authoring.workItems),
+		appliedFacts: collectData<WorkItemAuthoringFact>(application.authoringFacts),
+		applications: collectData(application.applications),
+		applicationStatus: collectData(application.status),
+		applicationIssues: collectData(application.issues),
+		intakeStatus: collectData(intake.status),
+		intakeIssues: collectData(intake.issues),
+		admissionIssues: collectData(admissions.issues),
+	};
+}
+
+function _applyPatch(
+	setup: ReturnType<typeof setupActions>,
+	proposalId: string,
+	admissionId: string,
+	opts: {
+		readonly patch?: Record<string, unknown>;
+		readonly payload?: unknown;
+		readonly metadata?: Record<string, unknown>;
+	},
+): void {
+	setup.proposals.down([
+		[
+			"DATA",
+			workItemDomainActionProposalIntake(proposalId, "wi-1", "patch", {
+				payload: opts.payload ?? { patch: opts.patch },
+				metadata: opts.metadata,
+			}),
+		],
+	]);
+	setup.decisions.down([
+		["DATA", admissionDecision(`${admissionId}:decision`, admissionId, proposalId)],
+	]);
+}
+
+function admissionDecision(
+	decisionId: string,
+	admissionId: string,
+	proposalId: string,
+	outcome: WorkItemDomainActionAdmissionDecision["outcome"] = "admit",
+	opts: Partial<WorkItemDomainActionAdmissionDecision> = {},
+): WorkItemDomainActionAdmissionDecision {
+	return {
+		kind: "work-item-domain-action-admission-decision",
+		decisionId,
+		admissionId,
+		proposalId,
+		outcome,
+		...opts,
+	};
+}
+
+function capabilityAdmission(
+	capabilityId: string,
+	state: CapabilityAdmission["state"],
+	opts: {
+		readonly kind?: BoundaryCapabilityKind;
+		readonly subjectId?: string;
+	} = {},
+): CapabilityAdmission {
+	return {
+		kind: "capability-admission",
+		admissionId: `capability-admission:${opts.kind ?? "auth"}:${capabilityId}:${opts.subjectId ?? `boundary:${capabilityId}`}:${state}`,
+		proposalId: `capability-proposal:${capabilityId}`,
+		subjectId: opts.subjectId ?? `boundary:${capabilityId}`,
+		capability: capabilityRef(capabilityId, opts.kind),
+		state,
+		decisionId: `capability-decision:${capabilityId}:${state}`,
+	};
+}
+
+function capabilityRef(capabilityId: string, kind: BoundaryCapabilityKind = "auth") {
+	return { id: capabilityId, kind, required: true };
+}
+
+function collectData<T>(node: {
+	subscribe(sink: (msg: readonly [string, unknown?]) => void): unknown;
+}): T[] {
+	const out: T[] = [];
+	node.subscribe((msg) => {
+		if (msg[0] === "DATA") out.push(msg[1] as T);
+	});
+	return out;
+}
+
+function collectMessages(node: {
+	subscribe(sink: (msg: readonly [string, unknown?]) => void): unknown;
+}) {
+	const out: (readonly [string, unknown?])[] = [];
+	node.subscribe((msg) => out.push(msg));
+	return out;
+}
+
+function draft(opts: Partial<ReturnType<typeof baseDraft>> = {}) {
+	return { ...baseDraft(), ...opts };
+}
+
+function baseDraft() {
+	return {
+		summary: "Ship verification",
+		detail: "Make WorkItem actions explicit.",
+		acceptanceCriteria: [{ criterionId: "ac-1", statement: "Focused tests pass", required: true }],
+		verificationPlan: plan(),
+		tags: ["work-item"],
+		metadata: { color: "green" },
+	};
+}
+
+function plan(): VerificationPlan {
+	return {
+		planId: "plan-1",
+		steps: [
+			{
+				stepId: "step-1",
+				mode: "auto",
+				effectKind: "verification",
+				verifiesCriteriaIds: ["ac-1"],
+				goal: { kind: "verification", summary: "Run focused tests" },
+			},
+		],
+	};
+}
+
+describe("WorkItem domain action admission and application (D239/D333-D343) — sub 1", () => {
+	it("keeps proposals without admission from mutating WorkItem projections", () => {
+		const setup = setupActions();
+
+		setup.seed.down([["DATA", workItemCreatedFromDraft("wi-1", draft())]]);
+		setup.proposals.down([
+			[
+				"DATA",
+				workItemDomainActionProposalIntake("proposal-1", "wi-1", "patch", {
+					payload: { patch: { summary: "Changed too early" } },
+				}),
+			],
+		]);
+
+		expect(setup.appliedFacts).toEqual([]);
+		expect(setup.workItems.at(-1)).toMatchObject({
+			workItemId: "wi-1",
+			summary: "Ship verification",
+			authoringRevision: 1,
+		});
+	});
+
+	it("uses capability admission DATA facts to guard WorkItem domain-action admission", () => {
+		const g = graph();
+		const seed = g.node<WorkItemAuthoringInput>([], null, { name: "authoringFacts" });
+		const proposalInputs = g.node<WorkItemDomainActionProposalInput>([], null, {
+			name: "proposals",
+		});
+		const capabilityAdmissions = g.node<CapabilityAdmission>([], null, {
+			name: "capabilityAdmissions",
+		});
+		const guardPolicies = g.node<WorkItemDomainActionCapabilityGuardPolicy>([], null, {
+			name: "capabilityGuardPolicies",
+		});
+		const applyPolicies = g.node<WorkItemDomainActionApplyPolicy>([], null, {
+			name: "applyPolicies",
+		});
+		const authoring = workItemAuthoringProjector(g, { facts: seed });
+		const intake = workItemDomainActionProposalIntakeProjector(g, { proposals: proposalInputs });
+		const guard = workItemDomainActionCapabilityGuardProjector(g, {
+			proposals: intake.proposals,
+			capabilityAdmissions,
+			guardPolicies,
+			now: () => 123,
+		});
+		const admissions = workItemDomainActionAdmissionProjector(g, {
+			proposals: intake.proposals,
+			decisions: guard.decisions,
+		});
+		const application = workItemDomainActionApplicationProjector(g, {
+			proposals: intake.proposals,
+			admissions: admissions.admissions,
+			workItems: authoring.workItems,
+			applyPolicies,
+		});
+		const decisions = collectData<WorkItemDomainActionAdmissionDecision>(guard.decisions);
+		const guardStatus = collectData(guard.status);
+		const appliedFacts = collectData<WorkItemAuthoringFact>(application.authoringFacts);
+
+		seed.down([["DATA", workItemCreatedFromDraft("wi-1", draft())]]);
+		applyPolicies.down([
+			["DATA", workItemDomainActionApplyPolicy("apply-patch", { actionKinds: ["patch"] })],
+		]);
+		guardPolicies.down([
+			[
+				"DATA",
+				{
+					kind: "work-item-domain-action-capability-guard-policy",
+					policyId: "capability-ready",
+					actionKinds: ["patch"],
+					capabilityRefs: [capabilityRef("boundary-auth")],
+					admissionSubjectIds: ["boundary:boundary-auth"],
+				},
+			],
+		]);
+		proposalInputs.down([
+			[
+				"DATA",
+				workItemDomainActionProposalIntake("proposal-1", "wi-1", "patch", {
+					payload: { patch: { summary: "Patched after capability admission" } },
+					metadata: {
+						applyPolicyId: "apply-patch",
+						capabilityGuardPolicyId: "capability-ready",
+					},
+				}),
+			],
+		]);
+
+		expect(decisions).toEqual([]);
+		expect(guardStatus.at(-1)).toMatchObject({ state: "deferred" });
+
+		capabilityAdmissions.down([["DATA", capabilityAdmission("boundary-auth", "allowed")]]);
+
+		expect(decisions).toEqual([expect.objectContaining({ outcome: "admit" })]);
+		expect(decisions.at(-1)?.sourceRefs).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({ kind: "boundary-capability", id: "auth:boundary-auth" }),
+			]),
+		);
+		expect(decisions.at(-1)?.sourceRefs).not.toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({ kind: "boundary-capability", id: "boundary-auth" }),
+			]),
+		);
+		expect(appliedFacts.at(-1)).toMatchObject({
+			kind: "work-item-patched",
+			patch: { summary: "Patched after capability admission" },
+		});
+	});
+
+	it("turns blocked capability admission into WorkItem rejection status, not protocol ERROR", () => {
+		const g = graph();
+		const proposalInputs = g.node<WorkItemDomainActionProposalInput>([], null, {
+			name: "proposals",
+		});
+		const capabilityAdmissions = g.node<CapabilityAdmission>([], null, {
+			name: "capabilityAdmissions",
+		});
+		const guardPolicies = g.node<WorkItemDomainActionCapabilityGuardPolicy>([], null, {
+			name: "capabilityGuardPolicies",
+		});
+		const intake = workItemDomainActionProposalIntakeProjector(g, { proposals: proposalInputs });
+		const guard = workItemDomainActionCapabilityGuardProjector(g, {
+			proposals: intake.proposals,
+			capabilityAdmissions,
+			guardPolicies,
+			now: () => 123,
+		});
+		const decisions = collectData<WorkItemDomainActionAdmissionDecision>(guard.decisions);
+		const messages = collectMessages(guard.status);
+
+		guardPolicies.down([
+			[
+				"DATA",
+				{
+					kind: "work-item-domain-action-capability-guard-policy",
+					policyId: "capability-ready",
+					actionKinds: ["patch"],
+					capabilityRefs: [capabilityRef("boundary-auth")],
+					admissionSubjectIds: ["boundary:boundary-auth"],
+				},
+			],
+		]);
+		proposalInputs.down([
+			[
+				"DATA",
+				workItemDomainActionProposalIntake("proposal-1", "wi-1", "patch", {
+					metadata: { capabilityGuardPolicyId: "capability-ready" },
+				}),
+			],
+		]);
+		capabilityAdmissions.down([["DATA", capabilityAdmission("boundary-auth", "blocked")]]);
+
+		expect(decisions).toEqual([expect.objectContaining({ outcome: "reject" })]);
+		expect(messages.filter((msg) => msg[0] === "DATA")).not.toHaveLength(0);
+		expect(messages.some((msg) => msg[0] === "ERROR")).toBe(false);
+	});
+
+	it("keeps capability guard admission scoped by capability kind and subject", () => {
+		const g = graph();
+		const proposalInputs = g.node<WorkItemDomainActionProposalInput>([], null, {
+			name: "proposals",
+		});
+		const capabilityAdmissions = g.node<CapabilityAdmission>([], null, {
+			name: "capabilityAdmissions",
+		});
+		const guardPolicies = g.node<WorkItemDomainActionCapabilityGuardPolicy>([], null, {
+			name: "capabilityGuardPolicies",
+		});
+		const intake = workItemDomainActionProposalIntakeProjector(g, { proposals: proposalInputs });
+		const guard = workItemDomainActionCapabilityGuardProjector(g, {
+			proposals: intake.proposals,
+			capabilityAdmissions,
+			guardPolicies,
+			now: () => 123,
+		});
+		const decisions = collectData<WorkItemDomainActionAdmissionDecision>(guard.decisions);
+		const status = collectData(guard.status);
+
+		guardPolicies.down([
+			[
+				"DATA",
+				{
+					kind: "work-item-domain-action-capability-guard-policy",
+					policyId: "capability-ready",
+					actionKinds: ["patch"],
+					capabilityRefs: [capabilityRef("shared-id", "auth")],
+					admissionSubjectIds: ["boundary:expected"],
+				},
+			],
+		]);
+		proposalInputs.down([
+			[
+				"DATA",
+				workItemDomainActionProposalIntake("proposal-1", "wi-1", "patch", {
+					metadata: { capabilityGuardPolicyId: "capability-ready" },
+				}),
+			],
+		]);
+		capabilityAdmissions.down([
+			[
+				"DATA",
+				capabilityAdmission("shared-id", "allowed", {
+					kind: "resource",
+					subjectId: "boundary:expected",
+				}),
+			],
+			[
+				"DATA",
+				capabilityAdmission("shared-id", "allowed", {
+					kind: "auth",
+					subjectId: "boundary:other",
+				}),
+			],
+		]);
+
+		expect(decisions).toEqual([]);
+		expect(status.at(-1)).toMatchObject({
+			state: "deferred",
+			metadata: { missingCapabilityRefs: ["auth:shared-id"] },
+		});
+
+		capabilityAdmissions.down([
+			[
+				"DATA",
+				capabilityAdmission("shared-id", "allowed", {
+					kind: "auth",
+					subjectId: "boundary:expected",
+				}),
+			],
+		]);
+
+		expect(decisions).toEqual([expect.objectContaining({ outcome: "admit" })]);
+	});
+
+	it("replays capability admission issue statuses without capabilityId to guarded proposals", () => {
+		const g = graph();
+		const proposalInputs = g.node<WorkItemDomainActionProposalInput>([], null, {
+			name: "proposals",
+		});
+		const capabilityAdmissions = g.node<CapabilityAdmission>([], null, {
+			name: "capabilityAdmissions",
+		});
+		const guardPolicies = g.node<WorkItemDomainActionCapabilityGuardPolicy>([], null, {
+			name: "capabilityGuardPolicies",
+		});
+		const capabilityAdmissionStatus = g.node<CapabilityAdmissionStatus>([], null, {
+			name: "capabilityAdmissionStatus",
+		});
+		const intake = workItemDomainActionProposalIntakeProjector(g, { proposals: proposalInputs });
+		const guard = workItemDomainActionCapabilityGuardProjector(g, {
+			proposals: intake.proposals,
+			capabilityAdmissions,
+			guardPolicies,
+			capabilityAdmissionStatus,
+			now: () => 123,
+		});
+		const issues = collectData(guard.issues);
+		const statusMessages = collectMessages(guard.status);
+
+		capabilityAdmissionStatus.down([
+			[
+				"DATA",
+				{
+					kind: "capability-admission-status",
+					statusId: "capability-source-unavailable",
+					state: "capability-admission-issue",
+					issues: [
+						{
+							kind: "issue",
+							code: "capability-source-unavailable",
+							message: "Capability admission source unavailable",
+						},
+					],
+				},
+			],
+		]);
+		guardPolicies.down([
+			[
+				"DATA",
+				{
+					kind: "work-item-domain-action-capability-guard-policy",
+					policyId: "capability-ready",
+					actionKinds: ["patch"],
+					capabilityRefs: [capabilityRef("boundary-auth")],
+					admissionSubjectIds: ["boundary:boundary-auth"],
+				},
+			],
+		]);
+		proposalInputs.down([
+			[
+				"DATA",
+				workItemDomainActionProposalIntake("proposal-1", "wi-1", "patch", {
+					metadata: { capabilityGuardPolicyId: "capability-ready" },
+				}),
+			],
+		]);
+
+		expect(issues.at(-1)).toMatchObject({
+			code: "capability-source-unavailable",
+			metadata: { capabilityAdmissionStatusId: "capability-source-unavailable" },
+		});
+		expect(issues.at(-1)?.metadata).not.toHaveProperty("capabilityId");
+		expect(statusMessages.some((msg) => msg[0] === "ERROR")).toBe(false);
+	});
+
+	it("keeps capability admission issue statuses scoped by admission subject", () => {
+		const g = graph();
+		const proposalInputs = g.node<WorkItemDomainActionProposalInput>([], null, {
+			name: "proposals",
+		});
+		const capabilityAdmissions = g.node<CapabilityAdmission>([], null, {
+			name: "capabilityAdmissions",
+		});
+		const guardPolicies = g.node<WorkItemDomainActionCapabilityGuardPolicy>([], null, {
+			name: "capabilityGuardPolicies",
+		});
+		const capabilityAdmissionStatus = g.node<CapabilityAdmissionStatus>([], null, {
+			name: "capabilityAdmissionStatus",
+		});
+		const intake = workItemDomainActionProposalIntakeProjector(g, { proposals: proposalInputs });
+		const guard = workItemDomainActionCapabilityGuardProjector(g, {
+			proposals: intake.proposals,
+			capabilityAdmissions,
+			guardPolicies,
+			capabilityAdmissionStatus,
+			now: () => 123,
+		});
+		const issues = collectData(guard.issues);
+
+		guardPolicies.down([
+			[
+				"DATA",
+				{
+					kind: "work-item-domain-action-capability-guard-policy",
+					policyId: "capability-ready",
+					actionKinds: ["patch"],
+					capabilityRefs: [capabilityRef("boundary-auth")],
+					admissionSubjectIds: ["boundary:boundary-auth"],
+				},
+			],
+		]);
+		proposalInputs.down([
+			[
+				"DATA",
+				workItemDomainActionProposalIntake("proposal-1", "wi-1", "patch", {
+					metadata: { capabilityGuardPolicyId: "capability-ready" },
+				}),
+			],
+		]);
+
+		capabilityAdmissionStatus.down([
+			[
+				"DATA",
+				{
+					kind: "capability-admission-status",
+					statusId: "wrong-subject",
+					state: "capability-admission-issue",
+					subjectId: "boundary:other",
+					capabilityId: "boundary-auth",
+					capabilityKind: "auth",
+					issues: [
+						{
+							kind: "issue",
+							code: "wrong-subject-status",
+							message: "Wrong subject should not apply",
+						},
+					],
+				},
+			],
+		]);
+		expect(issues.map((issue) => issue.code)).not.toContain("wrong-subject-status");
+
+		capabilityAdmissionStatus.down([
+			[
+				"DATA",
+				{
+					kind: "capability-admission-status",
+					statusId: "matching-subject",
+					state: "capability-admission-issue",
+					subjectId: "boundary:boundary-auth",
+					capabilityId: "boundary-auth",
+					capabilityKind: "auth",
+					issues: [
+						{
+							kind: "issue",
+							code: "matching-subject-status",
+							message: "Matching subject should apply",
+						},
+					],
+				},
+			],
+		]);
+		expect(issues.at(-1)).toMatchObject({ code: "matching-subject-status" });
+	});
+
+	it("keeps malformed capability guard DATA as issues instead of implicit admission or ERROR", () => {
+		const g = graph();
+		const proposalInputs = g.node<WorkItemDomainActionProposalInput>([], null, {
+			name: "proposals",
+		});
+		const capabilityAdmissions = g.node<CapabilityAdmission>([], null, {
+			name: "capabilityAdmissions",
+		});
+		const guardPolicies = g.node<WorkItemDomainActionCapabilityGuardPolicy>([], null, {
+			name: "capabilityGuardPolicies",
+		});
+		const intake = workItemDomainActionProposalIntakeProjector(g, { proposals: proposalInputs });
+		const guard = workItemDomainActionCapabilityGuardProjector(g, {
+			proposals: intake.proposals,
+			capabilityAdmissions,
+			guardPolicies,
+			now: () => 123,
+		});
+		const decisions = collectData<WorkItemDomainActionAdmissionDecision>(guard.decisions);
+		const issues = collectData(guard.issues);
+		const statusMessages = collectMessages(guard.status);
+
+		guardPolicies.down([["DATA", null as unknown as WorkItemDomainActionCapabilityGuardPolicy]]);
+		guardPolicies.down([
+			[
+				"DATA",
+				{
+					kind: "work-item-domain-action-capability-guard-policy",
+					policyId: "capability-ready",
+					actionKinds: ["patch"],
+					capabilityRefs: [capabilityRef("boundary-auth")],
+					admissionSubjectIds: ["boundary:boundary-auth"],
+				},
+			],
+		]);
+		proposalInputs.down([
+			[
+				"DATA",
+				workItemDomainActionProposalIntake("proposal-1", "wi-1", "patch", {
+					metadata: { capabilityGuardPolicyId: "capability-ready" },
+				}),
+			],
+		]);
+		capabilityAdmissions.down([
+			[
+				"DATA",
+				{
+					...capabilityAdmission("boundary-auth", "allowed"),
+					state: "surprise",
+				} as unknown as CapabilityAdmission,
+			],
+		]);
+
+		expect(decisions).toEqual([]);
+		expect(issues.map((issue) => issue.code)).toEqual(
+			expect.arrayContaining([
+				"malformed-work-item-domain-action-capability-guard-policy",
+				"malformed-capability-admission",
+			]),
+		);
+		expect(statusMessages.some((msg) => msg[0] === "ERROR")).toBe(false);
+	});
+});
diff --git a/packages/ts/src/__tests__/work-item-actions.workitem-domain-action-admission-and-application-d239-d333-d343-part-01.sub-02.test.ts b/packages/ts/src/__tests__/work-item-actions.workitem-domain-action-admission-and-application-d239-d333-d343-part-01.sub-02.test.ts
new file mode 100644
index 00000000..50548f49
--- /dev/null
+++ b/packages/ts/src/__tests__/work-item-actions.workitem-domain-action-admission-and-application-d239-d333-d343-part-01.sub-02.test.ts
@@ -0,0 +1,573 @@
+import { describe, expect, it } from "vitest";
+import { depBatch } from "../ctx/types.js";
+import { graph } from "../graph/graph.js";
+import type { BoundaryCapabilityKind } from "../inspection/boundary.js";
+import type {
+	CapabilityAdmission,
+	CapabilityAdmissionStatus,
+} from "../solutions/capability-admission.js";
+import {
+	type WorkItemDomainActionAdmission,
+	type WorkItemDomainActionAdmissionDecision,
+	type WorkItemDomainActionApplyPolicy,
+	type WorkItemDomainActionCapabilityGuardPolicy,
+	type WorkItemDomainActionProposal,
+	type WorkItemDomainActionProposalInput,
+	workItemDomainActionAdmissionProjector,
+	workItemDomainActionApplicationProjector,
+	workItemDomainActionApplyPolicy,
+	workItemDomainActionCapabilityGuardProjector,
+	workItemDomainActionProposal,
+	workItemDomainActionProposalIntake,
+	workItemDomainActionProposalIntakeProjector,
+} from "../solutions/work-item/actions.js";
+import {
+	type VerificationPlan,
+	type WorkItemAuthoringFact,
+	type WorkItemAuthoringInput,
+	type WorkItemProjection,
+	workItemAuthoringProjector,
+	workItemCreatedFromDraft,
+} from "../solutions/work-item/scheduling.js";
+
+function setupActions() {
+	const g = graph();
+	const seed = g.node<WorkItemAuthoringInput>([], null, { name: "authoringFacts" });
+	const proposals = g.node<WorkItemDomainActionProposalInput>([], null, { name: "proposals" });
+	const decisions = g.node<WorkItemDomainActionAdmissionDecision>([], null, {
+		name: "admissionDecisions",
+	});
+	const directAdmissions = g.node<WorkItemDomainActionAdmission>([], null, {
+		name: "directAdmissions",
+	});
+	const applyPolicies = g.node<WorkItemDomainActionApplyPolicy>([], null, {
+		name: "applyPolicies",
+	});
+	const authoring = workItemAuthoringProjector(g, { facts: seed });
+	const intake = workItemDomainActionProposalIntakeProjector(g, { proposals });
+	const admissions = workItemDomainActionAdmissionProjector(g, {
+		proposals: intake.proposals,
+		decisions,
+	});
+	const admissionUnion = g.node<WorkItemDomainActionAdmission>(
+		[admissions.admissions, directAdmissions],
+		(ctx) => {
+			for (const raw of depBatch(ctx, 0) ?? []) ctx.down([["DATA", raw]]);
+			for (const raw of depBatch(ctx, 1) ?? []) ctx.down([["DATA", raw]]);
+		},
+		{ name: "admissionUnion", partial: true },
+	);
+	const application = workItemDomainActionApplicationProjector(g, {
+		proposals: intake.proposals,
+		admissions: admissionUnion,
+		workItems: authoring.workItems,
+		applyPolicies,
+	});
+	return {
+		seed,
+		proposals,
+		decisions,
+		directAdmissions,
+		applyPolicies,
+		workItems: collectData<WorkItemProjection>(authoring.workItems),
+		appliedFacts: collectData<WorkItemAuthoringFact>(application.authoringFacts),
+		applications: collectData(application.applications),
+		applicationStatus: collectData(application.status),
+		applicationIssues: collectData(application.issues),
+		intakeStatus: collectData(intake.status),
+		intakeIssues: collectData(intake.issues),
+		admissionIssues: collectData(admissions.issues),
+	};
+}
+
+function applyPatch(
+	setup: ReturnType<typeof setupActions>,
+	proposalId: string,
+	admissionId: string,
+	opts: {
+		readonly patch?: Record<string, unknown>;
+		readonly payload?: unknown;
+		readonly metadata?: Record<string, unknown>;
+	},
+): void {
+	setup.proposals.down([
+		[
+			"DATA",
+			workItemDomainActionProposalIntake(proposalId, "wi-1", "patch", {
+				payload: opts.payload ?? { patch: opts.patch },
+				metadata: opts.metadata,
+			}),
+		],
+	]);
+	setup.decisions.down([
+		["DATA", admissionDecision(`${admissionId}:decision`, admissionId, proposalId)],
+	]);
+}
+
+function admissionDecision(
+	decisionId: string,
+	admissionId: string,
+	proposalId: string,
+	outcome: WorkItemDomainActionAdmissionDecision["outcome"] = "admit",
+	opts: Partial<WorkItemDomainActionAdmissionDecision> = {},
+): WorkItemDomainActionAdmissionDecision {
+	return {
+		kind: "work-item-domain-action-admission-decision",
+		decisionId,
+		admissionId,
+		proposalId,
+		outcome,
+		...opts,
+	};
+}
+
+function capabilityAdmission(
+	capabilityId: string,
+	state: CapabilityAdmission["state"],
+	opts: {
+		readonly kind?: BoundaryCapabilityKind;
+		readonly subjectId?: string;
+	} = {},
+): CapabilityAdmission {
+	return {
+		kind: "capability-admission",
+		admissionId: `capability-admission:${opts.kind ?? "auth"}:${capabilityId}:${opts.subjectId ?? `boundary:${capabilityId}`}:${state}`,
+		proposalId: `capability-proposal:${capabilityId}`,
+		subjectId: opts.subjectId ?? `boundary:${capabilityId}`,
+		capability: capabilityRef(capabilityId, opts.kind),
+		state,
+		decisionId: `capability-decision:${capabilityId}:${state}`,
+	};
+}
+
+function capabilityRef(capabilityId: string, kind: BoundaryCapabilityKind = "auth") {
+	return { id: capabilityId, kind, required: true };
+}
+
+function collectData<T>(node: {
+	subscribe(sink: (msg: readonly [string, unknown?]) => void): unknown;
+}): T[] {
+	const out: T[] = [];
+	node.subscribe((msg) => {
+		if (msg[0] === "DATA") out.push(msg[1] as T);
+	});
+	return out;
+}
+
+function collectMessages(node: {
+	subscribe(sink: (msg: readonly [string, unknown?]) => void): unknown;
+}) {
+	const out: (readonly [string, unknown?])[] = [];
+	node.subscribe((msg) => out.push(msg));
+	return out;
+}
+
+function draft(opts: Partial<ReturnType<typeof baseDraft>> = {}) {
+	return { ...baseDraft(), ...opts };
+}
+
+function baseDraft() {
+	return {
+		summary: "Ship verification",
+		detail: "Make WorkItem actions explicit.",
+		acceptanceCriteria: [{ criterionId: "ac-1", statement: "Focused tests pass", required: true }],
+		verificationPlan: plan(),
+		tags: ["work-item"],
+		metadata: { color: "green" },
+	};
+}
+
+function plan(): VerificationPlan {
+	return {
+		planId: "plan-1",
+		steps: [
+			{
+				stepId: "step-1",
+				mode: "auto",
+				effectKind: "verification",
+				verifiesCriteriaIds: ["ac-1"],
+				goal: { kind: "verification", summary: "Run focused tests" },
+			},
+		],
+	};
+}
+
+describe("WorkItem domain action admission and application (D239/D333-D343) — sub 2", () => {
+	it("rejects malformed capability guard optional refs and nested issues as DATA issues", () => {
+		const g = graph();
+		const proposalInputs = g.node<WorkItemDomainActionProposalInput>([], null, {
+			name: "proposals",
+		});
+		const capabilityAdmissions = g.node<CapabilityAdmission>([], null, {
+			name: "capabilityAdmissions",
+		});
+		const guardPolicies = g.node<WorkItemDomainActionCapabilityGuardPolicy>([], null, {
+			name: "capabilityGuardPolicies",
+		});
+		const capabilityAdmissionStatus = g.node<CapabilityAdmissionStatus>([], null, {
+			name: "capabilityAdmissionStatus",
+		});
+		const intake = workItemDomainActionProposalIntakeProjector(g, { proposals: proposalInputs });
+		const guard = workItemDomainActionCapabilityGuardProjector(g, {
+			proposals: intake.proposals,
+			capabilityAdmissions,
+			guardPolicies,
+			capabilityAdmissionStatus,
+			now: () => 123,
+		});
+		const decisions = collectData<WorkItemDomainActionAdmissionDecision>(guard.decisions);
+		const issues = collectData(guard.issues);
+		const statusMessages = collectMessages(guard.status);
+
+		guardPolicies.down([
+			[
+				"DATA",
+				{
+					kind: "work-item-domain-action-capability-guard-policy",
+					policyId: "capability-ready",
+					actionKinds: ["patch"],
+					capabilityRefs: [capabilityRef("boundary-auth")],
+					admissionSubjectIds: ["boundary:boundary-auth"],
+				},
+			],
+		]);
+		proposalInputs.down([
+			[
+				"DATA",
+				workItemDomainActionProposalIntake("proposal-1", "wi-1", "patch", {
+					metadata: { capabilityGuardPolicyId: "capability-ready" },
+				}),
+			],
+		]);
+		capabilityAdmissions.down([
+			[
+				"DATA",
+				{
+					...capabilityAdmission("boundary-auth", "allowed"),
+					sourceRefs: { kind: "not-an-array", id: "bad" },
+				} as unknown as CapabilityAdmission,
+			],
+		]);
+		capabilityAdmissionStatus.down([
+			[
+				"DATA",
+				{
+					kind: "capability-admission-status",
+					statusId: "bad-status-issue",
+					state: "capability-admission-issue",
+					capabilityId: "boundary-auth",
+					issues: [{}],
+				} as unknown as CapabilityAdmissionStatus,
+			],
+			[
+				"DATA",
+				{
+					kind: "capability-admission-status",
+					statusId: "bad-status-kind-only",
+					state: "capability-admission-issue",
+					capabilityKind: "auth",
+				} as unknown as CapabilityAdmissionStatus,
+			],
+		]);
+
+		expect(decisions).toEqual([]);
+		expect(issues.map((issue) => issue.code)).toEqual(
+			expect.arrayContaining([
+				"malformed-capability-admission",
+				"malformed-capability-admission-status",
+			]),
+		);
+		expect(statusMessages.some((msg) => msg[0] === "ERROR")).toBe(false);
+	});
+
+	it("keeps admission alone from mutating WorkItem projections", () => {
+		const setup = setupActions();
+
+		setup.seed.down([["DATA", workItemCreatedFromDraft("wi-1", draft())]]);
+		setup.directAdmissions.down([
+			[
+				"DATA",
+				{
+					kind: "work-item-domain-action-admission",
+					admissionId: "admission-without-proposal",
+					proposalId: "missing-proposal",
+					workItemId: "wi-1",
+					actionKind: "patch",
+					state: "admitted",
+					decisionId: "decision-1",
+				} satisfies WorkItemDomainActionAdmission,
+			],
+		]);
+
+		expect(setup.appliedFacts).toEqual([]);
+		expect(setup.applicationIssues.at(-1)).toMatchObject({
+			code: "dangling-ref",
+			subjectId: "wi-1",
+		});
+		expect(setup.workItems.at(-1)).toMatchObject({ authoringRevision: 1 });
+	});
+
+	it("rejects admissions whose action refs do not match their proposal", () => {
+		const g = graph();
+		const seed = g.node<WorkItemAuthoringInput>([], null, { name: "authoringFacts" });
+		const proposals = g.node<WorkItemDomainActionProposal>([], null, { name: "rawProposals" });
+		const admissions = g.node<WorkItemDomainActionAdmission>([], null, { name: "rawAdmissions" });
+		const applyPolicies = g.node<WorkItemDomainActionApplyPolicy>([], null, {
+			name: "applyPolicies",
+		});
+		const authoring = workItemAuthoringProjector(g, { facts: seed });
+		const application = workItemDomainActionApplicationProjector(g, {
+			proposals,
+			admissions,
+			workItems: authoring.workItems,
+			applyPolicies,
+		});
+		const appliedFacts = collectData<WorkItemAuthoringFact>(application.authoringFacts);
+		const applicationIssues = collectData(application.issues);
+		const applicationStatus = collectData(application.status);
+
+		seed.down([["DATA", workItemCreatedFromDraft("wi-1", draft())]]);
+		seed.down([["DATA", workItemCreatedFromDraft("wi-2", draft({ summary: "Other" }))]]);
+		applyPolicies.down([
+			["DATA", workItemDomainActionApplyPolicy("apply-patch", { actionKinds: ["patch"] })],
+		]);
+		proposals.down([
+			[
+				"DATA",
+				workItemDomainActionProposal("proposal-mismatch", "wi-1", "patch", {
+					payload: { patch: { summary: "Must not hit wi-2" } },
+					metadata: { executionInputRevision: 1, applyPolicyId: "apply-patch" },
+				}),
+			],
+		]);
+		admissions.down([
+			[
+				"DATA",
+				{
+					kind: "work-item-domain-action-admission",
+					admissionId: "admission-mismatch",
+					proposalId: "proposal-mismatch",
+					workItemId: "wi-2",
+					actionKind: "patch",
+					state: "admitted",
+					decisionId: "decision-mismatch",
+				} satisfies WorkItemDomainActionAdmission,
+			],
+		]);
+
+		expect(appliedFacts).toEqual([]);
+		expect(applicationIssues.at(-1)).toMatchObject({
+			code: "dangling-ref",
+			subjectId: "wi-2",
+		});
+		expect(applicationStatus.at(-1)).toMatchObject({ state: "rejected" });
+	});
+
+	it("lowers admitted patch actions to WorkItemPatched and advances revisions only after re-entry", () => {
+		const setup = setupActions();
+		setup.seed.down([["DATA", workItemCreatedFromDraft("wi-1", draft())]]);
+		setup.applyPolicies.down([
+			["DATA", workItemDomainActionApplyPolicy("apply-patch", { actionKinds: ["patch"] })],
+		]);
+
+		setup.proposals.down([
+			[
+				"DATA",
+				workItemDomainActionProposalIntake("proposal-1", "wi-1", "patch", {
+					payload: { patch: { summary: "Patched summary" } },
+					metadata: { executionInputRevision: 1, applyPolicyId: "apply-patch" },
+				}),
+			],
+		]);
+		setup.decisions.down([["DATA", admissionDecision("decision-1", "admission-1", "proposal-1")]]);
+
+		expect(setup.appliedFacts.at(-1)).toMatchObject({
+			kind: "work-item-patched",
+			workItemId: "wi-1",
+			patch: { summary: "Patched summary" },
+		});
+		expect(setup.workItems.at(-1)).toMatchObject({
+			summary: "Ship verification",
+			authoringRevision: 1,
+		});
+
+		setup.seed.down([["DATA", setup.appliedFacts.at(-1) as WorkItemAuthoringFact]]);
+
+		expect(setup.workItems.at(-1)).toMatchObject({
+			summary: "Patched summary",
+			authoringRevision: 2,
+			executionInputRevision: 1,
+		});
+	});
+
+	it("splits acceptance criteria and verification plan out of generic patch actions", () => {
+		const setup = setupActions();
+		setup.seed.down([["DATA", workItemCreatedFromDraft("wi-1", draft())]]);
+		setup.applyPolicies.down([
+			["DATA", workItemDomainActionApplyPolicy("apply-patch", { actionKinds: ["patch"] })],
+		]);
+
+		setup.proposals.down([
+			[
+				"DATA",
+				workItemDomainActionProposalIntake("proposal-dedicated", "wi-1", "patch", {
+					payload: {
+						patch: {
+							summary: "Split patch",
+							acceptanceCriteria: [
+								{ criterionId: "ac-2", statement: "Dedicated AC fact", required: true },
+							],
+							verificationPlan: {
+								planId: "plan-2",
+								steps: [
+									{
+										stepId: "step-2",
+										mode: "auto",
+										effectKind: "verification",
+										verifiesCriteriaIds: ["ac-2"],
+									},
+								],
+							},
+						},
+					},
+					metadata: { executionInputRevision: 1, applyPolicyId: "apply-patch" },
+				}),
+			],
+		]);
+		setup.decisions.down([
+			[
+				"DATA",
+				admissionDecision("decision-dedicated", "admission-dedicated", "proposal-dedicated"),
+			],
+		]);
+
+		expect(setup.appliedFacts.map((fact) => fact.kind)).toEqual([
+			"work-item-patched",
+			"acceptance-criteria-changed",
+			"verification-plan-changed",
+		]);
+		expect(setup.appliedFacts[0]).toMatchObject({
+			kind: "work-item-patched",
+			patch: { summary: "Split patch" },
+		});
+	});
+
+	it("keeps inline patch fields when action payload also carries dedicated authoring facts", () => {
+		const setup = setupActions();
+		setup.seed.down([["DATA", workItemCreatedFromDraft("wi-1", draft())]]);
+		setup.applyPolicies.down([
+			["DATA", workItemDomainActionApplyPolicy("apply-patch", { actionKinds: ["patch"] })],
+		]);
+
+		setup.proposals.down([
+			[
+				"DATA",
+				workItemDomainActionProposalIntake("proposal-inline-dedicated", "wi-1", "patch", {
+					payload: {
+						summary: "Inline split patch",
+						acceptanceCriteria: [
+							{ criterionId: "ac-inline", statement: "Inline AC fact", required: true },
+						],
+					},
+					metadata: { executionInputRevision: 1, applyPolicyId: "apply-patch" },
+				}),
+			],
+		]);
+		setup.decisions.down([
+			[
+				"DATA",
+				admissionDecision(
+					"decision-inline-dedicated",
+					"admission-inline-dedicated",
+					"proposal-inline-dedicated",
+				),
+			],
+		]);
+
+		expect(setup.appliedFacts.map((fact) => fact.kind)).toEqual([
+			"work-item-patched",
+			"acceptance-criteria-changed",
+		]);
+		expect(setup.appliedFacts[0]).toMatchObject({
+			kind: "work-item-patched",
+			patch: { summary: "Inline split patch" },
+		});
+	});
+
+	it("rejects dedicated authoring fields that are outside a patch allowlist", () => {
+		const setup = setupActions();
+		setup.seed.down([["DATA", workItemCreatedFromDraft("wi-1", draft())]]);
+		setup.applyPolicies.down([
+			[
+				"DATA",
+				workItemDomainActionApplyPolicy("apply-patch", {
+					actionKinds: ["patch"],
+					patch: { allowedFields: ["summary"] },
+				}),
+			],
+		]);
+
+		setup.proposals.down([
+			[
+				"DATA",
+				workItemDomainActionProposalIntake("proposal-ac-blocked", "wi-1", "patch", {
+					payload: {
+						summary: "Allowed alone",
+						acceptanceCriteria: [
+							{ criterionId: "ac-blocked", statement: "Should be blocked", required: true },
+						],
+					},
+					metadata: { executionInputRevision: 1, applyPolicyId: "apply-patch" },
+				}),
+			],
+		]);
+		setup.decisions.down([
+			[
+				"DATA",
+				admissionDecision("decision-ac-blocked", "admission-ac-blocked", "proposal-ac-blocked"),
+			],
+		]);
+
+		expect(setup.appliedFacts).toEqual([]);
+		expect(setup.applicationIssues.at(-1)).toMatchObject({ code: "policy-mismatch" });
+		expect(setup.applicationStatus.at(-1)).toMatchObject({ state: "rejected" });
+	});
+
+	it("preserves executionInputRevision for metadata-only patch unless policy marks it relevant", () => {
+		const setup = setupActions();
+		setup.seed.down([["DATA", workItemCreatedFromDraft("wi-1", draft())]]);
+		setup.applyPolicies.down([
+			["DATA", workItemDomainActionApplyPolicy("apply-patch", { actionKinds: ["patch"] })],
+		]);
+
+		applyPatch(setup, "proposal-meta", "admission-meta", {
+			patch: { metadata: { color: "blue" } },
+			metadata: { executionInputRevision: 1, applyPolicyId: "apply-patch" },
+		});
+		setup.seed.down([["DATA", setup.appliedFacts.at(-1) as WorkItemAuthoringFact]]);
+		expect(setup.workItems.at(-1)).toMatchObject({
+			authoringRevision: 2,
+			executionInputRevision: 1,
+		});
+
+		setup.applyPolicies.down([
+			[
+				"DATA",
+				workItemDomainActionApplyPolicy("apply-patch", {
+					actionKinds: ["patch"],
+					patch: { executionRelevantFields: ["metadata.color"] },
+				}),
+			],
+		]);
+		applyPatch(setup, "proposal-relevant", "admission-relevant", {
+			patch: { metadata: { color: "red" } },
+			metadata: { executionInputRevision: 1, applyPolicyId: "apply-patch" },
+		});
+		setup.seed.down([["DATA", setup.appliedFacts.at(-1) as WorkItemAuthoringFact]]);
+
+		expect(setup.workItems.at(-1)).toMatchObject({
+			authoringRevision: 3,
+			executionInputRevision: 2,
+		});
+	});
+});
diff --git a/packages/ts/src/__tests__/work-item-actions.workitem-domain-action-admission-and-application-d239-d333-d343-part-02.test.ts b/packages/ts/src/__tests__/work-item-actions.workitem-domain-action-admission-and-application-d239-d333-d343-part-02.test.ts
new file mode 100644
index 00000000..c5730359
--- /dev/null
+++ b/packages/ts/src/__tests__/work-item-actions.workitem-domain-action-admission-and-application-d239-d333-d343-part-02.test.ts
@@ -0,0 +1,511 @@
+import { describe, expect, it } from "vitest";
+import { depBatch } from "../ctx/types.js";
+import { graph } from "../graph/graph.js";
+import type { BoundaryCapabilityKind } from "../inspection/boundary.js";
+import type { CapabilityAdmission } from "../solutions/capability-admission.js";
+import {
+	type WorkItemDomainActionAdmission,
+	type WorkItemDomainActionAdmissionDecision,
+	type WorkItemDomainActionApplyPolicy,
+	type WorkItemDomainActionProposalInput,
+	workItemDomainActionAdmissionProjector,
+	workItemDomainActionApplicationProjector,
+	workItemDomainActionApplyPolicy,
+	workItemDomainActionProposalIntake,
+	workItemDomainActionProposalIntakeProjector,
+} from "../solutions/work-item/actions.js";
+import {
+	type VerificationPlan,
+	type WorkItemAuthoringFact,
+	type WorkItemAuthoringInput,
+	type WorkItemProjection,
+	workItemAuthoringProjector,
+	workItemCreatedFromDraft,
+} from "../solutions/work-item/scheduling.js";
+
+function setupActions() {
+	const g = graph();
+	const seed = g.node<WorkItemAuthoringInput>([], null, { name: "authoringFacts" });
+	const proposals = g.node<WorkItemDomainActionProposalInput>([], null, { name: "proposals" });
+	const decisions = g.node<WorkItemDomainActionAdmissionDecision>([], null, {
+		name: "admissionDecisions",
+	});
+	const directAdmissions = g.node<WorkItemDomainActionAdmission>([], null, {
+		name: "directAdmissions",
+	});
+	const applyPolicies = g.node<WorkItemDomainActionApplyPolicy>([], null, {
+		name: "applyPolicies",
+	});
+	const authoring = workItemAuthoringProjector(g, { facts: seed });
+	const intake = workItemDomainActionProposalIntakeProjector(g, { proposals });
+	const admissions = workItemDomainActionAdmissionProjector(g, {
+		proposals: intake.proposals,
+		decisions,
+	});
+	const admissionUnion = g.node<WorkItemDomainActionAdmission>(
+		[admissions.admissions, directAdmissions],
+		(ctx) => {
+			for (const raw of depBatch(ctx, 0) ?? []) ctx.down([["DATA", raw]]);
+			for (const raw of depBatch(ctx, 1) ?? []) ctx.down([["DATA", raw]]);
+		},
+		{ name: "admissionUnion", partial: true },
+	);
+	const application = workItemDomainActionApplicationProjector(g, {
+		proposals: intake.proposals,
+		admissions: admissionUnion,
+		workItems: authoring.workItems,
+		applyPolicies,
+	});
+	return {
+		seed,
+		proposals,
+		decisions,
+		directAdmissions,
+		applyPolicies,
+		workItems: collectData<WorkItemProjection>(authoring.workItems),
+		appliedFacts: collectData<WorkItemAuthoringFact>(application.authoringFacts),
+		applications: collectData(application.applications),
+		applicationStatus: collectData(application.status),
+		applicationIssues: collectData(application.issues),
+		intakeStatus: collectData(intake.status),
+		intakeIssues: collectData(intake.issues),
+		admissionIssues: collectData(admissions.issues),
+	};
+}
+
+function applyPatch(
+	setup: ReturnType<typeof setupActions>,
+	proposalId: string,
+	admissionId: string,
+	opts: {
+		readonly patch?: Record<string, unknown>;
+		readonly payload?: unknown;
+		readonly metadata?: Record<string, unknown>;
+	},
+): void {
+	setup.proposals.down([
+		[
+			"DATA",
+			workItemDomainActionProposalIntake(proposalId, "wi-1", "patch", {
+				payload: opts.payload ?? { patch: opts.patch },
+				metadata: opts.metadata,
+			}),
+		],
+	]);
+	setup.decisions.down([
+		["DATA", admissionDecision(`${admissionId}:decision`, admissionId, proposalId)],
+	]);
+}
+
+function admissionDecision(
+	decisionId: string,
+	admissionId: string,
+	proposalId: string,
+	outcome: WorkItemDomainActionAdmissionDecision["outcome"] = "admit",
+	opts: Partial<WorkItemDomainActionAdmissionDecision> = {},
+): WorkItemDomainActionAdmissionDecision {
+	return {
+		kind: "work-item-domain-action-admission-decision",
+		decisionId,
+		admissionId,
+		proposalId,
+		outcome,
+		...opts,
+	};
+}
+
+function _capabilityAdmission(
+	capabilityId: string,
+	state: CapabilityAdmission["state"],
+	opts: {
+		readonly kind?: BoundaryCapabilityKind;
+		readonly subjectId?: string;
+	} = {},
+): CapabilityAdmission {
+	return {
+		kind: "capability-admission",
+		admissionId: `capability-admission:${opts.kind ?? "auth"}:${capabilityId}:${opts.subjectId ?? `boundary:${capabilityId}`}:${state}`,
+		proposalId: `capability-proposal:${capabilityId}`,
+		subjectId: opts.subjectId ?? `boundary:${capabilityId}`,
+		capability: capabilityRef(capabilityId, opts.kind),
+		state,
+		decisionId: `capability-decision:${capabilityId}:${state}`,
+	};
+}
+
+function capabilityRef(capabilityId: string, kind: BoundaryCapabilityKind = "auth") {
+	return { id: capabilityId, kind, required: true };
+}
+
+function collectData<T>(node: {
+	subscribe(sink: (msg: readonly [string, unknown?]) => void): unknown;
+}): T[] {
+	const out: T[] = [];
+	node.subscribe((msg) => {
+		if (msg[0] === "DATA") out.push(msg[1] as T);
+	});
+	return out;
+}
+
+function _collectMessages(node: {
+	subscribe(sink: (msg: readonly [string, unknown?]) => void): unknown;
+}) {
+	const out: (readonly [string, unknown?])[] = [];
+	node.subscribe((msg) => out.push(msg));
+	return out;
+}
+
+function draft(opts: Partial<ReturnType<typeof baseDraft>> = {}) {
+	return { ...baseDraft(), ...opts };
+}
+
+function baseDraft() {
+	return {
+		summary: "Ship verification",
+		detail: "Make WorkItem actions explicit.",
+		acceptanceCriteria: [{ criterionId: "ac-1", statement: "Focused tests pass", required: true }],
+		verificationPlan: plan(),
+		tags: ["work-item"],
+		metadata: { color: "green" },
+	};
+}
+
+function plan(): VerificationPlan {
+	return {
+		planId: "plan-1",
+		steps: [
+			{
+				stepId: "step-1",
+				mode: "auto",
+				effectKind: "verification",
+				verifiesCriteriaIds: ["ac-1"],
+				goal: { kind: "verification", summary: "Run focused tests" },
+			},
+		],
+	};
+}
+describe("WorkItem domain action admission and application (D239/D333-D343) — part 2", () => {
+	it("records admitted verification actions visibly without closing lifecycle magically", () => {
+		const setup = setupActions();
+		setup.seed.down([["DATA", workItemCreatedFromDraft("wi-1", draft())]]);
+		setup.applyPolicies.down([
+			["DATA", workItemDomainActionApplyPolicy("apply-verify", { actionKinds: ["mark-verified"] })],
+		]);
+
+		setup.proposals.down([
+			[
+				"DATA",
+				workItemDomainActionProposalIntake("proposal-verify", "wi-1", "mark-verified", {
+					metadata: { executionInputRevision: 1, applyPolicyId: "apply-verify" },
+				}),
+			],
+		]);
+		setup.decisions.down([
+			["DATA", admissionDecision("decision-verify", "admission-verify", "proposal-verify")],
+		]);
+
+		expect(setup.appliedFacts).toEqual([]);
+		expect(setup.applications.at(-1)).toMatchObject({
+			state: "proposal-only",
+			actionKind: "mark-verified",
+			producedFactIds: [],
+		});
+		expect(setup.applicationStatus.at(-1)).toMatchObject({
+			state: "proposal-only",
+			actionKind: "mark-verified",
+		});
+		expect(setup.workItems.at(-1)).toMatchObject({ authoringRevision: 1 });
+	});
+
+	it("emits stale issues for admitted actions targeting old revision coordinates", () => {
+		const setup = setupActions();
+		setup.seed.down([["DATA", workItemCreatedFromDraft("wi-1", draft())]]);
+		setup.seed.down([
+			[
+				"DATA",
+				{
+					kind: "work-item-patched",
+					eventId: "wi-1:detail",
+					workItemId: "wi-1",
+					patch: { detail: "Changed before admission" },
+				},
+			],
+		]);
+		setup.applyPolicies.down([
+			["DATA", workItemDomainActionApplyPolicy("apply-patch", { actionKinds: ["patch"] })],
+		]);
+
+		applyPatch(setup, "proposal-stale", "admission-stale", {
+			patch: { summary: "Too old" },
+			metadata: { executionInputRevision: 1, applyPolicyId: "apply-patch" },
+		});
+
+		expect(setup.appliedFacts).toEqual([]);
+		expect(setup.applicationIssues.at(-1)).toMatchObject({ code: "stale-execution-input" });
+		expect(setup.applicationStatus.at(-1)).toMatchObject({
+			state: "rejected",
+			code: "stale-execution-input",
+		});
+	});
+
+	it("rejects conflicting proposal and admission revision metadata visibly", () => {
+		const setup = setupActions();
+		setup.seed.down([["DATA", workItemCreatedFromDraft("wi-1", draft())]]);
+		setup.applyPolicies.down([
+			["DATA", workItemDomainActionApplyPolicy("apply-patch", { actionKinds: ["patch"] })],
+		]);
+		setup.proposals.down([
+			[
+				"DATA",
+				workItemDomainActionProposalIntake("proposal-conflict", "wi-1", "patch", {
+					payload: { patch: { summary: "Conflicting refs" } },
+					metadata: { executionInputRevision: 1, applyPolicyId: "apply-patch" },
+				}),
+			],
+		]);
+		setup.decisions.down([
+			[
+				"DATA",
+				admissionDecision("decision-conflict", "admission-conflict", "proposal-conflict", "admit", {
+					metadata: { executionInputRevision: 2 },
+				}),
+			],
+		]);
+
+		expect(setup.appliedFacts).toEqual([]);
+		expect(setup.applicationIssues.at(-1)).toMatchObject({ code: "stale-execution-input" });
+		expect(setup.applicationStatus.at(-1)).toMatchObject({ state: "rejected" });
+	});
+
+	it("suppresses duplicate proposal and admission application visibly", () => {
+		const setup = setupActions();
+		setup.seed.down([["DATA", workItemCreatedFromDraft("wi-1", draft())]]);
+		setup.applyPolicies.down([
+			["DATA", workItemDomainActionApplyPolicy("apply-patch", { actionKinds: ["patch"] })],
+		]);
+		const proposal = workItemDomainActionProposalIntake("proposal-dup", "wi-1", "patch", {
+			payload: { patch: { summary: "Once" } },
+			metadata: { executionInputRevision: 1, applyPolicyId: "apply-patch" },
+		});
+
+		setup.proposals.down([
+			["DATA", proposal],
+			["DATA", proposal],
+		]);
+		setup.decisions.down([
+			["DATA", admissionDecision("decision-dup", "admission-dup", "proposal-dup")],
+			["DATA", admissionDecision("decision-dup", "admission-dup", "proposal-dup")],
+		]);
+
+		expect(setup.appliedFacts).toHaveLength(1);
+		expect(setup.intakeStatus.map((status) => status.state)).toContain("duplicate");
+		expect(setup.admissionIssues.at(-1)).toMatchObject({
+			code: "duplicate-work-item-domain-action-admission-decision",
+		});
+	});
+
+	it("emits missing or invalid apply policy as visible status without lowering facts", () => {
+		const setup = setupActions();
+		setup.seed.down([["DATA", workItemCreatedFromDraft("wi-1", draft())]]);
+
+		applyPatch(setup, "proposal-no-policy", "admission-no-policy", {
+			patch: { summary: "No policy" },
+			metadata: { executionInputRevision: 1 },
+		});
+
+		expect(setup.appliedFacts).toEqual([]);
+		expect(setup.applicationIssues.at(-1)).toMatchObject({ code: "missing-policy" });
+		expect(setup.applicationStatus.at(-1)).toMatchObject({ state: "missing-policy" });
+	});
+
+	it("makes invalid patch validation terminal instead of re-emitting on later waves", () => {
+		const setup = setupActions();
+		setup.seed.down([["DATA", workItemCreatedFromDraft("wi-1", draft())]]);
+		setup.applyPolicies.down([
+			["DATA", workItemDomainActionApplyPolicy("apply-patch", { actionKinds: ["patch"] })],
+		]);
+
+		applyPatch(setup, "proposal-bad-ac", "admission-bad-ac", {
+			payload: { acceptanceCriteria: [{ statement: "missing id" }] },
+			metadata: { executionInputRevision: 1, applyPolicyId: "apply-patch" },
+		});
+		const issueCount = setup.applicationIssues.length;
+		const statusCount = setup.applicationStatus.length;
+
+		setup.applyPolicies.down([
+			[
+				"DATA",
+				workItemDomainActionApplyPolicy("apply-patch-extra", { actionKinds: ["require-review"] }),
+			],
+		]);
+
+		expect(setup.appliedFacts).toEqual([]);
+		expect(setup.applicationIssues).toHaveLength(issueCount);
+		expect(setup.applicationStatus).toHaveLength(statusCount);
+	});
+
+	it("rejects multi-fact patch actions atomically when any event id was already emitted", () => {
+		const setup = setupActions();
+		setup.seed.down([["DATA", workItemCreatedFromDraft("wi-1", draft())]]);
+		setup.applyPolicies.down([
+			["DATA", workItemDomainActionApplyPolicy("apply-patch", { actionKinds: ["patch"] })],
+		]);
+
+		applyPatch(setup, "proposal-first-event", "admission-first-event", {
+			payload: { patch: { summary: "First" }, eventId: "shared-event" },
+			metadata: { executionInputRevision: 1, applyPolicyId: "apply-patch" },
+		});
+		applyPatch(setup, "proposal-colliding-event", "admission-colliding-event", {
+			payload: {
+				patch: {
+					summary: "Second",
+					acceptanceCriteria: [
+						{ criterionId: "ac-collision", statement: "Must not partially apply", required: true },
+					],
+				},
+				eventId: "shared-event",
+			},
+			metadata: { executionInputRevision: 1, applyPolicyId: "apply-patch" },
+		});
+
+		expect(setup.appliedFacts).toHaveLength(1);
+		expect(setup.appliedFacts[0]).toMatchObject({ eventId: "shared-event" });
+		expect(setup.applicationIssues.at(-1)).toMatchObject({ code: "duplicate-suppressed" });
+		expect(setup.applicationStatus.at(-1)).toMatchObject({ state: "duplicate" });
+	});
+
+	it("lowers admitted spawn actions to WorkItemCreated only under explicit create policy", () => {
+		const setup = setupActions();
+		setup.seed.down([["DATA", workItemCreatedFromDraft("wi-parent", draft())]]);
+		setup.applyPolicies.down([
+			["DATA", workItemDomainActionApplyPolicy("spawn-review", { actionKinds: ["spawn-child"] })],
+		]);
+		setup.proposals.down([
+			[
+				"DATA",
+				workItemDomainActionProposalIntake("spawn-1", "wi-parent", "spawn-child", {
+					payload: { childWorkItemId: "wi-child", draft: draft({ summary: "Child" }) },
+					metadata: { executionInputRevision: 1, applyPolicyId: "spawn-review" },
+				}),
+			],
+		]);
+		setup.decisions.down([
+			["DATA", admissionDecision("spawn-decision", "spawn-admission", "spawn-1")],
+		]);
+
+		expect(setup.appliedFacts).toEqual([]);
+		expect(setup.applications.at(-1)).toMatchObject({ state: "proposal-only" });
+
+		const incompleteCreateSetup = setupActions();
+		incompleteCreateSetup.seed.down([["DATA", workItemCreatedFromDraft("wi-parent", draft())]]);
+		incompleteCreateSetup.applyPolicies.down([
+			[
+				"DATA",
+				workItemDomainActionApplyPolicy("spawn-create", {
+					actionKinds: ["spawn-child"],
+					spawn: { create: true },
+				}),
+			],
+		]);
+		incompleteCreateSetup.proposals.down([
+			[
+				"DATA",
+				workItemDomainActionProposalIntake("spawn-create", "wi-parent", "spawn-child", {
+					payload: { childWorkItemId: "wi-child", draft: draft({ summary: "Child" }) },
+					metadata: { executionInputRevision: 1, applyPolicyId: "spawn-create" },
+				}),
+			],
+		]);
+		incompleteCreateSetup.decisions.down([
+			[
+				"DATA",
+				admissionDecision("spawn-create-decision", "spawn-create-admission", "spawn-create"),
+			],
+		]);
+
+		expect(incompleteCreateSetup.appliedFacts).toEqual([]);
+		expect(incompleteCreateSetup.applicationIssues.at(-1)).toMatchObject({
+			code: "policy-mismatch",
+		});
+		expect(incompleteCreateSetup.applications.at(-1)).toMatchObject({
+			state: "policy-rejected",
+			producedFactIds: [],
+		});
+
+		const createSetup = setupActions();
+		createSetup.seed.down([["DATA", workItemCreatedFromDraft("wi-parent", draft())]]);
+		createSetup.applyPolicies.down([
+			[
+				"DATA",
+				workItemDomainActionApplyPolicy("spawn-create-complete", {
+					actionKinds: ["spawn-child"],
+					spawn: {
+						create: true,
+						linkParent: true,
+						idempotencyKey: "spawn:create:wi-child",
+						maxChildrenPerAdmission: 1,
+					},
+				}),
+			],
+		]);
+		createSetup.proposals.down([
+			[
+				"DATA",
+				workItemDomainActionProposalIntake("spawn-create-complete", "wi-parent", "spawn-child", {
+					payload: { childWorkItemId: "wi-child", draft: draft({ summary: "Child" }) },
+					metadata: { executionInputRevision: 1, applyPolicyId: "spawn-create-complete" },
+				}),
+			],
+		]);
+		createSetup.decisions.down([
+			[
+				"DATA",
+				admissionDecision(
+					"spawn-create-complete-decision",
+					"spawn-create-complete-admission",
+					"spawn-create-complete",
+				),
+			],
+		]);
+
+		expect(createSetup.appliedFacts).toEqual([
+			expect.objectContaining({
+				kind: "work-item-created",
+				workItemId: "wi-child",
+				draft: expect.objectContaining({ summary: "Child" }),
+				metadata: expect.objectContaining({
+					parentWorkItemId: "wi-parent",
+					sourceProposalId: "spawn-create-complete",
+					idempotencyKey: "spawn:create:wi-child",
+				}),
+			}),
+		]);
+		expect(createSetup.applications.at(-1)).toMatchObject({
+			state: "applied",
+			actionKind: "spawn-child",
+			producedFactIds: ["spawn-create-complete-admission:work-item-created:wi-child"],
+		});
+	});
+
+	it("turns malformed runtime action payloads into DataIssue/status instead of protocol ERROR", () => {
+		const setup = setupActions();
+		setup.seed.down([["DATA", workItemCreatedFromDraft("wi-1", draft())]]);
+		setup.applyPolicies.down([
+			["DATA", workItemDomainActionApplyPolicy("apply-patch", { actionKinds: ["patch"] })],
+		]);
+
+		setup.proposals.down([
+			["DATA", { kind: "work-item-domain-action-proposal-intake", proposalId: "" }],
+		]);
+		applyPatch(setup, "proposal-bad-payload", "admission-bad-payload", {
+			payload: "not-a-patch",
+			metadata: { executionInputRevision: 1, applyPolicyId: "apply-patch" },
+		});
+
+		expect(setup.intakeIssues.at(-1)).toMatchObject({
+			code: "malformed-domain-action-proposal",
+		});
+		expect(setup.applicationIssues.at(-1)).toMatchObject({ code: "invalid-patch" });
+		expect(setup.appliedFacts).toEqual([]);
+	});
+});
diff --git a/packages/ts/src/__tests__/work-item-scheduling.workitem-authoring-verification-and-scheduling-surface-d333-d343-part-01.sub-01.test.ts b/packages/ts/src/__tests__/work-item-scheduling.workitem-authoring-verification-and-scheduling-surface-d333-d343-part-01.sub-01.test.ts
new file mode 100644
index 00000000..ec3cb433
--- /dev/null
+++ b/packages/ts/src/__tests__/work-item-scheduling.workitem-authoring-verification-and-scheduling-surface-d333-d343-part-01.sub-01.test.ts
@@ -0,0 +1,769 @@
+import { describe, expect, it } from "vitest";
+import { graph } from "../graph/graph.js";
+import type {
+	WorkItemEffectRequested,
+	WorkItemEvidenceRecorded,
+} from "../orchestration/work-item-runtime.js";
+import {
+	DEFAULT_WORK_ITEM_LINK_TYPE_CATALOG_SEED,
+	DEFAULT_WORK_ITEM_TYPE_CATALOG_SEED,
+	type RecommendedActionView,
+	type RequiredInputGate,
+	type RequiredInputResponseProposed,
+	type SidePanelActionIntent,
+	type VerificationPlan,
+	verificationPlanChanged,
+	type WorkItemAuthoringInput,
+	type WorkItemDispatchIntent,
+	type WorkItemEffectPlanProposed,
+	type WorkItemEffectPlanResult,
+	type WorkItemEffectPlanStatus,
+	type WorkItemLinked,
+	type WorkItemLinkProjection,
+	type WorkItemProjection,
+	type WorkItemSpawnAdmission,
+	type WorkItemSpawnApplication,
+	type WorkItemVerificationMappingPolicy,
+	workItemAuthoringProjector,
+	workItemCreatedFromDraft,
+	workItemEffectPlanProjector,
+	workItemSpawnProposed,
+	workItemVerificationRequestLowerer,
+	workItemVerificationResultMapper,
+} from "../solutions/work-item/scheduling.js";
+
+function collectData<T>(node: {
+	subscribe(sink: (msg: readonly [string, unknown?]) => void): unknown;
+}): T[] {
+	const out: T[] = [];
+	node.subscribe((msg) => {
+		if (msg[0] === "DATA") out.push(msg[1] as T);
+	});
+	return out;
+}
+
+function draft(opts: Partial<ReturnType<typeof baseDraft>> = {}) {
+	return { ...baseDraft(), ...opts };
+}
+
+function baseDraft() {
+	return {
+		summary: "Ship verification",
+		detail: "Make the first WorkItem scheduling slice verifiable.",
+		acceptanceCriteria: [{ criterionId: "ac-1", statement: "Focused tests pass", required: true }],
+		verificationPlan: plan(),
+		tags: ["work-item"],
+		metadata: { color: "green" },
+	};
+}
+
+function plan(): VerificationPlan {
+	return {
+		planId: "plan-1",
+		steps: [
+			{
+				stepId: "step-1",
+				mode: "auto",
+				effectKind: "verification",
+				verifiesCriteriaIds: ["ac-1"],
+				goal: { kind: "verification", summary: "Run focused tests" },
+			},
+		],
+	};
+}
+
+function evidenceFact(
+	evidenceId: string,
+	opts: Partial<WorkItemEvidenceRecorded> = {},
+): WorkItemEvidenceRecorded {
+	return {
+		kind: "work-item-evidence-recorded",
+		evidenceId,
+		workItemId: "wi-1",
+		effectRunId: "run-1",
+		effectRunResultId: `result:${evidenceId}`,
+		status: "completed",
+		output: { kind: "verification-output", value: { ok: true } },
+		metadata: {
+			executionInputRevision: 1,
+			verificationStepIds: ["step-1"],
+			acceptanceCriterionIds: ["ac-1"],
+		},
+		...opts,
+	};
+}
+
+function _planSetup() {
+	const g = graph();
+	const facts = g.node<WorkItemAuthoringInput>([], null, { name: "facts" });
+	const proposals = g.node<WorkItemEffectPlanProposed>([], null, { name: "effectPlanProposals" });
+	const evidence = g.node<WorkItemEvidenceRecorded>([], null, { name: "effectPlanEvidence" });
+	const authoring = workItemAuthoringProjector(g, { facts });
+	const planBundle = workItemEffectPlanProjector(g, {
+		workItems: authoring.workItems,
+		proposals,
+		evidence,
+		policy: { allowedEffectKinds: ["verification"] },
+		now: () => 123,
+	});
+	return {
+		facts,
+		proposals,
+		evidence,
+		workItems: collectData<WorkItemProjection>(authoring.workItems),
+		admitted: collectData(planBundle.admitted),
+		rejected: collectData(planBundle.rejected),
+		requests: collectData<WorkItemEffectRequested>(planBundle.effectRequests),
+		results: collectData<WorkItemEffectPlanResult>(planBundle.results),
+		status: collectData<WorkItemEffectPlanStatus>(planBundle.status),
+		issues: collectData(planBundle.issues),
+	};
+}
+
+function _planProposal(
+	members: WorkItemEffectPlanProposed["members"],
+	opts: Partial<
+		Omit<WorkItemEffectPlanProposed, "kind" | "planId" | "workItemId" | "members">
+	> = {},
+): WorkItemEffectPlanProposed {
+	return {
+		kind: "work-item-effect-plan-proposed",
+		planId: "effect-plan-1",
+		workItemId: "wi-1",
+		executionInputRevision: opts.executionInputRevision ?? 1,
+		members,
+		joinPolicy: opts.joinPolicy,
+		limits: opts.limits,
+		policyRefs: opts.policyRefs,
+		sourceRefs: opts.sourceRefs,
+		metadata: opts.metadata,
+	};
+}
+
+function _planMember(
+	memberId: string,
+	opts: Partial<WorkItemEffectPlanProposed["members"][number]> = {},
+): WorkItemEffectPlanProposed["members"][number] {
+	return {
+		memberId,
+		effectKind: opts.effectKind ?? "verification",
+		goal: opts.goal ?? { kind: "verification", summary: `Run ${memberId}` },
+		required: opts.required,
+		dependsOnMemberIds: opts.dependsOnMemberIds,
+		sourceRefs: opts.sourceRefs,
+		metadata: opts.metadata,
+	};
+}
+
+function _evidenceForPlanRequest(
+	evidenceId: string,
+	request: WorkItemEffectRequested,
+	opts: Partial<WorkItemEvidenceRecorded> = {},
+): WorkItemEvidenceRecorded {
+	return {
+		kind: "work-item-evidence-recorded",
+		evidenceId,
+		workItemId: request.workItemId,
+		requestId: request.requestId,
+		effectRunId: request.effectRunId,
+		effectRunResultId: `result:${evidenceId}`,
+		executionInputRevision: request.executionInputRevision,
+		planId: request.planId,
+		planMemberId: request.planMemberId,
+		status: "completed",
+		sourceRefs: request.sourceRefs,
+		output: { kind: "verification-output", value: { ok: true } },
+		metadata: {
+			executionInputRevision: request.executionInputRevision,
+			planId: request.planId,
+			planMemberId: request.planMemberId,
+			...(opts.metadata ?? {}),
+		},
+		...opts,
+	};
+}
+
+describe("WorkItem authoring, verification, and scheduling surface (D333-D343) — sub 1", () => {
+	it("lowers human/API WorkItemDraft facts to projections with revision coordinates", () => {
+		const g = graph();
+		const facts = g.node<WorkItemAuthoringInput>([], null, { name: "facts" });
+		const bundle = workItemAuthoringProjector(g, { facts });
+		const workItems = collectData<WorkItemProjection>(bundle.workItems);
+		const issues = collectData(bundle.issues);
+
+		facts.down([["DATA", workItemCreatedFromDraft("wi-1", draft())]]);
+
+		expect(issues).toEqual([]);
+		expect(workItems.at(-1)).toMatchObject({
+			workItemId: "wi-1",
+			summary: "Ship verification",
+			authoringRevision: 1,
+			executionInputRevision: 1,
+			verificationPlan: expect.objectContaining({ planId: "plan-1" }),
+		});
+	});
+
+	it("lets LLM spawn proposals carry WorkItemDraft without applying them", () => {
+		const g = graph();
+		const facts = g.node<WorkItemAuthoringInput>([], null, { name: "facts" });
+		const bundle = workItemAuthoringProjector(g, { facts });
+		const workItems = collectData(bundle.workItems);
+		const status = collectData(bundle.status);
+
+		facts.down([
+			[
+				"DATA",
+				workItemSpawnProposed("spawn-1", draft({ summary: "Proposed child" }), {
+					proposedWorkItemId: "wi-child",
+					parentWorkItemId: "wi-parent",
+					idempotencyKey: "spawn:wi-parent:wi-child",
+				}),
+			],
+		]);
+
+		expect(workItems).toEqual([]);
+		expect(status.at(-1)).toMatchObject({
+			state: "deferred",
+			workItemId: "wi-child",
+			metadata: {
+				proposalId: "spawn-1",
+				parentWorkItemId: "wi-parent",
+				idempotencyKey: "spawn:wi-parent:wi-child",
+			},
+		});
+	});
+
+	it("publishes Workspace WorkItem model seeds and proposal-facing view shapes", () => {
+		expect(DEFAULT_WORK_ITEM_TYPE_CATALOG_SEED.map((entry) => entry.kind)).toEqual([
+			"task",
+			"spike",
+			"review",
+		]);
+		expect(DEFAULT_WORK_ITEM_LINK_TYPE_CATALOG_SEED.map((entry) => entry.linkKind)).toEqual([
+			"parent-child",
+			"blocks",
+			"related",
+			"duplicate",
+			"spawned-from",
+		]);
+
+		const linkFact = {
+			kind: "work-item-linked",
+			eventId: "link:event:1",
+			linkId: "link:1",
+			fromWorkItemId: "wi-1",
+			toWorkItemId: "wi-2",
+			linkKind: "blocks",
+		} satisfies WorkItemLinked;
+		const linkProjection = {
+			linkId: linkFact.linkId,
+			fromWorkItemId: linkFact.fromWorkItemId,
+			toWorkItemId: linkFact.toWorkItemId,
+			linkKind: linkFact.linkKind,
+			direction: "directed",
+			active: true,
+			lastEventId: linkFact.eventId,
+		} satisfies WorkItemLinkProjection;
+		const spawnAdmission = {
+			kind: "work-item-spawn-admission",
+			admissionId: "spawn-admission:1",
+			proposalId: "spawn-1",
+			state: "admitted",
+			decisionId: "spawn-decision:1",
+			proposedWorkItemId: "wi-child",
+		} satisfies WorkItemSpawnAdmission;
+		const spawnApplication = {
+			kind: "work-item-spawn-application",
+			applicationId: "spawn-application:1",
+			admissionId: spawnAdmission.admissionId,
+			proposalId: spawnAdmission.proposalId,
+			state: "applied",
+			linkFacts: [linkFact],
+		} satisfies WorkItemSpawnApplication;
+		const requiredInput = {
+			kind: "required-input-gate",
+			gateId: "gate:1",
+			requestId: "required-input:1",
+			workItemId: "wi-1",
+			status: "requested",
+			prompt: "Confirm metric definition",
+		} satisfies RequiredInputGate;
+		const response = {
+			kind: "required-input-response-proposed",
+			proposalId: "input-response:1",
+			requestId: requiredInput.requestId,
+			workItemId: requiredInput.workItemId,
+			summary: "Use weekly activated accounts",
+		} satisfies RequiredInputResponseProposed;
+		const action = {
+			kind: "recommended-action-view",
+			actionId: "provide-input",
+			label: "Provide input",
+			tone: "attention",
+			loweringKind: "required-input-response-proposed",
+			draftSeed: response,
+		} satisfies RecommendedActionView;
+		const intent = {
+			kind: "side-panel-action-intent",
+			intentId: "intent:1",
+			actionId: action.actionId,
+			loweringKind: action.loweringKind,
+			workItemId: requiredInput.workItemId,
+			draft: response,
+		} satisfies SidePanelActionIntent<RequiredInputResponseProposed>;
+
+		expect(linkProjection.active).toBe(true);
+		expect(spawnApplication.linkFacts).toEqual([linkFact]);
+		expect(action.draftSeed).toBe(response);
+		expect(intent.loweringKind).toBe("required-input-response-proposed");
+	});
+
+	it("turns malformed runtime drafts, duplicate creates, and invalid patches into visible issues", () => {
+		const g = graph();
+		const facts = g.node<WorkItemAuthoringInput>([], null, { name: "facts" });
+		const bundle = workItemAuthoringProjector(g, { facts });
+		const workItems = collectData<WorkItemProjection>(bundle.workItems);
+		const issues = collectData(bundle.issues);
+		const status = collectData(bundle.status);
+
+		facts.down([
+			[
+				"DATA",
+				{
+					kind: "work-item-created",
+					eventId: "bad-create",
+					workItemId: "bad",
+					draft: { summary: 7 },
+				} as unknown as WorkItemAuthoringInput,
+			],
+		]);
+		facts.down([
+			[
+				"DATA",
+				workItemSpawnProposed("bad-spawn", { summary: "" } as unknown as ReturnType<typeof draft>),
+			],
+		]);
+		facts.down([["DATA", workItemCreatedFromDraft("wi-1", draft())]]);
+		facts.down([["DATA", workItemCreatedFromDraft("wi-1", draft(), { eventId: "wi-1:again" })]]);
+		facts.down([
+			[
+				"DATA",
+				{
+					kind: "work-item-patched",
+					eventId: "wi-1:bad-patch",
+					workItemId: "wi-1",
+					patch: { workItemId: "evil" },
+				} as unknown as WorkItemAuthoringInput,
+			],
+		]);
+
+		expect(workItems.at(-1)).toMatchObject({ workItemId: "wi-1", authoringRevision: 1 });
+		expect(issues.map((issue) => issue.code)).toEqual(
+			expect.arrayContaining(["missing-required-field", "duplicate-id", "invalid-patch"]),
+		);
+		expect(status.map((item) => item.state)).toEqual(
+			expect.arrayContaining(["rejected", "duplicate"]),
+		);
+	});
+
+	it("separates authoringRevision from executionInputRevision for metadata-only changes", () => {
+		const g = graph();
+		const facts = g.node<WorkItemAuthoringInput>([], null, { name: "facts" });
+		const bundle = workItemAuthoringProjector(g, {
+			facts,
+			policy: { executionRelevantFields: ["customFields.risk"] },
+		});
+		const workItems = collectData<WorkItemProjection>(bundle.workItems);
+
+		facts.down([["DATA", workItemCreatedFromDraft("wi-1", draft())]]);
+		facts.down([
+			[
+				"DATA",
+				{
+					kind: "work-item-patched",
+					eventId: "wi-1:metadata",
+					workItemId: "wi-1",
+					patch: { metadata: { color: "blue" } },
+				},
+			],
+		]);
+		facts.down([
+			[
+				"DATA",
+				{
+					kind: "work-item-patched",
+					eventId: "wi-1:custom-field-other",
+					workItemId: "wi-1",
+					patch: { customFields: { other: true } },
+				},
+			],
+		]);
+		facts.down([
+			[
+				"DATA",
+				{
+					kind: "work-item-patched",
+					eventId: "wi-1:custom-field-risk",
+					workItemId: "wi-1",
+					patch: { customFields: { risk: "high" } },
+				},
+			],
+		]);
+		facts.down([
+			[
+				"DATA",
+				{
+					kind: "work-item-patched",
+					eventId: "wi-1:detail",
+					workItemId: "wi-1",
+					patch: { detail: "Updated execution detail" },
+				},
+			],
+		]);
+
+		expect(workItems.map((item) => [item.authoringRevision, item.executionInputRevision])).toEqual([
+			[1, 1],
+			[2, 1],
+			[3, 1],
+			[4, 2],
+			[5, 3],
+		]);
+	});
+
+	it("lets patch facts clear optional draft fields without clearing required summary", () => {
+		const g = graph();
+		const facts = g.node<WorkItemAuthoringInput>([], null, { name: "facts" });
+		const bundle = workItemAuthoringProjector(g, { facts });
+		const workItems = collectData<WorkItemProjection>(bundle.workItems);
+		const issues = collectData(bundle.issues);
+
+		facts.down([["DATA", workItemCreatedFromDraft("wi-1", draft())]]);
+		facts.down([
+			[
+				"DATA",
+				{
+					kind: "work-item-patched",
+					eventId: "wi-1:clear-detail",
+					workItemId: "wi-1",
+					patch: { detail: undefined },
+				},
+			],
+		]);
+
+		expect(issues).toEqual([]);
+		expect(workItems.at(-1)).toMatchObject({
+			workItemId: "wi-1",
+			detail: undefined,
+			authoringRevision: 2,
+			executionInputRevision: 2,
+		});
+	});
+
+	it("lowers VerificationPlanChanged to stable WorkItemEffectRequested refs", () => {
+		const g = graph();
+		const facts = g.node<WorkItemAuthoringInput>([], null, { name: "facts" });
+		const authoring = workItemAuthoringProjector(g, { facts });
+		const lowerer = workItemVerificationRequestLowerer(g, {
+			workItems: authoring.workItems,
+			policy: { policyId: "verify-auto", autoRun: true },
+		});
+		const requests = collectData(lowerer.effectRequests);
+
+		facts.down([
+			["DATA", workItemCreatedFromDraft("wi-1", draft({ verificationPlan: undefined }))],
+		]);
+		facts.down([["DATA", verificationPlanChanged("wi-1", plan(), { eventId: "wi-1:plan-1" })]]);
+
+		expect(requests.at(-1)).toMatchObject({
+			kind: "work-item-effect-requested",
+			requestId: "work-item:wi-1:verification:2:plan-1:step-1",
+			workItemId: "wi-1",
+			effectRunId: "effect-run:work-item:wi-1:verification:2:plan-1:step-1",
+			effectKind: "verification",
+			idempotencyKey: "wi-1:verification:2:plan-1:step-1",
+			metadata: {
+				executionInputRevision: 2,
+				verificationStepIds: ["step-1"],
+				acceptanceCriterionIds: ["ac-1"],
+			},
+		});
+	});
+
+	it("requires explicit event ids for repeated mutable change helpers", () => {
+		const g = graph();
+		const facts = g.node<WorkItemAuthoringInput>([], null, { name: "facts" });
+		const bundle = workItemAuthoringProjector(g, { facts });
+		const workItems = collectData<WorkItemProjection>(bundle.workItems);
+
+		facts.down([["DATA", workItemCreatedFromDraft("wi-1", draft())]]);
+		facts.down([["DATA", verificationPlanChanged("wi-1", plan(), { eventId: "wi-1:plan-a" })]]);
+		facts.down([
+			[
+				"DATA",
+				verificationPlanChanged(
+					"wi-1",
+					{
+						planId: "plan-2",
+						steps: [{ stepId: "step-2", mode: "auto", verifiesCriteriaIds: ["ac-1"] }],
+					},
+					{ eventId: "wi-1:plan-b" },
+				),
+			],
+		]);
+
+		expect(workItems.at(-1)).toMatchObject({
+			verificationPlan: expect.objectContaining({ planId: "plan-2" }),
+			authoringRevision: 3,
+			executionInputRevision: 3,
+		});
+	});
+
+	it("preserves verification step input and scheduling hints on emitted requests", () => {
+		const g = graph();
+		const facts = g.node<WorkItemAuthoringInput<{ target: string }>>([], null, {
+			name: "facts",
+		});
+		const authoring = workItemAuthoringProjector(g, { facts });
+		const lowerer = workItemVerificationRequestLowerer(g, {
+			workItems: authoring.workItems,
+			policy: { policyId: "verify-auto", autoRun: true },
+		});
+		const requests = collectData(lowerer.effectRequests);
+		const contextRefs = [{ kind: "source-file", id: "src/work-item.ts" }];
+		const capacityHints = { lane: "ci", expectedMs: 2500 };
+
+		facts.down([
+			[
+				"DATA",
+				workItemCreatedFromDraft(
+					"wi-1",
+					draft({
+						verificationPlan: {
+							planId: "plan-rich",
+							steps: [
+								{
+									stepId: "step-rich",
+									mode: "auto",
+									effectKind: "verification",
+									verifiesCriteriaIds: ["ac-1"],
+									goal: { kind: "verification", summary: "Run rich verification" },
+									input: { target: "release" },
+									contextRefs,
+									requirements: ["node-20", "pnpm"],
+									capacityHints,
+								},
+							],
+						},
+					}),
+				),
+			],
+		]);
+
+		expect(requests.at(-1)).toMatchObject({
+			goal: {
+				input: {
+					inputId: "verification-step:step-rich:input",
+					inputKind: "verification",
+					dataMode: "inline",
+					value: { target: "release" },
+					subjectRefs: contextRefs,
+				},
+			},
+			metadata: {
+				contextRefs,
+				requirements: ["node-20", "pnpm"],
+				capacityHints,
+			},
+		});
+	});
+
+	it("emits visible status when verification auto-run is disabled by policy", () => {
+		const g = graph();
+		const facts = g.node<WorkItemAuthoringInput>([], null, { name: "facts" });
+		const authoring = workItemAuthoringProjector(g, { facts });
+		const lowerer = workItemVerificationRequestLowerer(g, {
+			workItems: authoring.workItems,
+			policy: { policyId: "manual-policy", autoRun: false },
+		});
+		const requests = collectData(lowerer.effectRequests);
+		const status = collectData(lowerer.status);
+
+		facts.down([["DATA", workItemCreatedFromDraft("wi-1", draft())]]);
+
+		expect(requests).toEqual([]);
+		expect(status.at(-1)).toMatchObject({
+			state: "deferred",
+			code: "policy-mismatch",
+			metadata: { policyId: "manual-policy", reason: "auto-run-disabled" },
+		});
+	});
+
+	it("preserves dispatch intent context, requirements, capacity hints, and limits", () => {
+		const g = graph();
+		const facts = g.node<WorkItemAuthoringInput>([], null, { name: "facts" });
+		const intents = g.node<WorkItemDispatchIntent>([], null, { name: "intents" });
+		const authoring = workItemAuthoringProjector(g, { facts });
+		const lowerer = workItemVerificationRequestLowerer(g, {
+			workItems: authoring.workItems,
+			dispatchIntents: intents,
+		});
+		const requests = collectData(lowerer.effectRequests);
+		const contextRefs = [{ kind: "artifact", id: "build-log" }];
+		const capacityHints = { lane: "review" };
+
+		facts.down([["DATA", workItemCreatedFromDraft("wi-1", draft())]]);
+		intents.down([
+			[
+				"DATA",
+				{
+					kind: "work-item-dispatch-intent",
+					intentId: "intent-current",
+					workItemId: "wi-1",
+					targetKind: "verification",
+					executionInputRevision: 1,
+					contextRefs,
+					requirements: ["human-readable-summary"],
+					capacityHints,
+					limits: { timeoutMs: 120000, maxSteps: 4 },
+				} satisfies WorkItemDispatchIntent,
+			],
+		]);
+
+		expect(requests.at(-1)).toMatchObject({
+			limits: { timeoutMs: 120000, maxSteps: 4 },
+			metadata: {
+				contextRefs,
+				requirements: ["human-readable-summary"],
+				capacityHints,
+			},
+		});
+	});
+
+	it("rejects dispatch intents outside the verification effect policy", () => {
+		const g = graph();
+		const facts = g.node<WorkItemAuthoringInput>([], null, { name: "facts" });
+		const intents = g.node<WorkItemDispatchIntent>([], null, { name: "intents" });
+		const authoring = workItemAuthoringProjector(g, { facts });
+		const lowerer = workItemVerificationRequestLowerer(g, {
+			workItems: authoring.workItems,
+			dispatchIntents: intents,
+		});
+		const requests = collectData(lowerer.effectRequests);
+		const issues = collectData(lowerer.issues);
+		const status = collectData(lowerer.status);
+
+		facts.down([["DATA", workItemCreatedFromDraft("wi-1", draft())]]);
+		const beforeIntentRequestCount = requests.length;
+		intents.down([
+			[
+				"DATA",
+				{
+					kind: "work-item-dispatch-intent",
+					intentId: "intent-executor",
+					workItemId: "wi-1",
+					targetKind: "executor",
+					executionInputRevision: 1,
+				} satisfies WorkItemDispatchIntent,
+			],
+		]);
+
+		expect(requests).toHaveLength(beforeIntentRequestCount);
+		expect(issues.at(-1)).toMatchObject({ code: "unsupported-effect-kind" });
+		expect(status.at(-1)).toMatchObject({ state: "rejected", code: "unsupported-effect-kind" });
+	});
+
+	it("emits visible stale issues for dispatch intents targeting an old execution input", () => {
+		const g = graph();
+		const facts = g.node<WorkItemAuthoringInput>([], null, { name: "facts" });
+		const intents = g.node<WorkItemDispatchIntent>([], null, { name: "intents" });
+		const authoring = workItemAuthoringProjector(g, { facts });
+		const lowerer = workItemVerificationRequestLowerer(g, {
+			workItems: authoring.workItems,
+			dispatchIntents: intents,
+			policy: { stalePolicy: "review" },
+		});
+		const requests = collectData(lowerer.effectRequests);
+		const issues = collectData(lowerer.issues);
+		const status = collectData(lowerer.status);
+
+		facts.down([["DATA", workItemCreatedFromDraft("wi-1", draft())]]);
+		facts.down([
+			[
+				"DATA",
+				{
+					kind: "work-item-patched",
+					eventId: "wi-1:detail",
+					workItemId: "wi-1",
+					patch: { detail: "Changed before execution" },
+				},
+			],
+		]);
+		const beforeIntentRequestCount = requests.length;
+		intents.down([
+			[
+				"DATA",
+				{
+					kind: "work-item-dispatch-intent",
+					intentId: "intent-old",
+					workItemId: "wi-1",
+					targetKind: "verification",
+					executionInputRevision: 1,
+				} satisfies WorkItemDispatchIntent,
+			],
+		]);
+
+		expect(requests).toHaveLength(beforeIntentRequestCount);
+		expect(issues.at(-1)).toMatchObject({ code: "stale-execution-input" });
+		expect(status.at(-1)).toMatchObject({ state: "stale", code: "stale-execution-input" });
+	});
+
+	it("maps verification evidence evidence-first and proposes actions only by explicit policy", () => {
+		const g = graph();
+		const facts = g.node<WorkItemAuthoringInput>([], null, { name: "facts" });
+		const evidence = g.node<WorkItemEvidenceRecorded>([], null, { name: "evidence" });
+		const policies = g.node<WorkItemVerificationMappingPolicy>([], null, { name: "policies" });
+		const authoring = workItemAuthoringProjector(g, { facts });
+		const mapper = workItemVerificationResultMapper(g, {
+			workItems: authoring.workItems,
+			evidence,
+			policies,
+		});
+		const results = collectData(mapper.results);
+		const proposals = collectData(mapper.proposals);
+
+		facts.down([["DATA", workItemCreatedFromDraft("wi-1", draft())]]);
+		evidence.down([["DATA", evidenceFact("ev-no-policy")]]);
+		expect(results.at(-1)).toMatchObject({
+			kind: "verification-result-recorded",
+			status: "passed",
+			executionInputRevision: 1,
+		});
+		expect(proposals).toEqual([]);
+
+		policies.down([
+			[
+				"DATA",
+				{
+					kind: "work-item-verification-mapping-policy",
+					policyId: "verify-policy",
+					actionProposals: [{ actionKind: "mark-verified", statuses: ["completed"] }],
+				} satisfies WorkItemVerificationMappingPolicy,
+			],
+		]);
+		evidence.down([
+			[
+				"DATA",
+				evidenceFact("ev-policy", {
+					sourceRefs: [{ kind: "work-item-verification-mapping-policy", id: "verify-policy" }],
+				}),
+			],
+		]);
+
+		expect(proposals.at(-1)).toMatchObject({
+			kind: "work-item-domain-action-proposal",
+			actionKind: "mark-verified",
+			workItemId: "wi-1",
+			policyId: "verify-policy",
+		});
+	});
+});
diff --git a/packages/ts/src/__tests__/work-item-scheduling.workitem-authoring-verification-and-scheduling-surface-d333-d343-part-01.sub-02.test.ts b/packages/ts/src/__tests__/work-item-scheduling.workitem-authoring-verification-and-scheduling-surface-d333-d343-part-01.sub-02.test.ts
new file mode 100644
index 00000000..ad20ee79
--- /dev/null
+++ b/packages/ts/src/__tests__/work-item-scheduling.workitem-authoring-verification-and-scheduling-surface-d333-d343-part-01.sub-02.test.ts
@@ -0,0 +1,547 @@
+import { describe, expect, it } from "vitest";
+import { graph } from "../graph/graph.js";
+import type {
+	WorkItemEffectRequested,
+	WorkItemEvidenceRecorded,
+} from "../orchestration/work-item-runtime.js";
+import {
+	type AcceptanceCriterion,
+	type VerificationPlan,
+	type VerificationResultRecorded,
+	validateVerificationPlan,
+	type WorkItemAuthoringInput,
+	type WorkItemEffectPlanProposed,
+	type WorkItemEffectPlanResult,
+	type WorkItemEffectPlanStatus,
+	type WorkItemProjection,
+	type WorkItemVerificationMappingPolicy,
+	workItemAuthoringProjector,
+	workItemCreatedFromDraft,
+	workItemEffectPlanProjector,
+	workItemVerificationRequestLowerer,
+	workItemVerificationResultMapper,
+} from "../solutions/work-item/scheduling.js";
+
+function collectData<T>(node: {
+	subscribe(sink: (msg: readonly [string, unknown?]) => void): unknown;
+}): T[] {
+	const out: T[] = [];
+	node.subscribe((msg) => {
+		if (msg[0] === "DATA") out.push(msg[1] as T);
+	});
+	return out;
+}
+
+function draft(opts: Partial<ReturnType<typeof baseDraft>> = {}) {
+	return { ...baseDraft(), ...opts };
+}
+
+function baseDraft() {
+	return {
+		summary: "Ship verification",
+		detail: "Make the first WorkItem scheduling slice verifiable.",
+		acceptanceCriteria: [{ criterionId: "ac-1", statement: "Focused tests pass", required: true }],
+		verificationPlan: plan(),
+		tags: ["work-item"],
+		metadata: { color: "green" },
+	};
+}
+
+function plan(): VerificationPlan {
+	return {
+		planId: "plan-1",
+		steps: [
+			{
+				stepId: "step-1",
+				mode: "auto",
+				effectKind: "verification",
+				verifiesCriteriaIds: ["ac-1"],
+				goal: { kind: "verification", summary: "Run focused tests" },
+			},
+		],
+	};
+}
+
+function evidenceFact(
+	evidenceId: string,
+	opts: Partial<WorkItemEvidenceRecorded> = {},
+): WorkItemEvidenceRecorded {
+	return {
+		kind: "work-item-evidence-recorded",
+		evidenceId,
+		workItemId: "wi-1",
+		effectRunId: "run-1",
+		effectRunResultId: `result:${evidenceId}`,
+		status: "completed",
+		output: { kind: "verification-output", value: { ok: true } },
+		metadata: {
+			executionInputRevision: 1,
+			verificationStepIds: ["step-1"],
+			acceptanceCriterionIds: ["ac-1"],
+		},
+		...opts,
+	};
+}
+
+function planSetup() {
+	const g = graph();
+	const facts = g.node<WorkItemAuthoringInput>([], null, { name: "facts" });
+	const proposals = g.node<WorkItemEffectPlanProposed>([], null, { name: "effectPlanProposals" });
+	const evidence = g.node<WorkItemEvidenceRecorded>([], null, { name: "effectPlanEvidence" });
+	const authoring = workItemAuthoringProjector(g, { facts });
+	const planBundle = workItemEffectPlanProjector(g, {
+		workItems: authoring.workItems,
+		proposals,
+		evidence,
+		policy: { allowedEffectKinds: ["verification"] },
+		now: () => 123,
+	});
+	return {
+		facts,
+		proposals,
+		evidence,
+		workItems: collectData<WorkItemProjection>(authoring.workItems),
+		admitted: collectData(planBundle.admitted),
+		rejected: collectData(planBundle.rejected),
+		requests: collectData<WorkItemEffectRequested>(planBundle.effectRequests),
+		results: collectData<WorkItemEffectPlanResult>(planBundle.results),
+		status: collectData<WorkItemEffectPlanStatus>(planBundle.status),
+		issues: collectData(planBundle.issues),
+	};
+}
+
+function planProposal(
+	members: WorkItemEffectPlanProposed["members"],
+	opts: Partial<
+		Omit<WorkItemEffectPlanProposed, "kind" | "planId" | "workItemId" | "members">
+	> = {},
+): WorkItemEffectPlanProposed {
+	return {
+		kind: "work-item-effect-plan-proposed",
+		planId: "effect-plan-1",
+		workItemId: "wi-1",
+		executionInputRevision: opts.executionInputRevision ?? 1,
+		members,
+		joinPolicy: opts.joinPolicy,
+		limits: opts.limits,
+		policyRefs: opts.policyRefs,
+		sourceRefs: opts.sourceRefs,
+		metadata: opts.metadata,
+	};
+}
+
+function planMember(
+	memberId: string,
+	opts: Partial<WorkItemEffectPlanProposed["members"][number]> = {},
+): WorkItemEffectPlanProposed["members"][number] {
+	return {
+		memberId,
+		effectKind: opts.effectKind ?? "verification",
+		goal: opts.goal ?? { kind: "verification", summary: `Run ${memberId}` },
+		required: opts.required,
+		dependsOnMemberIds: opts.dependsOnMemberIds,
+		sourceRefs: opts.sourceRefs,
+		metadata: opts.metadata,
+	};
+}
+
+function evidenceForPlanRequest(
+	evidenceId: string,
+	request: WorkItemEffectRequested,
+	opts: Partial<WorkItemEvidenceRecorded> = {},
+): WorkItemEvidenceRecorded {
+	return {
+		kind: "work-item-evidence-recorded",
+		evidenceId,
+		workItemId: request.workItemId,
+		requestId: request.requestId,
+		effectRunId: request.effectRunId,
+		effectRunResultId: `result:${evidenceId}`,
+		executionInputRevision: request.executionInputRevision,
+		planId: request.planId,
+		planMemberId: request.planMemberId,
+		status: "completed",
+		sourceRefs: request.sourceRefs,
+		output: { kind: "verification-output", value: { ok: true } },
+		metadata: {
+			executionInputRevision: request.executionInputRevision,
+			planId: request.planId,
+			planMemberId: request.planMemberId,
+			...(opts.metadata ?? {}),
+		},
+		...opts,
+	};
+}
+
+describe("WorkItem authoring, verification, and scheduling surface (D333-D343) — sub 2", () => {
+	it("unblocks dependent verification steps after prior results pass", () => {
+		const g = graph();
+		const facts = g.node<WorkItemAuthoringInput>([], null, { name: "facts" });
+		const results = g.node<VerificationResultRecorded>([], null, { name: "results" });
+		const authoring = workItemAuthoringProjector(g, { facts });
+		const lowerer = workItemVerificationRequestLowerer(g, {
+			workItems: authoring.workItems,
+			verificationResults: results,
+		});
+		const requests = collectData(lowerer.effectRequests);
+		const status = collectData(lowerer.status);
+
+		facts.down([
+			[
+				"DATA",
+				workItemCreatedFromDraft(
+					"wi-1",
+					draft({
+						verificationPlan: {
+							planId: "plan-deps",
+							steps: [
+								{ stepId: "step-a", mode: "auto", verifiesCriteriaIds: ["ac-1"] },
+								{
+									stepId: "step-b",
+									mode: "auto",
+									verifiesCriteriaIds: ["ac-1"],
+									dependsOnStepIds: ["step-a"],
+								},
+							],
+						},
+					}),
+				),
+			],
+		]);
+		expect(requests.map((request) => request.metadata?.verificationStepIds)).toEqual([["step-a"]]);
+		expect(status.at(-1)).toMatchObject({ code: "blocked-prerequisite" });
+
+		results.down([
+			[
+				"DATA",
+				{
+					kind: "verification-result-recorded",
+					resultId: "result-a",
+					workItemId: "wi-1",
+					evidenceId: "ev-a",
+					effectRunId: "run-a",
+					effectRunResultId: "effect-result-a",
+					executionInputRevision: 1,
+					verificationStepIds: ["step-a"],
+					acceptanceCriterionIds: ["ac-1"],
+					status: "passed",
+				},
+			],
+		]);
+
+		expect(requests.map((request) => request.metadata?.verificationStepIds)).toEqual([
+			["step-a"],
+			["step-b"],
+		]);
+	});
+
+	it("honors verification action proposal output gates and compact payload sources", () => {
+		const g = graph();
+		const facts = g.node<WorkItemAuthoringInput>([], null, { name: "facts" });
+		const evidence = g.node<WorkItemEvidenceRecorded>([], null, { name: "evidence" });
+		const policies = g.node<WorkItemVerificationMappingPolicy>([], null, { name: "policies" });
+		const authoring = workItemAuthoringProjector(g, { facts });
+		const mapper = workItemVerificationResultMapper(g, {
+			workItems: authoring.workItems,
+			evidence,
+			policies,
+		});
+		const proposals = collectData(mapper.proposals);
+		const issues = collectData(mapper.issues);
+
+		facts.down([["DATA", workItemCreatedFromDraft("wi-1", draft())]]);
+		policies.down([
+			[
+				"DATA",
+				{
+					kind: "work-item-verification-mapping-policy",
+					policyId: "verify-policy",
+					actionProposals: [
+						{ actionKind: "wrong-output", outputKinds: ["other"], payloadFrom: "output" },
+						{
+							actionKind: "payload-output",
+							outputKinds: ["verification-output"],
+							payloadFrom: "output",
+						},
+						{ actionKind: "payload-result", payloadFrom: "effect-run-result" },
+						{ actionKind: "payload-evidence", payloadFrom: "evidence" },
+						{ actionKind: "" },
+					],
+				} satisfies WorkItemVerificationMappingPolicy,
+			],
+		]);
+		evidence.down([
+			[
+				"DATA",
+				evidenceFact("ev-policy-payload", {
+					sourceRefs: [{ kind: "work-item-verification-mapping-policy", id: "verify-policy" }],
+				}),
+			],
+		]);
+
+		expect(proposals.map((proposal) => proposal.actionKind)).toEqual([
+			"payload-output",
+			"payload-result",
+			"payload-evidence",
+		]);
+		expect(proposals.find((proposal) => proposal.actionKind === "payload-output")?.payload).toEqual(
+			{
+				kind: "verification-output",
+				value: { ok: true },
+			},
+		);
+		expect(proposals.find((proposal) => proposal.actionKind === "payload-result")?.payload).toEqual(
+			{
+				kind: "effect-run-result-ref",
+				resultId: "result:ev-policy-payload",
+			},
+		);
+		expect(
+			proposals.find((proposal) => proposal.actionKind === "payload-evidence")?.payload,
+		).toEqual({
+			kind: "work-item-evidence-ref",
+			evidenceId: "ev-policy-payload",
+		});
+		expect(issues.at(-1)).toMatchObject({ code: "policy-mismatch" });
+	});
+
+	it("replays evidence when explicit mapping policy arrives later", () => {
+		const g = graph();
+		const facts = g.node<WorkItemAuthoringInput>([], null, { name: "facts" });
+		const evidence = g.node<WorkItemEvidenceRecorded>([], null, { name: "evidence" });
+		const policies = g.node<WorkItemVerificationMappingPolicy>([], null, { name: "policies" });
+		const authoring = workItemAuthoringProjector(g, { facts });
+		const mapper = workItemVerificationResultMapper(g, {
+			workItems: authoring.workItems,
+			evidence,
+			policies,
+		});
+		const results = collectData(mapper.results);
+		const proposals = collectData(mapper.proposals);
+		const issues = collectData(mapper.issues);
+
+		facts.down([["DATA", workItemCreatedFromDraft("wi-1", draft())]]);
+		evidence.down([
+			[
+				"DATA",
+				evidenceFact("ev-late-policy", {
+					sourceRefs: [{ kind: "work-item-verification-mapping-policy", id: "late-policy" }],
+				}),
+			],
+		]);
+		expect(results).toHaveLength(1);
+		expect(issues.at(-1)).toMatchObject({ code: "missing-policy" });
+		expect(proposals).toEqual([]);
+
+		policies.down([
+			[
+				"DATA",
+				{
+					kind: "work-item-verification-mapping-policy",
+					policyId: "late-policy",
+					actionProposals: [{ actionKind: "mark-verified", statuses: ["completed"] }],
+				} satisfies WorkItemVerificationMappingPolicy,
+			],
+		]);
+
+		expect(results).toHaveLength(1);
+		expect(proposals.at(-1)).toMatchObject({
+			actionKind: "mark-verified",
+			policyId: "late-policy",
+		});
+	});
+
+	it("replays cached evidence when the WorkItem projection arrives or catches up", () => {
+		const g = graph();
+		const facts = g.node<WorkItemAuthoringInput>([], null, { name: "facts" });
+		const evidence = g.node<WorkItemEvidenceRecorded>([], null, { name: "evidence" });
+		const authoring = workItemAuthoringProjector(g, { facts });
+		const mapper = workItemVerificationResultMapper(g, {
+			workItems: authoring.workItems,
+			evidence,
+		});
+		const results = collectData(mapper.results);
+		const issues = collectData(mapper.issues);
+
+		evidence.down([["DATA", evidenceFact("ev-before-work-item")]]);
+		expect(results).toEqual([]);
+		expect(issues.at(-1)).toMatchObject({ code: "dangling-ref" });
+
+		facts.down([["DATA", workItemCreatedFromDraft("wi-1", draft())]]);
+
+		expect(results.at(-1)).toMatchObject({
+			resultId: "verification-result:ev-before-work-item",
+			workItemId: "wi-1",
+		});
+	});
+
+	it("validates malformed mapping policies and honors every referenced policy", () => {
+		const g = graph();
+		const facts = g.node<WorkItemAuthoringInput>([], null, { name: "facts" });
+		const evidence = g.node<WorkItemEvidenceRecorded>([], null, { name: "evidence" });
+		const policies = g.node<WorkItemVerificationMappingPolicy>([], null, { name: "policies" });
+		const authoring = workItemAuthoringProjector(g, { facts });
+		const mapper = workItemVerificationResultMapper(g, {
+			workItems: authoring.workItems,
+			evidence,
+			policies,
+		});
+		const proposals = collectData(mapper.proposals);
+		const issues = collectData(mapper.issues);
+
+		facts.down([["DATA", workItemCreatedFromDraft("wi-1", draft())]]);
+		policies.down([
+			[
+				"DATA",
+				{
+					kind: "work-item-verification-mapping-policy",
+					policyId: "bad-policy",
+					actionProposals: [{ metadata: { missing: "actionKind" } }],
+				} as unknown as WorkItemVerificationMappingPolicy,
+			],
+			[
+				"DATA",
+				{
+					kind: "work-item-verification-mapping-policy",
+					policyId: "policy-a",
+					actionProposals: [{ actionKind: "mark-verified-a" }],
+				} satisfies WorkItemVerificationMappingPolicy,
+			],
+			[
+				"DATA",
+				{
+					kind: "work-item-verification-mapping-policy",
+					policyId: "policy-b",
+					actionProposals: [{ actionKind: "mark-verified-b" }],
+				} satisfies WorkItemVerificationMappingPolicy,
+			],
+		]);
+		evidence.down([
+			[
+				"DATA",
+				evidenceFact("ev-multi-policy", {
+					sourceRefs: [
+						{ kind: "work-item-verification-mapping-policy", id: "policy-a" },
+						{ kind: "work-item-verification-mapping-policy", id: "policy-b" },
+					],
+				}),
+			],
+		]);
+
+		expect(issues.at(0)).toMatchObject({ code: "policy-mismatch" });
+		expect(proposals.map((proposal) => proposal.actionKind)).toEqual([
+			"mark-verified-a",
+			"mark-verified-b",
+		]);
+	});
+
+	it("rejects verification evidence with dangling coverage refs", () => {
+		const g = graph();
+		const facts = g.node<WorkItemAuthoringInput>([], null, { name: "facts" });
+		const evidence = g.node<WorkItemEvidenceRecorded>([], null, { name: "evidence" });
+		const authoring = workItemAuthoringProjector(g, { facts });
+		const mapper = workItemVerificationResultMapper(g, {
+			workItems: authoring.workItems,
+			evidence,
+		});
+		const results = collectData(mapper.results);
+		const issues = collectData(mapper.issues);
+
+		facts.down([["DATA", workItemCreatedFromDraft("wi-1", draft())]]);
+		evidence.down([
+			[
+				"DATA",
+				evidenceFact("ev-bad-coverage", {
+					metadata: {
+						executionInputRevision: 1,
+						verificationStepIds: ["missing-step"],
+						acceptanceCriterionIds: ["ac-1"],
+					},
+				}),
+			],
+		]);
+
+		expect(results).toEqual([]);
+		expect(issues.at(-1)).toMatchObject({ code: "dangling-ref" });
+	});
+
+	it("reports validation taxonomy issues for duplicate ids, refs, cycles, modes, and effect kinds", () => {
+		const criteria: AcceptanceCriterion[] = [{ criterionId: "ac-1", statement: "Has tests" }];
+		const issues = validateVerificationPlan(
+			{
+				planId: "bad",
+				steps: [
+					{
+						stepId: "step-1",
+						mode: "auto",
+						verifiesCriteriaIds: ["missing-ac"],
+						dependsOnStepIds: ["step-2"],
+					},
+					{
+						stepId: "step-1",
+						mode: "manual",
+					},
+					{
+						stepId: "step-2",
+						mode: "robot" as "auto",
+						effectKind: "deploy",
+						dependsOnStepIds: ["step-3"],
+					},
+					{
+						stepId: "step-3",
+						mode: "auto",
+						dependsOnStepIds: ["step-2"],
+					},
+				],
+			},
+			criteria,
+		);
+
+		expect(issues.map((issue) => issue.code)).toEqual(
+			expect.arrayContaining([
+				"duplicate-id",
+				"dangling-ref",
+				"cyclic-dependency",
+				"unsupported-mode",
+				"unsupported-effect-kind",
+			]),
+		);
+	});
+
+	it("lowers WorkItemEffectPlan serial members one prerequisite at a time", () => {
+		const setup = planSetup();
+
+		setup.facts.down([["DATA", workItemCreatedFromDraft("wi-1", draft())]]);
+		setup.proposals.down([
+			[
+				"DATA",
+				planProposal([
+					planMember("A"),
+					planMember("B", { dependsOnMemberIds: ["A"] }),
+					planMember("C", { dependsOnMemberIds: ["B"] }),
+				]),
+			],
+		]);
+
+		expect(setup.requests.map((request) => request.planMemberId)).toEqual(["A"]);
+		expect(
+			setup.status.filter((item) => item.state === "blocked").map((item) => item.planMemberId),
+		).toEqual(["B", "C"]);
+
+		setup.evidence.down([["DATA", evidenceForPlanRequest("ev-a", setup.requests.at(-1)!)]]);
+		expect(setup.requests.map((request) => request.planMemberId)).toEqual(["A", "B"]);
+
+		setup.evidence.down([["DATA", evidenceForPlanRequest("ev-b", setup.requests.at(-1)!)]]);
+		expect(setup.requests.map((request) => request.planMemberId)).toEqual(["A", "B", "C"]);
+
+		setup.evidence.down([["DATA", evidenceForPlanRequest("ev-c", setup.requests.at(-1)!)]]);
+		expect(setup.results.at(-1)).toMatchObject({
+			status: "succeeded",
+			memberResults: [
+				expect.objectContaining({ planMemberId: "A" }),
+				expect.objectContaining({ planMemberId: "B" }),
+				expect.objectContaining({ planMemberId: "C" }),
+			],
+		});
+	});
+});
diff --git a/packages/ts/src/__tests__/work-item-scheduling.workitem-authoring-verification-and-scheduling-surface-d333-d343-part-02.test.ts b/packages/ts/src/__tests__/work-item-scheduling.workitem-authoring-verification-and-scheduling-surface-d333-d343-part-02.test.ts
new file mode 100644
index 00000000..c3091a84
--- /dev/null
+++ b/packages/ts/src/__tests__/work-item-scheduling.workitem-authoring-verification-and-scheduling-surface-d333-d343-part-02.test.ts
@@ -0,0 +1,616 @@
+import { describe, expect, it } from "vitest";
+import { graph } from "../graph/graph.js";
+import type {
+	WorkItemEffectRequested,
+	WorkItemEvidenceRecorded,
+} from "../orchestration/work-item-runtime.js";
+import {
+	type VerificationPlan,
+	validateWorkItemEffectPlan,
+	type WorkItemAuthoringInput,
+	type WorkItemEffectPlanProposed,
+	type WorkItemEffectPlanResult,
+	type WorkItemEffectPlanStatus,
+	type WorkItemProjection,
+	workItemAuthoringProjector,
+	workItemCreatedFromDraft,
+	workItemEffectPlanProjector,
+} from "../solutions/work-item/scheduling.js";
+
+function collectData<T>(node: {
+	subscribe(sink: (msg: readonly [string, unknown?]) => void): unknown;
+}): T[] {
+	const out: T[] = [];
+	node.subscribe((msg) => {
+		if (msg[0] === "DATA") out.push(msg[1] as T);
+	});
+	return out;
+}
+
+function draft(opts: Partial<ReturnType<typeof baseDraft>> = {}) {
+	return { ...baseDraft(), ...opts };
+}
+
+function baseDraft() {
+	return {
+		summary: "Ship verification",
+		detail: "Make the first WorkItem scheduling slice verifiable.",
+		acceptanceCriteria: [{ criterionId: "ac-1", statement: "Focused tests pass", required: true }],
+		verificationPlan: plan(),
+		tags: ["work-item"],
+		metadata: { color: "green" },
+	};
+}
+
+function plan(): VerificationPlan {
+	return {
+		planId: "plan-1",
+		steps: [
+			{
+				stepId: "step-1",
+				mode: "auto",
+				effectKind: "verification",
+				verifiesCriteriaIds: ["ac-1"],
+				goal: { kind: "verification", summary: "Run focused tests" },
+			},
+		],
+	};
+}
+
+function evidenceFact(
+	evidenceId: string,
+	opts: Partial<WorkItemEvidenceRecorded> = {},
+): WorkItemEvidenceRecorded {
+	return {
+		kind: "work-item-evidence-recorded",
+		evidenceId,
+		workItemId: "wi-1",
+		effectRunId: "run-1",
+		effectRunResultId: `result:${evidenceId}`,
+		status: "completed",
+		output: { kind: "verification-output", value: { ok: true } },
+		metadata: {
+			executionInputRevision: 1,
+			verificationStepIds: ["step-1"],
+			acceptanceCriterionIds: ["ac-1"],
+		},
+		...opts,
+	};
+}
+
+function planSetup() {
+	const g = graph();
+	const facts = g.node<WorkItemAuthoringInput>([], null, { name: "facts" });
+	const proposals = g.node<WorkItemEffectPlanProposed>([], null, { name: "effectPlanProposals" });
+	const evidence = g.node<WorkItemEvidenceRecorded>([], null, { name: "effectPlanEvidence" });
+	const authoring = workItemAuthoringProjector(g, { facts });
+	const planBundle = workItemEffectPlanProjector(g, {
+		workItems: authoring.workItems,
+		proposals,
+		evidence,
+		policy: { allowedEffectKinds: ["verification"] },
+		now: () => 123,
+	});
+	return {
+		facts,
+		proposals,
+		evidence,
+		workItems: collectData<WorkItemProjection>(authoring.workItems),
+		admitted: collectData(planBundle.admitted),
+		rejected: collectData(planBundle.rejected),
+		requests: collectData<WorkItemEffectRequested>(planBundle.effectRequests),
+		results: collectData<WorkItemEffectPlanResult>(planBundle.results),
+		status: collectData<WorkItemEffectPlanStatus>(planBundle.status),
+		issues: collectData(planBundle.issues),
+	};
+}
+
+function planProposal(
+	members: WorkItemEffectPlanProposed["members"],
+	opts: Partial<
+		Omit<WorkItemEffectPlanProposed, "kind" | "planId" | "workItemId" | "members">
+	> = {},
+): WorkItemEffectPlanProposed {
+	return {
+		kind: "work-item-effect-plan-proposed",
+		planId: "effect-plan-1",
+		workItemId: "wi-1",
+		executionInputRevision: opts.executionInputRevision ?? 1,
+		members,
+		joinPolicy: opts.joinPolicy,
+		limits: opts.limits,
+		policyRefs: opts.policyRefs,
+		sourceRefs: opts.sourceRefs,
+		metadata: opts.metadata,
+	};
+}
+
+function planMember(
+	memberId: string,
+	opts: Partial<WorkItemEffectPlanProposed["members"][number]> = {},
+): WorkItemEffectPlanProposed["members"][number] {
+	return {
+		memberId,
+		effectKind: opts.effectKind ?? "verification",
+		goal: opts.goal ?? { kind: "verification", summary: `Run ${memberId}` },
+		required: opts.required,
+		dependsOnMemberIds: opts.dependsOnMemberIds,
+		sourceRefs: opts.sourceRefs,
+		metadata: opts.metadata,
+	};
+}
+
+function evidenceForPlanRequest(
+	evidenceId: string,
+	request: WorkItemEffectRequested,
+	opts: Partial<WorkItemEvidenceRecorded> = {},
+): WorkItemEvidenceRecorded {
+	return {
+		kind: "work-item-evidence-recorded",
+		evidenceId,
+		workItemId: request.workItemId,
+		requestId: request.requestId,
+		effectRunId: request.effectRunId,
+		effectRunResultId: `result:${evidenceId}`,
+		executionInputRevision: request.executionInputRevision,
+		planId: request.planId,
+		planMemberId: request.planMemberId,
+		status: "completed",
+		sourceRefs: request.sourceRefs,
+		output: { kind: "verification-output", value: { ok: true } },
+		metadata: {
+			executionInputRevision: request.executionInputRevision,
+			planId: request.planId,
+			planMemberId: request.planMemberId,
+			...(opts.metadata ?? {}),
+		},
+		...opts,
+	};
+}
+describe("WorkItem authoring, verification, and scheduling surface (D333-D343) — part 2", () => {
+	it("lowers WorkItemEffectPlan parallel members together", () => {
+		const setup = planSetup();
+
+		setup.facts.down([["DATA", workItemCreatedFromDraft("wi-1", draft())]]);
+		setup.proposals.down([
+			["DATA", planProposal([planMember("A"), planMember("B"), planMember("C")])],
+		]);
+
+		expect(setup.requests.map((request) => request.planMemberId)).toEqual(["A", "B", "C"]);
+		expect(setup.requests).toEqual([
+			expect.objectContaining({
+				executionInputRevision: 1,
+				planId: "effect-plan-1",
+				planMemberId: "A",
+			}),
+			expect.objectContaining({ planId: "effect-plan-1", planMemberId: "B" }),
+			expect.objectContaining({ planId: "effect-plan-1", planMemberId: "C" }),
+		]);
+		expect(setup.status.some((item) => item.state === "blocked")).toBe(false);
+	});
+
+	it("lowers WorkItemEffectPlan fan-out/fan-in only after all member deps pass", () => {
+		const setup = planSetup();
+
+		setup.facts.down([["DATA", workItemCreatedFromDraft("wi-1", draft())]]);
+		setup.proposals.down([
+			[
+				"DATA",
+				planProposal([
+					planMember("A"),
+					planMember("B", { dependsOnMemberIds: ["A"] }),
+					planMember("C", { dependsOnMemberIds: ["A"] }),
+					planMember("D", { dependsOnMemberIds: ["B", "C"] }),
+				]),
+			],
+		]);
+
+		expect(setup.requests.map((request) => request.planMemberId)).toEqual(["A"]);
+		setup.evidence.down([["DATA", evidenceForPlanRequest("ev-a", setup.requests.at(-1)!)]]);
+		expect(setup.requests.map((request) => request.planMemberId)).toEqual(["A", "B", "C"]);
+
+		const requestB = setup.requests.find((request) => request.planMemberId === "B")!;
+		const requestC = setup.requests.find((request) => request.planMemberId === "C")!;
+		setup.evidence.down([["DATA", evidenceForPlanRequest("ev-b", requestB)]]);
+		expect(setup.requests.map((request) => request.planMemberId)).toEqual(["A", "B", "C"]);
+
+		setup.evidence.down([["DATA", evidenceForPlanRequest("ev-c", requestC)]]);
+		expect(setup.requests.map((request) => request.planMemberId)).toEqual(["A", "B", "C", "D"]);
+	});
+
+	it("rejects stale and malformed WorkItemEffectPlan proposals visibly", () => {
+		const setup = planSetup();
+
+		setup.facts.down([["DATA", workItemCreatedFromDraft("wi-1", draft())]]);
+		setup.facts.down([
+			[
+				"DATA",
+				{
+					kind: "work-item-patched",
+					eventId: "wi-1:detail",
+					workItemId: "wi-1",
+					patch: { detail: "new execution input" },
+				},
+			],
+		]);
+		setup.proposals.down([
+			["DATA", planProposal([planMember("A")], { executionInputRevision: 1 })],
+		]);
+
+		expect(setup.rejected.at(-1)).toMatchObject({
+			kind: "work-item-effect-plan-rejected",
+			issues: [expect.objectContaining({ code: "stale-execution-input" })],
+		});
+		expect(setup.requests).toEqual([]);
+
+		const workItem = setup.workItems.at(-1)!;
+		const validationIssues = validateWorkItemEffectPlan(
+			planProposal([
+				planMember("dup"),
+				planMember("dup"),
+				planMember("dangling", { dependsOnMemberIds: ["missing"] }),
+				planMember("cycle-a", { dependsOnMemberIds: ["cycle-b"] }),
+				planMember("cycle-b", { dependsOnMemberIds: ["cycle-a"] }),
+			]),
+			workItem,
+		);
+
+		expect(validationIssues.map((item) => item.code)).toEqual(
+			expect.arrayContaining(["duplicate-id", "dangling-ref", "cyclic-dependency"]),
+		);
+	});
+
+	it("defers WorkItemEffectPlan proposals until their WorkItem projection exists", () => {
+		const setup = planSetup();
+
+		setup.proposals.down([["DATA", planProposal([planMember("A")])]]);
+		expect(setup.rejected).toEqual([]);
+		expect(setup.status.at(-1)).toMatchObject({
+			state: "deferred",
+			metadata: { reason: "missing-work-item" },
+		});
+
+		setup.facts.down([["DATA", workItemCreatedFromDraft("wi-1", draft())]]);
+		expect(setup.admitted.at(-1)).toMatchObject({
+			kind: "work-item-effect-plan-admitted",
+			planId: "effect-plan-1",
+		});
+		expect(setup.requests.at(-1)).toMatchObject({ planMemberId: "A" });
+	});
+
+	it("suppresses duplicate WorkItemEffectPlan terminal evidence without rewriting results", () => {
+		const setup = planSetup();
+
+		setup.facts.down([["DATA", workItemCreatedFromDraft("wi-1", draft())]]);
+		setup.proposals.down([["DATA", planProposal([planMember("A")])]]);
+		const request = setup.requests.at(-1)!;
+
+		setup.evidence.down([["DATA", evidenceForPlanRequest("ev-a", request)]]);
+		setup.evidence.down([
+			[
+				"DATA",
+				evidenceForPlanRequest("ev-a-late-fail", request, {
+					status: "failed",
+					error: { kind: "issue", code: "late-fail", message: "late fail" },
+				}),
+			],
+		]);
+
+		expect(setup.results).toHaveLength(1);
+		expect(setup.results.at(-1)).toMatchObject({ status: "succeeded" });
+		expect(setup.issues.at(-1)).toMatchObject({ code: "duplicate-suppressed" });
+	});
+
+	it("keeps optional independent failure from failing all-required WorkItemEffectPlan results", () => {
+		const setup = planSetup();
+
+		setup.facts.down([["DATA", workItemCreatedFromDraft("wi-1", draft())]]);
+		setup.proposals.down([
+			["DATA", planProposal([planMember("required"), planMember("optional", { required: false })])],
+		]);
+
+		const requiredRequest = setup.requests.find((request) => request.planMemberId === "required")!;
+		const optionalRequest = setup.requests.find((request) => request.planMemberId === "optional")!;
+		setup.evidence.down([["DATA", evidenceForPlanRequest("ev-required", requiredRequest)]]);
+		expect(setup.results).toEqual([expect.objectContaining({ status: "succeeded" })]);
+
+		setup.evidence.down([
+			[
+				"DATA",
+				evidenceForPlanRequest("ev-optional-failed", optionalRequest, {
+					status: "failed",
+					error: { kind: "issue", code: "optional-failed", message: "optional failed" },
+				}),
+			],
+		]);
+
+		expect(setup.results).toHaveLength(1);
+		expect(setup.results.at(-1)).toMatchObject({ status: "succeeded" });
+	});
+
+	it("uses top-level plan coordinates rather than metadata as WorkItemEffectPlan join keys", () => {
+		const setup = planSetup();
+
+		setup.facts.down([["DATA", workItemCreatedFromDraft("wi-1", draft())]]);
+		setup.proposals.down([
+			[
+				"DATA",
+				planProposal([
+					planMember("A", { metadata: { label: "same" } }),
+					planMember("B", { dependsOnMemberIds: ["A"], metadata: { label: "same" } }),
+				]),
+			],
+		]);
+
+		const requestA = setup.requests.at(-1)!;
+		setup.evidence.down([
+			[
+				"DATA",
+				evidenceForPlanRequest("ev-a", requestA, {
+					metadata: { planId: "wrong-plan", planMemberId: "B", label: "same" },
+				}),
+			],
+		]);
+
+		expect(setup.requests.map((request) => request.planMemberId)).toEqual(["A", "B"]);
+		expect(setup.requests.map((request) => request.requestId)).toEqual([
+			"work-item:wi-1:effect-plan:1:effect-plan-1:A",
+			"work-item:wi-1:effect-plan:1:effect-plan-1:B",
+		]);
+	});
+
+	it("rejects WorkItemEffectPlan evidence whose request/effectRun conflicts with plan coordinates", () => {
+		const setup = planSetup();
+
+		setup.facts.down([["DATA", workItemCreatedFromDraft("wi-1", draft())]]);
+		setup.proposals.down([
+			["DATA", planProposal([planMember("A"), planMember("B", { dependsOnMemberIds: ["A"] })])],
+		]);
+
+		const requestA = setup.requests.find((request) => request.planMemberId === "A")!;
+		setup.evidence.down([
+			[
+				"DATA",
+				evidenceForPlanRequest("ev-conflict", requestA, {
+					planMemberId: "B",
+					metadata: { planMemberId: "B" },
+				}),
+			],
+		]);
+
+		expect(setup.issues.at(-1)).toMatchObject({ code: "dangling-ref" });
+		expect(setup.status.at(-1)).toMatchObject({
+			state: "rejected",
+			planMemberId: "B",
+			requestId: requestA.requestId,
+		});
+		expect(setup.results).toEqual([]);
+		expect(setup.requests.map((request) => request.planMemberId)).toEqual(["A"]);
+	});
+
+	it("rejects early WorkItemEffectPlan evidence once conflicting request coordinates are known", () => {
+		const setup = planSetup();
+
+		setup.evidence.down([
+			[
+				"DATA",
+				evidenceFact("ev-early-conflict", {
+					requestId: "work-item:wi-1:effect-plan:1:effect-plan-1:A",
+					effectRunId: "effect-run:work-item:wi-1:effect-plan:1:effect-plan-1:A",
+					executionInputRevision: 1,
+					planId: "effect-plan-1",
+					planMemberId: "B",
+				}),
+			],
+		]);
+		setup.facts.down([["DATA", workItemCreatedFromDraft("wi-1", draft())]]);
+		setup.proposals.down([
+			["DATA", planProposal([planMember("A"), planMember("B", { dependsOnMemberIds: ["A"] })])],
+		]);
+
+		expect(setup.issues.at(-1)).toMatchObject({ code: "dangling-ref" });
+		expect(setup.status.at(-1)).toMatchObject({
+			state: "rejected",
+			planMemberId: "B",
+			requestId: "work-item:wi-1:effect-plan:1:effect-plan-1:A",
+		});
+		expect(setup.results).toEqual([]);
+		expect(setup.requests.map((request) => request.planMemberId)).toEqual(["A"]);
+	});
+
+	it("rejects WorkItemEffectPlan evidence with correct member coordinates but wrong execution identity", () => {
+		const setup = planSetup();
+
+		setup.facts.down([["DATA", workItemCreatedFromDraft("wi-1", draft())]]);
+		setup.proposals.down([["DATA", planProposal([planMember("A")])]]);
+
+		const requestA = setup.requests.find((request) => request.planMemberId === "A")!;
+		setup.evidence.down([
+			[
+				"DATA",
+				evidenceForPlanRequest("ev-wrong-effect", requestA, {
+					effectRunId: "effect-run:wrong",
+				}),
+			],
+		]);
+
+		expect(setup.issues.at(-1)).toMatchObject({ code: "dangling-ref" });
+		expect(setup.status.at(-1)).toMatchObject({
+			state: "rejected",
+			planMemberId: "A",
+			effectRunId: "effect-run:wrong",
+		});
+		expect(setup.results).toEqual([]);
+	});
+
+	it("rejects WorkItemEffectPlan evidence whose requestId disagrees with known effectRun", () => {
+		const setup = planSetup();
+
+		setup.facts.down([["DATA", workItemCreatedFromDraft("wi-1", draft())]]);
+		setup.proposals.down([["DATA", planProposal([planMember("A")])]]);
+
+		const requestA = setup.requests.find((request) => request.planMemberId === "A")!;
+		setup.evidence.down([
+			[
+				"DATA",
+				evidenceForPlanRequest("ev-request-mismatch", requestA, {
+					requestId: "unknown-request",
+				}),
+			],
+		]);
+
+		expect(setup.issues.at(-1)).toMatchObject({ code: "dangling-ref" });
+		expect(setup.status.at(-1)).toMatchObject({
+			state: "rejected",
+			planMemberId: "A",
+			requestId: "unknown-request",
+			effectRunId: requestA.effectRunId,
+		});
+		expect(setup.results).toEqual([]);
+	});
+
+	it("accepts WorkItemEffectPlan evidence with member coordinates and effectRun but no requestId", () => {
+		const setup = planSetup();
+
+		setup.facts.down([["DATA", workItemCreatedFromDraft("wi-1", draft())]]);
+		setup.proposals.down([["DATA", planProposal([planMember("A")])]]);
+
+		const requestA = setup.requests.find((request) => request.planMemberId === "A")!;
+		const { requestId: _requestId, ...evidenceWithoutRequestId } = evidenceForPlanRequest(
+			"ev-no-request",
+			requestA,
+		);
+		setup.evidence.down([["DATA", evidenceWithoutRequestId]]);
+
+		expect(setup.issues.map((item) => item.code)).not.toContain("dangling-ref");
+		expect(
+			setup.status.find((status) => status.state === "completed" && status.planMemberId === "A"),
+		).toMatchObject({
+			state: "completed",
+			planMemberId: "A",
+			requestId: requestA.requestId,
+			effectRunId: requestA.effectRunId,
+		});
+		expect(setup.results.at(-1)).toMatchObject({ status: "succeeded" });
+	});
+
+	it("replays early WorkItemEffectPlan evidence once the admitted plan is visible", () => {
+		const setup = planSetup();
+
+		setup.evidence.down([
+			[
+				"DATA",
+				evidenceFact("ev-a-early", {
+					effectRunId: "effect-run:work-item:wi-1:effect-plan:1:effect-plan-1:A",
+					requestId: "work-item:wi-1:effect-plan:1:effect-plan-1:A",
+					executionInputRevision: 1,
+					planId: "effect-plan-1",
+					planMemberId: "A",
+					metadata: {
+						requestId: "metadata-request-should-not-be-needed",
+					},
+				}),
+			],
+		]);
+		setup.facts.down([["DATA", workItemCreatedFromDraft("wi-1", draft())]]);
+		setup.proposals.down([
+			["DATA", planProposal([planMember("A"), planMember("B", { dependsOnMemberIds: ["A"] })])],
+		]);
+
+		expect(setup.requests.map((request) => request.planMemberId)).toEqual(["A", "B"]);
+
+		setup.evidence.down([["DATA", evidenceForPlanRequest("ev-b", setup.requests.at(-1)!)]]);
+		expect(setup.results.at(-1)).toMatchObject({ status: "succeeded" });
+		expect(setup.results.at(-1)?.memberResults).toContainEqual(
+			expect.objectContaining({
+				planMemberId: "A",
+				requestId: "work-item:wi-1:effect-plan:1:effect-plan-1:A",
+			}),
+		);
+	});
+
+	it("rejects WorkItemEffectPlan evidence for unknown plan members", () => {
+		const setup = planSetup();
+
+		setup.facts.down([["DATA", workItemCreatedFromDraft("wi-1", draft())]]);
+		setup.proposals.down([["DATA", planProposal([planMember("A")])]]);
+		setup.evidence.down([
+			[
+				"DATA",
+				evidenceFact("ev-ghost", {
+					metadata: {
+						executionInputRevision: 1,
+						planId: "effect-plan-1",
+						planMemberId: "ghost",
+					},
+				}),
+			],
+		]);
+
+		expect(setup.issues.at(-1)).toMatchObject({ code: "dangling-ref" });
+		expect(setup.status.at(-1)).toMatchObject({
+			state: "rejected",
+			planMemberId: "ghost",
+		});
+		expect(setup.results).toEqual([]);
+	});
+
+	it("does not release admitted WorkItemEffectPlan members after the WorkItem revision changes", () => {
+		const setup = planSetup();
+
+		setup.facts.down([["DATA", workItemCreatedFromDraft("wi-1", draft())]]);
+		setup.proposals.down([
+			["DATA", planProposal([planMember("A"), planMember("B", { dependsOnMemberIds: ["A"] })])],
+		]);
+		expect(setup.requests.map((request) => request.planMemberId)).toEqual(["A"]);
+
+		setup.facts.down([
+			[
+				"DATA",
+				{
+					kind: "work-item-patched",
+					eventId: "wi-1:detail-after-admit",
+					workItemId: "wi-1",
+					patch: { detail: "new execution input" },
+				},
+			],
+		]);
+		setup.evidence.down([["DATA", evidenceForPlanRequest("ev-a", setup.requests.at(-1)!)]]);
+
+		expect(setup.requests.map((request) => request.planMemberId)).toEqual(["A"]);
+		expect(setup.status).toContainEqual(
+			expect.objectContaining({
+				state: "stale",
+				issues: [expect.objectContaining({ code: "stale-execution-input" })],
+			}),
+		);
+	});
+
+	it("fails a WorkItemEffectPlan when a failed optional dependency blocks required work", () => {
+		const setup = planSetup();
+
+		setup.facts.down([["DATA", workItemCreatedFromDraft("wi-1", draft())]]);
+		setup.proposals.down([
+			[
+				"DATA",
+				planProposal([
+					planMember("A", { required: false }),
+					planMember("B", { dependsOnMemberIds: ["A"] }),
+				]),
+			],
+		]);
+
+		setup.evidence.down([
+			[
+				"DATA",
+				evidenceForPlanRequest("ev-a", setup.requests.at(-1)!, {
+					status: "failed",
+					error: { kind: "issue", code: "optional-failed", message: "optional failed" },
+				}),
+			],
+		]);
+
+		expect(setup.requests.map((request) => request.planMemberId)).toEqual(["A"]);
+		expect(setup.results.at(-1)).toMatchObject({ status: "failed" });
+	});
+});
diff --git a/packages/ts/src/__tests__/work-item-workspace-proposals-d429.test.ts b/packages/ts/src/__tests__/work-item-workspace-proposals-d429.test.ts
new file mode 100644
index 00000000..7a64df7a
--- /dev/null
+++ b/packages/ts/src/__tests__/work-item-workspace-proposals-d429.test.ts
@@ -0,0 +1,418 @@
+import { describe, expect, it } from "vitest";
+import {
+	assertWorkspaceProposalDataOnly,
+	decideWorkspaceProposalAdmission,
+	projectWorkspaceProposalApplicationStatus,
+	recordWorkspaceProposal,
+	type WorkspaceProposalAdmissionDecision,
+	type WorkspaceProposalAdmissionMaterial,
+	type WorkspaceProposalReadyRequest,
+	type WorkspaceProposalRecorded,
+} from "../solutions/work-item/scheduling.js";
+
+const actorRef = { kind: "actor", id: "actor-1" } as const;
+const capabilityRef = { kind: "capability", id: "work-item-write" } as const;
+const policyRef = { kind: "workspace-proposal-policy", id: "policy-1" } as const;
+const projectionRef = { kind: "workspace-projection-bundle", id: "bundle-1" } as const;
+const sourceRef = { kind: "side-panel-preview", id: "preview-1" } as const;
+const targetRef = { kind: "work-item", id: "wi-1", revision: 1 } as const;
+
+describe("Workspace proposal durable spine (D429)", () => {
+	it("records a ready proposal and applies only family-specific emitted fact refs", () => {
+		const recordResult = recordWorkspaceProposal(readyRequest());
+		expect(recordResult.issues).toEqual([]);
+		expect(recordResult.status.state).toBe("recorded");
+
+		const record = mustRecord(recordResult.record);
+		expect(record).toMatchObject({
+			kind: "workspace-proposal-recorded",
+			proposalId: "proposal-1",
+			intakeRequestId: "intake-1",
+			idempotencyKey: "idem-1",
+			workspaceId: "workspace-1",
+			proposalFamily: "work-item-domain-action",
+			loweringKind: "side-panel-domain-action",
+		});
+
+		const admission = decideWorkspaceProposalAdmission(record, admissionMaterial());
+		expect(admission.decision.status).toBe("admitted");
+		expect(admission.issues).toEqual([]);
+
+		const application = projectWorkspaceProposalApplicationStatus(record, admission.decision, {
+			applicationId: "application-1",
+			emittedFactRefs: [
+				{
+					proposalFamily: "work-item-domain-action",
+					factKind: "work-item-domain-action-application",
+					factId: "family-application-1",
+				},
+			],
+		});
+
+		expect(application.status.state).toBe("applied");
+		expect(application.recorded?.emittedFactRefs).toEqual(application.status.emittedFactRefs);
+		expect(Object.hasOwn(application.status, "created")).toBe(false);
+		expect(Object.hasOwn(application.status, "workItemCreated")).toBe(false);
+		expect(Object.hasOwn(application.status, "requiredInputSatisfied")).toBe(false);
+	});
+
+	it("blocks malformed recording and unsupported families before admission/application", () => {
+		const malformed = recordWorkspaceProposal({
+			kind: "workspace-proposal-ready-request",
+			proposalId: "",
+			workspaceId: "workspace-1",
+		});
+		expect(malformed.status.state).toBe("blocked");
+		expect(malformed.issues.map((entry) => entry.code)).toContain("missing-proposal-id");
+
+		const unsupported = recordWorkspaceProposal(readyRequest({ proposalFamily: "unknown-family" }));
+		expect(unsupported.status.state).toBe("blocked");
+		expect(unsupported.issues.map((entry) => entry.code)).toContain("unsupported-proposal-family");
+	});
+
+	it("defaults no matching policy to needs-review rather than admitted", () => {
+		const record = mustRecord(recordWorkspaceProposal(readyRequest()).record);
+		const admission = decideWorkspaceProposalAdmission(record, {
+			...admissionMaterial(),
+			policies: [],
+		});
+
+		expect(admission.decision.status).toBe("needs-review");
+		expect(admission.issues.map((entry) => entry.code)).toContain("missing-policy");
+	});
+
+	it("requires an explicit admitting policy outcome", () => {
+		const record = mustRecord(recordWorkspaceProposal(readyRequest()).record);
+		const admission = decideWorkspaceProposalAdmission(record, {
+			...admissionMaterial(),
+			policies: [
+				{
+					kind: "workspace-proposal-admission-policy",
+					policyId: "policy-without-outcome",
+					proposalFamilies: ["work-item-domain-action"],
+				},
+			],
+		});
+
+		expect(admission.decision.status).toBe("needs-review");
+		expect(admission.issues.map((entry) => entry.code)).toContain("missing-admission-outcome");
+	});
+
+	it("fails closed for missing policy, capability, idempotency, and freshness evidence", () => {
+		const record = mustRecord(recordWorkspaceProposal(readyRequest()).record);
+		const admission = decideWorkspaceProposalAdmission(record, {
+			decisionId: "decision-missing-evidence",
+		});
+
+		expect(admission.decision.status).toBe("needs-review");
+		expect(admission.issues.map((entry) => entry.code)).toEqual(
+			expect.arrayContaining([
+				"missing-policy",
+				"missing-capability-evidence",
+				"missing-idempotency-evidence",
+				"missing-freshness-evidence",
+				"missing-projection-freshness-evidence",
+			]),
+		);
+	});
+
+	it("fails closed for stale, unknown, duplicate, rejected, blocked, and conflicting admission material", () => {
+		const record = mustRecord(recordWorkspaceProposal(readyRequest()).record);
+
+		expect(
+			decideWorkspaceProposalAdmission(record, admissionMaterial({ freshnessState: "stale" }))
+				.decision.status,
+		).toBe("blocked");
+		expect(
+			decideWorkspaceProposalAdmission(
+				record,
+				admissionMaterial({ freshnessState: "unknown" }),
+			).issues.map((entry) => entry.code),
+		).toContain("unknown-target-ref");
+		expect(
+			decideWorkspaceProposalAdmission(record, admissionMaterial({ idempotencyState: "conflict" }))
+				.decision.status,
+		).toBe("blocked");
+		expect(
+			decideWorkspaceProposalAdmission(record, admissionMaterial({ idempotencyState: "duplicate" }))
+				.decision.status,
+		).toBe("rejected");
+		expect(
+			decideWorkspaceProposalAdmission(record, admissionMaterial({ policyOutcome: "rejected" }))
+				.decision.status,
+		).toBe("rejected");
+		expect(
+			decideWorkspaceProposalAdmission(record, admissionMaterial({ policyOutcome: "blocked" }))
+				.decision.status,
+		).toBe("blocked");
+		expect(
+			decideWorkspaceProposalAdmission(record, {
+				...admissionMaterial(),
+				freshnessEvidence: [
+					{ kind: "workspace-proposal-freshness-evidence", targetRef, state: "fresh" },
+					{ kind: "workspace-proposal-freshness-evidence", targetRef, state: "stale" },
+				],
+			}).issues.map((entry) => entry.code),
+		).toContain("conflicting-freshness-evidence");
+	});
+
+	it("requires policy-required capabilities and projection freshness evidence", () => {
+		const record = mustRecord(recordWorkspaceProposal(readyRequest()).record);
+		const extraCapabilityRef = { kind: "capability", id: "extra-write" } as const;
+		const missingCapability = decideWorkspaceProposalAdmission(record, {
+			...admissionMaterial(),
+			policies: [
+				{
+					kind: "workspace-proposal-admission-policy",
+					policyId: "policy-extra-capability",
+					proposalFamilies: ["work-item-domain-action"],
+					outcome: "admitted",
+					requiredCapabilityRefs: [extraCapabilityRef],
+				},
+			],
+		});
+		expect(missingCapability.decision.status).toBe("blocked");
+		expect(missingCapability.issues.map((entry) => entry.code)).toContain(
+			"missing-policy-required-capability",
+		);
+
+		const staleProjection = decideWorkspaceProposalAdmission(
+			record,
+			admissionMaterial({ projectionFreshnessState: "stale" }),
+		);
+		expect(staleProjection.decision.status).toBe("blocked");
+		expect(staleProjection.issues.map((entry) => entry.code)).toContain("stale-projection-ref");
+	});
+
+	it("blocks application for non-admitted, issueful, or envelope-mismatched decisions", () => {
+		const record = mustRecord(recordWorkspaceProposal(readyRequest()).record);
+		const admitted = decideWorkspaceProposalAdmission(record, admissionMaterial()).decision;
+
+		expect(
+			projectWorkspaceProposalApplicationStatus(
+				record,
+				{ ...admitted, status: "needs-review" },
+				{
+					applicationId: "application-review",
+					emittedFactRefs: [familyRef()],
+				},
+			).status.state,
+		).toBe("blocked");
+
+		const issueful = {
+			...admitted,
+			issues: [
+				{
+					kind: "issue",
+					source: "workspace-proposal",
+					code: "manual-review-required",
+					message: "review",
+					severity: "error",
+				},
+			],
+		} satisfies WorkspaceProposalAdmissionDecision;
+		expect(
+			projectWorkspaceProposalApplicationStatus(record, issueful, {
+				applicationId: "application-issueful",
+				emittedFactRefs: [familyRef()],
+			}).issues.map((entry) => entry.code),
+		).toContain("admission-decision-has-issues");
+
+		expect(
+			projectWorkspaceProposalApplicationStatus(
+				record,
+				{ ...admitted, workspaceId: "other-workspace" },
+				{ applicationId: "application-mismatch", emittedFactRefs: [familyRef()] },
+			).issues.map((entry) => entry.code),
+		).toContain("proposal-envelope-mismatch");
+	});
+
+	it("leaves generic application pending without family projector refs and blocks mismatched refs", () => {
+		const record = mustRecord(recordWorkspaceProposal(readyRequest()).record);
+		const decision = decideWorkspaceProposalAdmission(record, admissionMaterial()).decision;
+
+		const pending = projectWorkspaceProposalApplicationStatus(record, decision, {
+			applicationId: "application-no-refs",
+		});
+		expect(pending.status.state).toBe("pending");
+		expect(pending.status.code).toBe("pending-family-emitted-fact-refs");
+		expect(pending.issues).toEqual([]);
+		expect(pending.status).toMatchObject({
+			idempotencyKey: "idem-1",
+			targetRefs: [targetRef],
+			policyRefs: [policyRef],
+		});
+		expect(
+			projectWorkspaceProposalApplicationStatus(record, decision, {
+				applicationId: "application-bad-refs",
+				emittedFactRefs: [{ ...familyRef(), proposalFamily: "work-item-spawn" }],
+			}).issues.map((entry) => entry.code),
+		).toContain("family-ref-mismatch");
+		expect(
+			projectWorkspaceProposalApplicationStatus(record, decision, {
+				applicationId: "application-fact-blob",
+				emittedFactRefs: [
+					{
+						...familyRef(),
+						fact: { kind: "work-item-created", id: "not-a-ref" },
+					} as unknown as ReturnType<typeof familyRef>,
+				],
+			}).issues.map((entry) => entry.code),
+		).toContain("malformed-family-emitted-fact-ref");
+		expect(
+			projectWorkspaceProposalApplicationStatus(record, decision, {
+				applicationId: "application-unsupported-fact-kind",
+				emittedFactRefs: [{ ...familyRef(), factKind: "required-input-response-applied" }],
+			}).issues.map((entry) => entry.code),
+		).toContain("unsupported-family-fact-kind");
+	});
+
+	it("rejects runtime/provider/credential/command/callback material and non-data shapes", () => {
+		expect(
+			recordWorkspaceProposal(readyRequest({ metadata: { callback: "handleSubmit" } })).issues.map(
+				(entry) => entry.code,
+			),
+		).toContain("forbidden-runtime-material");
+		expect(
+			recordWorkspaceProposal(
+				readyRequest({ metadata: { providerClient: "runtime-private" } }),
+			).issues.map((entry) => entry.code),
+		).toContain("forbidden-runtime-material");
+		expect(
+			recordWorkspaceProposal(
+				readyRequest({ metadata: { credentialRef: "credential-1" } }),
+			).issues.map((entry) => entry.code),
+		).toContain("forbidden-runtime-material");
+
+		expect(() => assertWorkspaceProposalDataOnly({ fn: () => undefined })).toThrow(
+			/not structured data/,
+		);
+		expect(() => assertWorkspaceProposalDataOnly({ value: "https://example.com/runtime" })).toThrow(
+			/not proposal data material/,
+		);
+		expect(() => assertWorkspaceProposalDataOnly({ [Symbol("hidden")]: "x" })).toThrow(
+			/non-string key/,
+		);
+		const accessor = {};
+		Object.defineProperty(accessor, "derived", { get: () => "nope" });
+		expect(() => assertWorkspaceProposalDataOnly(accessor)).toThrow(/accessor/);
+		const cycle: Record<string, unknown> = {};
+		cycle.self = cycle;
+		expect(() => assertWorkspaceProposalDataOnly(cycle)).toThrow(/cycle/);
+		const sparse = ["ok"];
+		sparse.length = 2;
+		expect(() => assertWorkspaceProposalDataOnly(sparse)).toThrow(/sparse array hole/);
+		const shared = { kind: "source", id: "shared" };
+		expect(() => assertWorkspaceProposalDataOnly({ left: shared, right: shared })).not.toThrow();
+		expect(() => assertWorkspaceProposalDataOnly({ tokenCount: 12 })).not.toThrow();
+	});
+
+	it("records immutable durable material detached from caller-owned drafts", () => {
+		const request = readyRequest();
+		const result = recordWorkspaceProposal(request);
+		const record = mustRecord(result.record);
+		const mutableRequest = request as unknown as {
+			draft: { patch: { summary: string } };
+			readonly targetRefs: { [index: number]: WorkspaceProposalReadyRequest["targetRefs"][number] };
+		};
+		mutableRequest.draft.patch.summary = "mutated";
+		mutableRequest.targetRefs[0] = {
+			kind: "work-item",
+			id: "other",
+		};
+
+		expect((record.draft as { patch: { summary: string } }).patch.summary).toBe("Updated");
+		expect(record.targetRefs[0]).toEqual(targetRef);
+		expect(() => {
+			(
+				record.targetRefs as unknown as {
+					[index: number]: WorkspaceProposalReadyRequest["targetRefs"][number];
+				}
+			)[0] = targetRef;
+		}).toThrow();
+	});
+});
+
+function readyRequest(
+	opts: Partial<WorkspaceProposalReadyRequest<Record<string, unknown>>> = {},
+): WorkspaceProposalReadyRequest<Record<string, unknown>> {
+	return {
+		kind: "workspace-proposal-ready-request",
+		proposalId: "proposal-1",
+		intakeRequestId: "intake-1",
+		idempotencyKey: "idem-1",
+		workspaceId: "workspace-1",
+		proposalFamily: "work-item-domain-action",
+		loweringKind: "side-panel-domain-action",
+		draft: { actionKind: "patch", patch: { summary: "Updated" } },
+		targetRefs: [targetRef],
+		actorRef,
+		capabilityRefs: [capabilityRef],
+		policyRefs: [policyRef],
+		projectionBundleRefs: [projectionRef],
+		sourceRefs: [sourceRef],
+		audit: { auditId: "audit-1", actorId: "actor-1" },
+		...opts,
+	};
+}
+
+function admissionMaterial(
+	opts: {
+		readonly freshnessState?: "fresh" | "stale" | "unknown";
+		readonly projectionFreshnessState?: "fresh" | "stale" | "unknown";
+		readonly idempotencyState?: "unique" | "duplicate" | "conflict";
+		readonly policyOutcome?: "admitted" | "rejected" | "blocked" | "needs-review";
+	} = {},
+): WorkspaceProposalAdmissionMaterial {
+	return {
+		decisionId: "decision-1",
+		policies: [
+			{
+				kind: "workspace-proposal-admission-policy",
+				policyId: "policy-1",
+				proposalFamilies: ["work-item-domain-action"],
+				outcome: opts.policyOutcome ?? "admitted",
+			},
+		],
+		idempotencyEvidence: {
+			kind: "workspace-proposal-idempotency-evidence",
+			idempotencyKey: "idem-1",
+			state: opts.idempotencyState ?? "unique",
+		},
+		freshnessEvidence: [
+			{
+				kind: "workspace-proposal-freshness-evidence",
+				targetRef,
+				state: opts.freshnessState ?? "fresh",
+			},
+		],
+		projectionFreshnessEvidence: [
+			{
+				kind: "workspace-proposal-projection-freshness-evidence",
+				projectionBundleRef: projectionRef,
+				state: opts.projectionFreshnessState ?? "fresh",
+			},
+		],
+		capabilityEvidence: [
+			{
+				kind: "workspace-proposal-capability-evidence",
+				capabilityRef,
+				state: "present",
+			},
+		],
+		sourceRefs: [sourceRef],
+	};
+}
+
+function familyRef() {
+	return {
+		proposalFamily: "work-item-domain-action" as const,
+		factKind: "work-item-domain-action-application",
+		factId: "family-application-1",
+	};
+}
+
+function mustRecord(record: WorkspaceProposalRecorded | undefined): WorkspaceProposalRecorded {
+	expect(record).toBeDefined();
+	return record as WorkspaceProposalRecorded;
+}
diff --git a/packages/ts/src/__tests__/work-item-workspace-proposals-d430-family-applications.test.ts b/packages/ts/src/__tests__/work-item-workspace-proposals-d430-family-applications.test.ts
new file mode 100644
index 00000000..ba10265b
--- /dev/null
+++ b/packages/ts/src/__tests__/work-item-workspace-proposals-d430-family-applications.test.ts
@@ -0,0 +1,6405 @@
+import { describe, expect, it } from "vitest";
+import { graph } from "../graph/graph.js";
+import {
+	decideWorkspaceProposalAdmission,
+	isWorkspaceProposalProjectionReleaseMaterial,
+	prepareWorkspaceProposalRepairReviewDecisionRecordingInput,
+	prepareWorkspaceProposalRepairSuccessorProposalReadyRequest,
+	previewWorkspaceProposalRepairSuccessorProposalIntake,
+	projectWorkspaceProposalApplicationStatus,
+	projectWorkspaceProposalDomainActionApplicationStatus,
+	projectWorkspaceProposalFamilyApplicationDiagnostics,
+	projectWorkspaceProposalFamilyApplicationReadModel,
+	projectWorkspaceProposalFamilyApplicationReadModels,
+	projectWorkspaceProposalFamilyOutcomeDetailSupplyResults,
+	projectWorkspaceProposalFamilyOutcomeIndex,
+	projectWorkspaceProposalRepairActionDescriptors,
+	projectWorkspaceProposalRepairActionDisplayPolicyAdvisory,
+	projectWorkspaceProposalRepairReviewDecisionRecordings,
+	projectWorkspaceProposalRepairReviewRequests,
+	projectWorkspaceProposalRepairReviewStatuses,
+	projectWorkspaceProposalRepairSuccessorProposalIntakePreview,
+	projectWorkspaceProposalRequiredInputResponseApplication,
+	projectWorkspaceProposalWorkItemLinkApplication,
+	projectWorkspaceProposalWorkItemSpawnApplication,
+	type RequiredInputGate,
+	type RequiredInputResponseProposed,
+	recordWorkspaceProposal,
+	recordWorkspaceProposalDomainActionOutcome,
+	recordWorkspaceProposalRepairReviewDecision,
+	recordWorkspaceProposalRequiredInputResponseOutcome,
+	recordWorkspaceProposalWorkItemLinkOutcome,
+	recordWorkspaceProposalWorkItemSpawnOutcome,
+	validateWorkspaceProposalApplicationEnvelope,
+	validateWorkspaceProposalProjectionReleaseMaterial,
+	validateWorkspaceProposalRepairActionDisplayPolicyAdvisory,
+	validateWorkspaceProposalRepairActionIntent,
+	type WorkItemAuthoringFact,
+	type WorkItemDraft,
+	type WorkItemLinked,
+	type WorkItemLinkProjection,
+	type WorkItemProjection,
+	type WorkItemSpawnProposed,
+	type WorkspaceProposalAdmissionDecision,
+	type WorkspaceProposalAdmissionMaterial,
+	type WorkspaceProposalApplicationStatus,
+	type WorkspaceProposalDomainActionApplicationContext,
+	type WorkspaceProposalFamily,
+	type WorkspaceProposalFamilyApplicationReadModelQuery,
+	type WorkspaceProposalFamilyOutcomeDetailSupplyRequest,
+	type WorkspaceProposalFamilyOutcomeDetailSupplyResult,
+	type WorkspaceProposalProjectionRelease,
+	type WorkspaceProposalProjectionReleaseDiagnostic,
+	type WorkspaceProposalReadyRequest,
+	type WorkspaceProposalRecorded,
+	type WorkspaceProposalRepairActionDescriptor,
+	type WorkspaceProposalRepairActionDisplayPolicyAdvisory,
+	type WorkspaceProposalRepairActionIntent,
+	type WorkspaceProposalRepairActionIntentValidationResult,
+	type WorkspaceProposalRepairReviewDecision,
+	type WorkspaceProposalRepairReviewDecisionRecordingInput,
+	type WorkspaceProposalRepairReviewRequest,
+	type WorkspaceProposalRepairSuccessorProposalIntakePreview,
+	type WorkspaceProposalRepairSuccessorProposalReadyRequestPreparationInput,
+	type WorkspaceProposalRepairSuccessorProposalReadyRequestPreparationResult,
+	type WorkspaceProposalRequiredInputResponseApplicationContext,
+	type WorkspaceProposalWorkItemLinkApplicationContext,
+	type WorkspaceProposalWorkItemSpawnApplicationContext,
+	workspaceProposalApplicationFamilyRef,
+	workspaceProposalDomainActionApplicationProjector,
+	workspaceProposalFamilyApplicationDiagnosticProjector,
+	workspaceProposalFamilyApplicationReadModelProjector,
+	workspaceProposalFamilyApplicationReadModelsProjector,
+	workspaceProposalFamilyOutcomeDetailSupplyProjector,
+	workspaceProposalProjectionReleaseDiagnosticProjector,
+	workspaceProposalRepairActionDescriptorProjector,
+	workspaceProposalRepairActionDisplayPolicyAdvisoryProjector,
+	workspaceProposalRepairActionIntentProjector,
+	workspaceProposalRepairReviewDecisionRecordingProjector,
+	workspaceProposalRepairReviewProjector,
+	workspaceProposalRepairReviewStatusProjector,
+	workspaceProposalRepairSuccessorProposalIntakePreviewProjector,
+	workspaceProposalRepairSuccessorProposalReadyRequestPreparationProjector,
+	workspaceProposalRequiredInputResponseApplicationProjector,
+	workspaceProposalWorkItemLinkApplicationProjector,
+	workspaceProposalWorkItemSpawnApplicationProjector,
+} from "../solutions/work-item/scheduling.js";
+
+const actorRef = { kind: "actor", id: "actor-1" } as const;
+const capabilityRef = { kind: "capability", id: "work-item-write" } as const;
+const policyRef = { kind: "workspace-proposal-policy", id: "policy-1" } as const;
+const projectionRef = { kind: "workspace-projection-bundle", id: "bundle-1" } as const;
+const sourceRef = { kind: "side-panel-preview", id: "preview-1" } as const;
+
+describe("Workspace proposal family application helpers (D430)", () => {
+	it("validates application envelopes and keeps family refs on append-only fact ids", () => {
+		const record = proposalRecord("work-item-link", linkDraft());
+		const decision = admittedDecision(record);
+
+		expect(validateWorkspaceProposalApplicationEnvelope(record, decision)).toEqual([]);
+		expect(
+			validateWorkspaceProposalApplicationEnvelope(record, decision, {
+				expectedFamily: "work-item-spawn",
+			}).map((entry) => entry.code),
+		).toContain("unexpected-proposal-family");
+		expect(
+			validateWorkspaceProposalApplicationEnvelope(record, {
+				...decision,
+				workspaceId: "other-workspace",
+			}).map((entry) => entry.code),
+		).toContain("proposal-envelope-mismatch");
+		expect(
+			validateWorkspaceProposalApplicationEnvelope(record, {
+				...decision,
+				status: "needs-review",
+			}).map((entry) => entry.code),
+		).toContain("proposal-not-admitted");
+
+		const linked = {
+			kind: "work-item-linked",
+			eventId: "event-1",
+			linkId: "link-1",
+			fromWorkItemId: "wi-1",
+			toWorkItemId: "wi-2",
+			linkKind: "blocks",
+		} satisfies WorkItemLinked;
+		expect(workspaceProposalApplicationFamilyRef("work-item-link", linked)).toEqual({
+			proposalFamily: "work-item-link",
+			factKind: "work-item-linked",
+			factId: "event-1",
+			sourceRefs: [],
+		});
+		expect(() =>
+			workspaceProposalApplicationFamilyRef("work-item-link", {
+				kind: "work-item-linked",
+				linkId: "link-1",
+			} as unknown as Parameters<typeof workspaceProposalApplicationFamilyRef>[1]),
+		).toThrow(/append-only fact id/);
+	});
+
+	it("clamps generic applied overrides when validation has issues or missing family refs", () => {
+		const record = proposalRecord("work-item-link", linkDraft());
+		const decision = admittedDecision(record);
+		const ref = workspaceProposalApplicationFamilyRef("work-item-link", {
+			kind: "work-item-linked",
+			eventId: "event-override",
+			linkId: "link-1",
+			fromWorkItemId: "wi-1",
+			toWorkItemId: "wi-2",
+			linkKind: "blocks",
+		} satisfies WorkItemLinked);
+
+		const issueful = projectWorkspaceProposalApplicationStatus(
+			record,
+			{
+				...decision,
+				status: "needs-review",
+			},
+			{
+				applicationId: "application-override-issueful",
+				emittedFactRefs: [ref],
+				state: "applied",
+			},
+		);
+		expect(issueful.status.state).toBe("blocked");
+		expect(issueful.status.emittedFactRefs).toEqual([]);
+		expect(issueful.recorded).toBeUndefined();
+
+		const missingRefs = projectWorkspaceProposalApplicationStatus(record, decision, {
+			applicationId: "application-override-missing-refs",
+			state: "applied",
+		});
+		expect(missingRefs.status.state).toBe("pending");
+		expect(missingRefs.status.emittedFactRefs).toEqual([]);
+		expect(missingRefs.recorded).toBeUndefined();
+
+		const recorded = projectWorkspaceProposalApplicationStatus(record, decision, {
+			applicationId: "application-override-recorded",
+			emittedFactRefs: [ref],
+			state: "recorded",
+		});
+		expect(recorded.status.state).toBe("recorded");
+		expect(recorded.status.emittedFactRefs).toEqual([ref]);
+		expect(recorded.recorded).toEqual(
+			expect.objectContaining({
+				applicationId: "application-override-recorded",
+				emittedFactRefs: [ref],
+			}),
+		);
+	});
+
+	it("applies Required Input response facts and blocks stale gates", () => {
+		const draft = {
+			kind: "required-input-response-proposed",
+			proposalId: "proposal-1",
+			requestId: "request-1",
+			workItemId: "wi-1",
+			value: "answer",
+		} satisfies RequiredInputResponseProposed<string>;
+		const record = proposalRecord("required-input-response", draft);
+		const decision = admittedDecision(record);
+		const gate = requiredInputGate();
+
+		const applied = projectWorkspaceProposalRequiredInputResponseApplication(record, decision, {
+			applicationId: "application-1",
+			gate,
+		});
+
+		expect(applied.status.state).toBe("applied");
+		expect(applied.applied?.kind).toBe("required-input-response-applied");
+		expect(applied.status.emittedFactRefs).toEqual([
+			expect.objectContaining({
+				proposalFamily: "required-input-response",
+				factKind: "required-input-response-applied",
+				factId: "application-1",
+			}),
+		]);
+
+		const stale = projectWorkspaceProposalRequiredInputResponseApplication(record, decision, {
+			applicationId: "application-stale",
+			gate: { ...gate, status: "stale" },
+		});
+		expect(stale.status.state).toBe("blocked");
+		expect(stale.applied).toBeUndefined();
+		expect(stale.status.issues.map((entry) => entry.code)).toContain("stale-target-ref");
+	});
+
+	it("applies WorkItem spawn facts with optional link refs and blocks duplicates", () => {
+		const draft = {
+			kind: "work-item-spawn-proposed",
+			proposalId: "proposal-1",
+			proposedWorkItemId: "child-1",
+			parentWorkItemId: "parent-1",
+			draft: workItemDraft("Child"),
+			idempotencyKey: "spawn-idem",
+		} satisfies WorkItemSpawnProposed;
+		const record = proposalRecord("work-item-spawn", draft);
+		const decision = admittedDecision(record);
+
+		const applied = projectWorkspaceProposalWorkItemSpawnApplication(record, decision, {
+			applicationId: "application-spawn",
+			linkParent: true,
+		});
+
+		expect(applied.status.state).toBe("applied");
+		expect(applied.created?.kind).toBe("work-item-created");
+		expect(applied.linked?.kind).toBe("work-item-linked");
+		expect(applied.created?.metadata).toMatchObject({
+			applicationProposalId: "proposal-1",
+			applicationDecisionId: "decision-1",
+			applicationIntakeRequestId: "intake-1",
+			applicationIdempotencyKey: "idem-1",
+		});
+		expect(applied.linked?.sourceRefs).toEqual(
+			expect.arrayContaining([
+				{ kind: "workspace-proposal-recorded", id: "proposal-1" },
+				{ kind: "workspace-proposal-admission-decision", id: "decision-1" },
+				{ kind: "workspace-proposal-application-status", id: "application-spawn" },
+			]),
+		);
+		expect(applied.status.emittedFactRefs).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({
+					factKind: "work-item-created",
+					factId: "application-spawn:work-item-created:child-1",
+				}),
+				expect.objectContaining({
+					factKind: "work-item-linked",
+					factId: "application-spawn:work-item-linked:parent-1:child-1",
+				}),
+			]),
+		);
+		expect(
+			applied.status.emittedFactRefs.find((ref) => ref.factKind === "work-item-linked")?.factId,
+		).not.toBe(applied.linked?.linkId);
+
+		const duplicate = projectWorkspaceProposalWorkItemSpawnApplication(record, decision, {
+			applicationId: "application-duplicate",
+			existingWorkItems: [workItem("child-1")],
+		});
+		expect(duplicate.status.state).toBe("blocked");
+		expect(duplicate.created).toBeUndefined();
+		expect(duplicate.status.issues.map((entry) => entry.code)).toContain("duplicate-id");
+	});
+
+	it("applies WorkItem link and unlink facts with event ids as emitted refs", () => {
+		const record = proposalRecord("work-item-link", linkDraft());
+		const decision = admittedDecision(record);
+
+		const linked = projectWorkspaceProposalWorkItemLinkApplication(record, decision, {
+			applicationId: "application-link",
+			workItems: [workItem("wi-1"), workItem("wi-2")],
+		});
+
+		expect(linked.status.state).toBe("applied");
+		expect(linked.linked?.kind).toBe("work-item-linked");
+		expect(linked.status.emittedFactRefs[0]).toEqual(
+			expect.objectContaining({
+				factKind: "work-item-linked",
+				factId: "application-link:work-item-linked:link-1",
+			}),
+		);
+
+		const unlinkRecord = proposalRecord("work-item-link", {
+			...linkDraft(),
+			action: "unlink",
+		});
+		const unlinked = projectWorkspaceProposalWorkItemLinkApplication(
+			unlinkRecord,
+			admittedDecision(unlinkRecord),
+			{
+				applicationId: "application-unlink",
+				links: [linkProjection("link-1")],
+			},
+		);
+		expect(unlinked.status.state).toBe("applied");
+		expect(unlinked.unlinked?.kind).toBe("work-item-unlinked");
+		expect(unlinked.status.emittedFactRefs[0]).toEqual(
+			expect.objectContaining({
+				factKind: "work-item-unlinked",
+				factId: "application-unlink:work-item-unlinked:link-1",
+			}),
+		);
+
+		const unknown = projectWorkspaceProposalWorkItemLinkApplication(
+			unlinkRecord,
+			admittedDecision(unlinkRecord),
+			{
+				applicationId: "application-unknown-link",
+				links: [],
+			},
+		);
+		expect(unknown.status.state).toBe("blocked");
+		expect(unknown.status.issues.map((entry) => entry.code)).toContain("unknown-target-ref");
+
+		const malformedRecord = proposalRecord("work-item-link", {
+			kind: "work-item-link-proposal",
+		});
+		const malformed = projectWorkspaceProposalWorkItemLinkApplication(
+			malformedRecord,
+			admittedDecision(malformedRecord),
+			{ applicationId: "application-malformed-link" },
+		);
+		expect(malformed.status.state).toBe("blocked");
+		expect(malformed.linked).toBeUndefined();
+		expect(malformed.status.issues.map((entry) => entry.code)).toContain("missing-required-field");
+	});
+
+	it("indexes domain-action emitted authoring facts without emitting arbitrary facts", () => {
+		const record = proposalRecord("work-item-domain-action", {
+			kind: "work-item-domain-action-proposal-intake",
+			proposalId: "proposal-1",
+			workItemId: "wi-1",
+			actionKind: "patch",
+			payload: { patch: { summary: "Updated" } },
+		});
+		const decision = admittedDecision(record);
+		const status = projectWorkspaceProposalDomainActionApplicationStatus(record, decision, {
+			applicationId: "application-domain-action",
+			emittedFacts: [
+				{
+					kind: "work-item-patched",
+					eventId: "patch-event-1",
+					workItemId: "wi-1",
+					patch: { summary: "Updated" },
+					sourceRefs: d430ApplicationRefs(record, decision, "application-domain-action"),
+					metadata: { applicationIdempotencyKey: record.idempotencyKey },
+				},
+			],
+		});
+
+		expect(status.status.state).toBe("applied");
+		expect(status.status.emittedFactRefs).toEqual([
+			expect.objectContaining({
+				proposalFamily: "work-item-domain-action",
+				factKind: "work-item-patched",
+				factId: "patch-event-1",
+			}),
+		]);
+
+		const blocked = projectWorkspaceProposalDomainActionApplicationStatus(
+			record,
+			{ ...decision, status: "needs-review" },
+			{ applicationId: "application-domain-blocked", emittedFacts: [] },
+		);
+		expect(blocked.status.state).toBe("blocked");
+		expect(blocked.status.emittedFactRefs).toEqual([]);
+		expect(blocked.status.issues.map((entry) => entry.code)).toContain("proposal-not-admitted");
+	});
+
+	it("exposes graph-visible DATA projector topology and output nodes per family", () => {
+		const g = graph();
+		const requiredRecords = g.node<WorkspaceProposalRecorded<RequiredInputResponseProposed>>(
+			[],
+			null,
+			{ name: "requiredRecords" },
+		);
+		const spawnRecords = g.node<WorkspaceProposalRecorded<WorkItemSpawnProposed>>([], null, {
+			name: "spawnRecords",
+		});
+		const linkRecords = g.node<WorkspaceProposalRecorded<ReturnType<typeof linkDraft>>>([], null, {
+			name: "linkRecords",
+		});
+		const domainRecords = g.node<WorkspaceProposalRecorded>([], null, { name: "domainRecords" });
+		const decisions = g.node<WorkspaceProposalAdmissionDecision>([], null, { name: "decisions" });
+		const requiredInputContexts = g.node<WorkspaceProposalRequiredInputResponseApplicationContext>(
+			[],
+			null,
+			{
+				name: "requiredContexts",
+			},
+		);
+		const spawnContexts = g.node<WorkspaceProposalWorkItemSpawnApplicationContext>([], null, {
+			name: "spawnContexts",
+		});
+		const linkContexts = g.node<WorkspaceProposalWorkItemLinkApplicationContext>([], null, {
+			name: "linkContexts",
+		});
+		const domainContexts = g.node<WorkspaceProposalDomainActionApplicationContext>([], null, {
+			name: "domainContexts",
+		});
+		const gates = g.node<RequiredInputGate>([], null, { name: "gates" });
+		const workItems = g.node<WorkItemProjection>([], null, { name: "workItems" });
+		const links = g.node<WorkItemLinkProjection>([], null, { name: "links" });
+		const domainFacts = g.node<never>([], null, { name: "domainFacts" });
+
+		const required = workspaceProposalRequiredInputResponseApplicationProjector(g, {
+			name: "requiredProjector",
+			records: requiredRecords,
+			decisions,
+			contexts: requiredInputContexts,
+			gates,
+		});
+		const spawn = workspaceProposalWorkItemSpawnApplicationProjector(g, {
+			name: "spawnProjector",
+			records: spawnRecords,
+			decisions,
+			contexts: spawnContexts,
+			workItems,
+		});
+		const link = workspaceProposalWorkItemLinkApplicationProjector(g, {
+			name: "linkProjector",
+			records: linkRecords,
+			decisions,
+			contexts: linkContexts,
+			workItems,
+			links,
+		});
+		const domain = workspaceProposalDomainActionApplicationProjector(g, {
+			name: "domainProjector",
+			records: domainRecords,
+			decisions,
+			contexts: domainContexts,
+			emittedFacts: domainFacts,
+		});
+
+		expect(Object.keys(required).sort()).toEqual([
+			"applied",
+			"audit",
+			"issues",
+			"recorded",
+			"status",
+		]);
+		expect(Object.keys(spawn).sort()).toEqual([
+			"audit",
+			"created",
+			"issues",
+			"linked",
+			"recorded",
+			"status",
+		]);
+		expect(Object.keys(link).sort()).toEqual([
+			"audit",
+			"issues",
+			"linked",
+			"recorded",
+			"status",
+			"unlinked",
+		]);
+		expect(Object.keys(domain).sort()).toEqual(["audit", "issues", "recorded", "status"]);
+		expect(
+			g
+				.describe()
+				.nodes.filter((node) => node.factory.includes("workspaceProposal"))
+				.map((node) => node.factory)
+				.sort(),
+		).toEqual(
+			expect.arrayContaining([
+				"workspaceProposalRequiredInputResponseApplicationProjector",
+				"workspaceProposalWorkItemSpawnApplicationProjector",
+				"workspaceProposalWorkItemLinkApplicationProjector",
+				"workspaceProposalDomainActionApplicationProjector",
+			]),
+		);
+	});
+
+	it("diagnoses missing durable handoff material per family without status or family truth", () => {
+		const required = requiredInputProjectorHarness();
+		const spawn = spawnProjectorHarness();
+		const link = linkProjectorHarness();
+		const domain = domainActionProjectorHarness();
+
+		required.contexts.down([
+			[
+				"DATA",
+				{
+					kind: "workspace-proposal-required-input-response-application-context",
+					applicationId: "application-required-missing",
+					proposalId: "proposal-required-missing",
+				},
+			],
+		]);
+		spawn.contexts.down([
+			[
+				"DATA",
+				{
+					kind: "workspace-proposal-work-item-spawn-application-context",
+					applicationId: "application-spawn-missing",
+					proposalId: "proposal-spawn-missing",
+				},
+			],
+		]);
+		link.contexts.down([
+			[
+				"DATA",
+				{
+					kind: "workspace-proposal-work-item-link-application-context",
+					applicationId: "application-link-missing",
+					proposalId: "proposal-link-missing",
+				},
+			],
+		]);
+		domain.contexts.down([
+			[
+				"DATA",
+				{
+					kind: "workspace-proposal-domain-action-application-context",
+					applicationId: "application-domain-missing-durable",
+					proposalId: "proposal-domain-missing",
+				},
+			],
+		]);
+
+		for (const harness of [required, spawn, link, domain]) {
+			expect(harness.status).toEqual([]);
+			expect(harness.recorded).toEqual([]);
+			expect(harness.familyTruth).toEqual([]);
+			expect(harness.repairRequests).toEqual([]);
+			expect(harness.issues.map((entry) => entry.code)).toEqual([
+				"missing-workspace-proposal-recorded",
+				"missing-workspace-proposal-admission-decision",
+			]);
+			expect(harness.diagnostics.map((entry) => entry.code)).toEqual([
+				"missing-workspace-proposal-recorded",
+				"missing-workspace-proposal-admission-decision",
+				"missing-durable-handoff",
+			]);
+			expect(harness.diagnostics.map((entry) => entry.classification)).toEqual([
+				"missing-durable-handoff",
+				"missing-durable-handoff",
+				"missing-durable-handoff",
+			]);
+			expect(harness.audit).toEqual([
+				expect.objectContaining({
+					state: "pending",
+					code: "missing-durable-handoff",
+					emittedFactRefs: [],
+					metadata: expect.objectContaining({
+						diagnostic: "missing-durable-handoff",
+						missingRecord: true,
+						missingDecision: true,
+					}),
+				}),
+			]);
+		}
+	});
+
+	it("dedupes missing durable handoff diagnostics and recovers when record and decision arrive", () => {
+		const harness = requiredInputProjectorHarness();
+		const context = {
+			kind: "workspace-proposal-required-input-response-application-context",
+			applicationId: "application-required-late",
+			proposalId: "proposal-1",
+		} satisfies WorkspaceProposalRequiredInputResponseApplicationContext;
+		const record = proposalRecord("required-input-response", {
+			kind: "required-input-response-proposed",
+			proposalId: "proposal-1",
+			requestId: "request-1",
+			workItemId: "wi-1",
+			value: "answer",
+		} satisfies RequiredInputResponseProposed<string>);
+
+		harness.contexts.down([["DATA", context]]);
+		harness.contexts.down([["DATA", context]]);
+
+		expect(harness.issues.map((entry) => entry.code)).toEqual([
+			"missing-workspace-proposal-recorded",
+			"missing-workspace-proposal-admission-decision",
+		]);
+		expect(harness.audit).toHaveLength(1);
+		expect(harness.status).toEqual([]);
+		expect(harness.familyTruth).toEqual([]);
+		expect(harness.diagnostics.map((entry) => entry.code)).toEqual([
+			"missing-workspace-proposal-recorded",
+			"missing-workspace-proposal-admission-decision",
+			"missing-durable-handoff",
+		]);
+		expect(harness.repairRequests).toEqual([]);
+
+		harness.gates.down([["DATA", requiredInputGate()]]);
+		harness.records.down([["DATA", record]]);
+		harness.decisions.down([["DATA", admittedDecision(record)]]);
+
+		expect(harness.diagnostics.map((entry) => entry.code)).toContain(
+			"missing-workspace-proposal-recorded",
+		);
+		expect(harness.familyTruth).toHaveLength(1);
+		expect(harness.status.at(-1)).toMatchObject({
+			applicationId: "application-required-late",
+			state: "applied",
+			emittedFactRefs: [
+				expect.objectContaining({
+					factKind: "required-input-response-applied",
+					factId: "application-required-late",
+				}),
+			],
+		});
+		expect(harness.recorded.at(-1)).toMatchObject({
+			applicationId: "application-required-late",
+		});
+		expect(harness.repairRequests).toEqual([]);
+	});
+
+	it("diagnoses an explicit missing decisionId without falling back to another proposal decision", () => {
+		const harness = spawnProjectorHarness();
+		const record = proposalRecord("work-item-spawn", {
+			kind: "work-item-spawn-proposed",
+			proposalId: "proposal-1",
+			proposedWorkItemId: "child-1",
+			draft: workItemDraft("Child"),
+		} satisfies WorkItemSpawnProposed);
+		const decision = admittedDecision(record);
+
+		harness.records.down([["DATA", record]]);
+		harness.decisions.down([["DATA", decision]]);
+		harness.contexts.down([
+			[
+				"DATA",
+				{
+					kind: "workspace-proposal-work-item-spawn-application-context",
+					applicationId: "application-spawn-wrong-decision",
+					proposalId: record.proposalId,
+					decisionId: "decision-missing",
+				},
+			],
+		]);
+
+		expect(harness.familyTruth).toEqual([]);
+		expect(harness.status).toEqual([]);
+		expect(harness.recorded).toEqual([]);
+		expect(harness.issues.map((entry) => entry.code)).toEqual([
+			"missing-workspace-proposal-admission-decision",
+		]);
+		expect(harness.issues[0]?.refs).toContain(
+			"workspace-proposal-admission-decision:decision-missing",
+		);
+
+		harness.decisions.down([["DATA", admittedDecisionWithId(record, "decision-missing")]]);
+
+		expect(harness.familyTruth).toHaveLength(1);
+		expect(harness.status.at(-1)).toMatchObject({
+			applicationId: "application-spawn-wrong-decision",
+			decisionId: "decision-missing",
+			state: "applied",
+		});
+	});
+
+	it("graph required-input projector applies once and re-references on replay", () => {
+		const g = graph();
+		const records = g.node<WorkspaceProposalRecorded<RequiredInputResponseProposed<string>>>(
+			[],
+			null,
+			{ name: "records" },
+		);
+		const decisions = g.node<WorkspaceProposalAdmissionDecision>([], null, { name: "decisions" });
+		const contexts = g.node<WorkspaceProposalRequiredInputResponseApplicationContext>([], null, {
+			name: "contexts",
+		});
+		const gates = g.node<RequiredInputGate>([], null, { name: "gates" });
+		const bundle = workspaceProposalRequiredInputResponseApplicationProjector(g, {
+			records,
+			decisions,
+			contexts,
+			gates,
+		});
+		const applied = collectData(bundle.applied);
+		const status = collectData(bundle.status);
+
+		const record = proposalRecord("required-input-response", {
+			kind: "required-input-response-proposed",
+			proposalId: "proposal-1",
+			requestId: "request-1",
+			workItemId: "wi-1",
+			value: "answer",
+		} satisfies RequiredInputResponseProposed<string>);
+		const decision = admittedDecision(record);
+		records.down([["DATA", record]]);
+		decisions.down([["DATA", decision]]);
+		contexts.down([
+			[
+				"DATA",
+				{
+					kind: "workspace-proposal-required-input-response-application-context",
+					applicationId: "application-graph-required",
+					proposalId: record.proposalId,
+				},
+			],
+		]);
+		gates.down([["DATA", requiredInputGate()]]);
+		decisions.down([["DATA", decision]]);
+
+		expect(applied).toHaveLength(1);
+		expect(status.at(-1)).toMatchObject({
+			state: "applied",
+			emittedFactRefs: [
+				expect.objectContaining({
+					factKind: "required-input-response-applied",
+					factId: "application-graph-required",
+				}),
+			],
+		});
+
+		contexts.down([
+			[
+				"DATA",
+				{
+					kind: "workspace-proposal-required-input-response-application-context",
+					applicationId: "application-graph-required",
+					proposalId: record.proposalId,
+					sourceRefs: [{ kind: "manual-review", id: "changed-provenance" }],
+				},
+			],
+		]);
+
+		expect(applied).toHaveLength(1);
+		expect(status.at(-1)).toMatchObject({
+			applicationId: "application-graph-required",
+			state: "idempotency-conflict",
+			code: "idempotency-conflict",
+			emittedFactRefs: [],
+		});
+	});
+
+	it("graph required-input projector preserves distinct application attempts for one proposal", () => {
+		const g = graph();
+		const records = g.node<WorkspaceProposalRecorded<RequiredInputResponseProposed<string>>>(
+			[],
+			null,
+			{ name: "records" },
+		);
+		const decisions = g.node<WorkspaceProposalAdmissionDecision>([], null, { name: "decisions" });
+		const contexts = g.node<WorkspaceProposalRequiredInputResponseApplicationContext>([], null, {
+			name: "contexts",
+		});
+		const gates = g.node<RequiredInputGate>([], null, { name: "gates" });
+		const bundle = workspaceProposalRequiredInputResponseApplicationProjector(g, {
+			records,
+			decisions,
+			contexts,
+			gates,
+		});
+		const applied = collectData(bundle.applied);
+		const status = collectData(bundle.status);
+		const record = proposalRecord("required-input-response", {
+			kind: "required-input-response-proposed",
+			proposalId: "proposal-1",
+			requestId: "request-1",
+			workItemId: "wi-1",
+			value: "answer",
+		} satisfies RequiredInputResponseProposed<string>);
+
+		records.down([["DATA", record]]);
+		decisions.down([["DATA", admittedDecision(record)]]);
+		gates.down([["DATA", requiredInputGate()]]);
+		contexts.down([
+			[
+				"DATA",
+				{
+					kind: "workspace-proposal-required-input-response-application-context",
+					applicationId: "application-graph-required-a",
+					proposalId: record.proposalId,
+				},
+			],
+		]);
+		contexts.down([
+			[
+				"DATA",
+				{
+					kind: "workspace-proposal-required-input-response-application-context",
+					applicationId: "application-graph-required-b",
+					proposalId: record.proposalId,
+				},
+			],
+		]);
+
+		expect(applied.map((entry) => entry.applicationId)).toEqual([
+			"application-graph-required-a",
+			"application-graph-required-b",
+		]);
+		expect(status.at(-1)).toMatchObject({
+			applicationId: "application-graph-required-b",
+			state: "applied",
+		});
+	});
+
+	it("graph required-input projector blocks reused applicationId across proposal provenance", () => {
+		const g = graph();
+		const records = g.node<WorkspaceProposalRecorded<RequiredInputResponseProposed<string>>>(
+			[],
+			null,
+			{ name: "records" },
+		);
+		const decisions = g.node<WorkspaceProposalAdmissionDecision>([], null, { name: "decisions" });
+		const contexts = g.node<WorkspaceProposalRequiredInputResponseApplicationContext>([], null, {
+			name: "contexts",
+		});
+		const gates = g.node<RequiredInputGate>([], null, { name: "gates" });
+		const bundle = workspaceProposalRequiredInputResponseApplicationProjector(g, {
+			records,
+			decisions,
+			contexts,
+			gates,
+		});
+		const applied = collectData(bundle.applied);
+		const status = collectData(bundle.status);
+		const first = proposalRecord("required-input-response", {
+			kind: "required-input-response-proposed",
+			proposalId: "proposal-1",
+			requestId: "request-1",
+			workItemId: "wi-1",
+			value: "answer",
+		} satisfies RequiredInputResponseProposed<string>);
+		const second = proposalRecordWithProposalId(
+			"required-input-response",
+			{
+				kind: "required-input-response-proposed",
+				proposalId: "proposal-2",
+				requestId: "request-1",
+				workItemId: "wi-1",
+				value: "answer",
+			} satisfies RequiredInputResponseProposed<string>,
+			"proposal-2",
+		);
+
+		gates.down([["DATA", requiredInputGate()]]);
+		records.down([["DATA", first]]);
+		decisions.down([["DATA", admittedDecision(first)]]);
+		contexts.down([
+			[
+				"DATA",
+				{
+					kind: "workspace-proposal-required-input-response-application-context",
+					applicationId: "application-reused",
+					proposalId: first.proposalId,
+				},
+			],
+		]);
+		records.down([["DATA", second]]);
+		decisions.down([["DATA", admittedDecision(second)]]);
+		contexts.down([
+			[
+				"DATA",
+				{
+					kind: "workspace-proposal-required-input-response-application-context",
+					applicationId: "application-reused",
+					proposalId: second.proposalId,
+				},
+			],
+		]);
+
+		expect(applied).toHaveLength(1);
+		expect(status.at(-1)).toMatchObject({
+			applicationId: "application-reused",
+			proposalId: "proposal-2",
+			state: "idempotency-conflict",
+			code: "idempotency-conflict",
+			emittedFactRefs: [],
+		});
+	});
+
+	it("graph required-input projector reports malformed draft before missing gate repair", () => {
+		const g = graph();
+		const records = g.node<WorkspaceProposalRecorded<RequiredInputResponseProposed<string>>>(
+			[],
+			null,
+			{ name: "records" },
+		);
+		const decisions = g.node<WorkspaceProposalAdmissionDecision>([], null, { name: "decisions" });
+		const contexts = g.node<WorkspaceProposalRequiredInputResponseApplicationContext>([], null, {
+			name: "contexts",
+		});
+		const gates = g.node<RequiredInputGate>([], null, { name: "gates" });
+		const bundle = workspaceProposalRequiredInputResponseApplicationProjector(g, {
+			records,
+			decisions,
+			contexts,
+			gates,
+		});
+		const status = collectData(bundle.status);
+		const record = proposalRecord("required-input-response", {
+			kind: "wrong-required-input-draft",
+			proposalId: "proposal-1",
+		});
+
+		records.down([["DATA", record]]);
+		decisions.down([["DATA", admittedDecision(record)]]);
+		contexts.down([
+			[
+				"DATA",
+				{
+					kind: "workspace-proposal-required-input-response-application-context",
+					applicationId: "application-malformed-required",
+					proposalId: record.proposalId,
+				},
+			],
+		]);
+
+		expect(status.at(-1)).toMatchObject({
+			applicationId: "application-malformed-required",
+			state: "blocked",
+			emittedFactRefs: [],
+		});
+		expect(status.at(-1)?.issues.map((entry) => entry.code)).toEqual(["malformed-family-draft"]);
+	});
+
+	it("graph link projector blocks conflicting replay instead of re-emitting duplicate truth", () => {
+		const g = graph();
+		const records = g.node<WorkspaceProposalRecorded<ReturnType<typeof linkDraft>>>([], null, {
+			name: "records",
+		});
+		const decisions = g.node<WorkspaceProposalAdmissionDecision>([], null, { name: "decisions" });
+		const contexts = g.node<WorkspaceProposalWorkItemLinkApplicationContext>([], null, {
+			name: "contexts",
+		});
+		const workItems = g.node<WorkItemProjection>([], null, { name: "workItems" });
+		const bundle = workspaceProposalWorkItemLinkApplicationProjector(g, {
+			records,
+			decisions,
+			contexts,
+			workItems,
+		});
+		const linked = collectData(bundle.linked);
+		const status = collectData(bundle.status);
+		const first = proposalRecord("work-item-link", {
+			...linkDraft(),
+			eventId: "link-event-1",
+		});
+		const second = proposalRecordWithProposalId(
+			"work-item-link",
+			{
+				...linkDraft(),
+				proposalId: "proposal-2",
+				eventId: "link-event-1",
+			},
+			"proposal-2",
+		);
+		const secondDecision = admittedDecision(second);
+
+		workItems.down([["DATA", workItem("wi-1")]]);
+		workItems.down([["DATA", workItem("wi-2")]]);
+		records.down([["DATA", first]]);
+		decisions.down([["DATA", admittedDecision(first)]]);
+		contexts.down([
+			[
+				"DATA",
+				{
+					kind: "workspace-proposal-work-item-link-application-context",
+					applicationId: "application-link-1",
+					proposalId: first.proposalId,
+				},
+			],
+		]);
+		records.down([["DATA", second]]);
+		decisions.down([["DATA", secondDecision]]);
+		contexts.down([
+			[
+				"DATA",
+				{
+					kind: "workspace-proposal-work-item-link-application-context",
+					applicationId: "application-link-2",
+					proposalId: second.proposalId,
+				},
+			],
+		]);
+
+		expect(linked).toHaveLength(1);
+		expect(status.at(-1)).toMatchObject({
+			applicationId: "application-link-2",
+			state: "idempotency-conflict",
+			code: "idempotency-conflict",
+			emittedFactRefs: [],
+		});
+
+		const diagnostics = workspaceProposalFamilyApplicationDiagnosticProjector(g, {
+			applicationStatuses: bundle.status,
+		});
+		const repair = workspaceProposalRepairReviewProjector(g, {
+			applicationStatuses: bundle.status,
+		});
+		const diagnosticView = collectData(diagnostics.diagnostics);
+		const repairRequests = collectData(repair.requests);
+
+		contexts.down([
+			[
+				"DATA",
+				{
+					kind: "workspace-proposal-work-item-link-application-context",
+					applicationId: "application-link-2",
+					proposalId: second.proposalId,
+				},
+			],
+		]);
+
+		expect(linked).toHaveLength(1);
+		expect(diagnosticView.map((entry) => entry.code)).toContain("idempotency-conflict");
+		expect(repairRequests).toEqual([
+			expect.objectContaining({
+				kind: "workspace-proposal-repair-review-request",
+				applicationId: "application-link-2",
+				proposalId: "proposal-2",
+				decisionId: secondDecision.decisionId,
+				idempotencyKey: second.idempotencyKey,
+				proposalFamily: "work-item-link",
+				code: "idempotency-conflict",
+			}),
+		]);
+	});
+
+	it("graph domain-action adapter stays repair-needed until D430-provenance facts arrive", () => {
+		const g = graph();
+		const records = g.node<WorkspaceProposalRecorded>([], null, { name: "records" });
+		const decisions = g.node<WorkspaceProposalAdmissionDecision>([], null, { name: "decisions" });
+		const contexts = g.node<WorkspaceProposalDomainActionApplicationContext>([], null, {
+			name: "contexts",
+		});
+		const domainFacts = g.node<never>([], null, { name: "domainFacts" });
+		const bundle = workspaceProposalDomainActionApplicationProjector(g, {
+			records,
+			decisions,
+			contexts,
+			emittedFacts: domainFacts,
+		});
+		const status = collectData(bundle.status);
+		const record = proposalRecord("work-item-domain-action", {
+			kind: "work-item-domain-action-proposal-intake",
+			proposalId: "proposal-1",
+			workItemId: "wi-1",
+			actionKind: "patch",
+			payload: { patch: { summary: "Updated" } },
+		});
+
+		records.down([["DATA", record]]);
+		decisions.down([["DATA", admittedDecision(record)]]);
+		contexts.down([
+			[
+				"DATA",
+				{
+					kind: "workspace-proposal-domain-action-application-context",
+					applicationId: "application-domain-missing",
+					proposalId: record.proposalId,
+				},
+			],
+		]);
+
+		expect(status.at(-1)).toMatchObject({
+			state: "repair-needed",
+			code: "missing-domain-action-facts",
+			emittedFactRefs: [],
+		});
+		expect(
+			projectWorkspaceProposalRepairReviewRequests({
+				applicationStatuses: status,
+			}),
+		).toEqual([
+			expect.objectContaining({
+				kind: "workspace-proposal-repair-review-request",
+				applicationId: "application-domain-missing",
+				proposalId: record.proposalId,
+				decisionId: "decision-1",
+				idempotencyKey: record.idempotencyKey,
+				proposalFamily: "work-item-domain-action",
+				code: "missing-domain-action-facts",
+			}),
+		]);
+	});
+
+	it("graph domain-action adapter waits for every explicitly requested emitted fact id", () => {
+		const g = graph();
+		const records = g.node<WorkspaceProposalRecorded>([], null, { name: "records" });
+		const decisions = g.node<WorkspaceProposalAdmissionDecision>([], null, { name: "decisions" });
+		const contexts = g.node<WorkspaceProposalDomainActionApplicationContext>([], null, {
+			name: "contexts",
+		});
+		const domainFacts = g.node<WorkItemAuthoringFact>([], null, { name: "domainFacts" });
+		const bundle = workspaceProposalDomainActionApplicationProjector(g, {
+			records,
+			decisions,
+			contexts,
+			emittedFacts: domainFacts,
+		});
+		const status = collectData(bundle.status);
+		const record = proposalRecord("work-item-domain-action", {
+			kind: "work-item-domain-action-proposal-intake",
+			proposalId: "proposal-1",
+			workItemId: "wi-1",
+			actionKind: "patch",
+			payload: { patch: { summary: "Updated" } },
+		});
+		const decision = admittedDecision(record);
+		const applicationId = "application-domain-partial";
+		const fact = (eventId: string): WorkItemAuthoringFact => ({
+			kind: "work-item-patched",
+			eventId,
+			workItemId: "wi-1",
+			patch: { summary: eventId },
+			sourceRefs: d430ApplicationRefs(record, decision, applicationId),
+			metadata: { applicationIdempotencyKey: record.idempotencyKey },
+		});
+
+		records.down([["DATA", record]]);
+		decisions.down([["DATA", decision]]);
+		contexts.down([
+			[
+				"DATA",
+				{
+					kind: "workspace-proposal-domain-action-application-context",
+					applicationId,
+					proposalId: record.proposalId,
+					emittedFactIds: ["patch-event-1", "patch-event-2"],
+				},
+			],
+		]);
+		domainFacts.down([["DATA", fact("patch-event-1")]]);
+
+		expect(status.at(-1)).toMatchObject({
+			applicationId,
+			state: "repair-needed",
+			code: "missing-domain-action-facts",
+			emittedFactRefs: [],
+		});
+
+		domainFacts.down([["DATA", fact("patch-event-2")]]);
+
+		expect(status.at(-1)).toMatchObject({
+			applicationId,
+			state: "applied",
+			emittedFactRefs: [
+				expect.objectContaining({ factId: "patch-event-1" }),
+				expect.objectContaining({ factId: "patch-event-2" }),
+			],
+		});
+	});
+
+	it("fails closed before emitting family facts when family context carries runtime material", () => {
+		const requiredInputRecord = proposalRecord("required-input-response", {
+			kind: "required-input-response-proposed",
+			proposalId: "proposal-1",
+			requestId: "request-1",
+			workItemId: "wi-1",
+			value: "answer",
+		} satisfies RequiredInputResponseProposed<string>);
+		const requiredInput = projectWorkspaceProposalRequiredInputResponseApplication(
+			requiredInputRecord,
+			admittedDecision(requiredInputRecord),
+			{
+				applicationId: "application-runtime-gate",
+				gate: {
+					...requiredInputGate(),
+					metadata: { callback: "handleSubmit" },
+				},
+			},
+		);
+		expect(requiredInput.status.state).toBe("blocked");
+		expect(requiredInput.applied).toBeUndefined();
+		expect(requiredInput.status.issues.map((entry) => entry.code)).toContain(
+			"forbidden-runtime-material",
+		);
+
+		const domainRecord = proposalRecord("work-item-domain-action", {
+			kind: "work-item-domain-action-proposal-intake",
+			proposalId: "proposal-1",
+			workItemId: "wi-1",
+			actionKind: "patch",
+			payload: { patch: { summary: "Updated" } },
+		});
+		const domain = projectWorkspaceProposalDomainActionApplicationStatus(
+			domainRecord,
+			admittedDecision(domainRecord),
+			{
+				applicationId: "application-runtime-domain",
+				emittedFacts: [
+					{
+						kind: "work-item-patched",
+						eventId: "patch-event-runtime",
+						workItemId: "wi-1",
+						patch: { summary: "Updated" },
+						metadata: { providerClient: "runtime-private" },
+					},
+				],
+			},
+		);
+		expect(domain.status.state).toBe("blocked");
+		expect(domain.status.emittedFactRefs).toEqual([]);
+		expect(domain.status.issues.map((entry) => entry.code)).toContain("forbidden-runtime-material");
+	});
+
+	it("records D437 family-owned outcome refs without exposing a generic recorder", () => {
+		const requiredRecord = proposalRecord("required-input-response", {
+			kind: "required-input-response-proposed",
+			proposalId: "proposal-1",
+			requestId: "request-1",
+			workItemId: "wi-1",
+			value: "answer",
+		} satisfies RequiredInputResponseProposed<string>);
+		const required = projectWorkspaceProposalRequiredInputResponseApplication(
+			requiredRecord,
+			admittedDecision(requiredRecord),
+			{ applicationId: "application-required-outcome", gate: requiredInputGate() },
+		);
+		const requiredOutcome = recordWorkspaceProposalRequiredInputResponseOutcome(required.status, {
+			outcomeId: "required-outcome-1",
+			requiredInputRequestId: "request-1",
+			responseRef: { kind: "required-input-response-applied", id: "application-required-outcome" },
+		});
+		expect(requiredOutcome.status.state).toBe("recorded");
+		expect(requiredOutcome.outcome).toMatchObject({
+			kind: "workspace-proposal-required-input-response-outcome-recorded",
+			requiredInputRequestId: "request-1",
+		});
+
+		const spawnRecord = proposalRecord("work-item-spawn", {
+			kind: "work-item-spawn-proposed",
+			proposalId: "proposal-1",
+			proposedWorkItemId: "child-1",
+			draft: workItemDraft("Child"),
+		} satisfies WorkItemSpawnProposed);
+		const spawn = projectWorkspaceProposalWorkItemSpawnApplication(
+			spawnRecord,
+			admittedDecision(spawnRecord),
+			{ applicationId: "application-spawn-outcome" },
+		);
+		const spawnOutcome = recordWorkspaceProposalWorkItemSpawnOutcome(spawn.status, {
+			outcomeId: "spawn-outcome-1",
+			workItemRef: { kind: "work-item", id: "child-1" },
+		});
+		expect(spawnOutcome.status.state).toBe("recorded");
+		expect(spawnOutcome.outcome).toMatchObject({
+			kind: "workspace-proposal-work-item-spawn-outcome-recorded",
+			workItemRef: { kind: "work-item", id: "child-1" },
+		});
+
+		const linkRecord = proposalRecord("work-item-link", linkDraft());
+		const link = projectWorkspaceProposalWorkItemLinkApplication(
+			linkRecord,
+			admittedDecision(linkRecord),
+			{
+				applicationId: "application-link-outcome",
+				workItems: [workItem("wi-1"), workItem("wi-2")],
+			},
+		);
+		const linkOutcome = recordWorkspaceProposalWorkItemLinkOutcome(link.status, {
+			outcomeId: "link-outcome-1",
+			linkRef: { kind: "work-item-link", id: "link-1" },
+		});
+		expect(linkOutcome.status.state).toBe("recorded");
+		expect(linkOutcome.outcome).toMatchObject({
+			kind: "workspace-proposal-work-item-link-outcome-recorded",
+			linkRef: { kind: "work-item-link", id: "link-1" },
+		});
+
+		const domainRecord = proposalRecord("work-item-domain-action", {
+			kind: "work-item-domain-action-proposal-intake",
+			proposalId: "proposal-1",
+			workItemId: "wi-1",
+			actionKind: "patch",
+			payload: { patch: { summary: "Updated" } },
+		});
+		const domainDecision = admittedDecision(domainRecord);
+		const domain = projectWorkspaceProposalDomainActionApplicationStatus(
+			domainRecord,
+			domainDecision,
+			{
+				applicationId: "application-domain-outcome",
+				emittedFacts: [
+					{
+						kind: "work-item-patched",
+						eventId: "patch-event-outcome",
+						workItemId: "wi-1",
+						patch: { summary: "Updated" },
+						sourceRefs: d430ApplicationRefs(
+							domainRecord,
+							domainDecision,
+							"application-domain-outcome",
+						),
+						metadata: { applicationIdempotencyKey: domainRecord.idempotencyKey },
+					},
+				],
+			},
+		);
+		const domainOutcome = recordWorkspaceProposalDomainActionOutcome(domain.status, {
+			outcomeId: "domain-outcome-1",
+			actionRef: { kind: "work-item-domain-action", id: "patch-event-outcome" },
+		});
+		expect(domainOutcome.status.state).toBe("recorded");
+		expect(domainOutcome.outcome).toMatchObject({
+			kind: "workspace-proposal-domain-action-outcome-recorded",
+			actionRef: { kind: "work-item-domain-action", id: "patch-event-outcome" },
+		});
+	});
+
+	it("keeps D437 outcome recording data-only and horizon-driven", () => {
+		const record = proposalRecord("work-item-link", linkDraft());
+		const status = projectWorkspaceProposalWorkItemLinkApplication(
+			record,
+			admittedDecision(record),
+			{
+				applicationId: "application-link-outcome-guard",
+				workItems: [workItem("wi-1"), workItem("wi-2")],
+			},
+		).status;
+
+		const runtimeMaterial = recordWorkspaceProposalWorkItemLinkOutcome(status, {
+			outcomeId: "link-runtime-outcome",
+			linkRef: { kind: "work-item-link", id: "link-1" },
+			metadata: { callback: "recordOutcome" },
+		});
+		expect(runtimeMaterial.status.state).toBe("not-recorded");
+		expect(runtimeMaterial.outcome).toBeUndefined();
+		expect(runtimeMaterial.issues.map((entry) => entry.code)).toContain(
+			"forbidden-runtime-material",
+		);
+
+		const openHorizon = recordWorkspaceProposalWorkItemLinkOutcome(status, {
+			outcomeId: "link-open-horizon",
+			horizon: {
+				kind: "workspace-proposal-family-evidence-horizon",
+				horizonId: "horizon-open",
+				applicationId: status.applicationId,
+				state: "open",
+			},
+		});
+		expect(openHorizon.status.state).toBe("pending");
+		expect(openHorizon.outcome).toBeUndefined();
+
+		const closedHorizon = recordWorkspaceProposalWorkItemLinkOutcome(status, {
+			outcomeId: "link-closed-horizon",
+			horizon: {
+				kind: "workspace-proposal-family-evidence-horizon",
+				horizonId: "horizon-closed",
+				applicationId: status.applicationId,
+				state: "closed",
+			},
+		});
+		expect(closedHorizon.status.state).toBe("repair-needed");
+		expect(closedHorizon.outcome).toBeUndefined();
+
+		const domainRecord = proposalRecord("work-item-domain-action", {
+			kind: "work-item-domain-action-proposal-intake",
+			proposalId: "proposal-1",
+			workItemId: "wi-1",
+			actionKind: "patch",
+			payload: { patch: { summary: "Updated" } },
+		});
+		const decision = admittedDecision(domainRecord);
+		const domain = projectWorkspaceProposalDomainActionApplicationStatus(domainRecord, decision, {
+			applicationId: "application-domain-partial-outcome",
+			emittedFacts: [
+				{
+					kind: "work-item-patched",
+					eventId: "patch-event-partial",
+					workItemId: "wi-1",
+					patch: { summary: "Updated" },
+					sourceRefs: d430ApplicationRefs(
+						domainRecord,
+						decision,
+						"application-domain-partial-outcome",
+					),
+					metadata: { applicationIdempotencyKey: domainRecord.idempotencyKey },
+				},
+			],
+		});
+		const partial = recordWorkspaceProposalDomainActionOutcome(domain.status, {
+			outcomeId: "domain-partial-outcome",
+			policy: {
+				kind: "workspace-proposal-family-completion-policy",
+				policyId: "domain-multi-step",
+				proposalFamily: "work-item-domain-action",
+				domainActionCompletion: "multi-step-partial",
+			},
+		});
+		expect(partial.status.state).toBe("partial");
+		expect(partial.issues).toEqual([]);
+
+		const malformedRef = recordWorkspaceProposalDomainActionOutcome(domain.status, {
+			outcomeId: "domain-malformed-ref-outcome",
+			actionRef: { kind: "work-item-domain-action" } as Parameters<
+				typeof recordWorkspaceProposalDomainActionOutcome
+			>[1]["actionRef"],
+			policy: {
+				kind: "workspace-proposal-family-completion-policy",
+				policyId: "domain-multi-step",
+				proposalFamily: "work-item-domain-action",
+				domainActionCompletion: "multi-step-partial",
+			},
+		});
+		expect(malformedRef.status.state).toBe("pending");
+		expect(malformedRef.outcome).toBeUndefined();
+		expect(malformedRef.issues.map((entry) => entry.code)).toEqual(["missing-required-field"]);
+	});
+
+	it("projects D437 family outcome thin-ref index exact replay and conflicts", () => {
+		const record = proposalRecord("work-item-link", linkDraft());
+		const status = projectWorkspaceProposalWorkItemLinkApplication(
+			record,
+			admittedDecision(record),
+			{
+				applicationId: "application-link-index",
+				workItems: [workItem("wi-1"), workItem("wi-2")],
+			},
+		).status;
+		const first = recordWorkspaceProposalWorkItemLinkOutcome(status, {
+			outcomeId: "link-index-outcome",
+			linkRef: { kind: "work-item-link", id: "link-1" },
+		}).outcome;
+		expect(first).toBeDefined();
+		if (first === undefined) throw new Error("expected first D437 outcome");
+		const replay = projectWorkspaceProposalFamilyOutcomeIndex([first, first]);
+		expect(replay).toEqual([
+			expect.objectContaining({
+				state: "recorded",
+				outcomeRefs: [
+					expect.objectContaining({
+						kind: "workspace-proposal-family-outcome-ref",
+						outcomeId: "link-index-outcome",
+					}),
+				],
+				issues: [],
+			}),
+		]);
+
+		const second = recordWorkspaceProposalWorkItemLinkOutcome(status, {
+			outcomeId: "link-index-outcome",
+			linkRef: { kind: "work-item-link", id: "link-2" },
+		}).outcome;
+		expect(second).toBeDefined();
+		if (second === undefined) throw new Error("expected second D437 outcome");
+		const conflict = projectWorkspaceProposalFamilyOutcomeIndex([first, second]);
+		expect(conflict).toEqual([
+			expect.objectContaining({
+				state: "idempotency-conflict",
+				outcomeRefs: [],
+			}),
+		]);
+		expect(conflict[0]?.issues.map((entry) => entry.code)).toEqual(["idempotency-conflict"]);
+
+		const provenanceConflict = recordWorkspaceProposalWorkItemLinkOutcome(status, {
+			outcomeId: "link-index-outcome",
+			linkRef: { kind: "work-item-link", id: "link-1" },
+			sourceRefs: [{ kind: "manual-review", id: "changed-provenance" }],
+		}).outcome;
+		expect(provenanceConflict).toBeDefined();
+		if (provenanceConflict === undefined) throw new Error("expected provenance D437 outcome");
+		expect(projectWorkspaceProposalFamilyOutcomeIndex([first, provenanceConflict])).toEqual([
+			expect.objectContaining({
+				state: "idempotency-conflict",
+				outcomeRefs: [],
+			}),
+		]);
+	});
+
+	it("projects diagnostic view and repair review from existing durable material only", () => {
+		const record = proposalRecord("work-item-link", linkDraft());
+		const application = projectWorkspaceProposalWorkItemLinkApplication(
+			record,
+			admittedDecision(record),
+			{
+				applicationId: "application-link-diagnostics",
+				workItems: [workItem("wi-1"), workItem("wi-2")],
+			},
+		);
+		const outcomeStatus = recordWorkspaceProposalWorkItemLinkOutcome(application.status, {
+			outcomeId: "link-diagnostic-outcome",
+			horizon: {
+				kind: "workspace-proposal-family-evidence-horizon",
+				horizonId: "horizon-closed-diagnostic",
+				applicationId: application.status.applicationId,
+				state: "closed",
+			},
+		}).status;
+		const duplicateDiagnostics = projectWorkspaceProposalFamilyApplicationDiagnostics({
+			applicationStatuses: [application.status, application.status],
+			outcomeStatuses: [outcomeStatus, outcomeStatus],
+		});
+
+		expect(duplicateDiagnostics.map((entry) => entry.classification)).toEqual([
+			"missing-family-material",
+		]);
+		expect(duplicateDiagnostics[0]).toMatchObject({
+			kind: "workspace-proposal-family-application-diagnostic",
+			applicationId: "application-link-diagnostics",
+			proposalId: record.proposalId,
+			decisionId: "decision-1",
+			proposalFamily: "work-item-link",
+			code: "missing-required-field",
+		});
+
+		expect(
+			projectWorkspaceProposalRepairReviewRequests({
+				outcomeStatuses: [outcomeStatus],
+			}),
+		).toEqual([]);
+		expect(
+			projectWorkspaceProposalRepairReviewRequests({
+				applicationStatuses: [application.status],
+				outcomeStatuses: [{ ...outcomeStatus, proposalId: "other-proposal" }],
+			}),
+		).toEqual([]);
+		expect(
+			projectWorkspaceProposalRepairReviewRequests({
+				applicationStatuses: [application.status],
+				outcomeStatuses: [outcomeStatus, outcomeStatus],
+			}),
+		).toEqual([
+			expect.objectContaining({
+				applicationId: "application-link-diagnostics",
+				code: "missing-required-field",
+				proposalFamily: "work-item-link",
+			}),
+		]);
+	});
+
+	it("dedupes graph-visible diagnostic and repair review projection on replay", () => {
+		const g = graph();
+		const statuses = g.node<WorkspaceProposalApplicationStatus>([], null, { name: "statuses" });
+		const diagnostics = workspaceProposalFamilyApplicationDiagnosticProjector(g, {
+			applicationStatuses: statuses,
+		});
+		const repair = workspaceProposalRepairReviewProjector(g, {
+			applicationStatuses: statuses,
+		});
+		const diagnosticView = collectData(diagnostics.diagnostics);
+		const repairRequests = collectData(repair.requests);
+		const record = proposalRecord("work-item-domain-action", {
+			kind: "work-item-domain-action-proposal-intake",
+			proposalId: "proposal-1",
+			workItemId: "wi-1",
+			actionKind: "patch",
+			payload: { patch: { summary: "Updated" } },
+		});
+		const pending = projectWorkspaceProposalDomainActionApplicationStatus(
+			record,
+			admittedDecision(record),
+			{
+				applicationId: "application-domain-replay-repair",
+				emittedFacts: [],
+			},
+		).status;
+		const repairNeeded = {
+			...pending,
+			state: "repair-needed",
+			code: "missing-domain-action-facts",
+			issues: [
+				{
+					kind: "issue",
+					source: "workspace-proposal",
+					severity: "error",
+					code: "missing-domain-action-facts",
+					message: "Workspace proposal family application material is missing",
+					subjectId: pending.proposalId,
+					refs: pending.sourceRefs.map((sourceRef) => `${sourceRef.kind}:${sourceRef.id}`),
+				},
+			],
+		} satisfies typeof pending;
+
+		statuses.down([["DATA", repairNeeded]]);
+		statuses.down([["DATA", repairNeeded]]);
+
+		expect(diagnosticView).toHaveLength(1);
+		expect(diagnosticView[0]).toMatchObject({
+			classification: "missing-family-material",
+			code: "missing-domain-action-facts",
+		});
+		expect(repairRequests).toHaveLength(1);
+		expect(repairRequests[0]?.repairRequestId).toContain("workspace-proposal-repair-review:");
+
+		const repairIssue = repairNeeded.issues[0];
+		if (repairIssue === undefined) throw new Error("expected repair issue");
+		const updatedRepairNeeded = {
+			...repairNeeded,
+			issues: [
+				{
+					...repairIssue,
+					message: "Workspace proposal family application material is still missing",
+				},
+			],
+			sourceRefs: [
+				...repairNeeded.sourceRefs,
+				{ kind: "manual-review", id: "repair-context-updated" },
+			],
+		} satisfies typeof repairNeeded;
+
+		statuses.down([["DATA", updatedRepairNeeded]]);
+
+		expect(diagnosticView).toHaveLength(2);
+		expect(diagnosticView.at(-1)?.issues[0]?.message).toBe(
+			"Workspace proposal family application material is still missing",
+		);
+		expect(repairRequests).toHaveLength(2);
+		expect(repairRequests.at(-1)?.repairRequestId).toBe(repairRequests[0]?.repairRequestId);
+
+		const oldDelimitedCollisionA = {
+			...repairNeeded,
+			applicationId: "a:b",
+			proposalId: "proposal-a",
+			decisionId: "decision-a",
+			idempotencyKey: "c",
+		} satisfies typeof repairNeeded;
+		const oldDelimitedCollisionB = {
+			...repairNeeded,
+			applicationId: "a",
+			proposalId: "proposal-b",
+			decisionId: "decision-b",
+			idempotencyKey: "b:c",
+		} satisfies typeof repairNeeded;
+		const collisionIds = projectWorkspaceProposalRepairReviewRequests({
+			applicationStatuses: [oldDelimitedCollisionA, oldDelimitedCollisionB],
+		}).map((entry) => entry.repairRequestId);
+		expect(collisionIds).toHaveLength(2);
+		expect(new Set(collisionIds).size).toBe(2);
+	});
+
+	it("classifies malformed repair-needed material before missing-family fallback", () => {
+		const record = proposalRecord("work-item-link", linkDraft());
+		const pending = projectWorkspaceProposalWorkItemLinkApplication(
+			record,
+			admittedDecision(record),
+			{
+				applicationId: "application-malformed-repair",
+				workItems: [workItem("wi-1"), workItem("wi-2")],
+			},
+		).status;
+		const malformedRepair = {
+			...pending,
+			state: "repair-needed",
+			code: "malformed-family-draft",
+			issues: [
+				{
+					kind: "issue",
+					source: "workspace-proposal",
+					severity: "error",
+					code: "malformed-family-draft",
+					message: "WorkItem link draft is malformed",
+					subjectId: pending.proposalId,
+					refs: pending.sourceRefs.map((sourceRef) => `${sourceRef.kind}:${sourceRef.id}`),
+				},
+			],
+		} satisfies typeof pending;
+
+		expect(
+			projectWorkspaceProposalFamilyApplicationDiagnostics({
+				applicationStatuses: [malformedRepair],
+			}),
+		).toEqual([
+			expect.objectContaining({
+				classification: "malformed-family-material",
+				code: "malformed-family-draft",
+			}),
+		]);
+		expect(
+			projectWorkspaceProposalRepairReviewRequests({
+				applicationStatuses: [malformedRepair],
+			}),
+		).toEqual([]);
+	});
+
+	it("keeps D438 missing durable diagnostics out of repair review lowering", () => {
+		const missingIssue = {
+			kind: "issue",
+			source: "workspace-proposal",
+			severity: "error",
+			code: "missing-workspace-proposal-recorded",
+			message: "Workspace family application context references a missing durable proposal record",
+			subjectId: "proposal-missing",
+			refs: [
+				"workspace-proposal-application-context:application-missing",
+				"workspace-proposal-recorded:proposal-missing",
+			],
+			metadata: {
+				applicationId: "application-missing",
+				proposalId: "proposal-missing",
+			},
+		} satisfies WorkspaceProposalRecordedIssue;
+		const diagnostics = projectWorkspaceProposalFamilyApplicationDiagnostics({
+			issues: [missingIssue, missingIssue],
+		});
+
+		expect(diagnostics).toEqual([
+			expect.objectContaining({
+				classification: "missing-durable-handoff",
+				code: "missing-workspace-proposal-recorded",
+				applicationId: "application-missing",
+				proposalId: "proposal-missing",
+			}),
+		]);
+		expect(projectWorkspaceProposalRepairReviewRequests({})).toEqual([]);
+	});
+
+	it("projects D444 repair-review requests as open until explicit lifecycle material arrives", () => {
+		const { request, repairNeededStatus } = repairReviewFixture();
+
+		expect(projectWorkspaceProposalRepairReviewStatuses({ requests: [request] })).toEqual([
+			expect.objectContaining({
+				kind: "workspace-proposal-repair-review-status",
+				repairRequestId: request.repairRequestId,
+				applicationId: request.applicationId,
+				state: "open",
+				proofRefs: [],
+				issues: [],
+			}),
+		]);
+
+		const absenceDoesNotResolve = projectWorkspaceProposalRepairReviewStatuses({
+			requests: [request],
+			applicationStatuses: [
+				{
+					...repairNeededStatus,
+					state: "applied",
+					code: undefined,
+					issues: [],
+					emittedFactRefs: [],
+				},
+			],
+		});
+		expect(absenceDoesNotResolve[0]?.state).toBe("open");
+	});
+
+	it("projects D444 acknowledged and terminal human decisions without remutation outputs", () => {
+		const { request, appliedStatus } = repairReviewFixture();
+		const acknowledged = repairReviewDecision(request, "acknowledged", "review-ack");
+		const withdrawn = repairReviewDecision(request, "withdrawn", "review-withdrawn");
+		const resolved = repairReviewDecision(request, "resolved", "review-resolved");
+		const superseded = repairReviewDecision(request, "superseded", "review-superseded");
+
+		expect(
+			projectWorkspaceProposalRepairReviewStatuses({
+				requests: [request],
+				decisions: [acknowledged],
+			})[0],
+		).toMatchObject({
+			state: "acknowledged",
+			proofKind: "human-decision",
+			decisions: [acknowledged],
+		});
+
+		for (const decision of [withdrawn, resolved, superseded]) {
+			expect(
+				projectWorkspaceProposalRepairReviewStatuses({
+					requests: [request],
+					decisions: [acknowledged, decision],
+					applicationStatuses: [appliedStatus],
+				})[0],
+			).toMatchObject({
+				state: decision.intent,
+				proofKind: "human-decision",
+				proofRefs: [
+					{
+						kind: "workspace-proposal-repair-review-decision",
+						id: decision.reviewDecisionId,
+					},
+				],
+			});
+		}
+	});
+
+	it("records D450 repair-review decisions from request coordinates only", () => {
+		const { request } = repairReviewFixture();
+		const requestBefore = structuredClone(request);
+		const options = {
+			reviewDecisionId: "review-decision:d450-ack",
+			intent: "acknowledged",
+			reviewerRef: { kind: "actor", id: "reviewer:d450" },
+			actorRef: { kind: "actor", id: "actor:d450" },
+			capabilityRefs: [{ kind: "capability", id: "repair-review:write" }],
+			policyRefs: [{ kind: "policy", id: "repair-review:policy" }],
+			sourceRefs: [{ kind: "manual-review", id: "source:d450" }],
+			audit: {
+				auditId: "audit:d450",
+				actorId: "actor:d450",
+				sourceRefs: [{ kind: "manual-review", id: "audit-source:d450" }],
+			},
+			reason: "human acknowledged the review request",
+			code: "acknowledged-by-reviewer",
+			decidedAtMs: 450,
+			metadata: { queue: "repair-review" },
+		} as const;
+		const optionsBefore = structuredClone(options);
+		const result = recordWorkspaceProposalRepairReviewDecision(request, options);
+
+		expect(result).toMatchObject({
+			kind: "workspace-proposal-repair-review-decision-recording-result",
+			status: "recorded",
+			issues: [],
+			decision: {
+				kind: "workspace-proposal-repair-review-decision",
+				reviewDecisionId: "review-decision:d450-ack",
+				repairRequestId: request.repairRequestId,
+				applicationId: request.applicationId,
+				proposalId: request.proposalId,
+				decisionId: request.decisionId,
+				idempotencyKey: request.idempotencyKey,
+				proposalFamily: request.proposalFamily,
+				intent: "acknowledged",
+				reviewerRef: { kind: "actor", id: "reviewer:d450" },
+				actorRef: { kind: "actor", id: "actor:d450" },
+			},
+		});
+		expect(structuredClone(result)).toEqual(result);
+		expect(request).toEqual(requestBefore);
+		expect(options).toEqual(optionsBefore);
+		(options.sourceRefs[0] as { id: string }).id = "source:d450-mutated";
+		expect(result.sourceRefs).toContainEqual({ kind: "manual-review", id: "source:d450" });
+		expect(result.decision?.sourceRefs).toContainEqual({
+			kind: "manual-review",
+			id: "source:d450",
+		});
+		expect(JSON.stringify(result)).not.toContain("WorkItemCreated");
+		expect(JSON.stringify(result)).not.toContain("RequiredInputSatisfied");
+		expect(JSON.stringify(result)).not.toContain("WorkItemLinked");
+		expect(JSON.stringify(result)).not.toContain("domain-mutation");
+		expect(JSON.stringify(result)).not.toContain("runtime-private");
+
+		for (const intent of ["resolved", "withdrawn", "superseded"] as const) {
+			const recorded = recordWorkspaceProposalRepairReviewDecision(request, {
+				reviewDecisionId: `review-decision:d450-${intent}`,
+				intent,
+				reviewerRef: { kind: "actor", id: "reviewer:d450" },
+				capabilityRefs: [{ kind: "capability", id: `repair-review:${intent}` }],
+				policyRefs: [{ kind: "policy", id: "repair-review:policy" }],
+				sourceRefs: [{ kind: "manual-review", id: `source:d450-${intent}` }],
+				audit: {
+					auditId: `audit:d450-${intent}`,
+					actorId: "actor:d450",
+					sourceRefs: [{ kind: "manual-review", id: `audit-source:d450-${intent}` }],
+				},
+				code: `review-${intent}`,
+				resolvesRefs:
+					intent === "resolved"
+						? [{ kind: "workspace-proposal-family-outcome-index-entry", id: "outcome-index:1" }]
+						: undefined,
+				supersedesRefs:
+					intent === "superseded"
+						? [{ kind: "workspace-proposal-repair-review-decision", id: "prior-review" }]
+						: undefined,
+			});
+			expect(recorded.status).toBe("recorded");
+			expect(recorded.decision).toMatchObject({
+				applicationId: request.applicationId,
+				proposalId: request.proposalId,
+				decisionId: request.decisionId,
+				idempotencyKey: request.idempotencyKey,
+				proposalFamily: request.proposalFamily,
+				intent,
+			});
+		}
+	});
+
+	it("fails D450 repair-review decision intake closed for overrides, stale guards, and forbidden material", () => {
+		const { request } = repairReviewFixture();
+		const openStatus = projectWorkspaceProposalRepairReviewStatuses({ requests: [request] })[0]!;
+		const acknowledged = recordWorkspaceProposalRepairReviewDecision(request, {
+			reviewDecisionId: "review-decision:d450-status",
+			intent: "acknowledged",
+			reviewerRef: { kind: "actor", id: "reviewer:d450" },
+			capabilityRefs: [{ kind: "capability", id: "repair-review:write" }],
+			policyRefs: [{ kind: "policy", id: "repair-review:policy" }],
+			sourceRefs: [{ kind: "manual-review", id: "source:d450-status" }],
+			audit: {
+				auditId: "audit:d450-status",
+				actorId: "actor:d450",
+				sourceRefs: [{ kind: "manual-review", id: "audit-source:d450-status" }],
+			},
+			code: "acknowledged-by-reviewer",
+			currentStatus: openStatus,
+			expectedCurrentState: { state: "open", code: "open" },
+		});
+		expect(acknowledged.status).toBe("recorded");
+
+		const status = projectWorkspaceProposalRepairReviewStatuses({
+			requests: [request],
+			decisions: [acknowledged.decision!],
+		})[0]!;
+		expect(status).toMatchObject({
+			state: "acknowledged",
+			proofKind: "human-decision",
+			decisions: [acknowledged.decision],
+		});
+
+		const invalid = [
+			recordWorkspaceProposalRepairReviewDecision(request, {
+				intent: "acknowledged",
+				reviewerRef: { kind: "actor", id: "reviewer:d450" },
+			}),
+			recordWorkspaceProposalRepairReviewDecision(request, {
+				reviewDecisionId: "review-decision:d450-bad-intent",
+				intent: "retry-now" as never,
+				reviewerRef: { kind: "actor", id: "reviewer:d450" },
+			}),
+			recordWorkspaceProposalRepairReviewDecision(request, {
+				reviewDecisionId: "review-decision:d450-override",
+				intent: "acknowledged",
+				applicationId: "application:override",
+				reviewerRef: { kind: "actor", id: "reviewer:d450" },
+			} as never),
+			recordWorkspaceProposalRepairReviewDecision(request, {
+				reviewDecisionId: "review-decision:d450-stale",
+				intent: "resolved",
+				reviewerRef: { kind: "actor", id: "reviewer:d450" },
+				capabilityRefs: [{ kind: "capability", id: "repair-review:write" }],
+				policyRefs: [{ kind: "policy", id: "repair-review:policy" }],
+				sourceRefs: [{ kind: "manual-review", id: "source:d450-stale" }],
+				audit: {
+					auditId: "audit:d450-stale",
+					actorId: "actor:d450",
+					sourceRefs: [{ kind: "manual-review", id: "audit-source:d450-stale" }],
+				},
+				code: "resolved-by-reviewer",
+				currentStatus: status,
+				expectedCurrentState: { state: "open" },
+			}),
+			recordWorkspaceProposalRepairReviewDecision(request, {
+				reviewDecisionId: "review-decision:d450-unverifiable",
+				intent: "resolved",
+				reviewerRef: { kind: "actor", id: "reviewer:d450" },
+				capabilityRefs: [{ kind: "capability", id: "repair-review:write" }],
+				policyRefs: [{ kind: "policy", id: "repair-review:policy" }],
+				sourceRefs: [{ kind: "manual-review", id: "source:d450-unverifiable" }],
+				audit: {
+					auditId: "audit:d450-unverifiable",
+					actorId: "actor:d450",
+					sourceRefs: [{ kind: "manual-review", id: "audit-source:d450-unverifiable" }],
+				},
+				code: "resolved-by-reviewer",
+				expectedCurrentState: { state: "open" },
+			}),
+			recordWorkspaceProposalRepairReviewDecision(request, {
+				reviewDecisionId: "review-decision:d450-unaudited",
+				intent: "acknowledged",
+			}),
+			recordWorkspaceProposalRepairReviewDecision(request, {
+				reviewDecisionId: "review-decision:d450-forbidden",
+				intent: "acknowledged",
+				reviewerRef: { kind: "actor", id: "credential:leak" },
+				capabilityRefs: [{ kind: "capability", id: "repair-review:write" }],
+				policyRefs: [{ kind: "policy", id: "repair-review:policy" }],
+				sourceRefs: [{ kind: "manual-review", id: "source:d450-forbidden" }],
+				audit: {
+					auditId: "audit:d450-forbidden",
+					actorId: "actor:d450",
+					sourceRefs: [{ kind: "manual-review", id: "audit-source:d450-forbidden" }],
+				},
+				code: "acknowledged-by-reviewer",
+			}),
+			recordWorkspaceProposalRepairReviewDecision(request, {
+				reviewDecisionId: "review-decision:d450-callback",
+				intent: "acknowledged",
+				reviewerRef: { kind: "actor", id: "reviewer:d450" },
+				capabilityRefs: [{ kind: "capability", id: "repair-review:write" }],
+				policyRefs: [{ kind: "policy", id: "repair-review:policy" }],
+				sourceRefs: [{ kind: "manual-review", id: "source:d450-callback" }],
+				audit: {
+					auditId: "audit:d450-callback",
+					actorId: "actor:d450",
+					sourceRefs: [{ kind: "manual-review", id: "audit-source:d450-callback" }],
+				},
+				code: "acknowledged-by-reviewer",
+				metadata: { callback: () => undefined },
+			} as never),
+		];
+		expect(invalid.every((entry) => entry.status === "blocked")).toBe(true);
+		expect(invalid.every((entry) => entry.sourceRefs.length === 0)).toBe(true);
+		expect(JSON.stringify(invalid)).not.toContain("credential:leak");
+		expect(invalid.flatMap((entry) => entry.issues.map((issue) => issue.code))).toEqual(
+			expect.arrayContaining([
+				"missing-review-decision-id",
+				"unsupported-repair-review-intent",
+				"coordinate-override-forbidden",
+				"stale-repair-review-state",
+				"missing-review-authority-material",
+				"missing-review-audit-material",
+				"forbidden-runtime-material",
+				"non-data-material",
+			]),
+		);
+		expect(JSON.stringify(invalid)).not.toContain("WorkItemCreated");
+		expect(JSON.stringify(invalid)).not.toContain("RequiredInputSatisfied");
+		expect(JSON.stringify(invalid)).not.toContain("workspace-proposal-family-outcome-recorded");
+
+		const accessorOptions = {
+			reviewDecisionId: "review-decision:d450-accessor",
+			intent: "acknowledged",
+			reviewerRef: { kind: "actor", id: "reviewer:d450" },
+			capabilityRefs: [{ kind: "capability", id: "repair-review:write" }],
+			policyRefs: [{ kind: "policy", id: "repair-review:policy" }],
+			audit: {
+				auditId: "audit:d450-accessor",
+				actorId: "actor:d450",
+			},
+			code: "acknowledged-by-reviewer",
+		};
+		Object.defineProperty(accessorOptions, "sourceRefs", {
+			enumerable: true,
+			get() {
+				throw new Error("sourceRefs getter must not run");
+			},
+		});
+		expect(() =>
+			recordWorkspaceProposalRepairReviewDecision(request, accessorOptions as never),
+		).not.toThrow();
+		expect(
+			recordWorkspaceProposalRepairReviewDecision(request, accessorOptions as never),
+		).toMatchObject({
+			status: "blocked",
+			sourceRefs: [],
+			issues: expect.arrayContaining([expect.objectContaining({ code: "non-data-material" })]),
+		});
+	});
+
+	it("projects graph-visible D456 repair-review decision recordings without status authority", () => {
+		const { request } = repairReviewFixture();
+		const openStatus = projectWorkspaceProposalRepairReviewStatuses({ requests: [request] })[0];
+		if (openStatus === undefined) throw new Error("expected D456 open status");
+		const recordingInput = repairReviewRecordingInput(request, "review-decision:d456");
+		const duplicate = structuredClone(recordingInput);
+		const conflict = {
+			...recordingInput,
+			intent: "withdrawn",
+			code: "conflicting-withdrawn",
+		} satisfies WorkspaceProposalRepairReviewDecisionRecordingInput;
+		const unsafeAuditConflict = {
+			...recordingInput,
+			audit: {
+				auditId: "audit:unsafe-conflict",
+				metadata: { providerHandle: "secret-provider" },
+			},
+		} satisfies WorkspaceProposalRepairReviewDecisionRecordingInput;
+
+		expect(
+			projectWorkspaceProposalRepairReviewDecisionRecordings({
+				requests: [request],
+				recordingInputs: [recordingInput, duplicate],
+				statuses: [openStatus],
+			}),
+		).toEqual([
+			expect.objectContaining({
+				status: "recorded",
+				decision: expect.objectContaining({
+					reviewDecisionId: "review-decision:d456",
+					applicationId: request.applicationId,
+					intent: "acknowledged",
+				}),
+				issues: [],
+			}),
+		]);
+		expect(
+			projectWorkspaceProposalRepairReviewDecisionRecordings({
+				requests: [request],
+				recordingInputs: [recordingInput, conflict],
+				statuses: [openStatus],
+			})[0],
+		).toMatchObject({
+			status: "blocked",
+			issues: [
+				expect.objectContaining({
+					code: "conflicting-repair-review-decision-recording-input",
+				}),
+			],
+		});
+		const unsafeConflictResult = projectWorkspaceProposalRepairReviewDecisionRecordings({
+			requests: [request],
+			recordingInputs: [unsafeAuditConflict, conflict],
+			statuses: [openStatus],
+		})[0];
+		expect(unsafeConflictResult?.status).toBe("blocked");
+		expect(unsafeConflictResult?.audit).toBeUndefined();
+		expect(JSON.stringify(unsafeConflictResult)).not.toContain("secret-provider");
+
+		const g = graph();
+		const requests = g.node<WorkspaceProposalRepairReviewRequest>([], null, { name: "requests" });
+		const inputs = g.node<WorkspaceProposalRepairReviewDecisionRecordingInput>([], null, {
+			name: "recordingInputs",
+		});
+		const statuses = g.node<typeof openStatus>([], null, { name: "statuses" });
+		const bundle = workspaceProposalRepairReviewDecisionRecordingProjector(g, {
+			requests,
+			recordingInputs: inputs,
+			statuses,
+		});
+		const results = collectData(bundle.results);
+		const decisions = collectData(bundle.decisions);
+		const issues = collectData(bundle.issues);
+
+		requests.down([["DATA", request]]);
+		statuses.down([["DATA", openStatus]]);
+		inputs.down([["DATA", recordingInput]]);
+		inputs.down([["DATA", duplicate]]);
+		inputs.down([["DATA", conflict]]);
+
+		expect(results.map((entry) => entry.status)).toEqual(["recorded", "blocked"]);
+		expect(decisions).toHaveLength(1);
+		expect(decisions[0]).toMatchObject({
+			reviewDecisionId: "review-decision:d456",
+			repairRequestId: request.repairRequestId,
+		});
+		expect(issues.map((entry) => entry.code)).toEqual([
+			"conflicting-repair-review-decision-recording-input",
+		]);
+		expect(Object.keys(bundle).sort()).toEqual(["decisions", "issues", "results"]);
+		expect(JSON.stringify(results)).not.toContain("workspace-proposal-application-status");
+		expect(JSON.stringify(results)).not.toContain("WorkItemCreated");
+		expect(JSON.stringify(results)).not.toContain("RequiredInputSatisfied");
+		expect(JSON.stringify(results)).not.toContain("runtime");
+	});
+
+	it("validates D459 repair action intents and lowers review-only actions to D456 input", () => {
+		const fixture = repairReviewFixture();
+		const status = projectWorkspaceProposalRepairReviewStatuses({ requests: [fixture.request] })[0];
+		if (status === undefined) throw new Error("expected D459 status");
+		const descriptor = projectWorkspaceProposalRepairActionDescriptors({
+			requests: [fixture.request],
+			statuses: [status],
+		}).find((entry) => entry.actionKind === "mark-human-resolved");
+		if (descriptor === undefined) throw new Error("expected D459 descriptor");
+		const intent = repairActionIntent(fixture.request, descriptor, {
+			actionKind: "mark-human-resolved",
+			expectedCurrentState: { state: "open", code: "open" },
+		});
+
+		expect(
+			validateWorkspaceProposalRepairActionIntent(intent, {
+				descriptor,
+				request: fixture.request,
+				currentStatus: status,
+				capabilityRefs: intent.capabilityRefs,
+				policyRefs: intent.policyRefs,
+				policyStatus: "allowed",
+			}),
+		).toMatchObject({
+			status: "accepted",
+			issues: [],
+			intent,
+		});
+		const prepared = prepareWorkspaceProposalRepairReviewDecisionRecordingInput(intent, {
+			descriptor,
+			request: fixture.request,
+			currentStatus: status,
+			reviewDecisionId: "review-decision:d459",
+			code: "resolved-from-intent",
+			reason: "human resolved from repair action",
+			capabilityRefs: intent.capabilityRefs,
+			policyRefs: intent.policyRefs,
+			sourceRefs: intent.sourceRefs,
+			audit: intent.audit,
+		});
+		expect(prepared).toMatchObject({
+			status: "prepared",
+			recordingInput: {
+				kind: "workspace-proposal-repair-review-decision-recording-input",
+				repairRequestId: fixture.request.repairRequestId,
+				reviewDecisionId: "review-decision:d459",
+				intent: "resolved",
+			},
+			issues: [],
+		});
+		expect(Object.keys(prepared.recordingInput ?? {}).sort()).not.toEqual(
+			expect.arrayContaining(["applicationId", "proposalId", "decisionId", "idempotencyKey"]),
+		);
+
+		const mismatched = validateWorkspaceProposalRepairActionIntent(
+			{ ...intent, proposalId: "other-proposal" },
+			{
+				descriptor,
+				request: fixture.request,
+				currentStatus: status,
+				capabilityRefs: intent.capabilityRefs,
+				policyRefs: intent.policyRefs,
+				policyStatus: "allowed",
+			},
+		);
+		expect(mismatched).toMatchObject({
+			status: "blocked",
+			issues: expect.arrayContaining([
+				expect.objectContaining({ code: "repair-action-intent-coordinate-mismatch" }),
+				expect.objectContaining({ code: "repair-action-intent-descriptor-mismatch" }),
+			]),
+		});
+		const stale = validateWorkspaceProposalRepairActionIntent(
+			{ ...intent, expectedCurrentState: { state: "resolved" } },
+			{
+				descriptor,
+				request: fixture.request,
+				currentStatus: status,
+				capabilityRefs: intent.capabilityRefs,
+				policyRefs: intent.policyRefs,
+				policyStatus: "allowed",
+			},
+		);
+		expect(stale).toMatchObject({
+			status: "blocked",
+			issues: [expect.objectContaining({ code: "stale-repair-review-state" })],
+		});
+		expect(JSON.stringify(prepared)).not.toContain("workspace-proposal-application-recorded");
+		expect(JSON.stringify(prepared)).not.toContain("WorkItemCreated");
+	});
+
+	it("previews D460 successor proposal intake context without proposal truth or ids", () => {
+		const fixture = repairReviewFixture();
+		const status = projectWorkspaceProposalRepairReviewStatuses({ requests: [fixture.request] })[0];
+		if (status === undefined) throw new Error("expected D460 status");
+		const descriptor = projectWorkspaceProposalRepairActionDescriptors({
+			requests: [fixture.request],
+			statuses: [status],
+		}).find((entry) => entry.actionKind === "open-successor-proposal-flow");
+		if (descriptor === undefined) throw new Error("expected D460 descriptor");
+		const unsupportedDescriptor = projectWorkspaceProposalRepairActionDescriptors({
+			requests: [fixture.request],
+			statuses: [status],
+		}).find((entry) => entry.actionKind === "mark-human-resolved");
+		if (unsupportedDescriptor === undefined) {
+			throw new Error("expected D460 unsupported descriptor");
+		}
+		const intent = repairActionIntent(fixture.request, descriptor, {
+			actionKind: "open-successor-proposal-flow",
+		});
+		const unsupportedIntent = repairActionIntent(fixture.request, unsupportedDescriptor, {
+			actionKind: "mark-human-resolved",
+		});
+		const preview = projectWorkspaceProposalRepairSuccessorProposalIntakePreview(intent, {
+			descriptor,
+			request: fixture.request,
+			currentStatus: status,
+			capabilityRefs: intent.capabilityRefs,
+			policyRefs: intent.policyRefs,
+			policyStatus: "allowed",
+			code: "open-successor",
+			reason: "prepare a follow-up proposal",
+			contextRefs: [{ kind: "workspace-proposal-family-outcome-index-entry", id: "index:1" }],
+			suggestedDraftPatch: { summary: "Follow-up proposal context" },
+			sourceRefs: [{ kind: "manual-review", id: "successor-source" }],
+		});
+
+		expect(preview).toMatchObject({
+			status: "proposal-context-ready",
+			repairRequestId: fixture.request.repairRequestId,
+			intentId: intent.intentId,
+			suggestedFamily: fixture.request.proposalFamily,
+			code: "open-successor",
+			diagnostics: [],
+			suggestedDraftPatch: { summary: "Follow-up proposal context" },
+		});
+		expect(
+			previewWorkspaceProposalRepairSuccessorProposalIntake(
+				fixture.request,
+				{
+					descriptor,
+					currentStatus: status,
+					capabilityRefs: intent.capabilityRefs,
+					policyRefs: intent.policyRefs,
+					policyStatus: "allowed",
+					code: "open-successor-wrapper",
+				},
+				intent,
+			),
+		).toMatchObject({
+			status: "proposal-context-ready",
+			diagnostics: [],
+			code: "open-successor-wrapper",
+		});
+		expect(preview.targetRefs).toEqual(
+			expect.arrayContaining([
+				{ kind: "workspace-proposal-repair-review-request", id: fixture.request.repairRequestId },
+			]),
+		);
+		const text = JSON.stringify(preview);
+		expect(text).not.toContain("successorProposalId");
+		expect(text).not.toContain("admissionId");
+		expect(text).not.toContain("WorkItemCreated");
+		expect(text).not.toContain("provider");
+		expect(text).not.toContain("runtime");
+
+		expect(
+			projectWorkspaceProposalRepairSuccessorProposalIntakePreview(unsupportedIntent, {
+				descriptor: unsupportedDescriptor,
+				request: fixture.request,
+				currentStatus: status,
+				capabilityRefs: unsupportedIntent.capabilityRefs,
+				policyRefs: unsupportedIntent.policyRefs,
+				policyStatus: "allowed",
+			}),
+		).toMatchObject({
+			status: "blocked",
+			diagnostics: expect.arrayContaining([
+				expect.objectContaining({ code: "unsupported-repair-action-intent" }),
+			]),
+		});
+	});
+
+	it("prepares D467 successor ready requests only from preview plus explicit final material", () => {
+		const fixture = repairReviewFixture();
+		const status = projectWorkspaceProposalRepairReviewStatuses({ requests: [fixture.request] })[0];
+		if (status === undefined) throw new Error("expected D467 status");
+		const descriptor = projectWorkspaceProposalRepairActionDescriptors({
+			requests: [fixture.request],
+			statuses: [status],
+		}).find((entry) => entry.actionKind === "open-successor-proposal-flow");
+		if (descriptor === undefined) throw new Error("expected D467 descriptor");
+		const intent = repairActionIntent(fixture.request, descriptor, {
+			actionKind: "open-successor-proposal-flow",
+		});
+		const intentValidation = validateWorkspaceProposalRepairActionIntent(intent, {
+			descriptor,
+			request: fixture.request,
+			currentStatus: status,
+			capabilityRefs: intent.capabilityRefs,
+			policyRefs: intent.policyRefs,
+			policyStatus: "allowed",
+		});
+		expect(intentValidation.status).toBe("accepted");
+		const preview = projectWorkspaceProposalRepairSuccessorProposalIntakePreview(intent, {
+			descriptor,
+			request: fixture.request,
+			currentStatus: status,
+			capabilityRefs: intent.capabilityRefs,
+			policyRefs: intent.policyRefs,
+			policyStatus: "allowed",
+			suggestedLoweringKind: "work-item-spawn",
+			suggestedDraftPatch: { title: "suggested only" },
+			sourceRefs: [{ kind: "manual-review", id: "d467-preview-source" }],
+		});
+		const input: WorkspaceProposalRepairSuccessorProposalReadyRequestPreparationInput<{
+			readonly title: string;
+		}> = {
+			kind: "workspace-proposal-repair-successor-proposal-ready-request-preparation-input",
+			preparationId: "successor-preparation:d467",
+			previewId: preview.previewId,
+			intent,
+			intentValidation,
+			descriptor,
+			request: fixture.request,
+			currentStatus: status,
+			successorProposalId: "successor-proposal:d467",
+			intakeRequestId: "successor-intake:d467",
+			successorIdempotencyKey: "successor-idempotency:d467",
+			workspaceId: "workspace:d467",
+			actorRef,
+			capabilityRefs: [capabilityRef],
+			policyRefs: [policyRef],
+			projectionBundleRefs: [projectionRef],
+			sourceRefs: [{ kind: "workspace-successor-materialization", id: "source:d467" }],
+			audit: {
+				auditId: "audit:d467",
+				actorId: "actor-1",
+				sourceRefs: [{ kind: "audit", id: "source:d467" }],
+			},
+			targetRefs: [
+				{ kind: "work-item", id: "successor-target:d467", workspaceId: "workspace:d467" },
+			],
+			successorProposalFamily: preview.suggestedFamily ?? fixture.request.proposalFamily,
+			successorLoweringKind: preview.suggestedLoweringKind ?? "work-item-spawn",
+			draft: { title: "explicit final draft" },
+			finalDraftSourceRefs: [{ kind: "workspace-final-draft", id: "draft:d467" }],
+			metadata: {
+				purpose: "successor-proposal-ready-request",
+				nested: { mutable: "before" },
+			},
+		};
+		const prepared = prepareWorkspaceProposalRepairSuccessorProposalReadyRequest(preview, input);
+		(input.metadata?.nested as { mutable: string }).mutable = "after";
+
+		expect(prepared).toMatchObject({
+			status: "prepared",
+			preparationId: "successor-preparation:d467",
+			readyRequest: {
+				kind: "workspace-proposal-ready-request",
+				proposalId: "successor-proposal:d467",
+				intakeRequestId: "successor-intake:d467",
+				idempotencyKey: "successor-idempotency:d467",
+				workspaceId: "workspace:d467",
+				proposalFamily: fixture.request.proposalFamily,
+				loweringKind: "work-item-spawn",
+				draft: { title: "explicit final draft" },
+				actorRef,
+				capabilityRefs: [capabilityRef],
+				policyRefs: [policyRef],
+				projectionBundleRefs: [projectionRef],
+			},
+			issues: [],
+		});
+		expect(prepared.readyRequest?.draft).not.toEqual(preview.suggestedDraftPatch);
+		expect(Object.isFrozen(prepared.readyRequest)).toBe(true);
+		expect(Object.isFrozen(prepared.readyRequest?.metadata)).toBe(true);
+		expect((prepared.readyRequest?.metadata?.nested as { mutable: string }).mutable).toBe("before");
+		const callerFinalDivergesFromPreview =
+			prepareWorkspaceProposalRepairSuccessorProposalReadyRequest(preview, {
+				...input,
+				preparationId: "successor-preparation:d467-divergent-final",
+				successorProposalId: "successor-proposal:d467-divergent-final",
+				intakeRequestId: "successor-intake:d467-divergent-final",
+				successorIdempotencyKey: "successor-idempotency:d467-divergent-final",
+				successorProposalFamily: "work-item-link",
+				successorLoweringKind: "work-item-link",
+			});
+		expect(callerFinalDivergesFromPreview).toMatchObject({
+			status: "prepared",
+			issues: [],
+			readyRequest: {
+				proposalId: "successor-proposal:d467-divergent-final",
+				proposalFamily: "work-item-link",
+				loweringKind: "work-item-link",
+			},
+		});
+		const blockedIntentValidation = validateWorkspaceProposalRepairActionIntent(intent, {
+			descriptor,
+			request: fixture.request,
+			currentStatus: status,
+			capabilityRefs: intent.capabilityRefs,
+			policyRefs: intent.policyRefs,
+			policyStatus: "blocked",
+		});
+		const blockedByValidation = prepareWorkspaceProposalRepairSuccessorProposalReadyRequest(
+			preview,
+			{
+				...input,
+				preparationId: "successor-preparation:d467-blocked-validation",
+				intentValidation: blockedIntentValidation,
+			},
+		);
+		expect(blockedByValidation).toMatchObject({
+			status: "blocked",
+			issues: expect.arrayContaining([
+				expect.objectContaining({ code: "blocked-repair-action-intent-validation" }),
+			]),
+		});
+		expect(blockedByValidation).not.toHaveProperty("readyRequest");
+		const omittedIntentValidation = prepareWorkspaceProposalRepairSuccessorProposalReadyRequest(
+			preview,
+			{
+				...input,
+				preparationId: "successor-preparation:d467-missing-validation",
+				intentValidation: undefined as never,
+			},
+		);
+		expect(omittedIntentValidation).toMatchObject({
+			status: "blocked",
+			issues: expect.arrayContaining([
+				expect.objectContaining({ code: "malformed-repair-successor-preparation-input" }),
+			]),
+		});
+		expect(omittedIntentValidation).not.toHaveProperty("readyRequest");
+		expect(Object.hasOwn(omittedIntentValidation, "readyRequest")).toBe(false);
+		const mismatchedIntentValidation = prepareWorkspaceProposalRepairSuccessorProposalReadyRequest(
+			preview,
+			{
+				...input,
+				preparationId: "successor-preparation:d467-validation-coordinate-mismatch",
+				intentValidation: {
+					...intentValidation,
+					proposalId: "other-proposal",
+				},
+			},
+		);
+		expect(mismatchedIntentValidation).toMatchObject({
+			status: "blocked",
+			issues: expect.arrayContaining([
+				expect.objectContaining({
+					code: "repair-successor-preparation-coordinate-mismatch",
+				}),
+			]),
+		});
+		expect(mismatchedIntentValidation).not.toHaveProperty("readyRequest");
+		const recorded = recordWorkspaceProposal(prepared.readyRequest);
+		expect(recorded.status.state).toBe("recorded");
+		expect(prepared).not.toHaveProperty("record");
+		const text = JSON.stringify(prepared);
+		expect(text).not.toContain("WorkspaceProposalRecorded");
+		expect(prepared).not.toHaveProperty("record");
+		expect(prepared).not.toHaveProperty("decision");
+		expect(prepared).not.toHaveProperty("applicationStatus");
+		expect(text).not.toContain("WorkItemCreated");
+		expect(text).not.toContain("provider");
+		expect(text).not.toContain("runtime");
+		const forbiddenRefPreparation = prepareWorkspaceProposalRepairSuccessorProposalReadyRequest(
+			preview,
+			{
+				...input,
+				preparationId: "successor-preparation:d467-forbidden-ref",
+				capabilityRefs: [{ kind: "provider", id: "runtime-private" }],
+			},
+		);
+		expect(forbiddenRefPreparation).toMatchObject({
+			status: "blocked",
+			issues: expect.arrayContaining([
+				expect.objectContaining({ code: "malformed-repair-successor-preparation-input" }),
+			]),
+		});
+		expect(forbiddenRefPreparation).not.toHaveProperty("readyRequest");
+		expect(JSON.stringify(forbiddenRefPreparation)).not.toContain("runtime-private");
+
+		const suggestedOnly = prepareWorkspaceProposalRepairSuccessorProposalReadyRequest(preview, {
+			...input,
+			draft: undefined,
+			finalDraftSourceRefs: undefined,
+		});
+		expect(suggestedOnly).toMatchObject({
+			status: "blocked",
+			issues: expect.arrayContaining([expect.objectContaining({ code: "missing-draft-material" })]),
+		});
+		expect(suggestedOnly).not.toHaveProperty("readyRequest");
+		expect(Object.hasOwn(suggestedOnly, "readyRequest")).toBe(false);
+		const draftRefWithoutFinalSourceRefs =
+			prepareWorkspaceProposalRepairSuccessorProposalReadyRequest(preview, {
+				...input,
+				preparationId: "successor-preparation:d467-draft-ref-without-source",
+				draft: undefined,
+				draftRefs: [{ kind: "workspace-final-draft", id: "draft-ref:d467-no-source" }],
+				finalDraftSourceRefs: undefined,
+			});
+		expect(draftRefWithoutFinalSourceRefs).toMatchObject({
+			status: "blocked",
+			issues: expect.arrayContaining([
+				expect.objectContaining({ code: "missing-final-draft-source" }),
+			]),
+		});
+		expect(draftRefWithoutFinalSourceRefs).not.toHaveProperty("readyRequest");
+		const mismatched = prepareWorkspaceProposalRepairSuccessorProposalReadyRequest(preview, {
+			...input,
+			intent: { ...intent, proposalId: "other-proposal" },
+		});
+		expect(mismatched).toMatchObject({
+			status: "blocked",
+			issues: expect.arrayContaining([
+				expect.objectContaining({ code: "repair-successor-preparation-coordinate-mismatch" }),
+			]),
+		});
+		const unsafe = prepareWorkspaceProposalRepairSuccessorProposalReadyRequest(preview, {
+			...input,
+			metadata: { providerHandle: "runtime-private" },
+		});
+		expect(unsafe).toMatchObject({
+			status: "blocked",
+			issues: expect.arrayContaining([
+				expect.objectContaining({ code: "forbidden-runtime-material" }),
+			]),
+		});
+		expect(JSON.stringify(unsafe)).not.toContain("runtime-private");
+		const reservedTruthMetadata = prepareWorkspaceProposalRepairSuccessorProposalReadyRequest(
+			preview,
+			{
+				...input,
+				metadata: { successorAdmissionId: "admission:d467", applicationStatus: "applied" },
+			},
+		);
+		expect(reservedTruthMetadata).toMatchObject({
+			status: "blocked",
+			issues: expect.arrayContaining([
+				expect.objectContaining({ code: "malformed-repair-successor-preparation-input" }),
+			]),
+		});
+		expect(reservedTruthMetadata).not.toHaveProperty("readyRequest");
+	});
+
+	it("projects graph-visible D467 preparation results without recording proposal truth", () => {
+		const fixture = repairReviewFixture();
+		const status = projectWorkspaceProposalRepairReviewStatuses({ requests: [fixture.request] })[0];
+		if (status === undefined) throw new Error("expected graph D467 status");
+		const descriptor = projectWorkspaceProposalRepairActionDescriptors({
+			requests: [fixture.request],
+			statuses: [status],
+		}).find((entry) => entry.actionKind === "open-successor-proposal-flow");
+		if (descriptor === undefined) throw new Error("expected graph D467 descriptor");
+		const intent = repairActionIntent(fixture.request, descriptor, {
+			actionKind: "open-successor-proposal-flow",
+		});
+		const intentValidation = validateWorkspaceProposalRepairActionIntent(intent, {
+			descriptor,
+			request: fixture.request,
+			currentStatus: status,
+			capabilityRefs: intent.capabilityRefs,
+			policyRefs: intent.policyRefs,
+			policyStatus: "allowed",
+		});
+		expect(intentValidation.status).toBe("accepted");
+		const preview = projectWorkspaceProposalRepairSuccessorProposalIntakePreview(intent, {
+			descriptor,
+			request: fixture.request,
+			currentStatus: status,
+			capabilityRefs: intent.capabilityRefs,
+			policyRefs: intent.policyRefs,
+			policyStatus: "allowed",
+			suggestedLoweringKind: "work-item-spawn",
+		});
+		const input: WorkspaceProposalRepairSuccessorProposalReadyRequestPreparationInput = {
+			kind: "workspace-proposal-repair-successor-proposal-ready-request-preparation-input",
+			preparationId: "successor-preparation:graph-d467",
+			previewId: preview.previewId,
+			intent,
+			intentValidation,
+			descriptor,
+			request: fixture.request,
+			currentStatus: status,
+			successorProposalId: "successor-proposal:graph-d467",
+			intakeRequestId: "successor-intake:graph-d467",
+			successorIdempotencyKey: "successor-idempotency:graph-d467",
+			workspaceId: "workspace:graph-d467",
+			actorRef,
+			capabilityRefs: [capabilityRef],
+			policyRefs: [policyRef],
+			projectionBundleRefs: [projectionRef],
+			sourceRefs: [sourceRef],
+			audit: { auditId: "audit:graph-d467", sourceRefs: [sourceRef] },
+			targetRefs: [{ kind: "work-item", id: "target:graph-d467" }],
+			successorProposalFamily: fixture.request.proposalFamily,
+			successorLoweringKind: "work-item-spawn",
+			draftRefs: [{ kind: "workspace-final-draft", id: "draft-ref:graph-d467" }],
+			finalDraftSourceRefs: [{ kind: "workspace-final-draft", id: "draft-source:graph-d467" }],
+		};
+		const g = graph();
+		const previews = g.node<WorkspaceProposalRepairSuccessorProposalIntakePreview>([], null, {
+			name: "previews",
+		});
+		const inputs = g.node<WorkspaceProposalRepairSuccessorProposalReadyRequestPreparationInput>(
+			[],
+			null,
+			{
+				name: "inputs",
+			},
+		);
+		const bundle = workspaceProposalRepairSuccessorProposalReadyRequestPreparationProjector(g, {
+			previews,
+			preparationInputs: inputs,
+		});
+		const results =
+			collectData<WorkspaceProposalRepairSuccessorProposalReadyRequestPreparationResult>(
+				bundle.results,
+			);
+		const readyRequests = collectData<WorkspaceProposalReadyRequest>(bundle.readyRequests);
+		const issues = collectData<WorkspaceProposalRecordedIssue>(bundle.issues);
+
+		previews.down([["DATA", preview]]);
+		inputs.down([["DATA", input]]);
+		inputs.down([["DATA", structuredClone(input)]]);
+
+		expect(results).toHaveLength(1);
+		expect(results[0]).toMatchObject({ status: "prepared", preparationId: input.preparationId });
+		expect(readyRequests).toHaveLength(1);
+		expect(readyRequests[0]).toMatchObject({
+			kind: "workspace-proposal-ready-request",
+			proposalId: input.successorProposalId,
+			draftRefs: input.draftRefs,
+		});
+		expect(Object.isFrozen(readyRequests[0])).toBe(true);
+		inputs.down([
+			[
+				"DATA",
+				{
+					...input,
+					draftRefs: undefined,
+					finalDraftSourceRefs: undefined,
+				},
+			],
+		]);
+		expect(results).toHaveLength(2);
+		expect(results.at(-1)).toMatchObject({
+			status: "blocked",
+			preparationId: input.preparationId,
+			issues: expect.arrayContaining([
+				expect.objectContaining({ code: "repair-successor-preparation-already-prepared" }),
+			]),
+		});
+		expect(results.at(-1)).not.toHaveProperty("readyRequest");
+		expect(Object.hasOwn(results.at(-1) ?? {}, "readyRequest")).toBe(false);
+		expect(readyRequests).toHaveLength(1);
+		expect(issues).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({ code: "repair-successor-preparation-already-prepared" }),
+			]),
+		);
+		expect(results[0]).not.toHaveProperty("record");
+		expect(results[0]).not.toHaveProperty("decision");
+		expect(results[0]).not.toHaveProperty("applicationStatus");
+		expect([...results, ...readyRequests].map((entry) => entry.kind)).not.toContain(
+			"workspace-proposal-recorded",
+		);
+		expect([...results, ...readyRequests].map((entry) => entry.kind)).not.toContain(
+			"workspace-proposal-admission-decision",
+		);
+		expect([...results, ...readyRequests].map((entry) => entry.kind)).not.toContain(
+			"workspace-proposal-application-status",
+		);
+		expect([...results, ...readyRequests]).toEqual(
+			expect.not.arrayContaining([
+				expect.objectContaining({ record: expect.anything() }),
+				expect.objectContaining({ decision: expect.anything() }),
+				expect.objectContaining({ applicationStatus: expect.anything() }),
+			]),
+		);
+		const manualRecord = recordWorkspaceProposal(readyRequests[0]);
+		expect(manualRecord.status.state).toBe("recorded");
+		expect(readyRequests).toHaveLength(1);
+		expect(results).toHaveLength(2);
+	});
+
+	it("compacts D472 successor preparation release to D471 immutable tombstone", () => {
+		const fixture = repairReviewFixture();
+		const status = projectWorkspaceProposalRepairReviewStatuses({ requests: [fixture.request] })[0];
+		if (status === undefined) throw new Error("expected D472 successor status");
+		const descriptor = projectWorkspaceProposalRepairActionDescriptors({
+			requests: [fixture.request],
+			statuses: [status],
+		}).find((entry) => entry.actionKind === "open-successor-proposal-flow");
+		if (descriptor === undefined) throw new Error("expected D472 successor descriptor");
+		const intent = repairActionIntent(fixture.request, descriptor, {
+			actionKind: "open-successor-proposal-flow",
+		});
+		const intentValidation = validateWorkspaceProposalRepairActionIntent(intent, {
+			descriptor,
+			request: fixture.request,
+			currentStatus: status,
+			capabilityRefs: intent.capabilityRefs,
+			policyRefs: intent.policyRefs,
+			policyStatus: "allowed",
+		});
+		const preview = projectWorkspaceProposalRepairSuccessorProposalIntakePreview(intent, {
+			descriptor,
+			request: fixture.request,
+			currentStatus: status,
+			capabilityRefs: intent.capabilityRefs,
+			policyRefs: intent.policyRefs,
+			policyStatus: "allowed",
+			suggestedLoweringKind: "work-item-spawn",
+		});
+		const input: WorkspaceProposalRepairSuccessorProposalReadyRequestPreparationInput<{
+			readonly title: string;
+		}> = {
+			kind: "workspace-proposal-repair-successor-proposal-ready-request-preparation-input",
+			preparationId: "successor-preparation:d472-release",
+			previewId: preview.previewId,
+			intent,
+			intentValidation,
+			descriptor,
+			request: fixture.request,
+			currentStatus: status,
+			successorProposalId: "successor-proposal:d472-release",
+			intakeRequestId: "successor-intake:d472-release",
+			successorIdempotencyKey: "successor-idempotency:d472-release",
+			workspaceId: "workspace:d472-release",
+			actorRef,
+			capabilityRefs: [capabilityRef],
+			policyRefs: [policyRef],
+			projectionBundleRefs: [projectionRef],
+			sourceRefs: [sourceRef],
+			audit: { auditId: "audit:d472-release", sourceRefs: [sourceRef] },
+			targetRefs: [{ kind: "work-item", id: "target:d472-release" }],
+			successorProposalFamily: fixture.request.proposalFamily,
+			successorLoweringKind: "work-item-spawn",
+			draft: { title: "first prepared request bulk" },
+			finalDraftSourceRefs: [{ kind: "workspace-final-draft", id: "draft:d472-release" }],
+		};
+		const g = graph();
+		const previews = g.node<WorkspaceProposalRepairSuccessorProposalIntakePreview>([], null, {
+			name: "d472PreparationPreviews",
+		});
+		const inputs = g.node<
+			WorkspaceProposalRepairSuccessorProposalReadyRequestPreparationInput<{
+				readonly title: string;
+			}>
+		>([], null, { name: "d472PreparationInputs" });
+		const releases = g.node<WorkspaceProposalProjectionRelease>([], null, {
+			name: "d472PreparationReleases",
+		});
+		const bundle = workspaceProposalRepairSuccessorProposalReadyRequestPreparationProjector(g, {
+			previews,
+			preparationInputs: inputs,
+			releases,
+		});
+		const results = collectData<
+			WorkspaceProposalRepairSuccessorProposalReadyRequestPreparationResult<{
+				readonly title: string;
+			}>
+		>(bundle.results);
+		const readyRequests = collectData<WorkspaceProposalReadyRequest>(bundle.readyRequests);
+		const issues = collectData<WorkspaceProposalRecordedIssue>(bundle.issues);
+
+		previews.down([["DATA", preview]]);
+		inputs.down([["DATA", input]]);
+		expect(results).toHaveLength(1);
+		expect(results[0]?.readyRequest).toBeDefined();
+		expect(readyRequests).toHaveLength(1);
+
+		expect(() =>
+			releases.down([
+				[
+					"DATA",
+					{
+						kind: "workspace-proposal-projection-release",
+						releaseId: "projection-release:d472-successor-preparation-bad",
+						targetKind: "repair-successor-preparation",
+						targetId: input.preparationId,
+						preparationId: input.preparationId,
+						sourceRefs: [{ kind: "provider", id: "runtime-private" }],
+					} as never,
+				],
+			]),
+		).not.toThrow();
+		inputs.down([["DATA", structuredClone(input)]]);
+		expect(results).toHaveLength(1);
+		expect(readyRequests).toHaveLength(1);
+
+		for (const mismatch of [
+			{ applicationId: "other-application" },
+			{ proposalId: "other-proposal" },
+			{ decisionId: "other-decision" },
+			{ idempotencyKey: "other-idempotency" },
+			{ proposalFamily: "required-input-response" as const },
+		]) {
+			releases.down([
+				[
+					"DATA",
+					projectionRelease(
+						`projection-release:d472-successor-preparation-coordinate-mismatch:${
+							Object.keys(mismatch)[0]
+						}`,
+						"repair-successor-preparation",
+						input.preparationId,
+						{
+							preparationId: input.preparationId,
+							previewId: preview.previewId,
+							...mismatch,
+						},
+					),
+				],
+			]);
+			inputs.down([["DATA", structuredClone(input)]]);
+			expect(results).toHaveLength(1);
+			expect(readyRequests).toHaveLength(1);
+		}
+
+		releases.down([
+			[
+				"DATA",
+				projectionRelease(
+					"projection-release:d472-successor-preparation",
+					"repair-successor-preparation",
+					input.preparationId,
+					{ preparationId: input.preparationId, previewId: preview.previewId },
+				),
+			],
+		]);
+		inputs.down([["DATA", structuredClone(input)]]);
+		expect(results).toHaveLength(2);
+		expect(results.at(-1)).toMatchObject({
+			status: "prepared",
+			preparationId: input.preparationId,
+			issues: [],
+		});
+		expect(results.at(-1)).not.toHaveProperty("readyRequest");
+		expect(readyRequests).toHaveLength(1);
+
+		previews.down([["DATA", structuredClone(preview)]]);
+		inputs.down([
+			[
+				"DATA",
+				{
+					...input,
+					successorProposalId: "successor-proposal:d472-different",
+					draft: { title: "different request after release" },
+				},
+			],
+		]);
+
+		expect(results.at(-1)).toMatchObject({
+			status: "blocked",
+			preparationId: input.preparationId,
+			issues: expect.arrayContaining([
+				expect.objectContaining({ code: "repair-successor-preparation-already-prepared" }),
+			]),
+		});
+		expect(results.at(-1)).not.toHaveProperty("readyRequest");
+		expect(readyRequests).toHaveLength(1);
+		expect(issues).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({ code: "repair-successor-preparation-already-prepared" }),
+			]),
+		);
+		expect(JSON.stringify(results.slice(1))).not.toContain("first prepared request bulk");
+	});
+
+	it("keeps D472 successor preview release scoped until fresh intent data", () => {
+		const fixture = repairReviewFixture();
+		const status = projectWorkspaceProposalRepairReviewStatuses({ requests: [fixture.request] })[0];
+		if (status === undefined) throw new Error("expected D472 preview status");
+		const descriptor = projectWorkspaceProposalRepairActionDescriptors({
+			requests: [fixture.request],
+			statuses: [status],
+		}).find((entry) => entry.actionKind === "open-successor-proposal-flow");
+		if (descriptor === undefined) throw new Error("expected D472 preview descriptor");
+		const intent = repairActionIntent(fixture.request, descriptor, {
+			actionKind: "open-successor-proposal-flow",
+		});
+		const g = graph();
+		const intents = g.node<WorkspaceProposalRepairActionIntent>([], null, {
+			name: "d472PreviewReleaseIntents",
+		});
+		const descriptors = g.node<WorkspaceProposalRepairActionDescriptor>([], null, {
+			name: "d472PreviewReleaseDescriptors",
+		});
+		const requests = g.node<WorkspaceProposalRepairReviewRequest>([], null, {
+			name: "d472PreviewReleaseRequests",
+		});
+		const statuses = g.node<typeof status>([], null, {
+			name: "d472PreviewReleaseStatuses",
+		});
+		const releases = g.node<WorkspaceProposalProjectionRelease>([], null, {
+			name: "d472PreviewReleaseReleases",
+		});
+		const bundle = workspaceProposalRepairSuccessorProposalIntakePreviewProjector(g, {
+			intents,
+			descriptors,
+			requests,
+			statuses,
+			releases,
+			capabilityRefs: intent.capabilityRefs,
+			policyRefs: intent.policyRefs,
+			policyStatus: "allowed",
+		});
+		const previews = collectData<WorkspaceProposalRepairSuccessorProposalIntakePreview>(
+			bundle.previews,
+		);
+
+		requests.down([["DATA", fixture.request]]);
+		statuses.down([["DATA", status]]);
+		descriptors.down([["DATA", descriptor]]);
+		intents.down([["DATA", intent]]);
+		expect(previews).toHaveLength(1);
+		const previewId = previews[0]?.previewId;
+		if (previewId === undefined) throw new Error("expected D472 preview id");
+
+		releases.down([
+			[
+				"DATA",
+				projectionRelease(
+					"projection-release:d472-preview",
+					"repair-successor-preview",
+					previewId,
+					{
+						previewId,
+						intentId: intent.intentId,
+						descriptorId: descriptor.descriptorId,
+						repairRequestId: fixture.request.repairRequestId,
+						actionKind: intent.actionKind,
+						applicationId: fixture.request.applicationId,
+						proposalId: fixture.request.proposalId,
+						decisionId: fixture.request.decisionId,
+						idempotencyKey: fixture.request.idempotencyKey,
+						proposalFamily: fixture.request.proposalFamily,
+					},
+				),
+			],
+		]);
+		requests.down([["DATA", structuredClone(fixture.request)]]);
+		statuses.down([["DATA", structuredClone(status)]]);
+		descriptors.down([["DATA", structuredClone(descriptor)]]);
+		expect(previews).toHaveLength(1);
+
+		intents.down([["DATA", structuredClone(intent)]]);
+		expect(previews).toHaveLength(2);
+	});
+
+	it("validates D468 repair action policy advisories as display-only material", () => {
+		const fixture = repairReviewFixture();
+		const status = projectWorkspaceProposalRepairReviewStatuses({ requests: [fixture.request] })[0];
+		if (status === undefined) throw new Error("expected D468 status");
+		const descriptor = projectWorkspaceProposalRepairActionDescriptors({
+			requests: [fixture.request],
+			statuses: [status],
+		}).find((entry) => entry.actionKind === "mark-human-resolved");
+		if (descriptor === undefined) throw new Error("expected D468 descriptor");
+		const advisory: WorkspaceProposalRepairActionDisplayPolicyAdvisory = {
+			kind: "workspace-proposal-repair-action-display-policy-advisory",
+			authority: "display-only-advisory",
+			descriptorId: descriptor.descriptorId,
+			repairRequestId: descriptor.repairRequestId,
+			actionKind: descriptor.actionKind,
+			applicationId: descriptor.applicationId,
+			proposalId: descriptor.proposalId,
+			decisionId: descriptor.decisionId,
+			idempotencyKey: descriptor.idempotencyKey,
+			proposalFamily: descriptor.proposalFamily,
+			displayAssessment: "needs-review",
+			policyEvidenceRefs: [{ kind: "policy-evidence", id: "policy:d468" }],
+			capabilityEvidenceRefs: [{ kind: "capability-evidence", id: "capability:d468" }],
+			advisoryIssues: [
+				{ kind: "human-review-required", message: "Display can ask for review.", severity: "info" },
+			],
+			displayCode: "human-review-required",
+			displayMessage: "Needs workspace review",
+			sourceRefs: [sourceRef],
+			audit: { auditId: "audit:d468", sourceRefs: [sourceRef] },
+			metadata: { displayOnly: true },
+		};
+		const validated = validateWorkspaceProposalRepairActionDisplayPolicyAdvisory(advisory, {
+			descriptor,
+			request: fixture.request,
+		});
+		expect(validated).toMatchObject({
+			status: "accepted",
+			advisory: { authority: "display-only-advisory", displayAssessment: "needs-review" },
+			issues: [],
+		});
+		const blockedIntent = validateWorkspaceProposalRepairActionIntent(
+			repairActionIntent(fixture.request, descriptor, { actionKind: descriptor.actionKind }),
+			{ descriptor, request: fixture.request, currentStatus: status },
+		);
+		expect(blockedIntent.status).toBe("blocked");
+		expect(blockedIntent.issues.map((entry) => entry.code)).toContain(
+			"missing-repair-action-policy-material",
+		);
+		const advisoryBackedIntent = validateWorkspaceProposalRepairActionIntent(
+			repairActionIntent(fixture.request, descriptor, {
+				actionKind: descriptor.actionKind,
+				sourceRefs: advisory.sourceRefs,
+				metadata: { advisory },
+			}),
+			{
+				descriptor,
+				request: fixture.request,
+				currentStatus: status,
+				sourceRefs: advisory.sourceRefs,
+				audit: advisory.audit,
+			},
+		);
+		expect(advisoryBackedIntent).toMatchObject({
+			status: "blocked",
+			issues: expect.arrayContaining([
+				expect.objectContaining({ code: "missing-repair-action-policy-material" }),
+			]),
+		});
+		const text = JSON.stringify(validated);
+		expect(text).not.toMatch(/allowed|permitted|authorized|canSubmit/);
+		expect(text).not.toContain("command");
+		expect(text).not.toContain("provider");
+		expect(text).not.toContain("runtime");
+		expect(
+			projectWorkspaceProposalRepairActionDisplayPolicyAdvisory(descriptor, fixture.request, {
+				displayAssessment: "no-known-blocker",
+				policyEvidenceRefs: [{ kind: "policy-evidence", id: "policy:d468-helper" }],
+				sourceRefs: [sourceRef],
+			}),
+		).toMatchObject({
+			authority: "display-only-advisory",
+			displayAssessment: "no-known-blocker",
+			descriptorId: descriptor.descriptorId,
+		});
+		const sanitizedHelper = projectWorkspaceProposalRepairActionDisplayPolicyAdvisory(
+			descriptor,
+			fixture.request,
+			{
+				displayAssessment: "needs-review",
+				displayMessage: "authorized to submit",
+				metadata: { canSubmit: true },
+				sourceRefs: [sourceRef],
+			},
+		);
+		expect(JSON.stringify(sanitizedHelper)).not.toMatch(/authorized|allowed|permitted|canSubmit/);
+		expect(
+			validateWorkspaceProposalRepairActionDisplayPolicyAdvisory(sanitizedHelper, {
+				descriptor,
+				request: fixture.request,
+			}),
+		).toMatchObject({ status: "accepted" });
+		const unsafeRefAdvisory = validateWorkspaceProposalRepairActionDisplayPolicyAdvisory(
+			{
+				...advisory,
+				sourceRefs: [{ kind: "provider", id: "runtime-private" }],
+			},
+			{ descriptor, request: fixture.request },
+		);
+		expect(unsafeRefAdvisory).toMatchObject({
+			status: "blocked",
+			issues: expect.arrayContaining([
+				expect.objectContaining({ code: "malformed-repair-action-display-policy-advisory" }),
+			]),
+		});
+		expect(unsafeRefAdvisory).not.toHaveProperty("advisory");
+		expect(JSON.stringify(unsafeRefAdvisory)).not.toContain("runtime-private");
+		const unsafeEvidenceHelper = projectWorkspaceProposalRepairActionDisplayPolicyAdvisory(
+			descriptor,
+			fixture.request,
+			{
+				displayAssessment: "needs-review",
+				policyEvidenceRefs: [{ kind: "provider", id: "runtime-private" }],
+				capabilityEvidenceRefs: [{ kind: "capability-evidence", id: "capability:d468-safe" }],
+				advisoryIssues: [
+					{
+						kind: "display-note",
+						message: "Display-only note",
+						ref: { kind: "provider", id: "runtime-private" },
+					},
+				],
+				sourceRefs: [sourceRef],
+			},
+		);
+		expect(JSON.stringify(unsafeEvidenceHelper)).not.toContain("runtime-private");
+		expect(unsafeEvidenceHelper.policyEvidenceRefs).toBeUndefined();
+		expect(unsafeEvidenceHelper.advisoryIssues).toBeUndefined();
+		const unsafeIssueRefAdvisory = validateWorkspaceProposalRepairActionDisplayPolicyAdvisory(
+			{
+				...advisory,
+				advisoryIssues: [
+					{
+						kind: "display-note",
+						message: "Display-only note",
+						ref: { kind: "provider", id: "runtime-private" },
+					},
+				],
+			},
+			{ descriptor, request: fixture.request },
+		);
+		expect(unsafeIssueRefAdvisory).toMatchObject({
+			status: "blocked",
+			issues: expect.arrayContaining([
+				expect.objectContaining({ code: "malformed-repair-action-display-policy-advisory" }),
+			]),
+		});
+		expect(JSON.stringify(unsafeIssueRefAdvisory)).not.toContain("runtime-private");
+		const malformedDisplayText = validateWorkspaceProposalRepairActionDisplayPolicyAdvisory(
+			{
+				...advisory,
+				displayCode: { code: "not-a-string" } as never,
+			},
+			{ descriptor, request: fixture.request },
+		);
+		expect(malformedDisplayText).toMatchObject({
+			status: "blocked",
+			issues: expect.arrayContaining([
+				expect.objectContaining({ code: "malformed-repair-action-display-policy-advisory" }),
+			]),
+		});
+		expect(
+			validateWorkspaceProposalRepairActionDisplayPolicyAdvisory(
+				{
+					...advisory,
+					metadata: { note: "x".repeat(5000) },
+				},
+				{ descriptor, request: fixture.request },
+			),
+		).toMatchObject({
+			status: "blocked",
+			issues: expect.arrayContaining([expect.objectContaining({ code: "malformed-metadata" })]),
+		});
+		const g = graph();
+		const descriptors = g.node<WorkspaceProposalRepairActionDescriptor>([], null, {
+			name: "advisoryDescriptors",
+		});
+		const requests = g.node<WorkspaceProposalRepairReviewRequest>([], null, {
+			name: "advisoryRequests",
+		});
+		const projector = workspaceProposalRepairActionDisplayPolicyAdvisoryProjector(g, {
+			descriptors,
+			requests,
+			displayAssessment: "unknown",
+			sourceRefs: [sourceRef],
+		});
+		const advisories = collectData<WorkspaceProposalRepairActionDisplayPolicyAdvisory>(
+			projector.advisories,
+		);
+		requests.down([["DATA", fixture.request]]);
+		descriptors.down([["DATA", descriptor]]);
+		descriptors.down([["DATA", structuredClone(descriptor)]]);
+		expect(advisories).toHaveLength(1);
+		expect(advisories[0]).toMatchObject({
+			authority: "display-only-advisory",
+			displayAssessment: "unknown",
+		});
+		const invalidGraph = graph();
+		const invalidDescriptors = invalidGraph.node<WorkspaceProposalRepairActionDescriptor>(
+			[],
+			null,
+			{
+				name: "invalidAdvisoryDescriptors",
+			},
+		);
+		const invalidRequests = invalidGraph.node<WorkspaceProposalRepairReviewRequest>([], null, {
+			name: "invalidAdvisoryRequests",
+		});
+		const invalidProjector = workspaceProposalRepairActionDisplayPolicyAdvisoryProjector(
+			invalidGraph,
+			{
+				descriptors: invalidDescriptors,
+				requests: invalidRequests,
+				displayAssessment: "no-known-blocker",
+				displayMessage: "authorized to submit",
+			},
+		);
+		const invalidAdvisories = collectData<WorkspaceProposalRepairActionDisplayPolicyAdvisory>(
+			invalidProjector.advisories,
+		);
+		invalidRequests.down([["DATA", fixture.request]]);
+		invalidDescriptors.down([["DATA", descriptor]]);
+		expect(invalidAdvisories).toEqual([]);
+
+		const proofy = validateWorkspaceProposalRepairActionDisplayPolicyAdvisory(
+			{ ...advisory, metadata: { canSubmit: true } },
+			{ descriptor, request: fixture.request },
+		);
+		expect(proofy).toMatchObject({
+			status: "blocked",
+			issues: expect.arrayContaining([
+				expect.objectContaining({
+					code: "forbidden-repair-action-permission-proof-vocabulary",
+				}),
+			]),
+		});
+		const proofyText = validateWorkspaceProposalRepairActionDisplayPolicyAdvisory(
+			{ ...advisory, displayMessage: "authorized by display" },
+			{ descriptor, request: fixture.request },
+		);
+		expect(proofyText).toMatchObject({
+			status: "blocked",
+			issues: expect.arrayContaining([
+				expect.objectContaining({
+					code: "forbidden-repair-action-permission-proof-vocabulary",
+				}),
+			]),
+		});
+		const cyclicMetadata: Record<string, unknown> = {};
+		cyclicMetadata.self = cyclicMetadata;
+		const cyclic = validateWorkspaceProposalRepairActionDisplayPolicyAdvisory(
+			{ ...advisory, metadata: cyclicMetadata },
+			{ descriptor, request: fixture.request },
+		);
+		expect(cyclic).toMatchObject({
+			status: "blocked",
+			issues: expect.arrayContaining([expect.objectContaining({ code: "cyclic-data-material" })]),
+		});
+		const mismatched = validateWorkspaceProposalRepairActionDisplayPolicyAdvisory(
+			{ ...advisory, proposalId: "other-proposal" },
+			{ descriptor, request: fixture.request },
+		);
+		expect(mismatched).toMatchObject({
+			status: "blocked",
+			issues: expect.arrayContaining([
+				expect.objectContaining({ code: "repair-action-advisory-coordinate-mismatch" }),
+			]),
+		});
+	});
+
+	it("fails D463 repair action policy and non-data intake material closed without descriptor permission truth", () => {
+		const fixture = repairReviewFixture();
+		const status = projectWorkspaceProposalRepairReviewStatuses({ requests: [fixture.request] })[0];
+		if (status === undefined) throw new Error("expected D463 status");
+		const descriptor = projectWorkspaceProposalRepairActionDescriptors({
+			requests: [fixture.request],
+			statuses: [status],
+		}).find((entry) => entry.actionKind === "mark-human-resolved");
+		if (descriptor === undefined) throw new Error("expected D463 descriptor");
+		const intent = repairActionIntent(fixture.request, descriptor, {
+			actionKind: "mark-human-resolved",
+		});
+
+		const blocked = validateWorkspaceProposalRepairActionIntent(intent, {
+			descriptor,
+			request: fixture.request,
+			currentStatus: status,
+			policyStatus: "blocked",
+			policyRefs: [{ kind: "policy", id: "repair-action:intake-policy" }],
+		});
+		expect(blocked).toMatchObject({
+			status: "blocked",
+			issues: [expect.objectContaining({ code: "blocked-repair-action-policy" })],
+		});
+		expect(
+			validateWorkspaceProposalRepairActionIntent(intent, {
+				descriptor,
+				request: fixture.request,
+				currentStatus: status,
+				policyStatus: "allowed",
+			}),
+		).toMatchObject({
+			status: "blocked",
+			issues: expect.arrayContaining([
+				expect.objectContaining({ code: "missing-repair-action-policy-material" }),
+			]),
+		});
+		expect(JSON.stringify(descriptor)).not.toMatch(
+			/permission|policyOutcome|capabilityEvidence|runtime|provider/i,
+		);
+
+		const malformed = validateWorkspaceProposalRepairActionIntent(
+			{
+				...intent,
+				metadata: { callback: "run-me" },
+				sourceRefs: [{ kind: "source", id: "bad", metadata: { runtimeHandle: "x" } }],
+			},
+			{ descriptor, request: fixture.request, currentStatus: status, policyStatus: "allowed" },
+		);
+		expect(malformed.status).toBe("blocked");
+		expect(malformed.issues.map((entry) => entry.code)).toContain("forbidden-runtime-material");
+		expect(malformed.intent).toBeUndefined();
+		expect(JSON.stringify(malformed)).not.toContain("run-me");
+		const unsafeAuditIntent = validateWorkspaceProposalRepairActionIntent(
+			{
+				...intent,
+				audit: {
+					auditId: "audit:unsafe-intent",
+					metadata: { providerHandle: "secret-audit" },
+				},
+			},
+			{ descriptor, request: fixture.request, currentStatus: status, policyStatus: "allowed" },
+		);
+		expect(unsafeAuditIntent.status).toBe("blocked");
+		expect(unsafeAuditIntent.audit).toBeUndefined();
+		expect(JSON.stringify(unsafeAuditIntent)).not.toContain("secret-audit");
+
+		const cyclicIntent = { ...intent } as Record<string, unknown>;
+		cyclicIntent.self = cyclicIntent;
+		const cyclicValidation = validateWorkspaceProposalRepairActionIntent(cyclicIntent, {
+			descriptor,
+			request: fixture.request,
+			currentStatus: status,
+			policyStatus: "allowed",
+		});
+		expect(cyclicValidation).toMatchObject({
+			status: "blocked",
+			issues: expect.arrayContaining([expect.objectContaining({ code: "cyclic-data-material" })]),
+		});
+
+		const unsafePreview = projectWorkspaceProposalRepairSuccessorProposalIntakePreview(
+			{ ...intent, actionKind: "open-successor-proposal-flow" },
+			{
+				descriptor: { ...descriptor, actionKind: "open-successor-proposal-flow" },
+				request: fixture.request,
+				currentStatus: status,
+				capabilityRefs: intent.capabilityRefs,
+				policyRefs: intent.policyRefs,
+				policyStatus: "allowed",
+				suggestedDraftPatch: { successorProposalId: "canonical-successor" },
+			},
+		);
+		expect(unsafePreview).toMatchObject({
+			status: "blocked",
+			diagnostics: expect.arrayContaining([
+				expect.objectContaining({ code: "forbidden-successor-truth-material" }),
+			]),
+		});
+		expect(unsafePreview.suggestedDraftPatch).toBeUndefined();
+		expect(unsafePreview.metadata).toBeUndefined();
+		expect(JSON.stringify(unsafePreview)).not.toContain("canonical-successor");
+		const nestedTruthPreview = projectWorkspaceProposalRepairSuccessorProposalIntakePreview(
+			{ ...intent, actionKind: "open-successor-proposal-flow" },
+			{
+				descriptor: { ...descriptor, actionKind: "open-successor-proposal-flow" },
+				request: fixture.request,
+				currentStatus: status,
+				capabilityRefs: intent.capabilityRefs,
+				policyRefs: intent.policyRefs,
+				policyStatus: "allowed",
+				suggestedDraftPatch: { draft: { proposalRecordRef: "canonical-successor" } },
+			},
+		);
+		expect(nestedTruthPreview).toMatchObject({
+			status: "blocked",
+			diagnostics: expect.arrayContaining([
+				expect.objectContaining({ code: "forbidden-successor-truth-material" }),
+			]),
+		});
+		expect(JSON.stringify(nestedTruthPreview)).not.toContain("canonical-successor");
+
+		const unsafeMetadataPreview = projectWorkspaceProposalRepairSuccessorProposalIntakePreview(
+			{ ...intent, actionKind: "open-successor-proposal-flow" },
+			{
+				descriptor: { ...descriptor, actionKind: "open-successor-proposal-flow" },
+				request: fixture.request,
+				currentStatus: status,
+				capabilityRefs: intent.capabilityRefs,
+				policyRefs: intent.policyRefs,
+				policyStatus: "allowed",
+				metadata: { providerAction: "call-network" },
+			},
+		);
+		expect(unsafeMetadataPreview).toMatchObject({
+			status: "blocked",
+			diagnostics: expect.arrayContaining([
+				expect.objectContaining({ code: "forbidden-runtime-material" }),
+			]),
+		});
+		expect(unsafeMetadataPreview.metadata).toBeUndefined();
+		expect(JSON.stringify(unsafeMetadataPreview)).not.toContain("call-network");
+
+		const cyclicPatch: Record<string, unknown> = { summary: "cyclic draft patch" };
+		cyclicPatch.self = cyclicPatch;
+		const cyclicPreview = projectWorkspaceProposalRepairSuccessorProposalIntakePreview(
+			{ ...intent, actionKind: "open-successor-proposal-flow" },
+			{
+				descriptor: { ...descriptor, actionKind: "open-successor-proposal-flow" },
+				request: fixture.request,
+				currentStatus: status,
+				capabilityRefs: intent.capabilityRefs,
+				policyRefs: intent.policyRefs,
+				policyStatus: "allowed",
+				suggestedDraftPatch: cyclicPatch,
+			},
+		);
+		expect(cyclicPreview).toMatchObject({
+			status: "blocked",
+			diagnostics: expect.arrayContaining([
+				expect.objectContaining({ code: "cyclic-data-material" }),
+			]),
+		});
+		expect(cyclicPreview.suggestedDraftPatch).toBeUndefined();
+	});
+
+	it("dedupes graph-visible D459 intent validation and D460 successor previews by stable identity", () => {
+		const fixture = repairReviewFixture();
+		const status = projectWorkspaceProposalRepairReviewStatuses({ requests: [fixture.request] })[0];
+		if (status === undefined) throw new Error("expected graph D459/D460 status");
+		const descriptor = projectWorkspaceProposalRepairActionDescriptors({
+			requests: [fixture.request],
+			statuses: [status],
+		}).find((entry) => entry.actionKind === "open-successor-proposal-flow");
+		if (descriptor === undefined) throw new Error("expected graph D459/D460 descriptor");
+		const intentA = repairActionIntent(fixture.request, descriptor, {
+			actionKind: "open-successor-proposal-flow",
+		});
+		const intentB = { ...intentA, intentId: "repair-action-intent:successor-b" };
+		const conflictingIntentA = { ...intentA, proposalId: "conflicting-proposal" };
+
+		const g = graph();
+		const intents = g.node<WorkspaceProposalRepairActionIntent>([], null, { name: "intents" });
+		const descriptors = g.node<WorkspaceProposalRepairActionDescriptor>([], null, {
+			name: "descriptors",
+		});
+		const requests = g.node<WorkspaceProposalRepairReviewRequest>([], null, { name: "requests" });
+		const statuses = g.node<typeof status>([], null, { name: "statuses" });
+		const validation = workspaceProposalRepairActionIntentProjector(g, {
+			intents,
+			descriptors,
+			requests,
+			statuses,
+			capabilityRefs: intentA.capabilityRefs,
+			policyRefs: intentA.policyRefs,
+			policyStatus: "allowed",
+		});
+		const previews = workspaceProposalRepairSuccessorProposalIntakePreviewProjector(g, {
+			intents,
+			descriptors,
+			requests,
+			statuses,
+			capabilityRefs: intentA.capabilityRefs,
+			policyRefs: intentA.policyRefs,
+			policyStatus: "allowed",
+		});
+		const results = collectData<WorkspaceProposalRepairActionIntentValidationResult>(
+			validation.results,
+		);
+		const previewData = collectData<WorkspaceProposalRepairSuccessorProposalIntakePreview>(
+			previews.previews,
+		);
+
+		requests.down([["DATA", fixture.request]]);
+		statuses.down([["DATA", status]]);
+		descriptors.down([["DATA", descriptor]]);
+		intents.down([["DATA", intentA]]);
+		intents.down([["DATA", structuredClone(intentA)]]);
+		intents.down([["DATA", intentB]]);
+
+		expect(results.map((entry) => entry.intentId)).toEqual([intentA.intentId, intentB.intentId]);
+		expect(previewData.map((entry) => entry.intentId)).toEqual([
+			intentA.intentId,
+			intentB.intentId,
+		]);
+		expect(previewData.every((entry) => entry.status === "proposal-context-ready")).toBe(true);
+
+		intents.down([["DATA", conflictingIntentA]]);
+
+		expect(results.at(-1)).toMatchObject({
+			intentId: intentA.intentId,
+			status: "blocked",
+			issues: [expect.objectContaining({ code: "conflicting-repair-action-intent" })],
+		});
+		expect(previewData.at(-1)).toMatchObject({
+			intentId: intentA.intentId,
+			status: "blocked",
+			diagnostics: [expect.objectContaining({ code: "conflicting-repair-action-intent" })],
+		});
+
+		const cyclicIntent = { ...intentA, intentId: "repair-action-intent:cyclic" } as Record<
+			string,
+			unknown
+		>;
+		cyclicIntent.self = cyclicIntent;
+		expect(() => intents.down([["DATA", cyclicIntent]])).not.toThrow();
+		expect(results.at(-1)).toMatchObject({
+			intentId: "repair-action-intent:cyclic",
+			status: "blocked",
+			issues: [expect.objectContaining({ code: "cyclic-data-material" })],
+		});
+	});
+
+	it("resolves D444 lifecycle only from matching durable proof coordinates", () => {
+		const { request, appliedStatus, outcome, outcomeStatus, outcomeIndex } = repairReviewFixture();
+
+		expect(
+			projectWorkspaceProposalRepairReviewStatuses({
+				requests: [request],
+				outcomeStatuses: [outcomeStatus],
+			})[0],
+		).toMatchObject({ state: "resolved", proofKind: "family-outcome-status" });
+		expect(
+			projectWorkspaceProposalRepairReviewStatuses({
+				requests: [request],
+				outcomeStatuses: [{ ...outcomeStatus, proposalId: "other-proposal" }],
+			})[0]?.state,
+		).toBe("open");
+		expect(
+			projectWorkspaceProposalRepairReviewStatuses({
+				requests: [request],
+				outcomeStatuses: [{ ...outcomeStatus, outcomeRefs: [] }],
+			})[0]?.state,
+		).toBe("open");
+
+		expect(
+			projectWorkspaceProposalRepairReviewStatuses({
+				requests: [request],
+				outcomeIndex,
+			})[0],
+		).toMatchObject({ state: "resolved", proofKind: "family-outcome-index" });
+		expect(
+			projectWorkspaceProposalRepairReviewStatuses({
+				requests: [request],
+				outcomeIndex: [{ ...outcomeIndex[0], idempotencyKey: "other-idem" }],
+			})[0]?.state,
+		).toBe("open");
+
+		expect(
+			projectWorkspaceProposalRepairReviewStatuses({
+				requests: [request],
+				applicationStatuses: [appliedStatus],
+			})[0],
+		).toMatchObject({ state: "resolved", proofKind: "application-status" });
+		expect(
+			projectWorkspaceProposalRepairReviewStatuses({
+				requests: [request],
+				applicationStatuses: [{ ...appliedStatus, proposalId: "other-proposal" }, appliedStatus],
+			})[0],
+		).toMatchObject({ state: "resolved", proofKind: "application-status" });
+		expect(
+			projectWorkspaceProposalRepairReviewStatuses({
+				requests: [request],
+				applicationStatuses: [{ ...appliedStatus, emittedFactRefs: [] }],
+			})[0]?.state,
+		).toBe("open");
+
+		expect(outcome).toBeDefined();
+	});
+
+	it("does not resolve outcome-specific D444 repair requests from sibling outcomes", () => {
+		const { request, appliedStatus, outcomeStatus } = repairReviewFixture();
+		const repairOutcomeStatus = {
+			...outcomeStatus,
+			outcomeId: "repair-review-outcome-a",
+			state: "repair-needed",
+			outcomeRefs: [],
+			issues: [
+				{
+					kind: "issue",
+					source: "workspace-proposal",
+					severity: "error",
+					code: "missing-required-field",
+					message: "Outcome A missing material",
+					subjectId: outcomeStatus.proposalId,
+					refs: [],
+				},
+			],
+		} satisfies typeof outcomeStatus;
+		const outcomeRequest = projectWorkspaceProposalRepairReviewRequests({
+			applicationStatuses: [appliedStatus],
+			outcomeStatuses: [repairOutcomeStatus],
+		})[0];
+		expect(outcomeRequest).toBeDefined();
+		if (outcomeRequest === undefined) throw new Error("expected outcome repair request");
+
+		expect(outcomeRequest.repairRequestId).not.toBe(request.repairRequestId);
+		expect(
+			projectWorkspaceProposalRepairReviewStatuses({
+				requests: [outcomeRequest],
+				applicationStatuses: [appliedStatus],
+			})[0]?.state,
+		).toBe("open");
+		expect(
+			projectWorkspaceProposalRepairReviewStatuses({
+				requests: [outcomeRequest],
+				outcomeStatuses: [outcomeStatus],
+			})[0]?.state,
+		).toBe("open");
+	});
+
+	it("joins WorkspaceProposalApplicationRecorded to matching status before D444 resolution", () => {
+		const { request, appliedStatus, applicationRecorded } = repairReviewFixture();
+		expect(applicationRecorded).toBeDefined();
+		if (applicationRecorded === undefined) throw new Error("expected application recorded proof");
+
+		expect(
+			projectWorkspaceProposalRepairReviewStatuses({
+				requests: [request],
+				applicationRecorded: [applicationRecorded],
+			})[0]?.state,
+		).toBe("open");
+		expect(
+			projectWorkspaceProposalRepairReviewStatuses({
+				requests: [request],
+				applicationStatuses: [appliedStatus],
+				applicationRecorded: [applicationRecorded],
+			})[0],
+		).toMatchObject({
+			state: "resolved",
+			proofKind: "application-recorded",
+		});
+	});
+
+	it("fails closed on incomparable D444 human terminal decision conflicts", () => {
+		const { request } = repairReviewFixture();
+		const resolved = repairReviewDecision(request, "resolved", "review-resolved");
+		const withdrawn = repairReviewDecision(request, "withdrawn", "review-withdrawn");
+		const secondResolved = repairReviewDecision(request, "resolved", "review-resolved-2");
+		const supersedingWithdrawn = {
+			...withdrawn,
+			supersedesRefs: [
+				{ kind: "workspace-proposal-repair-review-decision", id: resolved.reviewDecisionId },
+			],
+		} satisfies WorkspaceProposalRepairReviewDecision;
+
+		expect(
+			projectWorkspaceProposalRepairReviewStatuses({
+				requests: [request],
+				decisions: [resolved, withdrawn],
+			})[0],
+		).toMatchObject({
+			state: "conflict",
+			code: "conflicting-repair-review-decisions",
+			conflicts: expect.arrayContaining([
+				expect.objectContaining({ reviewDecisionId: "review-resolved" }),
+				expect.objectContaining({ reviewDecisionId: "review-withdrawn" }),
+			]),
+		});
+		expect(
+			projectWorkspaceProposalRepairReviewStatuses({
+				requests: [request],
+				decisions: [resolved, supersedingWithdrawn],
+			})[0],
+		).toMatchObject({
+			state: "withdrawn",
+			conflicts: [],
+		});
+		expect(
+			projectWorkspaceProposalRepairReviewStatuses({
+				requests: [request],
+				decisions: [resolved, secondResolved],
+			})[0],
+		).toMatchObject({
+			state: "conflict",
+			code: "conflicting-repair-review-decisions",
+		});
+	});
+
+	it("preserves full-coordinate candidates in graph-visible D444 lifecycle proof state", () => {
+		const applicationGraph = graph();
+		const applicationRequests = applicationGraph.node<WorkspaceProposalRepairReviewRequest>(
+			[],
+			null,
+			{ name: "applicationRequests" },
+		);
+		const applicationStatuses = applicationGraph.node<WorkspaceProposalApplicationStatus>(
+			[],
+			null,
+			{
+				name: "applicationStatuses",
+			},
+		);
+		const applicationProjector = workspaceProposalRepairReviewStatusProjector(applicationGraph, {
+			requests: applicationRequests,
+			applicationStatuses,
+		});
+		const applicationResults = collectData(applicationProjector.statuses);
+		const fixture = repairReviewFixture();
+
+		applicationRequests.down([["DATA", fixture.request]]);
+		applicationStatuses.down([["DATA", fixture.appliedStatus]]);
+		applicationStatuses.down([
+			["DATA", { ...fixture.appliedStatus, proposalId: "other-proposal" }],
+		]);
+
+		expect(applicationResults.map((status) => status.state)).toEqual(["open", "resolved"]);
+		expect(applicationResults.at(-1)).toMatchObject({
+			state: "resolved",
+			proofKind: "application-status",
+		});
+
+		const outcomeGraph = graph();
+		const outcomeRequests = outcomeGraph.node<WorkspaceProposalRepairReviewRequest>([], null, {
+			name: "outcomeRequests",
+		});
+		const outcomeStatuses = outcomeGraph.node<typeof fixture.outcomeStatus>([], null, {
+			name: "outcomeStatuses",
+		});
+		const outcomeProjector = workspaceProposalRepairReviewStatusProjector(outcomeGraph, {
+			requests: outcomeRequests,
+			outcomeStatuses,
+		});
+		const outcomeResults = collectData(outcomeProjector.statuses);
+
+		outcomeRequests.down([["DATA", fixture.request]]);
+		outcomeStatuses.down([["DATA", fixture.outcomeStatus]]);
+		outcomeStatuses.down([["DATA", { ...fixture.outcomeStatus, proposalId: "other-proposal" }]]);
+
+		expect(outcomeResults.map((status) => status.state)).toEqual(["open", "resolved"]);
+		expect(outcomeResults.at(-1)).toMatchObject({
+			state: "resolved",
+			proofKind: "family-outcome-status",
+		});
+	});
+
+	it("dedupes graph-visible D444 repair-review lifecycle emissions on replay", () => {
+		const g = graph();
+		const requests = g.node<WorkspaceProposalRepairReviewRequest>([], null, { name: "requests" });
+		const decisions = g.node<WorkspaceProposalRepairReviewDecision>([], null, {
+			name: "decisions",
+		});
+		const durableStatuses = g.node<ReturnType<typeof repairReviewFixture>["outcomeStatus"]>(
+			[],
+			null,
+			{ name: "outcomeStatuses" },
+		);
+		const projector = workspaceProposalRepairReviewStatusProjector(g, {
+			requests,
+			decisions,
+			outcomeStatuses: durableStatuses,
+		});
+		const statuses = collectData(projector.statuses);
+		const fixture = repairReviewFixture();
+		const acknowledged = repairReviewDecision(fixture.request, "acknowledged", "review-ack");
+		const acknowledgedWithReason = {
+			...acknowledged,
+			reason: "looked-at-by-human",
+		} satisfies WorkspaceProposalRepairReviewDecision;
+
+		requests.down([["DATA", fixture.request]]);
+		requests.down([["DATA", fixture.request]]);
+		decisions.down([["DATA", acknowledged]]);
+		decisions.down([["DATA", acknowledged]]);
+		decisions.down([["DATA", acknowledgedWithReason]]);
+		durableStatuses.down([["DATA", fixture.outcomeStatus]]);
+		durableStatuses.down([["DATA", fixture.outcomeStatus]]);
+
+		expect(statuses.map((status) => status.state)).toEqual([
+			"open",
+			"acknowledged",
+			"acknowledged",
+			"resolved",
+		]);
+		expect(statuses[2]?.decisions[0]?.reason).toBe("looked-at-by-human");
+	});
+
+	it("composes D445 Canvas read-model handoff from projected material only", () => {
+		const { request, outcome, outcomeIndex, outcomeStatus } = repairReviewFixture();
+		const readModelCoordinates = repairReviewReadModelCoordinates(request);
+		expect(outcome).toBeDefined();
+		if (outcome === undefined) throw new Error("expected outcome detail");
+		const repairStatus = projectWorkspaceProposalRepairReviewStatuses({
+			requests: [request],
+			outcomeStatuses: [outcomeStatus],
+		})[0];
+		const rawIssueOnly = projectWorkspaceProposalFamilyApplicationReadModel({
+			...({
+				issues: [
+					{
+						kind: "issue",
+						source: "workspace-proposal",
+						severity: "error",
+						code: "missing-domain-action-facts",
+						message: "raw issue must not be classified by read-model",
+						subjectId: request.proposalId,
+					},
+				],
+			} as Record<string, unknown>),
+			applicationId: request.applicationId,
+		});
+		expect(rawIssueOnly.diagnostics).toEqual([]);
+		expect(rawIssueOnly.repairReviewStatuses).toEqual([]);
+
+		const diagnostic = projectWorkspaceProposalFamilyApplicationDiagnostics({
+			outcomeStatuses: [
+				{
+					...outcomeStatus,
+					state: "repair-needed",
+					outcomeRefs: [],
+					issues: [
+						{
+							kind: "issue",
+							source: "workspace-proposal",
+							severity: "error",
+							code: "missing-required-field",
+							message: "Outcome detail missing",
+							subjectId: request.proposalId,
+							refs: [],
+						},
+					],
+				},
+			],
+		})[0];
+		const readModel = projectWorkspaceProposalFamilyApplicationReadModel({
+			...readModelCoordinates,
+			diagnostics: diagnostic === undefined ? [] : [diagnostic],
+			repairReviewStatuses: repairStatus === undefined ? [] : [repairStatus],
+			outcomeIndex,
+			outcomeStatuses: [outcomeStatus],
+			outcomes: [outcome],
+			limit: 1,
+		});
+
+		expect(readModel).toMatchObject({
+			kind: "workspace-proposal-family-application-read-model",
+			applicationId: request.applicationId,
+			diagnostics: diagnostic === undefined ? [] : [diagnostic],
+			repairReviewStatuses: repairStatus === undefined ? [] : [repairStatus],
+			page: { offset: 0, limit: 1, totalOutcomeRefs: 1, returnedOutcomeRefs: 1 },
+			displayDiagnostics: [],
+		});
+		expect(readModel.outcomeIndexes[0]?.outcomeRefs[0]).toMatchObject({
+			kind: "workspace-proposal-family-outcome-ref",
+			outcomeId: outcome.outcomeId,
+		});
+		expect(readModel.outcomeDetails[0]).toMatchObject({
+			outcomeRef: expect.objectContaining({ outcomeId: outcome.outcomeId }),
+			outcome: expect.objectContaining({ outcomeId: outcome.outcomeId }),
+			status: expect.objectContaining({ outcomeId: outcome.outcomeId }),
+		});
+		const collision = projectWorkspaceProposalFamilyApplicationReadModel({
+			...readModelCoordinates,
+			outcomeIndex,
+			outcomes: [{ ...outcome, proposalId: "other-proposal" }, outcome],
+			outcomeStatuses: [{ ...outcomeStatus, proposalId: "other-proposal" }, outcomeStatus],
+		});
+		expect(collision.displayDiagnostics).toEqual([]);
+		expect(collision.outcomeDetails[0]).toMatchObject({
+			outcome: expect.objectContaining({ proposalId: request.proposalId }),
+			status: expect.objectContaining({ proposalId: request.proposalId }),
+		});
+		const wrongKindOutcomeIndex = [
+			{
+				...outcomeIndex[0]!,
+				outcomeRefs: [
+					{
+						...outcomeIndex[0]!.outcomeRefs[0]!,
+						outcomeKind: "workspace-proposal-work-item-spawn-outcome-recorded",
+					},
+				],
+			},
+		] satisfies typeof outcomeIndex;
+		const wrongKind = projectWorkspaceProposalFamilyApplicationReadModel({
+			...readModelCoordinates,
+			outcomeIndex: wrongKindOutcomeIndex,
+			outcomes: [outcome],
+			outcomeStatuses: [outcomeStatus],
+		});
+		expect(wrongKind.displayDiagnostics.map((entry) => entry.code)).toEqual([
+			"mismatched-outcome-detail",
+			"mismatched-outcome-status",
+		]);
+		expect(wrongKind.outcomeDetails[0]?.outcome).toBeUndefined();
+		expect(wrongKind.outcomeDetails[0]?.status).toBeUndefined();
+
+		const mismatched = projectWorkspaceProposalFamilyApplicationReadModel({
+			...readModelCoordinates,
+			outcomeIndex,
+			outcomes: [{ ...outcome, proposalId: "other-proposal" }],
+		});
+		expect(mismatched.displayDiagnostics.map((entry) => entry.code)).toEqual([
+			"mismatched-outcome-detail",
+		]);
+		const missing = projectWorkspaceProposalFamilyApplicationReadModel({
+			...readModelCoordinates,
+			outcomeIndex,
+		});
+		expect(missing.displayDiagnostics.map((entry) => entry.code)).toEqual([
+			"missing-outcome-detail",
+		]);
+		const secondPage = projectWorkspaceProposalFamilyApplicationReadModel({
+			...readModelCoordinates,
+			outcomeIndex,
+			offset: 1,
+			limit: 1,
+		});
+		expect(secondPage.readModelId).not.toBe(readModel.readModelId);
+		const partialCoordinates = projectWorkspaceProposalFamilyApplicationReadModel({
+			applicationId: request.applicationId,
+			diagnostics: diagnostic === undefined ? [] : [diagnostic],
+			repairReviewStatuses: repairStatus === undefined ? [] : [repairStatus],
+			outcomeIndex,
+			outcomeStatuses: [outcomeStatus],
+			outcomes: [outcome],
+		});
+		expect(partialCoordinates).toMatchObject({
+			diagnostics: [],
+			repairReviewStatuses: [],
+			outcomeIndexes: [],
+			outcomeDetails: [],
+		});
+	});
+
+	it("exposes graph-visible D445 read-model projection without raw classification", () => {
+		const g = graph();
+		const diagnostics = g.node<
+			ReturnType<typeof projectWorkspaceProposalFamilyApplicationDiagnostics>[number]
+		>([], null, { name: "diagnostics" });
+		const repairStatuses = g.node<
+			ReturnType<typeof projectWorkspaceProposalRepairReviewStatuses>[number]
+		>([], null, { name: "repairStatuses" });
+		const outcomeIndex = g.node<
+			ReturnType<typeof projectWorkspaceProposalFamilyOutcomeIndex>[number]
+		>([], null, { name: "outcomeIndex" });
+		const outcomeStatuses = g.node<ReturnType<typeof repairReviewFixture>["outcomeStatus"]>(
+			[],
+			null,
+			{ name: "outcomeStatuses" },
+		);
+		const outcomes = g.node<NonNullable<ReturnType<typeof repairReviewFixture>["outcome"]>>(
+			[],
+			null,
+			{ name: "outcomes" },
+		);
+		const fixture = repairReviewFixture();
+		const readModelCoordinates = repairReviewReadModelCoordinates(fixture.request);
+		const repairStatus = projectWorkspaceProposalRepairReviewStatuses({
+			requests: [fixture.request],
+			outcomeStatuses: [fixture.outcomeStatus],
+		})[0];
+		const projector = workspaceProposalFamilyApplicationReadModelProjector(g, {
+			diagnostics,
+			repairReviewStatuses: repairStatuses,
+			outcomeIndex,
+			outcomeStatuses,
+			outcomes,
+			...readModelCoordinates,
+			limit: 1,
+		});
+		const readModels = collectData(projector.readModels);
+
+		if (repairStatus !== undefined) repairStatuses.down([["DATA", repairStatus]]);
+		outcomeIndex.down([["DATA", fixture.outcomeIndex[0]]]);
+		outcomeStatuses.down([["DATA", fixture.outcomeStatus]]);
+		if (fixture.outcome !== undefined) {
+			outcomes.down([["DATA", fixture.outcome]]);
+			outcomeStatuses.down([["DATA", { ...fixture.outcomeStatus, proposalId: "other-proposal" }]]);
+			outcomes.down([["DATA", { ...fixture.outcome, proposalId: "other-proposal" }]]);
+		}
+
+		expect(readModels.at(-1)).toMatchObject({
+			applicationId: fixture.request.applicationId,
+			repairReviewStatuses: repairStatus === undefined ? [] : [repairStatus],
+			displayDiagnostics: [],
+		});
+		expect(readModels.at(-1)?.outcomeDetails[0]).toMatchObject({
+			outcome: expect.objectContaining({ proposalId: fixture.request.proposalId }),
+			status: expect.objectContaining({ proposalId: fixture.request.proposalId }),
+		});
+	});
+
+	it("projects D448 query-driven read-model pages without query-side classification authority", () => {
+		const fixture = repairReviewFixture();
+		const coordinates = repairReviewReadModelCoordinates(fixture.request);
+		const repairStatus = projectWorkspaceProposalRepairReviewStatuses({
+			requests: [fixture.request],
+			outcomeStatuses: [fixture.outcomeStatus],
+		})[0];
+		const diagnosticSourceStatus = {
+			...fixture.outcomeStatus,
+			state: "repair-needed",
+			outcomeRefs: [],
+			issues: [
+				{
+					kind: "issue",
+					source: "workspace-proposal",
+					severity: "error",
+					code: "missing-required-field",
+					message: "Outcome detail missing",
+					subjectId: fixture.request.proposalId,
+					refs: [],
+				},
+			],
+		} satisfies typeof fixture.outcomeStatus;
+		const diagnostic = projectWorkspaceProposalFamilyApplicationDiagnostics({
+			outcomeStatuses: [diagnosticSourceStatus],
+		})[0];
+		if (diagnostic === undefined) throw new Error("expected D448 diagnostic fixture");
+		if (repairStatus === undefined) throw new Error("expected D448 repair status fixture");
+		const query = readModelQuery("query-complete", coordinates);
+		const readModel = projectWorkspaceProposalFamilyApplicationReadModels({
+			queries: [query],
+			diagnostics: [diagnostic],
+			repairReviewStatuses: [repairStatus],
+			outcomeIndex: fixture.outcomeIndex,
+			outcomeStatuses: [fixture.outcomeStatus],
+			outcomes: [fixture.outcome],
+		})[0];
+
+		expect(readModel).toMatchObject({
+			queryId: "query-complete",
+			viewId: "view-query-complete",
+			...coordinates,
+			diagnostics: [diagnostic],
+			repairReviewStatuses: [repairStatus],
+			displayDiagnostics: [],
+			page: { offset: 0, limit: 50, totalOutcomeRefs: 1, returnedOutcomeRefs: 1 },
+		});
+		expect(readModel?.outcomeDetails[0]).toMatchObject({
+			outcome: expect.objectContaining({ outcomeId: fixture.outcome.outcomeId }),
+			status: expect.objectContaining({ outcomeId: fixture.outcome.outcomeId }),
+		});
+
+		const incomplete = projectWorkspaceProposalFamilyApplicationReadModels({
+			queries: [
+				{
+					kind: "workspace-proposal-family-application-read-model-query",
+					queryId: "query-incomplete",
+					viewId: "view-incomplete",
+					applicationId: coordinates.applicationId,
+					proposalId: coordinates.proposalId,
+					idempotencyKey: coordinates.idempotencyKey,
+					proposalFamily: coordinates.proposalFamily,
+					page: { offset: -10, limit: 999 },
+					sourceRefs: [sourceRef],
+				} as WorkspaceProposalFamilyApplicationReadModelQuery,
+			],
+			diagnostics: [diagnostic],
+			repairReviewStatuses: [repairStatus],
+			outcomeIndex: fixture.outcomeIndex,
+			outcomeStatuses: [fixture.outcomeStatus],
+			outcomes: [fixture.outcome],
+		})[0];
+		expect(incomplete).toMatchObject({
+			queryId: "query-incomplete",
+			viewId: "view-incomplete",
+			diagnostics: [],
+			repairReviewStatuses: [],
+			outcomeIndexes: [],
+			outcomeDetails: [],
+			page: { offset: 0, limit: 100, totalOutcomeRefs: 0, returnedOutcomeRefs: 0 },
+		});
+		expect(incomplete?.displayDiagnostics.map((entry) => entry.code)).toEqual([
+			"incomplete-read-model-query",
+		]);
+
+		const rawIssueQuery = {
+			...query,
+			queryId: "query-raw-issue",
+			rawIssues: [
+				{
+					code: "missing-domain-action-facts",
+					message: "query descriptors must not classify this",
+				},
+			],
+		} as WorkspaceProposalFamilyApplicationReadModelQuery;
+		const rawIssueOnly = projectWorkspaceProposalFamilyApplicationReadModels({
+			queries: [rawIssueQuery],
+		})[0];
+		expect(rawIssueOnly?.diagnostics).toEqual([]);
+		expect(rawIssueOnly?.repairReviewStatuses).toEqual([]);
+
+		const forbiddenMaterial = projectWorkspaceProposalFamilyApplicationReadModels({
+			queries: [
+				{
+					...query,
+					queryId: "query-forbidden-material",
+					metadata: { callback: "doRepair" },
+					sourceRefs: [
+						{ kind: "source", id: "safe" },
+						{ kind: "source", id: "bad", metadata: { providerClient: "x" } },
+					],
+				},
+			],
+			diagnostics: [diagnostic],
+			repairReviewStatuses: [repairStatus],
+			outcomeIndex: fixture.outcomeIndex,
+			outcomeStatuses: [fixture.outcomeStatus],
+			outcomes: [fixture.outcome],
+		})[0];
+		expect(forbiddenMaterial).toMatchObject({
+			queryId: "query-forbidden-material",
+			diagnostics: [],
+			repairReviewStatuses: [],
+			outcomeIndexes: [],
+			outcomeDetails: [],
+		});
+		expect(forbiddenMaterial?.displayDiagnostics.map((entry) => entry.code)).toEqual([
+			"malformed-read-model-query",
+		]);
+		expect(forbiddenMaterial?.displayDiagnostics[0]?.sourceRefs).toEqual([
+			{ kind: "source", id: "safe" },
+		]);
+	});
+
+	it("normalizes D448 page/filter identity and narrows only projected material", () => {
+		const fixture = repairReviewFixture();
+		const coordinates = repairReviewReadModelCoordinates(fixture.request);
+		const secondOutcome = recordWorkspaceProposalWorkItemLinkOutcome(fixture.appliedStatus, {
+			outcomeId: "repair-review-outcome-2",
+			linkRef: { kind: "work-item-link", id: "link-2" },
+		}).outcome;
+		if (secondOutcome === undefined) throw new Error("expected second D448 outcome");
+		const outcomeIndex = projectWorkspaceProposalFamilyOutcomeIndex([secondOutcome]);
+		const diagnosticA = {
+			kind: "workspace-proposal-family-application-diagnostic",
+			diagnosticId: "diagnostic-a",
+			classification: "missing-family-material",
+			...coordinates,
+			code: "diagnostic-a",
+			issues: [],
+			sourceRefs: [sourceRef],
+		} as const;
+		const diagnosticB = { ...diagnosticA, diagnosticId: "diagnostic-b", code: "diagnostic-b" };
+		const openStatus = projectWorkspaceProposalRepairReviewStatuses({
+			requests: [fixture.request],
+		})[0];
+		const resolvedStatus = projectWorkspaceProposalRepairReviewStatuses({
+			requests: [fixture.request],
+			outcomeStatuses: [fixture.outcomeStatus],
+		})[0];
+		if (openStatus === undefined || resolvedStatus === undefined) {
+			throw new Error("expected D448 repair statuses");
+		}
+		const filtered = projectWorkspaceProposalFamilyApplicationReadModels({
+			queries: [
+				readModelQuery("query-filtered", coordinates, {
+					page: { offset: -1, limit: 999 },
+					filters: {
+						outcomeIds: [secondOutcome.outcomeId],
+						outcomeKinds: [secondOutcome.kind],
+						diagnosticCodes: ["diagnostic-b"],
+						repairStates: ["open"],
+					},
+				}),
+			],
+			diagnostics: [diagnosticA, diagnosticB],
+			repairReviewStatuses: [openStatus, resolvedStatus],
+			outcomeIndex,
+			outcomes: [fixture.outcome, secondOutcome],
+		})[0];
+
+		expect(filtered).toMatchObject({
+			filters: {
+				outcomeIds: [secondOutcome.outcomeId],
+				outcomeKinds: [secondOutcome.kind],
+				diagnosticCodes: ["diagnostic-b"],
+				repairStates: ["open"],
+			},
+			page: { offset: 0, limit: 100, totalOutcomeRefs: 1, returnedOutcomeRefs: 1 },
+		});
+		expect(filtered?.diagnostics.map((entry) => entry.code)).toEqual(["diagnostic-b"]);
+		expect(filtered?.repairReviewStatuses.map((entry) => entry.state)).toEqual(["open"]);
+		expect(filtered?.outcomeDetails.map((entry) => entry.outcomeRef.outcomeId)).toEqual([
+			secondOutcome.outcomeId,
+		]);
+		expect(filtered?.readModelId).not.toBe(
+			projectWorkspaceProposalFamilyApplicationReadModels({
+				queries: [readModelQuery("query-filtered", coordinates, { page: { offset: 1, limit: 1 } })],
+				outcomeIndex,
+			})[0]?.readModelId,
+		);
+		const invalidClosedFilters = projectWorkspaceProposalFamilyApplicationReadModels({
+			queries: [
+				readModelQuery("query-invalid-closed-filters", coordinates, {
+					filters: {
+						outcomeKinds: ["not-an-outcome-kind"] as readonly never[],
+						repairStates: ["retry-now"] as readonly never[],
+					},
+				}),
+			],
+			diagnostics: [diagnosticA, diagnosticB],
+			repairReviewStatuses: [openStatus, resolvedStatus],
+			outcomeIndex,
+			outcomes: [fixture.outcome, secondOutcome],
+		})[0];
+		expect(invalidClosedFilters).toMatchObject({
+			queryId: "query-invalid-closed-filters",
+			diagnostics: [],
+			repairReviewStatuses: [],
+			outcomeIndexes: [],
+			outcomeDetails: [],
+		});
+		expect(invalidClosedFilters?.displayDiagnostics.map((entry) => entry.code)).toEqual([
+			"malformed-read-model-query",
+		]);
+		const pureCurrentView = projectWorkspaceProposalFamilyApplicationReadModels({
+			queries: [
+				{
+					...readModelQuery("query-pure-a", coordinates, { page: { offset: 0, limit: 1 } }),
+					viewId: "shared-pure-view",
+				},
+				{
+					...readModelQuery("query-pure-b", coordinates, { page: { offset: 1, limit: 1 } }),
+					viewId: "shared-pure-view",
+				},
+			],
+			outcomeIndex,
+		});
+		expect(pureCurrentView).toHaveLength(1);
+		expect(pureCurrentView[0]).toMatchObject({
+			queryId: "query-pure-b",
+			page: { offset: 1, limit: 1 },
+		});
+	});
+
+	it("normalizes D461 sort/group/search as display-only read-model presentation", () => {
+		const fixture = repairReviewFixture();
+		const coordinates = repairReviewReadModelCoordinates(fixture.request);
+		const secondOutcome = recordWorkspaceProposalWorkItemLinkOutcome(fixture.appliedStatus, {
+			outcomeId: "repair-review-outcome-2",
+			linkRef: { kind: "work-item-link", id: "link-2" },
+			audit: { recordedAtMs: 200 },
+		}).outcome;
+		if (secondOutcome === undefined) throw new Error("expected D461 second outcome");
+		const firstIndex = fixture.outcomeIndex[0];
+		const secondIndex = projectWorkspaceProposalFamilyOutcomeIndex([secondOutcome])[0];
+		if (firstIndex === undefined || secondIndex === undefined) throw new Error("expected indexes");
+		const repairStatus = projectWorkspaceProposalRepairReviewStatuses({
+			requests: [fixture.request],
+		})[0];
+		if (repairStatus === undefined) throw new Error("expected D461 repair status");
+		const diagnostic = {
+			kind: "workspace-proposal-family-application-diagnostic",
+			diagnosticId: "diagnostic-d461",
+			classification: "missing-family-material",
+			...coordinates,
+			code: "diagnostic-d461",
+			issues: [
+				{
+					kind: "issue",
+					source: "workspace-proposal",
+					severity: "error",
+					code: "diagnostic-d461",
+					message: "Visible diagnostic text",
+				},
+			],
+			sourceRefs: [sourceRef],
+		} as const;
+		const query = readModelQuery("query-d461", coordinates, {
+			page: { limit: 25 },
+			sort: [
+				{ field: "recorded-at-ms", direction: "desc" },
+				{ field: "outcome-id", direction: "desc" },
+				{ field: "outcome-id", direction: "asc" },
+			],
+			groupBy: ["repair-state", "outcome-kind", "repair-state"],
+			search: {
+				text: "repair-review-outcome",
+				fields: ["outcome-id", "diagnostic-message", "outcome-id"],
+			},
+		});
+		const readModel = projectWorkspaceProposalFamilyApplicationReadModels({
+			queries: [query],
+			diagnostics: [diagnostic],
+			repairReviewStatuses: [repairStatus],
+			outcomeIndex: [firstIndex, secondIndex],
+			outcomeStatuses: [fixture.outcomeStatus],
+			outcomes: [fixture.outcome, secondOutcome],
+		})[0];
+		if (readModel === undefined) throw new Error("expected D461 read model");
+
+		expect(readModel).toMatchObject({
+			queryId: "query-d461",
+			sort: [
+				{ field: "recorded-at-ms", direction: "desc" },
+				{ field: "outcome-id", direction: "asc" },
+			],
+			groupBy: ["outcome-kind", "repair-state"],
+			search: {
+				text: "repair-review-outcome",
+				fields: ["diagnostic-message", "outcome-id"],
+			},
+			displayDiagnostics: [],
+		});
+		expect(readModel.outcomeDetails.map((entry) => entry.outcomeRef.outcomeId)).toEqual([
+			"repair-review-outcome-2",
+			"repair-review-outcome",
+		]);
+		expect(readModel.displayGroups).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({
+					field: "outcome-kind",
+					value: fixture.outcome.kind,
+					count: 2,
+				}),
+				expect.objectContaining({ field: "repair-state", value: "open", count: 2 }),
+			]),
+		);
+		expect(readModel.outcomeIndexes).toHaveLength(2);
+		expect(readModel.readModelId).toContain("sort");
+		expect(readModel.readModelId).toContain("groupBy");
+		expect(readModel.readModelId).toContain("search");
+		expect(JSON.stringify(readModel)).not.toMatch(/cursor|provider|runtime|queryAdapter/i);
+
+		const malformed = projectWorkspaceProposalFamilyApplicationReadModels({
+			queries: [
+				readModelQuery("query-d461-bad", coordinates, {
+					sort: [{ field: "storage-cursor", direction: "asc" }] as never,
+					groupBy: ["raw-issue-classifier"] as never,
+					search: { text: "anything", fields: ["sourceRefs"] as never },
+				}),
+			],
+			diagnostics: [diagnostic],
+			repairReviewStatuses: [repairStatus],
+			outcomeIndex: [firstIndex, secondIndex],
+			outcomes: [fixture.outcome, secondOutcome],
+		})[0];
+		expect(malformed).toMatchObject({
+			queryId: "query-d461-bad",
+			diagnostics: [],
+			repairReviewStatuses: [],
+			outcomeIndexes: [],
+			outcomeDetails: [],
+		});
+		expect(malformed?.displayDiagnostics.map((entry) => entry.code)).toEqual([
+			"malformed-read-model-query",
+		]);
+		const malformedSearchShape = projectWorkspaceProposalFamilyApplicationReadModels({
+			queries: [
+				readModelQuery("query-d461-string-search", coordinates, {
+					search: "repair-review-outcome" as never,
+				}),
+			],
+			diagnostics: [diagnostic],
+			repairReviewStatuses: [repairStatus],
+			outcomeIndex: [firstIndex, secondIndex],
+			outcomes: [fixture.outcome, secondOutcome],
+		})[0];
+		expect(malformedSearchShape).toMatchObject({
+			queryId: "query-d461-string-search",
+			diagnostics: [],
+			repairReviewStatuses: [],
+			outcomeIndexes: [],
+			outcomeDetails: [],
+		});
+		expect(malformedSearchShape?.displayDiagnostics.map((entry) => entry.code)).toEqual([
+			"malformed-read-model-query",
+		]);
+	});
+
+	it("projects D462 outcome detail supply from explicit supplied facts only", () => {
+		const fixture = repairReviewFixture();
+		const ref = fixture.outcomeIndex[0]?.outcomeRefs[0];
+		if (ref === undefined) throw new Error("expected D462 ref");
+		const request: WorkspaceProposalFamilyOutcomeDetailSupplyRequest = {
+			kind: "workspace-proposal-family-outcome-detail-supply-request",
+			supplyRequestId: "supply:d462",
+			viewId: "view:d462",
+			...repairReviewReadModelCoordinates(fixture.request),
+			requestedOutcomeRefs: [ref],
+			page: { offset: 0, limit: 1 },
+			filters: { outcomeIds: [ref.outcomeId] },
+			sourceRefs: [{ kind: "workspace-outcome-detail-supply", id: "source:d462" }],
+			audit: {
+				auditId: "audit:d462",
+				sourceRefs: [{ kind: "audit", id: "source:d462" }],
+			},
+			metadata: { suppliedFactsOnly: true },
+		};
+		const result = projectWorkspaceProposalFamilyOutcomeDetailSupplyResults({
+			requests: [request],
+			suppliedOutcomes: [fixture.outcome],
+		})[0];
+
+		expect(result).toMatchObject({
+			kind: "workspace-proposal-family-outcome-detail-supply-result",
+			supplyRequestId: "supply:d462",
+			viewId: "view:d462",
+			currentViewId: "view:d462",
+			suppliedOutcomeFacts: [expect.objectContaining({ outcomeId: ref.outcomeId })],
+			missingRefs: [],
+			mismatchedRefs: [],
+			displayDiagnostics: [],
+			page: { offset: 0, limit: 1 },
+			filters: { outcomeIds: [ref.outcomeId] },
+		});
+		const missing = projectWorkspaceProposalFamilyOutcomeDetailSupplyResults({
+			requests: [request],
+			suppliedOutcomes: [],
+		})[0];
+		expect(missing).toMatchObject({
+			suppliedOutcomeFacts: [],
+			missingRefs: [ref],
+			displayDiagnostics: expect.arrayContaining([
+				expect.objectContaining({ code: "missing-supplied-outcome-detail" }),
+			]),
+		});
+		const mismatched = projectWorkspaceProposalFamilyOutcomeDetailSupplyResults({
+			requests: [request],
+			suppliedOutcomes: [{ ...fixture.outcome, proposalId: "other-proposal" }],
+		})[0];
+		expect(mismatched).toMatchObject({
+			suppliedOutcomeFacts: [],
+			mismatchedRefs: [ref],
+			displayDiagnostics: expect.arrayContaining([
+				expect.objectContaining({ code: "mismatched-supplied-outcome-detail" }),
+			]),
+		});
+		const mismatchedRequestedRef = { ...ref, proposalId: "other-proposal" };
+		const mismatchedRequestRefResult = projectWorkspaceProposalFamilyOutcomeDetailSupplyResults({
+			requests: [{ ...request, requestedOutcomeRefs: [mismatchedRequestedRef] }],
+			suppliedOutcomes: [fixture.outcome],
+		})[0];
+		expect(mismatchedRequestRefResult).toMatchObject({
+			suppliedOutcomeFacts: [],
+			mismatchedRefs: [mismatchedRequestedRef],
+			displayDiagnostics: expect.arrayContaining([
+				expect.objectContaining({ code: "mismatched-supplied-outcome-detail" }),
+			]),
+		});
+		const manyMismatchedRefs = Array.from({ length: 5 }, (_, index) => ({
+			...ref,
+			proposalId: `other-proposal:${index}`,
+		}));
+		const pagedMismatches = projectWorkspaceProposalFamilyOutcomeDetailSupplyResults({
+			requests: [
+				{
+					...request,
+					requestedOutcomeRefs: manyMismatchedRefs,
+					page: { offset: 1, limit: 2 },
+				},
+			],
+			suppliedOutcomes: [fixture.outcome],
+		})[0];
+		expect(pagedMismatches).toMatchObject({
+			suppliedOutcomeFacts: [],
+			mismatchedRefs: manyMismatchedRefs.slice(1, 3),
+		});
+		expect(projectWorkspaceProposalFamilyOutcomeIndex([fixture.outcome])).toEqual(
+			fixture.outcomeIndex,
+		);
+		const unsafeSupplied = projectWorkspaceProposalFamilyOutcomeDetailSupplyResults({
+			requests: [request],
+			suppliedOutcomes: [{ ...fixture.outcome, metadata: { providerHandle: "runtime-private" } }],
+		})[0];
+		expect(unsafeSupplied).toMatchObject({
+			suppliedOutcomeFacts: [],
+			mismatchedRefs: [ref],
+			displayDiagnostics: expect.arrayContaining([
+				expect.objectContaining({ code: "malformed-supplied-outcome-detail" }),
+			]),
+		});
+		expect(JSON.stringify(unsafeSupplied)).not.toContain("runtime-private");
+		const unsafeSuppliedRef = projectWorkspaceProposalFamilyOutcomeDetailSupplyResults({
+			requests: [request],
+			suppliedOutcomes: [
+				{
+					...fixture.outcome,
+					sourceRefs: [{ kind: "provider", id: "runtime-private" }],
+				},
+			],
+		})[0];
+		expect(unsafeSuppliedRef).toMatchObject({
+			suppliedOutcomeFacts: [],
+			mismatchedRefs: [ref],
+			displayDiagnostics: expect.arrayContaining([
+				expect.objectContaining({ code: "malformed-supplied-outcome-detail" }),
+			]),
+		});
+		expect(JSON.stringify(unsafeSuppliedRef)).not.toContain("runtime-private");
+		const malformedRequest = projectWorkspaceProposalFamilyOutcomeDetailSupplyResults({
+			requests: [
+				{
+					...request,
+					requestedOutcomeRefs: [
+						{
+							kind: "workspace-proposal-family-outcome-ref",
+							outcomeId: ref.outcomeId,
+						} as never,
+					],
+					sourceRefs: [{ kind: "workspace-outcome-detail-supply" } as never],
+				},
+			],
+			suppliedOutcomes: [fixture.outcome],
+		})[0];
+		expect(malformedRequest).toMatchObject({
+			suppliedOutcomeFacts: [],
+			missingRefs: [],
+			mismatchedRefs: [],
+			displayDiagnostics: expect.arrayContaining([
+				expect.objectContaining({ code: "malformed-outcome-detail-supply-request" }),
+			]),
+		});
+		const unsafeRequestedRefRequest = projectWorkspaceProposalFamilyOutcomeDetailSupplyResults({
+			requests: [
+				{
+					...request,
+					requestedOutcomeRefs: [
+						{
+							...ref,
+							sourceRefs: [{ kind: "provider", id: "runtime-private" }],
+						},
+					],
+				},
+			],
+			suppliedOutcomes: [fixture.outcome],
+		})[0];
+		expect(unsafeRequestedRefRequest).toMatchObject({
+			suppliedOutcomeFacts: [],
+			missingRefs: [],
+			mismatchedRefs: [],
+			displayDiagnostics: expect.arrayContaining([
+				expect.objectContaining({ code: "malformed-outcome-detail-supply-request" }),
+			]),
+		});
+		expect(JSON.stringify(unsafeRequestedRefRequest)).not.toContain("runtime-private");
+		const secondOutcome = recordWorkspaceProposalWorkItemLinkOutcome(fixture.appliedStatus, {
+			outcomeId: "repair-review-outcome-d462-2",
+			linkRef: { kind: "work-item-link", id: "link-d462-2" },
+		}).outcome;
+		if (secondOutcome === undefined) throw new Error("expected D462 second outcome");
+		const secondRef = projectWorkspaceProposalFamilyOutcomeIndex([secondOutcome])[0]
+			?.outcomeRefs[0];
+		if (secondRef === undefined) throw new Error("expected D462 second ref");
+		const bounded = projectWorkspaceProposalFamilyOutcomeDetailSupplyResults({
+			requests: [
+				{
+					...request,
+					requestedOutcomeRefs: [ref, secondRef],
+					page: { offset: 1, limit: 1 },
+					filters: { outcomeKinds: [secondRef.outcomeKind] },
+				},
+			],
+			suppliedOutcomes: [fixture.outcome, secondOutcome],
+		})[0];
+		expect(bounded).toMatchObject({
+			suppliedOutcomeFacts: [expect.objectContaining({ outcomeId: secondOutcome.outcomeId })],
+			missingRefs: [],
+			mismatchedRefs: [],
+			page: { offset: 1, limit: 1 },
+		});
+
+		const g = graph();
+		const requests = g.node<WorkspaceProposalFamilyOutcomeDetailSupplyRequest>([], null, {
+			name: "supplyRequests",
+		});
+		const outcomes = g.node<typeof fixture.outcome>([], null, { name: "suppliedOutcomes" });
+		const projector = workspaceProposalFamilyOutcomeDetailSupplyProjector(g, {
+			requests,
+			suppliedOutcomes: outcomes,
+		});
+		const results = collectData<WorkspaceProposalFamilyOutcomeDetailSupplyResult>(
+			projector.results,
+		);
+		requests.down([["DATA", request]]);
+		outcomes.down([["DATA", fixture.outcome]]);
+		outcomes.down([["DATA", structuredClone(fixture.outcome)]]);
+		expect(() =>
+			outcomes.down([
+				[
+					"DATA",
+					{
+						kind: "workspace-proposal-work-item-link-outcome-recorded",
+						sourceRefs: [sourceRef],
+					} as never,
+				],
+			]),
+		).not.toThrow();
+		requests.down([["DATA", structuredClone(request)]]);
+
+		expect(results).toHaveLength(2);
+		expect(results[0]?.displayDiagnostics.map((entry) => entry.code)).toEqual([
+			"missing-supplied-outcome-detail",
+		]);
+		expect(results.at(-1)).toMatchObject({ currentViewId: "view:d462", displayDiagnostics: [] });
+		expect(JSON.stringify(results.at(-1))).not.toMatch(/cursor|storage|provider|runtime/i);
+	});
+
+	it("preserves graph-visible D448 query/view pages and dedupes normalized replay", () => {
+		const g = graph();
+		const queries = g.node<WorkspaceProposalFamilyApplicationReadModelQuery>([], null, {
+			name: "queries",
+		});
+		const outcomeIndex = g.node<
+			ReturnType<typeof projectWorkspaceProposalFamilyOutcomeIndex>[number]
+		>([], null, { name: "outcomeIndex" });
+		const outcomes = g.node<NonNullable<ReturnType<typeof repairReviewFixture>["outcome"]>>(
+			[],
+			null,
+			{ name: "outcomes" },
+		);
+		const projector = workspaceProposalFamilyApplicationReadModelsProjector(g, {
+			queries,
+			outcomeIndex,
+			outcomes,
+		});
+		const readModels = collectData(projector.readModels);
+		const fixture = repairReviewFixture();
+		const coordinates = repairReviewReadModelCoordinates(fixture.request);
+		const secondOutcome = recordWorkspaceProposalWorkItemLinkOutcome(fixture.appliedStatus, {
+			outcomeId: "repair-review-outcome-graph-2",
+			linkRef: { kind: "work-item-link", id: "link-2" },
+		}).outcome;
+		if (secondOutcome === undefined) throw new Error("expected graph D448 second outcome");
+		const index = projectWorkspaceProposalFamilyOutcomeIndex([fixture.outcome, secondOutcome])[0];
+		if (index === undefined) throw new Error("expected graph D448 outcome index");
+
+		outcomeIndex.down([["DATA", index]]);
+		outcomes.down([["DATA", fixture.outcome]]);
+		outcomes.down([["DATA", secondOutcome]]);
+		queries.down([
+			["DATA", readModelQuery("query-page-a", coordinates, { page: { offset: -1, limit: 999 } })],
+		]);
+		queries.down([
+			["DATA", readModelQuery("query-page-a", coordinates, { page: { offset: 0, limit: 100 } })],
+		]);
+		queries.down([
+			["DATA", readModelQuery("query-page-b", coordinates, { page: { offset: 1, limit: 1 } })],
+		]);
+
+		expect(readModels.map((entry) => entry.queryId)).toEqual(["query-page-a", "query-page-b"]);
+		expect(readModels[0]?.page).toMatchObject({ offset: 0, limit: 100 });
+		expect(readModels[1]?.page).toMatchObject({ offset: 1, limit: 1 });
+		expect(readModels[0]?.readModelId).not.toBe(readModels[1]?.readModelId);
+
+		const sameViewA = {
+			...readModelQuery("query-same-view-a", coordinates, { page: { offset: 0, limit: 1 } }),
+			viewId: "shared-current-view",
+		};
+		const sameViewB = {
+			...readModelQuery("query-same-view-b", coordinates, { page: { offset: 1, limit: 1 } }),
+			viewId: "shared-current-view",
+		};
+		queries.down([["DATA", sameViewA]]);
+		queries.down([["DATA", sameViewB]]);
+		queries.down([["DATA", sameViewA]]);
+
+		expect(readModels.slice(2).map((entry) => entry.queryId)).toEqual([
+			"query-same-view-a",
+			"query-same-view-b",
+			"query-same-view-a",
+		]);
+	});
+
+	it("accepts D472 projection release material only for closed display scopes", () => {
+		const release: WorkspaceProposalProjectionRelease = {
+			kind: "workspace-proposal-projection-release",
+			releaseId: "projection-release:d472",
+			targetKind: "family-read-model-query",
+			targetId: "view:d472",
+			viewId: "view:d472",
+			queryId: "query:d472",
+			sourceRefs: [{ kind: "workspace-projection-release", id: "source:d472" }],
+			audit: {
+				auditId: "audit:d472-release",
+				sourceRefs: [{ kind: "workspace-projection-release", id: "audit-source:d472" }],
+			},
+			metadata: { reason: "host view no longer current" },
+		};
+
+		expect(isWorkspaceProposalProjectionReleaseMaterial(release)).toBe(true);
+		expect(
+			isWorkspaceProposalProjectionReleaseMaterial({
+				...release,
+				targetKind: "workspace-cache" as never,
+			}),
+		).toBe(false);
+		expect(
+			isWorkspaceProposalProjectionReleaseMaterial({
+				...release,
+				sourceRefs: [{ kind: "provider", id: "runtime-private" }],
+			}),
+		).toBe(false);
+		expect(
+			isWorkspaceProposalProjectionReleaseMaterial({
+				...release,
+				metadata: { storageOwner: "hidden-cache-owner" },
+			}),
+		).toBe(false);
+		expect(
+			isWorkspaceProposalProjectionReleaseMaterial({
+				...release,
+				metadata: { revocation: "not a ready-request revocation" },
+			}),
+		).toBe(false);
+		expect(
+			isWorkspaceProposalProjectionReleaseMaterial({
+				...release,
+				audit: {
+					auditId: "audit:d472-unsafe",
+					sourceRefs: [{ kind: "workspace-projection-release", id: "audit-source:d472" }],
+					metadata: { releaseAsPolicyProof: true },
+				},
+			}),
+		).toBe(false);
+		expect(
+			isWorkspaceProposalProjectionReleaseMaterial({
+				...release,
+				readyRequest: { kind: "workspace-proposal-ready-request" },
+			}),
+		).toBe(false);
+		expect(
+			isWorkspaceProposalProjectionReleaseMaterial({
+				...release,
+				policyProof: { kind: "runtime-private-proof" },
+			}),
+		).toBe(false);
+		expect(
+			isWorkspaceProposalProjectionReleaseMaterial({
+				...release,
+				targetId: release.queryId,
+			}),
+		).toBe(true);
+		expect(isWorkspaceProposalProjectionReleaseMaterial({ ...release, targetId: "*" })).toBe(false);
+		expect(
+			isWorkspaceProposalProjectionReleaseMaterial({
+				...release,
+				targetKind: "repair-action-advisory",
+				targetId: "open-successor-proposal-flow",
+				actionKind: "open-successor-proposal-flow",
+			}),
+		).toBe(false);
+		expect(
+			isWorkspaceProposalProjectionReleaseMaterial({
+				...release,
+				targetKind: "repair-action-advisory",
+				targetId: "repair-request:d472",
+				repairRequestId: "repair-request:d472",
+			}),
+		).toBe(false);
+		for (const mismatched of [
+			{ ...release, targetId: "other-view" },
+			{
+				...release,
+				targetKind: "outcome-detail-supply-request",
+				targetId: "other-supply-view",
+				viewId: "view:d472-supply",
+				supplyRequestId: "supply:d472",
+			},
+			{
+				...release,
+				targetKind: "repair-action-advisory",
+				targetId: "other-descriptor",
+				descriptorId: "descriptor:d472",
+				repairRequestId: "repair-request:d472",
+			},
+			{
+				...release,
+				targetKind: "repair-action-intent",
+				targetId: "other-intent",
+				intentId: "intent:d472",
+			},
+			{
+				...release,
+				targetKind: "repair-successor-preview",
+				targetId: "other-preview",
+				intentId: "intent:d472",
+				previewId: "preview:d472",
+			},
+			{
+				...release,
+				targetKind: "repair-successor-preparation",
+				targetId: "other-preparation",
+				preparationId: "preparation:d472",
+			},
+		] satisfies WorkspaceProposalProjectionRelease[]) {
+			expect(isWorkspaceProposalProjectionReleaseMaterial(mismatched)).toBe(false);
+		}
+		expect(
+			isWorkspaceProposalProjectionReleaseMaterial({
+				...release,
+				targetKind: "repair-successor-preview",
+				targetId: "preview:d472",
+			}),
+		).toBe(false);
+	});
+
+	it("drives D476 repair release choreography without revoking ready requests", () => {
+		const fixture = repairReviewFixture();
+		const status = projectWorkspaceProposalRepairReviewStatuses({ requests: [fixture.request] })[0];
+		if (status === undefined) throw new Error("expected D476 repair status");
+		const descriptor = projectWorkspaceProposalRepairActionDescriptors({
+			requests: [fixture.request],
+			statuses: [status],
+		}).find((entry) => entry.actionKind === "open-successor-proposal-flow");
+		if (descriptor === undefined) throw new Error("expected D476 descriptor");
+		const intent = repairActionIntent(fixture.request, descriptor, {
+			actionKind: "open-successor-proposal-flow",
+		});
+		const intentValidation = validateWorkspaceProposalRepairActionIntent(intent, {
+			descriptor,
+			request: fixture.request,
+			currentStatus: status,
+			capabilityRefs: intent.capabilityRefs,
+			policyRefs: intent.policyRefs,
+			policyStatus: "allowed",
+		});
+		const g = graph();
+		const requests = g.node<WorkspaceProposalRepairReviewRequest>([], null, {
+			name: "d476RepairRequests",
+		});
+		const statuses = g.node<typeof status>([], null, { name: "d476RepairStatuses" });
+		const descriptors = g.node<WorkspaceProposalRepairActionDescriptor>([], null, {
+			name: "d476RepairDescriptors",
+		});
+		const intents = g.node<WorkspaceProposalRepairActionIntent>([], null, {
+			name: "d476RepairIntents",
+		});
+		const releases = g.node<WorkspaceProposalProjectionRelease>([], null, {
+			name: "d476RepairReleases",
+		});
+		const preparationInputs = g.node<
+			WorkspaceProposalRepairSuccessorProposalReadyRequestPreparationInput<{
+				readonly title: string;
+			}>
+		>([], null, { name: "d476PreparationInputs" });
+		const intentProjector = workspaceProposalRepairActionIntentProjector(g, {
+			intents,
+			descriptors,
+			requests,
+			statuses,
+			releases,
+			capabilityRefs: intent.capabilityRefs,
+			policyRefs: intent.policyRefs,
+			policyStatus: "allowed",
+		});
+		const previewProjector = workspaceProposalRepairSuccessorProposalIntakePreviewProjector(g, {
+			intents,
+			descriptors,
+			requests,
+			statuses,
+			releases,
+			capabilityRefs: intent.capabilityRefs,
+			policyRefs: intent.policyRefs,
+			policyStatus: "allowed",
+		});
+		const preparationProjector =
+			workspaceProposalRepairSuccessorProposalReadyRequestPreparationProjector(g, {
+				previews: previewProjector.previews,
+				preparationInputs,
+				releases,
+			});
+		const releaseFacts = collectData<WorkspaceProposalProjectionRelease>(releases);
+		const validations = collectData<WorkspaceProposalRepairActionIntentValidationResult>(
+			intentProjector.results,
+		);
+		const previews = collectData<WorkspaceProposalRepairSuccessorProposalIntakePreview>(
+			previewProjector.previews,
+		);
+		const preparations = collectData<
+			WorkspaceProposalRepairSuccessorProposalReadyRequestPreparationResult<{
+				readonly title: string;
+			}>
+		>(preparationProjector.results);
+		const readyRequests = collectData<WorkspaceProposalReadyRequest>(
+			preparationProjector.readyRequests,
+		);
+
+		requests.down([["DATA", fixture.request]]);
+		statuses.down([["DATA", status]]);
+		descriptors.down([["DATA", descriptor]]);
+		intents.down([["DATA", intent]]);
+		expect(validations).toHaveLength(1);
+		expect(previews).toHaveLength(1);
+		const preview = previews[0];
+		if (preview === undefined) throw new Error("expected D476 preview");
+		const input: WorkspaceProposalRepairSuccessorProposalReadyRequestPreparationInput<{
+			readonly title: string;
+		}> = {
+			kind: "workspace-proposal-repair-successor-proposal-ready-request-preparation-input",
+			preparationId: "successor-preparation:d476",
+			previewId: preview.previewId,
+			intent,
+			intentValidation,
+			descriptor,
+			request: fixture.request,
+			currentStatus: status,
+			successorProposalId: "successor-proposal:d476",
+			intakeRequestId: "successor-intake:d476",
+			successorIdempotencyKey: "successor-idempotency:d476",
+			workspaceId: "workspace:d476",
+			actorRef,
+			capabilityRefs: [capabilityRef],
+			policyRefs: [policyRef],
+			projectionBundleRefs: [projectionRef],
+			sourceRefs: [sourceRef],
+			audit: { auditId: "audit:d476", sourceRefs: [sourceRef] },
+			targetRefs: [{ kind: "work-item", id: "target:d476" }],
+			successorProposalFamily: fixture.request.proposalFamily,
+			successorLoweringKind: "work-item-spawn",
+			draft: { title: "prepared request bulk d476" },
+			finalDraftSourceRefs: [{ kind: "workspace-final-draft", id: "draft:d476" }],
+		};
+		preparationInputs.down([["DATA", input]]);
+		expect(preparations).toHaveLength(1);
+		expect(preparations[0]).toMatchObject({ status: "prepared" });
+		expect(readyRequests).toHaveLength(1);
+
+		releases.down([
+			[
+				"DATA",
+				projectionRelease(
+					"projection-release:d476-preparation",
+					"repair-successor-preparation",
+					input.preparationId,
+					{
+						preparationId: input.preparationId,
+						previewId: preview.previewId,
+						intentId: intent.intentId,
+						descriptorId: descriptor.descriptorId,
+						repairRequestId: fixture.request.repairRequestId,
+						actionKind: intent.actionKind,
+						applicationId: fixture.request.applicationId,
+						proposalId: fixture.request.proposalId,
+						decisionId: fixture.request.decisionId,
+						idempotencyKey: fixture.request.idempotencyKey,
+						proposalFamily: fixture.request.proposalFamily,
+					},
+				),
+			],
+			[
+				"DATA",
+				projectionRelease(
+					"projection-release:d476-preview",
+					"repair-successor-preview",
+					preview.previewId,
+					{
+						previewId: preview.previewId,
+						intentId: intent.intentId,
+						descriptorId: descriptor.descriptorId,
+						repairRequestId: fixture.request.repairRequestId,
+						actionKind: intent.actionKind,
+						applicationId: fixture.request.applicationId,
+						proposalId: fixture.request.proposalId,
+						decisionId: fixture.request.decisionId,
+						idempotencyKey: fixture.request.idempotencyKey,
+						proposalFamily: fixture.request.proposalFamily,
+					},
+				),
+			],
+			[
+				"DATA",
+				projectionRelease(
+					"projection-release:d476-intent",
+					"repair-action-intent",
+					intent.intentId,
+					{
+						intentId: intent.intentId,
+						descriptorId: descriptor.descriptorId,
+						repairRequestId: fixture.request.repairRequestId,
+						actionKind: intent.actionKind,
+						applicationId: fixture.request.applicationId,
+						proposalId: fixture.request.proposalId,
+						decisionId: fixture.request.decisionId,
+						idempotencyKey: fixture.request.idempotencyKey,
+						proposalFamily: fixture.request.proposalFamily,
+					},
+				),
+			],
+		]);
+		expect(releaseFacts.map((entry) => entry.targetKind)).toEqual([
+			"repair-successor-preparation",
+			"repair-successor-preview",
+			"repair-action-intent",
+		]);
+		expect(readyRequests).toHaveLength(1);
+
+		requests.down([["DATA", structuredClone(fixture.request)]]);
+		statuses.down([["DATA", structuredClone(status)]]);
+		descriptors.down([["DATA", structuredClone(descriptor)]]);
+		expect(previews).toHaveLength(1);
+		expect(validations).toHaveLength(1);
+
+		intents.down([["DATA", structuredClone(intent)]]);
+		expect(validations).toHaveLength(2);
+		expect(previews).toHaveLength(2);
+		preparationInputs.down([["DATA", structuredClone(input)]]);
+		expect(preparations).toHaveLength(2);
+		expect(preparations.at(-1)).toMatchObject({ status: "prepared", issues: [] });
+		expect(preparations.at(-1)).not.toHaveProperty("readyRequest");
+		expect(readyRequests).toHaveLength(1);
+
+		preparationInputs.down([
+			[
+				"DATA",
+				{
+					...input,
+					successorProposalId: "successor-proposal:d476-different",
+					draft: { title: "different after release" },
+				},
+			],
+		]);
+		expect(preparations.at(-1)).toMatchObject({
+			status: "blocked",
+			issues: expect.arrayContaining([
+				expect.objectContaining({ code: "repair-successor-preparation-already-prepared" }),
+			]),
+		});
+		expect(readyRequests).toHaveLength(1);
+		expect(JSON.stringify({ releaseFacts, preparations })).not.toMatch(
+			/\b(pruned|missed|not-retained|not retained|revoked|deleted|evicted)\b/i,
+		);
+	});
+
+	it("projects D473 release diagnostics separately from release-consuming projectors", () => {
+		const release: WorkspaceProposalProjectionRelease = {
+			kind: "workspace-proposal-projection-release",
+			releaseId: "projection-release:d473-valid",
+			targetKind: "family-read-model-query",
+			targetId: "view:d473",
+			viewId: "view:d473",
+			queryId: "query:d473",
+			sourceRefs: [{ kind: "workspace-projection-release", id: "source:d473" }],
+		};
+
+		const accepted = validateWorkspaceProposalProjectionReleaseMaterial(release);
+		expect(accepted).toMatchObject({
+			kind: "workspace-proposal-projection-release-validation-result",
+			status: "accepted",
+			release,
+			issues: [],
+		});
+		expect(accepted.release).not.toBe(release);
+		expect(accepted.release?.sourceRefs).not.toBe(release.sourceRefs);
+		expect(Object.isFrozen(accepted.release)).toBe(true);
+		expect(Object.isFrozen(accepted.release?.sourceRefs)).toBe(true);
+
+		const blocked = validateWorkspaceProposalProjectionReleaseMaterial({
+			...release,
+			releaseId: "projection-release:d473-blocked",
+			storageOwner: "runtime-private-secret",
+		});
+		expect(blocked).toMatchObject({
+			status: "blocked",
+			releaseId: "projection-release:d473-blocked",
+			targetKind: "family-read-model-query",
+			targetId: "view:d473",
+			issues: expect.arrayContaining([
+				expect.objectContaining({ code: "forbidden-projection-release-material" }),
+			]),
+		});
+		expect(blocked).not.toHaveProperty("release");
+		expect(JSON.stringify(blocked)).not.toContain("runtime-private-secret");
+		for (const forbiddenAuthorityKey of [
+			"record",
+			"decision",
+			"applicationStatus",
+			"readyRequest",
+			"policyProof",
+			"permissionProof",
+			"storageOwner",
+			"providerCursor",
+			"runtimeHandle",
+		]) {
+			expect(Object.hasOwn(release, forbiddenAuthorityKey)).toBe(false);
+		}
+
+		const g = graph();
+		const releases = g.node<unknown>([], null, { name: "d473ReleaseDiagnosticsInput" });
+		const bundle = workspaceProposalProjectionReleaseDiagnosticProjector(g, { releases });
+		const diagnostics = collectData<WorkspaceProposalProjectionReleaseDiagnostic>(
+			bundle.diagnostics,
+		);
+
+		releases.down([["DATA", release]]);
+		expect(diagnostics).toHaveLength(0);
+
+		releases.down([
+			[
+				"DATA",
+				{
+					...release,
+					releaseId: "projection-release:d473-blocked",
+					storageOwner: "runtime-private-secret",
+				},
+			],
+		]);
+		expect(diagnostics).toHaveLength(1);
+		expect(diagnostics[0]).toMatchObject({
+			kind: "workspace-proposal-projection-release-diagnostic",
+			releaseId: "projection-release:d473-blocked",
+			targetKind: "family-read-model-query",
+			targetId: "view:d473",
+			status: "blocked",
+			issues: expect.arrayContaining([
+				expect.objectContaining({ code: "forbidden-projection-release-material" }),
+			]),
+		});
+		expect(JSON.stringify(diagnostics)).not.toContain("runtime-private-secret");
+
+		releases.down([
+			[
+				"DATA",
+				{
+					...release,
+					releaseId: "projection-release:d473-unsafe-audit",
+					audit: {
+						auditId: "audit:d473-unsafe",
+						sourceRefs: [{ kind: "workspace-projection-release", id: "audit-source:d473" }],
+						metadata: { storageOwner: "hidden-cache-owner" },
+					},
+				},
+			],
+		]);
+		expect(diagnostics).toHaveLength(2);
+		expect(diagnostics[1]).toMatchObject({
+			releaseId: "projection-release:d473-unsafe-audit",
+			status: "blocked",
+			issues: expect.arrayContaining([
+				expect.objectContaining({ code: "forbidden-projection-release-vocabulary" }),
+			]),
+		});
+		expect(diagnostics[1]?.audit?.metadata).toBeUndefined();
+		expect(JSON.stringify(diagnostics)).not.toContain("hidden-cache-owner");
+
+		releases.down([
+			[
+				"DATA",
+				{
+					...release,
+					releaseId: "projection-release:d473-blocked",
+					storageOwner: "runtime-private-secret",
+				},
+			],
+		]);
+		expect(diagnostics).toHaveLength(3);
+	});
+
+	it("diagnoses malformed D473 releases for every closed D472 target kind", () => {
+		const base = {
+			kind: "workspace-proposal-projection-release",
+			releaseId: "projection-release:d473-target",
+			sourceRefs: [{ kind: "workspace-projection-release", id: "source:d473-target" }],
+		} as const;
+		const releases: readonly WorkspaceProposalProjectionRelease[] = [
+			{
+				...base,
+				releaseId: "projection-release:d473-read-model",
+				targetKind: "family-read-model-query",
+				targetId: "view:d473-read-model",
+				viewId: "view:d473-read-model",
+			},
+			{
+				...base,
+				releaseId: "projection-release:d473-supply",
+				targetKind: "outcome-detail-supply-request",
+				targetId: "view:d473-supply",
+				viewId: "view:d473-supply",
+			},
+			{
+				...base,
+				releaseId: "projection-release:d473-advisory",
+				targetKind: "repair-action-advisory",
+				targetId: "descriptor:d473",
+				descriptorId: "descriptor:d473",
+			},
+			{
+				...base,
+				releaseId: "projection-release:d473-intent",
+				targetKind: "repair-action-intent",
+				targetId: "intent:d473",
+				intentId: "intent:d473",
+			},
+			{
+				...base,
+				releaseId: "projection-release:d473-preview",
+				targetKind: "repair-successor-preview",
+				targetId: "preview:d473",
+				intentId: "intent:d473",
+				previewId: "preview:d473",
+			},
+			{
+				...base,
+				releaseId: "projection-release:d473-preparation",
+				targetKind: "repair-successor-preparation",
+				targetId: "preparation:d473",
+				preparationId: "preparation:d473",
+			},
+		];
+		for (const release of releases) {
+			expect(isWorkspaceProposalProjectionReleaseMaterial(release)).toBe(true);
+			const blocked = validateWorkspaceProposalProjectionReleaseMaterial({
+				...release,
+				providerCursor: "opaque-provider-cursor",
+			});
+			expect(blocked).toMatchObject({
+				status: "blocked",
+				releaseId: release.releaseId,
+				targetKind: release.targetKind,
+				targetId: release.targetId,
+				issues: expect.arrayContaining([
+					expect.objectContaining({ code: "forbidden-projection-release-material" }),
+				]),
+			});
+			expect(blocked).not.toHaveProperty("release");
+			expect(JSON.stringify(blocked)).not.toContain("opaque-provider-cursor");
+		}
+	});
+
+	it("uses D472 read-model releases to prune query current-view material only", () => {
+		const fixture = repairReviewFixture();
+		const coordinates = repairReviewReadModelCoordinates(fixture.request);
+		const repairStatus = projectWorkspaceProposalRepairReviewStatuses({
+			requests: [fixture.request],
+			outcomeStatuses: [fixture.outcomeStatus],
+		})[0];
+		if (repairStatus === undefined) throw new Error("expected D472 release repair status");
+		const g = graph();
+		const queries = g.node<WorkspaceProposalFamilyApplicationReadModelQuery>([], null, {
+			name: "d472ReadModelQueries",
+		});
+		const repairStatuses = g.node<typeof repairStatus>([], null, {
+			name: "d472ReadModelRepairStatuses",
+		});
+		const outcomeIndex = g.node<
+			ReturnType<typeof projectWorkspaceProposalFamilyOutcomeIndex>[number]
+		>([], null, { name: "d472ReadModelOutcomeIndex" });
+		const outcomeStatuses = g.node<typeof fixture.outcomeStatus>([], null, {
+			name: "d472ReadModelOutcomeStatuses",
+		});
+		const outcomes = g.node<typeof fixture.outcome>([], null, { name: "d472ReadModelOutcomes" });
+		const releases = g.node<WorkspaceProposalProjectionRelease>([], null, {
+			name: "d472ReadModelReleases",
+		});
+		const projector = workspaceProposalFamilyApplicationReadModelsProjector(g, {
+			queries,
+			repairReviewStatuses: repairStatuses,
+			outcomeIndex,
+			outcomeStatuses,
+			outcomes,
+			releases,
+		});
+		const readModels = collectData(projector.readModels);
+		const query = readModelQuery("query-d472-release", coordinates, { page: { limit: 1 } });
+
+		repairStatuses.down([["DATA", repairStatus]]);
+		outcomeIndex.down([["DATA", fixture.outcomeIndex[0]!]]);
+		outcomeStatuses.down([["DATA", fixture.outcomeStatus]]);
+		outcomes.down([["DATA", fixture.outcome]]);
+		queries.down([["DATA", query]]);
+		queries.down([["DATA", structuredClone(query)]]);
+		expect(readModels).toHaveLength(1);
+
+		expect(() =>
+			releases.down([
+				[
+					"DATA",
+					{
+						kind: "workspace-proposal-projection-release",
+						releaseId: "projection-release:d472-read-model-bad",
+						targetKind: "family-read-model-query",
+						targetId: query.viewId,
+						sourceRefs: [{ kind: "provider", id: "runtime-private" }],
+					} as never,
+				],
+			]),
+		).not.toThrow();
+		queries.down([["DATA", structuredClone(query)]]);
+		expect(readModels).toHaveLength(1);
+		releases.down([
+			[
+				"DATA",
+				projectionRelease(
+					"projection-release:d472-read-model-unknown-target",
+					"family-read-model-query",
+					"view:unknown",
+					{
+						queryId: "query:unknown",
+						viewId: "view:unknown",
+						...coordinates,
+					},
+				),
+			],
+		]);
+		queries.down([["DATA", structuredClone(query)]]);
+		expect(readModels).toHaveLength(1);
+
+		for (const mismatch of [
+			{ applicationId: "other-application" },
+			{ proposalId: "other-proposal" },
+			{ decisionId: "other-decision" },
+			{ idempotencyKey: "other-idempotency" },
+			{ proposalFamily: "work-item-spawn" as const },
+		]) {
+			releases.down([
+				[
+					"DATA",
+					projectionRelease(
+						`projection-release:d472-read-model-coordinate-mismatch:${Object.keys(mismatch)[0]}`,
+						"family-read-model-query",
+						query.viewId,
+						{
+							queryId: query.queryId,
+							viewId: query.viewId,
+							...mismatch,
+						},
+					),
+				],
+			]);
+			queries.down([["DATA", structuredClone(query)]]);
+			expect(readModels).toHaveLength(1);
+		}
+
+		releases.down([
+			[
+				"DATA",
+				projectionRelease(
+					"projection-release:d472-read-model",
+					"family-read-model-query",
+					query.viewId,
+					{
+						queryId: query.queryId,
+						viewId: query.viewId,
+					},
+				),
+			],
+		]);
+		expect(readModels).toHaveLength(1);
+		queries.down([["DATA", structuredClone(query)]]);
+
+		expect(readModels).toHaveLength(2);
+		expect(readModels.map((entry) => entry.queryId)).toEqual([
+			"query-d472-release",
+			"query-d472-release",
+		]);
+		expect(readModels.at(-1)).toMatchObject({
+			page: { offset: 0, limit: 1 },
+			outcomeIndexes: [
+				expect.objectContaining({
+					outcomeRefs: [expect.objectContaining({ outcomeId: fixture.outcome.outcomeId })],
+				}),
+			],
+		});
+		queries.down([
+			[
+				"DATA",
+				readModelQuery("query-d472-release", coordinates, { page: { offset: 1, limit: 1 } }),
+			],
+		]);
+		expect(readModels).toHaveLength(3);
+		expect(readModels.at(-1)).toMatchObject({
+			queryId: "query-d472-release",
+			page: { offset: 1, limit: 1 },
+			outcomeIndexes: [
+				expect.objectContaining({
+					outcomeRefs: [expect.objectContaining({ outcomeId: fixture.outcome.outcomeId })],
+				}),
+			],
+		});
+		expect(JSON.stringify(readModels)).not.toMatch(/runtime-private|storage|provider/i);
+	});
+
+	it("uses D472 supply releases without deleting supplied outcome facts", () => {
+		const fixture = repairReviewFixture();
+		const coordinates = repairReviewReadModelCoordinates(fixture.request);
+		const ref = fixture.outcomeIndex[0]?.outcomeRefs[0];
+		if (ref === undefined) throw new Error("expected D472 supply ref");
+		const secondOutcome = recordWorkspaceProposalWorkItemLinkOutcome(fixture.appliedStatus, {
+			outcomeId: "repair-review-outcome-d472-supply-2",
+			linkRef: { kind: "work-item-link", id: "link:d472-supply-2" },
+		}).outcome;
+		if (secondOutcome === undefined) throw new Error("expected D472 supply second outcome");
+		const secondRef = projectWorkspaceProposalFamilyOutcomeIndex([secondOutcome])[0]
+			?.outcomeRefs[0];
+		if (secondRef === undefined) throw new Error("expected D472 supply second ref");
+		const request: WorkspaceProposalFamilyOutcomeDetailSupplyRequest = {
+			kind: "workspace-proposal-family-outcome-detail-supply-request",
+			supplyRequestId: "supply:d472-release",
+			viewId: "view:d472-supply",
+			...coordinates,
+			requestedOutcomeRefs: [ref, secondRef],
+			page: { offset: 0, limit: 1 },
+			sourceRefs: [sourceRef],
+		};
+		const secondPageRequest: WorkspaceProposalFamilyOutcomeDetailSupplyRequest = {
+			...request,
+			page: { offset: 1, limit: 1 },
+		};
+		const g = graph();
+		const requests = g.node<WorkspaceProposalFamilyOutcomeDetailSupplyRequest>([], null, {
+			name: "d472SupplyRequests",
+		});
+		const outcomes = g.node<typeof fixture.outcome>([], null, { name: "d472SupplyOutcomes" });
+		const releases = g.node<WorkspaceProposalProjectionRelease>([], null, {
+			name: "d472SupplyReleases",
+		});
+		const projector = workspaceProposalFamilyOutcomeDetailSupplyProjector(g, {
+			requests,
+			suppliedOutcomes: outcomes,
+			releases,
+		});
+		const results = collectData<WorkspaceProposalFamilyOutcomeDetailSupplyResult>(
+			projector.results,
+		);
+
+		requests.down([["DATA", request]]);
+		outcomes.down([["DATA", fixture.outcome]]);
+		outcomes.down([["DATA", secondOutcome]]);
+		requests.down([["DATA", structuredClone(request)]]);
+		expect(results).toHaveLength(2);
+		expect(results.at(-1)).toMatchObject({
+			currentViewId: "view:d472-supply",
+			suppliedOutcomeFacts: [expect.objectContaining({ outcomeId: ref.outcomeId })],
+			page: { offset: 0, limit: 1 },
+		});
+		releases.down([
+			[
+				"DATA",
+				projectionRelease(
+					"projection-release:d472-supply-unknown-target",
+					"outcome-detail-supply-request",
+					"view:unknown",
+					{
+						supplyRequestId: "supply:unknown",
+						viewId: "view:unknown",
+						...coordinates,
+					},
+				),
+			],
+		]);
+		requests.down([["DATA", structuredClone(request)]]);
+		expect(results).toHaveLength(2);
+
+		for (const mismatch of [
+			{ applicationId: "other-application" },
+			{ proposalId: "other-proposal" },
+			{ decisionId: "other-decision" },
+			{ idempotencyKey: "other-idempotency" },
+			{ proposalFamily: "work-item-spawn" as const },
+		]) {
+			releases.down([
+				[
+					"DATA",
+					projectionRelease(
+						`projection-release:d472-supply-coordinate-mismatch:${Object.keys(mismatch)[0]}`,
+						"outcome-detail-supply-request",
+						request.viewId,
+						{
+							supplyRequestId: request.supplyRequestId,
+							viewId: request.viewId,
+							...mismatch,
+						},
+					),
+				],
+			]);
+			requests.down([["DATA", structuredClone(request)]]);
+			expect(results).toHaveLength(2);
+		}
+
+		releases.down([
+			[
+				"DATA",
+				projectionRelease(
+					"projection-release:d472-supply",
+					"outcome-detail-supply-request",
+					request.viewId,
+					{ supplyRequestId: request.supplyRequestId, viewId: request.viewId },
+				),
+			],
+		]);
+		requests.down([["DATA", secondPageRequest]]);
+
+		expect(results).toHaveLength(3);
+		expect(results.at(-1)).toMatchObject({
+			suppliedOutcomeFacts: [expect.objectContaining({ outcomeId: secondOutcome.outcomeId })],
+			displayDiagnostics: [],
+			page: { offset: 1, limit: 1 },
+		});
+		expect(results.at(-1)?.suppliedOutcomeFacts).not.toEqual(
+			expect.arrayContaining([expect.objectContaining({ outcomeId: fixture.outcome.outcomeId })]),
+		);
+		requests.down([["DATA", { ...secondPageRequest, page: { offset: 0, limit: 2 } }]]);
+		expect(results).toHaveLength(4);
+		expect(results.at(-1)).toMatchObject({
+			suppliedOutcomeFacts: [
+				expect.objectContaining({ outcomeId: fixture.outcome.outcomeId }),
+				expect.objectContaining({ outcomeId: secondOutcome.outcomeId }),
+			],
+			displayDiagnostics: [],
+			page: { offset: 0, limit: 2 },
+		});
+		expect(JSON.stringify(results)).not.toMatch(/cursor|storage|provider|runtime/i);
+	});
+
+	it("uses D472 repair action releases without policy authority or truth mutation", () => {
+		const fixture = repairReviewFixture();
+		const status = projectWorkspaceProposalRepairReviewStatuses({ requests: [fixture.request] })[0];
+		if (status === undefined) throw new Error("expected D472 repair status");
+		const descriptor = projectWorkspaceProposalRepairActionDescriptors({
+			requests: [fixture.request],
+			statuses: [status],
+		}).find((entry) => entry.actionKind === "open-successor-proposal-flow");
+		if (descriptor === undefined) throw new Error("expected D472 descriptor");
+		const intent = repairActionIntent(fixture.request, descriptor, {
+			actionKind: "open-successor-proposal-flow",
+		});
+		const g = graph();
+		const descriptors = g.node<WorkspaceProposalRepairActionDescriptor>([], null, {
+			name: "d472Descriptors",
+		});
+		const requests = g.node<WorkspaceProposalRepairReviewRequest>([], null, {
+			name: "d472RepairRequests",
+		});
+		const intents = g.node<WorkspaceProposalRepairActionIntent>([], null, {
+			name: "d472Intents",
+		});
+		const statuses = g.node<typeof status>([], null, { name: "d472Statuses" });
+		const releases = g.node<WorkspaceProposalProjectionRelease>([], null, {
+			name: "d472RepairReleases",
+		});
+		const advisoryProjector = workspaceProposalRepairActionDisplayPolicyAdvisoryProjector(g, {
+			descriptors,
+			requests,
+			releases,
+			displayAssessment: "no-known-blocker",
+			sourceRefs: [sourceRef],
+		});
+		const intentProjector = workspaceProposalRepairActionIntentProjector(g, {
+			intents,
+			descriptors,
+			requests,
+			statuses,
+			releases,
+			capabilityRefs: intent.capabilityRefs,
+			policyRefs: intent.policyRefs,
+			policyStatus: "allowed",
+		});
+		const previewProjector = workspaceProposalRepairSuccessorProposalIntakePreviewProjector(g, {
+			intents,
+			descriptors,
+			requests,
+			statuses,
+			releases,
+			capabilityRefs: intent.capabilityRefs,
+			policyRefs: intent.policyRefs,
+			policyStatus: "allowed",
+		});
+		const advisories = collectData<WorkspaceProposalRepairActionDisplayPolicyAdvisory>(
+			advisoryProjector.advisories,
+		);
+		const validations = collectData<WorkspaceProposalRepairActionIntentValidationResult>(
+			intentProjector.results,
+		);
+		const previews = collectData<WorkspaceProposalRepairSuccessorProposalIntakePreview>(
+			previewProjector.previews,
+		);
+
+		requests.down([["DATA", fixture.request]]);
+		statuses.down([["DATA", status]]);
+		descriptors.down([["DATA", descriptor]]);
+		intents.down([["DATA", intent]]);
+		expect(advisories).toHaveLength(1);
+		expect(validations).toHaveLength(1);
+		expect(previews).toHaveLength(1);
+
+		releases.down([
+			[
+				"DATA",
+				projectionRelease(
+					"projection-release:d472-advisory",
+					"repair-action-advisory",
+					descriptor.descriptorId,
+					{
+						descriptorId: descriptor.descriptorId,
+						repairRequestId: descriptor.repairRequestId,
+						actionKind: descriptor.actionKind,
+					},
+				),
+			],
+			[
+				"DATA",
+				projectionRelease(
+					"projection-release:d472-intent",
+					"repair-action-intent",
+					intent.intentId,
+					{
+						intentId: intent.intentId,
+					},
+				),
+			],
+			[
+				"DATA",
+				projectionRelease(
+					"projection-release:d472-preview",
+					"repair-successor-preview",
+					previews[0]!.previewId,
+					{ intentId: intent.intentId, previewId: previews[0]!.previewId },
+				),
+			],
+		]);
+		descriptors.down([["DATA", structuredClone(descriptor)]]);
+		intents.down([["DATA", structuredClone(intent)]]);
+
+		expect(advisories).toHaveLength(2);
+		expect(validations).toHaveLength(2);
+		expect(previews).toHaveLength(2);
+		expect(
+			validateWorkspaceProposalRepairActionIntent(intent, {
+				descriptor,
+				request: fixture.request,
+				currentStatus: status,
+				policyStatus: "allowed",
+			}),
+		).toMatchObject({
+			status: "blocked",
+			issues: expect.arrayContaining([
+				expect.objectContaining({ code: "missing-repair-action-policy-material" }),
+			]),
+		});
+	});
+
+	it("projects D449 repair action descriptors as non-executable affordances", () => {
+		const fixture = repairReviewFixture();
+		const open = projectWorkspaceProposalRepairReviewStatuses({ requests: [fixture.request] })[0];
+		const acknowledged = projectWorkspaceProposalRepairReviewStatuses({
+			requests: [fixture.request],
+			decisions: [repairReviewDecision(fixture.request, "acknowledged", "review-ack-d449")],
+		})[0];
+		const resolved = projectWorkspaceProposalRepairReviewStatuses({
+			requests: [fixture.request],
+			decisions: [repairReviewDecision(fixture.request, "resolved", "review-resolved-d449")],
+		})[0];
+		const withdrawn = projectWorkspaceProposalRepairReviewStatuses({
+			requests: [fixture.request],
+			decisions: [repairReviewDecision(fixture.request, "withdrawn", "review-withdrawn-d449")],
+		})[0];
+		const superseded = projectWorkspaceProposalRepairReviewStatuses({
+			requests: [fixture.request],
+			decisions: [repairReviewDecision(fixture.request, "superseded", "review-superseded-d449")],
+		})[0];
+		const conflict = projectWorkspaceProposalRepairReviewStatuses({
+			requests: [fixture.request],
+			decisions: [
+				repairReviewDecision(fixture.request, "resolved", "review-conflict-resolved"),
+				repairReviewDecision(fixture.request, "withdrawn", "review-conflict-withdrawn"),
+			],
+		})[0];
+
+		for (const status of [open, acknowledged, conflict, resolved, withdrawn, superseded]) {
+			if (status === undefined) throw new Error("expected D449 status fixture");
+			const descriptors = projectWorkspaceProposalRepairActionDescriptors({
+				requests: [fixture.request],
+				statuses: [status],
+			});
+			expect(descriptors.map((entry) => entry.actionKind).sort()).toEqual([
+				"acknowledge-review",
+				"mark-human-resolved",
+				"open-successor-proposal-flow",
+				"supersede-review",
+				"withdraw-review",
+			]);
+			for (const descriptor of descriptors) {
+				expect(descriptor).toMatchObject({
+					kind: "workspace-proposal-repair-action-descriptor",
+					repairRequestId: fixture.request.repairRequestId,
+					repairState: status.state,
+					applicationId: fixture.request.applicationId,
+					proposalId: fixture.request.proposalId,
+					decisionId: fixture.request.decisionId,
+					idempotencyKey: fixture.request.idempotencyKey,
+					proposalFamily: fixture.request.proposalFamily,
+				});
+				expectForbiddenDescriptorKeys(descriptor);
+			}
+		}
+
+		const acknowledgedDescriptors = projectWorkspaceProposalRepairActionDescriptors({
+			requests: [fixture.request],
+			statuses: [acknowledged!],
+		});
+		expect(
+			acknowledgedDescriptors.find((entry) => entry.actionKind === "acknowledge-review"),
+		).toMatchObject({
+			enabled: false,
+			disabledCode: "repair-review-already-acknowledged",
+		});
+		expect(
+			acknowledgedDescriptors.find((entry) => entry.actionKind === "withdraw-review"),
+		).toMatchObject({ enabled: true });
+		for (const terminal of [resolved!, withdrawn!, superseded!]) {
+			expect(
+				projectWorkspaceProposalRepairActionDescriptors({
+					requests: [fixture.request],
+					statuses: [terminal],
+				}).every(
+					(descriptor) =>
+						descriptor.enabled === false && descriptor.disabledCode === "repair-review-terminal",
+				),
+			).toBe(true);
+		}
+		expect(
+			projectWorkspaceProposalRepairActionDescriptors({
+				requests: [fixture.request],
+				statuses: [conflict!],
+			}).every(
+				(descriptor) =>
+					descriptor.enabled === false && descriptor.disabledCode === "repair-review-conflict",
+			),
+		).toBe(true);
+		const mismatchedStatus = { ...resolved!, proposalId: "other-proposal" };
+		expect(
+			projectWorkspaceProposalRepairActionDescriptors({
+				requests: [fixture.request],
+				statuses: [mismatchedStatus],
+			}).every((descriptor) => descriptor.repairState === "open" && descriptor.enabled),
+		).toBe(true);
+		expect(
+			projectWorkspaceProposalRepairActionDescriptors({
+				requests: [fixture.request],
+				statuses: [resolved!, mismatchedStatus],
+			}).every(
+				(descriptor) =>
+					descriptor.repairState === "resolved" &&
+					descriptor.enabled === false &&
+					descriptor.disabledCode === "repair-review-terminal",
+			),
+		).toBe(true);
+		const toxicRequest = {
+			...fixture.request,
+			sourceRefs: [
+				sourceRef,
+				{ kind: "source", id: "bad-request-ref", metadata: { providerClient: "x" } },
+			],
+			audit: {
+				auditId: "audit:d449-toxic-request",
+				sourceRefs: [{ kind: "source", id: "bad-audit-ref", metadata: { callback: "x" } }],
+				metadata: { callback: "x" },
+			},
+		};
+		const toxicStatus = {
+			...acknowledged!,
+			sourceRefs: [
+				{ kind: "manual-review", id: "safe-status-ref" },
+				{ kind: "source", id: "bad-status-ref", metadata: { runtimeHandle: "x" } },
+			],
+			audit: {
+				auditId: "audit:d449-toxic-status",
+				sourceRefs: [{ kind: "manual-review", id: "safe-status-audit-ref" }],
+				metadata: { providerClient: "x" },
+			},
+		};
+		const toxicDescriptor = projectWorkspaceProposalRepairActionDescriptors({
+			requests: [toxicRequest],
+			statuses: [toxicStatus],
+		})[0];
+		expect(toxicDescriptor).toMatchObject({
+			sourceRefs: expect.arrayContaining([
+				sourceRef,
+				{ kind: "manual-review", id: "safe-status-ref" },
+				{ kind: "workspace-proposal-repair-review-status", id: fixture.request.repairRequestId },
+			]),
+		});
+		expect(toxicDescriptor?.audit).toBeUndefined();
+		expectForbiddenDescriptorKeys(toxicDescriptor);
+
+		const reviewDescriptor = acknowledgedDescriptors.find(
+			(entry) => entry.actionKind === "mark-human-resolved",
+		);
+		if (reviewDescriptor === undefined) throw new Error("expected D449 review descriptor");
+		const recorded = recordWorkspaceProposalRepairReviewDecision(fixture.request, {
+			reviewDecisionId: "review-from-descriptor",
+			intent: "resolved",
+			reviewerRef: { kind: "actor", id: "reviewer:d449" },
+			policyRefs: [{ kind: "policy", id: "repair-review:policy" }],
+			sourceRefs: reviewDescriptor.sourceRefs,
+			audit: {
+				auditId: "audit:review-from-descriptor",
+				actorId: "actor:d449",
+				sourceRefs: reviewDescriptor.sourceRefs,
+			},
+			code: "resolved-from-review-descriptor",
+			metadata: reviewDescriptor.metadata,
+		});
+		expect(recorded.status).toBe("recorded");
+		expect(recorded.decision).toMatchObject({
+			reviewDecisionId: "review-from-descriptor",
+			repairRequestId: fixture.request.repairRequestId,
+			intent: "resolved",
+			sourceRefs: expect.arrayContaining(reviewDescriptor.sourceRefs),
+			metadata: reviewDescriptor.metadata,
+		});
+	});
+
+	it("exposes graph-visible D449 repair action descriptors without mutation payloads", () => {
+		const g = graph();
+		const requests = g.node<WorkspaceProposalRepairReviewRequest>([], null, { name: "requests" });
+		const statuses = g.node<
+			ReturnType<typeof projectWorkspaceProposalRepairReviewStatuses>[number]
+		>([], null, { name: "statuses" });
+		const projector = workspaceProposalRepairActionDescriptorProjector(g, {
+			requests,
+			statuses,
+		});
+		const descriptors = collectData<WorkspaceProposalRepairActionDescriptor>(projector.descriptors);
+		const fixture = repairReviewFixture();
+		const resolved = projectWorkspaceProposalRepairReviewStatuses({
+			requests: [fixture.request],
+			outcomeStatuses: [fixture.outcomeStatus],
+		})[0];
+		if (resolved === undefined) throw new Error("expected D449 resolved status");
+
+		requests.down([["DATA", fixture.request]]);
+		statuses.down([["DATA", resolved]]);
+		statuses.down([["DATA", { ...resolved, proposalId: "other-proposal" }]]);
+
+		expect(descriptors).toHaveLength(10);
+		expect(descriptors.slice(0, 5).every((descriptor) => descriptor.repairState === "open")).toBe(
+			true,
+		);
+		expect(
+			descriptors
+				.slice(5)
+				.every(
+					(descriptor) =>
+						descriptor.repairState === "resolved" &&
+						descriptor.enabled === false &&
+						descriptor.disabledCode === "repair-review-terminal",
+				),
+		).toBe(true);
+		for (const descriptor of descriptors) expectForbiddenDescriptorKeys(descriptor);
+	});
+});
+
+function requiredInputProjectorHarness() {
+	const g = graph();
+	const records = g.node<WorkspaceProposalRecorded<RequiredInputResponseProposed<string>>>(
+		[],
+		null,
+		{
+			name: "records",
+		},
+	);
+	const decisions = g.node<WorkspaceProposalAdmissionDecision>([], null, { name: "decisions" });
+	const contexts = g.node<WorkspaceProposalRequiredInputResponseApplicationContext>([], null, {
+		name: "contexts",
+	});
+	const gates = g.node<RequiredInputGate>([], null, { name: "gates" });
+	const bundle = workspaceProposalRequiredInputResponseApplicationProjector(g, {
+		records,
+		decisions,
+		contexts,
+		gates,
+	});
+	const diagnostics = workspaceProposalFamilyApplicationDiagnosticProjector(g, {
+		issues: bundle.issues,
+		audit: bundle.audit,
+		applicationStatuses: bundle.status,
+	});
+	const repair = workspaceProposalRepairReviewProjector(g, {
+		applicationStatuses: bundle.status,
+	});
+	return {
+		records,
+		decisions,
+		contexts,
+		gates,
+		status: collectData(bundle.status),
+		recorded: collectData(bundle.recorded),
+		issues: collectData(bundle.issues),
+		audit: collectData(bundle.audit),
+		diagnostics: collectData(diagnostics.diagnostics),
+		repairRequests: collectData(repair.requests),
+		familyTruth: collectData(bundle.applied),
+	};
+}
+
+function spawnProjectorHarness() {
+	const g = graph();
+	const records = g.node<WorkspaceProposalRecorded<WorkItemSpawnProposed>>([], null, {
+		name: "records",
+	});
+	const decisions = g.node<WorkspaceProposalAdmissionDecision>([], null, { name: "decisions" });
+	const contexts = g.node<WorkspaceProposalWorkItemSpawnApplicationContext>([], null, {
+		name: "contexts",
+	});
+	const bundle = workspaceProposalWorkItemSpawnApplicationProjector(g, {
+		records,
+		decisions,
+		contexts,
+	});
+	const diagnostics = workspaceProposalFamilyApplicationDiagnosticProjector(g, {
+		issues: bundle.issues,
+		audit: bundle.audit,
+		applicationStatuses: bundle.status,
+	});
+	const repair = workspaceProposalRepairReviewProjector(g, {
+		applicationStatuses: bundle.status,
+	});
+	const familyTruth = collectDataFromNodes(bundle.created, bundle.linked);
+	return {
+		records,
+		decisions,
+		contexts,
+		status: collectData(bundle.status),
+		recorded: collectData(bundle.recorded),
+		issues: collectData(bundle.issues),
+		audit: collectData(bundle.audit),
+		diagnostics: collectData(diagnostics.diagnostics),
+		repairRequests: collectData(repair.requests),
+		familyTruth,
+	};
+}
+
+function linkProjectorHarness() {
+	const g = graph();
+	const records = g.node<WorkspaceProposalRecorded<ReturnType<typeof linkDraft>>>([], null, {
+		name: "records",
+	});
+	const decisions = g.node<WorkspaceProposalAdmissionDecision>([], null, { name: "decisions" });
+	const contexts = g.node<WorkspaceProposalWorkItemLinkApplicationContext>([], null, {
+		name: "contexts",
+	});
+	const bundle = workspaceProposalWorkItemLinkApplicationProjector(g, {
+		records,
+		decisions,
+		contexts,
+	});
+	const diagnostics = workspaceProposalFamilyApplicationDiagnosticProjector(g, {
+		issues: bundle.issues,
+		audit: bundle.audit,
+		applicationStatuses: bundle.status,
+	});
+	const repair = workspaceProposalRepairReviewProjector(g, {
+		applicationStatuses: bundle.status,
+	});
+	const familyTruth = collectDataFromNodes(bundle.linked, bundle.unlinked);
+	return {
+		records,
+		decisions,
+		contexts,
+		status: collectData(bundle.status),
+		recorded: collectData(bundle.recorded),
+		issues: collectData(bundle.issues),
+		audit: collectData(bundle.audit),
+		diagnostics: collectData(diagnostics.diagnostics),
+		repairRequests: collectData(repair.requests),
+		familyTruth,
+	};
+}
+
+function domainActionProjectorHarness() {
+	const g = graph();
+	const records = g.node<WorkspaceProposalRecorded>([], null, { name: "records" });
+	const decisions = g.node<WorkspaceProposalAdmissionDecision>([], null, { name: "decisions" });
+	const contexts = g.node<WorkspaceProposalDomainActionApplicationContext>([], null, {
+		name: "contexts",
+	});
+	const emittedFacts = g.node<WorkItemAuthoringFact>([], null, { name: "domainFacts" });
+	const bundle = workspaceProposalDomainActionApplicationProjector(g, {
+		records,
+		decisions,
+		contexts,
+		emittedFacts,
+	});
+	const diagnostics = workspaceProposalFamilyApplicationDiagnosticProjector(g, {
+		issues: bundle.issues,
+		audit: bundle.audit,
+		applicationStatuses: bundle.status,
+	});
+	const repair = workspaceProposalRepairReviewProjector(g, {
+		applicationStatuses: bundle.status,
+	});
+	return {
+		records,
+		decisions,
+		contexts,
+		emittedFacts,
+		status: collectData(bundle.status),
+		recorded: collectData(bundle.recorded),
+		issues: collectData(bundle.issues),
+		audit: collectData(bundle.audit),
+		diagnostics: collectData(diagnostics.diagnostics),
+		repairRequests: collectData(repair.requests),
+		familyTruth: [] as unknown[],
+	};
+}
+
+function proposalRecord<TDraft>(
+	family: WorkspaceProposalFamily,
+	draft: TDraft,
+): WorkspaceProposalRecorded<TDraft> {
+	const result = recordWorkspaceProposal(readyRequest(family, draft));
+	expect(result.issues).toEqual([]);
+	expect(result.record).toBeDefined();
+	return result.record as WorkspaceProposalRecorded<TDraft>;
+}
+
+function proposalRecordWithProposalId<TDraft>(
+	family: WorkspaceProposalFamily,
+	draft: TDraft,
+	proposalId: string,
+): WorkspaceProposalRecorded<TDraft> {
+	const result = recordWorkspaceProposal({
+		...readyRequest(family, draft),
+		proposalId,
+		intakeRequestId: `${proposalId}:intake`,
+	});
+	expect(result.issues).toEqual([]);
+	expect(result.record).toBeDefined();
+	return result.record as WorkspaceProposalRecorded<TDraft>;
+}
+
+function admittedDecision(record: WorkspaceProposalRecorded): WorkspaceProposalAdmissionDecision {
+	const result = decideWorkspaceProposalAdmission(record, admissionMaterial(record.proposalFamily));
+	expect(result.issues).toEqual([]);
+	expect(result.decision.status).toBe("admitted");
+	return result.decision;
+}
+
+function admittedDecisionWithId(
+	record: WorkspaceProposalRecorded,
+	decisionId: string,
+): WorkspaceProposalAdmissionDecision {
+	const result = decideWorkspaceProposalAdmission(record, {
+		...admissionMaterial(record.proposalFamily),
+		decisionId,
+	});
+	expect(result.issues).toEqual([]);
+	expect(result.decision.status).toBe("admitted");
+	return result.decision;
+}
+
+function readyRequest<TDraft>(
+	family: WorkspaceProposalFamily,
+	draft: TDraft,
+): WorkspaceProposalReadyRequest<TDraft> {
+	return {
+		kind: "workspace-proposal-ready-request",
+		proposalId: "proposal-1",
+		intakeRequestId: "intake-1",
+		idempotencyKey: "idem-1",
+		workspaceId: "workspace-1",
+		proposalFamily: family,
+		loweringKind: `side-panel-${family}`,
+		draft,
+		targetRefs: [{ kind: "work-item", id: "wi-1", revision: 1 }],
+		actorRef,
+		capabilityRefs: [capabilityRef],
+		policyRefs: [policyRef],
+		projectionBundleRefs: [projectionRef],
+		sourceRefs: [sourceRef],
+	};
+}
+
+function admissionMaterial(family: WorkspaceProposalFamily): WorkspaceProposalAdmissionMaterial {
+	return {
+		decisionId: "decision-1",
+		policies: [
+			{
+				kind: "workspace-proposal-admission-policy",
+				policyId: "policy-1",
+				proposalFamilies: [family],
+				outcome: "admitted",
+			},
+		],
+		idempotencyEvidence: {
+			kind: "workspace-proposal-idempotency-evidence",
+			idempotencyKey: "idem-1",
+			state: "unique",
+		},
+		freshnessEvidence: [
+			{
+				kind: "workspace-proposal-freshness-evidence",
+				targetRef: { kind: "work-item", id: "wi-1", revision: 1 },
+				state: "fresh",
+			},
+		],
+		projectionFreshnessEvidence: [
+			{
+				kind: "workspace-proposal-projection-freshness-evidence",
+				projectionBundleRef: projectionRef,
+				state: "fresh",
+			},
+		],
+		capabilityEvidence: [
+			{
+				kind: "workspace-proposal-capability-evidence",
+				capabilityRef,
+				state: "present",
+			},
+		],
+		sourceRefs: [sourceRef],
+	};
+}
+
+function requiredInputGate(): RequiredInputGate {
+	return {
+		kind: "required-input-gate",
+		gateId: "gate-1",
+		requestId: "request-1",
+		workItemId: "wi-1",
+		status: "requested",
+		prompt: "Answer",
+	};
+}
+
+function workItem(id: string): WorkItemProjection {
+	return {
+		...workItemDraft(`Item ${id}`),
+		workItemId: id,
+		authoringRevision: 1,
+		executionInputRevision: 1,
+		lastEventId: `${id}:created`,
+	};
+}
+
+function workItemDraft(summary: string): WorkItemDraft {
+	return {
+		title: summary,
+		summary,
+		workKind: "task",
+		status: "open",
+	};
+}
+
+function linkDraft() {
+	return {
+		kind: "work-item-link-proposal",
+		linkId: "link-1",
+		fromWorkItemId: "wi-1",
+		toWorkItemId: "wi-2",
+		linkKind: "blocks",
+		direction: "directed",
+	} as const;
+}
+
+function linkProjection(linkId: string): WorkItemLinkProjection {
+	return {
+		linkId,
+		fromWorkItemId: "wi-1",
+		toWorkItemId: "wi-2",
+		linkKind: "blocks",
+		direction: "directed",
+		active: true,
+		lastEventId: `${linkId}:linked`,
+	};
+}
+
+function repairReviewFixture() {
+	const record = proposalRecord("work-item-link", linkDraft());
+	const decision = admittedDecision(record);
+	const application = projectWorkspaceProposalWorkItemLinkApplication(record, decision, {
+		applicationId: "application-repair-review",
+		workItems: [workItem("wi-1"), workItem("wi-2")],
+	});
+	const repairNeededStatus = {
+		...application.status,
+		state: "repair-needed",
+		code: "missing-required-field",
+		issues: [
+			{
+				kind: "issue",
+				source: "workspace-proposal",
+				severity: "error",
+				code: "missing-required-field",
+				message: "Workspace proposal family application material is missing",
+				subjectId: application.status.proposalId,
+				refs: application.status.sourceRefs.map((source) => `${source.kind}:${source.id}`),
+			},
+		],
+		emittedFactRefs: [],
+	} satisfies WorkspaceProposalApplicationStatus;
+	const request = projectWorkspaceProposalRepairReviewRequests({
+		applicationStatuses: [repairNeededStatus],
+	})[0];
+	if (request === undefined) throw new Error("expected D444 repair request fixture");
+	const outcomeResult = recordWorkspaceProposalWorkItemLinkOutcome(application.status, {
+		outcomeId: "repair-review-outcome",
+		linkRef: { kind: "work-item-link", id: "link-1" },
+	});
+	const outcome = outcomeResult.outcome;
+	if (outcome === undefined) throw new Error("expected D444 outcome fixture");
+	const outcomeIndex = projectWorkspaceProposalFamilyOutcomeIndex([outcome]);
+	return {
+		record,
+		decision,
+		request,
+		appliedStatus: application.status,
+		applicationRecorded: application.recorded,
+		repairNeededStatus,
+		outcome,
+		outcomeStatus: outcomeResult.status,
+		outcomeIndex,
+	};
+}
+
+function repairReviewReadModelCoordinates(request: WorkspaceProposalRepairReviewRequest) {
+	return {
+		applicationId: request.applicationId,
+		proposalId: request.proposalId,
+		decisionId: request.decisionId,
+		idempotencyKey: request.idempotencyKey,
+		proposalFamily: request.proposalFamily,
+	} as const;
+}
+
+function repairReviewDecision(
+	request: WorkspaceProposalRepairReviewRequest,
+	intent: WorkspaceProposalRepairReviewDecision["intent"],
+	reviewDecisionId: string,
+): WorkspaceProposalRepairReviewDecision {
+	return {
+		kind: "workspace-proposal-repair-review-decision",
+		reviewDecisionId,
+		repairRequestId: request.repairRequestId,
+		applicationId: request.applicationId,
+		proposalId: request.proposalId,
+		decisionId: request.decisionId,
+		idempotencyKey: request.idempotencyKey,
+		proposalFamily: request.proposalFamily,
+		intent,
+		reviewerRef: { kind: "actor", id: "reviewer-1" },
+		sourceRefs: [{ kind: "manual-review", id: reviewDecisionId }],
+	};
+}
+
+function repairReviewRecordingInput(
+	request: WorkspaceProposalRepairReviewRequest,
+	reviewDecisionId: string,
+): WorkspaceProposalRepairReviewDecisionRecordingInput {
+	return {
+		kind: "workspace-proposal-repair-review-decision-recording-input",
+		repairRequestId: request.repairRequestId,
+		reviewDecisionId,
+		intent: "acknowledged",
+		reviewerRef: { kind: "actor", id: "reviewer:d456" },
+		capabilityRefs: [{ kind: "capability", id: "repair-review:write" }],
+		policyRefs: [{ kind: "policy", id: "repair-review:policy" }],
+		sourceRefs: [{ kind: "manual-review", id: `source:${reviewDecisionId}` }],
+		audit: {
+			auditId: `audit:${reviewDecisionId}`,
+			actorId: "reviewer:d456",
+			sourceRefs: [{ kind: "manual-review", id: `audit-source:${reviewDecisionId}` }],
+		},
+		code: "acknowledged-by-reviewer",
+		expectedCurrentState: { state: "open", code: "open" },
+	};
+}
+
+function repairActionIntent(
+	request: WorkspaceProposalRepairReviewRequest,
+	descriptor: WorkspaceProposalRepairActionDescriptor,
+	options: {
+		readonly actionKind: WorkspaceProposalRepairActionIntent["actionKind"];
+		readonly expectedCurrentState?: WorkspaceProposalRepairActionIntent["expectedCurrentState"];
+	},
+): WorkspaceProposalRepairActionIntent {
+	return {
+		kind: "workspace-proposal-repair-action-intent",
+		intentId: `repair-action-intent:${options.actionKind}`,
+		descriptorId: descriptor.descriptorId,
+		repairRequestId: request.repairRequestId,
+		actionKind: options.actionKind,
+		applicationId: request.applicationId,
+		proposalId: request.proposalId,
+		decisionId: request.decisionId,
+		idempotencyKey: request.idempotencyKey,
+		proposalFamily: request.proposalFamily,
+		reviewerRef: { kind: "actor", id: "reviewer:d459" },
+		capabilityRefs: [{ kind: "capability", id: `repair-action:${options.actionKind}` }],
+		policyRefs: [{ kind: "policy", id: "repair-action:intake-policy" }],
+		sourceRefs: descriptor.sourceRefs,
+		audit: {
+			auditId: `audit:${options.actionKind}`,
+			actorId: "reviewer:d459",
+			sourceRefs: descriptor.sourceRefs,
+		},
+		metadata: { descriptorRoute: descriptor.metadata?.route },
+		expectedCurrentState: options.expectedCurrentState,
+	};
+}
+
+function readModelQuery(
+	queryId: string,
+	coordinates: ReturnType<typeof repairReviewReadModelCoordinates>,
+	options: {
+		readonly page?: WorkspaceProposalFamilyApplicationReadModelQuery["page"];
+		readonly filters?: WorkspaceProposalFamilyApplicationReadModelQuery["filters"];
+		readonly sort?: WorkspaceProposalFamilyApplicationReadModelQuery["sort"];
+		readonly groupBy?: WorkspaceProposalFamilyApplicationReadModelQuery["groupBy"];
+		readonly search?: WorkspaceProposalFamilyApplicationReadModelQuery["search"];
+	} = {},
+): WorkspaceProposalFamilyApplicationReadModelQuery {
+	return {
+		kind: "workspace-proposal-family-application-read-model-query",
+		queryId,
+		viewId: `view-${queryId}`,
+		...coordinates,
+		page: options.page,
+		filters: options.filters,
+		sort: options.sort,
+		groupBy: options.groupBy,
+		search: options.search,
+		sourceRefs: [sourceRef],
+	};
+}
+
+function projectionRelease(
+	releaseId: string,
+	targetKind: WorkspaceProposalProjectionRelease["targetKind"],
+	targetId: string | undefined,
+	options: Partial<
+		Omit<
+			WorkspaceProposalProjectionRelease,
+			"kind" | "releaseId" | "targetKind" | "targetId" | "sourceRefs"
+		>
+	> = {},
+): WorkspaceProposalProjectionRelease {
+	if (targetId === undefined) throw new Error("expected D472 projection release target");
+	return {
+		kind: "workspace-proposal-projection-release",
+		releaseId,
+		targetKind,
+		targetId,
+		sourceRefs: [{ kind: "workspace-projection-release", id: releaseId }],
+		...options,
+	};
+}
+
+function expectForbiddenDescriptorKeys(value: unknown): void {
+	const forbidden = new Set([
+		"command",
+		"commands",
+		"callback",
+		"callbacks",
+		"handler",
+		"onClick",
+		"onSubmit",
+		"draftFactory",
+		"proposalDraft",
+		"successorProposalId",
+		"successorAdmissionId",
+		"successorApplicationId",
+		"mutationIntent",
+		"providerClient",
+		"runtimeHandle",
+		"retryCommand",
+		"familyFact",
+		"applicationStatus",
+	]);
+	const visit = (item: unknown): void => {
+		if (Array.isArray(item)) {
+			for (const entry of item) visit(entry);
+			return;
+		}
+		if (item === null || typeof item !== "object") return;
+		for (const [key, child] of Object.entries(item)) {
+			expect(forbidden.has(key), `forbidden descriptor key ${key}`).toBe(false);
+			visit(child);
+		}
+	};
+	visit(value);
+}
+
+function d430ApplicationRefs(
+	record: WorkspaceProposalRecorded,
+	decision: WorkspaceProposalAdmissionDecision,
+	applicationId: string,
+) {
+	return [
+		{ kind: "workspace-proposal-recorded", id: record.proposalId },
+		{ kind: "workspace-proposal-admission-decision", id: decision.decisionId },
+		{ kind: "workspace-proposal-application-status", id: applicationId },
+	] as const;
+}
+
+function collectData<T>(node: {
+	subscribe(sink: (msg: readonly [string, unknown?]) => void): unknown;
+}): T[] {
+	const out: T[] = [];
+	node.subscribe((msg) => {
+		if (msg[0] === "DATA") out.push(msg[1] as T);
+	});
+	return out;
+}
+
+function collectDataFromNodes<T>(
+	...nodes: {
+		subscribe(sink: (msg: readonly [string, unknown?]) => void): unknown;
+	}[]
+): T[] {
+	const out: T[] = [];
+	for (const node of nodes) {
+		node.subscribe((msg) => {
+			if (msg[0] === "DATA") out.push(msg[1] as T);
+		});
+	}
+	return out;
+}
diff --git a/packages/ts/src/__tests__/work-queue-recipes.test.ts b/packages/ts/src/__tests__/work-queue-recipes.test.ts
new file mode 100644
index 00000000..c6280bb2
--- /dev/null
+++ b/packages/ts/src/__tests__/work-queue-recipes.test.ts
@@ -0,0 +1,663 @@
+import { describe, expect, it } from "vitest";
+import {
+	type ExecutorQueuedDispatchPayload,
+	executorWorkQueueRecipe,
+} from "../executors/work-queue.js";
+import { graph } from "../graph/graph.js";
+import type { AgentRequestIssued, ExecutorOutcome } from "../orchestration/agent-runtime.js";
+import type {
+	WorkItemEffectRequested,
+	WorkItemEvidenceRecorded,
+} from "../orchestration/work-item-runtime.js";
+import {
+	type WorkItemAuthoringInput,
+	type WorkItemEffectPlanProposed,
+	type WorkItemEffectPlanResult,
+	workItemAuthoringProjector,
+	workItemCreatedFromDraft,
+	workItemEffectPlanProjector,
+} from "../solutions/work-item/scheduling.js";
+import {
+	type WorkItemQueuedWorkPayload,
+	workItemWorkQueueRecipe,
+} from "../solutions/work-item/work-queue.js";
+import type { WorkQueueCommand, WorkQueueRecord } from "../work-queue/index.js";
+
+describe("workQueue recipes (D327/D328/D331)", () => {
+	it("lowers WorkItem effect facts to queue submit command facts", () => {
+		const g = graph();
+		const requests = g.node<WorkItemEffectRequested>([], null, { name: "workItemRequests" });
+		const records = g.node<WorkQueueRecord<WorkItemQueuedWorkPayload>>([], null, {
+			name: "queueRecords",
+		});
+		const recipe = workItemWorkQueueRecipe(g, {
+			effectRequests: requests,
+			records,
+			policy: {
+				payload: () =>
+					({
+						workItemId: "wrong",
+						effectRunId: "wrong",
+						requestId: "wrong",
+						effectKind: "wrong",
+						sourceEventId: "event-1",
+					}) as Partial<WorkItemQueuedWorkPayload>,
+			},
+		});
+		const submits = collectData<WorkQueueCommand<WorkItemQueuedWorkPayload>>(recipe.submitCommands);
+
+		requests.down([
+			[
+				"DATA",
+				{
+					kind: "work-item-effect-requested",
+					requestId: "req-1",
+					workItemId: "wi-1",
+					effectRunId: "run-1",
+					effectKind: "verify",
+					idempotencyKey: "idem-1",
+					sourceRefs: [{ kind: "work-item", id: "wi-1" }],
+				} satisfies WorkItemEffectRequested,
+			],
+		]);
+
+		expect(submits.at(-1)).toEqual(
+			expect.objectContaining({
+				kind: "submit",
+				commandId: "req-1:work-queue-submit",
+				workId: "wi-1:run-1",
+				idempotencyKey: "idem-1",
+				payload: expect.objectContaining({
+					kind: "work-item-queued-work",
+					workItemId: "wi-1",
+					effectRunId: "run-1",
+					requestId: "req-1",
+					effectKind: "verify",
+					sourceEventId: "event-1",
+				}),
+			}),
+		);
+		expect(g.describe().nodes).toContainEqual(
+			expect.objectContaining({
+				id: "workItemWorkQueue/submitCommands",
+				factory: "workItemWorkQueueSubmitCommands",
+			}),
+		);
+	});
+
+	it("maps terminal WorkItem queue records to evidence without mutating WorkItems", () => {
+		const g = graph();
+		const requests = g.node<WorkItemEffectRequested>([], null, { name: "workItemRequests" });
+		const records = g.node<WorkQueueRecord<WorkItemQueuedWorkPayload>>([], null, {
+			name: "queueRecords",
+		});
+		const recipe = workItemWorkQueueRecipe(g, { effectRequests: requests, records });
+		const evidence = collectData(recipe.evidence);
+		const issues = collectData(recipe.issues);
+
+		records.down([
+			[
+				"DATA",
+				{
+					kind: "work-admitted",
+					recordSeq: 1,
+					queueId: "q",
+					workId: "work-1",
+					commandId: "admit-1",
+					recordedAtMs: 100,
+					payload: workItemPayload(),
+					messageBus: { topic: "work", seq: 1, subscriptionId: "sub" },
+				} satisfies WorkQueueRecord<WorkItemQueuedWorkPayload>,
+			],
+			[
+				"DATA",
+				{
+					kind: "work-completed",
+					recordSeq: 2,
+					queueId: "q",
+					workId: "work-1",
+					leaseId: "lease-1",
+					attempt: 1,
+					workerId: "worker-1",
+					result: { ok: true },
+					recordedAtMs: 120,
+				} satisfies WorkQueueRecord<WorkItemQueuedWorkPayload>,
+			],
+			[
+				"DATA",
+				{
+					kind: "work-dead-lettered",
+					recordSeq: 3,
+					queueId: "q",
+					workId: "work-1",
+					reason: "retry-exhausted",
+					recordedAtMs: 140,
+				} satisfies WorkQueueRecord<WorkItemQueuedWorkPayload>,
+			],
+		]);
+
+		expect(evidence).toEqual([
+			expect.objectContaining({
+				kind: "work-item-evidence-recorded",
+				workItemId: "wi-1",
+				effectRunId: "run-1",
+				status: "completed",
+				output: expect.objectContaining({ kind: "work-queue-completion" }),
+				metadata: expect.objectContaining({
+					executionInputRevision: 3,
+					verificationStepIds: ["step-1"],
+					acceptanceCriterionIds: ["ac-1"],
+					queueRecordKind: "work-completed",
+				}),
+			}),
+			expect.objectContaining({
+				kind: "work-item-evidence-recorded",
+				workItemId: "wi-1",
+				effectRunId: "run-1",
+				status: "failed",
+				reason: "retry-exhausted",
+			}),
+		]);
+		expect(issues).toEqual([]);
+	});
+
+	it("roundtrips WorkItemEffectPlan coordinates through the WorkItem workQueue recipe", () => {
+		const g = graph();
+		const facts = g.node<WorkItemAuthoringInput>([], null, { name: "workItemFacts" });
+		const proposals = g.node<WorkItemEffectPlanProposed>([], null, { name: "effectPlans" });
+		const queueEvidence = g.node<WorkItemEvidenceRecorded>([], null, { name: "queueEvidence" });
+		const records = g.node<WorkQueueRecord<WorkItemQueuedWorkPayload>>([], null, {
+			name: "queueRecords",
+		});
+		const authoring = workItemAuthoringProjector(g, { facts });
+		const plan = workItemEffectPlanProjector(g, {
+			workItems: authoring.workItems,
+			proposals,
+			evidence: queueEvidence,
+			policy: { allowedEffectKinds: ["verification"] },
+		});
+		const recipe = workItemWorkQueueRecipe(g, {
+			effectRequests: plan.effectRequests,
+			records,
+		});
+		const submits = collectData<WorkQueueCommand<WorkItemQueuedWorkPayload>>(recipe.submitCommands);
+		const evidence = collectData<WorkItemEvidenceRecorded>(recipe.evidence);
+		const results = collectData<WorkItemEffectPlanResult>(plan.results);
+		recipe.evidence.subscribe((msg) => {
+			if (msg[0] === "DATA")
+				queueEvidence.down([msg as readonly ["DATA", WorkItemEvidenceRecorded]]);
+		});
+
+		facts.down([
+			[
+				"DATA",
+				workItemCreatedFromDraft("wi-1", {
+					summary: "Queue a plan member",
+					detail: "Exercise the WorkItem three-layer roundtrip.",
+				}),
+			],
+		]);
+		proposals.down([
+			[
+				"DATA",
+				{
+					kind: "work-item-effect-plan-proposed",
+					planId: "effect-plan-queue",
+					workItemId: "wi-1",
+					executionInputRevision: 1,
+					members: [
+						{
+							memberId: "A",
+							effectKind: "verification",
+							goal: { kind: "verification", summary: "Run queued verification" },
+						},
+					],
+				} satisfies WorkItemEffectPlanProposed,
+			],
+		]);
+		const submit = submits.at(-1);
+		if (submit === undefined) throw new Error("expected submit command");
+
+		expect(submit.payload).toMatchObject({
+			workItemId: "wi-1",
+			requestId: "work-item:wi-1:effect-plan:1:effect-plan-queue:A",
+			effectRunId: "effect-run:work-item:wi-1:effect-plan:1:effect-plan-queue:A",
+			executionInputRevision: 1,
+			planId: "effect-plan-queue",
+			planMemberId: "A",
+		});
+
+		records.down([
+			[
+				"DATA",
+				{
+					kind: "work-admitted",
+					recordSeq: 1,
+					queueId: "q",
+					workId: submit.workId ?? "queued-plan-member",
+					commandId: submit.commandId,
+					recordedAtMs: 100,
+					payload: submit.payload,
+					messageBus: { topic: "work", seq: 1, subscriptionId: "sub" },
+				} satisfies WorkQueueRecord<WorkItemQueuedWorkPayload>,
+			],
+			[
+				"DATA",
+				{
+					kind: "work-completed",
+					recordSeq: 2,
+					queueId: "q",
+					workId: submit.workId ?? "queued-plan-member",
+					leaseId: "lease-1",
+					attempt: 1,
+					workerId: "worker-1",
+					result: { ok: true },
+					recordedAtMs: 120,
+				} satisfies WorkQueueRecord<WorkItemQueuedWorkPayload>,
+			],
+		]);
+
+		expect(evidence.at(-1)).toMatchObject({
+			workItemId: "wi-1",
+			requestId: submit.payload.requestId,
+			effectRunId: submit.payload.effectRunId,
+			executionInputRevision: 1,
+			planId: "effect-plan-queue",
+			planMemberId: "A",
+			status: "completed",
+		});
+		expect(results.at(-1)).toMatchObject({
+			status: "succeeded",
+			memberResults: [
+				expect.objectContaining({
+					planMemberId: "A",
+					requestId: submit.payload.requestId,
+					effectRunId: submit.payload.effectRunId,
+					evidenceId: "work-queue:2",
+				}),
+			],
+		});
+	});
+
+	it("maps executor queue claims to dispatch-attempt facts and outcomes to queue commands", () => {
+		const g = graph();
+		const records = g.node<WorkQueueRecord<ExecutorPayload>>([], null, { name: "queueRecords" });
+		const outcomes = g.node<ExecutorOutcome>([], null, { name: "executorOutcomes" });
+		const recipe = executorWorkQueueRecipe(g, { records, outcomes, workerId: "worker-1" });
+		const attempts = collectData(recipe.attempts);
+		const commands = collectData(recipe.commands);
+
+		records.down([
+			[
+				"DATA",
+				{
+					kind: "work-admitted",
+					recordSeq: 1,
+					queueId: "q",
+					workId: "work-1",
+					commandId: "admit-1",
+					recordedAtMs: 100,
+					payload: executorPayload(),
+					messageBus: { topic: "exec", seq: 1, subscriptionId: "sub" },
+				} satisfies WorkQueueRecord<ExecutorPayload>,
+			],
+			[
+				"DATA",
+				{
+					kind: "work-claimed",
+					recordSeq: 2,
+					queueId: "q",
+					workId: "work-1",
+					leaseId: "lease-1",
+					attempt: 1,
+					workerId: "worker-1",
+					claimedAtMs: 110,
+					leaseExpiresAtMs: 210,
+					recordedAtMs: 110,
+				} satisfies WorkQueueRecord<ExecutorPayload>,
+			],
+		]);
+		outcomes.down([
+			[
+				"DATA",
+				{
+					kind: "result",
+					outcomeId: "out-1",
+					requestId: "req-1",
+					operationId: "op-1",
+					routeId: "route-1",
+					executorId: "exec-1",
+					profileId: "profile-1",
+					attempt: 1,
+					result: { kind: "tool-result", value: { ok: true } },
+				} satisfies ExecutorOutcome,
+			],
+		]);
+
+		expect(attempts.at(-1)).toEqual(
+			expect.objectContaining({
+				kind: "executor-queued-dispatch-attempt",
+				workId: "work-1",
+				leaseId: "lease-1",
+				queueAttempt: 1,
+				requestId: "req-1",
+				operationId: "op-1",
+			}),
+		);
+		expect(commands.at(-1)).toEqual(
+			expect.objectContaining({
+				kind: "complete",
+				workId: "work-1",
+				leaseId: "lease-1",
+				attempt: 1,
+				workerId: "worker-1",
+				result: { kind: "tool-result", value: { ok: true } },
+			}),
+		);
+	});
+
+	it("keeps executor failures as queue lifecycle commands, not ExecutorOutcome truth", () => {
+		const g = graph();
+		const records = g.node<WorkQueueRecord<ExecutorPayload>>([], null, { name: "queueRecords" });
+		const outcomes = g.node<ExecutorOutcome>([], null, { name: "executorOutcomes" });
+		const recipe = executorWorkQueueRecipe(g, { records, outcomes });
+		const commands = collectData(recipe.commands);
+
+		records.down([
+			[
+				"DATA",
+				{
+					kind: "work-admitted",
+					recordSeq: 1,
+					queueId: "q",
+					workId: "work-1",
+					commandId: "admit-1",
+					recordedAtMs: 100,
+					payload: executorPayload(),
+					messageBus: { topic: "exec", seq: 1, subscriptionId: "sub" },
+				} satisfies WorkQueueRecord<ExecutorPayload>,
+			],
+			[
+				"DATA",
+				{
+					kind: "work-claimed",
+					recordSeq: 2,
+					queueId: "q",
+					workId: "work-1",
+					leaseId: "lease-1",
+					attempt: 1,
+					workerId: "worker-1",
+					claimedAtMs: 110,
+					leaseExpiresAtMs: 210,
+					recordedAtMs: 110,
+				} satisfies WorkQueueRecord<ExecutorPayload>,
+			],
+		]);
+		outcomes.down([
+			[
+				"DATA",
+				{
+					kind: "failure",
+					outcomeId: "out-fail",
+					requestId: "req-1",
+					operationId: "op-1",
+					routeId: "route-1",
+					executorId: "exec-1",
+					profileId: "profile-1",
+					attempt: 1,
+					error: { kind: "issue", code: "provider-error", message: "provider failed" },
+					retryable: true,
+				} satisfies ExecutorOutcome,
+			],
+		]);
+
+		expect(commands.at(-1)).toEqual(
+			expect.objectContaining({
+				kind: "fail",
+				workId: "work-1",
+				leaseId: "lease-1",
+				retryable: true,
+			}),
+		);
+	});
+
+	it("buffers executor outcomes that replay before the queue claim", () => {
+		const g = graph();
+		const records = g.node<WorkQueueRecord<ExecutorPayload>>([], null, { name: "queueRecords" });
+		const outcomes = g.node<ExecutorOutcome>([], null, { name: "executorOutcomes" });
+		const recipe = executorWorkQueueRecipe(g, { records, outcomes });
+		const commands = collectData(recipe.commands);
+		const issues = collectData(recipe.issues);
+
+		outcomes.down([
+			[
+				"DATA",
+				{
+					kind: "result",
+					outcomeId: "out-before-claim",
+					requestId: "req-1",
+					operationId: "op-1",
+					routeId: "route-1",
+					executorId: "exec-1",
+					profileId: "profile-1",
+					attempt: 1,
+					result: { kind: "tool-result", value: { ok: true } },
+				} satisfies ExecutorOutcome,
+			],
+		]);
+		expect(commands).toEqual([]);
+		expect(issues).toEqual([]);
+
+		records.down([
+			[
+				"DATA",
+				{
+					kind: "work-admitted",
+					recordSeq: 1,
+					queueId: "q",
+					workId: "work-1",
+					commandId: "admit-1",
+					recordedAtMs: 100,
+					payload: executorPayload(),
+					messageBus: { topic: "exec", seq: 1, subscriptionId: "sub" },
+				} satisfies WorkQueueRecord<ExecutorPayload>,
+			],
+			[
+				"DATA",
+				{
+					kind: "work-claimed",
+					recordSeq: 2,
+					queueId: "q",
+					workId: "work-1",
+					leaseId: "lease-1",
+					attempt: 1,
+					workerId: "worker-1",
+					claimedAtMs: 110,
+					leaseExpiresAtMs: 210,
+					recordedAtMs: 110,
+				} satisfies WorkQueueRecord<ExecutorPayload>,
+			],
+		]);
+
+		expect(commands.at(-1)).toEqual(
+			expect.objectContaining({
+				kind: "complete",
+				workId: "work-1",
+				leaseId: "lease-1",
+			}),
+		);
+		expect(issues).toEqual([]);
+	});
+
+	it("rejects duplicate executor terminal outcomes for one queue claim", () => {
+		const g = graph();
+		const records = g.node<WorkQueueRecord<ExecutorPayload>>([], null, { name: "queueRecords" });
+		const outcomes = g.node<ExecutorOutcome>([], null, { name: "executorOutcomes" });
+		const recipe = executorWorkQueueRecipe(g, { records, outcomes });
+		const commands = collectData(recipe.commands);
+		const issues = collectData(recipe.issues);
+
+		records.down([
+			[
+				"DATA",
+				{
+					kind: "work-admitted",
+					recordSeq: 1,
+					queueId: "q",
+					workId: "work-1",
+					commandId: "admit-1",
+					recordedAtMs: 100,
+					payload: executorPayload(),
+					messageBus: { topic: "exec", seq: 1, subscriptionId: "sub" },
+				} satisfies WorkQueueRecord<ExecutorPayload>,
+			],
+			[
+				"DATA",
+				{
+					kind: "work-claimed",
+					recordSeq: 2,
+					queueId: "q",
+					workId: "work-1",
+					leaseId: "lease-1",
+					attempt: 1,
+					workerId: "worker-1",
+					claimedAtMs: 110,
+					leaseExpiresAtMs: 210,
+					recordedAtMs: 110,
+				} satisfies WorkQueueRecord<ExecutorPayload>,
+			],
+		]);
+		outcomes.down([
+			[
+				"DATA",
+				{
+					kind: "result",
+					outcomeId: "out-result",
+					requestId: "req-1",
+					operationId: "op-1",
+					routeId: "route-1",
+					executorId: "exec-1",
+					profileId: "profile-1",
+					attempt: 1,
+					result: { kind: "ok" },
+				} satisfies ExecutorOutcome,
+			],
+			[
+				"DATA",
+				{
+					kind: "failure",
+					outcomeId: "out-late-fail",
+					requestId: "req-1",
+					operationId: "op-1",
+					routeId: "route-1",
+					executorId: "exec-1",
+					profileId: "profile-1",
+					attempt: 1,
+					error: { kind: "issue", code: "late", message: "late failure" },
+				} satisfies ExecutorOutcome,
+			],
+		]);
+
+		expect(commands).toHaveLength(1);
+		expect(commands[0]).toEqual(expect.objectContaining({ kind: "complete" }));
+		expect(issues.at(-1)).toEqual(
+			expect.objectContaining({
+				code: "executor-duplicate-terminal-outcome-for-queue-claim",
+			}),
+		);
+	});
+
+	it("lowers issued executor requests to optional queue submit command facts", () => {
+		const g = graph();
+		const requests = g.node<AgentRequestIssued>([], null, { name: "requests" });
+		const records = g.node<WorkQueueRecord<ExecutorPayload>>([], null, { name: "queueRecords" });
+		const outcomes = g.node<ExecutorOutcome>([], null, { name: "outcomes" });
+		const recipe = executorWorkQueueRecipe(g, {
+			requests,
+			records,
+			outcomes,
+			policy: {
+				payload: () =>
+					({
+						requestId: "wrong",
+						operationId: "wrong",
+						routeId: "route-override",
+					}) as Partial<ExecutorPayload>,
+			},
+		});
+		if (recipe.submitCommands === undefined) throw new Error("missing submitCommands");
+		const submits = collectData(recipe.submitCommands);
+
+		requests.down([
+			[
+				"DATA",
+				{
+					kind: "issued",
+					requestId: "req-1",
+					operationId: "op-1",
+					effectRunId: "run-1",
+					requestKind: "executor",
+					required: true,
+					input: { inputId: "input-1", inputKind: "tool-call", value: { tool: "search" } },
+					sourceRefs: [{ kind: "agent-request", id: "req-1" }],
+				} satisfies AgentRequestIssued,
+			],
+		]);
+
+		expect(submits.at(-1)).toEqual(
+			expect.objectContaining({
+				kind: "submit",
+				commandId: "req-1:executor-work-queue-submit",
+				workId: "executor:req-1",
+				payload: expect.objectContaining({
+					kind: "executor-queued-dispatch",
+					requestId: "req-1",
+					operationId: "op-1",
+					inputId: "input-1",
+					routeId: "route-override",
+				}),
+			}),
+		);
+	});
+});
+
+type ExecutorPayload = ExecutorQueuedDispatchPayload;
+
+function collectData<T>(node: {
+	subscribe(sink: (msg: readonly [string, unknown?]) => void): unknown;
+}): T[] {
+	const out: T[] = [];
+	node.subscribe((msg) => {
+		if (msg[0] === "DATA") out.push(msg[1] as T);
+	});
+	return out;
+}
+
+function workItemPayload(): WorkItemQueuedWorkPayload {
+	return {
+		kind: "work-item-queued-work",
+		workItemId: "wi-1",
+		effectRunId: "run-1",
+		requestId: "req-1",
+		effectKind: "verify",
+		sourceRefs: [{ kind: "work-item", id: "wi-1" }],
+		metadata: {
+			executionInputRevision: 3,
+			verificationStepIds: ["step-1"],
+			acceptanceCriterionIds: ["ac-1"],
+		},
+	};
+}
+
+function executorPayload(): ExecutorPayload {
+	return {
+		kind: "executor-queued-dispatch",
+		requestId: "req-1",
+		operationId: "op-1",
+		routeId: "route-1",
+		executorId: "exec-1",
+		profileId: "profile-1",
+		effectRunId: "run-1",
+		sourceRefs: [{ kind: "agent-request", id: "req-1" }],
+	};
+}
diff --git a/packages/ts/src/__tests__/work-queue-scheduled-readiness.test.ts b/packages/ts/src/__tests__/work-queue-scheduled-readiness.test.ts
new file mode 100644
index 00000000..35ad01fe
--- /dev/null
+++ b/packages/ts/src/__tests__/work-queue-scheduled-readiness.test.ts
@@ -0,0 +1,878 @@
+import { describe, expect, it } from "vitest";
+import type { DataIssue } from "../data/index.js";
+import { graph } from "../graph/graph.js";
+import type {
+	ScheduledReadinessClock,
+	ScheduledReadinessOverdue,
+	ScheduledReadinessReady,
+	ScheduledReadinessRequested,
+} from "../orchestration/index.js";
+import { scheduledReadinessProjector } from "../orchestration/index.js";
+import {
+	type WorkQueueReadinessCandidate,
+	type WorkQueueReadinessHandoffStatus,
+	type WorkQueueReadinessHandoffViews,
+	type WorkQueueScheduledReadinessStatus,
+	type WorkQueueScheduledReadinessViews,
+	workQueueLeaseExpirationCommandProjector,
+	workQueueReadinessHandoffProjector,
+	workQueueScheduledReadinessProjector,
+} from "../orchestration/work-queue.js";
+import type { WorkQueueCommand, WorkQueueRecord } from "../work-queue/index.js";
+
+describe("workQueueScheduledReadinessProjector (B94/D424/D432/D433)", () => {
+	it("lowers work-scheduled notBeforeMs to shared readyAtMs without shared notBeforeMs", () => {
+		const harness = createHarness();
+
+		harness.records.down([
+			[
+				"DATA",
+				workScheduled({
+					recordSeq: 7,
+					commandId: "schedule-command",
+					scheduleId: "user-schedule",
+					notBeforeMs: 1_000,
+					deadlineMs: 1_500,
+				}),
+			],
+		]);
+
+		expect(harness.seen.schedules).toEqual([
+			expect.objectContaining({
+				kind: "scheduled-readiness-requested",
+				scheduleId: "workQueue:q:w1:schedule:user-schedule",
+				readyAtMs: 1_000,
+				deadlineMs: 1_500,
+				reason: "work-queue-schedule",
+			}),
+		]);
+		expect(JSON.stringify(harness.seen.schedules[0])).not.toContain("notBeforeMs");
+		expect(harness.seen.schedules[0]?.subjectRefs).toEqual(
+			expect.arrayContaining([
+				{ kind: "work-queue", id: "q" },
+				{ kind: "work-queue-work", id: "w1" },
+				{ kind: "work-queue-record", id: "7" },
+				{ kind: "work-queue-command", id: "schedule-command" },
+			]),
+		);
+	});
+
+	it("lowers delayed work-admitted and retry-scheduled records to shared readyAtMs", () => {
+		const harness = createHarness();
+
+		harness.records.down([
+			[
+				"DATA",
+				workAdmitted({
+					recordSeq: 1,
+					notBeforeMs: 250,
+					deadlineMs: 300,
+				}),
+			],
+			[
+				"DATA",
+				retryScheduled({
+					recordSeq: 2,
+					commandId: "fail-1",
+					retryAtMs: 500,
+					delayMs: 100,
+				}),
+			],
+		]);
+
+		expect(harness.seen.schedules).toEqual([
+			expect.objectContaining({
+				scheduleId: "workQueue:q:w1:admission:1",
+				readyAtMs: 250,
+				deadlineMs: 300,
+				reason: "work-queue-delayed-admission",
+			}),
+			expect.objectContaining({
+				scheduleId: "workQueue:q:w1:retry:fail-1",
+				readyAtMs: 500,
+				reason: "work-queue-retry",
+			}),
+		]);
+		expect(JSON.stringify(harness.seen.schedules)).not.toContain("retryAtMs");
+		expect(harness.seen.schedules[1]?.metadata).toEqual(
+			expect.objectContaining({ delayMs: 100, scheduleKind: "retry-scheduled" }),
+		);
+	});
+
+	it("dedupes replayed records without duplicating shared schedules", () => {
+		const harness = createHarness();
+		const record = workScheduled({ recordSeq: 9, notBeforeMs: 900 });
+
+		harness.records.down([["DATA", record]]);
+		harness.records.down([["DATA", record]]);
+
+		expect(harness.seen.schedules).toHaveLength(1);
+		expect(harness.seen.status.filter((status) => status.state === "translated")).toHaveLength(1);
+		expect(harness.seen.audit).toHaveLength(1);
+		expect(harness.seen.views.at(-1)?.schedulesById.size).toBe(1);
+	});
+
+	it("emits a visible issue when a scheduleId replays with conflicting material", () => {
+		const harness = createHarness();
+
+		harness.records.down([
+			[
+				"DATA",
+				workScheduled({
+					recordSeq: 1,
+					scheduleId: "same-schedule",
+					notBeforeMs: 100,
+				}),
+			],
+		]);
+		harness.records.down([
+			[
+				"DATA",
+				workScheduled({
+					recordSeq: 2,
+					scheduleId: "same-schedule",
+					notBeforeMs: 200,
+				}),
+			],
+		]);
+
+		expect(harness.seen.schedules).toHaveLength(1);
+		expect(harness.seen.schedules[0]).toEqual(
+			expect.objectContaining({
+				scheduleId: "workQueue:q:w1:schedule:same-schedule",
+				readyAtMs: 100,
+			}),
+		);
+		expect(harness.seen.issues).toEqual([
+			expect.objectContaining({
+				code: "work-queue-scheduled-readiness-schedule-conflict",
+			}),
+		]);
+		expect(harness.seen.status).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({
+					state: "issue",
+					issueCodes: ["work-queue-scheduled-readiness-schedule-conflict"],
+				}),
+			]),
+		);
+		expect(
+			harness.seen.views.at(-1)?.schedulesById.get("workQueue:q:w1:schedule:same-schedule")
+				?.readyAtMs,
+		).toBe(100);
+	});
+
+	it("emits a visible issue when the same workQueue record replays with conflicting material", () => {
+		const harness = createHarness();
+
+		harness.records.down([
+			[
+				"DATA",
+				workScheduled({
+					recordSeq: 5,
+					notBeforeMs: 100,
+				}),
+			],
+		]);
+		harness.records.down([
+			[
+				"DATA",
+				workScheduled({
+					recordSeq: 5,
+					notBeforeMs: 200,
+				}),
+			],
+		]);
+
+		expect(harness.seen.schedules).toHaveLength(1);
+		expect(harness.seen.schedules[0]).toEqual(
+			expect.objectContaining({
+				scheduleId: "workQueue:q:w1:schedule:5",
+				readyAtMs: 100,
+			}),
+		);
+		expect(harness.seen.issues).toEqual([
+			expect.objectContaining({
+				code: "work-queue-scheduled-readiness-schedule-conflict",
+			}),
+		]);
+	});
+
+	it("fails closed on malformed delayed records instead of throwing", () => {
+		const harness = createHarness();
+
+		harness.records.down([
+			[
+				"DATA",
+				{
+					kind: "work-scheduled",
+					queueId: "q",
+					recordSeq: 13,
+					notBeforeMs: 100,
+					recordedAtMs: 0,
+				} as unknown as WorkQueueRecord,
+			],
+		]);
+
+		expect(harness.seen.schedules).toEqual([]);
+		expect(harness.seen.issues).toEqual([
+			expect.objectContaining({
+				code: "work-queue-scheduled-readiness-malformed-record",
+			}),
+		]);
+		expect(harness.seen.status).toEqual([
+			expect.objectContaining({
+				state: "issue",
+				issueCodes: ["work-queue-scheduled-readiness-malformed-record"],
+			}),
+		]);
+	});
+
+	it("translates lease expiration eligibility without materializing lease-expired lifecycle records", () => {
+		const harness = createHarness();
+
+		harness.records.down([
+			[
+				"DATA",
+				workClaimed({
+					recordSeq: 3,
+					leaseId: "lease-1",
+					leaseExpiresAtMs: 1_200,
+				}),
+			],
+			[
+				"DATA",
+				leaseRenewed({
+					recordSeq: 4,
+					leaseId: "lease-1",
+					leaseExpiresAtMs: 1_600,
+					previousLeaseExpiresAtMs: 1_200,
+				}),
+			],
+		]);
+
+		expect(harness.seen.schedules).toEqual([
+			expect.objectContaining({
+				scheduleId: "workQueue:q:w1:lease:lease-1:expires:3",
+				readyAtMs: 1_200,
+				reason: "work-queue-lease-expiration",
+			}),
+			expect.objectContaining({
+				scheduleId: "workQueue:q:w1:lease:lease-1:expires:4",
+				readyAtMs: 1_600,
+				reason: "work-queue-lease-expiration",
+			}),
+		]);
+		const serialized = JSON.stringify({
+			schedules: harness.seen.schedules,
+			status: harness.seen.status,
+			views: harness.seen.views,
+		});
+		expect(serialized).not.toContain("lease-expired");
+		expect(serialized).not.toContain("expire-leases");
+		expect(serialized).not.toContain("work-canceled");
+		expect(serialized).not.toContain("work-completed");
+	});
+
+	it("keeps shared ready and overdue as visibility only, not workQueue lifecycle mutation", () => {
+		const harness = createHarness({ includeSharedReadiness: true });
+
+		harness.records.down([
+			[
+				"DATA",
+				workScheduled({
+					recordSeq: 11,
+					notBeforeMs: 1_000,
+					deadlineMs: 900,
+				}),
+			],
+		]);
+		harness.clocks?.down([["DATA", clock(1_000)]]);
+
+		expect(harness.seen.ready).toEqual([
+			expect.objectContaining({
+				scheduleId: "workQueue:q:w1:schedule:11",
+				readyAtMs: 1_000,
+				nowMs: 1_000,
+			}),
+		]);
+		expect(harness.seen.overdue).toEqual([
+			expect.objectContaining({
+				scheduleId: "workQueue:q:w1:schedule:11",
+				deadlineMs: 900,
+				nowMs: 1_000,
+			}),
+		]);
+		expect(harness.seen.status).toEqual([
+			expect.objectContaining({ state: "translated", readyAtMs: 1_000, deadlineMs: 900 }),
+		]);
+		const serialized = JSON.stringify({
+			translator: harness.seen,
+			ready: harness.seen.ready,
+			overdue: harness.seen.overdue,
+		});
+		expect(serialized).not.toContain("work-queue-command");
+		expect(serialized).not.toContain("lease-expired");
+		expect(serialized).not.toContain("cancel");
+		expect(serialized).not.toContain("complete");
+		expect(serialized).not.toContain("fail");
+	});
+
+	it("bounds public metadata and source refs without carrying raw payloads or secrets", () => {
+		const harness = createHarness();
+		const raw = "x".repeat(10_000);
+		const privateRef = `secret-token-${"s".repeat(1_000)}`;
+		const extraRefs = Array.from({ length: 20 }, (_, index) => `source-${index}`);
+
+		harness.records.down([
+			[
+				"DATA",
+				workScheduled({
+					recordSeq: 12,
+					notBeforeMs: 300,
+					commandId: privateRef,
+					sourceRefs: ["visible-source", privateRef, ...extraRefs],
+					policyRefs: [privateRef],
+					payload: { apiKey: "SECRET", rawResponseBody: raw },
+				} as WorkQueueRecord<{ readonly apiKey: string; readonly rawResponseBody: string }>),
+			],
+		]);
+
+		const serialized = JSON.stringify(harness.seen.schedules[0]);
+		expect(serialized).not.toContain("SECRET");
+		expect(serialized).not.toContain(raw);
+		expect(serialized).not.toContain(privateRef);
+		expect(serialized).not.toContain("secret-token");
+		expect(serialized.length).toBeLessThan(4_000);
+		expect(harness.seen.schedules[0]?.scheduleId).toContain("bounded:");
+		expect(harness.seen.schedules[0]?.sourceRefs).toEqual(
+			expect.arrayContaining([
+				{ kind: "work-queue-source-ref", id: "visible-source" },
+				{ kind: "work-queue-record", id: "12" },
+				expect.objectContaining({
+					kind: "work-queue-source-ref",
+					id: expect.stringMatching(/^bounded:/),
+				}),
+				expect.objectContaining({
+					kind: "work-queue-source-ref-overflow",
+				}),
+			]),
+		);
+		expect(harness.seen.schedules[0]?.policyRefs).toEqual([
+			expect.objectContaining({
+				kind: "work-queue-policy-ref",
+				id: expect.stringMatching(/^bounded:/),
+			}),
+		]);
+	});
+
+	it("ignores terminal/canceled/dead-lettered records instead of emitting shared lifecycle facts", () => {
+		const harness = createHarness();
+
+		harness.records.down([
+			["DATA", terminalRecord("work-canceled", 20)],
+			["DATA", terminalRecord("work-completed", 21)],
+			["DATA", terminalRecord("work-dead-lettered", 22)],
+		]);
+
+		expect(harness.seen.schedules).toEqual([]);
+		expect(harness.seen.status).toEqual([]);
+		expect(harness.seen.issues).toEqual([]);
+	});
+});
+
+describe("workQueueReadinessHandoffProjector (B94/D433)", () => {
+	it("turns scheduled and retry readiness into claim-eligible candidates without claiming work", () => {
+		const harness = createHandoffHarness();
+
+		harness.records.down([
+			["DATA", workScheduled({ recordSeq: 1, notBeforeMs: 100 })],
+			["DATA", retryScheduled({ workId: "w2", recordSeq: 2, commandId: "fail-1", retryAtMs: 200 })],
+		]);
+		harness.ready.down([["DATA", ready("workQueue:q:w1:schedule:1", 100)]]);
+		harness.ready.down([["DATA", ready("workQueue:q:w2:retry:fail-1", 200)]]);
+
+		expect(harness.seen.candidates).toEqual([
+			expect.objectContaining({
+				kind: "work-queue-readiness-candidate",
+				candidateKind: "claim-eligible",
+				workId: "w1",
+				scheduleId: "workQueue:q:w1:schedule:1",
+				readyAtMs: 100,
+			}),
+			expect.objectContaining({
+				candidateKind: "claim-eligible",
+				workId: "w2",
+				scheduleId: "workQueue:q:w2:retry:fail-1",
+				readyAtMs: 200,
+			}),
+		]);
+		expect(harness.seen.commands).toEqual([]);
+		expect(JSON.stringify(harness.seen)).not.toContain("work-claimed");
+		expect(JSON.stringify(harness.seen)).not.toContain("lease-expired");
+	});
+
+	it("keeps current work state isolated by queueId and workId", () => {
+		const harness = createHandoffHarness();
+
+		harness.records.down([
+			[
+				"DATA",
+				workScheduled({ queueId: "q1", workId: "same-work", recordSeq: 1, notBeforeMs: 100 }),
+			],
+			["DATA", terminalRecord("work-completed", 2, { queueId: "q2", workId: "same-work" })],
+		]);
+		harness.ready.down([["DATA", ready("workQueue:q1:same-work:schedule:1", 100)]]);
+
+		expect(harness.seen.candidates).toEqual([
+			expect.objectContaining({
+				candidateKind: "claim-eligible",
+				queueId: "q1",
+				workId: "same-work",
+				scheduleId: "workQueue:q1:same-work:schedule:1",
+			}),
+		]);
+		expect(harness.seen.handoffStatus).not.toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({
+					state: "ignored-terminal",
+					queueId: "q1",
+					workId: "same-work",
+				}),
+			]),
+		);
+	});
+
+	it("ignores stale readiness whose origin record was superseded by a newer record", () => {
+		const harness = createHandoffHarness();
+
+		harness.records.down([
+			["DATA", workScheduled({ recordSeq: 1, notBeforeMs: 100 })],
+			["DATA", workScheduled({ recordSeq: 2, notBeforeMs: 200 })],
+		]);
+		harness.ready.down([["DATA", ready("workQueue:q:w1:schedule:1", 100)]]);
+
+		expect(harness.seen.candidates).toEqual([]);
+		expect(harness.seen.handoffStatus).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({
+					state: "ignored-superseded",
+					scheduleId: "workQueue:q:w1:schedule:1",
+					metadata: expect.objectContaining({
+						originRecordSeq: 1,
+						latestRecordSeq: 2,
+					}),
+				}),
+			]),
+		);
+	});
+
+	it("ignores stale lower-sequence records instead of reopening terminal work", () => {
+		const harness = createHandoffHarness();
+
+		harness.records.down([
+			["DATA", terminalRecord("work-completed", 10)],
+			["DATA", workScheduled({ recordSeq: 1, notBeforeMs: 100 })],
+		]);
+		harness.ready.down([["DATA", ready("workQueue:q:w1:schedule:1", 100)]]);
+
+		expect(harness.seen.candidates).toEqual([]);
+		expect(harness.seen.handoffStatus).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({
+					state: "ignored-superseded",
+					currentState: "completed",
+					scheduleId: "workQueue:q:w1:schedule:1",
+					metadata: expect.objectContaining({ latestRecordSeq: 10 }),
+				}),
+			]),
+		);
+	});
+
+	it("lowers only lease-expiration candidates into expire-leases commands", () => {
+		const harness = createHandoffHarness({ includeLeaseCommands: true });
+
+		harness.records.down([
+			[
+				"DATA",
+				workClaimed({
+					recordSeq: 3,
+					leaseId: "lease-1",
+					attempt: 1,
+					workerId: "worker-1",
+					leaseExpiresAtMs: 300,
+				}),
+			],
+		]);
+		harness.ready.down([["DATA", ready("workQueue:q:w1:lease:lease-1:expires:3", 300)]]);
+
+		expect(harness.seen.candidates).toEqual([
+			expect.objectContaining({
+				candidateKind: "lease-expiration-eligible",
+				workId: "w1",
+				leaseId: "lease-1",
+				attempt: 1,
+				workerId: "worker-1",
+				leaseExpiresAtMs: 300,
+			}),
+		]);
+		expect(harness.seen.commands).toEqual([
+			expect.objectContaining({
+				kind: "expire-leases",
+				workIds: ["w1"],
+				limit: 1,
+				nowMs: 300,
+				causationId: "workQueue:q:w1:lease:lease-1:expires:3",
+			}),
+		]);
+		expect(JSON.stringify(harness.seen.commands)).not.toContain("lease-expired");
+	});
+
+	it("ignores superseded lease readiness after a renewal extends the active lease", () => {
+		const harness = createHandoffHarness({ includeLeaseCommands: true });
+
+		harness.records.down([
+			[
+				"DATA",
+				workClaimed({
+					recordSeq: 3,
+					leaseId: "lease-1",
+					attempt: 1,
+					leaseExpiresAtMs: 300,
+				}),
+			],
+			[
+				"DATA",
+				leaseRenewed({
+					recordSeq: 4,
+					leaseId: "lease-1",
+					attempt: 1,
+					previousLeaseExpiresAtMs: 300,
+					leaseExpiresAtMs: 600,
+				}),
+			],
+		]);
+		harness.ready.down([["DATA", ready("workQueue:q:w1:lease:lease-1:expires:3", 300)]]);
+
+		expect(harness.seen.candidates).toEqual([]);
+		expect(harness.seen.commands).toEqual([]);
+		expect(harness.seen.handoffStatus).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({
+					state: "ignored-superseded",
+					scheduleId: "workQueue:q:w1:lease:lease-1:expires:3",
+					currentState: "leased",
+				}),
+			]),
+		);
+	});
+
+	it("ignores terminal work and treats overdue as visibility-only status", () => {
+		const harness = createHandoffHarness({ includeLeaseCommands: true });
+
+		harness.records.down([
+			["DATA", workScheduled({ recordSeq: 6, notBeforeMs: 100 })],
+			["DATA", terminalRecord("work-completed", 7)],
+		]);
+		harness.ready.down([["DATA", ready("workQueue:q:w1:schedule:6", 100)]]);
+		harness.overdue.down([["DATA", overdue("workQueue:q:w1:schedule:6", 100, 90)]]);
+
+		expect(harness.seen.candidates).toEqual([]);
+		expect(harness.seen.commands).toEqual([]);
+		expect(harness.seen.handoffStatus).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({
+					state: "ignored-superseded",
+					currentState: "completed",
+					metadata: expect.objectContaining({ latestRecordSeq: 7 }),
+				}),
+				expect.objectContaining({
+					state: "overdue",
+					scheduleId: "workQueue:q:w1:schedule:6",
+				}),
+			]),
+		);
+		expect(JSON.stringify(harness.seen)).not.toContain("cancel");
+		expect(JSON.stringify(harness.seen)).not.toContain("fail");
+	});
+
+	it("handles out-of-order ready before origin records deterministically", () => {
+		const harness = createHandoffHarness();
+
+		harness.ready.down([["DATA", ready("workQueue:q:w1:schedule:8", 800)]]);
+		expect(harness.seen.candidates).toEqual([]);
+		expect(harness.seen.handoffStatus).toEqual([
+			expect.objectContaining({
+				state: "pending-origin",
+				scheduleId: "workQueue:q:w1:schedule:8",
+			}),
+		]);
+
+		harness.records.down([["DATA", workScheduled({ recordSeq: 8, notBeforeMs: 800 })]]);
+
+		expect(harness.seen.candidates).toEqual([
+			expect.objectContaining({
+				candidateKind: "claim-eligible",
+				scheduleId: "workQueue:q:w1:schedule:8",
+			}),
+		]);
+	});
+
+	it("re-emits overdue status with origin coordinates after late origin material", () => {
+		const harness = createHandoffHarness();
+
+		harness.overdue.down([["DATA", overdue("workQueue:q:w1:schedule:9", 100, 90)]]);
+		harness.records.down([["DATA", workScheduled({ recordSeq: 9, notBeforeMs: 100 })]]);
+		harness.overdue.down([["DATA", overdue("workQueue:q:w1:schedule:9", 100, 90)]]);
+
+		expect(harness.seen.handoffStatus[0]).toEqual(
+			expect.objectContaining({
+				state: "overdue",
+				scheduleId: "workQueue:q:w1:schedule:9",
+			}),
+		);
+		expect(Object.hasOwn(harness.seen.handoffStatus[0] ?? {}, "queueId")).toBe(false);
+		expect(Object.hasOwn(harness.seen.handoffStatus[0] ?? {}, "workId")).toBe(false);
+		expect(harness.seen.handoffStatus[1]).toEqual(
+			expect.objectContaining({
+				state: "overdue",
+				scheduleId: "workQueue:q:w1:schedule:9",
+				queueId: "q",
+				workId: "w1",
+			}),
+		);
+		expect(harness.seen.candidates).toEqual([]);
+	});
+});
+
+function createHarness(opts: { readonly includeSharedReadiness?: boolean } = {}) {
+	const g = graph();
+	const records = g.node<WorkQueueRecord>([], null, { name: "work-queue-records" });
+	const translator = workQueueScheduledReadinessProjector(g, { records });
+	const clocks = opts.includeSharedReadiness
+		? g.node<ScheduledReadinessClock>([], null, { name: "work-queue-readiness-clock" })
+		: undefined;
+	const readiness =
+		clocks === undefined
+			? undefined
+			: scheduledReadinessProjector(g, {
+					schedules: [translator.readinessSchedules],
+					clocks: [clocks],
+				});
+	return {
+		records,
+		clocks,
+		seen: {
+			schedules: collectData<ScheduledReadinessRequested>(translator.readinessSchedules),
+			status: collectData<WorkQueueScheduledReadinessStatus>(translator.status),
+			issues: collectData<DataIssue>(translator.issues),
+			audit: collectData<{ readonly kind: string }>(translator.audit),
+			views: collectData<WorkQueueScheduledReadinessViews>(translator.views),
+			ready: readiness === undefined ? [] : collectData<ScheduledReadinessReady>(readiness.ready),
+			overdue:
+				readiness === undefined ? [] : collectData<ScheduledReadinessOverdue>(readiness.overdue),
+		},
+	};
+}
+
+function createHandoffHarness(opts: { readonly includeLeaseCommands?: boolean } = {}) {
+	const g = graph();
+	const records = g.node<WorkQueueRecord>([], null, { name: "work-queue-handoff-records" });
+	const readyNode = g.node<ScheduledReadinessReady>([], null, {
+		name: "work-queue-handoff-ready",
+	});
+	const overdueNode = g.node<ScheduledReadinessOverdue>([], null, {
+		name: "work-queue-handoff-overdue",
+	});
+	const handoff = workQueueReadinessHandoffProjector(g, {
+		records,
+		ready: readyNode,
+		overdue: overdueNode,
+	});
+	const leaseCommands = opts.includeLeaseCommands
+		? workQueueLeaseExpirationCommandProjector(g, { candidates: handoff.candidates })
+		: undefined;
+	return {
+		records,
+		ready: readyNode,
+		overdue: overdueNode,
+		seen: {
+			candidates: collectData<WorkQueueReadinessCandidate>(handoff.candidates),
+			handoffStatus: collectData<WorkQueueReadinessHandoffStatus>(handoff.status),
+			handoffViews: collectData<WorkQueueReadinessHandoffViews>(handoff.views),
+			commands:
+				leaseCommands === undefined ? [] : collectData<WorkQueueCommand>(leaseCommands.commands),
+			commandStatus:
+				leaseCommands === undefined
+					? []
+					: collectData<WorkQueueReadinessHandoffStatus>(leaseCommands.status),
+		},
+	};
+}
+
+function workAdmitted(
+	fields: Partial<Extract<WorkQueueRecord, { kind: "work-admitted" }>> = {},
+): WorkQueueRecord {
+	return {
+		kind: "work-admitted",
+		queueId: "q",
+		workId: "w1",
+		recordSeq: 1,
+		payload: { id: "payload" },
+		messageBus: { topic: "work", seq: 1, subscriptionId: "q-admit" },
+		recordedAtMs: 0,
+		...fields,
+	};
+}
+
+function workScheduled(
+	fields: Partial<Extract<WorkQueueRecord, { kind: "work-scheduled" }>> = {},
+): WorkQueueRecord {
+	return {
+		kind: "work-scheduled",
+		queueId: "q",
+		workId: "w1",
+		recordSeq: 1,
+		notBeforeMs: 100,
+		recordedAtMs: 0,
+		...fields,
+	};
+}
+
+function retryScheduled(
+	fields: Partial<Extract<WorkQueueRecord, { kind: "retry-scheduled" }>> = {},
+): WorkQueueRecord {
+	return {
+		kind: "retry-scheduled",
+		queueId: "q",
+		workId: "w1",
+		recordSeq: 1,
+		retryAtMs: 100,
+		delayMs: 100,
+		recordedAtMs: 0,
+		...fields,
+	};
+}
+
+function workClaimed(
+	fields: Partial<Extract<WorkQueueRecord, { kind: "work-claimed" }>> = {},
+): WorkQueueRecord {
+	return {
+		kind: "work-claimed",
+		queueId: "q",
+		workId: "w1",
+		recordSeq: 1,
+		leaseId: "lease-1",
+		attempt: 1,
+		workerId: "worker",
+		claimedAtMs: 0,
+		leaseExpiresAtMs: 100,
+		recordedAtMs: 0,
+		...fields,
+	};
+}
+
+function leaseRenewed(
+	fields: Partial<Extract<WorkQueueRecord, { kind: "lease-renewed" }>> = {},
+): WorkQueueRecord {
+	return {
+		kind: "lease-renewed",
+		queueId: "q",
+		workId: "w1",
+		recordSeq: 1,
+		leaseId: "lease-1",
+		attempt: 1,
+		workerId: "worker",
+		previousLeaseExpiresAtMs: 50,
+		leaseExpiresAtMs: 100,
+		renewedAtMs: 0,
+		recordedAtMs: 0,
+		...fields,
+	};
+}
+
+function terminalRecord(
+	kind: "work-canceled" | "work-completed" | "work-dead-lettered",
+	recordSeq: number,
+	fields: Partial<Extract<WorkQueueRecord, { kind: typeof kind }>> = {},
+): WorkQueueRecord {
+	if (kind === "work-canceled") {
+		return {
+			kind,
+			queueId: "q",
+			workId: "w1",
+			recordSeq,
+			canceledAtMs: 10,
+			recordedAtMs: 10,
+			...fields,
+		};
+	}
+	if (kind === "work-completed") {
+		return {
+			kind,
+			queueId: "q",
+			workId: "w1",
+			recordSeq,
+			leaseId: "lease-1",
+			attempt: 1,
+			workerId: "worker",
+			recordedAtMs: 10,
+			...fields,
+		};
+	}
+	return {
+		kind,
+		queueId: "q",
+		workId: "w1",
+		recordSeq,
+		reason: "attempts-exhausted",
+		recordedAtMs: 10,
+		...fields,
+	};
+}
+
+function clock(nowMs: number): ScheduledReadinessClock {
+	return {
+		kind: "scheduled-readiness-clock",
+		clockId: "work-queue-test-clock",
+		nowMs,
+		sourceRefs: [{ kind: "clock", id: "work-queue-test-clock" }],
+	};
+}
+
+function ready(scheduleId: string, readyAtMs: number): ScheduledReadinessReady {
+	return {
+		kind: "scheduled-readiness-ready",
+		scheduleId,
+		subjectRefs: [{ kind: "work-queue-work", id: "w1" }],
+		readyAtMs,
+		nowMs: readyAtMs,
+		sourceRefs: [{ kind: "scheduled-readiness", id: scheduleId }],
+	};
+}
+
+function overdue(
+	scheduleId: string,
+	readyAtMs: number,
+	deadlineMs: number,
+): ScheduledReadinessOverdue {
+	return {
+		kind: "scheduled-readiness-overdue",
+		scheduleId,
+		subjectRefs: [{ kind: "work-queue-work", id: "w1" }],
+		readyAtMs,
+		deadlineMs,
+		nowMs: readyAtMs,
+		sourceRefs: [{ kind: "scheduled-readiness", id: scheduleId }],
+	};
+}
+
+function collectData<T>(node: {
+	subscribe(sink: (msg: readonly [string, unknown?]) => void): unknown;
+}): T[] {
+	const out: T[] = [];
+	node.subscribe((msg) => {
+		if (msg[0] === "DATA") out.push(msg[1] as T);
+	});
+	return out;
+}
diff --git a/packages/ts/src/__tests__/work-queue.test.ts b/packages/ts/src/__tests__/work-queue.test.ts
new file mode 100644
index 00000000..443dfdb8
--- /dev/null
+++ b/packages/ts/src/__tests__/work-queue.test.ts
@@ -0,0 +1,537 @@
+import { describe, expect, it } from "vitest";
+import { graph } from "../graph/graph.js";
+import { messageBus } from "../messaging/index.js";
+import { workQueue } from "../work-queue/index.js";
+
+describe("workQueue messageBus-backed lifecycle (D299-D324/D325)", () => {
+	it("admits submitted work through messageBus and advances ingestion ack after durable record", () => {
+		const g = graph();
+		const now = 100;
+		const bus = messageBus(g, { topics: ["work"], name: "bus", now: () => now });
+		const queue = workQueue<{ id: string }>(g, {
+			queueId: "q",
+			bus,
+			topic: "work",
+			subscriptionId: "q-admit",
+			now: () => now,
+		});
+		const records: unknown[] = [];
+		const cursor: unknown[] = [];
+		queue.records.subscribe((msg) => records.push(msg));
+		bus
+			.subscription({ topic: "work", subscriptionId: "q-admit" })
+			.cursor.subscribe((msg) => cursor.push(msg));
+
+		queue.submit({ id: "a" });
+
+		expect(records).toContainEqual([
+			"DATA",
+			expect.objectContaining({
+				kind: "work-admitted",
+				queueId: "q",
+				workId: "q:work:1",
+				payload: { id: "a" },
+				messageBus: { topic: "work", seq: 1, subscriptionId: "q-admit" },
+			}),
+		]);
+		expect(cursor.at(-1)).toEqual([
+			"DATA",
+			expect.objectContaining({ topic: "work", subscriptionId: "q-admit", nextSeq: 2 }),
+		]);
+		expect(g.describe().nodes).toContainEqual(
+			expect.objectContaining({
+				id: "workQueue/q/admissionAckCommands",
+				factory: "workQueueAdmissionAckCommands",
+			}),
+		);
+	});
+
+	it("admits retained backlog through subscription.available rather than helper cache ack", () => {
+		const g = graph();
+		const bus = messageBus(g, { topics: ["work"], name: "bus", now: () => 101 });
+		bus.publish("work", { id: "before" });
+		const queue = workQueue<{ id: string }>(g, {
+			queueId: "q",
+			bus,
+			topic: "work",
+			subscriptionId: "q-admit",
+			now: () => 101,
+		});
+		const records: unknown[] = [];
+		const cursor: unknown[] = [];
+		queue.records.subscribe((msg) => records.push(msg));
+		bus
+			.subscription({ topic: "work", subscriptionId: "q-admit" })
+			.cursor.subscribe((msg) => cursor.push(msg));
+
+		expect(records).toContainEqual([
+			"DATA",
+			expect.objectContaining({
+				kind: "work-admitted",
+				workId: "q:work:1",
+				payload: { id: "before" },
+			}),
+		]);
+		expect(cursor.at(-1)).toEqual([
+			"DATA",
+			expect.objectContaining({ topic: "work", subscriptionId: "q-admit", nextSeq: 2 }),
+		]);
+	});
+
+	it("preserves non-object submit payloads while keeping helper metadata separate", () => {
+		const g = graph();
+		const bus = messageBus(g, { topics: ["work"], name: "bus", now: () => 1 });
+		const queue = workQueue<string>(g, {
+			queueId: "q",
+			bus,
+			topic: "work",
+			subscriptionId: "q-admit",
+			now: () => 1,
+		});
+		const records: unknown[] = [];
+		queue.records.subscribe((msg) => records.push(msg));
+
+		queue.submit("payload", { workId: "custom-work" });
+
+		expect(records).toContainEqual([
+			"DATA",
+			expect.objectContaining({
+				kind: "work-admitted",
+				workId: "custom-work",
+				payload: "payload",
+			}),
+		]);
+	});
+
+	it("claim races resolve by record order and stale claims emit issues", () => {
+		const g = graph();
+		const bus = messageBus(g, { topics: ["work"], name: "bus", now: () => 1 });
+		const queue = workQueue<{ id: string }>(g, {
+			queueId: "q",
+			bus,
+			topic: "work",
+			subscriptionId: "q-admit",
+			now: () => 1,
+		});
+		const records: unknown[] = [];
+		const issues: unknown[] = [];
+		queue.records.subscribe((msg) => records.push(msg));
+		queue.issues.subscribe((msg) => issues.push(msg));
+
+		queue.submit({ id: "a" });
+		queue.claim({ workerId: "w1", requestedWorkIds: ["q:work:1"], commandId: "claim-1" });
+		queue.claim({ workerId: "w2", requestedWorkIds: ["q:work:1"], commandId: "claim-2" });
+
+		expect(records).toContainEqual([
+			"DATA",
+			expect.objectContaining({ kind: "work-claimed", workId: "q:work:1", workerId: "w1" }),
+		]);
+		expect(issues.at(-1)).toEqual([
+			"DATA",
+			expect.objectContaining({ code: "already-leased", source: "workQueue" }),
+		]);
+	});
+
+	it("reports requested claim misses even when a batch partially succeeds", () => {
+		const g = graph();
+		const bus = messageBus(g, { topics: ["work"], name: "bus", now: () => 1 });
+		const queue = workQueue<{ id: string }>(g, {
+			queueId: "q",
+			bus,
+			topic: "work",
+			subscriptionId: "q-admit",
+			now: () => 1,
+		});
+		const records: unknown[] = [];
+		const issues: unknown[] = [];
+		queue.records.subscribe((msg) => records.push(msg));
+		queue.issues.subscribe((msg) => issues.push(msg));
+
+		queue.submit({ id: "a" });
+		queue.claim({
+			workerId: "w1",
+			requestedWorkIds: ["q:work:1", "missing"],
+			commandId: "claim-partial",
+		});
+
+		expect(records).toContainEqual([
+			"DATA",
+			expect.objectContaining({ kind: "work-claimed", workId: "q:work:1" }),
+		]);
+		expect(issues).toContainEqual([
+			"DATA",
+			expect.objectContaining({ code: "unknown-work", source: "workQueue" }),
+		]);
+	});
+
+	it("renews, releases, reclaims, completes, and rejects stale lease callbacks", () => {
+		const g = graph();
+		const now = 10;
+		const bus = messageBus(g, { topics: ["work"], name: "bus", now: () => now });
+		const queue = workQueue<{ id: string }>(g, {
+			queueId: "q",
+			bus,
+			topic: "work",
+			subscriptionId: "q-admit",
+			now: () => now,
+			leaseDurationMs: 10,
+		});
+		const records: unknown[] = [];
+		const issues: unknown[] = [];
+		queue.records.subscribe((msg) => records.push(msg));
+		queue.issues.subscribe((msg) => issues.push(msg));
+
+		queue.submit({ id: "a" });
+		queue.claim({ workerId: "w1", commandId: "claim-1" });
+		queue.renewLease({
+			workId: "q:work:1",
+			leaseId: "q:work:1:lease:1",
+			attempt: 1,
+			workerId: "w1",
+			commandId: "renew-1",
+			leaseDurationMs: 20,
+		});
+		queue.release({
+			workId: "q:work:1",
+			leaseId: "q:work:1:lease:1",
+			attempt: 1,
+			workerId: "w1",
+			commandId: "release-1",
+		});
+		queue.claim({ workerId: "w2", commandId: "claim-2" });
+		queue.complete({
+			workId: "q:work:1",
+			leaseId: "q:work:1:lease:2",
+			attempt: 2,
+			workerId: "w2",
+			commandId: "complete-1",
+			result: { ok: true },
+		});
+		queue.fail({
+			workId: "q:work:1",
+			leaseId: "q:work:1:lease:2",
+			attempt: 2,
+			workerId: "w2",
+			commandId: "fail-stale",
+		});
+
+		expect(records).toContainEqual([
+			"DATA",
+			expect.objectContaining({ kind: "lease-renewed", leaseExpiresAtMs: 30 }),
+		]);
+		expect(records).toContainEqual([
+			"DATA",
+			expect.objectContaining({ kind: "work-released", workId: "q:work:1" }),
+		]);
+		expect(records).toContainEqual([
+			"DATA",
+			expect.objectContaining({ kind: "work-completed", result: { ok: true } }),
+		]);
+		expect(issues.at(-1)).toEqual(["DATA", expect.objectContaining({ code: "terminal-work" })]);
+	});
+
+	it("dedupes lifecycle commands by idempotencyKey", () => {
+		const g = graph();
+		const bus = messageBus(g, { topics: ["work"], name: "bus", now: () => 0 });
+		const queue = workQueue<{ id: string }>(g, {
+			queueId: "q",
+			bus,
+			topic: "work",
+			subscriptionId: "q-admit",
+			now: () => 0,
+		});
+		const records: unknown[] = [];
+		const issues: unknown[] = [];
+		queue.records.subscribe((msg) => records.push(msg));
+		queue.issues.subscribe((msg) => issues.push(msg));
+
+		queue.submit({ id: "a" });
+		queue.claim({ workerId: "w1", commandId: "claim-1", idempotencyKey: "idem-claim" });
+		queue.claim({ workerId: "w2", commandId: "claim-2", idempotencyKey: "idem-claim" });
+
+		expect(
+			records.filter(
+				(msg) => msg[0] === "DATA" && (msg[1] as { kind?: string }).kind === "work-claimed",
+			),
+		).toHaveLength(1);
+		expect(issues).toContainEqual([
+			"DATA",
+			expect.objectContaining({ code: "duplicate-command", source: "workQueue" }),
+		]);
+	});
+
+	it("expires leases through explicit maintenance, then makes work claimable again", () => {
+		const g = graph();
+		let now = 0;
+		const bus = messageBus(g, { topics: ["work"], name: "bus", now: () => now });
+		const queue = workQueue<{ id: string }>(g, {
+			queueId: "q",
+			bus,
+			topic: "work",
+			subscriptionId: "q-admit",
+			now: () => now,
+			leaseDurationMs: 5,
+		});
+		const records: unknown[] = [];
+		queue.records.subscribe((msg) => records.push(msg));
+
+		queue.submit({ id: "a" });
+		queue.claim({ workerId: "w1", commandId: "claim-1" });
+		now = 6;
+		queue.expireLeases({ commandId: "expire-1" });
+		queue.claim({ workerId: "w2", commandId: "claim-2" });
+
+		expect(records).toContainEqual([
+			"DATA",
+			expect.objectContaining({ kind: "lease-expired", leaseId: "q:work:1:lease:1" }),
+		]);
+		expect(records).toContainEqual([
+			"DATA",
+			expect.objectContaining({
+				kind: "work-claimed",
+				leaseId: "q:work:1:lease:2",
+				workerId: "w2",
+			}),
+		]);
+	});
+
+	it("materializes lease expiration before stale lifecycle commands or reclaim", () => {
+		const g = graph();
+		let now = 0;
+		const bus = messageBus(g, { topics: ["work"], name: "bus", now: () => now });
+		const queue = workQueue<{ id: string }>(g, {
+			queueId: "q",
+			bus,
+			topic: "work",
+			subscriptionId: "q-admit",
+			now: () => now,
+			leaseDurationMs: 5,
+		});
+		const records: unknown[] = [];
+		const issues: unknown[] = [];
+		queue.records.subscribe((msg) => records.push(msg));
+		queue.issues.subscribe((msg) => issues.push(msg));
+
+		queue.submit({ id: "a" });
+		queue.claim({ workerId: "w1", commandId: "claim-1" });
+		now = 6;
+		queue.complete({
+			workId: "q:work:1",
+			leaseId: "q:work:1:lease:1",
+			attempt: 1,
+			workerId: "w1",
+			commandId: "complete-expired",
+		});
+		queue.claim({ workerId: "w2", commandId: "claim-2" });
+
+		expect(records).toContainEqual([
+			"DATA",
+			expect.objectContaining({ kind: "lease-expired", commandId: "complete-expired" }),
+		]);
+		expect(issues).toContainEqual(["DATA", expect.objectContaining({ code: "lease-expired" })]);
+		expect(records).toContainEqual([
+			"DATA",
+			expect.objectContaining({ kind: "work-claimed", workerId: "w2" }),
+		]);
+	});
+
+	it("fail emits retry-scheduled or work-dead-lettered disposition", () => {
+		const g = graph();
+		let now = 0;
+		const bus = messageBus(g, { topics: ["work"], name: "bus", now: () => now });
+		const queue = workQueue<{ id: string }>(g, {
+			queueId: "q",
+			bus,
+			topic: "work",
+			subscriptionId: "q-admit",
+			now: () => now,
+			retry: { maxAttempts: 2, delayMs: 5 },
+		});
+		const records: unknown[] = [];
+		queue.records.subscribe((msg) => records.push(msg));
+
+		queue.submit({ id: "a" });
+		queue.claim({ workerId: "w1", commandId: "claim-1" });
+		queue.fail({
+			workId: "q:work:1",
+			leaseId: "q:work:1:lease:1",
+			attempt: 1,
+			workerId: "w1",
+			commandId: "fail-1",
+		});
+		now = 6;
+		queue.claim({ workerId: "w2", commandId: "claim-2" });
+		queue.fail({
+			workId: "q:work:1",
+			leaseId: "q:work:1:lease:2",
+			attempt: 2,
+			workerId: "w2",
+			commandId: "fail-2",
+		});
+
+		expect(records).toContainEqual([
+			"DATA",
+			expect.objectContaining({ kind: "retry-scheduled", retryAtMs: 5 }),
+		]);
+		expect(records).toContainEqual([
+			"DATA",
+			expect.objectContaining({ kind: "work-dead-lettered", reason: "attempts-exhausted" }),
+		]);
+	});
+
+	it("terminal work projections do not expose an active lease", () => {
+		const g = graph();
+		const bus = messageBus(g, { topics: ["work"], name: "bus", now: () => 0 });
+		const queue = workQueue<{ id: string }>(g, {
+			queueId: "q",
+			bus,
+			topic: "work",
+			subscriptionId: "q-admit",
+			now: () => 0,
+		});
+
+		queue.submit({ id: "a" });
+		queue.claim({ workerId: "w1", commandId: "claim-1" });
+		queue.complete({
+			workId: "q:work:1",
+			leaseId: "q:work:1:lease:1",
+			attempt: 1,
+			workerId: "w1",
+			commandId: "complete-1",
+		});
+		const work = queue.work("q:work:1");
+		work.snapshot.up([["PULL", { pullId: work.snapshotPullId }]]);
+
+		expect(work.snapshot.cache).toEqual(expect.objectContaining({ state: "completed" }));
+		expect(work.snapshot.cache?.activeLease).toBeUndefined();
+	});
+
+	it("schedule/cancel and read-only projections do not mutate queue state", () => {
+		const g = graph();
+		const now = 0;
+		const bus = messageBus(g, { topics: ["work"], name: "bus", now: () => now });
+		const queue = workQueue<{ id: string }>(g, {
+			queueId: "q",
+			bus,
+			topic: "work",
+			subscriptionId: "q-admit",
+			now: () => now,
+		});
+		queue.submit({ id: "a" });
+		queue.schedule({ workId: "q:work:1", notBeforeMs: 10, commandId: "schedule-1" });
+		const available = queue.available();
+		const work = queue.work("q:work:1");
+		const dead = queue.deadLetter();
+
+		available.available.up([["PULL", { pullId: available.availablePullId, params: { nowMs: 0 } }]]);
+		work.snapshot.up([["PULL", { pullId: work.snapshotPullId }]]);
+		dead.snapshot.up([["PULL", { pullId: dead.snapshotPullId }]]);
+
+		expect(available.available.cache).toEqual(
+			expect.objectContaining({ items: [], asOfRecordSeq: 2 }),
+		);
+		expect(work.snapshot.cache).toEqual(
+			expect.objectContaining({ workId: "q:work:1", state: "scheduled" }),
+		);
+		expect(dead.snapshot.cache).toEqual(expect.objectContaining({ entries: [] }));
+
+		queue.cancel({ workId: "q:work:1", commandId: "cancel-1", reason: "user" });
+		expect(work.snapshot.cache?.state).toBe("scheduled");
+		work.snapshot.up([["PULL", { pullId: work.snapshotPullId }]]);
+		expect(work.snapshot.cache?.state).toBe("canceled");
+	});
+
+	it("uses explicit command/projection time for delayed eligibility", () => {
+		const g = graph();
+		const bus = messageBus(g, { topics: ["work"], name: "bus", now: () => 0 });
+		const queue = workQueue<{ id: string }>(g, {
+			queueId: "q",
+			bus,
+			topic: "work",
+			subscriptionId: "q-admit",
+			now: () => 0,
+		});
+		const records: unknown[] = [];
+		const issues: unknown[] = [];
+		queue.records.subscribe((msg) => records.push(msg));
+		queue.issues.subscribe((msg) => issues.push(msg));
+
+		queue.submit({ id: "later" }, { notBeforeMs: 10 });
+		queue.claim({ workerId: "early", commandId: "claim-early" });
+		const available = queue.available();
+		available.available.up([["PULL", { pullId: available.availablePullId }]]);
+		expect(issues).toContainEqual(["DATA", expect.objectContaining({ code: "not-ready" })]);
+		expect(available.available.cache?.items).toEqual([]);
+
+		available.available.up([
+			["PULL", { pullId: available.availablePullId, params: { nowMs: 10 } }],
+		]);
+		expect(available.available.cache?.items.map((item) => item.workId)).toEqual(["q:work:1"]);
+		queue.claim({ workerId: "on-time", commandId: "claim-on-time", nowMs: 10 });
+
+		expect(records).toContainEqual([
+			"DATA",
+			expect.objectContaining({ kind: "work-claimed", workerId: "on-time" }),
+		]);
+	});
+
+	it("rejects malformed and wrong-queue command facts without mutating lifecycle state", () => {
+		const g = graph();
+		const bus = messageBus(g, { topics: ["work"], name: "bus", now: () => 0 });
+		const queue = workQueue<{ id: string }>(g, {
+			queueId: "q",
+			bus,
+			topic: "work",
+			subscriptionId: "q-admit",
+			now: () => 0,
+		});
+		const issues: unknown[] = [];
+		const records: unknown[] = [];
+		queue.issues.subscribe((msg) => issues.push(msg));
+		queue.records.subscribe((msg) => records.push(msg));
+
+		queue.commands.down([
+			["DATA", { kind: "bogus", commandId: "bad-1" } as never],
+			["DATA", { kind: "cancel", commandId: "bad-2", queueId: "other", workId: "x" } as never],
+		]);
+
+		expect(issues).toContainEqual([
+			"DATA",
+			expect.objectContaining({ code: "malformed-command", source: "workQueue" }),
+		]);
+		expect(issues).toContainEqual([
+			"DATA",
+			expect.objectContaining({ code: "queue-mismatch", source: "workQueue" }),
+		]);
+		expect(records.filter((msg) => msg[0] === "DATA")).toEqual([]);
+	});
+
+	it("available pagination can use admissionSeq without workId sort skips", () => {
+		const g = graph();
+		const bus = messageBus(g, { topics: ["work"], name: "bus", now: () => 0 });
+		const queue = workQueue<{ id: string }>(g, {
+			queueId: "q",
+			bus,
+			topic: "work",
+			subscriptionId: "q-admit",
+			now: () => 0,
+		});
+		queue.submit({ id: "first" }, { workId: "z" });
+		queue.submit({ id: "second" }, { workId: "a" });
+		const available = queue.available();
+
+		available.available.up([["PULL", { pullId: available.availablePullId, params: { limit: 1 } }]]);
+		const nextAfterAdmissionSeq = available.available.cache?.nextAfterAdmissionSeq;
+		available.available.up([
+			[
+				"PULL",
+				{
+					pullId: available.availablePullId,
+					params: { limit: 1, afterAdmissionSeq: nextAfterAdmissionSeq },
+				},
+			],
+		]);
+
+		expect(available.available.cache?.items.map((item) => item.workId)).toEqual(["a"]);
+	});
+});
diff --git a/packages/ts/src/__tests__/worker.test.ts b/packages/ts/src/__tests__/worker.test.ts
new file mode 100644
index 00000000..950cebae
--- /dev/null
+++ b/packages/ts/src/__tests__/worker.test.ts
@@ -0,0 +1,327 @@
+import { describe, expect, it } from "vitest";
+import { depBatch } from "../ctx/types.js";
+import { graph } from "../graph/graph.js";
+import { type WorkerDerivedJob, type WorkerDerivedSettle, workerDerived } from "../graph/worker.js";
+
+interface CapturedWorker<TInput, TResult> {
+	readonly job: WorkerDerivedJob<TInput, TResult>;
+	readonly settle: WorkerDerivedSettle<TResult>;
+}
+
+describe("workerDerived — backend-required helper-first worker slice (D148)", () => {
+	it("prepares owned input on the graph thread and emits backend completion as a later wave", () => {
+		const g = graph();
+		const src = g.state(0, { name: "src" });
+		const jobs: CapturedWorker<number, number>[] = [];
+		const doubled = workerDerived<number, number>(g, [src], {
+			name: "worker/doubled",
+			prepare(ctx) {
+				const batch = depBatch(ctx, 0);
+				const value = batch === null ? undefined : (batch.at(-1) as number | undefined);
+				return value === 0 ? undefined : value;
+			},
+			compute(input) {
+				return input * 2;
+			},
+			backend: {
+				run(job, settle) {
+					jobs.push({ job, settle });
+				},
+			},
+		});
+		const seen: unknown[] = [];
+		doubled.subscribe((msg) => seen.push(msg));
+
+		src.set(2);
+		expect(jobs).toHaveLength(1);
+		expect(seen).not.toContainEqual(["DATA", 4]);
+
+		jobs[0].settle({ ok: true, value: jobs[0].job.compute(jobs[0].job.input) });
+		expect(seen).toContainEqual(["DATA", 4]);
+		expect(g.describe().edges).toContainEqual({ from: "src", to: "worker/doubled" });
+	});
+
+	it("fences stale completions and prepare-empty waves before graph mutation", () => {
+		const g = graph();
+		const src = g.state(0, { name: "src" });
+		const jobs: CapturedWorker<number, number>[] = [];
+		const worker = workerDerived<number, number>(g, [src], {
+			name: "worker",
+			prepare(ctx) {
+				const value = depBatch(ctx, 0)?.at(-1) as number | undefined;
+				return value === 0 ? undefined : value;
+			},
+			compute(input) {
+				return input * 10;
+			},
+			backend: {
+				run(job, settle) {
+					jobs.push({ job, settle });
+				},
+			},
+		});
+		const seen: unknown[] = [];
+		worker.subscribe((msg) => seen.push(msg));
+
+		src.set(1);
+		src.set(2);
+		jobs[0].settle({ ok: true, value: jobs[0].job.compute(jobs[0].job.input) });
+		expect(seen).not.toContainEqual(["DATA", 10]);
+
+		jobs[1].settle({ ok: true, value: jobs[1].job.compute(jobs[1].job.input) });
+		expect(seen).toContainEqual(["DATA", 20]);
+
+		src.set(3);
+		src.set(0);
+		jobs[2].settle({ ok: true, value: jobs[2].job.compute(jobs[2].job.input) });
+		expect(seen).not.toContainEqual(["DATA", 30]);
+	});
+
+	it("rejects synchronous backend completion instead of mutating graph as worker output", () => {
+		const g = graph();
+		const src = g.state(1, { name: "src" });
+		const worker = workerDerived<number, number>(g, [src], {
+			name: "worker",
+			prepare(ctx) {
+				const value = depBatch(ctx, 0)?.at(-1) as number | undefined;
+				return value === 0 ? undefined : value;
+			},
+			compute(input) {
+				return input + 1;
+			},
+			backend: {
+				run(job, settle) {
+					settle({ ok: true, value: job.compute(job.input) });
+				},
+			},
+		});
+		const seen: unknown[] = [];
+		worker.subscribe((msg) => seen.push(msg));
+
+		src.set(2);
+
+		expect(seen).not.toContainEqual(["DATA", 3]);
+		expect(seen).toContainEqual([
+			"ERROR",
+			expect.objectContaining({
+				message: "workerDerived: backend completions must arrive after backend.run returns",
+			}),
+		]);
+	});
+
+	it("closes a synchronously misused settlement so later backend calls cannot emit DATA", () => {
+		const g = graph();
+		const src = g.state(1, { name: "src" });
+		let captured: WorkerDerivedSettle<number> | undefined;
+		const worker = workerDerived<number, number>(g, [src], {
+			name: "worker",
+			prepare(ctx) {
+				const value = depBatch(ctx, 0)?.at(-1) as number | undefined;
+				return value === 0 ? undefined : value;
+			},
+			compute(input) {
+				return input + 1;
+			},
+			backend: {
+				run(job, settle) {
+					captured = settle;
+					try {
+						settle({ ok: true, value: job.compute(job.input) });
+					} catch {
+						// Backend misuse may catch the synchronous guard; the helper still closes it.
+					}
+				},
+			},
+		});
+		const seen: unknown[] = [];
+		worker.subscribe((msg) => seen.push(msg));
+
+		src.set(2);
+		captured?.({ ok: true, value: 3 });
+
+		expect(seen).toContainEqual([
+			"ERROR",
+			expect.objectContaining({
+				message: "workerDerived: backend completions must arrive after backend.run returns",
+			}),
+		]);
+		expect(seen).not.toContainEqual(["DATA", 3]);
+	});
+
+	it("does not retain or cancel an already accepted backend completion", () => {
+		const g = graph();
+		const src = g.state(0, { name: "src" });
+		let canceled = 0;
+		let captured: CapturedWorker<number, number> | undefined;
+		const worker = workerDerived<number, number>(g, [src], {
+			name: "worker",
+			prepare(ctx) {
+				const value = depBatch(ctx, 0)?.at(-1) as number | undefined;
+				return value === 0 ? undefined : value;
+			},
+			compute(input) {
+				return input;
+			},
+			backend: {
+				run(job, settle) {
+					captured = { job, settle };
+					return () => {
+						canceled += 1;
+					};
+				},
+			},
+		});
+		const seen: unknown[] = [];
+		worker.subscribe((msg) => seen.push(msg));
+
+		src.set(1);
+		captured?.settle({ ok: true, value: 1 });
+		src.set(2);
+
+		expect(seen).toContainEqual(["DATA", 1]);
+		expect(canceled).toBe(0);
+	});
+
+	it("cooperatively cancels superseded backend jobs", () => {
+		const g = graph();
+		const src = g.state(0, { name: "src" });
+		let canceled = 0;
+		const worker = workerDerived<number, number>(g, [src], {
+			name: "worker",
+			prepare(ctx) {
+				return depBatch(ctx, 0)?.at(-1) as number | undefined;
+			},
+			compute(input) {
+				return input;
+			},
+			backend: {
+				run() {
+					return () => {
+						canceled += 1;
+					};
+				},
+			},
+		});
+		worker.subscribe(() => undefined);
+
+		src.set(1);
+		src.set(2);
+		src.set(0);
+
+		expect(canceled).toBeGreaterThanOrEqual(2);
+	});
+
+	it("routes prepare errors as graph ERROR and does not submit a backend job", () => {
+		const g = graph();
+		const src = g.state(1, { name: "src" });
+		let submitted = false;
+		const worker = workerDerived<number, number>(g, [src], {
+			name: "worker",
+			prepare() {
+				throw new Error("prepare failed");
+			},
+			compute(input) {
+				return input + 1;
+			},
+			backend: {
+				run() {
+					submitted = true;
+				},
+			},
+		});
+		const seen: unknown[] = [];
+		worker.subscribe((msg) => seen.push(msg));
+
+		src.set(2);
+
+		expect(submitted).toBe(false);
+		expect(seen).toContainEqual(["ERROR", expect.objectContaining({ message: "prepare failed" })]);
+	});
+
+	it("passes a cloned owned input to the backend", () => {
+		const g = graph();
+		const src = g.state({ count: 1 }, { name: "src" });
+		const inputs: { count: number }[] = [];
+		const worker = workerDerived<{ count: number }, number>(g, [src], {
+			name: "worker",
+			prepare(ctx) {
+				return depBatch(ctx, 0)?.at(-1) as { count: number } | undefined;
+			},
+			compute(input) {
+				return input.count;
+			},
+			backend: {
+				run(job) {
+					inputs.push(job.input);
+				},
+			},
+		});
+		worker.subscribe(() => undefined);
+
+		const next = { count: 2 };
+		src.set(next);
+
+		expect(inputs.at(-1)).toEqual(next);
+		expect(inputs.at(-1)).not.toBe(next);
+	});
+
+	it("rejects non-cloneable worker inputs before backend submission", () => {
+		const g = graph();
+		const src = g.state(0, { name: "src" });
+		let submitted = false;
+		const worker = workerDerived<() => number, number>(g, [src], {
+			name: "worker",
+			prepare() {
+				return () => 1;
+			},
+			compute(input) {
+				return input();
+			},
+			backend: {
+				run() {
+					submitted = true;
+				},
+			},
+		});
+		const seen: unknown[] = [];
+		worker.subscribe((msg) => seen.push(msg));
+
+		src.set(1);
+
+		expect(submitted).toBe(false);
+		expect(seen).toContainEqual([
+			"ERROR",
+			expect.objectContaining({ message: "workerDerived: input must be owned and cloneable" }),
+		]);
+	});
+
+	it("rejects symbol worker inputs before backend submission", () => {
+		const g = graph();
+		const src = g.state(0, { name: "src" });
+		let submitted = false;
+		const worker = workerDerived<symbol, number>(g, [src], {
+			name: "worker",
+			prepare() {
+				return Symbol("not-cloneable");
+			},
+			compute() {
+				return 1;
+			},
+			backend: {
+				run() {
+					submitted = true;
+				},
+			},
+		});
+		const seen: unknown[] = [];
+		worker.subscribe((msg) => seen.push(msg));
+
+		src.set(1);
+
+		expect(submitted).toBe(false);
+		expect(seen).toContainEqual([
+			"ERROR",
+			expect.objectContaining({ message: "workerDerived: input must be owned and cloneable" }),
+		]);
+	});
+});
diff --git a/packages/ts/src/adapters/agentic-memory-storage.ts b/packages/ts/src/adapters/agentic-memory-storage.ts
new file mode 100644
index 00000000..947c0eee
--- /dev/null
+++ b/packages/ts/src/adapters/agentic-memory-storage.ts
@@ -0,0 +1,614 @@
+import type { DeliveryMeta } from "../ctx/types.js";
+import { assertGraphLocalNode, type Graph, type StateNode } from "../graph/graph.js";
+import type { Node } from "../node/node.js";
+import type { Message } from "../protocol/messages.js";
+import {
+	type AgenticMemoryRecord,
+	type AgenticMemoryRecordFrame,
+	type AgenticMemoryStrictJsonValue,
+	agenticMemoryRecordCodec,
+	agenticMemoryRecordFrame,
+	agenticMemoryRecordFrameCodec,
+	assertAgenticMemoryRecordFrame,
+} from "../solutions/index.js";
+import type { AppendLogEntry, AppendLogStorageTier, KvStorageTier } from "../storage/index.js";
+
+export const AGENTIC_MEMORY_RECORD_SNAPSHOT_FORMAT =
+	"graphrefly.agenticMemory.records.snapshot" as const;
+export const AGENTIC_MEMORY_RECORD_CHANGE_FORMAT =
+	"graphrefly.agenticMemory.records.change" as const;
+export const AGENTIC_MEMORY_RECORD_STORAGE_FRAME_VERSION = 1 as const;
+
+export interface AgenticMemoryRecordSnapshotFrame<
+	TJson extends AgenticMemoryStrictJsonValue = AgenticMemoryStrictJsonValue,
+> {
+	readonly format: typeof AGENTIC_MEMORY_RECORD_SNAPSHOT_FORMAT;
+	readonly version: typeof AGENTIC_MEMORY_RECORD_STORAGE_FRAME_VERSION;
+	readonly changeCursor: number;
+	readonly records: readonly AgenticMemoryRecordFrame<TJson>[];
+}
+
+export interface AgenticMemoryRecordChangeFrame<
+	TJson extends AgenticMemoryStrictJsonValue = AgenticMemoryStrictJsonValue,
+> {
+	readonly format: typeof AGENTIC_MEMORY_RECORD_CHANGE_FORMAT;
+	readonly version: typeof AGENTIC_MEMORY_RECORD_STORAGE_FRAME_VERSION;
+	readonly change: {
+		readonly kind: "replaceAll";
+		readonly records: readonly AgenticMemoryRecordFrame<TJson>[];
+	};
+}
+
+export interface AgenticMemoryRecordsRestoreState<
+	TJson extends AgenticMemoryStrictJsonValue = AgenticMemoryStrictJsonValue,
+> {
+	readonly records: readonly AgenticMemoryRecord<TJson>[];
+	readonly source: "empty" | "changes" | "snapshot" | "snapshot+changes";
+	readonly snapshot: { readonly found: boolean; readonly changeCursor: number };
+	readonly changes: { readonly applied: number; readonly cursor: number };
+}
+
+export interface LoadAgenticMemoryRecordsStateOptions {
+	readonly snapshotStore: KvStorageTier<unknown>;
+	readonly snapshotKey?: string;
+	readonly storagePrefix?: string;
+	readonly changeLog?: AppendLogStorageTier<unknown>;
+}
+
+export interface AgenticMemoryRecordsPersistenceCursor {
+	readonly kind: "persistence.cursor";
+	readonly changeSeq: number;
+	readonly snapshotWrites: number;
+	readonly changeWrites: number;
+}
+
+export interface AgenticMemoryRecordsPersistenceStatus {
+	readonly state: "starting" | "ready" | "flushing" | "errored" | "disposed";
+	readonly pending: number;
+	readonly writes: number;
+	readonly errors: number;
+	readonly cursor: AgenticMemoryRecordsPersistenceCursor;
+}
+
+export interface AgenticMemoryRecordsPersistenceError {
+	readonly phase: "snapshot" | "change";
+	readonly message: string;
+	readonly cursor: AgenticMemoryRecordsPersistenceCursor;
+}
+
+export interface PersistAgenticMemoryRecordsOptions {
+	readonly name?: string;
+	readonly snapshotStore: KvStorageTier<unknown>;
+	readonly snapshotKey?: string;
+	readonly storagePrefix?: string;
+	readonly changeLog?: AppendLogStorageTier<unknown>;
+	readonly initialChangeCursor?: number;
+	readonly snapshotOnAttach?: boolean;
+	readonly snapshotEveryChanges?: number;
+}
+
+export interface AgenticMemoryRecordsPersistenceHandle {
+	readonly ready: StateNode<boolean>;
+	readonly status: StateNode<AgenticMemoryRecordsPersistenceStatus>;
+	readonly error: StateNode<AgenticMemoryRecordsPersistenceError | null>;
+	readonly cursor: StateNode<AgenticMemoryRecordsPersistenceCursor>;
+	flush(done?: (status: AgenticMemoryRecordsPersistenceStatus) => void): void;
+	snapshot(done?: (status: AgenticMemoryRecordsPersistenceStatus) => void): void;
+	dispose(done?: (status: AgenticMemoryRecordsPersistenceStatus) => void): void;
+}
+
+export interface OpenPersistentAgenticMemoryRecordsOptions<
+	TJson extends AgenticMemoryStrictJsonValue,
+> extends LoadAgenticMemoryRecordsStateOptions,
+		Omit<
+			PersistAgenticMemoryRecordsOptions,
+			"snapshotStore" | "changeLog" | "initialChangeCursor"
+		> {
+	readonly graph: Graph;
+	readonly name?: string;
+	readonly initial?: readonly AgenticMemoryRecord<TJson>[];
+}
+
+export interface PersistentAgenticMemoryRecords<TJson extends AgenticMemoryStrictJsonValue> {
+	readonly records: StateNode<readonly AgenticMemoryRecord<TJson>[]>;
+	readonly persistence: AgenticMemoryRecordsPersistenceHandle;
+	readonly loaded: AgenticMemoryRecordsRestoreState<TJson>;
+}
+
+interface QueueItem {
+	readonly phase: "snapshot" | "change" | "flush" | "dispose";
+	readonly done?: (status: AgenticMemoryRecordsPersistenceStatus) => void;
+	run(): void | PromiseLike<void>;
+}
+
+export function agenticMemoryRecordsSnapshotKey(storagePrefix = "agentic-memory"): string {
+	if (storagePrefix.length === 0) throw new TypeError("storagePrefix must be non-empty");
+	return `${storagePrefix}/records.snapshot`;
+}
+
+export function agenticMemoryRecordSnapshotFrame<
+	TJson extends AgenticMemoryStrictJsonValue = AgenticMemoryStrictJsonValue,
+>(
+	records: readonly AgenticMemoryRecord<TJson>[],
+	opts: { readonly changeCursor?: number } = {},
+): AgenticMemoryRecordSnapshotFrame<TJson> {
+	const changeCursor = validateChangeCursor(opts.changeCursor ?? -1);
+	return assertAgenticMemoryRecordSnapshotFrame({
+		format: AGENTIC_MEMORY_RECORD_SNAPSHOT_FORMAT,
+		version: AGENTIC_MEMORY_RECORD_STORAGE_FRAME_VERSION,
+		changeCursor,
+		records: records.map((record) => agenticMemoryRecordFrame(record)),
+	});
+}
+
+export function agenticMemoryRecordChangeFrame<
+	TJson extends AgenticMemoryStrictJsonValue = AgenticMemoryStrictJsonValue,
+>(records: readonly AgenticMemoryRecord<TJson>[]): AgenticMemoryRecordChangeFrame<TJson> {
+	return assertAgenticMemoryRecordChangeFrame({
+		format: AGENTIC_MEMORY_RECORD_CHANGE_FORMAT,
+		version: AGENTIC_MEMORY_RECORD_STORAGE_FRAME_VERSION,
+		change: {
+			kind: "replaceAll",
+			records: records.map((record) => agenticMemoryRecordFrame(record)),
+		},
+	});
+}
+
+export function assertAgenticMemoryRecordSnapshotFrame<
+	TJson extends AgenticMemoryStrictJsonValue = AgenticMemoryStrictJsonValue,
+>(value: unknown): AgenticMemoryRecordSnapshotFrame<TJson> {
+	if (!isPlainRecord(value)) throw new TypeError("agentic memory snapshot frame must be an object");
+	assertKeys(
+		value,
+		["changeCursor", "format", "records", "version"],
+		"agentic memory snapshot frame",
+	);
+	if (value.format !== AGENTIC_MEMORY_RECORD_SNAPSHOT_FORMAT) {
+		throw new TypeError("agentic memory snapshot frame: invalid format");
+	}
+	if (value.version !== AGENTIC_MEMORY_RECORD_STORAGE_FRAME_VERSION) {
+		throw new TypeError("agentic memory snapshot frame: invalid version");
+	}
+	const changeCursor = validateChangeCursor(value.changeCursor);
+	if (!Array.isArray(value.records)) {
+		throw new TypeError("agentic memory snapshot frame: records must be an array");
+	}
+	const records = assertDenseRecordFrames<TJson>(
+		value.records,
+		"agentic memory snapshot frame records",
+	);
+	return Object.freeze({
+		format: AGENTIC_MEMORY_RECORD_SNAPSHOT_FORMAT,
+		version: AGENTIC_MEMORY_RECORD_STORAGE_FRAME_VERSION,
+		changeCursor,
+		records: Object.freeze(records),
+	});
+}
+
+export function assertAgenticMemoryRecordChangeFrame<
+	TJson extends AgenticMemoryStrictJsonValue = AgenticMemoryStrictJsonValue,
+>(value: unknown): AgenticMemoryRecordChangeFrame<TJson> {
+	if (!isPlainRecord(value)) throw new TypeError("agentic memory change frame must be an object");
+	assertKeys(value, ["change", "format", "version"], "agentic memory change frame");
+	if (value.format !== AGENTIC_MEMORY_RECORD_CHANGE_FORMAT) {
+		throw new TypeError("agentic memory change frame: invalid format");
+	}
+	if (value.version !== AGENTIC_MEMORY_RECORD_STORAGE_FRAME_VERSION) {
+		throw new TypeError("agentic memory change frame: invalid version");
+	}
+	if (!isPlainRecord(value.change)) {
+		throw new TypeError("agentic memory change frame: change must be an object");
+	}
+	assertKeys(value.change, ["kind", "records"], "agentic memory change frame change");
+	if (value.change.kind !== "replaceAll") {
+		throw new TypeError("agentic memory change frame: change.kind must be replaceAll");
+	}
+	if (!Array.isArray(value.change.records)) {
+		throw new TypeError("agentic memory change frame: change.records must be an array");
+	}
+	const records = assertDenseRecordFrames<TJson>(
+		value.change.records,
+		"agentic memory change frame records",
+	);
+	return Object.freeze({
+		format: AGENTIC_MEMORY_RECORD_CHANGE_FORMAT,
+		version: AGENTIC_MEMORY_RECORD_STORAGE_FRAME_VERSION,
+		change: Object.freeze({
+			kind: "replaceAll",
+			records: Object.freeze(records),
+		}),
+	});
+}
+
+export function loadAgenticMemoryRecordsState<
+	TJson extends AgenticMemoryStrictJsonValue = AgenticMemoryStrictJsonValue,
+>(opts: LoadAgenticMemoryRecordsStateOptions): Promise<AgenticMemoryRecordsRestoreState<TJson>> {
+	const storagePrefix = opts.storagePrefix ?? "agentic-memory";
+	const snapshotKey = opts.snapshotKey ?? agenticMemoryRecordsSnapshotKey(storagePrefix);
+	return opts.snapshotStore.get(snapshotKey).then((rawSnapshot) => {
+		let records: readonly AgenticMemoryRecord<TJson>[] = [];
+		let source: AgenticMemoryRecordsRestoreState<TJson>["source"] = "empty";
+		let changeCursor = -1;
+		if (rawSnapshot !== undefined) {
+			const snapshot = assertAgenticMemoryRecordSnapshotFrame<TJson>(rawSnapshot);
+			records = snapshot.records.map(recordFromFrame);
+			changeCursor = snapshot.changeCursor;
+			source = "snapshot";
+		}
+		if (opts.changeLog === undefined) {
+			return {
+				records,
+				source,
+				snapshot: { found: rawSnapshot !== undefined, changeCursor },
+				changes: { applied: 0, cursor: changeCursor },
+			};
+		}
+		return opts.changeLog.read({ after: changeCursor }).then((entries) => {
+			let applied = 0;
+			let cursor = changeCursor;
+			for (const entry of entries) {
+				if (entry.seq !== cursor + 1) {
+					throw new Error("agentic memory records change log is non-contiguous");
+				}
+				const change = assertAgenticMemoryRecordChangeFrame<TJson>(entry.value);
+				records = change.change.records.map(recordFromFrame);
+				cursor = entry.seq;
+				applied += 1;
+			}
+			return {
+				records,
+				source:
+					rawSnapshot !== undefined && applied > 0
+						? "snapshot+changes"
+						: rawSnapshot !== undefined
+							? "snapshot"
+							: applied > 0
+								? "changes"
+								: "empty",
+				snapshot: { found: rawSnapshot !== undefined, changeCursor },
+				changes: { applied, cursor },
+			};
+		});
+	});
+}
+
+export function persistAgenticMemoryRecords<
+	TJson extends AgenticMemoryStrictJsonValue = AgenticMemoryStrictJsonValue,
+>(
+	graph: Graph,
+	records: Node<readonly AgenticMemoryRecord<TJson>[]>,
+	opts: PersistAgenticMemoryRecordsOptions,
+): AgenticMemoryRecordsPersistenceHandle {
+	const name = opts.name ?? "agenticMemoryRecords.persistence";
+	const snapshotKey =
+		opts.snapshotKey ?? agenticMemoryRecordsSnapshotKey(opts.storagePrefix ?? name);
+	const snapshotEveryChanges = validateSnapshotEveryChanges(opts.snapshotEveryChanges);
+	assertGraphLocalNode(graph, records as Node<unknown>, `${name}.records`);
+	let cursorValue: AgenticMemoryRecordsPersistenceCursor = {
+		kind: "persistence.cursor",
+		changeSeq: validateChangeCursor(opts.initialChangeCursor ?? -1),
+		snapshotWrites: 0,
+		changeWrites: 0,
+	};
+	let statusValue = statusOf("starting", 0, 0, 0, cursorValue);
+	let errorCount = 0;
+	let writes = 0;
+	let running = false;
+	let disposed = false;
+	let disposeRequested = false;
+	let subscribing = true;
+	let observedChangesSinceSnapshot = 0;
+	let latestRecords: readonly AgenticMemoryRecord<TJson>[] = records.cache ?? [];
+	let stop: (() => void) | undefined;
+	const queue: QueueItem[] = [];
+	const ready = graph.state(false, { name: `${name}/ready` });
+	const status = graph.state<AgenticMemoryRecordsPersistenceStatus>(statusValue, {
+		name: `${name}/status`,
+	});
+	const error = graph.state<AgenticMemoryRecordsPersistenceError | null>(null, {
+		name: `${name}/error`,
+	});
+	const cursor = graph.state<AgenticMemoryRecordsPersistenceCursor>(cursorValue, {
+		name: `${name}/cursor`,
+	});
+
+	function publish(state: AgenticMemoryRecordsPersistenceStatus["state"]): void {
+		const nextState = statusValue.state === "errored" && state !== "disposed" ? "errored" : state;
+		statusValue = statusOf(
+			nextState,
+			queue.length + (running ? 1 : 0),
+			writes,
+			errorCount,
+			cursorValue,
+		);
+		cursor.set(cursorValue);
+		status.set(statusValue);
+		if (nextState === "ready") ready.set(true);
+		if (nextState === "errored" || nextState === "disposed") ready.set(false);
+	}
+
+	function report(phase: "snapshot" | "change", caught: unknown): void {
+		errorCount += 1;
+		error.set({ phase, message: errorMessage(caught), cursor: cursorValue });
+	}
+
+	function callDone(done: QueueItem["done"]): void {
+		try {
+			done?.(statusValue);
+		} catch {
+			// Done callbacks are advisory controls and must not wedge the adapter queue.
+		}
+	}
+
+	function finish(item: QueueItem): void {
+		if (item.phase === "dispose") {
+			disposed = true;
+			running = false;
+			publish("disposed");
+		} else if (statusValue.state !== "errored") {
+			running = false;
+			publish("ready");
+		} else {
+			running = false;
+			publish("errored");
+		}
+		callDone(item.done);
+		drain();
+	}
+
+	function fail(item: QueueItem, caught: unknown): void {
+		if (item.phase === "snapshot" || item.phase === "change") report(item.phase, caught);
+		running = false;
+		if (item.phase === "snapshot" || item.phase === "change") publish("errored");
+		callDone(item.done);
+		drain();
+	}
+
+	function chainThenable(item: QueueItem, value: unknown): boolean {
+		if ((typeof value !== "object" && typeof value !== "function") || value === null) return false;
+		const then = (value as { then?: unknown }).then;
+		if (typeof then !== "function") return false;
+		let settled = false;
+		const settle = (next: () => void) => {
+			if (settled) return;
+			settled = true;
+			next();
+		};
+		try {
+			(then as (onFulfilled: () => void, onRejected: (error: unknown) => void) => unknown).call(
+				value,
+				() => settle(() => finish(item)),
+				(caught) => settle(() => fail(item, caught)),
+			);
+		} catch (caught) {
+			settle(() => fail(item, caught));
+		}
+		return true;
+	}
+
+	function enqueue(item: QueueItem): void {
+		if (disposed || (disposeRequested && item.phase !== "dispose" && item.phase !== "flush")) {
+			callDone(item.done);
+			return;
+		}
+		queue.push(item);
+		drain();
+	}
+
+	function drain(): void {
+		if (running) return;
+		const item = queue.shift();
+		if (item === undefined) return;
+		running = true;
+		publish(
+			item.phase === "flush" ? "flushing" : statusValue.state === "starting" ? "starting" : "ready",
+		);
+		let result: void | PromiseLike<void>;
+		try {
+			result = item.run();
+		} catch (caught) {
+			fail(item, caught);
+			return;
+		}
+		if (chainThenable(item, result)) return;
+		finish(item);
+	}
+
+	function enqueueSnapshot(done?: (status: AgenticMemoryRecordsPersistenceStatus) => void): void {
+		const snapshotRecords = latestRecords;
+		observedChangesSinceSnapshot = 0;
+		enqueue({
+			phase: "snapshot",
+			done,
+			run() {
+				const records = Object.freeze(
+					snapshotRecords.map((record) => agenticMemoryRecordFrame(record)),
+				);
+				const frame = assertAgenticMemoryRecordSnapshotFrame<TJson>({
+					format: AGENTIC_MEMORY_RECORD_SNAPSHOT_FORMAT,
+					version: AGENTIC_MEMORY_RECORD_STORAGE_FRAME_VERSION,
+					changeCursor: cursorValue.changeSeq,
+					records,
+				});
+				return opts.snapshotStore.set(snapshotKey, frame).then(() => {
+					cursorValue = { ...cursorValue, snapshotWrites: cursorValue.snapshotWrites + 1 };
+					writes += 1;
+					publish("ready");
+				});
+			},
+		});
+	}
+
+	function enqueueChange(nextRecords: readonly AgenticMemoryRecord<TJson>[]): void {
+		const changeLog = opts.changeLog;
+		if (changeLog === undefined) return;
+		enqueue({
+			phase: "change",
+			run() {
+				const frame = agenticMemoryRecordChangeFrame(nextRecords);
+				return changeLog.append(frame).then((written) => {
+					const entry = written as AppendLogEntry<AgenticMemoryRecordChangeFrame<TJson>>;
+					cursorValue = {
+						...cursorValue,
+						changeSeq: entry.seq,
+						changeWrites: cursorValue.changeWrites + 1,
+					};
+					writes += 1;
+					publish("ready");
+				});
+			},
+		});
+	}
+
+	function cancelQueuedForDispose(): void {
+		const pending = queue.splice(0);
+		for (const item of pending) callDone(item.done);
+	}
+
+	stop = records.subscribe((msg: Message, delivery?: DeliveryMeta) => {
+		if (disposeRequested) return;
+		const nextRecords = dataOf<readonly AgenticMemoryRecord<TJson>[]>(msg);
+		if (nextRecords === undefined) return;
+		latestRecords = nextRecords;
+		if (subscribing && delivery === undefined) return;
+		observedChangesSinceSnapshot += 1;
+		enqueueChange(nextRecords);
+		if (
+			snapshotEveryChanges !== undefined &&
+			observedChangesSinceSnapshot >= snapshotEveryChanges
+		) {
+			enqueueSnapshot();
+		}
+	});
+	subscribing = false;
+	if (opts.snapshotOnAttach !== false) enqueueSnapshot();
+	else publish("ready");
+
+	return {
+		ready,
+		status,
+		error,
+		cursor,
+		flush(done?: (status: AgenticMemoryRecordsPersistenceStatus) => void): void {
+			if (disposed) {
+				callDone(done);
+				return;
+			}
+			enqueue({ phase: "flush", done, run: () => undefined });
+		},
+		snapshot(done?: (status: AgenticMemoryRecordsPersistenceStatus) => void): void {
+			if (disposed || disposeRequested) {
+				callDone(done);
+				return;
+			}
+			enqueueSnapshot(done);
+		},
+		dispose(done?: (status: AgenticMemoryRecordsPersistenceStatus) => void): void {
+			if (disposed) {
+				callDone(done);
+				return;
+			}
+			disposeRequested = true;
+			stop?.();
+			cancelQueuedForDispose();
+			enqueue({ phase: "dispose", done, run: () => undefined });
+		},
+	};
+}
+
+export function openPersistentAgenticMemoryRecords<
+	TJson extends AgenticMemoryStrictJsonValue = AgenticMemoryStrictJsonValue,
+>(
+	opts: OpenPersistentAgenticMemoryRecordsOptions<TJson>,
+): Promise<PersistentAgenticMemoryRecords<TJson>> {
+	const storagePrefix = opts.storagePrefix ?? opts.name ?? "agentic-memory";
+	const snapshotKey = opts.snapshotKey ?? agenticMemoryRecordsSnapshotKey(storagePrefix);
+	return loadAgenticMemoryRecordsState<TJson>({ ...opts, snapshotKey, storagePrefix }).then(
+		(loaded) => {
+			const records =
+				loaded.source === "empty" && opts.initial !== undefined ? opts.initial : loaded.records;
+			const node = opts.graph.state<readonly AgenticMemoryRecord<TJson>[]>(records, {
+				name: opts.name,
+			});
+			const persistence = persistAgenticMemoryRecords(opts.graph, node, {
+				...opts,
+				name: opts.name ? `${opts.name}/persistence` : undefined,
+				snapshotKey,
+				storagePrefix,
+				initialChangeCursor: loaded.changes.cursor,
+			});
+			return { records: node, persistence, loaded };
+		},
+	);
+}
+
+function recordFromFrame<TJson extends AgenticMemoryStrictJsonValue>(
+	frame: AgenticMemoryRecordFrame<TJson>,
+): AgenticMemoryRecord<TJson> {
+	return agenticMemoryRecordCodec<TJson>().decode(
+		agenticMemoryRecordFrameCodec<TJson>().encode(frame),
+	);
+}
+
+function statusOf(
+	state: AgenticMemoryRecordsPersistenceStatus["state"],
+	pending: number,
+	writes: number,
+	errors: number,
+	cursor: AgenticMemoryRecordsPersistenceCursor,
+): AgenticMemoryRecordsPersistenceStatus {
+	return { state, pending, writes, errors, cursor };
+}
+
+function dataOf<C>(msg: Message): C | undefined {
+	return msg[0] === "DATA" ? (msg[1] as C) : undefined;
+}
+
+function validateChangeCursor(value: unknown): number {
+	if (typeof value !== "number" || !Number.isSafeInteger(value) || value < -1) {
+		throw new RangeError("changeCursor must be a safe integer >= -1");
+	}
+	return value;
+}
+
+function validateSnapshotEveryChanges(value: number | undefined): number | undefined {
+	if (value === undefined) return undefined;
+	if (!Number.isSafeInteger(value) || value < 1) {
+		throw new RangeError("snapshotEveryChanges must be a positive safe integer");
+	}
+	return value;
+}
+
+function isPlainRecord(value: unknown): value is Record<string, unknown> {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+function assertKeys(
+	value: Record<string, unknown>,
+	expected: readonly string[],
+	label: string,
+): void {
+	const actual = Object.keys(value).sort();
+	const want = [...expected].sort();
+	if (actual.length !== want.length || actual.some((key, i) => key !== want[i])) {
+		throw new TypeError(`${label}: unexpected frame fields ${actual.join(",")}`);
+	}
+}
+
+function assertDenseRecordFrames<TJson extends AgenticMemoryStrictJsonValue>(
+	value: readonly unknown[],
+	label: string,
+): readonly AgenticMemoryRecordFrame<TJson>[] {
+	const records: AgenticMemoryRecordFrame<TJson>[] = [];
+	for (let i = 0; i < value.length; i += 1) {
+		if (!Object.hasOwn(value, i)) {
+			throw new TypeError(`${label}: sparse array hole at ${i}`);
+		}
+		records.push(assertAgenticMemoryRecordFrame<TJson>(value[i]));
+	}
+	return Object.freeze(records);
+}
+
+function errorMessage(error: unknown): string {
+	return error instanceof Error ? error.message : String(error);
+}
diff --git a/packages/ts/src/adapters/bridge-projections.ts b/packages/ts/src/adapters/bridge-projections.ts
new file mode 100644
index 00000000..ce0e7e88
--- /dev/null
+++ b/packages/ts/src/adapters/bridge-projections.ts
@@ -0,0 +1,329 @@
+/**
+ * Graph-visible wire bridge envelope helpers (D134).
+ *
+ * This first slice is transport-free: commands become outbound envelope facts,
+ * remote receipts enter only through the inbound fact node, and retry/ack timeout
+ * state is surfaced through graph-visible attempts/status/errors nodes.
+ */
+
+import { depBatch } from "../ctx/types.js";
+import type { Graph } from "../graph/graph.js";
+import type { Node } from "../node/node.js";
+import { errorPayload, type Wave } from "../protocol/messages.js";
+import type {
+	WireBridgeAck,
+	WireBridgeAttempt,
+	WireBridgeEnvelope,
+	WireBridgeEvent,
+	WireBridgeInvalidIngress,
+	WireBridgeNack,
+	WireBridgeStatus,
+} from "./bridge-types.js";
+import { bridgePayloadError, shouldTrackAck } from "./bridge-validation.js";
+
+export function projectOutbound<TOutbound, TInbound>(
+	graph: Graph,
+	events: Node<WireBridgeEvent<TOutbound, TInbound>>,
+	name: string,
+): Node<WireBridgeEnvelope<TOutbound>> {
+	return graph.node<WireBridgeEnvelope<TOutbound>>(
+		[events],
+		(ctx) => {
+			for (const raw of depBatch(ctx, 0) ?? []) {
+				const event = raw as WireBridgeEvent<TOutbound, TInbound>;
+				if (event.kind === "outbound") ctx.down([["DATA", event.envelope]]);
+			}
+		},
+		{ name: `${name}/outbound`, factory: "wireBridgeOutbound" },
+	);
+}
+
+export function projectAcks<TOutbound, TInbound>(
+	graph: Graph,
+	events: Node<WireBridgeEvent<TOutbound, TInbound>>,
+	name: string,
+): Node<WireBridgeAck> {
+	return graph.node<WireBridgeAck>(
+		[events],
+		(ctx) => {
+			for (const raw of depBatch(ctx, 0) ?? []) {
+				const event = raw as WireBridgeEvent<TOutbound, TInbound>;
+				if (event.kind === "ack") {
+					ctx.down([["DATA", { ackForSeq: event.ackForSeq, envelope: event.envelope }]]);
+				}
+			}
+		},
+		{ name: `${name}/acks`, factory: "wireBridgeAcks" },
+	);
+}
+
+export function projectNacks<TOutbound, TInbound>(
+	graph: Graph,
+	events: Node<WireBridgeEvent<TOutbound, TInbound>>,
+	name: string,
+): Node<WireBridgeNack> {
+	return graph.node<WireBridgeNack>(
+		[events],
+		(ctx) => {
+			for (const raw of depBatch(ctx, 0) ?? []) {
+				const event = raw as WireBridgeEvent<TOutbound, TInbound>;
+				if (event.kind === "nack") {
+					ctx.down([
+						["DATA", { ackForSeq: event.ackForSeq, envelope: event.envelope, error: event.error }],
+					]);
+				}
+			}
+		},
+		{ name: `${name}/nacks`, factory: "wireBridgeNacks" },
+	);
+}
+
+export function projectStatus<TOutbound, TInbound>(
+	graph: Graph,
+	events: Node<WireBridgeEvent<TOutbound, TInbound>>,
+	name: string,
+	sessionId: string,
+): Node<WireBridgeStatus> {
+	return graph.node<WireBridgeStatus>(
+		[events],
+		(ctx) => {
+			let next =
+				ctx.state.get<WireBridgeStatus>() ??
+				({
+					sessionId,
+					state: "idle",
+					cursor: 0,
+					nextSeq: 1,
+					pending: 0,
+					attempts: 0,
+					acked: 0,
+					nacked: 0,
+					errors: 0,
+				} satisfies WireBridgeStatus);
+			for (const raw of depBatch(ctx, 0) ?? []) {
+				const event = raw as WireBridgeEvent<TOutbound, TInbound>;
+				if (event.kind === "outbound") {
+					const { seq, attempt } = event.envelope.metadata;
+					const trackAck = shouldTrackAck(event.envelope.type);
+					next = {
+						...next,
+						state:
+							event.envelope.type === "start"
+								? "started"
+								: event.envelope.type === "close"
+									? "closed"
+									: "open",
+						nextSeq: Math.max(next.nextSeq, seq + 1),
+						pending:
+							event.envelope.type === "close"
+								? 1
+								: trackAck && attempt === 1
+									? next.pending + 1
+									: next.pending,
+						attempts: trackAck ? next.attempts + 1 : next.attempts,
+						lastSeq: seq,
+					};
+				} else if (event.kind === "ack") {
+					next = {
+						...next,
+						state: event.outbound.type === "close" ? "closed" : "open",
+						pending: Math.max(0, next.pending - 1),
+						acked: next.acked + 1,
+						lastSeq: event.envelope.metadata.seq,
+					};
+				} else if (event.kind === "nack") {
+					next = {
+						...next,
+						state: "errored",
+						pending: Math.max(0, next.pending - 1),
+						nacked: next.nacked + 1,
+						errors: next.errors + 1,
+						lastSeq: event.envelope.metadata.seq,
+					};
+				} else if (event.kind === "retry") {
+					next = {
+						...next,
+						state: "waiting",
+						lastSeq: event.seq,
+						lastDelayMs: event.delayMs,
+					};
+				} else if (event.kind === "exhausted") {
+					next = {
+						...next,
+						state: "exhausted",
+						pending: Math.max(0, next.pending - 1),
+						errors: next.errors + 1,
+						lastSeq: event.seq,
+					};
+				} else if (event.kind === "cursor") {
+					next = { ...next, cursor: event.cursor };
+				} else if (event.kind === "out-of-order") {
+					next = { ...next, state: "errored", errors: next.errors + 1, lastSeq: event.seq };
+				} else if (event.kind === "session-mismatch") {
+					next = { ...next, state: "errored", errors: next.errors + 1 };
+				} else if (event.kind === "late-receipt" || event.kind === "invalid") {
+					next = { ...next, state: "errored", errors: next.errors + 1 };
+				} else if (event.kind === "inbound" && event.envelope.type === "error") {
+					next = {
+						...next,
+						state: "errored",
+						errors: next.errors + 1,
+						lastSeq: event.envelope.metadata.seq,
+					};
+				} else if (event.kind === "inbound" && event.envelope.type === "close") {
+					next = { ...next, state: "closed", lastSeq: event.envelope.metadata.seq };
+				}
+			}
+			ctx.state.set(next);
+			ctx.down([["DATA", next]]);
+		},
+		{ name: `${name}/status`, factory: "wireBridgeStatus" },
+	);
+}
+
+export function projectErrors<TOutbound, TInbound>(
+	graph: Graph,
+	events: Node<WireBridgeEvent<TOutbound, TInbound>>,
+	name: string,
+): Node<unknown> {
+	return graph.node<unknown>(
+		[events],
+		(ctx) => {
+			for (const raw of depBatch(ctx, 0) ?? []) {
+				const event = raw as WireBridgeEvent<TOutbound, TInbound>;
+				if (event.kind === "nack") ctx.down([["DATA", event.error]]);
+				else if (event.kind === "exhausted") ctx.down([["DATA", event.error]]);
+				else if (event.kind === "out-of-order") {
+					ctx.down([
+						[
+							"DATA",
+							`${name}: inbound seq ${event.seq} arrived before expected seq ${event.expected}`,
+						],
+					]);
+				} else if (event.kind === "inbound" && event.envelope.type === "error") {
+					ctx.down([["DATA", bridgePayloadError(event.envelope.payload, "remote error envelope")]]);
+				} else if (event.kind === "session-mismatch") {
+					ctx.down([
+						[
+							"DATA",
+							`${name}: inbound session ${event.actual} did not match expected ${event.expected}`,
+						],
+					]);
+				} else if (event.kind === "late-receipt") {
+					ctx.down([
+						[
+							"DATA",
+							`${name}: late ${event.receipt} for unknown or completed ackForSeq ${event.ackForSeq}`,
+						],
+					]);
+				} else if (event.kind === "invalid") {
+					ctx.down([["DATA", event.error]]);
+				}
+			}
+		},
+		{ name: `${name}/errors`, factory: "wireBridgeErrors" },
+	);
+}
+
+export function projectCursor<TOutbound, TInbound>(
+	graph: Graph,
+	events: Node<WireBridgeEvent<TOutbound, TInbound>>,
+	name: string,
+): Node<number> {
+	return graph.node<number>(
+		[events],
+		(ctx) => {
+			for (const raw of depBatch(ctx, 0) ?? []) {
+				const event = raw as WireBridgeEvent<TOutbound, TInbound>;
+				if (event.kind === "cursor") ctx.down([["DATA", event.cursor]]);
+			}
+		},
+		{ name: `${name}/cursor`, factory: "wireBridgeCursor" },
+	);
+}
+
+export function projectAttempts<TOutbound, TInbound>(
+	graph: Graph,
+	events: Node<WireBridgeEvent<TOutbound, TInbound>>,
+	name: string,
+): Node<WireBridgeAttempt> {
+	return graph.node<WireBridgeAttempt>(
+		[events],
+		(ctx) => {
+			for (const raw of depBatch(ctx, 0) ?? []) {
+				const event = raw as WireBridgeEvent<TOutbound, TInbound>;
+				if (event.kind === "outbound" && shouldTrackAck(event.envelope.type)) {
+					ctx.down([
+						[
+							"DATA",
+							{
+								seq: event.envelope.metadata.seq,
+								attempt: event.envelope.metadata.attempt,
+								maxAttempts: event.envelope.metadata.maxAttempts,
+							},
+						],
+					]);
+				}
+			}
+		},
+		{ name: `${name}/attempts`, factory: "wireBridgeAttempts" },
+	);
+}
+
+export function guardedInboundNode<TInbound>(
+	node: Node<WireBridgeEnvelope<TInbound> | WireBridgeInvalidIngress>,
+	sessionId: string,
+): Node<WireBridgeEnvelope<TInbound>> {
+	return new Proxy(node, {
+		get(target, property) {
+			if (property === "down") {
+				return (msgs: Wave) => target.down(guardInboundWave(msgs, sessionId));
+			}
+			const value = Reflect.get(target, property, target);
+			return typeof value === "function" ? value.bind(target) : value;
+		},
+	}) as Node<WireBridgeEnvelope<TInbound>>;
+}
+
+export function guardInboundWave(msgs: Wave, sessionId: string): Wave {
+	return msgs.map((msg) => {
+		if (msg[0] === "DATA") return msg;
+		if (msg[0] === "ERROR") {
+			return [
+				"DATA",
+				invalidIngress(
+					`${sessionId}: inbound protocol ERROR ${String(
+						errorPayload(msg[1]),
+					)} is local misuse; remote errors must arrive as DATA envelope facts`,
+				),
+			];
+		}
+		if (msg[0] === "COMPLETE") {
+			return [
+				"DATA",
+				invalidIngress(
+					`${sessionId}: inbound protocol COMPLETE is local misuse; remote completion must arrive as a DATA envelope fact`,
+				),
+			];
+		}
+		return [
+			"DATA",
+			invalidIngress(
+				`${sessionId}: inbound port accepts DATA envelope facts only; ${msg[0]} is local protocol traffic`,
+			),
+		];
+	});
+}
+
+export function invalidIngress(error: string): WireBridgeInvalidIngress {
+	return { __wireBridgeInvalidIngress: true, error };
+}
+
+export function isInvalidIngress(value: unknown): value is WireBridgeInvalidIngress {
+	return (
+		typeof value === "object" &&
+		value !== null &&
+		(value as WireBridgeInvalidIngress).__wireBridgeInvalidIngress === true &&
+		typeof (value as WireBridgeInvalidIngress).error === "string"
+	);
+}
diff --git a/packages/ts/src/adapters/bridge-protobuf.ts b/packages/ts/src/adapters/bridge-protobuf.ts
new file mode 100644
index 00000000..f6205bfb
--- /dev/null
+++ b/packages/ts/src/adapters/bridge-protobuf.ts
@@ -0,0 +1,739 @@
+// D497 canonical protobuf profile for the D134/D496 wire bridge envelope subset.
+
+export type CanonicalProtobufErrorCategory =
+	| "unknown_field"
+	| "duplicate_singular"
+	| "noncanonical_bytes"
+	| "invalid_oneof"
+	| "missing_required"
+	| "invalid_wire_edge"
+	| "default_emission"
+	| "malformed";
+
+export class CanonicalProtobufError extends Error {
+	readonly category: CanonicalProtobufErrorCategory;
+
+	constructor(category: CanonicalProtobufErrorCategory, message: string) {
+		super(message);
+		this.name = "CanonicalProtobufError";
+		this.category = category;
+	}
+}
+
+export interface CanonicalWireBridgeMetadata {
+	readonly seq: bigint;
+	readonly cursor: bigint;
+	readonly idempotencyKey: string;
+	readonly attempt: number;
+	readonly maxAttempts: number;
+	readonly timestampMs?: bigint;
+	readonly ackForSeq?: bigint;
+	readonly requestId?: string;
+}
+
+export type CanonicalWireBridgeDataBody =
+	| { readonly kind: "value"; readonly value: Uint8Array }
+	| { readonly kind: "wire_edge"; readonly frame: CanonicalWireEdgeFrame };
+
+export interface CanonicalWireEdgeFrame {
+	readonly kind: "dirty" | "data";
+	readonly edgeId: string;
+	readonly causeId: string;
+	readonly value?: Uint8Array;
+}
+
+export type CanonicalWireBridgePayload =
+	| { readonly kind: "start" }
+	| { readonly kind: "data"; readonly body: CanonicalWireBridgeDataBody }
+	| { readonly kind: "ack" }
+	| { readonly kind: "nack"; readonly error?: Uint8Array }
+	| { readonly kind: "status"; readonly status: Uint8Array }
+	| { readonly kind: "error"; readonly error: Uint8Array }
+	| { readonly kind: "close"; readonly reason?: Uint8Array };
+
+export interface CanonicalWireBridgeEnvelope {
+	readonly sessionId: string;
+	readonly metadata: CanonicalWireBridgeMetadata;
+	readonly payload: CanonicalWireBridgePayload;
+}
+
+interface Field {
+	readonly no: number;
+	readonly wireType: number;
+	readonly value: bigint | Uint8Array;
+}
+
+const maxUint64 = (1n << 64n) - 1n;
+const textDecoder = new TextDecoder("utf-8", { fatal: true });
+const textEncoder = new TextEncoder();
+
+export function decodeCanonicalWireBridgeEnvelope(bytes: Uint8Array): CanonicalWireBridgeEnvelope {
+	const input = Uint8Array.from(bytes);
+	const envelope = parseWireBridgeEnvelope(input);
+	validateWireBridgeEnvelope(envelope);
+	const canonical = encodeCanonicalWireBridgeEnvelope(envelope);
+	if (!bytesEqual(input, canonical)) {
+		throw new CanonicalProtobufError(
+			"noncanonical_bytes",
+			"WireBridgeEnvelope bytes are not canonical deterministic protobuf",
+		);
+	}
+	return envelope;
+}
+
+export function decodeCanonicalWireEdgeFrame(bytes: Uint8Array): CanonicalWireEdgeFrame {
+	const input = Uint8Array.from(bytes);
+	const frame = parseWireEdgeFrame(input);
+	validateWireEdgeFrame(frame);
+	const canonical = encodeWireEdgeFrame(frame);
+	if (!bytesEqual(input, canonical)) {
+		throw new CanonicalProtobufError(
+			"noncanonical_bytes",
+			"WireEdgeFrame bytes are not canonical deterministic protobuf",
+		);
+	}
+	return frame;
+}
+
+export function encodeCanonicalWireEdgeFrame(frame: CanonicalWireEdgeFrame): Uint8Array {
+	validateWireEdgeFrame(frame);
+	return encodeWireEdgeFrame(frame);
+}
+
+export function encodeCanonicalWireBridgeEnvelope(
+	envelope: CanonicalWireBridgeEnvelope,
+): Uint8Array {
+	validateWireBridgeEnvelope(envelope);
+	const out = new ByteWriter();
+	out.stringField(1, envelope.sessionId);
+	out.messageField(2, encodeMetadata(envelope.metadata));
+	switch (envelope.payload.kind) {
+		case "start":
+			out.messageField(3, new Uint8Array());
+			break;
+		case "data":
+			out.messageField(4, encodeDataPayload(envelope.payload.body));
+			break;
+		case "ack":
+			out.messageField(5, new Uint8Array());
+			break;
+		case "nack":
+			out.messageField(6, encodeOptionalBytesMessage(1, envelope.payload.error));
+			break;
+		case "status":
+			out.messageField(7, encodeRequiredBytesMessage(1, envelope.payload.status));
+			break;
+		case "error":
+			out.messageField(8, encodeRequiredBytesMessage(1, envelope.payload.error));
+			break;
+		case "close":
+			out.messageField(9, encodeOptionalBytesMessage(1, envelope.payload.reason));
+			break;
+	}
+	return out.finish();
+}
+
+function parseWireBridgeEnvelope(bytes: Uint8Array): CanonicalWireBridgeEnvelope {
+	const fields = readFields(
+		bytes,
+		new Map([
+			[1, 2],
+			[2, 2],
+			[3, 2],
+			[4, 2],
+			[5, 2],
+			[6, 2],
+			[7, 2],
+			[8, 2],
+			[9, 2],
+		]),
+		"WireBridgeEnvelope",
+	);
+	const session = bytesField(fields, 1);
+	const metadataBytes = bytesField(fields, 2);
+	const payloadFields = fields.filter((field) => field.no >= 3 && field.no <= 9);
+	if (session === undefined || metadataBytes === undefined || payloadFields.length === 0) {
+		throw new CanonicalProtobufError(
+			"missing_required",
+			"WireBridgeEnvelope missing required fields",
+		);
+	}
+	if (payloadFields.length !== 1) {
+		throw new CanonicalProtobufError(
+			"invalid_oneof",
+			"WireBridgeEnvelope payload oneof has multiple cases",
+		);
+	}
+	const payloadField = payloadFields[0];
+	if (!(payloadField.value instanceof Uint8Array)) {
+		throw new CanonicalProtobufError("malformed", "WireBridgeEnvelope payload is malformed");
+	}
+	return {
+		sessionId: utf8String(session, "session_id"),
+		metadata: parseMetadata(metadataBytes),
+		payload: parseEnvelopePayload(payloadField.no, payloadField.value),
+	};
+}
+
+function parseEnvelopePayload(fieldNo: number, bytes: Uint8Array): CanonicalWireBridgePayload {
+	switch (fieldNo) {
+		case 3:
+			requireEmptyMessage(bytes, "start");
+			return { kind: "start" };
+		case 4:
+			return { kind: "data", body: parseDataPayload(bytes) };
+		case 5:
+			requireEmptyMessage(bytes, "ack");
+			return { kind: "ack" };
+		case 6:
+			return { kind: "nack", error: parseOptionalBytesPayload(bytes, "nack") };
+		case 7:
+			return { kind: "status", status: parseRequiredBytesPayload(bytes, "status") };
+		case 8:
+			return { kind: "error", error: parseRequiredBytesPayload(bytes, "error") };
+		case 9:
+			return { kind: "close", reason: parseOptionalBytesPayload(bytes, "close") };
+		default:
+			throw new CanonicalProtobufError("unknown_field", "unknown envelope payload field");
+	}
+}
+
+function parseMetadata(bytes: Uint8Array): CanonicalWireBridgeMetadata {
+	const fields = readFields(
+		bytes,
+		new Map([
+			[1, 0],
+			[2, 0],
+			[3, 2],
+			[4, 0],
+			[5, 0],
+			[6, 0],
+			[7, 0],
+			[8, 2],
+		]),
+		"WireBridgeMetadata",
+	);
+	const seq = uintField(fields, 1);
+	const cursor = uintField(fields, 2);
+	const key = bytesField(fields, 3);
+	const attempt = uintField(fields, 4);
+	const maxAttempts = uintField(fields, 5);
+	if (
+		seq === undefined ||
+		cursor === undefined ||
+		key === undefined ||
+		attempt === undefined ||
+		maxAttempts === undefined
+	) {
+		throw new CanonicalProtobufError(
+			"missing_required",
+			"WireBridgeMetadata missing required fields",
+		);
+	}
+	const timestampMs = uintField(fields, 6);
+	const ackForSeq = uintField(fields, 7);
+	const requestId = bytesField(fields, 8);
+	if (timestampMs === 0n || ackForSeq === 0n || requestId?.length === 0) {
+		throw new CanonicalProtobufError(
+			"default_emission",
+			"optional metadata default value was emitted",
+		);
+	}
+	return {
+		seq,
+		cursor,
+		idempotencyKey: utf8String(key, "idempotency_key"),
+		attempt: uint32(attempt, "attempt"),
+		maxAttempts: uint32(maxAttempts, "max_attempts"),
+		timestampMs,
+		ackForSeq,
+		requestId: requestId === undefined ? undefined : utf8String(requestId, "request_id"),
+	};
+}
+
+function parseDataPayload(bytes: Uint8Array): CanonicalWireBridgeDataBody {
+	const fields = readFields(
+		bytes,
+		new Map([
+			[1, 2],
+			[2, 2],
+		]),
+		"WireBridgeDataPayload",
+	);
+	const value = bytesField(fields, 1);
+	const wireEdge = bytesField(fields, 2);
+	if (value !== undefined && wireEdge !== undefined) {
+		throw new CanonicalProtobufError(
+			"invalid_oneof",
+			"WireBridgeDataPayload body has multiple cases",
+		);
+	}
+	if (value !== undefined) return { kind: "value", value };
+	if (wireEdge !== undefined) return { kind: "wire_edge", frame: parseWireEdgeFrame(wireEdge) };
+	throw new CanonicalProtobufError("missing_required", "WireBridgeDataPayload missing body");
+}
+
+function parseWireEdgeFrame(bytes: Uint8Array): CanonicalWireEdgeFrame {
+	const fields = readFields(
+		bytes,
+		new Map([
+			[1, 0],
+			[2, 2],
+			[3, 2],
+			[4, 2],
+		]),
+		"WireEdgeFrame",
+	);
+	const kind = uintField(fields, 1);
+	const edge = bytesField(fields, 2);
+	const cause = bytesField(fields, 3);
+	const value = bytesField(fields, 4);
+	if (kind === undefined || edge === undefined || cause === undefined) {
+		throw new CanonicalProtobufError("missing_required", "WireEdgeFrame missing required fields");
+	}
+	if (edge.length === 0 || cause.length === 0) {
+		throw new CanonicalProtobufError(
+			"missing_required",
+			"WireEdgeFrame edge_id/cause_id must be non-empty",
+		);
+	}
+	if (kind === 1n) {
+		if (value !== undefined) {
+			throw new CanonicalProtobufError(
+				"invalid_wire_edge",
+				"DIRTY WireEdgeFrame must not carry value",
+			);
+		}
+		return {
+			kind: "dirty",
+			edgeId: utf8String(edge, "edge_id"),
+			causeId: utf8String(cause, "cause_id"),
+		};
+	}
+	if (kind === 2n) {
+		if (value === undefined) {
+			throw new CanonicalProtobufError("invalid_wire_edge", "DATA WireEdgeFrame requires value");
+		}
+		return {
+			kind: "data",
+			edgeId: utf8String(edge, "edge_id"),
+			causeId: utf8String(cause, "cause_id"),
+			value,
+		};
+	}
+	throw new CanonicalProtobufError("invalid_wire_edge", "WireEdgeFrame kind is invalid");
+}
+
+function validateWireBridgeEnvelope(envelope: CanonicalWireBridgeEnvelope): void {
+	if (!isRecord(envelope)) {
+		throw new CanonicalProtobufError("malformed", "WireBridgeEnvelope DTO must be an object");
+	}
+	if (typeof envelope.sessionId !== "string" || envelope.sessionId.length === 0) {
+		throw new CanonicalProtobufError(
+			"missing_required",
+			"WireBridgeEnvelope session_id must be non-empty",
+		);
+	}
+	const metadata = envelope.metadata;
+	if (!isRecord(metadata)) {
+		throw new CanonicalProtobufError("malformed", "WireBridgeMetadata DTO must be an object");
+	}
+	assertUint64(metadata.seq, "seq");
+	assertUint64(metadata.cursor, "cursor");
+	assertUint32Number(metadata.attempt, "attempt");
+	assertUint32Number(metadata.maxAttempts, "max_attempts");
+	if (metadata.timestampMs !== undefined) assertUint64(metadata.timestampMs, "timestamp_ms");
+	if (metadata.ackForSeq !== undefined) assertUint64(metadata.ackForSeq, "ack_for_seq");
+	if (metadata.seq === 0n || metadata.attempt === 0 || metadata.maxAttempts < metadata.attempt) {
+		throw new CanonicalProtobufError(
+			"missing_required",
+			"WireBridgeMetadata positive fields are invalid",
+		);
+	}
+	if (typeof metadata.idempotencyKey !== "string" || metadata.idempotencyKey.length === 0) {
+		throw new CanonicalProtobufError(
+			"missing_required",
+			"WireBridgeMetadata idempotency_key is required",
+		);
+	}
+	if (metadata.requestId !== undefined && typeof metadata.requestId !== "string") {
+		throw new CanonicalProtobufError("malformed", "WireBridgeMetadata request_id must be a string");
+	}
+	if (!isRecord(envelope.payload)) {
+		throw new CanonicalProtobufError("missing_required", "WireBridgeEnvelope payload is required");
+	}
+	validatePayloadDto(envelope.payload);
+	if (
+		(envelope.payload.kind === "ack" || envelope.payload.kind === "nack") &&
+		metadata.ackForSeq === undefined
+	) {
+		throw new CanonicalProtobufError("missing_required", "ACK/NACK requires metadata.ack_for_seq");
+	}
+	if (metadata.timestampMs === 0n || metadata.ackForSeq === 0n || metadata.requestId === "") {
+		throw new CanonicalProtobufError(
+			"default_emission",
+			"optional metadata default value was emitted",
+		);
+	}
+}
+
+function validatePayloadDto(payload: CanonicalWireBridgePayload): void {
+	switch (payload.kind) {
+		case "start":
+		case "ack":
+			return;
+		case "data":
+			if (!isRecord(payload.body)) {
+				throw new CanonicalProtobufError(
+					"missing_required",
+					"WireBridgeDataPayload body is required",
+				);
+			}
+			if (payload.body.kind === "value") {
+				assertUint8Array(payload.body.value, "WireBridgeDataPayload value");
+				return;
+			}
+			if (payload.body.kind === "wire_edge") {
+				validateWireEdgeFrame(payload.body.frame);
+				return;
+			}
+			throw new CanonicalProtobufError(
+				"invalid_oneof",
+				"WireBridgeDataPayload body kind is invalid",
+			);
+		case "nack":
+			if (payload.error !== undefined)
+				assertNonEmptyOptionalBytes(payload.error, "WireBridgeNackPayload error");
+			return;
+		case "status":
+			assertNonEmptyRequiredBytes(payload.status, "WireBridgeStatusPayload status");
+			return;
+		case "error":
+			assertNonEmptyRequiredBytes(payload.error, "WireBridgeErrorPayload error");
+			return;
+		case "close":
+			if (payload.reason !== undefined)
+				assertNonEmptyOptionalBytes(payload.reason, "WireBridgeClosePayload reason");
+			return;
+		default:
+			throw new CanonicalProtobufError(
+				"invalid_oneof",
+				"WireBridgeEnvelope payload kind is invalid",
+			);
+	}
+}
+
+function validateWireEdgeFrame(frame: CanonicalWireEdgeFrame): void {
+	if (!isRecord(frame)) {
+		throw new CanonicalProtobufError("malformed", "WireEdgeFrame DTO must be an object");
+	}
+	if (typeof frame.edgeId !== "string" || typeof frame.causeId !== "string") {
+		throw new CanonicalProtobufError(
+			"missing_required",
+			"WireEdgeFrame edge_id/cause_id are required",
+		);
+	}
+	if (frame.edgeId.length === 0 || frame.causeId.length === 0) {
+		throw new CanonicalProtobufError(
+			"missing_required",
+			"WireEdgeFrame edge_id/cause_id must be non-empty",
+		);
+	}
+	switch (frame.kind) {
+		case "dirty":
+			if (frame.value !== undefined) {
+				throw new CanonicalProtobufError(
+					"invalid_wire_edge",
+					"DIRTY WireEdgeFrame must not carry value",
+				);
+			}
+			return;
+		case "data":
+			if (frame.value === undefined) {
+				throw new CanonicalProtobufError("invalid_wire_edge", "DATA WireEdgeFrame requires value");
+			}
+			assertUint8Array(frame.value, "WireEdgeFrame value");
+			return;
+		default:
+			throw new CanonicalProtobufError("invalid_wire_edge", "WireEdgeFrame kind is invalid");
+	}
+}
+
+function encodeMetadata(metadata: CanonicalWireBridgeMetadata): Uint8Array {
+	const out = new ByteWriter();
+	out.varintField(1, metadata.seq);
+	out.varintField(2, metadata.cursor);
+	out.stringField(3, metadata.idempotencyKey);
+	out.varintField(4, BigInt(metadata.attempt));
+	out.varintField(5, BigInt(metadata.maxAttempts));
+	if (metadata.timestampMs !== undefined) out.varintField(6, metadata.timestampMs);
+	if (metadata.ackForSeq !== undefined) out.varintField(7, metadata.ackForSeq);
+	if (metadata.requestId !== undefined) out.stringField(8, metadata.requestId);
+	return out.finish();
+}
+
+function encodeDataPayload(body: CanonicalWireBridgeDataBody): Uint8Array {
+	const out = new ByteWriter();
+	if (body.kind === "value") {
+		out.bytesField(1, body.value);
+	} else {
+		out.messageField(2, encodeWireEdgeFrame(body.frame));
+	}
+	return out.finish();
+}
+
+function encodeWireEdgeFrame(frame: CanonicalWireEdgeFrame): Uint8Array {
+	const out = new ByteWriter();
+	out.varintField(1, frame.kind === "dirty" ? 1n : 2n);
+	out.stringField(2, frame.edgeId);
+	out.stringField(3, frame.causeId);
+	if (frame.value !== undefined) out.bytesField(4, frame.value);
+	return out.finish();
+}
+
+function encodeRequiredBytesMessage(fieldNo: number, value: Uint8Array): Uint8Array {
+	const out = new ByteWriter();
+	out.bytesField(fieldNo, value);
+	return out.finish();
+}
+
+function encodeOptionalBytesMessage(fieldNo: number, value: Uint8Array | undefined): Uint8Array {
+	const out = new ByteWriter();
+	if (value !== undefined) {
+		assertNonEmptyOptionalBytes(value, "optional bytes payload");
+		out.bytesField(fieldNo, value);
+	}
+	return out.finish();
+}
+
+function parseRequiredBytesPayload(bytes: Uint8Array, name: string): Uint8Array {
+	const fields = readFields(bytes, new Map([[1, 2]]), `WireBridge${name}Payload`);
+	const value = bytesField(fields, 1);
+	if (value === undefined) {
+		throw new CanonicalProtobufError("missing_required", `${name} payload missing required bytes`);
+	}
+	if (value.length === 0) {
+		throw new CanonicalProtobufError("missing_required", `${name} payload bytes must be non-empty`);
+	}
+	return value;
+}
+
+function parseOptionalBytesPayload(bytes: Uint8Array, name: string): Uint8Array | undefined {
+	const fields = readFields(bytes, new Map([[1, 2]]), `WireBridge${name}Payload`);
+	const value = bytesField(fields, 1);
+	if (value?.length === 0) {
+		throw new CanonicalProtobufError(
+			"default_emission",
+			`${name} optional bytes default value was emitted`,
+		);
+	}
+	return value;
+}
+
+function requireEmptyMessage(bytes: Uint8Array, name: string): void {
+	if (bytes.length !== 0) {
+		throw new CanonicalProtobufError("unknown_field", `${name} payload must be empty`);
+	}
+}
+
+function readFields(bytes: Uint8Array, allowed: Map<number, number>, messageName: string): Field[] {
+	const reader = new ByteReader(bytes);
+	const fields: Field[] = [];
+	const seen = new Set<number>();
+	while (!reader.done()) {
+		const key = reader.varint();
+		const fieldNo = Number(key >> 3n);
+		const wireType = Number(key & 7n);
+		const expectedWireType = allowed.get(fieldNo);
+		if (fieldNo <= 0 || expectedWireType === undefined) {
+			throw new CanonicalProtobufError(
+				"unknown_field",
+				`${messageName} contains unknown field ${fieldNo}`,
+			);
+		}
+		if (wireType !== expectedWireType) {
+			throw new CanonicalProtobufError(
+				"malformed",
+				`${messageName} field ${fieldNo} has wrong wire type`,
+			);
+		}
+		if (seen.has(fieldNo)) {
+			throw new CanonicalProtobufError(
+				"duplicate_singular",
+				`${messageName} field ${fieldNo} is duplicated`,
+			);
+		}
+		seen.add(fieldNo);
+		if (wireType === 0) {
+			fields.push({ no: fieldNo, wireType, value: reader.varint() });
+		} else if (wireType === 2) {
+			fields.push({ no: fieldNo, wireType, value: reader.readBytes() });
+		} else {
+			throw new CanonicalProtobufError("malformed", `${messageName} unsupported wire type`);
+		}
+	}
+	return fields;
+}
+
+function uintField(fields: readonly Field[], no: number): bigint | undefined {
+	const field = fields.find((candidate) => candidate.no === no);
+	return typeof field?.value === "bigint" ? field.value : undefined;
+}
+
+function bytesField(fields: readonly Field[], no: number): Uint8Array | undefined {
+	const field = fields.find((candidate) => candidate.no === no);
+	return field?.value instanceof Uint8Array ? field.value : undefined;
+}
+
+function utf8String(bytes: Uint8Array, field: string): string {
+	let text: string;
+	try {
+		text = textDecoder.decode(bytes);
+	} catch (error) {
+		throw new CanonicalProtobufError(
+			"malformed",
+			`${field} is not valid utf-8: ${error instanceof Error ? error.message : String(error)}`,
+		);
+	}
+	if (text.length === 0) {
+		throw new CanonicalProtobufError("missing_required", `${field} must be non-empty`);
+	}
+	return text;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null;
+}
+
+function assertUint64(value: unknown, field: string): asserts value is bigint {
+	if (typeof value !== "bigint" || value < 0n || value > maxUint64) {
+		throw new CanonicalProtobufError("malformed", `${field} must be a uint64 bigint`);
+	}
+}
+
+function assertUint32Number(value: unknown, field: string): asserts value is number {
+	if (!Number.isInteger(value) || (value as number) < 0 || (value as number) > 0xffff_ffff) {
+		throw new CanonicalProtobufError("malformed", `${field} must be a uint32 number`);
+	}
+}
+
+function assertUint8Array(value: unknown, field: string): asserts value is Uint8Array {
+	if (!(value instanceof Uint8Array)) {
+		throw new CanonicalProtobufError("malformed", `${field} must be Uint8Array bytes`);
+	}
+}
+
+function assertNonEmptyOptionalBytes(value: unknown, field: string): asserts value is Uint8Array {
+	assertUint8Array(value, field);
+	if (value.length === 0) {
+		throw new CanonicalProtobufError("default_emission", `${field} default value must be omitted`);
+	}
+}
+
+function assertNonEmptyRequiredBytes(value: unknown, field: string): asserts value is Uint8Array {
+	assertUint8Array(value, field);
+	if (value.length === 0) {
+		throw new CanonicalProtobufError("missing_required", `${field} must be non-empty`);
+	}
+}
+
+function uint32(value: bigint, field: string): number {
+	if (value > 0xffff_ffffn) {
+		throw new CanonicalProtobufError("malformed", `${field} exceeds uint32`);
+	}
+	return Number(value);
+}
+
+function bytesEqual(left: Uint8Array, right: Uint8Array): boolean {
+	if (left.length !== right.length) return false;
+	for (let i = 0; i < left.length; i++) {
+		if (left[i] !== right[i]) return false;
+	}
+	return true;
+}
+
+class ByteReader {
+	private offset = 0;
+
+	constructor(private readonly buf: Uint8Array) {}
+
+	done(): boolean {
+		return this.offset === this.buf.length;
+	}
+
+	varint(): bigint {
+		let shift = 0n;
+		let result = 0n;
+		for (let i = 0; i < 10; i++) {
+			if (this.offset >= this.buf.length) {
+				throw new CanonicalProtobufError("malformed", "truncated varint");
+			}
+			const byte = this.buf[this.offset++];
+			if (i === 9 && (byte & 0xfe) !== 0) {
+				throw new CanonicalProtobufError("malformed", "varint exceeds 64 bits");
+			}
+			result |= BigInt(byte & 0x7f) << shift;
+			if ((byte & 0x80) === 0) return result;
+			shift += 7n;
+		}
+		throw new CanonicalProtobufError("malformed", "varint exceeds 64 bits");
+	}
+
+	readBytes(): Uint8Array {
+		const len = this.varint();
+		if (len > BigInt(this.buf.length - this.offset)) {
+			throw new CanonicalProtobufError("malformed", "length-delimited field is truncated");
+		}
+		const start = this.offset;
+		this.offset += Number(len);
+		return this.buf.slice(start, this.offset);
+	}
+}
+
+class ByteWriter {
+	private readonly chunks: number[] = [];
+
+	varintField(fieldNo: number, value: bigint): void {
+		this.tag(fieldNo, 0);
+		this.varint(value);
+	}
+
+	bytesField(fieldNo: number, value: Uint8Array): void {
+		this.tag(fieldNo, 2);
+		this.varint(BigInt(value.length));
+		this.bytes(value);
+	}
+
+	stringField(fieldNo: number, value: string): void {
+		this.bytesField(fieldNo, textEncoder.encode(value));
+	}
+
+	messageField(fieldNo: number, value: Uint8Array): void {
+		this.bytesField(fieldNo, value);
+	}
+
+	finish(): Uint8Array {
+		return new Uint8Array(this.chunks);
+	}
+
+	private tag(fieldNo: number, wireType: number): void {
+		this.varint(BigInt((fieldNo << 3) | wireType));
+	}
+
+	private varint(value: bigint): void {
+		if (value < 0n || value > maxUint64) {
+			throw new CanonicalProtobufError("malformed", "varint value must fit uint64");
+		}
+		let next = value;
+		do {
+			let byte = Number(next & 0x7fn);
+			next >>= 7n;
+			if (next !== 0n) byte |= 0x80;
+			this.chunks.push(byte);
+		} while (next !== 0n);
+	}
+
+	private bytes(value: Uint8Array): void {
+		for (const byte of value) this.chunks.push(byte);
+	}
+}
diff --git a/packages/ts/src/adapters/bridge-remote-call.ts b/packages/ts/src/adapters/bridge-remote-call.ts
new file mode 100644
index 00000000..fcca6838
--- /dev/null
+++ b/packages/ts/src/adapters/bridge-remote-call.ts
@@ -0,0 +1,675 @@
+/**
+ * Graph-visible wire bridge envelope helpers (D134).
+ *
+ * This first slice is transport-free: commands become outbound envelope facts,
+ * remote receipts enter only through the inbound fact node, and retry/ack timeout
+ * state is surfaced through graph-visible attempts/status/errors nodes.
+ */
+
+import { depBatch } from "../ctx/types.js";
+import type { Graph } from "../graph/graph.js";
+import type { Node } from "../node/node.js";
+import type {
+	RemoteCallBundle,
+	RemoteCallError,
+	RemoteCallOptions,
+	RemoteCallRequest,
+	RemoteCallResponse,
+	RemoteCallResult,
+	RemoteCallStatus,
+	RemoteCallTimeout,
+	WireBridgeBundle,
+	WireBridgeEnvelope,
+	WireBridgeEvent,
+} from "./bridge-types.js";
+import {
+	remoteMalformedResponseOperation,
+	remoteMalformedResponseRequestId,
+	validateRemoteCallRequest,
+	validateRemoteCallResponse,
+} from "./bridge-validation.js";
+
+/** D147 remote dispatcher call helper over explicit wireBridge request/response facts. */
+export function remoteCall<TRequest = unknown, TResponse = unknown>(
+	graph: Graph,
+	bridge: WireBridgeBundle<RemoteCallRequest<TRequest>, RemoteCallResponse<TResponse>>,
+	opts: RemoteCallOptions = {},
+): RemoteCallBundle<TRequest, TResponse> {
+	const name = opts.name ?? "remoteCall";
+	const timeouts = graph.node<RemoteCallTimeout>([], null, {
+		name: `${name}/timeouts`,
+		factory: "remoteCallTimeouts",
+		completeWhenDepsComplete: false,
+		errorWhenDepsError: false,
+	});
+	const responses = remoteCallResponsesNode(graph, bridge.events, timeouts, name);
+	const results = remoteCallResultsNode(graph, responses, name);
+	const status = remoteCallStatusNode(graph, bridge.events, timeouts, name);
+	const errors = remoteCallErrorsNode(graph, timeouts, bridge.events, name);
+	return {
+		responses,
+		results,
+		status,
+		errors,
+		timeouts,
+		call(operation, requestId, payload, callOpts) {
+			const request = remoteCallRequest(operation, requestId, payload);
+			bridge.command.down([
+				[
+					"DATA",
+					{
+						kind: "send",
+						payload: request,
+						idempotencyKey: callOpts?.idempotencyKey,
+						requestId,
+					},
+				],
+			]);
+			return request;
+		},
+		timeout(requestId, operation, error) {
+			const timeout = remoteCallTimeout(requestId, operation, error);
+			timeouts.down([["DATA", timeout]]);
+			return timeout;
+		},
+	};
+}
+
+function remoteCallRequest<TRequest>(
+	operation: string,
+	requestId: string,
+	payload: TRequest,
+): RemoteCallRequest<TRequest> {
+	if (operation.length === 0) throw new RangeError("remoteCall: operation must be non-empty");
+	if (requestId.length === 0) throw new RangeError("remoteCall: requestId must be non-empty");
+	return { operation, requestId, payload };
+}
+
+function remoteCallTimeout(
+	requestId: string,
+	operation: string | undefined,
+	error: string,
+): RemoteCallTimeout {
+	if (requestId.length === 0)
+		throw new RangeError("remoteCall: timeout requestId must be non-empty");
+	if (error.length === 0) throw new RangeError("remoteCall: timeout error must be non-empty");
+	return { ...(operation === undefined ? {} : { operation }), requestId, error };
+}
+
+interface RemotePendingRequest {
+	operation: string;
+	requestId: string;
+	seq: number;
+}
+
+interface RemotePendingState {
+	requestIds: Set<string>;
+	bySeq: Map<number, RemotePendingRequest>;
+}
+
+function remotePendingState(): RemotePendingState {
+	return { requestIds: new Set(), bySeq: new Map() };
+}
+
+function remotePendingContains(state: RemotePendingState, requestId: string): boolean {
+	return state.requestIds.has(requestId);
+}
+
+function remotePendingDuplicate(state: RemotePendingState, request: RemotePendingRequest): boolean {
+	const current = remotePendingTakeBySeqPreview(state, request.seq);
+	return current?.requestId !== request.requestId && state.requestIds.has(request.requestId);
+}
+
+function remotePendingTakeBySeqPreview(
+	state: RemotePendingState,
+	seq: number,
+): RemotePendingRequest | undefined {
+	return state.bySeq.get(seq);
+}
+
+function remotePendingPeekByRequestId(
+	state: RemotePendingState,
+	requestId: string,
+): RemotePendingRequest | undefined {
+	for (const request of state.bySeq.values()) {
+		if (request.requestId === requestId) return request;
+	}
+	return undefined;
+}
+
+function remotePendingInsert(state: RemotePendingState, request: RemotePendingRequest): void {
+	const existingBySeq = state.bySeq.get(request.seq);
+	if (existingBySeq !== undefined) {
+		state.requestIds.delete(existingBySeq.requestId);
+	}
+	for (const [seq, pending] of state.bySeq) {
+		if (pending.requestId === request.requestId && seq !== request.seq) {
+			state.bySeq.delete(seq);
+			break;
+		}
+	}
+	state.requestIds.add(request.requestId);
+	state.bySeq.set(request.seq, request);
+}
+
+function remotePendingTakeByRequestId(
+	state: RemotePendingState,
+	requestId: string,
+): RemotePendingRequest | undefined {
+	if (!state.requestIds.delete(requestId)) return undefined;
+	let seq: number | undefined;
+	let found: RemotePendingRequest | undefined;
+	for (const [candidateSeq, request] of state.bySeq) {
+		if (request.requestId === requestId) {
+			seq = candidateSeq;
+			found = request;
+			break;
+		}
+	}
+	if (seq !== undefined) state.bySeq.delete(seq);
+	return found;
+}
+
+function remotePendingTakeBySeq(
+	state: RemotePendingState,
+	seq: number,
+): RemotePendingRequest | undefined {
+	const request = state.bySeq.get(seq);
+	if (request === undefined) return undefined;
+	state.bySeq.delete(seq);
+	state.requestIds.delete(request.requestId);
+	return request;
+}
+
+function remotePendingFromReceipt<T>(
+	state: RemotePendingState,
+	envelope: WireBridgeEnvelope<RemoteCallRequest<T>>,
+): RemotePendingRequest | undefined {
+	const bySeq = remotePendingTakeBySeq(state, envelope.metadata.seq);
+	if (bySeq !== undefined) return bySeq;
+	const fallback = pendingRequestFromEnvelope(envelope);
+	if (fallback === undefined || remotePendingContains(state, fallback.requestId)) {
+		return undefined;
+	}
+	return fallback;
+}
+
+function pendingRequestFromEnvelope<T>(
+	envelope: WireBridgeEnvelope<RemoteCallRequest<T>>,
+): RemotePendingRequest | undefined {
+	if (envelope.payload?.kind !== "data") return undefined;
+	const request = validateRemoteCallRequest(envelope.payload.value);
+	if (request === undefined) return undefined;
+	return {
+		operation: request.operation,
+		requestId: request.requestId,
+		seq: envelope.metadata.seq,
+	};
+}
+
+function remoteCallResponseRequestId<T>(response: RemoteCallResponse<T>): string {
+	return response.requestId;
+}
+
+function remoteCallResponseIsTerminal<T>(response: RemoteCallResponse<T>): boolean {
+	return response.kind === "result" || response.kind === "error";
+}
+
+function remoteCallResponseOperation<T>(response: RemoteCallResponse<T>): string {
+	return response.operation;
+}
+
+function remoteCallResponseMatchesPending<T>(
+	response: RemoteCallResponse<T>,
+	request: RemotePendingRequest,
+): boolean {
+	return remoteCallResponseOperation(response) === request.operation;
+}
+
+function remoteCallResponsesNode<TRequest, TResponse>(
+	graph: Graph,
+	events: Node<WireBridgeEvent<RemoteCallRequest<TRequest>, RemoteCallResponse<TResponse>>>,
+	timeouts: Node<RemoteCallTimeout>,
+	name: string,
+): Node<RemoteCallResponse<TResponse>> {
+	return graph.node<RemoteCallResponse<TResponse>>(
+		[events, timeouts],
+		(ctx) => {
+			type State = {
+				pending: RemotePendingState;
+			};
+			const state = ctx.state.get<State>() ?? {
+				pending: remotePendingState(),
+			};
+			const ready: RemoteCallResponse<TResponse>[] = [];
+			for (const raw of depBatch(ctx, 0) ?? []) {
+				const event = raw as WireBridgeEvent<
+					RemoteCallRequest<TRequest>,
+					RemoteCallResponse<TResponse>
+				>;
+				if (event.kind === "outbound") {
+					const request = pendingRequestFromEnvelope(event.envelope);
+					if (request === undefined) continue;
+					if (remotePendingDuplicate(state.pending, request)) continue;
+					remotePendingInsert(state.pending, request);
+				} else if (event.kind === "inbound" && event.envelope.payload?.kind === "data") {
+					const response = validateRemoteCallResponse<TResponse>(event.envelope.payload.value);
+					if (response === undefined) {
+						const requestId = remoteMalformedResponseRequestId(event.envelope.payload.value);
+						const operation = remoteMalformedResponseOperation(event.envelope.payload.value);
+						const request =
+							requestId === undefined
+								? undefined
+								: remotePendingPeekByRequestId(state.pending, requestId);
+						if (
+							request !== undefined &&
+							operation !== undefined &&
+							operation === request.operation
+						) {
+							remotePendingTakeByRequestId(state.pending, request.requestId);
+						}
+						continue;
+					}
+					const requestId = remoteCallResponseRequestId(response);
+					const request = remotePendingPeekByRequestId(state.pending, requestId);
+					if (request !== undefined && remoteCallResponseMatchesPending(response, request)) {
+						if (remoteCallResponseIsTerminal(response)) {
+							remotePendingTakeByRequestId(state.pending, requestId);
+						}
+						ready.push(response);
+					}
+				} else if (event.kind === "nack") {
+					remotePendingFromReceipt(state.pending, event.outbound);
+				} else if (event.kind === "exhausted") {
+					remotePendingTakeBySeq(state.pending, event.seq);
+				}
+			}
+			for (const raw of depBatch(ctx, 1) ?? []) {
+				const timeout = raw as RemoteCallTimeout;
+				remotePendingTakeByRequestId(state.pending, timeout.requestId);
+			}
+			ctx.state.set(state);
+			for (const response of ready) ctx.down([["DATA", response]]);
+		},
+		{
+			name: `${name}/responses`,
+			factory: "remoteCallResponses",
+			partial: true,
+			completeWhenDepsComplete: false,
+			errorWhenDepsError: false,
+		},
+	);
+}
+
+function remoteCallResultsNode<TResponse>(
+	graph: Graph,
+	responses: Node<RemoteCallResponse<TResponse>>,
+	name: string,
+): Node<RemoteCallResult<TResponse>> {
+	return graph.node<RemoteCallResult<TResponse>>(
+		[responses],
+		(ctx) => {
+			for (const raw of depBatch(ctx, 0) ?? []) {
+				const response = raw as RemoteCallResponse<TResponse>;
+				if (response.kind === "result") {
+					ctx.down([
+						[
+							"DATA",
+							{
+								operation: response.operation,
+								requestId: response.requestId,
+								payload: response.payload,
+							},
+						],
+					]);
+				}
+			}
+		},
+		{ name: `${name}/results`, factory: "remoteCallResults", completeWhenDepsComplete: false },
+	);
+}
+
+function remoteCallStatusNode<TRequest, TResponse>(
+	graph: Graph,
+	events: Node<WireBridgeEvent<RemoteCallRequest<TRequest>, RemoteCallResponse<TResponse>>>,
+	timeouts: Node<RemoteCallTimeout>,
+	name: string,
+): Node<RemoteCallStatus> {
+	return graph.node<RemoteCallStatus>(
+		[events, timeouts],
+		(ctx) => {
+			type State = { status: RemoteCallStatus; pending: RemotePendingState };
+			const state =
+				ctx.state.get<State>() ??
+				({
+					status: { state: "idle", pending: 0, completed: 0, errors: 0, timeouts: 0 },
+					pending: remotePendingState(),
+				} satisfies State);
+			for (const raw of depBatch(ctx, 0) ?? []) {
+				const event = raw as WireBridgeEvent<
+					RemoteCallRequest<TRequest>,
+					RemoteCallResponse<TResponse>
+				>;
+				if (event.kind === "outbound") {
+					const request = pendingRequestFromEnvelope(event.envelope);
+					if (request !== undefined) {
+						if (remotePendingDuplicate(state.pending, request)) {
+							state.status = {
+								...state.status,
+								state: "errored",
+								operation: request.operation,
+								requestId: request.requestId,
+								errors: state.status.errors + 1,
+							};
+							continue;
+						}
+						remotePendingInsert(state.pending, request);
+						state.status = {
+							...state.status,
+							state: "requested",
+							operation: request.operation,
+							requestId: request.requestId,
+						};
+					}
+				} else if (
+					event.kind === "invalid" ||
+					event.kind === "session-mismatch" ||
+					event.kind === "out-of-order" ||
+					event.kind === "late-receipt"
+				) {
+					state.status = {
+						...state.status,
+						state: "bridge-errored",
+						errors: state.status.errors + 1,
+					};
+				} else if (event.kind === "nack") {
+					const request = remotePendingFromReceipt(state.pending, event.outbound);
+					state.status = {
+						...state.status,
+						state: "bridge-errored",
+						...(request === undefined
+							? {}
+							: { operation: request.operation, requestId: request.requestId }),
+						errors: state.status.errors + 1,
+					};
+				} else if (event.kind === "exhausted") {
+					const request = remotePendingTakeBySeq(state.pending, event.seq);
+					state.status = {
+						...state.status,
+						state: "bridge-errored",
+						...(request === undefined
+							? {}
+							: { operation: request.operation, requestId: request.requestId }),
+						errors: state.status.errors + 1,
+					};
+				} else if (event.kind === "inbound" && event.envelope.payload?.kind === "data") {
+					const response = validateRemoteCallResponse<TResponse>(event.envelope.payload.value);
+					if (response === undefined) {
+						const requestId = remoteMalformedResponseRequestId(event.envelope.payload.value);
+						const operation = remoteMalformedResponseOperation(event.envelope.payload.value);
+						const request =
+							requestId === undefined || operation === undefined
+								? undefined
+								: remotePendingPeekByRequestId(state.pending, requestId);
+						const matchedRequest =
+							request !== undefined && request.operation === operation ? request : undefined;
+						if (matchedRequest !== undefined) {
+							remotePendingTakeByRequestId(state.pending, matchedRequest.requestId);
+						}
+						state.status = {
+							...state.status,
+							state: "errored",
+							...(matchedRequest === undefined
+								? {
+										...(operation === undefined ? {} : { operation }),
+										...(requestId === undefined ? {} : { requestId }),
+									}
+								: { operation: matchedRequest.operation, requestId: matchedRequest.requestId }),
+							errors: state.status.errors + 1,
+						};
+						continue;
+					}
+					const request = remotePendingPeekByRequestId(state.pending, response.requestId);
+					if (request === undefined) {
+						state.status = {
+							...state.status,
+							state: "errored",
+							operation: response.operation,
+							requestId: response.requestId,
+							errors: state.status.errors + 1,
+						};
+						continue;
+					}
+					if (!remoteCallResponseMatchesPending(response, request)) {
+						state.status = {
+							...state.status,
+							state: "errored",
+							operation: request.operation,
+							requestId: request.requestId,
+							errors: state.status.errors + 1,
+						};
+						continue;
+					}
+					if (response.kind === "result") {
+						remotePendingTakeByRequestId(state.pending, request.requestId);
+						state.status = {
+							...state.status,
+							state: "responded",
+							operation: response.operation,
+							requestId: response.requestId,
+							completed: state.status.completed + 1,
+						};
+					} else if (response.kind === "error") {
+						remotePendingTakeByRequestId(state.pending, request.requestId);
+						state.status = {
+							...state.status,
+							state: "errored",
+							operation: response.operation,
+							requestId: response.requestId,
+							errors: state.status.errors + 1,
+						};
+					} else {
+						state.status = {
+							...state.status,
+							state: "requested",
+							operation: response.operation,
+							requestId: response.requestId,
+						};
+					}
+				}
+			}
+			for (const raw of depBatch(ctx, 1) ?? []) {
+				const timeout = raw as RemoteCallTimeout;
+				remotePendingTakeByRequestId(state.pending, timeout.requestId);
+				state.status = {
+					...state.status,
+					state: "timed-out",
+					operation: timeout.operation,
+					requestId: timeout.requestId,
+					errors: state.status.errors + 1,
+					timeouts: state.status.timeouts + 1,
+				};
+			}
+			state.status = { ...state.status, pending: state.pending.requestIds.size };
+			ctx.state.set(state);
+			ctx.down([["DATA", state.status]]);
+		},
+		{
+			name: `${name}/status`,
+			factory: "remoteCallStatus",
+			partial: true,
+			completeWhenDepsComplete: false,
+			errorWhenDepsError: false,
+		},
+	);
+}
+
+function remoteCallErrorsNode<TRequest, TResponse>(
+	graph: Graph,
+	timeouts: Node<RemoteCallTimeout>,
+	events: Node<WireBridgeEvent<RemoteCallRequest<TRequest>, RemoteCallResponse<TResponse>>>,
+	name: string,
+): Node<RemoteCallError> {
+	return graph.node<RemoteCallError>(
+		[timeouts, events],
+		(ctx) => {
+			const pending = ctx.state.get<RemotePendingState>() ?? remotePendingState();
+			for (const raw of depBatch(ctx, 0) ?? []) {
+				const timeout = raw as RemoteCallTimeout;
+				remotePendingTakeByRequestId(pending, timeout.requestId);
+				ctx.down([
+					[
+						"DATA",
+						{ operation: timeout.operation, requestId: timeout.requestId, error: timeout.error },
+					],
+				]);
+			}
+			for (const raw of depBatch(ctx, 1) ?? []) {
+				const event = raw as WireBridgeEvent<
+					RemoteCallRequest<TRequest>,
+					RemoteCallResponse<TResponse>
+				>;
+				if (event.kind === "outbound") {
+					const request = pendingRequestFromEnvelope(event.envelope);
+					if (request !== undefined) {
+						if (remotePendingDuplicate(pending, request)) {
+							ctx.down([
+								[
+									"DATA",
+									{
+										operation: request.operation,
+										requestId: request.requestId,
+										error: `remoteCall: duplicate in-flight requestId '${request.requestId}'`,
+									},
+								],
+							]);
+							continue;
+						}
+						remotePendingInsert(pending, request);
+					}
+					continue;
+				}
+				if (event.kind === "inbound" && event.envelope.payload?.kind === "data") {
+					const response = validateRemoteCallResponse<TResponse>(event.envelope.payload.value);
+					if (response === undefined) {
+						const requestId = remoteMalformedResponseRequestId(event.envelope.payload.value);
+						const operation = remoteMalformedResponseOperation(event.envelope.payload.value);
+						const request =
+							requestId === undefined || operation === undefined
+								? undefined
+								: remotePendingPeekByRequestId(pending, requestId);
+						if (request !== undefined && request.operation === operation) {
+							remotePendingTakeByRequestId(pending, request.requestId);
+						}
+						ctx.down([
+							[
+								"DATA",
+								{
+									...(operation === undefined ? {} : { operation }),
+									...(requestId === undefined ? {} : { requestId }),
+									error: "remoteCall: response payload is malformed",
+								},
+							],
+						]);
+					} else {
+						const request = remotePendingPeekByRequestId(pending, response.requestId);
+						if (request === undefined) {
+							ctx.down([
+								[
+									"DATA",
+									{
+										operation: response.operation,
+										requestId: response.requestId,
+										error: "remoteCall: orphan response for unknown or completed request",
+									},
+								],
+							]);
+						} else if (!remoteCallResponseMatchesPending(response, request)) {
+							ctx.down([
+								[
+									"DATA",
+									{
+										operation: request.operation,
+										requestId: request.requestId,
+										error: `remoteCall: response operation '${response.operation}' did not match pending operation '${request.operation}'`,
+									},
+								],
+							]);
+						} else if (response.kind === "error") {
+							remotePendingTakeByRequestId(pending, request.requestId);
+							ctx.down([
+								[
+									"DATA",
+									{
+										operation: response.operation,
+										requestId: response.requestId,
+										error: response.error,
+									},
+								],
+							]);
+						} else if (response.kind === "result") {
+							remotePendingTakeByRequestId(pending, request.requestId);
+						}
+					}
+					continue;
+				}
+				if (event.kind === "nack") {
+					const request = remotePendingFromReceipt(pending, event.outbound);
+					ctx.down([
+						[
+							"DATA",
+							{
+								operation: request?.operation,
+								requestId: request?.requestId,
+								error: String(event.error),
+							},
+						],
+					]);
+				} else if (event.kind === "exhausted") {
+					const request = remotePendingTakeBySeq(pending, event.seq);
+					ctx.down([
+						[
+							"DATA",
+							{
+								operation: request?.operation,
+								requestId: request?.requestId,
+								error: String(event.error),
+							},
+						],
+					]);
+				} else if (event.kind === "invalid") {
+					ctx.down([["DATA", { error: event.error }]]);
+				} else if (
+					event.kind === "session-mismatch" ||
+					event.kind === "out-of-order" ||
+					event.kind === "late-receipt"
+				) {
+					ctx.down([["DATA", { error: remoteCallBridgeErrorMessage(event) }]]);
+				}
+			}
+			ctx.state.set(pending);
+		},
+		{
+			name: `${name}/errors`,
+			factory: "remoteCallErrors",
+			partial: true,
+			completeWhenDepsComplete: false,
+			errorWhenDepsError: false,
+		},
+	);
+}
+
+function remoteCallBridgeErrorMessage<TRequest, TResponse>(
+	event: WireBridgeEvent<RemoteCallRequest<TRequest>, RemoteCallResponse<TResponse>>,
+): string {
+	if (event.kind === "session-mismatch") {
+		return `remoteCall: inbound session ${event.actual} did not match expected ${event.expected}`;
+	}
+	if (event.kind === "out-of-order") {
+		return `remoteCall: inbound seq ${event.seq} arrived before expected seq ${event.expected}`;
+	}
+	if (event.kind === "late-receipt") {
+		return `remoteCall: late ${event.receipt} for unknown or completed ackForSeq ${event.ackForSeq}`;
+	}
+	return "remoteCall: bridge error";
+}
diff --git a/packages/ts/src/adapters/bridge-remote-responder.ts b/packages/ts/src/adapters/bridge-remote-responder.ts
new file mode 100644
index 00000000..8ca4788b
--- /dev/null
+++ b/packages/ts/src/adapters/bridge-remote-responder.ts
@@ -0,0 +1,330 @@
+/**
+ * Graph-visible wire bridge envelope helpers (D134).
+ *
+ * This first slice is transport-free: commands become outbound envelope facts,
+ * remote receipts enter only through the inbound fact node, and retry/ack timeout
+ * state is surfaced through graph-visible attempts/status/errors nodes.
+ */
+
+import { depBatch } from "../ctx/types.js";
+import type { Graph } from "../graph/graph.js";
+import type { Node } from "../node/node.js";
+import type {
+	RemoteCallError,
+	RemoteCallRequest,
+	RemoteCallResponse,
+	RemoteResponderEvent,
+	RemoteResponderHandler,
+	RemoteResponderHandlerDefinition,
+	RemoteResponderStatus,
+	WireBridgeCommand,
+	WireBridgeEnvelope,
+	WireBridgeInvalidIngress,
+} from "./bridge-types.js";
+import {
+	errorMessage,
+	isThenable,
+	rethrowGraphRuntimeInvariant,
+	validateInboundEnvelope,
+	validateRemoteCallRequest,
+} from "./bridge-validation.js";
+
+export function normalizeRemoteHandlers<TRequest, TResponse>(
+	handlers: readonly RemoteResponderHandlerDefinition<TRequest, TResponse>[],
+): Map<string, RemoteResponderHandler<TRequest, TResponse>> {
+	const out = new Map<string, RemoteResponderHandler<TRequest, TResponse>>();
+	for (const handler of handlers) {
+		if (handler.operation.length === 0) {
+			throw new RangeError("remoteResponder: operation must be non-empty");
+		}
+		if (out.has(handler.operation)) {
+			throw new RangeError(`remoteResponder: duplicate operation '${handler.operation}'`);
+		}
+		out.set(handler.operation, handler.handle);
+	}
+	return out;
+}
+
+interface RemoteResponderCursor {
+	cursor: number;
+	remoteCursor: number;
+}
+
+type RemoteResponderInbound<T> =
+	| { readonly kind: "request"; readonly request: RemoteCallRequest<T>; readonly seq: number }
+	| { readonly kind: "consumed" }
+	| { readonly kind: "invalid"; readonly error: string };
+
+function reduceRemoteResponderInbound<T>(
+	cursor: RemoteResponderCursor,
+	envelope: WireBridgeEnvelope<RemoteCallRequest<T>>,
+	expectedSessionId: string,
+): RemoteResponderInbound<T> {
+	const envelopeError = validateInboundEnvelope(envelope);
+	if (envelopeError !== undefined) {
+		return { kind: "invalid", error: envelopeError };
+	}
+	if (envelope.sessionId !== expectedSessionId) {
+		return {
+			kind: "invalid",
+			error: `remoteResponder: inbound session ${envelope.sessionId} did not match expected ${expectedSessionId}`,
+		};
+	}
+	const seq = envelope.metadata.seq;
+	const expected = cursor.cursor + 1;
+	if (seq <= cursor.cursor) {
+		return {
+			kind: "invalid",
+			error: `remoteResponder: duplicate request seq ${seq} at cursor ${cursor.cursor}`,
+		};
+	}
+	if (seq > expected) {
+		return {
+			kind: "invalid",
+			error: `remoteResponder: out-of-order request seq ${seq}, expected ${expected}`,
+		};
+	}
+	if (envelope.metadata.cursor < cursor.remoteCursor) {
+		return {
+			kind: "invalid",
+			error: `${envelope.sessionId}: remoteResponder inbound cursor ${envelope.metadata.cursor} regressed below ${cursor.remoteCursor}`,
+		};
+	}
+	cursor.cursor = seq;
+	cursor.remoteCursor = envelope.metadata.cursor;
+	if (envelope.type !== "data") return { kind: "consumed" };
+	if (envelope.payload?.kind !== "data") {
+		return { kind: "invalid", error: "remoteResponder: request envelope must carry request DATA" };
+	}
+	const request = validateRemoteCallRequest<T>(envelope.payload.value);
+	if (request === undefined) {
+		return { kind: "invalid", error: "remoteResponder: request payload is malformed" };
+	}
+	return { kind: "request", request, seq };
+}
+
+export function remoteResponderEventsNode<TRequest, TResponse>(
+	graph: Graph,
+	inbound: Node<WireBridgeEnvelope<RemoteCallRequest<TRequest>> | WireBridgeInvalidIngress>,
+	name: string,
+	expectedSessionId: string,
+	handlers: Map<string, RemoteResponderHandler<TRequest, TResponse>>,
+	rejectUnknown: boolean,
+): Node<RemoteResponderEvent<TRequest, TResponse>> {
+	return graph.node<RemoteResponderEvent<TRequest, TResponse>>(
+		[inbound],
+		(ctx) => {
+			const cursor = ctx.state.get<RemoteResponderCursor>() ?? { cursor: 0, remoteCursor: 0 };
+			for (const raw of depBatch(ctx, 0) ?? []) {
+				const envelope = raw as WireBridgeEnvelope<RemoteCallRequest<TRequest>>;
+				const received = reduceRemoteResponderInbound(cursor, envelope, expectedSessionId);
+				if (received.kind === "consumed") continue;
+				if (received.kind === "invalid") {
+					ctx.down([["DATA", { kind: "invalid", error: received.error }]]);
+					continue;
+				}
+				const { request, seq } = received;
+				ctx.down([["DATA", { kind: "request", request, seq }]]);
+				const handler = handlers.get(request.operation);
+				if (handler === undefined) {
+					if (!rejectUnknown) continue;
+					const error = `remoteResponder: unknown operation '${request.operation}'`;
+					const response = remoteCallErrorResponse(request, error);
+					ctx.down([
+						[
+							"DATA",
+							{
+								kind: "rejected",
+								requestId: request.requestId,
+								operation: request.operation,
+								error,
+								command: { kind: "send", payload: response, requestId: request.requestId },
+							},
+						],
+					]);
+					continue;
+				}
+				try {
+					const payload = handler(request);
+					if (isThenable(payload)) {
+						throw new Error("remoteResponder: async handler results require a later adapter shape");
+					}
+					const response = {
+						kind: "result",
+						operation: request.operation,
+						requestId: request.requestId,
+						payload,
+					} satisfies RemoteCallResponse<TResponse>;
+					ctx.down([
+						[
+							"DATA",
+							{
+								kind: "response",
+								requestId: request.requestId,
+								operation: request.operation,
+								command: { kind: "send", payload: response, requestId: request.requestId },
+							},
+						],
+					]);
+				} catch (error) {
+					rethrowGraphRuntimeInvariant(error);
+					const message = errorMessage(error);
+					const response = remoteCallErrorResponse(request, message);
+					ctx.down([
+						[
+							"DATA",
+							{
+								kind: "rejected",
+								requestId: request.requestId,
+								operation: request.operation,
+								error: message,
+								command: { kind: "send", payload: response, requestId: request.requestId },
+							},
+						],
+					]);
+				}
+			}
+			ctx.state.set(cursor);
+		},
+		{
+			name: `${name}/events`,
+			factory: "remoteResponderEvents",
+			partial: true,
+			completeWhenDepsComplete: false,
+			errorWhenDepsError: false,
+		},
+	);
+}
+
+function remoteCallErrorResponse<TRequest, TResponse>(
+	request: RemoteCallRequest<TRequest>,
+	error: string,
+): RemoteCallResponse<TResponse> {
+	return {
+		kind: "error",
+		operation: request.operation,
+		requestId: request.requestId,
+		error,
+	};
+}
+
+export function remoteResponderResponseCommandsNode<TRequest, TResponse>(
+	graph: Graph,
+	events: Node<RemoteResponderEvent<TRequest, TResponse>>,
+	name: string,
+): Node<WireBridgeCommand<RemoteCallResponse<TResponse>>> {
+	return graph.node<WireBridgeCommand<RemoteCallResponse<TResponse>>>(
+		[events],
+		(ctx) => {
+			for (const raw of depBatch(ctx, 0) ?? []) {
+				const event = raw as RemoteResponderEvent<TRequest, TResponse>;
+				if (
+					(event.kind === "response" || event.kind === "rejected") &&
+					event.command !== undefined
+				) {
+					ctx.down([["DATA", event.command]]);
+				}
+			}
+		},
+		{
+			name: `${name}/responseCommands`,
+			factory: "remoteResponderResponseCommands",
+			completeWhenDepsComplete: false,
+			errorWhenDepsError: false,
+		},
+	);
+}
+
+export function remoteResponderRequestsNode<TRequest, TResponse>(
+	graph: Graph,
+	events: Node<RemoteResponderEvent<TRequest, TResponse>>,
+	name: string,
+): Node<RemoteCallRequest<TRequest>> {
+	return graph.node<RemoteCallRequest<TRequest>>(
+		[events],
+		(ctx) => {
+			for (const raw of depBatch(ctx, 0) ?? []) {
+				const event = raw as RemoteResponderEvent<TRequest, TResponse>;
+				if (event.kind === "request") ctx.down([["DATA", event.request]]);
+			}
+		},
+		{
+			name: `${name}/requests`,
+			factory: "remoteResponderRequests",
+			completeWhenDepsComplete: false,
+		},
+	);
+}
+
+export function remoteResponderStatusNode<TRequest, TResponse>(
+	graph: Graph,
+	events: Node<RemoteResponderEvent<TRequest, TResponse>>,
+	name: string,
+): Node<RemoteResponderStatus> {
+	return graph.node<RemoteResponderStatus>(
+		[events],
+		(ctx) => {
+			let status =
+				ctx.state.get<RemoteResponderStatus>() ??
+				({ state: "idle", handled: 0, rejected: 0, errors: 0 } satisfies RemoteResponderStatus);
+			for (const raw of depBatch(ctx, 0) ?? []) {
+				const event = raw as RemoteResponderEvent<TRequest, TResponse>;
+				if (event.kind === "response") {
+					status = {
+						...status,
+						state: "responded",
+						operation: event.operation,
+						requestId: event.requestId,
+						handled: status.handled + 1,
+					};
+				} else if (event.kind === "rejected") {
+					status = {
+						...status,
+						state: "rejected",
+						operation: event.operation,
+						requestId: event.requestId,
+						rejected: status.rejected + 1,
+						errors: status.errors + 1,
+					};
+				} else if (event.kind === "invalid") {
+					status = { ...status, state: "errored", errors: status.errors + 1 };
+				}
+			}
+			ctx.state.set(status);
+			ctx.down([["DATA", status]]);
+		},
+		{
+			name: `${name}/status`,
+			factory: "remoteResponderStatus",
+			partial: true,
+			completeWhenDepsComplete: false,
+			errorWhenDepsError: false,
+		},
+	);
+}
+
+export function remoteResponderErrorsNode<TRequest, TResponse>(
+	graph: Graph,
+	events: Node<RemoteResponderEvent<TRequest, TResponse>>,
+	name: string,
+): Node<RemoteCallError> {
+	return graph.node<RemoteCallError>(
+		[events],
+		(ctx) => {
+			for (const raw of depBatch(ctx, 0) ?? []) {
+				const event = raw as RemoteResponderEvent<TRequest, TResponse>;
+				if (event.kind === "rejected") {
+					ctx.down([
+						[
+							"DATA",
+							{ operation: event.operation, requestId: event.requestId, error: event.error },
+						],
+					]);
+				} else if (event.kind === "invalid") {
+					ctx.down([["DATA", { error: event.error }]]);
+				}
+			}
+		},
+		{ name: `${name}/errors`, factory: "remoteResponderErrors", completeWhenDepsComplete: false },
+	);
+}
diff --git a/packages/ts/src/adapters/bridge-types.ts b/packages/ts/src/adapters/bridge-types.ts
new file mode 100644
index 00000000..4a19752a
--- /dev/null
+++ b/packages/ts/src/adapters/bridge-types.ts
@@ -0,0 +1,399 @@
+import type { RetryPolicy } from "../graph/resilience.js";
+import type { Node } from "../node/node.js";
+import type {
+	CanonicalProtobufErrorCategory,
+	CanonicalWireBridgeDataBody,
+} from "./bridge-protobuf.js";
+
+export type WireBridgeEnvelopeType =
+	| "start"
+	| "data"
+	| "ack"
+	| "nack"
+	| "status"
+	| "error"
+	| "close";
+
+export interface WireBridgeMetadata {
+	/** Monotonic envelope sequence within the bridge session. */
+	readonly seq: number;
+	/** Monotonic accepted inbound cursor observed by the sending side. */
+	readonly cursor: number;
+	/** D151: correlation/idempotency metadata, not an authoritative duplicate lookup key. */
+	readonly idempotencyKey: string;
+	readonly attempt: number;
+	readonly maxAttempts: number;
+	readonly timestampMs?: number;
+	/** D151 ack/nack correlation target; receipt duplicate recognition still uses seq/cursor. */
+	readonly ackForSeq?: number;
+	readonly requestId?: string;
+}
+
+export type WireBridgePayload<TData = unknown> =
+	| { readonly kind: "data"; readonly value: TData }
+	| { readonly kind: "error"; readonly error: unknown }
+	| { readonly kind: "status"; readonly status: unknown }
+	| { readonly kind: "close"; readonly reason?: unknown };
+
+export interface WireBridgeEnvelope<TData = unknown> {
+	readonly sessionId: string;
+	readonly type: WireBridgeEnvelopeType;
+	readonly payload?: WireBridgePayload<TData>;
+	readonly metadata: WireBridgeMetadata;
+}
+
+export type WireBridgeCommand<TData = unknown> =
+	| { readonly kind: "start"; readonly idempotencyKey?: string; readonly requestId?: string }
+	| {
+			readonly kind: "send";
+			readonly payload: TData;
+			readonly idempotencyKey?: string;
+			readonly requestId?: string;
+	  }
+	| {
+			readonly kind: "ack";
+			readonly ackForSeq: number;
+			readonly idempotencyKey?: string;
+			readonly requestId?: string;
+	  }
+	| {
+			readonly kind: "nack";
+			readonly ackForSeq: number;
+			readonly error: unknown;
+			readonly idempotencyKey?: string;
+			readonly requestId?: string;
+	  }
+	| {
+			readonly kind: "ack-timeout";
+			readonly seq: number;
+			readonly attempt: number;
+			readonly observedAtMs?: number;
+	  }
+	| { readonly kind: "close"; readonly reason?: unknown; readonly idempotencyKey?: string };
+
+export type WireBridgeEvent<TOutbound = unknown, TInbound = unknown> =
+	| {
+			readonly kind: "outbound";
+			readonly envelope: WireBridgeEnvelope<TOutbound>;
+	  }
+	| {
+			readonly kind: "inbound";
+			readonly envelope: WireBridgeEnvelope<TInbound>;
+	  }
+	| {
+			readonly kind: "ack";
+			readonly ackForSeq: number;
+			readonly envelope: WireBridgeEnvelope<TInbound>;
+			readonly outbound: WireBridgeEnvelope<TOutbound>;
+	  }
+	| {
+			readonly kind: "nack";
+			readonly ackForSeq: number;
+			readonly envelope: WireBridgeEnvelope<TInbound>;
+			readonly outbound: WireBridgeEnvelope<TOutbound>;
+			readonly error: unknown;
+	  }
+	| { readonly kind: "timeout"; readonly seq: number; readonly attempt: number }
+	| {
+			readonly kind: "retry";
+			readonly seq: number;
+			readonly attempt: number;
+			readonly delayMs: number;
+			readonly error: unknown;
+	  }
+	| {
+			readonly kind: "exhausted";
+			readonly seq: number;
+			readonly attempt: number;
+			readonly error: unknown;
+	  }
+	| { readonly kind: "cursor"; readonly cursor: number }
+	| { readonly kind: "duplicate"; readonly seq: number; readonly cursor: number }
+	| { readonly kind: "out-of-order"; readonly seq: number; readonly expected: number }
+	| { readonly kind: "session-mismatch"; readonly expected: string; readonly actual: string }
+	| { readonly kind: "late-receipt"; readonly receipt: "ack" | "nack"; readonly ackForSeq: number }
+	| { readonly kind: "invalid"; readonly error: string };
+
+export interface WireBridgeAck {
+	readonly ackForSeq: number;
+	readonly envelope: WireBridgeEnvelope;
+}
+
+export interface WireBridgeNack {
+	readonly ackForSeq: number;
+	readonly envelope: WireBridgeEnvelope;
+	readonly error: unknown;
+}
+
+export interface WireBridgeAttempt {
+	readonly seq: number;
+	readonly attempt: number;
+	readonly maxAttempts: number;
+}
+
+export interface WireBridgeStatus {
+	readonly sessionId: string;
+	readonly state: "idle" | "started" | "open" | "waiting" | "closed" | "errored" | "exhausted";
+	readonly cursor: number;
+	readonly nextSeq: number;
+	readonly pending: number;
+	readonly attempts: number;
+	readonly acked: number;
+	readonly nacked: number;
+	readonly errors: number;
+	readonly lastSeq?: number;
+	readonly lastDelayMs?: number;
+}
+
+export interface WireBridgeOptions {
+	readonly name?: string;
+	readonly sessionId: string;
+	readonly retry?: RetryPolicy;
+	readonly now?: () => number;
+}
+
+export interface WireBridgeBundle<TOutbound = unknown, TInbound = unknown> {
+	readonly sessionId: string;
+	readonly command: Node<WireBridgeCommand<TOutbound>>;
+	readonly outbound: Node<WireBridgeEnvelope<TOutbound>>;
+	readonly inbound: Node<WireBridgeEnvelope<TInbound>>;
+	readonly events: Node<WireBridgeEvent<TOutbound, TInbound>>;
+	readonly acks: Node<WireBridgeAck>;
+	readonly nacks: Node<WireBridgeNack>;
+	readonly status: Node<WireBridgeStatus>;
+	readonly errors: Node<unknown>;
+	readonly cursor: Node<number>;
+	readonly attempts: Node<WireBridgeAttempt>;
+	start(): void;
+	send(payload: TOutbound, opts?: { idempotencyKey?: string; requestId?: string }): void;
+	ack(ackForSeq: number, opts?: { idempotencyKey?: string; requestId?: string }): void;
+	nack(
+		ackForSeq: number,
+		error: unknown,
+		opts?: { idempotencyKey?: string; requestId?: string },
+	): void;
+	close(reason?: unknown, opts?: { idempotencyKey?: string }): void;
+}
+
+export interface WireBridgeAckDriverIssue {
+	readonly code: "wire-bridge-ack-driver-clock-invalid" | "wire-bridge-ack-driver-clock-regressed";
+	readonly message: string;
+	readonly seq?: number;
+	readonly attempt?: number;
+	readonly observedAtMs?: number;
+	readonly nowMs?: number;
+}
+
+export interface WireBridgeAckDriverStatus {
+	readonly state: "idle" | "active" | "timed-out" | "issues";
+	readonly pending: number;
+	readonly commands: number;
+	readonly issues: number;
+	readonly nowMs?: number;
+	readonly lastCommand?: Extract<WireBridgeCommand, { readonly kind: "ack-timeout" }>;
+	readonly lastIssue?: WireBridgeAckDriverIssue;
+}
+
+export interface WireBridgeAckDriverOptions {
+	readonly name?: string;
+	readonly clock: Node<number>;
+	readonly timeoutMs: number;
+}
+
+export interface WireBridgeAckDriverBundle {
+	readonly commands: Node<WireBridgeCommand<never>>;
+	readonly status: Node<WireBridgeAckDriverStatus>;
+	readonly issues: Node<WireBridgeAckDriverIssue>;
+	release(): void;
+}
+
+export type WireBridgeProtobufData = Uint8Array | CanonicalWireBridgeDataBody;
+
+export interface WireBridgeProtobufIssue {
+	readonly direction: "inbound" | "outbound";
+	readonly operation: "decode" | "encode";
+	readonly message: string;
+	readonly category?: CanonicalProtobufErrorCategory;
+}
+
+export interface WireBridgeProtobufStatus {
+	readonly decoded: number;
+	readonly encoded: number;
+	readonly issues: number;
+	readonly state: "idle" | "active" | "issues";
+	readonly lastIssue?: WireBridgeProtobufIssue;
+}
+
+export interface WireBridgeProtobufBundle {
+	readonly inboundBytes: Node<Uint8Array>;
+	readonly outboundBytes: Node<Uint8Array>;
+	readonly issues: Node<WireBridgeProtobufIssue>;
+	readonly status: Node<WireBridgeProtobufStatus>;
+	release(): void;
+}
+
+export interface WireBridgeProtobufOptions {
+	readonly name?: string;
+}
+
+export interface RemoteCallRequest<T = unknown> {
+	readonly operation: string;
+	readonly requestId: string;
+	readonly payload: T;
+}
+
+export type RemoteCallResponse<T = unknown> =
+	| {
+			readonly kind: "result";
+			readonly operation: string;
+			readonly requestId: string;
+			readonly payload: T;
+	  }
+	| {
+			readonly kind: "error";
+			readonly operation: string;
+			readonly requestId: string;
+			readonly error: string;
+	  }
+	| {
+			readonly kind: "status";
+			readonly operation: string;
+			readonly requestId: string;
+			readonly status: string;
+	  };
+
+export interface RemoteCallResult<T = unknown> {
+	readonly operation: string;
+	readonly requestId: string;
+	readonly payload: T;
+}
+
+export type RemoteCallStatusState =
+	| "idle"
+	| "requested"
+	| "responded"
+	| "errored"
+	| "timed-out"
+	| "bridge-errored";
+
+export interface RemoteCallStatus {
+	readonly state: RemoteCallStatusState;
+	readonly operation?: string;
+	readonly requestId?: string;
+	readonly pending: number;
+	readonly completed: number;
+	readonly errors: number;
+	readonly timeouts: number;
+}
+
+export interface RemoteCallError {
+	readonly operation?: string;
+	readonly requestId?: string;
+	readonly error: string;
+}
+
+export interface RemoteCallTimeout {
+	readonly operation?: string;
+	readonly requestId: string;
+	readonly error: string;
+}
+
+export interface RemoteCallOptions {
+	readonly name?: string;
+}
+
+export interface RemoteCallBundle<TRequest = unknown, TResponse = unknown> {
+	readonly responses: Node<RemoteCallResponse<TResponse>>;
+	readonly results: Node<RemoteCallResult<TResponse>>;
+	readonly status: Node<RemoteCallStatus>;
+	readonly errors: Node<RemoteCallError>;
+	readonly timeouts: Node<RemoteCallTimeout>;
+	call(
+		operation: string,
+		requestId: string,
+		payload: TRequest,
+		opts?: { readonly idempotencyKey?: string },
+	): RemoteCallRequest<TRequest>;
+	timeout(requestId: string, operation: string | undefined, error: string): RemoteCallTimeout;
+}
+
+export type RemoteResponderHandler<TRequest = unknown, TResponse = unknown> = (
+	request: RemoteCallRequest<TRequest>,
+) => TResponse;
+
+export interface RemoteResponderHandlerDefinition<TRequest = unknown, TResponse = unknown> {
+	readonly operation: string;
+	readonly handle: RemoteResponderHandler<TRequest, TResponse>;
+}
+
+export type RemoteResponderEvent<TRequest = unknown, TResponse = unknown> =
+	| {
+			readonly kind: "request";
+			readonly request: RemoteCallRequest<TRequest>;
+			readonly seq: number;
+	  }
+	| {
+			readonly kind: "response";
+			readonly requestId: string;
+			readonly operation: string;
+			readonly command: WireBridgeCommand<RemoteCallResponse<TResponse>>;
+	  }
+	| {
+			readonly kind: "rejected";
+			readonly requestId?: string;
+			readonly operation?: string;
+			readonly error: string;
+			readonly command?: WireBridgeCommand<RemoteCallResponse<TResponse>>;
+	  }
+	| { readonly kind: "invalid"; readonly error: string };
+
+export type RemoteResponderStatusState = "idle" | "responded" | "rejected" | "errored";
+
+export interface RemoteResponderStatus {
+	readonly state: RemoteResponderStatusState;
+	readonly operation?: string;
+	readonly requestId?: string;
+	readonly handled: number;
+	readonly rejected: number;
+	readonly errors: number;
+}
+
+export interface RemoteResponderOptions<TRequest = unknown, TResponse = unknown> {
+	readonly name?: string;
+	readonly handlers?: readonly RemoteResponderHandlerDefinition<TRequest, TResponse>[];
+	/** Default false: non-owned operations are ignored so multiple responders may share one bridge. */
+	readonly rejectUnknown?: boolean;
+}
+
+export interface RemoteResponderBundle<TRequest = unknown, TResponse = unknown> {
+	readonly events: Node<RemoteResponderEvent<TRequest, TResponse>>;
+	readonly responseCommands: Node<WireBridgeCommand<RemoteCallResponse<TResponse>>>;
+	readonly requests: Node<RemoteCallRequest<TRequest>>;
+	readonly status: Node<RemoteResponderStatus>;
+	readonly errors: Node<RemoteCallError>;
+	release(): void;
+}
+
+export interface PendingEnvelope<TData> {
+	envelope: WireBridgeEnvelope<TData>;
+	timeoutReportedAttempt?: number;
+	retryDueAtMs?: number;
+}
+
+export interface BridgeState<TData> {
+	cleanupInstalled: boolean;
+	nextSeq: number;
+	cursor: number;
+	remoteCursor: number;
+	terminalReported: boolean;
+	pending: Map<number, PendingEnvelope<TData>>;
+}
+
+export interface AttachedCommandSources<TOutbound> {
+	sources: Node<WireBridgeCommand<TOutbound>>[];
+}
+
+export interface WireBridgeInvalidIngress {
+	readonly __wireBridgeInvalidIngress: true;
+	readonly error: string;
+}
diff --git a/packages/ts/src/adapters/bridge-validation.ts b/packages/ts/src/adapters/bridge-validation.ts
new file mode 100644
index 00000000..9df972eb
--- /dev/null
+++ b/packages/ts/src/adapters/bridge-validation.ts
@@ -0,0 +1,434 @@
+/**
+ * Graph-visible wire bridge envelope helpers (D134).
+ *
+ * This first slice is transport-free: commands become outbound envelope facts,
+ * remote receipts enter only through the inbound fact node, and retry/ack timeout
+ * state is surfaced through graph-visible attempts/status/errors nodes.
+ */
+
+import { assertStrictJsonValue } from "../json/codec.js";
+import type { CanonicalWireBridgeDataBody, CanonicalWireEdgeFrame } from "./bridge-protobuf.js";
+import type {
+	RemoteCallRequest,
+	RemoteCallResponse,
+	WireBridgeEnvelope,
+	WireBridgeEnvelopeType,
+	WireBridgeMetadata,
+} from "./bridge-types.js";
+
+export const envelopeTypes = new Set<WireBridgeEnvelopeType>([
+	"start",
+	"data",
+	"ack",
+	"nack",
+	"status",
+	"error",
+	"close",
+]);
+
+export function validateRemoteCallRequest<T>(value: unknown): RemoteCallRequest<T> | undefined {
+	if (!isRecord(value)) return undefined;
+	if (typeof value.operation !== "string" || value.operation.length === 0) return undefined;
+	if (typeof value.requestId !== "string" || value.requestId.length === 0) return undefined;
+	if (!("payload" in value)) return undefined;
+	return {
+		operation: value.operation,
+		requestId: value.requestId,
+		payload: value.payload as T,
+	};
+}
+
+export function validateRemoteCallResponse<T>(value: unknown): RemoteCallResponse<T> | undefined {
+	if (!isRecord(value)) return undefined;
+	if (typeof value.operation !== "string" || value.operation.length === 0) return undefined;
+	if (typeof value.requestId !== "string" || value.requestId.length === 0) return undefined;
+	if (value.kind === "result" && "payload" in value) {
+		return {
+			kind: "result",
+			operation: value.operation,
+			requestId: value.requestId,
+			payload: value.payload as T,
+		};
+	}
+	if (value.kind === "error" && typeof value.error === "string" && value.error.length > 0) {
+		return {
+			kind: "error",
+			operation: value.operation,
+			requestId: value.requestId,
+			error: value.error,
+		};
+	}
+	if (value.kind === "status" && typeof value.status === "string" && value.status.length > 0) {
+		return {
+			kind: "status",
+			operation: value.operation,
+			requestId: value.requestId,
+			status: value.status,
+		};
+	}
+	return undefined;
+}
+
+export function remoteMalformedResponseRequestId(value: unknown): string | undefined {
+	if (!isRecord(value)) return undefined;
+	return typeof value.requestId === "string" && value.requestId.length > 0
+		? value.requestId
+		: undefined;
+}
+
+export function remoteMalformedResponseOperation(value: unknown): string | undefined {
+	if (!isRecord(value)) return undefined;
+	return typeof value.operation === "string" && value.operation.length > 0
+		? value.operation
+		: undefined;
+}
+
+export function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null;
+}
+
+export function isThenable(value: unknown): boolean {
+	return isRecord(value) && typeof value.then === "function";
+}
+
+export function validateInboundEnvelope(envelope: unknown): string | undefined {
+	if (typeof envelope !== "object" || envelope === null) {
+		return "wireBridge: inbound envelope must be an object";
+	}
+	const candidate = envelope as Partial<WireBridgeEnvelope<unknown>>;
+	if (typeof candidate.sessionId !== "string" || candidate.sessionId.length === 0) {
+		return "wireBridge: inbound envelope sessionId must be a non-empty string";
+	}
+	if (
+		typeof candidate.type !== "string" ||
+		!envelopeTypes.has(candidate.type as WireBridgeEnvelopeType)
+	) {
+		return "wireBridge: inbound envelope type is not recognized";
+	}
+	const metadata = candidate.metadata as Partial<WireBridgeMetadata> | undefined;
+	if (typeof metadata !== "object" || metadata === null) {
+		return "wireBridge: inbound envelope metadata must be an object";
+	}
+	if (!isSafePositiveInteger(metadata.seq)) {
+		return "wireBridge: inbound envelope seq must be a positive integer";
+	}
+	if (!isSafeNonNegativeInteger(metadata.cursor)) {
+		return "wireBridge: inbound envelope cursor must be a non-negative integer";
+	}
+	if (
+		typeof metadata.idempotencyKey !== "string" ||
+		(metadata.idempotencyKey as string).length === 0
+	) {
+		return "wireBridge: inbound envelope idempotencyKey must be a non-empty string";
+	}
+	if (!isSafePositiveInteger(metadata.attempt)) {
+		return "wireBridge: inbound envelope attempt must be a positive integer";
+	}
+	if (
+		!isSafePositiveInteger(metadata.maxAttempts) ||
+		(metadata.maxAttempts as number) < (metadata.attempt as number)
+	) {
+		return "wireBridge: inbound envelope maxAttempts must be >= attempt";
+	}
+	if (metadata.ackForSeq !== undefined && !isSafePositiveInteger(metadata.ackForSeq)) {
+		return "wireBridge: inbound envelope ackForSeq must be a positive integer";
+	}
+	if ((candidate.type === "ack" || candidate.type === "nack") && metadata.ackForSeq === undefined) {
+		return `wireBridge: inbound ${candidate.type} envelope requires ackForSeq`;
+	}
+	const payloadError = validatePayloadForType(
+		candidate.type as WireBridgeEnvelopeType,
+		candidate.payload,
+		"wireBridge: inbound envelope",
+	);
+	if (payloadError !== undefined) return payloadError;
+	return undefined;
+}
+
+export function validateCommand(value: unknown): string | undefined {
+	if (typeof value !== "object" || value === null) {
+		return "wireBridge: command fact must be an object";
+	}
+	const kind = (value as { readonly kind?: unknown }).kind;
+	if (
+		kind !== "start" &&
+		kind !== "send" &&
+		kind !== "ack" &&
+		kind !== "nack" &&
+		kind !== "ack-timeout" &&
+		kind !== "close"
+	) {
+		return "wireBridge: command kind is not recognized";
+	}
+	if (
+		(kind === "ack" || kind === "nack") &&
+		!isSafePositiveInteger((value as { readonly ackForSeq?: unknown }).ackForSeq)
+	) {
+		return `wireBridge: ${kind} command ackForSeq must be a positive integer`;
+	}
+	if (kind === "ack-timeout") {
+		const timeout = value as {
+			readonly seq?: unknown;
+			readonly attempt?: unknown;
+			readonly observedAtMs?: unknown;
+		};
+		if (!isSafePositiveInteger(timeout.seq)) {
+			return "wireBridge: ack-timeout command seq must be a positive integer";
+		}
+		if (!isSafePositiveInteger(timeout.attempt)) {
+			return "wireBridge: ack-timeout command attempt must be a positive integer";
+		}
+		const observedAtMs = timeout.observedAtMs;
+		if (
+			observedAtMs !== undefined &&
+			(typeof observedAtMs !== "number" || !Number.isFinite(observedAtMs) || observedAtMs < 0)
+		) {
+			return "wireBridge: ack-timeout command observedAtMs must be a non-negative finite number";
+		}
+	}
+	return undefined;
+}
+
+export function shouldTrackAck(type: WireBridgeEnvelopeType): boolean {
+	return type === "start" || type === "data" || type === "close";
+}
+
+export function isSafePositiveInteger(value: unknown): value is number {
+	return Number.isSafeInteger(value) && (value as number) > 0;
+}
+
+export function isSafeNonNegativeInteger(value: unknown): value is number {
+	return Number.isSafeInteger(value) && (value as number) >= 0;
+}
+
+export function validatePayloadForType(
+	type: WireBridgeEnvelopeType,
+	payload: unknown,
+	prefix: string,
+): string | undefined {
+	const record =
+		typeof payload === "object" && payload !== null
+			? (payload as Record<string, unknown>)
+			: undefined;
+	const kind = record === undefined ? undefined : ownData(record, "kind");
+	switch (type) {
+		case "data":
+			if (kind !== "data" || record === undefined || !hasOwnData(record, "value")) {
+				return `${prefix}: data envelope requires data payload`;
+			}
+			return wireAdmissiblePayloadError(ownData(record, "value"), `${prefix}: data payload`);
+		case "nack":
+		case "error":
+			if (kind !== "error" || record === undefined || !hasOwnData(record, "error")) {
+				return `${prefix}: ${type} envelope requires error payload`;
+			}
+			return wireAdmissiblePayloadError(ownData(record, "error"), `${prefix}: ${type} payload`);
+		case "status":
+			if (kind !== "status" || record === undefined || !hasOwnData(record, "status")) {
+				return `${prefix}: status envelope requires status payload`;
+			}
+			return wireAdmissiblePayloadError(ownData(record, "status"), `${prefix}: status payload`);
+		case "close":
+			if (kind !== "close") return `${prefix}: close envelope requires close payload`;
+			if (record === undefined || !("reason" in record)) return undefined;
+			if (!hasOwnData(record, "reason")) {
+				return `${prefix}: close reason must be a data property`;
+			}
+			return wireAdmissiblePayloadError(ownData(record, "reason"), `${prefix}: close reason`);
+		case "start":
+		case "ack":
+			return payload === undefined
+				? undefined
+				: `${prefix}: ${type} envelope must not carry a payload`;
+	}
+}
+
+export function normalizeWireAdmissiblePayload(value: unknown, label: string): unknown {
+	if (value instanceof Uint8Array) return Uint8Array.from(value);
+	if (isCanonicalWireBridgeDataBody(value)) return cloneCanonicalWireBridgeDataBody(value);
+	if (isCanonicalWireEdgeFrame(value)) return cloneCanonicalWireEdgeFrame(value);
+	if (isCanonicalWireBridgeDataBodyLike(value) || isCanonicalWireEdgeFrameLike(value)) {
+		throw new TypeError(`${label}: invalid canonical wire DTO`);
+	}
+	try {
+		return assertStrictJsonValue(value, label);
+	} catch (error) {
+		throw new TypeError(
+			`${label}: wire-admissible payload must be copied bytes, canonical WireEdgeFrame material, or strict JSON-like material`,
+			{ cause: error },
+		);
+	}
+}
+
+export function wireAdmissiblePayloadError(value: unknown, label: string): string | undefined {
+	try {
+		normalizeWireAdmissiblePayload(value, label);
+		return undefined;
+	} catch (error) {
+		return errorMessage(error);
+	}
+}
+
+export function normalizeWireBridgePayload<T>(
+	payload:
+		| { readonly kind: "data"; readonly value: T }
+		| { readonly kind: "error"; readonly error: unknown }
+		| { readonly kind: "status"; readonly status: unknown }
+		| { readonly kind: "close"; readonly reason?: unknown }
+		| undefined,
+	prefix: string,
+): typeof payload {
+	if (payload === undefined) return undefined;
+	if (payload.kind === "data") {
+		return {
+			...payload,
+			value: normalizeWireAdmissiblePayload(payload.value, `${prefix}: data payload`) as T,
+		};
+	}
+	if (payload.kind === "error") {
+		return {
+			...payload,
+			error: normalizeWireAdmissiblePayload(payload.error, `${prefix}: error payload`),
+		};
+	}
+	if (payload.kind === "status") {
+		return {
+			...payload,
+			status: normalizeWireAdmissiblePayload(payload.status, `${prefix}: status payload`),
+		};
+	}
+	if ("reason" in payload) {
+		if (payload.reason === undefined) return { kind: "close" };
+		return {
+			...payload,
+			reason: normalizeWireAdmissiblePayload(payload.reason, `${prefix}: close reason`),
+		};
+	}
+	return payload;
+}
+
+function isCanonicalWireBridgeDataBody(value: unknown): value is CanonicalWireBridgeDataBody {
+	if (!isPlainDataRecord(value)) return false;
+	const kind = ownData(value, "kind");
+	if (kind === "value") {
+		return hasOnlyKeys(value, ["kind", "value"]) && ownData(value, "value") instanceof Uint8Array;
+	}
+	if (kind === "wire_edge") {
+		return (
+			hasOnlyKeys(value, ["frame", "kind"]) && isCanonicalWireEdgeFrame(ownData(value, "frame"))
+		);
+	}
+	return false;
+}
+
+function isCanonicalWireBridgeDataBodyLike(value: unknown): boolean {
+	if (!isPlainDataRecord(value)) return false;
+	const kind = ownData(value, "kind");
+	if (kind === "wire_edge") return "frame" in value;
+	if (kind !== "value") return false;
+	return "value" in value && ownData(value, "value") instanceof Uint8Array;
+}
+
+function isCanonicalWireEdgeFrame(value: unknown): value is CanonicalWireEdgeFrame {
+	if (!isPlainDataRecord(value)) return false;
+	const kind = ownData(value, "kind");
+	const edgeId = ownData(value, "edgeId");
+	const causeId = ownData(value, "causeId");
+	if (typeof edgeId !== "string" || edgeId.length === 0) return false;
+	if (typeof causeId !== "string" || causeId.length === 0) return false;
+	if (kind === "dirty") return hasOnlyKeys(value, ["causeId", "edgeId", "kind"]);
+	if (kind === "data") {
+		return (
+			hasOnlyKeys(value, ["causeId", "edgeId", "kind", "value"]) &&
+			ownData(value, "value") instanceof Uint8Array
+		);
+	}
+	return false;
+}
+
+function isCanonicalWireEdgeFrameLike(value: unknown): boolean {
+	if (!isPlainDataRecord(value)) return false;
+	const kind = ownData(value, "kind");
+	if (kind !== "dirty" && kind !== "data") return false;
+	return "edgeId" in value || "causeId" in value || "value" in value;
+}
+
+function isPlainDataRecord(value: unknown): value is Record<string, unknown> {
+	if (!isRecord(value)) return false;
+	const proto = Object.getPrototypeOf(value);
+	if (proto !== Object.prototype && proto !== null) return false;
+	if (Object.getOwnPropertySymbols(value).length > 0) return false;
+	for (const key of Object.getOwnPropertyNames(value)) {
+		const descriptor = Object.getOwnPropertyDescriptor(value, key);
+		if (descriptor === undefined || !("value" in descriptor) || !descriptor.enumerable) {
+			return false;
+		}
+	}
+	return true;
+}
+
+function ownData(value: Record<string, unknown>, key: string): unknown {
+	const descriptor = Object.getOwnPropertyDescriptor(value, key);
+	return descriptor !== undefined && "value" in descriptor ? descriptor.value : undefined;
+}
+
+function hasOwnData(value: Record<string, unknown>, key: string): boolean {
+	const descriptor = Object.getOwnPropertyDescriptor(value, key);
+	return descriptor !== undefined && "value" in descriptor;
+}
+
+function hasOnlyKeys(value: Record<string, unknown>, keys: readonly string[]): boolean {
+	const allowed = new Set(keys);
+	const actual = Object.getOwnPropertyNames(value);
+	return actual.length === keys.length && actual.every((key) => allowed.has(key));
+}
+
+function cloneCanonicalWireBridgeDataBody(
+	value: CanonicalWireBridgeDataBody,
+): CanonicalWireBridgeDataBody {
+	if (value.kind === "value") return { kind: "value", value: Uint8Array.from(value.value) };
+	return { kind: "wire_edge", frame: cloneCanonicalWireEdgeFrame(value.frame) };
+}
+
+function cloneCanonicalWireEdgeFrame(value: CanonicalWireEdgeFrame): CanonicalWireEdgeFrame {
+	return {
+		kind: value.kind,
+		edgeId: value.edgeId,
+		causeId: value.causeId,
+		...(value.value === undefined ? {} : { value: Uint8Array.from(value.value) }),
+	};
+}
+
+export function bridgePayloadError(payload: unknown, fallback: unknown): unknown {
+	if (
+		typeof payload === "object" &&
+		payload !== null &&
+		(payload as { readonly kind?: unknown }).kind === "error"
+	) {
+		return (payload as { readonly error?: unknown }).error;
+	}
+	return fallback;
+}
+
+export function rethrowGraphRuntimeInvariant(error: unknown): void {
+	const message = errorMessage(error);
+	if (
+		message.includes("R-reentrancy") ||
+		message.includes("R-rewire") ||
+		message.includes("R-graph-domain") ||
+		message.includes("D37") ||
+		message.includes("D22") ||
+		message.includes("different graph") ||
+		message.includes("cross-graph") ||
+		message.includes("wire bridge") ||
+		message.includes("mid-fn topology mutation") ||
+		message.includes("reentrant dep mutation") ||
+		message.includes("feedback cycle")
+	) {
+		throw error;
+	}
+}
+
+export function errorMessage(error: unknown): string {
+	return error instanceof Error ? error.message : String(error);
+}
diff --git a/packages/ts/src/adapters/bridge-wire-edge-group.ts b/packages/ts/src/adapters/bridge-wire-edge-group.ts
new file mode 100644
index 00000000..118e893c
--- /dev/null
+++ b/packages/ts/src/adapters/bridge-wire-edge-group.ts
@@ -0,0 +1,625 @@
+import { type Ctx, depBatch } from "../ctx/types.js";
+import type { Graph } from "../graph/graph.js";
+import type { Node } from "../node/node.js";
+import type { CanonicalWireEdgeFrame } from "./bridge-protobuf.js";
+import type {
+	WireBridgeBundle,
+	WireBridgeCommand,
+	WireBridgeEnvelope,
+	WireBridgeProtobufData,
+} from "./bridge-types.js";
+
+export interface WireEdgeGroupEdge {
+	readonly edgeId: string;
+	readonly outbound?: Node<Uint8Array>;
+}
+export type WireEdgeGroupIssueCode =
+	| "wire-edge-group-missing-snapshot"
+	| "wire-edge-group-unknown-edge"
+	| "wire-edge-group-duplicate-dirty"
+	| "wire-edge-group-duplicate-data"
+	| "wire-edge-group-data-before-dirty"
+	| "wire-edge-group-competing-cause"
+	| "wire-edge-group-malformed-frame"
+	| "wire-edge-group-incomplete-cause";
+export interface WireEdgeGroupIssue {
+	readonly code: WireEdgeGroupIssueCode;
+	readonly message: string;
+	readonly edgeId?: string;
+	readonly causeId?: string;
+	readonly activeCauseId?: string;
+}
+export interface WireEdgeGroupStatus {
+	readonly state: "idle" | "collecting" | "released" | "issues";
+	readonly expectedEdges: readonly string[];
+	readonly dirty: number;
+	readonly data: number;
+	readonly released: number;
+	readonly issues: number;
+	readonly activeCauseId?: string;
+	readonly lastIssue?: WireEdgeGroupIssue;
+}
+export interface WireEdgeGroupOptions {
+	readonly name?: string;
+	readonly edges: readonly WireEdgeGroupEdge[];
+}
+export interface WireEdgeGroupBundle {
+	readonly inbound: ReadonlyMap<string, Node<Uint8Array>>;
+	readonly status: Node<WireEdgeGroupStatus>;
+	readonly issues: Node<WireEdgeGroupIssue>;
+	release(): void;
+}
+
+type Command = WireBridgeCommand<WireBridgeProtobufData>;
+type Event =
+	| { kind: "outbound"; command: Command }
+	| { kind: "frame"; frame: CanonicalWireEdgeFrame }
+	| { kind: "bridge-end" }
+	| { kind: "issue"; issue: WireEdgeGroupIssue };
+type Gate =
+	| { kind: "release"; causeId: string; edgeId: string; value: Uint8Array }
+	| { kind: "progress"; causeId: string; dirty: number; data: number }
+	| { kind: "issue"; issue: WireEdgeGroupIssue };
+interface OutState {
+	nextCause: number;
+	snapshots: Map<string, Uint8Array>;
+}
+interface GateState {
+	activeCauseId?: string;
+	dirty: Set<string>;
+	data: Map<string, Uint8Array>;
+	failed: CauseTombstones;
+	released: CauseTombstones;
+}
+
+const WIRE_EDGE_GROUP_CAUSE_TOMBSTONE_LIMIT = 1024;
+
+class CauseTombstones {
+	private readonly seen = new Set<string>();
+	private readonly order: string[] = [];
+
+	has(causeId: string): boolean {
+		return this.seen.has(causeId);
+	}
+
+	add(causeId: string): void {
+		if (this.seen.has(causeId)) return;
+		this.seen.add(causeId);
+		this.order.push(causeId);
+		while (this.order.length > WIRE_EDGE_GROUP_CAUSE_TOMBSTONE_LIMIT) {
+			const evicted = this.order.shift();
+			if (evicted !== undefined) this.seen.delete(evicted);
+		}
+	}
+}
+
+export function wireEdgeGroup(
+	graph: Graph,
+	bridge: WireBridgeBundle<WireBridgeProtobufData, WireBridgeProtobufData>,
+	opts: WireEdgeGroupOptions,
+): WireEdgeGroupBundle {
+	const name = opts.name ?? "wireEdgeGroup";
+	const edges = normalize(opts.edges);
+	const expected = edges.map((edge) => edge.edgeId);
+	const outbound = edges
+		.map((edge, index) => ({ edge, index }))
+		.filter(
+			(entry): entry is { edge: { edgeId: string; outbound: Node<Uint8Array> }; index: number } =>
+				entry.edge.outbound !== undefined,
+		);
+	const topology = graph.topologyGroup({ name: `${name}.wireEdgeGroup` });
+	const events = topology.node<Event>(
+		[...outbound.map((entry) => entry.edge.outbound), bridge.inbound],
+		eventsFn(
+			name,
+			edges,
+			outbound.map((entry) => entry.index),
+		),
+		{
+			name: `${name}/events`,
+			factory: "wireEdgeGroupEvents",
+			partial: true,
+			completeWhenDepsComplete: false,
+			errorWhenDepsError: false,
+			terminalAsRealInput: true,
+		},
+	);
+	const gate = topology.node<Gate>([events], gateFn(name, expected), {
+		name: `${name}/gate`,
+		factory: "wireEdgeGroupGate",
+		partial: true,
+		completeWhenDepsComplete: false,
+		errorWhenDepsError: false,
+	});
+	const commands = topology.node<Command>(
+		[events],
+		(ctx) => {
+			for (const raw of depBatch(ctx, 0) ?? []) {
+				const event = raw as Event;
+				if (event.kind === "outbound") ctx.down([["DATA", event.command]]);
+			}
+		},
+		{
+			name: `${name}/commands`,
+			factory: "wireEdgeGroupCommands",
+			partial: true,
+			completeWhenDepsComplete: false,
+			errorWhenDepsError: false,
+		},
+	);
+	const issues = topology.node<WireEdgeGroupIssue>(
+		[events, gate],
+		(ctx) => {
+			for (const raw of depBatch(ctx, 0) ?? []) {
+				const event = raw as Event;
+				if (event.kind === "issue") ctx.down([["DATA", event.issue]]);
+			}
+			for (const raw of depBatch(ctx, 1) ?? []) {
+				const event = raw as Gate;
+				if (event.kind === "issue") ctx.down([["DATA", event.issue]]);
+			}
+		},
+		{
+			name: `${name}/issues`,
+			factory: "wireEdgeGroupIssues",
+			partial: true,
+			completeWhenDepsComplete: false,
+			errorWhenDepsError: false,
+		},
+	);
+	const status = topology.node<WireEdgeGroupStatus>([events, gate], statusFn(expected), {
+		name: `${name}/status`,
+		factory: "wireEdgeGroupStatus",
+		partial: true,
+		completeWhenDepsComplete: false,
+		errorWhenDepsError: false,
+	});
+	const inbound = new Map(
+		edges.map(
+			(edge) =>
+				[
+					edge.edgeId,
+					topology.node<Uint8Array>(
+						[gate],
+						(ctx) => {
+							for (const raw of depBatch(ctx, 0) ?? []) {
+								const event = raw as Gate;
+								if (event.kind === "release" && event.edgeId === edge.edgeId)
+									ctx.down([["DATA", Uint8Array.from(event.value)]]);
+							}
+						},
+						{
+							name: `${name}/inbound/${edge.edgeId}`,
+							factory: "wireEdgeGroupInboundEdge",
+							partial: true,
+							completeWhenDepsComplete: false,
+							errorWhenDepsError: false,
+							meta: { edgeId: edge.edgeId },
+						},
+					),
+				] as const,
+		),
+	);
+	bridge.command.replaceDeps([commands], commandSourceFn());
+	let released = false;
+	return {
+		inbound,
+		status,
+		issues,
+		release() {
+			if (released) return;
+			bridge.command.replaceDeps([], commandSourceFn());
+			try {
+				topology.release({ reason: `${name}.wireEdgeGroup.release` });
+				released = true;
+			} catch (error) {
+				bridge.command.replaceDeps([commands], commandSourceFn());
+				throw error;
+			}
+		},
+	};
+}
+
+function commandSourceFn(): (ctx: Ctx) => void {
+	return (ctx) => {
+		for (const command of depBatch(ctx, 0) ?? []) ctx.down([["DATA", command as Command]]);
+	};
+}
+function normalize(edges: readonly WireEdgeGroupEdge[]) {
+	const seen = new Set<string>();
+	if (edges.length === 0) throw new RangeError("wireEdgeGroup: edges must be non-empty");
+	return edges.map((edge) => {
+		if (!edge.edgeId) throw new RangeError("wireEdgeGroup: edgeId must be a non-empty string");
+		if (seen.has(edge.edgeId))
+			throw new RangeError(`wireEdgeGroup: duplicate edgeId ${edge.edgeId}`);
+		seen.add(edge.edgeId);
+		return edge;
+	});
+}
+function issue(
+	code: WireEdgeGroupIssueCode,
+	message: string,
+	extra: Omit<WireEdgeGroupIssue, "code" | "message"> = {},
+): WireEdgeGroupIssue {
+	return { code, message, ...extra };
+}
+function send(frame: CanonicalWireEdgeFrame): Command {
+	return { kind: "send", payload: { kind: "wire_edge", frame: clone(frame) } };
+}
+function clone(frame: CanonicalWireEdgeFrame): CanonicalWireEdgeFrame {
+	return frame.kind === "data"
+		? {
+				kind: "data",
+				edgeId: frame.edgeId,
+				causeId: frame.causeId,
+				value: Uint8Array.from(frame.value ?? new Uint8Array()),
+			}
+		: { kind: "dirty", edgeId: frame.edgeId, causeId: frame.causeId };
+}
+function eventsFn(
+	name: string,
+	edges: readonly WireEdgeGroupEdge[],
+	outboundIndexes: readonly number[],
+): (ctx: Ctx) => void {
+	const byDep = new Map<number, WireEdgeGroupEdge>();
+	outboundIndexes.forEach((edgeIndex, depIndex) => {
+		byDep.set(depIndex, edges[edgeIndex]);
+	});
+	const inboundIndex = outboundIndexes.length;
+	return (ctx) => {
+		let st = ctx.state.get<OutState>();
+		if (!st) {
+			st = { nextCause: 1, snapshots: new Map() };
+			ctx.state.set(st);
+		}
+		let trigger = false;
+		for (let i = 0; i < outboundIndexes.length; i++) {
+			const edge = byDep.get(i);
+			if (!edge) continue;
+			for (const raw of depBatch(ctx, i) ?? []) {
+				if (!(raw instanceof Uint8Array))
+					ctx.down([
+						[
+							"DATA",
+							{
+								kind: "issue",
+								issue: issue(
+									"wire-edge-group-malformed-frame",
+									`${name}: outbound edge ${edge.edgeId} must emit Uint8Array bytes`,
+									{ edgeId: edge.edgeId },
+								),
+							} satisfies Event,
+						],
+					]);
+				else {
+					st.snapshots.set(edge.edgeId, Uint8Array.from(raw));
+					trigger = true;
+				}
+			}
+		}
+		if (trigger) emitOutbound(ctx, name, edges, st);
+		for (const rawEnvelope of depBatch(ctx, inboundIndex) ?? []) {
+			const ev = frameEvent(name, rawEnvelope as WireBridgeEnvelope<unknown>);
+			if (ev) ctx.down([["DATA", ev]]);
+		}
+	};
+}
+function emitOutbound(
+	ctx: Ctx,
+	name: string,
+	edges: readonly WireEdgeGroupEdge[],
+	st: OutState,
+): void {
+	const missing = edges.filter((edge) => !st.snapshots.has(edge.edgeId));
+	if (missing.length) {
+		for (const edge of missing)
+			ctx.down([
+				[
+					"DATA",
+					{
+						kind: "issue",
+						issue: issue(
+							"wire-edge-group-missing-snapshot",
+							`${name}: missing outbound snapshot for edge ${edge.edgeId}`,
+							{ edgeId: edge.edgeId },
+						),
+					} satisfies Event,
+				],
+			]);
+		return;
+	}
+	const causeId = `${name}:cause:${st.nextCause++}`;
+	for (const edge of edges)
+		ctx.down([
+			[
+				"DATA",
+				{
+					kind: "outbound",
+					command: send({ kind: "dirty", edgeId: edge.edgeId, causeId }),
+				} satisfies Event,
+			],
+		]);
+	for (const edge of edges) {
+		const value = st.snapshots.get(edge.edgeId);
+		if (value)
+			ctx.down([
+				[
+					"DATA",
+					{
+						kind: "outbound",
+						command: send({ kind: "data", edgeId: edge.edgeId, causeId, value }),
+					} satisfies Event,
+				],
+			]);
+	}
+}
+function frameEvent(name: string, envelope: WireBridgeEnvelope<unknown>): Event | undefined {
+	if (envelope.type === "close" || envelope.type === "error") return { kind: "bridge-end" };
+	if (envelope.type !== "data") return undefined;
+	const value = envelope.payload?.kind === "data" ? envelope.payload.value : undefined;
+	if (
+		value instanceof Uint8Array ||
+		(typeof value === "object" && value !== null && (value as { kind?: unknown }).kind === "value")
+	)
+		return undefined;
+	if (
+		typeof value !== "object" ||
+		value === null ||
+		(value as { kind?: unknown }).kind !== "wire_edge"
+	)
+		return {
+			kind: "issue",
+			issue: issue(
+				"wire-edge-group-malformed-frame",
+				`${name}: wire-edge payload must be a wire_edge frame`,
+			),
+		};
+	const frame = (value as { frame?: unknown }).frame;
+	const bad = validate(name, frame);
+	return bad
+		? { kind: "issue", issue: bad }
+		: { kind: "frame", frame: clone(frame as CanonicalWireEdgeFrame) };
+}
+function validate(name: string, frame: unknown): WireEdgeGroupIssue | undefined {
+	if (typeof frame !== "object" || frame === null)
+		return issue("wire-edge-group-malformed-frame", `${name}: wire-edge frame must be an object`);
+	const f = frame as Partial<CanonicalWireEdgeFrame>;
+	if (f.kind !== "dirty" && f.kind !== "data")
+		return issue(
+			"wire-edge-group-malformed-frame",
+			`${name}: wire-edge frame kind must be dirty or data`,
+		);
+	if (!f.edgeId)
+		return issue(
+			"wire-edge-group-malformed-frame",
+			`${name}: wire-edge frame edgeId must be non-empty`,
+			{ causeId: f.causeId },
+		);
+	if (!f.causeId)
+		return issue(
+			"wire-edge-group-malformed-frame",
+			`${name}: wire-edge frame causeId must be non-empty`,
+			{ edgeId: f.edgeId },
+		);
+	if (f.kind === "dirty" && f.value !== undefined)
+		return issue(
+			"wire-edge-group-malformed-frame",
+			`${name}: DIRTY wire-edge frame must not carry value bytes`,
+			{ edgeId: f.edgeId, causeId: f.causeId },
+		);
+	if (f.kind === "data" && !(f.value instanceof Uint8Array))
+		return issue(
+			"wire-edge-group-malformed-frame",
+			`${name}: DATA wire-edge frame requires Uint8Array value bytes`,
+			{ edgeId: f.edgeId, causeId: f.causeId },
+		);
+	return undefined;
+}
+function gateFn(name: string, expectedIds: readonly string[]): (ctx: Ctx) => void {
+	const expected = new Set(expectedIds);
+	return (ctx) => {
+		let st = ctx.state.get<GateState>();
+		if (!st) {
+			st = {
+				dirty: new Set(),
+				data: new Map(),
+				failed: new CauseTombstones(),
+				released: new CauseTombstones(),
+			};
+			ctx.state.set(st);
+		}
+		const emitIssue = (i: WireEdgeGroupIssue) =>
+			ctx.down([["DATA", { kind: "issue", issue: i } satisfies Gate]]);
+		const reset = () => {
+			st.activeCauseId = undefined;
+			st.dirty.clear();
+			st.data.clear();
+		};
+		const fail = (causeId?: string) => {
+			if (causeId) st.failed.add(causeId);
+			reset();
+		};
+		const progress = (causeId: string) =>
+			ctx.down([
+				[
+					"DATA",
+					{ kind: "progress", causeId, dirty: st.dirty.size, data: st.data.size } satisfies Gate,
+				],
+			]);
+		for (const raw of depBatch(ctx, 0) ?? []) {
+			const ev = raw as Event;
+			if (ev.kind === "issue") {
+				emitIssue(ev.issue);
+				continue;
+			}
+			if (ev.kind === "outbound") continue;
+			if (ev.kind === "bridge-end") {
+				if (st.activeCauseId) {
+					emitIssue(
+						issue(
+							"wire-edge-group-incomplete-cause",
+							`${name}: cause ${st.activeCauseId} ended before all expected edge frames arrived`,
+							{ causeId: st.activeCauseId },
+						),
+					);
+					fail(st.activeCauseId);
+				}
+				continue;
+			}
+			const f = ev.frame;
+			if (st.failed.has(f.causeId)) {
+				emitIssue(
+					issue(
+						"wire-edge-group-incomplete-cause",
+						`${name}: cause ${f.causeId} was already failed closed`,
+						{ edgeId: f.edgeId, causeId: f.causeId },
+					),
+				);
+				continue;
+			}
+			if (st.released.has(f.causeId)) {
+				emitIssue(
+					issue(
+						f.kind === "dirty"
+							? "wire-edge-group-duplicate-dirty"
+							: "wire-edge-group-duplicate-data",
+						`${name}: cause ${f.causeId} was already released`,
+						{ edgeId: f.edgeId, causeId: f.causeId },
+					),
+				);
+				continue;
+			}
+			if (!expected.has(f.edgeId)) {
+				emitIssue(
+					issue("wire-edge-group-unknown-edge", `${name}: unknown edge ${f.edgeId}`, {
+						edgeId: f.edgeId,
+						causeId: f.causeId,
+					}),
+				);
+				fail(f.causeId);
+				continue;
+			}
+			if (!st.activeCauseId) st.activeCauseId = f.causeId;
+			if (st.activeCauseId !== f.causeId) {
+				const activeCauseId = st.activeCauseId;
+				emitIssue(
+					issue(
+						"wire-edge-group-competing-cause",
+						`${name}: competing cause ${f.causeId} arrived while ${activeCauseId} is active`,
+						{ edgeId: f.edgeId, causeId: f.causeId, activeCauseId },
+					),
+				);
+				emitIssue(
+					issue(
+						"wire-edge-group-incomplete-cause",
+						`${name}: active cause ${activeCauseId} is incomplete`,
+						{ causeId: activeCauseId },
+					),
+				);
+				fail(activeCauseId);
+				st.failed.add(f.causeId);
+				continue;
+			}
+			if (f.kind === "dirty") {
+				if (st.dirty.has(f.edgeId)) {
+					emitIssue(
+						issue(
+							"wire-edge-group-duplicate-dirty",
+							`${name}: duplicate DIRTY for edge ${f.edgeId}`,
+							{ edgeId: f.edgeId, causeId: f.causeId },
+						),
+					);
+					fail(f.causeId);
+					continue;
+				}
+				st.dirty.add(f.edgeId);
+				progress(f.causeId);
+				continue;
+			}
+			if (!st.dirty.has(f.edgeId)) {
+				emitIssue(
+					issue(
+						"wire-edge-group-data-before-dirty",
+						`${name}: DATA for edge ${f.edgeId} arrived before DIRTY`,
+						{ edgeId: f.edgeId, causeId: f.causeId },
+					),
+				);
+				fail(f.causeId);
+				continue;
+			}
+			if (st.data.has(f.edgeId)) {
+				emitIssue(
+					issue("wire-edge-group-duplicate-data", `${name}: duplicate DATA for edge ${f.edgeId}`, {
+						edgeId: f.edgeId,
+						causeId: f.causeId,
+					}),
+				);
+				fail(f.causeId);
+				continue;
+			}
+			st.data.set(f.edgeId, Uint8Array.from(f.value ?? new Uint8Array()));
+			if (st.dirty.size === expectedIds.length && st.data.size === expectedIds.length) {
+				for (const edgeId of expectedIds) {
+					const value = st.data.get(edgeId);
+					if (value)
+						ctx.down([
+							[
+								"DATA",
+								{
+									kind: "release",
+									causeId: f.causeId,
+									edgeId,
+									value: Uint8Array.from(value),
+								} satisfies Gate,
+							],
+						]);
+				}
+				st.released.add(f.causeId);
+				reset();
+			} else progress(f.causeId);
+		}
+	};
+}
+function statusFn(expectedIds: readonly string[]): (ctx: Ctx) => void {
+	return (ctx) => {
+		let next =
+			ctx.state.get<WireEdgeGroupStatus>() ??
+			({
+				state: "idle",
+				expectedEdges: [...expectedIds],
+				dirty: 0,
+				data: 0,
+				released: 0,
+				issues: 0,
+			} satisfies WireEdgeGroupStatus);
+		for (const raw of depBatch(ctx, 0) ?? []) {
+			const ev = raw as Event;
+			if (ev.kind === "issue")
+				next = { ...next, state: "issues", issues: next.issues + 1, lastIssue: ev.issue };
+		}
+		for (const raw of depBatch(ctx, 1) ?? []) {
+			const ev = raw as Gate;
+			if (ev.kind === "issue")
+				next = { ...next, state: "issues", issues: next.issues + 1, lastIssue: ev.issue };
+			else if (ev.kind === "progress")
+				next = {
+					...next,
+					state: "collecting",
+					activeCauseId: ev.causeId,
+					dirty: ev.dirty,
+					data: ev.data,
+				};
+			else
+				next = {
+					...next,
+					state: "released",
+					activeCauseId: ev.causeId,
+					dirty: expectedIds.length,
+					data: expectedIds.length,
+					released: next.released + 1,
+				};
+		}
+		ctx.state.set(next);
+		ctx.down([["DATA", next]]);
+	};
+}
diff --git a/packages/ts/src/adapters/bridge.ts b/packages/ts/src/adapters/bridge.ts
new file mode 100644
index 00000000..4bdeec53
--- /dev/null
+++ b/packages/ts/src/adapters/bridge.ts
@@ -0,0 +1,1732 @@
+/**
+ * Graph-visible wire bridge envelope helpers (D134).
+ *
+ * This first slice is transport-free: commands become outbound envelope facts,
+ * remote receipts enter only through the inbound fact node, and retry/ack timeout
+ * state is surfaced through graph-visible attempts/status/errors nodes.
+ */
+
+import { type Ctx, depBatch } from "../ctx/types.js";
+import type { Graph } from "../graph/graph.js";
+import {
+	nextRetryDelayMs,
+	type RetryPolicy,
+	retryPolicy,
+	shouldRetry,
+} from "../graph/resilience.js";
+import type { Node } from "../node/node.js";
+import { errorPayload } from "../protocol/messages.js";
+import type {
+	CanonicalWireBridgeDataBody,
+	CanonicalWireBridgeEnvelope,
+	CanonicalWireBridgeMetadata,
+	CanonicalWireBridgePayload,
+	CanonicalWireEdgeFrame,
+} from "./bridge-protobuf.js";
+import {
+	CanonicalProtobufError,
+	decodeCanonicalWireBridgeEnvelope,
+	encodeCanonicalWireBridgeEnvelope,
+} from "./bridge-protobuf.js";
+import type {
+	AttachedCommandSources,
+	BridgeState,
+	RemoteCallRequest,
+	RemoteCallResponse,
+	RemoteResponderBundle,
+	RemoteResponderHandler,
+	RemoteResponderHandlerDefinition,
+	RemoteResponderOptions,
+	WireBridgeAckDriverBundle,
+	WireBridgeAckDriverIssue,
+	WireBridgeAckDriverOptions,
+	WireBridgeAckDriverStatus,
+	WireBridgeBundle,
+	WireBridgeCommand,
+	WireBridgeEnvelope,
+	WireBridgeEnvelopeType,
+	WireBridgeEvent,
+	WireBridgeInvalidIngress,
+	WireBridgeMetadata,
+	WireBridgeOptions,
+	WireBridgePayload,
+	WireBridgeProtobufBundle,
+	WireBridgeProtobufData,
+	WireBridgeProtobufIssue,
+	WireBridgeProtobufOptions,
+	WireBridgeProtobufStatus,
+} from "./bridge-types.js";
+
+export type {
+	CanonicalProtobufErrorCategory,
+	CanonicalWireBridgeDataBody,
+	CanonicalWireBridgeEnvelope,
+	CanonicalWireBridgeMetadata,
+	CanonicalWireBridgePayload,
+	CanonicalWireEdgeFrame,
+} from "./bridge-protobuf.js";
+export {
+	CanonicalProtobufError,
+	decodeCanonicalWireBridgeEnvelope,
+	decodeCanonicalWireEdgeFrame,
+	encodeCanonicalWireBridgeEnvelope,
+	encodeCanonicalWireEdgeFrame,
+} from "./bridge-protobuf.js";
+export { remoteCall } from "./bridge-remote-call.js";
+export type {
+	RemoteCallBundle,
+	RemoteCallError,
+	RemoteCallOptions,
+	RemoteCallRequest,
+	RemoteCallResponse,
+	RemoteCallResult,
+	RemoteCallStatus,
+	RemoteCallStatusState,
+	RemoteCallTimeout,
+	RemoteResponderBundle,
+	RemoteResponderEvent,
+	RemoteResponderHandler,
+	RemoteResponderHandlerDefinition,
+	RemoteResponderOptions,
+	RemoteResponderStatus,
+	RemoteResponderStatusState,
+	WireBridgeAck,
+	WireBridgeAckDriverBundle,
+	WireBridgeAckDriverIssue,
+	WireBridgeAckDriverOptions,
+	WireBridgeAckDriverStatus,
+	WireBridgeAttempt,
+	WireBridgeBundle,
+	WireBridgeCommand,
+	WireBridgeEnvelope,
+	WireBridgeEnvelopeType,
+	WireBridgeEvent,
+	WireBridgeMetadata,
+	WireBridgeNack,
+	WireBridgeOptions,
+	WireBridgePayload,
+	WireBridgeProtobufBundle,
+	WireBridgeProtobufData,
+	WireBridgeProtobufIssue,
+	WireBridgeProtobufOptions,
+	WireBridgeProtobufStatus,
+	WireBridgeStatus,
+} from "./bridge-types.js";
+
+import {
+	guardedInboundNode,
+	invalidIngress,
+	isInvalidIngress,
+	projectAcks,
+	projectAttempts,
+	projectCursor,
+	projectErrors,
+	projectNacks,
+	projectOutbound,
+	projectStatus,
+} from "./bridge-projections.js";
+import {
+	normalizeRemoteHandlers,
+	remoteResponderErrorsNode,
+	remoteResponderEventsNode,
+	remoteResponderRequestsNode,
+	remoteResponderResponseCommandsNode,
+	remoteResponderStatusNode,
+} from "./bridge-remote-responder.js";
+import {
+	bridgePayloadError,
+	envelopeTypes,
+	isSafeNonNegativeInteger,
+	isSafePositiveInteger,
+	normalizeWireBridgePayload,
+	shouldTrackAck,
+	validateCommand,
+	validateInboundEnvelope,
+	validatePayloadForType,
+} from "./bridge-validation.js";
+
+const bridgeCommandSources = new WeakMap<
+	WireBridgeBundle<unknown, unknown>,
+	AttachedCommandSources<unknown>
+>();
+const bridgeInboundTargets = new WeakMap<
+	WireBridgeBundle<unknown, unknown>,
+	Node<WireBridgeEnvelope<unknown> | WireBridgeInvalidIngress>
+>();
+const bridgeInboundSources = new WeakMap<
+	WireBridgeBundle<unknown, unknown>,
+	{ sources: Node<WireBridgeEnvelope<unknown> | WireBridgeInvalidIngress>[] }
+>();
+
+/** Stable D134 idempotency key helper scoped to one bridge session and sequence. */
+export function wireBridgeIdempotencyKey(sessionId: string, seq: number): string {
+	return `${sessionId}:${seq}`;
+}
+
+/** Create a D134 wire bridge envelope with ordered metadata. */
+export function wireBridgeEnvelope<TData = unknown>(input: {
+	readonly sessionId: string;
+	readonly type: WireBridgeEnvelopeType;
+	readonly seq: number;
+	readonly cursor?: number;
+	readonly payload?: WireBridgePayload<TData>;
+	readonly idempotencyKey?: string;
+	readonly attempt?: number;
+	readonly maxAttempts?: number;
+	readonly timestampMs?: number;
+	readonly ackForSeq?: number;
+	readonly requestId?: string;
+}): WireBridgeEnvelope<TData> {
+	if (typeof input.sessionId !== "string" || input.sessionId.length === 0) {
+		throw new RangeError("wireBridgeEnvelope: sessionId must be a non-empty string");
+	}
+	if (!envelopeTypes.has(input.type)) {
+		throw new RangeError("wireBridgeEnvelope: type is not recognized");
+	}
+	if (!isSafePositiveInteger(input.seq)) {
+		throw new RangeError("wireBridgeEnvelope: seq must be a positive integer");
+	}
+	const cursor = input.cursor ?? 0;
+	if (!isSafeNonNegativeInteger(cursor)) {
+		throw new RangeError("wireBridgeEnvelope: cursor must be a non-negative integer");
+	}
+	const attempt = input.attempt ?? 1;
+	if (!isSafePositiveInteger(attempt)) {
+		throw new RangeError("wireBridgeEnvelope: attempt must be a positive integer");
+	}
+	const maxAttempts = input.maxAttempts ?? attempt;
+	if (!isSafePositiveInteger(maxAttempts) || maxAttempts < attempt) {
+		throw new RangeError("wireBridgeEnvelope: maxAttempts must be >= attempt");
+	}
+	if (input.ackForSeq !== undefined && !isSafePositiveInteger(input.ackForSeq)) {
+		throw new RangeError("wireBridgeEnvelope: ackForSeq must be a positive integer");
+	}
+	if ((input.type === "ack" || input.type === "nack") && input.ackForSeq === undefined) {
+		throw new RangeError(`wireBridgeEnvelope: ${input.type} envelope requires ackForSeq`);
+	}
+	if (input.idempotencyKey !== undefined && input.idempotencyKey.length === 0) {
+		throw new RangeError("wireBridgeEnvelope: idempotencyKey must be a non-empty string");
+	}
+	const payloadError = validatePayloadForType(input.type, input.payload, "wireBridgeEnvelope");
+	if (payloadError !== undefined) {
+		throw new RangeError(payloadError);
+	}
+	const payload = normalizeWireBridgePayload(
+		input.payload,
+		`wireBridgeEnvelope ${input.type} envelope`,
+	) as WireBridgePayload<TData> | undefined;
+	return {
+		sessionId: input.sessionId,
+		type: input.type,
+		payload,
+		metadata: {
+			seq: input.seq,
+			cursor,
+			idempotencyKey: input.idempotencyKey ?? wireBridgeIdempotencyKey(input.sessionId, input.seq),
+			attempt,
+			maxAttempts,
+			timestampMs: input.timestampMs,
+			ackForSeq: input.ackForSeq,
+			requestId: input.requestId,
+		},
+	};
+}
+
+export function wireBridge<TOutbound = unknown, TInbound = unknown>(
+	graph: Graph,
+	opts: WireBridgeOptions,
+): WireBridgeBundle<TOutbound, TInbound> {
+	const name = opts.name ?? "wireBridge";
+	const policy = opts.retry ?? retryPolicy();
+	const command = graph.node<WireBridgeCommand<TOutbound>>([], null, {
+		name: `${name}/command`,
+		factory: "wireBridgeCommand",
+	});
+	const inboundCore = graph.node<WireBridgeEnvelope<TInbound> | WireBridgeInvalidIngress>(
+		[],
+		null,
+		{
+			name: `${name}/inbound`,
+			factory: "wireBridgeInbound",
+		},
+	);
+	const inbound = guardedInboundNode(inboundCore, opts.sessionId);
+	const events = wireBridgeEventsNode<TOutbound, TInbound>(
+		graph,
+		command,
+		inboundCore,
+		name,
+		opts,
+		policy,
+	);
+	const outbound = projectOutbound(graph, events, name);
+	const acks = projectAcks(graph, events, name);
+	const nacks = projectNacks(graph, events, name);
+	const status = projectStatus(graph, events, name, opts.sessionId);
+	const errors = projectErrors(graph, events, name);
+	const cursor = projectCursor(graph, events, name);
+	const attempts = projectAttempts(graph, events, name);
+	const bundle: WireBridgeBundle<TOutbound, TInbound> = {
+		sessionId: opts.sessionId,
+		command,
+		outbound,
+		inbound,
+		events,
+		acks,
+		nacks,
+		status,
+		errors,
+		cursor,
+		attempts,
+		start: () => command.down([["DATA", { kind: "start" }]]),
+		send: (payload, sendOpts) =>
+			command.down([
+				[
+					"DATA",
+					{
+						kind: "send",
+						payload,
+						idempotencyKey: sendOpts?.idempotencyKey,
+						requestId: sendOpts?.requestId,
+					},
+				],
+			]),
+		ack: (ackForSeq, ackOpts) =>
+			command.down([
+				[
+					"DATA",
+					{
+						kind: "ack",
+						ackForSeq,
+						idempotencyKey: ackOpts?.idempotencyKey,
+						requestId: ackOpts?.requestId,
+					},
+				],
+			]),
+		nack: (ackForSeq, error, nackOpts) =>
+			command.down([
+				[
+					"DATA",
+					{
+						kind: "nack",
+						ackForSeq,
+						error,
+						idempotencyKey: nackOpts?.idempotencyKey,
+						requestId: nackOpts?.requestId,
+					},
+				],
+			]),
+		close: (reason, closeOpts) =>
+			command.down([
+				["DATA", { kind: "close", reason, idempotencyKey: closeOpts?.idempotencyKey }],
+			]),
+	};
+	bridgeCommandSources.set(bundle as WireBridgeBundle<unknown, unknown>, { sources: [] });
+	bridgeInboundTargets.set(bundle as WireBridgeBundle<unknown, unknown>, inboundCore);
+	bridgeInboundSources.set(bundle as WireBridgeBundle<unknown, unknown>, { sources: [] });
+	return bundle;
+}
+
+type WireBridgeAckTimeoutCommand = Extract<
+	WireBridgeCommand<never>,
+	{ readonly kind: "ack-timeout" }
+>;
+
+type WireBridgeAckDriverEvent =
+	| {
+			readonly kind: "command";
+			readonly command: WireBridgeAckTimeoutCommand;
+			readonly pending: number;
+			readonly nowMs: number;
+	  }
+	| {
+			readonly kind: "issue";
+			readonly issue: WireBridgeAckDriverIssue;
+			readonly pending: number;
+			readonly nowMs?: number;
+	  }
+	| { readonly kind: "state"; readonly pending: number; readonly nowMs?: number };
+
+interface AckDriverPendingAttempt {
+	readonly seq: number;
+	attempt: number;
+	observedAtMs?: number;
+	timedOutAttempt?: number;
+	timedOutAtMs?: number;
+	retryDueAtMs?: number;
+	retryReleasedAttempt?: number;
+}
+
+interface AckDriverState {
+	nowMs?: number;
+	pending: Map<number, AckDriverPendingAttempt>;
+}
+
+/** D502 explicit graph-visible ack-timeout command driver for a wireBridge. */
+export function wireBridgeAckDriver<TOutbound = unknown, TInbound = unknown>(
+	graph: Graph,
+	bridge: WireBridgeBundle<TOutbound, TInbound>,
+	opts: WireBridgeAckDriverOptions,
+): WireBridgeAckDriverBundle {
+	const name = opts.name ?? `${bridge.sessionId}/wireBridgeAckDriver`;
+	if (!Number.isFinite(opts.timeoutMs) || opts.timeoutMs < 0) {
+		throw new RangeError("wireBridgeAckDriver: timeoutMs must be a non-negative finite number");
+	}
+	const topology = graph.topologyGroup({ name: `${name}.wireBridgeAckDriver` });
+	const active = { current: true };
+	const events = topology.add(wireBridgeAckDriverEventsNode(graph, bridge, opts, name, active));
+	const commands = topology.add(
+		graph.node<WireBridgeCommand<never>>([events], wireBridgeAckDriverCommandsFn(), {
+			name: `${name}/commands`,
+			factory: "wireBridgeAckDriverCommands",
+		}),
+	);
+	const issues = topology.add(wireBridgeAckDriverIssuesNode(graph, events, name));
+	const status = topology.add(wireBridgeAckDriverStatusNode(graph, events, name));
+	let released = false;
+	return {
+		commands,
+		status,
+		issues,
+		release() {
+			if (released) return;
+			active.current = false;
+			try {
+				topology.release({ reason: `${name}.wireBridgeAckDriver.release` });
+				released = true;
+			} catch (error) {
+				active.current = true;
+				throw error;
+			}
+		},
+	};
+}
+
+function wireBridgeAckDriverEventsNode<TOutbound, TInbound>(
+	graph: Graph,
+	bridge: WireBridgeBundle<TOutbound, TInbound>,
+	opts: WireBridgeAckDriverOptions,
+	name: string,
+	active: { current: boolean },
+): Node<WireBridgeAckDriverEvent> {
+	return graph.node<WireBridgeAckDriverEvent>(
+		[opts.clock, bridge.attempts, bridge.acks, bridge.nacks, bridge.status],
+		(ctx) => {
+			let state = ctx.state.get<AckDriverState>();
+			if (state === undefined) {
+				state = { pending: new Map() };
+				ctx.state.set(state);
+			}
+			let touched = false;
+			for (const rawClock of depBatch(ctx, 0) ?? []) {
+				if (!Number.isFinite(rawClock) || (rawClock as number) < 0) {
+					ctx.down([
+						[
+							"DATA",
+							{
+								kind: "issue",
+								issue: {
+									code: "wire-bridge-ack-driver-clock-invalid",
+									message: "wireBridgeAckDriver: clock facts must be non-negative finite numbers",
+									nowMs: rawClock as number,
+								},
+								pending: state.pending.size,
+								nowMs: state.nowMs,
+							} satisfies WireBridgeAckDriverEvent,
+						],
+					]);
+					touched = true;
+					continue;
+				}
+				const nowMs = rawClock as number;
+				if (state.nowMs !== undefined && nowMs < state.nowMs) {
+					ctx.down([
+						[
+							"DATA",
+							{
+								kind: "issue",
+								issue: {
+									code: "wire-bridge-ack-driver-clock-regressed",
+									message: "wireBridgeAckDriver: clock facts must be monotonic",
+									nowMs,
+								},
+								pending: state.pending.size,
+								nowMs: state.nowMs,
+							} satisfies WireBridgeAckDriverEvent,
+						],
+					]);
+					touched = true;
+					continue;
+				}
+				state.nowMs = nowMs;
+				touched = true;
+			}
+			for (const rawAttempt of depBatch(ctx, 1) ?? []) {
+				const attempt = rawAttempt as { readonly seq: number; readonly attempt: number };
+				state.pending.set(attempt.seq, {
+					seq: attempt.seq,
+					attempt: attempt.attempt,
+					observedAtMs: state.nowMs,
+				});
+				touched = true;
+			}
+			for (const rawAck of depBatch(ctx, 2) ?? []) {
+				state.pending.delete((rawAck as { readonly ackForSeq: number }).ackForSeq);
+				touched = true;
+			}
+			for (const rawNack of depBatch(ctx, 3) ?? []) {
+				state.pending.delete((rawNack as { readonly ackForSeq: number }).ackForSeq);
+				touched = true;
+			}
+			for (const rawStatus of depBatch(ctx, 4) ?? []) {
+				const status = rawStatus as {
+					readonly state?: string;
+					readonly pending?: number;
+					readonly lastSeq?: number;
+					readonly lastDelayMs?: number;
+				};
+				if (status.pending === 0) state.pending.clear();
+				else if (status.state === "exhausted" && status.lastSeq !== undefined) {
+					state.pending.delete(status.lastSeq);
+				} else if (
+					status.state === "waiting" &&
+					status.lastSeq !== undefined &&
+					status.lastDelayMs !== undefined
+				) {
+					const pending = state.pending.get(status.lastSeq);
+					if (
+						pending?.timedOutAtMs !== undefined &&
+						pending.retryReleasedAttempt !== pending.attempt
+					) {
+						pending.retryDueAtMs = pending.timedOutAtMs + status.lastDelayMs;
+					}
+				}
+				touched = true;
+			}
+			const nowMs = state.nowMs;
+			let emittedCommand = false;
+			if (active.current && nowMs !== undefined) {
+				for (const pending of state.pending.values()) {
+					if (pending.observedAtMs === undefined) {
+						pending.observedAtMs = nowMs;
+						touched = true;
+					}
+					if (
+						pending.observedAtMs !== undefined &&
+						nowMs - pending.observedAtMs >= opts.timeoutMs &&
+						pending.timedOutAttempt !== pending.attempt
+					) {
+						const command: WireBridgeAckTimeoutCommand = {
+							kind: "ack-timeout",
+							seq: pending.seq,
+							attempt: pending.attempt,
+							observedAtMs: nowMs,
+						};
+						pending.timedOutAttempt = pending.attempt;
+						pending.timedOutAtMs = nowMs;
+						ctx.down([["DATA", { kind: "command", command, pending: state.pending.size, nowMs }]]);
+						emittedCommand = true;
+						touched = true;
+					} else if (
+						pending.retryDueAtMs !== undefined &&
+						nowMs >= pending.retryDueAtMs &&
+						pending.retryReleasedAttempt !== pending.attempt
+					) {
+						const command: WireBridgeAckTimeoutCommand = {
+							kind: "ack-timeout",
+							seq: pending.seq,
+							attempt: pending.attempt,
+							observedAtMs: nowMs,
+						};
+						pending.retryReleasedAttempt = pending.attempt;
+						ctx.down([["DATA", { kind: "command", command, pending: state.pending.size, nowMs }]]);
+						emittedCommand = true;
+						touched = true;
+					}
+				}
+			}
+			if (touched && !emittedCommand) {
+				ctx.down([["DATA", { kind: "state", pending: state.pending.size, nowMs }]]);
+			}
+		},
+		{
+			name: `${name}/events`,
+			factory: "wireBridgeAckDriverEvents",
+			partial: true,
+			completeWhenDepsComplete: false,
+			errorWhenDepsError: false,
+		},
+	);
+}
+
+function wireBridgeAckDriverCommandsFn(): (ctx: Ctx) => void {
+	return (ctx) => {
+		for (const raw of depBatch(ctx, 0) ?? []) {
+			const event = raw as WireBridgeAckDriverEvent;
+			if (event.kind === "command") ctx.down([["DATA", event.command]]);
+		}
+	};
+}
+
+function wireBridgeAckDriverIssuesNode(
+	graph: Graph,
+	events: Node<WireBridgeAckDriverEvent>,
+	name: string,
+): Node<WireBridgeAckDriverIssue> {
+	return graph.node<WireBridgeAckDriverIssue>(
+		[events],
+		(ctx) => {
+			for (const raw of depBatch(ctx, 0) ?? []) {
+				const event = raw as WireBridgeAckDriverEvent;
+				if (event.kind === "issue") ctx.down([["DATA", event.issue]]);
+			}
+		},
+		{ name: `${name}/issues`, factory: "wireBridgeAckDriverIssues" },
+	);
+}
+
+function wireBridgeAckDriverStatusNode(
+	graph: Graph,
+	events: Node<WireBridgeAckDriverEvent>,
+	name: string,
+): Node<WireBridgeAckDriverStatus> {
+	return graph.node<WireBridgeAckDriverStatus>(
+		[events],
+		(ctx) => {
+			let next =
+				ctx.state.get<WireBridgeAckDriverStatus>() ??
+				({
+					state: "idle",
+					pending: 0,
+					commands: 0,
+					issues: 0,
+				} satisfies WireBridgeAckDriverStatus);
+			for (const raw of depBatch(ctx, 0) ?? []) {
+				const event = raw as WireBridgeAckDriverEvent;
+				if (event.kind === "command") {
+					next = {
+						...next,
+						state: "timed-out",
+						pending: event.pending,
+						commands: next.commands + 1,
+						nowMs: event.nowMs,
+						lastCommand: event.command,
+					};
+				} else if (event.kind === "issue") {
+					next = {
+						...next,
+						state: "issues",
+						pending: event.pending,
+						issues: next.issues + 1,
+						nowMs: event.nowMs,
+						lastIssue: event.issue,
+					};
+				} else {
+					next = {
+						...next,
+						state: event.pending > 0 ? "active" : "idle",
+						pending: event.pending,
+						nowMs: event.nowMs,
+					};
+				}
+			}
+			ctx.state.set(next);
+			ctx.down([["DATA", next]]);
+		},
+		{ name: `${name}/status`, factory: "wireBridgeAckDriverStatus" },
+	);
+}
+
+type WireBridgeProtobufInboundResult =
+	| { readonly kind: "decoded"; readonly envelope: WireBridgeEnvelope<WireBridgeProtobufData> }
+	| {
+			readonly kind: "issue";
+			readonly issue: WireBridgeProtobufIssue;
+			readonly invalid: WireBridgeInvalidIngress;
+	  };
+
+type WireBridgeProtobufOutboundResult =
+	| { readonly kind: "encoded"; readonly bytes: Uint8Array }
+	| { readonly kind: "issue"; readonly issue: WireBridgeProtobufIssue };
+
+type WireBridgeProtobufEvent =
+	| {
+			readonly kind: "inbound";
+			readonly result: WireBridgeProtobufInboundResult;
+	  }
+	| {
+			readonly kind: "outbound";
+			readonly result: WireBridgeProtobufOutboundResult;
+	  };
+
+type WireBridgeProtobufInboundEvent = Extract<
+	WireBridgeProtobufEvent,
+	{ readonly kind: "inbound" }
+>;
+type WireBridgeProtobufOutboundEvent = Extract<
+	WireBridgeProtobufEvent,
+	{ readonly kind: "outbound" }
+>;
+
+/**
+ * D498 focused canonical protobuf byte adapter over an existing semantic wireBridge bundle.
+ *
+ * This helper owns no transport/session/retry policy and does not add wireBridge core options.
+ * Malformed bytes become graph-visible issue/invalid facts, never local protocol terminals.
+ */
+export function wireBridgeProtobuf(
+	graph: Graph,
+	bridge: WireBridgeBundle<WireBridgeProtobufData, WireBridgeProtobufData>,
+	opts: WireBridgeProtobufOptions = {},
+): WireBridgeProtobufBundle {
+	const name = opts.name ?? "wireBridgeProtobuf";
+	const topology = graph.topologyGroup({ name: `${name}.wireBridgeProtobuf` });
+	const inboundBytes = topology.node<Uint8Array>([], null, {
+		name: `${name}/inboundBytes`,
+		factory: "wireBridgeProtobufInboundBytes",
+	});
+	const inboundResults = topology.node<WireBridgeProtobufInboundResult>(
+		[inboundBytes],
+		(ctx) => {
+			for (const bytes of depBatch(ctx, 0) ?? []) {
+				const result = wireBridgeProtobufInboundResult(bytes as Uint8Array, bridge.sessionId);
+				ctx.down([["DATA", result]]);
+			}
+		},
+		{
+			name: `${name}/inboundResults`,
+			factory: "wireBridgeProtobufInboundResults",
+			partial: true,
+			completeWhenDepsComplete: false,
+			errorWhenDepsError: false,
+		},
+	);
+	const outboundResults = topology.node<WireBridgeProtobufOutboundResult>(
+		[bridge.outbound],
+		(ctx) => {
+			for (const envelope of depBatch(ctx, 0) ?? []) {
+				let result: WireBridgeProtobufOutboundResult;
+				try {
+					const canonical = canonicalEnvelopeFromSemantic(
+						envelope as WireBridgeEnvelope<WireBridgeProtobufData>,
+					);
+					result = { kind: "encoded", bytes: encodeCanonicalWireBridgeEnvelope(canonical) };
+				} catch (error) {
+					const issue = protobufIssue("outbound", "encode", error);
+					result = { kind: "issue", issue };
+				}
+				ctx.down([["DATA", result]]);
+			}
+		},
+		{
+			name: `${name}/outboundResults`,
+			factory: "wireBridgeProtobufOutboundResults",
+			partial: true,
+			completeWhenDepsComplete: false,
+			errorWhenDepsError: false,
+		},
+	);
+	const inboundEvents = topology.node<WireBridgeProtobufInboundEvent>(
+		[inboundResults],
+		(ctx) => {
+			for (const result of depBatch(ctx, 0) ?? []) {
+				ctx.down([
+					["DATA", { kind: "inbound", result: result as WireBridgeProtobufInboundResult }],
+				]);
+			}
+		},
+		{
+			name: `${name}/inboundEvents`,
+			factory: "wireBridgeProtobufInboundEvents",
+			partial: true,
+			completeWhenDepsComplete: false,
+			errorWhenDepsError: false,
+		},
+	);
+	const outboundEvents = topology.node<WireBridgeProtobufOutboundEvent>(
+		[outboundResults],
+		(ctx) => {
+			for (const result of depBatch(ctx, 0) ?? []) {
+				ctx.down([
+					["DATA", { kind: "outbound", result: result as WireBridgeProtobufOutboundResult }],
+				]);
+			}
+		},
+		{
+			name: `${name}/outboundEvents`,
+			factory: "wireBridgeProtobufOutboundEvents",
+			partial: true,
+			completeWhenDepsComplete: false,
+			errorWhenDepsError: false,
+		},
+	);
+	const inboundDecoded = topology.node<
+		WireBridgeEnvelope<WireBridgeProtobufData> | WireBridgeInvalidIngress
+	>(
+		[inboundEvents],
+		(ctx) => {
+			for (const raw of depBatch(ctx, 0) ?? []) {
+				const event = raw as WireBridgeProtobufInboundEvent;
+				const result = event.result;
+				ctx.down([["DATA", result.kind === "decoded" ? result.envelope : result.invalid]]);
+			}
+		},
+		{
+			name: `${name}/inboundDecoded`,
+			factory: "wireBridgeProtobufInboundDecoded",
+			partial: true,
+			completeWhenDepsComplete: false,
+			errorWhenDepsError: false,
+		},
+	);
+	const outboundBytes = topology.node<Uint8Array>(
+		[outboundEvents],
+		(ctx) => {
+			for (const raw of depBatch(ctx, 0) ?? []) {
+				const event = raw as WireBridgeProtobufOutboundEvent;
+				if (event.result.kind === "encoded") {
+					ctx.down([["DATA", event.result.bytes]]);
+				}
+			}
+		},
+		{
+			name: `${name}/outboundBytes`,
+			factory: "wireBridgeProtobufOutboundBytes",
+			partial: true,
+			completeWhenDepsComplete: false,
+			errorWhenDepsError: false,
+		},
+	);
+	const issues = topology.node<WireBridgeProtobufIssue>(
+		[inboundEvents, outboundEvents],
+		(ctx) => {
+			for (const raw of depBatch(ctx, 0) ?? []) {
+				const event = raw as WireBridgeProtobufInboundEvent;
+				const result = event.result;
+				if (result.kind === "issue") ctx.down([["DATA", result.issue]]);
+			}
+			for (const raw of depBatch(ctx, 1) ?? []) {
+				const event = raw as WireBridgeProtobufOutboundEvent;
+				const result = event.result;
+				if (result.kind === "issue") ctx.down([["DATA", result.issue]]);
+			}
+		},
+		{
+			name: `${name}/issues`,
+			factory: "wireBridgeProtobufIssues",
+			partial: true,
+			completeWhenDepsComplete: false,
+			errorWhenDepsError: false,
+		},
+	);
+	const status = topology.node<WireBridgeProtobufStatus>(
+		[inboundEvents, outboundEvents],
+		(ctx) => {
+			let status =
+				ctx.state.get<WireBridgeProtobufStatus>() ??
+				({ decoded: 0, encoded: 0, issues: 0, state: "idle" } satisfies WireBridgeProtobufStatus);
+			const emitStatus = (next: WireBridgeProtobufStatus) => {
+				status = next;
+				ctx.state.set(status);
+				ctx.down([["DATA", status]]);
+			};
+			for (const raw of depBatch(ctx, 0) ?? []) {
+				const event = raw as WireBridgeProtobufInboundEvent;
+				const result = event.result;
+				if (result.kind === "decoded") {
+					emitStatus({
+						...status,
+						decoded: status.decoded + 1,
+						state: status.issues > 0 ? "issues" : "active",
+					});
+				} else {
+					emitStatus({
+						...status,
+						issues: status.issues + 1,
+						state: "issues",
+						lastIssue: result.issue,
+					});
+				}
+			}
+			for (const raw of depBatch(ctx, 1) ?? []) {
+				const event = raw as WireBridgeProtobufOutboundEvent;
+				const result = event.result;
+				if (result.kind === "encoded") {
+					emitStatus({
+						...status,
+						encoded: status.encoded + 1,
+						state: status.issues > 0 ? "issues" : "active",
+					});
+				} else {
+					emitStatus({
+						...status,
+						issues: status.issues + 1,
+						state: "issues",
+						lastIssue: result.issue,
+					});
+				}
+			}
+		},
+		{
+			name: `${name}/status`,
+			factory: "wireBridgeProtobufStatus",
+			partial: true,
+			completeWhenDepsComplete: false,
+			errorWhenDepsError: false,
+		},
+	);
+	try {
+		attachWireBridgeInboundSource(bridge, inboundDecoded);
+	} catch (error) {
+		topology.release({ reason: `${name}.wireBridgeProtobuf.failedAttach` });
+		throw error;
+	}
+	let released = false;
+	return {
+		inboundBytes,
+		outboundBytes,
+		issues,
+		status,
+		release() {
+			if (released) return;
+			detachWireBridgeInboundSource(bridge, inboundDecoded);
+			try {
+				topology.release({ reason: `${name}.wireBridgeProtobuf.release` });
+				released = true;
+			} catch (error) {
+				attachWireBridgeInboundSource(bridge, inboundDecoded);
+				throw error;
+			}
+		},
+	};
+}
+
+export function remoteResponderHandler<TRequest = unknown, TResponse = unknown>(
+	operation: string,
+	handle: RemoteResponderHandler<TRequest, TResponse>,
+): RemoteResponderHandlerDefinition<TRequest, TResponse> {
+	if (operation.length === 0) {
+		throw new RangeError("remoteResponderHandler: operation must be non-empty");
+	}
+	if (typeof handle !== "function") {
+		throw new TypeError("remoteResponderHandler: handle must be a function");
+	}
+	return { operation, handle };
+}
+
+/** D147 remote responder over inbound wireBridge request facts and outbound command facts. */
+export function remoteResponder<TRequest = unknown, TResponse = unknown>(
+	graph: Graph,
+	bridge: WireBridgeBundle<RemoteCallResponse<TResponse>, RemoteCallRequest<TRequest>>,
+	opts: RemoteResponderOptions<TRequest, TResponse> = {},
+): RemoteResponderBundle<TRequest, TResponse> {
+	const name = opts.name ?? "remoteResponder";
+	const handlers = normalizeRemoteHandlers(opts.handlers ?? []);
+	const topology = graph.topologyGroup({ name: `${name}.remoteResponder` });
+	const events = topology.add(
+		remoteResponderEventsNode(
+			graph,
+			wireBridgeInboundTarget(bridge),
+			name,
+			bridge.sessionId,
+			handlers,
+			opts.rejectUnknown === true,
+		),
+	);
+	const responseCommands = topology.add(remoteResponderResponseCommandsNode(graph, events, name));
+	const requests = topology.add(remoteResponderRequestsNode(graph, events, name));
+	const status = topology.add(remoteResponderStatusNode(graph, events, name));
+	const errors = topology.add(remoteResponderErrorsNode(graph, events, name));
+	try {
+		attachWireBridgeCommandSource(bridge, responseCommands);
+	} catch (error) {
+		topology.release({ reason: `${name}.remoteResponder.failedAttach` });
+		throw error;
+	}
+	let released = false;
+	return {
+		events,
+		responseCommands,
+		requests,
+		status,
+		errors,
+		release() {
+			if (released) return;
+			detachWireBridgeCommandSource(bridge, responseCommands);
+			try {
+				topology.release({ reason: `${name}.remoteResponder.release` });
+				released = true;
+			} catch (error) {
+				attachWireBridgeCommandSource(bridge, responseCommands);
+				throw error;
+			}
+		},
+	};
+}
+
+function wireBridgeEventsNode<TOutbound, TInbound>(
+	graph: Graph,
+	command: Node<WireBridgeCommand<TOutbound>>,
+	inbound: Node<WireBridgeEnvelope<TInbound> | WireBridgeInvalidIngress>,
+	name: string,
+	opts: WireBridgeOptions,
+	policy: RetryPolicy,
+): Node<WireBridgeEvent<TOutbound, TInbound>> {
+	const now = opts.now ?? Date.now;
+	return graph.node<WireBridgeEvent<TOutbound, TInbound>>(
+		[command, inbound],
+		(ctx) => {
+			const state = initBridgeState<TOutbound>(ctx);
+
+			const emitOutbound = (
+				type: WireBridgeEnvelopeType,
+				payload: WireBridgePayload<TOutbound> | undefined,
+				commandOpts: { idempotencyKey?: string; requestId?: string; ackForSeq?: number } = {},
+				beforeEmit?: () => void,
+			) => {
+				if (!isSafePositiveInteger(state.nextSeq)) {
+					ctx.down([
+						[
+							"DATA",
+							{
+								kind: "invalid",
+								error: `${opts.sessionId}: next outbound seq exceeded Number.MAX_SAFE_INTEGER`,
+							},
+						],
+					]);
+					return;
+				}
+				const seq = state.nextSeq;
+				let envelope: WireBridgeEnvelope<TOutbound>;
+				try {
+					const normalizedPayload = normalizeWireBridgePayload(
+						payload,
+						`wireBridge: outbound ${type} envelope`,
+					) as WireBridgePayload<TOutbound> | undefined;
+					envelope = wireBridgeEnvelope<TOutbound>({
+						sessionId: opts.sessionId,
+						type,
+						seq,
+						cursor: state.cursor,
+						payload: normalizedPayload,
+						idempotencyKey: commandOpts.idempotencyKey,
+						attempt: 1,
+						maxAttempts: policy.maxAttempts,
+						timestampMs: now(),
+						ackForSeq: commandOpts.ackForSeq,
+						requestId: commandOpts.requestId,
+					});
+				} catch (error) {
+					ctx.down([
+						[
+							"DATA",
+							{
+								kind: "invalid",
+								error: error instanceof Error ? error.message : String(error),
+							},
+						],
+					]);
+					return;
+				}
+				state.nextSeq++;
+				beforeEmit?.();
+				ctx.down([["DATA", { kind: "outbound", envelope }]]);
+				if (shouldTrackAck(type)) state.pending.set(envelope.metadata.seq, { envelope });
+			};
+
+			for (const raw of depBatch(ctx, 1) ?? []) {
+				processInbound(ctx, state, raw, opts.sessionId);
+			}
+			const inboundTerminal = ctx.terminal[1];
+			if (inboundTerminal !== false && inboundTerminal !== undefined && !state.terminalReported) {
+				state.terminalReported = true;
+				const error =
+					inboundTerminal === true
+						? `${opts.sessionId}: inbound protocol COMPLETE is local misuse; remote completion must arrive as a DATA envelope fact`
+						: `${opts.sessionId}: inbound protocol ERROR ${String(
+								errorPayload(inboundTerminal),
+							)} is local misuse; remote errors must arrive as DATA envelope facts`;
+				ctx.down([["DATA", { kind: "invalid", error }]]);
+			}
+			for (const raw of depBatch(ctx, 0) ?? []) {
+				const invalid = validateCommand(raw);
+				if (invalid !== undefined) {
+					ctx.down([["DATA", { kind: "invalid", error: invalid }]]);
+					continue;
+				}
+				const commandValue = raw as WireBridgeCommand<TOutbound>;
+				switch (commandValue.kind) {
+					case "start":
+						emitOutbound("start", undefined, commandValue);
+						break;
+					case "send":
+						emitOutbound("data", { kind: "data", value: commandValue.payload }, commandValue);
+						break;
+					case "ack":
+						emitOutbound("ack", undefined, {
+							idempotencyKey: commandValue.idempotencyKey,
+							requestId: commandValue.requestId,
+							ackForSeq: commandValue.ackForSeq,
+						});
+						break;
+					case "nack":
+						emitOutbound(
+							"nack",
+							{ kind: "error", error: errorPayload(commandValue.error) },
+							{
+								idempotencyKey: commandValue.idempotencyKey,
+								requestId: commandValue.requestId,
+								ackForSeq: commandValue.ackForSeq,
+							},
+						);
+						break;
+					case "ack-timeout":
+						processAckTimeoutCommand(ctx, state, commandValue, opts, policy, now);
+						break;
+					case "close":
+						emitOutbound(
+							"close",
+							commandValue.reason === undefined
+								? { kind: "close" }
+								: { kind: "close", reason: commandValue.reason },
+							commandValue,
+							() => {
+								state.pending.clear();
+							},
+						);
+						break;
+				}
+			}
+		},
+		{
+			name: `${name}/events`,
+			factory: "wireBridgeEvents",
+			partial: true,
+			errorWhenDepsError: false,
+			completeWhenDepsComplete: false,
+			terminalAsRealInput: true,
+		},
+	);
+}
+
+function initBridgeState<TPayload>(ctx: Ctx): BridgeState<TPayload> {
+	let state = ctx.state.get<BridgeState<TPayload>>();
+	if (state === undefined) {
+		state = {
+			cleanupInstalled: false,
+			nextSeq: 1,
+			cursor: 0,
+			remoteCursor: 0,
+			terminalReported: false,
+			pending: new Map(),
+		};
+		ctx.state.set(state);
+	}
+	if (!state.cleanupInstalled) {
+		state.cleanupInstalled = true;
+		ctx.onDeactivation(() => {
+			state.cleanupInstalled = false;
+			state.pending.clear();
+		});
+	}
+	return state;
+}
+
+function attachWireBridgeCommandSource<TOutbound, TInbound>(
+	bridge: WireBridgeBundle<TOutbound, TInbound>,
+	source: Node<WireBridgeCommand<TOutbound>>,
+): void {
+	const attached = bridgeCommandSources.get(bridge as WireBridgeBundle<unknown, unknown>);
+	if (attached === undefined) {
+		throw new Error("remoteResponder: bridge command source registry missing");
+	}
+	const sources = attached.sources as Node<WireBridgeCommand<TOutbound>>[];
+	const previousSources = [...sources];
+	if (!sources.includes(source)) sources.push(source);
+	try {
+		bridge.command.replaceDeps([...sources], wireBridgeCommandSourceFn(sources.length));
+	} catch (error) {
+		sources.splice(0, sources.length, ...previousSources);
+		bridge.command.replaceDeps(
+			[...previousSources],
+			wireBridgeCommandSourceFn(previousSources.length),
+		);
+		throw error;
+	}
+}
+
+function detachWireBridgeCommandSource<TOutbound, TInbound>(
+	bridge: WireBridgeBundle<TOutbound, TInbound>,
+	source: Node<WireBridgeCommand<TOutbound>>,
+): void {
+	const attached = bridgeCommandSources.get(bridge as WireBridgeBundle<unknown, unknown>);
+	if (attached === undefined) {
+		throw new Error("remoteResponder: bridge command source registry missing");
+	}
+	const sources = attached.sources as Node<WireBridgeCommand<TOutbound>>[];
+	if (!sources.includes(source)) return;
+	const previousSources = [...sources];
+	const nextSources = sources.filter((candidate) => candidate !== source);
+	sources.splice(0, sources.length, ...nextSources);
+	try {
+		bridge.command.replaceDeps([...nextSources], wireBridgeCommandSourceFn(nextSources.length));
+	} catch (error) {
+		sources.splice(0, sources.length, ...previousSources);
+		bridge.command.replaceDeps(
+			[...previousSources],
+			wireBridgeCommandSourceFn(previousSources.length),
+		);
+		throw error;
+	}
+}
+
+function attachWireBridgeInboundSource<TOutbound, TInbound>(
+	bridge: WireBridgeBundle<TOutbound, TInbound>,
+	source: Node<WireBridgeEnvelope<TInbound> | WireBridgeInvalidIngress>,
+): void {
+	const attached = bridgeInboundSources.get(bridge as WireBridgeBundle<unknown, unknown>);
+	if (attached === undefined) {
+		throw new Error("wireBridgeProtobuf: bridge inbound source registry missing");
+	}
+	const sources = attached.sources as Node<
+		WireBridgeEnvelope<TInbound> | WireBridgeInvalidIngress
+	>[];
+	const previousSources = [...sources];
+	if (!sources.includes(source)) sources.push(source);
+	try {
+		wireBridgeInboundTarget(bridge).replaceDeps(
+			[...sources],
+			wireBridgeInboundSourceFn(sources.length),
+		);
+	} catch (error) {
+		sources.splice(0, sources.length, ...previousSources);
+		wireBridgeInboundTarget(bridge).replaceDeps(
+			[...previousSources],
+			wireBridgeInboundSourceFn(previousSources.length),
+		);
+		throw error;
+	}
+}
+
+function detachWireBridgeInboundSource<TOutbound, TInbound>(
+	bridge: WireBridgeBundle<TOutbound, TInbound>,
+	source: Node<WireBridgeEnvelope<TInbound> | WireBridgeInvalidIngress>,
+): void {
+	const attached = bridgeInboundSources.get(bridge as WireBridgeBundle<unknown, unknown>);
+	if (attached === undefined) {
+		throw new Error("wireBridgeProtobuf: bridge inbound source registry missing");
+	}
+	const sources = attached.sources as Node<
+		WireBridgeEnvelope<TInbound> | WireBridgeInvalidIngress
+	>[];
+	if (!sources.includes(source)) return;
+	const previousSources = [...sources];
+	const nextSources = sources.filter((candidate) => candidate !== source);
+	sources.splice(0, sources.length, ...nextSources);
+	try {
+		wireBridgeInboundTarget(bridge).replaceDeps(
+			[...nextSources],
+			wireBridgeInboundSourceFn(nextSources.length),
+		);
+	} catch (error) {
+		sources.splice(0, sources.length, ...previousSources);
+		wireBridgeInboundTarget(bridge).replaceDeps(
+			[...previousSources],
+			wireBridgeInboundSourceFn(previousSources.length),
+		);
+		throw error;
+	}
+}
+
+function wireBridgeInboundTarget<TInbound>(
+	bridge: WireBridgeBundle<unknown, TInbound>,
+): Node<WireBridgeEnvelope<TInbound> | WireBridgeInvalidIngress> {
+	const target = bridgeInboundTargets.get(bridge as WireBridgeBundle<unknown, unknown>);
+	if (target === undefined) {
+		throw new Error("remoteResponder: bridge inbound target registry missing");
+	}
+	return target as Node<WireBridgeEnvelope<TInbound> | WireBridgeInvalidIngress>;
+}
+
+function wireBridgeCommandSourceFn<TOutbound>(sourceCount: number): (ctx: Ctx) => void {
+	return (ctx) => {
+		for (let i = 0; i < sourceCount; i += 1) {
+			for (const command of depBatch(ctx, i) ?? []) {
+				ctx.down([["DATA", command as WireBridgeCommand<TOutbound>]]);
+			}
+		}
+	};
+}
+
+function wireBridgeInboundSourceFn<TInbound>(sourceCount: number): (ctx: Ctx) => void {
+	return (ctx) => {
+		for (let i = 0; i < sourceCount; i += 1) {
+			for (const envelope of depBatch(ctx, i) ?? []) {
+				ctx.down([["DATA", envelope as WireBridgeEnvelope<TInbound> | WireBridgeInvalidIngress]]);
+			}
+		}
+	};
+}
+
+function wireBridgeProtobufInboundResult(
+	bytes: Uint8Array,
+	sessionId: string,
+): WireBridgeProtobufInboundResult {
+	try {
+		const envelope = semanticEnvelopeFromCanonical(decodeCanonicalWireBridgeEnvelope(bytes));
+		return { kind: "decoded", envelope };
+	} catch (error) {
+		const issue = protobufIssue("inbound", "decode", error);
+		return {
+			kind: "issue",
+			issue,
+			invalid: invalidIngress(`${sessionId}: ${issue.message}`),
+		};
+	}
+}
+
+function semanticEnvelopeFromCanonical(
+	envelope: CanonicalWireBridgeEnvelope,
+): WireBridgeEnvelope<WireBridgeProtobufData> {
+	const metadata = semanticMetadataFromCanonical(envelope.metadata);
+	switch (envelope.payload.kind) {
+		case "start":
+			return wireBridgeEnvelope({
+				sessionId: envelope.sessionId,
+				type: "start",
+				seq: metadata.seq,
+				cursor: metadata.cursor,
+				idempotencyKey: metadata.idempotencyKey,
+				attempt: metadata.attempt,
+				maxAttempts: metadata.maxAttempts,
+				timestampMs: metadata.timestampMs,
+				requestId: metadata.requestId,
+			});
+		case "ack":
+			return wireBridgeEnvelope({
+				sessionId: envelope.sessionId,
+				type: "ack",
+				seq: metadata.seq,
+				cursor: metadata.cursor,
+				idempotencyKey: metadata.idempotencyKey,
+				attempt: metadata.attempt,
+				maxAttempts: metadata.maxAttempts,
+				timestampMs: metadata.timestampMs,
+				ackForSeq: metadata.ackForSeq,
+				requestId: metadata.requestId,
+			});
+		case "data":
+			return wireBridgeEnvelope({
+				sessionId: envelope.sessionId,
+				type: "data",
+				seq: metadata.seq,
+				cursor: metadata.cursor,
+				payload: { kind: "data", value: envelope.payload.body },
+				idempotencyKey: metadata.idempotencyKey,
+				attempt: metadata.attempt,
+				maxAttempts: metadata.maxAttempts,
+				timestampMs: metadata.timestampMs,
+				requestId: metadata.requestId,
+			});
+		case "nack":
+			if (envelope.payload.error === undefined) {
+				throw new CanonicalProtobufError(
+					"missing_required",
+					"semantic wireBridge nack requires error bytes",
+				);
+			}
+			return wireBridgeEnvelope({
+				sessionId: envelope.sessionId,
+				type: "nack",
+				seq: metadata.seq,
+				cursor: metadata.cursor,
+				payload: { kind: "error", error: envelope.payload.error },
+				idempotencyKey: metadata.idempotencyKey,
+				attempt: metadata.attempt,
+				maxAttempts: metadata.maxAttempts,
+				timestampMs: metadata.timestampMs,
+				ackForSeq: metadata.ackForSeq,
+				requestId: metadata.requestId,
+			});
+		case "status":
+			return wireBridgeEnvelope({
+				sessionId: envelope.sessionId,
+				type: "status",
+				seq: metadata.seq,
+				cursor: metadata.cursor,
+				payload: { kind: "status", status: envelope.payload.status },
+				idempotencyKey: metadata.idempotencyKey,
+				attempt: metadata.attempt,
+				maxAttempts: metadata.maxAttempts,
+				timestampMs: metadata.timestampMs,
+				requestId: metadata.requestId,
+			});
+		case "error":
+			return wireBridgeEnvelope({
+				sessionId: envelope.sessionId,
+				type: "error",
+				seq: metadata.seq,
+				cursor: metadata.cursor,
+				payload: { kind: "error", error: envelope.payload.error },
+				idempotencyKey: metadata.idempotencyKey,
+				attempt: metadata.attempt,
+				maxAttempts: metadata.maxAttempts,
+				timestampMs: metadata.timestampMs,
+				requestId: metadata.requestId,
+			});
+		case "close":
+			return wireBridgeEnvelope({
+				sessionId: envelope.sessionId,
+				type: "close",
+				seq: metadata.seq,
+				cursor: metadata.cursor,
+				payload:
+					envelope.payload.reason === undefined
+						? { kind: "close" }
+						: { kind: "close", reason: envelope.payload.reason },
+				idempotencyKey: metadata.idempotencyKey,
+				attempt: metadata.attempt,
+				maxAttempts: metadata.maxAttempts,
+				timestampMs: metadata.timestampMs,
+				requestId: metadata.requestId,
+			});
+	}
+}
+
+function canonicalEnvelopeFromSemantic(
+	envelope: WireBridgeEnvelope<WireBridgeProtobufData>,
+): CanonicalWireBridgeEnvelope {
+	return {
+		sessionId: envelope.sessionId,
+		metadata: {
+			seq: BigInt(envelope.metadata.seq),
+			cursor: BigInt(envelope.metadata.cursor),
+			idempotencyKey: envelope.metadata.idempotencyKey,
+			attempt: envelope.metadata.attempt,
+			maxAttempts: envelope.metadata.maxAttempts,
+			timestampMs:
+				envelope.metadata.timestampMs === undefined
+					? undefined
+					: BigInt(envelope.metadata.timestampMs),
+			ackForSeq:
+				envelope.metadata.ackForSeq === undefined ? undefined : BigInt(envelope.metadata.ackForSeq),
+			requestId: envelope.metadata.requestId,
+		},
+		payload: canonicalPayloadFromSemantic(envelope),
+	};
+}
+
+function canonicalPayloadFromSemantic(
+	envelope: WireBridgeEnvelope<WireBridgeProtobufData>,
+): CanonicalWireBridgePayload {
+	const payload = envelope.payload;
+	switch (envelope.type) {
+		case "start":
+			return { kind: "start" };
+		case "ack":
+			return { kind: "ack" };
+		case "data":
+			if (payload?.kind !== "data") {
+				throw new CanonicalProtobufError("missing_required", "data envelope requires data payload");
+			}
+			return { kind: "data", body: canonicalDataBody(payload.value) };
+		case "nack":
+			if (payload?.kind !== "error") {
+				throw new CanonicalProtobufError(
+					"missing_required",
+					"nack envelope requires error payload",
+				);
+			}
+			return { kind: "nack", error: requiredBytes(payload.error, "nack error") };
+		case "status":
+			if (payload?.kind !== "status") {
+				throw new CanonicalProtobufError(
+					"missing_required",
+					"status envelope requires status payload",
+				);
+			}
+			return { kind: "status", status: requiredBytes(payload.status, "status") };
+		case "error":
+			if (payload?.kind !== "error") {
+				throw new CanonicalProtobufError(
+					"missing_required",
+					"error envelope requires error payload",
+				);
+			}
+			return { kind: "error", error: requiredBytes(payload.error, "error") };
+		case "close":
+			if (payload?.kind !== "close") {
+				throw new CanonicalProtobufError(
+					"missing_required",
+					"close envelope requires close payload",
+				);
+			}
+			return { kind: "close", reason: optionalBytes(payload.reason, "close reason") };
+	}
+}
+
+function canonicalDataBody(value: unknown): CanonicalWireBridgeDataBody {
+	if (value instanceof Uint8Array) return { kind: "value", value };
+	if (
+		typeof value === "object" &&
+		value !== null &&
+		(value as { readonly kind?: unknown }).kind === "value"
+	) {
+		const bytes = (value as { readonly value?: unknown }).value;
+		if (bytes instanceof Uint8Array) return { kind: "value", value: bytes };
+	}
+	if (
+		typeof value === "object" &&
+		value !== null &&
+		(value as { readonly kind?: unknown }).kind === "wire_edge"
+	) {
+		const frame = (value as { readonly frame?: unknown }).frame;
+		return { kind: "wire_edge", frame: frame as CanonicalWireEdgeFrame };
+	}
+	throw new CanonicalProtobufError(
+		"malformed",
+		"wireBridgeProtobuf data payload must be Uint8Array or CanonicalWireBridgeDataBody",
+	);
+}
+
+function semanticMetadataFromCanonical(metadata: CanonicalWireBridgeMetadata): WireBridgeMetadata {
+	return {
+		seq: safeSemanticNumber(metadata.seq, "seq"),
+		cursor: safeSemanticNumber(metadata.cursor, "cursor"),
+		idempotencyKey: metadata.idempotencyKey,
+		attempt: metadata.attempt,
+		maxAttempts: metadata.maxAttempts,
+		timestampMs:
+			metadata.timestampMs === undefined
+				? undefined
+				: safeSemanticNumber(metadata.timestampMs, "timestamp_ms"),
+		ackForSeq:
+			metadata.ackForSeq === undefined
+				? undefined
+				: safeSemanticNumber(metadata.ackForSeq, "ack_for_seq"),
+		requestId: metadata.requestId,
+	};
+}
+
+function safeSemanticNumber(value: bigint, field: string): number {
+	if (value > BigInt(Number.MAX_SAFE_INTEGER)) {
+		throw new CanonicalProtobufError(
+			"malformed",
+			`${field} exceeds semantic wireBridge Number.MAX_SAFE_INTEGER range`,
+		);
+	}
+	return Number(value);
+}
+
+function requiredBytes(value: unknown, field: string): Uint8Array {
+	if (value instanceof Uint8Array) return value;
+	throw new CanonicalProtobufError("malformed", `wireBridgeProtobuf ${field} must be Uint8Array`);
+}
+
+function optionalBytes(value: unknown, field: string): Uint8Array | undefined {
+	if (value === undefined) return undefined;
+	if (value instanceof Uint8Array) return value;
+	throw new CanonicalProtobufError("malformed", `wireBridgeProtobuf ${field} must be Uint8Array`);
+}
+
+function protobufIssue(
+	direction: WireBridgeProtobufIssue["direction"],
+	operation: WireBridgeProtobufIssue["operation"],
+	error: unknown,
+): WireBridgeProtobufIssue {
+	return {
+		direction,
+		operation,
+		message: error instanceof Error ? error.message : String(error),
+		category: error instanceof CanonicalProtobufError ? error.category : undefined,
+	};
+}
+
+function processAckTimeoutCommand<TPayload>(
+	ctx: Ctx,
+	state: BridgeState<TPayload>,
+	command: Extract<WireBridgeCommand<TPayload>, { readonly kind: "ack-timeout" }>,
+	opts: WireBridgeOptions,
+	policy: RetryPolicy,
+	now: () => number,
+): void {
+	const pending = state.pending.get(command.seq);
+	if (pending === undefined || pending.envelope.metadata.attempt !== command.attempt) return;
+	const current = pending.envelope;
+	const emitRetryOutbound = () => {
+		const attempt = current.metadata.attempt + 1;
+		const retry = wireBridgeEnvelope<TPayload>({
+			sessionId: current.sessionId,
+			type: current.type,
+			seq: current.metadata.seq,
+			cursor: state.cursor,
+			payload: current.payload,
+			idempotencyKey: current.metadata.idempotencyKey,
+			attempt,
+			maxAttempts: policy.maxAttempts,
+			timestampMs: now(),
+			requestId: current.metadata.requestId,
+		});
+		pending.envelope = retry;
+		pending.timeoutReportedAttempt = undefined;
+		pending.retryDueAtMs = undefined;
+		ctx.down([["DATA", { kind: "outbound", envelope: retry }]]);
+	};
+	if (pending.timeoutReportedAttempt === current.metadata.attempt) {
+		if (
+			pending.retryDueAtMs !== undefined &&
+			command.observedAtMs !== undefined &&
+			command.observedAtMs < pending.retryDueAtMs
+		) {
+			return;
+		}
+		emitRetryOutbound();
+		return;
+	}
+	ctx.down([
+		[
+			"DATA",
+			{
+				kind: "timeout",
+				seq: current.metadata.seq,
+				attempt: current.metadata.attempt,
+			} satisfies WireBridgeEvent<TPayload, unknown>,
+		],
+	]);
+	if (!shouldRetry(policy, current.metadata.attempt)) {
+		const error = `${opts.sessionId}: ack timeout for seq ${current.metadata.seq}`;
+		state.pending.delete(current.metadata.seq);
+		ctx.down([
+			[
+				"DATA",
+				{
+					kind: "exhausted",
+					seq: current.metadata.seq,
+					attempt: current.metadata.attempt,
+					error,
+				} satisfies WireBridgeEvent<TPayload, unknown>,
+			],
+		]);
+		return;
+	}
+	const attempt = current.metadata.attempt + 1;
+	const delayMs = nextRetryDelayMs(policy, attempt) ?? 0;
+	const error = `${opts.sessionId}: ack timeout for seq ${current.metadata.seq}`;
+	pending.timeoutReportedAttempt = current.metadata.attempt;
+	if (delayMs > 0 && command.observedAtMs !== undefined) {
+		pending.retryDueAtMs = command.observedAtMs + delayMs;
+	}
+	ctx.down([
+		[
+			"DATA",
+			{
+				kind: "retry",
+				seq: current.metadata.seq,
+				attempt,
+				delayMs,
+				error,
+			} satisfies WireBridgeEvent<TPayload, unknown>,
+		],
+	]);
+	if (pending.retryDueAtMs !== undefined) return;
+	emitRetryOutbound();
+}
+
+function processInbound<TOutbound, TInbound>(
+	ctx: Ctx,
+	state: BridgeState<TOutbound>,
+	input: unknown,
+	sessionId: string,
+): void {
+	if (isInvalidIngress(input)) {
+		ctx.down([["DATA", { kind: "invalid", error: input.error }]]);
+		return;
+	}
+	const invalid = validateInboundEnvelope(input);
+	if (invalid !== undefined) {
+		ctx.down([["DATA", { kind: "invalid", error: invalid }]]);
+		return;
+	}
+	const envelope = input as WireBridgeEnvelope<TInbound>;
+	if (envelope.sessionId !== sessionId) {
+		ctx.down([
+			[
+				"DATA",
+				{
+					kind: "session-mismatch",
+					expected: sessionId,
+					actual: envelope.sessionId,
+				} satisfies WireBridgeEvent<TOutbound, TInbound>,
+			],
+		]);
+		return;
+	}
+	const seq = envelope.metadata.seq;
+	const expected = state.cursor + 1;
+	if (seq <= state.cursor) {
+		ctx.down([["DATA", { kind: "duplicate", seq, cursor: state.cursor }]]);
+		return;
+	}
+	if (seq > expected) {
+		ctx.down([["DATA", { kind: "out-of-order", seq, expected }]]);
+		return;
+	}
+	if (envelope.metadata.cursor < state.remoteCursor) {
+		ctx.down([
+			[
+				"DATA",
+				{
+					kind: "invalid",
+					error: `${sessionId}: inbound cursor ${envelope.metadata.cursor} regressed below ${state.remoteCursor}`,
+				},
+			],
+		]);
+		return;
+	}
+	state.remoteCursor = envelope.metadata.cursor;
+	state.cursor = seq;
+	ctx.down([["DATA", { kind: "cursor", cursor: state.cursor }]]);
+	ctx.down([["DATA", { kind: "inbound", envelope }]]);
+	if (envelope.type === "ack" && envelope.metadata.ackForSeq !== undefined) {
+		const pending = state.pending.get(envelope.metadata.ackForSeq);
+		if (pending === undefined) {
+			ctx.down([
+				["DATA", { kind: "late-receipt", receipt: "ack", ackForSeq: envelope.metadata.ackForSeq }],
+			]);
+			return;
+		}
+		state.pending.delete(envelope.metadata.ackForSeq);
+		ctx.down([
+			[
+				"DATA",
+				{
+					kind: "ack",
+					ackForSeq: envelope.metadata.ackForSeq,
+					envelope,
+					outbound: pending.envelope,
+				} satisfies WireBridgeEvent<TOutbound, TInbound>,
+			],
+		]);
+	} else if (envelope.type === "nack" && envelope.metadata.ackForSeq !== undefined) {
+		const pending = state.pending.get(envelope.metadata.ackForSeq);
+		if (pending === undefined) {
+			ctx.down([
+				["DATA", { kind: "late-receipt", receipt: "nack", ackForSeq: envelope.metadata.ackForSeq }],
+			]);
+			return;
+		}
+		state.pending.delete(envelope.metadata.ackForSeq);
+		ctx.down([
+			[
+				"DATA",
+				{
+					kind: "nack",
+					ackForSeq: envelope.metadata.ackForSeq,
+					envelope,
+					outbound: pending.envelope,
+					error: bridgePayloadError(envelope.payload, "remote nack"),
+				} satisfies WireBridgeEvent<TOutbound, TInbound>,
+			],
+		]);
+	}
+}
diff --git a/packages/ts/src/adapters/environment-outbound.ts b/packages/ts/src/adapters/environment-outbound.ts
new file mode 100644
index 00000000..1c4fba42
--- /dev/null
+++ b/packages/ts/src/adapters/environment-outbound.ts
@@ -0,0 +1,361 @@
+/**
+ * Graph-visible outbound environment adapters (D130/D132).
+ *
+ * Async transport work is confined to graph-local EnvironmentDrivers. Each
+ * helper returns declared nodes for events/status/attempts/errors instead of a
+ * hidden sink side channel.
+ */
+
+import { type Ctx, depBatch } from "../ctx/types.js";
+import type {
+	DriverCancel,
+	HttpResponse,
+	ProcessResult,
+	WebSocketRequest,
+	WebSocketSendResult,
+} from "../graph/environment.js";
+import type { Graph } from "../graph/graph.js";
+import { nextRetryDelayMs, retryPolicy, shouldRetry } from "../graph/resilience.js";
+import type { Node } from "../node/node.js";
+import { errorPayload } from "../protocol/messages.js";
+import type {
+	HttpRequestOf,
+	OutboundAdapterOptions,
+	OutboundBundle,
+	OutboundEvent,
+	OutboundStatus,
+	ProcessCommandOf,
+	WebSocketSendOf,
+} from "./environment-types.js";
+
+interface SendState {
+	seq: number;
+	cancels: Map<number, DriverCancel>;
+	timers: Map<number, ReturnType<typeof setTimeout>>;
+	active: boolean;
+	cleanupInstalled: boolean;
+}
+
+function assertSourceLocal<T>(source: Node<T>): Node<T> {
+	return source;
+}
+
+function initSendState(ctx: Ctx): SendState {
+	let state = ctx.state.get<SendState>();
+	if (state === undefined) {
+		state = {
+			seq: 0,
+			cancels: new Map(),
+			timers: new Map(),
+			active: true,
+			cleanupInstalled: false,
+		};
+		ctx.state.set(state);
+	}
+	state.active = true;
+	if (!state.cleanupInstalled) {
+		state.cleanupInstalled = true;
+		ctx.onDeactivation(() => {
+			state.active = false;
+			state.cleanupInstalled = false;
+			for (const cancel of state.cancels.values()) runCancel(cancel);
+			for (const timer of state.timers.values()) clearTimeout(timer);
+			state.cancels.clear();
+			state.timers.clear();
+		});
+	}
+	return state;
+}
+
+export function runCancel(cancel: DriverCancel): void {
+	try {
+		cancel();
+	} catch {
+		// Driver cancellation is best-effort and must not hide graph-visible outcomes.
+	}
+}
+
+function outboundNodes<TValue, TResult>(
+	graph: Graph,
+	events: Node<OutboundEvent<TValue, TResult>>,
+	name: string,
+): OutboundBundle<TValue, TResult> {
+	const status = graph.node<OutboundStatus>(
+		[events],
+		(ctx) => {
+			const current =
+				ctx.state.get<OutboundStatus>() ??
+				({ state: "idle", inFlight: 0, attempt: 0, sent: 0, failed: 0 } satisfies OutboundStatus);
+			let next = current;
+			for (const event of depBatch(ctx, 0) ?? []) {
+				next = reduceStatus(next, event as OutboundEvent<TValue, TResult>);
+			}
+			ctx.state.set(next);
+			ctx.down([["DATA", next]]);
+		},
+		{ name: `${name}/status`, factory: "outboundStatus" },
+	);
+	const attempts = graph.node<number>(
+		[events],
+		(ctx) => {
+			for (const event of depBatch(ctx, 0) ?? []) {
+				const typed = event as OutboundEvent<TValue, TResult>;
+				if ("attempt" in typed) ctx.down([["DATA", typed.attempt]]);
+			}
+		},
+		{ name: `${name}/attempts`, factory: "outboundAttempts" },
+	);
+	const errors = graph.node<unknown>(
+		[events],
+		(ctx) => {
+			for (const event of depBatch(ctx, 0) ?? []) {
+				const typed = event as OutboundEvent<TValue, TResult>;
+				if ("error" in typed) ctx.down([["DATA", typed.error]]);
+			}
+		},
+		{ name: `${name}/errors`, factory: "outboundErrors" },
+	);
+	return { events, status, attempts, errors };
+}
+
+function reduceStatus<TValue, TResult>(
+	current: OutboundStatus,
+	event: OutboundEvent<TValue, TResult>,
+): OutboundStatus {
+	switch (event.kind) {
+		case "attempt":
+			return {
+				...current,
+				state: "running",
+				inFlight: current.inFlight + 1,
+				attempt: event.attempt,
+			};
+		case "retry":
+			return {
+				...current,
+				state: "waiting",
+				inFlight: Math.max(0, current.inFlight - 1),
+				attempt: event.attempt,
+				lastDelayMs: event.delayMs,
+			};
+		case "sent":
+			return {
+				...current,
+				state: "succeeded",
+				inFlight: Math.max(0, current.inFlight - 1),
+				attempt: event.attempt,
+				sent: current.sent + 1,
+				lastDelayMs: undefined,
+			};
+		case "failed":
+			return {
+				...current,
+				state: "failed",
+				inFlight: Math.max(0, current.inFlight - 1),
+				attempt: event.attempt,
+				failed: current.failed + 1,
+			};
+		case "exhausted":
+			return {
+				...current,
+				state: "exhausted",
+				inFlight: Math.max(0, current.inFlight - 1),
+				attempt: event.attempt,
+				failed: current.failed + 1,
+			};
+		case "upstream-complete":
+			return { ...current, state: "completed" };
+		case "upstream-error":
+			return { ...current, state: "failed", failed: current.failed + 1 };
+	}
+}
+
+function outboundNode<TValue, TResult>(
+	graph: Graph,
+	source: Node<TValue>,
+	name: string,
+	send: (
+		ctx: Ctx,
+		value: TValue,
+		callback: (result: { ok: true; value: TResult } | { ok: false; error: unknown }) => void,
+	) => DriverCancel | undefined,
+	opts: OutboundAdapterOptions,
+): Node<OutboundEvent<TValue, TResult>> {
+	const policy = opts.retry ?? retryPolicy();
+	return graph.node<OutboundEvent<TValue, TResult>>(
+		[assertSourceLocal(source)],
+		(ctx) => {
+			const state = initSendState(ctx);
+			const start = (value: TValue, attempt: number) => {
+				if (!state.active) return;
+				const id = state.seq++;
+				ctx.down([
+					["DATA", { kind: "attempt", value, attempt } satisfies OutboundEvent<TValue, TResult>],
+				]);
+				const failTerminal = (error: unknown) => {
+					const payload = errorPayload(error);
+					ctx.down([
+						[
+							"DATA",
+							{ kind: "exhausted", value, attempt, error: payload } satisfies OutboundEvent<
+								TValue,
+								TResult
+							>,
+						],
+					]);
+					ctx.down([["ERROR", payload]]);
+				};
+				let cancel: DriverCancel | undefined;
+				let done = false;
+				try {
+					cancel = send(ctx, value, (result) => {
+						if (done || !state.active) return;
+						done = true;
+						state.cancels.delete(id);
+						if (result.ok) {
+							ctx.down([
+								[
+									"DATA",
+									{ kind: "sent", value, attempt, result: result.value } satisfies OutboundEvent<
+										TValue,
+										TResult
+									>,
+								],
+							]);
+							return;
+						}
+						if (shouldRetry(policy, attempt)) {
+							const nextAttempt = attempt + 1;
+							const delayMs = nextRetryDelayMs(policy, nextAttempt) ?? 0;
+							ctx.down([
+								[
+									"DATA",
+									{
+										kind: "retry",
+										value,
+										attempt,
+										delayMs,
+										error: errorPayload(result.error),
+									} satisfies OutboundEvent<TValue, TResult>,
+								],
+							]);
+							const timer = setTimeout(() => {
+								state.timers.delete(id);
+								if (!state.active) return;
+								start(value, nextAttempt);
+							}, delayMs);
+							state.timers.set(id, timer);
+						} else {
+							ctx.down([
+								[
+									"DATA",
+									{
+										kind: "exhausted",
+										value,
+										attempt,
+										error: errorPayload(result.error),
+									} satisfies OutboundEvent<TValue, TResult>,
+								],
+							]);
+						}
+					});
+				} catch (error) {
+					if (!done) {
+						done = true;
+						state.cancels.delete(id);
+						failTerminal(error);
+					}
+					return;
+				}
+				if (cancel === undefined) {
+					if (!done) {
+						done = true;
+						failTerminal(`${name}: missing environment driver capability`);
+					}
+					return;
+				}
+				if (!done && state.active) {
+					state.cancels.set(id, cancel);
+				} else if (!state.active) {
+					runCancel(cancel);
+				}
+			};
+			for (const value of depBatch(ctx, 0) ?? []) start(value as TValue, 1);
+			const terminal = ctx.terminal[0];
+			if (terminal === true) {
+				ctx.down([
+					["DATA", { kind: "upstream-complete" } satisfies OutboundEvent<TValue, TResult>],
+				]);
+			} else if (terminal !== false && terminal !== undefined) {
+				ctx.down([
+					[
+						"DATA",
+						{ kind: "upstream-error", error: terminal } satisfies OutboundEvent<TValue, TResult>,
+					],
+				]);
+			}
+		},
+		{ name, factory: name },
+	);
+}
+
+export function toHttp<T>(
+	graph: Graph,
+	source: Node<T>,
+	requestOf: HttpRequestOf<T>,
+	opts: OutboundAdapterOptions = {},
+): OutboundBundle<T, HttpResponse> {
+	const name = opts.name ?? "toHttp";
+	const events = outboundNode<T, HttpResponse>(
+		graph,
+		source,
+		name,
+		(ctx, value, callback) => {
+			const request = requestOf(value);
+			return ctx.environment().httpDriver()?.request(request, callback);
+		},
+		opts,
+	);
+	return outboundNodes(graph, events, name);
+}
+
+export function toProcess<T>(
+	graph: Graph,
+	source: Node<T>,
+	commandOf: ProcessCommandOf<T>,
+	opts: OutboundAdapterOptions = {},
+): OutboundBundle<T, ProcessResult> {
+	const name = opts.name ?? "toProcess";
+	const events = outboundNode<T, ProcessResult>(
+		graph,
+		source,
+		name,
+		(ctx, value, callback) => {
+			const command = commandOf(value);
+			return ctx.environment().processDriver()?.run(command, callback);
+		},
+		opts,
+	);
+	return outboundNodes(graph, events, name);
+}
+
+export function toWebSocket<T>(
+	graph: Graph,
+	source: Node<T>,
+	request: WebSocketRequest,
+	sendOf: WebSocketSendOf<T>,
+	opts: OutboundAdapterOptions = {},
+): OutboundBundle<T, WebSocketSendResult> {
+	const name = opts.name ?? "toWebSocket";
+	const events = outboundNode<T, WebSocketSendResult>(
+		graph,
+		source,
+		name,
+		(ctx, value, callback) => {
+			const driver = ctx.environment().webSocketDriver();
+			return driver?.send?.(request, sendOf(value), callback);
+		},
+		opts,
+	);
+	return outboundNodes(graph, events, name);
+}
diff --git a/packages/ts/src/adapters/environment-types.ts b/packages/ts/src/adapters/environment-types.ts
new file mode 100644
index 00000000..612dbe6d
--- /dev/null
+++ b/packages/ts/src/adapters/environment-types.ts
@@ -0,0 +1,154 @@
+import type { HttpRequest, ProcessCommand, WebSocketSend } from "../graph/environment.js";
+import type { RetryPolicy } from "../graph/resilience.js";
+import type { Node } from "../node/node.js";
+
+export type OutboundEvent<TValue, TResult> =
+	| { readonly kind: "attempt"; readonly value: TValue; readonly attempt: number }
+	| {
+			readonly kind: "retry";
+			readonly value: TValue;
+			readonly attempt: number;
+			readonly delayMs: number;
+			readonly error: unknown;
+	  }
+	| {
+			readonly kind: "sent";
+			readonly value: TValue;
+			readonly attempt: number;
+			readonly result: TResult;
+	  }
+	| {
+			readonly kind: "failed";
+			readonly value: TValue;
+			readonly attempt: number;
+			readonly error: unknown;
+	  }
+	| {
+			readonly kind: "exhausted";
+			readonly value: TValue;
+			readonly attempt: number;
+			readonly error: unknown;
+	  }
+	| { readonly kind: "upstream-complete" }
+	| { readonly kind: "upstream-error"; readonly error: unknown };
+
+export interface OutboundStatus {
+	readonly state:
+		| "idle"
+		| "running"
+		| "waiting"
+		| "succeeded"
+		| "failed"
+		| "exhausted"
+		| "completed";
+	readonly inFlight: number;
+	readonly attempt: number;
+	readonly sent: number;
+	readonly failed: number;
+	readonly lastDelayMs?: number;
+}
+
+export interface OutboundBundle<TValue, TResult> {
+	readonly events: Node<OutboundEvent<TValue, TResult>>;
+	readonly status: Node<OutboundStatus>;
+	readonly attempts: Node<number>;
+	readonly errors: Node<unknown>;
+}
+
+export interface OutboundAdapterOptions {
+	readonly name?: string;
+	readonly retry?: RetryPolicy;
+}
+
+export type HttpRequestOf<T> = (value: T) => HttpRequest;
+export type ProcessCommandOf<T> = (value: T) => ProcessCommand;
+export type WebSocketSendOf<T> = (value: T) => WebSocketSend;
+
+/** D133 command facts for a graph-visible WebSocket SessionBundle. */
+export type WebSocketSessionCommand =
+	| { readonly kind: "start" }
+	| { readonly kind: "send"; readonly message: WebSocketSend }
+	| { readonly kind: "close"; readonly code?: number; readonly reason?: string };
+
+/** Inbound facts emitted by the live WebSocket session connection. */
+export type WebSocketSessionInbound =
+	| { readonly kind: "text"; readonly data: string }
+	| { readonly kind: "binary"; readonly data: Uint8Array };
+
+/** Observable lifecycle facts for bounded D133 reconnect/session progress. */
+export type WebSocketSessionLifecycle =
+	| { readonly kind: "starting"; readonly attempt: number; readonly maxAttempts: number }
+	| { readonly kind: "open"; readonly attempt: number }
+	| { readonly kind: "sent"; readonly message: WebSocketSend }
+	| { readonly kind: "closing"; readonly code?: number; readonly reason?: string }
+	| { readonly kind: "closed"; readonly code?: number; readonly reason?: string }
+	| {
+			readonly kind: "retrying";
+			readonly attempt: number;
+			readonly nextAttempt: number;
+			readonly delayMs: number;
+			readonly error: unknown;
+	  }
+	| { readonly kind: "exhausted"; readonly attempt: number; readonly error: unknown };
+
+/** D175 graph-visible outbound disposition for a WebSocket SessionBundle send. */
+export type WebSocketSessionOutbound =
+	| { readonly kind: "queued"; readonly seq: number; readonly message: WebSocketSend }
+	| { readonly kind: "sending"; readonly seq: number; readonly message: WebSocketSend }
+	| { readonly kind: "sent"; readonly seq: number; readonly message: WebSocketSend }
+	| {
+			readonly kind: "rejected";
+			readonly seq: number;
+			readonly message: WebSocketSend;
+			readonly error: unknown;
+	  }
+	| {
+			readonly kind: "canceled";
+			readonly seq: number;
+			readonly message: WebSocketSend;
+			readonly reason: unknown;
+	  };
+
+/** Current graph-visible WebSocket session status projection. */
+export interface WebSocketSessionStatus {
+	readonly state:
+		| "idle"
+		| "connecting"
+		| "open"
+		| "closing"
+		| "closed"
+		| "waiting"
+		| "exhausted"
+		| "errored";
+	readonly attempt: number;
+	readonly maxAttempts: number;
+	readonly sent: number;
+	readonly received: number;
+	readonly errors: number;
+	readonly lastDelayMs?: number;
+}
+
+/** D133 SessionBundle: all session commands, inbound data, attempts, status, and errors are nodes. */
+export interface WebSocketSessionBundle {
+	readonly command: Node<WebSocketSessionCommand>;
+	readonly inbound: Node<WebSocketSessionInbound>;
+	readonly lifecycle: Node<WebSocketSessionLifecycle>;
+	readonly outbound: Node<WebSocketSessionOutbound>;
+	readonly status: Node<WebSocketSessionStatus>;
+	readonly errors: Node<unknown>;
+	readonly attempts: Node<number>;
+	start(): void;
+	send(message: WebSocketSend | string | Uint8Array): void;
+	close(code?: number, reason?: string): void;
+}
+
+export type WebSocketSessionSendPolicy =
+	| { readonly kind?: "reject" }
+	| { readonly kind: "buffer"; readonly maxPending: number };
+
+/** Options for the D133 WebSocket SessionBundle; retry is bounded unless configured otherwise. */
+export interface WebSocketSessionOptions {
+	readonly name?: string;
+	readonly retry?: RetryPolicy;
+	readonly sendPolicy?: WebSocketSessionSendPolicy;
+}
diff --git a/packages/ts/src/adapters/environment-websocket-session.ts b/packages/ts/src/adapters/environment-websocket-session.ts
new file mode 100644
index 00000000..e51c0466
--- /dev/null
+++ b/packages/ts/src/adapters/environment-websocket-session.ts
@@ -0,0 +1,724 @@
+/**
+ * Graph-visible outbound environment adapters (D130/D132).
+ *
+ * Async transport work is confined to graph-local EnvironmentDrivers. Each
+ * helper returns declared nodes for events/status/attempts/errors instead of a
+ * hidden sink side channel.
+ */
+
+import { type Ctx, depBatch } from "../ctx/types.js";
+import type {
+	DriverCancel,
+	WebSocketRequest,
+	WebSocketSend,
+	WebSocketSessionHandle,
+} from "../graph/environment.js";
+import type { Graph } from "../graph/graph.js";
+import {
+	nextRetryDelayMs,
+	type RetryPolicy,
+	retryPolicy,
+	shouldRetry,
+} from "../graph/resilience.js";
+import type { Node } from "../node/node.js";
+import { errorPayload } from "../protocol/messages.js";
+import { runCancel } from "./environment-outbound.js";
+import type {
+	WebSocketSessionBundle,
+	WebSocketSessionCommand,
+	WebSocketSessionInbound,
+	WebSocketSessionLifecycle,
+	WebSocketSessionOptions,
+	WebSocketSessionOutbound,
+	WebSocketSessionSendPolicy,
+	WebSocketSessionStatus,
+} from "./environment-types.js";
+
+type WebSocketSessionEvent =
+	| { readonly kind: "attempt"; readonly attempt: number; readonly maxAttempts: number }
+	| { readonly kind: "open"; readonly attempt: number }
+	| { readonly kind: "message"; readonly message: WebSocketSessionInbound }
+	| { readonly kind: "sent"; readonly message: WebSocketSend }
+	| { readonly kind: "closing"; readonly code?: number; readonly reason?: string }
+	| { readonly kind: "closed"; readonly code?: number; readonly reason?: string }
+	| {
+			readonly kind: "retry";
+			readonly attempt: number;
+			readonly nextAttempt: number;
+			readonly delayMs: number;
+			readonly error: unknown;
+	  }
+	| { readonly kind: "outbound"; readonly fact: WebSocketSessionOutbound }
+	| { readonly kind: "error"; readonly error: unknown; readonly attempt?: number }
+	| { readonly kind: "exhausted"; readonly attempt: number; readonly error: unknown };
+
+interface WebSocketSessionState {
+	active: boolean;
+	connected: boolean;
+	cleanupInstalled: boolean;
+	currentAttempt: number;
+	currentSession: WebSocketSessionHandle | undefined;
+	sendCancels: Map<number, DriverCancel>;
+	liveSends: Map<number, PendingWebSocketOutbound>;
+	pendingOutbound: PendingWebSocketOutbound[];
+	timers: Map<number, ReturnType<typeof setTimeout>>;
+	seq: number;
+	outboundSeq: number;
+}
+
+interface PendingWebSocketOutbound {
+	readonly seq: number;
+	readonly message: WebSocketSend;
+}
+
+function initWebSocketSessionState(ctx: Ctx): WebSocketSessionState {
+	let state = ctx.state.get<WebSocketSessionState>();
+	if (state === undefined) {
+		state = {
+			active: true,
+			connected: false,
+			cleanupInstalled: false,
+			currentAttempt: 0,
+			currentSession: undefined,
+			sendCancels: new Map(),
+			liveSends: new Map(),
+			pendingOutbound: [],
+			timers: new Map(),
+			seq: 0,
+			outboundSeq: 0,
+		};
+		ctx.state.set(state);
+	}
+	state.active = true;
+	if (!state.cleanupInstalled) {
+		state.cleanupInstalled = true;
+		ctx.onDeactivation(() => {
+			const sendCancels = [...state.sendCancels.values()];
+			const timers = [...state.timers.values()];
+			const session = state.currentSession;
+			state.active = false;
+			state.cleanupInstalled = false;
+			state.connected = false;
+			state.currentAttempt = 0;
+			state.currentSession = undefined;
+			state.sendCancels.clear();
+			state.liveSends.clear();
+			state.pendingOutbound = [];
+			state.timers.clear();
+			for (const cancel of sendCancels) runCancel(cancel);
+			for (const timer of timers) clearTimeout(timer);
+			session?.cancel();
+		});
+	}
+	return state;
+}
+
+function closeWebSocketSessionState(
+	state: WebSocketSessionState,
+	driverAction: "cancel" | "none" = "cancel",
+): {
+	readonly canceled: PendingWebSocketOutbound[];
+	readonly session: WebSocketSessionHandle | undefined;
+} {
+	const session = state.currentSession;
+	const timers = [...state.timers.values()];
+	const sendCancels = [...state.sendCancels.values()];
+	const canceled = [...state.pendingOutbound, ...state.liveSends.values()];
+	state.connected = false;
+	state.currentAttempt = 0;
+	state.currentSession = undefined;
+	state.timers.clear();
+	state.sendCancels.clear();
+	state.pendingOutbound = [];
+	state.liveSends.clear();
+	for (const timer of timers) clearTimeout(timer);
+	for (const cancelSend of sendCancels) runCancel(cancelSend);
+	if (driverAction === "cancel") session?.cancel();
+	return { canceled, session };
+}
+
+function cancelRetryTimers(state: WebSocketSessionState): void {
+	for (const timer of state.timers.values()) clearTimeout(timer);
+	state.timers.clear();
+}
+
+function cleanupWebSocketConnection(
+	state: WebSocketSessionState,
+	driverAction: "cancel" | "none" = "cancel",
+): PendingWebSocketOutbound[] {
+	const session = state.currentSession;
+	const sendCancels = [...state.sendCancels.values()];
+	const canceled = [...state.liveSends.values()];
+	state.connected = false;
+	state.currentAttempt = 0;
+	state.currentSession = undefined;
+	state.sendCancels.clear();
+	state.liveSends.clear();
+	for (const cancelSend of sendCancels) runCancel(cancelSend);
+	if (driverAction === "cancel") session?.cancel();
+	return canceled;
+}
+
+function normalizeWebSocketSessionSendPolicy(
+	policy: WebSocketSessionSendPolicy | undefined,
+): { readonly kind: "reject" } | { readonly kind: "buffer"; readonly maxPending: number } {
+	if (policy?.kind !== "buffer") return { kind: "reject" };
+	if (!Number.isFinite(policy.maxPending) || policy.maxPending < 1) {
+		throw new Error("webSocketSession: buffer sendPolicy requires finite maxPending >= 1");
+	}
+	return { kind: "buffer", maxPending: Math.floor(policy.maxPending) };
+}
+
+function webSocketSessionEventNode(
+	graph: Graph,
+	command: Node<WebSocketSessionCommand>,
+	request: WebSocketRequest,
+	name: string,
+	policy: RetryPolicy,
+	sendPolicy: ReturnType<typeof normalizeWebSocketSessionSendPolicy>,
+): Node<WebSocketSessionEvent> {
+	return graph.node<WebSocketSessionEvent>(
+		[command],
+		(ctx) => {
+			const state = initWebSocketSessionState(ctx);
+
+			const emitOutbound = (fact: WebSocketSessionOutbound) => {
+				ctx.down([["DATA", { kind: "outbound", fact } satisfies WebSocketSessionEvent]]);
+			};
+
+			const emitOutboundCanceled = (
+				items: readonly PendingWebSocketOutbound[],
+				reason: unknown,
+			) => {
+				for (const item of items) {
+					emitOutbound({
+						kind: "canceled",
+						seq: item.seq,
+						message: item.message,
+						reason,
+					});
+				}
+			};
+
+			const emitOutboundRejected = (items: readonly PendingWebSocketOutbound[], error: unknown) => {
+				const payload = errorPayload(error);
+				for (const item of items) {
+					emitOutbound({
+						kind: "rejected",
+						seq: item.seq,
+						message: item.message,
+						error: payload,
+					});
+				}
+			};
+
+			const retryOrExhaust = (attempt: number, error: unknown) => {
+				const payload = errorPayload(error);
+				const canceled = cleanupWebSocketConnection(state);
+				emitOutboundCanceled(canceled, `${name}: connection cleanup`);
+				if (shouldRetry(policy, attempt)) {
+					const nextAttempt = attempt + 1;
+					const delayMs = nextRetryDelayMs(policy, nextAttempt) ?? 0;
+					ctx.down([
+						[
+							"DATA",
+							{
+								kind: "retry",
+								attempt,
+								nextAttempt,
+								delayMs,
+								error: payload,
+							} satisfies WebSocketSessionEvent,
+						],
+					]);
+					const timerId = state.seq++;
+					const timer = setTimeout(() => {
+						state.timers.delete(timerId);
+						if (!state.active) return;
+						start(nextAttempt);
+					}, delayMs);
+					state.timers.set(timerId, timer);
+				} else {
+					emitOutboundRejected(state.pendingOutbound, payload);
+					state.pendingOutbound = [];
+					ctx.down([
+						[
+							"DATA",
+							{ kind: "exhausted", attempt, error: payload } satisfies WebSocketSessionEvent,
+						],
+					]);
+				}
+			};
+
+			const start = (attempt: number) => {
+				if (
+					!state.active ||
+					state.connected ||
+					state.currentAttempt !== 0 ||
+					state.timers.size > 0
+				) {
+					return;
+				}
+				const driver = ctx.environment().webSocketDriver();
+				state.currentAttempt = attempt;
+				ctx.down([
+					[
+						"DATA",
+						{
+							kind: "attempt",
+							attempt,
+							maxAttempts: policy.maxAttempts,
+						} satisfies WebSocketSessionEvent,
+					],
+				]);
+				const connectSession = driver?.connectSession;
+				if (connectSession === undefined) {
+					retryOrExhaust(attempt, `${name}: missing WebSocket session capability`);
+					return;
+				}
+				let session: WebSocketSessionHandle | undefined;
+				try {
+					session = connectSession.call(driver, request, (event) => {
+						if (!state.active || state.currentAttempt !== attempt) return;
+						if (event.kind === "event") {
+							const ws = event.event;
+							if (ws.kind === "open") {
+								state.connected = true;
+								ctx.down([["DATA", { kind: "open", attempt } satisfies WebSocketSessionEvent]]);
+								flushPending();
+							} else if (ws.kind === "text" || ws.kind === "binary") {
+								ctx.down([
+									[
+										"DATA",
+										{
+											kind: "message",
+											message: ws satisfies WebSocketSessionInbound,
+										} satisfies WebSocketSessionEvent,
+									],
+								]);
+							} else if (ws.kind === "close") {
+								const normalClose = ws.code === 1000;
+								const canceled = cleanupWebSocketConnection(state);
+								emitOutboundCanceled(canceled, `${name}: session closed`);
+								ctx.down([
+									[
+										"DATA",
+										{
+											kind: "closed",
+											code: ws.code,
+											reason: ws.reason,
+										} satisfies WebSocketSessionEvent,
+									],
+								]);
+								if (!normalClose) {
+									retryOrExhaust(attempt, {
+										kind: "close",
+										code: ws.code,
+										reason: ws.reason,
+									});
+								}
+							}
+						} else if (event.kind === "error") {
+							retryOrExhaust(attempt, event.error);
+						} else if (event.kind === "complete") {
+							retryOrExhaust(attempt, `${name}: connection completed`);
+						}
+					});
+				} catch (error) {
+					retryOrExhaust(attempt, error);
+					return;
+				}
+				if (session === undefined) {
+					retryOrExhaust(attempt, `${name}: missing WebSocket session capability`);
+					return;
+				}
+				if (state.active && state.currentAttempt === attempt) {
+					state.currentSession = session;
+				} else {
+					session.cancel();
+				}
+			};
+
+			function sendNow(item: PendingWebSocketOutbound): void {
+				if (!state.connected) {
+					emitOutbound({
+						kind: "rejected",
+						seq: item.seq,
+						message: item.message,
+						error: `${name}: session is not open`,
+					});
+					ctx.down([
+						[
+							"DATA",
+							{
+								kind: "error",
+								error: `${name}: session is not open`,
+							} satisfies WebSocketSessionEvent,
+						],
+					]);
+					return;
+				}
+				const session = state.currentSession;
+				if (session === undefined) {
+					emitOutbound({
+						kind: "rejected",
+						seq: item.seq,
+						message: item.message,
+						error: `${name}: missing WebSocket session capability`,
+					});
+					ctx.down([
+						[
+							"DATA",
+							{
+								kind: "error",
+								error: `${name}: missing WebSocket session capability`,
+							} satisfies WebSocketSessionEvent,
+						],
+					]);
+					return;
+				}
+				const sendId = state.seq++;
+				state.liveSends.set(sendId, item);
+				emitOutbound({ kind: "sending", seq: item.seq, message: item.message });
+				let done = false;
+				let cancel: DriverCancel | undefined;
+				try {
+					cancel = session.send(item.message, (result) => {
+						if (done || !state.active || !state.liveSends.has(sendId)) return;
+						done = true;
+						state.liveSends.delete(sendId);
+						state.sendCancels.delete(sendId);
+						if (result.ok) {
+							emitOutbound({ kind: "sent", seq: item.seq, message: item.message });
+							ctx.down([
+								["DATA", { kind: "sent", message: item.message } satisfies WebSocketSessionEvent],
+							]);
+						} else {
+							const payload = errorPayload(result.error);
+							emitOutbound({
+								kind: "rejected",
+								seq: item.seq,
+								message: item.message,
+								error: payload,
+							});
+							ctx.down([
+								[
+									"DATA",
+									{
+										kind: "error",
+										error: payload,
+									} satisfies WebSocketSessionEvent,
+								],
+							]);
+						}
+					});
+				} catch (error) {
+					state.liveSends.delete(sendId);
+					const payload = errorPayload(error);
+					emitOutbound({
+						kind: "rejected",
+						seq: item.seq,
+						message: item.message,
+						error: payload,
+					});
+					ctx.down([["DATA", { kind: "error", error: payload } satisfies WebSocketSessionEvent]]);
+					return;
+				}
+				if (cancel !== undefined && !done && state.active && state.liveSends.has(sendId)) {
+					state.sendCancels.set(sendId, cancel);
+				} else if (cancel !== undefined && !state.active) runCancel(cancel);
+			}
+
+			function flushPending(): void {
+				const pending = state.pendingOutbound;
+				state.pendingOutbound = [];
+				for (let index = 0; index < pending.length; index++) {
+					const item = pending[index];
+					if (!state.connected || state.currentSession === undefined) {
+						emitOutboundCanceled(pending.slice(index), `${name}: session closed`);
+						return;
+					}
+					sendNow(item);
+				}
+			}
+
+			const send = (message: WebSocketSend) => {
+				const item = { seq: state.outboundSeq++, message } satisfies PendingWebSocketOutbound;
+				if (state.connected) {
+					sendNow(item);
+					return;
+				}
+				if (sendPolicy.kind === "buffer") {
+					if (state.pendingOutbound.length >= sendPolicy.maxPending) {
+						emitOutbound({
+							kind: "rejected",
+							seq: item.seq,
+							message,
+							error: `${name}: outbound buffer full`,
+						});
+						ctx.down([
+							[
+								"DATA",
+								{
+									kind: "error",
+									error: `${name}: outbound buffer full`,
+								} satisfies WebSocketSessionEvent,
+							],
+						]);
+						return;
+					}
+					state.pendingOutbound.push(item);
+					emitOutbound({ kind: "queued", seq: item.seq, message });
+					return;
+				}
+				emitOutbound({
+					kind: "rejected",
+					seq: item.seq,
+					message,
+					error: `${name}: session is not open`,
+				});
+				ctx.down([
+					[
+						"DATA",
+						{
+							kind: "error",
+							error: `${name}: session is not open`,
+						} satisfies WebSocketSessionEvent,
+					],
+				]);
+			};
+
+			for (const raw of depBatch(ctx, 0) ?? []) {
+				const commandValue = raw as WebSocketSessionCommand;
+				if (commandValue.kind === "start") start(1);
+				else if (commandValue.kind === "send") send(commandValue.message);
+				else {
+					cancelRetryTimers(state);
+					ctx.down([
+						[
+							"DATA",
+							{
+								kind: "closing",
+								code: commandValue.code,
+								reason: commandValue.reason,
+							} satisfies WebSocketSessionEvent,
+						],
+					]);
+					const { canceled, session } = closeWebSocketSessionState(state, "none");
+					emitOutboundCanceled(canceled, `${name}: session closed`);
+					session?.close(commandValue.code, commandValue.reason);
+					ctx.down([
+						[
+							"DATA",
+							{
+								kind: "closed",
+								code: commandValue.code,
+								reason: commandValue.reason,
+							} satisfies WebSocketSessionEvent,
+						],
+					]);
+				}
+			}
+		},
+		{ name: `${name}/events`, factory: "webSocketSessionEvents" },
+	);
+}
+
+function webSocketSessionNodes(
+	graph: Graph,
+	command: Node<WebSocketSessionCommand>,
+	events: Node<WebSocketSessionEvent>,
+	name: string,
+	policy: RetryPolicy,
+): WebSocketSessionBundle {
+	const inbound = graph.node<WebSocketSessionInbound>(
+		[events],
+		(ctx) => {
+			for (const raw of depBatch(ctx, 0) ?? []) {
+				const event = raw as WebSocketSessionEvent;
+				if (event.kind === "message") ctx.down([["DATA", event.message]]);
+			}
+		},
+		{ name: `${name}/inbound`, factory: "webSocketSessionInbound" },
+	);
+	const lifecycle = graph.node<WebSocketSessionLifecycle>(
+		[events],
+		(ctx) => {
+			for (const raw of depBatch(ctx, 0) ?? []) {
+				const event = raw as WebSocketSessionEvent;
+				if (event.kind === "attempt") {
+					ctx.down([
+						[
+							"DATA",
+							{
+								kind: "starting",
+								attempt: event.attempt,
+								maxAttempts: event.maxAttempts,
+							} satisfies WebSocketSessionLifecycle,
+						],
+					]);
+				} else if (event.kind === "open") {
+					ctx.down([["DATA", { kind: "open", attempt: event.attempt }]]);
+				} else if (event.kind === "sent") {
+					ctx.down([["DATA", { kind: "sent", message: event.message }]]);
+				} else if (event.kind === "closing" || event.kind === "closed") {
+					ctx.down([["DATA", event]]);
+				} else if (event.kind === "retry") {
+					ctx.down([
+						[
+							"DATA",
+							{
+								kind: "retrying",
+								attempt: event.attempt,
+								nextAttempt: event.nextAttempt,
+								delayMs: event.delayMs,
+								error: event.error,
+							} satisfies WebSocketSessionLifecycle,
+						],
+					]);
+				} else if (event.kind === "exhausted") {
+					ctx.down([["DATA", event]]);
+				}
+			}
+		},
+		{ name: `${name}/lifecycle`, factory: "webSocketSessionLifecycle" },
+	);
+	const outbound = graph.node<WebSocketSessionOutbound>(
+		[events],
+		(ctx) => {
+			for (const raw of depBatch(ctx, 0) ?? []) {
+				const event = raw as WebSocketSessionEvent;
+				if (event.kind === "outbound") ctx.down([["DATA", event.fact]]);
+			}
+		},
+		{ name: `${name}/outbound`, factory: "webSocketSessionOutbound" },
+	);
+	const status = graph.node<WebSocketSessionStatus>(
+		[events],
+		(ctx) => {
+			let next =
+				ctx.state.get<WebSocketSessionStatus>() ??
+				({
+					state: "idle",
+					attempt: 0,
+					maxAttempts: policy.maxAttempts,
+					sent: 0,
+					received: 0,
+					errors: 0,
+				} satisfies WebSocketSessionStatus);
+			for (const raw of depBatch(ctx, 0) ?? []) {
+				const event = raw as WebSocketSessionEvent;
+				if (event.kind === "attempt") {
+					next = {
+						...next,
+						state: "connecting",
+						attempt: event.attempt,
+						maxAttempts: event.maxAttempts,
+						lastDelayMs: undefined,
+					};
+				} else if (event.kind === "open") {
+					next = { ...next, state: "open", attempt: event.attempt, lastDelayMs: undefined };
+				} else if (event.kind === "message") {
+					next = { ...next, received: next.received + 1 };
+				} else if (event.kind === "sent") {
+					next = { ...next, sent: next.sent + 1 };
+				} else if (event.kind === "closing") {
+					next = { ...next, state: "closing" };
+				} else if (event.kind === "closed") {
+					next = { ...next, state: "closed" };
+				} else if (event.kind === "retry") {
+					next = {
+						...next,
+						state: "waiting",
+						attempt: event.attempt,
+						errors: next.errors + 1,
+						lastDelayMs: event.delayMs,
+					};
+				} else if (event.kind === "error") {
+					next = {
+						...next,
+						state: "errored",
+						attempt: event.attempt ?? next.attempt,
+						errors: next.errors + 1,
+					};
+				} else if (event.kind === "exhausted") {
+					next = {
+						...next,
+						state: "exhausted",
+						attempt: event.attempt,
+						errors: next.errors + 1,
+					};
+				}
+			}
+			ctx.state.set(next);
+			ctx.down([["DATA", next]]);
+		},
+		{ name: `${name}/status`, factory: "webSocketSessionStatus" },
+	);
+	const errors = graph.node<unknown>(
+		[events],
+		(ctx) => {
+			for (const raw of depBatch(ctx, 0) ?? []) {
+				const event = raw as WebSocketSessionEvent;
+				if ("error" in event) ctx.down([["DATA", event.error]]);
+			}
+		},
+		{ name: `${name}/errors`, factory: "webSocketSessionErrors" },
+	);
+	const attempts = graph.node<number>(
+		[events],
+		(ctx) => {
+			for (const raw of depBatch(ctx, 0) ?? []) {
+				const event = raw as WebSocketSessionEvent;
+				if (event.kind === "attempt") ctx.down([["DATA", event.attempt]]);
+			}
+		},
+		{ name: `${name}/attempts`, factory: "webSocketSessionAttempts" },
+	);
+	return {
+		command,
+		inbound,
+		lifecycle,
+		outbound,
+		status,
+		errors,
+		attempts,
+		start: () => command.down([["DATA", { kind: "start" }]]),
+		send: (message) =>
+			command.down([
+				[
+					"DATA",
+					{
+						kind: "send",
+						message:
+							typeof message === "string" || message instanceof Uint8Array
+								? { data: message }
+								: message,
+					},
+				],
+			]),
+		close: (code, reason) => command.down([["DATA", { kind: "close", code, reason }]]),
+	};
+}
+
+/**
+ * Create a graph-visible D133 WebSocket SessionBundle.
+ *
+ * The convenience start/send/close methods publish command facts only; hidden
+ * session state is driven by the command node and graph-local EnvironmentDrivers.
+ */
+export function webSocketSession(
+	graph: Graph,
+	request: WebSocketRequest,
+	opts: WebSocketSessionOptions = {},
+): WebSocketSessionBundle {
+	const name = opts.name ?? "webSocketSession";
+	const policy = opts.retry ?? retryPolicy();
+	const sendPolicy = normalizeWebSocketSessionSendPolicy(opts.sendPolicy);
+	const command = graph.node<WebSocketSessionCommand>([], null, {
+		name: `${name}/command`,
+		factory: "webSocketSessionCommand",
+	});
+	const events = webSocketSessionEventNode(graph, command, request, name, policy, sendPolicy);
+	return webSocketSessionNodes(graph, command, events, name, policy);
+}
diff --git a/packages/ts/src/adapters/environment.ts b/packages/ts/src/adapters/environment.ts
new file mode 100644
index 00000000..1131cc86
--- /dev/null
+++ b/packages/ts/src/adapters/environment.ts
@@ -0,0 +1,27 @@
+/**
+ * Graph-visible outbound environment adapters (D130/D132).
+ *
+ * Async transport work is confined to graph-local EnvironmentDrivers. Each
+ * helper returns declared nodes for events/status/attempts/errors instead of a
+ * hidden sink side channel.
+ */
+
+export { toHttp, toProcess, toWebSocket } from "./environment-outbound.js";
+export type {
+	HttpRequestOf,
+	OutboundAdapterOptions,
+	OutboundBundle,
+	OutboundEvent,
+	OutboundStatus,
+	ProcessCommandOf,
+	WebSocketSendOf,
+	WebSocketSessionBundle,
+	WebSocketSessionCommand,
+	WebSocketSessionInbound,
+	WebSocketSessionLifecycle,
+	WebSocketSessionOptions,
+	WebSocketSessionOutbound,
+	WebSocketSessionSendPolicy,
+	WebSocketSessionStatus,
+} from "./environment-types.js";
+export { webSocketSession } from "./environment-websocket-session.js";
diff --git a/packages/ts/src/adapters/index.ts b/packages/ts/src/adapters/index.ts
new file mode 100644
index 00000000..5a509eea
--- /dev/null
+++ b/packages/ts/src/adapters/index.ts
@@ -0,0 +1,13 @@
+/**
+ * Graph/framework/environment adapter namespace.
+ *
+ * Use focused adapter subpaths for graph-bound bridges such as
+ * `@graphrefly/ts/adapters/observe-storage`.
+ */
+
+export * from "./agentic-memory-storage.js";
+export * from "./bridge.js";
+export * from "./bridge-wire-edge-group.js";
+export * from "./environment.js";
+export * from "./reactive-collection-storage.js";
+export * from "./store.js";
diff --git a/packages/ts/src/adapters/nestjs.ts b/packages/ts/src/adapters/nestjs.ts
new file mode 100644
index 00000000..ee642d90
--- /dev/null
+++ b/packages/ts/src/adapters/nestjs.ts
@@ -0,0 +1,1697 @@
+/**
+ * Focused NestJS boundary bindings for GraphReFly (D474/D478).
+ *
+ * This subpath stays dependency-light: it exposes graph boundary primitives,
+ * token/provider shapes, and decorator metadata without importing Nest itself.
+ * User-land Nest modules/controllers bind these helpers to real decorators and
+ * host lifecycle objects at the framework edge.
+ */
+
+import type { DataIssue } from "../data/index.js";
+import type { Graph } from "../graph/graph.js";
+import type { Node } from "../node/node.js";
+import type { Message } from "../protocol/messages.js";
+
+export const NEST_BOUNDARY_ENVELOPE_VERSION = 1;
+export const NEST_BOUNDARY_PAYLOAD_MAX_BYTES = 64 * 1024;
+export const NEST_HTTP_DIAGNOSTICS_MAX_RETAINED = 100;
+
+/** D478 minimal graph-visible transport envelope. Payload must be data-only. */
+export interface NestBoundaryEnvelope<T = unknown> {
+	readonly bindingId: string;
+	readonly version: number;
+	readonly payload: T;
+	readonly requestId?: string;
+}
+
+/** Reply-capable egress must carry host-private request correlation (D478). */
+export type NestReplyEnvelope<T = unknown> = NestBoundaryEnvelope<T> & {
+	readonly requestId: string;
+};
+
+export type NestBoundaryKind =
+	| "request"
+	| "guard"
+	| "interceptor"
+	| "error"
+	| "lifecycle"
+	| "cron"
+	| "diagnostics"
+	| "ws"
+	| "message";
+
+export type NestEgressKind = "http" | "guard-decision" | "ws-ack" | "ws-reply" | "message-reply";
+export type NestFilterMode = "handle" | "observe";
+export type NestDiagnosticPhase =
+	| "adapter"
+	| "http"
+	| "guard"
+	| "filter"
+	| "cron"
+	| "lifecycle"
+	| "ws"
+	| "message"
+	| NestBoundaryKind
+	| NestEgressKind;
+
+export interface NestHttpResponsePayload<TBody = unknown> {
+	readonly status: number;
+	readonly body?: TBody;
+	readonly headers?: Record<string, string>;
+}
+
+export interface HttpDataIssue extends DataIssue {
+	readonly status: number;
+	readonly body?: unknown;
+	readonly headers?: Record<string, string>;
+}
+
+export type NestIssueResponse<THost = unknown> = (
+	issue: DataIssue,
+	host: THost,
+) => NestHttpResponsePayload;
+
+export type NestProtocolErrorResponse<THost = unknown> = (
+	errorPayload: unknown,
+	host: THost,
+) => NestHttpResponsePayload;
+
+export type GraphGuardDecision =
+	| {
+			readonly kind: "allow";
+			readonly reason?: string;
+			readonly metadata?: Record<string, unknown>;
+	  }
+	| {
+			readonly kind: "deny";
+			readonly reason?: string;
+			readonly status?: number;
+			readonly body?: unknown;
+			readonly headers?: Record<string, string>;
+			readonly issue?: DataIssue | HttpDataIssue;
+			readonly metadata?: Record<string, unknown>;
+	  };
+
+export interface NestBoundaryDiagnostic {
+	readonly kind:
+		| "binding-mismatch"
+		| "dispose-pending"
+		| "malformed-egress"
+		| "stale-egress"
+		| "terminal-egress"
+		| "timeout"
+		| "resolve-threw"
+		| "reject-threw";
+	readonly phase?: NestDiagnosticPhase;
+	readonly requestId?: string;
+	readonly bindingId?: string;
+	readonly expectedBindingId?: string;
+	readonly message: string;
+	readonly error?: unknown;
+}
+
+export interface NestDiagnosticErrorPayload {
+	readonly name?: string;
+	readonly message: string;
+}
+
+export interface NestDiagnosticPayload {
+	readonly kind: NestBoundaryDiagnostic["kind"];
+	readonly phase: NestDiagnosticPhase;
+	readonly requestId?: string;
+	readonly bindingId?: string;
+	readonly expectedBindingId?: string;
+	readonly message: string;
+	readonly error?: NestDiagnosticErrorPayload;
+}
+
+export interface NestDiagnosticInput extends NestBoundaryDiagnostic {
+	readonly phase?: NestDiagnosticPhase;
+}
+
+export interface NestDiagnosticsOptions
+	extends Omit<NestIngressOptions<NestDiagnosticInput, NestDiagnosticPayload>, "payload"> {
+	readonly phase?: NestDiagnosticPhase;
+}
+
+export type NestDiagnosticIngressBoundary = NestIngressBoundary<
+	NestDiagnosticInput,
+	NestDiagnosticPayload
+>;
+
+export interface NestIngressBoundary<THost = unknown, TPayload = THost> {
+	readonly kind: NestBoundaryKind;
+	readonly bindingId: string;
+	readonly version: number;
+	readonly node: Node<NestBoundaryEnvelope<TPayload>>;
+	envelope(host: THost, opts?: NestIngressEmitOptions<TPayload>): NestBoundaryEnvelope<TPayload>;
+	emit(host: THost, opts?: NestIngressEmitOptions<TPayload>): NestBoundaryEnvelope<TPayload>;
+}
+
+export interface NestIngressOptions<THost, TPayload> {
+	readonly bindingId?: string;
+	readonly name?: string;
+	readonly version?: number;
+	readonly maxPayloadBytes?: number;
+	readonly requestId?: string | ((host: THost) => string | undefined);
+	readonly requireRequestId?: boolean;
+	readonly payload?: (host: THost) => TPayload;
+}
+
+export interface NestIngressEmitOptions<TPayload> {
+	readonly requestId?: string;
+	readonly bindingId?: string;
+	readonly version?: number;
+	readonly payload?: TPayload;
+	readonly requireRequestId?: boolean;
+}
+
+export interface NestReplyResponseHandle<TPayload> {
+	resolve(payload: TPayload, envelope: NestReplyEnvelope<TPayload>): void;
+	reject(error: unknown, envelope?: NestReplyEnvelope<TPayload>): void;
+}
+
+export interface NestReplyPendingRegistration<TPayload> {
+	readonly requestId: string;
+	readonly handle: NestReplyResponseHandle<TPayload>;
+	readonly bindingId?: string;
+}
+
+export interface NestReplyBoundary<TPayload = unknown> {
+	readonly kind: NestEgressKind;
+	readonly bindingId: string;
+	attach(registration: NestReplyPendingRegistration<TPayload>): () => boolean;
+	pendingCount(): number;
+	diagnostics(): readonly NestBoundaryDiagnostic[];
+	dispose(): void;
+}
+
+export interface NestHttpResponseHandle<TPayload> extends NestReplyResponseHandle<TPayload> {}
+
+export interface NestHttpPendingRegistration<TPayload>
+	extends NestReplyPendingRegistration<TPayload> {}
+
+export interface NestHttpBoundary<TPayload = unknown> extends NestReplyBoundary<TPayload> {
+	readonly kind: "http";
+}
+
+export interface ToNestHttpOptions<TPayload> {
+	readonly bindingId?: string;
+	readonly diagnosticBoundary?: NestDiagnosticIngressBoundary;
+	readonly diagnosticPhase?: NestDiagnosticPhase;
+	readonly maxDiagnostics?: number;
+	readonly maxPayloadBytes?: number;
+	readonly name?: string;
+	readonly transform?: (payload: TPayload, envelope: NestReplyEnvelope<TPayload>) => TPayload;
+	readonly label?: string;
+}
+
+interface NestReplyPendingEntry<TPayload> {
+	readonly requestId: string;
+	readonly bindingId?: string;
+	readonly handle: NestReplyResponseHandle<TPayload>;
+}
+
+interface NestHttpPendingEntry<TPayload> extends NestReplyPendingEntry<TPayload> {}
+
+export interface NestBoundaryDecoratorOptions<THost = unknown, TPayload = unknown> {
+	readonly bindingId?: string;
+	readonly payload?: (host: THost) => TPayload;
+	readonly requestId?: string | ((host: THost) => string | undefined);
+	readonly order?: number;
+}
+
+export interface NestFilterDecoratorOptions<THost = unknown, TPayload = unknown>
+	extends NestBoundaryDecoratorOptions<THost, TPayload> {
+	readonly mode?: NestFilterMode;
+	readonly issueResponse?: NestIssueResponse<THost>;
+	readonly protocolError?: NestProtocolErrorResponse<THost>;
+}
+
+export interface NestHttpReplyDecoratorOptions<THost = unknown> {
+	readonly bindingId: string;
+	readonly order?: number;
+	readonly issueResponse?: NestIssueResponse<THost>;
+	readonly protocolError?: NestProtocolErrorResponse<THost>;
+}
+
+export interface NestGuardDecisionDecoratorOptions<THost = unknown> {
+	readonly bindingId: string;
+	readonly order?: number;
+	readonly issueResponse?: NestIssueResponse<THost>;
+	readonly protocolError?: NestProtocolErrorResponse<THost>;
+}
+
+export interface NestGraphRunOptions<THost = unknown> {
+	readonly requestId?: string | ((host: THost) => string | undefined);
+}
+
+export interface NestGraphBoundaryRunnerOptions {
+	readonly diagnosticBoundary?: NestDiagnosticIngressBoundary;
+	readonly diagnosticPhase?: NestDiagnosticPhase;
+}
+
+export interface NestGraphBoundaryRunner {
+	run<THost = unknown>(
+		target: DecoratorHostConstructor | object,
+		methodKey: string | symbol,
+		host: THost,
+		opts?: NestGraphRunOptions<THost>,
+	): Promise<unknown> | undefined;
+	dispose(): void;
+}
+
+export interface NestExecutionContextLike {
+	getClass(): DecoratorHostConstructor;
+	getHandler(): DecoratorBoundMethod;
+	switchToHttp?(): { getRequest<T = unknown>(): T };
+}
+
+export interface NestCallHandlerLike {
+	handle(): unknown;
+}
+
+export interface NestGraphBoundaryInterceptorOptions<THost = unknown>
+	extends NestGraphRunOptions<THost>,
+		NestGraphBoundaryRunnerOptions {
+	readonly host?: (context: NestExecutionContextLike) => THost;
+	readonly runner?: NestGraphBoundaryRunner;
+}
+
+export interface NestGraphBoundaryInterceptor {
+	intercept(
+		context: NestExecutionContextLike,
+		next?: NestCallHandlerLike,
+	): Promise<unknown> | unknown;
+	dispose(): void;
+}
+
+/** Injection token for a root graph singleton. */
+export const GRAPHREFLY_ROOT_GRAPH = Symbol.for("graphrefly:root-graph");
+
+/** Injection token for adapter module options. */
+export const GRAPHREFLY_MODULE_OPTIONS = Symbol.for("graphrefly:module-options");
+
+/** Injection token for a request-scoped graph. */
+export const GRAPHREFLY_REQUEST_GRAPH = Symbol.for("graphrefly:request-graph");
+
+export type DecoratorHostConstructor = abstract new (...args: unknown[]) => unknown;
+export type DecoratorBoundMethod = (...args: unknown[]) => unknown;
+
+export interface OnGraphEventMeta {
+	nodeName: string;
+	methodKey: string | symbol;
+}
+
+export interface GraphIntervalMeta {
+	ms: number;
+	methodKey: string | symbol;
+}
+
+export interface GraphCronMeta {
+	expr: string;
+	methodKey: string | symbol;
+}
+
+export type NestBoundaryBindingDirection = "ingress" | "egress";
+
+export interface NestIngressBindingMeta {
+	readonly direction: "ingress";
+	kind: NestBoundaryKind;
+	bindingId: string;
+	methodKey: string | symbol;
+	readonly boundary: NestIngressBoundary<unknown, unknown>;
+	readonly payload?: (host: unknown) => unknown;
+	readonly requestId?: string | ((host: unknown) => string | undefined);
+	readonly order?: number;
+	readonly mode?: NestFilterMode;
+	readonly issueResponse?: NestIssueResponse<unknown>;
+	readonly protocolError?: NestProtocolErrorResponse<unknown>;
+}
+
+export interface NestHttpReplyBindingMeta {
+	readonly direction: "egress";
+	readonly kind: "http";
+	readonly bindingId: string;
+	readonly methodKey: string | symbol;
+	readonly replyNode: Node<NestReplyEnvelope<unknown>>;
+	readonly order?: number;
+	readonly issueResponse?: NestIssueResponse<unknown>;
+	readonly protocolError?: NestProtocolErrorResponse<unknown>;
+}
+
+export interface NestGuardDecisionBindingMeta {
+	readonly direction: "egress";
+	readonly kind: "guard-decision";
+	readonly bindingId: string;
+	readonly methodKey: string | symbol;
+	readonly decisionNode: Node<NestReplyEnvelope<GraphGuardDecision>>;
+	readonly order?: number;
+	readonly issueResponse?: NestIssueResponse<unknown>;
+	readonly protocolError?: NestProtocolErrorResponse<unknown>;
+}
+
+export interface NestWsAckBindingMeta {
+	readonly direction: "egress";
+	readonly kind: "ws-ack";
+	readonly bindingId: string;
+	readonly methodKey: string | symbol;
+	readonly ackNode: Node<NestReplyEnvelope<unknown>>;
+	readonly order?: number;
+}
+
+export interface NestWsReplyBindingMeta {
+	readonly direction: "egress";
+	readonly kind: "ws-reply";
+	readonly bindingId: string;
+	readonly methodKey: string | symbol;
+	readonly replyNode: Node<NestReplyEnvelope<unknown>>;
+	readonly order?: number;
+}
+
+export interface NestMessageReplyBindingMeta {
+	readonly direction: "egress";
+	readonly kind: "message-reply";
+	readonly bindingId: string;
+	readonly methodKey: string | symbol;
+	readonly replyNode: Node<NestReplyEnvelope<unknown>>;
+	readonly order?: number;
+}
+
+export type NestBoundaryBindingMeta =
+	| NestIngressBindingMeta
+	| NestHttpReplyBindingMeta
+	| NestGuardDecisionBindingMeta
+	| NestWsAckBindingMeta
+	| NestWsReplyBindingMeta
+	| NestMessageReplyBindingMeta;
+
+export const EVENT_HANDLERS = new WeakMap<DecoratorHostConstructor, OnGraphEventMeta[]>();
+export const INTERVAL_HANDLERS = new WeakMap<DecoratorHostConstructor, GraphIntervalMeta[]>();
+export const CRON_HANDLERS = new WeakMap<DecoratorHostConstructor, GraphCronMeta[]>();
+export const NEST_BOUNDARY_BINDINGS = new WeakMap<
+	DecoratorHostConstructor,
+	NestBoundaryBindingMeta[]
+>();
+
+export type GraphMethodDecorator = MethodDecorator &
+	((value: DecoratorBoundMethod, context: ClassMethodDecoratorContext) => void);
+
+/** Minimal Nest provider object shape without importing @nestjs/common. */
+export type NestProviderBinding<T = unknown> =
+	| { readonly provide: string | symbol; readonly useValue: T }
+	| { readonly provide: string | symbol; readonly useFactory: (...args: unknown[]) => T };
+
+/** Get the injection token for a named feature graph. */
+export function getGraphToken(name: string): symbol {
+	assertNonEmptyString(name, "getGraphToken(name)");
+	return Symbol.for(`graphrefly:graph:${name}`);
+}
+
+/** Get the injection token for a node at a qualified path. */
+export function getNodeToken(path: string): symbol {
+	assertNonEmptyString(path, "getNodeToken(path)");
+	return Symbol.for(`graphrefly:node:${path}`);
+}
+
+/** Get the injection token for a named Nest boundary binding. */
+export function getNestBoundaryToken(bindingId: string): symbol {
+	assertNonEmptyString(bindingId, "getNestBoundaryToken(bindingId)");
+	return Symbol.for(`graphrefly:nest-boundary:${bindingId}`);
+}
+
+/** Build a dependency-free provider binding shape for user-land Nest modules. */
+export function nestProvider<T>(provide: string | symbol, useValue: T): NestProviderBinding<T> {
+	return { provide, useValue };
+}
+
+/** D474 P0 HTTP request ingress. */
+export function fromNestReq<THost = unknown, TPayload = THost>(
+	graph: Graph,
+	opts: NestIngressOptions<THost, TPayload> = {},
+): NestIngressBoundary<THost, TPayload> {
+	return nestIngress(graph, "request", opts);
+}
+
+/** D474 P0 guard/admission ingress. */
+export function fromNestGuard<THost = unknown, TPayload = THost>(
+	graph: Graph,
+	opts: NestIngressOptions<THost, TPayload> = {},
+): NestIngressBoundary<THost, TPayload> {
+	return nestIngress(graph, "guard", opts);
+}
+
+/** D474 P1 interceptor ingress. */
+export function fromNestIntercept<THost = unknown, TPayload = THost>(
+	graph: Graph,
+	opts: NestIngressOptions<THost, TPayload> = {},
+): NestIngressBoundary<THost, TPayload> {
+	return nestIngress(graph, "interceptor", opts);
+}
+
+/** D474 P0 error/filter ingress. */
+export function fromNestError<THost = unknown, TPayload = THost>(
+	graph: Graph,
+	opts: NestIngressOptions<THost, TPayload> = {},
+): NestIngressBoundary<THost, TPayload> {
+	return nestIngress(graph, "error", opts);
+}
+
+/** D474 P1 Nest lifecycle hook ingress. */
+export function fromNestLifecycle<THost = unknown, TPayload = THost>(
+	graph: Graph,
+	opts: NestIngressOptions<THost, TPayload> = {},
+): NestIngressBoundary<THost, TPayload> {
+	return nestIngress(graph, "lifecycle", opts);
+}
+
+/** D474 P1 schedule/cron ingress. */
+export function fromNestCron<THost = unknown, TPayload = THost>(
+	graph: Graph,
+	opts: NestIngressOptions<THost, TPayload> = {},
+): NestIngressBoundary<THost, TPayload> {
+	return nestIngress(graph, "cron", opts);
+}
+
+/** D494 explicit graph-visible diagnostics ingress. Emits sanitized data-only payloads. */
+export function fromNestDiagnostics(
+	graph: Graph,
+	opts: NestDiagnosticsOptions = {},
+): NestDiagnosticIngressBoundary {
+	return nestIngress<NestDiagnosticInput, NestDiagnosticPayload>(graph, "diagnostics", {
+		...opts,
+		payload: (diagnostic) => sanitizeNestDiagnostic(diagnostic, opts.phase),
+	});
+}
+
+/** D474 later/optional WebSocket ingress. Kept thin for first-slice experiments. */
+export function fromNestWs<THost = unknown, TPayload = THost>(
+	graph: Graph,
+	opts: NestIngressOptions<THost, TPayload> = {},
+): NestIngressBoundary<THost, TPayload> {
+	return nestIngress(graph, "ws", opts);
+}
+
+/** D474 later/optional microservice/message ingress. */
+export function fromNestMessage<THost = unknown, TPayload = THost>(
+	graph: Graph,
+	opts: NestIngressOptions<THost, TPayload> = {},
+): NestIngressBoundary<THost, TPayload> {
+	return nestIngress(graph, "message", opts);
+}
+
+/**
+ * D474 HTTP egress resolver.
+ *
+ * The returned boundary owns only a host-private pending map. It never stores
+ * response/socket/ack handles in graph DATA and only resolves handles whose
+ * requestId (and optional bindingId) match an egress envelope.
+ */
+export function toNestHttp<TPayload = unknown>(
+	egress: Node<NestReplyEnvelope<TPayload>>,
+	opts: ToNestHttpOptions<TPayload> = {},
+): NestHttpBoundary<TPayload> {
+	const bindingId = stableBindingId("http", opts);
+	const scopedBindingId = opts.bindingId;
+	const maxDiagnostics = diagnosticsRetainedLimit(opts.maxDiagnostics);
+	const maxPayloadBytes = payloadByteLimit(opts.maxPayloadBytes);
+	const pending = new Map<string, NestHttpPendingEntry<TPayload>>();
+	const diagnostics: NestBoundaryDiagnostic[] = [];
+	let active = true;
+	let terminal:
+		| {
+				readonly error: unknown;
+				readonly message: string;
+		  }
+		| undefined;
+
+	const report = (diagnostic: NestBoundaryDiagnostic) => {
+		pushDiagnostic(diagnostics, diagnostic, maxDiagnostics);
+		try {
+			const phase = diagnostic.phase ?? opts.diagnosticPhase ?? "http";
+			const payload = sanitizeNestDiagnostic({ ...diagnostic, phase }, phase);
+			opts.diagnosticBoundary?.emit(payload, { payload });
+		} catch {
+			// Graph-visible diagnostics are optional and must not interrupt host cleanup.
+		}
+	};
+	const keyOf = (requestId: string, requestBindingId?: string) =>
+		requestBindingId === undefined ? requestId : `${requestBindingId}\u0000${requestId}`;
+	const rejectEntry = (
+		entry: NestHttpPendingEntry<TPayload>,
+		error: unknown,
+		envelope: NestReplyEnvelope<TPayload> | undefined,
+		message: string,
+	) => {
+		try {
+			entry.handle.reject(error, envelope);
+		} catch (rejectError) {
+			report({
+				kind: "reject-threw",
+				requestId: entry.requestId,
+				bindingId: entry.bindingId,
+				message,
+				error: rejectError,
+			});
+		}
+	};
+	const rejectPending = (
+		kind: "dispose-pending" | "terminal-egress",
+		error: unknown,
+		message: string,
+	): number => {
+		const entries = [...pending.values()];
+		pending.clear();
+		if (entries.length === 0) return 0;
+		report({ kind, bindingId: scopedBindingId, message, error });
+		for (const entry of entries) {
+			rejectEntry(entry, error, undefined, `toNestHttp(${bindingId}) pending reject threw`);
+		}
+		return entries.length;
+	};
+
+	const unsubscribe = egress.subscribe((msg: Message) => {
+		if (!active) return;
+		if (msg[0] === "ERROR" || msg[0] === "COMPLETE" || msg[0] === "TEARDOWN") {
+			const error =
+				msg[0] === "ERROR"
+					? msg[1]
+					: new Error(`toNestHttp(${bindingId}) egress received ${msg[0]}`);
+			const message = `toNestHttp(${bindingId}) rejected pending requests after ${msg[0]}`;
+			terminal = { error, message };
+			const rejectedCount = rejectPending("terminal-egress", error, message);
+			if (rejectedCount === 0)
+				report({ kind: "terminal-egress", bindingId: scopedBindingId, message, error });
+			return;
+		}
+		if (msg[0] !== "DATA") return;
+		const envelope = msg[1] as NestReplyEnvelope<TPayload>;
+		const malformed = validateEnvelope(envelope, maxPayloadBytes);
+		if (malformed !== undefined) {
+			const correlated = malformedCorrelation(msg[1], scopedBindingId);
+			if (correlated !== undefined) {
+				const pendingKey = keyOf(correlated.requestId, scopedBindingId);
+				const entry = pending.get(pendingKey);
+				if (entry !== undefined) {
+					pending.delete(pendingKey);
+					rejectEntry(
+						entry,
+						new Error(malformed),
+						undefined,
+						`toNestHttp(${bindingId}) rejected malformed correlated egress`,
+					);
+				}
+			}
+			report({
+				kind: "malformed-egress",
+				requestId: correlated?.requestId,
+				bindingId: correlated?.bindingId,
+				message: malformed,
+			});
+			return;
+		}
+		if (scopedBindingId !== undefined && envelope.bindingId !== scopedBindingId) {
+			report({
+				kind: "binding-mismatch",
+				requestId: envelope.requestId,
+				bindingId: envelope.bindingId,
+				expectedBindingId: scopedBindingId,
+				message: `toNestHttp(${bindingId}) ignored egress for binding ${envelope.bindingId}`,
+			});
+			return;
+		}
+		const pendingKey = keyOf(envelope.requestId, scopedBindingId);
+		const entry = pending.get(pendingKey);
+		if (entry === undefined) {
+			report({
+				kind: "stale-egress",
+				requestId: envelope.requestId,
+				bindingId: envelope.bindingId,
+				message: `toNestHttp(${bindingId}) ignored stale requestId ${envelope.requestId}`,
+			});
+			return;
+		}
+		pending.delete(pendingKey);
+		try {
+			entry.handle.resolve(
+				opts.transform?.(envelope.payload, envelope) ?? envelope.payload,
+				envelope,
+			);
+		} catch (error) {
+			report({
+				kind: "resolve-threw",
+				requestId: envelope.requestId,
+				bindingId: envelope.bindingId,
+				message: `toNestHttp(${bindingId}) response handle threw while resolving`,
+				error,
+			});
+			rejectEntry(
+				entry,
+				error,
+				envelope,
+				`toNestHttp(${bindingId}) response handle threw while rejecting`,
+			);
+		}
+	});
+
+	return {
+		kind: "http",
+		bindingId,
+		attach(registration) {
+			if (!active) throw new Error(`toNestHttp(${bindingId}) is disposed`);
+			assertNonEmptyString(registration.requestId, "toNestHttp.attach(requestId)");
+			const registrationBindingId = registration.bindingId ?? scopedBindingId;
+			if (scopedBindingId !== undefined && registrationBindingId !== scopedBindingId) {
+				throw new Error(
+					`toNestHttp.attach expected bindingId ${scopedBindingId}, got ${registrationBindingId}`,
+				);
+			}
+			if (terminal !== undefined) {
+				const entry = {
+					requestId: registration.requestId,
+					bindingId: registrationBindingId,
+					handle: registration.handle,
+				};
+				report({
+					kind: "terminal-egress",
+					requestId: registration.requestId,
+					bindingId: registrationBindingId,
+					message: terminal.message,
+					error: terminal.error,
+				});
+				rejectEntry(
+					entry,
+					terminal.error,
+					undefined,
+					`toNestHttp(${bindingId}) terminal response handle reject threw`,
+				);
+				return () => false;
+			}
+			const key = keyOf(registration.requestId, scopedBindingId);
+			if (pending.has(key)) {
+				throw new Error(`toNestHttp.attach duplicate pending requestId ${registration.requestId}`);
+			}
+			const entry = {
+				requestId: registration.requestId,
+				bindingId: registrationBindingId,
+				handle: registration.handle,
+			};
+			pending.set(key, entry);
+			return () => {
+				if (pending.get(key) !== entry) return false;
+				return pending.delete(key);
+			};
+		},
+		pendingCount: () => pending.size,
+		diagnostics: () => diagnostics.slice(),
+		dispose() {
+			if (!active) return;
+			active = false;
+			rejectPending(
+				"dispose-pending",
+				new Error(`toNestHttp(${bindingId}) disposed before response resolution`),
+				`toNestHttp(${bindingId}) rejected pending requests during dispose`,
+			);
+			unsubscribe();
+		},
+	};
+}
+
+/** D478 route-request decorator over an existing ingress boundary. */
+export function GraphReq<THost = unknown, TPayload = unknown>(
+	boundary: NestIngressBoundary<THost, TPayload>,
+	opts: NestBoundaryDecoratorOptions<THost, TPayload> = {},
+): GraphMethodDecorator {
+	return graphIngressBinding("request", boundary, opts);
+}
+
+/** D478 route-guard decorator over an existing ingress boundary. */
+export function GraphGuard<THost = unknown, TPayload = unknown>(
+	boundary: NestIngressBoundary<THost, TPayload>,
+	opts: NestBoundaryDecoratorOptions<THost, TPayload> = {},
+): GraphMethodDecorator {
+	return graphIngressBinding("guard", boundary, opts);
+}
+
+/** D478 route-interceptor decorator over an existing ingress boundary. */
+export function GraphIntercept<THost = unknown, TPayload = unknown>(
+	boundary: NestIngressBoundary<THost, TPayload>,
+	opts: NestBoundaryDecoratorOptions<THost, TPayload> = {},
+): GraphMethodDecorator {
+	return graphIngressBinding("interceptor", boundary, opts);
+}
+
+/** D484 generic filter decorator over an existing ingress boundary. */
+export function GraphFilter<THost = unknown, TPayload = unknown>(
+	boundary: NestIngressBoundary<THost, TPayload>,
+	opts: NestFilterDecoratorOptions<THost, TPayload> = {},
+): GraphMethodDecorator {
+	return graphIngressBinding("error", boundary, opts);
+}
+
+/** D484 exception-oriented sugar over GraphFilter. */
+export function GraphError<THost = unknown, TPayload = unknown>(
+	boundary: NestIngressBoundary<THost, TPayload>,
+	opts: NestFilterDecoratorOptions<THost, TPayload> = {},
+): GraphMethodDecorator {
+	return GraphFilter(boundary, opts);
+}
+
+/** D478 lifecycle decorator over an existing ingress boundary. */
+export function GraphLifecycle<THost = unknown, TPayload = unknown>(
+	boundary: NestIngressBoundary<THost, TPayload>,
+	opts: NestBoundaryDecoratorOptions<THost, TPayload> = {},
+): GraphMethodDecorator {
+	return graphIngressBinding("lifecycle", boundary, opts);
+}
+
+/** D478 cron/schedule decorator over an existing ingress boundary. */
+export function GraphCron<THost = unknown, TPayload = unknown>(
+	boundary: NestIngressBoundary<THost, TPayload>,
+	opts: NestBoundaryDecoratorOptions<THost, TPayload> = {},
+): GraphMethodDecorator {
+	return graphIngressBinding("cron", boundary, opts);
+}
+
+/** D488 WebSocket message ingress decorator over an existing boundary. */
+export function GraphWs<THost = unknown, TPayload = unknown>(
+	boundary: NestIngressBoundary<THost, TPayload>,
+	opts: NestBoundaryDecoratorOptions<THost, TPayload> = {},
+): GraphMethodDecorator {
+	return graphIngressBinding("ws", boundary, opts);
+}
+
+/** D488 microservice/message ingress decorator over an existing boundary. */
+export function GraphMessage<THost = unknown, TPayload = unknown>(
+	boundary: NestIngressBoundary<THost, TPayload>,
+	opts: NestBoundaryDecoratorOptions<THost, TPayload> = {},
+): GraphMethodDecorator {
+	return graphIngressBinding("message", boundary, opts);
+}
+
+/** D478 HTTP reply decorator over an existing reply node. */
+export function GraphHttpReply<THost = unknown, TPayload = unknown>(
+	replyNode: Node<NestReplyEnvelope<TPayload>>,
+	opts: NestHttpReplyDecoratorOptions<THost>,
+): GraphMethodDecorator {
+	const bindingId = opts?.bindingId;
+	if (typeof bindingId !== "string" || bindingId.length === 0) {
+		throw new Error("GraphHttpReply requires a non-empty bindingId");
+	}
+	return registerMeta(NEST_BOUNDARY_BINDINGS, (methodKey) => ({
+		direction: "egress" as const,
+		kind: "http" as const,
+		bindingId,
+		methodKey,
+		replyNode: replyNode as Node<NestReplyEnvelope<unknown>>,
+		order: opts.order,
+		issueResponse: opts.issueResponse as NestIssueResponse<unknown> | undefined,
+		protocolError: opts.protocolError as NestProtocolErrorResponse<unknown> | undefined,
+	}));
+}
+
+/** D484 guard decision egress decorator over an existing reply-correlated decision node. */
+export function GraphGuardDecision<THost = unknown>(
+	decisionNode: Node<NestReplyEnvelope<GraphGuardDecision>>,
+	opts: NestGuardDecisionDecoratorOptions<THost>,
+): GraphMethodDecorator {
+	const bindingId = opts?.bindingId;
+	if (typeof bindingId !== "string" || bindingId.length === 0) {
+		throw new Error("GraphGuardDecision requires a non-empty bindingId");
+	}
+	return registerMeta(NEST_BOUNDARY_BINDINGS, (methodKey) => ({
+		direction: "egress" as const,
+		kind: "guard-decision" as const,
+		bindingId,
+		methodKey,
+		decisionNode,
+		order: opts.order,
+		issueResponse: opts.issueResponse as NestIssueResponse<unknown> | undefined,
+		protocolError: opts.protocolError as NestProtocolErrorResponse<unknown> | undefined,
+	}));
+}
+
+/** D488 WebSocket acknowledgement egress decorator over an existing reply-correlated node. */
+export function GraphWsAck<TPayload = unknown>(
+	ackNode: Node<NestReplyEnvelope<TPayload>>,
+	opts: { readonly bindingId: string; readonly order?: number },
+): GraphMethodDecorator {
+	return graphReplyBinding("ws-ack", ackNode, opts, "GraphWsAck");
+}
+
+/** D488 WebSocket reply egress decorator over an existing reply-correlated node. */
+export function GraphWsReply<TPayload = unknown>(
+	replyNode: Node<NestReplyEnvelope<TPayload>>,
+	opts: { readonly bindingId: string; readonly order?: number },
+): GraphMethodDecorator {
+	return graphReplyBinding("ws-reply", replyNode, opts, "GraphWsReply");
+}
+
+/** D488 microservice/message reply egress decorator over an existing reply-correlated node. */
+export function GraphMessageReply<TPayload = unknown>(
+	replyNode: Node<NestReplyEnvelope<TPayload>>,
+	opts: { readonly bindingId: string; readonly order?: number },
+): GraphMethodDecorator {
+	return graphReplyBinding("message-reply", replyNode, opts, "GraphMessageReply");
+}
+
+export function createNestGraphBoundaryRunner(
+	opts: NestGraphBoundaryRunnerOptions = {},
+): NestGraphBoundaryRunner {
+	const httpBoundaries = new Map<
+		Node<NestReplyEnvelope<unknown>>,
+		Map<string, NestHttpBoundary<unknown>>
+	>();
+	const httpBoundaryFor = (
+		node: Node<NestReplyEnvelope<unknown>>,
+		bindingId: string,
+	): NestHttpBoundary<unknown> => {
+		let byBinding = httpBoundaries.get(node);
+		if (byBinding === undefined) {
+			byBinding = new Map();
+			httpBoundaries.set(node, byBinding);
+		}
+		let boundary = byBinding.get(bindingId);
+		if (boundary === undefined) {
+			boundary = toNestHttp(node, {
+				bindingId,
+				diagnosticBoundary: opts.diagnosticBoundary,
+				diagnosticPhase: opts.diagnosticPhase ?? "http",
+			});
+			byBinding.set(bindingId, boundary);
+		}
+		return boundary;
+	};
+
+	return {
+		run(target, methodKey, host, opts = {}) {
+			const ctor = typeof target === "function" ? target : target.constructor;
+			const bindings = getNestBoundaryBindings(ctor as DecoratorHostConstructor, methodKey);
+			if (bindings.length === 0) return undefined;
+			const requestId = requestIdFromRunOptions(host, opts);
+			const replies = bindings.filter(isHttpReplyBinding);
+			const ingress = bindings.filter(
+				(binding): binding is NestIngressBindingMeta =>
+					binding.direction === "ingress" &&
+					(binding.kind === "request" || binding.kind === "interceptor"),
+			);
+			if (replies.length > 0 && ingress.length === 0) {
+				throw new Error("Nest GraphHttpReply requires at least one ingress boundary");
+			}
+			const ingressEmits = ingress.map((binding) => ({
+				binding,
+				requestId: requestIdFromBinding(host, binding) ?? requestId,
+			}));
+			const replyRequestIds = uniqueDefinedStrings(ingressEmits.map((entry) => entry.requestId));
+			if (replies.length > 0 && replyRequestIds.length === 0) {
+				throw new Error("Nest GraphHttpReply requires a stable requestId");
+			}
+			const cleanups: Array<() => boolean> = [];
+			let resolveReply: ((value: unknown) => void) | undefined;
+			let rejectReply: ((reason?: unknown) => void) | undefined;
+			const replyPromise =
+				replies.length === 0
+					? undefined
+					: new Promise<unknown>((resolve, reject) => {
+							resolveReply = resolve;
+							rejectReply = reject;
+						});
+			try {
+				for (const reply of replies) {
+					const http = httpBoundaryFor(reply.replyNode, reply.bindingId);
+					for (const replyRequestId of replyRequestIds) {
+						cleanups.push(
+							http.attach({
+								requestId: replyRequestId,
+								bindingId: reply.bindingId,
+								handle: {
+									resolve: resolveReply ?? (() => undefined),
+									reject: rejectReply ?? (() => undefined),
+								},
+							}),
+						);
+					}
+				}
+				for (const entry of ingressEmits) {
+					entry.binding.boundary.emit(host, {
+						bindingId: entry.binding.bindingId,
+						requestId: entry.requestId,
+						...bindingPayloadEmitOption(host, entry.binding),
+						requireRequestId: requiresRequestId(entry.binding.kind),
+					});
+				}
+			} catch (error) {
+				for (const cleanup of cleanups) cleanup();
+				throw error;
+			}
+			return replyPromise?.finally(() => {
+				for (const cleanup of cleanups) cleanup();
+			});
+		},
+		dispose() {
+			for (const byBinding of httpBoundaries.values()) {
+				for (const boundary of byBinding.values()) boundary.dispose();
+			}
+			httpBoundaries.clear();
+		},
+	};
+}
+
+export function createNestGraphBoundaryInterceptor<THost = unknown>(
+	opts: NestGraphBoundaryInterceptorOptions<THost> = {},
+): NestGraphBoundaryInterceptor {
+	const runner = opts.runner ?? createNestGraphBoundaryRunner(opts);
+	let nextRequestSeq = 1;
+	return {
+		intercept(context, next) {
+			const ctor = context.getClass();
+			const handler = context.getHandler();
+			const methodKey = methodKeyForHandler(ctor, handler);
+			if (methodKey === undefined) return next?.handle();
+			const bindings = getNestBoundaryBindings(ctor, methodKey);
+			const needsSyntheticRequestId = bindings.some(
+				(binding) =>
+					binding.direction === "egress" ||
+					(binding.direction === "ingress" && requiresRequestId(binding.kind)),
+			);
+			const host =
+				opts.host?.(context) ??
+				(defaultNestHttpHost(context, () => nextRequestSeq++, needsSyntheticRequestId) as THost) ??
+				({} as THost);
+			const result = runner.run(ctor, methodKey, host, opts);
+			return result ?? next?.handle();
+		},
+		dispose() {
+			runner.dispose();
+		},
+	};
+}
+
+export function getNestBoundaryBindings(
+	target: DecoratorHostConstructor | object,
+	methodKey?: string | symbol,
+): readonly NestBoundaryBindingMeta[] {
+	const ctor =
+		typeof target === "function"
+			? (target as DecoratorHostConstructor)
+			: ((target as { constructor: DecoratorHostConstructor })
+					.constructor as DecoratorHostConstructor);
+	const bindings = boundaryBindingsFor(ctor);
+	return sortBoundaryBindings(
+		methodKey === undefined
+			? bindings
+			: bindings.filter((binding) => binding.methodKey === methodKey),
+	);
+}
+
+export function resolveNestMethodKey(
+	ctor: DecoratorHostConstructor,
+	handler: DecoratorBoundMethod,
+): string | symbol | undefined {
+	return methodKeyForHandler(ctor, handler);
+}
+
+export function bindingRequestId<THost>(
+	host: THost,
+	binding: NestBoundaryBindingMeta,
+	fallback?: string | ((host: THost) => string | undefined),
+): string | undefined {
+	if (binding.direction === "ingress") {
+		const requestId = requestIdFromBinding(host, binding);
+		if (requestId !== undefined) return requestId;
+	}
+	if (typeof fallback === "string") {
+		assertNonEmptyString(fallback, "requestId");
+		return fallback;
+	}
+	if (typeof fallback === "function") {
+		const requestId = fallback(host);
+		if (requestId !== undefined) assertNonEmptyString(requestId, "requestId");
+		return requestId;
+	}
+	return requestIdOf(host, {}, {});
+}
+
+export function bindingEmitOptions<THost>(
+	host: THost,
+	binding: NestIngressBindingMeta,
+	requestId?: string,
+): NestIngressEmitOptions<unknown> {
+	return {
+		bindingId: binding.bindingId,
+		requestId,
+		...bindingPayloadEmitOption(host, binding),
+		requireRequestId: requiresRequestId(binding.kind),
+	};
+}
+
+export function isDataIssue(value: unknown): value is DataIssue {
+	return (
+		value !== null &&
+		typeof value === "object" &&
+		(value as { kind?: unknown }).kind === "issue" &&
+		typeof (value as { code?: unknown }).code === "string" &&
+		typeof (value as { message?: unknown }).message === "string"
+	);
+}
+
+export function isHttpDataIssue(value: unknown): value is HttpDataIssue {
+	return isDataIssue(value) && Number.isInteger((value as { status?: unknown }).status);
+}
+
+export function issueResponse<THost = unknown>(
+	issue: DataIssue,
+	_host?: THost,
+): NestHttpResponsePayload {
+	if (isHttpDataIssue(issue)) {
+		return {
+			status: issue.status,
+			body: issue.body ?? { code: issue.code, message: issue.message },
+			headers: issue.headers,
+		};
+	}
+	return {
+		status: 400,
+		body: { code: issue.code, message: issue.message },
+	};
+}
+
+export function protocolError<THost = unknown>(
+	_errorPayload: unknown,
+	_host?: THost,
+): NestHttpResponsePayload {
+	return {
+		status: 500,
+		body: { code: "graphrefly.protocol_error", message: "GraphReFly reply pipeline failed" },
+	};
+}
+
+export function lowerHttpReplyPayload<THost = unknown>(
+	payload: unknown,
+	host: THost,
+	opts: { readonly issueResponse?: NestIssueResponse<THost> } = {},
+): NestHttpResponsePayload {
+	if (isHttpResponsePayload(payload)) return payload;
+	if (isDataIssue(payload)) return (opts.issueResponse ?? issueResponse)(payload, host);
+	return { status: 200, body: payload };
+}
+
+export function lowerProtocolError<THost = unknown>(
+	errorPayload: unknown,
+	host: THost,
+	opts: { readonly protocolError?: NestProtocolErrorResponse<THost> } = {},
+): NestHttpResponsePayload {
+	return (opts.protocolError ?? protocolError)(errorPayload, host);
+}
+
+export function sanitizeNestDiagnostic(
+	diagnostic: NestDiagnosticInput,
+	defaultPhase: NestDiagnosticPhase = "adapter",
+): NestDiagnosticPayload {
+	const payload: NestDiagnosticPayload = {
+		kind: diagnostic.kind,
+		phase: diagnostic.phase ?? defaultPhase,
+		message: diagnostic.message,
+		...optionalStringField("requestId", diagnostic.requestId),
+		...optionalStringField("bindingId", diagnostic.bindingId),
+		...optionalStringField("expectedBindingId", diagnostic.expectedBindingId),
+		...optionalDiagnosticError(diagnostic.error),
+	};
+	assertGraphVisibleData(payload, "NestDiagnosticPayload", NEST_BOUNDARY_PAYLOAD_MAX_BYTES);
+	return payload;
+}
+
+function nestIngress<THost, TPayload>(
+	graph: Graph,
+	kind: NestBoundaryKind,
+	opts: NestIngressOptions<THost, TPayload>,
+): NestIngressBoundary<THost, TPayload> {
+	const bindingId = stableBindingId(kind, opts);
+	const version = parseEnvelopeVersion(opts.version ?? NEST_BOUNDARY_ENVELOPE_VERSION, "version");
+	const maxPayloadBytes = payloadByteLimit(opts.maxPayloadBytes);
+	const node = graph.node<NestBoundaryEnvelope<TPayload>>([], null, {
+		name: opts.name,
+		meta: { adapter: "nestjs", boundary: "ingress", kind, bindingId, version },
+	});
+
+	return {
+		kind,
+		bindingId,
+		version,
+		node,
+		envelope(host, emitOpts = {}) {
+			const requestId = requestIdOf(host, opts, {
+				...emitOpts,
+				requireRequestId:
+					emitOpts.requireRequestId ?? opts.requireRequestId ?? requiresRequestId(kind),
+			});
+			const envelopeBindingId = emitOpts.bindingId ?? bindingId;
+			assertNonEmptyString(envelopeBindingId, "NestBoundaryEnvelope.bindingId");
+			const envelopeVersion = parseEnvelopeVersion(
+				emitOpts.version ?? version,
+				"NestBoundaryEnvelope.version",
+			);
+			const payload =
+				"payload" in emitOpts
+					? (emitOpts.payload as TPayload)
+					: opts.payload !== undefined
+						? opts.payload(host)
+						: (host as unknown as TPayload);
+			assertGraphVisibleData(payload, "NestBoundaryEnvelope.payload", maxPayloadBytes);
+			const envelope: NestBoundaryEnvelope<TPayload> = {
+				bindingId: envelopeBindingId,
+				version: envelopeVersion,
+				payload,
+			};
+			return requestId === undefined ? envelope : { ...envelope, requestId };
+		},
+		emit(host, emitOpts = {}) {
+			const envelope = this.envelope(host, emitOpts);
+			node.down([["DATA", envelope]]);
+			return envelope;
+		},
+	};
+}
+
+function stableBindingId(
+	kind: NestBoundaryKind | NestEgressKind,
+	opts: { readonly bindingId?: string; readonly name?: string },
+): string {
+	const bindingId = opts.bindingId ?? opts.name ?? `nestjs.${kind}`;
+	assertNonEmptyString(bindingId, "bindingId");
+	return bindingId;
+}
+
+function requiresRequestId(kind: NestBoundaryKind): boolean {
+	return kind === "request" || kind === "guard" || kind === "interceptor" || kind === "error";
+}
+
+function requestIdFromRunOptions<THost>(
+	host: THost,
+	opts: NestGraphRunOptions<THost>,
+): string | undefined {
+	if (typeof opts.requestId === "string") {
+		assertNonEmptyString(opts.requestId, "requestId");
+		return opts.requestId;
+	}
+	if (typeof opts.requestId === "function") {
+		const requestId = opts.requestId(host);
+		if (requestId !== undefined) assertNonEmptyString(requestId, "requestId");
+		return requestId;
+	}
+	return requestIdOf(host, {}, {});
+}
+
+function requestIdFromBinding<THost>(
+	host: THost,
+	binding: NestIngressBindingMeta,
+): string | undefined {
+	if (typeof binding.requestId === "string") {
+		assertNonEmptyString(binding.requestId, "requestId");
+		return binding.requestId;
+	}
+	if (typeof binding.requestId === "function") {
+		const requestId = binding.requestId(host);
+		if (requestId !== undefined) assertNonEmptyString(requestId, "requestId");
+		return requestId;
+	}
+	return undefined;
+}
+
+function bindingPayloadEmitOption<THost>(
+	host: THost,
+	binding: NestIngressBindingMeta,
+): { readonly payload: unknown } | Record<string, never> {
+	return binding.payload === undefined ? {} : { payload: binding.payload(host) };
+}
+
+function isHttpResponsePayload(value: unknown): value is NestHttpResponsePayload {
+	if (value === null || typeof value !== "object") return false;
+	const status = (value as { status?: unknown }).status;
+	if (!Number.isInteger(status)) return false;
+	const headers = (value as { headers?: unknown }).headers;
+	return headers === undefined || isStringRecord(headers);
+}
+
+function isStringRecord(value: unknown): value is Record<string, string> {
+	if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
+	for (const entry of Object.values(value)) if (typeof entry !== "string") return false;
+	return true;
+}
+
+function isHttpReplyBinding(binding: NestBoundaryBindingMeta): binding is NestHttpReplyBindingMeta {
+	return binding.direction === "egress" && binding.kind === "http";
+}
+
+function uniqueDefinedStrings(values: readonly (string | undefined)[]): string[] {
+	const seen = new Set<string>();
+	for (const value of values) {
+		if (value !== undefined) seen.add(value);
+	}
+	return [...seen];
+}
+
+function defaultNestHttpHost(
+	context: NestExecutionContextLike,
+	nextSeq: () => number,
+	needsSyntheticRequestId: boolean,
+): unknown | undefined {
+	const request = context.switchToHttp?.().getRequest<Record<string, unknown>>();
+	if (request === undefined || request === null || typeof request !== "object") return request;
+	if (requestIdFromRecord(request) !== undefined) return request;
+	const headerId = requestIdFromHeaders(request.headers);
+	if (headerId !== undefined || needsSyntheticRequestId) {
+		return { ...request, requestId: headerId ?? `nestjs-request:${nextSeq()}` };
+	}
+	return request;
+}
+
+function requestIdFromRecord(record: Record<string, unknown>): string | undefined {
+	for (const key of ["requestId", "id"]) {
+		const value = record[key];
+		if (typeof value === "string" && value.length > 0) return value;
+	}
+	return undefined;
+}
+
+function requestIdFromHeaders(headers: unknown): string | undefined {
+	if (headers === null || typeof headers !== "object") return undefined;
+	for (const key of ["x-request-id", "x-correlation-id"]) {
+		const value = (headers as Record<string, unknown>)[key];
+		const first = Array.isArray(value) ? value[0] : value;
+		if (typeof first === "string" && first.trim().length > 0) return first.trim();
+	}
+	return undefined;
+}
+
+function graphIngressBinding<THost, TPayload>(
+	kind: NestBoundaryKind,
+	boundary: NestIngressBoundary<THost, TPayload>,
+	opts: NestBoundaryDecoratorOptions<THost, TPayload> & NestFilterDecoratorOptions<THost, TPayload>,
+): GraphMethodDecorator {
+	if (boundary.kind !== kind) {
+		throw new Error(`Graph${kind} expected a ${kind} boundary, got ${boundary.kind}`);
+	}
+	const bindingId = opts.bindingId ?? boundary.bindingId;
+	assertNonEmptyString(bindingId, "bindingId");
+	return registerMeta(NEST_BOUNDARY_BINDINGS, (methodKey) => ({
+		direction: "ingress" as const,
+		kind,
+		bindingId,
+		methodKey,
+		boundary: boundary as NestIngressBoundary<unknown, unknown>,
+		payload: opts.payload as ((host: unknown) => unknown) | undefined,
+		requestId: opts.requestId as string | ((host: unknown) => string | undefined) | undefined,
+		order: opts.order,
+		mode: opts.mode,
+		issueResponse: opts.issueResponse as NestIssueResponse<unknown> | undefined,
+		protocolError: opts.protocolError as NestProtocolErrorResponse<unknown> | undefined,
+	}));
+}
+
+function graphReplyBinding<TPayload>(
+	kind: "ws-ack" | "ws-reply" | "message-reply",
+	node: Node<NestReplyEnvelope<TPayload>>,
+	opts: { readonly bindingId: string; readonly order?: number },
+	decoratorName: string,
+): GraphMethodDecorator {
+	const bindingId = opts?.bindingId;
+	if (typeof bindingId !== "string" || bindingId.length === 0) {
+		throw new Error(`${decoratorName} requires a non-empty bindingId`);
+	}
+	const replyNode = node as Node<NestReplyEnvelope<unknown>>;
+	return registerMeta(NEST_BOUNDARY_BINDINGS, (methodKey) => {
+		if (kind === "ws-ack") {
+			return {
+				direction: "egress" as const,
+				kind,
+				bindingId,
+				methodKey,
+				ackNode: replyNode,
+				order: opts.order,
+			};
+		}
+		return {
+			direction: "egress" as const,
+			kind,
+			bindingId,
+			methodKey,
+			replyNode,
+			order: opts.order,
+		};
+	});
+}
+
+function methodKeyForHandler(
+	ctor: DecoratorHostConstructor,
+	handler: DecoratorBoundMethod,
+): string | symbol | undefined {
+	for (const binding of boundaryBindingsFor(ctor)) {
+		const candidate = methodOnPrototypeChain(ctor, binding.methodKey);
+		if (candidate === handler || String(binding.methodKey) === handler.name)
+			return binding.methodKey;
+	}
+	return undefined;
+}
+
+function boundaryBindingsFor(ctor: DecoratorHostConstructor): NestBoundaryBindingMeta[] {
+	const bindings: NestBoundaryBindingMeta[] = [];
+	const seen = new Set<NestBoundaryBindingMeta>();
+	let current: unknown = ctor;
+	while (typeof current === "function" && current !== Function.prototype) {
+		for (const binding of NEST_BOUNDARY_BINDINGS.get(current as DecoratorHostConstructor) ?? []) {
+			if (seen.has(binding)) continue;
+			seen.add(binding);
+			bindings.push(binding);
+		}
+		current = Object.getPrototypeOf(current);
+	}
+	return bindings;
+}
+
+function sortBoundaryBindings(
+	bindings: readonly NestBoundaryBindingMeta[],
+): readonly NestBoundaryBindingMeta[] {
+	return bindings
+		.map((binding, index) => ({ binding, index }))
+		.sort((a, b) => (a.binding.order ?? 0) - (b.binding.order ?? 0) || a.index - b.index)
+		.map(({ binding }) => binding);
+}
+
+function methodOnPrototypeChain(
+	ctor: DecoratorHostConstructor,
+	methodKey: string | symbol,
+): unknown {
+	let proto: unknown = ctor.prototype;
+	while (proto !== null && typeof proto === "object") {
+		if (Object.hasOwn(proto, methodKey)) {
+			return (proto as Record<string | symbol, unknown>)[methodKey];
+		}
+		proto = Object.getPrototypeOf(proto);
+	}
+	return undefined;
+}
+
+function requestIdOf<THost, TPayload>(
+	host: THost,
+	opts: NestIngressOptions<THost, TPayload>,
+	emitOpts: NestIngressEmitOptions<TPayload>,
+): string | undefined {
+	const fromEmit = emitOpts.requestId;
+	if (fromEmit !== undefined) {
+		assertNonEmptyString(fromEmit, "requestId");
+		return fromEmit;
+	}
+	if (typeof opts.requestId === "string") {
+		assertNonEmptyString(opts.requestId, "requestId");
+		return opts.requestId;
+	}
+	if (typeof opts.requestId === "function") {
+		const requestId = opts.requestId(host);
+		if (requestId !== undefined) assertNonEmptyString(requestId, "requestId");
+		return requestId;
+	}
+	const record = host as { requestId?: unknown; id?: unknown };
+	if (typeof record?.requestId === "string" && record.requestId.length > 0) return record.requestId;
+	if (typeof record?.id === "string" && record.id.length > 0) return record.id;
+	if (emitOpts.requireRequestId ?? opts.requireRequestId ?? false) {
+		throw new Error("Nest boundary ingress requires a stable requestId");
+	}
+	return undefined;
+}
+
+function validateEnvelope(value: unknown, maxPayloadBytes: number): string | undefined {
+	try {
+		assertGraphVisibleData(value, "NestBoundaryEnvelope", maxPayloadBytes);
+	} catch (error) {
+		return error instanceof Error ? error.message : "egress envelope must be data-only material";
+	}
+	if (value === null || typeof value !== "object") return "egress DATA is not an envelope object";
+	const envelope = value as Partial<NestBoundaryEnvelope>;
+	if (typeof envelope.requestId !== "string" || envelope.requestId.length === 0) {
+		return "egress envelope requestId must be a non-empty string";
+	}
+	if (typeof envelope.bindingId !== "string" || envelope.bindingId.length === 0) {
+		return "egress envelope bindingId must be a non-empty string";
+	}
+	try {
+		parseEnvelopeVersion(envelope.version, "egress envelope version");
+	} catch {
+		return `egress envelope version must be ${NEST_BOUNDARY_ENVELOPE_VERSION}`;
+	}
+	return undefined;
+}
+
+function malformedCorrelation(
+	value: unknown,
+	scopedBindingId: string | undefined,
+): { readonly requestId: string; readonly bindingId: string } | undefined {
+	if (value === null || typeof value !== "object") return undefined;
+	const requestId = (value as { readonly requestId?: unknown }).requestId;
+	const bindingId = (value as { readonly bindingId?: unknown }).bindingId;
+	if (typeof requestId !== "string" || requestId.length === 0) return undefined;
+	if (typeof bindingId !== "string" || bindingId.length === 0) return undefined;
+	if (scopedBindingId !== undefined && bindingId !== scopedBindingId) return undefined;
+	return { requestId, bindingId };
+}
+
+function parseEnvelopeVersion(value: unknown, label: string): number {
+	if (value !== NEST_BOUNDARY_ENVELOPE_VERSION) {
+		throw new Error(`${label} must be ${NEST_BOUNDARY_ENVELOPE_VERSION}`);
+	}
+	return value;
+}
+
+function assertNonEmptyString(value: string, label: string): void {
+	if (value.length === 0) throw new Error(`${label} must be a non-empty string`);
+}
+
+function optionalStringField<K extends "requestId" | "bindingId" | "expectedBindingId">(
+	key: K,
+	value: string | undefined,
+): Record<K, string> | Record<string, never> {
+	return value === undefined ? {} : ({ [key]: value } as Record<K, string>);
+}
+
+function optionalDiagnosticError(
+	error: unknown,
+): { readonly error: NestDiagnosticErrorPayload } | Record<string, never> {
+	const summarized = summarizeDiagnosticError(error);
+	return summarized === undefined ? {} : { error: summarized };
+}
+
+function summarizeDiagnosticError(error: unknown): NestDiagnosticErrorPayload | undefined {
+	if (error === undefined) return undefined;
+	if (error instanceof Error) {
+		return {
+			...optionalDiagnosticName(safeDiagnosticString(() => error.name)),
+			message: safeDiagnosticString(() => error.message) ?? "diagnostic error",
+		};
+	}
+	if (typeof error === "string") return { message: error };
+	if (typeof error === "number" || typeof error === "boolean" || typeof error === "bigint") {
+		return { message: String(error) };
+	}
+	if (typeof error === "symbol") return { message: error.description ?? "symbol" };
+	if (typeof error === "function") return { message: "opaque diagnostic function" };
+	if (error !== null && typeof error === "object") {
+		const record = error as { readonly name?: unknown; readonly message?: unknown };
+		const message = safeDiagnosticString(() => record.message);
+		if (message !== undefined) {
+			return {
+				...optionalDiagnosticName(safeDiagnosticString(() => record.name)),
+				message,
+			};
+		}
+		return { message: "opaque diagnostic error" };
+	}
+	return { message: String(error) };
+}
+
+function safeDiagnosticString(read: () => unknown): string | undefined {
+	try {
+		const value = read();
+		return typeof value === "string" ? value : undefined;
+	} catch {
+		return undefined;
+	}
+}
+
+function optionalDiagnosticName(
+	name: string | undefined,
+): { readonly name: string } | Record<string, never> {
+	return name === undefined || name.length === 0 ? {} : { name };
+}
+
+function payloadByteLimit(value: number | undefined): number {
+	if (value === undefined) return NEST_BOUNDARY_PAYLOAD_MAX_BYTES;
+	if (!Number.isSafeInteger(value) || value < 1) {
+		throw new Error("Nest boundary maxPayloadBytes must be a positive safe integer");
+	}
+	return value;
+}
+
+function diagnosticsRetainedLimit(value: number | undefined): number {
+	if (value === undefined) return NEST_HTTP_DIAGNOSTICS_MAX_RETAINED;
+	if (!Number.isSafeInteger(value) || value < 0) {
+		throw new Error("toNestHttp maxDiagnostics must be a non-negative safe integer");
+	}
+	return value;
+}
+
+function pushDiagnostic(
+	diagnostics: NestBoundaryDiagnostic[],
+	diagnostic: NestBoundaryDiagnostic,
+	maxDiagnostics: number,
+): void {
+	if (maxDiagnostics === 0) return;
+	diagnostics.push(diagnostic);
+	if (diagnostics.length > maxDiagnostics)
+		diagnostics.splice(0, diagnostics.length - maxDiagnostics);
+}
+
+function assertGraphVisibleData(
+	value: unknown,
+	path: string,
+	maxPayloadBytes: number,
+	seen = new WeakSet<object>(),
+): void {
+	if (value === undefined) {
+		throw new TypeError(`${path} cannot be undefined; undefined is SENTINEL/no DATA`);
+	}
+	if (value === null) return;
+	const type = typeof value;
+	if (type === "string" || type === "boolean") return;
+	if (type === "number") {
+		if (!Number.isFinite(value)) throw new TypeError(`${path} number must be finite`);
+		return;
+	}
+	if (type === "function" || type === "symbol" || type === "bigint") {
+		throw new TypeError(`${path} must be data-only; found ${type}`);
+	}
+	if (type !== "object") return;
+	if (seen.has(value as object)) throw new TypeError(`${path} must be acyclic data`);
+	seen.add(value as object);
+	if (Array.isArray(value)) {
+		try {
+			for (let i = 0; i < value.length; i += 1) {
+				const descriptor = Object.getOwnPropertyDescriptor(value, i);
+				if (descriptor === undefined) {
+					throw new TypeError(`${path}[${i}] cannot be a sparse array hole`);
+				}
+				if (!descriptor.enumerable || !("value" in descriptor)) {
+					throw new TypeError(`${path}[${i}] must be enumerable plain data`);
+				}
+				assertGraphVisibleData(descriptor.value, `${path}[${i}]`, maxPayloadBytes, seen);
+			}
+			for (const key of Reflect.ownKeys(value)) {
+				if (key === "length") continue;
+				if (typeof key === "symbol" || !/^(0|[1-9]\d*)$/.test(key)) {
+					throw new TypeError(`${path} arrays must not carry hidden or extra properties`);
+				}
+			}
+			assertPayloadSize(value, path, maxPayloadBytes);
+		} finally {
+			seen.delete(value as object);
+		}
+		return;
+	}
+	const proto = Object.getPrototypeOf(value);
+	if (proto !== Object.prototype && proto !== null) {
+		throw new TypeError(`${path} must be a plain data object or array`);
+	}
+	try {
+		for (const key of Reflect.ownKeys(value)) {
+			if (typeof key === "symbol") throw new TypeError(`${path} must not carry symbol keys`);
+			const descriptor = Object.getOwnPropertyDescriptor(value, key);
+			if (descriptor === undefined) continue;
+			if (!descriptor.enumerable || !("value" in descriptor)) {
+				throw new TypeError(`${path}.${key} must be enumerable plain data`);
+			}
+			assertGraphVisibleData(descriptor.value, `${path}.${key}`, maxPayloadBytes, seen);
+		}
+		assertPayloadSize(value, path, maxPayloadBytes);
+	} finally {
+		seen.delete(value as object);
+	}
+}
+
+function assertPayloadSize(value: unknown, path: string, maxPayloadBytes: number): void {
+	const serialized = JSON.stringify(value);
+	if (serialized !== undefined && utf8ByteLength(serialized) > maxPayloadBytes) {
+		throw new TypeError(`${path} exceeds ${maxPayloadBytes} bytes`);
+	}
+}
+
+function utf8ByteLength(value: string): number {
+	let bytes = 0;
+	for (let i = 0; i < value.length; i += 1) {
+		const code = value.charCodeAt(i);
+		if (code < 0x80) {
+			bytes += 1;
+		} else if (code < 0x800) {
+			bytes += 2;
+		} else if (code >= 0xd800 && code <= 0xdbff && i + 1 < value.length) {
+			const next = value.charCodeAt(i + 1);
+			if (next >= 0xdc00 && next <= 0xdfff) {
+				bytes += 4;
+				i += 1;
+			} else {
+				bytes += 3;
+			}
+		} else {
+			bytes += 3;
+		}
+	}
+	return bytes;
+}
+
+function sameMeta<T>(a: T, b: T): boolean {
+	const left = a as Record<string | symbol, unknown>;
+	const right = b as Record<string | symbol, unknown>;
+	const keys = Reflect.ownKeys(left);
+	if (keys.length !== Reflect.ownKeys(right).length) return false;
+	for (const key of keys) {
+		if (!Object.is(left[key], right[key])) return false;
+	}
+	return true;
+}
+
+function pushUniqueMeta<T>(
+	registry: WeakMap<DecoratorHostConstructor, T[]>,
+	ctor: DecoratorHostConstructor,
+	item: T,
+): void {
+	const existing = registry.get(ctor) ?? [];
+	if (existing.some((current) => sameMeta(current, item))) return;
+	registry.set(ctor, [...existing, item]);
+}
+
+function registerMeta<T>(
+	registry: WeakMap<DecoratorHostConstructor, T[]>,
+	meta: (methodKey: string | symbol) => T,
+): GraphMethodDecorator {
+	return ((targetOrValue: object, contextOrKey: ClassMethodDecoratorContext | string | symbol) => {
+		if (typeof contextOrKey === "object" && contextOrKey !== null) {
+			const methodKey = contextOrKey.name;
+			contextOrKey.addInitializer(function (this: unknown) {
+				const ctor = (this as { constructor: DecoratorHostConstructor }).constructor;
+				pushUniqueMeta(registry, ctor, meta(methodKey));
+			});
+			return;
+		}
+
+		const ctor = (targetOrValue as { constructor: DecoratorHostConstructor }).constructor;
+		pushUniqueMeta(registry, ctor, meta(contextOrKey));
+	}) as GraphMethodDecorator;
+}
+
+/** Register a method as a DATA-event handler for a graph observe path. */
+export function OnGraphEvent(nodeName: string): GraphMethodDecorator {
+	return registerMeta(EVENT_HANDLERS, (methodKey) => ({ nodeName, methodKey }));
+}
+
+/** Register fixed-interval metadata for a user-land NestJS scheduler bridge. */
+export function GraphInterval(ms: number): GraphMethodDecorator {
+	return registerMeta(INTERVAL_HANDLERS, (methodKey) => ({ ms, methodKey }));
+}
diff --git a/packages/ts/src/adapters/nestjs/microservices.ts b/packages/ts/src/adapters/nestjs/microservices.ts
new file mode 100644
index 00000000..fc98b41e
--- /dev/null
+++ b/packages/ts/src/adapters/nestjs/microservices.ts
@@ -0,0 +1,292 @@
+/**
+ * NestJS microservice/message native phase bridge (D488).
+ *
+ * This focused subpath may import `@nestjs/microservices`; the dependency-light
+ * structural layer and HTTP native bridge stay free of that optional peer.
+ */
+
+import type { CustomTransportStrategy } from "@nestjs/microservices";
+import {
+	bindingEmitOptions,
+	bindingRequestId,
+	type DecoratorHostConstructor,
+	fromNestMessage,
+	GraphMessage,
+	GraphMessageReply,
+	getNestBoundaryBindings,
+	type NestBoundaryBindingMeta,
+	type NestBoundaryDiagnostic,
+	type NestBoundaryEnvelope,
+	type NestDiagnosticIngressBoundary,
+	type NestGraphRunOptions,
+	type NestIngressBindingMeta,
+	type NestIngressBoundary,
+	type NestIngressEmitOptions,
+	type NestIngressOptions,
+	type NestMessageReplyBindingMeta,
+	type NestProviderBinding,
+	type NestReplyEnvelope,
+	type NestReplyResponseHandle,
+	sanitizeNestDiagnostic,
+	toNestHttp,
+} from "../nestjs.js";
+
+/** D488 provider token for the focused Nest microservice/message native bridge. */
+export const GRAPHREFLY_NEST_MESSAGE_BRIDGE = Symbol.for("graphrefly:nest:message-bridge");
+
+/** Options for the D488 Nest message bridge; transport contexts stay host-private. */
+export interface GraphMessageBridgeOptions<THost = unknown> extends NestGraphRunOptions<THost> {
+	readonly diagnosticBoundary?: NestDiagnosticIngressBoundary;
+	readonly timeoutMs?: number;
+	readonly maxDiagnostics?: number;
+}
+
+/** D495 focused microservice/message provider bundle options. */
+export interface GraphMessageProviderBundleOptions<THost = unknown> {
+	readonly bridge?: GraphMessageBridgeOptions<THost> | false;
+}
+
+/** Explicit Nest message-pattern phase bridge over `GraphMessage` and `GraphMessageReply` metadata. */
+export interface GraphMessageBridge<THost = unknown>
+	extends Pick<CustomTransportStrategy, "close"> {
+	handleMessage(
+		target: DecoratorHostConstructor | object,
+		methodKey: string | symbol,
+		host: THost,
+		opts?: NestGraphRunOptions<THost>,
+	): Promise<unknown> | undefined;
+	onModuleDestroy(): void;
+	diagnostics(): readonly NestBoundaryDiagnostic[];
+	dispose(): void;
+}
+
+type MessageBoundary = ReturnType<typeof toNestHttp<unknown>>;
+
+/** Build a dependency-light Nest provider for the focused message bridge token. */
+export function provideGraphMessageBridge<THost = unknown>(
+	opts: GraphMessageBridgeOptions<THost> = {},
+): NestProviderBinding<GraphMessageBridge<THost>> {
+	return { provide: GRAPHREFLY_NEST_MESSAGE_BRIDGE, useValue: createGraphMessageBridge(opts) };
+}
+
+/** Build the D495 focused message provider bundle without adding a router or event bus. */
+export function provideGraphMessageProviders<THost = unknown>(
+	opts: GraphMessageProviderBundleOptions<THost> = {},
+): NestProviderBinding<GraphMessageBridge<THost>>[] {
+	return opts.bridge === false ? [] : [provideGraphMessageBridge(opts.bridge ?? {})];
+}
+
+/** Create a host-private message bridge instance without adding a router or event bus. */
+export function createGraphMessageBridge<THost = unknown>(
+	opts: GraphMessageBridgeOptions<THost> = {},
+): GraphMessageBridge<THost> {
+	return new GraphMessageBridgeImpl(opts);
+}
+
+class GraphMessageBridgeImpl<THost> implements GraphMessageBridge<THost> {
+	private readonly boundaries = new WeakMap<object, Map<string, MessageBoundary>>();
+	private readonly disposable = new Set<MessageBoundary>();
+	private readonly localDiagnostics: NestBoundaryDiagnostic[] = [];
+	private active = true;
+
+	constructor(private readonly opts: GraphMessageBridgeOptions<THost>) {}
+
+	close(): void {
+		this.dispose();
+	}
+
+	onModuleDestroy(): void {
+		this.dispose();
+	}
+
+	handleMessage(
+		target: DecoratorHostConstructor | object,
+		methodKey: string | symbol,
+		host: THost,
+		runOpts: NestGraphRunOptions<THost> = {},
+	): Promise<unknown> | undefined {
+		if (!this.active) throw new Error("GraphMessage native bridge is disposed");
+		const bindings = getNestBoundaryBindings(target, methodKey);
+		const ingress = bindings.filter(isMessageIngress);
+		if (ingress.length === 0) return undefined;
+		const replies = bindings.filter(isMessageReply);
+		const needsRequestId = replies.length > 0;
+		for (const binding of ingress) assertExplicitNativePayload(binding, "GraphMessage");
+		const ingressEmits = ingress.map((binding) => ({
+			binding,
+			requestId: bindingRequestId(host, binding, runOpts.requestId ?? this.opts.requestId),
+		}));
+		if (needsRequestId && ingressEmits.some((entry) => entry.requestId === undefined)) {
+			throw new Error("GraphMessage native bridge requires a stable requestId for reply egress");
+		}
+		const requestIds = uniqueDefinedStrings(ingressEmits.map((entry) => entry.requestId));
+		const cleanups: Array<() => boolean> = [];
+		let timeout: ReturnType<typeof setTimeout> | undefined;
+		let settled = false;
+		let resolvePromise: ((payload: unknown) => void) | undefined;
+		let rejectPromise: ((error: unknown) => void) | undefined;
+		let cleaned = false;
+		const cleanupAll = () => {
+			if (cleaned) return;
+			cleaned = true;
+			for (const cleanup of cleanups) cleanup();
+			this.clearTimeout(timeout);
+		};
+		const handle: NestReplyResponseHandle<unknown> = {
+			resolve(payload) {
+				if (settled) return;
+				settled = true;
+				resolvePromise?.(payload);
+			},
+			reject(error) {
+				if (settled) return;
+				settled = true;
+				rejectPromise?.(error);
+			},
+		};
+		const promise =
+			replies.length === 0
+				? undefined
+				: new Promise<unknown>((resolve, reject) => {
+						resolvePromise = resolve;
+						rejectPromise = reject;
+					});
+		if (promise !== undefined) {
+			try {
+				for (const requestId of requestIds) {
+					for (const reply of replies) {
+						cleanups.push(
+							this.boundaryFor(reply).attach({
+								requestId,
+								bindingId: reply.bindingId,
+								handle,
+							}),
+						);
+					}
+				}
+			} catch (error) {
+				cleanupAll();
+				handle.reject(error);
+				return promise;
+			}
+			if (settled) {
+				cleanupAll();
+				return promise;
+			}
+			if (this.opts.timeoutMs !== undefined) {
+				timeout = setTimeout(() => {
+					cleanupAll();
+					const error = new Error(
+						`GraphMessage native bridge timed out waiting for ${requestIds[0]}`,
+					);
+					this.diagnose({
+						kind: "timeout",
+						requestId: requestIds[0],
+						message: error.message,
+						error,
+					});
+					handle.reject(error);
+				}, this.opts.timeoutMs);
+			}
+		}
+		try {
+			for (const { binding, requestId } of ingressEmits) {
+				binding.boundary.emit(host, {
+					...bindingEmitOptions(host, binding, requestId),
+					requireRequestId: needsRequestId,
+				});
+			}
+		} catch (error) {
+			cleanupAll();
+			throw error;
+		}
+		return promise?.finally(() => {
+			cleanupAll();
+		});
+	}
+
+	diagnostics(): readonly NestBoundaryDiagnostic[] {
+		return [
+			...this.localDiagnostics,
+			...[...this.disposable].flatMap((boundary) => boundary.diagnostics()),
+		];
+	}
+
+	dispose(): void {
+		if (!this.active) return;
+		this.active = false;
+		for (const boundary of this.disposable) boundary.dispose();
+	}
+
+	private boundaryFor(binding: NestMessageReplyBindingMeta): MessageBoundary {
+		let byBinding = this.boundaries.get(binding.replyNode);
+		if (byBinding === undefined) {
+			byBinding = new Map();
+			this.boundaries.set(binding.replyNode, byBinding);
+		}
+		const existing = byBinding.get(binding.bindingId);
+		if (existing !== undefined) return existing;
+		const boundary = toNestHttp(binding.replyNode, {
+			bindingId: binding.bindingId,
+			diagnosticBoundary: this.opts.diagnosticBoundary,
+			diagnosticPhase: "message",
+			name: "nestjs.message-reply",
+			maxDiagnostics: this.opts.maxDiagnostics,
+		});
+		byBinding.set(binding.bindingId, boundary);
+		this.disposable.add(boundary);
+		return boundary;
+	}
+
+	private diagnose(diagnostic: NestBoundaryDiagnostic): void {
+		this.localDiagnostics.push(diagnostic);
+		try {
+			const phase = diagnostic.phase ?? "message";
+			const payload = sanitizeNestDiagnostic({ ...diagnostic, phase }, phase);
+			this.opts.diagnosticBoundary?.emit(payload, { payload });
+		} catch {
+			// Graph-visible diagnostics are optional and must not interrupt host cleanup.
+		}
+		if (
+			this.opts.maxDiagnostics !== undefined &&
+			this.localDiagnostics.length > this.opts.maxDiagnostics
+		) {
+			this.localDiagnostics.splice(0, this.localDiagnostics.length - this.opts.maxDiagnostics);
+		}
+	}
+
+	private clearTimeout(timeout: ReturnType<typeof setTimeout> | undefined): void {
+		if (timeout !== undefined) clearTimeout(timeout);
+	}
+}
+
+function isMessageIngress(binding: NestBoundaryBindingMeta): binding is NestIngressBindingMeta {
+	return binding.direction === "ingress" && binding.kind === "message";
+}
+
+function isMessageReply(binding: NestBoundaryBindingMeta): binding is NestMessageReplyBindingMeta {
+	return binding.direction === "egress" && binding.kind === "message-reply";
+}
+
+function assertExplicitNativePayload(binding: NestIngressBindingMeta, label: string): void {
+	if (binding.payload === undefined) {
+		throw new Error(`${label} native bridge requires an explicit payload selector`);
+	}
+}
+
+function uniqueDefinedStrings(values: readonly (string | undefined)[]): string[] {
+	const seen = new Set<string>();
+	for (const value of values) if (value !== undefined) seen.add(value);
+	return [...seen];
+}
+
+export {
+	fromNestMessage,
+	GraphMessage,
+	GraphMessageReply,
+	type NestBoundaryEnvelope,
+	type NestIngressBoundary,
+	type NestIngressEmitOptions,
+	type NestIngressOptions,
+	type NestReplyEnvelope,
+};
diff --git a/packages/ts/src/adapters/nestjs/native.ts b/packages/ts/src/adapters/nestjs/native.ts
new file mode 100644
index 00000000..ea46da60
--- /dev/null
+++ b/packages/ts/src/adapters/nestjs/native.ts
@@ -0,0 +1,818 @@
+/**
+ * Nest-native provider bridge for GraphReFly boundary metadata (D484).
+ *
+ * This focused subpath is allowed to import Nest/RxJS. The dependency-light
+ * `@graphrefly/ts/adapters/nestjs` structural layer stays Nest-free.
+ */
+
+import type {
+	ArgumentsHost,
+	CallHandler,
+	CanActivate,
+	ExceptionFilter,
+	ExecutionContext,
+	OnModuleDestroy,
+	OnModuleInit,
+	Provider,
+} from "@nestjs/common";
+import { Catch, HttpException, type NestInterceptor } from "@nestjs/common";
+import { APP_GUARD, APP_INTERCEPTOR } from "@nestjs/core";
+import { from, type Observable } from "rxjs";
+import {
+	type CronSchedule,
+	type FromCronOptions,
+	matchesCron,
+	parseCron,
+} from "../../graph/sources.js";
+import {
+	bindingEmitOptions,
+	bindingRequestId,
+	createNestGraphBoundaryRunner,
+	type DecoratorBoundMethod,
+	type DecoratorHostConstructor,
+	type GraphGuardDecision,
+	getNestBoundaryBindings,
+	isDataIssue,
+	lowerHttpReplyPayload,
+	lowerProtocolError,
+	type NestBoundaryBindingMeta,
+	type NestDiagnosticIngressBoundary,
+	type NestGraphRunOptions,
+	type NestHttpReplyBindingMeta,
+	type NestHttpResponsePayload,
+	type NestIngressBindingMeta,
+	type NestIssueResponse,
+	type NestProtocolErrorResponse,
+	protocolError,
+	resolveNestMethodKey,
+	toNestHttp,
+} from "../nestjs.js";
+
+export const GRAPHREFLY_NEST_CRON_SCHEDULER = Symbol.for("graphrefly:nest:cron-scheduler");
+export const GRAPHREFLY_NEST_EXCEPTION_FILTER = Symbol.for("graphrefly:nest:exception-filter");
+export const GRAPHREFLY_NEST_LIFECYCLE_HOOKS = Symbol.for("graphrefly:nest:lifecycle-hooks");
+
+export interface GraphNativeHostOptions<THost = unknown> extends NestGraphRunOptions<THost> {
+	readonly host?: (context: ExecutionContext) => THost;
+	readonly diagnosticBoundary?: NestDiagnosticIngressBoundary;
+}
+
+export interface GraphNativeHttpOptions<THost = unknown> extends GraphNativeHostOptions<THost> {
+	readonly issueResponse?: NestIssueResponse<THost>;
+	readonly protocolError?: NestProtocolErrorResponse<THost>;
+}
+
+export interface GraphExceptionFilterTarget {
+	readonly target: DecoratorHostConstructor | object;
+	readonly methodKey: string | symbol;
+}
+
+export interface GraphExceptionFilterProviderOptions<THost = unknown> {
+	readonly host?: (host: ArgumentsHost, exception: unknown) => THost;
+	readonly target: (
+		host: ArgumentsHost,
+		exception: unknown,
+	) => GraphExceptionFilterTarget | undefined;
+	readonly diagnosticBoundary?: NestDiagnosticIngressBoundary;
+	readonly requestId?: string | ((host: THost) => string | undefined);
+	readonly issueResponse?: NestIssueResponse<THost>;
+	readonly protocolError?: NestProtocolErrorResponse<THost>;
+}
+
+export interface GraphCronProviderTarget<THost = unknown> {
+	readonly target: DecoratorHostConstructor | object;
+	readonly methodKey?: string | symbol;
+	readonly expr: string;
+	readonly tickMs?: number;
+	readonly timezone?: string;
+	readonly dst?: FromCronOptions["dst"];
+	readonly host?: (date: Date) => THost;
+}
+
+export interface GraphCronSchedulerProviderOptions {
+	readonly targets: readonly GraphCronProviderTarget[];
+}
+
+export interface GraphCronController {
+	check(now: Date): void;
+}
+
+export interface GraphCronControllerOptions {
+	readonly targets: readonly GraphCronProviderTarget[];
+}
+
+export interface GraphLifecycleProviderTarget<THost = unknown> {
+	readonly target: DecoratorHostConstructor | object;
+	readonly methodKey?: string | symbol;
+	readonly event?: "module-init" | "module-destroy";
+	readonly host?: (event: "module-init" | "module-destroy") => THost;
+}
+
+export interface GraphLifecycleHooksProviderOptions {
+	readonly targets: readonly GraphLifecycleProviderTarget[];
+}
+
+export interface GraphNativeHttpProviderBundleOptions<THost = unknown> {
+	readonly boundaryInterceptor?: GraphNativeHttpOptions<THost> | false;
+	readonly guard?: GraphNativeHttpOptions<THost> | false;
+	readonly guardDeniedFilter?: boolean;
+	readonly exceptionFilter?: GraphExceptionFilterProviderOptions<THost>;
+}
+
+export interface GraphNativeProviderBundleOptions<THost = unknown> {
+	readonly http?: GraphNativeHttpProviderBundleOptions<THost> | false;
+	readonly cronScheduler?: GraphCronSchedulerProviderOptions;
+	readonly lifecycleHooks?: GraphLifecycleHooksProviderOptions;
+}
+
+export function provideGraphBoundaryInterceptor<THost = unknown>(
+	opts: GraphNativeHttpOptions<THost> = {},
+): Provider {
+	return { provide: APP_INTERCEPTOR, useValue: new GraphBoundaryInterceptorBridge(opts) };
+}
+
+export function provideGraphGuard<THost = unknown>(
+	opts: GraphNativeHttpOptions<THost> = {},
+): Provider {
+	return { provide: APP_GUARD, useValue: new GraphGuardBridge(opts) };
+}
+
+export function provideGraphExceptionFilter<THost = unknown>(
+	opts: GraphExceptionFilterProviderOptions<THost>,
+): Provider {
+	return { provide: GRAPHREFLY_NEST_EXCEPTION_FILTER, useValue: createGraphExceptionFilter(opts) };
+}
+
+export function createGraphExceptionFilter<THost = unknown>(
+	opts: GraphExceptionFilterProviderOptions<THost>,
+): ExceptionFilter & OnModuleDestroy {
+	return new GraphExceptionFilterBridge(opts);
+}
+
+export function provideGraphGuardDeniedFilter(): Provider {
+	return GraphGuardDeniedFilter;
+}
+
+export function createGraphGuardDeniedFilter(): ExceptionFilter {
+	return new GraphGuardDeniedFilter();
+}
+
+export function provideGraphCronScheduler(opts: GraphCronSchedulerProviderOptions): Provider {
+	return { provide: GRAPHREFLY_NEST_CRON_SCHEDULER, useValue: new GraphCronSchedulerBridge(opts) };
+}
+
+export function provideGraphLifecycleHooks(opts: GraphLifecycleHooksProviderOptions): Provider {
+	return {
+		provide: GRAPHREFLY_NEST_LIFECYCLE_HOOKS,
+		useValue: new GraphLifecycleHooksBridge(opts),
+	};
+}
+
+export function provideGraphNativeHttpProviders<THost = unknown>(
+	opts: GraphNativeHttpProviderBundleOptions<THost> = {},
+): Provider[] {
+	const providers: Provider[] = [];
+	if (opts.boundaryInterceptor !== false)
+		providers.push(provideGraphBoundaryInterceptor(opts.boundaryInterceptor ?? {}));
+	if (opts.guard !== false) providers.push(provideGraphGuard(opts.guard ?? {}));
+	if (opts.guardDeniedFilter ?? true) providers.push(provideGraphGuardDeniedFilter());
+	if (opts.exceptionFilter !== undefined)
+		providers.push(provideGraphExceptionFilter(opts.exceptionFilter));
+	return providers;
+}
+
+export function provideGraphNativeProviders<THost = unknown>(
+	opts: GraphNativeProviderBundleOptions<THost> = {},
+): Provider[] {
+	const providers: Provider[] = [];
+	if (opts.http !== false) providers.push(...provideGraphNativeHttpProviders(opts.http ?? {}));
+	if (opts.cronScheduler !== undefined)
+		providers.push(provideGraphCronScheduler(opts.cronScheduler));
+	if (opts.lifecycleHooks !== undefined)
+		providers.push(provideGraphLifecycleHooks(opts.lifecycleHooks));
+	return providers;
+}
+
+export function graphCronTarget<THost = unknown>(
+	target: DecoratorHostConstructor | object,
+	methodKey: string | symbol,
+	opts: Omit<GraphCronProviderTarget<THost>, "target" | "methodKey">,
+): GraphCronProviderTarget<THost> {
+	return { ...opts, target, methodKey };
+}
+
+export function graphLifecycleTarget<THost = unknown>(
+	target: DecoratorHostConstructor | object,
+	methodKey: string | symbol,
+	opts: Omit<GraphLifecycleProviderTarget<THost>, "target" | "methodKey"> = {},
+): GraphLifecycleProviderTarget<THost> {
+	return { ...opts, target, methodKey };
+}
+
+export function createGraphCronController(opts: GraphCronControllerOptions): GraphCronController {
+	return new GraphCronControllerImpl(opts);
+}
+
+class GraphBoundaryInterceptorBridge<THost> implements NestInterceptor, OnModuleDestroy {
+	private readonly runner: ReturnType<typeof createNestGraphBoundaryRunner>;
+
+	constructor(private readonly opts: GraphNativeHttpOptions<THost>) {
+		this.runner = createNestGraphBoundaryRunner({
+			diagnosticBoundary: opts.diagnosticBoundary,
+			diagnosticPhase: "http",
+		});
+	}
+
+	intercept(context: ExecutionContext, next: CallHandler): Observable<unknown> {
+		const host = this.opts.host?.(context) ?? (defaultHttpHost(context) as THost);
+		const result = this.runner.run(
+			context.getClass(),
+			methodKeyForContext(context),
+			host,
+			this.opts,
+		);
+		const reply = firstHttpReply(context);
+		const value =
+			result === undefined
+				? next.handle()
+				: Promise.resolve(result).then(
+						(payload) =>
+							writeHttpResponse(
+								context,
+								lowerHttpReplyPayload(payload, host, {
+									issueResponse: reply?.issueResponse ?? this.opts.issueResponse,
+								}),
+							),
+						(errorPayload) =>
+							writeHttpResponse(
+								context,
+								lowerProtocolError(errorPayload, host, {
+									protocolError: reply?.protocolError ?? this.opts.protocolError,
+								}),
+							),
+					);
+		return isObservableLike(value) ? value : from(Promise.resolve(value));
+	}
+
+	onModuleDestroy(): void {
+		this.runner.dispose();
+	}
+}
+
+class GraphGuardBridge<THost> implements CanActivate, OnModuleDestroy {
+	private readonly decisions = new WeakMap<
+		object,
+		Map<string, ReturnType<typeof toNestHttp<GraphGuardDecision>>>
+	>();
+	private readonly disposableDecisions = new Set<
+		ReturnType<typeof toNestHttp<GraphGuardDecision>>
+	>();
+
+	constructor(private readonly opts: GraphNativeHttpOptions<THost>) {}
+
+	async canActivate(context: ExecutionContext): Promise<boolean> {
+		const methodKey = methodKeyForContext(context);
+		const bindings = getNestBoundaryBindings(context.getClass(), methodKey);
+		const guards = bindings.filter(isGuardIngress);
+		if (guards.length === 0) return true;
+		const decisions = bindings.filter(isGuardDecision);
+		if (decisions.length === 0) return false;
+		const host = this.opts.host?.(context) ?? (defaultHttpHost(context) as THost);
+		const guardEmits = guards.map((guard) => ({
+			guard,
+			requestId: bindingRequestId(host, guard, this.opts.requestId),
+		}));
+		if (guardEmits.some((entry) => entry.requestId === undefined)) return false;
+		const requestIds = new Set(guardEmits.map((entry) => entry.requestId as string));
+		const cleanups: Array<() => boolean> = [];
+		try {
+			const pending: GuardDecisionState[] = [];
+			for (const requestId of requestIds) {
+				for (const decision of decisions) {
+					const state: GuardDecisionState = { status: "pending", binding: decision };
+					pending.push(state);
+					cleanups.push(
+						this.decisionBoundary(decision).attach({
+							requestId,
+							bindingId: decision.bindingId,
+							handle: {
+								resolve(payload) {
+									state.status = "resolved";
+									state.payload = payload;
+								},
+								reject(error) {
+									state.status = "rejected";
+									state.error = error;
+								},
+							},
+						}),
+					);
+				}
+			}
+			for (const entry of guardEmits)
+				entry.guard.boundary.emit(host, bindingEmitOptions(host, entry.guard, entry.requestId));
+			const rejected = pending.find((state) => state.status === "rejected");
+			if (rejected !== undefined) {
+				throw new GraphGuardProtocolErrorException(
+					lowerProtocolError(rejected.error, host, {
+						protocolError: rejected.binding.protocolError ?? this.opts.protocolError,
+					}),
+				);
+			}
+			if (pending.some((state) => state.status !== "resolved")) return false;
+			const denied = pending.find(
+				(
+					state,
+				): state is GuardDecisionState & {
+					readonly status: "resolved";
+					readonly payload: Extract<GraphGuardDecision, { readonly kind: "deny" }>;
+				} => state.status === "resolved" && state.payload?.kind === "deny",
+			);
+			if (denied !== undefined) {
+				throw new GraphGuardDeniedException(
+					guardDecisionResponse(denied.payload, host, {
+						issueResponse: denied.binding.issueResponse ?? this.opts.issueResponse,
+					}),
+				);
+			}
+			return pending.every((state) => state.payload?.kind === "allow");
+		} catch (error) {
+			if (isGraphGuardDeniedException(error) || error instanceof GraphGuardProtocolErrorException) {
+				throw error;
+			}
+			return false;
+		} finally {
+			for (const cleanup of cleanups) cleanup();
+		}
+	}
+
+	onModuleDestroy(): void {
+		for (const boundary of this.disposableDecisions) boundary.dispose();
+		this.disposableDecisions.clear();
+	}
+
+	private decisionBoundary(
+		binding: NestGuardDecisionBindingMeta,
+	): ReturnType<typeof toNestHttp<GraphGuardDecision>> {
+		const node = binding.decisionNode as object;
+		let byBinding = this.decisions.get(node);
+		if (byBinding === undefined) {
+			byBinding = new Map();
+			this.decisions.set(node, byBinding);
+		}
+		const existing = byBinding.get(binding.bindingId);
+		if (existing !== undefined) return existing;
+		const boundary = toNestHttp(binding.decisionNode, {
+			bindingId: binding.bindingId,
+			diagnosticBoundary: this.opts.diagnosticBoundary,
+			diagnosticPhase: "guard",
+		});
+		byBinding.set(binding.bindingId, boundary);
+		this.disposableDecisions.add(boundary);
+		return boundary;
+	}
+}
+
+export class GraphExceptionFilterBridge<THost> implements ExceptionFilter, OnModuleDestroy {
+	private readonly replies = new WeakMap<
+		object,
+		Map<string, ReturnType<typeof toNestHttp<NestHttpReplyPayloadUnknown>>>
+	>();
+	private readonly disposableReplies = new Set<
+		ReturnType<typeof toNestHttp<NestHttpReplyPayloadUnknown>>
+	>();
+
+	constructor(private readonly opts: GraphExceptionFilterProviderOptions<THost>) {}
+
+	catch(exception: unknown, host: ArgumentsHost): unknown {
+		const target = this.opts.target(host, exception);
+		if (target === undefined) throw exception;
+		const bindings = getNestBoundaryBindings(target.target, target.methodKey);
+		const filters = bindings.filter(isErrorIngress);
+		if (filters.length === 0) throw exception;
+		const nativeHost =
+			this.opts.host?.(host, exception) ?? (defaultArgumentsHost(host, exception) as THost);
+		const filterEmits = filters.map((filter) => ({
+			filter,
+			requestId: bindingRequestId(nativeHost, filter, this.opts.requestId),
+		}));
+		const handleFilters = filterEmits.filter((entry) => entry.filter.mode !== "observe");
+		const observeOnly = handleFilters.length === 0;
+		const replies = bindings.filter(isHttpReply);
+		const cleanups: Array<() => boolean> = [];
+		const emitFilters = () => {
+			for (const entry of filterEmits) {
+				entry.filter.boundary.emit(
+					nativeHost,
+					bindingEmitOptions(nativeHost, entry.filter, entry.requestId),
+				);
+			}
+		};
+		if (observeOnly) {
+			emitFilters();
+			throw exception;
+		}
+		const requestIds = new Set(
+			handleFilters
+				.map((entry) => entry.requestId)
+				.filter((requestId): requestId is string => requestId !== undefined),
+		);
+		if (replies.length === 0 || requestIds.size === 0) {
+			for (const entry of filterEmits) {
+				if (entry.requestId === undefined) continue;
+				entry.filter.boundary.emit(
+					nativeHost,
+					bindingEmitOptions(nativeHost, entry.filter, entry.requestId),
+				);
+			}
+			const filter = handleFilters[0]?.filter;
+			const lowered = lowerCaughtException(exception, nativeHost, {
+				issueResponse: filter?.issueResponse ?? this.opts.issueResponse,
+				protocolError: filter?.protocolError ?? this.opts.protocolError,
+			});
+			return writeHttpResponse(host, lowered);
+		}
+		const pending: FilterReplyState[] = [];
+		try {
+			for (const requestId of requestIds) {
+				for (const reply of replies) {
+					const state: FilterReplyState = { status: "pending", reply };
+					pending.push(state);
+					cleanups.push(
+						this.replyBoundary(reply).attach({
+							requestId,
+							bindingId: reply.bindingId,
+							handle: {
+								resolve(payload) {
+									state.status = "resolved";
+									state.payload = payload;
+								},
+								reject(error) {
+									state.status = "rejected";
+									state.error = error;
+								},
+							},
+						}),
+					);
+				}
+			}
+			emitFilters();
+			const resolved = pending.find((state) => state.status === "resolved");
+			if (resolved !== undefined) {
+				return writeHttpResponse(
+					host,
+					lowerHttpReplyPayload(resolved.payload, nativeHost, {
+						issueResponse:
+							resolved.reply.issueResponse ??
+							handleFilters[0]?.filter.issueResponse ??
+							this.opts.issueResponse,
+					}),
+				);
+			}
+			const rejected = pending.find((state) => state.status === "rejected");
+			if (rejected !== undefined) {
+				return writeHttpResponse(
+					host,
+					lowerProtocolError(rejected.error, nativeHost, {
+						protocolError:
+							rejected.reply.protocolError ??
+							handleFilters[0]?.filter.protocolError ??
+							this.opts.protocolError,
+					}),
+				);
+			}
+			const filter = handleFilters[0]?.filter;
+			return writeHttpResponse(
+				host,
+				lowerCaughtException(exception, nativeHost, {
+					issueResponse: filter?.issueResponse ?? this.opts.issueResponse,
+					protocolError: filter?.protocolError ?? this.opts.protocolError,
+				}),
+			);
+		} finally {
+			for (const cleanup of cleanups) cleanup();
+		}
+	}
+
+	onModuleDestroy(): void {
+		for (const boundary of this.disposableReplies) boundary.dispose();
+		this.disposableReplies.clear();
+	}
+
+	private replyBoundary(
+		binding: NestHttpReplyBindingMeta,
+	): ReturnType<typeof toNestHttp<NestHttpReplyPayloadUnknown>> {
+		const node = binding.replyNode as object;
+		let byBinding = this.replies.get(node);
+		if (byBinding === undefined) {
+			byBinding = new Map();
+			this.replies.set(node, byBinding);
+		}
+		const existing = byBinding.get(binding.bindingId);
+		if (existing !== undefined) return existing;
+		const boundary = toNestHttp(binding.replyNode as NodeReplyPayload, {
+			bindingId: binding.bindingId,
+			diagnosticBoundary: this.opts.diagnosticBoundary,
+			diagnosticPhase: "filter",
+		});
+		byBinding.set(binding.bindingId, boundary);
+		this.disposableReplies.add(boundary);
+		return boundary;
+	}
+}
+
+class GraphCronControllerImpl implements GraphCronController {
+	private readonly targets: Array<{
+		readonly target: GraphCronProviderTarget;
+		readonly schedule: CronSchedule;
+		readonly fired: Set<string>;
+	}>;
+
+	constructor(opts: GraphCronControllerOptions) {
+		this.targets = opts.targets.map((target) => ({
+			target,
+			schedule: parseCron(target.expr),
+			fired: new Set<string>(),
+		}));
+	}
+
+	check(now: Date): void {
+		for (const entry of this.targets) {
+			emitCronTarget(entry.target, entry.schedule, entry.fired, now);
+		}
+	}
+}
+
+class GraphCronSchedulerBridge implements OnModuleInit, OnModuleDestroy {
+	private readonly timers: Array<ReturnType<typeof setInterval>> = [];
+
+	constructor(private readonly opts: GraphCronSchedulerProviderOptions) {}
+
+	onModuleInit(): void {
+		try {
+			for (const target of this.opts.targets) this.startTarget(target);
+		} catch (error) {
+			this.onModuleDestroy();
+			throw error;
+		}
+	}
+
+	onModuleDestroy(): void {
+		for (const timer of this.timers.splice(0)) clearInterval(timer);
+	}
+
+	private startTarget(target: GraphCronProviderTarget): void {
+		const tickMs = target.tickMs ?? 60_000;
+		if (!Number.isFinite(tickMs) || tickMs <= 0) {
+			throw new RangeError("provideGraphCronScheduler: tickMs must be a positive finite number");
+		}
+		const controller = createGraphCronController({ targets: [target] });
+		const check = () => controller.check(new Date());
+		check();
+		this.timers.push(setInterval(check, tickMs));
+	}
+}
+
+class GraphLifecycleHooksBridge implements OnModuleInit, OnModuleDestroy {
+	constructor(private readonly opts: GraphLifecycleHooksProviderOptions) {}
+
+	onModuleInit(): void {
+		this.emit("module-init");
+	}
+
+	onModuleDestroy(): void {
+		this.emit("module-destroy");
+	}
+
+	private emit(event: "module-init" | "module-destroy"): void {
+		for (const target of this.opts.targets) {
+			if (target.event !== undefined && target.event !== event) continue;
+			const host = target.host?.(event) ?? { event };
+			for (const binding of lifecycleBindings(target)) {
+				binding.boundary.emit(host, bindingEmitOptions(host, binding, undefined));
+			}
+		}
+	}
+}
+
+type NestHttpReplyPayloadUnknown = unknown;
+type NodeReplyPayload = Parameters<typeof toNestHttp<NestHttpReplyPayloadUnknown>>[0];
+type NestGuardDecisionBindingMeta = Extract<NestBoundaryBindingMeta, { kind: "guard-decision" }>;
+interface GuardDecisionState {
+	status: "pending" | "resolved" | "rejected";
+	binding: NestGuardDecisionBindingMeta;
+	payload?: GraphGuardDecision;
+	error?: unknown;
+}
+
+interface FilterReplyState {
+	status: "pending" | "resolved" | "rejected";
+	reply: NestHttpReplyBindingMeta;
+	payload?: NestHttpReplyPayloadUnknown;
+	error?: unknown;
+}
+
+function methodKeyForContext(context: ExecutionContext): string | symbol {
+	const resolved = resolveNestMethodKey(
+		context.getClass(),
+		context.getHandler() as DecoratorBoundMethod,
+	);
+	return resolved ?? context.getHandler().name;
+}
+
+function defaultHttpHost(context: ExecutionContext): unknown {
+	const request = context.switchToHttp?.().getRequest?.();
+	return request ?? {};
+}
+
+function defaultArgumentsHost(host: ArgumentsHost, exception: unknown): unknown {
+	const request = host.switchToHttp?.().getRequest?.();
+	if (request !== undefined && request !== null) return { ...request, exception };
+	return { exception };
+}
+
+function isObservableLike(value: unknown): value is Observable<unknown> {
+	return (
+		value !== null &&
+		typeof value === "object" &&
+		typeof (value as { subscribe?: unknown }).subscribe === "function"
+	);
+}
+
+function isGuardIngress(binding: NestBoundaryBindingMeta): binding is NestIngressBindingMeta {
+	return binding.direction === "ingress" && binding.kind === "guard";
+}
+
+function isErrorIngress(binding: NestBoundaryBindingMeta): binding is NestIngressBindingMeta {
+	return binding.direction === "ingress" && binding.kind === "error";
+}
+
+function isHttpReply(binding: NestBoundaryBindingMeta): binding is NestHttpReplyBindingMeta {
+	return binding.direction === "egress" && binding.kind === "http";
+}
+
+function isGuardDecision(
+	binding: NestBoundaryBindingMeta,
+): binding is NestGuardDecisionBindingMeta {
+	return binding.direction === "egress" && binding.kind === "guard-decision";
+}
+
+function firstHttpReply(context: ExecutionContext): NestHttpReplyBindingMeta | undefined {
+	return getNestBoundaryBindings(context.getClass(), methodKeyForContext(context)).find(
+		isHttpReply,
+	);
+}
+
+function lifecycleBindings(
+	target: GraphLifecycleProviderTarget,
+): readonly NestIngressBindingMeta[] {
+	return getNestBoundaryBindings(target.target, target.methodKey).filter(
+		(binding): binding is NestIngressBindingMeta =>
+			binding.direction === "ingress" && binding.kind === "lifecycle",
+	);
+}
+
+function cronBindings(target: GraphCronProviderTarget): readonly NestIngressBindingMeta[] {
+	return getNestBoundaryBindings(target.target, target.methodKey).filter(
+		(binding): binding is NestIngressBindingMeta =>
+			binding.direction === "ingress" && binding.kind === "cron",
+	);
+}
+
+function emitCronTarget(
+	target: GraphCronProviderTarget,
+	schedule: CronSchedule,
+	fired: Set<string>,
+	now: Date,
+): void {
+	if (!matchesCron(schedule, now, { timezone: target.timezone })) return;
+	const key = cronProviderMinuteKey(now, target.timezone);
+	for (const existing of fired) {
+		if (!existing.startsWith(`${key.dayKey}:`)) fired.delete(existing);
+	}
+	if (fired.has(key.minuteKey)) return;
+	fired.add(key.minuteKey);
+	const host =
+		target.host?.(now) ??
+		({
+			iso: now.toISOString(),
+			timestamp_ms: now.getTime(),
+			timestamp_ns: (BigInt(now.getTime()) * 1_000_000n).toString(),
+			timezone: target.timezone,
+		} satisfies Record<string, unknown>);
+	for (const binding of cronBindings(target)) {
+		binding.boundary.emit(host, bindingEmitOptions(host, binding, undefined));
+	}
+}
+
+function cronProviderMinuteKey(
+	date: Date,
+	timezone?: string,
+): { readonly dayKey: string; readonly minuteKey: string } {
+	if (timezone === undefined) {
+		const dayKey = `${date.getFullYear()}-${date.getMonth() + 1}-${date.getDate()}`;
+		return { dayKey, minuteKey: `${dayKey}:${date.getHours()}:${date.getMinutes()}` };
+	}
+	const parts = new Intl.DateTimeFormat("en-US-u-ca-gregory-nu-latn", {
+		timeZone: timezone,
+		year: "numeric",
+		month: "2-digit",
+		day: "2-digit",
+		hour: "2-digit",
+		minute: "2-digit",
+		hourCycle: "h23",
+	}).formatToParts(date);
+	const byType = new Map(parts.map((part) => [part.type, part.value]));
+	const dayKey = `${byType.get("year")}-${byType.get("month")}-${byType.get("day")}`;
+	return { dayKey, minuteKey: `${dayKey}:${byType.get("hour")}:${byType.get("minute")}` };
+}
+
+function lowerCaughtException<THost>(
+	exception: unknown,
+	host: THost,
+	opts: {
+		readonly issueResponse?: NestIssueResponse<THost>;
+		readonly protocolError?: NestProtocolErrorResponse<THost>;
+	},
+): ReturnType<typeof lowerHttpReplyPayload> {
+	if (isDataIssue(exception)) return lowerHttpReplyPayload(exception, host, opts);
+	return (opts.protocolError ?? protocolError)(exception, host);
+}
+
+function guardDecisionResponse<THost>(
+	decision: Extract<GraphGuardDecision, { readonly kind: "deny" }>,
+	host: THost,
+	opts: { readonly issueResponse?: NestIssueResponse<THost> },
+): NestHttpResponsePayload {
+	if (decision.issue !== undefined) return lowerHttpReplyPayload(decision.issue, host, opts);
+	if (Number.isInteger(decision.status)) {
+		return {
+			status: decision.status as number,
+			body: decision.body ?? {
+				code: "graphrefly.guard_denied",
+				message: decision.reason ?? "GraphReFly guard denied request",
+			},
+			headers: decision.headers,
+		};
+	}
+	return {
+		status: 403,
+		body: {
+			code: "graphrefly.guard_denied",
+			message: decision.reason ?? "GraphReFly guard denied request",
+		},
+		headers: decision.headers,
+	};
+}
+
+export class GraphGuardDeniedException extends HttpException {
+	readonly payload: NestHttpResponsePayload;
+
+	constructor(payload: NestHttpResponsePayload) {
+		super(payload.body ?? {}, payload.status);
+		this.payload = payload;
+	}
+}
+
+class GraphGuardProtocolErrorException extends HttpException {
+	constructor(payload: NestHttpResponsePayload) {
+		super(payload.body ?? {}, payload.status);
+	}
+}
+
+export function isGraphGuardDeniedException(value: unknown): value is GraphGuardDeniedException {
+	return value instanceof GraphGuardDeniedException;
+}
+
+export class GraphGuardDeniedFilter implements ExceptionFilter {
+	catch(exception: unknown, host: ArgumentsHost): unknown {
+		if (!isGraphGuardDeniedException(exception)) throw exception;
+		return writeHttpResponse(host, exception.payload);
+	}
+}
+
+Catch(GraphGuardDeniedException)(GraphGuardDeniedFilter);
+
+function writeHttpResponse(
+	host: ArgumentsHost,
+	payload: ReturnType<typeof lowerHttpReplyPayload>,
+): unknown {
+	const response = host.switchToHttp?.().getResponse?.() as
+		| {
+				status?: (status: number) => unknown;
+				json?: (body: unknown) => unknown;
+				send?: (body?: unknown) => unknown;
+				setHeader?: (name: string, value: string) => void;
+				header?: (name: string, value: string) => void;
+		  }
+		| undefined;
+	if (response === undefined) return payload;
+	for (const [name, value] of Object.entries(payload.headers ?? {})) {
+		if (typeof response.setHeader === "function") response.setHeader(name, value);
+		else response.header?.(name, value);
+	}
+	response.status?.(payload.status);
+	if (typeof response.json === "function") return response.json(payload.body ?? {});
+	if (typeof response.send === "function") return response.send(payload.body);
+	return payload;
+}
diff --git a/packages/ts/src/adapters/nestjs/websockets.ts b/packages/ts/src/adapters/nestjs/websockets.ts
new file mode 100644
index 00000000..fb06a367
--- /dev/null
+++ b/packages/ts/src/adapters/nestjs/websockets.ts
@@ -0,0 +1,403 @@
+/**
+ * NestJS WebSocket native phase bridge (D488).
+ *
+ * This focused subpath may import `@nestjs/websockets`; the dependency-light
+ * structural layer and HTTP native bridge stay free of that optional peer.
+ */
+
+import type { OnGatewayDisconnect } from "@nestjs/websockets";
+import {
+	bindingEmitOptions,
+	bindingRequestId,
+	type DecoratorHostConstructor,
+	fromNestWs,
+	GraphWs,
+	GraphWsAck,
+	GraphWsReply,
+	getNestBoundaryBindings,
+	type NestBoundaryBindingMeta,
+	type NestBoundaryDiagnostic,
+	type NestBoundaryEnvelope,
+	type NestDiagnosticIngressBoundary,
+	type NestGraphRunOptions,
+	type NestIngressBindingMeta,
+	type NestIngressBoundary,
+	type NestIngressEmitOptions,
+	type NestIngressOptions,
+	type NestProviderBinding,
+	type NestReplyEnvelope,
+	type NestReplyResponseHandle,
+	type NestWsAckBindingMeta,
+	type NestWsReplyBindingMeta,
+	sanitizeNestDiagnostic,
+	toNestHttp,
+} from "../nestjs.js";
+
+/** D488 provider token for the focused Nest WebSocket native bridge. */
+export const GRAPHREFLY_NEST_WS_BRIDGE = Symbol.for("graphrefly:nest:ws-bridge");
+
+/** Options for the D488 Nest WebSocket bridge; socket and ack handles stay host-private. */
+export interface GraphWsBridgeOptions<THost = unknown> extends NestGraphRunOptions<THost> {
+	readonly ack?: (host: THost) => (payload: unknown, envelope: NestReplyEnvelope<unknown>) => void;
+	readonly client?: (host: THost) => object | undefined;
+	readonly diagnosticBoundary?: NestDiagnosticIngressBoundary;
+	readonly timeoutMs?: number;
+	readonly maxDiagnostics?: number;
+}
+
+/** D495 focused WebSocket provider bundle options. */
+export interface GraphWsProviderBundleOptions<THost = unknown> {
+	readonly bridge?: GraphWsBridgeOptions<THost> | false;
+}
+
+/** Explicit Nest WebSocket phase bridge over `GraphWs`, `GraphWsAck`, and `GraphWsReply` metadata. */
+export interface GraphWsBridge<THost = unknown> extends OnGatewayDisconnect {
+	handleMessage(
+		target: DecoratorHostConstructor | object,
+		methodKey: string | symbol,
+		host: THost,
+		opts?: NestGraphRunOptions<THost>,
+	): Promise<unknown> | undefined;
+	onModuleDestroy(): void;
+	diagnostics(): readonly NestBoundaryDiagnostic[];
+	dispose(): void;
+}
+
+type WsEgressBinding = NestWsAckBindingMeta | NestWsReplyBindingMeta;
+type WsBoundary = ReturnType<typeof toNestHttp<unknown>>;
+interface WsPending {
+	readonly requestId: string;
+	readonly cleanups: Array<() => boolean>;
+	readonly reject: (error: unknown) => void;
+	timeout?: ReturnType<typeof setTimeout>;
+	settled: boolean;
+}
+
+/** Build a dependency-light Nest provider for the focused WebSocket bridge token. */
+export function provideGraphWsBridge<THost = unknown>(
+	opts: GraphWsBridgeOptions<THost> = {},
+): NestProviderBinding<GraphWsBridge<THost>> {
+	return { provide: GRAPHREFLY_NEST_WS_BRIDGE, useValue: createGraphWsBridge(opts) };
+}
+
+/** Build the D495 focused WebSocket provider bundle without scanning or creating graphs. */
+export function provideGraphWsProviders<THost = unknown>(
+	opts: GraphWsProviderBundleOptions<THost> = {},
+): NestProviderBinding<GraphWsBridge<THost>>[] {
+	return opts.bridge === false ? [] : [provideGraphWsBridge(opts.bridge ?? {})];
+}
+
+/** Create a host-private WebSocket bridge instance without scanning the Nest container. */
+export function createGraphWsBridge<THost = unknown>(
+	opts: GraphWsBridgeOptions<THost> = {},
+): GraphWsBridge<THost> {
+	return new GraphWsBridgeImpl(opts);
+}
+
+class GraphWsBridgeImpl<THost> implements GraphWsBridge<THost> {
+	private readonly boundaries = new WeakMap<object, Map<string, WsBoundary>>();
+	private readonly disposable = new Set<WsBoundary>();
+	private readonly pendingByClient = new WeakMap<object, Set<WsPending>>();
+	private readonly localDiagnostics: NestBoundaryDiagnostic[] = [];
+	private active = true;
+
+	constructor(private readonly opts: GraphWsBridgeOptions<THost>) {}
+
+	handleDisconnect(client?: unknown): void {
+		if (client === null || typeof client !== "object") return;
+		const pending = this.pendingByClient.get(client);
+		if (pending === undefined) return;
+		for (const entry of [...pending]) {
+			this.rejectPending(
+				entry,
+				new Error(`GraphWs native bridge disconnected before ${entry.requestId} resolved`),
+				"dispose-pending",
+			);
+		}
+		this.pendingByClient.delete(client);
+	}
+
+	onModuleDestroy(): void {
+		this.dispose();
+	}
+
+	handleMessage(
+		target: DecoratorHostConstructor | object,
+		methodKey: string | symbol,
+		host: THost,
+		runOpts: NestGraphRunOptions<THost> = {},
+	): Promise<unknown> | undefined {
+		if (!this.active) throw new Error("GraphWs native bridge is disposed");
+		const bindings = wsBindings(target, methodKey);
+		const ingress = bindings.filter(isWsIngress);
+		if (ingress.length === 0) return undefined;
+		const egress = bindings.filter(isWsEgress);
+		const needsRequestId = egress.length > 0;
+		for (const binding of ingress) assertExplicitNativePayload(binding, "GraphWs");
+		const ingressEmits = ingress.map((binding) => ({
+			binding,
+			requestId: bindingRequestId(host, binding, runOpts.requestId ?? this.opts.requestId),
+		}));
+		if (needsRequestId && ingressEmits.some((entry) => entry.requestId === undefined)) {
+			throw new Error("GraphWs native bridge requires a stable requestId for ack/reply egress");
+		}
+		const requestIds = uniqueDefinedStrings(ingressEmits.map((entry) => entry.requestId));
+		const cleanups: Array<() => boolean> = [];
+		let settled = false;
+		const replyBindings = egress.filter(isWsReply);
+		const settleOnAck = replyBindings.length === 0;
+		let activePending: WsPending | undefined;
+		let resolvePromise: ((payload: unknown) => void) | undefined;
+		let rejectPromise: ((error: unknown) => void) | undefined;
+		let cleaned = false;
+		const cleanupAll = () => {
+			if (cleaned) return;
+			cleaned = true;
+			for (const cleanup of cleanups) cleanup();
+			if (activePending?.timeout !== undefined) clearTimeout(activePending.timeout);
+			this.unregisterClientPending(host, activePending);
+		};
+		const settleResolve = (payload: unknown) => {
+			if (settled) return;
+			settled = true;
+			if (activePending !== undefined) activePending.settled = true;
+			resolvePromise?.(payload);
+		};
+		const settleReject = (error: unknown) => {
+			if (settled) return;
+			settled = true;
+			if (activePending !== undefined) activePending.settled = true;
+			rejectPromise?.(error);
+		};
+		const promise =
+			egress.length === 0
+				? undefined
+				: new Promise<unknown>((resolve, reject) => {
+						resolvePromise = resolve;
+						rejectPromise = reject;
+					});
+		if (promise !== undefined) {
+			activePending = {
+				requestId: requestIds[0],
+				cleanups,
+				reject: settleReject,
+				settled: false,
+			};
+			try {
+				for (const requestId of requestIds) {
+					for (const binding of egress) {
+						const boundary = this.boundaryFor(binding);
+						cleanups.push(
+							boundary.attach({
+								requestId,
+								bindingId: binding.bindingId,
+								handle: this.handleFor(binding, host, settleResolve, settleReject, settleOnAck),
+							}),
+						);
+					}
+				}
+			} catch (error) {
+				cleanupAll();
+				settleReject(error);
+				return promise;
+			}
+			if (settled) {
+				cleanupAll();
+				return promise;
+			}
+			try {
+				this.registerClientPending(host, activePending);
+			} catch (error) {
+				cleanupAll();
+				settleReject(error);
+				return promise;
+			}
+			if (this.opts.timeoutMs !== undefined) {
+				activePending.timeout = setTimeout(() => {
+					const error = new Error(`GraphWs native bridge timed out waiting for ${requestIds[0]}`);
+					this.rejectPending(activePending as WsPending, error, "timeout");
+				}, this.opts.timeoutMs);
+			}
+		}
+		try {
+			for (const { binding, requestId } of ingressEmits) {
+				binding.boundary.emit(host, {
+					...bindingEmitOptions(host, binding, requestId),
+					requireRequestId: needsRequestId,
+				});
+			}
+		} catch (error) {
+			cleanupAll();
+			throw error;
+		}
+		return promise?.finally(() => {
+			cleanupAll();
+		});
+	}
+
+	diagnostics(): readonly NestBoundaryDiagnostic[] {
+		return [
+			...this.localDiagnostics,
+			...[...this.disposable].flatMap((boundary) => boundary.diagnostics()),
+		];
+	}
+
+	dispose(): void {
+		if (!this.active) return;
+		this.active = false;
+		for (const boundary of this.disposable) boundary.dispose();
+	}
+
+	private boundaryFor(binding: WsEgressBinding): WsBoundary {
+		const node = binding.kind === "ws-ack" ? binding.ackNode : binding.replyNode;
+		let byBinding = this.boundaries.get(node);
+		if (byBinding === undefined) {
+			byBinding = new Map();
+			this.boundaries.set(node, byBinding);
+		}
+		const existing = byBinding.get(binding.bindingId);
+		if (existing !== undefined) return existing;
+		const boundary = toNestHttp(node, {
+			bindingId: binding.bindingId,
+			diagnosticBoundary: this.opts.diagnosticBoundary,
+			diagnosticPhase: "ws",
+			name: `nestjs.${binding.kind}`,
+			maxDiagnostics: this.opts.maxDiagnostics,
+		});
+		byBinding.set(binding.bindingId, boundary);
+		this.disposable.add(boundary);
+		return boundary;
+	}
+
+	private handleFor(
+		binding: WsEgressBinding,
+		host: THost,
+		resolve: (payload: unknown) => void,
+		reject: (error: unknown) => void,
+		settleOnAck: boolean,
+	): NestReplyResponseHandle<unknown> {
+		return {
+			resolve: (payload, envelope) => {
+				if (binding.kind === "ws-ack") {
+					this.opts.ack?.(host)?.(payload, envelope);
+					if (settleOnAck) resolve(payload);
+					return;
+				}
+				resolve(payload);
+			},
+			reject,
+		};
+	}
+
+	private diagnose(diagnostic: NestBoundaryDiagnostic): void {
+		this.localDiagnostics.push(diagnostic);
+		try {
+			const phase = diagnostic.phase ?? "ws";
+			const payload = sanitizeNestDiagnostic({ ...diagnostic, phase }, phase);
+			this.opts.diagnosticBoundary?.emit(payload, { payload });
+		} catch {
+			// Graph-visible diagnostics are optional and must not interrupt host cleanup.
+		}
+		if (
+			this.opts.maxDiagnostics !== undefined &&
+			this.localDiagnostics.length > this.opts.maxDiagnostics
+		) {
+			this.localDiagnostics.splice(0, this.localDiagnostics.length - this.opts.maxDiagnostics);
+		}
+	}
+
+	private registerClientPending(host: THost, pending: WsPending | undefined): void {
+		if (pending === undefined) return;
+		const client = this.clientFor(host);
+		if (client === undefined) return;
+		let set = this.pendingByClient.get(client);
+		if (set === undefined) {
+			set = new Set();
+			this.pendingByClient.set(client, set);
+		}
+		set.add(pending);
+	}
+
+	private unregisterClientPending(host: THost, pending: WsPending | undefined): void {
+		if (pending === undefined) return;
+		const client = this.clientFor(host);
+		if (client === undefined) return;
+		const set = this.pendingByClient.get(client);
+		if (set === undefined) return;
+		set.delete(pending);
+		if (set.size === 0) this.pendingByClient.delete(client);
+	}
+
+	private rejectPending(
+		pending: WsPending,
+		error: unknown,
+		kind: "dispose-pending" | "timeout",
+	): void {
+		if (pending.settled) return;
+		pending.settled = true;
+		for (const cleanup of pending.cleanups) cleanup();
+		if (pending.timeout !== undefined) clearTimeout(pending.timeout);
+		this.diagnose({
+			kind,
+			requestId: pending.requestId,
+			message: error instanceof Error ? error.message : String(error),
+			error,
+		});
+		pending.reject(error);
+	}
+
+	private clientFor(host: THost): object | undefined {
+		const fromOption = this.opts.client?.(host);
+		if (fromOption !== null && typeof fromOption === "object") return fromOption;
+		if (host === null || typeof host !== "object") return undefined;
+		const record = host as { readonly client?: unknown; readonly socket?: unknown };
+		if (record.client !== null && typeof record.client === "object") return record.client;
+		if (record.socket !== null && typeof record.socket === "object") return record.socket;
+		return undefined;
+	}
+}
+
+function wsBindings(
+	target: DecoratorHostConstructor | object,
+	methodKey: string | symbol,
+): readonly NestBoundaryBindingMeta[] {
+	return getNestBoundaryBindings(target, methodKey);
+}
+
+function isWsIngress(binding: NestBoundaryBindingMeta): binding is NestIngressBindingMeta {
+	return binding.direction === "ingress" && binding.kind === "ws";
+}
+
+function isWsEgress(binding: NestBoundaryBindingMeta): binding is WsEgressBinding {
+	return (
+		binding.direction === "egress" && (binding.kind === "ws-ack" || binding.kind === "ws-reply")
+	);
+}
+
+function isWsReply(binding: WsEgressBinding): binding is NestWsReplyBindingMeta {
+	return binding.kind === "ws-reply";
+}
+
+function assertExplicitNativePayload(binding: NestIngressBindingMeta, label: string): void {
+	if (binding.payload === undefined) {
+		throw new Error(`${label} native bridge requires an explicit payload selector`);
+	}
+}
+
+function uniqueDefinedStrings(values: readonly (string | undefined)[]): string[] {
+	const seen = new Set<string>();
+	for (const value of values) if (value !== undefined) seen.add(value);
+	return [...seen];
+}
+
+export {
+	fromNestWs,
+	GraphWs,
+	GraphWsAck,
+	GraphWsReply,
+	type NestBoundaryEnvelope,
+	type NestIngressBoundary,
+	type NestIngressEmitOptions,
+	type NestIngressOptions,
+	type NestReplyEnvelope,
+};
diff --git a/packages/ts/src/adapters/observe-storage.ts b/packages/ts/src/adapters/observe-storage.ts
new file mode 100644
index 00000000..5f4151cf
--- /dev/null
+++ b/packages/ts/src/adapters/observe-storage.ts
@@ -0,0 +1,257 @@
+/**
+ * Graph-bound observe storage adapters.
+ *
+ * Passive storage lives under ../storage. This subpath owns bridges that need
+ * Graph.observe() and therefore sit above both graph and passive storage (D125).
+ */
+
+import type { Graph } from "../graph/graph.js";
+import type { ObserveEvent } from "../graph/inspect.js";
+import type { AppendLogStorageTier } from "../storage/append-log.js";
+import {
+	type ObserveEventFrame,
+	type ObserveEventLogPage,
+	observeEventFrame,
+} from "../storage/observe-event-log.js";
+
+/** Adapter-owned sink for observed graph events (D57/D74/D125). */
+export interface ObserveSink<T = ObserveEvent> {
+	/** Persist or forward one mapped observe event. Thenables are serialized in observe order. */
+	write(event: T): void | PromiseLike<void>;
+	/** Optional adapter flush barrier. Runs after all earlier writes. */
+	flush?(): void | PromiseLike<void>;
+	/** Optional adapter rollback hook. Runs after all earlier writes. */
+	rollback?(): void | PromiseLike<void>;
+	/** Optional adapter cleanup hook. Runs once after queued work drains. */
+	dispose?(): void | PromiseLike<void>;
+}
+
+/** Error routing context for attachObserveSink lifecycle hooks. */
+export interface ObserveSinkErrorContext<T = ObserveEvent> {
+	phase: "map" | "write" | "flush" | "rollback" | "dispose";
+	event?: ObserveEvent;
+	value?: T;
+}
+
+/** Queue-drain completion callback for observe-sink control calls (D75). */
+export type ObserveSinkDone = () => void;
+
+/** Options for attaching a sink to the read-only observe egress (D74/D125). */
+export interface AttachObserveSinkOptions<T = ObserveEvent> {
+	/** Optional exact-id or subtree path filter; forwarded to `graph.observe(path?)`. */
+	path?: string;
+	/** Optional projection/filter. Return `undefined` to drop an observed event. */
+	map?: (event: ObserveEvent) => T | undefined;
+	/** Optional error hook for mapper, write, and lifecycle failures. */
+	onError?: (error: unknown, ctx: ObserveSinkErrorContext<T>) => void;
+}
+
+/** Done-only callback control handle for an attached observe sink (D75). */
+export interface ObserveSinkHandle {
+	flush(done?: ObserveSinkDone): void;
+	rollback(done?: ObserveSinkDone): void;
+	dispose(done?: ObserveSinkDone): void;
+}
+
+type QueueItem<T> =
+	| { kind: "write"; event: ObserveEvent; value: T }
+	| { kind: "flush"; done?: ObserveSinkDone }
+	| { kind: "rollback"; done?: ObserveSinkDone }
+	| { kind: "dispose" };
+
+/** Options for persisting Graph.observe() events into an append log. */
+export interface AttachObserveEventLogOptions<T = ObserveEvent> {
+	path?: string;
+	stream?: string;
+	map?: (event: ObserveEvent) => T | undefined;
+	onError?: (error: unknown, ctx: ObserveSinkErrorContext<ObserveEventFrame<T>>) => void;
+}
+
+/** Done-callback lifecycle handle for an attached observe-event log. */
+export interface ObserveEventLogHandle extends ObserveSinkHandle {
+	flush(done?: ObserveSinkDone): void;
+	rollback(done?: ObserveSinkDone): void;
+	dispose(done?: ObserveSinkDone): void;
+}
+
+export type { ObserveEventFrame, ObserveEventLogPage };
+
+/**
+ * Attach adapter-owned storage to `Graph.observe()` read-only egress (D57/D74/D125). Writes are
+ * serialized in observe order; lifecycle barriers drain the queue without mutating graph topology.
+ */
+export function attachObserveSink<T = ObserveEvent>(
+	graph: Graph,
+	sink: ObserveSink<T>,
+	opts: AttachObserveSinkOptions<T> = {},
+): ObserveSinkHandle {
+	const { map, onError, path } = opts;
+	const queue: QueueItem<T>[] = [];
+	const disposeDone: ObserveSinkDone[] = [];
+	let draining = false;
+	let disposeRequested = false;
+	let disposed = false;
+
+	function report(error: unknown, ctx: ObserveSinkErrorContext<T>): void {
+		if (!onError) return;
+		try {
+			onError(error, ctx);
+		} catch {
+			// Error routing is best-effort; never let adapter logging wedge the queue.
+		}
+	}
+
+	function callDone(done?: ObserveSinkDone): void {
+		try {
+			done?.();
+		} catch {
+			// Completion callbacks are advisory only; never wedge the queue on observer code.
+		}
+	}
+
+	function run(item: QueueItem<T>): void | PromiseLike<void> {
+		switch (item.kind) {
+			case "write":
+				return sink.write(item.value);
+			case "flush":
+				return sink.flush?.();
+			case "rollback":
+				return sink.rollback?.();
+			case "dispose":
+				return sink.dispose?.();
+		}
+	}
+
+	function finish(item: QueueItem<T>): void {
+		if (item.kind === "dispose") {
+			disposed = true;
+			for (const done of disposeDone.splice(0)) callDone(done);
+		} else if (item.kind !== "write") {
+			callDone(item.done);
+		}
+		draining = false;
+		drain();
+	}
+
+	function fail(item: QueueItem<T>, error: unknown): void {
+		if (item.kind === "write")
+			report(error, { phase: "write", event: item.event, value: item.value });
+		else report(error, { phase: item.kind });
+		finish(item);
+	}
+
+	function chainThenable(item: QueueItem<T>, value: unknown): boolean {
+		if ((typeof value !== "object" && typeof value !== "function") || value === null) return false;
+
+		let then: unknown;
+		try {
+			then = (value as { then?: unknown }).then;
+		} catch (error) {
+			fail(item, error);
+			return true;
+		}
+		if (typeof then !== "function") return false;
+
+		let settled = false;
+		const settle = (next: () => void) => {
+			if (settled) return;
+			settled = true;
+			next();
+		};
+		try {
+			(then as (onFulfilled: () => void, onRejected: (error: unknown) => void) => unknown).call(
+				value,
+				() => settle(() => finish(item)),
+				(error) => settle(() => fail(item, error)),
+			);
+		} catch (error) {
+			settle(() => fail(item, error));
+		}
+		return true;
+	}
+
+	function drain(): void {
+		if (draining) return;
+		const item = queue.shift();
+		if (!item) return;
+		draining = true;
+		let result: void | PromiseLike<void>;
+		try {
+			result = run(item);
+		} catch (error) {
+			fail(item, error);
+			return;
+		}
+		if (chainThenable(item, result)) return;
+		finish(item);
+	}
+
+	function enqueueBarrier(kind: "flush" | "rollback", done?: ObserveSinkDone): void {
+		if (disposeRequested) {
+			callDone(done);
+			return;
+		}
+		queue.push({ kind, done });
+		drain();
+	}
+
+	const stop = graph.observe(path).subscribe((event) => {
+		if (disposeRequested) return;
+		let value: T | undefined;
+		try {
+			value = map ? map(event) : (event as unknown as T);
+		} catch (error) {
+			report(error, { phase: "map", event });
+			return;
+		}
+		if (value === undefined) return;
+		queue.push({ kind: "write", event, value });
+		drain();
+	});
+
+	return {
+		flush(done?: ObserveSinkDone): void {
+			enqueueBarrier("flush", done);
+		},
+		rollback(done?: ObserveSinkDone): void {
+			enqueueBarrier("rollback", done);
+		},
+		dispose(done?: ObserveSinkDone): void {
+			if (disposed) {
+				callDone(done);
+				return;
+			}
+			if (done) disposeDone.push(done);
+			if (disposeRequested) {
+				return;
+			}
+			disposeRequested = true;
+			stop();
+			queue.push({ kind: "dispose" });
+			drain();
+		},
+	};
+}
+
+/**
+ * Persist Graph.observe() events to an append log. This is a graph-bound
+ * adapter over passive storage frames, not graph restore or projection.
+ */
+export function attachObserveEventLog<T = ObserveEvent>(
+	graph: Graph,
+	log: AppendLogStorageTier<ObserveEventFrame<T>>,
+	opts: AttachObserveEventLogOptions<T> = {},
+): ObserveEventLogHandle {
+	return attachObserveSink<ObserveEventFrame<T>>(
+		graph,
+		{ write: (frame) => log.append(frame).then(() => undefined) },
+		{
+			path: opts.path,
+			map: (event) => {
+				const value = opts.map ? opts.map(event) : (event as unknown as T);
+				return value === undefined ? undefined : observeEventFrame(event, value, opts);
+			},
+			onError: opts.onError,
+		},
+	);
+}
diff --git a/packages/ts/src/adapters/react.ts b/packages/ts/src/adapters/react.ts
new file mode 100644
index 00000000..ea0269e2
--- /dev/null
+++ b/packages/ts/src/adapters/react.ts
@@ -0,0 +1,69 @@
+/**
+ * React node bindings for GraphReFly (D238).
+ *
+ * React is imported only from this focused subpath. The dependency-free
+ * `@graphrefly/ts/adapters` barrel keeps the framework-neutral store contract.
+ */
+
+import { useCallback, useMemo, useSyncExternalStore } from "react";
+import type { Node } from "../node/node.js";
+import { externalStore, recordReadableStore, type WritableNode } from "./store.js";
+
+function assertDataValue(value: unknown): void {
+	if (value === undefined) {
+		throw new TypeError("useNodeInput: undefined is SENTINEL/no DATA, not a writable DATA value");
+	}
+}
+
+/** Read a GraphReFly node through React's useSyncExternalStore contract. */
+export function useNodeValue<T>(node: Node<T>): T | undefined {
+	const store = useMemo(() => externalStore(node), [node]);
+	return useSyncExternalStore(store.subscribe, store.getSnapshot, store.getServerSnapshot);
+}
+
+/**
+ * Bind a writable GraphReFly node as `[value, setValue]`.
+ *
+ * The setter identity is stable for a stable node identity, and writes through
+ * the node's reactive DATA boundary rather than a presentation-owned trigger.
+ */
+export function useNodeInput<T>(
+	node: WritableNode<T>,
+): readonly [T | undefined, (value: T) => void] {
+	const value = useNodeValue(node);
+	const setValue = useCallback(
+		(next: T) => {
+			assertDataValue(next);
+			node.set(next);
+		},
+		[node],
+	);
+	return [value, setValue] as const;
+}
+
+/**
+ * Read a keyed record of nodes.
+ *
+ * `factory` must have stable identity. Recreating it on every render forces the
+ * record subscription graph to rebuild on every render.
+ */
+export function useNodeRecord<K extends string, R extends Record<string, unknown>>(
+	keysNode: Node<readonly K[]>,
+	factory: (key: K) => { [P in keyof R]: Node<R[P]> },
+): Record<K, R> {
+	const store = useMemo(() => {
+		const recordStore = recordReadableStore(keysNode, factory);
+		let current = recordStore.get() ?? ({} as Record<K, R>);
+		return {
+			getSnapshot: () => current,
+			subscribe(onStoreChange: () => void) {
+				return recordStore.subscribe((next) => {
+					current = next ?? ({} as Record<K, R>);
+					onStoreChange();
+				});
+			},
+		};
+	}, [keysNode, factory]);
+	const getSnapshot = useCallback(() => store.getSnapshot(), [store]);
+	return useSyncExternalStore(store.subscribe, getSnapshot, getSnapshot);
+}
diff --git a/packages/ts/src/adapters/reactive-collection-storage.ts b/packages/ts/src/adapters/reactive-collection-storage.ts
new file mode 100644
index 00000000..c7a5347e
--- /dev/null
+++ b/packages/ts/src/adapters/reactive-collection-storage.ts
@@ -0,0 +1,637 @@
+import type { DeliveryMeta } from "../ctx/types.js";
+import {
+	type ReactiveIndex,
+	type ReactiveIndexOptions,
+	type ReactiveList,
+	type ReactiveListOptions,
+	type ReactiveLog,
+	type ReactiveLogOptions,
+	type ReactiveMap,
+	type ReactiveMapOptions,
+	restoreReactiveIndex,
+	restoreReactiveList,
+	restoreReactiveLog,
+	restoreReactiveMap,
+} from "../data-structures/index.js";
+import type {
+	IndexChange,
+	ListChange,
+	LogChange,
+	MapChange,
+} from "../graph/data-structures/change.js";
+import type { IndexRow } from "../graph/data-structures/reactive-index.js";
+import { assertGraphLocalNode, type Graph, type StateNode } from "../graph/graph.js";
+import type { Node } from "../node/node.js";
+import type { Message } from "../protocol/messages.js";
+import type {
+	AppendLogEntry,
+	AppendLogStorageTier,
+	KvStorageTier,
+	LoadReactiveCollectionStateOptions,
+	ReactiveCollectionChangeFrame,
+	ReactiveCollectionSnapshotFrame,
+	ReactiveIndexRestoreState,
+	ReactiveListRestoreState,
+	ReactiveLogRestoreState,
+	ReactiveMapRestoreState,
+} from "../storage/index.js";
+import {
+	assertReactiveCollectionChangeFrame,
+	assertReactiveCollectionSnapshotFrame,
+	collectionSnapshotKey,
+	loadReactiveIndexState,
+	loadReactiveListState,
+	loadReactiveLogState,
+	loadReactiveMapState,
+	reactiveCollectionChangeFrame,
+	reactiveCollectionSnapshotFrame,
+} from "../storage/index.js";
+
+type PersistableKind = "reactiveList" | "reactiveLog" | "reactiveMap" | "reactiveIndex";
+type PersistableChange<T, K extends PersistableKind> = K extends "reactiveList"
+	? ListChange<T>
+	: K extends "reactiveLog"
+		? LogChange<T>
+		: K extends "reactiveMap"
+			? MapChange<unknown, T>
+			: IndexChange<unknown, T>;
+type PersistableCollection<T, K extends PersistableKind> = K extends "reactiveList"
+	? ReactiveList<T>
+	: K extends "reactiveLog"
+		? ReactiveLog<T>
+		: K extends "reactiveMap"
+			? ReactiveMap<unknown, T>
+			: ReactiveIndex<unknown, T>;
+
+/** D161 adapter write-progress cursor; this is not a domain replay or wire-bridge cursor. */
+export interface ReactiveCollectionPersistenceCursor {
+	readonly kind: "persistence.cursor";
+	readonly collection: PersistableKind;
+	readonly changeSeq: number;
+	readonly snapshotWrites: number;
+	readonly changeWrites: number;
+}
+
+/** D161 graph-visible persistence sidecar status fact. */
+export interface ReactiveCollectionPersistenceStatus {
+	readonly state: "starting" | "ready" | "flushing" | "errored" | "disposed";
+	readonly pending: number;
+	readonly writes: number;
+	readonly errors: number;
+	readonly cursor: ReactiveCollectionPersistenceCursor;
+}
+
+/** D161 graph-visible persistence sidecar error fact. */
+export interface ReactiveCollectionPersistenceError {
+	readonly phase: "snapshot" | "change";
+	readonly message: string;
+	readonly cursor: ReactiveCollectionPersistenceCursor;
+}
+
+/** Options for the D161 graph-bound persistence sidecar over a reactive collection. */
+export interface PersistReactiveCollectionOptions<K extends PersistableKind = PersistableKind> {
+	readonly kind: K;
+	readonly name?: string;
+	readonly snapshotStore: KvStorageTier<unknown>;
+	readonly snapshotKey?: string;
+	readonly storagePrefix?: string;
+	readonly changeLog?: AppendLogStorageTier<unknown>;
+	/** Adapter write cursor seed for wrappers that already folded a change log. */
+	readonly initialChangeCursor?: number;
+	/** Default true: write one durable baseline when the adapter attaches. */
+	readonly snapshotOnAttach?: boolean;
+	/** Optional snapshot cadence. Manual snapshots remain available via handle.snapshot(). */
+	readonly snapshotEveryChanges?: number;
+}
+
+/** D161 sidecar controls; flush waits for queued storage promises to settle, not fsync. */
+export interface ReactiveCollectionPersistenceHandle {
+	readonly ready: StateNode<boolean>;
+	readonly status: StateNode<ReactiveCollectionPersistenceStatus>;
+	readonly error: StateNode<ReactiveCollectionPersistenceError | null>;
+	readonly cursor: StateNode<ReactiveCollectionPersistenceCursor>;
+	flush(done?: (status: ReactiveCollectionPersistenceStatus) => void): void;
+	snapshot(done?: (status: ReactiveCollectionPersistenceStatus) => void): void;
+	dispose(done?: (status: ReactiveCollectionPersistenceStatus) => void): void;
+}
+
+interface QueueItem {
+	readonly phase: "snapshot" | "change" | "flush" | "dispose";
+	readonly done?: (status: ReactiveCollectionPersistenceStatus) => void;
+	run(): void | PromiseLike<void>;
+}
+
+function emptyCursor(collection: PersistableKind): ReactiveCollectionPersistenceCursor {
+	return {
+		kind: "persistence.cursor",
+		collection,
+		changeSeq: -1,
+		snapshotWrites: 0,
+		changeWrites: 0,
+	};
+}
+
+function errorMessage(error: unknown): string {
+	return error instanceof Error ? error.message : String(error);
+}
+
+function validateSnapshotEveryChanges(value: number | undefined): number | undefined {
+	if (value === undefined) return undefined;
+	if (!Number.isSafeInteger(value) || value < 1) {
+		throw new RangeError("snapshotEveryChanges must be a positive safe integer");
+	}
+	return value;
+}
+
+function validateInitialChangeCursor(value: number | undefined): number {
+	if (value === undefined) return -1;
+	if (!Number.isSafeInteger(value) || value < -1) {
+		throw new RangeError("initialChangeCursor must be a safe integer >= -1");
+	}
+	return value;
+}
+
+function statusOf(
+	state: ReactiveCollectionPersistenceStatus["state"],
+	pending: number,
+	writes: number,
+	errors: number,
+	cursor: ReactiveCollectionPersistenceCursor,
+): ReactiveCollectionPersistenceStatus {
+	return { state, pending, writes, errors, cursor };
+}
+
+function dataOf<C>(msg: Message): C | undefined {
+	return msg[0] === "DATA" ? (msg[1] as C) : undefined;
+}
+
+/**
+ * D161 graph-bound sidecar over an existing collection. It writes passive storage frames and
+ * exposes adapter progress as graph-visible DATA facts; it never restores or mutates the collection.
+ */
+export function persistReactiveCollection<T, K extends PersistableKind>(
+	graph: Graph,
+	collection: PersistableCollection<T, K>,
+	opts: PersistReactiveCollectionOptions<K>,
+): ReactiveCollectionPersistenceHandle {
+	const kind = opts.kind;
+	const name = opts.name ?? `${kind}.persistence`;
+	const snapshotKey = opts.snapshotKey ?? collectionSnapshotKey(opts.storagePrefix ?? name);
+	const snapshotEveryChanges = validateSnapshotEveryChanges(opts.snapshotEveryChanges);
+	assertGraphLocalNode(graph, collection.delta as Node<unknown>, `${name}.collection.delta`);
+	assertGraphLocalNode(graph, collection.snapshot as Node<unknown>, `${name}.collection.snapshot`);
+
+	let cursorValue = {
+		...emptyCursor(kind),
+		changeSeq: validateInitialChangeCursor(opts.initialChangeCursor),
+	};
+	let statusValue = statusOf("starting", 0, 0, 0, cursorValue);
+	let errorCount = 0;
+	let writes = 0;
+	let observedChangesSinceSnapshot = 0;
+	let running = false;
+	let disposed = false;
+	let disposeRequested = false;
+	let subscribing = true;
+	let stop: (() => void) | undefined;
+	const queue: QueueItem[] = [];
+
+	const ready = graph.state(false, { name: `${name}/ready` });
+	const status = graph.state<ReactiveCollectionPersistenceStatus>(statusValue, {
+		name: `${name}/status`,
+	});
+	const error = graph.state<ReactiveCollectionPersistenceError | null>(null, {
+		name: `${name}/error`,
+	});
+	const cursor = graph.state<ReactiveCollectionPersistenceCursor>(cursorValue, {
+		name: `${name}/cursor`,
+	});
+
+	function publish(state: ReactiveCollectionPersistenceStatus["state"]): void {
+		const nextState = statusValue.state === "errored" && state !== "disposed" ? "errored" : state;
+		statusValue = statusOf(
+			nextState,
+			queue.length + (running ? 1 : 0),
+			writes,
+			errorCount,
+			cursorValue,
+		);
+		cursor.set(cursorValue);
+		status.set(statusValue);
+		if (nextState === "ready") ready.set(true);
+		if (nextState === "errored" || nextState === "disposed") ready.set(false);
+	}
+
+	function report(phase: "snapshot" | "change", caught: unknown): void {
+		errorCount += 1;
+		const fact = { phase, message: errorMessage(caught), cursor: cursorValue };
+		error.set(fact);
+	}
+
+	function callDone(done: QueueItem["done"]): void {
+		try {
+			done?.(statusValue);
+		} catch {
+			// Done callbacks are advisory barriers; user code must not wedge the adapter queue.
+		}
+	}
+
+	function finish(item: QueueItem): void {
+		if (item.phase === "dispose") {
+			disposed = true;
+			running = false;
+			publish("disposed");
+		} else if (statusValue.state !== "errored") {
+			running = false;
+			publish("ready");
+		} else {
+			running = false;
+			publish("errored");
+		}
+		callDone(item.done);
+		drain();
+	}
+
+	function fail(item: QueueItem, caught: unknown): void {
+		if (item.phase === "snapshot" || item.phase === "change") report(item.phase, caught);
+		running = false;
+		if (item.phase === "snapshot" || item.phase === "change") publish("errored");
+		callDone(item.done);
+		drain();
+	}
+
+	function chainThenable(item: QueueItem, value: unknown): boolean {
+		if ((typeof value !== "object" && typeof value !== "function") || value === null) return false;
+		let then: unknown;
+		try {
+			then = (value as { then?: unknown }).then;
+		} catch (caught) {
+			fail(item, caught);
+			return true;
+		}
+		if (typeof then !== "function") return false;
+		let settled = false;
+		const settle = (next: () => void) => {
+			if (settled) return;
+			settled = true;
+			next();
+		};
+		try {
+			(then as (onFulfilled: () => void, onRejected: (error: unknown) => void) => unknown).call(
+				value,
+				() => settle(() => finish(item)),
+				(caught) => settle(() => fail(item, caught)),
+			);
+		} catch (caught) {
+			settle(() => fail(item, caught));
+		}
+		return true;
+	}
+
+	function enqueue(item: QueueItem): void {
+		if (disposed || (disposeRequested && item.phase !== "dispose" && item.phase !== "flush")) {
+			callDone(item.done);
+			return;
+		}
+		queue.push(item);
+		drain();
+	}
+
+	function drain(): void {
+		if (running) return;
+		const item = queue.shift();
+		if (item === undefined) return;
+		running = true;
+		publish(
+			item.phase === "flush" ? "flushing" : statusValue.state === "starting" ? "starting" : "ready",
+		);
+		let result: void | PromiseLike<void>;
+		try {
+			result = item.run();
+		} catch (caught) {
+			fail(item, caught);
+			return;
+		}
+		if (chainThenable(item, result)) return;
+		finish(item);
+	}
+
+	function enqueueSnapshot(done?: (status: ReactiveCollectionPersistenceStatus) => void): void {
+		const snapshot = collectionSnapshot(collection, kind);
+		observedChangesSinceSnapshot = 0;
+		enqueue({
+			phase: "snapshot",
+			done,
+			run() {
+				const frame: ReactiveCollectionSnapshotFrame<K, readonly unknown[]> =
+					reactiveCollectionSnapshotFrame(kind, snapshot, {
+						changeCursor: cursorValue.changeSeq,
+					});
+				assertReactiveCollectionSnapshotFrame(frame, kind);
+				return opts.snapshotStore.set(snapshotKey, frame).then(() => {
+					cursorValue = {
+						...cursorValue,
+						snapshotWrites: cursorValue.snapshotWrites + 1,
+					};
+					writes += 1;
+					publish("ready");
+				});
+			},
+		});
+	}
+
+	function enqueueChange(change: PersistableChange<T, K>): void {
+		const changeLog = opts.changeLog;
+		if (changeLog === undefined) return;
+		enqueue({
+			phase: "change",
+			run() {
+				const frame: ReactiveCollectionChangeFrame<
+					PersistableKind,
+					PersistableChange<T, K>
+				> = reactiveCollectionChangeFrame(kind, change);
+				assertReactiveCollectionChangeFrame(frame, kind);
+				return changeLog.append(frame).then((written) => {
+					const entry = written as AppendLogEntry<
+						ReactiveCollectionChangeFrame<PersistableKind, PersistableChange<T, K>>
+					>;
+					cursorValue = {
+						...cursorValue,
+						changeSeq: entry.seq,
+						changeWrites: cursorValue.changeWrites + 1,
+					};
+					writes += 1;
+					publish("ready");
+				});
+			},
+		});
+	}
+
+	function cancelQueuedForDispose(): void {
+		const pending = queue.splice(0);
+		for (const item of pending) callDone(item.done);
+	}
+
+	stop = (collection.delta as Node<PersistableChange<T, K>>).subscribe(
+		(msg: Message, delivery?: DeliveryMeta) => {
+			if (disposeRequested) return;
+			const change = dataOf<PersistableChange<T, K>>(msg);
+			if (change === undefined) return;
+			if (subscribing && delivery === undefined) return;
+			observedChangesSinceSnapshot += 1;
+			enqueueChange(change);
+			if (
+				snapshotEveryChanges !== undefined &&
+				observedChangesSinceSnapshot >= snapshotEveryChanges
+			) {
+				enqueueSnapshot();
+			}
+		},
+	);
+	subscribing = false;
+
+	if (opts.snapshotOnAttach !== false) enqueueSnapshot();
+	else publish("ready");
+
+	return {
+		ready,
+		status,
+		error,
+		cursor,
+		flush(done?: (status: ReactiveCollectionPersistenceStatus) => void): void {
+			if (disposed) {
+				callDone(done);
+				return;
+			}
+			enqueue({ phase: "flush", done, run: () => undefined });
+		},
+		snapshot(done?: (status: ReactiveCollectionPersistenceStatus) => void): void {
+			if (disposed || disposeRequested) {
+				callDone(done);
+				return;
+			}
+			enqueueSnapshot(done);
+		},
+		dispose(done?: (status: ReactiveCollectionPersistenceStatus) => void): void {
+			if (disposed) {
+				callDone(done);
+				return;
+			}
+			disposeRequested = true;
+			stop?.();
+			cancelQueuedForDispose();
+			enqueue({ phase: "dispose", done, run: () => undefined });
+		},
+	};
+}
+
+function collectionSnapshot<T, K extends PersistableKind>(
+	collection: PersistableCollection<T, K>,
+	kind: K,
+): readonly unknown[] {
+	if (kind === "reactiveMap") {
+		return [...(collection as ReactiveMap<unknown, unknown>).toMap()];
+	}
+	if (kind === "reactiveIndex") {
+		return (collection as ReactiveIndex<unknown, unknown>).toArray();
+	}
+	return (collection as ReactiveList<T> | ReactiveLog<T>).toArray();
+}
+
+type CollectionOptionsWithoutGraphName<T> = Omit<T, "graph" | "name">;
+
+/** Options for D161 load -> restore -> persist composition for reactiveList. */
+export interface OpenPersistentReactiveListOptions<T>
+	extends LoadReactiveCollectionStateOptions,
+		Omit<
+			PersistReactiveCollectionOptions<"reactiveList">,
+			"kind" | "snapshotStore" | "changeLog" | "initialChangeCursor"
+		> {
+	readonly graph: Graph;
+	readonly name?: string;
+	readonly initial?: readonly T[];
+	readonly collection?: CollectionOptionsWithoutGraphName<ReactiveListOptions>;
+}
+
+/** Options for D161 load -> restore -> persist composition for reactiveLog. */
+export interface OpenPersistentReactiveLogOptions<T>
+	extends LoadReactiveCollectionStateOptions,
+		Omit<
+			PersistReactiveCollectionOptions<"reactiveLog">,
+			"kind" | "snapshotStore" | "changeLog" | "initialChangeCursor"
+		> {
+	readonly graph: Graph;
+	readonly name?: string;
+	readonly initial?: readonly T[];
+	readonly collection?: CollectionOptionsWithoutGraphName<ReactiveLogOptions>;
+}
+
+/** Options for D161 load -> restore -> persist composition for reactiveMap. */
+export interface OpenPersistentReactiveMapOptions<K, V>
+	extends LoadReactiveCollectionStateOptions,
+		Omit<
+			PersistReactiveCollectionOptions<"reactiveMap">,
+			"kind" | "snapshotStore" | "changeLog" | "initialChangeCursor"
+		> {
+	readonly graph: Graph;
+	readonly name?: string;
+	readonly initial?: readonly (readonly [K, V])[];
+	readonly collection?: CollectionOptionsWithoutGraphName<ReactiveMapOptions<K, V>>;
+}
+
+/** Options for D161 load -> restore -> persist composition for reactiveIndex. */
+export interface OpenPersistentReactiveIndexOptions<K, V>
+	extends LoadReactiveCollectionStateOptions,
+		Omit<
+			PersistReactiveCollectionOptions<"reactiveIndex">,
+			"kind" | "snapshotStore" | "changeLog" | "initialChangeCursor"
+		> {
+	readonly graph: Graph;
+	readonly name?: string;
+	readonly initial?: readonly IndexRow<K, V>[];
+	readonly collection?: CollectionOptionsWithoutGraphName<ReactiveIndexOptions>;
+}
+
+/** Return value for D161 persistent reactiveList composition. */
+export interface PersistentReactiveList<T> {
+	readonly collection: ReactiveList<T>;
+	readonly persistence: ReactiveCollectionPersistenceHandle;
+	readonly loaded: ReactiveListRestoreState<T>;
+}
+
+/** Return value for D161 persistent reactiveLog composition. */
+export interface PersistentReactiveLog<T> {
+	readonly collection: ReactiveLog<T>;
+	readonly persistence: ReactiveCollectionPersistenceHandle;
+	readonly loaded: ReactiveLogRestoreState<T>;
+}
+
+/** Return value for D161 persistent reactiveMap composition. */
+export interface PersistentReactiveMap<K, V> {
+	readonly collection: ReactiveMap<K, V>;
+	readonly persistence: ReactiveCollectionPersistenceHandle;
+	readonly loaded: ReactiveMapRestoreState<K, V>;
+}
+
+/** Return value for D161 persistent reactiveIndex composition. */
+export interface PersistentReactiveIndex<K, V> {
+	readonly collection: ReactiveIndex<K, V>;
+	readonly persistence: ReactiveCollectionPersistenceHandle;
+	readonly loaded: ReactiveIndexRestoreState<K, V>;
+}
+
+/** D161 convenience wrapper: passive load, sync restoreReactiveList, then sidecar persist. */
+export function openPersistentReactiveList<T = unknown>(
+	opts: OpenPersistentReactiveListOptions<T>,
+): Promise<PersistentReactiveList<T>> {
+	const storagePrefix = opts.storagePrefix ?? opts.name ?? "reactive-collection";
+	const snapshotKey = opts.snapshotKey ?? collectionSnapshotKey(storagePrefix);
+	const loadOpts = { ...opts, snapshotKey, storagePrefix };
+	return loadReactiveListState<T>(loadOpts).then((loaded) => {
+		const state =
+			loaded.source === "empty" && opts.initial !== undefined
+				? { ...loaded, state: opts.initial }
+				: loaded;
+		const collection = restoreReactiveList<T>(state, {
+			...(opts.collection ?? {}),
+			graph: opts.graph,
+			name: opts.name,
+		});
+		const persistence = persistReactiveCollection<T, "reactiveList">(opts.graph, collection, {
+			...opts,
+			kind: "reactiveList",
+			name: opts.name ? `${opts.name}/persistence` : undefined,
+			snapshotKey,
+			storagePrefix,
+			initialChangeCursor: loaded.changes.cursor,
+		});
+		return { collection, persistence, loaded };
+	});
+}
+
+/** D161 convenience wrapper: passive load, sync restoreReactiveLog, then sidecar persist. */
+export function openPersistentReactiveLog<T = unknown>(
+	opts: OpenPersistentReactiveLogOptions<T>,
+): Promise<PersistentReactiveLog<T>> {
+	const storagePrefix = opts.storagePrefix ?? opts.name ?? "reactive-collection";
+	const snapshotKey = opts.snapshotKey ?? collectionSnapshotKey(storagePrefix);
+	const loadOpts = { ...opts, snapshotKey, storagePrefix };
+	return loadReactiveLogState<T>(loadOpts).then((loaded) => {
+		const state =
+			loaded.source === "empty" && opts.initial !== undefined
+				? { ...loaded, state: opts.initial }
+				: loaded;
+		const collection = restoreReactiveLog<T>(state, {
+			...(opts.collection ?? {}),
+			graph: opts.graph,
+			name: opts.name,
+		});
+		const persistence = persistReactiveCollection<T, "reactiveLog">(opts.graph, collection, {
+			...opts,
+			kind: "reactiveLog",
+			name: opts.name ? `${opts.name}/persistence` : undefined,
+			snapshotKey,
+			storagePrefix,
+			initialChangeCursor: loaded.changes.cursor,
+		});
+		return { collection, persistence, loaded };
+	});
+}
+
+/** D161 convenience wrapper: passive load, sync restoreReactiveMap, then sidecar persist. */
+export function openPersistentReactiveMap<K = unknown, V = unknown>(
+	opts: OpenPersistentReactiveMapOptions<K, V>,
+): Promise<PersistentReactiveMap<K, V>> {
+	const storagePrefix = opts.storagePrefix ?? opts.name ?? "reactive-collection";
+	const snapshotKey = opts.snapshotKey ?? collectionSnapshotKey(storagePrefix);
+	const loadOpts = { ...opts, snapshotKey, storagePrefix };
+	return loadReactiveMapState<K, V>(loadOpts).then((loaded) => {
+		const state =
+			loaded.source === "empty" && opts.initial !== undefined
+				? { ...loaded, state: opts.initial }
+				: loaded;
+		const collection = restoreReactiveMap<K, V>(state, {
+			...(opts.collection ?? {}),
+			graph: opts.graph,
+			name: opts.name,
+		});
+		const persistence = persistReactiveCollection<V, "reactiveMap">(opts.graph, collection, {
+			...opts,
+			kind: "reactiveMap",
+			name: opts.name ? `${opts.name}/persistence` : undefined,
+			snapshotKey,
+			storagePrefix,
+			initialChangeCursor: loaded.changes.cursor,
+		});
+		return { collection, persistence, loaded };
+	});
+}
+
+/** D161 convenience wrapper: passive load, sync restoreReactiveIndex, then sidecar persist. */
+export function openPersistentReactiveIndex<K = unknown, V = unknown>(
+	opts: OpenPersistentReactiveIndexOptions<K, V>,
+): Promise<PersistentReactiveIndex<K, V>> {
+	const storagePrefix = opts.storagePrefix ?? opts.name ?? "reactive-collection";
+	const snapshotKey = opts.snapshotKey ?? collectionSnapshotKey(storagePrefix);
+	const loadOpts = { ...opts, snapshotKey, storagePrefix };
+	return loadReactiveIndexState<K, V>(loadOpts).then((loaded) => {
+		const state =
+			loaded.source === "empty" && opts.initial !== undefined
+				? { ...loaded, state: opts.initial }
+				: loaded;
+		const collection = restoreReactiveIndex<K, V>(state, {
+			...(opts.collection ?? {}),
+			graph: opts.graph,
+			name: opts.name,
+		});
+		const persistence = persistReactiveCollection<V, "reactiveIndex">(opts.graph, collection, {
+			...opts,
+			kind: "reactiveIndex",
+			name: opts.name ? `${opts.name}/persistence` : undefined,
+			snapshotKey,
+			storagePrefix,
+			initialChangeCursor: loaded.changes.cursor,
+		});
+		return { collection, persistence, loaded };
+	});
+}
diff --git a/packages/ts/src/adapters/solid.ts b/packages/ts/src/adapters/solid.ts
new file mode 100644
index 00000000..72fbe4c6
--- /dev/null
+++ b/packages/ts/src/adapters/solid.ts
@@ -0,0 +1,61 @@
+/**
+ * Solid node bindings for GraphReFly (D238).
+ *
+ * Solid is imported only from this focused subpath.
+ */
+
+import { type Accessor, createSignal, onCleanup } from "solid-js";
+import type { Node } from "../node/node.js";
+import { readableStore, recordReadableStore, type WritableNode } from "./store.js";
+
+function assertDataValue(value: unknown): void {
+	if (value === undefined) {
+		throw new TypeError(
+			"createNodeInput: undefined is SENTINEL/no DATA, not a writable DATA value",
+		);
+	}
+}
+
+function bindReadable<T>(store: { get(): T; subscribe(run: (value: T) => void): () => void }) {
+	const [value, setValue] = createSignal<T>(store.get());
+	const unsubscribe = store.subscribe((next) => {
+		setValue(() => next);
+	});
+	onCleanup(unsubscribe);
+	return value;
+}
+
+/** Read a GraphReFly node as a Solid accessor. */
+export function createNodeValue<T>(node: Node<T>): Accessor<T | undefined> {
+	return bindReadable(readableStore(node));
+}
+
+/** Bind a writable GraphReFly node as `[valueAccessor, setValue]`. */
+export function createNodeInput<T>(
+	node: WritableNode<T>,
+): readonly [Accessor<T | undefined>, (value: T) => void] {
+	return [
+		createNodeValue(node),
+		(value: T) => {
+			assertDataValue(value);
+			node.set(value);
+		},
+	] as const;
+}
+
+/**
+ * Read a keyed record of nodes as a Solid accessor.
+ *
+ * `factory` must have stable identity; callers should define it outside render
+ * churn or memoize it in their component setup.
+ */
+export function createNodeRecord<K extends string, R extends Record<string, unknown>>(
+	keysNode: Node<readonly K[]>,
+	factory: (key: K) => { [P in keyof R]: Node<R[P]> },
+): Accessor<Record<K, R>> {
+	const store = recordReadableStore(keysNode, factory);
+	return bindReadable({
+		get: () => store.get() ?? ({} as Record<K, R>),
+		subscribe: (run) => store.subscribe((value) => run(value ?? ({} as Record<K, R>))),
+	});
+}
diff --git a/packages/ts/src/adapters/store.ts b/packages/ts/src/adapters/store.ts
new file mode 100644
index 00000000..cca2ed0e
--- /dev/null
+++ b/packages/ts/src/adapters/store.ts
@@ -0,0 +1,404 @@
+/**
+ * Framework-neutral store adapters.
+ *
+ * Focused framework bindings build on this tiny Node-facing layer without
+ * importing framework packages into the dependency-free adapters barrel
+ * (D125/D238).
+ */
+
+import type { DeliveryMeta, Sink } from "../ctx/types.js";
+import type { Node } from "../node/node.js";
+
+/** A minimal readable store contract shared by Svelte/Nanostores-style adapters. */
+export interface ReadableStore<T> {
+	get(): T | undefined;
+	subscribe(run: (value: T | undefined) => void): () => void;
+}
+
+/** A minimal writable store contract over a clean-slate writable node. */
+export interface WritableStore<T> extends ReadableStore<T> {
+	set(value: T): void;
+	update(fn: (value: T | undefined) => T): void;
+}
+
+/** React `useSyncExternalStore`-compatible shape, without importing React. */
+export interface ExternalStore<T> {
+	getSnapshot(): T | undefined;
+	getServerSnapshot(): T | undefined;
+	subscribe(onStoreChange: () => void): () => void;
+}
+
+/** Object-of-nodes factory used by record subscription adapters. */
+export type NodeRecordFactory<K extends string, R extends Record<string, unknown>> = (key: K) => {
+	[P in keyof R]: Node<R[P]>;
+};
+
+/** Zustand-compatible store API over a caller-owned clean-slate state node. */
+export interface ZustandStoreApi<T extends object> {
+	getState(): T;
+	setState(partial: T | Partial<T> | ((state: T) => T | Partial<T>), replace?: boolean): void;
+	getInitialState(): T;
+	subscribe(listener: (state: T, prevState: T) => void): () => void;
+	destroy(): void;
+}
+
+/** Jotai-style atom facade over a caller-owned node. */
+export interface JotaiAtom<T> {
+	get(): T | undefined;
+	subscribe(callback: (value: T | undefined) => void): () => void;
+	readonly _node: Node<T>;
+}
+
+/** Writable Jotai-style atom facade over a caller-owned writable node. */
+export interface WritableJotaiAtom<T> extends JotaiAtom<T> {
+	set(value: T): void;
+	update(fn: (value: T | undefined) => T): void;
+}
+
+/** Nanostores-style atom facade over a caller-owned node. */
+export interface NanoAtom<T> {
+	get(): T | undefined;
+	subscribe(callback: (value: T | undefined) => void): () => void;
+	listen(callback: (value: T | undefined) => void): () => void;
+	readonly _node: Node<T>;
+}
+
+/** Writable Nanostores-style atom facade over a caller-owned writable node. */
+export interface WritableNanoAtom<T> extends NanoAtom<T> {
+	set(value: T): void;
+	update(fn: (value: T | undefined) => T): void;
+}
+
+/** TC39-Signals-style facade over a caller-owned node. */
+export interface SignalLike<T> {
+	get(): T | undefined;
+	subscribe(callback: (value: T | undefined) => void): () => void;
+	readonly _node: Node<T>;
+}
+
+/** Writable TC39-Signals-style facade over a caller-owned writable node. */
+export interface WritableSignalLike<T> extends SignalLike<T> {
+	set(value: T): void;
+	update(fn: (value: T | undefined) => T): void;
+}
+
+export interface SubscribeValuesOptions<T> {
+	/** Emit the current cache snapshot immediately. `undefined` means SENTINEL/no DATA. */
+	immediate?: boolean;
+	/** Suppress synchronous push-on-subscribe/replay DATA. Useful for change-only store listeners. */
+	changesOnly?: boolean;
+	onError?: (error: unknown) => void;
+	onComplete?: () => void;
+	/** Custom cache reader for wrappers that keep their own snapshot object. */
+	getSnapshot?: () => T | undefined;
+}
+
+export interface WritableNode<T> extends Node<T> {
+	set(value: T): void;
+}
+
+export interface WritableStoreOptions<T> extends SubscribeValuesOptions<T> {
+	/** Override writes for adapters that need a framework-owned reducer. */
+	write?: (node: WritableNode<T>, value: T) => void;
+}
+
+/** Read a node cache without activating it. */
+export function nodeSnapshot<T>(node: Node<T>): T | undefined {
+	return node.cache as T | undefined;
+}
+
+/**
+ * Subscribe to DATA values from a Node. Protocol internals stay below the adapter boundary:
+ * DATA drives value listeners, ERROR/COMPLETE route to optional lifecycle callbacks.
+ */
+export function subscribeNodeValues<T>(
+	node: Node<T>,
+	run: (value: T | undefined) => void,
+	opts: SubscribeValuesOptions<T> = {},
+): () => void {
+	const read = opts.getSnapshot ?? (() => nodeSnapshot(node));
+	if (opts.immediate) run(read());
+
+	let subscribing = true;
+	const skipSynchronousHandshakeData = opts.changesOnly || opts.immediate;
+	const sink: Sink = (msg, delivery?: DeliveryMeta) => {
+		switch (msg[0]) {
+			case "DATA":
+				if (skipSynchronousHandshakeData && subscribing && delivery === undefined) {
+					return;
+				}
+				run(msg[1] as T);
+				return;
+			case "ERROR":
+				opts.onError?.(msg[1]);
+				return;
+			case "COMPLETE":
+				opts.onComplete?.();
+				return;
+		}
+	};
+	const unsubscribe = node.subscribe(sink);
+	subscribing = false;
+	return unsubscribe;
+}
+
+/** Build a Svelte/Nanostores-style readable store from a clean-slate Node. */
+export function readableStore<T>(
+	node: Node<T>,
+	opts: SubscribeValuesOptions<T> = {},
+): ReadableStore<T> {
+	return {
+		get: () => (opts.getSnapshot ?? (() => nodeSnapshot(node)))(),
+		subscribe: (run) => subscribeNodeValues(node, run, { immediate: true, ...opts }),
+	};
+}
+
+function hasWritableSet<T>(node: Node<T>): node is WritableNode<T> {
+	return typeof (node as { set?: unknown }).set === "function";
+}
+
+function defaultWrite<T>(node: WritableNode<T>, value: T): void {
+	node.set(value);
+}
+
+/** Build a writable store over a StateNode or compatible clean-slate writable Node. */
+export function writableStore<T>(
+	node: WritableNode<T>,
+	opts?: WritableStoreOptions<T>,
+): WritableStore<T>;
+export function writableStore<T>(
+	node: Node<T>,
+	opts: WritableStoreOptions<T> & { write: (node: WritableNode<T>, value: T) => void },
+): WritableStore<T>;
+export function writableStore<T>(
+	node: Node<T>,
+	opts: WritableStoreOptions<T> = {},
+): WritableStore<T> {
+	const read = opts.getSnapshot ?? (() => nodeSnapshot(node));
+	const write = opts.write ?? (hasWritableSet(node) ? defaultWrite : undefined);
+	if (!write) {
+		throw new TypeError("writableStore: node must expose set(value) or opts.write");
+	}
+	const writable = node as WritableNode<T>;
+	return {
+		get: read,
+		subscribe: (run) => subscribeNodeValues(node, run, { immediate: true, ...opts }),
+		set: (value) => write(writable, value),
+		update: (fn) => write(writable, fn(read())),
+	};
+}
+
+/** Build the tiny shape React's `useSyncExternalStore` expects, without importing React. */
+export function externalStore<T>(
+	node: Node<T>,
+	opts: Pick<SubscribeValuesOptions<T>, "getSnapshot" | "onError" | "onComplete"> = {},
+): ExternalStore<T> {
+	const read = opts.getSnapshot ?? (() => nodeSnapshot(node));
+	return {
+		getSnapshot: read,
+		getServerSnapshot: read,
+		subscribe: (onStoreChange) =>
+			subscribeNodeValues(node, () => onStoreChange(), {
+				changesOnly: true,
+				onError: opts.onError,
+				onComplete: opts.onComplete,
+			}),
+	};
+}
+
+/** Build a framework-neutral keyed record store for focused framework record bindings. */
+export function recordReadableStore<K extends string, R extends Record<string, unknown>>(
+	keysNode: Node<readonly K[]>,
+	factory: NodeRecordFactory<K, R>,
+	opts: SubscribeValuesOptions<Record<K, R>> = {},
+): ReadableStore<Record<K, R>> {
+	const read = () => {
+		const keys = keysNode.cache ?? [];
+		const out = {} as Record<K, R>;
+		for (const key of keys) {
+			const nodes = factory(key);
+			const values = {} as R;
+			for (const field of Object.keys(nodes) as Array<keyof R>) {
+				values[field] = nodes[field].cache as R[keyof R];
+			}
+			out[key] = values;
+		}
+		return out;
+	};
+
+	return {
+		get: read,
+		subscribe(run) {
+			const entryUnsubs: Array<() => void> = [];
+			const cleanupEntries = () => {
+				for (const unsub of entryUnsubs.splice(0)) unsub();
+			};
+			const sync = () => {
+				cleanupEntries();
+				for (const key of keysNode.cache ?? []) {
+					const nodes = factory(key);
+					for (const field of Object.keys(nodes) as Array<keyof R>) {
+						entryUnsubs.push(
+							subscribeNodeValues(nodes[field], () => run(read()), {
+								changesOnly: true,
+								onError: opts.onError,
+								onComplete: opts.onComplete,
+							}),
+						);
+					}
+				}
+				run(read());
+			};
+			const keysUnsub = subscribeNodeValues(keysNode, sync, {
+				changesOnly: true,
+				onError: opts.onError,
+				onComplete: opts.onComplete,
+			});
+			sync();
+			return () => {
+				keysUnsub();
+				cleanupEntries();
+			};
+		},
+	};
+}
+
+/** Build a Zustand-compatible StoreApi over a caller-owned clean-slate state node. */
+export function zustandStore<T extends object>(
+	node: WritableNode<T>,
+	initialState?: T,
+	opts?: WritableStoreOptions<T>,
+): ZustandStoreApi<T>;
+export function zustandStore<T extends object>(
+	node: Node<T>,
+	initialState: T | undefined,
+	opts: WritableStoreOptions<T> & { write: (node: WritableNode<T>, value: T) => void },
+): ZustandStoreApi<T>;
+export function zustandStore<T extends object>(
+	node: Node<T>,
+	initialState: T = nodeSnapshot(node) as T,
+	opts: WritableStoreOptions<T> = {},
+): ZustandStoreApi<T> {
+	const listeners = new Set<() => void>();
+	const read = opts.getSnapshot ?? (() => nodeSnapshot(node));
+	const write = opts.write ?? (hasWritableSet(node) ? defaultWrite : undefined);
+	if (!write) {
+		throw new TypeError("zustandStore: node must expose set(value) or opts.write");
+	}
+	const writable = node as WritableNode<T>;
+	const api: ZustandStoreApi<T> = {
+		getState: () => read() as T,
+		setState(partial, replace) {
+			const prev = api.getState();
+			const next = typeof partial === "function" ? partial(prev) : partial;
+			write(writable, replace ? (next as T) : ({ ...prev, ...next } as T));
+		},
+		getInitialState: () => initialState,
+		subscribe(listener) {
+			let prev = api.getState();
+			const unsub = subscribeNodeValues(
+				node,
+				() => {
+					const next = api.getState();
+					listener(next, prev);
+					prev = next;
+				},
+				{ changesOnly: true, onError: opts.onError, onComplete: opts.onComplete },
+			);
+			listeners.add(unsub);
+			return () => {
+				if (!listeners.delete(unsub)) return;
+				unsub();
+			};
+		},
+		destroy() {
+			for (const unsub of [...listeners]) {
+				listeners.delete(unsub);
+				unsub();
+			}
+		},
+	};
+	return api;
+}
+
+/** Build a Jotai-style atom facade over a caller-owned node. */
+export function jotaiAtom<T>(
+	node: WritableNode<T>,
+	opts?: WritableStoreOptions<T>,
+): WritableJotaiAtom<T>;
+export function jotaiAtom<T>(node: Node<T>, opts?: SubscribeValuesOptions<T>): JotaiAtom<T>;
+export function jotaiAtom<T>(
+	node: Node<T> | WritableNode<T>,
+	opts: SubscribeValuesOptions<T> | WritableStoreOptions<T> = {},
+): JotaiAtom<T> | WritableJotaiAtom<T> {
+	const base: JotaiAtom<T> = {
+		get: () => (opts.getSnapshot ?? (() => nodeSnapshot(node)))(),
+		subscribe: (callback) => subscribeNodeValues(node, callback, { changesOnly: true, ...opts }),
+		_node: node,
+	};
+	if (hasWritableSet(node) || typeof (opts as WritableStoreOptions<T>).write === "function") {
+		const writable = writableStore(
+			node,
+			opts as WritableStoreOptions<T> & {
+				write: (node: WritableNode<T>, value: T) => void;
+			},
+		);
+		return { ...base, set: writable.set, update: writable.update };
+	}
+	return base;
+}
+
+/** Build a Nanostores-style atom facade over a caller-owned node. */
+export function nanoAtom<T>(
+	node: WritableNode<T>,
+	opts?: WritableStoreOptions<T>,
+): WritableNanoAtom<T>;
+export function nanoAtom<T>(node: Node<T>, opts?: SubscribeValuesOptions<T>): NanoAtom<T>;
+export function nanoAtom<T>(
+	node: Node<T> | WritableNode<T>,
+	opts: SubscribeValuesOptions<T> | WritableStoreOptions<T> = {},
+): NanoAtom<T> | WritableNanoAtom<T> {
+	const base: NanoAtom<T> = {
+		get: () => (opts.getSnapshot ?? (() => nodeSnapshot(node)))(),
+		subscribe: (callback) => subscribeNodeValues(node, callback, { immediate: true, ...opts }),
+		listen: (callback) => subscribeNodeValues(node, callback, { changesOnly: true, ...opts }),
+		_node: node,
+	};
+	if (hasWritableSet(node) || typeof (opts as WritableStoreOptions<T>).write === "function") {
+		const writable = writableStore(
+			node,
+			opts as WritableStoreOptions<T> & {
+				write: (node: WritableNode<T>, value: T) => void;
+			},
+		);
+		return { ...base, set: writable.set, update: writable.update };
+	}
+	return base;
+}
+
+/** Build a TC39-Signals-style facade over a caller-owned node. */
+export function signalFromNode<T>(
+	node: WritableNode<T>,
+	opts?: WritableStoreOptions<T>,
+): WritableSignalLike<T>;
+export function signalFromNode<T>(node: Node<T>, opts?: SubscribeValuesOptions<T>): SignalLike<T>;
+export function signalFromNode<T>(
+	node: Node<T> | WritableNode<T>,
+	opts: SubscribeValuesOptions<T> | WritableStoreOptions<T> = {},
+): SignalLike<T> | WritableSignalLike<T> {
+	const base: SignalLike<T> = {
+		get: () => (opts.getSnapshot ?? (() => nodeSnapshot(node)))(),
+		subscribe: (callback) => subscribeNodeValues(node, callback, { changesOnly: true, ...opts }),
+		_node: node,
+	};
+	if (hasWritableSet(node) || typeof (opts as WritableStoreOptions<T>).write === "function") {
+		const writable = writableStore(
+			node,
+			opts as WritableStoreOptions<T> & {
+				write: (node: WritableNode<T>, value: T) => void;
+			},
+		);
+		return { ...base, set: writable.set, update: writable.update };
+	}
+	return base;
+}
diff --git a/packages/ts/src/adapters/svelte.ts b/packages/ts/src/adapters/svelte.ts
new file mode 100644
index 00000000..6e0d3eaf
--- /dev/null
+++ b/packages/ts/src/adapters/svelte.ts
@@ -0,0 +1,65 @@
+/**
+ * Svelte node bindings for GraphReFly (D238).
+ *
+ * Svelte is imported only from this focused subpath.
+ */
+
+import { type Readable, readable } from "svelte/store";
+import type { Node } from "../node/node.js";
+import {
+	nodeSnapshot,
+	recordReadableStore,
+	subscribeNodeValues,
+	type WritableNode,
+} from "./store.js";
+
+/** A Svelte-readable store plus DATA-only write helpers. */
+export interface NodeWritable<T> extends Readable<T | undefined> {
+	set(value: T): void;
+	update(fn: (value: T | undefined) => T): void;
+}
+
+/** Read a GraphReFly node as a Svelte readable store. */
+export function nodeReadable<T>(node: Node<T>): Readable<T | undefined> {
+	return readable<T | undefined>(nodeSnapshot(node), (set) =>
+		subscribeNodeValues(node, set, { immediate: true }),
+	);
+}
+
+function assertDataValue(value: unknown): void {
+	if (value === undefined) {
+		throw new TypeError("nodeWritable: undefined is SENTINEL/no DATA, not a writable DATA value");
+	}
+}
+
+/** Bind a writable GraphReFly node as a Svelte store. */
+export function nodeWritable<T>(node: WritableNode<T>): NodeWritable<T> {
+	const store = nodeReadable(node);
+	return {
+		subscribe: store.subscribe,
+		set(value) {
+			assertDataValue(value);
+			node.set(value);
+		},
+		update(fn) {
+			const next = fn(nodeSnapshot(node));
+			assertDataValue(next);
+			node.set(next);
+		},
+	};
+}
+
+/**
+ * Read a keyed record of nodes as a Svelte readable store.
+ *
+ * `factory` must have stable identity. Recreating it during component churn
+ * rebuilds the record subscriptions.
+ */
+export function nodeRecord<K extends string, R extends Record<string, unknown>>(
+	keysNode: Node<readonly K[]>,
+	factory: (key: K) => { [P in keyof R]: Node<R[P]> },
+): Readable<Record<K, R>> {
+	const store = recordReadableStore(keysNode, factory);
+	const read = () => store.get() ?? ({} as Record<K, R>);
+	return readable(read(), (set) => store.subscribe((value) => set(value ?? ({} as Record<K, R>))));
+}
diff --git a/packages/ts/src/adapters/vue.ts b/packages/ts/src/adapters/vue.ts
new file mode 100644
index 00000000..1c946da8
--- /dev/null
+++ b/packages/ts/src/adapters/vue.ts
@@ -0,0 +1,59 @@
+/**
+ * Vue node bindings for GraphReFly (D238).
+ *
+ * Vue is imported only from this focused subpath.
+ */
+
+import { onScopeDispose, readonly, type ShallowRef, shallowRef } from "vue";
+import type { Node } from "../node/node.js";
+import { readableStore, recordReadableStore, type WritableNode } from "./store.js";
+
+function assertDataValue(value: unknown): void {
+	if (value === undefined) {
+		throw new TypeError("useNodeInput: undefined is SENTINEL/no DATA, not a writable DATA value");
+	}
+}
+
+function bindReadable<T>(store: { get(): T; subscribe(run: (value: T) => void): () => void }) {
+	const value = shallowRef(store.get()) as ShallowRef<T>;
+	const unsubscribe = store.subscribe((next) => {
+		value.value = next;
+	});
+	onScopeDispose(unsubscribe);
+	return readonly(value) as Readonly<ShallowRef<T>>;
+}
+
+/** Read a GraphReFly node as a Vue shallow ref. */
+export function useNodeValue<T>(node: Node<T>): Readonly<ShallowRef<T | undefined>> {
+	return bindReadable(readableStore(node));
+}
+
+/** Bind a writable GraphReFly node as `[valueRef, setValue]`. */
+export function useNodeInput<T>(
+	node: WritableNode<T>,
+): readonly [Readonly<ShallowRef<T | undefined>>, (value: T) => void] {
+	return [
+		useNodeValue(node),
+		(value: T) => {
+			assertDataValue(value);
+			node.set(value);
+		},
+	] as const;
+}
+
+/**
+ * Read a keyed record of nodes as a Vue shallow ref.
+ *
+ * `factory` must have stable identity; callers should define it outside render
+ * churn or memoize it in their composition function.
+ */
+export function useNodeRecord<K extends string, R extends Record<string, unknown>>(
+	keysNode: Node<readonly K[]>,
+	factory: (key: K) => { [P in keyof R]: Node<R[P]> },
+): Readonly<ShallowRef<Record<K, R>>> {
+	const store = recordReadableStore(keysNode, factory);
+	return bindReadable({
+		get: () => store.get() ?? ({} as Record<K, R>),
+		subscribe: (run) => store.subscribe((value) => run(value ?? ({} as Record<K, R>))),
+	});
+}
diff --git a/packages/ts/src/batch/batch.ts b/packages/ts/src/batch/batch.ts
new file mode 100644
index 00000000..afe168a0
--- /dev/null
+++ b/packages/ts/src/batch/batch.ts
@@ -0,0 +1,134 @@
+/**
+ * Declarative batch (R-batch-coalesce / D12).
+ *
+ * Inside a batch, DIRTY propagates immediately but the tier-3 settle slice
+ * (DATA/RESOLVED/INVALIDATE) is deferred to commit, so a shared downstream
+ * recomputes ONCE after all batched sources settle. Success -> commit; a thrown
+ * error -> rollback; `bctx.rollback()` is the explicit escape hatch.
+ *
+ * Coalescing note: this kernel coalesces multiple emits to the SAME node within
+ * one batch to the latest tier-3 wave (last-value-wins). Full per-item batch-array
+ * delivery (downstream fn receiving [v1..vK]) is a documented refinement — the
+ * dominant use (coalescing a diamond join to one recompute) is exact here.
+ */
+
+import type { Wave } from "../protocol/messages.js";
+import { dropBoundaryTasksForBatch, enterWave, exitWave } from "./boundary.js";
+
+/** A node target the batch can commit/rollback against (structural, avoids an import cycle). */
+export interface BatchTarget {
+	__commitBatchedWave(wave: Wave): void;
+	__rollbackBatched(): void;
+	__deferBoundary(fn: () => void, batchToken?: object): void;
+}
+
+export interface BatchCtx {
+	/** Discard all deferred emissions in this batch instead of committing. */
+	rollback(): void;
+}
+
+interface ActiveBatch {
+	order: BatchTarget[];
+	deferred: Map<BatchTarget, Wave>;
+	committed: boolean;
+	rolledBack: boolean;
+}
+
+let active: ActiveBatch | null = null;
+let boundaryOwner: ActiveBatch | null = null;
+
+export function currentBatch(): boolean {
+	return active !== null;
+}
+
+export function currentBoundaryBatchToken(): object | undefined {
+	return active ?? boundaryOwner ?? undefined;
+}
+
+/**
+ * Defer a node's tier-3 settle slice into the active batch. Returns true if a batch
+ * captured it; false if there is no active batch (caller emits normally).
+ */
+export function deferToBatch(target: BatchTarget, tier3Wave: Wave): boolean {
+	if (active === null) return false;
+	if (!active.deferred.has(target)) active.order.push(target);
+	active.deferred.set(target, tier3Wave); // last-value coalescing
+	return true;
+}
+
+/**
+ * Defer a topology mutation until after the active batch has committed/rolled back,
+ * but only when this target has an uncommitted settle slice in the current batch.
+ */
+export function deferAfterBatchForTarget(target: BatchTarget, fn: () => void): boolean {
+	if (active === null || !active.deferred.has(target)) return false;
+	const owner = active;
+	target.__deferBoundary(() => {
+		if (owner.committed) fn();
+	}, owner);
+	return true;
+}
+
+function commit(b: ActiveBatch): void {
+	const prev = boundaryOwner;
+	boundaryOwner = b;
+	try {
+		for (const target of b.order) {
+			const wave = b.deferred.get(target);
+			if (wave) target.__commitBatchedWave(wave);
+		}
+		b.committed = true;
+	} catch (e) {
+		dropBoundaryTasksForBatch(b);
+		throw e;
+	} finally {
+		boundaryOwner = prev;
+	}
+}
+
+function rollback(b: ActiveBatch): void {
+	dropBoundaryTasksForBatch(b);
+	for (const target of b.order) target.__rollbackBatched();
+}
+
+/** Run `fn` as a batch (D12). DATA deferred to commit; throw/rollback discards. */
+export function batch<R>(fn: (bctx: BatchCtx) => R): R {
+	// Wave-owner boundary (R-rewire-deferred / D47): bracket the whole batch (fn + commit) so a
+	// ctx.rewireNext issued by a fn that runs during COMMIT drains AFTER the commit, never on the
+	// un-committed view. Inner waves (state.set, commit cascade) nest under this owner.
+	enterWave();
+	try {
+		if (active !== null) {
+			// Nested batch joins the outer frame (one commit at the outermost exit).
+			const outer = active;
+			return fn({
+				rollback: () => {
+					outer.rolledBack = true;
+				},
+			});
+		}
+		const b: ActiveBatch = { order: [], deferred: new Map(), committed: false, rolledBack: false };
+		active = b;
+		const bctx: BatchCtx = {
+			rollback: () => {
+				b.rolledBack = true;
+			},
+		};
+		let result: R;
+		try {
+			result = fn(bctx);
+		} catch (e) {
+			active = null;
+			rollback(b);
+			throw e;
+		}
+		active = null;
+		if (b.rolledBack) rollback(b);
+		else {
+			commit(b);
+		}
+		return result;
+	} finally {
+		exitWave();
+	}
+}
diff --git a/packages/ts/src/batch/boundary.ts b/packages/ts/src/batch/boundary.ts
new file mode 100644
index 00000000..a7358c61
--- /dev/null
+++ b/packages/ts/src/batch/boundary.ts
@@ -0,0 +1,126 @@
+/**
+ * The wave-owner boundary + deferred self-rewire drain (R-rewire-deferred / D47).
+ *
+ * `ctx.rewireNext` defers a node's OWN dep-set mutation to the COMMITTED wave boundary.
+ * The substrate has no such boundary on the raw call stack, so this module establishes one:
+ * a module-global re-entrant DEPTH counter — the TS analogue of the Rust `WaveScope` /
+ * `with_wave_owner` (graphrefly-rs B25, flagged forward-load-bearing for exactly this). JS is
+ * single-threaded and waves are synchronous, so one cascade is on the stack at a time (same
+ * rationale as `batch.ts`'s module-global `active`).
+ *
+ * Every EXTERNAL wave origin brackets its synchronous cascade with {@link enterWave} /
+ * {@link exitWave}: `Node.subscribe`/`Node.down`/`Node.up` (activation, state.set, control),
+ * the async-pool `ctx.down`/`ctx.up` re-entry (which enters via the stashed ctx, NOT the public
+ * method), and `batch()` (so the drain fires AFTER commit). Re-entrant (nested) calls just
+ * inc/dec the counter; only the OUTERMOST exit (depth → 0) DRAINS the deferred-rewire queue.
+ *
+ * B49 migration: the deferred thunks now live on the graph-local NodeCore, not in this module.
+ * This module keeps only the JS call-stack wave-owner depth plus a small FIFO of cores that
+ * have work to drain. Per D22, a graph is the supported single-thread domain; cross-domain
+ * coordination is the async wire bridge (D32), so the queued work for one legal synchronous cascade
+ * belongs to one graph-local core. Standalone nodes keep their private core. Within a core, FIFO
+ * issue order still gives the R-rewire-deferred drain order, and the scheduler records one core
+ * token per queued task so mixed-core legal batches keep their enqueue order. Each queued mutation
+ * runs as a fresh wave whose own `ctx.rewireNext` calls re-enqueue and drain in the same loop.
+ *
+ * C-25 / D110: queued boundary work is tagged with the batch frame that caused it (when any)
+ * plus an owner-readiness predicate. The drain applies only committed, unpaused tasks; rollback
+ * drops the batch's tasks, and paused owners re-schedule their core on final RESUME.
+ * Zero behavior change when no `ctx.rewireNext`/`ctx.upNext` is ever called: the drain is one
+ * empty-queue check per outermost wave (F-PERF).
+ */
+
+import type { NodeCore } from "../node/core.js";
+
+let depth = 0;
+const pendingCores: NodeCore[] = [];
+let pendingHead = 0;
+
+/** Enter a wave cascade (re-entrant). Pair with {@link exitWave} in a try/finally. */
+export function enterWave(): void {
+	depth++;
+}
+
+/** Exit a wave cascade; the OUTERMOST exit (depth → 0) drains the deferred-rewire queue. */
+export function exitWave(): void {
+	depth--;
+	if (depth === 0 && pendingHead < pendingCores.length) drain();
+}
+
+export interface DeferredBoundaryOptions {
+	readonly batchToken?: object;
+	readonly isReady?: () => boolean;
+}
+
+/**
+ * Queue a deferred self-rewire application, drained at the committed boundary
+ * (R-rewire-deferred). The thunk applies one queued mutation to its owning node.
+ */
+export function deferRewire(
+	core: NodeCore,
+	apply: () => void,
+	options: DeferredBoundaryOptions = {},
+): void {
+	core.enqueueBoundaryTask({ apply, batchToken: options.batchToken, isReady: options.isReady });
+	pendingCores.push(core);
+}
+
+/** Re-schedule an existing core queue, used when a final RESUME opens a paused boundary gate. */
+export function scheduleBoundaryDrain(core: NodeCore): void {
+	for (let i = 0; i < core.boundaryTaskCount(); i++) pendingCores.push(core);
+	if (depth === 0 && pendingHead < pendingCores.length) drain();
+}
+
+/** D110: an uncommitted batch cannot leak queued boundary effects. */
+export function dropBoundaryTasksForBatch(batchToken: object): void {
+	const seen = new Set<NodeCore>();
+	for (let i = pendingHead; i < pendingCores.length; i++) {
+		const core = pendingCores[i] as NodeCore;
+		if (seen.has(core)) continue;
+		seen.add(core);
+		core.dropBoundaryTasksForBatch(batchToken);
+	}
+}
+
+function drain(): void {
+	// Each applied rewire runs a fresh wave (its own depth-bracketed cascade) which may itself
+	// enqueue more rewireNext requests — appended and drained by this same FIFO loop
+	// (DrainExactlyOnce). The depth++ around apply() prevents the fresh wave's own outermost
+	// exit from re-entering drain (this loop owns the draining). A net-changing op re-issued
+	// every boundary (oscillation) is a user-level runaway, like an infinite producer — NOT a
+	// substrate-detected error (D47).
+	//
+	// Per-thunk isolation: a thunk whose application throws (e.g. its _applyRewireNext error-route
+	// reaches a throwing external sink) must NOT abandon the rest of the queue — otherwise the
+	// stranded thunks would linger in this module-global queue and drain at an unrelated LATER
+	// wave boundary (a stale, misattributed rewire). Drain every thunk; re-surface the FIRST
+	// escape once the queue is empty so the error stays visible without corrupting the queue.
+	let escaped: { e: unknown } | null = null;
+	while (pendingHead < pendingCores.length) {
+		const core = pendingCores[pendingHead++] as NodeCore;
+		const task = core.shiftBoundaryTask();
+		if (task === undefined) continue;
+		if (task.batchToken !== undefined) {
+			// A stale token means the batch never reached the committed boundary (D110). Rollback
+			// normally removes these before drain; this guard covers commit failures before the
+			// batch frame marks itself committed.
+			const committed = (task.batchToken as { committed?: boolean }).committed === true;
+			if (!committed) continue;
+		}
+		if (task.isReady !== undefined && !task.isReady()) {
+			core.unshiftBoundaryTask(task);
+			continue;
+		}
+		depth++;
+		try {
+			task.apply();
+		} catch (e) {
+			if (escaped === null) escaped = { e };
+		} finally {
+			depth--;
+		}
+	}
+	pendingCores.length = 0;
+	pendingHead = 0;
+	if (escaped !== null) throw escaped.e;
+}
diff --git a/packages/ts/src/composition/index.ts b/packages/ts/src/composition/index.ts
new file mode 100644
index 00000000..8188117e
--- /dev/null
+++ b/packages/ts/src/composition/index.ts
@@ -0,0 +1,12 @@
+export {
+	type DescribeChangeset,
+	type DescribeEvent,
+	type PipeOperator,
+	pipe,
+	type Stratified,
+	type StratifyOptions,
+	type StratifyRule,
+	stratify,
+	stratifyBranch,
+	topologyDiff,
+} from "../graph/composition.js";
diff --git a/packages/ts/src/core/index.ts b/packages/ts/src/core/index.ts
new file mode 100644
index 00000000..b7fbb344
--- /dev/null
+++ b/packages/ts/src/core/index.ts
@@ -0,0 +1,41 @@
+export { type BatchCtx, batch } from "../batch/batch.js";
+export type {
+	Ctx,
+	CtxState,
+	NodeFn,
+	RewireNext,
+	Sink,
+	TerminalData,
+	WaveData,
+} from "../ctx/types.js";
+export {
+	depBatch,
+	depCount,
+	depLatest,
+	depTerminal,
+	depWaves,
+	isTerminalComplete,
+	isTerminalError,
+	isTerminalNone,
+	terminalErrorValue,
+} from "../ctx/types.js";
+export {
+	Dispatcher,
+	defaultDispatcher,
+	type Handle,
+	type HandleStat,
+	type Pool,
+	type PoolKind,
+} from "../dispatcher/index.js";
+export { dynamicNode, Node, type NodeOptions, node, type Status } from "../node/node.js";
+export {
+	defaultNodeVersionHash,
+	type NodeVersion,
+	type NodeVersionHashFn,
+	type NodeVersioningLevel,
+	type NodeVersioningPolicy,
+	type NodeVersionJson,
+	type NodeVersionV0,
+	type NodeVersionV1,
+} from "../node/versioning.js";
+export * from "../protocol/messages.js";
diff --git a/packages/ts/src/cqrs/index.ts b/packages/ts/src/cqrs/index.ts
new file mode 100644
index 00000000..05657b57
--- /dev/null
+++ b/packages/ts/src/cqrs/index.ts
@@ -0,0 +1,880 @@
+/**
+ * Reusable application-infrastructure CQRS helpers (B63 / D125 / D129).
+ *
+ * The bundle is graph-visible facts over ordinary nodes: command DATA facts
+ * enter through a graph-owned command node, command handlers run inside the
+ * dispatched runtime node, and events/status/errors/audit/cursor are derived
+ * facts. It is not a Graph subclass, hidden EventEmitter, saga runtime, or
+ * storage-owned restore surface.
+ */
+
+import { depBatch } from "../ctx/types.js";
+import type { Graph } from "../graph/graph.js";
+import type { Node } from "../node/node.js";
+
+/** Command fact accepted by a CQRS bundle. */
+export interface CqrsCommand<T = unknown> {
+	readonly id: string;
+	readonly type: string;
+	readonly payload: T;
+	readonly aggregateId?: string;
+	readonly correlationId?: string;
+	readonly causationId?: string;
+	readonly metadata?: Record<string, unknown>;
+}
+
+/** Event draft returned by a command handler before the runtime orders it. */
+export interface CqrsEventDraft<T = unknown> {
+	readonly id?: string;
+	readonly type: string;
+	readonly payload: T;
+	readonly aggregateId?: string;
+	readonly correlationId?: string;
+	readonly causationId?: string;
+	readonly metadata?: Record<string, unknown>;
+}
+
+/** Ordered event fact emitted by the CQRS runtime node. */
+export interface CqrsEvent<T = unknown> {
+	readonly id: string;
+	readonly type: string;
+	readonly seq: number;
+	readonly cursor: number;
+	readonly runtimeCursor: CqrsCursor;
+	readonly commandId: string;
+	readonly commandType: string;
+	readonly payload: T;
+	readonly timestampMs: number;
+	readonly aggregateId?: string;
+	readonly correlationId?: string;
+	readonly causationId?: string;
+	readonly metadata?: Record<string, unknown>;
+}
+
+export type CqrsErrorCode =
+	| "malformed-command"
+	| "duplicate-command"
+	| "unknown-command"
+	| "handler-threw"
+	| "clock-threw"
+	| "malformed-event"
+	| "unknown-event"
+	| "duplicate-event";
+
+/** Graph-visible CQRS error fact. These are DATA facts, not protocol ERROR. */
+export interface CqrsError {
+	readonly code: CqrsErrorCode;
+	readonly message: string;
+	readonly command?: unknown;
+	readonly commandId?: string;
+	readonly commandType?: string;
+	readonly event?: unknown;
+	readonly eventType?: string;
+	readonly cursor: CqrsCursor;
+}
+
+export interface CqrsStatus {
+	readonly state: "accepted" | "rejected";
+	readonly commandId?: string;
+	readonly commandType?: string;
+	readonly eventCount: number;
+	readonly errorCode?: CqrsErrorCode;
+	readonly cursor: CqrsCursor;
+}
+
+export interface CqrsAuditRecord {
+	readonly seq: number;
+	readonly commandId?: string;
+	readonly commandType?: string;
+	readonly outcome: "success" | "failure";
+	readonly eventIds: readonly string[];
+	readonly eventTypes: readonly string[];
+	readonly errorCode?: CqrsErrorCode;
+	readonly errorMessage?: string;
+	readonly cursor: CqrsCursor;
+}
+
+export interface CqrsDedupeSnapshot {
+	readonly commandIdsRetained: number;
+	readonly eventIdsRetained: number;
+	readonly commandIdsEvicted: number;
+	readonly eventIdsEvicted: number;
+}
+
+export interface CqrsCursor {
+	readonly eventSeq: number;
+	readonly commandCount: number;
+	readonly errorCount: number;
+	readonly auditSeq: number;
+	readonly dedupe?: CqrsDedupeSnapshot;
+}
+
+export type CqrsRuntimeFact<T = unknown> =
+	| { readonly kind: "event"; readonly event: CqrsEvent<T> }
+	| { readonly kind: "status"; readonly status: CqrsStatus }
+	| { readonly kind: "error"; readonly error: CqrsError }
+	| { readonly kind: "audit"; readonly audit: CqrsAuditRecord }
+	| { readonly kind: "cursor"; readonly cursor: CqrsCursor };
+
+export type CqrsCommandHandler<TCommand = unknown, TEvent = unknown> = (
+	command: CqrsCommand<TCommand>,
+) => readonly CqrsEventDraft<TEvent>[];
+
+export interface CqrsCommandHandlerDefinition<TCommand = unknown, TEvent = unknown> {
+	readonly type: string;
+	readonly handle: CqrsCommandHandler<TCommand, TEvent>;
+}
+
+export interface CqrsOptions<TCommand = unknown, TEvent = unknown> {
+	readonly name?: string;
+	readonly handlers?: readonly CqrsCommandHandlerDefinition<TCommand, TEvent>[];
+	readonly events?: readonly string[];
+	readonly now?: () => number;
+	/**
+	 * D142: static command/event duplicate-recognition windows. Omitted means
+	 * exact unbounded dedupe; bounded windows evict oldest ids by insertion order.
+	 */
+	readonly dedupe?: CqrsDedupePolicy;
+}
+
+/**
+ * D151 membership-based duplicate-recognition window for CQRS ids.
+ *
+ * This is passive CQRS vocabulary, not a shared idempotency reducer engine:
+ * commands and events each own their own id membership window.
+ */
+export type CqrsDedupeWindow = "unbounded" | { readonly maxEntries: number };
+
+export interface CqrsDedupePolicy {
+	readonly commands?: CqrsDedupeWindow;
+	readonly events?: CqrsDedupeWindow;
+}
+
+export interface CqrsBundle<TCommand = unknown, TEvent = unknown> {
+	readonly command: Node<CqrsCommand<TCommand>>;
+	readonly runtime: Node<CqrsRuntimeFact<TEvent>>;
+	readonly events: Node<CqrsEvent<TEvent>>;
+	readonly status: Node<CqrsStatus>;
+	readonly errors: Node<CqrsError>;
+	readonly audit: Node<CqrsAuditRecord>;
+	readonly cursor: Node<CqrsCursor>;
+	dispatch(command: CqrsCommand<TCommand>): CqrsCommand<TCommand>;
+}
+
+interface CqrsRuntimeState {
+	eventSeq: number;
+	commandCount: number;
+	errorCount: number;
+	auditSeq: number;
+	seenCommandIds: string[];
+	seenEventIds: string[];
+	commandDedupeEvicted?: number;
+	eventDedupeEvicted?: number;
+}
+
+interface HandlerRecord {
+	readonly type: string;
+	readonly handle: CqrsCommandHandler<unknown, unknown>;
+}
+
+interface NormalizedCqrsDedupePolicy {
+	readonly commandMaxEntries?: number;
+	readonly eventMaxEntries?: number;
+	readonly bounded: boolean;
+}
+
+/** Convenience helper for declaring typed command handlers in a CQRS bundle. */
+export function cqrsCommandHandler<TCommand = unknown, TEvent = unknown>(
+	type: string,
+	handle: CqrsCommandHandler<TCommand, TEvent>,
+): CqrsCommandHandlerDefinition<TCommand, TEvent> {
+	if (type.length === 0) throw new Error("cqrsCommandHandler: type must be non-empty");
+	return { type, handle };
+}
+
+/**
+ * Create a graph-visible CQRS bundle. Command dispatch is only DATA on the
+ * returned `command` node; all derived facts flow through declared graph deps.
+ */
+export function cqrs<TCommand = unknown, TEvent = unknown>(
+	graph: Graph,
+	opts: CqrsOptions<TCommand, TEvent> = {},
+): CqrsBundle<TCommand, TEvent> {
+	const name = opts.name ?? "cqrs";
+	const handlers = normalizeHandlers(opts.handlers ?? []);
+	const knownEvents =
+		opts.events === undefined ? undefined : new Set(uniqueNames(opts.events, "cqrs.events"));
+	const now = opts.now ?? Date.now;
+	const dedupe = normalizeDedupePolicy(opts.dedupe);
+	const command = graph.node<CqrsCommand<TCommand>>([], null, {
+		name: `${name}/command`,
+		factory: "cqrsCommand",
+		completeWhenDepsComplete: false,
+		errorWhenDepsError: false,
+	});
+	const runtime = graph.node<CqrsRuntimeFact<TEvent>>(
+		[command],
+		(ctx) => {
+			const state =
+				ctx.state.get<CqrsRuntimeState>() ??
+				({
+					eventSeq: 0,
+					commandCount: 0,
+					errorCount: 0,
+					auditSeq: 0,
+					seenCommandIds: [],
+					seenEventIds: [],
+				} satisfies CqrsRuntimeState);
+			ctx.state.persist(true);
+			for (const raw of depBatch(ctx, 0) ?? []) {
+				reduceCommandFact(raw, state, handlers, knownEvents, now, dedupe, (fact) =>
+					ctx.down([["DATA", fact as CqrsRuntimeFact<TEvent>]]),
+				);
+			}
+			ctx.state.set(state);
+		},
+		{
+			name: `${name}/runtime`,
+			factory: "cqrsRuntime",
+			meta: {
+				commandTypes: [...handlers.keys()],
+				eventTypes: knownEvents ? [...knownEvents] : "open",
+				dedupe: dedupeMeta(dedupe),
+			},
+			completeWhenDepsComplete: false,
+			errorWhenDepsError: false,
+		},
+	);
+	const events = runtimeProjection<CqrsEvent<TEvent>, TEvent>(
+		graph,
+		runtime,
+		"event",
+		`${name}/events`,
+		"cqrsEvents",
+		(fact) => (fact.kind === "event" ? fact.event : undefined),
+	);
+	const status = runtimeProjection<CqrsStatus, TEvent>(
+		graph,
+		runtime,
+		"status",
+		`${name}/status`,
+		"cqrsStatus",
+		(fact) => (fact.kind === "status" ? fact.status : undefined),
+	);
+	const errors = runtimeProjection<CqrsError, TEvent>(
+		graph,
+		runtime,
+		"error",
+		`${name}/errors`,
+		"cqrsErrors",
+		(fact) => (fact.kind === "error" ? fact.error : undefined),
+	);
+	const audit = runtimeProjection<CqrsAuditRecord, TEvent>(
+		graph,
+		runtime,
+		"audit",
+		`${name}/audit`,
+		"cqrsAudit",
+		(fact) => (fact.kind === "audit" ? fact.audit : undefined),
+	);
+	const cursor = runtimeProjection<CqrsCursor, TEvent>(
+		graph,
+		runtime,
+		"cursor",
+		`${name}/cursor`,
+		"cqrsCursor",
+		(fact) => (fact.kind === "cursor" ? fact.cursor : undefined),
+	);
+	graph.retain(runtime, { reason: `${name}.cqrs.runtime` });
+	graph.retain(events, { reason: `${name}.cqrs.events` });
+	graph.retain(status, { reason: `${name}.cqrs.status` });
+	graph.retain(errors, { reason: `${name}.cqrs.errors` });
+	graph.retain(audit, { reason: `${name}.cqrs.audit` });
+	graph.retain(cursor, { reason: `${name}.cqrs.cursor` });
+	return {
+		command,
+		runtime,
+		events,
+		status,
+		errors,
+		audit,
+		cursor,
+		dispatch(commandFact) {
+			command.down([["DATA", commandFact]]);
+			return commandFact;
+		},
+	};
+}
+
+export interface CqrsProjectionOptions<TState, TEvent = unknown> {
+	readonly name?: string;
+	readonly events?: readonly string[];
+	readonly initial: TState;
+	readonly reducer: (state: TState, event: CqrsEvent<TEvent>) => TState;
+}
+
+export type CqrsProjectionFrame<TState> =
+	| {
+			readonly kind: "value";
+			readonly state: TState;
+			readonly eventId: string;
+			readonly cursor: CqrsCursor;
+	  }
+	| { readonly kind: "error"; readonly error: CqrsProjectionError };
+
+export interface CqrsProjectionError {
+	readonly code: "projection-threw";
+	readonly message: string;
+	readonly eventId: string;
+	readonly eventType: string;
+	readonly cursor: CqrsCursor;
+}
+
+export interface CqrsProjectionStatus {
+	readonly state: "updated" | "errored";
+	readonly eventId: string;
+	readonly eventType?: string;
+	readonly cursor: CqrsCursor;
+}
+
+export interface CqrsProjection<TState> {
+	readonly frames: Node<CqrsProjectionFrame<TState>>;
+	readonly value: Node<TState>;
+	readonly status: Node<CqrsProjectionStatus>;
+	readonly errors: Node<CqrsProjectionError>;
+}
+
+/**
+ * Derive a projection from declared CQRS event deps. Reducer failures become
+ * graph-visible error DATA facts on the returned `errors` node.
+ */
+export function cqrsProjection<TState, TEvent = unknown>(
+	graph: Graph,
+	source: Pick<CqrsBundle<unknown, TEvent>, "events">,
+	opts: CqrsProjectionOptions<TState, TEvent>,
+): CqrsProjection<TState> {
+	const name = opts.name ?? "cqrsProjection";
+	const eventFilter =
+		opts.events === undefined
+			? undefined
+			: new Set(uniqueNames(opts.events, "cqrsProjection.events"));
+	const frames = graph.node<CqrsProjectionFrame<TState>>(
+		[source.events],
+		(ctx) => {
+			const state = ctx.state.get<{ value: TState }>() ?? { value: opts.initial };
+			ctx.state.persist(true);
+			for (const raw of depBatch(ctx, 0) ?? []) {
+				const event = raw as CqrsEvent<TEvent>;
+				if (eventFilter !== undefined && !eventFilter.has(event.type)) continue;
+				try {
+					state.value = opts.reducer(state.value, event);
+					ctx.state.set(state);
+					ctx.down([
+						[
+							"DATA",
+							{
+								kind: "value",
+								state: state.value,
+								eventId: event.id,
+								cursor: event.runtimeCursor,
+							} satisfies CqrsProjectionFrame<TState>,
+						],
+					]);
+				} catch (error) {
+					rethrowGraphRuntimeInvariant(error);
+					ctx.down([
+						[
+							"DATA",
+							{
+								kind: "error",
+								error: {
+									code: "projection-threw",
+									message: errorMessage(error),
+									eventId: event.id,
+									eventType: event.type,
+									cursor: event.runtimeCursor,
+								},
+							} satisfies CqrsProjectionFrame<TState>,
+						],
+					]);
+					return;
+				}
+			}
+		},
+		{
+			name,
+			factory: "cqrsProjection",
+			meta: { eventTypes: eventFilter ? [...eventFilter] : "open" },
+			completeWhenDepsComplete: false,
+			errorWhenDepsError: false,
+		},
+	);
+	const value = graph.node<TState>(
+		[frames],
+		(ctx) => {
+			for (const frame of depBatch(ctx, 0) ?? []) {
+				const typed = frame as CqrsProjectionFrame<TState>;
+				if (typed.kind === "value") ctx.down([["DATA", typed.state]]);
+			}
+		},
+		{
+			name: `${name}/value`,
+			factory: "cqrsProjectionValue",
+			completeWhenDepsComplete: false,
+			errorWhenDepsError: false,
+		},
+	);
+	const errors = graph.node<CqrsProjectionError>(
+		[frames],
+		(ctx) => {
+			for (const frame of depBatch(ctx, 0) ?? []) {
+				const typed = frame as CqrsProjectionFrame<TState>;
+				if (typed.kind === "error") ctx.down([["DATA", typed.error]]);
+			}
+		},
+		{
+			name: `${name}/errors`,
+			factory: "cqrsProjectionErrors",
+			completeWhenDepsComplete: false,
+			errorWhenDepsError: false,
+		},
+	);
+	const status = graph.node<CqrsProjectionStatus>(
+		[frames],
+		(ctx) => {
+			for (const frame of depBatch(ctx, 0) ?? []) {
+				const typed = frame as CqrsProjectionFrame<TState>;
+				if (typed.kind === "value") {
+					ctx.down([
+						[
+							"DATA",
+							{
+								state: "updated",
+								eventId: typed.eventId,
+								cursor: typed.cursor,
+							} satisfies CqrsProjectionStatus,
+						],
+					]);
+				} else {
+					ctx.down([
+						[
+							"DATA",
+							{
+								state: "errored",
+								eventId: typed.error.eventId,
+								eventType: typed.error.eventType,
+								cursor: typed.error.cursor,
+							} satisfies CqrsProjectionStatus,
+						],
+					]);
+				}
+			}
+		},
+		{
+			name: `${name}/status`,
+			factory: "cqrsProjectionStatus",
+			completeWhenDepsComplete: false,
+			errorWhenDepsError: false,
+		},
+	);
+	graph.retain(frames, { reason: `${name}.cqrsProjection.frames` });
+	graph.retain(value, { reason: `${name}.cqrsProjection.value` });
+	graph.retain(status, { reason: `${name}.cqrsProjection.status` });
+	graph.retain(errors, { reason: `${name}.cqrsProjection.errors` });
+	return { frames, value, status, errors };
+}
+
+function normalizeHandlers<TCommand, TEvent>(
+	definitions: readonly CqrsCommandHandlerDefinition<TCommand, TEvent>[],
+): ReadonlyMap<string, HandlerRecord> {
+	const handlers = new Map<string, HandlerRecord>();
+	for (const definition of definitions) {
+		if (definition.type.length === 0) throw new Error("cqrs: handler type must be non-empty");
+		if (handlers.has(definition.type))
+			throw new Error(`cqrs: duplicate handler '${definition.type}'`);
+		handlers.set(definition.type, {
+			type: definition.type,
+			handle: definition.handle as CqrsCommandHandler<unknown, unknown>,
+		});
+	}
+	return handlers;
+}
+
+function reduceCommandFact<TEvent>(
+	raw: unknown,
+	state: CqrsRuntimeState,
+	handlers: ReadonlyMap<string, HandlerRecord>,
+	knownEvents: ReadonlySet<string> | undefined,
+	now: () => number,
+	dedupe: NormalizedCqrsDedupePolicy,
+	emit: (fact: CqrsRuntimeFact<TEvent>) => void,
+): void {
+	state.commandCount += 1;
+	const parsed = parseCommand(raw);
+	if (typeof parsed === "string") {
+		emitFailure(state, emit, raw, undefined, "malformed-command", parsed, dedupe);
+		return;
+	}
+	const command = parsed as CqrsCommand<unknown>;
+	if (state.seenCommandIds.includes(command.id)) {
+		emitFailure(
+			state,
+			emit,
+			command,
+			command,
+			"duplicate-command",
+			`cqrs: duplicate command '${command.id}'`,
+			dedupe,
+		);
+		return;
+	}
+	state.seenCommandIds.push(command.id);
+	trimDedupeWindow(state.seenCommandIds, dedupe.commandMaxEntries, (evicted) => {
+		state.commandDedupeEvicted = (state.commandDedupeEvicted ?? 0) + evicted;
+	});
+	const handler = handlers.get(command.type);
+	if (handler === undefined) {
+		emitFailure(
+			state,
+			emit,
+			command,
+			command,
+			"unknown-command",
+			`cqrs: unknown command '${command.type}'`,
+			dedupe,
+		);
+		return;
+	}
+	let drafts: readonly CqrsEventDraft<unknown>[];
+	try {
+		drafts = handler.handle(command);
+	} catch (error) {
+		rethrowGraphRuntimeInvariant(error);
+		emitFailure(state, emit, command, command, "handler-threw", errorMessage(error), dedupe);
+		return;
+	}
+	if (!Array.isArray(drafts)) {
+		emitFailure(
+			state,
+			emit,
+			command,
+			command,
+			"malformed-event",
+			"cqrs: command handler must return an event draft array",
+			dedupe,
+		);
+		return;
+	}
+	const prepared = prepareEvents(command, drafts, state, knownEvents);
+	if (typeof prepared === "string") {
+		emitFailure(state, emit, command, command, preparedCode(prepared), prepared, dedupe);
+		return;
+	}
+	const timestampMs = readTimestampMs(now);
+	if (typeof timestampMs === "string") {
+		emitFailure(state, emit, command, command, "clock-threw", timestampMs, dedupe);
+		return;
+	}
+	const events: CqrsEvent<unknown>[] = [];
+	for (const draft of prepared) {
+		state.eventSeq += 1;
+		state.seenEventIds.push(draft.id);
+		trimDedupeWindow(state.seenEventIds, dedupe.eventMaxEntries, (evicted) => {
+			state.eventDedupeEvicted = (state.eventDedupeEvicted ?? 0) + evicted;
+		});
+		const runtimeCursor = cursorOf(state, dedupe);
+		events.push({
+			id: draft.id,
+			type: draft.type,
+			seq: state.eventSeq,
+			cursor: state.eventSeq,
+			runtimeCursor,
+			commandId: command.id,
+			commandType: command.type,
+			payload: draft.payload,
+			timestampMs,
+			...(draft.aggregateId === undefined ? {} : { aggregateId: draft.aggregateId }),
+			...(draft.correlationId === undefined ? {} : { correlationId: draft.correlationId }),
+			...(draft.causationId === undefined ? {} : { causationId: draft.causationId }),
+			...(draft.metadata === undefined ? {} : { metadata: draft.metadata }),
+		});
+	}
+	for (const event of events) emit({ kind: "event", event: event as CqrsEvent<TEvent> });
+	emitStatus(state, emit, command, "accepted", events.length, dedupe);
+	emitAudit(state, emit, command, "success", events, undefined, undefined, dedupe);
+	emit({ kind: "cursor", cursor: cursorOf(state, dedupe) });
+}
+
+function parseCommand(value: unknown): CqrsCommand<unknown> | string {
+	if (!isObjectRecord(value)) return "cqrs: command fact must be an object";
+	if (typeof value.id !== "string" || value.id.length === 0) {
+		return "cqrs: command id must be a non-empty string";
+	}
+	if (typeof value.type !== "string" || value.type.length === 0) {
+		return "cqrs: command type must be a non-empty string";
+	}
+	return {
+		id: value.id,
+		type: value.type,
+		payload: value.payload,
+		...(typeof value.aggregateId === "string" ? { aggregateId: value.aggregateId } : {}),
+		...(typeof value.correlationId === "string" ? { correlationId: value.correlationId } : {}),
+		...(typeof value.causationId === "string" ? { causationId: value.causationId } : {}),
+		...(isObjectRecord(value.metadata) ? { metadata: value.metadata } : {}),
+	};
+}
+
+function prepareEvents(
+	command: CqrsCommand<unknown>,
+	drafts: readonly CqrsEventDraft<unknown>[],
+	state: CqrsRuntimeState,
+	knownEvents: ReadonlySet<string> | undefined,
+): Array<CqrsEventDraft<unknown> & { readonly id: string }> | string {
+	const seenInCommand = new Set<string>();
+	const prepared: Array<CqrsEventDraft<unknown> & { readonly id: string }> = [];
+	for (let i = 0; i < drafts.length; i += 1) {
+		const draft = drafts[i];
+		if (!isObjectRecord(draft) || typeof draft.type !== "string" || draft.type.length === 0) {
+			return "cqrs: event draft must have a non-empty type";
+		}
+		if (knownEvents !== undefined && !knownEvents.has(draft.type)) {
+			return `cqrs: unknown event '${draft.type}'`;
+		}
+		const id =
+			typeof draft.id === "string" && draft.id.length > 0 ? draft.id : `${command.id}:${i + 1}`;
+		if (state.seenEventIds.includes(id) || seenInCommand.has(id)) {
+			return `cqrs: duplicate event '${id}'`;
+		}
+		seenInCommand.add(id);
+		prepared.push({
+			id,
+			type: draft.type,
+			payload: draft.payload,
+			...(typeof draft.aggregateId === "string" ? { aggregateId: draft.aggregateId } : {}),
+			...(typeof draft.correlationId === "string" ? { correlationId: draft.correlationId } : {}),
+			...(typeof draft.causationId === "string" ? { causationId: draft.causationId } : {}),
+			...(isObjectRecord(draft.metadata) ? { metadata: draft.metadata } : {}),
+		});
+	}
+	return prepared;
+}
+
+function preparedCode(message: string): CqrsErrorCode {
+	if (message.includes("unknown event")) return "unknown-event";
+	if (message.includes("duplicate event")) return "duplicate-event";
+	return "malformed-event";
+}
+
+function rethrowGraphRuntimeInvariant(error: unknown): void {
+	const message = errorMessage(error);
+	if (
+		message.includes("R-reentrancy") ||
+		message.includes("R-rewire") ||
+		message.includes("R-graph-domain") ||
+		message.includes("D37") ||
+		message.includes("D22") ||
+		message.includes("different graph") ||
+		message.includes("cross-graph") ||
+		message.includes("wire bridge") ||
+		message.includes("mid-fn topology mutation") ||
+		message.includes("reentrant dep mutation") ||
+		message.includes("feedback cycle")
+	) {
+		throw error;
+	}
+}
+
+function emitFailure<TEvent>(
+	state: CqrsRuntimeState,
+	emit: (fact: CqrsRuntimeFact<TEvent>) => void,
+	raw: unknown,
+	command: CqrsCommand<unknown> | undefined,
+	code: CqrsErrorCode,
+	message: string,
+	dedupe: NormalizedCqrsDedupePolicy,
+): void {
+	state.errorCount += 1;
+	const cursor = cursorOf(state, dedupe);
+	const error: CqrsError = {
+		code,
+		message,
+		command: raw,
+		...(command === undefined ? {} : { commandId: command.id, commandType: command.type }),
+		cursor,
+	};
+	emit({ kind: "error", error });
+	emit({
+		kind: "status",
+		status: {
+			state: "rejected",
+			...(command === undefined ? {} : { commandId: command.id, commandType: command.type }),
+			eventCount: 0,
+			errorCode: code,
+			cursor,
+		},
+	});
+	emitAudit(state, emit, command, "failure", [], code, message, dedupe);
+	emit({ kind: "cursor", cursor: cursorOf(state, dedupe) });
+}
+
+function emitStatus<TEvent>(
+	state: CqrsRuntimeState,
+	emit: (fact: CqrsRuntimeFact<TEvent>) => void,
+	command: CqrsCommand<unknown>,
+	statusState: "accepted" | "rejected",
+	eventCount: number,
+	dedupe: NormalizedCqrsDedupePolicy,
+): void {
+	emit({
+		kind: "status",
+		status: {
+			state: statusState,
+			commandId: command.id,
+			commandType: command.type,
+			eventCount,
+			cursor: cursorOf(state, dedupe),
+		},
+	});
+}
+
+function emitAudit<TEvent>(
+	state: CqrsRuntimeState,
+	emit: (fact: CqrsRuntimeFact<TEvent>) => void,
+	command: CqrsCommand<unknown> | undefined,
+	outcome: "success" | "failure",
+	events: readonly CqrsEvent<unknown>[],
+	errorCode: CqrsErrorCode | undefined,
+	errorMessageValue: string | undefined,
+	dedupe: NormalizedCqrsDedupePolicy,
+): void {
+	state.auditSeq += 1;
+	emit({
+		kind: "audit",
+		audit: {
+			seq: state.auditSeq,
+			...(command === undefined ? {} : { commandId: command.id, commandType: command.type }),
+			outcome,
+			eventIds: Object.freeze(events.map((event) => event.id)),
+			eventTypes: Object.freeze(events.map((event) => event.type)),
+			...(errorCode === undefined ? {} : { errorCode }),
+			...(errorMessageValue === undefined ? {} : { errorMessage: errorMessageValue }),
+			cursor: cursorOf(state, dedupe),
+		},
+	});
+}
+
+function runtimeProjection<TOut, TEvent>(
+	graph: Graph,
+	runtime: Node<CqrsRuntimeFact<TEvent>>,
+	kind: CqrsRuntimeFact<TEvent>["kind"],
+	name: string,
+	factory: string,
+	select: (fact: CqrsRuntimeFact<TEvent>) => TOut | undefined,
+): Node<TOut> {
+	return graph.node<TOut>(
+		[runtime],
+		(ctx) => {
+			for (const fact of depBatch(ctx, 0) ?? []) {
+				const typed = fact as CqrsRuntimeFact<TEvent>;
+				if (typed.kind !== kind) continue;
+				const selected = select(typed);
+				if (selected !== undefined) ctx.down([["DATA", selected]]);
+			}
+		},
+		{
+			name,
+			factory,
+			completeWhenDepsComplete: false,
+			errorWhenDepsError: false,
+		},
+	);
+}
+
+function cursorOf(state: CqrsRuntimeState, dedupe: NormalizedCqrsDedupePolicy): CqrsCursor {
+	return {
+		eventSeq: state.eventSeq,
+		commandCount: state.commandCount,
+		errorCount: state.errorCount,
+		auditSeq: state.auditSeq,
+		...(dedupe.bounded
+			? {
+					dedupe: {
+						commandIdsRetained: state.seenCommandIds.length,
+						eventIdsRetained: state.seenEventIds.length,
+						commandIdsEvicted: state.commandDedupeEvicted ?? 0,
+						eventIdsEvicted: state.eventDedupeEvicted ?? 0,
+					},
+				}
+			: {}),
+	};
+}
+
+function normalizeDedupePolicy(policy: CqrsDedupePolicy | undefined): NormalizedCqrsDedupePolicy {
+	const commandMaxEntries = normalizeDedupeWindow(policy?.commands, "cqrs.dedupe.commands");
+	const eventMaxEntries = normalizeDedupeWindow(policy?.events, "cqrs.dedupe.events");
+	return {
+		...(commandMaxEntries === undefined ? {} : { commandMaxEntries }),
+		...(eventMaxEntries === undefined ? {} : { eventMaxEntries }),
+		bounded: commandMaxEntries !== undefined || eventMaxEntries !== undefined,
+	};
+}
+
+function normalizeDedupeWindow(
+	window: CqrsDedupeWindow | undefined,
+	owner: string,
+): number | undefined {
+	if (window === undefined || window === "unbounded") return undefined;
+	if (!Number.isInteger(window.maxEntries) || window.maxEntries < 0) {
+		throw new RangeError(`${owner}: maxEntries must be a non-negative integer`);
+	}
+	return window.maxEntries;
+}
+
+function dedupeMeta(dedupe: NormalizedCqrsDedupePolicy): unknown {
+	if (!dedupe.bounded) return "unbounded";
+	return {
+		commands:
+			dedupe.commandMaxEntries === undefined
+				? "unbounded"
+				: { maxEntries: dedupe.commandMaxEntries },
+		events:
+			dedupe.eventMaxEntries === undefined ? "unbounded" : { maxEntries: dedupe.eventMaxEntries },
+	};
+}
+
+function trimDedupeWindow(
+	ids: string[],
+	maxEntries: number | undefined,
+	onEvicted: (evicted: number) => void,
+): void {
+	if (maxEntries === undefined || ids.length <= maxEntries) return;
+	const evicted = ids.length - maxEntries;
+	ids.splice(0, evicted);
+	onEvicted(evicted);
+}
+
+function readTimestampMs(now: () => number): number | string {
+	try {
+		const timestampMs = now();
+		return Number.isFinite(timestampMs) ? timestampMs : "cqrs: now() must return a finite number";
+	} catch (error) {
+		return `cqrs: now() threw: ${errorMessage(error)}`;
+	}
+}
+
+function uniqueNames(values: readonly string[], owner: string): readonly string[] {
+	const unique = [...new Set(values)];
+	if (unique.length !== values.length) throw new Error(`${owner}: duplicate value`);
+	for (const value of unique) {
+		if (value.length === 0) throw new Error(`${owner}: values must be non-empty`);
+	}
+	return Object.freeze(unique);
+}
+
+function errorMessage(error: unknown): string {
+	return error instanceof Error ? error.message : String(error);
+}
+
+function isObjectRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
diff --git a/packages/ts/src/cqrs/messaging.ts b/packages/ts/src/cqrs/messaging.ts
new file mode 100644
index 00000000..6bf2a241
--- /dev/null
+++ b/packages/ts/src/cqrs/messaging.ts
@@ -0,0 +1,380 @@
+/**
+ * Optional CQRS-over-messageBus recipe (D350/D351/D353).
+ *
+ * Retained message delivery is lowered to CQRS command facts. Ack commands are
+ * derived only after visible CQRS accepted/rejected/error/audit material exists.
+ */
+
+import type { CqrsCommand, CqrsError, CqrsEvent, CqrsStatus } from "../cqrs/index.js";
+import { depBatch } from "../ctx/types.js";
+import type { DataIssue } from "../data/index.js";
+import type { Graph } from "../graph/graph.js";
+import type {
+	MessageBusAvailablePage,
+	MessageBusCommand,
+	MessageBusMessage,
+} from "../messaging/index.js";
+import type { Node } from "../node/node.js";
+
+export interface CqrsMessagingPolicy<TPayload = unknown, TCommand = unknown> {
+	readonly command?: (
+		message: MessageBusMessage<TPayload>,
+		delivery: MessageBusDelivery,
+	) => CqrsCommand<TCommand> | undefined;
+	readonly ackRejected?: boolean;
+	readonly outboxTopic?: string;
+}
+
+export interface CqrsMessagingRecipeOptions<
+	TPayload = unknown,
+	TCommand = unknown,
+	TEvent = unknown,
+> {
+	readonly name?: string;
+	readonly deliveries: Node<MessageBusAvailablePage<TPayload>>;
+	readonly status: Node<CqrsStatus>;
+	readonly errors?: Node<CqrsError>;
+	readonly events?: Node<CqrsEvent<TEvent>>;
+	readonly policy?: CqrsMessagingPolicy<TPayload, TCommand>;
+}
+
+export interface CqrsMessagingRecipeBundle<TCommand = unknown> {
+	readonly commands: Node<CqrsCommand<TCommand>>;
+	readonly ackCommands: Node<MessageBusCommand>;
+	readonly outboxCommands?: Node<MessageBusCommand>;
+	readonly issues: Node<DataIssue>;
+}
+
+type CqrsMessagingFact<TCommand> =
+	| { readonly kind: "command"; readonly command: CqrsCommand<TCommand> }
+	| { readonly kind: "issue"; readonly issue: DataIssue };
+
+export interface MessageBusDelivery {
+	readonly topic: string;
+	readonly seq: number;
+	readonly subscriptionId: string;
+	readonly commandId: string;
+}
+
+/** Build the optional D350/D351 CQRS messaging recipe. */
+export function cqrsMessagingRecipe<TPayload = unknown, TCommand = unknown, TEvent = unknown>(
+	graph: Graph,
+	opts: CqrsMessagingRecipeOptions<TPayload, TCommand, TEvent>,
+): CqrsMessagingRecipeBundle<TCommand> {
+	const name = opts.name ?? "cqrsMessaging";
+	const runtime = graph.node<CqrsMessagingFact<TCommand>>(
+		[opts.deliveries],
+		(ctx) => {
+			for (const raw of depBatch(ctx, 0) ?? []) {
+				const page = raw as MessageBusAvailablePage<TPayload>;
+				for (const message of page.messages) {
+					const delivery = messageDelivery(page, message);
+					const command = cqrsMessageCommand(message, delivery, opts.policy);
+					if (command === undefined) {
+						ctx.down([["DATA", { kind: "issue", issue: messageIssue(message, delivery) }]]);
+					} else {
+						ctx.down([["DATA", { kind: "command", command }]]);
+					}
+				}
+			}
+		},
+		{
+			name: `${name}/runtime`,
+			factory: "cqrsMessagingRuntime",
+			partial: true,
+			completeWhenDepsComplete: false,
+			errorWhenDepsError: false,
+		},
+	);
+	const issues = project(graph, runtime, `${name}/issues`, "cqrsMessagingIssues", (fact) =>
+		fact.kind === "issue" ? fact.issue : undefined,
+	);
+	const commands = project(graph, runtime, `${name}/commands`, "cqrsMessagingCommands", (fact) =>
+		fact.kind === "command" ? fact.command : undefined,
+	);
+	const ackCommands = cqrsMessageAckCommands(graph, {
+		name: `${name}/ackCommands`,
+		commands,
+		status: opts.status,
+		issues,
+		ackRejected: opts.policy?.ackRejected ?? true,
+	});
+	return {
+		commands,
+		ackCommands,
+		...(opts.events === undefined || opts.policy?.outboxTopic === undefined
+			? {}
+			: {
+					outboxCommands: cqrsEventOutboxCommands(graph, opts.events, opts.policy.outboxTopic, {
+						name: `${name}/outboxCommands`,
+					}),
+				}),
+		issues,
+	};
+}
+
+export function cqrsMessageCommand<TPayload = unknown, TCommand = unknown>(
+	message: MessageBusMessage<TPayload>,
+	delivery: MessageBusDelivery,
+	policy?: CqrsMessagingPolicy<TPayload, TCommand>,
+): CqrsCommand<TCommand> | undefined {
+	const mapped = policy?.command?.(message, delivery);
+	if (mapped !== undefined) return commandWithDelivery(mapped, delivery);
+	if (!isObjectRecord(message.payload)) return undefined;
+	const id = stringField(message.payload, "id") ?? delivery.commandId;
+	const type = stringField(message.payload, "type");
+	if (type === undefined) return undefined;
+	return commandWithDelivery(
+		{
+			id,
+			type,
+			payload: message.payload.payload as TCommand,
+			aggregateId: stringField(message.payload, "aggregateId"),
+			correlationId: stringField(message.payload, "correlationId"),
+			causationId: stringField(message.payload, "causationId"),
+			metadata: {
+				...(objectField(message.payload, "metadata") ?? {}),
+			},
+		},
+		delivery,
+	);
+}
+
+export function cqrsMessageAckCommands(
+	graph: Graph,
+	opts: {
+		readonly name?: string;
+		readonly commands: Node<CqrsCommand>;
+		readonly status: Node<CqrsStatus>;
+		readonly issues?: Node<DataIssue>;
+		readonly ackRejected?: boolean;
+	},
+): Node<MessageBusCommand> {
+	return graph.node<MessageBusCommand>(
+		opts.issues === undefined
+			? [opts.commands, opts.status]
+			: [opts.commands, opts.status, opts.issues],
+		(ctx) => {
+			const deliveries =
+				ctx.state.get<Map<string, MessageBusDelivery[]>>() ??
+				new Map<string, MessageBusDelivery[]>();
+			for (const raw of depBatch(ctx, 0) ?? []) {
+				const command = raw as CqrsCommand;
+				const delivery = commandDelivery(command);
+				if (delivery !== undefined) pushDelivery(deliveries, command.id, delivery);
+			}
+			for (const raw of depBatch(ctx, 1) ?? []) {
+				const status = raw as CqrsStatus;
+				if (status.state === "rejected" && opts.ackRejected === false) continue;
+				if (status.commandId === undefined) continue;
+				const delivery = shiftDelivery(deliveries, status.commandId);
+				if (delivery === undefined) continue;
+				ctx.down([["DATA", ackCommand(delivery, ackCommandId("cqrs", delivery, "status"))]]);
+			}
+			if (opts.issues !== undefined) {
+				for (const raw of depBatch(ctx, 2) ?? []) {
+					const issue = raw as DataIssue;
+					const delivery = issueDelivery(issue);
+					if (delivery !== undefined) {
+						ctx.down([["DATA", ackCommand(delivery, ackCommandId("cqrs", delivery, "issue"))]]);
+					}
+				}
+			}
+			ctx.state.set(deliveries);
+		},
+		{
+			name: opts.name ?? "cqrsMessaging/ackCommands",
+			factory: "cqrsMessagingAckCommands",
+			partial: true,
+			completeWhenDepsComplete: false,
+			errorWhenDepsError: false,
+		},
+	);
+}
+
+export function cqrsEventOutboxCommands<TEvent>(
+	graph: Graph,
+	events: Node<CqrsEvent<TEvent>>,
+	topic: string,
+	opts: { readonly name?: string } = {},
+): Node<MessageBusCommand> {
+	return graph.node<MessageBusCommand>(
+		[events],
+		(ctx) => {
+			for (const event of depBatch(ctx, 0) ?? []) {
+				const typed = event as CqrsEvent<TEvent>;
+				ctx.down([
+					[
+						"DATA",
+						{
+							kind: "publish",
+							topic,
+							payload: typed,
+							key: typed.aggregateId,
+							commandId: `${typed.id}:cqrs-outbox`,
+							idempotencyKey: typed.id,
+						} satisfies MessageBusCommand,
+					],
+				]);
+			}
+		},
+		{
+			name: opts.name ?? "cqrsMessaging/outboxCommands",
+			factory: "cqrsMessagingOutboxCommands",
+			completeWhenDepsComplete: false,
+			errorWhenDepsError: false,
+		},
+	);
+}
+
+function project<T, TCommand>(
+	graph: Graph,
+	runtime: Node<CqrsMessagingFact<TCommand>>,
+	name: string,
+	factory: string,
+	pick: (fact: CqrsMessagingFact<TCommand>) => T | undefined,
+): Node<T> {
+	return graph.node<T>(
+		[runtime],
+		(ctx) => {
+			for (const fact of depBatch(ctx, 0) ?? []) {
+				const value = pick(fact as CqrsMessagingFact<TCommand>);
+				if (value !== undefined) ctx.down([["DATA", value]]);
+			}
+		},
+		{ name, factory, partial: true, completeWhenDepsComplete: false, errorWhenDepsError: false },
+	);
+}
+
+function messageIssue(message: MessageBusMessage, delivery: MessageBusDelivery): DataIssue {
+	return {
+		kind: "issue",
+		code: "cqrs-message-lowering-rejected",
+		message: "CQRS messaging recipe could not lower retained message to a command fact",
+		severity: "error",
+		source: "cqrs.messaging",
+		metadata: {
+			messageBus: {
+				topic: delivery.topic,
+				seq: delivery.seq,
+				subscriptionId: delivery.subscriptionId,
+				commandId: delivery.commandId,
+			},
+		},
+		details: message,
+	};
+}
+
+function ackCommand(delivery: MessageBusDelivery, commandId: string): MessageBusCommand {
+	return {
+		kind: "ack",
+		topic: delivery.topic,
+		subscriptionId: delivery.subscriptionId,
+		seq: delivery.seq,
+		commandId,
+	};
+}
+
+function ackCommandId(namespace: string, delivery: MessageBusDelivery, reason: string): string {
+	return `${namespace}:${delivery.topic}:${delivery.subscriptionId}:${delivery.seq}:${reason}-ack`;
+}
+
+function commandWithDelivery<TCommand>(
+	command: CqrsCommand<TCommand>,
+	delivery: MessageBusDelivery,
+): CqrsCommand<TCommand> {
+	return {
+		...command,
+		metadata: {
+			...(command.metadata ?? {}),
+			messageBus: delivery,
+		},
+	};
+}
+
+function messageDelivery(
+	page: MessageBusAvailablePage,
+	message: MessageBusMessage,
+): MessageBusDelivery {
+	return {
+		topic: page.topic,
+		seq: message.seq,
+		subscriptionId: page.subscriptionId,
+		commandId:
+			isObjectRecord(message.payload) && typeof message.payload.id === "string"
+				? message.payload.id
+				: (message.commandId ?? `${page.topic}:${message.seq}`),
+	};
+}
+
+function pushDelivery(
+	deliveries: Map<string, MessageBusDelivery[]>,
+	commandId: string,
+	delivery: MessageBusDelivery,
+): void {
+	const queue = deliveries.get(commandId) ?? [];
+	deliveries.set(commandId, [...queue, delivery]);
+}
+
+function shiftDelivery(
+	deliveries: Map<string, MessageBusDelivery[]>,
+	commandId: string,
+): MessageBusDelivery | undefined {
+	const queue = deliveries.get(commandId);
+	if (queue === undefined || queue.length === 0) return undefined;
+	const [first, ...rest] = queue;
+	if (rest.length === 0) deliveries.delete(commandId);
+	else deliveries.set(commandId, rest);
+	return first;
+}
+
+function issueDelivery(issue: DataIssue): MessageBusDelivery | undefined {
+	const metadata = isObjectRecord(issue.metadata) ? issue.metadata : undefined;
+	const messageBus = isObjectRecord(metadata?.messageBus) ? metadata.messageBus : undefined;
+	if (messageBus === undefined) return undefined;
+	if (typeof messageBus.topic !== "string" || typeof messageBus.seq !== "number") return undefined;
+	if (typeof messageBus.subscriptionId !== "string") return undefined;
+	if (typeof messageBus.commandId !== "string") return undefined;
+	return {
+		topic: messageBus.topic,
+		seq: messageBus.seq,
+		subscriptionId: messageBus.subscriptionId,
+		commandId: messageBus.commandId,
+	};
+}
+
+function commandDelivery(command: CqrsCommand): MessageBusDelivery | undefined {
+	const metadata = isObjectRecord(command.metadata) ? command.metadata : undefined;
+	const messageBus = isObjectRecord(metadata?.messageBus) ? metadata.messageBus : undefined;
+	if (messageBus === undefined) return undefined;
+	return messageBusDelivery(messageBus);
+}
+
+function messageBusDelivery(messageBus: Record<string, unknown>): MessageBusDelivery | undefined {
+	if (typeof messageBus.topic !== "string" || typeof messageBus.seq !== "number") return undefined;
+	if (typeof messageBus.subscriptionId !== "string") return undefined;
+	const commandId = typeof messageBus.commandId === "string" ? messageBus.commandId : "";
+	return {
+		topic: messageBus.topic,
+		seq: messageBus.seq,
+		subscriptionId: messageBus.subscriptionId,
+		commandId,
+	};
+}
+
+function stringField(record: Record<string, unknown>, key: string): string | undefined {
+	const value = record[key];
+	return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+
+function objectField(
+	record: Record<string, unknown>,
+	key: string,
+): Record<string, unknown> | undefined {
+	const value = record[key];
+	return isObjectRecord(value) ? value : undefined;
+}
+
+function isObjectRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null;
+}
diff --git a/packages/ts/src/cqrs/work-queue.ts b/packages/ts/src/cqrs/work-queue.ts
new file mode 100644
index 00000000..65c1cea6
--- /dev/null
+++ b/packages/ts/src/cqrs/work-queue.ts
@@ -0,0 +1,432 @@
+/**
+ * Optional CQRS-over-workQueue recipe (D350/D352/D353).
+ *
+ * The CQRS core remains synchronous graph-visible command/event truth. This
+ * recipe only maps queue claims to CQRS command facts and maps visible CQRS
+ * outcomes back to generic workQueue disposition commands.
+ */
+
+import type { CqrsCommand, CqrsError, CqrsErrorCode, CqrsStatus } from "../cqrs/index.js";
+import { type Ctx, depBatch } from "../ctx/types.js";
+import type { DataIssue } from "../data/index.js";
+import type { Graph } from "../graph/graph.js";
+import type { Node } from "../node/node.js";
+import type { WorkQueueCommand, WorkQueueRecord } from "../work-queue/index.js";
+
+export interface CqrsQueuedCommandPayload<TCommand = unknown> {
+	readonly kind: "cqrs-queued-command";
+	readonly command: CqrsCommand<TCommand>;
+	readonly idempotencyKey?: string;
+	readonly sourceRefs?: readonly string[];
+	readonly policyRefs?: readonly string[];
+	readonly actorRefs?: readonly string[];
+	readonly auditRefs?: readonly string[];
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface CqrsWorkQueueAttempt<TCommand = unknown> {
+	readonly kind: "cqrs-work-queue-attempt";
+	readonly workId: string;
+	readonly leaseId: string;
+	readonly queueAttempt: number;
+	readonly workerId: string;
+	readonly command: CqrsCommand<TCommand>;
+	readonly payload: CqrsQueuedCommandPayload<TCommand>;
+	readonly sourceRefs?: readonly string[];
+}
+
+export type CqrsWorkQueueAcceptedOutcome = {
+	readonly kind: "accepted";
+	readonly status: CqrsStatus;
+};
+
+export type CqrsWorkQueueRejectedOutcome = {
+	readonly kind: "rejected";
+	readonly status: CqrsStatus;
+	readonly error?: CqrsError;
+};
+
+export type CqrsWorkQueueReleaseOutcome = {
+	readonly kind: "release";
+	readonly reason?: string;
+};
+
+export type CqrsWorkQueueOutcome =
+	| CqrsWorkQueueAcceptedOutcome
+	| CqrsWorkQueueRejectedOutcome
+	| CqrsWorkQueueReleaseOutcome;
+
+export interface CqrsWorkQueuePolicy {
+	/**
+	 * D352: handler-threw and clock-threw fail retryable:true by default. A
+	 * policy may classify a known deterministic handler failure as nonretryable.
+	 */
+	readonly retryableFailure?: (
+		errorCode: CqrsErrorCode,
+		outcome: CqrsWorkQueueRejectedOutcome,
+	) => boolean;
+	readonly releaseReason?: (attempt: CqrsWorkQueueAttempt) => string | undefined;
+}
+
+export interface CqrsWorkQueueRecipeOptions<TCommand = unknown> {
+	readonly name?: string;
+	readonly records: Node<WorkQueueRecord<CqrsQueuedCommandPayload<TCommand>>>;
+	readonly status: Node<CqrsStatus>;
+	readonly errors?: Node<CqrsError>;
+	readonly workerId?: string;
+	readonly policy?: CqrsWorkQueuePolicy;
+}
+
+export interface CqrsWorkQueueRecipeBundle<TCommand = unknown> {
+	readonly attempts: Node<CqrsWorkQueueAttempt<TCommand>>;
+	readonly dispatches: Node<CqrsCommand<TCommand>>;
+	readonly commands: Node<WorkQueueCommand<CqrsQueuedCommandPayload<TCommand>>>;
+	readonly issues: Node<DataIssue>;
+}
+
+type CqrsQueueFact<TCommand> =
+	| { readonly kind: "attempt"; readonly attempt: CqrsWorkQueueAttempt<TCommand> }
+	| { readonly kind: "dispatch"; readonly command: CqrsCommand<TCommand> }
+	| {
+			readonly kind: "command";
+			readonly command: WorkQueueCommand<CqrsQueuedCommandPayload<TCommand>>;
+	  }
+	| { readonly kind: "issue"; readonly issue: DataIssue };
+
+interface CqrsQueueState<TCommand> {
+	readonly payloads: Map<string, CqrsQueuedCommandPayload<TCommand>>;
+	readonly activeClaims: Map<string, CqrsWorkQueueAttempt<TCommand>[]>;
+	readonly errors: Map<string, CqrsError>;
+	readonly terminalClaims: Set<string>;
+}
+
+/** Build the optional D350/D352 CQRS workQueue recipe. */
+export function cqrsWorkQueueRecipe<TCommand = unknown>(
+	graph: Graph,
+	opts: CqrsWorkQueueRecipeOptions<TCommand>,
+): CqrsWorkQueueRecipeBundle<TCommand> {
+	const name = opts.name ?? "cqrsWorkQueue";
+	const deps =
+		opts.errors === undefined
+			? [opts.records, opts.status]
+			: [opts.records, opts.status, opts.errors];
+	const runtime = graph.node<CqrsQueueFact<TCommand>>(
+		deps,
+		(ctx) => {
+			const state = ctx.state.get<CqrsQueueState<TCommand>>() ?? emptyState<TCommand>();
+			for (const raw of depBatch(ctx, 0) ?? []) {
+				reduceRecord(ctx, state, raw as WorkQueueRecord<CqrsQueuedCommandPayload<TCommand>>, opts);
+			}
+			if (opts.errors !== undefined) {
+				for (const raw of depBatch(ctx, 2) ?? []) {
+					const error = raw as CqrsError;
+					if (error.commandId !== undefined) state.errors.set(error.commandId, error);
+				}
+			}
+			for (const raw of depBatch(ctx, 1) ?? []) {
+				reduceStatus(ctx, state, raw as CqrsStatus, opts);
+			}
+			ctx.state.set(state);
+		},
+		{
+			name: `${name}/runtime`,
+			factory: "cqrsWorkQueueRuntime",
+			partial: true,
+			completeWhenDepsComplete: false,
+			errorWhenDepsError: false,
+		},
+	);
+	return {
+		attempts: project(graph, runtime, `${name}/attempts`, "cqrsWorkQueueAttempts", (fact) =>
+			fact.kind === "attempt" ? fact.attempt : undefined,
+		),
+		dispatches: project(graph, runtime, `${name}/dispatches`, "cqrsWorkQueueDispatches", (fact) =>
+			fact.kind === "dispatch" ? fact.command : undefined,
+		),
+		commands: project(graph, runtime, `${name}/commands`, "cqrsWorkQueueCommands", (fact) =>
+			fact.kind === "command" ? fact.command : undefined,
+		),
+		issues: project(graph, runtime, `${name}/issues`, "cqrsWorkQueueIssues", (fact) =>
+			fact.kind === "issue" ? fact.issue : undefined,
+		),
+	};
+}
+
+export function cqrsSubmitCommand<TCommand>(
+	command: CqrsCommand<TCommand>,
+	opts: {
+		readonly workId?: string;
+		readonly commandId?: string;
+		readonly idempotencyKey?: string;
+		readonly sourceRefs?: readonly string[];
+		readonly policyRefs?: readonly string[];
+		readonly actorRefs?: readonly string[];
+		readonly auditRefs?: readonly string[];
+		readonly metadata?: Record<string, unknown>;
+	} = {},
+): WorkQueueCommand<CqrsQueuedCommandPayload<TCommand>> {
+	const payload: CqrsQueuedCommandPayload<TCommand> = {
+		kind: "cqrs-queued-command",
+		command,
+		idempotencyKey: opts.idempotencyKey ?? command.id,
+		sourceRefs: opts.sourceRefs,
+		policyRefs: opts.policyRefs,
+		actorRefs: opts.actorRefs,
+		auditRefs: opts.auditRefs,
+		metadata: opts.metadata,
+	};
+	return {
+		kind: "submit",
+		commandId: opts.commandId ?? `${command.id}:cqrs-work-queue-submit`,
+		workId: opts.workId ?? `cqrs:${command.id}`,
+		payload,
+		idempotencyKey: opts.idempotencyKey ?? command.id,
+		sourceRefs: opts.sourceRefs,
+		policyRefs: opts.policyRefs,
+		actorRefs: opts.actorRefs,
+		auditRefs: opts.auditRefs,
+	};
+}
+
+export function cqrsWorkQueueDispositionCommand<TCommand>(
+	attempt: CqrsWorkQueueAttempt<TCommand>,
+	outcome: CqrsWorkQueueOutcome,
+	policy?: CqrsWorkQueuePolicy,
+): WorkQueueCommand<CqrsQueuedCommandPayload<TCommand>> {
+	if (outcome.kind === "release") {
+		return {
+			kind: "release",
+			commandId: dispositionCommandId(attempt, "release"),
+			workId: attempt.workId,
+			leaseId: attempt.leaseId,
+			attempt: attempt.queueAttempt,
+			workerId: attempt.workerId,
+			reason: outcome.reason ?? policy?.releaseReason?.(attempt),
+		};
+	}
+	if (outcome.kind === "accepted") {
+		return completeCommand(attempt, {
+			kind: "cqrs-accepted-result",
+			commandId: outcome.status.commandId,
+			commandType: outcome.status.commandType,
+			eventCount: outcome.status.eventCount,
+			cursor: outcome.status.cursor,
+		});
+	}
+	const code = outcome.status.errorCode;
+	if (code === "handler-threw" || code === "clock-threw" || code === undefined) {
+		return {
+			kind: "fail",
+			commandId: dispositionCommandId(attempt, "fail"),
+			workId: attempt.workId,
+			leaseId: attempt.leaseId,
+			attempt: attempt.queueAttempt,
+			workerId: attempt.workerId,
+			error: outcome.error ?? {
+				kind: "issue",
+				code: code ?? "cqrs-outcome-ambiguous",
+				message: "CQRS rejected without deterministic rejection evidence",
+			},
+			retryable: code === undefined ? true : (policy?.retryableFailure?.(code, outcome) ?? true),
+		};
+	}
+	return completeCommand(attempt, {
+		kind: "cqrs-rejected-result",
+		commandId: outcome.status.commandId,
+		commandType: outcome.status.commandType,
+		errorCode: code,
+		error: outcome.error,
+		eventCount: outcome.status.eventCount,
+		cursor: outcome.status.cursor,
+	});
+}
+
+function completeCommand<TCommand>(
+	attempt: CqrsWorkQueueAttempt<TCommand>,
+	result: unknown,
+): WorkQueueCommand<CqrsQueuedCommandPayload<TCommand>> {
+	return {
+		kind: "complete",
+		commandId: dispositionCommandId(attempt, "complete"),
+		workId: attempt.workId,
+		leaseId: attempt.leaseId,
+		attempt: attempt.queueAttempt,
+		workerId: attempt.workerId,
+		result,
+	};
+}
+
+function reduceRecord<TCommand>(
+	ctx: Ctx,
+	state: CqrsQueueState<TCommand>,
+	record: WorkQueueRecord<CqrsQueuedCommandPayload<TCommand>>,
+	opts: CqrsWorkQueueRecipeOptions<TCommand>,
+): void {
+	if (record.kind === "work-admitted") {
+		if (isQueuedPayload(record.payload)) state.payloads.set(record.workId, record.payload);
+		else emit(ctx, { kind: "issue", issue: queueIssue(record, "cqrs-queue-malformed-payload") });
+		return;
+	}
+	if (record.kind !== "work-claimed") return;
+	if (opts.workerId !== undefined && record.workerId !== opts.workerId) return;
+	const payload = state.payloads.get(record.workId);
+	if (payload === undefined) {
+		emit(ctx, { kind: "issue", issue: queueIssue(record, "cqrs-claim-without-payload") });
+		emit(ctx, {
+			kind: "command",
+			command: {
+				kind: "release",
+				commandId: `cqrs:${record.workId}:${record.leaseId}:${record.attempt}:release-no-payload`,
+				workId: record.workId,
+				leaseId: record.leaseId,
+				attempt: record.attempt,
+				workerId: record.workerId,
+				reason: "cqrs-claim-without-payload",
+			},
+		});
+		return;
+	}
+	const attempt: CqrsWorkQueueAttempt<TCommand> = {
+		kind: "cqrs-work-queue-attempt",
+		workId: record.workId,
+		leaseId: record.leaseId,
+		queueAttempt: record.attempt,
+		workerId: record.workerId,
+		command: payload.command,
+		payload,
+		sourceRefs: [...(payload.sourceRefs ?? []), `work-queue-record:${record.recordSeq}`],
+	};
+	pushActiveClaim(state, payload.command.id, attempt);
+	emit(ctx, { kind: "attempt", attempt });
+	emit(ctx, { kind: "dispatch", command: payload.command });
+}
+
+function reduceStatus<TCommand>(
+	ctx: Ctx,
+	state: CqrsQueueState<TCommand>,
+	status: CqrsStatus,
+	opts: CqrsWorkQueueRecipeOptions<TCommand>,
+): void {
+	if (status.commandId === undefined) return;
+	const attempt = shiftActiveClaim(state, status.commandId);
+	if (attempt === undefined) {
+		emit(ctx, {
+			kind: "issue",
+			issue: {
+				kind: "issue",
+				code: "cqrs-status-without-active-queue-claim",
+				message:
+					"CQRS workQueue recipe observed a CQRS status without an active queue claim; no queue disposition was emitted",
+				severity: "error",
+				source: "cqrs.workQueue",
+				refs: [`cqrs-command:${status.commandId}`],
+				details: status,
+			},
+		});
+		return;
+	}
+	const claimKey = queueClaimKey(attempt);
+	if (state.terminalClaims.has(claimKey)) {
+		emit(ctx, {
+			kind: "issue",
+			issue: {
+				kind: "issue",
+				code: "cqrs-duplicate-terminal-outcome-for-queue-claim",
+				message: `CQRS queue claim '${claimKey}' already produced a terminal queue disposition`,
+				refs: [`cqrs-command:${status.commandId}`, `work-queue-work:${attempt.workId}`],
+			},
+		});
+		return;
+	}
+	state.terminalClaims.add(claimKey);
+	const command = cqrsWorkQueueDispositionCommand(
+		attempt,
+		status.state === "accepted"
+			? { kind: "accepted", status }
+			: { kind: "rejected", status, error: state.errors.get(status.commandId) },
+		opts.policy,
+	);
+	emit(ctx, { kind: "command", command });
+}
+
+function emptyState<TCommand>(): CqrsQueueState<TCommand> {
+	return {
+		payloads: new Map(),
+		activeClaims: new Map(),
+		errors: new Map(),
+		terminalClaims: new Set(),
+	};
+}
+
+function pushActiveClaim<TCommand>(
+	state: CqrsQueueState<TCommand>,
+	commandId: string,
+	attempt: CqrsWorkQueueAttempt<TCommand>,
+): void {
+	const claims = state.activeClaims.get(commandId) ?? [];
+	state.activeClaims.set(commandId, [...claims, attempt]);
+}
+
+function shiftActiveClaim<TCommand>(
+	state: CqrsQueueState<TCommand>,
+	commandId: string,
+): CqrsWorkQueueAttempt<TCommand> | undefined {
+	const claims = state.activeClaims.get(commandId);
+	if (claims === undefined || claims.length === 0) return undefined;
+	const [first, ...rest] = claims;
+	if (rest.length === 0) state.activeClaims.delete(commandId);
+	else state.activeClaims.set(commandId, rest);
+	return first;
+}
+
+function queueClaimKey(attempt: CqrsWorkQueueAttempt): string {
+	return `${attempt.workId}:${attempt.leaseId}:${attempt.queueAttempt}`;
+}
+
+function dispositionCommandId(attempt: CqrsWorkQueueAttempt, kind: string): string {
+	return `${attempt.command.id}:${attempt.workId}:${attempt.leaseId}:${attempt.queueAttempt}:cqrs-queue-${kind}`;
+}
+
+function project<T, TCommand>(
+	graph: Graph,
+	runtime: Node<CqrsQueueFact<TCommand>>,
+	name: string,
+	factory: string,
+	pick: (fact: CqrsQueueFact<TCommand>) => T | undefined,
+): Node<T> {
+	return graph.node<T>(
+		[runtime],
+		(ctx) => {
+			for (const fact of depBatch(ctx, 0) ?? []) {
+				const value = pick(fact as CqrsQueueFact<TCommand>);
+				if (value !== undefined) ctx.down([["DATA", value]]);
+			}
+		},
+		{ name, factory, partial: true, completeWhenDepsComplete: false, errorWhenDepsError: false },
+	);
+}
+
+function emit<TCommand>(ctx: Ctx, fact: CqrsQueueFact<TCommand>): void {
+	ctx.down([["DATA", fact]]);
+}
+
+function isQueuedPayload<TCommand>(value: unknown): value is CqrsQueuedCommandPayload<TCommand> {
+	if (!isObjectRecord(value) || value.kind !== "cqrs-queued-command") return false;
+	return isObjectRecord(value.command) && typeof value.command.id === "string";
+}
+
+function queueIssue(record: WorkQueueRecord<unknown>, code: string): DataIssue {
+	return {
+		kind: "issue",
+		code,
+		message: `CQRS workQueue recipe could not map record '${record.kind}'`,
+		severity: "error",
+		source: "cqrs.workQueue",
+		refs: record.workId === undefined ? undefined : [`work-queue-work:${record.workId}`],
+		details: record,
+	};
+}
+
+function isObjectRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null;
+}
diff --git a/packages/ts/src/ctx/types.ts b/packages/ts/src/ctx/types.ts
new file mode 100644
index 00000000..d6063103
--- /dev/null
+++ b/packages/ts/src/ctx/types.ts
@@ -0,0 +1,181 @@
+/**
+ * The fn-invocation context and per-dep input shapes.
+ *
+ * Canonical authority: ~/src/graphrefly/spec/rules.jsonl
+ *   R-fn-contract (D8/D27), R-ctx-state (D23/D29), R-cleanup-hooks (D28), R-ctx-up.
+ */
+
+import type { Dispatcher } from "../dispatcher/index.js";
+import type { EnvironmentDrivers } from "../graph/environment.js";
+import type { Node } from "../node/node.js";
+import { type Message, type PullDemand, SENTINEL, type Wave } from "../protocol/messages.js";
+
+/** A downstream sink callback (the only way to connect to a node's output). */
+export type Sink = (msg: Message, delivery?: DeliveryMeta) => void;
+
+/** Internal delivery metadata used to preserve the upstream `ctx.down(msgs)` wave boundary. */
+export interface DeliveryMeta {
+	readonly wave: object;
+	readonly last: boolean;
+}
+
+/**
+ * Internal current-value reader. It is deliberately a symbol-backed implementation detail:
+ * raw ctx exposes `waveData` + `terminal`; helpers below derive from that plus this dep cache.
+ */
+export const CTX_DEP_CACHE: unique symbol = Symbol("graphrefly.ctx.depCache");
+
+export interface CtxDepCache {
+	readonly latest: readonly unknown[];
+}
+
+/** Internal node-construction binding for graph-local helper-created deps. */
+export const CTX_NODE_BINDING: unique symbol = Symbol("graphrefly.ctx.nodeBinding");
+
+export interface CtxNodeBinding {
+	readonly dispatcher: Dispatcher;
+	create<T>(factory: () => Node<T>): Node<T>;
+}
+
+/** Per-dep wave projections: dep -> waves -> values/SENTINEL markers. */
+export type WaveData = readonly (readonly (readonly unknown[])[])[];
+
+/** Terminal metadata parallel to `waveData`: false = none, true = COMPLETE, otherwise ERROR payload. */
+export type TerminalData = readonly unknown[];
+
+export function isTerminalNone(t: unknown): boolean {
+	return t === false || t === undefined;
+}
+
+export function isTerminalComplete(t: unknown): t is true {
+	return t === true;
+}
+
+export function isTerminalError(t: unknown): boolean {
+	return !isTerminalNone(t) && !isTerminalComplete(t);
+}
+
+export function terminalErrorValue(t: unknown): unknown {
+	return isTerminalError(t) ? t : undefined;
+}
+
+/**
+ * Per-node private cross-wave state (R-ctx-state / D23,D29). Default fresh-lifecycle
+ * wipe; `persist(true)` keeps it across lifecycle transitions.
+ */
+export interface CtxState {
+	get<S = unknown>(): S | undefined;
+	set<S = unknown>(v: S): void;
+	persist(on?: boolean): void;
+}
+
+/**
+ * Deferred SELF-rewire (R-rewire-deferred / D47). A node fn may, DURING its run, request a
+ * mutation of its OWN dep set; the request is QUEUED and applied at the committed wave boundary
+ * (after the current wave settles / batch commit / final-lock RESUME) as a fresh wave, reusing
+ * R-rewire surgical/Option-C semantics (D42). This is the ONLY legal self-triggered rewire — an
+ * IMMEDIATE in-fn `node.subscribeDep/unsubscribeDep/replaceDeps` is the D37 mid-fn feedback-cycle ERROR. An
+ * added cached dep pushes `[DIRTY,DATA]` on the boundary wave (R-push-subscribe); a removed dep
+ * is drained and, if it loses its last subscriber, `_deactivate`s + fires `onDeactivation`
+ * (input-side teardown — the basis for higher-order operator cancellation / abortInFlight).
+ */
+export interface RewireNext {
+	/** Defer subscribing to a dep (paired with the re-supplied fn — positional fn-deps lock, SD-1). */
+	subscribeDep(dep: Node<unknown>, fn: NodeFn): void;
+	/** Defer unsubscribing from a dep (its source is torn down if it loses its last subscriber). */
+	unsubscribeDep(dep: Node<unknown>, fn: NodeFn): void;
+	/** Defer replacing the whole dep set (surgical: kept deps untouched, removed drained, added fresh-subscribe). */
+	replaceDeps(deps: Node<unknown>[], fn: NodeFn): void;
+}
+
+/**
+ * The single argument to a node fn: `(ctx) => void` (R-fn-contract / D8). All emission
+ * is explicit via `ctx.down`; there is no return-value framing.
+ */
+export interface Ctx {
+	/**
+	 * Emit upstream toward deps — control tiers only (R-ctx-up). IMMEDIATE. `towardDep` (a dep index)
+	 * routes the wave up ONE declared edge (R-up-routing directed-up); omitted = broadcast up all deps.
+	 * A pull DEMAND is `up([[PULL, { pullId, params }]])` — but for a SELF-demand (demanding a dep
+	 * this fn also reads) use {@link Ctx.upNext} instead, since an immediate demand whose delivery loops back
+	 * re-enters this fn mid-wave (D37 / R-reentrancy).
+	 */
+	up(msgs: Wave, towardDep?: number): void;
+	/** Emit downstream toward sinks. */
+	down(msgs: Wave): void;
+	/**
+	 * The single raw dep-value input surface (R-ctx-wave-data / D77): dep -> upstream waves ->
+	 * per-wave DATA payloads and INVALIDATE/SENTINEL markers. `waveData[i] = []` means dep i
+	 * delivered no wave to this invocation; `waveData[i] = [[]]` means RESOLVED-only.
+	 */
+	waveData: WaveData;
+	/** Terminal metadata for the same invocation; terminal values never enter `waveData`. */
+	terminal: TerminalData;
+	state: CtxState;
+	/** Release external resources on deactivation (R-cleanup-hooks). */
+	onDeactivation(fn: () => void): void;
+	/** Flush on INVALIDATE (R-cleanup-hooks). */
+	onInvalidate(fn: () => void): void;
+	/** Graph-owned environment drivers for source/adapter boundaries (D130/D131). */
+	environment(): EnvironmentDrivers;
+	/** Holder-visible context for a PULL-caused invocation (D272); absent for ordinary waves. */
+	readonly pull?: PullDemand;
+	/**
+	 * Deferred SELF-rewire (R-rewire-deferred / D47) — the substrate affordance higher-order
+	 * operators (switchMap/mergeMap/concatMap/exhaustMap/flatMap) use to grow/shrink their own
+	 * inner-source dep set in response to their own data. Always present; see {@link RewireNext}.
+	 */
+	rewireNext: RewireNext;
+	/**
+	 * Deferred up — the boundary-deferred form of {@link Ctx.up} (R-up-routing / R-pull / D59). Routes
+	 * `msgs` up from this node at the COMMITTED wave boundary (broadcast, or up the single `towardDep`
+	 * edge), riding the same R-rewire-deferred (D47) drain as {@link RewireNext}. This is the
+	 * SELF-DEMAND path: a consumer issues `ctx.upNext([[PULL, { pullId, params }]])` to demand a pull
+	 * dep it ALSO reads — the cone-routed PULL reaches the pullId-holder, whose delivery loops back as a
+	 * FRESH wave (not a mid-fn re-entry → no D37). The consumer accepts one-wave latency (the
+	 * HTTP-request model). No node reference needed: the author writes the pullId verbatim.
+	 */
+	upNext(msgs: Wave, towardDep?: number): void;
+	/**
+	 * Read a dep's latest value by index (dynamicNode only, R-dynamic-node / D35).
+	 * Present only on dynamicNode fns; all declared deps still participate in wave
+	 * tracking. Under D49/R-resolved-undirty an unread dep's change still fires the fn,
+	 * which re-emits its (unchanged) output as a DATA occurrence — there is NO equals-
+	 * absorption; pair with distinctUntilChanged to suppress unchanged re-emits (opt-in).
+	 */
+	track?(depIndex: number): unknown;
+	[CTX_DEP_CACHE]?: CtxDepCache;
+	[CTX_NODE_BINDING]?: CtxNodeBinding;
+}
+
+/** A node fn (R-fn-contract). Registered in a dispatcher pool, indexed by Handle. */
+export type NodeFn = (ctx: Ctx) => void;
+
+/** Number of declared dep slots visible in this invocation. */
+export function depCount(ctx: Ctx): number {
+	return ctx.waveData.length;
+}
+
+/** DATA/SENTINEL projection batches delivered by one dep in this invocation. */
+export function depWaves(ctx: Ctx, depIndex: number): readonly (readonly unknown[])[] {
+	return ctx.waveData[depIndex] ?? [];
+}
+
+/** Flattened DATA projection for old event-counting operator bodies; null = no wave. */
+export function depBatch(ctx: Ctx, depIndex: number): readonly unknown[] | null {
+	const waves = depWaves(ctx, depIndex);
+	if (waves.length === 0) return null;
+	const flattened = waves.flat().filter((v) => v !== SENTINEL);
+	return flattened.length === 0 ? [] : flattened;
+}
+
+/** Latest cached DATA for a dep, derived from implementation-owned dep cache. */
+export function depLatest(ctx: Ctx, depIndex: number): unknown {
+	return ctx[CTX_DEP_CACHE]?.latest[depIndex];
+}
+
+/** Terminal metadata for one dep: false = none, true = COMPLETE, otherwise ERROR payload. */
+export function depTerminal(ctx: Ctx, depIndex: number): unknown {
+	const t = ctx.terminal[depIndex];
+	return t === undefined ? false : t;
+}
diff --git a/packages/ts/src/data-structures/index.ts b/packages/ts/src/data-structures/index.ts
new file mode 100644
index 00000000..8464035b
--- /dev/null
+++ b/packages/ts/src/data-structures/index.ts
@@ -0,0 +1,50 @@
+export type {
+	IndexChange,
+	ListChange,
+	LogChange,
+	MapChange,
+} from "../graph/data-structures/change.js";
+export type { ReactiveView } from "../graph/data-structures/core.js";
+export {
+	type IndexRow,
+	type ReactiveIndex,
+	type ReactiveIndexCapacityOrder,
+	type ReactiveIndexCapacityPolicy,
+	type ReactiveIndexOpt,
+	type ReactiveIndexOptions,
+	reactiveIndex,
+} from "../graph/data-structures/reactive-index.js";
+export {
+	type ReactiveList,
+	type ReactiveListOpt,
+	type ReactiveListOptions,
+	reactiveList,
+} from "../graph/data-structures/reactive-list.js";
+export {
+	mergeReactiveLogs,
+	type ReactiveLog,
+	type ReactiveLogOptions,
+	reactiveLog,
+	scanLog,
+} from "../graph/data-structures/reactive-log.js";
+export {
+	type ReactiveMap,
+	type ReactiveMapOpt,
+	type ReactiveMapOptions,
+	type ReactiveMapRetentionEntry,
+	type ReactiveMapRetentionPolicy,
+	reactiveMap,
+} from "../graph/data-structures/reactive-map.js";
+export type {
+	CapacityPolicy,
+	OrderedCapacityPolicy,
+	ReactiveOpt,
+	RetentionPolicy,
+	ViewCachePolicy,
+} from "../graph/policies/types.js";
+export {
+	restoreReactiveIndex,
+	restoreReactiveList,
+	restoreReactiveLog,
+	restoreReactiveMap,
+} from "./persistence.js";
diff --git a/packages/ts/src/data-structures/persistence.ts b/packages/ts/src/data-structures/persistence.ts
new file mode 100644
index 00000000..641a3295
--- /dev/null
+++ b/packages/ts/src/data-structures/persistence.ts
@@ -0,0 +1,108 @@
+import type {
+	IndexRow,
+	ReactiveIndex,
+	ReactiveIndexOptions,
+} from "../graph/data-structures/reactive-index.js";
+import { restoreReactiveIndexFromBackendState } from "../graph/data-structures/reactive-index.js";
+import type { ReactiveListOptions } from "../graph/data-structures/reactive-list.js";
+import { type ReactiveList, reactiveList } from "../graph/data-structures/reactive-list.js";
+import type { ReactiveLogOptions } from "../graph/data-structures/reactive-log.js";
+import { type ReactiveLog, reactiveLog } from "../graph/data-structures/reactive-log.js";
+import type { ReactiveMap, ReactiveMapOptions } from "../graph/data-structures/reactive-map.js";
+import { restoreReactiveMapFromBackendState } from "../graph/data-structures/reactive-map.js";
+import type {
+	ReactiveIndexRestoreState,
+	ReactiveListRestoreState,
+	ReactiveLogRestoreState,
+	ReactiveMapRestoreState,
+} from "../storage/index.js";
+
+function isListRestoreState<T>(
+	state: ReactiveListRestoreState<T> | readonly T[],
+): state is ReactiveListRestoreState<T> {
+	return !Array.isArray(state);
+}
+
+function restoreListValues<T>(state: ReactiveListRestoreState<T> | readonly T[]): readonly T[] {
+	if (!isListRestoreState(state)) return state;
+	if (state.kind !== "reactiveList") throw new TypeError("restore state kind must be reactiveList");
+	return state.state;
+}
+
+function isLogRestoreState<T>(
+	state: ReactiveLogRestoreState<T> | readonly T[],
+): state is ReactiveLogRestoreState<T> {
+	return !Array.isArray(state);
+}
+
+function restoreLogValues<T>(state: ReactiveLogRestoreState<T> | readonly T[]): readonly T[] {
+	if (!isLogRestoreState(state)) return state;
+	if (state.kind !== "reactiveLog") throw new TypeError("restore state kind must be reactiveLog");
+	return state.state;
+}
+
+function isMapRestoreState<K, V>(
+	state: ReactiveMapRestoreState<K, V> | readonly (readonly [K, V])[],
+): state is ReactiveMapRestoreState<K, V> {
+	return !Array.isArray(state);
+}
+
+function restoreMapEntries<K, V>(
+	state: ReactiveMapRestoreState<K, V> | readonly (readonly [K, V])[],
+): readonly (readonly [K, V])[] {
+	if (!isMapRestoreState(state)) return state;
+	if (state.kind !== "reactiveMap") throw new TypeError("restore state kind must be reactiveMap");
+	return state.state;
+}
+
+function isIndexRestoreState<K, V>(
+	state: ReactiveIndexRestoreState<K, V> | readonly IndexRow<K, V>[],
+): state is ReactiveIndexRestoreState<K, V> {
+	return !Array.isArray(state);
+}
+
+function restoreIndexRows<K, V>(
+	state: ReactiveIndexRestoreState<K, V> | readonly IndexRow<K, V>[],
+): readonly IndexRow<K, V>[] {
+	if (!isIndexRestoreState(state)) return state;
+	if (state.kind !== "reactiveIndex") {
+		throw new TypeError("restore state kind must be reactiveIndex");
+	}
+	return state.state;
+}
+
+/** D161 synchronous collection-owned restore. This helper never reads storage. */
+export function restoreReactiveList<T = unknown>(
+	state: ReactiveListRestoreState<T> | readonly T[],
+	options: ReactiveListOptions = {},
+): ReactiveList<T> {
+	const values = restoreListValues(state);
+	return reactiveList<T>(values, options);
+}
+
+/** D161 synchronous collection-owned restore. This helper never reads storage. */
+export function restoreReactiveLog<T = unknown>(
+	state: ReactiveLogRestoreState<T> | readonly T[],
+	options: ReactiveLogOptions = {},
+): ReactiveLog<T> {
+	const values = restoreLogValues(state);
+	return reactiveLog<T>(values, options);
+}
+
+/** D161 synchronous collection-owned restore for map entries; policy config still comes from options. */
+export function restoreReactiveMap<K = unknown, V = unknown>(
+	state: ReactiveMapRestoreState<K, V> | readonly (readonly [K, V])[],
+	options: ReactiveMapOptions<K, V> = {},
+): ReactiveMap<K, V> {
+	const entries = restoreMapEntries(state);
+	return restoreReactiveMapFromBackendState<K, V>(entries, options);
+}
+
+/** D161 synchronous collection-owned restore for sorted index rows; key-codec I/O stays outside. */
+export function restoreReactiveIndex<K = unknown, V = unknown>(
+	state: ReactiveIndexRestoreState<K, V> | readonly IndexRow<K, V>[],
+	options: ReactiveIndexOptions = {},
+): ReactiveIndex<K, V> {
+	const rows = restoreIndexRows(state);
+	return restoreReactiveIndexFromBackendState<K, V>(rows, options);
+}
diff --git a/packages/ts/src/data/index.ts b/packages/ts/src/data/index.ts
new file mode 100644
index 00000000..60da24e2
--- /dev/null
+++ b/packages/ts/src/data/index.ts
@@ -0,0 +1,38 @@
+/**
+ * Passive DATA-level result vocabulary (D184).
+ *
+ * These shapes are ordinary payload facts. They are not protocol ERROR messages and
+ * carry no wave terminal or lifecycle semantics.
+ */
+
+export interface DataIssue {
+	readonly kind: "issue";
+	readonly code: string;
+	readonly message: string;
+	readonly severity?: "info" | "warning" | "error";
+	readonly source?: string;
+	readonly subjectId?: string;
+	readonly correlationId?: string;
+	readonly causationId?: string;
+	readonly path?: readonly (string | number)[];
+	readonly refs?: readonly string[];
+	readonly retryable?: boolean;
+	readonly details?: unknown;
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface DataOk<T> {
+	readonly kind: "ok";
+	readonly value: T;
+	readonly issues?: readonly DataIssue[];
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface DataError<E extends DataIssue = DataIssue> {
+	readonly kind: "error";
+	readonly error: E;
+	readonly issues?: readonly DataIssue[];
+	readonly metadata?: Record<string, unknown>;
+}
+
+export type DataResult<T, E extends DataIssue = DataIssue> = DataOk<T> | DataError<E>;
diff --git a/packages/ts/src/dispatcher/index.ts b/packages/ts/src/dispatcher/index.ts
new file mode 100644
index 00000000..4661213c
--- /dev/null
+++ b/packages/ts/src/dispatcher/index.ts
@@ -0,0 +1,180 @@
+/**
+ * Dispatcher, pools, and the pure-data Handle.
+ *
+ * Canonical authority: ~/src/graphrefly/spec/rules.jsonl
+ *   R-handle (D7), R-dispatch-all (D21), R-sync-core (D20/D21).
+ *
+ * Lifted from the validated retired handle-dispatch PoC (R8/R9):
+ * fn lives in an external pool, indexed by handle; `dispatcher.invoke` is uniformly
+ * SYNC void — async/remote behavior lives in the fn body (it kicks off async work
+ * and emits later via `ctx.down`), not in a different call mechanism.
+ */
+
+import type { Ctx, NodeFn } from "../ctx/types.js";
+
+/** A pool kind label. LocalSync + LocalAsync ship in 1.0 (D20). */
+export type PoolKind = "sync" | "async";
+
+/**
+ * Handle = pure data `(poolId, handleId)`, NO methods (R-handle / D7). A serializable
+ * index into a pool's dispatch table. node != handle.
+ */
+export interface Handle {
+	readonly poolId: number;
+	readonly handleId: number;
+}
+
+/** A dispatch pool: a flat fn table + an array-indexed sync invoke. */
+export interface Pool {
+	readonly kind: PoolKind;
+	register(fn: NodeFn): number;
+	/** Free a handle's slot so its fn closure is GC'd and the id is reused (B15). */
+	unregister(handleId: number): void;
+	invoke(handleId: number, ctx: Ctx): void;
+}
+
+/**
+ * Array-indexed fn table with a free-list (B15). `register` reuses a freed slot before
+ * growing the array, so a rewire-heavy graph (fn-swap on every replaceDeps/subscribeDep/unsubscribeDep,
+ * e.g. CSP-2.7 higher-order *Map operators) keeps the table bounded to its peak live size
+ * instead of leaking a slot + closure per swap. `unregister` tombstones the slot (drops the
+ * closure reference for GC) and offers the id for reuse. handleId reuse is safe: the graph is
+ * a single causal domain (D22) and D37 forbids a fn rewiring its own handle mid-run, so a
+ * freed id is never re-registered while an invoke of it is in flight. The hot path stays a
+ * raw array index (F-PERF).
+ */
+class PoolTable implements Pool {
+	constructor(readonly kind: PoolKind) {}
+	private fns: (NodeFn | undefined)[] = [];
+	private free: number[] = [];
+	register(fn: NodeFn): number {
+		const reused = this.free.pop();
+		if (reused !== undefined) {
+			this.fns[reused] = fn;
+			return reused;
+		}
+		const id = this.fns.length;
+		this.fns.push(fn);
+		return id;
+	}
+	unregister(handleId: number): void {
+		if (this.fns[handleId] === undefined) return; // already free → idempotent
+		this.fns[handleId] = undefined; // drop the closure (GC)
+		this.free.push(handleId); // offer the slot for reuse (bounded growth)
+	}
+	invoke(handleId: number, ctx: Ctx): void {
+		// A live handle always resolves to a fn; a dead/unregistered id throws (TypeError —
+		// invoking an unregistered handle is a bug, surfaced loudly). Cast keeps the hot path
+		// a raw index with no extra branch (F-PERF).
+		(this.fns[handleId] as NodeFn)(ctx);
+	}
+}
+
+/**
+ * First-class dispatcher (D21). Owns pools; graph binds to one (default = process-global,
+ * D26 — the only global singleton). Pool trait is pluggable for WorkerPool/RemotePool (D20).
+ */
+/** Per-handle profiling counters (D39 / R-profile). Lives on the dispatcher — the invoke
+ * funnel (F-DISPATCH-ALL) — NEVER on the thin node (R-node-thin). */
+export interface HandleStat {
+	invokes: number;
+	totalDurationNs: number;
+	lastDurationNs: number;
+}
+
+const statKey = (h: Handle): string => `${h.poolId}:${h.handleId}`;
+
+export class Dispatcher {
+	private pools: Pool[] = [];
+	readonly syncPoolId: number;
+	readonly asyncPoolId: number;
+
+	// opt-in profile recorder (default OFF → zero overhead, F-PERF).
+	private _recording = false;
+	private _stats = new Map<string, HandleStat>();
+	private _totalInvokes = 0;
+
+	constructor() {
+		this.syncPoolId = this.addPool(new PoolTable("sync"));
+		this.asyncPoolId = this.addPool(new PoolTable("async"));
+	}
+
+	/** Turn the profile recorder on/off (D39). Off = zero overhead on invoke. */
+	setRecording(on: boolean): void {
+		this._recording = on;
+	}
+	/** Reset accumulated profiling counters. */
+	clearStats(): void {
+		this._stats.clear();
+		this._totalInvokes = 0;
+	}
+	/** Read a handle's accumulated counters (undefined if it never ran while recording). */
+	statFor(handle: Handle): HandleStat | undefined {
+		return this._stats.get(statKey(handle));
+	}
+	/** Total fn invocations recorded across the dispatcher. */
+	get totalInvokes(): number {
+		return this._totalInvokes;
+	}
+
+	addPool(pool: Pool): number {
+		const id = this.pools.length;
+		this.pools.push(pool);
+		return id;
+	}
+
+	/** Register a fn in a pool, returning its Handle. Default pool = sync (R-sync-core). */
+	register(fn: NodeFn, pool: PoolKind | number = "sync"): Handle {
+		const poolId = pool === "sync" ? this.syncPoolId : pool === "async" ? this.asyncPoolId : pool;
+		const handleId = this.pools[poolId].register(fn);
+		return { poolId, handleId };
+	}
+
+	/**
+	 * Release a handle (B15): frees the pool slot (closure GC'd, id reusable) and drops any
+	 * accumulated profile stat so a reused id never inherits the previous tenant's counters.
+	 * Called on rewire fn-swap (node._rewire) — the old handle is dropped before the node
+	 * adopts the new one. Idempotent. NOT called on deactivate (a node's handle survives
+	 * activate↔deactivate and is reused on reactivation; only a rewire swaps it).
+	 */
+	unregister(handle: Handle): void {
+		this.pools[handle.poolId].unregister(handle.handleId);
+		// Drop the stat UNCONDITIONALLY (QA F2.1), not only while recording: if recording was
+		// OFF at unregister time the key would linger, and a later register reusing this id (the
+		// free-list) would inherit the prior tenant's counters once recording resumes. delete of
+		// an absent key is a cheap no-op; unregister is off the hot invoke path (F-PERF intact).
+		this._stats.delete(statKey(handle));
+	}
+
+	/** Uniform sync-void invoke (R-sync-core / R-dispatch-all). */
+	invoke(handle: Handle, ctx: Ctx): void {
+		if (!this._recording) {
+			this.pools[handle.poolId].invoke(handle.handleId, ctx);
+			return;
+		}
+		this._totalInvokes++;
+		const t0 = performance.now();
+		try {
+			this.pools[handle.poolId].invoke(handle.handleId, ctx);
+		} finally {
+			const dur = (performance.now() - t0) * 1e6; // ms → ns
+			const key = statKey(handle);
+			const s = this._stats.get(key) ?? {
+				invokes: 0,
+				totalDurationNs: 0,
+				lastDurationNs: 0,
+			};
+			s.invokes++;
+			s.lastDurationNs = dur;
+			s.totalDurationNs += dur;
+			this._stats.set(key, s);
+		}
+	}
+
+	poolKind(poolId: number): PoolKind {
+		return this.pools[poolId].kind;
+	}
+}
+
+/** The only global singleton (D26). Overridable by passing an explicit dispatcher. */
+export const defaultDispatcher = new Dispatcher();
diff --git a/packages/ts/src/executors/tool-provider-adapters.ts b/packages/ts/src/executors/tool-provider-adapters.ts
new file mode 100644
index 00000000..51aec77b
--- /dev/null
+++ b/packages/ts/src/executors/tool-provider-adapters.ts
@@ -0,0 +1,1801 @@
+/**
+ * Concrete Layer C tool-provider adapter pack v0 (D283/D359-D362).
+ *
+ * Adapter factories return graph-visible catalog DATA plus runtime-private
+ * bindings. Permission checks are enforced by the binding closure; catalog
+ * policy remains descriptive admission/routing/audit material, not a security
+ * boundary.
+ */
+
+import { spawnSync } from "node:child_process";
+import { realpathSync } from "node:fs";
+import { isAbsolute, relative, resolve } from "node:path";
+import type { DataIssue } from "../data/index.js";
+import type { Graph } from "../graph/graph.js";
+import type { Node } from "../node/node.js";
+import {
+	type AgentRequestStatusChanged,
+	type AgentRuntimeAuditRecord,
+	buildToolProviderExecutorOutcome,
+	type ExecutorArtifactMaterial,
+	type ExecutorOutcome,
+	localBuiltinToolProviderCatalog,
+	type SizeCapacityEvidence,
+	type SourceRef,
+	type ToolProviderAdapterInput,
+	type ToolProviderAdapterRunRequested,
+	type ToolProviderAdapterRunStatus,
+	type ToolProviderCatalog,
+	type ToolProviderCatalogEntry,
+	type ToolProviderExecutionPolicy,
+	type ToolProviderPublicTextPolicy,
+	type ToolProviderSizeLimit,
+	toolProviderAdapterRunProjector,
+} from "../orchestration/index.js";
+import type {
+	ToolProviderAdapterBinding,
+	ToolProviderAdapterRunContext,
+	ToolProviderAdapterRunResult,
+} from "./tool-provider-runtime.js";
+
+export interface ToolProviderAdapterPack<TArguments = unknown, TResult = unknown> {
+	readonly catalogs: readonly ToolProviderCatalog[];
+	readonly bindings: readonly ToolProviderAdapterBinding<TArguments, TResult>[];
+}
+
+export type LocalBuiltinToolName = "date.now" | "json.parse" | "text.concat";
+
+export interface LocalBuiltinToolArguments {
+	readonly text?: string;
+	readonly parts?: readonly unknown[];
+	readonly separator?: string;
+}
+
+export type LocalBuiltinToolResult =
+	| { readonly toolName: "date.now"; readonly epochMs: number; readonly iso: string }
+	| { readonly toolName: "json.parse"; readonly value: unknown }
+	| { readonly toolName: "text.concat"; readonly text: string };
+
+export interface LocalBuiltinToolProviderBindingOptions {
+	readonly providerId?: string;
+	readonly now?: () => number;
+	readonly maxTextChars?: number;
+}
+
+export interface LocalBuiltinToolProviderAdapterPackOptions
+	extends LocalBuiltinToolProviderBindingOptions {
+	readonly executorId?: string;
+	readonly profileId?: string;
+	readonly publicText?: ToolProviderPublicTextPolicy;
+}
+
+export interface ProcessToolArguments {
+	readonly command?: string;
+	readonly args?: readonly string[];
+	readonly cwd?: string;
+	readonly env?: Readonly<Record<string, string | number | boolean | undefined>>;
+	readonly input?: string;
+}
+
+export interface ProcessToolResult {
+	readonly command: string;
+	readonly args: readonly string[];
+	readonly cwd: string;
+	readonly exitCode: number | null;
+	readonly signal?: string;
+	readonly outputPreview?: string;
+	readonly errorPreview?: string;
+	readonly outputBytes: number;
+	readonly errorOutputBytes: number;
+	readonly truncated: boolean;
+}
+
+export interface ProcessToolAllowedCommand {
+	/** Public command key accepted in tool arguments. */
+	readonly command: string;
+	/** Runtime executable. Defaults to `command`. This stays binding-private. */
+	readonly executable?: string;
+	readonly fixedArgs?: readonly string[];
+	/** Explicit argv policy. `true` allows any argv array; omitted means no extra args. */
+	readonly allowArgs?: true | readonly string[] | ((args: readonly string[]) => boolean);
+	readonly cwd?: string;
+}
+
+export interface ProcessToolProviderBindingOptions {
+	readonly providerId?: string;
+	readonly allowedCommands?: readonly ProcessToolAllowedCommand[];
+	readonly workingDirectory?: string;
+	readonly allowedWorkingDirectories?: readonly string[];
+	readonly baseEnv?: Readonly<Record<string, string>>;
+	readonly allowedEnvKeys?: readonly string[];
+	readonly timeoutMs?: number;
+	readonly maxOutputBytes?: number;
+	readonly maxSummaryChars?: number;
+}
+
+export interface ProcessToolProviderAdapterPackOptions extends ProcessToolProviderBindingOptions {
+	readonly executorId?: string;
+	readonly profileId?: string;
+}
+
+export interface HttpToolArguments {
+	readonly url?: string;
+	readonly method?: string;
+	readonly headers?: Readonly<Record<string, string | number | boolean | undefined>>;
+	readonly body?: string;
+}
+
+export interface HttpToolResult {
+	readonly url: string;
+	readonly method: string;
+	readonly status: number;
+	readonly statusText: string;
+	readonly headers?: Readonly<Record<string, string>>;
+	readonly bodyPreview?: string;
+	readonly bodyText?: string;
+	readonly bodyBytes: number;
+	readonly bodyTruncated: boolean;
+	readonly dataMode: "inline" | "summary" | "ref";
+	readonly bodyRef?: SourceRef;
+}
+
+export interface HttpToolProviderDriverRequest {
+	readonly url: string;
+	readonly method: string;
+	readonly headers: Readonly<Record<string, string>>;
+	readonly body?: string;
+	readonly signal?: AbortSignal;
+}
+
+export interface HttpToolProviderDriverResponse {
+	readonly url?: string;
+	readonly status: number;
+	readonly statusText?: string;
+	readonly headers?: Readonly<Record<string, string>>;
+	readonly bodyText?: string;
+	readonly bodyBytes?: number;
+	readonly bodyRef?: SourceRef;
+}
+
+export interface HttpToolProviderDriver {
+	fetch(
+		request: HttpToolProviderDriverRequest,
+	): HttpToolProviderDriverResponse | PromiseLike<HttpToolProviderDriverResponse>;
+}
+
+export interface HttpToolProviderRuntimeOptions {
+	readonly name?: string;
+	readonly providerId?: string;
+	readonly executorId?: string;
+	readonly profileId?: string;
+	readonly inputs: Node<ToolProviderAdapterInput<HttpToolArguments>>;
+	readonly runRequests?: readonly Node<ToolProviderAdapterRunRequested>[];
+	readonly autoRunReadyInputs?: boolean;
+	readonly allowedOrigins?: readonly string[];
+	readonly allowedMethods?: readonly string[];
+	readonly allowedRequestHeaders?: readonly string[];
+	readonly exposedResponseHeaders?: readonly string[];
+	readonly timeoutMs?: number;
+	readonly maxResponseBytes?: number;
+	readonly maxInlineBodyChars?: number;
+	readonly approvalMode?: "auto" | "require" | "never";
+	readonly driver?: HttpToolProviderDriver;
+	readonly now?: () => number;
+	readonly publicText?: ToolProviderPublicTextPolicy;
+}
+
+export interface HttpToolProviderRuntimeBundle {
+	readonly catalogs: readonly ToolProviderCatalog[];
+	readonly runRequests: Node<ToolProviderAdapterRunRequested>;
+	readonly runStatus: Node<ToolProviderAdapterRunStatus>;
+	readonly outcomes: Node<ExecutorOutcome<HttpToolResult>>;
+	readonly status: Node<AgentRequestStatusChanged>;
+	readonly issues: Node<DataIssue>;
+	readonly audit: Node<AgentRuntimeAuditRecord>;
+	dispose(): void;
+}
+
+const LOCAL_BUILTIN_TOOLS = Object.freeze([
+	Object.freeze({
+		toolName: "date.now",
+		operation: "read",
+		resultKinds: Object.freeze(["json"]),
+		capabilities: Object.freeze({ deterministicWithInjectedClock: true }),
+	}),
+	Object.freeze({
+		toolName: "json.parse",
+		operation: "parse",
+		resultKinds: Object.freeze(["json"]),
+		capabilities: Object.freeze({ externalSideEffects: false }),
+	}),
+	Object.freeze({
+		toolName: "text.concat",
+		operation: "transform",
+		resultKinds: Object.freeze(["text"]),
+		capabilities: Object.freeze({ externalSideEffects: false }),
+	}),
+] satisfies readonly Omit<
+	ToolProviderCatalogEntry,
+	"kind" | "providerId" | "inputKind" | "profileId" | "executorId"
+>[]);
+
+export function localBuiltinToolProviderBinding(
+	opts: LocalBuiltinToolProviderBindingOptions = {},
+): ToolProviderAdapterBinding<LocalBuiltinToolArguments, LocalBuiltinToolResult> {
+	const providerId = opts.providerId ?? "local-builtin";
+	const maxTextChars = nonNegativeFinite(opts.maxTextChars, 16_384);
+	return Object.freeze({
+		providerId,
+		run(input, ctx) {
+			const toolName = input.toolName as LocalBuiltinToolName | undefined;
+			switch (toolName) {
+				case "date.now":
+					return localDateNow(input, ctx, opts.now);
+				case "json.parse":
+					return localJsonParse(input, maxTextChars);
+				case "text.concat":
+					return localTextConcat(input, maxTextChars);
+				default:
+					return blocked(
+						input,
+						"local-builtin-unsupported-tool",
+						"Local builtin tool is not supported.",
+					);
+			}
+		},
+	} satisfies ToolProviderAdapterBinding<LocalBuiltinToolArguments, LocalBuiltinToolResult>);
+}
+
+export function localBuiltinToolProviderAdapterPack(
+	opts: LocalBuiltinToolProviderAdapterPackOptions = {},
+): ToolProviderAdapterPack<LocalBuiltinToolArguments, LocalBuiltinToolResult> {
+	const providerId = opts.providerId ?? "local-builtin";
+	const catalog = localBuiltinToolProviderCatalog({
+		providerId,
+		executorId: opts.executorId ?? `${providerId}:tool-executor`,
+		profileId: opts.profileId ?? `${providerId}:tool-profile`,
+		tools: LOCAL_BUILTIN_TOOLS,
+		policyOverrides: {
+			operations: Object.freeze(["read", "parse", "transform"]),
+			redaction: Object.freeze({
+				mode: "summary",
+				summaryMaxChars: opts.publicText?.maxSummaryChars ?? 512,
+			}),
+		},
+		metadata: Object.freeze({ adapterPack: "local-builtin-v0" }),
+	});
+	return Object.freeze({
+		catalogs: Object.freeze([catalog]),
+		bindings: Object.freeze([
+			localBuiltinToolProviderBinding({
+				providerId,
+				now: opts.now,
+				maxTextChars: opts.maxTextChars ?? opts.publicText?.maxSummaryChars,
+			}),
+		]),
+	});
+}
+
+export function processToolProviderBinding(
+	opts: ProcessToolProviderBindingOptions = {},
+): ToolProviderAdapterBinding<ProcessToolArguments, ProcessToolResult> {
+	const providerId = opts.providerId ?? "process";
+	const config = processConfig(opts);
+	return Object.freeze({
+		providerId,
+		run(input) {
+			const args = processArguments(input);
+			if (args === undefined) {
+				return blocked(input, "process-invalid-arguments", "Process tool requires argv arguments.");
+			}
+			const allowed = config.allowedCommands.get(args.command);
+			if (allowed === undefined) {
+				if (config.duplicateCommands.has(args.command)) {
+					return blocked(
+						input,
+						"process-command-duplicate-allowlist",
+						"Process command has duplicate allowlist entries.",
+					);
+				}
+				if (config.invalidCommands.has(args.command)) {
+					return blocked(
+						input,
+						"process-command-invalid-allowlist",
+						"Process command has an invalid allowlist entry.",
+					);
+				}
+				return blocked(input, "process-command-not-allowed", "Process command is not allowlisted.");
+			}
+			if (!argsAllowed(allowed, args.args)) {
+				return blocked(input, "process-argv-not-allowed", "Process argv is not allowlisted.");
+			}
+			const cwd = resolveProcessCwd(args.cwd, allowed, config);
+			if (cwd === undefined) {
+				return blocked(
+					input,
+					"process-cwd-not-allowed",
+					"Process cwd is outside the allowed policy.",
+				);
+			}
+			const env = processEnv(args.env, config);
+			if (env === undefined) {
+				return blocked(
+					input,
+					"process-env-not-allowed",
+					"Process env contains non-allowlisted keys.",
+				);
+			}
+			return runProcessTool(input, allowed, args, cwd, env, config);
+		},
+	} satisfies ToolProviderAdapterBinding<ProcessToolArguments, ProcessToolResult>);
+}
+
+export function processToolProviderAdapterPack(
+	opts: ProcessToolProviderAdapterPackOptions = {},
+): ToolProviderAdapterPack<ProcessToolArguments, ProcessToolResult> {
+	const providerId = opts.providerId ?? "process";
+	const executorId = opts.executorId ?? `${providerId}:tool-executor`;
+	const profileId = opts.profileId ?? `${providerId}:tool-profile`;
+	return Object.freeze({
+		catalogs: Object.freeze([
+			processToolProviderCatalog({ ...opts, providerId, executorId, profileId }),
+		]),
+		bindings: Object.freeze([processToolProviderBinding({ ...opts, providerId })]),
+	});
+}
+
+export function processToolProviderCatalog(
+	opts: ProcessToolProviderAdapterPackOptions = {},
+): ToolProviderCatalog {
+	const providerId = opts.providerId ?? "process";
+	const executorId = opts.executorId ?? `${providerId}:tool-executor`;
+	const profileId = opts.profileId ?? `${providerId}:tool-profile`;
+	const normalized = normalizeAllowedCommands(opts.allowedCommands ?? []);
+	const allowedCommands = Object.freeze([...normalized.commands.values()]);
+	const issueList = [
+		...(allowedCommands.length === 0
+			? [
+					issue(
+						"process-tool-provider-empty-allowlist",
+						"Process tool provider has no allowlisted commands and will deny execution.",
+						"warning",
+					),
+				]
+			: []),
+		...[...normalized.duplicates].map((command) =>
+			issue(
+				"process-tool-provider-duplicate-allowlist",
+				"Process tool provider has duplicate command allowlist entries.",
+				"error",
+				{ command },
+			),
+		),
+		...[...normalized.invalids].map((command) =>
+			issue(
+				"process-tool-provider-invalid-allowlist",
+				"Process tool provider has invalid command allowlist entries.",
+				"error",
+				{ command },
+			),
+		),
+	];
+	const issues = issueList.length === 0 ? undefined : Object.freeze(issueList);
+	const policy = processToolProviderExecutionPolicy(providerId, profileId, opts);
+	const tool = Object.freeze({
+		kind: "tool-catalog-entry",
+		providerId,
+		toolName: "process.execFile",
+		operation: "run",
+		inputKind: "tool-call",
+		profileId,
+		executorId,
+		resultKinds: Object.freeze(["process-result"]),
+		capabilities: Object.freeze({
+			argv: true,
+			shell: false,
+			commands: Object.freeze(allowedCommands.map((cmd) => cmd.command)),
+			env: Object.freeze({ allowedKeys: Object.freeze([...(opts.allowedEnvKeys ?? [])]) }),
+		}),
+		policyRefs: Object.freeze([{ kind: "tool-provider-execution-policy", id: policy.policyId }]),
+	} satisfies ToolProviderCatalogEntry);
+	return Object.freeze({
+		kind: "tool-provider-catalog",
+		providerId,
+		providerKind: "process",
+		status: issues === undefined ? "ready" : "misconfigured",
+		profiles: Object.freeze([
+			Object.freeze({
+				profileId,
+				executorId,
+				kind: "tool",
+				acceptedInputKinds: Object.freeze(["tool-call"]),
+				acceptedResultKinds: Object.freeze(["process-result"]),
+				capabilities: Object.freeze({
+					toolNames: Object.freeze([tool.toolName]),
+					argv: true,
+					shell: false,
+				}),
+				policyRefs: Object.freeze([
+					{ kind: "tool-provider-execution-policy", id: policy.policyId },
+				]),
+			}),
+		]),
+		tools: Object.freeze([tool]),
+		policies: Object.freeze([policy]),
+		policyRefs: Object.freeze([{ kind: "tool-provider-execution-policy", id: policy.policyId }]),
+		issues,
+		metadata: Object.freeze({ adapterPack: "process-v0" }),
+	} satisfies ToolProviderCatalog);
+}
+
+export function httpToolProviderCatalog(
+	opts: Omit<HttpToolProviderRuntimeOptions, "inputs" | "runRequests" | "driver"> = {},
+): ToolProviderCatalog {
+	const providerId = opts.providerId ?? "http";
+	const executorId = opts.executorId ?? `${providerId}:tool-executor`;
+	const profileId = opts.profileId ?? `${providerId}:tool-profile`;
+	const allowedOrigins = Object.freeze([...(opts.allowedOrigins ?? [])]);
+	const allowedMethods = Object.freeze(normalizeMethods(opts.allowedMethods ?? ["GET"]));
+	const maxResponseBytes = Math.max(1, nonNegativeFinite(opts.maxResponseBytes, 64 * 1024));
+	const policy = httpToolProviderExecutionPolicy(providerId, profileId, opts);
+	const issues = Object.freeze([
+		...(allowedOrigins.length === 0
+			? [
+					issue(
+						"http-tool-provider-empty-origin-allowlist",
+						"HTTP tool provider has no allowlisted origins and will deny execution.",
+						"warning",
+					),
+				]
+			: []),
+		...(allowedMethods.length === 0
+			? [
+					issue(
+						"http-tool-provider-empty-method-allowlist",
+						"HTTP tool provider has no allowlisted methods and will deny execution.",
+					),
+				]
+			: []),
+	]);
+	const tool = Object.freeze({
+		kind: "tool-catalog-entry",
+		providerId,
+		toolName: "http.fetch",
+		operation: "fetch",
+		inputKind: "tool-call",
+		profileId,
+		executorId,
+		resultKinds: Object.freeze(["http-result"]),
+		capabilities: Object.freeze({
+			origins: allowedOrigins,
+			methods: allowedMethods,
+			maxResponseBytes,
+			asyncRuntime: true,
+		}),
+		policyRefs: Object.freeze([{ kind: "tool-provider-execution-policy", id: policy.policyId }]),
+	} satisfies ToolProviderCatalogEntry);
+	return Object.freeze({
+		kind: "tool-provider-catalog",
+		providerId,
+		providerKind: "http",
+		status: issues.length === 0 ? "ready" : "misconfigured",
+		profiles: Object.freeze([
+			Object.freeze({
+				profileId,
+				executorId,
+				kind: "tool",
+				acceptedInputKinds: Object.freeze(["tool-call"]),
+				acceptedResultKinds: Object.freeze(["http-result"]),
+				capabilities: Object.freeze({
+					toolNames: Object.freeze([tool.toolName]),
+					asyncRuntime: true,
+				}),
+				policyRefs: Object.freeze([
+					{ kind: "tool-provider-execution-policy", id: policy.policyId },
+				]),
+			}),
+		]),
+		tools: Object.freeze([tool]),
+		policies: Object.freeze([policy]),
+		policyRefs: Object.freeze([{ kind: "tool-provider-execution-policy", id: policy.policyId }]),
+		issues: issues.length === 0 ? undefined : issues,
+		metadata: Object.freeze({ adapterPack: "http-v0", asyncRuntime: true }),
+	} satisfies ToolProviderCatalog);
+}
+
+export function httpToolProviderRuntime(
+	graph: Graph,
+	opts: HttpToolProviderRuntimeOptions,
+): HttpToolProviderRuntimeBundle {
+	const name = opts.name ?? "httpToolProviderRuntime";
+	const providerId = opts.providerId ?? "http";
+	const catalog = httpToolProviderCatalog(opts);
+	const outcomes = graph.node<ExecutorOutcome<HttpToolResult>>([], null, {
+		name: `${name}/outcomes`,
+	});
+	const runStatus = graph.node<ToolProviderAdapterRunStatus>([], null, {
+		name: `${name}/runStatus`,
+	});
+	const status = graph.node<AgentRequestStatusChanged>([], null, { name: `${name}/status` });
+	const issues = graph.node<DataIssue>([], null, { name: `${name}/issues` });
+	const audit = graph.node<AgentRuntimeAuditRecord>([], null, { name: `${name}/audit` });
+	const inputs = new Map<string, ToolProviderAdapterInput<HttpToolArguments>>();
+	const executions = new Set<string>();
+	const active = new Set<AbortController>();
+	const config = httpRuntimeConfig(opts);
+	const driver = opts.driver ?? defaultHttpToolProviderDriver(config.maxResponseBytes);
+	const forwardedRunStatusKeys = new Set<string>();
+	let auditSeq = 0;
+	let disposed = false;
+
+	function nowMs(): number | undefined {
+		return opts.now?.();
+	}
+
+	function publishIssue(nextIssue: DataIssue): void {
+		issues.down([["DATA", nextIssue]]);
+	}
+
+	function publishAudit(
+		kind: string,
+		subjectId: string,
+		metadata?: Record<string, unknown>,
+		issueCode?: string,
+	): void {
+		auditSeq += 1;
+		audit.down([
+			[
+				"DATA",
+				{
+					id: `${name}:audit:${auditSeq}`,
+					kind,
+					subjectId,
+					...(issueCode === undefined ? {} : { issueCode }),
+					...(metadata === undefined ? {} : { metadata }),
+				} satisfies AgentRuntimeAuditRecord,
+			],
+		]);
+	}
+
+	function publishRunStatus(
+		request: ToolProviderAdapterRunRequested,
+		nextStatus: ToolProviderAdapterRunStatus["status"],
+		statusIssues?: readonly DataIssue[],
+		outcomeId?: string,
+	): void {
+		forwardedRunStatusKeys.add(`${request.runId}:${nextStatus}`);
+		runStatus.down([
+			[
+				"DATA",
+				{
+					kind: "tool-provider-adapter-run-status",
+					runId: request.runId,
+					adapterInputId: request.adapterInputId,
+					requestId: request.requestId,
+					operationId: request.operationId,
+					status: nextStatus,
+					attempt: request.attempt,
+					...(outcomeId === undefined ? {} : { outcomeId }),
+					...(statusIssues === undefined ? {} : { issues: statusIssues }),
+					sourceRefs: request.sourceRefs,
+					metadata: Object.freeze({ providerId, reason: request.reason }),
+				} satisfies ToolProviderAdapterRunStatus,
+			],
+		]);
+	}
+
+	function publishRequestStatus(
+		input: ToolProviderAdapterInput<HttpToolArguments>,
+		nextStatus: AgentRequestStatusChanged["status"],
+		statusIssues?: readonly DataIssue[],
+	): void {
+		if (input.effectRunId === undefined) return;
+		status.down([
+			[
+				"DATA",
+				{
+					kind: "status",
+					requestId: input.requestId,
+					operationId: input.operationId,
+					effectRunId: input.effectRunId,
+					status: nextStatus,
+					sourceRefs: defaultEvidenceRefs(input),
+					...(statusIssues === undefined ? {} : { issues: statusIssues }),
+					metadata: Object.freeze({
+						adapterInputId: input.adapterInputId,
+						providerId: input.providerId,
+						toolName: input.toolName,
+					}),
+				} satisfies AgentRequestStatusChanged,
+			],
+		]);
+	}
+
+	function publishOutcome(
+		input: ToolProviderAdapterInput<HttpToolArguments>,
+		request: ToolProviderAdapterRunRequested,
+		result: ToolProviderAdapterRunResult<HttpToolResult>,
+	): void {
+		const outcome = buildToolProviderExecutorOutcome(input, result, {
+			runId: request.runId,
+			attempt: request.attempt,
+			occurredAtMs: nowMs(),
+			publicText: opts.publicText,
+		});
+		outcomes.down([["DATA", outcome]]);
+		const statusIssues = outcomeIssues(outcome);
+		for (const statusIssue of statusIssues) publishIssue(statusIssue);
+		publishRequestStatus(input, agentStatusForOutcome(outcome), statusIssues);
+		publishRunStatus(request, outcome.kind, statusIssues, outcome.outcomeId);
+		publishAudit("http-tool-provider-runtime-finished", input.requestId, {
+			runId: request.runId,
+			attempt: request.attempt,
+			status: outcome.kind,
+			outcomeId: outcome.outcomeId,
+		});
+	}
+
+	function execute(request: ToolProviderAdapterRunRequested): void {
+		if (disposed || (request.providerId !== undefined && request.providerId !== providerId)) return;
+		const input = inputs.get(request.adapterInputId);
+		if (input === undefined || input.providerId !== providerId) return;
+		const coordinate = `${request.runId}:${request.adapterInputId}:${request.attempt}`;
+		if (executions.has(coordinate)) return;
+		executions.add(coordinate);
+		publishRunStatus(request, "requested");
+		if (input.status !== "ready") {
+			const inputIssue = issue(
+				"http-tool-provider-input-not-ready",
+				"HTTP tool provider runtime requires a ready adapter input.",
+			);
+			publishIssue(inputIssue);
+			publishRunStatus(request, "stale-request", [inputIssue]);
+			publishRequestStatus(input, "blocked", [inputIssue]);
+			return;
+		}
+		if (!requestMatchesInput(request, input)) {
+			const mismatch = issue(
+				"http-tool-provider-run-request-mismatched-input",
+				"HTTP tool provider run request does not match its adapter input.",
+			);
+			publishIssue(mismatch);
+			publishRunStatus(request, "mismatched-request", [mismatch]);
+			publishRequestStatus(input, "blocked", [mismatch]);
+			return;
+		}
+		const prepared = prepareHttpRequest(input, config);
+		if (prepared.kind === "blocked") {
+			publishOutcome(input, request, {
+				kind: "blocked",
+				needs: Object.freeze([
+					Object.freeze({
+						kind: prepared.issue.code,
+						message: prepared.issue.message,
+					}),
+				]),
+				issues: Object.freeze([prepared.issue]),
+				evidenceRefs: defaultEvidenceRefs(input),
+			});
+			return;
+		}
+		if (config.approvalMode === "never") {
+			publishOutcome(input, request, {
+				kind: "blocked",
+				needs: Object.freeze([
+					Object.freeze({
+						kind: "tool-provider-approval-disabled",
+						message: "HTTP tool provider policy disallows execution.",
+					}),
+				]),
+				issues: Object.freeze([
+					issue("http-tool-provider-approval-never", "HTTP tool provider execution is disabled."),
+				]),
+				evidenceRefs: defaultEvidenceRefs(input),
+			});
+			return;
+		}
+		if (config.approvalMode === "require" && !requestApproved(request)) {
+			publishOutcome(input, request, {
+				kind: "blocked",
+				needs: Object.freeze([
+					Object.freeze({
+						kind: "tool-provider-approval",
+						message: "HTTP tool provider execution requires a visible approval run request.",
+					}),
+				]),
+				issues: Object.freeze([
+					issue(
+						"http-tool-provider-approval-required",
+						"HTTP tool provider execution requires approval.",
+					),
+				]),
+				evidenceRefs: defaultEvidenceRefs(input),
+			});
+			return;
+		}
+		const controller = new AbortController();
+		active.add(controller);
+		publishRunStatus(request, "started");
+		publishRequestStatus(input, "in-flight");
+		publishAudit("http-tool-provider-runtime-started", input.requestId, {
+			runId: request.runId,
+			attempt: request.attempt,
+			method: prepared.request.method,
+			origin: new URL(prepared.request.url).origin,
+		});
+		const timeout = setTimeout(() => controller.abort(), config.timeoutMs);
+		Promise.resolve(driver.fetch({ ...prepared.request, signal: controller.signal })).then(
+			(response) => {
+				clearTimeout(timeout);
+				active.delete(controller);
+				if (disposed) return;
+				publishOutcome(input, request, httpResponseResult(prepared.request, response, config));
+			},
+			(error: unknown) => {
+				clearTimeout(timeout);
+				active.delete(controller);
+				if (disposed) return;
+				publishOutcome(input, request, httpErrorResult(error, config));
+			},
+		);
+	}
+
+	const unsubscribeInputs = opts.inputs.subscribe((msg) => {
+		if (msg[0] !== "DATA") return;
+		const input = msg[1] as ToolProviderAdapterInput<HttpToolArguments>;
+		if (input.providerId === providerId) inputs.set(input.adapterInputId, input);
+	});
+	const autoRunReadyInputs =
+		opts.autoRunReadyInputs ?? (opts.runRequests === undefined || opts.runRequests.length === 0);
+	const runProjector = toolProviderAdapterRunProjector(graph, {
+		name: `${name}/runs`,
+		inputs: opts.inputs,
+		runRequests: opts.runRequests,
+		autoRunReadyInputs,
+		now: opts.now,
+	});
+	const unsubscribeRunStatus = runProjector.status.subscribe((msg) => {
+		if (msg[0] !== "DATA") return;
+		const nextStatus = msg[1] as ToolProviderAdapterRunStatus;
+		const statusKey = `${nextStatus.runId}:${nextStatus.status}`;
+		if (forwardedRunStatusKeys.has(statusKey)) return;
+		forwardedRunStatusKeys.add(statusKey);
+		runStatus.down([["DATA", nextStatus]]);
+	});
+	const unsubscribeRunIssues = runProjector.issues.subscribe((msg) => {
+		if (msg[0] === "DATA") publishIssue(msg[1] as DataIssue);
+	});
+	const unsubscribeRunAudit = runProjector.audit.subscribe((msg) => {
+		if (msg[0] === "DATA") audit.down([["DATA", msg[1] as AgentRuntimeAuditRecord]]);
+	});
+	const unsubscribeRunRequests = runProjector.requests.subscribe((msg) => {
+		if (msg[0] === "DATA") execute(msg[1] as ToolProviderAdapterRunRequested);
+	});
+	return Object.freeze({
+		catalogs: Object.freeze([catalog]),
+		runRequests: runProjector.requests,
+		runStatus,
+		outcomes,
+		status,
+		issues,
+		audit,
+		dispose() {
+			if (disposed) return;
+			disposed = true;
+			unsubscribeInputs();
+			unsubscribeRunStatus();
+			unsubscribeRunIssues();
+			unsubscribeRunAudit();
+			unsubscribeRunRequests();
+			for (const controller of active) controller.abort();
+			active.clear();
+		},
+	} satisfies HttpToolProviderRuntimeBundle);
+}
+
+function localDateNow(
+	input: ToolProviderAdapterInput<LocalBuiltinToolArguments>,
+	ctx: ToolProviderAdapterRunContext,
+	now: (() => number) | undefined,
+): ToolProviderAdapterRunResult<LocalBuiltinToolResult> {
+	const epochMs = now?.() ?? ctx.now?.() ?? Date.now();
+	return Object.freeze({
+		kind: "result",
+		result: Object.freeze({
+			kind: "json",
+			value: Object.freeze({
+				toolName: "date.now" as const,
+				epochMs,
+				iso: new Date(epochMs).toISOString(),
+			}),
+			summary: String(epochMs),
+		}),
+		occurredAtMs: epochMs,
+		evidenceRefs: input.sourceRefs,
+	} satisfies ToolProviderAdapterRunResult<LocalBuiltinToolResult>);
+}
+
+function localJsonParse(
+	input: ToolProviderAdapterInput<LocalBuiltinToolArguments>,
+	maxTextChars: number,
+): ToolProviderAdapterRunResult<LocalBuiltinToolResult> {
+	const text = input.toolCall?.arguments?.text;
+	if (typeof text !== "string") {
+		return failure(
+			input,
+			"local-json-parse-missing-text",
+			"json.parse requires a string text argument.",
+		);
+	}
+	if (text.length > maxTextChars) {
+		return failure(
+			input,
+			"local-json-parse-text-too-large",
+			"json.parse text exceeds maxTextChars.",
+		);
+	}
+	try {
+		const value = JSON.parse(text) as unknown;
+		return Object.freeze({
+			kind: "result",
+			result: Object.freeze({
+				kind: "json",
+				value: Object.freeze({ toolName: "json.parse" as const, value }),
+				summary: "parsed JSON",
+			}),
+			evidenceRefs: input.sourceRefs,
+		} satisfies ToolProviderAdapterRunResult<LocalBuiltinToolResult>);
+	} catch {
+		return failure(input, "local-json-parse-invalid-json", "json.parse received invalid JSON.");
+	}
+}
+
+function localTextConcat(
+	input: ToolProviderAdapterInput<LocalBuiltinToolArguments>,
+	maxTextChars: number,
+): ToolProviderAdapterRunResult<LocalBuiltinToolResult> {
+	const parts = input.toolCall?.arguments?.parts;
+	if (!Array.isArray(parts)) {
+		return failure(input, "local-text-concat-missing-parts", "text.concat requires a parts array.");
+	}
+	const separator = input.toolCall?.arguments?.separator ?? "";
+	if (typeof separator !== "string") {
+		return failure(
+			input,
+			"local-text-concat-invalid-separator",
+			"text.concat separator must be a string.",
+		);
+	}
+	const text = parts.map((part) => String(part)).join(separator);
+	if (text.length > maxTextChars) {
+		return failure(
+			input,
+			"local-text-concat-too-large",
+			"text.concat result exceeds maxTextChars.",
+		);
+	}
+	return Object.freeze({
+		kind: "result",
+		result: Object.freeze({
+			kind: "text",
+			value: Object.freeze({ toolName: "text.concat" as const, text }),
+			summary: text,
+		}),
+		evidenceRefs: input.sourceRefs,
+	} satisfies ToolProviderAdapterRunResult<LocalBuiltinToolResult>);
+}
+
+interface ProcessConfig {
+	readonly allowedCommands: ReadonlyMap<string, ProcessToolAllowedCommand>;
+	readonly duplicateCommands: ReadonlySet<string>;
+	readonly invalidCommands: ReadonlySet<string>;
+	readonly workingDirectory: string;
+	readonly allowedWorkingDirectories: readonly string[];
+	readonly baseEnv: Readonly<Record<string, string>>;
+	readonly allowedEnvKeys: ReadonlySet<string>;
+	readonly timeoutMs: number;
+	readonly maxOutputBytes: number;
+	readonly maxSummaryChars: number;
+}
+
+function processConfig(opts: ProcessToolProviderBindingOptions): ProcessConfig {
+	const workingDirectory = resolve(opts.workingDirectory ?? ".");
+	const allowedWorkingDirectories = Object.freeze(
+		(opts.allowedWorkingDirectories ?? [workingDirectory]).map((dir) => resolve(dir)),
+	);
+	const allowed = normalizeAllowedCommands(opts.allowedCommands ?? []);
+	return {
+		allowedCommands: allowed.commands,
+		duplicateCommands: allowed.duplicates,
+		invalidCommands: allowed.invalids,
+		workingDirectory,
+		allowedWorkingDirectories,
+		baseEnv: Object.freeze({ ...(opts.baseEnv ?? {}) }),
+		allowedEnvKeys: new Set(opts.allowedEnvKeys ?? []),
+		timeoutMs: positiveFinite(opts.timeoutMs, 10_000),
+		maxOutputBytes: Math.max(1, nonNegativeFinite(opts.maxOutputBytes, 64 * 1024)),
+		maxSummaryChars: Math.max(1, nonNegativeFinite(opts.maxSummaryChars, 512)),
+	};
+}
+
+function processArguments(
+	input: ToolProviderAdapterInput<ProcessToolArguments>,
+):
+	| (Required<Pick<ProcessToolArguments, "command" | "args">> &
+			Pick<ProcessToolArguments, "cwd" | "env" | "input">)
+	| undefined {
+	const raw = input.toolCall?.arguments;
+	if (!isRecord(raw) || typeof raw.command !== "string" || raw.command.length === 0) {
+		return undefined;
+	}
+	const rawArgs = raw.args === undefined ? Object.freeze([]) : stringArray(raw.args);
+	if (rawArgs === undefined) return undefined;
+	if (raw.cwd !== undefined && typeof raw.cwd !== "string") return undefined;
+	if (raw.input !== undefined && typeof raw.input !== "string") return undefined;
+	const rawEnv = raw.env === undefined ? undefined : processArgumentEnv(raw.env);
+	if (raw.env !== undefined && rawEnv === undefined) return undefined;
+	return {
+		command: raw.command,
+		args: rawArgs,
+		...(raw.cwd === undefined ? {} : { cwd: raw.cwd }),
+		...(rawEnv === undefined ? {} : { env: rawEnv }),
+		...(raw.input === undefined ? {} : { input: raw.input }),
+	};
+}
+
+function argsAllowed(command: ProcessToolAllowedCommand, args: readonly string[]): boolean {
+	if (command.allowArgs === true) return true;
+	if (typeof command.allowArgs === "function") return command.allowArgs(args);
+	if (command.allowArgs === undefined) return args.length === 0;
+	return arraysEqual(command.allowArgs, args);
+}
+
+function resolveProcessCwd(
+	requestedCwd: string | undefined,
+	command: ProcessToolAllowedCommand,
+	config: ProcessConfig,
+): string | undefined {
+	const rawCwd = command.cwd ?? requestedCwd;
+	const cwd =
+		rawCwd === undefined
+			? config.workingDirectory
+			: isAbsolute(rawCwd)
+				? resolve(rawCwd)
+				: resolve(config.workingDirectory, rawCwd);
+	const realCwd = realpath(cwd);
+	if (realCwd === undefined) return undefined;
+	return config.allowedWorkingDirectories.some((allowed) => {
+		const realAllowed = realpath(allowed);
+		return realAllowed !== undefined && isPathInside(realCwd, realAllowed);
+	})
+		? cwd
+		: undefined;
+}
+
+function processEnv(
+	inputEnv: ProcessToolArguments["env"],
+	config: ProcessConfig,
+): Readonly<Record<string, string>> | undefined {
+	const env: Record<string, string> = { ...config.baseEnv };
+	for (const [key, value] of Object.entries(inputEnv ?? {})) {
+		if (!config.allowedEnvKeys.has(key)) return undefined;
+		if (value !== undefined) env[key] = String(value);
+	}
+	return Object.freeze(env);
+}
+
+function processArgumentEnv(value: unknown): ProcessToolArguments["env"] | undefined {
+	if (!isRecord(value)) return undefined;
+	const env: Record<string, string | number | boolean | undefined> = {};
+	for (const [key, entry] of Object.entries(value)) {
+		if (
+			entry !== undefined &&
+			typeof entry !== "string" &&
+			typeof entry !== "number" &&
+			typeof entry !== "boolean"
+		) {
+			return undefined;
+		}
+		env[key] = entry;
+	}
+	return Object.freeze(env);
+}
+
+function runProcessTool(
+	input: ToolProviderAdapterInput<ProcessToolArguments>,
+	allowed: ProcessToolAllowedCommand,
+	args: Required<Pick<ProcessToolArguments, "command" | "args">> &
+		Pick<ProcessToolArguments, "input">,
+	cwd: string,
+	env: Readonly<Record<string, string>>,
+	config: ProcessConfig,
+): ToolProviderAdapterRunResult<ProcessToolResult> {
+	const executable = allowed.executable ?? args.command;
+	const argv = Object.freeze([...(allowed.fixedArgs ?? []), ...args.args]);
+	const result = spawnSync(executable, argv, {
+		cwd,
+		env,
+		input: args.input,
+		encoding: "buffer",
+		shell: false,
+		timeout: config.timeoutMs,
+		maxBuffer: config.maxOutputBytes + 1,
+	});
+	const stdout = result.stdout ?? Buffer.alloc(0);
+	const stderr = result.stderr ?? Buffer.alloc(0);
+	const truncated = stdout.length + stderr.length > config.maxOutputBytes;
+	if (result.error !== undefined && isTimeoutError(result.error)) {
+		return Object.freeze({
+			kind: "timeout",
+			timeoutMs: config.timeoutMs,
+			retryable: true,
+			evidenceRefs: input.sourceRefs,
+		} satisfies ToolProviderAdapterRunResult<ProcessToolResult>);
+	}
+	if (result.error !== undefined || truncated) {
+		return failure(
+			input,
+			truncated || isOutputLimitError(result.error)
+				? "process-output-limit-exceeded"
+				: "process-spawn-failed",
+			truncated || isOutputLimitError(result.error)
+				? "Process output exceeded maxOutputBytes."
+				: "Process execution failed before producing an exit result.",
+		);
+	}
+	const value = processResult(
+		args.command,
+		argv,
+		cwd,
+		result.status,
+		result.signal,
+		stdout,
+		stderr,
+		config,
+	);
+	if ((result.status ?? 1) !== 0) {
+		return Object.freeze({
+			kind: "failure",
+			error: issue("process-exit-nonzero", "Process exited with a non-zero status.", "error", {
+				exitCode: result.status,
+				signal: result.signal ?? undefined,
+			}),
+			retryable: false,
+			evidenceRefs: input.sourceRefs,
+			metadata: Object.freeze({
+				command: args.command,
+				exitCode: result.status,
+				signal: result.signal ?? undefined,
+				outputBytes: value.outputBytes,
+				errorOutputBytes: value.errorOutputBytes,
+			}),
+		} satisfies ToolProviderAdapterRunResult<ProcessToolResult>);
+	}
+	return Object.freeze({
+		kind: "result",
+		result: Object.freeze({
+			kind: "process-result",
+			value,
+			summary: value.outputPreview ?? `process exited ${value.exitCode ?? 0}`,
+			artifacts: processArtifacts(stdout, stderr, config, input.sourceRefs),
+		}),
+		evidenceRefs: input.sourceRefs,
+	} satisfies ToolProviderAdapterRunResult<ProcessToolResult>);
+}
+
+function processResult(
+	command: string,
+	args: readonly string[],
+	cwd: string,
+	exitCode: number | null,
+	signal: NodeJS.Signals | null,
+	stdout: Buffer,
+	stderr: Buffer,
+	config: ProcessConfig,
+): ProcessToolResult {
+	return Object.freeze({
+		command,
+		args,
+		cwd,
+		exitCode,
+		...(signal === null ? {} : { signal }),
+		outputPreview: preview(stdout, config.maxSummaryChars),
+		errorPreview: preview(stderr, config.maxSummaryChars),
+		outputBytes: stdout.length,
+		errorOutputBytes: stderr.length,
+		truncated: false,
+	});
+}
+
+function processArtifacts(
+	stdout: Buffer,
+	stderr: Buffer,
+	config: ProcessConfig,
+	sourceRefs: readonly SourceRef[] | undefined,
+): readonly ExecutorArtifactMaterial<string>[] | undefined {
+	const artifacts = [
+		processTextArtifact("process-stdout", stdout, config, sourceRefs),
+		processTextArtifact("process-stderr", stderr, config, sourceRefs),
+	].filter((artifact): artifact is ExecutorArtifactMaterial<string> => artifact !== undefined);
+	return artifacts.length === 0 ? undefined : Object.freeze(artifacts);
+}
+
+function processTextArtifact(
+	kind: "process-stdout" | "process-stderr",
+	bytes: Buffer,
+	config: ProcessConfig,
+	sourceRefs: readonly SourceRef[] | undefined,
+): ExecutorArtifactMaterial<string> | undefined {
+	if (bytes.length === 0) return undefined;
+	const text = bytes.toString("utf8");
+	const inline = text.length <= config.maxSummaryChars;
+	return Object.freeze({
+		kind,
+		format: "text",
+		mediaType: "text/plain",
+		encoding: "utf8",
+		byteLength: bytes.length,
+		dataMode: inline ? "inline" : "summary",
+		summary: preview(bytes, config.maxSummaryChars),
+		...(inline ? { value: text } : {}),
+		...(sourceRefs === undefined ? {} : { sourceRefs }),
+		sizeEvidence: Object.freeze([
+			sizeEvidence(bytes.length, "adapter-measured-process-output", sourceRefs),
+		]),
+	} satisfies ExecutorArtifactMaterial<string>);
+}
+
+function processToolProviderExecutionPolicy(
+	providerId: string,
+	profileId: string,
+	opts: ProcessToolProviderBindingOptions,
+): ToolProviderExecutionPolicy {
+	const maxOutputBytes = Math.max(1, nonNegativeFinite(opts.maxOutputBytes, 64 * 1024));
+	return Object.freeze({
+		kind: "tool-provider-execution-policy",
+		policyId: `${providerId}:policy:process-v0`,
+		providerId,
+		profileIds: Object.freeze([profileId]),
+		toolNames: Object.freeze(["process.execFile"]),
+		operations: Object.freeze(["run"]),
+		sizeCapacity: Object.freeze({
+			limits: Object.freeze([
+				Object.freeze({
+					unit: "bytes",
+					hardLimit: maxOutputBytes,
+					perRequest: true,
+					measurementSource: "adapter-measured",
+				} satisfies ToolProviderSizeLimit),
+			]),
+		}),
+		timeout: Object.freeze({ timeoutMs: positiveFinite(opts.timeoutMs, 10_000) }),
+		redaction: Object.freeze({
+			mode: "summary",
+			summaryMaxChars: nonNegativeFinite(opts.maxSummaryChars, 512),
+		}),
+		filesystem: Object.freeze({
+			cwd: opts.workingDirectory ?? ".",
+			allowRead: false,
+			allowWrite: false,
+			followSymlinks: false,
+			pathRules: Object.freeze(
+				(opts.allowedWorkingDirectories ?? [opts.workingDirectory ?? "."]).map((path) =>
+					Object.freeze({
+						effect: "allow",
+						path,
+						operation: "run",
+						reason: "Process adapter cwd allowlist.",
+					}),
+				),
+			),
+		}),
+		approval: Object.freeze({ mode: "auto" }),
+		metadata: Object.freeze({
+			argv: true,
+			shell: false,
+			allowedEnvKeys: Object.freeze([...(opts.allowedEnvKeys ?? [])]),
+		}),
+	} satisfies ToolProviderExecutionPolicy);
+}
+
+interface HttpRuntimeConfig {
+	readonly allowedOrigins: ReadonlySet<string>;
+	readonly allowedMethods: ReadonlySet<string>;
+	readonly allowedRequestHeaders: ReadonlySet<string>;
+	readonly exposedResponseHeaders: ReadonlySet<string>;
+	readonly timeoutMs: number;
+	readonly maxResponseBytes: number;
+	readonly maxInlineBodyChars: number;
+	readonly approvalMode: "auto" | "require" | "never";
+}
+
+function httpRuntimeConfig(opts: HttpToolProviderRuntimeOptions): HttpRuntimeConfig {
+	return {
+		allowedOrigins: new Set(opts.allowedOrigins ?? []),
+		allowedMethods: new Set(normalizeMethods(opts.allowedMethods ?? ["GET"])),
+		allowedRequestHeaders: new Set(normalizeHeaderNames(opts.allowedRequestHeaders ?? [])),
+		exposedResponseHeaders: new Set(normalizeHeaderNames(opts.exposedResponseHeaders ?? [])),
+		timeoutMs: positiveFinite(opts.timeoutMs, 10_000),
+		maxResponseBytes: Math.max(1, nonNegativeFinite(opts.maxResponseBytes, 64 * 1024)),
+		maxInlineBodyChars: Math.max(1, nonNegativeFinite(opts.maxInlineBodyChars, 4_096)),
+		approvalMode: opts.approvalMode ?? "auto",
+	};
+}
+
+function httpToolProviderExecutionPolicy(
+	providerId: string,
+	profileId: string,
+	opts: Omit<HttpToolProviderRuntimeOptions, "inputs" | "runRequests" | "driver">,
+): ToolProviderExecutionPolicy {
+	const allowedOrigins = Object.freeze([...(opts.allowedOrigins ?? [])]);
+	const allowedMethods = Object.freeze(normalizeMethods(opts.allowedMethods ?? ["GET"]));
+	const maxResponseBytes = Math.max(1, nonNegativeFinite(opts.maxResponseBytes, 64 * 1024));
+	return Object.freeze({
+		kind: "tool-provider-execution-policy",
+		policyId: `${providerId}:policy:http-v0`,
+		providerId,
+		profileIds: Object.freeze([profileId]),
+		toolNames: Object.freeze(["http.fetch"]),
+		operations: Object.freeze(["fetch"]),
+		sizeCapacity: Object.freeze({
+			limits: Object.freeze([
+				Object.freeze({
+					unit: "bytes",
+					hardLimit: maxResponseBytes,
+					perRequest: true,
+					measurementSource: "adapter-measured-response-body",
+				} satisfies ToolProviderSizeLimit),
+			]),
+		}),
+		timeout: Object.freeze({ timeoutMs: positiveFinite(opts.timeoutMs, 10_000) }),
+		redaction: Object.freeze({
+			mode: "summary",
+			summaryMaxChars: nonNegativeFinite(opts.maxInlineBodyChars, 4_096),
+		}),
+		network: Object.freeze({
+			mode: "allowlist",
+			protocols: Object.freeze(["http:", "https:"]),
+			allowedHosts: allowedOrigins,
+			metadata: Object.freeze({ allowlistKind: "origin" }),
+		}),
+		approval: Object.freeze({ mode: opts.approvalMode ?? "auto" }),
+		artifacts: Object.freeze({
+			defaultDataMode: "summary",
+			inlineLimits: Object.freeze([
+				Object.freeze({
+					unit: "chars",
+					hardLimit: Math.max(1, nonNegativeFinite(opts.maxInlineBodyChars, 4_096)),
+					perArtifact: true,
+					measurementSource: "js-string-length",
+				} satisfies ToolProviderSizeLimit),
+			]),
+			artifactKinds: Object.freeze(["http-response-body"]),
+		}),
+		metadata: Object.freeze({
+			allowedOrigins,
+			allowedMethods,
+			allowedRequestHeaders: Object.freeze([...(opts.allowedRequestHeaders ?? [])]),
+			exposedResponseHeaders: Object.freeze([...(opts.exposedResponseHeaders ?? [])]),
+			asyncRuntime: true,
+		}),
+	} satisfies ToolProviderExecutionPolicy);
+}
+
+function prepareHttpRequest(
+	input: ToolProviderAdapterInput<HttpToolArguments>,
+	config: HttpRuntimeConfig,
+):
+	| { readonly kind: "ready"; readonly request: HttpToolProviderDriverRequest }
+	| { readonly kind: "blocked"; readonly issue: DataIssue } {
+	const raw = input.toolCall?.arguments;
+	if (!isRecord(raw) || typeof raw.url !== "string") {
+		return {
+			kind: "blocked",
+			issue: issue("http-invalid-arguments", "http.fetch requires a string url argument."),
+		};
+	}
+	let url: URL;
+	try {
+		url = new URL(raw.url);
+	} catch {
+		return { kind: "blocked", issue: issue("http-invalid-url", "http.fetch url is invalid.") };
+	}
+	if (url.protocol !== "http:" && url.protocol !== "https:") {
+		return {
+			kind: "blocked",
+			issue: issue("http-protocol-not-allowed", "http.fetch only allows http and https URLs."),
+		};
+	}
+	if (!config.allowedOrigins.has(url.origin)) {
+		return {
+			kind: "blocked",
+			issue: issue("http-origin-not-allowed", "http.fetch origin is not allowlisted."),
+		};
+	}
+	const method = normalizeMethod(raw.method ?? "GET");
+	if (method === undefined || !config.allowedMethods.has(method)) {
+		return {
+			kind: "blocked",
+			issue: issue("http-method-not-allowed", "http.fetch method is not allowlisted."),
+		};
+	}
+	if (raw.body !== undefined && typeof raw.body !== "string") {
+		return {
+			kind: "blocked",
+			issue: issue("http-invalid-body", "http.fetch body must be a string when provided."),
+		};
+	}
+	const headers = httpArgumentHeaders(raw.headers, config);
+	if (headers === undefined) {
+		return {
+			kind: "blocked",
+			issue: issue("http-request-header-not-allowed", "http.fetch header is not allowlisted."),
+		};
+	}
+	return {
+		kind: "ready",
+		request: Object.freeze({
+			url: url.toString(),
+			method,
+			headers,
+			...(raw.body === undefined ? {} : { body: raw.body }),
+		}),
+	};
+}
+
+function httpArgumentHeaders(
+	value: unknown,
+	config: HttpRuntimeConfig,
+): Readonly<Record<string, string>> | undefined {
+	if (value === undefined) return Object.freeze({});
+	if (!isRecord(value)) return undefined;
+	const headers: Record<string, string> = {};
+	for (const [key, entry] of Object.entries(value)) {
+		const normalized = key.toLowerCase();
+		if (!config.allowedRequestHeaders.has(normalized)) return undefined;
+		if (
+			entry !== undefined &&
+			typeof entry !== "string" &&
+			typeof entry !== "number" &&
+			typeof entry !== "boolean"
+		) {
+			return undefined;
+		}
+		if (entry !== undefined) headers[key] = String(entry);
+	}
+	return Object.freeze(headers);
+}
+
+function httpResponseResult(
+	request: HttpToolProviderDriverRequest,
+	response: HttpToolProviderDriverResponse,
+	config: HttpRuntimeConfig,
+): ToolProviderAdapterRunResult<HttpToolResult> {
+	const hasInlineBody = response.bodyText !== undefined;
+	const bodyText = response.bodyText ?? "";
+	const bodyBytes = response.bodyBytes ?? textBytes(bodyText);
+	const hasBodyRef = response.bodyRef !== undefined;
+	if (bodyBytes > config.maxResponseBytes && !hasBodyRef) {
+		return {
+			kind: "failure",
+			error: issue("http-response-too-large", "HTTP response body exceeded maxResponseBytes."),
+			retryable: false,
+			metadata: Object.freeze({ bodyBytes, maxResponseBytes: config.maxResponseBytes }),
+		};
+	}
+	const inline =
+		hasInlineBody &&
+		bodyBytes <= config.maxResponseBytes &&
+		bodyText.length <= config.maxInlineBodyChars;
+	const result: HttpToolResult = Object.freeze({
+		url: response.url ?? request.url,
+		method: request.method,
+		status: response.status,
+		statusText: response.statusText ?? "",
+		headers: filterResponseHeaders(response.headers, config.exposedResponseHeaders),
+		bodyPreview: hasInlineBody ? previewText(bodyText, config.maxInlineBodyChars) : undefined,
+		...(inline ? { bodyText } : {}),
+		bodyBytes,
+		bodyTruncated:
+			bodyBytes > config.maxResponseBytes || bodyText.length > config.maxInlineBodyChars,
+		dataMode: inline ? "inline" : hasBodyRef ? "ref" : "summary",
+		...(response.bodyRef === undefined ? {} : { bodyRef: response.bodyRef }),
+	});
+	return {
+		kind: "result",
+		result: Object.freeze({
+			kind: "http-result",
+			value: result,
+			summary: `${request.method} ${response.status} ${response.url ?? request.url}`,
+			refs: response.bodyRef === undefined ? undefined : Object.freeze([response.bodyRef]),
+			artifacts: Object.freeze([httpBodyArtifact(result, response.bodyRef)]),
+		}),
+		issues:
+			!inline && !hasBodyRef
+				? Object.freeze([
+						issue(
+							"http-response-body-summary-only",
+							"HTTP response body was summarized without a durable body ref.",
+							"warning",
+						),
+					])
+				: undefined,
+		metadata: Object.freeze({ status: response.status, bodyBytes }),
+	};
+}
+
+function httpBodyArtifact(
+	result: HttpToolResult,
+	bodyRef: SourceRef | undefined,
+): ExecutorArtifactMaterial<string> {
+	return Object.freeze({
+		kind: "http-response-body",
+		format: "text",
+		byteLength: result.bodyBytes,
+		dataMode: result.dataMode,
+		...(result.bodyPreview === undefined ? {} : { summary: result.bodyPreview }),
+		...(result.dataMode === "inline" && result.bodyText !== undefined
+			? { value: result.bodyText }
+			: {}),
+		...(bodyRef === undefined ? {} : { ref: bodyRef, refs: Object.freeze([bodyRef]) }),
+		sizeEvidence: Object.freeze([
+			sizeEvidence(result.bodyBytes, "adapter-measured-http-response-body", undefined),
+		]),
+	} satisfies ExecutorArtifactMaterial<string>);
+}
+
+function httpErrorResult(
+	error: unknown,
+	config: HttpRuntimeConfig,
+): ToolProviderAdapterRunResult<HttpToolResult> {
+	const aborted = error instanceof Error && error.name === "AbortError";
+	if (aborted) {
+		return { kind: "timeout", timeoutMs: config.timeoutMs, retryable: true };
+	}
+	return {
+		kind: "failure",
+		error: issue("http-fetch-failed", "HTTP fetch failed before producing a response."),
+		retryable: true,
+		metadata: Object.freeze({ errorType: error instanceof Error ? error.name : typeof error }),
+	};
+}
+
+function defaultHttpToolProviderDriver(maxResponseBytes: number): HttpToolProviderDriver {
+	return Object.freeze({
+		fetch(request: HttpToolProviderDriverRequest) {
+			const fetchImpl = globalThis.fetch;
+			if (typeof fetchImpl !== "function") {
+				throw new Error("global fetch is unavailable");
+			}
+			return fetchImpl(request.url, {
+				method: request.method,
+				headers: request.headers,
+				body: request.body,
+				redirect: "manual",
+				signal: request.signal,
+			}).then((response) =>
+				readResponseBody(response, maxResponseBytes).then((body) =>
+					Object.freeze({
+						url: response.url,
+						status: response.status,
+						statusText: response.statusText,
+						headers: responseHeaders(response.headers),
+						bodyText: body.text,
+						bodyBytes: body.bytes,
+					} satisfies HttpToolProviderDriverResponse),
+				),
+			);
+		},
+	});
+}
+
+function readResponseBody(
+	response: Response,
+	maxBytes: number,
+): Promise<{ readonly text: string; readonly bytes: number }> {
+	const body = response.body;
+	if (body === null) return Promise.resolve({ text: "", bytes: 0 });
+	const reader = body.getReader();
+	const decoder = new TextDecoder();
+	const chunks: string[] = [];
+	let bytes = 0;
+	function pump(): Promise<{ readonly text: string; readonly bytes: number }> {
+		return reader.read().then((next) => {
+			if (next.done) {
+				chunks.push(decoder.decode());
+				return { text: chunks.join(""), bytes };
+			}
+			bytes += next.value.byteLength;
+			if (bytes > maxBytes) {
+				reader.cancel().catch(() => {});
+				return { text: chunks.join(""), bytes };
+			}
+			chunks.push(decoder.decode(next.value, { stream: true }));
+			return pump();
+		});
+	}
+	return pump();
+}
+
+function responseHeaders(headers: Headers): Readonly<Record<string, string>> {
+	const out: Record<string, string> = {};
+	headers.forEach((value, key) => {
+		out[key] = value;
+	});
+	return Object.freeze(out);
+}
+
+function filterResponseHeaders(
+	headers: Readonly<Record<string, string>> | undefined,
+	exposed: ReadonlySet<string>,
+): Readonly<Record<string, string>> | undefined {
+	if (headers === undefined || exposed.size === 0) return undefined;
+	const out: Record<string, string> = {};
+	for (const [key, value] of Object.entries(headers)) {
+		if (exposed.has(key.toLowerCase())) out[key] = value;
+	}
+	return Object.keys(out).length === 0 ? undefined : Object.freeze(out);
+}
+
+function requestMatchesInput(
+	request: ToolProviderAdapterRunRequested,
+	input: ToolProviderAdapterInput,
+): boolean {
+	return (
+		request.adapterInputId === input.adapterInputId &&
+		request.requestId === input.requestId &&
+		request.operationId === input.operationId &&
+		(request.routeId === undefined || request.routeId === input.routeId) &&
+		(request.executorId === undefined || request.executorId === input.executorId) &&
+		(request.profileId === undefined || request.profileId === input.profileId)
+	);
+}
+
+function requestApproved(request: ToolProviderAdapterRunRequested): boolean {
+	const metadata = request.metadata;
+	return (
+		isRecord(metadata) &&
+		(metadata.approval === "granted" ||
+			metadata.approvalGranted === true ||
+			(isAdmissionApprovedMetadata(metadata) && hasAdmissionSourceRef(request.sourceRefs)))
+	);
+}
+
+function isAdmissionApprovedMetadata(metadata: Record<string, unknown>): boolean {
+	return (
+		typeof metadata.admissionId === "string" &&
+		metadata.admissionId.length > 0 &&
+		typeof metadata.proposalId === "string" &&
+		metadata.proposalId.length > 0 &&
+		typeof metadata.approvedFromRunId === "string" &&
+		metadata.approvedFromRunId.length > 0
+	);
+}
+
+function hasAdmissionSourceRef(sourceRefs: readonly SourceRef[] | undefined): boolean {
+	return (sourceRefs ?? []).some(
+		(sourceRef) =>
+			sourceRef.kind === "tool-provider-run-admission" ||
+			sourceRef.kind === "tool-provider-run-admission-decision",
+	);
+}
+
+function defaultEvidenceRefs(input: ToolProviderAdapterInput): readonly SourceRef[] {
+	return Object.freeze([
+		{ kind: "tool-provider-adapter-input", id: input.adapterInputId },
+		...(input.sourceRefs ?? []),
+	]);
+}
+
+function outcomeIssues(outcome: ExecutorOutcome): readonly DataIssue[] {
+	if (outcome.kind === "failure") return Object.freeze([outcome.error, ...(outcome.issues ?? [])]);
+	return outcome.issues ?? [];
+}
+
+function agentStatusForOutcome(outcome: ExecutorOutcome): AgentRequestStatusChanged["status"] {
+	switch (outcome.kind) {
+		case "result":
+			return "completed";
+		case "failure":
+			return "failed";
+		case "blocked":
+			return "blocked";
+		case "canceled":
+			return "canceled";
+		case "timeout":
+			return "timeout";
+	}
+}
+
+function normalizeMethods(methods: readonly string[]): readonly string[] {
+	return Object.freeze(
+		methods
+			.map((method) => normalizeMethod(method))
+			.filter((method): method is string => method !== undefined),
+	);
+}
+
+function normalizeMethod(method: unknown): string | undefined {
+	return typeof method === "string" && method.length > 0 ? method.toUpperCase() : undefined;
+}
+
+function normalizeHeaderNames(headers: readonly string[]): readonly string[] {
+	return Object.freeze(
+		headers
+			.filter((header) => typeof header === "string" && header.length > 0)
+			.map((header) => header.toLowerCase()),
+	);
+}
+
+function textBytes(text: string): number {
+	return new TextEncoder().encode(text).byteLength;
+}
+
+function previewText(text: string, maxChars: number): string | undefined {
+	if (text.length === 0) return undefined;
+	return text.length <= maxChars ? text : text.slice(0, maxChars);
+}
+
+function blocked<T>(
+	input: ToolProviderAdapterInput,
+	code: string,
+	message: string,
+): ToolProviderAdapterRunResult<T> {
+	return Object.freeze({
+		kind: "blocked",
+		needs: Object.freeze([
+			Object.freeze({
+				kind: code,
+				message,
+				refs:
+					input.providerId === undefined
+						? undefined
+						: Object.freeze([{ kind: "tool-provider", id: input.providerId }]),
+			}),
+		]),
+		issues: Object.freeze([issue(code, message, "error")]),
+		evidenceRefs: input.sourceRefs,
+	} satisfies ToolProviderAdapterRunResult<T>);
+}
+
+function failure<T>(
+	input: ToolProviderAdapterInput,
+	code: string,
+	message: string,
+): ToolProviderAdapterRunResult<T> {
+	return Object.freeze({
+		kind: "failure",
+		error: issue(code, message, "error"),
+		retryable: false,
+		evidenceRefs: input.sourceRefs,
+	} satisfies ToolProviderAdapterRunResult<T>);
+}
+
+function issue(
+	code: string,
+	message: string,
+	severity: DataIssue["severity"] = "error",
+	details?: unknown,
+): DataIssue {
+	return Object.freeze({
+		kind: "issue",
+		code,
+		message,
+		severity,
+		...(details === undefined ? {} : { details }),
+	} satisfies DataIssue);
+}
+
+function sizeEvidence(
+	quantity: number,
+	measurementSource: string,
+	sourceRefs: readonly SourceRef[] | undefined,
+): SizeCapacityEvidence {
+	return Object.freeze({
+		kind: "size-capacity-evidence",
+		unit: "bytes",
+		quantity,
+		measurementSource,
+		...(sourceRefs === undefined ? {} : { sourceRefs }),
+	} satisfies SizeCapacityEvidence);
+}
+
+function nonNegativeFinite(value: number | undefined, fallback: number): number {
+	return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : fallback;
+}
+
+function positiveFinite(value: number | undefined, fallback: number): number {
+	return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : fallback;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function stringArray(value: unknown): readonly string[] | undefined {
+	if (!Array.isArray(value)) return undefined;
+	const entries = Array.from(value);
+	if (!entries.every((entry) => typeof entry === "string")) return undefined;
+	return Object.freeze(entries);
+}
+
+function arraysEqual(a: readonly string[], b: readonly string[]): boolean {
+	return a.length === b.length && a.every((value, index) => value === b[index]);
+}
+
+function normalizeAllowedCommands(commands: readonly ProcessToolAllowedCommand[]): {
+	readonly commands: ReadonlyMap<string, ProcessToolAllowedCommand>;
+	readonly duplicates: ReadonlySet<string>;
+	readonly invalids: ReadonlySet<string>;
+} {
+	const out = new Map<string, ProcessToolAllowedCommand>();
+	const duplicates = new Set<string>();
+	const invalids = new Set<string>();
+	for (const command of commands) {
+		if (typeof command.command !== "string" || command.command.length === 0) {
+			invalids.add("<invalid-command>");
+			continue;
+		}
+		const frozen = freezeAllowedCommand(command);
+		if (frozen === undefined) {
+			out.delete(command.command);
+			invalids.add(command.command);
+			continue;
+		}
+		if (out.has(command.command)) {
+			out.delete(command.command);
+			duplicates.add(command.command);
+			continue;
+		}
+		if (duplicates.has(command.command) || invalids.has(command.command)) continue;
+		out.set(command.command, frozen);
+	}
+	return { commands: out, duplicates, invalids };
+}
+
+function freezeAllowedCommand(
+	command: ProcessToolAllowedCommand,
+): ProcessToolAllowedCommand | undefined {
+	const fixedArgs = command.fixedArgs === undefined ? undefined : stringArray(command.fixedArgs);
+	if (command.fixedArgs !== undefined && fixedArgs === undefined) return undefined;
+	const allowArgs = Array.isArray(command.allowArgs)
+		? stringArray(command.allowArgs)
+		: command.allowArgs;
+	if (Array.isArray(command.allowArgs) && allowArgs === undefined) return undefined;
+	return Object.freeze({
+		command: command.command,
+		...(command.executable === undefined ? {} : { executable: command.executable }),
+		...(fixedArgs === undefined ? {} : { fixedArgs }),
+		...(allowArgs === undefined ? {} : { allowArgs }),
+		...(command.cwd === undefined ? {} : { cwd: command.cwd }),
+	});
+}
+
+function realpath(path: string): string | undefined {
+	try {
+		return realpathSync.native(path);
+	} catch {
+		return undefined;
+	}
+}
+
+function isPathInside(path: string, root: string): boolean {
+	const normalizedPath = resolve(path);
+	const normalizedRoot = resolve(root);
+	const rel = relative(normalizedRoot, normalizedPath);
+	return rel === "" || (rel.length > 0 && !rel.startsWith("..") && !isAbsolute(rel));
+}
+
+function isTimeoutError(error: Error): boolean {
+	return (error as Error & { readonly code?: unknown }).code === "ETIMEDOUT";
+}
+
+function isOutputLimitError(error: Error | undefined): boolean {
+	return (error as (Error & { readonly code?: unknown }) | undefined)?.code === "ENOBUFS";
+}
+
+function preview(buffer: Buffer, maxChars: number): string | undefined {
+	if (buffer.length === 0) return undefined;
+	const text = buffer.toString("utf8");
+	return text.length <= maxChars ? text : text.slice(0, maxChars);
+}
diff --git a/packages/ts/src/executors/tool-provider-runtime.ts b/packages/ts/src/executors/tool-provider-runtime.ts
new file mode 100644
index 00000000..96554bc5
--- /dev/null
+++ b/packages/ts/src/executors/tool-provider-runtime.ts
@@ -0,0 +1,30 @@
+/**
+ * Focused Layer C tool-provider runtime adapter surface (D283/D359-D362).
+ *
+ * Provider-neutral tool facts and projectors stay in orchestration. This
+ * subpath exposes the runtime binding boundary that may close over clients,
+ * credentials, subprocess access, transports, SDK objects, or environment
+ * handles without making them graph DATA.
+ */
+
+export { attachToolProviderAdapterRuntime } from "../orchestration/agent-runtime-adapter-runtime.js";
+export type {
+	ToolProviderAdapterBinding,
+	ToolProviderAdapterExecutionRetentionEntry,
+	ToolProviderAdapterInputRetentionEntry,
+	ToolProviderAdapterRunContext,
+	ToolProviderAdapterRunIssueRetentionEntry,
+	ToolProviderAdapterRunRequestRetentionEntry,
+	ToolProviderAdapterRunResult,
+	ToolProviderAdapterRunStatusRetentionEntry,
+	ToolProviderAdapterRuntimeHandle,
+	ToolProviderAdapterRuntimeIndexRetentionPolicy,
+	ToolProviderAdapterRuntimeOptions,
+	ToolProviderAdapterRuntimeRetentionEvidenceEntry,
+	ToolProviderAdapterRuntimeRetentionIndex,
+	ToolProviderAdapterRuntimeRetentionOrder,
+	ToolProviderAdapterRuntimeRetentionPolicy,
+	ToolProviderAdapterRuntimeStatus,
+	ToolProviderAdapterRuntimeStatusKind,
+	ToolProviderPublicTextPolicy,
+} from "../orchestration/agent-runtime-types-tool.js";
diff --git a/packages/ts/src/executors/tool-provider.ts b/packages/ts/src/executors/tool-provider.ts
new file mode 100644
index 00000000..bc412349
--- /dev/null
+++ b/packages/ts/src/executors/tool-provider.ts
@@ -0,0 +1,152 @@
+/**
+ * Optional Layer C tool-provider execution recipe (D283/D359-D362).
+ *
+ * This module composes the provider-neutral catalog/policy/input projectors
+ * with the runtime-private adapter binding boundary. It does not provide
+ * concrete bash, filesystem, URL, MCP, CLI, Composio, or SDK bindings.
+ */
+
+import type { DataIssue } from "../data/index.js";
+import type { Graph } from "../graph/graph.js";
+import type { Node } from "../node/node.js";
+import { executorOutcomeViewProjector } from "../orchestration/agent-runtime-outcome-view.js";
+import { toolProviderAdapterInputProjector } from "../orchestration/agent-runtime-tool-provider-input.js";
+import { toolProviderPolicyResolutionProjector } from "../orchestration/agent-runtime-tool-provider-policy.js";
+import type { AgentRuntimeAuditRecord } from "../orchestration/agent-runtime-types-agent.js";
+import type {
+	AgentRequestFact,
+	AgentRequestStatusChanged,
+	ExecutorOutcome,
+	ExecutorRoute,
+} from "../orchestration/agent-runtime-types-core.js";
+import type {
+	ExecutorOutcomeViewBundle,
+	ExecutorOutcomeViewPolicy,
+	ToolProviderAdapterInputBundle,
+	ToolProviderAdapterRunRequested,
+	ToolProviderCatalog,
+	ToolProviderPolicyResolutionBundle,
+} from "../orchestration/agent-runtime-types-tool.js";
+import {
+	attachToolProviderAdapterRuntime,
+	type ToolProviderAdapterBinding,
+	type ToolProviderAdapterRuntimeHandle,
+	type ToolProviderAdapterRuntimeRetentionPolicy,
+	type ToolProviderPublicTextPolicy,
+} from "./tool-provider-runtime.js";
+
+export interface ToolProviderExecutionRecipeOptions<TArguments = unknown, TResult = unknown> {
+	readonly name?: string;
+	readonly requestFacts: Node<AgentRequestFact>;
+	readonly executorRoutes?: readonly Node<ExecutorRoute>[];
+	readonly toolProviderCatalogs?: readonly Node<ToolProviderCatalog>[];
+	readonly catalogs?: readonly ToolProviderCatalog[];
+	readonly bindings:
+		| readonly ToolProviderAdapterBinding<TArguments, TResult>[]
+		| ReadonlyMap<string, ToolProviderAdapterBinding<TArguments, TResult>>;
+	readonly runRequests?: readonly Node<ToolProviderAdapterRunRequested>[];
+	readonly autoRunReadyInputs?: boolean;
+	readonly retention?: ToolProviderAdapterRuntimeRetentionPolicy;
+	readonly now?: () => number;
+	readonly publicText?: ToolProviderPublicTextPolicy;
+	readonly outcomeViewPolicy?: ExecutorOutcomeViewPolicy;
+}
+
+export interface ToolProviderExecutionRecipeBundle {
+	readonly catalogs?: Node<ToolProviderCatalog>;
+	readonly policy: ToolProviderPolicyResolutionBundle;
+	readonly adapterInputs: ToolProviderAdapterInputBundle;
+	readonly runtime: ToolProviderAdapterRuntimeHandle;
+	readonly outcomeViews: ExecutorOutcomeViewBundle;
+	readonly outcomes: Node<ExecutorOutcome>;
+	readonly status: Node<AgentRequestStatusChanged>;
+	readonly issues: {
+		readonly policy: Node<DataIssue>;
+		readonly adapterInputs: Node<DataIssue>;
+		readonly runtime: Node<DataIssue>;
+		readonly outcomeViews: Node<DataIssue>;
+	};
+	readonly audit: {
+		readonly policy: Node<AgentRuntimeAuditRecord>;
+		readonly adapterInputs: Node<AgentRuntimeAuditRecord>;
+		readonly runtime: Node<AgentRuntimeAuditRecord>;
+		readonly outcomeViews: Node<AgentRuntimeAuditRecord>;
+	};
+	dispose(): void;
+}
+
+export function toolProviderExecutionRecipe<TArguments = unknown, TResult = unknown>(
+	graph: Graph,
+	opts: ToolProviderExecutionRecipeOptions<TArguments, TResult>,
+): ToolProviderExecutionRecipeBundle {
+	const name = opts.name ?? "toolProviderExecution";
+	const staticCatalogs = staticToolProviderCatalogNode(graph, name, opts.catalogs);
+	const catalogDeps = [
+		...(staticCatalogs === undefined ? [] : [staticCatalogs]),
+		...(opts.toolProviderCatalogs ?? []),
+	];
+	const policy = toolProviderPolicyResolutionProjector(graph, {
+		name: `${name}/policy`,
+		requestFacts: opts.requestFacts,
+		executorRoutes: opts.executorRoutes,
+		toolProviderCatalogs: catalogDeps,
+	});
+	const adapterInputs = toolProviderAdapterInputProjector(graph, {
+		name: `${name}/adapterInput`,
+		requestFacts: opts.requestFacts,
+		executorRoutes: opts.executorRoutes,
+		toolProviderCatalogs: catalogDeps,
+		policyResolutions: [policy.resolutions],
+	});
+	const runtime = attachToolProviderAdapterRuntime(graph, {
+		name: `${name}/runtime`,
+		inputs: adapterInputs.inputs,
+		runRequests: opts.runRequests,
+		bindings: opts.bindings,
+		autoRunReadyInputs: opts.autoRunReadyInputs,
+		retention: opts.retention,
+		now: opts.now,
+		publicText: opts.publicText,
+	});
+	const outcomeViews = executorOutcomeViewProjector(graph, {
+		name: `${name}/outcomeView`,
+		outcomes: runtime.outcomes,
+		policy: opts.outcomeViewPolicy,
+	});
+	return {
+		...(staticCatalogs === undefined ? {} : { catalogs: staticCatalogs }),
+		policy,
+		adapterInputs,
+		runtime,
+		outcomeViews,
+		outcomes: runtime.outcomes,
+		status: runtime.status,
+		issues: {
+			policy: policy.issues,
+			adapterInputs: adapterInputs.issues,
+			runtime: runtime.issues,
+			outcomeViews: outcomeViews.issues,
+		},
+		audit: {
+			policy: policy.audit,
+			adapterInputs: adapterInputs.audit,
+			runtime: runtime.audit,
+			outcomeViews: outcomeViews.audit,
+		},
+		dispose: () => runtime.dispose(),
+	};
+}
+
+function staticToolProviderCatalogNode(
+	graph: Graph,
+	name: string,
+	catalogs: readonly ToolProviderCatalog[] | undefined,
+): Node<ToolProviderCatalog> | undefined {
+	if (catalogs === undefined || catalogs.length === 0) return undefined;
+	return graph.producer<ToolProviderCatalog>(
+		(ctx) => {
+			ctx.down(catalogs.map((catalog) => ["DATA", catalog] as const));
+		},
+		{ name: `${name}/catalogs`, factory: "toolProviderExecutionCatalogs" },
+	);
+}
diff --git a/packages/ts/src/executors/work-queue.ts b/packages/ts/src/executors/work-queue.ts
new file mode 100644
index 00000000..b88393d5
--- /dev/null
+++ b/packages/ts/src/executors/work-queue.ts
@@ -0,0 +1,460 @@
+/**
+ * Durable executor dispatch recipe over workQueue (D328/D331).
+ *
+ * Claim records become graph-visible dispatch-attempt facts. Executor outcomes become queue
+ * lifecycle commands. The recipe never calls ExecutorBinding or treats a queue claim as dispatch.
+ */
+
+import { type Ctx, depBatch } from "../ctx/types.js";
+import type { DataIssue } from "../data/index.js";
+import type { Graph } from "../graph/graph.js";
+import type { Node } from "../node/node.js";
+import type {
+	AgentRequestIssued,
+	ExecutorOutcome,
+	SourceRef,
+} from "../orchestration/agent-runtime.js";
+import type { WorkQueueCommand, WorkQueueRecord } from "../work-queue/index.js";
+
+export interface ExecutorQueuedDispatchPayload {
+	readonly kind: "executor-queued-dispatch";
+	readonly requestId: string;
+	readonly operationId: string;
+	readonly parentRequestId?: string;
+	readonly sourceDecisionId?: string;
+	readonly intentId?: string;
+	readonly inputId?: string;
+	readonly toolCallSeriesId?: string;
+	readonly routeId?: string;
+	readonly profileId?: string;
+	readonly executorId?: string;
+	readonly effectRunId?: string;
+	readonly promptBundleRefs?: readonly SourceRef[];
+	readonly toolDefinitionRefs?: readonly SourceRef[];
+	readonly policyRefs?: readonly SourceRef[];
+	readonly budgetRefs?: readonly SourceRef[];
+	readonly permissionRefs?: readonly SourceRef[];
+	readonly sandboxRefs?: readonly SourceRef[];
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly artifactRefs?: readonly SourceRef[];
+	readonly idempotencyKey?: string;
+	readonly requirements?: readonly string[];
+	readonly metadata?: Record<string, unknown>;
+}
+
+export type ExecutorQueuedDispatchPayloadExtra = Partial<
+	Omit<ExecutorQueuedDispatchPayload, "kind" | "requestId" | "operationId">
+>;
+
+export interface ExecutorQueuedDispatchAttempt {
+	readonly kind: "executor-queued-dispatch-attempt";
+	readonly workId: string;
+	readonly leaseId: string;
+	readonly queueAttempt: number;
+	readonly workerId: string;
+	readonly requestId: string;
+	readonly operationId: string;
+	readonly routeId?: string;
+	readonly executorId?: string;
+	readonly profileId?: string;
+	readonly payload: ExecutorQueuedDispatchPayload;
+	readonly sourceRefs?: readonly SourceRef[];
+}
+
+export interface ExecutorWorkQueueSubmitOptions {
+	readonly workId?: string;
+	readonly priority?: number;
+	readonly tags?: readonly string[];
+	readonly requirements?: readonly string[];
+	readonly notBeforeMs?: number;
+	readonly deadlineMs?: number;
+}
+
+export interface ExecutorWorkQueuePolicy {
+	readonly submit?: (request: AgentRequestIssued) => ExecutorWorkQueueSubmitOptions;
+	readonly payload?: (request: AgentRequestIssued) => ExecutorQueuedDispatchPayloadExtra;
+	readonly retryableBlocked?: boolean;
+	readonly retryableTimeout?: boolean;
+}
+
+export interface ExecutorWorkQueueRecipeOptions {
+	readonly name?: string;
+	readonly requests?: Node<AgentRequestIssued>;
+	readonly records: Node<WorkQueueRecord<ExecutorQueuedDispatchPayload>>;
+	readonly outcomes: Node<ExecutorOutcome>;
+	readonly workerId?: string;
+	readonly policy?: ExecutorWorkQueuePolicy;
+}
+
+export interface ExecutorWorkQueueRecipeBundle {
+	readonly submitCommands?: Node<WorkQueueCommand<ExecutorQueuedDispatchPayload>>;
+	readonly attempts: Node<ExecutorQueuedDispatchAttempt>;
+	readonly commands: Node<WorkQueueCommand<ExecutorQueuedDispatchPayload>>;
+	readonly issues: Node<DataIssue>;
+}
+
+type ExecutorQueueFact =
+	| { readonly kind: "attempt"; readonly attempt: ExecutorQueuedDispatchAttempt }
+	| { readonly kind: "command"; readonly command: WorkQueueCommand<ExecutorQueuedDispatchPayload> }
+	| { readonly kind: "issue"; readonly issue: DataIssue };
+
+interface ExecutorQueueState {
+	readonly payloads: Map<string, ExecutorQueuedDispatchPayload>;
+	readonly activeClaims: Map<string, ExecutorQueuedDispatchAttempt>;
+	readonly pendingOutcomes: Map<string, ExecutorOutcome[]>;
+	readonly terminalClaims: Set<string>;
+	readonly seenOutcomes: Set<string>;
+}
+
+export function executorWorkQueueRecipe(
+	graph: Graph,
+	opts: ExecutorWorkQueueRecipeOptions,
+): ExecutorWorkQueueRecipeBundle {
+	const name = opts.name ?? "executorWorkQueue";
+	const submitCommands =
+		opts.requests === undefined
+			? undefined
+			: graph.node<WorkQueueCommand<ExecutorQueuedDispatchPayload>>(
+					[opts.requests],
+					(ctx) => {
+						for (const raw of depBatch(ctx, 0) ?? []) {
+							const request = raw as AgentRequestIssued;
+							ctx.down([["DATA", executorSubmitCommand(request, opts.policy)]]);
+						}
+					},
+					{ name: `${name}/submitCommands`, factory: "executorWorkQueueSubmitCommands" },
+				);
+	const runtime = graph.node<ExecutorQueueFact>(
+		[opts.records, opts.outcomes],
+		(ctx) => {
+			const state = ctx.state.get<ExecutorQueueState>() ?? emptyState();
+			for (const raw of depBatch(ctx, 0) ?? []) {
+				reduceRecord(ctx, state, raw as WorkQueueRecord<ExecutorQueuedDispatchPayload>, opts);
+			}
+			for (const raw of depBatch(ctx, 1) ?? []) {
+				reduceOutcome(ctx, state, raw as ExecutorOutcome, opts);
+			}
+			ctx.state.set(state);
+		},
+		{
+			name: `${name}/runtime`,
+			factory: "executorWorkQueueRuntime",
+			partial: true,
+			completeWhenDepsComplete: false,
+			errorWhenDepsError: false,
+		},
+	);
+	return {
+		...(submitCommands === undefined ? {} : { submitCommands }),
+		attempts: project(graph, runtime, `${name}/attempts`, "executorWorkQueueAttempts", (fact) =>
+			fact.kind === "attempt" ? fact.attempt : undefined,
+		),
+		commands: project(graph, runtime, `${name}/commands`, "executorWorkQueueCommands", (fact) =>
+			fact.kind === "command" ? fact.command : undefined,
+		),
+		issues: project(graph, runtime, `${name}/issues`, "executorWorkQueueIssues", (fact) =>
+			fact.kind === "issue" ? fact.issue : undefined,
+		),
+	};
+}
+
+export function executorSubmitCommand(
+	request: AgentRequestIssued,
+	policy?: ExecutorWorkQueuePolicy,
+): WorkQueueCommand<ExecutorQueuedDispatchPayload> {
+	const payloadExtra = policy?.payload?.(request) ?? {};
+	const submit = policy?.submit?.(request) ?? {};
+	const payload: ExecutorQueuedDispatchPayload = {
+		...payloadExtra,
+		kind: "executor-queued-dispatch",
+		requestId: request.requestId,
+		operationId: request.operationId,
+		parentRequestId: request.parentRequestId,
+		inputId: request.input?.inputId,
+		effectRunId: request.effectRunId,
+		sourceRefs: request.sourceRefs,
+		idempotencyKey: request.requestId,
+		metadata: request.metadata,
+	};
+	return {
+		kind: "submit",
+		commandId: `${request.requestId}:executor-work-queue-submit`,
+		payload,
+		workId: submit.workId ?? `executor:${request.requestId}`,
+		priority: submit.priority,
+		tags: submit.tags ?? ["executor", request.requestKind],
+		requirements: submit.requirements,
+		notBeforeMs: submit.notBeforeMs,
+		deadlineMs: submit.deadlineMs,
+		idempotencyKey: request.requestId,
+		sourceRefs: stringRefs(request.sourceRefs),
+	};
+}
+
+function reduceRecord(
+	ctx: Ctx,
+	state: ExecutorQueueState,
+	record: WorkQueueRecord<ExecutorQueuedDispatchPayload>,
+	opts: ExecutorWorkQueueRecipeOptions,
+): void {
+	if (record.kind === "work-admitted") {
+		state.payloads.set(record.workId, record.payload);
+		return;
+	}
+	retireClaimForRecord(state, record);
+	if (record.kind !== "work-claimed") return;
+	if (opts.workerId !== undefined && record.workerId !== opts.workerId) return;
+	const payload = state.payloads.get(record.workId);
+	if (payload === undefined) {
+		emit(ctx, { kind: "issue", issue: queueIssue(record, "executor-claim-without-payload") });
+		return;
+	}
+	const attempt: ExecutorQueuedDispatchAttempt = {
+		kind: "executor-queued-dispatch-attempt",
+		workId: record.workId,
+		leaseId: record.leaseId,
+		queueAttempt: record.attempt,
+		workerId: record.workerId,
+		requestId: payload.requestId,
+		operationId: payload.operationId,
+		routeId: payload.routeId,
+		executorId: payload.executorId,
+		profileId: payload.profileId,
+		payload,
+		sourceRefs: [...(payload.sourceRefs ?? []), ref("work-queue-record", String(record.recordSeq))],
+	};
+	const key = outcomeKey(payload, record.attempt);
+	state.activeClaims.set(key, attempt);
+	emit(ctx, { kind: "attempt", attempt });
+	const pending = state.pendingOutcomes.get(key);
+	if (pending !== undefined) {
+		state.pendingOutcomes.delete(key);
+		for (const outcome of pending) {
+			mapClaimedOutcome(ctx, state, key, attempt, outcome, opts);
+		}
+	}
+}
+
+function reduceOutcome(
+	ctx: Ctx,
+	state: ExecutorQueueState,
+	outcome: ExecutorOutcome,
+	opts: ExecutorWorkQueueRecipeOptions,
+): void {
+	if (state.seenOutcomes.has(outcome.outcomeId)) return;
+	const key = outcomeKey(outcome, outcome.attempt);
+	if (state.terminalClaims.has(key)) {
+		state.seenOutcomes.add(outcome.outcomeId);
+		emit(ctx, {
+			kind: "issue",
+			issue: {
+				kind: "issue",
+				code: "executor-duplicate-terminal-outcome-for-queue-claim",
+				message: `ExecutorOutcome '${outcome.outcomeId}' arrived after the queue claim was already terminal`,
+				refs: [`executor-outcome:${outcome.outcomeId}`],
+			},
+		});
+		return;
+	}
+	const claim = state.activeClaims.get(key);
+	if (claim === undefined) {
+		bufferPendingOutcome(state, key, outcome);
+		return;
+	}
+	mapClaimedOutcome(ctx, state, key, claim, outcome, opts);
+}
+
+function mapClaimedOutcome(
+	ctx: Ctx,
+	state: ExecutorQueueState,
+	key: string,
+	claim: ExecutorQueuedDispatchAttempt,
+	outcome: ExecutorOutcome,
+	opts: ExecutorWorkQueueRecipeOptions,
+): void {
+	if (state.seenOutcomes.has(outcome.outcomeId)) return;
+	state.seenOutcomes.add(outcome.outcomeId);
+	if (state.terminalClaims.has(key)) {
+		emit(ctx, {
+			kind: "issue",
+			issue: {
+				kind: "issue",
+				code: "executor-duplicate-terminal-outcome-for-queue-claim",
+				message: `ExecutorOutcome '${outcome.outcomeId}' arrived after the queue claim was already terminal`,
+				refs: [`executor-outcome:${outcome.outcomeId}`, `work-queue-work:${claim.workId}`],
+			},
+		});
+		return;
+	}
+	if (outcome.kind === "result") {
+		terminalizeClaim(state, key);
+		emit(ctx, {
+			kind: "command",
+			command: {
+				kind: "complete",
+				commandId: `${outcome.outcomeId}:queue-complete`,
+				workId: claim.workId,
+				leaseId: claim.leaseId,
+				attempt: claim.queueAttempt,
+				workerId: claim.workerId,
+				result: outcome.result,
+				sourceRefs: stringRefs(outcome.evidenceRefs),
+			},
+		});
+		return;
+	}
+	if (outcome.kind === "canceled") {
+		terminalizeClaim(state, key);
+		emit(ctx, {
+			kind: "command",
+			command: {
+				kind: "cancel",
+				commandId: `${outcome.outcomeId}:queue-cancel`,
+				workId: claim.workId,
+				reason: outcome.reason,
+				sourceRefs: stringRefs(outcome.evidenceRefs),
+			},
+		});
+		return;
+	}
+	terminalizeClaim(state, key);
+	emit(ctx, {
+		kind: "command",
+		command: {
+			kind: "fail",
+			commandId: `${outcome.outcomeId}:queue-fail`,
+			workId: claim.workId,
+			leaseId: claim.leaseId,
+			attempt: claim.queueAttempt,
+			workerId: claim.workerId,
+			error: outcomeError(outcome),
+			retryable: outcomeRetryable(outcome, opts.policy),
+			sourceRefs: stringRefs(outcome.evidenceRefs),
+		},
+	});
+}
+
+function outcomeError(
+	outcome: Extract<ExecutorOutcome, { kind: "failure" | "timeout" | "blocked" }>,
+): unknown {
+	if (outcome.kind === "failure") return outcome.error;
+	if (outcome.kind === "timeout") {
+		return {
+			kind: "issue",
+			code: "executor-timeout",
+			message: `ExecutorOutcome '${outcome.outcomeId}' timed out`,
+			metadata: { timeoutMs: outcome.timeoutMs },
+		} satisfies DataIssue;
+	}
+	return {
+		kind: "issue",
+		code: "executor-blocked",
+		message: `ExecutorOutcome '${outcome.outcomeId}' blocked`,
+		metadata: { needs: outcome.needs },
+	} satisfies DataIssue;
+}
+
+function outcomeRetryable(
+	outcome: ExecutorOutcome,
+	policy: ExecutorWorkQueuePolicy | undefined,
+): boolean | undefined {
+	if (outcome.kind === "failure") return outcome.retryable;
+	if (outcome.kind === "timeout") return outcome.retryable ?? policy?.retryableTimeout;
+	if (outcome.kind === "blocked") return policy?.retryableBlocked;
+	return undefined;
+}
+
+function project<T>(
+	graph: Graph,
+	runtime: Node<ExecutorQueueFact>,
+	name: string,
+	factory: string,
+	select: (fact: ExecutorQueueFact) => T | undefined,
+): Node<T> {
+	return graph.node<T>(
+		[runtime],
+		(ctx) => {
+			for (const raw of depBatch(ctx, 0) ?? []) {
+				const selected = select(raw as ExecutorQueueFact);
+				if (selected !== undefined) ctx.down([["DATA", selected]]);
+			}
+		},
+		{ name, factory, partial: true, completeWhenDepsComplete: false, errorWhenDepsError: false },
+	);
+}
+
+function emit(ctx: Ctx, fact: ExecutorQueueFact): void {
+	ctx.down([["DATA", fact]]);
+}
+
+function emptyState(): ExecutorQueueState {
+	return {
+		payloads: new Map(),
+		activeClaims: new Map(),
+		pendingOutcomes: new Map(),
+		terminalClaims: new Set(),
+		seenOutcomes: new Set(),
+	};
+}
+
+function terminalizeClaim(state: ExecutorQueueState, key: string): void {
+	state.terminalClaims.add(key);
+	state.activeClaims.delete(key);
+}
+
+function bufferPendingOutcome(
+	state: ExecutorQueueState,
+	key: string,
+	outcome: ExecutorOutcome,
+): void {
+	const pending = state.pendingOutcomes.get(key) ?? [];
+	if (!pending.some((candidate) => candidate.outcomeId === outcome.outcomeId)) {
+		state.pendingOutcomes.set(key, [...pending, outcome]);
+	}
+}
+
+function retireClaimForRecord(
+	state: ExecutorQueueState,
+	record: WorkQueueRecord<ExecutorQueuedDispatchPayload>,
+): void {
+	if (
+		record.kind !== "attempt-completed" &&
+		record.kind !== "work-completed" &&
+		record.kind !== "work-canceled" &&
+		record.kind !== "work-dead-lettered" &&
+		record.kind !== "work-released" &&
+		record.kind !== "lease-expired"
+	) {
+		return;
+	}
+	for (const [key, claim] of state.activeClaims) {
+		if (claim.workId !== record.workId) continue;
+		if ("attempt" in record && record.attempt !== claim.queueAttempt) continue;
+		terminalizeClaim(state, key);
+	}
+}
+
+function outcomeKey(
+	value: Pick<ExecutorQueuedDispatchPayload | ExecutorOutcome, "requestId" | "operationId">,
+	attempt: number,
+): string {
+	return `${value.requestId}:${value.operationId}:${attempt}`;
+}
+
+function queueIssue(record: WorkQueueRecord, code: string): DataIssue {
+	return {
+		kind: "issue",
+		code,
+		message: `WorkQueue record '${record.kind}' cannot be mapped to executor dispatch`,
+		refs: [`work-queue-record:${record.recordSeq}`],
+		metadata: { queueRecordKind: record.kind, workId: record.workId },
+	};
+}
+
+function ref(kind: string, id: string): SourceRef {
+	return { kind, id };
+}
+
+function stringRefs(refs: readonly SourceRef[] | undefined): readonly string[] | undefined {
+	return refs?.map((sourceRef) => `${sourceRef.kind}:${sourceRef.id}`);
+}
diff --git a/packages/ts/src/graph/blueprint.ts b/packages/ts/src/graph/blueprint.ts
new file mode 100644
index 00000000..637ff411
--- /dev/null
+++ b/packages/ts/src/graph/blueprint.ts
@@ -0,0 +1,355 @@
+/**
+ * GraphBlueprint first slice (D173/D177).
+ *
+ * A blueprint is read-only audit/collaboration evidence over graph.topology(). It is not an
+ * authoring spec, checkpoint, restore input, hash owner, or collaboration ownership artifact.
+ */
+
+import {
+	assertStrictJsonObject,
+	type StrictJsonObject,
+	type StrictJsonValue,
+	stableJsonString,
+	strictCanonicalJsonBytes,
+} from "../json/codec.js";
+import type { GraphTopologyEdge, GraphTopologySnapshot } from "./describe.js";
+
+export const GRAPH_BLUEPRINT_VERSION = "graphrefly.blueprint.v1" as const;
+
+export type GraphBlueprintJson = StrictJsonValue;
+
+export type GraphBlueprintProvenance = StrictJsonObject;
+
+export interface NormalizedGraphTopologyNode {
+	readonly id: string;
+	readonly name?: string;
+	readonly factory: string;
+	readonly deps: readonly string[];
+	readonly meta?: Readonly<Record<string, GraphBlueprintJson>>;
+}
+
+export interface NormalizedGraphTopologySnapshot {
+	readonly name?: string;
+	readonly nodes: readonly NormalizedGraphTopologyNode[];
+	readonly edges: readonly GraphTopologyEdge[];
+	readonly subgraphs?: readonly NormalizedGraphTopologySnapshot[];
+}
+
+export type GraphBlueprintDiagnosticCode = "dangling-dep" | "duplicate-node-id" | "island-node";
+
+export interface GraphBlueprintDiagnosticIssue {
+	readonly severity: "warning" | "error";
+	readonly code: GraphBlueprintDiagnosticCode;
+	readonly message: string;
+	readonly nodeId?: string;
+	readonly from?: string;
+	readonly to?: string;
+}
+
+export interface GraphBlueprintDiagnostics {
+	readonly ok: boolean;
+	readonly issues: readonly GraphBlueprintDiagnosticIssue[];
+}
+
+export type GraphBlueprintHashInput = "strictCanonicalTopologyBytes";
+
+export interface GraphBlueprintHash {
+	readonly kind: "topology";
+	readonly algorithm: string;
+	readonly input: GraphBlueprintHashInput;
+	readonly value: string;
+}
+
+export interface GraphBlueprintHashOptions {
+	readonly algorithm: string;
+	readonly hash: (bytes: Uint8Array) => string | Promise<string>;
+}
+
+export interface GraphBlueprint {
+	readonly version: typeof GRAPH_BLUEPRINT_VERSION;
+	readonly topology: NormalizedGraphTopologySnapshot;
+	readonly diagnostics?: GraphBlueprintDiagnostics;
+	readonly provenance?: GraphBlueprintProvenance;
+	readonly hash?: GraphBlueprintHash;
+}
+
+export interface GraphBlueprintOptions {
+	/** Include graph-local structural diagnostics over the normalized topology. */
+	readonly diagnostics?: boolean;
+	/** Caller-supplied provenance only; environment enrichment stays outside Graph core (D177). */
+	readonly provenance?: GraphBlueprintProvenance;
+}
+
+export function normalizeTopologyMeta(
+	meta: Record<string, unknown>,
+	label = "meta",
+	kind = "graph meta",
+): Readonly<Record<string, GraphBlueprintJson>> {
+	try {
+		return assertStrictJsonObject(meta, label);
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		throw new TypeError(`${label}: ${kind} must be strict JSON-compatible data (D177): ${message}`);
+	}
+}
+
+export function normalizeTopology(
+	snapshot: GraphTopologySnapshot | NormalizedGraphTopologySnapshot,
+): NormalizedGraphTopologySnapshot {
+	return normalizeTopologySnapshot(snapshot as GraphTopologySnapshot, new WeakSet<object>(), "$");
+}
+
+function normalizeTopologySnapshot(
+	snapshot: GraphTopologySnapshot,
+	seen: WeakSet<object>,
+	path: string,
+): NormalizedGraphTopologySnapshot {
+	if (snapshot === null || typeof snapshot !== "object") {
+		throw new TypeError(`normalizeTopology: snapshot at ${path} must be an object`);
+	}
+	if (seen.has(snapshot)) {
+		throw new TypeError(`normalizeTopology: circular subgraph reference at ${path}`);
+	}
+	seen.add(snapshot);
+	try {
+		const nodes = mapDense(snapshot.nodes, `${path}.nodes`, (node, index) => {
+			const nodePath = `${path}.nodes[${index}]`;
+			assertTopologyObject(node, nodePath);
+			const id = topologyString(node.id, `${nodePath}.id`);
+			const factory = topologyString(node.factory, `${nodePath}.factory`);
+			const out: NormalizedGraphTopologyNode = {
+				id,
+				factory,
+				deps: mapDense(node.deps, `${labelForNode(id)}.deps`, (dep, depIndex) =>
+					topologyString(dep, `${labelForNode(id)}.deps[${depIndex}]`),
+				),
+			};
+			if (node.name !== undefined) {
+				(out as { name?: string }).name = topologyString(node.name, `${nodePath}.name`);
+			}
+			if (node.meta !== undefined) {
+				(out as { meta?: Readonly<Record<string, GraphBlueprintJson>> }).meta =
+					normalizeTopologyMeta(node.meta, `${labelForNode(id)}.meta`);
+			}
+			return out;
+		}).sort(compareNodes);
+		const out: NormalizedGraphTopologySnapshot = {
+			nodes,
+			edges: deriveEdges(nodes),
+		};
+		if (snapshot.name !== undefined) {
+			(out as { name?: string }).name = topologyString(snapshot.name, `${path}.name`);
+		}
+		if (snapshot.subgraphs !== undefined) {
+			(out as { subgraphs?: readonly NormalizedGraphTopologySnapshot[] }).subgraphs = mapDense(
+				snapshot.subgraphs,
+				`${path}.subgraphs`,
+				(subgraph, index) =>
+					normalizeTopologySnapshot(subgraph, seen, `${path}.subgraphs[${index}]`),
+			).sort(compareTopologies);
+		}
+		return out;
+	} finally {
+		seen.delete(snapshot);
+	}
+}
+
+function mapDense<T, U>(
+	values: readonly T[],
+	path: string,
+	mapper: (value: T, index: number) => U,
+): U[] {
+	if (!Array.isArray(values)) {
+		throw new TypeError(`normalizeTopology: ${path} must be an array`);
+	}
+	const out: U[] = [];
+	for (let i = 0; i < values.length; i += 1) {
+		if (!(i in values)) {
+			throw new TypeError(`normalizeTopology: sparse array hole at ${path}[${i}]`);
+		}
+		out.push(mapper(values[i] as T, i));
+	}
+	return out;
+}
+
+function assertTopologyObject(
+	value: unknown,
+	path: string,
+): asserts value is Record<string, unknown> {
+	if (value === null || typeof value !== "object" || Array.isArray(value)) {
+		throw new TypeError(`normalizeTopology: ${path} must be an object`);
+	}
+}
+
+function topologyString(value: unknown, path: string): string {
+	if (typeof value !== "string") {
+		throw new TypeError(`normalizeTopology: ${path} must be a string`);
+	}
+	return value;
+}
+
+export function canonicalTopologyJson(
+	snapshot: GraphTopologySnapshot | NormalizedGraphTopologySnapshot,
+): string {
+	return stableJsonString(normalizeTopology(snapshot as GraphTopologySnapshot));
+}
+
+export function canonicalTopologyBytes(
+	snapshot: GraphTopologySnapshot | NormalizedGraphTopologySnapshot,
+): Uint8Array {
+	return strictCanonicalJsonBytes(normalizeTopology(snapshot as GraphTopologySnapshot));
+}
+
+export function withBlueprintHash(
+	blueprint: GraphBlueprint,
+	options: GraphBlueprintHashOptions,
+): GraphBlueprint | Promise<GraphBlueprint> {
+	if (typeof options.algorithm !== "string" || options.algorithm.length === 0) {
+		throw new TypeError("withBlueprintHash: algorithm must be a non-empty string");
+	}
+	const topology = normalizeTopology(blueprint.topology);
+	const withHash = (value: string): GraphBlueprint => {
+		if (typeof value !== "string" || value.length === 0) {
+			throw new TypeError("withBlueprintHash: hash value must be a non-empty string");
+		}
+		return {
+			...blueprint,
+			topology,
+			hash: {
+				kind: "topology",
+				algorithm: options.algorithm,
+				input: "strictCanonicalTopologyBytes",
+				value,
+			},
+		};
+	};
+	const value = options.hash(canonicalTopologyBytes(topology));
+	if (typeof value !== "string" || value.length === 0) {
+		const maybeThenable = value as { then?: unknown } | null | undefined;
+		if (
+			maybeThenable === null ||
+			maybeThenable === undefined ||
+			typeof maybeThenable.then !== "function"
+		) {
+			throw new TypeError("withBlueprintHash: hash value must be a non-empty string");
+		}
+		return (value as Promise<string>).then(withHash);
+	}
+	return withHash(value);
+}
+
+export function withBlueprintProvenance(
+	blueprint: GraphBlueprint,
+	provenance: GraphBlueprintProvenance,
+): GraphBlueprint {
+	return {
+		...blueprint,
+		provenance: normalizeTopologyMeta(provenance, "graph blueprint provenance", "provenance"),
+	};
+}
+
+export function graphBlueprintDiagnostics(
+	topology: NormalizedGraphTopologySnapshot,
+): GraphBlueprintDiagnostics {
+	const issues: GraphBlueprintDiagnosticIssue[] = [];
+	collectDiagnostics(topology, issues);
+	issues.sort(compareIssues);
+	return { ok: !issues.some((issue) => issue.severity === "error"), issues };
+}
+
+function collectDiagnostics(
+	topology: NormalizedGraphTopologySnapshot,
+	issues: GraphBlueprintDiagnosticIssue[],
+): void {
+	const seen = new Set<string>();
+	const duplicateIds = new Set<string>();
+	for (const node of topology.nodes) {
+		if (seen.has(node.id)) duplicateIds.add(node.id);
+		seen.add(node.id);
+	}
+	for (const id of duplicateIds) {
+		issues.push({
+			severity: "error",
+			code: "duplicate-node-id",
+			nodeId: id,
+			message: `duplicate topology node id '${id}'`,
+		});
+	}
+
+	const dependents = new Map<string, number>();
+	for (const node of topology.nodes) dependents.set(node.id, 0);
+	for (const node of topology.nodes) {
+		for (const dep of node.deps) {
+			if (!seen.has(dep)) {
+				issues.push({
+					severity: "error",
+					code: "dangling-dep",
+					nodeId: node.id,
+					from: dep,
+					to: node.id,
+					message: `node '${node.id}' depends on missing node '${dep}'`,
+				});
+				continue;
+			}
+			dependents.set(dep, (dependents.get(dep) ?? 0) + 1);
+		}
+	}
+	for (const node of topology.nodes) {
+		if (node.deps.length === 0 && (dependents.get(node.id) ?? 0) === 0) {
+			issues.push({
+				severity: "warning",
+				code: "island-node",
+				nodeId: node.id,
+				message: `node '${node.id}' has no deps and no dependents`,
+			});
+		}
+	}
+
+	for (const subgraph of topology.subgraphs ?? []) collectDiagnostics(subgraph, issues);
+}
+
+function deriveEdges(nodes: readonly NormalizedGraphTopologyNode[]): GraphTopologyEdge[] {
+	const seen = new Set<string>();
+	const edges: GraphTopologyEdge[] = [];
+	for (const node of nodes) {
+		for (const from of node.deps) {
+			const key = `${from}\0${node.id}`;
+			if (seen.has(key)) continue;
+			seen.add(key);
+			edges.push({ from, to: node.id });
+		}
+	}
+	return edges.sort(compareEdges);
+}
+
+function labelForNode(id: string): string {
+	return id === "" ? "node" : `node '${id}'`;
+}
+
+function compareText(a: string, b: string): number {
+	return a < b ? -1 : a > b ? 1 : 0;
+}
+
+function compareNodes(a: NormalizedGraphTopologyNode, b: NormalizedGraphTopologyNode): number {
+	return compareText(a.id, b.id);
+}
+
+function compareEdges(a: GraphTopologyEdge, b: GraphTopologyEdge): number {
+	return compareText(a.from, b.from) || compareText(a.to, b.to);
+}
+
+function compareTopologies(
+	a: NormalizedGraphTopologySnapshot,
+	b: NormalizedGraphTopologySnapshot,
+): number {
+	return compareText(stableJsonString(a), stableJsonString(b));
+}
+
+function compareIssues(a: GraphBlueprintDiagnosticIssue, b: GraphBlueprintDiagnosticIssue): number {
+	return (
+		compareText(a.code, b.code) ||
+		compareText(a.nodeId ?? "", b.nodeId ?? "") ||
+		compareText(a.from ?? "", b.from ?? "") ||
+		compareText(a.to ?? "", b.to ?? "")
+	);
+}
diff --git a/packages/ts/src/graph/cascading-cache.ts b/packages/ts/src/graph/cascading-cache.ts
new file mode 100644
index 00000000..99c2a9d6
--- /dev/null
+++ b/packages/ts/src/graph/cascading-cache.ts
@@ -0,0 +1,527 @@
+import { type Ctx, depBatch, depLatest } from "../ctx/types.js";
+import type { Node } from "../node/node.js";
+import { errorPayload } from "../protocol/messages.js";
+import { hasKvVersioned, type KvGeneration, type KvStorageTier } from "../storage/kv.js";
+import {
+	type ReadThroughLookupFact,
+	type ReadThroughLookupTier,
+	type TieredReadThroughResult,
+	tieredReadThrough,
+} from "../storage/read-through.js";
+import type { Graph, SugarOpts } from "./graph.js";
+
+/** Dynamic read-through policy for {@link reactiveCascadingCache}. */
+export interface CascadingCachePolicy {
+	readonly promoteTo?: readonly number[] | false;
+}
+
+export type CascadingCacheStatus<K> =
+	| { readonly kind: "idle" }
+	| { readonly kind: "loading"; readonly key: K; readonly requestSeq: number }
+	| {
+			readonly kind: "hit";
+			readonly key: K;
+			readonly requestSeq: number;
+			readonly tier?: ReadThroughLookupTier;
+	  }
+	| { readonly kind: "miss"; readonly key: K; readonly requestSeq: number }
+	| {
+			readonly kind: "error";
+			readonly key: K;
+			readonly requestSeq: number;
+			readonly error: unknown;
+	  };
+
+export type CascadingCacheEvent<K, V> =
+	| { readonly kind: "request"; readonly key: K; readonly requestSeq: number }
+	| { readonly kind: "invalidate"; readonly key: K; readonly requestSeq: number }
+	| {
+			readonly kind: "lookup";
+			readonly key: K;
+			readonly requestSeq: number;
+			readonly outcome: "hit" | "miss" | "error";
+			readonly tier: ReadThroughLookupTier;
+			readonly value?: V;
+			readonly error?: unknown;
+	  }
+	| {
+			readonly kind: "promotion";
+			readonly key: K;
+			readonly requestSeq: number;
+			readonly tier: ReadThroughLookupTier;
+			readonly ok: boolean;
+			readonly error?: unknown;
+	  }
+	| {
+			readonly kind: "fill";
+			readonly key: K;
+			readonly requestSeq: number;
+			readonly status: "hit" | "miss" | "error";
+			readonly value?: V;
+			readonly tier?: ReadThroughLookupTier;
+			readonly error?: unknown;
+	  }
+	| {
+			readonly kind: "error";
+			readonly key: K;
+			readonly requestSeq: number;
+			readonly stage: "lookup" | "promotion";
+			readonly tier?: ReadThroughLookupTier;
+			readonly error: unknown;
+	  };
+
+export interface ReactiveCascadingCacheOptions<K extends string, V> {
+	readonly graph: Graph;
+	readonly request: Node<K>;
+	readonly policy?: Node<CascadingCachePolicy>;
+	readonly invalidate?: Node<K>;
+	readonly tiers: readonly KvStorageTier<V>[];
+	readonly load?: (key: K) => Promise<V | undefined> | V | undefined;
+	readonly tierNames?: readonly string[];
+	/**
+	 * Storage promotion is explicit for the graph-layer factory. `requestSeq` guards visible graph
+	 * value/status updates; without a generation/CAS storage contract, passive tier writes are
+	 * best-effort and cannot be made stale-proof once an async `set` has started.
+	 *
+	 * @default false
+	 */
+	readonly promoteTo?: readonly number[] | false;
+	readonly name?: string;
+	readonly meta?: Record<string, unknown>;
+}
+
+export interface ReactiveCascadingCache<K, V> {
+	readonly value: Node<V | undefined>;
+	readonly status: Node<CascadingCacheStatus<K>>;
+	readonly events: Node<CascadingCacheEvent<K, V>>;
+}
+
+interface DriverState<K> {
+	seq: number;
+	active: boolean;
+	dropBeforeSeq: number;
+	latestKey?: K;
+}
+
+interface SeqState {
+	seq: number;
+}
+
+/**
+ * Free-standing graph-layer cascading cache factory (D104/D105/D107).
+ *
+ * Passive tiers stay in `tieredReadThrough`; this factory wraps lookup work at an async pool
+ * boundary and exposes every request, invalidation, lookup, promotion, fill, status, and value
+ * change through declared graph nodes. `requestSeq` is the stale-fill guard for visible graph
+ * nodes: older async fills may still be observable as events, but downstream value/status nodes
+ * ignore them. Storage promotion defaults to `false` here because passive tier writes have no
+ * generation/CAS contract; callers may opt in with `promoteTo` when best-effort promotion is
+ * acceptable.
+ */
+export function reactiveCascadingCache<K extends string, V>(
+	opts: ReactiveCascadingCacheOptions<K, V>,
+): ReactiveCascadingCache<K, V> {
+	const {
+		graph: g,
+		request,
+		policy,
+		invalidate,
+		tiers,
+		tierNames,
+		promoteTo,
+		load,
+		name,
+		meta,
+	} = opts;
+	const eventDeps: Node<unknown>[] = [request];
+	const policyIndex = policy === undefined ? -1 : eventDeps.push(policy) - 1;
+	const invalidateIndex = invalidate === undefined ? -1 : eventDeps.push(invalidate) - 1;
+	const baseName = name ?? "reactiveCascadingCache";
+	const eventOpts: SugarOpts<CascadingCacheEvent<K, V>> = {
+		name: `${baseName}.events`,
+		meta,
+		partial: true,
+		pool: "async",
+	};
+	const events = g.node<CascadingCacheEvent<K, V>>(
+		eventDeps,
+		(ctx) => {
+			const st = ctx.state.get<DriverState<K>>() ?? {
+				seq: 0,
+				active: true,
+				dropBeforeSeq: 0,
+			};
+			st.active = true;
+			ctx.onDeactivation(() => {
+				st.active = false;
+				st.seq += 1;
+				st.dropBeforeSeq = st.seq;
+			});
+			const requestBatch = depBatch(ctx, 0) as readonly K[] | null;
+			const invalidateBatch =
+				invalidateIndex === -1 ? null : (depBatch(ctx, invalidateIndex) as readonly K[] | null);
+			const policyBatch =
+				policyIndex === -1
+					? null
+					: (depBatch(ctx, policyIndex) as readonly CascadingCachePolicy[] | null);
+			const currentPolicy =
+				policyIndex === -1
+					? undefined
+					: (depLatest(ctx, policyIndex) as CascadingCachePolicy | undefined);
+
+			if (requestBatch !== null) {
+				for (const key of requestBatch) {
+					startLookup(ctx, st, {
+						kind: "request",
+						key,
+						tiers,
+						tierNames,
+						load,
+						promoteTo: currentPolicy?.promoteTo ?? promoteTo ?? false,
+					});
+				}
+			}
+
+			if (invalidateBatch !== null) {
+				for (const key of invalidateBatch) {
+					startLookup(ctx, st, {
+						kind: "invalidate",
+						key,
+						tiers,
+						tierNames,
+						load,
+						promoteTo: currentPolicy?.promoteTo ?? promoteTo ?? false,
+					});
+				}
+			}
+
+			if (requestBatch === null && invalidateBatch === null && policyBatch !== null) {
+				const key = st.latestKey;
+				if (key !== undefined) {
+					startLookup(ctx, st, {
+						kind: "request",
+						key,
+						tiers,
+						tierNames,
+						load,
+						promoteTo: currentPolicy?.promoteTo ?? promoteTo ?? false,
+					});
+				}
+			}
+
+			ctx.state.set(st);
+		},
+		eventOpts,
+	);
+
+	const status = g.node<CascadingCacheStatus<K>>(
+		[events],
+		(ctx) => {
+			const st = ctx.state.get<SeqState>() ?? { seq: 0 };
+			const batch = depBatch(ctx, 0) as readonly CascadingCacheEvent<K, V>[] | null;
+			if (batch === null) return;
+			for (const event of batch) {
+				if (event.kind === "request" || event.kind === "invalidate") {
+					st.seq = event.requestSeq;
+					ctx.down([["DATA", { kind: "loading", key: event.key, requestSeq: event.requestSeq }]]);
+					continue;
+				}
+				if (event.requestSeq !== st.seq) continue;
+				if (event.kind === "fill") {
+					if (event.status === "hit") {
+						ctx.down([
+							[
+								"DATA",
+								{
+									kind: "hit",
+									key: event.key,
+									requestSeq: event.requestSeq,
+									tier: event.tier,
+								},
+							],
+						]);
+					} else if (event.status === "miss") {
+						ctx.down([["DATA", { kind: "miss", key: event.key, requestSeq: event.requestSeq }]]);
+					} else {
+						ctx.down([
+							[
+								"DATA",
+								{
+									kind: "error",
+									key: event.key,
+									requestSeq: event.requestSeq,
+									error: event.error,
+								},
+							],
+						]);
+					}
+				} else if (event.kind === "error") {
+					ctx.down([
+						[
+							"DATA",
+							{
+								kind: "error",
+								key: event.key,
+								requestSeq: event.requestSeq,
+								error: event.error,
+							},
+						],
+					]);
+				}
+			}
+			ctx.state.set(st);
+		},
+		{
+			name: `${baseName}.status`,
+			initial: { kind: "idle" },
+			meta,
+			partial: true,
+		},
+	);
+
+	const value = g.node<V | undefined>(
+		[events],
+		(ctx) => {
+			const st = ctx.state.get<SeqState>() ?? { seq: 0 };
+			const batch = depBatch(ctx, 0) as readonly CascadingCacheEvent<K, V>[] | null;
+			if (batch === null) return;
+			for (const event of batch) {
+				if (event.kind === "request") {
+					st.seq = event.requestSeq;
+					continue;
+				}
+				if (event.kind === "invalidate") {
+					st.seq = event.requestSeq;
+					ctx.down([["INVALIDATE"]]);
+					continue;
+				}
+				if (event.kind !== "fill" || event.requestSeq !== st.seq) continue;
+				if (event.status === "hit" && event.value !== undefined) {
+					ctx.down([["DATA", event.value]]);
+				} else {
+					ctx.down([["INVALIDATE"]]);
+				}
+			}
+			ctx.state.set(st);
+		},
+		{
+			name: `${baseName}.value`,
+			meta,
+			partial: true,
+		},
+	);
+
+	return { value, status, events };
+}
+
+function startLookup<K extends string, V>(
+	ctx: Ctx,
+	st: DriverState<K>,
+	opts: {
+		readonly kind: "request" | "invalidate";
+		readonly key: K;
+		readonly tiers: readonly KvStorageTier<V>[];
+		readonly tierNames?: readonly string[];
+		readonly load?: (key: K) => Promise<V | undefined> | V | undefined;
+		readonly promoteTo?: readonly number[] | false;
+	},
+): void {
+	const requestSeq = st.seq + 1;
+	st.seq = requestSeq;
+	st.latestKey = opts.key;
+	ctx.down([["DATA", { kind: opts.kind, key: opts.key, requestSeq }]]);
+	tieredReadThrough<V>({
+		key: opts.key,
+		tiers: opts.tiers,
+		tierNames: opts.tierNames,
+		load: opts.load === undefined ? undefined : (key) => opts.load?.(key as K),
+		promoteTo: false,
+	}).then(
+		(result) => {
+			promoteFresh(ctx, st, requestSeq, {
+				key: opts.key,
+				tiers: opts.tiers,
+				tierNames: opts.tierNames,
+				promoteTo: opts.promoteTo,
+				result,
+			});
+		},
+		(error) => {
+			if (!isLiveRequest(st, requestSeq)) return;
+			ctx.down([
+				[
+					"DATA",
+					{
+						kind: "error",
+						key: opts.key,
+						requestSeq,
+						stage: "lookup",
+						error: errorPayload(error),
+					},
+				],
+			]);
+		},
+	);
+}
+
+function promoteFresh<K, V>(
+	ctx: Ctx,
+	st: DriverState<K>,
+	requestSeq: number,
+	opts: {
+		readonly key: K;
+		readonly tiers: readonly KvStorageTier<V>[];
+		readonly tierNames?: readonly string[];
+		readonly promoteTo?: readonly number[] | false;
+		readonly result: TieredReadThroughResult<V>;
+	},
+	promotions: Array<{ tier: ReadThroughLookupTier; ok: boolean; error?: unknown }> = [],
+	offset = 0,
+): void {
+	if (!isLiveRequest(st, requestSeq)) return;
+	const { result } = opts;
+	const sourceIndex = result.hitTier?.index === -1 ? opts.tiers.length : result.hitTier?.index;
+	const targets =
+		result.value === undefined || sourceIndex === undefined
+			? []
+			: buildPromotionTargets(opts.tiers.length, sourceIndex, opts.promoteTo);
+	if (st.seq !== requestSeq || offset >= targets.length) {
+		const messages = eventsFromResult(opts.key, requestSeq, result, promotions);
+		if (messages.length > 0) ctx.down(messages);
+		return;
+	}
+	const index = targets[offset] as number;
+	const tier = { index, name: opts.tierNames?.[index] };
+	try {
+		const target = opts.tiers[index]!;
+		const generation = generationForTier(result.facts, index);
+		const write =
+			hasKvVersioned(target) && generation !== undefined
+				? target.setIfMatch(opts.key as string, result.value as V, generation)
+				: target.set(opts.key as string, result.value as V).then(() => true);
+		write.then(
+			(ok) => {
+				promotions.push({ tier, ok });
+				promoteFresh(ctx, st, requestSeq, opts, promotions, offset + 1);
+			},
+			(error) => {
+				promotions.push({ tier, ok: false, error });
+				promoteFresh(ctx, st, requestSeq, opts, promotions, offset + 1);
+			},
+		);
+	} catch (error) {
+		promotions.push({ tier, ok: false, error });
+		promoteFresh(ctx, st, requestSeq, opts, promotions, offset + 1);
+	}
+}
+
+function generationForTier<V>(
+	facts: readonly ReadThroughLookupFact<V>[],
+	index: number,
+): KvGeneration | undefined {
+	return facts.find((fact) => fact.tier.index === index)?.generation;
+}
+
+function isLiveRequest<K>(st: DriverState<K>, requestSeq: number): boolean {
+	return st.active && requestSeq >= st.dropBeforeSeq;
+}
+
+function buildPromotionTargets(
+	tierCount: number,
+	hitIndex: number,
+	promoteTo?: readonly number[] | false,
+): number[] {
+	if (promoteTo === false || tierCount <= 0) return [];
+	const maxPromote = Math.max(0, Math.min(hitIndex, tierCount));
+	if (promoteTo === undefined) return [...Array(maxPromote).keys()];
+	const normalized: number[] = [];
+	const seen = new Set<number>();
+	for (const index of promoteTo) {
+		if (!Number.isSafeInteger(index) || index < 0 || index >= tierCount || index >= maxPromote) {
+			continue;
+		}
+		if (!seen.has(index)) {
+			seen.add(index);
+			normalized.push(index);
+		}
+	}
+	return normalized;
+}
+
+function eventsFromResult<K, V>(
+	key: K,
+	requestSeq: number,
+	result: TieredReadThroughResult<V>,
+	promotions = result.promotions,
+): Array<["DATA", CascadingCacheEvent<K, V>]> {
+	const out: Array<["DATA", CascadingCacheEvent<K, V>]> = [];
+	let firstError: unknown;
+	for (const fact of result.facts) {
+		const lookupEvent: CascadingCacheEvent<K, V> = {
+			kind: "lookup",
+			key,
+			requestSeq,
+			outcome: fact.kind,
+			tier: fact.tier,
+			value: fact.value,
+			error: fact.error,
+		};
+		out.push(["DATA", lookupEvent]);
+		if (fact.kind === "error") {
+			firstError ??= fact.error;
+			out.push([
+				"DATA",
+				{
+					kind: "error",
+					key,
+					requestSeq,
+					stage: "lookup",
+					tier: fact.tier,
+					error: fact.error,
+				},
+			]);
+		}
+	}
+	for (const promotion of promotions) {
+		out.push([
+			"DATA",
+			{
+				kind: "promotion",
+				key,
+				requestSeq,
+				tier: promotion.tier,
+				ok: promotion.ok,
+				error: promotion.error,
+			},
+		]);
+		if (!promotion.ok) {
+			firstError ??= promotion.error;
+			if (promotion.error !== undefined) {
+				out.push([
+					"DATA",
+					{
+						kind: "error",
+						key,
+						requestSeq,
+						stage: "promotion",
+						tier: promotion.tier,
+						error: promotion.error,
+					},
+				]);
+			}
+		}
+	}
+	out.push([
+		"DATA",
+		{
+			kind: "fill",
+			key,
+			requestSeq,
+			status: result.status,
+			value: result.value,
+			tier: result.hitTier,
+			error: firstError,
+		},
+	]);
+	return out;
+}
diff --git a/packages/ts/src/graph/checkpoint.ts b/packages/ts/src/graph/checkpoint.ts
new file mode 100644
index 00000000..35d694e8
--- /dev/null
+++ b/packages/ts/src/graph/checkpoint.ts
@@ -0,0 +1,115 @@
+/**
+ * Graph checkpoint public data shape (D83/D86/D90/D116).
+ *
+ * Checkpoint is a graph lifecycle snapshot: strict-JSON-compatible data, no storage I/O,
+ * no observe-log replay, and no restore runtime in this first TS slice.
+ */
+
+import { type StrictJsonValue, strictJsonCodec } from "../json/codec.js";
+import type { Node } from "../node/node.js";
+import type { NodeVersionJson } from "../node/versioning.js";
+import { SENTINEL } from "../protocol/messages.js";
+
+export const GRAPH_CHECKPOINT_VERSION = "graphrefly.checkpoint.v1" as const;
+
+export type GraphCheckpointVersion = typeof GRAPH_CHECKPOINT_VERSION;
+
+export type GraphCheckpointJson = StrictJsonValue;
+
+export type GraphCheckpointValue =
+	| { kind: "SENTINEL" }
+	| { kind: "DATA"; data: GraphCheckpointJson };
+
+export type GraphCheckpointTerminal =
+	| { kind: "none" }
+	| { kind: "COMPLETE" }
+	| { kind: "ERROR"; error: GraphCheckpointJson };
+
+export type GraphCheckpointFactory =
+	| {
+			kind: "registry-ref";
+			ref: string;
+			config?: GraphCheckpointJson;
+			configVersion?: GraphCheckpointJson;
+	  }
+	| { kind: "local-only"; name: string; reason: string };
+
+export interface GraphCheckpointNode {
+	id: string;
+	name?: string;
+	factory: GraphCheckpointFactory;
+	status: string;
+	deps: string[];
+	value: GraphCheckpointValue;
+	backendState?: GraphCheckpointJson;
+	version?: NodeVersionJson;
+	terminal: GraphCheckpointTerminal;
+	lifecycle: { activated: boolean; hasCalledFnOnce: boolean };
+	ctxState: { persist: boolean; value: GraphCheckpointValue };
+	meta?: { [key: string]: GraphCheckpointJson };
+}
+
+export interface GraphCheckpointEdge {
+	from: string;
+	to: string;
+}
+
+export interface GraphCheckpointMount {
+	at: string;
+	checkpoint: GraphCheckpoint;
+}
+
+export interface GraphCheckpoint {
+	version: GraphCheckpointVersion;
+	name?: string;
+	nodes: GraphCheckpointNode[];
+	edges: GraphCheckpointEdge[];
+	mounts?: GraphCheckpointMount[];
+}
+
+export function toCheckpointJson(value: unknown, path = "$"): GraphCheckpointJson {
+	try {
+		return strictJsonCodec.decode(strictJsonCodec.encode(value)) as GraphCheckpointJson;
+	} catch (cause) {
+		throw new TypeError(`checkpoint: value at ${path} is not strict JSON compatible`, {
+			cause,
+		});
+	}
+}
+
+export function checkpointValue(
+	value: unknown,
+	hasData: boolean,
+	path: string,
+): GraphCheckpointValue {
+	if (!hasData || value === SENTINEL) return { kind: "SENTINEL" };
+	return { kind: "DATA", data: toCheckpointJson(value, path) };
+}
+
+export function checkpointTerminal(value: unknown, path: string): GraphCheckpointTerminal {
+	if (value === undefined) return { kind: "none" };
+	if (value === true) return { kind: "COMPLETE" };
+	return { kind: "ERROR", error: toCheckpointJson(value, path) };
+}
+
+type BackendStateContributor = () => unknown;
+
+const backendStateContributors = new WeakMap<Node<unknown>, BackendStateContributor>();
+
+/** @internal D160: collection-owned backend checkpoint contributor for graph checkpoint. */
+export function registerBackendStateContributor(
+	node: Node<unknown>,
+	contributor: BackendStateContributor,
+): void {
+	backendStateContributors.set(node, contributor);
+}
+
+/** @internal D160: capture a node's collection backend state when it has a contributor. */
+export function checkpointBackendStateOfNode(
+	node: Node<unknown>,
+	path: string,
+): GraphCheckpointJson | undefined {
+	const contributor = backendStateContributors.get(node);
+	if (contributor === undefined) return undefined;
+	return toCheckpointJson(contributor(), path);
+}
diff --git a/packages/ts/src/graph/combinators.ts b/packages/ts/src/graph/combinators.ts
new file mode 100644
index 00000000..4b699a08
--- /dev/null
+++ b/packages/ts/src/graph/combinators.ts
@@ -0,0 +1,394 @@
+/**
+ * Multi-source combinators + notifier-driven operators (CSP-2.7 catalog re-derive, D40 / D45).
+ *
+ * Per-language sugar (D6/D24, never in parity). Each forms topology ONLY via DECLARED deps (D45) —
+ * the frozen pure-ts reference (D41) builds these as a producer that calls `subscribeOr` on each
+ * source INSIDE the fn body, which is the D45-banned describe island (an edge `describe` cannot
+ * show). Re-derived here as static-dep nodes with `partial:true` (fire on any dep, R-first-run-gate
+ * off) + `ctx.state` (queue / phase / winner) — so every edge is a real subscription `describe`
+ * shows truthfully (D3 / R-edges-derived). Multi-source completion / error reads
+ * `depTerminal(ctx, i)` (R-deps-terminal) via `completeWhenDepsComplete:false +
+ * terminalAsRealInput:true`.
+ *
+ * Under D49 (no equals-absorption) `combine` emits a fresh tuple on EVERY contributing wave (no
+ * substrate tuple-dedup; the pure-ts `equals` tuple comparator is gone) — pair with
+ * `distinctUntilChanged` for opt-in dedup. SENTINEL ("a dep has never delivered DATA") is detected
+ * via `depLatest(ctx, i) === undefined` (R-sentinel: `undefined` is the global sentinel, `null` is a valid
+ * value).
+ *
+ * NOT re-derived in this cut (flagged): the window family (`window`/`windowCount`/`windowTime`)
+ * emits `Node<Node<T>>` nested sub-streams — the frozen reference creates child nodes inside the fn
+ * body and pushes DATA into them imperatively, which is a describe island AND an open question for
+ * how an emitted live sub-stream appears in `describe` (D45/D51). Deferred to a design pass.
+ */
+
+import {
+	type Ctx,
+	depBatch,
+	depCount,
+	depLatest,
+	depTerminal,
+	isTerminalComplete,
+	isTerminalError,
+	isTerminalNone,
+	terminalErrorValue,
+} from "../ctx/types.js";
+import type { Operator } from "./operators.js";
+
+/**
+ * combine (alias `combineLatest`): emit a tuple of every dep's latest value whenever ANY dep
+ * delivers, once ALL deps have delivered at least one value. `partial:true`; the all-delivered gate
+ * is `depLatest(ctx, i) !== undefined` per dep. Completes when ALL deps complete (default
+ * completeWhenDepsComplete); any dep ERROR propagates (default errorWhenDepsError). Emits a fresh
+ * tuple per wave (D49 — no dedup; compose `distinctUntilChanged` to suppress unchanged tuples).
+ */
+export function combine<T extends readonly unknown[]>(): Operator<unknown, T> {
+	return {
+		factory: "combine",
+		opts: { partial: true },
+		body: (ctx) => {
+			const vals = Array.from({ length: depCount(ctx) }, (_, i) => depLatest(ctx, i));
+			if (vals.some((v) => v === undefined)) return; // not all deps delivered → undirty RESOLVED
+			ctx.down([["DATA", vals as unknown as T]]);
+		},
+	};
+}
+
+/** combineLatest: RxJS-named alias of {@link combine}. */
+export const combineLatest = combine;
+
+/**
+ * withLatestFrom: on each PRIMARY (dep 0) value, emit `[primary, latestSecondary]`; a secondary-only
+ * (dep 1) wave updates the cached secondary but emits nothing. Uses the DEFAULT first-run gate
+ * (`partial:false`), NOT partial — the frozen reference's Phase 10.5 W1 fix: with `partial:true` the
+ * primary's push-on-subscribe fires the fn BEFORE the secondary has delivered, so the initial pair
+ * is dropped. The gate holds the first run until BOTH deps settle, then fires once with both
+ * populated; subsequent waves are gate-free and fire on primary-alone. Completes when the PRIMARY
+ * completes (not the secondary) — `completeWhenDepsComplete:false + terminalAsRealInput:true` with a
+ * primary-terminal check; a secondary terminal is ignored (its last value persists).
+ */
+export function withLatestFrom<A, B>(): Operator<unknown, readonly [A, B]> {
+	return {
+		factory: "withLatestFrom",
+		opts: { completeWhenDepsComplete: false, terminalAsRealInput: true },
+		body: (ctx) => {
+			if (isTerminalComplete(depTerminal(ctx, 0))) {
+				ctx.down([["COMPLETE"]]);
+				return;
+			}
+			const b0 = depBatch(ctx, 0);
+			if (!b0 || b0.length === 0) return; // secondary-only wave → quiet
+			const sec = depLatest(ctx, 1) as B | undefined;
+			if (sec === undefined) return; // secondary never delivered → quiet
+			for (const v of b0) ctx.down([["DATA", [v, sec] as readonly [A, B]]]);
+		},
+	};
+}
+
+/** Internal: per-dep FIFO queues for {@link zip}. */
+interface ZipState {
+	queues: unknown[][];
+	terminal: boolean[];
+}
+
+/**
+ * zip: combine one value from EACH dep, in lockstep, into a tuple — buffering per-dep queues until
+ * every dep has at least one queued value, then shifting one from each. `partial:true` +
+ * `ctx.state` queues. Completes as soon as ANY dep is terminal AND its queue is empty (no further
+ * tuple can form) — `completeWhenDepsComplete:false + terminalAsRealInput:true`. Any dep ERROR
+ * propagates (default errorWhenDepsError).
+ */
+export function zip<T extends readonly unknown[]>(): Operator<unknown, T> {
+	return {
+		factory: "zip",
+		opts: { partial: true, completeWhenDepsComplete: false, terminalAsRealInput: true },
+		body: (ctx) => {
+			const n = depCount(ctx);
+			if (n === 0) {
+				ctx.down([["COMPLETE"]]);
+				return;
+			}
+			const st = ctx.state.get<ZipState>() ?? {
+				queues: Array.from({ length: n }, () => [] as unknown[]),
+				terminal: new Array(n).fill(false),
+			};
+			for (let i = 0; i < n; i++) {
+				const b = depBatch(ctx, i);
+				if (b) for (const v of b) st.queues[i].push(v);
+				if (isTerminalComplete(depTerminal(ctx, i))) st.terminal[i] = true;
+			}
+			while (st.queues.every((q) => q.length > 0)) {
+				ctx.down([["DATA", st.queues.map((q) => q.shift()) as unknown as T]]);
+			}
+			ctx.state.set(st);
+			// A terminal dep whose queue is now drained can never contribute another tuple → COMPLETE.
+			for (let i = 0; i < n; i++) {
+				if (st.terminal[i] && st.queues[i].length === 0) {
+					ctx.down([["COMPLETE"]]);
+					return;
+				}
+			}
+		},
+	};
+}
+
+/** Internal: phase + buffered second-source values for {@link concat}. */
+interface ConcatState<S> {
+	phase: 0 | 1;
+	pending: S[];
+	secondDone: boolean;
+}
+
+/**
+ * concat: play ALL of dep 0, then ALL of dep 1. Dep-1 DATA arriving during phase 0 is buffered and
+ * flushed at the handoff (dep 0 COMPLETE). `partial:true` + `ctx.state` phase. Completes when dep 1
+ * completes (or when dep 0 completes and dep 1 already had). `completeWhenDepsComplete:false +
+ * terminalAsRealInput:true`; any dep ERROR propagates (default errorWhenDepsError).
+ */
+export function concat<S>(): Operator<S, S> {
+	return {
+		factory: "concat",
+		opts: { partial: true, completeWhenDepsComplete: false, terminalAsRealInput: true },
+		body: (ctx) => {
+			const firstBatch = depBatch(ctx, 0);
+			const secondBatch = depBatch(ctx, 1);
+			const firstTerminal = depTerminal(ctx, 0);
+			const secondTerminal = depTerminal(ctx, 1);
+			const st: ConcatState<S> = ctx.state.get<ConcatState<S>>() ?? {
+				phase: 0,
+				pending: [],
+				secondDone: false,
+			};
+			if (st.phase === 0) {
+				if (firstBatch) for (const v of firstBatch) ctx.down([["DATA", v]]);
+				if (secondBatch) for (const v of secondBatch) st.pending.push(v as S);
+				if (isTerminalComplete(secondTerminal)) st.secondDone = true;
+				if (isTerminalComplete(firstTerminal)) {
+					st.phase = 1;
+					for (const v of st.pending) ctx.down([["DATA", v]]);
+					st.pending = [];
+					if (st.secondDone) ctx.down([["COMPLETE"]]);
+				}
+			} else {
+				if (secondBatch) for (const v of secondBatch) ctx.down([["DATA", v]]);
+				if (isTerminalComplete(secondTerminal)) ctx.down([["COMPLETE"]]);
+			}
+			ctx.state.set(st);
+		},
+	};
+}
+
+/** Internal: which dep won the {@link race} (null until the first DATA). */
+interface RaceState {
+	winner: number | null;
+	terminals: unknown[];
+}
+
+/**
+ * race: the FIRST dep to deliver DATA wins; thereafter only the winner's messages flow (losers are
+ * dropped, including their terminals). `partial:true` + `ctx.state` winner. `errorWhenDepsError:false`
+ * (a LOSER's error must not error the race — only the winner's) + `completeWhenDepsComplete:false +
+ * terminalAsRealInput:true`. If every dep terminates before any DATA, COMPLETE.
+ */
+export function race<S>(): Operator<S, S> {
+	return {
+		factory: "race",
+		opts: {
+			partial: true,
+			errorWhenDepsError: false,
+			completeWhenDepsComplete: false,
+			terminalAsRealInput: true,
+		},
+		body: (ctx) => {
+			const n = depCount(ctx);
+			const st: RaceState = ctx.state.get<RaceState>() ?? {
+				winner: null,
+				terminals: new Array(n).fill(false),
+			};
+			for (let i = 0; i < n; i++) {
+				const terminal = depTerminal(ctx, i);
+				if (!isTerminalNone(terminal)) st.terminals[i] = terminal;
+			}
+			if (st.winner === null) {
+				// Find the first dep that delivered DATA this wave → it wins.
+				for (let i = 0; i < n; i++) {
+					const b = depBatch(ctx, i);
+					if (b && b.length > 0) {
+						st.winner = i;
+						for (const v of b) ctx.down([["DATA", v]]);
+						break;
+					}
+				}
+				if (st.winner === null) {
+					// No winner yet — if EVERY dep is terminal (none ever delivered DATA), COMPLETE.
+					if (st.terminals.every((t) => !isTerminalNone(t))) {
+						ctx.state.set(st);
+						ctx.down([["COMPLETE"]]);
+						return;
+					}
+				}
+			} else {
+				const b = depBatch(ctx, st.winner);
+				const terminal = depTerminal(ctx, st.winner);
+				if (b) for (const v of b) ctx.down([["DATA", v]]);
+				if (isTerminalComplete(terminal)) {
+					ctx.state.set(st);
+					ctx.down([["COMPLETE"]]);
+					return;
+				}
+				if (isTerminalError(terminal)) {
+					ctx.state.set(st);
+					ctx.down([["ERROR", terminalErrorValue(terminal)]]);
+					return;
+				}
+			}
+			ctx.state.set(st);
+		},
+	};
+}
+
+// ── notifier-driven (D46 first-cut: gated on a reactive notifier dep, no wall-clock) ──
+
+/**
+ * buffer: accumulate dep 0 (source) DATA; flush the buffer as an array each time dep 1 (notifier)
+ * delivers DATA. `partial:true` + `ctx.state` buffer. On source COMPLETE, flush any remainder then
+ * COMPLETE (`completeWhenDepsComplete:false + terminalAsRealInput:true`; a notifier terminal is
+ * ignored). Source/notifier ERROR propagates (default errorWhenDepsError).
+ */
+export function buffer<S>(): Operator<unknown, S[]> {
+	return {
+		factory: "buffer",
+		opts: { partial: true, completeWhenDepsComplete: false, terminalAsRealInput: true },
+		body: (ctx) => {
+			const sourceBatch = depBatch(ctx, 0);
+			const notifierBatch = depBatch(ctx, 1);
+			const buf = ctx.state.get<S[]>() ?? [];
+			if (sourceBatch) for (const v of sourceBatch) buf.push(v as S);
+			if (isTerminalComplete(depTerminal(ctx, 0))) {
+				if (buf.length > 0) ctx.down([["DATA", [...buf]]]);
+				ctx.state.set([]);
+				ctx.down([["COMPLETE"]]);
+				return;
+			}
+			if (notifierBatch && notifierBatch.length > 0) {
+				ctx.down([["DATA", [...buf]]]); // flush (may be empty) on each notifier signal
+				ctx.state.set([]);
+				return;
+			}
+			ctx.state.set(buf);
+		},
+	};
+}
+
+/**
+ * bufferCount: batch consecutive source DATA into arrays of length `count`; the remainder flushes on
+ * source COMPLETE. Single dep + `ctx.state` buffer + `completeWhenDepsComplete:false +
+ * terminalAsRealInput:true`.
+ */
+export function bufferCount<S>(count: number): Operator<S, S[]> {
+	if (!Number.isInteger(count) || count < 1) {
+		throw new RangeError(`bufferCount: count must be a positive integer (got ${count})`);
+	}
+	return {
+		factory: "bufferCount",
+		opts: { completeWhenDepsComplete: false, terminalAsRealInput: true },
+		body: (ctx) => {
+			const b = depBatch(ctx, 0);
+			const buf = ctx.state.get<S[]>() ?? [];
+			if (b) {
+				for (const v of b) {
+					buf.push(v as S);
+					if (buf.length >= count) ctx.down([["DATA", buf.splice(0, buf.length)]]);
+				}
+			}
+			if (isTerminalComplete(depTerminal(ctx, 0))) {
+				if (buf.length > 0) ctx.down([["DATA", [...buf]]]);
+				ctx.state.set([]);
+				ctx.down([["COMPLETE"]]);
+				return;
+			}
+			ctx.state.set(buf);
+		},
+	};
+}
+
+/** Internal: latest sampled source value + whether the source has completed, for {@link sample}. */
+interface SampleState<S> {
+	last: { v: S } | undefined;
+	sourceDone: boolean;
+}
+
+/**
+ * sample: emit the source's (dep 0) most recent value each time the notifier (dep 1) delivers DATA.
+ * `partial:true` + `ctx.state`. The notifier completing completes the operator; the source completing
+ * stops sampling (clears the held value); an ERROR from either terminates.
+ * `completeWhenDepsComplete:false + errorWhenDepsError:false + terminalAsRealInput:true` (manual
+ * terminal handling). No flush of the held value on source COMPLETE (RxJS sample semantics).
+ */
+export function sample<S>(): Operator<unknown, S> {
+	return {
+		factory: "sample",
+		opts: {
+			partial: true,
+			completeWhenDepsComplete: false,
+			errorWhenDepsError: false,
+			terminalAsRealInput: true,
+		},
+		body: (ctx) => {
+			const sourceBatch = depBatch(ctx, 0);
+			const notifierBatch = depBatch(ctx, 1);
+			const sourceTerminal = depTerminal(ctx, 0);
+			const notifierTerminal = depTerminal(ctx, 1);
+			const st: SampleState<S> = ctx.state.get<SampleState<S>>() ?? {
+				last: undefined,
+				sourceDone: false,
+			};
+			// ERROR from either dep → terminate.
+			if (isTerminalError(sourceTerminal)) {
+				ctx.down([["ERROR", terminalErrorValue(sourceTerminal)]]);
+				return;
+			}
+			if (isTerminalError(notifierTerminal)) {
+				ctx.down([["ERROR", terminalErrorValue(notifierTerminal)]]);
+				return;
+			}
+			if (sourceBatch) for (const v of sourceBatch) st.last = { v: v as S };
+			if (isTerminalComplete(sourceTerminal)) {
+				st.sourceDone = true;
+				st.last = undefined;
+			}
+			if (isTerminalComplete(notifierTerminal)) {
+				ctx.state.set(st);
+				ctx.down([["COMPLETE"]]);
+				return;
+			}
+			if (notifierBatch && notifierBatch.length > 0 && st.last !== undefined && !st.sourceDone) {
+				ctx.down([["DATA", st.last.v]]);
+			}
+			ctx.state.set(st);
+		},
+	};
+}
+
+/**
+ * takeUntil: forward dep 0 (source) DATA until dep 1 (notifier) delivers its first DATA, then
+ * COMPLETE. `partial:true` + `completeWhenDepsComplete:false + terminalAsRealInput:true`: a source
+ * COMPLETE forwards COMPLETE; a notifier DATA triggers COMPLETE. Source/notifier ERROR propagates
+ * (default errorWhenDepsError).
+ */
+export function takeUntil<S>(): Operator<unknown, S> {
+	return {
+		factory: "takeUntil",
+		opts: { partial: true, completeWhenDepsComplete: false, terminalAsRealInput: true },
+		body: (ctx: Ctx) => {
+			const sourceBatch = depBatch(ctx, 0);
+			const notifierBatch = depBatch(ctx, 1);
+			if (notifierBatch && notifierBatch.length > 0) {
+				ctx.down([["COMPLETE"]]); // notifier fired → stop
+				return;
+			}
+			if (sourceBatch) for (const v of sourceBatch) ctx.down([["DATA", v]]);
+			if (isTerminalComplete(depTerminal(ctx, 0))) ctx.down([["COMPLETE"]]);
+		},
+	};
+}
diff --git a/packages/ts/src/graph/composition.ts b/packages/ts/src/graph/composition.ts
new file mode 100644
index 00000000..b3928512
--- /dev/null
+++ b/packages/ts/src/graph/composition.ts
@@ -0,0 +1,306 @@
+/**
+ * CSP-2.8 composition helpers (D56).
+ *
+ * These are graph-layer, per-language helpers (D6/D24), not protocol primitives. The first cut is
+ * intentionally static: branch nodes are declared at construction time, with real dep edges
+ * `[source, rules]` that `describe()` can show. Dynamic rule add/remove is deferred by D56.
+ */
+
+import {
+	type Ctx,
+	depBatch,
+	depLatest,
+	depTerminal,
+	isTerminalComplete,
+	isTerminalError,
+	terminalErrorValue,
+} from "../ctx/types.js";
+import type { Node, NodeOptions } from "../node/node.js";
+import type { DescribeEdge, DescribeNode, DescribeSnapshot } from "./describe.js";
+import type { Graph, StateNode, SugarOpts } from "./graph.js";
+import { initNode, type Operator } from "./operators.js";
+
+/** One unary operator step accepted by {@link pipe}. */
+export type PipeOperator<TIn, TOut> = Operator<TIn, TOut>;
+
+export type DescribeEvent =
+	| { readonly type: "node-added"; readonly id: string; readonly node: DescribeNode }
+	| { readonly type: "node-removed"; readonly id: string }
+	| {
+			readonly type: "node-meta-changed";
+			readonly id: string;
+			readonly prevMeta: Record<string, unknown>;
+			readonly nextMeta: Record<string, unknown>;
+	  }
+	| { readonly type: "edge-added"; readonly from: string; readonly to: string }
+	| { readonly type: "edge-removed"; readonly from: string; readonly to: string }
+	| { readonly type: "subgraph-mounted"; readonly path: string }
+	| { readonly type: "subgraph-unmounted"; readonly path: string };
+
+export interface DescribeChangeset {
+	readonly events: readonly DescribeEvent[];
+}
+
+function metaEqual(a: unknown, b: unknown): boolean {
+	if (Object.is(a, b)) return true;
+	if (a == null || b == null || typeof a !== "object" || typeof b !== "object") return false;
+	if (Array.isArray(a) || Array.isArray(b)) {
+		if (!Array.isArray(a) || !Array.isArray(b) || a.length !== b.length) return false;
+		for (let i = 0; i < a.length; i++) if (!metaEqual(a[i], b[i])) return false;
+		return true;
+	}
+	const ak = Object.keys(a as Record<string, unknown>).sort();
+	const bk = Object.keys(b as Record<string, unknown>).sort();
+	if (ak.length !== bk.length) return false;
+	for (let i = 0; i < ak.length; i++) {
+		if (ak[i] !== bk[i]) return false;
+		if (!metaEqual((a as Record<string, unknown>)[ak[i]], (b as Record<string, unknown>)[bk[i]]))
+			return false;
+	}
+	return true;
+}
+
+function edgeKey(e: DescribeEdge): string {
+	return `${e.from}\0${e.to}`;
+}
+
+function cloneNode(n: DescribeNode): DescribeNode {
+	return {
+		...n,
+		deps: [...n.deps],
+		...(n.meta ? { meta: { ...n.meta } } : {}),
+	};
+}
+
+function flattenSnapshot(snap: DescribeSnapshot): {
+	nodes: Map<string, DescribeNode>;
+	edges: Map<string, DescribeEdge>;
+	subgraphs: Set<string>;
+} {
+	const nodes = new Map<string, DescribeNode>();
+	const edges = new Map<string, DescribeEdge>();
+	const subgraphs = new Set<string>();
+	const visit = (s: DescribeSnapshot, indexPath = ""): void => {
+		for (const n of s.nodes) nodes.set(n.id, n);
+		for (const e of s.edges) edges.set(edgeKey(e), e);
+		s.subgraphs?.forEach((child, i) => {
+			const prefixed = child.nodes.find((n) => n.id.includes("::"))?.id;
+			const key =
+				prefixed?.slice(0, prefixed.lastIndexOf("::")) ??
+				(child.name ? `${indexPath}${child.name}` : `${indexPath}${i}`);
+			subgraphs.add(key);
+			visit(child, `${key}/`);
+		});
+	};
+	visit(snap);
+	return { nodes, edges, subgraphs };
+}
+
+/**
+ * Pure topology delta from one D39 `describe()` snapshot to another. No node refs, no clocks, no
+ * old-core deps (D56). Values/status changes are not topology events; use `observe()` for data.
+ */
+export function topologyDiff(prev: DescribeSnapshot, next: DescribeSnapshot): DescribeChangeset {
+	const p = flattenSnapshot(prev);
+	const n = flattenSnapshot(next);
+	const events: DescribeEvent[] = [];
+
+	for (const path of [...n.subgraphs].filter((x) => !p.subgraphs.has(x)).sort())
+		events.push({ type: "subgraph-mounted", path });
+
+	for (const id of [...n.nodes.keys()].filter((x) => !p.nodes.has(x)).sort()) {
+		events.push({ type: "node-added", id, node: cloneNode(n.nodes.get(id) as DescribeNode) });
+	}
+
+	for (const id of [...n.nodes.keys()].filter((x) => p.nodes.has(x)).sort()) {
+		const prevMeta = p.nodes.get(id)?.meta ?? {};
+		const nextMeta = n.nodes.get(id)?.meta ?? {};
+		if (!metaEqual(prevMeta, nextMeta)) {
+			events.push({
+				type: "node-meta-changed",
+				id,
+				prevMeta: { ...prevMeta },
+				nextMeta: { ...nextMeta },
+			});
+		}
+	}
+
+	for (const [k, e] of [...n.edges.entries()].sort()) {
+		if (!p.edges.has(k)) events.push({ type: "edge-added", from: e.from, to: e.to });
+	}
+	for (const [k, e] of [...p.edges.entries()].sort()) {
+		if (!n.edges.has(k)) events.push({ type: "edge-removed", from: e.from, to: e.to });
+	}
+
+	for (const id of [...p.nodes.keys()].filter((x) => !n.nodes.has(x)).sort())
+		events.push({ type: "node-removed", id });
+
+	for (const path of [...p.subgraphs].filter((x) => !n.subgraphs.has(x)).sort())
+		events.push({ type: "subgraph-unmounted", path });
+
+	return { events };
+}
+
+/**
+ * Compose unary operator factories into a graph-registered chain.
+ *
+ * Each step is instantiated through `g.initNode`, so `describe()` still shows the real
+ * per-operator factory names and declared edges (D6/D39/D45). This is graph-layer sugar, not a
+ * new verb or protocol primitive.
+ */
+export function pipe<S>(g: Graph, source: Node<S>): Node<S>;
+export function pipe<S, A>(g: Graph, source: Node<S>, op1: PipeOperator<S, A>): Node<A>;
+export function pipe<S, A, B>(
+	g: Graph,
+	source: Node<S>,
+	op1: PipeOperator<S, A>,
+	op2: PipeOperator<A, B>,
+): Node<B>;
+export function pipe<S, A, B, C>(
+	g: Graph,
+	source: Node<S>,
+	op1: PipeOperator<S, A>,
+	op2: PipeOperator<A, B>,
+	op3: PipeOperator<B, C>,
+): Node<C>;
+export function pipe<S, A, B, C, D>(
+	g: Graph,
+	source: Node<S>,
+	op1: PipeOperator<S, A>,
+	op2: PipeOperator<A, B>,
+	op3: PipeOperator<B, C>,
+	op4: PipeOperator<C, D>,
+): Node<D>;
+export function pipe<S, A, B, C, D, E>(
+	g: Graph,
+	source: Node<S>,
+	op1: PipeOperator<S, A>,
+	op2: PipeOperator<A, B>,
+	op3: PipeOperator<B, C>,
+	op4: PipeOperator<C, D>,
+	op5: PipeOperator<D, E>,
+): Node<E>;
+export function pipe<S, A, B, C, D, E, F>(
+	g: Graph,
+	source: Node<S>,
+	op1: PipeOperator<S, A>,
+	op2: PipeOperator<A, B>,
+	op3: PipeOperator<B, C>,
+	op4: PipeOperator<C, D>,
+	op5: PipeOperator<D, E>,
+	op6: PipeOperator<E, F>,
+): Node<F>;
+export function pipe<S>(
+	g: Graph,
+	source: Node<S>,
+	...ops: readonly PipeOperator<unknown, unknown>[]
+): Node<unknown>;
+export function pipe(
+	g: Graph,
+	source: Node<unknown>,
+	...ops: readonly PipeOperator<unknown, unknown>[]
+): Node<unknown> {
+	let current = source;
+	for (const op of ops) current = g.initNode(op, [current]);
+	return current;
+}
+
+export interface StratifyRule<R> {
+	readonly name: string;
+	readonly rule: R;
+	readonly meta?: Record<string, unknown>;
+}
+
+export interface StratifyBranchOptions<T> extends Omit<NodeOptions<T>, "dispatcher"> {}
+
+/** D56 branch node body: declared deps `[source, rules]`, no internal subscribe island. */
+export function stratifyBranch<T, R>(
+	source: Node<T>,
+	rules: Node<R>,
+	classifier: (rules: R, value: T) => boolean,
+	opts: StratifyBranchOptions<T> = {},
+): Node<T> {
+	const op = stratifyBranchOperator<T, R>(classifier);
+	return initNode(op, [source as Node<unknown>, rules as Node<unknown>], opts);
+}
+
+function stratifyBranchOperator<T, R>(
+	classifier: (rules: R, value: T) => boolean,
+): Operator<unknown, T> {
+	return {
+		factory: "stratifyBranch",
+		opts: {
+			completeWhenDepsComplete: false,
+			errorWhenDepsError: false,
+			terminalAsRealInput: true,
+		},
+		body: (ctx: Ctx) => {
+			const sourceBatch = depBatch(ctx, 0);
+			const sourceTerminal = depTerminal(ctx, 0);
+			const rules = depLatest(ctx, 1) as R | undefined;
+			if (rules !== undefined && sourceBatch !== null) {
+				for (const value of sourceBatch as readonly T[]) {
+					if (classifier(rules, value)) ctx.down([["DATA", value]]);
+				}
+			}
+			if (isTerminalComplete(sourceTerminal)) {
+				ctx.down([["COMPLETE"]]);
+			} else if (isTerminalError(sourceTerminal)) {
+				ctx.down([["ERROR", terminalErrorValue(sourceTerminal)]]);
+			}
+		},
+	};
+}
+
+export interface StratifyOptions<R = unknown> {
+	/** Branch id prefix. Default `branch`, yielding ids like `branch/even`. */
+	prefix?: string;
+	/** Optional graph sugar opts for the rules state node. */
+	rules?: SugarOpts<readonly StratifyRule<R>[]>;
+	/** Optional graph sugar opts for each branch node, keyed by rule name. */
+	branches?: Record<string, SugarOpts<unknown>>;
+}
+
+export interface Stratified<T, R> {
+	readonly rules: StateNode<readonly StratifyRule<R>[]>;
+	readonly branches: Record<string, Node<T>>;
+}
+
+/**
+ * Build static stratification branches in `g` (D56 first cut). Rules are a state node so future
+ * classifier data changes affect future source items, but branch count is fixed at construction.
+ */
+export function stratify<T, R>(
+	g: Graph,
+	source: Node<T>,
+	rules: readonly StratifyRule<R>[],
+	classifier: (rule: R, value: T) => boolean,
+	opts: StratifyOptions<R> = {},
+): Stratified<T, R> {
+	const prefix = opts.prefix ?? "branch";
+	const seen = new Set<string>();
+	for (const { name } of rules) {
+		if (seen.has(name)) throw new Error(`stratify: duplicate rule name '${name}'`);
+		seen.add(name);
+	}
+	const { meta: rulesMeta, ...rulesOpts } = opts.rules ?? {};
+	const rulesNode = g.state<readonly StratifyRule<R>[]>([...rules], {
+		...rulesOpts,
+		name: rulesOpts.name ?? `${prefix}/rules`,
+		meta: { ...(rulesMeta ?? {}), kind: "stratify_rules" },
+	});
+	const branches: Record<string, Node<T>> = {};
+	for (const rule of rules) {
+		const op = stratifyBranchOperator<T, readonly StratifyRule<R>[]>((all, value) => {
+			const current = all.find((r) => r.name === rule.name);
+			return current === undefined ? false : classifier(current.rule, value);
+		});
+		const { meta: branchMeta, ...branchOpts } = opts.branches?.[rule.name] ?? {};
+		branches[rule.name] = g.initNode(op, [source as Node<unknown>, rulesNode as Node<unknown>], {
+			...branchOpts,
+			name: branchOpts.name ?? `${prefix}/${rule.name}`,
+			meta: { ...(rule.meta ?? {}), ...(branchMeta ?? {}), branch: rule.name },
+		}) as Node<T>;
+	}
+	return { rules: rulesNode, branches };
+}
diff --git a/packages/ts/src/graph/data-structures/change.ts b/packages/ts/src/graph/data-structures/change.ts
new file mode 100644
index 00000000..8fe5055b
--- /dev/null
+++ b/packages/ts/src/graph/data-structures/change.ts
@@ -0,0 +1,51 @@
+/**
+ * Delta-event payloads for the reactive data structures (CSP-2.8, D54/D60).
+ *
+ * Each reactive structure has a DELTA port (an always-on push stream, D60) that emits ONE of
+ * these change payloads per mutation (O(1)/mutation). The SNAPSHOT port (a lazy pull-mode node)
+ * carries the materialized state instead — see {@link collectionCore}. These are the structure-
+ * specific verbs; the delta stream emits the raw payload (no envelope — version/timestamp/audit
+ * framing is a storage concern, D57, layered separately if needed).
+ *
+ * Per-language (D6/D24, never in parity, no conformance). Canonical authority:
+ * ~/src/graphrefly/decisions/decisions.jsonl D54/D60.
+ */
+
+/** List structure delta events. */
+export type ListChange<T> =
+	| { readonly kind: "append"; readonly value: T }
+	| { readonly kind: "appendMany"; readonly values: readonly T[] }
+	| { readonly kind: "insert"; readonly index: number; readonly value: T }
+	| { readonly kind: "insertMany"; readonly index: number; readonly values: readonly T[] }
+	| { readonly kind: "pop"; readonly index: number; readonly value: T }
+	| { readonly kind: "trimHead"; readonly n: number }
+	| { readonly kind: "clear"; readonly count: number };
+
+/**
+ * Map structure delta events. `delete.reason` distinguishes the four delete sources (D60 #3c):
+ * an explicit `.delete`, a TTL `expired` read-prune, an `lru-evict` under `maxSize`, or an
+ * `archived` retention sweep.
+ */
+export type MapChange<K, V> =
+	| { readonly kind: "set"; readonly key: K; readonly value: V }
+	| {
+			readonly kind: "delete";
+			readonly key: K;
+			readonly previous: V;
+			readonly reason: "expired" | "lru-evict" | "archived" | "explicit";
+	  }
+	| { readonly kind: "clear"; readonly count: number };
+
+/** Dual-key index structure delta events. */
+export type IndexChange<K, V> =
+	| { readonly kind: "upsert"; readonly primary: K; readonly secondary: unknown; readonly value: V }
+	| { readonly kind: "delete"; readonly primary: K }
+	| { readonly kind: "deleteMany"; readonly primaries: readonly K[] }
+	| { readonly kind: "clear"; readonly count: number };
+
+/** Append-only log structure delta events. */
+export type LogChange<T> =
+	| { readonly kind: "append"; readonly value: T }
+	| { readonly kind: "appendMany"; readonly values: readonly T[] }
+	| { readonly kind: "clear"; readonly count: number }
+	| { readonly kind: "trimHead"; readonly n: number };
diff --git a/packages/ts/src/graph/data-structures/core.ts b/packages/ts/src/graph/data-structures/core.ts
new file mode 100644
index 00000000..7ab8285d
--- /dev/null
+++ b/packages/ts/src/graph/data-structures/core.ts
@@ -0,0 +1,334 @@
+/**
+ * The shared reactiveCollection core (CSP-2.8, D60).
+ *
+ * Every reactive data structure (list/map/index/log) is `collectionCore(backend) + a typed method
+ * surface` (D60 #5). The core owns the TWO output ports and nothing else:
+ *
+ *   - BACKEND — the single materialized state (D60 #1): a plain mutable object with a monotonic
+ *     `version` + a `snapshot()`. It applies deltas and IS the materialized state; there is NO ACC
+ *     node and NO effect bridge re-deriving it (the misdesign D60 rejected — the backend already
+ *     integrates, its cost is intrinsic). The backend is a closure object, not a graph node, so its
+ *     durability is structural (survives last-subscriber disconnect; node ROM/RAM is moot, D60 #1).
+ *
+ *   - DELTA port (D60 #2a) — an always-on bare source ({@link CollectionCore.delta}); each mutation
+ *     pushes ONE change payload (O(1)/mutation). Downstream watches events anytime. It is the
+ *     structure's BACKBONE: the snapshot node declares it as its dep (D60 reactiveList topology).
+ *
+ *   - SNAPSHOT port (D60 #2b) — a pull-mode node ({@link CollectionCore.snapshot}, R-pull/D269) that
+ *     is QUIET by default and, on a cone-routed PULL demand, LAZILY reads `backend.snapshot()`
+ *     (one O(n) materialization) and pushes it once, then re-quiets. The O(n) build happens ONLY on
+ *     demand — never eagerly per mutation (D60 #2b: lazy is P·O(n), not M·O(n)). It has NO value of
+ *     its own — its fn reads the backend on demand, so the backend stays the single source of truth
+ *     (D60 #3). Coalesce-on-no-change is free: the delta-dep's DIRTY/DATA arms the pull node via
+ *     R-pull's quiet-absorb accounting; a demand with no intervening delta emits no duplicate DATA.
+ *
+ * Demand path: a downstream consumer issues `ctx.upNext([["PULL", { pullId: core.pullId }]])`
+ * (boundary-deferred self-demand, R-up-routing/D269) — it needs the snapshot node upstream in its
+ * declared cone, NOT its reference. Cold-start (a demand before any mutation) emits no DATA; for an
+ * initial/imperative read use the structure's synchronous quick-read (the deliberately-non-reactive
+ * peek, D60) — the reactive pull serves the watch-delta-then-demand pattern.
+ *
+ * Per-language (D6/D24, never in parity, no conformance — the substrate pull is already C-16).
+ */
+
+import { type Ctx, depBatch } from "../../ctx/types.js";
+import type { Dispatcher } from "../../dispatcher/index.js";
+import { Node, releaseRuntimeOfNode } from "../../node/node.js";
+import { errorPayload } from "../../protocol/messages.js";
+import { type GraphCheckpointJson, registerBackendStateContributor } from "../checkpoint.js";
+import type { Graph } from "../graph.js";
+import type { Operator } from "../operators.js";
+import type { ViewCachePolicy } from "../policies/types.js";
+
+/** The materialized-state contract a structure's backend must satisfy (D60 #1). */
+export interface CollectionBackend<S> {
+	/** Monotonic mutation counter; advances on every visible state change (idempotency, D49). */
+	readonly version: number;
+	/** A fresh defensive materialization of the current state (D60: first-cut defensive copy). */
+	snapshot(): S;
+}
+
+export interface CollectionCoreOptions {
+	/** Debug/inspection name; the delta/snapshot nodes derive `${name}.delta` / `${name}.snapshot`. */
+	name?: string;
+	/** Dispatcher for the core's nodes (default = process-global, D26). */
+	dispatcher?: Dispatcher;
+	/** Graph funnel for describe-visible input folds (D61). Required by *From/attach methods. */
+	graph?: Graph;
+}
+
+export interface CollectionCore<S, C> {
+	/** DELTA backbone (D60 #2a): a bare source; every {@link CollectionCore.emit} pushes one change. */
+	readonly delta: Node<C>;
+	/** SNAPSHOT pull node (D60 #2b): demand via `ctx.upNext([["PULL", { pullId }]])`; lazy O(n) on demand. */
+	readonly snapshot: Node<S>;
+	/** The snapshot node's pullId — the author writes it verbatim into the demander's fn (D269). */
+	readonly pullId: symbol;
+	/** Push one delta event (the imperative path: a method mutates the backend, then calls this). */
+	emit(change: C): void;
+	/**
+	 * D54 widening: fold an in-graph producer `src` into the backend. `apply` mutates the backend +
+	 * `emit`s the change(s). The folder is a DECLARED-dep node (describe shows `src → folder`, NOT a
+	 * D45 island); its emit is the structure's plumbing (D54-sanctioned). Returns a disposer.
+	 */
+	bindSource<V>(src: Node<V>, apply: (value: V) => void): () => void;
+}
+
+/**
+ * Public D121 collection-view surface. A view is a derived surface: `delta` is the pushed update
+ * port, `snapshot` is a lazy pull node, and neither port is writable authority.
+ */
+export interface ReactiveView<C, S> {
+	/** Derived DELTA/update stream for the view. For light views this is recomputed from the parent backend. */
+	readonly delta: Node<C>;
+	/** Derived SNAPSHOT pull node: demand via `pullId` to materialize the current view. */
+	readonly snapshot: Node<S>;
+	/** The snapshot node's pullId (R-pull/D269), minted per view instance. */
+	readonly pullId: symbol;
+	/** Release memoized/light-view resources owned by the parent collection. */
+	dispose(): void;
+}
+
+interface LightReactiveViewOptions<S> extends CollectionCoreOptions {
+	readonly factory: string;
+	readonly materializeSnapshot: () => S;
+	readonly onDispose?: () => void;
+}
+
+interface CollectionRestoreSpec {
+	readonly deltaRef: string;
+	readonly snapshotRef: string;
+	readonly config?: GraphCheckpointJson;
+	readonly backendState: () => unknown;
+}
+
+function validateViewCacheMaxEntries(policy: ViewCachePolicy | undefined): number | undefined {
+	const maxEntries = policy?.maxEntries;
+	if (maxEntries === undefined) return undefined;
+	if (!Number.isInteger(maxEntries) || maxEntries < 0) {
+		throw new RangeError(`viewCache.maxEntries must be a non-negative integer (got ${maxEntries})`);
+	}
+	return maxEntries;
+}
+
+/**
+ * Internal D80 memo manager for derived views. Eviction drops only the structure's memo lookup;
+ * returned ReactiveView handles remain live until explicitly disposed or their parent releases all
+ * live views.
+ */
+export class ViewMemoCache<K, V extends { dispose(): void }> {
+	private readonly maxEntries: number | undefined;
+	private readonly equals: (a: K, b: K) => boolean;
+	private readonly memo: Array<{ key: K; value: V }> = [];
+	private readonly live = new Set<V>();
+
+	constructor(policy: ViewCachePolicy | undefined, equals: (a: K, b: K) => boolean = Object.is) {
+		this.maxEntries = validateViewCacheMaxEntries(policy);
+		this.equals = equals;
+	}
+
+	get(key: K): V | undefined {
+		const index = this.memo.findIndex((entry) => this.equals(entry.key, key));
+		if (index < 0) return undefined;
+		const [entry] = this.memo.splice(index, 1);
+		if (entry === undefined) return undefined;
+		this.memo.push(entry);
+		return entry.value;
+	}
+
+	set(key: K, value: V): void {
+		this.deleteValue(value);
+		this.live.add(value);
+		if (this.maxEntries === 0) return;
+		this.memo.push({ key, value });
+		while (this.maxEntries !== undefined && this.memo.length > this.maxEntries) {
+			this.memo.shift();
+		}
+	}
+
+	deleteValue(value: V): void {
+		for (let i = this.memo.length - 1; i >= 0; i -= 1) {
+			if (this.memo[i]?.value === value) this.memo.splice(i, 1);
+		}
+		this.live.delete(value);
+	}
+
+	disposeAll(): void {
+		for (const view of [...this.live]) view.dispose();
+		this.memo.length = 0;
+		this.live.clear();
+	}
+}
+
+/**
+ * Build a D121 first-cut light view. The view declares `parent.delta -> view.delta ->
+ * view.snapshot`; the pushed `delta` forwards parent delta events as the view's arm/update stream,
+ * while `snapshot` reads the parent collection backend through the supplied materializer on demand.
+ * No writable state/cache is exposed (D120).
+ */
+export function lightReactiveView<C, S>(
+	parentDelta: Node<unknown>,
+	opts: LightReactiveViewOptions<S>,
+): ReactiveView<C, S> {
+	const { dispatcher, factory, graph, materializeSnapshot, name, onDispose } = opts;
+	const base = dispatcher ? { dispatcher } : {};
+	const group = graph?.topologyGroup({ name: name ?? factory });
+	const deltaBody = (ctx: Ctx): void => {
+		for (const change of (depBatch(ctx, 0) ?? []) as readonly C[]) {
+			ctx.down([["DATA", change]]);
+		}
+	};
+	const delta = group
+		? group.node<C>([parentDelta], deltaBody, {
+				factory: `${factory}.delta`,
+				name: name ? `${name}.delta` : undefined,
+				meta: { kind: "collection_view_delta", factory },
+				partial: true,
+			})
+		: new Node<C>([parentDelta], deltaBody, {
+				...base,
+				factory: `${factory}.delta`,
+				name: name ? `${name}.delta` : undefined,
+				partial: true,
+			});
+
+	const pullId = Symbol(name ? `${name}.snapshot` : `${factory}.snapshot`);
+	const snapshotBody = (ctx: Ctx): void => {
+		try {
+			ctx.down([["DATA", materializeSnapshot()]]);
+		} catch (e) {
+			ctx.down([["ERROR", errorPayload(e, `${factory}.snapshot materializer failed`)]]);
+		}
+	};
+	const snapshot = group
+		? group.node<S>([delta as Node<unknown>], snapshotBody, {
+				factory: `${factory}.snapshot`,
+				name: name ? `${name}.snapshot` : undefined,
+				meta: { kind: "collection_view_snapshot", factory },
+				partial: true,
+				pullId,
+			})
+		: new Node<S>([delta as Node<unknown>], snapshotBody, {
+				...base,
+				factory: `${factory}.snapshot`,
+				name: name ? `${name}.snapshot` : undefined,
+				partial: true,
+				pullId,
+			});
+
+	let disposed = false;
+	return {
+		delta,
+		snapshot,
+		pullId,
+		dispose(): void {
+			if (disposed) return;
+			if (group) {
+				group.release({ reason: factory });
+			} else {
+				releaseRuntimeOfNode(delta as Node<unknown>);
+				releaseRuntimeOfNode(snapshot as Node<unknown>);
+			}
+			disposed = true;
+			onDispose?.();
+		},
+	};
+}
+
+/**
+ * Build the shared core for a reactive structure (D60). `factory` names the nodes for describe
+ * (D6/D51 auto-discovery). The structure passes its `backend` (any {@link CollectionBackend}) and
+ * layers a typed method surface on top.
+ */
+export function collectionCore<S, C>(
+	backend: CollectionBackend<S>,
+	factory: string,
+	opts: CollectionCoreOptions = {},
+	restore?: CollectionRestoreSpec,
+): CollectionCore<S, C> {
+	const { name, dispatcher, graph } = opts;
+	const base: { dispatcher?: Dispatcher } = dispatcher ? { dispatcher } : {};
+	let bindSeq = 0;
+
+	// DELTA backbone: a bare source (D60 #2a / review #2 — node([], null), no `initial`, so a late
+	// subscriber gets no fake "initial change"; state is the snapshot port's job).
+	const delta = graph
+		? graph.node<C>([], null, {
+				factory: `${factory}.delta`,
+				name: name ? `${name}.delta` : undefined,
+				meta: { kind: "collection_delta", collection: factory },
+				...(restore ? { restore: { ref: restore.deltaRef, config: restore.config } } : {}),
+			})
+		: new Node<C>([], null, {
+				...base,
+				factory: `${factory}.delta`,
+				name: name ? `${name}.delta` : undefined,
+			});
+
+	// SNAPSHOT pull node: dep=[delta] (the backbone arms it via quiet-absorb so coalesce is free,
+	// D60). The fn IGNORES the delta value — it reads `backend.snapshot()` on demand (D60 #3). The
+	// pullId is a unique Symbol (R-pull/D269: matched by identity, zero collision with pause locks).
+	// `partial:true`: the fn does not need the delta's value, so it must not gate on "all deps
+	// settled" — it fires whenever armed (a mutation since the last delivery).
+	const pullId = Symbol(name ? `${name}.snapshot` : `${factory}.snapshot`);
+	let deliveredVersion = backend.version;
+	const snapFn = (ctx: Ctx): void => {
+		if (ctx.pull !== undefined && backend.version === deliveredVersion) return;
+		deliveredVersion = backend.version;
+		ctx.down([["DATA", backend.snapshot()]]);
+	};
+	const snapshot = graph
+		? graph.node<S>([delta as Node<unknown>], snapFn, {
+				pullId,
+				partial: true,
+				factory: `${factory}.snapshot`,
+				name: name ? `${name}.snapshot` : undefined,
+				meta: { kind: "collection_snapshot", collection: factory },
+				...(restore ? { restore: { ref: restore.snapshotRef, config: restore.config } } : {}),
+			})
+		: new Node<S>([delta as Node<unknown>], snapFn, {
+				...base,
+				pullId,
+				partial: true,
+				factory: `${factory}.snapshot`,
+				name: name ? `${name}.snapshot` : undefined,
+			});
+
+	if (restore !== undefined) {
+		registerBackendStateContributor(delta as Node<unknown>, restore.backendState);
+	}
+
+	function emit(change: C): void {
+		// External tier-3 emit → the substrate synthesizes the leading DIRTY (R-dirty-before-data),
+		// which the quiet snapshot node absorbs (R-pull) and uses to arm its next demand delivery.
+		delta.down([["DATA", change]]);
+	}
+
+	function bindSource<V>(src: Node<V>, apply: (value: V) => void): () => void {
+		if (graph === undefined)
+			throw new Error(
+				"collectionCore.bindSource requires options.graph so the input fold is describe-visible (D61)",
+			);
+		// A graph-bound declared-dep folder (effect-shaped): reads each src batch value, applies it
+		// to the backend (apply mutates + emits the delta). src → folder is a real edge describe
+		// shows (D54/D61), not an internal subscribe island.
+		const op: Operator<V, void> = {
+			factory: `${factory}.bindSource`,
+			body: (ctx: Ctx) => {
+				const b = depBatch(ctx, 0);
+				try {
+					if (b) for (const v of b) apply(v as V);
+				} catch (e) {
+					ctx.down([["ERROR", errorPayload(e, "collectionCore.bindSource failed")]]);
+				}
+			},
+		};
+		const folder = graph.initNode(op, [src], {
+			name: name ? `${name}.bind#${bindSeq++}` : undefined,
+			meta: { kind: "collection_bind_source", collection: factory },
+		});
+		return graph.retain(folder, { reason: `${factory}.bindSource` });
+	}
+
+	return { delta, snapshot, pullId, emit, bindSource };
+}
diff --git a/packages/ts/src/graph/data-structures/reactive-index.ts b/packages/ts/src/graph/data-structures/reactive-index.ts
new file mode 100644
index 00000000..b2048074
--- /dev/null
+++ b/packages/ts/src/graph/data-structures/reactive-index.ts
@@ -0,0 +1,596 @@
+/**
+ * Reactive dual-key index (CSP-2.8, D54/D60) — unique primary key, rows sorted by (secondary, primary).
+ *
+ * Shape = the shared {@link collectionCore} two ports over a sorted-array + parallel-Map BACKEND
+ * (D60). The SNAPSHOT port delivers the ordered `IndexRow[]`. Secondary/reverse lookup = "Z"
+ * (review #4): `has`/`get`/`rangeByPrimary` are SYNCHRONOUS point-reads over the backend's parallel
+ * Map (NOT topology, like `.cache`); `byPrimary` is an OPTIONAL reactive derived over the delta
+ * backbone (a pushed primary→value map), LAZILY created on first access (no default keepalive,
+ * R-rom-ram). The two coexist: the derived is the reactive reverse-lookup port; the sync reads are
+ * the point query.
+ *
+ * Per-language (D6/D24, never in parity, no conformance — the substrate pull is already C-16).
+ */
+
+import { type Ctx, depBatch, depCount, depLatest } from "../../ctx/types.js";
+import { Node, node } from "../../node/node.js";
+import { errorPayload } from "../../protocol/messages.js";
+import type { Operator } from "../operators.js";
+import type { OrderedCapacityPolicy, ReactiveOpt, ViewCachePolicy } from "../policies/types.js";
+import type { IndexChange } from "./change.js";
+import {
+	type CollectionCore,
+	type CollectionCoreOptions,
+	collectionCore,
+	lightReactiveView,
+	type ReactiveView,
+	ViewMemoCache,
+} from "./core.js";
+
+export type ReactiveIndexOpt<T> = ReactiveOpt<T>;
+export type ReactiveIndexCapacityOrder = "secondary" | "primary" | "lru";
+
+export interface ReactiveIndexCapacityPolicy
+	extends OrderedCapacityPolicy<ReactiveIndexCapacityOrder> {}
+
+export interface ReactiveIndexOptions extends CollectionCoreOptions {
+	/**
+	 * D73 explicit capacity policy: no implicit eviction default.
+	 * `order` chooses eviction semantics and `maxSize` may be static or node-valued (D68).
+	 */
+	readonly capacity?: ReactiveIndexCapacityPolicy;
+	/** Static D80 memo policy for D121 light views. Eviction does not dispose returned views. */
+	readonly viewCache?: ViewCachePolicy;
+}
+
+export interface IndexRow<K, V = unknown> {
+	readonly primary: K;
+	readonly secondary: unknown;
+	readonly value: V;
+}
+
+export interface ReactiveIndex<K, V = unknown> {
+	readonly delta: Node<IndexChange<K, V>>;
+	/** SNAPSHOT pull node: demand → rows sorted by (secondary, primary) (lazy O(n)). */
+	readonly snapshot: Node<readonly IndexRow<K, V>[]>;
+	readonly pullId: symbol;
+	/** Row count (O(1)). Sync non-reactive read. */
+	readonly size: number;
+	/** O(1) primary-key existence. Sync read (Z). */
+	has(primary: K): boolean;
+	/** O(1) value lookup by primary key. Sync read (Z). */
+	get(primary: K): V | undefined;
+	/** Values whose primary sorts within `[start, end)`, ascending primary order. Sync read (Z). */
+	rangeByPrimary(start: K, end: K): V[];
+	/**
+	 * D121 light range view over the primary axis. `delta` forwards parent index mutations, and
+	 * `snapshot` is a pull node that materializes the current range on demand.
+	 */
+	range(start: K, end: K): ReactiveView<IndexChange<K, V>, readonly V[]>;
+	/** Ordered rows (fresh copy). Sync non-reactive read (cold-start peek). */
+	toArray(): readonly IndexRow<K, V>[];
+	/** Primary→value map (fresh copy). Sync non-reactive read. */
+	toPrimaryMap(): ReadonlyMap<K, V>;
+	/**
+	 * OPTIONAL reactive reverse-lookup port (Z): a derived primary→value map, pushed on every
+	 * mutation. Lazily created on first access (no keepalive — live only while subscribed). Use the
+	 * synchronous {@link ReactiveIndex.get} for a one-shot point query.
+	 */
+	readonly byPrimary: Node<ReadonlyMap<K, V>>;
+	/** Insert/replace a row. Returns `true` if a NEW row was inserted (primary was absent). */
+	upsert(primary: K, secondary: unknown, value: V): boolean;
+	/** Bulk upsert; one delta per row. No-op if empty. */
+	upsertMany(rows: Iterable<{ primary: K; secondary: unknown; value: V }>): void;
+	delete(primary: K): void;
+	/** Bulk delete; one delta event. No-op if nothing removed. */
+	deleteMany(primaries: Iterable<K>): void;
+	clear(): void;
+	/** D54 widening: every row from `src` is upserted. Returns a disposer. */
+	upsertFrom(src: Node<{ primary: K; secondary: unknown; value: V }>): () => void;
+	dispose(): void;
+}
+
+// ── ordering helpers (pure; backend-internal) ──
+function cmpOrd(a: unknown, b: unknown): number {
+	if (a === b) return 0;
+	const ta = typeof a;
+	if (
+		ta === typeof b &&
+		(ta === "number" || ta === "string" || ta === "boolean" || ta === "bigint")
+	) {
+		const ax = a as number | string;
+		const bx = b as number | string;
+		return ax < bx ? -1 : ax > bx ? 1 : 0;
+	}
+	return String(a).localeCompare(String(b));
+}
+function compareRows<K, V>(a: IndexRow<K, V>, b: IndexRow<K, V>): number {
+	const c = cmpOrd(a.secondary, b.secondary);
+	return c !== 0 ? c : cmpOrd(a.primary, b.primary);
+}
+function bisectLeft<K, V>(rows: readonly IndexRow<K, V>[], row: IndexRow<K, V>): number {
+	let lo = 0;
+	let hi = rows.length;
+	while (lo < hi) {
+		const mid = (lo + hi) >> 1;
+		if (compareRows(rows[mid] as IndexRow<K, V>, row) < 0) lo = mid + 1;
+		else hi = mid;
+	}
+	return lo;
+}
+
+/** Default sorted-array + parallel-Map backend (D60 first-cut; B-tree/persistent backend deferred). */
+class IndexBackend<K, V> {
+	private _version = 0;
+	private readonly buf: IndexRow<K, V>[] = [];
+	private readonly byKey = new Map<K, IndexRow<K, V>>();
+	private readonly trackLru: boolean;
+
+	constructor(trackLru: boolean, initialRows: readonly IndexRow<K, V>[] = []) {
+		this.trackLru = trackLru;
+		for (const row of initialRows) {
+			this.upsert(row.primary, row.secondary, row.value);
+		}
+		this._version = 0;
+	}
+
+	get version(): number {
+		return this._version;
+	}
+	get size(): number {
+		return this.buf.length;
+	}
+	has(primary: K): boolean {
+		const row = this.byKey.get(primary);
+		if (row === undefined) return false;
+		this.touchLru(row);
+		return true;
+	}
+	get(primary: K): V | undefined {
+		const row = this.byKey.get(primary);
+		if (row === undefined) return undefined;
+		this.touchLru(row);
+		return row.value;
+	}
+
+	private touchLru(row: IndexRow<K, V>): void {
+		if (!this.trackLru) return;
+		this.byKey.delete(row.primary);
+		this.byKey.set(row.primary, row);
+	}
+
+	private removeRow(row: IndexRow<K, V>): void {
+		const start = bisectLeft(this.buf, row);
+		for (
+			let i = start;
+			i < this.buf.length && compareRows(this.buf[i] as IndexRow<K, V>, row) === 0;
+			i++
+		) {
+			if (this.buf[i] === row) {
+				this.buf.splice(i, 1);
+				return;
+			}
+		}
+		const fallback = this.buf.indexOf(row);
+		if (fallback >= 0) {
+			this.buf.splice(fallback, 1);
+			return;
+		}
+		throw new Error("reactiveIndex: internal row index desynchronized");
+	}
+
+	upsert(primary: K, secondary: unknown, value: V): boolean {
+		const existing = this.byKey.get(primary);
+		const row: IndexRow<K, V> = { primary, secondary, value };
+		if (existing !== undefined) {
+			this.removeRow(existing);
+			this.byKey.delete(primary);
+		}
+		this.buf.splice(bisectLeft(this.buf, row), 0, row);
+		this.byKey.set(primary, row);
+		this._version += 1;
+		return existing === undefined;
+	}
+
+	delete(primary: K): boolean {
+		const existing = this.byKey.get(primary);
+		if (existing === undefined) return false;
+		this.removeRow(existing);
+		this.byKey.delete(primary);
+		this._version += 1;
+		return true;
+	}
+
+	clear(): number {
+		const n = this.buf.length;
+		if (n === 0) return 0;
+		this.buf.length = 0;
+		this.byKey.clear();
+		this._version += 1;
+		return n;
+	}
+
+	rangeByPrimary(start: K, end: K): V[] {
+		if (cmpOrd(start, end) >= 0) return [];
+		const rows = [...this.byKey.entries()].filter(
+			([p]) => cmpOrd(p, start) >= 0 && cmpOrd(p, end) < 0,
+		);
+		rows.sort(([a], [b]) => cmpOrd(a, b));
+		return rows.map(([, r]) => r.value);
+	}
+
+	evictOneForCapacity(order: ReactiveIndexCapacityOrder, maxSize?: number): K | undefined {
+		if (maxSize === undefined) return undefined;
+		if (!Number.isInteger(maxSize) || maxSize < 1)
+			throw new RangeError(`reactiveIndex: maxSize must be a positive integer (got ${maxSize})`);
+		const overflow = this.buf.length - maxSize;
+		if (overflow <= 0) return undefined;
+
+		switch (order) {
+			case "secondary": {
+				const row = this.buf[0] as IndexRow<K, V> | undefined;
+				if (row === undefined) return undefined;
+				this.buf.shift();
+				this.byKey.delete(row.primary);
+				this._version += 1;
+				return row.primary;
+			}
+			case "primary": {
+				let victim: K | undefined;
+				for (const key of this.byKey.keys()) {
+					if (victim === undefined || cmpOrd(key, victim) < 0) victim = key;
+				}
+				if (victim === undefined) return undefined;
+				const row = this.byKey.get(victim);
+				if (row !== undefined) this.removeRow(row);
+				this.byKey.delete(victim);
+				this._version += 1;
+				return victim;
+			}
+			case "lru": {
+				const oldest = this.byKey.keys().next().value as K | undefined;
+				if (oldest === undefined) return undefined;
+				const row = this.byKey.get(oldest);
+				if (row !== undefined) this.removeRow(row);
+				this.byKey.delete(oldest);
+				this._version += 1;
+				return oldest;
+			}
+			default: {
+				throw new Error(`reactiveIndex: unknown capacity order '${String(order)}'`);
+			}
+		}
+	}
+
+	snapshot(): readonly IndexRow<K, V>[] {
+		return [...this.buf];
+	}
+	toPrimaryMap(): ReadonlyMap<K, V> {
+		const m = new Map<K, V>();
+		for (const r of this.buf) m.set(r.primary, r.value);
+		return m;
+	}
+}
+
+function assertCheckpointableIndexRows(rows: readonly IndexRow<unknown, unknown>[]): void {
+	for (const [i, row] of rows.entries()) {
+		const primary = row.primary;
+		if (
+			primary === null ||
+			typeof primary === "string" ||
+			typeof primary === "number" ||
+			typeof primary === "boolean"
+		) {
+			continue;
+		}
+		throw new TypeError(
+			`reactiveIndex checkpoint backendState[${i}].primary must be a JSON primitive primary key for D160 restore`,
+		);
+	}
+}
+
+/**
+ * Create a reactive dual-key index (D54/D60). DELTA + lazy pull SNAPSHOT + pullId via
+ * {@link collectionCore}; this layer adds the sorted backend + Z reverse-lookup surface.
+ */
+export function reactiveIndex<K, V = unknown>(
+	options: ReactiveIndexOptions = {},
+): ReactiveIndex<K, V> {
+	return createReactiveIndex(options);
+}
+
+/** @internal D160 restore path: seed the backend without replaying public deltas. */
+export function restoreReactiveIndexFromBackendState<K, V = unknown>(
+	initialRows: readonly IndexRow<K, V>[],
+	options: ReactiveIndexOptions = {},
+): ReactiveIndex<K, V> {
+	return createReactiveIndex(options, initialRows);
+}
+
+function createReactiveIndex<K, V = unknown>(
+	options: ReactiveIndexOptions = {},
+	initialRows: readonly IndexRow<K, V>[] = [],
+): ReactiveIndex<K, V> {
+	const { capacity, graph, dispatcher, name } = options;
+	const lruEnabled = capacity?.order === "lru";
+	const backend = new IndexBackend<K, V>(lruEnabled, initialRows);
+	const core: CollectionCore<readonly IndexRow<K, V>[], IndexChange<K, V>> = collectionCore(
+		backend,
+		"reactiveIndex",
+		options,
+		graph !== undefined && name !== undefined && capacity === undefined
+			? {
+					deltaRef: "reactiveIndex.delta",
+					snapshotRef: "reactiveIndex.snapshot",
+					backendState: () => {
+						const rows = backend.snapshot();
+						assertCheckpointableIndexRows(rows);
+						return rows;
+					},
+				}
+			: undefined,
+	);
+	const binds: Array<() => void> = [];
+	const base = dispatcher ? { dispatcher } : {};
+	const bindDeps = new WeakSet<Node<unknown>>();
+	const rangeMemo = new ViewMemoCache<
+		readonly [K, K],
+		ReactiveView<IndexChange<K, V>, readonly V[]>
+	>(options.viewCache, ([aStart, aEnd], [bStart, bEnd]) => {
+		return cmpOrd(aStart, bStart) === 0 && cmpOrd(aEnd, bEnd) === 0;
+	});
+	let bindSeq = 0;
+	let rangeSeq = 0;
+	let capacityPolicy: Node<number> | undefined;
+	let apply: Node<IndexChange<K, V>> | undefined;
+	let releaseApply = () => {};
+
+	function isNodeOpt<T>(x: ReactiveIndexOpt<T>): x is Node<T> {
+		return x instanceof Node;
+	}
+
+	function validateMaxSize(v: number): number {
+		if (!Number.isFinite(v) || !Number.isInteger(v) || v < 1)
+			throw new RangeError(`reactiveIndex: maxSize must be a positive integer (got ${v})`);
+		return v;
+	}
+
+	function enforceCapacity(): void {
+		if (currentCapacityOrder === undefined) return;
+		for (;;) {
+			const primary = backend.evictOneForCapacity(currentCapacityOrder, currentMaxSize);
+			if (primary === undefined) return;
+			core.emit({ kind: "delete", primary });
+		}
+	}
+
+	const applyBody = (ctx: Ctx): void => {
+		const deps = apply?.deps ?? [];
+		for (let i = 0; i < depCount(ctx); i++) {
+			const dep = deps[i];
+			if (dep === capacityPolicy) {
+				const latest = depLatest(ctx, i);
+				if (latest !== undefined) currentMaxSize = validateMaxSize(latest as number);
+				continue;
+			}
+			if (dep && bindDeps.has(dep)) {
+				for (const r of (depBatch(ctx, i) ?? []) as readonly {
+					primary: K;
+					secondary: unknown;
+					value: V;
+				}[]) {
+					backend.upsert(r.primary, r.secondary, r.value);
+					core.emit({ kind: "upsert", primary: r.primary, secondary: r.secondary, value: r.value });
+					enforceCapacity();
+				}
+			}
+		}
+		enforceCapacity();
+	};
+
+	function ensureApply(): Node<IndexChange<K, V>> {
+		if (apply !== undefined) return apply;
+		const op: Operator<unknown, IndexChange<K, V>> = {
+			factory: "reactiveIndex.capacityPolicy",
+			body: applyBody,
+			opts: { partial: true },
+		};
+		const deps = capacityPolicy ? [capacityPolicy as Node<unknown>] : [];
+		apply = graph
+			? graph.initNode(op, deps, {
+					name: name ? `${name}.capacityPolicy` : undefined,
+					meta: { kind: "collection_policy_apply", collection: "reactiveIndex" },
+				})
+			: new Node<IndexChange<K, V>>(deps, op.body, {
+					...base,
+					factory: "reactiveIndex.capacityPolicy",
+					partial: true,
+					name: name ? `${name}.capacityPolicy` : undefined,
+				});
+		releaseApply = graph
+			? graph.retain(apply, { reason: "reactiveIndex.capacityPolicy" })
+			: apply.subscribe(() => {});
+		return apply;
+	}
+
+	let currentMaxSize: number | undefined;
+	const currentCapacityOrder: ReactiveIndexCapacityOrder | undefined = capacity?.order;
+	if (capacity !== undefined) {
+		if (
+			currentCapacityOrder !== "secondary" &&
+			currentCapacityOrder !== "primary" &&
+			currentCapacityOrder !== "lru"
+		) {
+			throw new Error("reactiveIndex: capacity.order must be one of secondary|primary|lru (D73)");
+		}
+
+		const maxSize = capacity.maxSize;
+		if (isNodeOpt(maxSize) && graph === undefined) {
+			throw new Error(
+				"reactiveIndex capacity.maxSize Node option requires options.graph so the policy edge is describe-visible (D73)",
+			);
+		}
+
+		capacityPolicy = isNodeOpt(maxSize)
+			? maxSize
+			: graph
+				? graph.initNode<number, number>(
+						{
+							factory: "reactiveIndex.maxSizePolicy",
+							body: () => {},
+							opts: { initial: validateMaxSize(maxSize) },
+						},
+						[],
+						{
+							name: name ? `${name}.maxSizePolicy` : undefined,
+							meta: { kind: "collection_policy", collection: "reactiveIndex", policy: "maxSize" },
+						},
+					)
+				: undefined;
+
+		if (!isNodeOpt(maxSize)) currentMaxSize = validateMaxSize(maxSize);
+
+		if (capacityPolicy instanceof Node) ensureApply();
+	}
+
+	// Lazy reactive reverse-lookup port (Z): a delta-driven pushed primary→value map. Created on
+	// first access so an index that never uses it pays nothing (no keepalive — R-rom-ram).
+	let byPrimaryNode: Node<ReadonlyMap<K, V>> | undefined;
+	function getByPrimary(): Node<ReadonlyMap<K, V>> {
+		if (byPrimaryNode === undefined) {
+			byPrimaryNode = node<ReadonlyMap<K, V>>(
+				[core.delta as Node<unknown>],
+				(ctx: Ctx) => {
+					// pushed reverse-lookup: re-read the backend's primary map on each delta (the
+					// structure's own backend, D60 #1 — not a foreign .cache peek).
+					ctx.down([["DATA", backend.toPrimaryMap()]]);
+				},
+				{ factory: "reactiveIndex.byPrimary", partial: true },
+			);
+		}
+		return byPrimaryNode;
+	}
+
+	function getRange(start: K, end: K): ReactiveView<IndexChange<K, V>, readonly V[]> {
+		const key = [start, end] as const;
+		const hit = rangeMemo.get(key);
+		if (hit !== undefined) return hit;
+		const materialize = (): readonly V[] => backend.rangeByPrimary(start, end);
+		let view: ReactiveView<IndexChange<K, V>, readonly V[]>;
+		view = lightReactiveView<IndexChange<K, V>, readonly V[]>(core.delta as Node<unknown>, {
+			...options,
+			factory: "reactiveIndex.range",
+			name: name ? `${name}.range#${rangeSeq++}` : undefined,
+			materializeSnapshot: materialize,
+			onDispose: () => {
+				rangeMemo.deleteValue(view);
+			},
+		});
+		rangeMemo.set(key, view);
+		return view;
+	}
+
+	return {
+		delta: core.delta,
+		snapshot: core.snapshot,
+		pullId: core.pullId,
+
+		get size(): number {
+			return backend.size;
+		},
+		has(primary: K): boolean {
+			return backend.has(primary);
+		},
+		get(primary: K): V | undefined {
+			return backend.get(primary);
+		},
+		rangeByPrimary(start: K, end: K): V[] {
+			return backend.rangeByPrimary(start, end);
+		},
+		range(start: K, end: K): ReactiveView<IndexChange<K, V>, readonly V[]> {
+			return getRange(start, end);
+		},
+		toArray(): readonly IndexRow<K, V>[] {
+			return backend.snapshot();
+		},
+		toPrimaryMap(): ReadonlyMap<K, V> {
+			return backend.toPrimaryMap();
+		},
+		get byPrimary(): Node<ReadonlyMap<K, V>> {
+			return getByPrimary();
+		},
+
+		upsert(primary: K, secondary: unknown, value: V): boolean {
+			const inserted = backend.upsert(primary, secondary, value);
+			core.emit({ kind: "upsert", primary, secondary, value });
+			enforceCapacity();
+			return inserted;
+		},
+		upsertMany(rows: Iterable<{ primary: K; secondary: unknown; value: V }>): void {
+			for (const r of rows) {
+				backend.upsert(r.primary, r.secondary, r.value);
+				core.emit({ kind: "upsert", primary: r.primary, secondary: r.secondary, value: r.value });
+				enforceCapacity();
+			}
+		},
+		delete(primary: K): void {
+			if (backend.delete(primary)) core.emit({ kind: "delete", primary });
+		},
+		deleteMany(primaries: Iterable<K>): void {
+			const removed: K[] = [];
+			for (const p of primaries) if (backend.delete(p)) removed.push(p);
+			if (removed.length > 0) core.emit({ kind: "deleteMany", primaries: removed });
+		},
+		clear(): void {
+			const count = backend.clear();
+			if (count > 0) core.emit({ kind: "clear", count });
+		},
+
+		upsertFrom(src: Node<{ primary: K; secondary: unknown; value: V }>): () => void {
+			if (graph === undefined)
+				throw new Error(
+					"reactiveIndex.upsertFrom requires options.graph so the input fold is describe-visible (D61)",
+				);
+			const op: Operator<
+				{ primary: K; secondary: unknown; value: V },
+				{ primary: K; secondary: unknown; value: V }
+			> = {
+				factory: "reactiveIndex.bindSource",
+				body: (ctx: Ctx) => {
+					try {
+						for (const r of (depBatch(ctx, 0) ?? []) as readonly {
+							primary: K;
+							secondary: unknown;
+							value: V;
+						}[]) {
+							ctx.down([["DATA", r]]);
+						}
+					} catch (e) {
+						ctx.down([["ERROR", errorPayload(e, "reactiveIndex.bindSource failed")]]);
+					}
+				},
+			};
+			const folder = graph.initNode(op, [src], {
+				name: name ? `${name}.bind#${bindSeq++}` : undefined,
+				meta: { kind: "collection_bind_source", collection: "reactiveIndex" },
+			});
+			bindDeps.add(folder as Node<unknown>);
+			const applyNode = ensureApply();
+			applyNode.subscribeDep(folder as Node<unknown>, applyBody);
+			let active = true;
+			const dispose = () => {
+				if (!active) return;
+				active = false;
+				applyNode.unsubscribeDep(folder as Node<unknown>, applyBody);
+			};
+			binds.push(dispose);
+			return dispose;
+		},
+		dispose(): void {
+			for (const d of binds) d();
+			binds.length = 0;
+			releaseApply();
+			rangeMemo.disposeAll();
+		},
+	};
+}
diff --git a/packages/ts/src/graph/data-structures/reactive-list.ts b/packages/ts/src/graph/data-structures/reactive-list.ts
new file mode 100644
index 00000000..b38c97a9
--- /dev/null
+++ b/packages/ts/src/graph/data-structures/reactive-list.ts
@@ -0,0 +1,379 @@
+/**
+ * Reactive positional list (CSP-2.8, D54/D60) — the two-port collection template.
+ *
+ * Shape (D60 + review #2): a mutable array BACKEND (the single materialized state) + the shared
+ * {@link collectionCore} two ports — a DELTA stream ({@link ReactiveList.delta}, one event per
+ * mutation, O(1)) and a lazy pull SNAPSHOT ({@link ReactiveList.snapshot}, materialized only on a
+ * cone-routed PULL demand). Mutation input is D54 A3 hybrid: ergonomic imperative methods (the
+ * external boundary, state-verb-legitimate, D4) + `appendFrom(src)` widening (an in-graph producer
+ * drives the list with zero imperative glue). Synchronous quick-reads (`at`/`size`/`toArray`) are
+ * the deliberately-non-reactive peek for cold/imperative reads (D60).
+ *
+ * Per-language (D6/D24, never in parity, no conformance — the substrate pull is already C-16).
+ */
+
+import { type Ctx, depBatch, depCount, depLatest } from "../../ctx/types.js";
+import { Node } from "../../node/node.js";
+import { errorPayload } from "../../protocol/messages.js";
+import type { Operator } from "../operators.js";
+import { trimHeadOverflow } from "../policies/collection.js";
+import type { ReactiveOpt } from "../policies/types.js";
+import type { ListChange } from "./change.js";
+import { type CollectionCore, type CollectionCoreOptions, collectionCore } from "./core.js";
+
+export type ReactiveListOpt<T> = ReactiveOpt<T>;
+
+export interface ReactiveListOptions extends CollectionCoreOptions {
+	/**
+	 * Head-trim capacity policy (D72). A static number caps the list locally; a Node-valued maxSize
+	 * must be graph-bound and becomes a declared policy dep that trims on policy changes.
+	 */
+	maxSize?: ReactiveListOpt<number>;
+}
+
+export interface ReactiveList<T> {
+	/** DELTA stream: one {@link ListChange} per mutation (O(1)). Subscribe to observe events. */
+	readonly delta: Node<ListChange<T>>;
+	/** SNAPSHOT pull node: demand via `ctx.upNext([["PULL", { pullId }]])` → one `readonly T[]` (lazy O(n)). */
+	readonly snapshot: Node<readonly T[]>;
+	/** The snapshot node's pullId — write it verbatim into the demander's fn (D269). */
+	readonly pullId: symbol;
+	/** Current entry count (O(1), synchronous non-reactive read). */
+	readonly size: number;
+	/** Positional access (O(1)); negative indices Python-style; `undefined` out of range. Sync read. */
+	at(index: number): T | undefined;
+	/** Full current contents (O(n), fresh defensive copy). Sync non-reactive read (cold-start peek). */
+	toArray(): readonly T[];
+	append(value: T): void;
+	/** Append all values; one delta event + one snapshot-arm. No-op if `values` is empty. */
+	appendMany(values: readonly T[]): void;
+	/** Insert at `index` (0..size). Throws `RangeError` out of range. */
+	insert(index: number, value: T): void;
+	/** Insert all at `index` as one op. No-op if `values` is empty. Throws out of range. */
+	insertMany(index: number, values: readonly T[]): void;
+	/** Remove and return the value at `index` (default last; negative Python-style). Throws if empty/out of range. */
+	pop(index?: number): T;
+	clear(): void;
+	/** D54 widening: every value from `src` is appended. Returns a disposer. */
+	appendFrom(src: Node<T>): () => void;
+	/** Release the widening subscriptions (idempotent). */
+	dispose(): void;
+}
+
+/** Default mutable-array backend (D60 first-cut; pluggable persistent/immutable backend deferred). */
+class ListBackend<T> {
+	private _version = 0;
+	private readonly buf: T[];
+
+	constructor(initial?: readonly T[], maxSize?: number) {
+		this.buf = initial ? [...initial] : [];
+		trimHeadOverflow(this.buf, { maxSize });
+	}
+
+	get version(): number {
+		return this._version;
+	}
+
+	get size(): number {
+		return this.buf.length;
+	}
+
+	at(index: number): T | undefined {
+		if (!Number.isInteger(index)) return undefined;
+		const i = index >= 0 ? index : this.buf.length + index;
+		return i < 0 || i >= this.buf.length ? undefined : this.buf[i];
+	}
+
+	snapshot(): readonly T[] {
+		return [...this.buf];
+	}
+
+	append(value: T): void {
+		this.buf.push(value);
+		this._version += 1;
+	}
+
+	appendMany(values: readonly T[]): void {
+		if (values.length === 0) return;
+		for (const v of values) this.buf.push(v);
+		this._version += 1;
+	}
+
+	insert(index: number, value: T): void {
+		if (!Number.isInteger(index) || index < 0 || index > this.buf.length)
+			throw new RangeError(`insert: index ${index} out of range [0, ${this.buf.length}]`);
+		this.buf.splice(index, 0, value);
+		this._version += 1;
+	}
+
+	insertMany(index: number, values: readonly T[]): void {
+		if (!Number.isInteger(index) || index < 0 || index > this.buf.length)
+			throw new RangeError(`insertMany: index ${index} out of range [0, ${this.buf.length}]`);
+		if (values.length === 0) return;
+		this.buf.splice(index, 0, ...values);
+		this._version += 1;
+	}
+
+	pop(index: number): T {
+		if (this.buf.length === 0) throw new RangeError("pop from empty list");
+		if (!Number.isInteger(index)) throw new RangeError(`pop: index ${index} must be an integer`);
+		const i = index >= 0 ? index : this.buf.length + index;
+		if (i < 0 || i >= this.buf.length) throw new RangeError(`pop: index ${index} out of range`);
+		const [v] = this.buf.splice(i, 1);
+		this._version += 1;
+		return v as T;
+	}
+
+	clear(): number {
+		const n = this.buf.length;
+		if (n === 0) return 0;
+		this.buf.length = 0;
+		this._version += 1;
+		return n;
+	}
+
+	enforceMaxSize(maxSize?: number): number {
+		const removed = trimHeadOverflow(this.buf, { maxSize }).length;
+		if (removed > 0) this._version += 1;
+		return removed;
+	}
+}
+
+/**
+ * Create a reactive list (D54/D60). The DELTA + SNAPSHOT ports + pullId come from the shared
+ * {@link collectionCore}; this layer adds the typed list method surface + backend.
+ *
+ * @example
+ * ```ts
+ * const list = reactiveList<number>([1]);
+ * // observe events:
+ * list.delta.subscribe((m) => { if (m[0] === "DATA") console.log("Δ", m[1]); });
+ * list.append(2);                 // delta: {kind:"append", value:2}
+ * // demand the snapshot (a downstream consumer, holding `list.snapshot` upstream, runs):
+ * //   ctx.upNext([["PULL", { pullId: list.pullId }]]);  → SNAPSHOT delivers [1, 2]
+ * list.toArray();                 // [1, 2]   (synchronous non-reactive read)
+ * ```
+ */
+export function reactiveList<T>(
+	initial?: readonly T[],
+	options: ReactiveListOptions = {},
+): ReactiveList<T> {
+	const { maxSize, graph, dispatcher } = options;
+	const base = dispatcher ? { dispatcher } : {};
+
+	function isNodeOpt(x: ReactiveListOpt<number> | undefined): x is Node<number> {
+		return x instanceof Node;
+	}
+
+	function validateMaxSize(v: number): number {
+		if (!Number.isFinite(v) || !Number.isInteger(v) || v < 1)
+			throw new RangeError(`reactiveList: maxSize must be a positive integer (got ${v})`);
+		return v;
+	}
+
+	const initialMaxSize = isNodeOpt(maxSize) ? undefined : maxSize;
+	const backend = new ListBackend<T>(
+		initial,
+		initialMaxSize === undefined ? undefined : validateMaxSize(initialMaxSize),
+	);
+	const restorable = graph !== undefined && options.name !== undefined && maxSize === undefined;
+	const core: CollectionCore<readonly T[], ListChange<T>> = collectionCore(
+		backend,
+		"reactiveList",
+		options,
+		restorable
+			? {
+					deltaRef: "reactiveList.delta",
+					snapshotRef: "reactiveList.snapshot",
+					backendState: () => backend.snapshot(),
+				}
+			: undefined,
+	);
+	const binds: Array<() => void> = [];
+	const bindDeps = new WeakSet<Node<unknown>>();
+	let bindSeq = 0;
+	let capacityPolicy: Node<number> | undefined;
+	let apply: Node<ListChange<T>> | undefined;
+	let releaseApply = () => {};
+	let currentMaxSize = initialMaxSize;
+
+	function emitTrimmed(n: number): void {
+		if (n > 0) core.emit({ kind: "trimHead", n });
+	}
+
+	function enforceCapacity(): void {
+		emitTrimmed(backend.enforceMaxSize(currentMaxSize));
+	}
+
+	const applyBody = (ctx: Ctx): void => {
+		const deps = apply?.deps ?? [];
+		for (let i = 0; i < depCount(ctx); i++) {
+			const dep = deps[i];
+			if (dep === capacityPolicy) {
+				const latest = depLatest(ctx, i);
+				if (latest !== undefined) currentMaxSize = validateMaxSize(latest as number);
+				continue;
+			}
+			if (dep && bindDeps.has(dep)) {
+				for (const value of (depBatch(ctx, i) ?? []) as readonly T[]) {
+					backend.append(value);
+					core.emit({ kind: "append", value });
+					enforceCapacity();
+				}
+			}
+		}
+		enforceCapacity();
+	};
+
+	function ensureApply(): Node<ListChange<T>> {
+		if (apply !== undefined) return apply;
+		const op: Operator<unknown, ListChange<T>> = {
+			factory: "reactiveList.capacityPolicy",
+			body: applyBody,
+			opts: { partial: true },
+		};
+		const deps = capacityPolicy ? [capacityPolicy as Node<unknown>] : [];
+		apply = graph
+			? graph.initNode(op, deps, {
+					name: options.name ? `${options.name}.capacityPolicy` : undefined,
+					meta: { kind: "collection_policy_apply", collection: "reactiveList" },
+				})
+			: new Node<ListChange<T>>(deps, op.body, {
+					...base,
+					factory: "reactiveList.capacityPolicy",
+					partial: true,
+					name: options.name ? `${options.name}.capacityPolicy` : undefined,
+				});
+		releaseApply = graph
+			? graph.retain(apply, { reason: "reactiveList.capacityPolicy" })
+			: apply.subscribe(() => {});
+		return apply;
+	}
+
+	function constPolicyNode(value: number): Node<number> {
+		const op: Operator<never, number> = {
+			factory: "reactiveList.maxSizePolicy",
+			body: () => {},
+			opts: { initial: value },
+		};
+		if (graph) {
+			return graph.initNode(op, [], {
+				name: options.name ? `${options.name}.maxSizePolicy` : undefined,
+				meta: { kind: "collection_policy", collection: "reactiveList", policy: "maxSize" },
+			});
+		}
+		return new Node<number>([], null, {
+			...base,
+			initial: value,
+			factory: "reactiveList.maxSizePolicy",
+			name: options.name ? `${options.name}.maxSizePolicy` : undefined,
+		});
+	}
+
+	if (maxSize !== undefined) {
+		if (isNodeOpt(maxSize) && graph === undefined)
+			throw new Error(
+				"reactiveList maxSize Node option requires options.graph so the policy edge is describe-visible (D72)",
+			);
+		capacityPolicy = isNodeOpt(maxSize)
+			? maxSize
+			: graph
+				? constPolicyNode(validateMaxSize(maxSize))
+				: undefined;
+		if (capacityPolicy !== undefined) ensureApply();
+	}
+
+	return {
+		delta: core.delta,
+		snapshot: core.snapshot,
+		pullId: core.pullId,
+
+		get size(): number {
+			return backend.size;
+		},
+		at(index: number): T | undefined {
+			return backend.at(index);
+		},
+		toArray(): readonly T[] {
+			return backend.snapshot();
+		},
+
+		append(value: T): void {
+			backend.append(value);
+			core.emit({ kind: "append", value });
+			enforceCapacity();
+		},
+		appendMany(values: readonly T[]): void {
+			if (values.length === 0) return;
+			const copy = [...values];
+			backend.appendMany(copy);
+			core.emit({ kind: "appendMany", values: copy });
+			enforceCapacity();
+		},
+		insert(index: number, value: T): void {
+			backend.insert(index, value);
+			core.emit({ kind: "insert", index, value });
+			enforceCapacity();
+		},
+		insertMany(index: number, values: readonly T[]): void {
+			if (values.length === 0) {
+				// still validate the index (mirror backend) so an out-of-range empty insert throws
+				backend.insertMany(index, values);
+				return;
+			}
+			const copy = [...values];
+			backend.insertMany(index, copy);
+			core.emit({ kind: "insertMany", index, values: copy });
+			enforceCapacity();
+		},
+		pop(index = -1): T {
+			const resolved = index < 0 ? backend.size + index : index;
+			const value = backend.pop(index);
+			core.emit({ kind: "pop", index: resolved, value });
+			return value;
+		},
+		clear(): void {
+			const count = backend.clear();
+			if (count > 0) core.emit({ kind: "clear", count });
+		},
+
+		appendFrom(src: Node<T>): () => void {
+			if (graph === undefined)
+				throw new Error(
+					"reactiveList.appendFrom requires options.graph so the input fold is describe-visible (D61)",
+				);
+			const op: Operator<T, T> = {
+				factory: "reactiveList.bindSource",
+				body: (ctx: Ctx) => {
+					try {
+						for (const value of (depBatch(ctx, 0) ?? []) as readonly T[]) {
+							ctx.down([["DATA", value]]);
+						}
+					} catch (e) {
+						ctx.down([["ERROR", errorPayload(e, "reactiveList.bindSource failed")]]);
+					}
+				},
+			};
+			const folder = graph.initNode(op, [src], {
+				name: options.name ? `${options.name}.bind#${bindSeq++}` : undefined,
+				meta: { kind: "collection_bind_source", collection: "reactiveList" },
+			});
+			bindDeps.add(folder as Node<unknown>);
+			const applyNode = ensureApply();
+			applyNode.subscribeDep(folder as Node<unknown>, applyBody);
+			let active = true;
+			const dispose = () => {
+				if (!active) return;
+				active = false;
+				applyNode.unsubscribeDep(folder as Node<unknown>, applyBody);
+			};
+			binds.push(dispose);
+			return dispose;
+		},
+		dispose(): void {
+			for (const d of binds) d();
+			binds.length = 0;
+			releaseApply();
+		},
+	};
+}
diff --git a/packages/ts/src/graph/data-structures/reactive-log.ts b/packages/ts/src/graph/data-structures/reactive-log.ts
new file mode 100644
index 00000000..6497b7b8
--- /dev/null
+++ b/packages/ts/src/graph/data-structures/reactive-log.ts
@@ -0,0 +1,373 @@
+/**
+ * Reactive append-only log (CSP-2.8, D54/D60) — two-port collection with incremental views.
+ *
+ * Shape = the shared {@link collectionCore} two ports over an array (or ring-buffer if `maxSize`)
+ * BACKEND (D60). Specializations (D60 #5 / review #5):
+ *   - SNAPSHOT (the full `readonly T[]`) is the lazy pull port like the others, BUT the log's main
+ *     consumption is INCREMENTAL: `tail()` / `slice()` / `scan()` re-derive on the DELTA backbone
+ *     (dep=[delta]), folding each appended value as it arrives — NOT re-scanning a pushed full array.
+ *   - `append(undefined)` throws: `undefined` is the substrate SENTINEL (R-data-payload / R-sentinel),
+ *     not a valid value.
+ *   - empty log: the snapshot is `[]` (a real empty array); a never-appended `scan` seeds its initial.
+ *     There is NO `[[RESOLVED]]`-for-empty dual role (D49 narrowed RESOLVED to undirty-only, D60 #5b).
+ *   - `attach(upstream)` = the D54 widening (a declared input-fold dep), NOT an imperative subscribe.
+ *   - {@link mergeReactiveLogs} is a DECLARED-DEP merge (deps=[...delta streams]), NOT the old
+ *     internal-subscribe island (D45 must-fix, D60 #5e).
+ *   - storage persistence = D57 (binding-layer observe-sink), out of scope here.
+ *
+ * Per-language (D6/D24, never in parity, no conformance — the substrate pull is already C-16).
+ */
+
+import { type Ctx, depBatch, depCount } from "../../ctx/types.js";
+import { type Node, node } from "../../node/node.js";
+import type { GraphCheckpointJson } from "../checkpoint.js";
+import { trimHeadOverflow } from "../policies/collection.js";
+import type { ViewCachePolicy } from "../policies/types.js";
+import type { LogChange } from "./change.js";
+import {
+	type CollectionCore,
+	type CollectionCoreOptions,
+	collectionCore,
+	lightReactiveView,
+	type ReactiveView,
+	ViewMemoCache,
+} from "./core.js";
+
+export interface ReactiveLogOptions extends CollectionCoreOptions {
+	/** Ring-buffer cap: appends past `maxSize` evict the oldest (head-trim, append-only-safe). */
+	maxSize?: number;
+	/** Static D80 memo policy for D121 light views. Eviction does not dispose returned views. */
+	viewCache?: ViewCachePolicy;
+}
+
+export interface ReactiveLog<T> {
+	readonly delta: Node<LogChange<T>>;
+	/** SNAPSHOT pull node: demand → full `readonly T[]` (lazy O(n)). For incremental use {@link tail}, {@link slice}, or {@link scan}. */
+	readonly snapshot: Node<readonly T[]>;
+	readonly pullId: symbol;
+	/** Entry count (O(1)). Sync non-reactive read. */
+	readonly size: number;
+	/** Positional access (O(1)); negative Python-style; `undefined` out of range. Sync read. */
+	at(index: number): T | undefined;
+	/** Full contents (O(n) fresh copy). Sync non-reactive read (cold-start peek). */
+	toArray(): readonly T[];
+	/** Append one value. Throws on `undefined` (substrate SENTINEL, R-data-payload). */
+	append(value: T): void;
+	/** Append many; one delta event. No-op if empty. Throws if any value is `undefined`. */
+	appendMany(values: readonly T[]): void;
+	clear(): void;
+	/** Remove the first `n` entries (clamped to size). */
+	trimHead(n: number): void;
+	/**
+	 * Incremental tail view: a derived node emitting the last `n` entries, recomputed on each delta
+	 * (dep=[delta], D60 #5a). Memoized per `n` until {@link dispose}; use stable ranges for
+	 * long-lived logs. Subscribe to keep it live.
+	 */
+	tail(n: number): Node<readonly T[]>;
+	/**
+	 * Incremental positional view: a derived node emitting `toArray().slice(start, stop)`,
+	 * recomputed on each delta (dep=[delta], D60 #5a). Memoized per `[start, stop]` until
+	 * {@link dispose}; use stable ranges for long-lived logs.
+	 */
+	slice(start: number, stop?: number): Node<readonly T[]>;
+	/**
+	 * D121 light page view: `delta` forwards parent log mutations, and `snapshot` is a pull node
+	 * that materializes the current page on demand.
+	 */
+	page(offset: number, limit: number): ReactiveView<LogChange<T>, readonly T[]>;
+	/**
+	 * Incremental running aggregate over appended values (dep=[delta], D60 #5a). O(1) per append —
+	 * folds only the new values each delta; resets on `clear`/`trimHead` (a non-append delta) via a
+	 * full re-fold. Emits the current accumulator on every mutation; seeds `initial` on an empty log.
+	 */
+	scan<A>(initial: A, step: (acc: A, value: T) => A): Node<A>;
+	/** D54 widening: every value from `src` is appended. Returns a disposer. */
+	attach(src: Node<T>): () => void;
+	dispose(): void;
+}
+
+/** Default array / ring-buffer backend (D60 first-cut; persistent backend deferred). */
+class LogBackend<T> {
+	private _version = 0;
+	private buf: T[];
+	private readonly maxSize?: number;
+
+	constructor(initial?: readonly T[], maxSize?: number) {
+		if (maxSize !== undefined && maxSize < 1)
+			throw new RangeError("reactiveLog: maxSize must be >= 1");
+		this.maxSize = maxSize;
+		this.buf = initial ? [...initial] : [];
+		trimHeadOverflow(this.buf, { maxSize });
+	}
+
+	get version(): number {
+		return this._version;
+	}
+	get size(): number {
+		return this.buf.length;
+	}
+	at(index: number): T | undefined {
+		if (!Number.isInteger(index)) return undefined;
+		const i = index >= 0 ? index : this.buf.length + index;
+		return i < 0 || i >= this.buf.length ? undefined : this.buf[i];
+	}
+	snapshot(): readonly T[] {
+		return [...this.buf];
+	}
+
+	append(value: T): void {
+		this.buf.push(value);
+		trimHeadOverflow(this.buf, { maxSize: this.maxSize });
+		this._version += 1;
+	}
+	appendMany(values: readonly T[]): void {
+		if (values.length === 0) return;
+		for (const v of values) this.buf.push(v);
+		trimHeadOverflow(this.buf, { maxSize: this.maxSize });
+		this._version += 1;
+	}
+	clear(): number {
+		const n = this.buf.length;
+		if (n === 0) return 0;
+		this.buf.length = 0;
+		this._version += 1;
+		return n;
+	}
+	trimHead(n: number): number {
+		if (!Number.isInteger(n) || n < 0)
+			throw new RangeError(`trimHead: n must be a non-negative integer (got ${n})`);
+		if (n === 0 || this.buf.length === 0) return 0;
+		const removed = Math.min(n, this.buf.length);
+		this.buf.splice(0, removed);
+		this._version += 1;
+		return removed;
+	}
+}
+
+function rejectUndefined<T>(value: T, ctx: string): void {
+	// R-data-payload / R-sentinel (D60 #5): undefined is the substrate SENTINEL, not a valid value.
+	if (value === undefined)
+		throw new TypeError(
+			`${ctx}: undefined is the substrate SENTINEL, not a valid value — use null`,
+		);
+}
+
+/**
+ * Create an append-only reactive log (D54/D60). DELTA + lazy pull SNAPSHOT + pullId via
+ * {@link collectionCore}; this layer adds the typed append surface + incremental view/scan.
+ */
+export function reactiveLog<T>(
+	initial?: readonly T[],
+	options: ReactiveLogOptions = {},
+): ReactiveLog<T> {
+	const { maxSize, viewCache, ...coreOpts } = options;
+	const base = coreOpts.dispatcher ? { dispatcher: coreOpts.dispatcher } : {};
+	const backend = new LogBackend<T>(initial, maxSize);
+	const restoreConfig =
+		coreOpts.graph !== undefined && coreOpts.name !== undefined
+			? ({
+					...(maxSize !== undefined ? { maxSize } : {}),
+				} as GraphCheckpointJson)
+			: undefined;
+	const core: CollectionCore<readonly T[], LogChange<T>> = collectionCore(
+		backend,
+		"reactiveLog",
+		coreOpts,
+		restoreConfig !== undefined
+			? {
+					deltaRef: "reactiveLog.delta",
+					snapshotRef: "reactiveLog.snapshot",
+					config: restoreConfig,
+					backendState: () => backend.snapshot(),
+				}
+			: undefined,
+	);
+	const binds: Array<() => void> = [];
+	const tailMemo = new Map<number, Node<readonly T[]>>();
+	const sliceMemo = new Map<string, Node<readonly T[]>>();
+	const pageMemo = new ViewMemoCache<string, ReactiveView<LogChange<T>, readonly T[]>>(viewCache);
+	let pageSeq = 0;
+
+	return {
+		delta: core.delta,
+		snapshot: core.snapshot,
+		pullId: core.pullId,
+
+		get size(): number {
+			return backend.size;
+		},
+		at(index: number): T | undefined {
+			return backend.at(index);
+		},
+		toArray(): readonly T[] {
+			return backend.snapshot();
+		},
+
+		append(value: T): void {
+			rejectUndefined(value, "reactiveLog.append");
+			backend.append(value);
+			core.emit({ kind: "append", value });
+		},
+		appendMany(values: readonly T[]): void {
+			if (values.length === 0) return;
+			for (const v of values) rejectUndefined(v, "reactiveLog.appendMany");
+			const copy = [...values];
+			backend.appendMany(copy);
+			core.emit({ kind: "appendMany", values: copy });
+		},
+		clear(): void {
+			const count = backend.clear();
+			if (count > 0) core.emit({ kind: "clear", count });
+		},
+		trimHead(n: number): void {
+			const removed = backend.trimHead(n);
+			if (removed > 0) core.emit({ kind: "trimHead", n: removed });
+		},
+
+		tail(n: number): Node<readonly T[]> {
+			if (!Number.isInteger(n) || n < 0)
+				throw new RangeError(`tail: n must be a non-negative integer (got ${n})`);
+			const hit = tailMemo.get(n);
+			if (hit !== undefined) return hit;
+			// Incremental on the DELTA backbone (D60 #5a): each delta re-reads the backend's current
+			// tail (the backend is this structure's own materialized state, D60 #1 — not a foreign
+			// .cache peek). `partial:true` — the tail does not consume the delta value, it fires on arm.
+			const tnode = node<readonly T[]>(
+				[core.delta as Node<unknown>],
+				(ctx: Ctx) => {
+					const all = backend.snapshot();
+					ctx.down([["DATA", n === 0 ? [] : all.slice(Math.max(0, all.length - n))]]);
+				},
+				{ ...base, factory: "reactiveLog.tail", partial: true },
+			);
+			tailMemo.set(n, tnode);
+			return tnode;
+		},
+
+		slice(start: number, stop?: number): Node<readonly T[]> {
+			if (!Number.isInteger(start) || start < 0) {
+				throw new RangeError(`slice: start must be a non-negative integer (got ${start})`);
+			}
+			if (stop !== undefined && (!Number.isInteger(stop) || stop < 0)) {
+				throw new RangeError(`slice: stop must be a non-negative integer (got ${stop})`);
+			}
+			const key = `${start}:${stop ?? ""}`;
+			const hit = sliceMemo.get(key);
+			if (hit !== undefined) return hit;
+			// Incremental on the DELTA backbone (D60 #5a): each delta re-reads this log's own
+			// backend slice. The backend is the single materialized state (D60), not a dep cache.
+			const snode = node<readonly T[]>(
+				[core.delta as Node<unknown>],
+				(ctx: Ctx) => {
+					ctx.down([["DATA", backend.snapshot().slice(start, stop)]]);
+				},
+				{ ...base, factory: "reactiveLog.slice", partial: true },
+			);
+			sliceMemo.set(key, snode);
+			return snode;
+		},
+
+		page(offset: number, limit: number): ReactiveView<LogChange<T>, readonly T[]> {
+			if (!Number.isInteger(offset) || offset < 0) {
+				throw new RangeError(`page: offset must be a non-negative integer (got ${offset})`);
+			}
+			if (!Number.isInteger(limit) || limit < 0) {
+				throw new RangeError(`page: limit must be a non-negative integer (got ${limit})`);
+			}
+			const key = `${offset}:${limit}`;
+			const hit = pageMemo.get(key);
+			if (hit !== undefined) return hit;
+			const materialize = (): readonly T[] => backend.snapshot().slice(offset, offset + limit);
+			let view: ReactiveView<LogChange<T>, readonly T[]>;
+			view = lightReactiveView<LogChange<T>, readonly T[]>(core.delta as Node<unknown>, {
+				...coreOpts,
+				factory: "reactiveLog.page",
+				name: coreOpts.name ? `${coreOpts.name}.page#${pageSeq++}` : undefined,
+				materializeSnapshot: materialize,
+				onDispose: () => {
+					pageMemo.deleteValue(view);
+				},
+			});
+			pageMemo.set(key, view);
+			return view;
+		},
+
+		scan<A>(initial: A, step: (acc: A, value: T) => A): Node<A> {
+			// Incremental fold on the delta backbone: keep the accumulator + processed-count in
+			// ctx.state; fold only the new tail each append; full re-fold on a shrink (clear/trimHead).
+			return node<A>(
+				[core.delta as Node<unknown>],
+				(ctx: Ctx) => {
+					const st = ctx.state.get<{ acc: A; processed: number }>() ?? {
+						acc: initial,
+						processed: 0,
+					};
+					const all = backend.snapshot();
+					if (all.length < st.processed || (maxSize !== undefined && all.length <= st.processed)) {
+						// Shrink or ring-buffer overwrite: re-fold from the current backend snapshot.
+						let acc = initial;
+						for (const v of all) acc = step(acc, v);
+						st.acc = acc;
+						st.processed = all.length;
+					} else {
+						for (let i = st.processed; i < all.length; i++) st.acc = step(st.acc, all[i] as T);
+						st.processed = all.length;
+					}
+					ctx.state.set(st);
+					ctx.down([["DATA", st.acc]]);
+				},
+				{ ...base, factory: "reactiveLog.scan", partial: true },
+			);
+		},
+
+		attach(src: Node<T>): () => void {
+			const dispose = core.bindSource(src, (value: T) => {
+				rejectUndefined(value, "reactiveLog.attach");
+				backend.append(value);
+				core.emit({ kind: "append", value });
+			});
+			binds.push(dispose);
+			return dispose;
+		},
+		dispose(): void {
+			for (const d of binds) d();
+			binds.length = 0;
+			tailMemo.clear();
+			sliceMemo.clear();
+			pageMemo.disposeAll();
+		},
+	};
+}
+
+/**
+ * Fan-in N reactive logs into one merged DELTA stream (D60 #5e — a DECLARED-DEP merge, NOT the old
+ * internal-subscribe island). The returned node declares each log's `delta` as a dep (`partial`)
+ * and re-emits every change it sees — describe shows `log[i].delta → merged` truthfully (D45).
+ * For the merged SNAPSHOT, fold the merged delta with {@link ReactiveLog.scan}-style logic, or
+ * demand each source's snapshot independently.
+ */
+export function mergeReactiveLogs<T>(logs: readonly ReactiveLog<T>[]): Node<LogChange<T>> {
+	const deps = logs.map((l) => l.delta as Node<unknown>);
+	return node<LogChange<T>>(
+		deps,
+		(ctx: Ctx) => {
+			for (let i = 0; i < depCount(ctx); i++) {
+				const b = depBatch(ctx, i);
+				if (b) for (const c of b) ctx.down([["DATA", c as LogChange<T>]]);
+			}
+		},
+		{ factory: "mergeReactiveLogs", partial: true },
+	);
+}
+
+/**
+ * Standalone incremental scan over a reactive log. Equivalent to `log.scan(initial, step)`;
+ * provided for pipe-builder and helper-composition call sites.
+ */
+export function scanLog<T, A>(
+	log: ReactiveLog<T>,
+	initial: A,
+	step: (acc: A, value: T) => A,
+): Node<A> {
+	return log.scan(initial, step);
+}
diff --git a/packages/ts/src/graph/data-structures/reactive-map.ts b/packages/ts/src/graph/data-structures/reactive-map.ts
new file mode 100644
index 00000000..2cd2ae07
--- /dev/null
+++ b/packages/ts/src/graph/data-structures/reactive-map.ts
@@ -0,0 +1,805 @@
+/**
+ * Reactive key–value map (CSP-2.8, D54/D60/D68) — two-port collection with policy opts.
+ *
+ * Shape = the shared {@link collectionCore} two ports over a `Map` BACKEND (D60). Specializations
+ * (D60 #3 / review #3):
+ *   - TTL/LRU are node-as-opt policies (D68). Static `maxSize` / `defaultTtl` values become constant
+ *     policy deps; Node-valued opts are declared deps. The graph-visible `reactiveMap.apply` node is
+ *     the normal backend mutation path and emits the public delta payloads it materializes.
+ *   - LAZY TTL (no background timer): expiry is checked at read (`get`/`has`) + at synchronous
+ *     snapshot materialization (`toMap`/`pruneExpired`). A read/prune that deletes an expired key
+ *     emits the normal delta `delete{reason:"expired"}` (D61). Snapshot demand uses an internal pull
+ *     `snapshotPrep` node: it prunes expired entries and reads the backend once, then public
+ *     `snapshot` and `delta` derive from that declared prep payload. No snapshot fn drives its own
+ *     dep (D37).
+ *   - delete-reason enum {expired|lru-evict|archived|explicit} on the delta (D60 #3c).
+ *   - LRU `maxSize`: an over-cap `set` evicts the oldest, emitting a `delete{reason:"lru-evict"}`.
+ *     A live-key `get`/`has` touches LRU order WITHOUT a version bump (internal, D60 #3d).
+ *   - retention (score-archive, D72): `retention.maxSize` is a value-or-Node numeric policy and
+ *     the static scorer selects archive victims through the normal `reactiveMap.apply` path.
+ *
+ * Per-language (D6/D24, never in parity, no conformance — the substrate pull is already C-16).
+ */
+
+import {
+	type Ctx,
+	depBatch,
+	depCount,
+	depTerminal,
+	isTerminalComplete,
+	type NodeFn,
+} from "../../ctx/types.js";
+import { strictCanonicalJsonBytes } from "../../json/codec.js";
+import { Node } from "../../node/node.js";
+import { errorPayload } from "../../protocol/messages.js";
+import { registerBackendStateContributor } from "../checkpoint.js";
+import { initNode, type Operator } from "../operators.js";
+import {
+	deadlines,
+	lruKeys,
+	PolicyInputs,
+	type PolicyOpt,
+	type ScoredEntry,
+	selectRetentionVictims,
+	trimHeadOverflow,
+} from "../policies/collection.js";
+import type { ReactiveOpt, RetentionPolicy, ViewCachePolicy } from "../policies/types.js";
+import { timer } from "../sources.js";
+import type { MapChange } from "./change.js";
+import {
+	type CollectionCoreOptions,
+	lightReactiveView,
+	type ReactiveView,
+	ViewMemoCache,
+} from "./core.js";
+
+export type ReactiveMapOpt<T> = ReactiveOpt<T>;
+
+export interface ReactiveMapRetentionEntry<K, V> {
+	readonly key: K;
+	readonly value: V;
+}
+
+export interface ReactiveMapRetentionPolicy<K, V>
+	extends RetentionPolicy<ReactiveMapRetentionEntry<K, V>> {
+	/** Archive capacity. Unlike LRU, zero is allowed and archives every live entry. */
+	readonly maxSize?: ReactiveMapOpt<number>;
+	/** Higher scores are retained; lowest finite scores are archived first. */
+	score(entry: ReactiveMapRetentionEntry<K, V>): number;
+}
+
+interface ResolvedRetentionPolicy<K, V> {
+	readonly maxSize?: number;
+	score(entry: ReactiveMapRetentionEntry<K, V>): number;
+}
+
+export interface ReactiveMapOptions<K = unknown, V = unknown> extends CollectionCoreOptions {
+	/**
+	 * LRU cap as a node-as-opt policy (D68). A static number is a constant policy config; a Node must
+	 * be graph-bound and becomes a declared dep of `reactiveMap.apply`.
+	 */
+	maxSize?: ReactiveMapOpt<number>;
+	/**
+	 * Default TTL in milliseconds as a node-as-opt policy (D68). Per-call `set(...,{ttl})` overrides.
+	 * Lazy expiry only; no active timer in this cut.
+	 */
+	defaultTtl?: ReactiveMapOpt<number>;
+	/**
+	 * Score-based retention/archive policy (D72). The scorer is static local code; only maxSize can be
+	 * a Node-valued policy, keeping graph describe data serializable while apply owns the mutation.
+	 */
+	retention?: ReactiveMapRetentionPolicy<K, V>;
+	/** Static D80 memo policy for D121 light views. Eviction does not dispose returned views. */
+	viewCache?: ViewCachePolicy;
+	/** Injectable monotonic-ish clock for TTL (default `Date.now`). Graph-local clock = follow-up (D26). */
+	now?: () => number;
+}
+
+export interface ReactiveMap<K, V> {
+	readonly delta: Node<MapChange<K, V>>;
+	readonly snapshot: Node<ReadonlyMap<K, V>>;
+	readonly pullId: symbol;
+	/** Raw entry count (O(1)); may include not-yet-pruned expired entries. Sync non-reactive read. */
+	readonly size: number;
+	/** Get a live value (prunes the key if expired). Sync read. */
+	get(key: K): V | undefined;
+	/** Live-key existence (prunes if expired). Sync read. */
+	has(key: K): boolean;
+	/** Current live (non-expired) entries (fresh copy). Sync non-reactive read (cold-start peek). */
+	toMap(): ReadonlyMap<K, V>;
+	/**
+	 * D121 light selected-map view. `delta` forwards parent map mutations, and `snapshot` is a pull
+	 * node that materializes the currently matching live entries on demand.
+	 */
+	select(
+		predicate: (value: V, key: K) => boolean,
+	): ReactiveView<MapChange<K, V>, ReadonlyMap<K, V>>;
+	set(key: K, value: V, opts?: { ttl?: number }): void;
+	/** Bulk set; one delta event per entry, one snapshot-arm. No-op if empty. */
+	setMany(entries: Iterable<readonly [K, V]>, opts?: { ttl?: number }): void;
+	delete(key: K): void;
+	/** Bulk delete; one delta per removed key. No-op if none present. */
+	deleteMany(keys: Iterable<K>): void;
+	clear(): void;
+	/** Explicitly prune expired entries; every removed key emits `delete{reason:"expired"}` (D61). */
+	pruneExpired(): void;
+	/** D54 widening: every `[key, value]` from `src` is set. Returns a disposer. */
+	setFrom(src: Node<readonly [K, V]>): () => void;
+	dispose(): void;
+}
+
+interface Entry<V> {
+	value: V;
+	expiresAt?: number;
+}
+
+function strictJsonIdentity(value: unknown): string {
+	return Array.from(strictCanonicalJsonBytes(value)).join(",");
+}
+
+type Lookup<V> =
+	| { found: true; value: V }
+	| { found: false; expired?: false }
+	| { found: false; expired: true; previous: V };
+
+interface SnapshotPrep<K, V> {
+	readonly snapshot: ReadonlyMap<K, V>;
+	readonly expired: readonly MapChange<K, V>[];
+}
+
+type MapIntent<K, V> =
+	| { kind: "set"; key: K; value: V; ttl?: number }
+	| { kind: "delete"; key: K }
+	| { kind: "clear" }
+	| { kind: "pruneExpired" }
+	| { kind: "pruneKey"; key: K };
+
+/** Default `Map`-backed store. TTL/LRU policy lives in graph-visible policy/apply nodes (D68). */
+class MapBackend<K, V> {
+	private _version = 0;
+	private readonly store = new Map<K, Entry<V>>();
+	private readonly now: () => number;
+
+	constructor(opts: { now?: () => number }) {
+		this.now = opts.now ?? Date.now;
+	}
+
+	get version(): number {
+		return this._version;
+	}
+
+	get size(): number {
+		return this.store.size;
+	}
+
+	nowMs(): number {
+		return this.now();
+	}
+
+	expiresAtOf(key: K): number | undefined {
+		return this.store.get(key)?.expiresAt;
+	}
+
+	private isExpired(e: Entry<V>): boolean {
+		return e.expiresAt !== undefined && this.now() >= e.expiresAt;
+	}
+
+	resolveExpiresAt(ttl?: number): number | undefined {
+		if (ttl === undefined) return undefined;
+		if (!Number.isFinite(ttl) || ttl <= 0)
+			throw new RangeError(`reactiveMap: ttl must be a positive finite number (got ${ttl})`);
+		return this.now() + ttl;
+	}
+
+	private deleteExpired(key: K, e: Entry<V>): Array<[K, V]> {
+		this.store.delete(key);
+		this._version += 1;
+		return [[key, e.value]];
+	}
+
+	/** Read without materializing expiry. Caller routes expired deletes through the apply node (D68). */
+	lookup(key: K): Lookup<V> {
+		const e = this.store.get(key);
+		if (e === undefined) return { found: false };
+		if (this.isExpired(e)) return { found: false, expired: true, previous: e.value };
+		// LRU touch (no version bump — internal, D60 #3d).
+		this.store.delete(key);
+		this.store.set(key, e);
+		return { found: true, value: e.value };
+	}
+
+	/** Set; returns the entries evicted by LRU overflow (the caller emits their delete deltas). */
+	set(key: K, value: V, expiresAt?: number): void {
+		if (this.store.has(key)) this.store.delete(key); // re-insert at LRU end
+		this.store.set(key, { value, expiresAt });
+		this._version += 1;
+	}
+
+	enforceLru(maxSize?: number): Array<[K, V]> {
+		const evicted: Array<[K, V]> = [];
+		for (const oldest of trimHeadOverflow(lruKeys(this.store.keys()).keys(), {
+			maxSize,
+			size: this.store.size,
+		})) {
+			const e = this.store.get(oldest);
+			if (e !== undefined) evicted.push([oldest, e.value]);
+			this.store.delete(oldest);
+		}
+		if (evicted.length > 0) this._version += 1;
+		return evicted;
+	}
+
+	enforceRetention(policy?: ResolvedRetentionPolicy<K, V>): Array<[K, V]> {
+		if (policy === undefined || policy.maxSize === undefined) return [];
+		const scored: ScoredEntry<readonly [K, V]>[] = [];
+		for (const [key, entry] of this.store) {
+			if (!this.isExpired(entry)) {
+				scored.push({
+					entry: [key, entry.value] as const,
+					score: policy.score({ key, value: entry.value }),
+				});
+			}
+		}
+		const archived = selectRetentionVictims(scored, { maxSize: policy.maxSize });
+		for (const [key] of archived) this.store.delete(key);
+		if (archived.length > 0) this._version += 1;
+		return archived.map(([key, value]) => [key, value]);
+	}
+
+	delete(key: K): Lookup<V> {
+		const e = this.store.get(key);
+		if (e === undefined) return { found: false };
+		this.store.delete(key);
+		this._version += 1;
+		return { found: true, value: e.value };
+	}
+
+	clear(): number {
+		const n = this.store.size;
+		if (n === 0) return 0;
+		this.store.clear();
+		this._version += 1;
+		return n;
+	}
+
+	pruneExpired(): Array<[K, V]> {
+		const removed: Array<[K, V]> = [];
+		for (const [k, e] of this.store) {
+			if (this.isExpired(e)) {
+				this.store.delete(k);
+				removed.push([k, e.value]);
+			}
+		}
+		if (removed.length > 0) this._version += 1;
+		return removed;
+	}
+
+	pruneKeyIfExpired(key: K): Array<[K, V]> {
+		const e = this.store.get(key);
+		if (e === undefined || !this.isExpired(e)) return [];
+		return this.deleteExpired(key, e);
+	}
+
+	/** Fresh snapshot of live entries. Does not prune; callers choose whether to materialize expiry. */
+	snapshot(): ReadonlyMap<K, V> {
+		const out = new Map<K, V>();
+		for (const [k, e] of this.store) if (!this.isExpired(e)) out.set(k, e.value);
+		return out;
+	}
+
+	/** D160 checkpoint payload: exact restorable map entries, excluding TTL-bearing state. */
+	checkpointEntries(): readonly (readonly [K, V])[] {
+		const out: Array<readonly [K, V]> = [];
+		const seen = new Set<string>();
+		for (const [key, entry] of this.store) {
+			if (entry.expiresAt !== undefined) {
+				throw new TypeError(
+					"reactiveMap checkpoint backendState cannot preserve per-entry TTL; persist the map externally or clear TTL state before graph checkpoint (D160)",
+				);
+			}
+			const stableKey = strictJsonIdentity(key);
+			if (seen.has(stableKey)) {
+				throw new TypeError(
+					"reactiveMap checkpoint backendState contains duplicate strict-JSON keys (D160)",
+				);
+			}
+			seen.add(stableKey);
+			out.push([key, entry.value] as const);
+		}
+		return out;
+	}
+}
+
+/**
+ * Create a reactive map (D54/D60). DELTA stream of {@link MapChange} + lazy pull SNAPSHOT (a
+ * `ReadonlyMap`) + pullId via {@link collectionCore}; this layer adds the typed map surface.
+ */
+export function reactiveMap<K, V>(options: ReactiveMapOptions<K, V> = {}): ReactiveMap<K, V> {
+	return createReactiveMap(options);
+}
+
+/** @internal D161 restore path: seed the backend without replaying public deltas. */
+export function restoreReactiveMapFromBackendState<K, V>(
+	initialEntries: readonly (readonly [K, V])[],
+	options: ReactiveMapOptions<K, V> = {},
+): ReactiveMap<K, V> {
+	return createReactiveMap(options, initialEntries);
+}
+
+function createReactiveMap<K, V>(
+	options: ReactiveMapOptions<K, V> = {},
+	initialEntries: readonly (readonly [K, V])[] = [],
+): ReactiveMap<K, V> {
+	const { maxSize, defaultTtl, retention, viewCache, now, name, dispatcher, graph } = options;
+	const backend = new MapBackend<K, V>({ now });
+	for (const [key, value] of initialEntries) backend.set(key, value);
+	const base = dispatcher ? { dispatcher } : {};
+	const restorable =
+		graph !== undefined &&
+		name !== undefined &&
+		maxSize === undefined &&
+		defaultTtl === undefined &&
+		retention === undefined;
+
+	function isNodeOpt<T>(x: PolicyOpt<T> | undefined): x is Node<T> {
+		return x instanceof Node;
+	}
+
+	function validateMaxSize(v: number): number {
+		if (!Number.isFinite(v) || !Number.isInteger(v) || v < 1)
+			throw new RangeError(`reactiveMap: maxSize must be a positive integer (got ${v})`);
+		return v;
+	}
+
+	function validateTtl(v: number): number {
+		if (!Number.isFinite(v) || v <= 0)
+			throw new RangeError(`reactiveMap: defaultTtl must be a positive finite number (got ${v})`);
+		return v;
+	}
+
+	function validateRetentionMaxSize(v: number): number {
+		if (!Number.isFinite(v) || !Number.isInteger(v) || v < 0)
+			throw new RangeError(
+				`reactiveMap: retention.maxSize must be a non-negative integer (got ${v})`,
+			);
+		return v;
+	}
+
+	if (retention !== undefined && typeof retention.score !== "function")
+		throw new TypeError("reactiveMap: retention.score must be a function");
+
+	type PolicyLabel = "lruPolicy" | "ttlPolicy" | "retentionPolicy";
+
+	function constPolicyNode(label: PolicyLabel, value: number): Node<number> {
+		const op: Operator<never, number> = {
+			factory: `reactiveMap.${label}`,
+			body: () => {},
+			opts: { initial: value },
+		};
+		if (graph) {
+			return graph.initNode(op, [], {
+				name: name ? `${name}.${label}` : undefined,
+				meta: { kind: "collection_policy", collection: "reactiveMap", policy: label },
+			});
+		}
+		return new Node<number>([], null, {
+			...base,
+			initial: value,
+			factory: `reactiveMap.${label}`,
+			name: name ? `${name}.${label}` : undefined,
+		});
+	}
+
+	function policyNode(
+		label: PolicyLabel,
+		opt: PolicyOpt<number> | undefined,
+		validate: (v: number) => number,
+	): Node<number> | undefined {
+		if (opt === undefined) return undefined;
+		if (isNodeOpt(opt)) {
+			if (graph === undefined)
+				throw new Error(
+					`reactiveMap ${label} Node option requires options.graph so the policy edge is describe-visible (${label === "retentionPolicy" ? "D72" : "D68"})`,
+				);
+			return opt;
+		}
+		return constPolicyNode(label, validate(opt));
+	}
+
+	const intentOp: Operator<never, MapIntent<K, V>> = {
+		factory: "reactiveMap.intent",
+		body: () => {},
+	};
+	const intent = graph
+		? graph.initNode(intentOp, [], {
+				name: name ? `${name}.intent` : undefined,
+				meta: { kind: "collection_intent", collection: "reactiveMap" },
+				...(restorable ? { restore: { ref: "reactiveMap.intent" } } : {}),
+			})
+		: new Node<MapIntent<K, V>>([], null, {
+				...base,
+				factory: "reactiveMap.intent",
+				name: name ? `${name}.intent` : undefined,
+			});
+	const lruPolicy = policyNode("lruPolicy", maxSize, validateMaxSize);
+	const ttlPolicy = policyNode("ttlPolicy", defaultTtl, validateTtl);
+	const retentionPolicy = policyNode(
+		"retentionPolicy",
+		retention?.maxSize,
+		validateRetentionMaxSize,
+	);
+
+	let currentMaxSize = isNodeOpt(maxSize) ? undefined : maxSize;
+	let currentDefaultTtl = isNodeOpt(defaultTtl) ? undefined : defaultTtl;
+	let currentRetentionMaxSize = isNodeOpt(retention?.maxSize)
+		? undefined
+		: retention?.maxSize === undefined
+			? undefined
+			: validateRetentionMaxSize(retention.maxSize);
+	const ttlHeap = deadlines<K>();
+	let ttlTimer: Node<unknown> | null = null;
+	let ttlTimerDue: number | undefined;
+	const bindDeps = new WeakSet<Node<unknown>>();
+	let bindSeq = 0;
+	let apply: Node<MapChange<K, V>>;
+	const selectMemo = new ViewMemoCache<
+		(value: V, key: K) => boolean,
+		ReactiveView<MapChange<K, V>, ReadonlyMap<K, V>>
+	>(viewCache);
+	let selectSeq = 0;
+
+	const policyInputs = new PolicyInputs([intent as Node<unknown>]);
+	const lruReader = policyInputs.add(lruPolicy);
+	const ttlReader = policyInputs.add(ttlPolicy);
+	const retentionReader = policyInputs.add(retentionPolicy);
+
+	function emitExpired(ctx: Ctx, entries: Array<[K, V]>): void {
+		for (const [key, previous] of entries)
+			ctx.down([["DATA", { kind: "delete", key, previous, reason: "expired" }]]);
+	}
+
+	function emitLruEvicted(ctx: Ctx, entries: Array<[K, V]>): void {
+		for (const [key, previous] of entries)
+			ctx.down([["DATA", { kind: "delete", key, previous, reason: "lru-evict" }]]);
+	}
+
+	function emitArchived(ctx: Ctx, entries: Array<[K, V]>): void {
+		for (const [key, previous] of entries)
+			ctx.down([["DATA", { kind: "delete", key, previous, reason: "archived" }]]);
+	}
+
+	function nextValidExpiry(): { readonly key: K; readonly expiresAt: number } | undefined {
+		for (;;) {
+			const top = ttlHeap.peek();
+			if (top === undefined) return undefined;
+			if (backend.expiresAtOf(top.key) === top.expiresAt) return top;
+			ttlHeap.pop();
+		}
+	}
+
+	function scheduleTtl(ctx: Ctx, body: NodeFn): void {
+		for (;;) {
+			const next = nextValidExpiry();
+			if (next === undefined) {
+				if (ttlTimer) ctx.rewireNext.unsubscribeDep(ttlTimer, body);
+				ttlTimer = null;
+				ttlTimerDue = undefined;
+				return;
+			}
+			if (next.expiresAt <= backend.nowMs()) {
+				emitExpired(ctx, backend.pruneExpired());
+				continue;
+			}
+			if (ttlTimerDue === next.expiresAt) return;
+			if (ttlTimer) ctx.rewireNext.unsubscribeDep(ttlTimer, body);
+			ttlTimerDue = next.expiresAt;
+			ttlTimer = initNode(timer(Math.max(0, next.expiresAt - backend.nowMs())), [], base);
+			ctx.rewireNext.subscribeDep(ttlTimer, body);
+			return;
+		}
+	}
+
+	function applyIntent(ctx: Ctx, intentValue: MapIntent<K, V>): void {
+		if (intentValue.kind === "set") {
+			const ttl = intentValue.ttl ?? currentDefaultTtl;
+			const expiresAt = backend.resolveExpiresAt(ttl);
+			backend.set(intentValue.key, intentValue.value, expiresAt);
+			if (expiresAt !== undefined) ttlHeap.push({ key: intentValue.key, expiresAt });
+			ctx.down([["DATA", { kind: "set", key: intentValue.key, value: intentValue.value }]]);
+			emitLruEvicted(ctx, backend.enforceLru(currentMaxSize));
+			emitArchived(
+				ctx,
+				backend.enforceRetention(
+					retention ? { maxSize: currentRetentionMaxSize, score: retention.score } : undefined,
+				),
+			);
+			return;
+		}
+		if (intentValue.kind === "delete") {
+			const previous = backend.delete(intentValue.key);
+			if (previous.found)
+				ctx.down([
+					[
+						"DATA",
+						{ kind: "delete", key: intentValue.key, previous: previous.value, reason: "explicit" },
+					],
+				]);
+			return;
+		}
+		if (intentValue.kind === "clear") {
+			const count = backend.clear();
+			if (count > 0) ctx.down([["DATA", { kind: "clear", count }]]);
+			return;
+		}
+		if (intentValue.kind === "pruneExpired") {
+			emitExpired(ctx, backend.pruneExpired());
+			return;
+		}
+		emitExpired(ctx, backend.pruneKeyIfExpired(intentValue.key));
+	}
+
+	const applyBody: NodeFn = (ctx: Ctx) => {
+		const nextMaxSize = lruReader.read(ctx, currentMaxSize);
+		currentMaxSize = nextMaxSize === undefined ? undefined : validateMaxSize(nextMaxSize);
+		const nextTtl = ttlReader.read(ctx, currentDefaultTtl);
+		currentDefaultTtl = nextTtl === undefined ? undefined : validateTtl(nextTtl);
+		const nextRetentionMaxSize = retentionReader.read(ctx, currentRetentionMaxSize);
+		currentRetentionMaxSize =
+			nextRetentionMaxSize === undefined
+				? undefined
+				: validateRetentionMaxSize(nextRetentionMaxSize);
+
+		for (const item of (depBatch(ctx, 0) ?? []) as readonly MapIntent<K, V>[]) {
+			applyIntent(ctx, item);
+		}
+		const deps = apply.deps;
+		for (let i = 1; i < depCount(ctx); i++) {
+			if (i === lruReader.index || i === ttlReader.index || i === retentionReader.index) continue;
+			const dep = deps[i];
+			if (dep && bindDeps.has(dep)) {
+				for (const item of (depBatch(ctx, i) ?? []) as readonly MapIntent<K, V>[]) {
+					applyIntent(ctx, item);
+				}
+				continue;
+			}
+			if (
+				dep === ttlTimer &&
+				((depBatch(ctx, i)?.length ?? 0) > 0 || isTerminalComplete(depTerminal(ctx, i)))
+			) {
+				if (ttlTimer) ctx.rewireNext.unsubscribeDep(ttlTimer, applyBody);
+				ttlTimer = null;
+				ttlTimerDue = undefined;
+				emitExpired(ctx, backend.pruneExpired());
+			}
+		}
+		// Lowering a reactive maxSize is itself a policy-driven backend mutation (D68).
+		emitLruEvicted(ctx, backend.enforceLru(currentMaxSize));
+		emitArchived(
+			ctx,
+			backend.enforceRetention(
+				retention ? { maxSize: currentRetentionMaxSize, score: retention.score } : undefined,
+			),
+		);
+		scheduleTtl(ctx, applyBody);
+	};
+
+	const applyOp: Operator<unknown, MapChange<K, V>> = {
+		factory: "reactiveMap.apply",
+		body: applyBody,
+		opts: { partial: true },
+	};
+	apply = graph
+		? graph.initNode(applyOp, policyInputs.deps as readonly Node<unknown>[], {
+				name: name ? `${name}.apply` : undefined,
+				meta: { kind: "collection_policy_apply", collection: "reactiveMap" },
+				...(restorable ? { restore: { ref: "reactiveMap.apply" } } : {}),
+			})
+		: initNode(applyOp, policyInputs.deps, {
+				...base,
+				name: name ? `${name}.apply` : undefined,
+			});
+
+	const pullId = Symbol(name ? `${name}.snapshot` : "reactiveMap.snapshot");
+	const snapshotPrepOp: Operator<unknown, SnapshotPrep<K, V>> = {
+		factory: "reactiveMap.snapshotPrep",
+		body: (ctx: Ctx) => {
+			const expired = backend.pruneExpired().map(
+				([key, previous]): MapChange<K, V> => ({
+					kind: "delete",
+					key,
+					previous,
+					reason: "expired",
+				}),
+			);
+			ctx.down([["DATA", { snapshot: backend.snapshot(), expired }]]);
+		},
+		opts: {
+			...base,
+			pullId,
+			partial: true,
+		},
+	};
+	const snapshotPrep = graph
+		? graph.initNode(snapshotPrepOp, [apply as Node<unknown>], {
+				name: name ? `${name}.snapshotPrep` : undefined,
+				meta: { kind: "collection_snapshot_prep", collection: "reactiveMap" },
+				...(restorable ? { restore: { ref: "reactiveMap.snapshotPrep" } } : {}),
+			})
+		: initNode(snapshotPrepOp, [apply as Node<unknown>], {
+				...base,
+				name: name ? `${name}.snapshotPrep` : undefined,
+			});
+	const deltaOp: Operator<unknown, MapChange<K, V>> = {
+		factory: "reactiveMap.delta",
+		body: (ctx: Ctx) => {
+			for (const change of depBatch(ctx, 0) ?? []) {
+				ctx.down([["DATA", change as MapChange<K, V>]]);
+			}
+			for (const prep of depBatch(ctx, 1) ?? []) {
+				for (const change of (prep as SnapshotPrep<K, V>).expired) ctx.down([["DATA", change]]);
+			}
+		},
+		opts: { partial: true },
+	};
+	const delta = graph
+		? graph.initNode(deltaOp, [apply as Node<unknown>, snapshotPrep as Node<unknown>], {
+				name: name ? `${name}.delta` : undefined,
+				meta: { kind: "collection_delta", collection: "reactiveMap" },
+				...(restorable ? { restore: { ref: "reactiveMap.delta" } } : {}),
+			})
+		: initNode(deltaOp, [apply as Node<unknown>, snapshotPrep as Node<unknown>], {
+				...base,
+				name: name ? `${name}.delta` : undefined,
+			});
+	const snapshotOp: Operator<unknown, ReadonlyMap<K, V>> = {
+		factory: "reactiveMap.snapshot",
+		body: (ctx: Ctx) => {
+			for (const prep of depBatch(ctx, 0) ?? []) {
+				ctx.down([["DATA", (prep as SnapshotPrep<K, V>).snapshot]]);
+			}
+		},
+		opts: { partial: true },
+	};
+	const snapshot = graph
+		? graph.initNode(snapshotOp, [snapshotPrep as Node<unknown>], {
+				name: name ? `${name}.snapshot` : undefined,
+				meta: { kind: "collection_snapshot", collection: "reactiveMap" },
+				...(restorable ? { restore: { ref: "reactiveMap.snapshot" } } : {}),
+			})
+		: initNode(snapshotOp, [snapshotPrep as Node<unknown>], {
+				...base,
+				name: name ? `${name}.snapshot` : undefined,
+			});
+	if (restorable) {
+		registerBackendStateContributor(intent as Node<unknown>, () => backend.checkpointEntries());
+	}
+	const releaseApply = graph
+		? graph.retain(apply, { reason: "reactiveMap.apply" })
+		: apply.subscribe(() => {});
+	const binds: Array<() => void> = [];
+
+	function doSet(key: K, value: V, ttl?: number): void {
+		if (ttl !== undefined) validateTtl(ttl);
+		intent.down([
+			["DATA", ttl === undefined ? { kind: "set", key, value } : { kind: "set", key, value, ttl }],
+		]);
+	}
+
+	function read(key: K): Lookup<V> {
+		const r = backend.lookup(key);
+		if (!r.found && r.expired) intent.down([["DATA", { kind: "pruneKey", key }]]);
+		return r;
+	}
+
+	function selectedSnapshot(predicate: (value: V, key: K) => boolean): ReadonlyMap<K, V> {
+		const out = new Map<K, V>();
+		for (const [key, value] of backend.snapshot()) {
+			if (predicate(value, key)) out.set(key, value);
+		}
+		return out;
+	}
+
+	function select(
+		predicate: (value: V, key: K) => boolean,
+	): ReactiveView<MapChange<K, V>, ReadonlyMap<K, V>> {
+		if (typeof predicate !== "function")
+			throw new TypeError("reactiveMap.select: predicate must be a function");
+		const cached = selectMemo.get(predicate);
+		if (cached !== undefined) return cached;
+		let view: ReactiveView<MapChange<K, V>, ReadonlyMap<K, V>>;
+		view = lightReactiveView<MapChange<K, V>, ReadonlyMap<K, V>>(delta as Node<unknown>, {
+			dispatcher,
+			graph,
+			factory: "reactiveMap.select",
+			name: name ? `${name}.select#${selectSeq++}` : undefined,
+			materializeSnapshot: () => selectedSnapshot(predicate),
+			onDispose: () => {
+				selectMemo.deleteValue(view);
+			},
+		});
+		selectMemo.set(predicate, view);
+		return view;
+	}
+
+	return {
+		delta,
+		snapshot,
+		pullId,
+
+		get size(): number {
+			return backend.size;
+		},
+		get(key: K): V | undefined {
+			const r = read(key);
+			return r.found ? r.value : undefined;
+		},
+		has(key: K): boolean {
+			return read(key).found;
+		},
+		toMap(): ReadonlyMap<K, V> {
+			intent.down([["DATA", { kind: "pruneExpired" }]]);
+			return backend.snapshot();
+		},
+		select,
+
+		set(key: K, value: V, opts?: { ttl?: number }): void {
+			doSet(key, value, opts?.ttl);
+		},
+		setMany(entries: Iterable<readonly [K, V]>, opts?: { ttl?: number }): void {
+			for (const [k, v] of entries) doSet(k, v, opts?.ttl);
+		},
+		delete(key: K): void {
+			intent.down([["DATA", { kind: "delete", key }]]);
+		},
+		deleteMany(keys: Iterable<K>): void {
+			for (const k of keys) {
+				intent.down([["DATA", { kind: "delete", key: k }]]);
+			}
+		},
+		clear(): void {
+			intent.down([["DATA", { kind: "clear" }]]);
+		},
+		pruneExpired(): void {
+			intent.down([["DATA", { kind: "pruneExpired" }]]);
+		},
+
+		setFrom(src: Node<readonly [K, V]>): () => void {
+			if (graph === undefined)
+				throw new Error(
+					"reactiveMap.setFrom requires options.graph so the input fold is describe-visible (D61)",
+				);
+			const op: Operator<readonly [K, V], MapIntent<K, V>> = {
+				factory: "reactiveMap.bindSource",
+				body: (ctx: Ctx) => {
+					try {
+						for (const [k, v] of (depBatch(ctx, 0) ?? []) as readonly (readonly [K, V])[]) {
+							ctx.down([["DATA", { kind: "set", key: k, value: v }]]);
+						}
+					} catch (e) {
+						ctx.down([["ERROR", errorPayload(e, "reactiveMap.bindSource failed")]]);
+					}
+				},
+			};
+			const folder = graph.initNode(op, [src], {
+				name: name ? `${name}.bind#${bindSeq++}` : undefined,
+				meta: { kind: "collection_bind_source", collection: "reactiveMap" },
+			});
+			bindDeps.add(folder as Node<unknown>);
+			apply.subscribeDep(folder as Node<unknown>, applyBody);
+			let active = true;
+			const dispose = () => {
+				if (!active) return;
+				active = false;
+				apply.unsubscribeDep(folder as Node<unknown>, applyBody);
+			};
+			binds.push(dispose);
+			return dispose;
+		},
+		dispose(): void {
+			selectMemo.disposeAll();
+			for (const d of binds) d();
+			binds.length = 0;
+			releaseApply();
+		},
+	};
+}
diff --git a/packages/ts/src/graph/describe.ts b/packages/ts/src/graph/describe.ts
new file mode 100644
index 00000000..7cacf6bf
--- /dev/null
+++ b/packages/ts/src/graph/describe.ts
@@ -0,0 +1,122 @@
+/**
+ * topology()/describe() snapshot shapes (R-describe / D39 / D51 / D173).
+ *
+ * topology() is the current pure-structure snapshot direction (D173). describe()
+ * remains the richer developer inspection snapshot over the same live topology
+ * truth source, adding runtime status/value/version fields.
+ */
+
+import type { Status } from "../node/node.js";
+import type { NodeVersion } from "../node/versioning.js";
+
+export interface GraphTopologyNode {
+	/** Stable mount-aware `::` path (auto-numbered when unnamed). Edge key. */
+	id: string;
+	/** Optional debug name. */
+	name?: string;
+	/** Operator/verb real name (D6/L1.5 — "map"/"state", not "derived"). */
+	factory: string;
+	/** Dep ids (R-edges-derived: edges are a pure fn of live deps). */
+	deps: string[];
+	/** Static annotations attached via g.* opts (R-meta-presentation). */
+	meta?: Record<string, unknown>;
+}
+
+export interface GraphTopologyEdge {
+	from: string;
+	to: string;
+}
+
+export interface GraphTopologySnapshot {
+	name?: string;
+	nodes: GraphTopologyNode[];
+	edges: GraphTopologyEdge[];
+	subgraphs?: GraphTopologySnapshot[];
+}
+
+export interface DescribeNode extends GraphTopologyNode {
+	/** R-status-enum (7). */
+	status: Status;
+	/** Cache snapshot at call time; field ABSENT = SENTINEL / never-emitted. */
+	value?: unknown;
+	/** D109 node runtime version metadata; absent when versioning:false. */
+	version?: NodeVersion;
+}
+
+export interface DescribeEdge extends GraphTopologyEdge {}
+
+export interface DescribeSnapshot extends GraphTopologySnapshot {
+	name?: string;
+	nodes: DescribeNode[];
+	edges: DescribeEdge[];
+	subgraphs?: DescribeSnapshot[];
+}
+
+export interface DescribeOpts {
+	/** Causal-chain mode: filter to nodes on a path from→to (R-describe). */
+	explain?: { from: string; to: string };
+}
+
+/** Project a rich describe snapshot into the D173 pure-structure topology shape. */
+export function topologyFromDescribe(snapshot: DescribeSnapshot): GraphTopologySnapshot {
+	const nodes = snapshot.nodes.map((node) => {
+		const topologyNode: GraphTopologyNode = {
+			id: node.id,
+			factory: node.factory,
+			deps: [...node.deps],
+		};
+		if (node.name !== undefined) topologyNode.name = node.name;
+		if (node.meta !== undefined) topologyNode.meta = cloneTopologyMeta(node.meta);
+		return topologyNode;
+	});
+	const out: GraphTopologySnapshot = {
+		nodes,
+		edges: snapshot.edges.map((edge) => ({ from: edge.from, to: edge.to })),
+	};
+	if (snapshot.name !== undefined) out.name = snapshot.name;
+	if (snapshot.subgraphs !== undefined)
+		out.subgraphs = snapshot.subgraphs.map(topologyFromDescribe);
+	return out;
+}
+
+function cloneTopologyMeta(meta: Record<string, unknown>): Record<string, unknown> {
+	return cloneTopologyValue(meta, new WeakMap()) as Record<string, unknown>;
+}
+
+function cloneTopologyValue(value: unknown, seen: WeakMap<object, unknown>): unknown {
+	if (value === null) return null;
+	const kind = typeof value;
+	if (kind === "string" || kind === "boolean") return value;
+	if (kind === "number") {
+		if (!Number.isFinite(value)) {
+			throw new Error("topology(): meta must be finite JSON-compatible data (D39/D173)");
+		}
+		return value;
+	}
+	if (kind !== "object") {
+		throw new Error("topology(): meta must be JSON-compatible data (D39/D173)");
+	}
+	const objectValue = value as object;
+	const cached = seen.get(objectValue);
+	if (cached !== undefined) return cached;
+	if (Array.isArray(value)) {
+		const out = new Array<unknown>(value.length);
+		seen.set(objectValue, out);
+		for (let i = 0; i < value.length; i += 1) {
+			if (!(i in value)) {
+				throw new Error("topology(): meta arrays must be dense JSON-compatible data (D39/D173)");
+			}
+			out[i] = cloneTopologyValue(value[i], seen);
+		}
+		return out;
+	}
+	const proto = Object.getPrototypeOf(objectValue);
+	if (proto !== Object.prototype && proto !== null) {
+		throw new Error("topology(): meta must be plain JSON-compatible data (D39/D173)");
+	}
+	const out: Record<string, unknown> = {};
+	seen.set(objectValue, out);
+	for (const [key, item] of Object.entries(value as Record<string, unknown>))
+		out[key] = cloneTopologyValue(item, seen);
+	return out;
+}
diff --git a/packages/ts/src/graph/diagnostics.ts b/packages/ts/src/graph/diagnostics.ts
new file mode 100644
index 00000000..7890d5b1
--- /dev/null
+++ b/packages/ts/src/graph/diagnostics.ts
@@ -0,0 +1,424 @@
+/**
+ * Pure graph diagnostics over {@link DescribeSnapshot} (D39/R-describe).
+ *
+ * These helpers re-derive the useful frozen pure-ts inspection utilities without restoring
+ * graph methods, path facades, actors, soft edges, or storage coupling. They operate only on the
+ * public JSON-serializable describe shape; the live topology truth remains R-edges-derived.
+ */
+
+import type { DescribeNode, DescribeSnapshot } from "./describe.js";
+
+export type ReachableDirection = "upstream" | "downstream";
+
+export interface ReachableOptions {
+	/** Maximum hop distance to walk. Omit for unbounded. */
+	maxDepth?: number;
+	/** Walk both upstream and downstream, ignoring `direction`. */
+	both?: boolean;
+	/** Return depths/truncation metadata instead of only sorted paths. */
+	withDetail?: boolean;
+}
+
+export interface ReachableResult {
+	/** Reachable node ids, excluding the start id, sorted deterministically. */
+	paths: readonly string[];
+	/** Hop depth by reachable node id. */
+	depths: Readonly<Record<string, number>>;
+	/** True when `maxDepth` cut off at least one still-expandable frontier node. */
+	truncated: boolean;
+}
+
+export type ExplainPathReason =
+	| "ok"
+	| "no-such-from"
+	| "no-such-to"
+	| "no-path"
+	| "max-depth-exceeded";
+
+export interface ExplainPathOptions {
+	/** Maximum hop distance to search. Omit for unbounded. */
+	maxDepth?: number;
+	/** When `from === to`, search for a non-trivial cycle before returning the trivial step. */
+	findCycle?: boolean;
+}
+
+export interface CausalStep {
+	/** Mount-aware describe node id. */
+	id: string;
+	/** Operator/verb factory name from describe. */
+	factory: string;
+	/** Status as of the source snapshot. */
+	status: DescribeNode["status"];
+	/** Cached value when present; absence still means SENTINEL. */
+	value?: unknown;
+	/** Hop distance from the `from` node. */
+	hop: number;
+	/** First dep slot in the next step that points at this step, when the edge is dep-derived. */
+	depIndex?: number;
+	/** All matching dep slots when the next step depends on this step more than once. */
+	depIndices?: readonly number[];
+}
+
+export interface CausalChain {
+	from: string;
+	to: string;
+	found: boolean;
+	reason: ExplainPathReason;
+	steps: readonly CausalStep[];
+	text: string;
+	toJSON(): {
+		from: string;
+		to: string;
+		found: boolean;
+		reason: ExplainPathReason;
+		steps: readonly CausalStep[];
+	};
+}
+
+export interface IslandReport {
+	/** Node id from the flattened snapshot. */
+	id: string;
+	/** Factory/kind for quick triage. */
+	factory: string;
+}
+
+export interface ValidateNoIslandsResult {
+	ok: boolean;
+	/** Nodes with zero deps and zero dependents, sorted by id. */
+	orphans: readonly IslandReport[];
+	summary(): string;
+}
+
+interface SnapshotIndex {
+	nodes: Map<string, DescribeNode>;
+	outgoing: Map<string, Set<string>>;
+	incoming: Map<string, Set<string>>;
+}
+
+function compareCodeUnit(a: string, b: string): number {
+	return a < b ? -1 : a > b ? 1 : 0;
+}
+
+function assertMaxDepth(caller: string, maxDepth: number | undefined): void {
+	if (maxDepth !== undefined && (!Number.isInteger(maxDepth) || maxDepth < 0)) {
+		throw new Error(`${caller}: maxDepth must be an integer >= 0`);
+	}
+}
+
+function addEdge(map: Map<string, Set<string>>, from: string, to: string): void {
+	let set = map.get(from);
+	if (set === undefined) {
+		set = new Set();
+		map.set(from, set);
+	}
+	set.add(to);
+}
+
+function flattenSnapshots(snapshot: DescribeSnapshot): DescribeSnapshot[] {
+	const out: DescribeSnapshot[] = [];
+	const stack = [snapshot];
+	while (stack.length > 0) {
+		const cur = stack.pop() as DescribeSnapshot;
+		out.push(cur);
+		if (cur.subgraphs) {
+			for (let i = cur.subgraphs.length - 1; i >= 0; i -= 1) stack.push(cur.subgraphs[i]);
+		}
+	}
+	return out;
+}
+
+function indexSnapshot(snapshot: DescribeSnapshot): SnapshotIndex {
+	const nodes = new Map<string, DescribeNode>();
+	const outgoing = new Map<string, Set<string>>();
+	const incoming = new Map<string, Set<string>>();
+	for (const snap of flattenSnapshots(snapshot)) {
+		for (const n of snap.nodes) {
+			nodes.set(n.id, n);
+			if (!outgoing.has(n.id)) outgoing.set(n.id, new Set());
+			if (!incoming.has(n.id)) incoming.set(n.id, new Set());
+		}
+	}
+	for (const n of nodes.values()) {
+		for (const dep of n.deps) {
+			if (!dep || !nodes.has(dep)) continue;
+			addEdge(outgoing, dep, n.id);
+			addEdge(incoming, n.id, dep);
+		}
+	}
+	for (const snap of flattenSnapshots(snapshot)) {
+		for (const edge of snap.edges) {
+			if (!edge.from || !edge.to) continue;
+			if (!nodes.has(edge.from) || !nodes.has(edge.to)) continue;
+			addEdge(outgoing, edge.from, edge.to);
+			addEdge(incoming, edge.to, edge.from);
+		}
+	}
+	return { nodes, outgoing, incoming };
+}
+
+function adjacent(
+	idx: SnapshotIndex,
+	id: string,
+	direction: ReachableDirection,
+	both: boolean | undefined,
+): Set<string> {
+	return both === true
+		? new Set([...(idx.incoming.get(id) ?? []), ...(idx.outgoing.get(id) ?? [])])
+		: direction === "upstream"
+			? (idx.incoming.get(id) ?? new Set<string>())
+			: (idx.outgoing.get(id) ?? new Set<string>());
+}
+
+/**
+ * Return node ids reachable from `from` through describe deps/edges.
+ *
+ * `upstream` follows dep edges toward causes; `downstream` follows reverse deps toward effects.
+ * The helper is intentionally pure over `DescribeSnapshot` (D39/D51): it never reads Nodes.
+ */
+export function reachable(
+	snapshot: DescribeSnapshot,
+	from: string,
+	direction: ReachableDirection,
+	options?: ReachableOptions & { withDetail: true },
+): ReachableResult;
+export function reachable(
+	snapshot: DescribeSnapshot,
+	from: string,
+	direction: ReachableDirection,
+	options?: ReachableOptions,
+): readonly string[];
+export function reachable(
+	snapshot: DescribeSnapshot,
+	from: string,
+	direction: ReachableDirection,
+	options: ReachableOptions = {},
+): readonly string[] | ReachableResult {
+	if (!options.both && direction !== "upstream" && direction !== "downstream") {
+		throw new Error(`reachable: direction must be "upstream" or "downstream"`);
+	}
+	assertMaxDepth("reachable", options.maxDepth);
+	const empty: ReachableResult = { paths: [], depths: {}, truncated: false };
+	if (from === "") return options.withDetail ? empty : empty.paths;
+
+	const idx = indexSnapshot(snapshot);
+	if (!idx.nodes.has(from)) return options.withDetail ? empty : empty.paths;
+	if (options.maxDepth === 0) {
+		const truncated = adjacent(idx, from, direction, options.both).size > 0;
+		return options.withDetail ? { ...empty, truncated } : empty.paths;
+	}
+	const depths = new Map<string, number>();
+	const seen = new Set<string>([from]);
+	const queue: Array<{ id: string; depth: number }> = [{ id: from, depth: 0 }];
+	let truncated = false;
+	for (let head = 0; head < queue.length; head += 1) {
+		const cur = queue[head] as { id: string; depth: number };
+		const next = adjacent(idx, cur.id, direction, options.both);
+		if (options.maxDepth !== undefined && cur.depth >= options.maxDepth) {
+			if (next.size > 0) truncated = true;
+			continue;
+		}
+		for (const id of next) {
+			if (seen.has(id)) continue;
+			seen.add(id);
+			const depth = cur.depth + 1;
+			depths.set(id, depth);
+			queue.push({ id, depth });
+		}
+	}
+	const paths = [...depths.keys()].sort(compareCodeUnit);
+	if (!options.withDetail) return paths;
+	return {
+		paths,
+		depths: Object.fromEntries([...depths.entries()].sort(([a], [b]) => compareCodeUnit(a, b))),
+		truncated,
+	};
+}
+
+function depIndices(next: DescribeNode | undefined, prevId: string): readonly number[] | undefined {
+	if (next === undefined) return undefined;
+	const indices: number[] = [];
+	for (let i = 0; i < next.deps.length; i += 1) {
+		if (next.deps[i] === prevId) indices.push(i);
+	}
+	return indices.length > 0 ? indices : undefined;
+}
+
+function stepFor(
+	node: DescribeNode,
+	hop: number,
+	edgeToNext?: { next: DescribeNode; prevId: string },
+): CausalStep {
+	const indices = edgeToNext ? depIndices(edgeToNext.next, edgeToNext.prevId) : undefined;
+	const out: CausalStep = {
+		id: node.id,
+		factory: node.factory,
+		status: node.status,
+		hop,
+	};
+	if ("value" in node) out.value = node.value;
+	if (indices !== undefined) {
+		out.depIndex = indices[0];
+		if (indices.length > 1) out.depIndices = indices;
+	}
+	return out;
+}
+
+function makeChain(
+	from: string,
+	to: string,
+	reason: ExplainPathReason,
+	steps: readonly CausalStep[],
+): CausalChain {
+	const found = reason === "ok";
+	const text = found
+		? steps.map((s) => s.id).join(" -> ")
+		: `explainPath: ${reason} from '${from}' to '${to}'`;
+	return {
+		from,
+		to,
+		found,
+		reason,
+		steps,
+		text,
+		toJSON: () => ({ from, to, found, reason, steps }),
+	};
+}
+
+function shortestPath(
+	idx: SnapshotIndex,
+	from: string,
+	to: string,
+	maxDepth: number | undefined,
+): { path: string[]; truncated: boolean } | undefined {
+	const pred = new Map<string, string>();
+	const seen = new Set<string>([from]);
+	const queue: Array<{ id: string; depth: number }> = [{ id: from, depth: 0 }];
+	let truncated = false;
+	for (let head = 0; head < queue.length; head += 1) {
+		const cur = queue[head] as { id: string; depth: number };
+		const next = idx.outgoing.get(cur.id) ?? new Set<string>();
+		if (maxDepth !== undefined && cur.depth >= maxDepth) {
+			if (next.size > 0) truncated = true;
+			continue;
+		}
+		for (const id of next) {
+			if (seen.has(id)) continue;
+			seen.add(id);
+			pred.set(id, cur.id);
+			if (id === to) {
+				const path = [to];
+				let p = to;
+				while (p !== from) {
+					p = pred.get(p) as string;
+					path.push(p);
+				}
+				path.reverse();
+				return { path, truncated };
+			}
+			queue.push({ id, depth: cur.depth + 1 });
+		}
+	}
+	return truncated ? { path: [], truncated: true } : undefined;
+}
+
+function shortestCycle(
+	idx: SnapshotIndex,
+	from: string,
+	maxDepth: number | undefined,
+): { path: string[]; truncated: boolean } | undefined {
+	const first = idx.outgoing.get(from) ?? new Set<string>();
+	if (maxDepth === 0) return first.size > 0 ? { path: [], truncated: true } : undefined;
+	const queue: Array<{ id: string; depth: number; path: string[] }> = [];
+	const seen = new Set<string>();
+	for (const id of first) {
+		if (id === from) return { path: [from, from], truncated: false };
+		seen.add(id);
+		queue.push({ id, depth: 1, path: [from, id] });
+	}
+	let truncated = false;
+	for (let head = 0; head < queue.length; head += 1) {
+		const cur = queue[head] as { id: string; depth: number; path: string[] };
+		const next = idx.outgoing.get(cur.id) ?? new Set<string>();
+		if (maxDepth !== undefined && cur.depth >= maxDepth) {
+			if (next.size > 0) truncated = true;
+			continue;
+		}
+		for (const id of next) {
+			if (id === from) return { path: [...cur.path, from], truncated: false };
+			if (seen.has(id)) continue;
+			seen.add(id);
+			queue.push({ id, depth: cur.depth + 1, path: [...cur.path, id] });
+		}
+	}
+	return truncated ? { path: [], truncated: true } : undefined;
+}
+
+function materializePath(idx: SnapshotIndex, path: readonly string[]): readonly CausalStep[] {
+	return path.map((id, i) => {
+		const node = idx.nodes.get(id) as DescribeNode;
+		const next = path[i + 1] ? idx.nodes.get(path[i + 1]) : undefined;
+		return stepFor(node, i, next ? { next, prevId: id } : undefined);
+	});
+}
+
+/**
+ * Explain the shortest describe-edge path from `from` to `to`.
+ *
+ * This is the rich companion to `Graph.describe({ explain })`: it reports found/no-path
+ * status and per-hop metadata, but remains a pure helper over the snapshot.
+ */
+export function explainPath(
+	snapshot: DescribeSnapshot,
+	from: string,
+	to: string,
+	options: ExplainPathOptions = {},
+): CausalChain {
+	assertMaxDepth("explainPath", options.maxDepth);
+	const idx = indexSnapshot(snapshot);
+	if (!idx.nodes.has(from)) return makeChain(from, to, "no-such-from", []);
+	if (!idx.nodes.has(to)) return makeChain(from, to, "no-such-to", []);
+	if (options.maxDepth === 0 && from !== to) return makeChain(from, to, "no-path", []);
+
+	if (from === to && options.findCycle !== true) {
+		return makeChain(from, to, "ok", [stepFor(idx.nodes.get(from) as DescribeNode, 0)]);
+	}
+	if (from === to && options.findCycle === true) {
+		const cycle = shortestCycle(idx, from, options.maxDepth);
+		if (cycle !== undefined && cycle.path.length > 0) {
+			return makeChain(from, to, "ok", materializePath(idx, cycle.path));
+		}
+		if (cycle?.truncated) return makeChain(from, to, "max-depth-exceeded", []);
+		return makeChain(from, to, "ok", [stepFor(idx.nodes.get(from) as DescribeNode, 0)]);
+	}
+	const found = shortestPath(idx, from, to, options.maxDepth);
+	if (found !== undefined && found.path.length > 0) {
+		return makeChain(from, to, "ok", materializePath(idx, found.path));
+	}
+	return makeChain(from, to, found?.truncated ? "max-depth-exceeded" : "no-path", []);
+}
+
+/** Detect nodes with zero deps and zero dependents in a describe snapshot. */
+export function validateNoIslands(snapshot: DescribeSnapshot): ValidateNoIslandsResult {
+	const idx = indexSnapshot(snapshot);
+	const orphans: IslandReport[] = [];
+	for (const node of idx.nodes.values()) {
+		const hasDeps = node.deps.length > 0 || (idx.incoming.get(node.id)?.size ?? 0) > 0;
+		const hasDependents = (idx.outgoing.get(node.id)?.size ?? 0) > 0;
+		if (!hasDeps && !hasDependents && !node.id.startsWith("__internal__/")) {
+			orphans.push({ id: node.id, factory: node.factory });
+		}
+	}
+	orphans.sort((a, b) => compareCodeUnit(a.id, b.id));
+	return {
+		ok: orphans.length === 0,
+		orphans,
+		summary(): string {
+			if (orphans.length === 0) return "validateNoIslands: ok (no islands)";
+			const head = orphans
+				.slice(0, 3)
+				.map((o) => `${o.id} (${o.factory})`)
+				.join(", ");
+			return `validateNoIslands: ${orphans.length} island node(s) - ${head}${orphans.length > 3 ? ", ..." : ""}`;
+		},
+	};
+}
diff --git a/packages/ts/src/graph/environment.ts b/packages/ts/src/graph/environment.ts
new file mode 100644
index 00000000..1b599732
--- /dev/null
+++ b/packages/ts/src/graph/environment.ts
@@ -0,0 +1,414 @@
+/**
+ * Graph-owned environment driver bag (D130/D131).
+ *
+ * Drivers host process/network/messaging/runtime boundary work outside the synchronous wave core.
+ * The bag is graph-local and is read from ctx by source/adapter bodies.
+ */
+
+export type DriverCancel = () => void;
+
+export type DriverResult<T> =
+	| { readonly ok: true; readonly value: T }
+	| { readonly ok: false; readonly error: unknown };
+
+export interface ProcessCommand {
+	readonly program: string;
+	readonly args: readonly string[];
+	readonly cwd?: string;
+	readonly env?: readonly (readonly [string, string])[];
+}
+
+export interface ProcessResult {
+	readonly stdout: string;
+	readonly stderr: string;
+	readonly exitCode: number | null;
+	readonly signal: string | null;
+}
+
+export interface HttpRequest {
+	readonly method: string;
+	readonly url: string;
+	readonly headers?: readonly (readonly [string, string])[];
+	readonly body?: Uint8Array | string;
+}
+
+export interface HttpResponse {
+	readonly status: number;
+	readonly headers: readonly (readonly [string, string])[];
+	readonly body: Uint8Array;
+}
+
+export interface SseRequest {
+	readonly url: string;
+	readonly headers?: readonly (readonly [string, string])[];
+}
+
+export interface SseEvent {
+	readonly event?: string;
+	readonly data: string;
+	readonly id?: string;
+	readonly retryMs?: number;
+}
+
+export type SseDriverEvent =
+	| { readonly kind: "event"; readonly event: SseEvent }
+	| { readonly kind: "error"; readonly error: unknown }
+	| { readonly kind: "complete" };
+
+export interface WebSocketRequest {
+	readonly url: string;
+	readonly headers?: readonly (readonly [string, string])[];
+}
+
+export type WebSocketEvent =
+	| { readonly kind: "open" }
+	| { readonly kind: "text"; readonly data: string }
+	| { readonly kind: "binary"; readonly data: Uint8Array }
+	| { readonly kind: "close"; readonly code?: number; readonly reason?: string };
+
+export interface WebSocketSend {
+	readonly data: string | Uint8Array;
+}
+
+export interface WebSocketSendResult {
+	readonly sent: true;
+}
+
+/** Live WebSocket session handle for D133 SessionBundle adapters. */
+export interface WebSocketSessionHandle {
+	send(
+		message: WebSocketSend,
+		callback: (result: DriverResult<WebSocketSendResult>) => void,
+	): DriverCancel;
+	close(code?: number, reason?: string): void;
+	cancel(): void;
+}
+
+export type WebSocketDriverEvent =
+	| { readonly kind: "event"; readonly event: WebSocketEvent }
+	| { readonly kind: "error"; readonly error: unknown }
+	| { readonly kind: "complete" };
+
+export interface WebhookRegistration {
+	readonly id: string;
+	readonly method?: string;
+	readonly path?: string;
+}
+
+export interface WebhookEvent {
+	readonly registrationId: string;
+	readonly method: string;
+	readonly path: string;
+	readonly headers: readonly (readonly [string, string])[];
+	readonly query: readonly (readonly [string, string])[];
+	readonly body: Uint8Array;
+}
+
+export type WebhookDriverEvent =
+	| { readonly kind: "event"; readonly event: WebhookEvent }
+	| { readonly kind: "error"; readonly error: unknown }
+	| { readonly kind: "complete" };
+
+export interface LocalProcessDriver {
+	run(
+		command: ProcessCommand,
+		callback: (result: DriverResult<ProcessResult>) => void,
+	): DriverCancel;
+}
+
+export interface LocalHttpDriver {
+	request(
+		request: HttpRequest,
+		callback: (result: DriverResult<HttpResponse>) => void,
+	): DriverCancel;
+}
+
+export interface LocalSseDriver {
+	connect(request: SseRequest, callback: (event: SseDriverEvent) => void): DriverCancel;
+}
+
+export interface LocalWebSocketDriver {
+	connect(request: WebSocketRequest, callback: (event: WebSocketDriverEvent) => void): DriverCancel;
+	send?(
+		request: WebSocketRequest,
+		message: WebSocketSend,
+		callback: (result: DriverResult<WebSocketSendResult>) => void,
+	): DriverCancel;
+	/** Open a live bidirectional session; unlike send(), outbound messages use this same connection. */
+	connectSession?(
+		request: WebSocketRequest,
+		callback: (event: WebSocketDriverEvent) => void,
+	): WebSocketSessionHandle;
+}
+
+export interface LocalWebhookDriver {
+	register(
+		registration: WebhookRegistration,
+		callback: (event: WebhookDriverEvent) => void,
+	): DriverCancel;
+}
+
+export interface FetchResponseLike {
+	readonly status: number;
+	readonly headers?: { forEach?(fn: (value: string, key: string) => void): void };
+	arrayBuffer(): PromiseLike<ArrayBuffer>;
+}
+
+export type FetchLike = (
+	url: string,
+	init?: {
+		readonly method?: string;
+		readonly headers?: readonly (readonly [string, string])[];
+		readonly body?: Uint8Array | string;
+		readonly signal?: AbortSignal;
+	},
+) => PromiseLike<FetchResponseLike>;
+
+export interface WebSocketLike {
+	send(data: string | Uint8Array): void;
+	close(code?: number, reason?: string): void;
+	addEventListener(
+		type: "open" | "message" | "error" | "close",
+		listener: (event: unknown) => void,
+	): void;
+	removeEventListener(
+		type: "open" | "message" | "error" | "close",
+		listener: (event: unknown) => void,
+	): void;
+}
+
+export type WebSocketConstructorLike = new (url: string) => WebSocketLike;
+
+export interface EnvironmentDriversInit {
+	readonly process?: LocalProcessDriver;
+	readonly http?: LocalHttpDriver;
+	readonly sse?: LocalSseDriver;
+	readonly websocket?: LocalWebSocketDriver;
+	readonly webhook?: LocalWebhookDriver;
+}
+
+export class EnvironmentDrivers {
+	readonly process?: LocalProcessDriver;
+	readonly http?: LocalHttpDriver;
+	readonly sse?: LocalSseDriver;
+	readonly websocket?: LocalWebSocketDriver;
+	readonly webhook?: LocalWebhookDriver;
+
+	constructor(init: EnvironmentDriversInit = {}) {
+		this.process = init.process;
+		this.http = init.http;
+		this.sse = init.sse;
+		this.websocket = init.websocket;
+		this.webhook = init.webhook;
+		Object.freeze(this);
+	}
+
+	static empty(): EnvironmentDrivers {
+		return EMPTY_ENVIRONMENT;
+	}
+
+	withProcess(driver: LocalProcessDriver): EnvironmentDrivers {
+		return new EnvironmentDrivers({ ...this, process: driver });
+	}
+
+	withHttp(driver: LocalHttpDriver): EnvironmentDrivers {
+		return new EnvironmentDrivers({ ...this, http: driver });
+	}
+
+	withSse(driver: LocalSseDriver): EnvironmentDrivers {
+		return new EnvironmentDrivers({ ...this, sse: driver });
+	}
+
+	withWebSocket(driver: LocalWebSocketDriver): EnvironmentDrivers {
+		return new EnvironmentDrivers({ ...this, websocket: driver });
+	}
+
+	withWebhook(driver: LocalWebhookDriver): EnvironmentDrivers {
+		return new EnvironmentDrivers({ ...this, webhook: driver });
+	}
+
+	processDriver(): LocalProcessDriver | undefined {
+		return this.process;
+	}
+
+	httpDriver(): LocalHttpDriver | undefined {
+		return this.http;
+	}
+
+	sseDriver(): LocalSseDriver | undefined {
+		return this.sse;
+	}
+
+	webSocketDriver(): LocalWebSocketDriver | undefined {
+		return this.websocket;
+	}
+
+	webhookDriver(): LocalWebhookDriver | undefined {
+		return this.webhook;
+	}
+}
+
+const EMPTY_ENVIRONMENT = new EnvironmentDrivers();
+
+export function fetchHttpDriver(fetchFn: FetchLike = requireGlobalFetch()): LocalHttpDriver {
+	return {
+		request(request, callback) {
+			const controller = new AbortController();
+			void Promise.resolve(
+				fetchFn(request.url, {
+					method: request.method,
+					headers: request.headers,
+					body: request.body,
+					signal: controller.signal,
+				}),
+			).then(
+				async (response) => {
+					const headers: Array<readonly [string, string]> = [];
+					response.headers?.forEach?.((value, key) => {
+						headers.push([key, value]);
+					});
+					const body = new Uint8Array(await response.arrayBuffer());
+					callback({ ok: true, value: { status: response.status, headers, body } });
+				},
+				(error) => callback({ ok: false, error }),
+			);
+			return () => controller.abort();
+		},
+	};
+}
+
+export function domWebSocketDriver(
+	WebSocketCtor: WebSocketConstructorLike = requireGlobalWebSocket(),
+): LocalWebSocketDriver {
+	return {
+		connect(request, callback) {
+			const socket = new WebSocketCtor(request.url);
+			const onOpen = () => callback({ kind: "event", event: { kind: "open" } });
+			const onMessage = (event: unknown) => {
+				const data = (event as { data?: unknown }).data;
+				if (typeof data === "string") callback({ kind: "event", event: { kind: "text", data } });
+				else if (data instanceof Uint8Array) {
+					callback({ kind: "event", event: { kind: "binary", data } });
+				} else {
+					callback({ kind: "event", event: { kind: "text", data: String(data ?? "") } });
+				}
+			};
+			const onError = (event: unknown) => callback({ kind: "error", error: event });
+			const onClose = (event: unknown) => {
+				const close = event as { code?: number; reason?: string };
+				callback({
+					kind: "event",
+					event: { kind: "close", code: close.code, reason: close.reason },
+				});
+				callback({ kind: "complete" });
+			};
+			socket.addEventListener("open", onOpen);
+			socket.addEventListener("message", onMessage);
+			socket.addEventListener("error", onError);
+			socket.addEventListener("close", onClose);
+			return () => {
+				socket.removeEventListener("open", onOpen);
+				socket.removeEventListener("message", onMessage);
+				socket.removeEventListener("error", onError);
+				socket.removeEventListener("close", onClose);
+				socket.close();
+			};
+		},
+		send(request, message, callback) {
+			const socket = new WebSocketCtor(request.url);
+			let settled = false;
+			const finish = (result: DriverResult<WebSocketSendResult>) => {
+				if (settled) return;
+				settled = true;
+				callback(result);
+				socket.close();
+			};
+			const onOpen = () => {
+				try {
+					socket.send(message.data);
+					finish({ ok: true, value: { sent: true } });
+				} catch (error) {
+					finish({ ok: false, error });
+				}
+			};
+			const onError = (event: unknown) => finish({ ok: false, error: event });
+			socket.addEventListener("open", onOpen);
+			socket.addEventListener("error", onError);
+			return () => {
+				settled = true;
+				socket.removeEventListener("open", onOpen);
+				socket.removeEventListener("error", onError);
+				socket.close();
+			};
+		},
+		connectSession(request, callback) {
+			const socket = new WebSocketCtor(request.url);
+			let active = true;
+			const onOpen = () => callback({ kind: "event", event: { kind: "open" } });
+			const onMessage = (event: unknown) => {
+				const data = (event as { data?: unknown }).data;
+				if (typeof data === "string") callback({ kind: "event", event: { kind: "text", data } });
+				else if (data instanceof Uint8Array) {
+					callback({ kind: "event", event: { kind: "binary", data } });
+				} else {
+					callback({ kind: "event", event: { kind: "text", data: String(data ?? "") } });
+				}
+			};
+			const onError = (event: unknown) => callback({ kind: "error", error: event });
+			const onClose = (event: unknown) => {
+				const close = event as { code?: number; reason?: string };
+				callback({
+					kind: "event",
+					event: { kind: "close", code: close.code, reason: close.reason },
+				});
+				callback({ kind: "complete" });
+			};
+			const removeListeners = () => {
+				socket.removeEventListener("open", onOpen);
+				socket.removeEventListener("message", onMessage);
+				socket.removeEventListener("error", onError);
+				socket.removeEventListener("close", onClose);
+			};
+			socket.addEventListener("open", onOpen);
+			socket.addEventListener("message", onMessage);
+			socket.addEventListener("error", onError);
+			socket.addEventListener("close", onClose);
+			return {
+				send(message, sendCallback) {
+					let canceled = false;
+					try {
+						socket.send(message.data);
+						if (!canceled) sendCallback({ ok: true, value: { sent: true } });
+					} catch (error) {
+						if (!canceled) sendCallback({ ok: false, error });
+					}
+					return () => {
+						canceled = true;
+					};
+				},
+				close(code, reason) {
+					if (!active) return;
+					socket.close(code, reason);
+				},
+				cancel() {
+					if (!active) return;
+					active = false;
+					removeListeners();
+					socket.close();
+				},
+			};
+		},
+	};
+}
+
+function requireGlobalFetch(): FetchLike {
+	const fetchFn = (globalThis as { fetch?: FetchLike }).fetch;
+	if (fetchFn === undefined) throw new Error("fetchHttpDriver: global fetch is not available");
+	return fetchFn;
+}
+
+function requireGlobalWebSocket(): WebSocketConstructorLike {
+	const ctor = (globalThis as { WebSocket?: WebSocketConstructorLike }).WebSocket;
+	if (ctor === undefined) throw new Error("domWebSocketDriver: global WebSocket is not available");
+	return ctor;
+}
diff --git a/packages/ts/src/graph/graph-lifecycle.ts b/packages/ts/src/graph/graph-lifecycle.ts
new file mode 100644
index 00000000..4e25c963
--- /dev/null
+++ b/packages/ts/src/graph/graph-lifecycle.ts
@@ -0,0 +1,24 @@
+import type { NodeFn } from "../ctx/types.js";
+import type { Node } from "../node/node.js";
+import type { Graph, StateNode } from "./graph.js";
+import type { SugarOpts } from "./graph-types.js";
+
+export interface GraphRestoreRegistrar {
+	stateNode<T>(id: string, opts?: SugarOpts<T>): StateNode<T>;
+	node<T>(
+		id: string,
+		factory: string,
+		deps: readonly Node<unknown>[],
+		fn: NodeFn | null,
+		opts?: SugarOpts<T>,
+	): Node<T>;
+}
+
+export const restoreRegistrars = new WeakMap<Graph, GraphRestoreRegistrar>();
+
+export interface GraphLifecycleRegistrar {
+	assertRegisteredNode(node: Node<unknown>, label: string): void;
+	releaseNodes(nodes: readonly Node<unknown>[], opts?: { reason?: string }): void;
+}
+
+export const lifecycleRegistrars = new WeakMap<Graph, GraphLifecycleRegistrar>();
diff --git a/packages/ts/src/graph/graph-support.ts b/packages/ts/src/graph/graph-support.ts
new file mode 100644
index 00000000..0619900b
--- /dev/null
+++ b/packages/ts/src/graph/graph-support.ts
@@ -0,0 +1,130 @@
+import { checkpointStateOfNode, type Node } from "../node/node.js";
+import { type GraphCheckpointFactory, toCheckpointJson } from "./checkpoint.js";
+import type { DescribeSnapshot } from "./describe.js";
+import type { TopologyEvent } from "./inspect.js";
+
+export function isNonAuthoritativeCollectionHelperMeta(
+	meta: Record<string, unknown> | undefined,
+): boolean {
+	return (
+		meta?.kind === "collection_delta" ||
+		meta?.kind === "collection_intent" ||
+		meta?.kind === "collection_policy_apply" ||
+		meta?.kind === "collection_snapshot" ||
+		meta?.kind === "collection_snapshot_prep"
+	);
+}
+
+export function assertCheckpointQuiescentStatus(status: string, id: string, op: string): void {
+	if (status === "pending" || status === "dirty") {
+		throw new Error(
+			`${op}: node '${id}' has non-quiescent status '${status}' that cannot be checkpoint-restored yet`,
+		);
+	}
+}
+
+export function topologyPathMatches(eventPath: string, path: string): boolean {
+	return eventPath === path || eventPath.startsWith(`${path}::`);
+}
+
+export function prefixTopologyPath(prefix: string, path: string): string {
+	return `${prefix}::${path}`;
+}
+
+export function cloneTopologyEvent(event: TopologyEvent): TopologyEvent {
+	const deps = Object.freeze([...event.deps]);
+	const prevDeps = event.prevDeps === undefined ? undefined : Object.freeze([...event.prevDeps]);
+	return Object.freeze({
+		kind: event.kind,
+		path: event.path,
+		deps,
+		...(prevDeps !== undefined ? { prevDeps } : {}),
+		...(event.factory !== undefined ? { factory: event.factory } : {}),
+		seq: event.seq,
+	});
+}
+
+export function checkpointFactory(
+	name: string,
+	node: Node<unknown>,
+	unregistered: boolean,
+	restore?: { ref: string; config?: unknown; configVersion?: unknown },
+	meta?: Record<string, unknown>,
+): GraphCheckpointFactory {
+	const state = checkpointStateOfNode(node);
+	if (unregistered) {
+		return {
+			kind: "local-only",
+			name,
+			reason: "node is an unregistered live dependency auto-discovered from topology",
+		};
+	}
+	if (
+		restore === undefined &&
+		typeof meta?.kind === "string" &&
+		meta.kind.startsWith("collection_")
+	) {
+		return {
+			kind: "local-only",
+			name,
+			reason: "collection helper node has no backend checkpoint restore metadata",
+		};
+	}
+	if (restore !== undefined) {
+		const out: GraphCheckpointFactory = {
+			kind: "registry-ref",
+			ref: toCheckpointJson(restore.ref, `${name}.factory.ref`) as string,
+		};
+		if (restore.config !== undefined)
+			out.config = toCheckpointJson(restore.config, `${name}.factory.config`);
+		if (restore.configVersion !== undefined)
+			out.configVersion = toCheckpointJson(restore.configVersion, `${name}.factory.configVersion`);
+		return out;
+	}
+	if (state.handle !== null) {
+		return {
+			kind: "local-only",
+			name,
+			reason: "node uses a function body; first-cut checkpoints do not serialize local functions",
+		};
+	}
+	return { kind: "registry-ref", ref: name };
+}
+
+/** Filter a snapshot to the causal chain from→to (forward-reachable(from) ∩ back-reachable(to)). */
+export function explainSubset(
+	snap: DescribeSnapshot,
+	chain: { from: string; to: string },
+): DescribeSnapshot {
+	const fwd = new Map<string, string[]>();
+	const rev = new Map<string, string[]>();
+	const push = (map: Map<string, string[]>, k: string, v: string): void => {
+		const a = map.get(k);
+		if (a) a.push(v);
+		else map.set(k, [v]);
+	};
+	for (const e of snap.edges) {
+		push(fwd, e.from, e.to);
+		push(rev, e.to, e.from);
+	}
+	const reach = (start: string, adj: Map<string, string[]>): Set<string> => {
+		const seen = new Set<string>([start]);
+		const stack = [start];
+		while (stack.length > 0) {
+			const cur = stack.pop() as string;
+			for (const nxt of adj.get(cur) ?? []) {
+				if (!seen.has(nxt)) {
+					seen.add(nxt);
+					stack.push(nxt);
+				}
+			}
+		}
+		return seen;
+	};
+	const onPath = new Set([...reach(chain.from, fwd)].filter((id) => reach(chain.to, rev).has(id)));
+	return {
+		...(snap.name !== undefined ? { name: snap.name } : {}),
+		nodes: snap.nodes.filter((n) => onPath.has(n.id)),
+		edges: snap.edges.filter((e) => onPath.has(e.from) && onPath.has(e.to)),
+	};
+}
diff --git a/packages/ts/src/graph/graph-topology-group.ts b/packages/ts/src/graph/graph-topology-group.ts
new file mode 100644
index 00000000..59040310
--- /dev/null
+++ b/packages/ts/src/graph/graph-topology-group.ts
@@ -0,0 +1,138 @@
+import type { NodeFn } from "../ctx/types.js";
+import type { Node } from "../node/node.js";
+import type { Graph, StateNode } from "./graph.js";
+import { lifecycleRegistrars } from "./graph-lifecycle.js";
+import type { DerivedFn, EffectFn, SugarOpts } from "./graph-types.js";
+import type { Operator } from "./operators.js";
+
+export interface TopologyGroupOptions {
+	/** Optional inspection/release reason label for this graph-owned topology group. */
+	name?: string;
+}
+
+export interface TopologyGroupReleaseOptions {
+	/** Optional diagnostic reason. No protocol/control messages are synthesized. */
+	reason?: string;
+}
+
+/**
+ * Graph-owned D152 release group: a label over ordinary graph-registered nodes.
+ * The graph registry remains the source of truth; helper-local membership is only
+ * a memo for atomic quiescent release.
+ */
+export interface TopologyGroup {
+	readonly name?: string;
+	readonly released: boolean;
+	add<T extends Node<unknown>>(node: T): T;
+	node<T = unknown>(
+		deps?: readonly Node<unknown>[],
+		fn?: NodeFn | null,
+		opts?: SugarOpts<T>,
+	): Node<T>;
+	state<T>(initial: T, opts?: SugarOpts<T>): StateNode<T>;
+	producer<T = unknown>(fn: NodeFn, opts?: SugarOpts<T>): Node<T>;
+	derived<const D extends readonly Node<unknown>[], T>(
+		deps: D,
+		fn: DerivedFn<D, T>,
+		opts?: SugarOpts<T>,
+	): Node<T>;
+	effect<const D extends readonly Node<unknown>[]>(
+		deps: D,
+		fn: EffectFn<D>,
+		opts?: SugarOpts<void>,
+	): Node<void>;
+	initNode<TIn, TOut>(
+		op: Operator<TIn, TOut>,
+		deps: readonly Node<TIn>[],
+		opts?: SugarOpts<TOut>,
+	): Node<TOut>;
+	release(opts?: TopologyGroupReleaseOptions): void;
+}
+
+export class GraphTopologyGroup implements TopologyGroup {
+	readonly name?: string;
+	private readonly _graph: Graph;
+	private readonly _members: Node<unknown>[] = [];
+	private _released = false;
+
+	constructor(graph: Graph, opts: TopologyGroupOptions = {}) {
+		this._graph = graph;
+		this.name = opts.name;
+	}
+
+	get released(): boolean {
+		return this._released;
+	}
+
+	add<T extends Node<unknown>>(node: T): T {
+		this._assertLive();
+		const lifecycle = lifecycleRegistrars.get(this._graph);
+		if (lifecycle === undefined) throw new Error("topologyGroup: graph lifecycle unavailable");
+		lifecycle.assertRegisteredNode(node, `topology group '${this.name ?? "group"}' member`);
+		if (!this._members.includes(node)) this._members.push(node);
+		return node;
+	}
+
+	node<T = unknown>(
+		deps: readonly Node<unknown>[] = [],
+		fn: NodeFn | null = null,
+		opts: SugarOpts<T> = {},
+	): Node<T> {
+		this._assertLive();
+		return this.add(this._graph.node(deps, fn, opts));
+	}
+
+	state<T>(initial: T, opts: SugarOpts<T> = {}): StateNode<T> {
+		this._assertLive();
+		return this.add(this._graph.state(initial, opts));
+	}
+
+	producer<T = unknown>(fn: NodeFn, opts: SugarOpts<T> = {}): Node<T> {
+		this._assertLive();
+		return this.add(this._graph.producer(fn, opts));
+	}
+
+	derived<const D extends readonly Node<unknown>[], T>(
+		deps: D,
+		fn: DerivedFn<D, T>,
+		opts: SugarOpts<T> = {},
+	): Node<T> {
+		this._assertLive();
+		return this.add(this._graph.derived(deps, fn, opts));
+	}
+
+	effect<const D extends readonly Node<unknown>[]>(
+		deps: D,
+		fn: EffectFn<D>,
+		opts: SugarOpts<void> = {},
+	): Node<void> {
+		this._assertLive();
+		return this.add(this._graph.effect(deps, fn, opts));
+	}
+
+	initNode<TIn, TOut>(
+		op: Operator<TIn, TOut>,
+		deps: readonly Node<TIn>[],
+		opts: SugarOpts<TOut> = {},
+	): Node<TOut> {
+		this._assertLive();
+		return this.add(this._graph.initNode(op, deps, opts));
+	}
+
+	release(opts: TopologyGroupReleaseOptions = {}): void {
+		if (this._released) return;
+		const lifecycle = lifecycleRegistrars.get(this._graph);
+		if (lifecycle === undefined) throw new Error("topologyGroup: graph lifecycle unavailable");
+		lifecycle.releaseNodes([...this._members], {
+			reason: opts.reason ?? this.name,
+		});
+		this._members.length = 0;
+		this._released = true;
+	}
+
+	private _assertLive(): void {
+		if (this._released) {
+			throw new Error(`topology group '${this.name ?? "group"}' has been released (D152)`);
+		}
+	}
+}
diff --git a/packages/ts/src/graph/graph-types.ts b/packages/ts/src/graph/graph-types.ts
new file mode 100644
index 00000000..fb11ead3
--- /dev/null
+++ b/packages/ts/src/graph/graph-types.ts
@@ -0,0 +1,48 @@
+import type { Dispatcher } from "../dispatcher/index.js";
+import type { Node, NodeOptions } from "../node/node.js";
+import type { NodeVersioningPolicy } from "../node/versioning.js";
+import type { EnvironmentDrivers } from "./environment.js";
+
+/** Map a tuple of Nodes to the tuple of their value types (typed value-level fn args). */
+export type DepValues<D extends readonly Node<unknown>[]> = {
+	[K in keyof D]: D[K] extends Node<infer V> ? V : never;
+};
+
+/** Value-level derived fn: receives dep values, returns the next value (undefined = no emit). */
+export type DerivedFn<D extends readonly Node<unknown>[], T> = (
+	...values: DepValues<D>
+) => T | undefined;
+
+/** Value-level effect fn: receives dep values, optionally returns a deactivation cleanup. */
+export type EffectFn<D extends readonly Node<unknown>[]> = (
+	...values: DepValues<D>
+	// biome-ignore lint/suspicious/noConfusingVoidType: effect returns void OR a cleanup fn — the void arm keeps `(v) => { sideEffect(v) }` ergonomic (React EffectCallback idiom); dropping it would force an explicit `return undefined`.
+) => void | (() => void);
+
+/** Sugar options — node options minus graph-owned dispatcher plus naming/meta. */
+export interface SugarOpts<T = unknown> extends Omit<NodeOptions<T>, "dispatcher"> {
+	name?: string;
+	meta?: Record<string, unknown>;
+	/**
+	 * D95: explicit restorable factory metadata. Static JSON-compatible config may live here;
+	 * reactive options must remain graph deps. Without this, function-backed nodes are local-only.
+	 */
+	restore?: { ref: string; config?: unknown; configVersion?: unknown };
+}
+
+export interface GraphOptions {
+	name?: string;
+	/** Bind to a dispatcher (default = process-global, D26). */
+	dispatcher?: Dispatcher;
+	/** D109 default node runtime versioning policy for graph-owned nodes. Default is nodev0. */
+	versioning?: NodeVersioningPolicy;
+	/** Graph-owned environment drivers for source/adapter boundaries (D130/D131). */
+	environment?: EnvironmentDrivers;
+	/**
+	 * Turn on the dispatcher profile recorder (D39 / F-PERF default off). NOTE: this
+	 * switches recording on for the WHOLE bound dispatcher (the default is process-global,
+	 * D26) — every graph sharing it then pays the recorder cost. For isolated profiling
+	 * use a dedicated dispatcher: `graph({ dispatcher: new Dispatcher(), profile: true })`.
+	 */
+	profile?: boolean;
+}
diff --git a/packages/ts/src/graph/graph.ts b/packages/ts/src/graph/graph.ts
new file mode 100644
index 00000000..deda6f99
--- /dev/null
+++ b/packages/ts/src/graph/graph.ts
@@ -0,0 +1,979 @@
+/**
+ * The Graph layer (CSP-2): convenience + inspection entry (D5 / R-graph-role).
+ *
+ * g.* sugar desugars to dispatcher.register + Node and auto-registers into the graph
+ * inspection index (D27: sugar→ctx-fn conversion lives strictly here; the substrate node
+ * only ever sees `(ctx)=>void`). The Graph owns naming, describe, mount, and the D30
+ * value-level throw→ERROR boundary. The bare node()/dispatcher stay inspection-free
+ * (R-node-thin).
+ *
+ * Canonical authority: ~/src/graphrefly — D3/D5/D27/D30/D36/D37/D39, R-graph-role,
+ * R-describe, R-fn-contract, R-edges-derived, R-meta-presentation.
+ */
+
+import { type BatchCtx, batch as batchRun } from "../batch/batch.js";
+import { type Ctx, depCount, depLatest, type NodeFn } from "../ctx/types.js";
+import { type Dispatcher, defaultDispatcher } from "../dispatcher/index.js";
+import { NodeCore } from "../node/core.js";
+import {
+	checkpointStateOfNode,
+	getNodeOwner,
+	isNodeActiveForRelease,
+	isNodeRuntimeQuiescentForRelease,
+	isNodeRuntimeReleased,
+	Node,
+	type NodeOptions,
+	releaseRuntimeOfNode,
+	setNodeOwner,
+	setNodeTopologyDepsChangedObserver,
+	subscriberCountOfNode,
+	withEnvironmentDrivers,
+	withNodeCore,
+} from "../node/node.js";
+import type { NodeVersioningPolicy } from "../node/versioning.js";
+import { errorPayload, messageTier, SENTINEL } from "../protocol/messages.js";
+import {
+	GRAPH_BLUEPRINT_VERSION,
+	type GraphBlueprint,
+	type GraphBlueprintOptions,
+	graphBlueprintDiagnostics,
+	normalizeTopology,
+	normalizeTopologyMeta,
+} from "./blueprint.js";
+import {
+	checkpointBackendStateOfNode,
+	checkpointTerminal,
+	checkpointValue,
+	GRAPH_CHECKPOINT_VERSION,
+	type GraphCheckpoint,
+	type GraphCheckpointFactory,
+	type GraphCheckpointJson,
+	type GraphCheckpointNode,
+	toCheckpointJson,
+} from "./checkpoint.js";
+import {
+	type DescribeEdge,
+	type DescribeNode,
+	type DescribeOpts,
+	type DescribeSnapshot,
+	type GraphTopologySnapshot,
+	topologyFromDescribe,
+} from "./describe.js";
+import { EnvironmentDrivers } from "./environment.js";
+import { lifecycleRegistrars, restoreRegistrars } from "./graph-lifecycle.js";
+import {
+	assertCheckpointQuiescentStatus,
+	checkpointFactory,
+	cloneTopologyEvent,
+	explainSubset,
+	isNonAuthoritativeCollectionHelperMeta,
+	prefixTopologyPath,
+	topologyPathMatches,
+} from "./graph-support.js";
+import {
+	GraphTopologyGroup,
+	type TopologyGroup,
+	type TopologyGroupOptions,
+} from "./graph-topology-group.js";
+import type { DepValues, DerivedFn, EffectFn, GraphOptions, SugarOpts } from "./graph-types.js";
+import type {
+	NodeProfile,
+	ObserveStream,
+	Profile,
+	TopologyEvent,
+	TopologyStream,
+} from "./inspect.js";
+import { initNodeWithCore, type Operator } from "./operators.js";
+
+export type {
+	TopologyGroup,
+	TopologyGroupOptions,
+	TopologyGroupReleaseOptions,
+} from "./graph-topology-group.js";
+export type { DerivedFn, EffectFn, GraphOptions, SugarOpts } from "./graph-types.js";
+
+interface Entry {
+	node: Node<unknown>;
+	id: string;
+	name?: string;
+	factory: string;
+	deps: readonly Node<unknown>[];
+	meta?: Record<string, unknown>;
+	restore?: { ref: string; config?: unknown; configVersion?: unknown };
+}
+
+interface TopologyObserver {
+	path?: string;
+	sink(event: TopologyEvent): void;
+}
+
+interface MountedGraph {
+	at: string;
+	graph: Graph;
+	topologyUnsub?: () => void;
+}
+
+function nodeOwner(n: Node<unknown>): Graph | undefined {
+	return getNodeOwner(n) as Graph | undefined;
+}
+
+export function assertGraphLocalNode(owner: Graph, n: Node<unknown>, label: string): void {
+	if (isNodeRuntimeReleased(n)) {
+		throw new Error(`${label} has been released from its graph lifecycle (D122)`);
+	}
+	const existing = nodeOwner(n);
+	if (existing !== undefined && existing !== owner) {
+		throw new Error(
+			`${label} belongs to a different graph; cross-graph deps require a wire bridge`,
+		);
+	}
+}
+
+/**
+ * A state node (L4-Q1): a manual source whose `.set(v)` is `node.down([[DATA, v]])` sugar.
+ * Extends the substrate Node so it is usable as a dep AND carries the graph-layer `.set`.
+ */
+export class StateNode<T> extends Node<T> {
+	set(v: T): void {
+		this.down([["DATA", v]]);
+	}
+}
+
+export class Graph {
+	readonly name?: string;
+	private readonly _dispatcher: Dispatcher;
+	private readonly _versioning: NodeVersioningPolicy | undefined;
+	private readonly _environment: EnvironmentDrivers;
+	private readonly _core = new NodeCore();
+	private readonly _entries = new Map<Node<unknown>, Entry>();
+	private readonly _byId = new Map<string, Node<unknown>>();
+	private readonly _retiredIds = new Set<string>();
+	private readonly _mounts: MountedGraph[] = [];
+	private _seq = 0;
+	private _clock = 0; // graph-local monotonic clock for observe seq (D26)
+	private _topologyObserverSeq = 0;
+	private readonly _topologyObservers = new Map<number, TopologyObserver>();
+	private _topologyDelivering = false;
+	private readonly _topologyQueue: TopologyEvent[] = [];
+	// D51: stable synthetic ids for unregistered live deps (runtime *Map inners) auto-discovered by
+	// describe(). WeakMap-cached so successive describes agree + the inner's id is freed when it is.
+	// A dedicated counter (NOT _seq) so a describe() call never perturbs registered-node id numbering.
+	private _synthSeq = 0;
+	private readonly _synthIds = new WeakMap<Node<unknown>, string>();
+
+	constructor(opts: GraphOptions = {}) {
+		this.name = opts.name;
+		this._dispatcher = opts.dispatcher ?? defaultDispatcher;
+		this._versioning = opts.versioning;
+		this._environment = opts.environment ?? EnvironmentDrivers.empty();
+		if (opts.profile) this._dispatcher.setRecording(true);
+		restoreRegistrars.set(this, {
+			stateNode: <T = unknown>(id: string, stateOpts: SugarOpts<T> = {}) => {
+				const n = this._construct(() => new StateNode<T>([], null, this._nodeOpts(stateOpts)));
+				this._addWithId(n, "state", [], stateOpts, id);
+				return n;
+			},
+			node: <T = unknown>(
+				id: string,
+				factory: string,
+				deps: readonly Node<unknown>[],
+				fn: NodeFn | null,
+				nodeOpts: SugarOpts<T> = {},
+			) => {
+				this._assertDepsLocal(deps, `dep of restored '${id}'`);
+				const n = this._construct(() => new Node<T>([...deps], fn, this._nodeOpts(nodeOpts)));
+				this._addWithId(n, factory, deps, nodeOpts, id);
+				return n;
+			},
+		});
+		lifecycleRegistrars.set(this, {
+			assertRegisteredNode: (node, label) => this._assertRegisteredNode(node, label),
+			releaseNodes: (nodes, releaseOpts) => this._releaseNodes(nodes, releaseOpts),
+		});
+	}
+
+	// ── registration / inspection index ──
+
+	private _add<T>(
+		n: Node<T>,
+		factory: string,
+		deps: readonly Node<unknown>[],
+		opts: SugarOpts<T>,
+	): Node<T> {
+		const id = opts.name ?? `${factory}#${this._seq++}`;
+		return this._addWithId(n, factory, deps, opts, id);
+	}
+
+	private _addWithId<T>(
+		n: Node<T>,
+		factory: string,
+		deps: readonly Node<unknown>[],
+		opts: SugarOpts<T>,
+		id: string,
+	): Node<T> {
+		assertGraphLocalNode(this, n as Node<unknown>, `graph node '${opts.name ?? factory}'`);
+		for (const dep of deps) assertGraphLocalNode(this, dep, `dep of '${opts.name ?? factory}'`);
+		if (this._byId.has(id)) {
+			throw new Error(`graph: duplicate node id '${id}' (checkpoint/describe ids must be unique)`);
+		}
+		if (this._retiredIds.has(id)) {
+			throw new Error(`graph: node id '${id}' was released and cannot be reused (D152/D153)`);
+		}
+		const meta =
+			opts.meta === undefined
+				? undefined
+				: (normalizeTopologyMeta(opts.meta, `graph node '${id}' meta`) as Record<string, unknown>);
+		this._entries.set(n as Node<unknown>, {
+			node: n as Node<unknown>,
+			id,
+			name: opts.name,
+			factory,
+			deps,
+			meta,
+			restore: opts.restore,
+		});
+		setNodeOwner(n as Node<unknown>, this);
+		this._byId.set(id, n as Node<unknown>);
+		setNodeTopologyDepsChangedObserver(n as Node<unknown>, (_node, prevDeps, nextDeps) => {
+			this._emitTopologyDepsChanged(n as Node<unknown>, prevDeps, nextDeps);
+		});
+		const seqMatch = /#(\d+)$/.exec(id);
+		if (seqMatch) this._seq = Math.max(this._seq, Number(seqMatch[1]) + 1);
+		this._emitTopologyNodeRegistered(n as Node<unknown>);
+		return n;
+	}
+
+	private _assertDepsLocal(deps: readonly Node<unknown>[], label: string): void {
+		for (const dep of deps) assertGraphLocalNode(this, dep, label);
+	}
+
+	private _assertRegisteredNode(node: Node<unknown>, label: string): void {
+		assertGraphLocalNode(this, node, label);
+		if (!this._entries.has(node)) {
+			throw new Error(`${label} is not a registered graph node (D152)`);
+		}
+	}
+
+	private _nodeOpts<T>(opts: SugarOpts<T>): NodeOptions<T> {
+		if (opts.meta !== undefined) {
+			normalizeTopologyMeta(opts.meta, `graph node '${opts.name ?? opts.factory ?? "node"}' meta`);
+		}
+		// strip graph-only fields; inject the bound dispatcher
+		const { name: _n, meta: _m, restore: _r, ...rest } = opts;
+		return {
+			...rest,
+			versioning: rest.versioning ?? this._versioning,
+			dispatcher: this._dispatcher,
+		};
+	}
+
+	private _construct<TNode extends Node<unknown>>(create: () => TNode): TNode {
+		return withEnvironmentDrivers(this._environment, () => withNodeCore(this._core, create));
+	}
+
+	/** Look up a registered node by its id. */
+	find(id: string): Node<unknown> | undefined {
+		const local = this._byId.get(id);
+		if (local !== undefined) return local;
+		const separator = id.indexOf("::");
+		if (separator < 0) return undefined;
+		const mountPath = id.slice(0, separator);
+		const childPath = id.slice(separator + 2);
+		return this._mounts.find((mount) => mount.at === mountPath)?.graph.find(childPath);
+	}
+
+	private _releaseNodes(nodes: readonly Node<unknown>[], _opts: { reason?: string } = {}): void {
+		const seen = new Set<Node<unknown>>();
+		const entries: Array<{ node: Node<unknown>; entry: Entry }> = [];
+		for (const node of nodes) {
+			if (seen.has(node)) continue;
+			seen.add(node);
+			const entry = this._entries.get(node);
+			if (entry === undefined) continue;
+			entries.push({ node, entry });
+		}
+		const releaseSet = new Set(entries.map(({ node }) => node));
+		const releaseIds = new Map(entries.map(({ node, entry }) => [node, entry.id] as const));
+		for (const entry of this._entries.values()) {
+			if (releaseSet.has(entry.node)) continue;
+			for (const dep of entry.node.deps) {
+				if (!releaseSet.has(dep)) continue;
+				const depId = releaseIds.get(dep) ?? dep.name ?? dep.factory ?? "released node";
+				throw new Error(
+					`graph: cannot release node group; '${entry.id}' still depends on '${depId}' (D122)`,
+				);
+			}
+		}
+		for (const { node, entry } of entries) {
+			if (!isNodeRuntimeQuiescentForRelease(node)) {
+				throw new Error(
+					`graph: cannot release node group; '${entry.id}' is not runtime-quiescent (D124)`,
+				);
+			}
+			let internalSubscribers = 0;
+			for (const { node: dependent } of entries) {
+				if (dependent === node || !isNodeActiveForRelease(dependent)) continue;
+				for (const dep of dependent.deps) {
+					if (dep === node) internalSubscribers += 1;
+				}
+			}
+			if (subscriberCountOfNode(node) > internalSubscribers) {
+				throw new Error(
+					`graph: cannot release node group; '${entry.id}' still has live subscribers (D124)`,
+				);
+			}
+		}
+		const releasedEvents =
+			this._topologyObservers.size === 0
+				? []
+				: entries.map(({ node, entry }) => ({
+						path: entry.id,
+						factory: entry.factory,
+						deps: this._topologyDeps(node.deps),
+					}));
+		for (const { node, entry } of entries) {
+			this._entries.delete(node);
+			this._byId.delete(entry.id);
+			this._retiredIds.add(entry.id);
+		}
+		let releaseError: unknown;
+		for (const { node } of entries) {
+			try {
+				releaseRuntimeOfNode(node);
+			} catch (error) {
+				if (releaseError === undefined) releaseError = error;
+			}
+		}
+		for (const event of releasedEvents) this._emitTopologyNodeReleased(event);
+		if (releaseError !== undefined) throw releaseError;
+	}
+
+	// ── 8 verbs (core: node/state/batch + sugar: producer/derived/effect/mount) ──
+
+	/** ctx-level power surface: a raw `(ctx)=>void` fn (or a passthrough/state when null). */
+	node<T = unknown>(
+		deps: readonly Node<unknown>[] = [],
+		fn: NodeFn | null = null,
+		opts: SugarOpts<T> = {},
+	): Node<T> {
+		this._assertDepsLocal(deps, `dep of '${opts.name ?? "node"}'`);
+		const n = this._construct(() => new Node<T>(deps as Node<unknown>[], fn, this._nodeOpts(opts)));
+		return this._add(n, opts.factory ?? "node", deps, opts);
+	}
+
+	/** A manual source with `.set(v)` (L4-Q1). */
+	state<T>(initial: T, opts: SugarOpts<T> = {}): StateNode<T> {
+		const n = this._construct(
+			() => new StateNode<T>([], null, { ...this._nodeOpts(opts), initial }),
+		);
+		this._add(n, "state", [], opts);
+		return n;
+	}
+
+	/** ctx-level depless source; its fn runs on activation (R-rom-ram). */
+	producer<T = unknown>(fn: NodeFn, opts: SugarOpts<T> = {}): Node<T> {
+		const n = this._construct(() => new Node<T>([], fn, this._nodeOpts(opts)));
+		return this._add(n, "producer", [], opts);
+	}
+
+	/** value-level pure transform: deps → value (D27 wrapped; D30 throw→ERROR). */
+	derived<const D extends readonly Node<unknown>[], T>(
+		deps: D,
+		fn: DerivedFn<D, T>,
+		opts: SugarOpts<T> = {},
+	): Node<T> {
+		this._assertDepsLocal(deps, `dep of '${opts.name ?? "derived"}'`);
+		const ctxFn: NodeFn = (ctx: Ctx) => {
+			try {
+				const args = Array.from({ length: depCount(ctx) }, (_, i) =>
+					depLatest(ctx, i),
+				) as DepValues<D>;
+				const result = fn(...args);
+				if (result !== undefined) ctx.down([["DATA", result]]);
+			} catch (e) {
+				ctx.down([["ERROR", errorPayload(e, "derived threw without a valid error payload")]]); // D30: value-level throw → graph-layer ERROR
+			}
+		};
+		const n = this._construct(() => new Node<T>([...deps], ctxFn, this._nodeOpts(opts)));
+		return this._add(n, "derived", deps, opts);
+	}
+
+	/** value-level sink: deps → effect; return value (a fn) becomes onDeactivation (D28). */
+	effect<const D extends readonly Node<unknown>[]>(
+		deps: D,
+		fn: EffectFn<D>,
+		opts: SugarOpts<void> = {},
+	): Node<void> {
+		this._assertDepsLocal(deps, `dep of '${opts.name ?? "effect"}'`);
+		// effect cleanup = deactivation-only (D28 / Flag 3): the LATEST returned cleanup
+		// fires ONCE when the effect deactivates (not between re-runs — onRerun was cut).
+		// R-cleanup-hooks per-run lifecycle (D28 clarification / C-14): the substrate clears
+		// the hook list before EACH fn run, so the effect re-registers its returned cleanup
+		// every run — only the latest run's registration is live (or none, if the latest run
+		// returned void). No st.registered/ctx.state bookkeeping; re-registering every run is
+		// safe (the per-run clear prevents accumulation).
+		const ctxFn: NodeFn = (ctx: Ctx) => {
+			try {
+				const args = Array.from({ length: depCount(ctx) }, (_, i) =>
+					depLatest(ctx, i),
+				) as DepValues<D>;
+				const cleanup = fn(...args);
+				if (typeof cleanup === "function") ctx.onDeactivation(cleanup);
+			} catch (e) {
+				ctx.down([["ERROR", errorPayload(e, "effect threw without a valid error payload")]]);
+			}
+		};
+		const n = this._construct(() => new Node<void>([...deps], ctxFn, this._nodeOpts(opts)));
+		return this._add(n, "effect", deps, opts);
+	}
+
+	/** Declarative batch (D12): one wave, success→commit / throw→rollback. */
+	batch<T>(fn: (bctx: BatchCtx) => T): T {
+		return batchRun(fn);
+	}
+
+	/** Embed a child graph addressable under `at` (R-mount; mount has no deps). */
+	mount(child: Graph, opts: { at: string }): void {
+		const mount = { at: opts.at, graph: child };
+		this._mounts.push(mount);
+		if (this._topologyObservers.size > 0) this._ensureMountedTopologyForwarders();
+		this._emitTopologyMountChanged(opts.at);
+	}
+
+	// ── operator funnel (D43): instantiate any free-standing Operator (node sugar, D6/L1.5) ──
+	// g.initNode is the single graph-bound entry for the whole operator/source catalog (D40):
+	// it delegates to the FREE initNode (graph/operators.ts — the D30 throw→ERROR boundary +
+	// dispatcher binding live there) and records the operator's REAL factory name in the
+	// inspection index (_add) so describe shows it (D6/R-describe) while the node stays thin
+	// (R-node-thin). Operators are free-standing factory definitions (graph/operators.ts,
+	// graph/sources.ts) usable bare via the free initNode(); this funnel is the inspectable
+	// path. Replaces the per-operator methods.
+
+	/**
+	 * Instantiate an operator (or source) factory as a registered graph node. `deps` are
+	 * type-checked against the operator's input element type; the output type flows from the
+	 * operator. A source is a depless operator — pass `[]`. Caller `opts` (name/meta/behavioral
+	 * overrides) win over the operator's baked-in `opts`.
+	 */
+	initNode<TIn, TOut>(
+		op: Operator<TIn, TOut>,
+		deps: readonly Node<TIn>[],
+		opts: SugarOpts<TOut> = {},
+	): Node<TOut> {
+		const entryOpts =
+			op.restore !== undefined && !("restore" in opts) ? { ...opts, restore: op.restore } : opts;
+		for (const dep of deps as readonly Node<unknown>[])
+			assertGraphLocalNode(this, dep, `dep of '${entryOpts.name ?? op.factory}'`);
+		// Node<T> is invariant (T appears in NodeOptions.initial); widen the typed deps to the
+		// erased Node surface the free initNode / _add accept (same cast the old methods used).
+		const erased = deps as readonly Node<unknown>[];
+		const n = withEnvironmentDrivers(this._environment, () =>
+			initNodeWithCore(this._core, op, erased, this._nodeOpts(entryOpts)),
+		);
+		return this._add(n, op.factory, erased, entryOpts);
+	}
+
+	/**
+	 * Graph-owned activation root for internal helper nodes. This is the sanctioned keepalive shape:
+	 * a graph, not a helper closure, owns the subscription and returns the release handle.
+	 */
+	retain<T>(node: Node<T>, opts: { reason?: string } = {}): () => void {
+		assertGraphLocalNode(this, node as Node<unknown>, opts.reason ?? "retained node");
+		return node.subscribe(() => {});
+	}
+
+	/**
+	 * D152 graph-owned topology/release group. Members are ordinary registered graph nodes;
+	 * release is quiescent-only and removes ids atomically without synthesizing protocol messages.
+	 */
+	topologyGroup(opts: TopologyGroupOptions = {}): TopologyGroup {
+		return new GraphTopologyGroup(this, opts);
+	}
+
+	// ── inspection: describe / observe / profile (D39) ──
+
+	/** Live point-in-time structure snapshot (R-describe / D39 / D51). `_prefix` carries the mount path. */
+	describe(opts: DescribeOpts = {}, _prefix = ""): DescribeSnapshot {
+		// D51: edges derive from each node's CURRENT/LIVE deps (entry.node.deps, NOT the
+		// construction-time entry.deps), so a rewire (C-8 immediate / C-11 *Map deferred) is
+		// reflected and every edge is a real current subscription (D3). A live dep absent from this
+		// graph's index (a runtime *Map inner / bare fromAny node) is AUTO-DISCOVERED as a snapshot
+		// node with a synthesized stable id (B2). B38 extends this to transitive live-reachability:
+		// discovered unregistered nodes are recursively expanded through their own live deps.
+		const discovered = new Map<Node<unknown>, string>(); // unregistered live dep → synth local id
+		const localId = (n: Node<unknown>): string => {
+			const e = this._entries.get(n);
+			if (e) return `${_prefix}${e.id}`;
+			// unregistered: a stable synthetic id, cached so successive describes + both call sites
+			// agree; the `~` prefix can't collide with a registered name or `factory#seq`.
+			let sid = this._synthIds.get(n);
+			if (sid === undefined) {
+				// the `~` prefix avoids the registered `name`/`factory#seq` space; guard the
+				// pathological case of a user node literally named `~factory#n` (bump until free).
+				do {
+					sid = `~${n.factory ?? "?"}#${this._synthSeq++}`;
+				} while (this._byId.has(sid));
+				this._synthIds.set(n, sid);
+			}
+			discovered.set(n, sid);
+			return `${_prefix}${sid}`;
+		};
+		const nodes: DescribeNode[] = [];
+		const edges: DescribeEdge[] = [];
+		// pass 1: registered nodes, reading LIVE deps (localId records any unregistered inner).
+		for (const entry of this._entries.values()) {
+			const id = `${_prefix}${entry.id}`;
+			const liveIds = entry.node.deps.map(localId);
+			const dnode: DescribeNode = {
+				id,
+				factory: entry.factory,
+				status: entry.node.status,
+				deps: liveIds,
+			};
+			if (entry.name !== undefined) dnode.name = entry.name;
+			if (entry.node.cache !== undefined) dnode.value = entry.node.cache; // absent = SENTINEL
+			if (entry.node.version !== undefined) dnode.version = entry.node.version;
+			if (entry.meta !== undefined) dnode.meta = entry.meta;
+			nodes.push(dnode);
+			for (const from of liveIds) edges.push({ from, to: id });
+		}
+		// pass 2: recursively emit auto-discovered unregistered nodes (D51+B38). localId() may add
+		// further unregistered deps to `discovered` while this loop runs; a visited set keeps each
+		// discovered node emitted once (stable ids via _synthIds).
+		const visited = new Set<Node<unknown>>();
+		const queue: Node<unknown>[] = [...discovered.keys()];
+		for (let i = 0; i < queue.length; i += 1) {
+			const inner = queue[i];
+			if (visited.has(inner)) continue;
+			visited.add(inner);
+			const sid = discovered.get(inner);
+			if (sid === undefined) continue;
+			const liveIds = inner.deps.map(localId);
+			for (const dep of inner.deps) {
+				if (!this._entries.has(dep) && !visited.has(dep)) queue.push(dep);
+			}
+			const dnode: DescribeNode = {
+				id: `${_prefix}${sid}`,
+				factory: inner.factory ?? "?",
+				status: inner.status,
+				deps: liveIds,
+			};
+			if (inner.cache !== undefined) dnode.value = inner.cache;
+			if (inner.version !== undefined) dnode.version = inner.version;
+			nodes.push(dnode);
+			for (const from of liveIds) edges.push({ from, to: dnode.id });
+		}
+		const snap: DescribeSnapshot = { nodes, edges };
+		if (this.name !== undefined) snap.name = this.name;
+		if (this._mounts.length > 0) {
+			snap.subgraphs = this._mounts.map((m) => m.graph.describe({}, `${_prefix}${m.at}::`));
+		}
+		return opts.explain ? explainSubset(snap, opts.explain) : snap;
+	}
+
+	/**
+	 * D173 pure-structure topology snapshot over the same live truth source as describe().
+	 * Runtime status/value/version remain on describe(); blueprint metadata is a later envelope.
+	 */
+	topology(): GraphTopologySnapshot {
+		return topologyFromDescribe(this.describe());
+	}
+
+	/**
+	 * D177 synchronous audit/collaboration envelope over the pure topology snapshot.
+	 * Hashing and environment provenance enrichment stay in pure helpers outside Graph core.
+	 */
+	blueprint(opts: GraphBlueprintOptions = {}): GraphBlueprint {
+		const topology = normalizeTopology(this.topology());
+		const out: GraphBlueprint = {
+			version: GRAPH_BLUEPRINT_VERSION,
+			topology,
+		};
+		if (opts.diagnostics) {
+			(out as { diagnostics?: ReturnType<typeof graphBlueprintDiagnostics> }).diagnostics =
+				graphBlueprintDiagnostics(topology);
+		}
+		if (opts.provenance !== undefined) {
+			(out as { provenance?: GraphBlueprint["provenance"] }).provenance = normalizeTopologyMeta(
+				opts.provenance,
+				"graph blueprint provenance",
+				"provenance",
+			);
+		}
+		return out;
+	}
+
+	private _observeTargets(path?: string): Array<[string, Node<unknown>]> {
+		const all: Array<[string, Node<unknown>]> = [...this._entries.values()].map((e) => [
+			e.id,
+			e.node,
+		]);
+		if (path === undefined) return all; // whole graph
+		const exact = this._byId.get(path);
+		if (exact) return [[path, exact]]; // single node
+		return all.filter(([id]) => id.startsWith(`${path}::`)); // subtree (mount-aware :: boundary, QA A-1)
+	}
+
+	/**
+	 * observe(path?) = read-only enveloped EGRESS (R-observe / D39). NOT a graph node — it
+	 * taps the target node(s) via subscribe and forwards each Message as an ObserveEvent.
+	 * No path = whole graph; an exact id = a single node; otherwise a `::`-prefix subtree.
+	 */
+	// NOTE (R-observe/D19): observe is a real, lazily-ACTIVATING subscriber — observing a
+	// cold node runs its fn (and activates upstream); whole-graph observe() activates the
+	// graph. "Read-only" means it never emits/mutates node state, NOT that it avoids
+	// activation. Use it knowing inspection of a cold graph wakes it.
+	observe(path?: string): ObserveStream {
+		const targets = this._observeTargets(path);
+		return {
+			subscribe: (sink) => {
+				const unsubs = targets.map(([id, n]) =>
+					n.subscribe((msg) => {
+						sink({ path: id, msg, tier: messageTier(msg[0]), seq: this._clock++ });
+					}),
+				);
+				return () => {
+					for (const u of unsubs) u();
+				};
+			},
+		};
+	}
+
+	/**
+	 * D145 observeTopology(path?) = read-only graph lifecycle egress over the existing
+	 * graph registry. It is not a graph node, does not subscribe to nodes, and emits no DATA.
+	 */
+	observeTopology(path?: string): TopologyStream {
+		return {
+			subscribe: (sink) => {
+				const id = this._topologyObserverSeq++;
+				this._topologyObservers.set(id, { path, sink });
+				this._ensureMountedTopologyForwarders();
+				return () => {
+					this._topologyObservers.delete(id);
+					if (this._topologyObservers.size === 0) this._releaseMountedTopologyForwarders();
+				};
+			},
+		};
+	}
+
+	private _idForTopologyNode(n: Node<unknown>): string {
+		const e = this._entries.get(n);
+		if (e) return e.id;
+		let sid = this._synthIds.get(n);
+		if (sid === undefined) {
+			do {
+				sid = `~${n.factory ?? "?"}#${this._synthSeq++}`;
+			} while (this._byId.has(sid));
+			this._synthIds.set(n, sid);
+		}
+		return sid;
+	}
+
+	private _topologyDeps(deps: readonly Node<unknown>[]): string[] {
+		return deps.map((dep) => this._idForTopologyNode(dep));
+	}
+
+	private _emitTopologyNodeRegistered(node: Node<unknown>): void {
+		if (this._topologyObservers.size === 0) return;
+		const entry = this._entries.get(node);
+		if (entry === undefined) return;
+		this._emitTopologyEvent({
+			kind: "node-registered",
+			path: entry.id,
+			factory: entry.factory,
+			deps: this._topologyDeps(node.deps),
+			seq: this._clock++,
+		});
+	}
+
+	private _emitTopologyDepsChanged(
+		node: Node<unknown>,
+		prevDeps: readonly Node<unknown>[],
+		nextDeps: readonly Node<unknown>[],
+	): void {
+		if (this._topologyObservers.size === 0) return;
+		const entry = this._entries.get(node);
+		if (entry === undefined) return;
+		this._emitTopologyEvent({
+			kind: "deps-changed",
+			path: entry.id,
+			prevDeps: this._topologyDeps(prevDeps),
+			deps: this._topologyDeps(nextDeps),
+			seq: this._clock++,
+		});
+	}
+
+	private _emitTopologyNodeReleased(event: {
+		path: string;
+		factory: string;
+		deps: readonly string[];
+	}): void {
+		if (this._topologyObservers.size === 0) return;
+		this._emitTopologyEvent({
+			kind: "node-released",
+			path: event.path,
+			factory: event.factory,
+			deps: [...event.deps],
+			seq: this._clock++,
+		});
+	}
+
+	private _emitTopologyMountChanged(path: string): void {
+		if (this._topologyObservers.size === 0) return;
+		this._emitTopologyEvent({
+			kind: "mount-changed",
+			path,
+			factory: "mount",
+			deps: [],
+			seq: this._clock++,
+		});
+	}
+
+	private _ensureMountedTopologyForwarders(): void {
+		if (this._topologyObservers.size === 0) return;
+		for (const mount of this._mounts) {
+			if (mount.topologyUnsub !== undefined) continue;
+			const mountPath = mount.at;
+			mount.topologyUnsub = mount.graph.observeTopology().subscribe((event) => {
+				this._emitMountedTopologyEvent(mountPath, event);
+			});
+		}
+	}
+
+	private _releaseMountedTopologyForwarders(): void {
+		for (const mount of this._mounts) {
+			mount.topologyUnsub?.();
+			mount.topologyUnsub = undefined;
+		}
+	}
+
+	private _emitMountedTopologyEvent(mountPath: string, event: TopologyEvent): void {
+		if (this._topologyObservers.size === 0) return;
+		this._emitTopologyEvent({
+			kind: event.kind,
+			path: prefixTopologyPath(mountPath, event.path),
+			deps: event.deps.map((dep) => prefixTopologyPath(mountPath, dep)),
+			...(event.prevDeps !== undefined
+				? { prevDeps: event.prevDeps.map((dep) => prefixTopologyPath(mountPath, dep)) }
+				: {}),
+			...(event.factory !== undefined ? { factory: event.factory } : {}),
+			seq: this._clock++,
+		});
+	}
+
+	private _emitTopologyEvent(event: TopologyEvent): void {
+		if (this._topologyDelivering) {
+			this._topologyQueue.push(event);
+			return;
+		}
+		this._topologyDelivering = true;
+		try {
+			let current: TopologyEvent | undefined = event;
+			while (current !== undefined) {
+				const observers = [...this._topologyObservers.entries()];
+				for (const [id, observer] of observers) {
+					if (this._topologyObservers.get(id) !== observer) continue;
+					if (observer.path !== undefined && !topologyPathMatches(current.path, observer.path))
+						continue;
+					try {
+						observer.sink(cloneTopologyEvent(current));
+					} catch {
+						// D145 egress is read-only inspection; observer failure must not veto a
+						// graph registry/rewire mutation that already committed.
+					}
+				}
+				current = this._topologyQueue.shift();
+			}
+		} finally {
+			this._topologyDelivering = false;
+		}
+	}
+
+	/**
+	 * profile() = accumulated-counter snapshot (R-profile / D39). invokes + duration are
+	 * dispatcher-backed (the invoke funnel, F-DISPATCH-ALL) — counters never live on the
+	 * thin node (R-node-thin). Requires `graph({ profile: true })` (opt-in, F-PERF).
+	 */
+	profile(): Profile {
+		const nodes: Record<string, NodeProfile> = {};
+		let totalInvokes = 0;
+		for (const e of this._entries.values()) {
+			const h = e.node.handle;
+			const stat = h ? this._dispatcher.statFor(h) : undefined;
+			const invokes = stat?.invokes ?? 0;
+			nodes[e.id] = {
+				invokes,
+				totalDurationNs: stat?.totalDurationNs ?? 0,
+				lastDurationNs: stat?.lastDurationNs ?? 0,
+				status: e.node.status,
+			};
+			// graph-scoped (QA D-2): sum THIS graph's nodes, NOT the dispatcher-global
+			// counter (which would leak invokes from other graphs sharing the dispatcher).
+			totalInvokes += invokes;
+		}
+		return { totalInvokes, nodes };
+	}
+
+	/** Versioned graph lifecycle checkpoint (R-snapshot / D83 / D90). Pure capture, no storage I/O. */
+	checkpoint(): GraphCheckpoint {
+		return this._checkpoint("", new WeakSet());
+	}
+
+	private _checkpoint(_prefix: string, stack: WeakSet<Graph>): GraphCheckpoint {
+		if (stack.has(this)) {
+			throw new Error("checkpoint: cyclic graph mount detected");
+		}
+		stack.add(this);
+		const discovered = new Map<Node<unknown>, string>();
+		const localId = (n: Node<unknown>): string => {
+			const e = this._entries.get(n);
+			if (e) return `${_prefix}${e.id}`;
+			let sid = this._synthIds.get(n);
+			if (sid === undefined) {
+				do {
+					sid = `~${n.factory ?? "?"}#${this._synthSeq++}`;
+				} while (this._byId.has(sid));
+				this._synthIds.set(n, sid);
+			}
+			discovered.set(n, sid);
+			return `${_prefix}${sid}`;
+		};
+		const nodes: GraphCheckpointNode[] = [];
+		const edges: DescribeEdge[] = [];
+		for (const entry of this._entries.values()) {
+			const id = `${_prefix}${entry.id}`;
+			const liveIds = entry.node.deps.map(localId);
+			nodes.push(
+				this._checkpointNode(entry.node, id, {
+					name: entry.name,
+					factory: checkpointFactory(entry.factory, entry.node, false, entry.restore, entry.meta),
+					deps: liveIds,
+					meta: entry.meta,
+				}),
+			);
+			for (const from of liveIds) edges.push({ from, to: id });
+		}
+		const visited = new Set<Node<unknown>>();
+		const queue: Node<unknown>[] = [...discovered.keys()];
+		for (let i = 0; i < queue.length; i += 1) {
+			const inner = queue[i];
+			if (visited.has(inner)) continue;
+			visited.add(inner);
+			const sid = discovered.get(inner);
+			if (sid === undefined) continue;
+			const liveIds = inner.deps.map(localId);
+			for (const dep of inner.deps) {
+				if (!this._entries.has(dep) && !visited.has(dep)) queue.push(dep);
+			}
+			const id = `${_prefix}${sid}`;
+			nodes.push(
+				this._checkpointNode(inner, id, {
+					factory: checkpointFactory(inner.factory ?? "?", inner, true),
+					deps: liveIds,
+				}),
+			);
+			for (const from of liveIds) edges.push({ from, to: id });
+		}
+		const checkpoint: GraphCheckpoint = {
+			version: GRAPH_CHECKPOINT_VERSION,
+			nodes,
+			edges,
+		};
+		if (this.name !== undefined) checkpoint.name = this.name;
+		if (this._mounts.length > 0) {
+			checkpoint.mounts = this._mounts.map((m) => ({
+				at: m.at,
+				checkpoint: m.graph._checkpoint("", stack),
+			}));
+		}
+		stack.delete(this);
+		return toCheckpointJson(checkpoint, "checkpoint") as unknown as GraphCheckpoint;
+	}
+
+	private _checkpointNode(
+		node: Node<unknown>,
+		id: string,
+		opts: {
+			name?: string;
+			factory: GraphCheckpointFactory;
+			deps: string[];
+			meta?: Record<string, unknown>;
+		},
+	): GraphCheckpointNode {
+		const state = checkpointStateOfNode(node);
+		assertCheckpointQuiescentStatus(node.status, id, "checkpoint");
+		const nonAuthoritativeCollectionHelper = isNonAuthoritativeCollectionHelperMeta(opts.meta);
+		const out: GraphCheckpointNode = {
+			id,
+			factory: opts.factory,
+			status: node.status,
+			deps: opts.deps,
+			value: nonAuthoritativeCollectionHelper
+				? { kind: "SENTINEL" }
+				: checkpointValue(state.cache, state.hasData, `${id}.value`),
+			terminal: checkpointTerminal(state.terminal, `${id}.terminal`),
+			lifecycle: { activated: state.activated, hasCalledFnOnce: state.hasCalledFnOnce },
+			ctxState: {
+				persist: state.ctxState.persist,
+				value: nonAuthoritativeCollectionHelper
+					? { kind: "SENTINEL" }
+					: checkpointValue(
+							state.ctxState.value,
+							state.ctxState.value !== SENTINEL,
+							`${id}.ctxState`,
+						),
+			},
+		};
+		if (opts.name !== undefined) out.name = opts.name;
+		const backendState = checkpointBackendStateOfNode(node, `${id}.backendState`);
+		if (backendState !== undefined) out.backendState = backendState;
+		if (state.version !== undefined) out.version = state.version;
+		if (opts.meta !== undefined)
+			out.meta = toCheckpointJson(opts.meta, `${id}.meta`) as {
+				[key: string]: GraphCheckpointJson;
+			};
+		return out;
+	}
+}
+
+/** Construct a Graph (default global dispatcher; L4-Q4). */
+export function graph(opts: GraphOptions = {}): Graph {
+	return new Graph(opts);
+}
+
+/** @internal D122 graph-owned ephemeral node-group release. */
+export function releaseGraphNodes(
+	graph: Graph,
+	nodes: readonly Node<unknown>[],
+	opts: { reason?: string } = {},
+): void {
+	const registrar = lifecycleRegistrars.get(graph);
+	if (registrar === undefined) throw new Error("graph: unknown lifecycle registrar");
+	registrar.releaseNodes(nodes, opts);
+}
+
+/** @internal D94 descriptor path: register a restored state node without widening Graph. */
+export function restoreStateNodeInGraph<T = unknown>(
+	graph: Graph,
+	id: string,
+	opts: SugarOpts<T> = {},
+): StateNode<T> {
+	const registrar = restoreRegistrars.get(graph);
+	if (registrar === undefined) throw new Error("restoreGraph: unknown graph restore registrar");
+	return registrar.stateNode(id, opts);
+}
+
+/** @internal D94 descriptor path: register a restored ctx-level node without widening Graph. */
+export function restoreNodeInGraph<T = unknown>(
+	graph: Graph,
+	id: string,
+	factory: string,
+	deps: readonly Node<unknown>[],
+	fn: NodeFn | null,
+	opts: SugarOpts<T> = {},
+): Node<T> {
+	const registrar = restoreRegistrars.get(graph);
+	if (registrar === undefined) throw new Error("restoreGraph: unknown graph restore registrar");
+	return registrar.node(id, factory, deps, fn, opts);
+}
diff --git a/packages/ts/src/graph/higher-order.ts b/packages/ts/src/graph/higher-order.ts
new file mode 100644
index 00000000..956635e9
--- /dev/null
+++ b/packages/ts/src/graph/higher-order.ts
@@ -0,0 +1,413 @@
+/**
+ * Higher-order operators — switchMap / mergeMap / concatMap / exhaustMap / flatMap
+ * (D47 / R-rewire-deferred / CSP-2.7; per-language sugar, D6/D24, never in parity).
+ *
+ * Each projects every outer value to an INNER source and flattens the inners' emissions. The
+ * inner sources are wired as runtime DEPS via the deferred-self-rewire substrate affordance
+ * (`ctx.rewireNext`, D47) — NOT an internal subscribe (D45 bans that; it would create a describe
+ * island). Growing/shrinking the dep set is deferred to the committed wave boundary, so a fn
+ * never mutates its own topology mid-run (that is the D37 feedback-cycle ERROR). An inner that
+ * COMPLETEs is `unsubscribeDep`'d → its source `_deactivate`s + fires `onDeactivation`: that is the
+ * cancellation / abortInFlight basis (switchMap drops the superseded inner's WORK, not just its
+ * output; mergeMap bounds memory). Built on the bare `node` primitive via the {@link Operator}
+ * factory shape + the `g.initNode` funnel (D43), so the real factory name shows in describe.
+ *
+ * Lifecycle folding (D47/D81): completeWhenDepsComplete:false + terminalAsRealInput:true +
+ * errorWhenDepsError:false — the operator owns completion (emit COMPLETE only when the SOURCE is
+ * done AND no inner is live / pending), and observes source/inner ERROR so it can remove every live
+ * inner before emitting ERROR. Those removals drain after terminal via D62: terminal seals output,
+ * while helper-owned upstream work still sees unsubscribeDep->_deactivate->onDeactivation teardown.
+ *
+ * Alignment: each run issues REMOVES before ADDS so the per-node FIFO drain keeps the operator's
+ * tracked inner list aligned with the live dep order across the intermediate boundary waves (a
+ * removed dep is silent — no settle — and applies before any added dep's push-on-subscribe wave).
+ */
+
+import {
+	CTX_NODE_BINDING,
+	type Ctx,
+	depBatch,
+	depCount,
+	depTerminal,
+	isTerminalComplete,
+	isTerminalError,
+	type NodeFn,
+	terminalErrorValue,
+} from "../ctx/types.js";
+import type { Node } from "../node/node.js";
+import { errorPayload } from "../protocol/messages.js";
+import { initNode, type Operator } from "./operators.js";
+import { fromAsyncIter, fromIter, fromPromise, type NodeInput, of } from "./sources.js";
+
+/** Project an outer value to an inner source (a Node, Promise, (a)sync iterable, or scalar). */
+export type Project<TIn, TOut> = (value: TIn) => NodeInput<TOut>;
+
+type Mode = "merge" | "switch" | "concat" | "exhaust";
+
+/** Options for {@link mergeMap}. */
+export interface MergeMapOptions {
+	/**
+	 * Maximum number of live inner deps at once. `undefined`/`Infinity` keeps the default
+	 * unbounded mergeMap behavior; finite values queue outer values until an inner COMPLETEs.
+	 */
+	readonly concurrent?: number;
+}
+
+/** Per-node bookkeeping (ctx.state): the live inner deps (aligned with deps[1..]) + pending queue. */
+interface MapState<TIn> {
+	inners: Node<unknown>[];
+	queue: TIn[]; // concatMap / bounded mergeMap pending values (lazy projection)
+	sourceDone: boolean;
+}
+
+function uniqueNodes(nodes: readonly Node<unknown>[]): Node<unknown>[] {
+	const seen = new Set<Node<unknown>>();
+	const out: Node<unknown>[] = [];
+	for (const n of nodes) {
+		if (seen.has(n)) continue;
+		seen.add(n);
+		out.push(n);
+	}
+	return out;
+}
+
+function cleanupAllInners<TIn>(ctx: Ctx, st: MapState<TIn>, body: NodeFn): void {
+	for (const inner of uniqueNodes(st.inners)) ctx.rewireNext.unsubscribeDep(inner, body);
+	st.inners = [];
+	st.queue.length = 0;
+	st.sourceDone = true;
+	ctx.state.set(st);
+}
+
+function firstErrorTerminal(ctx: Ctx): unknown {
+	for (let i = 0; i < depCount(ctx); i++) {
+		const terminal = depTerminal(ctx, i);
+		if (isTerminalError(terminal)) return terminalErrorValue(terminal);
+	}
+	return undefined;
+}
+
+function fromAnyInCtx<T>(ctx: Ctx, input: NodeInput<T>): Node<unknown> {
+	const binding = ctx[CTX_NODE_BINDING];
+	if (isNode(input)) return input as Node<unknown>;
+
+	const nodeOpts = binding ? { dispatcher: binding.dispatcher } : {};
+	const make = (op: Operator<never, T>) =>
+		(binding
+			? binding.create(() => initNode(op, [], nodeOpts))
+			: initNode(op, [], nodeOpts)) as Node<unknown>;
+
+	if (isThenable(input)) return make(fromPromise(input as PromiseLike<T>));
+	if (input !== null && input !== undefined) {
+		const candidate = input as {
+			[Symbol.asyncIterator]?: unknown;
+			[Symbol.iterator]?: unknown;
+		};
+		if (typeof candidate[Symbol.asyncIterator] === "function") {
+			return make(fromAsyncIter(input as AsyncIterable<T>));
+		}
+		if (typeof candidate[Symbol.iterator] === "function") {
+			return make(fromIter(input as Iterable<T>));
+		}
+	}
+	return make(of(input as T));
+}
+
+function isNode(x: unknown): x is Node {
+	return (
+		x != null &&
+		typeof x === "object" &&
+		"cache" in x &&
+		typeof (x as Node).subscribe === "function"
+	);
+}
+
+function isThenable(x: unknown): x is PromiseLike<unknown> {
+	return x != null && typeof (x as PromiseLike<unknown>).then === "function";
+}
+
+function normalizeConcurrent(factory: string, concurrent: number | undefined): number {
+	if (concurrent === undefined || concurrent === Number.POSITIVE_INFINITY) {
+		return Number.POSITIVE_INFINITY;
+	}
+	if (!Number.isInteger(concurrent) || concurrent < 1) {
+		throw new RangeError(`${factory}: concurrent must be a positive integer or Infinity`);
+	}
+	return concurrent;
+}
+
+/**
+ * The shared higher-order machinery. The operator depends on the source S at index 0; inner
+ * sources occupy indices 1.. (added/removed at runtime via ctx.rewireNext). The body is
+ * SELF-CATCHING (D30) and re-supplies itself on every rewire (the initNode wrap covers only the
+ * first run; the re-supplied fn must stay self-catching).
+ */
+function mapOperator<TIn, TOut>(
+	factory: string,
+	project: Project<TIn, TOut>,
+	mode: Mode,
+	opts: { concurrent?: number } = {},
+): Operator<TIn, TOut> {
+	const maxConcurrent = normalizeConcurrent(factory, opts.concurrent);
+	const body: NodeFn = (ctx: Ctx) => {
+		let st: MapState<TIn> | undefined;
+		try {
+			st = (ctx.state.get<MapState<TIn>>() ?? {
+				inners: [],
+				queue: [],
+				sourceDone: false,
+			}) as MapState<TIn>;
+			let inners = st.inners;
+			const queue = st.queue;
+
+			// 1. forward any inner DATA this wave (index-independent — flatten whichever inner fired).
+			for (let i = 1; i < depCount(ctx); i++) {
+				const b = depBatch(ctx, i);
+				if (b && b.length > 0) for (const v of b) ctx.down([["DATA", v]]);
+			}
+
+			// D81: source ERROR / inner ERROR are terminal operator edges. Detach live inners first,
+			// then emit ERROR. Same-wave inner DATA that preceded the terminal is forwarded above.
+			// Do not send COMPLETE/ERROR to those inner sources.
+			const terminalError = firstErrorTerminal(ctx);
+			if (terminalError !== undefined) {
+				cleanupAllInners(ctx, st, body);
+				ctx.down([["ERROR", terminalError]]);
+				return;
+			}
+
+			if (isTerminalComplete(depTerminal(ctx, 0))) st.sourceDone = true;
+
+			// 2. drop inners that terminated this/any wave (bounding); `inners` aligns with deps[1..].
+			const toRemove: Node<unknown>[] = [];
+			const survivors: Node<unknown>[] = [];
+			for (let i = 0; i < inners.length; i++) {
+				if (isTerminalComplete(depTerminal(ctx, i + 1))) toRemove.push(inners[i]);
+				else survivors.push(inners[i]);
+			}
+			inners = survivors;
+
+			// 3. project the source's new value(s) per mode.
+			const toAdd: Node<unknown>[] = [];
+			const make = (v: TIn): Node<unknown> => fromAnyInCtx(ctx, project(v));
+			const isRemovedThisWave = (inner: Node<unknown>): boolean => toRemove.includes(inner);
+			const canTrackInner = (inner: Node<unknown>): boolean =>
+				!inners.includes(inner) && !isRemovedThisWave(inner);
+			const enqueueMerge = (v: TIn) => {
+				if (maxConcurrent === Number.POSITIVE_INFINITY && queue.length === 0) {
+					const inner = make(v);
+					// a projector returning an ALREADY-LIVE Node is already merged: subscribeDep is
+					// set-idempotent, so double-tracking it in `inners` would desync the
+					// inners[i] <-> deps[i+1] map permanently. Skip the duplicate.
+					if (!canTrackInner(inner)) return;
+					inners.push(inner);
+					toAdd.push(inner);
+					return;
+				}
+				queue.push(v);
+			};
+			const drainMergeQueue = () => {
+				while (queue.length > 0 && inners.length < maxConcurrent) {
+					const inner = make(queue.shift() as TIn);
+					if (!canTrackInner(inner)) continue;
+					inners.push(inner);
+					toAdd.push(inner);
+				}
+			};
+			const sb = depBatch(ctx, 0) as readonly TIn[] | null;
+			if (sb && sb.length > 0) {
+				if (mode === "switch") {
+					// switch to the latest value: cancel every current inner EXCEPT a (re-projected)
+					// already-live one — the dep set is unique, so removing+re-adding the same Node
+					// would needlessly tear down + re-subscribe it. Superseded sources torn down.
+					const inner = make(sb[sb.length - 1]);
+					for (const live of inners) if (live !== inner) toRemove.push(live);
+					if (isRemovedThisWave(inner)) {
+						inners = [];
+					} else {
+						if (!inners.includes(inner)) toAdd.push(inner);
+						inners = [inner];
+					}
+				} else if (mode === "merge") {
+					for (const v of sb) {
+						enqueueMerge(v);
+					}
+				} else if (mode === "concat") {
+					for (const v of sb) queue.push(v); // lazy: project on activation
+				} else {
+					// exhaust: ignore the source while an inner is active.
+					if (inners.length === 0) {
+						const inner = make(sb[0]);
+						if (canTrackInner(inner)) {
+							inners.push(inner);
+							toAdd.push(inner);
+						}
+					}
+				}
+			}
+
+			// 3a. bounded mergeMap: drain queued outer values as inner COMPLETEs free slots.
+			if (mode === "merge" && queue.length > 0) drainMergeQueue();
+
+			// 3b. concat: activate the queue head when the single slot is free.
+			if (mode === "concat" && inners.length === 0 && toAdd.length === 0 && queue.length > 0) {
+				const inner = make(queue.shift() as TIn);
+				if (canTrackInner(inner)) {
+					inners.push(inner);
+					toAdd.push(inner);
+				}
+			}
+
+			ctx.state.set({ inners, queue, sourceDone: st.sourceDone });
+
+			// 4. issue REMOVES before ADDS (alignment): a removed dep is silent + applies before the
+			//    added dep's push-on-subscribe settle wave, so the tracked list stays aligned.
+			for (const r of toRemove) ctx.rewireNext.unsubscribeDep(r, body);
+			for (const a of toAdd) ctx.rewireNext.subscribeDep(a, body);
+
+			// 5. completion: the SOURCE is done AND nothing is live or pending → COMPLETE (D47 folding;
+			//    a queued/just-added inner keeps it open). If terminal output happens in a wave that
+			//    also queued cleanup rewire, D62 still drains that queue after terminal.
+			if (st.sourceDone && inners.length === 0 && toAdd.length === 0 && queue.length === 0) {
+				ctx.down([["COMPLETE"]]);
+			}
+		} catch (e) {
+			if (st) cleanupAllInners(ctx, st, body);
+			ctx.down([["ERROR", errorPayload(e, "projector threw without a valid error payload")]]); // D30/D81: a throwing projector → cleanup inners, then ERROR
+		}
+	};
+
+	return {
+		factory,
+		body,
+		// D47/D81 folding: the operator owns completion + terminal ERROR cleanup.
+		opts: { completeWhenDepsComplete: false, terminalAsRealInput: true, errorWhenDepsError: false },
+	};
+}
+
+/**
+ * switchMap: project each source value to an inner; on a new source value, CANCEL the in-flight
+ * inner (its source `_deactivate`s — abortInFlight) and switch to the new one. Only the current
+ * inner's emissions are forwarded.
+ */
+export function switchMap<TIn, TOut>(project: Project<TIn, TOut>): Operator<TIn, TOut> {
+	return mapOperator("switchMap", project, "switch");
+}
+
+/**
+ * mergeMap (a.k.a. flatMap): project each source value to an inner and keep ALL inners live,
+ * interleaving their emissions. A completed inner is removed (memory bounding). On source/inner
+ * ERROR or projector failure, every live inner is removed before the operator emits ERROR (D81).
+ */
+export function mergeMap<TIn, TOut>(
+	project: Project<TIn, TOut>,
+	opts: MergeMapOptions = {},
+): Operator<TIn, TOut> {
+	return mapOperator("mergeMap", project, "merge", opts);
+}
+
+/** flatMap: alias of {@link mergeMap} (RxJS naming parity). */
+export function flatMap<TIn, TOut>(
+	project: Project<TIn, TOut>,
+	opts: MergeMapOptions = {},
+): Operator<TIn, TOut> {
+	return mapOperator("flatMap", project, "merge", opts);
+}
+
+/**
+ * concatMap: project each source value to an inner, but run AT MOST ONE inner at a time — queue
+ * later source values (lazy projection) and activate the next only when the active inner COMPLETEs.
+ * Preserves source order.
+ */
+export function concatMap<TIn, TOut>(project: Project<TIn, TOut>): Operator<TIn, TOut> {
+	return mapOperator("concatMap", project, "concat");
+}
+
+/**
+ * exhaustMap: while an inner is active, DROP new source values; project the next source value only
+ * after the active inner COMPLETEs.
+ */
+export function exhaustMap<TIn, TOut>(project: Project<TIn, TOut>): Operator<TIn, TOut> {
+	return mapOperator("exhaustMap", project, "exhaust");
+}
+
+/** Per-node bookkeeping for {@link repeat}: the round index + the current live inner. */
+interface RepeatState {
+	started: boolean;
+	round: number;
+	inner: Node<unknown> | null;
+}
+
+/**
+ * repeat: play a source `count` times in sequence (RxJS `repeat`). A DEPLESS self-driving operator
+ * (Operator<never, S>, instantiate via `g.initNode(repeat(factory, count), [])`) — NOT a dep-operator.
+ *
+ * It takes a `factory: () => NodeInput<S>` (a RECIPE), not a source Node, because clean-slate Nodes
+ * are HOT/shared (multicast + cache): re-subscribing the SAME node replays its cache, it does not
+ * re-RUN the source. RxJS `repeat` re-subscribes the COLD source = a fresh subscription each round;
+ * the clean-slate analogue is a fresh node per round → a factory. (A `repeat(count)`-over-a-Node
+ * shape remains deferred: D47's no-net-change-is-a-no-op makes
+ * `unsubscribeDep(S)+subscribeDep(S)` on the SAME boundary cancel out. D115 keeps the model to
+ * ordinary unsubscribe plus a later subscribe, so same-node repeat needs a separate future design.)
+ *
+ * Mechanism (reuses the D47 self-rewire substrate, like the *Map family; NOT an internal subscribe,
+ * D45): on activation it mints round 0's inner via `ctx.rewireNext.subscribeDep`; each round's inner DATA
+ * is forwarded; on the inner's COMPLETE (`completeWhenDepsComplete:false + terminalAsRealInput:true`)
+ * it unsubscribeDep's the finished inner and, if rounds remain, subscribeDep's a FRESH `factory()` inner (a
+ * distinct node → a real net change, not the no-op same-node case); after the last round it emits
+ * COMPLETE. An inner ERROR auto-forwards (errorWhenDepsError default → repeat errors). The body is
+ * SELF-CATCHING (D30) and re-supplied on every rewire. The factory MUST mint a FRESH node per call
+ * (a factory returning the same Node makes unsubscribeDep+subscribeDep a net-zero no-op → repeat wedges).
+ */
+export function repeat<S>(factory: () => NodeInput<S>, count: number): Operator<never, S> {
+	if (!Number.isInteger(count) || count < 1) {
+		throw new RangeError(`repeat: count must be a positive integer (got ${count})`);
+	}
+	const body: NodeFn = (ctx: Ctx) => {
+		try {
+			const st = (ctx.state.get<RepeatState>() ?? {
+				started: false,
+				round: 0,
+				inner: null,
+			}) as RepeatState;
+			// 1. forward the current inner's DATA this wave (the inner is the sole dep once wired).
+			for (let i = 0; i < depCount(ctx); i++) {
+				const b = depBatch(ctx, i);
+				if (b && b.length > 0) for (const v of b) ctx.down([["DATA", v]]);
+			}
+			// 2. activation: mint round 0's inner.
+			if (!st.started) {
+				st.started = true;
+				st.round = 0;
+				const inner = fromAnyInCtx(ctx, factory());
+				st.inner = inner;
+				ctx.state.set(st);
+				ctx.rewireNext.subscribeDep(inner, body);
+				return;
+			}
+			// 3. inner COMPLETE → next round or terminal COMPLETE.
+			if (st.inner !== null && isTerminalComplete(depTerminal(ctx, 0))) {
+				const old = st.inner;
+				ctx.rewireNext.unsubscribeDep(old, body); // bound the finished round's inner
+				if (st.round + 1 < count) {
+					st.round += 1;
+					const next = fromAnyInCtx(ctx, factory());
+					st.inner = next;
+					ctx.state.set(st);
+					ctx.rewireNext.subscribeDep(next, body);
+				} else {
+					st.inner = null;
+					ctx.state.set(st);
+					ctx.down([["COMPLETE"]]);
+				}
+			}
+		} catch (e) {
+			ctx.down([["ERROR", errorPayload(e, "repeat threw without a valid error payload")]]); // D30 (self-catch survives rewire)
+		}
+	};
+	return {
+		factory: "repeat",
+		body,
+		opts: { completeWhenDepsComplete: false, terminalAsRealInput: true },
+	};
+}
diff --git a/packages/ts/src/graph/index.ts b/packages/ts/src/graph/index.ts
new file mode 100644
index 00000000..73456a8f
--- /dev/null
+++ b/packages/ts/src/graph/index.ts
@@ -0,0 +1,156 @@
+export * from "../composition/index.js";
+export * from "../data-structures/index.js";
+export * from "../render/index.js";
+export {
+	canonicalTopologyBytes,
+	canonicalTopologyJson,
+	GRAPH_BLUEPRINT_VERSION,
+	type GraphBlueprint,
+	type GraphBlueprintDiagnosticCode,
+	type GraphBlueprintDiagnosticIssue,
+	type GraphBlueprintDiagnostics,
+	type GraphBlueprintHash,
+	type GraphBlueprintHashInput,
+	type GraphBlueprintHashOptions,
+	type GraphBlueprintJson,
+	type GraphBlueprintOptions,
+	type GraphBlueprintProvenance,
+	graphBlueprintDiagnostics,
+	type NormalizedGraphTopologyNode,
+	type NormalizedGraphTopologySnapshot,
+	normalizeTopology,
+	withBlueprintHash,
+	withBlueprintProvenance,
+} from "./blueprint.js";
+export {
+	type CascadingCacheEvent,
+	type CascadingCachePolicy,
+	type CascadingCacheStatus,
+	type ReactiveCascadingCache,
+	type ReactiveCascadingCacheOptions,
+	reactiveCascadingCache,
+} from "./cascading-cache.js";
+export {
+	GRAPH_CHECKPOINT_VERSION,
+	type GraphCheckpoint,
+	type GraphCheckpointEdge,
+	type GraphCheckpointFactory,
+	type GraphCheckpointJson,
+	type GraphCheckpointMount,
+	type GraphCheckpointNode,
+	type GraphCheckpointTerminal,
+	type GraphCheckpointValue,
+	type GraphCheckpointVersion,
+} from "./checkpoint.js";
+export type {
+	DescribeEdge,
+	DescribeNode,
+	DescribeOpts,
+	DescribeSnapshot,
+	GraphTopologyEdge,
+	GraphTopologyNode,
+	GraphTopologySnapshot,
+} from "./describe.js";
+export {
+	type CausalChain,
+	type CausalStep,
+	type ExplainPathOptions,
+	type ExplainPathReason,
+	explainPath,
+	type IslandReport,
+	type ReachableDirection,
+	type ReachableOptions,
+	type ReachableResult,
+	reachable,
+	type ValidateNoIslandsResult,
+	validateNoIslands,
+} from "./diagnostics.js";
+export {
+	type DriverCancel,
+	type DriverResult,
+	domWebSocketDriver,
+	EnvironmentDrivers,
+	type EnvironmentDriversInit,
+	type FetchLike,
+	type FetchResponseLike,
+	fetchHttpDriver,
+	type HttpRequest,
+	type HttpResponse,
+	type LocalHttpDriver,
+	type LocalProcessDriver,
+	type LocalSseDriver,
+	type LocalWebhookDriver,
+	type LocalWebSocketDriver,
+	type ProcessCommand,
+	type ProcessResult,
+	type SseDriverEvent,
+	type SseEvent,
+	type SseRequest,
+	type WebhookDriverEvent,
+	type WebhookEvent,
+	type WebhookRegistration,
+	type WebSocketConstructorLike,
+	type WebSocketDriverEvent,
+	type WebSocketEvent,
+	type WebSocketLike,
+	type WebSocketRequest,
+	type WebSocketSend,
+	type WebSocketSendResult,
+	type WebSocketSessionHandle,
+} from "./environment.js";
+export {
+	type DerivedFn,
+	type EffectFn,
+	Graph,
+	type GraphOptions,
+	graph,
+	StateNode,
+	type SugarOpts,
+	type TopologyGroup,
+	type TopologyGroupOptions,
+	type TopologyGroupReleaseOptions,
+} from "./graph.js";
+export {
+	coalesceObserve,
+	filterObserve,
+	type NodeProfile,
+	type ObserveEvent,
+	type ObserveEventEquals,
+	type ObservePredicate,
+	type ObserveStream,
+	type Profile,
+	type TopologyEvent,
+	type TopologyEventKind,
+	type TopologyStream,
+} from "./inspect.js";
+export {
+	type BackoffPolicy,
+	backoffDelayMs,
+	nextRetryDelayMs,
+	noBackoff,
+	type RetryPolicy,
+	type RetryState,
+	type RetryStatus,
+	retryPolicy,
+	shouldRetry,
+} from "./resilience.js";
+export {
+	defaultRestoreRegistry,
+	type GraphRestoreDescriptor,
+	type GraphRestoreDescriptorContext,
+	type GraphRestoreRegistry,
+	type RestoreGraphOptions,
+	restoreGraph,
+	stateRestoreDescriptor,
+	takeRestoreDescriptor,
+	timerRestoreDescriptor,
+} from "./restore.js";
+export {
+	type WorkerDerivedBackend,
+	type WorkerDerivedCancel,
+	type WorkerDerivedJob,
+	type WorkerDerivedOptions,
+	type WorkerDerivedSettle,
+	type WorkerDerivedSettlement,
+	workerDerived,
+} from "./worker.js";
diff --git a/packages/ts/src/graph/inspect.ts b/packages/ts/src/graph/inspect.ts
new file mode 100644
index 00000000..c4da9778
--- /dev/null
+++ b/packages/ts/src/graph/inspect.ts
@@ -0,0 +1,129 @@
+/**
+ * observe / profile inspection shapes (R-observe, R-profile / D39).
+ *
+ * observe = a read-only enveloped EGRESS (not a graph node). profile = an opt-in
+ * accumulated-counter snapshot backed by the dispatcher recorder (counters never live on
+ * the thin node, R-node-thin). Per-language (D24, never in parity).
+ */
+
+import type { Status } from "../node/node.js";
+import type { Message } from "../protocol/messages.js";
+
+/** One item of an observe() stream. The envelope carries node identity + ordering. */
+export interface ObserveEvent {
+	/** Mount-aware `::` path of the emitting node (shared key with describe/profile). */
+	path: string;
+	/** The protocol message observed at that node. */
+	msg: Message;
+	/** messageTier(msg[0]). */
+	tier: number;
+	/** Graph-local monotonic sequence (D26) — orders events across nodes. */
+	seq: number;
+}
+
+/** A read-only egress: subscribe to the live ObserveEvent stream; call the returned fn to stop. */
+export interface ObserveStream {
+	subscribe(sink: (e: ObserveEvent) => void): () => void;
+}
+
+export type TopologyEventKind =
+	| "node-registered"
+	| "deps-changed"
+	| "node-released"
+	| "mount-changed";
+
+export interface TopologyEvent {
+	/** D145 graph inspection/lifecycle event kind. Not a protocol message. */
+	readonly kind: TopologyEventKind;
+	/** Mount-aware `::` path of the affected registered node. */
+	readonly path: string;
+	/** Current dep ids after the event, matching describe().nodes[].deps. */
+	readonly deps: readonly string[];
+	/** Previous dep ids for deps-changed events. */
+	readonly prevDeps?: readonly string[];
+	/** Factory name for node-registered and node-released events. */
+	readonly factory?: string;
+	/** Graph-local monotonic sequence shared with observe() ordering. */
+	readonly seq: number;
+}
+
+/** A read-only topology egress stream. It does not activate nodes or emit DATA. */
+export interface TopologyStream {
+	subscribe(sink: (e: TopologyEvent) => void): () => void;
+}
+
+/** Predicate used by filterObserve(). */
+export type ObservePredicate = (event: ObserveEvent) => boolean;
+
+/** Equality used by coalesceObserve() for adjacent observe-event suppression. */
+export type ObserveEventEquals = (prev: ObserveEvent, next: ObserveEvent) => boolean;
+
+/**
+ * Filter a read-only observe egress stream without turning it into a graph node.
+ *
+ * The source stream owns ordering and lifecycle; this helper only decides whether to forward each
+ * ObserveEvent and returns the source unsubscribe unchanged.
+ */
+export function filterObserve(stream: ObserveStream, predicate: ObservePredicate): ObserveStream {
+	return {
+		subscribe(sink) {
+			return stream.subscribe((event) => {
+				if (predicate(event)) {
+					sink(event);
+				}
+			});
+		},
+	};
+}
+
+function sameObserveEvent(prev: ObserveEvent, next: ObserveEvent): boolean {
+	return (
+		prev.path === next.path &&
+		prev.tier === next.tier &&
+		prev.msg[0] === next.msg[0] &&
+		Object.is(messagePayload(prev.msg), messagePayload(next.msg))
+	);
+}
+
+function messagePayload(msg: Message): unknown {
+	return msg.length > 1 ? msg[1] : undefined;
+}
+
+/**
+ * Suppress adjacent duplicate ObserveEvents while preserving the source stream order.
+ *
+ * This is egress-side coalescing only: it does not batch, delay, reorder, alter seq values, or add
+ * topology to describe(). Pass a custom equality when the caller wants a narrower or wider
+ * definition of "duplicate".
+ */
+export function coalesceObserve(
+	stream: ObserveStream,
+	equals: ObserveEventEquals = sameObserveEvent,
+): ObserveStream {
+	return {
+		subscribe(sink) {
+			let previous: ObserveEvent | undefined;
+			return stream.subscribe((event) => {
+				if (previous && equals(previous, event)) {
+					return;
+				}
+				previous = event;
+				sink(event);
+			});
+		},
+	};
+}
+
+/** Per-node profile counters (D39). invokes/duration are dispatcher-backed (R-profile). */
+export interface NodeProfile {
+	invokes: number;
+	totalDurationNs: number;
+	lastDurationNs: number;
+	status: Status;
+}
+
+/** profile() snapshot. Shares the mount-aware `::` path key with describe/observe. */
+export interface Profile {
+	totalInvokes: number;
+	nodes: Record<string, NodeProfile>;
+}
diff --git a/packages/ts/src/graph/operators.ts b/packages/ts/src/graph/operators.ts
new file mode 100644
index 00000000..cb35996d
--- /dev/null
+++ b/packages/ts/src/graph/operators.ts
@@ -0,0 +1,781 @@
+/**
+ * Operators as free-standing factory definitions (D43 / D6 / D40 Catalog-first).
+ *
+ * Operators are `node` sugar (D6), NOT verbs (D4) and NEVER in parity (D24). Each is a
+ * pure {@link Operator} spec — `{factory, body, opts}` — built on the bare `node` primitive
+ * (NOT the `derived` verb): `body` reads ctx dep slots positionally and emits via
+ * `ctx.down`. Two ways to instantiate:
+ *
+ *   - {@link initNode}(op, deps, opts?) — bare, no Graph; returns a working `Node<T>`.
+ *   - `g.initNode(op, deps, opts?)` — graph-bound; the SAME call, plus inspection registration
+ *     (the real factory name lands in the graph's `_entries`, so describe/observe/profile
+ *     show it — D6/R-describe — while the node stays thin, R-node-thin).
+ *
+ * The D30 throw→ERROR boundary lives once, in the free {@link initNode} (which `g.initNode`
+ * funnels through). The pure-ts `operatorOpts/partialOperatorOpts/gatedOperatorOpts` trio is
+ * NOT ported: its sole job (`describeKind:"derived"`) is dead under D6/D39 (factory = the
+ * REAL operator name); only the `partial`/`terminalAsRealInput` flags survive, carried
+ * per-operator in `op.opts`.
+ *
+ * Config is folded into the factory (`map(fn)`, `scan(reducer, seed)`, `take(n)`, `merge()`),
+ * so fn params are annotated where the source type can't be inferred (RxJS-pipe cost);
+ * dep-type safety is recovered by the typed `g.initNode` overloads.
+ */
+
+import {
+	type Ctx,
+	depBatch,
+	depCount,
+	depLatest,
+	depTerminal,
+	isTerminalComplete,
+	isTerminalError,
+	type NodeFn,
+	terminalErrorValue,
+} from "../ctx/types.js";
+import type { NodeCore } from "../node/core.js";
+import { Node, type NodeOptions, withNodeCore } from "../node/node.js";
+import { errorPayload } from "../protocol/messages.js";
+import { type GraphCheckpointJson, toCheckpointJson } from "./checkpoint.js";
+import type { GraphRestoreDefinition, GraphRestoreEntry, GraphRestoreRegistry } from "./restore.js";
+
+/**
+ * A free-standing operator definition (D43). `TIn` = the element type each dep delivers
+ * (the operator reads `depLatest(ctx, i) as TIn`); `TOut` = the emitted value type.
+ * `__in`/`__out` are phantom-only (never assigned) — they let `g.initNode` infer + check the
+ * dep tuple against the operator without an explicit type argument.
+ */
+export interface Operator<TIn = unknown, TOut = unknown> {
+	/** Real operator name shown in describe (D6/L1.5) — recorded at `_add` by `g.initNode`. */
+	readonly factory: string;
+	/** The ctx-body: reads ctx dep slots positionally, emits via `ctx.down`. */
+	readonly body: (ctx: Ctx) => void;
+	/** Behavioral node options the operator needs (e.g. `partial:true` for combine-family). */
+	readonly opts?: Partial<NodeOptions<TOut>>;
+	/**
+	 * D97/D100 restore metadata derived from a named definition or static built-in config.
+	 * This is semantic metadata only; dispatcher handles stay graph-local runtime state.
+	 */
+	readonly restore?: {
+		ref: string;
+		config?: GraphCheckpointJson;
+		configVersion?: GraphCheckpointJson;
+	};
+	/** @internal phantom — never set; carries the dep element type for `g.initNode` inference. */
+	readonly __in?: TIn;
+	/** @internal phantom — never set; carries the output value type. */
+	readonly __out?: TOut;
+}
+
+type MutableRestoreRegistry = Map<string, GraphRestoreEntry> | Record<string, GraphRestoreEntry>;
+
+export type RestoreRegistryEntry = GraphRestoreEntry;
+
+export interface Definition<S = unknown, T = unknown> extends GraphRestoreDefinition<S, T> {
+	readonly ref: string;
+	readonly fn: (v: S) => T;
+}
+
+export interface DefineOpts {
+	registry?: MutableRestoreRegistry;
+}
+
+function registryHas(registry: MutableRestoreRegistry, ref: string): boolean {
+	return registry instanceof Map ? registry.has(ref) : Object.hasOwn(registry, ref);
+}
+
+function registrySet(
+	registry: MutableRestoreRegistry,
+	ref: string,
+	entry: GraphRestoreEntry,
+): void {
+	if (registryHas(registry, ref)) {
+		throw new Error(`restoreRegistry: duplicate ref '${ref}'`);
+	}
+	if (registry instanceof Map) registry.set(ref, entry);
+	else registry[ref] = entry;
+}
+
+export function addToRestoreRegistry(
+	registry: MutableRestoreRegistry,
+	entry: GraphRestoreEntry,
+): void {
+	registrySet(registry, entry.ref, entry);
+}
+
+export function restoreRegistry(
+	entries: readonly GraphRestoreEntry[] = [],
+	base?: GraphRestoreRegistry,
+): Map<string, GraphRestoreEntry> {
+	const out = new Map<string, GraphRestoreEntry>();
+	if (base instanceof Map) {
+		for (const [ref, entry] of base) registrySet(out, ref, entry);
+	} else if (base !== undefined) {
+		for (const [ref, entry] of Object.entries(base)) registrySet(out, ref, entry);
+	}
+	for (const entry of entries) addToRestoreRegistry(out, entry);
+	return out;
+}
+
+function isDefinition<S, T>(fn: ((v: S) => T) | Definition<S, T>): fn is Definition<S, T> {
+	return typeof fn === "object" && fn !== null && (fn as Definition<S, T>).kind === "definition";
+}
+
+export function define<S, T>(
+	ref: string,
+	fn: (v: S) => T,
+	opts: DefineOpts = {},
+): Definition<S, T> {
+	const jsonRef = toCheckpointJson(ref, "define.ref");
+	if (typeof jsonRef !== "string") throw new TypeError("define: ref must be a string");
+	const definition: Definition<S, T> = {
+		kind: "definition",
+		ref: jsonRef,
+		fn,
+	};
+	if (opts.registry !== undefined) addToRestoreRegistry(opts.registry, definition);
+	return definition;
+}
+
+/**
+ * Instantiate an operator as a bare `Node<T>` — NO Graph required (D43 bare-node path).
+ * Wraps `op.body` in the D30 value-throw→ERROR boundary; merges `op.opts` with caller `opts`
+ * (caller wins, so `partial`/`pool`/`dispatcher` overrides take effect). The
+ * dispatcher defaults to the process-global (D26) unless `opts.dispatcher` is passed.
+ *
+ * `g.initNode` is the same call PLUS graph registration; graph inspection
+ * (describe/observe/profile) requires that path — a node built bare here is not registered in
+ * any graph's index.
+ */
+export function initNode<TIn, TOut>(
+	op: Operator<TIn, TOut>,
+	deps: readonly Node<unknown>[],
+	opts: NodeOptions<TOut> = {},
+): Node<TOut> {
+	return makeInitNode(op, deps, opts);
+}
+
+/** @internal Graph-bound operator instantiation into a graph-local B49 core. */
+export function initNodeWithCore<TIn, TOut>(
+	core: NodeCore,
+	op: Operator<TIn, TOut>,
+	deps: readonly Node<unknown>[],
+	opts: NodeOptions<TOut> = {},
+): Node<TOut> {
+	return withNodeCore(core, () => makeInitNode(op, deps, opts));
+}
+
+function makeInitNode<TIn, TOut>(
+	op: Operator<TIn, TOut>,
+	deps: readonly Node<unknown>[],
+	opts: NodeOptions<TOut>,
+): Node<TOut> {
+	const body = operatorNodeFn(op);
+	// D43-reserved / D51: stamp the operator's real factory onto the bare node so a runtime *Map
+	// inner (created here via fromAny, NOT registered in any graph) is named in describe's
+	// auto-discovery. A graph-bound g.initNode also records it in `_entries` (entry.factory wins
+	// there); this field is only read for a node absent from the graph index. Caller opts win.
+	return new Node<TOut>([...deps], body, { factory: op.factory, ...op.opts, ...opts });
+}
+
+/** @internal Build the dispatcher body for an Operator spec. */
+export function operatorNodeFn<TIn, TOut>(op: Operator<TIn, TOut>): NodeFn {
+	return (ctx) => {
+		try {
+			op.body(ctx);
+		} catch (e) {
+			ctx.down([["ERROR", errorPayload(e, "operator threw without a valid error payload")]]); // D30: value-level throw → ERROR
+		}
+	};
+}
+
+// ── Slice 1 — single-dep map / take / control (CSP-2.7 catalog re-derive, D40) ──
+// All read dep 0 positionally + emit via ctx.down. Under D49 every occurrence is DATA (no
+// equals-absorption); a body that returns WITHOUT emitting gets a substrate-synthesized undirty
+// RESOLVED (R-resolved-undirty) — so a "skip this wave" is a bare `return`. Terminal-emitting
+// operators (reduce/last/find/elementAt) read `depTerminal(ctx, 0)` via the
+// `completeWhenDepsComplete:false + terminalAsRealInput:true` flags (R-deps-terminal): the fn fires
+// on the source's COMPLETE and emits its final value. NOT 1:1 pure-ts ports — the frozen reference
+// (D41) uses a producer + internal `subscribeOr`, the D45-banned describe island; these are
+// declared-dep nodes whose single edge `describe` shows truthfully.
+
+/** map: emit fn(value). A named {@link define} makes the map restorable via the map descriptor (D101). */
+export function map<S, T>(fn: ((v: S) => T) | Definition<S, T>): Operator<S, T> {
+	if (isDefinition(fn)) {
+		return mapFromFunction(fn.fn, {
+			ref: "map",
+			config: { fn: toCheckpointJson(fn.ref, `map.fn`) },
+		});
+	}
+	return mapFromFunction(fn);
+}
+
+function mapFromFunction<S, T>(
+	fn: (v: S) => T,
+	restore?: {
+		ref: string;
+		config?: GraphCheckpointJson;
+		configVersion?: GraphCheckpointJson;
+	},
+): Operator<S, T> {
+	return {
+		factory: "map",
+		...(restore ? { restore } : {}),
+		body: (ctx) => {
+			const b = depBatch(ctx, 0);
+			if (!b) return;
+			for (const v of b) ctx.down([["DATA", fn(v as S)]]);
+		},
+	};
+}
+
+/** filter: emit value only when pred(value) (else skip the wave). */
+export function filter<S>(pred: (v: S) => boolean): Operator<S, S> {
+	return {
+		factory: "filter",
+		body: (ctx) => {
+			const b = depBatch(ctx, 0);
+			if (!b) return;
+			for (const v of b) if (pred(v as S)) ctx.down([["DATA", v]]);
+		},
+	};
+}
+
+/** scan: stateful accumulator over the upstream (acc seeded once, kept in ctx.state). */
+export function scan<S, T>(reducer: (acc: T, v: S) => T, seed: T): Operator<S, T> {
+	return {
+		factory: "scan",
+		body: (ctx) => {
+			const b = depBatch(ctx, 0);
+			if (!b) return;
+			let acc = ctx.state.get<T>() ?? seed;
+			for (const v of b) {
+				acc = reducer(acc, v as S);
+				ctx.down([["DATA", acc]]);
+			}
+			ctx.state.set(acc);
+		},
+	};
+}
+
+/** take: emit the first n values, then COMPLETE (terminal-is-forever). */
+export function take<S>(n: number): Operator<S, S> {
+	return {
+		factory: "take",
+		restore: { ref: "take", config: { n: toCheckpointJson(n, "take.n") } },
+		body: (ctx) => {
+			if (n <= 0) {
+				ctx.down([["COMPLETE"]]);
+				return;
+			}
+			const b = depBatch(ctx, 0);
+			if (!b) return;
+			let count = ctx.state.get<number>() ?? 0;
+			if (count >= n) return; // already satisfied
+			for (const v of b) {
+				if (count >= n) break;
+				count += 1;
+				ctx.down(count >= n ? [["DATA", v], ["COMPLETE"]] : [["DATA", v]]);
+			}
+			ctx.state.set(count);
+		},
+	};
+}
+
+/** distinctUntilChanged: emit only when the value differs from the previous emit. */
+export function distinctUntilChanged<S>(eq: (a: S, b: S) => boolean = Object.is): Operator<S, S> {
+	return {
+		factory: "distinctUntilChanged",
+		body: (ctx) => {
+			const b = depBatch(ctx, 0);
+			if (!b) return;
+			const prev = ctx.state.get<{ v: S }>();
+			let last = prev?.v;
+			let hasLast = prev !== undefined;
+			for (const v of b as readonly S[]) {
+				if (hasLast && eq(last as S, v)) continue;
+				last = v;
+				hasLast = true;
+				ctx.down([["DATA", v]]);
+			}
+			if (hasLast) ctx.state.set({ v: last as S });
+		},
+	};
+}
+
+/**
+ * merge: interleave several sources — emit each DATA from whichever dep fired. `partial:true`
+ * (combine-family): fires on any single dep, not gated on all deps settling.
+ */
+export function merge<T>(): Operator<T, T> {
+	return {
+		factory: "merge",
+		opts: { partial: true },
+		body: (ctx) => {
+			for (let i = 0; i < depCount(ctx); i++) {
+				const b = depBatch(ctx, i);
+				if (b && b.length > 0) {
+					for (const v of b) ctx.down([["DATA", v]]);
+				}
+			}
+		},
+	};
+}
+
+/**
+ * reduce: accumulate over the whole source, emit ONE final value on the source's COMPLETE
+ * (RxJS `reduce`). Unlike {@link scan} (which emits every step), reduce stays quiet until the
+ * source terminates. `completeWhenDepsComplete:false + terminalAsRealInput:true`: the fn fires on
+ * the source COMPLETE (reading `terminal===true`) and emits the accumulator + COMPLETE. An empty
+ * source emits the seed (RxJS parity). A source ERROR auto-forwards (errorWhenDepsError default).
+ */
+export function reduce<S, T>(reducer: (acc: T, v: S) => T, seed: T): Operator<S, T> {
+	return {
+		factory: "reduce",
+		opts: { completeWhenDepsComplete: false, terminalAsRealInput: true },
+		body: (ctx) => {
+			const b = depBatch(ctx, 0);
+			let acc = ctx.state.get<T>() ?? seed;
+			if (b) for (const v of b) acc = reducer(acc, v as S);
+			ctx.state.set(acc);
+			if (isTerminalComplete(depTerminal(ctx, 0))) ctx.down([["DATA", acc], ["COMPLETE"]]);
+			// else (live DATA wave): no emit → substrate-synthesized undirty RESOLVED (D49).
+		},
+	};
+}
+
+/**
+ * pairwise: emit `[previous, current]` for each consecutive pair; the very first value produces no
+ * pair (quiet → undirty RESOLVED). Previous value is kept in `ctx.state`.
+ */
+export function pairwise<S>(): Operator<S, readonly [S, S]> {
+	return {
+		factory: "pairwise",
+		body: (ctx) => {
+			const b = depBatch(ctx, 0);
+			if (!b) return;
+			const st = ctx.state.get<{ prev: S }>();
+			let prev = st?.prev;
+			let hasPrev = st !== undefined;
+			for (const v of b as readonly S[]) {
+				if (hasPrev) ctx.down([["DATA", [prev as S, v] as const]]);
+				prev = v;
+				hasPrev = true;
+			}
+			if (hasPrev) ctx.state.set({ prev: prev as S });
+		},
+	};
+}
+
+/** skip: drop the first `n` DATA values, then pass the rest through. */
+export function skip<S>(n: number): Operator<S, S> {
+	return {
+		factory: "skip",
+		body: (ctx) => {
+			const b = depBatch(ctx, 0);
+			if (!b) return;
+			let count = ctx.state.get<number>() ?? 0;
+			for (const v of b) {
+				if (count < n) {
+					count += 1;
+					continue;
+				}
+				ctx.down([["DATA", v]]);
+			}
+			ctx.state.set(count);
+		},
+	};
+}
+
+/**
+ * takeWhile: emit values while `pred` holds; on the first value that fails `pred`, COMPLETE
+ * WITHOUT emitting it (RxJS default, non-inclusive). Terminal-is-forever once it completes.
+ */
+export function takeWhile<S>(pred: (v: S) => boolean): Operator<S, S> {
+	return {
+		factory: "takeWhile",
+		body: (ctx) => {
+			const b = depBatch(ctx, 0);
+			if (!b) return;
+			for (const v of b as readonly S[]) {
+				if (pred(v)) ctx.down([["DATA", v]]);
+				else {
+					ctx.down([["COMPLETE"]]);
+					return;
+				}
+			}
+		},
+	};
+}
+
+/**
+ * first: emit the first value matching `pred` (or simply the first value), then COMPLETE. EDGE
+ * (RxJS divergence, flagged — same class as last/find/elementAt): if the source COMPLETEs with no
+ * matching value, the substrate auto-cascades a bare COMPLETE (no value); RxJS `first()` throws
+ * EmptyError. Could align to `[[ERROR, EmptyError]]` (expressible) if strict RxJS parity is wanted.
+ */
+export function first<S>(pred?: (v: S) => boolean): Operator<S, S> {
+	return {
+		factory: "first",
+		body: (ctx) => {
+			const b = depBatch(ctx, 0);
+			if (!b) return;
+			for (const v of b as readonly S[]) {
+				if (!pred || pred(v)) {
+					ctx.down([["DATA", v], ["COMPLETE"]]);
+					return;
+				}
+			}
+			// no match in this wave → undirty RESOLVED (await next match)
+		},
+	};
+}
+
+/**
+ * last: emit the last value matching `pred` (or the last value) on the source's COMPLETE.
+ * `completeWhenDepsComplete:false + terminalAsRealInput:true`. EDGE (RxJS divergence, flagged):
+ * RxJS `last()` throws EmptyError when no value matched; we COMPLETE without a value (no throw) —
+ * the clean-slate substrate has no "complete-or-throw" terminal and SENTINEL forbids emitting a
+ * placeholder.
+ */
+export function last<S>(pred?: (v: S) => boolean): Operator<S, S> {
+	return {
+		factory: "last",
+		opts: { completeWhenDepsComplete: false, terminalAsRealInput: true },
+		body: (ctx) => {
+			const b = depBatch(ctx, 0);
+			if (b) for (const v of b) if (!pred || pred(v as S)) ctx.state.set({ v });
+			if (isTerminalComplete(depTerminal(ctx, 0))) {
+				const st = ctx.state.get<{ v: S }>();
+				ctx.down(st ? [["DATA", st.v], ["COMPLETE"]] : [["COMPLETE"]]);
+			}
+		},
+	};
+}
+
+/**
+ * find: emit the first value matching `pred`, then COMPLETE. EDGE (RxJS divergence, flagged): RxJS
+ * `find` emits `undefined` then COMPLETE when nothing matched — but `undefined` IS the SENTINEL
+ * (R-sentinel), so a not-found source COMPLETE here emits a bare COMPLETE (no value).
+ */
+export function find<S>(pred: (v: S) => boolean): Operator<S, S> {
+	return {
+		factory: "find",
+		opts: { completeWhenDepsComplete: false, terminalAsRealInput: true },
+		body: (ctx) => {
+			const b = depBatch(ctx, 0);
+			if (b) {
+				for (const v of b) {
+					if (pred(v as S)) {
+						ctx.down([["DATA", v], ["COMPLETE"]]);
+						return;
+					}
+				}
+			}
+			if (isTerminalComplete(depTerminal(ctx, 0))) ctx.down([["COMPLETE"]]); // not found → bare COMPLETE
+		},
+	};
+}
+
+/**
+ * elementAt: emit the value at zero-based `index`, then COMPLETE. EDGE (RxJS divergence, flagged):
+ * RxJS throws ArgumentOutOfRangeError if the source completes before `index`; we COMPLETE without
+ * a value (no throw), consistent with last/find.
+ */
+export function elementAt<S>(index: number): Operator<S, S> {
+	return {
+		factory: "elementAt",
+		opts: { completeWhenDepsComplete: false, terminalAsRealInput: true },
+		body: (ctx) => {
+			const b = depBatch(ctx, 0);
+			let count = ctx.state.get<number>() ?? 0;
+			if (b) {
+				for (const v of b) {
+					if (count === index) {
+						ctx.down([["DATA", v], ["COMPLETE"]]);
+						return;
+					}
+					count++;
+				}
+				ctx.state.set(count);
+			}
+			if (isTerminalComplete(depTerminal(ctx, 0))) ctx.down([["COMPLETE"]]); // index out of range → bare COMPLETE
+		},
+	};
+}
+
+/** Observer object for {@link tap} — lifecycle-aware side effects (RxJS tap observer form). */
+export interface TapObserver<T> {
+	data?: (value: T) => void;
+	error?: (err: unknown) => void;
+	complete?: () => void;
+}
+
+/**
+ * tap: invoke a side effect on each DATA (function form) or on data/error/complete (observer form);
+ * values pass through unchanged. The observer form reads source terminals
+ * (`completeWhenDepsComplete:false + errorWhenDepsError:false + terminalAsRealInput:true`) so it can
+ * call `error`/`complete` then forward the terminal; the function form lets the substrate
+ * auto-cascade terminals.
+ */
+export function tap<S>(fnOrObserver: ((v: S) => void) | TapObserver<S>): Operator<S, S> {
+	if (typeof fnOrObserver === "function") {
+		const fn = fnOrObserver;
+		return {
+			factory: "tap",
+			body: (ctx) => {
+				const b = depBatch(ctx, 0);
+				if (b)
+					for (const v of b) {
+						fn(v as S);
+						ctx.down([["DATA", v]]);
+					}
+			},
+		};
+	}
+	const obs = fnOrObserver;
+	return {
+		factory: "tap",
+		opts: {
+			completeWhenDepsComplete: false,
+			errorWhenDepsError: false,
+			terminalAsRealInput: true,
+		},
+		body: (ctx) => {
+			const terminal = depTerminal(ctx, 0);
+			if (isTerminalComplete(terminal)) {
+				obs.complete?.();
+				ctx.down([["COMPLETE"]]);
+				return;
+			}
+			if (isTerminalError(terminal)) {
+				const err = terminalErrorValue(terminal);
+				obs.error?.(err);
+				ctx.down([["ERROR", err]]);
+				return;
+			}
+			const b = depBatch(ctx, 0);
+			if (b)
+				for (const v of b) {
+					obs.data?.(v as S);
+					ctx.down([["DATA", v]]);
+				}
+		},
+	};
+}
+
+/**
+ * onFirstData (alias `tapFirst`): invoke `fn` exactly once on the first qualifying value (default
+ * `where: v => v != null` — null/undefined pass through without counting as "first"), then pass all
+ * values through unchanged. The one-shot guard is per-node `ctx.state` (NOT a factory closure, so a
+ * second instantiation of the same factory re-arms — R-ctx-state).
+ */
+export function onFirstData<S>(
+	fn: (v: S) => void,
+	opts?: { where?: (v: S) => boolean },
+): Operator<S, S> {
+	const where = opts?.where ?? ((v: S) => v != null);
+	return {
+		factory: "onFirstData",
+		body: (ctx) => {
+			const b = depBatch(ctx, 0);
+			if (!b) return;
+			let fired = ctx.state.get<boolean>() ?? false;
+			for (const v of b) {
+				if (!fired && where(v as S)) {
+					fired = true;
+					fn(v as S);
+				}
+				ctx.down([["DATA", v]]);
+			}
+			ctx.state.set(fired);
+		},
+	};
+}
+
+/** tapFirst: alias of {@link onFirstData} (the one-shot companion to {@link tap}). */
+export const tapFirst = onFirstData;
+
+/** Options for {@link settle}. */
+export interface SettleOpts<S> {
+	/** Consecutive no-change waves before declaring convergence + COMPLETE. */
+	quietWaves: number;
+	/** Optional hard cap on total waves before forced COMPLETE. */
+	maxWaves?: number;
+	/** Optional comparator; a DATA equal to the previous one does NOT reset the quiet counter. */
+	equals?: (a: S, b: S) => boolean;
+}
+
+/** Internal settle accumulator state (per-node, R-ctx-state). */
+interface SettleState<S> {
+	last: S | undefined;
+	hasValue: boolean;
+	quiet: number;
+	waves: number;
+	done: boolean;
+}
+
+/**
+ * settle: forward each DATA unchanged, watch for convergence, COMPLETE once the source has been
+ * quiet for `quietWaves` consecutive waves (or `maxWaves` elapsed). "Wave" = one fn invocation
+ * (a DATA batch OR a bare undirty RESOLVED end-of-wave). No polling (R-no-polling) — the counter
+ * advances only on real upstream waves. `settle`'s own `equals` is a body comparator, NOT the
+ * removed substrate `equals` (D49).
+ */
+export function settle<S>(opts: SettleOpts<S>): Operator<S, S> {
+	const { quietWaves, maxWaves, equals } = opts;
+	if (!Number.isInteger(quietWaves) || quietWaves < 1) {
+		throw new RangeError(`settle: quietWaves must be a positive integer (got ${quietWaves})`);
+	}
+	if (maxWaves != null && (!Number.isInteger(maxWaves) || maxWaves < 1)) {
+		throw new RangeError(`settle: maxWaves must be a positive integer when set (got ${maxWaves})`);
+	}
+	return {
+		factory: "settle",
+		body: (ctx) => {
+			const st: SettleState<S> = ctx.state.get<SettleState<S>>() ?? {
+				last: undefined,
+				hasValue: false,
+				quiet: 0,
+				waves: 0,
+				done: false,
+			};
+			if (st.done) return;
+			st.waves++;
+			const b = depBatch(ctx, 0);
+			let sawChange = false;
+			if (b && b.length > 0) {
+				for (const v of b) {
+					const next = v as S;
+					const isChange = !st.hasValue || equals == null || !equals(st.last as S, next);
+					if (isChange) sawChange = true;
+					st.last = next;
+					st.hasValue = true;
+					ctx.down([["DATA", next]]);
+				}
+			}
+			st.quiet = sawChange ? 0 : st.quiet + 1;
+			const settled = st.hasValue && st.quiet >= quietWaves;
+			const exhausted = maxWaves != null && st.waves >= maxWaves;
+			if (settled || exhausted) {
+				st.done = true;
+				ctx.state.set(st);
+				ctx.down([["COMPLETE"]]);
+				return;
+			}
+			ctx.state.set(st);
+			// A no-DATA wave that didn't converge → bare undirty RESOLVED is synthesized by the
+			// substrate (D49); nothing to emit here.
+		},
+	};
+}
+
+// ── Slice 3 — error-handling control (CSP-2.7, D40) ──
+// rescue/catchError ABSORB the source ERROR (errorWhenDepsError:false) and read the error payload
+// from `depTerminal(ctx, 0)` (R-deps-terminal). They set completeWhenDepsComplete:false so a
+// normal source COMPLETE is forwarded explicitly — which ALSO sidesteps B40 (the
+// completeWhenDepsComplete:true × absorbed-errored-dep auto-complete gap): there is no auto-complete
+// to block. valve is a [source, control] gate (state-verb-legitimate control input).
+
+/**
+ * rescue (alias `catchError`): replace an upstream ERROR with a recovered value. On source DATA →
+ * forward; on source ERROR → emit `recover(err)` as DATA (if `recover` throws, forward THAT as
+ * ERROR); on source COMPLETE → COMPLETE. After recovery the source is terminal-errored (dead) so no
+ * further values flow — the recovered value is the final cached value (matches the frozen pure-ts
+ * reference; it does NOT auto-COMPLETE, RxJS-`catchError(()=>of(x))` divergence, flagged).
+ */
+export function rescue<S>(recover: (err: unknown) => S): Operator<S, S> {
+	return {
+		factory: "rescue",
+		opts: {
+			errorWhenDepsError: false,
+			completeWhenDepsComplete: false,
+			terminalAsRealInput: true,
+		},
+		body: (ctx) => {
+			const b = depBatch(ctx, 0);
+			const terminal = depTerminal(ctx, 0);
+			if (b) for (const v of b) ctx.down([["DATA", v]]);
+			if (isTerminalComplete(terminal)) {
+				ctx.down([["COMPLETE"]]);
+			} else if (isTerminalError(terminal)) {
+				// ERROR payload absorbed → recover.
+				try {
+					ctx.down([["DATA", recover(terminalErrorValue(terminal))]]);
+				} catch (e) {
+					ctx.down([["ERROR", errorPayload(e, "rescue threw without a valid error payload")]]);
+				}
+			}
+		},
+	};
+}
+
+/** catchError: RxJS-named alias of {@link rescue}. */
+export const catchError = rescue;
+
+/** Options for {@link valve}. */
+export interface ValveOpts {
+	/**
+	 * Optional AbortController (or a `() => AbortController | undefined` factory): on the control's
+	 * truthy→falsy edge, `valve` calls `controller.abort()` — cancel an in-flight async boundary
+	 * (LLM/fetch) the caller threaded `controller.signal` into. An external-resource cleanup (like
+	 * `ctx.onDeactivation`), NOT an imperative reactive trigger (R-no-imperative).
+	 */
+	abortInFlight?: AbortController | (() => AbortController | undefined);
+}
+
+/**
+ * valve: forward the source's DATA only while `control` (dep 1) is truthy; when closed, stay quiet
+ * (undirty RESOLVED). `[source, control]` declared deps + `partial:true` (the control wave can fire
+ * before the source ever delivers). `completeWhenDepsComplete:false` — closing the gate (control
+ * terminating) does NOT complete the valve; only the SOURCE's terminal (read via
+ * `terminalAsRealInput`) is forwarded. The `state`-verb control input is a legitimate external
+ * boundary (D4 / D54), not a forbidden imperative trigger.
+ */
+export function valve<S>(opts?: ValveOpts): Operator<S, S> {
+	const abortInFlight = opts?.abortInFlight;
+	return {
+		factory: "valve",
+		opts: { partial: true, completeWhenDepsComplete: false, terminalAsRealInput: true },
+		body: (ctx) => {
+			const srcBatch = depBatch(ctx, 0);
+			const ctlBatch = depBatch(ctx, 1);
+			const srcTerminal = depTerminal(ctx, 0);
+			const controlValue = depLatest(ctx, 1) as boolean | undefined;
+
+			if (abortInFlight != null) {
+				// Fire abort on the truthy→falsy edge only (never on activation / no prior state).
+				const prev = ctx.state.get<{ ctl: boolean | undefined }>();
+				if (prev?.ctl === true && !controlValue) {
+					const c = typeof abortInFlight === "function" ? abortInFlight() : abortInFlight;
+					c?.abort();
+				}
+				ctx.state.set({
+					ctl: controlValue === true ? true : controlValue == null ? undefined : false,
+				});
+			}
+
+			// Source terminal forwarding (control terminal is absorbed by completeWhenDepsComplete:false).
+			if (isTerminalComplete(srcTerminal)) {
+				ctx.down([["COMPLETE"]]);
+				return;
+			}
+			if (isTerminalError(srcTerminal)) {
+				ctx.down([["ERROR", terminalErrorValue(srcTerminal)]]);
+				return;
+			}
+
+			if (!controlValue) return; // gate closed → quiet (undirty RESOLVED)
+
+			if (srcBatch && srcBatch.length > 0) {
+				for (const v of srcBatch) ctx.down([["DATA", v]]);
+				return;
+			}
+			// Gate just opened this wave (control fired, source didn't): re-emit the last source value.
+			const srcLatest = depLatest(ctx, 0);
+			if (ctlBatch && ctlBatch.length > 0 && srcLatest !== undefined) {
+				ctx.down([["DATA", srcLatest as S]]);
+			}
+		},
+	};
+}
diff --git a/packages/ts/src/graph/policies/collection.ts b/packages/ts/src/graph/policies/collection.ts
new file mode 100644
index 00000000..33dff7f8
--- /dev/null
+++ b/packages/ts/src/graph/policies/collection.ts
@@ -0,0 +1,204 @@
+/**
+ * Internal graph-layer policy helpers (D70).
+ *
+ * This module is deliberately NOT exported from the package index. It centralizes policy plumbing
+ * shared by collection structures while each structure still owns backend mutation + delta emission
+ * in its apply/mutation path (D60/D61/D68/D69).
+ */
+
+import { type Ctx, depLatest } from "../../ctx/types.js";
+import type { Node } from "../../node/node.js";
+
+export type PolicyOpt<T> = T | Node<T>;
+
+export interface PolicyReader<T> {
+	readonly index: number;
+	read(ctx: Ctx, current: T | undefined): T | undefined;
+}
+
+export class PolicyInputs {
+	readonly deps: Node<unknown>[];
+
+	constructor(initial: readonly Node<unknown>[] = []) {
+		this.deps = [...initial];
+	}
+
+	add<T>(node: Node<T> | undefined): PolicyReader<T> {
+		if (node === undefined) return missingPolicyReader<T>();
+		const index = this.deps.push(node as Node<unknown>) - 1;
+		return policyReader<T>(index);
+	}
+}
+
+function missingPolicyReader<T>(): PolicyReader<T> {
+	return {
+		index: -1,
+		read: (_ctx, current) => current,
+	};
+}
+
+function policyReader<T>(index: number): PolicyReader<T> {
+	return {
+		index,
+		read(ctx, current) {
+			const latest = depLatest(ctx, index);
+			return latest === undefined ? current : (latest as T);
+		},
+	};
+}
+
+export interface KeyOrderPolicy<K> {
+	keys(): Iterable<K>;
+}
+
+export function lruKeys<K>(keys: Iterable<K>): KeyOrderPolicy<K> {
+	return {
+		keys: () => keys,
+	};
+}
+
+export interface CapacityConfig {
+	readonly maxSize?: number;
+}
+
+export interface SizedCapacityConfig extends CapacityConfig {
+	readonly size: number;
+}
+
+export function trimHeadOverflow<T>(items: T[], config: CapacityConfig): T[];
+export function trimHeadOverflow<T>(items: Iterable<T>, config: SizedCapacityConfig): T[];
+export function trimHeadOverflow<T>(
+	items: T[] | Iterable<T>,
+	config: CapacityConfig | SizedCapacityConfig,
+): T[] {
+	const { maxSize } = config;
+	if (maxSize === undefined) return [];
+	if (!Number.isInteger(maxSize) || maxSize < 1)
+		throw new RangeError(`maxSize must be a positive integer (got ${maxSize})`);
+
+	const size = "size" in config ? config.size : Array.isArray(items) ? items.length : undefined;
+	if (size === undefined) throw new Error("trimHeadOverflow requires size for non-array iterables");
+	const overflow = size - maxSize;
+	if (overflow <= 0) return [];
+
+	if (Array.isArray(items) && !("size" in config)) return items.splice(0, overflow);
+
+	const victims: T[] = [];
+	for (const item of items) {
+		victims.push(item);
+		if (victims.length === overflow) break;
+	}
+	return victims;
+}
+
+export interface DeadlineEntry<K> {
+	readonly key: K;
+	readonly expiresAt: number;
+}
+
+export interface DeadlinePolicy<K> {
+	readonly size: number;
+	push(item: DeadlineEntry<K>): void;
+	peek(): DeadlineEntry<K> | undefined;
+	pop(): DeadlineEntry<K> | undefined;
+}
+
+export function deadlines<K>(): DeadlinePolicy<K> {
+	return new MinDeadlineHeap<K>();
+}
+
+class MinDeadlineHeap<K> implements DeadlinePolicy<K> {
+	private readonly items: DeadlineEntry<K>[] = [];
+
+	get size(): number {
+		return this.items.length;
+	}
+
+	push(item: DeadlineEntry<K>): void {
+		this.items.push(item);
+		this.up(this.items.length - 1);
+	}
+
+	peek(): DeadlineEntry<K> | undefined {
+		return this.items[0];
+	}
+
+	pop(): DeadlineEntry<K> | undefined {
+		const top = this.items[0];
+		const last = this.items.pop();
+		if (top !== undefined && last !== undefined && this.items.length > 0) {
+			this.items[0] = last;
+			this.down(0);
+		}
+		return top;
+	}
+
+	private up(i: number): void {
+		while (i > 0) {
+			const p = (i - 1) >> 1;
+			if (
+				(this.items[p] as DeadlineEntry<K>).expiresAt <=
+				(this.items[i] as DeadlineEntry<K>).expiresAt
+			)
+				return;
+			[this.items[p], this.items[i]] = [
+				this.items[i] as DeadlineEntry<K>,
+				this.items[p] as DeadlineEntry<K>,
+			];
+			i = p;
+		}
+	}
+
+	private down(i: number): void {
+		for (;;) {
+			const left = i * 2 + 1;
+			const right = left + 1;
+			let smallest = i;
+			if (left < this.items.length && this.expiresAt(left) < this.expiresAt(smallest))
+				smallest = left;
+			if (right < this.items.length && this.expiresAt(right) < this.expiresAt(smallest))
+				smallest = right;
+			if (smallest === i) return;
+			[this.items[i], this.items[smallest]] = [
+				this.items[smallest] as DeadlineEntry<K>,
+				this.items[i] as DeadlineEntry<K>,
+			];
+			i = smallest;
+		}
+	}
+
+	private expiresAt(i: number): number {
+		return (this.items[i] as DeadlineEntry<K>).expiresAt;
+	}
+}
+
+export interface ScoredEntry<T> {
+	readonly entry: T;
+	readonly score: number;
+}
+
+export interface RetentionSelectionConfig {
+	readonly maxSize?: number;
+}
+
+export function selectRetentionVictims<T>(
+	scoredEntries: readonly ScoredEntry<T>[],
+	config: RetentionSelectionConfig,
+): T[] {
+	const { maxSize } = config;
+	if (maxSize === undefined) return [];
+	if (!Number.isInteger(maxSize) || maxSize < 0)
+		throw new RangeError(`retention maxSize must be a non-negative integer (got ${maxSize})`);
+	const overflow = scoredEntries.length - maxSize;
+	if (overflow <= 0) return [];
+
+	return scoredEntries
+		.map((item, index) => {
+			if (!Number.isFinite(item.score))
+				throw new RangeError(`retention score must be finite (got ${item.score})`);
+			return { ...item, index };
+		})
+		.sort((a, b) => a.score - b.score || a.index - b.index)
+		.slice(0, overflow)
+		.map((item) => item.entry);
+}
diff --git a/packages/ts/src/graph/policies/types.ts b/packages/ts/src/graph/policies/types.ts
new file mode 100644
index 00000000..3ece3862
--- /dev/null
+++ b/packages/ts/src/graph/policies/types.ts
@@ -0,0 +1,36 @@
+import type { Node } from "../../node/node.js";
+
+/**
+ * Public policy vocabulary (D80): shared option shapes only.
+ *
+ * Runtime policy mechanics stay structure-owned: each reactive collection still owns
+ * backend mutation, victim application, delta emission, and graph-bound node-as-opt wiring.
+ */
+export type ReactiveOpt<T> = T | Node<T>;
+
+/** Capacity vocabulary shared by structures that bound retained entries. */
+export interface CapacityPolicy<Order extends string = never> {
+	readonly maxSize: ReactiveOpt<number>;
+	readonly order?: Order;
+}
+
+/** Capacity policy variant for structures whose eviction order must be explicit. */
+export type OrderedCapacityPolicy<Order extends string> = CapacityPolicy<Order> & {
+	readonly order: Order;
+};
+
+/** Score-based retention vocabulary; higher scores are retained. */
+export interface RetentionPolicy<Entry> {
+	readonly maxSize?: ReactiveOpt<number>;
+	score(entry: Entry): number;
+}
+
+/**
+ * Static view-cache vocabulary for memoized helper nodes.
+ *
+ * This is intentionally not a release/keepalive API: eviction may drop the structure's
+ * memo reference, but externally held Node views remain valid.
+ */
+export interface ViewCachePolicy {
+	readonly maxEntries?: number;
+}
diff --git a/packages/ts/src/graph/render.ts b/packages/ts/src/graph/render.ts
new file mode 100644
index 00000000..f825d7b8
--- /dev/null
+++ b/packages/ts/src/graph/render.ts
@@ -0,0 +1,306 @@
+/**
+ * Pure renderers over `DescribeSnapshot` (D39 / D40 tail).
+ *
+ * Render is graph-layer presentation: no Graph method, no topology mutation, no substrate behavior.
+ */
+
+import type { DescribeEdge, DescribeNode, DescribeSnapshot } from "./describe.js";
+
+export type DiagramDirection = "TD" | "LR" | "BT" | "RL";
+
+export interface DescribeToMermaidOptions {
+	/** Diagram direction; default "LR". */
+	direction?: DiagramDirection;
+}
+
+export type MermaidLiveTheme = "default" | "dark" | "forest" | "neutral" | "base";
+
+export interface MermaidLiveUrlOptions {
+	/** Mermaid Live theme; default "default". */
+	theme?: MermaidLiveTheme;
+	/** Mermaid Live auto-sync flag; default true. */
+	autoSync?: boolean;
+}
+
+export interface DescribeToMermaidUrlOptions
+	extends DescribeToMermaidOptions,
+		MermaidLiveUrlOptions {}
+
+export interface DescribeToD2Options {
+	/** Diagram direction; default "LR". */
+	direction?: DiagramDirection;
+}
+
+export interface DescribeToPrettyOptions {
+	/** Include the Edges section; default true. */
+	includeEdges?: boolean;
+}
+
+export interface DescribeToAsciiOptions {
+	/** Include cached values; default false. */
+	includeValues?: boolean;
+}
+
+export interface DescribeToJsonOptions {
+	/** Include edges; default true. */
+	includeEdges?: boolean;
+	/** JSON indent; default 2. */
+	indent?: number;
+}
+
+interface FlatSnapshot {
+	name?: string;
+	nodes: DescribeNode[];
+	edges: DescribeEdge[];
+}
+
+/** Render a D39 describe snapshot as Mermaid flowchart text. */
+export function describeToMermaid(
+	snapshot: DescribeSnapshot,
+	opts: DescribeToMermaidOptions = {},
+): string {
+	const direction = normalizeDirection(opts.direction);
+	const flat = flattenDescribe(snapshot);
+	const nodes = sortedNodes(flat.nodes);
+	const ids = new Map<string, string>();
+	for (let i = 0; i < nodes.length; i += 1) ids.set(nodes[i]!.id, `n${i}`);
+
+	const lines = [`flowchart ${direction}`];
+	for (const node of nodes) {
+		lines.push(`  ${ids.get(node.id)!}["${escapeMermaidLabel(node.id)}"]`);
+	}
+	for (const edge of sortedEdges(flat.edges)) {
+		const from = ids.get(edge.from);
+		const to = ids.get(edge.to);
+		if (from === undefined || to === undefined) continue;
+		lines.push(`  ${from} --> ${to}`);
+	}
+	return lines.join("\n");
+}
+
+/** Encode arbitrary Mermaid source as a mermaid.live deep link. */
+export function mermaidLiveUrl(mermaidSource: string, opts: MermaidLiveUrlOptions = {}): string {
+	const payload = {
+		code: mermaidSource,
+		mermaid: { theme: opts.theme ?? "default" },
+		autoSync: opts.autoSync ?? true,
+	};
+	return `https://mermaid.live/edit#base64:${base64UrlEncode(JSON.stringify(payload))}`;
+}
+
+/** Render a D39 describe snapshot as a mermaid.live deep link. */
+export function describeToMermaidUrl(
+	snapshot: DescribeSnapshot,
+	opts: DescribeToMermaidUrlOptions = {},
+): string {
+	return mermaidLiveUrl(describeToMermaid(snapshot, opts), opts);
+}
+
+/** Render a D39 describe snapshot as D2 diagram text. */
+export function describeToD2(snapshot: DescribeSnapshot, opts: DescribeToD2Options = {}): string {
+	const direction = normalizeDirection(opts.direction);
+	const flat = flattenDescribe(snapshot);
+	const nodes = sortedNodes(flat.nodes);
+	const ids = new Map<string, string>();
+	for (let i = 0; i < nodes.length; i += 1) ids.set(nodes[i]!.id, `n${i}`);
+
+	const lines = [`direction: ${d2Direction(direction)}`];
+	for (const node of nodes) {
+		lines.push(`${ids.get(node.id)!}: "${escapeD2Label(node.id)}"`);
+	}
+	for (const edge of sortedEdges(flat.edges)) {
+		const from = ids.get(edge.from);
+		const to = ids.get(edge.to);
+		if (from === undefined || to === undefined) continue;
+		lines.push(`${from} -> ${to}`);
+	}
+	return lines.join("\n");
+}
+
+/** Render a D39 describe snapshot as compact human-readable plaintext. */
+export function describeToPretty(
+	snapshot: DescribeSnapshot,
+	opts: DescribeToPrettyOptions = {},
+): string {
+	const flat = flattenDescribe(snapshot);
+	const includeEdges = opts.includeEdges ?? true;
+	const lines: string[] = [`Graph ${flat.name ?? "(anonymous)"}`, "Nodes:"];
+	for (const node of sortedNodes(flat.nodes)) {
+		lines.push(`- ${node.id} (${node.factory}/${node.status}): ${formatValue(node)}`);
+	}
+	if (includeEdges) {
+		lines.push("Edges:");
+		for (const edge of sortedEdges(flat.edges)) lines.push(`- ${edge.from} -> ${edge.to}`);
+	}
+	return lines.join("\n");
+}
+
+/** Render a D39 describe snapshot as a compact ASCII adjacency diagram. */
+export function describeToAscii(
+	snapshot: DescribeSnapshot,
+	opts: DescribeToAsciiOptions = {},
+): string {
+	const flat = flattenDescribe(snapshot);
+	const outgoing = new Map<string, string[]>();
+	for (const edge of sortedEdges(flat.edges)) {
+		const list = outgoing.get(edge.from);
+		if (list) list.push(edge.to);
+		else outgoing.set(edge.from, [edge.to]);
+	}
+	const lines: string[] = [`Graph ${flat.name ?? "(anonymous)"}`];
+	for (const node of sortedNodes(flat.nodes)) {
+		const value = opts.includeValues ? ` ${formatValue(node)}` : "";
+		const to = outgoing.get(node.id)?.join(", ") ?? "-";
+		lines.push(`${node.id} [${node.factory}/${node.status}${value}] -> ${to}`);
+	}
+	return lines.join("\n");
+}
+
+/** Render a D39 describe snapshot as deterministic JSON text. */
+export function describeToJson(
+	snapshot: DescribeSnapshot,
+	opts: DescribeToJsonOptions = {},
+): string {
+	const includeEdges = opts.includeEdges ?? true;
+	const flat = flattenDescribe(snapshot);
+	const payload: FlatSnapshot = {
+		...(flat.name !== undefined ? { name: flat.name } : {}),
+		nodes: sortedNodes(flat.nodes).map((node) => sortJsonValue(node) as DescribeNode),
+		edges: includeEdges ? sortedEdges(flat.edges) : [],
+	};
+	return JSON.stringify(sortJsonValue(payload), null, opts.indent ?? 2);
+}
+
+function flattenDescribe(snapshot: DescribeSnapshot): FlatSnapshot {
+	const nodes: DescribeNode[] = [];
+	const edges: DescribeEdge[] = [];
+	const visit = (snap: DescribeSnapshot): void => {
+		nodes.push(...snap.nodes);
+		edges.push(...snap.edges);
+		for (const child of snap.subgraphs ?? []) visit(child);
+	};
+	visit(snapshot);
+	return { ...(snapshot.name !== undefined ? { name: snapshot.name } : {}), nodes, edges };
+}
+
+function sortedNodes(nodes: readonly DescribeNode[]): DescribeNode[] {
+	return [...nodes].sort((a, b) => compareText(a.id, b.id));
+}
+
+function sortedEdges(edges: readonly DescribeEdge[]): DescribeEdge[] {
+	const seen = new Set<string>();
+	const out: DescribeEdge[] = [];
+	for (const edge of edges) {
+		const key = `${edge.from}\0${edge.to}`;
+		if (seen.has(key)) continue;
+		seen.add(key);
+		out.push(edge);
+	}
+	return out.sort((a, b) => compareText(a.from, b.from) || compareText(a.to, b.to));
+}
+
+function compareText(a: string, b: string): number {
+	return a < b ? -1 : a > b ? 1 : 0;
+}
+
+function normalizeDirection(direction: unknown): DiagramDirection {
+	if (direction === undefined) return "LR";
+	if (direction === "TD" || direction === "LR" || direction === "BT" || direction === "RL") {
+		return direction;
+	}
+	throw new Error(
+		`invalid diagram direction ${String(direction)}; expected one of: TD, LR, BT, RL`,
+	);
+}
+
+function d2Direction(direction: DiagramDirection): string {
+	if (direction === "TD") return "down";
+	if (direction === "BT") return "up";
+	if (direction === "RL") return "left";
+	return "right";
+}
+
+function escapeMermaidLabel(value: string): string {
+	return escapeQuotedLabel(value);
+}
+
+function escapeD2Label(value: string): string {
+	return escapeQuotedLabel(value);
+}
+
+function escapeQuotedLabel(value: string): string {
+	return JSON.stringify(value).slice(1, -1);
+}
+
+function formatValue(node: DescribeNode): string {
+	if (!("value" in node)) return "<SENTINEL>";
+	const value = node.value;
+	if (typeof value === "string") return JSON.stringify(value);
+	if (typeof value === "number" || typeof value === "boolean" || value == null)
+		return String(value);
+	try {
+		return JSON.stringify(value);
+	} catch {
+		return "[unserializable]";
+	}
+}
+
+function sortJsonValue(value: unknown, seen: WeakSet<object> = new WeakSet()): unknown {
+	if (typeof value === "bigint") return value.toString();
+	if (value === null || typeof value !== "object") return value;
+	if (seen.has(value)) return "[Circular]";
+	seen.add(value);
+	if (Array.isArray(value)) {
+		const out = value.map((item) => sortJsonValue(item, seen));
+		seen.delete(value);
+		return out;
+	}
+	const obj = value as Record<string, unknown>;
+	const out: Record<string, unknown> = {};
+	for (const key of Object.keys(obj).sort(compareText)) out[key] = sortJsonValue(obj[key], seen);
+	seen.delete(value);
+	return out;
+}
+
+const B64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+
+function base64UrlEncode(value: string): string {
+	const bytes = utf8Bytes(value);
+	let out = "";
+	for (let i = 0; i < bytes.length; i += 3) {
+		const a = bytes[i]!;
+		const b = bytes[i + 1];
+		const c = bytes[i + 2];
+		out += B64[a >> 2];
+		out += B64[((a & 0x03) << 4) | ((b ?? 0) >> 4)];
+		out += b === undefined ? "=" : B64[((b & 0x0f) << 2) | ((c ?? 0) >> 6)];
+		out += c === undefined ? "=" : B64[c & 0x3f];
+	}
+	return out.replaceAll("+", "-").replaceAll("/", "_").replace(/=+$/, "");
+}
+
+function utf8Bytes(value: string): number[] {
+	const bytes: number[] = [];
+	for (let i = 0; i < value.length; i += 1) {
+		let cp = value.charCodeAt(i);
+		if (cp >= 0xd800 && cp <= 0xdbff && i + 1 < value.length) {
+			const lo = value.charCodeAt(i + 1);
+			if (lo >= 0xdc00 && lo <= 0xdfff) {
+				cp = 0x10000 + ((cp - 0xd800) << 10) + (lo - 0xdc00);
+				i += 1;
+			}
+		}
+		if (cp <= 0x7f) bytes.push(cp);
+		else if (cp <= 0x7ff) bytes.push(0xc0 | (cp >> 6), 0x80 | (cp & 0x3f));
+		else if (cp <= 0xffff)
+			bytes.push(0xe0 | (cp >> 12), 0x80 | ((cp >> 6) & 0x3f), 0x80 | (cp & 0x3f));
+		else
+			bytes.push(
+				0xf0 | (cp >> 18),
+				0x80 | ((cp >> 12) & 0x3f),
+				0x80 | ((cp >> 6) & 0x3f),
+				0x80 | (cp & 0x3f),
+			);
+	}
+	return bytes;
+}
diff --git a/packages/ts/src/graph/resilience.ts b/packages/ts/src/graph/resilience.ts
new file mode 100644
index 00000000..983dcda9
--- /dev/null
+++ b/packages/ts/src/graph/resilience.ts
@@ -0,0 +1,101 @@
+/**
+ * Passive resilience policy helpers for graph-visible adapters (D130/D132).
+ *
+ * These helpers never schedule work and never own graph state. Drivers/adapters
+ * consume them, while graph-visible bundles expose attempts/status/errors.
+ */
+
+export type BackoffPolicy =
+	| { readonly kind: "none" }
+	| { readonly kind: "constant"; readonly delayMs: number }
+	| {
+			readonly kind: "linear";
+			readonly initialMs: number;
+			readonly stepMs: number;
+			readonly maxMs?: number;
+	  }
+	| {
+			readonly kind: "exponential";
+			readonly initialMs: number;
+			readonly factor: number;
+			readonly maxMs?: number;
+	  }
+	| { readonly kind: "fibonacci"; readonly unitMs: number; readonly maxMs?: number };
+
+export interface RetryPolicy {
+	/** Total attempts including the first try. */
+	readonly maxAttempts: number;
+	readonly backoff: BackoffPolicy;
+}
+
+export type RetryState = "idle" | "running" | "waiting" | "succeeded" | "failed" | "exhausted";
+
+export interface RetryStatus {
+	readonly attempt: number;
+	readonly maxAttempts: number;
+	readonly delayMs?: number;
+	readonly state: RetryState;
+}
+
+export const noBackoff: BackoffPolicy = Object.freeze({ kind: "none" });
+
+export function retryPolicy(maxAttempts = 1, backoff: BackoffPolicy = noBackoff): RetryPolicy {
+	if (!Number.isInteger(maxAttempts) || maxAttempts <= 0) {
+		throw new RangeError("retryPolicy: maxAttempts must be a positive integer");
+	}
+	return Object.freeze({ maxAttempts, backoff });
+}
+
+export function shouldRetry(policy: RetryPolicy, failedAttempt: number): boolean {
+	return failedAttempt < policy.maxAttempts;
+}
+
+export function nextRetryDelayMs(policy: RetryPolicy, nextAttempt: number): number | undefined {
+	if (!Number.isInteger(nextAttempt) || nextAttempt <= 0 || nextAttempt > policy.maxAttempts) {
+		return undefined;
+	}
+	return backoffDelayMs(policy.backoff, nextAttempt);
+}
+
+export function backoffDelayMs(policy: BackoffPolicy, attempt: number): number {
+	const safeAttempt = Math.max(1, Math.trunc(attempt));
+	switch (policy.kind) {
+		case "none":
+			return 0;
+		case "constant":
+			return nonNegative(policy.delayMs);
+		case "linear":
+			return cap(
+				nonNegative(policy.initialMs) + nonNegative(policy.stepMs) * (safeAttempt - 1),
+				policy.maxMs,
+			);
+		case "exponential": {
+			const factor = Math.max(1, Math.trunc(policy.factor));
+			return cap(nonNegative(policy.initialMs) * factor ** (safeAttempt - 1), policy.maxMs);
+		}
+		case "fibonacci":
+			return cap(nonNegative(policy.unitMs) * fibonacci(safeAttempt), policy.maxMs);
+	}
+}
+
+function cap(value: number, max: number | undefined): number {
+	if (max === undefined) return value;
+	return Math.min(value, nonNegative(max));
+}
+
+function nonNegative(value: number): number {
+	if (!Number.isFinite(value)) return 0;
+	return Math.max(0, value);
+}
+
+function fibonacci(n: number): number {
+	if (n <= 1) return 1;
+	let prev = 1;
+	let curr = 1;
+	for (let i = 2; i <= n; i += 1) {
+		const next = prev + curr;
+		prev = curr;
+		curr = next;
+	}
+	return curr;
+}
diff --git a/packages/ts/src/graph/restore.ts b/packages/ts/src/graph/restore.ts
new file mode 100644
index 00000000..3df3cd7a
--- /dev/null
+++ b/packages/ts/src/graph/restore.ts
@@ -0,0 +1,969 @@
+/**
+ * Fresh-graph checkpoint restore (D94/D95).
+ *
+ * Restore consumes an already-loaded strict-JSON checkpoint. It validates the whole tree,
+ * constructs graph-registered topology through explicit descriptors, then performs one
+ * internal runtime-state commit. No storage I/O, observe replay, public hook, or protocol
+ * wave participates in this path.
+ */
+
+import type { Dispatcher } from "../dispatcher/index.js";
+import { strictCanonicalJsonBytes } from "../json/codec.js";
+import type { Node } from "../node/node.js";
+import { restoreStateOfNode, type Status } from "../node/node.js";
+import {
+	type NodeVersioningPolicy,
+	type NodeVersionJson,
+	validateNodeVersionJson,
+} from "../node/versioning.js";
+import { SENTINEL } from "../protocol/messages.js";
+import {
+	GRAPH_CHECKPOINT_VERSION,
+	type GraphCheckpoint,
+	type GraphCheckpointFactory,
+	type GraphCheckpointJson,
+	type GraphCheckpointNode,
+	type GraphCheckpointTerminal,
+	type GraphCheckpointValue,
+	toCheckpointJson,
+} from "./checkpoint.js";
+import type { IndexRow, ReactiveIndex } from "./data-structures/reactive-index.js";
+import { restoreReactiveIndexFromBackendState } from "./data-structures/reactive-index.js";
+import { type ReactiveList, reactiveList } from "./data-structures/reactive-list.js";
+import { type ReactiveLog, reactiveLog } from "./data-structures/reactive-log.js";
+import {
+	type ReactiveMap,
+	restoreReactiveMapFromBackendState,
+} from "./data-structures/reactive-map.js";
+import {
+	type Graph,
+	graph,
+	restoreNodeInGraph,
+	restoreStateNodeInGraph,
+	type SugarOpts,
+} from "./graph.js";
+import { map, operatorNodeFn, take } from "./operators.js";
+import { timer } from "./sources.js";
+
+export interface GraphRestoreDefinition<S = never, T = unknown> {
+	readonly kind: "definition";
+	readonly ref: string;
+	readonly fn: (v: S) => T;
+}
+
+export type GraphRestoreEntry = GraphRestoreDescriptor | GraphRestoreDefinition;
+
+export interface GraphRestoreDescriptorContext<
+	C extends GraphCheckpointJson | undefined = GraphCheckpointJson | undefined,
+> {
+	readonly graph: Graph;
+	readonly id: string;
+	readonly name?: string;
+	readonly deps: readonly Node<unknown>[];
+	readonly config: C;
+	readonly configVersion?: GraphCheckpointJson;
+	readonly checkpoint: GraphCheckpointNode;
+	resolveDefinition<S = unknown, T = unknown>(ref: string): GraphRestoreDefinition<S, T>;
+	registerState<T = unknown>(opts?: SugarOpts<T>): Node<unknown>;
+	registerNode<T = unknown>(
+		factory: string,
+		deps: readonly Node<unknown>[],
+		fn: import("../ctx/types.js").NodeFn | null,
+		opts?: SugarOpts<T>,
+	): Node<unknown>;
+}
+
+export interface GraphRestoreDescriptor<
+	C extends GraphCheckpointJson | undefined = GraphCheckpointJson | undefined,
+> {
+	readonly ref: string;
+	validateConfig?(
+		config: GraphCheckpointJson | undefined,
+		configVersion: GraphCheckpointJson | undefined,
+		checkpoint: GraphCheckpointNode,
+	): C;
+	create(ctx: GraphRestoreDescriptorContext<C>): Node<unknown>;
+}
+
+export type GraphRestoreRegistry =
+	| ReadonlyMap<string, GraphRestoreEntry>
+	| Readonly<Record<string, GraphRestoreEntry>>;
+
+export interface RestoreGraphOptions {
+	registry: GraphRestoreRegistry;
+	dispatcher?: Dispatcher;
+	versioning?: NodeVersioningPolicy;
+}
+
+export const stateRestoreDescriptor: GraphRestoreDescriptor<undefined> = {
+	ref: "state",
+	validateConfig(config, configVersion) {
+		if (config !== undefined || configVersion !== undefined) {
+			throw new Error("restoreGraph: built-in state descriptor does not accept config");
+		}
+		return undefined;
+	},
+	create(ctx) {
+		if (ctx.deps.length !== 0) {
+			throw new Error(`restoreGraph: state node '${ctx.checkpoint.id}' cannot restore deps`);
+		}
+		return ctx.registerState({
+			name: ctx.name,
+			meta: ctx.checkpoint.meta,
+		});
+	},
+};
+
+type TakeConfig = { n: number };
+type TimerConfig = { ms: number };
+type MapConfig = { fn: string };
+type LogConfig = { maxSize?: number };
+
+function objectConfig(
+	config: GraphCheckpointJson | undefined,
+	ref: string,
+): Record<string, GraphCheckpointJson> {
+	if (
+		config === undefined ||
+		config === null ||
+		Array.isArray(config) ||
+		typeof config !== "object"
+	) {
+		throw new Error(`restoreGraph: '${ref}' descriptor requires object config`);
+	}
+	return config as Record<string, GraphCheckpointJson>;
+}
+
+function finiteNumber(value: GraphCheckpointJson | undefined, ref: string, key: string): number {
+	if (typeof value !== "number" || !Number.isFinite(value)) {
+		throw new Error(`restoreGraph: '${ref}' config.${key} must be a finite number`);
+	}
+	return value;
+}
+
+export const takeRestoreDescriptor: GraphRestoreDescriptor<TakeConfig> = {
+	ref: "take",
+	validateConfig(config, configVersion) {
+		if (configVersion !== undefined) {
+			throw new Error("restoreGraph: built-in take descriptor does not accept configVersion");
+		}
+		return { n: finiteNumber(objectConfig(config, "take").n, "take", "n") };
+	},
+	create(ctx) {
+		if (ctx.deps.length !== 1) {
+			throw new Error(`restoreGraph: take node '${ctx.checkpoint.id}' requires exactly one dep`);
+		}
+		const op = take(ctx.config.n);
+		return ctx.registerNode("take", ctx.deps, operatorNodeFn(op), {
+			name: ctx.name,
+			meta: ctx.checkpoint.meta,
+			restore: op.restore,
+		});
+	},
+};
+
+export const mapRestoreDescriptor: GraphRestoreDescriptor<MapConfig> = {
+	ref: "map",
+	validateConfig(config, configVersion) {
+		if (configVersion !== undefined) {
+			throw new Error("restoreGraph: built-in map descriptor does not accept configVersion");
+		}
+		const obj = objectConfig(config, "map");
+		if (typeof obj.fn !== "string") {
+			throw new Error("restoreGraph: 'map' config.fn must be a string definition ref");
+		}
+		return { fn: obj.fn };
+	},
+	create(ctx) {
+		if (ctx.deps.length !== 1) {
+			throw new Error(`restoreGraph: map node '${ctx.checkpoint.id}' requires exactly one dep`);
+		}
+		const definition = ctx.resolveDefinition(ctx.config.fn);
+		const op = map(definition);
+		return ctx.registerNode("map", ctx.deps, operatorNodeFn(op), {
+			name: ctx.name,
+			meta: ctx.checkpoint.meta,
+			restore: op.restore,
+		});
+	},
+};
+
+export const timerRestoreDescriptor: GraphRestoreDescriptor<TimerConfig> = {
+	ref: "timer",
+	validateConfig(config, configVersion) {
+		if (configVersion !== undefined) {
+			throw new Error("restoreGraph: built-in timer descriptor does not accept configVersion");
+		}
+		return { ms: finiteNumber(objectConfig(config, "timer").ms, "timer", "ms") };
+	},
+	create(ctx) {
+		if (ctx.deps.length !== 0) {
+			throw new Error(`restoreGraph: timer node '${ctx.checkpoint.id}' cannot restore deps`);
+		}
+		const op = timer(ctx.config.ms);
+		return ctx.registerNode("timer", ctx.deps, operatorNodeFn(op), {
+			name: ctx.name,
+			meta: ctx.checkpoint.meta,
+			restore: op.restore,
+			...op.opts,
+		});
+	},
+};
+
+type RestoredCollection =
+	| { kind: "reactiveList"; collection: ReactiveList<unknown> }
+	| { kind: "reactiveIndex"; collection: ReactiveIndex<unknown, unknown> }
+	| { kind: "reactiveLog"; collection: ReactiveLog<unknown> }
+	| { kind: "reactiveMap"; collection: ReactiveMap<unknown, unknown> };
+
+const restoredCollections = new WeakMap<Graph, Map<string, RestoredCollection>>();
+
+function restoredCollectionMap(graph: Graph): Map<string, RestoredCollection> {
+	let map = restoredCollections.get(graph);
+	if (map === undefined) {
+		map = new Map();
+		restoredCollections.set(graph, map);
+	}
+	return map;
+}
+
+function clearRestoredCollectionMap(graph: Graph): void {
+	restoredCollections.delete(graph);
+}
+
+function collectionBaseId(
+	id: string,
+	suffix: ".intent" | ".apply" | ".snapshotPrep" | ".delta" | ".snapshot",
+	ref: string,
+): string {
+	if (!id.endsWith(suffix)) {
+		throw new Error(`restoreGraph: '${ref}' node '${id}' must end with '${suffix}'`);
+	}
+	const base = id.slice(0, -suffix.length);
+	if (base.length === 0) {
+		throw new Error(`restoreGraph: '${ref}' node '${id}' has no collection name`);
+	}
+	return base;
+}
+
+function noCollectionConfig(
+	config: GraphCheckpointJson | undefined,
+	configVersion: GraphCheckpointJson | undefined,
+	ref: string,
+): undefined {
+	if (config !== undefined || configVersion !== undefined) {
+		throw new Error(`restoreGraph: '${ref}' descriptor does not accept config`);
+	}
+	return undefined;
+}
+
+function backendArray(
+	checkpoint: GraphCheckpointNode,
+	ref: string,
+): readonly GraphCheckpointJson[] {
+	const state = checkpoint.backendState;
+	if (!Array.isArray(state)) {
+		throw new Error(`restoreGraph: '${ref}' node '${checkpoint.id}' requires array backendState`);
+	}
+	return state;
+}
+
+function primitiveJsonKey(
+	value: GraphCheckpointJson,
+	path: string,
+): string | number | boolean | null {
+	if (
+		value === null ||
+		typeof value === "string" ||
+		typeof value === "number" ||
+		typeof value === "boolean"
+	) {
+		return value;
+	}
+	throw new Error(`restoreGraph: ${path} must be a JSON primitive primary key`);
+}
+
+function indexRows(
+	checkpoint: GraphCheckpointNode,
+	ref: string,
+): readonly IndexRow<unknown, unknown>[] {
+	const rows: IndexRow<unknown, unknown>[] = [];
+	const seen = new Set<string>();
+	for (const [i, row] of backendArray(checkpoint, ref).entries()) {
+		const path = `${checkpoint.id}.backendState[${i}]`;
+		if (row === null || Array.isArray(row) || typeof row !== "object") {
+			throw new Error(`restoreGraph: ${path} must be an index row object`);
+		}
+		if (
+			!Object.hasOwn(row, "primary") ||
+			!Object.hasOwn(row, "secondary") ||
+			!Object.hasOwn(row, "value")
+		) {
+			throw new Error(`restoreGraph: ${path} must contain primary, secondary, and value`);
+		}
+		const obj = row as Record<string, GraphCheckpointJson>;
+		const primary = primitiveJsonKey(obj.primary as GraphCheckpointJson, `${path}.primary`);
+		const stablePrimary = JSON.stringify(primary);
+		if (seen.has(stablePrimary)) {
+			throw new Error(`restoreGraph: ${path}.primary duplicates an earlier index row`);
+		}
+		seen.add(stablePrimary);
+		rows.push({
+			primary,
+			secondary: obj.secondary,
+			value: obj.value,
+		});
+	}
+	return rows;
+}
+
+function stableJsonKey(value: GraphCheckpointJson): string {
+	return Array.from(strictCanonicalJsonBytes(value)).join(",");
+}
+
+function mapEntries(
+	checkpoint: GraphCheckpointNode,
+	ref: string,
+): readonly (readonly [unknown, unknown])[] {
+	const entries: Array<readonly [unknown, unknown]> = [];
+	const seen = new Set<string>();
+	for (const [i, entry] of backendArray(checkpoint, ref).entries()) {
+		const path = `${checkpoint.id}.backendState[${i}]`;
+		if (!Array.isArray(entry) || entry.length !== 2) {
+			throw new Error(`restoreGraph: ${path} must be a [key, value] map entry`);
+		}
+		const key = entry[0] as GraphCheckpointJson;
+		const stableKey = stableJsonKey(key);
+		if (seen.has(stableKey)) {
+			throw new Error(`restoreGraph: ${path}[0] duplicates an earlier map key`);
+		}
+		seen.add(stableKey);
+		entries.push([key, entry[1]] as const);
+	}
+	return entries;
+}
+
+function restoredList(ctx: GraphRestoreDescriptorContext, ref: string): ReactiveList<unknown> {
+	const base = collectionBaseId(ctx.id, ".delta", ref);
+	if (ctx.deps.length !== 0) {
+		throw new Error(`restoreGraph: '${ref}' node '${ctx.id}' cannot restore deps`);
+	}
+	const collection = reactiveList(backendArray(ctx.checkpoint, ref), {
+		graph: ctx.graph,
+		name: base,
+	});
+	restoredCollectionMap(ctx.graph).set(base, { kind: "reactiveList", collection });
+	return collection;
+}
+
+function restoredIndex(ctx: GraphRestoreDescriptorContext, ref: string): ReactiveIndex<unknown> {
+	const base = collectionBaseId(ctx.id, ".delta", ref);
+	if (ctx.deps.length !== 0) {
+		throw new Error(`restoreGraph: '${ref}' node '${ctx.id}' cannot restore deps`);
+	}
+	const rows = indexRows(ctx.checkpoint, ref);
+	const collection = restoreReactiveIndexFromBackendState(rows, {
+		graph: ctx.graph,
+		name: base,
+	});
+	restoredCollectionMap(ctx.graph).set(base, { kind: "reactiveIndex", collection });
+	return collection;
+}
+
+function restoredLog(
+	ctx: GraphRestoreDescriptorContext<LogConfig>,
+	ref: string,
+): ReactiveLog<unknown> {
+	const base = collectionBaseId(ctx.id, ".delta", ref);
+	if (ctx.deps.length !== 0) {
+		throw new Error(`restoreGraph: '${ref}' node '${ctx.id}' cannot restore deps`);
+	}
+	const state = backendArray(ctx.checkpoint, ref);
+	if (ctx.config.maxSize !== undefined && state.length > ctx.config.maxSize) {
+		throw new Error(`restoreGraph: '${ref}' node '${ctx.id}' backendState exceeds config.maxSize`);
+	}
+	const collection = reactiveLog(state, {
+		graph: ctx.graph,
+		name: base,
+		...(ctx.config.maxSize !== undefined ? { maxSize: ctx.config.maxSize } : {}),
+	});
+	restoredCollectionMap(ctx.graph).set(base, { kind: "reactiveLog", collection });
+	return collection;
+}
+
+function restoredMapNode(ctx: GraphRestoreDescriptorContext, ref: string): Node<unknown> {
+	const base = collectionBaseId(ctx.id, ".intent", ref);
+	if (ctx.deps.length !== 0) {
+		throw new Error(`restoreGraph: '${ref}' node '${ctx.id}' cannot restore deps`);
+	}
+	const entries = mapEntries(ctx.checkpoint, ref);
+	const collection = restoreReactiveMapFromBackendState(entries, {
+		graph: ctx.graph,
+		name: base,
+	});
+	restoredCollectionMap(ctx.graph).set(base, { kind: "reactiveMap", collection });
+	const node = ctx.graph.find(ctx.id);
+	if (node === undefined) {
+		throw new Error(`restoreGraph: '${ref}' node '${ctx.id}' was not restored`);
+	}
+	return node;
+}
+
+function existingMapNode(
+	ctx: GraphRestoreDescriptorContext,
+	ref: string,
+	suffix: ".apply" | ".snapshotPrep" | ".delta" | ".snapshot",
+): Node<unknown> {
+	const base = collectionBaseId(ctx.id, suffix, ref);
+	const item = restoredCollectionMap(ctx.graph).get(base);
+	if (item === undefined || item.kind !== "reactiveMap") {
+		throw new Error(`restoreGraph: '${ref}' node '${ctx.id}' is missing restored '${base}.intent'`);
+	}
+	const node = ctx.graph.find(ctx.id);
+	if (node === undefined) {
+		throw new Error(`restoreGraph: '${ref}' node '${ctx.id}' was not restored`);
+	}
+	return node;
+}
+
+function existingCollection(
+	ctx: GraphRestoreDescriptorContext,
+	ref: string,
+	kind: RestoredCollection["kind"],
+): RestoredCollection {
+	const base = collectionBaseId(ctx.id, ".snapshot", ref);
+	if (ctx.deps.length !== 1) {
+		throw new Error(`restoreGraph: '${ref}' node '${ctx.id}' requires exactly one dep`);
+	}
+	const item = restoredCollectionMap(ctx.graph).get(base);
+	if (item === undefined || item.kind !== kind) {
+		throw new Error(`restoreGraph: '${ref}' node '${ctx.id}' is missing restored '${base}.delta'`);
+	}
+	return item;
+}
+
+function validateLogConfig(
+	config: GraphCheckpointJson | undefined,
+	configVersion: GraphCheckpointJson | undefined,
+	ref: string,
+): LogConfig {
+	if (configVersion !== undefined) {
+		throw new Error(`restoreGraph: '${ref}' descriptor does not accept configVersion`);
+	}
+	if (config === undefined) return {};
+	const obj = objectConfig(config, ref);
+	if (obj.maxSize === undefined) return {};
+	const maxSize = finiteNumber(obj.maxSize, ref, "maxSize");
+	if (!Number.isInteger(maxSize) || maxSize < 1) {
+		throw new Error(`restoreGraph: '${ref}' config.maxSize must be a positive integer`);
+	}
+	return { maxSize };
+}
+
+export const reactiveListDeltaRestoreDescriptor: GraphRestoreDescriptor<undefined> = {
+	ref: "reactiveList.delta",
+	validateConfig(config, configVersion) {
+		return noCollectionConfig(config, configVersion, "reactiveList.delta");
+	},
+	create(ctx) {
+		return restoredList(ctx, "reactiveList.delta").delta as Node<unknown>;
+	},
+};
+
+export const reactiveListSnapshotRestoreDescriptor: GraphRestoreDescriptor<undefined> = {
+	ref: "reactiveList.snapshot",
+	validateConfig(config, configVersion) {
+		return noCollectionConfig(config, configVersion, "reactiveList.snapshot");
+	},
+	create(ctx) {
+		return existingCollection(ctx, "reactiveList.snapshot", "reactiveList").collection
+			.snapshot as Node<unknown>;
+	},
+};
+
+export const reactiveIndexDeltaRestoreDescriptor: GraphRestoreDescriptor<undefined> = {
+	ref: "reactiveIndex.delta",
+	validateConfig(config, configVersion) {
+		return noCollectionConfig(config, configVersion, "reactiveIndex.delta");
+	},
+	create(ctx) {
+		return restoredIndex(ctx, "reactiveIndex.delta").delta as Node<unknown>;
+	},
+};
+
+export const reactiveIndexSnapshotRestoreDescriptor: GraphRestoreDescriptor<undefined> = {
+	ref: "reactiveIndex.snapshot",
+	validateConfig(config, configVersion) {
+		return noCollectionConfig(config, configVersion, "reactiveIndex.snapshot");
+	},
+	create(ctx) {
+		return existingCollection(ctx, "reactiveIndex.snapshot", "reactiveIndex").collection
+			.snapshot as Node<unknown>;
+	},
+};
+
+export const reactiveLogDeltaRestoreDescriptor: GraphRestoreDescriptor<LogConfig> = {
+	ref: "reactiveLog.delta",
+	validateConfig(config, configVersion) {
+		return validateLogConfig(config, configVersion, "reactiveLog.delta");
+	},
+	create(ctx) {
+		return restoredLog(ctx, "reactiveLog.delta").delta as Node<unknown>;
+	},
+};
+
+export const reactiveLogSnapshotRestoreDescriptor: GraphRestoreDescriptor<LogConfig> = {
+	ref: "reactiveLog.snapshot",
+	validateConfig(config, configVersion) {
+		return validateLogConfig(config, configVersion, "reactiveLog.snapshot");
+	},
+	create(ctx) {
+		return existingCollection(ctx, "reactiveLog.snapshot", "reactiveLog").collection
+			.snapshot as Node<unknown>;
+	},
+};
+
+export const reactiveMapIntentRestoreDescriptor: GraphRestoreDescriptor<undefined> = {
+	ref: "reactiveMap.intent",
+	validateConfig(config, configVersion) {
+		return noCollectionConfig(config, configVersion, "reactiveMap.intent");
+	},
+	create(ctx) {
+		return restoredMapNode(ctx, "reactiveMap.intent");
+	},
+};
+
+export const reactiveMapApplyRestoreDescriptor: GraphRestoreDescriptor<undefined> = {
+	ref: "reactiveMap.apply",
+	validateConfig(config, configVersion) {
+		return noCollectionConfig(config, configVersion, "reactiveMap.apply");
+	},
+	create(ctx) {
+		return existingMapNode(ctx, "reactiveMap.apply", ".apply");
+	},
+};
+
+export const reactiveMapSnapshotPrepRestoreDescriptor: GraphRestoreDescriptor<undefined> = {
+	ref: "reactiveMap.snapshotPrep",
+	validateConfig(config, configVersion) {
+		return noCollectionConfig(config, configVersion, "reactiveMap.snapshotPrep");
+	},
+	create(ctx) {
+		return existingMapNode(ctx, "reactiveMap.snapshotPrep", ".snapshotPrep");
+	},
+};
+
+export const reactiveMapDeltaRestoreDescriptor: GraphRestoreDescriptor<undefined> = {
+	ref: "reactiveMap.delta",
+	validateConfig(config, configVersion) {
+		return noCollectionConfig(config, configVersion, "reactiveMap.delta");
+	},
+	create(ctx) {
+		return existingMapNode(ctx, "reactiveMap.delta", ".delta");
+	},
+};
+
+export const reactiveMapSnapshotRestoreDescriptor: GraphRestoreDescriptor<undefined> = {
+	ref: "reactiveMap.snapshot",
+	validateConfig(config, configVersion) {
+		return noCollectionConfig(config, configVersion, "reactiveMap.snapshot");
+	},
+	create(ctx) {
+		return existingMapNode(ctx, "reactiveMap.snapshot", ".snapshot");
+	},
+};
+
+export const defaultRestoreRegistry: Readonly<Record<string, GraphRestoreDescriptor>> = {
+	state: stateRestoreDescriptor,
+	map: mapRestoreDescriptor,
+	take: takeRestoreDescriptor,
+	timer: timerRestoreDescriptor,
+	"reactiveList.delta": reactiveListDeltaRestoreDescriptor,
+	"reactiveList.snapshot": reactiveListSnapshotRestoreDescriptor,
+	"reactiveIndex.delta": reactiveIndexDeltaRestoreDescriptor,
+	"reactiveIndex.snapshot": reactiveIndexSnapshotRestoreDescriptor,
+	"reactiveLog.delta": reactiveLogDeltaRestoreDescriptor,
+	"reactiveLog.snapshot": reactiveLogSnapshotRestoreDescriptor,
+	"reactiveMap.intent": reactiveMapIntentRestoreDescriptor,
+	"reactiveMap.apply": reactiveMapApplyRestoreDescriptor,
+	"reactiveMap.snapshotPrep": reactiveMapSnapshotPrepRestoreDescriptor,
+	"reactiveMap.delta": reactiveMapDeltaRestoreDescriptor,
+	"reactiveMap.snapshot": reactiveMapSnapshotRestoreDescriptor,
+};
+
+type PreparedNode = {
+	checkpoint: GraphCheckpointNode;
+	localId: string;
+	descriptor: GraphRestoreDescriptor;
+	config: GraphCheckpointJson | undefined;
+	deps: string[];
+	runtime: PreparedRuntime;
+};
+
+type PreparedCheckpoint = {
+	checkpoint: GraphCheckpoint;
+	nodes: Map<string, PreparedNode>;
+	mounts: Array<{ at: string; prepared: PreparedCheckpoint }>;
+};
+
+type PreparedRuntime = {
+	cache: unknown;
+	hasData: boolean;
+	status: Status;
+	terminal: true | unknown | undefined;
+	hasCalledFnOnce: boolean;
+	ctxState: { value: unknown; persist: boolean };
+	version: NodeVersionJson | false;
+};
+
+function registryGet(registry: GraphRestoreRegistry, ref: string): GraphRestoreEntry | undefined {
+	return registry instanceof Map
+		? registry.get(ref)
+		: (registry as Readonly<Record<string, GraphRestoreEntry>>)[ref];
+}
+
+function isRestoreDescriptor(
+	entry: GraphRestoreEntry | undefined,
+): entry is GraphRestoreDescriptor {
+	return entry !== undefined && "create" in entry;
+}
+
+function isRestoreDefinition(
+	entry: GraphRestoreEntry | undefined,
+): entry is GraphRestoreDefinition {
+	return entry !== undefined && "kind" in entry && entry.kind === "definition";
+}
+
+function assertString(value: unknown, label: string): string {
+	if (typeof value !== "string") throw new Error(`restoreGraph: ${label} must be a string`);
+	return value;
+}
+
+function assertStatus(value: string, id: string): Status {
+	if (
+		value !== "sentinel" &&
+		value !== "pending" &&
+		value !== "dirty" &&
+		value !== "settled" &&
+		value !== "resolved" &&
+		value !== "completed" &&
+		value !== "errored"
+	) {
+		throw new Error(`restoreGraph: node '${id}' has invalid status '${value}'`);
+	}
+	if (value === "pending" || value === "dirty") {
+		throw new Error(
+			`restoreGraph: node '${id}' has non-quiescent status '${value}' that cannot be checkpoint-restored yet`,
+		);
+	}
+	return value;
+}
+
+function checkpointDataValue(
+	value: GraphCheckpointValue,
+	id: string,
+): {
+	cache: unknown;
+	hasData: boolean;
+} {
+	if (value.kind === "SENTINEL") return { cache: SENTINEL, hasData: false };
+	if (value.kind === "DATA") return { cache: value.data, hasData: true };
+	throw new Error(`restoreGraph: node '${id}' has invalid checkpoint value`);
+}
+
+function checkpointTerminal(
+	value: GraphCheckpointTerminal,
+	id: string,
+): true | unknown | undefined {
+	if (value.kind === "none") return undefined;
+	if (value.kind === "COMPLETE") return true;
+	if (value.kind === "ERROR") return value.error;
+	throw new Error(`restoreGraph: node '${id}' has invalid terminal state`);
+}
+
+function prepareRuntime(node: GraphCheckpointNode): PreparedRuntime {
+	const nonAuthoritativeCollectionHelper = isCollectionHelperNonAuthoritative(node);
+	const value = nonAuthoritativeCollectionHelper
+		? { cache: SENTINEL, hasData: false }
+		: checkpointDataValue(node.value, node.id);
+	const terminal = checkpointTerminal(node.terminal, node.id);
+	const status = assertStatus(node.status, node.id);
+	if (terminal === true && status !== "completed") {
+		throw new Error(`restoreGraph: node '${node.id}' COMPLETE terminal requires completed status`);
+	}
+	if (terminal !== undefined && terminal !== true && status !== "errored") {
+		throw new Error(`restoreGraph: node '${node.id}' ERROR terminal requires errored status`);
+	}
+	if (terminal === undefined && (status === "completed" || status === "errored")) {
+		throw new Error(`restoreGraph: node '${node.id}' terminal status requires terminal state`);
+	}
+	if (typeof node.lifecycle.activated !== "boolean") {
+		throw new Error(`restoreGraph: node '${node.id}' lifecycle.activated must be boolean`);
+	}
+	if (typeof node.lifecycle.hasCalledFnOnce !== "boolean") {
+		throw new Error(`restoreGraph: node '${node.id}' lifecycle.hasCalledFnOnce must be boolean`);
+	}
+	if (typeof node.ctxState.persist !== "boolean") {
+		throw new Error(`restoreGraph: node '${node.id}' ctxState.persist must be boolean`);
+	}
+	const ctxState = nonAuthoritativeCollectionHelper
+		? { cache: SENTINEL, hasData: false }
+		: checkpointDataValue(node.ctxState.value, `${node.id}.ctxState`);
+	const version =
+		node.version === undefined
+			? false
+			: validateNodeVersionJson(node.version, `${node.id}.version`);
+	return {
+		cache: value.cache,
+		hasData: value.hasData,
+		status,
+		terminal,
+		hasCalledFnOnce: node.lifecycle.hasCalledFnOnce,
+		ctxState: { value: ctxState.cache, persist: node.ctxState.persist },
+		version,
+	};
+}
+
+function isCollectionHelperNonAuthoritative(node: GraphCheckpointNode): boolean {
+	if (node.factory.kind !== "registry-ref") return false;
+	return (
+		node.factory.ref === "reactiveList.delta" ||
+		node.factory.ref === "reactiveList.snapshot" ||
+		node.factory.ref === "reactiveIndex.delta" ||
+		node.factory.ref === "reactiveIndex.snapshot" ||
+		node.factory.ref === "reactiveLog.delta" ||
+		node.factory.ref === "reactiveLog.snapshot" ||
+		node.factory.ref === "reactiveMap.intent" ||
+		node.factory.ref === "reactiveMap.apply" ||
+		node.factory.ref === "reactiveMap.delta" ||
+		node.factory.ref === "reactiveMap.snapshotPrep" ||
+		node.factory.ref === "reactiveMap.snapshot"
+	);
+}
+
+function validateFactory(
+	factory: GraphCheckpointFactory,
+	registry: GraphRestoreRegistry,
+	id: string,
+): GraphRestoreDescriptor {
+	if (factory.kind === "local-only") {
+		throw new Error(
+			`restoreGraph: node '${id}' uses local-only factory '${factory.name}' (${factory.reason})`,
+		);
+	}
+	const ref = assertString(factory.ref, `factory ref for node '${id}'`);
+	const entry = registryGet(registry, ref);
+	if (!isRestoreDescriptor(entry)) {
+		throw new Error(`restoreGraph: missing registry descriptor for '${ref}' (node '${id}')`);
+	}
+	const descriptor = entry;
+	if (descriptor.ref !== ref) {
+		throw new Error(
+			`restoreGraph: registry descriptor for '${ref}' reports ref '${descriptor.ref}'`,
+		);
+	}
+	if (factory.config !== undefined) toCheckpointJson(factory.config, `${id}.factory.config`);
+	if (factory.configVersion !== undefined)
+		toCheckpointJson(factory.configVersion, `${id}.factory.configVersion`);
+	return descriptor;
+}
+
+function resolveDefinition<S, T>(
+	registry: GraphRestoreRegistry,
+	ref: string,
+	nodeId: string,
+): GraphRestoreDefinition<S, T> {
+	const entry = registryGet(registry, ref);
+	if (!isRestoreDefinition(entry)) {
+		throw new Error(`restoreGraph: missing function definition for '${ref}' (node '${nodeId}')`);
+	}
+	return entry as GraphRestoreDefinition<S, T>;
+}
+
+function prepareCheckpoint(
+	checkpoint: GraphCheckpoint,
+	registry: GraphRestoreRegistry,
+	path = "checkpoint",
+	mountAt?: string,
+): PreparedCheckpoint {
+	if (checkpoint.version !== GRAPH_CHECKPOINT_VERSION) {
+		throw new Error(`restoreGraph: unsupported checkpoint version at ${path}`);
+	}
+	toCheckpointJson(checkpoint, path);
+	const nodes = new Map<string, PreparedNode>();
+	const localIds = new Set<string>();
+	for (const node of checkpoint.nodes) {
+		assertString(node.id, `${path}.nodes[].id`);
+		if (nodes.has(node.id)) throw new Error(`restoreGraph: duplicate node id '${node.id}'`);
+		if (mountAt !== undefined && node.id.startsWith(`${mountAt}::`)) {
+			throw new Error(
+				`restoreGraph: mounted checkpoint at '${mountAt}' must use child-local node id '${node.id.slice(`${mountAt}::`.length)}', not '${node.id}'`,
+			);
+		}
+		const id = node.id;
+		if (localIds.has(id)) {
+			throw new Error(`restoreGraph: duplicate restored local node id '${id}'`);
+		}
+		localIds.add(id);
+		const factory = node.factory;
+		const descriptor = validateFactory(factory, registry, node.id);
+		const rawConfig = factory.kind === "registry-ref" ? factory.config : undefined;
+		const configVersion = factory.kind === "registry-ref" ? factory.configVersion : undefined;
+		const config = descriptor.validateConfig
+			? descriptor.validateConfig(rawConfig, configVersion, node)
+			: rawConfig;
+		assertStatus(node.status, node.id);
+		nodes.set(node.id, {
+			checkpoint: node,
+			localId: id,
+			descriptor,
+			config,
+			runtime: prepareRuntime(node),
+			deps: node.deps.map((dep, i) => assertString(dep, `${node.id}.deps[${i}]`)),
+		});
+	}
+	for (const prepared of nodes.values()) {
+		for (const dep of prepared.deps) {
+			if (!nodes.has(dep)) {
+				throw new Error(`restoreGraph: node '${prepared.checkpoint.id}' has missing dep '${dep}'`);
+			}
+		}
+	}
+	const edgeKeys = new Set<string>();
+	for (const edge of checkpoint.edges) {
+		const edgeKey = `${edge.from}\u0000${edge.to}`;
+		if (edgeKeys.has(edgeKey)) {
+			throw new Error(`restoreGraph: duplicate edge '${edge.from}' -> '${edge.to}'`);
+		}
+		edgeKeys.add(edgeKey);
+		if (!nodes.has(edge.from) || !nodes.has(edge.to)) {
+			throw new Error(
+				`restoreGraph: edge '${edge.from}' -> '${edge.to}' references a missing node`,
+			);
+		}
+		const target = nodes.get(edge.to) as PreparedNode;
+		if (!target.deps.includes(edge.from)) {
+			throw new Error(
+				`restoreGraph: edge '${edge.from}' -> '${edge.to}' is not present in target deps`,
+			);
+		}
+	}
+	for (const prepared of nodes.values()) {
+		for (const dep of prepared.deps) {
+			if (!edgeKeys.has(`${dep}\u0000${prepared.checkpoint.id}`)) {
+				throw new Error(
+					`restoreGraph: node '${prepared.checkpoint.id}' dep '${dep}' is missing its edge`,
+				);
+			}
+		}
+	}
+	const mountPaths = new Set<string>();
+	const mounts: PreparedCheckpoint["mounts"] = [];
+	for (const mount of checkpoint.mounts ?? []) {
+		const at = assertString(mount.at, `${path}.mounts[].at`);
+		if (at.length === 0) throw new Error("restoreGraph: mount path must not be empty");
+		if (mountPaths.has(at)) throw new Error(`restoreGraph: duplicate mount path '${at}'`);
+		mountPaths.add(at);
+		mounts.push({
+			at,
+			prepared: prepareCheckpoint(mount.checkpoint, registry, `${path}.mounts.${at}`, at),
+		});
+	}
+	return { checkpoint, nodes, mounts };
+}
+
+function constructPrepared(
+	prepared: PreparedCheckpoint,
+	registry: GraphRestoreRegistry,
+	dispatcher?: Dispatcher,
+	versioning?: NodeVersioningPolicy,
+): Graph {
+	const out = graph({ name: prepared.checkpoint.name, dispatcher, versioning });
+	try {
+		const built = new Map<string, Node<unknown>>();
+		const visiting = new Set<string>();
+
+		const buildNode = (id: string): Node<unknown> => {
+			const existing = built.get(id);
+			if (existing) return existing;
+			const item = prepared.nodes.get(id);
+			if (item === undefined) throw new Error(`restoreGraph: missing prepared node '${id}'`);
+			if (visiting.has(id)) throw new Error(`restoreGraph: dependency cycle at '${id}'`);
+			visiting.add(id);
+			const deps = item.deps.map(buildNode);
+			const node = item.descriptor.create({
+				graph: out,
+				id: item.localId,
+				name: item.checkpoint.name,
+				deps,
+				config: item.config,
+				configVersion:
+					item.checkpoint.factory.kind === "registry-ref"
+						? item.checkpoint.factory.configVersion
+						: undefined,
+				checkpoint: item.checkpoint,
+				resolveDefinition: (ref) => resolveDefinition(registry, ref, item.checkpoint.id),
+				registerState: (opts) => restoreStateNodeInGraph(out, item.localId, opts),
+				registerNode: (factory, nodeDeps, fn, opts) =>
+					restoreNodeInGraph(out, item.localId, factory, nodeDeps, fn, opts),
+			});
+			if (out.find(item.localId) !== node) {
+				throw new Error(
+					`restoreGraph: descriptor '${item.descriptor.ref}' did not register node '${item.localId}'`,
+				);
+			}
+			if (node.deps.length !== deps.length || node.deps.some((dep, i) => dep !== deps[i])) {
+				throw new Error(
+					`restoreGraph: descriptor '${item.descriptor.ref}' registered node '${item.localId}' with deps that do not match the checkpoint`,
+				);
+			}
+			built.set(id, node);
+			visiting.delete(id);
+			return node;
+		};
+
+		for (const id of prepared.nodes.keys()) buildNode(id);
+
+		for (const mount of prepared.mounts) {
+			out.mount(constructPrepared(mount.prepared, registry, dispatcher, versioning), {
+				at: mount.at,
+			});
+		}
+
+		for (const [id, node] of built) {
+			const runtime = (prepared.nodes.get(id) as PreparedNode).runtime;
+			restoreStateOfNode(node, {
+				cache: runtime.cache,
+				hasData: runtime.hasData,
+				status: runtime.status,
+				terminal: runtime.terminal,
+				hasCalledFnOnce: runtime.hasCalledFnOnce,
+				ctxState: runtime.ctxState,
+				version: runtime.version,
+			});
+		}
+	} finally {
+		clearRestoredCollectionMap(out);
+	}
+
+	return out;
+}
+
+export function restoreGraph(checkpoint: GraphCheckpoint, options: RestoreGraphOptions): Graph {
+	if (options == null || options.registry === undefined) {
+		throw new Error("restoreGraph: registry is required");
+	}
+	if (
+		!(options.registry instanceof Map) &&
+		(typeof options.registry !== "object" || options.registry === null)
+	) {
+		throw new Error("restoreGraph: registry must be a Map or object");
+	}
+	for (const key of Object.keys(options)) {
+		if (key !== "registry" && key !== "dispatcher" && key !== "versioning") {
+			throw new Error(`restoreGraph: unknown option '${key}'`);
+		}
+	}
+	const prepared = prepareCheckpoint(checkpoint, options.registry);
+	return constructPrepared(prepared, options.registry, options.dispatcher, options.versioning);
+}
diff --git a/packages/ts/src/graph/sources.ts b/packages/ts/src/graph/sources.ts
new file mode 100644
index 00000000..06b3d287
--- /dev/null
+++ b/packages/ts/src/graph/sources.ts
@@ -0,0 +1,1088 @@
+/**
+ * Async + sync sources (binding-layer sugar, D43 / D40 / feedback_async_sources_binding_layer).
+ *
+ * Sources are depless {@link Operator}`<never, T>` specs built on the `producer`/`node` path:
+ * the body runs ONCE on activation (node `_activate`), schedules its work, and emits later via
+ * the captured `ctx.down` (an external tier-3 emit → the leading DIRTY is synthesized for it,
+ * R-dirty-before-data). Async lives ONLY here (R-no-raw-async / F-SYNC-CORE): `setTimeout` /
+ * `Promise` / `for await` are confined to source bodies; the wave core stays sync. Cleanup is
+ * `ctx.onDeactivation` (D28), NOT a returned object. Per-language (D6/D24), never in parity.
+ *
+ * Instantiate via `g.initNode(timer(1000), [])` (graph-bound, inspectable) or
+ * {@link initNode}(timer(1000), []) (bare). Pool/pause defaults (D43): timer/interval =
+ * sync + pausable:false (keep producing through PAUSE); fromPromise/fromAsyncIter = async
+ * (default pausable, so a paused source buffers its late emits — R-async-paused).
+ */
+
+import type { Ctx } from "../ctx/types.js";
+import type { Node, NodeOptions } from "../node/node.js";
+import { errorPayload } from "../protocol/messages.js";
+import { toCheckpointJson } from "./checkpoint.js";
+import type {
+	DriverCancel,
+	DriverResult,
+	HttpRequest,
+	HttpResponse,
+	ProcessCommand,
+	ProcessResult,
+	SseDriverEvent,
+	SseEvent,
+	SseRequest,
+	WebhookDriverEvent,
+	WebhookEvent,
+	WebhookRegistration,
+	WebSocketDriverEvent,
+	WebSocketEvent,
+	WebSocketRequest,
+} from "./environment.js";
+import { initNode, type Operator } from "./operators.js";
+
+/**
+ * Values accepted by {@link fromAny}: an existing Node, a Promise, an (a)sync iterable, or a
+ * bare scalar. The universal coercion target for higher-order operators (CSP-2.7).
+ */
+export type NodeInput<T> = Node<T> | PromiseLike<T> | AsyncIterable<T> | Iterable<T> | T;
+
+/** Host-boundary options for {@link singleFromAny}. */
+export interface SingleFromAnyOptions<K> {
+	/**
+	 * Map a caller key to the in-flight dedupe key. Defaults to key identity; object keys dedupe only
+	 * when the same object reference is reused. Return a stable string/canonical value for structural
+	 * object-key dedupe.
+	 */
+	keyOf?: (key: K) => unknown;
+	/** Treat a sync iterable result as a stream and take its first item. Defaults to scalar value. */
+	iter?: boolean;
+}
+
+/**
+ * Internal: build a depless source spec. `setup` runs once on activation; its returned fn (if
+ * any) is registered as the deactivation cleanup (clear timers / abort). `setup` schedules the
+ * async work and emits via `ctx.down` — synchronously (sync sources) or later (async sources).
+ */
+function source<T>(
+	factory: string,
+	// biome-ignore lint/suspicious/noConfusingVoidType: setup returns a cleanup fn OR nothing — the void arm keeps no-return source bodies (e.g. `of`/`fromIter`) ergonomic, same idiom as EffectFn.
+	setup: (ctx: Ctx) => void | (() => void),
+	opts?: Partial<NodeOptions<T>>,
+): Operator<never, T> {
+	return {
+		factory,
+		opts,
+		body: (ctx) => {
+			let cleanup: undefined | (() => void);
+			let deactivated = false;
+			ctx.onDeactivation(() => {
+				deactivated = true;
+				if (typeof cleanup === "function") cleanup();
+			});
+			const maybeCleanup = setup(ctx);
+			cleanup = typeof maybeCleanup === "function" ? maybeCleanup : undefined;
+			if (deactivated && typeof cleanup === "function") cleanup();
+		},
+	};
+}
+
+function assertNonEmptyString(value: string, label: string): void {
+	if (typeof value !== "string" || value.length === 0) {
+		throw new TypeError(`${label} must be a non-empty string`);
+	}
+}
+
+function cleanupDriverWork(
+	active: { value: boolean },
+	cancelSlot: { value: DriverCancel | undefined },
+): void {
+	active.value = false;
+	const cancel = cancelSlot.value;
+	cancelSlot.value = undefined;
+	if (cancel !== undefined) runDriverCancel(cancel);
+}
+
+function installDriverCancel(
+	active: { value: boolean },
+	cancelSlot: { value: DriverCancel | undefined },
+	cancel: DriverCancel,
+): void {
+	if (active.value) cancelSlot.value = cancel;
+	else runDriverCancel(cancel);
+}
+
+function runDriverCancel(cancel: DriverCancel): void {
+	try {
+		cancel();
+	} catch {
+		// Driver cleanup is best-effort: it must not suppress graph-visible terminal delivery.
+	}
+}
+
+function driverOneShotSource<T>(
+	factory: string,
+	missing: string,
+	start: (ctx: Ctx, callback: (result: DriverResult<T>) => void) => DriverCancel | undefined,
+): Operator<never, T> {
+	return source<T>(
+		factory,
+		(ctx) => {
+			const active = { value: true };
+			const cancelSlot: { value: DriverCancel | undefined } = { value: undefined };
+			const callback = (result: DriverResult<T>) => {
+				if (!active.value) return;
+				cleanupDriverWork(active, cancelSlot);
+				if (result.ok) ctx.down([["DATA", result.value], ["COMPLETE"]]);
+				else ctx.down([["ERROR", errorPayload(result.error)]]);
+			};
+			let cancel: DriverCancel | undefined;
+			try {
+				cancel = start(ctx, callback);
+			} catch (e) {
+				active.value = false;
+				ctx.down([["ERROR", errorPayload(e)]]);
+				return;
+			}
+			if (cancel === undefined) {
+				active.value = false;
+				ctx.down([["ERROR", missing]]);
+				return;
+			}
+			installDriverCancel(active, cancelSlot, cancel);
+			return () => cleanupDriverWork(active, cancelSlot);
+		},
+		{ pool: "async", pausable: false },
+	);
+}
+
+function driverStreamSource<T, E extends { readonly kind: string }>(
+	factory: string,
+	missing: string,
+	start: (ctx: Ctx, callback: (event: E) => void) => DriverCancel | undefined,
+	dataOf: (event: E) => T | undefined,
+	errorOf: (event: E) => unknown,
+): Operator<never, T> {
+	return source<T>(
+		factory,
+		(ctx) => {
+			const active = { value: true };
+			const cancelSlot: { value: DriverCancel | undefined } = { value: undefined };
+			const callback = (event: E) => {
+				if (!active.value) return;
+				if (event.kind === "event") {
+					const value = dataOf(event);
+					if (value !== undefined) ctx.down([["DATA", value]]);
+				} else if (event.kind === "error") {
+					cleanupDriverWork(active, cancelSlot);
+					ctx.down([["ERROR", errorPayload(errorOf(event))]]);
+				} else if (event.kind === "complete") {
+					cleanupDriverWork(active, cancelSlot);
+					ctx.down([["COMPLETE"]]);
+				}
+			};
+			let cancel: DriverCancel | undefined;
+			try {
+				cancel = start(ctx, callback);
+			} catch (e) {
+				active.value = false;
+				ctx.down([["ERROR", errorPayload(e)]]);
+				return;
+			}
+			if (cancel === undefined) {
+				active.value = false;
+				ctx.down([["ERROR", missing]]);
+				return;
+			}
+			installDriverCancel(active, cancelSlot, cancel);
+			return () => cleanupDriverWork(active, cancelSlot);
+		},
+		{ pool: "async", pausable: false },
+	);
+}
+
+function isNode(x: unknown): x is Node {
+	return (
+		x != null &&
+		typeof x === "object" &&
+		"cache" in x &&
+		typeof (x as Node).subscribe === "function"
+	);
+}
+
+function isThenable(x: unknown): x is PromiseLike<unknown> {
+	return x != null && typeof (x as PromiseLike<unknown>).then === "function";
+}
+
+function isAsyncIterable<T>(x: unknown): x is AsyncIterable<T> {
+	return (
+		x !== null &&
+		x !== undefined &&
+		typeof (x as { [Symbol.asyncIterator]?: unknown })[Symbol.asyncIterator] === "function"
+	);
+}
+
+function isIterable<T>(x: unknown): x is Iterable<T> {
+	return (
+		x !== null &&
+		x !== undefined &&
+		typeof (x as { [Symbol.iterator]?: unknown })[Symbol.iterator] === "function"
+	);
+}
+
+/** Options shared by async/timer sources: an optional AbortSignal → ERROR on abort. */
+export interface AsyncSourceOpts {
+	signal?: AbortSignal;
+}
+
+export interface TimerSourceOpts extends AsyncSourceOpts {
+	period?: number;
+}
+
+/** Options for {@link fromCron}. */
+export interface FromCronOptions extends AsyncSourceOpts {
+	/** Cron matcher polling interval in milliseconds. Default: 60_000. */
+	tickMs?: number;
+	/** IANA timezone used for wall-clock cron matching. Defaults to the host-local timezone. */
+	timezone?: string;
+	/**
+	 * DST policy for timezone-aware matching. Current D484 defaults are explicit: nonexistent
+	 * wall-clock minutes are skipped, and repeated wall-clock minutes fire at most once.
+	 */
+	dst?: {
+		readonly nonexistent?: "skip";
+		readonly repeated?: "once";
+	};
+	/**
+	 * Emitted value shape. `timestamp_ns` is a decimal string so it cannot lose precision as a
+	 * JavaScript number; use `timestamp_ms` when numeric millisecond precision is enough.
+	 */
+	output?: "date" | "timestamp_ms" | "timestamp_ns";
+}
+
+/** Minimal five-field cron schedule: minute hour day-of-month month day-of-week. */
+export interface CronSchedule {
+	readonly minutes: ReadonlySet<number>;
+	readonly hours: ReadonlySet<number>;
+	readonly daysOfMonth: ReadonlySet<number>;
+	readonly months: ReadonlySet<number>;
+	readonly daysOfWeek: ReadonlySet<number>;
+}
+
+/** DOM/EventEmitter-style target accepted by {@link fromEvent}. */
+export interface EventTargetLike {
+	addEventListener(
+		type: string,
+		listener: (event: unknown) => void,
+		options?: EventListenerOptionsLike,
+	): void;
+	removeEventListener(
+		type: string,
+		listener: (event: unknown) => void,
+		options?: EventListenerOptionsLike,
+	): void;
+}
+
+export interface EventListenerOptionsLike {
+	capture?: boolean;
+	passive?: boolean;
+	once?: boolean;
+}
+
+export type FromEventOptions = EventListenerOptionsLike;
+
+/** Host push registration callback accepted by {@link fromPushNotification}. */
+export type PushUnsubscribe = () => void;
+export type PushRegister<T> = (deliver: (payload: T) => void) => PushUnsubscribe | undefined;
+
+function parseCronField(field: string, min: number, max: number): Set<number> {
+	if (field.length === 0) throw new Error("Invalid cron field: empty");
+	const out = new Set<number>();
+	for (const part of field.split(",")) {
+		if (part.length === 0) throw new Error(`Invalid cron field: ${field}`);
+		const stepParts = part.split("/");
+		if (stepParts.length > 2) throw new Error(`Invalid cron step: ${part}`);
+		const [range, stepText] = stepParts;
+		if (range == null || range.length === 0) throw new Error(`Invalid cron field: ${field}`);
+		if (stepText === "") throw new Error(`Invalid cron step: ${part}`);
+		const step = stepText == null ? 1 : parseCronInt(stepText, `Invalid cron step: ${part}`);
+		if (step < 1) throw new Error(`Invalid cron step: ${part}`);
+
+		let start: number;
+		let end: number;
+		if (range === "*") {
+			start = min;
+			end = max;
+		} else if (range.includes("-")) {
+			const [a, b, extra] = range.split("-");
+			if (extra !== undefined || a === "" || b === "")
+				throw new Error(`Invalid cron field: ${field}`);
+			start = parseCronInt(a, `Invalid cron field: ${field}`);
+			end = parseCronInt(b, `Invalid cron field: ${field}`);
+		} else {
+			start = parseCronInt(range, `Invalid cron field: ${field}`);
+			end = start;
+		}
+
+		if (!Number.isInteger(start) || !Number.isInteger(end)) {
+			throw new Error(`Invalid cron field: ${field}`);
+		}
+		if (start < min || end > max) {
+			throw new RangeError(`Cron field out of range: ${field} (${min}-${max})`);
+		}
+		if (start > end) throw new Error(`Invalid cron range: ${start}-${end} in ${field}`);
+		for (let i = start; i <= end; i += step) out.add(i);
+	}
+	return out;
+}
+
+function parseCronInt(text: string, message: string): number {
+	if (!/^\d+$/.test(text)) throw new Error(message);
+	const value = Number.parseInt(text, 10);
+	if (!Number.isSafeInteger(value)) throw new Error(message);
+	return value;
+}
+
+/** Parse a standard five-field cron expression. */
+export function parseCron(expr: string): CronSchedule {
+	const parts = expr.trim().split(/\s+/);
+	if (parts.length !== 5 || parts.some((part) => part.length === 0)) {
+		throw new Error(`Invalid cron: expected 5 fields, got ${parts.length}`);
+	}
+	return {
+		minutes: parseCronField(parts[0], 0, 59),
+		hours: parseCronField(parts[1], 0, 23),
+		daysOfMonth: parseCronField(parts[2], 1, 31),
+		months: parseCronField(parts[3], 1, 12),
+		daysOfWeek: parseCronField(parts[4], 0, 6),
+	};
+}
+
+export interface CronMatchOptions {
+	/** IANA timezone used for wall-clock projection. Defaults to the host-local timezone. */
+	timezone?: string;
+}
+
+interface CronWallClockFields {
+	readonly year: number;
+	readonly month: number;
+	readonly day: number;
+	readonly hour: number;
+	readonly minute: number;
+	readonly dayOfWeek: number;
+}
+
+/** Test whether a Date matches a parsed cron schedule in host-local time or an IANA timezone. */
+export function matchesCron(
+	schedule: CronSchedule,
+	date: Date,
+	opts: CronMatchOptions = {},
+): boolean {
+	const fields = cronWallClockFields(date, opts.timezone);
+	return (
+		schedule.minutes.has(fields.minute) &&
+		schedule.hours.has(fields.hour) &&
+		schedule.daysOfMonth.has(fields.day) &&
+		schedule.months.has(fields.month) &&
+		schedule.daysOfWeek.has(fields.dayOfWeek)
+	);
+}
+
+function cronMinuteKey(date: Date, timezone?: string): string {
+	const fields = cronWallClockFields(date, timezone);
+	return `${fields.year}-${fields.month}-${fields.day}-${fields.hour}-${fields.minute}`;
+}
+
+function cronDayKey(date: Date, timezone?: string): string {
+	const fields = cronWallClockFields(date, timezone);
+	return `${fields.year}-${fields.month}-${fields.day}`;
+}
+
+function cronWallClockFields(date: Date, timezone?: string): CronWallClockFields {
+	if (timezone === undefined) {
+		return {
+			year: date.getFullYear(),
+			month: date.getMonth() + 1,
+			day: date.getDate(),
+			hour: date.getHours(),
+			minute: date.getMinutes(),
+			dayOfWeek: date.getDay(),
+		};
+	}
+	const parts = timezoneFormatter(timezone).formatToParts(date);
+	const values: Record<string, number> = {};
+	for (const part of parts) {
+		if (
+			part.type === "year" ||
+			part.type === "month" ||
+			part.type === "day" ||
+			part.type === "hour" ||
+			part.type === "minute"
+		) {
+			values[part.type] = Number.parseInt(part.value, 10);
+		}
+	}
+	const year = values.year;
+	const month = values.month;
+	const day = values.day;
+	const hour = values.hour;
+	const minute = values.minute;
+	if (
+		year === undefined ||
+		month === undefined ||
+		day === undefined ||
+		hour === undefined ||
+		minute === undefined
+	) {
+		throw new Error(`fromCron: timezone projection failed for ${timezone}`);
+	}
+	return {
+		year,
+		month,
+		day,
+		hour,
+		minute,
+		dayOfWeek: new Date(Date.UTC(year, month - 1, day)).getUTCDay(),
+	};
+}
+
+const TIMEZONE_FORMATTERS = new Map<string, Intl.DateTimeFormat>();
+
+function timezoneFormatter(timezone: string): Intl.DateTimeFormat {
+	const existing = TIMEZONE_FORMATTERS.get(timezone);
+	if (existing !== undefined) return existing;
+	assertNonEmptyString(timezone, "fromCron: timezone");
+	try {
+		const formatter = new Intl.DateTimeFormat("en-US-u-ca-gregory-nu-latn", {
+			timeZone: timezone,
+			year: "numeric",
+			month: "2-digit",
+			day: "2-digit",
+			hour: "2-digit",
+			minute: "2-digit",
+			hourCycle: "h23",
+		});
+		formatter.format(new Date(0));
+		TIMEZONE_FORMATTERS.set(timezone, formatter);
+		return formatter;
+	} catch (error) {
+		throw new RangeError(
+			`fromCron: unsupported IANA timezone '${timezone}' (${error instanceof Error ? error.message : String(error)})`,
+		);
+	}
+}
+
+function dateToTimestampNs(date: Date): string {
+	return (BigInt(date.getTime()) * 1_000_000n).toString();
+}
+
+export function fromCron(
+	expr: string,
+	opts: FromCronOptions & { output: "date" },
+): Operator<never, Date>;
+export function fromCron(
+	expr: string,
+	opts: FromCronOptions & { output: "timestamp_ms" },
+): Operator<never, number>;
+export function fromCron(
+	expr: string,
+	opts?: FromCronOptions & { output?: "timestamp_ns" },
+): Operator<never, string>;
+export function fromCron(
+	expr: string,
+	opts?: FromCronOptions,
+): Operator<never, Date | number | string>;
+export function fromCron(
+	expr: string,
+	opts: FromCronOptions = {},
+): Operator<never, Date | number | string> {
+	const schedule = parseCron(expr);
+	const { tickMs = 60_000, output = "timestamp_ns", signal, timezone } = opts;
+	if (opts.dst?.nonexistent !== undefined && opts.dst.nonexistent !== "skip") {
+		throw new RangeError("fromCron: dst.nonexistent currently supports only 'skip'");
+	}
+	if (opts.dst?.repeated !== undefined && opts.dst.repeated !== "once") {
+		throw new RangeError("fromCron: dst.repeated currently supports only 'once'");
+	}
+	if (timezone !== undefined) timezoneFormatter(timezone);
+	if (!Number.isFinite(tickMs) || tickMs <= 0) {
+		throw new RangeError("fromCron: tickMs must be a positive finite number");
+	}
+	return source<Date | number | string>(
+		"fromCron",
+		(ctx) => {
+			let done = false;
+			let lastFiredKey: string | undefined;
+			let firedTimezoneDay: string | undefined;
+			const firedTimezoneMinutes = new Set<string>();
+			let intervalId: ReturnType<typeof setInterval> | undefined;
+			const cleanup = () => {
+				done = true;
+				if (intervalId !== undefined) clearInterval(intervalId);
+				intervalId = undefined;
+				signal?.removeEventListener("abort", onAbort);
+			};
+			const onAbort = () => {
+				if (done) return;
+				cleanup();
+				ctx.down([["ERROR", errorPayload(signal?.reason)]]);
+			};
+			const emitNow = (now: Date) => {
+				if (output === "date") ctx.down([["DATA", now]]);
+				else if (output === "timestamp_ms") ctx.down([["DATA", now.getTime()]]);
+				else ctx.down([["DATA", dateToTimestampNs(now)]]);
+			};
+			const check = () => {
+				if (done) return;
+				const now = new Date();
+				const key = cronMinuteKey(now, timezone);
+				const alreadyFired =
+					timezone === undefined ? key === lastFiredKey : firedTimezoneMinutes.has(key);
+				if (!alreadyFired && matchesCron(schedule, now, { timezone })) {
+					lastFiredKey = key;
+					if (timezone !== undefined) {
+						const dayKey = cronDayKey(now, timezone);
+						if (dayKey !== firedTimezoneDay) {
+							firedTimezoneDay = dayKey;
+							firedTimezoneMinutes.clear();
+						}
+						firedTimezoneMinutes.add(key);
+					}
+					emitNow(now);
+				}
+			};
+			if (signal?.aborted) {
+				onAbort();
+				return cleanup;
+			}
+			signal?.addEventListener("abort", onAbort, { once: true });
+			check();
+			intervalId = setInterval(check, tickMs);
+			return cleanup;
+		},
+		{ pool: "sync", pausable: false },
+	);
+}
+
+export function runProcess(
+	program: string,
+	args: readonly string[] = [],
+): Operator<never, ProcessResult> {
+	return runProcessWithOptions({ program, args });
+}
+
+export function fromProcess(
+	program: string,
+	args: readonly string[] = [],
+): Operator<never, ProcessResult> {
+	return processSource("fromProcess", { program, args });
+}
+
+export function runProcessWithOptions(command: ProcessCommand): Operator<never, ProcessResult> {
+	return processSource("runProcess", command);
+}
+
+function processSource(factory: string, command: ProcessCommand): Operator<never, ProcessResult> {
+	assertNonEmptyString(command.program, `${factory}: program`);
+	return driverOneShotSource<ProcessResult>(
+		factory,
+		`${factory}: missing process driver`,
+		(ctx, callback) => ctx.environment().processDriver()?.run(command, callback),
+	);
+}
+
+export function fromHttp(url: string): Operator<never, HttpResponse> {
+	return fromHttpWithOptions({ method: "GET", url });
+}
+
+export function fromHttpWithOptions(request: HttpRequest): Operator<never, HttpResponse> {
+	assertNonEmptyString(request.url, "fromHttp: url");
+	assertNonEmptyString(request.method, "fromHttp: method");
+	return driverOneShotSource<HttpResponse>(
+		"fromHttp",
+		"fromHttp: missing http driver",
+		(ctx, callback) => ctx.environment().httpDriver()?.request(request, callback),
+	);
+}
+
+export function fromSSE(url: string): Operator<never, SseEvent> {
+	return fromSSEWithOptions({ url });
+}
+
+export function fromSSEWithOptions(request: SseRequest): Operator<never, SseEvent> {
+	assertNonEmptyString(request.url, "fromSSE: url");
+	return driverStreamSource<SseEvent, SseDriverEvent>(
+		"fromSSE",
+		"fromSSE: missing sse driver",
+		(ctx, callback) => ctx.environment().sseDriver()?.connect(request, callback),
+		(event) => (event.kind === "event" ? event.event : undefined),
+		(event) => (event.kind === "error" ? event.error : undefined),
+	);
+}
+
+export function fromWebSocket(url: string): Operator<never, WebSocketEvent> {
+	return fromWebSocketWithOptions({ url });
+}
+
+export function fromWebSocketWithOptions(
+	request: WebSocketRequest,
+): Operator<never, WebSocketEvent> {
+	assertNonEmptyString(request.url, "fromWebSocket: url");
+	return driverStreamSource<WebSocketEvent, WebSocketDriverEvent>(
+		"fromWebSocket",
+		"fromWebSocket: missing websocket driver",
+		(ctx, callback) => ctx.environment().webSocketDriver()?.connect(request, callback),
+		(event) => (event.kind === "event" ? event.event : undefined),
+		(event) => (event.kind === "error" ? event.error : undefined),
+	);
+}
+
+export function fromWebhook(id: string): Operator<never, WebhookEvent> {
+	return fromWebhookWithOptions({ id });
+}
+
+export function fromWebhookWithOptions(
+	registration: WebhookRegistration,
+): Operator<never, WebhookEvent> {
+	assertNonEmptyString(registration.id, "fromWebhook: id");
+	return driverStreamSource<WebhookEvent, WebhookDriverEvent>(
+		"fromWebhook",
+		"fromWebhook: missing webhook driver",
+		(ctx, callback) => ctx.environment().webhookDriver()?.register(registration, callback),
+		(event) => (event.kind === "event" ? event.event : undefined),
+		(event) => (event.kind === "error" ? event.error : undefined),
+	);
+}
+
+function timerSource(factory: string, ms: number, opts?: TimerSourceOpts): Operator<never, number> {
+	const { period, signal } = opts ?? {};
+	const op = source<number>(
+		factory,
+		(ctx) => {
+			let done = false;
+			let count = 0;
+			let t: ReturnType<typeof setTimeout> | undefined;
+			let iv: ReturnType<typeof setInterval> | undefined;
+			const cleanup = () => {
+				done = true;
+				if (t !== undefined) clearTimeout(t);
+				if (iv !== undefined) clearInterval(iv);
+				signal?.removeEventListener("abort", onAbort);
+			};
+			const onAbort = () => {
+				if (done) return;
+				cleanup();
+				ctx.down([["ERROR", errorPayload(signal?.reason)]]);
+			};
+			const finish = () => {
+				if (done) return;
+				if (period != null) {
+					ctx.down([["DATA", count++]]);
+					iv = setInterval(() => {
+						if (done) return;
+						ctx.down([["DATA", count++]]);
+					}, period);
+				} else {
+					// One-shot: DATA then COMPLETE in one wave (terminal-is-forever).
+					done = true;
+					signal?.removeEventListener("abort", onAbort);
+					ctx.down([["DATA", count++], ["COMPLETE"]]);
+				}
+			};
+			if (signal?.aborted) {
+				onAbort();
+				return;
+			}
+			signal?.addEventListener("abort", onAbort, { once: true });
+			t = setTimeout(finish, ms);
+			return cleanup;
+		},
+		{ pool: "sync", pausable: false },
+	);
+	if (factory === "timer" && period === undefined && signal === undefined) {
+		return { ...op, restore: { ref: "timer", config: { ms: toCheckpointJson(ms, "timer.ms") } } };
+	}
+	return op;
+}
+
+/**
+ * Timer source: one-shot (first tick then COMPLETE) or periodic (`{period}` → 0, 1, 2, …).
+ * sync pool + pausable:false (a timer keeps producing through PAUSE, R-pause-modes). Emits the
+ * tick counter from 0; deactivation clears the timers.
+ */
+export function timer(ms: number, opts?: TimerSourceOpts): Operator<never, number> {
+	return timerSource("timer", ms, opts);
+}
+
+/** Frozen pure-ts name for {@link timer}; preserves the real factory name in describe(). */
+export function fromTimer(ms: number, opts?: TimerSourceOpts): Operator<never, number> {
+	return timerSource("fromTimer", ms, opts);
+}
+
+/** interval: periodic ticks (0, 1, 2, …), first at `ms`, then every `ms` (RxJS semantics). */
+export function interval(ms: number): Operator<never, number> {
+	return timerSource("interval", ms, { period: ms });
+}
+
+/**
+ * Lift a Promise (or thenable) to a single-value stream: one DATA then COMPLETE, or ERROR on
+ * rejection. async pool (default pausable → a paused source buffers its late emit). Optional
+ * `signal` aborts to ERROR.
+ */
+export function fromPromise<T>(
+	p: Promise<T> | PromiseLike<T>,
+	opts?: AsyncSourceOpts,
+): Operator<never, T> {
+	const signal = opts?.signal;
+	return source<T>(
+		"fromPromise",
+		(ctx) => {
+			let settled = false;
+			const onAbort = () => {
+				if (settled) return;
+				settled = true;
+				// onAbort only runs from a `signal` listener / the `signal.aborted` guard → signal is defined.
+				ctx.down([["ERROR", errorPayload((signal as AbortSignal).reason)]]);
+			};
+			if (signal?.aborted) {
+				onAbort();
+				return;
+			}
+			signal?.addEventListener("abort", onAbort, { once: true });
+			void Promise.resolve(p).then(
+				(v) => {
+					if (settled) return;
+					settled = true;
+					signal?.removeEventListener("abort", onAbort);
+					ctx.down([["DATA", v], ["COMPLETE"]]);
+				},
+				(e) => {
+					if (settled) return;
+					settled = true;
+					signal?.removeEventListener("abort", onAbort);
+					ctx.down([["ERROR", errorPayload(e)]]);
+				},
+			);
+			return () => {
+				settled = true;
+				signal?.removeEventListener("abort", onAbort);
+			};
+		},
+		{ pool: "async" },
+	);
+}
+
+/**
+ * Read an async iterable: each value → DATA; COMPLETE when done; ERROR on failure. async pool.
+ * Optional `signal` aborts the pump.
+ */
+export function fromAsyncIter<T>(
+	iterable: AsyncIterable<T>,
+	opts?: AsyncSourceOpts,
+): Operator<never, T> {
+	const outerSignal = opts?.signal;
+	return source<T>(
+		"fromAsyncIter",
+		(ctx) => {
+			const ac = new AbortController();
+			const onOuterAbort = () => ac.abort(outerSignal?.reason);
+			outerSignal?.addEventListener("abort", onOuterAbort, { once: true });
+			let done = false;
+			const pump = async () => {
+				try {
+					for await (const v of iterable) {
+						if (ac.signal.aborted) break;
+						ctx.down([["DATA", v]]);
+					}
+					if (!ac.signal.aborted) ctx.down([["COMPLETE"]]);
+				} catch (e) {
+					if (!ac.signal.aborted) ctx.down([["ERROR", errorPayload(e)]]);
+				} finally {
+					done = true;
+				}
+			};
+			void pump();
+			return () => {
+				if (!done) ac.abort();
+				outerSignal?.removeEventListener("abort", onOuterAbort);
+			};
+		},
+		{ pool: "async" },
+	);
+}
+
+/**
+ * of: synchronous values — each argument as DATA, then COMPLETE. `of()` is the EMPTY source.
+ */
+export function of<T = never>(...values: T[]): Operator<never, T> {
+	return source<T>(
+		"of",
+		(ctx) => {
+			for (const value of values) ctx.down([["DATA", value]]);
+			ctx.down([["COMPLETE"]]);
+		},
+		{ pool: "sync" },
+	);
+}
+
+/** fromIter: a sync iterable — each value → DATA (in order), then COMPLETE, on activation. */
+export function fromIter<T>(iterable: Iterable<T>): Operator<never, T> {
+	return source<T>(
+		"fromIter",
+		(ctx) => {
+			for (const v of iterable) ctx.down([["DATA", v]]);
+			ctx.down([["COMPLETE"]]);
+		},
+		{ pool: "sync" },
+	);
+}
+
+/** EMPTY analogue: complete immediately with no DATA. */
+export function empty<T = never>(): Operator<never, T> {
+	return source<T>(
+		"empty",
+		(ctx) => {
+			ctx.down([["COMPLETE"]]);
+		},
+		{ pool: "sync" },
+	);
+}
+
+/** NEVER analogue: activate and remain silent until deactivation. */
+export function never<T = never>(): Operator<never, T> {
+	return source<T>("never", () => undefined, { pool: "sync" });
+}
+
+/** Error source: terminate with ERROR on activation, coercing invalid host-language payloads. */
+export function throwError(err: unknown): Operator<never, never> {
+	return source<never>(
+		"throwError",
+		(ctx) => {
+			ctx.down([["ERROR", errorPayload(err)]]);
+		},
+		{ pool: "sync" },
+	);
+}
+
+/**
+ * Wrap a DOM-style event target. Each event becomes DATA; deactivation removes the listener.
+ * External callbacks are source boundaries (D43), so no polling or operator-level async leaks in.
+ */
+export function fromEvent<T = unknown>(
+	target: EventTargetLike,
+	type: string,
+	opts: FromEventOptions = {},
+): Operator<never, T> {
+	if (target == null || typeof target.addEventListener !== "function") {
+		throw new TypeError("fromEvent: target must implement addEventListener");
+	}
+	if (typeof target.removeEventListener !== "function") {
+		throw new TypeError("fromEvent: target must implement removeEventListener");
+	}
+	if (typeof type !== "string" || type.length === 0) {
+		throw new TypeError("fromEvent: event type must be a non-empty string");
+	}
+	return source<T>(
+		"fromEvent",
+		(ctx) => {
+			let done = false;
+			const handler = (event: unknown) => {
+				if (!done) ctx.down([["DATA", event as T]]);
+			};
+			target.addEventListener(type, handler, opts);
+			return () => {
+				done = true;
+				target.removeEventListener(type, handler, opts);
+			};
+		},
+		{ pool: "sync" },
+	);
+}
+
+/**
+ * Wrap a host push transport. The host owns network/native setup; this factory owns reactive
+ * delivery and teardown only, preserving async-at-source-boundary discipline.
+ */
+export function fromPushNotification<T = unknown>(register: PushRegister<T>): Operator<never, T> {
+	if (typeof register !== "function") {
+		throw new TypeError("fromPushNotification: register must be a function");
+	}
+	return source<T>(
+		"fromPushNotification",
+		(ctx) => {
+			let done = false;
+			const deliver = (payload: T) => {
+				if (!done) ctx.down([["DATA", payload]]);
+			};
+			const unsubscribe = register(deliver);
+			return () => {
+				done = true;
+				if (typeof unsubscribe === "function") unsubscribe();
+			};
+		},
+		{ pool: "sync" },
+	);
+}
+
+/**
+ * Coerce a {@link NodeInput}`<T>` to a `Node<T>` (D43 — coercion prerequisite for the CSP-2.7
+ * higher-order operators). An existing Node passes through; a thenable → {@link fromPromise};
+ * an async iterable → {@link fromAsyncIter}; with `{iter:true}` a sync iterable →
+ * {@link fromIter}; everything else → {@link of}. Coerced nodes are bare (use
+ * `opts.dispatcher` to bind one, default = process-global D26).
+ */
+export function fromAny<T>(
+	input: NodeInput<T>,
+	opts: NodeOptions<T> & { iter?: boolean } = {},
+): Node<T> {
+	if (isNode(input)) return input as Node<T>;
+	const { iter, ...nodeOpts } = opts;
+	if (isThenable(input)) {
+		return initNode(fromPromise(input as PromiseLike<T>), [], nodeOpts);
+	}
+	if (input !== null && input !== undefined) {
+		const candidate = input as {
+			[Symbol.asyncIterator]?: unknown;
+			[Symbol.iterator]?: unknown;
+		};
+		if (typeof candidate[Symbol.asyncIterator] === "function") {
+			return initNode(fromAsyncIter(input as AsyncIterable<T>), [], nodeOpts);
+		}
+		if (iter === true && typeof candidate[Symbol.iterator] === "function") {
+			return initNode(fromIter(input as Iterable<T>), [], nodeOpts);
+		}
+	}
+	return initNode(of(input as T), [], nodeOpts);
+}
+
+/**
+ * Resolve the first DATA from a Node as a Promise. This is a host-boundary escape hatch, not a
+ * graph operator; do not call it from reactive node bodies. ERROR rejects, and COMPLETE before DATA
+ * rejects because no value exists.
+ */
+export function firstValueFrom<T>(source: Node<T>): Promise<T> {
+	return new Promise<T>((resolve, reject) => {
+		let settled = false;
+		let shouldUnsub = false;
+		let unsub: (() => void) | undefined;
+		const finish = (f: () => void): void => {
+			if (settled) return;
+			settled = true;
+			f();
+			if (unsub) {
+				unsub();
+				unsub = undefined;
+			} else {
+				shouldUnsub = true;
+			}
+		};
+		unsub = source.subscribe((msg) => {
+			if (msg[0] === "DATA") {
+				finish(() => resolve(msg[1] as T));
+			} else if (msg[0] === "ERROR") {
+				finish(() => reject(msg[1]));
+			} else if (msg[0] === "COMPLETE") {
+				finish(() => reject(new Error("firstValueFrom: completed without DATA")));
+			} else if (msg[0] === "TEARDOWN") {
+				finish(() => reject(new Error("firstValueFrom: torn down without DATA")));
+			}
+		});
+		if (shouldUnsub) {
+			unsub?.();
+			unsub = undefined;
+		}
+	});
+}
+
+function singleFromAnyValue<T>(value: T): T {
+	if (value === undefined) {
+		throw new TypeError("singleFromAny: undefined is the substrate SENTINEL");
+	}
+	return value;
+}
+
+async function firstFromAsyncIterable<T>(input: AsyncIterable<T>): Promise<T> {
+	const iter = input[Symbol.asyncIterator]();
+	const { value, done } = await iter.next();
+	if (done) {
+		await iter.return?.();
+		throw new Error("singleFromAny: factory returned empty async iterable");
+	}
+	try {
+		await iter.return?.();
+	} catch {
+		// The first value is the bridge result; close failures after that are cleanup-only.
+	}
+	return value as T;
+}
+
+function firstFromIterable<T>(input: Iterable<T>): Promise<T> {
+	const iter = input[Symbol.iterator]();
+	const { value, done } = iter.next();
+	if (done) {
+		iter.return?.();
+		return Promise.reject(new Error("singleFromAny: factory returned empty iterable"));
+	}
+	try {
+		iter.return?.();
+	} catch {
+		// The first value is the bridge result; close failures after that are cleanup-only.
+	}
+	return Promise.resolve(value as T);
+}
+
+function nodeInputToPromise<T>(input: NodeInput<T>, opts: { iter?: boolean }): Promise<T> {
+	if (isThenable(input)) return Promise.resolve(input as PromiseLike<T>).then(singleFromAnyValue);
+	if (isNode(input)) return firstValueFrom(input as Node<T>).then(singleFromAnyValue);
+	if (isAsyncIterable<T>(input)) return firstFromAsyncIterable(input).then(singleFromAnyValue);
+	if (opts.iter === true && isIterable<T>(input)) {
+		return firstFromIterable(input).then(singleFromAnyValue);
+	}
+	if (input === undefined) {
+		return Promise.reject(new TypeError("singleFromAny: undefined is the substrate SENTINEL"));
+	}
+	return Promise.resolve(singleFromAnyValue(input as T));
+}
+
+/**
+ * Keyed singleflight over {@link NodeInput}. Concurrent calls with the same key share one Promise;
+ * once that input resolves/rejects, the in-flight entry is cleared and a later call re-runs the
+ * factory. Host-boundary helper only; it does not create graph topology.
+ */
+export function singleFromAny<K, T>(
+	factory: (key: K) => NodeInput<T>,
+	opts: SingleFromAnyOptions<K> = {},
+): (key: K) => Promise<T> {
+	const keyOf = opts.keyOf ?? ((key: K): unknown => key);
+	const inFlight = new Map<unknown, Promise<T>>();
+
+	return (key: K): Promise<T> => {
+		const dedupeKey = keyOf(key);
+		const existing = inFlight.get(dedupeKey);
+		if (existing) return existing;
+
+		let resolvePending!: (value: T) => void;
+		let rejectPending!: (reason: unknown) => void;
+		let tracked!: Promise<T>;
+		const cleanup = (): void => {
+			if (inFlight.get(dedupeKey) === tracked) inFlight.delete(dedupeKey);
+		};
+		const pending = new Promise<T>((resolve, reject) => {
+			resolvePending = resolve;
+			rejectPending = reject;
+		});
+		tracked = pending.then(
+			(value) => {
+				cleanup();
+				return value;
+			},
+			(error) => {
+				cleanup();
+				throw error;
+			},
+		);
+		inFlight.set(dedupeKey, tracked);
+		try {
+			nodeInputToPromise(factory(key), opts).then(resolvePending, rejectPending);
+		} catch (e) {
+			rejectPending(e);
+		}
+		return tracked;
+	};
+}
diff --git a/packages/ts/src/graph/time.ts b/packages/ts/src/graph/time.ts
new file mode 100644
index 00000000..1f69f36e
--- /dev/null
+++ b/packages/ts/src/graph/time.ts
@@ -0,0 +1,366 @@
+/**
+ * Wall-clock time operators (CSP-2.7 / D52 / B23). Authored as COMPOSITIONS over the already-active
+ * higher-order *Map machinery (D47) + the `timer` source — NO raw `setTimeout` in any operator body
+ * (R-no-raw-async / check-no-raw-async; `setTimeout` stays confined to `sources.ts`'s `timer`). The
+ * timer source's `onDeactivation` clearTimeout IS the reset/cancel: switchMap's unsubscribeDep on a new
+ * source value tears the in-flight timer down (the declarative equivalent of the frozen reference's
+ * imperative clearTimeout-then-setTimeout). Per-language (D6/D24), never in parity.
+ *
+ * Shipped this cut (clean *Map+timer):
+ *   - delay        = mergeMap(v → timer(ms)→v)   (every value delayed ms, ALL kept, order preserved)
+ *   - debounce(Time) = switchMap(v → timer(ms)→v) (cancel-and-restart; emit the latest after quiet ms)
+ *   - throttle(Time) = exhaustMap(v → [v now, alive ms]) (leading edge: emit v, ignore for ms)
+ *
+ * Behavior on source COMPLETE (per-operator, NOT a uniform DROP): debounce/debounceTime EMIT their
+ * pending trailing value — switchMap does not cancel the in-flight inner on source COMPLETE (only a
+ * superseding source value cancels it via unsubscribeDep→onDeactivation→clearTimeout), so the timer still
+ * fires at `ms`, emits the debounced value, and only THEN does the operator COMPLETE (RxJS
+ * debounceTime parity). delay emits every still-pending delayed value then COMPLETEs (mergeMap keeps
+ * all inners). throttle/throttleTime have NO trailing value (leading-edge only, RxJS default
+ * trailing:false) — an open window inner is dropped when the operator completes.
+ *
+ * B41 tail (landed 2026-05-31, the two shapes reflect WHEN the clock arms):
+ *   - audit / auditTime — VALUE-TRIGGERED trailing edge: a source value opens a duration window
+ *                        (`audit(durationSelector)` = the general/notifier form, mirroring the *Map
+ *                        `Project` idiom + D46; `auditTime(ms)` = `audit(() => timer(ms))`), emits the
+ *                        window's LATEST value at the window's close. Self-wires the notifier via
+ *                        ctx.rewireNext — a normal `g.initNode(audit(sel), [source])` operator.
+ *   - timeout / bufferTime — SUBSCRIBE-ARMED (RxJS-cold): the clock must run from activation, before
+ *                        any source value, so the timer/interval is a CONSTRUCTION-time dep (a depless
+ *                        source arms lazily on subscribe per node `_activate`). A dep-bearing operator
+ *                        body never runs at activation (only depless nodes do, node.ts), so these ship
+ *                        as graph composition HELPERS `timeout(source, ms)` / `bufferTime(source, ms)`
+ *                        returning a Node — NOT `g.initNode(op, [deps])` operators. timeout resets its
+ *                        idle timer per source value via ctx.rewireNext (ERROR on the gap); bufferTime
+ *                        is buffer-over-interval with terminal cleanup via ctx.rewireNext.
+ *
+ * NOT ported (D58): window/windowCount/windowTime — the Node<Node<T>> higher-order forms are a D45
+ *   describe island; the array forms (buffer/bufferCount/bufferTime) are the graph-first equivalent.
+ *
+ * Inspection caveat (timeout/bufferTime): the helper returns a BARE node (free initNode) self-carrying
+ * its factory for describe auto-discovery (D51), but it is NOT in a graph's _entries — so g.describe()
+ * lists it only when it is a live dep of a registered node (a first-cut limit, like the *Map inners).
+ */
+
+import {
+	type Ctx,
+	depBatch,
+	depTerminal,
+	isTerminalComplete,
+	isTerminalError,
+	type NodeFn,
+	terminalErrorValue,
+} from "../ctx/types.js";
+import type { Node } from "../node/node.js";
+import { errorPayload } from "../protocol/messages.js";
+import { exhaustMap, mergeMap, switchMap } from "./higher-order.js";
+import { filter, initNode, map, merge, type Operator } from "./operators.js";
+import { fromAny, interval, type NodeInput, of, timer } from "./sources.js";
+
+/** A bare inner that emits `v` once after `ms`, then COMPLETEs (timer(ms)→map(v); auto-completes). */
+function delayedValue<S>(v: S, ms: number): Node<S> {
+	return initNode(
+		map(() => v),
+		[initNode(timer(ms), [])],
+	);
+}
+
+/**
+ * An inner that emits `v` IMMEDIATELY (on activation) and stays alive for `ms` (then COMPLETEs),
+ * emitting nothing more — the leading-edge throttle window. `merge(of(v), silentTimer)`: `of(v)`
+ * emits v + COMPLETE at t=0; `filter(()=>false)` over `timer(ms)` emits no DATA and COMPLETEs at
+ * t=ms; merge forwards v at t=0 and COMPLETEs (all deps complete) at t=ms.
+ */
+function throttleWindow<S>(v: S, ms: number): Node<S> {
+	const silentTimer = initNode(
+		filter<number>(() => false),
+		[initNode(timer(ms), [])],
+	) as Node<S>;
+	return initNode(merge<S>(), [initNode(of(v), []), silentTimer]);
+}
+
+/**
+ * delay: shift every value by `ms`, preserving all values + order. `mergeMap` keeps every inner
+ * timer live (equal `ms`, so they fire in arrival order).
+ */
+export function delay<S>(ms: number): Operator<S, S> {
+	return { ...mergeMap<S, S>((v) => delayedValue(v, ms)), factory: "delay" };
+}
+
+/**
+ * debounce (alias `debounceTime`): emit the latest value only after `ms` of quiet. `switchMap`
+ * cancels the prior timer (its onDeactivation clearTimeout) on each new source value and restarts —
+ * the declarative debounce.
+ *
+ * RxJS-7 divergence (reference rxjs@7.8, B44): RxJS `debounceTime` FLUSHES the pending value
+ * IMMEDIATELY when the source COMPLETEs (its `_complete` calls `debouncedNext()` before
+ * `complete()`). This composition instead emits the pending value when the in-flight `timer(ms)`
+ * fires — i.e. at `(last-value-time + ms)` — so if the source completes mid-window the trailing
+ * value arrives up to `ms` later than RxJS. Inherent to the `*Map`+`timer` form (the composition
+ * cannot flush early without detecting COMPLETE inside the switchMap inner); accepted, not a bug.
+ */
+export function debounce<S>(ms: number): Operator<S, S> {
+	return { ...switchMap<S, S>((v) => delayedValue(v, ms)), factory: "debounce" };
+}
+
+/** debounceTime: RxJS-named alias of {@link debounce}. */
+export function debounceTime<S>(ms: number): Operator<S, S> {
+	return { ...switchMap<S, S>((v) => delayedValue(v, ms)), factory: "debounceTime" };
+}
+
+/**
+ * throttle (alias `throttleTime`): leading-edge — emit a value immediately, then ignore the source
+ * for `ms`. `exhaustMap` drops new source values while the current window inner is alive; the
+ * window emits v at its leading edge and stays alive `ms`.
+ *
+ * Matches the RxJS-7 `throttleTime` DEFAULT (leading:true, trailing:false). The leading/trailing
+ * OPTIONS RxJS exposes are NOT provided (a capability gap, not a behavior divergence; B44) — add a
+ * trailing-window form if a consumer needs it.
+ */
+export function throttle<S>(ms: number): Operator<S, S> {
+	return { ...exhaustMap<S, S>((v) => throttleWindow(v, ms)), factory: "throttle" };
+}
+
+/** throttleTime: RxJS-named alias of {@link throttle}. */
+export function throttleTime<S>(ms: number): Operator<S, S> {
+	return { ...exhaustMap<S, S>((v) => throttleWindow(v, ms)), factory: "throttleTime" };
+}
+
+// ── B41 tail: value-triggered (audit) + subscribe-armed (timeout/bufferTime) ──
+
+/** Per-node bookkeeping for {@link audit}: the open window's notifier + the latest value seen. */
+interface AuditState<S> {
+	windowOpen: boolean;
+	latest: { v: S } | undefined;
+	notifier: Node<unknown> | null;
+}
+
+/**
+ * audit: VALUE-TRIGGERED trailing throttle. A source value (when no window is open) opens a duration
+ * window via `durationSelector(value)` → a notifier `NodeInput` wired as dep 1 with `ctx.rewireNext`
+ * (D47 — the *Map self-rewire idiom, NOT an internal subscribe, D45); during the window new source
+ * values only UPDATE the tracked latest (no emit); when the notifier fires (its first DATA / COMPLETE)
+ * the window closes and the LATEST value is emitted. This is throttle's trailing-edge twin
+ * (throttle emits the window's FIRST value at the leading edge; audit emits the LAST at the close).
+ *
+ * `durationSelector` is the general/notifier form (mirrors the *Map `Project` idiom + D46); the source
+ * is dep 0, the live notifier (if any) is dep 1. On source COMPLETE the pending latest is FLUSHED then
+ * COMPLETE (RxJS-7 audit flush-on-complete, B44). A source/notifier ERROR is read as a real terminal
+ * input so the live notifier can be removed before ERROR. Self-catching (D30); re-supplies its body on
+ * every rewire.
+ */
+export function audit<S>(durationSelector: (v: S) => NodeInput<unknown>): Operator<S, S> {
+	const body: NodeFn = (ctx: Ctx) => {
+		try {
+			const st: AuditState<S> = ctx.state.get<AuditState<S>>() ?? {
+				windowOpen: false,
+				latest: undefined,
+				notifier: null,
+			};
+			const sourceBatch = depBatch(ctx, 0);
+			const notifierBatch = depBatch(ctx, 1); // live duration notifier while a window is open
+			const sourceTerminal = depTerminal(ctx, 0);
+			const notifierTerminal = depTerminal(ctx, 1);
+
+			// every source value updates the window's latest (the value emitted at the window's close).
+			const sb = sourceBatch as readonly S[] | null;
+			if (sb) for (const v of sb) st.latest = { v };
+
+			// the window closes when its duration notifier fires (DATA or COMPLETE) → emit the latest.
+			const notifierFired =
+				st.windowOpen &&
+				((notifierBatch != null && notifierBatch.length > 0) ||
+					isTerminalComplete(notifierTerminal));
+			if (notifierFired) {
+				if (st.latest !== undefined) ctx.down([["DATA", st.latest.v]]);
+				const old = st.notifier;
+				st.windowOpen = false;
+				st.notifier = null;
+				st.latest = undefined;
+				if (old) ctx.rewireNext.unsubscribeDep(old, body);
+			}
+
+			// source/notifier ERROR → forward ERROR, but first remove the helper-owned notifier.
+			const sourceError = isTerminalError(sourceTerminal);
+			const notifierError = isTerminalError(notifierTerminal);
+			if (sourceError || notifierError) {
+				const err = terminalErrorValue(sourceError ? sourceTerminal : notifierTerminal);
+				if (st.notifier) ctx.rewireNext.unsubscribeDep(st.notifier, body);
+				ctx.state.set({ windowOpen: false, latest: undefined, notifier: null });
+				ctx.down([["ERROR", err]]);
+				return;
+			}
+
+			// source COMPLETE → flush the pending latest (B44 audit flush-on-complete) then COMPLETE.
+			if (isTerminalComplete(sourceTerminal)) {
+				if (st.windowOpen && st.latest !== undefined) ctx.down([["DATA", st.latest.v]]);
+				if (st.notifier) ctx.rewireNext.unsubscribeDep(st.notifier, body);
+				ctx.state.set({ windowOpen: false, latest: undefined, notifier: null });
+				ctx.down([["COMPLETE"]]);
+				return;
+			}
+
+			// a fresh source value with no open window → open one (value-triggered, trailing edge).
+			if (!st.windowOpen && sb != null && sb.length > 0 && st.latest !== undefined) {
+				const n = fromAny<unknown>(durationSelector(st.latest.v), { iter: true });
+				st.windowOpen = true;
+				st.notifier = n;
+				ctx.rewireNext.subscribeDep(n, body); // (a same-wave close+reopen issues remove-before-add)
+			}
+
+			ctx.state.set(st);
+		} catch (e) {
+			ctx.down([["ERROR", errorPayload(e, "audit threw without a valid error payload")]]);
+		}
+	};
+	return {
+		factory: "audit",
+		body,
+		opts: {
+			partial: true,
+			completeWhenDepsComplete: false,
+			errorWhenDepsError: false,
+			terminalAsRealInput: true,
+		},
+	};
+}
+
+/** auditTime: the `ms`-specialization of {@link audit} — the window is a `timer(ms)`. */
+export function auditTime<S>(ms: number): Operator<S, S> {
+	return { ...audit<S>(() => initNode(timer(ms), [])), factory: "auditTime" };
+}
+
+/** Per-node bookkeeping for {@link timeout}: the live idle timer (reset on each source value). */
+interface TimeoutState {
+	timer: Node<unknown> | null;
+}
+
+/**
+ * timeout: idle watchdog — forward every source value, but ERROR if more than `ms` elapses with no
+ * value (RxJS `timeout(ms)`, `first === each === ms`). SUBSCRIBE-ARMED: the first `timer(ms)` is a
+ * CONSTRUCTION-time dep, so it arms when `timeout`'s node is subscribed/activated (a depless source
+ * runs lazily on `_activate`) — i.e. a source that never emits its FIRST value within `ms` still
+ * errors. A dep-bearing operator body never runs at activation (only depless nodes do, node.ts), which
+ * is why this is a HELPER returning a Node, not a `g.initNode(op, [source])` operator.
+ *
+ * Each source value forwards as-is and RESETS the idle timer (unsubscribeDep the current `timer(ms)`,
+ * subscribeDep a fresh one — its `onDeactivation` clearTimeout cancels the prior countdown). The timer
+ * firing (its DATA/COMPLETE) is the timeout → `[[ERROR]]`. Source COMPLETE forwards COMPLETE (no
+ * error) and removes the idle timer during the terminal wave (D62 terminal-drains-queued-rewire);
+ * a source ERROR forwards likewise. The idle timer is also torn down when the consumer unsubscribes
+ * (timeout deactivates → dep unsub → timer onDeactivation). Self-catching (D30).
+ */
+export function timeout<S>(source: Node<S>, ms: number): Node<S> {
+	const makeTimer = (): Node<unknown> => initNode(timer(ms), []);
+	const initial = makeTimer();
+	const body: NodeFn = (ctx: Ctx) => {
+		try {
+			const st: TimeoutState = ctx.state.get<TimeoutState>() ?? { timer: initial };
+			const srcBatch = depBatch(ctx, 0);
+			const srcTerminal = depTerminal(ctx, 0);
+
+			// a source value forwards as-is and resets the idle window.
+			const sb = srcBatch as readonly S[] | null;
+			if (sb != null && sb.length > 0) {
+				for (const v of sb) ctx.down([["DATA", v]]);
+				const old = st.timer;
+				const next = makeTimer();
+				st.timer = next;
+				ctx.state.set(st);
+				if (old) ctx.rewireNext.unsubscribeDep(old, body); // remove-before-add (alignment)
+				ctx.rewireNext.subscribeDep(next, body);
+				return; // a value-bearing wave is never also a timeout-fire wave
+			}
+
+			// source COMPLETE → forward COMPLETE (no timeout fires).
+			if (isTerminalComplete(srcTerminal)) {
+				if (st.timer) ctx.rewireNext.unsubscribeDep(st.timer, body);
+				ctx.down([["COMPLETE"]]);
+				return;
+			}
+			// source ERROR (absorbed via errorWhenDepsError:false) → forward it.
+			if (isTerminalError(srcTerminal)) {
+				if (st.timer) ctx.rewireNext.unsubscribeDep(st.timer, body);
+				ctx.down([["ERROR", terminalErrorValue(srcTerminal)]]);
+				return;
+			}
+
+			// otherwise this wave is the idle timer firing → timeout ERROR.
+			const timerBatch = depBatch(ctx, 1);
+			if (
+				(timerBatch != null && timerBatch.length > 0) ||
+				isTerminalComplete(depTerminal(ctx, 1))
+			) {
+				ctx.down([["ERROR", new Error(`timeout: no value within ${ms}ms`)]]);
+				return;
+			}
+			ctx.state.set(st);
+		} catch (e) {
+			ctx.down([["ERROR", errorPayload(e, "timeout threw without a valid error payload")]]);
+		}
+	};
+	return initNode<S, S>(
+		{
+			factory: "timeout",
+			body,
+			opts: {
+				partial: true,
+				completeWhenDepsComplete: false,
+				errorWhenDepsError: false,
+				terminalAsRealInput: true,
+			},
+		},
+		[source as Node<unknown>, initial],
+	);
+}
+
+/**
+ * bufferTime: buffer source values and flush them as an array every `ms` (RxJS `bufferTime(ms)`).
+ * SUBSCRIBE-ARMED: the `interval(ms)` notifier is a CONSTRUCTION-time dep (arms on subscribe), so an
+ * empty window flushes `[]` even before the first source value — matching the landed {@link buffer}
+ * (which flushes on every notifier signal). On source COMPLETE the remainder flushes then COMPLETE
+ * (B44), and D62 lets the terminal wave still drain `unsubscribeDep(interval)` so the helper-owned
+ * interval source deactivates instead of ticking forever.
+ */
+export function bufferTime<S>(source: Node<S>, ms: number): Node<S[]> {
+	const iv: Node<unknown> = initNode(interval(ms), []);
+	const body: NodeFn = (ctx: Ctx) => {
+		const srcBatch = depBatch(ctx, 0);
+		const tickBatch = depBatch(ctx, 1);
+		const srcTerminal = depTerminal(ctx, 0);
+		const buf = ctx.state.get<S[]>() ?? [];
+		if (srcBatch) for (const v of srcBatch) buf.push(v as S);
+		if (isTerminalComplete(srcTerminal)) {
+			if (buf.length > 0) ctx.down([["DATA", [...buf]]]);
+			ctx.state.set([]);
+			ctx.rewireNext.unsubscribeDep(iv, body);
+			ctx.down([["COMPLETE"]]);
+			return;
+		}
+		if (isTerminalError(srcTerminal)) {
+			ctx.state.set([]);
+			ctx.rewireNext.unsubscribeDep(iv, body);
+			ctx.down([["ERROR", terminalErrorValue(srcTerminal)]]);
+			return;
+		}
+		if (tickBatch && tickBatch.length > 0) {
+			ctx.down([["DATA", [...buf]]]);
+			ctx.state.set([]);
+			return;
+		}
+		ctx.state.set(buf);
+	};
+	return initNode<unknown, S[]>(
+		{
+			factory: "bufferTime",
+			body,
+			opts: {
+				partial: true,
+				completeWhenDepsComplete: false,
+				errorWhenDepsError: false,
+				terminalAsRealInput: true,
+			},
+		},
+		[source as Node<unknown>, iv],
+	);
+}
diff --git a/packages/ts/src/graph/worker.ts b/packages/ts/src/graph/worker.ts
new file mode 100644
index 00000000..25c64080
--- /dev/null
+++ b/packages/ts/src/graph/worker.ts
@@ -0,0 +1,190 @@
+/**
+ * Helper-first worker compute (D138/D148).
+ *
+ * `prepare` runs on the graph thread and returns an owned input. The required
+ * backend receives only that input plus the static compute closure; Ctx/Node/
+ * graph state/live topology never cross the boundary.
+ */
+
+import type { Ctx, NodeFn } from "../ctx/types.js";
+import type { Graph } from "../graph/graph.js";
+import type { Node } from "../node/node.js";
+import { errorPayload } from "../protocol/messages.js";
+
+export interface WorkerDerivedJob<TInput, TResult> {
+	readonly input: TInput;
+	readonly compute: (input: TInput) => TResult;
+}
+
+export type WorkerDerivedSettlement<TResult> =
+	| { readonly ok: true; readonly value: TResult }
+	| { readonly ok: false; readonly error: unknown };
+
+export type WorkerDerivedSettle<TResult> = (settlement: WorkerDerivedSettlement<TResult>) => void;
+
+export type WorkerDerivedCancel = () => void;
+
+export interface WorkerDerivedBackend<TInput, TResult> {
+	run(
+		job: WorkerDerivedJob<TInput, TResult>,
+		settle: WorkerDerivedSettle<TResult>,
+	): WorkerDerivedCancel | undefined;
+}
+
+export interface WorkerDerivedOptions<TInput, TResult> {
+	readonly name?: string;
+	prepare(ctx: Ctx): TInput | undefined;
+	compute(input: TInput): TResult;
+	backend: WorkerDerivedBackend<TInput, TResult>;
+}
+
+/**
+ * D148 backend-required graph helper. No public submit API is exposed; the
+ * backend starts work only after this helper installs the graph-local fence.
+ */
+export function workerDerived<TInput, TResult>(
+	graph: Graph,
+	deps: readonly Node<unknown>[],
+	opts: WorkerDerivedOptions<TInput, TResult>,
+): Node<TResult> {
+	if (typeof opts.prepare !== "function") {
+		throw new TypeError("workerDerived: prepare must be a function");
+	}
+	if (typeof opts.compute !== "function") {
+		throw new TypeError("workerDerived: compute must be a function");
+	}
+	if (opts.backend === undefined || typeof opts.backend.run !== "function") {
+		throw new TypeError("workerDerived: backend is required");
+	}
+	let latestInvocation = 0;
+	let cancelActive: (() => void) | undefined;
+	const fn: NodeFn = (ctx) => {
+		cancelActive?.();
+		cancelActive = undefined;
+		latestInvocation += 1;
+		const invocation = latestInvocation;
+		let input: TInput | undefined;
+		try {
+			input = opts.prepare(ctx);
+		} catch (error) {
+			ctx.down([["ERROR", errorPayload(error, "workerDerived prepare failed")]]);
+			return;
+		}
+		if (input === undefined) {
+			ctx.down([["RESOLVED"]]);
+			return;
+		}
+		const ownedInput = cloneWorkerInput(input);
+		if (!ownedInput.ok) {
+			ctx.down([["ERROR", errorPayload(new Error(ownedInput.message), ownedInput.message)]]);
+			return;
+		}
+		let live = true;
+		let cancel: WorkerDerivedCancel | undefined;
+		let canceled = false;
+		let submitting = true;
+		let settled = false;
+		let synchronousSettlementError: Error | undefined;
+		const cancelThis = (): void => {
+			if (canceled) return;
+			canceled = true;
+			live = false;
+			cancel?.();
+			cancel = undefined;
+		};
+		cancelActive = cancelThis;
+		ctx.onDeactivation(() => {
+			cancelThis();
+			if (cancelActive === cancelThis) cancelActive = undefined;
+		});
+		const assertNotSynchronousCompletion = (): void => {
+			if (submitting) {
+				synchronousSettlementError = new Error(
+					"workerDerived: backend completions must arrive after backend.run returns",
+				);
+				throw synchronousSettlementError;
+			}
+		};
+		const clearAcceptedSettlement = (): void => {
+			cancelActive = undefined;
+			cancel = undefined;
+			live = false;
+		};
+		const settle: WorkerDerivedSettle<TResult> = (settlement) => {
+			if (settled) return;
+			settled = true;
+			assertNotSynchronousCompletion();
+			if (!live || invocation !== latestInvocation) return;
+			clearAcceptedSettlement();
+			if (settlement.ok) {
+				ctx.down([["DATA", settlement.value]]);
+			} else {
+				ctx.down([["ERROR", errorPayload(settlement.error, "workerDerived compute failed")]]);
+			}
+		};
+		let thrown = false;
+		let thrownError: unknown;
+		try {
+			cancel =
+				opts.backend.run(
+					{
+						input: ownedInput.value,
+						compute: opts.compute,
+					},
+					settle,
+				) ?? undefined;
+		} catch (error) {
+			thrown = true;
+			thrownError = error;
+		} finally {
+			submitting = false;
+		}
+		if (synchronousSettlementError !== undefined) {
+			if (live && invocation === latestInvocation) {
+				ctx.down([
+					["ERROR", errorPayload(synchronousSettlementError, "workerDerived compute failed")],
+				]);
+			}
+			cancelThis();
+			if (cancelActive === cancelThis) cancelActive = undefined;
+			return;
+		}
+		if (thrown) {
+			if (live && invocation === latestInvocation) {
+				ctx.down([["ERROR", errorPayload(thrownError, "workerDerived compute failed")]]);
+			}
+			cancelThis();
+			if (cancelActive === cancelThis) cancelActive = undefined;
+		}
+	};
+	return graph.node<TResult>(deps, fn, {
+		name: opts.name ?? "workerDerived",
+		factory: "workerDerived",
+		pool: "async",
+		completeWhenDepsComplete: false,
+		errorWhenDepsError: false,
+	});
+}
+
+type CloneWorkerInputResult<TInput> =
+	| { readonly ok: true; readonly value: TInput }
+	| { readonly ok: false; readonly message: string };
+
+function cloneWorkerInput<TInput>(input: TInput): CloneWorkerInputResult<TInput> {
+	if (typeof input === "function" || typeof input === "symbol") {
+		return { ok: false, message: "workerDerived: input must be owned and cloneable" };
+	}
+	if (typeof input !== "object" || input === null) return { ok: true, value: input };
+	if (typeof globalThis.structuredClone !== "function") {
+		return { ok: false, message: "workerDerived: structuredClone is required for object inputs" };
+	}
+	try {
+		return { ok: true, value: globalThis.structuredClone(input) as TInput };
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		return {
+			ok: false,
+			message: `workerDerived: input must be owned and cloneable (${message})`,
+		};
+	}
+}
diff --git a/packages/ts/src/index.ts b/packages/ts/src/index.ts
new file mode 100644
index 00000000..e5275104
--- /dev/null
+++ b/packages/ts/src/index.ts
@@ -0,0 +1,671 @@
+/**
+ * @graphrefly/ts — clean-slate TypeScript package.
+ *
+ * Canonical authority: ~/src/graphrefly/spec/rules.jsonl + decisions.jsonl.
+ * CSP-1 substrate: node / dispatcher / pool / wave protocol.
+ * CSP-2 graph layer: Graph + 8-verb sugar + describe/observe/profile inspection.
+ */
+
+export {
+	AGENTIC_MEMORY_RECORD_CHANGE_FORMAT,
+	AGENTIC_MEMORY_RECORD_SNAPSHOT_FORMAT,
+	AGENTIC_MEMORY_RECORD_STORAGE_FRAME_VERSION,
+	type AgenticMemoryRecordChangeFrame,
+	type AgenticMemoryRecordSnapshotFrame,
+	type AgenticMemoryRecordsPersistenceCursor,
+	type AgenticMemoryRecordsPersistenceError,
+	type AgenticMemoryRecordsPersistenceHandle,
+	type AgenticMemoryRecordsPersistenceStatus,
+	type AgenticMemoryRecordsRestoreState,
+	agenticMemoryRecordChangeFrame,
+	agenticMemoryRecordSnapshotFrame,
+	agenticMemoryRecordsSnapshotKey,
+	assertAgenticMemoryRecordChangeFrame,
+	assertAgenticMemoryRecordSnapshotFrame,
+	type LoadAgenticMemoryRecordsStateOptions,
+	loadAgenticMemoryRecordsState,
+	type OpenPersistentAgenticMemoryRecordsOptions,
+	openPersistentAgenticMemoryRecords,
+	type PersistAgenticMemoryRecordsOptions,
+	type PersistentAgenticMemoryRecords,
+	persistAgenticMemoryRecords,
+} from "./adapters/agentic-memory-storage.js";
+export {
+	type OpenPersistentReactiveIndexOptions,
+	type OpenPersistentReactiveListOptions,
+	type OpenPersistentReactiveLogOptions,
+	type OpenPersistentReactiveMapOptions,
+	openPersistentReactiveIndex,
+	openPersistentReactiveList,
+	openPersistentReactiveLog,
+	openPersistentReactiveMap,
+	type PersistentReactiveIndex,
+	type PersistentReactiveList,
+	type PersistentReactiveLog,
+	type PersistentReactiveMap,
+	type PersistReactiveCollectionOptions,
+	persistReactiveCollection,
+	type ReactiveCollectionPersistenceCursor,
+	type ReactiveCollectionPersistenceError,
+	type ReactiveCollectionPersistenceHandle,
+	type ReactiveCollectionPersistenceStatus,
+} from "./adapters/reactive-collection-storage.js";
+export { type BatchCtx, batch } from "./batch/batch.js";
+export type {
+	Ctx,
+	CtxState,
+	NodeFn,
+	RewireNext,
+	Sink,
+	TerminalData,
+	WaveData,
+} from "./ctx/types.js";
+export {
+	depBatch,
+	depCount,
+	depLatest,
+	depTerminal,
+	depWaves,
+	isTerminalComplete,
+	isTerminalError,
+	isTerminalNone,
+	terminalErrorValue,
+} from "./ctx/types.js";
+export type { DataError, DataIssue, DataOk, DataResult } from "./data/index.js";
+export {
+	restoreReactiveIndex,
+	restoreReactiveList,
+	restoreReactiveLog,
+	restoreReactiveMap,
+} from "./data-structures/persistence.js";
+export {
+	Dispatcher,
+	defaultDispatcher,
+	type Handle,
+	type HandleStat,
+	type Pool,
+	type PoolKind,
+} from "./dispatcher/index.js";
+export {
+	canonicalTopologyBytes,
+	canonicalTopologyJson,
+	GRAPH_BLUEPRINT_VERSION,
+	type GraphBlueprint,
+	type GraphBlueprintDiagnosticCode,
+	type GraphBlueprintDiagnosticIssue,
+	type GraphBlueprintDiagnostics,
+	type GraphBlueprintHash,
+	type GraphBlueprintHashInput,
+	type GraphBlueprintHashOptions,
+	type GraphBlueprintJson,
+	type GraphBlueprintOptions,
+	type GraphBlueprintProvenance,
+	graphBlueprintDiagnostics,
+	type NormalizedGraphTopologyNode,
+	type NormalizedGraphTopologySnapshot,
+	normalizeTopology,
+	withBlueprintHash,
+	withBlueprintProvenance,
+} from "./graph/blueprint.js";
+export {
+	type CascadingCacheEvent,
+	type CascadingCachePolicy,
+	type CascadingCacheStatus,
+	type ReactiveCascadingCache,
+	type ReactiveCascadingCacheOptions,
+	reactiveCascadingCache,
+} from "./graph/cascading-cache.js";
+export {
+	GRAPH_CHECKPOINT_VERSION,
+	type GraphCheckpoint,
+	type GraphCheckpointEdge,
+	type GraphCheckpointFactory,
+	type GraphCheckpointJson,
+	type GraphCheckpointMount,
+	type GraphCheckpointNode,
+	type GraphCheckpointTerminal,
+	type GraphCheckpointValue,
+	type GraphCheckpointVersion,
+} from "./graph/checkpoint.js";
+export {
+	buffer,
+	bufferCount,
+	combine,
+	combineLatest,
+	concat,
+	race,
+	sample,
+	takeUntil,
+	withLatestFrom,
+	zip,
+} from "./graph/combinators.js";
+export {
+	type DescribeChangeset,
+	type DescribeEvent,
+	type PipeOperator,
+	pipe,
+	type Stratified,
+	type StratifyOptions,
+	type StratifyRule,
+	stratify,
+	stratifyBranch,
+	topologyDiff,
+} from "./graph/composition.js";
+export type {
+	IndexChange,
+	ListChange,
+	LogChange,
+	MapChange,
+} from "./graph/data-structures/change.js";
+export type { ReactiveView } from "./graph/data-structures/core.js";
+export {
+	type IndexRow,
+	type ReactiveIndex,
+	type ReactiveIndexCapacityOrder,
+	type ReactiveIndexCapacityPolicy,
+	type ReactiveIndexOpt,
+	type ReactiveIndexOptions,
+	reactiveIndex,
+} from "./graph/data-structures/reactive-index.js";
+export {
+	type ReactiveList,
+	type ReactiveListOpt,
+	type ReactiveListOptions,
+	reactiveList,
+} from "./graph/data-structures/reactive-list.js";
+export {
+	mergeReactiveLogs,
+	type ReactiveLog,
+	type ReactiveLogOptions,
+	reactiveLog,
+	scanLog,
+} from "./graph/data-structures/reactive-log.js";
+export {
+	type ReactiveMap,
+	type ReactiveMapOpt,
+	type ReactiveMapOptions,
+	type ReactiveMapRetentionEntry,
+	type ReactiveMapRetentionPolicy,
+	reactiveMap,
+} from "./graph/data-structures/reactive-map.js";
+export type {
+	DescribeEdge,
+	DescribeNode,
+	DescribeOpts,
+	DescribeSnapshot,
+	GraphTopologyEdge,
+	GraphTopologyNode,
+	GraphTopologySnapshot,
+} from "./graph/describe.js";
+export {
+	type CausalChain,
+	type CausalStep,
+	type ExplainPathOptions,
+	type ExplainPathReason,
+	explainPath,
+	type IslandReport,
+	type ReachableDirection,
+	type ReachableOptions,
+	type ReachableResult,
+	reachable,
+	type ValidateNoIslandsResult,
+	validateNoIslands,
+} from "./graph/diagnostics.js";
+export {
+	type DriverCancel,
+	type DriverResult,
+	domWebSocketDriver,
+	EnvironmentDrivers,
+	type EnvironmentDriversInit,
+	type FetchLike,
+	type FetchResponseLike,
+	fetchHttpDriver,
+	type HttpRequest,
+	type HttpResponse,
+	type LocalHttpDriver,
+	type LocalProcessDriver,
+	type LocalSseDriver,
+	type LocalWebhookDriver,
+	type LocalWebSocketDriver,
+	type ProcessCommand,
+	type ProcessResult,
+	type SseDriverEvent,
+	type SseEvent,
+	type SseRequest,
+	type WebhookDriverEvent,
+	type WebhookEvent,
+	type WebhookRegistration,
+	type WebSocketConstructorLike,
+	type WebSocketDriverEvent,
+	type WebSocketEvent,
+	type WebSocketLike,
+	type WebSocketRequest,
+	type WebSocketSend,
+	type WebSocketSendResult,
+	type WebSocketSessionHandle,
+} from "./graph/environment.js";
+export {
+	type DerivedFn,
+	type EffectFn,
+	Graph,
+	type GraphOptions,
+	graph,
+	StateNode,
+	type SugarOpts,
+	type TopologyGroup,
+	type TopologyGroupOptions,
+	type TopologyGroupReleaseOptions,
+} from "./graph/graph.js";
+export {
+	concatMap,
+	exhaustMap,
+	flatMap,
+	type MergeMapOptions,
+	mergeMap,
+	type Project,
+	repeat,
+	switchMap,
+} from "./graph/higher-order.js";
+export {
+	coalesceObserve,
+	filterObserve,
+	type NodeProfile,
+	type ObserveEvent,
+	type ObserveEventEquals,
+	type ObservePredicate,
+	type ObserveStream,
+	type Profile,
+	type TopologyEvent,
+	type TopologyEventKind,
+	type TopologyStream,
+} from "./graph/inspect.js";
+export {
+	catchError,
+	type DefineOpts,
+	type Definition,
+	define,
+	distinctUntilChanged,
+	elementAt,
+	filter,
+	find,
+	first,
+	initNode,
+	last,
+	map,
+	merge,
+	type Operator,
+	onFirstData,
+	pairwise,
+	type RestoreRegistryEntry,
+	reduce,
+	rescue,
+	restoreRegistry,
+	type SettleOpts,
+	scan,
+	settle,
+	skip,
+	type TapObserver,
+	take,
+	takeWhile,
+	tap,
+	tapFirst,
+	type ValveOpts,
+	valve,
+} from "./graph/operators.js";
+export type {
+	CapacityPolicy,
+	OrderedCapacityPolicy,
+	ReactiveOpt,
+	RetentionPolicy,
+	ViewCachePolicy,
+} from "./graph/policies/types.js";
+export {
+	type DescribeToAsciiOptions,
+	type DescribeToD2Options,
+	type DescribeToJsonOptions,
+	type DescribeToMermaidOptions,
+	type DescribeToMermaidUrlOptions,
+	type DescribeToPrettyOptions,
+	type DiagramDirection,
+	describeToAscii,
+	describeToD2,
+	describeToJson,
+	describeToMermaid,
+	describeToMermaidUrl,
+	describeToPretty,
+	type MermaidLiveTheme,
+	type MermaidLiveUrlOptions,
+	mermaidLiveUrl,
+} from "./graph/render.js";
+export {
+	type BackoffPolicy,
+	backoffDelayMs,
+	nextRetryDelayMs,
+	noBackoff,
+	type RetryPolicy,
+	type RetryState,
+	type RetryStatus,
+	retryPolicy,
+	shouldRetry,
+} from "./graph/resilience.js";
+export {
+	defaultRestoreRegistry,
+	type GraphRestoreDefinition,
+	type GraphRestoreDescriptor,
+	type GraphRestoreDescriptorContext,
+	type GraphRestoreEntry,
+	type GraphRestoreRegistry,
+	mapRestoreDescriptor,
+	type RestoreGraphOptions,
+	restoreGraph,
+	stateRestoreDescriptor,
+	takeRestoreDescriptor,
+	timerRestoreDescriptor,
+} from "./graph/restore.js";
+export {
+	type AsyncSourceOpts,
+	type CronSchedule,
+	type EventListenerOptionsLike,
+	type EventTargetLike,
+	empty,
+	type FromCronOptions,
+	type FromEventOptions,
+	firstValueFrom,
+	fromAny,
+	fromAsyncIter,
+	fromCron,
+	fromEvent,
+	fromHttp,
+	fromHttpWithOptions,
+	fromIter,
+	fromProcess,
+	fromPromise,
+	fromPushNotification,
+	fromSSE,
+	fromSSEWithOptions,
+	fromTimer,
+	fromWebhook,
+	fromWebhookWithOptions,
+	fromWebSocket,
+	fromWebSocketWithOptions,
+	interval,
+	matchesCron,
+	type NodeInput,
+	never,
+	of,
+	type PushRegister,
+	type PushUnsubscribe,
+	parseCron,
+	runProcess,
+	runProcessWithOptions,
+	type SingleFromAnyOptions,
+	singleFromAny,
+	type TimerSourceOpts,
+	throwError,
+	timer,
+} from "./graph/sources.js";
+export {
+	audit,
+	auditTime,
+	bufferTime,
+	debounce,
+	debounceTime,
+	delay,
+	throttle,
+	throttleTime,
+	timeout,
+} from "./graph/time.js";
+export {
+	type WorkerDerivedBackend,
+	type WorkerDerivedCancel,
+	type WorkerDerivedJob,
+	type WorkerDerivedOptions,
+	type WorkerDerivedSettle,
+	type WorkerDerivedSettlement,
+	workerDerived,
+} from "./graph/worker.js";
+export {
+	assertStrictJsonObject,
+	assertStrictJsonValue,
+	type StrictJsonObject,
+	type StrictJsonScalar,
+	type StrictJsonValue,
+	strictCanonicalJsonBytes,
+} from "./json/codec.js";
+export { dynamicNode, Node, type NodeOptions, node, type Status } from "./node/node.js";
+export {
+	defaultNodeVersionHash,
+	type NodeVersion,
+	type NodeVersionHashFn,
+	type NodeVersioningLevel,
+	type NodeVersioningPolicy,
+	type NodeVersionJson,
+	type NodeVersionV0,
+	type NodeVersionV1,
+} from "./node/versioning.js";
+export {
+	type KnowledgeAssertionStrictJsonValue,
+	type KnowledgeGraphCursor,
+	type KnowledgeGraphEntity,
+	type KnowledgeGraphError,
+	type KnowledgeGraphErrorCode,
+	type KnowledgeGraphIndex,
+	type KnowledgeGraphPolicy,
+	type KnowledgeGraphReducerBundle,
+	type KnowledgeGraphReducerBundleOptions,
+	type KnowledgeGraphRelation,
+	type KnowledgeGraphSnapshot,
+	type KnowledgeGraphStatus,
+	type KnowledgeGraphStatusState,
+	type KnowledgeGraphTopic,
+	knowledgeGraphReducerBundle,
+} from "./patterns/index.js";
+export * from "./protocol/messages.js";
+export {
+	AGENTIC_MEMORY_RECORD_FRAME_FORMAT,
+	AGENTIC_MEMORY_RECORD_FRAME_VERSION,
+	type AgenticMemoryArtifactKind,
+	type AgenticMemoryBundle,
+	type AgenticMemoryBundleOptions,
+	type AgenticMemoryConsolidationBundle,
+	type AgenticMemoryConsolidationBundleOptions,
+	type AgenticMemoryConsolidationCommand,
+	type AgenticMemoryConsolidationCursor,
+	type AgenticMemoryConsolidationError,
+	type AgenticMemoryConsolidationErrorCode,
+	type AgenticMemoryConsolidationOutcome,
+	type AgenticMemoryConsolidationRecordDraft,
+	type AgenticMemoryConsolidationRequest,
+	type AgenticMemoryConsolidationResult,
+	type AgenticMemoryConsolidationSnapshot,
+	type AgenticMemoryConsolidationStatus,
+	type AgenticMemoryContext,
+	type AgenticMemoryContextEntry,
+	type AgenticMemoryContextPackingBundle,
+	type AgenticMemoryContextPackingBundleOptions,
+	type AgenticMemoryContextPackingCursor,
+	type AgenticMemoryContextPackingError,
+	type AgenticMemoryContextPackingErrorCode,
+	type AgenticMemoryContextPackingPolicy,
+	type AgenticMemoryContextPackingSnapshot,
+	type AgenticMemoryContextPackingStatus,
+	type AgenticMemoryContextState,
+	type AgenticMemoryContextText,
+	type AgenticMemoryError,
+	type AgenticMemoryErrorCode,
+	type AgenticMemoryFragmentFrame,
+	type AgenticMemoryKgAssertionDraft,
+	type AgenticMemoryKgProjectionBundle,
+	type AgenticMemoryKgProjectionBundleOptions,
+	type AgenticMemoryKgProjectionCursor,
+	type AgenticMemoryKgProjectionError,
+	type AgenticMemoryKgProjectionErrorCode,
+	type AgenticMemoryKgProjectionSnapshot,
+	type AgenticMemoryKgProjectionStatus,
+	type AgenticMemoryKgProjectionStatusState,
+	type AgenticMemoryKind,
+	type AgenticMemoryPackedContext,
+	type AgenticMemoryPackedContextEntry,
+	type AgenticMemoryPersistenceLevel,
+	type AgenticMemoryProjectionCursor,
+	type AgenticMemoryProjectionSnapshot,
+	type AgenticMemoryRecord,
+	type AgenticMemoryRecordFrame,
+	type AgenticMemoryRecordMetadata,
+	type AgenticMemoryRetentionBundle,
+	type AgenticMemoryRetentionBundleOptions,
+	type AgenticMemoryRetentionCommand,
+	type AgenticMemoryRetentionCursor,
+	type AgenticMemoryRetentionError,
+	type AgenticMemoryRetentionErrorCode,
+	type AgenticMemoryRetentionSnapshot,
+	type AgenticMemoryRetentionStatus,
+	type AgenticMemoryScope,
+	type AgenticMemorySourceProjection,
+	type AgenticMemoryStatus,
+	type AgenticMemoryStatusState,
+	type AgenticMemoryStrictJsonValue,
+	agenticMemoryBundle,
+	agenticMemoryConsolidationBundle,
+	agenticMemoryContextPackingBundle,
+	agenticMemoryKgProjectionBundle,
+	agenticMemoryRecordCodec,
+	agenticMemoryRecordFrame,
+	agenticMemoryRecordFrameCodec,
+	agenticMemoryRetentionBundle,
+	assertAgenticMemoryRecordFrame,
+	type KnowledgeAssertion,
+	type KnowledgeAssertionObject,
+	type KnowledgeAssertionSubject,
+} from "./solutions/index.js";
+export {
+	APPEND_LOG_SEQ_PAD,
+	type AppendLogEntry,
+	type AppendLogPage,
+	type AppendLogReadOptions,
+	type AppendLogStorageTier,
+	appendLogKey,
+	appendLogStorage,
+	assertChangeEnvelope,
+	assertDecimalIntegerString,
+	assertNonNegativeDecimalIntegerString,
+	assertObserveEventFrame,
+	assertReactiveCollectionChangeFrame,
+	assertReactiveCollectionSnapshotFrame,
+	assertWalFrame,
+	bigIntToDecimalString,
+	bigIntToNonNegativeDecimalString,
+	type ChangeEnvelope,
+	type ChangeEnvelopeOptions,
+	type ChangeLifecycle,
+	type Codec,
+	type ContentAddressedKv,
+	type ContentAddressedKvOptions,
+	ContentAddressedMissError,
+	type ContentAddressedMode,
+	type ContentAddressedStorage,
+	type ContentAddressedStorageOptions,
+	changeEnvelopeCodec,
+	collectionSnapshotKey,
+	contentAddressedKv,
+	contentAddressedStorage,
+	type DecimalIntegerString,
+	decimalStringToBigInt,
+	dictKv,
+	envelopeChange,
+	hasKvPutIfAbsent,
+	hasKvVersioned,
+	hasStoragePutIfAbsent,
+	hasStorageVersioned,
+	isDecimalIntegerString,
+	isNonNegativeDecimalIntegerString,
+	jsonCodec,
+	jsonCodecFor,
+	type KvGeneration,
+	type KvStorageOptions,
+	type KvStorageTier,
+	type KvVersionedRead,
+	kvStorage,
+	type LoadReactiveCollectionStateOptions,
+	listByPrefix,
+	loadReactiveIndexState,
+	loadReactiveListState,
+	loadReactiveLogState,
+	loadReactiveMapState,
+	type MemoryBackend,
+	type MultiWriterAppendLogOptions,
+	type MultiWriterAppendLogStorageTier,
+	memoryAppendLog,
+	memoryBackend,
+	memoryKv,
+	memoryMultiWriterAppendLog,
+	multiWriterAppendLogStorage,
+	type NonNegativeDecimalIntegerString,
+	nonNegativeDecimalStringToBigInt,
+	nowNs,
+	type ObserveEventFrame,
+	type ObserveEventLogPage,
+	observeEventFrame,
+	observeEventFrameCodec,
+	type PutIfAbsentKvStorageTier,
+	type PutIfAbsentStorageBackend,
+	REACTIVE_COLLECTION_CHANGE_FORMAT,
+	REACTIVE_COLLECTION_FRAME_VERSION,
+	REACTIVE_COLLECTION_SNAPSHOT_FORMAT,
+	type ReactiveCollectionChangeFrame,
+	type ReactiveCollectionRestoreState,
+	type ReactiveCollectionSnapshotFrame,
+	type ReactiveCollectionStorageKind,
+	type ReactiveIndexRestoreState,
+	type ReactiveListRestoreState,
+	type ReactiveLogRestoreState,
+	type ReactiveMapRestoreState,
+	type ReadThroughErrorContext,
+	type ReadThroughLookupFact,
+	type ReadThroughLookupTier,
+	type ReadThroughMissContext,
+	type ReadThroughPromotionFact,
+	reactiveCollectionChangeFrame,
+	reactiveCollectionChangeFrameCodec,
+	reactiveCollectionSnapshotFrame,
+	reactiveCollectionSnapshotFrameCodec,
+	readAppendLogPage,
+	readObserveEventLogPage,
+	readThroughKv,
+	requireKvPutIfAbsent,
+	requireKvVersioned,
+	requireStoragePutIfAbsent,
+	requireStorageVersioned,
+	type StorageBackend,
+	type StorageGeneration,
+	type StorageNamespaceOptions,
+	type StorageTimestampNs,
+	type StorageVersionedRead,
+	stableJsonString,
+	strictJsonCodec,
+	strictJsonCodecFor,
+	type TieredReadThroughOptions,
+	type TieredReadThroughResult,
+	tieredReadThrough,
+	type VersionedKvStorageTier,
+	type VersionedStorageBackend,
+	verifyWalFrameChecksum,
+	WAL_FORMAT_VERSION,
+	WAL_FRAME_SEQ_PAD,
+	WAL_KEY_SEGMENT,
+	type WalFrame,
+	type WalFrameBody,
+	type WalFrameOptions,
+	type WalFrameTimestampNs,
+	type WebStorageLike,
+	walFrame,
+	walFrameChecksum,
+	walFrameCodec,
+	walFrameKey,
+	walFramePrefix,
+	webStorageBackend,
+} from "./storage/index.js";
+export {
+	assertDirtyPrecedesTerminalData,
+	type MessageSequence,
+} from "./testing/index.js";
diff --git a/packages/ts/src/inspection/boundary.ts b/packages/ts/src/inspection/boundary.ts
new file mode 100644
index 00000000..e7f56604
--- /dev/null
+++ b/packages/ts/src/inspection/boundary.ts
@@ -0,0 +1,144 @@
+/**
+ * Framework-neutral graph boundary projection (D238).
+ *
+ * The manifest is derived from describe()/live topology (R-describe,
+ * R-edges-derived). It does not own widgets, layouts, capabilities, or product
+ * metadata; those layers consume this structural boundary.
+ */
+
+import type { WritableNode } from "../adapters/store.js";
+import type { DescribeSnapshot } from "../graph/describe.js";
+import type { Graph } from "../graph/graph.js";
+import type { Node } from "../node/node.js";
+
+export type BoundaryRole = "input" | "output";
+export type BoundaryCapabilityKind = "auth" | "permission" | "config" | "resource";
+
+export interface BoundaryCapabilityRef {
+	id: string;
+	kind: BoundaryCapabilityKind;
+	required: boolean;
+	sourceRefs?: readonly string[];
+}
+
+export interface BaseBoundaryNode {
+	/** Registered graph node id/path. */
+	name: string;
+	/** Structural boundary role inferred from current describe() topology. */
+	role: BoundaryRole;
+	/** describe() factory: "state" | "producer" | "derived" | operator real name. */
+	type: string;
+	/** Live handle for framework adapters such as useNodeInput/useNodeValue. */
+	node: Node<unknown>;
+	/**
+	 * D348 generic capability refs only. Product/OAuth/config-form semantics stay in trusted
+	 * React/Canvas/product registries and do not affect structural boundary role inference.
+	 */
+	capabilities?: readonly BoundaryCapabilityRef[];
+}
+
+export interface InputBoundaryNode extends BaseBoundaryNode {
+	role: "input";
+	node: WritableNode<unknown>;
+}
+
+export interface OutputBoundaryNode extends BaseBoundaryNode {
+	role: "output";
+}
+
+export type BoundaryNode = InputBoundaryNode | OutputBoundaryNode;
+
+export interface BoundaryManifest {
+	inputs: InputBoundaryNode[];
+	outputs: OutputBoundaryNode[];
+}
+
+/**
+ * Derive a narrow v0 boundary manifest from current graph structure.
+ *
+ * Writable source nodes are inputs; unconsumed sink nodes are outputs; interior
+ * nodes are omitted. Auto-discovered graphless describe entries are skipped
+ * because widgets need live graph handles.
+ */
+export function boundaryManifest(graph: Graph): BoundaryManifest {
+	const described = graph.describe();
+	const consumed = new Set<string>();
+	for (const snapshot of walkSnapshots(described)) {
+		for (const edge of snapshot.edges ?? []) consumed.add(edge.from);
+	}
+	const inputs: InputBoundaryNode[] = [];
+	const outputs: OutputBoundaryNode[] = [];
+
+	for (const snapshot of walkSnapshots(described)) {
+		for (const entry of snapshot.nodes ?? []) {
+			const node = graph.find(entry.id);
+			if (node === undefined) continue;
+			const capabilities = boundaryCapabilities(entry.meta);
+			const isSource = (entry.deps?.length ?? 0) === 0;
+			const base =
+				capabilities === undefined
+					? { name: entry.id, type: entry.factory, node }
+					: { name: entry.id, type: entry.factory, node, capabilities };
+			if (isSource && isWritableNode(node)) {
+				inputs.push({ ...base, role: "input", node });
+			} else if (!consumed.has(entry.id)) {
+				outputs.push({ ...base, role: "output" });
+			}
+		}
+	}
+
+	return { inputs, outputs };
+}
+
+function* walkSnapshots(snapshot: DescribeSnapshot): Generator<DescribeSnapshot> {
+	yield snapshot;
+	for (const child of snapshot.subgraphs ?? []) yield* walkSnapshots(child);
+}
+
+function isWritableNode(node: Node<unknown>): node is WritableNode<unknown> {
+	return typeof (node as { set?: unknown }).set === "function";
+}
+
+function boundaryCapabilities(
+	meta: Record<string, unknown> | undefined,
+): BoundaryCapabilityRef[] | undefined {
+	const raw = meta?.boundaryCapabilities;
+	if (raw === undefined) return undefined;
+	if (!Array.isArray(raw)) return undefined;
+	const refs: BoundaryCapabilityRef[] = [];
+	for (const item of raw) {
+		const ref = boundaryCapabilityRef(item);
+		if (ref !== undefined) refs.push(ref);
+	}
+	return refs.length === 0 ? undefined : refs;
+}
+
+function boundaryCapabilityRef(value: unknown): BoundaryCapabilityRef | undefined {
+	if (value === null || typeof value !== "object" || Array.isArray(value)) return undefined;
+	const record = value as Record<string, unknown>;
+	if (!Object.keys(record).every(isBoundaryCapabilityRefKey)) return undefined;
+	if (typeof record.id !== "string" || !isBoundaryCapabilityKind(record.kind)) return undefined;
+	if (typeof record.required !== "boolean") return undefined;
+	const sourceRefs = stringArray(record.sourceRefs);
+	if (record.sourceRefs !== undefined && sourceRefs === undefined) return undefined;
+	return {
+		id: record.id,
+		kind: record.kind,
+		required: record.required,
+		...(sourceRefs === undefined ? {} : { sourceRefs }),
+	};
+}
+
+function isBoundaryCapabilityKind(value: unknown): value is BoundaryCapabilityKind {
+	return value === "auth" || value === "permission" || value === "config" || value === "resource";
+}
+
+function isBoundaryCapabilityRefKey(value: string): value is keyof BoundaryCapabilityRef {
+	return value === "id" || value === "kind" || value === "required" || value === "sourceRefs";
+}
+
+function stringArray(value: unknown): readonly string[] | undefined {
+	if (value === undefined) return undefined;
+	if (!Array.isArray(value) || !value.every((entry) => typeof entry === "string")) return undefined;
+	return value;
+}
diff --git a/packages/ts/src/json/codec.ts b/packages/ts/src/json/codec.ts
new file mode 100644
index 00000000..9ff071a3
--- /dev/null
+++ b/packages/ts/src/json/codec.ts
@@ -0,0 +1,403 @@
+/**
+ * Neutral JSON/encoding utilities (D96).
+ *
+ * Shared by graph checkpoints and storage bindings; neither layer owns the strict JSON
+ * scanner/canonicalization contract.
+ */
+
+/** Typed byte codec for D82 storage binding helpers and D96 shared JSON surfaces. */
+export interface Codec<T> {
+	encode(value: T): Uint8Array;
+	decode(bytes: Uint8Array): T;
+}
+
+export type StrictJsonScalar = null | boolean | number | string;
+export type StrictJsonValue =
+	| StrictJsonScalar
+	| readonly StrictJsonValue[]
+	| { readonly [key: string]: StrictJsonValue };
+export type StrictJsonObject = Readonly<Record<string, StrictJsonValue>>;
+
+type JsonValue = StrictJsonValue;
+
+const JS_MIN_NORMAL_NUMBER = 2 ** -1022;
+
+function assertStableJsonNumber(value: number, path: string): void {
+	if (!Number.isFinite(value)) {
+		throw new TypeError(`stableJsonString: non-finite number at ${path}`);
+	}
+}
+
+function assertStrictJsonNumber(value: number, path: string): void {
+	assertStableJsonNumber(value, path);
+	if (Object.is(value, -0)) {
+		throw new TypeError(`stableJsonString: non-canonical number at ${path}`);
+	}
+	const abs = Math.abs(value);
+	if (abs > 0 && abs < JS_MIN_NORMAL_NUMBER) {
+		throw new TypeError(`stableJsonString: subnormal number at ${path}`);
+	}
+	if (Number.isInteger(value) && !Number.isSafeInteger(value)) {
+		throw new TypeError(`stableJsonString: integer outside safe range at ${path}`);
+	}
+}
+
+function sortedJsonValue(
+	value: unknown,
+	seen = new Set<object>(),
+	path = "$",
+	strictNumbers = false,
+): JsonValue {
+	if (value === null) return null;
+	if (typeof value === "string" || typeof value === "boolean") return value;
+	if (typeof value === "number") {
+		if (strictNumbers) assertStrictJsonNumber(value, path);
+		else assertStableJsonNumber(value, path);
+		return value;
+	}
+	if (typeof value !== "object") {
+		throw new TypeError(`stableJsonString: value at ${path} is not JSON-encodable`);
+	}
+	if (seen.has(value)) throw new TypeError(`stableJsonString: circular reference at ${path}`);
+	const proto = Object.getPrototypeOf(value);
+	if (!Array.isArray(value) && proto !== Object.prototype && proto !== null) {
+		throw new TypeError(`stableJsonString: non-plain object at ${path}`);
+	}
+	seen.add(value);
+	try {
+		if (Array.isArray(value)) {
+			if (Object.getOwnPropertySymbols(value).length > 0) {
+				throw new TypeError(`stableJsonString: symbol-keyed properties at ${path}`);
+			}
+			for (const key of Object.getOwnPropertyNames(value)) {
+				const isIndex =
+					/^(0|[1-9]\d*)$/.test(key) &&
+					Number.isSafeInteger(Number(key)) &&
+					Number(key) < value.length;
+				const descriptor = Object.getOwnPropertyDescriptor(value, key);
+				if (descriptor !== undefined && ("get" in descriptor || "set" in descriptor)) {
+					throw new TypeError(`stableJsonString: accessor property at ${path}.${key}`);
+				}
+				if (key !== "length" && !isIndex) {
+					throw new TypeError(`stableJsonString: non-index array property at ${path}.${key}`);
+				}
+				if (key !== "length" && descriptor !== undefined && !descriptor.enumerable) {
+					throw new TypeError(`stableJsonString: non-enumerable array property at ${path}.${key}`);
+				}
+			}
+			const out: JsonValue[] = [];
+			for (let i = 0; i < value.length; i += 1) {
+				if (!(i in value)) {
+					throw new TypeError(`stableJsonString: sparse array hole at ${path}[${i}]`);
+				}
+				out.push(sortedJsonValue(value[i], seen, `${path}[${i}]`, strictNumbers));
+			}
+			return out;
+		}
+		if (Object.getOwnPropertySymbols(value).length > 0) {
+			throw new TypeError(`stableJsonString: symbol-keyed properties at ${path}`);
+		}
+		for (const key of Object.getOwnPropertyNames(value)) {
+			const descriptor = Object.getOwnPropertyDescriptor(value, key);
+			if (descriptor !== undefined && ("get" in descriptor || "set" in descriptor)) {
+				throw new TypeError(`stableJsonString: accessor property at ${path}.${key}`);
+			}
+			if (descriptor !== undefined && !descriptor.enumerable) {
+				throw new TypeError(`stableJsonString: non-enumerable property at ${path}.${key}`);
+			}
+		}
+		const out: Record<string, JsonValue> = Object.create(null);
+		for (const key of Object.keys(value as Record<string, unknown>).sort()) {
+			out[key] = sortedJsonValue(
+				(value as Record<string, unknown>)[key],
+				seen,
+				`${path}.${key}`,
+				strictNumbers,
+			);
+		}
+		return out;
+	} finally {
+		seen.delete(value);
+	}
+}
+
+/** Stable JSON string: object keys sort by code-unit order for deterministic storage/checkpoint bytes. */
+export function stableJsonString(value: unknown): string {
+	return JSON.stringify(sortedJsonValue(value));
+}
+
+function strictStableJsonString(value: unknown): string {
+	return JSON.stringify(sortedJsonValue(value, new Set<object>(), "$", true));
+}
+
+/** Build a JSON codec using stable object-key ordering. */
+export function jsonCodecFor<T>(): Codec<T> {
+	const encoder = new TextEncoder();
+	const decoder = new TextDecoder();
+	return {
+		encode(value: T): Uint8Array {
+			return encoder.encode(stableJsonString(value));
+		},
+		decode(bytes: Uint8Array): T {
+			return JSON.parse(decoder.decode(bytes)) as T;
+		},
+	};
+}
+
+/** Default stable JSON codec for unknown values. */
+export const jsonCodec: Codec<unknown> = jsonCodecFor<unknown>();
+
+function bytesEqual(a: Uint8Array, b: Uint8Array): boolean {
+	if (a.byteLength !== b.byteLength) return false;
+	for (let i = 0; i < a.byteLength; i += 1) {
+		if (a[i] !== b[i]) return false;
+	}
+	return true;
+}
+
+function hasUnpairedSurrogate(value: string): boolean {
+	for (let i = 0; i < value.length; i += 1) {
+		const code = value.charCodeAt(i);
+		if (code >= 0xd800 && code <= 0xdbff) {
+			const next = value.charCodeAt(i + 1);
+			if (next >= 0xdc00 && next <= 0xdfff) {
+				i += 1;
+				continue;
+			}
+			return true;
+		}
+		if (code >= 0xdc00 && code <= 0xdfff) return true;
+	}
+	return false;
+}
+
+function assertNoUnpairedSurrogates(value: unknown, seen = new Set<object>(), path = "$"): void {
+	if (typeof value === "string") {
+		if (hasUnpairedSurrogate(value)) {
+			throw new TypeError(`strictJsonCodec: unpaired surrogate at ${path}`);
+		}
+		return;
+	}
+	if (value === null || typeof value !== "object") return;
+	if (seen.has(value)) return;
+	seen.add(value);
+	try {
+		if (Array.isArray(value)) {
+			for (let i = 0; i < value.length; i += 1) {
+				assertNoUnpairedSurrogates(value[i], seen, `${path}[${i}]`);
+			}
+			return;
+		}
+		for (const key of Object.keys(value as Record<string, unknown>)) {
+			if (hasUnpairedSurrogate(key)) {
+				throw new TypeError(`strictJsonCodec: unpaired surrogate at ${path}.${key}`);
+			}
+			assertNoUnpairedSurrogates((value as Record<string, unknown>)[key], seen, `${path}.${key}`);
+		}
+	} finally {
+		seen.delete(value);
+	}
+}
+
+function assertNoDuplicateJsonObjectKeys(text: string): void {
+	let index = 0;
+
+	function fail(message: string): never {
+		throw new TypeError(`strictJsonCodec: ${message}`);
+	}
+
+	function skipWhitespace(): void {
+		while (/\s/.test(text[index] ?? "")) index += 1;
+	}
+
+	function readJsonString(): string {
+		const start = index;
+		index += 1;
+		while (index < text.length) {
+			const ch = text[index];
+			if (ch === '"') {
+				index += 1;
+				try {
+					return JSON.parse(text.slice(start, index)) as string;
+				} catch {
+					fail("malformed JSON string");
+				}
+			}
+			if (ch === "\\") {
+				index += 2;
+				continue;
+			}
+			index += 1;
+		}
+		fail("unterminated JSON string");
+	}
+
+	function consumeLiteral(literal: string): void {
+		if (text.slice(index, index + literal.length) !== literal) {
+			fail(`malformed JSON near byte ${index}`);
+		}
+		index += literal.length;
+	}
+
+	function consumeNumber(): void {
+		const match = /^-?(0|[1-9]\d*)(\.\d+)?([eE][+-]?\d+)?/.exec(text.slice(index));
+		if (!match) fail(`malformed JSON number near byte ${index}`);
+		index += match[0].length;
+	}
+
+	function parseValue(path: string): void {
+		skipWhitespace();
+		const ch = text[index];
+		if (ch === "{") {
+			parseObject(path);
+			return;
+		}
+		if (ch === "[") {
+			parseArray(path);
+			return;
+		}
+		if (ch === '"') {
+			readJsonString();
+			return;
+		}
+		if (ch === "t") {
+			consumeLiteral("true");
+			return;
+		}
+		if (ch === "f") {
+			consumeLiteral("false");
+			return;
+		}
+		if (ch === "n") {
+			consumeLiteral("null");
+			return;
+		}
+		if (ch === "-" || (ch !== undefined && ch >= "0" && ch <= "9")) {
+			consumeNumber();
+			return;
+		}
+		fail(`malformed JSON near byte ${index}`);
+	}
+
+	function parseObject(path: string): void {
+		const keys = new Set<string>();
+		index += 1;
+		skipWhitespace();
+		if (text[index] === "}") {
+			index += 1;
+			return;
+		}
+		while (index < text.length) {
+			skipWhitespace();
+			if (text[index] !== '"') fail(`expected object key near byte ${index}`);
+			const key = readJsonString();
+			if (keys.has(key)) {
+				throw new TypeError(
+					`strictJsonCodec: duplicate object key ${JSON.stringify(key)} at ${path}`,
+				);
+			}
+			keys.add(key);
+			skipWhitespace();
+			if (text[index] !== ":") fail(`expected ':' after object key near byte ${index}`);
+			index += 1;
+			parseValue(`${path}.${key}`);
+			skipWhitespace();
+			if (text[index] === ",") {
+				index += 1;
+				continue;
+			}
+			if (text[index] === "}") {
+				index += 1;
+				return;
+			}
+			fail(`expected ',' or '}' near byte ${index}`);
+		}
+		fail("unterminated JSON object");
+	}
+
+	function parseArray(path: string): void {
+		index += 1;
+		skipWhitespace();
+		if (text[index] === "]") {
+			index += 1;
+			return;
+		}
+		let item = 0;
+		while (index < text.length) {
+			parseValue(`${path}[${item}]`);
+			item += 1;
+			skipWhitespace();
+			if (text[index] === ",") {
+				index += 1;
+				continue;
+			}
+			if (text[index] === "]") {
+				index += 1;
+				return;
+			}
+			fail(`expected ',' or ']' near byte ${index}`);
+		}
+		fail("unterminated JSON array");
+	}
+
+	parseValue("$");
+	skipWhitespace();
+	if (index !== text.length) fail(`trailing JSON token near byte ${index}`);
+}
+
+/**
+ * Build a strict canonical JSON codec (D84/D87/D96).
+ * The strict surface rejects malformed UTF-8, duplicate object keys, non-canonical bytes,
+ * unpaired surrogates, and values that cannot round-trip through stable JSON.
+ */
+export function strictJsonCodecFor<T>(): Codec<T> {
+	const encoder = new TextEncoder();
+	const decoder = new TextDecoder("utf-8", { fatal: true });
+	return {
+		encode(value: T): Uint8Array {
+			assertNoUnpairedSurrogates(value);
+			return encoder.encode(strictStableJsonString(value));
+		},
+		decode(bytes: Uint8Array): T {
+			const text = decoder.decode(bytes);
+			assertNoDuplicateJsonObjectKeys(text);
+			const decoded = JSON.parse(text) as unknown;
+			assertNoUnpairedSurrogates(decoded);
+			const canonical = encoder.encode(strictStableJsonString(decoded));
+			if (!bytesEqual(bytes, canonical)) {
+				throw new TypeError("strictJsonCodec: bytes are not canonical stable JSON");
+			}
+			return decoded as T;
+		},
+	};
+}
+
+/** Default strict canonical JSON codec for unknown values. */
+export const strictJsonCodec: Codec<unknown> = strictJsonCodecFor<unknown>();
+
+/** D113 neutral helper for strict canonical JSON UTF-8 bytes. */
+export function strictCanonicalJsonBytes(value: unknown): Uint8Array {
+	return strictJsonCodec.encode(value);
+}
+
+/** Validate and normalize a host value into strict canonical JSON data. */
+export function assertStrictJsonValue(value: unknown, label = "strictJsonValue"): StrictJsonValue {
+	try {
+		return strictJsonCodec.decode(strictJsonCodec.encode(value)) as StrictJsonValue;
+	} catch (cause) {
+		const message = cause instanceof Error ? cause.message : String(cause);
+		throw new TypeError(`${label}: value is not strict JSON compatible: ${message}`, { cause });
+	}
+}
+
+/** Validate and normalize a host value into a strict canonical JSON object. */
+export function assertStrictJsonObject(
+	value: unknown,
+	label = "strictJsonObject",
+): StrictJsonObject {
+	const normalized = assertStrictJsonValue(value, label);
+	if (normalized === null || typeof normalized !== "object" || Array.isArray(normalized)) {
+		throw new TypeError(`${label}: value must be a strict JSON object`);
+	}
+	return normalized as StrictJsonObject;
+}
diff --git a/packages/ts/src/messaging/event-message.ts b/packages/ts/src/messaging/event-message.ts
new file mode 100644
index 00000000..aaa00b63
--- /dev/null
+++ b/packages/ts/src/messaging/event-message.ts
@@ -0,0 +1,56 @@
+import type { DataIssue } from "../data/index.js";
+import type { EventMessage, EventMessageOptions } from "./types.js";
+import { assertNonEmpty, isObjectRecord } from "./utils.js";
+
+export function eventMessage<T>(
+	type: string,
+	payload: T,
+	opts: EventMessageOptions,
+): EventMessage<T> {
+	assertNonEmpty(type, "eventMessage.type");
+	assertNonEmpty(opts.id, "eventMessage.id");
+	return {
+		id: opts.id,
+		type,
+		payload,
+		...(opts.key === undefined ? {} : { key: opts.key }),
+		...(opts.subjectId === undefined ? {} : { subjectId: opts.subjectId }),
+		...(opts.correlationId === undefined ? {} : { correlationId: opts.correlationId }),
+		...(opts.causationId === undefined ? {} : { causationId: opts.causationId }),
+		...(opts.occurredAtMs === undefined ? {} : { occurredAtMs: opts.occurredAtMs }),
+		...(opts.actor === undefined ? {} : { actor: opts.actor }),
+		...(opts.evidenceRefs === undefined ? {} : { evidenceRefs: opts.evidenceRefs }),
+		...(opts.schema === undefined ? {} : { schema: opts.schema }),
+		...(opts.metadata === undefined ? {} : { metadata: opts.metadata }),
+	};
+}
+
+export function isEventMessage(value: unknown): value is EventMessage {
+	return eventMessageIssue(value) === undefined;
+}
+
+export function eventMessageIssue(value: unknown): DataIssue | undefined {
+	if (!isObjectRecord(value)) {
+		return eventIssue("event message must be an object");
+	}
+	if (typeof value.id !== "string" || value.id.length === 0) {
+		return eventIssue("event message id must be a non-empty string");
+	}
+	if (typeof value.type !== "string" || value.type.length === 0) {
+		return eventIssue("event message type must be a non-empty string");
+	}
+	if (!("payload" in value)) {
+		return eventIssue("event message payload field is required");
+	}
+	return undefined;
+}
+
+function eventIssue(message: string): DataIssue {
+	return {
+		kind: "issue",
+		code: "malformed-event-message",
+		message,
+		severity: "error",
+		source: "messageBus.eventMessage",
+	};
+}
diff --git a/packages/ts/src/messaging/index.ts b/packages/ts/src/messaging/index.ts
new file mode 100644
index 00000000..5504806c
--- /dev/null
+++ b/packages/ts/src/messaging/index.ts
@@ -0,0 +1,979 @@
+/**
+ * Reusable application-infrastructure messaging namespace.
+ *
+ * D279/D282/D284/D285/D276: messageBus is a retained topic-log plus independent
+ * subscription-cursor substrate. DynamicHub is intentionally retired; do not add aliases.
+ */
+
+import { depBatch, type NodeFn } from "../ctx/types.js";
+import type { DataIssue } from "../data/index.js";
+import type { Graph } from "../graph/graph.js";
+import type { Node } from "../node/node.js";
+import {
+	attachMessageBusCommandSource,
+	getMessageBusState,
+	registerMessageBusState,
+} from "./internal.js";
+import type {
+	MessageBusState,
+	RuntimeEvent,
+	SubscriptionState,
+	TopicState,
+} from "./runtime-types.js";
+import type {
+	MessageBus,
+	MessageBusAvailablePage,
+	MessageBusAvailableParams,
+	MessageBusCatalogPage,
+	MessageBusCatalogParams,
+	MessageBusCommand,
+	MessageBusCursor,
+	MessageBusDeadLetterEntry,
+	MessageBusDeadLetterPage,
+	MessageBusDeadLetterParams,
+	MessageBusMessage,
+	MessageBusOptions,
+	MessageBusStatus,
+	MessageBusTopicPage,
+	MessageBusTopicParams,
+	ToTopicBundle,
+	ToTopicOptions,
+} from "./types.js";
+import {
+	assertNonEmpty,
+	assertTopicKey,
+	commandIdOf,
+	commandTopic,
+	idempotencyKey,
+	isObjectRecord,
+	isPositiveSeq,
+	makeTopicState,
+	positiveLimit,
+	publishCommand,
+	pullParams,
+	uniqueTopics,
+	validateTopicKey,
+} from "./utils.js";
+
+export {
+	eventMessage,
+	eventMessageIssue,
+	isEventMessage,
+} from "./event-message.js";
+export type {
+	EventMessage,
+	EventMessageOptions,
+	JsonSchema,
+	MessageBus,
+	MessageBusAvailablePage,
+	MessageBusAvailableParams,
+	MessageBusCatalogEntry,
+	MessageBusCatalogPage,
+	MessageBusCatalogParams,
+	MessageBusCommand,
+	MessageBusCursor,
+	MessageBusDeadLetterEntry,
+	MessageBusDeadLetterPage,
+	MessageBusDeadLetterParams,
+	MessageBusDedupePolicy,
+	MessageBusMessage,
+	MessageBusOptions,
+	MessageBusPageParams,
+	MessageBusPullProjection,
+	MessageBusRetentionPolicy,
+	MessageBusStatus,
+	MessageBusSubscription,
+	MessageBusTopicPage,
+	MessageBusTopicParams,
+	MessageBusTopicPolicy,
+	MessageBusTopicProjection,
+	MessageEnvelope,
+	StandardTopic,
+	TopicMessage,
+	ToTopicBundle,
+	ToTopicOptions,
+} from "./types.js";
+export {
+	CONTEXT_TOPIC,
+	DEFERRED_TOPIC,
+	INJECTIONS_TOPIC,
+	PROMPTS_TOPIC,
+	RESPONSES_TOPIC,
+	SPAWNS_TOPIC,
+	STANDARD_TOPICS,
+	TODOS_TOPIC,
+} from "./types.js";
+
+export function messageBus<TTopic extends string>(
+	graph: Graph,
+	opts: MessageBusOptions<TTopic> = {},
+): MessageBus<TTopic> {
+	const name = opts.name ?? "messageBus";
+	const initialTopics = uniqueTopics(opts.topics ?? []);
+	const commandSources: Node<MessageBusCommand>[] = [];
+	const commandBody: NodeFn = (ctx) => {
+		for (let i = 0; i < commandSources.length; i++) {
+			for (const command of depBatch(ctx, i) ?? []) ctx.down([["DATA", command]]);
+		}
+	};
+	const commands = graph.node<MessageBusCommand>([], commandBody, {
+		name: `${name}/commands`,
+		factory: "messageBusCommands",
+		completeWhenDepsComplete: false,
+		errorWhenDepsError: false,
+	});
+	const state: MessageBusState = {
+		graph,
+		name,
+		now: opts.now ?? Date.now,
+		topicPolicy: opts.topicPolicy ?? "strict",
+		retention: opts.retention ?? {},
+		dedupe: opts.dedupe ?? { commandId: "status" },
+		topics: new Map(initialTopics.map((topic) => [topic, makeTopicState()])),
+		subscriptions: new Map(),
+		seenCommandIds: new Set(),
+		seenIdempotencyKeys: new Set(),
+		deadLetters: [],
+		deadLetterSeq: 0,
+		commandSources,
+		commandBody,
+	};
+	const runtime = graph.node<RuntimeEvent>(
+		[commands],
+		(ctx) => {
+			for (const command of depBatch(ctx, 0) ?? []) {
+				for (const event of reduceMessageBusCommand(state, command as MessageBusCommand)) {
+					ctx.down([["DATA", event]]);
+				}
+			}
+		},
+		{
+			name: `${name}/runtime`,
+			factory: "messageBusRuntime",
+			completeWhenDepsComplete: false,
+			errorWhenDepsError: false,
+		},
+	);
+	graph.retain(runtime, { reason: `${name}.messageBus.runtime` });
+	const messages = graph.node<MessageBusMessage>(
+		[runtime],
+		(ctx) => {
+			for (const event of depBatch(ctx, 0) ?? []) {
+				const typed = event as RuntimeEvent;
+				if (typed.kind === "message") ctx.down([["DATA", typed.message]]);
+			}
+		},
+		{
+			name: `${name}/messages`,
+			factory: "messageBusMessages",
+			completeWhenDepsComplete: false,
+			errorWhenDepsError: false,
+		},
+	);
+	const status = graph.node<MessageBusStatus>(
+		[runtime],
+		(ctx) => {
+			for (const event of depBatch(ctx, 0) ?? []) {
+				const typed = event as RuntimeEvent;
+				if (typed.kind === "status") ctx.down([["DATA", typed.status]]);
+			}
+		},
+		{
+			name: `${name}/status`,
+			factory: "messageBusStatus",
+			completeWhenDepsComplete: false,
+			errorWhenDepsError: false,
+		},
+	);
+	const issues = graph.node<DataIssue>(
+		[runtime],
+		(ctx) => {
+			for (const event of depBatch(ctx, 0) ?? []) {
+				const typed = event as RuntimeEvent;
+				if (typed.kind === "issue") ctx.down([["DATA", typed.issue]]);
+			}
+		},
+		{
+			name: `${name}/issues`,
+			factory: "messageBusIssues",
+			completeWhenDepsComplete: false,
+			errorWhenDepsError: false,
+		},
+	);
+
+	const bus: MessageBus<TTopic> = {
+		commands,
+		messages,
+		status,
+		issues,
+		ensureTopic(topic, commandOpts = {}) {
+			return publishCommand(commands, {
+				kind: "ensure-topic",
+				topic,
+				...(commandOpts.commandId === undefined ? {} : { commandId: commandOpts.commandId }),
+			});
+		},
+		closeTopic(topic, commandOpts = {}) {
+			return publishCommand(commands, {
+				kind: "close-topic",
+				topic,
+				...(commandOpts.commandId === undefined ? {} : { commandId: commandOpts.commandId }),
+			});
+		},
+		publish<T = unknown>(
+			topic: TTopic | string,
+			payload: T,
+			publishOpts: { key?: string; commandId?: string; idempotencyKey?: string } = {},
+		) {
+			return publishCommand(commands, {
+				kind: "publish",
+				topic,
+				payload,
+				...(publishOpts.key === undefined ? {} : { key: publishOpts.key }),
+				...(publishOpts.commandId === undefined ? {} : { commandId: publishOpts.commandId }),
+				...(publishOpts.idempotencyKey === undefined
+					? {}
+					: { idempotencyKey: publishOpts.idempotencyKey }),
+			});
+		},
+		topic<T = unknown>(topic: TTopic | string, projectionOpts: { name?: string } = {}) {
+			assertTopicKey(topic, "messageBus.topic");
+			const snapshotPullId = Symbol(`${name}/${topic}/topicSnapshot`);
+			const snapshot = graph.node<MessageBusTopicPage<T>>(
+				[messages],
+				(ctx) => {
+					const params = pullParams<MessageBusTopicParams>(ctx.pull);
+					ctx.down([["DATA", topicPage<T>(state, topic, params)]]);
+				},
+				{
+					name: projectionOpts.name ?? `${name}/${topic}/topic`,
+					factory: "messageBusTopicProjection",
+					meta: { topic },
+					pullId: snapshotPullId,
+					partial: true,
+					completeWhenDepsComplete: false,
+					errorWhenDepsError: false,
+				},
+			);
+			return { snapshot, snapshotPullId, status, issues };
+		},
+		catalog(projectionOpts: { name?: string } = {}) {
+			const snapshotPullId = Symbol(`${name}/catalogSnapshot`);
+			const snapshot = graph.node<MessageBusCatalogPage>(
+				[runtime],
+				(ctx) => {
+					const params = pullParams<MessageBusCatalogParams>(ctx.pull);
+					ctx.down([["DATA", catalogPage(state, params)]]);
+				},
+				{
+					name: projectionOpts.name ?? `${name}/catalog`,
+					factory: "messageBusCatalog",
+					pullId: snapshotPullId,
+					partial: true,
+					completeWhenDepsComplete: false,
+					errorWhenDepsError: false,
+				},
+			);
+			return { snapshot, snapshotPullId, status, issues };
+		},
+		deadLetter<T = unknown>(projectionOpts: { name?: string } = {}) {
+			const snapshotPullId = Symbol(`${name}/deadLetterSnapshot`);
+			const snapshot = graph.node<MessageBusDeadLetterPage<T>>(
+				[runtime],
+				(ctx) => {
+					const params = pullParams<MessageBusDeadLetterParams>(ctx.pull);
+					ctx.down([["DATA", deadLetterPage<T>(state, params)]]);
+				},
+				{
+					name: projectionOpts.name ?? `${name}/deadLetter`,
+					factory: "messageBusDeadLetter",
+					pullId: snapshotPullId,
+					partial: true,
+					completeWhenDepsComplete: false,
+					errorWhenDepsError: false,
+				},
+			);
+			return { snapshot, snapshotPullId, status, issues };
+		},
+		subscription<T = unknown>(subscriptionOpts: {
+			topic: TTopic | string;
+			subscriptionId: string;
+			from?: "earliest" | "latest" | number;
+			name?: string;
+		}) {
+			assertTopicKey(subscriptionOpts.topic, "messageBus.subscription");
+			assertNonEmpty(subscriptionOpts.subscriptionId, "messageBus.subscriptionId");
+			const sub = ensureSubscription(state, {
+				topic: subscriptionOpts.topic,
+				subscriptionId: subscriptionOpts.subscriptionId,
+				from: subscriptionOpts.from ?? "earliest",
+			});
+			const availablePullId = Symbol(
+				`${name}/${subscriptionOpts.topic}/${subscriptionOpts.subscriptionId}/available`,
+			);
+			const projectionName =
+				subscriptionOpts.name ??
+				`${name}/${subscriptionOpts.topic}/${subscriptionOpts.subscriptionId}`;
+			const available = graph.node<MessageBusAvailablePage<T>>(
+				[messages, status],
+				(ctx) => {
+					const params = pullParams<MessageBusAvailableParams>(ctx.pull);
+					ctx.down([["DATA", availablePage<T>(state, sub, params)]]);
+				},
+				{
+					name: `${projectionName}/available`,
+					factory: "messageBusSubscriptionAvailable",
+					meta: { topic: subscriptionOpts.topic, subscriptionId: subscriptionOpts.subscriptionId },
+					pullId: availablePullId,
+					partial: true,
+					completeWhenDepsComplete: false,
+					errorWhenDepsError: false,
+				},
+			);
+			const cursor = graph.node<MessageBusCursor>(
+				[status],
+				(ctx) => {
+					for (const fact of depBatch(ctx, 0) ?? []) {
+						const typed = fact as MessageBusStatus;
+						const subscriptionMoved =
+							typed.topic === sub.topic &&
+							typed.subscriptionId === sub.subscriptionId &&
+							(typed.kind === "subscription-acked" ||
+								typed.kind === "subscription-sought" ||
+								typed.kind === "subscription-closed");
+						const retentionMoved = typed.topic === sub.topic && typed.kind === "retention-trimmed";
+						if (subscriptionMoved || retentionMoved) {
+							ctx.down([["DATA", cursorSnapshot(state, sub)]]);
+						}
+					}
+				},
+				{
+					name: `${projectionName}/cursor`,
+					factory: "messageBusSubscriptionCursor",
+					completeWhenDepsComplete: false,
+					errorWhenDepsError: false,
+				},
+			);
+			return {
+				available,
+				availablePullId,
+				cursor,
+				status,
+				issues,
+				ack(seq, commandOpts = {}) {
+					return publishCommand(commands, {
+						kind: "ack",
+						topic: sub.topic,
+						subscriptionId: sub.subscriptionId,
+						seq,
+						...(commandOpts.commandId === undefined ? {} : { commandId: commandOpts.commandId }),
+					});
+				},
+				seek(nextSeq, commandOpts = {}) {
+					return publishCommand(commands, {
+						kind: "seek",
+						topic: sub.topic,
+						subscriptionId: sub.subscriptionId,
+						nextSeq,
+						...(commandOpts.commandId === undefined ? {} : { commandId: commandOpts.commandId }),
+					});
+				},
+				close(commandOpts = {}) {
+					return publishCommand(commands, {
+						kind: "close-subscription",
+						topic: sub.topic,
+						subscriptionId: sub.subscriptionId,
+						...(commandOpts.commandId === undefined ? {} : { commandId: commandOpts.commandId }),
+					});
+				},
+			};
+		},
+	};
+	registerMessageBusState(bus, state);
+	return bus;
+}
+
+export function fromTopic<T = unknown, TTopic extends string = string>(
+	bus: MessageBus<TTopic>,
+	topic: TTopic | string,
+): Node<MessageBusTopicPage<T>> {
+	return bus.topic<T>(topic).snapshot;
+}
+
+export function toTopic<T, TTopic extends string>(
+	graph: Graph,
+	source: Node<T>,
+	bus: MessageBus<TTopic>,
+	topic: TTopic | string,
+	opts: ToTopicOptions = {},
+): ToTopicBundle<T> {
+	const state = getMessageBusState(bus);
+	if (state === undefined) throw new Error("toTopic: unknown message bus implementation");
+	if (state.graph !== graph) throw new Error("toTopic: bus and source graph must match");
+	assertTopicKey(topic, "toTopic");
+	const commands = graph.node<MessageBusCommand<T>>(
+		[source],
+		(ctx) => {
+			for (const value of depBatch(ctx, 0) ?? []) {
+				const key = opts.keyOf?.(value);
+				const commandId = opts.commandIdOf?.(value);
+				ctx.down([
+					[
+						"DATA",
+						{
+							kind: "publish",
+							topic,
+							payload: value as T,
+							...(key === undefined ? {} : { key }),
+							...(commandId === undefined ? {} : { commandId }),
+						} satisfies MessageBusCommand<T>,
+					],
+				]);
+			}
+		},
+		{
+			name: opts.name ?? `${state.name}/${topic}/toTopic`,
+			factory: "toTopic",
+			meta: { topic },
+			completeWhenDepsComplete: false,
+			errorWhenDepsError: false,
+		},
+	);
+	const releaseSource = attachMessageBusCommandSource(
+		graph,
+		bus,
+		commands as Node<MessageBusCommand>,
+	);
+	let released = false;
+	return {
+		commands,
+		release() {
+			if (released) return;
+			released = true;
+			releaseSource();
+		},
+	};
+}
+
+function reduceMessageBusCommand(
+	state: MessageBusState,
+	command: MessageBusCommand,
+): RuntimeEvent[] {
+	const malformed = validateCommand(command);
+	if (malformed !== undefined) return rejectCommand(state, command, malformed);
+	if (command.commandId !== undefined) {
+		if (state.seenCommandIds.has(command.commandId)) {
+			return duplicateCommandEvents(state, command, "duplicate commandId");
+		}
+		state.seenCommandIds.add(command.commandId);
+	}
+	if (
+		command.kind === "publish" &&
+		command.idempotencyKey !== undefined &&
+		state.seenIdempotencyKeys.has(idempotencyKey(command.topic, command.idempotencyKey))
+	) {
+		return duplicateCommandEvents(state, command, "duplicate idempotencyKey");
+	}
+	switch (command.kind) {
+		case "ensure-topic":
+			return ensureTopic(state, command.topic, command.commandId);
+		case "close-topic": {
+			const topic = state.topics.get(command.topic);
+			if (topic === undefined) {
+				return issueEvents(state, command, "unknown-topic", `unknown topic '${command.topic}'`);
+			}
+			topic.closed = true;
+			return [
+				{
+					kind: "status",
+					status: statusFact(state, "topic-closed", {
+						topic: command.topic,
+						commandId: command.commandId,
+					}),
+				},
+			];
+		}
+		case "topic-policy":
+			state.topicPolicy = command.topicPolicy;
+			return [
+				{
+					kind: "status",
+					status: statusFact(state, "projection-ready", {
+						commandId: command.commandId,
+						details: { topicPolicy: command.topicPolicy },
+					}),
+				},
+			];
+		case "publish":
+			return publishMessage(state, command);
+		case "ack":
+			return ackSubscription(state, command);
+		case "seek":
+			return seekSubscription(state, command);
+		case "close-subscription":
+			return closeSubscription(state, command);
+	}
+}
+
+function publishMessage(
+	state: MessageBusState,
+	command: Extract<MessageBusCommand, { kind: "publish" }>,
+): RuntimeEvent[] {
+	let topic = state.topics.get(command.topic);
+	const events: RuntimeEvent[] = [];
+	if (topic === undefined) {
+		if (state.topicPolicy !== "create-as-fact") {
+			return issueEvents(state, command, "unknown-topic", `unknown topic '${command.topic}'`);
+		}
+		events.push(...ensureTopic(state, command.topic, command.commandId));
+		topic = state.topics.get(command.topic);
+	}
+	if (topic === undefined)
+		return issueEvents(state, command, "unknown-topic", `unknown topic '${command.topic}'`);
+	if (topic.closed)
+		return issueEvents(state, command, "closed-topic", `closed topic '${command.topic}'`);
+	const message: MessageBusMessage = {
+		topic: command.topic,
+		seq: topic.nextSeq++,
+		payload: command.payload,
+		timestampMs: state.now(),
+		...(command.key === undefined ? {} : { key: command.key }),
+		...(command.idempotencyKey === undefined ? {} : { idempotencyKey: command.idempotencyKey }),
+		...(command.commandId === undefined ? {} : { commandId: command.commandId }),
+	};
+	if (command.idempotencyKey !== undefined) {
+		state.seenIdempotencyKeys.add(idempotencyKey(command.topic, command.idempotencyKey));
+	}
+	topic.messages.push(message);
+	events.push({ kind: "message", message });
+	events.push({
+		kind: "status",
+		status: statusFact(state, "message-published", {
+			topic: command.topic,
+			seq: message.seq,
+			commandId: command.commandId,
+		}),
+	});
+	events.push(...trimRetention(state, command.topic, topic));
+	return events;
+}
+
+function ensureTopic(state: MessageBusState, topic: string, commandId?: string): RuntimeEvent[] {
+	assertTopicKey(topic, "messageBus");
+	if (!state.topics.has(topic)) state.topics.set(topic, makeTopicState());
+	return [
+		{
+			kind: "status",
+			status: statusFact(state, "topic-created", { topic, commandId }),
+		},
+	];
+}
+
+function trimRetention(
+	state: MessageBusState,
+	topicName: string,
+	topic: TopicState,
+): RuntimeEvent[] {
+	const max = state.retention.maxMessages;
+	if (max === undefined || topic.messages.length <= max) return [];
+	if (!Number.isInteger(max) || max < 1) {
+		return issueEvents(
+			state,
+			{ kind: "publish", topic: topicName, payload: undefined },
+			"policy-rejected",
+			"retention.maxMessages must be a positive integer",
+		);
+	}
+	const trimCount = topic.messages.length - max;
+	topic.messages.splice(0, trimCount);
+	topic.headSeq = topic.messages[0]?.seq ?? topic.nextSeq;
+	const events: RuntimeEvent[] = [
+		{
+			kind: "status",
+			status: statusFact(state, "retention-trimmed", {
+				topic: topicName,
+				headSeq: topic.headSeq,
+				details: { trimCount },
+			}),
+		},
+	];
+	for (const sub of state.subscriptions.values()) {
+		if (sub.closed || sub.topic !== topicName || sub.nextSeq >= topic.headSeq) continue;
+		sub.retentionGap = true;
+		events.push(
+			...issueEvents(
+				state,
+				{
+					kind: "seek",
+					topic: topicName,
+					subscriptionId: sub.subscriptionId,
+					nextSeq: sub.nextSeq,
+				},
+				"retention-gap",
+				`subscription '${sub.subscriptionId}' is before retained headSeq`,
+			),
+		);
+	}
+	return events;
+}
+
+function ackSubscription(
+	state: MessageBusState,
+	command: Extract<MessageBusCommand, { kind: "ack" }>,
+): RuntimeEvent[] {
+	const topic = state.topics.get(command.topic);
+	if (topic === undefined)
+		return issueEvents(state, command, "unknown-topic", `unknown topic '${command.topic}'`);
+	const sub = getSubscription(state, command.topic, command.subscriptionId);
+	if (sub === undefined)
+		return issueEvents(
+			state,
+			command,
+			"unknown-subscription",
+			`unknown subscription '${command.subscriptionId}'`,
+		);
+	if (sub.closed)
+		return issueEvents(state, command, "subscription-closed", "subscription is closed");
+	if (sub.retentionGap)
+		return issueEvents(state, command, "retention-gap", "subscription must seek before ack");
+	if (command.seq < sub.nextSeq)
+		return issueEvents(state, command, "source-cursor-stale", "ack is behind subscription cursor");
+	if (command.seq >= topic.nextSeq)
+		return issueEvents(state, command, "cursor-out-of-range", "ack is beyond topic tail");
+	sub.nextSeq = Math.max(sub.nextSeq, command.seq + 1);
+	return [
+		{
+			kind: "status",
+			status: statusFact(state, "subscription-acked", {
+				topic: command.topic,
+				subscriptionId: command.subscriptionId,
+				nextSeq: sub.nextSeq,
+				commandId: command.commandId,
+			}),
+		},
+	];
+}
+
+function seekSubscription(
+	state: MessageBusState,
+	command: Extract<MessageBusCommand, { kind: "seek" }>,
+): RuntimeEvent[] {
+	const topic = state.topics.get(command.topic);
+	if (topic === undefined)
+		return issueEvents(state, command, "unknown-topic", `unknown topic '${command.topic}'`);
+	const sub = getSubscription(state, command.topic, command.subscriptionId);
+	if (sub === undefined)
+		return issueEvents(
+			state,
+			command,
+			"unknown-subscription",
+			`unknown subscription '${command.subscriptionId}'`,
+		);
+	if (sub.closed)
+		return issueEvents(state, command, "subscription-closed", "subscription is closed");
+	if (command.nextSeq < topic.headSeq)
+		return issueEvents(state, command, "retention-gap", "seek is before retained headSeq");
+	if (command.nextSeq > topic.nextSeq)
+		return issueEvents(state, command, "cursor-out-of-range", "seek is beyond topic tail");
+	sub.nextSeq = command.nextSeq;
+	sub.retentionGap = false;
+	return [
+		{
+			kind: "status",
+			status: statusFact(state, "subscription-sought", {
+				topic: command.topic,
+				subscriptionId: command.subscriptionId,
+				nextSeq: sub.nextSeq,
+				commandId: command.commandId,
+			}),
+		},
+	];
+}
+
+function closeSubscription(
+	state: MessageBusState,
+	command: Extract<MessageBusCommand, { kind: "close-subscription" }>,
+): RuntimeEvent[] {
+	if (!state.topics.has(command.topic))
+		return issueEvents(state, command, "unknown-topic", `unknown topic '${command.topic}'`);
+	const sub = getSubscription(state, command.topic, command.subscriptionId);
+	if (sub === undefined)
+		return issueEvents(
+			state,
+			command,
+			"unknown-subscription",
+			`unknown subscription '${command.subscriptionId}'`,
+		);
+	sub.closed = true;
+	return [
+		{
+			kind: "status",
+			status: statusFact(state, "subscription-closed", {
+				topic: command.topic,
+				subscriptionId: command.subscriptionId,
+				nextSeq: sub.nextSeq,
+				commandId: command.commandId,
+			}),
+		},
+	];
+}
+
+function issueEvents(
+	state: MessageBusState,
+	command: unknown,
+	code: string,
+	message: string,
+): RuntimeEvent[] {
+	const topic = commandTopic(command);
+	const commandId = commandIdOf(command);
+	const issue: DataIssue = {
+		kind: "issue",
+		code,
+		message,
+		severity: "error",
+		source: "messageBus",
+		details: command,
+		metadata: topic === undefined ? undefined : { topic },
+	};
+	const entry: MessageBusDeadLetterEntry = {
+		entrySeq: ++state.deadLetterSeq,
+		...(topic === undefined ? {} : { topic }),
+		...(isObjectRecord(command) ? { command: command as MessageBusCommand } : {}),
+		issue,
+		timestampMs: state.now(),
+	};
+	state.deadLetters.push(entry);
+	return [
+		{ kind: "issue", issue },
+		{ kind: "dead-letter", entry },
+		{
+			kind: "status",
+			status: statusFact(state, "command-rejected", {
+				topic,
+				commandId,
+				issueCode: code,
+			}),
+		},
+	];
+}
+
+function rejectCommand(state: MessageBusState, command: unknown, reason: string): RuntimeEvent[] {
+	return issueEvents(state, command, "malformed-command", reason);
+}
+
+function duplicateCommandEvents(
+	state: MessageBusState,
+	command: MessageBusCommand,
+	message: string,
+): RuntimeEvent[] {
+	const status = statusFact(state, "duplicate-command", {
+		topic: "topic" in command ? command.topic : undefined,
+		commandId: command.commandId,
+	});
+	if (state.dedupe.commandId === "issue") {
+		return [
+			{ kind: "status", status },
+			...issueEvents(state, command, "duplicate-command", message),
+		];
+	}
+	return [{ kind: "status", status }];
+}
+
+function statusFact(
+	state: MessageBusState,
+	kind: MessageBusStatus["kind"],
+	fields: Partial<MessageBusStatus>,
+): MessageBusStatus {
+	return {
+		kind,
+		timestampMs: state.now(),
+		...(fields.topic === undefined ? {} : { topic: fields.topic }),
+		...(fields.seq === undefined ? {} : { seq: fields.seq }),
+		...(fields.headSeq === undefined ? {} : { headSeq: fields.headSeq }),
+		...(fields.subscriptionId === undefined ? {} : { subscriptionId: fields.subscriptionId }),
+		...(fields.nextSeq === undefined ? {} : { nextSeq: fields.nextSeq }),
+		...(fields.commandId === undefined ? {} : { commandId: fields.commandId }),
+		...(fields.issueCode === undefined ? {} : { issueCode: fields.issueCode }),
+		...(fields.details === undefined ? {} : { details: fields.details }),
+	};
+}
+
+function validateCommand(command: unknown): string | undefined {
+	if (!isObjectRecord(command)) return "command must be an object";
+	if (typeof command.kind !== "string") return "command kind is required";
+	if (!isMessageBusCommandKind(command.kind)) return `unknown command kind '${command.kind}'`;
+	if ("topic" in command) {
+		if (typeof command.topic !== "string") return "messageBus: topic must be a non-empty string";
+		const topicError = validateTopicKey(command.topic, "messageBus");
+		if (topicError !== undefined) return topicError;
+	}
+	if ("subscriptionId" in command && typeof command.subscriptionId !== "string") {
+		return "subscriptionId must be a string";
+	}
+	if (command.kind === "publish" && command.payload === undefined)
+		return "publish payload is required";
+	if (command.kind === "ack" && !isPositiveSeq(command.seq))
+		return "ack seq must be a positive integer";
+	if (command.kind === "seek" && !isPositiveSeq(command.nextSeq)) {
+		return "seek nextSeq must be a positive integer";
+	}
+	if (
+		command.kind === "topic-policy" &&
+		command.topicPolicy !== "strict" &&
+		command.topicPolicy !== "create-as-fact"
+	) {
+		return "topicPolicy is not recognized";
+	}
+	return undefined;
+}
+
+function isMessageBusCommandKind(kind: string): kind is MessageBusCommand["kind"] {
+	return (
+		kind === "ensure-topic" ||
+		kind === "close-topic" ||
+		kind === "publish" ||
+		kind === "topic-policy" ||
+		kind === "ack" ||
+		kind === "seek" ||
+		kind === "close-subscription"
+	);
+}
+
+function catalogPage(
+	state: MessageBusState,
+	params: MessageBusCatalogParams,
+): MessageBusCatalogPage {
+	const limit = positiveLimit(params.limit);
+	const topics = [...state.topics.entries()]
+		.filter(
+			([topic, value]) =>
+				(params.includeClosed ? true : !value.closed) &&
+				(params.afterTopic === undefined || topic > params.afterTopic),
+		)
+		.sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0));
+	const page = topics.slice(0, limit);
+	const hasMore = topics.length > limit;
+	return {
+		topics: page.map(([topic, value]) => ({
+			topic,
+			closed: value.closed,
+			headSeq: value.headSeq,
+			nextSeq: value.nextSeq,
+			messageCount: value.messages.length,
+		})),
+		...(hasMore && page.length > 0 ? { nextAfterTopic: page[page.length - 1]?.[0] } : {}),
+		hasMore,
+	};
+}
+
+function topicPage<T>(
+	state: MessageBusState,
+	topicName: string,
+	params: MessageBusTopicParams,
+): MessageBusTopicPage<T> {
+	const topic = state.topics.get(topicName);
+	const start = params.afterSeq === undefined ? (topic?.headSeq ?? 1) : params.afterSeq + 1;
+	const all = (topic?.messages ?? []).filter((message) => message.seq >= start);
+	const limit = positiveLimit(params.limit);
+	const messages = all.slice(0, limit) as MessageBusMessage<T>[];
+	const hasMore = all.length > limit;
+	return {
+		topic: topicName,
+		messages,
+		fromSeq: start,
+		...(messages.length > 0 ? { throughSeq: messages[messages.length - 1]?.seq } : {}),
+		...(hasMore && messages.length > 0 ? { nextAfterSeq: messages[messages.length - 1]?.seq } : {}),
+		hasMore,
+	};
+}
+
+function availablePage<T>(
+	state: MessageBusState,
+	sub: SubscriptionState,
+	params: MessageBusAvailableParams,
+): MessageBusAvailablePage<T> {
+	const cursor = cursorSnapshot(state, sub);
+	const start = params.afterSeq === undefined ? sub.nextSeq : params.afterSeq + 1;
+	const topic = state.topics.get(sub.topic);
+	const all = sub.retentionGap
+		? []
+		: (topic?.messages ?? []).filter((message) => message.seq >= start);
+	const limit = positiveLimit(params.limit);
+	const messages = all.slice(0, limit) as MessageBusMessage<T>[];
+	const hasMore = all.length > limit;
+	return {
+		topic: sub.topic,
+		subscriptionId: sub.subscriptionId,
+		cursor,
+		messages,
+		fromSeq: start,
+		...(messages.length > 0 ? { throughSeq: messages[messages.length - 1]?.seq } : {}),
+		...(hasMore && messages.length > 0 ? { nextAfterSeq: messages[messages.length - 1]?.seq } : {}),
+		hasMore,
+	};
+}
+
+function deadLetterPage<T>(
+	state: MessageBusState,
+	params: MessageBusDeadLetterParams,
+): MessageBusDeadLetterPage<T> {
+	const limit = positiveLimit(params.limit);
+	const entries = state.deadLetters.filter((entry) => {
+		if (params.afterEntrySeq !== undefined && entry.entrySeq <= params.afterEntrySeq) return false;
+		if (params.topic !== undefined && entry.topic !== params.topic) return false;
+		if (params.code !== undefined && entry.issue.code !== params.code) return false;
+		return true;
+	});
+	const page = entries.slice(0, limit) as MessageBusDeadLetterEntry<T>[];
+	const hasMore = entries.length > limit;
+	return {
+		entries: page,
+		...(hasMore && page.length > 0 ? { nextAfterEntrySeq: page[page.length - 1]?.entrySeq } : {}),
+		hasMore,
+	};
+}
+
+function cursorSnapshot(state: MessageBusState, sub: SubscriptionState): MessageBusCursor {
+	const topic = state.topics.get(sub.topic);
+	return {
+		topic: sub.topic,
+		subscriptionId: sub.subscriptionId,
+		nextSeq: sub.nextSeq,
+		closed: sub.closed,
+		retentionGap: sub.retentionGap,
+		headSeq: topic?.headSeq ?? 1,
+	};
+}
+
+function ensureSubscription(
+	state: MessageBusState,
+	opts: { topic: string; subscriptionId: string; from: "earliest" | "latest" | number },
+): SubscriptionState {
+	const key = `${opts.topic}\u0000${opts.subscriptionId}`;
+	const existing = state.subscriptions.get(key);
+	if (existing !== undefined) return existing;
+	const topic = state.topics.get(opts.topic);
+	const nextSeq =
+		opts.from === "earliest"
+			? (topic?.headSeq ?? 1)
+			: opts.from === "latest"
+				? (topic?.nextSeq ?? 1)
+				: opts.from;
+	const sub: SubscriptionState = {
+		topic: opts.topic,
+		subscriptionId: opts.subscriptionId,
+		nextSeq,
+		closed: false,
+		retentionGap: topic !== undefined && nextSeq < topic.headSeq,
+	};
+	state.subscriptions.set(key, sub);
+	return sub;
+}
+
+function getSubscription(
+	state: MessageBusState,
+	topic: string,
+	subscriptionId: string,
+): SubscriptionState | undefined {
+	return state.subscriptions.get(`${topic}\u0000${subscriptionId}`);
+}
diff --git a/packages/ts/src/messaging/internal.ts b/packages/ts/src/messaging/internal.ts
new file mode 100644
index 00000000..55057dbd
--- /dev/null
+++ b/packages/ts/src/messaging/internal.ts
@@ -0,0 +1,66 @@
+import type { NodeFn } from "../ctx/types.js";
+import type { Graph } from "../graph/graph.js";
+import type { Node } from "../node/node.js";
+import type { MessageBusCommand } from "./index.js";
+
+export interface MessageBusInternalState {
+	readonly graph: Graph;
+	readonly name: string;
+	readonly commandSources: Node<MessageBusCommand>[];
+	readonly commandBody: NodeFn;
+}
+
+const busStates = new WeakMap<object, MessageBusInternalState>();
+
+export function registerMessageBusState(bus: object, state: MessageBusInternalState): void {
+	busStates.set(bus, state);
+}
+
+export function getMessageBusState(bus: object): MessageBusInternalState | undefined {
+	return busStates.get(bus);
+}
+
+export function attachMessageBusCommandSource(
+	graph: Graph,
+	bus: object,
+	commands: Node<MessageBusCommand>,
+): () => void {
+	const state = getMessageBusState(bus);
+	if (state === undefined) throw new Error("messageBus: unknown implementation");
+	if (state.graph !== graph) throw new Error("messageBus: command source graph must match");
+	state.commandSources.push(commands);
+	const busCommands = (bus as { readonly commands?: Node<MessageBusCommand> }).commands;
+	if (busCommands === undefined) throw new Error("messageBus: missing commands node");
+	busCommands.replaceDeps([...state.commandSources], state.commandBody);
+	let released = false;
+	return () => {
+		if (released) return;
+		released = true;
+		const index = state.commandSources.indexOf(commands);
+		if (index >= 0) state.commandSources.splice(index, 1);
+		busCommands.replaceDeps([...state.commandSources], state.commandBody);
+	};
+}
+
+export function attachMessageBusDeferredCommandSink(
+	graph: Graph,
+	bus: object,
+	commands: Node<MessageBusCommand>,
+): () => void {
+	const state = getMessageBusState(bus);
+	if (state === undefined) throw new Error("messageBus: unknown implementation");
+	if (state.graph !== graph) throw new Error("messageBus: command sink graph must match");
+	const busCommands = (bus as { readonly commands?: Node<MessageBusCommand> }).commands;
+	if (busCommands === undefined) throw new Error("messageBus: missing commands node");
+	const boundary = commands as Node<MessageBusCommand> & {
+		__deferBoundary?: (fn: () => void) => void;
+	};
+	const unsubscribe = commands.subscribe((msg) => {
+		if (msg[0] !== "DATA") return;
+		const command = msg[1] as MessageBusCommand;
+		const send = () => busCommands.down([["DATA", command]]);
+		if (boundary.__deferBoundary === undefined) send();
+		else boundary.__deferBoundary(send);
+	});
+	return unsubscribe;
+}
diff --git a/packages/ts/src/messaging/runtime-types.ts b/packages/ts/src/messaging/runtime-types.ts
new file mode 100644
index 00000000..a1388db8
--- /dev/null
+++ b/packages/ts/src/messaging/runtime-types.ts
@@ -0,0 +1,51 @@
+import type { NodeFn } from "../ctx/types.js";
+import type { DataIssue } from "../data/index.js";
+import type { Graph } from "../graph/graph.js";
+import type { Node } from "../node/node.js";
+import type {
+	MessageBusCommand,
+	MessageBusDeadLetterEntry,
+	MessageBusDedupePolicy,
+	MessageBusMessage,
+	MessageBusRetentionPolicy,
+	MessageBusStatus,
+	MessageBusTopicPolicy,
+} from "./types.js";
+
+export interface TopicState {
+	closed: boolean;
+	headSeq: number;
+	nextSeq: number;
+	messages: MessageBusMessage[];
+}
+
+export interface SubscriptionState {
+	topic: string;
+	subscriptionId: string;
+	nextSeq: number;
+	closed: boolean;
+	retentionGap: boolean;
+}
+
+export type RuntimeEvent<T = unknown> =
+	| { readonly kind: "message"; readonly message: MessageBusMessage<T> }
+	| { readonly kind: "status"; readonly status: MessageBusStatus }
+	| { readonly kind: "issue"; readonly issue: DataIssue }
+	| { readonly kind: "dead-letter"; readonly entry: MessageBusDeadLetterEntry<T> };
+
+export interface MessageBusState {
+	readonly graph: Graph;
+	readonly name: string;
+	readonly now: () => number;
+	topicPolicy: MessageBusTopicPolicy;
+	readonly retention: MessageBusRetentionPolicy;
+	readonly dedupe: MessageBusDedupePolicy;
+	readonly topics: Map<string, TopicState>;
+	readonly subscriptions: Map<string, SubscriptionState>;
+	readonly seenCommandIds: Set<string>;
+	readonly seenIdempotencyKeys: Set<string>;
+	readonly deadLetters: MessageBusDeadLetterEntry[];
+	deadLetterSeq: number;
+	readonly commandSources: Node<MessageBusCommand>[];
+	readonly commandBody: NodeFn;
+}
diff --git a/packages/ts/src/messaging/types.ts b/packages/ts/src/messaging/types.ts
new file mode 100644
index 00000000..9f4b417d
--- /dev/null
+++ b/packages/ts/src/messaging/types.ts
@@ -0,0 +1,327 @@
+import type { DataIssue } from "../data/index.js";
+import type { Node } from "../node/node.js";
+import type { LockId } from "../protocol/messages.js";
+
+export interface MessageEnvelope<T = unknown> {
+	readonly topic: string;
+	readonly seq: number;
+	readonly payload: T;
+	readonly key?: string;
+	readonly idempotencyKey?: string;
+	readonly timestampMs: number;
+	readonly commandId?: string;
+}
+
+/** Minimal JSON Schema vocabulary for passive topic payload descriptions (D125/D132). */
+export interface JsonSchema {
+	readonly type?:
+		| "string"
+		| "number"
+		| "integer"
+		| "boolean"
+		| "object"
+		| "array"
+		| "null"
+		| readonly ("string" | "number" | "integer" | "boolean" | "object" | "array" | "null")[];
+	readonly properties?: Readonly<Record<string, JsonSchema>>;
+	readonly required?: readonly string[];
+	readonly additionalProperties?: boolean | JsonSchema;
+	readonly items?: JsonSchema | readonly JsonSchema[];
+	readonly enum?: readonly unknown[];
+	readonly const?: unknown;
+	readonly $ref?: string;
+	readonly definitions?: Readonly<Record<string, JsonSchema>>;
+	readonly description?: string;
+	readonly title?: string;
+}
+
+/** Passive envelope for payloads that cross topic, agent, or graph boundaries. */
+export interface TopicMessage<T = unknown> {
+	readonly id: string;
+	readonly schema?: JsonSchema;
+	readonly expiresAt?: string;
+	readonly correlationId?: string;
+	readonly payload: T;
+}
+
+/** Passive domain event vocabulary for messageBus/eventFlow composition (D329). */
+export interface EventMessage<T = unknown> {
+	readonly id: string;
+	readonly type: string;
+	readonly payload: T;
+	readonly key?: string;
+	readonly subjectId?: string;
+	readonly correlationId?: string;
+	readonly causationId?: string;
+	readonly occurredAtMs?: number;
+	readonly actor?: string;
+	readonly evidenceRefs?: readonly string[];
+	readonly schema?: JsonSchema;
+	readonly metadata?: Readonly<Record<string, unknown>>;
+}
+
+export interface EventMessageOptions {
+	readonly id: string;
+	readonly key?: string;
+	readonly subjectId?: string;
+	readonly correlationId?: string;
+	readonly causationId?: string;
+	readonly occurredAtMs?: number;
+	readonly actor?: string;
+	readonly evidenceRefs?: readonly string[];
+	readonly schema?: JsonSchema;
+	readonly metadata?: Readonly<Record<string, unknown>>;
+}
+
+export const PROMPTS_TOPIC = "prompts";
+export const RESPONSES_TOPIC = "responses";
+export const INJECTIONS_TOPIC = "injections";
+export const DEFERRED_TOPIC = "deferred";
+export const SPAWNS_TOPIC = "spawns";
+export const CONTEXT_TOPIC = "context";
+export const TODOS_TOPIC = "todos";
+
+export const STANDARD_TOPICS = Object.freeze([
+	PROMPTS_TOPIC,
+	RESPONSES_TOPIC,
+	INJECTIONS_TOPIC,
+	DEFERRED_TOPIC,
+	SPAWNS_TOPIC,
+	CONTEXT_TOPIC,
+	TODOS_TOPIC,
+] as const);
+
+export type StandardTopic = (typeof STANDARD_TOPICS)[number];
+
+export type MessageBusTopicPolicy = "strict" | "create-as-fact";
+
+export interface MessageBusRetentionPolicy {
+	/** Count retention. Trimming advances headSeq and never rewrites seq (D284). */
+	readonly maxMessages?: number;
+}
+
+export interface MessageBusDedupePolicy {
+	/** Duplicate commandId emits status and never publishes a second retained message (D284). */
+	readonly commandId?: "status" | "issue";
+}
+
+export interface MessageBusOptions<TTopic extends string = string> {
+	readonly topics?: readonly TTopic[];
+	readonly name?: string;
+	readonly now?: () => number;
+	readonly topicPolicy?: MessageBusTopicPolicy;
+	readonly retention?: MessageBusRetentionPolicy;
+	readonly dedupe?: MessageBusDedupePolicy;
+}
+
+export type MessageBusCommand<T = unknown> =
+	| {
+			readonly kind: "ensure-topic";
+			readonly topic: string;
+			readonly commandId?: string;
+	  }
+	| {
+			readonly kind: "close-topic";
+			readonly topic: string;
+			readonly commandId?: string;
+	  }
+	| {
+			readonly kind: "publish";
+			readonly topic: string;
+			readonly payload: T;
+			readonly key?: string;
+			readonly commandId?: string;
+			readonly idempotencyKey?: string;
+	  }
+	| {
+			readonly kind: "topic-policy";
+			readonly topicPolicy: MessageBusTopicPolicy;
+			readonly commandId?: string;
+	  }
+	| {
+			readonly kind: "ack";
+			readonly topic: string;
+			readonly subscriptionId: string;
+			readonly seq: number;
+			readonly commandId?: string;
+	  }
+	| {
+			readonly kind: "seek";
+			readonly topic: string;
+			readonly subscriptionId: string;
+			readonly nextSeq: number;
+			readonly commandId?: string;
+	  }
+	| {
+			readonly kind: "close-subscription";
+			readonly topic: string;
+			readonly subscriptionId: string;
+			readonly commandId?: string;
+	  };
+
+export type MessageBusMessage<T = unknown> = MessageEnvelope<T>;
+
+export interface MessageBusStatus {
+	readonly kind:
+		| "topic-created"
+		| "topic-closed"
+		| "message-published"
+		| "retention-trimmed"
+		| "duplicate-command"
+		| "subscription-acked"
+		| "subscription-sought"
+		| "subscription-closed"
+		| "command-rejected"
+		| "projection-ready"
+		| "projection-partial";
+	readonly topic?: string;
+	readonly seq?: number;
+	readonly headSeq?: number;
+	readonly subscriptionId?: string;
+	readonly nextSeq?: number;
+	readonly commandId?: string;
+	readonly issueCode?: string;
+	readonly timestampMs: number;
+	readonly details?: unknown;
+}
+
+export interface MessageBusCatalogEntry {
+	readonly topic: string;
+	readonly closed: boolean;
+	readonly headSeq: number;
+	readonly nextSeq: number;
+	readonly messageCount: number;
+}
+
+export interface MessageBusCatalogPage {
+	readonly topics: readonly MessageBusCatalogEntry[];
+	readonly nextAfterTopic?: string;
+	readonly hasMore: boolean;
+}
+
+export interface MessageBusDeadLetterEntry<T = unknown> {
+	readonly entrySeq: number;
+	readonly topic?: string;
+	readonly command?: MessageBusCommand<T>;
+	readonly message?: MessageBusMessage<T>;
+	readonly issue: DataIssue;
+	readonly timestampMs: number;
+}
+
+export interface MessageBusDeadLetterPage<T = unknown> {
+	readonly entries: readonly MessageBusDeadLetterEntry<T>[];
+	readonly nextAfterEntrySeq?: number;
+	readonly hasMore: boolean;
+}
+
+export interface MessageBusTopicPage<T = unknown> {
+	readonly topic: string;
+	readonly messages: readonly MessageBusMessage<T>[];
+	readonly fromSeq: number;
+	readonly throughSeq?: number;
+	readonly nextAfterSeq?: number;
+	readonly hasMore: boolean;
+}
+
+export interface MessageBusCursor {
+	readonly topic: string;
+	readonly subscriptionId: string;
+	readonly nextSeq: number;
+	readonly closed: boolean;
+	readonly retentionGap: boolean;
+	readonly headSeq: number;
+}
+
+export interface MessageBusAvailablePage<T = unknown> {
+	readonly topic: string;
+	readonly subscriptionId: string;
+	readonly cursor: MessageBusCursor;
+	readonly messages: readonly MessageBusMessage<T>[];
+	readonly fromSeq: number;
+	readonly throughSeq?: number;
+	readonly nextAfterSeq?: number;
+	readonly hasMore: boolean;
+}
+
+export interface MessageBusPageParams {
+	readonly limit?: number;
+}
+
+export interface MessageBusCatalogParams extends MessageBusPageParams {
+	readonly afterTopic?: string;
+	readonly includeClosed?: boolean;
+}
+
+export interface MessageBusDeadLetterParams extends MessageBusPageParams {
+	readonly afterEntrySeq?: number;
+	readonly topic?: string;
+	readonly code?: string;
+}
+
+export interface MessageBusTopicParams extends MessageBusPageParams {
+	readonly afterSeq?: number;
+}
+
+export interface MessageBusAvailableParams extends MessageBusPageParams {
+	readonly afterSeq?: number;
+}
+
+export interface MessageBusPullProjection<TPage> {
+	readonly snapshot: Node<TPage>;
+	readonly snapshotPullId: LockId;
+	readonly status: Node<MessageBusStatus>;
+	readonly issues: Node<DataIssue>;
+}
+
+export interface MessageBusTopicProjection<T = unknown>
+	extends MessageBusPullProjection<MessageBusTopicPage<T>> {}
+
+export interface MessageBusSubscription<T = unknown> {
+	readonly available: Node<MessageBusAvailablePage<T>>;
+	readonly availablePullId: LockId;
+	readonly cursor: Node<MessageBusCursor>;
+	readonly status: Node<MessageBusStatus>;
+	readonly issues: Node<DataIssue>;
+	ack(seq: number, opts?: { commandId?: string }): MessageBusCommand;
+	seek(nextSeq: number, opts?: { commandId?: string }): MessageBusCommand;
+	close(opts?: { commandId?: string }): MessageBusCommand;
+}
+
+export interface MessageBus<TTopic extends string = string> {
+	readonly commands: Node<MessageBusCommand>;
+	readonly messages: Node<MessageBusMessage>;
+	readonly status: Node<MessageBusStatus>;
+	readonly issues: Node<DataIssue>;
+	ensureTopic(topic: TTopic | string, opts?: { commandId?: string }): MessageBusCommand;
+	closeTopic(topic: TTopic | string, opts?: { commandId?: string }): MessageBusCommand;
+	publish<T = unknown>(
+		topic: TTopic | string,
+		payload: T,
+		opts?: { key?: string; commandId?: string; idempotencyKey?: string },
+	): MessageBusCommand<T>;
+	topic<T = unknown>(
+		topic: TTopic | string,
+		opts?: { name?: string },
+	): MessageBusTopicProjection<T>;
+	catalog(opts?: { name?: string }): MessageBusPullProjection<MessageBusCatalogPage>;
+	deadLetter<T = unknown>(opts?: {
+		name?: string;
+	}): MessageBusPullProjection<MessageBusDeadLetterPage<T>>;
+	subscription<T = unknown>(opts: {
+		topic: TTopic | string;
+		subscriptionId: string;
+		from?: "earliest" | "latest" | number;
+		name?: string;
+	}): MessageBusSubscription<T>;
+}
+
+export interface ToTopicOptions {
+	readonly name?: string;
+	readonly keyOf?: (value: unknown) => string | undefined;
+	readonly commandIdOf?: (value: unknown) => string | undefined;
+}
+
+export interface ToTopicBundle<T> {
+	readonly commands: Node<MessageBusCommand<T>>;
+	release(): void;
+}
diff --git a/packages/ts/src/messaging/utils.ts b/packages/ts/src/messaging/utils.ts
new file mode 100644
index 00000000..2c872fa8
--- /dev/null
+++ b/packages/ts/src/messaging/utils.ts
@@ -0,0 +1,76 @@
+import type { Node } from "../node/node.js";
+import type { PullDemand } from "../protocol/messages.js";
+import type { MessageBusCommand } from "./types.js";
+
+export function pullParams<T>(pull: PullDemand | undefined): T {
+	return (isObjectRecord(pull?.params) ? pull.params : {}) as T;
+}
+
+export function publishCommand<T extends MessageBusCommand>(
+	commandNode: Node<MessageBusCommand>,
+	command: T,
+): T {
+	commandNode.down([["DATA", command]]);
+	return command;
+}
+
+export function makeTopicState(): {
+	closed: boolean;
+	headSeq: number;
+	nextSeq: number;
+	messages: [];
+} {
+	return { closed: false, headSeq: 1, nextSeq: 1, messages: [] };
+}
+
+export function uniqueTopics(topics: readonly string[]): readonly string[] {
+	const unique = [...new Set(topics)];
+	if (unique.length !== topics.length) throw new Error("messageBus: duplicate topic");
+	for (const topic of unique) assertTopicKey(topic, "messageBus");
+	return Object.freeze(unique.sort());
+}
+
+export function assertTopicKey(topic: string, owner: string): void {
+	const error = validateTopicKey(topic, owner);
+	if (error !== undefined) throw new Error(error);
+}
+
+export function validateTopicKey(topic: string, owner: string): string | undefined {
+	if (typeof topic !== "string" || topic.length === 0)
+		return `${owner}: topic must be a non-empty string`;
+	return undefined;
+}
+
+export function assertNonEmpty(value: string, owner: string): void {
+	if (typeof value !== "string" || value.length === 0)
+		throw new Error(`${owner}: must be a non-empty string`);
+}
+
+export function positiveLimit(limit: number | undefined): number {
+	if (limit === undefined) return 100;
+	if (!Number.isInteger(limit) || limit < 1)
+		throw new Error("messageBus: limit must be a positive integer");
+	return limit;
+}
+
+export function isPositiveSeq(value: unknown): value is number {
+	return Number.isInteger(value) && (value as number) >= 1;
+}
+
+export function isObjectRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+export function commandTopic(command: unknown): string | undefined {
+	return isObjectRecord(command) && typeof command.topic === "string" ? command.topic : undefined;
+}
+
+export function commandIdOf(command: unknown): string | undefined {
+	return isObjectRecord(command) && typeof command.commandId === "string"
+		? command.commandId
+		: undefined;
+}
+
+export function idempotencyKey(topic: string, key: string): string {
+	return `${topic}\u0000${key}`;
+}
diff --git a/packages/ts/src/node/core.ts b/packages/ts/src/node/core.ts
new file mode 100644
index 00000000..4775419a
--- /dev/null
+++ b/packages/ts/src/node/core.ts
@@ -0,0 +1,291 @@
+import type { Ctx, Sink } from "../ctx/types.js";
+import type { Dispatcher, Handle } from "../dispatcher/index.js";
+import type { EnvironmentDrivers } from "../graph/environment.js";
+import { type LockId, type PullDemand, SENTINEL, type Wave } from "../protocol/messages.js";
+import type { Node, Status } from "./node.js";
+import type { NodeVersion, ResolvedNodeVersioningPolicy } from "./versioning.js";
+
+export type NodeId = number & { readonly __nodeId: unique symbol };
+
+export interface DepBookkeeping {
+	batch: Array<unknown[] | null>;
+	waveData: unknown[][][];
+	waveTokens: Array<object | undefined>;
+	prev: unknown[];
+	hasData: boolean[];
+	dirty: boolean[];
+	tier: number[];
+	terminal: Array<true | unknown | undefined>;
+	terminalInput: Array<true | unknown | undefined>;
+	unsubs: Array<() => void>;
+	idxBoxes: Array<{ v: number }>;
+}
+
+export interface ValueState<T> {
+	cache: T | undefined;
+	hasData: boolean;
+	status: Status;
+	terminal: true | unknown | undefined;
+	hasTorndown: boolean;
+	replayRing: T[];
+}
+
+export interface VersionState {
+	policy: ResolvedNodeVersioningPolicy;
+	value: NodeVersion | undefined;
+}
+
+export interface WaveState {
+	pending: number;
+	hasCalledFnOnce: boolean;
+	emittedDirtyThisWave: boolean;
+	emittedSettleThisWave: boolean;
+	insideRunWave: boolean;
+	inDepMutation: boolean;
+	rewireRunPending: boolean;
+	batchDirtyOwed: boolean;
+}
+
+export interface ControlState {
+	pauseLockset: Set<unknown>;
+	pausedDepWaveOccurred: boolean;
+	pauseBuffer: Wave[];
+	demandOwed: PullDemand | undefined;
+	activePull: PullDemand | undefined;
+	pullDirtyOwed: boolean;
+	inDeliverDemand: boolean;
+}
+
+export interface PrivateState {
+	value: unknown;
+	persist: boolean;
+}
+
+export interface CleanupHooks {
+	onDeactivation: Array<() => void>;
+	onInvalidate: Array<() => void>;
+}
+
+export interface SyncCtxState {
+	value: Ctx | null;
+}
+
+export interface LifecycleState {
+	subscribers: Set<Sink>;
+	activated: boolean;
+}
+
+export interface BoundaryTask {
+	apply: () => void;
+	batchToken?: object;
+	isReady?: () => boolean;
+}
+
+export interface BoundaryState {
+	queue: BoundaryTask[];
+	head: number;
+}
+
+export interface NodeSlot<_T> {
+	id: NodeId;
+	deps: Node<unknown>[];
+	handle: Handle | null;
+	pool: "sync" | "async";
+	dispatcher: Dispatcher;
+	environment: EnvironmentDrivers;
+	partial: boolean;
+	terminalAsRealInput: boolean;
+	completeWhenDepsComplete: boolean;
+	errorWhenDepsError: boolean;
+	resubscribable: boolean;
+	resetOnTeardown: boolean;
+	pausable: boolean | "resumeAll";
+	pull: boolean;
+	pullLock: LockId | undefined;
+	replayN: number;
+	dynamic: boolean;
+	name?: string;
+	factory?: string;
+}
+
+export interface NodeState<T> {
+	dep: DepBookkeeping;
+	lifecycle: LifecycleState;
+	value: ValueState<T>;
+	version: VersionState;
+	wave: WaveState;
+	control: ControlState;
+	privateState: PrivateState;
+	hooks: CleanupHooks;
+	syncCtx: SyncCtxState;
+}
+
+export class NodeCore {
+	private nextId = 0;
+	private readonly slots: Array<NodeSlot<unknown> | undefined> = [];
+	private readonly values: Array<ValueState<unknown> | undefined> = [];
+	private readonly waves: Array<WaveState | undefined> = [];
+	private readonly controls: Array<ControlState | undefined> = [];
+	private readonly lifecycles: Array<LifecycleState | undefined> = [];
+	private readonly depStates: Array<DepBookkeeping | undefined> = [];
+	private readonly privateStates: Array<PrivateState | undefined> = [];
+	private readonly hooks: Array<CleanupHooks | undefined> = [];
+	private readonly syncCtxs: Array<SyncCtxState | undefined> = [];
+	private readonly versionStates: Array<VersionState | undefined> = [];
+	private readonly boundary: BoundaryState = { queue: [], head: 0 };
+
+	createSlot<T>(
+		slot: Omit<NodeSlot<T>, "id">,
+		state: NodeState<T>,
+	): { id: NodeId; slot: NodeSlot<T> } {
+		const id = this.nextId++ as NodeId;
+		const full = { ...slot, id };
+		this.slots[id] = full as NodeSlot<unknown>;
+		this.depStates[id] = state.dep;
+		this.lifecycles[id] = state.lifecycle;
+		this.values[id] = state.value as ValueState<unknown>;
+		this.waves[id] = state.wave;
+		this.controls[id] = state.control;
+		this.privateStates[id] = state.privateState;
+		this.hooks[id] = state.hooks;
+		this.syncCtxs[id] = state.syncCtx;
+		this.versionStates[id] = state.version;
+		return { id, slot: full };
+	}
+
+	get<T>(id: NodeId): NodeSlot<T> {
+		const slot = this.slots[id];
+		if (slot === undefined) throw new Error("NodeCore: unknown node slot");
+		return slot as NodeSlot<T>;
+	}
+
+	getValue<T>(id: NodeId): ValueState<T> {
+		const value = this.values[id];
+		if (value === undefined) throw new Error("NodeCore: unknown node value state");
+		return value as ValueState<T>;
+	}
+
+	getWave(id: NodeId): WaveState {
+		const wave = this.waves[id];
+		if (wave === undefined) throw new Error("NodeCore: unknown node wave state");
+		return wave;
+	}
+
+	getControl(id: NodeId): ControlState {
+		const control = this.controls[id];
+		if (control === undefined) throw new Error("NodeCore: unknown node control state");
+		return control;
+	}
+
+	getLifecycle(id: NodeId): LifecycleState {
+		const lifecycle = this.lifecycles[id];
+		if (lifecycle === undefined) throw new Error("NodeCore: unknown node lifecycle state");
+		return lifecycle;
+	}
+
+	getDep(id: NodeId): DepBookkeeping {
+		const dep = this.depStates[id];
+		if (dep === undefined) throw new Error("NodeCore: unknown node dep state");
+		return dep;
+	}
+
+	getPrivateState(id: NodeId): PrivateState {
+		const state = this.privateStates[id];
+		if (state === undefined) throw new Error("NodeCore: unknown node private state");
+		return state;
+	}
+
+	getHooks(id: NodeId): CleanupHooks {
+		const hooks = this.hooks[id];
+		if (hooks === undefined) throw new Error("NodeCore: unknown node cleanup hooks");
+		return hooks;
+	}
+
+	getSyncCtx(id: NodeId): SyncCtxState {
+		const state = this.syncCtxs[id];
+		if (state === undefined) throw new Error("NodeCore: unknown node ctx state");
+		return state;
+	}
+
+	getVersion(id: NodeId): VersionState {
+		const state = this.versionStates[id];
+		if (state === undefined) throw new Error("NodeCore: unknown node version state");
+		return state;
+	}
+
+	/** @internal D122: release graph-owned ephemeral node runtime state from core retention. */
+	releaseSlot(id: NodeId): void {
+		this.slots[id] = undefined;
+		this.depStates[id] = undefined;
+		this.lifecycles[id] = undefined;
+		this.values[id] = undefined;
+		this.waves[id] = undefined;
+		this.controls[id] = undefined;
+		this.privateStates[id] = undefined;
+		this.hooks[id] = undefined;
+		this.syncCtxs[id] = undefined;
+		this.versionStates[id] = undefined;
+	}
+
+	/** @internal B49: graph-local deferred-boundary queue (rewireNext/upNext/batch-after-commit). */
+	enqueueBoundaryTask(task: BoundaryTask): void {
+		this.boundary.queue.push(task);
+	}
+
+	/** @internal */
+	hasBoundaryTasks(): boolean {
+		return this.boundary.head < this.boundary.queue.length;
+	}
+
+	/** @internal */
+	boundaryTaskCount(): number {
+		return this.boundary.queue.length - this.boundary.head;
+	}
+
+	/** @internal */
+	shiftBoundaryTask(): BoundaryTask | undefined {
+		if (!this.hasBoundaryTasks()) {
+			this.boundary.queue = [];
+			this.boundary.head = 0;
+			return undefined;
+		}
+		const task = this.boundary.queue[this.boundary.head++];
+		if (!this.hasBoundaryTasks()) {
+			this.boundary.queue = [];
+			this.boundary.head = 0;
+		}
+		return task;
+	}
+
+	/** @internal Put a not-yet-ready task back at this core's FIFO head. */
+	unshiftBoundaryTask(task: BoundaryTask): void {
+		const remaining = this.boundary.queue.slice(this.boundary.head);
+		this.boundary.queue = [task, ...remaining];
+		this.boundary.head = 0;
+	}
+
+	/** @internal D110: discard all pending tasks caused by an uncommitted batch. */
+	dropBoundaryTasksForBatch(batchToken: object): void {
+		const remaining = this.boundary.queue
+			.slice(this.boundary.head)
+			.filter((task) => task.batchToken !== batchToken);
+		this.boundary.queue = remaining;
+		this.boundary.head = 0;
+	}
+}
+
+export function makeDepBookkeeping(depCount: number): DepBookkeeping {
+	return {
+		batch: new Array(depCount).fill(null),
+		waveData: Array.from({ length: depCount }, () => []),
+		waveTokens: new Array(depCount).fill(undefined),
+		prev: new Array(depCount).fill(SENTINEL),
+		hasData: new Array(depCount).fill(false),
+		dirty: new Array(depCount).fill(false),
+		tier: new Array(depCount).fill(0),
+		terminal: new Array(depCount).fill(undefined),
+		terminalInput: new Array(depCount).fill(undefined),
+		unsubs: [],
+		idxBoxes: [],
+	};
+}
diff --git a/packages/ts/src/node/node-context-runtime.ts b/packages/ts/src/node/node-context-runtime.ts
new file mode 100644
index 00000000..c1b4b263
--- /dev/null
+++ b/packages/ts/src/node/node-context-runtime.ts
@@ -0,0 +1,119 @@
+import { enterWave, exitWave } from "../batch/boundary.js";
+import {
+	CTX_DEP_CACHE,
+	CTX_NODE_BINDING,
+	type Ctx,
+	type CtxState,
+	type TerminalData,
+	type WaveData,
+} from "../ctx/types.js";
+import type { PullDemand } from "../protocol/messages.js";
+import type { Node } from "./node.js";
+import type { NodeRuntimeHost } from "./node-runtime-host.js";
+import { terminalView } from "./protocol-guards.js";
+import { withEnvironmentDrivers, withNodeCore } from "./runtime-accessors.js";
+
+export function nodeBuildCtx<T>(self: NodeRuntimeHost<T>): Ctx {
+	const kind = self._slot.handle
+		? self._slot.dispatcher.poolKind(self._slot.handle.poolId)
+		: "sync";
+	if (kind === "sync") {
+		if (self._syncCtx === null) self._syncCtx = self._makeCtx();
+		self._refreshCtx(self._syncCtx);
+		return self._syncCtx;
+	}
+	// async: snapshot dep inputs so a deferred late-emit reads this wave's view.
+	return self._makeCtx({
+		waveData: self._dep.waveData.map((waves) => waves.map((w) => [...w])),
+		terminal: self._dep.terminalInput.map(terminalView),
+		latest: [...self._dep.prev],
+	});
+}
+
+export function nodeMakeCtx<T>(
+	self: NodeRuntimeHost<T>,
+	snapshot?: { waveData: unknown[][][]; terminal: unknown[]; latest: unknown[] },
+): Ctx {
+	const ctx: Ctx = {
+		// Wave-owner boundary (D47): a SYNC fn's emit nests under the public entry that drove
+		// it (cheap inc/dec, no early drain); an ASYNC-pool fn re-enters here from its stashed
+		// ctx at depth 0, so this is the boundary that drains any rewireNext it issued.
+		up: (msgs, towardDep) => {
+			if (self._released) return;
+			enterWave();
+			try {
+				self._up(msgs, towardDep);
+			} finally {
+				exitWave();
+			}
+		},
+		down: (msgs) => {
+			if (self._released) return;
+			enterWave();
+			try {
+				self._down(msgs);
+			} finally {
+				exitWave();
+			}
+		},
+		waveData: snapshot?.waveData ?? self._dep.waveData,
+		terminal: snapshot?.terminal ?? self._dep.terminalInput.map(terminalView),
+		state: self._makeState(),
+		onDeactivation: (fn) => {
+			if (self._released) return;
+			self._hooks.onDeactivation.push(fn);
+		},
+		onInvalidate: (fn) => {
+			if (self._released) return;
+			self._hooks.onInvalidate.push(fn);
+		},
+		environment: () => self._slot.environment,
+		// R-rewire-deferred (D47): defer a self-dep-set mutation to the committed boundary.
+		rewireNext: {
+			subscribeDep: (dep, fn) => self._requestRewireNext({ kind: "add", dep, fn }),
+			unsubscribeDep: (dep, fn) => self._requestRewireNext({ kind: "remove", dep, fn }),
+			replaceDeps: (deps, fn) => self._requestRewireNext({ kind: "set", deps, fn }),
+		},
+		// R-up-routing / R-pull (D269): deferred up — route a control/demand wave (e.g. PULL)
+		// up the declared cone at the committed boundary. The SELF-demand path: an
+		// immediate ctx.up whose delivery loops back re-enters this fn (D37 / R-reentrancy).
+		upNext: (msgs, towardDep) => self._requestUpNext(msgs, towardDep),
+		...(self._control.activePull === undefined ? {} : { pull: self._control.activePull }),
+		[CTX_DEP_CACHE]: { latest: snapshot?.latest ?? self._dep.prev },
+		[CTX_NODE_BINDING]: {
+			dispatcher: self._slot.dispatcher,
+			create: <U>(factory: () => Node<U>) =>
+				withEnvironmentDrivers(self._slot.environment, () => withNodeCore(self._core, factory)),
+		},
+	};
+	if (self._slot.dynamic) {
+		// R-dynamic-node: read a dep's latest by index. Untracked deps still drive waves and
+		// re-run the fn; under D49 (no equals-substitution) the fn re-emits its current value
+		// as DATA — to suppress redundant downstream propagation, pair with distinctUntilChanged.
+		ctx.track = (i: number) => ctx[CTX_DEP_CACHE]?.latest[i];
+	}
+	return ctx;
+}
+
+export function nodeRefreshCtx<T>(self: NodeRuntimeHost<T>, ctx: Ctx): void {
+	(ctx as { waveData: WaveData }).waveData = self._dep.waveData;
+	(ctx as { terminal: TerminalData }).terminal = self._dep.terminalInput.map(terminalView);
+	if (self._control.activePull === undefined) {
+		delete (ctx as { pull?: PullDemand }).pull;
+	} else {
+		(ctx as { pull?: PullDemand }).pull = self._control.activePull;
+	}
+	ctx[CTX_DEP_CACHE] = { latest: self._dep.prev };
+}
+
+export function nodeMakeState<T>(self: NodeRuntimeHost<T>): CtxState {
+	return {
+		get: <S>() => self._privateState.value as S | undefined,
+		set: <S>(v: S) => {
+			self._privateState.value = v;
+		},
+		persist: (on = true) => {
+			self._privateState.persist = on;
+		},
+	};
+}
diff --git a/packages/ts/src/node/node-input-runtime.ts b/packages/ts/src/node/node-input-runtime.ts
new file mode 100644
index 00000000..90c58f69
--- /dev/null
+++ b/packages/ts/src/node/node-input-runtime.ts
@@ -0,0 +1,334 @@
+import type { DeliveryMeta } from "../ctx/types.js";
+import type { Handle } from "../dispatcher/index.js";
+import type { Message } from "../protocol/messages.js";
+import { isTerminal, SENTINEL } from "../protocol/messages.js";
+import type { NodeRuntimeHost } from "./node-runtime-host.js";
+
+export function nodeRecordDepProjection<T>(
+	self: NodeRuntimeHost<T>,
+	idx: number,
+	delivery: DeliveryMeta | undefined,
+): unknown[] {
+	const token = delivery?.wave ?? {};
+	if (self._dep.waveTokens[idx] !== token) {
+		self._dep.waveData[idx].push([]);
+		self._dep.waveTokens[idx] = token;
+	}
+	return self._dep.waveData[idx][self._dep.waveData[idx].length - 1];
+}
+
+export function nodeDepProjectionHasData<T>(self: NodeRuntimeHost<T>, idx: number): boolean {
+	const projection = self._dep.waveData[idx][self._dep.waveData[idx].length - 1];
+	return projection?.some((v) => v !== SENTINEL) ?? false;
+}
+
+export function nodeReceiveFromDep<T>(
+	self: NodeRuntimeHost<T>,
+	idx: number,
+	msg: Message,
+	delivery?: DeliveryMeta,
+): void {
+	if (self._released) return;
+	const t = msg[0];
+	if (t === "START") return;
+	const isLastInDeliveredWave = delivery?.last ?? true;
+	// Terminal-is-forever, except terminal intermediates still relay upstream TEARDOWN
+	// downstream for lifecycle unwire (R-teardown-terminal-relay / D65).
+	if (self._value.terminal !== undefined) {
+		if (t === "TEARDOWN") self._down([["TEARDOWN"]]);
+		return;
+	}
+
+	if (t === "INVALIDATE") {
+		const projection = self._recordDepProjection(idx, delivery);
+		projection.push(SENTINEL);
+		if (projection.some((v) => v !== SENTINEL) && isLastInDeliveredWave) self._maybeRun();
+		// The dep's value is gone — drop our cached latest view to SENTINEL so the
+		// never-emitted detector reads correctly, C-3) and cascade (idempotent).
+		self._dep.prev[idx] = SENTINEL;
+		self._dep.hasData[idx] = false;
+		self._dep.batch[idx] = null;
+		// EC3: un-wedge the dirty bookkeeping if this dep had gone DIRTY first, so an
+		// INVALIDATE-before-DATA doesn't strand _pending / downstream forever
+		// (R-invalidate-idempotent — exists to prevent the wedged-DIRTY deadlock).
+		if (self._dep.dirty[idx]) {
+			self._dep.dirty[idx] = false;
+			self._wave.pending--;
+		}
+		// D50 / R-paused-invalidate: this INVALIDATE SUPERSEDES the dep's buffered
+		// paused dep-wave (_depBatch[idx] just cleared). Re-derive the paused-recompute
+		// flag — if no dep still carries a buffered DATA, CANCEL the paused recompute
+		// (attributed cancellation; the node has settled to SENTINEL via its own
+		// INVALIDATE, so a RESUME must not recompute against a now-SENTINEL dep). A
+		// surviving dep keeps it set; a later DATA re-arms it ([DATA,INVALIDATE,DATA2]).
+		if (self._control.pausedDepWaveOccurred && self._dep.batch.every((b) => b === null)) {
+			self._control.pausedDepWaveOccurred = false;
+		}
+		const hadData = self._value.hasData;
+		self._invalidate(); // cascades INVALIDATE iff populated; no-op otherwise
+		// If we broadcast DIRTY this wave but _invalidate produced no settle (the node
+		// was never populated, so the cascade is suppressed per the rule), un-dirty
+		// downstream with a RESOLVED once all deps have settled.
+		if (self._wave.pending === 0 && self._wave.emittedDirtyThisWave) {
+			if (!hadData) self._down([["RESOLVED"]]);
+			else self._wave.emittedDirtyThisWave = false;
+		}
+		self._fireOwedDemandIfReady(); // R-pull (D59/B1/F6): an INVALIDATE settle can drain _pending → fire a deferred demand
+		return;
+	}
+
+	if (isTerminal(t)) {
+		// Tier 5 (R-tier / D34): COMPLETE | ERROR — ONE branch routed by the CENTRAL tier table,
+		// not a per-variant string check (feedback_use_tier_for_signal_routing). The shared terminal
+		// bookkeeping (record the terminal + release the in-wave DIRTY) runs for ANY tier-5 message;
+		// only the COMPLETE-vs-ERROR cascade differs, so discriminate by the type within the tier.
+		const isError = t === "ERROR";
+		const errPayload = isError ? (msg as readonly ["ERROR", unknown])[1] : undefined;
+		self._dep.terminal[idx] = isError ? errPayload : true;
+		self._dep.terminalInput[idx] = isError ? errPayload : true;
+		// R-terminal-settles-dirty (B35): a terminal RELEASES this dep's outstanding in-wave DIRTY
+		// contribution (the exactly-one-settle invariant) — exactly as DATA/RESOLVED/INVALIDATE do
+		// (a dirty-then-terminal-without-DATA dep would otherwise strand _pending and wedge the node,
+		// the deadlock R-invalidate-idempotent prevents for INVALIDATE).
+		self._releaseDepDirty(idx);
+		const ranValueBeforeTerminal = self._depProjectionHasData(idx) && isLastInDeliveredWave;
+		if (ranValueBeforeTerminal) self._maybeRun();
+		if (isError && self._slot.errorWhenDepsError) {
+			self._down([["ERROR", errPayload]]); // auto-cascade ERROR → node itself terminal
+		} else if (self._slot.terminalAsRealInput) {
+			if (ranValueBeforeTerminal) {
+				self._fireOwedDemandIfReady();
+				return;
+			}
+			self._maybeRun(); // rescue/reduce/catch/*Map: the fn reads depTerminal(ctx, idx)
+		} else if (self._slot.completeWhenDepsComplete && self._allDepsTerminal()) {
+			// R-deps-terminal auto-COMPLETE + B42: COMPLETE once ALL deps are TERMINAL (each COMPLETE
+			// or an absorbed ERROR) — so an absorbed-error dep terminating LAST still fires the
+			// cascade. terminalAsRealInput is checked FIRST so a rescue recovers via _maybeRun rather
+			// than being preempted (no operator sets both completeWhenDepsComplete:true + tari:true).
+			self._down([["COMPLETE"]]);
+		} else {
+			// absorbed terminal, NOT an input + not auto-completing: the dep's signalled change did
+			// not materialise (no DATA) → un-dirty downstream, keep cache (R-resolved-undirty balance).
+			self._settleAfterAbsorbedTerminal();
+		}
+		self._fireOwedDemandIfReady(); // R-pull (D59/B1/F6): a dep terminal can drain _pending → fire a deferred demand (no-op if this node went terminal)
+		return;
+	}
+
+	if (t === "TEARDOWN") {
+		self._down([["TEARDOWN"]]);
+		return;
+	}
+
+	if (t === "DIRTY") {
+		if (!self._dep.dirty[idx]) {
+			self._dep.dirty[idx] = true;
+			self._wave.pending++;
+			self._dep.tier[idx] = 2;
+			self._markDirty();
+		}
+		return;
+	}
+
+	if (t === "DATA") {
+		const v = msg[1];
+		self._recordDepProjection(idx, delivery).push(v);
+		const b = self._dep.batch[idx];
+		if (b === null) self._dep.batch[idx] = [v];
+		else b.push(v);
+		self._dep.prev[idx] = v;
+		self._dep.hasData[idx] = true;
+		self._dep.tier[idx] = 3;
+		if (self._dep.dirty[idx]) {
+			self._dep.dirty[idx] = false;
+			self._wave.pending--;
+		}
+		if (isLastInDeliveredWave) self._maybeRun();
+		self._fireOwedDemandIfReady(); // R-pull pin 5: settle-ready now → fire a deferred demand
+		return;
+	}
+
+	if (t === "RESOLVED") {
+		self._recordDepProjection(idx, delivery);
+		self._dep.tier[idx] = 3;
+		if (self._dep.dirty[idx]) {
+			self._dep.dirty[idx] = false;
+			self._wave.pending--;
+		}
+		if (isLastInDeliveredWave) self._maybeRun();
+		self._fireOwedDemandIfReady(); // R-pull pin 5: settle-ready now → fire a deferred demand
+		return;
+	}
+	// PAUSE / RESUME are not delivered downstream to a dep-subscriber; a node is
+	// paused via its own up() (lockset), not by an upstream dep.
+}
+
+export function nodeReleaseDepDirty<T>(self: NodeRuntimeHost<T>, idx: number): void {
+	if (self._dep.dirty[idx]) {
+		self._dep.dirty[idx] = false;
+		self._wave.pending--;
+	}
+}
+
+export function nodeSettleAfterAbsorbedTerminal<T>(self: NodeRuntimeHost<T>): void {
+	if (self._wave.pending !== 0 || !self._wave.emittedDirtyThisWave) return;
+	// A real value occurred this wave (some OTHER dep delivered DATA) → recompute. _maybeRun
+	// runs the fn ONLY if it's not gated (first-run gate open, not paused); it may emit DATA, a
+	// fn-synthesized undirty RESOLVED, or nothing (gated / gate still holds).
+	const sawData = self._dep.batch.some((b) => b !== null && b.length > 0);
+	if (sawData) self._maybeRun();
+	// If after that the node STILL owes a downstream settle (no DATA occurred, OR the recompute
+	// was gated — e.g. the first-run gate holds because the terminated dep never delivered and
+	// terminalAsRealInput is false), balance the broadcast DIRTY with one undirty RESOLVED
+	// (R-resolved-undirty), keeping the cache (a terminal, unlike INVALIDATE, leaves the value).
+	// Without this fallback a DIRTY-then-terminal-without-DATA dep on a pre-first-run multi-dep
+	// node would strand the DIRTY → downstream wedged (the B35 class, in the gate-holds corner).
+	if (self._wave.emittedDirtyThisWave) self._down([["RESOLVED"]]);
+}
+
+export function nodeMarkDirty<T>(self: NodeRuntimeHost<T>): void {
+	self._value.status = "dirty";
+	// SPIKE (protocol-pull): while quiet, ABSORB the upstream DIRTY — do NOT relay it downstream.
+	// This is the P0b wedge fix: a quiet pull node that relayed DIRTY but withheld the settle
+	// (coalesced by pause) wedged every downstream's two-phase _pending. The downstream learns of
+	// changes via the push STREAM port, not the silent snapshot port; on demand the pull node
+	// emits a fresh wave. Internal dep dirty-accounting (the DIRTY-branch _pending++) is untouched.
+	if (self._isPullQuiet()) return;
+	if (!self._wave.emittedDirtyThisWave) {
+		self._wave.emittedDirtyThisWave = true;
+		self._emitToSubs(["DIRTY"]);
+	}
+}
+
+export function nodeMaybeRun<T>(self: NodeRuntimeHost<T>): void {
+	// R-rewire: an added cached dep's push-on-subscribe lands here mid-mutation. Defer
+	// the fn-run to ONE atomic two-phase settle after every added dep is wired, so the
+	// fn never fires on a partially-populated added-dep view (multi-add) — _settleRewire
+	// drains this flag.
+	if (self._wave.inDepMutation) {
+		self._wave.rewireRunPending = true;
+		return;
+	}
+	// R-pause-modes + R-pull: while externally paused or pull-quiet, default pull mode
+	// coalesces. `resumeAll` still runs so its outgoing settle slice can enter pauseBuffer.
+	if (self._slot.pausable === true && (self._isPaused() || self._isPullQuiet())) {
+		self._control.pausedDepWaveOccurred = true;
+		return;
+	}
+	self._tryRun();
+}
+
+export function nodeSettleRewire<T>(self: NodeRuntimeHost<T>): void {
+	if (self._slot.pausable === true && self._isPaused()) {
+		self._control.pausedDepWaveOccurred = true;
+		return;
+	}
+	if (self._wave.pending > 0) return;
+	if (self._slot.handle === null) {
+		self._passthroughEmit();
+		return;
+	}
+	if (!self._wave.hasCalledFnOnce && !(self._slot.partial || self._allDepsSettled())) return;
+	self._markDirty(); // phase 1 (no-op if already dirty, e.g. unsubscribeDep auto-settle)
+	self._runWave(); // phase 2: fn → DATA/RESOLVED
+}
+
+export function nodeTryRun<T>(self: NodeRuntimeHost<T>): void {
+	if (self._wave.pending > 0) return;
+	if (self._slot.handle === null) {
+		// Passthrough wire (deps, no fn): forward the latest dep DATA downstream.
+		self._passthroughEmit();
+		return;
+	}
+	if (!self._wave.hasCalledFnOnce) {
+		if (self._slot.partial || self._allDepsSettled()) self._runWave();
+		// else: first-run gate holds fn until every dep has settled (R-first-run-gate).
+		return;
+	}
+	self._runWave();
+}
+
+export function nodeAllDepsSettled<T>(self: NodeRuntimeHost<T>): boolean {
+	for (let i = 0; i < self._slot.deps.length; i++) {
+		if (self._dep.hasData[i]) continue;
+		if (self._slot.terminalAsRealInput && self._dep.terminal[i] !== undefined) continue;
+		return false;
+	}
+	return true;
+}
+
+export function nodePassthroughEmit<T>(self: NodeRuntimeHost<T>): void {
+	// Single-dep wire: relay dep 0's latest batch value as DATA.
+	const b = self._dep.batch[0];
+	if (b !== null && b.length > 0) {
+		self._down([["DATA", b[b.length - 1]]]);
+	} else if (self._wave.emittedDirtyThisWave) {
+		// R-resolved-undirty (D49): the dep settled via an undirty RESOLVED (no DATA in the
+		// batch), but this wire already broadcast DIRTY downstream this wave — balance it with
+		// a RESOLVED so downstream un-dirties instead of wedging. Routed through _down (NOT a
+		// bare _emitToSubs) so the balance respects batch-defer (D12) + pause-buffer, matching
+		// the zero-dep un-dirty path. Without this, a passthrough over a filter-reject /
+		// distinctUntilChanged-dup leaves a dangling DIRTY (the wedge D49 made common).
+		self._down([["RESOLVED"]]);
+	}
+	self._dep.batch[0] = null;
+	self._wave.emittedDirtyThisWave = false;
+}
+
+export function nodeRunWave<T>(self: NodeRuntimeHost<T>): void {
+	// R-reentrancy (D37): a fn that re-drives its own dep mid-wave re-enters here while
+	// _insideRunWave is still set — a synchronous feedback cycle. Reject (throw); the graph
+	// layer catches it and converts to [[ERROR, e]] (D30). The try/finally resets the flag
+	// on every frame as the throw unwinds, leaving the graph clean for the catch. Detection
+	// is node-local and free — it reuses the existing _insideRunWave flag (no new structure,
+	// dispatcher stays a pure funnel).
+	if (self._wave.insideRunWave)
+		throw new Error(
+			"synchronous feedback cycle: node fn re-entered its own wave (R-reentrancy / D37)",
+		);
+	self._wave.hasCalledFnOnce = true;
+	// R-cleanup-hooks per-run lifecycle (D28 clarification): clear BOTH hook lists
+	// before the fn runs; the fn body re-registers the current run's hooks. Only the
+	// latest run's registrations are live — a re-run supersedes the prior run's hooks,
+	// discarded WITHOUT firing (no fire-on-rerun; onRerun stays cut). Fixes the push-only
+	// accumulation (K stale hooks fired after K runs). C-14.
+	self._hooks.onInvalidate = [];
+	self._hooks.onDeactivation = [];
+	const ctx = self._buildCtx();
+	const wasDirty = self._wave.emittedDirtyThisWave;
+	self._wave.emittedSettleThisWave = false;
+	self._wave.insideRunWave = true;
+	try {
+		self._slot.dispatcher.invoke(self._slot.handle as Handle, ctx);
+	} finally {
+		self._wave.insideRunWave = false;
+	}
+
+	// R-resolved-undirty (D49): a SYNC fn DIRTY'd in phase 1 that produced NO tier-3 value
+	// this wave (filter-reject / distinctUntilChanged-dup / any no-emit fn) gets a substrate-
+	// SYNTHESIZED undirty RESOLVED to clear the downstream dirty — operator bodies stay
+	// protocol-clean (R-primary-api-clean). Status reflects cache freshness: a carried value
+	// -> resolved, never-valued -> sentinel. EXEMPT: terminal/INVALIDATE waves (they set
+	// _emittedSettleThisWave and balance their own dirty), and ASYNC-pool nodes — an async fn
+	// that returns without emitting has DEFERRED its result (it emits later via the stashed
+	// ctx), NOT rejected; synthesizing here would prematurely settle a still-pending diamond
+	// leg (R-async-paused / C-4). The eventual async ctx.down carries its own DIRTY balance.
+	if (
+		wasDirty &&
+		!self._wave.emittedSettleThisWave &&
+		self._value.terminal === undefined &&
+		!self._isAsyncPool()
+	) {
+		self._down([["RESOLVED"]]);
+	}
+
+	// roll wave-local state forward
+	for (let i = 0; i < self._dep.batch.length; i++) {
+		self._dep.batch[i] = null;
+		self._dep.waveData[i] = [];
+		self._dep.waveTokens[i] = undefined;
+		self._dep.terminalInput[i] = undefined;
+	}
+	self._wave.emittedDirtyThisWave = false;
+}
diff --git a/packages/ts/src/node/node-lifecycle-runtime.ts b/packages/ts/src/node/node-lifecycle-runtime.ts
new file mode 100644
index 00000000..35d97862
--- /dev/null
+++ b/packages/ts/src/node/node-lifecycle-runtime.ts
@@ -0,0 +1,220 @@
+import { SENTINEL } from "../protocol/messages.js";
+import type { Node } from "./node.js";
+import { type NodeRuntimeHost, nodeRuntimeHost } from "./node-runtime-host.js";
+import {
+	activationReaders,
+	checkpointReaders,
+	ownerTokens,
+	releasedNodes,
+	restoreWriters,
+	runtimeQuiescenceReaders,
+	runtimeReleasers,
+	subscriberCountReaders,
+	topologyDepsChangedObservers,
+} from "./runtime-accessors.js";
+
+export function nodeActivate<T>(self: NodeRuntimeHost<T>): void {
+	self._lifecycle.activated = true;
+	const seedRestoredDeps = self._restoredActivationPending;
+	self._restoredActivationPending = false;
+	// R-pull (D55/D272): activePull is undefined before wiring deps, so each dep's
+	// push-on-subscribe DIRTY/DATA is absorbed quietly, not relayed downstream.
+	self._dep.unsubs = new Array(self._slot.deps.length);
+	self._dep.idxBoxes = new Array(self._slot.deps.length);
+	for (const dep of self._slot.deps) self._subscribeDepAt(dep, { seedRestored: seedRestoredDeps });
+	// Depless producer (fn, no deps): run once on activation.
+	if (self._slot.deps.length === 0 && self._slot.handle !== null && !self._wave.hasCalledFnOnce) {
+		self._runWave();
+	}
+}
+
+export function nodeSubscribeDepAt<T>(
+	self: NodeRuntimeHost<T>,
+	depNode: Node<unknown>,
+	opts: { seedRestored?: boolean } = {},
+): void {
+	const idx0 = self._slot.deps.indexOf(depNode);
+	const box = { v: idx0 };
+	let ignoreInitialPush = opts.seedRestored === true;
+	if (ignoreInitialPush && idx0 !== -1) {
+		self._seedRestoredDepAt(idx0, depNode);
+		const dep = nodeRuntimeHost(depNode);
+		if (dep._value.terminal !== undefined && !dep._slot.resubscribable) {
+			self._dep.unsubs[idx0] = () => {};
+			self._dep.idxBoxes[idx0] = box;
+			return;
+		}
+	}
+	const unsub = depNode.subscribe((msg, delivery) => {
+		if (ignoreInitialPush && delivery === undefined) return;
+		if (ignoreInitialPush) ignoreInitialPush = false;
+		if (box.v === -1) return; // dep removed — stale callback, drop (drain)
+		self._receiveFromDep(box.v, msg, delivery);
+	});
+	if (ignoreInitialPush && idx0 !== -1 && box.v !== -1) self._seedRestoredDepAt(idx0, depNode);
+	ignoreInitialPush = false;
+	if (idx0 !== -1) {
+		self._dep.unsubs[idx0] = unsub;
+		self._dep.idxBoxes[idx0] = box;
+	}
+}
+
+export function nodeSeedRestoredDepAt<T>(
+	self: NodeRuntimeHost<T>,
+	idx: number,
+	depNode: Node<unknown>,
+): void {
+	const dep = nodeRuntimeHost(depNode);
+	const seedData = dep._value.hasData && !dep._slot.pull;
+	self._dep.batch[idx] = null;
+	self._dep.waveData[idx] = [];
+	self._dep.waveTokens[idx] = undefined;
+	self._dep.prev[idx] = seedData ? dep._value.cache : SENTINEL;
+	self._dep.hasData[idx] = seedData;
+	self._dep.dirty[idx] = false;
+	self._dep.tier[idx] = seedData ? 3 : 0;
+	self._dep.terminal[idx] = dep._value.terminal;
+	self._dep.terminalInput[idx] = undefined;
+}
+
+export function nodeDeactivate<T>(self: NodeRuntimeHost<T>): void {
+	self._lifecycle.activated = false;
+	for (const u of self._dep.unsubs) if (u) u();
+	self._dep.unsubs = [];
+	self._dep.idxBoxes = [];
+	for (const fn of self._hooks.onDeactivation) fn();
+	self._hooks.onDeactivation = [];
+	self._hooks.onInvalidate = [];
+
+	const isCompute = self._slot.handle !== null || self._slot.deps.length > 0;
+	if (isCompute) {
+		// RAM: compute nodes clear cache; reconnect re-runs fn fresh.
+		self._value.cache = SENTINEL;
+		self._value.hasData = false;
+		self._value.status = "sentinel";
+	}
+	self._resetDepState();
+	self._wave.hasCalledFnOnce = false;
+	self._control.pauseLockset.clear();
+	self._control.pauseBuffer = [];
+	self._control.pausedDepWaveOccurred = false;
+	self._control.demandOwed = undefined; // R-pull (D269): drop any deferred demand
+	self._control.activePull = undefined;
+	self._control.pullDirtyOwed = false;
+	self._value.replayRing = []; // BH6: don't replay stale values to a post-reactivation subscriber
+	if (!self._privateState.persist) self._privateState.value = SENTINEL;
+}
+
+export function nodeSubscriberCount<T>(self: NodeRuntimeHost<T>): number {
+	return self._lifecycle.subscribers.size;
+}
+
+export function nodeIsRuntimeQuiescentForRelease<T>(self: NodeRuntimeHost<T>): boolean {
+	return (
+		!self._released &&
+		self._value.status !== "dirty" &&
+		self._value.status !== "pending" &&
+		self._wave.pending === 0 &&
+		!self._wave.insideRunWave &&
+		!self._wave.inDepMutation &&
+		!self._wave.rewireRunPending &&
+		!self._wave.batchDirtyOwed &&
+		self._dep.dirty.every((dirty) => !dirty) &&
+		self._control.pauseBuffer.length === 0 &&
+		!self._control.pausedDepWaveOccurred &&
+		self._control.demandOwed === undefined &&
+		self._control.activePull === undefined &&
+		!self._control.inDeliverDemand &&
+		self._control.pauseLockset.size === 0
+	);
+}
+
+export function nodeReleaseRuntime<T>(self: NodeRuntimeHost<T>): void {
+	if (self._released) return;
+	self._released = true;
+	const node = self as unknown as Node<unknown>;
+	releasedNodes.add(node);
+	let releaseError: unknown;
+	const recordReleaseError = (error: unknown): void => {
+		if (releaseError === undefined) releaseError = error;
+	};
+	self._lifecycle.activated = false;
+	for (const u of self._dep.unsubs) {
+		try {
+			u();
+		} catch (error) {
+			recordReleaseError(error);
+			// D124 release is graph-owned and atomic; user cleanup must not split commit.
+		}
+	}
+	for (const fn of self._hooks.onDeactivation) {
+		try {
+			fn();
+		} catch (error) {
+			recordReleaseError(error);
+			// D124 release cleans runtime without synthesizing protocol ERROR/COMPLETE.
+		}
+	}
+	self._dep.unsubs = [];
+	self._dep.idxBoxes = [];
+	self._lifecycle.subscribers.clear();
+	if (self._slot.handle !== null) {
+		self._slot.dispatcher.unregister(self._slot.handle);
+		self._slot.handle = null;
+	}
+	self._slot.deps = [];
+	self._dep.batch = [];
+	self._dep.waveData = [];
+	self._dep.waveTokens = [];
+	self._dep.prev = [];
+	self._dep.hasData = [];
+	self._dep.dirty = [];
+	self._dep.tier = [];
+	self._dep.terminal = [];
+	self._dep.terminalInput = [];
+	self._value.cache = SENTINEL;
+	self._value.hasData = false;
+	self._value.status = "sentinel";
+	self._value.terminal = undefined;
+	self._value.replayRing = [];
+	self._privateState.value = SENTINEL;
+	self._privateState.persist = false;
+	self._syncCtx = null;
+	self._resetDepState();
+	self._hooks.onDeactivation = [];
+	self._hooks.onInvalidate = [];
+	self._control.pauseLockset.clear();
+	self._control.pauseBuffer = [];
+	self._control.pausedDepWaveOccurred = false;
+	self._control.demandOwed = undefined;
+	self._control.activePull = undefined;
+	self._control.pullDirtyOwed = false;
+	self._restoredActivationPending = false;
+	checkpointReaders.delete(node);
+	restoreWriters.delete(node);
+	runtimeReleasers.delete(node);
+	runtimeQuiescenceReaders.delete(node);
+	subscriberCountReaders.delete(node);
+	activationReaders.delete(node);
+	ownerTokens.delete(node);
+	topologyDepsChangedObservers.delete(node);
+	self._core.releaseSlot(self._id);
+	if (releaseError !== undefined) throw releaseError;
+}
+
+export function nodeResetDepState<T>(self: NodeRuntimeHost<T>): void {
+	const n = self._slot.deps.length;
+	for (let i = 0; i < n; i++) {
+		self._dep.batch[i] = null;
+		self._dep.waveData[i] = [];
+		self._dep.waveTokens[i] = undefined;
+		self._dep.prev[i] = SENTINEL;
+		self._dep.hasData[i] = false;
+		self._dep.dirty[i] = false;
+		self._dep.tier[i] = 0;
+		self._dep.terminal[i] = undefined;
+		self._dep.terminalInput[i] = undefined;
+	}
+	self._wave.pending = 0;
+	self._wave.emittedDirtyThisWave = false;
+}
diff --git a/packages/ts/src/node/node-output-runtime.ts b/packages/ts/src/node/node-output-runtime.ts
new file mode 100644
index 00000000..0a4cde7c
--- /dev/null
+++ b/packages/ts/src/node/node-output-runtime.ts
@@ -0,0 +1,524 @@
+import { currentBatch, deferToBatch } from "../batch/batch.js";
+import { deferRewire, scheduleBoundaryDrain } from "../batch/boundary.js";
+import type { DeliveryMeta } from "../ctx/types.js";
+import type { LockId, Message, PullDemand, Wave } from "../protocol/messages.js";
+import {
+	isDeferredTier,
+	isPauseBufferedTier,
+	isUpAllowed,
+	isValueTier,
+	messageTier,
+	SENTINEL,
+} from "../protocol/messages.js";
+import type { Node } from "./node.js";
+import { type NodeRuntimeHost, nodeRuntimeHost } from "./node-runtime-host.js";
+import { normalizePullDemand, validateDownPayloads } from "./protocol-guards.js";
+import type { UpRouteState } from "./types.js";
+import {
+	advanceNodeVersion,
+	assertNodeVersionDataCompatible,
+	snapshotNodeVersionData,
+} from "./versioning.js";
+
+export function nodeDown<T>(self: NodeRuntimeHost<T>, msgs: Wave): void {
+	if (self._released) return;
+	validateDownPayloads(msgs);
+	const deliveryWave = {};
+	const assertVersionDataCompatible = (wave: readonly Message[]) => {
+		for (const m of wave) {
+			if (m[0] === "DATA") assertNodeVersionDataCompatible(self._version.policy, m[1]);
+		}
+	};
+	const snapshotVersionData = (wave: readonly Message[]): Message[] =>
+		wave.map((m) =>
+			m[0] === "DATA"
+				? (["DATA", snapshotNodeVersionData(self._version.policy, m[1])] as Message)
+				: m,
+		);
+	assertVersionDataCompatible(msgs);
+	// Terminal-is-forever (R-terminal / D17 / B30): once COMPLETE/ERROR has been emitted the
+	// node is final — a self-emit (state.set / ctx.down) in a LATER wave is a no-op, never
+	// resurrecting the cache or re-emitting. The COMPLETE/ERROR arms below also self-guard
+	// against a double terminal, but DATA/RESOLVED/INVALIDATE had no entry guard, so a
+	// post-terminal set() would overwrite cache + emit DATA. R-teardown-terminal-relay / D65
+	// carves out the only post-terminal exception: TEARDOWN still relays downstream for unwire
+	// without reopening value output. A single wave that goes terminal mid-loop (e.g.
+	// [COMPLETE, TEARDOWN]) is unaffected: _terminal is still undefined at entry.
+	// Resubscribable reset clears _terminal before any re-emit.
+	if (self._value.terminal !== undefined) {
+		if (!msgs.some((m) => m[0] === "TEARDOWN")) return;
+		self._value.hasTorndown = true;
+		if (self._slot.resetOnTeardown) {
+			self._value.cache = SENTINEL;
+			self._value.hasData = false;
+		}
+		self._emitToSubs(["TEARDOWN"], { wave: deliveryWave, last: true });
+		return;
+	}
+	let sorted: Message[] = [...msgs].sort((a, b) => messageTier(a[0]) - messageTier(b[0]));
+	// R-same-wave-merge: collapse repeated INVALIDATE in one wave (Q9) so the
+	// cleanup hook + downstream broadcast fire at most once.
+	const firstInvalidate = sorted.findIndex((m) => m[0] === "INVALIDATE");
+	if (firstInvalidate !== -1) {
+		sorted = sorted.filter((m, i) => m[0] !== "INVALIDATE" || i === firstInvalidate);
+	}
+	// R-teardown-complete: a TEARDOWN reaching a non-terminal node synthesizes a
+	// COMPLETE prefix (so firstValueFrom-style bridges resolve), unless the wave
+	// already carries a terminal or the node already tore down.
+	const hasTeardown = sorted.some((m) => m[0] === "TEARDOWN");
+	const hasTerminal = sorted.some((m) => m[0] === "COMPLETE" || m[0] === "ERROR");
+	if (
+		hasTeardown &&
+		!hasTerminal &&
+		self._value.terminal === undefined &&
+		!self._value.hasTorndown
+	) {
+		sorted = [["COMPLETE"], ...sorted];
+	}
+	// R-batch-coalesce (D12): inside a batch, emit DIRTY immediately but defer the
+	// tier-3 settle slice to commit so a shared downstream recomputes once. Only
+	// external emits defer (fn emits during commit run normally).
+	if (!self._wave.insideRunWave && currentBatch()) {
+		const deferred = snapshotVersionData(sorted.filter((m) => isDeferredTier(m[0])));
+		if (deferred.length > 0) {
+			if (!self._wave.emittedDirtyThisWave) {
+				self._wave.emittedDirtyThisWave = true;
+				self._value.status = "dirty";
+				self._emitToSubs(["DIRTY"], { wave: deliveryWave, last: false });
+			}
+			self._wave.batchDirtyOwed = true; // BH1: owe a balancing RESOLVED on rollback
+			deferToBatch(self as unknown as Node<unknown>, deferred);
+			return;
+		}
+	}
+	// R-pause-modes / R-async-paused: defer the settle slice (tier 3/4) into the
+	// pause buffer while paused; tier 0-2 (DIRTY/PAUSE/RESUME), tier 5 (terminal),
+	// tier 6 (TEARDOWN) bypass so end-of-stream + control always reach observers.
+	if (self._shouldBufferOnPause()) {
+		const buffered = snapshotVersionData(sorted.filter((m) => isPauseBufferedTier(m[0])));
+		if (buffered.length > 0) {
+			// B36 / R-resolved-undirty: buffering a settle slice still means this fn wave
+			// produced a settle. Without this, _runWave sees "dirty + no settle" and
+			// synthesizes a RESOLVED that pierces the pause while the DATA waits in the buffer.
+			self._wave.emittedSettleThisWave = true;
+			self._control.pauseBuffer.push(buffered);
+		}
+		sorted = sorted.filter((m) => !isPauseBufferedTier(m[0]));
+		if (sorted.length === 0) return;
+	}
+	let dataCount = 0;
+	let hasTier3 = false;
+	let hasResolved = false;
+	for (const m of sorted) {
+		if (m[0] === "DATA") dataCount++;
+		if (m[0] === "RESOLVED") hasResolved = true;
+		if (isValueTier(m[0])) hasTier3 = true;
+	}
+	// EC2 / R-resolved-undirty tier-3 exclusivity: a wave's tier-3 slot is >=1 DATA
+	// (occurrence) XOR exactly 1 RESOLVED (undirty) — never mixed. Reject fail-fast.
+	if (dataCount >= 1 && hasResolved) {
+		throw new Error(
+			"down: a wave cannot mix DATA and RESOLVED (tier-3 exclusivity, R-resolved-undirty)",
+		);
+	}
+	const plannedVersions: Array<NodeVersion | undefined> = new Array(sorted.length);
+	if (dataCount > 0) {
+		let plannedVersion = self._version.value;
+		for (let i = 0; i < sorted.length; i++) {
+			const m = sorted[i];
+			if (m[0] !== "DATA") continue;
+			plannedVersion = advanceNodeVersion(plannedVersion, self._version.policy, m[1]);
+			plannedVersions[i] = plannedVersion;
+		}
+	}
+
+	// Synthesize a leading DIRTY for an EXTERNAL tier-3 emit (R-dirty-before-data), and for
+	// PULL demand fns only when they actually emit tier-3. A no-op pull helper must stay silent.
+	if (
+		hasTier3 &&
+		(!self._wave.insideRunWave || self._control.pullDirtyOwed) &&
+		!self._wave.emittedDirtyThisWave
+	) {
+		self._wave.emittedDirtyThisWave = true;
+		self._value.status = "dirty";
+		self._emitToSubs(["DIRTY"], { wave: deliveryWave, last: false });
+	}
+
+	for (let i = 0; i < sorted.length; i++) {
+		const m = sorted[i];
+		const delivery = { wave: deliveryWave, last: i === sorted.length - 1 };
+		// R-resolved-undirty (D49): a tier-3+ emit this wave means the fn produced a settle,
+		// so no synthesized undirty RESOLVED is owed (see _runWave).
+		if (isDeferredTier(m[0])) self._wave.emittedSettleThisWave = true;
+		if (m[0] === "DIRTY") {
+			if (!self._wave.emittedDirtyThisWave) {
+				self._wave.emittedDirtyThisWave = true;
+				self._value.status = "dirty";
+				self._emitToSubs(["DIRTY"], delivery);
+			}
+			continue;
+		}
+		if (m[0] === "DATA") {
+			const v = m[1] as T;
+			// R-resolved-undirty (D49): every value-occurrence is emitted as DATA — the
+			// substrate never substitutes DATA->RESOLVED on value-equality. Dedup is opt-in
+			// at the operator layer (distinctUntilChanged), never a substrate behavior.
+			self._value.cache = v;
+			self._value.hasData = true;
+			self._value.status = "settled";
+			self._version.value = plannedVersions[i];
+			if (self._slot.replayN > 0) {
+				self._value.replayRing.push(v);
+				if (self._value.replayRing.length > self._slot.replayN) self._value.replayRing.shift();
+			}
+			self._emitToSubs(["DATA", v], delivery);
+			continue;
+		}
+		if (m[0] === "RESOLVED") {
+			self._value.status = self._value.hasData ? "resolved" : "sentinel";
+			self._emitToSubs(["RESOLVED"], delivery);
+			continue;
+		}
+		if (m[0] === "INVALIDATE") {
+			self._invalidate(delivery);
+			continue;
+		}
+		if (m[0] === "COMPLETE") {
+			if (self._value.terminal !== undefined) continue;
+			self._value.terminal = true;
+			self._control.pauseBuffer = []; // BH3: terminal discards buffered settle slices
+			self._value.status = "completed";
+			self._emitToSubs(["COMPLETE"], delivery);
+			continue;
+		}
+		if (m[0] === "ERROR") {
+			if (self._value.terminal !== undefined) continue;
+			self._value.terminal = m[1];
+			self._control.pauseBuffer = []; // BH3: terminal discards buffered settle slices
+			self._value.status = "errored";
+			self._emitToSubs(["ERROR", m[1]], delivery);
+			continue;
+		}
+		if (m[0] === "TEARDOWN") {
+			self._value.hasTorndown = true;
+			if (self._slot.resetOnTeardown) {
+				self._value.cache = SENTINEL;
+				self._value.hasData = false;
+			}
+			self._emitToSubs(["TEARDOWN"], delivery);
+		}
+		// PAUSE / RESUME — control slice.
+	}
+
+	if (!self._wave.insideRunWave) self._wave.emittedDirtyThisWave = false;
+}
+
+export function nodeUp<T>(
+	self: NodeRuntimeHost<T>,
+	msgs: Wave,
+	towardDep?: number,
+	route?: UpRouteState,
+): void {
+	if (self._released) return;
+	const routeState = route ?? { demandFired: new Map() };
+	for (const m of msgs) {
+		if (!isUpAllowed(m[0])) {
+			throw new Error(
+				`ctx.up: ${m[0]} is down-only (tier ${messageTier(m[0])}); up carries control tiers only (R-ctx-up)`,
+			);
+		}
+	}
+	for (const m of msgs) {
+		if (m[0] === "PAUSE") {
+			// PAUSE is NODE-TARGETED (R-up-routing): it ACQUIRES a lock, so there is no
+			// pre-existing holder to route to — a controller targets the node directly.
+			self._pauseAcquire(m[1]);
+		} else if (m[0] === "RESUME") {
+			// R-up-routing (D269): RESUME is pause-lock release only.
+			if (self._control.pauseLockset.has(m[1])) {
+				// a pause lock held HERE → release LOCALLY (normal pause/resume, R-pause-lockset).
+				self._pauseRelease(m[1]);
+			} else {
+				// not held here → forward UP the declared cone to find the holder.
+				self._forwardUp(m, towardDep, routeState);
+			}
+		} else if (m[0] === "PULL") {
+			// R-up-routing / R-pull (D269/D272): DEMAND-IF-PULL-HOLDER-ELSE-FORWARD-UP.
+			const demand = normalizePullDemand(m[1]);
+			if (self._slot.pull && demand.pullId === self._slot.pullLock) {
+				if (!self._markDemandRouted(demand.pullId, routeState)) self._onDemand(demand);
+			} else {
+				self._forwardUp(["PULL", demand], towardDep, routeState);
+			}
+		} else if (self._slot.deps.length === 0) {
+			// R-up-at-source (D38): a depless source is the terminus of upstream control.
+			// INVALIDATE → HONOR the invalidate-request. Routed through _down (NOT a direct
+			// _invalidate call, QA A-2) so the invalidate-request respects batch-defer (D12)
+			// and pause-buffer exactly like a downstream-originated INVALIDATE; _down's
+			// INVALIDATE branch calls _invalidate() (clear cache → SENTINEL, fire onInvalidate,
+			// broadcast downstream). Outside batch/pause it is identical to a direct call.
+			// DIRTY / TEARDOWN → DROP (no coherent terminus action; self-dirty would wedge
+			// downstream awaiting a settle that never comes; source lifecycle is source-owned).
+			if (m[0] === "INVALIDATE") self._down([["INVALIDATE"]]);
+		} else {
+			// dep-bearing intermediate: forward DIRTY/INVALIDATE/TEARDOWN up toward deps.
+			self._forwardUp(m, towardDep, routeState);
+		}
+	}
+}
+
+export function nodeMarkDemandRouted<T>(
+	self: NodeRuntimeHost<T>,
+	lockId: LockId,
+	route: UpRouteState,
+): boolean {
+	let holders = route.demandFired.get(lockId);
+	if (holders === undefined) {
+		holders = new Set();
+		route.demandFired.set(lockId, holders);
+	}
+	const node = self as unknown as Node<unknown>;
+	if (holders.has(node)) return true;
+	holders.add(node);
+	return false;
+}
+
+export function nodeForwardUp<T>(
+	self: NodeRuntimeHost<T>,
+	m: Message,
+	towardDep: number | undefined,
+	route: UpRouteState,
+): void {
+	if (self._slot.deps.length === 0) return; // depless source terminus → drop
+	if (towardDep !== undefined) {
+		const d = self._slot.deps[towardDep];
+		if (d !== undefined) nodeRuntimeHost(d)._up([m], undefined, route);
+	} else {
+		for (const dep of self._slot.deps) nodeRuntimeHost(dep)._up([m], undefined, route);
+	}
+}
+
+export function nodeIsPaused<T>(self: NodeRuntimeHost<T>): boolean {
+	return self._control.pauseLockset.size > 0;
+}
+
+export function nodeHasBoundaryPauseLock<T>(self: NodeRuntimeHost<T>): boolean {
+	if (self._slot.pausable === false) return false;
+	return self._control.pauseLockset.size > 0;
+}
+
+export function nodeIsAsyncPool<T>(self: NodeRuntimeHost<T>): boolean {
+	return (
+		self._slot.handle !== null &&
+		self._slot.dispatcher.poolKind(self._slot.handle.poolId) === "async"
+	);
+}
+
+export function nodePauseAcquire<T>(self: NodeRuntimeHost<T>, lockId: unknown): void {
+	self._control.pauseLockset.add(lockId); // Set => same-id repeat PAUSE is idempotent
+}
+
+export function nodePauseRelease<T>(self: NodeRuntimeHost<T>, lockId: unknown): void {
+	if (!self._control.pauseLockset.has(lockId)) return; // unknown id => no-op
+	self._control.pauseLockset.delete(lockId);
+	// R-pull (D59 / D272): releasing an EXTERNAL pause lock can unblock an owed demand.
+	// Pull quiet is activePull-derived and never stored in pauseLockset.
+	if (self._slot.pull && self._control.demandOwed !== undefined) self._fireOwedDemandIfReady();
+	if (self._hasBoundaryPauseLock()) return; // another external lock still held => stay paused
+	scheduleBoundaryDrain(self._core);
+	if (self._slot.pull) return; // pull nodes stay quiet until PULL, even after external resume
+	self._onResume();
+}
+
+export function nodeOnResume<T>(self: NodeRuntimeHost<T>): void {
+	// BH3: a node that terminated while paused discards its buffer and never
+	// replays/recomputes (terminal-is-forever).
+	if (self._value.terminal !== undefined) {
+		self._control.pauseBuffer = [];
+		self._control.pausedDepWaveOccurred = false;
+		self._control.demandOwed = undefined;
+		self._control.activePull = undefined;
+		self._control.pullDirtyOwed = false;
+		return;
+	}
+	// Non-pull pause/resume (R-pause-modes): drain buffered settle slices (resumeAll /
+	// async-at-paused, R-async-paused), then fire a coalesced dep-wave once (default mode).
+	// A PULL node does not resume by draining here; its demand fires through _onDemand.
+	if (self._control.pauseBuffer.length > 0) {
+		const buf = self._control.pauseBuffer;
+		self._control.pauseBuffer = [];
+		for (const wave of buf) self._down(wave);
+	}
+	if (self._control.pausedDepWaveOccurred) {
+		self._control.pausedDepWaveOccurred = false;
+		self._tryRun();
+	}
+}
+
+export function nodeCanFireDemand<T>(self: NodeRuntimeHost<T>): boolean {
+	if (self._value.terminal !== undefined || self._wave.pending > 0) return false;
+	return self._control.pauseLockset.size === 0;
+}
+
+export function nodeDeliverPullDemand<T>(self: NodeRuntimeHost<T>, demand: PullDemand): void {
+	self._control.demandOwed = undefined;
+	self._control.activePull = demand;
+	self._control.inDeliverDemand = true;
+	try {
+		self._firePullDemand();
+	} finally {
+		self._control.activePull = undefined;
+		self._control.inDeliverDemand = false;
+	}
+}
+
+export function nodeOnDemand<T>(self: NodeRuntimeHost<T>, demand: PullDemand): void {
+	if (self._control.inDeliverDemand) return; // re-entrant demand during an active delivery → drop (1:1)
+	if (self._canFireDemand()) self._deliverPullDemand(demand);
+	else self._control.demandOwed = demand; // latest owed params wins (D269/D272)
+}
+
+export function nodeFirePullDemand<T>(self: NodeRuntimeHost<T>): void {
+	let drainedBuffer = false;
+	if (self._control.pauseBuffer.length > 0) {
+		const buf = self._control.pauseBuffer;
+		self._control.pauseBuffer = [];
+		for (const wave of buf) self._down(wave);
+		drainedBuffer = true;
+	}
+	if (drainedBuffer) return;
+	if (self._control.pausedDepWaveOccurred) {
+		// QA-B2: only deliver if the fn can actually run this wave (settle-ready + first-run gate
+		// open). A gated run emits no DATA, so emitting the leading DIRTY would STRAND downstream
+		// — the exact wedge this feature exists to prevent (NoWedgeWhileQuiet). When gated, stay
+		// SILENT and KEEP _pausedDepWaveOccurred so a later demand (once every dep has settled)
+		// delivers. Mirrors _settleRewire's pre-_markDirty gate.
+		const gated =
+			self._slot.handle !== null &&
+			!self._wave.hasCalledFnOnce &&
+			!(self._slot.partial || self._allDepsSettled());
+		if (self._wave.pending > 0 || gated) return;
+		self._control.pausedDepWaveOccurred = false;
+		self._wave.emittedDirtyThisWave = false;
+		self._control.pullDirtyOwed = true;
+		try {
+			self._tryRun(); // fn DATA triggers DIRTY-before-DATA; no DATA means no output.
+		} finally {
+			self._control.pullDirtyOwed = false;
+		}
+		return;
+	}
+	if (self._slot.handle !== null) {
+		if (!self._wave.hasCalledFnOnce && !(self._slot.partial || self._allDepsSettled())) return;
+		self._wave.emittedDirtyThisWave = false;
+		self._control.pullDirtyOwed = true;
+		try {
+			self._runWave();
+		} finally {
+			self._control.pullDirtyOwed = false;
+		}
+	}
+}
+
+export function nodeFireOwedDemandIfReady<T>(self: NodeRuntimeHost<T>): void {
+	if (self._control.inDeliverDemand) return; // don't re-enter during an active delivery (1:1, QA guard)
+	if (self._slot.pull && self._control.demandOwed !== undefined && self._canFireDemand()) {
+		self._deliverPullDemand(self._control.demandOwed);
+	}
+}
+
+export function nodeShouldBufferOnPause<T>(self: NodeRuntimeHost<T>): boolean {
+	// D44: pausable mode is the OUTER gate over R-async-paused buffering.
+	// false: ignore PAUSE/RESUME ENTIRELY — never buffer, keep producing (R-pause-modes; resolves B20).
+	if (self._slot.pausable === false) return false;
+	if (!self._isPaused() && !self._isPullQuiet()) return false;
+	// resumeAll: production-gating — buffer the node's own (sync/async) settle slice too.
+	if (self._slot.pausable === "resumeAll") return true;
+	// true (default): PAUSE gates recomputation/propagation, NOT a leaf source's own production.
+	// An async COMPUTE node's (deps>0) in-flight result buffers (R-async-paused / C-2); a depless
+	// async leaf source's own production delivers immediately (R-pause-modes / C-10).
+	if (!self._wave.insideRunWave && self._isAsyncPool() && self._slot.deps.length > 0) return true;
+	return false;
+}
+
+export function nodeInvalidate<T>(self: NodeRuntimeHost<T>, delivery?: DeliveryMeta): void {
+	if (!self._value.hasData) return; // never-populated or already-reset → no-op
+	self._value.cache = SENTINEL;
+	self._value.hasData = false;
+	self._value.status = "sentinel";
+	self._value.replayRing = []; // BH6: invalidated values are stale — don't replay them
+	for (const fn of self._hooks.onInvalidate) fn();
+	self._emitToSubs(["INVALIDATE"], delivery);
+}
+
+export function nodeAllDepsTerminal<T>(self: NodeRuntimeHost<T>): boolean {
+	if (self._slot.deps.length === 0) return false;
+	for (const tm of self._dep.terminal) if (tm === undefined) return false;
+	return true;
+}
+
+export function nodeResetLifecycle<T>(self: NodeRuntimeHost<T>): void {
+	for (const u of self._dep.unsubs) if (u) u();
+	self._dep.unsubs = [];
+	self._dep.idxBoxes = [];
+	self._lifecycle.subscribers.clear();
+	self._lifecycle.activated = false;
+	self._value.terminal = undefined;
+	self._value.hasTorndown = false;
+	self._wave.hasCalledFnOnce = false;
+	self._resetDepState();
+	self._control.pauseLockset.clear();
+	self._control.pauseBuffer = [];
+	self._control.pausedDepWaveOccurred = false;
+	self._control.demandOwed = undefined; // R-pull (D269): drop any deferred demand
+	self._control.activePull = undefined;
+	self._control.pullDirtyOwed = false;
+	self._value.replayRing = []; // BH6
+	const isCompute = self._slot.handle !== null || self._slot.deps.length > 0;
+	if (isCompute) {
+		self._value.cache = SENTINEL;
+		self._value.hasData = false;
+		self._value.status = "sentinel";
+	} else {
+		self._value.status = self._value.hasData ? "settled" : "sentinel";
+	}
+	if (!self._privateState.persist) self._privateState.value = SENTINEL;
+}
+
+export function nodeEmitToSubs<T>(
+	self: NodeRuntimeHost<T>,
+	msg: Message,
+	delivery?: DeliveryMeta,
+): void {
+	if (self._released) return;
+	// Copy guards against subscribe/unsubscribe during iteration.
+	const subs = [...self._lifecycle.subscribers];
+	for (const sink of subs) sink(msg, delivery);
+}
+
+export function nodeCommitBatchedWave<T>(self: NodeRuntimeHost<T>, wave: Wave): void {
+	self._wave.batchDirtyOwed = false; // commit delivers the real settle (BH1)
+	self._down(wave); // batch is inactive at commit -> processes normally
+}
+
+export function nodeRollbackBatched<T>(self: NodeRuntimeHost<T>): void {
+	// BH1: keyed on _batchDirtyOwed (not _emittedDirtyThisWave, which a fn wave between
+	// defer and rollback would have reset) so the balancing RESOLVED is never skipped.
+	if (self._wave.batchDirtyOwed) {
+		self._wave.batchDirtyOwed = false;
+		self._wave.emittedDirtyThisWave = false;
+		self._value.status = self._value.hasData ? "settled" : "sentinel";
+		self._emitToSubs(["RESOLVED"]);
+	}
+}
+
+export function nodeDeferBoundary<T>(
+	self: NodeRuntimeHost<T>,
+	fn: () => void,
+	batchToken?: object,
+): void {
+	deferRewire(self._core, fn, {
+		batchToken,
+		isReady: () => !self._hasBoundaryPauseLock(),
+	});
+}
diff --git a/packages/ts/src/node/node-rewire-runtime.ts b/packages/ts/src/node/node-rewire-runtime.ts
new file mode 100644
index 00000000..5b3e42cc
--- /dev/null
+++ b/packages/ts/src/node/node-rewire-runtime.ts
@@ -0,0 +1,212 @@
+import { currentBoundaryBatchToken, deferAfterBatchForTarget } from "../batch/batch.js";
+import { deferRewire } from "../batch/boundary.js";
+import type { NodeFn } from "../ctx/types.js";
+import type { Wave } from "../protocol/messages.js";
+import { errorPayload, SENTINEL } from "../protocol/messages.js";
+import type { Node } from "./node.js";
+import { type NodeRuntimeHost, nodeRuntimeHost } from "./node-runtime-host.js";
+import { notifyTopologyDepsChanged } from "./runtime-accessors.js";
+import type { RewireOp } from "./types.js";
+
+export function nodeRequestRewireNext<T>(self: NodeRuntimeHost<T>, op: RewireOp): void {
+	deferRewire(self._core, () => self._applyRewireNext(op), {
+		batchToken: currentBoundaryBatchToken(),
+		isReady: () => !self._hasBoundaryPauseLock(),
+	});
+}
+
+export function nodeRequestUpNext<T>(
+	self: NodeRuntimeHost<T>,
+	msgs: Wave,
+	towardDep?: number,
+): void {
+	deferRewire(
+		self._core,
+		() => {
+			if (!self._released) self._up(msgs, towardDep);
+		},
+		{
+			batchToken: currentBoundaryBatchToken(),
+			isReady: () => !self._hasBoundaryPauseLock(),
+		},
+	);
+}
+
+export function nodeApplyRewireNext<T>(self: NodeRuntimeHost<T>, op: RewireOp): void {
+	if (self._released) return;
+	try {
+		// D62 / R-rewire-deferred: terminal seals output but does NOT cancel queued topology.
+		// Public/immediate rewire of a terminal node still rejects; the exception is only for
+		// self-triggered ops already issued before terminal and now draining at the boundary.
+		if (op.kind === "add") {
+			const next = self._slot.deps.includes(op.dep)
+				? [...self._slot.deps]
+				: [...self._slot.deps, op.dep];
+			self._rewire(next, op.fn, { allowTerminalOwner: true });
+		} else if (op.kind === "remove") {
+			self._rewire(
+				self._slot.deps.filter((d) => d !== op.dep),
+				op.fn,
+				{ allowTerminalOwner: true },
+			);
+		} else {
+			self._rewire(self._dedupDeps(op.deps), op.fn, { allowTerminalOwner: true });
+		}
+	} catch (e) {
+		// An invalid deferred op (cycle / self / non-resubscribable terminal dep) surfaces as
+		// an ERROR on this node (D30-consistent) rather than stranding the rest of the drain
+		// queue. Reachable only on misuse — higher-order operator inners are fresh, acyclic
+		// leaf sources. Coerce a SENTINEL reason (a rewire fn that `throw undefined`s) to a real
+		// Error so _down's R-data-payload guard does not itself throw out of the drain.
+		self._down([["ERROR", errorPayload(e, "rewireNext op failed")]]);
+	}
+}
+
+export function nodeRewire<T>(
+	self: NodeRuntimeHost<T>,
+	newDeps: Node<unknown>[],
+	fn: NodeFn,
+	opts: { allowTerminalOwner?: boolean } = {},
+): boolean {
+	const node = self as unknown as Node<unknown>;
+	// ── rejects (R-rewire / D42) ──
+	if (self._value.terminal !== undefined && !opts.allowTerminalOwner)
+		throw new Error(
+			"rewire: node is terminal (completed/errored) — cannot rewire (R-rewire / D42)",
+		);
+	if (self._wave.insideRunWave)
+		throw new Error(
+			"rewire: mid-fn topology mutation — a fn mutating its own deps mid-wave is the feedback cycle (R-rewire / D37)",
+		);
+	if (self._wave.inDepMutation)
+		throw new Error(
+			"rewire: reentrant dep mutation — another replaceDeps/subscribeDep/unsubscribeDep is in flight (R-rewire)",
+		);
+	if (newDeps.includes(node)) throw new Error("rewire: self-dependency rejected (R-rewire / D42)");
+	const oldDeps = self._slot.deps;
+	const added = newDeps.filter((d) => !oldDeps.includes(d));
+	for (const d of added) {
+		if (self._reachableUpstream(d, node))
+			throw new Error(
+				"rewire: would create a cycle — dep already transitively depends on this node (R-rewire / D42)",
+			);
+		const dep = nodeRuntimeHost(d);
+		if (dep._value.terminal !== undefined && !dep._slot.resubscribable)
+			throw new Error(
+				"rewire: cannot add a non-resubscribable terminal dep — would wedge (R-rewire / D42)",
+			);
+		self._assertRewireDepOwner(d);
+	}
+
+	if (
+		deferAfterBatchForTarget(node, () => {
+			self._rewire(newDeps, fn, { ...opts, allowTerminalOwner: true });
+		})
+	) {
+		return true;
+	}
+	if (!self._lifecycle.activated) self._restoredActivationPending = false;
+
+	self._wave.inDepMutation = true;
+	self._wave.rewireRunPending = false;
+	let zeroDepUnDirty = false;
+	try {
+		// fn swap (SD-1): re-register against the same pool, then release the old handle
+		// (B15) so the rewired-away fn closure is GC'd and its dispatcher slot is reused —
+		// a rewire-heavy graph (CSP-2.7 *Map) no longer leaks a handle per swap. Register
+		// first, then unregister the old: self._slot.handle never points at a freed slot, and a
+		// null old handle (a passthrough/state node gaining a fn) has nothing to free.
+		const oldHandle = self._slot.handle;
+		self._slot.handle = self._slot.dispatcher.register(fn, self._slot.pool);
+		if (oldHandle !== null) self._slot.dispatcher.unregister(oldHandle);
+
+		const removed = oldDeps.filter((d) => !newDeps.includes(d));
+		let removedDirtyContributor = false;
+		for (const d of removed) {
+			const oldIdx = oldDeps.indexOf(d);
+			if (self._dep.dirty[oldIdx]) {
+				removedDirtyContributor = true;
+				self._wave.pending--;
+			}
+			if (self._lifecycle.activated) {
+				const box = self._dep.idxBoxes[oldIdx];
+				if (box) box.v = -1; // drain: any stale in-flight callback drops
+				const unsub = self._dep.unsubs[oldIdx];
+				if (unsub) unsub(); // stops the removed dep's edge — no further delivery
+			}
+		}
+
+		// Rebuild per-dep parallel arrays in newDeps order; kept deps carry their state
+		// + subscription, added deps start fresh (R-rewire Q1/Q4).
+		const n = newDeps.length;
+		const newBatch: Array<unknown[] | null> = new Array(n).fill(null);
+		const newPrev: unknown[] = new Array(n).fill(SENTINEL);
+		const newHasData: boolean[] = new Array(n).fill(false);
+		const newDirty: boolean[] = new Array(n).fill(false);
+		const newTier: number[] = new Array(n).fill(0);
+		const newTerminal: Array<true | unknown | undefined> = new Array(n).fill(undefined);
+		const newTerminalInput: Array<true | unknown | undefined> = new Array(n).fill(undefined);
+		const newUnsubs: Array<() => void> = new Array(n);
+		const newBoxes: Array<{ v: number }> = new Array(n);
+		for (let j = 0; j < n; j++) {
+			const oldIdx = oldDeps.indexOf(newDeps[j]);
+			if (oldIdx !== -1) {
+				newBatch[j] = self._dep.batch[oldIdx];
+				newPrev[j] = self._dep.prev[oldIdx];
+				newHasData[j] = self._dep.hasData[oldIdx];
+				newDirty[j] = self._dep.dirty[oldIdx];
+				newTier[j] = self._dep.tier[oldIdx];
+				newTerminal[j] = self._dep.terminal[oldIdx];
+				newUnsubs[j] = self._dep.unsubs[oldIdx];
+				// carry the kept dep's subscription box and point it at the new index (O(1) reroute)
+				const box = self._dep.idxBoxes[oldIdx];
+				if (box) box.v = j;
+				newBoxes[j] = box;
+			}
+		}
+		self._slot.deps = newDeps;
+		self._dep.batch = newBatch;
+		self._dep.prev = newPrev;
+		self._dep.hasData = newHasData;
+		self._dep.dirty = newDirty;
+		self._dep.tier = newTier;
+		self._dep.terminal = newTerminal;
+		self._dep.terminalInput = newTerminalInput;
+		self._dep.unsubs = newUnsubs;
+		self._dep.idxBoxes = newBoxes;
+		self._dep.waveData = newDeps.map(() => []);
+		self._dep.waveTokens = new Array(newDeps.length).fill(undefined);
+		self._syncCtx = null;
+
+		// Subscribe added deps — push-on-subscribe (R-push-subscribe) delivers a cached
+		// dep's DATA here, which drives _maybeRun; a SENTINEL dep delivers START only.
+		if (self._lifecycle.activated) {
+			for (const d of added) self._subscribeDepAt(d);
+		}
+		notifyTopologyDepsChanged(node, oldDeps, newDeps);
+
+		// Q6 auto-settle: removing the sole dirty contributor closes the wave. With deps
+		// remaining, request the atomic settle (recompute → DATA for a value; a no-emit fn
+		// gets a substrate-synthesized undirty RESOLVED per R-resolved-undirty/D49 — NOT
+		// equals-absorption, which is gone). With zero deps the node is inert (degenerate
+		// fn-no-deps) — just un-dirty downstream. Cache is preserved either way (Q7).
+		if (removedDirtyContributor && self._wave.pending === 0 && self._value.status === "dirty") {
+			if (newDeps.length > 0) self._wave.rewireRunPending = true;
+			else zeroDepUnDirty = true;
+		}
+	} finally {
+		self._wave.inDepMutation = false;
+	}
+
+	// Atomic post-mutation settle (outside the reentrancy guard so a fresh wave runs
+	// normally): ONE two-phase DIRTY→DATA recompute if any added dep delivered data or a
+	// sole-dirty dep was removed; else the zero-dep un-dirty via _down (pause/batch-safe).
+	if (self._wave.rewireRunPending) {
+		self._wave.rewireRunPending = false;
+		self._settleRewire();
+	} else if (zeroDepUnDirty) {
+		if (self._wave.emittedDirtyThisWave) self._down([["RESOLVED"]]);
+		else self._value.status = self._value.hasData ? "settled" : "sentinel";
+	}
+	return false;
+}
diff --git a/packages/ts/src/node/node-runtime-host.ts b/packages/ts/src/node/node-runtime-host.ts
new file mode 100644
index 00000000..c3f3b720
--- /dev/null
+++ b/packages/ts/src/node/node-runtime-host.ts
@@ -0,0 +1,96 @@
+import type { Ctx, CtxState, DeliveryMeta, NodeFn } from "../ctx/types.js";
+import type { LockId, Message, PullDemand, Wave } from "../protocol/messages.js";
+import type {
+	CleanupHooks,
+	ControlState,
+	DepBookkeeping,
+	LifecycleState,
+	NodeCore,
+	NodeId,
+	NodeSlot,
+	PrivateState,
+	SyncCtxState,
+	ValueState,
+	VersionState,
+	WaveState,
+} from "./core.js";
+import type { Node } from "./node.js";
+import type { RewireOp, UpRouteState } from "./types.js";
+
+export interface NodeRuntimeHost<T = unknown> {
+	_core: NodeCore;
+	_id: NodeId;
+	_slot: NodeSlot<T>;
+	_dep: DepBookkeeping;
+	_value: ValueState<T>;
+	_wave: WaveState;
+	_control: ControlState;
+	_lifecycle: LifecycleState;
+	_privateState: PrivateState;
+	_hooks: CleanupHooks;
+	_syncCtxState: SyncCtxState;
+	_version: VersionState;
+	_syncCtx: Ctx | null;
+	_restoredActivationPending: boolean;
+	_released: boolean;
+	_assertNotReleased(op: string): void;
+	_isPullQuiet(): boolean;
+	_requestRewireNext(op: RewireOp): void;
+	_requestUpNext(msgs: Wave, towardDep?: number): void;
+	_applyRewireNext(op: RewireOp): void;
+	_dedupDeps(deps: Node<unknown>[]): Node<unknown>[];
+	_reachableUpstream(from: Node<unknown>, target: Node<unknown>): boolean;
+	_assertRewireDepOwner(dep: Node<unknown>): void;
+	_rewire(newDeps: Node<unknown>[], fn: NodeFn, opts?: { allowTerminalOwner?: boolean }): boolean;
+	_activate(): void;
+	_subscribeDepAt(depNode: Node<unknown>, opts?: { seedRestored?: boolean }): void;
+	_seedRestoredDepAt(idx: number, depNode: Node<unknown>): void;
+	_deactivate(): void;
+	_subscriberCount(): number;
+	_isRuntimeQuiescentForRelease(): boolean;
+	_releaseRuntime(): void;
+	_resetDepState(): void;
+	_recordDepProjection(idx: number, delivery: DeliveryMeta | undefined): unknown[];
+	_depProjectionHasData(idx: number): boolean;
+	_receiveFromDep(idx: number, msg: Message, delivery?: DeliveryMeta): void;
+	_releaseDepDirty(idx: number): void;
+	_settleAfterAbsorbedTerminal(): void;
+	_markDirty(): void;
+	_maybeRun(): void;
+	_settleRewire(): void;
+	_tryRun(): void;
+	_allDepsSettled(): boolean;
+	_passthroughEmit(): void;
+	_runWave(): void;
+	_buildCtx(): Ctx;
+	_makeCtx(snapshot?: { waveData: unknown[][][]; terminal: unknown[]; latest: unknown[] }): Ctx;
+	_refreshCtx(ctx: Ctx): void;
+	_makeState(): CtxState;
+	_down(msgs: Wave): void;
+	_up(msgs: Wave, towardDep?: number, route?: UpRouteState): void;
+	_markDemandRouted(lockId: LockId, route: UpRouteState): boolean;
+	_forwardUp(m: Message, towardDep: number | undefined, route: UpRouteState): void;
+	_isPaused(): boolean;
+	_hasBoundaryPauseLock(): boolean;
+	_isAsyncPool(): boolean;
+	_pauseAcquire(lockId: unknown): void;
+	_pauseRelease(lockId: unknown): void;
+	_onResume(): void;
+	_canFireDemand(): boolean;
+	_deliverPullDemand(demand: PullDemand): void;
+	_onDemand(demand: PullDemand): void;
+	_firePullDemand(): void;
+	_fireOwedDemandIfReady(): void;
+	_shouldBufferOnPause(): boolean;
+	_invalidate(delivery?: DeliveryMeta): void;
+	_allDepsTerminal(): boolean;
+	_resetLifecycle(): void;
+	_emitToSubs(msg: Message, delivery?: DeliveryMeta): void;
+	__commitBatchedWave(wave: Wave): void;
+	__rollbackBatched(): void;
+	__deferBoundary(fn: () => void, batchToken?: object): void;
+}
+
+export function nodeRuntimeHost<T>(node: Node<T>): NodeRuntimeHost<T> {
+	return node as unknown as NodeRuntimeHost<T>;
+}
diff --git a/packages/ts/src/node/node.ts b/packages/ts/src/node/node.ts
new file mode 100644
index 00000000..47c7d29e
--- /dev/null
+++ b/packages/ts/src/node/node.ts
@@ -0,0 +1,854 @@
+/**
+ * The node primitive — the thinnest substrate object (R-node-thin / D5).
+ *
+ * Holds a fn handle + deps + the wave state machine; ZERO inspection cruft
+ * (naming/find/describe are the graph layer, CSP-2). Canonical authority:
+ * ~/src/graphrefly/spec/rules.jsonl (R-node-*, R-two-phase, R-diamond, R-resolved-undirty,
+ * R-first-run-gate, R-push-subscribe, R-rom-ram, R-fn-contract, R-initial, R-ctx-up).
+ *
+ * Slice 1 = core wave: state node, compute node, two-phase DIRTY->DATA, diamond
+ * pending-counter join, first-run gate, substrate-synthesized undirty RESOLVED
+ * (R-resolved-undirty / D49 — no equals-substitution; every occurrence is DATA),
+ * push-on-subscribe, lazy activation, ROM/RAM. Lifecycle (terminal/INVALIDATE/cleanup),
+ * control (PAUSE/async), batch, and dynamicNode land in later slices.
+ */
+
+import { enterWave, exitWave } from "../batch/boundary.js";
+import type { Ctx, CtxState, DeliveryMeta, NodeFn, Sink } from "../ctx/types.js";
+import { defaultDispatcher, type Handle } from "../dispatcher/index.js";
+import { EnvironmentDrivers } from "../graph/environment.js";
+import {
+	type LockId,
+	type Message,
+	type PullDemand,
+	SENTINEL,
+	type Wave,
+} from "../protocol/messages.js";
+import {
+	type CleanupHooks,
+	type ControlState,
+	type DepBookkeeping,
+	type LifecycleState,
+	makeDepBookkeeping,
+	NodeCore,
+	type NodeId,
+	type NodeSlot,
+	type PrivateState,
+	type SyncCtxState,
+	type ValueState,
+	type VersionState,
+	type WaveState,
+} from "./core.js";
+import {
+	nodeBuildCtx,
+	nodeMakeCtx,
+	nodeMakeState,
+	nodeRefreshCtx,
+} from "./node-context-runtime.js";
+import {
+	nodeAllDepsSettled,
+	nodeDepProjectionHasData,
+	nodeMarkDirty,
+	nodeMaybeRun,
+	nodePassthroughEmit,
+	nodeReceiveFromDep,
+	nodeRecordDepProjection,
+	nodeReleaseDepDirty,
+	nodeRunWave,
+	nodeSettleAfterAbsorbedTerminal,
+	nodeSettleRewire,
+	nodeTryRun,
+} from "./node-input-runtime.js";
+import {
+	nodeActivate,
+	nodeDeactivate,
+	nodeIsRuntimeQuiescentForRelease,
+	nodeReleaseRuntime,
+	nodeResetDepState,
+	nodeSeedRestoredDepAt,
+	nodeSubscribeDepAt,
+	nodeSubscriberCount,
+} from "./node-lifecycle-runtime.js";
+import {
+	nodeAllDepsTerminal,
+	nodeCanFireDemand,
+	nodeCommitBatchedWave,
+	nodeDeferBoundary,
+	nodeDeliverPullDemand,
+	nodeDown,
+	nodeEmitToSubs,
+	nodeFireOwedDemandIfReady,
+	nodeFirePullDemand,
+	nodeForwardUp,
+	nodeHasBoundaryPauseLock,
+	nodeInvalidate,
+	nodeIsAsyncPool,
+	nodeIsPaused,
+	nodeMarkDemandRouted,
+	nodeOnDemand,
+	nodeOnResume,
+	nodePauseAcquire,
+	nodePauseRelease,
+	nodeResetLifecycle,
+	nodeRollbackBatched,
+	nodeShouldBufferOnPause,
+	nodeUp,
+} from "./node-output-runtime.js";
+import {
+	nodeApplyRewireNext,
+	nodeRequestRewireNext,
+	nodeRequestUpNext,
+	nodeRewire,
+} from "./node-rewire-runtime.js";
+import { nodeRuntimeHost } from "./node-runtime-host.js";
+import {
+	activationReaders,
+	checkpointReaders,
+	getNodeOwner,
+	restoreWriters,
+	runtimeQuiescenceReaders,
+	runtimeReleasers,
+	subscriberCountReaders,
+	takeConstructingEnvironmentDrivers,
+	takeConstructingNodeCore,
+} from "./runtime-accessors.js";
+import type { NodeOptions, RewireOp, Status, UpRouteState } from "./types.js";
+import {
+	cloneNodeVersion,
+	createNodeVersion,
+	type NodeVersion,
+	resolveNodeVersioningPolicy,
+	restoredV1Cid,
+} from "./versioning.js";
+
+export {
+	checkpointStateOfNode,
+	getNodeOwner,
+	isNodeActiveForRelease,
+	isNodeRuntimeQuiescentForRelease,
+	isNodeRuntimeReleased,
+	releaseRuntimeOfNode,
+	restoreStateOfNode,
+	setNodeOwner,
+	setNodeTopologyDepsChangedObserver,
+	subscriberCountOfNode,
+	withEnvironmentDrivers,
+	withNodeCore,
+} from "./runtime-accessors.js";
+export type { NodeCheckpointState, NodeOptions, NodeRestoreState, Status } from "./types.js";
+
+export class Node<T = unknown> {
+	private readonly _core: NodeCore;
+	private readonly _id: NodeId;
+	private readonly _slot: NodeSlot<T>;
+	private readonly _dep: DepBookkeeping;
+	private readonly _value: ValueState<T>;
+	private readonly _wave: WaveState;
+	private readonly _control: ControlState;
+	private readonly _lifecycle: LifecycleState;
+	private readonly _privateState: PrivateState;
+	private readonly _hooks: CleanupHooks;
+	private readonly _syncCtxState: SyncCtxState;
+	private readonly _version: VersionState;
+	private _restoredActivationPending = false;
+	private _released = false;
+
+	private get _syncCtx(): Ctx | null {
+		return this._syncCtxState.value;
+	}
+
+	private set _syncCtx(ctx: Ctx | null) {
+		this._syncCtxState.value = ctx;
+	}
+
+	private static _retainIndirectRuntimeMethods(node: Node<unknown>): void {
+		void node._dep;
+		void node._hooks;
+		void node._restoredActivationPending;
+		void node._requestRewireNext;
+		void node._requestUpNext;
+		void node._applyRewireNext;
+		void node._reachableUpstream;
+		void node._assertRewireDepOwner;
+		void node._subscribeDepAt;
+		void node._seedRestoredDepAt;
+		void node._recordDepProjection;
+		void node._depProjectionHasData;
+		void node._receiveFromDep;
+		void node._releaseDepDirty;
+		void node._settleAfterAbsorbedTerminal;
+		void node._markDirty;
+		void node._maybeRun;
+		void node._settleRewire;
+		void node._tryRun;
+		void node._allDepsSettled;
+		void node._passthroughEmit;
+		void node._runWave;
+		void node._buildCtx;
+		void node._makeCtx;
+		void node._refreshCtx;
+		void node._makeState;
+		void node._markDemandRouted;
+		void node._forwardUp;
+		void node._isPullQuiet;
+		void node._isPaused;
+		void node._hasBoundaryPauseLock;
+		void node._isAsyncPool;
+		void node._pauseAcquire;
+		void node._pauseRelease;
+		void node._onResume;
+		void node._canFireDemand;
+		void node._deliverPullDemand;
+		void node._onDemand;
+		void node._firePullDemand;
+		void node._fireOwedDemandIfReady;
+		void node._shouldBufferOnPause;
+		void node._invalidate;
+		void node._allDepsTerminal;
+		void node._emitToSubs;
+	}
+
+	constructor(
+		deps: Node<unknown>[],
+		handleOrFn: Handle | NodeFn | null,
+		opts: NodeOptions<T> = {},
+	) {
+		const core = takeConstructingNodeCore();
+		const dispatcher = opts.dispatcher ?? defaultDispatcher;
+		const environment = takeConstructingEnvironmentDrivers() ?? EnvironmentDrivers.empty();
+		const pool = opts.pool ?? "sync";
+		const pausable = opts.pausable ?? true;
+		const pullLock = opts.pullId;
+		const pull = opts.pullId !== undefined;
+		// R-pull (D269): pull-mode is keyed by an author-supplied pullId (its quiet latch).
+		// R-pull (D55, pin 3): pull still uses the pausable delivery-content axis; pausable:false
+		// ignores PAUSE/RESUME buffering and contradicts quiet pull delivery. Reject at construction.
+		if (pull && pausable === false)
+			throw new Error(
+				"node: pullId is incompatible with pausable:false — a pull node uses the pausable delivery-content axis (R-pull / R-pause-modes / D55,D269)",
+			);
+
+		let handle: Handle | null;
+		if (handleOrFn === null) handle = null;
+		else if (typeof handleOrFn === "function") handle = dispatcher.register(handleOrFn, pool);
+		else handle = handleOrFn;
+
+		const n = deps.length;
+		const dep = makeDepBookkeeping(n);
+		const versioning = resolveNodeVersioningPolicy(opts.versioning);
+		const value = {
+			cache: SENTINEL as T | undefined,
+			hasData: false,
+			status: "sentinel" as Status,
+			terminal: undefined,
+			hasTorndown: false,
+			replayRing: [] as T[],
+		};
+		if (opts.initial !== undefined) {
+			value.cache = opts.initial as T;
+			value.hasData = true;
+			value.status = "settled";
+		}
+		const pauseLockset = new Set<unknown>();
+		this._core = core ?? new NodeCore();
+		const created = this._core.createSlot<T>(
+			{
+				deps,
+				handle,
+				pool,
+				dispatcher,
+				environment,
+				partial: opts.partial ?? false,
+				terminalAsRealInput: opts.terminalAsRealInput ?? false,
+				completeWhenDepsComplete: opts.completeWhenDepsComplete ?? true,
+				errorWhenDepsError: opts.errorWhenDepsError ?? true,
+				resubscribable: opts.resubscribable ?? false,
+				resetOnTeardown: opts.resetOnTeardown ?? false,
+				pausable,
+				pull,
+				pullLock,
+				replayN: opts.replayBuffer ?? 0,
+				dynamic: opts.dynamic ?? false,
+				name: opts.name,
+				factory: opts.factory,
+			},
+			{
+				dep,
+				lifecycle: { subscribers: new Set<Sink>(), activated: false },
+				value,
+				wave: {
+					pending: 0,
+					hasCalledFnOnce: false,
+					emittedDirtyThisWave: false,
+					emittedSettleThisWave: false,
+					insideRunWave: false,
+					inDepMutation: false,
+					rewireRunPending: false,
+					batchDirtyOwed: false,
+				},
+				control: {
+					pauseLockset,
+					pausedDepWaveOccurred: false,
+					pauseBuffer: [],
+					demandOwed: undefined,
+					activePull: undefined,
+					pullDirtyOwed: false,
+					inDeliverDemand: false,
+				},
+				privateState: { value: SENTINEL, persist: false },
+				hooks: { onDeactivation: [], onInvalidate: [] },
+				syncCtx: { value: null },
+				version: {
+					policy: versioning,
+					value: createNodeVersion(
+						versioning,
+						opts.initial !== undefined ? opts.initial : undefined,
+					),
+				},
+			},
+		);
+		this._id = created.id;
+		this._slot = this._core.get<T>(this._id);
+		this._dep = this._core.getDep(this._id);
+		this._value = this._core.getValue<T>(this._id);
+		this._wave = this._core.getWave(this._id);
+		this._control = this._core.getControl(this._id);
+		this._lifecycle = this._core.getLifecycle(this._id);
+		this._privateState = this._core.getPrivateState(this._id);
+		this._hooks = this._core.getHooks(this._id);
+		this._syncCtxState = this._core.getSyncCtx(this._id);
+		this._version = this._core.getVersion(this._id);
+		checkpointReaders.set(this as Node<unknown>, () => ({
+			cache: this._value.cache,
+			hasData: this._value.hasData,
+			terminal: this._value.terminal,
+			activated: this._lifecycle.activated,
+			hasCalledFnOnce: this._wave.hasCalledFnOnce,
+			ctxState: {
+				value: this._privateState.value,
+				persist: this._privateState.persist,
+			},
+			version: cloneNodeVersion(this._version.value),
+			handle: this._slot.handle,
+		}));
+		restoreWriters.set(this as Node<unknown>, (state) => {
+			this._assertNotReleased("restoreGraph");
+			this._value.cache = state.cache as T;
+			this._value.hasData = state.hasData;
+			this._value.status = state.status;
+			this._value.terminal = state.terminal;
+			this._value.hasTorndown = false;
+			this._value.replayRing = [];
+			this._wave.hasCalledFnOnce = state.hasCalledFnOnce;
+			this._wave.emittedDirtyThisWave = false;
+			this._wave.emittedSettleThisWave = false;
+			this._wave.pending = 0;
+			this._wave.insideRunWave = false;
+			this._wave.inDepMutation = false;
+			this._wave.rewireRunPending = false;
+			this._wave.batchDirtyOwed = false;
+			this._control.pauseBuffer = [];
+			this._control.pausedDepWaveOccurred = false;
+			this._control.demandOwed = undefined;
+			this._control.activePull = undefined;
+			this._control.pullDirtyOwed = false;
+			this._control.inDeliverDemand = false;
+			this._control.pauseLockset.clear();
+			this._privateState.value = state.ctxState.value;
+			this._privateState.persist = state.ctxState.persist;
+			if (state.version === false) {
+				this._version.policy = { enabled: false };
+				this._version.value = undefined;
+			} else if (state.version.level === 0) {
+				this._version.policy = { enabled: true, level: 0 };
+				this._version.value = cloneNodeVersion(state.version);
+			} else {
+				if (!this._version.policy.enabled || this._version.policy.level !== 1) {
+					throw new Error(
+						`restoreGraph: checkpoint node version level ${state.version.level} requires matching node versioning policy`,
+					);
+				}
+				// D109: V1 restore must match the selected hash lane. After DATA then
+				// INVALIDATE/resetOnTeardown, cache is absent while cid remains the last DATA cid;
+				// without the DATA value, restore cannot verify the lane, so fail honestly.
+				if (!state.hasData && state.version.counter > 0) {
+					throw new Error(
+						"restoreGraph: checkpoint node version cid cannot be verified without current DATA under V1 versioning (D109)",
+					);
+				}
+				const expectedCid = restoredV1Cid(this._version.policy, state.hasData, state.cache);
+				if (expectedCid !== state.version.cid) {
+					throw new Error(
+						"restoreGraph: checkpoint node version cid does not match the selected node versioning hash policy (D109)",
+					);
+				}
+				this._version.value = cloneNodeVersion(state.version);
+			}
+			this._syncCtx = null;
+			this._resetDepState();
+			// A fresh restored graph has no subscribers before return. Keep activation closed so the
+			// first real subscriber wires deps normally; D94's preserved lifecycle bit is the first-run
+			// gate (`hasCalledFnOnce`), not a hidden subscription graph.
+			this._lifecycle.activated = false;
+			this._lifecycle.subscribers.clear();
+			this._restoredActivationPending = true;
+		});
+		runtimeReleasers.set(this as Node<unknown>, () => this._releaseRuntime());
+		runtimeQuiescenceReaders.set(this as Node<unknown>, () => this._isRuntimeQuiescentForRelease());
+		subscriberCountReaders.set(this as Node<unknown>, () => this._subscriberCount());
+		activationReaders.set(this as Node<unknown>, () => this._lifecycle.activated);
+		Node._retainIndirectRuntimeMethods(this as Node<unknown>);
+	}
+
+	/** R-pull (D55/D272): true while a pull node is not serving a PULL demand pulse. */
+	private _isPullQuiet(): boolean {
+		return this._slot.pull && this._control.activePull === undefined;
+	}
+
+	/**
+	 * R-pull (D269/D272): this pull node's pullId (pure data, like {@link cache}/{@link handle} —
+	 * never triggers computation). A consumer demands one delivery by cone-routing PULL of it (no
+	 * node reference): `ctx.up([["PULL", { pullId }]])` (immediate; loops back → D37 for a self-read
+	 * dep) or `ctx.upNext([["PULL", { pullId }]])` (boundary-deferred self-demand). Undefined for a
+	 * non-pull node. The author writes the pullId verbatim; routing matches by identity.
+	 */
+	get pullId(): LockId | undefined {
+		return this._slot.pullLock;
+	}
+
+	get cache(): T | undefined {
+		return this._value.cache;
+	}
+
+	get status(): Status {
+		return this._value.status;
+	}
+
+	get version(): NodeVersion | undefined {
+		return cloneNodeVersion(this._version.value);
+	}
+
+	get name(): string | undefined {
+		return this._slot.name;
+	}
+
+	/** R-describe/D51: real factory name for a standalone graph-less node (a runtime *Map inner). */
+	get factory(): string | undefined {
+		return this._slot.factory;
+	}
+
+	/**
+	 * The node's CURRENT/LIVE deps (R-describe / R-edges-derived / D51) — readonly view of the
+	 * live `_deps`, which a rewire (C-8 / C-11) mutates. The graph's describe() reads this (NOT a
+	 * construction-time snapshot) so every edge corresponds to a real current subscription (D3).
+	 * Inspection-only, like cache/status; never triggers computation.
+	 */
+	get deps(): readonly Node<unknown>[] {
+		return this._slot.deps;
+	}
+
+	/**
+	 * The fn handle (pure data `(poolId, handleId)`, D7) or null for state/passthrough
+	 * nodes. Inspection-only (L1.6 handle is referenceable/inspectable) — lets the graph
+	 * layer key a dispatcher-backed profile recorder WITHOUT putting counters on the node
+	 * (R-node-thin / D39).
+	 */
+	get handle(): Handle | null {
+		return this._slot.handle;
+	}
+
+	/** R-push-subscribe: a new sink receives START, then cached DATA (or DIRTY if dirty). */
+	subscribe(sink: Sink): () => void {
+		this._assertNotReleased("subscribe");
+		// Wave-owner boundary (R-rewire-deferred / D47): the activation cascade can run fns that
+		// issue ctx.rewireNext; the OUTERMOST exit drains them. Nested subscribes (dep wiring)
+		// just inc/dec the depth.
+		enterWave();
+		try {
+			// R-terminal: late subscribe to a terminal node either resets (resubscribable)
+			// or is rejected (non-resubscribable, R2.2.7.b).
+			if (this._value.terminal !== undefined) {
+				if (this._slot.resubscribable) {
+					this._restoredActivationPending = false;
+					this._resetLifecycle();
+				} else
+					throw new Error(
+						"subscribe: node is non-resubscribable and has terminated; the stream is permanently over (R-terminal / R2.2.7.b)",
+					);
+			}
+
+			this._lifecycle.subscribers.add(sink);
+			sink(["START"]);
+			if (this._slot.replayN > 0 && this._value.replayRing.length > 0) {
+				// R-replay-buffer: late subscriber gets the last N DATA after START.
+				for (const v of this._value.replayRing) sink(["DATA", v]);
+			} else if (this._value.hasData && !this._slot.pull) {
+				// R-pull (D55): a pull node NEVER push-on-subscribes its cached value — quiet by
+				// default, it stays silent until demanded (START only). QA-B4: gated on `_pull`, not
+				// activePull, so a REACTIVATED pull node still does not leak its cache.
+				sink(["DATA", this._value.cache]);
+			} else if (this._value.status === "dirty" && !this._slot.pull) {
+				sink(["DIRTY"]);
+			}
+
+			if (!this._lifecycle.activated) this._activate();
+
+			return () => {
+				if (!this._lifecycle.subscribers.delete(sink)) return;
+				if (this._lifecycle.subscribers.size === 0) this._deactivate();
+			};
+		} finally {
+			exitWave();
+		}
+	}
+
+	/** External emission toward sinks (state-node push, or async late-emit). One call = one wave. */
+	down(msgs: Wave): void {
+		this._assertNotReleased("down");
+		// Wave-owner boundary (D47): a state.set / external push that drives a fn issuing
+		// ctx.rewireNext drains at this outermost exit.
+		enterWave();
+		try {
+			this._down(msgs);
+		} finally {
+			exitWave();
+		}
+	}
+
+	/**
+	 * Emit upstream toward deps — control tiers only (R-ctx-up). `towardDep` (a dep index) routes up
+	 * ONE declared edge (R-up-routing directed-up); omitted = broadcast up all deps.
+	 */
+	up(msgs: Wave, towardDep?: number): void {
+		this._assertNotReleased("up");
+		// Wave-owner boundary (D47). Internal dep-forwarding calls dep.up() nest under this.
+		enterWave();
+		try {
+			this._up(msgs, towardDep);
+		} finally {
+			exitWave();
+		}
+	}
+
+	// ── rewire (R-rewire / D42): intra-graph runtime topology mutation ──
+
+	/**
+	 * Replace this node's deps atomically (surgical, Option-C). Requires an explicit
+	 * `fn` (SD-1 fn-deps pairing — user fns read dep input positionally). Kept deps
+	 * keep their subscription + per-dep state; only removed deps unsubscribe and only
+	 * added deps fresh-subscribe (push-on-subscribe for an added cached dep). The
+	 * first-run gate and cache are PRESERVED (R-rewire Q2/Q7). Intra-graph only (D22).
+	 */
+	replaceDeps(newDeps: Node<unknown>[], fn: NodeFn): void {
+		this._assertNotReleased("replaceDeps");
+		this._rewire(this._dedupDeps(newDeps), fn);
+	}
+
+	/** Subscribe to one dep (special case of replaceDeps); returns its index. fn required (SD-1). */
+	subscribeDep(depNode: Node<unknown>, fn: NodeFn): number {
+		this._assertNotReleased("subscribeDep");
+		const next = this._slot.deps.includes(depNode)
+			? [...this._slot.deps]
+			: [...this._slot.deps, depNode];
+		const deferred = this._rewire(next, fn);
+		return deferred ? next.indexOf(depNode) : this._slot.deps.indexOf(depNode);
+	}
+
+	/** Unsubscribe from one dep (special case of replaceDeps); idempotent if absent (fn swap still applies). */
+	unsubscribeDep(depNode: Node<unknown>, fn: NodeFn): void {
+		this._assertNotReleased("unsubscribeDep");
+		this._rewire(
+			this._slot.deps.filter((d) => d !== depNode),
+			fn,
+		);
+	}
+
+	private _requestRewireNext(op: RewireOp): void {
+		nodeRequestRewireNext(nodeRuntimeHost(this), op);
+	}
+
+	private _requestUpNext(msgs: Wave, towardDep?: number): void {
+		nodeRequestUpNext(nodeRuntimeHost(this), msgs, towardDep);
+	}
+
+	private _applyRewireNext(op: RewireOp): void {
+		nodeApplyRewireNext(nodeRuntimeHost(this), op);
+	}
+
+	private _dedupDeps(deps: Node<unknown>[]): Node<unknown>[] {
+		const seen = new Set<Node<unknown>>();
+		const out: Node<unknown>[] = [];
+		for (const d of deps)
+			if (!seen.has(d)) {
+				seen.add(d);
+				out.push(d);
+			}
+		return out;
+	}
+
+	private _reachableUpstream(from: Node<unknown>, target: Node<unknown>): boolean {
+		const seen = new Set<Node<unknown>>();
+		const stack: Node<unknown>[] = [from];
+		while (stack.length > 0) {
+			const n = stack.pop();
+			if (n === undefined) continue;
+			if (n === target) return true;
+			if (seen.has(n)) continue;
+			seen.add(n);
+			for (const d of nodeRuntimeHost(n)._slot.deps) stack.push(d);
+		}
+		return false;
+	}
+
+	private _assertRewireDepOwner(dep: Node<unknown>): void {
+		const selfOwner = getNodeOwner(this as unknown as Node<unknown>);
+		const depOwner = getNodeOwner(dep);
+		if (selfOwner !== undefined && depOwner !== undefined && selfOwner !== depOwner)
+			throw new Error(
+				"rewire: dep belongs to a different graph; cross-graph deps require a wire bridge (D22 / R-graph-domain)",
+			);
+	}
+
+	private _rewire(
+		newDeps: Node<unknown>[],
+		fn: NodeFn,
+		opts: { allowTerminalOwner?: boolean } = {},
+	): boolean {
+		return nodeRewire(nodeRuntimeHost(this), newDeps, fn, opts);
+	}
+
+	// ── activation / deactivation (lazy; R-rom-ram) ──
+
+	private _activate(): void {
+		nodeActivate(nodeRuntimeHost(this));
+	}
+
+	private _deactivate(): void {
+		nodeDeactivate(nodeRuntimeHost(this));
+	}
+
+	private _assertNotReleased(op: string): void {
+		if (this._released)
+			throw new Error(`${op}: node has been released from its graph lifecycle (D122)`);
+	}
+
+	private _subscriberCount(): number {
+		return nodeSubscriberCount(nodeRuntimeHost(this));
+	}
+
+	private _isRuntimeQuiescentForRelease(): boolean {
+		return nodeIsRuntimeQuiescentForRelease(nodeRuntimeHost(this));
+	}
+
+	private _releaseRuntime(): void {
+		nodeReleaseRuntime(nodeRuntimeHost(this));
+	}
+
+	private _resetDepState(): void {
+		nodeResetDepState(nodeRuntimeHost(this));
+	}
+
+	private _subscribeDepAt(depNode: Node<unknown>, opts: { seedRestored?: boolean } = {}): void {
+		nodeSubscribeDepAt(nodeRuntimeHost(this), depNode, opts);
+	}
+
+	private _seedRestoredDepAt(idx: number, depNode: Node<unknown>): void {
+		nodeSeedRestoredDepAt(nodeRuntimeHost(this), idx, depNode);
+	}
+
+	private _recordDepProjection(idx: number, delivery: DeliveryMeta | undefined): unknown[] {
+		return nodeRecordDepProjection(nodeRuntimeHost(this), idx, delivery);
+	}
+
+	private _depProjectionHasData(idx: number): boolean {
+		return nodeDepProjectionHasData(nodeRuntimeHost(this), idx);
+	}
+
+	private _receiveFromDep(idx: number, msg: Message, delivery?: DeliveryMeta): void {
+		nodeReceiveFromDep(nodeRuntimeHost(this), idx, msg, delivery);
+	}
+
+	private _releaseDepDirty(idx: number): void {
+		nodeReleaseDepDirty(nodeRuntimeHost(this), idx);
+	}
+
+	private _settleAfterAbsorbedTerminal(): void {
+		nodeSettleAfterAbsorbedTerminal(nodeRuntimeHost(this));
+	}
+
+	private _markDirty(): void {
+		nodeMarkDirty(nodeRuntimeHost(this));
+	}
+
+	private _maybeRun(): void {
+		nodeMaybeRun(nodeRuntimeHost(this));
+	}
+
+	private _settleRewire(): void {
+		nodeSettleRewire(nodeRuntimeHost(this));
+	}
+
+	private _tryRun(): void {
+		nodeTryRun(nodeRuntimeHost(this));
+	}
+
+	private _allDepsSettled(): boolean {
+		return nodeAllDepsSettled(nodeRuntimeHost(this));
+	}
+
+	private _passthroughEmit(): void {
+		nodePassthroughEmit(nodeRuntimeHost(this));
+	}
+
+	private _runWave(): void {
+		nodeRunWave(nodeRuntimeHost(this));
+	}
+
+	private _buildCtx(): Ctx {
+		return nodeBuildCtx(nodeRuntimeHost(this));
+	}
+
+	private _makeCtx(snapshot?: {
+		waveData: unknown[][][];
+		terminal: unknown[];
+		latest: unknown[];
+	}): Ctx {
+		return nodeMakeCtx(nodeRuntimeHost(this), snapshot);
+	}
+
+	private _refreshCtx(ctx: Ctx): void {
+		nodeRefreshCtx(nodeRuntimeHost(this), ctx);
+	}
+
+	private _makeState(): CtxState {
+		return nodeMakeState(nodeRuntimeHost(this));
+	}
+
+	// ── downstream emission pipeline (the unified waist) ──
+
+	private _down(msgs: Wave): void {
+		nodeDown(nodeRuntimeHost(this), msgs);
+	}
+
+	private _up(msgs: Wave, towardDep?: number, route?: UpRouteState): void {
+		nodeUp(nodeRuntimeHost(this), msgs, towardDep, route);
+	}
+
+	private _markDemandRouted(lockId: LockId, route: UpRouteState): boolean {
+		return nodeMarkDemandRouted(nodeRuntimeHost(this), lockId, route);
+	}
+
+	private _forwardUp(m: Message, towardDep: number | undefined, route: UpRouteState): void {
+		nodeForwardUp(nodeRuntimeHost(this), m, towardDep, route);
+	}
+
+	private _isPaused(): boolean {
+		return nodeIsPaused(nodeRuntimeHost(this));
+	}
+
+	private _hasBoundaryPauseLock(): boolean {
+		return nodeHasBoundaryPauseLock(nodeRuntimeHost(this));
+	}
+
+	private _isAsyncPool(): boolean {
+		return nodeIsAsyncPool(nodeRuntimeHost(this));
+	}
+
+	private _pauseAcquire(lockId: unknown): void {
+		nodePauseAcquire(nodeRuntimeHost(this), lockId);
+	}
+
+	private _pauseRelease(lockId: unknown): void {
+		nodePauseRelease(nodeRuntimeHost(this), lockId);
+	}
+
+	private _onResume(): void {
+		nodeOnResume(nodeRuntimeHost(this));
+	}
+
+	private _canFireDemand(): boolean {
+		return nodeCanFireDemand(nodeRuntimeHost(this));
+	}
+
+	private _deliverPullDemand(demand: PullDemand): void {
+		nodeDeliverPullDemand(nodeRuntimeHost(this), demand);
+	}
+
+	private _onDemand(demand: PullDemand): void {
+		nodeOnDemand(nodeRuntimeHost(this), demand);
+	}
+
+	private _firePullDemand(): void {
+		nodeFirePullDemand(nodeRuntimeHost(this));
+	}
+
+	private _fireOwedDemandIfReady(): void {
+		nodeFireOwedDemandIfReady(nodeRuntimeHost(this));
+	}
+
+	private _shouldBufferOnPause(): boolean {
+		return nodeShouldBufferOnPause(nodeRuntimeHost(this));
+	}
+
+	private _invalidate(delivery?: DeliveryMeta): void {
+		nodeInvalidate(nodeRuntimeHost(this), delivery);
+	}
+
+	private _allDepsTerminal(): boolean {
+		return nodeAllDepsTerminal(nodeRuntimeHost(this));
+	}
+
+	private _emitToSubs(msg: Message, delivery?: DeliveryMeta): void {
+		nodeEmitToSubs(nodeRuntimeHost(this), msg, delivery);
+	}
+
+	/** R-terminal: resubscribable reset clears terminal + dep state + re-arms the gate. */
+	private _resetLifecycle(): void {
+		nodeResetLifecycle(nodeRuntimeHost(this));
+	}
+
+	/** Batch commit (R-batch-coalesce): deliver the deferred tier-3 wave now. */
+	__commitBatchedWave(wave: Wave): void {
+		nodeCommitBatchedWave(nodeRuntimeHost(this), wave);
+	}
+
+	/** Batch rollback: balance the immediate DIRTY with a RESOLVED so downstream un-dirties. */
+	__rollbackBatched(): void {
+		nodeRollbackBatched(nodeRuntimeHost(this));
+	}
+
+	/** B49: enqueue a committed-boundary task on this node's graph-local core. */
+	__deferBoundary(fn: () => void, batchToken?: object): void {
+		nodeDeferBoundary(nodeRuntimeHost(this), fn, batchToken);
+	}
+}
+
+/**
+ * Construct a node (R-node-iface / D5 / L1.9 deps-first).
+ *   node([], null, { initial })       — state node (manual source; emit via .down)
+ *   node([], fn)                        — producer (runs on activation)
+ *   node([a, b], fn)                    — compute / derived
+ *   node([dep])                         — passthrough wire
+ */
+export function node<T = unknown>(
+	deps: Node<unknown>[] = [],
+	handleOrFn: Handle | NodeFn | null = null,
+	opts: NodeOptions<T> = {},
+): Node<T> {
+	return new Node<T>(deps, handleOrFn, opts);
+}
+
+/**
+ * Construct a dynamicNode (R-dynamic-node / D35) — a node variant whose fn reads a
+ * subset of a fixed superset of deps per invocation via `ctx.track(i)`. All declared
+ * deps participate in wave tracking; an unread dep's change re-runs the fn, which re-emits
+ * its current value as DATA (D49 removed equals-absorption — dedup is opt-in via
+ * distinctUntilChanged). Intra-graph only (D22).
+ */
+export function dynamicNode<T = unknown>(
+	deps: Node<unknown>[],
+	fn: NodeFn,
+	opts: NodeOptions<T> = {},
+): Node<T> {
+	return new Node<T>(deps, fn, { ...opts, dynamic: true });
+}
diff --git a/packages/ts/src/node/protocol-guards.ts b/packages/ts/src/node/protocol-guards.ts
new file mode 100644
index 00000000..68b697dd
--- /dev/null
+++ b/packages/ts/src/node/protocol-guards.ts
@@ -0,0 +1,28 @@
+import { isInvalidErrorPayload, type PullDemand, type Wave } from "../protocol/messages.js";
+
+export function terminalView(t: unknown): unknown {
+	return t === undefined ? false : t;
+}
+
+export function normalizePullDemand(demand: PullDemand): PullDemand {
+	if (typeof demand !== "object" || demand === null || Array.isArray(demand)) {
+		throw new Error("ctx.up: PULL requires { pullId, params? } demand payload (D269)");
+	}
+	const pullId = (demand as { pullId?: unknown }).pullId;
+	if (typeof pullId !== "string" && typeof pullId !== "symbol") {
+		throw new Error("ctx.up: PULL demand requires a string or symbol pullId (D269)");
+	}
+	const params = (demand as { params?: unknown }).params;
+	return params === undefined ? { pullId } : { pullId, params };
+}
+
+export function validateDownPayloads(msgs: Wave): void {
+	for (const m of msgs) {
+		if (m[0] === "DATA" && m[1] === undefined) {
+			throw new Error("down: DATA requires a non-SENTINEL payload (R-data-payload)");
+		}
+		if (m[0] === "ERROR" && isInvalidErrorPayload(m[1])) {
+			throw new Error("down: ERROR requires a non-SENTINEL, non-boolean payload (R-data-payload)");
+		}
+	}
+}
diff --git a/packages/ts/src/node/runtime-accessors.ts b/packages/ts/src/node/runtime-accessors.ts
new file mode 100644
index 00000000..9d74a8cd
--- /dev/null
+++ b/packages/ts/src/node/runtime-accessors.ts
@@ -0,0 +1,132 @@
+import type { EnvironmentDrivers } from "../graph/environment.js";
+import type { NodeCore } from "./core.js";
+import type { Node } from "./node.js";
+import type { NodeCheckpointState, NodeRestoreState } from "./types.js";
+
+type TopologyDepsChangedObserver = (
+	node: Node<unknown>,
+	prevDeps: readonly Node<unknown>[],
+	deps: readonly Node<unknown>[],
+) => void;
+
+let constructingCore: NodeCore | undefined;
+let constructingEnvironment: EnvironmentDrivers | undefined;
+export const ownerTokens = new WeakMap<Node<unknown>, unknown>();
+export const topologyDepsChangedObservers = new WeakMap<
+	Node<unknown>,
+	TopologyDepsChangedObserver
+>();
+export const checkpointReaders = new WeakMap<Node<unknown>, () => NodeCheckpointState>();
+export const restoreWriters = new WeakMap<Node<unknown>, (state: NodeRestoreState) => void>();
+export const runtimeReleasers = new WeakMap<Node<unknown>, () => void>();
+export const runtimeQuiescenceReaders = new WeakMap<Node<unknown>, () => boolean>();
+export const subscriberCountReaders = new WeakMap<Node<unknown>, () => number>();
+export const activationReaders = new WeakMap<Node<unknown>, () => boolean>();
+export const releasedNodes = new WeakSet<Node<unknown>>();
+
+/** @internal Run a Node/StateNode constructor against a graph-local core without widening the public constructor. */
+export function withNodeCore<TNode extends Node<unknown>>(
+	core: NodeCore,
+	create: () => TNode,
+): TNode {
+	const prev = constructingCore;
+	constructingCore = core;
+	try {
+		return create();
+	} finally {
+		constructingCore = prev;
+	}
+}
+
+/** @internal Consume the graph-local NodeCore staged by withNodeCore. */
+export function takeConstructingNodeCore(): NodeCore | undefined {
+	const core = constructingCore;
+	constructingCore = undefined;
+	return core;
+}
+
+/** @internal Run a Node/StateNode constructor with graph-owned environment drivers (D130/D131). */
+export function withEnvironmentDrivers<TNode extends Node<unknown>>(
+	environment: EnvironmentDrivers,
+	create: () => TNode,
+): TNode {
+	const prev = constructingEnvironment;
+	constructingEnvironment = environment;
+	try {
+		return create();
+	} finally {
+		constructingEnvironment = prev;
+	}
+}
+
+/** @internal Consume graph-owned environment drivers staged by withEnvironmentDrivers. */
+export function takeConstructingEnvironmentDrivers(): EnvironmentDrivers | undefined {
+	const environment = constructingEnvironment;
+	constructingEnvironment = undefined;
+	return environment;
+}
+
+/** @internal Graph-domain ownership token for D22 intra-graph guards. */
+export function getNodeOwner(n: Node<unknown>): unknown {
+	return ownerTokens.get(n);
+}
+
+/** @internal Assign graph-domain ownership after graph registration. */
+export function setNodeOwner(n: Node<unknown>, owner: unknown): void {
+	ownerTokens.set(n, owner);
+}
+
+/** @internal Graph-layer D145 topology egress hook. */
+export function setNodeTopologyDepsChangedObserver(
+	n: Node<unknown>,
+	observer: TopologyDepsChangedObserver,
+): void {
+	topologyDepsChangedObservers.set(n, observer);
+}
+
+export function notifyTopologyDepsChanged(
+	node: Node<unknown>,
+	prevDeps: readonly Node<unknown>[],
+	deps: readonly Node<unknown>[],
+): void {
+	topologyDepsChangedObservers.get(node)?.(node, prevDeps, deps);
+}
+
+/** @internal Graph checkpoint inspection, kept as a module helper so Node stays method-thin. */
+export function checkpointStateOfNode(n: Node<unknown>): NodeCheckpointState {
+	const read = checkpointReaders.get(n);
+	if (read === undefined) throw new Error("checkpoint: unknown node state");
+	return read();
+}
+
+/** @internal D94 restore commit: install runtime state without a protocol wave or subscription. */
+export function restoreStateOfNode(n: Node<unknown>, state: NodeRestoreState): void {
+	const write = restoreWriters.get(n);
+	if (write === undefined) throw new Error("restoreGraph: unknown node state");
+	write(state);
+}
+
+/** @internal D122 graph-owned ephemeral lifecycle release. */
+export function releaseRuntimeOfNode(n: Node<unknown>): void {
+	runtimeReleasers.get(n)?.();
+}
+
+/** @internal D124 guard for graph-owned ephemeral lifecycle release. */
+export function isNodeRuntimeQuiescentForRelease(n: Node<unknown>): boolean {
+	return runtimeQuiescenceReaders.get(n)?.() ?? false;
+}
+
+/** @internal D124 graph-owned release subscriber accounting. */
+export function subscriberCountOfNode(n: Node<unknown>): number {
+	return subscriberCountReaders.get(n)?.() ?? 0;
+}
+
+/** @internal D124 graph-owned release internal-subscriber accounting. */
+export function isNodeActiveForRelease(n: Node<unknown>): boolean {
+	return activationReaders.get(n)?.() ?? false;
+}
+
+/** @internal D122 guard for graph-owned ephemeral lifecycle release. */
+export function isNodeRuntimeReleased(n: Node<unknown>): boolean {
+	return releasedNodes.has(n);
+}
diff --git a/packages/ts/src/node/types.ts b/packages/ts/src/node/types.ts
new file mode 100644
index 00000000..37ef8cc2
--- /dev/null
+++ b/packages/ts/src/node/types.ts
@@ -0,0 +1,106 @@
+import type { NodeFn } from "../ctx/types.js";
+import type { Dispatcher, Handle } from "../dispatcher/index.js";
+import type { LockId } from "../protocol/messages.js";
+import type { Node } from "./node.js";
+import type { NodeVersion, NodeVersioningPolicy } from "./versioning.js";
+
+export type Status =
+	| "sentinel"
+	| "pending"
+	| "dirty"
+	| "settled"
+	| "resolved"
+	| "completed"
+	| "errored";
+
+export interface NodeOptions<T = unknown> {
+	/** Pre-populate cache; source pushes [DATA, initial] on subscribe (R-initial). `null` is valid. */
+	initial?: T | null;
+	/** First-run gate off when true; fn body must guard SENTINEL per dep (R-first-run-gate). */
+	partial?: boolean;
+	/** A dep terminal also settles the first-run gate (Reduce-class, R-first-run-gate). */
+	terminalAsRealInput?: boolean;
+	/** Auto-emit COMPLETE when ALL deps complete (R-deps-terminal). Default true. */
+	completeWhenDepsComplete?: boolean;
+	/** Auto-emit ERROR when any dep errors (R-deps-terminal). Default true. */
+	errorWhenDepsError?: boolean;
+	/** Allow re-activation after terminal; late subscribe resets the lifecycle (R-terminal). Default false. */
+	resubscribable?: boolean;
+	/** Clear cached value on TEARDOWN. Default false. */
+	resetOnTeardown?: boolean;
+	/** PAUSE/RESUME behavior (R-pause-modes). Default true. */
+	pausable?: boolean | "resumeAll";
+	/**
+	 * Pull-mode node (R-pull / D269): a quiet-until-demanded source, identified by this
+	 * author-supplied `pullId` (a unique LockId — a `Symbol` recommended; NOT the node name, NOT a
+	 * bare string if callers may also use strings as pause locks). QUIET by default: it ABSORBS
+	 * an upstream DIRTY WITHOUT relaying it downstream
+	 * (the wedge fix) and does NOT push-on-subscribe its cached value (START only). A DEMAND =
+	 * cone-routed `PULL({pullId, params?})`: a downstream consumer issues
+	 * `ctx.up([["PULL", { pullId, params }]])` (broadcast up the declared cone) or
+	 * `ctx.up(msgs, towardDep)` (directed) WITHOUT holding this node's reference; the PULL travels
+	 * up to the pullId-holder, which fires EXACTLY ONE delivery (DIRTY-before-DATA when it emits)
+	 * then RE-QUIETS (1:1). Delivery content =
+	 * the orthogonal `pausable` mode: `true` → coalesced LATEST (one DATA); `'resumeAll'` → buffered
+	 * BACKLOG. `pullId` + `pausable:false` is REJECTED at construction. A SELF-triggered demand (a
+	 * consumer demanding a dep it ALSO reads) must defer via {@link import("../ctx/types.js").Ctx.upNext}
+	 * (R-rewire-deferred / D37). Author the pullId as a shared module const used at both this node and
+	 * the demander's fn.
+	 */
+	pullId?: LockId;
+	/** Buffer the last N outgoing DATA for late subscribers (R-replay-buffer). */
+	replayBuffer?: number;
+	/**
+	 * D109 node runtime versioning policy. Default is nodev0 (`{level:0,counter}`); `false`
+	 * disables runtime version metadata for this node.
+	 */
+	versioning?: NodeVersioningPolicy;
+	/** Mark this as a dynamicNode — fn gets ctx.track(i) for read-selection (R-dynamic-node / D35). */
+	dynamic?: boolean;
+	/** Dispatch pool for the fn (R-sync-core). Default sync. */
+	pool?: "sync" | "async";
+	/** Dispatcher to register/invoke against. Default = process-global (D26). */
+	dispatcher?: Dispatcher;
+	/** Optional debug name (graph layer owns real naming/inspection). */
+	name?: string;
+	/**
+	 * Real operator/source factory name for a STANDALONE graph-less node (D43-reserved; D51).
+	 * The graph index (`_entries`) carries the factory for g.*-registered nodes, so this is only
+	 * read for a node NOT in any graph index — a runtime *Map inner (bare `fromAny`/`initNode`
+	 * node) auto-discovered by `describe` (R-describe / R-edges-derived / D51). Off the canonical
+	 * wave path (R-node-thin intact — a pure annotation, never touched by the wave machinery).
+	 */
+	factory?: string;
+}
+
+export interface NodeCheckpointState {
+	readonly cache: unknown;
+	readonly hasData: boolean;
+	readonly terminal: true | unknown | undefined;
+	readonly activated: boolean;
+	readonly hasCalledFnOnce: boolean;
+	readonly ctxState: { readonly value: unknown; readonly persist: boolean };
+	readonly version: NodeVersion | undefined;
+	readonly handle: Handle | null;
+}
+
+export interface NodeRestoreState {
+	readonly cache: unknown;
+	readonly hasData: boolean;
+	readonly status: Status;
+	readonly terminal: true | unknown | undefined;
+	readonly hasCalledFnOnce: boolean;
+	readonly ctxState: { readonly value: unknown; readonly persist: boolean };
+	readonly version: NodeVersion | false;
+}
+
+/** A queued deferred self-rewire op (R-rewire-deferred / D47), drained at the wave boundary. */
+export type RewireOp =
+	| { kind: "add"; dep: Node<unknown>; fn: NodeFn }
+	| { kind: "remove"; dep: Node<unknown>; fn: NodeFn }
+	| { kind: "set"; deps: Node<unknown>[]; fn: NodeFn };
+
+/** Internal routing state for one up-going control wave. */
+export type UpRouteState = {
+	demandFired: Map<LockId, Set<Node<unknown>>>;
+};
diff --git a/packages/ts/src/node/versioning.ts b/packages/ts/src/node/versioning.ts
new file mode 100644
index 00000000..6415f833
--- /dev/null
+++ b/packages/ts/src/node/versioning.ts
@@ -0,0 +1,193 @@
+import { strictCanonicalJsonBytes, strictJsonCodec } from "../json/codec.js";
+
+export type NodeVersioningLevel = 0 | 1;
+
+/**
+ * D112 V1 node-version hash callback.
+ *
+ * The callback receives strict canonical JSON UTF-8 DATA bytes, not the raw host value.
+ * Runtime V1 versioning encodes DATA with `strictCanonicalJsonBytes(value)` before calling hash.
+ */
+export type NodeVersionHashFn = (bytes: Uint8Array) => string;
+
+export type NodeVersioningPolicy =
+	| false
+	| 0
+	| 1
+	| {
+			level: NodeVersioningLevel;
+			hash?: NodeVersionHashFn;
+	  };
+
+export type ResolvedNodeVersioningPolicy =
+	| { readonly enabled: false }
+	| { readonly enabled: true; readonly level: 0 }
+	| { readonly enabled: true; readonly level: 1; readonly hash: NodeVersionHashFn };
+
+export type NodeVersionV0 = {
+	readonly level: 0;
+	readonly counter: number;
+};
+
+export type NodeVersionV1 = {
+	readonly level: 1;
+	readonly counter: number;
+	readonly cid: string;
+	readonly prev: string | null;
+};
+
+export type NodeVersion = NodeVersionV0 | NodeVersionV1;
+
+export type NodeVersionJson = NodeVersion;
+
+const ABSENT_V1_SEED = Object.freeze({
+	"@graphrefly/node-version": "v1-absent",
+});
+
+function fnv1a64(input: Uint8Array): string {
+	let hash = 0xcbf29ce484222325n;
+	const prime = 0x100000001b3n;
+	for (const byte of input) {
+		hash ^= BigInt(byte);
+		hash = BigInt.asUintN(64, hash * prime);
+	}
+	return hash.toString(16).padStart(16, "0");
+}
+
+/**
+ * Default synchronous D112 V1 node-version hash over strict canonical JSON UTF-8 bytes.
+ *
+ * When hashing a host value directly, encode first:
+ * `defaultNodeVersionHash(strictCanonicalJsonBytes(value))`.
+ */
+export function defaultNodeVersionHash(bytes: Uint8Array): string {
+	return `fnv1a64:${fnv1a64(bytes)}`;
+}
+
+function computeV1Cid(
+	policy: Extract<ResolvedNodeVersioningPolicy, { enabled: true; level: 1 }>,
+	value: unknown,
+): string {
+	return policy.hash(strictCanonicalJsonBytes(value));
+}
+
+export function assertNodeVersionDataCompatible(
+	policy: ResolvedNodeVersioningPolicy,
+	value: unknown,
+): void {
+	if (!policy.enabled || policy.level === 0) return;
+	strictCanonicalJsonBytes(value);
+}
+
+export function snapshotNodeVersionData(
+	policy: ResolvedNodeVersioningPolicy,
+	value: unknown,
+): unknown {
+	if (!policy.enabled || policy.level === 0) return value;
+	const bytes = strictCanonicalJsonBytes(value);
+	return strictJsonCodec.decode(bytes);
+}
+
+export function resolveNodeVersioningPolicy(
+	policy: NodeVersioningPolicy | undefined,
+): ResolvedNodeVersioningPolicy {
+	if (policy === false) return { enabled: false };
+	if (policy === undefined || policy === 0) return { enabled: true, level: 0 };
+	if (policy === 1) return { enabled: true, level: 1, hash: defaultNodeVersionHash };
+	if (typeof policy === "object" && policy !== null) {
+		if (policy.level === 0) return { enabled: true, level: 0 };
+		if (policy.level === 1) {
+			return { enabled: true, level: 1, hash: policy.hash ?? defaultNodeVersionHash };
+		}
+	}
+	throw new Error("node: versioning level must be 0 or 1; V2/V3 are not locked yet (D109)");
+}
+
+export function createNodeVersion(
+	policy: ResolvedNodeVersioningPolicy,
+	initialValue: unknown = ABSENT_V1_SEED,
+): NodeVersion | undefined {
+	if (!policy.enabled) return undefined;
+	if (policy.level === 0) return Object.freeze({ level: 0, counter: 0 });
+	return Object.freeze({
+		level: 1,
+		counter: 0,
+		cid: computeV1Cid(policy, initialValue),
+		prev: null,
+	});
+}
+
+export function advanceNodeVersion(
+	current: NodeVersion | undefined,
+	policy: ResolvedNodeVersioningPolicy,
+	value: unknown,
+): NodeVersion | undefined {
+	if (!policy.enabled) return undefined;
+	if (current === undefined) return createNodeVersion(policy, value);
+	if (policy.level === 0) {
+		return Object.freeze({ level: 0, counter: current.counter + 1 });
+	}
+	const previous = current.level === 1 ? current.cid : null;
+	return Object.freeze({
+		level: 1,
+		counter: current.counter + 1,
+		cid: computeV1Cid(policy, value),
+		prev: previous,
+	});
+}
+
+export function cloneNodeVersion(version: NodeVersion | undefined): NodeVersion | undefined {
+	if (version === undefined) return undefined;
+	if (version.level === 0) return Object.freeze({ level: 0, counter: version.counter });
+	return Object.freeze({
+		level: 1,
+		counter: version.counter,
+		cid: version.cid,
+		prev: version.prev,
+	});
+}
+
+export function restoredV1Cid(
+	policy: Extract<ResolvedNodeVersioningPolicy, { enabled: true; level: 1 }>,
+	hasData: boolean,
+	cache: unknown,
+): string {
+	return computeV1Cid(policy, hasData ? cache : ABSENT_V1_SEED);
+}
+
+export function validateNodeVersionJson(value: unknown, path: string): NodeVersionJson {
+	if (typeof value !== "object" || value === null) {
+		throw new Error(`restoreGraph: ${path} must be an object`);
+	}
+	const record = value as Record<string, unknown>;
+	if (record.level === 0) {
+		if (!Number.isSafeInteger(record.counter) || (record.counter as number) < 0) {
+			throw new Error(`restoreGraph: ${path}.counter must be a non-negative safe integer`);
+		}
+		return Object.freeze({ level: 0, counter: record.counter as number });
+	}
+	if (record.level === 1) {
+		if (!Number.isSafeInteger(record.counter) || (record.counter as number) < 0) {
+			throw new Error(`restoreGraph: ${path}.counter must be a non-negative safe integer`);
+		}
+		if (typeof record.cid !== "string") {
+			throw new Error(`restoreGraph: ${path}.cid must be a string`);
+		}
+		if (record.prev !== null && typeof record.prev !== "string") {
+			throw new Error(`restoreGraph: ${path}.prev must be a string or null`);
+		}
+		if ((record.counter as number) === 0 && record.prev !== null) {
+			throw new Error(`restoreGraph: ${path}.prev must be null when counter is 0`);
+		}
+		if ((record.counter as number) > 0 && typeof record.prev !== "string") {
+			throw new Error(`restoreGraph: ${path}.prev must be a string when counter is > 0`);
+		}
+		return Object.freeze({
+			level: 1,
+			counter: record.counter as number,
+			cid: record.cid,
+			prev: record.prev,
+		});
+	}
+	throw new Error(`restoreGraph: ${path}.level must be 0 or 1`);
+}
diff --git a/packages/ts/src/operators/index.ts b/packages/ts/src/operators/index.ts
new file mode 100644
index 00000000..81731c90
--- /dev/null
+++ b/packages/ts/src/operators/index.ts
@@ -0,0 +1,66 @@
+export {
+	buffer,
+	bufferCount,
+	combine,
+	combineLatest,
+	concat,
+	race,
+	sample,
+	takeUntil,
+	withLatestFrom,
+	zip,
+} from "../graph/combinators.js";
+export {
+	concatMap,
+	exhaustMap,
+	flatMap,
+	type MergeMapOptions,
+	mergeMap,
+	type Project,
+	repeat,
+	switchMap,
+} from "../graph/higher-order.js";
+export {
+	catchError,
+	type DefineOpts,
+	type Definition,
+	define,
+	distinctUntilChanged,
+	elementAt,
+	filter,
+	find,
+	first,
+	initNode,
+	last,
+	map,
+	merge,
+	type Operator,
+	onFirstData,
+	pairwise,
+	type RestoreRegistryEntry,
+	reduce,
+	rescue,
+	restoreRegistry,
+	type SettleOpts,
+	scan,
+	settle,
+	skip,
+	type TapObserver,
+	take,
+	takeWhile,
+	tap,
+	tapFirst,
+	type ValveOpts,
+	valve,
+} from "../graph/operators.js";
+export {
+	audit,
+	auditTime,
+	bufferTime,
+	debounce,
+	debounceTime,
+	delay,
+	throttle,
+	throttleTime,
+	timeout,
+} from "../graph/time.js";
diff --git a/packages/ts/src/orchestration/agent-runtime-adapter-retention.ts b/packages/ts/src/orchestration/agent-runtime-adapter-retention.ts
new file mode 100644
index 00000000..e0c9ac22
--- /dev/null
+++ b/packages/ts/src/orchestration/agent-runtime-adapter-retention.ts
@@ -0,0 +1,506 @@
+import type { Ctx } from "../ctx/types.js";
+import type { DataIssue } from "../data/index.js";
+import type { Graph } from "../graph/graph.js";
+import {
+	PolicyInputs,
+	type PolicyReader,
+	selectRetentionVictims,
+	trimHeadOverflow,
+} from "../graph/policies/collection.js";
+import type { CapacityPolicy, ReactiveOpt } from "../graph/policies/types.js";
+import { Node } from "../node/node.js";
+import {
+	canonicalPublicSourceRefs,
+	dataIssue,
+	isPlainRecord,
+	publicMaterialForbiddenKeys,
+	stableStringHash,
+} from "./agent-runtime-common.js";
+import type { SourceRef } from "./agent-runtime-types-core.js";
+import type {
+	ToolProviderAdapterExecutionRetentionEntry,
+	ToolProviderAdapterInput,
+	ToolProviderAdapterInputRetentionEntry,
+	ToolProviderAdapterRunIssueRetentionEntry,
+	ToolProviderAdapterRunRequested,
+	ToolProviderAdapterRunRequestRetentionEntry,
+	ToolProviderAdapterRunStatus,
+	ToolProviderAdapterRunStatusRetentionEntry,
+	ToolProviderAdapterRuntimeIndexRetentionPolicy,
+	ToolProviderAdapterRuntimeRetentionEvidenceEntry,
+	ToolProviderAdapterRuntimeRetentionIndex,
+	ToolProviderAdapterRuntimeRetentionPolicy,
+} from "./agent-runtime-types-tool.js";
+
+export type RuntimeRetentionMode = "fifo" | "score";
+
+export interface RuntimeRetentionIndexConfig {
+	readonly maxSize?: number;
+	readonly mode: RuntimeRetentionMode;
+}
+
+export interface RuntimeRetentionPolicyFact {
+	readonly kind: "tool-provider-adapter-runtime-retention-policy";
+	readonly policies: ReadonlyMap<
+		ToolProviderAdapterRuntimeRetentionIndex,
+		RuntimeRetentionIndexConfig
+	>;
+	readonly issues?: readonly DataIssue[];
+}
+
+export interface RuntimeRetentionPolicyReaders {
+	readonly inputs: PolicyInputs;
+	readonly readers: ReadonlyMap<ToolProviderAdapterRuntimeRetentionIndex, PolicyReader<number>>;
+	readonly statics: ReadonlyMap<ToolProviderAdapterRuntimeRetentionIndex, number | undefined>;
+}
+
+export type EffectiveRuntimeRetentionPolicy = Partial<{
+	readonly adapterInputs: RuntimeRetentionIndexConfig;
+	readonly runRequests: RuntimeRetentionIndexConfig;
+	readonly executions: RuntimeRetentionIndexConfig;
+	readonly runStatuses: RuntimeRetentionIndexConfig;
+	readonly runIssues: RuntimeRetentionIndexConfig;
+	readonly retentionEvidence: RuntimeRetentionIndexConfig;
+}>;
+
+export type ReplayEvidenceGapKind =
+	| "adapter-input-trimmed"
+	| "execution-proof-trimmed"
+	| "evidence-horizon"
+	| "evidence-horizon-closed";
+
+export type ReplayEvidenceClassification =
+	| { readonly kind: "fresh" }
+	| { readonly kind: "missing-input" }
+	| {
+			readonly kind: "retention-gap";
+			readonly index: ToolProviderAdapterRuntimeRetentionIndex;
+			readonly gapKind: ReplayEvidenceGapKind;
+			readonly key?: string;
+	  };
+
+export interface RuntimeIndexItem<Entry, Value> {
+	readonly key: string;
+	readonly entry: Entry;
+	readonly value: Value;
+}
+
+export interface RuntimeRetentionTrackedValue<Value> {
+	readonly fact: Value;
+	readonly dropKey?: () => void;
+}
+
+export interface ToolProviderAdapterRunProjectorPrivateRetentionHooks {
+	readonly onAdapterInputKey?: (entry: {
+		readonly adapterInputId: string;
+		readonly dropInput: () => void;
+	}) => void;
+	readonly classifyRetainedRunRequestReplayEvidence?: (
+		request: ToolProviderAdapterRunRequested,
+	) => ReplayEvidenceClassification;
+	readonly onRunRequestKey?: (entry: {
+		readonly key: string;
+		readonly request: ToolProviderAdapterRunRequested;
+		readonly dropKey: () => void;
+	}) => void;
+	readonly onRunStatusKey?: (entry: {
+		readonly key: string;
+		readonly status: ToolProviderAdapterRunStatus;
+		readonly dropKey: () => void;
+	}) => void;
+	readonly onRunIssueKey?: (entry: {
+		readonly key: string;
+		readonly issue: DataIssue;
+		readonly dropKey: () => void;
+	}) => void;
+}
+
+export class RuntimeRetentionIndex<Entry extends { readonly sequence: number }, Value> {
+	private readonly items = new Map<string, RuntimeIndexItem<Entry, Value>>();
+
+	get size(): number {
+		return this.items.size;
+	}
+
+	get(key: string): RuntimeIndexItem<Entry, Value> | undefined {
+		return this.items.get(key);
+	}
+
+	has(key: string): boolean {
+		return this.items.has(key);
+	}
+
+	set(key: string, entry: Entry, value: Value): RuntimeIndexItem<Entry, Value> {
+		const item = { key, entry, value };
+		this.items.set(key, item);
+		return item;
+	}
+
+	delete(key: string): RuntimeIndexItem<Entry, Value> | undefined {
+		const item = this.items.get(key);
+		if (item !== undefined) this.items.delete(key);
+		return item;
+	}
+
+	trimFifo(maxSize: number): RuntimeIndexItem<Entry, Value>[] {
+		const items = Array.from(this.items.values()).sort(
+			(a, b) => a.entry.sequence - b.entry.sequence,
+		);
+		return trimHeadOverflow(items, { maxSize })
+			.map((item) => this.delete(item.key))
+			.filter((item): item is RuntimeIndexItem<Entry, Value> => item !== undefined);
+	}
+
+	trimScored(
+		maxSize: number,
+		score: (entry: Entry) => number,
+	): {
+		readonly victims?: RuntimeIndexItem<Entry, Value>[];
+		readonly invalid?: "threw" | "non-finite";
+	} {
+		const scored: { readonly entry: RuntimeIndexItem<Entry, Value>; readonly score: number }[] = [];
+		for (const item of this.items.values()) {
+			let value: number;
+			try {
+				value = score(item.entry);
+			} catch {
+				return { invalid: "threw" };
+			}
+			if (!Number.isFinite(value)) return { invalid: "non-finite" };
+			scored.push({ entry: item, score: value });
+		}
+		const victims = selectRetentionVictims(scored, { maxSize }).map((item) =>
+			this.delete(item.key),
+		);
+		return {
+			victims: victims.filter((item): item is RuntimeIndexItem<Entry, Value> => item !== undefined),
+		};
+	}
+}
+
+export const toolProviderAdapterRuntimeRetentionIndexes = Object.freeze([
+	"adapterInputs",
+	"runRequests",
+	"executions",
+	"runStatuses",
+	"runIssues",
+	"retentionEvidence",
+] as const satisfies readonly ToolProviderAdapterRuntimeRetentionIndex[]);
+
+export function toolProviderAdapterRuntimeRetentionIndex(
+	value: string | undefined,
+): ToolProviderAdapterRuntimeRetentionIndex | undefined {
+	return toolProviderAdapterRuntimeRetentionIndexes.find((index) => index === value);
+}
+
+export function isNodeOpt<T>(value: ReactiveOpt<T> | undefined): value is Node<T> {
+	return value instanceof Node;
+}
+
+export function retentionIndexSourceRef(
+	index: ToolProviderAdapterRuntimeRetentionIndex,
+): SourceRef {
+	return { kind: "tool-provider-adapter-runtime-retention-index", id: index };
+}
+
+export function runtimeEvidenceSourceRefs(
+	index: ToolProviderAdapterRuntimeRetentionIndex,
+	refs: readonly SourceRef[] = [],
+): readonly SourceRef[] {
+	return canonicalPublicSourceRefs([...refs, retentionIndexSourceRef(index)]);
+}
+
+export function runtimeEvidenceMetadata(
+	index: ToolProviderAdapterRuntimeRetentionIndex,
+	opts: {
+		readonly key?: string;
+		readonly extra?: Record<string, unknown>;
+	} = {},
+): Record<string, unknown> {
+	return {
+		index,
+		...(opts.key === undefined ? {} : { key: runtimeDiagnosticKey(opts.key) }),
+		...(opts.extra ?? {}),
+	};
+}
+
+export function runtimeDiagnosticKey(key: string): string {
+	return `key:${stableStringHash(key)}:${key.length}`;
+}
+
+export const maxRuntimeRetentionScorerStringChars = 256;
+
+export function runtimeRetentionScorerEntry<Entry>(
+	index: ToolProviderAdapterRuntimeRetentionIndex,
+	entry: Entry,
+): Entry {
+	if (!isPlainRecord(entry) || publicMaterialForbiddenKeys(entry, "provider").length > 0) {
+		throw new TypeError(`unsafe ${index} retention scorer entry`);
+	}
+	const bounded: Record<string, unknown> = {};
+	for (const value of Object.values(entry)) {
+		if (value !== undefined && typeof value !== "string" && typeof value !== "number") {
+			throw new TypeError(`unsafe ${index} retention scorer entry`);
+		}
+	}
+	for (const [key, value] of Object.entries(entry)) {
+		bounded[key] =
+			key === "key" && typeof value === "string"
+				? runtimeDiagnosticKey(value)
+				: typeof value === "string" && value.length > maxRuntimeRetentionScorerStringChars
+					? `bounded:${stableStringHash(value)}:${value.length}`
+					: value;
+	}
+	return Object.freeze(bounded) as Entry;
+}
+
+export function retentionPolicyMaxSize(
+	policy: ToolProviderAdapterRuntimeIndexRetentionPolicy<unknown> | undefined,
+): ReactiveOpt<number> | undefined {
+	return policy?.maxSize;
+}
+
+export function retentionPolicyMode(
+	policy: ToolProviderAdapterRuntimeIndexRetentionPolicy<unknown> | undefined,
+): RuntimeRetentionMode | undefined {
+	if (policy === undefined) return undefined;
+	return "score" in policy && policy.score !== undefined ? "score" : "fifo";
+}
+
+export function buildRetentionPolicyReaders(
+	graph: Graph,
+	name: string,
+	retention: ToolProviderAdapterRuntimeRetentionPolicy | undefined,
+): RuntimeRetentionPolicyReaders {
+	const inputs = new PolicyInputs();
+	const readers = new Map<ToolProviderAdapterRuntimeRetentionIndex, PolicyReader<number>>();
+	const statics = new Map<ToolProviderAdapterRuntimeRetentionIndex, number | undefined>();
+	for (const index of toolProviderAdapterRuntimeRetentionIndexes) {
+		const policy = retention?.[index] as
+			| ToolProviderAdapterRuntimeIndexRetentionPolicy<unknown>
+			| undefined;
+		const maxSize = retentionPolicyMaxSize(policy);
+		if (maxSize === undefined) {
+			statics.set(index, undefined);
+			readers.set(index, inputs.add(undefined));
+			continue;
+		}
+		const node = isNodeOpt(maxSize)
+			? maxSize
+			: graph.node<number>([], null, {
+					name: `${name}/retentionPolicy/${index}/maxSize`,
+					factory: "toolProviderAdapterRuntimeRetentionPolicy.maxSize",
+					initial: maxSize,
+				});
+		if (!isNodeOpt(maxSize)) statics.set(index, maxSize);
+		readers.set(index, inputs.add(node));
+	}
+	return { inputs, readers, statics };
+}
+
+export function readRetentionPolicyFact(
+	ctx: Ctx,
+	retention: ToolProviderAdapterRuntimeRetentionPolicy | undefined,
+	readers: RuntimeRetentionPolicyReaders,
+	current: RuntimeRetentionPolicyFact | undefined,
+): RuntimeRetentionPolicyFact {
+	const policies = new Map<ToolProviderAdapterRuntimeRetentionIndex, RuntimeRetentionIndexConfig>();
+	const issues: DataIssue[] = [];
+	for (const index of toolProviderAdapterRuntimeRetentionIndexes) {
+		const raw = retention?.[index] as
+			| ToolProviderAdapterRuntimeIndexRetentionPolicy<unknown>
+			| undefined;
+		if (raw === undefined) continue;
+		const reader = readers.readers.get(index);
+		const previous = current?.policies.get(index)?.maxSize ?? readers.statics.get(index);
+		const maxSize = reader?.read(ctx, previous);
+		const issue = validateRuntimeRetentionPolicy(index, raw, maxSize);
+		if (issue !== undefined) {
+			issues.push(issue);
+			continue;
+		}
+		policies.set(index, {
+			maxSize,
+			mode: retentionPolicyMode(raw) ?? "fifo",
+		});
+	}
+	return {
+		kind: "tool-provider-adapter-runtime-retention-policy",
+		policies,
+		...(issues.length === 0 ? {} : { issues: Object.freeze(issues) }),
+	};
+}
+
+export function validateRuntimeRetentionPolicy(
+	index: ToolProviderAdapterRuntimeRetentionIndex,
+	policy: ToolProviderAdapterRuntimeIndexRetentionPolicy<unknown>,
+	maxSize: number | undefined,
+): DataIssue | undefined {
+	if ("score" in policy && policy.score !== undefined && typeof policy.score !== "function")
+		return invalidRetentionPolicyIssue(index, "score must be a function");
+	if (!("score" in policy) || policy.score === undefined) {
+		const order = (policy as CapacityPolicy<string>).order ?? "fifo";
+		if (order !== "fifo") return invalidRetentionPolicyIssue(index, "order must be fifo");
+	}
+	if (maxSize === undefined || !Number.isSafeInteger(maxSize) || maxSize < 1)
+		return invalidRetentionPolicyIssue(index, "maxSize must be a safe integer >= 1");
+	return undefined;
+}
+
+export function invalidRetentionPolicyIssue(
+	index: ToolProviderAdapterRuntimeRetentionIndex,
+	reason: string,
+): DataIssue {
+	return dataIssue(
+		"tool-provider-adapter-runtime-invalid-retention-policy",
+		"Tool provider adapter runtime retention policy is invalid; last-known-good policy remains active.",
+		{
+			subjectId: index,
+			refs: [retentionIndexSourceRef(index)],
+			details: { index, reason },
+			severity: "warning",
+		},
+	);
+}
+
+export function adapterInputRetentionEntry(
+	key: string,
+	sequence: number,
+	input: ToolProviderAdapterInput,
+	insertedAtMs: number | undefined,
+): ToolProviderAdapterInputRetentionEntry {
+	return Object.freeze({
+		key,
+		sequence,
+		...(insertedAtMs === undefined ? {} : { insertedAtMs }),
+		adapterInputId: input.adapterInputId,
+		requestId: input.requestId,
+		operationId: input.operationId,
+		...(input.routeId === undefined ? {} : { routeId: input.routeId }),
+		...(input.providerId === undefined ? {} : { providerId: input.providerId }),
+		...(input.executorId === undefined ? {} : { executorId: input.executorId }),
+		...(input.profileId === undefined ? {} : { profileId: input.profileId }),
+		status: input.status,
+	});
+}
+
+export function runRequestRetentionEntry(
+	key: string,
+	sequence: number,
+	request: ToolProviderAdapterRunRequested,
+): ToolProviderAdapterRunRequestRetentionEntry {
+	return Object.freeze({
+		key,
+		sequence,
+		...(request.requestedAtMs === undefined ? {} : { requestedAtMs: request.requestedAtMs }),
+		adapterInputId: request.adapterInputId,
+		runId: request.runId,
+		attempt: request.attempt,
+		requestId: request.requestId,
+		operationId: request.operationId,
+		...(request.routeId === undefined ? {} : { routeId: request.routeId }),
+		...(request.providerId === undefined ? {} : { providerId: request.providerId }),
+		...(request.executorId === undefined ? {} : { executorId: request.executorId }),
+		...(request.profileId === undefined ? {} : { profileId: request.profileId }),
+		reason: request.reason,
+	});
+}
+
+export function executionRetentionEntry(
+	key: string,
+	sequence: number,
+	request: ToolProviderAdapterRunRequested,
+	status: ToolProviderAdapterExecutionRetentionEntry["status"],
+	occurredAtMs: number | undefined,
+	outcomeId?: string,
+): ToolProviderAdapterExecutionRetentionEntry {
+	return Object.freeze({
+		key,
+		sequence,
+		...(occurredAtMs === undefined ? {} : { occurredAtMs }),
+		adapterInputId: request.adapterInputId,
+		runId: request.runId,
+		attempt: request.attempt,
+		requestId: request.requestId,
+		operationId: request.operationId,
+		...(request.routeId === undefined ? {} : { routeId: request.routeId }),
+		...(request.providerId === undefined ? {} : { providerId: request.providerId }),
+		...(request.executorId === undefined ? {} : { executorId: request.executorId }),
+		...(request.profileId === undefined ? {} : { profileId: request.profileId }),
+		...(outcomeId === undefined ? {} : { outcomeId }),
+		status,
+		reason: request.reason,
+	});
+}
+
+export function runStatusRetentionEntry(
+	key: string,
+	sequence: number,
+	status: ToolProviderAdapterRunStatus,
+	occurredAtMs: number | undefined,
+): ToolProviderAdapterRunStatusRetentionEntry {
+	const issueCode = status.issues?.[0]?.code;
+	return Object.freeze({
+		key,
+		sequence,
+		...(occurredAtMs === undefined ? {} : { occurredAtMs }),
+		adapterInputId: status.adapterInputId,
+		runId: status.runId,
+		...(status.attempt === undefined ? {} : { attempt: status.attempt }),
+		...(status.requestId === undefined ? {} : { requestId: status.requestId }),
+		...(status.operationId === undefined ? {} : { operationId: status.operationId }),
+		status: status.status,
+		...(status.outcomeId === undefined ? {} : { outcomeId: status.outcomeId }),
+		...(issueCode === undefined ? {} : { issueCode }),
+	});
+}
+
+export function runIssueRetentionEntry(
+	key: string,
+	sequence: number,
+	issue: DataIssue,
+	occurredAtMs: number | undefined,
+	context: {
+		readonly adapterInputId?: string;
+		readonly runId?: string;
+		readonly attempt?: number;
+		readonly requestId?: string;
+		readonly operationId?: string;
+	} = {},
+): ToolProviderAdapterRunIssueRetentionEntry {
+	return Object.freeze({
+		key,
+		sequence,
+		...(occurredAtMs === undefined ? {} : { occurredAtMs }),
+		...(context.adapterInputId === undefined ? {} : { adapterInputId: context.adapterInputId }),
+		...(context.runId === undefined ? {} : { runId: context.runId }),
+		...(context.attempt === undefined ? {} : { attempt: context.attempt }),
+		...(context.requestId === undefined ? {} : { requestId: context.requestId }),
+		...(context.operationId === undefined ? {} : { operationId: context.operationId }),
+		issueCode: issue.code,
+		...(issue.severity === undefined ? {} : { severity: issue.severity }),
+		...(issue.subjectId === undefined ? {} : { subjectId: issue.subjectId }),
+	});
+}
+
+export function retentionEvidenceEntry(
+	key: string,
+	sequence: number,
+	opts: {
+		readonly adapterInputId: string;
+		readonly evidenceKind: ToolProviderAdapterRuntimeRetentionEvidenceEntry["evidenceKind"];
+		readonly occurredAtMs?: number;
+		readonly attemptHighWater?: number;
+		readonly reason: ToolProviderAdapterRuntimeRetentionEvidenceEntry["reason"];
+	},
+): ToolProviderAdapterRuntimeRetentionEvidenceEntry {
+	return Object.freeze({
+		key,
+		sequence,
+		...(opts.occurredAtMs === undefined ? {} : { occurredAtMs: opts.occurredAtMs }),
+		adapterInputId: opts.adapterInputId,
+		evidenceKind: opts.evidenceKind,
+		...(opts.attemptHighWater === undefined ? {} : { attemptHighWater: opts.attemptHighWater }),
+		reason: opts.reason,
+	});
+}
diff --git a/packages/ts/src/orchestration/agent-runtime-adapter-run.ts b/packages/ts/src/orchestration/agent-runtime-adapter-run.ts
new file mode 100644
index 00000000..d0d1a9ed
--- /dev/null
+++ b/packages/ts/src/orchestration/agent-runtime-adapter-run.ts
@@ -0,0 +1,776 @@
+import { type Ctx, depBatch } from "../ctx/types.js";
+import type { DataIssue } from "../data/index.js";
+import type { Graph } from "../graph/graph.js";
+import type { Node } from "../node/node.js";
+import type { ToolProviderAdapterRunProjectorPrivateRetentionHooks } from "./agent-runtime-adapter-retention.js";
+import {
+	boundPublicText,
+	dataIssue,
+	forbiddenDataKeys,
+	forbiddenProviderRawMaterialKeys,
+	forEachDepBatch,
+	isRecord,
+	maxPublicReasonChars,
+	projectRuntimeFact,
+	ref,
+	sanitizeAdapterInputIssue,
+	sanitizeAdapterInputSourceRefs,
+	sanitizeProviderGraphVisibleRecord,
+	stableJsonStringify,
+	stableStringHash,
+} from "./agent-runtime-common.js";
+import type { AgentRuntimeAuditRecord } from "./agent-runtime-types-agent.js";
+import type { SourceRef } from "./agent-runtime-types-core.js";
+import type {
+	ToolProviderAdapterBinding,
+	ToolProviderAdapterInput,
+	ToolProviderAdapterRunBundle,
+	ToolProviderAdapterRunReason,
+	ToolProviderAdapterRunRequested,
+	ToolProviderAdapterRunStatus,
+	ToolProviderPublicTextPolicy,
+} from "./agent-runtime-types-tool.js";
+
+export function normalizeToolProviderAdapterBindings<TArguments, TResult>(
+	bindings:
+		| readonly ToolProviderAdapterBinding<TArguments, TResult>[]
+		| ReadonlyMap<string, ToolProviderAdapterBinding<TArguments, TResult>>,
+): ReadonlyMap<string, ToolProviderAdapterBinding<TArguments, TResult>> {
+	const result = new Map<string, ToolProviderAdapterBinding<TArguments, TResult>>();
+	const bindingList = Array.isArray(bindings)
+		? (bindings as readonly ToolProviderAdapterBinding<TArguments, TResult>[])
+		: undefined;
+	if (bindingList === undefined) {
+		const bindingMap = bindings as ReadonlyMap<
+			string,
+			ToolProviderAdapterBinding<TArguments, TResult>
+		>;
+		for (const [providerId, binding] of bindingMap.entries()) {
+			if (providerId !== binding.providerId) {
+				throw new RangeError(
+					`attachToolProviderAdapterRuntime: binding key '${providerId}' must match provider '${binding.providerId}'`,
+				);
+			}
+			result.set(providerId, binding);
+		}
+		return result;
+	}
+	for (const binding of bindingList) {
+		if (result.has(binding.providerId)) {
+			throw new RangeError(
+				`attachToolProviderAdapterRuntime: duplicate binding for provider '${binding.providerId}'`,
+			);
+		}
+		result.set(binding.providerId, binding);
+	}
+	return result;
+}
+
+export function requestToolProviderAdapterRun(
+	input: ToolProviderAdapterInput,
+	opts: {
+		readonly runId?: string;
+		readonly attempt?: number;
+		readonly reason?: ToolProviderAdapterRunReason;
+		readonly retryOfOutcomeId?: string;
+		readonly policyRefs?: readonly SourceRef[];
+		readonly sourceRefs?: readonly SourceRef[];
+		readonly metadata?: Record<string, unknown>;
+		readonly requestedAtMs?: number;
+	} = {},
+): ToolProviderAdapterRunRequested {
+	const attempt = opts.attempt ?? 1;
+	return Object.freeze({
+		kind: "tool-provider-adapter-run-requested",
+		runId: opts.runId ?? defaultToolProviderAdapterRunId(input.adapterInputId, attempt, input),
+		adapterInputId: input.adapterInputId,
+		requestId: input.requestId,
+		operationId: input.operationId,
+		routeId: input.routeId,
+		providerId: input.providerId,
+		executorId: input.executorId,
+		profileId: input.profileId,
+		attempt,
+		reason: sanitizeToolProviderAdapterRunReason(opts.reason, attempt),
+		retryOfOutcomeId: opts.retryOfOutcomeId,
+		policyRefs: sanitizeAdapterInputSourceRefs(opts.policyRefs ?? input.policyRefs ?? []),
+		sourceRefs: sanitizeAdapterInputSourceRefs([
+			ref("tool-provider-adapter-input", input.adapterInputId),
+			...(input.sourceRefs ?? []),
+			...(opts.sourceRefs ?? []),
+		]),
+		metadata: sanitizeProviderGraphVisibleRecord(opts.metadata),
+		requestedAtMs: opts.requestedAtMs,
+	} satisfies ToolProviderAdapterRunRequested);
+}
+
+export function toolProviderAdapterRunProjector(
+	graph: Graph,
+	opts: {
+		readonly name?: string;
+		readonly inputs: Node<ToolProviderAdapterInput>;
+		readonly runRequests?: readonly Node<ToolProviderAdapterRunRequested>[];
+		readonly autoRunReadyInputs?: boolean;
+		readonly now?: () => number;
+	},
+): ToolProviderAdapterRunBundle {
+	return toolProviderAdapterRunProjectorInternal(graph, opts);
+}
+
+export function toolProviderAdapterRunProjectorInternal(
+	graph: Graph,
+	opts: {
+		readonly name?: string;
+		readonly inputs: Node<ToolProviderAdapterInput>;
+		readonly runRequests?: readonly Node<ToolProviderAdapterRunRequested>[];
+		readonly autoRunReadyInputs?: boolean;
+		readonly now?: () => number;
+		readonly publicText?: ToolProviderPublicTextPolicy;
+		readonly privateRetentionHooks?: ToolProviderAdapterRunProjectorPrivateRetentionHooks;
+	},
+): ToolProviderAdapterRunBundle {
+	const name = opts.name ?? "toolProviderAdapterRun";
+	const explicitRunDeps = opts.runRequests ?? [];
+	const autoRunReadyInputs = opts.autoRunReadyInputs ?? true;
+	const runtime = graph.node<ToolProviderAdapterRunFact>(
+		[opts.inputs, ...explicitRunDeps],
+		(ctx) => {
+			const state = ctx.state.get<ToolProviderAdapterRunProjectorState>() ?? {
+				inputs: new Map<string, ToolProviderAdapterInput>(),
+				emittedKeys: new Set<string>(),
+				statusKeys: new Set<string>(),
+				issueKeys: new Set<string>(),
+				auditSeq: 0,
+			};
+			for (const raw of depBatch(ctx, 0) ?? []) {
+				const input = raw as ToolProviderAdapterInput;
+				state.inputs.set(input.adapterInputId, input);
+				opts.privateRetentionHooks?.onAdapterInputKey?.({
+					adapterInputId: input.adapterInputId,
+					dropInput: () => {
+						state.inputs.delete(input.adapterInputId);
+					},
+				});
+				if (input.status !== "ready") continue;
+				if (autoRunReadyInputs) {
+					emitRunRequested(
+						ctx,
+						state,
+						requestToolProviderAdapterRun(input, {
+							requestedAtMs: opts.now?.(),
+						}),
+						opts.privateRetentionHooks,
+					);
+				} else if (explicitRunDeps.length === 0) {
+					emitRunIssue(
+						ctx,
+						state,
+						"tool-provider-adapter-run-request-missing",
+						"Ready tool provider adapter input has no visible run request.",
+						input.adapterInputId,
+						[ref("tool-provider-adapter-input", input.adapterInputId)],
+						opts.privateRetentionHooks,
+					);
+					emitRunStatus(
+						ctx,
+						state,
+						{
+							kind: "tool-provider-adapter-run-status",
+							runId: defaultToolProviderAdapterRunId(input.adapterInputId, 1, input),
+							adapterInputId: input.adapterInputId,
+							requestId: input.requestId,
+							operationId: input.operationId,
+							status: "missing-request",
+							attempt: 1,
+							sourceRefs: [ref("tool-provider-adapter-input", input.adapterInputId)],
+						},
+						opts.privateRetentionHooks,
+					);
+				}
+			}
+			forEachDepBatch(ctx, 1, explicitRunDeps.length, (raw) => {
+				if (!isToolProviderAdapterRunRequestedLike(raw)) {
+					const request = fallbackToolProviderAdapterRunRequest(raw, opts.publicText);
+					const issue = dataIssue(
+						"tool-provider-adapter-run-request-invalid-shape",
+						"Tool provider adapter run request must be a data object with runId, adapterInputId, requestId, operationId, and attempt.",
+						{
+							subjectId: request.adapterInputId,
+							refs: [ref("tool-provider-adapter-run", request.runId)],
+						},
+					);
+					emitRunIssueFact(ctx, state, issue, opts.privateRetentionHooks);
+					emitRunStatus(
+						ctx,
+						state,
+						{
+							kind: "tool-provider-adapter-run-status",
+							runId: request.runId,
+							adapterInputId: request.adapterInputId,
+							requestId: request.requestId,
+							operationId: request.operationId,
+							status: "mismatched-request",
+							attempt: request.attempt,
+							issues: [issue],
+							sourceRefs: request.sourceRefs,
+						},
+						opts.privateRetentionHooks,
+					);
+					emitRunAudit(ctx, state, "tool-provider-adapter-run-request-invalid-shape", request, {
+						issueCode: issue.code,
+					});
+					return;
+				}
+				const request = raw;
+				const input = state.inputs.get(request.adapterInputId);
+				if (input === undefined) {
+					const replayClassification =
+						opts.privateRetentionHooks?.classifyRetainedRunRequestReplayEvidence?.(request);
+					if (replayClassification?.kind === "retention-gap") {
+						emitRunRequested(
+							ctx,
+							state,
+							sanitizeRetainedToolProviderAdapterRunRequest(request, opts.publicText),
+							opts.privateRetentionHooks,
+						);
+						return;
+					}
+					const issue = dataIssue(
+						"tool-provider-adapter-run-request-missing-input",
+						"Tool provider adapter run request references an unknown adapter input.",
+						{
+							subjectId: request.adapterInputId,
+							refs: sanitizeAdapterInputSourceRefs([
+								ref("tool-provider-adapter-run", request.runId),
+								...(request.sourceRefs ?? []),
+							]),
+						},
+					);
+					emitRunIssueFact(ctx, state, issue, opts.privateRetentionHooks);
+					emitRunStatus(
+						ctx,
+						state,
+						{
+							kind: "tool-provider-adapter-run-status",
+							runId: request.runId,
+							adapterInputId: request.adapterInputId,
+							requestId: request.requestId,
+							operationId: request.operationId,
+							status: "missing-input",
+							attempt: request.attempt,
+							issues: [issue],
+							sourceRefs: sanitizeAdapterInputSourceRefs(request.sourceRefs ?? []),
+						},
+						opts.privateRetentionHooks,
+					);
+					return;
+				}
+				const issues = runRequestIdentityIssues(request, input);
+				if (input.status !== "ready") {
+					issues.push(
+						dataIssue(
+							"tool-provider-adapter-run-request-input-not-ready",
+							"Tool provider adapter run request requires a ready adapter input.",
+							{
+								subjectId: input.requestId,
+								refs: [ref("tool-provider-adapter-input", input.adapterInputId)],
+								details: { status: input.status },
+							},
+						),
+					);
+				}
+				if (issues.length > 0) {
+					for (const issue of issues)
+						emitRunIssueFact(ctx, state, issue, opts.privateRetentionHooks);
+					emitRunStatus(
+						ctx,
+						state,
+						{
+							kind: "tool-provider-adapter-run-status",
+							runId: request.runId,
+							adapterInputId: request.adapterInputId,
+							requestId: request.requestId,
+							operationId: request.operationId,
+							status: "mismatched-request",
+							attempt: request.attempt,
+							issues: Object.freeze(issues),
+							sourceRefs: sanitizeAdapterInputSourceRefs(request.sourceRefs ?? []),
+						},
+						opts.privateRetentionHooks,
+					);
+					emitRunAudit(ctx, state, "tool-provider-adapter-run-request-rejected", request, {
+						issueCodes: issues.map((issue) => issue.code),
+					});
+					return;
+				}
+				emitRunRequested(
+					ctx,
+					state,
+					sanitizeToolProviderAdapterRunRequest(request, input, opts.publicText),
+					opts.privateRetentionHooks,
+				);
+			});
+			ctx.state.set(state);
+		},
+		{ name: `${name}/runtime`, factory: "toolProviderAdapterRunProjector", partial: true },
+	);
+	return {
+		requests: projectRuntimeFact(
+			graph,
+			runtime,
+			`${name}/requests`,
+			"toolProviderAdapterRunRequests",
+			(fact) => (fact.kind === "request" ? fact.request : undefined),
+		),
+		status: projectRuntimeFact(
+			graph,
+			runtime,
+			`${name}/status`,
+			"toolProviderAdapterRunStatus",
+			(fact) => (fact.kind === "status" ? fact.status : undefined),
+		),
+		issues: projectRuntimeFact(
+			graph,
+			runtime,
+			`${name}/issues`,
+			"toolProviderAdapterRunIssues",
+			(fact) => (fact.kind === "issue" ? fact.issue : undefined),
+		),
+		audit: projectRuntimeFact(
+			graph,
+			runtime,
+			`${name}/audit`,
+			"toolProviderAdapterRunAudit",
+			(fact) => (fact.kind === "audit" ? fact.audit : undefined),
+		),
+	};
+}
+
+export type ToolProviderAdapterRunFact =
+	| { readonly kind: "request"; readonly request: ToolProviderAdapterRunRequested }
+	| { readonly kind: "status"; readonly status: ToolProviderAdapterRunStatus }
+	| { readonly kind: "issue"; readonly issue: DataIssue }
+	| { readonly kind: "audit"; readonly audit: AgentRuntimeAuditRecord };
+
+export interface ToolProviderAdapterRunProjectorState {
+	inputs: Map<string, ToolProviderAdapterInput>;
+	emittedKeys: Set<string>;
+	statusKeys: Set<string>;
+	issueKeys: Set<string>;
+	auditSeq: number;
+}
+
+export function defaultToolProviderAdapterRunId(
+	adapterInputId: string,
+	attempt: number,
+	input?: ToolProviderAdapterInput,
+): string {
+	const suffix = input === undefined ? "" : `:${stableStringHash(stableJsonStringify(input))}`;
+	return `${adapterInputId}:run-${attempt}${suffix}`;
+}
+
+export function sanitizeToolProviderAdapterRunReason(
+	reason: ToolProviderAdapterRunReason | undefined,
+	attempt: number,
+	policy?: ToolProviderPublicTextPolicy,
+): ToolProviderAdapterRunReason {
+	const value = reason ?? (attempt === 1 ? "initial" : "retry");
+	return boundPublicText(value, maxPublicReasonChars(policy)).text as ToolProviderAdapterRunReason;
+}
+
+export function sanitizeToolProviderAdapterRunRequest(
+	request: ToolProviderAdapterRunRequested,
+	input: ToolProviderAdapterInput,
+	policy?: ToolProviderPublicTextPolicy,
+): ToolProviderAdapterRunRequested {
+	return Object.freeze({
+		...request,
+		reason: sanitizeToolProviderAdapterRunReason(request.reason, request.attempt, policy),
+		policyRefs: sanitizeAdapterInputSourceRefs(request.policyRefs ?? input.policyRefs ?? []),
+		sourceRefs: sanitizeAdapterInputSourceRefs([
+			ref("tool-provider-adapter-input", input.adapterInputId),
+			...(input.sourceRefs ?? []),
+			...(request.sourceRefs ?? []),
+		]),
+		metadata: sanitizeProviderGraphVisibleRecord(request.metadata),
+	} satisfies ToolProviderAdapterRunRequested);
+}
+
+export function sanitizeRetainedToolProviderAdapterRunRequest(
+	request: ToolProviderAdapterRunRequested,
+	policy?: ToolProviderPublicTextPolicy,
+): ToolProviderAdapterRunRequested {
+	const policyRefs = sanitizeAdapterInputSourceRefs(request.policyRefs ?? []);
+	const sourceRefs = sanitizeAdapterInputSourceRefs(request.sourceRefs ?? []);
+	const metadata = sanitizeProviderGraphVisibleRecord(request.metadata);
+	return Object.freeze({
+		kind: "tool-provider-adapter-run-requested",
+		runId: request.runId,
+		adapterInputId: request.adapterInputId,
+		requestId: request.requestId,
+		operationId: request.operationId,
+		...(request.routeId === undefined ? {} : { routeId: request.routeId }),
+		...(request.providerId === undefined ? {} : { providerId: request.providerId }),
+		...(request.executorId === undefined ? {} : { executorId: request.executorId }),
+		...(request.profileId === undefined ? {} : { profileId: request.profileId }),
+		attempt: request.attempt,
+		reason: sanitizeToolProviderAdapterRunReason(request.reason, request.attempt, policy),
+		...(request.retryOfOutcomeId === undefined
+			? {}
+			: { retryOfOutcomeId: request.retryOfOutcomeId }),
+		...(policyRefs.length === 0 ? {} : { policyRefs }),
+		...(sourceRefs.length === 0 ? {} : { sourceRefs }),
+		...(metadata === undefined ? {} : { metadata }),
+		...(request.requestedAtMs === undefined ? {} : { requestedAtMs: request.requestedAtMs }),
+	} satisfies ToolProviderAdapterRunRequested);
+}
+
+export function isToolProviderAdapterRunRequestedLike(
+	value: unknown,
+): value is ToolProviderAdapterRunRequested {
+	const attempt = isRecord(value) ? value.attempt : undefined;
+	return (
+		isRecord(value) &&
+		value.kind === "tool-provider-adapter-run-requested" &&
+		typeof value.runId === "string" &&
+		value.runId.length > 0 &&
+		typeof value.adapterInputId === "string" &&
+		value.adapterInputId.length > 0 &&
+		typeof value.requestId === "string" &&
+		value.requestId.length > 0 &&
+		typeof value.operationId === "string" &&
+		value.operationId.length > 0 &&
+		typeof attempt === "number" &&
+		Number.isInteger(attempt) &&
+		attempt > 0 &&
+		typeof value.reason === "string" &&
+		value.reason.length > 0
+	);
+}
+
+export function fallbackToolProviderAdapterRunRequest(
+	raw: unknown,
+	policy?: ToolProviderPublicTextPolicy,
+): ToolProviderAdapterRunRequested {
+	const record = isRecord(raw) ? raw : {};
+	const adapterInputId =
+		typeof record.adapterInputId === "string" && record.adapterInputId.length > 0
+			? record.adapterInputId
+			: "<invalid-adapter-input>";
+	const runId =
+		typeof record.runId === "string" && record.runId.length > 0
+			? record.runId
+			: `${adapterInputId}:invalid-run`;
+	const attempt =
+		typeof record.attempt === "number" && Number.isInteger(record.attempt) && record.attempt > 0
+			? record.attempt
+			: 1;
+	const metadata = isRecord(record.metadata)
+		? sanitizeProviderGraphVisibleRecord(record.metadata, policy)
+		: undefined;
+	return Object.freeze({
+		kind: "tool-provider-adapter-run-requested",
+		runId,
+		adapterInputId,
+		requestId:
+			typeof record.requestId === "string" && record.requestId.length > 0
+				? record.requestId
+				: "<invalid-request>",
+		operationId:
+			typeof record.operationId === "string" && record.operationId.length > 0
+				? record.operationId
+				: "<invalid-operation>",
+		attempt,
+		reason: sanitizeToolProviderAdapterRunReason(
+			typeof record.reason === "string" && record.reason.length > 0 ? record.reason : "manual",
+			attempt,
+			policy,
+		),
+		sourceRefs: sanitizeAdapterInputSourceRefs([
+			ref("tool-provider-adapter-run", runId),
+			...sanitizeUntrustedSourceRefs(record.sourceRefs),
+		]),
+		...(metadata === undefined ? {} : { metadata }),
+	} satisfies ToolProviderAdapterRunRequested);
+}
+
+export function sanitizeUntrustedSourceRefs(value: unknown): readonly SourceRef[] {
+	if (!Array.isArray(value)) return [];
+	return Object.freeze(
+		value
+			.filter(
+				(sourceRef): sourceRef is SourceRef =>
+					isRecord(sourceRef) &&
+					typeof sourceRef.kind === "string" &&
+					sourceRef.kind.length > 0 &&
+					typeof sourceRef.id === "string" &&
+					sourceRef.id.length > 0,
+			)
+			.map((sourceRef) => ({
+				kind: sourceRef.kind,
+				id: sourceRef.id,
+				...(isRecord(sourceRef.metadata) ? { metadata: sourceRef.metadata } : {}),
+			})),
+	);
+}
+
+export function runRequestIdentityIssues(
+	request: ToolProviderAdapterRunRequested,
+	input: ToolProviderAdapterInput,
+): DataIssue[] {
+	const refs = sanitizeAdapterInputSourceRefs([
+		ref("tool-provider-adapter-run", request.runId),
+		ref("tool-provider-adapter-input", input.adapterInputId),
+		...(request.sourceRefs ?? []),
+	]);
+	const issues: DataIssue[] = [];
+	if (request.kind !== "tool-provider-adapter-run-requested") {
+		issues.push(
+			dataIssue(
+				"tool-provider-adapter-run-request-invalid-kind",
+				"Tool provider adapter run request kind must be tool-provider-adapter-run-requested.",
+				{ subjectId: request.adapterInputId, refs },
+			),
+		);
+	}
+	if (request.runId.length === 0) {
+		issues.push(
+			dataIssue(
+				"tool-provider-adapter-run-request-missing-run-id",
+				"Tool provider adapter run request requires runId.",
+				{
+					subjectId: request.adapterInputId,
+					refs,
+				},
+			),
+		);
+	}
+	if (!Number.isInteger(request.attempt) || request.attempt < 1) {
+		issues.push(
+			dataIssue(
+				"tool-provider-adapter-run-request-invalid-attempt",
+				"Tool provider adapter run request attempt must be a positive integer.",
+				{ subjectId: request.adapterInputId, refs },
+			),
+		);
+	}
+	if (request.requestId !== input.requestId) {
+		issues.push(
+			dataIssue(
+				"tool-provider-adapter-run-request-stale-request",
+				"Tool provider adapter run request requestId does not match the adapter input.",
+				{ subjectId: input.requestId, refs },
+			),
+		);
+	}
+	if (request.operationId !== input.operationId) {
+		issues.push(
+			dataIssue(
+				"tool-provider-adapter-run-request-stale-operation",
+				"Tool provider adapter run request operationId does not match the adapter input.",
+				{ subjectId: input.requestId, refs },
+			),
+		);
+	}
+	if (request.routeId !== undefined && request.routeId !== input.routeId) {
+		issues.push(
+			dataIssue(
+				"tool-provider-adapter-run-request-stale-route",
+				"Tool provider adapter run request routeId does not match the adapter input.",
+				{ subjectId: input.requestId, refs },
+			),
+		);
+	}
+	if (request.providerId !== undefined && request.providerId !== input.providerId) {
+		issues.push(
+			dataIssue(
+				"tool-provider-adapter-run-request-stale-provider",
+				"Tool provider adapter run request providerId does not match the adapter input.",
+				{ subjectId: input.requestId, refs },
+			),
+		);
+	}
+	if (request.executorId !== undefined && request.executorId !== input.executorId) {
+		issues.push(
+			dataIssue(
+				"tool-provider-adapter-run-request-stale-executor",
+				"Tool provider adapter run request executorId does not match the adapter input.",
+				{ subjectId: input.requestId, refs },
+			),
+		);
+	}
+	if (request.profileId !== undefined && request.profileId !== input.profileId) {
+		issues.push(
+			dataIssue(
+				"tool-provider-adapter-run-request-stale-profile",
+				"Tool provider adapter run request profileId does not match the adapter input.",
+				{ subjectId: input.requestId, refs },
+			),
+		);
+	}
+	for (const forbidden of [
+		...forbiddenDataKeys(request),
+		...forbiddenProviderRawMaterialKeys(request),
+	]) {
+		issues.push(
+			dataIssue(
+				"tool-provider-adapter-run-request-forbidden-runtime-material",
+				"Tool provider adapter run request must not contain runtime-private adapter material.",
+				{ subjectId: input.requestId, refs, details: { reason: forbidden.reason } },
+			),
+		);
+	}
+	return issues;
+}
+
+export function emitRunRequested(
+	ctx: Ctx,
+	state: ToolProviderAdapterRunProjectorState,
+	request: ToolProviderAdapterRunRequested,
+	privateRetentionHooks?: ToolProviderAdapterRunProjectorPrivateRetentionHooks,
+): void {
+	const key = `${request.runId}:${request.adapterInputId}:${request.attempt}`;
+	if (state.emittedKeys.has(key)) return;
+	state.emittedKeys.add(key);
+	ctx.down([["DATA", { kind: "request", request } satisfies ToolProviderAdapterRunFact]]);
+	privateRetentionHooks?.onRunRequestKey?.({
+		key,
+		request,
+		dropKey: () => state.emittedKeys.delete(key),
+	});
+	emitRunStatus(
+		ctx,
+		state,
+		{
+			kind: "tool-provider-adapter-run-status",
+			runId: request.runId,
+			adapterInputId: request.adapterInputId,
+			requestId: request.requestId,
+			operationId: request.operationId,
+			status: "requested",
+			attempt: request.attempt,
+			sourceRefs: request.sourceRefs,
+		},
+		privateRetentionHooks,
+	);
+	emitRunAudit(ctx, state, "tool-provider-adapter-run-requested", request, {
+		reason: request.reason,
+		attempt: request.attempt,
+	});
+}
+
+export function emitRunStatus(
+	ctx: Ctx,
+	state: ToolProviderAdapterRunProjectorState,
+	status: ToolProviderAdapterRunStatus,
+	privateRetentionHooks?: ToolProviderAdapterRunProjectorPrivateRetentionHooks,
+): void {
+	const cleanSourceRefs =
+		status.sourceRefs === undefined ? undefined : sanitizeAdapterInputSourceRefs(status.sourceRefs);
+	const cleanIssues =
+		status.issues === undefined
+			? undefined
+			: Object.freeze(status.issues.map((issue) => sanitizeAdapterInputIssue(issue)));
+	const cleanMetadata = sanitizeProviderGraphVisibleRecord(status.metadata);
+	const cleanStatus = Object.freeze({
+		kind: status.kind,
+		runId: status.runId,
+		adapterInputId: status.adapterInputId,
+		...(status.requestId === undefined ? {} : { requestId: status.requestId }),
+		...(status.operationId === undefined ? {} : { operationId: status.operationId }),
+		status: status.status,
+		...(status.attempt === undefined ? {} : { attempt: status.attempt }),
+		...(status.outcomeId === undefined ? {} : { outcomeId: status.outcomeId }),
+		...(cleanIssues === undefined || cleanIssues.length === 0 ? {} : { issues: cleanIssues }),
+		...(cleanSourceRefs === undefined || cleanSourceRefs.length === 0
+			? {}
+			: { sourceRefs: cleanSourceRefs }),
+		...(cleanMetadata === undefined ? {} : { metadata: cleanMetadata }),
+	} satisfies ToolProviderAdapterRunStatus);
+	const key = stableJsonStringify({
+		runId: cleanStatus.runId,
+		adapterInputId: cleanStatus.adapterInputId,
+		requestId: cleanStatus.requestId,
+		attempt: cleanStatus.attempt,
+		status: cleanStatus.status,
+		outcomeId: cleanStatus.outcomeId,
+	});
+	if (state.statusKeys.has(key)) return;
+	state.statusKeys.add(key);
+	ctx.down([
+		["DATA", { kind: "status", status: cleanStatus } satisfies ToolProviderAdapterRunFact],
+	]);
+	privateRetentionHooks?.onRunStatusKey?.({
+		key,
+		status: cleanStatus,
+		dropKey: () => state.statusKeys.delete(key),
+	});
+}
+
+export function emitRunIssue(
+	ctx: Ctx,
+	state: ToolProviderAdapterRunProjectorState,
+	code: string,
+	message: string,
+	subjectId: string,
+	refs?: readonly SourceRef[],
+	privateRetentionHooks?: ToolProviderAdapterRunProjectorPrivateRetentionHooks,
+): void {
+	emitRunIssueFact(
+		ctx,
+		state,
+		dataIssue(code, message, { subjectId, refs }),
+		privateRetentionHooks,
+	);
+}
+
+export function emitRunIssueFact(
+	ctx: Ctx,
+	state: ToolProviderAdapterRunProjectorState,
+	issue: DataIssue,
+	privateRetentionHooks?: ToolProviderAdapterRunProjectorPrivateRetentionHooks,
+): void {
+	const key = stableJsonStringify({
+		code: issue.code,
+		subjectId: issue.subjectId,
+		refs: issue.refs ?? [],
+		details: issue.details,
+	});
+	if (state.issueKeys.has(key)) return;
+	state.issueKeys.add(key);
+	ctx.down([["DATA", { kind: "issue", issue } satisfies ToolProviderAdapterRunFact]]);
+	privateRetentionHooks?.onRunIssueKey?.({
+		key,
+		issue,
+		dropKey: () => state.issueKeys.delete(key),
+	});
+}
+
+export function emitRunAudit(
+	ctx: Ctx,
+	state: ToolProviderAdapterRunProjectorState,
+	kind: string,
+	request: ToolProviderAdapterRunRequested,
+	metadata?: Record<string, unknown>,
+): void {
+	state.auditSeq += 1;
+	ctx.down([
+		[
+			"DATA",
+			{
+				kind: "audit",
+				audit: {
+					id: `${request.runId}:audit:${state.auditSeq}`,
+					kind,
+					subjectId: request.requestId,
+					sourceRefs: sanitizeAdapterInputSourceRefs(request.sourceRefs ?? []),
+					metadata: sanitizeProviderGraphVisibleRecord({
+						runId: request.runId,
+						adapterInputId: request.adapterInputId,
+						...metadata,
+					}),
+				},
+			} satisfies ToolProviderAdapterRunFact,
+		],
+	]);
+}
diff --git a/packages/ts/src/orchestration/agent-runtime-adapter-runtime-execute.ts b/packages/ts/src/orchestration/agent-runtime-adapter-runtime-execute.ts
new file mode 100644
index 00000000..dcb313ba
--- /dev/null
+++ b/packages/ts/src/orchestration/agent-runtime-adapter-runtime-execute.ts
@@ -0,0 +1,185 @@
+import type { DataIssue } from "../data/index.js";
+import type {
+	ReplayEvidenceClassification,
+	RuntimeRetentionIndex,
+} from "./agent-runtime-adapter-retention.js";
+import { runRequestIdentityIssues } from "./agent-runtime-adapter-run.js";
+import { dataIssue, ref } from "./agent-runtime-common.js";
+import type { AgentRequestStatus } from "./agent-runtime-types-core.js";
+import type {
+	ToolProviderAdapterBinding,
+	ToolProviderAdapterExecutionRetentionEntry,
+	ToolProviderAdapterInput,
+	ToolProviderAdapterInputRetentionEntry,
+	ToolProviderAdapterRunRequested,
+	ToolProviderAdapterRunResult,
+	ToolProviderAdapterRunStatus,
+} from "./agent-runtime-types-tool.js";
+
+export interface AdapterRuntimeRunRequestContext<TArguments = unknown, TResult = unknown> {
+	isDisposed(): boolean;
+	adapterInputs: RuntimeRetentionIndex<
+		ToolProviderAdapterInputRetentionEntry,
+		ToolProviderAdapterInput<TArguments>
+	>;
+	executions: RuntimeRetentionIndex<
+		ToolProviderAdapterExecutionRetentionEntry,
+		ToolProviderAdapterRunRequested
+	>;
+	bindings: ReadonlyMap<string, ToolProviderAdapterBinding<TArguments, TResult>>;
+	now?: () => number;
+	classifyRunRequestReplayEvidence(
+		request: ToolProviderAdapterRunRequested,
+		input?: ToolProviderAdapterInput<TArguments>,
+	): ReplayEvidenceClassification;
+	publishReplayClassification(
+		request: ToolProviderAdapterRunRequested,
+		classification: ReplayEvidenceClassification,
+	): boolean;
+	startExecutionProof(request: ToolProviderAdapterRunRequested): boolean;
+	executionCoordinate(request: ToolProviderAdapterRunRequested): string;
+	publishIssue(issue: DataIssue, track?: boolean): void;
+	publishRunStatus(
+		request: ToolProviderAdapterRunRequested,
+		statusValue: ToolProviderAdapterRunStatus["status"],
+		issueList?: readonly DataIssue[],
+	): void;
+	publishStatus(
+		input: ToolProviderAdapterInput<TArguments>,
+		statusValue: AgentRequestStatus,
+		issueList?: readonly DataIssue[],
+	): void;
+	publishAudit(
+		input: ToolProviderAdapterInput<TArguments>,
+		kind: string,
+		metadata?: Record<string, unknown>,
+	): void;
+	publishOutcome(
+		input: ToolProviderAdapterInput<TArguments>,
+		result: ToolProviderAdapterRunResult<TResult>,
+		request: ToolProviderAdapterRunRequested,
+	): void;
+	publishRuntimeFailure(
+		input: ToolProviderAdapterInput<TArguments>,
+		request: ToolProviderAdapterRunRequested,
+		code: string,
+		error: unknown,
+	): void;
+}
+
+export function runAdapterRuntimeRequest<TArguments = unknown, TResult = unknown>(
+	ctx: AdapterRuntimeRunRequestContext<TArguments, TResult>,
+	request: ToolProviderAdapterRunRequested,
+): void {
+	if (ctx.isDisposed()) return;
+	const input = ctx.adapterInputs.get(request.adapterInputId)?.value;
+	if (input === undefined) {
+		const missingInputClassification = ctx.classifyRunRequestReplayEvidence(request);
+		ctx.publishReplayClassification(request, missingInputClassification);
+		return;
+	}
+	if (input.status !== "ready") {
+		const issue = dataIssue(
+			"tool-provider-adapter-runtime-input-not-ready",
+			"Tool provider adapter runtime requires a ready adapter input.",
+			{
+				subjectId: input.requestId,
+				refs: [ref("tool-provider-adapter-input", input.adapterInputId)],
+				details: { status: input.status },
+			},
+		);
+		ctx.publishIssue(issue);
+		ctx.publishRunStatus(request, "stale-request", [issue]);
+		ctx.publishStatus(input, "blocked", [issue]);
+		return;
+	}
+	const requestIssues = runRequestIdentityIssues(request, input);
+	if (requestIssues.length > 0) {
+		for (const issue of requestIssues) ctx.publishIssue(issue);
+		ctx.publishRunStatus(request, "mismatched-request", requestIssues);
+		ctx.publishStatus(input, "blocked", requestIssues);
+		ctx.publishAudit(input, "tool-provider-adapter-runtime-run-request-rejected", {
+			runId: request.runId,
+			attempt: request.attempt,
+			issueCodes: requestIssues.map((issue) => issue.code),
+		});
+		return;
+	}
+	if (ctx.executions.has(ctx.executionCoordinate(request))) {
+		ctx.startExecutionProof(request);
+		return;
+	}
+	const classification = ctx.classifyRunRequestReplayEvidence(request, input);
+	if (ctx.publishReplayClassification(request, classification)) return;
+	if (!ctx.startExecutionProof(request)) return;
+	const binding = input.providerId === undefined ? undefined : ctx.bindings.get(input.providerId);
+	if (binding === undefined) {
+		const issue = dataIssue(
+			"tool-provider-adapter-runtime-missing-binding",
+			"Tool provider adapter runtime requires a matching runtime-private binding.",
+			{
+				subjectId: input.requestId,
+				refs: [ref("tool-provider-adapter-input", input.adapterInputId)],
+				details: { providerId: input.providerId },
+			},
+		);
+		ctx.publishOutcome(
+			input,
+			{
+				kind: "blocked",
+				needs: [
+					{
+						kind: "tool-provider-binding",
+						message: "Matching runtime-private tool provider binding is unavailable.",
+						...(input.providerId === undefined
+							? {}
+							: { refs: [ref("tool-provider", input.providerId)] }),
+					},
+				],
+				issues: [issue],
+			},
+			request,
+		);
+		return;
+	}
+	ctx.publishRunStatus(request, "started");
+	ctx.publishStatus(input, "in-flight");
+	ctx.publishAudit(input, "tool-provider-adapter-runtime-started", {
+		providerId: binding.providerId,
+		runId: request.runId,
+		attempt: request.attempt,
+		reason: request.reason,
+	});
+	let result: ToolProviderAdapterRunResult<TResult>;
+	try {
+		result = binding.run(input, {
+			runId: request.runId,
+			attempt: request.attempt,
+			reason: request.reason,
+			sourceRefs: request.sourceRefs ?? input.sourceRefs ?? [],
+			now: ctx.now,
+		});
+	} catch (error) {
+		ctx.publishRuntimeFailure(input, request, "tool-provider-adapter-runtime-threw", error);
+		return;
+	}
+	if (isThenableResult(result)) {
+		ctx.publishRuntimeFailure(
+			input,
+			request,
+			"tool-provider-adapter-runtime-async-result-unsupported",
+			new Error("Tool provider adapter runtime bindings must return synchronously."),
+		);
+		return;
+	}
+	ctx.publishOutcome(input, result, request);
+}
+
+function isThenableResult(value: unknown): boolean {
+	if (value === null || (typeof value !== "object" && typeof value !== "function")) return false;
+	try {
+		return typeof (value as { readonly then?: unknown }).then === "function";
+	} catch {
+		return true;
+	}
+}
diff --git a/packages/ts/src/orchestration/agent-runtime-adapter-runtime-retention-gaps.ts b/packages/ts/src/orchestration/agent-runtime-adapter-runtime-retention-gaps.ts
new file mode 100644
index 00000000..cd4ad69f
--- /dev/null
+++ b/packages/ts/src/orchestration/agent-runtime-adapter-runtime-retention-gaps.ts
@@ -0,0 +1,179 @@
+import type { DataIssue } from "../data/index.js";
+import {
+	type ReplayEvidenceClassification,
+	type ReplayEvidenceGapKind,
+	type RuntimeIndexItem,
+	runtimeDiagnosticKey,
+	runtimeEvidenceMetadata,
+	runtimeEvidenceSourceRefs,
+} from "./agent-runtime-adapter-retention.js";
+import { dataIssue, ref } from "./agent-runtime-common.js";
+import type { SourceRef } from "./agent-runtime-types-core.js";
+import type {
+	ToolProviderAdapterRunRequested,
+	ToolProviderAdapterRunStatus,
+	ToolProviderAdapterRuntimeRetentionEvidenceEntry,
+	ToolProviderAdapterRuntimeStatus,
+} from "./agent-runtime-types-tool.js";
+
+export interface AdapterRuntimeRetentionGapContext {
+	publishIssue(issue: DataIssue, track?: boolean): void;
+	publishRunStatus(
+		request: ToolProviderAdapterRunRequested,
+		statusValue: ToolProviderAdapterRunStatus["status"],
+		issueList?: readonly DataIssue[],
+	): void;
+	publishRuntimeStatus(fact: Omit<ToolProviderAdapterRuntimeStatus, "kind">): void;
+	publishRuntimeAudit(
+		kind: string,
+		auditOpts?: {
+			readonly subjectId?: string;
+			readonly sourceRefs?: readonly SourceRef[];
+			readonly issueCode?: string;
+			readonly metadata?: Record<string, unknown>;
+		},
+	): void;
+}
+
+function retentionGapIssueCode(gapKind: ReplayEvidenceGapKind): string {
+	switch (gapKind) {
+		case "evidence-horizon":
+			return "tool-provider-adapter-runtime-retention-evidence-gap";
+		case "evidence-horizon-closed":
+			return "tool-provider-adapter-runtime-retention-evidence-horizon-closed";
+		case "adapter-input-trimmed":
+		case "execution-proof-trimmed":
+			return "tool-provider-adapter-runtime-retention-gap";
+	}
+}
+
+function retentionGapMessage(gapKind: ReplayEvidenceGapKind): string {
+	switch (gapKind) {
+		case "evidence-horizon":
+			return "Tool provider adapter runtime retention evidence horizon no longer proves this request is fresh.";
+		case "evidence-horizon-closed":
+			return "Tool provider adapter runtime retention evidence horizon is closed; this request must fail closed.";
+		case "adapter-input-trimmed":
+			return "Tool provider adapter runtime retention removed the requested adapter input proof.";
+		case "execution-proof-trimmed":
+			return "Tool provider adapter runtime retention removed execution proof needed to safely replay this request.";
+	}
+}
+
+function retentionGapEvidenceKind(
+	gapKind: ReplayEvidenceGapKind,
+): ToolProviderAdapterRuntimeRetentionEvidenceEntry["evidenceKind"] | undefined {
+	switch (gapKind) {
+		case "adapter-input-trimmed":
+			return "adapter-input-trimmed";
+		case "execution-proof-trimmed":
+			return "execution-high-water";
+		case "evidence-horizon":
+		case "evidence-horizon-closed":
+			return undefined;
+	}
+}
+
+export function publishAdapterRuntimeRetentionGap(
+	ctx: AdapterRuntimeRetentionGapContext,
+	request: ToolProviderAdapterRunRequested,
+	classification: Extract<ReplayEvidenceClassification, { readonly kind: "retention-gap" }>,
+): void {
+	const { index, gapKind } = classification;
+	const key = classification.key ?? request.adapterInputId;
+	const issueCode = retentionGapIssueCode(gapKind);
+	const evidenceKind = retentionGapEvidenceKind(gapKind);
+	const sourceRefs = runtimeEvidenceSourceRefs(index, [
+		ref("tool-provider-adapter-run", request.runId),
+		ref("tool-provider-adapter-input", request.adapterInputId),
+	]);
+	const metadata = runtimeEvidenceMetadata(index, {
+		key,
+		extra: {
+			gapKind,
+			...(evidenceKind === undefined ? {} : { evidenceKind }),
+		},
+	});
+	const issue = dataIssue(issueCode, retentionGapMessage(gapKind), {
+		subjectId: request.adapterInputId,
+		refs: sourceRefs,
+		details: {
+			index,
+			adapterInputId: request.adapterInputId,
+			runId: request.runId,
+			attempt: request.attempt,
+			issueCode,
+			gapKind,
+			key: runtimeDiagnosticKey(key),
+			...(evidenceKind === undefined ? {} : { evidenceKind }),
+		},
+	});
+	ctx.publishIssue(issue);
+	ctx.publishRunStatus(request, "retention-gap", [issue]);
+	ctx.publishRuntimeStatus({
+		status: "retention-gap",
+		index,
+		key,
+		adapterInputId: request.adapterInputId,
+		runId: request.runId,
+		attempt: request.attempt,
+		issueCode: issue.code,
+		sourceRefs,
+		metadata,
+	});
+	ctx.publishRuntimeAudit("tool-provider-adapter-runtime-retention-gap", {
+		subjectId: request.adapterInputId,
+		sourceRefs,
+		issueCode: issue.code,
+		metadata,
+	});
+}
+
+export function publishAdapterRuntimeRetentionEvidenceGlobalFailClosed(
+	ctx: AdapterRuntimeRetentionGapContext,
+	victim: RuntimeIndexItem<
+		ToolProviderAdapterRuntimeRetentionEvidenceEntry,
+		ToolProviderAdapterRuntimeRetentionEvidenceEntry
+	>,
+): void {
+	const sourceRefs = runtimeEvidenceSourceRefs("retentionEvidence");
+	const metadata = runtimeEvidenceMetadata("retentionEvidence", {
+		key: victim.key,
+		extra: {
+			evidenceKind: victim.value.evidenceKind,
+			gapKind: "evidence-horizon-closed",
+		},
+	});
+	const issue = dataIssue(
+		"tool-provider-adapter-runtime-retention-evidence-horizon-closed",
+		"Tool provider adapter runtime retention evidence closed-marker horizon overflowed; future requests fail closed until runtime reset.",
+		{
+			subjectId: victim.value.adapterInputId,
+			refs: sourceRefs,
+			details: {
+				index: "retentionEvidence",
+				key: runtimeDiagnosticKey(victim.key),
+				gapKind: "evidence-horizon-closed",
+			},
+		},
+	);
+	ctx.publishIssue(issue, false);
+	ctx.publishRuntimeStatus({
+		status: "retention-gap",
+		index: "retentionEvidence",
+		key: victim.key,
+		adapterInputId: victim.value.adapterInputId,
+		...(victim.value.attemptHighWater === undefined
+			? {}
+			: { attempt: victim.value.attemptHighWater }),
+		issueCode: issue.code,
+		sourceRefs,
+		metadata,
+	});
+	ctx.publishRuntimeAudit("tool-provider-adapter-runtime-retention-evidence-horizon-closed", {
+		subjectId: victim.value.adapterInputId,
+		sourceRefs,
+		issueCode: issue.code,
+		metadata,
+	});
+}
diff --git a/packages/ts/src/orchestration/agent-runtime-adapter-runtime-state.ts b/packages/ts/src/orchestration/agent-runtime-adapter-runtime-state.ts
new file mode 100644
index 00000000..232b7eda
--- /dev/null
+++ b/packages/ts/src/orchestration/agent-runtime-adapter-runtime-state.ts
@@ -0,0 +1,80 @@
+import type { DataIssue } from "../data/index.js";
+import type { Graph } from "../graph/graph.js";
+import type { RuntimeRetentionTrackedValue } from "./agent-runtime-adapter-retention.js";
+import { RuntimeRetentionIndex } from "./agent-runtime-adapter-retention.js";
+import type { AgentRuntimeAuditRecord } from "./agent-runtime-types-agent.js";
+import type { AgentRequestStatusChanged, ExecutorOutcome } from "./agent-runtime-types-core.js";
+import type {
+	ToolProviderAdapterExecutionRetentionEntry,
+	ToolProviderAdapterInput,
+	ToolProviderAdapterInputRetentionEntry,
+	ToolProviderAdapterRunIssueRetentionEntry,
+	ToolProviderAdapterRunRequested,
+	ToolProviderAdapterRunRequestRetentionEntry,
+	ToolProviderAdapterRunStatus,
+	ToolProviderAdapterRunStatusRetentionEntry,
+	ToolProviderAdapterRuntimeRetentionEvidenceEntry,
+	ToolProviderAdapterRuntimeStatus,
+} from "./agent-runtime-types-tool.js";
+
+export function createAdapterRuntimeRetentionIndexes<TArguments>() {
+	return {
+		adapterInputs: new RuntimeRetentionIndex<
+			ToolProviderAdapterInputRetentionEntry,
+			ToolProviderAdapterInput<TArguments>
+		>(),
+		runRequests: new RuntimeRetentionIndex<
+			ToolProviderAdapterRunRequestRetentionEntry,
+			RuntimeRetentionTrackedValue<ToolProviderAdapterRunRequested>
+		>(),
+		executions: new RuntimeRetentionIndex<
+			ToolProviderAdapterExecutionRetentionEntry,
+			ToolProviderAdapterRunRequested
+		>(),
+		runStatuses: new RuntimeRetentionIndex<
+			ToolProviderAdapterRunStatusRetentionEntry,
+			RuntimeRetentionTrackedValue<ToolProviderAdapterRunStatus>
+		>(),
+		runIssues: new RuntimeRetentionIndex<
+			ToolProviderAdapterRunIssueRetentionEntry,
+			RuntimeRetentionTrackedValue<DataIssue>
+		>(),
+		retentionEvidence: new RuntimeRetentionIndex<
+			ToolProviderAdapterRuntimeRetentionEvidenceEntry,
+			ToolProviderAdapterRuntimeRetentionEvidenceEntry
+		>(),
+		closedRetentionEvidence: new RuntimeRetentionIndex<
+			ToolProviderAdapterRuntimeRetentionEvidenceEntry,
+			ToolProviderAdapterRuntimeRetentionEvidenceEntry
+		>(),
+	};
+}
+
+export function createAdapterRuntimeOutputNodes(graph: Graph, name: string) {
+	return {
+		outcomes: graph.node<ExecutorOutcome>([], null, {
+			name: `${name}/outcomes`,
+			factory: "toolProviderAdapterRuntimeOutcomes",
+		}),
+		runStatus: graph.node<ToolProviderAdapterRunStatus>([], null, {
+			name: `${name}/runStatus`,
+			factory: "toolProviderAdapterRuntimeRunStatus",
+		}),
+		status: graph.node<AgentRequestStatusChanged>([], null, {
+			name: `${name}/status`,
+			factory: "toolProviderAdapterRuntimeStatus",
+		}),
+		runtimeStatus: graph.node<ToolProviderAdapterRuntimeStatus>([], null, {
+			name: `${name}/runtimeStatus`,
+			factory: "toolProviderAdapterRuntimeStatus",
+		}),
+		issues: graph.node<DataIssue>([], null, {
+			name: `${name}/issues`,
+			factory: "toolProviderAdapterRuntimeIssues",
+		}),
+		audit: graph.node<AgentRuntimeAuditRecord>([], null, {
+			name: `${name}/audit`,
+			factory: "toolProviderAdapterRuntimeAudit",
+		}),
+	};
+}
diff --git a/packages/ts/src/orchestration/agent-runtime-adapter-runtime.ts b/packages/ts/src/orchestration/agent-runtime-adapter-runtime.ts
new file mode 100644
index 00000000..f9d9198e
--- /dev/null
+++ b/packages/ts/src/orchestration/agent-runtime-adapter-runtime.ts
@@ -0,0 +1,997 @@
+import type { DataIssue } from "../data/index.js";
+import type { Graph } from "../graph/graph.js";
+import type { RetentionPolicy } from "../graph/policies/types.js";
+import type {
+	EffectiveRuntimeRetentionPolicy,
+	ReplayEvidenceClassification,
+	RuntimeIndexItem,
+	RuntimeRetentionIndex,
+	RuntimeRetentionIndexConfig,
+	RuntimeRetentionPolicyFact,
+} from "./agent-runtime-adapter-retention.js";
+import {
+	adapterInputRetentionEntry,
+	buildRetentionPolicyReaders,
+	executionRetentionEntry,
+	readRetentionPolicyFact,
+	retentionEvidenceEntry,
+	runIssueRetentionEntry,
+	runRequestRetentionEntry,
+	runStatusRetentionEntry,
+	runtimeDiagnosticKey,
+	runtimeEvidenceMetadata,
+	runtimeEvidenceSourceRefs,
+	runtimeRetentionScorerEntry,
+	toolProviderAdapterRuntimeRetentionIndex,
+} from "./agent-runtime-adapter-retention.js";
+import {
+	normalizeToolProviderAdapterBindings,
+	toolProviderAdapterRunProjectorInternal,
+} from "./agent-runtime-adapter-run.js";
+import { runAdapterRuntimeRequest } from "./agent-runtime-adapter-runtime-execute.js";
+import {
+	publishAdapterRuntimeRetentionEvidenceGlobalFailClosed,
+	publishAdapterRuntimeRetentionGap,
+} from "./agent-runtime-adapter-runtime-retention-gaps.js";
+import {
+	createAdapterRuntimeOutputNodes,
+	createAdapterRuntimeRetentionIndexes,
+} from "./agent-runtime-adapter-runtime-state.js";
+import {
+	boundPublicText,
+	dataIssue,
+	isRecord,
+	maxPublicMetadataStringChars,
+	ref,
+	sanitizeAdapterInputIssue,
+	sanitizeAdapterInputSourceRefs,
+	sanitizeGraphVisibleRecord,
+	sanitizeProviderGraphVisibleRecord,
+} from "./agent-runtime-common.js";
+import {
+	adapterRuntimeIssue,
+	agentRequestStatusForExecutorOutcome,
+	buildToolProviderExecutorOutcome,
+	defaultToolProviderAdapterEvidenceRefs,
+	outcomeIssues,
+} from "./agent-runtime-executor-outcome.js";
+import type { AgentRuntimeAuditRecord } from "./agent-runtime-types-agent.js";
+import type {
+	AgentRequestStatus,
+	AgentRequestStatusChanged,
+	ExecutorOutcome,
+	SourceRef,
+} from "./agent-runtime-types-core.js";
+import type {
+	ToolProviderAdapterInput,
+	ToolProviderAdapterRunRequested,
+	ToolProviderAdapterRunResult,
+	ToolProviderAdapterRunStatus,
+	ToolProviderAdapterRuntimeHandle,
+	ToolProviderAdapterRuntimeOptions,
+	ToolProviderAdapterRuntimeRetentionEvidenceEntry,
+	ToolProviderAdapterRuntimeRetentionIndex,
+	ToolProviderAdapterRuntimeStatus,
+} from "./agent-runtime-types-tool.js";
+
+export function attachToolProviderAdapterRuntime<TArguments = unknown, TResult = unknown>(
+	graph: Graph,
+	opts: ToolProviderAdapterRuntimeOptions<TArguments, TResult>,
+): ToolProviderAdapterRuntimeHandle {
+	const name = opts.name ?? "toolProviderAdapterRuntime";
+	const bindings = normalizeToolProviderAdapterBindings(opts.bindings);
+	const retentionReaders = buildRetentionPolicyReaders(graph, name, opts.retention);
+	const retentionPolicy = graph.node<RuntimeRetentionPolicyFact>(
+		retentionReaders.inputs.deps,
+		(ctx) => {
+			const current = ctx.state.get<RuntimeRetentionPolicyFact>();
+			const fact = readRetentionPolicyFact(ctx, opts.retention, retentionReaders, current);
+			ctx.state.set(fact);
+			ctx.down([["DATA", fact]]);
+		},
+		{
+			name: `${name}/retentionPolicy`,
+			factory: "toolProviderAdapterRuntimeRetentionPolicy",
+			partial: true,
+		},
+	);
+	const {
+		adapterInputs,
+		runRequests,
+		executions,
+		runStatuses,
+		runIssues,
+		retentionEvidence,
+		closedRetentionEvidence,
+	} = createAdapterRuntimeRetentionIndexes<TArguments>();
+	const executionHighWaterByInput = new Map<string, number>();
+	const trimmedAdapterInputIds = new Set<string>();
+	const projectorInputDropById = new Map<string, () => void>();
+	let retentionEvidenceHorizonExceeded = false;
+	const { outcomes, runStatus, status, runtimeStatus, issues, audit } =
+		createAdapterRuntimeOutputNodes(graph, name);
+	let disposed = false;
+	let auditSeq = 0;
+	let retentionSeq = 0;
+	let effectiveRetention: EffectiveRuntimeRetentionPolicy = {};
+
+	function nowMs(): number | undefined {
+		return opts.now?.();
+	}
+
+	function nextRetentionSequence(): number {
+		retentionSeq += 1;
+		return retentionSeq;
+	}
+
+	function publishRuntimeStatus(fact: Omit<ToolProviderAdapterRuntimeStatus, "kind">): void {
+		const occurredAtMs = nowMs();
+		const { sourceRefs: rawSourceRefs, metadata: rawMetadata, key: rawKey, ...statusFields } = fact;
+		const sourceRefs =
+			rawSourceRefs === undefined ? undefined : sanitizeAdapterInputSourceRefs(rawSourceRefs);
+		const metadata = sanitizeProviderGraphVisibleRecord(rawMetadata, opts.publicText);
+		const key =
+			rawKey === undefined
+				? undefined
+				: boundPublicText(
+						runtimeDiagnosticKey(rawKey),
+						maxPublicMetadataStringChars(opts.publicText),
+					).text;
+		runtimeStatus.down([
+			[
+				"DATA",
+				{
+					kind: "tool-provider-adapter-runtime-status",
+					...(occurredAtMs === undefined ? {} : { occurredAtMs }),
+					...statusFields,
+					...(key === undefined ? {} : { key }),
+					...(sourceRefs === undefined ? {} : { sourceRefs }),
+					...(metadata === undefined ? {} : { metadata }),
+				} satisfies ToolProviderAdapterRuntimeStatus,
+			],
+		]);
+	}
+
+	function publishRuntimeAudit(
+		kind: string,
+		auditOpts: {
+			readonly subjectId?: string;
+			readonly sourceRefs?: readonly SourceRef[];
+			readonly issueCode?: string;
+			readonly metadata?: Record<string, unknown>;
+		} = {},
+	): void {
+		auditSeq += 1;
+		const metadata = sanitizeProviderGraphVisibleRecord(auditOpts.metadata, opts.publicText);
+		audit.down([
+			[
+				"DATA",
+				{
+					id: `${name}:audit:${auditSeq}`,
+					kind,
+					...(auditOpts.subjectId === undefined ? {} : { subjectId: auditOpts.subjectId }),
+					...(auditOpts.sourceRefs === undefined
+						? {}
+						: { sourceRefs: sanitizeAdapterInputSourceRefs(auditOpts.sourceRefs) }),
+					...(auditOpts.issueCode === undefined ? {} : { issueCode: auditOpts.issueCode }),
+					...(metadata === undefined ? {} : { metadata }),
+				} satisfies AgentRuntimeAuditRecord,
+			],
+		]);
+	}
+
+	function trackRunIssue(issue: DataIssue, emittedKey?: string, dropKey?: () => void): void {
+		const sequence = nextRetentionSequence();
+		const key = emittedKey ?? `${sequence}:${issue.code}:${issue.subjectId ?? ""}`;
+		runIssues.set(key, runIssueRetentionEntry(key, sequence, issue, nowMs()), {
+			fact: issue,
+			dropKey,
+		});
+		trimRunIssues();
+	}
+
+	function publishIssue(issue: DataIssue, track = true): void {
+		issues.down([["DATA", sanitizeAdapterInputIssue(issue)]]);
+		if (track) trackRunIssue(issue);
+	}
+
+	function publishRunStatus(
+		request: ToolProviderAdapterRunRequested,
+		nextStatus: ToolProviderAdapterRunStatus["status"],
+		statusIssues?: readonly DataIssue[],
+		outcomeId?: string,
+	): void {
+		const statusFact = {
+			kind: "tool-provider-adapter-run-status",
+			runId: request.runId,
+			adapterInputId: request.adapterInputId,
+			requestId: request.requestId,
+			operationId: request.operationId,
+			status: nextStatus,
+			attempt: request.attempt,
+			outcomeId,
+			issues: statusIssues,
+			sourceRefs: sanitizeAdapterInputSourceRefs(request.sourceRefs ?? []),
+			metadata: sanitizeGraphVisibleRecord(
+				{
+					providerId: request.providerId,
+					routeId: request.routeId,
+					reason: request.reason,
+				},
+				opts.publicText,
+			),
+		} satisfies ToolProviderAdapterRunStatus;
+		runStatus.down([["DATA", statusFact]]);
+		trackRunStatus(statusFact);
+	}
+
+	function trackRunStatus(
+		statusFact: ToolProviderAdapterRunStatus,
+		emittedKey?: string,
+		dropKey?: () => void,
+	): void {
+		const sequence = nextRetentionSequence();
+		const key = emittedKey ?? `${sequence}:${statusFact.runId}:${statusFact.status}`;
+		runStatuses.set(key, runStatusRetentionEntry(key, sequence, statusFact, nowMs()), {
+			fact: statusFact,
+			dropKey,
+		});
+		trimRunStatuses();
+	}
+
+	function retentionScore<Entry>(
+		index: ToolProviderAdapterRuntimeRetentionIndex,
+	): ((entry: Entry) => number) | undefined {
+		const policy = opts.retention?.[index] as RetentionPolicy<Entry> | undefined;
+		return typeof policy?.score === "function" ? policy.score : undefined;
+	}
+
+	function trimRuntimeIndex<Entry extends { readonly sequence: number }, Value>(
+		indexName: ToolProviderAdapterRuntimeRetentionIndex,
+		store: RuntimeRetentionIndex<Entry, Value>,
+		config: RuntimeRetentionIndexConfig | undefined,
+		onVictim?: (victim: RuntimeIndexItem<Entry, Value>) => void,
+	): void {
+		if (config?.maxSize === undefined) return;
+		let victims: RuntimeIndexItem<Entry, Value>[];
+		if (config.mode === "score") {
+			const score = retentionScore<Entry>(indexName);
+			if (score === undefined) return;
+			const selected = store.trimScored(config.maxSize, (entry) => {
+				return score(runtimeRetentionScorerEntry(indexName, entry));
+			});
+			if (selected.invalid !== undefined) {
+				publishRetentionScoreInvalid(indexName, selected.invalid);
+				return;
+			}
+			victims = selected.victims ?? [];
+		} else {
+			victims = store.trimFifo(config.maxSize);
+		}
+		for (const victim of victims) {
+			onVictim?.(victim);
+			publishRetentionTrimmed(indexName, victim.key, victim.entry);
+		}
+	}
+
+	function trackAdapterInputTrimmedEvidence(adapterInputId: string): void {
+		trimmedAdapterInputIds.add(adapterInputId);
+		const sequence = nextRetentionSequence();
+		const key = `adapter-input-trimmed:${adapterInputId}`;
+		const entry = retentionEvidenceEntry(key, sequence, {
+			adapterInputId,
+			evidenceKind: "adapter-input-trimmed",
+			occurredAtMs: nowMs(),
+			reason: "adapter-input-retention",
+		});
+		retentionEvidence.set(key, entry, entry);
+		trimRetentionEvidence();
+	}
+
+	function trackExecutionHighWaterEvidence(adapterInputId: string, attempt: number): void {
+		const previous = executionHighWaterByInput.get(adapterInputId) ?? 0;
+		const attemptHighWater = Math.max(previous, attempt);
+		executionHighWaterByInput.set(adapterInputId, attemptHighWater);
+		const sequence = nextRetentionSequence();
+		const key = `execution-high-water:${adapterInputId}`;
+		const entry = retentionEvidenceEntry(key, sequence, {
+			adapterInputId,
+			evidenceKind: "execution-high-water",
+			occurredAtMs: nowMs(),
+			attemptHighWater,
+			reason: "execution-proof-retention",
+		});
+		retentionEvidence.set(key, entry, entry);
+		trimRetentionEvidence();
+	}
+
+	function retentionEvidenceClosedKey(adapterInputId: string): string {
+		return `closed:${adapterInputId}`;
+	}
+
+	function isRetentionEvidenceClosed(adapterInputId: string): boolean {
+		return (
+			retentionEvidenceHorizonExceeded ||
+			closedRetentionEvidence.has(retentionEvidenceClosedKey(adapterInputId))
+		);
+	}
+
+	function classifyRunRequestReplayEvidence(
+		request: ToolProviderAdapterRunRequested,
+		input?: ToolProviderAdapterInput<TArguments>,
+	): ReplayEvidenceClassification {
+		if (isRetentionEvidenceClosed(request.adapterInputId)) {
+			return {
+				kind: "retention-gap",
+				index: "retentionEvidence",
+				gapKind: "evidence-horizon-closed",
+				key: retentionEvidenceClosedKey(request.adapterInputId),
+			};
+		}
+		if (input === undefined && trimmedAdapterInputIds.has(request.adapterInputId)) {
+			return {
+				kind: "retention-gap",
+				index: "adapterInputs",
+				gapKind: "adapter-input-trimmed",
+				key: `adapter-input-trimmed:${request.adapterInputId}`,
+			};
+		}
+		const highWater = executionHighWaterByInput.get(request.adapterInputId) ?? 0;
+		if (highWater >= request.attempt) {
+			return {
+				kind: "retention-gap",
+				index: "executions",
+				gapKind: "execution-proof-trimmed",
+				key: `execution-high-water:${request.adapterInputId}`,
+			};
+		}
+		if (input === undefined) return { kind: "missing-input" };
+		return { kind: "fresh" };
+	}
+
+	function classifyRetainedRunRequestReplayEvidence(
+		request: ToolProviderAdapterRunRequested,
+	): ReplayEvidenceClassification {
+		return classifyRunRequestReplayEvidence(request);
+	}
+
+	function dropProjectorInput(adapterInputId: string): void {
+		projectorInputDropById.get(adapterInputId)?.();
+		projectorInputDropById.delete(adapterInputId);
+	}
+
+	function closeRetentionEvidenceHorizon(
+		victim: RuntimeIndexItem<
+			ToolProviderAdapterRuntimeRetentionEvidenceEntry,
+			ToolProviderAdapterRuntimeRetentionEvidenceEntry
+		>,
+	): void {
+		const key = retentionEvidenceClosedKey(victim.value.adapterInputId);
+		const sequence = nextRetentionSequence();
+		const entry = retentionEvidenceEntry(key, sequence, {
+			adapterInputId: victim.value.adapterInputId,
+			evidenceKind: victim.value.evidenceKind,
+			occurredAtMs: nowMs(),
+			...(victim.value.attemptHighWater === undefined
+				? {}
+				: { attemptHighWater: victim.value.attemptHighWater }),
+			reason: victim.value.reason,
+		});
+		closedRetentionEvidence.set(key, entry, entry);
+		trimClosedRetentionEvidence();
+	}
+
+	function trimClosedRetentionEvidence(): void {
+		const maxSize = effectiveRetention.retentionEvidence?.maxSize;
+		if (maxSize === undefined) return;
+		const victims = closedRetentionEvidence.trimFifo(maxSize);
+		for (const victim of victims) {
+			const firstGlobalClosure = !retentionEvidenceHorizonExceeded;
+			if (firstGlobalClosure) retentionEvidenceHorizonExceeded = true;
+			publishRetentionTrimmed("retentionEvidence", victim.key, victim.entry);
+			if (firstGlobalClosure) {
+				publishRetentionEvidenceGlobalFailClosed(victim);
+			}
+		}
+	}
+
+	function trimAdapterInputs(): void {
+		trimRuntimeIndex("adapterInputs", adapterInputs, effectiveRetention.adapterInputs, (victim) => {
+			dropProjectorInput(victim.value.adapterInputId);
+			trackAdapterInputTrimmedEvidence(victim.value.adapterInputId);
+		});
+	}
+
+	function trimRunRequests(): void {
+		trimRuntimeIndex("runRequests", runRequests, effectiveRetention.runRequests, (victim) => {
+			victim.value.dropKey?.();
+		});
+	}
+
+	function trimExecutions(): void {
+		trimRuntimeIndex("executions", executions, effectiveRetention.executions, (victim) => {
+			trackExecutionHighWaterEvidence(victim.value.adapterInputId, victim.value.attempt);
+		});
+	}
+
+	function trimRunStatuses(): void {
+		trimRuntimeIndex("runStatuses", runStatuses, effectiveRetention.runStatuses, (victim) => {
+			victim.value.dropKey?.();
+		});
+	}
+
+	function trimRunIssues(): void {
+		trimRuntimeIndex("runIssues", runIssues, effectiveRetention.runIssues, (victim) => {
+			victim.value.dropKey?.();
+		});
+	}
+
+	function trimRetentionEvidence(): void {
+		trimRuntimeIndex(
+			"retentionEvidence",
+			retentionEvidence,
+			effectiveRetention.retentionEvidence,
+			(victim) => {
+				closeRetentionEvidenceHorizon(victim);
+				if (victim.value.evidenceKind === "adapter-input-trimmed") {
+					trimmedAdapterInputIds.delete(victim.value.adapterInputId);
+				} else {
+					executionHighWaterByInput.delete(victim.value.adapterInputId);
+				}
+				adapterInputs.delete(victim.value.adapterInputId);
+				dropProjectorInput(victim.value.adapterInputId);
+			},
+		);
+	}
+
+	function trimAllRetentionIndexes(): void {
+		trimAdapterInputs();
+		trimRunRequests();
+		trimExecutions();
+		trimRunStatuses();
+		trimRunIssues();
+		trimRetentionEvidence();
+	}
+
+	function publishRetentionTrimmed(
+		index: ToolProviderAdapterRuntimeRetentionIndex,
+		key: string,
+		entry: unknown,
+	): void {
+		const record = isRecord(entry) ? entry : {};
+		const evidenceKind = typeof record.evidenceKind === "string" ? record.evidenceKind : undefined;
+		const code =
+			index === "retentionEvidence"
+				? "tool-provider-adapter-runtime-retention-evidence-trimmed"
+				: "tool-provider-adapter-runtime-retention-trimmed";
+		const issue = dataIssue(
+			code,
+			index === "retentionEvidence"
+				? "Tool provider adapter runtime retention trimmed replay proof evidence and closed the affected horizon."
+				: "Tool provider adapter runtime retention trimmed a runtime-private index entry.",
+			{
+				subjectId:
+					typeof record.adapterInputId === "string"
+						? record.adapterInputId
+						: typeof record.key === "string"
+							? runtimeDiagnosticKey(record.key)
+							: index,
+				refs: runtimeEvidenceSourceRefs(index),
+				details: runtimeEvidenceMetadata(index, { key }),
+				severity: "info",
+			},
+		);
+		publishIssue(issue, false);
+		const sourceRefs = runtimeEvidenceSourceRefs(index);
+		const metadata = runtimeEvidenceMetadata(index, {
+			key,
+			extra: evidenceKind === undefined ? {} : { evidenceKind },
+		});
+		publishRuntimeStatus({
+			status: "retention-trimmed",
+			index,
+			key,
+			...(typeof record.adapterInputId === "string"
+				? { adapterInputId: record.adapterInputId }
+				: {}),
+			...(typeof record.runId === "string" ? { runId: record.runId } : {}),
+			...(typeof record.attempt === "number" ? { attempt: record.attempt } : {}),
+			issueCode: issue.code,
+			sourceRefs,
+			metadata,
+		});
+		publishRuntimeAudit("tool-provider-adapter-runtime-retention-trimmed", {
+			subjectId: issue.subjectId,
+			sourceRefs,
+			issueCode: issue.code,
+			metadata,
+		});
+	}
+
+	function publishRetentionScoreInvalid(
+		index: ToolProviderAdapterRuntimeRetentionIndex,
+		reason: "threw" | "non-finite",
+	): void {
+		const issue = dataIssue(
+			"tool-provider-adapter-retention-score-invalid",
+			"Tool provider adapter runtime retention scorer returned invalid material; last-known-good policy remains active.",
+			{
+				subjectId: index,
+				refs: runtimeEvidenceSourceRefs(index),
+				details: runtimeEvidenceMetadata(index, { extra: { reason } }),
+				severity: "warning",
+			},
+		);
+		publishIssue(issue, index !== "runIssues");
+		const sourceRefs = runtimeEvidenceSourceRefs(index);
+		const metadata = runtimeEvidenceMetadata(index, { extra: { reason } });
+		publishRuntimeStatus({
+			status: "invalid-retention-policy",
+			index,
+			issueCode: issue.code,
+			sourceRefs,
+			metadata,
+		});
+		publishRuntimeAudit("tool-provider-adapter-runtime-invalid-retention-policy", {
+			subjectId: index,
+			sourceRefs,
+			issueCode: issue.code,
+			metadata,
+		});
+	}
+
+	function applyRetentionPolicyFact(fact: RuntimeRetentionPolicyFact): void {
+		const invalidIndexes = new Set<ToolProviderAdapterRuntimeRetentionIndex>();
+		if (fact.issues !== undefined && fact.issues.length > 0) {
+			for (const issue of fact.issues) {
+				publishIssue(issue);
+				const index = toolProviderAdapterRuntimeRetentionIndex(issue.subjectId);
+				if (index !== undefined) invalidIndexes.add(index);
+				publishRuntimeStatus({
+					status: "invalid-retention-policy",
+					...(index === undefined ? {} : { index }),
+					issueCode: issue.code,
+					...(index === undefined ? {} : { sourceRefs: runtimeEvidenceSourceRefs(index) }),
+				});
+				publishRuntimeAudit("tool-provider-adapter-runtime-invalid-retention-policy", {
+					...(issue.subjectId === undefined ? {} : { subjectId: issue.subjectId }),
+					...(index === undefined ? {} : { sourceRefs: runtimeEvidenceSourceRefs(index) }),
+					issueCode: issue.code,
+				});
+			}
+		}
+		const adapterInputsPolicy = fact.policies.get("adapterInputs");
+		const runRequestsPolicy = fact.policies.get("runRequests");
+		const executionsPolicy = fact.policies.get("executions");
+		const runStatusesPolicy = fact.policies.get("runStatuses");
+		const runIssuesPolicy = fact.policies.get("runIssues");
+		const retentionEvidencePolicy = fact.policies.get("retentionEvidence");
+		effectiveRetention = {
+			...(invalidIndexes.has("adapterInputs")
+				? effectiveRetention.adapterInputs === undefined
+					? {}
+					: { adapterInputs: effectiveRetention.adapterInputs }
+				: adapterInputsPolicy === undefined
+					? {}
+					: { adapterInputs: adapterInputsPolicy }),
+			...(invalidIndexes.has("runRequests")
+				? effectiveRetention.runRequests === undefined
+					? {}
+					: { runRequests: effectiveRetention.runRequests }
+				: runRequestsPolicy === undefined
+					? {}
+					: { runRequests: runRequestsPolicy }),
+			...(invalidIndexes.has("executions")
+				? effectiveRetention.executions === undefined
+					? {}
+					: { executions: effectiveRetention.executions }
+				: executionsPolicy === undefined
+					? {}
+					: { executions: executionsPolicy }),
+			...(invalidIndexes.has("runStatuses")
+				? effectiveRetention.runStatuses === undefined
+					? {}
+					: { runStatuses: effectiveRetention.runStatuses }
+				: runStatusesPolicy === undefined
+					? {}
+					: { runStatuses: runStatusesPolicy }),
+			...(invalidIndexes.has("runIssues")
+				? effectiveRetention.runIssues === undefined
+					? {}
+					: { runIssues: effectiveRetention.runIssues }
+				: runIssuesPolicy === undefined
+					? {}
+					: { runIssues: runIssuesPolicy }),
+			...(invalidIndexes.has("retentionEvidence")
+				? effectiveRetention.retentionEvidence === undefined
+					? {}
+					: { retentionEvidence: effectiveRetention.retentionEvidence }
+				: retentionEvidencePolicy === undefined
+					? {}
+					: { retentionEvidence: retentionEvidencePolicy }),
+		};
+		trimAllRetentionIndexes();
+	}
+
+	function publishStatus(
+		input: ToolProviderAdapterInput<TArguments>,
+		nextStatus: AgentRequestStatus,
+		statusIssues?: readonly DataIssue[],
+	): void {
+		if (input.effectRunId === undefined) return;
+		const metadata = sanitizeGraphVisibleRecord({
+			adapterInputId: input.adapterInputId,
+			providerId: input.providerId,
+			toolName: input.toolName,
+		});
+		status.down([
+			[
+				"DATA",
+				{
+					kind: "status",
+					requestId: input.requestId,
+					operationId: input.operationId,
+					effectRunId: input.effectRunId,
+					status: nextStatus,
+					sourceRefs: defaultToolProviderAdapterEvidenceRefs(input),
+					...(statusIssues === undefined ? {} : { issues: statusIssues }),
+					...(metadata === undefined ? {} : { metadata }),
+				} satisfies AgentRequestStatusChanged,
+			],
+		]);
+	}
+
+	function publishAudit(
+		input: ToolProviderAdapterInput<TArguments>,
+		kind: string,
+		metadata?: Record<string, unknown>,
+		issueCode?: string,
+	): void {
+		auditSeq += 1;
+		const cleanMetadata = sanitizeGraphVisibleRecord({
+			adapterInputId: input.adapterInputId,
+			providerId: input.providerId,
+			toolName: input.toolName,
+			...metadata,
+		});
+		audit.down([
+			[
+				"DATA",
+				{
+					id: `${name}:audit:${auditSeq}`,
+					kind,
+					subjectId: input.requestId,
+					sourceRefs: defaultToolProviderAdapterEvidenceRefs(input),
+					...(issueCode === undefined ? {} : { issueCode }),
+					...(cleanMetadata === undefined ? {} : { metadata: cleanMetadata }),
+				} satisfies AgentRuntimeAuditRecord,
+			],
+		]);
+	}
+
+	function publishOutcome(
+		input: ToolProviderAdapterInput<TArguments>,
+		result: ToolProviderAdapterRunResult<TResult>,
+		request: ToolProviderAdapterRunRequested,
+	): void {
+		if (disposed) return;
+		let outcome: ExecutorOutcome<TResult>;
+		try {
+			outcome = buildToolProviderExecutorOutcome(input, result, {
+				attempt: request.attempt,
+				runId: request.runId,
+				occurredAtMs: opts.now?.(),
+				publicText: opts.publicText,
+			});
+		} catch (error) {
+			const issue = adapterRuntimeIssue(
+				input,
+				"tool-provider-adapter-runtime-invalid-input",
+				error,
+			);
+			publishIssue(issue);
+			publishRunStatus(request, "failure", [issue]);
+			publishStatus(input, "failed", [issue]);
+			publishAudit(input, "tool-provider-adapter-runtime-invalid-input", undefined, issue.code);
+			return;
+		}
+		outcomes.down([["DATA", outcome]]);
+		const execution = executions.get(executionCoordinate(request));
+		if (execution !== undefined) {
+			executions.set(
+				execution.key,
+				executionRetentionEntry(
+					execution.key,
+					execution.entry.sequence,
+					request,
+					outcome.kind,
+					outcome.occurredAtMs,
+					outcome.outcomeId,
+				),
+				request,
+			);
+		}
+		const publishedIssueKeys = new Set<string>();
+		for (const issue of outcome.issues ?? []) {
+			publishedIssueKeys.add(`${issue.code}:${issue.message}`);
+			publishIssue(issue);
+		}
+		if (
+			outcome.kind === "failure" &&
+			!publishedIssueKeys.has(`${outcome.error.code}:${outcome.error.message}`)
+		) {
+			publishIssue(outcome.error);
+		}
+		const statusIssues = outcomeIssues(outcome);
+		publishStatus(
+			input,
+			agentRequestStatusForExecutorOutcome(outcome),
+			statusIssues.length === 0 ? undefined : statusIssues,
+		);
+		publishRunStatus(
+			request,
+			outcome.kind,
+			statusIssues.length === 0 ? undefined : statusIssues,
+			outcome.outcomeId,
+		);
+		publishAudit(input, "tool-provider-adapter-runtime-finished", {
+			status: outcome.kind,
+			outcomeId: outcome.outcomeId,
+			runId: request.runId,
+			attempt: request.attempt,
+		});
+	}
+
+	function publishRuntimeFailure(
+		input: ToolProviderAdapterInput<TArguments>,
+		request: ToolProviderAdapterRunRequested,
+		code: string,
+		error: unknown,
+	): void {
+		const issue = adapterRuntimeIssue(input, code, error);
+		publishOutcome(
+			input,
+			{
+				kind: "failure",
+				error: issue,
+				retryable: false,
+				issues: [issue],
+			},
+			request,
+		);
+	}
+
+	function executionCoordinate(request: ToolProviderAdapterRunRequested): string {
+		return `${request.adapterInputId}:${request.attempt}`;
+	}
+
+	function trackRunRequest(
+		request: ToolProviderAdapterRunRequested,
+		emittedKey: string,
+		dropKey: () => void,
+	): void {
+		const sequence = nextRetentionSequence();
+		runRequests.set(emittedKey, runRequestRetentionEntry(emittedKey, sequence, request), {
+			fact: request,
+			dropKey,
+		});
+		trimRunRequests();
+	}
+
+	function startExecutionProof(request: ToolProviderAdapterRunRequested): boolean {
+		const coordinate = executionCoordinate(request);
+		const existing = executions.get(coordinate);
+		if (existing !== undefined) {
+			if (existing.value.runId !== request.runId) {
+				const issue = dataIssue(
+					"tool-provider-adapter-runtime-duplicate-execution-coordinate",
+					"Tool provider adapter runtime requires one visible runId per adapterInputId and attempt.",
+					{
+						subjectId: request.adapterInputId,
+						refs: [ref("tool-provider-adapter-run", request.runId)],
+						details: {
+							adapterInputId: request.adapterInputId,
+							attempt: request.attempt,
+						},
+					},
+				);
+				publishIssue(issue);
+				publishRunStatus(request, "mismatched-request", [issue]);
+				publishRuntimeAudit("tool-provider-adapter-runtime-duplicate-execution-coordinate", {
+					subjectId: request.adapterInputId,
+					sourceRefs: [ref("tool-provider-adapter-run", request.runId)],
+					issueCode: issue.code,
+					metadata: {
+						adapterInputId: request.adapterInputId,
+						attempt: request.attempt,
+						key: runtimeDiagnosticKey(coordinate),
+					},
+				});
+			}
+			return false;
+		}
+		const sequence = nextRetentionSequence();
+		executions.set(
+			coordinate,
+			executionRetentionEntry(coordinate, sequence, request, "started", nowMs()),
+			request,
+		);
+		trimExecutions();
+		const classification = classifyRunRequestReplayEvidence(
+			request,
+			adapterInputs.get(request.adapterInputId)?.value,
+		);
+		if (classification.kind !== "fresh") {
+			executions.delete(coordinate);
+			publishReplayClassification(request, classification);
+			return false;
+		}
+		return true;
+	}
+
+	function publishReplayClassification(
+		request: ToolProviderAdapterRunRequested,
+		classification: ReplayEvidenceClassification,
+	): boolean {
+		if (classification.kind === "fresh") return false;
+		if (classification.kind === "missing-input") {
+			const issueCode = "tool-provider-adapter-runtime-missing-input";
+			const issue = dataIssue(
+				issueCode,
+				"Tool provider adapter runtime requires the requested adapter input.",
+				{
+					subjectId: request.adapterInputId,
+					refs: [ref("tool-provider-adapter-run", request.runId)],
+					details: {
+						adapterInputId: request.adapterInputId,
+						runId: request.runId,
+						attempt: request.attempt,
+						issueCode,
+					},
+				},
+			);
+			publishIssue(issue);
+			publishRunStatus(request, "missing-input", [issue]);
+			return true;
+		}
+		publishRetentionGap(request, classification);
+		return true;
+	}
+
+	function publishRetentionGap(
+		request: ToolProviderAdapterRunRequested,
+		classification: Extract<ReplayEvidenceClassification, { readonly kind: "retention-gap" }>,
+	): void {
+		publishAdapterRuntimeRetentionGap(
+			{ publishIssue, publishRunStatus, publishRuntimeStatus, publishRuntimeAudit },
+			request,
+			classification,
+		);
+	}
+
+	function publishRetentionEvidenceGlobalFailClosed(
+		victim: RuntimeIndexItem<
+			ToolProviderAdapterRuntimeRetentionEvidenceEntry,
+			ToolProviderAdapterRuntimeRetentionEvidenceEntry
+		>,
+	): void {
+		publishAdapterRuntimeRetentionEvidenceGlobalFailClosed(
+			{ publishIssue, publishRunStatus, publishRuntimeStatus, publishRuntimeAudit },
+			victim,
+		);
+	}
+
+	function runRequest(request: ToolProviderAdapterRunRequested): void {
+		runAdapterRuntimeRequest(
+			{
+				isDisposed: () => disposed,
+				adapterInputs,
+				executions,
+				bindings,
+				now: opts.now,
+				classifyRunRequestReplayEvidence,
+				publishReplayClassification,
+				startExecutionProof,
+				executionCoordinate,
+				publishIssue,
+				publishRunStatus,
+				publishStatus,
+				publishAudit,
+				publishOutcome,
+				publishRuntimeFailure,
+			},
+			request,
+		);
+	}
+
+	const unsubscribeRetentionPolicy = retentionPolicy.subscribe((msg) => {
+		if (msg[0] === "DATA") applyRetentionPolicyFact(msg[1] as RuntimeRetentionPolicyFact);
+	});
+	const unsubscribeInputs = opts.inputs.subscribe((msg) => {
+		if (msg[0] !== "DATA") return;
+		const input = msg[1] as ToolProviderAdapterInput<TArguments>;
+		if (isRetentionEvidenceClosed(input.adapterInputId)) {
+			adapterInputs.delete(input.adapterInputId);
+			dropProjectorInput(input.adapterInputId);
+			return;
+		}
+		if (trimmedAdapterInputIds.delete(input.adapterInputId)) {
+			retentionEvidence.delete(`adapter-input-trimmed:${input.adapterInputId}`);
+		}
+		const sequence = nextRetentionSequence();
+		adapterInputs.set(
+			input.adapterInputId,
+			adapterInputRetentionEntry(input.adapterInputId, sequence, input, nowMs()),
+			input,
+		);
+		trimAdapterInputs();
+	});
+	const runProjector = toolProviderAdapterRunProjectorInternal(graph, {
+		name: `${name}/runs`,
+		inputs: opts.inputs,
+		runRequests: opts.runRequests,
+		autoRunReadyInputs: opts.autoRunReadyInputs,
+		now: opts.now,
+		publicText: opts.publicText,
+		privateRetentionHooks: {
+			onRunRequestKey(entry) {
+				trackRunRequest(entry.request, entry.key, entry.dropKey);
+			},
+			onRunStatusKey(entry) {
+				trackRunStatus(entry.status, entry.key, entry.dropKey);
+			},
+			onRunIssueKey(entry) {
+				trackRunIssue(entry.issue, entry.key, entry.dropKey);
+			},
+			onAdapterInputKey(entry) {
+				if (
+					isRetentionEvidenceClosed(entry.adapterInputId) ||
+					!adapterInputs.has(entry.adapterInputId)
+				) {
+					entry.dropInput();
+					projectorInputDropById.delete(entry.adapterInputId);
+					return;
+				}
+				projectorInputDropById.set(entry.adapterInputId, entry.dropInput);
+			},
+			classifyRetainedRunRequestReplayEvidence,
+		},
+	});
+	const unsubscribeRunProjectorStatus = runProjector.status.subscribe((msg) => {
+		if (msg[0] === "DATA") {
+			const statusFact = msg[1] as ToolProviderAdapterRunStatus;
+			runStatus.down([["DATA", statusFact]]);
+		}
+	});
+	const unsubscribeRunProjectorIssues = runProjector.issues.subscribe((msg) => {
+		if (msg[0] === "DATA") publishIssue(msg[1] as DataIssue, false);
+	});
+	const unsubscribeRunProjectorAudit = runProjector.audit.subscribe((msg) => {
+		if (msg[0] === "DATA") audit.down([["DATA", msg[1] as AgentRuntimeAuditRecord]]);
+	});
+	const unsubscribeRunRequests = runProjector.requests.subscribe((msg) => {
+		if (msg[0] !== "DATA") return;
+		const request = msg[1] as ToolProviderAdapterRunRequested;
+		runRequest(request);
+	});
+
+	return {
+		runRequests: runProjector.requests,
+		runStatus,
+		runtimeStatus,
+		outcomes,
+		status,
+		issues,
+		audit,
+		dispose() {
+			if (disposed) return;
+			disposed = true;
+			unsubscribeRetentionPolicy();
+			unsubscribeInputs();
+			unsubscribeRunProjectorStatus();
+			unsubscribeRunProjectorIssues();
+			unsubscribeRunProjectorAudit();
+			unsubscribeRunRequests();
+		},
+	};
+}
diff --git a/packages/ts/src/orchestration/agent-runtime-common.ts b/packages/ts/src/orchestration/agent-runtime-common.ts
new file mode 100644
index 00000000..c56bf88b
--- /dev/null
+++ b/packages/ts/src/orchestration/agent-runtime-common.ts
@@ -0,0 +1,858 @@
+import { type Ctx, depBatch } from "../ctx/types.js";
+import type { DataIssue } from "../data/index.js";
+import type { Graph } from "../graph/graph.js";
+import type { Node } from "../node/node.js";
+import type { AgentNeed } from "./agent-runtime-types-agent.js";
+import type {
+	AgentOutputEnvelope,
+	ExecutorArtifactMaterial,
+	SizeCapacityEvidence,
+	SourceRef,
+} from "./agent-runtime-types-core.js";
+import type {
+	ToolProviderAdapterInput,
+	ToolProviderExecutionPolicy,
+	ToolProviderPublicTextPolicy,
+} from "./agent-runtime-types-tool.js";
+
+export function uniqueSourceRefs(sourceRefs: readonly SourceRef[]): readonly SourceRef[] {
+	const seen = new Set<string>();
+	const unique: SourceRef[] = [];
+	for (const sourceRef of sourceRefs) {
+		const key = `${sourceRef.kind}:${sourceRef.id}:${JSON.stringify(sourceRef.metadata ?? {})}`;
+		if (seen.has(key)) continue;
+		seen.add(key);
+		unique.push(sourceRef);
+	}
+	return Object.freeze(unique);
+}
+
+export function stableJsonStringify(value: unknown): string {
+	const seen = new WeakSet<object>();
+	return JSON.stringify(value, (_key, child) => {
+		if (typeof child === "bigint") return child.toString();
+		if (typeof child === "function") return "[Function]";
+		if (!isRecord(child) && !Array.isArray(child)) return child;
+		if (seen.has(child)) return "[Circular]";
+		seen.add(child);
+		if (Array.isArray(child)) return child;
+		return Object.keys(child)
+			.sort()
+			.reduce<Record<string, unknown>>((out, key) => {
+				out[key] = child[key];
+				return out;
+			}, {});
+	});
+}
+
+export function stableStringHash(value: string): string {
+	let hash = 0x811c9dc5;
+	for (let i = 0; i < value.length; i += 1) {
+		hash ^= value.charCodeAt(i);
+		hash = Math.imul(hash, 0x01000193);
+	}
+	return (hash >>> 0).toString(36);
+}
+
+export function cloneGraphVisibleMaterial(value: unknown): unknown {
+	if (!isRecord(value) && !Array.isArray(value)) return value;
+	if (Array.isArray(value))
+		return Object.freeze(value.map((item) => cloneGraphVisibleMaterial(item)));
+	return Object.freeze(
+		Object.entries(value).reduce<Record<string, unknown>>((record, [key, child]) => {
+			record[key] = cloneGraphVisibleMaterial(child);
+			return record;
+		}, {}),
+	);
+}
+
+export function projectRuntimeFact<T, TOut>(
+	graph: Graph,
+	runtime: Node<T>,
+	name: string,
+	factory: string,
+	pick: (fact: T) => TOut | undefined,
+): Node<TOut> {
+	return graph.node<TOut>(
+		[runtime],
+		(ctx) => {
+			for (const fact of depBatch(ctx, 0) ?? []) {
+				const typed = fact as T;
+				const value = pick(typed);
+				if (value !== undefined) ctx.down([["DATA", value]]);
+			}
+		},
+		{ name, factory },
+	);
+}
+
+export function forEachDepBatch(
+	ctx: Ctx,
+	start: number,
+	count: number,
+	fn: (value: unknown) => void,
+): void {
+	for (let i = 0; i < count; i += 1) {
+		for (const value of depBatch(ctx, start + i) ?? []) fn(value);
+	}
+}
+
+export function forbiddenDataKeys(
+	value: unknown,
+	path: readonly (string | number)[] = [],
+	seen: WeakSet<object> = new WeakSet(),
+): readonly { readonly path: readonly (string | number)[]; readonly reason: string }[] {
+	if (typeof value === "function") return [{ path, reason: "function-value" }];
+	if (typeof value === "symbol" || typeof value === "bigint") {
+		return [{ path, reason: "non-graph-visible-primitive" }];
+	}
+	if (!isRecord(value) && !Array.isArray(value)) return [];
+	if (typeof value === "object" && value !== null) {
+		if (seen.has(value)) return [];
+		seen.add(value);
+	}
+	const issues: { readonly path: readonly (string | number)[]; readonly reason: string }[] = [];
+	if (Array.isArray(value)) {
+		value.forEach((item, index) => {
+			issues.push(...forbiddenDataKeys(item, [...path, index], seen));
+		});
+		return issues;
+	}
+	if (!isPlainRecord(value)) return [{ path, reason: "non-plain-runtime-object" }];
+	const symbolKeys = Object.getOwnPropertySymbols(value);
+	if (symbolKeys.length > 0) {
+		issues.push({ path, reason: "symbol-key" });
+	}
+	for (const [key, child] of Object.entries(value)) {
+		const nextPath = [...path, key];
+		if (
+			/^(apiKey|api_key|secret|client|transport|subprocess|sdk|oauth|credential|credentials|accessToken|access_token|refreshToken|refresh_token|idToken|id_token|token|password|passphrase|authorization|authHeader|auth_header|bearer|privateKey|private_key|sessionCookie|session_cookie|cookie)$/i.test(
+				key,
+			)
+		) {
+			issues.push({ path: nextPath, reason: "forbidden-runtime-key" });
+		}
+		issues.push(...forbiddenDataKeys(child, nextPath, seen));
+	}
+	return issues;
+}
+
+export function forbiddenGraphVisibleMaterialIssues(
+	value: unknown,
+	subjectRef: SourceRef,
+	area: string,
+): readonly DataIssue[] {
+	if (value === undefined) return [];
+	const forbidden = publicMaterialForbiddenKeys(value, "provider");
+	if (forbidden.length === 0) return [];
+	return Object.freeze(
+		forbidden.map((entry) =>
+			dataIssue(
+				"tool-provider-catalog-forbidden-runtime-material",
+				"Tool provider catalog material must not contain runtime-private adapter material.",
+				{ subjectId: subjectRef.id, refs: [subjectRef], details: { area, reason: entry.reason } },
+			),
+		),
+	);
+}
+
+export function forbiddenAdapterInputMaterialIssues(
+	value: unknown,
+	subjectRef: SourceRef,
+	area: string,
+): readonly DataIssue[] {
+	if (value === undefined) return [];
+	const forbidden = publicMaterialForbiddenKeys(value, "provider");
+	if (forbidden.length === 0) return [];
+	return Object.freeze(
+		forbidden.map((entry) =>
+			dataIssue(
+				"tool-provider-adapter-input-forbidden-runtime-material",
+				"Tool provider adapter input material must not contain runtime-private adapter material.",
+				{ subjectId: subjectRef.id, refs: [subjectRef], details: { area, reason: entry.reason } },
+			),
+		),
+	);
+}
+
+export type PublicMaterialMode = "graph" | "provider";
+
+export function sanitizeAdapterInputSourceRefs(
+	sourceRefs: readonly SourceRef[],
+): readonly SourceRef[] {
+	return canonicalPublicSourceRefs(sourceRefs);
+}
+
+export function sanitizeGraphVisibleRecord<T extends Record<string, unknown> | undefined>(
+	value: T,
+	policy?: ToolProviderPublicTextPolicy,
+): T | undefined {
+	return sanitizePublicRecord(value, { mode: "graph", policy });
+}
+
+export function sanitizeProviderGraphVisibleRecord<T extends Record<string, unknown> | undefined>(
+	value: T,
+	policy?: ToolProviderPublicTextPolicy,
+): T | undefined {
+	return sanitizePublicRecord(value, { mode: "provider", policy });
+}
+
+export function canonicalPublicSourceRefs(sourceRefs: readonly SourceRef[]): readonly SourceRef[] {
+	return uniqueSourceRefs(
+		sourceRefs.map((sourceRef) => {
+			const metadata = sanitizePublicRecord(sourceRef.metadata, { mode: "provider" });
+			return metadata === undefined
+				? { kind: sourceRef.kind, id: sourceRef.id }
+				: { kind: sourceRef.kind, id: sourceRef.id, metadata };
+		}),
+	);
+}
+
+export function sanitizePublicRecord<T extends Record<string, unknown> | undefined>(
+	value: T,
+	opts: {
+		readonly mode: PublicMaterialMode;
+		readonly policy?: ToolProviderPublicTextPolicy;
+	},
+): T | undefined {
+	if (value === undefined || publicMaterialForbiddenKeys(value, opts.mode).length > 0) {
+		return undefined;
+	}
+	return Object.freeze(boundRecordStrings(value, maxPublicMetadataStringChars(opts.policy))) as T;
+}
+
+export function publicMaterialForbiddenKeys(
+	value: unknown,
+	mode: PublicMaterialMode,
+): readonly { readonly path: readonly (string | number)[]; readonly reason: string }[] {
+	const forbidden = [...forbiddenDataKeys(value)];
+	if (mode === "provider") forbidden.push(...forbiddenProviderRawMaterialKeys(value));
+	return forbidden;
+}
+
+export function unlockedToolProviderPolicyOverrides(
+	overrides:
+		| Partial<Omit<ToolProviderExecutionPolicy, "kind" | "policyId" | "providerId">>
+		| undefined,
+): Partial<Omit<ToolProviderExecutionPolicy, "kind" | "policyId" | "providerId">> | undefined {
+	if (overrides === undefined) return undefined;
+	const rest = { ...(overrides as Record<string, unknown>) };
+	delete rest.kind;
+	delete rest.policyId;
+	delete rest.providerId;
+	return rest as Partial<Omit<ToolProviderExecutionPolicy, "kind" | "policyId" | "providerId">>;
+}
+
+export function sanitizeAgentOutputEnvelope<T>(
+	envelope: AgentOutputEnvelope<T>,
+	input: ToolProviderAdapterInput,
+	policy: ToolProviderPublicTextPolicy | undefined,
+	issues: DataIssue[],
+): AgentOutputEnvelope<T> {
+	const summary =
+		envelope.summary === undefined
+			? undefined
+			: boundedPublicText(envelope.summary, "summary", input, policy, issues);
+	const metadata = sanitizeRuntimeMetadata(envelope.metadata, input, policy, issues);
+	if (metadata === undefined && envelope.metadata !== undefined) {
+		issues.push(
+			dataIssue(
+				"tool-provider-adapter-runtime-metadata-redacted",
+				"Tool provider adapter runtime metadata was omitted because it contained runtime-private material.",
+				{
+					subjectId: input.requestId,
+					refs: [ref("tool-provider-adapter-input", input.adapterInputId)],
+					severity: "warning",
+				},
+			),
+		);
+	}
+	const value = sanitizeInlineOutputValue(envelope.value, input, policy, issues);
+	return Object.freeze({
+		kind: envelope.kind,
+		value: value as T | undefined,
+		refs: envelope.refs === undefined ? undefined : sanitizeAdapterInputSourceRefs(envelope.refs),
+		summary,
+		artifacts:
+			envelope.artifacts === undefined
+				? undefined
+				: Object.freeze(
+						envelope.artifacts.map((artifact) =>
+							sanitizeExecutorArtifactMaterial(artifact, input, policy, issues),
+						),
+					),
+		metadata,
+	} satisfies AgentOutputEnvelope<T>);
+}
+
+export function sanitizeExecutorArtifactMaterial(
+	artifact: ExecutorArtifactMaterial,
+	input: ToolProviderAdapterInput,
+	policy: ToolProviderPublicTextPolicy | undefined,
+	issues: DataIssue[],
+): ExecutorArtifactMaterial {
+	const metadata = sanitizeRuntimeMetadata(artifact.metadata, input, policy, issues);
+	const redaction = sanitizeRuntimeMetadata(artifact.redaction, input, policy, issues);
+	return Object.freeze({
+		kind: artifact.kind,
+		...(artifact.format === undefined ? {} : { format: artifact.format }),
+		...(artifact.schemaRef === undefined ? {} : { schemaRef: artifact.schemaRef }),
+		...(artifact.schemaKind === undefined ? {} : { schemaKind: artifact.schemaKind }),
+		...(artifact.mimeType === undefined ? {} : { mimeType: artifact.mimeType }),
+		...(artifact.mediaType === undefined ? {} : { mediaType: artifact.mediaType }),
+		...(artifact.filename === undefined ? {} : { filename: artifact.filename }),
+		...(artifact.byteLength === undefined ? {} : { byteLength: artifact.byteLength }),
+		...(artifact.digest === undefined ? {} : { digest: artifact.digest }),
+		...(artifact.encoding === undefined ? {} : { encoding: artifact.encoding }),
+		dataMode: artifact.dataMode,
+		...(artifact.summary === undefined
+			? {}
+			: { summary: boundedPublicText(artifact.summary, "summary", input, policy, issues) }),
+		...(artifact.value === undefined
+			? {}
+			: { value: sanitizeInlineOutputValue(artifact.value, input, policy, issues) }),
+		...(artifact.ref === undefined
+			? {}
+			: { ref: sanitizeAdapterInputSourceRefs([artifact.ref])[0] }),
+		...(artifact.refs === undefined ? {} : { refs: sanitizeAdapterInputSourceRefs(artifact.refs) }),
+		...(artifact.sourceRefs === undefined
+			? {}
+			: { sourceRefs: sanitizeAdapterInputSourceRefs(artifact.sourceRefs) }),
+		...(artifact.sizeEvidence === undefined
+			? {}
+			: {
+					sizeEvidence: Object.freeze(
+						artifact.sizeEvidence.map((evidence) =>
+							sanitizeSizeCapacityEvidence(evidence, input, policy, issues),
+						),
+					),
+				}),
+		...(artifact.sensitivity === undefined
+			? {}
+			: { sensitivity: Object.freeze([...artifact.sensitivity]) }),
+		...(redaction === undefined ? {} : { redaction }),
+		...(metadata === undefined ? {} : { metadata }),
+	} satisfies ExecutorArtifactMaterial);
+}
+
+function sanitizeSizeCapacityEvidence(
+	evidence: SizeCapacityEvidence,
+	input: ToolProviderAdapterInput,
+	policy: ToolProviderPublicTextPolicy | undefined,
+	issues: DataIssue[],
+): SizeCapacityEvidence {
+	const metadata = sanitizeRuntimeMetadata(evidence.metadata, input, policy, issues);
+	const redaction = sanitizeRuntimeMetadata(evidence.redaction, input, policy, issues);
+	return Object.freeze({
+		kind: "size-capacity-evidence",
+		unit: evidence.unit,
+		quantity: evidence.quantity,
+		measurementSource: evidence.measurementSource,
+		...(evidence.estimated === undefined ? {} : { estimated: evidence.estimated }),
+		...(evidence.encoding === undefined ? {} : { encoding: evidence.encoding }),
+		...(evidence.mediaType === undefined ? {} : { mediaType: evidence.mediaType }),
+		...(evidence.sourceRefs === undefined
+			? {}
+			: { sourceRefs: sanitizeAdapterInputSourceRefs(evidence.sourceRefs) }),
+		...(evidence.refs === undefined ? {} : { refs: sanitizeAdapterInputSourceRefs(evidence.refs) }),
+		...(evidence.issues === undefined
+			? {}
+			: {
+					issues: Object.freeze(evidence.issues.map((issue) => sanitizeAdapterInputIssue(issue))),
+				}),
+		...(evidence.sensitivity === undefined
+			? {}
+			: { sensitivity: Object.freeze([...evidence.sensitivity]) }),
+		...(redaction === undefined ? {} : { redaction }),
+		...(metadata === undefined ? {} : { metadata }),
+	} satisfies SizeCapacityEvidence);
+}
+
+export function sanitizeAgentNeed(
+	need: AgentNeed,
+	input: ToolProviderAdapterInput,
+	policy: ToolProviderPublicTextPolicy | undefined,
+	issues: DataIssue[],
+): AgentNeed {
+	const metadata = sanitizeRuntimeMetadata(need.metadata, input, policy, issues);
+	if (metadata === undefined && need.metadata !== undefined) {
+		issues.push(
+			dataIssue(
+				"tool-provider-adapter-runtime-metadata-redacted",
+				"Tool provider adapter runtime metadata was omitted because it contained runtime-private material.",
+				{
+					subjectId: input.requestId,
+					refs: [ref("tool-provider-adapter-input", input.adapterInputId)],
+					severity: "warning",
+				},
+			),
+		);
+	}
+	return Object.freeze({
+		kind: need.kind,
+		message:
+			need.message === undefined
+				? undefined
+				: boundedPublicText(need.message, "message", input, policy, issues),
+		refs: need.refs === undefined ? undefined : sanitizeAdapterInputSourceRefs(need.refs),
+		metadata,
+	} satisfies AgentNeed);
+}
+
+export function sanitizeRuntimeMetadata<T extends Record<string, unknown> | undefined>(
+	value: T,
+	input: ToolProviderAdapterInput,
+	policy: ToolProviderPublicTextPolicy | undefined,
+	issues: DataIssue[],
+): T | undefined {
+	if (value === undefined) return undefined;
+	const bounded = sanitizePublicRecordWithEvidence(value, { mode: "provider", policy });
+	if (bounded === undefined) return undefined;
+	for (const entry of bounded.truncated) {
+		issues.push(
+			dataIssue(
+				"tool-provider-adapter-runtime-public-text-truncated",
+				"Tool provider adapter runtime public text was truncated; large/raw material must use artifact summary/ref envelopes.",
+				{
+					subjectId: input.requestId,
+					refs: [ref("tool-provider-adapter-input", input.adapterInputId)],
+					severity: "warning",
+					details: {
+						field: "metadata",
+						path: entry.path.join("."),
+						originalChars: entry.originalChars,
+						limitChars: entry.limitChars,
+						unit: "chars",
+						measurementSource: "js-string-length",
+					},
+				},
+			),
+		);
+	}
+	return Object.freeze(bounded.value) as T;
+}
+
+export function sanitizePublicRecordWithEvidence(
+	value: Record<string, unknown>,
+	opts: {
+		readonly mode: PublicMaterialMode;
+		readonly policy?: ToolProviderPublicTextPolicy;
+	},
+):
+	| {
+			readonly value: Record<string, unknown>;
+			readonly truncated: readonly {
+				readonly path: readonly (string | number)[];
+				readonly originalChars: number;
+				readonly limitChars: number;
+			}[];
+	  }
+	| undefined {
+	if (publicMaterialForbiddenKeys(value, opts.mode).length > 0) return undefined;
+	return boundRecordStringsWithEvidence(value, maxPublicMetadataStringChars(opts.policy));
+}
+
+export function sanitizeInlineOutputValue(
+	value: unknown,
+	input: ToolProviderAdapterInput,
+	policy: ToolProviderPublicTextPolicy | undefined,
+	issues: DataIssue[],
+): unknown {
+	if (value === undefined) return undefined;
+	const forbidden = [
+		...publicMaterialForbiddenKeys(value, "provider"),
+		...oversizedInlineTextKeys(value, maxPublicSummaryChars(policy)),
+	];
+	if (forbidden.length === 0) return cloneGraphVisibleMaterial(value);
+	for (const entry of forbidden) {
+		issues.push(
+			dataIssue(
+				"tool-provider-adapter-runtime-forbidden-runtime-material",
+				"Tool provider adapter runtime output value must not inline runtime-private, raw, or oversized provider material.",
+				{
+					subjectId: input.requestId,
+					refs: [ref("tool-provider-adapter-input", input.adapterInputId)],
+					details: { reason: entry.reason },
+				},
+			),
+		);
+	}
+	return undefined;
+}
+
+export function boundedPublicText(
+	text: string,
+	field: "message" | "reason" | "summary",
+	input: ToolProviderAdapterInput,
+	policy: ToolProviderPublicTextPolicy | undefined,
+	issues: DataIssue[],
+): string {
+	const limit =
+		field === "summary"
+			? maxPublicSummaryChars(policy)
+			: field === "reason"
+				? maxPublicReasonChars(policy)
+				: maxPublicMessageChars(policy);
+	const bounded = boundPublicText(text, limit);
+	if (!bounded.truncated) return bounded.text;
+	issues.push(
+		dataIssue(
+			"tool-provider-adapter-runtime-public-text-truncated",
+			"Tool provider adapter runtime public text was truncated; large/raw material must use artifact summary/ref envelopes.",
+			{
+				subjectId: input.requestId,
+				refs: [ref("tool-provider-adapter-input", input.adapterInputId)],
+				severity: "warning",
+				details: {
+					field,
+					originalChars: bounded.originalChars,
+					limitChars: bounded.limitChars,
+					unit: "chars",
+					measurementSource: "js-string-length",
+				},
+			},
+		),
+	);
+	return bounded.text;
+}
+
+export function boundPublicText(
+	text: string,
+	limitChars: number,
+): {
+	readonly text: string;
+	readonly truncated: boolean;
+	readonly originalChars: number;
+	readonly limitChars: number;
+} {
+	const limit = Math.max(0, limitChars);
+	if (text.length <= limit) {
+		return { text, truncated: false, originalChars: text.length, limitChars: limit };
+	}
+	const bounded =
+		limit <= 1
+			? text.slice(0, limit)
+			: limit <= 3
+				? text.slice(0, limit)
+				: `${text.slice(0, limit - 3)}...`;
+	return { text: bounded, truncated: true, originalChars: text.length, limitChars: limit };
+}
+
+export function boundRecordStrings(
+	value: Record<string, unknown>,
+	limitChars: number,
+	seen: WeakSet<object> = new WeakSet(),
+): Record<string, unknown> {
+	if (seen.has(value)) return {};
+	seen.add(value);
+	return Object.entries(value).reduce<Record<string, unknown>>((out, [key, child]) => {
+		if (typeof child === "string") {
+			out[key] = boundPublicText(child, limitChars).text;
+		} else if (Array.isArray(child)) {
+			out[key] = child.map((item) =>
+				typeof item === "string"
+					? boundPublicText(item, limitChars).text
+					: isPlainRecord(item)
+						? boundRecordStrings(item, limitChars, seen)
+						: item,
+			);
+		} else if (isPlainRecord(child)) {
+			out[key] = boundRecordStrings(child, limitChars, seen);
+		} else {
+			out[key] = child;
+		}
+		return out;
+	}, {});
+}
+
+export function boundRecordStringsWithEvidence(
+	value: Record<string, unknown>,
+	limitChars: number,
+	path: readonly (string | number)[] = [],
+	seen: WeakSet<object> = new WeakSet(),
+): {
+	readonly value: Record<string, unknown>;
+	readonly truncated: readonly {
+		readonly path: readonly (string | number)[];
+		readonly originalChars: number;
+		readonly limitChars: number;
+	}[];
+} {
+	if (seen.has(value)) return { value: {}, truncated: [] };
+	seen.add(value);
+	const truncated: {
+		readonly path: readonly (string | number)[];
+		readonly originalChars: number;
+		readonly limitChars: number;
+	}[] = [];
+	const out = Object.entries(value).reduce<Record<string, unknown>>((record, [key, child]) => {
+		const childPath = [...path, key];
+		if (typeof child === "string") {
+			const bounded = boundPublicText(child, limitChars);
+			record[key] = bounded.text;
+			if (bounded.truncated) {
+				truncated.push({
+					path: childPath,
+					originalChars: bounded.originalChars,
+					limitChars: bounded.limitChars,
+				});
+			}
+		} else if (Array.isArray(child)) {
+			record[key] = child.map((item, index) => {
+				const itemPath = [...childPath, index];
+				if (typeof item === "string") {
+					const bounded = boundPublicText(item, limitChars);
+					if (bounded.truncated) {
+						truncated.push({
+							path: itemPath,
+							originalChars: bounded.originalChars,
+							limitChars: bounded.limitChars,
+						});
+					}
+					return bounded.text;
+				}
+				if (isPlainRecord(item)) {
+					const nested = boundRecordStringsWithEvidence(item, limitChars, itemPath, seen);
+					truncated.push(...nested.truncated);
+					return nested.value;
+				}
+				return item;
+			});
+		} else if (isPlainRecord(child)) {
+			const nested = boundRecordStringsWithEvidence(child, limitChars, childPath, seen);
+			record[key] = nested.value;
+			truncated.push(...nested.truncated);
+		} else {
+			record[key] = child;
+		}
+		return record;
+	}, {});
+	return { value: out, truncated };
+}
+
+export function sanitizeIssueDetails(
+	details: unknown,
+	policy?: ToolProviderPublicTextPolicy,
+): unknown {
+	if (details === undefined) return undefined;
+	if (publicMaterialForbiddenKeys(details, "provider").length > 0) {
+		return { redacted: true, reason: "forbidden-runtime-material" };
+	}
+	const bounded = boundUnknownStringsWithEvidence(details, maxPublicMetadataStringChars(policy));
+	if (bounded.truncated.length === 0) return bounded.value;
+	const detailsTruncated = {
+		detailsTruncated: true,
+		detailsTruncatedPaths: bounded.truncated.map((entry) => entry.path.join(".")),
+		measurementSource: "js-string-length",
+	};
+	if (isPlainRecord(bounded.value)) {
+		return Object.freeze({ ...bounded.value, ...detailsTruncated });
+	}
+	return Object.freeze({ value: bounded.value, ...detailsTruncated });
+}
+
+export function boundUnknownStringsWithEvidence(
+	value: unknown,
+	limitChars: number,
+	path: readonly (string | number)[] = [],
+	seen: WeakSet<object> = new WeakSet(),
+): {
+	readonly value: unknown;
+	readonly truncated: readonly {
+		readonly path: readonly (string | number)[];
+		readonly originalChars: number;
+		readonly limitChars: number;
+	}[];
+} {
+	if (typeof value === "string") {
+		const bounded = boundPublicText(value, limitChars);
+		return {
+			value: bounded.text,
+			truncated: bounded.truncated
+				? [{ path, originalChars: bounded.originalChars, limitChars: bounded.limitChars }]
+				: [],
+		};
+	}
+	if (!isRecord(value) && !Array.isArray(value)) return { value, truncated: [] };
+	if (typeof value === "object" && value !== null) {
+		if (seen.has(value)) return { value: Array.isArray(value) ? [] : {}, truncated: [] };
+		seen.add(value);
+	}
+	const truncated: {
+		readonly path: readonly (string | number)[];
+		readonly originalChars: number;
+		readonly limitChars: number;
+	}[] = [];
+	if (Array.isArray(value)) {
+		const out = value.map((item, index) => {
+			const bounded = boundUnknownStringsWithEvidence(item, limitChars, [...path, index], seen);
+			truncated.push(...bounded.truncated);
+			return bounded.value;
+		});
+		return { value: out, truncated };
+	}
+	const out = Object.entries(value).reduce<Record<string, unknown>>((record, [key, child]) => {
+		const bounded = boundUnknownStringsWithEvidence(child, limitChars, [...path, key], seen);
+		record[key] = bounded.value;
+		truncated.push(...bounded.truncated);
+		return record;
+	}, {});
+	return { value: out, truncated };
+}
+
+export function oversizedInlineTextKeys(
+	value: unknown,
+	limitChars: number,
+	path: readonly (string | number)[] = [],
+	seen: WeakSet<object> = new WeakSet(),
+): readonly { readonly path: readonly (string | number)[]; readonly reason: string }[] {
+	if (typeof value === "string") {
+		return value.length > Math.max(0, limitChars)
+			? [{ path, reason: "oversized-inline-text" }]
+			: [];
+	}
+	if (!isRecord(value) && !Array.isArray(value)) return [];
+	if (typeof value === "object" && value !== null) {
+		if (seen.has(value)) return [];
+		seen.add(value);
+	}
+	const issues: { readonly path: readonly (string | number)[]; readonly reason: string }[] = [];
+	if (Array.isArray(value)) {
+		value.forEach((item, index) => {
+			issues.push(...oversizedInlineTextKeys(item, limitChars, [...path, index], seen));
+		});
+		return issues;
+	}
+	for (const [key, child] of Object.entries(value)) {
+		issues.push(...oversizedInlineTextKeys(child, limitChars, [...path, key], seen));
+	}
+	return issues;
+}
+
+export function maxPublicMessageChars(policy?: ToolProviderPublicTextPolicy): number {
+	return normalizedPublicTextLimit(policy?.maxMessageChars, 512);
+}
+
+export function maxPublicSummaryChars(policy?: ToolProviderPublicTextPolicy): number {
+	return normalizedPublicTextLimit(policy?.maxSummaryChars, 512);
+}
+
+export function maxPublicReasonChars(policy?: ToolProviderPublicTextPolicy): number {
+	return normalizedPublicTextLimit(policy?.maxReasonChars, 512);
+}
+
+export function maxPublicMetadataStringChars(policy?: ToolProviderPublicTextPolicy): number {
+	return normalizedPublicTextLimit(policy?.maxMetadataStringChars, 256);
+}
+
+export function normalizedPublicTextLimit(value: number | undefined, fallback: number): number {
+	if (value === undefined || !Number.isFinite(value)) return fallback;
+	return Math.max(0, Math.floor(value));
+}
+
+export function sanitizeAdapterInputIssue(
+	issue: DataIssue,
+	policy?: ToolProviderPublicTextPolicy,
+): DataIssue {
+	const boundedMessage = boundPublicText(issue.message, maxPublicMessageChars(policy));
+	const details = sanitizeIssueDetails(issue.details, policy);
+	const metadata = sanitizeProviderGraphVisibleRecord(issue.metadata, policy);
+	const refs =
+		issue.refs === undefined
+			? undefined
+			: Object.freeze(issue.refs.filter((entry): entry is string => typeof entry === "string"));
+	return Object.freeze({
+		kind: issue.kind,
+		code: issue.code,
+		...(issue.source === undefined ? {} : { source: issue.source }),
+		message: boundedMessage.text,
+		severity: issue.severity,
+		subjectId: issue.subjectId,
+		...(issue.correlationId === undefined ? {} : { correlationId: issue.correlationId }),
+		...(issue.causationId === undefined ? {} : { causationId: issue.causationId }),
+		...(issue.path === undefined ? {} : { path: Object.freeze([...issue.path]) }),
+		...(refs === undefined || refs.length === 0 ? {} : { refs }),
+		...(issue.retryable === undefined ? {} : { retryable: issue.retryable }),
+		details:
+			boundedMessage.truncated || details !== issue.details
+				? {
+						...(isRecord(details) ? details : {}),
+						...(boundedMessage.truncated
+							? {
+									truncated: true,
+									originalChars: boundedMessage.originalChars,
+									limitChars: boundedMessage.limitChars,
+									measurementSource: "js-string-length",
+								}
+							: {}),
+					}
+				: details,
+		...(metadata === undefined ? {} : { metadata }),
+	} satisfies DataIssue);
+}
+
+export function forbiddenProviderRawMaterialKeys(
+	value: unknown,
+	path: readonly (string | number)[] = [],
+	seen: WeakSet<object> = new WeakSet(),
+): readonly { readonly path: readonly (string | number)[]; readonly reason: string }[] {
+	if (!isRecord(value) && !Array.isArray(value)) return [];
+	if (typeof value === "object" && value !== null) {
+		if (seen.has(value)) return [];
+		seen.add(value);
+	}
+	const issues: { readonly path: readonly (string | number)[]; readonly reason: string }[] = [];
+	if (Array.isArray(value)) {
+		value.forEach((item, index) => {
+			issues.push(...forbiddenProviderRawMaterialKeys(item, [...path, index], seen));
+		});
+		return issues;
+	}
+	for (const [key, child] of Object.entries(value)) {
+		const nextPath = [...path, key];
+		if (
+			/^(stdout|stderr|stack|stackTrace|stack_trace|providerRaw|provider_raw|rawResponse|raw_response|diff|patch|fileContents|file_contents|binary|media)$/i.test(
+				key,
+			)
+		) {
+			issues.push({ path: nextPath, reason: "raw-provider-material" });
+		}
+		issues.push(...forbiddenProviderRawMaterialKeys(child, nextPath, seen));
+	}
+	return issues;
+}
+
+export function dataIssue(
+	code: string,
+	message: string,
+	opts: {
+		readonly subjectId?: string;
+		readonly refs?: readonly SourceRef[];
+		readonly severity?: DataIssue["severity"];
+		readonly details?: unknown;
+	} = {},
+): DataIssue {
+	return {
+		kind: "issue",
+		code,
+		message,
+		severity: opts.severity ?? "error",
+		subjectId: opts.subjectId,
+		refs: opts.refs?.map((r) => `${r.kind}:${r.id}`),
+		details: opts.details,
+	};
+}
+
+export function ref(kind: string, id: string): SourceRef {
+	return { kind, id };
+}
+
+export function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+export function isPlainRecord(value: unknown): value is Record<string, unknown> {
+	if (!isRecord(value)) return false;
+	const proto = Object.getPrototypeOf(value);
+	return proto === Object.prototype || proto === null;
+}
diff --git a/packages/ts/src/orchestration/agent-runtime-decision-interpreter.ts b/packages/ts/src/orchestration/agent-runtime-decision-interpreter.ts
new file mode 100644
index 00000000..cd8247a5
--- /dev/null
+++ b/packages/ts/src/orchestration/agent-runtime-decision-interpreter.ts
@@ -0,0 +1,342 @@
+import { type Ctx, depBatch } from "../ctx/types.js";
+import type { DataIssue } from "../data/index.js";
+import type { Graph } from "../graph/graph.js";
+import type { Node } from "../node/node.js";
+import {
+	dataIssue,
+	forEachDepBatch,
+	isRecord,
+	projectRuntimeFact,
+	ref,
+} from "./agent-runtime-common.js";
+import type { EffectRunCompletionState } from "./agent-runtime-effect-completion.js";
+import {
+	decisionSourceRequestTerminal,
+	requiredPendingRequests,
+} from "./agent-runtime-effect-completion.js";
+import type {
+	AgentDecision,
+	AgentDecisionBlocked,
+	AgentDecisionContinue,
+	AgentDecisionFinal,
+	AgentRuntimeAuditRecord,
+	EffectRunResult,
+	StructuredAgentDecisionEnvelope,
+	StructuredAgentDecisionInterpreterBundle,
+} from "./agent-runtime-types-agent.js";
+import type {
+	AgentRequestFact,
+	AgentRequestIssued,
+	ExecutorOutcome,
+} from "./agent-runtime-types-core.js";
+
+export function structuredAgentDecisionInterpreter(
+	graph: Graph,
+	outcomes: Node<ExecutorOutcome>,
+	opts: {
+		readonly name?: string;
+		readonly schemaRef?: string;
+		readonly requestFacts?: readonly Node<AgentRequestFact>[];
+	} = {},
+): StructuredAgentDecisionInterpreterBundle {
+	const name = opts.name ?? "structuredAgentDecisionInterpreter";
+	const requestFacts = opts.requestFacts ?? [];
+	const runtime = graph.node<StructuredAgentDecisionInterpreterFact>(
+		[outcomes, ...requestFacts],
+		(ctx) => {
+			const state = ctx.state.get<StructuredInterpreterState>() ?? {
+				requests: new Map<string, AgentRequestIssued>(),
+				issueSeq: 0,
+			};
+			forEachDepBatch(ctx, 1, requestFacts.length, (raw) => {
+				const fact = raw as AgentRequestFact;
+				if (fact.kind === "issued") state.requests.set(fact.requestId, fact);
+			});
+			for (const raw of depBatch(ctx, 0) ?? []) {
+				const outcome = raw as ExecutorOutcome;
+				if (outcome.kind !== "result") {
+					state.issueSeq += 1;
+					emitInterpreterIssue(
+						ctx,
+						state.issueSeq,
+						outcome,
+						"non-result-outcome",
+						"Only result outcomes can carry AgentDecision envelopes",
+					);
+					continue;
+				}
+				const value = outcome.result.value;
+				if (!isRecord(value)) {
+					state.issueSeq += 1;
+					emitInterpreterIssue(
+						ctx,
+						state.issueSeq,
+						outcome,
+						"malformed-agent-decision",
+						"ExecutorOutcome result must carry a structured agent-decision envelope",
+					);
+					continue;
+				}
+				const envelope = value as Partial<StructuredAgentDecisionEnvelope>;
+				if (envelope.kind !== "agent-decision" || !isRecord(envelope.decision)) {
+					state.issueSeq += 1;
+					emitInterpreterIssue(
+						ctx,
+						state.issueSeq,
+						outcome,
+						"malformed-agent-decision",
+						"Structured agent-decision envelope is missing kind or decision",
+					);
+					continue;
+				}
+				if (typeof envelope.schemaRef !== "string" || envelope.schemaRef.length === 0) {
+					state.issueSeq += 1;
+					emitInterpreterIssue(
+						ctx,
+						state.issueSeq,
+						outcome,
+						"missing-agent-decision-schema",
+						"Structured agent-decision envelope must carry schemaRef evidence",
+					);
+					continue;
+				}
+				if (opts.schemaRef !== undefined && envelope.schemaRef !== opts.schemaRef) {
+					state.issueSeq += 1;
+					emitInterpreterIssue(
+						ctx,
+						state.issueSeq,
+						outcome,
+						"agent-decision-schema-mismatch",
+						"Structured agent-decision envelope schemaRef did not match",
+					);
+					continue;
+				}
+				const decision = validateAgentDecision(envelope.decision, outcome);
+				if (typeof decision === "string") {
+					state.issueSeq += 1;
+					emitInterpreterIssue(ctx, state.issueSeq, outcome, "malformed-agent-decision", decision);
+					continue;
+				}
+				const request = state.requests.get(decision.source.requestId);
+				if (request === undefined) {
+					state.issueSeq += 1;
+					emitInterpreterIssue(
+						ctx,
+						state.issueSeq,
+						outcome,
+						"missing-agent-decision-request",
+						"AgentDecision source request must be present in the request ledger",
+					);
+					continue;
+				}
+				if (
+					request.effectRunId !== decision.effectRunId ||
+					request.operationId !== decision.source.operationId
+				) {
+					state.issueSeq += 1;
+					emitInterpreterIssue(
+						ctx,
+						state.issueSeq,
+						outcome,
+						"stale-agent-decision-source",
+						"AgentDecision source request/effectRun/operation identity did not match the request ledger",
+					);
+					continue;
+				}
+				ctx.down([
+					["DATA", { kind: "decision", decision } satisfies StructuredAgentDecisionInterpreterFact],
+					[
+						"DATA",
+						{
+							kind: "audit",
+							audit: {
+								id: `${outcome.outcomeId}:agent-decision-interpreted`,
+								kind: "agent-decision-interpreted",
+								subjectId: decision.effectRunId,
+								sourceRefs: [ref("executor-outcome", outcome.outcomeId)],
+							},
+						} satisfies StructuredAgentDecisionInterpreterFact,
+					],
+				]);
+			}
+			ctx.state.set(state);
+		},
+		{ name: `${name}/runtime`, factory: "structuredAgentDecisionInterpreter" },
+	);
+	return {
+		decisions: projectRuntimeFact(
+			graph,
+			runtime,
+			`${name}/decisions`,
+			"structuredAgentDecisions",
+			(fact) => (fact.kind === "decision" ? fact.decision : undefined),
+		),
+		issues: projectRuntimeFact(
+			graph,
+			runtime,
+			`${name}/issues`,
+			"structuredAgentDecisionIssues",
+			(fact) => (fact.kind === "issue" ? fact.issue : undefined),
+		),
+		audit: projectRuntimeFact(
+			graph,
+			runtime,
+			`${name}/audit`,
+			"structuredAgentDecisionAudit",
+			(fact) => (fact.kind === "audit" ? fact.audit : undefined),
+		),
+	};
+}
+
+export type StructuredAgentDecisionInterpreterFact =
+	| { readonly kind: "decision"; readonly decision: AgentDecision }
+	| { readonly kind: "issue"; readonly issue: DataIssue }
+	| { readonly kind: "audit"; readonly audit: AgentRuntimeAuditRecord };
+
+export interface StructuredInterpreterState {
+	requests: Map<string, AgentRequestIssued>;
+	issueSeq: number;
+}
+
+export function emitInterpreterIssue(
+	ctx: Ctx,
+	seq: number,
+	outcome: ExecutorOutcome,
+	code: string,
+	message: string,
+): void {
+	const issue = dataIssue(code, message, {
+		subjectId: outcome.requestId,
+		refs: [ref("executor-outcome", outcome.outcomeId)],
+	});
+	ctx.down([
+		["DATA", { kind: "issue", issue } satisfies StructuredAgentDecisionInterpreterFact],
+		[
+			"DATA",
+			{
+				kind: "audit",
+				audit: {
+					id: `${outcome.outcomeId}:agent-decision-issue:${seq}`,
+					kind: "agent-decision-issue",
+					subjectId: outcome.requestId,
+					issueCode: code,
+					message,
+					sourceRefs: [ref("executor-outcome", outcome.outcomeId)],
+				},
+			} satisfies StructuredAgentDecisionInterpreterFact,
+		],
+	]);
+}
+
+export function validateAgentDecision(
+	raw: unknown,
+	outcome: ExecutorOutcome,
+): AgentDecision | string {
+	if (!isRecord(raw)) return "AgentDecision must be an object";
+	const kind = raw.kind;
+	if (kind !== "continue" && kind !== "final" && kind !== "blocked") {
+		return "AgentDecision kind must be continue, final, or blocked";
+	}
+	if (typeof raw.decisionId !== "string" || raw.decisionId.length === 0)
+		return "AgentDecision decisionId must be a non-empty string";
+	if (
+		raw.effectRunId === undefined ||
+		typeof raw.effectRunId !== "string" ||
+		raw.effectRunId.length === 0
+	)
+		return "AgentDecision effectRunId must be a non-empty string";
+	if (typeof raw.agentRunId !== "string" || raw.agentRunId.length === 0)
+		return "AgentDecision agentRunId must be a non-empty string";
+	const source = raw.source;
+	if (
+		!isRecord(source) ||
+		source.requestId !== outcome.requestId ||
+		source.operationId !== outcome.operationId ||
+		source.outcomeId !== outcome.outcomeId
+	) {
+		return "AgentDecision source must match the ExecutorOutcome requestId, operationId, and outcomeId";
+	}
+	if (kind === "continue") {
+		if (!Array.isArray(raw.next)) return "AgentDecision.continue next must be an array";
+		for (const proposal of raw.next) {
+			if (!isAgentRequestProposalLike(proposal, raw.effectRunId)) {
+				return "AgentDecision.continue next entries must be AgentRequestProposal-like objects";
+			}
+		}
+		return raw as unknown as AgentDecisionContinue;
+	}
+	if (kind === "final") {
+		if (!isRecord(raw.output) || typeof raw.output.kind !== "string")
+			return "AgentDecision.final output must be an envelope with kind";
+		return raw as unknown as AgentDecisionFinal;
+	}
+	if (!Array.isArray(raw.needs)) return "AgentDecision.blocked needs must be an array";
+	for (const need of raw.needs) {
+		if (!isAgentNeedLike(need))
+			return "AgentDecision.blocked needs entries must be AgentNeed-like objects";
+	}
+	return raw as unknown as AgentDecisionBlocked;
+}
+
+export function isAgentRequestProposalLike(value: unknown, effectRunId: string): boolean {
+	if (!isRecord(value)) return false;
+	if (value.kind !== "proposal") return false;
+	if (typeof value.proposalId !== "string" || value.proposalId.length === 0) return false;
+	if (value.effectRunId !== effectRunId) return false;
+	return (
+		value.requestKind === "context" ||
+		value.requestKind === "prompt" ||
+		value.requestKind === "executor"
+	);
+}
+
+export function isAgentNeedLike(value: unknown): boolean {
+	return isRecord(value) && typeof value.kind === "string" && value.kind.length > 0;
+}
+
+export function candidateFromDecision(
+	decision: AgentDecision,
+	state: EffectRunCompletionState,
+	completedAtMs: number,
+): EffectRunResult | undefined {
+	const run = state.runs.get(decision.effectRunId);
+	if (run === undefined) return undefined;
+	if (!decisionSourceRequestTerminal(decision, state)) return undefined;
+	const requiredPending = requiredPendingRequests(decision.effectRunId, state);
+	if (decision.kind === "final") {
+		if (requiredPending.length > 0) {
+			return undefined;
+		}
+		return {
+			kind: "effect-run-result",
+			resultId: `${decision.effectRunId}:result`,
+			status: "completed",
+			effectRunId: decision.effectRunId,
+			subjectRefs: run.subjectRefs,
+			operationId: decision.source.operationId,
+			sourceRefs: [
+				ref("agent-decision", decision.decisionId),
+				ref("executor-outcome", decision.source.outcomeId),
+			],
+			completedAtMs,
+			output: decision.output,
+		};
+	}
+	if (decision.kind === "blocked" && requiredPending.length === 0) {
+		return {
+			kind: "effect-run-result",
+			resultId: `${decision.effectRunId}:result`,
+			status: "blocked",
+			effectRunId: decision.effectRunId,
+			subjectRefs: run.subjectRefs,
+			operationId: decision.source.operationId,
+			sourceRefs: [
+				ref("agent-decision", decision.decisionId),
+				ref("executor-outcome", decision.source.outcomeId),
+			],
+			completedAtMs,
+			needs: decision.needs,
+		};
+	}
+	return undefined;
+}
diff --git a/packages/ts/src/orchestration/agent-runtime-effect-completion.ts b/packages/ts/src/orchestration/agent-runtime-effect-completion.ts
new file mode 100644
index 00000000..07409428
--- /dev/null
+++ b/packages/ts/src/orchestration/agent-runtime-effect-completion.ts
@@ -0,0 +1,434 @@
+import { type Ctx, depBatch } from "../ctx/types.js";
+import type { DataIssue } from "../data/index.js";
+import type { Graph } from "../graph/graph.js";
+import type { Node } from "../node/node.js";
+import { dataIssue, forEachDepBatch, projectRuntimeFact, ref } from "./agent-runtime-common.js";
+import { candidateFromDecision } from "./agent-runtime-decision-interpreter.js";
+import type {
+	AgentDecision,
+	AgentRuntimeAuditRecord,
+	EffectRunCompletionBundle,
+	EffectRunCompletionStatus,
+	EffectRunResult,
+} from "./agent-runtime-types-agent.js";
+import type {
+	AgentRequestFact,
+	AgentRequestIssued,
+	AgentRequestStatus,
+	AgentRequestStatusChanged,
+	EffectRun,
+	SourceRef,
+} from "./agent-runtime-types-core.js";
+
+export function effectRunCompletionProjector(
+	graph: Graph,
+	opts: {
+		readonly name?: string;
+		readonly effectRuns: Node<EffectRun>;
+		readonly decisions?: readonly Node<AgentDecision>[];
+		readonly requestStatuses?: readonly Node<AgentRequestStatusChanged>[];
+		readonly requestFacts?: readonly Node<AgentRequestFact>[];
+		readonly resultCandidates?: readonly Node<EffectRunResult>[];
+		readonly now?: () => number;
+	},
+): EffectRunCompletionBundle {
+	const name = opts.name ?? "effectRunCompletion";
+	const decisions = opts.decisions ?? [];
+	const requestStatuses = opts.requestStatuses ?? [];
+	const requestFacts = opts.requestFacts ?? [];
+	const resultCandidates = opts.resultCandidates ?? [];
+	const deps = [
+		opts.effectRuns,
+		...decisions,
+		...requestStatuses,
+		...requestFacts,
+		...resultCandidates,
+	];
+	const decisionStart = 1;
+	const requestStatusStart = decisionStart + decisions.length;
+	const requestFactStart = requestStatusStart + requestStatuses.length;
+	const resultCandidateStart = requestFactStart + requestFacts.length;
+	const now = opts.now ?? Date.now;
+	const runtime = graph.node<EffectRunCompletionFact>(
+		deps,
+		(ctx) => {
+			const state = ctx.state.get<EffectRunCompletionState>() ?? emptyEffectRunCompletionState();
+			const touchedEffectRunIds = new Set<string>();
+			for (const raw of depBatch(ctx, 0) ?? []) {
+				const run = raw as EffectRun;
+				state.runs.set(run.effectRunId, run);
+				touchedEffectRunIds.add(run.effectRunId);
+			}
+			forEachDepBatch(ctx, requestFactStart, requestFacts.length, (raw) => {
+				const fact = raw as AgentRequestFact;
+				if (fact.kind === "issued") {
+					state.requests.set(fact.requestId, fact);
+					touchedEffectRunIds.add(fact.effectRunId);
+					const existingStatus = state.statusByRequest.get(fact.requestId);
+					if (existingStatus !== undefined && !statusMatchesRequest(existingStatus, fact)) {
+						emitEffectRunIssue(
+							ctx,
+							state,
+							"stale-request-status",
+							`AgentRequest status for '${fact.requestId}' did not match its issued effectRun/operation identity`,
+							fact.effectRunId,
+							[ref("agent-request", fact.requestId)],
+						);
+					}
+					const result = state.resultsByEffectRun.get(fact.effectRunId);
+					if (result !== undefined && fact.required) {
+						state.issueSeq += 1;
+						const issue = dataIssue(
+							"late-required-request-after-effect-run-result",
+							`Required request '${fact.requestId}' arrived after EffectRun '${fact.effectRunId}' already had a terminal result`,
+							{
+								subjectId: fact.effectRunId,
+								refs: [
+									ref("agent-request", fact.requestId),
+									ref("effect-run-result", result.resultId),
+								],
+							},
+						);
+						ctx.down([
+							["DATA", { kind: "issue", issue } satisfies EffectRunCompletionFact],
+							[
+								"DATA",
+								{
+									kind: "audit",
+									audit: {
+										id: `${fact.effectRunId}:late-required-request:${state.issueSeq}`,
+										kind: "late-required-request-after-effect-run-result",
+										subjectId: fact.effectRunId,
+										issueCode: issue.code,
+										sourceRefs: [
+											ref("agent-request", fact.requestId),
+											ref("effect-run-result", result.resultId),
+										],
+									},
+								} satisfies EffectRunCompletionFact,
+							],
+						]);
+					}
+				} else if (fact.kind === "status") {
+					acceptRequestStatus(ctx, state, fact);
+					touchedEffectRunIds.add(fact.effectRunId);
+				}
+			});
+			forEachDepBatch(ctx, requestStatusStart, requestStatuses.length, (raw) => {
+				const status = raw as AgentRequestStatusChanged;
+				acceptRequestStatus(ctx, state, status);
+				touchedEffectRunIds.add(status.effectRunId);
+			});
+			forEachDepBatch(ctx, resultCandidateStart, resultCandidates.length, (raw) => {
+				acceptEffectRunResultCandidate(ctx, state, raw as EffectRunResult);
+			});
+			forEachDepBatch(ctx, decisionStart, decisions.length, (raw) => {
+				const decision = raw as AgentDecision;
+				state.decisions.set(decision.decisionId, decision);
+				touchedEffectRunIds.add(decision.effectRunId);
+			});
+			for (const decision of state.decisions.values()) {
+				if (state.resultsByEffectRun.has(decision.effectRunId)) continue;
+				const candidate = candidateFromDecision(decision, state, now());
+				if (candidate === undefined) continue;
+				acceptEffectRunResultCandidate(ctx, state, candidate);
+			}
+			for (const effectRunId of touchedEffectRunIds) {
+				if (!state.resultsByEffectRun.has(effectRunId)) {
+					emitEffectRunStatus(
+						ctx,
+						effectRunId,
+						"pending",
+						requiredPendingRequests(effectRunId, state),
+						requiredTerminalRequests(effectRunId, state),
+					);
+				}
+			}
+			ctx.state.set(state);
+		},
+		{ name: `${name}/runtime`, factory: "effectRunCompletionProjector" },
+	);
+	return {
+		results: projectRuntimeFact(
+			graph,
+			runtime,
+			`${name}/results`,
+			"effectRunCompletionResults",
+			(fact) => (fact.kind === "result" ? fact.result : undefined),
+		),
+		status: projectRuntimeFact(
+			graph,
+			runtime,
+			`${name}/status`,
+			"effectRunCompletionStatus",
+			(fact) => (fact.kind === "status" ? fact.status : undefined),
+		),
+		issues: projectRuntimeFact(
+			graph,
+			runtime,
+			`${name}/issues`,
+			"effectRunCompletionIssues",
+			(fact) => (fact.kind === "issue" ? fact.issue : undefined),
+		),
+		audit: projectRuntimeFact(
+			graph,
+			runtime,
+			`${name}/audit`,
+			"effectRunCompletionAudit",
+			(fact) => (fact.kind === "audit" ? fact.audit : undefined),
+		),
+	};
+}
+
+export type EffectRunCompletionFact =
+	| { readonly kind: "result"; readonly result: EffectRunResult }
+	| { readonly kind: "status"; readonly status: EffectRunCompletionStatus }
+	| { readonly kind: "issue"; readonly issue: DataIssue }
+	| { readonly kind: "audit"; readonly audit: AgentRuntimeAuditRecord };
+
+export interface EffectRunCompletionState {
+	runs: Map<string, EffectRun>;
+	requests: Map<string, AgentRequestIssued>;
+	statusByRequest: Map<string, AgentRequestStatusChanged>;
+	decisions: Map<string, AgentDecision>;
+	resultsByEffectRun: Map<string, EffectRunResult>;
+	issueSeq: number;
+}
+
+export function acceptEffectRunResultCandidate(
+	ctx: Ctx,
+	state: EffectRunCompletionState,
+	candidate: EffectRunResult,
+): void {
+	if (!state.runs.has(candidate.effectRunId)) {
+		emitEffectRunIssue(
+			ctx,
+			state,
+			"unknown-effect-run-result-candidate",
+			`EffectRunResult candidate '${candidate.resultId}' references unknown EffectRun '${candidate.effectRunId}'`,
+			candidate.effectRunId,
+			candidate.sourceRefs,
+		);
+		return;
+	}
+	const existing = state.resultsByEffectRun.get(candidate.effectRunId);
+	if (existing !== undefined) {
+		state.issueSeq += 1;
+		const duplicate = sameTerminalResult(existing, candidate);
+		const code = duplicate ? "duplicate-effect-run-result" : "conflicting-effect-run-result";
+		const issue = dataIssue(
+			code,
+			`EffectRun '${candidate.effectRunId}' already has a terminal result`,
+			{
+				subjectId: candidate.effectRunId,
+				refs: candidate.sourceRefs,
+			},
+		);
+		ctx.down([
+			["DATA", { kind: "issue", issue } satisfies EffectRunCompletionFact],
+			[
+				"DATA",
+				{
+					kind: "audit",
+					audit: {
+						id: `${candidate.effectRunId}:${code}:${state.issueSeq}`,
+						kind: duplicate ? "effect-run-result-duplicate" : "effect-run-result-conflict",
+						subjectId: candidate.effectRunId,
+						issueCode: issue.code,
+						sourceRefs: candidate.sourceRefs,
+					},
+				} satisfies EffectRunCompletionFact,
+			],
+		]);
+		return;
+	}
+	state.resultsByEffectRun.set(candidate.effectRunId, candidate);
+	ctx.down([
+		["DATA", { kind: "result", result: candidate } satisfies EffectRunCompletionFact],
+		[
+			"DATA",
+			{
+				kind: "status",
+				status: {
+					effectRunId: candidate.effectRunId,
+					state: candidate.status,
+					requiredPending: [],
+					requiredTerminal: requiredTerminalRequests(candidate.effectRunId, state),
+					sourceRefs: candidate.sourceRefs,
+				},
+			} satisfies EffectRunCompletionFact,
+		],
+		[
+			"DATA",
+			{
+				kind: "audit",
+				audit: {
+					id: `${candidate.effectRunId}:terminal-result`,
+					kind: "effect-run-terminal-result",
+					subjectId: candidate.effectRunId,
+					sourceRefs: candidate.sourceRefs,
+					metadata: { status: candidate.status },
+				},
+			} satisfies EffectRunCompletionFact,
+		],
+	]);
+}
+
+export function emitEffectRunStatus(
+	ctx: Ctx,
+	effectRunId: string,
+	state: EffectRunCompletionStatus["state"],
+	requiredPending: readonly string[],
+	requiredTerminal: readonly string[],
+): void {
+	ctx.down([
+		[
+			"DATA",
+			{
+				kind: "status",
+				status: { effectRunId, state, requiredPending, requiredTerminal },
+			} satisfies EffectRunCompletionFact,
+		],
+	]);
+}
+
+export function requiredPendingRequests(
+	effectRunId: string,
+	state: EffectRunCompletionState,
+): readonly string[] {
+	const pending: string[] = [];
+	for (const request of state.requests.values()) {
+		if (request.effectRunId !== effectRunId || !request.required) continue;
+		const statusFact = matchingStatusForRequest(state, request);
+		const status = statusFact?.status;
+		if (status === undefined || !isTerminalRequestStatus(status)) pending.push(request.requestId);
+	}
+	return pending;
+}
+
+export function requiredTerminalRequests(
+	effectRunId: string,
+	state: EffectRunCompletionState,
+): readonly string[] {
+	const terminal: string[] = [];
+	for (const request of state.requests.values()) {
+		if (request.effectRunId !== effectRunId || !request.required) continue;
+		const statusFact = matchingStatusForRequest(state, request);
+		const status = statusFact?.status;
+		if (status !== undefined && isTerminalRequestStatus(status)) terminal.push(request.requestId);
+	}
+	return terminal;
+}
+
+export function isTerminalRequestStatus(status: AgentRequestStatus): boolean {
+	return (
+		status === "completed" ||
+		status === "failed" ||
+		status === "blocked" ||
+		status === "canceled" ||
+		status === "timeout" ||
+		status === "waived" ||
+		status === "retry-exhausted"
+	);
+}
+
+export function decisionSourceRequestTerminal(
+	decision: AgentDecision,
+	state: EffectRunCompletionState,
+): boolean {
+	const request = state.requests.get(decision.source.requestId);
+	if (request === undefined) return false;
+	if (
+		request.effectRunId !== decision.effectRunId ||
+		request.operationId !== decision.source.operationId
+	) {
+		return false;
+	}
+	const status = matchingStatusForRequest(state, request)?.status;
+	return status !== undefined && isTerminalRequestStatus(status);
+}
+
+export function acceptRequestStatus(
+	ctx: Ctx,
+	state: EffectRunCompletionState,
+	status: AgentRequestStatusChanged,
+): void {
+	const request = state.requests.get(status.requestId);
+	if (request !== undefined && !statusMatchesRequest(status, request)) {
+		emitEffectRunIssue(
+			ctx,
+			state,
+			"stale-request-status",
+			`AgentRequest status for '${status.requestId}' did not match its issued effectRun/operation identity`,
+			request.effectRunId,
+			[ref("agent-request", status.requestId)],
+		);
+		return;
+	}
+	state.statusByRequest.set(status.requestId, status);
+}
+
+export function matchingStatusForRequest(
+	state: EffectRunCompletionState,
+	request: AgentRequestIssued,
+): AgentRequestStatusChanged | undefined {
+	const status = state.statusByRequest.get(request.requestId);
+	if (status === undefined) return undefined;
+	return statusMatchesRequest(status, request) ? status : undefined;
+}
+
+export function statusMatchesRequest(
+	status: AgentRequestStatusChanged,
+	request: AgentRequestIssued,
+): boolean {
+	return (
+		status.effectRunId === request.effectRunId &&
+		(status.operationId === undefined || status.operationId === request.operationId)
+	);
+}
+
+export function emitEffectRunIssue(
+	ctx: Ctx,
+	state: EffectRunCompletionState,
+	code: string,
+	message: string,
+	subjectId?: string,
+	sourceRefs?: readonly SourceRef[],
+): void {
+	state.issueSeq += 1;
+	const issue = dataIssue(code, message, { subjectId, refs: sourceRefs });
+	ctx.down([
+		["DATA", { kind: "issue", issue } satisfies EffectRunCompletionFact],
+		[
+			"DATA",
+			{
+				kind: "audit",
+				audit: {
+					id: `${subjectId ?? "effect-run"}:${code}:${state.issueSeq}`,
+					kind: "effect-run-issue",
+					subjectId,
+					issueCode: code,
+					message,
+					sourceRefs,
+				},
+			} satisfies EffectRunCompletionFact,
+		],
+	]);
+}
+
+export function sameTerminalResult(a: EffectRunResult, b: EffectRunResult): boolean {
+	return (
+		a.status === b.status && a.resultId === b.resultId && JSON.stringify(a) === JSON.stringify(b)
+	);
+}
+
+export function emptyEffectRunCompletionState(): EffectRunCompletionState {
+	return {
+		runs: new Map<string, EffectRun>(),
+		requests: new Map<string, AgentRequestIssued>(),
+		statusByRequest: new Map<string, AgentRequestStatusChanged>(),
+		decisions: new Map<string, AgentDecision>(),
+		resultsByEffectRun: new Map<string, EffectRunResult>(),
+		issueSeq: 0,
+	};
+}
diff --git a/packages/ts/src/orchestration/agent-runtime-executor-outcome.ts b/packages/ts/src/orchestration/agent-runtime-executor-outcome.ts
new file mode 100644
index 00000000..590d2a2c
--- /dev/null
+++ b/packages/ts/src/orchestration/agent-runtime-executor-outcome.ts
@@ -0,0 +1,289 @@
+import type { DataIssue } from "../data/index.js";
+import {
+	boundedPublicText,
+	dataIssue,
+	publicMaterialForbiddenKeys,
+	ref,
+	sanitizeAdapterInputIssue,
+	sanitizeAdapterInputSourceRefs,
+	sanitizeAgentNeed,
+	sanitizeAgentOutputEnvelope,
+	sanitizeGraphVisibleRecord,
+	sanitizeRuntimeMetadata,
+} from "./agent-runtime-common.js";
+import type { AgentRequestStatus, ExecutorOutcome, SourceRef } from "./agent-runtime-types-core.js";
+import type {
+	ToolProviderAdapterInput,
+	ToolProviderAdapterRunResult,
+	ToolProviderPublicTextPolicy,
+} from "./agent-runtime-types-tool.js";
+
+export function adapterRuntimeIdentity(input: ToolProviderAdapterInput): {
+	readonly routeId: string;
+	readonly executorId: string;
+	readonly profileId: string;
+} {
+	if (input.status !== "ready") {
+		throw new RangeError("buildToolProviderExecutorOutcome: adapter input must be ready");
+	}
+	if (
+		input.routeId === undefined ||
+		input.executorId === undefined ||
+		input.profileId === undefined
+	) {
+		throw new RangeError(
+			"buildToolProviderExecutorOutcome: ready adapter input is missing route/executor/profile identity",
+		);
+	}
+	return {
+		routeId: input.routeId,
+		executorId: input.executorId,
+		profileId: input.profileId,
+	};
+}
+
+export function defaultToolProviderAdapterEvidenceRefs(
+	input: ToolProviderAdapterInput,
+): readonly SourceRef[] {
+	return sanitizeAdapterInputSourceRefs([
+		ref("tool-provider-adapter-input", input.adapterInputId),
+		...(input.sourceRefs ?? []),
+	]);
+}
+
+export function buildToolProviderExecutorOutcome<T = unknown>(
+	input: ToolProviderAdapterInput,
+	result: ToolProviderAdapterRunResult<T>,
+	opts: {
+		readonly attempt?: number;
+		readonly outcomeId?: string;
+		readonly occurredAtMs?: number;
+		readonly runId?: string;
+		readonly publicText?: ToolProviderPublicTextPolicy;
+	} = {},
+): ExecutorOutcome<T> {
+	const ids = adapterRuntimeIdentity(input);
+	const attempt = opts.attempt ?? 1;
+	const occurredAtMs = result.occurredAtMs ?? opts.occurredAtMs;
+	const evidenceRefs =
+		result.evidenceRefs === undefined
+			? defaultToolProviderAdapterEvidenceRefs(input)
+			: sanitizeAdapterInputSourceRefs(result.evidenceRefs);
+	const issues =
+		result.issues === undefined
+			? undefined
+			: Object.freeze(
+					result.issues.map((issue) => sanitizeAdapterInputIssue(issue, opts.publicText)),
+				);
+	const textIssues: DataIssue[] = [];
+	const metadata = sanitizeRuntimeMetadata(
+		{
+			...(result.metadata ?? {}),
+			adapterInputId: input.adapterInputId,
+			...(opts.runId === undefined ? {} : { runId: opts.runId }),
+			providerId: input.providerId,
+			toolName: input.toolName,
+			operation: input.operation,
+		},
+		input,
+		opts.publicText,
+		textIssues,
+	);
+	if (metadata === undefined && result.metadata !== undefined) {
+		textIssues.push(
+			dataIssue(
+				"tool-provider-adapter-runtime-metadata-redacted",
+				"Tool provider adapter runtime metadata was omitted because it contained runtime-private material.",
+				{
+					subjectId: input.requestId,
+					refs: [ref("tool-provider-adapter-input", input.adapterInputId)],
+					severity: "warning",
+				},
+			),
+		);
+	}
+	const base = {
+		outcomeId:
+			opts.outcomeId ??
+			`${input.adapterInputId}:${toolProviderOutcomeRunSegment(opts.runId, attempt)}:${
+				result.kind
+			}`,
+		requestId: input.requestId,
+		operationId: input.operationId,
+		routeId: ids.routeId,
+		executorId: ids.executorId,
+		profileId: ids.profileId,
+		attempt,
+		evidenceRefs,
+		...(input.input?.inputId === undefined ? {} : { inputId: input.input.inputId }),
+		...(input.input?.inputKind === undefined ? {} : { inputKind: input.input.inputKind }),
+		...(occurredAtMs === undefined ? {} : { occurredAtMs }),
+		...(issues === undefined ? {} : { issues }),
+		...(result.usage === undefined ? {} : { usage: result.usage }),
+		...(metadata === undefined ? {} : { metadata }),
+	};
+	const candidate = (() => {
+		switch (result.kind) {
+			case "result":
+				return {
+					...base,
+					kind: "result",
+					result: sanitizeAgentOutputEnvelope(result.result, input, opts.publicText, textIssues),
+				} satisfies ExecutorOutcome<T>;
+			case "failure":
+				return {
+					...base,
+					kind: "failure",
+					error: sanitizeAdapterInputIssue(result.error, opts.publicText),
+					...(result.retryable === undefined ? {} : { retryable: result.retryable }),
+				} satisfies ExecutorOutcome<T>;
+			case "canceled":
+				return {
+					...base,
+					kind: "canceled",
+					...(result.reason === undefined
+						? {}
+						: {
+								reason: boundedPublicText(
+									result.reason,
+									"reason",
+									input,
+									opts.publicText,
+									textIssues,
+								),
+							}),
+				} satisfies ExecutorOutcome<T>;
+			case "timeout":
+				return {
+					...base,
+					kind: "timeout",
+					...(result.timeoutMs === undefined ? {} : { timeoutMs: result.timeoutMs }),
+					...(result.retryable === undefined ? {} : { retryable: result.retryable }),
+				} satisfies ExecutorOutcome<T>;
+			case "blocked":
+				return {
+					...base,
+					kind: "blocked",
+					needs: Object.freeze(
+						result.needs.map((need) => sanitizeAgentNeed(need, input, opts.publicText, textIssues)),
+					),
+				} satisfies ExecutorOutcome<T>;
+		}
+	})();
+	const boundedCandidate =
+		textIssues.length === 0
+			? candidate
+			: ({
+					...candidate,
+					issues: Object.freeze([...(candidate.issues ?? []), ...textIssues]),
+				} satisfies ExecutorOutcome<T>);
+	const materialIssues = (boundedCandidate.issues ?? []).filter(
+		(issue) => issue.code === "tool-provider-adapter-runtime-forbidden-runtime-material",
+	);
+	const leakIssues = forbiddenAdapterRuntimeMaterialIssues(
+		boundedCandidate,
+		ref("executor-outcome", boundedCandidate.outcomeId),
+		"executor-outcome",
+	);
+	if (leakIssues.length === 0 && materialIssues.length === 0)
+		return Object.freeze(boundedCandidate);
+	const allLeakIssues = Object.freeze([...materialIssues, ...leakIssues]);
+	const issue = allLeakIssues[0] ?? dataIssue("tool-provider-adapter-runtime-invalid", "invalid");
+	const failureMetadata = sanitizeGraphVisibleRecord({
+		adapterInputId: input.adapterInputId,
+		...(opts.runId === undefined ? {} : { runId: opts.runId }),
+		providerId: input.providerId,
+		toolName: input.toolName,
+		operation: input.operation,
+	});
+	return Object.freeze({
+		kind: "failure",
+		outcomeId: `${input.adapterInputId}:${toolProviderOutcomeRunSegment(
+			opts.runId,
+			attempt,
+		)}:failure`,
+		requestId: input.requestId,
+		operationId: input.operationId,
+		routeId: ids.routeId,
+		executorId: ids.executorId,
+		profileId: ids.profileId,
+		attempt,
+		evidenceRefs,
+		...(input.input?.inputId === undefined ? {} : { inputId: input.input.inputId }),
+		...(input.input?.inputKind === undefined ? {} : { inputKind: input.input.inputKind }),
+		...(occurredAtMs === undefined ? {} : { occurredAtMs }),
+		...(failureMetadata === undefined ? {} : { metadata: failureMetadata }),
+		error: issue,
+		retryable: false,
+		issues: allLeakIssues,
+	} as ExecutorOutcome<T>);
+}
+
+export function agentRequestStatusForExecutorOutcome(outcome: ExecutorOutcome): AgentRequestStatus {
+	switch (outcome.kind) {
+		case "result":
+			return "completed";
+		case "failure":
+			return "failed";
+		case "canceled":
+			return "canceled";
+		case "timeout":
+			return "timeout";
+		case "blocked":
+			return "blocked";
+	}
+}
+
+export function toolProviderOutcomeRunSegment(runId: string | undefined, attempt: number): string {
+	return runId === undefined ? `attempt-${attempt}` : `${runId}:attempt-${attempt}`;
+}
+
+export function adapterRuntimeIssue(
+	input: ToolProviderAdapterInput,
+	code: string,
+	error: unknown,
+): DataIssue {
+	return dataIssue(code, "Tool provider adapter runtime failed.", {
+		subjectId: input.requestId,
+		refs: [ref("tool-provider-adapter-input", input.adapterInputId)],
+		details: { errorType: error instanceof Error ? error.name : typeof error },
+	});
+}
+
+export function forbiddenAdapterRuntimeMaterialIssues(
+	value: unknown,
+	subjectRef: SourceRef,
+	area: string,
+): readonly DataIssue[] {
+	if (value === undefined) return [];
+	const forbidden = publicMaterialForbiddenKeys(value, "provider");
+	if (forbidden.length === 0) return [];
+	return Object.freeze(
+		forbidden.map((entry) =>
+			dataIssue(
+				"tool-provider-adapter-runtime-forbidden-runtime-material",
+				"Tool provider adapter runtime output must not contain runtime-private adapter material.",
+				{ subjectId: subjectRef.id, refs: [subjectRef], details: { area, reason: entry.reason } },
+			),
+		),
+	);
+}
+
+export function readThenable<T>(value: T | PromiseLike<T>): {
+	readonly subscribe?: PromiseLike<T>["then"];
+	readonly error?: unknown;
+} {
+	if ((typeof value !== "object" && typeof value !== "function") || value === null) return {};
+	try {
+		const then = (value as { then?: unknown }).then;
+		if (typeof then !== "function") return {};
+		return { subscribe: then.bind(value) as PromiseLike<T>["then"] };
+	} catch (error) {
+		return { error };
+	}
+}
+
+export function outcomeIssues(outcome: ExecutorOutcome): readonly DataIssue[] {
+	if (outcome.kind === "failure") return Object.freeze([outcome.error, ...(outcome.issues ?? [])]);
+	return outcome.issues ?? [];
+}
diff --git a/packages/ts/src/orchestration/agent-runtime-fakes.ts b/packages/ts/src/orchestration/agent-runtime-fakes.ts
new file mode 100644
index 00000000..b32dd987
--- /dev/null
+++ b/packages/ts/src/orchestration/agent-runtime-fakes.ts
@@ -0,0 +1,43 @@
+import type { DataIssue } from "../data/index.js";
+import type { AgentNeed } from "./agent-runtime-types-agent.js";
+import type {
+	AgentOutputEnvelope,
+	ExecutorOutcome,
+	ExecutorOutcomeBase,
+} from "./agent-runtime-types-core.js";
+
+export function fakeExecutorResult<T>(
+	opts: Omit<ExecutorOutcomeBase, "kind"> & { readonly result: AgentOutputEnvelope<T> },
+): ExecutorOutcome<T> {
+	return { kind: "result", ...opts };
+}
+
+export function fakeExecutorFailure(
+	opts: Omit<ExecutorOutcomeBase, "kind"> & {
+		readonly error: DataIssue;
+		readonly retryable?: boolean;
+	},
+): ExecutorOutcome {
+	return { kind: "failure", ...opts };
+}
+
+export function fakeExecutorBlocked(
+	opts: Omit<ExecutorOutcomeBase, "kind"> & { readonly needs: readonly AgentNeed[] },
+): ExecutorOutcome {
+	return { kind: "blocked", ...opts };
+}
+
+export function fakeExecutorTimeout(
+	opts: Omit<ExecutorOutcomeBase, "kind"> & {
+		readonly timeoutMs?: number;
+		readonly retryable?: boolean;
+	},
+): ExecutorOutcome {
+	return { kind: "timeout", ...opts };
+}
+
+export function fakeExecutorCanceled(
+	opts: Omit<ExecutorOutcomeBase, "kind"> & { readonly reason?: string },
+): ExecutorOutcome {
+	return { kind: "canceled", ...opts };
+}
diff --git a/packages/ts/src/orchestration/agent-runtime-outcome-view.ts b/packages/ts/src/orchestration/agent-runtime-outcome-view.ts
new file mode 100644
index 00000000..b1db43ce
--- /dev/null
+++ b/packages/ts/src/orchestration/agent-runtime-outcome-view.ts
@@ -0,0 +1,245 @@
+import { depBatch } from "../ctx/types.js";
+import type { DataIssue } from "../data/index.js";
+import type { Graph } from "../graph/graph.js";
+import type { Node } from "../node/node.js";
+import {
+	dataIssue,
+	projectRuntimeFact,
+	ref,
+	sanitizeProviderGraphVisibleRecord,
+	uniqueSourceRefs,
+} from "./agent-runtime-common.js";
+import { outcomeIssues } from "./agent-runtime-executor-outcome.js";
+import type { AgentRuntimeAuditRecord } from "./agent-runtime-types-agent.js";
+import type { ExecutorOutcome, SourceRef } from "./agent-runtime-types-core.js";
+import type {
+	ExecutorOutcomeView,
+	ExecutorOutcomeViewBundle,
+	ExecutorOutcomeViewPolicy,
+} from "./agent-runtime-types-tool.js";
+
+export function executorOutcomeViewProjector(
+	graph: Graph,
+	opts: {
+		readonly name?: string;
+		readonly outcomes: Node<ExecutorOutcome>;
+		readonly policy?: ExecutorOutcomeViewPolicy;
+	},
+): ExecutorOutcomeViewBundle {
+	const name = opts.name ?? "executorOutcomeViews";
+	const policy = {
+		audience: opts.policy?.audience ?? "agent-observation",
+		maxSummaryChars: opts.policy?.maxSummaryChars ?? 512,
+		includeIssues: opts.policy?.includeIssues ?? true,
+		includeUsage: opts.policy?.includeUsage ?? false,
+		includeMetadata: opts.policy?.includeMetadata ?? false,
+	} satisfies Required<ExecutorOutcomeViewPolicy>;
+	const runtime = graph.node<ExecutorOutcomeViewFact>(
+		[opts.outcomes],
+		(ctx) => {
+			for (const raw of depBatch(ctx, 0) ?? []) {
+				const outcome = raw as ExecutorOutcome;
+				const projection = executorOutcomeViewProjectionFromOutcome(outcome, policy);
+				ctx.down([
+					["DATA", { kind: "view", view: projection.view } satisfies ExecutorOutcomeViewFact],
+					[
+						"DATA",
+						{
+							kind: "audit",
+							audit: {
+								id: `${outcome.outcomeId}:outcome-view:${policy.audience}`,
+								kind: "executor-outcome-view-projected",
+								subjectId: outcome.requestId,
+								sourceRefs: [ref("executor-outcome", outcome.outcomeId)],
+								metadata: { audience: policy.audience, status: outcome.kind },
+							},
+						} satisfies ExecutorOutcomeViewFact,
+					],
+				]);
+				for (const issue of projection.issues) {
+					ctx.down([["DATA", { kind: "issue", issue } satisfies ExecutorOutcomeViewFact]]);
+				}
+			}
+		},
+		{ name: `${name}/runtime`, factory: "executorOutcomeViewProjector" },
+	);
+	return {
+		views: projectRuntimeFact(graph, runtime, `${name}/views`, "executorOutcomeViews", (fact) =>
+			fact.kind === "view" ? fact.view : undefined,
+		),
+		issues: projectRuntimeFact(
+			graph,
+			runtime,
+			`${name}/issues`,
+			"executorOutcomeViewIssues",
+			(fact) => (fact.kind === "issue" ? fact.issue : undefined),
+		),
+		audit: projectRuntimeFact(
+			graph,
+			runtime,
+			`${name}/audit`,
+			"executorOutcomeViewAudit",
+			(fact) => (fact.kind === "audit" ? fact.audit : undefined),
+		),
+	};
+}
+
+export type ExecutorOutcomeViewFact =
+	| { readonly kind: "view"; readonly view: ExecutorOutcomeView }
+	| { readonly kind: "issue"; readonly issue: DataIssue }
+	| { readonly kind: "audit"; readonly audit: AgentRuntimeAuditRecord };
+
+export interface ExecutorOutcomeViewProjection {
+	readonly view: ExecutorOutcomeView;
+	readonly issues: readonly DataIssue[];
+}
+
+export interface ExecutorOutcomeSummaryProjection {
+	readonly summary: string;
+	readonly truncated: boolean;
+	readonly originalChars: number;
+	readonly limitChars: number;
+}
+
+export function executorOutcomeViewProjectionFromOutcome(
+	outcome: ExecutorOutcome,
+	policy: Required<ExecutorOutcomeViewPolicy>,
+): ExecutorOutcomeViewProjection {
+	const sourceRefs = uniqueSourceRefs([
+		ref("executor-outcome", outcome.outcomeId),
+		...(outcome.evidenceRefs ?? []),
+	]);
+	const summary = projectOutcomeSummary(outcome, policy.maxSummaryChars);
+	const issues = Object.freeze([
+		...outcomeIssues(outcome),
+		...(summary.truncated ? [outcomeSummaryTruncationIssue(outcome, summary, policy)] : []),
+	]);
+	const metadata = policy.includeMetadata
+		? sanitizeProviderGraphVisibleRecord(outcome.metadata)
+		: undefined;
+	const view = Object.freeze({
+		kind: "executor-outcome-view",
+		viewId: `${outcome.outcomeId}:${policy.audience}`,
+		audience: policy.audience,
+		outcomeId: outcome.outcomeId,
+		requestId: outcome.requestId,
+		operationId: outcome.operationId,
+		routeId: outcome.routeId,
+		executorId: outcome.executorId,
+		profileId: outcome.profileId,
+		status: outcome.kind,
+		summary: summary.summary,
+		summaryTruncated: summary.truncated,
+		summaryChars: summary.originalChars,
+		summaryLimitChars: summary.limitChars,
+		errorKind: outcomeErrorKind(outcome),
+		retryable: outcomeRetryable(outcome),
+		nextActions: outcomeNextActions(outcome),
+		sourceRefs,
+		materialRefs: outcomeMaterialRefs(outcome),
+		issues: policy.includeIssues && issues.length > 0 ? issues : undefined,
+		usage: policy.includeUsage ? outcome.usage : undefined,
+		...(metadata === undefined ? {} : { metadata }),
+	} satisfies ExecutorOutcomeView);
+	return Object.freeze({ view, issues });
+}
+
+export function projectOutcomeSummary(
+	outcome: ExecutorOutcome,
+	maxChars: number,
+): ExecutorOutcomeSummaryProjection {
+	const summary = outcomeSummary(outcome);
+	const limitChars = Math.max(0, maxChars);
+	if (summary.length <= limitChars) {
+		return Object.freeze({
+			summary,
+			truncated: false,
+			originalChars: summary.length,
+			limitChars,
+		});
+	}
+	const bounded =
+		limitChars <= 1
+			? summary.slice(0, limitChars)
+			: limitChars <= 3
+				? summary.slice(0, limitChars)
+				: `${summary.slice(0, limitChars - 3)}...`;
+	return Object.freeze({
+		summary: bounded,
+		truncated: true,
+		originalChars: summary.length,
+		limitChars,
+	});
+}
+
+export function outcomeSummaryTruncationIssue(
+	outcome: ExecutorOutcome,
+	summary: ExecutorOutcomeSummaryProjection,
+	policy: Required<ExecutorOutcomeViewPolicy>,
+): DataIssue {
+	return dataIssue(
+		"executor-outcome-view-summary-truncated",
+		"ExecutorOutcome view summary was truncated; inspect material refs or the source outcome for full detail",
+		{
+			subjectId: outcome.requestId,
+			refs: [ref("executor-outcome", outcome.outcomeId)],
+			severity: "warning",
+			details: {
+				audience: policy.audience,
+				outcomeId: outcome.outcomeId,
+				originalChars: summary.originalChars,
+				limitChars: summary.limitChars,
+			},
+		},
+	);
+}
+
+export function outcomeSummary(outcome: ExecutorOutcome): string {
+	if (outcome.kind === "result") {
+		if (outcome.result.summary !== undefined && outcome.result.summary.length > 0)
+			return outcome.result.summary;
+		return `Executor result '${outcome.result.kind}' is available via source refs`;
+	}
+	if (outcome.kind === "failure") return outcome.error.message;
+	if (outcome.kind === "blocked") {
+		const needKinds = outcome.needs.map((need) => need.kind).join(", ");
+		return needKinds.length > 0 ? `Executor blocked: ${needKinds}` : "Executor blocked";
+	}
+	if (outcome.kind === "timeout") {
+		return outcome.timeoutMs === undefined
+			? "Executor timed out"
+			: `Executor timed out after ${outcome.timeoutMs}ms`;
+	}
+	return outcome.reason ?? "Executor canceled";
+}
+
+export function outcomeErrorKind(outcome: ExecutorOutcome): string | undefined {
+	if (outcome.kind === "failure") return outcome.error.code;
+	if (outcome.kind === "timeout") return "timeout";
+	if (outcome.kind === "blocked") return outcome.needs[0]?.kind ?? "blocked";
+	if (outcome.kind === "canceled") return "canceled";
+	return undefined;
+}
+
+export function outcomeRetryable(outcome: ExecutorOutcome): boolean | undefined {
+	if (outcome.kind === "failure" || outcome.kind === "timeout") return outcome.retryable;
+	return undefined;
+}
+
+export function outcomeNextActions(outcome: ExecutorOutcome): readonly string[] | undefined {
+	if (outcome.kind === "blocked") return Object.freeze(outcome.needs.map((need) => need.kind));
+	if ((outcome.kind === "failure" || outcome.kind === "timeout") && outcome.retryable === true) {
+		return Object.freeze(["retry-or-route"]);
+	}
+	return undefined;
+}
+
+export function outcomeMaterialRefs(outcome: ExecutorOutcome): readonly SourceRef[] | undefined {
+	const refs =
+		outcome.kind === "result"
+			? [...(outcome.result.refs ?? [])]
+			: outcome.kind === "blocked"
+				? outcome.needs.flatMap((need) => [...(need.refs ?? [])])
+				: [];
+	return refs.length === 0 ? undefined : uniqueSourceRefs(refs);
+}
diff --git a/packages/ts/src/orchestration/agent-runtime-request-ledger.ts b/packages/ts/src/orchestration/agent-runtime-request-ledger.ts
new file mode 100644
index 00000000..cc63123e
--- /dev/null
+++ b/packages/ts/src/orchestration/agent-runtime-request-ledger.ts
@@ -0,0 +1,322 @@
+import { depBatch } from "../ctx/types.js";
+import type { DataIssue } from "../data/index.js";
+import type { Graph } from "../graph/graph.js";
+import type { Node } from "../node/node.js";
+import {
+	boundPublicText,
+	cloneGraphVisibleMaterial,
+	maxPublicReasonChars,
+	publicMaterialForbiddenKeys,
+	ref,
+	sanitizeAdapterInputIssue,
+	sanitizeAdapterInputSourceRefs,
+	sanitizeProviderGraphVisibleRecord,
+} from "./agent-runtime-common.js";
+import { isTerminalRequestStatus } from "./agent-runtime-effect-completion.js";
+import type {
+	AgentDecisionContinue,
+	AgentRuntimeAuditRecord,
+} from "./agent-runtime-types-agent.js";
+import type {
+	AgentRequestAdmitted,
+	AgentRequestFact,
+	AgentRequestInput,
+	AgentRequestIssued,
+	AgentRequestLedgerBundle,
+	AgentRequestProposal,
+	AgentRequestStatusChanged,
+	AgentRequestViews,
+	SourceRef,
+} from "./agent-runtime-types-core.js";
+
+export function agentRequestProposalFromDecision(
+	decision: AgentDecisionContinue,
+	proposal: Omit<AgentRequestProposal, "kind" | "effectRunId" | "agentRunId" | "sourceDecisionId">,
+): AgentRequestProposal {
+	return {
+		kind: "proposal",
+		...proposal,
+		effectRunId: decision.effectRunId,
+		agentRunId: decision.agentRunId,
+		sourceDecisionId: decision.decisionId,
+		evidenceRefs: proposal.evidenceRefs ?? decision.evidenceRefs,
+	};
+}
+
+export function admitAgentRequestProposal(
+	proposal: AgentRequestProposal,
+	opts: {
+		readonly requestId: string;
+		readonly operationId: string;
+		readonly admittedAtMs?: number;
+		readonly reason?: string;
+		readonly sourceRefs?: readonly SourceRef[];
+		readonly metadata?: Record<string, unknown>;
+	},
+): AgentRequestAdmitted {
+	const sourceRefs =
+		opts.sourceRefs === undefined ? undefined : sanitizeAdapterInputSourceRefs(opts.sourceRefs);
+	const metadata = sanitizeProviderGraphVisibleRecord(opts.metadata);
+	return {
+		kind: "admitted",
+		proposalId: proposal.proposalId,
+		requestId: opts.requestId,
+		operationId: opts.operationId,
+		effectRunId: proposal.effectRunId,
+		agentRunId: proposal.agentRunId,
+		admittedAtMs: opts.admittedAtMs,
+		...(opts.reason === undefined
+			? {}
+			: { reason: boundPublicText(opts.reason, maxPublicReasonChars()).text }),
+		...(sourceRefs === undefined || sourceRefs.length === 0 ? {} : { sourceRefs }),
+		...(metadata === undefined ? {} : { metadata }),
+	};
+}
+
+export function issueAgentRequest(
+	proposal: AgentRequestProposal,
+	admission: AgentRequestAdmitted,
+	opts: { readonly issuedAtMs?: number; readonly sourceRefs?: readonly SourceRef[] } = {},
+): AgentRequestIssued {
+	const input = sanitizeAgentRequestInput(proposal.input);
+	const payload = sanitizeAgentRequestMaterial(proposal.payload);
+	const sourceRefs = sanitizeAdapterInputSourceRefs(opts.sourceRefs ?? admission.sourceRefs ?? []);
+	const metadata = sanitizeProviderGraphVisibleRecord(proposal.metadata);
+	return {
+		kind: "issued",
+		requestId: admission.requestId,
+		operationId: admission.operationId,
+		effectRunId: admission.effectRunId,
+		agentRunId: admission.agentRunId,
+		proposalId: proposal.proposalId,
+		parentRequestId: proposal.parentRequestId,
+		requestKind: proposal.requestKind,
+		required: proposal.required ?? true,
+		...(input === undefined ? {} : { input }),
+		...(payload === undefined ? {} : { payload }),
+		issuedAtMs: opts.issuedAtMs,
+		...(sourceRefs.length === 0 ? {} : { sourceRefs }),
+		...(metadata === undefined ? {} : { metadata }),
+	};
+}
+
+export function sanitizeAgentRequestInput<T>(
+	input: AgentRequestInput<T> | undefined,
+): AgentRequestInput<T> | undefined {
+	if (input === undefined) return undefined;
+	const {
+		value: rawValue,
+		subjectRefs: rawSubjectRefs,
+		metadata: rawMetadata,
+		...inputFields
+	} = input;
+	const value = sanitizeAgentRequestMaterial(rawValue);
+	const subjectRefs =
+		rawSubjectRefs === undefined ? undefined : sanitizeAdapterInputSourceRefs(rawSubjectRefs);
+	const metadata = sanitizeProviderGraphVisibleRecord(rawMetadata);
+	return Object.freeze({
+		...inputFields,
+		...(value === undefined ? {} : { value }),
+		...(subjectRefs === undefined || subjectRefs.length === 0 ? {} : { subjectRefs }),
+		...(metadata === undefined ? {} : { metadata }),
+	} satisfies AgentRequestInput<T>) as AgentRequestInput<T>;
+}
+
+export function sanitizeAgentRequestMaterial<T>(value: T | undefined): T | undefined {
+	if (value === undefined) return undefined;
+	if (publicMaterialForbiddenKeys(value, "provider").length > 0) return undefined;
+	return cloneGraphVisibleMaterial(value) as T;
+}
+
+export function sanitizeAgentRequestIssued(request: AgentRequestIssued): AgentRequestIssued {
+	const input = sanitizeAgentRequestInput(request.input);
+	const payload = sanitizeAgentRequestMaterial(request.payload);
+	const sourceRefs =
+		request.sourceRefs === undefined
+			? undefined
+			: sanitizeAdapterInputSourceRefs(request.sourceRefs);
+	const metadata = sanitizeProviderGraphVisibleRecord(request.metadata);
+	return Object.freeze({
+		kind: "issued",
+		requestId: request.requestId,
+		operationId: request.operationId,
+		effectRunId: request.effectRunId,
+		...(request.agentRunId === undefined ? {} : { agentRunId: request.agentRunId }),
+		...(request.proposalId === undefined ? {} : { proposalId: request.proposalId }),
+		...(request.parentRequestId === undefined ? {} : { parentRequestId: request.parentRequestId }),
+		requestKind: request.requestKind,
+		required: request.required,
+		...(input === undefined ? {} : { input }),
+		...(payload === undefined ? {} : { payload }),
+		...(request.issuedAtMs === undefined ? {} : { issuedAtMs: request.issuedAtMs }),
+		...(sourceRefs === undefined || sourceRefs.length === 0 ? {} : { sourceRefs }),
+		...(metadata === undefined ? {} : { metadata }),
+	} satisfies AgentRequestIssued);
+}
+
+export function agentRequestLedgerViews(
+	graph: Graph,
+	facts: Node<AgentRequestFact>,
+	opts: { readonly name?: string } = {},
+): AgentRequestLedgerBundle {
+	const name = opts.name ?? "agentRequests";
+	const views = graph.node<AgentRequestViews>(
+		[facts],
+		(ctx) => {
+			const prev = ctx.state.get<AgentRequestViewsState>() ?? emptyAgentRequestViewsState();
+			const next = cloneAgentRequestViewsState(prev);
+			for (const raw of depBatch(ctx, 0) ?? []) {
+				const fact = raw as AgentRequestFact;
+				reduceAgentRequestViews(next, fact);
+			}
+			ctx.state.set(next);
+			ctx.down([["DATA", freezeAgentRequestViews(next)]]);
+		},
+		{ name: `${name}/views`, factory: "agentRequestLedgerViews" },
+	);
+	const issues = graph.node<DataIssue>(
+		[facts],
+		(ctx) => {
+			for (const raw of depBatch(ctx, 0) ?? []) {
+				const fact = raw as AgentRequestFact;
+				if (fact.kind === "rejected") ctx.down([["DATA", sanitizeAdapterInputIssue(fact.issue)]]);
+				if (fact.kind === "status") {
+					for (const issue of fact.issues ?? []) {
+						ctx.down([["DATA", sanitizeAdapterInputIssue(issue)]]);
+					}
+				}
+			}
+		},
+		{ name: `${name}/issues`, factory: "agentRequestLedgerIssues" },
+	);
+	const audit = graph.node<AgentRuntimeAuditRecord>(
+		[facts],
+		(ctx) => {
+			let seq = ctx.state.get<number>() ?? 0;
+			for (const raw of depBatch(ctx, 0) ?? []) {
+				seq += 1;
+				const fact = raw as AgentRequestFact;
+				ctx.down([
+					[
+						"DATA",
+						{
+							id: `${name}:ledger:${seq}`,
+							kind: `agent-request-${fact.kind}`,
+							subjectId: "requestId" in fact ? fact.requestId : fact.proposalId,
+						} satisfies AgentRuntimeAuditRecord,
+					],
+				]);
+			}
+			ctx.state.set(seq);
+		},
+		{ name: `${name}/audit`, factory: "agentRequestLedgerAudit" },
+	);
+	return { views, issues, audit };
+}
+
+export interface AgentRequestViewsState {
+	requestsById: Map<string, AgentRequestIssued>;
+	requestsByEffectRun: Map<string, string[]>;
+	statusByRequest: Map<string, AgentRequestStatusChanged>;
+	issues: DataIssue[];
+	audit: AgentRuntimeAuditRecord[];
+	auditSeq: number;
+}
+
+export function emptyAgentRequestViewsState(): AgentRequestViewsState {
+	return {
+		requestsById: new Map<string, AgentRequestIssued>(),
+		requestsByEffectRun: new Map<string, string[]>(),
+		statusByRequest: new Map<string, AgentRequestStatusChanged>(),
+		issues: [],
+		audit: [],
+		auditSeq: 0,
+	};
+}
+
+export function cloneAgentRequestViewsState(state: AgentRequestViewsState): AgentRequestViewsState {
+	return {
+		requestsById: new Map(state.requestsById),
+		requestsByEffectRun: new Map(Array.from(state.requestsByEffectRun, ([k, v]) => [k, [...v]])),
+		statusByRequest: new Map(state.statusByRequest),
+		issues: [...state.issues],
+		audit: [...state.audit],
+		auditSeq: state.auditSeq,
+	};
+}
+
+export function reduceAgentRequestViews(
+	state: AgentRequestViewsState,
+	fact: AgentRequestFact,
+): void {
+	state.auditSeq += 1;
+	if (fact.kind === "issued") {
+		const request = sanitizeAgentRequestIssued(fact);
+		state.requestsById.set(request.requestId, request);
+		const requestIds = state.requestsByEffectRun.get(request.effectRunId) ?? [];
+		if (!requestIds.includes(request.requestId)) requestIds.push(request.requestId);
+		state.requestsByEffectRun.set(request.effectRunId, requestIds);
+		state.statusByRequest.set(request.requestId, {
+			kind: "status",
+			requestId: request.requestId,
+			operationId: request.operationId,
+			effectRunId: request.effectRunId,
+			status: "issued",
+			sourceRefs: [ref("agent-request", request.requestId)],
+		});
+	} else if (fact.kind === "status") {
+		const status = sanitizeAgentRequestStatusChanged(fact);
+		state.statusByRequest.set(status.requestId, status);
+		if (status.issues !== undefined) state.issues.push(...status.issues);
+	} else if (fact.kind === "rejected") {
+		state.issues.push(sanitizeAdapterInputIssue(fact.issue));
+	}
+	state.audit.push({
+		id: `agent-request-ledger:${state.auditSeq}`,
+		kind: `agent-request-${fact.kind}`,
+		subjectId: "requestId" in fact ? fact.requestId : fact.proposalId,
+	});
+}
+
+export function sanitizeAgentRequestStatusChanged(
+	status: AgentRequestStatusChanged,
+): AgentRequestStatusChanged {
+	const sourceRefs =
+		status.sourceRefs === undefined ? undefined : sanitizeAdapterInputSourceRefs(status.sourceRefs);
+	const issues =
+		status.issues === undefined
+			? undefined
+			: Object.freeze(status.issues.map((issue) => sanitizeAdapterInputIssue(issue)));
+	const metadata = sanitizeProviderGraphVisibleRecord(status.metadata);
+	return Object.freeze({
+		kind: "status",
+		requestId: status.requestId,
+		...(status.operationId === undefined ? {} : { operationId: status.operationId }),
+		effectRunId: status.effectRunId,
+		status: status.status,
+		...(sourceRefs === undefined || sourceRefs.length === 0 ? {} : { sourceRefs }),
+		...(issues === undefined || issues.length === 0 ? {} : { issues }),
+		...(metadata === undefined ? {} : { metadata }),
+	} satisfies AgentRequestStatusChanged);
+}
+
+export function freezeAgentRequestViews(state: AgentRequestViewsState): AgentRequestViews {
+	const pending = Array.from(state.requestsById.values()).filter((request) => {
+		const status = state.statusByRequest.get(request.requestId)?.status;
+		return status === undefined || !isTerminalRequestStatus(status);
+	});
+	const awaitingProvider = pending.filter(
+		(request) => state.statusByRequest.get(request.requestId)?.status === "awaiting-provider",
+	);
+	return {
+		requestsById: new Map(state.requestsById),
+		requestsByEffectRun: new Map(
+			Array.from(state.requestsByEffectRun, ([key, value]) => [key, Object.freeze([...value])]),
+		),
+		statusByRequest: new Map(state.statusByRequest),
+		pending: Object.freeze(pending),
+		awaitingProvider: Object.freeze(awaitingProvider),
+		issues: Object.freeze([...state.issues]),
+		audit: Object.freeze([...state.audit]),
+	};
+}
diff --git a/packages/ts/src/orchestration/agent-runtime-request-satisfaction.ts b/packages/ts/src/orchestration/agent-runtime-request-satisfaction.ts
new file mode 100644
index 00000000..af5cd926
--- /dev/null
+++ b/packages/ts/src/orchestration/agent-runtime-request-satisfaction.ts
@@ -0,0 +1,663 @@
+import { type Ctx, depBatch } from "../ctx/types.js";
+import type { DataIssue } from "../data/index.js";
+import type { Graph } from "../graph/graph.js";
+import type { Node } from "../node/node.js";
+import {
+	dataIssue,
+	forEachDepBatch,
+	ref,
+	sanitizeAdapterInputIssue,
+	sanitizeAdapterInputSourceRefs,
+} from "./agent-runtime-common.js";
+import type {
+	AgentRequestSatisfactionBundle,
+	AgentRuntimeAuditRecord,
+	ContextContribution,
+	PromptBundle,
+} from "./agent-runtime-types-agent.js";
+import type {
+	AgentRequestFact,
+	AgentRequestIssued,
+	AgentRequestStatus,
+	AgentRequestStatusChanged,
+	ExecutorOutcome,
+	ExecutorProfile,
+	ExecutorRoute,
+	SourceRef,
+} from "./agent-runtime-types-core.js";
+
+export interface RequestSatisfactionState {
+	requests: Map<string, AgentRequestIssued>;
+	profiles: Map<string, ExecutorProfile>;
+	routes: Map<string, ExecutorRoute>;
+	outcomes: Map<string, ExecutorOutcome>;
+	contexts: Map<string, ContextContribution>;
+	prompts: Map<string, PromptBundle>;
+	compatibleRoutesByRouteId: Map<string, ExecutorRoute>;
+	terminalRequests: Set<string>;
+	acceptedTerminalFactIds: Set<string>;
+	issueKeys: Set<string>;
+	statusKeys: Set<string>;
+	issueSeq: number;
+	auditSeq: number;
+}
+
+export function requestSatisfactionProjector(
+	graph: Graph,
+	opts: {
+		readonly name?: string;
+		readonly requestFacts: Node<AgentRequestFact>;
+		readonly executorProfiles?: readonly Node<ExecutorProfile>[];
+		readonly executorRoutes?: readonly Node<ExecutorRoute>[];
+		readonly executorOutcomes?: readonly Node<ExecutorOutcome>[];
+		readonly contextContributions?: readonly Node<ContextContribution>[];
+		readonly promptBundles?: readonly Node<PromptBundle>[];
+	},
+): AgentRequestSatisfactionBundle {
+	const name = opts.name ?? "requestSatisfaction";
+	const profileDeps = opts.executorProfiles ?? [];
+	const routeDeps = opts.executorRoutes ?? [];
+	const outcomeDeps = opts.executorOutcomes ?? [];
+	const contextDeps = opts.contextContributions ?? [];
+	const promptDeps = opts.promptBundles ?? [];
+	const deps = [
+		opts.requestFacts,
+		...profileDeps,
+		...routeDeps,
+		...outcomeDeps,
+		...contextDeps,
+		...promptDeps,
+	];
+	const profileStart = 1;
+	const routeStart = profileStart + profileDeps.length;
+	const outcomeStart = routeStart + routeDeps.length;
+	const contextStart = outcomeStart + outcomeDeps.length;
+	const promptStart = contextStart + contextDeps.length;
+	const runtime = graph.node<AgentRequestSatisfactionFact>(
+		deps,
+		(ctx) => {
+			const state = ctx.state.get<RequestSatisfactionState>() ?? {
+				requests: new Map<string, AgentRequestIssued>(),
+				profiles: new Map<string, ExecutorProfile>(),
+				routes: new Map<string, ExecutorRoute>(),
+				outcomes: new Map<string, ExecutorOutcome>(),
+				contexts: new Map<string, ContextContribution>(),
+				prompts: new Map<string, PromptBundle>(),
+				compatibleRoutesByRouteId: new Map<string, ExecutorRoute>(),
+				terminalRequests: new Set<string>(),
+				acceptedTerminalFactIds: new Set<string>(),
+				issueKeys: new Set<string>(),
+				statusKeys: new Set<string>(),
+				issueSeq: 0,
+				auditSeq: 0,
+			};
+			for (const fact of depBatch(ctx, 0) ?? []) {
+				if ((fact as AgentRequestFact).kind === "issued") {
+					const request = fact as AgentRequestIssued;
+					state.requests.set(request.requestId, request);
+					emitStatus(ctx, state, request, initialRequestStatus(request), [
+						ref("agent-request", request.requestId),
+					]);
+				}
+			}
+			forEachDepBatch(ctx, profileStart, profileDeps.length, (raw) => {
+				const profile = raw as ExecutorProfile;
+				state.profiles.set(profile.profileId, profile);
+			});
+			forEachDepBatch(ctx, routeStart, routeDeps.length, (raw) => {
+				const route = raw as ExecutorRoute;
+				state.routes.set(route.routeId, route);
+			});
+			forEachDepBatch(ctx, outcomeStart, outcomeDeps.length, (raw) => {
+				const outcome = raw as ExecutorOutcome;
+				state.outcomes.set(outcome.outcomeId, outcome);
+			});
+			forEachDepBatch(ctx, contextStart, contextDeps.length, (raw) => {
+				const contribution = raw as ContextContribution;
+				state.contexts.set(contribution.contributionId, contribution);
+			});
+			forEachDepBatch(ctx, promptStart, promptDeps.length, (raw) => {
+				const prompt = raw as PromptBundle;
+				state.prompts.set(prompt.promptId, prompt);
+			});
+			evaluateRequestSatisfaction(ctx, state);
+			ctx.state.set(state);
+		},
+		{ name: `${name}/runtime`, factory: "requestSatisfactionProjector" },
+	);
+	const status = graph.node<AgentRequestStatusChanged>(
+		[runtime],
+		(ctx) => {
+			for (const fact of depBatch(ctx, 0) ?? []) {
+				const typed = fact as AgentRequestSatisfactionFact;
+				if (typed.kind === "status") ctx.down([["DATA", typed.status]]);
+			}
+		},
+		{ name: `${name}/status`, factory: "requestSatisfactionStatus" },
+	);
+	const issues = graph.node<DataIssue>(
+		[runtime],
+		(ctx) => {
+			for (const fact of depBatch(ctx, 0) ?? []) {
+				const typed = fact as AgentRequestSatisfactionFact;
+				if (typed.kind === "issue") ctx.down([["DATA", typed.issue]]);
+			}
+		},
+		{ name: `${name}/issues`, factory: "requestSatisfactionIssues" },
+	);
+	const audit = graph.node<AgentRuntimeAuditRecord>(
+		[runtime],
+		(ctx) => {
+			for (const fact of depBatch(ctx, 0) ?? []) {
+				const typed = fact as AgentRequestSatisfactionFact;
+				if (typed.kind === "audit") ctx.down([["DATA", typed.audit]]);
+			}
+		},
+		{ name: `${name}/audit`, factory: "requestSatisfactionAudit" },
+	);
+	return { status, issues, audit };
+}
+
+export type AgentRequestSatisfactionFact =
+	| { readonly kind: "status"; readonly status: AgentRequestStatusChanged }
+	| { readonly kind: "issue"; readonly issue: DataIssue }
+	| { readonly kind: "audit"; readonly audit: AgentRuntimeAuditRecord };
+
+export function initialRequestStatus(request: AgentRequestIssued): AgentRequestStatus {
+	if (request.requestKind === "context") return "awaiting-context";
+	if (request.requestKind === "prompt") return "awaiting-prompt";
+	return "awaiting-route";
+}
+
+export function evaluateRequestSatisfaction(ctx: Ctx, state: RequestSatisfactionState): void {
+	for (const route of state.routes.values()) handleRoute(ctx, state, route);
+	for (const contribution of state.contexts.values())
+		handleContextContribution(ctx, state, contribution);
+	for (const prompt of state.prompts.values()) handlePromptBundle(ctx, state, prompt);
+	for (const outcome of state.outcomes.values()) handleExecutorOutcome(ctx, state, outcome);
+}
+
+export function handleRoute(ctx: Ctx, state: RequestSatisfactionState, route: ExecutorRoute): void {
+	const request = state.requests.get(route.requestId);
+	if (request === undefined) {
+		return;
+	}
+	if (state.terminalRequests.has(request.requestId)) {
+		if (state.compatibleRoutesByRouteId.get(route.routeId)?.requestId !== request.requestId) {
+			emitIssueOnce(
+				ctx,
+				state,
+				`late-route:${route.routeId}`,
+				"late-route-after-terminal",
+				`ExecutorRoute '${route.routeId}' arrived after request '${request.requestId}' was already terminal`,
+				request.requestId,
+				[ref("executor-route", route.routeId), ref("agent-request", request.requestId)],
+			);
+		}
+		return;
+	}
+	if (request.operationId !== route.operationId) {
+		emitIssueOnce(
+			ctx,
+			state,
+			`stale-route:${route.routeId}`,
+			"stale-route-operation",
+			`ExecutorRoute '${route.routeId}' operationId does not match request '${request.requestId}'`,
+			request.requestId,
+			[ref("executor-route", route.routeId), ref("agent-request", request.requestId)],
+		);
+		return;
+	}
+	const profile = state.profiles.get(route.profileId);
+	if (profile === undefined) {
+		return;
+	}
+	const compatibilityIssue = routeCompatibilityIssue(request, route, profile);
+	if (compatibilityIssue !== undefined) {
+		emitIssueOnce(
+			ctx,
+			state,
+			`route-incompatible:${route.routeId}:${compatibilityIssue}`,
+			compatibilityIssue,
+			`ExecutorRoute '${route.routeId}' is incompatible with request '${request.requestId}'`,
+			request.requestId,
+			[
+				ref("executor-route", route.routeId),
+				ref("executor-profile", profile.profileId),
+				ref("agent-request", request.requestId),
+			],
+		);
+		return;
+	}
+	state.compatibleRoutesByRouteId.set(route.routeId, route);
+	emitStatusOnce(
+		ctx,
+		state,
+		`route:${route.routeId}:awaiting-provider`,
+		request,
+		"awaiting-provider",
+		[
+			ref("executor-route", route.routeId),
+			ref("executor-profile", profile.profileId),
+			ref("agent-request", request.requestId),
+		],
+	);
+}
+
+export function handleExecutorOutcome(
+	ctx: Ctx,
+	state: RequestSatisfactionState,
+	outcome: ExecutorOutcome,
+): void {
+	const request = state.requests.get(outcome.requestId);
+	if (request === undefined) {
+		return;
+	}
+	if (request.operationId !== outcome.operationId) {
+		emitIssueOnce(
+			ctx,
+			state,
+			`stale-outcome:${outcome.outcomeId}`,
+			"stale-outcome-operation",
+			`ExecutorOutcome '${outcome.outcomeId}' operationId does not match request '${request.requestId}'`,
+			request.requestId,
+			[ref("executor-outcome", outcome.outcomeId), ref("agent-request", request.requestId)],
+		);
+		return;
+	}
+	const route = state.compatibleRoutesByRouteId.get(outcome.routeId);
+	if (route === undefined || route.requestId !== request.requestId) {
+		emitIssueOnce(
+			ctx,
+			state,
+			`missing-route:${outcome.outcomeId}`,
+			"missing-compatible-route",
+			`ExecutorOutcome '${outcome.outcomeId}' has no compatible route for request '${request.requestId}'`,
+			request.requestId,
+			[ref("executor-outcome", outcome.outcomeId), ref("agent-request", request.requestId)],
+		);
+		return;
+	}
+	const outcomeIssue = outcomeCompatibilityIssue(request, route, outcome);
+	if (outcomeIssue !== undefined) {
+		emitIssueOnce(
+			ctx,
+			state,
+			`outcome-incompatible:${outcome.outcomeId}:${outcomeIssue}`,
+			outcomeIssue,
+			`ExecutorOutcome '${outcome.outcomeId}' is incompatible with route '${route.routeId}' for request '${request.requestId}'`,
+			request.requestId,
+			[
+				ref("executor-outcome", outcome.outcomeId),
+				ref("executor-route", route.routeId),
+				ref("agent-request", request.requestId),
+			],
+		);
+		return;
+	}
+	if (state.terminalRequests.has(request.requestId)) {
+		if (state.acceptedTerminalFactIds.has(`outcome:${outcome.outcomeId}`)) return;
+		emitIssueOnce(
+			ctx,
+			state,
+			`duplicate-outcome:${outcome.outcomeId}`,
+			"duplicate-terminal-outcome",
+			`ExecutorOutcome '${outcome.outcomeId}' arrived after request '${request.requestId}' was already terminal`,
+			request.requestId,
+			[ref("executor-outcome", outcome.outcomeId), ref("agent-request", request.requestId)],
+		);
+		return;
+	}
+	state.terminalRequests.add(request.requestId);
+	state.acceptedTerminalFactIds.add(`outcome:${outcome.outcomeId}`);
+	const status = outcomeStatus(outcome);
+	emitStatus(ctx, state, request, status, [
+		ref("executor-outcome", outcome.outcomeId),
+		ref("executor-route", route.routeId),
+		ref("agent-request", request.requestId),
+	]);
+}
+
+export function handleContextContribution(
+	ctx: Ctx,
+	state: RequestSatisfactionState,
+	contribution: ContextContribution,
+): void {
+	const request = state.requests.get(contribution.requestId);
+	if (request === undefined) return;
+	if (request.operationId !== contribution.operationId) {
+		emitIssueOnce(
+			ctx,
+			state,
+			`stale-context:${contribution.contributionId}`,
+			"stale-context-operation",
+			`ContextContribution '${contribution.contributionId}' operationId does not match request '${request.requestId}'`,
+			request.requestId,
+			[ref("context-contribution", contribution.contributionId)],
+		);
+		return;
+	}
+	if (request.requestKind !== "context") {
+		emitIssueOnce(
+			ctx,
+			state,
+			`wrong-context-kind:${contribution.contributionId}`,
+			"wrong-kind-context-satisfaction",
+			`ContextContribution '${contribution.contributionId}' cannot satisfy ${request.requestKind} request '${request.requestId}'`,
+			request.requestId,
+			[ref("context-contribution", contribution.contributionId)],
+		);
+		return;
+	}
+	if (state.terminalRequests.has(request.requestId)) {
+		if (
+			state.acceptedTerminalFactIds.has(`context:${contribution.contributionId}`) ||
+			state.statusKeys.has(`context:${contribution.contributionId}:awaiting-context`)
+		) {
+			return;
+		}
+		emitIssueOnce(
+			ctx,
+			state,
+			`duplicate-context:${contribution.contributionId}`,
+			"duplicate-terminal-context",
+			`ContextContribution '${contribution.contributionId}' arrived after request '${request.requestId}' was already terminal`,
+			request.requestId,
+			[
+				ref("context-contribution", contribution.contributionId),
+				ref("agent-request", request.requestId),
+			],
+		);
+		return;
+	}
+	if (contribution.status === "pending")
+		emitStatusOnce(
+			ctx,
+			state,
+			`context:${contribution.contributionId}:awaiting-context`,
+			request,
+			"awaiting-context",
+			[ref("context-contribution", contribution.contributionId)],
+		);
+	else {
+		state.terminalRequests.add(request.requestId);
+		state.acceptedTerminalFactIds.add(`context:${contribution.contributionId}`);
+		emitStatus(
+			ctx,
+			state,
+			request,
+			contribution.status === "ready" ? "completed" : "failed",
+			[ref("context-contribution", contribution.contributionId)],
+			contribution.issues,
+		);
+	}
+}
+
+export function handlePromptBundle(
+	ctx: Ctx,
+	state: RequestSatisfactionState,
+	prompt: PromptBundle,
+): void {
+	const request = state.requests.get(prompt.requestId);
+	if (request === undefined) return;
+	if (request.operationId !== prompt.operationId) {
+		emitIssueOnce(
+			ctx,
+			state,
+			`stale-prompt:${prompt.promptId}`,
+			"stale-prompt-operation",
+			`PromptBundle '${prompt.promptId}' operationId does not match request '${request.requestId}'`,
+			request.requestId,
+			[ref("prompt-bundle", prompt.promptId)],
+		);
+		return;
+	}
+	if (request.requestKind !== "prompt") {
+		emitIssueOnce(
+			ctx,
+			state,
+			`wrong-prompt-kind:${prompt.promptId}`,
+			"wrong-kind-prompt-satisfaction",
+			`PromptBundle '${prompt.promptId}' cannot satisfy ${request.requestKind} request '${request.requestId}'`,
+			request.requestId,
+			[ref("prompt-bundle", prompt.promptId)],
+		);
+		return;
+	}
+	if (state.terminalRequests.has(request.requestId)) {
+		if (
+			state.acceptedTerminalFactIds.has(`prompt:${prompt.promptId}`) ||
+			state.statusKeys.has(`prompt:${prompt.promptId}:awaiting-prompt`)
+		) {
+			return;
+		}
+		emitIssueOnce(
+			ctx,
+			state,
+			`duplicate-prompt:${prompt.promptId}`,
+			"duplicate-terminal-prompt",
+			`PromptBundle '${prompt.promptId}' arrived after request '${request.requestId}' was already terminal`,
+			request.requestId,
+			[ref("prompt-bundle", prompt.promptId), ref("agent-request", request.requestId)],
+		);
+		return;
+	}
+	if (prompt.status === "ready") {
+		state.terminalRequests.add(request.requestId);
+		state.acceptedTerminalFactIds.add(`prompt:${prompt.promptId}`);
+		emitStatus(ctx, state, request, "completed", [ref("prompt-bundle", prompt.promptId)]);
+	} else if (prompt.status === "issue") {
+		state.terminalRequests.add(request.requestId);
+		state.acceptedTerminalFactIds.add(`prompt:${prompt.promptId}`);
+		emitStatus(
+			ctx,
+			state,
+			request,
+			"failed",
+			[ref("prompt-bundle", prompt.promptId)],
+			prompt.issues,
+		);
+	} else {
+		emitStatusOnce(
+			ctx,
+			state,
+			`prompt:${prompt.promptId}:awaiting-prompt`,
+			request,
+			"awaiting-prompt",
+			[ref("prompt-bundle", prompt.promptId)],
+			prompt.issues,
+		);
+	}
+}
+
+export function routeCompatibilityIssue(
+	request: AgentRequestIssued,
+	route: ExecutorRoute,
+	profile: ExecutorProfile,
+): string | undefined {
+	if (request.requestKind !== "executor") return "route-for-non-executor-request";
+	if (route.executorId !== profile.executorId) return "route-profile-executor-mismatch";
+	if (
+		request.input?.inputId !== undefined &&
+		route.inputId !== undefined &&
+		request.input.inputId !== route.inputId
+	) {
+		return "route-input-mismatch";
+	}
+	if (
+		request.input?.inputKind !== undefined &&
+		route.inputKind !== undefined &&
+		request.input.inputKind !== route.inputKind
+	) {
+		return "route-input-kind-mismatch";
+	}
+	const inputKind = request.input?.inputKind ?? route.inputKind;
+	if (inputKind !== undefined && !profileKindAcceptsInput(profile.kind, inputKind))
+		return "profile-kind-input-incompatible";
+	if (
+		inputKind !== undefined &&
+		profile.acceptedInputKinds !== undefined &&
+		!profile.acceptedInputKinds.includes(inputKind)
+	) {
+		return "profile-rejects-input-kind";
+	}
+	if (
+		request.input?.schemaRef !== undefined &&
+		profile.acceptedSchemaRefs !== undefined &&
+		!profile.acceptedSchemaRefs.includes(request.input.schemaRef)
+	) {
+		return "profile-rejects-schema";
+	}
+	return undefined;
+}
+
+export function outcomeCompatibilityIssue(
+	request: AgentRequestIssued,
+	route: ExecutorRoute,
+	outcome: ExecutorOutcome,
+): string | undefined {
+	if (outcome.executorId !== route.executorId) return "outcome-route-executor-mismatch";
+	if (outcome.profileId !== route.profileId) return "outcome-route-profile-mismatch";
+	if (
+		route.inputId !== undefined &&
+		(outcome.inputId === undefined || outcome.inputId !== route.inputId)
+	) {
+		return "outcome-route-input-mismatch";
+	}
+	if (
+		request.input?.inputId !== undefined &&
+		outcome.inputId !== undefined &&
+		outcome.inputId !== request.input.inputId
+	) {
+		return "outcome-request-input-mismatch";
+	}
+	if (
+		route.inputKind !== undefined &&
+		(outcome.inputKind === undefined || outcome.inputKind !== route.inputKind)
+	) {
+		return "outcome-route-input-kind-mismatch";
+	}
+	if (
+		request.input?.inputKind !== undefined &&
+		outcome.inputKind !== undefined &&
+		outcome.inputKind !== request.input.inputKind
+	) {
+		return "outcome-request-input-kind-mismatch";
+	}
+	return undefined;
+}
+
+export function profileKindAcceptsInput(kind: ExecutorProfile["kind"], inputKind: string): boolean {
+	if (kind === "llm") return inputKind === "llm-call";
+	if (kind === "tool") return inputKind === "tool-call";
+	if (kind === "human") return inputKind === "human-task";
+	return inputKind === "agent-task";
+}
+
+export function outcomeStatus(outcome: ExecutorOutcome): AgentRequestStatus {
+	if (outcome.kind === "result") return "completed";
+	if (outcome.kind === "failure") return "failed";
+	if (outcome.kind === "timeout") return "timeout";
+	if (outcome.kind === "canceled") return "canceled";
+	return "blocked";
+}
+
+export function emitStatus(
+	ctx: Ctx,
+	state: RequestSatisfactionState,
+	request: AgentRequestIssued,
+	status: AgentRequestStatus,
+	sourceRefs?: readonly SourceRef[],
+	issues?: readonly DataIssue[],
+): void {
+	const cleanSourceRefs =
+		sourceRefs === undefined ? undefined : sanitizeAdapterInputSourceRefs(sourceRefs);
+	const cleanIssues =
+		issues === undefined
+			? undefined
+			: Object.freeze(issues.map((issue) => sanitizeAdapterInputIssue(issue)));
+	const fact: AgentRequestStatusChanged = {
+		kind: "status",
+		requestId: request.requestId,
+		operationId: request.operationId,
+		effectRunId: request.effectRunId,
+		status,
+		sourceRefs: cleanSourceRefs,
+		issues: cleanIssues,
+	};
+	state.auditSeq += 1;
+	ctx.down([
+		["DATA", { kind: "status", status: fact } satisfies AgentRequestSatisfactionFact],
+		[
+			"DATA",
+			{
+				kind: "audit",
+				audit: {
+					id: `${request.requestId}:status:${state.auditSeq}`,
+					kind: "agent-request-status",
+					subjectId: request.requestId,
+					sourceRefs: cleanSourceRefs,
+					metadata: { status },
+				},
+			} satisfies AgentRequestSatisfactionFact,
+		],
+	]);
+}
+
+export function emitStatusOnce(
+	ctx: Ctx,
+	state: RequestSatisfactionState,
+	key: string,
+	request: AgentRequestIssued,
+	status: AgentRequestStatus,
+	sourceRefs?: readonly SourceRef[],
+	issues?: readonly DataIssue[],
+): void {
+	if (state.statusKeys.has(key)) return;
+	state.statusKeys.add(key);
+	emitStatus(ctx, state, request, status, sourceRefs, issues);
+}
+
+export function emitIssue(
+	ctx: Ctx,
+	state: RequestSatisfactionState,
+	code: string,
+	message: string,
+	subjectId?: string,
+	refs?: readonly SourceRef[],
+): void {
+	state.issueSeq += 1;
+	const issue = dataIssue(code, message, { subjectId, refs });
+	state.auditSeq += 1;
+	ctx.down([
+		["DATA", { kind: "issue", issue } satisfies AgentRequestSatisfactionFact],
+		[
+			"DATA",
+			{
+				kind: "audit",
+				audit: {
+					id: `${subjectId ?? "request"}:issue:${state.auditSeq}`,
+					kind: "agent-request-issue",
+					subjectId,
+					issueCode: code,
+					message,
+					sourceRefs: refs,
+				},
+			} satisfies AgentRequestSatisfactionFact,
+		],
+	]);
+}
+
+export function emitIssueOnce(
+	ctx: Ctx,
+	state: RequestSatisfactionState,
+	key: string,
+	code: string,
+	message: string,
+	subjectId?: string,
+	refs?: readonly SourceRef[],
+): void {
+	if (state.issueKeys.has(key)) return;
+	state.issueKeys.add(key);
+	emitIssue(ctx, state, code, message, subjectId, refs);
+}
diff --git a/packages/ts/src/orchestration/agent-runtime-tool-provider-input.ts b/packages/ts/src/orchestration/agent-runtime-tool-provider-input.ts
new file mode 100644
index 00000000..a7734296
--- /dev/null
+++ b/packages/ts/src/orchestration/agent-runtime-tool-provider-input.ts
@@ -0,0 +1,573 @@
+import { depBatch } from "../ctx/types.js";
+import type { DataIssue } from "../data/index.js";
+import type { Graph } from "../graph/graph.js";
+import type { Node } from "../node/node.js";
+import {
+	dataIssue,
+	forbiddenAdapterInputMaterialIssues,
+	forEachDepBatch,
+	projectRuntimeFact,
+	ref,
+	sanitizeAdapterInputIssue,
+	sanitizeAdapterInputSourceRefs,
+	stableJsonStringify,
+} from "./agent-runtime-common.js";
+import {
+	toolCallFromRequest,
+	validateToolProviderExecutionPolicy,
+	validateToolProviderPolicyProviderScope,
+} from "./agent-runtime-tool-provider-policy.js";
+import type { AgentRuntimeAuditRecord } from "./agent-runtime-types-agent.js";
+import type {
+	AgentRequestFact,
+	AgentRequestInput,
+	AgentRequestIssued,
+	ExecutorRoute,
+	SourceRef,
+} from "./agent-runtime-types-core.js";
+import type {
+	ToolCallInput,
+	ToolProviderAdapterInput,
+	ToolProviderAdapterInputBundle,
+	ToolProviderAdapterInputStatus,
+	ToolProviderCatalog,
+	ToolProviderCatalogEntry,
+	ToolProviderExecutionPolicy,
+	ToolProviderPolicyResolution,
+} from "./agent-runtime-types-tool.js";
+
+export function buildToolProviderAdapterInputs(opts: {
+	readonly requests: readonly AgentRequestIssued[];
+	readonly routes?: readonly ExecutorRoute[];
+	readonly catalogs?: readonly ToolProviderCatalog[];
+	readonly resolutions: readonly ToolProviderPolicyResolution[];
+}): readonly ToolProviderAdapterInput[] {
+	const requestsById = new Map(opts.requests.map((request) => [request.requestId, request]));
+	const routesById = new Map((opts.routes ?? []).map((route) => [route.routeId, route]));
+	const catalogsById = new Map(
+		(opts.catalogs ?? []).map((catalog) => [catalog.providerId, catalog]),
+	);
+	return Object.freeze(
+		opts.resolutions.map((resolution) =>
+			buildToolProviderAdapterInput({
+				resolution,
+				request: requestsById.get(resolution.requestId),
+				route: resolution.routeId === undefined ? undefined : routesById.get(resolution.routeId),
+				catalog:
+					resolution.providerId === undefined ? undefined : catalogsById.get(resolution.providerId),
+			}),
+		),
+	);
+}
+
+export function toolProviderAdapterInputProjector(
+	graph: Graph,
+	opts: {
+		readonly name?: string;
+		readonly requestFacts: Node<AgentRequestFact>;
+		readonly executorRoutes?: readonly Node<ExecutorRoute>[];
+		readonly toolProviderCatalogs?: readonly Node<ToolProviderCatalog>[];
+		readonly policyResolutions: readonly Node<ToolProviderPolicyResolution>[];
+	},
+): ToolProviderAdapterInputBundle {
+	const name = opts.name ?? "toolProviderAdapterInput";
+	const routeDeps = opts.executorRoutes ?? [];
+	const catalogDeps = opts.toolProviderCatalogs ?? [];
+	const routeStart = 1;
+	const catalogStart = routeStart + routeDeps.length;
+	const resolutionStart = catalogStart + catalogDeps.length;
+	const runtime = graph.node<ToolProviderAdapterInputFact>(
+		[opts.requestFacts, ...routeDeps, ...catalogDeps, ...opts.policyResolutions],
+		(ctx) => {
+			const state = ctx.state.get<ToolProviderAdapterInputState>() ?? {
+				requests: new Map<string, AgentRequestIssued>(),
+				routes: new Map<string, ExecutorRoute>(),
+				catalogs: new Map<string, ToolProviderCatalog>(),
+				resolutions: new Map<string, ToolProviderPolicyResolution>(),
+				emittedKeys: new Set<string>(),
+				auditSeq: 0,
+			};
+			for (const raw of depBatch(ctx, 0) ?? []) {
+				const fact = raw as AgentRequestFact;
+				if (fact.kind === "issued" && fact.input?.inputKind === "tool-call") {
+					state.requests.set(fact.requestId, fact);
+				}
+			}
+			forEachDepBatch(ctx, routeStart, routeDeps.length, (raw) => {
+				const route = raw as ExecutorRoute;
+				state.routes.set(route.routeId, route);
+			});
+			forEachDepBatch(ctx, catalogStart, catalogDeps.length, (raw) => {
+				const catalog = raw as ToolProviderCatalog;
+				state.catalogs.set(catalog.providerId, catalog);
+			});
+			forEachDepBatch(ctx, resolutionStart, opts.policyResolutions.length, (raw) => {
+				const resolution = raw as ToolProviderPolicyResolution;
+				state.resolutions.set(resolution.resolutionId, resolution);
+			});
+			const inputs = buildToolProviderAdapterInputs({
+				requests: Array.from(state.requests.values()),
+				routes: Array.from(state.routes.values()),
+				catalogs: Array.from(state.catalogs.values()),
+				resolutions: Array.from(state.resolutions.values()),
+			});
+			for (const input of inputs) {
+				const key = stableToolProviderAdapterInputKey(input);
+				if (state.emittedKeys.has(key)) continue;
+				state.emittedKeys.add(key);
+				ctx.down([["DATA", { kind: "input", input } satisfies ToolProviderAdapterInputFact]]);
+				for (const issue of input.issues ?? []) {
+					ctx.down([["DATA", { kind: "issue", issue } satisfies ToolProviderAdapterInputFact]]);
+				}
+				state.auditSeq += 1;
+				ctx.down([
+					[
+						"DATA",
+						{
+							kind: "audit",
+							audit: {
+								id: `${name}:audit:${state.auditSeq}`,
+								kind: "tool-provider-adapter-input",
+								subjectId: input.requestId,
+								sourceRefs: input.sourceRefs,
+								metadata: {
+									status: input.status,
+									routeId: input.routeId,
+									providerId: input.providerId,
+									profileId: input.profileId,
+									toolName: input.toolName,
+								},
+							},
+						} satisfies ToolProviderAdapterInputFact,
+					],
+				]);
+			}
+			ctx.state.set(state);
+		},
+		{ name: `${name}/runtime`, factory: "toolProviderAdapterInputProjector", partial: true },
+	);
+	const inputs = projectRuntimeFact(
+		graph,
+		runtime,
+		`${name}/inputs`,
+		"toolProviderAdapterInputs",
+		(fact) => (fact.kind === "input" ? fact.input : undefined),
+	);
+	const issues = projectRuntimeFact(
+		graph,
+		runtime,
+		`${name}/issues`,
+		"toolProviderAdapterInputIssues",
+		(fact) => (fact.kind === "issue" ? fact.issue : undefined),
+	);
+	const audit = projectRuntimeFact(
+		graph,
+		runtime,
+		`${name}/audit`,
+		"toolProviderAdapterInputAudit",
+		(fact) => (fact.kind === "audit" ? fact.audit : undefined),
+	);
+	return { inputs, issues, audit };
+}
+
+export type ToolProviderAdapterInputFact =
+	| { readonly kind: "input"; readonly input: ToolProviderAdapterInput }
+	| { readonly kind: "issue"; readonly issue: DataIssue }
+	| { readonly kind: "audit"; readonly audit: AgentRuntimeAuditRecord };
+
+export interface ToolProviderAdapterInputState {
+	requests: Map<string, AgentRequestIssued>;
+	routes: Map<string, ExecutorRoute>;
+	catalogs: Map<string, ToolProviderCatalog>;
+	resolutions: Map<string, ToolProviderPolicyResolution>;
+	emittedKeys: Set<string>;
+	auditSeq: number;
+}
+
+export function buildToolProviderAdapterInput(opts: {
+	readonly resolution: ToolProviderPolicyResolution;
+	readonly request?: AgentRequestIssued;
+	readonly route?: ExecutorRoute;
+	readonly catalog?: ToolProviderCatalog;
+}): ToolProviderAdapterInput {
+	const { resolution, request, route, catalog } = opts;
+	const sourceRefs = sanitizeAdapterInputSourceRefs([
+		ref("tool-provider-policy-resolution", resolution.resolutionId),
+		...(resolution.sourceRefs ?? []),
+		...(resolution.routeId === undefined ? [] : [ref("executor-route", resolution.routeId)]),
+		...(resolution.providerId === undefined
+			? []
+			: [ref("tool-provider-catalog", resolution.providerId)]),
+		...(resolution.policyRefs ?? []),
+	]);
+	const issues: DataIssue[] = (resolution.issues ?? []).map((issue) =>
+		sanitizeAdapterInputIssue(issue),
+	);
+	let statusOverride: Exclude<ToolProviderAdapterInputStatus, "ready"> | undefined;
+	if (request === undefined) {
+		issues.push(
+			dataIssue(
+				"tool-provider-adapter-input-missing-request",
+				"Tool provider adapter input requires the issued AgentRequest fact.",
+				{ subjectId: resolution.requestId, refs: sourceRefs },
+			),
+		);
+	}
+	if (request !== undefined && request.requestId !== resolution.requestId) {
+		issues.push(
+			dataIssue(
+				"tool-provider-adapter-input-stale-request",
+				"Tool provider adapter input request identity does not match its policy resolution.",
+				{ subjectId: resolution.requestId, refs: sourceRefs },
+			),
+		);
+	}
+	if (request !== undefined && request.operationId !== resolution.operationId) {
+		issues.push(
+			dataIssue(
+				"tool-provider-adapter-input-stale-request-operation",
+				"Tool provider adapter input request operationId does not match its policy resolution.",
+				{ subjectId: resolution.requestId, refs: sourceRefs },
+			),
+		);
+	}
+	if (resolution.routeId !== undefined && route === undefined) {
+		issues.push(
+			dataIssue(
+				"tool-provider-adapter-input-missing-route",
+				"Tool provider adapter input requires the selected ExecutorRoute fact.",
+				{ subjectId: resolution.requestId, refs: sourceRefs },
+			),
+		);
+	}
+	if (route !== undefined) {
+		issues.push(...routeIdentityIssuesForAdapterInput(route, resolution, request, sourceRefs));
+	}
+	if (resolution.providerId !== undefined && catalog === undefined) {
+		issues.push(
+			dataIssue(
+				"tool-provider-adapter-input-missing-catalog",
+				"Tool provider adapter input requires the selected ToolProviderCatalog fact.",
+				{ subjectId: resolution.requestId, refs: sourceRefs },
+			),
+		);
+	}
+	if (catalog !== undefined && catalog.status !== undefined && catalog.status !== "ready") {
+		statusOverride = "invalid-policy";
+		issues.push(
+			dataIssue(
+				"tool-provider-adapter-input-catalog-unavailable",
+				"Tool provider adapter input requires a ready ToolProviderCatalog.",
+				{
+					subjectId: resolution.requestId,
+					refs: [...sourceRefs, ref("tool-provider-catalog", catalog.providerId)],
+					details: { status: catalog.status },
+				},
+			),
+		);
+		issues.push(...(catalog.issues ?? []).map((issue) => sanitizeAdapterInputIssue(issue)));
+	}
+	const toolCall = request === undefined ? undefined : toolCallFromRequest(request);
+	if (request !== undefined && toolCall === undefined) {
+		issues.push(
+			dataIssue(
+				"tool-provider-adapter-input-missing-tool-call",
+				"Tool provider adapter input requires AgentRequest input.value to be a ToolCallInput.",
+				{ subjectId: resolution.requestId, refs: sourceRefs },
+			),
+		);
+	}
+	const tool =
+		catalog === undefined || route === undefined || toolCall === undefined
+			? undefined
+			: selectedToolForAdapterInput(catalog, route, toolCall);
+	if (resolution.status === "resolved" && tool === undefined) {
+		issues.push(
+			dataIssue(
+				"tool-provider-adapter-input-missing-tool",
+				"Tool provider adapter input requires the selected catalog tool entry.",
+				{ subjectId: resolution.requestId, refs: sourceRefs },
+			),
+		);
+	}
+	const policies =
+		catalog === undefined
+			? []
+			: selectedPoliciesForAdapterInput(catalog, resolution.policyRefs ?? []);
+	if (resolution.status === "resolved" && (resolution.policyRefs?.length ?? 0) === 0) {
+		statusOverride = "missing-policy";
+		issues.push(
+			dataIssue(
+				"tool-provider-adapter-input-missing-policy-ref",
+				"Ready tool provider adapter input requires at least one D360 policy ref.",
+				{ subjectId: resolution.requestId, refs: sourceRefs },
+			),
+		);
+	}
+	if (catalog !== undefined) {
+		for (const issue of policyMaterialIssuesForAdapterInput(catalog, resolution, sourceRefs)) {
+			statusOverride ??= "invalid-policy";
+			issues.push(issue);
+		}
+	}
+	for (const policy of policies) {
+		issues.push(...validateToolProviderExecutionPolicy(policy));
+		if (catalog !== undefined)
+			issues.push(...validateToolProviderPolicyProviderScope(policy, catalog.providerId));
+	}
+	if (request?.input !== undefined) {
+		issues.push(
+			...forbiddenAdapterInputMaterialIssues(
+				request.input,
+				ref("agent-request", request.requestId),
+				"request-input",
+			),
+		);
+	}
+	if (route !== undefined) {
+		issues.push(
+			...forbiddenAdapterInputMaterialIssues(
+				route.allowedParams,
+				ref("executor-route", route.routeId),
+				"route-allowed-params",
+			),
+			...forbiddenAdapterInputMaterialIssues(
+				route.metadata,
+				ref("executor-route", route.routeId),
+				"route-metadata",
+			),
+		);
+	}
+	if (tool !== undefined) {
+		const toolRef = ref("tool", tool.toolName);
+		issues.push(
+			...forbiddenAdapterInputMaterialIssues(tool.capabilities, toolRef, "tool-capabilities"),
+			...forbiddenAdapterInputMaterialIssues(tool.limits, toolRef, "tool-limits"),
+			...forbiddenAdapterInputMaterialIssues(tool.metadata, toolRef, "tool-metadata"),
+		);
+	}
+	for (const policy of policies) {
+		issues.push(
+			...forbiddenAdapterInputMaterialIssues(
+				policy,
+				ref("tool-provider-execution-policy", policy.policyId),
+				"policy-material",
+			),
+		);
+	}
+	const status =
+		resolution.status === "resolved"
+			? issues.length === 0
+				? "ready"
+				: (statusOverride ?? "invalid-policy")
+			: resolution.status;
+	const ready = status === "ready";
+	const candidate = {
+		kind: "tool-provider-adapter-input",
+		adapterInputId: `${resolution.requestId}:${resolution.operationId}:${resolution.routeId ?? resolution.resolutionId}:adapter-input`,
+		status,
+		requestId: resolution.requestId,
+		operationId: resolution.operationId,
+		effectRunId: request?.effectRunId,
+		agentRunId: request?.agentRunId,
+		routeId: resolution.routeId,
+		providerId: resolution.providerId,
+		executorId: resolution.executorId,
+		profileId: resolution.profileId,
+		toolName: resolution.toolName,
+		operation: resolution.operation,
+		input: ready ? (request?.input as AgentRequestInput<ToolCallInput> | undefined) : undefined,
+		toolCall: ready ? toolCall : undefined,
+		route: ready ? route : undefined,
+		tool: ready ? tool : undefined,
+		policies: ready ? Object.freeze(policies) : undefined,
+		policyRefs: sanitizeAdapterInputSourceRefs(resolution.policyRefs ?? []),
+		sourceRefs,
+		issues: issues.length === 0 ? undefined : Object.freeze(issues),
+		metadata: { resolutionId: resolution.resolutionId },
+	} satisfies ToolProviderAdapterInput;
+	if (ready) {
+		const candidateIssues = forbiddenAdapterInputMaterialIssues(
+			candidate,
+			ref("tool-provider-adapter-input", candidate.adapterInputId),
+			"adapter-input",
+		);
+		if (candidateIssues.length > 0) {
+			const blockedIssues = Object.freeze([...issues, ...candidateIssues]);
+			return Object.freeze({
+				...candidate,
+				status: "invalid-policy",
+				input: undefined,
+				toolCall: undefined,
+				route: undefined,
+				tool: undefined,
+				policies: undefined,
+				issues: blockedIssues,
+			} satisfies ToolProviderAdapterInput);
+		}
+	}
+	return Object.freeze(candidate);
+}
+
+export function selectedToolForAdapterInput(
+	catalog: ToolProviderCatalog,
+	route: ExecutorRoute,
+	toolCall: ToolCallInput,
+): ToolProviderCatalogEntry | undefined {
+	return catalog.tools.find(
+		(entry) =>
+			entry.profileId === route.profileId &&
+			entry.executorId === route.executorId &&
+			entry.toolName === toolCall.toolName &&
+			(entry.operation === undefined ||
+				toolCall.operation === undefined ||
+				entry.operation === toolCall.operation),
+	);
+}
+
+export function selectedPoliciesForAdapterInput(
+	catalog: ToolProviderCatalog,
+	policyRefs: readonly SourceRef[],
+): ToolProviderExecutionPolicy[] {
+	const policiesById = new Map((catalog.policies ?? []).map((policy) => [policy.policyId, policy]));
+	const policies: ToolProviderExecutionPolicy[] = [];
+	for (const policyRef of policyRefs) {
+		if (policyRef.kind !== "tool-provider-execution-policy") continue;
+		const policy = policiesById.get(policyRef.id);
+		if (policy !== undefined) policies.push(policy);
+	}
+	return policies;
+}
+
+export function routeIdentityIssuesForAdapterInput(
+	route: ExecutorRoute,
+	resolution: ToolProviderPolicyResolution,
+	request: AgentRequestIssued | undefined,
+	sourceRefs: readonly SourceRef[],
+): readonly DataIssue[] {
+	const issues: DataIssue[] = [];
+	const refs = [...sourceRefs, ref("executor-route", route.routeId)];
+	if (route.requestId !== resolution.requestId) {
+		issues.push(
+			dataIssue(
+				"tool-provider-adapter-input-stale-route-request",
+				"ExecutorRoute requestId does not match the tool provider policy resolution.",
+				{ subjectId: resolution.requestId, refs },
+			),
+		);
+	}
+	if (route.operationId !== resolution.operationId) {
+		issues.push(
+			dataIssue(
+				"tool-provider-adapter-input-stale-route-operation",
+				"ExecutorRoute operationId does not match the tool provider policy resolution.",
+				{ subjectId: resolution.requestId, refs },
+			),
+		);
+	}
+	if (resolution.routeId !== undefined && route.routeId !== resolution.routeId) {
+		issues.push(
+			dataIssue(
+				"tool-provider-adapter-input-stale-route-id",
+				"ExecutorRoute routeId does not match the tool provider policy resolution.",
+				{ subjectId: resolution.requestId, refs },
+			),
+		);
+	}
+	if (resolution.executorId !== undefined && route.executorId !== resolution.executorId) {
+		issues.push(
+			dataIssue(
+				"tool-provider-adapter-input-stale-route-executor",
+				"ExecutorRoute executorId does not match the tool provider policy resolution.",
+				{ subjectId: resolution.requestId, refs },
+			),
+		);
+	}
+	if (resolution.profileId !== undefined && route.profileId !== resolution.profileId) {
+		issues.push(
+			dataIssue(
+				"tool-provider-adapter-input-stale-route-profile",
+				"ExecutorRoute profileId does not match the tool provider policy resolution.",
+				{ subjectId: resolution.requestId, refs },
+			),
+		);
+	}
+	if (
+		request !== undefined &&
+		route.inputId !== undefined &&
+		route.inputId !== request.input?.inputId
+	) {
+		issues.push(
+			dataIssue(
+				"tool-provider-adapter-input-stale-route-input",
+				"ExecutorRoute inputId does not match the issued AgentRequest input.",
+				{ subjectId: resolution.requestId, refs },
+			),
+		);
+	}
+	if (route.inputKind !== undefined && route.inputKind !== "tool-call") {
+		issues.push(
+			dataIssue(
+				"tool-provider-adapter-input-invalid-route-input-kind",
+				"Tool provider adapter input requires ExecutorRoute.inputKind to be tool-call when present.",
+				{ subjectId: resolution.requestId, refs },
+			),
+		);
+	}
+	if (
+		request !== undefined &&
+		route.inputKind !== undefined &&
+		request.input?.inputKind !== undefined &&
+		route.inputKind !== request.input.inputKind
+	) {
+		issues.push(
+			dataIssue(
+				"tool-provider-adapter-input-stale-route-input-kind",
+				"ExecutorRoute inputKind does not match the issued AgentRequest input.",
+				{ subjectId: resolution.requestId, refs },
+			),
+		);
+	}
+	return Object.freeze(issues);
+}
+
+export function policyMaterialIssuesForAdapterInput(
+	catalog: ToolProviderCatalog,
+	resolution: ToolProviderPolicyResolution,
+	sourceRefs: readonly SourceRef[],
+): readonly DataIssue[] {
+	const policiesById = new Map((catalog.policies ?? []).map((policy) => [policy.policyId, policy]));
+	const issues: DataIssue[] = [];
+	for (const policyRef of resolution.policyRefs ?? []) {
+		if (policyRef.kind !== "tool-provider-execution-policy") {
+			issues.push(
+				dataIssue(
+					"tool-provider-adapter-input-invalid-policy-ref-kind",
+					"Tool provider adapter input policy refs must point at ToolProviderExecutionPolicy facts.",
+					{ subjectId: resolution.requestId, refs: [...sourceRefs, policyRef] },
+				),
+			);
+			continue;
+		}
+		if (!policiesById.has(policyRef.id)) {
+			issues.push(
+				dataIssue(
+					"tool-provider-adapter-input-policy-ref-missing-material",
+					"Tool provider adapter input policy ref has no selected policy material.",
+					{ subjectId: resolution.requestId, refs: [...sourceRefs, policyRef] },
+				),
+			);
+		}
+	}
+	return Object.freeze(issues);
+}
+
+export function stableToolProviderAdapterInputKey(input: ToolProviderAdapterInput): string {
+	return stableJsonStringify({
+		id: input.adapterInputId,
+		status: input.status,
+		policyRefs: input.policyRefs?.map((policyRef) => `${policyRef.kind}:${policyRef.id}`) ?? [],
+		issues: input.issues?.map((issue) => issue.code) ?? [],
+		input,
+	});
+}
diff --git a/packages/ts/src/orchestration/agent-runtime-tool-provider-policy.ts b/packages/ts/src/orchestration/agent-runtime-tool-provider-policy.ts
new file mode 100644
index 00000000..92e4f72a
--- /dev/null
+++ b/packages/ts/src/orchestration/agent-runtime-tool-provider-policy.ts
@@ -0,0 +1,978 @@
+import { depBatch } from "../ctx/types.js";
+import type { DataIssue } from "../data/index.js";
+import type { Graph } from "../graph/graph.js";
+import type { Node } from "../node/node.js";
+import {
+	dataIssue,
+	forbiddenDataKeys,
+	forbiddenGraphVisibleMaterialIssues,
+	forbiddenProviderRawMaterialKeys,
+	forEachDepBatch,
+	isRecord,
+	projectRuntimeFact,
+	ref,
+	sanitizeProviderGraphVisibleRecord,
+	unlockedToolProviderPolicyOverrides,
+} from "./agent-runtime-common.js";
+import type { AgentRuntimeAuditRecord } from "./agent-runtime-types-agent.js";
+import type {
+	AgentRequestFact,
+	AgentRequestIssued,
+	ExecutorProfile,
+	ExecutorRoute,
+	SourceRef,
+} from "./agent-runtime-types-core.js";
+import type {
+	LocalBuiltinToolProviderCatalogOptions,
+	ToolCallInput,
+	ToolProviderApprovalPolicy,
+	ToolProviderArtifactPolicy,
+	ToolProviderCatalog,
+	ToolProviderCatalogEntry,
+	ToolProviderExecutionPolicy,
+	ToolProviderFilesystemPolicy,
+	ToolProviderNetworkPolicy,
+	ToolProviderPathRule,
+	ToolProviderPolicyResolution,
+	ToolProviderPolicyResolutionBundle,
+	ToolProviderPolicyResolutionStatus,
+	ToolProviderRedactionPolicy,
+	ToolProviderSizeCapacityPolicy,
+	ToolProviderSizeLimit,
+	ToolProviderTimeoutPolicy,
+} from "./agent-runtime-types-tool.js";
+
+export function localBuiltinToolProviderCatalog(
+	opts: LocalBuiltinToolProviderCatalogOptions = {},
+): ToolProviderCatalog {
+	const providerId = opts.providerId ?? "local-builtin";
+	const executorId = opts.executorId ?? `${providerId}:tool-executor`;
+	const profileId = opts.profileId ?? `${providerId}:tool-profile`;
+	const tools =
+		opts.tools ??
+		([
+			{ toolName: "document/read-doc", operation: "read" },
+			{ toolName: "file.read", operation: "read" },
+			{ toolName: "file.edit/apply-patch", operation: "edit" },
+			{ toolName: "bash.run", operation: "run" },
+			{ toolName: "url.fetch", operation: "fetch" },
+			{ toolName: "date.now", operation: "read" },
+			{ toolName: "weather.fetch", operation: "fetch" },
+			{ toolName: "calculator/eval", operation: "eval" },
+		] satisfies readonly Omit<
+			ToolProviderCatalogEntry,
+			"kind" | "providerId" | "inputKind" | "profileId" | "executorId"
+		>[]);
+	const candidatePolicies: readonly unknown[] = opts.policies?.map((policy) =>
+		Object.freeze(policy),
+	) ?? [
+		defaultLocalBuiltinToolProviderExecutionPolicy({
+			providerId,
+			profileId,
+			tools,
+			overrides: opts.policyOverrides,
+		}),
+	];
+	const policyIssues = Object.freeze(
+		candidatePolicies.flatMap((policy) => [
+			...validateToolProviderExecutionPolicy(policy),
+			...validateToolProviderPolicyProviderScope(policy, providerId),
+		]),
+	);
+	const policies = Object.freeze(
+		candidatePolicies
+			.filter((policy) => isPublishableToolProviderExecutionPolicy(policy, providerId))
+			.map((policy) => Object.freeze(policy)),
+	);
+	const policyRefs = Object.freeze(
+		policies.map((policy) => ref("tool-provider-execution-policy", policy.policyId)),
+	);
+	const catalogInputIssues = Object.freeze([
+		...forbiddenGraphVisibleMaterialIssues(
+			opts.metadata,
+			ref("tool-provider-catalog", providerId),
+			"catalog-metadata",
+		),
+		...forbiddenGraphVisibleMaterialIssues(
+			opts.capabilities,
+			ref("executor-profile", profileId),
+			"profile-capabilities",
+		),
+		...forbiddenGraphVisibleMaterialIssues(
+			opts.limits,
+			ref("executor-profile", profileId),
+			"profile-limits",
+		),
+		...tools.flatMap((tool) => [
+			...forbiddenGraphVisibleMaterialIssues(
+				tool.metadata,
+				ref("tool", tool.toolName),
+				"tool-metadata",
+			),
+			...forbiddenGraphVisibleMaterialIssues(
+				tool.capabilities,
+				ref("tool", tool.toolName),
+				"tool-capabilities",
+			),
+			...forbiddenGraphVisibleMaterialIssues(
+				tool.limits,
+				ref("tool", tool.toolName),
+				"tool-limits",
+			),
+		]),
+	]);
+	const toolEntries = tools.map((tool) => {
+		const toolPolicyRefs = policyRefsForTool(policies, profileId, tool);
+		return Object.freeze({
+			...tool,
+			kind: "tool-catalog-entry",
+			providerId,
+			inputKind: "tool-call",
+			profileId,
+			executorId,
+			capabilities: sanitizeProviderGraphVisibleRecord(tool.capabilities),
+			limits: sanitizeProviderGraphVisibleRecord(tool.limits),
+			policyRefs: toolPolicyRefs,
+			metadata: sanitizeProviderGraphVisibleRecord(tool.metadata),
+		} satisfies ToolProviderCatalogEntry);
+	});
+	const profilePolicyRefs = policyRefsForProfile(policies, profileId);
+	const issues = Object.freeze([...policyIssues, ...catalogInputIssues]);
+	return Object.freeze({
+		kind: "tool-provider-catalog",
+		providerId,
+		providerKind: "local-builtin",
+		status: issues.length === 0 ? "ready" : "misconfigured",
+		profiles: Object.freeze([
+			Object.freeze({
+				profileId,
+				executorId,
+				kind: "tool",
+				acceptedInputKinds: Object.freeze(["tool-call"]),
+				acceptedResultKinds: Object.freeze(
+					Array.from(new Set(toolEntries.flatMap((tool) => tool.resultKinds ?? []))),
+				),
+				capabilities: Object.freeze({
+					toolNames: Object.freeze(toolEntries.map((tool) => tool.toolName)),
+					...(sanitizeProviderGraphVisibleRecord(opts.capabilities) ?? {}),
+				}),
+				limits: sanitizeProviderGraphVisibleRecord(opts.limits),
+				policyRefs: profilePolicyRefs,
+				metadata: sanitizeProviderGraphVisibleRecord(opts.metadata),
+			} satisfies ExecutorProfile),
+		]),
+		tools: Object.freeze(toolEntries),
+		policies,
+		policyRefs,
+		issues: issues.length === 0 ? undefined : issues,
+		metadata: sanitizeProviderGraphVisibleRecord(opts.metadata),
+	});
+}
+
+export function validateToolProviderExecutionPolicy(policy: unknown): readonly DataIssue[] {
+	const issues: DataIssue[] = [];
+	if (!isRecord(policy)) {
+		return Object.freeze([
+			dataIssue(
+				"tool-provider-policy-invalid-shape",
+				"Tool provider policy must be a data object.",
+				{ refs: [ref("tool-provider-execution-policy", "<invalid>")] },
+			),
+		]);
+	}
+	const policyId = typeof policy.policyId === "string" ? policy.policyId : "";
+	const providerId = typeof policy.providerId === "string" ? policy.providerId : "";
+	const policyRef = ref("tool-provider-execution-policy", policyId || "<missing>");
+	if (policy.kind !== "tool-provider-execution-policy") {
+		issues.push(
+			dataIssue(
+				"tool-provider-policy-invalid-kind",
+				"ToolProviderExecutionPolicy.kind must be tool-provider-execution-policy.",
+				{ subjectId: policyId, refs: [policyRef] },
+			),
+		);
+	}
+	if (!policyId) {
+		issues.push(
+			dataIssue(
+				"tool-provider-policy-missing-policy-id",
+				"Tool provider policy is missing policyId.",
+				{
+					refs: [policyRef],
+				},
+			),
+		);
+	}
+	if (!providerId) {
+		issues.push(
+			dataIssue(
+				"tool-provider-policy-missing-provider-id",
+				"Tool provider policy is missing providerId.",
+				{ subjectId: policyId, refs: [policyRef] },
+			),
+		);
+	}
+	if (
+		policy.sizeCapacity === undefined &&
+		policy.timeout === undefined &&
+		policy.redaction === undefined &&
+		policy.filesystem === undefined &&
+		policy.approval === undefined &&
+		policy.artifacts === undefined &&
+		policy.network === undefined
+	) {
+		issues.push(
+			dataIssue(
+				"tool-provider-policy-missing-material",
+				"Tool provider policy has no D360 policy material sections.",
+				{ subjectId: policyId, refs: [policyRef] },
+			),
+		);
+	}
+	if (policy.sizeCapacity !== undefined && !isRecord(policy.sizeCapacity)) {
+		issues.push(
+			dataIssue(
+				"tool-provider-policy-invalid-size-capacity",
+				"Tool provider size-capacity policy must be a data object.",
+				{ subjectId: policyId, refs: [policyRef] },
+			),
+		);
+	}
+	const limits = isRecord(policy.sizeCapacity) ? policy.sizeCapacity.limits : undefined;
+	if (isRecord(policy.sizeCapacity) && !Array.isArray(limits)) {
+		issues.push(
+			dataIssue(
+				"tool-provider-policy-invalid-size-capacity",
+				"Tool provider size-capacity limits must be an array.",
+				{ subjectId: policyId, refs: [policyRef] },
+			),
+		);
+	}
+	for (const [index, rawLimit] of (Array.isArray(limits) ? limits : []).entries()) {
+		if (!isRecord(rawLimit)) {
+			issues.push(
+				dataIssue(
+					"tool-provider-policy-invalid-size-limit",
+					"Tool provider size-capacity limit must be a data object.",
+					{ subjectId: policyId, refs: [policyRef], details: { index } },
+				),
+			);
+			continue;
+		}
+		const limit = rawLimit as Partial<ToolProviderSizeLimit>;
+		if (typeof limit.unit !== "string" || limit.unit.length === 0) {
+			issues.push(
+				dataIssue(
+					"tool-provider-policy-invalid-size-limit",
+					"Tool provider size-capacity limit unit must be a non-empty string.",
+					{ subjectId: policyId, refs: [policyRef], details: { index } },
+				),
+			);
+		}
+		if (
+			limit.softLimit !== undefined &&
+			(typeof limit.softLimit !== "number" ||
+				!Number.isFinite(limit.softLimit) ||
+				limit.softLimit < 0)
+		) {
+			issues.push(
+				dataIssue(
+					"tool-provider-policy-invalid-size-limit",
+					"Tool provider size-capacity softLimit must be a finite non-negative number.",
+					{ subjectId: policyId, refs: [policyRef], details: { index, unit: limit.unit } },
+				),
+			);
+		}
+		if (
+			limit.hardLimit !== undefined &&
+			(typeof limit.hardLimit !== "number" ||
+				!Number.isFinite(limit.hardLimit) ||
+				limit.hardLimit < 0)
+		) {
+			issues.push(
+				dataIssue(
+					"tool-provider-policy-invalid-size-limit",
+					"Tool provider size-capacity hardLimit must be a finite non-negative number.",
+					{ subjectId: policyId, refs: [policyRef], details: { index, unit: limit.unit } },
+				),
+			);
+		}
+		if (
+			typeof limit.softLimit === "number" &&
+			Number.isFinite(limit.softLimit) &&
+			typeof limit.hardLimit === "number" &&
+			Number.isFinite(limit.hardLimit) &&
+			limit.softLimit > limit.hardLimit
+		) {
+			issues.push(
+				dataIssue(
+					"tool-provider-policy-invalid-size-limit",
+					"Tool provider size-capacity softLimit must not exceed hardLimit.",
+					{ subjectId: policyId, refs: [policyRef], details: { index, unit: limit.unit } },
+				),
+			);
+		}
+	}
+	if (policy.timeout !== undefined && !isRecord(policy.timeout)) {
+		issues.push(
+			dataIssue(
+				"tool-provider-policy-invalid-timeout",
+				"Tool provider timeout policy must be a data object.",
+				{ subjectId: policyId, refs: [policyRef] },
+			),
+		);
+	}
+	for (const [field, value] of Object.entries(isRecord(policy.timeout) ? policy.timeout : {})) {
+		if (field.endsWith("TimeoutMs") || field === "timeoutMs") {
+			if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
+				issues.push(
+					dataIssue(
+						"tool-provider-policy-invalid-timeout",
+						"Tool provider timeout values must be finite non-negative numbers.",
+						{ subjectId: policyId, refs: [policyRef], details: { field } },
+					),
+				);
+			}
+		}
+	}
+	for (const forbidden of [
+		...forbiddenDataKeys(policy),
+		...forbiddenProviderRawMaterialKeys(policy),
+	]) {
+		issues.push(
+			dataIssue(
+				"tool-provider-policy-forbidden-runtime-material",
+				"Tool provider policy must not contain runtime-private adapter material.",
+				{ subjectId: policyId, refs: [policyRef], details: { reason: forbidden.reason } },
+			),
+		);
+	}
+	return Object.freeze(issues);
+}
+
+export function resolveToolProviderExecutionPolicies(opts: {
+	readonly request: AgentRequestIssued;
+	readonly routes?: readonly ExecutorRoute[];
+	readonly catalogs?: readonly ToolProviderCatalog[];
+}): readonly ToolProviderPolicyResolution[] {
+	const request = opts.request;
+	const toolCall = toolCallFromRequest(request);
+	const baseSourceRefs = Object.freeze([ref("agent-request", request.requestId)]);
+	if (toolCall === undefined) {
+		return Object.freeze([
+			Object.freeze({
+				kind: "tool-provider-policy-resolution",
+				resolutionId: `${request.requestId}:${request.operationId}:tool-policy:missing-tool-call`,
+				status: "missing-tool-call",
+				requestId: request.requestId,
+				operationId: request.operationId,
+				issues: Object.freeze([
+					dataIssue(
+						"tool-provider-policy-missing-tool-call",
+						"Tool provider policy resolution requires AgentRequest input.value to be a ToolCallInput.",
+						{ subjectId: request.requestId, refs: baseSourceRefs },
+					),
+				]),
+				sourceRefs: baseSourceRefs,
+			} satisfies ToolProviderPolicyResolution),
+		]);
+	}
+	const routes = (opts.routes ?? []).filter(
+		(route) => route.requestId === request.requestId && route.operationId === request.operationId,
+	);
+	if (routes.length === 0) {
+		return Object.freeze([
+			Object.freeze({
+				kind: "tool-provider-policy-resolution",
+				resolutionId: `${request.requestId}:${request.operationId}:tool-policy:pending-route`,
+				status: "pending-route",
+				requestId: request.requestId,
+				operationId: request.operationId,
+				toolName: toolCall.toolName,
+				operation: toolCall.operation,
+				sourceRefs: baseSourceRefs,
+			} satisfies ToolProviderPolicyResolution),
+		]);
+	}
+	return Object.freeze(
+		routes.map((route) =>
+			Object.freeze(
+				resolveToolProviderPolicyForRoute(request, route, toolCall, opts.catalogs ?? []),
+			),
+		),
+	);
+}
+
+export function toolProviderPolicyResolutionProjector(
+	graph: Graph,
+	opts: {
+		readonly name?: string;
+		readonly requestFacts: Node<AgentRequestFact>;
+		readonly executorRoutes?: readonly Node<ExecutorRoute>[];
+		readonly toolProviderCatalogs?: readonly Node<ToolProviderCatalog>[];
+	},
+): ToolProviderPolicyResolutionBundle {
+	const name = opts.name ?? "toolProviderPolicyResolution";
+	const routeDeps = opts.executorRoutes ?? [];
+	const catalogDeps = opts.toolProviderCatalogs ?? [];
+	const routeStart = 1;
+	const catalogStart = routeStart + routeDeps.length;
+	const runtime = graph.node<ToolProviderPolicyResolutionFact>(
+		[opts.requestFacts, ...routeDeps, ...catalogDeps],
+		(ctx) => {
+			const state = ctx.state.get<ToolProviderPolicyResolutionState>() ?? {
+				requests: new Map<string, AgentRequestIssued>(),
+				routes: new Map<string, ExecutorRoute>(),
+				catalogs: new Map<string, ToolProviderCatalog>(),
+				emittedKeys: new Set<string>(),
+				auditSeq: 0,
+			};
+			for (const raw of depBatch(ctx, 0) ?? []) {
+				const fact = raw as AgentRequestFact;
+				if (fact.kind === "issued" && fact.input?.inputKind === "tool-call") {
+					state.requests.set(fact.requestId, fact);
+				}
+			}
+			forEachDepBatch(ctx, routeStart, routeDeps.length, (raw) => {
+				const route = raw as ExecutorRoute;
+				state.routes.set(route.routeId, route);
+			});
+			forEachDepBatch(ctx, catalogStart, catalogDeps.length, (raw) => {
+				const catalog = raw as ToolProviderCatalog;
+				state.catalogs.set(catalog.providerId, catalog);
+			});
+			for (const request of state.requests.values()) {
+				const resolutions = resolveToolProviderExecutionPolicies({
+					request,
+					routes: Array.from(state.routes.values()),
+					catalogs: Array.from(state.catalogs.values()),
+				});
+				for (const resolution of resolutions) {
+					const key = stableToolProviderPolicyResolutionKey(resolution);
+					if (state.emittedKeys.has(key)) continue;
+					state.emittedKeys.add(key);
+					ctx.down([
+						["DATA", { kind: "resolution", resolution } satisfies ToolProviderPolicyResolutionFact],
+					]);
+					for (const issue of resolution.issues ?? []) {
+						ctx.down([
+							["DATA", { kind: "issue", issue } satisfies ToolProviderPolicyResolutionFact],
+						]);
+					}
+					state.auditSeq += 1;
+					ctx.down([
+						[
+							"DATA",
+							{
+								kind: "audit",
+								audit: {
+									id: `${name}:audit:${state.auditSeq}`,
+									kind: "tool-provider-policy-resolution",
+									subjectId: request.requestId,
+									sourceRefs: resolution.sourceRefs,
+									metadata: {
+										status: resolution.status,
+										routeId: resolution.routeId,
+										providerId: resolution.providerId,
+										profileId: resolution.profileId,
+										toolName: resolution.toolName,
+									},
+								},
+							} satisfies ToolProviderPolicyResolutionFact,
+						],
+					]);
+				}
+			}
+			ctx.state.set(state);
+		},
+		{ name: `${name}/runtime`, factory: "toolProviderPolicyResolutionProjector", partial: true },
+	);
+	const resolutions = projectRuntimeFact(
+		graph,
+		runtime,
+		`${name}/resolutions`,
+		"toolProviderPolicyResolutions",
+		(fact) => (fact.kind === "resolution" ? fact.resolution : undefined),
+	);
+	const issues = projectRuntimeFact(
+		graph,
+		runtime,
+		`${name}/issues`,
+		"toolProviderPolicyResolutionIssues",
+		(fact) => (fact.kind === "issue" ? fact.issue : undefined),
+	);
+	const audit = projectRuntimeFact(
+		graph,
+		runtime,
+		`${name}/audit`,
+		"toolProviderPolicyResolutionAudit",
+		(fact) => (fact.kind === "audit" ? fact.audit : undefined),
+	);
+	return { resolutions, issues, audit };
+}
+
+export type ToolProviderPolicyResolutionFact =
+	| { readonly kind: "resolution"; readonly resolution: ToolProviderPolicyResolution }
+	| { readonly kind: "issue"; readonly issue: DataIssue }
+	| { readonly kind: "audit"; readonly audit: AgentRuntimeAuditRecord };
+
+export interface ToolProviderPolicyResolutionState {
+	requests: Map<string, AgentRequestIssued>;
+	routes: Map<string, ExecutorRoute>;
+	catalogs: Map<string, ToolProviderCatalog>;
+	emittedKeys: Set<string>;
+	auditSeq: number;
+}
+
+export function isPublishableToolProviderExecutionPolicy(
+	policy: unknown,
+	providerId?: string,
+): policy is ToolProviderExecutionPolicy {
+	return (
+		isRecord(policy) &&
+		policy.kind === "tool-provider-execution-policy" &&
+		typeof policy.policyId === "string" &&
+		policy.policyId.length > 0 &&
+		typeof policy.providerId === "string" &&
+		policy.providerId.length > 0 &&
+		(providerId === undefined || policy.providerId === providerId) &&
+		validateToolProviderExecutionPolicy(policy).length === 0
+	);
+}
+
+export function validateToolProviderPolicyProviderScope(
+	policy: unknown,
+	providerId: string,
+): readonly DataIssue[] {
+	if (!isRecord(policy)) return [];
+	if (policy.providerId === undefined || policy.providerId === providerId) return [];
+	return Object.freeze([
+		dataIssue(
+			"tool-provider-policy-provider-mismatch",
+			"Tool provider policy providerId must match the catalog providerId.",
+			{
+				subjectId: typeof policy.policyId === "string" ? policy.policyId : undefined,
+				refs: [
+					ref(
+						"tool-provider-execution-policy",
+						typeof policy.policyId === "string" && policy.policyId.length > 0
+							? policy.policyId
+							: "<missing>",
+					),
+					ref("tool-provider-catalog", providerId),
+				],
+			},
+		),
+	]);
+}
+
+export function policyRefsForProfile(
+	policies: readonly ToolProviderExecutionPolicy[],
+	profileId: string,
+): readonly SourceRef[] {
+	return Object.freeze(
+		policies
+			.filter((policy) => policyAppliesToProfile(policy, profileId))
+			.map((policy) => ref("tool-provider-execution-policy", policy.policyId)),
+	);
+}
+
+export function policyRefsForTool(
+	policies: readonly ToolProviderExecutionPolicy[],
+	profileId: string,
+	tool: Omit<
+		ToolProviderCatalogEntry,
+		"kind" | "providerId" | "inputKind" | "profileId" | "executorId"
+	>,
+): readonly SourceRef[] {
+	return Object.freeze(
+		policies
+			.filter((policy) => policyAppliesToProfile(policy, profileId))
+			.filter((policy) => policyAppliesToOptionalScope(policy.toolNames, tool.toolName))
+			.filter((policy) => policyAppliesToOptionalScope(policy.operations, tool.operation))
+			.map((policy) => ref("tool-provider-execution-policy", policy.policyId)),
+	);
+}
+
+export function policyAppliesToProfile(
+	policy: ToolProviderExecutionPolicy,
+	profileId: string,
+): boolean {
+	return policyAppliesToOptionalScope(policy.profileIds, profileId);
+}
+
+export function policyAppliesToOptionalScope(
+	scope: readonly string[] | undefined,
+	value: string | undefined,
+): boolean {
+	return (
+		scope === undefined || scope.length === 0 || (value !== undefined && scope.includes(value))
+	);
+}
+
+export function toolCallFromRequest(request: AgentRequestIssued): ToolCallInput | undefined {
+	const value = request.input?.value;
+	if (request.input?.inputKind !== "tool-call" || !isRecord(value)) return undefined;
+	if (
+		value.kind !== "tool-call" ||
+		typeof value.toolName !== "string" ||
+		value.toolName.length === 0
+	) {
+		return undefined;
+	}
+	return value as unknown as ToolCallInput;
+}
+
+export function resolveToolProviderPolicyForRoute(
+	request: AgentRequestIssued,
+	route: ExecutorRoute,
+	toolCall: ToolCallInput,
+	catalogs: readonly ToolProviderCatalog[],
+): ToolProviderPolicyResolution {
+	const sourceRefs = Object.freeze([
+		ref("agent-request", request.requestId),
+		ref("executor-route", route.routeId),
+	]);
+	const matchingCatalogs = catalogs.filter((catalog) => catalogHasRouteProfile(catalog, route));
+	if (matchingCatalogs.length === 0) {
+		return policyResolutionWithIssue({
+			request,
+			route,
+			toolCall,
+			status: "missing-catalog",
+			sourceRefs,
+			issue: dataIssue(
+				"tool-provider-policy-missing-catalog",
+				`No tool provider catalog exposes route profile '${route.profileId}'.`,
+				{ subjectId: request.requestId, refs: sourceRefs },
+			),
+		});
+	}
+	if (matchingCatalogs.length > 1) {
+		return policyResolutionWithIssue({
+			request,
+			route,
+			toolCall,
+			status: "ambiguous-catalog",
+			sourceRefs,
+			issue: dataIssue(
+				"tool-provider-policy-ambiguous-catalog",
+				`Multiple tool provider catalogs expose route profile '${route.profileId}'.`,
+				{
+					subjectId: request.requestId,
+					refs: [
+						...sourceRefs,
+						...matchingCatalogs.map((catalog) => ref("tool-provider-catalog", catalog.providerId)),
+					],
+				},
+			),
+		});
+	}
+	const catalog = matchingCatalogs[0];
+	if (catalog === undefined) throw new Error("unreachable catalog match");
+	const tool = catalog.tools.find(
+		(entry) =>
+			entry.profileId === route.profileId &&
+			entry.executorId === route.executorId &&
+			entry.toolName === toolCall.toolName &&
+			(entry.operation === undefined ||
+				toolCall.operation === undefined ||
+				entry.operation === toolCall.operation),
+	);
+	if (tool === undefined) {
+		return policyResolutionWithIssue({
+			request,
+			route,
+			toolCall,
+			status: "missing-tool",
+			sourceRefs,
+			providerId: catalog.providerId,
+			issue: dataIssue(
+				"tool-provider-policy-missing-tool",
+				`Tool provider catalog '${catalog.providerId}' does not expose requested tool '${toolCall.toolName}'.`,
+				{
+					subjectId: request.requestId,
+					refs: [...sourceRefs, ref("tool-provider-catalog", catalog.providerId)],
+				},
+			),
+		});
+	}
+	const policyRefs = policyRefsForResolution(catalog, route, tool);
+	if (policyRefs.length === 0) {
+		return policyResolutionWithIssue({
+			request,
+			route,
+			toolCall,
+			status: "missing-policy",
+			sourceRefs,
+			providerId: catalog.providerId,
+			issue: dataIssue(
+				"tool-provider-policy-missing-policy-ref",
+				`Tool '${tool.toolName}' has no D360 policy refs on its entry, profile, or catalog.`,
+				{
+					subjectId: request.requestId,
+					refs: [...sourceRefs, ref("tool-provider-catalog", catalog.providerId)],
+				},
+			),
+		});
+	}
+	const issues = policyIssuesForRefs(catalog, policyRefs, request, sourceRefs);
+	const status = issues.length === 0 ? "resolved" : "invalid-policy";
+	return Object.freeze({
+		kind: "tool-provider-policy-resolution",
+		resolutionId: `${request.requestId}:${request.operationId}:${route.routeId}:tool-policy`,
+		status,
+		requestId: request.requestId,
+		operationId: request.operationId,
+		routeId: route.routeId,
+		providerId: catalog.providerId,
+		executorId: route.executorId,
+		profileId: route.profileId,
+		toolName: toolCall.toolName,
+		operation: toolCall.operation,
+		policyRefs,
+		issues: issues.length === 0 ? undefined : Object.freeze(issues),
+		sourceRefs: Object.freeze([...sourceRefs, ref("tool-provider-catalog", catalog.providerId)]),
+	} satisfies ToolProviderPolicyResolution);
+}
+
+export function catalogHasRouteProfile(
+	catalog: ToolProviderCatalog,
+	route: ExecutorRoute,
+): boolean {
+	return catalog.profiles.some(
+		(profile) => profile.profileId === route.profileId && profile.executorId === route.executorId,
+	);
+}
+
+export function policyRefsForResolution(
+	catalog: ToolProviderCatalog,
+	route: ExecutorRoute,
+	tool: ToolProviderCatalogEntry,
+): readonly SourceRef[] {
+	const profile = catalog.profiles.find(
+		(candidate) =>
+			candidate.profileId === route.profileId && candidate.executorId === route.executorId,
+	);
+	return Object.freeze([
+		...(tool.policyRefs ?? []),
+		...((tool.policyRefs?.length ?? 0) === 0 ? (profile?.policyRefs ?? []) : []),
+		...((tool.policyRefs?.length ?? 0) === 0 && (profile?.policyRefs?.length ?? 0) === 0
+			? (catalog.policyRefs ?? [])
+			: []),
+	]);
+}
+
+export function policyIssuesForRefs(
+	catalog: ToolProviderCatalog,
+	policyRefs: readonly SourceRef[],
+	request: AgentRequestIssued,
+	sourceRefs: readonly SourceRef[],
+): readonly DataIssue[] {
+	const policiesById = new Map((catalog.policies ?? []).map((policy) => [policy.policyId, policy]));
+	const issues: DataIssue[] = [];
+	for (const policyRef of policyRefs) {
+		if (policyRef.kind !== "tool-provider-execution-policy") {
+			issues.push(
+				dataIssue(
+					"tool-provider-policy-invalid-ref-kind",
+					"Tool provider policy refs must point at ToolProviderExecutionPolicy facts.",
+					{ subjectId: request.requestId, refs: [...sourceRefs, policyRef] },
+				),
+			);
+			continue;
+		}
+		const policy = policiesById.get(policyRef.id);
+		if (policy === undefined) {
+			issues.push(
+				dataIssue(
+					"tool-provider-policy-ref-missing-material",
+					`Tool provider policy ref '${policyRef.id}' has no policy material in catalog '${catalog.providerId}'.`,
+					{ subjectId: request.requestId, refs: [...sourceRefs, policyRef] },
+				),
+			);
+			continue;
+		}
+		issues.push(...validateToolProviderExecutionPolicy(policy));
+		issues.push(...validateToolProviderPolicyProviderScope(policy, catalog.providerId));
+	}
+	return Object.freeze(issues);
+}
+
+export function policyResolutionWithIssue(opts: {
+	readonly request: AgentRequestIssued;
+	readonly route: ExecutorRoute;
+	readonly toolCall: ToolCallInput;
+	readonly status: ToolProviderPolicyResolutionStatus;
+	readonly sourceRefs: readonly SourceRef[];
+	readonly issue: DataIssue;
+	readonly providerId?: string;
+}): ToolProviderPolicyResolution {
+	return Object.freeze({
+		kind: "tool-provider-policy-resolution",
+		resolutionId: `${opts.request.requestId}:${opts.request.operationId}:${opts.route.routeId}:tool-policy:${opts.status}`,
+		status: opts.status,
+		requestId: opts.request.requestId,
+		operationId: opts.request.operationId,
+		routeId: opts.route.routeId,
+		providerId: opts.providerId,
+		executorId: opts.route.executorId,
+		profileId: opts.route.profileId,
+		toolName: opts.toolCall.toolName,
+		operation: opts.toolCall.operation,
+		issues: Object.freeze([opts.issue]),
+		sourceRefs: opts.sourceRefs,
+	} satisfies ToolProviderPolicyResolution);
+}
+
+export function stableToolProviderPolicyResolutionKey(
+	resolution: ToolProviderPolicyResolution,
+): string {
+	return JSON.stringify({
+		id: resolution.resolutionId,
+		status: resolution.status,
+		policyRefs:
+			resolution.policyRefs?.map((policyRef) => `${policyRef.kind}:${policyRef.id}`) ?? [],
+		issues: resolution.issues?.map((issue) => issue.code) ?? [],
+	});
+}
+
+export function defaultLocalBuiltinToolProviderExecutionPolicy(opts: {
+	readonly providerId: string;
+	readonly profileId: string;
+	readonly tools: readonly Omit<
+		ToolProviderCatalogEntry,
+		"kind" | "providerId" | "inputKind" | "profileId" | "executorId"
+	>[];
+	readonly overrides?: Partial<
+		Omit<ToolProviderExecutionPolicy, "kind" | "policyId" | "providerId">
+	>;
+}): ToolProviderExecutionPolicy {
+	const toolNames = Object.freeze(Array.from(new Set(opts.tools.map((tool) => tool.toolName))));
+	const operations = Object.freeze(
+		Array.from(new Set(opts.tools.map((tool) => tool.operation).filter((op) => op !== undefined))),
+	);
+	const hasUrlFetch = toolNames.includes("url.fetch");
+	const filesystemToolNames = toolNames.filter(
+		(toolName) =>
+			toolName.startsWith("file.") || toolName.startsWith("document/") || toolName === "bash.run",
+	);
+	const approvalToolNames = toolNames.filter(
+		(toolName) => toolName === "file.edit/apply-patch" || toolName === "bash.run",
+	);
+	const approvalOperations = operations.filter(
+		(operation) => operation === "edit" || operation === "run",
+	);
+	const policy = {
+		kind: "tool-provider-execution-policy",
+		policyId: `${opts.providerId}:policy:default`,
+		providerId: opts.providerId,
+		profileIds: Object.freeze([opts.profileId]),
+		toolNames,
+		operations,
+		sizeCapacity: Object.freeze({
+			limits: Object.freeze([
+				Object.freeze({
+					unit: "chars",
+					softLimit: 16_384,
+					hardLimit: 65_536,
+					perRequest: true,
+					measurementSource: "adapter-estimated",
+				} satisfies ToolProviderSizeLimit),
+				Object.freeze({
+					unit: "bytes",
+					softLimit: 1_048_576,
+					hardLimit: 8_388_608,
+					perArtifact: true,
+					measurementSource: "adapter-measured",
+				} satisfies ToolProviderSizeLimit),
+				Object.freeze({
+					unit: "lines",
+					softLimit: 2_000,
+					hardLimit: 10_000,
+					perStream: true,
+					measurementSource: "adapter-measured",
+				} satisfies ToolProviderSizeLimit),
+			]),
+		} satisfies ToolProviderSizeCapacityPolicy),
+		timeout: Object.freeze({
+			timeoutMs: 30_000,
+			idleTimeoutMs: 5_000,
+		} satisfies ToolProviderTimeoutPolicy),
+		redaction: Object.freeze({
+			mode: "summary",
+			sensitivity: Object.freeze(["private-material", "auth-material", "personal-data"]),
+			summaryMaxChars: 512,
+		} satisfies ToolProviderRedactionPolicy),
+		...(filesystemToolNames.length > 0
+			? {
+					filesystem: Object.freeze({
+						cwd: ".",
+						allowRead: true,
+						allowWrite: false,
+						followSymlinks: false,
+						sourceRefs: Object.freeze(filesystemToolNames.map((toolName) => ref("tool", toolName))),
+						pathRules: Object.freeze([
+							Object.freeze({
+								effect: "allow",
+								path: ".",
+								operation: "read",
+								reason: "Default local builtin catalog is workspace-relative data material.",
+							} satisfies ToolProviderPathRule),
+							Object.freeze({
+								effect: "deny",
+								glob: "**/.env*",
+								reason: "D360 policies keep private material outside catalog DATA.",
+							} satisfies ToolProviderPathRule),
+						]),
+					} satisfies ToolProviderFilesystemPolicy),
+				}
+			: {}),
+		...(hasUrlFetch
+			? {
+					network: Object.freeze({
+						mode: "custom",
+						protocols: Object.freeze(["https:"]),
+						allowedHosts: Object.freeze(["*"]),
+						sourceRefs: Object.freeze([ref("tool", "url.fetch")]),
+					} satisfies ToolProviderNetworkPolicy),
+				}
+			: {}),
+		approval: Object.freeze({
+			mode: approvalToolNames.length > 0 ? "require" : "auto",
+			...(approvalToolNames.length > 0
+				? { requiredForToolNames: Object.freeze(approvalToolNames) }
+				: {}),
+			...(approvalOperations.length > 0
+				? { requiredForOperations: Object.freeze(approvalOperations) }
+				: {}),
+		} satisfies ToolProviderApprovalPolicy),
+		artifacts: Object.freeze({
+			defaultDataMode: "summary",
+			artifactKinds: Object.freeze([
+				"text",
+				"markdown",
+				"file",
+				"stdout",
+				"stderr",
+				"tool-output",
+				"provider-raw",
+			]),
+			inlineLimits: Object.freeze([
+				Object.freeze({
+					unit: "chars",
+					hardLimit: 4_096,
+					perArtifact: true,
+					measurementSource: "adapter-estimated",
+				} satisfies ToolProviderSizeLimit),
+			]),
+			requireDigest: false,
+		} satisfies ToolProviderArtifactPolicy),
+		sourceRefs: Object.freeze([ref("decision", "D360"), ref("tool-provider", opts.providerId)]),
+		metadata: Object.freeze({
+			description: "Default data-only policy material for local builtin tools.",
+		}),
+		...unlockedToolProviderPolicyOverrides(opts.overrides),
+	} satisfies ToolProviderExecutionPolicy;
+	return Object.freeze(policy);
+}
diff --git a/packages/ts/src/orchestration/agent-runtime-tool-provider-run-admission.ts b/packages/ts/src/orchestration/agent-runtime-tool-provider-run-admission.ts
new file mode 100644
index 00000000..230fe72b
--- /dev/null
+++ b/packages/ts/src/orchestration/agent-runtime-tool-provider-run-admission.ts
@@ -0,0 +1,703 @@
+import { depBatch } from "../ctx/types.js";
+import type { DataIssue } from "../data/index.js";
+import type { Graph } from "../graph/graph.js";
+import type { Node } from "../node/node.js";
+import {
+	requestToolProviderAdapterRun,
+	runRequestIdentityIssues,
+} from "./agent-runtime-adapter-run.js";
+import {
+	dataIssue,
+	forEachDepBatch,
+	projectRuntimeFact,
+	ref,
+	sanitizeAdapterInputSourceRefs,
+	sanitizeProviderGraphVisibleRecord,
+	uniqueSourceRefs,
+} from "./agent-runtime-common.js";
+import type { AgentNeed, AgentRuntimeAuditRecord } from "./agent-runtime-types-agent.js";
+import type { SourceRef } from "./agent-runtime-types-core.js";
+import type {
+	ToolProviderAdapterInput,
+	ToolProviderAdapterRunRequested,
+	ToolProviderApprovalPolicy,
+	ToolProviderExecutionPolicy,
+	ToolProviderRunAdmission,
+	ToolProviderRunAdmissionBundle,
+	ToolProviderRunAdmissionDecision,
+	ToolProviderRunAdmissionOutcome,
+	ToolProviderRunAdmissionProposal,
+	ToolProviderRunAdmissionState,
+	ToolProviderRunAdmissionStatus,
+	ToolProviderRunAdmissionViews,
+} from "./agent-runtime-types-tool.js";
+
+export function toolProviderRunAdmissionProjector(
+	graph: Graph,
+	opts: {
+		readonly name?: string;
+		readonly inputs: Node<ToolProviderAdapterInput>;
+		readonly runRequests: readonly Node<ToolProviderAdapterRunRequested>[];
+		readonly decisions?: readonly Node<ToolProviderRunAdmissionDecision>[];
+		readonly now?: () => number;
+	},
+): ToolProviderRunAdmissionBundle {
+	const name = opts.name ?? "toolProviderRunAdmission";
+	const decisionDeps = opts.decisions ?? [];
+	const runtime = graph.node<ToolProviderRunAdmissionFact>(
+		[opts.inputs, ...opts.runRequests, ...decisionDeps],
+		(ctx) => {
+			const state = ctx.state.get<ToolProviderRunAdmissionProjectorState>() ?? {
+				inputs: new Map<string, ToolProviderAdapterInput>(),
+				proposalsById: new Map<string, InternalAdmissionProposal>(),
+				proposalsByRun: new Map<string, ToolProviderRunAdmissionProposal[]>(),
+				decisionsByProposal: new Map<string, ToolProviderRunAdmissionDecision>(),
+				admissionsByProposal: new Map<string, ToolProviderRunAdmission>(),
+				admissionsByRun: new Map<string, ToolProviderRunAdmission[]>(),
+				proposalKeys: new Set<string>(),
+				admissionKeys: new Set<string>(),
+				approvedRunKeys: new Set<string>(),
+				statusKeys: new Set<string>(),
+				issueKeys: new Set<string>(),
+				auditSeq: 0,
+			};
+			for (const raw of depBatch(ctx, 0) ?? []) {
+				const input = raw as ToolProviderAdapterInput;
+				state.inputs.set(input.adapterInputId, input);
+			}
+			forEachDepBatch(ctx, 1, opts.runRequests.length, (raw) => {
+				const request = raw as ToolProviderAdapterRunRequested;
+				const input = state.inputs.get(request.adapterInputId);
+				if (input === undefined) {
+					emitAdmissionIssue(
+						ctx,
+						state,
+						dataIssue(
+							"tool-provider-run-admission-missing-input",
+							"Tool provider run admission request references an unknown adapter input.",
+							{
+								subjectId: request.adapterInputId,
+								refs: sanitizeAdapterInputSourceRefs([
+									ref("tool-provider-adapter-run", request.runId),
+									...(request.sourceRefs ?? []),
+								]),
+							},
+						),
+					);
+					emitAdmissionStatus(ctx, state, {
+						kind: "tool-provider-run-admission-status",
+						proposalId: `${request.runId}:admission-proposal`,
+						runId: request.runId,
+						adapterInputId: request.adapterInputId,
+						requestId: request.requestId,
+						operationId: request.operationId,
+						state: "issue",
+						sourceRefs: request.sourceRefs,
+					});
+					return;
+				}
+				handleRunRequest(ctx, state, input, request, opts.now);
+			});
+			forEachDepBatch(ctx, 1 + opts.runRequests.length, decisionDeps.length, (raw) => {
+				const decision = sanitizeAdmissionDecision(raw as ToolProviderRunAdmissionDecision);
+				state.decisionsByProposal.set(decision.proposalId, decision);
+				const internal = state.proposalsById.get(decision.proposalId);
+				if (internal !== undefined) applyDecision(ctx, state, internal, decision, opts.now);
+			});
+			ctx.down([["DATA", { kind: "views", views: buildAdmissionViews(state) }]]);
+			ctx.state.set(state);
+		},
+		{ name: `${name}/runtime`, factory: "toolProviderRunAdmissionProjector", partial: true },
+	);
+	return {
+		proposals: projectRuntimeFact(
+			graph,
+			runtime,
+			`${name}/proposals`,
+			"toolProviderRunAdmissionProposals",
+			(fact) => (fact.kind === "proposal" ? fact.proposal : undefined),
+		),
+		admissions: projectRuntimeFact(
+			graph,
+			runtime,
+			`${name}/admissions`,
+			"toolProviderRunAdmissions",
+			(fact) => (fact.kind === "admission" ? fact.admission : undefined),
+		),
+		approvedRunRequests: projectRuntimeFact(
+			graph,
+			runtime,
+			`${name}/approvedRunRequests`,
+			"toolProviderRunAdmissionApprovedRunRequests",
+			(fact) => (fact.kind === "approved-run-request" ? fact.request : undefined),
+		),
+		status: projectRuntimeFact(
+			graph,
+			runtime,
+			`${name}/status`,
+			"toolProviderRunAdmissionStatus",
+			(fact) => (fact.kind === "status" ? fact.status : undefined),
+		),
+		issues: projectRuntimeFact(
+			graph,
+			runtime,
+			`${name}/issues`,
+			"toolProviderRunAdmissionIssues",
+			(fact) => (fact.kind === "issue" ? fact.issue : undefined),
+		),
+		audit: projectRuntimeFact(
+			graph,
+			runtime,
+			`${name}/audit`,
+			"toolProviderRunAdmissionAudit",
+			(fact) => (fact.kind === "audit" ? fact.audit : undefined),
+		),
+		views: projectRuntimeFact(
+			graph,
+			runtime,
+			`${name}/views`,
+			"toolProviderRunAdmissionViews",
+			(fact) => (fact.kind === "views" ? fact.views : undefined),
+		),
+	};
+}
+
+type ToolProviderRunAdmissionFact =
+	| { readonly kind: "proposal"; readonly proposal: ToolProviderRunAdmissionProposal }
+	| { readonly kind: "admission"; readonly admission: ToolProviderRunAdmission }
+	| { readonly kind: "approved-run-request"; readonly request: ToolProviderAdapterRunRequested }
+	| { readonly kind: "status"; readonly status: ToolProviderRunAdmissionStatus }
+	| { readonly kind: "issue"; readonly issue: DataIssue }
+	| { readonly kind: "audit"; readonly audit: AgentRuntimeAuditRecord }
+	| { readonly kind: "views"; readonly views: ToolProviderRunAdmissionViews };
+
+interface InternalAdmissionProposal {
+	readonly proposal: ToolProviderRunAdmissionProposal;
+	readonly request: ToolProviderAdapterRunRequested;
+	readonly input: ToolProviderAdapterInput;
+}
+
+interface ToolProviderRunAdmissionProjectorState {
+	inputs: Map<string, ToolProviderAdapterInput>;
+	proposalsById: Map<string, InternalAdmissionProposal>;
+	proposalsByRun: Map<string, ToolProviderRunAdmissionProposal[]>;
+	decisionsByProposal: Map<string, ToolProviderRunAdmissionDecision>;
+	admissionsByProposal: Map<string, ToolProviderRunAdmission>;
+	admissionsByRun: Map<string, ToolProviderRunAdmission[]>;
+	proposalKeys: Set<string>;
+	admissionKeys: Set<string>;
+	approvedRunKeys: Set<string>;
+	statusKeys: Set<string>;
+	issueKeys: Set<string>;
+	auditSeq: number;
+}
+
+function handleRunRequest(
+	ctx: { down: (msgs: readonly ["DATA", ToolProviderRunAdmissionFact][]) => void },
+	state: ToolProviderRunAdmissionProjectorState,
+	input: ToolProviderAdapterInput,
+	request: ToolProviderAdapterRunRequested,
+	now: (() => number) | undefined,
+): void {
+	const issues = runRequestIdentityIssues(request, input);
+	if (input.status !== "ready") {
+		issues.push(
+			dataIssue(
+				"tool-provider-run-admission-input-not-ready",
+				"Tool provider run admission requires a ready adapter input.",
+				{
+					subjectId: input.requestId,
+					refs: [ref("tool-provider-adapter-input", input.adapterInputId)],
+					details: { status: input.status },
+				},
+			),
+		);
+	}
+	if (issues.length > 0) {
+		for (const issue of issues) emitAdmissionIssue(ctx, state, issue);
+		emitAdmissionStatus(ctx, state, {
+			kind: "tool-provider-run-admission-status",
+			proposalId: `${request.runId}:admission-proposal`,
+			runId: request.runId,
+			adapterInputId: request.adapterInputId,
+			requestId: request.requestId,
+			operationId: request.operationId,
+			state: "issue",
+			issues: Object.freeze(issues),
+			sourceRefs: request.sourceRefs,
+		});
+		emitAdmissionAudit(ctx, state, "tool-provider-run-admission-request-rejected", request, {
+			issueCodes: issues.map((issue) => issue.code),
+		});
+		return;
+	}
+	const approval = resolveApprovalPolicy(input);
+	const proposal = admissionProposal(input, request, approval);
+	const internal = { proposal, request, input };
+	state.proposalsById.set(proposal.proposalId, internal);
+	pushMapArrayBy(state.proposalsByRun, request.runId, proposal, (entry) => entry.proposalId);
+	emitProposal(ctx, state, proposal);
+	emitAdmissionAudit(ctx, state, "tool-provider-run-admission-proposed", proposal, {
+		approvalMode: proposal.approvalMode,
+	});
+	if (proposal.approvalMode === "auto") {
+		admit(ctx, state, internal, undefined, now);
+		return;
+	}
+	if (proposal.approvalMode === "never") {
+		recordAdmission(ctx, state, internal, "blocked", {
+			reason: "blocked by tool provider approval policy",
+			now,
+		});
+		return;
+	}
+	const decision = state.decisionsByProposal.get(proposal.proposalId);
+	if (decision === undefined) {
+		emitAdmissionStatus(ctx, state, {
+			kind: "tool-provider-run-admission-status",
+			proposalId: proposal.proposalId,
+			runId: request.runId,
+			adapterInputId: request.adapterInputId,
+			requestId: request.requestId,
+			operationId: request.operationId,
+			state: "waiting",
+			sourceRefs: proposal.sourceRefs,
+		});
+		return;
+	}
+	applyDecision(ctx, state, internal, decision, now);
+}
+
+function applyDecision(
+	ctx: { down: (msgs: readonly ["DATA", ToolProviderRunAdmissionFact][]) => void },
+	state: ToolProviderRunAdmissionProjectorState,
+	internal: InternalAdmissionProposal,
+	decision: ToolProviderRunAdmissionDecision,
+	now: (() => number) | undefined,
+): void {
+	const existing = state.admissionsByProposal.get(internal.proposal.proposalId);
+	if (existing !== undefined) {
+		if (existing.decisionId === decision.decisionId) return;
+		const issue = dataIssue(
+			"tool-provider-run-admission-duplicate-decision",
+			"Tool provider run admission proposal already has a terminal admission decision.",
+			{
+				subjectId: internal.input.requestId,
+				refs: admissionSourceRefs(internal, decision),
+				severity: "warning",
+				details: {
+					proposalId: internal.proposal.proposalId,
+					existingDecisionId: existing.decisionId,
+					rejectedDecisionId: decision.decisionId,
+				},
+			},
+		);
+		emitAdmissionIssue(ctx, state, issue);
+		emitAdmissionStatus(ctx, state, {
+			kind: "tool-provider-run-admission-status",
+			proposalId: internal.proposal.proposalId,
+			runId: internal.request.runId,
+			adapterInputId: internal.input.adapterInputId,
+			requestId: internal.input.requestId,
+			operationId: internal.input.operationId,
+			state: "issue",
+			issues: Object.freeze([issue]),
+			sourceRefs: admissionSourceRefs(internal, decision),
+		});
+		emitAdmissionAudit(ctx, state, "tool-provider-run-admission-duplicate-decision", decision, {
+			proposalId: internal.proposal.proposalId,
+			existingDecisionId: existing.decisionId,
+		});
+		return;
+	}
+	if (decision.outcome === "admit") {
+		admit(ctx, state, internal, decision, now);
+		return;
+	}
+	recordAdmission(ctx, state, internal, admissionStateForOutcome(decision.outcome), {
+		decision,
+		reason: decision.reason,
+		now,
+	});
+}
+
+function admit(
+	ctx: { down: (msgs: readonly ["DATA", ToolProviderRunAdmissionFact][]) => void },
+	state: ToolProviderRunAdmissionProjectorState,
+	internal: InternalAdmissionProposal,
+	decision: ToolProviderRunAdmissionDecision | undefined,
+	now: (() => number) | undefined,
+): void {
+	const approvedRunId =
+		decision?.approvedRunId ??
+		(decision === undefined
+			? `${internal.request.runId}:admitted`
+			: `${internal.request.runId}:admitted:${decision.decisionId}`);
+	const admission = recordAdmission(ctx, state, internal, "admitted", {
+		decision,
+		approvedRunId,
+		reason: decision?.reason,
+		now,
+	});
+	const approvedRequest = requestToolProviderAdapterRun(internal.input, {
+		runId: approvedRunId,
+		attempt: internal.request.attempt,
+		reason: internal.request.reason,
+		retryOfOutcomeId: internal.request.retryOfOutcomeId,
+		policyRefs: internal.request.policyRefs ?? internal.input.policyRefs,
+		sourceRefs: uniqueSourceRefs([
+			ref("tool-provider-adapter-run", internal.request.runId),
+			ref("tool-provider-run-admission-proposal", internal.proposal.proposalId),
+			ref("tool-provider-run-admission", admission.admissionId),
+			...(decision === undefined
+				? []
+				: [ref("tool-provider-run-admission-decision", decision.decisionId)]),
+			...(internal.request.sourceRefs ?? []),
+		]),
+		metadata: {
+			...(internal.request.metadata ?? {}),
+			approval: "granted",
+			approvalGranted: true,
+			admissionId: admission.admissionId,
+			proposalId: internal.proposal.proposalId,
+			approvedFromRunId: internal.request.runId,
+			...(decision === undefined ? {} : { decisionId: decision.decisionId }),
+		},
+		requestedAtMs: now?.(),
+	});
+	emitApprovedRunRequest(ctx, state, approvedRequest);
+	emitAdmissionAudit(
+		ctx,
+		state,
+		"tool-provider-run-admission-approved-run-requested",
+		{
+			proposalId: internal.proposal.proposalId,
+			runId: approvedRequest.runId,
+		},
+		{
+			approvedFromRunId: internal.request.runId,
+			decisionId: decision?.decisionId,
+		},
+	);
+}
+
+function recordAdmission(
+	ctx: { down: (msgs: readonly ["DATA", ToolProviderRunAdmissionFact][]) => void },
+	state: ToolProviderRunAdmissionProjectorState,
+	internal: InternalAdmissionProposal,
+	admissionState: ToolProviderRunAdmissionState,
+	opts: {
+		readonly decision?: ToolProviderRunAdmissionDecision;
+		readonly approvedRunId?: string;
+		readonly reason?: string;
+		readonly now?: (() => number) | undefined;
+	},
+): ToolProviderRunAdmission {
+	const admissionId = opts.decision?.admissionId ?? `${internal.proposal.proposalId}:admission`;
+	const sourceRefs = admissionSourceRefs(internal, opts.decision);
+	const admission: ToolProviderRunAdmission = Object.freeze({
+		kind: "tool-provider-run-admission",
+		admissionId,
+		proposalId: internal.proposal.proposalId,
+		runId: internal.request.runId,
+		adapterInputId: internal.input.adapterInputId,
+		requestId: internal.input.requestId,
+		operationId: internal.input.operationId,
+		state: admissionState,
+		...(opts.decision === undefined ? {} : { decisionId: opts.decision.decisionId }),
+		...(opts.approvedRunId === undefined ? {} : { approvedRunId: opts.approvedRunId }),
+		...(opts.reason === undefined ? {} : { reason: opts.reason }),
+		sourceRefs,
+		metadata: sanitizeProviderGraphVisibleRecord({
+			approvalMode: internal.proposal.approvalMode,
+			occurredAtMs: opts.now?.(),
+		}),
+	});
+	state.admissionsByProposal.set(admission.proposalId, admission);
+	pushMapArrayBy(state.admissionsByRun, admission.runId, admission, (entry) => entry.admissionId);
+	emitAdmission(ctx, state, admission);
+	if (admissionState === "blocked") {
+		emitAdmissionIssue(
+			ctx,
+			state,
+			dataIssue(
+				"tool-provider-run-admission-blocked",
+				"Tool provider run admission blocked the candidate run request.",
+				{
+					subjectId: internal.input.requestId,
+					refs: sourceRefs,
+					severity: "warning",
+					details: { approvalMode: internal.proposal.approvalMode },
+				},
+			),
+		);
+	}
+	emitAdmissionStatus(ctx, state, {
+		kind: "tool-provider-run-admission-status",
+		proposalId: admission.proposalId,
+		runId: admission.runId,
+		adapterInputId: admission.adapterInputId,
+		requestId: admission.requestId,
+		operationId: admission.operationId,
+		state: admission.state,
+		admissionId: admission.admissionId,
+		...(admission.decisionId === undefined ? {} : { decisionId: admission.decisionId }),
+		...(admission.approvedRunId === undefined ? {} : { approvedRunId: admission.approvedRunId }),
+		sourceRefs,
+	});
+	emitAdmissionAudit(ctx, state, `tool-provider-run-admission-${admissionState}`, admission, {
+		decisionId: opts.decision?.decisionId,
+	});
+	return admission;
+}
+
+function admissionProposal(
+	input: ToolProviderAdapterInput,
+	request: ToolProviderAdapterRunRequested,
+	approval: ResolvedApprovalPolicy,
+): ToolProviderRunAdmissionProposal {
+	const sourceRefs = uniqueSourceRefs([
+		ref("tool-provider-adapter-run", request.runId),
+		ref("tool-provider-adapter-input", input.adapterInputId),
+		...(request.sourceRefs ?? []),
+		...(input.sourceRefs ?? []),
+		...(approval.policy?.approval?.sourceRefs ?? []),
+		...(approval.policy?.sourceRefs ?? []),
+	]);
+	return Object.freeze({
+		kind: "tool-provider-run-admission-proposal",
+		proposalId: `${request.runId}:admission-proposal`,
+		runId: request.runId,
+		adapterInputId: input.adapterInputId,
+		requestId: input.requestId,
+		operationId: input.operationId,
+		routeId: input.routeId,
+		providerId: input.providerId,
+		executorId: input.executorId,
+		profileId: input.profileId,
+		toolName: input.toolName,
+		operation: input.operation,
+		attempt: request.attempt,
+		reason: request.reason,
+		approvalMode: approval.mode,
+		policyRefs: sanitizeAdapterInputSourceRefs([
+			...(request.policyRefs ?? []),
+			...(input.policyRefs ?? []),
+			...(approval.policy === undefined
+				? []
+				: [ref("tool-provider-execution-policy", approval.policy.policyId)]),
+		]),
+		sourceRefs: sanitizeAdapterInputSourceRefs(sourceRefs),
+		needs:
+			approval.mode === "require" || approval.mode === "custom"
+				? approvalNeeds(approval.policy?.approval)
+				: undefined,
+		metadata: sanitizeProviderGraphVisibleRecord({
+			approvalPolicyId: approval.policy?.policyId,
+			approvalMode: approval.mode,
+		}),
+	});
+}
+
+function resolveApprovalPolicy(input: ToolProviderAdapterInput): ResolvedApprovalPolicy {
+	for (const policy of input.policies ?? []) {
+		const approval = policy.approval;
+		const mode = approval?.mode ?? "auto";
+		if (matchesApprovalSelector(input, approval)) return { mode, policy };
+	}
+	return { mode: "auto" };
+}
+
+interface ResolvedApprovalPolicy {
+	readonly mode: "auto" | "require" | "never" | "custom" | (string & {});
+	readonly policy?: ToolProviderExecutionPolicy;
+}
+
+function matchesApprovalSelector(
+	input: ToolProviderAdapterInput,
+	approval: ToolProviderApprovalPolicy | undefined,
+): boolean {
+	if (approval === undefined) return true;
+	const names = approval.requiredForToolNames;
+	const operations = approval.requiredForOperations;
+	const matchesName =
+		names === undefined || (input.toolName !== undefined && names.includes(input.toolName));
+	const matchesOperation =
+		operations === undefined ||
+		(input.operation !== undefined && operations.includes(input.operation));
+	return matchesName && matchesOperation;
+}
+
+function approvalNeeds(approval: ToolProviderApprovalPolicy | undefined): readonly AgentNeed[] {
+	return Object.freeze([
+		{
+			kind: "approval",
+			message: "Tool provider run requires graph-visible admission.",
+			refs: sanitizeAdapterInputSourceRefs(approval?.approverRefs ?? []),
+			metadata: sanitizeProviderGraphVisibleRecord({ approvalMode: approval?.mode ?? "require" }),
+		},
+	]);
+}
+
+function admissionStateForOutcome(
+	outcome: ToolProviderRunAdmissionOutcome,
+): ToolProviderRunAdmissionState {
+	if (outcome === "admit") return "admitted";
+	if (outcome === "defer") return "deferred";
+	return "blocked";
+}
+
+function admissionSourceRefs(
+	internal: InternalAdmissionProposal,
+	decision: ToolProviderRunAdmissionDecision | undefined,
+): readonly SourceRef[] {
+	return sanitizeAdapterInputSourceRefs([
+		ref("tool-provider-run-admission-proposal", internal.proposal.proposalId),
+		ref("tool-provider-adapter-run", internal.request.runId),
+		ref("tool-provider-adapter-input", internal.input.adapterInputId),
+		...(decision === undefined
+			? []
+			: [ref("tool-provider-run-admission-decision", decision.decisionId)]),
+		...(decision?.sourceRefs ?? []),
+	]);
+}
+
+function sanitizeAdmissionDecision(
+	decision: ToolProviderRunAdmissionDecision,
+): ToolProviderRunAdmissionDecision {
+	return Object.freeze({
+		kind: "tool-provider-run-admission-decision",
+		decisionId: decision.decisionId,
+		proposalId: decision.proposalId,
+		admissionId: decision.admissionId,
+		outcome: decision.outcome,
+		...(decision.approvedRunId === undefined ? {} : { approvedRunId: decision.approvedRunId }),
+		...(decision.reason === undefined ? {} : { reason: decision.reason }),
+		...(decision.decidedByRef === undefined
+			? {}
+			: { decidedByRef: sanitizeAdapterInputSourceRefs([decision.decidedByRef])[0] }),
+		...(decision.sourceRefs === undefined
+			? {}
+			: { sourceRefs: sanitizeAdapterInputSourceRefs(decision.sourceRefs) }),
+		metadata: sanitizeProviderGraphVisibleRecord(decision.metadata),
+	});
+}
+
+function emitProposal(
+	ctx: { down: (msgs: readonly ["DATA", ToolProviderRunAdmissionFact][]) => void },
+	state: ToolProviderRunAdmissionProjectorState,
+	proposal: ToolProviderRunAdmissionProposal,
+): void {
+	const key = `proposal:${proposal.proposalId}`;
+	if (state.proposalKeys.has(key)) return;
+	state.proposalKeys.add(key);
+	ctx.down([["DATA", { kind: "proposal", proposal }]]);
+}
+
+function emitAdmission(
+	ctx: { down: (msgs: readonly ["DATA", ToolProviderRunAdmissionFact][]) => void },
+	state: ToolProviderRunAdmissionProjectorState,
+	admission: ToolProviderRunAdmission,
+): void {
+	const key = `admission:${admission.admissionId}:${admission.state}:${admission.decisionId ?? ""}:${admission.approvedRunId ?? ""}`;
+	if (state.admissionKeys.has(key)) return;
+	state.admissionKeys.add(key);
+	ctx.down([["DATA", { kind: "admission", admission }]]);
+}
+
+function emitApprovedRunRequest(
+	ctx: { down: (msgs: readonly ["DATA", ToolProviderRunAdmissionFact][]) => void },
+	state: ToolProviderRunAdmissionProjectorState,
+	request: ToolProviderAdapterRunRequested,
+): void {
+	const key = `approved-run:${request.runId}`;
+	if (state.approvedRunKeys.has(key)) return;
+	state.approvedRunKeys.add(key);
+	ctx.down([["DATA", { kind: "approved-run-request", request }]]);
+}
+
+function emitAdmissionStatus(
+	ctx: { down: (msgs: readonly ["DATA", ToolProviderRunAdmissionFact][]) => void },
+	state: ToolProviderRunAdmissionProjectorState,
+	status: ToolProviderRunAdmissionStatus,
+): void {
+	const key = `status:${status.proposalId}:${status.state}:${status.admissionId ?? ""}:${status.decisionId ?? ""}:${status.approvedRunId ?? ""}`;
+	if (state.statusKeys.has(key)) return;
+	state.statusKeys.add(key);
+	ctx.down([["DATA", { kind: "status", status }]]);
+}
+
+function emitAdmissionIssue(
+	ctx: { down: (msgs: readonly ["DATA", ToolProviderRunAdmissionFact][]) => void },
+	state: ToolProviderRunAdmissionProjectorState,
+	issue: DataIssue,
+): void {
+	const key = `issue:${issue.code}:${issue.subjectId ?? ""}:${JSON.stringify(issue.details ?? {})}`;
+	if (state.issueKeys.has(key)) return;
+	state.issueKeys.add(key);
+	ctx.down([["DATA", { kind: "issue", issue }]]);
+}
+
+function emitAdmissionAudit(
+	ctx: { down: (msgs: readonly ["DATA", ToolProviderRunAdmissionFact][]) => void },
+	state: ToolProviderRunAdmissionProjectorState,
+	kind: string,
+	subject: unknown,
+	metadata?: Record<string, unknown>,
+): void {
+	state.auditSeq += 1;
+	ctx.down([
+		[
+			"DATA",
+			{
+				kind: "audit",
+				audit: Object.freeze({
+					id: `tool-provider-run-admission-audit-${state.auditSeq}`,
+					kind,
+					message: kind,
+					sourceRefs: [],
+					metadata: sanitizeProviderGraphVisibleRecord({
+						...metadata,
+						subject,
+					}),
+				} satisfies AgentRuntimeAuditRecord),
+			},
+		],
+	]);
+}
+
+function buildAdmissionViews(
+	state: ToolProviderRunAdmissionProjectorState,
+): ToolProviderRunAdmissionViews {
+	return Object.freeze({
+		admissionsByProposal: new Map(state.admissionsByProposal),
+		admissionsByRun: new Map(
+			Array.from(state.admissionsByRun.entries()).map(([key, value]) => [
+				key,
+				Object.freeze([...value]),
+			]),
+		),
+		proposalsByRun: new Map(
+			Array.from(state.proposalsByRun.entries()).map(([key, value]) => [
+				key,
+				Object.freeze([...value]),
+			]),
+		),
+	});
+}
+
+function pushMapArrayBy<T>(
+	map: Map<string, T[]>,
+	key: string,
+	value: T,
+	entryKey: (entry: T) => string,
+): void {
+	const existing = map.get(key);
+	if (existing === undefined) {
+		map.set(key, [value]);
+		return;
+	}
+	const valueKey = entryKey(value);
+	if (existing.some((entry) => entryKey(entry) === valueKey)) return;
+	existing.push(value);
+}
diff --git a/packages/ts/src/orchestration/agent-runtime-tool-provider-run-retry.ts b/packages/ts/src/orchestration/agent-runtime-tool-provider-run-retry.ts
new file mode 100644
index 00000000..f74e27f1
--- /dev/null
+++ b/packages/ts/src/orchestration/agent-runtime-tool-provider-run-retry.ts
@@ -0,0 +1,1019 @@
+import { depBatch } from "../ctx/types.js";
+import type { DataIssue } from "../data/index.js";
+import type { Graph } from "../graph/graph.js";
+import type { RetryPolicy } from "../graph/resilience.js";
+import { nextRetryDelayMs, shouldRetry } from "../graph/resilience.js";
+import type { Node } from "../node/node.js";
+import { requestToolProviderAdapterRun } from "./agent-runtime-adapter-run.js";
+import {
+	dataIssue,
+	forEachDepBatch,
+	isRecord,
+	projectRuntimeFact,
+	ref,
+	sanitizeAdapterInputIssue,
+	sanitizeAdapterInputSourceRefs,
+	sanitizeProviderGraphVisibleRecord,
+	uniqueSourceRefs,
+} from "./agent-runtime-common.js";
+import type { AgentRuntimeAuditRecord } from "./agent-runtime-types-agent.js";
+import type { ExecutorOutcome, SourceRef } from "./agent-runtime-types-core.js";
+import type {
+	ToolProviderAdapterInput,
+	ToolProviderAdapterRunRequested,
+	ToolProviderRunRetryBundle,
+	ToolProviderRunRetryPolicy,
+	ToolProviderRunRetryProposal,
+	ToolProviderRunRetryScheduled,
+	ToolProviderRunRetryStatus,
+	ToolProviderRunRetryStatusState,
+	ToolProviderRunRetryViews,
+} from "./agent-runtime-types-tool.js";
+import type {
+	ScheduledReadinessReady,
+	ScheduledReadinessRequested,
+} from "./scheduled-readiness.js";
+
+export function toolProviderRunRetryProjector(
+	graph: Graph,
+	opts: {
+		readonly name?: string;
+		readonly inputs: Node<ToolProviderAdapterInput>;
+		readonly outcomes: Node<ExecutorOutcome>;
+		readonly policies?: readonly Node<ToolProviderRunRetryPolicy>[];
+		readonly nowMs?: Node<number>;
+		readonly readiness?: readonly Node<ScheduledReadinessReady>[];
+	},
+): ToolProviderRunRetryBundle {
+	const name = opts.name ?? "toolProviderRunRetry";
+	const policyDeps = opts.policies ?? [];
+	const nowDeps = opts.nowMs === undefined ? [] : [opts.nowMs];
+	const readinessDeps = opts.readiness ?? [];
+	const outcomeDepIndex = 1 + policyDeps.length;
+	const nowDepIndex = outcomeDepIndex + 1;
+	const readinessDepStart = nowDepIndex + nowDeps.length;
+	const runtime = graph.node<ToolProviderRunRetryFact>(
+		[opts.inputs, ...policyDeps, opts.outcomes, ...nowDeps, ...readinessDeps],
+		(ctx) => {
+			const state = ctx.state.get<ToolProviderRunRetryProjectorState>() ?? initialRetryState();
+			state.usesSharedReadiness = readinessDeps.length > 0;
+			for (const raw of depBatch(ctx, 0) ?? []) {
+				const input = raw as ToolProviderAdapterInput;
+				state.inputsById.set(input.adapterInputId, input);
+				let inputIds = state.inputIdsByRequest.get(input.requestId);
+				if (inputIds === undefined) {
+					inputIds = new Set();
+					state.inputIdsByRequest.set(input.requestId, inputIds);
+				}
+				inputIds.add(input.adapterInputId);
+			}
+			forEachDepBatch(ctx, 1, policyDeps.length, (raw) => {
+				const policy = sanitizeToolProviderRunRetryPolicy(raw as ToolProviderRunRetryPolicy);
+				state.policies.set(policy.policyId, policy);
+			});
+			for (const rawNow of depBatch(ctx, nowDepIndex) ?? []) {
+				if (typeof rawNow === "number" && Number.isFinite(rawNow)) state.nowMs = rawNow;
+			}
+			forEachDepBatch(ctx, readinessDepStart, readinessDeps.length, (raw) => {
+				const ready = sanitizeRetryReadinessReady(raw);
+				if (!ready.ok) {
+					emitIssue(ctx, state, ready.issue);
+					return;
+				}
+				state.readinessBySchedule.set(ready.scheduleId, ready);
+			});
+			for (const raw of depBatch(ctx, outcomeDepIndex) ?? []) {
+				retainOutcome(state, raw as ExecutorOutcome);
+			}
+			evaluateOutcomes(ctx, state);
+			processDueRetries(ctx, state);
+			ctx.down([["DATA", { kind: "views", views: buildRetryViews(state) }]]);
+			ctx.state.set(state);
+		},
+		{ name: `${name}/runtime`, factory: "toolProviderRunRetryProjector", partial: true },
+	);
+	return {
+		proposals: projectRuntimeFact(
+			graph,
+			runtime,
+			`${name}/proposals`,
+			"toolProviderRunRetryProposals",
+			(fact) => (fact.kind === "proposal" ? fact.proposal : undefined),
+		),
+		scheduled: projectRuntimeFact(
+			graph,
+			runtime,
+			`${name}/scheduled`,
+			"toolProviderRunRetryScheduled",
+			(fact) => (fact.kind === "scheduled" ? fact.scheduled : undefined),
+		),
+		readinessSchedules: projectRuntimeFact(
+			graph,
+			runtime,
+			`${name}/readinessSchedules`,
+			"toolProviderRunRetryReadinessSchedules",
+			(fact) => (fact.kind === "readiness-schedule" ? fact.schedule : undefined),
+		),
+		runRequests: projectRuntimeFact(
+			graph,
+			runtime,
+			`${name}/runRequests`,
+			"toolProviderRunRetryRunRequests",
+			(fact) => (fact.kind === "run-request" ? fact.request : undefined),
+		),
+		status: projectRuntimeFact(
+			graph,
+			runtime,
+			`${name}/status`,
+			"toolProviderRunRetryStatus",
+			(fact) => (fact.kind === "status" ? fact.status : undefined),
+		),
+		issues: projectRuntimeFact(
+			graph,
+			runtime,
+			`${name}/issues`,
+			"toolProviderRunRetryIssues",
+			(fact) => (fact.kind === "issue" ? fact.issue : undefined),
+		),
+		audit: projectRuntimeFact(
+			graph,
+			runtime,
+			`${name}/audit`,
+			"toolProviderRunRetryAudit",
+			(fact) => (fact.kind === "audit" ? fact.audit : undefined),
+		),
+		views: projectRuntimeFact(
+			graph,
+			runtime,
+			`${name}/views`,
+			"toolProviderRunRetryViews",
+			(fact) => (fact.kind === "views" ? fact.views : undefined),
+		),
+	};
+}
+
+type ToolProviderRunRetryFact =
+	| { readonly kind: "proposal"; readonly proposal: ToolProviderRunRetryProposal }
+	| { readonly kind: "scheduled"; readonly scheduled: ToolProviderRunRetryScheduled }
+	| { readonly kind: "readiness-schedule"; readonly schedule: ScheduledReadinessRequested }
+	| { readonly kind: "run-request"; readonly request: ToolProviderAdapterRunRequested }
+	| { readonly kind: "status"; readonly status: ToolProviderRunRetryStatus }
+	| { readonly kind: "issue"; readonly issue: DataIssue }
+	| { readonly kind: "audit"; readonly audit: AgentRuntimeAuditRecord }
+	| { readonly kind: "views"; readonly views: ToolProviderRunRetryViews };
+
+interface ToolProviderRunRetryProjectorState {
+	inputIdsByRequest: Map<string, Set<string>>;
+	inputsById: Map<string, ToolProviderAdapterInput>;
+	policies: Map<string, ToolProviderRunRetryPolicy>;
+	outcomesById: Map<string, ExecutorOutcome>;
+	proposalsByOutcome: Map<string, ToolProviderRunRetryProposal>;
+	scheduledByOutcome: Map<string, ToolProviderRunRetryScheduled>;
+	readinessSchedulesByOutcome: Map<string, ScheduledReadinessRequested>;
+	readinessBySchedule: Map<string, ScheduledReadinessReady>;
+	nextRequestsByOutcome: Map<string, ToolProviderAdapterRunRequested>;
+	statusByOutcome: Map<string, ToolProviderRunRetryStatus>;
+	proposalKeys: Set<string>;
+	scheduledKeys: Set<string>;
+	readinessScheduleKeys: Set<string>;
+	requestKeys: Set<string>;
+	statusKeys: Set<string>;
+	issueKeys: Set<string>;
+	auditSeq: number;
+	nowMs: number | undefined;
+	usesSharedReadiness: boolean;
+}
+
+interface RetryPolicyChoice {
+	readonly policy: ToolProviderRunRetryPolicy;
+	readonly score: number;
+}
+
+function initialRetryState(): ToolProviderRunRetryProjectorState {
+	return {
+		inputIdsByRequest: new Map(),
+		inputsById: new Map(),
+		policies: new Map(),
+		outcomesById: new Map(),
+		proposalsByOutcome: new Map(),
+		scheduledByOutcome: new Map(),
+		readinessSchedulesByOutcome: new Map(),
+		readinessBySchedule: new Map(),
+		nextRequestsByOutcome: new Map(),
+		statusByOutcome: new Map(),
+		proposalKeys: new Set(),
+		scheduledKeys: new Set(),
+		readinessScheduleKeys: new Set(),
+		requestKeys: new Set(),
+		statusKeys: new Set(),
+		issueKeys: new Set(),
+		auditSeq: 0,
+		nowMs: undefined,
+		usesSharedReadiness: false,
+	};
+}
+
+function retainOutcome(state: ToolProviderRunRetryProjectorState, outcome: ExecutorOutcome): void {
+	if (!state.outcomesById.has(outcome.outcomeId))
+		state.outcomesById.set(outcome.outcomeId, outcome);
+}
+
+function inputForOutcome(
+	state: ToolProviderRunRetryProjectorState,
+	outcome: ExecutorOutcome,
+):
+	| { readonly ok: true; readonly input: ToolProviderAdapterInput }
+	| { readonly ok: false; readonly issue: DataIssue } {
+	if (typeof outcome.inputId === "string" && outcome.inputId.length > 0) {
+		const exactInput = state.inputsById.get(outcome.inputId);
+		if (exactInput !== undefined) return { ok: true, input: exactInput };
+		return {
+			ok: false,
+			issue: dataIssue(
+				"tool-provider-run-retry-missing-input",
+				"Tool provider run retry requires the retained adapter input identified by the outcome.",
+				{
+					subjectId: outcome.inputId,
+					refs: [ref("executor-outcome", outcome.outcomeId)],
+				},
+			),
+		};
+	}
+	const inputIds = state.inputIdsByRequest.get(outcome.requestId);
+	if (inputIds === undefined || inputIds.size === 0) {
+		return {
+			ok: false,
+			issue: dataIssue(
+				"tool-provider-run-retry-missing-input",
+				"Tool provider run retry requires a retained adapter input for the outcome request.",
+				{ subjectId: outcome.requestId, refs: [ref("executor-outcome", outcome.outcomeId)] },
+			),
+		};
+	}
+	if (inputIds.size > 1) {
+		return {
+			ok: false,
+			issue: dataIssue(
+				"tool-provider-run-retry-ambiguous-input",
+				"Tool provider run retry requires an exact outcome inputId when multiple adapter inputs share a request.",
+				{
+					subjectId: outcome.requestId,
+					refs: [ref("executor-outcome", outcome.outcomeId)],
+					details: { inputIds: [...inputIds].sort() },
+				},
+			),
+		};
+	}
+	const [inputId] = inputIds;
+	const input = inputId === undefined ? undefined : state.inputsById.get(inputId);
+	if (input !== undefined) return { ok: true, input };
+	return {
+		ok: false,
+		issue: dataIssue(
+			"tool-provider-run-retry-missing-input",
+			"Tool provider run retry requires a retained adapter input for the outcome request.",
+			{ subjectId: outcome.requestId, refs: [ref("executor-outcome", outcome.outcomeId)] },
+		),
+	};
+}
+
+function evaluateOutcomes(
+	ctx: { down: (msgs: readonly ["DATA", ToolProviderRunRetryFact][]) => void },
+	state: ToolProviderRunRetryProjectorState,
+): void {
+	for (const outcome of state.outcomesById.values()) evaluateOutcome(ctx, state, outcome);
+}
+
+function evaluateOutcome(
+	ctx: { down: (msgs: readonly ["DATA", ToolProviderRunRetryFact][]) => void },
+	state: ToolProviderRunRetryProjectorState,
+	outcome: ExecutorOutcome,
+): void {
+	const inputResolution = inputForOutcome(state, outcome);
+	if (!inputResolution.ok) {
+		emitIssue(ctx, state, inputResolution.issue);
+		emitStatus(ctx, state, statusForMissingInput(outcome, "blocked", [inputResolution.issue]));
+		return;
+	}
+	const input = inputResolution.input;
+	if (input.status !== "ready") {
+		const issue = dataIssue(
+			"tool-provider-run-retry-input-not-ready",
+			"Tool provider run retry requires a ready adapter input.",
+			{
+				subjectId: input.adapterInputId,
+				refs: [
+					ref("executor-outcome", outcome.outcomeId),
+					ref("tool-provider-adapter-input", input.adapterInputId),
+				],
+				details: { status: input.status },
+			},
+		);
+		emitIssue(ctx, state, issue);
+		emitStatus(ctx, state, statusForOutcome(outcome, input, "blocked", { issues: [issue] }));
+		return;
+	}
+	if (!isRetryableOutcome(outcome)) {
+		emitStatus(ctx, state, statusForOutcome(outcome, input, "not-retryable"));
+		return;
+	}
+	if (
+		state.scheduledByOutcome.has(outcome.outcomeId) ||
+		state.nextRequestsByOutcome.has(outcome.outcomeId)
+	) {
+		return;
+	}
+	const choice = chooseRetryPolicy(state, input, outcome);
+	if (choice === undefined) {
+		const issue = dataIssue(
+			"tool-provider-run-retry-policy-missing",
+			"Tool provider run retry requires an explicit retry policy fact.",
+			{
+				subjectId: input.adapterInputId,
+				refs: [
+					ref("executor-outcome", outcome.outcomeId),
+					ref("tool-provider-adapter-input", input.adapterInputId),
+				],
+			},
+		);
+		emitIssue(ctx, state, issue);
+		emitStatus(ctx, state, statusForOutcome(outcome, input, "not-retryable", { issues: [issue] }));
+		return;
+	}
+	if (!shouldRetry(choice.policy.retryPolicy, outcome.attempt)) {
+		const issue = dataIssue(
+			"tool-provider-run-retry-exhausted",
+			"Tool provider run retry policy exhausted available attempts.",
+			{
+				subjectId: input.adapterInputId,
+				refs: retrySourceRefs(input, outcome, choice.policy),
+				severity: "warning",
+				details: {
+					attempt: outcome.attempt,
+					maxAttempts: choice.policy.retryPolicy.maxAttempts,
+				},
+			},
+		);
+		emitIssue(ctx, state, issue);
+		emitStatus(
+			ctx,
+			state,
+			statusForOutcome(outcome, input, "exhausted", { choice, issues: [issue] }),
+		);
+		return;
+	}
+	const nextAttempt = outcome.attempt + 1;
+	const delayMs = nextRetryDelayMs(choice.policy.retryPolicy, nextAttempt);
+	if (delayMs === undefined) {
+		const issue = dataIssue(
+			"tool-provider-run-retry-delay-unavailable",
+			"Tool provider run retry could not compute a delay for the next attempt.",
+			{
+				subjectId: input.adapterInputId,
+				refs: retrySourceRefs(input, outcome, choice.policy),
+			},
+		);
+		emitIssue(ctx, state, issue);
+		emitStatus(
+			ctx,
+			state,
+			statusForOutcome(outcome, input, "blocked", { choice, issues: [issue] }),
+		);
+		return;
+	}
+	const proposal = retryProposal(input, outcome, choice, delayMs);
+	state.proposalsByOutcome.set(outcome.outcomeId, proposal);
+	emitProposal(ctx, state, proposal);
+	if (delayMs <= 0) {
+		emitRunRequest(ctx, state, input, proposal, "immediate");
+		return;
+	}
+	if (state.nowMs === undefined) {
+		const issue = dataIssue(
+			"tool-provider-run-retry-now-missing",
+			"Tool provider delayed retry requires a graph-visible nowMs input.",
+			{
+				subjectId: input.adapterInputId,
+				refs: retrySourceRefs(input, outcome, choice.policy),
+			},
+		);
+		emitIssue(ctx, state, issue);
+		emitStatus(
+			ctx,
+			state,
+			statusForOutcome(outcome, input, "blocked", { choice, proposal, issues: [issue], delayMs }),
+		);
+		return;
+	}
+	const scheduled = retryScheduled(input, outcome, proposal, state.nowMs + delayMs, delayMs);
+	state.scheduledByOutcome.set(outcome.outcomeId, scheduled);
+	emitScheduled(ctx, state, scheduled);
+	const readinessSchedule = retryReadinessSchedule(input, outcome, proposal, scheduled);
+	state.readinessSchedulesByOutcome.set(outcome.outcomeId, readinessSchedule);
+	emitReadinessSchedule(ctx, state, readinessSchedule);
+	emitStatus(
+		ctx,
+		state,
+		statusForOutcome(outcome, input, "scheduled", {
+			choice,
+			proposal,
+			delayMs,
+			retryAtMs: scheduled.retryAtMs,
+		}),
+	);
+}
+
+function processDueRetries(
+	ctx: { down: (msgs: readonly ["DATA", ToolProviderRunRetryFact][]) => void },
+	state: ToolProviderRunRetryProjectorState,
+): void {
+	for (const [outcomeId, scheduled] of state.scheduledByOutcome) {
+		const readiness = state.readinessBySchedule.get(
+			scheduled.readinessScheduleId ?? scheduled.scheduleId,
+		);
+		const readinessSchedule = state.readinessSchedulesByOutcome.get(outcomeId);
+		const readyByReadiness =
+			readiness !== undefined &&
+			readiness.readyAtMs === scheduled.retryAtMs &&
+			readiness.nowMs >= scheduled.retryAtMs &&
+			readinessSchedule !== undefined &&
+			readinessMatchesSchedule(readiness, readinessSchedule);
+		if (readiness !== undefined && !readyByReadiness) {
+			emitIssue(
+				ctx,
+				state,
+				dataIssue(
+					"tool-provider-run-retry-readiness-mismatch",
+					"Tool provider delayed retry readiness fact does not match the scheduled retry eligibility.",
+					{
+						subjectId: scheduled.scheduleId,
+						refs: sanitizeAdapterInputSourceRefs([
+							ref("tool-provider-run-retry-scheduled", scheduled.scheduleId),
+							ref("scheduled-readiness-ready", readiness.scheduleId),
+						]),
+						details: {
+							retryAtMs: scheduled.retryAtMs,
+							readyAtMs: readiness.readyAtMs,
+							nowMs: readiness.nowMs,
+						},
+					},
+				),
+			);
+		}
+		const readyByClock =
+			!state.usesSharedReadiness && state.nowMs !== undefined && scheduled.retryAtMs <= state.nowMs;
+		if (!readyByReadiness && !readyByClock) continue;
+		if (state.nextRequestsByOutcome.has(outcomeId)) continue;
+		const proposal = state.proposalsByOutcome.get(outcomeId);
+		if (proposal === undefined) continue;
+		const input = state.inputsById.get(proposal.adapterInputId);
+		if (input === undefined) continue;
+		emitRunRequest(ctx, state, input, proposal, "scheduled", readiness);
+	}
+}
+
+function sanitizeRetryReadinessReady(
+	raw: unknown,
+):
+	| ({ readonly ok: true } & ScheduledReadinessReady)
+	| { readonly ok: false; readonly issue: DataIssue } {
+	if (
+		!isRecord(raw) ||
+		raw.kind !== "scheduled-readiness-ready" ||
+		typeof raw.scheduleId !== "string" ||
+		raw.scheduleId.length === 0 ||
+		typeof raw.readyAtMs !== "number" ||
+		!Number.isFinite(raw.readyAtMs) ||
+		typeof raw.nowMs !== "number" ||
+		!Number.isFinite(raw.nowMs) ||
+		!Array.isArray(raw.subjectRefs) ||
+		(raw.sourceRefs !== undefined && !Array.isArray(raw.sourceRefs))
+	) {
+		return {
+			ok: false,
+			issue: dataIssue(
+				"tool-provider-run-retry-readiness-malformed",
+				"Tool provider delayed retry readiness fact must be graph-visible scheduled readiness material.",
+				{
+					subjectId:
+						isRecord(raw) && typeof raw.scheduleId === "string"
+							? raw.scheduleId
+							: "unknown-scheduled-readiness",
+				},
+			),
+		};
+	}
+	return Object.freeze({
+		ok: true,
+		kind: "scheduled-readiness-ready",
+		scheduleId: raw.scheduleId,
+		subjectRefs: sanitizeAdapterInputSourceRefs(
+			raw.subjectRefs.flatMap((entry) => {
+				const sourceRef = sourceRefOrUndefined(entry);
+				return sourceRef === undefined ? [] : [sourceRef];
+			}),
+		),
+		readyAtMs: raw.readyAtMs,
+		...(typeof raw.deadlineMs === "number" && Number.isFinite(raw.deadlineMs)
+			? { deadlineMs: raw.deadlineMs }
+			: {}),
+		nowMs: raw.nowMs,
+		...(raw.sourceRefs === undefined
+			? {}
+			: {
+					sourceRefs: sanitizeAdapterInputSourceRefs(
+						raw.sourceRefs.flatMap((entry) => {
+							const sourceRef = sourceRefOrUndefined(entry);
+							return sourceRef === undefined ? [] : [sourceRef];
+						}),
+					),
+				}),
+		...(isRecord(raw.metadata)
+			? { metadata: sanitizeProviderGraphVisibleRecord(raw.metadata) }
+			: {}),
+	});
+}
+
+function readinessMatchesSchedule(
+	readiness: ScheduledReadinessReady,
+	schedule: ScheduledReadinessRequested,
+): boolean {
+	const subjectRefs = sanitizeAdapterInputSourceRefs(schedule.subjectRefs);
+	const readySubjectRefs = sanitizeAdapterInputSourceRefs(readiness.subjectRefs);
+	if (!sourceRefsContainAll(readySubjectRefs, subjectRefs)) return false;
+	return sourceRefsContainAll(sanitizeAdapterInputSourceRefs(readiness.sourceRefs ?? []), [
+		ref("scheduled-readiness", schedule.scheduleId),
+		...(schedule.sourceRefs ?? []),
+	]);
+}
+
+function sourceRefsContainAll(
+	actual: readonly SourceRef[],
+	expected: readonly SourceRef[],
+): boolean {
+	const actualKeys = new Set(actual.map(sourceRefKey));
+	return expected.every((sourceRef) => actualKeys.has(sourceRefKey(sourceRef)));
+}
+
+function sourceRefKey(sourceRef: SourceRef): string {
+	return `${sourceRef.kind}:${sourceRef.id}`;
+}
+
+function sourceRefOrUndefined(value: unknown): SourceRef | undefined {
+	if (!isRecord(value)) return undefined;
+	if (typeof value.kind !== "string" || value.kind.length === 0) return undefined;
+	if (typeof value.id !== "string" || value.id.length === 0) return undefined;
+	return isRecord(value.metadata)
+		? { kind: value.kind, id: value.id, metadata: value.metadata }
+		: { kind: value.kind, id: value.id };
+}
+
+function sanitizeToolProviderRunRetryPolicy(
+	raw: ToolProviderRunRetryPolicy,
+): ToolProviderRunRetryPolicy {
+	const metadata = sanitizeProviderGraphVisibleRecord(raw.metadata);
+	return Object.freeze({
+		kind: "tool-provider-run-retry-policy",
+		policyId: raw.policyId,
+		retryPolicy: sanitizeRetryPolicy(raw.retryPolicy),
+		...(raw.runId === undefined ? {} : { runId: raw.runId }),
+		...(raw.requestId === undefined ? {} : { requestId: raw.requestId }),
+		...(raw.adapterInputId === undefined ? {} : { adapterInputId: raw.adapterInputId }),
+		sourceRefs: sanitizeAdapterInputSourceRefs(raw.sourceRefs ?? []),
+		...(metadata === undefined ? {} : { metadata }),
+	} satisfies ToolProviderRunRetryPolicy);
+}
+
+function sanitizeRetryPolicy(policy: RetryPolicy): RetryPolicy {
+	if (!Number.isInteger(policy.maxAttempts) || policy.maxAttempts <= 0) {
+		return Object.freeze({ maxAttempts: 1, backoff: { kind: "none" as const } });
+	}
+	return Object.freeze(policy);
+}
+
+function chooseRetryPolicy(
+	state: ToolProviderRunRetryProjectorState,
+	input: ToolProviderAdapterInput,
+	outcome: ExecutorOutcome,
+): RetryPolicyChoice | undefined {
+	let best: RetryPolicyChoice | undefined;
+	for (const policy of state.policies.values()) {
+		const score = retryPolicyScore(policy, input, outcome);
+		if (score === undefined) continue;
+		if (best === undefined || score > best.score) best = { policy, score };
+	}
+	return best;
+}
+
+function retryPolicyScore(
+	policy: ToolProviderRunRetryPolicy,
+	input: ToolProviderAdapterInput,
+	outcome: ExecutorOutcome,
+): number | undefined {
+	let score = 0;
+	if (policy.adapterInputId !== undefined) {
+		if (policy.adapterInputId !== input.adapterInputId) return undefined;
+		score += 8;
+	}
+	if (policy.requestId !== undefined) {
+		if (policy.requestId !== outcome.requestId) return undefined;
+		score += 4;
+	}
+	if (policy.runId !== undefined) {
+		if (policy.runId !== outcomeRunId(outcome)) return undefined;
+		score += 2;
+	}
+	return score;
+}
+
+function retryProposal(
+	input: ToolProviderAdapterInput,
+	outcome: ExecutorOutcome,
+	choice: RetryPolicyChoice,
+	delayMs: number,
+): ToolProviderRunRetryProposal {
+	const fromRunId = outcomeRunId(outcome);
+	const nextAttempt = outcome.attempt + 1;
+	const policyRefs = retryPolicyRefs(input, choice.policy);
+	const sourceRefs = retrySourceRefs(input, outcome, choice.policy);
+	return Object.freeze({
+		kind: "tool-provider-run-retry-proposal",
+		proposalId: `${outcome.outcomeId}:retry-proposal`,
+		outcomeId: outcome.outcomeId,
+		fromRunId,
+		fromRequestId: outcome.requestId,
+		fromAttempt: outcome.attempt,
+		nextAttempt,
+		nextRunId: `${fromRunId}:retry-${nextAttempt}`,
+		adapterInputId: input.adapterInputId,
+		requestId: input.requestId,
+		operationId: input.operationId,
+		policyId: choice.policy.policyId,
+		policyRefs,
+		maxAttempts: choice.policy.retryPolicy.maxAttempts,
+		nextDelayMs: delayMs,
+		sourceRefs,
+		metadata: sanitizeProviderGraphVisibleRecord({ policyScore: choice.score }),
+	} satisfies ToolProviderRunRetryProposal);
+}
+
+function retryScheduled(
+	input: ToolProviderAdapterInput,
+	outcome: ExecutorOutcome,
+	proposal: ToolProviderRunRetryProposal,
+	retryAtMs: number,
+	delayMs: number,
+): ToolProviderRunRetryScheduled {
+	return Object.freeze({
+		kind: "tool-provider-run-retry-scheduled",
+		scheduleId: `${proposal.proposalId}:scheduled`,
+		readinessScheduleId: `${proposal.proposalId}:scheduled-readiness`,
+		outcomeId: outcome.outcomeId,
+		proposalId: proposal.proposalId,
+		fromRunId: proposal.fromRunId,
+		nextRunId: proposal.nextRunId,
+		nextAttempt: proposal.nextAttempt,
+		retryAtMs,
+		retryAfterMs: delayMs,
+		sourceRefs: sanitizeAdapterInputSourceRefs([
+			ref("executor-outcome", outcome.outcomeId),
+			ref("tool-provider-run-retry-proposal", proposal.proposalId),
+			ref("tool-provider-adapter-input", input.adapterInputId),
+		]),
+	} satisfies ToolProviderRunRetryScheduled);
+}
+
+function retryReadinessSchedule(
+	input: ToolProviderAdapterInput,
+	outcome: ExecutorOutcome,
+	proposal: ToolProviderRunRetryProposal,
+	scheduled: ToolProviderRunRetryScheduled,
+): ScheduledReadinessRequested {
+	return Object.freeze({
+		kind: "scheduled-readiness-requested",
+		scheduleId: scheduled.readinessScheduleId ?? scheduled.scheduleId,
+		subjectRefs: sanitizeAdapterInputSourceRefs([
+			ref("tool-provider-run-retry-proposal", proposal.proposalId),
+			ref("tool-provider-run-retry-scheduled", scheduled.scheduleId),
+			ref("tool-provider-adapter-input", input.adapterInputId),
+		]),
+		readyAtMs: scheduled.retryAtMs,
+		reason: "tool-provider-retry",
+		policyRefs: proposal.policyRefs,
+		sourceRefs: sanitizeAdapterInputSourceRefs([
+			ref("executor-outcome", outcome.outcomeId),
+			ref("tool-provider-run-retry-proposal", proposal.proposalId),
+			ref("tool-provider-run-retry-scheduled", scheduled.scheduleId),
+			...(scheduled.sourceRefs ?? []),
+		]),
+		metadata: sanitizeProviderGraphVisibleRecord({
+			outcomeId: outcome.outcomeId,
+			nextRunId: proposal.nextRunId,
+			nextAttempt: proposal.nextAttempt,
+			retryAfterMs: scheduled.retryAfterMs,
+		}),
+	} satisfies ScheduledReadinessRequested);
+}
+
+function emitRunRequest(
+	ctx: { down: (msgs: readonly ["DATA", ToolProviderRunRetryFact][]) => void },
+	state: ToolProviderRunRetryProjectorState,
+	input: ToolProviderAdapterInput,
+	proposal: ToolProviderRunRetryProposal,
+	mode: "immediate" | "scheduled",
+	readiness?: ScheduledReadinessReady,
+): void {
+	const key = `request:${proposal.outcomeId}:${proposal.nextRunId}`;
+	if (state.requestKeys.has(key)) return;
+	state.requestKeys.add(key);
+	const request = requestToolProviderAdapterRun(input, {
+		runId: proposal.nextRunId,
+		attempt: proposal.nextAttempt,
+		reason: "retry",
+		retryOfOutcomeId: proposal.outcomeId,
+		policyRefs: proposal.policyRefs,
+		sourceRefs: uniqueSourceRefs([
+			...(proposal.sourceRefs ?? []),
+			ref("tool-provider-run-retry-proposal", proposal.proposalId),
+			...(mode === "scheduled"
+				? [ref("tool-provider-run-retry-scheduled", `${proposal.proposalId}:scheduled`)]
+				: []),
+			...(readiness === undefined
+				? []
+				: [
+						ref("scheduled-readiness-ready", readiness.scheduleId),
+						...(readiness.sourceRefs ?? []),
+					]),
+		]),
+		metadata: {
+			retryMode: mode,
+			retryProposalId: proposal.proposalId,
+			retryOfOutcomeId: proposal.outcomeId,
+			...(readiness === undefined ? {} : { readinessScheduleId: readiness.scheduleId }),
+		},
+	});
+	state.nextRequestsByOutcome.set(proposal.outcomeId, request);
+	emitStatus(ctx, state, statusForProposal(input, proposal, "ready"));
+	emitAudit(ctx, state, "tool-provider-run-retry-run-requested", {
+		subjectId: request.requestId,
+		sourceRefs: request.sourceRefs,
+		metadata: {
+			runId: request.runId,
+			adapterInputId: request.adapterInputId,
+			attempt: request.attempt,
+			retryOfOutcomeId: request.retryOfOutcomeId,
+			retryMode: mode,
+		},
+	});
+	ctx.down([["DATA", { kind: "run-request", request }]]);
+}
+
+function emitProposal(
+	ctx: { down: (msgs: readonly ["DATA", ToolProviderRunRetryFact][]) => void },
+	state: ToolProviderRunRetryProjectorState,
+	proposal: ToolProviderRunRetryProposal,
+): void {
+	const key = `proposal:${proposal.proposalId}`;
+	if (state.proposalKeys.has(key)) return;
+	state.proposalKeys.add(key);
+	emitAudit(ctx, state, "tool-provider-run-retry-proposed", {
+		subjectId: proposal.requestId,
+		sourceRefs: proposal.sourceRefs,
+		metadata: {
+			proposalId: proposal.proposalId,
+			outcomeId: proposal.outcomeId,
+			nextAttempt: proposal.nextAttempt,
+			nextDelayMs: proposal.nextDelayMs,
+		},
+	});
+	ctx.down([["DATA", { kind: "proposal", proposal }]]);
+}
+
+function emitScheduled(
+	ctx: { down: (msgs: readonly ["DATA", ToolProviderRunRetryFact][]) => void },
+	state: ToolProviderRunRetryProjectorState,
+	scheduled: ToolProviderRunRetryScheduled,
+): void {
+	const key = `scheduled:${scheduled.scheduleId}`;
+	if (state.scheduledKeys.has(key)) return;
+	state.scheduledKeys.add(key);
+	emitAudit(ctx, state, "tool-provider-run-retry-scheduled", {
+		sourceRefs: scheduled.sourceRefs,
+		metadata: {
+			scheduleId: scheduled.scheduleId,
+			outcomeId: scheduled.outcomeId,
+			nextAttempt: scheduled.nextAttempt,
+			retryAtMs: scheduled.retryAtMs,
+		},
+	});
+	ctx.down([["DATA", { kind: "scheduled", scheduled }]]);
+}
+
+function emitReadinessSchedule(
+	ctx: { down: (msgs: readonly ["DATA", ToolProviderRunRetryFact][]) => void },
+	state: ToolProviderRunRetryProjectorState,
+	schedule: ScheduledReadinessRequested,
+): void {
+	const key = `readiness-schedule:${schedule.scheduleId}`;
+	if (state.readinessScheduleKeys.has(key)) return;
+	state.readinessScheduleKeys.add(key);
+	emitAudit(ctx, state, "tool-provider-run-retry-readiness-scheduled", {
+		sourceRefs: schedule.sourceRefs,
+		metadata: {
+			scheduleId: schedule.scheduleId,
+			readyAtMs: schedule.readyAtMs,
+		},
+	});
+	ctx.down([["DATA", { kind: "readiness-schedule", schedule }]]);
+}
+
+function emitStatus(
+	ctx: { down: (msgs: readonly ["DATA", ToolProviderRunRetryFact][]) => void },
+	state: ToolProviderRunRetryProjectorState,
+	status: ToolProviderRunRetryStatus,
+): void {
+	const key = `${status.outcomeId}:${status.state}:${status.nextAttempt ?? ""}:${status.nextRetryAtMs ?? ""}:${(status.issueCodes ?? []).join(",")}`;
+	if (state.statusKeys.has(key)) return;
+	state.statusKeys.add(key);
+	state.statusByOutcome.set(status.outcomeId, status);
+	ctx.down([["DATA", { kind: "status", status }]]);
+}
+
+function emitIssue(
+	ctx: { down: (msgs: readonly ["DATA", ToolProviderRunRetryFact][]) => void },
+	state: ToolProviderRunRetryProjectorState,
+	issue: DataIssue,
+): void {
+	const sanitized = sanitizeAdapterInputIssue(issue);
+	const key = `${sanitized.code}:${sanitized.subjectId ?? ""}:${JSON.stringify(sanitized.details ?? {})}`;
+	if (state.issueKeys.has(key)) return;
+	state.issueKeys.add(key);
+	ctx.down([["DATA", { kind: "issue", issue: sanitized }]]);
+}
+
+function emitAudit(
+	ctx: { down: (msgs: readonly ["DATA", ToolProviderRunRetryFact][]) => void },
+	state: ToolProviderRunRetryProjectorState,
+	kind: string,
+	opts: {
+		readonly subjectId?: string;
+		readonly sourceRefs?: readonly SourceRef[];
+		readonly metadata?: Record<string, unknown>;
+	} = {},
+): void {
+	state.auditSeq += 1;
+	const metadata = sanitizeProviderGraphVisibleRecord(opts.metadata);
+	ctx.down([
+		[
+			"DATA",
+			{
+				kind: "audit",
+				audit: Object.freeze({
+					id: `tool-provider-run-retry-audit-${state.auditSeq}`,
+					kind,
+					...(opts.subjectId === undefined ? {} : { subjectId: opts.subjectId }),
+					...(opts.sourceRefs === undefined
+						? {}
+						: { sourceRefs: sanitizeAdapterInputSourceRefs(opts.sourceRefs) }),
+					...(metadata === undefined ? {} : { metadata }),
+				} satisfies AgentRuntimeAuditRecord),
+			},
+		],
+	]);
+}
+
+function statusForOutcome(
+	outcome: ExecutorOutcome,
+	input: ToolProviderAdapterInput,
+	state: ToolProviderRunRetryStatusState,
+	opts: {
+		readonly choice?: RetryPolicyChoice;
+		readonly proposal?: ToolProviderRunRetryProposal;
+		readonly issues?: readonly DataIssue[];
+		readonly delayMs?: number;
+		readonly retryAtMs?: number;
+	} = {},
+): ToolProviderRunRetryStatus {
+	const proposal = opts.proposal;
+	const nextAttempt =
+		proposal?.nextAttempt ?? (opts.choice === undefined ? undefined : outcome.attempt + 1);
+	return Object.freeze({
+		kind: "tool-provider-run-retry-status",
+		statusId: `${outcome.outcomeId}:retry-status:${state}`,
+		outcomeId: outcome.outcomeId,
+		proposalId: proposal?.proposalId ?? `${outcome.outcomeId}:retry-proposal`,
+		fromRunId: outcomeRunId(outcome),
+		adapterInputId: input.adapterInputId,
+		requestId: input.requestId,
+		operationId: input.operationId,
+		...(proposal?.nextRunId === undefined ? {} : { nextRunId: proposal.nextRunId }),
+		...(nextAttempt === undefined ? {} : { nextAttempt }),
+		...(opts.retryAtMs === undefined ? {} : { nextRetryAtMs: opts.retryAtMs }),
+		state,
+		sourceRefs: retrySourceRefs(input, outcome, opts.choice?.policy),
+		...(opts.issues === undefined || opts.issues.length === 0
+			? {}
+			: { issueCodes: Object.freeze(opts.issues.map((issue) => issue.code)) }),
+		...optionalMetadata({
+			...(opts.delayMs === undefined ? {} : { delayMs: opts.delayMs }),
+			...(opts.choice === undefined
+				? {}
+				: { maxAttempts: opts.choice.policy.retryPolicy.maxAttempts }),
+		}),
+	} satisfies ToolProviderRunRetryStatus);
+}
+
+function statusForProposal(
+	input: ToolProviderAdapterInput,
+	proposal: ToolProviderRunRetryProposal,
+	state: ToolProviderRunRetryStatusState,
+): ToolProviderRunRetryStatus {
+	return Object.freeze({
+		kind: "tool-provider-run-retry-status",
+		statusId: `${proposal.outcomeId}:retry-status:${state}`,
+		outcomeId: proposal.outcomeId,
+		proposalId: proposal.proposalId,
+		fromRunId: proposal.fromRunId,
+		adapterInputId: input.adapterInputId,
+		requestId: input.requestId,
+		operationId: input.operationId,
+		nextRunId: proposal.nextRunId,
+		nextAttempt: proposal.nextAttempt,
+		state,
+		sourceRefs: proposal.sourceRefs,
+		...optionalMetadata({ maxAttempts: proposal.maxAttempts }),
+	} satisfies ToolProviderRunRetryStatus);
+}
+
+function statusForMissingInput(
+	outcome: ExecutorOutcome,
+	state: ToolProviderRunRetryStatusState,
+	issues: readonly DataIssue[],
+): ToolProviderRunRetryStatus {
+	return Object.freeze({
+		kind: "tool-provider-run-retry-status",
+		statusId: `${outcome.outcomeId}:retry-status:${state}`,
+		outcomeId: outcome.outcomeId,
+		proposalId: `${outcome.outcomeId}:retry-proposal`,
+		fromRunId: outcomeRunId(outcome),
+		adapterInputId: outcome.inputId ?? outcome.requestId,
+		requestId: outcome.requestId,
+		operationId: outcome.operationId,
+		state,
+		sourceRefs: [ref("executor-outcome", outcome.outcomeId)],
+		issueCodes: Object.freeze(issues.map((issue) => issue.code)),
+	} satisfies ToolProviderRunRetryStatus);
+}
+
+function isRetryableOutcome(outcome: ExecutorOutcome): boolean {
+	return (outcome.kind === "failure" || outcome.kind === "timeout") && outcome.retryable === true;
+}
+
+function retryPolicyRefs(
+	input: ToolProviderAdapterInput,
+	policy: ToolProviderRunRetryPolicy,
+): readonly SourceRef[] {
+	return sanitizeAdapterInputSourceRefs([
+		ref("tool-provider-run-retry-policy", policy.policyId),
+		...(policy.sourceRefs ?? []),
+		...(input.policyRefs ?? []),
+	]);
+}
+
+function retrySourceRefs(
+	input: ToolProviderAdapterInput,
+	outcome: ExecutorOutcome,
+	policy?: ToolProviderRunRetryPolicy,
+): readonly SourceRef[] {
+	return sanitizeAdapterInputSourceRefs([
+		ref("executor-outcome", outcome.outcomeId),
+		ref("tool-provider-adapter-input", input.adapterInputId),
+		...(outcome.evidenceRefs ?? []),
+		...(input.sourceRefs ?? []),
+		...(policy === undefined ? [] : retryPolicyRefs(input, policy)),
+	]);
+}
+
+function outcomeRunId(outcome: ExecutorOutcome): string {
+	const runId = isRecord(outcome.metadata) ? outcome.metadata.runId : undefined;
+	if (typeof runId === "string" && runId.length > 0) return runId;
+	return `${outcome.requestId}:attempt-${outcome.attempt}`;
+}
+
+function optionalMetadata(value: Record<string, unknown>): {
+	readonly metadata?: Record<string, unknown>;
+} {
+	const metadata = sanitizeProviderGraphVisibleRecord(value);
+	return metadata === undefined ? {} : { metadata };
+}
+
+function buildRetryViews(state: ToolProviderRunRetryProjectorState): ToolProviderRunRetryViews {
+	return Object.freeze({
+		proposalsByOutcome: new Map(state.proposalsByOutcome),
+		scheduledByOutcome: new Map(state.scheduledByOutcome),
+		readinessSchedulesByOutcome: new Map(state.readinessSchedulesByOutcome),
+		readinessBySchedule: new Map(state.readinessBySchedule),
+		nextRunRequestsByOutcome: new Map(state.nextRequestsByOutcome),
+		statusByOutcome: new Map(state.statusByOutcome),
+	});
+}
diff --git a/packages/ts/src/orchestration/agent-runtime-types-agent.ts b/packages/ts/src/orchestration/agent-runtime-types-agent.ts
new file mode 100644
index 00000000..aa507439
--- /dev/null
+++ b/packages/ts/src/orchestration/agent-runtime-types-agent.ts
@@ -0,0 +1,156 @@
+import type { DataIssue } from "../data/index.js";
+import type { Node } from "../node/node.js";
+import type {
+	AgentOutputEnvelope,
+	AgentRequestProposal,
+	AgentRequestStatusChanged,
+	SourceRef,
+} from "./agent-runtime-types-core.js";
+
+export interface ContextContribution {
+	readonly kind: "context-contribution";
+	readonly contributionId: string;
+	readonly requestId: string;
+	readonly operationId: string;
+	readonly status: "ready" | "pending" | "issue";
+	readonly frameId?: string;
+	readonly issues?: readonly DataIssue[];
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface PromptBundle {
+	readonly kind: "prompt-bundle";
+	readonly promptId: string;
+	readonly requestId: string;
+	readonly operationId: string;
+	readonly status: "ready" | "partial" | "issue";
+	readonly sourceFrameIds?: readonly string[];
+	readonly issues?: readonly DataIssue[];
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface AgentRequestSatisfactionBundle {
+	readonly status: Node<AgentRequestStatusChanged>;
+	readonly issues: Node<DataIssue>;
+	readonly audit: Node<AgentRuntimeAuditRecord>;
+}
+
+export type AgentDecisionKind = "continue" | "final" | "blocked";
+
+export interface AgentNeed {
+	readonly kind: string;
+	readonly message?: string;
+	readonly refs?: readonly SourceRef[];
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface AgentDecisionBase {
+	readonly kind: AgentDecisionKind;
+	readonly decisionId: string;
+	readonly effectRunId: string;
+	readonly agentRunId: string;
+	readonly source: {
+		readonly requestId: string;
+		readonly operationId: string;
+		readonly outcomeId: string;
+	};
+	readonly reason?: string;
+	readonly confidence?: number;
+	readonly evidenceRefs?: readonly SourceRef[];
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface AgentDecisionContinue extends AgentDecisionBase {
+	readonly kind: "continue";
+	readonly next: readonly AgentRequestProposal[];
+}
+
+export interface AgentDecisionFinal extends AgentDecisionBase {
+	readonly kind: "final";
+	readonly output: AgentOutputEnvelope;
+	readonly summary?: string;
+}
+
+export interface AgentDecisionBlocked extends AgentDecisionBase {
+	readonly kind: "blocked";
+	readonly needs: readonly AgentNeed[];
+}
+
+export type AgentDecision = AgentDecisionContinue | AgentDecisionFinal | AgentDecisionBlocked;
+
+export interface StructuredAgentDecisionEnvelope {
+	readonly kind: "agent-decision";
+	readonly decision: AgentDecision;
+	readonly schemaRef: string;
+	readonly sourceRefs?: readonly SourceRef[];
+}
+
+export interface StructuredAgentDecisionInterpreterBundle {
+	readonly decisions: Node<AgentDecision>;
+	readonly issues: Node<DataIssue>;
+	readonly audit: Node<AgentRuntimeAuditRecord>;
+}
+
+export type EffectRunResultStatus =
+	| "completed"
+	| "failed"
+	| "blocked"
+	| "canceled"
+	| "timeout"
+	| "waived";
+
+export interface EffectRunResultBase {
+	readonly kind: "effect-run-result";
+	readonly resultId: string;
+	readonly status: EffectRunResultStatus;
+	readonly effectRunId: string;
+	readonly subjectRefs?: readonly SourceRef[];
+	readonly operationId?: string;
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly issues?: readonly DataIssue[];
+	readonly auditRefs?: readonly string[];
+	readonly completedAtMs?: number;
+	readonly metadata?: Record<string, unknown>;
+}
+
+export type EffectRunResult =
+	| (EffectRunResultBase & { readonly status: "completed"; readonly output: AgentOutputEnvelope })
+	| (EffectRunResultBase & { readonly status: "failed"; readonly error: DataIssue })
+	| (EffectRunResultBase & { readonly status: "blocked"; readonly needs: readonly AgentNeed[] })
+	| (EffectRunResultBase & { readonly status: "canceled"; readonly reason?: string })
+	| (EffectRunResultBase & { readonly status: "timeout"; readonly timeoutMs?: number })
+	| (EffectRunResultBase & { readonly status: "waived"; readonly reason?: string });
+
+export interface EffectRunCompletionBundle {
+	readonly results: Node<EffectRunResult>;
+	readonly status: Node<EffectRunCompletionStatus>;
+	readonly issues: Node<DataIssue>;
+	readonly audit: Node<AgentRuntimeAuditRecord>;
+}
+
+export interface EffectRunCompletionStatus {
+	readonly effectRunId: string;
+	readonly state:
+		| "pending"
+		| "completed"
+		| "failed"
+		| "blocked"
+		| "canceled"
+		| "timeout"
+		| "waived";
+	readonly requiredPending: readonly string[];
+	readonly requiredTerminal: readonly string[];
+	readonly sourceRefs?: readonly SourceRef[];
+}
+
+export interface AgentRuntimeAuditRecord {
+	readonly id: string;
+	readonly kind: string;
+	readonly subjectId?: string;
+	readonly message?: string;
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly issueCode?: string;
+	readonly metadata?: Record<string, unknown>;
+}
diff --git a/packages/ts/src/orchestration/agent-runtime-types-core.ts b/packages/ts/src/orchestration/agent-runtime-types-core.ts
new file mode 100644
index 00000000..6caf718d
--- /dev/null
+++ b/packages/ts/src/orchestration/agent-runtime-types-core.ts
@@ -0,0 +1,340 @@
+import type { DataIssue } from "../data/index.js";
+import type { Node } from "../node/node.js";
+import type { AgentNeed, AgentRuntimeAuditRecord } from "./agent-runtime-types-agent.js";
+
+export interface SourceRef {
+	readonly kind: string;
+	readonly id: string;
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface AgentRequestInput<T = unknown> {
+	readonly inputId: string;
+	readonly inputKind: string;
+	readonly dataMode?: "ref" | "summary" | "inline";
+	readonly ref?: string;
+	readonly summary?: string;
+	readonly value?: T;
+	readonly schemaRef?: string;
+	readonly subjectRefs?: readonly SourceRef[];
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface EffectRunGoal<TInput = unknown> {
+	readonly kind: string;
+	readonly summary?: string;
+	readonly detailRef?: string;
+	readonly input?: AgentRequestInput<TInput>;
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface EffectRunLimits {
+	readonly maxSteps?: number;
+	readonly maxRequests?: number;
+	readonly maxAttemptsPerOperation?: number;
+	readonly maxPendingRequests?: number;
+	readonly maxCostUsd?: number;
+	readonly timeoutMs?: number;
+}
+
+export interface EffectRun<TInput = unknown> {
+	readonly kind: "effect-run";
+	readonly effectRunId: string;
+	readonly agentRunId?: string;
+	readonly subjectRefs?: readonly SourceRef[];
+	readonly goal: EffectRunGoal<TInput>;
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly policyRefs?: readonly SourceRef[];
+	readonly limits?: EffectRunLimits;
+	readonly createdBy?: string;
+	readonly createdAtMs?: number;
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface EffectRunOptions<TInput = unknown> {
+	readonly effectRunId: string;
+	readonly agentRunId?: string;
+	readonly subjectRefs?: readonly SourceRef[];
+	readonly goal: EffectRunGoal<TInput>;
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly policyRefs?: readonly SourceRef[];
+	readonly limits?: EffectRunLimits;
+	readonly createdBy?: string;
+	readonly createdAtMs?: number;
+	readonly metadata?: Record<string, unknown>;
+}
+
+export function effectRun<TInput = unknown>(opts: EffectRunOptions<TInput>): EffectRun<TInput> {
+	return {
+		kind: "effect-run",
+		effectRunId: opts.effectRunId,
+		agentRunId: opts.agentRunId,
+		subjectRefs: opts.subjectRefs,
+		goal: opts.goal,
+		sourceRefs: opts.sourceRefs,
+		policyRefs: opts.policyRefs,
+		limits: opts.limits,
+		createdBy: opts.createdBy,
+		createdAtMs: opts.createdAtMs,
+		metadata: opts.metadata,
+	};
+}
+
+export type AgentRequestKind = "context" | "prompt" | "executor";
+
+export interface AgentRequestProposal<TPayload = unknown> {
+	readonly kind: "proposal";
+	readonly proposalId: string;
+	readonly effectRunId: string;
+	readonly agentRunId?: string;
+	readonly parentRequestId?: string;
+	readonly sourceDecisionId?: string;
+	readonly requestKind: AgentRequestKind;
+	readonly required?: boolean;
+	readonly subjectId?: string;
+	readonly input?: AgentRequestInput<TPayload>;
+	readonly payload?: TPayload;
+	readonly reason?: string;
+	readonly evidenceRefs?: readonly SourceRef[];
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface AgentRequestAdmitted {
+	readonly kind: "admitted";
+	readonly proposalId: string;
+	readonly requestId: string;
+	readonly operationId: string;
+	readonly effectRunId: string;
+	readonly agentRunId?: string;
+	readonly admittedAtMs?: number;
+	readonly reason?: string;
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface AgentRequestRejected {
+	readonly kind: "rejected";
+	readonly proposalId: string;
+	readonly effectRunId: string;
+	readonly issue: DataIssue;
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface AgentRequestDeferred {
+	readonly kind: "deferred";
+	readonly proposalId: string;
+	readonly effectRunId: string;
+	readonly reason?: string;
+	readonly untilRef?: string;
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface AgentRequestMerged {
+	readonly kind: "merged";
+	readonly proposalId: string;
+	readonly effectRunId: string;
+	readonly targetRequestId: string;
+	readonly reason?: string;
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface AgentRequestIssued<TPayload = unknown> {
+	readonly kind: "issued";
+	readonly requestId: string;
+	readonly operationId: string;
+	readonly effectRunId: string;
+	readonly agentRunId?: string;
+	readonly proposalId?: string;
+	readonly parentRequestId?: string;
+	readonly requestKind: AgentRequestKind;
+	readonly required: boolean;
+	readonly input?: AgentRequestInput<TPayload>;
+	readonly payload?: TPayload;
+	readonly issuedAtMs?: number;
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly metadata?: Record<string, unknown>;
+}
+
+export type AgentRequestStatus =
+	| "proposed"
+	| "admitted"
+	| "rejected"
+	| "deferred"
+	| "merged"
+	| "issued"
+	| "awaiting-context"
+	| "awaiting-prompt"
+	| "awaiting-route"
+	| "awaiting-provider"
+	| "in-flight"
+	| "completed"
+	| "failed"
+	| "blocked"
+	| "canceled"
+	| "timeout"
+	| "waived"
+	| "retry-exhausted";
+
+export interface AgentRequestStatusChanged {
+	readonly kind: "status";
+	readonly requestId: string;
+	readonly operationId?: string;
+	readonly effectRunId: string;
+	readonly status: AgentRequestStatus;
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly issues?: readonly DataIssue[];
+	readonly metadata?: Record<string, unknown>;
+}
+
+export type AgentRequestFact<TPayload = unknown> =
+	| AgentRequestProposal<TPayload>
+	| AgentRequestAdmitted
+	| AgentRequestRejected
+	| AgentRequestDeferred
+	| AgentRequestMerged
+	| AgentRequestIssued<TPayload>
+	| AgentRequestStatusChanged;
+
+export interface AgentRequestViews {
+	readonly requestsById: ReadonlyMap<string, AgentRequestIssued>;
+	readonly requestsByEffectRun: ReadonlyMap<string, readonly string[]>;
+	readonly statusByRequest: ReadonlyMap<string, AgentRequestStatusChanged>;
+	readonly pending: readonly AgentRequestIssued[];
+	readonly awaitingProvider: readonly AgentRequestIssued[];
+	readonly issues: readonly DataIssue[];
+	readonly audit: readonly AgentRuntimeAuditRecord[];
+}
+
+export interface AgentRequestLedgerBundle {
+	readonly views: Node<AgentRequestViews>;
+	readonly issues: Node<DataIssue>;
+	readonly audit: Node<AgentRuntimeAuditRecord>;
+}
+
+export interface ExecutorProfile {
+	readonly profileId: string;
+	readonly executorId: string;
+	readonly kind: "llm" | "tool" | "human" | "agent";
+	readonly acceptedInputKinds?: readonly string[];
+	readonly acceptedSchemaRefs?: readonly string[];
+	readonly acceptedResultKinds?: readonly string[];
+	readonly capabilities?: Record<string, unknown>;
+	readonly limits?: Record<string, number>;
+	readonly policyRefs?: readonly SourceRef[];
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface ExecutorRoute {
+	readonly kind: "executor-route";
+	readonly routeId: string;
+	readonly requestId: string;
+	readonly operationId: string;
+	readonly inputId?: string;
+	readonly inputKind?: string;
+	readonly executorId: string;
+	readonly profileId: string;
+	readonly allowedParams?: Record<string, unknown>;
+	readonly reason?: string;
+	readonly evidenceRefs?: readonly SourceRef[];
+	readonly metadata?: Record<string, unknown>;
+}
+
+export type ExecutorOutcomeStatus = "result" | "failure" | "canceled" | "timeout" | "blocked";
+
+export interface ExecutorUsage {
+	readonly inputTokens?: number;
+	readonly outputTokens?: number;
+	readonly cacheHitTokens?: number;
+	readonly cacheMissTokens?: number;
+	readonly cacheWriteTokens?: number;
+	readonly cacheMode?: string;
+	readonly costUsd?: number;
+	readonly latencyMs?: number;
+}
+
+export interface SizeCapacityEvidence {
+	readonly kind: "size-capacity-evidence";
+	readonly unit: string;
+	readonly quantity: number;
+	readonly measurementSource: string;
+	readonly estimated?: boolean;
+	readonly encoding?: string;
+	readonly mediaType?: string;
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly refs?: readonly SourceRef[];
+	readonly issues?: readonly DataIssue[];
+	readonly sensitivity?: readonly string[];
+	readonly redaction?: Record<string, unknown>;
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface ExecutorOutcomeBase {
+	readonly kind: ExecutorOutcomeStatus;
+	readonly outcomeId: string;
+	readonly requestId: string;
+	readonly operationId: string;
+	readonly routeId: string;
+	readonly executorId: string;
+	readonly profileId: string;
+	readonly attempt: number;
+	readonly inputId?: string;
+	readonly inputKind?: string;
+	readonly occurredAtMs?: number;
+	readonly evidenceRefs?: readonly SourceRef[];
+	readonly issues?: readonly DataIssue[];
+	readonly usage?: ExecutorUsage;
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface AgentOutputEnvelope<T = unknown> {
+	readonly kind: string;
+	readonly value?: T;
+	readonly refs?: readonly SourceRef[];
+	readonly summary?: string;
+	readonly artifacts?: readonly ExecutorArtifactMaterial[];
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface ExecutorArtifactMaterial<T = unknown> {
+	readonly kind: string;
+	readonly format?: string;
+	readonly schemaRef?: string;
+	readonly schemaKind?: string;
+	readonly mimeType?: string;
+	readonly mediaType?: string;
+	readonly filename?: string;
+	readonly byteLength?: number;
+	readonly digest?: string;
+	readonly encoding?: string;
+	readonly dataMode: "inline" | "summary" | "ref" | (string & {});
+	readonly summary?: string;
+	readonly value?: T;
+	readonly ref?: SourceRef;
+	readonly refs?: readonly SourceRef[];
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly sizeEvidence?: readonly SizeCapacityEvidence[];
+	readonly sensitivity?: readonly string[];
+	readonly redaction?: Record<string, unknown>;
+	readonly metadata?: Record<string, unknown>;
+}
+
+export type ExecutorOutcome<T = unknown> =
+	| (ExecutorOutcomeBase & { readonly kind: "result"; readonly result: AgentOutputEnvelope<T> })
+	| (ExecutorOutcomeBase & {
+			readonly kind: "failure";
+			readonly error: DataIssue;
+			readonly retryable?: boolean;
+	  })
+	| (ExecutorOutcomeBase & { readonly kind: "canceled"; readonly reason?: string })
+	| (ExecutorOutcomeBase & {
+			readonly kind: "timeout";
+			readonly timeoutMs?: number;
+			readonly retryable?: boolean;
+	  })
+	| (ExecutorOutcomeBase & {
+			readonly kind: "blocked";
+			readonly needs: readonly AgentNeed[];
+	  });
diff --git a/packages/ts/src/orchestration/agent-runtime-types-tool.ts b/packages/ts/src/orchestration/agent-runtime-types-tool.ts
new file mode 100644
index 00000000..96311832
--- /dev/null
+++ b/packages/ts/src/orchestration/agent-runtime-types-tool.ts
@@ -0,0 +1,822 @@
+import type { DataIssue } from "../data/index.js";
+import type { CapacityPolicy, ReactiveOpt, RetentionPolicy } from "../graph/policies/types.js";
+import type { RetryPolicy } from "../graph/resilience.js";
+import type { Node } from "../node/node.js";
+import type { AgentNeed, AgentRuntimeAuditRecord } from "./agent-runtime-types-agent.js";
+import type {
+	AgentOutputEnvelope,
+	AgentRequestInput,
+	AgentRequestStatusChanged,
+	ExecutorOutcome,
+	ExecutorOutcomeStatus,
+	ExecutorProfile,
+	ExecutorRoute,
+	ExecutorUsage,
+	SourceRef,
+} from "./agent-runtime-types-core.js";
+import type {
+	ScheduledReadinessReady,
+	ScheduledReadinessRequested,
+} from "./scheduled-readiness.js";
+
+/**
+ * Provider-neutral tool-call request input (D359). Concrete clients, secrets,
+ * transports, and SDK handles stay in executor adapter bindings, not this fact.
+ */
+export interface ToolCallInput<TArguments = unknown> {
+	readonly kind: "tool-call";
+	readonly toolName: string;
+	readonly operation?: string;
+	readonly arguments?: TArguments;
+	readonly argumentsRef?: string;
+	readonly expectedOutput?: {
+		readonly resultKind?: string;
+		readonly schemaRef?: string;
+	};
+	readonly idempotency?: {
+		readonly key?: string;
+		readonly safeToRetry?: boolean;
+	};
+	readonly timeoutMs?: number;
+	readonly subjectRefs?: readonly SourceRef[];
+	readonly metadata?: Record<string, unknown>;
+}
+
+/**
+ * Tool provider family label for optional Layer C adapters (D359). Builtin,
+ * MCP, CLI, and Composio providers stay executor/tool recipes, not WorkItem
+ * core or protocol semantics.
+ */
+export type ToolProviderKind = "local-builtin" | "mcp" | "cli" | "composio" | (string & {});
+
+export type ToolProviderSizeUnit =
+	| "bytes"
+	| "chars"
+	| "tokens"
+	| "items"
+	| "events"
+	| "lines"
+	| (string & {});
+
+/**
+ * D293-style size-capacity limit material for Layer C tool providers (D360).
+ * This is policy/evidence vocabulary only; enforcement remains adapter-owned.
+ */
+export interface ToolProviderSizeLimit {
+	readonly unit: ToolProviderSizeUnit;
+	readonly softLimit?: number;
+	readonly hardLimit?: number;
+	readonly window?: string;
+	readonly perItem?: boolean;
+	readonly perBatch?: boolean;
+	readonly perArtifact?: boolean;
+	readonly perStream?: boolean;
+	readonly perRequest?: boolean;
+	readonly perTool?: boolean;
+	readonly policyScopeRefs?: readonly SourceRef[];
+	readonly measurementSource?: string;
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface ToolProviderSizeCapacityPolicy {
+	readonly limits: readonly ToolProviderSizeLimit[];
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface ToolProviderTimeoutPolicy {
+	readonly timeoutMs?: number;
+	readonly connectTimeoutMs?: number;
+	readonly idleTimeoutMs?: number;
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface ToolProviderRedactionPolicy {
+	readonly mode?: "none" | "summary" | "redact" | "ref-only" | (string & {});
+	readonly sensitivity?: readonly string[];
+	readonly redactKinds?: readonly string[];
+	readonly summaryMaxChars?: number;
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface ToolProviderPathRule {
+	readonly effect: "allow" | "deny" | "summary" | "ref-only" | (string & {});
+	readonly path?: string;
+	readonly glob?: string;
+	readonly operation?: string;
+	readonly reason?: string;
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface ToolProviderFilesystemPolicy {
+	readonly cwd?: string;
+	readonly pathRules?: readonly ToolProviderPathRule[];
+	readonly allowRead?: boolean;
+	readonly allowWrite?: boolean;
+	readonly followSymlinks?: boolean;
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface ToolProviderNetworkPolicy {
+	readonly mode?: "disabled" | "allowlist" | "denylist" | "custom" | (string & {});
+	readonly protocols?: readonly string[];
+	readonly allowedHosts?: readonly string[];
+	readonly deniedHosts?: readonly string[];
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface ToolProviderApprovalPolicy {
+	readonly mode?: "auto" | "require" | "never" | "custom" | (string & {});
+	readonly requiredForToolNames?: readonly string[];
+	readonly requiredForOperations?: readonly string[];
+	readonly approverRefs?: readonly SourceRef[];
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface ToolProviderArtifactPolicy {
+	readonly defaultDataMode?: "inline" | "summary" | "ref" | (string & {});
+	readonly inlineLimits?: readonly ToolProviderSizeLimit[];
+	readonly artifactKinds?: readonly string[];
+	readonly requireDigest?: boolean;
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly metadata?: Record<string, unknown>;
+}
+
+/**
+ * Data-only execution policy fact for optional Layer C tool providers (D360).
+ * It is admission/routing/audit/adapter-input material, not an enforcement
+ * runtime, security boundary, provider SDK, client handle, or secret container.
+ */
+export interface ToolProviderExecutionPolicy {
+	readonly kind: "tool-provider-execution-policy";
+	readonly policyId: string;
+	readonly providerId: string;
+	readonly profileIds?: readonly string[];
+	readonly toolNames?: readonly string[];
+	readonly operations?: readonly string[];
+	readonly sizeCapacity?: ToolProviderSizeCapacityPolicy;
+	readonly timeout?: ToolProviderTimeoutPolicy;
+	readonly redaction?: ToolProviderRedactionPolicy;
+	readonly filesystem?: ToolProviderFilesystemPolicy;
+	readonly network?: ToolProviderNetworkPolicy;
+	readonly approval?: ToolProviderApprovalPolicy;
+	readonly artifacts?: ToolProviderArtifactPolicy;
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly metadata?: Record<string, unknown>;
+}
+
+/**
+ * Graph-visible catalog entry for a tool exposed by an executor provider
+ * (D359). Runtime clients and credentials remain private adapter state.
+ */
+export interface ToolProviderCatalogEntry {
+	readonly kind: "tool-catalog-entry";
+	readonly providerId: string;
+	readonly toolName: string;
+	readonly operation?: string;
+	readonly inputKind: "tool-call";
+	readonly profileId: string;
+	readonly executorId: string;
+	readonly resultKinds?: readonly string[];
+	readonly schemaRefs?: readonly string[];
+	readonly capabilities?: Record<string, unknown>;
+	readonly limits?: Record<string, number>;
+	readonly policyRefs?: readonly SourceRef[];
+	readonly metadata?: Record<string, unknown>;
+}
+
+/**
+ * Graph-visible tool provider catalog/status surface (D359). This is passive
+ * DATA for routing/profile selection and UI inspection, not a provider runtime.
+ */
+export interface ToolProviderCatalog {
+	readonly kind: "tool-provider-catalog";
+	readonly providerId: string;
+	readonly providerKind: ToolProviderKind;
+	readonly profiles: readonly ExecutorProfile[];
+	readonly tools: readonly ToolProviderCatalogEntry[];
+	readonly policies?: readonly ToolProviderExecutionPolicy[];
+	readonly policyRefs?: readonly SourceRef[];
+	readonly status?: "ready" | "unavailable" | "misconfigured";
+	readonly issues?: readonly DataIssue[];
+	readonly audit?: readonly AgentRuntimeAuditRecord[];
+	readonly metadata?: Record<string, unknown>;
+}
+
+/**
+ * Options for producing a local builtin tool-provider catalog (D359). Limits and
+ * capabilities are declarative policy hints; execution remains adapter-owned.
+ */
+export interface LocalBuiltinToolProviderCatalogOptions {
+	readonly providerId?: string;
+	readonly executorId?: string;
+	readonly profileId?: string;
+	readonly tools?: readonly Omit<
+		ToolProviderCatalogEntry,
+		"kind" | "providerId" | "inputKind" | "profileId" | "executorId"
+	>[];
+	readonly limits?: Record<string, number>;
+	readonly capabilities?: Record<string, unknown>;
+	readonly policies?: readonly ToolProviderExecutionPolicy[];
+	readonly policyOverrides?: Partial<
+		Omit<ToolProviderExecutionPolicy, "kind" | "policyId" | "providerId">
+	>;
+	readonly metadata?: Record<string, unknown>;
+}
+
+export type ToolProviderPolicyResolutionStatus =
+	| "pending-route"
+	| "resolved"
+	| "missing-tool-call"
+	| "missing-catalog"
+	| "ambiguous-catalog"
+	| "missing-tool"
+	| "missing-policy"
+	| "invalid-policy";
+
+export interface ToolProviderPolicyResolution {
+	readonly kind: "tool-provider-policy-resolution";
+	readonly resolutionId: string;
+	readonly status: ToolProviderPolicyResolutionStatus;
+	readonly requestId: string;
+	readonly operationId: string;
+	readonly routeId?: string;
+	readonly providerId?: string;
+	readonly executorId?: string;
+	readonly profileId?: string;
+	readonly toolName?: string;
+	readonly operation?: string;
+	readonly policyRefs?: readonly SourceRef[];
+	readonly issues?: readonly DataIssue[];
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface ToolProviderPolicyResolutionBundle {
+	readonly resolutions: Node<ToolProviderPolicyResolution>;
+	readonly issues: Node<DataIssue>;
+	readonly audit: Node<AgentRuntimeAuditRecord>;
+}
+
+export type ToolProviderAdapterInputStatus =
+	| "ready"
+	| Exclude<ToolProviderPolicyResolutionStatus, "resolved">;
+
+/**
+ * Data-only adapter input projection for optional Layer C tool providers
+ * (D359/D360). It packages already-routed AgentRequest/tool-call material plus
+ * selected D360 policy facts for an adapter boundary, but it never executes a
+ * tool and never carries clients, transports, credentials, subprocesses, SDK
+ * handles, or OAuth state.
+ */
+export interface ToolProviderAdapterInput<TArguments = unknown> {
+	readonly kind: "tool-provider-adapter-input";
+	readonly adapterInputId: string;
+	readonly status: ToolProviderAdapterInputStatus;
+	readonly requestId: string;
+	readonly operationId: string;
+	readonly effectRunId?: string;
+	readonly agentRunId?: string;
+	readonly routeId?: string;
+	readonly providerId?: string;
+	readonly executorId?: string;
+	readonly profileId?: string;
+	readonly toolName?: string;
+	readonly operation?: string;
+	readonly input?: AgentRequestInput<ToolCallInput<TArguments>>;
+	readonly toolCall?: ToolCallInput<TArguments>;
+	readonly route?: ExecutorRoute;
+	readonly tool?: ToolProviderCatalogEntry;
+	readonly policies?: readonly ToolProviderExecutionPolicy[];
+	readonly policyRefs?: readonly SourceRef[];
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly issues?: readonly DataIssue[];
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface ToolProviderAdapterInputBundle {
+	readonly inputs: Node<ToolProviderAdapterInput>;
+	readonly issues: Node<DataIssue>;
+	readonly audit: Node<AgentRuntimeAuditRecord>;
+}
+
+export type ToolProviderAdapterRunResult<T = unknown> =
+	| {
+			readonly kind: "result";
+			readonly result: AgentOutputEnvelope<T>;
+			readonly evidenceRefs?: readonly SourceRef[];
+			readonly issues?: readonly DataIssue[];
+			readonly usage?: ExecutorUsage;
+			readonly occurredAtMs?: number;
+			readonly metadata?: Record<string, unknown>;
+	  }
+	| {
+			readonly kind: "failure";
+			readonly error: DataIssue;
+			readonly retryable?: boolean;
+			readonly evidenceRefs?: readonly SourceRef[];
+			readonly issues?: readonly DataIssue[];
+			readonly usage?: ExecutorUsage;
+			readonly occurredAtMs?: number;
+			readonly metadata?: Record<string, unknown>;
+	  }
+	| {
+			readonly kind: "canceled";
+			readonly reason?: string;
+			readonly evidenceRefs?: readonly SourceRef[];
+			readonly issues?: readonly DataIssue[];
+			readonly usage?: ExecutorUsage;
+			readonly occurredAtMs?: number;
+			readonly metadata?: Record<string, unknown>;
+	  }
+	| {
+			readonly kind: "timeout";
+			readonly timeoutMs?: number;
+			readonly retryable?: boolean;
+			readonly evidenceRefs?: readonly SourceRef[];
+			readonly issues?: readonly DataIssue[];
+			readonly usage?: ExecutorUsage;
+			readonly occurredAtMs?: number;
+			readonly metadata?: Record<string, unknown>;
+	  }
+	| {
+			readonly kind: "blocked";
+			readonly needs: readonly AgentNeed[];
+			readonly evidenceRefs?: readonly SourceRef[];
+			readonly issues?: readonly DataIssue[];
+			readonly usage?: ExecutorUsage;
+			readonly occurredAtMs?: number;
+			readonly metadata?: Record<string, unknown>;
+	  };
+
+export interface ToolProviderAdapterRunContext {
+	readonly runId?: string;
+	readonly attempt: number;
+	readonly reason?: ToolProviderAdapterRunReason;
+	readonly sourceRefs: readonly SourceRef[];
+	readonly now?: () => number;
+}
+
+export type ToolProviderAdapterRunReason = "initial" | "retry" | "manual" | (string & {});
+
+/**
+ * Graph-visible D362 execution lifecycle request. Attempts stay out of
+ * ToolProviderAdapterInput identity; this fact is the visible run coordinate.
+ */
+export interface ToolProviderAdapterRunRequested {
+	readonly kind: "tool-provider-adapter-run-requested";
+	readonly runId: string;
+	readonly adapterInputId: string;
+	readonly requestId: string;
+	readonly operationId: string;
+	readonly routeId?: string;
+	readonly providerId?: string;
+	readonly executorId?: string;
+	readonly profileId?: string;
+	readonly attempt: number;
+	readonly reason: ToolProviderAdapterRunReason;
+	readonly retryOfOutcomeId?: string;
+	readonly policyRefs?: readonly SourceRef[];
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly metadata?: Record<string, unknown>;
+	readonly requestedAtMs?: number;
+}
+
+export interface ToolProviderAdapterRunStatus {
+	readonly kind: "tool-provider-adapter-run-status";
+	readonly runId: string;
+	readonly adapterInputId: string;
+	readonly requestId?: string;
+	readonly operationId?: string;
+	readonly status:
+		| "requested"
+		| "missing-request"
+		| "missing-input"
+		| "stale-request"
+		| "mismatched-request"
+		| "retention-gap"
+		| "started"
+		| ExecutorOutcomeStatus;
+	readonly attempt?: number;
+	readonly outcomeId?: string;
+	readonly issues?: readonly DataIssue[];
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface ToolProviderAdapterRunBundle {
+	readonly requests: Node<ToolProviderAdapterRunRequested>;
+	readonly status: Node<ToolProviderAdapterRunStatus>;
+	readonly issues: Node<DataIssue>;
+	readonly audit: Node<AgentRuntimeAuditRecord>;
+}
+
+export type ToolProviderRunAdmissionOutcome = "admit" | "block" | "defer";
+export type ToolProviderRunAdmissionState = "admitted" | "blocked" | "deferred" | "waiting";
+
+export interface ToolProviderRunAdmissionProposal {
+	readonly kind: "tool-provider-run-admission-proposal";
+	readonly proposalId: string;
+	readonly runId: string;
+	readonly adapterInputId: string;
+	readonly requestId: string;
+	readonly operationId: string;
+	readonly routeId?: string;
+	readonly providerId?: string;
+	readonly executorId?: string;
+	readonly profileId?: string;
+	readonly toolName?: string;
+	readonly operation?: string;
+	readonly attempt: number;
+	readonly reason: ToolProviderAdapterRunReason;
+	readonly approvalMode: "auto" | "require" | "never" | "custom" | (string & {});
+	readonly policyRefs?: readonly SourceRef[];
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly needs?: readonly AgentNeed[];
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface ToolProviderRunAdmissionDecision {
+	readonly kind: "tool-provider-run-admission-decision";
+	readonly decisionId: string;
+	readonly proposalId: string;
+	readonly admissionId: string;
+	readonly outcome: ToolProviderRunAdmissionOutcome;
+	readonly approvedRunId?: string;
+	readonly reason?: string;
+	readonly decidedByRef?: SourceRef;
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface ToolProviderRunAdmission {
+	readonly kind: "tool-provider-run-admission";
+	readonly admissionId: string;
+	readonly proposalId: string;
+	readonly runId: string;
+	readonly adapterInputId: string;
+	readonly requestId: string;
+	readonly operationId: string;
+	readonly state: ToolProviderRunAdmissionState;
+	readonly decisionId?: string;
+	readonly approvedRunId?: string;
+	readonly reason?: string;
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface ToolProviderRunAdmissionStatus {
+	readonly kind: "tool-provider-run-admission-status";
+	readonly proposalId: string;
+	readonly runId: string;
+	readonly adapterInputId: string;
+	readonly requestId?: string;
+	readonly operationId?: string;
+	readonly state: ToolProviderRunAdmissionState | "issue";
+	readonly admissionId?: string;
+	readonly decisionId?: string;
+	readonly approvedRunId?: string;
+	readonly issues?: readonly DataIssue[];
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface ToolProviderRunAdmissionViews {
+	readonly admissionsByProposal: ReadonlyMap<string, ToolProviderRunAdmission>;
+	readonly admissionsByRun: ReadonlyMap<string, readonly ToolProviderRunAdmission[]>;
+	readonly proposalsByRun: ReadonlyMap<string, readonly ToolProviderRunAdmissionProposal[]>;
+}
+
+export interface ToolProviderRunAdmissionBundle {
+	readonly proposals: Node<ToolProviderRunAdmissionProposal>;
+	readonly admissions: Node<ToolProviderRunAdmission>;
+	readonly approvedRunRequests: Node<ToolProviderAdapterRunRequested>;
+	readonly status: Node<ToolProviderRunAdmissionStatus>;
+	readonly issues: Node<DataIssue>;
+	readonly audit: Node<AgentRuntimeAuditRecord>;
+	readonly views: Node<ToolProviderRunAdmissionViews>;
+}
+
+export interface ToolProviderRunRetryPolicy {
+	readonly kind: "tool-provider-run-retry-policy";
+	readonly policyId: string;
+	readonly retryPolicy: RetryPolicy;
+	readonly runId?: string;
+	readonly requestId?: string;
+	readonly adapterInputId?: string;
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface ToolProviderRunRetryProposal {
+	readonly kind: "tool-provider-run-retry-proposal";
+	readonly proposalId: string;
+	readonly outcomeId: string;
+	readonly fromRunId: string;
+	readonly fromRequestId: string;
+	readonly fromAttempt: number;
+	readonly nextAttempt: number;
+	readonly nextRunId: string;
+	readonly adapterInputId: string;
+	readonly requestId: string;
+	readonly operationId: string;
+	readonly policyId?: string;
+	readonly policyRefs?: readonly SourceRef[];
+	readonly maxAttempts: number;
+	readonly nextDelayMs?: number;
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface ToolProviderRunRetryScheduled {
+	readonly kind: "tool-provider-run-retry-scheduled";
+	readonly scheduleId: string;
+	readonly readinessScheduleId?: string;
+	readonly outcomeId: string;
+	readonly proposalId: string;
+	readonly fromRunId: string;
+	readonly nextRunId: string;
+	readonly nextAttempt: number;
+	readonly retryAtMs: number;
+	readonly retryAfterMs: number;
+	readonly sourceRefs?: readonly SourceRef[];
+}
+
+export type ToolProviderRunRetryStatusState =
+	| "scheduled"
+	| "ready"
+	| "exhausted"
+	| "not-retryable"
+	| "blocked";
+
+export interface ToolProviderRunRetryStatus {
+	readonly kind: "tool-provider-run-retry-status";
+	readonly statusId: string;
+	readonly outcomeId: string;
+	readonly proposalId: string;
+	readonly fromRunId: string;
+	readonly adapterInputId: string;
+	readonly requestId: string;
+	readonly operationId: string;
+	readonly nextRunId?: string;
+	readonly nextAttempt?: number;
+	readonly nextRetryAtMs?: number;
+	readonly state: ToolProviderRunRetryStatusState;
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly issueCodes?: readonly string[];
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface ToolProviderRunRetryViews {
+	readonly proposalsByOutcome: ReadonlyMap<string, ToolProviderRunRetryProposal>;
+	readonly scheduledByOutcome: ReadonlyMap<string, ToolProviderRunRetryScheduled>;
+	readonly readinessSchedulesByOutcome: ReadonlyMap<string, ScheduledReadinessRequested>;
+	readonly readinessBySchedule: ReadonlyMap<string, ScheduledReadinessReady>;
+	readonly nextRunRequestsByOutcome: ReadonlyMap<string, ToolProviderAdapterRunRequested>;
+	readonly statusByOutcome: ReadonlyMap<string, ToolProviderRunRetryStatus>;
+}
+
+export interface ToolProviderRunRetryBundle {
+	readonly proposals: Node<ToolProviderRunRetryProposal>;
+	readonly scheduled: Node<ToolProviderRunRetryScheduled>;
+	readonly readinessSchedules: Node<ScheduledReadinessRequested>;
+	readonly runRequests: Node<ToolProviderAdapterRunRequested>;
+	readonly status: Node<ToolProviderRunRetryStatus>;
+	readonly issues: Node<DataIssue>;
+	readonly audit: Node<AgentRuntimeAuditRecord>;
+	readonly views: Node<ToolProviderRunRetryViews>;
+}
+
+export interface ToolProviderPublicTextPolicy {
+	readonly maxMessageChars?: number;
+	readonly maxSummaryChars?: number;
+	readonly maxReasonChars?: number;
+	readonly maxMetadataStringChars?: number;
+}
+
+export type ToolProviderAdapterRuntimeRetentionIndex =
+	| "adapterInputs"
+	| "runRequests"
+	| "executions"
+	| "runStatuses"
+	| "runIssues"
+	| "retentionEvidence";
+
+export type ToolProviderAdapterRuntimeRetentionOrder = "fifo";
+
+export interface ToolProviderAdapterInputRetentionEntry {
+	readonly key: string;
+	readonly sequence: number;
+	readonly insertedAtMs?: number;
+	readonly adapterInputId: string;
+	readonly requestId: string;
+	readonly operationId: string;
+	readonly routeId?: string;
+	readonly providerId?: string;
+	readonly executorId?: string;
+	readonly profileId?: string;
+	readonly status?: ToolProviderAdapterInputStatus;
+}
+
+export interface ToolProviderAdapterRunRequestRetentionEntry {
+	readonly key: string;
+	readonly sequence: number;
+	readonly requestedAtMs?: number;
+	readonly adapterInputId: string;
+	readonly runId: string;
+	readonly attempt: number;
+	readonly requestId: string;
+	readonly operationId: string;
+	readonly routeId?: string;
+	readonly providerId?: string;
+	readonly executorId?: string;
+	readonly profileId?: string;
+	readonly reason?: ToolProviderAdapterRunReason;
+}
+
+export interface ToolProviderAdapterExecutionRetentionEntry {
+	readonly key: string;
+	readonly sequence: number;
+	readonly occurredAtMs?: number;
+	readonly adapterInputId: string;
+	readonly runId: string;
+	readonly attempt: number;
+	readonly requestId: string;
+	readonly operationId: string;
+	readonly routeId?: string;
+	readonly providerId?: string;
+	readonly executorId?: string;
+	readonly profileId?: string;
+	readonly outcomeId?: string;
+	readonly status?: ExecutorOutcomeStatus | "started";
+	readonly reason?: ToolProviderAdapterRunReason;
+}
+
+export interface ToolProviderAdapterRunStatusRetentionEntry {
+	readonly key: string;
+	readonly sequence: number;
+	readonly occurredAtMs?: number;
+	readonly adapterInputId: string;
+	readonly runId: string;
+	readonly attempt?: number;
+	readonly requestId?: string;
+	readonly operationId?: string;
+	readonly status: ToolProviderAdapterRunStatus["status"];
+	readonly outcomeId?: string;
+	readonly issueCode?: string;
+}
+
+export interface ToolProviderAdapterRunIssueRetentionEntry {
+	readonly key: string;
+	readonly sequence: number;
+	readonly occurredAtMs?: number;
+	readonly adapterInputId?: string;
+	readonly runId?: string;
+	readonly attempt?: number;
+	readonly requestId?: string;
+	readonly operationId?: string;
+	readonly issueCode: string;
+	readonly severity?: DataIssue["severity"];
+	readonly subjectId?: string;
+}
+
+export interface ToolProviderAdapterRuntimeRetentionEvidenceEntry {
+	readonly key: string;
+	readonly sequence: number;
+	readonly occurredAtMs?: number;
+	readonly adapterInputId: string;
+	readonly evidenceKind: "adapter-input-trimmed" | "execution-high-water";
+	readonly attemptHighWater?: number;
+	readonly reason: "adapter-input-retention" | "execution-proof-retention";
+}
+
+export type ToolProviderAdapterRuntimeIndexRetentionPolicy<Entry> =
+	| CapacityPolicy<ToolProviderAdapterRuntimeRetentionOrder>
+	| (RetentionPolicy<Entry> & { readonly maxSize: ReactiveOpt<number> });
+
+export interface ToolProviderAdapterRuntimeRetentionPolicy {
+	readonly adapterInputs?: ToolProviderAdapterRuntimeIndexRetentionPolicy<ToolProviderAdapterInputRetentionEntry>;
+	readonly runRequests?: ToolProviderAdapterRuntimeIndexRetentionPolicy<ToolProviderAdapterRunRequestRetentionEntry>;
+	readonly executions?: ToolProviderAdapterRuntimeIndexRetentionPolicy<ToolProviderAdapterExecutionRetentionEntry>;
+	readonly runStatuses?: ToolProviderAdapterRuntimeIndexRetentionPolicy<ToolProviderAdapterRunStatusRetentionEntry>;
+	readonly runIssues?: ToolProviderAdapterRuntimeIndexRetentionPolicy<ToolProviderAdapterRunIssueRetentionEntry>;
+	readonly retentionEvidence?: ToolProviderAdapterRuntimeIndexRetentionPolicy<ToolProviderAdapterRuntimeRetentionEvidenceEntry>;
+}
+
+export type ToolProviderAdapterRuntimeStatusKind =
+	| "retention-trimmed"
+	| "retention-gap"
+	| "invalid-retention-policy";
+
+export interface ToolProviderAdapterRuntimeStatus {
+	readonly kind: "tool-provider-adapter-runtime-status";
+	readonly status: ToolProviderAdapterRuntimeStatusKind;
+	readonly index?: ToolProviderAdapterRuntimeRetentionIndex;
+	readonly key?: string;
+	readonly adapterInputId?: string;
+	readonly runId?: string;
+	readonly attempt?: number;
+	readonly issueCode?: string;
+	readonly occurredAtMs?: number;
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly metadata?: Record<string, unknown>;
+}
+
+/**
+ * Runtime-private adapter binding for D361. Bindings may close over clients,
+ * credentials, subprocess access, transports, SDK objects, or environment
+ * handles, but the binding itself must never be graph DATA or WorkItem core
+ * material.
+ */
+export interface ToolProviderAdapterBinding<TArguments = unknown, TResult = unknown> {
+	readonly providerId: string;
+	run(
+		input: ToolProviderAdapterInput<TArguments>,
+		ctx: ToolProviderAdapterRunContext,
+	): ToolProviderAdapterRunResult<TResult>;
+}
+
+export interface ToolProviderAdapterRuntimeOptions<TArguments = unknown, TResult = unknown> {
+	readonly name?: string;
+	readonly inputs: Node<ToolProviderAdapterInput<TArguments>>;
+	readonly runRequests?: readonly Node<ToolProviderAdapterRunRequested>[];
+	readonly bindings:
+		| readonly ToolProviderAdapterBinding<TArguments, TResult>[]
+		| ReadonlyMap<string, ToolProviderAdapterBinding<TArguments, TResult>>;
+	readonly autoRunReadyInputs?: boolean;
+	readonly retention?: ToolProviderAdapterRuntimeRetentionPolicy;
+	readonly now?: () => number;
+	readonly publicText?: ToolProviderPublicTextPolicy;
+}
+
+export interface ToolProviderAdapterRuntimeHandle {
+	readonly runRequests: Node<ToolProviderAdapterRunRequested>;
+	readonly runStatus: Node<ToolProviderAdapterRunStatus>;
+	readonly runtimeStatus: Node<ToolProviderAdapterRuntimeStatus>;
+	readonly outcomes: Node<ExecutorOutcome>;
+	readonly status: Node<AgentRequestStatusChanged>;
+	readonly issues: Node<DataIssue>;
+	readonly audit: Node<AgentRuntimeAuditRecord>;
+	dispose(): void;
+}
+
+/**
+ * Audience selector for bounded ExecutorOutcome projections (D359).
+ */
+export type ExecutorOutcomeViewAudience = "agent-observation" | "ui" | "diagnostic" | "audit";
+
+/**
+ * View policy for deriving bounded, audience-specific ExecutorOutcome summaries
+ * (D359/D270/D293) without inlining large/raw provider material.
+ */
+export interface ExecutorOutcomeViewPolicy {
+	readonly audience?: ExecutorOutcomeViewAudience;
+	readonly maxSummaryChars?: number;
+	readonly includeIssues?: boolean;
+	readonly includeUsage?: boolean;
+	readonly includeMetadata?: boolean;
+}
+
+/**
+ * Bounded projection of ExecutorOutcome for agent, UI, diagnostic, or audit
+ * consumers (D359). Large/raw material stays behind refs.
+ */
+export interface ExecutorOutcomeView {
+	readonly kind: "executor-outcome-view";
+	readonly viewId: string;
+	readonly audience: ExecutorOutcomeViewAudience;
+	readonly outcomeId: string;
+	readonly requestId: string;
+	readonly operationId: string;
+	readonly routeId: string;
+	readonly executorId: string;
+	readonly profileId: string;
+	readonly status: ExecutorOutcomeStatus;
+	readonly summary: string;
+	readonly summaryTruncated?: boolean;
+	readonly summaryChars?: number;
+	readonly summaryLimitChars?: number;
+	readonly errorKind?: string;
+	readonly retryable?: boolean;
+	readonly nextActions?: readonly string[];
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly materialRefs?: readonly SourceRef[];
+	readonly issues?: readonly DataIssue[];
+	readonly usage?: ExecutorUsage;
+	readonly metadata?: Record<string, unknown>;
+}
+
+/**
+ * Output bundle for ExecutorOutcome view projectors (D359).
+ */
+export interface ExecutorOutcomeViewBundle {
+	readonly views: Node<ExecutorOutcomeView>;
+	readonly issues: Node<DataIssue>;
+	readonly audit: Node<AgentRuntimeAuditRecord>;
+}
diff --git a/packages/ts/src/orchestration/agent-runtime.ts b/packages/ts/src/orchestration/agent-runtime.ts
new file mode 100644
index 00000000..b6395e1e
--- /dev/null
+++ b/packages/ts/src/orchestration/agent-runtime.ts
@@ -0,0 +1,85 @@
+export {
+	requestToolProviderAdapterRun,
+	toolProviderAdapterRunProjector,
+} from "./agent-runtime-adapter-run.js";
+export { structuredAgentDecisionInterpreter } from "./agent-runtime-decision-interpreter.js";
+export { effectRunCompletionProjector } from "./agent-runtime-effect-completion.js";
+export { buildToolProviderExecutorOutcome } from "./agent-runtime-executor-outcome.js";
+export {
+	fakeExecutorBlocked,
+	fakeExecutorCanceled,
+	fakeExecutorFailure,
+	fakeExecutorResult,
+	fakeExecutorTimeout,
+} from "./agent-runtime-fakes.js";
+export { executorOutcomeViewProjector } from "./agent-runtime-outcome-view.js";
+export {
+	admitAgentRequestProposal,
+	agentRequestLedgerViews,
+	agentRequestProposalFromDecision,
+	issueAgentRequest,
+} from "./agent-runtime-request-ledger.js";
+export { requestSatisfactionProjector } from "./agent-runtime-request-satisfaction.js";
+export {
+	buildToolProviderAdapterInputs,
+	toolProviderAdapterInputProjector,
+} from "./agent-runtime-tool-provider-input.js";
+export {
+	localBuiltinToolProviderCatalog,
+	resolveToolProviderExecutionPolicies,
+	toolProviderPolicyResolutionProjector,
+	validateToolProviderExecutionPolicy,
+} from "./agent-runtime-tool-provider-policy.js";
+export { toolProviderRunAdmissionProjector } from "./agent-runtime-tool-provider-run-admission.js";
+export { toolProviderRunRetryProjector } from "./agent-runtime-tool-provider-run-retry.js";
+export type * from "./agent-runtime-types-agent.js";
+export type * from "./agent-runtime-types-core.js";
+export { effectRun } from "./agent-runtime-types-core.js";
+export type {
+	ExecutorOutcomeView,
+	ExecutorOutcomeViewAudience,
+	ExecutorOutcomeViewBundle,
+	ExecutorOutcomeViewPolicy,
+	LocalBuiltinToolProviderCatalogOptions,
+	ToolCallInput,
+	ToolProviderAdapterInput,
+	ToolProviderAdapterInputBundle,
+	ToolProviderAdapterInputStatus,
+	ToolProviderAdapterRunBundle,
+	ToolProviderAdapterRunReason,
+	ToolProviderAdapterRunRequested,
+	ToolProviderAdapterRunStatus,
+	ToolProviderApprovalPolicy,
+	ToolProviderArtifactPolicy,
+	ToolProviderCatalog,
+	ToolProviderCatalogEntry,
+	ToolProviderExecutionPolicy,
+	ToolProviderFilesystemPolicy,
+	ToolProviderKind,
+	ToolProviderNetworkPolicy,
+	ToolProviderPathRule,
+	ToolProviderPolicyResolution,
+	ToolProviderPolicyResolutionBundle,
+	ToolProviderPolicyResolutionStatus,
+	ToolProviderPublicTextPolicy,
+	ToolProviderRedactionPolicy,
+	ToolProviderRunAdmission,
+	ToolProviderRunAdmissionBundle,
+	ToolProviderRunAdmissionDecision,
+	ToolProviderRunAdmissionOutcome,
+	ToolProviderRunAdmissionProposal,
+	ToolProviderRunAdmissionState,
+	ToolProviderRunAdmissionStatus,
+	ToolProviderRunAdmissionViews,
+	ToolProviderRunRetryBundle,
+	ToolProviderRunRetryPolicy,
+	ToolProviderRunRetryProposal,
+	ToolProviderRunRetryScheduled,
+	ToolProviderRunRetryStatus,
+	ToolProviderRunRetryStatusState,
+	ToolProviderRunRetryViews,
+	ToolProviderSizeCapacityPolicy,
+	ToolProviderSizeLimit,
+	ToolProviderSizeUnit,
+	ToolProviderTimeoutPolicy,
+} from "./agent-runtime-types-tool.js";
diff --git a/packages/ts/src/orchestration/index.ts b/packages/ts/src/orchestration/index.ts
new file mode 100644
index 00000000..45e22281
--- /dev/null
+++ b/packages/ts/src/orchestration/index.ts
@@ -0,0 +1,32 @@
+/**
+ * Reusable application-infrastructure orchestration namespace.
+ *
+ * Retained root orchestration helpers land here only after B63 re-derives them
+ * onto clean-slate graph surfaces.
+ */
+
+export {
+	type BackoffPolicy,
+	backoffDelayMs,
+	nextRetryDelayMs,
+	noBackoff,
+	type RetryPolicy,
+	type RetryStatus,
+	retryPolicy,
+	shouldRetry,
+} from "../graph/resilience.js";
+export * from "./agent-runtime.js";
+export * from "./process.js";
+export * from "./resilience-bundles.js";
+export type {
+	ScheduledReadinessBundle,
+	ScheduledReadinessClock,
+	ScheduledReadinessOverdue,
+	ScheduledReadinessPending,
+	ScheduledReadinessReady,
+	ScheduledReadinessRequested,
+	ScheduledReadinessStatus,
+	ScheduledReadinessStatusState,
+	ScheduledReadinessViews,
+} from "./scheduled-readiness.js";
+export { scheduledReadinessProjector } from "./scheduled-readiness.js";
diff --git a/packages/ts/src/orchestration/messaging.ts b/packages/ts/src/orchestration/messaging.ts
new file mode 100644
index 00000000..fb33a388
--- /dev/null
+++ b/packages/ts/src/orchestration/messaging.ts
@@ -0,0 +1,393 @@
+/**
+ * Optional orchestration-over-messageBus recipe (D349/D351/D353).
+ *
+ * Ack commands are graph-derived from visible ProcessBundle accepted/rejected
+ * material; retained delivery receipt is never an ack.
+ */
+
+import { depBatch } from "../ctx/types.js";
+import type { DataIssue } from "../data/index.js";
+import type { Graph } from "../graph/graph.js";
+import type {
+	MessageBusAvailablePage,
+	MessageBusCommand,
+	MessageBusMessage,
+} from "../messaging/index.js";
+import type { Node } from "../node/node.js";
+import type { ProcessCommand, ProcessEvent, ProcessStatus } from "../orchestration/index.js";
+
+export interface OrchestrationMessagingPolicy<TPayload = unknown, TCommand = unknown> {
+	readonly command?: (
+		message: MessageBusMessage<TPayload>,
+		delivery: MessageBusDelivery,
+	) => ProcessCommand<TCommand> | undefined;
+	readonly ackRejected?: boolean;
+	readonly outboxTopic?: string;
+}
+
+export interface OrchestrationMessagingRecipeOptions<
+	TPayload = unknown,
+	TCommand = unknown,
+	TEvent = unknown,
+> {
+	readonly name?: string;
+	readonly deliveries: Node<MessageBusAvailablePage<TPayload>>;
+	readonly status: Node<ProcessStatus>;
+	readonly events?: Node<ProcessEvent<TEvent>>;
+	readonly policy?: OrchestrationMessagingPolicy<TPayload, TCommand>;
+}
+
+export interface OrchestrationMessagingRecipeBundle<TCommand = unknown> {
+	readonly commands: Node<ProcessCommand<TCommand>>;
+	readonly ackCommands: Node<MessageBusCommand>;
+	readonly outboxCommands?: Node<MessageBusCommand>;
+	readonly issues: Node<DataIssue>;
+}
+
+type OrchestrationMessagingFact<TCommand> =
+	| { readonly kind: "command"; readonly command: ProcessCommand<TCommand> }
+	| { readonly kind: "issue"; readonly issue: DataIssue };
+
+export interface MessageBusDelivery {
+	readonly topic: string;
+	readonly seq: number;
+	readonly subscriptionId: string;
+	readonly commandId: string;
+}
+
+/** Build the optional D349/D351 orchestration messaging recipe. */
+export function orchestrationMessagingRecipe<
+	TPayload = unknown,
+	TCommand = unknown,
+	TEvent = unknown,
+>(
+	graph: Graph,
+	opts: OrchestrationMessagingRecipeOptions<TPayload, TCommand, TEvent>,
+): OrchestrationMessagingRecipeBundle<TCommand> {
+	const name = opts.name ?? "orchestrationMessaging";
+	const runtime = graph.node<OrchestrationMessagingFact<TCommand>>(
+		[opts.deliveries],
+		(ctx) => {
+			for (const raw of depBatch(ctx, 0) ?? []) {
+				const page = raw as MessageBusAvailablePage<TPayload>;
+				for (const message of page.messages) {
+					const delivery = messageDelivery(page, message);
+					const command = orchestrationMessageCommand(message, delivery, opts.policy);
+					if (command === undefined) {
+						ctx.down([["DATA", { kind: "issue", issue: messageIssue(message, delivery) }]]);
+					} else {
+						ctx.down([["DATA", { kind: "command", command }]]);
+					}
+				}
+			}
+		},
+		{
+			name: `${name}/runtime`,
+			factory: "orchestrationMessagingRuntime",
+			partial: true,
+			completeWhenDepsComplete: false,
+			errorWhenDepsError: false,
+		},
+	);
+	const issues = project(
+		graph,
+		runtime,
+		`${name}/issues`,
+		"orchestrationMessagingIssues",
+		(fact) => (fact.kind === "issue" ? fact.issue : undefined),
+	);
+	const commands = project(
+		graph,
+		runtime,
+		`${name}/commands`,
+		"orchestrationMessagingCommands",
+		(fact) => (fact.kind === "command" ? fact.command : undefined),
+	);
+	return {
+		commands,
+		ackCommands: orchestrationMessageAckCommands(graph, {
+			name: `${name}/ackCommands`,
+			commands,
+			status: opts.status,
+			issues,
+			ackRejected: opts.policy?.ackRejected ?? true,
+		}),
+		...(opts.events === undefined || opts.policy?.outboxTopic === undefined
+			? {}
+			: {
+					outboxCommands: processEventOutboxCommands(graph, opts.events, opts.policy.outboxTopic, {
+						name: `${name}/outboxCommands`,
+					}),
+				}),
+		issues,
+	};
+}
+
+export function orchestrationMessageCommand<TPayload = unknown, TCommand = unknown>(
+	message: MessageBusMessage<TPayload>,
+	delivery: MessageBusDelivery,
+	policy?: OrchestrationMessagingPolicy<TPayload, TCommand>,
+): ProcessCommand<TCommand> | undefined {
+	const mapped = policy?.command?.(message, delivery);
+	if (mapped !== undefined) return commandWithDelivery(mapped, delivery);
+	if (!isObjectRecord(message.payload)) return undefined;
+	const id = stringField(message.payload, "id") ?? delivery.commandId;
+	const type = stringField(message.payload, "type");
+	if (type === undefined) return undefined;
+	return commandWithDelivery(
+		{
+			id,
+			type,
+			payload: message.payload.payload as TCommand,
+			processId: stringField(message.payload, "processId"),
+			correlationId: stringField(message.payload, "correlationId"),
+			causationId: stringField(message.payload, "causationId"),
+			metadata: {
+				...(objectField(message.payload, "metadata") ?? {}),
+			},
+		},
+		delivery,
+	);
+}
+
+export function orchestrationMessageAckCommands(
+	graph: Graph,
+	opts: {
+		readonly name?: string;
+		readonly commands: Node<ProcessCommand>;
+		readonly status: Node<ProcessStatus>;
+		readonly issues?: Node<DataIssue>;
+		readonly ackRejected?: boolean;
+	},
+): Node<MessageBusCommand> {
+	return graph.node<MessageBusCommand>(
+		opts.issues === undefined
+			? [opts.commands, opts.status]
+			: [opts.commands, opts.status, opts.issues],
+		(ctx) => {
+			const deliveries =
+				ctx.state.get<Map<string, MessageBusDelivery[]>>() ??
+				new Map<string, MessageBusDelivery[]>();
+			for (const raw of depBatch(ctx, 0) ?? []) {
+				const command = raw as ProcessCommand;
+				const delivery = commandDelivery(command);
+				if (delivery !== undefined) pushDelivery(deliveries, command.id, delivery);
+			}
+			for (const raw of depBatch(ctx, 1) ?? []) {
+				const status = raw as ProcessStatus;
+				if (status.state === "rejected" && opts.ackRejected === false) continue;
+				if (status.commandId === undefined) continue;
+				const delivery = shiftDelivery(deliveries, status.commandId);
+				if (delivery === undefined) continue;
+				ctx.down([
+					["DATA", ackCommand(delivery, ackCommandId("orchestration", delivery, "status"))],
+				]);
+			}
+			if (opts.issues !== undefined) {
+				for (const raw of depBatch(ctx, 2) ?? []) {
+					const delivery = issueDelivery(raw as DataIssue);
+					if (delivery !== undefined) {
+						ctx.down([
+							["DATA", ackCommand(delivery, ackCommandId("orchestration", delivery, "issue"))],
+						]);
+					}
+				}
+			}
+			ctx.state.set(deliveries);
+		},
+		{
+			name: opts.name ?? "orchestrationMessaging/ackCommands",
+			factory: "orchestrationMessagingAckCommands",
+			partial: true,
+			completeWhenDepsComplete: false,
+			errorWhenDepsError: false,
+		},
+	);
+}
+
+export function processEventOutboxCommands<TEvent>(
+	graph: Graph,
+	events: Node<ProcessEvent<TEvent>>,
+	topic: string,
+	opts: { readonly name?: string } = {},
+): Node<MessageBusCommand> {
+	return graph.node<MessageBusCommand>(
+		[events],
+		(ctx) => {
+			for (const event of depBatch(ctx, 0) ?? []) {
+				const typed = event as ProcessEvent<TEvent>;
+				ctx.down([
+					[
+						"DATA",
+						{
+							kind: "publish",
+							topic,
+							payload: typed,
+							key: typed.processId,
+							commandId: `${typed.id}:process-outbox`,
+							idempotencyKey: typed.id,
+						} satisfies MessageBusCommand,
+					],
+				]);
+			}
+		},
+		{
+			name: opts.name ?? "orchestrationMessaging/outboxCommands",
+			factory: "orchestrationMessagingOutboxCommands",
+			completeWhenDepsComplete: false,
+			errorWhenDepsError: false,
+		},
+	);
+}
+
+function project<T, TCommand>(
+	graph: Graph,
+	runtime: Node<OrchestrationMessagingFact<TCommand>>,
+	name: string,
+	factory: string,
+	pick: (fact: OrchestrationMessagingFact<TCommand>) => T | undefined,
+): Node<T> {
+	return graph.node<T>(
+		[runtime],
+		(ctx) => {
+			for (const fact of depBatch(ctx, 0) ?? []) {
+				const value = pick(fact as OrchestrationMessagingFact<TCommand>);
+				if (value !== undefined) ctx.down([["DATA", value]]);
+			}
+		},
+		{ name, factory, partial: true, completeWhenDepsComplete: false, errorWhenDepsError: false },
+	);
+}
+
+function messageIssue(message: MessageBusMessage, delivery: MessageBusDelivery): DataIssue {
+	return {
+		kind: "issue",
+		code: "orchestration-message-lowering-rejected",
+		message: "Orchestration messaging recipe could not lower retained message to a command fact",
+		severity: "error",
+		source: "orchestration.messaging",
+		metadata: {
+			messageBus: {
+				topic: delivery.topic,
+				seq: delivery.seq,
+				subscriptionId: delivery.subscriptionId,
+				commandId: delivery.commandId,
+			},
+		},
+		details: message,
+	};
+}
+
+function ackCommand(delivery: MessageBusDelivery, commandId: string): MessageBusCommand {
+	return {
+		kind: "ack",
+		topic: delivery.topic,
+		subscriptionId: delivery.subscriptionId,
+		seq: delivery.seq,
+		commandId,
+	};
+}
+
+function ackCommandId(namespace: string, delivery: MessageBusDelivery, reason: string): string {
+	return `${namespace}:${delivery.topic}:${delivery.subscriptionId}:${delivery.seq}:${reason}-ack`;
+}
+
+function commandWithDelivery<TCommand>(
+	command: ProcessCommand<TCommand>,
+	delivery: MessageBusDelivery,
+): ProcessCommand<TCommand> {
+	return {
+		...command,
+		metadata: {
+			...(command.metadata ?? {}),
+			messageBus: delivery,
+		},
+	};
+}
+
+function messageDelivery(
+	page: MessageBusAvailablePage,
+	message: MessageBusMessage,
+): MessageBusDelivery {
+	return {
+		topic: page.topic,
+		seq: message.seq,
+		subscriptionId: page.subscriptionId,
+		commandId:
+			isObjectRecord(message.payload) && typeof message.payload.id === "string"
+				? message.payload.id
+				: (message.commandId ?? `${page.topic}:${message.seq}`),
+	};
+}
+
+function pushDelivery(
+	deliveries: Map<string, MessageBusDelivery[]>,
+	commandId: string,
+	delivery: MessageBusDelivery,
+): void {
+	const queue = deliveries.get(commandId) ?? [];
+	deliveries.set(commandId, [...queue, delivery]);
+}
+
+function shiftDelivery(
+	deliveries: Map<string, MessageBusDelivery[]>,
+	commandId: string,
+): MessageBusDelivery | undefined {
+	const queue = deliveries.get(commandId);
+	if (queue === undefined || queue.length === 0) return undefined;
+	const [first, ...rest] = queue;
+	if (rest.length === 0) deliveries.delete(commandId);
+	else deliveries.set(commandId, rest);
+	return first;
+}
+
+function issueDelivery(issue: DataIssue): MessageBusDelivery | undefined {
+	const metadata = isObjectRecord(issue.metadata) ? issue.metadata : undefined;
+	const messageBus = isObjectRecord(metadata?.messageBus) ? metadata.messageBus : undefined;
+	if (messageBus === undefined) return undefined;
+	if (typeof messageBus.topic !== "string" || typeof messageBus.seq !== "number") return undefined;
+	if (typeof messageBus.subscriptionId !== "string") return undefined;
+	if (typeof messageBus.commandId !== "string") return undefined;
+	return {
+		topic: messageBus.topic,
+		seq: messageBus.seq,
+		subscriptionId: messageBus.subscriptionId,
+		commandId: messageBus.commandId,
+	};
+}
+
+function commandDelivery(command: ProcessCommand): MessageBusDelivery | undefined {
+	const metadata = isObjectRecord(command.metadata) ? command.metadata : undefined;
+	const messageBus = isObjectRecord(metadata?.messageBus) ? metadata.messageBus : undefined;
+	if (messageBus === undefined) return undefined;
+	return messageBusDelivery(messageBus);
+}
+
+function messageBusDelivery(messageBus: Record<string, unknown>): MessageBusDelivery | undefined {
+	if (typeof messageBus.topic !== "string" || typeof messageBus.seq !== "number") return undefined;
+	if (typeof messageBus.subscriptionId !== "string") return undefined;
+	const commandId = typeof messageBus.commandId === "string" ? messageBus.commandId : "";
+	return {
+		topic: messageBus.topic,
+		seq: messageBus.seq,
+		subscriptionId: messageBus.subscriptionId,
+		commandId,
+	};
+}
+
+function stringField(record: Record<string, unknown>, key: string): string | undefined {
+	const value = record[key];
+	return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+
+function objectField(
+	record: Record<string, unknown>,
+	key: string,
+): Record<string, unknown> | undefined {
+	const value = record[key];
+	return isObjectRecord(value) ? value : undefined;
+}
+
+function isObjectRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null;
+}
diff --git a/packages/ts/src/orchestration/process-types.ts b/packages/ts/src/orchestration/process-types.ts
new file mode 100644
index 00000000..41b6dcca
--- /dev/null
+++ b/packages/ts/src/orchestration/process-types.ts
@@ -0,0 +1,240 @@
+import type { Node } from "../node/node.js";
+
+/** D136 graph-visible process command fact. */
+export interface ProcessCommand<T = unknown> {
+	readonly id: string;
+	readonly type: string;
+	readonly payload: T;
+	readonly processId?: string;
+	readonly correlationId?: string;
+	readonly causationId?: string;
+	readonly metadata?: Record<string, unknown>;
+}
+
+/** Event draft returned by a ProcessBundle reducer before runtime ordering. */
+export interface ProcessEventDraft<T = unknown> {
+	readonly id?: string;
+	readonly type: string;
+	readonly payload: T;
+	readonly processId?: string;
+	readonly correlationId?: string;
+	readonly causationId?: string;
+	readonly metadata?: Record<string, unknown>;
+}
+
+/** Ordered process event fact. These are DATA facts, not protocol messages. */
+export interface ProcessEvent<T = unknown> {
+	readonly id: string;
+	readonly type: string;
+	readonly seq: number;
+	readonly cursor: number;
+	readonly commandId: string;
+	readonly commandType: string;
+	readonly payload: T;
+	readonly timestampMs: number;
+	readonly processId?: string;
+	readonly correlationId?: string;
+	readonly causationId?: string;
+	readonly metadata?: Record<string, unknown>;
+}
+
+/** Effect-request draft emitted by a ProcessBundle reducer for visible effect runners. */
+export interface ProcessEffectRequestDraft<T = unknown> {
+	readonly id?: string;
+	readonly type: string;
+	readonly payload: T;
+	readonly processId?: string;
+	readonly correlationId?: string;
+	readonly causationId?: string;
+	readonly metadata?: Record<string, unknown>;
+}
+
+/** Ordered effect-request fact. Effect runners consume this node in later slices. */
+export interface ProcessEffectRequest<T = unknown> {
+	readonly id: string;
+	readonly type: string;
+	readonly seq: number;
+	readonly cursor: number;
+	readonly commandId: string;
+	readonly commandType: string;
+	readonly payload: T;
+	readonly timestampMs: number;
+	readonly processId?: string;
+	readonly correlationId?: string;
+	readonly causationId?: string;
+	readonly metadata?: Record<string, unknown>;
+}
+
+export type ProcessEffectCommandType =
+	| "effect.result"
+	| "effect.failure"
+	| "effect.cancel"
+	| "effect.timeout";
+
+interface ProcessEffectOutcomeBase {
+	readonly effectId: string;
+	readonly effectType: string;
+	readonly processId?: string;
+	readonly correlationId?: string;
+	readonly causationId?: string;
+	readonly commandId?: string;
+	readonly metadata?: Record<string, unknown>;
+}
+
+export type ProcessEffectOutcome<TResult = unknown> =
+	| (ProcessEffectOutcomeBase & { readonly kind: "result"; readonly value: TResult })
+	| (ProcessEffectOutcomeBase & { readonly kind: "failure"; readonly error: unknown })
+	| (ProcessEffectOutcomeBase & { readonly kind: "cancel"; readonly reason?: string })
+	| (ProcessEffectOutcomeBase & { readonly kind: "timeout"; readonly error: unknown });
+
+export type ProcessEffectCommandPayload<TResult = unknown> =
+	| (Omit<ProcessEffectOutcomeBase, "commandId"> & {
+			readonly kind: "result";
+			readonly value: TResult;
+	  })
+	| (Omit<ProcessEffectOutcomeBase, "commandId"> & {
+			readonly kind: "failure";
+			readonly error: unknown;
+	  })
+	| (Omit<ProcessEffectOutcomeBase, "commandId"> & {
+			readonly kind: "cancel";
+			readonly reason?: string;
+	  })
+	| (Omit<ProcessEffectOutcomeBase, "commandId"> & {
+			readonly kind: "timeout";
+			readonly error: unknown;
+	  });
+
+export type ProcessErrorCode =
+	| "malformed-command"
+	| "reducer-threw"
+	| "clock-threw"
+	| "malformed-state"
+	| "malformed-event"
+	| "malformed-effect";
+
+/** Graph-visible ProcessBundle error fact. These are DATA facts, not protocol ERROR. */
+export interface ProcessError {
+	readonly code: ProcessErrorCode;
+	readonly message: string;
+	readonly command?: unknown;
+	readonly commandId?: string;
+	readonly commandType?: string;
+	readonly cursor: ProcessCursor;
+}
+
+/** Accepted/rejected command outcome projected from the ProcessBundle runtime. */
+export interface ProcessStatus {
+	readonly state: "accepted" | "rejected";
+	readonly commandId?: string;
+	readonly commandType?: string;
+	readonly eventCount: number;
+	readonly effectCount: number;
+	readonly errorCode?: ProcessErrorCode;
+	readonly cursor: ProcessCursor;
+}
+
+export interface ProcessEffectRunnerStatus {
+	readonly state: "requested" | "commanded" | "rejected";
+	readonly effectId?: string;
+	readonly effectType?: string;
+	readonly commandId?: string;
+	readonly commandType?: ProcessEffectCommandType;
+	readonly requested: number;
+	readonly commanded: number;
+	readonly rejected: number;
+}
+
+export interface ProcessEffectRunnerError {
+	readonly code: "malformed-outcome";
+	readonly message: string;
+	readonly outcome?: unknown;
+	readonly effectId?: string;
+	readonly effectType?: string;
+}
+
+/** Ordered audit fact for one attempted command reduction. */
+export interface ProcessAuditRecord {
+	readonly seq: number;
+	readonly commandId?: string;
+	readonly commandType?: string;
+	readonly outcome: "success" | "failure";
+	readonly eventIds: readonly string[];
+	readonly eventTypes: readonly string[];
+	readonly effectIds: readonly string[];
+	readonly effectTypes: readonly string[];
+	readonly errorCode?: ProcessErrorCode;
+	readonly errorMessage?: string;
+	readonly cursor: ProcessCursor;
+}
+
+/** Monotonic graph-visible ProcessBundle cursor counters. */
+export interface ProcessCursor {
+	readonly eventSeq: number;
+	readonly effectSeq: number;
+	readonly commandCount: number;
+	readonly errorCount: number;
+	readonly auditSeq: number;
+}
+
+/** Reducer result: next process state plus optional event/effect-request drafts. */
+export interface ProcessReduction<TState = unknown, TEvent = unknown, TEffect = unknown> {
+	readonly state: TState;
+	readonly events?: readonly ProcessEventDraft<TEvent>[];
+	readonly effects?: readonly ProcessEffectRequestDraft<TEffect>[];
+}
+
+/** Sync ProcessBundle reducer. Async effects belong in graph-visible adapters, not here. */
+export type ProcessReducer<
+	TCommand = unknown,
+	TState = unknown,
+	TEvent = unknown,
+	TEffect = unknown,
+> = (command: ProcessCommand<TCommand>, state: TState) => ProcessReduction<TState, TEvent, TEffect>;
+
+/** Options for a D136 facts-plus-reducer ProcessBundle. */
+export interface ProcessBundleOptions<
+	TCommand = unknown,
+	TState = unknown,
+	TEvent = unknown,
+	TEffect = unknown,
+> {
+	readonly name?: string;
+	readonly initialState: TState;
+	readonly reduce: ProcessReducer<TCommand, TState, TEvent, TEffect>;
+	readonly now?: () => number;
+}
+
+/** D136 facts-plus-reducer process bundle. It is not a workflow engine or hidden runtime owner. */
+export interface ProcessBundle<
+	TCommand = unknown,
+	TState = unknown,
+	TEvent = unknown,
+	TEffect = unknown,
+> {
+	readonly command: Node<ProcessCommand<TCommand>>;
+	readonly events: Node<ProcessEvent<TEvent>>;
+	readonly state: Node<TState>;
+	readonly audit: Node<ProcessAuditRecord>;
+	readonly effectRequests: Node<ProcessEffectRequest<TEffect>>;
+	readonly status: Node<ProcessStatus>;
+	readonly errors: Node<ProcessError>;
+	readonly cursor: Node<ProcessCursor>;
+	dispatch(command: ProcessCommand<TCommand>): ProcessCommand<TCommand>;
+	/** Release only graph-owned retain roots; process facts/topology/cache/state remain ordinary graph data. */
+	release(): void;
+}
+
+export interface ProcessEffectRunnerOptions<TResult = unknown> {
+	readonly name?: string;
+	readonly outcomes: readonly Node<ProcessEffectOutcome<TResult>>[];
+}
+
+export interface ProcessEffectRunnerBundle<TEffect = unknown, TResult = unknown> {
+	readonly requests: Node<ProcessEffectRequest<TEffect>>;
+	readonly outcomes: Node<ProcessEffectOutcome<TResult>>;
+	readonly commands: Node<ProcessCommand<ProcessEffectCommandPayload<TResult>>>;
+	readonly status: Node<ProcessEffectRunnerStatus>;
+	readonly errors: Node<ProcessEffectRunnerError>;
+	release(): void;
+}
diff --git a/packages/ts/src/orchestration/process-utils.ts b/packages/ts/src/orchestration/process-utils.ts
new file mode 100644
index 00000000..4898f982
--- /dev/null
+++ b/packages/ts/src/orchestration/process-utils.ts
@@ -0,0 +1,55 @@
+export type CloneProcessStateResult<TState> =
+	| { readonly ok: true; readonly value: TState }
+	| { readonly ok: false; readonly message: string };
+
+export function cloneProcessState<TState>(state: TState): CloneProcessStateResult<TState> {
+	if (typeof state !== "object" || state === null) return { ok: true, value: state };
+	try {
+		if (typeof globalThis.structuredClone === "function") {
+			return { ok: true, value: globalThis.structuredClone(state) as TState };
+		}
+		return { ok: true, value: JSON.parse(JSON.stringify(state)) as TState };
+	} catch (error) {
+		return {
+			ok: false,
+			message: `processBundle: state must be cloneable before reducer execution (${errorMessage(error)})`,
+		};
+	}
+}
+
+export function readTimestampMs(now: () => number): number | string {
+	try {
+		const timestampMs = now();
+		if (!Number.isFinite(timestampMs)) return "processBundle: now() must return a finite number";
+		return timestampMs;
+	} catch (error) {
+		return errorMessage(error);
+	}
+}
+
+export function rethrowGraphRuntimeInvariant(error: unknown): void {
+	const message = errorMessage(error);
+	if (
+		message.includes("R-reentrancy") ||
+		message.includes("R-rewire") ||
+		message.includes("R-graph-domain") ||
+		message.includes("D37") ||
+		message.includes("D22") ||
+		message.includes("different graph") ||
+		message.includes("cross-graph") ||
+		message.includes("wire bridge") ||
+		message.includes("mid-fn topology mutation") ||
+		message.includes("reentrant dep mutation") ||
+		message.includes("feedback cycle")
+	) {
+		throw error;
+	}
+}
+
+export function isObjectRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+export function errorMessage(error: unknown): string {
+	return error instanceof Error ? error.message : String(error);
+}
diff --git a/packages/ts/src/orchestration/process.ts b/packages/ts/src/orchestration/process.ts
new file mode 100644
index 00000000..60362f8d
--- /dev/null
+++ b/packages/ts/src/orchestration/process.ts
@@ -0,0 +1,977 @@
+/**
+ * Graph-visible ProcessBundle orchestration helpers (D136/D156).
+ */
+
+import { depBatch, type NodeFn } from "../ctx/types.js";
+import type { Graph, TopologyGroup } from "../graph/graph.js";
+import type { Node } from "../node/node.js";
+import type {
+	ProcessAuditRecord,
+	ProcessBundle,
+	ProcessBundleOptions,
+	ProcessCommand,
+	ProcessCursor,
+	ProcessEffectCommandPayload,
+	ProcessEffectCommandType,
+	ProcessEffectOutcome,
+	ProcessEffectRequest,
+	ProcessEffectRequestDraft,
+	ProcessEffectRunnerBundle,
+	ProcessEffectRunnerError,
+	ProcessEffectRunnerOptions,
+	ProcessEffectRunnerStatus,
+	ProcessError,
+	ProcessErrorCode,
+	ProcessEvent,
+	ProcessEventDraft,
+	ProcessReducer,
+	ProcessReduction,
+	ProcessStatus,
+} from "./process-types.js";
+import {
+	cloneProcessState,
+	errorMessage,
+	isObjectRecord,
+	readTimestampMs,
+	rethrowGraphRuntimeInvariant,
+} from "./process-utils.js";
+
+export type {
+	ProcessAuditRecord,
+	ProcessBundle,
+	ProcessBundleOptions,
+	ProcessCommand,
+	ProcessCursor,
+	ProcessEffectCommandPayload,
+	ProcessEffectCommandType,
+	ProcessEffectOutcome,
+	ProcessEffectRequest,
+	ProcessEffectRequestDraft,
+	ProcessEffectRunnerBundle,
+	ProcessEffectRunnerError,
+	ProcessEffectRunnerOptions,
+	ProcessEffectRunnerStatus,
+	ProcessError,
+	ProcessErrorCode,
+	ProcessEvent,
+	ProcessEventDraft,
+	ProcessReducer,
+	ProcessReduction,
+	ProcessStatus,
+} from "./process-types.js";
+
+type ProcessRuntimeFact<TState = unknown, TEvent = unknown, TEffect = unknown> =
+	| { readonly kind: "state"; readonly state: TState; readonly cursor: ProcessCursor }
+	| { readonly kind: "event"; readonly event: ProcessEvent<TEvent> }
+	| { readonly kind: "effect-request"; readonly effect: ProcessEffectRequest<TEffect> }
+	| { readonly kind: "status"; readonly status: ProcessStatus }
+	| { readonly kind: "error"; readonly error: ProcessError }
+	| { readonly kind: "audit"; readonly audit: ProcessAuditRecord }
+	| { readonly kind: "cursor"; readonly cursor: ProcessCursor };
+
+type ProcessEffectRunnerFact<TResult = unknown> =
+	| { readonly kind: "outcome"; readonly outcome: ProcessEffectOutcome<TResult> }
+	| {
+			readonly kind: "command";
+			readonly command: ProcessCommand<ProcessEffectCommandPayload<TResult>>;
+	  }
+	| { readonly kind: "error"; readonly error: ProcessEffectRunnerError };
+
+interface AttachedProcessCommandSources<TCommand> {
+	sources: Node<ProcessCommand<TCommand>>[];
+}
+
+const processCommandSources = new WeakMap<
+	ProcessBundle<unknown, unknown, unknown, unknown>,
+	AttachedProcessCommandSources<unknown>
+>();
+
+/**
+ * Build a D136 ProcessBundle from graph-visible command facts and a reducer.
+ *
+ * The bundle retains its runtime/projection nodes until `release()` is called.
+ * Reducer and validation failures are emitted as DATA error/status/audit facts;
+ * they do not mint protocol ERROR messages or own restore/hydration behavior.
+ */
+export function processBundle<
+	TCommand = unknown,
+	TState = unknown,
+	TEvent = unknown,
+	TEffect = unknown,
+>(
+	graph: Graph,
+	opts: ProcessBundleOptions<TCommand, TState, TEvent, TEffect>,
+): ProcessBundle<TCommand, TState, TEvent, TEffect> {
+	if (typeof opts.reduce !== "function") {
+		throw new TypeError("processBundle: reduce must be a function");
+	}
+	if (opts.initialState === undefined) {
+		throw new TypeError("processBundle: initialState must not be undefined");
+	}
+	const name = opts.name ?? "process";
+	const now = opts.now ?? Date.now;
+	const topology = graph.topologyGroup({ name: `${name}.process` });
+	const command = topology.node<ProcessCommand<TCommand>>([], null, {
+		name: `${name}/command`,
+		factory: "processCommand",
+		completeWhenDepsComplete: false,
+		errorWhenDepsError: false,
+	});
+	const runtime = topology.node<ProcessRuntimeFact<TState, TEvent, TEffect>>(
+		[command],
+		(ctx) => {
+			let state =
+				ctx.state.get<ProcessRuntimeState<TState>>() ??
+				({
+					eventSeq: 0,
+					effectSeq: 0,
+					commandCount: 0,
+					errorCount: 0,
+					auditSeq: 0,
+					seenEventIds: [],
+					seenEffectIds: [],
+					state: opts.initialState,
+				} satisfies ProcessRuntimeState<TState>);
+			ctx.state.persist(true);
+			for (const raw of depBatch(ctx, 0) ?? []) {
+				state = reduceProcessCommandFact(
+					raw,
+					state,
+					opts.reduce as ProcessReducer<unknown, TState, unknown, unknown>,
+					now,
+					(fact) => ctx.down([["DATA", fact as ProcessRuntimeFact<TState, TEvent, TEffect>]]),
+				);
+				ctx.state.set(state);
+			}
+		},
+		{
+			name: `${name}/runtime`,
+			factory: "processRuntime",
+			meta: { process: "facts-plus-reducer", d: "D136" },
+			completeWhenDepsComplete: false,
+			errorWhenDepsError: false,
+		},
+	);
+	const events = processProjection<ProcessEvent<TEvent>, TState, TEvent, TEffect>(
+		topology,
+		runtime,
+		`${name}/events`,
+		"processEvents",
+		(fact) => (fact.kind === "event" ? fact.event : undefined),
+	);
+	const state = processProjection<TState, TState, TEvent, TEffect>(
+		topology,
+		runtime,
+		`${name}/state`,
+		"processState",
+		(fact) => (fact.kind === "state" ? fact.state : undefined),
+	);
+	const audit = processProjection<ProcessAuditRecord, TState, TEvent, TEffect>(
+		topology,
+		runtime,
+		`${name}/audit`,
+		"processAudit",
+		(fact) => (fact.kind === "audit" ? fact.audit : undefined),
+	);
+	const effectRequests = processProjection<ProcessEffectRequest<TEffect>, TState, TEvent, TEffect>(
+		topology,
+		runtime,
+		`${name}/effectRequests`,
+		"processEffectRequests",
+		(fact) => (fact.kind === "effect-request" ? fact.effect : undefined),
+	);
+	const status = processProjection<ProcessStatus, TState, TEvent, TEffect>(
+		topology,
+		runtime,
+		`${name}/status`,
+		"processStatus",
+		(fact) => (fact.kind === "status" ? fact.status : undefined),
+	);
+	const errors = processProjection<ProcessError, TState, TEvent, TEffect>(
+		topology,
+		runtime,
+		`${name}/errors`,
+		"processErrors",
+		(fact) => (fact.kind === "error" ? fact.error : undefined),
+	);
+	const cursor = processProjection<ProcessCursor, TState, TEvent, TEffect>(
+		topology,
+		runtime,
+		`${name}/cursor`,
+		"processCursor",
+		(fact) => (fact.kind === "cursor" ? fact.cursor : undefined),
+	);
+	const retainProcessNodes = () => [
+		graph.retain(runtime, { reason: `${name}.process.runtime` }),
+		graph.retain(events, { reason: `${name}.process.events` }),
+		graph.retain(state, { reason: `${name}.process.state` }),
+		graph.retain(audit, { reason: `${name}.process.audit` }),
+		graph.retain(effectRequests, { reason: `${name}.process.effectRequests` }),
+		graph.retain(status, { reason: `${name}.process.status` }),
+		graph.retain(errors, { reason: `${name}.process.errors` }),
+		graph.retain(cursor, { reason: `${name}.process.cursor` }),
+	];
+	let releaseRetains = retainProcessNodes();
+	let released = false;
+	const bundle: ProcessBundle<TCommand, TState, TEvent, TEffect> = {
+		command,
+		events,
+		state,
+		audit,
+		effectRequests,
+		status,
+		errors,
+		cursor,
+		dispatch(next) {
+			command.down([["DATA", next]]);
+			return next;
+		},
+		release() {
+			if (released) return;
+			const activeRetains = releaseRetains;
+			releaseRetains = [];
+			for (const releaseRetain of activeRetains) releaseRetain();
+			try {
+				topology.release({ reason: `${name}.process.release` });
+				released = true;
+				processCommandSources.delete(
+					bundle as unknown as ProcessBundle<unknown, unknown, unknown, unknown>,
+				);
+			} catch (error) {
+				releaseRetains = retainProcessNodes();
+				throw error;
+			}
+		},
+	};
+	processCommandSources.set(
+		bundle as unknown as ProcessBundle<unknown, unknown, unknown, unknown>,
+		{ sources: [] },
+	);
+	return bundle;
+}
+
+/**
+ * Build a D156 graph-visible effect runner adapter over a ProcessBundle.
+ *
+ * The runner consumes visible effect-request and outcome facts, then publishes
+ * ordinary ProcessCommand DATA facts back through process.command via a declared
+ * graph edge. Async handlers, timers, and process state ownership stay outside
+ * this helper.
+ */
+export function processEffectRunner<TEffect = unknown, TResult = unknown>(
+	graph: Graph,
+	process: ProcessBundle<unknown, unknown, unknown, TEffect>,
+	opts: ProcessEffectRunnerOptions<TResult>,
+): ProcessEffectRunnerBundle<TEffect, TResult> {
+	if (opts.outcomes.length === 0) {
+		throw new RangeError("processEffectRunner: outcomes must contain at least one node");
+	}
+	const name = opts.name ?? "processEffectRunner";
+	const topology = graph.topologyGroup({ name: `${name}.effectRunner` });
+	const requests = topology.node<ProcessEffectRequest<TEffect>>(
+		[process.effectRequests],
+		(ctx) => {
+			for (const request of depBatch(ctx, 0) ?? []) {
+				ctx.down([["DATA", request as ProcessEffectRequest<TEffect>]]);
+			}
+		},
+		{
+			name: `${name}/requests`,
+			factory: "processEffectRunnerRequests",
+			partial: true,
+			completeWhenDepsComplete: false,
+			errorWhenDepsError: false,
+		},
+	);
+	const runtime = topology.node<ProcessEffectRunnerFact<TResult>>(
+		[...opts.outcomes],
+		(ctx) => {
+			for (let i = 0; i < opts.outcomes.length; i += 1) {
+				for (const raw of depBatch(ctx, i) ?? []) {
+					const parsed = parseProcessEffectOutcome<TResult>(raw);
+					if (typeof parsed === "string") {
+						const error = {
+							code: "malformed-outcome",
+							message: parsed,
+							outcome: raw,
+						} satisfies ProcessEffectRunnerError;
+						ctx.down([["DATA", { kind: "error", error }]]);
+						continue;
+					}
+					const outcome = parsed as ProcessEffectOutcome<TResult>;
+					const command = processEffectOutcomeCommand(outcome);
+					ctx.down([["DATA", { kind: "outcome", outcome }]]);
+					ctx.down([["DATA", { kind: "command", command }]]);
+				}
+			}
+		},
+		{
+			name: `${name}/runtime`,
+			factory: "processEffectRunner",
+			meta: { process: "effect-runner", d: "D156" },
+			partial: true,
+			completeWhenDepsComplete: false,
+			errorWhenDepsError: false,
+		},
+	);
+	const outcomes = processEffectRunnerProjection<ProcessEffectOutcome<TResult>, TResult>(
+		topology,
+		runtime,
+		`${name}/outcomes`,
+		"processEffectRunnerOutcomes",
+		(fact) => (fact.kind === "outcome" ? fact.outcome : undefined),
+	);
+	const commands = processEffectRunnerProjection<
+		ProcessCommand<ProcessEffectCommandPayload<TResult>>,
+		TResult
+	>(topology, runtime, `${name}/commands`, "processEffectRunnerCommands", (fact) =>
+		fact.kind === "command" ? fact.command : undefined,
+	);
+	const errors = processEffectRunnerProjection<ProcessEffectRunnerError, TResult>(
+		topology,
+		runtime,
+		`${name}/errors`,
+		"processEffectRunnerErrors",
+		(fact) => (fact.kind === "error" ? fact.error : undefined),
+	);
+	const status = topology.node<ProcessEffectRunnerStatus>(
+		[requests, runtime],
+		(ctx) => {
+			let state =
+				ctx.state.get<ProcessEffectRunnerState>() ??
+				({ requested: 0, commanded: 0, rejected: 0 } satisfies ProcessEffectRunnerState);
+			for (const request of depBatch(ctx, 0) ?? []) {
+				state = { ...state, requested: state.requested + 1 };
+				const typedRequest = request as ProcessEffectRequest<TEffect>;
+				ctx.down([
+					[
+						"DATA",
+						{
+							state: "requested",
+							effectId: typedRequest.id,
+							effectType: typedRequest.type,
+							requested: state.requested,
+							commanded: state.commanded,
+							rejected: state.rejected,
+						} satisfies ProcessEffectRunnerStatus,
+					],
+				]);
+			}
+			for (const fact of depBatch(ctx, 1) ?? []) {
+				const typedFact = fact as ProcessEffectRunnerFact<TResult>;
+				if (typedFact.kind === "command") {
+					state = { ...state, commanded: state.commanded + 1 };
+					ctx.down([
+						[
+							"DATA",
+							{
+								state: "commanded",
+								effectId: typedFact.command.payload.effectId,
+								effectType: typedFact.command.payload.effectType,
+								commandId: typedFact.command.id,
+								commandType: typedFact.command.type as ProcessEffectCommandType,
+								requested: state.requested,
+								commanded: state.commanded,
+								rejected: state.rejected,
+							} satisfies ProcessEffectRunnerStatus,
+						],
+					]);
+				}
+				if (typedFact.kind === "error") {
+					state = { ...state, rejected: state.rejected + 1 };
+					ctx.down([
+						[
+							"DATA",
+							{
+								state: "rejected",
+								effectId: typedFact.error.effectId,
+								effectType: typedFact.error.effectType,
+								requested: state.requested,
+								commanded: state.commanded,
+								rejected: state.rejected,
+							} satisfies ProcessEffectRunnerStatus,
+						],
+					]);
+				}
+			}
+			ctx.state.set(state);
+		},
+		{
+			name: `${name}/status`,
+			factory: "processEffectRunnerStatus",
+			partial: true,
+			completeWhenDepsComplete: false,
+			errorWhenDepsError: false,
+		},
+	);
+	const retainRunnerNodes = () => [
+		graph.retain(requests, { reason: `${name}.effectRunner.requests` }),
+		graph.retain(outcomes, { reason: `${name}.effectRunner.outcomes` }),
+		graph.retain(commands, { reason: `${name}.effectRunner.commands` }),
+		graph.retain(status, { reason: `${name}.effectRunner.status` }),
+		graph.retain(errors, { reason: `${name}.effectRunner.errors` }),
+	];
+	let releaseRetains = retainRunnerNodes();
+	try {
+		attachProcessCommandSource(process, commands);
+	} catch (error) {
+		for (const releaseRetain of releaseRetains) releaseRetain();
+		releaseRetains = [];
+		topology.release({ reason: `${name}.effectRunner.failedAttach` });
+		throw error;
+	}
+	let released = false;
+	return {
+		requests,
+		outcomes,
+		commands,
+		status,
+		errors,
+		release() {
+			if (released) return;
+			const activeRetains = releaseRetains;
+			releaseRetains = [];
+			for (const releaseRetain of activeRetains) releaseRetain();
+			detachProcessCommandSource(process, commands);
+			try {
+				topology.release({ reason: `${name}.effectRunner.release` });
+				released = true;
+			} catch (error) {
+				attachProcessCommandSource(process, commands);
+				releaseRetains = retainRunnerNodes();
+				throw error;
+			}
+		},
+	};
+}
+
+interface ProcessEffectRunnerState {
+	requested: number;
+	commanded: number;
+	rejected: number;
+}
+
+interface ProcessRuntimeState<TState> {
+	eventSeq: number;
+	effectSeq: number;
+	commandCount: number;
+	errorCount: number;
+	auditSeq: number;
+	seenEventIds: string[];
+	seenEffectIds: string[];
+	state: TState;
+}
+
+function processEffectRunnerProjection<T, TResult>(
+	topology: TopologyGroup,
+	runtime: Node<ProcessEffectRunnerFact<TResult>>,
+	name: string,
+	factory: string,
+	pick: (fact: ProcessEffectRunnerFact<TResult>) => T | undefined,
+): Node<T> {
+	return topology.node<T>(
+		[runtime],
+		(ctx) => {
+			for (const fact of depBatch(ctx, 0) ?? []) {
+				const value = pick(fact as ProcessEffectRunnerFact<TResult>);
+				if (value !== undefined) ctx.down([["DATA", value]]);
+			}
+		},
+		{
+			name,
+			factory,
+			partial: true,
+			completeWhenDepsComplete: false,
+			errorWhenDepsError: false,
+		},
+	);
+}
+
+function parseProcessEffectOutcome<TResult>(raw: unknown): ProcessEffectOutcome<TResult> | string {
+	if (!isObjectRecord(raw)) return "processEffectRunner: outcome must be an object";
+	if (typeof raw.kind !== "string") {
+		return "processEffectRunner: outcome kind must be a string";
+	}
+	if (
+		raw.kind !== "result" &&
+		raw.kind !== "failure" &&
+		raw.kind !== "cancel" &&
+		raw.kind !== "timeout"
+	) {
+		return "processEffectRunner: outcome kind must be result, failure, cancel, or timeout";
+	}
+	if (typeof raw.effectId !== "string" || raw.effectId.length === 0) {
+		return "processEffectRunner: outcome effectId must be a non-empty string";
+	}
+	if (typeof raw.effectType !== "string" || raw.effectType.length === 0) {
+		return "processEffectRunner: outcome effectType must be a non-empty string";
+	}
+	if ("commandId" in raw && raw.commandId !== undefined) {
+		if (typeof raw.commandId !== "string" || raw.commandId.length === 0) {
+			return "processEffectRunner: outcome commandId must be a non-empty string";
+		}
+	}
+	for (const key of ["processId", "correlationId", "causationId"] as const) {
+		if (key in raw && raw[key] !== undefined && typeof raw[key] !== "string") {
+			return `processEffectRunner: outcome ${key} must be a string`;
+		}
+	}
+	if ("metadata" in raw && raw.metadata !== undefined && !isObjectRecord(raw.metadata)) {
+		return "processEffectRunner: outcome metadata must be a plain object";
+	}
+	if (raw.kind === "result" && !("value" in raw)) {
+		return "processEffectRunner: result outcome must carry value";
+	}
+	if ((raw.kind === "failure" || raw.kind === "timeout") && !("error" in raw)) {
+		return `processEffectRunner: ${raw.kind} outcome must carry error`;
+	}
+	if (
+		raw.kind === "cancel" &&
+		"reason" in raw &&
+		raw.reason !== undefined &&
+		typeof raw.reason !== "string"
+	) {
+		return "processEffectRunner: cancel outcome reason must be a string";
+	}
+	return raw as unknown as ProcessEffectOutcome<TResult>;
+}
+
+function processEffectOutcomeCommand<TResult>(
+	outcome: ProcessEffectOutcome<TResult>,
+): ProcessCommand<ProcessEffectCommandPayload<TResult>> {
+	const commandType = processEffectCommandType(outcome.kind);
+	return {
+		id: outcome.commandId ?? `${outcome.effectId}:${commandType}`,
+		type: commandType,
+		payload: processEffectCommandPayload(outcome),
+		processId: outcome.processId,
+		correlationId: outcome.correlationId,
+		causationId: outcome.causationId,
+		metadata: outcome.metadata,
+	};
+}
+
+function processEffectCommandType(kind: ProcessEffectOutcome["kind"]): ProcessEffectCommandType {
+	switch (kind) {
+		case "result":
+			return "effect.result";
+		case "failure":
+			return "effect.failure";
+		case "cancel":
+			return "effect.cancel";
+		case "timeout":
+			return "effect.timeout";
+	}
+}
+
+function processEffectCommandPayload<TResult>(
+	outcome: ProcessEffectOutcome<TResult>,
+): ProcessEffectCommandPayload<TResult> {
+	const base = {
+		effectId: outcome.effectId,
+		effectType: outcome.effectType,
+		processId: outcome.processId,
+		correlationId: outcome.correlationId,
+		causationId: outcome.causationId,
+		metadata: outcome.metadata,
+	};
+	switch (outcome.kind) {
+		case "result":
+			return { ...base, kind: "result", value: outcome.value };
+		case "failure":
+			return { ...base, kind: "failure", error: outcome.error };
+		case "cancel":
+			return { ...base, kind: "cancel", reason: outcome.reason };
+		case "timeout":
+			return { ...base, kind: "timeout", error: outcome.error };
+	}
+}
+
+function attachProcessCommandSource(
+	process: ProcessBundle<unknown, unknown, unknown, unknown>,
+	source: Node<ProcessCommand<unknown>>,
+): void {
+	const attached = processCommandSources.get(process);
+	if (attached === undefined) {
+		throw new Error("processEffectRunner: process command source registry missing");
+	}
+	const sources = attached.sources as Node<ProcessCommand<unknown>>[];
+	const previousSources = [...sources];
+	if (!sources.includes(source)) sources.push(source);
+	try {
+		process.command.replaceDeps([...sources], processCommandSourceFn(sources.length));
+	} catch (error) {
+		sources.splice(0, sources.length, ...previousSources);
+		process.command.replaceDeps(
+			[...previousSources],
+			processCommandSourceFn(previousSources.length),
+		);
+		throw error;
+	}
+}
+
+function detachProcessCommandSource(
+	process: ProcessBundle<unknown, unknown, unknown, unknown>,
+	source: Node<ProcessCommand<unknown>>,
+): void {
+	const attached = processCommandSources.get(process);
+	if (attached === undefined) {
+		throw new Error("processEffectRunner: process command source registry missing");
+	}
+	const sources = attached.sources as Node<ProcessCommand<unknown>>[];
+	if (!sources.includes(source)) return;
+	const previousSources = [...sources];
+	const nextSources = sources.filter((candidate) => candidate !== source);
+	sources.splice(0, sources.length, ...nextSources);
+	try {
+		process.command.replaceDeps([...nextSources], processCommandSourceFn(nextSources.length));
+	} catch (error) {
+		sources.splice(0, sources.length, ...previousSources);
+		process.command.replaceDeps(
+			[...previousSources],
+			processCommandSourceFn(previousSources.length),
+		);
+		throw error;
+	}
+}
+
+function processCommandSourceFn(sourceCount: number) {
+	return (ctx: Parameters<NodeFn>[0]) => {
+		for (let i = 0; i < sourceCount; i += 1) {
+			for (const command of depBatch(ctx, i) ?? []) {
+				ctx.down([["DATA", command as ProcessCommand<unknown>]]);
+			}
+		}
+	};
+}
+
+function processRuntimeDraft<TState>(
+	state: ProcessRuntimeState<TState>,
+): ProcessRuntimeState<TState> {
+	return {
+		eventSeq: state.eventSeq,
+		effectSeq: state.effectSeq,
+		commandCount: state.commandCount,
+		errorCount: state.errorCount,
+		auditSeq: state.auditSeq,
+		seenEventIds: [...state.seenEventIds],
+		seenEffectIds: [...state.seenEffectIds],
+		state: state.state,
+	};
+}
+
+function reduceProcessCommandFact<TState>(
+	raw: unknown,
+	state: ProcessRuntimeState<TState>,
+	reduce: ProcessReducer<unknown, TState, unknown, unknown>,
+	now: () => number,
+	emit: (fact: ProcessRuntimeFact<TState, unknown, unknown>) => void,
+): ProcessRuntimeState<TState> {
+	const draft = processRuntimeDraft(state);
+	draft.commandCount += 1;
+	const parsed = parseProcessCommand(raw);
+	if (typeof parsed === "string") {
+		emitProcessFailure(draft, emit, raw, undefined, "malformed-command", parsed);
+		return draft;
+	}
+	const command = parsed as ProcessCommand<unknown>;
+	let reduction: ProcessReduction<TState, unknown, unknown>;
+	const reducerState = cloneProcessState(state.state);
+	if (!reducerState.ok) {
+		emitProcessFailure(draft, emit, command, command, "malformed-state", reducerState.message);
+		return draft;
+	}
+	try {
+		reduction = reduce(command, reducerState.value);
+	} catch (error) {
+		rethrowGraphRuntimeInvariant(error);
+		emitProcessFailure(draft, emit, command, command, "reducer-threw", errorMessage(error));
+		return draft;
+	}
+	if (!isObjectRecord(reduction) || !("state" in reduction)) {
+		emitProcessFailure(
+			draft,
+			emit,
+			command,
+			command,
+			"malformed-state",
+			"processBundle: reducer must return { state, events?, effects? }",
+		);
+		return draft;
+	}
+	if (reduction.state === undefined) {
+		emitProcessFailure(
+			draft,
+			emit,
+			command,
+			command,
+			"malformed-state",
+			"processBundle: reducer state must not be undefined",
+		);
+		return draft;
+	}
+	const privateState = cloneProcessState(reduction.state);
+	if (!privateState.ok) {
+		emitProcessFailure(draft, emit, command, command, "malformed-state", privateState.message);
+		return draft;
+	}
+	const visibleState = cloneProcessState(privateState.value);
+	if (!visibleState.ok) {
+		emitProcessFailure(draft, emit, command, command, "malformed-state", visibleState.message);
+		return draft;
+	}
+	const preparedEvents = prepareProcessEvents(command, draft, reduction.events ?? []);
+	if (typeof preparedEvents === "string") {
+		emitProcessFailure(draft, emit, command, command, "malformed-event", preparedEvents);
+		return draft;
+	}
+	const preparedEffects = prepareProcessEffects(command, draft, reduction.effects ?? []);
+	if (typeof preparedEffects === "string") {
+		emitProcessFailure(draft, emit, command, command, "malformed-effect", preparedEffects);
+		return draft;
+	}
+	const timestampMs = readTimestampMs(now);
+	if (typeof timestampMs === "string") {
+		emitProcessFailure(draft, emit, command, command, "clock-threw", timestampMs);
+		return draft;
+	}
+	draft.state = privateState.value;
+	emit({ kind: "state", state: visibleState.value, cursor: processCursorOf(draft) });
+	const events: ProcessEvent<unknown>[] = [];
+	for (const eventDraft of preparedEvents) {
+		draft.eventSeq += 1;
+		draft.seenEventIds.push(eventDraft.id);
+		const event: ProcessEvent<unknown> = {
+			id: eventDraft.id,
+			type: eventDraft.type,
+			seq: draft.eventSeq,
+			cursor: draft.eventSeq,
+			commandId: command.id,
+			commandType: command.type,
+			payload: eventDraft.payload,
+			timestampMs,
+			...(eventDraft.processId === undefined ? {} : { processId: eventDraft.processId }),
+			...(eventDraft.correlationId === undefined
+				? {}
+				: { correlationId: eventDraft.correlationId }),
+			...(eventDraft.causationId === undefined ? {} : { causationId: eventDraft.causationId }),
+			...(eventDraft.metadata === undefined ? {} : { metadata: eventDraft.metadata }),
+		};
+		events.push(event);
+		emit({ kind: "event", event });
+	}
+	const effects: ProcessEffectRequest<unknown>[] = [];
+	for (const effectDraft of preparedEffects) {
+		draft.effectSeq += 1;
+		draft.seenEffectIds.push(effectDraft.id);
+		const effect: ProcessEffectRequest<unknown> = {
+			id: effectDraft.id,
+			type: effectDraft.type,
+			seq: draft.effectSeq,
+			cursor: draft.effectSeq,
+			commandId: command.id,
+			commandType: command.type,
+			payload: effectDraft.payload,
+			timestampMs,
+			...(effectDraft.processId === undefined ? {} : { processId: effectDraft.processId }),
+			...(effectDraft.correlationId === undefined
+				? {}
+				: { correlationId: effectDraft.correlationId }),
+			...(effectDraft.causationId === undefined ? {} : { causationId: effectDraft.causationId }),
+			...(effectDraft.metadata === undefined ? {} : { metadata: effectDraft.metadata }),
+		};
+		effects.push(effect);
+		emit({ kind: "effect-request", effect });
+	}
+	emitProcessStatus(draft, emit, command, "accepted", events.length, effects.length);
+	emitProcessAudit(draft, emit, command, "success", events, effects, undefined, undefined);
+	emit({ kind: "cursor", cursor: processCursorOf(draft) });
+	return draft;
+}
+
+function processProjection<TOut, TState, TEvent, TEffect>(
+	graph: Graph | TopologyGroup,
+	runtime: Node<ProcessRuntimeFact<TState, TEvent, TEffect>>,
+	name: string,
+	factory: string,
+	select: (fact: ProcessRuntimeFact<TState, TEvent, TEffect>) => TOut | undefined,
+): Node<TOut> {
+	return graph.node<TOut>(
+		[runtime],
+		(ctx) => {
+			for (const raw of depBatch(ctx, 0) ?? []) {
+				const selected = select(raw as ProcessRuntimeFact<TState, TEvent, TEffect>);
+				if (selected !== undefined) ctx.down([["DATA", selected]]);
+			}
+		},
+		{ name, factory, completeWhenDepsComplete: false, errorWhenDepsError: false },
+	);
+}
+
+function parseProcessCommand(value: unknown): ProcessCommand<unknown> | string {
+	if (!isObjectRecord(value)) return "processBundle: command fact must be an object";
+	if (typeof value.id !== "string" || value.id.length === 0) {
+		return "processBundle: command id must be a non-empty string";
+	}
+	if (typeof value.type !== "string" || value.type.length === 0) {
+		return "processBundle: command type must be a non-empty string";
+	}
+	return {
+		id: value.id,
+		type: value.type,
+		payload: value.payload,
+		...(typeof value.processId === "string" ? { processId: value.processId } : {}),
+		...(typeof value.correlationId === "string" ? { correlationId: value.correlationId } : {}),
+		...(typeof value.causationId === "string" ? { causationId: value.causationId } : {}),
+		...(isObjectRecord(value.metadata) ? { metadata: value.metadata } : {}),
+	};
+}
+
+function prepareProcessEvents(
+	command: ProcessCommand<unknown>,
+	state: ProcessRuntimeState<unknown>,
+	drafts: readonly ProcessEventDraft<unknown>[],
+): Array<ProcessEventDraft<unknown> & { readonly id: string }> | string {
+	if (!Array.isArray(drafts)) return "processBundle: events must be an array";
+	const seen = new Set<string>();
+	const out: Array<ProcessEventDraft<unknown> & { readonly id: string }> = [];
+	for (let i = 0; i < drafts.length; i += 1) {
+		const draft = drafts[i];
+		if (!isObjectRecord(draft) || typeof draft.type !== "string" || draft.type.length === 0) {
+			return "processBundle: event draft must have a non-empty type";
+		}
+		const id =
+			typeof draft.id === "string" && draft.id.length > 0
+				? draft.id
+				: `${command.id}:event:${state.eventSeq + i + 1}`;
+		if (seen.has(id)) return `processBundle: duplicate event '${id}'`;
+		if (state.seenEventIds.includes(id)) return `processBundle: duplicate event '${id}'`;
+		seen.add(id);
+		out.push({
+			id,
+			type: draft.type,
+			payload: draft.payload,
+			...(typeof draft.processId === "string" ? { processId: draft.processId } : {}),
+			...(typeof draft.correlationId === "string" ? { correlationId: draft.correlationId } : {}),
+			...(typeof draft.causationId === "string" ? { causationId: draft.causationId } : {}),
+			...(isObjectRecord(draft.metadata) ? { metadata: draft.metadata } : {}),
+		});
+	}
+	return out;
+}
+
+function prepareProcessEffects(
+	command: ProcessCommand<unknown>,
+	state: ProcessRuntimeState<unknown>,
+	drafts: readonly ProcessEffectRequestDraft<unknown>[],
+): Array<ProcessEffectRequestDraft<unknown> & { readonly id: string }> | string {
+	if (!Array.isArray(drafts)) return "processBundle: effects must be an array";
+	const seen = new Set<string>();
+	const out: Array<ProcessEffectRequestDraft<unknown> & { readonly id: string }> = [];
+	for (let i = 0; i < drafts.length; i += 1) {
+		const draft = drafts[i];
+		if (!isObjectRecord(draft) || typeof draft.type !== "string" || draft.type.length === 0) {
+			return "processBundle: effect draft must have a non-empty type";
+		}
+		const id =
+			typeof draft.id === "string" && draft.id.length > 0
+				? draft.id
+				: `${command.id}:effect:${state.effectSeq + i + 1}`;
+		if (seen.has(id)) return `processBundle: duplicate effect '${id}'`;
+		if (state.seenEffectIds.includes(id)) return `processBundle: duplicate effect '${id}'`;
+		seen.add(id);
+		out.push({
+			id,
+			type: draft.type,
+			payload: draft.payload,
+			...(typeof draft.processId === "string" ? { processId: draft.processId } : {}),
+			...(typeof draft.correlationId === "string" ? { correlationId: draft.correlationId } : {}),
+			...(typeof draft.causationId === "string" ? { causationId: draft.causationId } : {}),
+			...(isObjectRecord(draft.metadata) ? { metadata: draft.metadata } : {}),
+		});
+	}
+	return out;
+}
+
+function emitProcessFailure<TState>(
+	state: ProcessRuntimeState<TState>,
+	emit: (fact: ProcessRuntimeFact<TState, unknown, unknown>) => void,
+	raw: unknown,
+	command: ProcessCommand<unknown> | undefined,
+	code: ProcessErrorCode,
+	message: string,
+): void {
+	state.errorCount += 1;
+	const cursor = processCursorOf(state);
+	const error: ProcessError = {
+		code,
+		message,
+		command: raw,
+		...(command === undefined ? {} : { commandId: command.id, commandType: command.type }),
+		cursor,
+	};
+	emit({ kind: "error", error });
+	emitProcessStatus(state, emit, command, "rejected", 0, 0, code);
+	emitProcessAudit(state, emit, command, "failure", [], [], code, message);
+	emit({ kind: "cursor", cursor: processCursorOf(state) });
+}
+
+function emitProcessStatus<TState>(
+	state: ProcessRuntimeState<TState>,
+	emit: (fact: ProcessRuntimeFact<TState, unknown, unknown>) => void,
+	command: ProcessCommand<unknown> | undefined,
+	statusState: ProcessStatus["state"],
+	eventCount: number,
+	effectCount: number,
+	errorCode?: ProcessErrorCode,
+): void {
+	emit({
+		kind: "status",
+		status: {
+			state: statusState,
+			...(command === undefined ? {} : { commandId: command.id, commandType: command.type }),
+			eventCount,
+			effectCount,
+			...(errorCode === undefined ? {} : { errorCode }),
+			cursor: processCursorOf(state),
+		},
+	});
+}
+
+function emitProcessAudit<TState>(
+	state: ProcessRuntimeState<TState>,
+	emit: (fact: ProcessRuntimeFact<TState, unknown, unknown>) => void,
+	command: ProcessCommand<unknown> | undefined,
+	outcome: ProcessAuditRecord["outcome"],
+	events: readonly ProcessEvent<unknown>[],
+	effects: readonly ProcessEffectRequest<unknown>[],
+	errorCode: ProcessErrorCode | undefined,
+	errorMessage: string | undefined,
+): void {
+	state.auditSeq += 1;
+	emit({
+		kind: "audit",
+		audit: {
+			seq: state.auditSeq,
+			...(command === undefined ? {} : { commandId: command.id, commandType: command.type }),
+			outcome,
+			eventIds: events.map((event) => event.id),
+			eventTypes: events.map((event) => event.type),
+			effectIds: effects.map((effect) => effect.id),
+			effectTypes: effects.map((effect) => effect.type),
+			...(errorCode === undefined ? {} : { errorCode }),
+			...(errorMessage === undefined ? {} : { errorMessage }),
+			cursor: processCursorOf(state),
+		},
+	});
+}
+
+function processCursorOf(state: ProcessRuntimeState<unknown>): ProcessCursor {
+	return {
+		eventSeq: state.eventSeq,
+		effectSeq: state.effectSeq,
+		commandCount: state.commandCount,
+		errorCount: state.errorCount,
+		auditSeq: state.auditSeq,
+	};
+}
diff --git a/packages/ts/src/orchestration/resilience-bundles.ts b/packages/ts/src/orchestration/resilience-bundles.ts
new file mode 100644
index 00000000..d3142d94
--- /dev/null
+++ b/packages/ts/src/orchestration/resilience-bundles.ts
@@ -0,0 +1,312 @@
+import { depBatch } from "../ctx/types.js";
+import type { Graph } from "../graph/graph.js";
+import {
+	type BackoffPolicy,
+	nextRetryDelayMs,
+	type RetryPolicy,
+	type RetryStatus,
+	retryPolicy,
+	shouldRetry,
+} from "../graph/resilience.js";
+import { timeout as timeoutOperator } from "../graph/time.js";
+import type { Node } from "../node/node.js";
+
+export type ResilienceEvent =
+	| { readonly kind: "attempt"; readonly attempt: number }
+	| {
+			readonly kind: "retry";
+			readonly attempt: number;
+			readonly delayMs: number;
+			readonly error: unknown;
+	  }
+	| { readonly kind: "success"; readonly attempt?: number }
+	| { readonly kind: "failure"; readonly attempt?: number; readonly error: unknown }
+	| { readonly kind: "exhausted"; readonly attempt: number; readonly error: unknown };
+
+export interface RetryStatusBundle {
+	readonly status: Node<RetryStatus>;
+	readonly errors: Node<unknown>;
+}
+
+export interface BreakerOptions {
+	readonly failureThreshold: number;
+	readonly resetAfterMs?: number;
+	readonly now?: () => number;
+	readonly name?: string;
+}
+
+export interface BreakerStatus {
+	readonly state: "closed" | "open" | "half-open";
+	readonly failures: number;
+	readonly openedAtMs?: number;
+}
+
+export interface BreakerBundle {
+	readonly status: Node<BreakerStatus>;
+	readonly allowed: Node<boolean>;
+}
+
+export interface RateLimitOptions {
+	readonly max: number;
+	readonly windowMs: number;
+	readonly now?: () => number;
+	readonly name?: string;
+}
+
+export interface RateLimitStatus {
+	readonly allowed: number;
+	readonly dropped: number;
+	readonly remaining: number;
+	readonly resetAtMs: number;
+}
+
+export interface RateLimitBundle<T> {
+	readonly allowed: Node<T>;
+	readonly dropped: Node<T>;
+	readonly status: Node<RateLimitStatus>;
+}
+
+type RateLimitEvent<T> =
+	| { readonly kind: "allowed"; readonly value: T; readonly status: RateLimitStatus }
+	| { readonly kind: "dropped"; readonly value: T; readonly status: RateLimitStatus };
+
+export interface TimeoutBundle<T> {
+	readonly node: Node<T>;
+	readonly status: Node<"running" | "completed" | "errored">;
+	readonly errors: Node<unknown>;
+}
+
+export function retryStatusBundle(
+	graph: Graph,
+	events: Node<ResilienceEvent>,
+	opts: { name?: string; policy?: RetryPolicy } = {},
+): RetryStatusBundle {
+	const policy = opts.policy ?? retryPolicy();
+	const name = opts.name ?? "retry";
+	const status = graph.node<RetryStatus>(
+		[events],
+		(ctx) => {
+			let next =
+				ctx.state.get<RetryStatus>() ??
+				({ state: "idle", attempt: 0, maxAttempts: policy.maxAttempts } satisfies RetryStatus);
+			for (const raw of depBatch(ctx, 0) ?? []) {
+				const event = raw as ResilienceEvent;
+				if (event.kind === "attempt") {
+					next = { state: "running", attempt: event.attempt, maxAttempts: policy.maxAttempts };
+				} else if (event.kind === "retry") {
+					next = {
+						state: "waiting",
+						attempt: event.attempt,
+						maxAttempts: policy.maxAttempts,
+						delayMs: event.delayMs,
+					};
+				} else if (event.kind === "success") {
+					next = {
+						state: "succeeded",
+						attempt: event.attempt ?? next.attempt,
+						maxAttempts: policy.maxAttempts,
+					};
+				} else if (event.kind === "failure") {
+					const attempt = event.attempt ?? next.attempt;
+					next = {
+						state: shouldRetry(policy, attempt) ? "failed" : "exhausted",
+						attempt,
+						maxAttempts: policy.maxAttempts,
+						delayMs: shouldRetry(policy, attempt)
+							? nextRetryDelayMs(policy, attempt + 1)
+							: undefined,
+					};
+				} else {
+					next = {
+						state: "exhausted",
+						attempt: event.attempt,
+						maxAttempts: policy.maxAttempts,
+					};
+				}
+			}
+			ctx.state.set(next);
+			ctx.down([["DATA", next]]);
+		},
+		{ name: `${name}/status`, factory: "retryStatus" },
+	);
+	const errors = graph.node<unknown>(
+		[events],
+		(ctx) => {
+			for (const raw of depBatch(ctx, 0) ?? []) {
+				const event = raw as ResilienceEvent;
+				if ("error" in event) ctx.down([["DATA", event.error]]);
+			}
+		},
+		{ name: `${name}/errors`, factory: "retryErrors" },
+	);
+	return { status, errors };
+}
+
+export function breakerBundle(
+	graph: Graph,
+	events: Node<ResilienceEvent>,
+	opts: BreakerOptions,
+): BreakerBundle {
+	if (!Number.isInteger(opts.failureThreshold) || opts.failureThreshold <= 0) {
+		throw new RangeError("breakerBundle: failureThreshold must be a positive integer");
+	}
+	const name = opts.name ?? "breaker";
+	const now = opts.now ?? Date.now;
+	const status = graph.node<BreakerStatus>(
+		[events],
+		(ctx) => {
+			let next =
+				ctx.state.get<BreakerStatus>() ??
+				({ state: "closed", failures: 0 } satisfies BreakerStatus);
+			if (
+				next.state === "open" &&
+				opts.resetAfterMs !== undefined &&
+				next.openedAtMs !== undefined &&
+				now() - next.openedAtMs >= opts.resetAfterMs
+			) {
+				next = { ...next, state: "half-open" };
+			}
+			for (const raw of depBatch(ctx, 0) ?? []) {
+				const event = raw as ResilienceEvent;
+				if (event.kind === "success") {
+					next = { state: "closed", failures: 0 };
+				} else if (event.kind === "failure" || event.kind === "exhausted") {
+					const failures = next.failures + 1;
+					next =
+						failures >= opts.failureThreshold
+							? { state: "open", failures, openedAtMs: now() }
+							: { ...next, failures };
+				}
+			}
+			ctx.state.set(next);
+			ctx.down([["DATA", next]]);
+		},
+		{ name: `${name}/status`, factory: "breakerStatus" },
+	);
+	const allowed = graph.node<boolean>(
+		[status],
+		(ctx) => {
+			const statusBatch = depBatch(ctx, 0) ?? [];
+			for (const value of statusBatch) {
+				ctx.down([["DATA", (value as BreakerStatus).state !== "open"]]);
+			}
+		},
+		{ name: `${name}/allowed`, factory: "breakerAllowed" },
+	);
+	return { status, allowed };
+}
+
+export function rateLimitBundle<T>(
+	graph: Graph,
+	source: Node<T>,
+	opts: RateLimitOptions,
+): RateLimitBundle<T> {
+	if (!Number.isInteger(opts.max) || opts.max <= 0) {
+		throw new RangeError("rateLimitBundle: max must be a positive integer");
+	}
+	if (!Number.isFinite(opts.windowMs) || opts.windowMs <= 0) {
+		throw new RangeError("rateLimitBundle: windowMs must be positive");
+	}
+	const now = opts.now ?? Date.now;
+	const name = opts.name ?? "rateLimit";
+	const events = graph.node<RateLimitEvent<T>>(
+		[source],
+		(ctx) => {
+			type State = { count: number; resetAtMs: number; allowed: number; dropped: number };
+			const current = now();
+			let state =
+				ctx.state.get<State>() ??
+				({ count: 0, resetAtMs: current + opts.windowMs, allowed: 0, dropped: 0 } satisfies State);
+			if (current >= state.resetAtMs) {
+				state = { ...state, count: 0, resetAtMs: current + opts.windowMs };
+			}
+			for (const value of depBatch(ctx, 0) ?? []) {
+				const allowed = state.count < opts.max;
+				state = allowed
+					? { ...state, count: state.count + 1, allowed: state.allowed + 1 }
+					: { ...state, dropped: state.dropped + 1 };
+				const status = {
+					allowed: state.allowed,
+					dropped: state.dropped,
+					remaining: Math.max(0, opts.max - state.count),
+					resetAtMs: state.resetAtMs,
+				} satisfies RateLimitStatus;
+				ctx.down([
+					[
+						"DATA",
+						allowed
+							? ({ kind: "allowed", value: value as T, status } satisfies RateLimitEvent<T>)
+							: ({ kind: "dropped", value: value as T, status } satisfies RateLimitEvent<T>),
+					],
+				]);
+			}
+			ctx.state.set(state);
+		},
+		{ name: `${name}/events`, factory: "rateLimitEvents" },
+	);
+	const allowed = graph.node<T>(
+		[events],
+		(ctx) => {
+			for (const event of depBatch(ctx, 0) ?? []) {
+				const typed = event as RateLimitEvent<T>;
+				if (typed.kind === "allowed") ctx.down([["DATA", typed.value]]);
+			}
+		},
+		{ name: `${name}/allowed`, factory: "rateLimitAllowed" },
+	);
+	const dropped = graph.node<T>(
+		[events],
+		(ctx) => {
+			for (const event of depBatch(ctx, 0) ?? []) {
+				const typed = event as RateLimitEvent<T>;
+				if (typed.kind === "dropped") ctx.down([["DATA", typed.value]]);
+			}
+		},
+		{ name: `${name}/dropped`, factory: "rateLimitDropped" },
+	);
+	const status = graph.node<RateLimitStatus>(
+		[events],
+		(ctx) => {
+			for (const event of depBatch(ctx, 0) ?? []) {
+				ctx.down([["DATA", (event as RateLimitEvent<T>).status]]);
+			}
+		},
+		{ name: `${name}/status`, factory: "rateLimitStatus" },
+	);
+	return { allowed, dropped, status };
+}
+
+export function timeoutBundle<T>(
+	graph: Graph,
+	source: Node<T>,
+	ms: number,
+	opts: { name?: string } = {},
+): TimeoutBundle<T> {
+	const name = opts.name ?? "timeout";
+	const node = timeoutOperator(source, ms);
+	const status = graph.node<"running" | "completed" | "errored">(
+		[node],
+		(ctx) => {
+			const terminal = ctx.terminal[0];
+			if (terminal === true) ctx.down([["DATA", "completed"]]);
+			else if (terminal !== false && terminal !== undefined) ctx.down([["DATA", "errored"]]);
+			else if ((depBatch(ctx, 0) ?? []).length > 0) ctx.down([["DATA", "running"]]);
+		},
+		{ name: `${name}/status`, factory: "timeoutStatus" },
+	);
+	const errors = graph.node<unknown>(
+		[node],
+		(ctx) => {
+			const terminal = ctx.terminal[0];
+			if (terminal !== true && terminal !== false && terminal !== undefined) {
+				ctx.down([["DATA", terminal]]);
+			}
+		},
+		{ name: `${name}/errors`, factory: "timeoutErrors" },
+	);
+	return { node, status, errors };
+}
+
+export function constantBackoff(delayMs: number): BackoffPolicy {
+	return { kind: "constant", delayMs };
+}
diff --git a/packages/ts/src/orchestration/scheduled-readiness.ts b/packages/ts/src/orchestration/scheduled-readiness.ts
new file mode 100644
index 00000000..02e0965b
--- /dev/null
+++ b/packages/ts/src/orchestration/scheduled-readiness.ts
@@ -0,0 +1,714 @@
+import type { DataIssue } from "../data/index.js";
+import type { Graph } from "../graph/graph.js";
+import type { Node } from "../node/node.js";
+import {
+	canonicalPublicSourceRefs,
+	dataIssue,
+	forEachDepBatch,
+	projectRuntimeFact,
+	ref,
+	sanitizeGraphVisibleRecord,
+	stableJsonStringify,
+	uniqueSourceRefs,
+} from "./agent-runtime-common.js";
+import type { AgentRuntimeAuditRecord } from "./agent-runtime-types-agent.js";
+import type { SourceRef } from "./agent-runtime-types-core.js";
+
+export interface ScheduledReadinessRequested {
+	readonly kind: "scheduled-readiness-requested";
+	readonly scheduleId: string;
+	readonly subjectRefs: readonly SourceRef[];
+	readonly readyAtMs: number;
+	readonly deadlineMs?: number;
+	readonly reason?: string;
+	readonly policyRefs?: readonly SourceRef[];
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface ScheduledReadinessClock {
+	readonly kind: "scheduled-readiness-clock";
+	readonly clockId: string;
+	readonly nowMs: number;
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface ScheduledReadinessPending {
+	readonly kind: "scheduled-readiness-pending";
+	readonly scheduleId: string;
+	readonly subjectRefs: readonly SourceRef[];
+	readonly readyAtMs: number;
+	readonly deadlineMs?: number;
+	readonly nowMs?: number;
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface ScheduledReadinessReady {
+	readonly kind: "scheduled-readiness-ready";
+	readonly scheduleId: string;
+	readonly subjectRefs: readonly SourceRef[];
+	readonly readyAtMs: number;
+	readonly deadlineMs?: number;
+	readonly nowMs: number;
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface ScheduledReadinessOverdue {
+	readonly kind: "scheduled-readiness-overdue";
+	readonly scheduleId: string;
+	readonly subjectRefs: readonly SourceRef[];
+	readonly readyAtMs: number;
+	readonly deadlineMs: number;
+	readonly nowMs: number;
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly metadata?: Record<string, unknown>;
+}
+
+export type ScheduledReadinessStatusState = "pending" | "ready" | "overdue" | "issue";
+
+export interface ScheduledReadinessStatus {
+	readonly kind: "scheduled-readiness-status";
+	readonly statusId: string;
+	readonly scheduleId: string;
+	readonly state: ScheduledReadinessStatusState;
+	readonly subjectRefs?: readonly SourceRef[];
+	readonly readyAtMs?: number;
+	readonly deadlineMs?: number;
+	readonly nowMs?: number;
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly issueCodes?: readonly string[];
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface ScheduledReadinessViews {
+	readonly schedulesById: ReadonlyMap<string, ScheduledReadinessRequested>;
+	readonly pendingById: ReadonlyMap<string, ScheduledReadinessPending>;
+	readonly readyById: ReadonlyMap<string, ScheduledReadinessReady>;
+	readonly overdueById: ReadonlyMap<string, ScheduledReadinessOverdue>;
+	readonly statusById: ReadonlyMap<string, ScheduledReadinessStatus>;
+	readonly nowMs?: number;
+}
+
+export interface ScheduledReadinessBundle {
+	readonly pending: Node<ScheduledReadinessPending>;
+	readonly ready: Node<ScheduledReadinessReady>;
+	readonly overdue: Node<ScheduledReadinessOverdue>;
+	readonly status: Node<ScheduledReadinessStatus>;
+	readonly issues: Node<DataIssue>;
+	readonly audit: Node<AgentRuntimeAuditRecord>;
+	readonly views: Node<ScheduledReadinessViews>;
+}
+
+export function scheduledReadinessProjector(
+	graph: Graph,
+	opts: {
+		readonly name?: string;
+		readonly schedules: readonly Node<ScheduledReadinessRequested>[];
+		readonly clocks?: readonly Node<ScheduledReadinessClock>[];
+	},
+): ScheduledReadinessBundle {
+	const name = opts.name ?? "scheduledReadiness";
+	const clockDeps = opts.clocks ?? [];
+	const runtime = graph.node<ScheduledReadinessFact>(
+		[...opts.schedules, ...clockDeps],
+		(ctx) => {
+			const state = ctx.state.get<ScheduledReadinessProjectorState>() ?? initialState();
+			forEachDepBatch(ctx, 0, opts.schedules.length, (raw) => {
+				const retained = sanitizeSchedule(raw);
+				if (retained.ok) {
+					const existing = state.schedules.get(retained.schedule.scheduleId);
+					if (existing === undefined) {
+						state.schedules.set(retained.schedule.scheduleId, retained.schedule);
+					} else if (scheduleIdentity(existing) !== scheduleIdentity(retained.schedule)) {
+						const issue = dataIssue(
+							"scheduled-readiness-schedule-conflict",
+							"Scheduled readiness scheduleId was replayed with conflicting schedule material; the first valid schedule was retained.",
+							{
+								subjectId: retained.schedule.scheduleId,
+								refs: scheduleSourceRefs(retained.schedule, state.clockSourceRefs),
+								details: {
+									existingReadyAtMs: readinessMs(existing),
+									incomingReadyAtMs: readinessMs(retained.schedule),
+									existingDeadlineMs: existing.deadlineMs,
+									incomingDeadlineMs: retained.schedule.deadlineMs,
+								},
+							},
+						);
+						emitIssue(ctx, state, issue);
+						emitStatus(ctx, state, {
+							kind: "scheduled-readiness-status",
+							statusId: `${retained.schedule.scheduleId}:scheduled-readiness-status:issue`,
+							scheduleId: retained.schedule.scheduleId,
+							state: "issue",
+							subjectRefs: scheduleSubjectRefs(existing),
+							readyAtMs: readinessMs(existing),
+							...(existing.deadlineMs === undefined ? {} : { deadlineMs: existing.deadlineMs }),
+							nowMs: state.nowMs,
+							sourceRefs: scheduleSourceRefs(existing, state.clockSourceRefs),
+							issueCodes: [issue.code],
+						});
+					}
+				} else {
+					emitIssue(ctx, state, retained.issue);
+					emitStatus(ctx, state, {
+						kind: "scheduled-readiness-status",
+						statusId: `${retained.scheduleId}:scheduled-readiness-status:issue`,
+						scheduleId: retained.scheduleId,
+						state: "issue",
+						sourceRefs: retained.sourceRefs,
+						issueCodes: [retained.issue.code],
+					});
+				}
+			});
+			forEachDepBatch(ctx, opts.schedules.length, clockDeps.length, (raw) => {
+				const clock = sanitizeClock(raw);
+				if (clock.ok) {
+					if (state.nowMs !== undefined && clock.clock.nowMs < state.nowMs) {
+						emitIssue(
+							ctx,
+							state,
+							dataIssue(
+								"scheduled-readiness-clock-rollback",
+								"Scheduled readiness clock facts must be monotonic; rollback was ignored.",
+								{
+									subjectId: clock.clock.clockId,
+									refs: clock.clock.sourceRefs,
+									severity: "warning",
+									details: { nowMs: clock.clock.nowMs, previousNowMs: state.nowMs },
+								},
+							),
+						);
+						return;
+					}
+					state.nowMs = clock.clock.nowMs;
+					state.clockSourceRefs = clock.clock.sourceRefs;
+				} else {
+					emitIssue(ctx, state, clock.issue);
+				}
+			});
+			evaluateSchedules(ctx, state);
+			ctx.down([["DATA", { kind: "views", views: buildViews(state) }]]);
+			ctx.state.set(state);
+		},
+		{ name: `${name}/runtime`, factory: "scheduledReadinessProjector", partial: true },
+	);
+	return {
+		pending: projectRuntimeFact(
+			graph,
+			runtime,
+			`${name}/pending`,
+			"scheduledReadinessPending",
+			(fact) => (fact.kind === "pending" ? fact.pending : undefined),
+		),
+		ready: projectRuntimeFact(graph, runtime, `${name}/ready`, "scheduledReadinessReady", (fact) =>
+			fact.kind === "ready" ? fact.ready : undefined,
+		),
+		overdue: projectRuntimeFact(
+			graph,
+			runtime,
+			`${name}/overdue`,
+			"scheduledReadinessOverdue",
+			(fact) => (fact.kind === "overdue" ? fact.overdue : undefined),
+		),
+		status: projectRuntimeFact(
+			graph,
+			runtime,
+			`${name}/status`,
+			"scheduledReadinessStatus",
+			(fact) => (fact.kind === "status" ? fact.status : undefined),
+		),
+		issues: projectRuntimeFact(
+			graph,
+			runtime,
+			`${name}/issues`,
+			"scheduledReadinessIssues",
+			(fact) => (fact.kind === "issue" ? fact.issue : undefined),
+		),
+		audit: projectRuntimeFact(graph, runtime, `${name}/audit`, "scheduledReadinessAudit", (fact) =>
+			fact.kind === "audit" ? fact.audit : undefined,
+		),
+		views: projectRuntimeFact(graph, runtime, `${name}/views`, "scheduledReadinessViews", (fact) =>
+			fact.kind === "views" ? fact.views : undefined,
+		),
+	};
+}
+
+type ScheduledReadinessFact =
+	| { readonly kind: "pending"; readonly pending: ScheduledReadinessPending }
+	| { readonly kind: "ready"; readonly ready: ScheduledReadinessReady }
+	| { readonly kind: "overdue"; readonly overdue: ScheduledReadinessOverdue }
+	| { readonly kind: "status"; readonly status: ScheduledReadinessStatus }
+	| { readonly kind: "issue"; readonly issue: DataIssue }
+	| { readonly kind: "audit"; readonly audit: AgentRuntimeAuditRecord }
+	| { readonly kind: "views"; readonly views: ScheduledReadinessViews };
+
+interface ScheduledReadinessProjectorState {
+	schedules: Map<string, ScheduledReadinessRequested>;
+	pendingById: Map<string, ScheduledReadinessPending>;
+	readyById: Map<string, ScheduledReadinessReady>;
+	overdueById: Map<string, ScheduledReadinessOverdue>;
+	statusById: Map<string, ScheduledReadinessStatus>;
+	emittedKeys: Set<string>;
+	issueKeys: Set<string>;
+	auditSeq: number;
+	nowMs: number | undefined;
+	clockSourceRefs: readonly SourceRef[] | undefined;
+}
+
+function initialState(): ScheduledReadinessProjectorState {
+	return {
+		schedules: new Map(),
+		pendingById: new Map(),
+		readyById: new Map(),
+		overdueById: new Map(),
+		statusById: new Map(),
+		emittedKeys: new Set(),
+		issueKeys: new Set(),
+		auditSeq: 0,
+		nowMs: undefined,
+		clockSourceRefs: undefined,
+	};
+}
+
+function evaluateSchedules(
+	ctx: { down: (msgs: readonly ["DATA", ScheduledReadinessFact][]) => void },
+	state: ScheduledReadinessProjectorState,
+): void {
+	for (const schedule of state.schedules.values()) {
+		const readyAtMs = readinessMs(schedule);
+		const subjectRefs = scheduleSubjectRefs(schedule);
+		const sourceRefs = scheduleSourceRefs(schedule, state.clockSourceRefs);
+		const baseMetadata = sanitizeScheduledReadinessMetadata({
+			...(schedule.reason === undefined ? {} : { reason: schedule.reason }),
+			...(schedule.metadata ?? {}),
+		});
+		if (state.nowMs === undefined || state.nowMs < readyAtMs) {
+			const pending = Object.freeze({
+				kind: "scheduled-readiness-pending",
+				scheduleId: schedule.scheduleId,
+				subjectRefs,
+				readyAtMs,
+				...(schedule.deadlineMs === undefined ? {} : { deadlineMs: schedule.deadlineMs }),
+				...(state.nowMs === undefined ? {} : { nowMs: state.nowMs }),
+				sourceRefs,
+				...(baseMetadata === undefined ? {} : { metadata: baseMetadata }),
+			} satisfies ScheduledReadinessPending);
+			emitPending(ctx, state, pending);
+			emitStatus(
+				ctx,
+				state,
+				statusFor(schedule, "pending", {
+					subjectRefs,
+					readyAtMs,
+					sourceRefs,
+					nowMs: state.nowMs,
+				}),
+			);
+			continue;
+		}
+		const ready = Object.freeze({
+			kind: "scheduled-readiness-ready",
+			scheduleId: schedule.scheduleId,
+			subjectRefs,
+			readyAtMs,
+			...(schedule.deadlineMs === undefined ? {} : { deadlineMs: schedule.deadlineMs }),
+			nowMs: state.nowMs,
+			sourceRefs,
+			...(baseMetadata === undefined ? {} : { metadata: baseMetadata }),
+		} satisfies ScheduledReadinessReady);
+		emitReady(ctx, state, ready);
+		emitStatus(
+			ctx,
+			state,
+			statusFor(schedule, "ready", {
+				subjectRefs,
+				readyAtMs,
+				sourceRefs,
+				nowMs: state.nowMs,
+			}),
+		);
+		if (schedule.deadlineMs !== undefined && state.nowMs > schedule.deadlineMs) {
+			const overdue = Object.freeze({
+				kind: "scheduled-readiness-overdue",
+				scheduleId: schedule.scheduleId,
+				subjectRefs,
+				readyAtMs,
+				deadlineMs: schedule.deadlineMs,
+				nowMs: state.nowMs,
+				sourceRefs,
+				...(baseMetadata === undefined ? {} : { metadata: baseMetadata }),
+			} satisfies ScheduledReadinessOverdue);
+			emitOverdue(ctx, state, overdue);
+			emitStatus(
+				ctx,
+				state,
+				statusFor(schedule, "overdue", {
+					subjectRefs,
+					readyAtMs,
+					sourceRefs,
+					nowMs: state.nowMs,
+				}),
+			);
+		}
+	}
+}
+
+function sanitizeSchedule(raw: unknown):
+	| { readonly ok: true; readonly schedule: ScheduledReadinessRequested }
+	| {
+			readonly ok: false;
+			readonly scheduleId: string;
+			readonly issue: DataIssue;
+			readonly sourceRefs?: readonly SourceRef[];
+	  } {
+	if (!isPlainRecord(raw)) {
+		return {
+			ok: false,
+			scheduleId: "unknown-scheduled-readiness",
+			sourceRefs: [],
+			issue: dataIssue(
+				"scheduled-readiness-malformed-schedule",
+				"Scheduled readiness requires a stable scheduleId, subjectRefs array, and finite readyAtMs.",
+				{ subjectId: "unknown-scheduled-readiness", refs: [] },
+			),
+		};
+	}
+	const scheduleId =
+		typeof raw.scheduleId === "string" && raw.scheduleId.length > 0
+			? raw.scheduleId
+			: "unknown-scheduled-readiness";
+	const refs = sourceRefArray(raw.sourceRefs);
+	const hasDeadlineMs = Object.hasOwn(raw, "deadlineMs");
+	const readyAtMs = finiteNumberOrUndefined(raw.readyAtMs);
+	const deadlineMs = finiteNumberOrUndefined(raw.deadlineMs);
+	if (
+		raw.kind !== "scheduled-readiness-requested" ||
+		typeof raw.scheduleId !== "string" ||
+		raw.scheduleId.length === 0 ||
+		readyAtMs === undefined ||
+		(hasDeadlineMs && deadlineMs === undefined) ||
+		raw.subjectRef !== undefined ||
+		!Array.isArray(raw.subjectRefs) ||
+		raw.notBeforeMs !== undefined ||
+		(raw.policyRefs !== undefined && !Array.isArray(raw.policyRefs)) ||
+		(raw.sourceRefs !== undefined && !Array.isArray(raw.sourceRefs))
+	) {
+		return {
+			ok: false,
+			scheduleId,
+			sourceRefs: refs,
+			issue: dataIssue(
+				"scheduled-readiness-malformed-schedule",
+				"Scheduled readiness requires a stable scheduleId, subjectRefs array, and finite readyAtMs.",
+				{ subjectId: scheduleId, refs },
+			),
+		};
+	}
+	const subjectRefs = sourceRefArray(raw.subjectRefs);
+	const policyRefs = sourceRefArray(raw.policyRefs);
+	const metadata = sanitizeScheduledReadinessMetadata(
+		isPlainRecord(raw.metadata) ? raw.metadata : undefined,
+	);
+	return {
+		ok: true,
+		schedule: Object.freeze({
+			kind: "scheduled-readiness-requested",
+			scheduleId: raw.scheduleId,
+			subjectRefs,
+			readyAtMs,
+			...(deadlineMs === undefined ? {} : { deadlineMs }),
+			...(typeof raw.reason === "string" ? { reason: raw.reason } : {}),
+			...(policyRefs.length === 0 ? {} : { policyRefs }),
+			sourceRefs: refs,
+			...(metadata === undefined ? {} : { metadata }),
+		} satisfies ScheduledReadinessRequested),
+	};
+}
+
+function sanitizeClock(
+	raw: unknown,
+):
+	| { readonly ok: true; readonly clock: ScheduledReadinessClock }
+	| { readonly ok: false; readonly issue: DataIssue } {
+	if (!isPlainRecord(raw)) {
+		return {
+			ok: false,
+			issue: dataIssue(
+				"scheduled-readiness-malformed-clock",
+				"Scheduled readiness clock facts require a stable clockId and finite nowMs.",
+				{ subjectId: "unknown-scheduled-readiness-clock", refs: [] },
+			),
+		};
+	}
+	const refs = sourceRefArray(raw.sourceRefs);
+	const nowMs = finiteNumberOrUndefined(raw.nowMs);
+	if (
+		raw.kind !== "scheduled-readiness-clock" ||
+		typeof raw.clockId !== "string" ||
+		raw.clockId.length === 0 ||
+		nowMs === undefined ||
+		(raw.sourceRefs !== undefined && !Array.isArray(raw.sourceRefs))
+	) {
+		const clockSubjectId =
+			typeof raw.clockId === "string" && raw.clockId.length > 0
+				? raw.clockId
+				: "unknown-scheduled-readiness-clock";
+		return {
+			ok: false,
+			issue: dataIssue(
+				"scheduled-readiness-malformed-clock",
+				"Scheduled readiness clock facts require a stable clockId and finite nowMs.",
+				{ subjectId: clockSubjectId, refs },
+			),
+		};
+	}
+	const metadata = sanitizeScheduledReadinessMetadata(
+		isPlainRecord(raw.metadata) ? raw.metadata : undefined,
+	);
+	return {
+		ok: true,
+		clock: Object.freeze({
+			kind: "scheduled-readiness-clock",
+			clockId: raw.clockId,
+			nowMs,
+			sourceRefs: refs,
+			...(metadata === undefined ? {} : { metadata }),
+		} satisfies ScheduledReadinessClock),
+	};
+}
+
+function emitPending(
+	ctx: { down: (msgs: readonly ["DATA", ScheduledReadinessFact][]) => void },
+	state: ScheduledReadinessProjectorState,
+	pending: ScheduledReadinessPending,
+): void {
+	state.pendingById.set(pending.scheduleId, pending);
+	const key = `pending:${pending.scheduleId}`;
+	if (state.emittedKeys.has(key)) return;
+	state.emittedKeys.add(key);
+	ctx.down([["DATA", { kind: "pending", pending }]]);
+}
+
+function emitReady(
+	ctx: { down: (msgs: readonly ["DATA", ScheduledReadinessFact][]) => void },
+	state: ScheduledReadinessProjectorState,
+	ready: ScheduledReadinessReady,
+): void {
+	const key = `ready:${ready.scheduleId}`;
+	if (state.emittedKeys.has(key)) return;
+	state.emittedKeys.add(key);
+	state.readyById.set(ready.scheduleId, ready);
+	state.pendingById.delete(ready.scheduleId);
+	emitAudit(ctx, state, "scheduled-readiness-ready", {
+		subjectId: ready.scheduleId,
+		sourceRefs: ready.sourceRefs,
+		metadata: { nowMs: ready.nowMs, readyAtMs: ready.readyAtMs },
+	});
+	ctx.down([["DATA", { kind: "ready", ready }]]);
+}
+
+function emitOverdue(
+	ctx: { down: (msgs: readonly ["DATA", ScheduledReadinessFact][]) => void },
+	state: ScheduledReadinessProjectorState,
+	overdue: ScheduledReadinessOverdue,
+): void {
+	const key = `overdue:${overdue.scheduleId}`;
+	if (state.emittedKeys.has(key)) return;
+	state.emittedKeys.add(key);
+	state.overdueById.set(overdue.scheduleId, overdue);
+	emitAudit(ctx, state, "scheduled-readiness-overdue", {
+		subjectId: overdue.scheduleId,
+		sourceRefs: overdue.sourceRefs,
+		metadata: {
+			nowMs: overdue.nowMs,
+			readyAtMs: overdue.readyAtMs,
+			deadlineMs: overdue.deadlineMs,
+		},
+	});
+	ctx.down([["DATA", { kind: "overdue", overdue }]]);
+}
+
+function emitStatus(
+	ctx: { down: (msgs: readonly ["DATA", ScheduledReadinessFact][]) => void },
+	state: ScheduledReadinessProjectorState,
+	status: ScheduledReadinessStatus,
+): void {
+	state.statusById.set(status.scheduleId, status);
+	const key = `status:${stableJsonStringify(status)}`;
+	if (state.emittedKeys.has(key)) return;
+	state.emittedKeys.add(key);
+	ctx.down([["DATA", { kind: "status", status }]]);
+}
+
+function emitIssue(
+	ctx: { down: (msgs: readonly ["DATA", ScheduledReadinessFact][]) => void },
+	state: ScheduledReadinessProjectorState,
+	issue: DataIssue,
+): void {
+	const key = `${issue.code}:${issue.subjectId ?? ""}:${JSON.stringify(issue.details ?? {})}`;
+	if (state.issueKeys.has(key)) return;
+	state.issueKeys.add(key);
+	ctx.down([["DATA", { kind: "issue", issue }]]);
+}
+
+function emitAudit(
+	ctx: { down: (msgs: readonly ["DATA", ScheduledReadinessFact][]) => void },
+	state: ScheduledReadinessProjectorState,
+	kind: string,
+	opts: {
+		readonly subjectId?: string;
+		readonly sourceRefs?: readonly SourceRef[];
+		readonly metadata?: Record<string, unknown>;
+	} = {},
+): void {
+	state.auditSeq += 1;
+	const metadata = sanitizeGraphVisibleRecord(opts.metadata);
+	ctx.down([
+		[
+			"DATA",
+			{
+				kind: "audit",
+				audit: Object.freeze({
+					id: `scheduled-readiness-audit-${state.auditSeq}`,
+					kind,
+					...(opts.subjectId === undefined ? {} : { subjectId: opts.subjectId }),
+					...(opts.sourceRefs === undefined
+						? {}
+						: { sourceRefs: canonicalPublicSourceRefs(opts.sourceRefs) }),
+					...(metadata === undefined ? {} : { metadata }),
+				} satisfies AgentRuntimeAuditRecord),
+			},
+		],
+	]);
+}
+
+function statusFor(
+	schedule: ScheduledReadinessRequested,
+	state: ScheduledReadinessStatusState,
+	opts: {
+		readonly subjectRefs: readonly SourceRef[];
+		readonly readyAtMs: number;
+		readonly sourceRefs: readonly SourceRef[];
+		readonly nowMs?: number;
+	},
+): ScheduledReadinessStatus {
+	const metadata = sanitizeGraphVisibleRecord({
+		...(schedule.reason === undefined ? {} : { reason: schedule.reason }),
+	});
+	return Object.freeze({
+		kind: "scheduled-readiness-status",
+		statusId: `${schedule.scheduleId}:scheduled-readiness-status:${state}`,
+		scheduleId: schedule.scheduleId,
+		state,
+		subjectRefs: opts.subjectRefs,
+		readyAtMs: opts.readyAtMs,
+		...(schedule.deadlineMs === undefined ? {} : { deadlineMs: schedule.deadlineMs }),
+		...(opts.nowMs === undefined ? {} : { nowMs: opts.nowMs }),
+		sourceRefs: opts.sourceRefs,
+		...(metadata === undefined ? {} : { metadata }),
+	} satisfies ScheduledReadinessStatus);
+}
+
+function readinessMs(schedule: ScheduledReadinessRequested): number {
+	return schedule.readyAtMs;
+}
+
+function scheduleIdentity(schedule: ScheduledReadinessRequested): string {
+	return stableJsonStringify({
+		scheduleId: schedule.scheduleId,
+		subjectRefs: schedule.subjectRefs,
+		readyAtMs: schedule.readyAtMs,
+		deadlineMs: schedule.deadlineMs,
+		reason: schedule.reason,
+		policyRefs: schedule.policyRefs,
+		sourceRefs: schedule.sourceRefs,
+		metadata: schedule.metadata,
+	});
+}
+
+function scheduleSubjectRefs(schedule: ScheduledReadinessRequested): readonly SourceRef[] {
+	return canonicalPublicSourceRefs(uniqueSourceRefs(schedule.subjectRefs));
+}
+
+function scheduleSourceRefs(
+	schedule: ScheduledReadinessRequested,
+	clockSourceRefs: readonly SourceRef[] | undefined,
+): readonly SourceRef[] {
+	return canonicalPublicSourceRefs(
+		uniqueSourceRefs([
+			ref("scheduled-readiness", schedule.scheduleId),
+			...(schedule.sourceRefs ?? []),
+			...(schedule.policyRefs ?? []),
+			...(clockSourceRefs ?? []),
+		]),
+	);
+}
+
+function sanitizeScheduledReadinessMetadata(
+	value: Record<string, unknown> | undefined,
+): Record<string, unknown> | undefined {
+	const filtered = omitRuntimeMetadata(value);
+	return sanitizeGraphVisibleRecord(filtered);
+}
+
+function omitRuntimeMetadata(value: unknown): Record<string, unknown> | undefined {
+	if (!isPlainRecord(value)) return undefined;
+	const out: Record<string, unknown> = {};
+	for (const [key, child] of Object.entries(value)) {
+		if (isRuntimeMetadataKey(key)) continue;
+		const filteredChild = Array.isArray(child)
+			? child.map((entry) => (isPlainRecord(entry) ? omitRuntimeMetadata(entry) : entry))
+			: isPlainRecord(child)
+				? omitRuntimeMetadata(child)
+				: child;
+		if (filteredChild !== undefined) out[key] = filteredChild;
+	}
+	return Object.keys(out).length === 0 ? undefined : out;
+}
+
+function isPlainRecord(value: unknown): value is Record<string, unknown> {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+function finiteNumberOrUndefined(value: unknown): number | undefined {
+	return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+
+function sourceRefArray(value: unknown): readonly SourceRef[] {
+	if (!Array.isArray(value)) return [];
+	return canonicalPublicSourceRefs(
+		value.flatMap((entry) => {
+			const sourceRef = sourceRefOrUndefined(entry);
+			return sourceRef === undefined ? [] : [sourceRef];
+		}),
+	);
+}
+
+function sourceRefOrUndefined(value: unknown): SourceRef | undefined {
+	if (!isPlainRecord(value)) return undefined;
+	if (typeof value.kind !== "string" || value.kind.length === 0) return undefined;
+	if (typeof value.id !== "string" || value.id.length === 0) return undefined;
+	return isPlainRecord(value.metadata)
+		? { kind: value.kind, id: value.id, metadata: value.metadata }
+		: { kind: value.kind, id: value.id };
+}
+
+function isRuntimeMetadataKey(key: string): boolean {
+	return /^(apiKey|api_key|secret|client|transport|subprocess|sdk|oauth|credential|credentials|accessToken|access_token|refreshToken|refresh_token|idToken|id_token|token|password|passphrase|authorization|authHeader|auth_header|bearer|privateKey|private_key|sessionCookie|session_cookie|cookie|stdout|stderr|stack|stackTrace|stack_trace|providerRaw|provider_raw|rawResponse|raw_response|rawResponseBody|raw_response_body|diff|patch|fileContents|file_contents|binary|media)$/i.test(
+		key,
+	);
+}
+
+function buildViews(state: ScheduledReadinessProjectorState): ScheduledReadinessViews {
+	return Object.freeze({
+		schedulesById: new Map(state.schedules),
+		pendingById: new Map(state.pendingById),
+		readyById: new Map(state.readyById),
+		overdueById: new Map(state.overdueById),
+		statusById: new Map(state.statusById),
+		...(state.nowMs === undefined ? {} : { nowMs: state.nowMs }),
+	});
+}
diff --git a/packages/ts/src/orchestration/work-item-runtime-admission.ts b/packages/ts/src/orchestration/work-item-runtime-admission.ts
new file mode 100644
index 00000000..d8929345
--- /dev/null
+++ b/packages/ts/src/orchestration/work-item-runtime-admission.ts
@@ -0,0 +1,467 @@
+import { type Ctx, depBatch } from "../ctx/types.js";
+import type { Graph } from "../graph/graph.js";
+import type { Node } from "../node/node.js";
+import type { AgentRuntimeAuditRecord } from "./agent-runtime.js";
+import {
+	emitWorkItemAdmissionIssue,
+	emptyWorkItemDomainActionAdmissionState,
+	forEachPolicyDepBatch,
+	freezeWorkItemDomainActionAdmissionViews,
+	projectRuntimeFact,
+	workItemAdmissionDecisionRefs,
+	workItemAdmissionProposalRefs,
+} from "./work-item-runtime-shared.js";
+import type {
+	WorkItemDomainActionAdmission,
+	WorkItemDomainActionAdmissionBundle,
+	WorkItemDomainActionAdmissionDecision,
+	WorkItemDomainActionAdmissionFact,
+	WorkItemDomainActionAdmissionOutcome,
+	WorkItemDomainActionAdmissionPolicy,
+	WorkItemDomainActionAdmissionState,
+	WorkItemDomainActionAdmissionStateInternal,
+	WorkItemDomainActionAdmissionViews,
+	WorkItemDomainActionAdmissionViewsState,
+	WorkItemDomainActionProposal,
+	WorkItemStatusRecord,
+} from "./work-item-runtime-types.js";
+
+export function workItemDomainActionAdmissionProjector(
+	graph: Graph,
+	opts: {
+		readonly name?: string;
+		readonly proposals: Node<WorkItemDomainActionProposal>;
+		readonly decisions: Node<WorkItemDomainActionAdmissionDecision>;
+		readonly admissionPolicies?: readonly Node<WorkItemDomainActionAdmissionPolicy>[];
+		readonly now?: () => number;
+	},
+): WorkItemDomainActionAdmissionBundle {
+	const name = opts.name ?? "workItemDomainActionAdmissions";
+	const policyDeps = opts.admissionPolicies ?? [];
+	const policyStart = 2;
+	const now = opts.now ?? Date.now;
+	const runtime = graph.node<WorkItemDomainActionAdmissionFact>(
+		[opts.proposals, opts.decisions, ...policyDeps],
+		(ctx) => {
+			const state =
+				ctx.state.get<WorkItemDomainActionAdmissionStateInternal>() ??
+				emptyWorkItemDomainActionAdmissionState();
+			for (const raw of depBatch(ctx, 0) ?? []) {
+				const proposal = raw as WorkItemDomainActionProposal;
+				if (state.proposals.has(proposal.proposalId)) {
+					emitWorkItemAdmissionIssue(
+						ctx,
+						state,
+						`duplicate-admission-proposal:${proposal.proposalId}`,
+						"duplicate-work-item-domain-action-proposal",
+						`WorkItemDomainActionProposal '${proposal.proposalId}' was already seen by the admission projector`,
+						proposal.workItemId,
+						workItemAdmissionProposalRefs(proposal),
+					);
+					continue;
+				}
+				state.proposals.set(proposal.proposalId, proposal);
+			}
+			forEachPolicyDepBatch(ctx, policyStart, policyDeps.length, (raw) => {
+				const policy = raw as WorkItemDomainActionAdmissionPolicy;
+				state.policies.set(policy.policyId, policy);
+			});
+			for (const raw of depBatch(ctx, 1) ?? []) {
+				const decision = raw as WorkItemDomainActionAdmissionDecision;
+				if (state.decisions.has(decision.decisionId)) {
+					emitWorkItemAdmissionIssue(
+						ctx,
+						state,
+						`duplicate-admission-decision:${decision.decisionId}`,
+						"duplicate-work-item-domain-action-admission-decision",
+						`WorkItemDomainActionAdmissionDecision '${decision.decisionId}' was already seen by the admission projector`,
+						decision.proposalId,
+						workItemAdmissionDecisionRefs(decision),
+					);
+					continue;
+				}
+				state.decisions.set(decision.decisionId, decision);
+			}
+			evaluateWorkItemDomainActionAdmissions(ctx, state, now());
+			ctx.state.set(state);
+		},
+		{ name: `${name}/runtime`, factory: "workItemDomainActionAdmissionProjector", partial: true },
+	);
+	return {
+		admissions: projectRuntimeFact(
+			graph,
+			runtime,
+			`${name}/admissions`,
+			"workItemDomainActionAdmissions",
+			(fact) => (fact.kind === "admission" ? fact.admission : undefined),
+		),
+		status: projectRuntimeFact(
+			graph,
+			runtime,
+			`${name}/status`,
+			"workItemDomainActionAdmissionStatus",
+			(fact) => (fact.kind === "status" ? fact.status : undefined),
+		),
+		issues: projectRuntimeFact(
+			graph,
+			runtime,
+			`${name}/issues`,
+			"workItemDomainActionAdmissionIssues",
+			(fact) => (fact.kind === "issue" ? fact.issue : undefined),
+		),
+		audit: projectRuntimeFact(
+			graph,
+			runtime,
+			`${name}/audit`,
+			"workItemDomainActionAdmissionAudit",
+			(fact) => (fact.kind === "audit" ? fact.audit : undefined),
+		),
+		views: graph.node<WorkItemDomainActionAdmissionViews>(
+			[runtime],
+			(ctx) => {
+				const state = ctx.state.get<WorkItemDomainActionAdmissionViewsState>() ?? {
+					admissionsByProposal: new Map<string, WorkItemDomainActionAdmission>(),
+					admissionsByWorkItem: new Map<string, WorkItemDomainActionAdmission[]>(),
+					issues: [],
+					audit: [],
+				};
+				for (const raw of depBatch(ctx, 0) ?? []) {
+					const fact = raw as WorkItemDomainActionAdmissionFact;
+					if (fact.kind === "admission") {
+						const admission = fact.admission;
+						state.admissionsByProposal.set(admission.proposalId, admission);
+						const byWorkItem = state.admissionsByWorkItem.get(admission.workItemId) ?? [];
+						byWorkItem.push(admission);
+						state.admissionsByWorkItem.set(admission.workItemId, byWorkItem);
+					} else if (fact.kind === "issue") state.issues.push(fact.issue);
+					else if (fact.kind === "audit") state.audit.push(fact.audit);
+				}
+				ctx.state.set(state);
+				ctx.down([["DATA", freezeWorkItemDomainActionAdmissionViews(state)]]);
+			},
+			{ name: `${name}/views`, factory: "workItemDomainActionAdmissionViews" },
+		),
+	};
+}
+
+function evaluateWorkItemDomainActionAdmissions(
+	ctx: Ctx,
+	state: WorkItemDomainActionAdmissionStateInternal,
+	admittedAtMs: number,
+): void {
+	let emitted = true;
+	let passes = 0;
+	while (emitted && passes <= state.decisions.size) {
+		emitted = false;
+		passes += 1;
+		for (const decision of state.decisions.values()) {
+			if (state.terminalDecisionIds.has(decision.decisionId)) continue;
+			emitted =
+				evaluateWorkItemDomainActionAdmission(ctx, state, decision, admittedAtMs) || emitted;
+		}
+	}
+}
+
+function evaluateWorkItemDomainActionAdmission(
+	ctx: Ctx,
+	state: WorkItemDomainActionAdmissionStateInternal,
+	decision: WorkItemDomainActionAdmissionDecision,
+	admittedAtMs: number,
+): boolean {
+	const proposal = state.proposals.get(decision.proposalId);
+	const proposalRefs = workItemAdmissionDecisionRefs(decision, proposal);
+	const subjectId = proposal?.workItemId ?? decision.proposalId;
+	if (proposal === undefined) {
+		emitWorkItemAdmissionIssue(
+			ctx,
+			state,
+			`missing-admission-proposal:${decision.decisionId}:${decision.proposalId}`,
+			"missing-work-item-domain-action-admission-proposal",
+			`WorkItemDomainActionAdmissionDecision '${decision.decisionId}' references missing proposal '${decision.proposalId}'`,
+			subjectId,
+			proposalRefs,
+		);
+		return false;
+	}
+	const staleProposalRef = (decision.sourceRefs ?? []).find(
+		(sourceRef) =>
+			sourceRef.kind === "work-item-domain-action-proposal" &&
+			sourceRef.id !== decision.proposalId &&
+			sourceRef.id !== decision.targetProposalId,
+	);
+	if (staleProposalRef !== undefined) {
+		emitWorkItemAdmissionIssue(
+			ctx,
+			state,
+			`stale-admission-proposal-ref:${decision.decisionId}:${staleProposalRef.id}`,
+			"stale-work-item-domain-action-admission-proposal-ref",
+			`WorkItemDomainActionAdmissionDecision '${decision.decisionId}' carries stale proposal ref '${staleProposalRef.id}'`,
+			proposal.workItemId,
+			proposalRefs,
+		);
+		state.terminalDecisionIds.add(decision.decisionId);
+		return false;
+	}
+	const policy = admissionPolicyForDecision(state, decision);
+	if (typeof policy === "string") {
+		emitWorkItemAdmissionIssue(
+			ctx,
+			state,
+			`${policy}:${decision.decisionId}:${decision.policyId ?? "missing"}`,
+			policy,
+			admissionPolicyIssueMessage(policy, decision),
+			proposal.workItemId,
+			proposalRefs,
+		);
+		if (policy === "stale-work-item-domain-action-admission-policy-ref")
+			state.terminalDecisionIds.add(decision.decisionId);
+		return false;
+	}
+	if (policy !== undefined) {
+		const policyIssue = validateWorkItemAdmissionPolicy(policy, decision, proposal);
+		if (policyIssue !== undefined) {
+			emitWorkItemAdmissionIssue(
+				ctx,
+				state,
+				`${policyIssue.code}:${decision.decisionId}:${policy.policyId}`,
+				policyIssue.code,
+				policyIssue.message,
+				proposal.workItemId,
+				workItemAdmissionDecisionRefs(decision, proposal, policy),
+			);
+			return false;
+		}
+	}
+	const mergeIssue = validateWorkItemAdmissionMergeTarget(state, decision);
+	if (mergeIssue !== undefined) {
+		emitWorkItemAdmissionIssue(
+			ctx,
+			state,
+			`${mergeIssue.code}:${decision.decisionId}:${decision.targetProposalId ?? ""}:${decision.targetAdmissionId ?? ""}`,
+			mergeIssue.code,
+			mergeIssue.message,
+			proposal.workItemId,
+			proposalRefs,
+		);
+		if (mergeIssue.code !== "unknown-work-item-domain-action-admission-merge-target")
+			state.terminalDecisionIds.add(decision.decisionId);
+		return false;
+	}
+	if (state.admissionsById.has(decision.admissionId)) {
+		emitWorkItemAdmissionIssue(
+			ctx,
+			state,
+			`duplicate-admission-id:${decision.admissionId}`,
+			"duplicate-work-item-domain-action-admission",
+			`WorkItemDomainActionAdmission '${decision.admissionId}' was already emitted`,
+			proposal.workItemId,
+			proposalRefs,
+		);
+		state.terminalDecisionIds.add(decision.decisionId);
+		return false;
+	}
+	if (state.admissionsByProposal.has(decision.proposalId)) {
+		emitWorkItemAdmissionIssue(
+			ctx,
+			state,
+			`duplicate-admission-proposal-decision:${decision.proposalId}:${decision.decisionId}`,
+			"duplicate-work-item-domain-action-admission-proposal",
+			`WorkItemDomainActionProposal '${decision.proposalId}' already has an admission decision`,
+			proposal.workItemId,
+			proposalRefs,
+		);
+		state.terminalDecisionIds.add(decision.decisionId);
+		return false;
+	}
+	const admissionState = admissionStateForOutcome(decision.outcome);
+	if (admissionState === undefined) {
+		emitWorkItemAdmissionIssue(
+			ctx,
+			state,
+			`unsupported-admission-outcome:${decision.decisionId}:${String(decision.outcome)}`,
+			"unsupported-work-item-domain-action-admission-outcome",
+			`WorkItemDomainActionAdmissionDecision '${decision.decisionId}' uses unsupported outcome '${String(decision.outcome)}'`,
+			proposal.workItemId,
+			proposalRefs,
+		);
+		state.terminalDecisionIds.add(decision.decisionId);
+		return false;
+	}
+	const admission: WorkItemDomainActionAdmission = {
+		kind: "work-item-domain-action-admission",
+		admissionId: decision.admissionId,
+		proposalId: proposal.proposalId,
+		workItemId: proposal.workItemId,
+		actionKind: proposal.actionKind,
+		state: admissionState,
+		decisionId: decision.decisionId,
+		policyId: decision.policyId,
+		reason: decision.reason,
+		targetProposalId: decision.targetProposalId,
+		targetAdmissionId: decision.targetAdmissionId,
+		sourceRefs: workItemAdmissionDecisionRefs(decision, proposal, policy),
+		admittedAtMs: decision.decidedAtMs ?? admittedAtMs,
+		metadata: {
+			...(proposal.metadata ?? {}),
+			...(policy?.metadata ?? {}),
+			...(decision.metadata ?? {}),
+		},
+	};
+	state.admissionsById.set(admission.admissionId, admission);
+	state.admissionsByProposal.set(admission.proposalId, admission);
+	state.terminalDecisionIds.add(decision.decisionId);
+	state.statusSeq += 1;
+	state.auditSeq += 1;
+	const statusState = workItemAdmissionStatusState(admission.state);
+	const status: WorkItemStatusRecord = {
+		kind: "work-item-status",
+		statusId: `${proposal.workItemId}:${statusState}:${state.statusSeq}`,
+		workItemId: proposal.workItemId,
+		state: statusState,
+		sourceRefs: admission.sourceRefs,
+		effectRunId: proposal.effectRunId,
+		evidenceId: proposal.evidenceId,
+		proposalId: proposal.proposalId,
+		metadata: {
+			actionKind: proposal.actionKind,
+			admissionId: admission.admissionId,
+			decisionId: decision.decisionId,
+			policyId: decision.policyId,
+		},
+	};
+	const audit: AgentRuntimeAuditRecord = {
+		id: `${proposal.workItemId}:${statusState}:${state.auditSeq}`,
+		kind: `work-item-domain-action-${admission.state}`,
+		subjectId: proposal.workItemId,
+		sourceRefs: admission.sourceRefs,
+		metadata: {
+			actionKind: proposal.actionKind,
+			admissionId: admission.admissionId,
+			decisionId: decision.decisionId,
+			policyId: decision.policyId,
+			proposalId: proposal.proposalId,
+		},
+	};
+	ctx.down([
+		["DATA", { kind: "admission", admission } satisfies WorkItemDomainActionAdmissionFact],
+		["DATA", { kind: "status", status } satisfies WorkItemDomainActionAdmissionFact],
+		["DATA", { kind: "audit", audit } satisfies WorkItemDomainActionAdmissionFact],
+	]);
+	return true;
+}
+
+function admissionPolicyForDecision(
+	state: WorkItemDomainActionAdmissionStateInternal,
+	decision: WorkItemDomainActionAdmissionDecision,
+):
+	| WorkItemDomainActionAdmissionPolicy
+	| "missing-work-item-domain-action-admission-policy"
+	| "stale-work-item-domain-action-admission-policy-ref"
+	| undefined {
+	if (decision.policyId === undefined) return undefined;
+	const stalePolicyRef = (decision.sourceRefs ?? []).find(
+		(sourceRef) =>
+			sourceRef.kind === "work-item-domain-action-admission-policy" &&
+			sourceRef.id !== decision.policyId,
+	);
+	if (stalePolicyRef !== undefined) return "stale-work-item-domain-action-admission-policy-ref";
+	return (
+		state.policies.get(decision.policyId) ?? "missing-work-item-domain-action-admission-policy"
+	);
+}
+
+function admissionPolicyIssueMessage(
+	code:
+		| "missing-work-item-domain-action-admission-policy"
+		| "stale-work-item-domain-action-admission-policy-ref",
+	decision: WorkItemDomainActionAdmissionDecision,
+): string {
+	if (code === "missing-work-item-domain-action-admission-policy") {
+		return `WorkItemDomainActionAdmissionPolicy '${decision.policyId}' was referenced for WorkItem action admission but not present`;
+	}
+	return `WorkItemDomainActionAdmissionDecision '${decision.decisionId}' carries a stale admission policy source ref`;
+}
+
+function validateWorkItemAdmissionPolicy(
+	policy: WorkItemDomainActionAdmissionPolicy,
+	decision: WorkItemDomainActionAdmissionDecision,
+	proposal: WorkItemDomainActionProposal,
+): { readonly code: string; readonly message: string } | undefined {
+	if (policy.actionKinds !== undefined && !policy.actionKinds.includes(proposal.actionKind)) {
+		return {
+			code: "work-item-domain-action-admission-policy-mismatch",
+			message: `WorkItemDomainActionAdmissionPolicy '${policy.policyId}' does not apply to actionKind '${proposal.actionKind}'`,
+		};
+	}
+	if (policy.allowedOutcomes !== undefined && !policy.allowedOutcomes.includes(decision.outcome)) {
+		return {
+			code: "unsupported-work-item-domain-action-admission-outcome",
+			message: `WorkItemDomainActionAdmissionPolicy '${policy.policyId}' does not allow outcome '${decision.outcome}'`,
+		};
+	}
+	return undefined;
+}
+
+function validateWorkItemAdmissionMergeTarget(
+	state: WorkItemDomainActionAdmissionStateInternal,
+	decision: WorkItemDomainActionAdmissionDecision,
+): { readonly code: string; readonly message: string } | undefined {
+	const hasTargetProposal = decision.targetProposalId !== undefined;
+	const hasTargetAdmission = decision.targetAdmissionId !== undefined;
+	if (decision.outcome !== "merge") {
+		if (hasTargetProposal || hasTargetAdmission) {
+			return {
+				code: "ambiguous-work-item-domain-action-admission-merge-target",
+				message: `WorkItemDomainActionAdmissionDecision '${decision.decisionId}' carries a merge target for non-merge outcome '${decision.outcome}'`,
+			};
+		}
+		return undefined;
+	}
+	if (hasTargetProposal === hasTargetAdmission) {
+		return {
+			code: "ambiguous-work-item-domain-action-admission-merge-target",
+			message: `WorkItemDomainActionAdmissionDecision '${decision.decisionId}' must reference exactly one merge target`,
+		};
+	}
+	if (decision.targetProposalId === decision.proposalId) {
+		return {
+			code: "ambiguous-work-item-domain-action-admission-merge-target",
+			message: `WorkItemDomainActionAdmissionDecision '${decision.decisionId}' cannot merge a proposal into itself`,
+		};
+	}
+	if (decision.targetProposalId !== undefined && !state.proposals.has(decision.targetProposalId)) {
+		return {
+			code: "unknown-work-item-domain-action-admission-merge-target",
+			message: `WorkItemDomainActionAdmissionDecision '${decision.decisionId}' references unknown target proposal '${decision.targetProposalId}'`,
+		};
+	}
+	if (
+		decision.targetAdmissionId !== undefined &&
+		!state.admissionsById.has(decision.targetAdmissionId)
+	) {
+		return {
+			code: "unknown-work-item-domain-action-admission-merge-target",
+			message: `WorkItemDomainActionAdmissionDecision '${decision.decisionId}' references unknown target admission '${decision.targetAdmissionId}'`,
+		};
+	}
+	return undefined;
+}
+
+function admissionStateForOutcome(
+	outcome: WorkItemDomainActionAdmissionOutcome,
+): WorkItemDomainActionAdmissionState | undefined {
+	if (outcome === "admit") return "admitted";
+	if (outcome === "reject") return "rejected";
+	if (outcome === "defer") return "deferred";
+	if (outcome === "merge") return "merged";
+	return undefined;
+}
+
+function workItemAdmissionStatusState(
+	state: WorkItemDomainActionAdmissionState,
+): WorkItemStatusRecord["state"] {
+	if (state === "admitted") return "domain-action-admitted";
+	if (state === "rejected") return "domain-action-rejected";
+	if (state === "deferred") return "domain-action-deferred";
+	return "domain-action-merged";
+}
diff --git a/packages/ts/src/orchestration/work-item-runtime-effect-run.ts b/packages/ts/src/orchestration/work-item-runtime-effect-run.ts
new file mode 100644
index 00000000..950fa604
--- /dev/null
+++ b/packages/ts/src/orchestration/work-item-runtime-effect-run.ts
@@ -0,0 +1,236 @@
+import { depBatch } from "../ctx/types.js";
+import type { Graph } from "../graph/graph.js";
+import type { Node } from "../node/node.js";
+import { effectRun } from "./agent-runtime.js";
+import {
+	deletePendingWorkItemEffectRequest,
+	emitWorkItemEffectRunIssue,
+	emptyWorkItemEffectRunState,
+	freezeWorkItemEffectRequestViews,
+	projectRuntimeFact,
+	ref,
+	workItemEffectRequestRefs,
+} from "./work-item-runtime-shared.js";
+import type {
+	WorkItemEffectRequested,
+	WorkItemEffectRequestViews,
+	WorkItemEffectRunBundle,
+	WorkItemEffectRunFact,
+	WorkItemEffectRunState,
+	WorkItemEffectRunViewsState,
+	WorkItemSeed,
+} from "./work-item-runtime-types.js";
+
+export function workItemEffectRunProjector(
+	graph: Graph,
+	opts: {
+		readonly name?: string;
+		readonly workItems: Node<WorkItemSeed>;
+		readonly effectRequests: Node<WorkItemEffectRequested>;
+	},
+): WorkItemEffectRunBundle {
+	const name = opts.name ?? "workItemEffectRuns";
+	const runtime = graph.node<WorkItemEffectRunFact>(
+		[opts.workItems, opts.effectRequests],
+		(ctx) => {
+			const state = ctx.state.get<WorkItemEffectRunState>() ?? emptyWorkItemEffectRunState();
+			for (const raw of depBatch(ctx, 0) ?? []) {
+				const workItem = raw as WorkItemSeed;
+				state.workItems.set(workItem.workItemId, workItem);
+			}
+			for (const raw of depBatch(ctx, 1) ?? []) {
+				const request = raw as WorkItemEffectRequested;
+				state.requests.set(request.requestId, request);
+				const requestRefs = workItemEffectRequestRefs(request);
+				state.statusSeq += 1;
+				state.auditSeq += 1;
+				ctx.down([
+					[
+						"DATA",
+						{
+							kind: "status",
+							status: {
+								kind: "work-item-status",
+								statusId: `${request.workItemId}:effect-request-pending:${state.statusSeq}`,
+								workItemId: request.workItemId,
+								effectRunId: request.effectRunId,
+								requestId: request.requestId,
+								state: "effect-request-pending",
+								sourceRefs: requestRefs,
+								metadata: { effectKind: request.effectKind },
+							},
+						} satisfies WorkItemEffectRunFact,
+					],
+					[
+						"DATA",
+						{
+							kind: "audit",
+							audit: {
+								id: `${request.workItemId}:effect-request-pending:${state.auditSeq}`,
+								kind: "work-item-effect-request-pending",
+								subjectId: request.workItemId,
+								sourceRefs: requestRefs,
+								metadata: { effectRunId: request.effectRunId, effectKind: request.effectKind },
+							},
+						} satisfies WorkItemEffectRunFact,
+					],
+				]);
+				const workItem = state.workItems.get(request.workItemId);
+				if (workItem === undefined) {
+					emitWorkItemEffectRunIssue(
+						ctx,
+						state,
+						`unknown-work-item:${request.requestId}`,
+						"unknown-work-item-effect-request",
+						`WorkItemEffectRequested '${request.requestId}' references unknown WorkItem '${request.workItemId}'`,
+						request.workItemId,
+						requestRefs,
+					);
+					continue;
+				}
+				const existingEffectRunId = state.effectRunsByRequest.get(request.requestId);
+				if (existingEffectRunId !== undefined) {
+					emitWorkItemEffectRunIssue(
+						ctx,
+						state,
+						`duplicate-effect-request:${request.requestId}`,
+						"duplicate-work-item-effect-request",
+						`WorkItemEffectRequested '${request.requestId}' was already mapped to EffectRun '${existingEffectRunId}'`,
+						request.workItemId,
+						requestRefs,
+					);
+					continue;
+				}
+				if (state.seededEffectRunIds.has(request.effectRunId)) {
+					emitWorkItemEffectRunIssue(
+						ctx,
+						state,
+						`duplicate-effect-run:${request.effectRunId}:${request.requestId}`,
+						"duplicate-work-item-effect-run",
+						`EffectRun '${request.effectRunId}' was already seeded from another WorkItemEffectRequested fact`,
+						request.workItemId,
+						requestRefs,
+					);
+					continue;
+				}
+				state.effectRunsByRequest.set(request.requestId, request.effectRunId);
+				state.seededEffectRunIds.add(request.effectRunId);
+				const run = effectRun({
+					effectRunId: request.effectRunId,
+					agentRunId: request.agentRunId,
+					subjectRefs: [ref("work-item", request.workItemId)],
+					goal: request.goal,
+					sourceRefs: [
+						ref("work-item", request.workItemId),
+						ref("work-item-effect-request", request.requestId),
+						...(request.sourceRefs ?? []),
+					],
+					policyRefs: request.policyRefs,
+					limits: request.limits,
+					createdBy: request.createdBy,
+					createdAtMs: request.createdAtMs,
+					metadata: {
+						...(request.metadata ?? {}),
+						effectKind: request.effectKind,
+						idempotencyKey: request.idempotencyKey,
+					},
+				});
+				state.statusSeq += 1;
+				state.auditSeq += 1;
+				ctx.down([
+					["DATA", { kind: "effect-run", effectRun: run } satisfies WorkItemEffectRunFact],
+					[
+						"DATA",
+						{
+							kind: "status",
+							status: {
+								kind: "work-item-status",
+								statusId: `${request.workItemId}:effect-run-seeded:${state.statusSeq}`,
+								workItemId: request.workItemId,
+								effectRunId: request.effectRunId,
+								requestId: request.requestId,
+								state: "effect-run-seeded",
+								sourceRefs: run.sourceRefs,
+							},
+						} satisfies WorkItemEffectRunFact,
+					],
+					[
+						"DATA",
+						{
+							kind: "audit",
+							audit: {
+								id: `${request.workItemId}:effect-run-seeded:${state.auditSeq}`,
+								kind: "work-item-effect-run-seeded",
+								subjectId: request.workItemId,
+								sourceRefs: run.sourceRefs,
+								metadata: { effectRunId: request.effectRunId, effectKind: request.effectKind },
+							},
+						} satisfies WorkItemEffectRunFact,
+					],
+				]);
+			}
+			ctx.state.set(state);
+		},
+		{ name: `${name}/runtime`, factory: "workItemEffectRunProjector" },
+	);
+	return {
+		effectRuns: projectRuntimeFact(
+			graph,
+			runtime,
+			`${name}/effectRuns`,
+			"workItemEffectRuns",
+			(fact) => (fact.kind === "effect-run" ? fact.effectRun : undefined),
+		),
+		status: projectRuntimeFact(
+			graph,
+			runtime,
+			`${name}/status`,
+			"workItemEffectRunStatus",
+			(fact) => (fact.kind === "status" ? fact.status : undefined),
+		),
+		issues: projectRuntimeFact(
+			graph,
+			runtime,
+			`${name}/issues`,
+			"workItemEffectRunIssues",
+			(fact) => (fact.kind === "issue" ? fact.issue : undefined),
+		),
+		audit: projectRuntimeFact(graph, runtime, `${name}/audit`, "workItemEffectRunAudit", (fact) =>
+			fact.kind === "audit" ? fact.audit : undefined,
+		),
+		views: graph.node<WorkItemEffectRequestViews>(
+			[opts.effectRequests, runtime],
+			(ctx) => {
+				const state = ctx.state.get<WorkItemEffectRunViewsState>() ?? {
+					pendingEffectRequests: new Map<string, WorkItemEffectRequested>(),
+					settledRequestIds: new Set<string>(),
+					issues: [],
+					audit: [],
+				};
+				for (const raw of depBatch(ctx, 0) ?? []) {
+					const request = raw as WorkItemEffectRequested;
+					if (!state.settledRequestIds.has(request.requestId))
+						state.pendingEffectRequests.set(request.requestId, request);
+				}
+				for (const raw of depBatch(ctx, 1) ?? []) {
+					const fact = raw as WorkItemEffectRunFact;
+					if (fact.kind === "effect-run") {
+						for (const request of state.pendingEffectRequests.values()) {
+							if (request.effectRunId === fact.effectRun.effectRunId) {
+								state.pendingEffectRequests.delete(request.requestId);
+								state.settledRequestIds.add(request.requestId);
+								break;
+							}
+						}
+					} else if (fact.kind === "issue") {
+						deletePendingWorkItemEffectRequest(state, fact.issue.refs);
+						state.issues.push(fact.issue);
+					} else if (fact.kind === "audit") state.audit.push(fact.audit);
+				}
+				ctx.state.set(state);
+				ctx.down([["DATA", freezeWorkItemEffectRequestViews(state)]]);
+			},
+			{ name: `${name}/views`, factory: "workItemEffectRequestViews" },
+		),
+	};
+}
diff --git a/packages/ts/src/orchestration/work-item-runtime-evidence.ts b/packages/ts/src/orchestration/work-item-runtime-evidence.ts
new file mode 100644
index 00000000..140912ae
--- /dev/null
+++ b/packages/ts/src/orchestration/work-item-runtime-evidence.ts
@@ -0,0 +1,682 @@
+import { type Ctx, depBatch } from "../ctx/types.js";
+import type { DataIssue } from "../data/index.js";
+import type { Graph } from "../graph/graph.js";
+import type { Node } from "../node/node.js";
+import type {
+	AgentNeed,
+	AgentOutputEnvelope,
+	AgentRuntimeAuditRecord,
+	EffectRun,
+	EffectRunResult,
+	SourceRef,
+} from "./agent-runtime.js";
+import {
+	boundPublicText,
+	canonicalPublicSourceRefs,
+	cloneGraphVisibleMaterial,
+	oversizedInlineTextKeys,
+	publicMaterialForbiddenKeys,
+	sanitizePublicRecordWithEvidence,
+} from "./agent-runtime-common.js";
+import {
+	deletePendingWorkItemEffectRequest,
+	distinctWorkItemRefs,
+	emitWorkItemEvidenceIssue,
+	emptyWorkItemEvidenceState,
+	forEachPolicyDepBatch,
+	freezeWorkItemEvidenceViews,
+	policyAppliesToRequest,
+	projectRuntimeFact,
+	ref,
+	singleWorkItemRef,
+	uniqueSourceRefs,
+	workItemEffectRequestRefs,
+	workItemResultRefs,
+} from "./work-item-runtime-shared.js";
+import type {
+	WorkItemEffectMappingPolicy,
+	WorkItemEffectRequested,
+	WorkItemEvidenceMapperBundle,
+	WorkItemEvidenceMapperFact,
+	WorkItemEvidenceRecorded,
+	WorkItemEvidenceState,
+	WorkItemEvidenceViews,
+	WorkItemEvidenceViewsState,
+	WorkItemMappingPolicyContext,
+	WorkItemSeed,
+	WorkItemStatusRecord,
+} from "./work-item-runtime-types.js";
+
+const WORK_ITEM_EVIDENCE_INLINE_TEXT_LIMIT_CHARS = 512;
+
+export function workItemEffectResultMapper(
+	graph: Graph,
+	opts: {
+		readonly name?: string;
+		readonly workItems: Node<WorkItemSeed>;
+		readonly effectRuns: Node<EffectRun>;
+		readonly effectRunResults: Node<EffectRunResult>;
+		readonly effectRequests?: Node<WorkItemEffectRequested>;
+		readonly mappingPolicies?: readonly Node<WorkItemEffectMappingPolicy>[];
+		readonly now?: () => number;
+	},
+): WorkItemEvidenceMapperBundle {
+	const name = opts.name ?? "workItemEffectResultMapper";
+	const policyDeps = opts.mappingPolicies ?? [];
+	const deps = [
+		opts.workItems,
+		opts.effectRuns,
+		opts.effectRunResults,
+		...(opts.effectRequests === undefined ? [] : [opts.effectRequests]),
+		...policyDeps,
+	];
+	const effectRequestIndex = 3;
+	const policyStart = effectRequestIndex + (opts.effectRequests === undefined ? 0 : 1);
+	const now = opts.now ?? Date.now;
+	const runtime = graph.node<WorkItemEvidenceMapperFact>(
+		deps,
+		(ctx) => {
+			const state = ctx.state.get<WorkItemEvidenceState>() ?? emptyWorkItemEvidenceState();
+			for (const raw of depBatch(ctx, 0) ?? []) {
+				const workItem = raw as WorkItemSeed;
+				state.workItems.set(workItem.workItemId, workItem);
+			}
+			for (const raw of depBatch(ctx, 1) ?? []) {
+				const run = raw as EffectRun;
+				state.effectRuns.set(run.effectRunId, run);
+				const workItemRef = singleWorkItemRef([
+					...(run.subjectRefs ?? []),
+					...(run.sourceRefs ?? []),
+				]);
+				if (workItemRef !== undefined)
+					state.effectRunWorkItems.set(run.effectRunId, workItemRef.id);
+			}
+			if (opts.effectRequests !== undefined) {
+				for (const raw of depBatch(ctx, effectRequestIndex) ?? []) {
+					const request = raw as WorkItemEffectRequested;
+					state.pendingEffectRequests.set(request.requestId, request);
+					const existing = state.requestsByEffectRun.get(request.effectRunId);
+					if (existing !== undefined && existing.requestId !== request.requestId) {
+						const ambiguous = state.ambiguousRequestsByEffectRun.get(request.effectRunId) ?? [
+							existing,
+						];
+						if (!ambiguous.some((item) => item.requestId === request.requestId))
+							ambiguous.push(request);
+						state.ambiguousRequestsByEffectRun.set(request.effectRunId, ambiguous);
+						emitWorkItemEvidenceIssue(
+							ctx,
+							state,
+							`duplicate-effect-request:${request.effectRunId}:${request.requestId}`,
+							"duplicate-work-item-effect-request",
+							`EffectRun '${request.effectRunId}' has multiple WorkItemEffectRequested facts`,
+							request.workItemId,
+							uniqueSourceRefs(ambiguous.flatMap(workItemEffectRequestRefs)),
+						);
+					} else {
+						state.requestsByEffectRun.set(request.effectRunId, request);
+					}
+				}
+			}
+			forEachPolicyDepBatch(ctx, policyStart, policyDeps.length, (raw) => {
+				const policy = raw as WorkItemEffectMappingPolicy;
+				state.policies.set(policy.policyId, policy);
+			});
+			for (const raw of depBatch(ctx, 2) ?? []) {
+				const result = raw as EffectRunResult;
+				mapEffectRunResultToWorkItemEvidence(ctx, state, result, now());
+			}
+			ctx.state.set(state);
+		},
+		{ name: `${name}/runtime`, factory: "workItemEffectResultMapper" },
+	);
+	return {
+		evidence: projectRuntimeFact(
+			graph,
+			runtime,
+			`${name}/evidence`,
+			"workItemEvidenceRecorded",
+			(fact) => (fact.kind === "evidence" ? fact.evidence : undefined),
+		),
+		status: projectRuntimeFact(
+			graph,
+			runtime,
+			`${name}/status`,
+			"workItemEvidenceStatus",
+			(fact) => (fact.kind === "status" ? fact.status : undefined),
+		),
+		issues: projectRuntimeFact(
+			graph,
+			runtime,
+			`${name}/issues`,
+			"workItemEvidenceIssues",
+			(fact) => (fact.kind === "issue" ? fact.issue : undefined),
+		),
+		audit: projectRuntimeFact(graph, runtime, `${name}/audit`, "workItemEvidenceAudit", (fact) =>
+			fact.kind === "audit" ? fact.audit : undefined,
+		),
+		views: graph.node<WorkItemEvidenceViews>(
+			[...(opts.effectRequests === undefined ? [] : [opts.effectRequests]), runtime],
+			(ctx) => {
+				const state = ctx.state.get<WorkItemEvidenceViewsState>() ?? {
+					evidenceByWorkItem: new Map<string, WorkItemEvidenceRecorded[]>(),
+					latestEvidenceByEffectRun: new Map<string, WorkItemEvidenceRecorded>(),
+					pendingEffectRequests: new Map<string, WorkItemEffectRequested>(),
+					settledEffectRunIds: new Set<string>(),
+					settledRequestIds: new Set<string>(),
+					issues: [],
+					audit: [],
+				};
+				if (opts.effectRequests !== undefined) {
+					for (const raw of depBatch(ctx, 0) ?? []) {
+						const request = raw as WorkItemEffectRequested;
+						if (
+							!state.settledRequestIds.has(request.requestId) &&
+							!state.settledEffectRunIds.has(request.effectRunId)
+						)
+							state.pendingEffectRequests.set(request.requestId, request);
+					}
+				}
+				const runtimeIndex = opts.effectRequests === undefined ? 0 : 1;
+				for (const raw of depBatch(ctx, runtimeIndex) ?? []) {
+					const fact = raw as WorkItemEvidenceMapperFact;
+					if (fact.kind === "evidence") {
+						const evidence = fact.evidence;
+						const byWorkItem = state.evidenceByWorkItem.get(evidence.workItemId) ?? [];
+						byWorkItem.push(evidence);
+						state.evidenceByWorkItem.set(evidence.workItemId, byWorkItem);
+						state.latestEvidenceByEffectRun.set(evidence.effectRunId, evidence);
+						for (const request of state.pendingEffectRequests.values()) {
+							if (request.effectRunId === evidence.effectRunId) {
+								state.pendingEffectRequests.delete(request.requestId);
+								state.settledRequestIds.add(request.requestId);
+							}
+						}
+						state.settledEffectRunIds.add(evidence.effectRunId);
+					} else if (fact.kind === "issue") {
+						deletePendingWorkItemEffectRequest(state, fact.issue.refs);
+						state.issues.push(fact.issue);
+					} else if (fact.kind === "audit") state.audit.push(fact.audit);
+				}
+				ctx.state.set(state);
+				ctx.down([["DATA", freezeWorkItemEvidenceViews(state)]]);
+			},
+			{ name: `${name}/views`, factory: "workItemEvidenceViews" },
+		),
+	};
+}
+
+function mapEffectRunResultToWorkItemEvidence(
+	ctx: Ctx,
+	state: WorkItemEvidenceState,
+	result: EffectRunResult,
+	recordedAtMs: number,
+): void {
+	const run = state.effectRuns.get(result.effectRunId);
+	if (run === undefined) {
+		emitWorkItemEvidenceIssue(
+			ctx,
+			state,
+			`unknown-effect-run:${result.resultId}`,
+			"unknown-effect-run-result",
+			`EffectRunResult '${result.resultId}' references unknown EffectRun '${result.effectRunId}'`,
+			result.effectRunId,
+			result.sourceRefs,
+		);
+		return;
+	}
+	const staleEffectRunRef = (result.sourceRefs ?? []).find(
+		(sourceRef) => sourceRef.kind === "effect-run" && sourceRef.id !== result.effectRunId,
+	);
+	if (staleEffectRunRef !== undefined) {
+		emitWorkItemEvidenceIssue(
+			ctx,
+			state,
+			`stale-effect-run-ref:${result.resultId}`,
+			"stale-effect-run-source-ref",
+			`EffectRunResult '${result.resultId}' carries a stale EffectRun source ref '${staleEffectRunRef.id}'`,
+			result.effectRunId,
+			result.sourceRefs,
+		);
+		return;
+	}
+	const runWorkItemRef = singleWorkItemRef([...(run.subjectRefs ?? []), ...(run.sourceRefs ?? [])]);
+	const resultWorkItemRefs = distinctWorkItemRefs([
+		...(result.subjectRefs ?? []),
+		...(result.sourceRefs ?? []),
+	]);
+	if (resultWorkItemRefs.length > 1) {
+		emitWorkItemEvidenceIssue(
+			ctx,
+			state,
+			`ambiguous-work-item-ref:${result.resultId}`,
+			"stale-work-item-source-ref",
+			`EffectRunResult '${result.resultId}' carries multiple WorkItem refs`,
+			resultWorkItemRefs[0]?.id,
+			workItemResultRefs(result),
+		);
+		return;
+	}
+	const resultWorkItemRef = resultWorkItemRefs[0];
+	if (
+		runWorkItemRef !== undefined &&
+		resultWorkItemRef !== undefined &&
+		runWorkItemRef.id !== resultWorkItemRef.id
+	) {
+		emitWorkItemEvidenceIssue(
+			ctx,
+			state,
+			`stale-work-item-ref:${result.resultId}`,
+			"stale-work-item-source-ref",
+			`EffectRunResult '${result.resultId}' WorkItem ref '${resultWorkItemRef.id}' does not match EffectRun '${result.effectRunId}'`,
+			resultWorkItemRef.id,
+			workItemResultRefs(result),
+		);
+		return;
+	}
+	const workItemId =
+		resultWorkItemRef?.id ?? runWorkItemRef?.id ?? state.effectRunWorkItems.get(result.effectRunId);
+	if (workItemId === undefined) {
+		emitWorkItemEvidenceIssue(
+			ctx,
+			state,
+			`missing-work-item-ref:${result.resultId}`,
+			"missing-work-item-source-ref",
+			`EffectRunResult '${result.resultId}' cannot be mapped without a WorkItem source ref`,
+			result.effectRunId,
+			workItemResultRefs(result),
+		);
+		return;
+	}
+	if (!state.workItems.has(workItemId)) {
+		emitWorkItemEvidenceIssue(
+			ctx,
+			state,
+			`unknown-work-item:${result.resultId}`,
+			"unknown-work-item-evidence-target",
+			`EffectRunResult '${result.resultId}' references unseeded WorkItem '${workItemId}'`,
+			workItemId,
+			workItemResultRefs(result),
+		);
+		return;
+	}
+	const request = state.requestsByEffectRun.get(result.effectRunId);
+	const ambiguousRequests = state.ambiguousRequestsByEffectRun.get(result.effectRunId);
+	if (ambiguousRequests !== undefined) {
+		const refs = uniqueSourceRefs([
+			...workItemResultRefs(result),
+			...ambiguousRequests.flatMap(workItemEffectRequestRefs),
+		]);
+		emitWorkItemEvidenceIssue(
+			ctx,
+			state,
+			`ambiguous-effect-request:${result.effectRunId}:${result.resultId}`,
+			"duplicate-work-item-effect-request",
+			`EffectRun '${result.effectRunId}' has ambiguous WorkItemEffectRequested facts`,
+			workItemId,
+			refs,
+		);
+		clearPendingWorkItemEffectRequestsForRun(state, result.effectRunId);
+		return;
+	}
+	const policyIssue = workItemMappingPolicyIssue(state, request, run);
+	if (policyIssue !== undefined) {
+		emitWorkItemEvidenceIssue(
+			ctx,
+			state,
+			`${policyIssue.code}:${result.resultId}`,
+			policyIssue.code,
+			policyIssue.message,
+			workItemId,
+			workItemMappingPolicyIssueRefs(result, run, request),
+		);
+		clearPendingWorkItemEffectRequestsForRun(state, result.effectRunId);
+		return;
+	}
+	if (state.latestEvidenceByEffectRun.has(result.effectRunId)) {
+		emitWorkItemEvidenceIssue(
+			ctx,
+			state,
+			`duplicate-evidence:${result.effectRunId}:${result.resultId}`,
+			"duplicate-work-item-evidence",
+			`EffectRun '${result.effectRunId}' already recorded WorkItem evidence`,
+			workItemId,
+			workItemResultRefs(result),
+		);
+		return;
+	}
+	const evidence = workItemEvidenceFromResult(result, run, workItemId, request, recordedAtMs);
+	const byWorkItem = state.evidenceByWorkItem.get(workItemId) ?? [];
+	byWorkItem.push(evidence);
+	state.evidenceByWorkItem.set(workItemId, byWorkItem);
+	state.latestEvidenceByEffectRun.set(result.effectRunId, evidence);
+	clearPendingWorkItemEffectRequestsForRun(state, result.effectRunId);
+	state.statusSeq += 1;
+	state.auditSeq += 1;
+	const refs = evidence.sourceRefs;
+	const status: WorkItemStatusRecord = {
+		kind: "work-item-status",
+		statusId: `${workItemId}:evidence-recorded:${state.statusSeq}`,
+		workItemId,
+		state: "evidence-recorded",
+		sourceRefs: refs,
+		effectRunId: result.effectRunId,
+		evidenceId: evidence.evidenceId,
+		issues: result.issues,
+		metadata: { resultStatus: result.status },
+	};
+	const audit: AgentRuntimeAuditRecord = {
+		id: `${workItemId}:evidence-recorded:${state.auditSeq}`,
+		kind: "work-item-evidence-recorded",
+		subjectId: workItemId,
+		sourceRefs: refs,
+		metadata: {
+			effectRunId: result.effectRunId,
+			effectRunResultId: result.resultId,
+			resultStatus: result.status,
+		},
+	};
+	state.audit.push(audit);
+	ctx.down([
+		["DATA", { kind: "evidence", evidence } satisfies WorkItemEvidenceMapperFact],
+		["DATA", { kind: "status", status } satisfies WorkItemEvidenceMapperFact],
+		["DATA", { kind: "audit", audit } satisfies WorkItemEvidenceMapperFact],
+	]);
+}
+
+function workItemEvidenceFromResult(
+	result: EffectRunResult,
+	run: EffectRun,
+	workItemId: string,
+	request: WorkItemEffectRequested | undefined,
+	recordedAtMs: number,
+): WorkItemEvidenceRecorded {
+	const materialIssues: DataIssue[] = [];
+	const base = {
+		kind: "work-item-evidence-recorded",
+		evidenceId: `${workItemId}:${result.effectRunId}:${result.resultId}`,
+		workItemId,
+		requestId: request?.requestId,
+		effectRunId: result.effectRunId,
+		effectRunResultId: result.resultId,
+		executionInputRevision: request?.executionInputRevision,
+		planId: request?.planId,
+		planMemberId: request?.planMemberId,
+		status: result.status,
+		sourceRefs: canonicalPublicSourceRefs(
+			uniqueSourceRefs([
+				ref("work-item", workItemId),
+				ref("effect-run", result.effectRunId),
+				ref("effect-run-result", result.resultId),
+				...(run.sourceRefs ?? []),
+				...(run.subjectRefs ?? []),
+				...(run.policyRefs ?? []),
+				...(result.sourceRefs ?? []),
+				...(result.subjectRefs ?? []),
+			]),
+		),
+		issues: sanitizeEvidenceIssues(result.issues, result, materialIssues),
+		auditRefs: cloneStringArray(result.auditRefs),
+		recordedAtMs,
+		metadata: sanitizeEvidenceMetadata(
+			{
+				...(result.metadata ?? {}),
+				...(request?.requestId === undefined ? {} : { requestId: request.requestId }),
+				...(request?.executionInputRevision === undefined
+					? {}
+					: { executionInputRevision: request.executionInputRevision }),
+				...(request?.planId === undefined ? {} : { planId: request.planId }),
+				...(request?.planMemberId === undefined ? {} : { planMemberId: request.planMemberId }),
+			},
+			result,
+			materialIssues,
+		),
+	} satisfies Omit<WorkItemEvidenceRecorded, "output" | "error" | "needs" | "reason" | "timeoutMs">;
+	const finalize = (
+		evidence: Omit<WorkItemEvidenceRecorded, "issues"> & {
+			readonly issues?: readonly DataIssue[];
+		},
+	): WorkItemEvidenceRecorded => ({
+		...evidence,
+		issues: Object.freeze([...(evidence.issues ?? []), ...materialIssues]),
+	});
+	if (result.status === "completed") {
+		const output = sanitizeEvidenceOutput(result.output, result, materialIssues);
+		return finalize({ ...base, output });
+	}
+	if (result.status === "failed") {
+		const error = sanitizeEvidenceIssue(result.error, result, materialIssues);
+		return finalize({ ...base, error });
+	}
+	if (result.status === "blocked") {
+		const needs = result.needs.map((need) => sanitizeEvidenceNeed(need, result, materialIssues));
+		return {
+			...finalize({ ...base, needs }),
+		};
+	}
+	if (result.status === "timeout") return finalize({ ...base, timeoutMs: result.timeoutMs });
+	if (result.status === "canceled" || result.status === "waived")
+		return finalize({
+			...base,
+			reason: result.reason === undefined ? undefined : boundPublicText(result.reason, 280).text,
+		});
+	return finalize(base);
+}
+
+function sanitizeEvidenceOutput(
+	output: AgentOutputEnvelope,
+	result: EffectRunResult,
+	issues: DataIssue[],
+): AgentOutputEnvelope {
+	const value = sanitizeEvidenceValue(output.value, result, "output.value", issues);
+	const metadata = sanitizeEvidenceMetadata(output.metadata, result, issues);
+	return Object.freeze({
+		kind: output.kind,
+		value,
+		refs: output.refs === undefined ? undefined : canonicalPublicSourceRefs(output.refs),
+		summary: output.summary === undefined ? undefined : boundPublicText(output.summary, 280).text,
+		metadata,
+	} satisfies AgentOutputEnvelope);
+}
+
+function sanitizeEvidenceNeed(
+	need: AgentNeed,
+	result: EffectRunResult,
+	issues: DataIssue[],
+): AgentNeed {
+	return Object.freeze({
+		kind: need.kind,
+		message: need.message === undefined ? undefined : boundPublicText(need.message, 280).text,
+		refs: need.refs === undefined ? undefined : canonicalPublicSourceRefs(need.refs),
+		metadata: sanitizeEvidenceMetadata(need.metadata, result, issues),
+	} satisfies AgentNeed);
+}
+
+function sanitizeEvidenceIssues(
+	input: readonly DataIssue[] | undefined,
+	result: EffectRunResult,
+	issues: DataIssue[],
+): readonly DataIssue[] | undefined {
+	if (input === undefined) return undefined;
+	return Object.freeze(input.map((issue) => sanitizeEvidenceIssue(issue, result, issues)));
+}
+
+function sanitizeEvidenceIssue(
+	issue: DataIssue,
+	result: EffectRunResult,
+	issues: DataIssue[],
+): DataIssue {
+	return Object.freeze({
+		kind: "issue",
+		code: issue.code,
+		message: boundPublicText(issue.message, 280).text,
+		severity: issue.severity,
+		source: issue.source,
+		subjectId: issue.subjectId,
+		correlationId: issue.correlationId,
+		causationId: issue.causationId,
+		path: clonePathArray(issue.path),
+		refs: cloneStringArray(issue.refs),
+		retryable: issue.retryable,
+		details: sanitizeEvidenceValue(issue.details, result, "issue.details", issues),
+		metadata: sanitizeEvidenceMetadata(issue.metadata, result, issues),
+	} satisfies DataIssue);
+}
+
+function sanitizeEvidenceMetadata(
+	metadata: Record<string, unknown> | undefined,
+	result: EffectRunResult,
+	issues: DataIssue[],
+): Record<string, unknown> | undefined {
+	if (metadata === undefined) return undefined;
+	const sanitized = sanitizePublicRecordWithEvidence(metadata, { mode: "provider" });
+	if (sanitized === undefined) {
+		issues.push(redactedEvidenceMaterialIssue(result, "metadata", "forbidden-runtime-material"));
+		return undefined;
+	}
+	for (const entry of sanitized.truncated) {
+		issues.push(
+			redactedEvidenceMaterialIssue(result, `metadata.${entry.path.join(".")}`, "text-truncated"),
+		);
+	}
+	return Object.freeze(sanitized.value);
+}
+
+function sanitizeEvidenceValue(
+	value: unknown,
+	result: EffectRunResult,
+	area: string,
+	issues: DataIssue[],
+): unknown {
+	if (value === undefined) return undefined;
+	const forbidden = [
+		...publicMaterialForbiddenKeys(value, "provider"),
+		...oversizedInlineTextKeys(value, WORK_ITEM_EVIDENCE_INLINE_TEXT_LIMIT_CHARS),
+	];
+	if (forbidden.length > 0) {
+		const entry = forbidden[0];
+		issues.push(
+			redactedEvidenceMaterialIssue(
+				result,
+				formatEvidenceMaterialArea(area, entry?.path ?? []),
+				entry?.reason ?? "forbidden",
+			),
+		);
+		return undefined;
+	}
+	return cloneGraphVisibleMaterial(value);
+}
+
+function cloneStringArray(input: readonly string[] | undefined): readonly string[] | undefined {
+	if (input === undefined) return undefined;
+	return Object.freeze([...input]);
+}
+
+function clonePathArray(
+	input: readonly (string | number)[] | undefined,
+): readonly (string | number)[] | undefined {
+	if (input === undefined) return undefined;
+	return Object.freeze([...input]);
+}
+
+function formatEvidenceMaterialArea(area: string, path: readonly (string | number)[]): string {
+	if (path.length === 0) return area;
+	return `${area}.${path.map((entry) => String(entry)).join(".")}`;
+}
+
+function redactedEvidenceMaterialIssue(
+	result: EffectRunResult,
+	area: string,
+	reason: string,
+): DataIssue {
+	return Object.freeze({
+		kind: "issue",
+		code: "work-item-evidence-public-material-redacted",
+		message:
+			"WorkItem evidence material was omitted because it was not bounded public graph material.",
+		severity: "warning",
+		subjectId: result.effectRunId,
+		refs: [`effect-run-result:${result.resultId}`],
+		details: { area, reason },
+	} satisfies DataIssue);
+}
+
+function workItemMappingPolicyIssue(
+	state: WorkItemEvidenceState,
+	request: WorkItemEffectRequested | undefined,
+	run: EffectRun,
+): { readonly code: string; readonly message: string } | undefined {
+	const context = workItemMappingPolicyContext(request, run);
+	const referencedPolicyIds = context.policyRefs
+		.filter((sourceRef) => sourceRef.kind === "work-item-effect-mapping-policy")
+		.map((sourceRef) => sourceRef.id);
+	for (const policyId of referencedPolicyIds) {
+		const policy = state.policies.get(policyId);
+		if (policy === undefined) {
+			return {
+				code: "missing-work-item-effect-mapping-policy",
+				message: `WorkItemEffectMappingPolicy '${policyId}' was required but not present`,
+			};
+		}
+		const issue = validateWorkItemMappingPolicy(policy, context.effectKind);
+		if (issue !== undefined) return issue;
+	}
+	return undefined;
+}
+
+function validateWorkItemMappingPolicy(
+	policy: WorkItemEffectMappingPolicy,
+	effectKind: string | undefined,
+): { readonly code: string; readonly message: string } | undefined {
+	if (!policyAppliesToRequest(policy, effectKind)) {
+		return {
+			code: "work-item-effect-mapping-policy-mismatch",
+			message: `WorkItemEffectMappingPolicy '${policy.policyId}' does not apply to effectKind '${effectKind ?? "unknown"}'`,
+		};
+	}
+	const behavior = policy.evidence?.behavior ?? "record";
+	if (behavior !== "record") {
+		return {
+			code: "unsupported-work-item-evidence-behavior",
+			message: `WorkItemEffectMappingPolicy '${policy.policyId}' uses unsupported evidence behavior '${behavior}'`,
+		};
+	}
+	return undefined;
+}
+
+function workItemMappingPolicyContext(
+	request: WorkItemEffectRequested | undefined,
+	run: EffectRun,
+): WorkItemMappingPolicyContext {
+	return {
+		policyRefs: request?.policyRefs ?? run.policyRefs ?? [],
+		effectKind: request?.effectKind ?? effectKindFromRun(run),
+	};
+}
+
+function effectKindFromRun(run: EffectRun): string | undefined {
+	const effectKind = run.metadata?.effectKind;
+	return typeof effectKind === "string" ? effectKind : undefined;
+}
+
+function workItemMappingPolicyIssueRefs(
+	result: EffectRunResult,
+	run: EffectRun,
+	request: WorkItemEffectRequested | undefined,
+): readonly SourceRef[] {
+	return uniqueSourceRefs([
+		...workItemResultRefs(result),
+		...(request === undefined
+			? [...(run.sourceRefs ?? []), ...(run.subjectRefs ?? []), ...(run.policyRefs ?? [])]
+			: workItemEffectRequestRefs(request)),
+	]);
+}
+
+function clearPendingWorkItemEffectRequestsForRun(
+	state: Pick<WorkItemEvidenceState, "pendingEffectRequests">,
+	effectRunId: string,
+): void {
+	for (const pendingRequest of state.pendingEffectRequests.values()) {
+		if (pendingRequest.effectRunId === effectRunId)
+			state.pendingEffectRequests.delete(pendingRequest.requestId);
+	}
+}
diff --git a/packages/ts/src/orchestration/work-item-runtime-proposal.ts b/packages/ts/src/orchestration/work-item-runtime-proposal.ts
new file mode 100644
index 00000000..8a4e20d8
--- /dev/null
+++ b/packages/ts/src/orchestration/work-item-runtime-proposal.ts
@@ -0,0 +1,342 @@
+import { type Ctx, depBatch } from "../ctx/types.js";
+import type { Graph } from "../graph/graph.js";
+import type { Node } from "../node/node.js";
+import type { AgentRuntimeAuditRecord, EffectRunResult } from "./agent-runtime.js";
+import {
+	effectKindFromMetadata,
+	emitWorkItemActionProposalIssue,
+	emptyWorkItemDomainActionProposalState,
+	forEachPolicyDepBatch,
+	freezeWorkItemDomainActionProposalViews,
+	policyAppliesToRequest,
+	projectRuntimeFact,
+	referencedWorkItemMappingPolicyIds,
+	resultReason,
+	workItemActionProposalPayload,
+	workItemActionProposalRefs,
+	workItemEvidenceOnlyRefs,
+	workItemIdForEffectRunResult,
+	workItemResultRefs,
+} from "./work-item-runtime-shared.js";
+import type {
+	WorkItemDomainActionProposal,
+	WorkItemDomainActionProposalBundle,
+	WorkItemDomainActionProposalFact,
+	WorkItemDomainActionProposalSpec,
+	WorkItemDomainActionProposalState,
+	WorkItemDomainActionProposalViews,
+	WorkItemDomainActionProposalViewsState,
+	WorkItemEffectMappingPolicy,
+	WorkItemEvidenceRecorded,
+	WorkItemSeed,
+	WorkItemStatusRecord,
+} from "./work-item-runtime-types.js";
+
+export function workItemDomainActionProposalProjector(
+	graph: Graph,
+	opts: {
+		readonly name?: string;
+		readonly workItems: Node<WorkItemSeed>;
+		readonly evidence: Node<WorkItemEvidenceRecorded>;
+		readonly effectRunResults: Node<EffectRunResult>;
+		readonly mappingPolicies: readonly Node<WorkItemEffectMappingPolicy>[];
+		readonly now?: () => number;
+	},
+): WorkItemDomainActionProposalBundle {
+	const name = opts.name ?? "workItemDomainActionProposals";
+	const now = opts.now ?? Date.now;
+	const policyStart = 3;
+	const runtime = graph.node<WorkItemDomainActionProposalFact>(
+		[opts.workItems, opts.evidence, opts.effectRunResults, ...opts.mappingPolicies],
+		(ctx) => {
+			const state =
+				ctx.state.get<WorkItemDomainActionProposalState>() ??
+				emptyWorkItemDomainActionProposalState();
+			for (const raw of depBatch(ctx, 0) ?? []) {
+				const workItem = raw as WorkItemSeed;
+				state.workItems.set(workItem.workItemId, workItem);
+			}
+			for (const raw of depBatch(ctx, 1) ?? []) {
+				const evidence = raw as WorkItemEvidenceRecorded;
+				if (state.evidence.has(evidence.evidenceId)) {
+					emitWorkItemActionProposalIssue(
+						ctx,
+						state,
+						`duplicate-action-proposal-evidence:${evidence.evidenceId}`,
+						"duplicate-work-item-action-proposal-evidence",
+						`WorkItemEvidenceRecorded '${evidence.evidenceId}' was already seen by the action proposal projector`,
+						evidence.workItemId,
+						workItemEvidenceOnlyRefs(evidence),
+					);
+					continue;
+				}
+				state.evidence.set(evidence.evidenceId, evidence);
+			}
+			for (const raw of depBatch(ctx, 2) ?? []) {
+				const result = raw as EffectRunResult;
+				if (state.results.has(result.resultId)) {
+					emitWorkItemActionProposalIssue(
+						ctx,
+						state,
+						`duplicate-action-proposal-result:${result.resultId}`,
+						"duplicate-work-item-action-proposal-result",
+						`EffectRunResult '${result.resultId}' was already seen by the action proposal projector`,
+						workItemIdForEffectRunResult(state, result),
+						workItemResultRefs(result),
+					);
+					continue;
+				}
+				state.results.set(result.resultId, result);
+			}
+			forEachPolicyDepBatch(ctx, policyStart, opts.mappingPolicies.length, (raw) => {
+				const policy = raw as WorkItemEffectMappingPolicy;
+				state.policies.set(policy.policyId, policy);
+			});
+			evaluateWorkItemDomainActionProposals(ctx, state, now());
+			ctx.state.set(state);
+		},
+		{ name: `${name}/runtime`, factory: "workItemDomainActionProposalProjector", partial: true },
+	);
+	return {
+		proposals: projectRuntimeFact(
+			graph,
+			runtime,
+			`${name}/proposals`,
+			"workItemDomainActionProposals",
+			(fact) => (fact.kind === "proposal" ? fact.proposal : undefined),
+		),
+		status: projectRuntimeFact(
+			graph,
+			runtime,
+			`${name}/status`,
+			"workItemDomainActionProposalStatus",
+			(fact) => (fact.kind === "status" ? fact.status : undefined),
+		),
+		issues: projectRuntimeFact(
+			graph,
+			runtime,
+			`${name}/issues`,
+			"workItemDomainActionProposalIssues",
+			(fact) => (fact.kind === "issue" ? fact.issue : undefined),
+		),
+		audit: projectRuntimeFact(
+			graph,
+			runtime,
+			`${name}/audit`,
+			"workItemDomainActionProposalAudit",
+			(fact) => (fact.kind === "audit" ? fact.audit : undefined),
+		),
+		views: graph.node<WorkItemDomainActionProposalViews>(
+			[runtime],
+			(ctx) => {
+				const state = ctx.state.get<WorkItemDomainActionProposalViewsState>() ?? {
+					proposalsByWorkItem: new Map<string, WorkItemDomainActionProposal[]>(),
+					proposalsByEvidence: new Map<string, WorkItemDomainActionProposal[]>(),
+					issues: [],
+					audit: [],
+				};
+				for (const raw of depBatch(ctx, 0) ?? []) {
+					const fact = raw as WorkItemDomainActionProposalFact;
+					if (fact.kind === "proposal") {
+						const proposal = fact.proposal;
+						const byWorkItem = state.proposalsByWorkItem.get(proposal.workItemId) ?? [];
+						byWorkItem.push(proposal);
+						state.proposalsByWorkItem.set(proposal.workItemId, byWorkItem);
+						const byEvidence = state.proposalsByEvidence.get(proposal.evidenceId) ?? [];
+						byEvidence.push(proposal);
+						state.proposalsByEvidence.set(proposal.evidenceId, byEvidence);
+					} else if (fact.kind === "issue") state.issues.push(fact.issue);
+					else if (fact.kind === "audit") state.audit.push(fact.audit);
+				}
+				ctx.state.set(state);
+				ctx.down([["DATA", freezeWorkItemDomainActionProposalViews(state)]]);
+			},
+			{ name: `${name}/views`, factory: "workItemDomainActionProposalViews" },
+		),
+	};
+}
+
+function evaluateWorkItemDomainActionProposals(
+	ctx: Ctx,
+	state: WorkItemDomainActionProposalState,
+	proposedAtMs: number,
+): void {
+	for (const evidence of state.evidence.values()) {
+		const result = state.results.get(evidence.effectRunResultId);
+		if (result === undefined) {
+			emitWorkItemActionProposalIssue(
+				ctx,
+				state,
+				`missing-action-proposal-result:${evidence.evidenceId}:${evidence.effectRunResultId}`,
+				"missing-work-item-action-proposal-result",
+				`WorkItemEvidenceRecorded '${evidence.evidenceId}' references missing EffectRunResult '${evidence.effectRunResultId}'`,
+				evidence.workItemId,
+				workItemEvidenceOnlyRefs(evidence),
+			);
+			continue;
+		}
+		if (result.effectRunId !== evidence.effectRunId || result.status !== evidence.status) {
+			emitWorkItemActionProposalIssue(
+				ctx,
+				state,
+				`stale-action-proposal-result:${evidence.evidenceId}:${result.resultId}`,
+				"stale-work-item-action-proposal-result",
+				`WorkItemEvidenceRecorded '${evidence.evidenceId}' does not match EffectRunResult '${result.resultId}'`,
+				evidence.workItemId,
+				workItemActionProposalRefs(evidence, result),
+			);
+			continue;
+		}
+		if (!state.workItems.has(evidence.workItemId)) {
+			emitWorkItemActionProposalIssue(
+				ctx,
+				state,
+				`unknown-action-proposal-work-item:${evidence.evidenceId}`,
+				"unknown-work-item-action-proposal-target",
+				`WorkItemEvidenceRecorded '${evidence.evidenceId}' references unseeded WorkItem '${evidence.workItemId}'`,
+				evidence.workItemId,
+				workItemActionProposalRefs(evidence, result),
+			);
+			continue;
+		}
+		const policyIds = referencedWorkItemMappingPolicyIds(evidence);
+		for (const policyId of policyIds) {
+			const policy = state.policies.get(policyId);
+			if (policy === undefined) {
+				emitWorkItemActionProposalIssue(
+					ctx,
+					state,
+					`missing-action-proposal-policy:${evidence.evidenceId}:${policyId}`,
+					"missing-work-item-action-proposal-policy",
+					`WorkItemEffectMappingPolicy '${policyId}' was referenced for WorkItem action proposals but not present`,
+					evidence.workItemId,
+					workItemActionProposalRefs(evidence, result),
+				);
+				continue;
+			}
+			const effectKind =
+				effectKindFromMetadata(evidence.metadata) ?? effectKindFromMetadata(result.metadata);
+			if (!policyAppliesToRequest(policy, effectKind)) {
+				emitWorkItemActionProposalIssue(
+					ctx,
+					state,
+					`action-proposal-policy-mismatch:${evidence.evidenceId}:${policy.policyId}`,
+					"work-item-action-proposal-policy-mismatch",
+					`WorkItemEffectMappingPolicy '${policy.policyId}' does not apply to effectKind '${effectKind ?? "unknown"}'`,
+					evidence.workItemId,
+					workItemActionProposalRefs(evidence, result, policy),
+				);
+				continue;
+			}
+			for (const [index, spec] of (policy.actionProposals ?? []).entries()) {
+				emitWorkItemDomainActionProposal(
+					ctx,
+					state,
+					evidence,
+					result,
+					policy,
+					spec,
+					index,
+					proposedAtMs,
+				);
+			}
+		}
+	}
+}
+
+function emitWorkItemDomainActionProposal(
+	ctx: Ctx,
+	state: WorkItemDomainActionProposalState,
+	evidence: WorkItemEvidenceRecorded,
+	result: EffectRunResult,
+	policy: WorkItemEffectMappingPolicy,
+	spec: WorkItemDomainActionProposalSpec,
+	index: number,
+	proposedAtMs: number,
+): void {
+	const key = `${evidence.evidenceId}:${policy.policyId}:${index}:${spec.actionKind}`;
+	if (state.proposedKeys.has(key)) return;
+	if (spec.behavior !== undefined && spec.behavior !== "propose") {
+		emitWorkItemActionProposalIssue(
+			ctx,
+			state,
+			`unsupported-action-proposal-behavior:${key}`,
+			"unsupported-work-item-action-proposal-behavior",
+			`WorkItemEffectMappingPolicy '${policy.policyId}' uses unsupported action proposal behavior '${spec.behavior}'`,
+			evidence.workItemId,
+			workItemActionProposalRefs(evidence, result, policy),
+		);
+		return;
+	}
+	if (spec.actionKind.length === 0) {
+		emitWorkItemActionProposalIssue(
+			ctx,
+			state,
+			`malformed-action-proposal:${key}`,
+			"malformed-work-item-action-proposal",
+			`WorkItemEffectMappingPolicy '${policy.policyId}' has an empty actionKind`,
+			evidence.workItemId,
+			workItemActionProposalRefs(evidence, result, policy),
+		);
+		return;
+	}
+	if (spec.statuses !== undefined && !spec.statuses.includes(evidence.status)) return;
+	const outputKind = evidence.output?.kind;
+	if (
+		spec.outputKinds !== undefined &&
+		(outputKind === undefined || !spec.outputKinds.includes(outputKind))
+	)
+		return;
+	state.proposedKeys.add(key);
+	state.statusSeq += 1;
+	state.auditSeq += 1;
+	const proposal: WorkItemDomainActionProposal = {
+		kind: "work-item-domain-action-proposal",
+		proposalId: `${evidence.workItemId}:${evidence.effectRunId}:${evidence.effectRunResultId}:${policy.policyId}:${index}:${spec.actionKind}`,
+		workItemId: evidence.workItemId,
+		actionKind: spec.actionKind,
+		effectRunId: evidence.effectRunId,
+		effectRunResultId: evidence.effectRunResultId,
+		evidenceId: evidence.evidenceId,
+		policyId: policy.policyId,
+		payload: workItemActionProposalPayload(spec, evidence, result),
+		reason: spec.reason ?? evidence.reason ?? resultReason(result),
+		sourceRefs: workItemActionProposalRefs(evidence, result, policy),
+		proposedAtMs,
+		metadata: {
+			...(policy.metadata ?? {}),
+			...(spec.metadata ?? {}),
+			resultStatus: evidence.status,
+		},
+	};
+	const status: WorkItemStatusRecord = {
+		kind: "work-item-status",
+		statusId: `${evidence.workItemId}:domain-action-proposed:${state.statusSeq}`,
+		workItemId: evidence.workItemId,
+		state: "domain-action-proposed",
+		sourceRefs: proposal.sourceRefs,
+		effectRunId: evidence.effectRunId,
+		evidenceId: evidence.evidenceId,
+		proposalId: proposal.proposalId,
+		metadata: { actionKind: spec.actionKind, policyId: policy.policyId },
+	};
+	const audit: AgentRuntimeAuditRecord = {
+		id: `${evidence.workItemId}:domain-action-proposed:${state.auditSeq}`,
+		kind: "work-item-domain-action-proposed",
+		subjectId: evidence.workItemId,
+		sourceRefs: proposal.sourceRefs,
+		metadata: {
+			actionKind: spec.actionKind,
+			effectRunId: evidence.effectRunId,
+			effectRunResultId: evidence.effectRunResultId,
+			evidenceId: evidence.evidenceId,
+			policyId: policy.policyId,
+			proposalId: proposal.proposalId,
+		},
+	};
+	ctx.down([
+		["DATA", { kind: "proposal", proposal } satisfies WorkItemDomainActionProposalFact],
+		["DATA", { kind: "status", status } satisfies WorkItemDomainActionProposalFact],
+		["DATA", { kind: "audit", audit } satisfies WorkItemDomainActionProposalFact],
+	]);
+}
diff --git a/packages/ts/src/orchestration/work-item-runtime-shared.ts b/packages/ts/src/orchestration/work-item-runtime-shared.ts
new file mode 100644
index 00000000..079558aa
--- /dev/null
+++ b/packages/ts/src/orchestration/work-item-runtime-shared.ts
@@ -0,0 +1,552 @@
+import { type Ctx, depBatch } from "../ctx/types.js";
+import type { DataIssue } from "../data/index.js";
+import type { Graph } from "../graph/graph.js";
+import type { Node } from "../node/node.js";
+import type { AgentRuntimeAuditRecord, EffectRunResult, SourceRef } from "./agent-runtime.js";
+import type {
+	WorkItemDomainActionAdmission,
+	WorkItemDomainActionAdmissionDecision,
+	WorkItemDomainActionAdmissionFact,
+	WorkItemDomainActionAdmissionPolicy,
+	WorkItemDomainActionAdmissionStateInternal,
+	WorkItemDomainActionAdmissionViews,
+	WorkItemDomainActionAdmissionViewsState,
+	WorkItemDomainActionProposal,
+	WorkItemDomainActionProposalFact,
+	WorkItemDomainActionProposalSpec,
+	WorkItemDomainActionProposalState,
+	WorkItemDomainActionProposalViews,
+	WorkItemDomainActionProposalViewsState,
+	WorkItemEffectMappingPolicy,
+	WorkItemEffectRequested,
+	WorkItemEffectRequestViews,
+	WorkItemEffectRunFact,
+	WorkItemEffectRunState,
+	WorkItemEffectRunViewsState,
+	WorkItemEvidenceMapperFact,
+	WorkItemEvidenceRecorded,
+	WorkItemEvidenceState,
+	WorkItemEvidenceViews,
+	WorkItemEvidenceViewsState,
+	WorkItemSeed,
+	WorkItemStatusRecord,
+} from "./work-item-runtime-types.js";
+
+export function policyAppliesToRequest(
+	policy: WorkItemEffectMappingPolicy,
+	effectKind: string | undefined,
+): boolean {
+	return (
+		policy.effectKinds === undefined ||
+		(effectKind !== undefined && policy.effectKinds.includes(effectKind))
+	);
+}
+
+export function emitWorkItemEffectRunIssue(
+	ctx: Ctx,
+	state: WorkItemEffectRunState,
+	key: string,
+	code: string,
+	message: string,
+	subjectId?: string,
+	sourceRefs?: readonly SourceRef[],
+): void {
+	if (state.issueKeys.has(key)) return;
+	state.issueKeys.add(key);
+	state.issueSeq += 1;
+	state.statusSeq += 1;
+	state.auditSeq += 1;
+	const issue = dataIssue(code, message, { subjectId, refs: sourceRefs });
+	const status: WorkItemStatusRecord = {
+		kind: "work-item-status",
+		statusId: `${subjectId ?? "work-item"}:mapping-issue:${state.statusSeq}`,
+		workItemId: subjectId ?? "unknown",
+		state: "mapping-issue",
+		sourceRefs,
+		issues: [issue],
+	};
+	const audit: AgentRuntimeAuditRecord = {
+		id: `${subjectId ?? "work-item"}:${code}:${state.auditSeq}`,
+		kind: "work-item-effect-run-issue",
+		subjectId,
+		issueCode: code,
+		message,
+		sourceRefs,
+	};
+	state.issues.push(issue);
+	state.audit.push(audit);
+	ctx.down([
+		["DATA", { kind: "issue", issue } satisfies WorkItemEffectRunFact],
+		["DATA", { kind: "status", status } satisfies WorkItemEffectRunFact],
+		["DATA", { kind: "audit", audit } satisfies WorkItemEffectRunFact],
+	]);
+}
+
+export function emitWorkItemEvidenceIssue(
+	ctx: Ctx,
+	state: WorkItemEvidenceState,
+	key: string,
+	code: string,
+	message: string,
+	subjectId?: string,
+	sourceRefs?: readonly SourceRef[],
+): void {
+	if (state.issueKeys.has(key)) return;
+	state.issueKeys.add(key);
+	state.issueSeq += 1;
+	state.statusSeq += 1;
+	state.auditSeq += 1;
+	const issue = dataIssue(code, message, { subjectId, refs: sourceRefs });
+	const status: WorkItemStatusRecord = {
+		kind: "work-item-status",
+		statusId: `${subjectId ?? "work-item"}:mapping-issue:${state.statusSeq}`,
+		workItemId: subjectId ?? "unknown",
+		state: "mapping-issue",
+		sourceRefs,
+		issues: [issue],
+	};
+	const audit: AgentRuntimeAuditRecord = {
+		id: `${subjectId ?? "work-item"}:${code}:${state.auditSeq}`,
+		kind: "work-item-evidence-mapping-issue",
+		subjectId,
+		issueCode: code,
+		message,
+		sourceRefs,
+	};
+	state.issues.push(issue);
+	state.audit.push(audit);
+	ctx.down([
+		["DATA", { kind: "issue", issue } satisfies WorkItemEvidenceMapperFact],
+		["DATA", { kind: "status", status } satisfies WorkItemEvidenceMapperFact],
+		["DATA", { kind: "audit", audit } satisfies WorkItemEvidenceMapperFact],
+	]);
+}
+
+export function emitWorkItemActionProposalIssue(
+	ctx: Ctx,
+	state: WorkItemDomainActionProposalState,
+	key: string,
+	code: string,
+	message: string,
+	subjectId?: string,
+	sourceRefs?: readonly SourceRef[],
+): void {
+	if (state.issueKeys.has(key)) return;
+	state.issueKeys.add(key);
+	state.issueSeq += 1;
+	state.statusSeq += 1;
+	state.auditSeq += 1;
+	const issue = dataIssue(code, message, { subjectId, refs: sourceRefs });
+	const status: WorkItemStatusRecord = {
+		kind: "work-item-status",
+		statusId: `${subjectId ?? "work-item"}:mapping-issue:${state.statusSeq}`,
+		workItemId: subjectId ?? "unknown",
+		state: "mapping-issue",
+		sourceRefs,
+		issues: [issue],
+	};
+	const audit: AgentRuntimeAuditRecord = {
+		id: `${subjectId ?? "work-item"}:${code}:${state.auditSeq}`,
+		kind: "work-item-action-proposal-issue",
+		subjectId,
+		issueCode: code,
+		message,
+		sourceRefs,
+	};
+	ctx.down([
+		["DATA", { kind: "issue", issue } satisfies WorkItemDomainActionProposalFact],
+		["DATA", { kind: "status", status } satisfies WorkItemDomainActionProposalFact],
+		["DATA", { kind: "audit", audit } satisfies WorkItemDomainActionProposalFact],
+	]);
+}
+
+export function emitWorkItemAdmissionIssue(
+	ctx: Ctx,
+	state: WorkItemDomainActionAdmissionStateInternal,
+	key: string,
+	code: string,
+	message: string,
+	subjectId?: string,
+	sourceRefs?: readonly SourceRef[],
+): void {
+	if (state.issueKeys.has(key)) return;
+	state.issueKeys.add(key);
+	state.issueSeq += 1;
+	state.statusSeq += 1;
+	state.auditSeq += 1;
+	const issue = dataIssue(code, message, { subjectId, refs: sourceRefs });
+	const status: WorkItemStatusRecord = {
+		kind: "work-item-status",
+		statusId: `${subjectId ?? "work-item"}:mapping-issue:${state.statusSeq}`,
+		workItemId: subjectId ?? "unknown",
+		state: "mapping-issue",
+		sourceRefs,
+		issues: [issue],
+	};
+	const audit: AgentRuntimeAuditRecord = {
+		id: `${subjectId ?? "work-item"}:${code}:${state.auditSeq}`,
+		kind: "work-item-domain-action-admission-issue",
+		subjectId,
+		issueCode: code,
+		message,
+		sourceRefs,
+	};
+	ctx.down([
+		["DATA", { kind: "issue", issue } satisfies WorkItemDomainActionAdmissionFact],
+		["DATA", { kind: "status", status } satisfies WorkItemDomainActionAdmissionFact],
+		["DATA", { kind: "audit", audit } satisfies WorkItemDomainActionAdmissionFact],
+	]);
+}
+
+export function emptyWorkItemEffectRunState(): WorkItemEffectRunState {
+	return {
+		workItems: new Map<string, WorkItemSeed>(),
+		requests: new Map<string, WorkItemEffectRequested>(),
+		effectRunsByRequest: new Map<string, string>(),
+		seededEffectRunIds: new Set<string>(),
+		issues: [],
+		audit: [],
+		issueKeys: new Set<string>(),
+		statusSeq: 0,
+		issueSeq: 0,
+		auditSeq: 0,
+	};
+}
+
+export function emptyWorkItemEvidenceState(): WorkItemEvidenceState {
+	return {
+		workItems: new Map<string, WorkItemSeed>(),
+		effectRuns: new Map<string, EffectRun>(),
+		effectRunWorkItems: new Map<string, string>(),
+		evidenceByWorkItem: new Map<string, WorkItemEvidenceRecorded[]>(),
+		latestEvidenceByEffectRun: new Map<string, WorkItemEvidenceRecorded>(),
+		pendingEffectRequests: new Map<string, WorkItemEffectRequested>(),
+		requestsByEffectRun: new Map<string, WorkItemEffectRequested>(),
+		ambiguousRequestsByEffectRun: new Map<string, WorkItemEffectRequested[]>(),
+		policies: new Map<string, WorkItemEffectMappingPolicy>(),
+		issues: [],
+		audit: [],
+		issueKeys: new Set<string>(),
+		statusSeq: 0,
+		issueSeq: 0,
+		auditSeq: 0,
+	};
+}
+
+export function emptyWorkItemDomainActionProposalState(): WorkItemDomainActionProposalState {
+	return {
+		workItems: new Map<string, WorkItemSeed>(),
+		evidence: new Map<string, WorkItemEvidenceRecorded>(),
+		results: new Map<string, EffectRunResult>(),
+		policies: new Map<string, WorkItemEffectMappingPolicy>(),
+		proposedKeys: new Set<string>(),
+		issueKeys: new Set<string>(),
+		statusSeq: 0,
+		issueSeq: 0,
+		auditSeq: 0,
+	};
+}
+
+export function emptyWorkItemDomainActionAdmissionState(): WorkItemDomainActionAdmissionStateInternal {
+	return {
+		proposals: new Map<string, WorkItemDomainActionProposal>(),
+		policies: new Map<string, WorkItemDomainActionAdmissionPolicy>(),
+		decisions: new Map<string, WorkItemDomainActionAdmissionDecision>(),
+		admissionsById: new Map<string, WorkItemDomainActionAdmission>(),
+		admissionsByProposal: new Map<string, WorkItemDomainActionAdmission>(),
+		terminalDecisionIds: new Set<string>(),
+		issueKeys: new Set<string>(),
+		statusSeq: 0,
+		issueSeq: 0,
+		auditSeq: 0,
+	};
+}
+
+export function freezeWorkItemEffectRequestViews(
+	state: WorkItemEffectRunViewsState,
+): WorkItemEffectRequestViews {
+	return {
+		pendingEffectRequests: Object.freeze(Array.from(state.pendingEffectRequests.values())),
+		issues: Object.freeze([...state.issues]),
+		audit: Object.freeze([...state.audit]),
+	};
+}
+
+export function freezeWorkItemEvidenceViews(
+	state: WorkItemEvidenceViewsState,
+): WorkItemEvidenceViews {
+	return {
+		evidenceByWorkItem: new Map(
+			Array.from(state.evidenceByWorkItem, ([key, value]) => [key, Object.freeze([...value])]),
+		),
+		latestEvidenceByEffectRun: new Map(state.latestEvidenceByEffectRun),
+		issues: Object.freeze([...state.issues]),
+		audit: Object.freeze([...state.audit]),
+		pendingEffectRequests: Object.freeze(Array.from(state.pendingEffectRequests.values())),
+	};
+}
+
+export function freezeWorkItemDomainActionProposalViews(
+	state: WorkItemDomainActionProposalViewsState,
+): WorkItemDomainActionProposalViews {
+	return {
+		proposalsByWorkItem: new Map(
+			Array.from(state.proposalsByWorkItem, ([key, value]) => [key, Object.freeze([...value])]),
+		),
+		proposalsByEvidence: new Map(
+			Array.from(state.proposalsByEvidence, ([key, value]) => [key, Object.freeze([...value])]),
+		),
+		issues: Object.freeze([...state.issues]),
+		audit: Object.freeze([...state.audit]),
+	};
+}
+
+export function freezeWorkItemDomainActionAdmissionViews(
+	state: WorkItemDomainActionAdmissionViewsState,
+): WorkItemDomainActionAdmissionViews {
+	return {
+		admissionsByProposal: new Map(state.admissionsByProposal),
+		admissionsByWorkItem: new Map(
+			Array.from(state.admissionsByWorkItem, ([key, value]) => [key, Object.freeze([...value])]),
+		),
+		issues: Object.freeze([...state.issues]),
+		audit: Object.freeze([...state.audit]),
+	};
+}
+
+export function deletePendingWorkItemEffectRequest(
+	state: Pick<
+		WorkItemEffectRunViewsState | WorkItemEvidenceViewsState,
+		"pendingEffectRequests" | "settledRequestIds"
+	>,
+	refs: readonly string[] | undefined,
+): void {
+	for (const requestRef of refs?.filter((value) => value.startsWith("work-item-effect-request:")) ??
+		[]) {
+		const requestId = requestRef.slice("work-item-effect-request:".length);
+		state.pendingEffectRequests.delete(requestId);
+		state.settledRequestIds.add(requestId);
+	}
+}
+
+export function workItemEffectRequestRefs(request: WorkItemEffectRequested): readonly SourceRef[] {
+	return [
+		ref("work-item", request.workItemId),
+		ref("work-item-effect-request", request.requestId),
+		...(request.sourceRefs ?? []),
+	];
+}
+
+export function workItemResultRefs(result: EffectRunResult): readonly SourceRef[] {
+	return [
+		ref("effect-run", result.effectRunId),
+		ref("effect-run-result", result.resultId),
+		...(result.sourceRefs ?? []),
+		...(result.subjectRefs ?? []),
+	];
+}
+
+export function workItemActionProposalRefs(
+	evidence: WorkItemEvidenceRecorded,
+	result: EffectRunResult,
+	policy?: WorkItemEffectMappingPolicy,
+): readonly SourceRef[] {
+	return uniqueSourceRefs([
+		ref("work-item", evidence.workItemId),
+		ref("effect-run", evidence.effectRunId),
+		ref("effect-run-result", evidence.effectRunResultId),
+		ref("work-item-evidence", evidence.evidenceId),
+		...(policy === undefined ? [] : [ref("work-item-effect-mapping-policy", policy.policyId)]),
+		...(evidence.sourceRefs ?? []),
+		...(result.sourceRefs ?? []),
+		...(result.subjectRefs ?? []),
+	]);
+}
+
+export function workItemAdmissionProposalRefs(
+	proposal: WorkItemDomainActionProposal,
+): readonly SourceRef[] {
+	return uniqueSourceRefs([
+		ref("work-item", proposal.workItemId),
+		ref("work-item-domain-action-proposal", proposal.proposalId),
+		ref("effect-run", proposal.effectRunId),
+		ref("effect-run-result", proposal.effectRunResultId),
+		ref("work-item-evidence", proposal.evidenceId),
+		ref("work-item-effect-mapping-policy", proposal.policyId),
+		...(proposal.sourceRefs ?? []),
+	]);
+}
+
+export function workItemAdmissionDecisionRefs(
+	decision: WorkItemDomainActionAdmissionDecision,
+	proposal?: WorkItemDomainActionProposal,
+	policy?: WorkItemDomainActionAdmissionPolicy,
+): readonly SourceRef[] {
+	return uniqueSourceRefs([
+		...(proposal === undefined ? [] : workItemAdmissionProposalRefs(proposal)),
+		ref("work-item-domain-action-admission-decision", decision.decisionId),
+		ref("work-item-domain-action-admission", decision.admissionId),
+		ref("work-item-domain-action-proposal", decision.proposalId),
+		...(decision.policyId === undefined
+			? []
+			: [ref("work-item-domain-action-admission-policy", decision.policyId)]),
+		...(policy === undefined
+			? []
+			: [ref("work-item-domain-action-admission-policy", policy.policyId)]),
+		...(decision.targetProposalId === undefined
+			? []
+			: [ref("work-item-domain-action-proposal", decision.targetProposalId)]),
+		...(decision.targetAdmissionId === undefined
+			? []
+			: [ref("work-item-domain-action-admission", decision.targetAdmissionId)]),
+		...(decision.sourceRefs ?? []),
+	]);
+}
+
+export function workItemEvidenceOnlyRefs(evidence: WorkItemEvidenceRecorded): readonly SourceRef[] {
+	return uniqueSourceRefs([
+		ref("work-item", evidence.workItemId),
+		ref("effect-run", evidence.effectRunId),
+		ref("effect-run-result", evidence.effectRunResultId),
+		ref("work-item-evidence", evidence.evidenceId),
+		...(evidence.sourceRefs ?? []),
+	]);
+}
+
+export function referencedWorkItemMappingPolicyIds(
+	evidence: WorkItemEvidenceRecorded,
+): readonly string[] {
+	const refs = uniqueSourceRefs([...(evidence.sourceRefs ?? [])]);
+	return refs
+		.filter((sourceRef) => sourceRef.kind === "work-item-effect-mapping-policy")
+		.map((sourceRef) => sourceRef.id);
+}
+
+export function effectKindFromMetadata(
+	metadata: Record<string, unknown> | undefined,
+): string | undefined {
+	const effectKind = metadata?.effectKind;
+	return typeof effectKind === "string" ? effectKind : undefined;
+}
+
+export function workItemActionProposalPayload(
+	spec: WorkItemDomainActionProposalSpec,
+	evidence: WorkItemEvidenceRecorded,
+	result: EffectRunResult,
+): unknown {
+	if (spec.payload !== undefined) return spec.payload;
+	const payloadFrom = spec.payloadFrom;
+	if (payloadFrom === undefined) return undefined;
+	if (payloadFrom === "effect-run-result")
+		return { kind: "effect-run-result-ref", resultId: result.resultId };
+	if (payloadFrom === "output") return evidence.output;
+	return { kind: "work-item-evidence-ref", evidenceId: evidence.evidenceId };
+}
+
+export function resultReason(result: EffectRunResult): string | undefined {
+	if (result.status === "canceled" || result.status === "waived") return result.reason;
+	return undefined;
+}
+
+export function workItemIdForEffectRunResult(
+	state: Pick<WorkItemDomainActionProposalState, "evidence">,
+	result: EffectRunResult,
+): string | undefined {
+	for (const evidence of state.evidence.values()) {
+		if (
+			evidence.effectRunResultId === result.resultId &&
+			evidence.effectRunId === result.effectRunId
+		)
+			return evidence.workItemId;
+	}
+	return undefined;
+}
+
+export function uniqueSourceRefs(sourceRefs: readonly SourceRef[]): readonly SourceRef[] {
+	const seen = new Set<string>();
+	const unique: SourceRef[] = [];
+	for (const sourceRef of sourceRefs) {
+		const key = sourceRefKey(sourceRef);
+		if (seen.has(key)) continue;
+		seen.add(key);
+		unique.push(sourceRef);
+	}
+	return unique;
+}
+
+export function sourceRefKey(sourceRef: SourceRef): string {
+	return `${sourceRef.kind}:${sourceRef.id}:${JSON.stringify(sourceRef.metadata ?? {})}`;
+}
+
+export function distinctWorkItemRefs(
+	sourceRefs: readonly SourceRef[] | undefined,
+): readonly SourceRef[] {
+	const refs = new Map<string, SourceRef>();
+	for (const sourceRef of sourceRefs ?? []) {
+		if (sourceRef.kind === "work-item") refs.set(sourceRef.id, sourceRef);
+	}
+	return Array.from(refs.values());
+}
+
+export function singleWorkItemRef(
+	sourceRefs: readonly SourceRef[] | undefined,
+): SourceRef | undefined {
+	const matches = distinctWorkItemRefs(sourceRefs);
+	return matches.length === 1 ? matches[0] : undefined;
+}
+
+export function projectRuntimeFact<T, TOut>(
+	graph: Graph,
+	runtime: Node<T>,
+	name: string,
+	factory: string,
+	pick: (fact: T) => TOut | undefined,
+): Node<TOut> {
+	return graph.node<TOut>(
+		[runtime],
+		(ctx) => {
+			for (const fact of depBatch(ctx, 0) ?? []) {
+				const typed = fact as T;
+				const value = pick(typed);
+				if (value !== undefined) ctx.down([["DATA", value]]);
+			}
+		},
+		{ name, factory },
+	);
+}
+
+export function forEachPolicyDepBatch(
+	ctx: Ctx,
+	start: number,
+	count: number,
+	fn: (value: unknown) => void,
+): void {
+	for (let i = 0; i < count; i += 1) {
+		for (const value of depBatch(ctx, start + i) ?? []) fn(value);
+	}
+}
+
+export function dataIssue(
+	code: string,
+	message: string,
+	opts: {
+		readonly subjectId?: string;
+		readonly refs?: readonly SourceRef[];
+		readonly severity?: DataIssue["severity"];
+		readonly details?: unknown;
+	} = {},
+): DataIssue {
+	return {
+		kind: "issue",
+		code,
+		message,
+		severity: opts.severity ?? "error",
+		subjectId: opts.subjectId,
+		refs: opts.refs?.map((r) => `${r.kind}:${r.id}`),
+		details: opts.details,
+	};
+}
+
+export function ref(kind: string, id: string): SourceRef {
+	return { kind, id };
+}
diff --git a/packages/ts/src/orchestration/work-item-runtime-types.ts b/packages/ts/src/orchestration/work-item-runtime-types.ts
new file mode 100644
index 00000000..cbd63b55
--- /dev/null
+++ b/packages/ts/src/orchestration/work-item-runtime-types.ts
@@ -0,0 +1,350 @@
+import type { DataIssue } from "../data/index.js";
+import type { Node } from "../node/node.js";
+import type {
+	AgentNeed,
+	AgentOutputEnvelope,
+	AgentRuntimeAuditRecord,
+	EffectRun,
+	EffectRunGoal,
+	EffectRunLimits,
+	EffectRunResult,
+	EffectRunResultStatus,
+	SourceRef,
+} from "./agent-runtime.js";
+
+export interface WorkItemSeed {
+	readonly kind: "work-item";
+	readonly workItemId: string;
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly workItemKind?: string;
+	readonly summary?: string;
+	readonly detailRef?: string;
+	readonly lifecycleStatus?: string;
+	readonly issues?: readonly DataIssue[];
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface WorkItemEffectRequested<TInput = unknown> {
+	readonly kind: "work-item-effect-requested";
+	readonly requestId: string;
+	readonly workItemId: string;
+	readonly effectRunId: string;
+	readonly effectKind: string;
+	readonly executionInputRevision?: number;
+	readonly planId?: string;
+	readonly planMemberId?: string;
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly goal: EffectRunGoal<TInput>;
+	readonly agentRunId?: string;
+	readonly policyRefs?: readonly SourceRef[];
+	readonly limits?: EffectRunLimits;
+	readonly createdBy?: string;
+	readonly createdAtMs?: number;
+	readonly idempotencyKey?: string;
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface WorkItemEvidenceRecorded {
+	readonly kind: "work-item-evidence-recorded";
+	readonly evidenceId: string;
+	readonly workItemId: string;
+	readonly requestId?: string;
+	readonly effectRunId: string;
+	readonly effectRunResultId: string;
+	readonly executionInputRevision?: number;
+	readonly planId?: string;
+	readonly planMemberId?: string;
+	readonly status: EffectRunResultStatus;
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly output?: AgentOutputEnvelope;
+	readonly error?: DataIssue;
+	readonly needs?: readonly AgentNeed[];
+	readonly reason?: string;
+	readonly timeoutMs?: number;
+	readonly issues?: readonly DataIssue[];
+	readonly auditRefs?: readonly string[];
+	readonly recordedAtMs?: number;
+	readonly metadata?: Record<string, unknown>;
+}
+
+export type WorkItemDomainActionProposalPayloadFrom = "evidence" | "effect-run-result" | "output";
+
+export interface WorkItemDomainActionProposalSpec<TPayload = unknown> {
+	readonly actionKind: string;
+	readonly behavior?: "propose";
+	readonly statuses?: readonly EffectRunResultStatus[];
+	readonly outputKinds?: readonly string[];
+	readonly payloadFrom?: WorkItemDomainActionProposalPayloadFrom;
+	readonly payload?: TPayload;
+	readonly reason?: string;
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface WorkItemDomainActionProposal<TPayload = unknown> {
+	readonly kind: "work-item-domain-action-proposal";
+	readonly proposalId: string;
+	readonly workItemId: string;
+	readonly actionKind: string;
+	readonly effectRunId: string;
+	readonly effectRunResultId: string;
+	readonly evidenceId: string;
+	readonly policyId: string;
+	readonly payload?: TPayload;
+	readonly reason?: string;
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly proposedAtMs?: number;
+	readonly metadata?: Record<string, unknown>;
+}
+
+export type WorkItemDomainActionAdmissionOutcome = "admit" | "reject" | "defer" | "merge";
+export type WorkItemDomainActionAdmissionState = "admitted" | "rejected" | "deferred" | "merged";
+
+export interface WorkItemDomainActionAdmissionPolicy {
+	readonly kind: "work-item-domain-action-admission-policy";
+	readonly policyId: string;
+	readonly actionKinds?: readonly string[];
+	readonly allowedOutcomes?: readonly WorkItemDomainActionAdmissionOutcome[];
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface WorkItemDomainActionAdmissionDecision {
+	readonly kind: "work-item-domain-action-admission-decision";
+	readonly decisionId: string;
+	readonly admissionId: string;
+	readonly proposalId: string;
+	readonly outcome: WorkItemDomainActionAdmissionOutcome;
+	readonly policyId?: string;
+	readonly reason?: string;
+	readonly targetProposalId?: string;
+	readonly targetAdmissionId?: string;
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly decidedAtMs?: number;
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface WorkItemDomainActionAdmission {
+	readonly kind: "work-item-domain-action-admission";
+	readonly admissionId: string;
+	readonly proposalId: string;
+	readonly workItemId: string;
+	readonly actionKind: string;
+	readonly state: WorkItemDomainActionAdmissionState;
+	readonly decisionId: string;
+	readonly policyId?: string;
+	readonly reason?: string;
+	readonly targetProposalId?: string;
+	readonly targetAdmissionId?: string;
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly admittedAtMs?: number;
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface WorkItemEffectMappingPolicy {
+	readonly kind: "work-item-effect-mapping-policy";
+	readonly policyId: string;
+	readonly effectKinds?: readonly string[];
+	readonly evidence?: {
+		readonly behavior?: "record";
+	};
+	readonly actionProposals?: readonly WorkItemDomainActionProposalSpec[];
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface WorkItemStatusRecord {
+	readonly kind: "work-item-status";
+	readonly statusId: string;
+	readonly workItemId: string;
+	readonly state:
+		| "effect-request-pending"
+		| "effect-run-seeded"
+		| "evidence-recorded"
+		| "domain-action-proposed"
+		| "domain-action-admitted"
+		| "domain-action-rejected"
+		| "domain-action-deferred"
+		| "domain-action-merged"
+		| "mapping-issue";
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly effectRunId?: string;
+	readonly requestId?: string;
+	readonly evidenceId?: string;
+	readonly proposalId?: string;
+	readonly issues?: readonly DataIssue[];
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface WorkItemEffectRequestViews {
+	readonly pendingEffectRequests: readonly WorkItemEffectRequested[];
+	readonly issues: readonly DataIssue[];
+	readonly audit: readonly AgentRuntimeAuditRecord[];
+}
+
+export interface WorkItemEvidenceViews {
+	readonly evidenceByWorkItem: ReadonlyMap<string, readonly WorkItemEvidenceRecorded[]>;
+	readonly latestEvidenceByEffectRun: ReadonlyMap<string, WorkItemEvidenceRecorded>;
+	readonly issues: readonly DataIssue[];
+	readonly audit: readonly AgentRuntimeAuditRecord[];
+	readonly pendingEffectRequests: readonly WorkItemEffectRequested[];
+}
+
+export interface WorkItemDomainActionProposalViews {
+	readonly proposalsByWorkItem: ReadonlyMap<string, readonly WorkItemDomainActionProposal[]>;
+	readonly proposalsByEvidence: ReadonlyMap<string, readonly WorkItemDomainActionProposal[]>;
+	readonly issues: readonly DataIssue[];
+	readonly audit: readonly AgentRuntimeAuditRecord[];
+}
+
+export interface WorkItemDomainActionAdmissionViews {
+	readonly admissionsByProposal: ReadonlyMap<string, WorkItemDomainActionAdmission>;
+	readonly admissionsByWorkItem: ReadonlyMap<string, readonly WorkItemDomainActionAdmission[]>;
+	readonly issues: readonly DataIssue[];
+	readonly audit: readonly AgentRuntimeAuditRecord[];
+}
+
+export interface WorkItemEffectRunBundle {
+	readonly effectRuns: Node<EffectRun>;
+	readonly status: Node<WorkItemStatusRecord>;
+	readonly issues: Node<DataIssue>;
+	readonly audit: Node<AgentRuntimeAuditRecord>;
+	readonly views: Node<WorkItemEffectRequestViews>;
+}
+
+export interface WorkItemEvidenceMapperBundle {
+	readonly evidence: Node<WorkItemEvidenceRecorded>;
+	readonly status: Node<WorkItemStatusRecord>;
+	readonly issues: Node<DataIssue>;
+	readonly audit: Node<AgentRuntimeAuditRecord>;
+	readonly views: Node<WorkItemEvidenceViews>;
+}
+
+export interface WorkItemDomainActionProposalBundle {
+	readonly proposals: Node<WorkItemDomainActionProposal>;
+	readonly status: Node<WorkItemStatusRecord>;
+	readonly issues: Node<DataIssue>;
+	readonly audit: Node<AgentRuntimeAuditRecord>;
+	readonly views: Node<WorkItemDomainActionProposalViews>;
+}
+
+export interface WorkItemDomainActionAdmissionBundle {
+	readonly admissions: Node<WorkItemDomainActionAdmission>;
+	readonly status: Node<WorkItemStatusRecord>;
+	readonly issues: Node<DataIssue>;
+	readonly audit: Node<AgentRuntimeAuditRecord>;
+	readonly views: Node<WorkItemDomainActionAdmissionViews>;
+}
+
+export type WorkItemEffectRunFact =
+	| { readonly kind: "effect-run"; readonly effectRun: EffectRun }
+	| { readonly kind: "status"; readonly status: WorkItemStatusRecord }
+	| { readonly kind: "issue"; readonly issue: DataIssue }
+	| { readonly kind: "audit"; readonly audit: AgentRuntimeAuditRecord };
+
+export type WorkItemEvidenceMapperFact =
+	| { readonly kind: "evidence"; readonly evidence: WorkItemEvidenceRecorded }
+	| { readonly kind: "status"; readonly status: WorkItemStatusRecord }
+	| { readonly kind: "issue"; readonly issue: DataIssue }
+	| { readonly kind: "audit"; readonly audit: AgentRuntimeAuditRecord };
+
+export type WorkItemDomainActionProposalFact =
+	| { readonly kind: "proposal"; readonly proposal: WorkItemDomainActionProposal }
+	| { readonly kind: "status"; readonly status: WorkItemStatusRecord }
+	| { readonly kind: "issue"; readonly issue: DataIssue }
+	| { readonly kind: "audit"; readonly audit: AgentRuntimeAuditRecord };
+
+export type WorkItemDomainActionAdmissionFact =
+	| { readonly kind: "admission"; readonly admission: WorkItemDomainActionAdmission }
+	| { readonly kind: "status"; readonly status: WorkItemStatusRecord }
+	| { readonly kind: "issue"; readonly issue: DataIssue }
+	| { readonly kind: "audit"; readonly audit: AgentRuntimeAuditRecord };
+
+export interface WorkItemEffectRunState {
+	workItems: Map<string, WorkItemSeed>;
+	requests: Map<string, WorkItemEffectRequested>;
+	effectRunsByRequest: Map<string, string>;
+	seededEffectRunIds: Set<string>;
+	issues: DataIssue[];
+	audit: AgentRuntimeAuditRecord[];
+	issueKeys: Set<string>;
+	statusSeq: number;
+	issueSeq: number;
+	auditSeq: number;
+}
+
+export interface WorkItemEvidenceState {
+	workItems: Map<string, WorkItemSeed>;
+	effectRuns: Map<string, EffectRun>;
+	effectRunWorkItems: Map<string, string>;
+	evidenceByWorkItem: Map<string, WorkItemEvidenceRecorded[]>;
+	latestEvidenceByEffectRun: Map<string, WorkItemEvidenceRecorded>;
+	pendingEffectRequests: Map<string, WorkItemEffectRequested>;
+	requestsByEffectRun: Map<string, WorkItemEffectRequested>;
+	ambiguousRequestsByEffectRun: Map<string, WorkItemEffectRequested[]>;
+	policies: Map<string, WorkItemEffectMappingPolicy>;
+	issues: DataIssue[];
+	audit: AgentRuntimeAuditRecord[];
+	issueKeys: Set<string>;
+	statusSeq: number;
+	issueSeq: number;
+	auditSeq: number;
+}
+
+export interface WorkItemDomainActionProposalState {
+	workItems: Map<string, WorkItemSeed>;
+	evidence: Map<string, WorkItemEvidenceRecorded>;
+	results: Map<string, EffectRunResult>;
+	policies: Map<string, WorkItemEffectMappingPolicy>;
+	proposedKeys: Set<string>;
+	issueKeys: Set<string>;
+	statusSeq: number;
+	issueSeq: number;
+	auditSeq: number;
+}
+
+export interface WorkItemDomainActionAdmissionStateInternal {
+	proposals: Map<string, WorkItemDomainActionProposal>;
+	policies: Map<string, WorkItemDomainActionAdmissionPolicy>;
+	decisions: Map<string, WorkItemDomainActionAdmissionDecision>;
+	admissionsById: Map<string, WorkItemDomainActionAdmission>;
+	admissionsByProposal: Map<string, WorkItemDomainActionAdmission>;
+	terminalDecisionIds: Set<string>;
+	issueKeys: Set<string>;
+	statusSeq: number;
+	issueSeq: number;
+	auditSeq: number;
+}
+
+export interface WorkItemEffectRunViewsState {
+	pendingEffectRequests: Map<string, WorkItemEffectRequested>;
+	settledRequestIds: Set<string>;
+	issues: DataIssue[];
+	audit: AgentRuntimeAuditRecord[];
+}
+
+export interface WorkItemEvidenceViewsState {
+	evidenceByWorkItem: Map<string, WorkItemEvidenceRecorded[]>;
+	latestEvidenceByEffectRun: Map<string, WorkItemEvidenceRecorded>;
+	pendingEffectRequests: Map<string, WorkItemEffectRequested>;
+	settledEffectRunIds: Set<string>;
+	settledRequestIds: Set<string>;
+	issues: DataIssue[];
+	audit: AgentRuntimeAuditRecord[];
+}
+
+export interface WorkItemDomainActionProposalViewsState {
+	proposalsByWorkItem: Map<string, WorkItemDomainActionProposal[]>;
+	proposalsByEvidence: Map<string, WorkItemDomainActionProposal[]>;
+	issues: DataIssue[];
+	audit: AgentRuntimeAuditRecord[];
+}
+
+export interface WorkItemDomainActionAdmissionViewsState {
+	admissionsByProposal: Map<string, WorkItemDomainActionAdmission>;
+	admissionsByWorkItem: Map<string, WorkItemDomainActionAdmission[]>;
+	issues: DataIssue[];
+	audit: AgentRuntimeAuditRecord[];
+}
+
+export interface WorkItemMappingPolicyContext {
+	readonly policyRefs: readonly SourceRef[];
+	readonly effectKind?: string;
+}
diff --git a/packages/ts/src/orchestration/work-item-runtime.ts b/packages/ts/src/orchestration/work-item-runtime.ts
new file mode 100644
index 00000000..f55f1f60
--- /dev/null
+++ b/packages/ts/src/orchestration/work-item-runtime.ts
@@ -0,0 +1,27 @@
+export { workItemDomainActionAdmissionProjector } from "./work-item-runtime-admission.js";
+export { workItemEffectRunProjector } from "./work-item-runtime-effect-run.js";
+export { workItemEffectResultMapper } from "./work-item-runtime-evidence.js";
+export { workItemDomainActionProposalProjector } from "./work-item-runtime-proposal.js";
+export type {
+	WorkItemDomainActionAdmission,
+	WorkItemDomainActionAdmissionBundle,
+	WorkItemDomainActionAdmissionDecision,
+	WorkItemDomainActionAdmissionOutcome,
+	WorkItemDomainActionAdmissionPolicy,
+	WorkItemDomainActionAdmissionState,
+	WorkItemDomainActionAdmissionViews,
+	WorkItemDomainActionProposal,
+	WorkItemDomainActionProposalBundle,
+	WorkItemDomainActionProposalPayloadFrom,
+	WorkItemDomainActionProposalSpec,
+	WorkItemDomainActionProposalViews,
+	WorkItemEffectMappingPolicy,
+	WorkItemEffectRequested,
+	WorkItemEffectRequestViews,
+	WorkItemEffectRunBundle,
+	WorkItemEvidenceMapperBundle,
+	WorkItemEvidenceRecorded,
+	WorkItemEvidenceViews,
+	WorkItemSeed,
+	WorkItemStatusRecord,
+} from "./work-item-runtime-types.js";
diff --git a/packages/ts/src/orchestration/work-queue-scheduled-readiness.ts b/packages/ts/src/orchestration/work-queue-scheduled-readiness.ts
new file mode 100644
index 00000000..887bf76a
--- /dev/null
+++ b/packages/ts/src/orchestration/work-queue-scheduled-readiness.ts
@@ -0,0 +1,1555 @@
+import { depBatch } from "../ctx/types.js";
+import type { DataIssue } from "../data/index.js";
+import type { Graph } from "../graph/graph.js";
+import type { Node } from "../node/node.js";
+import type {
+	WorkQueueCommand,
+	WorkQueueDerivedState,
+	WorkQueueRecord,
+} from "../work-queue/index.js";
+import {
+	canonicalPublicSourceRefs,
+	dataIssue,
+	isRecord,
+	projectRuntimeFact,
+	ref,
+	sanitizeGraphVisibleRecord,
+	stableJsonStringify,
+	stableStringHash,
+	uniqueSourceRefs,
+} from "./agent-runtime-common.js";
+import type { AgentRuntimeAuditRecord } from "./agent-runtime-types-agent.js";
+import type { SourceRef } from "./agent-runtime-types-core.js";
+import type {
+	ScheduledReadinessOverdue,
+	ScheduledReadinessReady,
+	ScheduledReadinessRequested,
+} from "./scheduled-readiness.js";
+
+export type WorkQueueScheduledReadinessScheduleKind =
+	| "work-admitted"
+	| "work-scheduled"
+	| "retry-scheduled"
+	| "lease-expiration";
+
+export type WorkQueueScheduledReadinessStatusState = "translated" | "issue";
+
+export interface WorkQueueScheduledReadinessStatus {
+	readonly kind: "work-queue-scheduled-readiness-status";
+	readonly statusId: string;
+	readonly queueId?: string;
+	readonly workId?: string;
+	readonly recordSeq?: number;
+	readonly state: WorkQueueScheduledReadinessStatusState;
+	readonly scheduleKind?: WorkQueueScheduledReadinessScheduleKind;
+	readonly scheduleId?: string;
+	readonly readyAtMs?: number;
+	readonly deadlineMs?: number;
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly issueCodes?: readonly string[];
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface WorkQueueScheduledReadinessViews {
+	readonly schedulesById: ReadonlyMap<string, ScheduledReadinessRequested>;
+	readonly statusById: ReadonlyMap<string, WorkQueueScheduledReadinessStatus>;
+}
+
+export interface WorkQueueScheduledReadinessBundle {
+	readonly readinessSchedules: Node<ScheduledReadinessRequested>;
+	readonly status: Node<WorkQueueScheduledReadinessStatus>;
+	readonly issues: Node<DataIssue>;
+	readonly audit: Node<AgentRuntimeAuditRecord>;
+	readonly views: Node<WorkQueueScheduledReadinessViews>;
+}
+
+export type WorkQueueReadinessCandidateKind = "claim-eligible" | "lease-expiration-eligible";
+
+export interface WorkQueueReadinessCandidate {
+	readonly kind: "work-queue-readiness-candidate";
+	readonly candidateId: string;
+	readonly candidateKind: WorkQueueReadinessCandidateKind;
+	readonly queueId: string;
+	readonly workId: string;
+	readonly scheduleId: string;
+	readonly readyAtMs: number;
+	readonly nowMs: number;
+	readonly originRecordSeq?: number;
+	readonly originRecordKind?: string;
+	readonly leaseId?: string;
+	readonly attempt?: number;
+	readonly workerId?: string;
+	readonly leaseExpiresAtMs?: number;
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly metadata?: Record<string, unknown>;
+}
+
+export type WorkQueueReadinessHandoffStatusState =
+	| "candidate"
+	| "ignored-stale"
+	| "ignored-superseded"
+	| "ignored-terminal"
+	| "overdue"
+	| "pending-origin"
+	| "issue";
+
+export interface WorkQueueReadinessHandoffStatus {
+	readonly kind: "work-queue-readiness-handoff-status";
+	readonly statusId: string;
+	readonly state: WorkQueueReadinessHandoffStatusState;
+	readonly queueId?: string;
+	readonly workId?: string;
+	readonly scheduleId?: string;
+	readonly candidateId?: string;
+	readonly candidateKind?: WorkQueueReadinessCandidateKind;
+	readonly readyAtMs?: number;
+	readonly nowMs?: number;
+	readonly currentState?: WorkQueueDerivedState;
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly issueCodes?: readonly string[];
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface WorkQueueReadinessHandoffViews {
+	readonly candidatesById: ReadonlyMap<string, WorkQueueReadinessCandidate>;
+	readonly statusById: ReadonlyMap<string, WorkQueueReadinessHandoffStatus>;
+}
+
+export interface WorkQueueReadinessHandoffBundle {
+	readonly candidates: Node<WorkQueueReadinessCandidate>;
+	readonly status: Node<WorkQueueReadinessHandoffStatus>;
+	readonly issues: Node<DataIssue>;
+	readonly audit: Node<AgentRuntimeAuditRecord>;
+	readonly views: Node<WorkQueueReadinessHandoffViews>;
+}
+
+export interface WorkQueueLeaseExpirationCommandBundle<T = unknown> {
+	readonly commands: Node<WorkQueueCommand<T>>;
+	readonly status: Node<WorkQueueReadinessHandoffStatus>;
+	readonly views: Node<WorkQueueReadinessHandoffViews>;
+}
+
+const MAX_PUBLIC_COORDINATE_ID_CHARS = 160;
+const MAX_COPIED_PUBLIC_REFS = 16;
+const PRIVATE_COORDINATE_PATTERN =
+	/(api[_-]?key|authorization|bearer|credential|oauth|password|private[_-]?key|secret|session[_-]?cookie|token)/i;
+
+/**
+ * Translate workQueue-local delayed eligibility records into D432 shared readiness schedules.
+ *
+ * The projector is intentionally visibility-only: it never claims work, expires leases, cancels,
+ * completes, fails, mutates queue records, or starts timers. D433 consumption/materialization stays
+ * owned by later workQueue domain projectors.
+ */
+export function workQueueScheduledReadinessProjector<T = unknown>(
+	graph: Graph,
+	opts: {
+		readonly name?: string;
+		readonly records: Node<WorkQueueRecord<T>>;
+	},
+): WorkQueueScheduledReadinessBundle {
+	const name = opts.name ?? "workQueueScheduledReadiness";
+	const runtime = graph.node<WorkQueueScheduledReadinessFact>(
+		[opts.records],
+		(ctx) => {
+			const state = ctx.state.get<WorkQueueScheduledReadinessProjectorState>() ?? initialState();
+			for (const raw of depBatch(ctx, 0) ?? []) {
+				const translated = translateRecord(raw);
+				if (translated.kind === "none") continue;
+				if (translated.kind === "issue") {
+					emitIssue(ctx, state, translated.issue);
+					emitStatus(ctx, state, translated.status);
+					continue;
+				}
+				const identity = scheduleIdentity(translated.schedule);
+				const recordKey = `${translated.record.queueId}:${translated.record.recordSeq}`;
+				const existingRecordIdentity = state.recordScheduleIdentityByKey.get(recordKey);
+				if (existingRecordIdentity !== undefined) {
+					if (existingRecordIdentity !== identity) emitScheduleConflict(ctx, state, translated);
+					continue;
+				}
+				state.recordScheduleIdentityByKey.set(recordKey, identity);
+				const existing = state.schedulesById.get(translated.schedule.scheduleId);
+				if (existing !== undefined) {
+					if (scheduleIdentity(existing) !== identity) {
+						emitScheduleConflict(ctx, state, translated, existing);
+					}
+					continue;
+				}
+				state.schedulesById.set(translated.schedule.scheduleId, translated.schedule);
+				emitSchedule(ctx, state, translated.schedule);
+				emitStatus(ctx, state, translated.status);
+				emitAudit(ctx, state, "work-queue-scheduled-readiness-translated", {
+					subjectId: translated.schedule.scheduleId,
+					sourceRefs: translated.schedule.sourceRefs,
+					metadata: {
+						queueId: publicCoordinateId(translated.record.queueId),
+						workId: publicCoordinateId(translated.record.workId),
+						recordSeq: translated.record.recordSeq,
+						recordKind: translated.record.kind,
+						readyAtMs: translated.schedule.readyAtMs,
+					},
+				});
+			}
+			ctx.down([["DATA", { kind: "views", views: buildViews(state) }]]);
+			ctx.state.set(state);
+		},
+		{
+			name: `${name}/runtime`,
+			factory: "workQueueScheduledReadinessProjector",
+			partial: true,
+			completeWhenDepsComplete: false,
+			errorWhenDepsError: false,
+		},
+	);
+	return {
+		readinessSchedules: projectRuntimeFact(
+			graph,
+			runtime,
+			`${name}/readinessSchedules`,
+			"workQueueScheduledReadinessSchedules",
+			(fact) => (fact.kind === "readiness-schedule" ? fact.schedule : undefined),
+		),
+		status: projectRuntimeFact(
+			graph,
+			runtime,
+			`${name}/status`,
+			"workQueueScheduledReadinessStatus",
+			(fact) => (fact.kind === "status" ? fact.status : undefined),
+		),
+		issues: projectRuntimeFact(
+			graph,
+			runtime,
+			`${name}/issues`,
+			"workQueueScheduledReadinessIssues",
+			(fact) => (fact.kind === "issue" ? fact.issue : undefined),
+		),
+		audit: projectRuntimeFact(
+			graph,
+			runtime,
+			`${name}/audit`,
+			"workQueueScheduledReadinessAudit",
+			(fact) => (fact.kind === "audit" ? fact.audit : undefined),
+		),
+		views: projectRuntimeFact(
+			graph,
+			runtime,
+			`${name}/views`,
+			"workQueueScheduledReadinessViews",
+			(fact) => (fact.kind === "views" ? fact.views : undefined),
+		),
+	};
+}
+
+/**
+ * Consume D433 shared readiness through workQueue-owned handoff material.
+ *
+ * Ready facts only produce queue-domain candidates/status. They do not claim work, expire leases,
+ * cancel, complete, fail, or append workQueue records. Lease expiration candidates can be lowered
+ * separately into the existing mutation-bearing expire-leases command path.
+ */
+export function workQueueReadinessHandoffProjector<T = unknown>(
+	graph: Graph,
+	opts: {
+		readonly name?: string;
+		readonly records: Node<WorkQueueRecord<T>>;
+		readonly ready: Node<ScheduledReadinessReady>;
+		readonly overdue?: Node<ScheduledReadinessOverdue>;
+	},
+): WorkQueueReadinessHandoffBundle {
+	const name = opts.name ?? "workQueueReadinessHandoff";
+	const deps =
+		opts.overdue === undefined
+			? ([opts.records, opts.ready] as const)
+			: ([opts.records, opts.ready, opts.overdue] as const);
+	const runtime = graph.node<WorkQueueReadinessHandoffFact>(
+		deps,
+		(ctx) => {
+			const state = ctx.state.get<WorkQueueReadinessHandoffProjectorState>() ?? handoffState();
+			for (const raw of depBatch(ctx, 0) ?? []) {
+				const record = raw as WorkQueueRecord<T>;
+				ingestWorkQueueRecord(state, record);
+			}
+			for (const raw of depBatch(ctx, 1) ?? []) {
+				const ready = raw as ScheduledReadinessReady;
+				state.readyByScheduleId.set(ready.scheduleId, ready);
+			}
+			if (opts.overdue !== undefined) {
+				for (const raw of depBatch(ctx, 2) ?? []) {
+					emitOverdueHandoffStatus(ctx, state, raw as ScheduledReadinessOverdue);
+				}
+			}
+			evaluateReadyHandoffs(ctx, state);
+			ctx.down([["DATA", { kind: "views", views: buildHandoffViews(state) }]]);
+			ctx.state.set(state);
+		},
+		{
+			name: `${name}/runtime`,
+			factory: "workQueueReadinessHandoffProjector",
+			partial: true,
+			completeWhenDepsComplete: false,
+			errorWhenDepsError: false,
+		},
+	);
+	return {
+		candidates: projectRuntimeFact(
+			graph,
+			runtime,
+			`${name}/candidates`,
+			"workQueueReadinessHandoffCandidates",
+			(fact) => (fact.kind === "candidate" ? fact.candidate : undefined),
+		),
+		status: projectRuntimeFact(
+			graph,
+			runtime,
+			`${name}/status`,
+			"workQueueReadinessHandoffStatus",
+			(fact) => (fact.kind === "status" ? fact.status : undefined),
+		),
+		issues: projectRuntimeFact(
+			graph,
+			runtime,
+			`${name}/issues`,
+			"workQueueReadinessHandoffIssues",
+			(fact) => (fact.kind === "issue" ? fact.issue : undefined),
+		),
+		audit: projectRuntimeFact(
+			graph,
+			runtime,
+			`${name}/audit`,
+			"workQueueReadinessHandoffAudit",
+			(fact) => (fact.kind === "audit" ? fact.audit : undefined),
+		),
+		views: projectRuntimeFact(
+			graph,
+			runtime,
+			`${name}/views`,
+			"workQueueReadinessHandoffViews",
+			(fact) => (fact.kind === "views" ? fact.views : undefined),
+		),
+	};
+}
+
+/**
+ * Lower only lease-expiration readiness candidates into existing workQueue expire-leases commands.
+ */
+export function workQueueLeaseExpirationCommandProjector<T = unknown>(
+	graph: Graph,
+	opts: {
+		readonly name?: string;
+		readonly candidates: Node<WorkQueueReadinessCandidate>;
+	},
+): WorkQueueLeaseExpirationCommandBundle<T> {
+	const name = opts.name ?? "workQueueLeaseExpirationCommands";
+	const runtime = graph.node<WorkQueueLeaseExpirationCommandFact<T>>(
+		[opts.candidates],
+		(ctx) => {
+			const state =
+				ctx.state.get<WorkQueueLeaseExpirationCommandProjectorState<T>>() ??
+				leaseExpirationCommandState<T>();
+			for (const raw of depBatch(ctx, 0) ?? []) {
+				const candidate = raw as WorkQueueReadinessCandidate;
+				if (candidate.candidateKind !== "lease-expiration-eligible") continue;
+				if (state.commandByCandidateId.has(candidate.candidateId)) continue;
+				const command = Object.freeze({
+					kind: "expire-leases",
+					commandId: `${candidate.candidateId}:expire-leases`,
+					queueId: candidate.queueId,
+					workIds: [candidate.workId],
+					limit: 1,
+					nowMs: candidate.nowMs,
+					causationId: candidate.scheduleId,
+					...(sourceRefStrings(candidate.sourceRefs) === undefined
+						? {}
+						: { sourceRefs: sourceRefStrings(candidate.sourceRefs) }),
+				} satisfies WorkQueueCommand<T>);
+				state.commandByCandidateId.set(candidate.candidateId, command);
+				ctx.down([["DATA", { kind: "command", command }]]);
+				emitLeaseCommandStatus(ctx, state, command, candidate);
+			}
+			ctx.down([["DATA", { kind: "views", views: buildLeaseCommandViews(state) }]]);
+			ctx.state.set(state);
+		},
+		{
+			name: `${name}/runtime`,
+			factory: "workQueueLeaseExpirationCommandProjector",
+			partial: true,
+			completeWhenDepsComplete: false,
+			errorWhenDepsError: false,
+		},
+	);
+	return {
+		commands: projectRuntimeFact(
+			graph,
+			runtime,
+			`${name}/commands`,
+			"workQueueLeaseExpirationCommands",
+			(fact) => (fact.kind === "command" ? fact.command : undefined),
+		),
+		status: projectRuntimeFact(
+			graph,
+			runtime,
+			`${name}/status`,
+			"workQueueLeaseExpirationCommandStatus",
+			(fact) => (fact.kind === "status" ? fact.status : undefined),
+		),
+		views: projectRuntimeFact(
+			graph,
+			runtime,
+			`${name}/views`,
+			"workQueueLeaseExpirationCommandViews",
+			(fact) => (fact.kind === "views" ? fact.views : undefined),
+		),
+	};
+}
+
+type WorkQueueScheduledReadinessFact =
+	| { readonly kind: "readiness-schedule"; readonly schedule: ScheduledReadinessRequested }
+	| { readonly kind: "status"; readonly status: WorkQueueScheduledReadinessStatus }
+	| { readonly kind: "issue"; readonly issue: DataIssue }
+	| { readonly kind: "audit"; readonly audit: AgentRuntimeAuditRecord }
+	| { readonly kind: "views"; readonly views: WorkQueueScheduledReadinessViews };
+
+interface WorkQueueScheduledReadinessProjectorState {
+	recordScheduleIdentityByKey: Map<string, string>;
+	schedulesById: Map<string, ScheduledReadinessRequested>;
+	statusById: Map<string, WorkQueueScheduledReadinessStatus>;
+	emittedKeys: Set<string>;
+	issueKeys: Set<string>;
+	auditSeq: number;
+}
+
+type WorkQueueRecordWithWorkId = WorkQueueRecord<unknown> & { readonly workId: string };
+
+type TranslatedRecord =
+	| { readonly kind: "none" }
+	| {
+			readonly kind: "translated";
+			readonly record: WorkQueueRecordWithWorkId;
+			readonly schedule: ScheduledReadinessRequested;
+			readonly status: WorkQueueScheduledReadinessStatus;
+	  }
+	| {
+			readonly kind: "issue";
+			readonly issue: DataIssue;
+			readonly status: WorkQueueScheduledReadinessStatus;
+	  };
+
+type WorkQueueReadinessHandoffFact =
+	| { readonly kind: "candidate"; readonly candidate: WorkQueueReadinessCandidate }
+	| { readonly kind: "status"; readonly status: WorkQueueReadinessHandoffStatus }
+	| { readonly kind: "issue"; readonly issue: DataIssue }
+	| { readonly kind: "audit"; readonly audit: AgentRuntimeAuditRecord }
+	| { readonly kind: "views"; readonly views: WorkQueueReadinessHandoffViews };
+
+interface WorkQueueReadinessOrigin {
+	readonly record: WorkQueueRecordWithWorkId;
+	readonly schedule: ScheduledReadinessRequested;
+	readonly scheduleKind: WorkQueueScheduledReadinessScheduleKind;
+}
+
+interface WorkQueueReadinessWorkState {
+	readonly queueId: string;
+	readonly workId: string;
+	state: WorkQueueDerivedState;
+	notBeforeMs?: number;
+	retryAtMs?: number;
+	deadlineMs?: number;
+	leaseId?: string;
+	attempt?: number;
+	workerId?: string;
+	leaseExpiresAtMs?: number;
+	latestRecordSeq: number;
+}
+
+interface WorkQueueReadinessHandoffProjectorState {
+	originsByScheduleId: Map<string, WorkQueueReadinessOrigin>;
+	worksById: Map<string, WorkQueueReadinessWorkState>;
+	readyByScheduleId: Map<string, ScheduledReadinessReady>;
+	candidatesById: Map<string, WorkQueueReadinessCandidate>;
+	statusById: Map<string, WorkQueueReadinessHandoffStatus>;
+	emittedKeys: Set<string>;
+	issueKeys: Set<string>;
+	auditSeq: number;
+}
+
+type WorkQueueLeaseExpirationCommandFact<T> =
+	| { readonly kind: "command"; readonly command: WorkQueueCommand<T> }
+	| { readonly kind: "status"; readonly status: WorkQueueReadinessHandoffStatus }
+	| { readonly kind: "views"; readonly views: WorkQueueReadinessHandoffViews };
+
+interface WorkQueueLeaseExpirationCommandProjectorState<T> {
+	commandByCandidateId: Map<string, WorkQueueCommand<T>>;
+	statusById: Map<string, WorkQueueReadinessHandoffStatus>;
+	emittedKeys: Set<string>;
+}
+
+function initialState(): WorkQueueScheduledReadinessProjectorState {
+	return {
+		recordScheduleIdentityByKey: new Map(),
+		schedulesById: new Map(),
+		statusById: new Map(),
+		emittedKeys: new Set(),
+		issueKeys: new Set(),
+		auditSeq: 0,
+	};
+}
+
+function handoffState(): WorkQueueReadinessHandoffProjectorState {
+	return {
+		originsByScheduleId: new Map(),
+		worksById: new Map(),
+		readyByScheduleId: new Map(),
+		candidatesById: new Map(),
+		statusById: new Map(),
+		emittedKeys: new Set(),
+		issueKeys: new Set(),
+		auditSeq: 0,
+	};
+}
+
+function leaseExpirationCommandState<T>(): WorkQueueLeaseExpirationCommandProjectorState<T> {
+	return {
+		commandByCandidateId: new Map(),
+		statusById: new Map(),
+		emittedKeys: new Set(),
+	};
+}
+
+function ingestWorkQueueRecord<T>(
+	state: WorkQueueReadinessHandoffProjectorState,
+	record: WorkQueueRecord<T>,
+): void {
+	const translated = translateRecord(record);
+	if (translated.kind === "translated") {
+		state.originsByScheduleId.set(translated.schedule.scheduleId, {
+			record: translated.record,
+			schedule: translated.schedule,
+			scheduleKind: translated.status.scheduleKind as WorkQueueScheduledReadinessScheduleKind,
+		});
+	}
+	if (record.workId === undefined) return;
+	const recordWithWorkId = record as WorkQueueRecordWithWorkId;
+	const existing = state.worksById.get(
+		handoffWorkKey(recordWithWorkId.queueId, recordWithWorkId.workId),
+	);
+	if (existing !== undefined && recordWithWorkId.recordSeq < existing.latestRecordSeq) return;
+	const work = ensureHandoffWorkState(state, recordWithWorkId);
+	work.latestRecordSeq = Math.max(work.latestRecordSeq, recordWithWorkId.recordSeq);
+	switch (recordWithWorkId.kind) {
+		case "work-admitted":
+			work.state = recordWithWorkId.notBeforeMs === undefined ? "ready" : "scheduled";
+			work.notBeforeMs = recordWithWorkId.notBeforeMs;
+			work.retryAtMs = undefined;
+			work.deadlineMs = recordWithWorkId.deadlineMs;
+			clearHandoffLease(work);
+			break;
+		case "work-scheduled":
+			work.state = "scheduled";
+			work.notBeforeMs = recordWithWorkId.notBeforeMs;
+			work.deadlineMs = recordWithWorkId.deadlineMs;
+			break;
+		case "retry-scheduled":
+			work.state =
+				recordWithWorkId.retryAtMs <= recordWithWorkId.recordedAtMs ? "ready" : "retry-wait";
+			work.retryAtMs = recordWithWorkId.retryAtMs;
+			work.notBeforeMs = undefined;
+			break;
+		case "work-claimed":
+			work.state = "leased";
+			work.leaseId = recordWithWorkId.leaseId;
+			work.attempt = recordWithWorkId.attempt;
+			work.workerId = recordWithWorkId.workerId;
+			work.leaseExpiresAtMs = recordWithWorkId.leaseExpiresAtMs;
+			break;
+		case "lease-renewed":
+			work.state = "leased";
+			work.leaseId = recordWithWorkId.leaseId;
+			work.attempt = recordWithWorkId.attempt;
+			work.workerId = recordWithWorkId.workerId;
+			work.leaseExpiresAtMs = recordWithWorkId.leaseExpiresAtMs;
+			break;
+		case "work-released":
+		case "lease-expired":
+			work.state = "ready";
+			clearHandoffLease(work);
+			break;
+		case "work-completed":
+			work.state = "completed";
+			clearHandoffLease(work);
+			break;
+		case "work-canceled":
+			work.state = "canceled";
+			clearHandoffLease(work);
+			break;
+		case "work-dead-lettered":
+			work.state = "dead-lettered";
+			clearHandoffLease(work);
+			break;
+	}
+}
+
+function ensureHandoffWorkState(
+	state: WorkQueueReadinessHandoffProjectorState,
+	record: WorkQueueRecordWithWorkId,
+): WorkQueueReadinessWorkState {
+	const key = handoffWorkKey(record.queueId, record.workId);
+	const existing = state.worksById.get(key);
+	if (existing !== undefined) return existing;
+	const next: WorkQueueReadinessWorkState = {
+		queueId: record.queueId,
+		workId: record.workId,
+		state: "ready",
+		latestRecordSeq: record.recordSeq,
+	};
+	state.worksById.set(key, next);
+	return next;
+}
+
+function handoffWorkKey(queueId: string, workId: string): string {
+	return stableJsonStringify([queueId, workId]);
+}
+
+function clearHandoffLease(work: WorkQueueReadinessWorkState): void {
+	work.leaseId = undefined;
+	work.attempt = undefined;
+	work.workerId = undefined;
+	work.leaseExpiresAtMs = undefined;
+}
+
+function evaluateReadyHandoffs(
+	ctx: { down: (msgs: readonly ["DATA", WorkQueueReadinessHandoffFact][]) => void },
+	state: WorkQueueReadinessHandoffProjectorState,
+): void {
+	for (const ready of state.readyByScheduleId.values()) {
+		const origin = state.originsByScheduleId.get(ready.scheduleId);
+		if (origin === undefined) {
+			emitHandoffStatus(
+				ctx,
+				state,
+				handoffStatus("pending-origin", {
+					scheduleId: ready.scheduleId,
+					readyAtMs: ready.readyAtMs,
+					nowMs: ready.nowMs,
+					sourceRefs: ready.sourceRefs,
+				}),
+			);
+			continue;
+		}
+		const work = state.worksById.get(handoffWorkKey(origin.record.queueId, origin.record.workId));
+		if (work === undefined) {
+			emitHandoffStatus(
+				ctx,
+				state,
+				handoffStatus("pending-origin", {
+					queueId: origin.record.queueId,
+					workId: origin.record.workId,
+					scheduleId: ready.scheduleId,
+					readyAtMs: ready.readyAtMs,
+					nowMs: ready.nowMs,
+					sourceRefs: ready.sourceRefs,
+				}),
+			);
+			continue;
+		}
+		if (origin.record.recordSeq < work.latestRecordSeq) {
+			emitSuperseded(ctx, state, origin, work, ready, {
+				latestRecordSeq: work.latestRecordSeq,
+			});
+			continue;
+		}
+		const terminal = terminalHandoffState(work.state);
+		if (terminal) {
+			emitHandoffStatus(
+				ctx,
+				state,
+				handoffStatus("ignored-terminal", {
+					queueId: work.queueId,
+					workId: work.workId,
+					scheduleId: ready.scheduleId,
+					readyAtMs: ready.readyAtMs,
+					nowMs: ready.nowMs,
+					currentState: work.state,
+					sourceRefs: ready.sourceRefs,
+				}),
+			);
+			continue;
+		}
+		if (origin.scheduleKind === "lease-expiration") {
+			evaluateLeaseExpirationReady(ctx, state, origin, work, ready);
+			continue;
+		}
+		evaluateClaimEligibilityReady(ctx, state, origin, work, ready);
+	}
+}
+
+function evaluateClaimEligibilityReady(
+	ctx: { down: (msgs: readonly ["DATA", WorkQueueReadinessHandoffFact][]) => void },
+	state: WorkQueueReadinessHandoffProjectorState,
+	origin: WorkQueueReadinessOrigin,
+	work: WorkQueueReadinessWorkState,
+	ready: ScheduledReadinessReady,
+): void {
+	if (work.state === "leased") {
+		emitHandoffStatus(
+			ctx,
+			state,
+			handoffStatus("ignored-stale", {
+				queueId: work.queueId,
+				workId: work.workId,
+				scheduleId: ready.scheduleId,
+				readyAtMs: ready.readyAtMs,
+				nowMs: ready.nowMs,
+				currentState: work.state,
+				sourceRefs: ready.sourceRefs,
+			}),
+		);
+		return;
+	}
+	if (work.notBeforeMs !== undefined && work.notBeforeMs > ready.nowMs) {
+		emitSuperseded(ctx, state, origin, work, ready, { notBeforeMs: work.notBeforeMs });
+		return;
+	}
+	if (work.retryAtMs !== undefined && work.retryAtMs > ready.nowMs) {
+		emitSuperseded(ctx, state, origin, work, ready, { retryAtMs: work.retryAtMs });
+		return;
+	}
+	emitCandidate(ctx, state, candidateFor(origin, ready, "claim-eligible"));
+}
+
+function evaluateLeaseExpirationReady(
+	ctx: { down: (msgs: readonly ["DATA", WorkQueueReadinessHandoffFact][]) => void },
+	state: WorkQueueReadinessHandoffProjectorState,
+	origin: WorkQueueReadinessOrigin,
+	work: WorkQueueReadinessWorkState,
+	ready: ScheduledReadinessReady,
+): void {
+	if (origin.record.kind !== "work-claimed" && origin.record.kind !== "lease-renewed") {
+		emitHandoffIssue(
+			ctx,
+			state,
+			dataIssue(
+				"work-queue-readiness-handoff-malformed-origin",
+				"Lease-expiration readiness must originate from a lease-bearing workQueue record.",
+				{ subjectId: ready.scheduleId, refs: ready.sourceRefs },
+			),
+		);
+		return;
+	}
+	if (
+		work.state !== "leased" ||
+		work.leaseId !== origin.record.leaseId ||
+		work.attempt !== origin.record.attempt ||
+		work.workerId !== origin.record.workerId
+	) {
+		emitHandoffStatus(
+			ctx,
+			state,
+			handoffStatus("ignored-stale", {
+				queueId: work.queueId,
+				workId: work.workId,
+				scheduleId: ready.scheduleId,
+				readyAtMs: ready.readyAtMs,
+				nowMs: ready.nowMs,
+				currentState: work.state,
+				sourceRefs: ready.sourceRefs,
+			}),
+		);
+		return;
+	}
+	if (work.leaseExpiresAtMs !== origin.record.leaseExpiresAtMs) {
+		emitSuperseded(ctx, state, origin, work, ready, {
+			leaseExpiresAtMs: work.leaseExpiresAtMs,
+		});
+		return;
+	}
+	if (work.leaseExpiresAtMs !== undefined && work.leaseExpiresAtMs > ready.nowMs) {
+		emitSuperseded(ctx, state, origin, work, ready, {
+			leaseExpiresAtMs: work.leaseExpiresAtMs,
+		});
+		return;
+	}
+	emitCandidate(ctx, state, candidateFor(origin, ready, "lease-expiration-eligible"));
+}
+
+function emitSuperseded(
+	ctx: { down: (msgs: readonly ["DATA", WorkQueueReadinessHandoffFact][]) => void },
+	state: WorkQueueReadinessHandoffProjectorState,
+	origin: WorkQueueReadinessOrigin,
+	work: WorkQueueReadinessWorkState,
+	ready: ScheduledReadinessReady,
+	metadata: Record<string, unknown>,
+): void {
+	emitHandoffStatus(
+		ctx,
+		state,
+		handoffStatus("ignored-superseded", {
+			queueId: work.queueId,
+			workId: work.workId,
+			scheduleId: ready.scheduleId,
+			readyAtMs: ready.readyAtMs,
+			nowMs: ready.nowMs,
+			currentState: work.state,
+			sourceRefs: ready.sourceRefs,
+			metadata: {
+				originRecordSeq: origin.record.recordSeq,
+				originRecordKind: origin.record.kind,
+				...metadata,
+			},
+		}),
+	);
+}
+
+function candidateFor(
+	origin: WorkQueueReadinessOrigin,
+	ready: ScheduledReadinessReady,
+	candidateKind: WorkQueueReadinessCandidateKind,
+): WorkQueueReadinessCandidate {
+	const lease =
+		origin.record.kind === "work-claimed" || origin.record.kind === "lease-renewed"
+			? {
+					leaseId: origin.record.leaseId,
+					attempt: origin.record.attempt,
+					workerId: origin.record.workerId,
+					leaseExpiresAtMs: origin.record.leaseExpiresAtMs,
+				}
+			: {};
+	const metadata = sanitizeGraphVisibleRecord({
+		originRecordSeq: origin.record.recordSeq,
+		originRecordKind: origin.record.kind,
+		scheduleKind: origin.scheduleKind,
+	});
+	return Object.freeze({
+		kind: "work-queue-readiness-candidate",
+		candidateId: `${ready.scheduleId}:work-queue:${candidateKind}`,
+		candidateKind,
+		queueId: origin.record.queueId,
+		workId: origin.record.workId,
+		scheduleId: ready.scheduleId,
+		readyAtMs: ready.readyAtMs,
+		nowMs: ready.nowMs,
+		originRecordSeq: origin.record.recordSeq,
+		originRecordKind: origin.record.kind,
+		...lease,
+		sourceRefs: canonicalPublicSourceRefs(
+			uniqueSourceRefs([
+				...(ready.sourceRefs ?? []),
+				ref("work-queue-record", String(origin.record.recordSeq)),
+				ref("scheduled-readiness-ready", ready.scheduleId),
+			]),
+		),
+		...(metadata === undefined ? {} : { metadata }),
+	} satisfies WorkQueueReadinessCandidate);
+}
+
+function emitCandidate(
+	ctx: { down: (msgs: readonly ["DATA", WorkQueueReadinessHandoffFact][]) => void },
+	state: WorkQueueReadinessHandoffProjectorState,
+	candidate: WorkQueueReadinessCandidate,
+): void {
+	const key = `candidate:${candidate.candidateId}`;
+	if (!state.emittedKeys.has(key)) {
+		state.emittedKeys.add(key);
+		state.candidatesById.set(candidate.candidateId, candidate);
+		ctx.down([["DATA", { kind: "candidate", candidate }]]);
+		emitHandoffAudit(ctx, state, "work-queue-readiness-candidate", {
+			subjectId: candidate.candidateId,
+			sourceRefs: candidate.sourceRefs,
+			metadata: {
+				candidateKind: candidate.candidateKind,
+				queueId: candidate.queueId,
+				workId: candidate.workId,
+				readyAtMs: candidate.readyAtMs,
+				nowMs: candidate.nowMs,
+			},
+		});
+	} else {
+		state.candidatesById.set(candidate.candidateId, candidate);
+	}
+	emitHandoffStatus(
+		ctx,
+		state,
+		handoffStatus("candidate", {
+			queueId: candidate.queueId,
+			workId: candidate.workId,
+			scheduleId: candidate.scheduleId,
+			candidateId: candidate.candidateId,
+			candidateKind: candidate.candidateKind,
+			readyAtMs: candidate.readyAtMs,
+			nowMs: candidate.nowMs,
+			sourceRefs: candidate.sourceRefs,
+		}),
+	);
+}
+
+function emitOverdueHandoffStatus(
+	ctx: { down: (msgs: readonly ["DATA", WorkQueueReadinessHandoffFact][]) => void },
+	state: WorkQueueReadinessHandoffProjectorState,
+	overdue: ScheduledReadinessOverdue,
+): void {
+	const origin = state.originsByScheduleId.get(overdue.scheduleId);
+	emitHandoffStatus(
+		ctx,
+		state,
+		handoffStatus("overdue", {
+			queueId: origin?.record.queueId,
+			workId: origin?.record.workId,
+			scheduleId: overdue.scheduleId,
+			readyAtMs: overdue.readyAtMs,
+			nowMs: overdue.nowMs,
+			sourceRefs: overdue.sourceRefs,
+			metadata: {
+				deadlineMs: overdue.deadlineMs,
+				...(origin === undefined
+					? {}
+					: { originRecordSeq: origin.record.recordSeq, originRecordKind: origin.record.kind }),
+			},
+		}),
+	);
+}
+
+function handoffStatus(
+	state: WorkQueueReadinessHandoffStatusState,
+	opts: {
+		readonly queueId?: string;
+		readonly workId?: string;
+		readonly scheduleId?: string;
+		readonly candidateId?: string;
+		readonly candidateKind?: WorkQueueReadinessCandidateKind;
+		readonly readyAtMs?: number;
+		readonly nowMs?: number;
+		readonly currentState?: WorkQueueDerivedState;
+		readonly sourceRefs?: readonly SourceRef[];
+		readonly issueCodes?: readonly string[];
+		readonly metadata?: Record<string, unknown>;
+	},
+): WorkQueueReadinessHandoffStatus {
+	const subject = opts.candidateId ?? opts.scheduleId ?? "unknown-work-queue-readiness";
+	const metadata = sanitizeGraphVisibleRecord(opts.metadata);
+	return Object.freeze({
+		kind: "work-queue-readiness-handoff-status",
+		statusId: `${subject}:work-queue-readiness-handoff-status:${state}`,
+		state,
+		...(opts.queueId === undefined ? {} : { queueId: opts.queueId }),
+		...(opts.workId === undefined ? {} : { workId: opts.workId }),
+		...(opts.scheduleId === undefined ? {} : { scheduleId: opts.scheduleId }),
+		...(opts.candidateId === undefined ? {} : { candidateId: opts.candidateId }),
+		...(opts.candidateKind === undefined ? {} : { candidateKind: opts.candidateKind }),
+		...(opts.readyAtMs === undefined ? {} : { readyAtMs: opts.readyAtMs }),
+		...(opts.nowMs === undefined ? {} : { nowMs: opts.nowMs }),
+		...(opts.currentState === undefined ? {} : { currentState: opts.currentState }),
+		...(opts.sourceRefs === undefined
+			? {}
+			: { sourceRefs: canonicalPublicSourceRefs(opts.sourceRefs) }),
+		...(opts.issueCodes === undefined ? {} : { issueCodes: opts.issueCodes }),
+		...(metadata === undefined ? {} : { metadata }),
+	} satisfies WorkQueueReadinessHandoffStatus);
+}
+
+function emitHandoffStatus(
+	ctx: { down: (msgs: readonly ["DATA", WorkQueueReadinessHandoffFact][]) => void },
+	state: WorkQueueReadinessHandoffProjectorState,
+	status: WorkQueueReadinessHandoffStatus,
+): void {
+	state.statusById.set(status.statusId, status);
+	const key = `handoff-status:${status.statusId}:${stableJsonStringify(status)}`;
+	if (state.emittedKeys.has(key)) return;
+	state.emittedKeys.add(key);
+	ctx.down([["DATA", { kind: "status", status }]]);
+}
+
+function emitHandoffIssue(
+	ctx: { down: (msgs: readonly ["DATA", WorkQueueReadinessHandoffFact][]) => void },
+	state: WorkQueueReadinessHandoffProjectorState,
+	issue: DataIssue,
+): void {
+	const key = `${issue.code}:${issue.subjectId ?? ""}:${JSON.stringify(issue.details ?? {})}`;
+	if (state.issueKeys.has(key)) return;
+	state.issueKeys.add(key);
+	ctx.down([["DATA", { kind: "issue", issue }]]);
+	emitHandoffStatus(
+		ctx,
+		state,
+		handoffStatus("issue", {
+			scheduleId: issue.subjectId,
+			sourceRefs: issue.refs?.map(sourceRefFromIssueRef),
+			issueCodes: [issue.code],
+		}),
+	);
+}
+
+function emitHandoffAudit(
+	ctx: { down: (msgs: readonly ["DATA", WorkQueueReadinessHandoffFact][]) => void },
+	state: WorkQueueReadinessHandoffProjectorState,
+	kind: string,
+	opts: {
+		readonly subjectId: string;
+		readonly sourceRefs?: readonly SourceRef[];
+		readonly metadata?: Record<string, unknown>;
+	},
+): void {
+	state.auditSeq += 1;
+	const metadata = sanitizeGraphVisibleRecord(opts.metadata);
+	ctx.down([
+		[
+			"DATA",
+			{
+				kind: "audit",
+				audit: Object.freeze({
+					id: `work-queue-readiness-handoff-audit-${state.auditSeq}`,
+					kind,
+					subjectId: opts.subjectId,
+					...(opts.sourceRefs === undefined
+						? {}
+						: { sourceRefs: canonicalPublicSourceRefs(opts.sourceRefs) }),
+					...(metadata === undefined ? {} : { metadata }),
+				} satisfies AgentRuntimeAuditRecord),
+			},
+		],
+	]);
+}
+
+function buildHandoffViews(
+	state: WorkQueueReadinessHandoffProjectorState,
+): WorkQueueReadinessHandoffViews {
+	return Object.freeze({
+		candidatesById: new Map(state.candidatesById),
+		statusById: new Map(state.statusById),
+	});
+}
+
+function emitLeaseCommandStatus<T>(
+	ctx: { down: (msgs: readonly ["DATA", WorkQueueLeaseExpirationCommandFact<T>][]) => void },
+	state: WorkQueueLeaseExpirationCommandProjectorState<T>,
+	command: WorkQueueCommand<T>,
+	candidate: WorkQueueReadinessCandidate,
+): void {
+	const status = handoffStatus("candidate", {
+		queueId: candidate.queueId,
+		workId: candidate.workId,
+		scheduleId: candidate.scheduleId,
+		candidateId: candidate.candidateId,
+		candidateKind: candidate.candidateKind,
+		readyAtMs: candidate.readyAtMs,
+		nowMs: candidate.nowMs,
+		sourceRefs: candidate.sourceRefs,
+		metadata: {
+			commandId: command.commandId,
+			commandKind: command.kind,
+		},
+	});
+	state.statusById.set(status.statusId, status);
+	const key = `lease-command-status:${status.statusId}`;
+	if (state.emittedKeys.has(key)) return;
+	state.emittedKeys.add(key);
+	ctx.down([["DATA", { kind: "status", status }]]);
+}
+
+function buildLeaseCommandViews<T>(
+	state: WorkQueueLeaseExpirationCommandProjectorState<T>,
+): WorkQueueReadinessHandoffViews {
+	return Object.freeze({
+		candidatesById: new Map(),
+		statusById: new Map(state.statusById),
+	});
+}
+
+function sourceRefStrings(
+	sourceRefs: readonly SourceRef[] | undefined,
+): readonly string[] | undefined {
+	if (sourceRefs === undefined || sourceRefs.length === 0) return undefined;
+	return sourceRefs.map((sourceRef) => `${sourceRef.kind}:${sourceRef.id}`);
+}
+
+function sourceRefFromIssueRef(issueRef: string): SourceRef {
+	const [kind, ...rest] = issueRef.split(":");
+	return ref(kind || "issue-ref", rest.join(":") || issueRef);
+}
+
+function terminalHandoffState(state: WorkQueueDerivedState): boolean {
+	return state === "completed" || state === "canceled" || state === "dead-lettered";
+}
+
+function hasWorkRecordCoordinates(record: Record<string, unknown>): boolean {
+	return (
+		typeof record.queueId === "string" &&
+		typeof record.workId === "string" &&
+		typeof record.recordSeq === "number" &&
+		Number.isFinite(record.recordSeq)
+	);
+}
+
+function hasLeaseRecordCoordinates(record: Record<string, unknown>): boolean {
+	return (
+		hasWorkRecordCoordinates(record) &&
+		typeof record.leaseId === "string" &&
+		typeof record.attempt === "number" &&
+		Number.isFinite(record.attempt) &&
+		typeof record.workerId === "string"
+	);
+}
+
+function malformedRecord(record: Record<string, unknown>, message: string): TranslatedRecord {
+	const subjectId =
+		typeof record.kind === "string"
+			? `work-queue-record:${publicCoordinateId(record.kind)}`
+			: "unknown-work-queue-record";
+	const issue = dataIssue("work-queue-scheduled-readiness-malformed-record", message, {
+		subjectId,
+		refs: [],
+		details: sanitizeGraphVisibleRecord({
+			recordKind: typeof record.kind === "string" ? record.kind : undefined,
+			queueId: typeof record.queueId === "string" ? publicCoordinateId(record.queueId) : undefined,
+			workId: typeof record.workId === "string" ? publicCoordinateId(record.workId) : undefined,
+			recordSeq:
+				typeof record.recordSeq === "number" && Number.isFinite(record.recordSeq)
+					? record.recordSeq
+					: undefined,
+		}),
+	});
+	return {
+		kind: "issue",
+		issue,
+		status: issueStatus(subjectId, [issue]),
+	};
+}
+
+function translateRecord(raw: unknown): TranslatedRecord {
+	if (!isRecord(raw)) {
+		const issue = dataIssue(
+			"work-queue-scheduled-readiness-malformed-record",
+			"WorkQueue scheduled readiness requires a graph-visible workQueue record.",
+			{ subjectId: "unknown-work-queue-record", refs: [] },
+		);
+		return {
+			kind: "issue",
+			issue,
+			status: issueStatus("unknown-work-queue-record", [issue]),
+		};
+	}
+	const unknownRecord: unknown = raw;
+	const rawRecord = unknownRecord as Record<string, unknown>;
+	switch (rawRecord.kind) {
+		case "work-admitted": {
+			const notBeforeMs = rawRecord.notBeforeMs;
+			if (notBeforeMs === undefined) return { kind: "none" };
+			if (typeof notBeforeMs !== "number") {
+				return malformedRecord(rawRecord, "Delayed work-admitted notBeforeMs must be a number.");
+			}
+			if (!hasWorkRecordCoordinates(rawRecord)) {
+				return malformedRecord(
+					rawRecord,
+					"Delayed work-admitted records require queueId, workId, and recordSeq.",
+				);
+			}
+			const admitted = rawRecord as unknown as Extract<
+				WorkQueueRecord<unknown>,
+				{ readonly kind: "work-admitted" }
+			>;
+			return scheduleFromRecord(admitted, {
+				scheduleKind: "work-admitted",
+				scheduleId: workQueueScheduleId(admitted, "admission", admitted.recordSeq),
+				readyAtMs: notBeforeMs,
+				deadlineMs: admitted.deadlineMs,
+				reason: "work-queue-delayed-admission",
+			});
+		}
+		case "work-scheduled": {
+			if (!hasWorkRecordCoordinates(rawRecord)) {
+				return malformedRecord(
+					rawRecord,
+					"work-scheduled records require queueId, workId, and recordSeq.",
+				);
+			}
+			const scheduled = rawRecord as unknown as Extract<
+				WorkQueueRecord<unknown>,
+				{ readonly kind: "work-scheduled" }
+			>;
+			return scheduleFromRecord(scheduled, {
+				scheduleKind: "work-scheduled",
+				scheduleId: workQueueScheduleId(
+					scheduled,
+					"schedule",
+					scheduled.scheduleId ?? scheduled.commandId ?? scheduled.recordSeq,
+				),
+				readyAtMs: scheduled.notBeforeMs,
+				deadlineMs: scheduled.deadlineMs,
+				reason: scheduled.reason ?? "work-queue-schedule",
+			});
+		}
+		case "retry-scheduled": {
+			if (!hasWorkRecordCoordinates(rawRecord)) {
+				return malformedRecord(
+					rawRecord,
+					"retry-scheduled records require queueId, workId, and recordSeq.",
+				);
+			}
+			const retry = rawRecord as unknown as Extract<
+				WorkQueueRecord<unknown>,
+				{ readonly kind: "retry-scheduled" }
+			>;
+			return scheduleFromRecord(retry, {
+				scheduleKind: "retry-scheduled",
+				scheduleId: workQueueScheduleId(retry, "retry", retry.commandId ?? retry.recordSeq),
+				readyAtMs: retry.retryAtMs,
+				reason: retry.reason ?? "work-queue-retry",
+				metadata: { delayMs: retry.delayMs },
+			});
+		}
+		case "work-claimed": {
+			if (!hasLeaseRecordCoordinates(rawRecord)) {
+				return malformedRecord(
+					rawRecord,
+					"work-claimed records require queueId, workId, recordSeq, leaseId, attempt, and workerId.",
+				);
+			}
+			const claimed = rawRecord as unknown as Extract<
+				WorkQueueRecord<unknown>,
+				{ readonly kind: "work-claimed" }
+			>;
+			return scheduleFromRecord(claimed, {
+				scheduleKind: "lease-expiration",
+				scheduleId: workQueueLeaseScheduleId(claimed),
+				readyAtMs: claimed.leaseExpiresAtMs,
+				reason: "work-queue-lease-expiration",
+				leaseId: claimed.leaseId,
+				metadata: { attempt: claimed.attempt },
+			});
+		}
+		case "lease-renewed": {
+			if (!hasLeaseRecordCoordinates(rawRecord)) {
+				return malformedRecord(
+					rawRecord,
+					"lease-renewed records require queueId, workId, recordSeq, leaseId, attempt, and workerId.",
+				);
+			}
+			const renewed = rawRecord as unknown as Extract<
+				WorkQueueRecord<unknown>,
+				{ readonly kind: "lease-renewed" }
+			>;
+			return scheduleFromRecord(renewed, {
+				scheduleKind: "lease-expiration",
+				scheduleId: workQueueLeaseScheduleId(renewed),
+				readyAtMs: renewed.leaseExpiresAtMs,
+				reason: "work-queue-lease-expiration",
+				leaseId: renewed.leaseId,
+				metadata: {
+					attempt: renewed.attempt,
+					previousLeaseExpiresAtMs: renewed.previousLeaseExpiresAtMs,
+				},
+			});
+		}
+		default:
+			return { kind: "none" };
+	}
+}
+
+function scheduleFromRecord(
+	record: WorkQueueRecordWithWorkId,
+	opts: {
+		readonly scheduleKind: WorkQueueScheduledReadinessScheduleKind;
+		readonly scheduleId: string;
+		readonly readyAtMs: number;
+		readonly deadlineMs?: number;
+		readonly reason: string;
+		readonly leaseId?: string;
+		readonly metadata?: Record<string, unknown>;
+	},
+): TranslatedRecord {
+	if (!Number.isFinite(opts.readyAtMs) || !finiteOrUndefined(opts.deadlineMs)) {
+		const refs = recordSourceRefs(record, opts.leaseId);
+		const issue = dataIssue(
+			"work-queue-scheduled-readiness-malformed-record",
+			"WorkQueue delayed eligibility record must carry finite readiness and deadline coordinates.",
+			{
+				subjectId: workQueueRecordSubjectId(record),
+				refs,
+				details: {
+					recordKind: record.kind,
+					readyAtMs: opts.readyAtMs,
+					deadlineMs: opts.deadlineMs,
+				},
+			},
+		);
+		return {
+			kind: "issue",
+			issue,
+			status: issueStatus(opts.scheduleId, [issue], record, refs),
+		};
+	}
+	const subjectRefs = recordSubjectRefs(record, opts.leaseId);
+	const sourceRefs = recordSourceRefs(record, opts.leaseId);
+	const recordPolicyRefs = policyRefs(record);
+	const metadata = sanitizeGraphVisibleRecord({
+		queueId: publicCoordinateId(record.queueId),
+		workId: publicCoordinateId(record.workId),
+		recordSeq: record.recordSeq,
+		recordKind: record.kind,
+		scheduleKind: opts.scheduleKind,
+		...(record.commandId === undefined ? {} : { commandId: publicCoordinateId(record.commandId) }),
+		...(opts.leaseId === undefined ? {} : { leaseId: publicCoordinateId(opts.leaseId) }),
+		...(opts.metadata ?? {}),
+	});
+	const schedule = Object.freeze({
+		kind: "scheduled-readiness-requested",
+		scheduleId: opts.scheduleId,
+		subjectRefs,
+		readyAtMs: opts.readyAtMs,
+		...(opts.deadlineMs === undefined ? {} : { deadlineMs: opts.deadlineMs }),
+		reason: opts.reason,
+		...(recordPolicyRefs === undefined ? {} : { policyRefs: recordPolicyRefs }),
+		sourceRefs,
+		...(metadata === undefined ? {} : { metadata }),
+	} satisfies ScheduledReadinessRequested);
+	return {
+		kind: "translated",
+		record,
+		schedule,
+		status: Object.freeze({
+			kind: "work-queue-scheduled-readiness-status",
+			statusId: `${opts.scheduleId}:work-queue-scheduled-readiness-status:translated`,
+			queueId: publicCoordinateId(record.queueId),
+			workId: publicCoordinateId(record.workId),
+			recordSeq: record.recordSeq,
+			state: "translated",
+			scheduleKind: opts.scheduleKind,
+			scheduleId: opts.scheduleId,
+			readyAtMs: opts.readyAtMs,
+			...(opts.deadlineMs === undefined ? {} : { deadlineMs: opts.deadlineMs }),
+			sourceRefs,
+			...(metadata === undefined ? {} : { metadata }),
+		} satisfies WorkQueueScheduledReadinessStatus),
+	};
+}
+
+function recordSubjectRefs<T>(
+	record: WorkQueueRecord<T> & { readonly workId: string },
+	leaseId?: string,
+): readonly SourceRef[] {
+	return canonicalPublicSourceRefs(
+		uniqueSourceRefs([
+			ref("work-queue", publicCoordinateId(record.queueId)),
+			ref("work-queue-work", publicCoordinateId(record.workId)),
+			ref("work-queue-record", String(record.recordSeq)),
+			...(record.commandId === undefined
+				? []
+				: [ref("work-queue-command", publicCoordinateId(record.commandId))]),
+			...(leaseId === undefined ? [] : [ref("work-queue-lease", publicCoordinateId(leaseId))]),
+		]),
+	);
+}
+
+function recordSourceRefs<T>(
+	record: WorkQueueRecord<T> & { readonly workId?: string },
+	leaseId?: string,
+): readonly SourceRef[] {
+	return canonicalPublicSourceRefs(
+		uniqueSourceRefs([
+			ref("work-queue", publicCoordinateId(record.queueId)),
+			ref("work-queue-record", String(record.recordSeq)),
+			...(record.workId === undefined
+				? []
+				: [ref("work-queue-work", publicCoordinateId(record.workId))]),
+			...(record.commandId === undefined
+				? []
+				: [ref("work-queue-command", publicCoordinateId(record.commandId))]),
+			...(leaseId === undefined ? [] : [ref("work-queue-lease", publicCoordinateId(leaseId))]),
+			...copiedPublicRefs(record.sourceRefs, "work-queue-source-ref"),
+		]),
+	);
+}
+
+function policyRefs<T>(record: WorkQueueRecord<T>): readonly SourceRef[] | undefined {
+	if (record.policyRefs === undefined || record.policyRefs.length === 0) return undefined;
+	return canonicalPublicSourceRefs(copiedPublicRefs(record.policyRefs, "work-queue-policy-ref"));
+}
+
+function workQueueScheduleId<T>(
+	record: WorkQueueRecord<T> & { readonly workId: string },
+	part: "admission" | "retry" | "schedule",
+	id: string | number,
+): string {
+	return `workQueue:${publicCoordinateId(record.queueId)}:${publicCoordinateId(record.workId)}:${part}:${publicCoordinateId(String(id))}`;
+}
+
+function workQueueLeaseScheduleId<T>(
+	record: WorkQueueRecord<T> & {
+		readonly workId: string;
+		readonly leaseId: string;
+		readonly recordSeq: number;
+	},
+): string {
+	return `workQueue:${publicCoordinateId(record.queueId)}:${publicCoordinateId(record.workId)}:lease:${publicCoordinateId(record.leaseId)}:expires:${record.recordSeq}`;
+}
+
+function workQueueRecordSubjectId<T>(
+	record: WorkQueueRecord<T> & { readonly workId: string },
+): string {
+	return `${publicCoordinateId(record.queueId)}:${publicCoordinateId(record.workId)}:${record.recordSeq}`;
+}
+
+function copiedPublicRefs(ids: readonly string[] | undefined, kind: string): readonly SourceRef[] {
+	if (ids === undefined || ids.length === 0) return [];
+	const copied = ids
+		.slice(0, MAX_COPIED_PUBLIC_REFS)
+		.map((id) => ref(kind, publicCoordinateId(id)));
+	if (ids.length <= MAX_COPIED_PUBLIC_REFS) return copied;
+	return [
+		...copied,
+		ref(
+			`${kind}-overflow`,
+			`count:${ids.length}:hash:${stableStringHash(stableJsonStringify(ids))}`,
+		),
+	];
+}
+
+function publicCoordinateId(id: string): string {
+	if (id.length <= MAX_PUBLIC_COORDINATE_ID_CHARS && !PRIVATE_COORDINATE_PATTERN.test(id)) {
+		return id;
+	}
+	return `bounded:${stableStringHash(id)}:${id.length}`;
+}
+
+function issueStatus<T>(
+	statusId: string,
+	issues: readonly DataIssue[],
+	record?: WorkQueueRecord<T>,
+	sourceRefs?: readonly SourceRef[],
+): WorkQueueScheduledReadinessStatus {
+	return Object.freeze({
+		kind: "work-queue-scheduled-readiness-status",
+		statusId: `${statusId}:work-queue-scheduled-readiness-status:issue`,
+		...(record?.queueId === undefined ? {} : { queueId: publicCoordinateId(record.queueId) }),
+		...(record?.workId === undefined ? {} : { workId: publicCoordinateId(record.workId) }),
+		...(record?.recordSeq === undefined ? {} : { recordSeq: record.recordSeq }),
+		state: "issue",
+		...(sourceRefs === undefined ? {} : { sourceRefs }),
+		issueCodes: issues.map((issue) => issue.code),
+	} satisfies WorkQueueScheduledReadinessStatus);
+}
+
+function finiteOrUndefined(value: number | undefined): boolean {
+	return value === undefined || Number.isFinite(value);
+}
+
+function scheduleIdentity(schedule: ScheduledReadinessRequested): string {
+	return stableJsonStringify({
+		scheduleId: schedule.scheduleId,
+		subjectRefs: schedule.subjectRefs,
+		readyAtMs: schedule.readyAtMs,
+		deadlineMs: schedule.deadlineMs,
+		reason: schedule.reason,
+		policyRefs: schedule.policyRefs,
+		sourceRefs: schedule.sourceRefs,
+		metadata: schedule.metadata,
+	});
+}
+
+function emitScheduleConflict(
+	ctx: { down: (msgs: readonly ["DATA", WorkQueueScheduledReadinessFact][]) => void },
+	state: WorkQueueScheduledReadinessProjectorState,
+	translated: Extract<TranslatedRecord, { readonly kind: "translated" }>,
+	existing?: ScheduledReadinessRequested,
+): void {
+	const issue = dataIssue(
+		"work-queue-scheduled-readiness-schedule-conflict",
+		"WorkQueue delayed eligibility replayed with conflicting scheduled-readiness material; the first schedule was retained.",
+		{
+			subjectId: translated.schedule.scheduleId,
+			refs: translated.schedule.sourceRefs,
+			details: {
+				existingReadyAtMs: existing?.readyAtMs,
+				incomingReadyAtMs: translated.schedule.readyAtMs,
+				existingDeadlineMs: existing?.deadlineMs,
+				incomingDeadlineMs: translated.schedule.deadlineMs,
+				recordSeq: translated.record.recordSeq,
+				recordKind: translated.record.kind,
+			},
+		},
+	);
+	emitIssue(ctx, state, issue);
+	emitStatus(
+		ctx,
+		state,
+		issueStatus(
+			`${translated.schedule.scheduleId}:conflict:${translated.record.recordSeq}`,
+			[issue],
+			translated.record,
+			translated.schedule.sourceRefs,
+		),
+	);
+}
+
+function emitSchedule(
+	ctx: { down: (msgs: readonly ["DATA", WorkQueueScheduledReadinessFact][]) => void },
+	state: WorkQueueScheduledReadinessProjectorState,
+	schedule: ScheduledReadinessRequested,
+): void {
+	const key = `schedule:${schedule.scheduleId}`;
+	if (state.emittedKeys.has(key)) return;
+	state.emittedKeys.add(key);
+	ctx.down([["DATA", { kind: "readiness-schedule", schedule }]]);
+}
+
+function emitStatus(
+	ctx: { down: (msgs: readonly ["DATA", WorkQueueScheduledReadinessFact][]) => void },
+	state: WorkQueueScheduledReadinessProjectorState,
+	status: WorkQueueScheduledReadinessStatus,
+): void {
+	state.statusById.set(status.statusId, status);
+	const key = `status:${status.statusId}:${(status.issueCodes ?? []).join(",")}`;
+	if (state.emittedKeys.has(key)) return;
+	state.emittedKeys.add(key);
+	ctx.down([["DATA", { kind: "status", status }]]);
+}
+
+function emitIssue(
+	ctx: { down: (msgs: readonly ["DATA", WorkQueueScheduledReadinessFact][]) => void },
+	state: WorkQueueScheduledReadinessProjectorState,
+	issue: DataIssue,
+): void {
+	const key = `${issue.code}:${issue.subjectId ?? ""}:${JSON.stringify(issue.details ?? {})}`;
+	if (state.issueKeys.has(key)) return;
+	state.issueKeys.add(key);
+	ctx.down([["DATA", { kind: "issue", issue }]]);
+}
+
+function emitAudit(
+	ctx: { down: (msgs: readonly ["DATA", WorkQueueScheduledReadinessFact][]) => void },
+	state: WorkQueueScheduledReadinessProjectorState,
+	kind: string,
+	opts: {
+		readonly subjectId: string;
+		readonly sourceRefs?: readonly SourceRef[];
+		readonly metadata?: Record<string, unknown>;
+	},
+): void {
+	state.auditSeq += 1;
+	const metadata = sanitizeGraphVisibleRecord(opts.metadata);
+	ctx.down([
+		[
+			"DATA",
+			{
+				kind: "audit",
+				audit: Object.freeze({
+					id: `work-queue-scheduled-readiness-audit-${state.auditSeq}`,
+					kind,
+					subjectId: opts.subjectId,
+					...(opts.sourceRefs === undefined
+						? {}
+						: { sourceRefs: canonicalPublicSourceRefs(opts.sourceRefs) }),
+					...(metadata === undefined ? {} : { metadata }),
+				} satisfies AgentRuntimeAuditRecord),
+			},
+		],
+	]);
+}
+
+function buildViews(
+	state: WorkQueueScheduledReadinessProjectorState,
+): WorkQueueScheduledReadinessViews {
+	return Object.freeze({
+		schedulesById: new Map(state.schedulesById),
+		statusById: new Map(state.statusById),
+	});
+}
diff --git a/packages/ts/src/orchestration/work-queue.ts b/packages/ts/src/orchestration/work-queue.ts
new file mode 100644
index 00000000..5bb71b47
--- /dev/null
+++ b/packages/ts/src/orchestration/work-queue.ts
@@ -0,0 +1,372 @@
+/**
+ * Optional orchestration-over-workQueue recipe (D349/D353).
+ *
+ * Queue lifecycle remains disposition evidence. This module maps visible
+ * ProcessEffectRequest facts to queue commands and maps terminal queue records
+ * back to graph-visible orchestration evidence/status/issue facts.
+ */
+
+import { type Ctx, depBatch } from "../ctx/types.js";
+import type { DataIssue } from "../data/index.js";
+import type { Graph } from "../graph/graph.js";
+import type { Node } from "../node/node.js";
+import type { ProcessEffectRequest } from "../orchestration/index.js";
+import type { WorkQueueCommand, WorkQueueRecord } from "../work-queue/index.js";
+
+export type {
+	WorkQueueLeaseExpirationCommandBundle,
+	WorkQueueReadinessCandidate,
+	WorkQueueReadinessCandidateKind,
+	WorkQueueReadinessHandoffBundle,
+	WorkQueueReadinessHandoffStatus,
+	WorkQueueReadinessHandoffStatusState,
+	WorkQueueReadinessHandoffViews,
+	WorkQueueScheduledReadinessBundle,
+	WorkQueueScheduledReadinessScheduleKind,
+	WorkQueueScheduledReadinessStatus,
+	WorkQueueScheduledReadinessStatusState,
+	WorkQueueScheduledReadinessViews,
+} from "./work-queue-scheduled-readiness.js";
+export {
+	workQueueLeaseExpirationCommandProjector,
+	workQueueReadinessHandoffProjector,
+	workQueueScheduledReadinessProjector,
+} from "./work-queue-scheduled-readiness.js";
+
+export interface OrchestrationQueuedEffectPayload<TEffect = unknown> {
+	readonly kind: "orchestration-queued-effect";
+	readonly effect: ProcessEffectRequest<TEffect>;
+	readonly idempotencyKey?: string;
+	readonly sourceRefs?: readonly string[];
+	readonly policyRefs?: readonly string[];
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface OrchestrationQueueEvidence {
+	readonly kind: "orchestration-queue-evidence";
+	readonly evidenceId: string;
+	readonly effectId: string;
+	readonly effectType: string;
+	readonly workId: string;
+	readonly queueRecordKind: WorkQueueRecord["kind"];
+	readonly result?: unknown;
+	readonly error?: unknown;
+	readonly recordedAtMs: number;
+}
+
+export interface OrchestrationQueueStatus {
+	readonly kind: "orchestration-queue-status";
+	readonly state: "evidence-recorded" | "mapping-issue";
+	readonly effectId?: string;
+	readonly effectType?: string;
+	readonly workId?: string;
+	readonly queueRecordKind?: WorkQueueRecord["kind"];
+	readonly evidenceId?: string;
+	readonly issues?: readonly DataIssue[];
+}
+
+export interface OrchestrationQueueAuditRecord {
+	readonly kind: "orchestration-queue-audit";
+	readonly seq: number;
+	readonly outcome: "mapped" | "issue";
+	readonly effectId?: string;
+	readonly effectType?: string;
+	readonly workId?: string;
+	readonly queueRecordKind?: WorkQueueRecord["kind"];
+	readonly evidenceId?: string;
+}
+
+export interface OrchestrationWorkQueueRecipeOptions<TEffect = unknown> {
+	readonly name?: string;
+	readonly effectRequests?: Node<ProcessEffectRequest<TEffect>>;
+	readonly records: Node<WorkQueueRecord<OrchestrationQueuedEffectPayload<TEffect>>>;
+}
+
+export interface OrchestrationWorkQueueRecipeBundle<TEffect = unknown> {
+	readonly submitCommands?: Node<WorkQueueCommand<OrchestrationQueuedEffectPayload<TEffect>>>;
+	readonly evidence: Node<OrchestrationQueueEvidence>;
+	readonly status: Node<OrchestrationQueueStatus>;
+	readonly issues: Node<DataIssue>;
+	readonly audit: Node<OrchestrationQueueAuditRecord>;
+}
+
+type OrchestrationQueueFact =
+	| { readonly kind: "evidence"; readonly evidence: OrchestrationQueueEvidence }
+	| { readonly kind: "status"; readonly status: OrchestrationQueueStatus }
+	| { readonly kind: "issue"; readonly issue: DataIssue }
+	| { readonly kind: "audit"; readonly audit: OrchestrationQueueAuditRecord };
+
+interface QueueState<TEffect> {
+	readonly payloads: Map<string, OrchestrationQueuedEffectPayload<TEffect>>;
+	readonly terminalRecords: Set<string>;
+	auditSeq: number;
+}
+
+/** Build the optional D349 orchestration workQueue recipe. */
+export function orchestrationWorkQueueRecipe<TEffect = unknown>(
+	graph: Graph,
+	opts: OrchestrationWorkQueueRecipeOptions<TEffect>,
+): OrchestrationWorkQueueRecipeBundle<TEffect> {
+	const name = opts.name ?? "orchestrationWorkQueue";
+	const submitCommands =
+		opts.effectRequests === undefined
+			? undefined
+			: graph.node<WorkQueueCommand<OrchestrationQueuedEffectPayload<TEffect>>>(
+					[opts.effectRequests],
+					(ctx) => {
+						for (const raw of depBatch(ctx, 0) ?? []) {
+							ctx.down([
+								["DATA", processEffectSubmitCommand(raw as ProcessEffectRequest<TEffect>)],
+							]);
+						}
+					},
+					{
+						name: `${name}/submitCommands`,
+						factory: "orchestrationWorkQueueSubmitCommands",
+						completeWhenDepsComplete: false,
+						errorWhenDepsError: false,
+					},
+				);
+	const runtime = graph.node<OrchestrationQueueFact>(
+		[opts.records],
+		(ctx) => {
+			const state = ctx.state.get<QueueState<TEffect>>() ?? {
+				payloads: new Map(),
+				terminalRecords: new Set(),
+				auditSeq: 0,
+			};
+			for (const raw of depBatch(ctx, 0) ?? []) {
+				reduceRecord(ctx, state, raw as WorkQueueRecord<OrchestrationQueuedEffectPayload<TEffect>>);
+			}
+			ctx.state.set(state);
+		},
+		{
+			name: `${name}/runtime`,
+			factory: "orchestrationWorkQueueRuntime",
+			partial: true,
+			completeWhenDepsComplete: false,
+			errorWhenDepsError: false,
+		},
+	);
+	return {
+		...(submitCommands === undefined ? {} : { submitCommands }),
+		evidence: project(
+			graph,
+			runtime,
+			`${name}/evidence`,
+			"orchestrationWorkQueueEvidence",
+			(fact) => (fact.kind === "evidence" ? fact.evidence : undefined),
+		),
+		status: project(graph, runtime, `${name}/status`, "orchestrationWorkQueueStatus", (fact) =>
+			fact.kind === "status" ? fact.status : undefined,
+		),
+		issues: project(graph, runtime, `${name}/issues`, "orchestrationWorkQueueIssues", (fact) =>
+			fact.kind === "issue" ? fact.issue : undefined,
+		),
+		audit: project(graph, runtime, `${name}/audit`, "orchestrationWorkQueueAudit", (fact) =>
+			fact.kind === "audit" ? fact.audit : undefined,
+		),
+	};
+}
+
+export function processEffectSubmitCommand<TEffect>(
+	effect: ProcessEffectRequest<TEffect>,
+	opts: {
+		readonly workId?: string;
+		readonly commandId?: string;
+		readonly idempotencyKey?: string;
+		readonly sourceRefs?: readonly string[];
+		readonly policyRefs?: readonly string[];
+		readonly metadata?: Record<string, unknown>;
+	} = {},
+): WorkQueueCommand<OrchestrationQueuedEffectPayload<TEffect>> {
+	const payload: OrchestrationQueuedEffectPayload<TEffect> = {
+		kind: "orchestration-queued-effect",
+		effect,
+		idempotencyKey: opts.idempotencyKey ?? effect.id,
+		sourceRefs: opts.sourceRefs,
+		policyRefs: opts.policyRefs,
+		metadata: opts.metadata,
+	};
+	return {
+		kind: "submit",
+		commandId: opts.commandId ?? `${effect.id}:orchestration-work-queue-submit`,
+		workId: opts.workId ?? `process-effect:${effect.id}`,
+		payload,
+		idempotencyKey: opts.idempotencyKey ?? effect.id,
+		sourceRefs: opts.sourceRefs,
+		policyRefs: opts.policyRefs,
+	};
+}
+
+function reduceRecord<TEffect>(
+	ctx: Ctx,
+	state: QueueState<TEffect>,
+	record: WorkQueueRecord<OrchestrationQueuedEffectPayload<TEffect>>,
+): void {
+	if (record.kind === "work-admitted") {
+		if (isQueuedEffectPayload(record.payload)) {
+			state.payloads.set(record.workId, record.payload);
+		} else {
+			emitIssue(ctx, state, record, "orchestration-queue-malformed-payload");
+		}
+		return;
+	}
+	if (!isTerminalEvidenceRecord(record)) return;
+	const key = `${record.kind}:${record.recordSeq}`;
+	if (state.terminalRecords.has(key)) return;
+	state.terminalRecords.add(key);
+	const payload = record.workId === undefined ? undefined : state.payloads.get(record.workId);
+	if (payload === undefined) {
+		emitIssue(ctx, state, record, "orchestration-queue-record-without-payload");
+		return;
+	}
+	const evidence = evidenceFromRecord(record, payload);
+	emit(ctx, { kind: "evidence", evidence });
+	emit(ctx, { kind: "status", status: statusFromEvidence(evidence, payload) });
+	state.auditSeq += 1;
+	emit(ctx, { kind: "audit", audit: auditFromEvidence(state.auditSeq, evidence, payload) });
+}
+
+function isTerminalEvidenceRecord(record: WorkQueueRecord): boolean {
+	return (
+		record.kind === "work-completed" ||
+		record.kind === "attempt-completed" ||
+		record.kind === "work-canceled" ||
+		record.kind === "work-dead-lettered" ||
+		record.kind === "attempt-failed"
+	);
+}
+
+function evidenceFromRecord<TEffect>(
+	record: WorkQueueRecord<OrchestrationQueuedEffectPayload<TEffect>>,
+	payload: OrchestrationQueuedEffectPayload<TEffect>,
+): OrchestrationQueueEvidence {
+	return {
+		kind: "orchestration-queue-evidence",
+		evidenceId: `work-queue:${record.recordSeq}`,
+		effectId: payload.effect.id,
+		effectType: payload.effect.type,
+		workId: record.workId ?? `unknown:${record.recordSeq}`,
+		queueRecordKind: record.kind,
+		result: "result" in record ? record.result : undefined,
+		error: "error" in record ? record.error : undefined,
+		recordedAtMs: record.recordedAtMs,
+	};
+}
+
+function statusFromEvidence<TEffect>(
+	evidence: OrchestrationQueueEvidence,
+	payload: OrchestrationQueuedEffectPayload<TEffect>,
+): OrchestrationQueueStatus {
+	return {
+		kind: "orchestration-queue-status",
+		state: "evidence-recorded",
+		effectId: payload.effect.id,
+		effectType: payload.effect.type,
+		workId: evidence.workId,
+		queueRecordKind: evidence.queueRecordKind,
+		evidenceId: evidence.evidenceId,
+	};
+}
+
+function auditFromEvidence<TEffect>(
+	seq: number,
+	evidence: OrchestrationQueueEvidence,
+	payload: OrchestrationQueuedEffectPayload<TEffect>,
+): OrchestrationQueueAuditRecord {
+	return {
+		kind: "orchestration-queue-audit",
+		seq,
+		outcome: "mapped",
+		effectId: payload.effect.id,
+		effectType: payload.effect.type,
+		workId: evidence.workId,
+		queueRecordKind: evidence.queueRecordKind,
+		evidenceId: evidence.evidenceId,
+	};
+}
+
+function auditFromIssue(
+	seq: number,
+	record: WorkQueueRecord<unknown>,
+): OrchestrationQueueAuditRecord {
+	return {
+		kind: "orchestration-queue-audit",
+		seq,
+		outcome: "issue",
+		workId: record.workId,
+		queueRecordKind: record.kind,
+	};
+}
+
+function project<T>(
+	graph: Graph,
+	runtime: Node<OrchestrationQueueFact>,
+	name: string,
+	factory: string,
+	pick: (fact: OrchestrationQueueFact) => T | undefined,
+): Node<T> {
+	return graph.node<T>(
+		[runtime],
+		(ctx) => {
+			for (const fact of depBatch(ctx, 0) ?? []) {
+				const value = pick(fact as OrchestrationQueueFact);
+				if (value !== undefined) ctx.down([["DATA", value]]);
+			}
+		},
+		{ name, factory, partial: true, completeWhenDepsComplete: false, errorWhenDepsError: false },
+	);
+}
+
+function emit(ctx: Ctx, fact: OrchestrationQueueFact): void {
+	ctx.down([["DATA", fact]]);
+}
+
+function emitIssue(
+	ctx: Ctx,
+	state: QueueState<unknown>,
+	record: WorkQueueRecord<unknown>,
+	code: string,
+): void {
+	const issue = queueIssue(record, code);
+	emit(ctx, { kind: "issue", issue });
+	state.auditSeq += 1;
+	emit(ctx, {
+		kind: "status",
+		status: {
+			kind: "orchestration-queue-status",
+			state: "mapping-issue",
+			workId: record.workId,
+			queueRecordKind: record.kind,
+			issues: [issue],
+		},
+	});
+	emit(ctx, {
+		kind: "audit",
+		audit: auditFromIssue(state.auditSeq, record),
+	});
+}
+
+function queueIssue(record: WorkQueueRecord<unknown>, code: string): DataIssue {
+	return {
+		kind: "issue",
+		code,
+		message: `Orchestration workQueue recipe could not map record '${record.kind}'`,
+		severity: "error",
+		source: "orchestration.workQueue",
+		details: record,
+	};
+}
+
+function isQueuedEffectPayload<TEffect>(
+	value: unknown,
+): value is OrchestrationQueuedEffectPayload<TEffect> {
+	if (!isObjectRecord(value) || value.kind !== "orchestration-queued-effect") return false;
+	const effect = value.effect;
+	return isObjectRecord(effect) && typeof effect.id === "string" && typeof effect.type === "string";
+}
+
+function isObjectRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null;
+}
diff --git a/packages/ts/src/patterns/event-flow.ts b/packages/ts/src/patterns/event-flow.ts
new file mode 100644
index 00000000..cf26fa00
--- /dev/null
+++ b/packages/ts/src/patterns/event-flow.ts
@@ -0,0 +1,585 @@
+/**
+ * Event-flow projector helpers (D326/D329/D331).
+ *
+ * eventFlow consumes declared graph sources that emit EventMessage or
+ * MessageEnvelope<EventMessage>. It records projection facts and high-water over
+ * source coordinates; it does not own topics, subscriptions, cursors, retention,
+ * ack/seek/close, queues, workers, or dead-letter policy.
+ */
+
+import { depBatch } from "../ctx/types.js";
+import type { DataIssue } from "../data/index.js";
+import type { Graph } from "../graph/graph.js";
+import type { EventMessage, MessageEnvelope } from "../messaging/index.js";
+import { eventMessageIssue } from "../messaging/index.js";
+import type { Node } from "../node/node.js";
+
+export interface EventFlowSource<T = unknown> {
+	readonly source: string;
+	readonly node: Node<EventMessage<T> | MessageEnvelope<EventMessage<T>> | unknown>;
+}
+
+export type EventFlowSourceInput<T = unknown> =
+	| Node<EventMessage<T> | MessageEnvelope<EventMessage<T>> | unknown>
+	| EventFlowSource<T>;
+
+export interface EventFlowSourceRef {
+	readonly source: string;
+	readonly topic?: string;
+	readonly seq?: number;
+	readonly messageId?: string;
+	readonly idempotencyKey?: string;
+}
+
+export interface EventFlowRecord<T = unknown> {
+	readonly recordSeq: number;
+	readonly flowId: string;
+	readonly event: EventMessage<T>;
+	readonly source: EventFlowSourceRef;
+	readonly observedAtMs: number;
+	readonly correlationId?: string;
+	readonly causationId?: string;
+}
+
+export interface EventFlowStatus {
+	readonly kind: "recorded" | "rejected" | "projection-ready" | "projection-stale";
+	readonly flowId: string;
+	readonly recordSeq?: number;
+	readonly eventId?: string;
+	readonly eventType?: string;
+	readonly source?: EventFlowSourceRef;
+	readonly issueCode?: string;
+	readonly timestampMs: number;
+}
+
+export interface EventFlowAuditRecord {
+	readonly seq: number;
+	readonly flowId: string;
+	readonly outcome: "recorded" | "rejected";
+	readonly eventId?: string;
+	readonly eventType?: string;
+	readonly issueCode?: string;
+	readonly source?: EventFlowSourceRef;
+	readonly highWater: EventFlowHighWater;
+	readonly timestampMs: number;
+}
+
+export interface EventFlowSourceHighWater {
+	readonly source: string;
+	readonly topic?: string;
+	readonly seq?: number;
+	readonly messageId?: string;
+	readonly recordSeq: number;
+}
+
+export interface EventFlowHighWater {
+	readonly flowId: string;
+	readonly recordSeq: number;
+	readonly auditSeq: number;
+	readonly sources: readonly EventFlowSourceHighWater[];
+}
+
+export interface EventFlowOptions<T = unknown> {
+	readonly flowId?: string;
+	readonly name?: string;
+	readonly sources: readonly EventFlowSourceInput<T>[];
+	readonly now?: () => number;
+}
+
+export interface EventFlowBundle<T = unknown> {
+	readonly records: Node<EventFlowRecord<T>>;
+	readonly status: Node<EventFlowStatus>;
+	readonly issues: Node<DataIssue>;
+	readonly audit: Node<EventFlowAuditRecord>;
+	readonly highWater: Node<EventFlowHighWater>;
+}
+
+export interface EventFlowProjectionFrame<TState> {
+	readonly state: TState;
+	readonly highWater: EventFlowHighWater;
+}
+
+export interface EventFlowProjectionStatus {
+	readonly kind: "projected" | "rejected";
+	readonly projectionId: string;
+	readonly recordSeq?: number;
+	readonly issueCode?: string;
+	readonly timestampMs: number;
+}
+
+export interface EventFlowProjectionOptions<TState, TPayload = unknown> {
+	readonly projectionId?: string;
+	readonly name?: string;
+	readonly initial: TState;
+	readonly reduce: (state: TState, record: EventFlowRecord<TPayload>) => TState;
+	readonly now?: () => number;
+}
+
+export interface EventFlowProjectionBundle<TState> {
+	readonly snapshot: Node<TState>;
+	readonly frames: Node<EventFlowProjectionFrame<TState>>;
+	readonly status: Node<EventFlowProjectionStatus>;
+	readonly issues: Node<DataIssue>;
+	readonly highWater: Node<EventFlowHighWater>;
+}
+
+type EventFlowRuntimeFact<T = unknown> =
+	| { readonly kind: "record"; readonly record: EventFlowRecord<T> }
+	| { readonly kind: "status"; readonly status: EventFlowStatus }
+	| { readonly kind: "issue"; readonly issue: DataIssue }
+	| { readonly kind: "audit"; readonly audit: EventFlowAuditRecord }
+	| { readonly kind: "high-water"; readonly highWater: EventFlowHighWater };
+
+interface EventFlowRuntimeState {
+	recordSeq: number;
+	auditSeq: number;
+	highWater: Map<string, EventFlowSourceHighWater>;
+}
+
+export function eventFlow<T = unknown>(
+	graph: Graph,
+	opts: EventFlowOptions<T>,
+): EventFlowBundle<T> {
+	const name = opts.name ?? opts.flowId ?? "eventFlow";
+	const flowId = opts.flowId ?? name;
+	const now = opts.now ?? Date.now;
+	const sources = normalizeSources(opts.sources);
+	const runtime = graph.node<EventFlowRuntimeFact<T>>(
+		sources.map((source) => source.node),
+		(ctx) => {
+			const state =
+				ctx.state.get<EventFlowRuntimeState>() ??
+				({
+					recordSeq: 0,
+					auditSeq: 0,
+					highWater: new Map(),
+				} satisfies EventFlowRuntimeState);
+			ctx.state.persist(true);
+			for (let i = 0; i < sources.length; i++) {
+				const source = sources[i];
+				for (const raw of depBatch(ctx, i) ?? []) {
+					reduceEventSource(raw, source.source, flowId, now(), state, (fact) =>
+						ctx.down([["DATA", fact as EventFlowRuntimeFact<T>]]),
+					);
+				}
+			}
+			ctx.state.set(state);
+		},
+		{
+			name: `${name}/runtime`,
+			factory: "eventFlowRuntime",
+			meta: { flowId, sources: sources.map((source) => source.source) },
+			partial: true,
+			completeWhenDepsComplete: false,
+			errorWhenDepsError: false,
+		},
+	);
+	return {
+		records: runtimeProjection(graph, runtime, "record", `${name}/records`, "eventFlowRecords"),
+		status: runtimeProjection(graph, runtime, "status", `${name}/status`, "eventFlowStatus"),
+		issues: runtimeProjection(graph, runtime, "issue", `${name}/issues`, "eventFlowIssues"),
+		audit: runtimeProjection(graph, runtime, "audit", `${name}/audit`, "eventFlowAudit"),
+		highWater: runtimeProjection(
+			graph,
+			runtime,
+			"high-water",
+			`${name}/highWater`,
+			"eventFlowHighWater",
+		),
+	};
+}
+
+export function eventFlowProjection<TState, TPayload = unknown>(
+	graph: Graph,
+	flowOrRecords: EventFlowBundle<TPayload> | Node<EventFlowRecord<TPayload>>,
+	opts: EventFlowProjectionOptions<TState, TPayload>,
+): EventFlowProjectionBundle<TState> {
+	const records = isEventFlowBundle(flowOrRecords) ? flowOrRecords.records : flowOrRecords;
+	const name = opts.name ?? opts.projectionId ?? "eventFlowProjection";
+	const projectionId = opts.projectionId ?? name;
+	const now = opts.now ?? Date.now;
+	const runtime = graph.node<
+		| { readonly kind: "frame"; readonly frame: EventFlowProjectionFrame<TState> }
+		| { readonly kind: "status"; readonly status: EventFlowProjectionStatus }
+		| { readonly kind: "issue"; readonly issue: DataIssue }
+		| { readonly kind: "high-water"; readonly highWater: EventFlowHighWater }
+	>(
+		[records],
+		(ctx) => {
+			const state = ctx.state.get<{
+				value: TState;
+				highWater: EventFlowHighWater;
+				sourceHighWater: Map<string, EventFlowSourceHighWater>;
+			}>() ?? {
+				value: opts.initial,
+				highWater: emptyHighWater(projectionId),
+				sourceHighWater: new Map(),
+			};
+			ctx.state.persist(true);
+			for (const raw of depBatch(ctx, 0) ?? []) {
+				const record = raw as EventFlowRecord<TPayload>;
+				try {
+					state.value = opts.reduce(state.value, record);
+					state.highWater = projectionHighWater(projectionId, record, state.sourceHighWater);
+					ctx.down([
+						["DATA", { kind: "frame", frame: { state: state.value, highWater: state.highWater } }],
+						[
+							"DATA",
+							{
+								kind: "status",
+								status: {
+									kind: "projected",
+									projectionId,
+									recordSeq: record.recordSeq,
+									timestampMs: now(),
+								},
+							},
+						],
+						["DATA", { kind: "high-water", highWater: state.highWater }],
+					]);
+				} catch (error) {
+					const issue = dataIssue(
+						"event-flow-projection-threw",
+						error instanceof Error ? error.message : "eventFlowProjection reducer threw",
+						{ projectionId, record },
+					);
+					ctx.down([
+						["DATA", { kind: "issue", issue }],
+						[
+							"DATA",
+							{
+								kind: "status",
+								status: {
+									kind: "rejected",
+									projectionId,
+									recordSeq: record.recordSeq,
+									issueCode: issue.code,
+									timestampMs: now(),
+								},
+							},
+						],
+					]);
+				}
+			}
+			ctx.state.set(state);
+		},
+		{
+			name: `${name}/runtime`,
+			factory: "eventFlowProjectionRuntime",
+			meta: { projectionId },
+			completeWhenDepsComplete: false,
+			errorWhenDepsError: false,
+		},
+	);
+	return {
+		frames: projectionRuntime(
+			graph,
+			runtime,
+			"frame",
+			`${name}/frames`,
+			"eventFlowProjectionFrames",
+		),
+		snapshot: projectionRuntime(
+			graph,
+			runtime,
+			"frame",
+			`${name}/snapshot`,
+			"eventFlowProjectionSnapshot",
+			(fact) => (fact as { readonly frame: EventFlowProjectionFrame<TState> }).frame.state,
+		),
+		status: projectionRuntime(
+			graph,
+			runtime,
+			"status",
+			`${name}/status`,
+			"eventFlowProjectionStatus",
+		),
+		issues: projectionRuntime(
+			graph,
+			runtime,
+			"issue",
+			`${name}/issues`,
+			"eventFlowProjectionIssues",
+		),
+		highWater: projectionRuntime(
+			graph,
+			runtime,
+			"high-water",
+			`${name}/highWater`,
+			"eventFlowProjectionHighWater",
+		),
+	};
+}
+
+function reduceEventSource<T>(
+	raw: unknown,
+	source: string,
+	flowId: string,
+	timestampMs: number,
+	state: EventFlowRuntimeState,
+	emit: (fact: EventFlowRuntimeFact<T>) => void,
+): void {
+	const normalized = normalizeInput(raw, source);
+	if (normalized.issue !== undefined) {
+		const status: EventFlowStatus = {
+			kind: "rejected",
+			flowId,
+			source: normalized.source,
+			issueCode: normalized.issue.code,
+			timestampMs,
+		};
+		const audit = auditRecord(flowId, state, "rejected", timestampMs, {
+			source: normalized.source,
+			issueCode: normalized.issue.code,
+		});
+		emit({ kind: "issue", issue: normalized.issue });
+		emit({ kind: "status", status });
+		emit({ kind: "audit", audit });
+		emit({ kind: "high-water", highWater: highWaterSnapshot(flowId, state) });
+		return;
+	}
+
+	const recordSeq = ++state.recordSeq;
+	const record: EventFlowRecord<T> = {
+		recordSeq,
+		flowId,
+		event: normalized.event as EventMessage<T>,
+		source: normalized.source,
+		observedAtMs: timestampMs,
+		...(normalized.event.correlationId === undefined
+			? {}
+			: { correlationId: normalized.event.correlationId }),
+		...(normalized.event.causationId === undefined
+			? {}
+			: { causationId: normalized.event.causationId }),
+	};
+	state.highWater.set(sourceKey(normalized.source), {
+		source: normalized.source.source,
+		...(normalized.source.topic === undefined ? {} : { topic: normalized.source.topic }),
+		...(normalized.source.seq === undefined ? {} : { seq: normalized.source.seq }),
+		messageId: normalized.event.id,
+		recordSeq,
+	});
+	const audit = auditRecord(flowId, state, "recorded", timestampMs, {
+		source: normalized.source,
+		eventId: normalized.event.id,
+		eventType: normalized.event.type,
+	});
+	const highWater = highWaterSnapshot(flowId, state);
+	const status: EventFlowStatus = {
+		kind: "recorded",
+		flowId,
+		recordSeq,
+		eventId: normalized.event.id,
+		eventType: normalized.event.type,
+		source: normalized.source,
+		timestampMs,
+	};
+	emit({ kind: "record", record });
+	emit({ kind: "status", status });
+	emit({ kind: "audit", audit });
+	emit({ kind: "high-water", highWater });
+}
+
+function normalizeInput(
+	raw: unknown,
+	source: string,
+):
+	| {
+			readonly event: EventMessage;
+			readonly source: EventFlowSourceRef;
+			readonly issue?: undefined;
+	  }
+	| { readonly source: EventFlowSourceRef; readonly issue: DataIssue } {
+	const envelope = messageEnvelopeOf(raw);
+	const value = envelope?.payload ?? raw;
+	const sourceRef: EventFlowSourceRef =
+		envelope === undefined
+			? { source, ...(eventIdOf(value) === undefined ? {} : { messageId: eventIdOf(value) }) }
+			: {
+					source,
+					topic: envelope.topic,
+					seq: envelope.seq,
+					messageId: envelope.payload.id,
+					...(envelope.idempotencyKey === undefined
+						? {}
+						: { idempotencyKey: envelope.idempotencyKey }),
+				};
+	const issue = eventMessageIssue(value);
+	if (issue !== undefined) {
+		return {
+			source: sourceRef,
+			issue: dataIssue(issue.code, issue.message, { source: sourceRef, value }),
+		};
+	}
+	return { event: value as EventMessage, source: sourceRef };
+}
+
+function messageEnvelopeOf(value: unknown): MessageEnvelope<EventMessage> | undefined {
+	if (!isRecord(value)) return undefined;
+	if (
+		typeof value.topic !== "string" ||
+		!Number.isInteger(value.seq) ||
+		typeof value.timestampMs !== "number" ||
+		!("payload" in value)
+	) {
+		return undefined;
+	}
+	const payloadIssue = eventMessageIssue(value.payload);
+	return payloadIssue === undefined
+		? (value as unknown as MessageEnvelope<EventMessage>)
+		: undefined;
+}
+
+function normalizeSources<T>(
+	sources: readonly EventFlowSourceInput<T>[],
+): readonly EventFlowSource[] {
+	if (sources.length === 0) throw new Error("eventFlow: sources must be non-empty");
+	return sources.map((source, index) => {
+		if (isRecord(source) && "node" in source) {
+			if (typeof source.source !== "string" || source.source.length === 0) {
+				throw new Error("eventFlow: source name must be non-empty");
+			}
+			return source as EventFlowSource;
+		}
+		return { source: `source-${index}`, node: source as EventFlowSource["node"] };
+	});
+}
+
+function runtimeProjection<TOut, T>(
+	graph: Graph,
+	runtime: Node<EventFlowRuntimeFact<T>>,
+	kind: EventFlowRuntimeFact<T>["kind"],
+	name: string,
+	factory: string,
+): Node<TOut> {
+	return graph.node<TOut>(
+		[runtime],
+		(ctx) => {
+			for (const fact of depBatch(ctx, 0) ?? []) {
+				const typed = fact as EventFlowRuntimeFact<T>;
+				if (typed.kind === kind) ctx.down([["DATA", valueOfRuntimeFact(typed) as TOut]]);
+			}
+		},
+		{ name, factory, completeWhenDepsComplete: false, errorWhenDepsError: false },
+	);
+}
+
+function projectionRuntime<TOut, TFact extends { readonly kind: string }>(
+	graph: Graph,
+	runtime: Node<TFact>,
+	kind: TFact["kind"],
+	name: string,
+	factory: string,
+	map: (fact: Extract<TFact, { readonly kind: typeof kind }>) => TOut = valueOfRuntimeFact as never,
+): Node<TOut> {
+	return graph.node<TOut>(
+		[runtime],
+		(ctx) => {
+			for (const fact of depBatch(ctx, 0) ?? []) {
+				const typed = fact as TFact;
+				if (typed.kind === kind) ctx.down([["DATA", map(typed as never)]]);
+			}
+		},
+		{ name, factory, completeWhenDepsComplete: false, errorWhenDepsError: false },
+	);
+}
+
+function valueOfRuntimeFact(fact: { readonly kind: string }): unknown {
+	if ("record" in fact) return fact.record;
+	if ("status" in fact) return fact.status;
+	if ("issue" in fact) return fact.issue;
+	if ("audit" in fact) return fact.audit;
+	if ("highWater" in fact) return fact.highWater;
+	if ("frame" in fact) return fact.frame;
+	return undefined;
+}
+
+function auditRecord(
+	flowId: string,
+	state: EventFlowRuntimeState,
+	outcome: "recorded" | "rejected",
+	timestampMs: number,
+	opts: {
+		readonly source?: EventFlowSourceRef;
+		readonly eventId?: string;
+		readonly eventType?: string;
+		readonly issueCode?: string;
+	},
+): EventFlowAuditRecord {
+	return {
+		seq: ++state.auditSeq,
+		flowId,
+		outcome,
+		...(opts.eventId === undefined ? {} : { eventId: opts.eventId }),
+		...(opts.eventType === undefined ? {} : { eventType: opts.eventType }),
+		...(opts.issueCode === undefined ? {} : { issueCode: opts.issueCode }),
+		...(opts.source === undefined ? {} : { source: opts.source }),
+		highWater: highWaterSnapshot(flowId, state),
+		timestampMs,
+	};
+}
+
+function highWaterSnapshot(flowId: string, state: EventFlowRuntimeState): EventFlowHighWater {
+	return {
+		flowId,
+		recordSeq: state.recordSeq,
+		auditSeq: state.auditSeq,
+		sources: [...state.highWater.values()].sort(
+			(a, b) => a.source.localeCompare(b.source) || (a.topic ?? "").localeCompare(b.topic ?? ""),
+		),
+	};
+}
+
+function emptyHighWater(flowId: string): EventFlowHighWater {
+	return { flowId, recordSeq: 0, auditSeq: 0, sources: [] };
+}
+
+function projectionHighWater(
+	flowId: string,
+	record: EventFlowRecord,
+	sourceHighWater: Map<string, EventFlowSourceHighWater>,
+): EventFlowHighWater {
+	sourceHighWater.set(sourceKey(record.source), {
+		source: record.source.source,
+		...(record.source.topic === undefined ? {} : { topic: record.source.topic }),
+		...(record.source.seq === undefined ? {} : { seq: record.source.seq }),
+		messageId: record.event.id,
+		recordSeq: record.recordSeq,
+	});
+	return {
+		flowId,
+		recordSeq: record.recordSeq,
+		auditSeq: 0,
+		sources: [...sourceHighWater.values()].sort(
+			(a, b) => a.source.localeCompare(b.source) || (a.topic ?? "").localeCompare(b.topic ?? ""),
+		),
+	};
+}
+
+function sourceKey(source: EventFlowSourceRef): string {
+	return `${source.source}\u0000${source.topic ?? ""}`;
+}
+
+function eventIdOf(value: unknown): string | undefined {
+	return isRecord(value) && typeof value.id === "string" ? value.id : undefined;
+}
+
+function dataIssue(code: string, message: string, details?: unknown): DataIssue {
+	return {
+		kind: "issue",
+		code,
+		message,
+		severity: "error",
+		source: "eventFlow",
+		...(details === undefined ? {} : { details }),
+	};
+}
+
+function isEventFlowBundle<T>(value: unknown): value is EventFlowBundle<T> {
+	return isRecord(value) && "records" in value && "highWater" in value;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
diff --git a/packages/ts/src/patterns/index.ts b/packages/ts/src/patterns/index.ts
new file mode 100644
index 00000000..be10c461
--- /dev/null
+++ b/packages/ts/src/patterns/index.ts
@@ -0,0 +1,98 @@
+/**
+ * Horizontal reusable graph patterns.
+ *
+ * Former preset material lands here only when it is not a vertical solution
+ * and has been re-derived onto clean-slate APIs.
+ */
+
+export {
+	type EventFlowAuditRecord,
+	type EventFlowBundle,
+	type EventFlowHighWater,
+	type EventFlowOptions,
+	type EventFlowProjectionBundle,
+	type EventFlowProjectionFrame,
+	type EventFlowProjectionOptions,
+	type EventFlowProjectionStatus,
+	type EventFlowRecord,
+	type EventFlowSource,
+	type EventFlowSourceHighWater,
+	type EventFlowSourceInput,
+	type EventFlowSourceRef,
+	type EventFlowStatus,
+	eventFlow,
+	eventFlowProjection,
+} from "./event-flow.js";
+export {
+	type ProfileSummary,
+	type ProfileSummaryNode,
+	profileSummary,
+} from "./inspection.js";
+export {
+	type AdmissionFilter,
+	type AdmissionScore3DOptions,
+	type AdmissionScoredOptions,
+	type AdmissionScores,
+	type AdmissionThresholds,
+	admissionFilter3D,
+	admissionScored,
+	type CollectionEntry,
+	type CollectionScoreFn,
+	cosineSimilarity,
+	type DecayPolicy,
+	type FactId,
+	type FactStore,
+	filterMemoryFragments,
+	isMemoryFragment,
+	type KnowledgeAssertion,
+	type KnowledgeAssertionObject,
+	type KnowledgeAssertionStrictJsonValue,
+	type KnowledgeAssertionSubject,
+	type MemoryAnswer,
+	type MemoryFragment,
+	type MemoryFragmentValidation,
+	type MemoryQuery,
+	memoryFragmentMatchesQuery,
+	memoryFragmentValidAt,
+	type OutcomeSignal,
+	type RankedCollectionEntry,
+	type RetrievalEntry,
+	type RetrievalQuery,
+	type RetrievalTrace,
+	type ScoringPolicy,
+	type ShardByTenantConfig,
+	type ShardByTenantOptions,
+	type ShardKey,
+	type StoreReadHandle,
+	shardByTenant,
+	type VectorSearchResult,
+	validateMemoryFragment,
+} from "./semantic-memory.js";
+export {
+	type KnowledgeGraphCursor,
+	type KnowledgeGraphEntity,
+	type KnowledgeGraphError,
+	type KnowledgeGraphErrorCode,
+	type KnowledgeGraphIndex,
+	type KnowledgeGraphPolicy,
+	type KnowledgeGraphReducerBundle,
+	type KnowledgeGraphReducerBundleOptions,
+	type KnowledgeGraphRelation,
+	type KnowledgeGraphSnapshot,
+	type KnowledgeGraphStatus,
+	type KnowledgeGraphStatusState,
+	type KnowledgeGraphTopic,
+	knowledgeGraphReducerBundle,
+	type MemoryRetrievalBundle,
+	type MemoryRetrievalBundleOptions,
+	type MemoryRetrievalCursor,
+	type MemoryRetrievalError,
+	type MemoryRetrievalErrorCode,
+	type MemoryRetrievalFact,
+	type MemoryRetrievalIndex,
+	type MemoryRetrievalQuery,
+	type MemoryRetrievalSnapshot,
+	type MemoryRetrievalStatus,
+	type MemoryRetrievalStatusState,
+	memoryRetrievalBundle,
+} from "./semantic-memory-graph.js";
diff --git a/packages/ts/src/patterns/inspection.ts b/packages/ts/src/patterns/inspection.ts
new file mode 100644
index 00000000..9637fa5a
--- /dev/null
+++ b/packages/ts/src/patterns/inspection.ts
@@ -0,0 +1,59 @@
+/**
+ * Horizontal inspection patterns re-derived from old presets (B62 / D125).
+ *
+ * These helpers compose the clean-slate graph inspection egresses. They do not
+ * add graph nodes, hidden subscriptions, policy gates, or storage ownership.
+ */
+
+import type { Graph } from "../graph/graph.js";
+import type { NodeProfile } from "../graph/inspect.js";
+
+export interface ProfileSummaryNode {
+	path: string;
+	invokes: number;
+	totalDurationNs: number;
+	lastDurationNs: number;
+	status: NodeProfile["status"];
+}
+
+export interface ProfileSummary {
+	/** Number of nodes in describe(), including nodes with zero invokes. */
+	nodeCount: number;
+	totalInvokes: number;
+	byStatus: Partial<Record<NodeProfile["status"], number>>;
+	/** Nodes sorted by invokes desc, then path asc. */
+	hotNodes: ProfileSummaryNode[];
+}
+
+/**
+ * Summarize an opt-in Graph.profile() snapshot while keeping describe() as the
+ * source of node cardinality. No counters are stored on nodes (R-profile).
+ */
+export function profileSummary(graph: Graph, opts: { limit?: number } = {}): ProfileSummary {
+	const profile = graph.profile();
+	const described = graph.describe();
+	const nodeIds = new Set(described.nodes.map((node) => node.id));
+	for (const id of Object.keys(profile.nodes)) nodeIds.add(id);
+
+	const byStatus: Partial<Record<NodeProfile["status"], number>> = {};
+	const hotNodes: ProfileSummaryNode[] = [];
+	for (const path of [...nodeIds].sort()) {
+		const nodeProfile = profile.nodes[path];
+		if (nodeProfile === undefined) continue;
+		byStatus[nodeProfile.status] = (byStatus[nodeProfile.status] ?? 0) + 1;
+		hotNodes.push({
+			path,
+			invokes: nodeProfile.invokes,
+			totalDurationNs: nodeProfile.totalDurationNs,
+			lastDurationNs: nodeProfile.lastDurationNs,
+			status: nodeProfile.status,
+		});
+	}
+	hotNodes.sort((a, b) => b.invokes - a.invokes || a.path.localeCompare(b.path));
+	return {
+		nodeCount: nodeIds.size,
+		totalInvokes: profile.totalInvokes,
+		byStatus,
+		hotNodes: hotNodes.slice(0, opts.limit ?? hotNodes.length),
+	};
+}
diff --git a/packages/ts/src/patterns/semantic-memory-graph-types.ts b/packages/ts/src/patterns/semantic-memory-graph-types.ts
new file mode 100644
index 00000000..c18afed8
--- /dev/null
+++ b/packages/ts/src/patterns/semantic-memory-graph-types.ts
@@ -0,0 +1,186 @@
+import type { Node } from "../node/node.js";
+import type {
+	FactId,
+	KnowledgeAssertion,
+	KnowledgeAssertionObject,
+	KnowledgeAssertionSubject,
+	MemoryAnswer,
+	MemoryFragment,
+	MemoryQuery,
+} from "./semantic-memory.js";
+
+/** Query shape for the first graph-visible retrieval bundle. */
+export interface MemoryRetrievalQuery extends MemoryQuery {
+	/** Optional dense embedding used only for deterministic in-memory ranking. */
+	readonly vector?: readonly number[];
+}
+
+export interface MemoryRetrievalCursor {
+	readonly evaluation: number;
+	readonly validFragments: number;
+	readonly invalidFragments: number;
+	readonly resultCount: number;
+}
+
+export type MemoryRetrievalStatusState = "ready" | "empty" | "partial" | "error";
+
+export interface MemoryRetrievalStatus {
+	readonly state: MemoryRetrievalStatusState;
+	readonly query: MemoryRetrievalQuery;
+	readonly cursor: MemoryRetrievalCursor;
+}
+
+export interface MemoryRetrievalIndex<T = unknown> {
+	readonly ids: readonly FactId[];
+	readonly byId: Readonly<Record<FactId, MemoryFragment<T>>>;
+	readonly cursor: MemoryRetrievalCursor;
+}
+
+export type MemoryRetrievalErrorCode =
+	| "duplicate-fragment-id"
+	| "invalid-fragments-input"
+	| "invalid-fragment"
+	| "invalid-query"
+	| "invalid-query-vector";
+
+export interface MemoryRetrievalError {
+	readonly code: MemoryRetrievalErrorCode;
+	readonly message: string;
+	readonly index?: number;
+	readonly fragment?: unknown;
+	readonly validationErrors?: readonly string[];
+	readonly cursor: MemoryRetrievalCursor;
+}
+
+export interface MemoryRetrievalSnapshot<T = unknown> {
+	readonly fragments: readonly MemoryFragment<T>[];
+	readonly indexed: MemoryRetrievalIndex<T>;
+	readonly ranked: MemoryAnswer<T>;
+	readonly status: MemoryRetrievalStatus;
+	readonly errors: readonly MemoryRetrievalError[];
+	readonly cursor: MemoryRetrievalCursor;
+}
+
+export type MemoryRetrievalFact<T = unknown> = MemoryRetrievalSnapshot<T>;
+
+export interface KnowledgeGraphEntity {
+	readonly id: FactId;
+	readonly type?: string;
+	readonly assertionIds: readonly FactId[];
+	readonly subjectAssertionIds: readonly FactId[];
+	readonly objectAssertionIds: readonly FactId[];
+}
+
+export interface KnowledgeGraphRelation {
+	readonly assertionId: FactId;
+	readonly subject: KnowledgeAssertionSubject;
+	readonly predicate: string;
+	readonly object: KnowledgeAssertionObject;
+	readonly confidence?: number;
+	readonly sources: readonly FactId[];
+	readonly provenance?: string;
+}
+
+export interface KnowledgeGraphTopic {
+	readonly predicate: string;
+	readonly assertionIds: readonly FactId[];
+	readonly entityIds: readonly FactId[];
+}
+
+export interface KnowledgeGraphIndex {
+	readonly assertionIds: readonly FactId[];
+	readonly entityIds: readonly FactId[];
+	readonly relationIds: readonly FactId[];
+	readonly predicates: readonly string[];
+}
+
+export interface KnowledgeGraphPolicy {
+	readonly allowedPredicates?: readonly string[];
+	readonly requireEntityTypes?: boolean;
+}
+
+export interface KnowledgeGraphCursor {
+	readonly evaluation: number;
+	readonly validAssertions: number;
+	readonly invalidAssertions: number;
+	readonly entityCount: number;
+	readonly relationCount: number;
+	readonly predicateCount: number;
+}
+
+export type KnowledgeGraphStatusState = "ready" | "empty" | "partial" | "error";
+
+export interface KnowledgeGraphStatus {
+	readonly state: KnowledgeGraphStatusState;
+	readonly cursor: KnowledgeGraphCursor;
+}
+
+export type KnowledgeGraphErrorCode =
+	| "invalid-assertions-input"
+	| "invalid-assertion"
+	| "duplicate-assertion-id"
+	| "invalid-policy"
+	| "policy-conflict";
+
+export interface KnowledgeGraphError {
+	readonly code: KnowledgeGraphErrorCode;
+	readonly message: string;
+	readonly index?: number;
+	readonly assertionId?: FactId;
+	readonly assertion?: unknown;
+	readonly validationErrors?: readonly string[];
+	readonly cursor: KnowledgeGraphCursor;
+}
+
+export interface KnowledgeGraphSnapshot {
+	readonly assertions: readonly KnowledgeAssertion[];
+	readonly entities: readonly KnowledgeGraphEntity[];
+	readonly relations: readonly KnowledgeGraphRelation[];
+	readonly topics: readonly KnowledgeGraphTopic[];
+	readonly index: KnowledgeGraphIndex;
+	readonly status: KnowledgeGraphStatus;
+	readonly errors: readonly KnowledgeGraphError[];
+	readonly cursor: KnowledgeGraphCursor;
+}
+
+export interface KnowledgeGraphReducerBundle {
+	readonly input: {
+		readonly assertions: Node<readonly unknown[]>;
+		readonly policy?: Node<KnowledgeGraphPolicy>;
+	};
+	readonly snapshot: Node<KnowledgeGraphSnapshot>;
+	readonly assertions: Node<readonly KnowledgeAssertion[]>;
+	readonly entities: Node<readonly KnowledgeGraphEntity[]>;
+	readonly relations: Node<readonly KnowledgeGraphRelation[]>;
+	readonly topics: Node<readonly KnowledgeGraphTopic[]>;
+	readonly index: Node<KnowledgeGraphIndex>;
+	readonly status: Node<KnowledgeGraphStatus>;
+	readonly errors: Node<readonly KnowledgeGraphError[]>;
+	readonly cursor: Node<KnowledgeGraphCursor>;
+}
+
+export interface KnowledgeGraphReducerBundleOptions {
+	readonly name?: string;
+	readonly assertions: Node<readonly unknown[]>;
+	readonly policy?: Node<KnowledgeGraphPolicy>;
+}
+
+export interface MemoryRetrievalBundle<T = unknown> {
+	readonly input: {
+		readonly fragments: Node<readonly unknown[]>;
+		readonly query: Node<MemoryRetrievalQuery>;
+	};
+	readonly snapshot: Node<MemoryRetrievalSnapshot<T>>;
+	readonly fragments: Node<readonly MemoryFragment<T>[]>;
+	readonly indexed: Node<MemoryRetrievalIndex<T>>;
+	readonly ranked: Node<MemoryAnswer<T>>;
+	readonly status: Node<MemoryRetrievalStatus>;
+	readonly errors: Node<readonly MemoryRetrievalError[]>;
+	readonly cursor: Node<MemoryRetrievalCursor>;
+}
+
+export interface MemoryRetrievalBundleOptions {
+	readonly name?: string;
+	readonly fragments: Node<readonly unknown[]>;
+	readonly query: Node<MemoryRetrievalQuery>;
+}
diff --git a/packages/ts/src/patterns/semantic-memory-graph-utils.ts b/packages/ts/src/patterns/semantic-memory-graph-utils.ts
new file mode 100644
index 00000000..1d175170
--- /dev/null
+++ b/packages/ts/src/patterns/semantic-memory-graph-utils.ts
@@ -0,0 +1,669 @@
+/**
+ * Graph-visible semantic-memory retrieval patterns.
+ *
+ * D158 allows horizontal semantic-memory patterns when they are ordinary graph
+ * nodes with declared deps and graph-visible facts. This file intentionally
+ * owns no storage restore/hydration, scheduler, hidden subscription, vector DB,
+ * retention loop, consolidation loop, Graph subclass, or protocol behavior.
+ */
+
+import {
+	cosineSimilarity,
+	type FactId,
+	filterMemoryFragments,
+	type KnowledgeAssertion,
+	type KnowledgeAssertionObject,
+	type KnowledgeAssertionSubject,
+	type MemoryFragment,
+	memoryFragmentMatchesQuery,
+	validateMemoryFragment,
+} from "./semantic-memory.js";
+import type {
+	KnowledgeGraphEntity,
+	KnowledgeGraphError,
+	KnowledgeGraphIndex,
+	KnowledgeGraphPolicy,
+	KnowledgeGraphRelation,
+	KnowledgeGraphTopic,
+	MemoryRetrievalError,
+	MemoryRetrievalQuery,
+	MemoryRetrievalStatusState,
+} from "./semantic-memory-graph-types.js";
+
+interface MemoryRetrievalQueryValidation {
+	readonly ok: boolean;
+	readonly query: MemoryRetrievalQuery;
+	readonly errors: readonly Omit<MemoryRetrievalError, "cursor">[];
+}
+
+interface FragmentValidationResult<T> {
+	readonly fragment?: MemoryFragment<T>;
+	readonly error?: Omit<MemoryRetrievalError, "cursor">;
+}
+
+export function validateKnowledgeGraphPolicy(value: unknown): {
+	readonly policy?: KnowledgeGraphPolicy;
+	readonly errors: readonly Omit<KnowledgeGraphError, "cursor">[];
+} {
+	if (value === undefined) return { policy: undefined, errors: [] };
+	if (!isPlainObject(value)) {
+		return {
+			errors: [
+				{
+					code: "invalid-policy",
+					message: "knowledgeGraphReducerBundle: policy must be an object",
+					assertion: value,
+				},
+			],
+		};
+	}
+	const errors: string[] = [];
+	const policy = value as Partial<KnowledgeGraphPolicy>;
+	if (
+		policy.allowedPredicates !== undefined &&
+		!isDenseArrayOf(policy.allowedPredicates, (item): item is string => typeof item === "string")
+	) {
+		errors.push("allowedPredicates must be a readonly string array");
+	}
+	if (policy.requireEntityTypes !== undefined && typeof policy.requireEntityTypes !== "boolean") {
+		errors.push("requireEntityTypes must be a boolean when present");
+	}
+	if (errors.length > 0) {
+		return {
+			errors: [
+				{
+					code: "invalid-policy",
+					message: "knowledgeGraphReducerBundle: policy is invalid",
+					assertion: value,
+					validationErrors: Object.freeze(errors),
+				},
+			],
+		};
+	}
+	return {
+		policy: Object.freeze({
+			...(policy.allowedPredicates === undefined
+				? {}
+				: { allowedPredicates: Object.freeze([...policy.allowedPredicates]) }),
+			...(policy.requireEntityTypes === undefined
+				? {}
+				: { requireEntityTypes: policy.requireEntityTypes }),
+		}),
+		errors: [],
+	};
+}
+
+export function reduceKnowledgeAssertions(
+	value: unknown,
+	policy?: KnowledgeGraphPolicy,
+): {
+	readonly assertions: readonly KnowledgeAssertion[];
+	readonly entities: readonly KnowledgeGraphEntity[];
+	readonly relations: readonly KnowledgeGraphRelation[];
+	readonly topics: readonly KnowledgeGraphTopic[];
+	readonly index: KnowledgeGraphIndex;
+	readonly errors: readonly Omit<KnowledgeGraphError, "cursor">[];
+	readonly invalidAssertions: number;
+} {
+	const assertions: KnowledgeAssertion[] = [];
+	const errors: Omit<KnowledgeGraphError, "cursor">[] = [];
+	const seenAssertions = new Set<FactId>();
+	if (!Array.isArray(value)) {
+		return {
+			assertions,
+			entities: [],
+			relations: [],
+			topics: [],
+			index: emptyKnowledgeGraphIndex(),
+			errors: [
+				{
+					code: "invalid-assertions-input",
+					message: "knowledgeGraphReducerBundle: assertions input must be an array",
+					assertion: value,
+				},
+			],
+			invalidAssertions: 0,
+		};
+	}
+	const length = safeArrayLength(value);
+	if (length === undefined) {
+		return {
+			assertions,
+			entities: [],
+			relations: [],
+			topics: [],
+			index: emptyKnowledgeGraphIndex(),
+			errors: [
+				{
+					code: "invalid-assertions-input",
+					message: "knowledgeGraphReducerBundle: assertions input length could not be read",
+					assertion: value,
+				},
+			],
+			invalidAssertions: 0,
+		};
+	}
+	for (let i = 0; i < length; i += 1) {
+		const result = validateKnowledgeAssertion(value[i], i, policy);
+		if (result.error !== undefined) {
+			errors.push(result.error);
+			continue;
+		}
+		const assertion = result.assertion as KnowledgeAssertion;
+		if (seenAssertions.has(assertion.id)) {
+			errors.push({
+				code: "duplicate-assertion-id",
+				message: "knowledgeGraphReducerBundle: duplicate assertion id",
+				index: i,
+				assertionId: assertion.id,
+				assertion,
+				validationErrors: Object.freeze([`duplicate assertion id '${assertion.id}'`]),
+			});
+			continue;
+		}
+		seenAssertions.add(assertion.id);
+		assertions.push(assertion);
+	}
+	const materialized = materializeKnowledgeGraph(assertions);
+	return {
+		assertions: Object.freeze(assertions),
+		...materialized,
+		errors,
+		invalidAssertions: errors.filter((error) => error.code !== "invalid-policy").length,
+	};
+}
+
+function validateKnowledgeAssertion(
+	value: unknown,
+	index: number,
+	policy?: KnowledgeGraphPolicy,
+): {
+	readonly assertion?: KnowledgeAssertion;
+	readonly error?: Omit<KnowledgeGraphError, "cursor">;
+} {
+	if (!isPlainObject(value)) {
+		return invalidKnowledgeAssertion(index, value, ["assertion must be an object"]);
+	}
+	const raw = value as Partial<KnowledgeAssertion>;
+	const errors: string[] = [];
+	if (!isNonEmptyString(raw.id)) errors.push("id must be a non-empty string");
+	if (!isKnowledgeSubject(raw.subject)) errors.push("subject.id must be a non-empty string");
+	if (!isNonEmptyString(raw.predicate)) errors.push("predicate must be a non-empty string");
+	if (!isKnowledgeObject(raw.object)) errors.push("object shape is invalid");
+	if (
+		raw.confidence !== undefined &&
+		(!Number.isFinite(raw.confidence) || raw.confidence < 0 || raw.confidence > 1)
+	) {
+		errors.push("confidence must be a finite number in [0, 1] when present");
+	}
+	if (raw.sources !== undefined && !isDenseArrayOf(raw.sources, isNonEmptyString)) {
+		errors.push("sources must be a readonly non-empty string array when present");
+	}
+	if (
+		policy?.allowedPredicates !== undefined &&
+		!policy.allowedPredicates.includes(raw.predicate ?? "")
+	) {
+		errors.push(`predicate '${String(raw.predicate)}' is not allowed by policy`);
+	}
+	if (policy?.requireEntityTypes === true) {
+		if (isKnowledgeSubject(raw.subject) && raw.subject.type === undefined) {
+			errors.push("subject.type is required by policy");
+		}
+		if (
+			isKnowledgeObject(raw.object) &&
+			raw.object.kind === "entity" &&
+			raw.object.type === undefined
+		) {
+			errors.push("object.type is required by policy for entity objects");
+		}
+	}
+	if (errors.length > 0) {
+		return invalidKnowledgeAssertion(index, value, errors, raw.id);
+	}
+	return {
+		assertion: Object.freeze({
+			id: raw.id as FactId,
+			...(raw.recordId === undefined ? {} : { recordId: raw.recordId }),
+			...(raw.fragmentId === undefined ? {} : { fragmentId: raw.fragmentId }),
+			subject: snapshotSubject(raw.subject as KnowledgeAssertionSubject),
+			predicate: raw.predicate as string,
+			object: snapshotObject(raw.object as KnowledgeAssertionObject),
+			...(raw.confidence === undefined ? {} : { confidence: raw.confidence }),
+			sources: Object.freeze([...(raw.sources ?? [])]),
+			...(raw.provenance === undefined ? {} : { provenance: raw.provenance }),
+		}),
+	};
+}
+
+function invalidKnowledgeAssertion(
+	index: number,
+	assertion: unknown,
+	validationErrors: readonly string[],
+	assertionId?: unknown,
+): { readonly error: Omit<KnowledgeGraphError, "cursor"> } {
+	return {
+		error: {
+			code: "invalid-assertion",
+			message: "knowledgeGraphReducerBundle: assertion is invalid",
+			index,
+			assertionId: typeof assertionId === "string" ? assertionId : undefined,
+			assertion,
+			validationErrors: Object.freeze([...validationErrors]),
+		},
+	};
+}
+
+function materializeKnowledgeGraph(assertions: readonly KnowledgeAssertion[]): {
+	readonly entities: readonly KnowledgeGraphEntity[];
+	readonly relations: readonly KnowledgeGraphRelation[];
+	readonly topics: readonly KnowledgeGraphTopic[];
+	readonly index: KnowledgeGraphIndex;
+} {
+	const entityAssertions = new Map<
+		FactId,
+		{
+			type?: string;
+			assertionIds: Set<FactId>;
+			subjectAssertionIds: Set<FactId>;
+			objectAssertionIds: Set<FactId>;
+		}
+	>();
+	const topics = new Map<FactId, { assertionIds: Set<FactId>; entityIds: Set<FactId> }>();
+	const relations: KnowledgeGraphRelation[] = [];
+	for (const assertion of assertions) {
+		const subject = touchEntity(entityAssertions, assertion.subject.id, assertion.subject.type);
+		subject.assertionIds.add(assertion.id);
+		subject.subjectAssertionIds.add(assertion.id);
+		let topic = topics.get(assertion.predicate);
+		if (topic === undefined) {
+			topic = { assertionIds: new Set(), entityIds: new Set() };
+			topics.set(assertion.predicate, topic);
+		}
+		topic.assertionIds.add(assertion.id);
+		topic.entityIds.add(assertion.subject.id);
+		if (assertion.object.kind === "entity") {
+			const object = touchEntity(entityAssertions, assertion.object.id, assertion.object.type);
+			object.assertionIds.add(assertion.id);
+			object.objectAssertionIds.add(assertion.id);
+			topic.entityIds.add(assertion.object.id);
+		}
+		relations.push(
+			Object.freeze({
+				assertionId: assertion.id,
+				subject: assertion.subject,
+				predicate: assertion.predicate,
+				object: assertion.object,
+				...(assertion.confidence === undefined ? {} : { confidence: assertion.confidence }),
+				sources: Object.freeze([...(assertion.sources ?? [])]),
+				...(assertion.provenance === undefined ? {} : { provenance: assertion.provenance }),
+			}),
+		);
+	}
+	const entities = [...entityAssertions.entries()].map(([id, entity]) =>
+		Object.freeze({
+			id,
+			...(entity.type === undefined ? {} : { type: entity.type }),
+			assertionIds: freezeSortedSet(entity.assertionIds),
+			subjectAssertionIds: freezeSortedSet(entity.subjectAssertionIds),
+			objectAssertionIds: freezeSortedSet(entity.objectAssertionIds),
+		}),
+	);
+	entities.sort((a, b) => compareString(a.id, b.id));
+	relations.sort((a, b) => compareString(a.assertionId, b.assertionId));
+	const topicFacts = [...topics.entries()].map(([predicate, topic]) =>
+		Object.freeze({
+			predicate,
+			assertionIds: freezeSortedSet(topic.assertionIds),
+			entityIds: freezeSortedSet(topic.entityIds),
+		}),
+	);
+	topicFacts.sort((a, b) => compareString(a.predicate, b.predicate));
+	const index: KnowledgeGraphIndex = Object.freeze({
+		assertionIds: Object.freeze(assertions.map((assertion) => assertion.id).sort(compareString)),
+		entityIds: Object.freeze(entities.map((entity) => entity.id)),
+		relationIds: Object.freeze(relations.map((relation) => relation.assertionId)),
+		predicates: Object.freeze(topicFacts.map((topic) => topic.predicate)),
+	});
+	return {
+		entities: Object.freeze(entities),
+		relations: Object.freeze(relations),
+		topics: Object.freeze(topicFacts),
+		index,
+	};
+}
+
+function touchEntity(
+	entities: Map<
+		FactId,
+		{
+			type?: string;
+			assertionIds: Set<FactId>;
+			subjectAssertionIds: Set<FactId>;
+			objectAssertionIds: Set<FactId>;
+		}
+	>,
+	id: FactId,
+	type?: string,
+) {
+	let entity = entities.get(id);
+	if (entity === undefined) {
+		entity = {
+			...(type === undefined ? {} : { type }),
+			assertionIds: new Set(),
+			subjectAssertionIds: new Set(),
+			objectAssertionIds: new Set(),
+		};
+		entities.set(id, entity);
+	} else if (entity.type === undefined && type !== undefined) {
+		entity.type = type;
+	}
+	return entity;
+}
+
+function emptyKnowledgeGraphIndex(): KnowledgeGraphIndex {
+	return Object.freeze({
+		assertionIds: Object.freeze([]),
+		entityIds: Object.freeze([]),
+		relationIds: Object.freeze([]),
+		predicates: Object.freeze([]),
+	});
+}
+
+function snapshotSubject(subject: KnowledgeAssertionSubject): KnowledgeAssertionSubject {
+	return Object.freeze({
+		id: subject.id,
+		...(subject.type === undefined ? {} : { type: subject.type }),
+	});
+}
+
+function snapshotObject(object: KnowledgeAssertionObject): KnowledgeAssertionObject {
+	return object.kind === "entity"
+		? Object.freeze({
+				kind: "entity",
+				id: object.id,
+				...(object.type === undefined ? {} : { type: object.type }),
+			})
+		: Object.freeze({
+				kind: "value",
+				value: object.value,
+				...(object.valueType === undefined ? {} : { valueType: object.valueType }),
+			});
+}
+
+function isKnowledgeSubject(value: unknown): value is KnowledgeAssertionSubject {
+	return (
+		isPlainObject(value) &&
+		isNonEmptyString(value.id) &&
+		(value.type === undefined || isNonEmptyString(value.type))
+	);
+}
+
+function isKnowledgeObject(value: unknown): value is KnowledgeAssertionObject {
+	if (!isPlainObject(value)) return false;
+	if (value.kind === "entity") {
+		return isNonEmptyString(value.id) && (value.type === undefined || isNonEmptyString(value.type));
+	}
+	if (value.kind !== "value") return false;
+	return (
+		isStrictJsonValue(value.value) &&
+		(value.valueType === undefined || isNonEmptyString(value.valueType))
+	);
+}
+
+function isStrictJsonValue(value: unknown): boolean {
+	if (value === null || typeof value === "string" || typeof value === "boolean") return true;
+	if (typeof value === "number") return Number.isFinite(value);
+	if (Array.isArray(value)) {
+		for (let i = 0; i < value.length; i += 1) {
+			if (!Object.hasOwn(value, i) || !isStrictJsonValue(value[i])) return false;
+		}
+		return true;
+	}
+	if (!isPlainObject(value)) return false;
+	for (const key of Object.keys(value)) {
+		if (!isStrictJsonValue(value[key])) return false;
+	}
+	return Object.getOwnPropertySymbols(value).length === 0;
+}
+
+function freezeSortedSet(value: ReadonlySet<FactId>): readonly FactId[] {
+	return Object.freeze([...value].sort(compareString));
+}
+
+export function rankFragments<T>(
+	fragments: readonly MemoryFragment<T>[],
+	query: MemoryRetrievalQuery,
+): readonly MemoryFragment<T>[] {
+	if (query.vector === undefined) return filterMemoryFragments(fragments, query);
+	const ranked = fragments.filter((fragment) => memoryFragmentMatchesQuery(fragment, query));
+	ranked.sort((a, b) => {
+		const vectorDelta = vectorScore(b, query) - vectorScore(a, query);
+		if (vectorDelta !== 0) return vectorDelta;
+		const confidenceDelta = b.confidence - a.confidence;
+		if (confidenceDelta !== 0) return confidenceDelta;
+		return compareBigIntDesc(a.tNs, b.tNs);
+	});
+	return query.limit === undefined ? ranked : ranked.slice(0, Math.max(0, query.limit));
+}
+
+function vectorScore(fragment: MemoryFragment, query: MemoryRetrievalQuery): number {
+	if (query.vector === undefined || fragment.embedding === undefined) return 0;
+	return cosineSimilarity(query.vector, fragment.embedding);
+}
+
+export function statusState(
+	errors: readonly Omit<MemoryRetrievalError, "cursor">[],
+	resultCount: number,
+): MemoryRetrievalStatusState {
+	if (errors.some((error) => !isRecoverableFragmentError(error))) return "error";
+	if (errors.length > 0) return "partial";
+	return resultCount > 0 ? "ready" : "empty";
+}
+
+export function isRecoverableFragmentError(error: Omit<MemoryRetrievalError, "cursor">): boolean {
+	return error.code === "invalid-fragment" || error.code === "duplicate-fragment-id";
+}
+
+export function indexById<T>(
+	fragments: readonly MemoryFragment<T>[],
+): Readonly<Record<FactId, MemoryFragment<T>>> {
+	const byId = Object.create(null) as Record<FactId, MemoryFragment<T>>;
+	for (const fragment of fragments) byId[fragment.id] = fragment;
+	return Object.freeze(byId);
+}
+
+function isFiniteVector(value: unknown): value is readonly number[] {
+	if (!Array.isArray(value)) return false;
+	for (let i = 0; i < value.length; i += 1) {
+		if (!Object.hasOwn(value, i) || !Number.isFinite(value[i])) return false;
+	}
+	return true;
+}
+
+export function validateMemoryRetrievalQuery(value: unknown): MemoryRetrievalQueryValidation {
+	try {
+		return validateMemoryRetrievalQueryInner(value);
+	} catch (error) {
+		return {
+			ok: false,
+			query: {},
+			errors: [
+				{
+					code: "invalid-query",
+					message: `memoryRetrievalBundle: query access failed: ${errorMessage(error)}`,
+					fragment: value,
+				},
+			],
+		};
+	}
+}
+
+function validateMemoryRetrievalQueryInner(value: unknown): MemoryRetrievalQueryValidation {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) {
+		return invalidQuery(value, "memoryRetrievalBundle: query must be an object");
+	}
+	const query = value as Partial<MemoryRetrievalQuery>;
+	const errors: Omit<MemoryRetrievalError, "cursor">[] = [];
+	if (
+		query.tags !== undefined &&
+		!isDenseArrayOf(query.tags, (tag): tag is string => typeof tag === "string")
+	) {
+		errors.push({
+			code: "invalid-query",
+			message: "memoryRetrievalBundle: query.tags must be a readonly string array",
+			fragment: value,
+			validationErrors: ["tags must be a readonly string array"],
+		});
+	}
+	if (query.asOf !== undefined && typeof query.asOf !== "bigint") {
+		errors.push({
+			code: "invalid-query",
+			message: "memoryRetrievalBundle: query.asOf must be a bigint",
+			fragment: value,
+			validationErrors: ["asOf must be a bigint when present"],
+		});
+	}
+	if (
+		query.minConfidence !== undefined &&
+		(!Number.isFinite(query.minConfidence) || query.minConfidence < 0 || query.minConfidence > 1)
+	) {
+		errors.push({
+			code: "invalid-query",
+			message: "memoryRetrievalBundle: query.minConfidence must be a finite number in [0, 1]",
+			fragment: value,
+			validationErrors: ["minConfidence must be a finite number in [0, 1]"],
+		});
+	}
+	if (query.limit !== undefined && (!Number.isSafeInteger(query.limit) || query.limit < 0)) {
+		errors.push({
+			code: "invalid-query",
+			message: "memoryRetrievalBundle: query.limit must be a non-negative safe integer",
+			fragment: value,
+			validationErrors: ["limit must be a non-negative safe integer"],
+		});
+	}
+	if (query.vector !== undefined && !isFiniteVector(query.vector)) {
+		errors.push({
+			code: "invalid-query-vector",
+			message: "memoryRetrievalBundle: query.vector must be a finite number array",
+			fragment: value,
+			validationErrors: ["vector must be a finite number array"],
+		});
+	}
+	if (errors.length > 0) return { ok: false, query: {}, errors };
+	return { ok: true, query: snapshotQuery(query), errors };
+}
+
+function invalidQuery(value: unknown, message: string): MemoryRetrievalQueryValidation {
+	return {
+		ok: false,
+		query: {},
+		errors: [
+			{
+				code: "invalid-query",
+				message,
+				fragment: value,
+			},
+		],
+	};
+}
+
+function snapshotQuery(query: Partial<MemoryRetrievalQuery>): MemoryRetrievalQuery {
+	return Object.freeze({
+		...(query.tags === undefined ? {} : { tags: Object.freeze([...query.tags]) }),
+		...(query.asOf === undefined ? {} : { asOf: query.asOf }),
+		...(query.minConfidence === undefined ? {} : { minConfidence: query.minConfidence }),
+		...(query.limit === undefined ? {} : { limit: query.limit }),
+		...(query.vector === undefined ? {} : { vector: Object.freeze([...query.vector]) }),
+	});
+}
+
+export function safeArrayLength(value: readonly unknown[]): number | undefined {
+	try {
+		return value.length;
+	} catch {
+		return undefined;
+	}
+}
+
+export function validateAndSnapshotFragment<T>(
+	rawFragments: readonly unknown[],
+	index: number,
+): FragmentValidationResult<T> {
+	let raw: unknown;
+	try {
+		raw = rawFragments[index];
+		const validation = validateMemoryFragment(raw);
+		if (!validation.ok) {
+			return {
+				error: {
+					code: "invalid-fragment",
+					message: "memoryRetrievalBundle: invalid memory fragment",
+					index,
+					fragment: raw,
+					validationErrors: Object.freeze([...validation.errors]),
+				},
+			};
+		}
+		return { fragment: snapshotFragment(raw as MemoryFragment<T>) };
+	} catch (error) {
+		return {
+			error: {
+				code: "invalid-fragment",
+				message: `memoryRetrievalBundle: fragment access failed: ${errorMessage(error)}`,
+				index,
+				fragment: raw,
+				validationErrors: Object.freeze(["fragment access failed"]),
+			},
+		};
+	}
+}
+
+function snapshotFragment<T>(fragment: MemoryFragment<T>): MemoryFragment<T> {
+	return Object.freeze({
+		id: fragment.id,
+		payload: fragment.payload,
+		tNs: fragment.tNs,
+		...(fragment.validFrom === undefined ? {} : { validFrom: fragment.validFrom }),
+		...(fragment.validTo === undefined ? {} : { validTo: fragment.validTo }),
+		confidence: fragment.confidence,
+		tags: Object.freeze([...fragment.tags]),
+		sources: Object.freeze([...fragment.sources]),
+		...(fragment.embedding === undefined
+			? {}
+			: { embedding: Object.freeze([...fragment.embedding]) }),
+		...(fragment.parentFragmentId === undefined
+			? {}
+			: { parentFragmentId: fragment.parentFragmentId }),
+		...(fragment.provenance === undefined ? {} : { provenance: fragment.provenance }),
+	});
+}
+
+function isDenseArrayOf<T>(value: unknown, predicate: (item: unknown) => item is T): value is T[] {
+	if (!Array.isArray(value)) return false;
+	for (let i = 0; i < value.length; i += 1) {
+		if (!Object.hasOwn(value, i) || !predicate(value[i])) return false;
+	}
+	return true;
+}
+
+function isPlainObject(value: unknown): value is Record<string, unknown> {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+function isNonEmptyString(value: unknown): value is string {
+	return typeof value === "string" && value.length > 0;
+}
+
+function errorMessage(error: unknown): string {
+	return error instanceof Error ? error.message : String(error);
+}
+
+function compareString(a: string, b: string): number {
+	return a < b ? -1 : a > b ? 1 : 0;
+}
+
+function compareBigIntDesc(a: bigint, b: bigint): number {
+	if (a === b) return 0;
+	return a > b ? -1 : 1;
+}
diff --git a/packages/ts/src/patterns/semantic-memory-graph.ts b/packages/ts/src/patterns/semantic-memory-graph.ts
new file mode 100644
index 00000000..f9879330
--- /dev/null
+++ b/packages/ts/src/patterns/semantic-memory-graph.ts
@@ -0,0 +1,433 @@
+/**
+ * Graph-visible semantic-memory retrieval patterns.
+ *
+ * D158 allows horizontal semantic-memory patterns when they are ordinary graph
+ * nodes with declared deps and graph-visible facts. This file intentionally
+ * owns no storage restore/hydration, scheduler, hidden subscription, vector DB,
+ * retention loop, consolidation loop, Graph subclass, or protocol behavior.
+ */
+
+import { depBatch, depLatest } from "../ctx/types.js";
+import type { Graph } from "../graph/graph.js";
+import type { Node } from "../node/node.js";
+import type { FactId, MemoryAnswer, MemoryFragment } from "./semantic-memory.js";
+import type {
+	KnowledgeGraphCursor,
+	KnowledgeGraphReducerBundle,
+	KnowledgeGraphReducerBundleOptions,
+	KnowledgeGraphSnapshot,
+	KnowledgeGraphStatus,
+	MemoryRetrievalBundle,
+	MemoryRetrievalBundleOptions,
+	MemoryRetrievalCursor,
+	MemoryRetrievalError,
+	MemoryRetrievalIndex,
+	MemoryRetrievalSnapshot,
+	MemoryRetrievalStatus,
+} from "./semantic-memory-graph-types.js";
+import {
+	indexById,
+	isRecoverableFragmentError,
+	rankFragments,
+	reduceKnowledgeAssertions,
+	safeArrayLength,
+	statusState,
+	validateAndSnapshotFragment,
+	validateKnowledgeGraphPolicy,
+	validateMemoryRetrievalQuery,
+} from "./semantic-memory-graph-utils.js";
+
+export type {
+	KnowledgeGraphCursor,
+	KnowledgeGraphEntity,
+	KnowledgeGraphError,
+	KnowledgeGraphErrorCode,
+	KnowledgeGraphIndex,
+	KnowledgeGraphPolicy,
+	KnowledgeGraphReducerBundle,
+	KnowledgeGraphReducerBundleOptions,
+	KnowledgeGraphRelation,
+	KnowledgeGraphSnapshot,
+	KnowledgeGraphStatus,
+	KnowledgeGraphStatusState,
+	KnowledgeGraphTopic,
+	MemoryRetrievalBundle,
+	MemoryRetrievalBundleOptions,
+	MemoryRetrievalCursor,
+	MemoryRetrievalError,
+	MemoryRetrievalErrorCode,
+	MemoryRetrievalFact,
+	MemoryRetrievalIndex,
+	MemoryRetrievalQuery,
+	MemoryRetrievalSnapshot,
+	MemoryRetrievalStatus,
+	MemoryRetrievalStatusState,
+} from "./semantic-memory-graph-types.js";
+
+interface MemoryRetrievalRuntimeState {
+	evaluation: number;
+}
+
+/**
+ * Build a graph-visible memory retrieval bundle from explicit fragment/query deps.
+ *
+ * Invalid fragments and ranking status are emitted as ordinary DATA facts. The
+ * bundle never owns storage restore or hidden mutation; callers that need
+ * persistence compose D161 collection/storage sidecars outside this pattern.
+ */
+export function memoryRetrievalBundle<T = unknown>(
+	graph: Graph,
+	opts: MemoryRetrievalBundleOptions,
+): MemoryRetrievalBundle<T> {
+	const name = opts.name ?? "memoryRetrieval";
+	const { fragments, query } = opts;
+	const snapshot = graph.node<MemoryRetrievalSnapshot<T>>(
+		[fragments, query],
+		(ctx) => {
+			const state =
+				ctx.state.get<MemoryRetrievalRuntimeState>() ??
+				({ evaluation: 0 } satisfies MemoryRetrievalRuntimeState);
+			state.evaluation += 1;
+			const rawFragments = depLatest(ctx, 0);
+			const rawQuery = depLatest(ctx, 1);
+			const queryValidation = validateMemoryRetrievalQuery(rawQuery);
+			const currentQuery = queryValidation.query;
+			const valid: MemoryFragment<T>[] = [];
+			const seenIds = new Set<FactId>();
+			const errors: Omit<MemoryRetrievalError, "cursor">[] = [...queryValidation.errors];
+
+			if (!Array.isArray(rawFragments)) {
+				errors.push({
+					code: "invalid-fragments-input",
+					message: "memoryRetrievalBundle: fragments input must be an array",
+					fragment: rawFragments,
+				});
+			} else {
+				const length = safeArrayLength(rawFragments);
+				if (length === undefined) {
+					errors.push({
+						code: "invalid-fragments-input",
+						message: "memoryRetrievalBundle: fragments input length could not be read",
+						fragment: rawFragments,
+					});
+				}
+				for (let i = 0; i < (length ?? 0); i += 1) {
+					const result = validateAndSnapshotFragment<T>(rawFragments, i);
+					if (result.error !== undefined) {
+						errors.push(result.error);
+						continue;
+					}
+					const fragment = result.fragment as MemoryFragment<T>;
+					if (seenIds.has(fragment.id)) {
+						errors.push({
+							code: "duplicate-fragment-id",
+							message: "memoryRetrievalBundle: duplicate fragment id",
+							index: i,
+							fragment,
+							validationErrors: [`duplicate fragment id '${fragment.id}'`],
+						});
+						continue;
+					}
+					seenIds.add(fragment.id);
+					valid.push(fragment);
+				}
+			}
+
+			const ranked = errors.some((error) => !isRecoverableFragmentError(error))
+				? []
+				: rankFragments(valid, currentQuery);
+			const cursor: MemoryRetrievalCursor = Object.freeze({
+				evaluation: state.evaluation,
+				validFragments: valid.length,
+				invalidFragments: errors.filter(
+					(error) => error.code === "invalid-fragment" || error.code === "duplicate-fragment-id",
+				).length,
+				resultCount: ranked.length,
+			});
+			ctx.state.set(state);
+			const answer: MemoryAnswer<T> = Object.freeze({
+				query: currentQuery,
+				results: Object.freeze(ranked),
+			});
+			const status: MemoryRetrievalStatus = Object.freeze({
+				state: statusState(errors, ranked.length),
+				query: currentQuery,
+				cursor,
+			});
+			const indexed: MemoryRetrievalIndex<T> = Object.freeze({
+				ids: Object.freeze(valid.map((fragment) => fragment.id)),
+				byId: indexById(valid),
+				cursor,
+			});
+			const errorFacts = Object.freeze(
+				errors.map((error) =>
+					Object.freeze({
+						...error,
+						...(error.validationErrors === undefined
+							? {}
+							: { validationErrors: Object.freeze([...error.validationErrors]) }),
+						cursor,
+					}),
+				),
+			);
+
+			ctx.down([
+				[
+					"DATA",
+					Object.freeze({
+						fragments: Object.freeze([...valid]),
+						indexed,
+						ranked: answer,
+						status,
+						errors: errorFacts,
+						cursor,
+					}),
+				],
+			]);
+		},
+		{
+			name: `${name}/snapshot`,
+			factory: "memoryRetrievalSnapshot",
+			completeWhenDepsComplete: false,
+			errorWhenDepsError: false,
+		},
+	);
+	return {
+		input: { fragments, query },
+		snapshot,
+		fragments: retrievalProjection(
+			graph,
+			snapshot,
+			`${name}/fragments`,
+			"memoryRetrievalFragments",
+			(fact) => fact.fragments,
+		),
+		indexed: retrievalProjection(
+			graph,
+			snapshot,
+			`${name}/indexed`,
+			"memoryRetrievalIndexed",
+			(fact) => fact.indexed,
+		),
+		ranked: retrievalProjection(
+			graph,
+			snapshot,
+			`${name}/ranked`,
+			"memoryRetrievalRanked",
+			(fact) => fact.ranked,
+		),
+		status: retrievalProjection(
+			graph,
+			snapshot,
+			`${name}/status`,
+			"memoryRetrievalStatus",
+			(fact) => fact.status,
+		),
+		errors: retrievalProjection(
+			graph,
+			snapshot,
+			`${name}/errors`,
+			"memoryRetrievalErrors",
+			(fact) => fact.errors,
+		),
+		cursor: retrievalProjection(
+			graph,
+			snapshot,
+			`${name}/cursor`,
+			"memoryRetrievalCursor",
+			(fact) => fact.cursor,
+		),
+	};
+}
+
+/**
+ * D170 lower semantic-memory KG materializer.
+ *
+ * Assertion, entity, relation, and topic ids remain DATA keys. The bundle has
+ * static describe-visible topology and owns no storage, LLM extraction,
+ * scheduler, agent runtime, or dynamic graph node lifecycle.
+ */
+export function knowledgeGraphReducerBundle(
+	graph: Graph,
+	opts: KnowledgeGraphReducerBundleOptions,
+): KnowledgeGraphReducerBundle {
+	const name = opts.name ?? "knowledgeGraph";
+	const deps = opts.policy === undefined ? [opts.assertions] : [opts.assertions, opts.policy];
+	const snapshot = graph.node<KnowledgeGraphSnapshot>(
+		deps,
+		(ctx) => {
+			const state =
+				ctx.state.get<{ evaluation: number }>() ??
+				({ evaluation: 0 } satisfies { evaluation: number });
+			state.evaluation += 1;
+			const policy = validateKnowledgeGraphPolicy(
+				opts.policy === undefined ? undefined : depLatest(ctx, 1),
+			);
+			const reduced = reduceKnowledgeAssertions(depLatest(ctx, 0), policy.policy);
+			const pendingErrors = [...policy.errors, ...reduced.errors];
+			const cursor: KnowledgeGraphCursor = Object.freeze({
+				evaluation: state.evaluation,
+				validAssertions: reduced.assertions.length,
+				invalidAssertions: reduced.invalidAssertions,
+				entityCount: reduced.entities.length,
+				relationCount: reduced.relations.length,
+				predicateCount: reduced.topics.length,
+			});
+			const errors = Object.freeze(
+				pendingErrors.map((error) =>
+					Object.freeze({
+						...error,
+						...(error.validationErrors === undefined
+							? {}
+							: { validationErrors: Object.freeze([...error.validationErrors]) }),
+						cursor,
+					}),
+				),
+			);
+			const status: KnowledgeGraphStatus = Object.freeze({
+				state:
+					reduced.assertions.length === 0 && errors.length === 0
+						? "empty"
+						: errors.length === 0
+							? "ready"
+							: reduced.assertions.length > 0
+								? "partial"
+								: "error",
+				cursor,
+			});
+			ctx.state.set(state);
+			ctx.down([
+				[
+					"DATA",
+					Object.freeze({
+						assertions: Object.freeze(reduced.assertions),
+						entities: Object.freeze(reduced.entities),
+						relations: Object.freeze(reduced.relations),
+						topics: Object.freeze(reduced.topics),
+						index: reduced.index,
+						status,
+						errors,
+						cursor,
+					}),
+				],
+			]);
+		},
+		{
+			name: `${name}/snapshot`,
+			factory: "knowledgeGraphReducerSnapshot",
+			completeWhenDepsComplete: false,
+			errorWhenDepsError: false,
+		},
+	);
+	return {
+		input: {
+			assertions: opts.assertions,
+			...(opts.policy === undefined ? {} : { policy: opts.policy }),
+		},
+		snapshot,
+		assertions: kgProjection(
+			graph,
+			snapshot,
+			`${name}/assertions`,
+			"knowledgeGraphAssertions",
+			(fact) => fact.assertions,
+		),
+		entities: kgProjection(
+			graph,
+			snapshot,
+			`${name}/entities`,
+			"knowledgeGraphEntities",
+			(fact) => fact.entities,
+		),
+		relations: kgProjection(
+			graph,
+			snapshot,
+			`${name}/relations`,
+			"knowledgeGraphRelations",
+			(fact) => fact.relations,
+		),
+		topics: kgProjection(
+			graph,
+			snapshot,
+			`${name}/topics`,
+			"knowledgeGraphTopics",
+			(fact) => fact.topics,
+		),
+		index: kgProjection(
+			graph,
+			snapshot,
+			`${name}/index`,
+			"knowledgeGraphIndex",
+			(fact) => fact.index,
+		),
+		status: kgProjection(
+			graph,
+			snapshot,
+			`${name}/status`,
+			"knowledgeGraphStatus",
+			(fact) => fact.status,
+		),
+		errors: kgProjection(
+			graph,
+			snapshot,
+			`${name}/errors`,
+			"knowledgeGraphErrors",
+			(fact) => fact.errors,
+		),
+		cursor: kgProjection(
+			graph,
+			snapshot,
+			`${name}/cursor`,
+			"knowledgeGraphCursor",
+			(fact) => fact.cursor,
+		),
+	};
+}
+
+function retrievalProjection<TFact, T>(
+	graph: Graph,
+	snapshot: Node<MemoryRetrievalSnapshot<T>>,
+	name: string,
+	factory: string,
+	select: (fact: MemoryRetrievalSnapshot<T>) => TFact | undefined,
+): Node<TFact> {
+	return graph.node<TFact>(
+		[snapshot],
+		(ctx) => {
+			for (const raw of depBatch(ctx, 0) ?? []) {
+				const fact = raw as MemoryRetrievalSnapshot<T>;
+				const selected = select(fact);
+				if (selected !== undefined) ctx.down([["DATA", selected]]);
+			}
+		},
+		{
+			name,
+			factory,
+			completeWhenDepsComplete: false,
+			errorWhenDepsError: false,
+		},
+	);
+}
+
+function kgProjection<TFact>(
+	graph: Graph,
+	snapshot: Node<KnowledgeGraphSnapshot>,
+	name: string,
+	factory: string,
+	select: (fact: KnowledgeGraphSnapshot) => TFact,
+): Node<TFact> {
+	return graph.node<TFact>(
+		[snapshot],
+		(ctx) => {
+			for (const raw of depBatch(ctx, 0) ?? []) {
+				ctx.down([["DATA", select(raw as KnowledgeGraphSnapshot)]]);
+			}
+		},
+		{
+			name,
+			factory,
+			completeWhenDepsComplete: false,
+			errorWhenDepsError: false,
+		},
+	);
+}
diff --git a/packages/ts/src/patterns/semantic-memory.ts b/packages/ts/src/patterns/semantic-memory.ts
new file mode 100644
index 00000000..be6414cb
--- /dev/null
+++ b/packages/ts/src/patterns/semantic-memory.ts
@@ -0,0 +1,383 @@
+/**
+ * Passive semantic-memory vocabulary and deterministic helpers.
+ *
+ * D158 splits semantic memory into horizontal patterns and vertical solutions.
+ * This module intentionally owns no graph nodes, storage restore, timers,
+ * subscriptions, vector indexes, knowledge graphs, or agentic runtime.
+ */
+
+import type { StrictJsonValue } from "../json/codec.js";
+
+/** Stable identity for a semantic-memory fact. */
+export type FactId = string;
+
+/** Shard partition key used by passive sharding helpers. */
+export type ShardKey = string | number;
+
+/**
+ * A single semantic-memory fact. Pattern convention only: this is not a
+ * protocol message, storage record owner, restore contract, or graph runtime.
+ */
+export interface MemoryFragment<T = unknown> {
+	readonly id: FactId;
+	readonly payload: T;
+	/** Transaction time, typically monotonic nanoseconds. */
+	readonly tNs: bigint;
+	/** Valid-time start. Undefined means unbounded past. */
+	readonly validFrom?: bigint;
+	/** Valid-time end. Undefined means currently valid. */
+	readonly validTo?: bigint;
+	/** Confidence score in the closed interval [0, 1]. */
+	readonly confidence: number;
+	readonly tags: readonly string[];
+	/** Fact ids this fragment derives from or depends on. */
+	readonly sources: readonly FactId[];
+	readonly embedding?: readonly number[];
+	readonly parentFragmentId?: FactId;
+	readonly provenance?: string;
+}
+
+/** Columnar passive store vocabulary for callers that keep memory facts outside GraphReFly. */
+export interface FactStore<T = unknown> {
+	readonly byId: ReadonlyMap<FactId, MemoryFragment<T>>;
+}
+
+/** Read-only projection passed to scoring policies; it exposes no mutation surface. */
+export interface StoreReadHandle<T = unknown> {
+	get(id: FactId): MemoryFragment<T> | undefined;
+	has(id: FactId): boolean;
+	readonly size: number;
+	values(): IterableIterator<MemoryFragment<T>>;
+}
+
+export type ScoringPolicy<T = unknown> = (
+	fragment: MemoryFragment<T>,
+	store: StoreReadHandle<T>,
+) => number;
+export type DecayPolicy = (confidence: number, ageNs: bigint) => number;
+export type AdmissionFilter<T = unknown> = (fragment: MemoryFragment<T>) => boolean;
+
+/** Outcome signal for policy learning. This is an application fact, not a protocol event. */
+export interface OutcomeSignal {
+	readonly factId: FactId;
+	readonly reward: number;
+}
+
+/** Passive structured query over semantic-memory facts. */
+export interface MemoryQuery {
+	readonly tags?: readonly string[];
+	readonly asOf?: bigint;
+	readonly minConfidence?: number;
+	readonly limit?: number;
+}
+
+export interface MemoryAnswer<T = unknown> {
+	readonly query: MemoryQuery;
+	readonly results: readonly MemoryFragment<T>[];
+}
+
+export type KnowledgeAssertionStrictJsonValue = StrictJsonValue;
+
+/** Passive KG endpoint vocabulary. Entity ids are DATA keys, not graph node ids. */
+export interface KnowledgeAssertionSubject {
+	readonly id: FactId;
+	readonly type?: string;
+}
+
+/** Passive KG object/value vocabulary. */
+export type KnowledgeAssertionObject =
+	| {
+			readonly kind: "entity";
+			readonly id: FactId;
+			readonly type?: string;
+	  }
+	| {
+			readonly kind: "value";
+			readonly value: KnowledgeAssertionStrictJsonValue;
+			readonly valueType?: string;
+	  };
+
+/** Passive KG assertion fact consumed by lower semantic-memory graph patterns. */
+export interface KnowledgeAssertion {
+	readonly id: FactId;
+	readonly recordId?: FactId;
+	readonly fragmentId?: FactId;
+	readonly subject: KnowledgeAssertionSubject;
+	readonly predicate: string;
+	readonly object: KnowledgeAssertionObject;
+	readonly confidence?: number;
+	readonly sources?: readonly FactId[];
+	readonly provenance?: string;
+}
+
+/** Entry vocabulary for ranked collection-like memory views. */
+export interface CollectionEntry<T = unknown> {
+	readonly id: string;
+	readonly value: T;
+	readonly createdAtNs: bigint;
+	readonly lastAccessNs: bigint;
+	readonly baseScore: number;
+}
+
+export type RankedCollectionEntry<T = unknown> = CollectionEntry<T> & {
+	readonly score: number;
+};
+
+export type CollectionScoreFn<T = unknown> = (value: T) => number;
+
+/** Query shape shared by passive retrieval/ranking helpers. */
+export interface RetrievalQuery {
+	readonly text?: string;
+	readonly vector?: readonly number[];
+	readonly entityIds?: readonly string[];
+	readonly context?: readonly string[];
+}
+
+export interface VectorSearchResult<TMeta = unknown> {
+	readonly id: string;
+	readonly score: number;
+	readonly meta?: TMeta;
+}
+
+export interface RetrievalEntry<TMem = unknown> {
+	readonly key: string;
+	readonly value: TMem;
+	readonly score: number;
+	readonly sources: ReadonlyArray<"vector" | "graph" | "store">;
+	readonly context?: readonly string[];
+}
+
+export interface RetrievalTrace<TMem = unknown> {
+	readonly vectorCandidates: ReadonlyArray<VectorSearchResult<TMem>>;
+	readonly graphExpanded: ReadonlyArray<string>;
+	readonly ranked: ReadonlyArray<RetrievalEntry<TMem>>;
+	readonly packed: ReadonlyArray<RetrievalEntry<TMem>>;
+}
+
+/** Generic per-dimension thresholds. Any configured dimension below threshold is rejected. */
+export type AdmissionThresholds<Dims extends string> = Partial<Record<Dims, number>>;
+
+export interface AdmissionScoredOptions<Dims extends string, TRaw = unknown> {
+	readonly scoreFn: (raw: TRaw) => Readonly<Record<Dims, number>>;
+	readonly thresholds?: AdmissionThresholds<Dims>;
+}
+
+export interface AdmissionScores {
+	readonly persistence: number;
+	readonly structure: number;
+	readonly personalValue: number;
+}
+
+export interface AdmissionScore3DOptions {
+	readonly scoreFn: (raw: unknown) => AdmissionScores;
+	readonly persistenceThreshold?: number;
+	readonly personalValueThreshold?: number;
+	readonly requireStructured?: boolean;
+}
+
+export interface ShardByTenantOptions {
+	readonly tenants?: readonly string[];
+	readonly shardCount?: number;
+}
+
+export interface ShardByTenantConfig<T = unknown> {
+	readonly shardBy: (fragment: MemoryFragment<T>) => ShardKey;
+	readonly shardCount: number;
+}
+
+export interface MemoryFragmentValidation {
+	readonly ok: boolean;
+	readonly errors: readonly string[];
+}
+
+/** Cosine similarity over zero-padded vectors. Non-finite results normalize to 0. */
+export function cosineSimilarity(a: readonly number[], b: readonly number[]): number {
+	const n = Math.max(a.length, b.length);
+	let dot = 0;
+	let na = 0;
+	let nb = 0;
+	for (let i = 0; i < n; i += 1) {
+		const av = a[i] ?? 0;
+		const bv = b[i] ?? 0;
+		dot += av * bv;
+		na += av * av;
+		nb += bv * bv;
+	}
+	if (na === 0 || nb === 0) return 0;
+	const score = dot / Math.sqrt(na * nb);
+	return Number.isFinite(score) ? score : 0;
+}
+
+/**
+ * Returns true when a fragment is valid at `asOf`.
+ *
+ * Omitted `asOf` has no clock to compare against, so it admits only fragments
+ * that are live and not valid-time delayed.
+ */
+export function memoryFragmentValidAt(fragment: MemoryFragment, asOf?: bigint): boolean {
+	if (asOf === undefined) return fragment.validTo === undefined && fragment.validFrom === undefined;
+	if (fragment.validFrom !== undefined && fragment.validFrom > asOf) return false;
+	if (fragment.validTo !== undefined && fragment.validTo <= asOf) return false;
+	return true;
+}
+
+/** Pure structured-query predicate over a single fragment. */
+export function memoryFragmentMatchesQuery(
+	fragment: MemoryFragment,
+	query: MemoryQuery = {},
+): boolean {
+	if (!memoryFragmentValidAt(fragment, query.asOf)) return false;
+	if (query.minConfidence !== undefined && fragment.confidence < query.minConfidence) return false;
+	if (
+		query.tags &&
+		query.tags.length > 0 &&
+		!query.tags.some((tag) => fragment.tags.includes(tag))
+	) {
+		return false;
+	}
+	return true;
+}
+
+/** Filter and rank fragments by confidence desc, then transaction time desc. */
+export function filterMemoryFragments<T>(
+	fragments: Iterable<MemoryFragment<T>>,
+	query: MemoryQuery = {},
+): readonly MemoryFragment<T>[] {
+	const results = [...fragments].filter((fragment) => memoryFragmentMatchesQuery(fragment, query));
+	results.sort((a, b) => b.confidence - a.confidence || compareBigIntDesc(a.tNs, b.tNs));
+	return query.limit === undefined ? results : results.slice(0, Math.max(0, query.limit));
+}
+
+/** Validate the passive MemoryFragment shape without throwing. */
+export function validateMemoryFragment(value: unknown): MemoryFragmentValidation {
+	const errors: string[] = [];
+	if (typeof value !== "object" || value === null) {
+		return { ok: false, errors: ["fragment must be an object"] };
+	}
+	const fragment = value as Partial<MemoryFragment>;
+	if (typeof fragment.id !== "string" || fragment.id.length === 0) {
+		errors.push("id must be a non-empty string");
+	}
+	if (!Object.hasOwn(fragment, "payload")) {
+		errors.push("payload must be present");
+	}
+	if (typeof fragment.tNs !== "bigint") {
+		errors.push("tNs must be a bigint");
+	}
+	const confidence = fragment.confidence;
+	if (
+		!Number.isFinite(confidence) ||
+		confidence === undefined ||
+		confidence < 0 ||
+		confidence > 1
+	) {
+		errors.push("confidence must be a finite number in [0, 1]");
+	}
+	if (!isDenseArrayOf(fragment.tags, (tag): tag is string => typeof tag === "string")) {
+		errors.push("tags must be a readonly string array");
+	}
+	if (!isDenseArrayOf(fragment.sources, (source): source is string => typeof source === "string")) {
+		errors.push("sources must be a readonly string array");
+	}
+	if (fragment.validFrom !== undefined && typeof fragment.validFrom !== "bigint") {
+		errors.push("validFrom must be a bigint when present");
+	}
+	if (fragment.validTo !== undefined && typeof fragment.validTo !== "bigint") {
+		errors.push("validTo must be a bigint when present");
+	}
+	if (
+		typeof fragment.validFrom === "bigint" &&
+		typeof fragment.validTo === "bigint" &&
+		fragment.validFrom >= fragment.validTo
+	) {
+		errors.push("validFrom must be earlier than validTo");
+	}
+	if (
+		fragment.embedding !== undefined &&
+		!isDenseArrayOf(fragment.embedding, (component): component is number =>
+			Number.isFinite(component),
+		)
+	) {
+		errors.push("embedding must be a finite number array when present");
+	}
+	if (fragment.parentFragmentId !== undefined && typeof fragment.parentFragmentId !== "string") {
+		errors.push("parentFragmentId must be a string when present");
+	}
+	if (fragment.provenance !== undefined && typeof fragment.provenance !== "string") {
+		errors.push("provenance must be a string when present");
+	}
+	return { ok: errors.length === 0, errors };
+}
+
+export function isMemoryFragment(value: unknown): value is MemoryFragment {
+	return validateMemoryFragment(value).ok;
+}
+
+/**
+ * Generic N-dimension admission filter. Missing or non-finite thresholded scores reject.
+ */
+export function admissionScored<Dims extends string, TRaw = unknown>(
+	opts: AdmissionScoredOptions<Dims, TRaw>,
+): (raw: TRaw) => boolean {
+	const thresholds = opts.thresholds ?? ({} as AdmissionThresholds<Dims>);
+	return (raw: TRaw): boolean => {
+		const scores = opts.scoreFn(raw);
+		for (const dim of Object.keys(thresholds) as Dims[]) {
+			const min = thresholds[dim];
+			if (min === undefined) continue;
+			const score = scores[dim];
+			const safe = Number.isFinite(score) ? (score as number) : Number.NEGATIVE_INFINITY;
+			if (safe < min) return false;
+		}
+		return true;
+	};
+}
+
+/** Three-axis admission sugar for persistence / structure / personal-value scoring. */
+export function admissionFilter3D(opts: AdmissionScore3DOptions): (raw: unknown) => boolean {
+	return (raw: unknown): boolean => {
+		const scores = opts.scoreFn(raw);
+		if (!scoreAtLeast(scores.persistence, opts.persistenceThreshold ?? 0.3)) return false;
+		if (!scoreAtLeast(scores.personalValue, opts.personalValueThreshold ?? 0.3)) return false;
+		if (!opts.requireStructured) return true;
+		return scoreAtLeast(scores.structure, Number.MIN_VALUE);
+	};
+}
+
+/** Build a passive `{ shardBy, shardCount }` pair for tenant-isolated sharding. */
+export function shardByTenant<T>(
+	tenantOf: (fragment: MemoryFragment<T>) => string,
+	opts: ShardByTenantOptions = {},
+): ShardByTenantConfig<T> {
+	if (opts.tenants && opts.tenants.length > 0) {
+		const tenants = [...new Set(opts.tenants)];
+		const index = new Map(tenants.map((tenant, i) => [tenant, i] as const));
+		const overflow = tenants.length;
+		return {
+			shardBy: (fragment) => index.get(tenantOf(fragment)) ?? overflow,
+			shardCount: tenants.length + 1,
+		};
+	}
+	const configuredShardCount = opts.shardCount ?? 4;
+	const shardCount = Number.isSafeInteger(configuredShardCount)
+		? Math.max(1, configuredShardCount)
+		: 4;
+	return { shardBy: (fragment) => tenantOf(fragment), shardCount };
+}
+
+function compareBigIntDesc(a: bigint, b: bigint): number {
+	if (a === b) return 0;
+	return a > b ? -1 : 1;
+}
+
+function isDenseArrayOf<T>(value: unknown, predicate: (item: unknown) => item is T): value is T[] {
+	if (!Array.isArray(value)) return false;
+	for (let i = 0; i < value.length; i += 1) {
+		if (!Object.hasOwn(value, i) || !predicate(value[i])) return false;
+	}
+	return true;
+}
+
+function scoreAtLeast(score: number, min: number): boolean {
+	return Number.isFinite(score) && score >= min;
+}
diff --git a/packages/ts/src/protocol/messages.ts b/packages/ts/src/protocol/messages.ts
new file mode 100644
index 00000000..b55f6f50
--- /dev/null
+++ b/packages/ts/src/protocol/messages.ts
@@ -0,0 +1,120 @@
+/**
+ * Wave-protocol message types and the tier const table.
+ *
+ * Canonical authority: ~/src/graphrefly/spec/rules.jsonl
+ *   R-msg-format, R-msg-closed-set, R-tier (D34), R-data-payload, R-sentinel.
+ */
+
+/** Opaque pause-lock / pull identifier (R-pause-lockset, R-pull). */
+export type LockId = string | symbol;
+
+/** Explicit pull demand payload (D269/D272). Params are holder-visible context, never DATA-up. */
+export interface PullDemand {
+	readonly pullId: LockId;
+	readonly params?: unknown;
+}
+
+/**
+ * The CLOSED set of 11 message types (R-msg-closed-set / D9 + D269 + START handshake).
+ * No open set, no user-defined custom types. Adding a type is a spec change.
+ */
+export type Message =
+	| readonly ["START"]
+	| readonly ["DIRTY"]
+	| readonly ["DATA", unknown]
+	| readonly ["RESOLVED"]
+	| readonly ["INVALIDATE"]
+	| readonly ["COMPLETE"]
+	| readonly ["ERROR", unknown]
+	| readonly ["TEARDOWN"]
+	| readonly ["PAUSE", LockId]
+	| readonly ["RESUME", LockId]
+	| readonly ["PULL", PullDemand];
+
+/** One array of messages delivered in one call = one Wave (R-wave-boundary). */
+export type Wave = readonly Message[];
+
+/** The message-type tag (the first tuple element). */
+export type MessageType = Message[0];
+
+/**
+ * SENTINEL = absence-of-DATA (R-sentinel / D16). TS representation is `undefined`.
+ * Never a valid DATA payload; `null` IS a valid DATA value (domain-level absence).
+ */
+export const SENTINEL = undefined;
+
+/** R-data-payload: ERROR payloads must not collide with terminal metadata shorthand. */
+export function isInvalidErrorPayload(v: unknown): boolean {
+	return v === SENTINEL || typeof v === "boolean";
+}
+
+/** R-data-payload / D78: host-language failures that collide with ctx.terminal shorthand become diagnostics. */
+export function errorPayload(reason: unknown, fallback = "error without a valid payload"): unknown {
+	return isInvalidErrorPayload(reason) ? new Error(fallback) : reason;
+}
+
+export const TIER_START = 0;
+export const TIER_CONTROL = 1;
+export const TIER_NOTIFICATION = 2;
+export const TIER_VALUE = 3;
+export const TIER_SETTLE = 4;
+export const TIER_TERMINAL = 5;
+export const TIER_TEARDOWN = 6;
+
+/**
+ * Tier const table (R-tier / D34). Tiers below value dispatch immediately; value
+ * and above are batch-deferred. This is a compile-time const table (D18), not runtime config.
+ */
+const TIER: Record<MessageType, number> = {
+	START: TIER_START,
+	PAUSE: TIER_CONTROL,
+	RESUME: TIER_CONTROL,
+	PULL: TIER_CONTROL,
+	DIRTY: TIER_NOTIFICATION,
+	DATA: TIER_VALUE,
+	RESOLVED: TIER_VALUE,
+	INVALIDATE: TIER_SETTLE,
+	COMPLETE: TIER_TERMINAL,
+	ERROR: TIER_TERMINAL,
+	TEARDOWN: TIER_TEARDOWN,
+};
+
+export function messageTier(t: MessageType): number {
+	return TIER[t];
+}
+
+/** Value and above are deferred inside a batch (DATA/RESOLVED/INVALIDATE/terminal/teardown). */
+export function isDeferredTier(t: MessageType): boolean {
+	return TIER[t] >= TIER_VALUE;
+}
+
+/** Value-tier messages (DATA/RESOLVED) occupy the tier-3 slot. */
+export function isValueTier(t: MessageType): boolean {
+	return TIER[t] === TIER_VALUE;
+}
+
+/** The pause buffer holds the settle slice only: value-tier DATA/RESOLVED plus INVALIDATE. */
+export function isPauseBufferedTier(t: MessageType): boolean {
+	const tier = TIER[t];
+	return tier === TIER_VALUE || tier === TIER_SETTLE;
+}
+
+/**
+ * A TERMINAL message = tier 5 (COMPLETE | ERROR), R-tier / D34. Detected via the CENTRAL tier
+ * table, NOT a per-variant `=== "COMPLETE" || === "ERROR"` check — so terminal routing stays
+ * driven by the one const table (feedback_use_tier_for_signal_routing); discriminate COMPLETE vs
+ * ERROR within the tier by the message type only where the handling actually differs.
+ */
+export function isTerminal(t: MessageType): boolean {
+	return TIER[t] === TIER_TERMINAL;
+}
+
+/**
+ * ctx.up carries control/demand tiers only (R-ctx-up / D269): DIRTY, PAUSE, RESUME, PULL,
+ * INVALIDATE, TEARDOWN. DATA/RESOLVED (tier 3) and COMPLETE/ERROR (tier 5) are
+ * down-only.
+ */
+export function isUpAllowed(t: MessageType): boolean {
+	const tier = TIER[t];
+	return tier !== TIER_VALUE && tier !== TIER_TERMINAL;
+}
diff --git a/packages/ts/src/render/index.ts b/packages/ts/src/render/index.ts
new file mode 100644
index 00000000..46e4cc13
--- /dev/null
+++ b/packages/ts/src/render/index.ts
@@ -0,0 +1,18 @@
+export {
+	type DescribeToAsciiOptions,
+	type DescribeToD2Options,
+	type DescribeToJsonOptions,
+	type DescribeToMermaidOptions,
+	type DescribeToMermaidUrlOptions,
+	type DescribeToPrettyOptions,
+	type DiagramDirection,
+	describeToAscii,
+	describeToD2,
+	describeToJson,
+	describeToMermaid,
+	describeToMermaidUrl,
+	describeToPretty,
+	type MermaidLiveTheme,
+	type MermaidLiveUrlOptions,
+	mermaidLiveUrl,
+} from "../graph/render.js";
diff --git a/packages/ts/src/solutions/agentic-memory-bundle.ts b/packages/ts/src/solutions/agentic-memory-bundle.ts
new file mode 100644
index 00000000..499ac7e7
--- /dev/null
+++ b/packages/ts/src/solutions/agentic-memory-bundle.ts
@@ -0,0 +1,103 @@
+import type { Graph } from "../graph/graph.js";
+import { memoryRetrievalBundle } from "../patterns/semantic-memory-graph.js";
+import {
+	agenticMemoryContextProjection,
+	agenticMemoryProjection,
+	agenticMemoryRecordProjection,
+} from "./agentic-memory-projection.js";
+import type { AgenticMemoryBundle, AgenticMemoryBundleOptions } from "./agentic-memory-types.js";
+
+export function agenticMemoryBundle<T = unknown>(
+	graph: Graph,
+	opts: AgenticMemoryBundleOptions<T>,
+): AgenticMemoryBundle<T> {
+	const name = opts.name ?? "agenticMemory";
+	const projection = agenticMemoryRecordProjection<T>(graph, opts.records, `${name}/projection`);
+	const projectedRecords = agenticMemoryProjection(
+		graph,
+		projection,
+		`${name}/records`,
+		"agenticMemoryRecords",
+		(fact) => fact.records,
+	);
+	const projectedFragments = agenticMemoryProjection(
+		graph,
+		projection,
+		`${name}/fragments`,
+		"agenticMemoryFragments",
+		(fact) => fact.fragments,
+	);
+	const status = agenticMemoryProjection(
+		graph,
+		projection,
+		`${name}/status`,
+		"agenticMemoryStatus",
+		(fact) => fact.status,
+	);
+	const errors = agenticMemoryProjection(
+		graph,
+		projection,
+		`${name}/errors`,
+		"agenticMemoryErrors",
+		(fact) => fact.errors,
+	);
+	const retrieval = memoryRetrievalBundle<T>(graph, {
+		name: `${name}/retrieval`,
+		fragments: projectedFragments,
+		query: opts.query,
+	});
+	const sources = agenticMemoryProjection(
+		graph,
+		projection,
+		`${name}/sources`,
+		"agenticMemorySources",
+		(fact) =>
+			Object.freeze(
+				fact.fragments.map((fragment) =>
+					Object.freeze({
+						fragmentId: fragment.id,
+						...(fact.metadataByFragmentId[fragment.id] === undefined
+							? {}
+							: { record: fact.metadataByFragmentId[fragment.id] }),
+						sources: Object.freeze([...fragment.sources]),
+						...(fragment.parentFragmentId === undefined
+							? {}
+							: { parentFragmentId: fragment.parentFragmentId }),
+						...(fragment.provenance === undefined ? {} : { provenance: fragment.provenance }),
+					}),
+				),
+			),
+	);
+	const context = agenticMemoryContextProjection(
+		graph,
+		projection,
+		retrieval.snapshot,
+		`${name}/context`,
+	);
+
+	return {
+		input: { records: opts.records, query: opts.query },
+		projection,
+		retrieval,
+		retrievalSnapshot: retrieval.snapshot,
+		records: projectedRecords,
+		fragments: projectedFragments,
+		sources,
+		indexed: retrieval.indexed,
+		ranked: retrieval.ranked,
+		context,
+		status,
+		errors,
+		retrievalStatus: retrieval.status,
+		retrievalErrors: retrieval.errors,
+		cursor: retrieval.cursor,
+	};
+}
+
+/**
+ * D165 solution-level KG assertion projection.
+ *
+ * Records and explicit assertion drafts stay visible as declared deps. This
+ * bundle validates references and shape, then emits DATA facts only; it does
+ * not extract assertions, call LLMs, read/write storage, or mutate topology.
+ */
diff --git a/packages/ts/src/solutions/agentic-memory-consolidation.ts b/packages/ts/src/solutions/agentic-memory-consolidation.ts
new file mode 100644
index 00000000..5152b918
--- /dev/null
+++ b/packages/ts/src/solutions/agentic-memory-consolidation.ts
@@ -0,0 +1,571 @@
+import { depLatest } from "../ctx/types.js";
+import type { Graph } from "../graph/graph.js";
+import type { FactId } from "../patterns/semantic-memory.js";
+import { solutionProjection } from "./agentic-memory-projection.js";
+import {
+	agenticStatusState,
+	errorMessage,
+	freezeError,
+	isDenseArrayOf,
+	isNonEmptyString,
+	isPlainRecord,
+	safeArrayLength,
+	validateAndProjectRecords,
+	validateAndSnapshotRecord,
+} from "./agentic-memory-shared.js";
+import type {
+	AgenticMemoryConsolidationBundle,
+	AgenticMemoryConsolidationBundleOptions,
+	AgenticMemoryConsolidationCommand,
+	AgenticMemoryConsolidationCursor,
+	AgenticMemoryConsolidationError,
+	AgenticMemoryConsolidationOutcome,
+	AgenticMemoryConsolidationRecordDraft,
+	AgenticMemoryConsolidationRequest,
+	AgenticMemoryConsolidationResult,
+	AgenticMemoryConsolidationSnapshot,
+	AgenticMemoryConsolidationStatus,
+	AgenticMemoryError,
+	AgenticMemoryRecord,
+	AgenticMemoryRetentionError,
+} from "./agentic-memory-types.js";
+
+export function agenticMemoryConsolidationBundle<T = unknown>(
+	graph: Graph,
+	opts: AgenticMemoryConsolidationBundleOptions<T>,
+): AgenticMemoryConsolidationBundle<T> {
+	const name = opts.name ?? "agenticMemoryConsolidation";
+	const projection = graph.node<AgenticMemoryConsolidationSnapshot<T>>(
+		[opts.records, opts.requests, opts.outcomes],
+		(ctx) => {
+			const state =
+				ctx.state.get<{ evaluation: number }>() ??
+				({ evaluation: 0 } satisfies { evaluation: number });
+			state.evaluation += 1;
+			const recordProjection = validateAndProjectRecords<T>(depLatest(ctx, 0));
+			const requests = validateConsolidationRequests(depLatest(ctx, 1), recordProjection.records);
+			const outcomes = projectConsolidationOutcomes<T>(
+				depLatest(ctx, 2),
+				requests.requests,
+				state.evaluation,
+			);
+			const cursor: AgenticMemoryConsolidationCursor = Object.freeze({
+				evaluation: state.evaluation,
+				validRequests: requests.requests.length,
+				validOutcomes: outcomes.validOutcomes,
+				invalidOutcomes: outcomes.invalidOutcomes,
+				results: outcomes.results.length,
+				proposedRecordDrafts: outcomes.proposedRecordDrafts.length,
+			});
+			const errors = Object.freeze(
+				[
+					...recordProjection.errors.map(consolidationErrorFromRecordError),
+					...requests.errors.map(consolidationErrorFromRetentionError),
+					...outcomes.errors,
+				].map((error) => freezeError({ ...error, cursor })),
+			);
+			const status: AgenticMemoryConsolidationStatus = Object.freeze({
+				state: agenticStatusState(errors.length, outcomes.results.length),
+				cursor,
+			});
+			ctx.state.set(state);
+			ctx.down([
+				[
+					"DATA",
+					Object.freeze({
+						results: Object.freeze(outcomes.results),
+						proposedRecordDrafts: Object.freeze(outcomes.proposedRecordDrafts),
+						commands: Object.freeze(outcomes.commands),
+						status,
+						errors,
+						cursor,
+					}),
+				],
+			]);
+		},
+		{
+			name: `${name}/projection`,
+			factory: "agenticMemoryConsolidation",
+			completeWhenDepsComplete: false,
+			errorWhenDepsError: false,
+		},
+	);
+	return {
+		input: { records: opts.records, requests: opts.requests, outcomes: opts.outcomes },
+		projection,
+		results: solutionProjection(
+			graph,
+			projection,
+			`${name}/results`,
+			"agenticMemoryConsolidationResults",
+			(fact) => fact.results,
+		),
+		proposedRecordDrafts: solutionProjection(
+			graph,
+			projection,
+			`${name}/proposedRecordDrafts`,
+			"agenticMemoryConsolidationRecordDrafts",
+			(fact) => fact.proposedRecordDrafts,
+		),
+		commands: solutionProjection(
+			graph,
+			projection,
+			`${name}/commands`,
+			"agenticMemoryConsolidationCommands",
+			(fact) => fact.commands,
+		),
+		status: solutionProjection(
+			graph,
+			projection,
+			`${name}/status`,
+			"agenticMemoryConsolidationStatus",
+			(fact) => fact.status,
+		),
+		errors: solutionProjection(
+			graph,
+			projection,
+			`${name}/errors`,
+			"agenticMemoryConsolidationErrors",
+			(fact) => fact.errors,
+		),
+		cursor: solutionProjection(
+			graph,
+			projection,
+			`${name}/cursor`,
+			"agenticMemoryConsolidationCursor",
+			(fact) => fact.cursor,
+		),
+	};
+}
+
+/** D168 deterministic context-packing bundle over explicit context text facts. */
+
+function validateConsolidationRequests<T>(
+	value: unknown,
+	records: readonly AgenticMemoryRecord<T>[],
+): {
+	readonly requests: readonly AgenticMemoryConsolidationRequest[];
+	readonly errors: readonly Omit<AgenticMemoryRetentionError, "cursor">[];
+} {
+	const byId = new Map(records.map((record) => [record.id, record]));
+	const requests: AgenticMemoryConsolidationRequest[] = [];
+	const errors: Omit<AgenticMemoryRetentionError, "cursor">[] = [];
+	if (!Array.isArray(value)) {
+		return {
+			requests,
+			errors: [
+				{
+					code: "invalid-commands-input",
+					message: "agenticMemoryConsolidationBundle: requests input must be an array",
+					command: value,
+				},
+			],
+		};
+	}
+	const length = safeArrayLength(value);
+	if (length === undefined) {
+		return {
+			requests,
+			errors: [
+				{
+					code: "invalid-commands-input",
+					message: "agenticMemoryConsolidationBundle: requests input length could not be read",
+					command: value,
+				},
+			],
+		};
+	}
+	const seen = new Set<FactId>();
+	for (let i = 0; i < length; i += 1) {
+		let raw: unknown;
+		try {
+			if (!Object.hasOwn(value, i)) {
+				throw new TypeError("request array must be dense");
+			}
+			raw = value[i];
+		} catch (error) {
+			errors.push({
+				code: "invalid-command",
+				message: `agenticMemoryConsolidationBundle: request access failed: ${errorMessage(error)}`,
+				index: i,
+				validationErrors: Object.freeze(["request access failed"]),
+			});
+			continue;
+		}
+		if (!isPlainRecord(raw)) {
+			errors.push({
+				code: "invalid-command",
+				message: "agenticMemoryConsolidationBundle: request must be an object",
+				index: i,
+				command: raw,
+			});
+			continue;
+		}
+		const id = isNonEmptyString(raw.id) ? raw.id : undefined;
+		const commandId = isNonEmptyString(raw.commandId) ? raw.commandId : undefined;
+		const recordIds = isDenseArrayOf(raw.recordIds, isNonEmptyString)
+			? Object.freeze([...raw.recordIds])
+			: undefined;
+		const validationErrors: string[] = [];
+		if (id === undefined) validationErrors.push("request.id must be a non-empty string");
+		if (commandId === undefined) {
+			validationErrors.push("request.commandId must be a non-empty string");
+		}
+		if (recordIds === undefined || recordIds.length === 0) {
+			validationErrors.push("request.recordIds must be a non-empty string array");
+		}
+		if (raw.reason !== undefined && typeof raw.reason !== "string") {
+			validationErrors.push("request.reason must be a string when present");
+		}
+		if (id !== undefined && seen.has(id)) {
+			validationErrors.push(`duplicate request id '${id}'`);
+		}
+		const missing = (recordIds ?? []).filter((recordId) => !byId.has(recordId));
+		if (missing.length > 0) {
+			errors.push({
+				code: "missing-record-ref",
+				message: "agenticMemoryConsolidationBundle: request references missing records",
+				index: i,
+				commandId,
+				recordIds: Object.freeze(missing),
+				command: raw,
+				validationErrors: Object.freeze(
+					missing.map((recordId) => `record '${recordId}' is not projected`),
+				),
+			});
+			continue;
+		}
+		if (
+			validationErrors.length > 0 ||
+			id === undefined ||
+			commandId === undefined ||
+			recordIds === undefined
+		) {
+			errors.push({
+				code: "invalid-command",
+				message: "agenticMemoryConsolidationBundle: request is invalid",
+				index: i,
+				commandId,
+				recordIds,
+				command: raw,
+				validationErrors: Object.freeze(validationErrors),
+			});
+			continue;
+		}
+		seen.add(id);
+		requests.push(
+			Object.freeze({
+				id,
+				commandId,
+				recordIds,
+				...(raw.reason === undefined ? {} : { reason: raw.reason as string }),
+			}),
+		);
+	}
+	return { requests: Object.freeze(requests), errors };
+}
+
+function projectConsolidationOutcomes<T>(
+	value: unknown,
+	requests: readonly AgenticMemoryConsolidationRequest[],
+	evaluation: number,
+): {
+	readonly results: readonly AgenticMemoryConsolidationResult[];
+	readonly proposedRecordDrafts: readonly AgenticMemoryConsolidationRecordDraft<T>[];
+	readonly commands: readonly AgenticMemoryConsolidationCommand[];
+	readonly errors: readonly Omit<AgenticMemoryConsolidationError, "cursor">[];
+	readonly validOutcomes: number;
+	readonly invalidOutcomes: number;
+} {
+	const byRequest = new Map(requests.map((request) => [request.id, request]));
+	const results: AgenticMemoryConsolidationResult[] = [];
+	const proposedRecordDrafts: AgenticMemoryConsolidationRecordDraft<T>[] = [];
+	const commands: AgenticMemoryConsolidationCommand[] = [];
+	const errors: Omit<AgenticMemoryConsolidationError, "cursor">[] = [];
+	let validOutcomes = 0;
+	let invalidOutcomes = 0;
+	if (!Array.isArray(value)) {
+		return {
+			results,
+			proposedRecordDrafts,
+			commands,
+			validOutcomes,
+			invalidOutcomes: 1,
+			errors: [
+				{
+					code: "invalid-outcomes-input",
+					message: "agenticMemoryConsolidationBundle: outcomes input must be an array",
+					outcome: value,
+				},
+			],
+		};
+	}
+	const length = safeArrayLength(value);
+	if (length === undefined) {
+		return {
+			results,
+			proposedRecordDrafts,
+			commands,
+			validOutcomes,
+			invalidOutcomes: 1,
+			errors: [
+				{
+					code: "invalid-outcomes-input",
+					message: "agenticMemoryConsolidationBundle: outcomes input length could not be read",
+					outcome: value,
+				},
+			],
+		};
+	}
+	const seenOutcomes = new Set<FactId>();
+	for (let i = 0; i < length; i += 1) {
+		let raw: unknown;
+		let outcome: {
+			readonly outcome?: AgenticMemoryConsolidationOutcome<T>;
+			readonly error?: Omit<AgenticMemoryConsolidationError, "cursor">;
+		};
+		try {
+			if (!Object.hasOwn(value, i)) {
+				throw new TypeError("outcome array must be dense");
+			}
+			raw = value[i];
+			outcome = validateConsolidationOutcome<T>(raw, i);
+		} catch (error) {
+			invalidOutcomes += 1;
+			errors.push({
+				code: "invalid-outcome",
+				message: `agenticMemoryConsolidationBundle: outcome access failed: ${errorMessage(error)}`,
+				index: i,
+				outcome: raw,
+				validationErrors: Object.freeze(["outcome access failed"]),
+			});
+			continue;
+		}
+		if (outcome.error !== undefined || outcome.outcome === undefined) {
+			invalidOutcomes += 1;
+			if (outcome.error !== undefined) errors.push(outcome.error);
+			continue;
+		}
+		const validOutcome = outcome.outcome;
+		if (seenOutcomes.has(validOutcome.id)) {
+			invalidOutcomes += 1;
+			errors.push({
+				code: "duplicate-outcome-id",
+				message: "agenticMemoryConsolidationBundle: duplicate outcome id",
+				index: i,
+				outcomeId: validOutcome.id,
+				requestId: validOutcome.requestId,
+				outcome: raw,
+				validationErrors: Object.freeze([`duplicate outcome id '${validOutcome.id}'`]),
+			});
+			continue;
+		}
+		const request = byRequest.get(validOutcome.requestId);
+		if (request === undefined) {
+			invalidOutcomes += 1;
+			errors.push({
+				code: "missing-request-ref",
+				message: "agenticMemoryConsolidationBundle: outcome references missing request",
+				index: i,
+				outcomeId: validOutcome.id,
+				requestId: validOutcome.requestId,
+				outcome: raw,
+				validationErrors: Object.freeze([`request '${validOutcome.requestId}' is not projected`]),
+			});
+			continue;
+		}
+		seenOutcomes.add(validOutcome.id);
+		validOutcomes += 1;
+		if (validOutcome.kind === "failed") {
+			const resultId = `${validOutcome.requestId}:${validOutcome.id}`;
+			results.push(
+				Object.freeze({
+					id: resultId,
+					requestId: validOutcome.requestId,
+					outcomeId: validOutcome.id,
+					state: "failed",
+					sourceRecordIds: request.recordIds,
+					proposedRecordIds: Object.freeze([]),
+					message: validOutcome.message,
+					...(validOutcome.provenance === undefined ? {} : { provenance: validOutcome.provenance }),
+				}),
+			);
+			commands.push(
+				Object.freeze({
+					id: `${resultId}:markFailed`,
+					kind: "markFailed",
+					requestId: validOutcome.requestId,
+					outcomeId: validOutcome.id,
+					message: validOutcome.message,
+				}),
+			);
+			continue;
+		}
+		const draftIds = validOutcome.records.map(
+			(record) => `${validOutcome.requestId}:${validOutcome.id}:${record.id}`,
+		);
+		for (let recordIndex = 0; recordIndex < validOutcome.records.length; recordIndex += 1) {
+			proposedRecordDrafts.push(
+				Object.freeze({
+					id: draftIds[recordIndex] as FactId,
+					requestId: validOutcome.requestId,
+					outcomeId: validOutcome.id,
+					record: validOutcome.records[recordIndex] as AgenticMemoryRecord<T>,
+				}),
+			);
+		}
+		const resultId = `${validOutcome.requestId}:${validOutcome.id}`;
+		results.push(
+			Object.freeze({
+				id: resultId,
+				requestId: validOutcome.requestId,
+				outcomeId: validOutcome.id,
+				state: "proposed",
+				sourceRecordIds: request.recordIds,
+				proposedRecordIds: Object.freeze(validOutcome.records.map((record) => record.id)),
+				...(validOutcome.provenance === undefined ? {} : { provenance: validOutcome.provenance }),
+			}),
+		);
+		commands.push(
+			Object.freeze({
+				id: `${resultId}:proposeRecords`,
+				kind: "proposeRecords",
+				requestId: validOutcome.requestId,
+				outcomeId: validOutcome.id,
+				draftIds: Object.freeze(draftIds),
+			}),
+		);
+	}
+	void evaluation;
+	return {
+		results: Object.freeze(results),
+		proposedRecordDrafts: Object.freeze(proposedRecordDrafts),
+		commands: Object.freeze(commands),
+		errors,
+		validOutcomes,
+		invalidOutcomes,
+	};
+}
+
+function validateConsolidationOutcome<T>(
+	value: unknown,
+	index: number,
+): {
+	readonly outcome?: AgenticMemoryConsolidationOutcome<T>;
+	readonly error?: Omit<AgenticMemoryConsolidationError, "cursor">;
+} {
+	if (!isPlainRecord(value)) {
+		return {
+			error: {
+				code: "invalid-outcome",
+				message: "agenticMemoryConsolidationBundle: outcome must be an object",
+				index,
+				outcome: value,
+			},
+		};
+	}
+	const errors: string[] = [];
+	const id = isNonEmptyString(value.id) ? value.id : undefined;
+	const requestId = isNonEmptyString(value.requestId) ? value.requestId : undefined;
+	if (id === undefined) errors.push("outcome.id must be a non-empty string");
+	if (requestId === undefined) errors.push("outcome.requestId must be a non-empty string");
+	if (value.kind !== "proposedRecords" && value.kind !== "failed") {
+		errors.push("outcome.kind must be proposedRecords or failed");
+	}
+	if (value.provenance !== undefined && typeof value.provenance !== "string") {
+		errors.push("outcome.provenance must be a string when present");
+	}
+	if (value.kind === "failed" && !isNonEmptyString(value.message)) {
+		errors.push("failed outcome.message must be a non-empty string");
+	}
+	const records: AgenticMemoryRecord<T>[] = [];
+	if (value.kind === "proposedRecords") {
+		if (!Array.isArray(value.records)) {
+			errors.push("proposedRecords.records must be a non-empty array");
+		} else {
+			const recordsLength = safeArrayLength(value.records);
+			const seenRecordIds = new Set<FactId>();
+			if (recordsLength === undefined || recordsLength === 0) {
+				errors.push("proposedRecords.records must be a non-empty array");
+			}
+			for (let i = 0; i < (recordsLength ?? 0); i += 1) {
+				let result: {
+					readonly record?: AgenticMemoryRecord<T>;
+					readonly errors: Omit<AgenticMemoryError, "cursor">[];
+				};
+				try {
+					if (!Object.hasOwn(value.records, i)) {
+						throw new TypeError("proposedRecords.records must be dense");
+					}
+					result = validateAndSnapshotRecord<T>(value.records[i], i);
+				} catch (error) {
+					errors.push(`records[${i}]: record access failed: ${errorMessage(error)}`);
+					continue;
+				}
+				if (result.record === undefined || result.errors.length > 0) {
+					errors.push(
+						...result.errors
+							.flatMap((error) => error.validationErrors ?? [error.message])
+							.map((error) => `records[${i}]: ${error}`),
+					);
+				} else if (seenRecordIds.has(result.record.id)) {
+					errors.push(`records[${i}]: duplicate proposed record id '${result.record.id}'`);
+				} else {
+					seenRecordIds.add(result.record.id);
+					records.push(result.record);
+				}
+			}
+		}
+	}
+	if (errors.length > 0 || id === undefined || requestId === undefined) {
+		return {
+			error: {
+				code: value.kind === "proposedRecords" ? "invalid-proposed-record" : "invalid-outcome",
+				message: "agenticMemoryConsolidationBundle: outcome is invalid",
+				index,
+				outcomeId: id,
+				requestId,
+				outcome: value,
+				validationErrors: Object.freeze(errors),
+			},
+		};
+	}
+	if (value.kind === "failed") {
+		return {
+			outcome: Object.freeze({
+				id,
+				requestId,
+				kind: "failed",
+				message: value.message as string,
+				...(value.provenance === undefined ? {} : { provenance: value.provenance as string }),
+			}),
+		};
+	}
+	return {
+		outcome: Object.freeze({
+			id,
+			requestId,
+			kind: "proposedRecords",
+			records: Object.freeze(records),
+			...(value.provenance === undefined ? {} : { provenance: value.provenance as string }),
+		}),
+	};
+}
+
+function consolidationErrorFromRecordError(
+	error: Omit<AgenticMemoryError, "cursor">,
+): Omit<AgenticMemoryConsolidationError, "cursor"> {
+	return {
+		...error,
+		code: error.code,
+	};
+}
+
+function consolidationErrorFromRetentionError(
+	error: Omit<AgenticMemoryRetentionError, "cursor">,
+): Omit<AgenticMemoryConsolidationError, "cursor"> {
+	return {
+		...error,
+		code: error.code,
+	};
+}
diff --git a/packages/ts/src/solutions/agentic-memory-context-packing.ts b/packages/ts/src/solutions/agentic-memory-context-packing.ts
new file mode 100644
index 00000000..a2683a2f
--- /dev/null
+++ b/packages/ts/src/solutions/agentic-memory-context-packing.ts
@@ -0,0 +1,465 @@
+import { depLatest } from "../ctx/types.js";
+import type { Graph } from "../graph/graph.js";
+import type { FactId } from "../patterns/semantic-memory.js";
+import { solutionProjection } from "./agentic-memory-projection.js";
+import {
+	agenticStatusState,
+	assertStrictJsonValue,
+	errorMessage,
+	freezeError,
+	isNonEmptyString,
+	isPlainRecord,
+	safeArrayLength,
+	validateRecordMetadata,
+} from "./agentic-memory-shared.js";
+import type {
+	AgenticMemoryContextEntry,
+	AgenticMemoryContextPackingBundle,
+	AgenticMemoryContextPackingBundleOptions,
+	AgenticMemoryContextPackingCursor,
+	AgenticMemoryContextPackingError,
+	AgenticMemoryContextPackingPolicy,
+	AgenticMemoryContextPackingSnapshot,
+	AgenticMemoryContextPackingStatus,
+	AgenticMemoryContextText,
+	AgenticMemoryPackedContext,
+	AgenticMemoryPackedContextEntry,
+	StrictJsonValue,
+	ValidatedPackingContext,
+} from "./agentic-memory-types.js";
+
+export function agenticMemoryContextPackingBundle<T = unknown>(
+	graph: Graph,
+	opts: AgenticMemoryContextPackingBundleOptions<T>,
+): AgenticMemoryContextPackingBundle<T> {
+	const name = opts.name ?? "agenticMemoryContextPacking";
+	const projection = graph.node<AgenticMemoryContextPackingSnapshot>(
+		[opts.context, opts.texts, opts.policy],
+		(ctx) => {
+			const state =
+				ctx.state.get<{ evaluation: number }>() ??
+				({ evaluation: 0 } satisfies { evaluation: number });
+			state.evaluation += 1;
+			const packed = packContext(
+				depLatest(ctx, 0),
+				depLatest(ctx, 1),
+				depLatest(ctx, 2),
+				state.evaluation,
+			);
+			ctx.state.set(state);
+			ctx.down([["DATA", packed]]);
+		},
+		{
+			name: `${name}/projection`,
+			factory: "agenticMemoryContextPacking",
+			completeWhenDepsComplete: false,
+			errorWhenDepsError: false,
+		},
+	);
+	return {
+		input: { context: opts.context, texts: opts.texts, policy: opts.policy },
+		projection,
+		packedContext: solutionProjection(
+			graph,
+			projection,
+			`${name}/packedContext`,
+			"agenticMemoryPackedContext",
+			(fact) => fact.packedContext,
+		),
+		status: solutionProjection(
+			graph,
+			projection,
+			`${name}/status`,
+			"agenticMemoryContextPackingStatus",
+			(fact) => fact.status,
+		),
+		errors: solutionProjection(
+			graph,
+			projection,
+			`${name}/errors`,
+			"agenticMemoryContextPackingErrors",
+			(fact) => fact.errors,
+		),
+		cursor: solutionProjection(
+			graph,
+			projection,
+			`${name}/cursor`,
+			"agenticMemoryContextPackingCursor",
+			(fact) => fact.cursor,
+		),
+	};
+}
+
+function packContext(
+	contextValue: unknown,
+	textsValue: unknown,
+	policyValue: unknown,
+	evaluation: number,
+): AgenticMemoryContextPackingSnapshot {
+	const errors: Omit<AgenticMemoryContextPackingError, "cursor">[] = [];
+	const context = validatePackingContext(contextValue, errors);
+	const texts = validateContextTexts(textsValue, errors);
+	const policy = validatePackingPolicy(policyValue, errors);
+	const packedEntries: AgenticMemoryPackedContextEntry[] = [];
+	let omittedEntries = 0;
+	let totalChars = 0;
+	let totalCost = 0;
+	if (context !== undefined && policy !== undefined) {
+		for (const entry of context.entries) {
+			const textFact = texts.get(entry.fragmentId);
+			if (textFact === undefined) {
+				omittedEntries += 1;
+				errors.push({
+					code: "missing-text",
+					message: "agenticMemoryContextPackingBundle: missing text projection for context entry",
+					fragmentId: entry.fragmentId,
+					validationErrors: [`missing text for fragment '${entry.fragmentId}'`],
+				});
+				continue;
+			}
+			const cost = textFact.cost ?? textFact.text.length;
+			const nextEntries = packedEntries.length + 1;
+			const separatorChars = packedEntries.length === 0 ? 0 : 2;
+			const nextChars = totalChars + separatorChars + textFact.text.length;
+			const nextCost = totalCost + cost;
+			const exceeds =
+				(policy.maxEntries !== undefined && nextEntries > policy.maxEntries) ||
+				(policy.maxChars !== undefined && nextChars > policy.maxChars) ||
+				(policy.maxCost !== undefined && nextCost > policy.maxCost);
+			if (exceeds) {
+				omittedEntries += 1;
+				continue;
+			}
+			const packedEntry: AgenticMemoryPackedContextEntry = Object.freeze({
+				fragmentId: entry.fragmentId,
+				text: textFact.text,
+				cost,
+				chars: textFact.text.length,
+				...(entry.record === undefined ? {} : { record: entry.record }),
+				...(policy.includeMetadata && textFact.metadata !== undefined
+					? { metadata: textFact.metadata }
+					: {}),
+			});
+			packedEntries.push(packedEntry);
+			totalChars = nextChars;
+			totalCost = nextCost;
+		}
+	}
+	const cursor: AgenticMemoryContextPackingCursor = Object.freeze({
+		evaluation,
+		inputEntries: context?.entries.length ?? 0,
+		packedEntries: packedEntries.length,
+		omittedEntries,
+		totalChars,
+		totalCost,
+	});
+	const errorFacts = Object.freeze(
+		errors.map((error) =>
+			freezeError({
+				...error,
+				cursor,
+			}),
+		),
+	);
+	const packedContext: AgenticMemoryPackedContext = Object.freeze({
+		entries: Object.freeze(packedEntries),
+		text: packedEntries.map((entry) => entry.text).join("\n\n"),
+		totalChars,
+		totalCost,
+		truncated: omittedEntries > 0,
+	});
+	const status: AgenticMemoryContextPackingStatus = Object.freeze({
+		state: agenticStatusState(errorFacts.length, packedEntries.length),
+		cursor,
+	});
+	return Object.freeze({
+		packedContext,
+		status,
+		errors: errorFacts,
+		cursor,
+	});
+}
+
+function validatePackingContext(
+	value: unknown,
+	errors: Omit<AgenticMemoryContextPackingError, "cursor">[],
+): ValidatedPackingContext | undefined {
+	if (!isPlainRecord(value)) {
+		errors.push({
+			code: "invalid-context",
+			message: "agenticMemoryContextPackingBundle: context must be an AgenticMemoryContext fact",
+			value,
+		});
+		return undefined;
+	}
+	let entriesValue: unknown;
+	try {
+		entriesValue = value.entries;
+	} catch (error) {
+		errors.push({
+			code: "invalid-context",
+			message: `agenticMemoryContextPackingBundle: context entries access failed: ${errorMessage(error)}`,
+			value,
+			validationErrors: ["context entries access failed"],
+		});
+		return undefined;
+	}
+	if (!Array.isArray(entriesValue)) {
+		errors.push({
+			code: "invalid-context",
+			message: "agenticMemoryContextPackingBundle: context must be an AgenticMemoryContext fact",
+			value,
+			validationErrors: ["context.entries must be an array"],
+		});
+		return undefined;
+	}
+	const length = safeArrayLength(entriesValue);
+	if (length === undefined) {
+		errors.push({
+			code: "invalid-context",
+			message: "agenticMemoryContextPackingBundle: context entries length could not be read",
+			value,
+			validationErrors: ["context.entries length could not be read"],
+		});
+		return undefined;
+	}
+	const entries: AgenticMemoryContextEntry[] = [];
+	for (let i = 0; i < length; i += 1) {
+		let raw: unknown;
+		try {
+			raw = entriesValue[i];
+			if (!isPlainRecord(raw) || !isNonEmptyString(raw.fragmentId)) {
+				errors.push({
+					code: "invalid-context",
+					message: "agenticMemoryContextPackingBundle: context entry is invalid",
+					index: i,
+					value: raw,
+					validationErrors: ["context entry fragmentId must be a non-empty string"],
+				});
+				continue;
+			}
+			const record = validateRecordMetadata(raw.record);
+			if (!record.ok) {
+				errors.push({
+					code: "invalid-context",
+					message: "agenticMemoryContextPackingBundle: context entry record metadata is invalid",
+					index: i,
+					fragmentId: raw.fragmentId,
+					value: raw,
+					validationErrors: Object.freeze(record.errors),
+				});
+				continue;
+			}
+			entries.push(
+				Object.freeze({
+					fragmentId: raw.fragmentId,
+					...(record.metadata === undefined ? {} : { record: record.metadata }),
+				}) as AgenticMemoryContextEntry,
+			);
+		} catch (error) {
+			errors.push({
+				code: "invalid-context",
+				message: `agenticMemoryContextPackingBundle: context entry access failed: ${errorMessage(error)}`,
+				index: i,
+				value: raw,
+				validationErrors: ["context entry access failed"],
+			});
+		}
+	}
+	return Object.freeze({
+		entries: Object.freeze(entries),
+	});
+}
+
+function validateContextTexts(
+	value: unknown,
+	errors: Omit<AgenticMemoryContextPackingError, "cursor">[],
+): Map<FactId, AgenticMemoryContextText> {
+	const out = new Map<FactId, AgenticMemoryContextText>();
+	if (!Array.isArray(value)) {
+		errors.push({
+			code: "invalid-texts-input",
+			message: "agenticMemoryContextPackingBundle: texts input must be an array",
+			value,
+		});
+		return out;
+	}
+	const length = safeArrayLength(value);
+	if (length === undefined) {
+		errors.push({
+			code: "invalid-texts-input",
+			message: "agenticMemoryContextPackingBundle: texts input length could not be read",
+			value,
+		});
+		return out;
+	}
+	for (let i = 0; i < length; i += 1) {
+		try {
+			const raw = value[i];
+			const result = validateContextText(raw, i);
+			if (result.error !== undefined) {
+				errors.push(result.error);
+				continue;
+			}
+			if (result.text === undefined) {
+				errors.push({
+					code: "invalid-text",
+					message: "agenticMemoryContextPackingBundle: text fact is invalid",
+					index: i,
+					value: raw,
+					validationErrors: ["text validation returned no fact"],
+				});
+				continue;
+			}
+			if (out.has(result.text.fragmentId)) {
+				errors.push({
+					code: "duplicate-text-fragment-id",
+					message: "agenticMemoryContextPackingBundle: duplicate text fragment id",
+					index: i,
+					fragmentId: result.text.fragmentId,
+					value: raw,
+					validationErrors: [`duplicate text fragment id '${result.text.fragmentId}'`],
+				});
+				continue;
+			}
+			out.set(result.text.fragmentId, result.text);
+		} catch (error) {
+			errors.push({
+				code: "invalid-text",
+				message: `agenticMemoryContextPackingBundle: text access failed: ${errorMessage(error)}`,
+				index: i,
+				validationErrors: ["text access failed"],
+			});
+		}
+	}
+	return out;
+}
+
+function validateContextText(
+	value: unknown,
+	index: number,
+): {
+	readonly text?: AgenticMemoryContextText;
+	readonly error?: Omit<AgenticMemoryContextPackingError, "cursor">;
+} {
+	if (!isPlainRecord(value)) {
+		return {
+			error: {
+				code: "invalid-text",
+				message: "agenticMemoryContextPackingBundle: text fact must be an object",
+				index,
+				value,
+			},
+		};
+	}
+	const errors: string[] = [];
+	if (!isNonEmptyString(value.fragmentId)) errors.push("fragmentId must be a non-empty string");
+	if (typeof value.text !== "string") errors.push("text must be a string");
+	if (
+		value.cost !== undefined &&
+		(typeof value.cost !== "number" || !Number.isFinite(value.cost) || value.cost < 0)
+	) {
+		errors.push("cost must be a finite number >= 0");
+	}
+	if (value.metadata !== undefined) {
+		try {
+			if (!isPlainRecord(value.metadata)) {
+				throw new TypeError("metadata must be a plain object when present");
+			}
+			assertStrictJsonValue(value.metadata, "metadata");
+		} catch (error) {
+			errors.push(errorMessage(error));
+		}
+	}
+	if (errors.length > 0) {
+		return {
+			error: {
+				code: "invalid-text",
+				message: "agenticMemoryContextPackingBundle: text fact is invalid",
+				index,
+				fragmentId: typeof value.fragmentId === "string" ? value.fragmentId : undefined,
+				value,
+				validationErrors: Object.freeze(errors),
+			},
+		};
+	}
+	return {
+		text: Object.freeze({
+			fragmentId: value.fragmentId as string,
+			text: value.text as string,
+			...(value.cost === undefined ? {} : { cost: value.cost as number }),
+			...(value.metadata === undefined
+				? {}
+				: { metadata: Object.freeze({ ...(value.metadata as Record<string, StrictJsonValue>) }) }),
+		}),
+	};
+}
+
+function validatePackingPolicy(
+	value: unknown,
+	errors: Omit<AgenticMemoryContextPackingError, "cursor">[],
+): AgenticMemoryContextPackingPolicy | undefined {
+	if (!isPlainRecord(value)) {
+		errors.push({
+			code: "invalid-policy",
+			message: "agenticMemoryContextPackingBundle: policy must be an object",
+			value,
+		});
+		return undefined;
+	}
+	const validation: string[] = [];
+	let maxEntries: unknown;
+	let maxChars: unknown;
+	let maxCost: unknown;
+	let includeMetadata: unknown;
+	try {
+		maxEntries = value.maxEntries;
+		maxChars = value.maxChars;
+		maxCost = value.maxCost;
+		includeMetadata = value.includeMetadata;
+	} catch (error) {
+		errors.push({
+			code: "invalid-policy",
+			message: `agenticMemoryContextPackingBundle: policy access failed: ${errorMessage(error)}`,
+			value,
+			validationErrors: ["policy access failed"],
+		});
+		return undefined;
+	}
+	if (
+		maxEntries !== undefined &&
+		(typeof maxEntries !== "number" || !Number.isSafeInteger(maxEntries) || maxEntries < 0)
+	) {
+		validation.push("maxEntries must be a safe integer >= 0");
+	}
+	if (
+		maxChars !== undefined &&
+		(typeof maxChars !== "number" || !Number.isSafeInteger(maxChars) || maxChars < 0)
+	) {
+		validation.push("maxChars must be a safe integer >= 0");
+	}
+	if (
+		maxCost !== undefined &&
+		(typeof maxCost !== "number" || !Number.isFinite(maxCost) || maxCost < 0)
+	) {
+		validation.push("maxCost must be a finite number >= 0");
+	}
+	if (includeMetadata !== undefined && typeof includeMetadata !== "boolean") {
+		validation.push("includeMetadata must be a boolean when present");
+	}
+	if (validation.length > 0) {
+		errors.push({
+			code: "invalid-policy",
+			message: "agenticMemoryContextPackingBundle: policy is invalid",
+			value,
+			validationErrors: Object.freeze(validation),
+		});
+		return undefined;
+	}
+	return Object.freeze({
+		...(maxEntries === undefined ? {} : { maxEntries: maxEntries as number }),
+		...(maxChars === undefined ? {} : { maxChars: maxChars as number }),
+		...(maxCost === undefined ? {} : { maxCost: maxCost as number }),
+		...(includeMetadata === undefined ? {} : { includeMetadata: includeMetadata as boolean }),
+	});
+}
diff --git a/packages/ts/src/solutions/agentic-memory-frame.ts b/packages/ts/src/solutions/agentic-memory-frame.ts
new file mode 100644
index 00000000..6df47da7
--- /dev/null
+++ b/packages/ts/src/solutions/agentic-memory-frame.ts
@@ -0,0 +1,218 @@
+import { type Codec, strictJsonCodec } from "../json/codec.js";
+import type { MemoryFragment } from "../patterns/semantic-memory.js";
+import {
+	assertAgenticMemoryRecordCodecShape,
+	assertArtifactKindValue,
+	assertConfidence,
+	assertExactKeys,
+	assertFiniteNumberArray,
+	assertKindValue,
+	assertNonEmptyString,
+	assertPersistenceLevelValue,
+	assertScopeFrame,
+	assertStrictJsonValue,
+	assertString,
+	assertStringArray,
+	decimalBigIntString,
+	isPlainRecord,
+	parseDecimalBigInt,
+	validateAndSnapshotRecord,
+} from "./agentic-memory-shared.js";
+import type {
+	AgenticMemoryFragmentFrame,
+	AgenticMemoryRecord,
+	AgenticMemoryRecordFrame,
+	StrictJsonValue,
+} from "./agentic-memory-types.js";
+
+export const AGENTIC_MEMORY_RECORD_FRAME_FORMAT = "graphrefly.agenticMemoryRecord";
+export const AGENTIC_MEMORY_RECORD_FRAME_VERSION = 1;
+
+export function agenticMemoryRecordFrame<TJson extends StrictJsonValue>(
+	record: AgenticMemoryRecord<TJson>,
+): AgenticMemoryRecordFrame<TJson> {
+	const result = validateAndSnapshotRecord<TJson>(record, 0);
+	if (result.errors.length > 0 || result.record === undefined) {
+		throw new TypeError(
+			`agenticMemoryRecordFrame: invalid record: ${result.errors
+				.flatMap((error) => error.validationErrors ?? [error.message])
+				.join("; ")}`,
+		);
+	}
+	assertAgenticMemoryRecordCodecShape(record);
+	assertStrictJsonValue(result.record.fragment.payload, "record.fragment.payload");
+	return Object.freeze({
+		format: AGENTIC_MEMORY_RECORD_FRAME_FORMAT,
+		version: AGENTIC_MEMORY_RECORD_FRAME_VERSION,
+		record: Object.freeze({
+			id: result.record.id,
+			kind: result.record.kind,
+			persistenceLevel: result.record.persistenceLevel,
+			artifactKind: result.record.artifactKind,
+			...(result.record.scope === undefined ? {} : { scope: result.record.scope }),
+			fragment: fragmentFrame(result.record.fragment as MemoryFragment<TJson>),
+		}),
+	});
+}
+
+/** Assert and snapshot a decoded D166 record frame. Unknown fields fail honestly. */
+export function assertAgenticMemoryRecordFrame<TJson extends StrictJsonValue = StrictJsonValue>(
+	value: unknown,
+): AgenticMemoryRecordFrame<TJson> {
+	if (!isPlainRecord(value))
+		throw new TypeError("agenticMemoryRecordFrame: frame must be an object");
+	assertStrictJsonValue(value, "agenticMemoryRecordFrame");
+	assertExactKeys(value, ["format", "record", "version"], "agenticMemoryRecordFrame");
+	if (value.format !== AGENTIC_MEMORY_RECORD_FRAME_FORMAT) {
+		throw new TypeError("agenticMemoryRecordFrame: invalid format");
+	}
+	if (value.version !== AGENTIC_MEMORY_RECORD_FRAME_VERSION) {
+		throw new TypeError("agenticMemoryRecordFrame: invalid version");
+	}
+	const rawRecord = value.record;
+	if (!isPlainRecord(rawRecord)) {
+		throw new TypeError("agenticMemoryRecordFrame: record must be an object");
+	}
+	assertExactKeys(
+		rawRecord,
+		rawRecord.scope === undefined
+			? ["artifactKind", "fragment", "id", "kind", "persistenceLevel"]
+			: ["artifactKind", "fragment", "id", "kind", "persistenceLevel", "scope"],
+		"agenticMemoryRecordFrame.record",
+	);
+	const rawFragment = rawRecord.fragment;
+	if (!isPlainRecord(rawFragment)) {
+		throw new TypeError("agenticMemoryRecordFrame: fragment must be an object");
+	}
+	assertExactKeys(
+		rawFragment,
+		[
+			"id",
+			"payload",
+			"tNs",
+			...(rawFragment.validFrom === undefined ? [] : ["validFrom"]),
+			...(rawFragment.validTo === undefined ? [] : ["validTo"]),
+			"confidence",
+			"tags",
+			"sources",
+			...(rawFragment.embedding === undefined ? [] : ["embedding"]),
+			...(rawFragment.parentFragmentId === undefined ? [] : ["parentFragmentId"]),
+			...(rawFragment.provenance === undefined ? [] : ["provenance"]),
+		],
+		"agenticMemoryRecordFrame.record.fragment",
+	);
+	if (rawRecord.scope !== undefined) assertScopeFrame(rawRecord.scope);
+	const frame = value as unknown as AgenticMemoryRecordFrame<TJson>;
+	const decoded = recordFromFrame(frame);
+	const roundtrip = agenticMemoryRecordFrame(decoded);
+	return roundtrip as AgenticMemoryRecordFrame<TJson>;
+}
+
+/** Strict canonical JSON codec for D166 AgenticMemoryRecordFrame values. */
+export function agenticMemoryRecordFrameCodec<
+	TJson extends StrictJsonValue = StrictJsonValue,
+>(): Codec<AgenticMemoryRecordFrame<TJson>> {
+	return {
+		encode(value: AgenticMemoryRecordFrame<TJson>): Uint8Array {
+			return strictJsonCodec.encode(assertAgenticMemoryRecordFrame<TJson>(value));
+		},
+		decode(bytes: Uint8Array): AgenticMemoryRecordFrame<TJson> {
+			return assertAgenticMemoryRecordFrame<TJson>(strictJsonCodec.decode(bytes));
+		},
+	};
+}
+
+/** Strict canonical JSON codec that persists records and decodes bigint fields back to bigint. */
+export function agenticMemoryRecordCodec<TJson extends StrictJsonValue = StrictJsonValue>(): Codec<
+	AgenticMemoryRecord<TJson>
+> {
+	const frameCodec = agenticMemoryRecordFrameCodec<TJson>();
+	return {
+		encode(value: AgenticMemoryRecord<TJson>): Uint8Array {
+			return frameCodec.encode(agenticMemoryRecordFrame(value));
+		},
+		decode(bytes: Uint8Array): AgenticMemoryRecord<TJson> {
+			return recordFromFrame(frameCodec.decode(bytes));
+		},
+	};
+}
+
+/**
+ * D167 solution-level retention command projection.
+ *
+ * Archive/restore/setPersistenceLevel are derived views over current records;
+ * requestConsolidation emits request facts only.
+ */
+
+function fragmentFrame<TJson extends StrictJsonValue>(
+	fragment: MemoryFragment<TJson>,
+): AgenticMemoryFragmentFrame<TJson> {
+	return Object.freeze({
+		id: fragment.id,
+		payload: fragment.payload,
+		tNs: decimalBigIntString(fragment.tNs, "fragment.tNs"),
+		...(fragment.validFrom === undefined
+			? {}
+			: { validFrom: decimalBigIntString(fragment.validFrom, "fragment.validFrom") }),
+		...(fragment.validTo === undefined
+			? {}
+			: { validTo: decimalBigIntString(fragment.validTo, "fragment.validTo") }),
+		confidence: fragment.confidence,
+		tags: Object.freeze([...fragment.tags]),
+		sources: Object.freeze([...fragment.sources]),
+		...(fragment.embedding === undefined
+			? {}
+			: { embedding: Object.freeze([...fragment.embedding]) }),
+		...(fragment.parentFragmentId === undefined
+			? {}
+			: { parentFragmentId: fragment.parentFragmentId }),
+		...(fragment.provenance === undefined ? {} : { provenance: fragment.provenance }),
+	});
+}
+
+function recordFromFrame<TJson extends StrictJsonValue>(
+	frame: AgenticMemoryRecordFrame<TJson>,
+): AgenticMemoryRecord<TJson> {
+	const fragment = frame.record.fragment;
+	const record: AgenticMemoryRecord<TJson> = {
+		id: assertNonEmptyString(frame.record.id, "record.id"),
+		kind: assertKindValue(frame.record.kind),
+		persistenceLevel: assertPersistenceLevelValue(frame.record.persistenceLevel),
+		artifactKind: assertArtifactKindValue(frame.record.artifactKind),
+		...(frame.record.scope === undefined ? {} : { scope: assertScopeFrame(frame.record.scope) }),
+		fragment: {
+			id: assertNonEmptyString(fragment.id, "fragment.id"),
+			payload: assertStrictJsonValue(fragment.payload, "fragment.payload") as TJson,
+			tNs: parseDecimalBigInt(fragment.tNs, "fragment.tNs"),
+			...(fragment.validFrom === undefined
+				? {}
+				: { validFrom: parseDecimalBigInt(fragment.validFrom, "fragment.validFrom") }),
+			...(fragment.validTo === undefined
+				? {}
+				: { validTo: parseDecimalBigInt(fragment.validTo, "fragment.validTo") }),
+			confidence: assertConfidence(fragment.confidence, "fragment.confidence"),
+			tags: assertStringArray(fragment.tags, "fragment.tags"),
+			sources: assertStringArray(fragment.sources, "fragment.sources"),
+			...(fragment.embedding === undefined
+				? {}
+				: { embedding: assertFiniteNumberArray(fragment.embedding, "fragment.embedding") }),
+			...(fragment.parentFragmentId === undefined
+				? {}
+				: {
+						parentFragmentId: assertNonEmptyString(fragment.parentFragmentId, "parentFragmentId"),
+					}),
+			...(fragment.provenance === undefined
+				? {}
+				: { provenance: assertString(fragment.provenance, "provenance") }),
+		},
+	};
+	const result = validateAndSnapshotRecord<TJson>(record, 0);
+	if (result.errors.length > 0 || result.record === undefined) {
+		throw new TypeError(
+			`agenticMemoryRecordFrame: decoded record is invalid: ${result.errors
+				.flatMap((error) => error.validationErrors ?? [error.message])
+				.join("; ")}`,
+		);
+	}
+	return result.record;
+}
diff --git a/packages/ts/src/solutions/agentic-memory-kg.ts b/packages/ts/src/solutions/agentic-memory-kg.ts
new file mode 100644
index 00000000..e6c14fff
--- /dev/null
+++ b/packages/ts/src/solutions/agentic-memory-kg.ts
@@ -0,0 +1,433 @@
+import { depLatest } from "../ctx/types.js";
+import type { Graph } from "../graph/graph.js";
+import type {
+	FactId,
+	KnowledgeAssertion,
+	KnowledgeAssertionObject,
+	KnowledgeAssertionSubject,
+} from "../patterns/semantic-memory.js";
+import { solutionProjection } from "./agentic-memory-projection.js";
+import {
+	agenticStatusState,
+	assertStrictJsonValue,
+	errorMessage,
+	freezeError,
+	isDenseArrayOf,
+	isNonEmptyString,
+	isPlainRecord,
+	safeArrayLength,
+	validateAndProjectRecords,
+} from "./agentic-memory-shared.js";
+import type {
+	AgenticMemoryError,
+	AgenticMemoryKgAssertionDraft,
+	AgenticMemoryKgProjectionBundle,
+	AgenticMemoryKgProjectionBundleOptions,
+	AgenticMemoryKgProjectionCursor,
+	AgenticMemoryKgProjectionError,
+	AgenticMemoryKgProjectionSnapshot,
+	AgenticMemoryKgProjectionStatus,
+	AgenticMemoryRecord,
+	StrictJsonValue,
+} from "./agentic-memory-types.js";
+
+export function agenticMemoryKgProjectionBundle(
+	graph: Graph,
+	opts: AgenticMemoryKgProjectionBundleOptions,
+): AgenticMemoryKgProjectionBundle {
+	const name = opts.name ?? "agenticMemoryKgProjection";
+	const projection = graph.node<AgenticMemoryKgProjectionSnapshot>(
+		[opts.records, opts.drafts],
+		(ctx) => {
+			const state =
+				ctx.state.get<{ evaluation: number }>() ??
+				({ evaluation: 0 } satisfies { evaluation: number });
+			state.evaluation += 1;
+			const recordProjection = validateAndProjectRecords(depLatest(ctx, 0));
+			const draftProjection = validateAndProjectKgDrafts(
+				depLatest(ctx, 1),
+				recordProjection.records,
+			);
+			const cursor: AgenticMemoryKgProjectionCursor = Object.freeze({
+				evaluation: state.evaluation,
+				validRecords: recordProjection.records.length,
+				validDrafts: draftProjection.assertions.length,
+				invalidDrafts: draftProjection.invalidDrafts,
+				projectedAssertions: draftProjection.assertions.length,
+			});
+			const errors = Object.freeze(
+				[...recordProjection.errors.map(kgErrorFromRecordError), ...draftProjection.errors].map(
+					(error) => freezeError({ ...error, cursor }),
+				),
+			);
+			const status: AgenticMemoryKgProjectionStatus = Object.freeze({
+				state: agenticStatusState(errors.length, draftProjection.assertions.length),
+				cursor,
+			});
+			ctx.state.set(state);
+			ctx.down([
+				[
+					"DATA",
+					Object.freeze({
+						assertions: Object.freeze(draftProjection.assertions),
+						status,
+						errors,
+						cursor,
+					}),
+				],
+			]);
+		},
+		{
+			name: `${name}/projection`,
+			factory: "agenticMemoryKgProjection",
+			completeWhenDepsComplete: false,
+			errorWhenDepsError: false,
+		},
+	);
+	return {
+		input: { records: opts.records, drafts: opts.drafts },
+		projection,
+		assertions: solutionProjection(
+			graph,
+			projection,
+			`${name}/assertions`,
+			"agenticMemoryKgAssertions",
+			(fact) => fact.assertions,
+		),
+		status: solutionProjection(
+			graph,
+			projection,
+			`${name}/status`,
+			"agenticMemoryKgStatus",
+			(fact) => fact.status,
+		),
+		errors: solutionProjection(
+			graph,
+			projection,
+			`${name}/errors`,
+			"agenticMemoryKgErrors",
+			(fact) => fact.errors,
+		),
+		cursor: solutionProjection(
+			graph,
+			projection,
+			`${name}/cursor`,
+			"agenticMemoryKgCursor",
+			(fact) => fact.cursor,
+		),
+	};
+}
+
+/** Build a D166 strict-JSON frame from an in-memory AgenticMemoryRecord. */
+
+function validateAndProjectKgDrafts(
+	value: unknown,
+	records: readonly AgenticMemoryRecord[],
+): {
+	readonly assertions: KnowledgeAssertion[];
+	readonly errors: Omit<AgenticMemoryKgProjectionError, "cursor">[];
+	readonly invalidDrafts: number;
+} {
+	const assertions: KnowledgeAssertion[] = [];
+	const errors: Omit<AgenticMemoryKgProjectionError, "cursor">[] = [];
+	let invalidDrafts = 0;
+	if (!Array.isArray(value)) {
+		return {
+			assertions,
+			invalidDrafts: 1,
+			errors: [
+				{
+					code: "invalid-drafts-input",
+					message: "agenticMemoryKgProjectionBundle: drafts input must be an array",
+					draft: value,
+				},
+			],
+		};
+	}
+	const length = safeArrayLength(value);
+	if (length === undefined) {
+		return {
+			assertions,
+			invalidDrafts: 1,
+			errors: [
+				{
+					code: "invalid-drafts-input",
+					message: "agenticMemoryKgProjectionBundle: drafts input length could not be read",
+					draft: value,
+				},
+			],
+		};
+	}
+	const recordById = new Map(records.map((record) => [record.id, record]));
+	const fragmentToRecord = new Map(records.map((record) => [record.fragment.id, record.id]));
+	const seenAssertions = new Set<FactId>();
+	for (let i = 0; i < length; i += 1) {
+		let raw: unknown;
+		try {
+			raw = value[i];
+			const result = validateKgDraft(raw, i);
+			if (result.errors.length > 0 || result.draft === undefined) {
+				invalidDrafts += 1;
+				errors.push(...result.errors);
+				continue;
+			}
+			const draft = result.draft;
+			if (seenAssertions.has(draft.id)) {
+				invalidDrafts += 1;
+				errors.push({
+					code: "duplicate-assertion-id",
+					message: "agenticMemoryKgProjectionBundle: duplicate assertion id",
+					index: i,
+					assertionId: draft.id,
+					recordId: draft.recordId,
+					fragmentId: draft.fragmentId,
+					draft: raw,
+					validationErrors: [`duplicate assertion id '${draft.id}'`],
+				});
+				continue;
+			}
+			const record = recordById.get(draft.recordId);
+			if (record === undefined) {
+				invalidDrafts += 1;
+				errors.push({
+					code: "missing-record-ref",
+					message: "agenticMemoryKgProjectionBundle: draft references a missing record",
+					index: i,
+					assertionId: draft.id,
+					recordId: draft.recordId,
+					fragmentId: draft.fragmentId,
+					draft: raw,
+					validationErrors: [`record '${draft.recordId}' is not projected`],
+				});
+				continue;
+			}
+			const owner = fragmentToRecord.get(draft.fragmentId);
+			if (owner === undefined) {
+				invalidDrafts += 1;
+				errors.push({
+					code: "missing-fragment-ref",
+					message: "agenticMemoryKgProjectionBundle: draft references a missing fragment",
+					index: i,
+					assertionId: draft.id,
+					recordId: draft.recordId,
+					fragmentId: draft.fragmentId,
+					draft: raw,
+					validationErrors: [`fragment '${draft.fragmentId}' is not projected`],
+				});
+				continue;
+			}
+			if (owner !== draft.recordId || record.fragment.id !== draft.fragmentId) {
+				invalidDrafts += 1;
+				errors.push({
+					code: "fragment-record-mismatch",
+					message: "agenticMemoryKgProjectionBundle: draft record and fragment refs disagree",
+					index: i,
+					assertionId: draft.id,
+					recordId: draft.recordId,
+					fragmentId: draft.fragmentId,
+					draft: raw,
+					validationErrors: [
+						`fragment '${draft.fragmentId}' belongs to record '${owner}', not '${draft.recordId}'`,
+					],
+				});
+				continue;
+			}
+			seenAssertions.add(draft.id);
+			assertions.push(
+				Object.freeze({
+					id: draft.id,
+					recordId: draft.recordId,
+					fragmentId: draft.fragmentId,
+					subject: draft.subject,
+					predicate: draft.predicate,
+					object: draft.object,
+					...(draft.confidence === undefined ? {} : { confidence: draft.confidence }),
+					sources: Object.freeze(draft.sources ?? [draft.fragmentId]),
+					...(draft.provenance === undefined ? {} : { provenance: draft.provenance }),
+				}),
+			);
+		} catch (error) {
+			invalidDrafts += 1;
+			errors.push({
+				code: "invalid-draft",
+				message: `agenticMemoryKgProjectionBundle: draft access failed: ${errorMessage(error)}`,
+				index: i,
+				draft: raw,
+				validationErrors: ["draft access failed"],
+			});
+		}
+	}
+	return { assertions, errors, invalidDrafts };
+}
+
+function validateKgDraft(
+	value: unknown,
+	index: number,
+): {
+	readonly draft?: AgenticMemoryKgAssertionDraft;
+	readonly errors: Omit<AgenticMemoryKgProjectionError, "cursor">[];
+} {
+	const errors: Omit<AgenticMemoryKgProjectionError, "cursor">[] = [];
+	if (!isPlainRecord(value)) {
+		return {
+			errors: [
+				{
+					code: "invalid-draft",
+					message: "agenticMemoryKgProjectionBundle: draft must be an object",
+					index,
+					draft: value,
+				},
+			],
+		};
+	}
+	const raw = value as Partial<AgenticMemoryKgAssertionDraft>;
+	const id = typeof raw.id === "string" && raw.id.length > 0 ? raw.id : undefined;
+	const recordId =
+		typeof raw.recordId === "string" && raw.recordId.length > 0 ? raw.recordId : undefined;
+	const fragmentId =
+		typeof raw.fragmentId === "string" && raw.fragmentId.length > 0 ? raw.fragmentId : undefined;
+	const subject = validateAssertionSubject(raw.subject);
+	const object = validateAssertionObject(raw.object);
+	const shapeErrors: string[] = [];
+	if (id === undefined) shapeErrors.push("draft.id must be a non-empty string");
+	if (recordId === undefined) {
+		shapeErrors.push("draft.recordId must be a non-empty string");
+	}
+	if (fragmentId === undefined) {
+		shapeErrors.push("draft.fragmentId must be a non-empty string");
+	}
+	shapeErrors.push(...subject.errors);
+	if (typeof raw.predicate !== "string" || raw.predicate.length === 0) {
+		shapeErrors.push("draft.predicate must be a non-empty string");
+	}
+	shapeErrors.push(...object.errors);
+	if (
+		raw.confidence !== undefined &&
+		(!Number.isFinite(raw.confidence) || raw.confidence < 0 || raw.confidence > 1)
+	) {
+		shapeErrors.push("draft.confidence must be a finite number in [0, 1]");
+	}
+	if (raw.sources !== undefined && !isDenseArrayOf(raw.sources, isNonEmptyString)) {
+		shapeErrors.push("draft.sources must be a readonly string array");
+	}
+	if (raw.provenance !== undefined && typeof raw.provenance !== "string") {
+		shapeErrors.push("draft.provenance must be a string when present");
+	}
+	if (shapeErrors.length > 0) errors.push(kgShapeError(index, value, ...shapeErrors));
+	if (errors.length > 0 || id === undefined || recordId === undefined || fragmentId === undefined) {
+		return { errors };
+	}
+	return {
+		draft: Object.freeze({
+			id,
+			recordId,
+			fragmentId,
+			subject: subject.subject as KnowledgeAssertionSubject,
+			predicate: raw.predicate as string,
+			object: object.object as KnowledgeAssertionObject,
+			...(raw.confidence === undefined ? {} : { confidence: raw.confidence }),
+			...(raw.sources === undefined ? {} : { sources: Object.freeze([...raw.sources]) }),
+			...(raw.provenance === undefined ? {} : { provenance: raw.provenance }),
+		}),
+		errors,
+	};
+}
+
+function validateAssertionSubject(value: unknown): {
+	readonly subject?: KnowledgeAssertionSubject;
+	readonly errors: readonly string[];
+} {
+	if (!isPlainRecord(value)) return { errors: ["subject must be an object"] };
+	const id = value.id;
+	const type = value.type;
+	const errors: string[] = [];
+	if (typeof id !== "string" || id.length === 0) errors.push("subject.id must be non-empty");
+	if (type !== undefined && (typeof type !== "string" || type.length === 0)) {
+		errors.push("subject.type must be a non-empty string when present");
+	}
+	if (errors.length > 0) return { errors };
+	return {
+		subject: Object.freeze({
+			id: id as string,
+			...(type === undefined ? {} : { type: type as string }),
+		}),
+		errors,
+	};
+}
+
+function validateAssertionObject(value: unknown): {
+	readonly object?: KnowledgeAssertionObject;
+	readonly errors: readonly string[];
+} {
+	if (!isPlainRecord(value)) return { errors: ["object must be an object"] };
+	const kind = value.kind;
+	const errors: string[] = [];
+	if (kind === "entity") {
+		if (typeof value.id !== "string" || value.id.length === 0) {
+			errors.push("object.id must be non-empty for entity objects");
+		}
+		if (value.type !== undefined && (typeof value.type !== "string" || value.type.length === 0)) {
+			errors.push("object.type must be a non-empty string when present");
+		}
+		if (Object.hasOwn(value, "value")) errors.push("entity object must not include value");
+		if (errors.length > 0) return { errors };
+		return {
+			object: Object.freeze({
+				kind: "entity",
+				id: value.id as string,
+				...(value.type === undefined ? {} : { type: value.type as string }),
+			}),
+			errors,
+		};
+	}
+	if (kind === "value") {
+		if (!Object.hasOwn(value, "value")) errors.push("value object must include value");
+		else {
+			try {
+				assertStrictJsonValue(value.value, "object.value");
+			} catch (error) {
+				errors.push(errorMessage(error));
+			}
+		}
+		if (
+			value.valueType !== undefined &&
+			(typeof value.valueType !== "string" || value.valueType.length === 0)
+		) {
+			errors.push("object.valueType must be a non-empty string when present");
+		}
+		if (Object.hasOwn(value, "id")) errors.push("value object must not include id");
+		if (errors.length > 0) return { errors };
+		return {
+			object: Object.freeze({
+				kind: "value",
+				value: value.value as StrictJsonValue,
+				...(value.valueType === undefined ? {} : { valueType: value.valueType as string }),
+			}),
+			errors,
+		};
+	}
+	return { errors: ["object.kind must be entity or value"] };
+}
+
+function kgShapeError(
+	index: number,
+	draft: unknown,
+	...validationErrors: readonly string[]
+): Omit<AgenticMemoryKgProjectionError, "cursor"> {
+	return {
+		code: "invalid-assertion-shape",
+		message: "agenticMemoryKgProjectionBundle: draft assertion shape is invalid",
+		index,
+		draft,
+		validationErrors: Object.freeze([...validationErrors]),
+	};
+}
+
+function kgErrorFromRecordError(
+	error: Omit<AgenticMemoryError, "cursor">,
+): Omit<AgenticMemoryKgProjectionError, "cursor"> {
+	return {
+		...error,
+		code: error.code,
+	};
+}
diff --git a/packages/ts/src/solutions/agentic-memory-projection.ts b/packages/ts/src/solutions/agentic-memory-projection.ts
new file mode 100644
index 00000000..0b209f70
--- /dev/null
+++ b/packages/ts/src/solutions/agentic-memory-projection.ts
@@ -0,0 +1,178 @@
+import { depBatch, depLatest } from "../ctx/types.js";
+import type { Graph } from "../graph/graph.js";
+import type { Node } from "../node/node.js";
+import type { MemoryRetrievalSnapshot } from "../patterns/semantic-memory-graph.js";
+import {
+	agenticStatusState,
+	contextState,
+	validateAndProjectRecords,
+} from "./agentic-memory-shared.js";
+import type {
+	AgenticMemoryContext,
+	AgenticMemoryProjectionCursor,
+	AgenticMemoryProjectionSnapshot,
+	AgenticMemoryRecord,
+	AgenticMemoryStatus,
+} from "./agentic-memory-types.js";
+
+export function solutionProjection<TFact, TSnapshot>(
+	graph: Graph,
+	snapshot: Node<TSnapshot>,
+	name: string,
+	factory: string,
+	select: (fact: TSnapshot) => TFact,
+): Node<TFact> {
+	return graph.node<TFact>(
+		[snapshot],
+		(ctx) => {
+			for (const raw of depBatch(ctx, 0) ?? []) {
+				ctx.down([["DATA", select(raw as TSnapshot)]]);
+			}
+		},
+		{
+			name,
+			factory,
+			completeWhenDepsComplete: false,
+			errorWhenDepsError: false,
+		},
+	);
+}
+
+export function agenticMemoryProjection<TFact, T>(
+	graph: Graph,
+	snapshot: Node<AgenticMemoryProjectionSnapshot<T>>,
+	name: string,
+	factory: string,
+	select: (fact: AgenticMemoryProjectionSnapshot<T>) => TFact,
+): Node<TFact> {
+	return graph.node<TFact>(
+		[snapshot],
+		(ctx) => {
+			for (const raw of depBatch(ctx, 0) ?? []) {
+				ctx.down([["DATA", select(raw as AgenticMemoryProjectionSnapshot<T>)]]);
+			}
+		},
+		{
+			name,
+			factory,
+			completeWhenDepsComplete: false,
+			errorWhenDepsError: false,
+		},
+	);
+}
+
+export function agenticMemoryContextProjection<T>(
+	graph: Graph,
+	projection: Node<AgenticMemoryProjectionSnapshot<T>>,
+	retrieval: Node<MemoryRetrievalSnapshot<T>>,
+	name: string,
+): Node<AgenticMemoryContext<T>> {
+	return graph.node<AgenticMemoryContext<T>>(
+		[projection, retrieval],
+		(ctx) => {
+			const projectionFact = depLatest(ctx, 0) as AgenticMemoryProjectionSnapshot<T> | undefined;
+			const retrievalFacts = depBatch(ctx, 1) ?? [];
+			if (projectionFact === undefined || retrievalFacts.length === 0) return;
+			for (const raw of retrievalFacts) {
+				ctx.down([
+					["DATA", contextFromSnapshot(projectionFact, raw as MemoryRetrievalSnapshot<T>)],
+				]);
+			}
+		},
+		{
+			name,
+			factory: "agenticMemoryContext",
+			completeWhenDepsComplete: false,
+			errorWhenDepsError: false,
+		},
+	);
+}
+
+export function contextFromSnapshot<T>(
+	projection: AgenticMemoryProjectionSnapshot<T>,
+	retrieval: MemoryRetrievalSnapshot<T>,
+): AgenticMemoryContext<T> {
+	const entries = retrieval.ranked.results.map((fragment) =>
+		Object.freeze({
+			fragmentId: fragment.id,
+			payload: fragment.payload,
+			confidence: fragment.confidence,
+			tags: fragment.tags,
+			sources: fragment.sources,
+			...(projection.metadataByFragmentId[fragment.id] === undefined
+				? {}
+				: { record: projection.metadataByFragmentId[fragment.id] }),
+			fragment,
+		}),
+	);
+	const hasContext = entries.length > 0;
+	const state = contextState(projection.status.state, retrieval.status.state);
+	return Object.freeze({
+		state,
+		query: retrieval.ranked.query,
+		entries: Object.freeze(entries),
+		cursor: retrieval.cursor,
+		errors: projection.errors,
+		retrievalErrors: retrieval.errors,
+		contextReady: hasContext && (state === "ready" || state === "partial"),
+	});
+}
+
+export function agenticMemoryRecordProjection<T>(
+	graph: Graph,
+	records: Node<readonly AgenticMemoryRecord<T>[]>,
+	name: string,
+): Node<AgenticMemoryProjectionSnapshot<T>> {
+	return graph.node<AgenticMemoryProjectionSnapshot<T>>(
+		[records],
+		(ctx) => {
+			const state =
+				ctx.state.get<{ evaluation: number }>() ??
+				({ evaluation: 0 } satisfies { evaluation: number });
+			state.evaluation += 1;
+			const rawRecords = (depBatch(ctx, 0) ?? []).at(-1);
+			const projected = validateAndProjectRecords<T>(rawRecords);
+			const cursor: AgenticMemoryProjectionCursor = Object.freeze({
+				evaluation: state.evaluation,
+				validRecords: projected.records.length,
+				invalidRecords: projected.invalidRecordIndexes.size,
+				projectedFragments: projected.fragments.length,
+			});
+			const status: AgenticMemoryStatus = Object.freeze({
+				state: agenticStatusState(projected.errors.length, projected.records.length),
+				cursor,
+			});
+			const errors = Object.freeze(
+				projected.errors.map((error) =>
+					Object.freeze({
+						...error,
+						...(error.validationErrors === undefined
+							? {}
+							: { validationErrors: Object.freeze([...error.validationErrors]) }),
+						cursor,
+					}),
+				),
+			);
+			ctx.state.set(state);
+			ctx.down([
+				[
+					"DATA",
+					Object.freeze({
+						records: Object.freeze(projected.records),
+						fragments: Object.freeze(projected.fragments),
+						metadataByFragmentId: Object.freeze(projected.metadataByFragmentId),
+						status,
+						errors,
+						cursor,
+					}),
+				],
+			]);
+		},
+		{
+			name,
+			factory: "agenticMemoryProjection",
+			completeWhenDepsComplete: false,
+			errorWhenDepsError: false,
+		},
+	);
+}
diff --git a/packages/ts/src/solutions/agentic-memory-retention.ts b/packages/ts/src/solutions/agentic-memory-retention.ts
new file mode 100644
index 00000000..8035bac0
--- /dev/null
+++ b/packages/ts/src/solutions/agentic-memory-retention.ts
@@ -0,0 +1,443 @@
+import { depLatest } from "../ctx/types.js";
+import type { Graph } from "../graph/graph.js";
+import type { FactId } from "../patterns/semantic-memory.js";
+import { solutionProjection } from "./agentic-memory-projection.js";
+import {
+	agenticStatusState,
+	errorMessage,
+	freezeError,
+	isAgenticMemoryPersistenceLevel,
+	isDenseArrayOf,
+	isNonEmptyString,
+	isPlainRecord,
+	safeArrayLength,
+	validateAndProjectRecords,
+} from "./agentic-memory-shared.js";
+import type {
+	AgenticMemoryConsolidationRequest,
+	AgenticMemoryError,
+	AgenticMemoryPersistenceLevel,
+	AgenticMemoryRecord,
+	AgenticMemoryRetentionBundle,
+	AgenticMemoryRetentionBundleOptions,
+	AgenticMemoryRetentionCommand,
+	AgenticMemoryRetentionCursor,
+	AgenticMemoryRetentionError,
+	AgenticMemoryRetentionSnapshot,
+	AgenticMemoryRetentionStatus,
+} from "./agentic-memory-types.js";
+
+export function agenticMemoryRetentionBundle<T = unknown>(
+	graph: Graph,
+	opts: AgenticMemoryRetentionBundleOptions<T>,
+): AgenticMemoryRetentionBundle<T> {
+	const name = opts.name ?? "agenticMemoryRetention";
+	const projection = graph.node<AgenticMemoryRetentionSnapshot<T>>(
+		[opts.records, opts.commands],
+		(ctx) => {
+			const state =
+				ctx.state.get<{ evaluation: number }>() ??
+				({ evaluation: 0 } satisfies { evaluation: number });
+			state.evaluation += 1;
+			const recordProjection = validateAndProjectRecords<T>(depLatest(ctx, 0));
+			const retention = projectRetention<T>(depLatest(ctx, 1), recordProjection.records);
+			const cursor: AgenticMemoryRetentionCursor = Object.freeze({
+				evaluation: state.evaluation,
+				validRecords: recordProjection.records.length,
+				validCommands: retention.validCommands,
+				invalidCommands: retention.invalidCommands,
+				activeRecords: retention.activeRecords.length,
+				archivedRecords: retention.archivedRecords.length,
+				consolidationRequests: retention.consolidationRequests.length,
+			});
+			const errors = Object.freeze(
+				[...recordProjection.errors.map(retentionErrorFromRecordError), ...retention.errors].map(
+					(error) => freezeError({ ...error, cursor }),
+				),
+			);
+			const status: AgenticMemoryRetentionStatus = Object.freeze({
+				state: agenticStatusState(errors.length, recordProjection.records.length),
+				cursor,
+			});
+			ctx.state.set(state);
+			ctx.down([
+				[
+					"DATA",
+					Object.freeze({
+						activeRecords: Object.freeze(retention.activeRecords),
+						archivedRecords: Object.freeze(retention.archivedRecords),
+						consolidationRequests: Object.freeze(retention.consolidationRequests),
+						status,
+						errors,
+						cursor,
+					}),
+				],
+			]);
+		},
+		{
+			name: `${name}/projection`,
+			factory: "agenticMemoryRetention",
+			completeWhenDepsComplete: false,
+			errorWhenDepsError: false,
+		},
+	);
+	return {
+		input: { records: opts.records, commands: opts.commands },
+		projection,
+		activeRecords: solutionProjection(
+			graph,
+			projection,
+			`${name}/activeRecords`,
+			"agenticMemoryRetentionActiveRecords",
+			(fact) => fact.activeRecords,
+		),
+		archivedRecords: solutionProjection(
+			graph,
+			projection,
+			`${name}/archivedRecords`,
+			"agenticMemoryRetentionArchivedRecords",
+			(fact) => fact.archivedRecords,
+		),
+		consolidationRequests: solutionProjection(
+			graph,
+			projection,
+			`${name}/consolidationRequests`,
+			"agenticMemoryRetentionConsolidationRequests",
+			(fact) => fact.consolidationRequests,
+		),
+		status: solutionProjection(
+			graph,
+			projection,
+			`${name}/status`,
+			"agenticMemoryRetentionStatus",
+			(fact) => fact.status,
+		),
+		errors: solutionProjection(
+			graph,
+			projection,
+			`${name}/errors`,
+			"agenticMemoryRetentionErrors",
+			(fact) => fact.errors,
+		),
+		cursor: solutionProjection(
+			graph,
+			projection,
+			`${name}/cursor`,
+			"agenticMemoryRetentionCursor",
+			(fact) => fact.cursor,
+		),
+	};
+}
+
+/**
+ * D171 consolidation outcome projection.
+ *
+ * The bundle does not execute consolidation. External adapters may publish
+ * outcome facts, and this projection turns them into visible result/proposal
+ * facts for downstream record-creation policy.
+ */
+
+function projectRetention<T>(
+	value: unknown,
+	records: readonly AgenticMemoryRecord<T>[],
+): {
+	readonly activeRecords: AgenticMemoryRecord<T>[];
+	readonly archivedRecords: AgenticMemoryRecord<T>[];
+	readonly consolidationRequests: AgenticMemoryConsolidationRequest[];
+	readonly errors: Omit<AgenticMemoryRetentionError, "cursor">[];
+	readonly validCommands: number;
+	readonly invalidCommands: number;
+} {
+	const byId = new Map(records.map((record) => [record.id, record]));
+	const view = new Map(records.map((record) => [record.id, record]));
+	const requests: AgenticMemoryConsolidationRequest[] = [];
+	const errors: Omit<AgenticMemoryRetentionError, "cursor">[] = [];
+	let validCommands = 0;
+	let invalidCommands = 0;
+	if (!Array.isArray(value)) {
+		return {
+			activeRecords: records.filter((record) => record.persistenceLevel !== "archived"),
+			archivedRecords: records.filter((record) => record.persistenceLevel === "archived"),
+			consolidationRequests: requests,
+			validCommands,
+			invalidCommands: 1,
+			errors: [
+				{
+					code: "invalid-commands-input",
+					message: "agenticMemoryRetentionBundle: commands input must be an array",
+					command: value,
+				},
+			],
+		};
+	}
+	const length = safeArrayLength(value);
+	if (length === undefined) {
+		return {
+			activeRecords: records.filter((record) => record.persistenceLevel !== "archived"),
+			archivedRecords: records.filter((record) => record.persistenceLevel === "archived"),
+			consolidationRequests: requests,
+			validCommands,
+			invalidCommands: 1,
+			errors: [
+				{
+					code: "invalid-commands-input",
+					message: "agenticMemoryRetentionBundle: commands input length could not be read",
+					command: value,
+				},
+			],
+		};
+	}
+	const seenCommands = new Set<FactId>();
+	for (let i = 0; i < length; i += 1) {
+		let raw: unknown;
+		try {
+			raw = value[i];
+			const result = validateRetentionCommand(raw, i);
+			if (result.errors.length > 0 || result.command === undefined) {
+				invalidCommands += 1;
+				errors.push(...result.errors);
+				continue;
+			}
+			const command = result.command;
+			if (seenCommands.has(command.id)) {
+				invalidCommands += 1;
+				errors.push({
+					code: "duplicate-command-id",
+					message: "agenticMemoryRetentionBundle: duplicate command id",
+					index: i,
+					commandId: command.id,
+					command: raw,
+					validationErrors: [`duplicate command id '${command.id}'`],
+				});
+				continue;
+			}
+			const missing = retentionMissingRecords(command, byId);
+			if (missing.length > 0) {
+				invalidCommands += 1;
+				errors.push({
+					code: "missing-record-ref",
+					message: "agenticMemoryRetentionBundle: command references missing records",
+					index: i,
+					commandId: command.id,
+					recordId: "recordId" in command ? command.recordId : undefined,
+					recordIds: Object.freeze(missing),
+					command: raw,
+					validationErrors: Object.freeze(missing.map((id) => `record '${id}' is not projected`)),
+				});
+				continue;
+			}
+			seenCommands.add(command.id);
+			validCommands += 1;
+			applyRetentionCommand(command, byId, view, requests);
+		} catch (error) {
+			invalidCommands += 1;
+			errors.push({
+				code: "invalid-command",
+				message: `agenticMemoryRetentionBundle: command access failed: ${errorMessage(error)}`,
+				index: i,
+				command: raw,
+				validationErrors: ["command access failed"],
+			});
+		}
+	}
+	const projected = records.map((record) => view.get(record.id) ?? record);
+	return {
+		activeRecords: projected.filter((record) => record.persistenceLevel !== "archived"),
+		archivedRecords: projected.filter((record) => record.persistenceLevel === "archived"),
+		consolidationRequests: requests,
+		errors,
+		validCommands,
+		invalidCommands,
+	};
+}
+
+function validateRetentionCommand(
+	value: unknown,
+	index: number,
+): {
+	readonly command?: AgenticMemoryRetentionCommand;
+	readonly errors: Omit<AgenticMemoryRetentionError, "cursor">[];
+} {
+	if (!isPlainRecord(value)) {
+		return {
+			errors: [
+				{
+					code: "invalid-command",
+					message: "agenticMemoryRetentionBundle: command must be an object",
+					index,
+					command: value,
+				},
+			],
+		};
+	}
+	const id = typeof value.id === "string" && value.id.length > 0 ? value.id : undefined;
+	const kind = value.kind;
+	const errors: string[] = [];
+	if (id === undefined) errors.push("command.id must be a non-empty string");
+	if (
+		kind !== "archive" &&
+		kind !== "restore" &&
+		kind !== "setPersistenceLevel" &&
+		kind !== "requestConsolidation"
+	) {
+		errors.push("command.kind is invalid");
+	}
+	if (value.reason !== undefined && typeof value.reason !== "string") {
+		errors.push("command.reason must be a string when present");
+	}
+	if (kind === "archive") {
+		if (!isNonEmptyString(value.recordId)) errors.push("command.recordId must be non-empty");
+	} else if (kind === "restore") {
+		if (!isNonEmptyString(value.recordId)) errors.push("command.recordId must be non-empty");
+		if (
+			value.persistenceLevel !== undefined &&
+			(!isAgenticMemoryPersistenceLevel(value.persistenceLevel) ||
+				value.persistenceLevel === "archived")
+		) {
+			errors.push("restore.persistenceLevel must be a non-archived persistence level when present");
+		}
+	} else if (kind === "setPersistenceLevel") {
+		if (!isNonEmptyString(value.recordId)) errors.push("command.recordId must be non-empty");
+		if (!isAgenticMemoryPersistenceLevel(value.persistenceLevel)) {
+			errors.push("setPersistenceLevel.persistenceLevel is invalid");
+		}
+	} else if (kind === "requestConsolidation") {
+		if (!isDenseArrayOf(value.recordIds, isNonEmptyString) || value.recordIds.length === 0) {
+			errors.push("requestConsolidation.recordIds must be a non-empty string array");
+		}
+		if (
+			value.requestId !== undefined &&
+			(typeof value.requestId !== "string" || value.requestId.length === 0)
+		) {
+			errors.push("requestConsolidation.requestId must be non-empty when present");
+		}
+	}
+	if (errors.length > 0 || id === undefined) {
+		return {
+			errors: [
+				{
+					code: "invalid-command",
+					message: "agenticMemoryRetentionBundle: command is invalid",
+					index,
+					commandId: id,
+					command: value,
+					validationErrors: Object.freeze(errors),
+				},
+			],
+		};
+	}
+	const base = { id, reason: value.reason as string | undefined };
+	if (kind === "archive") {
+		return {
+			command: Object.freeze({
+				...base,
+				kind,
+				recordId: value.recordId as string,
+				...(base.reason === undefined ? {} : { reason: base.reason }),
+			}),
+			errors: [],
+		};
+	}
+	if (kind === "restore") {
+		return {
+			command: Object.freeze({
+				...base,
+				kind,
+				recordId: value.recordId as string,
+				...(value.persistenceLevel === undefined
+					? {}
+					: {
+							persistenceLevel: value.persistenceLevel as Exclude<
+								AgenticMemoryPersistenceLevel,
+								"archived"
+							>,
+						}),
+				...(base.reason === undefined ? {} : { reason: base.reason }),
+			}),
+			errors: [],
+		};
+	}
+	if (kind === "setPersistenceLevel") {
+		return {
+			command: Object.freeze({
+				...base,
+				kind,
+				recordId: value.recordId as string,
+				persistenceLevel: value.persistenceLevel as AgenticMemoryPersistenceLevel,
+				...(base.reason === undefined ? {} : { reason: base.reason }),
+			}),
+			errors: [],
+		};
+	}
+	return {
+		command: Object.freeze({
+			...base,
+			kind: "requestConsolidation",
+			recordIds: Object.freeze([...(value.recordIds as readonly string[])]),
+			...(value.requestId === undefined ? {} : { requestId: value.requestId as string }),
+			...(base.reason === undefined ? {} : { reason: base.reason }),
+		}),
+		errors: [],
+	};
+}
+
+function retentionMissingRecords(
+	command: AgenticMemoryRetentionCommand,
+	records: ReadonlyMap<FactId, AgenticMemoryRecord>,
+): readonly FactId[] {
+	if ("recordId" in command) return records.has(command.recordId) ? [] : [command.recordId];
+	return command.recordIds.filter((recordId) => !records.has(recordId));
+}
+
+function applyRetentionCommand<T>(
+	command: AgenticMemoryRetentionCommand,
+	source: ReadonlyMap<FactId, AgenticMemoryRecord<T>>,
+	view: Map<FactId, AgenticMemoryRecord<T>>,
+	requests: AgenticMemoryConsolidationRequest[],
+): void {
+	if (command.kind === "requestConsolidation") {
+		requests.push(
+			Object.freeze({
+				id: command.requestId ?? command.id,
+				commandId: command.id,
+				recordIds: Object.freeze([...command.recordIds]),
+				...(command.reason === undefined ? {} : { reason: command.reason }),
+			}),
+		);
+		return;
+	}
+	const record = view.get(command.recordId) ?? source.get(command.recordId);
+	if (record === undefined) return;
+	const persistenceLevel =
+		command.kind === "archive"
+			? "archived"
+			: command.kind === "restore"
+				? (command.persistenceLevel ?? nonArchivedLevel(source.get(command.recordId) ?? record))
+				: command.persistenceLevel;
+	view.set(command.recordId, withPersistenceLevel(record, persistenceLevel));
+}
+
+function nonArchivedLevel(
+	record: AgenticMemoryRecord,
+): Exclude<AgenticMemoryPersistenceLevel, "archived"> {
+	return record.persistenceLevel === "archived" ? "session" : record.persistenceLevel;
+}
+
+function withPersistenceLevel<T>(
+	record: AgenticMemoryRecord<T>,
+	persistenceLevel: AgenticMemoryPersistenceLevel,
+): AgenticMemoryRecord<T> {
+	return Object.freeze({
+		...record,
+		persistenceLevel,
+	});
+}
+
+function retentionErrorFromRecordError(
+	error: Omit<AgenticMemoryError, "cursor">,
+): Omit<AgenticMemoryRetentionError, "cursor"> {
+	return {
+		...error,
+		code: error.code,
+	};
+}
diff --git a/packages/ts/src/solutions/agentic-memory-shared.ts b/packages/ts/src/solutions/agentic-memory-shared.ts
new file mode 100644
index 00000000..4aef3b3a
--- /dev/null
+++ b/packages/ts/src/solutions/agentic-memory-shared.ts
@@ -0,0 +1,635 @@
+import { strictJsonCodec } from "../json/codec.js";
+import type { MemoryFragment } from "../patterns/semantic-memory.js";
+import { validateMemoryFragment } from "../patterns/semantic-memory.js";
+import type {
+	AgenticMemoryArtifactKind,
+	AgenticMemoryError,
+	AgenticMemoryKind,
+	AgenticMemoryPersistenceLevel,
+	AgenticMemoryRecord,
+	AgenticMemoryRecordMetadata,
+	AgenticMemoryScope,
+	AgenticMemoryStatusState,
+	StrictJsonValue,
+} from "./agentic-memory-types.js";
+
+export function validateAndProjectRecords<T>(value: unknown): {
+	readonly records: AgenticMemoryRecord<T>[];
+	readonly fragments: MemoryFragment<T>[];
+	readonly metadataByFragmentId: Record<FactId, AgenticMemoryRecordMetadata>;
+	readonly errors: Omit<AgenticMemoryError, "cursor">[];
+	readonly invalidRecordIndexes: Set<number>;
+} {
+	const records: AgenticMemoryRecord<T>[] = [];
+	const fragments: MemoryFragment<T>[] = [];
+	const metadataByFragmentId = Object.create(null) as Record<FactId, AgenticMemoryRecordMetadata>;
+	const errors: Omit<AgenticMemoryError, "cursor">[] = [];
+	const invalidRecordIndexes = new Set<number>();
+	const seenRecordIds = new Set<FactId>();
+	const seenFragmentIds = new Set<FactId>();
+	if (!Array.isArray(value)) {
+		errors.push({
+			code: "invalid-records-input",
+			message: "agenticMemoryBundle: records input must be an array",
+			record: value,
+		});
+		return { records, fragments, metadataByFragmentId, errors, invalidRecordIndexes };
+	}
+	const length = safeArrayLength(value);
+	if (length === undefined) {
+		errors.push({
+			code: "invalid-records-input",
+			message: "agenticMemoryBundle: records input length could not be read",
+			record: value,
+		});
+		return { records, fragments, metadataByFragmentId, errors, invalidRecordIndexes };
+	}
+	for (let i = 0; i < length; i += 1) {
+		let raw: unknown;
+		try {
+			raw = value[i];
+		} catch (error) {
+			invalidRecordIndexes.add(i);
+			errors.push({
+				code: "invalid-record",
+				message: `agenticMemoryBundle: record access failed: ${errorMessage(error)}`,
+				index: i,
+				validationErrors: Object.freeze(["record access failed"]),
+			});
+			continue;
+		}
+		const result = validateAndSnapshotRecord<T>(raw, i);
+		if (result.errors.length > 0) {
+			invalidRecordIndexes.add(i);
+			errors.push(...result.errors);
+			continue;
+		}
+		if (result.record === undefined) continue;
+		if (seenRecordIds.has(result.record.id)) {
+			invalidRecordIndexes.add(i);
+			errors.push({
+				code: "duplicate-record-id",
+				message: "agenticMemoryBundle: duplicate record id",
+				index: i,
+				recordId: result.record.id,
+				record: raw,
+				validationErrors: [`duplicate record id '${result.record.id}'`],
+			});
+			continue;
+		}
+		if (seenFragmentIds.has(result.record.fragment.id)) {
+			invalidRecordIndexes.add(i);
+			errors.push({
+				code: "duplicate-fragment-id",
+				message: "agenticMemoryBundle: duplicate fragment id",
+				index: i,
+				recordId: result.record.id,
+				fragmentId: result.record.fragment.id,
+				record: raw,
+				validationErrors: [`duplicate fragment id '${result.record.fragment.id}'`],
+			});
+			continue;
+		}
+		seenRecordIds.add(result.record.id);
+		seenFragmentIds.add(result.record.fragment.id);
+		records.push(result.record);
+		fragments.push(result.record.fragment);
+		metadataByFragmentId[result.record.fragment.id] = recordMetadata(result.record);
+	}
+	return { records, fragments, metadataByFragmentId, errors, invalidRecordIndexes };
+}
+
+export function validateAndSnapshotRecord<T>(
+	value: unknown,
+	index: number,
+): {
+	readonly record?: AgenticMemoryRecord<T>;
+	readonly errors: Omit<AgenticMemoryError, "cursor">[];
+} {
+	try {
+		return validateAndSnapshotRecordInner<T>(value, index);
+	} catch (error) {
+		return {
+			errors: [
+				{
+					code: "invalid-record",
+					message: `agenticMemoryBundle: record access failed: ${errorMessage(error)}`,
+					index,
+					record: value,
+					validationErrors: Object.freeze(["record access failed"]),
+				},
+			],
+		};
+	}
+}
+
+export function validateAndSnapshotRecordInner<T>(
+	value: unknown,
+	index: number,
+): {
+	readonly record?: AgenticMemoryRecord<T>;
+	readonly errors: Omit<AgenticMemoryError, "cursor">[];
+} {
+	const errors: Omit<AgenticMemoryError, "cursor">[] = [];
+	if (typeof value !== "object" || value === null || Array.isArray(value)) {
+		return {
+			errors: [
+				{
+					code: "invalid-record",
+					message: "agenticMemoryBundle: record must be an object",
+					index,
+					record: value,
+				},
+			],
+		};
+	}
+	const record = value as Partial<AgenticMemoryRecord<T>> & Record<string, unknown>;
+	const recordId = typeof record.id === "string" ? record.id : undefined;
+	if (recordId === undefined || recordId.length === 0) {
+		errors.push({
+			code: "invalid-record",
+			message: "agenticMemoryBundle: record.id must be a non-empty string",
+			index,
+			record: value,
+			validationErrors: ["record.id must be a non-empty string"],
+		});
+	}
+	if (!isAgenticMemoryKind(record.kind)) {
+		errors.push({
+			code: "invalid-record-kind",
+			message: "agenticMemoryBundle: record.kind is invalid",
+			index,
+			recordId,
+			record: value,
+			validationErrors: ["kind must be one of working, episodic, semantic, procedural, profile"],
+		});
+	}
+	if (!isAgenticMemoryPersistenceLevel(record.persistenceLevel)) {
+		errors.push({
+			code: "invalid-persistence-level",
+			message: "agenticMemoryBundle: record.persistenceLevel is invalid",
+			index,
+			recordId,
+			record: value,
+			validationErrors: [
+				"persistenceLevel must be one of turn, session, project, longTerm, permanent, archived",
+			],
+		});
+	}
+	if (!isAgenticMemoryArtifactKind(record.artifactKind)) {
+		errors.push({
+			code: "invalid-artifact-kind",
+			message: "agenticMemoryBundle: record.artifactKind is invalid",
+			index,
+			recordId,
+			record: value,
+			validationErrors: ["artifactKind must be one of raw, insight, profile, procedure"],
+		});
+	}
+	const scopeValidation = validateScope(record.scope);
+	if (!scopeValidation.ok) {
+		errors.push({
+			code: "invalid-scope",
+			message: "agenticMemoryBundle: record.scope is invalid",
+			index,
+			recordId,
+			record: value,
+			validationErrors: Object.freeze(scopeValidation.errors),
+		});
+	}
+	const fragmentValidation = validateMemoryFragment(record.fragment);
+	if (!fragmentValidation.ok) {
+		errors.push({
+			code: "invalid-fragment",
+			message: "agenticMemoryBundle: record.fragment is invalid",
+			index,
+			recordId,
+			fragmentId:
+				typeof record.fragment === "object" &&
+				record.fragment !== null &&
+				typeof (record.fragment as Partial<MemoryFragment>).id === "string"
+					? (record.fragment as Partial<MemoryFragment>).id
+					: undefined,
+			record: value,
+			validationErrors: Object.freeze([...fragmentValidation.errors]),
+		});
+	}
+	const forbiddenFields = [
+		"storageTier",
+		"storageKey",
+		"adapter",
+		"collection",
+		"collections",
+		"ttl",
+		"ttlMs",
+		"ttlNs",
+		"expiresAt",
+		"timer",
+		"scheduler",
+		"schedule",
+		"retentionTimer",
+		"consolidationSchedule",
+		"reflectionSchedule",
+		"llm",
+		"llmHandle",
+		"tool",
+		"toolHandle",
+		"runner",
+		"runnerHandle",
+		"restore",
+		"hydrate",
+		"hydration",
+		"graphMutation",
+		"protocol",
+	] as const;
+	const presentForbidden = forbiddenFields.filter((field) => Object.hasOwn(record, field));
+	if (presentForbidden.length > 0) {
+		errors.push({
+			code: "invalid-record",
+			message: "agenticMemoryBundle: record contains forbidden runtime/persistence fields",
+			index,
+			recordId,
+			record: value,
+			validationErrors: Object.freeze(
+				presentForbidden.map((field) => `${field} is not part of AgenticMemoryRecord`),
+			),
+		});
+	}
+	if (errors.length > 0) return { errors };
+	const scope = scopeValidation.scope;
+	const fragment = snapshotFragment(record.fragment as MemoryFragment<T>);
+	return {
+		record: Object.freeze({
+			id: recordId as FactId,
+			kind: record.kind as AgenticMemoryKind,
+			persistenceLevel: record.persistenceLevel as AgenticMemoryPersistenceLevel,
+			artifactKind: record.artifactKind as AgenticMemoryArtifactKind,
+			...(scope === undefined ? {} : { scope }),
+			fragment,
+		}),
+		errors,
+	};
+}
+
+export function snapshotFragment<T>(fragment: MemoryFragment<T>): MemoryFragment<T> {
+	return Object.freeze({
+		id: fragment.id,
+		payload: fragment.payload,
+		tNs: fragment.tNs,
+		...(fragment.validFrom === undefined ? {} : { validFrom: fragment.validFrom }),
+		...(fragment.validTo === undefined ? {} : { validTo: fragment.validTo }),
+		confidence: fragment.confidence,
+		tags: Object.freeze([...fragment.tags]),
+		sources: Object.freeze([...fragment.sources]),
+		...(fragment.embedding === undefined
+			? {}
+			: { embedding: Object.freeze([...fragment.embedding]) }),
+		...(fragment.parentFragmentId === undefined
+			? {}
+			: { parentFragmentId: fragment.parentFragmentId }),
+		...(fragment.provenance === undefined ? {} : { provenance: fragment.provenance }),
+	});
+}
+
+export function recordMetadata(record: AgenticMemoryRecord): AgenticMemoryRecordMetadata {
+	return Object.freeze({
+		recordId: record.id,
+		kind: record.kind,
+		persistenceLevel: record.persistenceLevel,
+		artifactKind: record.artifactKind,
+		...(record.scope === undefined ? {} : { scope: record.scope }),
+	});
+}
+
+export function validateRecordMetadata(value: unknown): {
+	readonly ok: boolean;
+	readonly metadata?: AgenticMemoryRecordMetadata;
+	readonly errors: readonly string[];
+} {
+	if (value === undefined) return { ok: true, errors: [] };
+	if (!isPlainRecord(value)) {
+		return { ok: false, errors: ["record metadata must be an object when present"] };
+	}
+	const errors: string[] = [];
+	for (const key of Object.keys(value)) {
+		if (
+			key !== "recordId" &&
+			key !== "kind" &&
+			key !== "persistenceLevel" &&
+			key !== "artifactKind" &&
+			key !== "scope"
+		) {
+			errors.push(`record.${key} is not part of AgenticMemoryRecordMetadata`);
+		}
+	}
+	if (!isNonEmptyString(value.recordId)) {
+		errors.push("record.recordId must be a non-empty string");
+	}
+	if (!isAgenticMemoryKind(value.kind)) {
+		errors.push("record.kind is invalid");
+	}
+	if (!isAgenticMemoryPersistenceLevel(value.persistenceLevel)) {
+		errors.push("record.persistenceLevel is invalid");
+	}
+	if (!isAgenticMemoryArtifactKind(value.artifactKind)) {
+		errors.push("record.artifactKind is invalid");
+	}
+	const scopeValidation = validateScope(value.scope);
+	if (!scopeValidation.ok) {
+		errors.push(...scopeValidation.errors.map((error) => `record.${error}`));
+	}
+	if (errors.length > 0) return { ok: false, errors };
+	return {
+		ok: true,
+		errors,
+		metadata: Object.freeze({
+			recordId: value.recordId as FactId,
+			kind: value.kind as AgenticMemoryKind,
+			persistenceLevel: value.persistenceLevel as AgenticMemoryPersistenceLevel,
+			artifactKind: value.artifactKind as AgenticMemoryArtifactKind,
+			...(scopeValidation.scope === undefined ? {} : { scope: scopeValidation.scope }),
+		}),
+	};
+}
+
+export function contextState(
+	projection: AgenticMemoryStatusState,
+	retrieval: MemoryRetrievalStatus["state"],
+): AgenticMemoryContextState {
+	if (projection === "error" || retrieval === "error") return "error";
+	if (projection === "partial" || retrieval === "partial") return "partial";
+	return retrieval;
+}
+
+export function agenticStatusState(
+	errorCount: number,
+	validRecords: number,
+): AgenticMemoryStatusState {
+	if (errorCount > 0 && validRecords === 0) return "error";
+	if (errorCount > 0) return "partial";
+	return validRecords > 0 ? "ready" : "empty";
+}
+
+export function isAgenticMemoryKind(value: unknown): value is AgenticMemoryKind {
+	return (
+		value === "working" ||
+		value === "episodic" ||
+		value === "semantic" ||
+		value === "procedural" ||
+		value === "profile"
+	);
+}
+
+export function isAgenticMemoryPersistenceLevel(
+	value: unknown,
+): value is AgenticMemoryPersistenceLevel {
+	return (
+		value === "turn" ||
+		value === "session" ||
+		value === "project" ||
+		value === "longTerm" ||
+		value === "permanent" ||
+		value === "archived"
+	);
+}
+
+export function isAgenticMemoryArtifactKind(value: unknown): value is AgenticMemoryArtifactKind {
+	return value === "raw" || value === "insight" || value === "profile" || value === "procedure";
+}
+
+export function validateScope(value: unknown): {
+	readonly ok: boolean;
+	readonly scope?: AgenticMemoryScope;
+	readonly errors: readonly string[];
+} {
+	if (value === undefined) return { ok: true, errors: [] };
+	if (typeof value !== "object" || value === null || Array.isArray(value)) {
+		return { ok: false, errors: ["scope must be an object when present"] };
+	}
+	const scope = value as Record<string, unknown>;
+	const errors: string[] = [];
+	const allowed = new Set(["sessionId", "projectId", "userId", "tenantId"]);
+	for (const key of Object.keys(scope)) {
+		if (!allowed.has(key)) errors.push(`scope.${key} is not part of AgenticMemoryScope`);
+	}
+	for (const key of allowed) {
+		if (scope[key] !== undefined && (typeof scope[key] !== "string" || scope[key].length === 0)) {
+			errors.push(`scope.${key} must be a non-empty string when present`);
+		}
+	}
+	if (errors.length > 0) return { ok: false, errors };
+	return {
+		ok: true,
+		errors,
+		scope: Object.freeze({
+			...(scope.sessionId === undefined ? {} : { sessionId: scope.sessionId as string }),
+			...(scope.projectId === undefined ? {} : { projectId: scope.projectId as string }),
+			...(scope.userId === undefined ? {} : { userId: scope.userId as string }),
+			...(scope.tenantId === undefined ? {} : { tenantId: scope.tenantId as string }),
+		}),
+	};
+}
+
+export function isPlainRecord(value: unknown): value is Record<string, unknown> {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+export function ownKeys(value: Record<string, unknown>): readonly string[] {
+	return Object.keys(value).sort();
+}
+
+export function assertExactKeys(
+	value: Record<string, unknown>,
+	expected: readonly string[],
+	label: string,
+): void {
+	const actual = ownKeys(value);
+	const want = [...expected].sort();
+	if (actual.length !== want.length || actual.some((key, i) => key !== want[i])) {
+		throw new TypeError(`${label}: unexpected fields ${actual.join(",")}`);
+	}
+}
+
+export function assertAgenticMemoryRecordCodecShape(value: unknown): void {
+	if (!isPlainRecord(value)) {
+		throw new TypeError("agenticMemoryRecordFrame: record must be an object");
+	}
+	assertNoSymbolKeys(value, "agenticMemoryRecordFrame.record");
+	assertExactKeys(
+		value,
+		value.scope === undefined
+			? ["artifactKind", "fragment", "id", "kind", "persistenceLevel"]
+			: ["artifactKind", "fragment", "id", "kind", "persistenceLevel", "scope"],
+		"agenticMemoryRecordFrame.record",
+	);
+	const fragment = value.fragment;
+	if (!isPlainRecord(fragment)) {
+		throw new TypeError("agenticMemoryRecordFrame: fragment must be an object");
+	}
+	assertNoSymbolKeys(fragment, "agenticMemoryRecordFrame.record.fragment");
+	assertExactKeys(
+		fragment,
+		[
+			"id",
+			"payload",
+			"tNs",
+			...(fragment.validFrom === undefined ? [] : ["validFrom"]),
+			...(fragment.validTo === undefined ? [] : ["validTo"]),
+			"confidence",
+			"tags",
+			"sources",
+			...(fragment.embedding === undefined ? [] : ["embedding"]),
+			...(fragment.parentFragmentId === undefined ? [] : ["parentFragmentId"]),
+			...(fragment.provenance === undefined ? [] : ["provenance"]),
+		],
+		"agenticMemoryRecordFrame.record.fragment",
+	);
+	assertStrictJsonValue(fragment.tags, "record.fragment.tags");
+	assertStrictJsonValue(fragment.sources, "record.fragment.sources");
+	if (fragment.embedding !== undefined) {
+		assertStrictJsonValue(fragment.embedding, "record.fragment.embedding");
+	}
+	if (value.scope !== undefined) assertScopeFrame(value.scope);
+}
+
+export function assertNoSymbolKeys(value: object, label: string): void {
+	if (Object.getOwnPropertySymbols(value).length > 0) {
+		throw new TypeError(`${label}: unexpected symbol fields`);
+	}
+}
+
+export function decimalBigIntString(value: bigint, label: string): string {
+	const out = value.toString(10);
+	if (!/^-?(0|[1-9]\d*)$/.test(out)) {
+		throw new TypeError(`${label} must encode as a canonical decimal bigint string`);
+	}
+	return out;
+}
+
+export function parseDecimalBigInt(value: unknown, label: string): bigint {
+	if (typeof value !== "string" || !/^(0|-?[1-9]\d*)$/.test(value)) {
+		throw new TypeError(`${label} must be a canonical decimal bigint string`);
+	}
+	return BigInt(value);
+}
+
+export function assertStrictJsonValue(value: unknown, label: string): StrictJsonValue {
+	try {
+		strictJsonCodec.encode(value);
+		return value as StrictJsonValue;
+	} catch (error) {
+		throw new TypeError(`${label} must be strict JSON: ${errorMessage(error)}`);
+	}
+}
+
+export function assertScopeFrame(value: unknown): AgenticMemoryScope {
+	if (!isPlainRecord(value)) {
+		throw new TypeError("agenticMemoryRecordFrame: scope must be an object when present");
+	}
+	assertStrictJsonValue(value, "record.scope");
+	const validation = validateScope(value);
+	if (!validation.ok || validation.scope === undefined) {
+		throw new TypeError(`agenticMemoryRecordFrame: invalid scope: ${validation.errors.join("; ")}`);
+	}
+	assertExactKeys(
+		value as Record<string, unknown>,
+		[
+			...((value as Record<string, unknown>).sessionId === undefined ? [] : ["sessionId"]),
+			...((value as Record<string, unknown>).projectId === undefined ? [] : ["projectId"]),
+			...((value as Record<string, unknown>).userId === undefined ? [] : ["userId"]),
+			...((value as Record<string, unknown>).tenantId === undefined ? [] : ["tenantId"]),
+		],
+		"agenticMemoryRecordFrame.record.scope",
+	);
+	return validation.scope;
+}
+
+export function assertKindValue(value: unknown): AgenticMemoryKind {
+	if (!isAgenticMemoryKind(value)) {
+		throw new TypeError("agenticMemoryRecordFrame: invalid memory kind");
+	}
+	return value;
+}
+
+export function assertPersistenceLevelValue(value: unknown): AgenticMemoryPersistenceLevel {
+	if (!isAgenticMemoryPersistenceLevel(value)) {
+		throw new TypeError("agenticMemoryRecordFrame: invalid persistence level");
+	}
+	return value;
+}
+
+export function assertArtifactKindValue(value: unknown): AgenticMemoryArtifactKind {
+	if (!isAgenticMemoryArtifactKind(value)) {
+		throw new TypeError("agenticMemoryRecordFrame: invalid artifact kind");
+	}
+	return value;
+}
+
+export function assertNonEmptyString(value: unknown, label: string): string {
+	if (!isNonEmptyString(value)) throw new TypeError(`${label} must be a non-empty string`);
+	return value;
+}
+
+export function assertString(value: unknown, label: string): string {
+	if (typeof value !== "string") throw new TypeError(`${label} must be a string`);
+	return value;
+}
+
+export function assertConfidence(value: unknown, label: string): number {
+	if (!Number.isFinite(value) || (value as number) < 0 || (value as number) > 1) {
+		throw new TypeError(`${label} must be a finite number in [0, 1]`);
+	}
+	return value as number;
+}
+
+export function assertStringArray(value: unknown, label: string): readonly string[] {
+	if (!isDenseArrayOf(value, (item): item is string => typeof item === "string")) {
+		throw new TypeError(`${label} must be a readonly string array`);
+	}
+	return Object.freeze([...value]);
+}
+
+export function assertFiniteNumberArray(value: unknown, label: string): readonly number[] {
+	if (!isDenseArrayOf(value, (item): item is number => Number.isFinite(item))) {
+		throw new TypeError(`${label} must be a finite number array`);
+	}
+	return Object.freeze([...value]);
+}
+
+export function isNonEmptyString(value: unknown): value is string {
+	return typeof value === "string" && value.length > 0;
+}
+
+export function isDenseArrayOf<T>(
+	value: unknown,
+	predicate: (item: unknown) => item is T,
+): value is T[] {
+	if (!Array.isArray(value)) return false;
+	for (let i = 0; i < value.length; i += 1) {
+		if (!Object.hasOwn(value, i) || !predicate(value[i])) return false;
+	}
+	return true;
+}
+
+export function freezeError<T extends { readonly validationErrors?: readonly string[] }>(
+	error: T,
+): T {
+	return Object.freeze({
+		...error,
+		...(error.validationErrors === undefined
+			? {}
+			: { validationErrors: Object.freeze([...error.validationErrors]) }),
+	}) as T;
+}
+
+export function safeArrayLength(value: readonly unknown[]): number | undefined {
+	try {
+		return value.length;
+	} catch {
+		return undefined;
+	}
+}
+
+export function errorMessage(error: unknown): string {
+	return error instanceof Error ? error.message : String(error);
+}
diff --git a/packages/ts/src/solutions/agentic-memory-types.ts b/packages/ts/src/solutions/agentic-memory-types.ts
new file mode 100644
index 00000000..fbfa5275
--- /dev/null
+++ b/packages/ts/src/solutions/agentic-memory-types.ts
@@ -0,0 +1,606 @@
+import type { StrictJsonValue as SharedStrictJsonValue } from "../json/codec.js";
+import type { Node } from "../node/node.js";
+import type {
+	FactId,
+	KnowledgeAssertion,
+	KnowledgeAssertionObject,
+	KnowledgeAssertionSubject,
+	MemoryAnswer,
+	MemoryFragment,
+} from "../patterns/semantic-memory.js";
+import type {
+	MemoryRetrievalBundle,
+	MemoryRetrievalCursor,
+	MemoryRetrievalError,
+	MemoryRetrievalIndex,
+	MemoryRetrievalQuery,
+	MemoryRetrievalSnapshot,
+	MemoryRetrievalStatus,
+} from "../patterns/semantic-memory-graph.js";
+import type {
+	AGENTIC_MEMORY_RECORD_FRAME_FORMAT,
+	AGENTIC_MEMORY_RECORD_FRAME_VERSION,
+} from "./agentic-memory-frame.js";
+
+export type AgenticMemoryStrictJsonValue = SharedStrictJsonValue;
+
+export type StrictJsonValue = SharedStrictJsonValue;
+
+export type {
+	KnowledgeAssertion,
+	KnowledgeAssertionObject,
+	KnowledgeAssertionSubject,
+} from "../patterns/semantic-memory.js";
+
+/** Agent-facing memory category. D164 keeps this separate from durability and artifact kind. */
+export type AgenticMemoryKind = "working" | "episodic" | "semantic" | "procedural" | "profile";
+
+/** Semantic durability/retention policy metadata. This is not a storage tier handle. */
+export type AgenticMemoryPersistenceLevel =
+	| "turn"
+	| "session"
+	| "project"
+	| "longTerm"
+	| "permanent"
+	| "archived";
+
+/** Whether the record is raw evidence or a derived artifact. */
+export type AgenticMemoryArtifactKind = "raw" | "insight" | "profile" | "procedure";
+
+/** Optional solution-facing scope metadata. Scope ids are ordinary DATA facts. */
+export interface AgenticMemoryScope {
+	readonly sessionId?: string;
+	readonly projectId?: string;
+	readonly userId?: string;
+	readonly tenantId?: string;
+}
+
+/**
+ * D164 solution envelope over a lower-layer MemoryFragment.
+ *
+ * The envelope carries agentic-memory metadata only. It intentionally owns no
+ * storage tiers/keys/adapters, restore/hydration behavior, timers, schedulers,
+ * LLM/tool/runner handles, or protocol semantics.
+ */
+export interface AgenticMemoryRecord<T = unknown> {
+	readonly id: FactId;
+	readonly kind: AgenticMemoryKind;
+	readonly persistenceLevel: AgenticMemoryPersistenceLevel;
+	readonly artifactKind: AgenticMemoryArtifactKind;
+	readonly scope?: AgenticMemoryScope;
+	readonly fragment: MemoryFragment<T>;
+}
+
+export interface AgenticMemoryRecordMetadata {
+	readonly recordId: FactId;
+	readonly kind: AgenticMemoryKind;
+	readonly persistenceLevel: AgenticMemoryPersistenceLevel;
+	readonly artifactKind: AgenticMemoryArtifactKind;
+	readonly scope?: AgenticMemoryScope;
+}
+
+export interface AgenticMemoryProjectionCursor {
+	readonly evaluation: number;
+	readonly validRecords: number;
+	readonly invalidRecords: number;
+	readonly projectedFragments: number;
+}
+
+export type AgenticMemoryStatusState = "ready" | "empty" | "partial" | "error";
+
+export interface AgenticMemoryStatus {
+	readonly state: AgenticMemoryStatusState;
+	readonly cursor: AgenticMemoryProjectionCursor;
+}
+
+export type AgenticMemoryErrorCode =
+	| "duplicate-record-id"
+	| "duplicate-fragment-id"
+	| "invalid-records-input"
+	| "invalid-record"
+	| "invalid-record-kind"
+	| "invalid-persistence-level"
+	| "invalid-artifact-kind"
+	| "invalid-scope"
+	| "invalid-fragment";
+
+export interface AgenticMemoryError {
+	readonly code: AgenticMemoryErrorCode;
+	readonly message: string;
+	readonly index?: number;
+	readonly recordId?: FactId;
+	readonly fragmentId?: FactId;
+	readonly record?: unknown;
+	readonly validationErrors?: readonly string[];
+	readonly cursor: AgenticMemoryProjectionCursor;
+}
+
+export interface AgenticMemoryProjectionSnapshot<T = unknown> {
+	readonly records: readonly AgenticMemoryRecord<T>[];
+	readonly fragments: readonly MemoryFragment<T>[];
+	readonly metadataByFragmentId: Readonly<Record<FactId, AgenticMemoryRecordMetadata>>;
+	readonly status: AgenticMemoryStatus;
+	readonly errors: readonly AgenticMemoryError[];
+	readonly cursor: AgenticMemoryProjectionCursor;
+}
+
+/** Source/provenance projection for a valid memory fragment. */
+export interface AgenticMemorySourceProjection {
+	readonly fragmentId: FactId;
+	readonly record?: AgenticMemoryRecordMetadata;
+	readonly sources: readonly FactId[];
+	readonly parentFragmentId?: FactId;
+	readonly provenance?: string;
+}
+
+/** A context-ready item derived from ranked memory retrieval results. */
+export interface AgenticMemoryContextEntry<T = unknown> {
+	readonly fragmentId: FactId;
+	readonly payload: T;
+	readonly confidence: number;
+	readonly tags: readonly string[];
+	readonly sources: readonly FactId[];
+	readonly record?: AgenticMemoryRecordMetadata;
+	readonly fragment: MemoryFragment<T>;
+}
+
+export type AgenticMemoryContextState = "ready" | "empty" | "partial" | "error";
+
+/**
+ * Context-ready ranked memory output for callers such as prompt builders.
+ *
+ * This is still only a DATA fact. It does not extract, summarize, reflect, run
+ * tools, or choose an autonomous action.
+ */
+export interface AgenticMemoryContext<T = unknown> {
+	readonly state: AgenticMemoryContextState;
+	readonly query: MemoryRetrievalQuery;
+	readonly entries: readonly AgenticMemoryContextEntry<T>[];
+	readonly cursor: MemoryRetrievalCursor;
+	readonly errors: readonly AgenticMemoryError[];
+	readonly retrievalErrors: readonly MemoryRetrievalError[];
+	readonly contextReady: boolean;
+}
+
+/** Explicit KG assertion draft fact; extraction/LLM work happens outside this bundle. */
+export interface AgenticMemoryKgAssertionDraft {
+	readonly id: FactId;
+	readonly recordId: FactId;
+	readonly fragmentId: FactId;
+	readonly subject: KnowledgeAssertionSubject;
+	readonly predicate: string;
+	readonly object: KnowledgeAssertionObject;
+	readonly confidence?: number;
+	readonly sources?: readonly FactId[];
+	readonly provenance?: string;
+}
+
+export interface AgenticMemoryKgProjectionCursor {
+	readonly evaluation: number;
+	readonly validRecords: number;
+	readonly validDrafts: number;
+	readonly invalidDrafts: number;
+	readonly projectedAssertions: number;
+}
+
+export type AgenticMemoryKgProjectionStatusState = AgenticMemoryStatusState;
+
+export interface AgenticMemoryKgProjectionStatus {
+	readonly state: AgenticMemoryKgProjectionStatusState;
+	readonly cursor: AgenticMemoryKgProjectionCursor;
+}
+
+export type AgenticMemoryKgProjectionErrorCode =
+	| AgenticMemoryErrorCode
+	| "invalid-drafts-input"
+	| "invalid-draft"
+	| "duplicate-assertion-id"
+	| "missing-record-ref"
+	| "missing-fragment-ref"
+	| "fragment-record-mismatch"
+	| "invalid-assertion-shape";
+
+export interface AgenticMemoryKgProjectionError {
+	readonly code: AgenticMemoryKgProjectionErrorCode;
+	readonly message: string;
+	readonly index?: number;
+	readonly assertionId?: FactId;
+	readonly recordId?: FactId;
+	readonly fragmentId?: FactId;
+	readonly draft?: unknown;
+	readonly record?: unknown;
+	readonly validationErrors?: readonly string[];
+	readonly cursor: AgenticMemoryKgProjectionCursor;
+}
+
+export interface AgenticMemoryKgProjectionSnapshot {
+	readonly assertions: readonly KnowledgeAssertion[];
+	readonly status: AgenticMemoryKgProjectionStatus;
+	readonly errors: readonly AgenticMemoryKgProjectionError[];
+	readonly cursor: AgenticMemoryKgProjectionCursor;
+}
+
+export interface AgenticMemoryKgProjectionBundle {
+	readonly input: {
+		readonly records: Node<readonly AgenticMemoryRecord[]>;
+		readonly drafts: Node<readonly AgenticMemoryKgAssertionDraft[]>;
+	};
+	readonly projection: Node<AgenticMemoryKgProjectionSnapshot>;
+	readonly assertions: Node<readonly KnowledgeAssertion[]>;
+	readonly status: Node<AgenticMemoryKgProjectionStatus>;
+	readonly errors: Node<readonly AgenticMemoryKgProjectionError[]>;
+	readonly cursor: Node<AgenticMemoryKgProjectionCursor>;
+}
+
+export interface AgenticMemoryKgProjectionBundleOptions {
+	readonly name?: string;
+	readonly records: Node<readonly AgenticMemoryRecord[]>;
+	readonly drafts: Node<readonly AgenticMemoryKgAssertionDraft[]>;
+}
+
+export interface AgenticMemoryFragmentFrame<TJson extends StrictJsonValue = StrictJsonValue> {
+	readonly id: FactId;
+	readonly payload: TJson;
+	readonly tNs: string;
+	readonly validFrom?: string;
+	readonly validTo?: string;
+	readonly confidence: number;
+	readonly tags: readonly string[];
+	readonly sources: readonly FactId[];
+	readonly embedding?: readonly number[];
+	readonly parentFragmentId?: FactId;
+	readonly provenance?: string;
+}
+
+export interface AgenticMemoryRecordFrame<TJson extends StrictJsonValue = StrictJsonValue> {
+	readonly format: typeof AGENTIC_MEMORY_RECORD_FRAME_FORMAT;
+	readonly version: typeof AGENTIC_MEMORY_RECORD_FRAME_VERSION;
+	readonly record: {
+		readonly id: FactId;
+		readonly kind: AgenticMemoryKind;
+		readonly persistenceLevel: AgenticMemoryPersistenceLevel;
+		readonly artifactKind: AgenticMemoryArtifactKind;
+		readonly scope?: AgenticMemoryScope;
+		readonly fragment: AgenticMemoryFragmentFrame<TJson>;
+	};
+}
+
+export type AgenticMemoryRetentionCommand =
+	| {
+			readonly id: FactId;
+			readonly kind: "archive";
+			readonly recordId: FactId;
+			readonly reason?: string;
+	  }
+	| {
+			readonly id: FactId;
+			readonly kind: "restore";
+			readonly recordId: FactId;
+			readonly persistenceLevel?: Exclude<AgenticMemoryPersistenceLevel, "archived">;
+			readonly reason?: string;
+	  }
+	| {
+			readonly id: FactId;
+			readonly kind: "setPersistenceLevel";
+			readonly recordId: FactId;
+			readonly persistenceLevel: AgenticMemoryPersistenceLevel;
+			readonly reason?: string;
+	  }
+	| {
+			readonly id: FactId;
+			readonly kind: "requestConsolidation";
+			readonly recordIds: readonly FactId[];
+			readonly requestId?: FactId;
+			readonly reason?: string;
+	  };
+
+export interface AgenticMemoryConsolidationRequest {
+	readonly id: FactId;
+	readonly commandId: FactId;
+	readonly recordIds: readonly FactId[];
+	readonly reason?: string;
+}
+
+export interface AgenticMemoryRetentionCursor {
+	readonly evaluation: number;
+	readonly validRecords: number;
+	readonly validCommands: number;
+	readonly invalidCommands: number;
+	readonly activeRecords: number;
+	readonly archivedRecords: number;
+	readonly consolidationRequests: number;
+}
+
+export interface AgenticMemoryRetentionStatus {
+	readonly state: AgenticMemoryStatusState;
+	readonly cursor: AgenticMemoryRetentionCursor;
+}
+
+export type AgenticMemoryRetentionErrorCode =
+	| AgenticMemoryErrorCode
+	| "invalid-commands-input"
+	| "invalid-command"
+	| "duplicate-command-id"
+	| "missing-record-ref";
+
+export interface AgenticMemoryRetentionError {
+	readonly code: AgenticMemoryRetentionErrorCode;
+	readonly message: string;
+	readonly index?: number;
+	readonly commandId?: FactId;
+	readonly recordId?: FactId;
+	readonly recordIds?: readonly FactId[];
+	readonly command?: unknown;
+	readonly record?: unknown;
+	readonly validationErrors?: readonly string[];
+	readonly cursor: AgenticMemoryRetentionCursor;
+}
+
+export interface AgenticMemoryRetentionSnapshot<T = unknown> {
+	readonly activeRecords: readonly AgenticMemoryRecord<T>[];
+	readonly archivedRecords: readonly AgenticMemoryRecord<T>[];
+	readonly consolidationRequests: readonly AgenticMemoryConsolidationRequest[];
+	readonly status: AgenticMemoryRetentionStatus;
+	readonly errors: readonly AgenticMemoryRetentionError[];
+	readonly cursor: AgenticMemoryRetentionCursor;
+}
+
+export interface AgenticMemoryRetentionBundle<T = unknown> {
+	readonly input: {
+		readonly records: Node<readonly AgenticMemoryRecord<T>[]>;
+		readonly commands: Node<readonly AgenticMemoryRetentionCommand[]>;
+	};
+	readonly projection: Node<AgenticMemoryRetentionSnapshot<T>>;
+	readonly activeRecords: Node<readonly AgenticMemoryRecord<T>[]>;
+	readonly archivedRecords: Node<readonly AgenticMemoryRecord<T>[]>;
+	readonly consolidationRequests: Node<readonly AgenticMemoryConsolidationRequest[]>;
+	readonly status: Node<AgenticMemoryRetentionStatus>;
+	readonly errors: Node<readonly AgenticMemoryRetentionError[]>;
+	readonly cursor: Node<AgenticMemoryRetentionCursor>;
+}
+
+export interface AgenticMemoryRetentionBundleOptions<T = unknown> {
+	readonly name?: string;
+	readonly records: Node<readonly AgenticMemoryRecord<T>[]>;
+	readonly commands: Node<readonly AgenticMemoryRetentionCommand[]>;
+}
+
+export type AgenticMemoryConsolidationOutcome<T = unknown> =
+	| {
+			readonly id: FactId;
+			readonly requestId: FactId;
+			readonly kind: "proposedRecords";
+			readonly records: readonly AgenticMemoryRecord<T>[];
+			readonly provenance?: string;
+	  }
+	| {
+			readonly id: FactId;
+			readonly requestId: FactId;
+			readonly kind: "failed";
+			readonly message: string;
+			readonly provenance?: string;
+	  };
+
+export interface AgenticMemoryConsolidationRecordDraft<T = unknown> {
+	readonly id: FactId;
+	readonly requestId: FactId;
+	readonly outcomeId: FactId;
+	readonly record: AgenticMemoryRecord<T>;
+}
+
+export interface AgenticMemoryConsolidationCommand {
+	readonly id: FactId;
+	readonly kind: "proposeRecords" | "markFailed";
+	readonly requestId: FactId;
+	readonly outcomeId: FactId;
+	readonly draftIds?: readonly FactId[];
+	readonly message?: string;
+}
+
+export interface AgenticMemoryConsolidationResult {
+	readonly id: FactId;
+	readonly requestId: FactId;
+	readonly outcomeId: FactId;
+	readonly state: "proposed" | "failed";
+	readonly sourceRecordIds: readonly FactId[];
+	readonly proposedRecordIds: readonly FactId[];
+	readonly message?: string;
+	readonly provenance?: string;
+}
+
+export interface AgenticMemoryConsolidationCursor {
+	readonly evaluation: number;
+	readonly validRequests: number;
+	readonly validOutcomes: number;
+	readonly invalidOutcomes: number;
+	readonly results: number;
+	readonly proposedRecordDrafts: number;
+}
+
+export interface AgenticMemoryConsolidationStatus {
+	readonly state: AgenticMemoryStatusState;
+	readonly cursor: AgenticMemoryConsolidationCursor;
+}
+
+export type AgenticMemoryConsolidationErrorCode =
+	| AgenticMemoryRetentionErrorCode
+	| "invalid-outcomes-input"
+	| "invalid-outcome"
+	| "duplicate-outcome-id"
+	| "missing-request-ref"
+	| "invalid-proposed-record";
+
+export interface AgenticMemoryConsolidationError {
+	readonly code: AgenticMemoryConsolidationErrorCode;
+	readonly message: string;
+	readonly index?: number;
+	readonly outcomeId?: FactId;
+	readonly requestId?: FactId;
+	readonly recordId?: FactId;
+	readonly outcome?: unknown;
+	readonly validationErrors?: readonly string[];
+	readonly cursor: AgenticMemoryConsolidationCursor;
+}
+
+export interface AgenticMemoryConsolidationSnapshot<T = unknown> {
+	readonly results: readonly AgenticMemoryConsolidationResult[];
+	readonly proposedRecordDrafts: readonly AgenticMemoryConsolidationRecordDraft<T>[];
+	readonly commands: readonly AgenticMemoryConsolidationCommand[];
+	readonly status: AgenticMemoryConsolidationStatus;
+	readonly errors: readonly AgenticMemoryConsolidationError[];
+	readonly cursor: AgenticMemoryConsolidationCursor;
+}
+
+export interface AgenticMemoryConsolidationBundle<T = unknown> {
+	readonly input: {
+		readonly records: Node<readonly AgenticMemoryRecord<T>[]>;
+		readonly requests: Node<readonly AgenticMemoryConsolidationRequest[]>;
+		readonly outcomes: Node<readonly AgenticMemoryConsolidationOutcome<T>[]>;
+	};
+	readonly projection: Node<AgenticMemoryConsolidationSnapshot<T>>;
+	readonly results: Node<readonly AgenticMemoryConsolidationResult[]>;
+	readonly proposedRecordDrafts: Node<readonly AgenticMemoryConsolidationRecordDraft<T>[]>;
+	readonly commands: Node<readonly AgenticMemoryConsolidationCommand[]>;
+	readonly status: Node<AgenticMemoryConsolidationStatus>;
+	readonly errors: Node<readonly AgenticMemoryConsolidationError[]>;
+	readonly cursor: Node<AgenticMemoryConsolidationCursor>;
+}
+
+export interface AgenticMemoryConsolidationBundleOptions<T = unknown> {
+	readonly name?: string;
+	readonly records: Node<readonly AgenticMemoryRecord<T>[]>;
+	readonly requests: Node<readonly AgenticMemoryConsolidationRequest[]>;
+	readonly outcomes: Node<readonly AgenticMemoryConsolidationOutcome<T>[]>;
+}
+
+export interface AgenticMemoryContextText {
+	readonly fragmentId: FactId;
+	readonly text: string;
+	readonly cost?: number;
+	readonly metadata?: Readonly<Record<string, StrictJsonValue>>;
+}
+
+export interface AgenticMemoryContextPackingPolicy {
+	readonly maxEntries?: number;
+	readonly maxChars?: number;
+	readonly maxCost?: number;
+	readonly includeMetadata?: boolean;
+}
+
+export interface AgenticMemoryPackedContextEntry {
+	readonly fragmentId: FactId;
+	readonly text: string;
+	readonly cost: number;
+	readonly chars: number;
+	readonly record?: AgenticMemoryRecordMetadata;
+	readonly metadata?: Readonly<Record<string, StrictJsonValue>>;
+}
+
+export interface AgenticMemoryPackedContext {
+	readonly entries: readonly AgenticMemoryPackedContextEntry[];
+	readonly text: string;
+	readonly totalChars: number;
+	readonly totalCost: number;
+	readonly truncated: boolean;
+}
+
+export interface AgenticMemoryContextPackingCursor {
+	readonly evaluation: number;
+	readonly inputEntries: number;
+	readonly packedEntries: number;
+	readonly omittedEntries: number;
+	readonly totalChars: number;
+	readonly totalCost: number;
+}
+
+export interface AgenticMemoryContextPackingStatus {
+	readonly state: AgenticMemoryStatusState;
+	readonly cursor: AgenticMemoryContextPackingCursor;
+}
+
+export type AgenticMemoryContextPackingErrorCode =
+	| "invalid-context"
+	| "invalid-texts-input"
+	| "invalid-text"
+	| "duplicate-text-fragment-id"
+	| "missing-text"
+	| "invalid-policy";
+
+export interface AgenticMemoryContextPackingError {
+	readonly code: AgenticMemoryContextPackingErrorCode;
+	readonly message: string;
+	readonly index?: number;
+	readonly fragmentId?: FactId;
+	readonly value?: unknown;
+	readonly validationErrors?: readonly string[];
+	readonly cursor: AgenticMemoryContextPackingCursor;
+}
+
+export interface AgenticMemoryContextPackingSnapshot {
+	readonly packedContext: AgenticMemoryPackedContext;
+	readonly status: AgenticMemoryContextPackingStatus;
+	readonly errors: readonly AgenticMemoryContextPackingError[];
+	readonly cursor: AgenticMemoryContextPackingCursor;
+}
+
+export interface AgenticMemoryContextPackingBundle<T = unknown> {
+	readonly input: {
+		readonly context: Node<AgenticMemoryContext<T>>;
+		readonly texts: Node<readonly AgenticMemoryContextText[]>;
+		readonly policy: Node<AgenticMemoryContextPackingPolicy>;
+	};
+	readonly projection: Node<AgenticMemoryContextPackingSnapshot>;
+	readonly packedContext: Node<AgenticMemoryPackedContext>;
+	readonly status: Node<AgenticMemoryContextPackingStatus>;
+	readonly errors: Node<readonly AgenticMemoryContextPackingError[]>;
+	readonly cursor: Node<AgenticMemoryContextPackingCursor>;
+}
+
+export interface AgenticMemoryContextPackingBundleOptions<T = unknown> {
+	readonly name?: string;
+	readonly context: Node<AgenticMemoryContext<T>>;
+	readonly texts: Node<readonly AgenticMemoryContextText[]>;
+	readonly policy: Node<AgenticMemoryContextPackingPolicy>;
+}
+
+export interface ValidatedPackingContext {
+	readonly entries: readonly AgenticMemoryContextEntry[];
+}
+
+export interface AgenticMemoryBundle<T = unknown> {
+	readonly input: {
+		readonly records: Node<readonly AgenticMemoryRecord<T>[]>;
+		readonly query: Node<MemoryRetrievalQuery>;
+	};
+	readonly projection: Node<AgenticMemoryProjectionSnapshot<T>>;
+	readonly retrieval: MemoryRetrievalBundle<T>;
+	readonly retrievalSnapshot: Node<MemoryRetrievalSnapshot<T>>;
+	readonly records: Node<readonly AgenticMemoryRecord<T>[]>;
+	readonly fragments: Node<readonly MemoryFragment<T>[]>;
+	readonly sources: Node<readonly AgenticMemorySourceProjection[]>;
+	readonly indexed: Node<MemoryRetrievalIndex<T>>;
+	readonly ranked: Node<MemoryAnswer<T>>;
+	readonly context: Node<AgenticMemoryContext<T>>;
+	readonly status: Node<AgenticMemoryStatus>;
+	readonly errors: Node<readonly AgenticMemoryError[]>;
+	readonly retrievalStatus: Node<MemoryRetrievalStatus>;
+	readonly retrievalErrors: Node<readonly MemoryRetrievalError[]>;
+	readonly cursor: Node<MemoryRetrievalCursor>;
+}
+
+export interface AgenticMemoryBundleOptions<T = unknown> {
+	readonly name?: string;
+	/** Explicit record-envelope input. Persistence, if needed, composes D161 outside this bundle. */
+	readonly records: Node<readonly AgenticMemoryRecord<T>[]>;
+	/** Explicit retrieval query input. */
+	readonly query: Node<MemoryRetrievalQuery>;
+}
+
+/**
+ * Compose graph-visible semantic-memory retrieval into an agentic-memory v0 bundle.
+ *
+ * The returned nodes are ordinary graph nodes with declared deps and DATA facts.
+ * Invalid record envelopes and duplicate record ids stay graph-visible through
+ * solution-level status/errors DATA facts. The lower retrieval bundle remains
+ * visible and receives only projected MemoryFragment values.
+ */
diff --git a/packages/ts/src/solutions/agentic-memory.ts b/packages/ts/src/solutions/agentic-memory.ts
new file mode 100644
index 00000000..1b847cd5
--- /dev/null
+++ b/packages/ts/src/solutions/agentic-memory.ts
@@ -0,0 +1,21 @@
+/**
+ * Thin agentic-memory solution surface.
+ *
+ * D125 places vertical application kits under solutions, while D158 keeps
+ * semantic-memory retrieval/ranking in horizontal patterns. This v0 bundle
+ * composes those lower layers into graph-visible facts only: no agent runtime,
+ * hidden scheduler, storage restore/hydration, LLM loop, or protocol behavior.
+ */
+
+export type {
+	KnowledgeAssertion,
+	KnowledgeAssertionObject,
+	KnowledgeAssertionSubject,
+} from "../patterns/semantic-memory.js";
+export * from "./agentic-memory-bundle.js";
+export * from "./agentic-memory-consolidation.js";
+export * from "./agentic-memory-context-packing.js";
+export * from "./agentic-memory-frame.js";
+export * from "./agentic-memory-kg.js";
+export * from "./agentic-memory-retention.js";
+export * from "./agentic-memory-types.js";
diff --git a/packages/ts/src/solutions/capability-admission.ts b/packages/ts/src/solutions/capability-admission.ts
new file mode 100644
index 00000000..38af853c
--- /dev/null
+++ b/packages/ts/src/solutions/capability-admission.ts
@@ -0,0 +1,847 @@
+/**
+ * Product-owned capability admission facts (D357).
+ *
+ * This helper consumes generic BoundaryCapabilityRef data and emits ordinary DATA
+ * facts for product admission state. It is not AutoPanel security, not a provider
+ * registry, and not protocol ERROR/tier/message semantics.
+ */
+
+import { type Ctx, depBatch } from "../ctx/types.js";
+import type { DataIssue } from "../data/index.js";
+import type { Graph } from "../graph/graph.js";
+import type { BoundaryCapabilityRef, BoundaryRole } from "../inspection/boundary.js";
+import type { Node } from "../node/node.js";
+import type { AgentRuntimeAuditRecord, SourceRef } from "../orchestration/agent-runtime.js";
+
+export type CapabilityAdmissionOutcome = "allow" | "block" | "defer";
+export type CapabilityAdmissionState = "allowed" | "blocked" | "deferred";
+
+export interface CapabilityAdmissionProposal {
+	readonly kind: "capability-admission-proposal";
+	readonly proposalId: string;
+	readonly subjectId: string;
+	readonly capability: BoundaryCapabilityRef;
+	readonly boundaryName?: string;
+	readonly role?: BoundaryRole;
+	readonly reason?: string;
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly proposedAtMs?: number;
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface CapabilityAdmissionPolicy {
+	readonly kind: "capability-admission-policy";
+	readonly policyId: string;
+	readonly capabilityIds?: readonly string[];
+	readonly capabilityKinds?: readonly BoundaryCapabilityRef["kind"][];
+	readonly requiredOnly?: boolean;
+	readonly allowedOutcomes?: readonly CapabilityAdmissionOutcome[];
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface CapabilityAdmissionDecision {
+	readonly kind: "capability-admission-decision";
+	readonly decisionId: string;
+	readonly admissionId: string;
+	readonly proposalId: string;
+	readonly outcome: CapabilityAdmissionOutcome;
+	readonly policyId?: string;
+	readonly reason?: string;
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly decidedAtMs?: number;
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface CapabilityAdmission {
+	readonly kind: "capability-admission";
+	readonly admissionId: string;
+	readonly proposalId: string;
+	readonly subjectId: string;
+	readonly capability: BoundaryCapabilityRef;
+	readonly state: CapabilityAdmissionState;
+	readonly decisionId: string;
+	readonly boundaryName?: string;
+	readonly role?: BoundaryRole;
+	readonly policyId?: string;
+	readonly reason?: string;
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly admittedAtMs?: number;
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface CapabilityAdmissionStatus {
+	readonly kind: "capability-admission-status";
+	readonly statusId: string;
+	readonly state:
+		| "capability-admission-allowed"
+		| "capability-admission-blocked"
+		| "capability-admission-deferred"
+		| "capability-admission-issue";
+	readonly proposalId?: string;
+	readonly admissionId?: string;
+	readonly subjectId?: string;
+	readonly capabilityId?: string;
+	readonly capabilityKind?: BoundaryCapabilityRef["kind"];
+	readonly policyId?: string;
+	readonly issues?: readonly DataIssue[];
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface CapabilityAdmissionViews {
+	readonly admissionsByProposal: ReadonlyMap<string, CapabilityAdmission>;
+	readonly admissionsBySubject: ReadonlyMap<string, readonly CapabilityAdmission[]>;
+	readonly issues: readonly DataIssue[];
+	readonly audit: readonly AgentRuntimeAuditRecord[];
+}
+
+export interface CapabilityAdmissionBundle {
+	readonly admissions: Node<CapabilityAdmission>;
+	readonly status: Node<CapabilityAdmissionStatus>;
+	readonly issues: Node<DataIssue>;
+	readonly audit: Node<AgentRuntimeAuditRecord>;
+	readonly views: Node<CapabilityAdmissionViews>;
+}
+
+type CapabilityAdmissionFact =
+	| { readonly kind: "admission"; readonly admission: CapabilityAdmission }
+	| { readonly kind: "status"; readonly status: CapabilityAdmissionStatus }
+	| { readonly kind: "issue"; readonly issue: DataIssue }
+	| { readonly kind: "audit"; readonly audit: AgentRuntimeAuditRecord };
+
+interface CapabilityAdmissionStateInternal {
+	proposals: Map<string, CapabilityAdmissionProposal>;
+	policies: Map<string, CapabilityAdmissionPolicy>;
+	decisions: Map<string, CapabilityAdmissionDecision>;
+	admissionsById: Map<string, CapabilityAdmission>;
+	admissionsByProposal: Map<string, CapabilityAdmission>;
+	terminalDecisionIds: Set<string>;
+	issueKeys: Set<string>;
+	issueSeq: number;
+	statusSeq: number;
+	auditSeq: number;
+}
+
+interface CapabilityAdmissionViewsState {
+	admissionsByProposal: Map<string, CapabilityAdmission>;
+	admissionsBySubject: Map<string, CapabilityAdmission[]>;
+	issues: DataIssue[];
+	audit: AgentRuntimeAuditRecord[];
+}
+
+export function capabilityAdmissionProposal(
+	opts: Omit<CapabilityAdmissionProposal, "kind">,
+): CapabilityAdmissionProposal {
+	return { kind: "capability-admission-proposal", ...opts };
+}
+
+export function capabilityAdmissionProjector(
+	graph: Graph,
+	opts: {
+		readonly name?: string;
+		readonly proposals: Node<CapabilityAdmissionProposal>;
+		readonly decisions: Node<CapabilityAdmissionDecision>;
+		readonly admissionPolicies?: readonly Node<CapabilityAdmissionPolicy>[];
+		readonly now?: () => number;
+	},
+): CapabilityAdmissionBundle {
+	const name = opts.name ?? "capabilityAdmissions";
+	const policyDeps = opts.admissionPolicies ?? [];
+	const now = opts.now ?? Date.now;
+	const runtime = graph.node<CapabilityAdmissionFact>(
+		[opts.proposals, opts.decisions, ...policyDeps],
+		(ctx) => {
+			const state =
+				ctx.state.get<CapabilityAdmissionStateInternal>() ?? emptyCapabilityAdmissionState();
+			for (const raw of depBatch(ctx, 0) ?? []) {
+				const proposal = raw as CapabilityAdmissionProposal;
+				const issue = capabilityAdmissionProposalIssue(proposal);
+				if (issue !== undefined) {
+					emitIssue(
+						ctx,
+						state,
+						nextMalformedIssueKey(state, "proposal", proposalKeyFallback(proposal)),
+						issue,
+					);
+					continue;
+				}
+				if (state.proposals.has(proposal.proposalId)) {
+					emitIssue(
+						ctx,
+						state,
+						`duplicate-proposal:${proposal.proposalId}`,
+						dataIssue(
+							"duplicate-capability-admission-proposal",
+							`CapabilityAdmissionProposal '${proposal.proposalId}' was already seen`,
+							{ subjectId: proposal.subjectId, refs: capabilityProposalRefs(proposal) },
+						),
+					);
+					continue;
+				}
+				state.proposals.set(proposal.proposalId, proposal);
+			}
+			forEachPolicyDepBatch(ctx, 2, policyDeps.length, (raw) => {
+				const policy = raw as CapabilityAdmissionPolicy;
+				const issue = capabilityAdmissionPolicyIssue(policy);
+				if (issue !== undefined) {
+					emitIssue(
+						ctx,
+						state,
+						nextMalformedIssueKey(state, "policy", policyKeyFallback(policy)),
+						issue,
+					);
+					return;
+				}
+				if (state.policies.has(policy.policyId)) {
+					emitIssue(
+						ctx,
+						state,
+						`duplicate-policy:${policy.policyId}`,
+						dataIssue(
+							"duplicate-capability-admission-policy",
+							`CapabilityAdmissionPolicy '${policy.policyId}' was already seen`,
+							{ refs: [ref("capability-admission-policy", policy.policyId)] },
+						),
+					);
+					return;
+				}
+				state.policies.set(policy.policyId, policy);
+			});
+			for (const raw of depBatch(ctx, 1) ?? []) {
+				const decision = raw as CapabilityAdmissionDecision;
+				const issue = capabilityAdmissionDecisionIssue(decision);
+				if (issue !== undefined) {
+					emitIssue(
+						ctx,
+						state,
+						nextMalformedIssueKey(state, "decision", decisionKeyFallback(decision)),
+						issue,
+					);
+					continue;
+				}
+				if (state.decisions.has(decision.decisionId)) {
+					emitIssue(
+						ctx,
+						state,
+						`duplicate-decision:${decision.decisionId}`,
+						dataIssue(
+							"duplicate-capability-admission-decision",
+							`CapabilityAdmissionDecision '${decision.decisionId}' was already seen`,
+							{ refs: capabilityDecisionRefs(decision) },
+						),
+					);
+					continue;
+				}
+				state.decisions.set(decision.decisionId, decision);
+			}
+			evaluateCapabilityAdmissions(ctx, state, now());
+			ctx.state.set(state);
+		},
+		{ name: `${name}/runtime`, factory: "capabilityAdmissionProjector", partial: true },
+	);
+	return {
+		admissions: projectRuntimeFact(
+			graph,
+			runtime,
+			`${name}/admissions`,
+			"capabilityAdmissions",
+			(fact) => (fact.kind === "admission" ? fact.admission : undefined),
+		),
+		status: projectRuntimeFact(
+			graph,
+			runtime,
+			`${name}/status`,
+			"capabilityAdmissionStatus",
+			(fact) => (fact.kind === "status" ? fact.status : undefined),
+		),
+		issues: projectRuntimeFact(
+			graph,
+			runtime,
+			`${name}/issues`,
+			"capabilityAdmissionIssues",
+			(fact) => (fact.kind === "issue" ? fact.issue : undefined),
+		),
+		audit: projectRuntimeFact(
+			graph,
+			runtime,
+			`${name}/audit`,
+			"capabilityAdmissionAudit",
+			(fact) => (fact.kind === "audit" ? fact.audit : undefined),
+		),
+		views: capabilityAdmissionViews(graph, runtime, `${name}/views`),
+	};
+}
+
+function evaluateCapabilityAdmissions(
+	ctx: Ctx,
+	state: CapabilityAdmissionStateInternal,
+	admittedAtMs: number,
+): void {
+	for (const decision of state.decisions.values()) {
+		if (state.terminalDecisionIds.has(decision.decisionId)) continue;
+		evaluateCapabilityAdmission(ctx, state, decision, admittedAtMs);
+	}
+}
+
+function evaluateCapabilityAdmission(
+	ctx: Ctx,
+	state: CapabilityAdmissionStateInternal,
+	decision: CapabilityAdmissionDecision,
+	admittedAtMs: number,
+): void {
+	const proposal = state.proposals.get(decision.proposalId);
+	if (proposal === undefined) {
+		emitIssue(
+			ctx,
+			state,
+			`missing-proposal:${decision.decisionId}:${decision.proposalId}`,
+			dataIssue(
+				"missing-capability-admission-proposal",
+				`CapabilityAdmissionDecision '${decision.decisionId}' references missing proposal '${decision.proposalId}'`,
+				{ subjectId: decision.proposalId, refs: capabilityDecisionRefs(decision) },
+			),
+		);
+		return;
+	}
+	const policy = capabilityPolicyForDecision(state, decision);
+	if (typeof policy === "string") {
+		emitIssue(
+			ctx,
+			state,
+			`${policy}:${decision.decisionId}:${decision.policyId ?? "missing"}`,
+			dataIssue(policy, capabilityPolicyIssueMessage(policy, decision), {
+				subjectId: proposal.subjectId,
+				refs: capabilityDecisionRefs(decision, proposal),
+			}),
+		);
+		if (policy === "stale-capability-admission-policy-ref")
+			state.terminalDecisionIds.add(decision.decisionId);
+		return;
+	}
+	if (policy !== undefined) {
+		const policyIssue = validateCapabilityAdmissionPolicy(policy, decision, proposal);
+		if (policyIssue !== undefined) {
+			emitIssue(
+				ctx,
+				state,
+				`${policyIssue.code}:${decision.decisionId}:${policy.policyId}`,
+				dataIssue(policyIssue.code, policyIssue.message, {
+					subjectId: proposal.subjectId,
+					refs: capabilityDecisionRefs(decision, proposal, policy),
+				}),
+			);
+			return;
+		}
+	}
+	if (state.admissionsById.has(decision.admissionId)) {
+		emitIssue(
+			ctx,
+			state,
+			`duplicate-admission-id:${decision.admissionId}`,
+			dataIssue(
+				"duplicate-capability-admission",
+				`CapabilityAdmission '${decision.admissionId}' was already emitted`,
+				{ subjectId: proposal.subjectId, refs: capabilityDecisionRefs(decision, proposal, policy) },
+			),
+		);
+		state.terminalDecisionIds.add(decision.decisionId);
+		return;
+	}
+	if (state.admissionsByProposal.has(decision.proposalId)) {
+		emitIssue(
+			ctx,
+			state,
+			`duplicate-admission-proposal:${decision.proposalId}:${decision.decisionId}`,
+			dataIssue(
+				"duplicate-capability-admission-proposal",
+				`CapabilityAdmissionProposal '${decision.proposalId}' already has an admission decision`,
+				{ subjectId: proposal.subjectId, refs: capabilityDecisionRefs(decision, proposal, policy) },
+			),
+		);
+		state.terminalDecisionIds.add(decision.decisionId);
+		return;
+	}
+	const admissionState = admissionStateForOutcome(decision.outcome);
+	if (admissionState === undefined) {
+		emitIssue(
+			ctx,
+			state,
+			`unsupported-outcome:${decision.decisionId}:${String(decision.outcome)}`,
+			dataIssue(
+				"unsupported-capability-admission-outcome",
+				`CapabilityAdmissionDecision '${decision.decisionId}' uses unsupported outcome '${String(decision.outcome)}'`,
+				{ subjectId: proposal.subjectId, refs: capabilityDecisionRefs(decision, proposal, policy) },
+			),
+		);
+		state.terminalDecisionIds.add(decision.decisionId);
+		return;
+	}
+	const admission: CapabilityAdmission = {
+		kind: "capability-admission",
+		admissionId: decision.admissionId,
+		proposalId: proposal.proposalId,
+		subjectId: proposal.subjectId,
+		capability: cloneCapabilityRef(proposal.capability),
+		state: admissionState,
+		decisionId: decision.decisionId,
+		boundaryName: proposal.boundaryName,
+		role: proposal.role,
+		policyId: decision.policyId,
+		reason: decision.reason ?? proposal.reason,
+		sourceRefs: capabilityDecisionRefs(decision, proposal, policy),
+		admittedAtMs: decision.decidedAtMs ?? admittedAtMs,
+		metadata: {
+			...(proposal.metadata ?? {}),
+			...(policy?.metadata ?? {}),
+			...(decision.metadata ?? {}),
+		},
+	};
+	state.admissionsById.set(admission.admissionId, admission);
+	state.admissionsByProposal.set(admission.proposalId, admission);
+	state.terminalDecisionIds.add(decision.decisionId);
+	emitAdmission(ctx, state, admission);
+}
+
+function capabilityAdmissionViews(
+	graph: Graph,
+	runtime: Node<CapabilityAdmissionFact>,
+	name: string,
+): Node<CapabilityAdmissionViews> {
+	return graph.node<CapabilityAdmissionViews>(
+		[runtime],
+		(ctx) => {
+			const state: CapabilityAdmissionViewsState =
+				ctx.state.get<CapabilityAdmissionViewsState>() ?? {
+					admissionsByProposal: new Map(),
+					admissionsBySubject: new Map(),
+					issues: [],
+					audit: [],
+				};
+			for (const raw of depBatch(ctx, 0) ?? []) {
+				const fact = raw as CapabilityAdmissionFact;
+				if (fact.kind === "admission") {
+					const admission = fact.admission;
+					state.admissionsByProposal.set(admission.proposalId, admission);
+					const bySubject = state.admissionsBySubject.get(admission.subjectId) ?? [];
+					bySubject.push(admission);
+					state.admissionsBySubject.set(admission.subjectId, bySubject);
+				}
+				if (fact.kind === "issue") state.issues.push(fact.issue);
+				if (fact.kind === "audit") state.audit.push(fact.audit);
+			}
+			ctx.state.set(state);
+			ctx.down([["DATA", freezeCapabilityAdmissionViews(state)]]);
+		},
+		{ name, factory: "capabilityAdmissionViews" },
+	);
+}
+
+function emitAdmission(
+	ctx: Ctx,
+	state: CapabilityAdmissionStateInternal,
+	admission: CapabilityAdmission,
+): void {
+	state.statusSeq += 1;
+	state.auditSeq += 1;
+	const statusState = capabilityAdmissionStatusState(admission.state);
+	const status: CapabilityAdmissionStatus = {
+		kind: "capability-admission-status",
+		statusId: `${admission.subjectId}:${statusState}:${state.statusSeq}`,
+		state: statusState,
+		proposalId: admission.proposalId,
+		admissionId: admission.admissionId,
+		subjectId: admission.subjectId,
+		capabilityId: admission.capability.id,
+		capabilityKind: admission.capability.kind,
+		policyId: admission.policyId,
+		sourceRefs: admission.sourceRefs,
+	};
+	const audit: AgentRuntimeAuditRecord = {
+		id: `${admission.subjectId}:${statusState}:${state.auditSeq}`,
+		kind: `capability-admission-${admission.state}`,
+		subjectId: admission.subjectId,
+		sourceRefs: admission.sourceRefs,
+		metadata: {
+			admissionId: admission.admissionId,
+			capabilityId: admission.capability.id,
+			capabilityKind: admission.capability.kind,
+			policyId: admission.policyId,
+			proposalId: admission.proposalId,
+		},
+	};
+	ctx.down([
+		["DATA", { kind: "admission", admission } satisfies CapabilityAdmissionFact],
+		["DATA", { kind: "status", status } satisfies CapabilityAdmissionFact],
+		["DATA", { kind: "audit", audit } satisfies CapabilityAdmissionFact],
+	]);
+}
+
+function emitIssue(
+	ctx: Ctx,
+	state: CapabilityAdmissionStateInternal,
+	key: string,
+	issue: DataIssue,
+): void {
+	if (state.issueKeys.has(key)) return;
+	state.issueKeys.add(key);
+	state.statusSeq += 1;
+	state.auditSeq += 1;
+	const status: CapabilityAdmissionStatus = {
+		kind: "capability-admission-status",
+		statusId: `capability-admission-issue:${state.statusSeq}`,
+		state: "capability-admission-issue",
+		subjectId: issue.subjectId,
+		issues: [issue],
+	};
+	const audit: AgentRuntimeAuditRecord = {
+		id: `capability-admission-issue:${state.auditSeq}`,
+		kind: "capability-admission-issue",
+		subjectId: issue.subjectId,
+		message: issue.message,
+		issueCode: issue.code,
+	};
+	ctx.down([
+		["DATA", { kind: "issue", issue } satisfies CapabilityAdmissionFact],
+		["DATA", { kind: "status", status } satisfies CapabilityAdmissionFact],
+		["DATA", { kind: "audit", audit } satisfies CapabilityAdmissionFact],
+	]);
+}
+
+function capabilityAdmissionProposalIssue(
+	proposal: CapabilityAdmissionProposal,
+): DataIssue | undefined {
+	if (
+		proposal.kind !== "capability-admission-proposal" ||
+		typeof proposal.proposalId !== "string" ||
+		proposal.proposalId.length === 0 ||
+		typeof proposal.subjectId !== "string" ||
+		proposal.subjectId.length === 0 ||
+		!isBoundaryCapabilityRef(proposal.capability)
+	) {
+		return dataIssue(
+			"malformed-capability-admission-proposal",
+			"CapabilityAdmissionProposal requires proposalId, subjectId, and a D348 BoundaryCapabilityRef",
+			{ subjectId: typeof proposal.subjectId === "string" ? proposal.subjectId : undefined },
+		);
+	}
+	return undefined;
+}
+
+function capabilityAdmissionPolicyIssue(policy: CapabilityAdmissionPolicy): DataIssue | undefined {
+	if (
+		policy.kind !== "capability-admission-policy" ||
+		typeof policy.policyId !== "string" ||
+		policy.policyId.length === 0 ||
+		(policy.capabilityIds !== undefined &&
+			(!Array.isArray(policy.capabilityIds) ||
+				!policy.capabilityIds.every((id) => typeof id === "string" && id.length > 0))) ||
+		(policy.capabilityKinds !== undefined &&
+			(!Array.isArray(policy.capabilityKinds) ||
+				!policy.capabilityKinds.every(isBoundaryCapabilityKind))) ||
+		(policy.requiredOnly !== undefined && typeof policy.requiredOnly !== "boolean") ||
+		(policy.allowedOutcomes !== undefined &&
+			(!Array.isArray(policy.allowedOutcomes) ||
+				!policy.allowedOutcomes.every(isCapabilityAdmissionOutcome)))
+	) {
+		return dataIssue(
+			"malformed-capability-admission-policy",
+			"CapabilityAdmissionPolicy requires a policyId and D348 capability/outcome filters",
+			{ subjectId: typeof policy.policyId === "string" ? policy.policyId : undefined },
+		);
+	}
+	return undefined;
+}
+
+function capabilityAdmissionDecisionIssue(
+	decision: CapabilityAdmissionDecision,
+): DataIssue | undefined {
+	if (
+		decision.kind !== "capability-admission-decision" ||
+		typeof decision.decisionId !== "string" ||
+		decision.decisionId.length === 0 ||
+		typeof decision.admissionId !== "string" ||
+		decision.admissionId.length === 0 ||
+		typeof decision.proposalId !== "string" ||
+		decision.proposalId.length === 0 ||
+		!isCapabilityAdmissionOutcome(decision.outcome) ||
+		(decision.policyId !== undefined &&
+			(typeof decision.policyId !== "string" || decision.policyId.length === 0))
+	) {
+		return dataIssue(
+			"malformed-capability-admission-decision",
+			"CapabilityAdmissionDecision requires decisionId, admissionId, proposalId, and allow/block/defer outcome",
+			{ subjectId: typeof decision.proposalId === "string" ? decision.proposalId : undefined },
+		);
+	}
+	return undefined;
+}
+
+function validateCapabilityAdmissionPolicy(
+	policy: CapabilityAdmissionPolicy,
+	decision: CapabilityAdmissionDecision,
+	proposal: CapabilityAdmissionProposal,
+): { readonly code: string; readonly message: string } | undefined {
+	if (
+		policy.capabilityIds !== undefined &&
+		!policy.capabilityIds.includes(proposal.capability.id)
+	) {
+		return {
+			code: "capability-admission-policy-mismatch",
+			message: `CapabilityAdmissionPolicy '${policy.policyId}' does not apply to capability '${proposal.capability.id}'`,
+		};
+	}
+	if (
+		policy.capabilityKinds !== undefined &&
+		!policy.capabilityKinds.includes(proposal.capability.kind)
+	) {
+		return {
+			code: "capability-admission-policy-mismatch",
+			message: `CapabilityAdmissionPolicy '${policy.policyId}' does not apply to capability kind '${proposal.capability.kind}'`,
+		};
+	}
+	if (policy.requiredOnly === true && !proposal.capability.required) {
+		return {
+			code: "capability-admission-policy-mismatch",
+			message: `CapabilityAdmissionPolicy '${policy.policyId}' applies only to required capabilities`,
+		};
+	}
+	if (policy.allowedOutcomes !== undefined && !policy.allowedOutcomes.includes(decision.outcome)) {
+		return {
+			code: "unsupported-capability-admission-outcome",
+			message: `CapabilityAdmissionPolicy '${policy.policyId}' does not allow outcome '${decision.outcome}'`,
+		};
+	}
+	return undefined;
+}
+
+function capabilityPolicyForDecision(
+	state: CapabilityAdmissionStateInternal,
+	decision: CapabilityAdmissionDecision,
+):
+	| CapabilityAdmissionPolicy
+	| "missing-capability-admission-policy"
+	| "stale-capability-admission-policy-ref"
+	| undefined {
+	if (decision.policyId === undefined) return undefined;
+	const stalePolicyRef = (decision.sourceRefs ?? []).find(
+		(sourceRef) =>
+			sourceRef.kind === "capability-admission-policy" && sourceRef.id !== decision.policyId,
+	);
+	if (stalePolicyRef !== undefined) return "stale-capability-admission-policy-ref";
+	return state.policies.get(decision.policyId) ?? "missing-capability-admission-policy";
+}
+
+function capabilityPolicyIssueMessage(
+	code: "missing-capability-admission-policy" | "stale-capability-admission-policy-ref",
+	decision: CapabilityAdmissionDecision,
+): string {
+	if (code === "missing-capability-admission-policy") {
+		return `CapabilityAdmissionPolicy '${decision.policyId}' was referenced but not present`;
+	}
+	return `CapabilityAdmissionDecision '${decision.decisionId}' carries a stale admission policy source ref`;
+}
+
+function admissionStateForOutcome(
+	outcome: CapabilityAdmissionOutcome,
+): CapabilityAdmissionState | undefined {
+	if (outcome === "allow") return "allowed";
+	if (outcome === "block") return "blocked";
+	if (outcome === "defer") return "deferred";
+	return undefined;
+}
+
+function capabilityAdmissionStatusState(
+	state: CapabilityAdmissionState,
+): CapabilityAdmissionStatus["state"] {
+	if (state === "allowed") return "capability-admission-allowed";
+	if (state === "blocked") return "capability-admission-blocked";
+	return "capability-admission-deferred";
+}
+
+function cloneCapabilityRef(ref: BoundaryCapabilityRef): BoundaryCapabilityRef {
+	return {
+		id: ref.id,
+		kind: ref.kind,
+		required: ref.required,
+		...(ref.sourceRefs === undefined ? {} : { sourceRefs: [...ref.sourceRefs] }),
+	};
+}
+
+function isBoundaryCapabilityRef(value: unknown): value is BoundaryCapabilityRef {
+	if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
+	const record = value as Partial<BoundaryCapabilityRef>;
+	return (
+		typeof record.id === "string" &&
+		record.id.length > 0 &&
+		isBoundaryCapabilityKind(record.kind) &&
+		typeof record.required === "boolean" &&
+		(record.sourceRefs === undefined ||
+			(Array.isArray(record.sourceRefs) &&
+				record.sourceRefs.every((sourceRef) => typeof sourceRef === "string")))
+	);
+}
+
+function isBoundaryCapabilityKind(value: unknown): value is BoundaryCapabilityRef["kind"] {
+	return value === "auth" || value === "permission" || value === "config" || value === "resource";
+}
+
+function isCapabilityAdmissionOutcome(value: unknown): value is CapabilityAdmissionOutcome {
+	return value === "allow" || value === "block" || value === "defer";
+}
+
+function proposalKeyFallback(proposal: CapabilityAdmissionProposal): string {
+	return typeof proposal.proposalId === "string" && proposal.proposalId.length > 0
+		? proposal.proposalId
+		: `${stringValue(proposal.subjectId) ?? "unknown"}:${capabilityKeyFallback(proposal.capability)}`;
+}
+
+function policyKeyFallback(policy: CapabilityAdmissionPolicy): string {
+	return typeof policy.policyId === "string" && policy.policyId.length > 0
+		? policy.policyId
+		: "unknown";
+}
+
+function decisionKeyFallback(decision: CapabilityAdmissionDecision): string {
+	return typeof decision.decisionId === "string" && decision.decisionId.length > 0
+		? decision.decisionId
+		: `${stringValue(decision.proposalId) ?? "unknown"}:${stringValue(decision.admissionId) ?? "unknown"}`;
+}
+
+function capabilityKeyFallback(value: unknown): string {
+	if (!isBoundaryCapabilityRef(value)) return "unknown-capability";
+	return `${value.kind}:${value.id}`;
+}
+
+function nextMalformedIssueKey(
+	state: CapabilityAdmissionStateInternal,
+	kind: "decision" | "policy" | "proposal",
+	fallback: string,
+): string {
+	state.issueSeq += 1;
+	return `malformed-${kind}:${state.issueSeq}:${fallback}`;
+}
+
+function stringValue(value: unknown): string | undefined {
+	return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+
+function capabilityProposalRefs(proposal: CapabilityAdmissionProposal): readonly SourceRef[] {
+	return uniqueSourceRefs([
+		ref("capability-admission-proposal", proposal.proposalId),
+		ref("boundary-capability", `${proposal.capability.kind}:${proposal.capability.id}`),
+		...(proposal.sourceRefs ?? []),
+	]);
+}
+
+function capabilityDecisionRefs(
+	decision: CapabilityAdmissionDecision,
+	proposal?: CapabilityAdmissionProposal,
+	policy?: CapabilityAdmissionPolicy,
+): readonly SourceRef[] {
+	return uniqueSourceRefs([
+		ref("capability-admission-decision", decision.decisionId),
+		ref("capability-admission", decision.admissionId),
+		ref("capability-admission-proposal", decision.proposalId),
+		...(proposal === undefined ? [] : capabilityProposalRefs(proposal)),
+		...(decision.policyId === undefined
+			? []
+			: [ref("capability-admission-policy", decision.policyId)]),
+		...(policy === undefined ? [] : [ref("capability-admission-policy", policy.policyId)]),
+		...(decision.sourceRefs ?? []),
+	]);
+}
+
+function forEachPolicyDepBatch(
+	ctx: Ctx,
+	start: number,
+	count: number,
+	fn: (value: unknown) => void,
+): void {
+	for (let i = 0; i < count; i += 1) {
+		for (const value of depBatch(ctx, start + i) ?? []) fn(value);
+	}
+}
+
+function projectRuntimeFact<T, TOut>(
+	graph: Graph,
+	runtime: Node<T>,
+	name: string,
+	factory: string,
+	pick: (fact: T) => TOut | undefined,
+): Node<TOut> {
+	return graph.node<TOut>(
+		[runtime],
+		(ctx) => {
+			for (const fact of depBatch(ctx, 0) ?? []) {
+				const typed = fact as T;
+				const value = pick(typed);
+				if (value !== undefined) ctx.down([["DATA", value]]);
+			}
+		},
+		{ name, factory },
+	);
+}
+
+function freezeCapabilityAdmissionViews(
+	state: CapabilityAdmissionViewsState,
+): CapabilityAdmissionViews {
+	return {
+		admissionsByProposal: new Map(state.admissionsByProposal),
+		admissionsBySubject: new Map(
+			Array.from(state.admissionsBySubject, ([key, value]) => [key, Object.freeze([...value])]),
+		),
+		issues: Object.freeze([...state.issues]),
+		audit: Object.freeze([...state.audit]),
+	};
+}
+
+function emptyCapabilityAdmissionState(): CapabilityAdmissionStateInternal {
+	return {
+		proposals: new Map(),
+		policies: new Map(),
+		decisions: new Map(),
+		admissionsById: new Map(),
+		admissionsByProposal: new Map(),
+		terminalDecisionIds: new Set(),
+		issueKeys: new Set(),
+		issueSeq: 0,
+		statusSeq: 0,
+		auditSeq: 0,
+	};
+}
+
+function dataIssue(
+	code: string,
+	message: string,
+	opts: {
+		readonly subjectId?: string;
+		readonly refs?: readonly SourceRef[];
+		readonly details?: unknown;
+	} = {},
+): DataIssue {
+	return {
+		kind: "issue",
+		code,
+		message,
+		severity: "error",
+		subjectId: opts.subjectId,
+		refs: opts.refs?.map((sourceRef) => `${sourceRef.kind}:${sourceRef.id}`),
+		details: opts.details,
+	};
+}
+
+function uniqueSourceRefs(sourceRefs: readonly SourceRef[]): readonly SourceRef[] {
+	const seen = new Set<string>();
+	const out: SourceRef[] = [];
+	for (const sourceRef of sourceRefs) {
+		const key = `${sourceRef.kind}:${sourceRef.id}:${JSON.stringify(sourceRef.metadata ?? {})}`;
+		if (seen.has(key)) continue;
+		seen.add(key);
+		out.push(sourceRef);
+	}
+	return out;
+}
+
+function ref(kind: string, id: string): SourceRef {
+	return { kind, id };
+}
diff --git a/packages/ts/src/solutions/index.ts b/packages/ts/src/solutions/index.ts
new file mode 100644
index 00000000..27622de7
--- /dev/null
+++ b/packages/ts/src/solutions/index.ts
@@ -0,0 +1,203 @@
+/**
+ * Vertical application solution kits.
+ *
+ * Agentic memory, harness, and data-agent surfaces land here after B63/B62
+ * classify and re-derive them onto lower D125 layers.
+ */
+
+export {
+	AGENTIC_MEMORY_RECORD_FRAME_FORMAT,
+	AGENTIC_MEMORY_RECORD_FRAME_VERSION,
+	type AgenticMemoryArtifactKind,
+	type AgenticMemoryBundle,
+	type AgenticMemoryBundleOptions,
+	type AgenticMemoryConsolidationBundle,
+	type AgenticMemoryConsolidationBundleOptions,
+	type AgenticMemoryConsolidationCommand,
+	type AgenticMemoryConsolidationCursor,
+	type AgenticMemoryConsolidationError,
+	type AgenticMemoryConsolidationErrorCode,
+	type AgenticMemoryConsolidationOutcome,
+	type AgenticMemoryConsolidationRecordDraft,
+	type AgenticMemoryConsolidationRequest,
+	type AgenticMemoryConsolidationResult,
+	type AgenticMemoryConsolidationSnapshot,
+	type AgenticMemoryConsolidationStatus,
+	type AgenticMemoryContext,
+	type AgenticMemoryContextEntry,
+	type AgenticMemoryContextPackingBundle,
+	type AgenticMemoryContextPackingBundleOptions,
+	type AgenticMemoryContextPackingCursor,
+	type AgenticMemoryContextPackingError,
+	type AgenticMemoryContextPackingErrorCode,
+	type AgenticMemoryContextPackingPolicy,
+	type AgenticMemoryContextPackingSnapshot,
+	type AgenticMemoryContextPackingStatus,
+	type AgenticMemoryContextState,
+	type AgenticMemoryContextText,
+	type AgenticMemoryError,
+	type AgenticMemoryErrorCode,
+	type AgenticMemoryFragmentFrame,
+	type AgenticMemoryKgAssertionDraft,
+	type AgenticMemoryKgProjectionBundle,
+	type AgenticMemoryKgProjectionBundleOptions,
+	type AgenticMemoryKgProjectionCursor,
+	type AgenticMemoryKgProjectionError,
+	type AgenticMemoryKgProjectionErrorCode,
+	type AgenticMemoryKgProjectionSnapshot,
+	type AgenticMemoryKgProjectionStatus,
+	type AgenticMemoryKgProjectionStatusState,
+	type AgenticMemoryKind,
+	type AgenticMemoryPackedContext,
+	type AgenticMemoryPackedContextEntry,
+	type AgenticMemoryPersistenceLevel,
+	type AgenticMemoryProjectionCursor,
+	type AgenticMemoryProjectionSnapshot,
+	type AgenticMemoryRecord,
+	type AgenticMemoryRecordFrame,
+	type AgenticMemoryRecordMetadata,
+	type AgenticMemoryRetentionBundle,
+	type AgenticMemoryRetentionBundleOptions,
+	type AgenticMemoryRetentionCommand,
+	type AgenticMemoryRetentionCursor,
+	type AgenticMemoryRetentionError,
+	type AgenticMemoryRetentionErrorCode,
+	type AgenticMemoryRetentionSnapshot,
+	type AgenticMemoryRetentionStatus,
+	type AgenticMemoryScope,
+	type AgenticMemorySourceProjection,
+	type AgenticMemoryStatus,
+	type AgenticMemoryStatusState,
+	type AgenticMemoryStrictJsonValue,
+	agenticMemoryBundle,
+	agenticMemoryConsolidationBundle,
+	agenticMemoryContextPackingBundle,
+	agenticMemoryKgProjectionBundle,
+	agenticMemoryRecordCodec,
+	agenticMemoryRecordFrame,
+	agenticMemoryRecordFrameCodec,
+	agenticMemoryRetentionBundle,
+	assertAgenticMemoryRecordFrame,
+	type KnowledgeAssertion,
+	type KnowledgeAssertionObject,
+	type KnowledgeAssertionSubject,
+} from "./agentic-memory.js";
+
+export {
+	type CapabilityAdmission,
+	type CapabilityAdmissionBundle,
+	type CapabilityAdmissionDecision,
+	type CapabilityAdmissionOutcome,
+	type CapabilityAdmissionPolicy,
+	type CapabilityAdmissionProposal,
+	type CapabilityAdmissionState,
+	type CapabilityAdmissionStatus,
+	type CapabilityAdmissionViews,
+	capabilityAdmissionProjector,
+	capabilityAdmissionProposal,
+} from "./capability-admission.js";
+
+export {
+	analyzeAndMeasure,
+	type BaseContentBlock,
+	BLOCKS_MEASUREMENT_KIND,
+	type BlockAdapters,
+	type BlockAdaptersProviderOptions,
+	type BlockMeasurementProviderOptions,
+	type BlocksMeasurement,
+	blockAdaptersProvider,
+	blockMeasurementProvider,
+	CapabilityMeasureAdapter,
+	type CapabilityTextMeasurementsOptions,
+	CellMeasureAdapter,
+	type CellMeasureAdapterOptions,
+	type CellTextMeasurementsOptions,
+	type CircleObstacle,
+	type ComputeFlowLinesOptions,
+	type ContentBlock,
+	capabilityTextMeasurements,
+	carveTextLineSlots,
+	cellTextMeasurements,
+	circleIntervalForBand,
+	computeBlockFlow,
+	computeCharPositions,
+	computeFlowLines,
+	computeLineBreaks,
+	computeTotalHeight,
+	type FlowColumns,
+	type FlowContainer,
+	type FlowLinesResult,
+	IMAGE_SIZE_MEASUREMENT_KIND,
+	type ImageContentBlock,
+	type ImageMeasurer,
+	ImageSizeAdapter,
+	type ImageSizeLookup,
+	type ImageSizeMeasurementsOptions,
+	type ImageSizeMeasurementTarget,
+	InjectedMeasureAdapter,
+	type InjectedMeasureAdapterOptions,
+	type InjectedTextMeasurementsOptions,
+	imageSizeMeasurements,
+	injectedTextMeasurements,
+	type LayoutCursor,
+	type LayoutLine,
+	type LayoutNextLineContext,
+	type LayoutNextLineResult,
+	type LineBreaksResult,
+	layoutNextLine,
+	type MeasureBlockOptions,
+	type MeasuredBlock,
+	type MeasureFn,
+	type MeasurementAdapter,
+	type MeasurementFact,
+	type MeasurementIssue,
+	type MeasurementReadiness,
+	type MeasurementResult,
+	type Measurements,
+	type MergeMeasurementsOptions,
+	measureBlock,
+	measureBlocks,
+	mergeMeasurements,
+	type Obstacle,
+	type PositionedBlock,
+	type PositionedLine,
+	PrecomputedMeasureAdapter,
+	type PrecomputedMeasureAdapterOptions,
+	type PrecomputedTextMeasurementsOptions,
+	type PreparedSegment,
+	precomputedTextMeasurements,
+	READINESS_MEASUREMENT_KIND,
+	type ReactiveBlockLayoutBundle,
+	type ReactiveBlockLayoutOptions,
+	type ReactiveFlowLayoutBundle,
+	type ReactiveFlowLayoutOptions,
+	type ReactiveLayoutBundle,
+	type ReactiveLayoutOptions,
+	type ReadinessMeasurementsOptions,
+	type ReadinessTextMeasurementsOptions,
+	type RectObstacle,
+	reactiveBlockLayout,
+	reactiveFlowLayout,
+	reactiveLayout,
+	readinessMeasurements,
+	readinessTextMeasurements,
+	rectIntervalForBand,
+	type SegmentAdapter,
+	type SegmentBreakKind,
+	type SegmentInfo,
+	type SegmentMeasureStats,
+	type Size,
+	SVG_BOUNDS_MEASUREMENT_KIND,
+	SvgBoundsAdapter,
+	type SvgBoundsMeasurementsOptions,
+	type SvgBoundsMeasurementTarget,
+	type SvgContentBlock,
+	type SvgMeasurer,
+	svgBoundsMeasurements,
+	TEXT_SEGMENTS_MEASUREMENT_KIND,
+	type TextContentBlock,
+	type TextMeasureCapability,
+	type TextMeasurementProviderOptions,
+	type TextSegmentsMeasurement,
+	textMeasurementProvider,
+} from "./reactive-layout/index.js";
diff --git a/packages/ts/src/solutions/reactive-layout/adapters.ts b/packages/ts/src/solutions/reactive-layout/adapters.ts
new file mode 100644
index 00000000..d2f49b65
--- /dev/null
+++ b/packages/ts/src/solutions/reactive-layout/adapters.ts
@@ -0,0 +1,179 @@
+import { isCJK, measuredWidth, metricKey } from "./segment.js";
+import type {
+	CellMeasureAdapterOptions,
+	ImageMeasurer,
+	ImageSizeLookup,
+	InjectedMeasureAdapterOptions,
+	MeasureFn,
+	MeasurementAdapter,
+	PrecomputedMeasureAdapterOptions,
+	Size,
+	SvgMeasurer,
+	TextMeasureCapability,
+} from "./types.js";
+import { nonNegativeFinite } from "./utils.js";
+
+/** Adapter that wraps a caller-owned synchronous measurement function. */
+export class InjectedMeasureAdapter implements MeasurementAdapter {
+	private readonly measure: MeasureFn;
+	private readonly shouldCache: boolean;
+	private readonly cache = new Map<string, number>();
+
+	constructor(measure: MeasureFn, opts: InjectedMeasureAdapterOptions = {}) {
+		this.measure = measure;
+		this.shouldCache = opts.cache ?? true;
+	}
+
+	measureSegment(text: string, font: string): { readonly width: number } {
+		const key = metricKey(text, font);
+		if (this.shouldCache) {
+			const cached = this.cache.get(key);
+			if (cached !== undefined) return { width: cached };
+		}
+		const width = measuredWidth(this.measure(text, font));
+		if (this.shouldCache) this.cache.set(key, width);
+		return { width };
+	}
+
+	clearCache(): void {
+		this.cache.clear();
+	}
+}
+
+/** Deterministic adapter backed by caller-supplied width metrics. */
+export class PrecomputedMeasureAdapter implements MeasurementAdapter {
+	private readonly metrics: ReadonlyMap<string, number>;
+	private readonly fallback: "per-char" | "error";
+	private readonly cellWidth: number;
+
+	constructor(opts: PrecomputedMeasureAdapterOptions) {
+		this.metrics =
+			opts.metrics instanceof Map ? opts.metrics : new Map(Object.entries(opts.metrics));
+		this.fallback = opts.fallback ?? "error";
+		this.cellWidth = nonNegativeFinite(opts.cellWidth ?? 8, 8);
+	}
+
+	measureSegment(text: string, font: string): { readonly width: number } {
+		const fontScoped = this.metrics.get(metricKey(text, font));
+		if (fontScoped !== undefined) return { width: nonNegativeFinite(fontScoped, 0) };
+		const unscoped = this.metrics.get(text);
+		if (unscoped !== undefined) return { width: nonNegativeFinite(unscoped, 0) };
+		if (this.fallback === "per-char") {
+			return { width: Array.from(text).length * this.cellWidth };
+		}
+		throw new Error(`No precomputed metric for segment ${JSON.stringify(text)}`);
+	}
+}
+
+/** Fixed-cell adapter for CLI, snapshots, and tests. */
+export class CellMeasureAdapter implements MeasurementAdapter {
+	private readonly cellWidth: number;
+	private readonly wideCellWidth: number;
+	private readonly tabCells: number;
+
+	constructor(opts: CellMeasureAdapterOptions = {}) {
+		this.cellWidth = nonNegativeFinite(opts.cellWidth ?? 8, 8);
+		this.wideCellWidth = nonNegativeFinite(
+			opts.wideCellWidth ?? this.cellWidth * 2,
+			this.cellWidth * 2,
+		);
+		this.tabCells = Math.max(1, Math.floor(nonNegativeFinite(opts.tabCells ?? 4, 4)));
+	}
+
+	measureSegment(text: string): { readonly width: number } {
+		let width = 0;
+		for (const char of text) {
+			if (char === "\t") width += this.cellWidth * this.tabCells;
+			else width += isCJK(char) ? this.wideCellWidth : this.cellWidth;
+		}
+		return { width };
+	}
+}
+
+/** Adapter over a caller-owned platform capability such as NodeCanvas, Skia, or RN text APIs. */
+export class CapabilityMeasureAdapter implements MeasurementAdapter {
+	private readonly capability: TextMeasureCapability;
+
+	constructor(capability: TextMeasureCapability) {
+		this.capability = capability;
+	}
+
+	measureSegment(text: string, font: string): { readonly width: number } {
+		return { width: measuredWidth(this.capability.measureText(text, font)) };
+	}
+
+	clearCache(): void {
+		this.capability.clearCache?.();
+	}
+}
+
+function stripSvgIgnoredContent(svg: string): string {
+	return svg.replace(/<!--[\s\S]*?-->/g, "").replace(/<!\[CDATA\[[\s\S]*?\]\]>/g, "");
+}
+
+function readSvgRootTag(svg: string): string | null {
+	return /<svg\b[^>]*>/i.exec(svg)?.[0] ?? null;
+}
+
+function readNumericAttr(tag: string, attr: string): number | null {
+	const pattern = new RegExp(`(?:^|\\s)${attr}\\s*=\\s*["']?(-?\\d+(?:\\.\\d+)?)`, "i");
+	const match = pattern.exec(tag);
+	if (!match) return null;
+	const value = Number(match[1]);
+	return Number.isFinite(value) && value >= 0 ? value : null;
+}
+
+function readViewBox(tag: string): Size | null {
+	const match =
+		/\bviewBox\s*=\s*["']\s*(-?\d+(?:\.\d+)?)\s+(-?\d+(?:\.\d+)?)\s+(-?\d+(?:\.\d+)?)\s+(-?\d+(?:\.\d+)?)\s*["']/i.exec(
+			tag,
+		);
+	if (!match) return null;
+	const width = Number(match[3]);
+	const height = Number(match[4]);
+	if (!Number.isFinite(width) || !Number.isFinite(height) || width < 0 || height < 0) {
+		return null;
+	}
+	return { width, height };
+}
+
+/**
+ * Minimal string-based SVG bounds reader for explicit width/height or viewBox.
+ *
+ * This is not a DOM SVG parser and does not resolve external resources.
+ */
+export class SvgBoundsAdapter implements SvgMeasurer {
+	measureSvg(svg: string): Size {
+		const cleaned = stripSvgIgnoredContent(svg);
+		const rootTag = readSvgRootTag(cleaned);
+		if (rootTag === null) throw new Error("Cannot measure SVG without a root <svg> element");
+		const width = readNumericAttr(rootTag, "width");
+		const height = readNumericAttr(rootTag, "height");
+		if (width !== null && height !== null) return { width, height };
+		const viewBox = readViewBox(rootTag);
+		if (viewBox) return viewBox;
+		throw new Error("Cannot measure SVG without width/height or viewBox");
+	}
+}
+
+/** Image measurer backed by explicit caller-provided dimensions; it never loads images. */
+export class ImageSizeAdapter implements ImageMeasurer {
+	private readonly sizes: ImageSizeLookup;
+
+	constructor(sizes: ImageSizeLookup | Record<string, Size>) {
+		this.sizes = isImageSizeLookup(sizes) ? sizes : new Map(Object.entries(sizes));
+	}
+
+	measureImage(src: string): Size {
+		const size = this.sizes.get(src);
+		if (!size) throw new Error(`No image size registered for ${JSON.stringify(src)}`);
+		return size;
+	}
+}
+
+function isImageSizeLookup(value: unknown): value is ImageSizeLookup {
+	if (value === null) return false;
+	const valueType = typeof value;
+	if (valueType !== "object" && valueType !== "function") return false;
+	return typeof (value as { readonly get?: unknown }).get === "function";
+}
diff --git a/packages/ts/src/solutions/reactive-layout/block.ts b/packages/ts/src/solutions/reactive-layout/block.ts
new file mode 100644
index 00000000..295685e5
--- /dev/null
+++ b/packages/ts/src/solutions/reactive-layout/block.ts
@@ -0,0 +1,124 @@
+import { analyzeAndMeasure, computeCharPositions, computeLineBreaks } from "./line.js";
+import { tryMeasureHyphenWidth } from "./measurements.js";
+import type { ContentBlock, MeasureBlockOptions, MeasuredBlock, PositionedBlock } from "./types.js";
+import {
+	blockMaxWidth,
+	clampDimension,
+	fitSize,
+	nonNegativeFinite,
+	positiveFinite,
+	resolveTextAdapter,
+} from "./utils.js";
+
+/** Measure one text/image/SVG block using only explicit or injected synchronous adapters. */
+export function measureBlock(block: ContentBlock, opts: MeasureBlockOptions): MeasuredBlock {
+	const maxWidth = nonNegativeFinite(opts.maxWidth ?? 800, 800);
+	const marginTop = nonNegativeFinite(block.marginTop ?? 0, 0);
+	const marginBottom = nonNegativeFinite(block.marginBottom ?? 0, 0);
+	if (block.kind === "text") {
+		const adapter = resolveTextAdapter(opts);
+		const font = block.font ?? opts.font ?? "16px sans-serif";
+		const lineHeight = positiveFinite(block.lineHeight ?? opts.lineHeight ?? 20, 20);
+		const cache = opts.cache ?? new Map<string, Map<string, number>>();
+		const width = blockMaxWidth(block.maxWidth, maxWidth);
+		const segments = analyzeAndMeasure(
+			block.text,
+			font,
+			adapter,
+			cache,
+			undefined,
+			opts.segmentAdapter,
+		);
+		const hyphenWidth = Object.hasOwn(opts, "hyphenWidth")
+			? opts.hyphenWidth
+			: tryMeasureHyphenWidth(adapter, font);
+		const lineBreaks = computeLineBreaks(segments, width, {
+			hyphenWidth,
+			segmentAdapter: opts.segmentAdapter,
+		});
+		const charPositions = computeCharPositions(
+			lineBreaks,
+			segments,
+			lineHeight,
+			opts.segmentAdapter,
+		);
+		return {
+			block,
+			kind: block.kind,
+			id: block.id,
+			width: lineBreaks.lines.reduce((acc, line) => Math.max(acc, line.width), 0),
+			height: lineBreaks.lineCount * lineHeight,
+			marginTop,
+			marginBottom,
+			segments,
+			lineBreaks,
+			charPositions,
+		};
+	}
+	if (block.kind === "image") {
+		const explicit =
+			block.width !== undefined && block.height !== undefined
+				? { width: clampDimension(block.width), height: clampDimension(block.height) }
+				: opts.adapters?.image?.measureImage(block.src);
+		if (!explicit) throw new Error("Image blocks require width/height or an ImageMeasurer");
+		const size = fitSize(explicit, blockMaxWidth(block.maxWidth, maxWidth));
+		return {
+			block,
+			kind: block.kind,
+			id: block.id,
+			width: size.width,
+			height: size.height,
+			marginTop,
+			marginBottom,
+		};
+	}
+	const explicit =
+		block.width !== undefined && block.height !== undefined
+			? { width: clampDimension(block.width), height: clampDimension(block.height) }
+			: opts.adapters?.svg?.measureSvg(block.svg);
+	if (!explicit) throw new Error("SVG blocks require width/height or a SvgMeasurer");
+	const size = fitSize(explicit, blockMaxWidth(block.maxWidth, maxWidth));
+	return {
+		block,
+		kind: block.kind,
+		id: block.id,
+		width: size.width,
+		height: size.height,
+		marginTop,
+		marginBottom,
+	};
+}
+
+/** Measure a block list while sharing a measurement cache across text blocks. */
+export function measureBlocks(
+	blocks: readonly ContentBlock[],
+	opts: MeasureBlockOptions,
+): readonly MeasuredBlock[] {
+	const cache = opts.cache ?? new Map<string, Map<string, number>>();
+	return blocks.map((block) => measureBlock(block, { ...opts, cache }));
+}
+
+/** Stack measured blocks vertically with margins and a fixed gap. */
+export function computeBlockFlow(
+	blocks: readonly MeasuredBlock[],
+	gap = 0,
+): readonly PositionedBlock[] {
+	const spacing = nonNegativeFinite(gap, 0);
+	let y = 0;
+	return blocks.map((block) => {
+		y += block.marginTop;
+		const positioned: PositionedBlock = { ...block, x: 0, y };
+		y += block.height + block.marginBottom + spacing;
+		return positioned;
+	});
+}
+
+/** Compute the bottom edge of a positioned block flow. */
+export function computeTotalHeight(blocks: readonly PositionedBlock[]): number {
+	if (blocks.length === 0) return 0;
+	let bottom = 0;
+	for (const block of blocks) {
+		bottom = Math.max(bottom, block.y + block.height + block.marginBottom);
+	}
+	return bottom;
+}
diff --git a/packages/ts/src/solutions/reactive-layout/browser/index.ts b/packages/ts/src/solutions/reactive-layout/browser/index.ts
new file mode 100644
index 00000000..3f0a24f5
--- /dev/null
+++ b/packages/ts/src/solutions/reactive-layout/browser/index.ts
@@ -0,0 +1,106 @@
+import type { Graph } from "../../../graph/graph.js";
+import type { Node } from "../../../node/node.js";
+import {
+	type MeasurementAdapter,
+	type Measurements,
+	type SegmentAdapter,
+	textMeasurementProvider,
+} from "../index.js";
+
+interface CanvasTextContextLike {
+	readonly measureText: (text: string) => { readonly width: number };
+	font: string;
+}
+
+interface OffscreenCanvasLike {
+	getContext(type: "2d"): CanvasTextContextLike | null;
+}
+
+interface OffscreenCanvasConstructor {
+	new (width: number, height: number): OffscreenCanvasLike;
+}
+
+/** Browser-only Canvas text measurement options. */
+export interface CanvasMeasureAdapterOptions {
+	/** Multiplier applied only to emoji-presentation segments. Default: 1. */
+	readonly emojiCorrection?: number;
+}
+
+/** Browser Canvas text measurement provider options. */
+export interface CanvasTextMeasurementsOptions extends CanvasMeasureAdapterOptions {
+	readonly graph: Graph;
+	readonly text: Node<string>;
+	readonly font: Node<string>;
+	readonly segmentAdapter?: Node<SegmentAdapter>;
+	readonly targetId?: string;
+	readonly source?: string;
+	readonly name?: string;
+}
+
+/**
+ * Browser measurement adapter using OffscreenCanvas.
+ *
+ * Lazily creates one OffscreenCanvas + 2D context when first measured.
+ */
+export class CanvasMeasureAdapter implements MeasurementAdapter {
+	private ctx: CanvasTextContextLike | null = null;
+	private currentFont = "";
+	private readonly emojiCorrection: number;
+
+	constructor(opts?: CanvasMeasureAdapterOptions) {
+		this.emojiCorrection = opts?.emojiCorrection ?? 1;
+	}
+
+	private getContext(): CanvasTextContextLike {
+		if (this.ctx !== null) return this.ctx;
+		const globalOffscreenCanvas = (
+			globalThis as { OffscreenCanvas?: OffscreenCanvasConstructor | undefined }
+		).OffscreenCanvas;
+		if (typeof globalOffscreenCanvas === "undefined") {
+			throw new TypeError("CanvasMeasureAdapter requires a browser with OffscreenCanvas support");
+		}
+		const canvas = new globalOffscreenCanvas(0, 0);
+		const ctx = canvas.getContext("2d");
+		if (ctx === null) throw new TypeError("CanvasMeasureAdapter: failed to get 2D context");
+		this.ctx = ctx;
+		return ctx;
+	}
+
+	measureSegment(text: string, font: string): { readonly width: number } {
+		const ctx = this.getContext();
+		if (font !== this.currentFont) {
+			ctx.font = font;
+			this.currentFont = font;
+		}
+		let width = ctx.measureText(text).width;
+		if (this.emojiCorrection !== 1 && /\p{Emoji_Presentation}/u.test(text)) {
+			width *= this.emojiCorrection;
+		}
+		return { width };
+	}
+
+	clearCache(): void {
+		this.currentFont = "";
+	}
+}
+
+/** Browser provider helper that emits graph-visible Canvas text measurement facts. */
+export function canvasTextMeasurements(opts: CanvasTextMeasurementsOptions): Node<Measurements> {
+	const targetId = opts.targetId ?? "text";
+	const adapter = opts.graph.state<MeasurementAdapter>(
+		new CanvasMeasureAdapter({ emojiCorrection: opts.emojiCorrection }),
+		{
+			name: opts.name ? `${opts.name}:measure-capability` : `${targetId}-canvas-measure-capability`,
+		},
+	);
+	return textMeasurementProvider({
+		graph: opts.graph,
+		text: opts.text,
+		font: opts.font,
+		adapter,
+		segmentAdapter: opts.segmentAdapter,
+		targetId: opts.targetId,
+		source: opts.source ?? "canvasTextMeasurements",
+		name: opts.name,
+	});
+}
diff --git a/packages/ts/src/solutions/reactive-layout/bundles.ts b/packages/ts/src/solutions/reactive-layout/bundles.ts
new file mode 100644
index 00000000..1254e180
--- /dev/null
+++ b/packages/ts/src/solutions/reactive-layout/bundles.ts
@@ -0,0 +1,319 @@
+import { type Ctx, depLatest } from "../../ctx/types.js";
+import { Node } from "../../node/node.js";
+import { computeBlockFlow, computeTotalHeight } from "./block.js";
+import {
+	computeFlowLines,
+	sanitizeFlowColumns,
+	sanitizeFlowContainer,
+	sanitizeObstacles,
+} from "./flow.js";
+import { computeCharPositions, computeLineBreaks } from "./line.js";
+import { inputNode, latestMeasurementValue, scopedName } from "./measurements.js";
+import { getDefaultSegmentAdapter } from "./segment.js";
+import type {
+	BlocksMeasurement,
+	CharPosition,
+	FlowColumns,
+	FlowContainer,
+	FlowLinesResult,
+	LineBreaksResult,
+	MeasuredBlock,
+	Measurements,
+	Obstacle,
+	PositionedBlock,
+	PreparedSegment,
+	ReactiveBlockLayoutBundle,
+	ReactiveBlockLayoutOptions,
+	ReactiveFlowLayoutBundle,
+	ReactiveFlowLayoutOptions,
+	ReactiveLayoutBundle,
+	ReactiveLayoutOptions,
+	TextSegmentsMeasurement,
+} from "./types.js";
+import { BLOCKS_MEASUREMENT_KIND, TEXT_SEGMENTS_MEASUREMENT_KIND } from "./types.js";
+import { emitLayoutError, nonNegativeFinite } from "./utils.js";
+
+/**
+ * Create a graph-visible single-column text layout bundle.
+ *
+ * D181: this adds ordinary state/output nodes only; it does not add protocol behavior,
+ * hidden subscriptions, GraphSpec ownership, storage, or platform globals.
+ */
+export function reactiveLayout(opts: ReactiveLayoutOptions): ReactiveLayoutBundle {
+	const { measurements, segmentAdapter: segmentAdapterOpt, name = "reactive-layout" } = opts;
+	const targetId = opts.targetId ?? "text";
+	const segAdapter = segmentAdapterOpt ?? getDefaultSegmentAdapter();
+	const g = opts.graph;
+	const lineHeightInput = inputNode(
+		g,
+		opts.lineHeight instanceof Node
+			? opts.lineHeight
+			: nonNegativeFinite(opts.lineHeight ?? 20, 20),
+		nonNegativeFinite(20, 20),
+		scopedName(name, "line-height"),
+	);
+	const maxWidthInput = inputNode(
+		g,
+		opts.maxWidth instanceof Node ? opts.maxWidth : nonNegativeFinite(opts.maxWidth ?? 800, 800),
+		nonNegativeFinite(800, 800),
+		scopedName(name, "max-width"),
+	);
+	const segments = g.node<readonly PreparedSegment[]>(
+		[measurements],
+		(ctx: Ctx) => {
+			try {
+				const measured = latestMeasurementValue<TextSegmentsMeasurement>(
+					depLatest(ctx, 0) as Measurements,
+					targetId,
+					TEXT_SEGMENTS_MEASUREMENT_KIND,
+				);
+				ctx.down([["DATA", measured?.segments ?? []]]);
+			} catch (error) {
+				emitLayoutError(ctx, error, "reactiveLayout segments failed");
+			}
+		},
+		{ name: scopedName(name, "segments") },
+	);
+	const lineBreaks = g.node<LineBreaksResult>(
+		[segments, maxWidthInput.node, measurements],
+		(ctx: Ctx) => {
+			try {
+				const measured = latestMeasurementValue<TextSegmentsMeasurement>(
+					depLatest(ctx, 2) as Measurements,
+					targetId,
+					TEXT_SEGMENTS_MEASUREMENT_KIND,
+				);
+				const computed = computeLineBreaks(
+					depLatest(ctx, 0) as readonly PreparedSegment[],
+					nonNegativeFinite(depLatest(ctx, 1) as number, 0),
+					{ hyphenWidth: measured?.hyphenWidth, segmentAdapter: segAdapter },
+				);
+				ctx.down([["DATA", computed]]);
+			} catch (error) {
+				emitLayoutError(ctx, error, "reactiveLayout line breaks failed");
+			}
+		},
+		{ name: scopedName(name, "line-breaks") },
+	);
+	const height = g.node<number>(
+		[lineBreaks, lineHeightInput.node],
+		(ctx: Ctx) => {
+			try {
+				const lines = depLatest(ctx, 0) as LineBreaksResult;
+				const lineHeight = nonNegativeFinite(depLatest(ctx, 1) as number, 0);
+				ctx.down([["DATA", lines.lineCount * lineHeight]]);
+			} catch (error) {
+				emitLayoutError(ctx, error, "reactiveLayout height failed");
+			}
+		},
+		{ name: scopedName(name, "height") },
+	);
+	const charPositions = g.node<readonly CharPosition[]>(
+		[lineBreaks, segments, lineHeightInput.node],
+		(ctx: Ctx) => {
+			try {
+				const positions = computeCharPositions(
+					depLatest(ctx, 0) as LineBreaksResult,
+					depLatest(ctx, 1) as readonly PreparedSegment[],
+					nonNegativeFinite(depLatest(ctx, 2) as number, 0),
+					segAdapter,
+				);
+				ctx.down([["DATA", positions]]);
+			} catch (error) {
+				emitLayoutError(ctx, error, "reactiveLayout char positions failed");
+			}
+		},
+		{ name: scopedName(name, "char-positions") },
+	);
+	return {
+		graph: g,
+		input: {
+			lineHeight: lineHeightInput.node,
+			maxWidth: maxWidthInput.node,
+			measurements,
+		},
+		setLineHeight(lineHeight: number): void {
+			lineHeightInput.set(nonNegativeFinite(lineHeight, 0));
+		},
+		setMaxWidth(maxWidth: number): void {
+			maxWidthInput.set(nonNegativeFinite(maxWidth, 0));
+		},
+		segments,
+		lineBreaks,
+		height,
+		charPositions,
+	};
+}
+
+/**
+ * Create a graph-visible vertical block layout bundle over the same DOM-free core.
+ *
+ * Image/SVG sizing is explicit or injected; no async image loading or DOM SVG parsing occurs.
+ */
+export function reactiveBlockLayout(opts: ReactiveBlockLayoutOptions): ReactiveBlockLayoutBundle {
+	const { measurements, name = "reactive-block-layout" } = opts;
+	const targetId = opts.targetId ?? "blocks";
+	const g = opts.graph;
+	const gapInput = inputNode(
+		g,
+		opts.gap instanceof Node ? opts.gap : nonNegativeFinite(opts.gap ?? 0, 0),
+		nonNegativeFinite(0, 0),
+		scopedName(name, "gap"),
+	);
+	const measuredBlocks = g.node<readonly MeasuredBlock[]>(
+		[measurements],
+		(ctx: Ctx) => {
+			try {
+				const measured = latestMeasurementValue<BlocksMeasurement>(
+					depLatest(ctx, 0) as Measurements,
+					targetId,
+					BLOCKS_MEASUREMENT_KIND,
+				);
+				ctx.down([["DATA", measured?.blocks ?? []]]);
+			} catch (error) {
+				emitLayoutError(ctx, error, "reactiveBlockLayout measured-blocks failed");
+			}
+		},
+		{ name: scopedName(name, "measured-blocks") },
+	);
+	const blockFlow = g.node<readonly PositionedBlock[]>(
+		[measuredBlocks, gapInput.node],
+		(ctx: Ctx) => {
+			try {
+				const positioned = computeBlockFlow(
+					depLatest(ctx, 0) as readonly MeasuredBlock[],
+					nonNegativeFinite(depLatest(ctx, 1) as number, 0),
+				);
+				ctx.down([["DATA", positioned]]);
+			} catch (error) {
+				emitLayoutError(ctx, error, "reactiveBlockLayout flow failed");
+			}
+		},
+		{ name: scopedName(name, "block-flow") },
+	);
+	const totalHeight = g.node<number>(
+		[blockFlow],
+		(ctx: Ctx) => {
+			try {
+				ctx.down([["DATA", computeTotalHeight(depLatest(ctx, 0) as readonly PositionedBlock[])]]);
+			} catch (error) {
+				emitLayoutError(ctx, error, "reactiveBlockLayout total height failed");
+			}
+		},
+		{ name: scopedName(name, "total-height") },
+	);
+	return {
+		graph: g,
+		input: {
+			gap: gapInput.node,
+			measurements,
+		},
+		setGap(gap: number): void {
+			gapInput.set(nonNegativeFinite(gap, 0));
+		},
+		measuredBlocks,
+		blockFlow,
+		totalHeight,
+	};
+}
+
+/** Create a graph-visible multi-column flow layout bundle with rectangle/circle obstacles. */
+export function reactiveFlowLayout(opts: ReactiveFlowLayoutOptions): ReactiveFlowLayoutBundle {
+	const { measurements, segmentAdapter: segmentAdapterOpt, name = "reactive-flow-layout" } = opts;
+	const targetId = opts.targetId ?? "text";
+	const segAdapter = segmentAdapterOpt ?? getDefaultSegmentAdapter();
+	const g = opts.graph;
+	const lineHeightInput = inputNode(
+		g,
+		opts.lineHeight instanceof Node
+			? opts.lineHeight
+			: nonNegativeFinite(opts.lineHeight ?? 20, 20),
+		nonNegativeFinite(20, 20),
+		scopedName(name, "line-height"),
+	);
+	const containerInput = inputNode(
+		g,
+		opts.container,
+		{ width: 800, height: 600 },
+		scopedName(name, "container"),
+	);
+	const columnsInput = inputNode(
+		g,
+		opts.columns,
+		{ count: 1, gap: 0 },
+		scopedName(name, "columns"),
+	);
+	const obstaclesInput = inputNode(g, opts.obstacles, [], scopedName(name, "obstacles"));
+	const segments = g.node<readonly PreparedSegment[]>(
+		[measurements],
+		(ctx: Ctx) => {
+			try {
+				const measured = latestMeasurementValue<TextSegmentsMeasurement>(
+					depLatest(ctx, 0) as Measurements,
+					targetId,
+					TEXT_SEGMENTS_MEASUREMENT_KIND,
+				);
+				ctx.down([["DATA", measured?.segments ?? []]]);
+			} catch (error) {
+				emitLayoutError(ctx, error, "reactiveFlowLayout segments failed");
+			}
+		},
+		{ name: scopedName(name, "segments") },
+	);
+	const flowLines = g.node<FlowLinesResult>(
+		[
+			segments,
+			lineHeightInput.node,
+			containerInput.node,
+			columnsInput.node,
+			obstaclesInput.node,
+			measurements,
+		],
+		(ctx: Ctx) => {
+			try {
+				const measured = latestMeasurementValue<TextSegmentsMeasurement>(
+					depLatest(ctx, 5) as Measurements,
+					targetId,
+					TEXT_SEGMENTS_MEASUREMENT_KIND,
+				);
+				const computed = computeFlowLines(depLatest(ctx, 0) as readonly PreparedSegment[], {
+					lineHeight: nonNegativeFinite(depLatest(ctx, 1) as number, 0),
+					container: sanitizeFlowContainer(depLatest(ctx, 2) as FlowContainer),
+					columns: sanitizeFlowColumns(depLatest(ctx, 3) as FlowColumns),
+					obstacles: sanitizeObstacles(depLatest(ctx, 4) as readonly Obstacle[]),
+					minSlotWidth: nonNegativeFinite(opts.minSlotWidth ?? 0, 0),
+					hyphenWidth: measured?.hyphenWidth,
+					segmentAdapter: segAdapter,
+				});
+				ctx.down([["DATA", computed]]);
+			} catch (error) {
+				emitLayoutError(ctx, error, "reactiveFlowLayout flow lines failed");
+			}
+		},
+		{ name: scopedName(name, "flow-lines") },
+	);
+	return {
+		graph: g,
+		input: {
+			lineHeight: lineHeightInput.node,
+			container: containerInput.node,
+			columns: columnsInput.node,
+			obstacles: obstaclesInput.node,
+			measurements,
+		},
+		setLineHeight(lineHeight: number): void {
+			lineHeightInput.set(nonNegativeFinite(lineHeight, 0));
+		},
+		setContainer(container: FlowContainer): void {
+			containerInput.set(container);
+		},
+		setColumns(columns: FlowColumns): void {
+			columnsInput.set(columns);
+		},
+		setObstacles(obstacles: readonly Obstacle[]): void {
+			obstaclesInput.set(obstacles);
+		},
+		segments,
+		flowLines,
+	};
+}
diff --git a/packages/ts/src/solutions/reactive-layout/flow.ts b/packages/ts/src/solutions/reactive-layout/flow.ts
new file mode 100644
index 00000000..f613f348
--- /dev/null
+++ b/packages/ts/src/solutions/reactive-layout/flow.ts
@@ -0,0 +1,193 @@
+import { carveTextLineSlots, layoutNextLine } from "./line.js";
+import { getDefaultSegmentAdapter } from "./segment.js";
+import type {
+	CircleObstacle,
+	ComputeFlowLinesOptions,
+	FlowColumns,
+	FlowContainer,
+	FlowLinesResult,
+	Interval,
+	LayoutCursor,
+	Obstacle,
+	PositionedLine,
+	PreparedSegment,
+	RectObstacle,
+} from "./types.js";
+import { finiteNumber, nonNegativeFinite, positiveFinite } from "./utils.js";
+
+export function columnGeometry(
+	container: FlowContainer,
+	columns: FlowColumns | undefined,
+): {
+	readonly paddingX: number;
+	readonly paddingY: number;
+	readonly count: number;
+	readonly gap: number;
+	readonly width: number;
+	readonly height: number;
+	readonly columnWidth: number;
+} {
+	const paddingX = nonNegativeFinite(container.paddingX ?? 0, 0);
+	const paddingY = nonNegativeFinite(container.paddingY ?? 0, 0);
+	const count = Math.max(1, Math.floor(nonNegativeFinite(columns?.count ?? 1, 1)));
+	const gap = nonNegativeFinite(columns?.gap ?? 0, 0);
+	const width = nonNegativeFinite(container.width, 0);
+	const height = nonNegativeFinite(container.height, 0);
+	const innerWidth = Math.max(0, width - paddingX * 2 - gap * (count - 1));
+	const columnWidth = count > 0 ? innerWidth / count : 0;
+	return { paddingX, paddingY, count, gap, width, height, columnWidth };
+}
+
+export function sanitizeFlowContainer(container: FlowContainer): FlowContainer {
+	return {
+		width: nonNegativeFinite(container.width, 0),
+		height: nonNegativeFinite(container.height, 0),
+		paddingX:
+			container.paddingX === undefined ? undefined : nonNegativeFinite(container.paddingX, 0),
+		paddingY:
+			container.paddingY === undefined ? undefined : nonNegativeFinite(container.paddingY, 0),
+	};
+}
+
+export function sanitizeFlowColumns(columns: FlowColumns): FlowColumns {
+	return {
+		count:
+			columns.count === undefined
+				? undefined
+				: Math.max(1, Math.floor(nonNegativeFinite(columns.count, 1))),
+		gap: columns.gap === undefined ? undefined : nonNegativeFinite(columns.gap, 0),
+	};
+}
+
+export function sanitizeObstacles(obstacles: readonly Obstacle[]): readonly Obstacle[] {
+	return obstacles.map((obstacle) => {
+		if (obstacle.kind === "circle") {
+			return {
+				kind: obstacle.kind,
+				cx: finiteNumber(obstacle.cx, 0),
+				cy: finiteNumber(obstacle.cy, 0),
+				r: nonNegativeFinite(obstacle.r, 0),
+			};
+		}
+		return {
+			kind: obstacle.kind,
+			x: finiteNumber(obstacle.x, 0),
+			y: finiteNumber(obstacle.y, 0),
+			width: nonNegativeFinite(obstacle.width, 0),
+			height: nonNegativeFinite(obstacle.height, 0),
+		};
+	});
+}
+
+/** Intersect a circle obstacle with a horizontal line band. */
+export function circleIntervalForBand(
+	obstacle: CircleObstacle,
+	bandTop: number,
+	bandBottom: number,
+): Interval | null {
+	const radius = nonNegativeFinite(obstacle.r, 0);
+	const centerY = obstacle.cy;
+	const nearestY = Math.max(bandTop, Math.min(centerY, bandBottom));
+	const dy = nearestY - centerY;
+	if (Math.abs(dy) > radius) return null;
+	const dx = Math.sqrt(Math.max(0, radius * radius - dy * dy));
+	return { left: obstacle.cx - dx, right: obstacle.cx + dx };
+}
+
+/** Intersect a rectangle obstacle with a horizontal line band. */
+export function rectIntervalForBand(
+	obstacle: RectObstacle,
+	bandTop: number,
+	bandBottom: number,
+): Interval | null {
+	const left = obstacle.x;
+	const right = obstacle.x + nonNegativeFinite(obstacle.width, 0);
+	const top = obstacle.y;
+	const bottom = obstacle.y + nonNegativeFinite(obstacle.height, 0);
+	if (bottom <= bandTop || top >= bandBottom || right <= left) return null;
+	return { left, right };
+}
+
+export function blockedIntervalsForBand(
+	obstacles: readonly Obstacle[],
+	bandTop: number,
+	bandBottom: number,
+): Interval[] {
+	const intervals: Interval[] = [];
+	for (const obstacle of obstacles) {
+		const interval =
+			obstacle.kind === "circle"
+				? circleIntervalForBand(obstacle, bandTop, bandBottom)
+				: rectIntervalForBand(obstacle, bandTop, bandBottom);
+		if (interval) intervals.push(interval);
+	}
+	return intervals.sort((a, b) => a.left - b.left);
+}
+
+/** Flow prepared text through columns and carved obstacle slots. */
+export function computeFlowLines(
+	segments: readonly PreparedSegment[],
+	opts: ComputeFlowLinesOptions,
+): FlowLinesResult {
+	const geometry = columnGeometry(opts.container, opts.columns);
+	const lineHeight = positiveFinite(opts.lineHeight, 20);
+	const minSlotWidth = nonNegativeFinite(opts.minSlotWidth ?? 0, 0);
+	const obstacles = opts.obstacles ?? [];
+	const segmentAdapter = opts.segmentAdapter ?? getDefaultSegmentAdapter();
+	const lines: PositionedLine[] = [];
+	let cursor: LayoutCursor = { segmentIndex: 0, graphemeIndex: 0 };
+	const contentBottom = Math.max(geometry.paddingY, geometry.height - geometry.paddingY);
+	for (let columnIndex = 0; columnIndex < geometry.count; columnIndex += 1) {
+		const columnLeft = geometry.paddingX + columnIndex * (geometry.columnWidth + geometry.gap);
+		const columnRight = columnLeft + geometry.columnWidth;
+		for (
+			let y = geometry.paddingY;
+			y + lineHeight <= contentBottom + 1e-3 && cursor.segmentIndex < segments.length;
+			y += lineHeight
+		) {
+			const blocked = blockedIntervalsForBand(obstacles, y, y + lineHeight);
+			const slots = carveTextLineSlots(
+				{ left: columnLeft, right: columnRight },
+				blocked,
+				Math.max(minSlotWidth, 1e-6),
+			);
+			for (const slot of slots) {
+				if (cursor.segmentIndex >= segments.length) break;
+				const slotWidth = slot.right - slot.left;
+				const next = layoutNextLine(segments, cursor, slotWidth, {
+					hyphenWidth: opts.hyphenWidth,
+					segmentAdapter,
+				});
+				if (next === null) {
+					cursor = { segmentIndex: segments.length, graphemeIndex: 0 };
+					break;
+				}
+				if (
+					next.end.segmentIndex === cursor.segmentIndex &&
+					next.end.graphemeIndex === cursor.graphemeIndex
+				) {
+					break;
+				}
+				cursor = next.end;
+				if (next.text.length === 0 && next.width === 0) break;
+				lines.push({
+					text: next.text,
+					width: next.width,
+					startSegment: next.start.segmentIndex,
+					startGrapheme: next.start.graphemeIndex,
+					endSegment: next.end.segmentIndex,
+					endGrapheme: next.end.graphemeIndex,
+					x: slot.left,
+					y,
+					slotWidth,
+					columnIndex,
+				});
+			}
+		}
+	}
+	return {
+		lines,
+		cursor,
+		done: cursor.segmentIndex >= segments.length,
+	};
+}
diff --git a/packages/ts/src/solutions/reactive-layout/index.ts b/packages/ts/src/solutions/reactive-layout/index.ts
new file mode 100644
index 00000000..fda89e7a
--- /dev/null
+++ b/packages/ts/src/solutions/reactive-layout/index.ts
@@ -0,0 +1,9 @@
+export * from "./adapters.js";
+export * from "./block.js";
+export * from "./bundles.js";
+export * from "./flow.js";
+export * from "./line.js";
+export * from "./measurements.js";
+export * from "./segment.js";
+export * from "./types.js";
+export * from "./utils.js";
diff --git a/packages/ts/src/solutions/reactive-layout/line.ts b/packages/ts/src/solutions/reactive-layout/line.ts
new file mode 100644
index 00000000..b15f574d
--- /dev/null
+++ b/packages/ts/src/solutions/reactive-layout/line.ts
@@ -0,0 +1,576 @@
+import {
+	getDefaultSegmentAdapter,
+	isCJK,
+	kinsokuStart,
+	leftStickyPunctuation,
+	normalizeWhitespace,
+	segmentText,
+} from "./segment.js";
+import type {
+	CharPosition,
+	Interval,
+	LayoutCursor,
+	LayoutLine,
+	LayoutNextLineContext,
+	LayoutNextLineResult,
+	LineBreaksResult,
+	MeasurementAdapter,
+	PreparedSegment,
+	SegmentAdapter,
+	SegmentBreakKind,
+	SegmentMeasureStats,
+} from "./types.js";
+import { nonNegativeFinite } from "./utils.js";
+
+/** Segment text and measure every resulting segment with a caller-owned synchronous adapter. */
+export function analyzeAndMeasure(
+	text: string,
+	font: string,
+	adapter: MeasurementAdapter,
+	cache: Map<string, Map<string, number>>,
+	stats?: SegmentMeasureStats,
+	segmentAdapter?: SegmentAdapter,
+): PreparedSegment[] {
+	const normalized = normalizeWhitespace(text);
+	if (normalized.length === 0) {
+		return [];
+	}
+	const segAdapter = segmentAdapter ?? getDefaultSegmentAdapter();
+	const pieces = segmentText(normalized, segAdapter);
+	const rawTexts: string[] = [];
+	const rawKinds: SegmentBreakKind[] = [];
+	const rawWordLike: boolean[] = [];
+	for (const piece of pieces) {
+		for (let i = 0; i < piece.texts.length; i += 1) {
+			rawTexts.push(piece.texts[i]);
+			rawKinds.push(piece.kinds[i]);
+			rawWordLike.push(piece.isWordLike[i]);
+		}
+	}
+	const mergedTexts: string[] = [];
+	const mergedKinds: SegmentBreakKind[] = [];
+	const mergedWordLike: boolean[] = [];
+	for (let i = 0; i < rawTexts.length; i += 1) {
+		const t = rawTexts[i];
+		const k = rawKinds[i];
+		const wl = rawWordLike[i];
+		if (
+			k === "text" &&
+			!wl &&
+			mergedTexts.length > 0 &&
+			mergedKinds[mergedTexts.length - 1] === "text"
+		) {
+			const isSticky = t.length === 1 && (leftStickyPunctuation.has(t) || kinsokuStart.has(t));
+			if (isSticky) {
+				mergedTexts[mergedTexts.length - 1] += t;
+				continue;
+			}
+		}
+		if (
+			t === "-" &&
+			mergedTexts.length > 0 &&
+			mergedKinds[mergedKinds.length - 1] === "text" &&
+			mergedWordLike[mergedWordLike.length - 1]
+		) {
+			mergedTexts[mergedTexts.length - 1] += t;
+			continue;
+		}
+		mergedTexts.push(t);
+		mergedKinds.push(k);
+		mergedWordLike.push(wl);
+	}
+	const fontCache = cache.get(font) ?? new Map<string, number>();
+	if (!cache.has(font)) cache.set(font, fontCache);
+	function measureCached(segment: string): number {
+		const cached = fontCache.get(segment);
+		if (cached === undefined) {
+			if (stats) stats.misses += 1;
+			const measured = adapter.measureSegment(segment, font).width;
+			const width = Number.isFinite(measured) && measured >= 0 ? measured : 0;
+			fontCache.set(segment, width);
+			return width;
+		}
+		if (stats) stats.hits += 1;
+		return cached;
+	}
+	const out: PreparedSegment[] = [];
+	for (let i = 0; i < mergedTexts.length; i += 1) {
+		const t = mergedTexts[i];
+		const kind = mergedKinds[i];
+		if (kind !== "text") {
+			out.push({
+				text: t,
+				width: kind === "space" ? measureCached(" ") * t.length : 0,
+				kind,
+				graphemeWidths: null,
+			});
+			continue;
+		}
+		if (isCJK(t)) {
+			let unitText = "";
+			for (const graphemeSegment of segAdapter.segmentGraphemes(t)) {
+				const grapheme = graphemeSegment.segment;
+				if (unitText.length > 0 && kinsokuStart.has(grapheme)) {
+					unitText += grapheme;
+					continue;
+				}
+				if (unitText.length > 0) {
+					out.push({
+						text: unitText,
+						width: measureCached(unitText),
+						kind: "text",
+						graphemeWidths: null,
+					});
+				}
+				unitText = grapheme;
+			}
+			if (unitText.length > 0) {
+				out.push({
+					text: unitText,
+					width: measureCached(unitText),
+					kind: "text",
+					graphemeWidths: null,
+				});
+			}
+			continue;
+		}
+		const textWidth = measureCached(t);
+		let graphemeWidths: number[] | null = null;
+		if (mergedWordLike[i] && t.length > 1) {
+			const widths = [];
+			for (const grapheme of segAdapter.segmentGraphemes(t)) {
+				widths.push(measureCached(grapheme.segment));
+			}
+			if (widths.length > 1) graphemeWidths = widths;
+		}
+		out.push({
+			text: t,
+			width: textWidth,
+			kind: "text",
+			graphemeWidths,
+		});
+	}
+	return out;
+}
+
+/** Greedy single-column line breaking over prepared segments. */
+export function computeLineBreaks(
+	segments: readonly PreparedSegment[],
+	maxWidth: number,
+	opts: { readonly hyphenWidth?: number; readonly segmentAdapter?: SegmentAdapter } = {},
+): LineBreaksResult {
+	if (segments.length === 0) return { lines: [], lineCount: 0 };
+	const segAdapter = opts.segmentAdapter ?? getDefaultSegmentAdapter();
+	const lines: LayoutLine[] = [];
+	let cursor: LayoutCursor = { segmentIndex: 0, graphemeIndex: 0 };
+	while (cursor.segmentIndex < segments.length) {
+		const next = layoutNextLine(segments, cursor, maxWidth, {
+			hyphenWidth: opts.hyphenWidth,
+			segmentAdapter: segAdapter,
+		});
+		if (next === null) break;
+		lines.push({
+			text: next.text,
+			width: next.width,
+			startSegment: next.start.segmentIndex,
+			startGrapheme: next.start.graphemeIndex,
+			endSegment: next.end.segmentIndex,
+			endGrapheme: next.end.graphemeIndex,
+		});
+		if (
+			next.end.segmentIndex === cursor.segmentIndex &&
+			next.end.graphemeIndex === cursor.graphemeIndex
+		) {
+			break;
+		}
+		cursor = next.end;
+	}
+	return { lines, lineCount: lines.length };
+}
+
+function canBreakAfter(kind: SegmentBreakKind): boolean {
+	return kind === "space" || kind === "zero-width-break" || kind === "soft-hyphen";
+}
+
+function sliceSegmentText(
+	seg: PreparedSegment,
+	startGrapheme: number,
+	endGrapheme: number,
+	segmentAdapter: SegmentAdapter,
+): string {
+	if (startGrapheme === 0 && endGrapheme < 0) return seg.text;
+	const graphemes = [...segmentAdapter.segmentGraphemes(seg.text)].map((g) => g.segment);
+	const stop = endGrapheme < 0 ? graphemes.length : endGrapheme;
+	return graphemes.slice(startGrapheme, stop).join("");
+}
+
+function buildLineText(
+	segments: readonly PreparedSegment[],
+	startSegment: number,
+	startGrapheme: number,
+	endSegment: number,
+	endGrapheme: number,
+	appendHyphen: boolean,
+	segmentAdapter: SegmentAdapter,
+): string {
+	let text = "";
+	for (let i = startSegment; i < endSegment; i += 1) {
+		const seg = segments[i];
+		if (seg.kind === "soft-hyphen" || seg.kind === "hard-break") continue;
+		if (i === startSegment && startGrapheme > 0) {
+			text += sliceSegmentText(seg, startGrapheme, -1, segmentAdapter);
+		} else {
+			text += seg.text;
+		}
+	}
+	if (endGrapheme > 0 && endSegment < segments.length) {
+		const seg = segments[endSegment];
+		const from = startSegment === endSegment ? startGrapheme : 0;
+		text += sliceSegmentText(seg, from, endGrapheme, segmentAdapter);
+	}
+	if (appendHyphen) text += "-";
+	return text;
+}
+
+function resolveHyphenWidth(ctx: LayoutNextLineContext | undefined): number {
+	if (ctx?.hyphenWidth !== undefined) return nonNegativeFinite(ctx.hyphenWidth, 0);
+	if (ctx?.adapter === undefined || ctx.font === undefined) return 0;
+	const cache = ctx.cache;
+	if (cache) {
+		let fontCache = cache.get(ctx.font);
+		if (fontCache === undefined) {
+			fontCache = new Map();
+			cache.set(ctx.font, fontCache);
+		}
+		let width = fontCache.get("-");
+		if (width === undefined) {
+			width = ctx.adapter.measureSegment("-", ctx.font).width;
+			fontCache.set("-", width);
+		}
+		return width;
+	}
+	return ctx.adapter.measureSegment("-", ctx.font).width;
+}
+
+/** Lay out one line from a cursor, returning the next cursor for continuation. */
+export function layoutNextLine(
+	segments: readonly PreparedSegment[],
+	cursor: LayoutCursor,
+	slotWidth: number,
+	ctx?: LayoutNextLineContext,
+): LayoutNextLineResult | null {
+	let i = cursor.segmentIndex;
+	const initialGrapheme = cursor.graphemeIndex;
+	const segmentAdapter = ctx?.segmentAdapter ?? getDefaultSegmentAdapter();
+	if (i >= segments.length) return null;
+	if (initialGrapheme === 0) {
+		while (i < segments.length) {
+			const seg = segments[i];
+			if (seg.kind === "hard-break") {
+				return {
+					text: "",
+					width: 0,
+					start: { segmentIndex: cursor.segmentIndex, graphemeIndex: 0 },
+					end: { segmentIndex: i + 1, graphemeIndex: 0 },
+				};
+			}
+			if (seg.kind === "space" || seg.kind === "zero-width-break" || seg.kind === "soft-hyphen") {
+				i += 1;
+				continue;
+			}
+			break;
+		}
+		if (i >= segments.length) return null;
+	}
+	const hyphenWidth = resolveHyphenWidth(ctx);
+	const startSegment = i;
+	const startGrapheme = i === cursor.segmentIndex ? initialGrapheme : 0;
+	let lineW = 0;
+	let lineEndSegment = startSegment;
+	let lineEndGrapheme = 0;
+	let hasContent = false;
+	let pendingBreakSegment = -1;
+	let pendingBreakGrapheme = 0;
+	let pendingBreakWidth = 0;
+	let pendingBreakSoftHyphen = false;
+	const recordPending = (
+		sIdx: number,
+		gIdx: number,
+		width: number,
+		kind: SegmentBreakKind,
+	): void => {
+		pendingBreakSegment = sIdx;
+		pendingBreakGrapheme = gIdx;
+		pendingBreakWidth = width;
+		pendingBreakSoftHyphen = kind === "soft-hyphen";
+	};
+	const consumeBreakable = (segIdx: number, startG: number, widths: readonly number[]): boolean => {
+		for (let g = startG; g < widths.length; g += 1) {
+			const gw = widths[g];
+			if (!hasContent) {
+				lineW = gw;
+				lineEndSegment = segIdx;
+				lineEndGrapheme = g + 1;
+				hasContent = true;
+				continue;
+			}
+			if (lineW + gw > slotWidth + 1e-3) {
+				return true;
+			}
+			lineW += gw;
+			lineEndSegment = segIdx;
+			lineEndGrapheme = g + 1;
+		}
+		if (lineEndSegment === segIdx && lineEndGrapheme === widths.length) {
+			lineEndSegment = segIdx + 1;
+			lineEndGrapheme = 0;
+		}
+		return false;
+	};
+	if (startGrapheme > 0 && startSegment < segments.length) {
+		const seg = segments[startSegment];
+		if (seg.graphemeWidths) {
+			const overflow = consumeBreakable(startSegment, startGrapheme, seg.graphemeWidths);
+			if (overflow) {
+				const text = buildLineText(
+					segments,
+					startSegment,
+					startGrapheme,
+					lineEndSegment,
+					lineEndGrapheme,
+					false,
+					segmentAdapter,
+				);
+				return {
+					text,
+					width: lineW,
+					start: { segmentIndex: startSegment, graphemeIndex: startGrapheme },
+					end: { segmentIndex: lineEndSegment, graphemeIndex: lineEndGrapheme },
+				};
+			}
+			i = lineEndSegment;
+		}
+	}
+	for (; i < segments.length; i += 1) {
+		const seg = segments[i];
+		if (seg.kind === "hard-break") {
+			if (hasContent) {
+				const endsAtSoftHyphen =
+					lineEndSegment > 0 && segments[lineEndSegment - 1]?.kind === "soft-hyphen";
+				const text = buildLineText(
+					segments,
+					startSegment,
+					startGrapheme,
+					lineEndSegment,
+					lineEndGrapheme,
+					endsAtSoftHyphen,
+					segmentAdapter,
+				);
+				return {
+					text,
+					width: lineW + (endsAtSoftHyphen ? hyphenWidth : 0),
+					start: { segmentIndex: startSegment, graphemeIndex: startGrapheme },
+					end: { segmentIndex: i + 1, graphemeIndex: 0 },
+				};
+			}
+			return {
+				text: "",
+				width: 0,
+				start: { segmentIndex: startSegment, graphemeIndex: startGrapheme },
+				end: { segmentIndex: i + 1, graphemeIndex: 0 },
+			};
+		}
+		const w = seg.width;
+		if (!hasContent) {
+			if (w > slotWidth && seg.graphemeWidths) {
+				const overflow = consumeBreakable(i, 0, seg.graphemeWidths);
+				if (overflow) {
+					const text = buildLineText(
+						segments,
+						startSegment,
+						startGrapheme,
+						lineEndSegment,
+						lineEndGrapheme,
+						false,
+						segmentAdapter,
+					);
+					return {
+						text,
+						width: lineW,
+						start: { segmentIndex: startSegment, graphemeIndex: startGrapheme },
+						end: { segmentIndex: lineEndSegment, graphemeIndex: lineEndGrapheme },
+					};
+				}
+				i = lineEndSegment - 1;
+				continue;
+			}
+			lineW = w;
+			lineEndSegment = i + 1;
+			lineEndGrapheme = 0;
+			hasContent = true;
+			if (canBreakAfter(seg.kind)) {
+				recordPending(i + 1, 0, seg.kind === "space" ? lineW - w : lineW, seg.kind);
+			}
+			continue;
+		}
+		const projectedWidth = lineW + w;
+		if (projectedWidth > slotWidth + 1e-3) {
+			if (canBreakAfter(seg.kind)) {
+				lineEndSegment = i + 1;
+				lineEndGrapheme = 0;
+				const endsAtSoftHyphen = seg.kind === "soft-hyphen";
+				const text = buildLineText(
+					segments,
+					startSegment,
+					startGrapheme,
+					lineEndSegment,
+					lineEndGrapheme,
+					endsAtSoftHyphen,
+					segmentAdapter,
+				);
+				return {
+					text,
+					width: seg.kind === "space" ? lineW : lineW + (endsAtSoftHyphen ? hyphenWidth : 0),
+					start: { segmentIndex: startSegment, graphemeIndex: startGrapheme },
+					end: { segmentIndex: lineEndSegment, graphemeIndex: lineEndGrapheme },
+				};
+			}
+			if (pendingBreakSegment >= 0) {
+				const text = buildLineText(
+					segments,
+					startSegment,
+					startGrapheme,
+					pendingBreakSegment,
+					pendingBreakGrapheme,
+					pendingBreakSoftHyphen,
+					segmentAdapter,
+				);
+				return {
+					text,
+					width: pendingBreakWidth + (pendingBreakSoftHyphen ? hyphenWidth : 0),
+					start: { segmentIndex: startSegment, graphemeIndex: startGrapheme },
+					end: { segmentIndex: pendingBreakSegment, graphemeIndex: pendingBreakGrapheme },
+				};
+			}
+			if (w > slotWidth && seg.graphemeWidths) {
+				const text = buildLineText(
+					segments,
+					startSegment,
+					startGrapheme,
+					lineEndSegment,
+					lineEndGrapheme,
+					false,
+					segmentAdapter,
+				);
+				return {
+					text,
+					width: lineW,
+					start: { segmentIndex: startSegment, graphemeIndex: startGrapheme },
+					end: { segmentIndex: lineEndSegment, graphemeIndex: lineEndGrapheme },
+				};
+			}
+			const text = buildLineText(
+				segments,
+				startSegment,
+				startGrapheme,
+				lineEndSegment,
+				lineEndGrapheme,
+				false,
+				segmentAdapter,
+			);
+			return {
+				text,
+				width: lineW,
+				start: { segmentIndex: startSegment, graphemeIndex: startGrapheme },
+				end: { segmentIndex: lineEndSegment, graphemeIndex: lineEndGrapheme },
+			};
+		}
+		lineW = projectedWidth;
+		lineEndSegment = i + 1;
+		lineEndGrapheme = 0;
+		if (canBreakAfter(seg.kind)) {
+			recordPending(i + 1, 0, seg.kind === "space" ? lineW - w : lineW, seg.kind);
+		}
+	}
+	if (!hasContent) return null;
+	const endsAtSoftHyphen =
+		lineEndSegment > 0 && segments[lineEndSegment - 1]?.kind === "soft-hyphen";
+	const text = buildLineText(
+		segments,
+		startSegment,
+		startGrapheme,
+		lineEndSegment,
+		lineEndGrapheme,
+		endsAtSoftHyphen,
+		segmentAdapter,
+	);
+	return {
+		text,
+		width: lineW + (endsAtSoftHyphen ? hyphenWidth : 0),
+		start: { segmentIndex: startSegment, graphemeIndex: startGrapheme },
+		end: { segmentIndex: lineEndSegment, graphemeIndex: lineEndGrapheme },
+	};
+}
+
+/** Subtract obstacle intervals from a horizontal text band. */
+export function carveTextLineSlots(
+	base: Interval,
+	blocked: readonly Interval[],
+	minSlotWidth = 0,
+): Interval[] {
+	let slots: Interval[] = [base];
+	for (const block of blocked) {
+		const next: Interval[] = [];
+		for (const slot of slots) {
+			if (block.right <= slot.left || block.left >= slot.right) {
+				next.push(slot);
+				continue;
+			}
+			if (block.left > slot.left) next.push({ left: slot.left, right: block.left });
+			if (block.right < slot.right) next.push({ left: block.right, right: slot.right });
+		}
+		slots = next;
+	}
+	if (minSlotWidth > 0) return slots.filter((slot) => slot.right - slot.left >= minSlotWidth);
+	return slots;
+}
+
+/** Compute per-grapheme boxes for already-broken lines. */
+export function computeCharPositions(
+	lineBreaks: LineBreaksResult,
+	segments: readonly PreparedSegment[],
+	lineHeight: number,
+	segmentAdapter?: SegmentAdapter,
+): readonly CharPosition[] {
+	const positions: CharPosition[] = [];
+	const segAdapter = segmentAdapter ?? getDefaultSegmentAdapter();
+	for (let lineIdx = 0; lineIdx < lineBreaks.lines.length; lineIdx += 1) {
+		const line = lineBreaks.lines[lineIdx];
+		const y = lineIdx * lineHeight;
+		let x = 0;
+		for (let si = line.startSegment; si < segments.length; si += 1) {
+			const seg = segments[si];
+			if (seg.kind === "soft-hyphen" || seg.kind === "hard-break") {
+				if (si >= line.endSegment && line.endGrapheme === 0) break;
+				continue;
+			}
+			const graphemes = [...segAdapter.segmentGraphemes(seg.text)].map((g) => g.segment);
+			if (graphemes.length === 0) continue;
+			const startGrapheme = si === line.startSegment ? line.startGrapheme : 0;
+			let endGrapheme: number;
+			if (si < line.endSegment) {
+				endGrapheme = graphemes.length;
+			} else if (si === line.endSegment && line.endGrapheme > 0) {
+				endGrapheme = line.endGrapheme;
+			} else {
+				break;
+			}
+			for (let g = startGrapheme; g < endGrapheme; g += 1) {
+				const width = seg.graphemeWidths ? seg.graphemeWidths[g] : seg.width / graphemes.length;
+				positions.push({ x, y, width, height: lineHeight, line: lineIdx });
+				x += width;
+			}
+		}
+	}
+	return positions;
+}
diff --git a/packages/ts/src/solutions/reactive-layout/measurements.ts b/packages/ts/src/solutions/reactive-layout/measurements.ts
new file mode 100644
index 00000000..9e6b1ee4
--- /dev/null
+++ b/packages/ts/src/solutions/reactive-layout/measurements.ts
@@ -0,0 +1,728 @@
+import { type Ctx, depLatest } from "../../ctx/types.js";
+import type { DataIssue } from "../../data/index.js";
+import type { Graph, StateNode } from "../../graph/graph.js";
+import { Node } from "../../node/node.js";
+import {
+	CapabilityMeasureAdapter,
+	CellMeasureAdapter,
+	InjectedMeasureAdapter,
+	PrecomputedMeasureAdapter,
+} from "./adapters.js";
+import { measureBlock } from "./block.js";
+import { analyzeAndMeasure } from "./line.js";
+import { getDefaultSegmentAdapter } from "./segment.js";
+import type {
+	BlockAdapters,
+	BlockAdaptersProviderOptions,
+	BlockMeasurementProviderOptions,
+	BlocksMeasurement,
+	CapabilityTextMeasurementsOptions,
+	CellTextMeasurementsOptions,
+	ContentBlock,
+	ImageMeasurer,
+	ImageSizeMeasurementsOptions,
+	ImageSizeMeasurementTarget,
+	InjectedTextMeasurementsOptions,
+	MeasuredBlock,
+	MeasurementAdapter,
+	MeasurementFact,
+	MeasurementIssue,
+	MeasurementReadiness,
+	MeasurementResult,
+	Measurements,
+	MergeMeasurementsOptions,
+	PrecomputedTextMeasurementsOptions,
+	ReadinessMeasurementsOptions,
+	ReadinessTextMeasurementsOptions,
+	SegmentAdapter,
+	Size,
+	SvgBoundsMeasurementsOptions,
+	SvgBoundsMeasurementTarget,
+	SvgMeasurer,
+	TextMeasureCapability,
+	TextMeasurementProviderOptions,
+	TextSegmentsMeasurement,
+} from "./types.js";
+import {
+	BLOCKS_MEASUREMENT_KIND,
+	IMAGE_SIZE_MEASUREMENT_KIND,
+	READINESS_MEASUREMENT_KIND,
+	SVG_BOUNDS_MEASUREMENT_KIND,
+	TEXT_SEGMENTS_MEASUREMENT_KIND,
+} from "./types.js";
+import { nonNegativeFinite } from "./utils.js";
+
+export function measurementIssue(
+	code: string,
+	message: string,
+	targetId: string,
+	measurementKind: string,
+	opts: {
+		readonly source?: string;
+		readonly details?: unknown;
+		readonly metadata?: Record<string, unknown>;
+		readonly severity?: DataIssue["severity"];
+	} = {},
+): MeasurementIssue {
+	return {
+		kind: "issue",
+		code,
+		message,
+		severity: opts.severity ?? "warning",
+		source: opts.source,
+		subjectId: targetId,
+		measurementKind,
+		details: opts.details,
+		metadata: opts.metadata,
+	};
+}
+
+export function measurementOk<T>(
+	targetId: string,
+	measurementKind: string,
+	value: T,
+	opts: { readonly source?: string; readonly metadata?: Record<string, unknown> } = {},
+): MeasurementResult<T> {
+	return {
+		kind: "ok",
+		targetId,
+		measurementKind,
+		value,
+		source: opts.source,
+		metadata: opts.metadata,
+	};
+}
+
+export function latestMeasurementValue<T>(
+	measurements: Measurements,
+	targetId: string,
+	measurementKind: string,
+): T | undefined {
+	let value: T | undefined;
+	for (const fact of measurements) {
+		if (
+			fact.kind === "ok" &&
+			fact.targetId === targetId &&
+			fact.measurementKind === measurementKind
+		) {
+			value = fact.value as T;
+		}
+	}
+	return value;
+}
+
+export function tryMeasureHyphenWidth(
+	adapter: MeasurementAdapter,
+	font: string,
+): number | undefined {
+	try {
+		return nonNegativeFinite(adapter.measureSegment("-", font).width, 0);
+	} catch {
+		return undefined;
+	}
+}
+
+export function validMeasurementSize(size: Size, label: string): Size {
+	if (
+		!Number.isFinite(size.width) ||
+		!Number.isFinite(size.height) ||
+		size.width < 0 ||
+		size.height < 0
+	) {
+		throw new Error(`Invalid ${label} measurement size`);
+	}
+	return size;
+}
+
+export function textMeasurementFacts(
+	text: string,
+	font: string,
+	adapter: MeasurementAdapter,
+	cache: Map<string, Map<string, number>>,
+	segmentAdapter: SegmentAdapter,
+	targetId: string,
+	source: string,
+): Measurements {
+	try {
+		const segments = analyzeAndMeasure(text, font, adapter, cache, undefined, segmentAdapter);
+		const hyphenWidth = tryMeasureHyphenWidth(adapter, font);
+		const facts: MeasurementFact<TextSegmentsMeasurement>[] = [
+			measurementOk<TextSegmentsMeasurement>(
+				targetId,
+				TEXT_SEGMENTS_MEASUREMENT_KIND,
+				hyphenWidth === undefined ? { segments } : { segments, hyphenWidth },
+				{ source },
+			),
+		];
+		if (hyphenWidth === undefined) {
+			facts.push(
+				measurementIssue(
+					"measurement.hyphen.failed",
+					`Hyphen measurement failed for '${targetId}'`,
+					targetId,
+					TEXT_SEGMENTS_MEASUREMENT_KIND,
+					{ source, severity: "warning" },
+				),
+			);
+		}
+		return facts;
+	} catch (error) {
+		return [
+			measurementIssue(
+				"measurement.failed",
+				`Text measurement failed for '${targetId}'`,
+				targetId,
+				TEXT_SEGMENTS_MEASUREMENT_KIND,
+				{ source, details: error, severity: "error" },
+			),
+		];
+	}
+}
+
+export function inputNode<T>(
+	g: Graph,
+	input: T | Node<T> | undefined,
+	fallback: T,
+	name: string,
+): { readonly node: Node<T>; readonly set: (value: T) => void } {
+	if (input instanceof Node) {
+		return {
+			node: input,
+			set(value: T): void {
+				const maybeState = input as Node<T> & { set?: (next: T) => void };
+				if (typeof maybeState.set !== "function") {
+					throw new TypeError(`reactive-layout input '${name}' is not a writable state node`);
+				}
+				maybeState.set(value);
+			},
+		};
+	}
+	const state: StateNode<T> = g.state(input ?? fallback, { name });
+	return { node: state, set: (value: T) => state.set(value) };
+}
+
+export function scopedName(scope: string, local: string): string {
+	return scope === local ? local : `${scope}:${local}`;
+}
+
+/** Generic sync text measurement provider that emits graph-visible measurement facts. */
+export function textMeasurementProvider(opts: TextMeasurementProviderOptions): Node<Measurements> {
+	const targetId = opts.targetId ?? "text";
+	const name = opts.name ?? `${targetId}-measurements`;
+	const source = opts.source ?? name;
+	const cache = new Map<string, Map<string, number>>();
+	let activeAdapter: MeasurementAdapter | null = null;
+	return opts.graph.node<Measurements>(
+		opts.segmentAdapter
+			? [opts.text, opts.font, opts.adapter, opts.segmentAdapter]
+			: [opts.text, opts.font, opts.adapter],
+		(ctx: Ctx) => {
+			const flush = () => {
+				cache.clear();
+				(depLatest(ctx, 2) as MeasurementAdapter).clearCache?.();
+			};
+			ctx.onDeactivation(flush);
+			ctx.onInvalidate(flush);
+			const text = depLatest(ctx, 0) as string;
+			const font = depLatest(ctx, 1) as string;
+			const adapter = depLatest(ctx, 2) as MeasurementAdapter;
+			if (adapter !== activeAdapter) {
+				cache.clear();
+				activeAdapter = adapter;
+			}
+			const segmentAdapter =
+				opts.segmentAdapter === undefined
+					? getDefaultSegmentAdapter()
+					: (depLatest(ctx, 3) as SegmentAdapter);
+			ctx.down([
+				[
+					"DATA",
+					textMeasurementFacts(text, font, adapter, cache, segmentAdapter, targetId, source),
+				],
+			]);
+		},
+		{ name },
+	);
+}
+
+/** Provider helper for caller-injected synchronous text measurement. */
+export function injectedTextMeasurements(
+	opts: InjectedTextMeasurementsOptions,
+): Node<Measurements> {
+	const targetId = opts.targetId ?? "text";
+	const adapter = opts.graph.state<MeasurementAdapter>(
+		new InjectedMeasureAdapter(opts.measure, { cache: opts.cache }),
+		{
+			name: opts.name
+				? scopedName(opts.name, "measure-capability")
+				: `${targetId}-measure-capability`,
+		},
+	);
+	return textMeasurementProvider({
+		...opts,
+		adapter,
+		source: opts.source ?? "injectedTextMeasurements",
+	});
+}
+
+/** Provider helper for deterministic precomputed text metrics. */
+export function precomputedTextMeasurements(
+	opts: PrecomputedTextMeasurementsOptions,
+): Node<Measurements> {
+	const targetId = opts.targetId ?? "text";
+	const adapter = opts.graph.state<MeasurementAdapter>(new PrecomputedMeasureAdapter(opts), {
+		name: opts.name
+			? scopedName(opts.name, "measure-capability")
+			: `${targetId}-measure-capability`,
+	});
+	return textMeasurementProvider({
+		...opts,
+		adapter,
+		source: opts.source ?? "precomputedTextMeasurements",
+	});
+}
+
+/** Provider helper for fixed-cell terminal/snapshot text measurement. */
+export function cellTextMeasurements(opts: CellTextMeasurementsOptions): Node<Measurements> {
+	const targetId = opts.targetId ?? "text";
+	const adapter = opts.graph.state<MeasurementAdapter>(new CellMeasureAdapter(opts), {
+		name: opts.name
+			? scopedName(opts.name, "measure-capability")
+			: `${targetId}-measure-capability`,
+	});
+	return textMeasurementProvider({
+		...opts,
+		adapter,
+		source: opts.source ?? "cellTextMeasurements",
+	});
+}
+
+/** Provider helper for caller-injected platform text capability nodes. */
+export function capabilityTextMeasurements(
+	opts: CapabilityTextMeasurementsOptions,
+): Node<Measurements> {
+	const targetId = opts.targetId ?? "text";
+	const adapter = opts.graph.node<MeasurementAdapter>(
+		[opts.capability],
+		(ctx: Ctx) => {
+			ctx.down([
+				["DATA", new CapabilityMeasureAdapter(depLatest(ctx, 0) as TextMeasureCapability)],
+			]);
+		},
+		{
+			name: opts.name
+				? scopedName(opts.name, "measure-capability")
+				: `${targetId}-measure-capability`,
+		},
+	);
+	return textMeasurementProvider({
+		...opts,
+		adapter,
+		source: opts.source ?? "capabilityTextMeasurements",
+	});
+}
+
+/** Provider helper that makes readiness facts an explicit measurement dependency. */
+export function readinessTextMeasurements(
+	opts: ReadinessTextMeasurementsOptions,
+): Node<Measurements> {
+	const targetId = opts.targetId ?? "text";
+	const name = opts.name ?? `${targetId}-measurements`;
+	const source = opts.source ?? name;
+	const cache = new Map<string, Map<string, number>>();
+	let activeAdapter: MeasurementAdapter | null = null;
+	let activeReadiness: MeasurementReadiness | null = null;
+	const deps = opts.segmentAdapter
+		? [opts.text, opts.font, opts.adapter, opts.readiness, opts.segmentAdapter]
+		: [opts.text, opts.font, opts.adapter, opts.readiness];
+	return opts.graph.node<Measurements>(
+		deps,
+		(ctx: Ctx) => {
+			const flush = () => {
+				cache.clear();
+				(depLatest(ctx, 2) as MeasurementAdapter).clearCache?.();
+			};
+			ctx.onDeactivation(flush);
+			ctx.onInvalidate(flush);
+			const text = depLatest(ctx, 0) as string;
+			const font = depLatest(ctx, 1) as string;
+			const adapter = depLatest(ctx, 2) as MeasurementAdapter;
+			if (adapter !== activeAdapter) {
+				cache.clear();
+				activeAdapter = adapter;
+			}
+			const readiness = depLatest(ctx, 3) as MeasurementReadiness;
+			if (readiness !== activeReadiness) {
+				cache.clear();
+				activeReadiness = readiness;
+			}
+			if (!readiness.ready) {
+				ctx.down([
+					[
+						"DATA",
+						[
+							measurementIssue(
+								readiness.code ?? "measurement.not-ready",
+								readiness.message ?? `Measurement readiness blocked '${targetId}'`,
+								targetId,
+								TEXT_SEGMENTS_MEASUREMENT_KIND,
+								{
+									source: readiness.source ?? source,
+									details: readiness.details,
+									metadata: readiness.metadata,
+									severity: "warning",
+								},
+							),
+						],
+					],
+				]);
+				return;
+			}
+			const segmentAdapter =
+				opts.segmentAdapter === undefined
+					? getDefaultSegmentAdapter()
+					: (depLatest(ctx, 4) as SegmentAdapter);
+			ctx.down([
+				[
+					"DATA",
+					textMeasurementFacts(text, font, adapter, cache, segmentAdapter, targetId, source),
+				],
+			]);
+		},
+		{ name },
+	);
+}
+
+/** Provider helper that emits graph-visible readiness facts without measuring layout. */
+export function readinessMeasurements(opts: ReadinessMeasurementsOptions): Node<Measurements> {
+	const targetId = opts.targetId ?? "measurement-readiness";
+	const measurementKind = opts.measurementKind ?? READINESS_MEASUREMENT_KIND;
+	const name = opts.name ?? `${targetId}-measurements`;
+	const source = opts.source ?? name;
+	return opts.graph.node<Measurements>(
+		[opts.readiness],
+		(ctx: Ctx) => {
+			const readiness = depLatest(ctx, 0) as MeasurementReadiness;
+			if (!readiness.ready) {
+				ctx.down([
+					[
+						"DATA",
+						[
+							measurementIssue(
+								readiness.code ?? "measurement.not-ready",
+								readiness.message ?? `Measurement readiness blocked '${targetId}'`,
+								targetId,
+								measurementKind,
+								{
+									source: readiness.source ?? source,
+									details: readiness.details,
+									metadata: readiness.metadata,
+									severity: "warning",
+								},
+							),
+						],
+					],
+				]);
+				return;
+			}
+			ctx.down([
+				[
+					"DATA",
+					[
+						measurementOk<MeasurementReadiness>(targetId, measurementKind, readiness, {
+							source: readiness.source ?? source,
+							metadata: readiness.metadata,
+						}),
+					],
+				],
+			]);
+		},
+		{ name },
+	);
+}
+
+/** Provider helper for image-size facts from caller-owned synchronous image measurers. */
+export function imageSizeMeasurements(opts: ImageSizeMeasurementsOptions): Node<Measurements> {
+	const measurementKind = opts.measurementKind ?? IMAGE_SIZE_MEASUREMENT_KIND;
+	const name = opts.name ?? "image-size-measurements";
+	const source = opts.source ?? name;
+	return opts.graph.node<Measurements>(
+		[opts.images, opts.measurer],
+		(ctx: Ctx) => {
+			const images = depLatest(ctx, 0) as readonly ImageSizeMeasurementTarget[];
+			const measurer = depLatest(ctx, 1) as ImageMeasurer;
+			const facts: MeasurementFact<Size>[] = [];
+			for (let i = 0; i < images.length; i += 1) {
+				const image = (images as readonly (ImageSizeMeasurementTarget | undefined)[])[i];
+				const subjectId = image?.id ?? image?.src ?? `image:${i}`;
+				try {
+					if (image === undefined) throw new Error(`Missing image target at index ${i}`);
+					facts.push(
+						measurementOk<Size>(
+							subjectId,
+							measurementKind,
+							validMeasurementSize(measurer.measureImage(image.src), "image"),
+							{
+								source,
+								metadata: image.metadata,
+							},
+						),
+					);
+				} catch (error) {
+					facts.push(
+						measurementIssue(
+							"measurement.image-size.failed",
+							`Image size measurement failed for '${subjectId}'`,
+							subjectId,
+							measurementKind,
+							{
+								source,
+								details: { error, index: i, src: image?.src },
+								metadata: image?.metadata,
+								severity: "error",
+							},
+						),
+					);
+				}
+			}
+			ctx.down([["DATA", facts]]);
+		},
+		{ name },
+	);
+}
+
+/** Provider helper for SVG bounds facts from caller-owned synchronous SVG measurers. */
+export function svgBoundsMeasurements(opts: SvgBoundsMeasurementsOptions): Node<Measurements> {
+	const measurementKind = opts.measurementKind ?? SVG_BOUNDS_MEASUREMENT_KIND;
+	const name = opts.name ?? "svg-bounds-measurements";
+	const source = opts.source ?? name;
+	return opts.graph.node<Measurements>(
+		[opts.svgs, opts.measurer],
+		(ctx: Ctx) => {
+			const svgs = depLatest(ctx, 0) as readonly SvgBoundsMeasurementTarget[];
+			const measurer = depLatest(ctx, 1) as SvgMeasurer;
+			const facts: MeasurementFact<Size>[] = [];
+			for (let i = 0; i < svgs.length; i += 1) {
+				const svg = (svgs as readonly (SvgBoundsMeasurementTarget | undefined)[])[i];
+				const subjectId = svg?.id ?? `svg:${i}`;
+				try {
+					if (svg === undefined) throw new Error(`Missing SVG target at index ${i}`);
+					facts.push(
+						measurementOk<Size>(
+							subjectId,
+							measurementKind,
+							validMeasurementSize(measurer.measureSvg(svg.svg), "SVG"),
+							{
+								source,
+								metadata: svg.metadata,
+							},
+						),
+					);
+				} catch (error) {
+					facts.push(
+						measurementIssue(
+							"measurement.svg-bounds.failed",
+							`SVG bounds measurement failed for '${subjectId}'`,
+							subjectId,
+							measurementKind,
+							{
+								source,
+								details: { error, index: i },
+								metadata: svg?.metadata,
+								severity: "error",
+							},
+						),
+					);
+				}
+			}
+			ctx.down([["DATA", facts]]);
+		},
+		{ name },
+	);
+}
+
+/** Merge provider fact nodes into the single measurements node consumed by layout bundles. */
+export function mergeMeasurements(opts: MergeMeasurementsOptions): Node<Measurements> {
+	const sources = [...opts.sources];
+	return opts.graph.node<Measurements>(
+		sources as readonly Node<unknown>[],
+		(ctx: Ctx) => {
+			const facts: MeasurementFact[] = [];
+			for (let i = 0; i < sources.length; i += 1) {
+				facts.push(...(depLatest(ctx, i) as Measurements));
+			}
+			ctx.down([["DATA", facts]]);
+		},
+		{ name: opts.name ?? "measurements" },
+	);
+}
+
+/** Compose optional block measurement capability nodes into one graph-visible adapter node. */
+export function blockAdaptersProvider(opts: BlockAdaptersProviderOptions): Node<BlockAdapters> {
+	const deps: Node<unknown>[] = [];
+	const positions: { text?: number; svg?: number; image?: number } = {};
+	if (opts.text) {
+		positions.text = deps.length;
+		deps.push(opts.text);
+	}
+	if (opts.svg) {
+		positions.svg = deps.length;
+		deps.push(opts.svg);
+	}
+	if (opts.image) {
+		positions.image = deps.length;
+		deps.push(opts.image);
+	}
+	return opts.graph.node<BlockAdapters>(
+		deps,
+		(ctx: Ctx) => {
+			const adapters: BlockAdapters = {
+				text:
+					positions.text === undefined
+						? undefined
+						: (depLatest(ctx, positions.text) as MeasurementAdapter),
+				svg:
+					positions.svg === undefined ? undefined : (depLatest(ctx, positions.svg) as SvgMeasurer),
+				image:
+					positions.image === undefined
+						? undefined
+						: (depLatest(ctx, positions.image) as ImageMeasurer),
+			};
+			ctx.down([["DATA", adapters]]);
+		},
+		{ name: opts.name ?? "block-adapters" },
+	);
+}
+
+/** Provider helper for block measurement facts over declared block/max-width deps. */
+export function blockMeasurementProvider(
+	opts: BlockMeasurementProviderOptions,
+): Node<Measurements> {
+	const targetId = opts.targetId ?? "blocks";
+	const name = opts.name ?? `${targetId}-measurements`;
+	const source = opts.source ?? name;
+	const cache = new Map<string, Map<string, number>>();
+	let activeTextAdapter: MeasurementAdapter | undefined;
+	const deps = [opts.blocks, opts.maxWidth, opts.adapters] as Node<unknown>[];
+	if (opts.font) deps.push(opts.font);
+	if (opts.lineHeight) deps.push(opts.lineHeight);
+	if (opts.segmentAdapter) deps.push(opts.segmentAdapter);
+	return opts.graph.node<Measurements>(
+		deps,
+		(ctx: Ctx) => {
+			const flush = () => {
+				cache.clear();
+				const adapters = depLatest(ctx, 2) as BlockAdapters;
+				adapters.text?.clearCache?.();
+			};
+			ctx.onDeactivation(flush);
+			ctx.onInvalidate(flush);
+			try {
+				const blocks = depLatest(ctx, 0) as readonly ContentBlock[];
+				const maxWidth = nonNegativeFinite(depLatest(ctx, 1) as number, 0);
+				const adapters = depLatest(ctx, 2) as BlockAdapters;
+				if (adapters.text !== activeTextAdapter) {
+					cache.clear();
+					activeTextAdapter = adapters.text;
+				}
+				let depIndex = 3;
+				const font = opts.font ? (depLatest(ctx, depIndex++) as string) : undefined;
+				const lineHeight = opts.lineHeight
+					? nonNegativeFinite(depLatest(ctx, depIndex++) as number, 0)
+					: undefined;
+				const segmentAdapter = opts.segmentAdapter
+					? (depLatest(ctx, depIndex) as SegmentAdapter)
+					: getDefaultSegmentAdapter();
+				const measured: MeasuredBlock[] = [];
+				const issues: MeasurementIssue[] = [];
+				for (let i = 0; i < blocks.length; i += 1) {
+					const block = (blocks as readonly (ContentBlock | undefined)[])[i];
+					const subjectId = block?.id ?? `${targetId}:${i}`;
+					try {
+						if (block === undefined) {
+							throw new Error(`Missing content block at index ${i}`);
+						}
+						const blockFont =
+							block.kind === "text" ? (block.font ?? font ?? "16px sans-serif") : undefined;
+						const hyphenWidth =
+							block.kind === "text" && adapters.text
+								? tryMeasureHyphenWidth(adapters.text, blockFont ?? "16px sans-serif")
+								: undefined;
+						measured.push(
+							measureBlock(block, {
+								adapters,
+								font,
+								hyphenWidth,
+								lineHeight,
+								maxWidth,
+								cache,
+								segmentAdapter,
+							}),
+						);
+						if (block.kind === "text" && adapters.text) {
+							if (hyphenWidth === undefined) {
+								issues.push(
+									measurementIssue(
+										"measurement.hyphen.failed",
+										`Hyphen measurement failed for '${subjectId}'`,
+										subjectId,
+										BLOCKS_MEASUREMENT_KIND,
+										{
+											source,
+											details: { targetId, index: i },
+											severity: "warning",
+										},
+									),
+								);
+							}
+						}
+					} catch (error) {
+						issues.push(
+							measurementIssue(
+								"measurement.block.failed",
+								`Block measurement failed for '${subjectId}'`,
+								subjectId,
+								BLOCKS_MEASUREMENT_KIND,
+								{
+									source,
+									details: { error, targetId, index: i, blockKind: block?.kind },
+									severity: "error",
+								},
+							),
+						);
+					}
+				}
+				ctx.down([
+					[
+						"DATA",
+						[
+							measurementOk<BlocksMeasurement>(
+								targetId,
+								BLOCKS_MEASUREMENT_KIND,
+								{ blocks: measured },
+								{ source },
+							),
+							...issues,
+						],
+					],
+				]);
+			} catch (error) {
+				ctx.down([
+					[
+						"DATA",
+						[
+							measurementIssue(
+								"measurement.failed",
+								`Block measurement failed for '${targetId}'`,
+								targetId,
+								BLOCKS_MEASUREMENT_KIND,
+								{ source, details: error, severity: "error" },
+							),
+						],
+					],
+				]);
+			}
+		},
+		{ name },
+	);
+}
diff --git a/packages/ts/src/solutions/reactive-layout/node-canvas/index.ts b/packages/ts/src/solutions/reactive-layout/node-canvas/index.ts
new file mode 100644
index 00000000..d43172db
--- /dev/null
+++ b/packages/ts/src/solutions/reactive-layout/node-canvas/index.ts
@@ -0,0 +1,186 @@
+import { createRequire } from "node:module";
+import { type Ctx, depLatest } from "../../../ctx/types.js";
+import type { Graph } from "../../../graph/graph.js";
+import type { Node } from "../../../node/node.js";
+import {
+	capabilityTextMeasurements,
+	type Measurements,
+	type SegmentAdapter,
+	type TextMeasureCapability,
+} from "../index.js";
+
+/** Minimal caller-owned NodeCanvas-style 2D text context. */
+export interface NodeCanvasTextContextLike {
+	measureText(text: string): { readonly width: number };
+	font: string;
+}
+
+export interface NodeCanvasLike {
+	getContext(type: "2d"): NodeCanvasTextContextLike | null;
+}
+
+export interface NodeCanvasPackageLike {
+	createCanvas(width: number, height: number): NodeCanvasLike;
+}
+
+/** Dependency-free NodeCanvas focused subpath options. */
+export interface NodeCanvasTextMeasurementsOptions {
+	readonly graph: Graph;
+	readonly text: Node<string>;
+	readonly font: Node<string>;
+	readonly context: Node<NodeCanvasTextContextLike>;
+	readonly segmentAdapter?: Node<SegmentAdapter>;
+	readonly targetId?: string;
+	readonly source?: string;
+	readonly name?: string;
+}
+
+/** Optional-peer NodeCanvas focused subpath options. */
+export interface NodeCanvasPackageTextMeasurementsOptions
+	extends Omit<NodeCanvasTextMeasurementsOptions, "context"> {
+	readonly canvas?: NodeCanvasPackageLike;
+	readonly width?: number;
+	readonly height?: number;
+}
+
+const requireOptionalPeer = createRequire(`${process.cwd()}/package.json`);
+
+function loadCanvasPackage(): NodeCanvasPackageLike {
+	const errors: unknown[] = [];
+	if (typeof require === "function") {
+		try {
+			return require("canvas") as NodeCanvasPackageLike;
+		} catch (error) {
+			errors.push(error);
+		}
+	}
+	try {
+		return requireOptionalPeer("canvas") as NodeCanvasPackageLike;
+	} catch (error) {
+		errors.push(error);
+		throw new TypeError(
+			"nodeCanvasPackageTextMeasurements requires optional peer dependency 'canvas'. Install canvas, pass { canvas }, or use nodeCanvasTextMeasurements({ context }) with a caller-owned 2D context.",
+			{ cause: errors.at(-1) },
+		);
+	}
+}
+
+class NodeCanvasPackageTextCapability implements TextMeasureCapability {
+	private readonly canvasPackage?: NodeCanvasPackageLike;
+	private readonly width: number;
+	private readonly height: number;
+	private context: NodeCanvasTextContextLike | null = null;
+
+	constructor(opts: {
+		readonly canvas?: NodeCanvasPackageLike;
+		readonly width: number;
+		readonly height: number;
+	}) {
+		this.canvasPackage = opts.canvas;
+		this.width = opts.width;
+		this.height = opts.height;
+	}
+
+	private getContext(): NodeCanvasTextContextLike {
+		if (this.context !== null) return this.context;
+		const canvas = (this.canvasPackage ?? loadCanvasPackage()).createCanvas(
+			this.width,
+			this.height,
+		);
+		const context = canvas.getContext("2d");
+		if (context === null) {
+			throw new TypeError("nodeCanvasPackageTextMeasurements: failed to create a 2D context");
+		}
+		this.context = context;
+		return context;
+	}
+
+	measureText(text: string, font: string): { readonly width: number } {
+		const context = this.getContext();
+		const previousFont = context.font;
+		context.font = font;
+		try {
+			return context.measureText(text);
+		} finally {
+			context.font = previousFont;
+		}
+	}
+}
+
+/**
+ * NodeCanvas provider helper for caller-injected 2D contexts.
+ *
+ * This subpath does not import `canvas`; hosts create and own the native context.
+ */
+export function nodeCanvasTextMeasurements(
+	opts: NodeCanvasTextMeasurementsOptions,
+): Node<Measurements> {
+	const targetId = opts.targetId ?? "text";
+	const capability = opts.graph.node<TextMeasureCapability>(
+		[opts.context],
+		(ctx: Ctx) => {
+			const context = depLatest(ctx, 0) as NodeCanvasTextContextLike;
+			const value: TextMeasureCapability = {
+				measureText(text: string, font: string): { readonly width: number } {
+					const previousFont = context.font;
+					context.font = font;
+					try {
+						return context.measureText(text);
+					} finally {
+						context.font = previousFont;
+					}
+				},
+			};
+			ctx.down([["DATA", value]]);
+		},
+		{
+			name: opts.name
+				? `${opts.name}:node-canvas-measure-capability`
+				: `${targetId}-node-canvas-measure-capability`,
+		},
+	);
+	return capabilityTextMeasurements({
+		graph: opts.graph,
+		text: opts.text,
+		font: opts.font,
+		capability,
+		segmentAdapter: opts.segmentAdapter,
+		targetId: opts.targetId,
+		source: opts.source ?? "nodeCanvasTextMeasurements",
+		name: opts.name,
+	});
+}
+
+/**
+ * NodeCanvas provider helper backed by the optional `canvas` peer package.
+ *
+ * The native package is loaded only when the graph measures; the universal layout core and
+ * caller-injected `nodeCanvasTextMeasurements` helper remain dependency-free.
+ */
+export function nodeCanvasPackageTextMeasurements(
+	opts: NodeCanvasPackageTextMeasurementsOptions,
+): Node<Measurements> {
+	const targetId = opts.targetId ?? "text";
+	const capability = opts.graph.state<TextMeasureCapability>(
+		new NodeCanvasPackageTextCapability({
+			canvas: opts.canvas,
+			width: opts.width ?? 0,
+			height: opts.height ?? 0,
+		}),
+		{
+			name: opts.name
+				? `${opts.name}:node-canvas-measure-capability`
+				: `${targetId}-node-canvas-measure-capability`,
+		},
+	);
+	return capabilityTextMeasurements({
+		graph: opts.graph,
+		text: opts.text,
+		font: opts.font,
+		capability,
+		segmentAdapter: opts.segmentAdapter,
+		targetId: opts.targetId,
+		source: opts.source ?? "nodeCanvasPackageTextMeasurements",
+		name: opts.name,
+	});
+}
diff --git a/packages/ts/src/solutions/reactive-layout/react-native/index.ts b/packages/ts/src/solutions/reactive-layout/react-native/index.ts
new file mode 100644
index 00000000..088b4d41
--- /dev/null
+++ b/packages/ts/src/solutions/reactive-layout/react-native/index.ts
@@ -0,0 +1,135 @@
+import { type Ctx, depLatest } from "../../../ctx/types.js";
+import type { Graph } from "../../../graph/graph.js";
+import type { Node } from "../../../node/node.js";
+import {
+	type CapabilityTextMeasurementsOptions,
+	capabilityTextMeasurements,
+	type MeasurementFact,
+	type MeasurementIssue,
+	type MeasurementResult,
+	type Measurements,
+	type Size,
+	type TextMeasureCapability,
+} from "../index.js";
+
+/** Caller-owned synchronous React Native text capability. */
+export interface ReactNativeTextMeasureCapability extends TextMeasureCapability {}
+
+export const REACT_NATIVE_LAYOUT_MEASUREMENT_KIND = "react-native-layout";
+
+/** Dependency-free React Native focused subpath options. */
+export interface ReactNativeTextMeasurementsOptions
+	extends Omit<CapabilityTextMeasurementsOptions, "capability"> {
+	readonly capability: Node<ReactNativeTextMeasureCapability>;
+}
+
+/** One async onLayout/native-probe fact supplied by a React Native host. */
+export interface ReactNativeLayoutProbe {
+	readonly id?: string;
+	readonly width?: number;
+	readonly height?: number;
+	readonly ready?: boolean;
+	readonly code?: string;
+	readonly message?: string;
+	readonly source?: string;
+	readonly details?: unknown;
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface ReactNativeLayoutMeasurementsOptions {
+	readonly graph: Graph;
+	readonly probes: Node<readonly ReactNativeLayoutProbe[]>;
+	readonly measurementKind?: string;
+	readonly source?: string;
+	readonly name?: string;
+}
+
+/**
+ * React Native provider helper for caller-injected synchronous text measurement.
+ *
+ * Async native readiness or layout probes should enter the graph as explicit facts upstream.
+ */
+export function reactNativeTextMeasurements(
+	opts: ReactNativeTextMeasurementsOptions,
+): Node<Measurements> {
+	return capabilityTextMeasurements({
+		...opts,
+		source: opts.source ?? "reactNativeTextMeasurements",
+	});
+}
+
+function validLayoutSize(probe: ReactNativeLayoutProbe): Size | null {
+	const width = probe.width;
+	const height = probe.height;
+	if (
+		typeof width !== "number" ||
+		typeof height !== "number" ||
+		!Number.isFinite(width) ||
+		!Number.isFinite(height) ||
+		width < 0 ||
+		height < 0
+	) {
+		return null;
+	}
+	return { width, height };
+}
+
+function reactNativeMeasurementIssue(
+	probe: ReactNativeLayoutProbe | undefined,
+	index: number,
+	subjectId: string,
+	measurementKind: string,
+	source: string,
+): MeasurementIssue {
+	return {
+		kind: "issue",
+		code: probe?.code ?? "measurement.react-native-layout.pending",
+		message: probe?.message ?? `React Native layout measurement is not ready for '${subjectId}'`,
+		severity: probe?.ready === false ? "warning" : "error",
+		source: probe?.source ?? source,
+		subjectId,
+		measurementKind,
+		details: probe?.details ?? { index },
+		metadata: probe?.metadata,
+	};
+}
+
+/**
+ * Project React Native onLayout/native-probe results into measurement facts.
+ *
+ * The async probe mechanism lives outside GraphReFly; this helper only consumes the latest probe
+ * facts as declared graph data and never pretends RN core measurement is synchronous.
+ */
+export function reactNativeLayoutMeasurements(
+	opts: ReactNativeLayoutMeasurementsOptions,
+): Node<Measurements> {
+	const measurementKind = opts.measurementKind ?? REACT_NATIVE_LAYOUT_MEASUREMENT_KIND;
+	const source = opts.source ?? "reactNativeLayoutMeasurements";
+	return opts.graph.node<Measurements>(
+		[opts.probes],
+		(ctx: Ctx) => {
+			const probes = depLatest(ctx, 0) as readonly ReactNativeLayoutProbe[];
+			const facts: MeasurementFact<Size>[] = [];
+			for (let i = 0; i < probes.length; i += 1) {
+				const probe = (probes as readonly (ReactNativeLayoutProbe | undefined)[])[i];
+				const subjectId = probe?.id ?? `react-native-layout:${i}`;
+				const size = probe && probe.ready !== false ? validLayoutSize(probe) : null;
+				if (probe && size) {
+					const ok: MeasurementResult<Size> = {
+						kind: "ok",
+						targetId: subjectId,
+						measurementKind,
+						value: size,
+						source: probe.source ?? source,
+						metadata: probe.metadata,
+					};
+					facts.push(ok);
+				} else {
+					facts.push(reactNativeMeasurementIssue(probe, i, subjectId, measurementKind, source));
+				}
+			}
+			ctx.down([["DATA", facts]]);
+		},
+		{ name: opts.name ?? "react-native-layout-measurements" },
+	);
+}
diff --git a/packages/ts/src/solutions/reactive-layout/segment.ts b/packages/ts/src/solutions/reactive-layout/segment.ts
new file mode 100644
index 00000000..ea040ac3
--- /dev/null
+++ b/packages/ts/src/solutions/reactive-layout/segment.ts
@@ -0,0 +1,176 @@
+import type { SegmentAdapter, SegmentBreakKind, SegmentInfo } from "./types.js";
+
+export const kinsokuStart = /* @__PURE__ */ new Set([
+	"\u3001",
+	"\u3002",
+	"\u30FB",
+	"\uFF09",
+	"\u3015",
+	"\u3009",
+	"\u300B",
+	"\u300D",
+	"\u300F",
+	"\u3011",
+]);
+
+export const leftStickyPunctuation = /* @__PURE__ */ new Set([
+	".",
+	",",
+	"!",
+	"?",
+	":",
+	";",
+	")",
+	"]",
+	"}",
+	"%",
+	'"',
+	"\u201D",
+	"\u2019",
+	"\xBB",
+	"\u203A",
+	"\u2026",
+]);
+
+export function isCJK(text: string): boolean {
+	for (const ch of text) {
+		const c = ch.codePointAt(0);
+		if (
+			(c !== undefined && c >= 19968 && c <= 40959) ||
+			(c !== undefined && c >= 13312 && c <= 19903) ||
+			(c !== undefined && c >= 12288 && c <= 12351) ||
+			(c !== undefined && c >= 12352 && c <= 12447) ||
+			(c !== undefined && c >= 44032 && c <= 55215) ||
+			(c !== undefined && c >= 65280 && c <= 65519)
+		) {
+			return true;
+		}
+	}
+	return false;
+}
+
+export function normalizeWhitespace(text: string): string {
+	return text.replace(/[\t\f ]+/g, " ").replace(/^ | $/g, "");
+}
+
+export function segmentText(
+	text: string,
+	segmentAdapter: SegmentAdapter,
+): {
+	readonly texts: string[];
+	readonly isWordLike: boolean[];
+	readonly kinds: SegmentBreakKind[];
+}[] {
+	const pieces: {
+		texts: string[];
+		isWordLike: boolean[];
+		kinds: SegmentBreakKind[];
+	}[] = [];
+	for (const s of segmentAdapter.segmentWords(text)) {
+		const wordSegment = s.segment;
+		const rawWordLike = s.isWordLike ?? false;
+		const pieceTexts: string[] = [];
+		const pieceWordLikes: boolean[] = [];
+		const pieceKinds: SegmentBreakKind[] = [];
+		let currentText = "";
+		let currentKind: SegmentBreakKind | null = null;
+		for (const ch of wordSegment) {
+			let kind: SegmentBreakKind;
+			if (ch === " ") {
+				kind = "space";
+			} else if (ch === "\u200B") {
+				kind = "zero-width-break";
+			} else if (ch === "\xAD") {
+				kind = "soft-hyphen";
+			} else if (ch === "\n") {
+				kind = "hard-break";
+			} else {
+				kind = "text";
+			}
+			if (currentKind !== null && kind === currentKind) {
+				currentText += ch;
+			} else {
+				if (currentKind !== null) {
+					pieceTexts.push(currentText);
+					pieceWordLikes.push(currentKind === "text" && rawWordLike);
+					pieceKinds.push(currentKind);
+				}
+				currentText = ch;
+				currentKind = kind;
+			}
+		}
+		if (currentKind !== null) {
+			pieceTexts.push(currentText);
+			pieceWordLikes.push(currentKind === "text" && rawWordLike);
+			pieceKinds.push(currentKind);
+		}
+		pieces.push({ texts: pieceTexts, isWordLike: pieceWordLikes, kinds: pieceKinds });
+	}
+	return pieces;
+}
+
+function* fallbackSegmentWords(text: string): Iterable<SegmentInfo> {
+	let index = 0;
+	let current = "";
+	let currentIndex = 0;
+	let currentWordLike: boolean | null = null;
+	const flush = () => {
+		if (current.length === 0 || currentWordLike === null) return undefined;
+		const out = { segment: current, index: currentIndex, isWordLike: currentWordLike };
+		current = "";
+		currentWordLike = null;
+		return out;
+	};
+	for (const ch of text) {
+		const isWordLike = !/[\s\u200B\u00AD]/u.test(ch);
+		if (currentWordLike !== null && currentWordLike !== isWordLike) {
+			const out = flush();
+			if (out) yield out;
+		}
+		if (currentWordLike === null) {
+			currentWordLike = isWordLike;
+			currentIndex = index;
+		}
+		current += ch;
+		index += ch.length;
+	}
+	const out = flush();
+	if (out) yield out;
+}
+
+function* fallbackSegmentGraphemes(text: string): Iterable<SegmentInfo> {
+	let index = 0;
+	for (const ch of text) {
+		yield { segment: ch, index };
+		index += ch.length;
+	}
+}
+
+export function createDefaultSegmentAdapter(): SegmentAdapter {
+	return {
+		segmentWords(text: string): Iterable<SegmentInfo> {
+			return fallbackSegmentWords(text);
+		},
+		segmentGraphemes(text: string): Iterable<SegmentInfo> {
+			return fallbackSegmentGraphemes(text);
+		},
+	};
+}
+
+let defaultSegmentAdapter: SegmentAdapter | null = null;
+
+export function getDefaultSegmentAdapter(): SegmentAdapter {
+	if (defaultSegmentAdapter === null) {
+		defaultSegmentAdapter = createDefaultSegmentAdapter();
+	}
+	return defaultSegmentAdapter;
+}
+
+export function measuredWidth(value: number | { readonly width: number }): number {
+	const width = typeof value === "number" ? value : value.width;
+	return Number.isFinite(width) && width >= 0 ? width : 0;
+}
+
+export function metricKey(text: string, font: string): string {
+	return `${font}\0${text}`;
+}
diff --git a/packages/ts/src/solutions/reactive-layout/skia/index.ts b/packages/ts/src/solutions/reactive-layout/skia/index.ts
new file mode 100644
index 00000000..879333b0
--- /dev/null
+++ b/packages/ts/src/solutions/reactive-layout/skia/index.ts
@@ -0,0 +1,127 @@
+import { depLatest } from "../../../ctx/types.js";
+import type { Node } from "../../../node/node.js";
+import {
+	CapabilityMeasureAdapter,
+	type CapabilityTextMeasurementsOptions,
+	capabilityTextMeasurements,
+	type MeasurementAdapter,
+	type MeasurementReadiness,
+	type Measurements,
+	readinessTextMeasurements,
+	type TextMeasureCapability,
+} from "../index.js";
+
+/** Caller-owned synchronous Skia text capability. */
+export interface SkiaTextMeasureCapability extends TextMeasureCapability {}
+
+export interface SkiaParagraphLike {
+	layout(width: number): void;
+	getLongestLine(): number;
+}
+
+export interface SkiaParagraphBuilderLike {
+	pushStyle?(style: unknown): SkiaParagraphBuilderLike;
+	addText(text: string): SkiaParagraphBuilderLike;
+	pop?(): SkiaParagraphBuilderLike;
+	build(): SkiaParagraphLike;
+}
+
+export interface SkiaParagraphBuilderFactoryLike {
+	Make(paragraphStyle?: unknown, fontManager?: unknown): SkiaParagraphBuilderLike;
+}
+
+export interface SkiaParagraphRuntimeLike {
+	readonly ParagraphBuilder: SkiaParagraphBuilderFactoryLike;
+}
+
+export interface SkiaParagraphTextCapabilityOptions {
+	readonly Skia: SkiaParagraphRuntimeLike;
+	readonly fontManager?: unknown;
+	readonly paragraphStyle?: unknown;
+	readonly textStyle?: unknown;
+	readonly textStyleForFont?: (font: string) => unknown;
+	readonly layoutWidth?: number;
+}
+
+/** Dependency-free Skia focused subpath options. */
+export interface SkiaTextMeasurementsOptions
+	extends Omit<CapabilityTextMeasurementsOptions, "capability"> {
+	readonly capability: Node<SkiaTextMeasureCapability>;
+}
+
+export interface SkiaReadyTextMeasurementsOptions extends SkiaTextMeasurementsOptions {
+	readonly readiness: Node<MeasurementReadiness>;
+}
+
+/**
+ * Skia provider helper for caller-injected synchronous text measurement.
+ *
+ * This subpath does not import a Skia package; hosts expose the capability as graph data.
+ */
+export function skiaTextMeasurements(opts: SkiaTextMeasurementsOptions): Node<Measurements> {
+	return capabilityTextMeasurements({
+		...opts,
+		source: opts.source ?? "skiaTextMeasurements",
+	});
+}
+
+/**
+ * Build a synchronous Skia Paragraph-backed text capability from an already-ready runtime.
+ *
+ * Hosts should load fonts first (for example with React Native Skia `useFonts`, which returns
+ * null until ready) and pass explicit readiness facts to `skiaReadyTextMeasurements`.
+ */
+export function skiaParagraphTextMeasureCapability(
+	opts: SkiaParagraphTextCapabilityOptions,
+): SkiaTextMeasureCapability {
+	const layoutWidth = opts.layoutWidth ?? Number.MAX_SAFE_INTEGER;
+	return {
+		measureText(text: string, font: string): { readonly width: number } {
+			const builder = opts.Skia.ParagraphBuilder.Make(opts.paragraphStyle ?? {}, opts.fontManager);
+			const style = opts.textStyleForFont?.(font) ?? opts.textStyle;
+			if (style !== undefined && builder.pushStyle) {
+				builder.pushStyle(style);
+			}
+			builder.addText(text);
+			if (style !== undefined && builder.pop) {
+				builder.pop();
+			}
+			const paragraph = builder.build();
+			paragraph.layout(layoutWidth);
+			return { width: paragraph.getLongestLine() };
+		},
+	};
+}
+
+/**
+ * Skia provider helper that refuses to measure until caller-supplied font/runtime readiness is DATA.
+ *
+ * This does not load fonts or create a Skia runtime; readiness is an explicit graph input.
+ */
+export function skiaReadyTextMeasurements(
+	opts: SkiaReadyTextMeasurementsOptions,
+): Node<Measurements> {
+	const targetId = opts.targetId ?? "text";
+	const adapter = opts.graph.node<MeasurementAdapter>(
+		[opts.capability],
+		(ctx) => {
+			ctx.down([
+				["DATA", new CapabilityMeasureAdapter(depLatest(ctx, 0) as SkiaTextMeasureCapability)],
+			]);
+		},
+		{
+			name: opts.name ? `${opts.name}:measure-capability` : `${targetId}-measure-capability`,
+		},
+	);
+	return readinessTextMeasurements({
+		graph: opts.graph,
+		text: opts.text,
+		font: opts.font,
+		adapter,
+		readiness: opts.readiness,
+		segmentAdapter: opts.segmentAdapter,
+		targetId: opts.targetId,
+		source: opts.source ?? "skiaReadyTextMeasurements",
+		name: opts.name,
+	});
+}
diff --git a/packages/ts/src/solutions/reactive-layout/types.ts b/packages/ts/src/solutions/reactive-layout/types.ts
new file mode 100644
index 00000000..3db0e144
--- /dev/null
+++ b/packages/ts/src/solutions/reactive-layout/types.ts
@@ -0,0 +1,519 @@
+import type { DataIssue } from "../../data/index.js";
+import type { Graph } from "../../graph/graph.js";
+import type { Node } from "../../node/node.js";
+
+/**
+ * Synchronous text measurement contract for the D181 reactive-layout solution core.
+ *
+ * Implementations are injected by the caller; the universal subpath never imports DOM,
+ * Canvas, React Native, storage, GraphSpec, or async image loading.
+ */
+export interface MeasurementAdapter {
+	measureSegment(text: string, font: string): { readonly width: number };
+	clearCache?(): void;
+}
+
+/** Caller-owned platform text capability, for NodeCanvas/Skia/RN-style wrappers. */
+export interface TextMeasureCapability {
+	measureText(text: string, font: string): number | { readonly width: number };
+	clearCache?(): void;
+}
+
+/** One text segment returned by a caller-provided segmenter. */
+export interface SegmentInfo {
+	readonly segment: string;
+	readonly index: number;
+	readonly isWordLike?: boolean;
+}
+
+/** Synchronous word/grapheme segmentation contract for hosts without Intl.Segmenter. */
+export interface SegmentAdapter {
+	segmentWords(text: string): Iterable<SegmentInfo>;
+	segmentGraphemes(text: string): Iterable<SegmentInfo>;
+}
+
+/** Layout segment class used by the line breaker. */
+export type SegmentBreakKind = "text" | "space" | "zero-width-break" | "soft-hyphen" | "hard-break";
+
+/** Measured text run consumed by pure line/block/flow helpers. */
+export interface PreparedSegment {
+	readonly text: string;
+	readonly width: number;
+	readonly kind: SegmentBreakKind;
+	readonly graphemeWidths: readonly number[] | null;
+}
+
+/** One laid-out line with segment/grapheme cursor bounds. */
+export interface LayoutLine {
+	readonly text: string;
+	readonly width: number;
+	readonly startSegment: number;
+	readonly startGrapheme: number;
+	readonly endSegment: number;
+	readonly endGrapheme: number;
+}
+
+/** Positioned grapheme box for hit testing or custom renderers. */
+export interface CharPosition {
+	readonly x: number;
+	readonly y: number;
+	readonly width: number;
+	readonly height: number;
+	readonly line: number;
+}
+
+/** Result emitted by `reactiveLayout().lineBreaks`. */
+export interface LineBreaksResult {
+	readonly lines: readonly LayoutLine[];
+	readonly lineCount: number;
+}
+
+/** Cursor into a prepared segment array. */
+export interface LayoutCursor {
+	readonly segmentIndex: number;
+	readonly graphemeIndex: number;
+}
+
+/** Pure helper result for one `layoutNextLine` step. */
+export interface LayoutNextLineResult {
+	readonly text: string;
+	readonly width: number;
+	readonly start: LayoutCursor;
+	readonly end: LayoutCursor;
+}
+
+/** Horizontal interval used by obstacle carving. */
+export interface Interval {
+	readonly left: number;
+	readonly right: number;
+}
+
+export const TEXT_SEGMENTS_MEASUREMENT_KIND = "text-segments";
+export const BLOCKS_MEASUREMENT_KIND = "blocks";
+/** Measurement kind for standalone readiness facts. */
+export const READINESS_MEASUREMENT_KIND = "readiness";
+/** Measurement kind for standalone image-size facts. */
+export const IMAGE_SIZE_MEASUREMENT_KIND = "image-size";
+/** Measurement kind for standalone SVG-bounds facts. */
+export const SVG_BOUNDS_MEASUREMENT_KIND = "svg-bounds";
+
+export interface TextSegmentsMeasurement {
+	readonly segments: readonly PreparedSegment[];
+	readonly hyphenWidth?: number;
+}
+
+export interface BlocksMeasurement {
+	readonly blocks: readonly MeasuredBlock[];
+}
+
+export interface MeasurementResult<T = unknown> {
+	readonly kind: "ok";
+	readonly targetId: string;
+	readonly measurementKind: string;
+	readonly value: T;
+	readonly source?: string;
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface MeasurementIssue extends DataIssue {
+	readonly subjectId: string;
+	readonly measurementKind: string;
+}
+
+export type MeasurementFact<T = unknown> = MeasurementResult<T> | MeasurementIssue;
+
+export type Measurements = readonly MeasurementFact[];
+
+export interface MergeMeasurementsOptions {
+	readonly graph: Graph;
+	readonly sources: readonly Node<Measurements>[];
+	readonly name?: string;
+}
+
+export interface TextMeasurementProviderOptions {
+	readonly graph: Graph;
+	readonly text: Node<string>;
+	readonly font: Node<string>;
+	readonly adapter: Node<MeasurementAdapter>;
+	readonly segmentAdapter?: Node<SegmentAdapter>;
+	readonly targetId?: string;
+	readonly source?: string;
+	readonly name?: string;
+}
+
+export interface InjectedTextMeasurementsOptions
+	extends Omit<TextMeasurementProviderOptions, "adapter"> {
+	readonly measure: MeasureFn;
+	readonly cache?: boolean;
+}
+
+export interface PrecomputedTextMeasurementsOptions
+	extends Omit<TextMeasurementProviderOptions, "adapter">,
+		PrecomputedMeasureAdapterOptions {}
+
+export interface CellTextMeasurementsOptions
+	extends Omit<TextMeasurementProviderOptions, "adapter">,
+		CellMeasureAdapterOptions {}
+
+export interface CapabilityTextMeasurementsOptions
+	extends Omit<TextMeasurementProviderOptions, "adapter"> {
+	readonly capability: Node<TextMeasureCapability>;
+}
+
+export interface MeasurementReadiness {
+	readonly ready: boolean;
+	readonly code?: string;
+	readonly message?: string;
+	readonly source?: string;
+	readonly details?: unknown;
+	readonly metadata?: Record<string, unknown>;
+}
+
+/** Options for projecting readiness into graph-visible measurement facts. */
+export interface ReadinessMeasurementsOptions {
+	readonly graph: Graph;
+	readonly readiness: Node<MeasurementReadiness>;
+	readonly targetId?: string;
+	readonly measurementKind?: string;
+	readonly source?: string;
+	readonly name?: string;
+}
+
+export interface ReadinessTextMeasurementsOptions extends TextMeasurementProviderOptions {
+	readonly readiness: Node<MeasurementReadiness>;
+}
+
+/** Minimal caller-owned lookup for explicit image sizes. */
+export interface ImageSizeLookup {
+	get(src: string): Size | undefined;
+}
+
+/** One image-size fact target for `imageSizeMeasurements`. */
+export interface ImageSizeMeasurementTarget {
+	readonly id?: string;
+	readonly src: string;
+	readonly metadata?: Record<string, unknown>;
+}
+
+/** Options for projecting image-size facts from a caller-owned synchronous measurer. */
+export interface ImageSizeMeasurementsOptions {
+	readonly graph: Graph;
+	readonly images: Node<readonly ImageSizeMeasurementTarget[]>;
+	readonly measurer: Node<ImageMeasurer>;
+	readonly measurementKind?: string;
+	readonly source?: string;
+	readonly name?: string;
+}
+
+/** One SVG-bounds fact target for `svgBoundsMeasurements`. */
+export interface SvgBoundsMeasurementTarget {
+	readonly id?: string;
+	readonly svg: string;
+	readonly metadata?: Record<string, unknown>;
+}
+
+/** Options for projecting SVG bounds from a caller-owned synchronous measurer. */
+export interface SvgBoundsMeasurementsOptions {
+	readonly graph: Graph;
+	readonly svgs: Node<readonly SvgBoundsMeasurementTarget[]>;
+	readonly measurer: Node<SvgMeasurer>;
+	readonly measurementKind?: string;
+	readonly source?: string;
+	readonly name?: string;
+}
+
+export interface BlockMeasurementProviderOptions {
+	readonly graph: Graph;
+	readonly blocks: Node<readonly ContentBlock[]>;
+	readonly maxWidth: Node<number>;
+	readonly adapters: Node<BlockAdapters>;
+	readonly segmentAdapter?: Node<SegmentAdapter>;
+	readonly font?: Node<string>;
+	readonly lineHeight?: Node<number>;
+	readonly targetId?: string;
+	readonly source?: string;
+	readonly name?: string;
+}
+
+export interface BlockAdaptersProviderOptions {
+	readonly graph: Graph;
+	readonly text?: Node<MeasurementAdapter>;
+	readonly svg?: Node<SvgMeasurer>;
+	readonly image?: Node<ImageMeasurer>;
+	readonly name?: string;
+}
+
+/**
+ * Graph-visible bundle returned by `reactiveLayout`.
+ *
+ * The setters are state-node sugar over real graph inputs; the output nodes are ordinary
+ * inspectable nodes visible through `graph.describe()`.
+ */
+export interface ReactiveLayoutBundle {
+	readonly graph: Graph;
+	readonly input: {
+		readonly lineHeight: Node<number>;
+		readonly maxWidth: Node<number>;
+		readonly measurements: Node<Measurements>;
+	};
+	setLineHeight(lineHeight: number): void;
+	setMaxWidth(maxWidth: number): void;
+	readonly segments: Node<readonly PreparedSegment[]>;
+	readonly lineBreaks: Node<LineBreaksResult>;
+	readonly height: Node<number>;
+	readonly charPositions: Node<readonly CharPosition[]>;
+}
+
+/** Optional context shared by pure line-breaking helpers. */
+export interface LayoutNextLineContext {
+	readonly adapter?: MeasurementAdapter;
+	readonly font?: string;
+	readonly cache?: Map<string, Map<string, number>>;
+	readonly hyphenWidth?: number;
+	readonly segmentAdapter?: SegmentAdapter;
+}
+
+/** Cache accounting object callers can pass into `analyzeAndMeasure`. */
+export interface SegmentMeasureStats {
+	hits: number;
+	misses: number;
+}
+
+/** Options for the single-column reactive text layout bundle. */
+export interface ReactiveLayoutOptions {
+	readonly measurements: Node<Measurements>;
+	readonly graph: Graph;
+	readonly segmentAdapter?: SegmentAdapter;
+	readonly targetId?: string;
+	readonly name?: string;
+	readonly lineHeight?: number | Node<number>;
+	readonly maxWidth?: number | Node<number>;
+}
+
+/** Host text measurement function accepted by `InjectedMeasureAdapter`. */
+export type MeasureFn = (text: string, font: string) => number | { readonly width: number };
+
+/** Options for caller-injected synchronous measurement. */
+export interface InjectedMeasureAdapterOptions {
+	readonly cache?: boolean;
+}
+
+/** Options for deterministic precomputed text metrics. */
+export interface PrecomputedMeasureAdapterOptions {
+	readonly metrics: ReadonlyMap<string, number> | Record<string, number>;
+	readonly fallback?: "per-char" | "error";
+	readonly cellWidth?: number;
+}
+
+/** Fixed-cell measurement options for terminal/snapshot rendering. */
+export interface CellMeasureAdapterOptions {
+	readonly cellWidth?: number;
+	readonly wideCellWidth?: number;
+	readonly tabCells?: number;
+}
+
+/** Width/height pair in CSS-like pixels. */
+export interface Size {
+	readonly width: number;
+	readonly height: number;
+}
+
+/** Synchronous SVG measurement seam; no DOM parser is provided by the core. */
+export interface SvgMeasurer {
+	measureSvg(svg: string): Size;
+}
+
+/** Synchronous image measurement seam; no loading/fetching is provided by the core. */
+export interface ImageMeasurer {
+	measureImage(src: string): Size;
+}
+
+/** Optional per-kind block measurement adapters. */
+export interface BlockAdapters {
+	readonly text?: MeasurementAdapter;
+	readonly svg?: SvgMeasurer;
+	readonly image?: ImageMeasurer;
+}
+
+/** Shared spacing/id fields for block layout inputs. */
+export interface BaseContentBlock {
+	readonly id?: string;
+	readonly marginTop?: number;
+	readonly marginBottom?: number;
+}
+
+/** Text block input for `measureBlock` and `reactiveBlockLayout`. */
+export interface TextContentBlock extends BaseContentBlock {
+	readonly kind: "text";
+	readonly text: string;
+	readonly font?: string;
+	readonly lineHeight?: number;
+	readonly maxWidth?: number;
+}
+
+/** Image block input with explicit dimensions or an injected `ImageMeasurer`. */
+export interface ImageContentBlock extends BaseContentBlock {
+	readonly kind: "image";
+	readonly src: string;
+	readonly width?: number;
+	readonly height?: number;
+	readonly maxWidth?: number;
+}
+
+/** SVG block input with explicit dimensions or an injected `SvgMeasurer`. */
+export interface SvgContentBlock extends BaseContentBlock {
+	readonly kind: "svg";
+	readonly svg: string;
+	readonly width?: number;
+	readonly height?: number;
+	readonly maxWidth?: number;
+}
+
+/** Heterogeneous block-layout input. */
+export type ContentBlock = TextContentBlock | ImageContentBlock | SvgContentBlock;
+
+/** Measured block produced by `measureBlock` or `measureBlocks`. */
+export interface MeasuredBlock {
+	readonly block: ContentBlock;
+	readonly kind: ContentBlock["kind"];
+	readonly id?: string;
+	readonly width: number;
+	readonly height: number;
+	readonly marginTop: number;
+	readonly marginBottom: number;
+	readonly segments?: readonly PreparedSegment[];
+	readonly lineBreaks?: LineBreaksResult;
+	readonly charPositions?: readonly CharPosition[];
+}
+
+/** Block with vertical-flow coordinates. */
+export interface PositionedBlock extends MeasuredBlock {
+	readonly x: number;
+	readonly y: number;
+}
+
+/** Options for pure block measurement helpers. */
+export interface MeasureBlockOptions {
+	readonly adapter?: MeasurementAdapter;
+	readonly adapters?: BlockAdapters;
+	readonly font?: string;
+	readonly lineHeight?: number;
+	readonly maxWidth?: number;
+	readonly cache?: Map<string, Map<string, number>>;
+	readonly hyphenWidth?: number;
+	readonly segmentAdapter?: SegmentAdapter;
+}
+
+/** Options for the graph-visible block layout bundle. */
+export interface ReactiveBlockLayoutOptions {
+	readonly measurements: Node<Measurements>;
+	readonly graph: Graph;
+	readonly targetId?: string;
+	readonly name?: string;
+	readonly gap?: number | Node<number>;
+}
+
+/** Graph-visible vertical block layout bundle. */
+export interface ReactiveBlockLayoutBundle {
+	readonly graph: Graph;
+	readonly input: {
+		readonly gap: Node<number>;
+		readonly measurements: Node<Measurements>;
+	};
+	setGap(gap: number): void;
+	readonly measuredBlocks: Node<readonly MeasuredBlock[]>;
+	readonly blockFlow: Node<readonly PositionedBlock[]>;
+	readonly totalHeight: Node<number>;
+}
+
+/** Circular obstacle for flow layout slot carving. */
+export interface CircleObstacle {
+	readonly kind: "circle";
+	readonly cx: number;
+	readonly cy: number;
+	readonly r: number;
+}
+
+/** Rectangular obstacle for flow layout slot carving. */
+export interface RectObstacle {
+	readonly kind: "rect";
+	readonly x: number;
+	readonly y: number;
+	readonly width: number;
+	readonly height: number;
+}
+
+/** Obstacle shape accepted by flow layout. */
+export type Obstacle = CircleObstacle | RectObstacle;
+
+/** Flow container geometry. */
+export interface FlowContainer {
+	readonly width: number;
+	readonly height: number;
+	readonly paddingX?: number;
+	readonly paddingY?: number;
+}
+
+/** Optional column geometry for flow layout. */
+export interface FlowColumns {
+	readonly count?: number;
+	readonly gap?: number;
+}
+
+/** Positioned line emitted by `computeFlowLines` / `reactiveFlowLayout`. */
+export interface PositionedLine extends LayoutLine {
+	readonly x: number;
+	readonly y: number;
+	readonly slotWidth: number;
+	readonly columnIndex: number;
+}
+
+/** Flow layout result plus the continuation cursor. */
+export interface FlowLinesResult {
+	readonly lines: readonly PositionedLine[];
+	readonly cursor: LayoutCursor;
+	readonly done: boolean;
+}
+
+/** Options for pure flow layout computation. */
+export interface ComputeFlowLinesOptions {
+	readonly container: FlowContainer;
+	readonly columns?: FlowColumns;
+	readonly obstacles?: readonly Obstacle[];
+	readonly lineHeight: number;
+	readonly minSlotWidth?: number;
+	readonly hyphenWidth?: number;
+	readonly segmentAdapter?: SegmentAdapter;
+}
+
+/** Options for the graph-visible flow layout bundle. */
+export interface ReactiveFlowLayoutOptions {
+	readonly measurements: Node<Measurements>;
+	readonly graph: Graph;
+	readonly segmentAdapter?: SegmentAdapter;
+	readonly targetId?: string;
+	readonly name?: string;
+	readonly lineHeight?: number | Node<number>;
+	readonly container?: FlowContainer | Node<FlowContainer>;
+	readonly columns?: FlowColumns | Node<FlowColumns>;
+	readonly obstacles?: readonly Obstacle[] | Node<readonly Obstacle[]>;
+	readonly minSlotWidth?: number;
+}
+
+/** Graph-visible multi-column flow layout bundle. */
+export interface ReactiveFlowLayoutBundle {
+	readonly graph: Graph;
+	readonly input: {
+		readonly lineHeight: Node<number>;
+		readonly container: Node<FlowContainer>;
+		readonly columns: Node<FlowColumns>;
+		readonly obstacles: Node<readonly Obstacle[]>;
+		readonly measurements: Node<Measurements>;
+	};
+	setLineHeight(lineHeight: number): void;
+	setContainer(container: FlowContainer): void;
+	setColumns(columns: FlowColumns): void;
+	setObstacles(obstacles: readonly Obstacle[]): void;
+	readonly segments: Node<readonly PreparedSegment[]>;
+	readonly flowLines: Node<FlowLinesResult>;
+}
diff --git a/packages/ts/src/solutions/reactive-layout/utils.ts b/packages/ts/src/solutions/reactive-layout/utils.ts
new file mode 100644
index 00000000..43c4d8a5
--- /dev/null
+++ b/packages/ts/src/solutions/reactive-layout/utils.ts
@@ -0,0 +1,44 @@
+import type { Ctx } from "../../ctx/types.js";
+import { errorPayload } from "../../protocol/messages.js";
+import type { MeasureBlockOptions, MeasurementAdapter, Size } from "./types.js";
+
+export function nonNegativeFinite(value: number, fallback: number): number {
+	return Number.isFinite(value) ? Math.max(0, value) : fallback;
+}
+
+export function finiteNumber(value: number, fallback: number): number {
+	return Number.isFinite(value) ? value : fallback;
+}
+
+export function emitLayoutError(ctx: Ctx, error: unknown, fallback: string): void {
+	ctx.down([["ERROR", errorPayload(error, fallback)]]);
+}
+
+export function positiveFinite(value: number, fallback: number): number {
+	return Number.isFinite(value) && value > 0 ? value : fallback;
+}
+
+export function clampDimension(value: number | undefined): number {
+	return nonNegativeFinite(value ?? 0, 0);
+}
+
+export function fitSize(size: Size, maxWidth: number): Size {
+	const width = nonNegativeFinite(size.width, 0);
+	const height = nonNegativeFinite(size.height, 0);
+	if (width === 0 || maxWidth <= 0 || width <= maxWidth) return { width, height };
+	const scale = maxWidth / width;
+	return { width: maxWidth, height: height * scale };
+}
+
+export function blockMaxWidth(blockMaxWidth: number | undefined, maxWidth: number): number {
+	const own = blockMaxWidth === undefined ? maxWidth : nonNegativeFinite(blockMaxWidth, maxWidth);
+	if (maxWidth <= 0) return own;
+	if (own <= 0) return maxWidth;
+	return Math.min(own, maxWidth);
+}
+
+export function resolveTextAdapter(opts: MeasureBlockOptions): MeasurementAdapter {
+	const adapter = opts.adapters?.text ?? opts.adapter;
+	if (!adapter) throw new Error("Text blocks require a MeasurementAdapter");
+	return adapter;
+}
diff --git a/packages/ts/src/solutions/work-item/actions-application.ts b/packages/ts/src/solutions/work-item/actions-application.ts
new file mode 100644
index 00000000..7435847e
--- /dev/null
+++ b/packages/ts/src/solutions/work-item/actions-application.ts
@@ -0,0 +1,1098 @@
+import { type Ctx, depBatch } from "../../ctx/types.js";
+import type { Graph } from "../../graph/graph.js";
+import type { SourceRef } from "../../orchestration/agent-runtime.js";
+import type {
+	WorkItemDomainActionAdmission,
+	WorkItemDomainActionProposal,
+} from "../../orchestration/work-item-runtime.js";
+import {
+	auditRecord,
+	dataIssue,
+	isRecord,
+	numberMetadata,
+	project,
+	ref,
+	stringMetadata,
+	uniqueSourceRefs,
+} from "./actions-shared.js";
+import type {
+	ApplicationFact,
+	ApplicationState,
+	WorkItemDomainActionApplication,
+	WorkItemDomainActionApplicationBundle,
+	WorkItemDomainActionApplicationOptions,
+	WorkItemDomainActionApplyPolicy,
+	WorkItemDomainActionStatus,
+	WorkItemPatchActionPayload,
+	WorkItemSpawnActionPayload,
+} from "./actions-types.js";
+import { patchFieldKeys } from "./actions-types.js";
+import {
+	type AcceptanceCriterion,
+	type VerificationPlan,
+	validateAcceptanceCriteria,
+	validateVerificationPlan,
+	validateWorkItemDraft,
+	type WorkItemAuthoringFact,
+	type WorkItemCreated,
+	type WorkItemPatch,
+	type WorkItemProjection,
+} from "./scheduling.js";
+
+export function workItemDomainActionApplicationProjector<TInput = unknown>(
+	graph: Graph,
+	opts: WorkItemDomainActionApplicationOptions<TInput>,
+): WorkItemDomainActionApplicationBundle<TInput> {
+	const name = opts.name ?? "workItemDomainActionApplication";
+	const deps =
+		opts.applyPolicies === undefined
+			? [opts.proposals, opts.admissions, opts.workItems]
+			: [opts.proposals, opts.admissions, opts.workItems, opts.applyPolicies];
+	const runtime = graph.node<ApplicationFact<TInput>>(
+		deps,
+		(ctx) => {
+			const state = ctx.state.get<ApplicationState<TInput>>() ?? {
+				proposals: new Map(),
+				admissions: new Map(),
+				workItems: new Map(),
+				policies: new Map(),
+				appliedAdmissions: new Set(),
+				emittedFactIds: new Set(),
+				issueKeys: new Set(),
+				statusSeq: 0,
+				auditSeq: 0,
+			};
+			for (const raw of depBatch(ctx, 0) ?? []) {
+				const proposal = raw as WorkItemDomainActionProposal;
+				if (state.proposals.has(proposal.proposalId)) {
+					emitApplicationIssue(
+						ctx,
+						state,
+						`duplicate-proposal:${proposal.proposalId}`,
+						"duplicate-suppressed",
+						`Duplicate WorkItem domain action proposal '${proposal.proposalId}' suppressed`,
+						proposal.workItemId,
+						proposal.sourceRefs,
+					);
+					continue;
+				}
+				state.proposals.set(proposal.proposalId, proposal);
+			}
+			for (const raw of depBatch(ctx, 2) ?? []) {
+				const workItem = raw as WorkItemProjection<TInput>;
+				state.workItems.set(workItem.workItemId, workItem);
+			}
+			if (opts.applyPolicies !== undefined) {
+				for (const raw of depBatch(ctx, 3) ?? []) {
+					const policy = raw as WorkItemDomainActionApplyPolicy;
+					state.policies.set(policy.policyId, policy);
+				}
+			}
+			for (const raw of depBatch(ctx, 1) ?? []) {
+				const admission = raw as WorkItemDomainActionAdmission;
+				if (state.admissions.has(admission.admissionId)) {
+					emitApplicationIssue(
+						ctx,
+						state,
+						`duplicate-admission:${admission.admissionId}`,
+						"duplicate-suppressed",
+						`Duplicate WorkItem domain action admission '${admission.admissionId}' suppressed`,
+						admission.workItemId,
+						admissionRefs(admission),
+					);
+					continue;
+				}
+				state.admissions.set(admission.admissionId, admission);
+			}
+			for (const admission of state.admissions.values()) applyAdmission(ctx, state, admission);
+			ctx.state.set(state);
+		},
+		{
+			name: `${name}/runtime`,
+			factory: "workItemDomainActionApplicationProjector",
+			partial: true,
+			completeWhenDepsComplete: false,
+			errorWhenDepsError: false,
+		},
+	);
+	return {
+		authoringFacts: project(
+			graph,
+			runtime,
+			`${name}/authoringFacts`,
+			"workItemDomainActionAuthoringFacts",
+			(fact) => (fact.kind === "authoring-fact" ? fact.value : undefined),
+		),
+		applications: project(
+			graph,
+			runtime,
+			`${name}/applications`,
+			"workItemDomainActionApplications",
+			(fact) => (fact.kind === "application" ? fact.value : undefined),
+		),
+		status: project(graph, runtime, `${name}/status`, "workItemDomainActionStatus", (fact) =>
+			fact.kind === "status" ? fact.value : undefined,
+		),
+		issues: project(graph, runtime, `${name}/issues`, "workItemDomainActionIssues", (fact) =>
+			fact.kind === "issue" ? fact.value : undefined,
+		),
+		audit: project(graph, runtime, `${name}/audit`, "workItemDomainActionAudit", (fact) =>
+			fact.kind === "audit" ? fact.value : undefined,
+		),
+	};
+}
+
+function applyAdmission<T>(
+	ctx: Ctx,
+	state: ApplicationState<T>,
+	admission: WorkItemDomainActionAdmission,
+): void {
+	if (state.appliedAdmissions.has(admission.admissionId)) return;
+	const proposal = state.proposals.get(admission.proposalId);
+	if (proposal === undefined) {
+		emitApplicationIssue(
+			ctx,
+			state,
+			`missing-proposal:${admission.admissionId}:${admission.proposalId}`,
+			"dangling-ref",
+			`Admission '${admission.admissionId}' cannot apply without proposal '${admission.proposalId}'`,
+			admission.workItemId,
+			admissionRefs(admission),
+		);
+		return;
+	}
+	if (admission.state !== "admitted") {
+		state.appliedAdmissions.add(admission.admissionId);
+		emitApplication(ctx, state, admission, proposal, admission.state, []);
+		return;
+	}
+	const mismatch = admissionProposalMismatch(admission, proposal);
+	if (mismatch !== undefined) {
+		state.appliedAdmissions.add(admission.admissionId);
+		emitApplicationIssue(
+			ctx,
+			state,
+			`admission-proposal-mismatch:${admission.admissionId}:${mismatch.field}`,
+			"dangling-ref",
+			mismatch.message,
+			admission.workItemId,
+			admissionRefs(admission, proposal),
+			{
+				field: mismatch.field,
+				admissionValue: mismatch.admissionValue,
+				proposalValue: mismatch.proposalValue,
+			},
+		);
+		emitApplication(ctx, state, admission, proposal, "rejected", [], {
+			code: "dangling-ref",
+			message: mismatch.message,
+		});
+		return;
+	}
+	const workItem = state.workItems.get(admission.workItemId);
+	if (workItem === undefined) {
+		emitApplicationIssue(
+			ctx,
+			state,
+			`missing-work-item:${admission.admissionId}:${admission.workItemId}`,
+			"dangling-ref",
+			`Admission '${admission.admissionId}' references unknown WorkItem '${admission.workItemId}'`,
+			admission.workItemId,
+			admissionRefs(admission, proposal),
+		);
+		return;
+	}
+	const metadataConflict = conflictingApplicationMetadata(proposal, admission);
+	if (metadataConflict !== undefined) {
+		state.appliedAdmissions.add(admission.admissionId);
+		emitApplicationIssue(
+			ctx,
+			state,
+			`metadata-conflict:${admission.admissionId}:${metadataConflict.field}`,
+			metadataConflict.code,
+			metadataConflict.message,
+			admission.workItemId,
+			admissionRefs(admission, proposal),
+			{
+				field: metadataConflict.field,
+				admissionValue: metadataConflict.admissionValue,
+				proposalValue: metadataConflict.proposalValue,
+			},
+		);
+		emitApplication(ctx, state, admission, proposal, "rejected", [], {
+			code: metadataConflict.code,
+			message: metadataConflict.message,
+		});
+		return;
+	}
+	const stale = staleRevision(proposal, admission, workItem);
+	if (stale !== undefined) {
+		state.appliedAdmissions.add(admission.admissionId);
+		emitApplicationIssue(
+			ctx,
+			state,
+			`stale:${admission.admissionId}:${stale.kind}:${stale.expected}:${stale.current}`,
+			stale.kind,
+			`Admission '${admission.admissionId}' targets stale WorkItem revision`,
+			admission.workItemId,
+			admissionRefs(admission, proposal),
+			{ expected: stale.expected, current: stale.current },
+		);
+		emitApplication(ctx, state, admission, proposal, "rejected", [], {
+			code: stale.kind,
+			message: "Stale WorkItem revision",
+		});
+		return;
+	}
+	const policyResult = selectApplyPolicy(state, proposal, admission);
+	if (typeof policyResult === "string") {
+		emitApplicationIssue(
+			ctx,
+			state,
+			`policy:${admission.admissionId}:${policyResult}`,
+			policyResult,
+			applyPolicyMessage(policyResult, proposal, admission),
+			admission.workItemId,
+			admissionRefs(admission, proposal),
+		);
+		return;
+	}
+	const output = lowerAction(ctx, state, workItem, proposal, admission, policyResult);
+	if (output === undefined) {
+		state.appliedAdmissions.add(admission.admissionId);
+		emitApplication(ctx, state, admission, proposal, "rejected", [], {
+			code: "invalid-action",
+			message: "WorkItem domain action application rejected; see emitted issues",
+			policyId: policyResult.policyId,
+		});
+		return;
+	}
+	const duplicateFactId = firstDuplicateFactId(state, output.facts);
+	if (duplicateFactId !== undefined) {
+		state.appliedAdmissions.add(admission.admissionId);
+		emitApplicationIssue(
+			ctx,
+			state,
+			`duplicate-authoring-fact:${admission.admissionId}:${duplicateFactId}`,
+			"duplicate-suppressed",
+			`WorkItem domain action application '${admission.admissionId}' would duplicate authoring fact '${duplicateFactId}'`,
+			admission.workItemId,
+			admissionRefs(admission, proposal, policyResult),
+			{ eventId: duplicateFactId },
+		);
+		emitApplication(ctx, state, admission, proposal, "duplicate", [], {
+			code: "duplicate-suppressed",
+			message: "Duplicate WorkItem authoring fact suppressed atomically",
+			policyId: policyResult.policyId,
+		});
+		return;
+	}
+	state.appliedAdmissions.add(admission.admissionId);
+	for (const fact of output.facts) claimFactId(state, fact.eventId);
+	for (const fact of output.facts) emitApplicationFact(ctx, "authoring-fact", fact);
+	emitApplication(ctx, state, admission, proposal, output.state, output.facts, {
+		code: output.code,
+		message: output.message,
+		policyId: policyResult.policyId,
+	});
+}
+
+function lowerAction<T>(
+	ctx: Ctx,
+	state: ApplicationState<T>,
+	workItem: WorkItemProjection<T>,
+	proposal: WorkItemDomainActionProposal,
+	admission: WorkItemDomainActionAdmission,
+	policy: WorkItemDomainActionApplyPolicy,
+):
+	| {
+			readonly state: WorkItemDomainActionApplication["state"];
+			readonly facts: readonly WorkItemAuthoringFact<T>[];
+			readonly code?: string;
+			readonly message?: string;
+	  }
+	| undefined {
+	if (!policyAllowsAction(policy, proposal.actionKind)) {
+		emitApplicationIssue(
+			ctx,
+			state,
+			`policy-action:${admission.admissionId}:${policy.policyId}:${proposal.actionKind}`,
+			"policy-mismatch",
+			`Apply policy '${policy.policyId}' does not allow actionKind '${proposal.actionKind}'`,
+			proposal.workItemId,
+			admissionRefs(admission, proposal, policy),
+		);
+		return { state: "policy-rejected", facts: [], code: "policy-mismatch" };
+	}
+	if (proposal.actionKind === "patch") {
+		const lowered = lowerPatchAction(ctx, state, workItem, proposal, admission, policy);
+		if (lowered === undefined) return undefined;
+		return { state: "applied", facts: lowered };
+	}
+	if (proposal.actionKind === "mark-verified" || proposal.actionKind === "require-review") {
+		return {
+			state: "proposal-only",
+			facts: [],
+			code: "domain-fact-unimplemented",
+			message: `Action '${proposal.actionKind}' recorded as visible application status only; no WorkItem domain mutation fact was emitted`,
+		};
+	}
+	if (proposal.actionKind === "spawn-proposed" || proposal.actionKind === "spawn-child") {
+		return lowerSpawnAction(ctx, state, proposal, admission, policy);
+	}
+	emitApplicationIssue(
+		ctx,
+		state,
+		`unsupported-action:${admission.admissionId}:${proposal.actionKind}`,
+		"unsupported-effect-kind",
+		`Unsupported WorkItem domain actionKind '${proposal.actionKind}'`,
+		proposal.workItemId,
+		admissionRefs(admission, proposal, policy),
+	);
+	return { state: "rejected", facts: [], code: "unsupported-effect-kind" };
+}
+
+function lowerPatchAction<T>(
+	ctx: Ctx,
+	state: ApplicationState<T>,
+	workItem: WorkItemProjection<T>,
+	proposal: WorkItemDomainActionProposal,
+	admission: WorkItemDomainActionAdmission,
+	policy: WorkItemDomainActionApplyPolicy,
+): readonly WorkItemAuthoringFact<T>[] | undefined {
+	const payload = normalizePatchPayload<T>(proposal.payload);
+	if (typeof payload === "string") {
+		emitApplicationIssue(
+			ctx,
+			state,
+			`invalid-patch:${admission.admissionId}`,
+			"invalid-patch",
+			payload,
+			proposal.workItemId,
+			admissionRefs(admission, proposal, policy),
+		);
+		return undefined;
+	}
+	const splitPayload = splitDedicatedPatchFields(payload, workItem);
+	const facts: WorkItemAuthoringFact<T>[] = [];
+	if (splitPayload.patch !== undefined) {
+		const invalid = invalidPatchKeys(splitPayload.patch, policy);
+		if (invalid.length > 0) {
+			emitApplicationIssue(
+				ctx,
+				state,
+				`invalid-patch-fields:${admission.admissionId}:${invalid.join(",")}`,
+				"invalid-patch",
+				`Patch action uses unsupported fields: ${invalid.join(", ")}`,
+				proposal.workItemId,
+				admissionRefs(admission, proposal, policy),
+				{ invalidFields: invalid },
+			);
+			return undefined;
+		}
+		facts.push({
+			kind: "work-item-patched",
+			eventId: splitPayload.eventId ?? `${admission.admissionId}:work-item-patched`,
+			workItemId: workItem.workItemId,
+			patch: splitPayload.patch,
+			executionRelevantFields:
+				splitPayload.executionRelevantFields ?? policy.patch?.executionRelevantFields,
+			authorId: splitPayload.authorId,
+			sourceRefs: actionSourceRefs(admission, proposal, policy),
+			metadata: { ...(splitPayload.metadata ?? {}), actionKind: proposal.actionKind },
+		});
+	}
+	if (splitPayload.acceptanceCriteria !== undefined) {
+		if (!allowsAcceptanceCriteria(policy)) {
+			emitApplicationIssue(
+				ctx,
+				state,
+				`ac-policy:${admission.admissionId}`,
+				"policy-mismatch",
+				`Apply policy '${policy.policyId}' does not allow acceptance criteria changes`,
+				proposal.workItemId,
+				admissionRefs(admission, proposal, policy),
+			);
+			return undefined;
+		}
+		const issues = validateAcceptanceCriteria(splitPayload.acceptanceCriteria, {
+			workItemId: workItem.workItemId,
+		});
+		if (issues.length > 0) {
+			for (const item of issues) emitApplicationFact(ctx, "issue", item);
+			emitApplicationStatus(ctx, state, {
+				state: "rejected",
+				code: issues[0]?.code,
+				message: issues[0]?.message,
+				workItemId: workItem.workItemId,
+				proposalId: proposal.proposalId,
+				admissionId: admission.admissionId,
+				actionKind: proposal.actionKind,
+				sourceRefs: admissionRefs(admission, proposal, policy),
+			});
+			return undefined;
+		}
+		facts.push({
+			kind: "acceptance-criteria-changed",
+			eventId: `${admission.admissionId}:acceptance-criteria-changed`,
+			workItemId: workItem.workItemId,
+			acceptanceCriteria: splitPayload.acceptanceCriteria,
+			authorId: splitPayload.authorId,
+			sourceRefs: actionSourceRefs(admission, proposal, policy),
+			metadata: { ...(splitPayload.metadata ?? {}), actionKind: proposal.actionKind },
+		});
+	}
+	if (splitPayload.verificationPlan !== undefined) {
+		if (!allowsVerificationPlan(policy)) {
+			emitApplicationIssue(
+				ctx,
+				state,
+				`plan-policy:${admission.admissionId}`,
+				"policy-mismatch",
+				`Apply policy '${policy.policyId}' does not allow verification plan changes`,
+				proposal.workItemId,
+				admissionRefs(admission, proposal, policy),
+			);
+			return undefined;
+		}
+		const issues = validateVerificationPlan(
+			splitPayload.verificationPlan,
+			splitPayload.acceptanceCriteria ?? workItem.acceptanceCriteria ?? [],
+			{ workItemId: workItem.workItemId },
+		);
+		if (issues.length > 0) {
+			for (const item of issues) emitApplicationFact(ctx, "issue", item);
+			emitApplicationStatus(ctx, state, {
+				state: "rejected",
+				code: issues[0]?.code,
+				message: issues[0]?.message,
+				workItemId: workItem.workItemId,
+				proposalId: proposal.proposalId,
+				admissionId: admission.admissionId,
+				actionKind: proposal.actionKind,
+				sourceRefs: admissionRefs(admission, proposal, policy),
+			});
+			return undefined;
+		}
+		facts.push({
+			kind: "verification-plan-changed",
+			eventId: `${admission.admissionId}:verification-plan-changed`,
+			workItemId: workItem.workItemId,
+			verificationPlan: splitPayload.verificationPlan,
+			authorId: splitPayload.authorId,
+			sourceRefs: actionSourceRefs(admission, proposal, policy),
+			metadata: { ...(splitPayload.metadata ?? {}), actionKind: proposal.actionKind },
+		});
+	}
+	if (facts.length === 0) {
+		emitApplicationIssue(
+			ctx,
+			state,
+			`empty-patch:${admission.admissionId}`,
+			"invalid-patch",
+			"Patch action payload did not contain patch, acceptanceCriteria, or verificationPlan",
+			proposal.workItemId,
+			admissionRefs(admission, proposal, policy),
+		);
+		return undefined;
+	}
+	return facts;
+}
+
+function lowerSpawnAction<T>(
+	ctx: Ctx,
+	state: ApplicationState<T>,
+	proposal: WorkItemDomainActionProposal,
+	admission: WorkItemDomainActionAdmission,
+	policy: WorkItemDomainActionApplyPolicy,
+): {
+	readonly state: WorkItemDomainActionApplication["state"];
+	readonly facts: readonly WorkItemAuthoringFact<T>[];
+	readonly code?: string;
+	readonly message?: string;
+} {
+	if (policy.spawn?.create !== true) {
+		return {
+			state: "proposal-only",
+			facts: [],
+			message: "Spawn action remains proposal/admission only without explicit create policy",
+		};
+	}
+	const policyIssue = validateSpawnCreatePolicy(policy, proposal);
+	if (policyIssue !== undefined) {
+		emitApplicationIssue(
+			ctx,
+			state,
+			`spawn-create-policy:${admission.admissionId}:${policy.policyId}:${policyIssue.field}`,
+			"policy-mismatch",
+			policyIssue.message,
+			proposal.workItemId,
+			admissionRefs(admission, proposal, policy),
+			{ field: policyIssue.field },
+		);
+		return {
+			state: "policy-rejected",
+			facts: [],
+			code: "policy-mismatch",
+			message: policyIssue.message,
+		};
+	}
+	const payload = normalizeSpawnPayload<T>(proposal.payload);
+	if (typeof payload === "string") {
+		emitApplicationIssue(
+			ctx,
+			state,
+			`invalid-spawn-payload:${admission.admissionId}`,
+			"invalid-patch",
+			payload,
+			proposal.workItemId,
+			admissionRefs(admission, proposal, policy),
+		);
+		return { state: "rejected", facts: [], code: "invalid-patch", message: payload };
+	}
+	const childWorkItemId =
+		payload.childWorkItemId ??
+		payload.workItemId ??
+		policy.spawn.childWorkItemId ??
+		(policy.spawn.childIdPrefix === undefined
+			? undefined
+			: `${policy.spawn.childIdPrefix}${admission.admissionId}`);
+	if (childWorkItemId === undefined || childWorkItemId.trim() === "") {
+		const message = "Spawn create action requires a childWorkItemId or create policy child id";
+		emitApplicationIssue(
+			ctx,
+			state,
+			`missing-spawn-child-id:${admission.admissionId}`,
+			"missing-required-field",
+			message,
+			proposal.workItemId,
+			admissionRefs(admission, proposal, policy),
+		);
+		return { state: "rejected", facts: [], code: "missing-required-field", message };
+	}
+	if (state.workItems.has(childWorkItemId)) {
+		const message = `Spawn create action would duplicate WorkItem '${childWorkItemId}'`;
+		emitApplicationIssue(
+			ctx,
+			state,
+			`duplicate-spawn-child:${admission.admissionId}:${childWorkItemId}`,
+			"duplicate-id",
+			message,
+			childWorkItemId,
+			admissionRefs(admission, proposal, policy),
+		);
+		return { state: "duplicate", facts: [], code: "duplicate-id", message };
+	}
+	if (payload.draft === undefined) {
+		const message = "Spawn create action requires a draft payload";
+		emitApplicationIssue(
+			ctx,
+			state,
+			`missing-spawn-draft:${admission.admissionId}`,
+			"missing-required-field",
+			message,
+			childWorkItemId,
+			admissionRefs(admission, proposal, policy),
+		);
+		return { state: "rejected", facts: [], code: "missing-required-field", message };
+	}
+	const issues = validateWorkItemDraft(payload.draft, { workItemId: childWorkItemId });
+	if (issues.length > 0) {
+		for (const item of issues) emitApplicationFact(ctx, "issue", item);
+		return {
+			state: "rejected",
+			facts: [],
+			code: issues[0]?.code,
+			message: issues[0]?.message,
+		};
+	}
+	const metadata = {
+		...(payload.metadata ?? {}),
+		actionKind: proposal.actionKind,
+		parentWorkItemId: policy.spawn.linkParent === true ? proposal.workItemId : undefined,
+		sourceProposalId: proposal.proposalId,
+		idempotencyKey: payload.idempotencyKey ?? policy.spawn.idempotencyKey,
+	};
+	const created: WorkItemCreated<T> = {
+		kind: "work-item-created",
+		eventId: payload.eventId ?? `${admission.admissionId}:work-item-created:${childWorkItemId}`,
+		workItemId: childWorkItemId,
+		draft: payload.draft,
+		authorId: payload.authorId,
+		sourceRefs: actionSourceRefs(admission, proposal, policy),
+		metadata,
+	};
+	return { state: "applied", facts: [created] };
+}
+
+function validateSpawnCreatePolicy(
+	policy: WorkItemDomainActionApplyPolicy,
+	proposal: WorkItemDomainActionProposal,
+): { readonly field: string; readonly message: string } | undefined {
+	if (policy.spawn?.idempotencyKey === undefined || policy.spawn.idempotencyKey.trim() === "") {
+		return {
+			field: "idempotencyKey",
+			message: `Spawn create policy '${policy.policyId}' requires an idempotencyKey`,
+		};
+	}
+	if (
+		policy.spawn.maxChildrenPerAdmission === undefined ||
+		policy.spawn.maxChildrenPerAdmission < 1
+	) {
+		return {
+			field: "maxChildrenPerAdmission",
+			message: `Spawn create policy '${policy.policyId}' requires maxChildrenPerAdmission >= 1`,
+		};
+	}
+	if (proposal.actionKind === "spawn-child" && policy.spawn.linkParent !== true) {
+		return {
+			field: "linkParent",
+			message: `Spawn child create policy '${policy.policyId}' requires linkParent: true`,
+		};
+	}
+	return undefined;
+}
+
+function normalizeSpawnPayload<T>(payload: unknown): WorkItemSpawnActionPayload<T> | string {
+	if (!isRecord(payload)) return "Spawn action payload must be an object";
+	if ("draft" in payload && payload.draft !== undefined && !isRecord(payload.draft)) {
+		return "Spawn action payload.draft must be an object";
+	}
+	if ("metadata" in payload && payload.metadata !== undefined && !isRecord(payload.metadata)) {
+		return "Spawn action payload.metadata must be an object";
+	}
+	return payload as WorkItemSpawnActionPayload<T>;
+}
+
+function normalizePatchPayload<T>(payload: unknown): WorkItemPatchActionPayload<T> | string {
+	if (!isRecord(payload)) return "Patch action payload must be an object";
+	if (
+		"patch" in payload ||
+		"acceptanceCriteria" in payload ||
+		"verificationPlan" in payload ||
+		"executionRelevantFields" in payload
+	) {
+		if ("patch" in payload && payload.patch !== undefined && !isRecord(payload.patch))
+			return "Patch action payload.patch must be an object";
+		if (
+			"acceptanceCriteria" in payload &&
+			payload.acceptanceCriteria !== undefined &&
+			!Array.isArray(payload.acceptanceCriteria)
+		)
+			return "Patch action payload.acceptanceCriteria must be an array";
+		if (
+			"verificationPlan" in payload &&
+			payload.verificationPlan !== undefined &&
+			!isRecord(payload.verificationPlan)
+		)
+			return "Patch action payload.verificationPlan must be an object";
+		const inlinePatch = inlinePatchFields<T>(payload);
+		const explicitPatch = isRecord(payload.patch) ? (payload.patch as WorkItemPatch<T>) : undefined;
+		const patch =
+			explicitPatch === undefined
+				? inlinePatch
+				: ({ ...inlinePatch, ...explicitPatch } as WorkItemPatch<T>);
+		return {
+			...(payload as unknown as WorkItemPatchActionPayload<T>),
+			patch: Object.keys(patch).length === 0 ? undefined : patch,
+		};
+	}
+	return { patch: payload as WorkItemPatch<T> };
+}
+
+function inlinePatchFields<T>(payload: Record<string, unknown>): WorkItemPatch<T> {
+	const patch: Record<string, unknown> = {};
+	for (const [key, value] of Object.entries(payload)) {
+		if (key === "metadata") continue;
+		if (patchFieldKeys.has(key)) patch[key] = value;
+	}
+	return patch as WorkItemPatch<T>;
+}
+
+function splitDedicatedPatchFields<T>(
+	payload: WorkItemPatchActionPayload<T>,
+	workItem: WorkItemProjection<T>,
+): WorkItemPatchActionPayload<T> {
+	if (!isRecord(payload.patch)) return payload;
+	const patchRecord = payload.patch as Record<string, unknown>;
+	const patch: Record<string, unknown> = {};
+	for (const [key, value] of Object.entries(patchRecord)) {
+		if (key === "acceptanceCriteria" || key === "verificationPlan" || key === "verificationSteps")
+			continue;
+		patch[key] = value;
+	}
+	const acceptanceCriteria =
+		payload.acceptanceCriteria ??
+		(Array.isArray(patchRecord.acceptanceCriteria)
+			? (patchRecord.acceptanceCriteria as readonly AcceptanceCriterion[])
+			: undefined);
+	const verificationPlan =
+		payload.verificationPlan ??
+		(isRecord(patchRecord.verificationPlan)
+			? (patchRecord.verificationPlan as unknown as VerificationPlan<T>)
+			: Array.isArray(patchRecord.verificationSteps)
+				? ({
+						...(workItem.verificationPlan ?? { planId: "default" }),
+						steps: patchRecord.verificationSteps,
+					} as VerificationPlan<T>)
+				: undefined);
+	return {
+		...payload,
+		patch: Object.keys(patch).length === 0 ? undefined : (patch as WorkItemPatch<T>),
+		acceptanceCriteria,
+		verificationPlan,
+	};
+}
+
+function invalidPatchKeys<T>(
+	patch: WorkItemPatch<T>,
+	policy: WorkItemDomainActionApplyPolicy,
+): readonly string[] {
+	const allowed = new Set(policy.patch?.allowedFields ?? Array.from(patchFieldKeys));
+	return Object.keys(patch).filter((key) => !patchFieldKeys.has(key) || !allowed.has(key));
+}
+
+function allowsAcceptanceCriteria(policy: WorkItemDomainActionApplyPolicy): boolean {
+	if (policy.patch?.allowAcceptanceCriteria === false) return false;
+	const allowed = policy.patch?.allowedFields;
+	return (
+		allowed === undefined ||
+		allowed.includes("acceptanceCriteria") ||
+		policy.patch?.allowAcceptanceCriteria === true
+	);
+}
+
+function allowsVerificationPlan(policy: WorkItemDomainActionApplyPolicy): boolean {
+	if (policy.patch?.allowVerificationPlan === false) return false;
+	const allowed = policy.patch?.allowedFields;
+	return (
+		allowed === undefined ||
+		allowed.includes("verificationPlan") ||
+		allowed.includes("verificationSteps") ||
+		policy.patch?.allowVerificationPlan === true
+	);
+}
+
+function selectApplyPolicy<T>(
+	state: ApplicationState<T>,
+	proposal: WorkItemDomainActionProposal,
+	admission: WorkItemDomainActionAdmission,
+):
+	| WorkItemDomainActionApplyPolicy
+	| "missing-policy"
+	| "unknown-work-item-domain-action-apply-policy"
+	| "policy-mismatch" {
+	const explicitId = explicitApplyPolicyId(proposal, admission);
+	if (explicitId !== undefined)
+		return state.policies.get(explicitId) ?? "unknown-work-item-domain-action-apply-policy";
+	const matching = Array.from(state.policies.values()).filter((policy) =>
+		policyAllowsAction(policy, proposal.actionKind),
+	);
+	if (matching.length === 0) return "missing-policy";
+	if (matching.length > 1) return "policy-mismatch";
+	return matching[0];
+}
+
+function explicitApplyPolicyId(
+	proposal: WorkItemDomainActionProposal,
+	admission: WorkItemDomainActionAdmission,
+): string | undefined {
+	const metadataPolicy =
+		stringMetadata(admission.metadata, "applyPolicyId") ??
+		stringMetadata(proposal.metadata, "applyPolicyId");
+	if (metadataPolicy !== undefined) return metadataPolicy;
+	return [...(admission.sourceRefs ?? []), ...(proposal.sourceRefs ?? [])].find(
+		(sourceRef) => sourceRef.kind === "work-item-domain-action-apply-policy",
+	)?.id;
+}
+
+function policyAllowsAction(policy: WorkItemDomainActionApplyPolicy, actionKind: string): boolean {
+	return policy.actionKinds === undefined || policy.actionKinds.includes(actionKind);
+}
+
+function admissionProposalMismatch(
+	admission: WorkItemDomainActionAdmission,
+	proposal: WorkItemDomainActionProposal,
+):
+	| {
+			readonly field: "workItemId" | "actionKind";
+			readonly admissionValue: string;
+			readonly proposalValue: string;
+			readonly message: string;
+	  }
+	| undefined {
+	if (admission.workItemId !== proposal.workItemId)
+		return {
+			field: "workItemId",
+			admissionValue: admission.workItemId,
+			proposalValue: proposal.workItemId,
+			message: `Admission '${admission.admissionId}' workItemId does not match proposal '${proposal.proposalId}'`,
+		};
+	if (admission.actionKind !== proposal.actionKind)
+		return {
+			field: "actionKind",
+			admissionValue: admission.actionKind,
+			proposalValue: proposal.actionKind,
+			message: `Admission '${admission.admissionId}' actionKind does not match proposal '${proposal.proposalId}'`,
+		};
+	return undefined;
+}
+
+function conflictingApplicationMetadata(
+	proposal: WorkItemDomainActionProposal,
+	admission: WorkItemDomainActionAdmission,
+):
+	| {
+			readonly field: "authoringRevision" | "executionInputRevision" | "applyPolicyId";
+			readonly code: "stale-revision" | "stale-execution-input" | "policy-mismatch";
+			readonly proposalValue: number | string;
+			readonly admissionValue: number | string;
+			readonly message: string;
+	  }
+	| undefined {
+	const authoringRevision = conflictingMetadataNumber(proposal, admission, "authoringRevision");
+	if (authoringRevision !== undefined)
+		return {
+			field: "authoringRevision",
+			code: "stale-revision",
+			...authoringRevision,
+			message: `Admission '${admission.admissionId}' carries conflicting authoringRevision metadata`,
+		};
+	const executionInputRevision = conflictingMetadataNumber(
+		proposal,
+		admission,
+		"executionInputRevision",
+	);
+	if (executionInputRevision !== undefined)
+		return {
+			field: "executionInputRevision",
+			code: "stale-execution-input",
+			...executionInputRevision,
+			message: `Admission '${admission.admissionId}' carries conflicting executionInputRevision metadata`,
+		};
+	const applyPolicyId = conflictingMetadataString(proposal, admission, "applyPolicyId");
+	if (applyPolicyId !== undefined)
+		return {
+			field: "applyPolicyId",
+			code: "policy-mismatch",
+			...applyPolicyId,
+			message: `Admission '${admission.admissionId}' carries conflicting applyPolicyId metadata`,
+		};
+	return undefined;
+}
+
+function conflictingMetadataNumber(
+	proposal: WorkItemDomainActionProposal,
+	admission: WorkItemDomainActionAdmission,
+	key: string,
+): { readonly proposalValue: number; readonly admissionValue: number } | undefined {
+	const proposalValue = numberMetadata(proposal.metadata, key);
+	const admissionValue = numberMetadata(admission.metadata, key);
+	if (
+		proposalValue === undefined ||
+		admissionValue === undefined ||
+		proposalValue === admissionValue
+	)
+		return undefined;
+	return { proposalValue, admissionValue };
+}
+
+function conflictingMetadataString(
+	proposal: WorkItemDomainActionProposal,
+	admission: WorkItemDomainActionAdmission,
+	key: string,
+): { readonly proposalValue: string; readonly admissionValue: string } | undefined {
+	const proposalValue = stringMetadata(proposal.metadata, key);
+	const admissionValue = stringMetadata(admission.metadata, key);
+	if (
+		proposalValue === undefined ||
+		admissionValue === undefined ||
+		proposalValue === admissionValue
+	)
+		return undefined;
+	return { proposalValue, admissionValue };
+}
+
+function staleRevision<T>(
+	proposal: WorkItemDomainActionProposal,
+	admission: WorkItemDomainActionAdmission,
+	workItem: WorkItemProjection<T>,
+):
+	| { readonly kind: "stale-revision"; readonly expected: number; readonly current: number }
+	| { readonly kind: "stale-execution-input"; readonly expected: number; readonly current: number }
+	| undefined {
+	const authoringRevision =
+		numberMetadata(admission.metadata, "authoringRevision") ??
+		numberMetadata(proposal.metadata, "authoringRevision");
+	if (authoringRevision !== undefined && authoringRevision !== workItem.authoringRevision)
+		return {
+			kind: "stale-revision",
+			expected: authoringRevision,
+			current: workItem.authoringRevision,
+		};
+	const executionInputRevision =
+		numberMetadata(admission.metadata, "executionInputRevision") ??
+		numberMetadata(proposal.metadata, "executionInputRevision");
+	if (
+		executionInputRevision !== undefined &&
+		executionInputRevision !== workItem.executionInputRevision
+	)
+		return {
+			kind: "stale-execution-input",
+			expected: executionInputRevision,
+			current: workItem.executionInputRevision,
+		};
+	return undefined;
+}
+
+function applyPolicyMessage(
+	code: "missing-policy" | "unknown-work-item-domain-action-apply-policy" | "policy-mismatch",
+	proposal: WorkItemDomainActionProposal,
+	admission: WorkItemDomainActionAdmission,
+): string {
+	if (code === "missing-policy")
+		return `Admitted action '${admission.admissionId}' requires an explicit apply policy`;
+	if (code === "unknown-work-item-domain-action-apply-policy")
+		return `Admitted action '${admission.admissionId}' references a missing apply policy`;
+	return `Admitted action '${proposal.proposalId}' matches multiple apply policies`;
+}
+
+function emitApplication<T>(
+	ctx: Ctx,
+	state: ApplicationState<T>,
+	admission: WorkItemDomainActionAdmission,
+	proposal: WorkItemDomainActionProposal,
+	applicationState: WorkItemDomainActionApplication["state"],
+	facts: readonly WorkItemAuthoringFact<T>[],
+	opts: { readonly code?: string; readonly message?: string; readonly policyId?: string } = {},
+): void {
+	const producedFactIds = facts.map((fact) => fact.eventId);
+	const application: WorkItemDomainActionApplication = {
+		kind: "work-item-domain-action-application",
+		applicationId: `${admission.admissionId}:application`,
+		admissionId: admission.admissionId,
+		proposalId: proposal.proposalId,
+		workItemId: proposal.workItemId,
+		actionKind: proposal.actionKind,
+		state: applicationState,
+		producedFactIds,
+		reason: admission.reason ?? proposal.reason,
+		sourceRefs: admissionRefs(admission, proposal),
+		metadata: { policyId: opts.policyId, code: opts.code },
+	};
+	emitApplicationFact(ctx, "application", application);
+	emitApplicationStatus(ctx, state, {
+		state: applicationState,
+		code: opts.code,
+		message: opts.message,
+		workItemId: proposal.workItemId,
+		proposalId: proposal.proposalId,
+		admissionId: admission.admissionId,
+		actionKind: proposal.actionKind,
+		sourceRefs: application.sourceRefs,
+		metadata: { producedFactIds, policyId: opts.policyId },
+	});
+}
+
+function emitApplicationIssue<T>(
+	ctx: Ctx,
+	state: ApplicationState<T>,
+	key: string,
+	code: string,
+	message: string,
+	workItemId?: string,
+	sourceRefs?: readonly SourceRef[],
+	metadata?: Record<string, unknown>,
+): void {
+	if (state.issueKeys.has(key)) return;
+	state.issueKeys.add(key);
+	const item = dataIssue(code, message, { subjectId: workItemId, refs: sourceRefs, metadata });
+	emitApplicationFact(ctx, "issue", item);
+	emitApplicationStatus(ctx, state, {
+		state: code === "missing-policy" ? "missing-policy" : "rejected",
+		code,
+		message,
+		workItemId,
+		sourceRefs,
+		metadata,
+	});
+}
+
+function emitApplicationStatus<T>(
+	ctx: Ctx,
+	state: ApplicationState<T>,
+	status: Omit<WorkItemDomainActionStatus, "kind" | "statusId">,
+): void {
+	state.statusSeq += 1;
+	const statusFact = {
+		kind: "work-item-domain-action-status",
+		statusId: `work-item-domain-action-application-status:${state.statusSeq}`,
+		...status,
+	} satisfies WorkItemDomainActionStatus;
+	emitApplicationFact(ctx, "status", statusFact);
+	emitApplicationAudit(ctx, state, "work-item-domain-action-application-status", statusFact);
+}
+
+function emitApplicationAudit<T>(
+	ctx: Ctx,
+	state: ApplicationState<T>,
+	kind: string,
+	status: WorkItemDomainActionStatus,
+): void {
+	state.auditSeq += 1;
+	emitApplicationFact(ctx, "audit", auditRecord(kind, state.auditSeq, status));
+}
+
+function emitApplicationFact<T, K extends ApplicationFact<T>["kind"]>(
+	ctx: Ctx,
+	kind: K,
+	value: Extract<ApplicationFact<T>, { kind: K }>["value"],
+): void {
+	ctx.down([["DATA", { kind, value } as ApplicationFact<T>]]);
+}
+
+function firstDuplicateFactId<T>(
+	state: ApplicationState<T>,
+	facts: readonly WorkItemAuthoringFact<T>[],
+): string | undefined {
+	const pending = new Set<string>();
+	for (const fact of facts) {
+		if (state.emittedFactIds.has(fact.eventId) || pending.has(fact.eventId)) return fact.eventId;
+		pending.add(fact.eventId);
+	}
+	return undefined;
+}
+
+function claimFactId<T>(state: ApplicationState<T>, factId: string): boolean {
+	if (state.emittedFactIds.has(factId)) return false;
+	state.emittedFactIds.add(factId);
+	return true;
+}
+
+function admissionRefs(
+	admission: WorkItemDomainActionAdmission,
+	proposal?: WorkItemDomainActionProposal,
+	policy?: WorkItemDomainActionApplyPolicy,
+): readonly SourceRef[] {
+	return uniqueSourceRefs([
+		ref("work-item-domain-action-admission", admission.admissionId),
+		ref("work-item-domain-action-proposal", admission.proposalId),
+		...(proposal === undefined
+			? []
+			: [
+					ref("work-item", proposal.workItemId),
+					ref("work-item-evidence", proposal.evidenceId),
+					...(proposal.sourceRefs ?? []),
+				]),
+		...(policy === undefined ? [] : [ref("work-item-domain-action-apply-policy", policy.policyId)]),
+		...(admission.sourceRefs ?? []),
+	]);
+}
+
+function actionSourceRefs(
+	admission: WorkItemDomainActionAdmission,
+	proposal: WorkItemDomainActionProposal,
+	policy: WorkItemDomainActionApplyPolicy,
+): readonly SourceRef[] {
+	return admissionRefs(admission, proposal, policy);
+}
diff --git a/packages/ts/src/solutions/work-item/actions-builders.ts b/packages/ts/src/solutions/work-item/actions-builders.ts
new file mode 100644
index 00000000..4a17879e
--- /dev/null
+++ b/packages/ts/src/solutions/work-item/actions-builders.ts
@@ -0,0 +1,72 @@
+import type { WorkItemDomainActionProposal } from "../../orchestration/work-item-runtime.js";
+import type {
+	WorkItemDomainActionApplyPolicy,
+	WorkItemDomainActionKind,
+	WorkItemDomainActionProposalIntake,
+} from "./actions-types.js";
+
+export function workItemDomainActionProposal(
+	proposalId: string,
+	workItemId: string,
+	actionKind: WorkItemDomainActionKind,
+	opts: Omit<
+		Partial<WorkItemDomainActionProposal>,
+		"kind" | "proposalId" | "workItemId" | "actionKind"
+	> = {},
+): WorkItemDomainActionProposal {
+	return {
+		kind: "work-item-domain-action-proposal",
+		proposalId,
+		workItemId,
+		actionKind,
+		effectRunId: opts.effectRunId ?? `domain-action:${proposalId}:effect-run`,
+		effectRunResultId: opts.effectRunResultId ?? `domain-action:${proposalId}:effect-run-result`,
+		evidenceId: opts.evidenceId ?? `domain-action:${proposalId}:evidence`,
+		policyId: opts.policyId ?? "domain-action-proposal",
+		payload: opts.payload,
+		reason: opts.reason,
+		sourceRefs: opts.sourceRefs,
+		proposedAtMs: opts.proposedAtMs,
+		metadata: opts.metadata,
+	};
+}
+
+export function workItemDomainActionProposalIntake<TPayload = unknown>(
+	proposalId: string,
+	workItemId: string,
+	actionKind: WorkItemDomainActionKind,
+	opts: Omit<
+		Partial<WorkItemDomainActionProposalIntake<TPayload>>,
+		"kind" | "proposalId" | "workItemId" | "actionKind"
+	> = {},
+): WorkItemDomainActionProposalIntake<TPayload> {
+	return {
+		kind: "work-item-domain-action-proposal-intake",
+		proposalId,
+		workItemId,
+		actionKind,
+		payload: opts.payload,
+		reason: opts.reason,
+		policyId: opts.policyId,
+		effectRunId: opts.effectRunId,
+		effectRunResultId: opts.effectRunResultId,
+		evidenceId: opts.evidenceId,
+		proposedAtMs: opts.proposedAtMs,
+		sourceRefs: opts.sourceRefs,
+		metadata: opts.metadata,
+	};
+}
+
+export function workItemDomainActionApplyPolicy(
+	policyId: string,
+	opts: Omit<Partial<WorkItemDomainActionApplyPolicy>, "kind" | "policyId"> = {},
+): WorkItemDomainActionApplyPolicy {
+	return {
+		kind: "work-item-domain-action-apply-policy",
+		policyId,
+		actionKinds: opts.actionKinds,
+		patch: opts.patch,
+		spawn: opts.spawn,
+		metadata: opts.metadata,
+	};
+}
diff --git a/packages/ts/src/solutions/work-item/actions-capability-guard.ts b/packages/ts/src/solutions/work-item/actions-capability-guard.ts
new file mode 100644
index 00000000..db030bbf
--- /dev/null
+++ b/packages/ts/src/solutions/work-item/actions-capability-guard.ts
@@ -0,0 +1,649 @@
+import { type Ctx, depBatch } from "../../ctx/types.js";
+import type { DataIssue } from "../../data/index.js";
+import type { Graph } from "../../graph/graph.js";
+import type { BoundaryCapabilityKind, BoundaryCapabilityRef } from "../../inspection/boundary.js";
+import type { SourceRef } from "../../orchestration/agent-runtime.js";
+import type {
+	WorkItemDomainActionAdmissionDecision,
+	WorkItemDomainActionProposal,
+} from "../../orchestration/work-item-runtime.js";
+import type { CapabilityAdmission, CapabilityAdmissionStatus } from "../capability-admission.js";
+import {
+	dataIssue,
+	isRecord,
+	project,
+	recordString,
+	ref,
+	stringMetadata,
+	uniqueSourceRefs,
+} from "./actions-shared.js";
+import type {
+	CapabilityGuardFact,
+	CapabilityGuardState,
+	WorkItemDomainActionCapabilityGuardBundle,
+	WorkItemDomainActionCapabilityGuardOptions,
+	WorkItemDomainActionCapabilityGuardPolicy,
+	WorkItemDomainActionCapabilityGuardStatus,
+} from "./actions-types.js";
+
+/**
+ * Connects CapabilityAdmission facts to WorkItem domain-action admission as a
+ * product-owned guard (D357), without adding protocol/boundary vocabulary or
+ * treating AutoPanel display affordances as hard security enforcement.
+ */
+export function workItemDomainActionCapabilityGuardProjector(
+	graph: Graph,
+	opts: WorkItemDomainActionCapabilityGuardOptions,
+): WorkItemDomainActionCapabilityGuardBundle {
+	const name = opts.name ?? "workItemDomainActionCapabilityGuard";
+	const deps =
+		opts.capabilityAdmissionStatus === undefined
+			? [opts.proposals, opts.capabilityAdmissions, opts.guardPolicies]
+			: [
+					opts.proposals,
+					opts.capabilityAdmissions,
+					opts.guardPolicies,
+					opts.capabilityAdmissionStatus,
+				];
+	const statusIndex = opts.capabilityAdmissionStatus === undefined ? -1 : 3;
+	const now = opts.now ?? Date.now;
+	const runtime = graph.node<CapabilityGuardFact>(
+		deps,
+		(ctx) => {
+			const state: CapabilityGuardState = ctx.state.get<CapabilityGuardState>() ?? {
+				proposals: new Map(),
+				admissionsByCapability: new Map(),
+				issueStatusesByCapability: new Map(),
+				issueStatusesWithoutCapability: [],
+				policies: new Map(),
+				emittedProposalDecisions: new Set(),
+				emittedStatusKeys: new Set(),
+				issueKeys: new Set(),
+				statusSeq: 0,
+				auditSeq: 0,
+			};
+			for (const raw of depBatch(ctx, 2) ?? []) {
+				const policyIssue = capabilityGuardPolicyIssue(raw);
+				if (policyIssue !== undefined) {
+					emitCapabilityGuardIssue(
+						ctx,
+						state,
+						`malformed-policy:${recordString(raw, "policyId") ?? "unknown"}`,
+						policyIssue,
+					);
+					continue;
+				}
+				const policy = raw as WorkItemDomainActionCapabilityGuardPolicy;
+				state.policies.set(policy.policyId, policy);
+			}
+			for (const raw of depBatch(ctx, 1) ?? []) {
+				const admissionIssue = capabilityAdmissionIssue(raw);
+				if (admissionIssue !== undefined) {
+					emitCapabilityGuardIssue(
+						ctx,
+						state,
+						`malformed-admission:${recordString(raw, "admissionId") ?? "unknown"}`,
+						admissionIssue,
+					);
+					continue;
+				}
+				const admission = raw as CapabilityAdmission;
+				const capabilityKey = capabilityBoundaryRefId(admission.capability);
+				const byCapability: CapabilityAdmission[] =
+					state.admissionsByCapability.get(capabilityKey) ?? [];
+				if (!byCapability.some((item) => item.admissionId === admission.admissionId)) {
+					state.admissionsByCapability.set(capabilityKey, [...byCapability, admission]);
+				}
+			}
+			if (statusIndex >= 0) {
+				for (const raw of depBatch(ctx, statusIndex) ?? []) {
+					const statusIssue = capabilityAdmissionStatusIssue(raw);
+					if (statusIssue !== undefined) {
+						emitCapabilityGuardIssue(
+							ctx,
+							state,
+							`malformed-capability-status:${recordString(raw, "statusId") ?? "unknown"}`,
+							statusIssue,
+						);
+						continue;
+					}
+					const status = raw as CapabilityAdmissionStatus;
+					if (status.state !== "capability-admission-issue") continue;
+					const capabilityId = status.capabilityId;
+					const capabilityKind = status.capabilityKind;
+					if (capabilityId !== undefined && capabilityKind !== undefined) {
+						const capabilityKey = capabilityBoundaryRefId({
+							id: capabilityId,
+							kind: capabilityKind,
+						});
+						const statuses: CapabilityAdmissionStatus[] =
+							state.issueStatusesByCapability.get(capabilityKey) ?? [];
+						if (!statuses.some((item) => item.statusId === status.statusId)) {
+							state.issueStatusesByCapability.set(capabilityKey, [...statuses, status]);
+						}
+					} else if (
+						!state.issueStatusesWithoutCapability.some((item) => item.statusId === status.statusId)
+					) {
+						state.issueStatusesWithoutCapability.push(status);
+					}
+					for (const proposal of state.proposals.values())
+						emitCapabilityStatusIssueForProposal(ctx, state, proposal, status);
+				}
+			}
+			for (const raw of depBatch(ctx, 0) ?? []) {
+				const proposalIssue = capabilityGuardProposalIssue(raw);
+				if (proposalIssue !== undefined) {
+					emitCapabilityGuardIssue(
+						ctx,
+						state,
+						`malformed-proposal:${recordString(raw, "proposalId") ?? "unknown"}`,
+						proposalIssue,
+					);
+					continue;
+				}
+				const proposal = raw as WorkItemDomainActionProposal;
+				state.proposals.set(proposal.proposalId, proposal);
+			}
+			for (const proposal of state.proposals.values())
+				evaluateCapabilityGuardProposal(ctx, state, proposal, now());
+			ctx.state.set(state);
+		},
+		{
+			name: `${name}/runtime`,
+			factory: "workItemDomainActionCapabilityGuardProjector",
+			partial: true,
+			completeWhenDepsComplete: false,
+			errorWhenDepsError: false,
+		},
+	);
+	return {
+		decisions: project(
+			graph,
+			runtime,
+			`${name}/decisions`,
+			"workItemDomainActionCapabilityGuardDecisions",
+			(fact) => (fact.kind === "decision" ? fact.value : undefined),
+		),
+		status: project(
+			graph,
+			runtime,
+			`${name}/status`,
+			"workItemDomainActionCapabilityGuardStatus",
+			(fact) => (fact.kind === "status" ? fact.value : undefined),
+		),
+		issues: project(
+			graph,
+			runtime,
+			`${name}/issues`,
+			"workItemDomainActionCapabilityGuardIssues",
+			(fact) => (fact.kind === "issue" ? fact.value : undefined),
+		),
+		audit: project(
+			graph,
+			runtime,
+			`${name}/audit`,
+			"workItemDomainActionCapabilityGuardAudit",
+			(fact) => (fact.kind === "audit" ? fact.value : undefined),
+		),
+	};
+}
+
+function evaluateCapabilityGuardProposal(
+	ctx: Ctx,
+	state: CapabilityGuardState,
+	proposal: WorkItemDomainActionProposal,
+	decidedAtMs: number,
+): void {
+	if (state.emittedProposalDecisions.has(proposal.proposalId)) return;
+	const policy = selectCapabilityGuardPolicy(state, proposal);
+	if (typeof policy === "string") {
+		emitCapabilityGuardIssue(
+			ctx,
+			state,
+			`policy:${proposal.proposalId}:${policy}`,
+			dataIssue(policy, capabilityGuardPolicyMessage(policy, proposal), {
+				subjectId: proposal.workItemId,
+				refs: [ref("work-item-domain-action-proposal", proposal.proposalId)],
+			}),
+		);
+		return;
+	}
+	for (const status of state.issueStatusesWithoutCapability)
+		emitCapabilityStatusIssueForProposal(ctx, state, proposal, status);
+	for (const capabilityRef of policy.capabilityRefs) {
+		for (const status of state.issueStatusesByCapability.get(
+			capabilityBoundaryRefId(capabilityRef),
+		) ?? [])
+			emitCapabilityStatusIssueForProposal(ctx, state, proposal, status);
+	}
+	const admissions = policy.capabilityRefs.map((capabilityRef) =>
+		latestCapabilityAdmission(state, policy, capabilityRef),
+	);
+	const missingCapabilityRefs = policy.capabilityRefs.filter(
+		(_, index) => admissions[index] === undefined,
+	);
+	const deferredCapabilityRefs = admissions
+		.filter((admission): admission is CapabilityAdmission => admission !== undefined)
+		.filter((admission) => admission.state === "deferred")
+		.map((admission) => capabilityBoundaryRefId(admission.capability));
+	if (missingCapabilityRefs.length > 0 || deferredCapabilityRefs.length > 0) {
+		emitCapabilityGuardStatusOnce(
+			ctx,
+			state,
+			`deferred:${proposal.proposalId}:${policy.policyId}:missing=${missingCapabilityRefs.map(capabilityBoundaryRefId).join(",")}:deferred=${deferredCapabilityRefs.join(",")}`,
+			{
+				state: "deferred",
+				workItemId: proposal.workItemId,
+				proposalId: proposal.proposalId,
+				actionKind: proposal.actionKind,
+				policyId: policy.policyId,
+				capabilityRefs: policy.capabilityRefs,
+				admissionSubjectIds: policy.admissionSubjectIds,
+				message: "WorkItem domain action is waiting for capability admission",
+				sourceRefs: capabilityGuardRefs(proposal, policy, admissions),
+				metadata: {
+					missingCapabilityRefs: missingCapabilityRefs.map(capabilityBoundaryRefId),
+					deferredCapabilityRefs,
+				},
+			},
+		);
+		return;
+	}
+	const presentAdmissions = admissions.filter(
+		(admission): admission is CapabilityAdmission => admission !== undefined,
+	);
+	const blocked = presentAdmissions.filter((admission) => admission.state === "blocked");
+	const outcome: WorkItemDomainActionAdmissionDecision["outcome"] =
+		blocked.length === 0 ? "admit" : "reject";
+	const decision: WorkItemDomainActionAdmissionDecision = {
+		kind: "work-item-domain-action-admission-decision",
+		decisionId: `capability-guard:${proposal.proposalId}:decision`,
+		admissionId: `capability-guard:${proposal.proposalId}:admission`,
+		proposalId: proposal.proposalId,
+		outcome,
+		reason:
+			blocked.length === 0
+				? "Capability guard admitted required capabilities"
+				: "Capability guard rejected blocked capabilities",
+		decidedAtMs,
+		sourceRefs: capabilityGuardRefs(proposal, policy, presentAdmissions),
+		metadata: {
+			capabilityGuardPolicyId: policy.policyId,
+			capabilityRefs: policy.capabilityRefs.map(capabilityBoundaryRefId),
+			admissionSubjectIds: policy.admissionSubjectIds,
+			blockedCapabilityRefs: blocked.map((admission) =>
+				capabilityBoundaryRefId(admission.capability),
+			),
+		},
+	};
+	state.emittedProposalDecisions.add(proposal.proposalId);
+	emitCapabilityGuard(ctx, "decision", decision);
+	emitCapabilityGuardStatus(ctx, state, {
+		state: outcome === "admit" ? "admitted" : "rejected",
+		workItemId: proposal.workItemId,
+		proposalId: proposal.proposalId,
+		actionKind: proposal.actionKind,
+		policyId: policy.policyId,
+		capabilityRefs: policy.capabilityRefs,
+		admissionSubjectIds: policy.admissionSubjectIds,
+		admissionIds: presentAdmissions.map((admission) => admission.admissionId),
+		sourceRefs: decision.sourceRefs,
+		metadata: { decisionId: decision.decisionId, admissionId: decision.admissionId },
+	});
+}
+
+function capabilityGuardProposalIssue(proposal: unknown): DataIssue | undefined {
+	if (
+		!isRecord(proposal) ||
+		proposal.kind !== "work-item-domain-action-proposal" ||
+		typeof proposal.proposalId !== "string" ||
+		proposal.proposalId.length === 0 ||
+		typeof proposal.workItemId !== "string" ||
+		proposal.workItemId.length === 0 ||
+		typeof proposal.actionKind !== "string" ||
+		proposal.actionKind.length === 0 ||
+		(proposal.sourceRefs !== undefined && !isSourceRefArray(proposal.sourceRefs))
+	) {
+		return dataIssue(
+			"malformed-work-item-domain-action-capability-guard-proposal",
+			"WorkItem domain action capability guard requires valid proposal DATA facts",
+			{ subjectId: recordString(proposal, "workItemId") },
+		);
+	}
+	return undefined;
+}
+
+function capabilityGuardPolicyIssue(policy: unknown): DataIssue | undefined {
+	if (
+		!isRecord(policy) ||
+		policy.kind !== "work-item-domain-action-capability-guard-policy" ||
+		typeof policy.policyId !== "string" ||
+		policy.policyId.length === 0 ||
+		!Array.isArray(policy.capabilityRefs) ||
+		policy.capabilityRefs.length === 0 ||
+		!policy.capabilityRefs.every(isBoundaryCapabilityRef) ||
+		!Array.isArray(policy.admissionSubjectIds) ||
+		policy.admissionSubjectIds.length === 0 ||
+		!policy.admissionSubjectIds.every((id) => typeof id === "string" && id.length > 0) ||
+		(policy.actionKinds !== undefined &&
+			(!Array.isArray(policy.actionKinds) ||
+				!policy.actionKinds.every((kind) => typeof kind === "string" && kind.length > 0)))
+	) {
+		return dataIssue(
+			"malformed-work-item-domain-action-capability-guard-policy",
+			"WorkItem domain action capability guard policy requires policyId, capabilityRefs, and admissionSubjectIds",
+			{
+				subjectId: recordString(policy, "policyId"),
+			},
+		);
+	}
+	return undefined;
+}
+
+function capabilityAdmissionIssue(admission: unknown): DataIssue | undefined {
+	if (
+		!isRecord(admission) ||
+		admission.kind !== "capability-admission" ||
+		typeof admission.admissionId !== "string" ||
+		admission.admissionId.length === 0 ||
+		typeof admission.proposalId !== "string" ||
+		admission.proposalId.length === 0 ||
+		typeof admission.subjectId !== "string" ||
+		admission.subjectId.length === 0 ||
+		!isBoundaryCapabilityRef(admission.capability) ||
+		!isCapabilityAdmissionState(admission.state) ||
+		typeof admission.decisionId !== "string" ||
+		admission.decisionId.length === 0 ||
+		(admission.sourceRefs !== undefined && !isSourceRefArray(admission.sourceRefs))
+	) {
+		return dataIssue(
+			"malformed-capability-admission",
+			"WorkItem domain action capability guard requires valid CapabilityAdmission DATA facts",
+			{ subjectId: recordString(admission, "subjectId") },
+		);
+	}
+	return undefined;
+}
+
+function capabilityAdmissionStatusIssue(status: unknown): DataIssue | undefined {
+	if (
+		!isRecord(status) ||
+		status.kind !== "capability-admission-status" ||
+		typeof status.statusId !== "string" ||
+		status.statusId.length === 0 ||
+		!isCapabilityAdmissionStatusState(status.state)
+	) {
+		return dataIssue(
+			"malformed-capability-admission-status",
+			"WorkItem domain action capability guard requires valid CapabilityAdmissionStatus DATA facts",
+			{ subjectId: recordString(status, "subjectId") },
+		);
+	}
+	const hasCapabilityId = status.capabilityId !== undefined;
+	const hasCapabilityKind = status.capabilityKind !== undefined;
+	if (
+		hasCapabilityId !== hasCapabilityKind ||
+		(hasCapabilityId &&
+			(typeof status.capabilityId !== "string" ||
+				status.capabilityId.length === 0 ||
+				!isBoundaryCapabilityKind(status.capabilityKind))) ||
+		(status.sourceRefs !== undefined && !isSourceRefArray(status.sourceRefs)) ||
+		(status.issues !== undefined && !isDataIssueArray(status.issues))
+	) {
+		return dataIssue(
+			"malformed-capability-admission-status",
+			"WorkItem domain action capability guard requires valid CapabilityAdmissionStatus DATA facts",
+			{ subjectId: recordString(status, "subjectId") },
+		);
+	}
+	return undefined;
+}
+
+function isCapabilityAdmissionState(value: unknown): value is CapabilityAdmission["state"] {
+	return value === "allowed" || value === "blocked" || value === "deferred";
+}
+
+function isCapabilityAdmissionStatusState(
+	value: unknown,
+): value is CapabilityAdmissionStatus["state"] {
+	return (
+		value === "capability-admission-allowed" ||
+		value === "capability-admission-blocked" ||
+		value === "capability-admission-deferred" ||
+		value === "capability-admission-issue"
+	);
+}
+
+function isSourceRefArray(value: unknown): value is readonly SourceRef[] {
+	return (
+		Array.isArray(value) &&
+		value.every(
+			(item) => isRecord(item) && typeof item.kind === "string" && typeof item.id === "string",
+		)
+	);
+}
+
+function isDataIssueArray(value: unknown): value is readonly DataIssue[] {
+	return Array.isArray(value) && value.every(isDataIssue);
+}
+
+function isDataIssue(value: unknown): value is DataIssue {
+	return (
+		isRecord(value) &&
+		value.kind === "issue" &&
+		typeof value.code === "string" &&
+		value.code.length > 0 &&
+		typeof value.message === "string" &&
+		value.message.length > 0
+	);
+}
+
+function isBoundaryCapabilityRef(value: unknown): value is BoundaryCapabilityRef {
+	return (
+		isRecord(value) &&
+		typeof value.id === "string" &&
+		value.id.length > 0 &&
+		isBoundaryCapabilityKind(value.kind) &&
+		typeof value.required === "boolean" &&
+		(value.sourceRefs === undefined ||
+			(Array.isArray(value.sourceRefs) &&
+				value.sourceRefs.every((sourceRef) => typeof sourceRef === "string")))
+	);
+}
+
+function isBoundaryCapabilityKind(value: unknown): value is BoundaryCapabilityKind {
+	return value === "auth" || value === "permission" || value === "config" || value === "resource";
+}
+
+function selectCapabilityGuardPolicy(
+	state: CapabilityGuardState,
+	proposal: WorkItemDomainActionProposal,
+):
+	| WorkItemDomainActionCapabilityGuardPolicy
+	| "missing-policy"
+	| "unknown-work-item-domain-action-capability-guard-policy"
+	| "policy-mismatch" {
+	const explicitId =
+		stringMetadata(proposal.metadata, "capabilityGuardPolicyId") ??
+		proposal.sourceRefs?.find(
+			(sourceRef) => sourceRef.kind === "work-item-domain-action-capability-guard-policy",
+		)?.id;
+	if (explicitId !== undefined)
+		return (
+			state.policies.get(explicitId) ?? "unknown-work-item-domain-action-capability-guard-policy"
+		);
+	const matching = [...state.policies.values()].filter(
+		(policy) =>
+			policy.actionKinds === undefined || policy.actionKinds.includes(proposal.actionKind),
+	);
+	if (matching.length === 0) return "missing-policy";
+	if (matching.length > 1) return "policy-mismatch";
+	return matching[0];
+}
+
+function latestCapabilityAdmission(
+	state: CapabilityGuardState,
+	policy: WorkItemDomainActionCapabilityGuardPolicy,
+	capabilityRef: BoundaryCapabilityRef,
+): CapabilityAdmission | undefined {
+	const admissions = state.admissionsByCapability.get(capabilityBoundaryRefId(capabilityRef)) ?? [];
+	for (let index = admissions.length - 1; index >= 0; index -= 1) {
+		const admission = admissions[index];
+		if (admission !== undefined && policy.admissionSubjectIds.includes(admission.subjectId))
+			return admission;
+	}
+	return undefined;
+}
+
+function emitCapabilityStatusIssueForProposal(
+	ctx: Ctx,
+	state: CapabilityGuardState,
+	proposal: WorkItemDomainActionProposal,
+	status: CapabilityAdmissionStatus,
+): void {
+	const policy = selectCapabilityGuardPolicy(state, proposal);
+	if (typeof policy === "string") return;
+	if (status.subjectId !== undefined && !policy.admissionSubjectIds.includes(status.subjectId))
+		return;
+	const capabilityId = status.capabilityId;
+	const capabilityKind = status.capabilityKind;
+	const statusCapabilityKey =
+		capabilityId === undefined || capabilityKind === undefined
+			? undefined
+			: capabilityBoundaryRefId({ id: capabilityId, kind: capabilityKind });
+	if (
+		statusCapabilityKey !== undefined &&
+		!policy.capabilityRefs.some(
+			(capabilityRef) => capabilityBoundaryRefId(capabilityRef) === statusCapabilityKey,
+		)
+	)
+		return;
+	const issue =
+		status.issues?.[0] ??
+		dataIssue(
+			"capability-admission-status-issue",
+			"Capability admission status reported an issue",
+			{ subjectId: proposal.workItemId },
+		);
+	emitCapabilityGuardIssue(
+		ctx,
+		state,
+		`capability-status:${proposal.proposalId}:${status.statusId}`,
+		dataIssue(issue.code, issue.message, {
+			subjectId: proposal.workItemId,
+			refs: uniqueSourceRefs([
+				...capabilityGuardRefs(proposal, policy),
+				...(status.sourceRefs ?? []),
+			]),
+			metadata: {
+				...(statusCapabilityKey === undefined ? {} : { capabilityRef: statusCapabilityKey }),
+				capabilityAdmissionStatusId: status.statusId,
+			},
+		}),
+	);
+}
+
+function capabilityGuardPolicyMessage(
+	code:
+		| "missing-policy"
+		| "unknown-work-item-domain-action-capability-guard-policy"
+		| "policy-mismatch",
+	proposal: WorkItemDomainActionProposal,
+): string {
+	if (code === "missing-policy")
+		return `WorkItem domain action '${proposal.proposalId}' has no capability guard policy`;
+	if (code === "unknown-work-item-domain-action-capability-guard-policy")
+		return `WorkItem domain action '${proposal.proposalId}' references a missing capability guard policy`;
+	return `WorkItem domain action '${proposal.proposalId}' matches multiple capability guard policies`;
+}
+
+function capabilityGuardRefs(
+	proposal: WorkItemDomainActionProposal,
+	policy: WorkItemDomainActionCapabilityGuardPolicy,
+	admissions: readonly (CapabilityAdmission | undefined)[] = [],
+): readonly SourceRef[] {
+	return uniqueSourceRefs([
+		ref("work-item", proposal.workItemId),
+		ref("work-item-domain-action-proposal", proposal.proposalId),
+		ref("work-item-domain-action-capability-guard-policy", policy.policyId),
+		...admissions
+			.filter((admission): admission is CapabilityAdmission => admission !== undefined)
+			.flatMap((admission) => [
+				ref("capability-admission", admission.admissionId),
+				ref("capability-admission-proposal", admission.proposalId),
+				ref("boundary-capability", capabilityBoundaryRefId(admission.capability)),
+				...(admission.sourceRefs ?? []),
+			]),
+		...(proposal.sourceRefs ?? []),
+	]);
+}
+
+function capabilityBoundaryRefId(capability: Pick<BoundaryCapabilityRef, "id" | "kind">): string {
+	return `${capability.kind}:${capability.id}`;
+}
+
+function emitCapabilityGuardStatus(
+	ctx: Ctx,
+	state: CapabilityGuardState,
+	status: Omit<WorkItemDomainActionCapabilityGuardStatus, "kind" | "statusId">,
+): void {
+	state.statusSeq += 1;
+	const statusFact: WorkItemDomainActionCapabilityGuardStatus = {
+		kind: "work-item-domain-action-capability-guard-status",
+		statusId: `work-item-domain-action-capability-guard-status:${state.statusSeq}`,
+		...status,
+	};
+	emitCapabilityGuard(ctx, "status", statusFact);
+	state.auditSeq += 1;
+	emitCapabilityGuard(ctx, "audit", {
+		id: `work-item-domain-action-capability-guard-status:${state.auditSeq}`,
+		kind: "work-item-domain-action-capability-guard-status",
+		subjectId: status.workItemId,
+		message: status.message,
+		sourceRefs: status.sourceRefs,
+		metadata: {
+			statusId: statusFact.statusId,
+			state: status.state,
+			proposalId: status.proposalId,
+			policyId: status.policyId,
+			...(status.metadata ?? {}),
+		},
+	});
+}
+
+function emitCapabilityGuardStatusOnce(
+	ctx: Ctx,
+	state: CapabilityGuardState,
+	key: string,
+	status: Omit<WorkItemDomainActionCapabilityGuardStatus, "kind" | "statusId">,
+): void {
+	if (state.emittedStatusKeys.has(key)) return;
+	state.emittedStatusKeys.add(key);
+	emitCapabilityGuardStatus(ctx, state, status);
+}
+
+function emitCapabilityGuardIssue(
+	ctx: Ctx,
+	state: CapabilityGuardState,
+	key: string,
+	issue: DataIssue,
+): void {
+	if (state.issueKeys.has(key)) return;
+	state.issueKeys.add(key);
+	emitCapabilityGuard(ctx, "issue", issue);
+	emitCapabilityGuardStatus(ctx, state, {
+		state: "issue",
+		workItemId: issue.subjectId,
+		issues: [issue],
+		message: issue.message,
+		metadata: { issueCode: issue.code },
+	});
+}
+
+function emitCapabilityGuard<K extends CapabilityGuardFact["kind"]>(
+	ctx: Ctx,
+	kind: K,
+	value: Extract<CapabilityGuardFact, { readonly kind: K }>["value"],
+): void {
+	ctx.down([["DATA", { kind, value } as unknown as CapabilityGuardFact]]);
+}
diff --git a/packages/ts/src/solutions/work-item/actions-intake.ts b/packages/ts/src/solutions/work-item/actions-intake.ts
new file mode 100644
index 00000000..535a0ca8
--- /dev/null
+++ b/packages/ts/src/solutions/work-item/actions-intake.ts
@@ -0,0 +1,176 @@
+import { type Ctx, depBatch } from "../../ctx/types.js";
+import type { Graph } from "../../graph/graph.js";
+import type { WorkItemDomainActionProposal } from "../../orchestration/work-item-runtime.js";
+import { workItemDomainActionProposal } from "./actions-builders.js";
+import { auditRecord, dataIssue, isRecord, project, sourceRefs } from "./actions-shared.js";
+import type {
+	IntakeFact,
+	IntakeState,
+	WorkItemDomainActionIntakeBundle,
+	WorkItemDomainActionIntakeOptions,
+	WorkItemDomainActionKind,
+	WorkItemDomainActionStatus,
+} from "./actions-types.js";
+
+export function workItemDomainActionProposalIntakeProjector(
+	graph: Graph,
+	opts: WorkItemDomainActionIntakeOptions,
+): WorkItemDomainActionIntakeBundle {
+	const name = opts.name ?? "workItemDomainActionIntake";
+	const now = opts.now ?? Date.now;
+	const runtime = graph.node<IntakeFact>(
+		[opts.proposals],
+		(ctx) => {
+			const state = ctx.state.get<IntakeState>() ?? {
+				proposals: new Set(),
+				statusSeq: 0,
+				auditSeq: 0,
+			};
+			for (const raw of depBatch(ctx, 0) ?? []) reduceProposalIntake(ctx, state, raw, now());
+			ctx.state.set(state);
+		},
+		{
+			name: `${name}/runtime`,
+			factory: "workItemDomainActionProposalIntakeProjector",
+			partial: true,
+			completeWhenDepsComplete: false,
+			errorWhenDepsError: false,
+		},
+	);
+	return {
+		proposals: project(
+			graph,
+			runtime,
+			`${name}/proposals`,
+			"workItemDomainActionProposals",
+			(fact) => (fact.kind === "proposal" ? fact.value : undefined),
+		),
+		status: project(graph, runtime, `${name}/status`, "workItemDomainActionStatus", (fact) =>
+			fact.kind === "status" ? fact.value : undefined,
+		),
+		issues: project(graph, runtime, `${name}/issues`, "workItemDomainActionIssues", (fact) =>
+			fact.kind === "issue" ? fact.value : undefined,
+		),
+		audit: project(graph, runtime, `${name}/audit`, "workItemDomainActionAudit", (fact) =>
+			fact.kind === "audit" ? fact.value : undefined,
+		),
+	};
+}
+
+function reduceProposalIntake(
+	ctx: Ctx,
+	state: IntakeState,
+	input: unknown,
+	proposedAtMs: number,
+): void {
+	const proposal = normalizeProposal(input, proposedAtMs);
+	if (typeof proposal === "string") {
+		const issue = dataIssue("malformed-domain-action-proposal", proposal);
+		emitIntake(ctx, "issue", issue);
+		emitIntakeStatus(ctx, state, {
+			state: "rejected",
+			code: issue.code,
+			message: issue.message,
+		});
+		return;
+	}
+	if (state.proposals.has(proposal.proposalId)) {
+		emitIntakeStatus(ctx, state, {
+			state: "duplicate",
+			code: "duplicate-suppressed",
+			workItemId: proposal.workItemId,
+			proposalId: proposal.proposalId,
+			actionKind: proposal.actionKind,
+			message: `Duplicate WorkItem domain action proposal '${proposal.proposalId}' suppressed`,
+		});
+		return;
+	}
+	state.proposals.add(proposal.proposalId);
+	emitIntake(ctx, "proposal", proposal);
+	emitIntakeStatus(ctx, state, {
+		state: "proposed",
+		workItemId: proposal.workItemId,
+		proposalId: proposal.proposalId,
+		actionKind: proposal.actionKind,
+		sourceRefs: proposal.sourceRefs,
+	});
+}
+
+function normalizeProposal(
+	input: unknown,
+	proposedAtMs: number,
+): WorkItemDomainActionProposal | string {
+	if (!isRecord(input)) return "WorkItemDomainActionProposal intake must be an object";
+	if (
+		input.kind !== "work-item-domain-action-proposal" &&
+		input.kind !== "work-item-domain-action-proposal-intake"
+	)
+		return "WorkItemDomainActionProposal intake has unsupported kind";
+	if (typeof input.proposalId !== "string" || input.proposalId.trim() === "")
+		return "WorkItemDomainActionProposal.proposalId is required";
+	if (typeof input.workItemId !== "string" || input.workItemId.trim() === "")
+		return "WorkItemDomainActionProposal.workItemId is required";
+	if (typeof input.actionKind !== "string" || input.actionKind.trim() === "")
+		return "WorkItemDomainActionProposal.actionKind is required";
+	if (input.kind === "work-item-domain-action-proposal") {
+		if (typeof input.effectRunId !== "string")
+			return "WorkItemDomainActionProposal.effectRunId is required";
+		if (typeof input.effectRunResultId !== "string")
+			return "WorkItemDomainActionProposal.effectRunResultId is required";
+		if (typeof input.evidenceId !== "string")
+			return "WorkItemDomainActionProposal.evidenceId is required";
+		if (typeof input.policyId !== "string")
+			return "WorkItemDomainActionProposal.policyId is required";
+		return input as unknown as WorkItemDomainActionProposal;
+	}
+	return workItemDomainActionProposal(
+		input.proposalId,
+		input.workItemId,
+		input.actionKind as WorkItemDomainActionKind,
+		{
+			payload: input.payload,
+			reason: typeof input.reason === "string" ? input.reason : undefined,
+			policyId: typeof input.policyId === "string" ? input.policyId : undefined,
+			effectRunId: typeof input.effectRunId === "string" ? input.effectRunId : undefined,
+			effectRunResultId:
+				typeof input.effectRunResultId === "string" ? input.effectRunResultId : undefined,
+			evidenceId: typeof input.evidenceId === "string" ? input.evidenceId : undefined,
+			proposedAtMs: typeof input.proposedAtMs === "number" ? input.proposedAtMs : proposedAtMs,
+			sourceRefs: sourceRefs(input.sourceRefs),
+			metadata: isRecord(input.metadata) ? input.metadata : undefined,
+		},
+	);
+}
+
+function emitIntakeStatus(
+	ctx: Ctx,
+	state: IntakeState,
+	status: Omit<WorkItemDomainActionStatus, "kind" | "statusId">,
+): void {
+	state.statusSeq += 1;
+	const statusFact = {
+		kind: "work-item-domain-action-status",
+		statusId: `work-item-domain-action-intake-status:${state.statusSeq}`,
+		...status,
+	} satisfies WorkItemDomainActionStatus;
+	emitIntake(ctx, "status", statusFact);
+	emitIntakeAudit(ctx, state, "work-item-domain-action-intake-status", statusFact);
+}
+
+function emitIntakeAudit(
+	ctx: Ctx,
+	state: IntakeState,
+	kind: string,
+	status: WorkItemDomainActionStatus,
+): void {
+	state.auditSeq += 1;
+	emitIntake(ctx, "audit", auditRecord(kind, state.auditSeq, status));
+}
+
+function emitIntake<K extends IntakeFact["kind"]>(
+	ctx: Ctx,
+	kind: K,
+	value: Extract<IntakeFact, { kind: K }>["value"],
+): void {
+	ctx.down([["DATA", { kind, value } as IntakeFact]]);
+}
diff --git a/packages/ts/src/solutions/work-item/actions-shared.ts b/packages/ts/src/solutions/work-item/actions-shared.ts
new file mode 100644
index 00000000..39b675f9
--- /dev/null
+++ b/packages/ts/src/solutions/work-item/actions-shared.ts
@@ -0,0 +1,117 @@
+import { depBatch } from "../../ctx/types.js";
+import type { DataIssue } from "../../data/index.js";
+import type { Graph } from "../../graph/graph.js";
+import type { Node } from "../../node/node.js";
+import type { AgentRuntimeAuditRecord, SourceRef } from "../../orchestration/agent-runtime.js";
+import type { WorkItemDomainActionStatus } from "./actions-types.js";
+
+export function auditRecord(
+	kind: string,
+	seq: number,
+	status: WorkItemDomainActionStatus,
+): AgentRuntimeAuditRecord {
+	return {
+		id: `${kind}:${seq}`,
+		kind,
+		subjectId: status.workItemId,
+		message: status.message,
+		issueCode: status.code,
+		sourceRefs: status.sourceRefs,
+		metadata: {
+			statusId: status.statusId,
+			state: status.state,
+			proposalId: status.proposalId,
+			admissionId: status.admissionId,
+			actionKind: status.actionKind,
+			...(status.metadata ?? {}),
+		},
+	};
+}
+
+export function project<TFact, TSelected>(
+	graph: Graph,
+	runtime: Node<TFact>,
+	name: string,
+	factory: string,
+	select: (fact: TFact) => TSelected | undefined,
+): Node<TSelected> {
+	return graph.node<TSelected>(
+		[runtime],
+		(ctx) => {
+			for (const raw of depBatch(ctx, 0) ?? []) {
+				const selected = select(raw as TFact);
+				if (selected !== undefined) ctx.down([["DATA", selected]]);
+			}
+		},
+		{ name, factory, partial: true, completeWhenDepsComplete: false, errorWhenDepsError: false },
+	);
+}
+
+export function dataIssue(
+	code: string,
+	message: string,
+	opts: {
+		readonly subjectId?: string;
+		readonly refs?: readonly SourceRef[];
+		readonly metadata?: Record<string, unknown>;
+	} = {},
+): DataIssue {
+	return {
+		kind: "issue",
+		code,
+		message,
+		severity: "error",
+		source: "work-item-actions",
+		subjectId: opts.subjectId,
+		refs: opts.refs?.map((sourceRef) => `${sourceRef.kind}:${sourceRef.id}`),
+		metadata: opts.metadata,
+	};
+}
+
+export function uniqueSourceRefs(sourceRefs: readonly SourceRef[]): readonly SourceRef[] {
+	const seen = new Set<string>();
+	const out: SourceRef[] = [];
+	for (const sourceRef of sourceRefs) {
+		const key = `${sourceRef.kind}:${sourceRef.id}:${JSON.stringify(sourceRef.metadata ?? {})}`;
+		if (seen.has(key)) continue;
+		seen.add(key);
+		out.push(sourceRef);
+	}
+	return out;
+}
+
+export function sourceRefs(value: unknown): readonly SourceRef[] | undefined {
+	if (!Array.isArray(value)) return undefined;
+	return value.filter(
+		(item): item is SourceRef =>
+			isRecord(item) && typeof item.kind === "string" && typeof item.id === "string",
+	);
+}
+
+export function numberMetadata(
+	metadata: Record<string, unknown> | undefined,
+	key: string,
+): number | undefined {
+	const value = metadata?.[key];
+	return typeof value === "number" ? value : undefined;
+}
+
+export function stringMetadata(
+	metadata: Record<string, unknown> | undefined,
+	key: string,
+): string | undefined {
+	const value = metadata?.[key];
+	return typeof value === "string" ? value : undefined;
+}
+
+export function ref(kind: string, id: string): SourceRef {
+	return { kind, id };
+}
+
+export function recordString(value: unknown, key: string): string | undefined {
+	return isRecord(value) && typeof value[key] === "string" ? value[key] : undefined;
+}
+
+export function isRecord(value: unknown): value is Record<string, unknown> {
+	return value !== null && typeof value === "object";
+}
diff --git a/packages/ts/src/solutions/work-item/actions-types.ts b/packages/ts/src/solutions/work-item/actions-types.ts
new file mode 100644
index 00000000..3bfe2839
--- /dev/null
+++ b/packages/ts/src/solutions/work-item/actions-types.ts
@@ -0,0 +1,291 @@
+import type { DataIssue } from "../../data/index.js";
+import type { BoundaryCapabilityRef } from "../../inspection/boundary.js";
+import type { Node } from "../../node/node.js";
+import type { AgentRuntimeAuditRecord, SourceRef } from "../../orchestration/agent-runtime.js";
+import type {
+	WorkItemDomainActionAdmission,
+	WorkItemDomainActionAdmissionDecision,
+	WorkItemDomainActionProposal,
+} from "../../orchestration/work-item-runtime.js";
+import type { CapabilityAdmission, CapabilityAdmissionStatus } from "../capability-admission.js";
+import type {
+	AcceptanceCriterion,
+	VerificationPlan,
+	WorkItemAuthoringFact,
+	WorkItemDraft,
+	WorkItemPatch,
+	WorkItemProjection,
+} from "./scheduling.js";
+
+export type {
+	WorkItemDomainActionAdmission,
+	WorkItemDomainActionAdmissionDecision,
+	WorkItemDomainActionAdmissionPolicy,
+	WorkItemDomainActionAdmissionViews,
+	WorkItemDomainActionProposal,
+	WorkItemDomainActionProposalSpec,
+} from "../../orchestration/work-item-runtime.js";
+
+export type WorkItemDomainActionKind =
+	| "patch"
+	| "mark-verified"
+	| "require-review"
+	| "spawn-proposed"
+	| "spawn-child"
+	| (string & {});
+
+export interface WorkItemDomainActionProposalIntake<TPayload = unknown> {
+	readonly kind: "work-item-domain-action-proposal-intake";
+	readonly proposalId: string;
+	readonly workItemId: string;
+	readonly actionKind: WorkItemDomainActionKind;
+	readonly payload?: TPayload;
+	readonly reason?: string;
+	readonly policyId?: string;
+	readonly effectRunId?: string;
+	readonly effectRunResultId?: string;
+	readonly evidenceId?: string;
+	readonly proposedAtMs?: number;
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly metadata?: Record<string, unknown>;
+}
+
+export type WorkItemDomainActionProposalInput<TPayload = unknown> =
+	| WorkItemDomainActionProposal<TPayload>
+	| WorkItemDomainActionProposalIntake<TPayload>
+	| unknown;
+
+export type WorkItemDomainActionStatusState =
+	| "proposed"
+	| "applied"
+	| "rejected"
+	| "deferred"
+	| "duplicate"
+	| "missing-policy"
+	| "merged"
+	| "policy-rejected"
+	| "proposal-only";
+
+export interface WorkItemDomainActionStatus {
+	readonly kind: "work-item-domain-action-status";
+	readonly statusId: string;
+	readonly workItemId?: string;
+	readonly proposalId?: string;
+	readonly admissionId?: string;
+	readonly actionKind?: string;
+	readonly state: WorkItemDomainActionStatusState;
+	readonly code?: string;
+	readonly message?: string;
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface WorkItemPatchActionPayload<TInput = unknown> {
+	readonly patch?: WorkItemPatch<TInput>;
+	readonly acceptanceCriteria?: readonly AcceptanceCriterion[];
+	readonly verificationPlan?: VerificationPlan<TInput>;
+	readonly executionRelevantFields?: readonly string[];
+	readonly authorId?: string;
+	readonly eventId?: string;
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface WorkItemSpawnActionPayload<TInput = unknown> {
+	readonly workItemId?: string;
+	readonly childWorkItemId?: string;
+	readonly draft?: WorkItemDraft<TInput>;
+	readonly authorId?: string;
+	readonly eventId?: string;
+	readonly idempotencyKey?: string;
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface WorkItemDomainActionApplyPolicy {
+	readonly kind: "work-item-domain-action-apply-policy";
+	readonly policyId: string;
+	readonly actionKinds?: readonly WorkItemDomainActionKind[];
+	readonly patch?: {
+		readonly allowedFields?: readonly string[];
+		readonly executionRelevantFields?: readonly string[];
+		readonly allowAcceptanceCriteria?: boolean;
+		readonly allowVerificationPlan?: boolean;
+	};
+	readonly spawn?: {
+		readonly create?: boolean;
+		readonly linkParent?: boolean;
+		readonly idempotencyKey?: string;
+		readonly maxChildrenPerAdmission?: number;
+		readonly childWorkItemId?: string;
+		readonly childIdPrefix?: string;
+	};
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface WorkItemDomainActionApplication {
+	readonly kind: "work-item-domain-action-application";
+	readonly applicationId: string;
+	readonly admissionId: string;
+	readonly proposalId: string;
+	readonly workItemId: string;
+	readonly actionKind: string;
+	readonly state: Exclude<WorkItemDomainActionStatusState, "proposed">;
+	readonly producedFactIds?: readonly string[];
+	readonly reason?: string;
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface WorkItemDomainActionIntakeOptions {
+	readonly name?: string;
+	readonly proposals: Node<WorkItemDomainActionProposalInput>;
+	readonly now?: () => number;
+}
+
+export interface WorkItemDomainActionIntakeBundle {
+	readonly proposals: Node<WorkItemDomainActionProposal>;
+	readonly status: Node<WorkItemDomainActionStatus>;
+	readonly issues: Node<DataIssue>;
+	readonly audit: Node<AgentRuntimeAuditRecord>;
+}
+
+export interface WorkItemDomainActionApplicationOptions<TInput = unknown> {
+	readonly name?: string;
+	readonly proposals: Node<WorkItemDomainActionProposal>;
+	readonly admissions: Node<WorkItemDomainActionAdmission>;
+	readonly workItems: Node<WorkItemProjection<TInput>>;
+	readonly applyPolicies?: Node<WorkItemDomainActionApplyPolicy>;
+}
+
+export interface WorkItemDomainActionApplicationBundle<TInput = unknown> {
+	readonly authoringFacts: Node<WorkItemAuthoringFact<TInput>>;
+	readonly applications: Node<WorkItemDomainActionApplication>;
+	readonly status: Node<WorkItemDomainActionStatus>;
+	readonly issues: Node<DataIssue>;
+	readonly audit: Node<AgentRuntimeAuditRecord>;
+}
+
+/**
+ * Product-owned command capability policy (D357): maps WorkItem domain action
+ * proposals to explicit boundary capability refs and admission subjects without
+ * defining provider/security registry semantics or protocol status vocabulary.
+ */
+export interface WorkItemDomainActionCapabilityGuardPolicy {
+	readonly kind: "work-item-domain-action-capability-guard-policy";
+	readonly policyId: string;
+	readonly actionKinds?: readonly WorkItemDomainActionKind[];
+	readonly capabilityRefs: readonly BoundaryCapabilityRef[];
+	readonly admissionSubjectIds: readonly string[];
+	readonly metadata?: Record<string, unknown>;
+}
+
+/**
+ * Visible DATA status for the capability guard (D357). Missing or mismatched
+ * capability facts remain product issues/status, not protocol ERROR messages.
+ */
+export interface WorkItemDomainActionCapabilityGuardStatus {
+	readonly kind: "work-item-domain-action-capability-guard-status";
+	readonly statusId: string;
+	readonly state: "admitted" | "rejected" | "deferred" | "issue";
+	readonly workItemId?: string;
+	readonly proposalId?: string;
+	readonly actionKind?: string;
+	readonly policyId?: string;
+	readonly capabilityRefs?: readonly BoundaryCapabilityRef[];
+	readonly admissionSubjectIds?: readonly string[];
+	readonly admissionIds?: readonly string[];
+	readonly issues?: readonly DataIssue[];
+	readonly message?: string;
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly metadata?: Record<string, unknown>;
+}
+
+/**
+ * Inputs for the WorkItem domain-action capability guard. All dependencies are
+ * ordinary solution/product DATA facts; the guard does not mutate WorkItems or
+ * claim dispatch queues.
+ */
+export interface WorkItemDomainActionCapabilityGuardOptions {
+	readonly name?: string;
+	readonly proposals: Node<WorkItemDomainActionProposal>;
+	readonly capabilityAdmissions: Node<CapabilityAdmission>;
+	readonly guardPolicies: Node<WorkItemDomainActionCapabilityGuardPolicy>;
+	readonly capabilityAdmissionStatus?: Node<CapabilityAdmissionStatus>;
+	readonly now?: () => number;
+}
+
+/**
+ * Output facts for product admission consumption. Decisions feed the existing
+ * WorkItem domain-action admission path; status/issues/audit remain inspectable
+ * product DATA.
+ */
+export interface WorkItemDomainActionCapabilityGuardBundle {
+	readonly decisions: Node<WorkItemDomainActionAdmissionDecision>;
+	readonly status: Node<WorkItemDomainActionCapabilityGuardStatus>;
+	readonly issues: Node<DataIssue>;
+	readonly audit: Node<AgentRuntimeAuditRecord>;
+}
+
+export type IntakeFact =
+	| { readonly kind: "proposal"; readonly value: WorkItemDomainActionProposal }
+	| { readonly kind: "status"; readonly value: WorkItemDomainActionStatus }
+	| { readonly kind: "issue"; readonly value: DataIssue }
+	| { readonly kind: "audit"; readonly value: AgentRuntimeAuditRecord };
+
+export type ApplicationFact<T> =
+	| { readonly kind: "authoring-fact"; readonly value: WorkItemAuthoringFact<T> }
+	| { readonly kind: "application"; readonly value: WorkItemDomainActionApplication }
+	| { readonly kind: "status"; readonly value: WorkItemDomainActionStatus }
+	| { readonly kind: "issue"; readonly value: DataIssue }
+	| { readonly kind: "audit"; readonly value: AgentRuntimeAuditRecord };
+
+export type CapabilityGuardFact =
+	| { readonly kind: "decision"; readonly value: WorkItemDomainActionAdmissionDecision }
+	| { readonly kind: "status"; readonly value: WorkItemDomainActionCapabilityGuardStatus }
+	| { readonly kind: "issue"; readonly value: DataIssue }
+	| { readonly kind: "audit"; readonly value: AgentRuntimeAuditRecord };
+
+export interface IntakeState {
+	readonly proposals: Set<string>;
+	statusSeq: number;
+	auditSeq: number;
+}
+
+export interface ApplicationState<T> {
+	readonly proposals: Map<string, WorkItemDomainActionProposal>;
+	readonly admissions: Map<string, WorkItemDomainActionAdmission>;
+	readonly workItems: Map<string, WorkItemProjection<T>>;
+	readonly policies: Map<string, WorkItemDomainActionApplyPolicy>;
+	readonly appliedAdmissions: Set<string>;
+	readonly emittedFactIds: Set<string>;
+	readonly issueKeys: Set<string>;
+	statusSeq: number;
+	auditSeq: number;
+}
+
+export interface CapabilityGuardState {
+	readonly proposals: Map<string, WorkItemDomainActionProposal>;
+	readonly admissionsByCapability: Map<string, CapabilityAdmission[]>;
+	readonly issueStatusesByCapability: Map<string, CapabilityAdmissionStatus[]>;
+	readonly issueStatusesWithoutCapability: CapabilityAdmissionStatus[];
+	readonly policies: Map<string, WorkItemDomainActionCapabilityGuardPolicy>;
+	readonly emittedProposalDecisions: Set<string>;
+	readonly emittedStatusKeys: Set<string>;
+	readonly issueKeys: Set<string>;
+	statusSeq: number;
+	auditSeq: number;
+}
+
+export const patchFieldKeys = new Set([
+	"summary",
+	"detail",
+	"detailRefs",
+	"kind",
+	"priority",
+	"tags",
+	"owner",
+	"assignee",
+	"deadlineMs",
+	"customFields",
+	"sourceRefs",
+	"metadata",
+]);
diff --git a/packages/ts/src/solutions/work-item/actions.ts b/packages/ts/src/solutions/work-item/actions.ts
new file mode 100644
index 00000000..cd7573a9
--- /dev/null
+++ b/packages/ts/src/solutions/work-item/actions.ts
@@ -0,0 +1,46 @@
+/**
+ * WorkItem domain action intake, admission, and application facts (D239/D333-D343).
+ *
+ * This focused solution subpath keeps action mutation data-first: proposals and
+ * admissions are visible facts, and application lowers only to append-only
+ * WorkItem authoring facts plus status/issue/audit projections. It does not
+ * mutate WorkItem projections directly, run executors, claim queues, or install
+ * hidden schedulers.
+ */
+
+export type {
+	WorkItemDomainActionAdmission,
+	WorkItemDomainActionAdmissionDecision,
+	WorkItemDomainActionAdmissionPolicy,
+	WorkItemDomainActionAdmissionViews,
+	WorkItemDomainActionProposal,
+	WorkItemDomainActionProposalSpec,
+} from "../../orchestration/work-item-runtime.js";
+export { workItemDomainActionAdmissionProjector } from "../../orchestration/work-item-runtime.js";
+export { workItemDomainActionApplicationProjector } from "./actions-application.js";
+export {
+	workItemDomainActionApplyPolicy,
+	workItemDomainActionProposal,
+	workItemDomainActionProposalIntake,
+} from "./actions-builders.js";
+export { workItemDomainActionCapabilityGuardProjector } from "./actions-capability-guard.js";
+export { workItemDomainActionProposalIntakeProjector } from "./actions-intake.js";
+export type {
+	WorkItemDomainActionApplication,
+	WorkItemDomainActionApplicationBundle,
+	WorkItemDomainActionApplicationOptions,
+	WorkItemDomainActionApplyPolicy,
+	WorkItemDomainActionCapabilityGuardBundle,
+	WorkItemDomainActionCapabilityGuardOptions,
+	WorkItemDomainActionCapabilityGuardPolicy,
+	WorkItemDomainActionCapabilityGuardStatus,
+	WorkItemDomainActionIntakeBundle,
+	WorkItemDomainActionIntakeOptions,
+	WorkItemDomainActionKind,
+	WorkItemDomainActionProposalInput,
+	WorkItemDomainActionProposalIntake,
+	WorkItemDomainActionStatus,
+	WorkItemDomainActionStatusState,
+	WorkItemPatchActionPayload,
+	WorkItemSpawnActionPayload,
+} from "./actions-types.js";
diff --git a/packages/ts/src/solutions/work-item/scheduling-authoring.ts b/packages/ts/src/solutions/work-item/scheduling-authoring.ts
new file mode 100644
index 00000000..a1a38287
--- /dev/null
+++ b/packages/ts/src/solutions/work-item/scheduling-authoring.ts
@@ -0,0 +1,355 @@
+import { type Ctx, depBatch } from "../../ctx/types.js";
+import type { DataIssue } from "../../data/index.js";
+import type { Graph } from "../../graph/graph.js";
+import {
+	emit,
+	emitAudit,
+	isRecord,
+	issue,
+	normalizePlan,
+	project,
+	refs,
+} from "./scheduling-shared.js";
+import type {
+	AuthoringState,
+	Fact,
+	WorkItemAuthoringInput,
+	WorkItemAuthoringPolicy,
+	WorkItemAuthoringProjectorBundle,
+	WorkItemAuthoringProjectorOptions,
+	WorkItemDraft,
+	WorkItemPatch,
+	WorkItemProjection,
+	WorkItemValidationIssueCode,
+	WorkItemValidationStatus,
+} from "./scheduling-types.js";
+import { draftPatchKeys, executionRelevantDefaults } from "./scheduling-types.js";
+import {
+	validateAcceptanceCriteria,
+	validateVerificationPlan,
+	validateWorkItemDraft,
+} from "./scheduling-validation.js";
+
+export function workItemAuthoringProjector<TInput = unknown>(
+	graph: Graph,
+	opts: WorkItemAuthoringProjectorOptions<TInput>,
+): WorkItemAuthoringProjectorBundle<TInput> {
+	const name = opts.name ?? "workItemAuthoring";
+	const runtime = graph.node<Fact<TInput>>(
+		[opts.facts],
+		(ctx) => {
+			const state = ctx.state.get<AuthoringState<TInput>>() ?? {
+				workItems: new Map(),
+				seenEvents: new Set(),
+				statusSeq: 0,
+				auditSeq: 0,
+			};
+			for (const raw of depBatch(ctx, 0) ?? [])
+				reduceAuthoring(ctx, state, raw as WorkItemAuthoringInput<TInput>, opts.policy);
+			ctx.state.set(state);
+		},
+		{
+			name: `${name}/runtime`,
+			factory: "workItemAuthoringProjector",
+			partial: true,
+			completeWhenDepsComplete: false,
+			errorWhenDepsError: false,
+		},
+	);
+	return {
+		workItems: project(graph, runtime, `${name}/workItems`, "workItemAuthoringWorkItems", (fact) =>
+			fact.kind === "work-item" ? fact.value : undefined,
+		),
+		status: project(graph, runtime, `${name}/status`, "workItemAuthoringStatus", (fact) =>
+			fact.kind === "status" ? fact.value : undefined,
+		),
+		issues: project(graph, runtime, `${name}/issues`, "workItemAuthoringIssues", (fact) =>
+			fact.kind === "issue" ? fact.value : undefined,
+		),
+		audit: project(graph, runtime, `${name}/audit`, "workItemAuthoringAudit", (fact) =>
+			fact.kind === "audit" ? fact.value : undefined,
+		),
+	};
+}
+
+function reduceAuthoring<T>(
+	ctx: Ctx,
+	state: AuthoringState<T>,
+	input: WorkItemAuthoringInput<T>,
+	policy?: WorkItemAuthoringPolicy,
+): void {
+	if (input.kind === "work-item-spawn-proposed") {
+		const statusWorkItemId = input.proposedWorkItemId ?? input.parentWorkItemId;
+		const issues = validateWorkItemDraft(input.draft, { workItemId: statusWorkItemId });
+		if (issues.length > 0) {
+			for (const item of issues) emit(ctx, "issue", item);
+			emitStatus(ctx, state, {
+				state: "rejected",
+				code: issues[0]?.code as WorkItemValidationIssueCode | undefined,
+				workItemId: statusWorkItemId,
+				message: issues[0]?.message,
+				metadata: {
+					proposalId: input.proposalId,
+					parentWorkItemId: input.parentWorkItemId,
+					idempotencyKey: input.idempotencyKey,
+				},
+			});
+			return;
+		}
+		emitStatus(ctx, state, {
+			state: "deferred",
+			workItemId: statusWorkItemId,
+			message: `WorkItem spawn proposal '${input.proposalId}' carries draft data but is not applied`,
+			metadata: {
+				proposalId: input.proposalId,
+				parentWorkItemId: input.parentWorkItemId,
+				idempotencyKey: input.idempotencyKey,
+			},
+		});
+		return;
+	}
+	if (state.seenEvents.has(input.eventId)) {
+		emit(
+			ctx,
+			"issue",
+			issue("duplicate-id", `Duplicate WorkItem authoring id '${input.eventId}'`, input.workItemId),
+		);
+		return;
+	}
+	state.seenEvents.add(input.eventId);
+	if (input.kind === "work-item-created") {
+		if (state.workItems.has(input.workItemId)) {
+			emit(
+				ctx,
+				"issue",
+				issue("duplicate-id", `Duplicate WorkItem '${input.workItemId}'`, input.workItemId),
+			);
+			emitStatus(ctx, state, {
+				state: "duplicate",
+				code: "duplicate-id",
+				workItemId: input.workItemId,
+				metadata: { eventId: input.eventId },
+			});
+			return;
+		}
+		const issues = validateWorkItemDraft(input.draft, { workItemId: input.workItemId });
+		if (issues.length > 0) {
+			reject(ctx, state, input.workItemId, issues);
+			return;
+		}
+		const projection: WorkItemProjection<T> = {
+			...input.draft,
+			verificationPlan: normalizePlan(input.draft),
+			workItemId: input.workItemId,
+			authoringRevision: 1,
+			executionInputRevision: 1,
+			lastEventId: input.eventId,
+			revisionSourceRefs: refs("work-item-authoring-fact", input.eventId, input.sourceRefs),
+			createdAtMs: input.createdAtMs,
+			updatedAtMs: input.createdAtMs,
+		};
+		accept(ctx, state, projection);
+		return;
+	}
+	const existing = state.workItems.get(input.workItemId);
+	if (existing === undefined) {
+		emit(
+			ctx,
+			"issue",
+			issue(
+				"dangling-ref",
+				`Authoring fact '${input.eventId}' references unknown WorkItem '${input.workItemId}'`,
+				input.workItemId,
+			),
+		);
+		return;
+	}
+	if (input.kind === "work-item-patched") {
+		if (!isRecord(input.patch)) {
+			reject(ctx, state, input.workItemId, [
+				issue("invalid-patch", "WorkItemPatch must be an object", input.workItemId),
+			]);
+			return;
+		}
+		const invalidKeys = Object.keys(input.patch).filter((key) => !draftPatchKeys.has(key));
+		if (invalidKeys.length > 0) {
+			reject(ctx, state, input.workItemId, [
+				issue(
+					"invalid-patch",
+					`WorkItemPatch contains unsupported keys: ${invalidKeys.join(", ")}`,
+					input.workItemId,
+					{
+						invalidKeys,
+					},
+				),
+			]);
+			return;
+		}
+		const draft = applyDraftPatch(existing, input.patch);
+		const issues = validateWorkItemDraft(draft, { workItemId: input.workItemId });
+		if (issues.length > 0) {
+			reject(ctx, state, input.workItemId, issues);
+			return;
+		}
+		const touched = touchesExecutionRelevant(
+			input.patch,
+			executionRelevant(policy, input.executionRelevantFields),
+		);
+		accept(ctx, state, {
+			...existing,
+			...draft,
+			authoringRevision: existing.authoringRevision + 1,
+			executionInputRevision: touched
+				? existing.executionInputRevision + 1
+				: existing.executionInputRevision,
+			lastEventId: input.eventId,
+			revisionSourceRefs: refs("work-item-authoring-fact", input.eventId, input.sourceRefs),
+			updatedAtMs: input.patchedAtMs,
+		});
+		return;
+	}
+	if (input.kind === "acceptance-criteria-changed") {
+		const issues = validateAcceptanceCriteria(input.acceptanceCriteria, {
+			workItemId: input.workItemId,
+		});
+		if (issues.length > 0) {
+			reject(ctx, state, input.workItemId, issues);
+			return;
+		}
+		accept(ctx, state, {
+			...existing,
+			acceptanceCriteria: input.acceptanceCriteria,
+			authoringRevision: existing.authoringRevision + 1,
+			executionInputRevision: existing.executionInputRevision + 1,
+			lastEventId: input.eventId,
+			revisionSourceRefs: refs("work-item-authoring-fact", input.eventId, input.sourceRefs),
+			updatedAtMs: input.changedAtMs,
+		});
+		return;
+	}
+	const issues = validateVerificationPlan(
+		input.verificationPlan,
+		existing.acceptanceCriteria ?? [],
+		{ workItemId: input.workItemId },
+	);
+	if (issues.length > 0) {
+		reject(ctx, state, input.workItemId, issues);
+		return;
+	}
+	accept(ctx, state, {
+		...existing,
+		verificationPlan: input.verificationPlan,
+		verificationSteps: input.verificationPlan.steps,
+		authoringRevision: existing.authoringRevision + 1,
+		executionInputRevision: existing.executionInputRevision + 1,
+		lastEventId: input.eventId,
+		revisionSourceRefs: refs("work-item-authoring-fact", input.eventId, input.sourceRefs),
+		updatedAtMs: input.changedAtMs,
+	});
+}
+
+function accept<T>(ctx: Ctx, state: AuthoringState<T>, projection: WorkItemProjection<T>): void {
+	state.workItems.set(projection.workItemId, projection);
+	emit(ctx, "work-item", projection);
+	emitStatus(ctx, state, {
+		state: "projected",
+		workItemId: projection.workItemId,
+		revision: projection.authoringRevision,
+		executionInputRevision: projection.executionInputRevision,
+		metadata: { lastEventId: projection.lastEventId },
+	});
+}
+
+function reject<T>(
+	ctx: Ctx,
+	state: AuthoringState<T>,
+	workItemId: string,
+	issues: readonly DataIssue[],
+): void {
+	for (const item of issues) emit(ctx, "issue", item);
+	emitStatus(ctx, state, {
+		state: "rejected",
+		code: issues[0]?.code as WorkItemValidationIssueCode | undefined,
+		workItemId,
+		message: issues[0]?.message,
+	});
+}
+
+function emitStatus<T>(
+	ctx: Ctx,
+	state: AuthoringState<T>,
+	status: Omit<WorkItemValidationStatus, "kind" | "statusId">,
+): void {
+	state.statusSeq += 1;
+	const statusFact = {
+		kind: "work-item-validation-status",
+		statusId: `work-item-authoring-status:${state.statusSeq}`,
+		...status,
+	} satisfies WorkItemValidationStatus;
+	emit(ctx, "status", statusFact);
+	emitAudit(ctx, state, "work-item-authoring-status", statusFact);
+}
+
+function applyDraftPatch<T>(
+	existing: WorkItemProjection<T>,
+	patch: WorkItemPatch<T>,
+): WorkItemDraft<T> {
+	return {
+		summary: patchValue(patch, existing, "summary"),
+		detail: patchValue(patch, existing, "detail"),
+		detailRefs: patchValue(patch, existing, "detailRefs"),
+		acceptanceCriteria: patchValue(patch, existing, "acceptanceCriteria"),
+		verificationPlan: patchValue(patch, existing, "verificationPlan"),
+		verificationSteps: patchValue(patch, existing, "verificationSteps"),
+		kind: patchValue(patch, existing, "kind"),
+		priority: patchValue(patch, existing, "priority"),
+		tags: patchValue(patch, existing, "tags"),
+		owner: patchValue(patch, existing, "owner"),
+		assignee: patchValue(patch, existing, "assignee"),
+		deadlineMs: patchValue(patch, existing, "deadlineMs"),
+		customFields: patchValue(patch, existing, "customFields"),
+		sourceRefs: patchValue(patch, existing, "sourceRefs"),
+		metadata: patchValue(patch, existing, "metadata"),
+	};
+}
+
+function patchValue<T, K extends keyof WorkItemDraft<T>>(
+	patch: WorkItemPatch<T>,
+	existing: WorkItemProjection<T>,
+	key: K,
+): WorkItemDraft<T>[K] {
+	return Object.hasOwn(patch, key) ? (patch[key] as WorkItemDraft<T>[K]) : existing[key];
+}
+
+function executionRelevant(
+	policy?: WorkItemAuthoringPolicy,
+	fields?: readonly string[],
+): Set<string> {
+	return new Set([
+		...executionRelevantDefaults,
+		...(policy?.executionRelevantFields ?? []),
+		...(fields ?? []),
+	]);
+}
+
+function touchesExecutionRelevant<T>(
+	patch: WorkItemPatch<T>,
+	relevantFields: Set<string>,
+): boolean {
+	const paths = patchPaths(patch);
+	for (const path of paths) {
+		if (relevantFields.has(path)) return true;
+	}
+	return false;
+}
+
+function patchPaths<T>(patch: WorkItemPatch<T>): readonly string[] {
+	const paths: string[] = [];
+	for (const [key, value] of Object.entries(patch)) {
+		paths.push(key);
+		if (isRecord(value)) {
+			for (const childKey of Object.keys(value)) paths.push(`${key}.${childKey}`);
+		}
+	}
+	return paths;
+}
diff --git a/packages/ts/src/solutions/work-item/scheduling-constructors.ts b/packages/ts/src/solutions/work-item/scheduling-constructors.ts
new file mode 100644
index 00000000..df26ba54
--- /dev/null
+++ b/packages/ts/src/solutions/work-item/scheduling-constructors.ts
@@ -0,0 +1,88 @@
+import type {
+	AcceptanceCriteriaChanged,
+	AcceptanceCriterion,
+	VerificationPlan,
+	VerificationPlanChanged,
+	WorkItemCreated,
+	WorkItemDraft,
+	WorkItemSpawnProposed,
+} from "./scheduling-types.js";
+
+export function workItemCreatedFromDraft<TInput = unknown>(
+	workItemId: string,
+	draft: WorkItemDraft<TInput>,
+	opts: Partial<Omit<WorkItemCreated<TInput>, "kind" | "eventId" | "workItemId" | "draft">> & {
+		readonly eventId?: string;
+	} = {},
+): WorkItemCreated<TInput> {
+	return {
+		kind: "work-item-created",
+		eventId: opts.eventId ?? `${workItemId}:created`,
+		workItemId,
+		draft,
+		authorId: opts.authorId,
+		createdAtMs: opts.createdAtMs,
+		sourceRefs: opts.sourceRefs,
+		metadata: opts.metadata,
+	};
+}
+
+export function workItemSpawnProposed<TInput = unknown>(
+	proposalId: string,
+	draft: WorkItemDraft<TInput>,
+	opts: Partial<Omit<WorkItemSpawnProposed<TInput>, "kind" | "proposalId" | "draft">> = {},
+): WorkItemSpawnProposed<TInput> {
+	return {
+		kind: "work-item-spawn-proposed",
+		proposalId,
+		draft,
+		proposedWorkItemId: opts.proposedWorkItemId,
+		parentWorkItemId: opts.parentWorkItemId,
+		proposedBy: opts.proposedBy,
+		idempotencyKey: opts.idempotencyKey,
+		sourceRefs: opts.sourceRefs,
+		metadata: opts.metadata,
+	};
+}
+
+export function acceptanceCriteriaChanged(
+	workItemId: string,
+	acceptanceCriteria: readonly AcceptanceCriterion[],
+	opts: Partial<
+		Omit<AcceptanceCriteriaChanged, "kind" | "eventId" | "workItemId" | "acceptanceCriteria">
+	> & {
+		readonly eventId: string;
+	},
+): AcceptanceCriteriaChanged {
+	return {
+		kind: "acceptance-criteria-changed",
+		eventId: opts.eventId,
+		workItemId,
+		acceptanceCriteria,
+		authorId: opts.authorId,
+		changedAtMs: opts.changedAtMs,
+		sourceRefs: opts.sourceRefs,
+		metadata: opts.metadata,
+	};
+}
+
+export function verificationPlanChanged<TInput = unknown>(
+	workItemId: string,
+	verificationPlan: VerificationPlan<TInput>,
+	opts: Partial<
+		Omit<VerificationPlanChanged<TInput>, "kind" | "eventId" | "workItemId" | "verificationPlan">
+	> & {
+		readonly eventId: string;
+	},
+): VerificationPlanChanged<TInput> {
+	return {
+		kind: "verification-plan-changed",
+		eventId: opts.eventId,
+		workItemId,
+		verificationPlan,
+		authorId: opts.authorId,
+		changedAtMs: opts.changedAtMs,
+		sourceRefs: opts.sourceRefs,
+		metadata: opts.metadata,
+	};
+}
diff --git a/packages/ts/src/solutions/work-item/scheduling-effect-plan-helpers.ts b/packages/ts/src/solutions/work-item/scheduling-effect-plan-helpers.ts
new file mode 100644
index 00000000..f76029ca
--- /dev/null
+++ b/packages/ts/src/solutions/work-item/scheduling-effect-plan-helpers.ts
@@ -0,0 +1,137 @@
+import type { WorkItemEffectRequested } from "../../orchestration/work-item-runtime.js";
+import { immutableClone, ref } from "./scheduling-shared.js";
+import type {
+	PlanState,
+	WorkItemEffectPlanAdmitted,
+	WorkItemEffectPlanMember,
+	WorkItemEffectPlanPolicy,
+	WorkItemEffectPlanProposed,
+	WorkItemEffectPlanSnapshot,
+} from "./scheduling-types.js";
+
+export function normalizeEffectPlanSnapshot<T>(
+	proposal: WorkItemEffectPlanProposed<T>,
+	policy?: WorkItemEffectPlanPolicy,
+): WorkItemEffectPlanSnapshot<T> {
+	const joinPolicy = proposal.joinPolicy ?? policy?.joinPolicy ?? "all-required";
+	const members = proposal.members.map((member) =>
+		Object.freeze({
+			...member,
+			goal: immutableClone(member.goal),
+			dependsOnMemberIds: immutableClone(member.dependsOnMemberIds ?? []),
+			contextRefs: immutableClone(member.contextRefs),
+			requirements: immutableClone(member.requirements),
+			capacityHints: immutableClone(member.capacityHints),
+			limits: immutableClone(member.limits),
+			policyRefs: immutableClone(member.policyRefs),
+			sourceRefs: immutableClone(member.sourceRefs),
+			metadata: immutableClone(member.metadata),
+		}),
+	);
+	return Object.freeze({
+		planId: proposal.planId,
+		workItemId: proposal.workItemId,
+		executionInputRevision: proposal.executionInputRevision,
+		members: Object.freeze(members),
+		joinPolicy,
+		limits: immutableClone(proposal.limits),
+		policyRefs: immutableClone(proposal.policyRefs),
+		sourceRefs: immutableClone(proposal.sourceRefs),
+		metadata: immutableClone(proposal.metadata),
+	});
+}
+
+export function requestFromPlanMember<T>(
+	admitted: WorkItemEffectPlanAdmitted<T>,
+	member: WorkItemEffectPlanMember<T>,
+	policy?: WorkItemEffectPlanPolicy,
+): WorkItemEffectRequested<T> {
+	const requestId = `work-item:${admitted.workItemId}:effect-plan:${admitted.executionInputRevision}:${admitted.planId}:${member.memberId}`;
+	const policyRefs =
+		policy?.policyId === undefined
+			? [...(admitted.plan.policyRefs ?? []), ...(member.policyRefs ?? [])]
+			: [
+					...(admitted.plan.policyRefs ?? []),
+					...(member.policyRefs ?? []),
+					ref("work-item-effect-plan-policy", policy.policyId),
+				];
+	return {
+		kind: "work-item-effect-requested",
+		requestId,
+		workItemId: admitted.workItemId,
+		effectRunId: `effect-run:${requestId}`,
+		effectKind: member.effectKind,
+		executionInputRevision: admitted.executionInputRevision,
+		planId: admitted.planId,
+		planMemberId: member.memberId,
+		sourceRefs: [
+			ref("work-item", admitted.workItemId),
+			ref("work-item-revision", `${admitted.workItemId}:${admitted.executionInputRevision}`),
+			ref("work-item-effect-plan", admitted.planId),
+			ref("work-item-effect-plan-member", member.memberId),
+			...(admitted.plan.sourceRefs ?? []),
+			...(member.sourceRefs ?? []),
+		],
+		goal: member.goal,
+		policyRefs: policyRefs.length === 0 ? undefined : policyRefs,
+		limits: member.limits ?? admitted.plan.limits,
+		idempotencyKey:
+			member.idempotencyKey ??
+			`${admitted.workItemId}:effect-plan:${admitted.executionInputRevision}:${admitted.planId}:${member.memberId}`,
+		metadata: {
+			...(member.metadata ?? {}),
+			executionInputRevision: admitted.executionInputRevision,
+			planId: admitted.planId,
+			planMemberId: member.memberId,
+			...(member.contextRefs === undefined ? {} : { contextRefs: member.contextRefs }),
+			...(member.requirements === undefined ? {} : { requirements: member.requirements }),
+			...(member.capacityHints === undefined ? {} : { capacityHints: member.capacityHints }),
+		},
+	};
+}
+
+export function memberSucceeded<T>(
+	state: PlanState<T>,
+	admitted: WorkItemEffectPlanAdmitted<T>,
+	memberId: string,
+): boolean {
+	return state.memberEvidence.get(memberCoord(admitted, memberId))?.status === "completed";
+}
+
+export function memberBlockedByFailure<T>(
+	state: PlanState<T>,
+	admitted: WorkItemEffectPlanAdmitted<T>,
+	memberId: string,
+	seen: Set<string>,
+): boolean {
+	if (seen.has(memberId)) return false;
+	seen.add(memberId);
+	const evidence = state.memberEvidence.get(memberCoord(admitted, memberId));
+	if (evidence !== undefined) return evidence.status !== "completed";
+	const member = admitted.plan.members.find((item) => item.memberId === memberId);
+	return (member?.dependsOnMemberIds ?? []).some((depId) =>
+		memberBlockedByFailure(state, admitted, depId, seen),
+	);
+}
+
+export function memberCoord<T>(admitted: WorkItemEffectPlanAdmitted<T>, memberId: string): string {
+	return `${admitted.workItemId}:${admitted.executionInputRevision}:${admitted.planId}:${memberId}`;
+}
+
+export function planKey(
+	workItemId: string | undefined,
+	planId: string | undefined,
+	executionInputRevision: number | undefined,
+): string | undefined {
+	if (workItemId === undefined || planId === undefined || executionInputRevision === undefined)
+		return undefined;
+	return `${workItemId}:${executionInputRevision}:${planId}`;
+}
+
+export function requiredPlanKey(
+	workItemId: string,
+	planId: string,
+	executionInputRevision: number,
+): string {
+	return `${workItemId}:${executionInputRevision}:${planId}`;
+}
diff --git a/packages/ts/src/solutions/work-item/scheduling-effect-plan-validation.ts b/packages/ts/src/solutions/work-item/scheduling-effect-plan-validation.ts
new file mode 100644
index 00000000..8d3813fa
--- /dev/null
+++ b/packages/ts/src/solutions/work-item/scheduling-effect-plan-validation.ts
@@ -0,0 +1,225 @@
+import type { DataIssue } from "../../data/index.js";
+import { isRecord, issue } from "./scheduling-shared.js";
+import type {
+	WorkItemEffectPlanJoinPolicy,
+	WorkItemEffectPlanMember,
+	WorkItemEffectPlanPolicy,
+	WorkItemEffectPlanProposed,
+	WorkItemProjection,
+} from "./scheduling-types.js";
+
+export function validateWorkItemEffectPlan<TInput>(
+	proposal: WorkItemEffectPlanProposed<TInput> | unknown,
+	workItem: WorkItemProjection<TInput> | undefined,
+	policy: WorkItemEffectPlanPolicy = {},
+): readonly DataIssue[] {
+	const out: DataIssue[] = [];
+	if (
+		!isRecord(proposal) ||
+		proposal.kind !== "work-item-effect-plan-proposed" ||
+		typeof proposal.planId !== "string" ||
+		proposal.planId.trim() === "" ||
+		typeof proposal.workItemId !== "string" ||
+		proposal.workItemId.trim() === "" ||
+		typeof proposal.executionInputRevision !== "number" ||
+		!Array.isArray(proposal.members)
+	) {
+		return [
+			issue(
+				"malformed-draft",
+				"WorkItemEffectPlanProposed requires planId, workItemId, executionInputRevision, and members",
+				isRecord(proposal) && typeof proposal.workItemId === "string"
+					? proposal.workItemId
+					: undefined,
+			),
+		];
+	}
+	if (proposal.joinPolicy !== undefined && !isWorkItemEffectPlanJoinPolicy(proposal.joinPolicy)) {
+		out.push(
+			issue(
+				"policy-mismatch",
+				`Unsupported WorkItemEffectPlan join policy '${proposal.joinPolicy}'`,
+				proposal.workItemId,
+				{ planId: proposal.planId, joinPolicy: proposal.joinPolicy },
+			),
+		);
+	}
+	if (workItem === undefined) {
+		out.push(
+			issue(
+				"dangling-ref",
+				`WorkItemEffectPlan '${proposal.planId}' references unknown WorkItem '${proposal.workItemId}'`,
+				proposal.workItemId,
+				{ planId: proposal.planId },
+			),
+		);
+	} else if (proposal.executionInputRevision !== workItem.executionInputRevision) {
+		out.push(
+			issue(
+				"stale-execution-input",
+				`WorkItemEffectPlan '${proposal.planId}' targets stale execution input`,
+				proposal.workItemId,
+				{
+					planId: proposal.planId,
+					proposedRevision: proposal.executionInputRevision,
+					currentRevision: workItem.executionInputRevision,
+				},
+			),
+		);
+	}
+	const memberIds = new Set<string>();
+	const allowedEffectKinds =
+		policy.allowedEffectKinds === undefined ? undefined : new Set(policy.allowedEffectKinds);
+	for (const member of proposal.members) {
+		if (!isRecord(member)) {
+			out.push(
+				issue(
+					"malformed-draft",
+					"WorkItemEffectPlan member must be an object",
+					proposal.workItemId,
+					{
+						planId: proposal.planId,
+					},
+				),
+			);
+			continue;
+		}
+		if (typeof member.memberId !== "string" || member.memberId.trim() === "") {
+			out.push(
+				issue(
+					"missing-required-field",
+					"WorkItemEffectPlan memberId is required",
+					proposal.workItemId,
+					{ planId: proposal.planId },
+				),
+			);
+			continue;
+		}
+		if (memberIds.has(member.memberId)) {
+			out.push(
+				issue(
+					"duplicate-id",
+					`Duplicate WorkItemEffectPlan member id '${member.memberId}'`,
+					proposal.workItemId,
+					{ planId: proposal.planId, planMemberId: member.memberId },
+				),
+			);
+		}
+		memberIds.add(member.memberId);
+		if (typeof member.effectKind !== "string" || member.effectKind.trim() === "") {
+			out.push(
+				issue(
+					"missing-required-field",
+					"WorkItemEffectPlan member effectKind is required",
+					proposal.workItemId,
+					{ planId: proposal.planId, planMemberId: member.memberId },
+				),
+			);
+		} else if (allowedEffectKinds !== undefined && !allowedEffectKinds.has(member.effectKind)) {
+			out.push(
+				issue(
+					"unsupported-effect-kind",
+					`Unsupported WorkItemEffectPlan effect kind '${member.effectKind}'`,
+					proposal.workItemId,
+					{ planId: proposal.planId, planMemberId: member.memberId },
+				),
+			);
+		}
+		if (!isRecord(member.goal)) {
+			out.push(
+				issue(
+					"missing-required-field",
+					"WorkItemEffectPlan member goal is required",
+					proposal.workItemId,
+					{ planId: proposal.planId, planMemberId: member.memberId },
+				),
+			);
+		}
+		for (const field of [
+			"dependsOnMemberIds",
+			"contextRefs",
+			"requirements",
+			"policyRefs",
+			"sourceRefs",
+		] as const) {
+			if (member[field] !== undefined && !Array.isArray(member[field])) {
+				out.push(
+					issue(
+						"malformed-draft",
+						`WorkItemEffectPlan member ${field} must be an array`,
+						proposal.workItemId,
+						{ planId: proposal.planId, planMemberId: member.memberId, field },
+					),
+				);
+			}
+		}
+	}
+	for (const member of proposal.members) {
+		if (!isRecord(member) || typeof member.memberId !== "string") continue;
+		const deps = Array.isArray(member.dependsOnMemberIds) ? member.dependsOnMemberIds : [];
+		for (const depId of deps) {
+			if (!memberIds.has(depId)) {
+				out.push(
+					issue(
+						"dangling-ref",
+						`Unknown WorkItemEffectPlan dependency '${depId}'`,
+						proposal.workItemId,
+						{ planId: proposal.planId, planMemberId: member.memberId, depId },
+					),
+				);
+			}
+		}
+	}
+	const cycle = findPlanCycle(
+		proposal.members.filter(
+			(member): member is WorkItemEffectPlanMember<TInput> =>
+				isRecord(member) &&
+				typeof member.memberId === "string" &&
+				Array.isArray(member.dependsOnMemberIds),
+		),
+	);
+	if (cycle !== undefined) {
+		out.push(
+			issue(
+				"cyclic-dependency",
+				`WorkItemEffectPlan member cycle detected: ${cycle.join(" -> ")}`,
+				proposal.workItemId,
+				{ planId: proposal.planId, planMemberId: cycle[0] },
+			),
+		);
+	}
+	return out;
+}
+
+function isWorkItemEffectPlanJoinPolicy(value: unknown): value is WorkItemEffectPlanJoinPolicy {
+	return value === "all-required" || value === "evidence-only";
+}
+
+function findPlanCycle<T>(
+	members: readonly WorkItemEffectPlanMember<T>[],
+): readonly string[] | undefined {
+	const byId = new Map(members.map((member) => [member.memberId, member.dependsOnMemberIds ?? []]));
+	const visiting = new Set<string>();
+	const visited = new Set<string>();
+	const stack: string[] = [];
+	const visit = (id: string): readonly string[] | undefined => {
+		if (visiting.has(id)) return [...stack.slice(stack.indexOf(id)), id];
+		if (visited.has(id)) return undefined;
+		visiting.add(id);
+		stack.push(id);
+		for (const dep of byId.get(id) ?? []) {
+			if (!byId.has(dep)) continue;
+			const cycle = visit(dep);
+			if (cycle !== undefined) return cycle;
+		}
+		stack.pop();
+		visiting.delete(id);
+		visited.add(id);
+		return undefined;
+	};
+	for (const member of members) {
+		const cycle = visit(member.memberId);
+		if (cycle !== undefined) return cycle;
+	}
+	return undefined;
+}
diff --git a/packages/ts/src/solutions/work-item/scheduling-effect-plan.ts b/packages/ts/src/solutions/work-item/scheduling-effect-plan.ts
new file mode 100644
index 00000000..543f260a
--- /dev/null
+++ b/packages/ts/src/solutions/work-item/scheduling-effect-plan.ts
@@ -0,0 +1,917 @@
+import { type Ctx, depBatch } from "../../ctx/types.js";
+import type { DataIssue } from "../../data/index.js";
+import type { Graph } from "../../graph/graph.js";
+import type { Node } from "../../node/node.js";
+import type { EffectRunResult } from "../../orchestration/agent-runtime.js";
+import type {
+	WorkItemEffectRequested,
+	WorkItemEvidenceRecorded,
+} from "../../orchestration/work-item-runtime.js";
+import {
+	memberBlockedByFailure,
+	memberCoord,
+	memberSucceeded,
+	normalizeEffectPlanSnapshot,
+	planKey,
+	requestFromPlanMember,
+	requiredPlanKey,
+} from "./scheduling-effect-plan-helpers.js";
+import { validateWorkItemEffectPlan } from "./scheduling-effect-plan-validation.js";
+import {
+	immutableClone,
+	isRecord,
+	issue,
+	numberMetadata,
+	project,
+	sourceRefId,
+	stringMetadata,
+} from "./scheduling-shared.js";
+import type {
+	PlanFact,
+	PlanMemberEvidence,
+	PlanState,
+	WorkItemEffectPlanAdmitted,
+	WorkItemEffectPlanPolicy,
+	WorkItemEffectPlanProjectorBundle,
+	WorkItemEffectPlanProjectorOptions,
+	WorkItemEffectPlanProposed,
+	WorkItemEffectPlanRejected,
+	WorkItemEffectPlanResult,
+	WorkItemEffectPlanResultStatus,
+	WorkItemEffectPlanStatus,
+	WorkItemProjection,
+} from "./scheduling-types.js";
+
+export function workItemEffectPlanProjector<TInput = unknown>(
+	graph: Graph,
+	opts: WorkItemEffectPlanProjectorOptions<TInput>,
+): WorkItemEffectPlanProjectorBundle<TInput> {
+	const name = opts.name ?? "workItemEffectPlans";
+	const deps: Node<unknown>[] = [opts.workItems, opts.proposals];
+	const evidenceIndex = opts.evidence === undefined ? -1 : deps.push(opts.evidence) - 1;
+	const resultIndex =
+		opts.effectRunResults === undefined ? -1 : deps.push(opts.effectRunResults) - 1;
+	const now = opts.now ?? Date.now;
+	const runtime = graph.node<PlanFact<TInput>>(
+		deps,
+		(ctx) => {
+			const state = ctx.state.get<PlanState<TInput>>() ?? emptyPlanState<TInput>();
+			for (const raw of depBatch(ctx, 0) ?? []) {
+				const workItem = raw as WorkItemProjection<TInput>;
+				state.workItems.set(workItem.workItemId, workItem);
+				for (const proposal of state.proposals.values()) {
+					if (proposal.workItemId === workItem.workItemId)
+						admitPlan(ctx, state, proposal, opts.policy, now);
+				}
+			}
+			for (const raw of depBatch(ctx, 1) ?? []) {
+				const proposal = raw as WorkItemEffectPlanProposed<TInput>;
+				if (
+					isRecord(proposal) &&
+					typeof proposal.planId === "string" &&
+					typeof proposal.workItemId === "string"
+				) {
+					const key = planKey(
+						proposal.workItemId,
+						proposal.planId,
+						proposal.executionInputRevision,
+					);
+					if (key !== undefined) state.proposals.set(key, proposal);
+				}
+				admitPlan(ctx, state, proposal, opts.policy, now);
+			}
+			if (evidenceIndex >= 0) {
+				for (const raw of depBatch(ctx, evidenceIndex) ?? [])
+					recordPlanEvidence(ctx, state, raw as WorkItemEvidenceRecorded);
+			}
+			if (resultIndex >= 0) {
+				for (const raw of depBatch(ctx, resultIndex) ?? [])
+					recordPlanResult(ctx, state, raw as EffectRunResult);
+			}
+			drainPlanWork(ctx, state, opts.policy);
+			ctx.state.set(state);
+		},
+		{
+			name: `${name}/runtime`,
+			factory: "workItemEffectPlanProjector",
+			partial: true,
+			completeWhenDepsComplete: false,
+			errorWhenDepsError: false,
+		},
+	);
+	return {
+		admitted: project(graph, runtime, `${name}/admitted`, "workItemEffectPlansAdmitted", (fact) =>
+			fact.kind === "admitted" ? fact.value : undefined,
+		),
+		rejected: project(graph, runtime, `${name}/rejected`, "workItemEffectPlansRejected", (fact) =>
+			fact.kind === "rejected" ? fact.value : undefined,
+		),
+		effectRequests: project(
+			graph,
+			runtime,
+			`${name}/effectRequests`,
+			"workItemEffectPlanEffectRequests",
+			(fact) => (fact.kind === "request" ? fact.value : undefined),
+		),
+		results: project(graph, runtime, `${name}/results`, "workItemEffectPlanResults", (fact) =>
+			fact.kind === "result" ? fact.value : undefined,
+		),
+		status: project(graph, runtime, `${name}/status`, "workItemEffectPlanStatus", (fact) =>
+			fact.kind === "status" ? fact.value : undefined,
+		),
+		issues: project(graph, runtime, `${name}/issues`, "workItemEffectPlanIssues", (fact) =>
+			fact.kind === "issue" ? fact.value : undefined,
+		),
+		audit: project(graph, runtime, `${name}/audit`, "workItemEffectPlanAudit", (fact) =>
+			fact.kind === "audit" ? fact.value : undefined,
+		),
+	};
+}
+
+function emptyPlanState<T>(): PlanState<T> {
+	return {
+		workItems: new Map(),
+		proposals: new Map(),
+		admitted: new Map(),
+		rejected: new Set(),
+		emittedMemberKeys: new Set(),
+		statusKeys: new Set(),
+		resultKeys: new Set(),
+		requestByEffectRun: new Map(),
+		requestByRequestId: new Map(),
+		memberEvidence: new Map(),
+		pendingEvidence: new Map(),
+		pendingResults: new Map(),
+		unmatchedEvidence: new Set(),
+		unmatchedResults: new Set(),
+		statusSeq: 0,
+		auditSeq: 0,
+	};
+}
+
+function admitPlan<T>(
+	ctx: Ctx,
+	state: PlanState<T>,
+	proposal: WorkItemEffectPlanProposed<T>,
+	policy: WorkItemEffectPlanPolicy | undefined,
+	now: () => number,
+): void {
+	if (!isRecord(proposal) || typeof proposal.planId !== "string") {
+		const issues = validateWorkItemEffectPlan(proposal, undefined, policy);
+		emitPlanIssues(ctx, state, issues);
+		return;
+	}
+	const key = planKey(proposal.workItemId, proposal.planId, proposal.executionInputRevision);
+	if (key === undefined) {
+		const issues = validateWorkItemEffectPlan(proposal, undefined, policy);
+		emitPlanIssues(ctx, state, issues);
+		return;
+	}
+	if (state.admitted.has(key) || state.rejected.has(key)) return;
+	const workItem = state.workItems.get(proposal.workItemId);
+	if (workItem === undefined) {
+		emitPlanStatusOnce(ctx, state, `${key}:deferred:missing-work-item`, {
+			workItemId: proposal.workItemId,
+			planId: proposal.planId,
+			executionInputRevision: proposal.executionInputRevision,
+			state: "deferred",
+			message: `WorkItemEffectPlan '${proposal.planId}' is waiting for WorkItem '${proposal.workItemId}'`,
+			sourceRefs: proposal.sourceRefs,
+			metadata: { reason: "missing-work-item" },
+		});
+		return;
+	}
+	const issues = validateWorkItemEffectPlan(proposal, workItem, policy);
+	if (issues.length > 0) {
+		state.rejected.add(key);
+		emitPlanIssues(ctx, state, issues);
+		const rejected: WorkItemEffectPlanRejected = {
+			kind: "work-item-effect-plan-rejected",
+			planId: proposal.planId,
+			workItemId: proposal.workItemId,
+			executionInputRevision: proposal.executionInputRevision,
+			issues,
+			sourceRefs: proposal.sourceRefs,
+			rejectedAtMs: now(),
+			metadata: proposal.metadata,
+		};
+		emitPlan(ctx, "rejected", rejected);
+		emitPlanStatus(ctx, state, {
+			workItemId: proposal.workItemId,
+			planId: proposal.planId,
+			executionInputRevision: proposal.executionInputRevision,
+			state: "rejected",
+			issues,
+			sourceRefs: proposal.sourceRefs,
+			metadata: { issueCodes: issues.map((item) => item.code) },
+		});
+		return;
+	}
+	const snapshot = normalizeEffectPlanSnapshot(proposal, policy);
+	const admitted: WorkItemEffectPlanAdmitted<T> = {
+		kind: "work-item-effect-plan-admitted",
+		planId: snapshot.planId,
+		workItemId: snapshot.workItemId,
+		executionInputRevision: snapshot.executionInputRevision,
+		plan: snapshot,
+		sourceRefs: immutableClone(proposal.sourceRefs),
+		admittedAtMs: now(),
+		metadata: immutableClone(proposal.metadata),
+	};
+	state.admitted.set(key, admitted);
+	emitPlan(ctx, "admitted", admitted);
+	emitPlanStatus(ctx, state, {
+		workItemId: admitted.workItemId,
+		planId: admitted.planId,
+		executionInputRevision: admitted.executionInputRevision,
+		state: "eligible",
+		sourceRefs: admitted.sourceRefs,
+		metadata: { memberCount: admitted.plan.members.length },
+	});
+}
+
+function drainPlanWork<T>(ctx: Ctx, state: PlanState<T>, policy?: WorkItemEffectPlanPolicy): void {
+	const maxPasses =
+		state.admitted.size +
+		state.pendingEvidence.size +
+		state.pendingResults.size +
+		state.emittedMemberKeys.size +
+		1;
+	for (let pass = 0; pass < maxPasses; pass += 1) {
+		let changed = false;
+		for (const admitted of state.admitted.values()) {
+			changed = lowerEligiblePlanMembers(ctx, state, admitted, policy) || changed;
+			derivePlanResult(ctx, state, admitted);
+		}
+		changed = replayPendingPlanFacts(ctx, state) || changed;
+		if (!changed) break;
+	}
+	for (const admitted of state.admitted.values()) derivePlanResult(ctx, state, admitted);
+}
+
+function lowerEligiblePlanMembers<T>(
+	ctx: Ctx,
+	state: PlanState<T>,
+	admitted: WorkItemEffectPlanAdmitted<T>,
+	policy?: WorkItemEffectPlanPolicy,
+): boolean {
+	if (isAdmittedPlanStale(state, admitted)) {
+		emitStaleAdmittedPlanOnce(ctx, state, admitted);
+		return false;
+	}
+	let changed = false;
+	for (const member of admitted.plan.members) {
+		const coord = memberCoord(admitted, member.memberId);
+		if (state.memberEvidence.has(coord)) continue;
+		const missing = (member.dependsOnMemberIds ?? []).filter(
+			(memberId) => !memberSucceeded(state, admitted, memberId),
+		);
+		if (missing.length > 0) {
+			emitPlanStatusOnce(ctx, state, `${coord}:blocked:${missing.join(",")}`, {
+				workItemId: admitted.workItemId,
+				planId: admitted.planId,
+				executionInputRevision: admitted.executionInputRevision,
+				state: "blocked",
+				planMemberId: member.memberId,
+				issues: [
+					issue(
+						"blocked-prerequisite",
+						`WorkItemEffectPlan member '${member.memberId}' is blocked by prerequisites`,
+						admitted.workItemId,
+						{ planId: admitted.planId, planMemberId: member.memberId, missingMemberIds: missing },
+					),
+				],
+				sourceRefs: member.sourceRefs,
+				metadata: { missingMemberIds: missing },
+			});
+			continue;
+		}
+		if (state.emittedMemberKeys.has(coord)) continue;
+		state.emittedMemberKeys.add(coord);
+		changed = true;
+		const request = requestFromPlanMember(admitted, member, policy);
+		state.requestByEffectRun.set(request.effectRunId, request);
+		state.requestByRequestId.set(request.requestId, request);
+		emitPlan(ctx, "request", request);
+		emitPlanStatus(ctx, state, {
+			workItemId: admitted.workItemId,
+			planId: admitted.planId,
+			executionInputRevision: admitted.executionInputRevision,
+			state: "requested",
+			planMemberId: member.memberId,
+			requestId: request.requestId,
+			effectRunId: request.effectRunId,
+			sourceRefs: request.sourceRefs,
+			metadata: { effectKind: request.effectKind },
+		});
+	}
+	return changed;
+}
+
+function recordPlanEvidence<T>(
+	ctx: Ctx,
+	state: PlanState<T>,
+	evidence: WorkItemEvidenceRecorded,
+): boolean {
+	const coordinate = planCoordinateFromEvidence(state, evidence);
+	if (coordinate === undefined) {
+		state.pendingEvidence.set(evidence.evidenceId, evidence);
+		emitUnmatchedEvidence(ctx, state, `evidence:${evidence.evidenceId}`, evidence.workItemId, {
+			evidenceId: evidence.evidenceId,
+			effectRunId: evidence.effectRunId,
+		});
+		return false;
+	}
+	if (emitConflictingPlanEvidenceCoordinate(ctx, state, evidence, coordinate)) return true;
+	const key = requiredPlanKey(
+		coordinate.workItemId,
+		coordinate.planId,
+		coordinate.executionInputRevision,
+	);
+	const admitted = state.admitted.get(key);
+	if (admitted === undefined) {
+		state.pendingEvidence.set(evidence.evidenceId, evidence);
+		emitUnmatchedEvidence(ctx, state, `evidence:${evidence.evidenceId}`, coordinate.workItemId, {
+			evidenceId: evidence.evidenceId,
+			effectRunId: evidence.effectRunId,
+			planId: coordinate.planId,
+			planMemberId: coordinate.planMemberId,
+			executionInputRevision: coordinate.executionInputRevision,
+		});
+		return false;
+	}
+	if (isAdmittedPlanStale(state, admitted)) {
+		emitStaleAdmittedPlanOnce(ctx, state, admitted);
+		return true;
+	}
+	if (!hasPlanMember(admitted, coordinate.planMemberId)) {
+		emitUnknownPlanMember(ctx, state, admitted, coordinate.planMemberId, {
+			evidenceId: evidence.evidenceId,
+			effectRunId: evidence.effectRunId,
+		});
+		return true;
+	}
+	const recorded = recordMemberEvidence(ctx, state, admitted, coordinate.planMemberId, {
+		status: evidence.status,
+		requestId: coordinate.requestId ?? coordinate.request?.requestId,
+		effectRunId: evidence.effectRunId,
+		evidenceId: evidence.evidenceId,
+		effectRunResultId: evidence.effectRunResultId,
+		sourceRefs: evidence.sourceRefs,
+	});
+	if (!recorded) return true;
+	emitPlanStatus(ctx, state, {
+		workItemId: coordinate.workItemId,
+		planId: coordinate.planId,
+		executionInputRevision: coordinate.executionInputRevision,
+		state: evidence.status === "completed" ? "completed" : "failed",
+		planMemberId: coordinate.planMemberId,
+		requestId: coordinate.requestId ?? coordinate.request?.requestId,
+		effectRunId: evidence.effectRunId,
+		evidenceId: evidence.evidenceId,
+		effectRunResultId: evidence.effectRunResultId,
+		sourceRefs: evidence.sourceRefs,
+		metadata: { evidenceStatus: evidence.status },
+	});
+	return true;
+}
+
+function emitConflictingPlanEvidenceCoordinate<T>(
+	ctx: Ctx,
+	state: PlanState<T>,
+	evidence: WorkItemEvidenceRecorded,
+	coordinate: PlanCoordinate<T>,
+): boolean {
+	const expectedRequest = planRequestForCoordinate(state, coordinate);
+	const expectedRequestIdMismatch =
+		expectedRequest !== undefined &&
+		evidence.requestId !== undefined &&
+		evidence.requestId !== expectedRequest.requestId;
+	if (
+		expectedRequest !== undefined &&
+		(expectedRequestIdMismatch || evidence.effectRunId !== expectedRequest.effectRunId)
+	) {
+		emitPlanEvidenceCoordinateMismatch(ctx, state, evidence, coordinate, expectedRequest);
+		return true;
+	}
+	const requestRefs = [
+		evidence.requestId === undefined ? undefined : state.requestByRequestId.get(evidence.requestId),
+		state.requestByEffectRun.get(evidence.effectRunId),
+	].filter((request): request is WorkItemEffectRequested<T> => request !== undefined);
+	const conflicting = requestRefs.find(
+		(request) =>
+			!requestMatchesPlanCoordinate(request, coordinate) ||
+			!requestMatchesEvidenceIdentity(request, evidence),
+	);
+	if (conflicting === undefined) return false;
+	emitPlanEvidenceCoordinateMismatch(ctx, state, evidence, coordinate, conflicting);
+	return true;
+}
+
+function emitPlanEvidenceCoordinateMismatch<T>(
+	ctx: Ctx,
+	state: PlanState<T>,
+	evidence: WorkItemEvidenceRecorded,
+	coordinate: PlanCoordinate<T>,
+	conflicting: WorkItemEffectRequested<T>,
+): void {
+	const item = issue(
+		"dangling-ref",
+		"WorkItemEffectPlan evidence request/effectRun coordinates do not match its plan member coordinates",
+		evidence.workItemId,
+		{
+			evidenceId: evidence.evidenceId,
+			requestId: evidence.requestId,
+			effectRunId: evidence.effectRunId,
+			planId: coordinate.planId,
+			planMemberId: coordinate.planMemberId,
+			executionInputRevision: coordinate.executionInputRevision,
+			requestPlanId: conflicting.planId,
+			requestPlanMemberId: conflicting.planMemberId,
+			requestExecutionInputRevision: conflicting.executionInputRevision,
+		},
+	);
+	emitPlan(ctx, "issue", item);
+	emitPlanStatus(ctx, state, {
+		workItemId: coordinate.workItemId,
+		planId: coordinate.planId,
+		executionInputRevision: coordinate.executionInputRevision,
+		state: "rejected",
+		planMemberId: coordinate.planMemberId,
+		requestId: evidence.requestId,
+		effectRunId: evidence.effectRunId,
+		evidenceId: evidence.evidenceId,
+		issues: [item],
+		sourceRefs: evidence.sourceRefs,
+		metadata: item.metadata,
+	});
+}
+
+function requestMatchesPlanCoordinate<T>(
+	request: WorkItemEffectRequested<T>,
+	coordinate: PlanCoordinate<T>,
+): boolean {
+	return (
+		request.workItemId === coordinate.workItemId &&
+		request.planId === coordinate.planId &&
+		request.planMemberId === coordinate.planMemberId &&
+		request.executionInputRevision === coordinate.executionInputRevision
+	);
+}
+
+function requestMatchesEvidenceIdentity<T>(
+	request: WorkItemEffectRequested<T>,
+	evidence: WorkItemEvidenceRecorded,
+): boolean {
+	return (
+		(evidence.requestId === undefined || evidence.requestId === request.requestId) &&
+		evidence.effectRunId === request.effectRunId
+	);
+}
+
+function planRequestForCoordinate<T>(
+	state: PlanState<T>,
+	coordinate: PlanCoordinate<T>,
+): WorkItemEffectRequested<T> | undefined {
+	for (const request of state.requestByRequestId.values()) {
+		if (requestMatchesPlanCoordinate(request, coordinate)) return request;
+	}
+	return undefined;
+}
+
+function recordPlanResult<T>(ctx: Ctx, state: PlanState<T>, result: EffectRunResult): boolean {
+	const coordinate = planCoordinateFromResult(state, result);
+	if (coordinate === undefined) {
+		state.pendingResults.set(result.resultId, result);
+		emitUnmatchedEvidence(ctx, state, `result:${result.resultId}`, undefined, {
+			effectRunResultId: result.resultId,
+			effectRunId: result.effectRunId,
+		});
+		return false;
+	}
+	const key = requiredPlanKey(
+		coordinate.workItemId,
+		coordinate.planId,
+		coordinate.executionInputRevision,
+	);
+	const admitted = state.admitted.get(key);
+	if (admitted === undefined) {
+		state.pendingResults.set(result.resultId, result);
+		emitUnmatchedEvidence(ctx, state, `result:${result.resultId}`, coordinate.workItemId, {
+			effectRunResultId: result.resultId,
+			effectRunId: result.effectRunId,
+			planId: coordinate.planId,
+			planMemberId: coordinate.planMemberId,
+			executionInputRevision: coordinate.executionInputRevision,
+		});
+		return false;
+	}
+	if (isAdmittedPlanStale(state, admitted)) {
+		emitStaleAdmittedPlanOnce(ctx, state, admitted);
+		return true;
+	}
+	if (!hasPlanMember(admitted, coordinate.planMemberId)) {
+		emitUnknownPlanMember(ctx, state, admitted, coordinate.planMemberId, {
+			effectRunResultId: result.resultId,
+			effectRunId: result.effectRunId,
+		});
+		return true;
+	}
+	const recorded = recordMemberEvidence(ctx, state, admitted, coordinate.planMemberId, {
+		status: result.status,
+		requestId: coordinate.request?.requestId,
+		effectRunId: result.effectRunId,
+		effectRunResultId: result.resultId,
+		sourceRefs: result.sourceRefs,
+	});
+	if (!recorded) return true;
+	emitPlanStatus(ctx, state, {
+		workItemId: coordinate.workItemId,
+		planId: coordinate.planId,
+		executionInputRevision: coordinate.executionInputRevision,
+		state: result.status === "completed" ? "completed" : "failed",
+		planMemberId: coordinate.planMemberId,
+		requestId: coordinate.request?.requestId,
+		effectRunId: result.effectRunId,
+		effectRunResultId: result.resultId,
+		sourceRefs: result.sourceRefs,
+		metadata: { resultStatus: result.status },
+	});
+	return true;
+}
+
+function replayPendingPlanFacts<T>(ctx: Ctx, state: PlanState<T>): boolean {
+	let changed = false;
+	for (const [evidenceId, evidence] of [...state.pendingEvidence]) {
+		if (recordPlanEvidence(ctx, state, evidence)) {
+			state.pendingEvidence.delete(evidenceId);
+			changed = true;
+		}
+	}
+	for (const [resultId, result] of [...state.pendingResults]) {
+		if (recordPlanResult(ctx, state, result)) {
+			state.pendingResults.delete(resultId);
+			changed = true;
+		}
+	}
+	return changed;
+}
+
+interface PlanCoordinate<T> {
+	readonly workItemId: string;
+	readonly planId: string;
+	readonly executionInputRevision: number;
+	readonly planMemberId: string;
+	readonly requestId?: string;
+	readonly request?: WorkItemEffectRequested<T>;
+}
+
+function planCoordinateFromEvidence<T>(
+	state: PlanState<T>,
+	evidence: WorkItemEvidenceRecorded,
+): PlanCoordinate<T> | undefined {
+	const topLevelRequest =
+		evidence.requestId === undefined ? undefined : state.requestByRequestId.get(evidence.requestId);
+	const effectRunRequest = state.requestByEffectRun.get(evidence.effectRunId);
+	if (
+		evidence.planId !== undefined &&
+		evidence.planMemberId !== undefined &&
+		evidence.executionInputRevision !== undefined
+	) {
+		return {
+			workItemId: evidence.workItemId,
+			planId: evidence.planId,
+			executionInputRevision: evidence.executionInputRevision,
+			planMemberId: evidence.planMemberId,
+			requestId: topLevelRequest?.requestId ?? effectRunRequest?.requestId ?? evidence.requestId,
+			request: topLevelRequest ?? effectRunRequest,
+		};
+	}
+	const request = effectRunRequest;
+	if (
+		request?.planId !== undefined &&
+		request.planMemberId !== undefined &&
+		request.executionInputRevision !== undefined
+	) {
+		return {
+			workItemId: request.workItemId,
+			planId: request.planId,
+			executionInputRevision: request.executionInputRevision,
+			planMemberId: request.planMemberId,
+			requestId: request.requestId,
+			request,
+		};
+	}
+	const planId = stringMetadata(evidence.metadata, "planId");
+	const planMemberId = stringMetadata(evidence.metadata, "planMemberId");
+	const executionInputRevision = numberMetadata(evidence.metadata, "executionInputRevision");
+	const requestId = stringMetadata(evidence.metadata, "requestId");
+	if (planId === undefined || planMemberId === undefined || executionInputRevision === undefined)
+		return undefined;
+	return {
+		workItemId: evidence.workItemId,
+		planId,
+		executionInputRevision,
+		planMemberId,
+		requestId,
+	};
+}
+
+function planCoordinateFromResult<T>(
+	state: PlanState<T>,
+	result: EffectRunResult,
+): PlanCoordinate<T> | undefined {
+	const request = state.requestByEffectRun.get(result.effectRunId);
+	if (
+		request?.planId !== undefined &&
+		request.planMemberId !== undefined &&
+		request.executionInputRevision !== undefined
+	) {
+		return {
+			workItemId: request.workItemId,
+			planId: request.planId,
+			executionInputRevision: request.executionInputRevision,
+			planMemberId: request.planMemberId,
+			requestId: request.requestId,
+			request,
+		};
+	}
+	const workItemId =
+		sourceRefId(result.subjectRefs, "work-item") ?? sourceRefId(result.sourceRefs, "work-item");
+	const planId = stringMetadata(result.metadata, "planId");
+	const planMemberId = stringMetadata(result.metadata, "planMemberId");
+	const executionInputRevision = numberMetadata(result.metadata, "executionInputRevision");
+	if (
+		workItemId === undefined ||
+		planId === undefined ||
+		planMemberId === undefined ||
+		executionInputRevision === undefined
+	)
+		return undefined;
+	return { workItemId, planId, executionInputRevision, planMemberId };
+}
+
+function recordMemberEvidence<T>(
+	ctx: Ctx,
+	state: PlanState<T>,
+	admitted: WorkItemEffectPlanAdmitted<T>,
+	planMemberId: string,
+	evidence: PlanMemberEvidence,
+): boolean {
+	const coord = memberCoord(admitted, planMemberId);
+	const existing = state.memberEvidence.get(coord);
+	if (existing !== undefined) {
+		const duplicateIssue = issue(
+			"duplicate-suppressed",
+			`WorkItemEffectPlan member '${planMemberId}' already has terminal evidence`,
+			admitted.workItemId,
+			{
+				planId: admitted.planId,
+				planMemberId,
+				existingEvidenceId: existing.evidenceId,
+				existingEffectRunResultId: existing.effectRunResultId,
+				evidenceId: evidence.evidenceId,
+				effectRunResultId: evidence.effectRunResultId,
+			},
+		);
+		emitPlan(ctx, "issue", duplicateIssue);
+		emitPlanStatus(ctx, state, {
+			workItemId: admitted.workItemId,
+			planId: admitted.planId,
+			executionInputRevision: admitted.executionInputRevision,
+			state: "duplicate",
+			planMemberId,
+			requestId: evidence.requestId,
+			effectRunId: evidence.effectRunId,
+			evidenceId: evidence.evidenceId,
+			effectRunResultId: evidence.effectRunResultId,
+			issues: [duplicateIssue],
+			sourceRefs: evidence.sourceRefs,
+		});
+		return false;
+	}
+	state.memberEvidence.set(coord, evidence);
+	return true;
+}
+
+function hasPlanMember<T>(admitted: WorkItemEffectPlanAdmitted<T>, planMemberId: string): boolean {
+	return admitted.plan.members.some((member) => member.memberId === planMemberId);
+}
+
+function isAdmittedPlanStale<T>(
+	state: PlanState<T>,
+	admitted: WorkItemEffectPlanAdmitted<T>,
+): boolean {
+	const current = state.workItems.get(admitted.workItemId);
+	return (
+		current !== undefined && current.executionInputRevision !== admitted.executionInputRevision
+	);
+}
+
+function emitStaleAdmittedPlanOnce<T>(
+	ctx: Ctx,
+	state: PlanState<T>,
+	admitted: WorkItemEffectPlanAdmitted<T>,
+): void {
+	const current = state.workItems.get(admitted.workItemId);
+	emitPlanStatusOnce(ctx, state, `${memberCoord(admitted, "plan")}:stale`, {
+		workItemId: admitted.workItemId,
+		planId: admitted.planId,
+		executionInputRevision: admitted.executionInputRevision,
+		state: "stale",
+		issues: [
+			issue(
+				"stale-execution-input",
+				`WorkItemEffectPlan '${admitted.planId}' targets stale execution input`,
+				admitted.workItemId,
+				{
+					planId: admitted.planId,
+					proposedRevision: admitted.executionInputRevision,
+					currentRevision: current?.executionInputRevision,
+				},
+			),
+		],
+		sourceRefs: admitted.sourceRefs,
+		metadata: { currentRevision: current?.executionInputRevision },
+	});
+}
+
+function emitUnknownPlanMember<T>(
+	ctx: Ctx,
+	state: PlanState<T>,
+	admitted: WorkItemEffectPlanAdmitted<T>,
+	planMemberId: string,
+	metadata: Record<string, unknown>,
+): void {
+	const item = issue(
+		"dangling-ref",
+		`WorkItemEffectPlan evidence/result references unknown member '${planMemberId}'`,
+		admitted.workItemId,
+		{ planId: admitted.planId, planMemberId, ...metadata },
+	);
+	emitPlan(ctx, "issue", item);
+	emitPlanStatus(ctx, state, {
+		workItemId: admitted.workItemId,
+		planId: admitted.planId,
+		executionInputRevision: admitted.executionInputRevision,
+		state: "rejected",
+		planMemberId,
+		issues: [item],
+		sourceRefs: admitted.sourceRefs,
+		metadata,
+	});
+}
+
+function emitUnmatchedEvidence<T>(
+	ctx: Ctx,
+	state: PlanState<T>,
+	key: string,
+	workItemId: string | undefined,
+	metadata: Record<string, unknown>,
+): void {
+	const seen = key.startsWith("evidence:") ? state.unmatchedEvidence : state.unmatchedResults;
+	if (seen.has(key)) return;
+	seen.add(key);
+	const item = issue(
+		"dangling-ref",
+		"WorkItemEffectPlan evidence/result could not be joined to an admitted plan member",
+		workItemId,
+		metadata,
+	);
+	emitPlan(ctx, "issue", item);
+	emitPlanStatus(ctx, state, {
+		workItemId: workItemId ?? "unknown",
+		planId: typeof metadata.planId === "string" ? metadata.planId : "unknown",
+		executionInputRevision:
+			typeof metadata.executionInputRevision === "number" ? metadata.executionInputRevision : 0,
+		state: "deferred",
+		issues: [item],
+		metadata,
+	});
+}
+
+function derivePlanResult<T>(
+	ctx: Ctx,
+	state: PlanState<T>,
+	admitted: WorkItemEffectPlanAdmitted<T>,
+): void {
+	const requiredMembers = admitted.plan.members.filter((member) => member.required !== false);
+	if (requiredMembers.length === 0) return;
+	const memberResults: WorkItemEffectPlanResult["memberResults"][number][] = [];
+	for (const member of admitted.plan.members) {
+		const evidence = state.memberEvidence.get(memberCoord(admitted, member.memberId));
+		if (evidence === undefined) continue;
+		memberResults.push({
+			planMemberId: member.memberId,
+			status: evidence.status,
+			requestId: evidence.requestId,
+			effectRunId: evidence.effectRunId,
+			evidenceId: evidence.evidenceId,
+			effectRunResultId: evidence.effectRunResultId,
+		});
+	}
+	const hasRequiredFailed = requiredMembers.some((member) => {
+		const evidence = state.memberEvidence.get(memberCoord(admitted, member.memberId));
+		return evidence !== undefined && evidence.status !== "completed";
+	});
+	const settledRequiredCount = requiredMembers.filter((member) =>
+		state.memberEvidence.has(memberCoord(admitted, member.memberId)),
+	).length;
+	const allRequiredSettled = settledRequiredCount === requiredMembers.length;
+	const requiredBlockedByFailure = requiredMembers.some((member) =>
+		memberBlockedByFailure(state, admitted, member.memberId, new Set()),
+	);
+	if (!hasRequiredFailed && !allRequiredSettled && !requiredBlockedByFailure) return;
+	const status: WorkItemEffectPlanResultStatus =
+		admitted.plan.joinPolicy === "evidence-only"
+			? "evidence-only"
+			: hasRequiredFailed || requiredBlockedByFailure
+				? "failed"
+				: "succeeded";
+	const key = memberCoord(admitted, "result");
+	if (state.resultKeys.has(key)) return;
+	state.resultKeys.add(key);
+	const result: WorkItemEffectPlanResult = {
+		kind: "work-item-effect-plan-result",
+		resultId: `work-item-effect-plan-result:${admitted.workItemId}:${admitted.executionInputRevision}:${admitted.planId}`,
+		workItemId: admitted.workItemId,
+		planId: admitted.planId,
+		executionInputRevision: admitted.executionInputRevision,
+		status,
+		memberResults,
+		sourceRefs: admitted.sourceRefs,
+	};
+	emitPlan(ctx, "result", result);
+	emitPlanStatus(ctx, state, {
+		workItemId: admitted.workItemId,
+		planId: admitted.planId,
+		executionInputRevision: admitted.executionInputRevision,
+		state: status === "succeeded" || status === "evidence-only" ? "completed" : "failed",
+		sourceRefs: admitted.sourceRefs,
+		metadata: { resultId: result.resultId, resultStatus: status },
+	});
+}
+
+function emitPlanIssues<T>(ctx: Ctx, state: PlanState<T>, issues: readonly DataIssue[]): void {
+	for (const item of issues) emitPlan(ctx, "issue", item);
+	if (issues.length > 0) {
+		state.auditSeq += 1;
+		emitPlan(ctx, "audit", {
+			id: `work-item-effect-plan-issue:${state.auditSeq}`,
+			kind: "work-item-effect-plan-issue",
+			subjectId: issues[0]?.subjectId,
+			message: issues[0]?.message,
+			issueCode: issues[0]?.code,
+			metadata: { issueCodes: issues.map((item) => item.code) },
+		});
+	}
+}
+
+function emitPlanStatusOnce<T>(
+	ctx: Ctx,
+	state: PlanState<T>,
+	key: string,
+	status: Omit<WorkItemEffectPlanStatus, "kind" | "statusId">,
+): void {
+	if (state.statusKeys.has(key)) return;
+	state.statusKeys.add(key);
+	emitPlanStatus(ctx, state, status);
+}
+
+function emitPlanStatus<T>(
+	ctx: Ctx,
+	state: PlanState<T>,
+	status: Omit<WorkItemEffectPlanStatus, "kind" | "statusId">,
+): void {
+	state.statusSeq += 1;
+	const statusFact = {
+		kind: "work-item-effect-plan-status",
+		statusId: `work-item-effect-plan-status:${state.statusSeq}`,
+		...status,
+	} satisfies WorkItemEffectPlanStatus;
+	emitPlan(ctx, "status", statusFact);
+	state.auditSeq += 1;
+	emitPlan(ctx, "audit", {
+		id: `work-item-effect-plan-status:${state.auditSeq}`,
+		kind: "work-item-effect-plan-status",
+		subjectId: status.workItemId,
+		message: status.message,
+		sourceRefs: status.sourceRefs,
+		metadata: {
+			statusId: statusFact.statusId,
+			state: status.state,
+			planId: status.planId,
+			planMemberId: status.planMemberId,
+			executionInputRevision: status.executionInputRevision,
+			...(status.metadata ?? {}),
+		},
+	});
+}
+
+function emitPlan<T, K extends PlanFact<T>["kind"]>(
+	ctx: Ctx,
+	kind: K,
+	value: Extract<PlanFact<T>, { kind: K }>["value"],
+): void {
+	ctx.down([["DATA", { kind, value } as PlanFact<T>]]);
+}
diff --git a/packages/ts/src/solutions/work-item/scheduling-shared.ts b/packages/ts/src/solutions/work-item/scheduling-shared.ts
new file mode 100644
index 00000000..127ce514
--- /dev/null
+++ b/packages/ts/src/solutions/work-item/scheduling-shared.ts
@@ -0,0 +1,181 @@
+import { type Ctx, depBatch } from "../../ctx/types.js";
+import type { DataIssue } from "../../data/index.js";
+import type { Graph } from "../../graph/graph.js";
+import type { Node } from "../../node/node.js";
+import type { EffectRunGoal, SourceRef } from "../../orchestration/agent-runtime.js";
+import type {
+	Fact,
+	VerificationPlan,
+	VerificationStep,
+	WorkItemDraft,
+	WorkItemValidationIssueCode,
+	WorkItemValidationStatus,
+} from "./scheduling-types.js";
+
+export function emitAudit(
+	ctx: Ctx,
+	state: { auditSeq: number },
+	kind: string,
+	status: WorkItemValidationStatus,
+): void {
+	state.auditSeq += 1;
+	emit(ctx, "audit", {
+		id: `${kind}:${state.auditSeq}`,
+		kind,
+		subjectId: status.workItemId,
+		message: status.message,
+		issueCode: status.code,
+		sourceRefs: status.sourceRefs,
+		metadata: {
+			statusId: status.statusId,
+			state: status.state,
+			revision: status.revision,
+			executionInputRevision: status.executionInputRevision,
+			...(status.metadata ?? {}),
+		},
+	});
+}
+
+export function project<TFact, TSelected>(
+	graph: Graph,
+	runtime: Node<TFact>,
+	name: string,
+	factory: string,
+	select: (fact: TFact) => TSelected | undefined,
+): Node<TSelected> {
+	return graph.node<TSelected>(
+		[runtime],
+		(ctx) => {
+			for (const raw of depBatch(ctx, 0) ?? []) {
+				const selected = select(raw as TFact);
+				if (selected !== undefined) ctx.down([["DATA", selected]]);
+			}
+		},
+		{ name, factory, partial: true, completeWhenDepsComplete: false, errorWhenDepsError: false },
+	);
+}
+
+export function emit<T, K extends Fact<T>["kind"]>(
+	ctx: Ctx,
+	kind: K,
+	value: Extract<Fact<T>, { kind: K }>["value"],
+): void {
+	ctx.down([["DATA", { kind, value } as Fact<T>]]);
+}
+
+export function normalizePlan<T>(
+	draft: Pick<WorkItemDraft<T>, "verificationPlan" | "verificationSteps">,
+): VerificationPlan<T> | undefined {
+	if (draft.verificationPlan !== undefined) return draft.verificationPlan;
+	if (draft.verificationSteps !== undefined)
+		return { planId: "default", steps: draft.verificationSteps };
+	return undefined;
+}
+
+export function normalizePlanFromUnknown<T>(
+	draft: Record<string, unknown>,
+): VerificationPlan<T> | undefined {
+	const verificationPlan = draft.verificationPlan;
+	if (verificationPlan !== undefined) {
+		if (!isRecord(verificationPlan) || !Array.isArray(verificationPlan.steps)) {
+			return { planId: "malformed", steps: [] };
+		}
+		return verificationPlan as unknown as VerificationPlan<T>;
+	}
+	const verificationSteps = draft.verificationSteps;
+	if (verificationSteps !== undefined) {
+		if (!Array.isArray(verificationSteps)) return { planId: "malformed", steps: [] };
+		return { planId: "default", steps: verificationSteps as readonly VerificationStep<T>[] };
+	}
+	return undefined;
+}
+
+export function isVerificationPlanShape(value: unknown): value is VerificationPlan {
+	return isRecord(value) && typeof value.planId === "string" && Array.isArray(value.steps);
+}
+
+export function immutableClone<T>(value: T): T {
+	if (Array.isArray(value)) return Object.freeze(value.map((item) => immutableClone(item))) as T;
+	if (!isRecord(value)) return value;
+	const out: Record<string, unknown> = {};
+	for (const [key, child] of Object.entries(value)) out[key] = immutableClone(child);
+	return Object.freeze(out) as T;
+}
+
+export function stringMetadata(
+	metadata: Record<string, unknown> | undefined,
+	key: string,
+): string | undefined {
+	const value = metadata?.[key];
+	return typeof value === "string" && value !== "" ? value : undefined;
+}
+
+export function numberMetadata(
+	metadata: Record<string, unknown> | undefined,
+	key: string,
+): number | undefined {
+	const value = metadata?.[key];
+	return typeof value === "number" ? value : undefined;
+}
+
+export function sourceRefId(
+	refs: readonly SourceRef[] | undefined,
+	kind: string,
+): string | undefined {
+	return refs?.find((sourceRef) => sourceRef.kind === kind)?.id;
+}
+
+export function goalWithInlineInput<T>(
+	goal: EffectRunGoal<T>,
+	input: T | undefined,
+	inputId: string,
+	inputKind: string,
+	subjectRefs: readonly SourceRef[] | undefined,
+): EffectRunGoal<T> {
+	if (input === undefined || goal.input !== undefined) return goal;
+	return {
+		...goal,
+		input: {
+			inputId,
+			inputKind,
+			dataMode: "inline",
+			value: input,
+			subjectRefs,
+		},
+	};
+}
+
+export function issue(
+	code: WorkItemValidationIssueCode,
+	message: string,
+	workItemId?: string,
+	metadata?: Record<string, unknown>,
+): DataIssue {
+	return {
+		kind: "issue",
+		code,
+		message,
+		severity: "error",
+		source: "work-item-scheduling",
+		subjectId: workItemId,
+		metadata,
+	};
+}
+
+export function refs(kind: string, id: string, rest?: readonly SourceRef[]): readonly SourceRef[] {
+	return [ref(kind, id), ...(rest ?? [])];
+}
+
+export function ref(kind: string, id: string): SourceRef {
+	return { kind, id };
+}
+
+export function stringArray(value: unknown): readonly string[] {
+	return Array.isArray(value)
+		? value.filter((item): item is string => typeof item === "string")
+		: [];
+}
+
+export function isRecord(value: unknown): value is Record<string, unknown> {
+	return value !== null && typeof value === "object";
+}
diff --git a/packages/ts/src/solutions/work-item/scheduling-types.ts b/packages/ts/src/solutions/work-item/scheduling-types.ts
new file mode 100644
index 00000000..dced4954
--- /dev/null
+++ b/packages/ts/src/solutions/work-item/scheduling-types.ts
@@ -0,0 +1,612 @@
+import type { DataIssue } from "../../data/index.js";
+import type { Node } from "../../node/node.js";
+import type {
+	AgentOutputEnvelope,
+	AgentRuntimeAuditRecord,
+	EffectRunGoal,
+	EffectRunLimits,
+	EffectRunResult,
+	EffectRunResultStatus,
+	SourceRef,
+} from "../../orchestration/agent-runtime.js";
+import type {
+	WorkItemDomainActionProposal,
+	WorkItemDomainActionProposalSpec,
+	WorkItemEffectRequested,
+	WorkItemEvidenceRecorded,
+} from "../../orchestration/work-item-runtime.js";
+
+export type WorkItemValidationIssueCode =
+	| "malformed-draft"
+	| "missing-required-field"
+	| "invalid-patch"
+	| "duplicate-id"
+	| "dangling-ref"
+	| "cyclic-dependency"
+	| "unsupported-mode"
+	| "unsupported-effect-kind"
+	| "oversized-inline-data"
+	| "policy-mismatch"
+	| "missing-policy"
+	| "stale-revision"
+	| "stale-execution-input"
+	| "blocked-prerequisite"
+	| "verification-unplanned"
+	| "manual-review-required"
+	| "duplicate-suppressed"
+	| "ambiguous-coverage"
+	| "partial-coverage"
+	| "unverifiable-output"
+	| "unauthorized-author"
+	| "unauthorized-target"
+	| "invalid-schedule";
+
+export type WorkItemValidationStatusState =
+	| "projected"
+	| "rejected"
+	| "deferred"
+	| "blocked"
+	| "needs-human-review"
+	| "stale"
+	| "duplicate"
+	| "request-emitted"
+	| "result-recorded"
+	| "domain-action-proposed";
+
+export interface WorkItemValidationStatus {
+	readonly kind: "work-item-validation-status";
+	readonly statusId: string;
+	readonly workItemId?: string;
+	readonly state: WorkItemValidationStatusState;
+	readonly code?: WorkItemValidationIssueCode;
+	readonly revision?: number;
+	readonly executionInputRevision?: number;
+	readonly policyRefs?: readonly SourceRef[];
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly stepId?: string;
+	readonly criterionId?: string;
+	readonly message?: string;
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface AcceptanceCriterion {
+	readonly criterionId: string;
+	readonly statement: string;
+	readonly required?: boolean;
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly metadata?: Record<string, unknown>;
+}
+
+export type VerificationStepMode = "auto" | "manual" | "hybrid";
+
+export interface VerificationStep<TInput = unknown> {
+	readonly stepId: string;
+	readonly title?: string;
+	readonly description?: string;
+	readonly verifiesCriteriaIds?: readonly string[];
+	readonly mode: VerificationStepMode;
+	readonly effectKind?: string;
+	readonly goal?: EffectRunGoal<TInput>;
+	readonly input?: TInput;
+	readonly contextRefs?: readonly SourceRef[];
+	readonly requirements?: readonly string[];
+	readonly capacityHints?: Record<string, unknown>;
+	readonly dependsOnStepIds?: readonly string[];
+	readonly policyRefs?: readonly SourceRef[];
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface VerificationPlan<TInput = unknown> {
+	readonly planId: string;
+	readonly planRevision?: string | number;
+	readonly steps: readonly VerificationStep<TInput>[];
+	readonly policyRefs?: readonly SourceRef[];
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface WorkItemDraft<TInput = unknown> {
+	readonly summary: string;
+	readonly detail?: string;
+	readonly detailRefs?: readonly SourceRef[];
+	readonly acceptanceCriteria?: readonly AcceptanceCriterion[];
+	readonly verificationPlan?: VerificationPlan<TInput>;
+	readonly verificationSteps?: readonly VerificationStep<TInput>[];
+	readonly kind?: string;
+	readonly priority?: number;
+	readonly tags?: readonly string[];
+	readonly owner?: string;
+	readonly assignee?: string;
+	readonly deadlineMs?: number;
+	readonly customFields?: Record<string, unknown>;
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly metadata?: Record<string, unknown>;
+}
+
+export type WorkItemPatch<TInput = unknown> = Partial<WorkItemDraft<TInput>>;
+
+export interface WorkItemCreated<TInput = unknown> {
+	readonly kind: "work-item-created";
+	readonly eventId: string;
+	readonly workItemId: string;
+	readonly draft: WorkItemDraft<TInput>;
+	readonly authorId?: string;
+	readonly createdAtMs?: number;
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface WorkItemPatched<TInput = unknown> {
+	readonly kind: "work-item-patched";
+	readonly eventId: string;
+	readonly workItemId: string;
+	readonly patch: WorkItemPatch<TInput>;
+	readonly executionRelevantFields?: readonly string[];
+	readonly authorId?: string;
+	readonly patchedAtMs?: number;
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface AcceptanceCriteriaChanged {
+	readonly kind: "acceptance-criteria-changed";
+	readonly eventId: string;
+	readonly workItemId: string;
+	readonly acceptanceCriteria: readonly AcceptanceCriterion[];
+	readonly authorId?: string;
+	readonly changedAtMs?: number;
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface VerificationPlanChanged<TInput = unknown> {
+	readonly kind: "verification-plan-changed";
+	readonly eventId: string;
+	readonly workItemId: string;
+	readonly verificationPlan: VerificationPlan<TInput>;
+	readonly authorId?: string;
+	readonly changedAtMs?: number;
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly metadata?: Record<string, unknown>;
+}
+
+export type WorkItemAuthoringFact<TInput = unknown> =
+	| WorkItemCreated<TInput>
+	| WorkItemPatched<TInput>
+	| AcceptanceCriteriaChanged
+	| VerificationPlanChanged<TInput>;
+
+export interface WorkItemSpawnProposed<TInput = unknown> {
+	readonly kind: "work-item-spawn-proposed";
+	readonly proposalId: string;
+	readonly proposedWorkItemId?: string;
+	readonly parentWorkItemId?: string;
+	readonly draft: WorkItemDraft<TInput>;
+	readonly proposedBy?: string;
+	readonly idempotencyKey?: string;
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly metadata?: Record<string, unknown>;
+}
+
+export type WorkItemAuthoringInput<TInput = unknown> =
+	| WorkItemAuthoringFact<TInput>
+	| WorkItemSpawnProposed<TInput>;
+
+export interface WorkItemProjection<TInput = unknown> extends WorkItemDraft<TInput> {
+	readonly workItemId: string;
+	readonly authoringRevision: number;
+	readonly executionInputRevision: number;
+	readonly lastEventId: string;
+	readonly revisionSourceRefs?: readonly SourceRef[];
+	readonly createdAtMs?: number;
+	readonly updatedAtMs?: number;
+}
+
+export interface WorkItemPriorityAssessment {
+	readonly kind: "work-item-priority-assessment";
+	readonly assessmentId: string;
+	readonly workItemId: string;
+	readonly authoringRevision?: number;
+	readonly executionInputRevision?: number;
+	readonly priority?: number;
+	readonly rank?: number;
+	readonly reason?: string;
+	readonly policyRefs?: readonly SourceRef[];
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface WorkItemPlacementDecision {
+	readonly kind: "work-item-placement-decision";
+	readonly decisionId: string;
+	readonly workItemId: string;
+	readonly authoringRevision?: number;
+	readonly executionInputRevision?: number;
+	readonly laneId: string;
+	readonly targetKind?: string;
+	readonly reason?: string;
+	readonly policyRefs?: readonly SourceRef[];
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface WorkItemScheduleDecision {
+	readonly kind: "work-item-schedule-decision";
+	readonly decisionId: string;
+	readonly workItemId: string;
+	readonly authoringRevision?: number;
+	readonly executionInputRevision?: number;
+	readonly targetKind: "work-item-effect" | "work-queue" | "executor" | "status";
+	readonly effectKind?: string;
+	readonly notBeforeMs?: number;
+	readonly deadlineMs?: number;
+	readonly requirements?: readonly string[];
+	readonly capacityHints?: Record<string, unknown>;
+	readonly reason?: string;
+	readonly policyRefs?: readonly SourceRef[];
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface WorkItemDispatchIntent<TInput = unknown> {
+	readonly kind: "work-item-dispatch-intent";
+	readonly intentId: string;
+	readonly workItemId: string;
+	readonly authoringRevision?: number;
+	readonly executionInputRevision: number;
+	readonly targetKind:
+		| "verification"
+		| "approval"
+		| "human-review"
+		| "external-sync"
+		| "spawn-review"
+		| "background-evidence"
+		| "executor";
+	readonly effectKind?: string;
+	readonly stepIds?: readonly string[];
+	readonly acceptanceCriterionIds?: readonly string[];
+	readonly goal?: EffectRunGoal<TInput>;
+	readonly contextRefs?: readonly SourceRef[];
+	readonly requirements?: readonly string[];
+	readonly capacityHints?: Record<string, unknown>;
+	readonly limits?: EffectRunLimits;
+	readonly idempotencyKey?: string;
+	readonly reason?: string;
+	readonly policyRefs?: readonly SourceRef[];
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface WorkItemAuthoringPolicy {
+	readonly executionRelevantFields?: readonly string[];
+}
+
+export interface WorkItemAuthoringProjectorOptions<TInput = unknown> {
+	readonly name?: string;
+	readonly facts: Node<WorkItemAuthoringInput<TInput>>;
+	readonly policy?: WorkItemAuthoringPolicy;
+}
+
+export interface WorkItemAuthoringProjectorBundle<TInput = unknown> {
+	readonly workItems: Node<WorkItemProjection<TInput>>;
+	readonly status: Node<WorkItemValidationStatus>;
+	readonly issues: Node<DataIssue>;
+	readonly audit: Node<AgentRuntimeAuditRecord>;
+}
+
+export interface WorkItemVerificationLowererPolicy {
+	readonly policyId?: string;
+	readonly autoRun?: boolean;
+	readonly allowedModes?: readonly VerificationStepMode[];
+	readonly allowedEffectKinds?: readonly string[];
+	readonly stalePolicy?: "cancel" | "reschedule" | "requeue" | "replacement-intent" | "review";
+}
+
+export interface WorkItemVerificationRequestLowererOptions<TInput = unknown> {
+	readonly name?: string;
+	readonly workItems: Node<WorkItemProjection<TInput>>;
+	readonly dispatchIntents?: Node<WorkItemDispatchIntent<TInput>>;
+	readonly verificationResults?: Node<VerificationResultRecorded>;
+	readonly policy?: WorkItemVerificationLowererPolicy;
+}
+
+export interface WorkItemVerificationRequestLowererBundle<TInput = unknown> {
+	readonly effectRequests: Node<WorkItemEffectRequested<TInput>>;
+	readonly status: Node<WorkItemValidationStatus>;
+	readonly issues: Node<DataIssue>;
+	readonly audit: Node<AgentRuntimeAuditRecord>;
+}
+
+export type VerificationResultStatus =
+	| "passed"
+	| "failed"
+	| "blocked"
+	| "canceled"
+	| "timeout"
+	| "waived"
+	| "unverifiable";
+
+export interface VerificationResultRecorded {
+	readonly kind: "verification-result-recorded";
+	readonly resultId: string;
+	readonly workItemId: string;
+	readonly evidenceId: string;
+	readonly effectRunId: string;
+	readonly effectRunResultId: string;
+	readonly executionInputRevision: number;
+	readonly verificationStepIds: readonly string[];
+	readonly acceptanceCriterionIds: readonly string[];
+	readonly status: VerificationResultStatus;
+	readonly output?: AgentOutputEnvelope;
+	readonly error?: DataIssue;
+	readonly reason?: string;
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly policyRefs?: readonly SourceRef[];
+	readonly recordedAtMs?: number;
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface WorkItemVerificationMappingPolicy {
+	readonly kind: "work-item-verification-mapping-policy";
+	readonly policyId: string;
+	readonly actionProposals?: readonly WorkItemDomainActionProposalSpec[];
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface WorkItemVerificationResultMapperOptions<TInput = unknown> {
+	readonly name?: string;
+	readonly workItems: Node<WorkItemProjection<TInput>>;
+	readonly evidence: Node<WorkItemEvidenceRecorded>;
+	readonly policies?: Node<WorkItemVerificationMappingPolicy>;
+}
+
+export interface WorkItemVerificationResultMapperBundle {
+	readonly results: Node<VerificationResultRecorded>;
+	readonly proposals: Node<WorkItemDomainActionProposal>;
+	readonly status: Node<WorkItemValidationStatus>;
+	readonly issues: Node<DataIssue>;
+	readonly audit: Node<AgentRuntimeAuditRecord>;
+}
+
+export type WorkItemEffectPlanJoinPolicy = "all-required" | "evidence-only";
+
+export interface WorkItemEffectPlanMember<TInput = unknown> {
+	readonly memberId: string;
+	readonly effectKind: string;
+	readonly goal: EffectRunGoal<TInput>;
+	readonly required?: boolean;
+	readonly dependsOnMemberIds?: readonly string[];
+	readonly contextRefs?: readonly SourceRef[];
+	readonly requirements?: readonly string[];
+	readonly capacityHints?: Record<string, unknown>;
+	readonly limits?: EffectRunLimits;
+	readonly policyRefs?: readonly SourceRef[];
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly idempotencyKey?: string;
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface WorkItemEffectPlanProposed<TInput = unknown> {
+	readonly kind: "work-item-effect-plan-proposed";
+	readonly planId: string;
+	readonly workItemId: string;
+	readonly executionInputRevision: number;
+	readonly members: readonly WorkItemEffectPlanMember<TInput>[];
+	readonly joinPolicy?: WorkItemEffectPlanJoinPolicy;
+	readonly limits?: EffectRunLimits;
+	readonly policyRefs?: readonly SourceRef[];
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly proposedBy?: string;
+	readonly proposedAtMs?: number;
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface WorkItemEffectPlanSnapshot<TInput = unknown> {
+	readonly planId: string;
+	readonly workItemId: string;
+	readonly executionInputRevision: number;
+	readonly members: readonly WorkItemEffectPlanMember<TInput>[];
+	readonly joinPolicy: WorkItemEffectPlanJoinPolicy;
+	readonly limits?: EffectRunLimits;
+	readonly policyRefs?: readonly SourceRef[];
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface WorkItemEffectPlanAdmitted<TInput = unknown> {
+	readonly kind: "work-item-effect-plan-admitted";
+	readonly planId: string;
+	readonly workItemId: string;
+	readonly executionInputRevision: number;
+	readonly plan: WorkItemEffectPlanSnapshot<TInput>;
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly admittedAtMs?: number;
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface WorkItemEffectPlanRejected {
+	readonly kind: "work-item-effect-plan-rejected";
+	readonly planId: string;
+	readonly workItemId: string;
+	readonly executionInputRevision?: number;
+	readonly issues: readonly DataIssue[];
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly rejectedAtMs?: number;
+	readonly metadata?: Record<string, unknown>;
+}
+
+export type WorkItemEffectPlanMemberStatus =
+	| "eligible"
+	| "requested"
+	| "blocked"
+	| "deferred"
+	| "evidence-recorded"
+	| "completed"
+	| "failed"
+	| "duplicate"
+	| "stale"
+	| "rejected";
+
+export interface WorkItemEffectPlanStatus {
+	readonly kind: "work-item-effect-plan-status";
+	readonly statusId: string;
+	readonly workItemId: string;
+	readonly planId: string;
+	readonly executionInputRevision: number;
+	readonly state: WorkItemEffectPlanMemberStatus;
+	readonly planMemberId?: string;
+	readonly requestId?: string;
+	readonly effectRunId?: string;
+	readonly evidenceId?: string;
+	readonly effectRunResultId?: string;
+	readonly issues?: readonly DataIssue[];
+	readonly message?: string;
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly metadata?: Record<string, unknown>;
+}
+
+export type WorkItemEffectPlanResultStatus = "succeeded" | "failed" | "evidence-only";
+
+export interface WorkItemEffectPlanResult {
+	readonly kind: "work-item-effect-plan-result";
+	readonly resultId: string;
+	readonly workItemId: string;
+	readonly planId: string;
+	readonly executionInputRevision: number;
+	readonly status: WorkItemEffectPlanResultStatus;
+	readonly memberResults: readonly {
+		readonly planMemberId: string;
+		readonly status: EffectRunResultStatus;
+		readonly requestId?: string;
+		readonly effectRunId?: string;
+		readonly evidenceId?: string;
+		readonly effectRunResultId?: string;
+	}[];
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface WorkItemEffectPlanPolicy {
+	readonly policyId?: string;
+	readonly allowedEffectKinds?: readonly string[];
+	readonly joinPolicy?: WorkItemEffectPlanJoinPolicy;
+}
+
+export interface WorkItemEffectPlanProjectorOptions<TInput = unknown> {
+	readonly name?: string;
+	readonly workItems: Node<WorkItemProjection<TInput>>;
+	readonly proposals: Node<WorkItemEffectPlanProposed<TInput>>;
+	readonly evidence?: Node<WorkItemEvidenceRecorded>;
+	readonly effectRunResults?: Node<EffectRunResult>;
+	readonly policy?: WorkItemEffectPlanPolicy;
+	readonly now?: () => number;
+}
+
+export interface WorkItemEffectPlanProjectorBundle<TInput = unknown> {
+	readonly admitted: Node<WorkItemEffectPlanAdmitted<TInput>>;
+	readonly rejected: Node<WorkItemEffectPlanRejected>;
+	readonly effectRequests: Node<WorkItemEffectRequested<TInput>>;
+	readonly results: Node<WorkItemEffectPlanResult>;
+	readonly status: Node<WorkItemEffectPlanStatus>;
+	readonly issues: Node<DataIssue>;
+	readonly audit: Node<AgentRuntimeAuditRecord>;
+}
+
+export type Fact<T> =
+	| { readonly kind: "work-item"; readonly value: WorkItemProjection<T> }
+	| { readonly kind: "request"; readonly value: WorkItemEffectRequested<T> }
+	| { readonly kind: "result"; readonly value: VerificationResultRecorded }
+	| { readonly kind: "proposal"; readonly value: WorkItemDomainActionProposal }
+	| { readonly kind: "status"; readonly value: WorkItemValidationStatus }
+	| { readonly kind: "issue"; readonly value: DataIssue }
+	| { readonly kind: "audit"; readonly value: AgentRuntimeAuditRecord };
+
+export type PlanFact<T> =
+	| { readonly kind: "admitted"; readonly value: WorkItemEffectPlanAdmitted<T> }
+	| { readonly kind: "rejected"; readonly value: WorkItemEffectPlanRejected }
+	| { readonly kind: "request"; readonly value: WorkItemEffectRequested<T> }
+	| { readonly kind: "result"; readonly value: WorkItemEffectPlanResult }
+	| { readonly kind: "status"; readonly value: WorkItemEffectPlanStatus }
+	| { readonly kind: "issue"; readonly value: DataIssue }
+	| { readonly kind: "audit"; readonly value: AgentRuntimeAuditRecord };
+
+export interface AuthoringState<T> {
+	readonly workItems: Map<string, WorkItemProjection<T>>;
+	readonly seenEvents: Set<string>;
+	statusSeq: number;
+	auditSeq: number;
+}
+
+export interface RequestState<T> {
+	readonly workItems: Map<string, WorkItemProjection<T>>;
+	readonly emittedKeys: Set<string>;
+	readonly passedSteps: Map<string, Set<string>>;
+	statusSeq: number;
+	auditSeq: number;
+}
+
+export interface ResultState<T> {
+	readonly workItems: Map<string, WorkItemProjection<T>>;
+	readonly policies: Map<string, WorkItemVerificationMappingPolicy>;
+	readonly evidenceById: Map<string, WorkItemEvidenceRecorded>;
+	readonly resultEvidence: Set<string>;
+	readonly proposalKeys: Set<string>;
+	statusSeq: number;
+	auditSeq: number;
+}
+
+export interface PlanMemberEvidence {
+	readonly status: EffectRunResultStatus;
+	readonly requestId?: string;
+	readonly effectRunId?: string;
+	readonly evidenceId?: string;
+	readonly effectRunResultId?: string;
+	readonly sourceRefs?: readonly SourceRef[];
+}
+
+export interface PlanState<T> {
+	readonly workItems: Map<string, WorkItemProjection<T>>;
+	readonly proposals: Map<string, WorkItemEffectPlanProposed<T>>;
+	readonly admitted: Map<string, WorkItemEffectPlanAdmitted<T>>;
+	readonly rejected: Set<string>;
+	readonly emittedMemberKeys: Set<string>;
+	readonly statusKeys: Set<string>;
+	readonly resultKeys: Set<string>;
+	readonly requestByEffectRun: Map<string, WorkItemEffectRequested<T>>;
+	readonly requestByRequestId: Map<string, WorkItemEffectRequested<T>>;
+	readonly memberEvidence: Map<string, PlanMemberEvidence>;
+	readonly pendingEvidence: Map<string, WorkItemEvidenceRecorded>;
+	readonly pendingResults: Map<string, EffectRunResult>;
+	readonly unmatchedEvidence: Set<string>;
+	readonly unmatchedResults: Set<string>;
+	statusSeq: number;
+	auditSeq: number;
+}
+
+export const executionRelevantDefaults = new Set([
+	"detail",
+	"detailRefs",
+	"acceptanceCriteria",
+	"verificationPlan",
+	"verificationSteps",
+	"dependencies",
+]);
+
+export const draftPatchKeys = new Set([
+	"summary",
+	"detail",
+	"detailRefs",
+	"acceptanceCriteria",
+	"verificationPlan",
+	"verificationSteps",
+	"kind",
+	"priority",
+	"tags",
+	"owner",
+	"assignee",
+	"deadlineMs",
+	"customFields",
+	"sourceRefs",
+	"metadata",
+]);
diff --git a/packages/ts/src/solutions/work-item/scheduling-validation.ts b/packages/ts/src/solutions/work-item/scheduling-validation.ts
new file mode 100644
index 00000000..0226c8a0
--- /dev/null
+++ b/packages/ts/src/solutions/work-item/scheduling-validation.ts
@@ -0,0 +1,236 @@
+import type { DataIssue } from "../../data/index.js";
+import {
+	isRecord,
+	issue,
+	isVerificationPlanShape,
+	normalizePlanFromUnknown,
+} from "./scheduling-shared.js";
+import type {
+	AcceptanceCriterion,
+	VerificationPlan,
+	VerificationStep,
+	VerificationStepMode,
+	WorkItemDraft,
+} from "./scheduling-types.js";
+
+export function validateWorkItemDraft<TInput>(
+	draft: WorkItemDraft<TInput> | unknown,
+	opts: { readonly workItemId?: string } = {},
+): readonly DataIssue[] {
+	const out: DataIssue[] = [];
+	if (!isRecord(draft)) {
+		return [issue("malformed-draft", "WorkItemDraft must be an object", opts.workItemId)];
+	}
+	if (typeof draft.summary !== "string") {
+		out.push(issue("missing-required-field", "WorkItemDraft.summary is required", opts.workItemId));
+	} else if (draft.summary.trim() === "") {
+		out.push(issue("missing-required-field", "WorkItemDraft.summary is required", opts.workItemId));
+	}
+	const criteria =
+		draft.acceptanceCriteria === undefined || Array.isArray(draft.acceptanceCriteria)
+			? (draft.acceptanceCriteria as readonly AcceptanceCriterion[] | undefined)
+			: undefined;
+	if (draft.acceptanceCriteria !== undefined && criteria === undefined) {
+		out.push(
+			issue(
+				"malformed-draft",
+				"WorkItemDraft.acceptanceCriteria must be an array",
+				opts.workItemId,
+			),
+		);
+	}
+	out.push(...validateAcceptanceCriteria(criteria ?? [], opts));
+	if (draft.verificationPlan !== undefined && !isVerificationPlanShape(draft.verificationPlan)) {
+		out.push(
+			issue("malformed-draft", "WorkItemDraft.verificationPlan is malformed", opts.workItemId),
+		);
+	}
+	if (draft.verificationSteps !== undefined && !Array.isArray(draft.verificationSteps)) {
+		out.push(
+			issue("malformed-draft", "WorkItemDraft.verificationSteps must be an array", opts.workItemId),
+		);
+	}
+	const plan = normalizePlanFromUnknown(draft);
+	if (plan !== undefined) {
+		out.push(...validateVerificationPlan(plan, criteria ?? [], opts));
+	}
+	return out;
+}
+
+export function validateAcceptanceCriteria(
+	criteria: readonly AcceptanceCriterion[],
+	opts: { readonly workItemId?: string } = {},
+): readonly DataIssue[] {
+	const out: DataIssue[] = [];
+	const seen = new Set<string>();
+	for (const criterion of criteria) {
+		if (!isRecord(criterion)) {
+			out.push(issue("malformed-draft", "AcceptanceCriterion must be an object", opts.workItemId));
+			continue;
+		}
+		if (typeof criterion.criterionId !== "string" || criterion.criterionId === "") {
+			out.push(
+				issue(
+					"missing-required-field",
+					"AcceptanceCriterion.criterionId is required",
+					opts.workItemId,
+				),
+			);
+			continue;
+		}
+		if (seen.has(criterion.criterionId)) {
+			out.push(
+				issue(
+					"duplicate-id",
+					`Duplicate acceptance criterion id '${criterion.criterionId}'`,
+					opts.workItemId,
+					{ criterionId: criterion.criterionId },
+				),
+			);
+		}
+		seen.add(criterion.criterionId);
+		if (typeof criterion.statement !== "string" || criterion.statement.trim() === "") {
+			out.push(
+				issue(
+					"missing-required-field",
+					"AcceptanceCriterion.statement is required",
+					opts.workItemId,
+					{ criterionId: criterion.criterionId },
+				),
+			);
+		}
+	}
+	return out;
+}
+
+export function validateVerificationPlan<TInput>(
+	plan: VerificationPlan<TInput>,
+	criteria: readonly AcceptanceCriterion[] = [],
+	opts: {
+		readonly workItemId?: string;
+		readonly allowedModes?: readonly VerificationStepMode[];
+		readonly allowedEffectKinds?: readonly string[];
+	} = {},
+): readonly DataIssue[] {
+	const out: DataIssue[] = [];
+	if (!isRecord(plan) || !Array.isArray(plan.steps)) {
+		return [issue("malformed-draft", "VerificationPlan.steps must be an array", opts.workItemId)];
+	}
+	const criterionIds = new Set(criteria.map((criterion) => criterion.criterionId));
+	const stepIds = new Set<string>();
+	const modes = new Set(opts.allowedModes ?? ["auto", "manual", "hybrid"]);
+	const effectKinds = new Set(opts.allowedEffectKinds ?? ["verification"]);
+	for (const step of plan.steps) {
+		if (!isRecord(step)) {
+			out.push(issue("malformed-draft", "VerificationStep must be an object", opts.workItemId));
+			continue;
+		}
+		if (typeof step.stepId !== "string" || step.stepId === "") {
+			out.push(
+				issue("missing-required-field", "VerificationStep.stepId is required", opts.workItemId),
+			);
+			continue;
+		}
+		if (stepIds.has(step.stepId)) {
+			out.push(
+				issue("duplicate-id", `Duplicate verification step id '${step.stepId}'`, opts.workItemId, {
+					stepId: step.stepId,
+				}),
+			);
+		}
+		stepIds.add(step.stepId);
+		if (typeof step.mode !== "string" || !modes.has(step.mode as VerificationStepMode)) {
+			out.push(
+				issue(
+					"unsupported-mode",
+					`Unsupported verification step mode '${step.mode}'`,
+					opts.workItemId,
+					{ stepId: step.stepId },
+				),
+			);
+		}
+		if (
+			step.effectKind !== undefined &&
+			(typeof step.effectKind !== "string" || !effectKinds.has(step.effectKind))
+		) {
+			out.push(
+				issue(
+					"unsupported-effect-kind",
+					`Unsupported verification effect kind '${step.effectKind}'`,
+					opts.workItemId,
+					{ stepId: step.stepId },
+				),
+			);
+		}
+		const verifiesCriteriaIds = Array.isArray(step.verifiesCriteriaIds)
+			? step.verifiesCriteriaIds
+			: [];
+		for (const criterionId of verifiesCriteriaIds) {
+			if (!criterionIds.has(criterionId)) {
+				out.push(
+					issue("dangling-ref", `Unknown acceptance criterion '${criterionId}'`, opts.workItemId, {
+						stepId: step.stepId,
+						criterionId,
+					}),
+				);
+			}
+		}
+	}
+	for (const step of plan.steps) {
+		if (!isRecord(step) || typeof step.stepId !== "string") continue;
+		const dependsOnStepIds = Array.isArray(step.dependsOnStepIds) ? step.dependsOnStepIds : [];
+		for (const depId of dependsOnStepIds) {
+			if (!stepIds.has(depId)) {
+				out.push(
+					issue("dangling-ref", `Unknown verification dependency '${depId}'`, opts.workItemId, {
+						stepId: step.stepId,
+					}),
+				);
+			}
+		}
+	}
+	const cycle = findCycle(
+		plan.steps.filter(
+			(step): step is VerificationStep =>
+				isRecord(step) && typeof step.stepId === "string" && Array.isArray(step.dependsOnStepIds),
+		),
+	);
+	if (cycle !== undefined) {
+		out.push(
+			issue(
+				"cyclic-dependency",
+				`Verification step cycle detected: ${cycle.join(" -> ")}`,
+				opts.workItemId,
+				{ stepId: cycle[0] },
+			),
+		);
+	}
+	return out;
+}
+
+function findCycle(steps: readonly VerificationStep[]): readonly string[] | undefined {
+	const byId = new Map(steps.map((step) => [step.stepId, step.dependsOnStepIds ?? []]));
+	const visiting = new Set<string>();
+	const visited = new Set<string>();
+	const stack: string[] = [];
+	const visit = (id: string): readonly string[] | undefined => {
+		if (visiting.has(id)) return [...stack.slice(stack.indexOf(id)), id];
+		if (visited.has(id)) return undefined;
+		visiting.add(id);
+		stack.push(id);
+		for (const dep of byId.get(id) ?? []) {
+			if (!byId.has(dep)) continue;
+			const cycle = visit(dep);
+			if (cycle !== undefined) return cycle;
+		}
+		stack.pop();
+		visiting.delete(id);
+		visited.add(id);
+		return undefined;
+	};
+	for (const step of steps) {
+		const cycle = visit(step.stepId);
+		if (cycle !== undefined) return cycle;
+	}
+	return undefined;
+}
diff --git a/packages/ts/src/solutions/work-item/scheduling-verification.ts b/packages/ts/src/solutions/work-item/scheduling-verification.ts
new file mode 100644
index 00000000..36d86433
--- /dev/null
+++ b/packages/ts/src/solutions/work-item/scheduling-verification.ts
@@ -0,0 +1,854 @@
+import { type Ctx, depBatch } from "../../ctx/types.js";
+import type { DataIssue } from "../../data/index.js";
+import type { Graph } from "../../graph/graph.js";
+import type { Node } from "../../node/node.js";
+import type { EffectRunResultStatus } from "../../orchestration/agent-runtime.js";
+import type {
+	WorkItemDomainActionProposalSpec,
+	WorkItemEffectRequested,
+	WorkItemEvidenceRecorded,
+} from "../../orchestration/work-item-runtime.js";
+import {
+	emit,
+	emitAudit,
+	goalWithInlineInput,
+	isRecord,
+	issue,
+	normalizePlan,
+	project,
+	ref,
+	stringArray,
+} from "./scheduling-shared.js";
+import type {
+	Fact,
+	RequestState,
+	ResultState,
+	VerificationPlan,
+	VerificationResultRecorded,
+	VerificationResultStatus,
+	VerificationStep,
+	WorkItemDispatchIntent,
+	WorkItemProjection,
+	WorkItemValidationIssueCode,
+	WorkItemValidationStatus,
+	WorkItemVerificationLowererPolicy,
+	WorkItemVerificationMappingPolicy,
+	WorkItemVerificationRequestLowererBundle,
+	WorkItemVerificationRequestLowererOptions,
+	WorkItemVerificationResultMapperBundle,
+	WorkItemVerificationResultMapperOptions,
+} from "./scheduling-types.js";
+import { validateVerificationPlan } from "./scheduling-validation.js";
+
+export function workItemVerificationRequestLowerer<TInput = unknown>(
+	graph: Graph,
+	opts: WorkItemVerificationRequestLowererOptions<TInput>,
+): WorkItemVerificationRequestLowererBundle<TInput> {
+	const name = opts.name ?? "workItemVerificationRequests";
+	const deps: Node<unknown>[] = [opts.workItems];
+	const dispatchIntentIndex =
+		opts.dispatchIntents === undefined ? -1 : deps.push(opts.dispatchIntents) - 1;
+	const verificationResultIndex =
+		opts.verificationResults === undefined ? -1 : deps.push(opts.verificationResults) - 1;
+	const runtime = graph.node<Fact<TInput>>(
+		deps,
+		(ctx) => {
+			const state = ctx.state.get<RequestState<TInput>>() ?? {
+				workItems: new Map(),
+				emittedKeys: new Set(),
+				passedSteps: new Map(),
+				statusSeq: 0,
+				auditSeq: 0,
+			};
+			for (const raw of depBatch(ctx, 0) ?? []) {
+				const workItem = raw as WorkItemProjection<TInput>;
+				state.workItems.set(workItem.workItemId, workItem);
+				lowerPlan(ctx, state, workItem, opts.policy);
+			}
+			if (dispatchIntentIndex >= 0) {
+				for (const raw of depBatch(ctx, dispatchIntentIndex) ?? [])
+					lowerIntent(ctx, state, raw as WorkItemDispatchIntent<TInput>, opts.policy);
+			}
+			if (verificationResultIndex >= 0) {
+				for (const raw of depBatch(ctx, verificationResultIndex) ?? [])
+					recordVerificationResult(ctx, state, raw as VerificationResultRecorded, opts.policy);
+			}
+			ctx.state.set(state);
+		},
+		{
+			name: `${name}/runtime`,
+			factory: "workItemVerificationRequestLowerer",
+			partial: true,
+			completeWhenDepsComplete: false,
+			errorWhenDepsError: false,
+		},
+	);
+	return {
+		effectRequests: project(
+			graph,
+			runtime,
+			`${name}/effectRequests`,
+			"workItemVerificationEffectRequests",
+			(fact) => (fact.kind === "request" ? fact.value : undefined),
+		),
+		status: project(
+			graph,
+			runtime,
+			`${name}/status`,
+			"workItemVerificationRequestStatus",
+			(fact) => (fact.kind === "status" ? fact.value : undefined),
+		),
+		issues: project(
+			graph,
+			runtime,
+			`${name}/issues`,
+			"workItemVerificationRequestIssues",
+			(fact) => (fact.kind === "issue" ? fact.value : undefined),
+		),
+		audit: project(graph, runtime, `${name}/audit`, "workItemVerificationRequestAudit", (fact) =>
+			fact.kind === "audit" ? fact.value : undefined,
+		),
+	};
+}
+
+export function workItemVerificationResultMapper<TInput = unknown>(
+	graph: Graph,
+	opts: WorkItemVerificationResultMapperOptions<TInput>,
+): WorkItemVerificationResultMapperBundle {
+	const name = opts.name ?? "workItemVerificationResults";
+	const deps =
+		opts.policies === undefined
+			? [opts.workItems, opts.evidence]
+			: [opts.workItems, opts.evidence, opts.policies];
+	const runtime = graph.node<Fact<TInput>>(
+		deps,
+		(ctx) => {
+			const state = ctx.state.get<ResultState<TInput>>() ?? {
+				workItems: new Map(),
+				policies: new Map(),
+				evidenceById: new Map(),
+				resultEvidence: new Set(),
+				proposalKeys: new Set(),
+				statusSeq: 0,
+				auditSeq: 0,
+			};
+			for (const raw of depBatch(ctx, 0) ?? []) {
+				const workItem = raw as WorkItemProjection<TInput>;
+				state.workItems.set(workItem.workItemId, workItem);
+				replayEvidence(ctx, state, workItem.workItemId);
+			}
+			if (opts.policies !== undefined) {
+				for (const raw of depBatch(ctx, 2) ?? []) {
+					const policy = raw as WorkItemVerificationMappingPolicy;
+					const issues = validateMappingPolicy(policy);
+					if (issues.length > 0) {
+						for (const item of issues) emit(ctx, "issue", item);
+						emitResultStatus(ctx, state, {
+							state: "rejected",
+							code: "policy-mismatch",
+							metadata: { policyId: isRecord(policy) ? policy.policyId : undefined },
+						});
+						continue;
+					}
+					state.policies.set(policy.policyId, policy);
+				}
+				for (const evidence of state.evidenceById.values()) {
+					mapEvidence(ctx, state, evidence, true);
+				}
+			}
+			for (const raw of depBatch(ctx, 1) ?? [])
+				mapEvidence(ctx, state, raw as WorkItemEvidenceRecorded);
+			ctx.state.set(state);
+		},
+		{
+			name: `${name}/runtime`,
+			factory: "workItemVerificationResultMapper",
+			partial: true,
+			completeWhenDepsComplete: false,
+			errorWhenDepsError: false,
+		},
+	);
+	return {
+		results: project(graph, runtime, `${name}/results`, "workItemVerificationResults", (fact) =>
+			fact.kind === "result" ? fact.value : undefined,
+		),
+		proposals: project(
+			graph,
+			runtime,
+			`${name}/proposals`,
+			"workItemVerificationProposals",
+			(fact) => (fact.kind === "proposal" ? fact.value : undefined),
+		),
+		status: project(graph, runtime, `${name}/status`, "workItemVerificationResultStatus", (fact) =>
+			fact.kind === "status" ? fact.value : undefined,
+		),
+		issues: project(graph, runtime, `${name}/issues`, "workItemVerificationResultIssues", (fact) =>
+			fact.kind === "issue" ? fact.value : undefined,
+		),
+		audit: project(graph, runtime, `${name}/audit`, "workItemVerificationResultAudit", (fact) =>
+			fact.kind === "audit" ? fact.value : undefined,
+		),
+	};
+}
+
+function lowerPlan<T>(
+	ctx: Ctx,
+	state: RequestState<T>,
+	workItem: WorkItemProjection<T>,
+	policy?: WorkItemVerificationLowererPolicy,
+): void {
+	const plan = normalizePlan(workItem);
+	if (plan === undefined) {
+		emitRequestStatus(ctx, state, {
+			state: "needs-human-review",
+			code: "verification-unplanned",
+			workItemId: workItem.workItemId,
+		});
+		return;
+	}
+	const issues = validateVerificationPlan(plan, workItem.acceptanceCriteria ?? [], {
+		workItemId: workItem.workItemId,
+		allowedModes: policy?.allowedModes,
+		allowedEffectKinds: policy?.allowedEffectKinds,
+	});
+	if (issues.length > 0) {
+		for (const item of issues) emit(ctx, "issue", item);
+		return;
+	}
+	if (policy?.autoRun === false) {
+		emitRequestStatus(ctx, state, {
+			state: "deferred",
+			code: "policy-mismatch",
+			workItemId: workItem.workItemId,
+			revision: workItem.authoringRevision,
+			executionInputRevision: workItem.executionInputRevision,
+			metadata: { policyId: policy.policyId, reason: "auto-run-disabled" },
+		});
+		return;
+	}
+	for (const step of plan.steps) {
+		if (isStepSatisfied(state, workItem, step.stepId)) {
+			emitRequestStatus(ctx, state, {
+				state: "duplicate",
+				code: "duplicate-suppressed",
+				workItemId: workItem.workItemId,
+				revision: workItem.authoringRevision,
+				executionInputRevision: workItem.executionInputRevision,
+				stepId: step.stepId,
+				message: `Verification step '${step.stepId}' already has valid evidence`,
+			});
+			continue;
+		}
+		if (step.mode === "manual") {
+			emitRequestStatus(ctx, state, {
+				state: "needs-human-review",
+				code: "manual-review-required",
+				workItemId: workItem.workItemId,
+				stepId: step.stepId,
+			});
+			continue;
+		}
+		const missingPrerequisites = (step.dependsOnStepIds ?? []).filter(
+			(stepId) => !isStepSatisfied(state, workItem, stepId),
+		);
+		if (missingPrerequisites.length > 0) {
+			emitRequestStatus(ctx, state, {
+				state: "blocked",
+				code: "blocked-prerequisite",
+				workItemId: workItem.workItemId,
+				stepId: step.stepId,
+				metadata: { missingStepIds: missingPrerequisites },
+			});
+			continue;
+		}
+		emitRequest(ctx, state, requestFromStep(workItem, plan, step, policy));
+	}
+}
+
+function lowerIntent<T>(
+	ctx: Ctx,
+	state: RequestState<T>,
+	intent: WorkItemDispatchIntent<T>,
+	policy?: WorkItemVerificationLowererPolicy,
+): void {
+	const workItem = state.workItems.get(intent.workItemId);
+	if (workItem === undefined) {
+		emit(
+			ctx,
+			"issue",
+			issue(
+				"dangling-ref",
+				`Dispatch intent '${intent.intentId}' references unknown WorkItem '${intent.workItemId}'`,
+				intent.workItemId,
+			),
+		);
+		return;
+	}
+	if (intent.executionInputRevision !== workItem.executionInputRevision) {
+		emit(
+			ctx,
+			"issue",
+			issue(
+				"stale-execution-input",
+				`Dispatch intent '${intent.intentId}' targets stale execution input`,
+				intent.workItemId,
+				{
+					intentRevision: intent.executionInputRevision,
+					currentRevision: workItem.executionInputRevision,
+					stalePolicy: policy?.stalePolicy ?? "review",
+				},
+			),
+		);
+		emitRequestStatus(ctx, state, {
+			state: "stale",
+			code: "stale-execution-input",
+			workItemId: intent.workItemId,
+			executionInputRevision: workItem.executionInputRevision,
+			metadata: { intentId: intent.intentId },
+		});
+		return;
+	}
+	const effectKind = intent.effectKind ?? intent.targetKind;
+	const allowedEffectKinds = new Set(policy?.allowedEffectKinds ?? ["verification"]);
+	if (!allowedEffectKinds.has(effectKind)) {
+		emit(
+			ctx,
+			"issue",
+			issue(
+				"unsupported-effect-kind",
+				`Dispatch intent '${intent.intentId}' targets unsupported effect kind '${effectKind}'`,
+				intent.workItemId,
+				{ intentId: intent.intentId, effectKind },
+			),
+		);
+		emitRequestStatus(ctx, state, {
+			state: "rejected",
+			code: "unsupported-effect-kind",
+			workItemId: intent.workItemId,
+			executionInputRevision: workItem.executionInputRevision,
+			metadata: { intentId: intent.intentId, effectKind },
+		});
+		return;
+	}
+	emitRequest(ctx, state, requestFromIntent(workItem, intent));
+}
+
+function recordVerificationResult<T>(
+	ctx: Ctx,
+	state: RequestState<T>,
+	result: VerificationResultRecorded,
+	policy?: WorkItemVerificationLowererPolicy,
+): void {
+	if (result.status !== "passed") return;
+	const workItem = state.workItems.get(result.workItemId);
+	if (workItem === undefined) {
+		emit(
+			ctx,
+			"issue",
+			issue(
+				"dangling-ref",
+				`Verification result '${result.resultId}' references unknown WorkItem '${result.workItemId}'`,
+				result.workItemId,
+			),
+		);
+		return;
+	}
+	if (result.executionInputRevision !== workItem.executionInputRevision) {
+		emit(
+			ctx,
+			"issue",
+			issue(
+				"stale-revision",
+				`Verification result '${result.resultId}' targets stale execution input`,
+				result.workItemId,
+			),
+		);
+		return;
+	}
+	const key = revisionKey(result.workItemId, result.executionInputRevision);
+	const passedSteps = state.passedSteps.get(key) ?? new Set<string>();
+	for (const stepId of result.verificationStepIds) passedSteps.add(stepId);
+	state.passedSteps.set(key, passedSteps);
+	lowerPlan(ctx, state, workItem, policy);
+}
+
+function mapEvidence<T>(
+	ctx: Ctx,
+	state: ResultState<T>,
+	evidence: WorkItemEvidenceRecorded,
+	replay = false,
+): void {
+	if (!replay && state.evidenceById.has(evidence.evidenceId)) {
+		emit(
+			ctx,
+			"issue",
+			issue(
+				"duplicate-suppressed",
+				`Duplicate evidence '${evidence.evidenceId}'`,
+				evidence.workItemId,
+			),
+		);
+		return;
+	}
+	state.evidenceById.set(evidence.evidenceId, evidence);
+	const workItem = state.workItems.get(evidence.workItemId);
+	if (workItem === undefined) {
+		emit(
+			ctx,
+			"issue",
+			issue(
+				"dangling-ref",
+				`Evidence '${evidence.evidenceId}' references unknown WorkItem '${evidence.workItemId}'`,
+				evidence.workItemId,
+			),
+		);
+		return;
+	}
+	const revision =
+		typeof evidence.metadata?.executionInputRevision === "number"
+			? evidence.metadata.executionInputRevision
+			: undefined;
+	if (revision !== workItem.executionInputRevision) {
+		emit(
+			ctx,
+			"issue",
+			issue(
+				"stale-revision",
+				`Evidence '${evidence.evidenceId}' targets stale revision`,
+				evidence.workItemId,
+			),
+		);
+		emitResultStatus(ctx, state, {
+			state: "stale",
+			code: "stale-revision",
+			workItemId: evidence.workItemId,
+			executionInputRevision: workItem.executionInputRevision,
+		});
+		return;
+	}
+	const stepIds = stringArray(evidence.metadata?.verificationStepIds);
+	const criterionIds = stringArray(evidence.metadata?.acceptanceCriterionIds);
+	if (stepIds.length === 0 || criterionIds.length === 0) {
+		emit(
+			ctx,
+			"issue",
+			issue(
+				"ambiguous-coverage",
+				`Evidence '${evidence.evidenceId}' lacks coverage refs`,
+				evidence.workItemId,
+			),
+		);
+		return;
+	}
+	const coverageIssue = validateEvidenceCoverage(workItem, stepIds, criterionIds);
+	if (coverageIssue !== undefined) {
+		emit(ctx, "issue", {
+			...coverageIssue,
+			message: `Evidence '${evidence.evidenceId}' has invalid verification coverage: ${coverageIssue.message}`,
+		});
+		emitResultStatus(ctx, state, {
+			state: "rejected",
+			code: coverageIssue.code as WorkItemValidationIssueCode,
+			workItemId: evidence.workItemId,
+			executionInputRevision: workItem.executionInputRevision,
+			metadata: { evidenceId: evidence.evidenceId },
+		});
+		return;
+	}
+	const result: VerificationResultRecorded = {
+		kind: "verification-result-recorded",
+		resultId: `verification-result:${evidence.evidenceId}`,
+		workItemId: evidence.workItemId,
+		evidenceId: evidence.evidenceId,
+		effectRunId: evidence.effectRunId,
+		effectRunResultId: evidence.effectRunResultId,
+		executionInputRevision: revision,
+		verificationStepIds: stepIds,
+		acceptanceCriterionIds: criterionIds,
+		status: resultStatus(evidence.status),
+		output: evidence.output,
+		error: evidence.error,
+		reason: evidence.reason,
+		sourceRefs: evidence.sourceRefs,
+		recordedAtMs: evidence.recordedAtMs,
+		metadata: evidence.metadata,
+	};
+	if (!state.resultEvidence.has(evidence.evidenceId)) {
+		state.resultEvidence.add(evidence.evidenceId);
+		emit(ctx, "result", result);
+		emitResultStatus(ctx, state, {
+			state: "result-recorded",
+			workItemId: evidence.workItemId,
+			executionInputRevision: revision,
+			metadata: { resultId: result.resultId },
+		});
+	}
+	const policyIds = [
+		...new Set(
+			(evidence.sourceRefs ?? [])
+				.filter((sourceRef) => sourceRef.kind === "work-item-verification-mapping-policy")
+				.map((sourceRef) => sourceRef.id),
+		),
+	];
+	if (policyIds.length === 0) return;
+	for (const policyId of policyIds) {
+		const policy = state.policies.get(policyId);
+		if (policy === undefined) {
+			if (!replay) {
+				emit(
+					ctx,
+					"issue",
+					issue(
+						"missing-policy",
+						`Missing verification mapping policy '${policyId}'`,
+						evidence.workItemId,
+						{ policyId },
+					),
+				);
+				emitResultStatus(ctx, state, {
+					state: "deferred",
+					code: "missing-policy",
+					workItemId: evidence.workItemId,
+					executionInputRevision: revision,
+					metadata: { evidenceId: evidence.evidenceId, policyId },
+				});
+			}
+			continue;
+		}
+		for (const [index, spec] of (policy.actionProposals ?? []).entries()) {
+			if (spec.behavior !== undefined && spec.behavior !== "propose") {
+				emit(ctx, "issue", actionProposalIssue(policy, spec, evidence, "unsupported behavior"));
+				continue;
+			}
+			if (spec.actionKind.length === 0) {
+				emit(ctx, "issue", actionProposalIssue(policy, spec, evidence, "empty actionKind"));
+				continue;
+			}
+			if (spec.statuses !== undefined && !spec.statuses.includes(evidence.status)) continue;
+			const outputKind = evidence.output?.kind;
+			if (
+				spec.outputKinds !== undefined &&
+				(outputKind === undefined || !spec.outputKinds.includes(outputKind))
+			)
+				continue;
+			const proposalKey = `${evidence.evidenceId}:${policy.policyId}:${index}:${spec.actionKind}`;
+			if (state.proposalKeys.has(proposalKey)) continue;
+			state.proposalKeys.add(proposalKey);
+			emit(ctx, "proposal", {
+				kind: "work-item-domain-action-proposal",
+				proposalId: `verification:${result.resultId}:${policy.policyId}:${index}:${spec.actionKind}`,
+				workItemId: result.workItemId,
+				actionKind: spec.actionKind,
+				effectRunId: result.effectRunId,
+				effectRunResultId: result.effectRunResultId,
+				evidenceId: result.evidenceId,
+				policyId: policy.policyId,
+				payload: actionProposalPayload(spec, evidence, result),
+				reason: spec.reason ?? evidence.reason,
+				sourceRefs: [
+					ref("work-item-evidence", evidence.evidenceId),
+					ref("verification-result", result.resultId),
+					ref("effect-run-result", result.effectRunResultId),
+					ref("work-item-verification-mapping-policy", policy.policyId),
+				],
+				metadata: {
+					...(policy.metadata ?? {}),
+					...(spec.metadata ?? {}),
+					resultStatus: evidence.status,
+				},
+			});
+			emitResultStatus(ctx, state, {
+				state: "domain-action-proposed",
+				workItemId: evidence.workItemId,
+				executionInputRevision: revision,
+				metadata: { actionKind: spec.actionKind, policyId: policy.policyId },
+			});
+		}
+	}
+}
+
+function requestFromStep<T>(
+	workItem: WorkItemProjection<T>,
+	plan: VerificationPlan<T>,
+	step: VerificationStep<T>,
+	policy?: WorkItemVerificationLowererPolicy,
+): WorkItemEffectRequested<T> {
+	const requestId = `work-item:${workItem.workItemId}:verification:${workItem.executionInputRevision}:${plan.planId}:${step.stepId}`;
+	const effectKind = step.effectKind ?? "verification";
+	const criterionIds =
+		step.verifiesCriteriaIds ??
+		(workItem.acceptanceCriteria ?? []).map((criterion) => criterion.criterionId);
+	const goal = goalWithInlineInput(
+		step.goal ?? { kind: effectKind, summary: step.title ?? workItem.summary },
+		step.input,
+		`verification-step:${step.stepId}:input`,
+		effectKind,
+		step.contextRefs,
+	);
+	return {
+		kind: "work-item-effect-requested",
+		requestId,
+		workItemId: workItem.workItemId,
+		effectRunId: `effect-run:${requestId}`,
+		effectKind,
+		executionInputRevision: workItem.executionInputRevision,
+		sourceRefs: [
+			ref("work-item", workItem.workItemId),
+			ref("work-item-revision", `${workItem.workItemId}:${workItem.executionInputRevision}`),
+			ref("verification-plan", plan.planId),
+			ref("verification-step", step.stepId),
+			...(plan.sourceRefs ?? []),
+			...(step.sourceRefs ?? []),
+		],
+		goal,
+		policyRefs:
+			policy?.policyId === undefined
+				? step.policyRefs
+				: [
+						...(step.policyRefs ?? []),
+						ref("work-item-verification-lowerer-policy", policy.policyId),
+					],
+		idempotencyKey: `${workItem.workItemId}:verification:${workItem.executionInputRevision}:${plan.planId}:${step.stepId}`,
+		metadata: {
+			...(step.metadata ?? {}),
+			executionInputRevision: workItem.executionInputRevision,
+			verificationPlanId: plan.planId,
+			verificationStepIds: [step.stepId],
+			acceptanceCriterionIds: criterionIds,
+			...(step.contextRefs === undefined ? {} : { contextRefs: step.contextRefs }),
+			...(step.requirements === undefined ? {} : { requirements: step.requirements }),
+			...(step.capacityHints === undefined ? {} : { capacityHints: step.capacityHints }),
+		},
+	};
+}
+
+function requestFromIntent<T>(
+	workItem: WorkItemProjection<T>,
+	intent: WorkItemDispatchIntent<T>,
+): WorkItemEffectRequested<T> {
+	const requestId = `work-item:${workItem.workItemId}:dispatch:${workItem.executionInputRevision}:${intent.intentId}`;
+	const effectKind = intent.effectKind ?? intent.targetKind;
+	return {
+		kind: "work-item-effect-requested",
+		requestId,
+		workItemId: workItem.workItemId,
+		effectRunId: `effect-run:${requestId}`,
+		effectKind,
+		executionInputRevision: workItem.executionInputRevision,
+		sourceRefs: [
+			ref("work-item", workItem.workItemId),
+			ref("work-item-dispatch-intent", intent.intentId),
+			...(intent.sourceRefs ?? []),
+		],
+		goal: intent.goal ?? { kind: effectKind, summary: intent.reason ?? workItem.summary },
+		policyRefs: intent.policyRefs,
+		limits: intent.limits,
+		idempotencyKey:
+			intent.idempotencyKey ??
+			`${workItem.workItemId}:dispatch:${workItem.executionInputRevision}:${intent.intentId}`,
+		metadata: {
+			...(intent.metadata ?? {}),
+			executionInputRevision: workItem.executionInputRevision,
+			verificationStepIds: intent.stepIds ?? [],
+			acceptanceCriterionIds: intent.acceptanceCriterionIds ?? [],
+			...(intent.contextRefs === undefined ? {} : { contextRefs: intent.contextRefs }),
+			...(intent.requirements === undefined ? {} : { requirements: intent.requirements }),
+			...(intent.capacityHints === undefined ? {} : { capacityHints: intent.capacityHints }),
+		},
+	};
+}
+
+function emitRequest<T>(
+	ctx: Ctx,
+	state: RequestState<T>,
+	request: WorkItemEffectRequested<T>,
+): void {
+	const key = request.idempotencyKey ?? request.requestId;
+	if (state.emittedKeys.has(key)) {
+		emitRequestStatus(ctx, state, {
+			state: "duplicate",
+			code: "duplicate-suppressed",
+			workItemId: request.workItemId,
+			metadata: { requestId: request.requestId },
+		});
+		return;
+	}
+	state.emittedKeys.add(key);
+	emit(ctx, "request", request);
+	emitRequestStatus(ctx, state, {
+		state: "request-emitted",
+		workItemId: request.workItemId,
+		executionInputRevision:
+			request.executionInputRevision ??
+			(request.metadata?.executionInputRevision as number | undefined),
+		metadata: { requestId: request.requestId },
+	});
+}
+
+function emitRequestStatus<T>(
+	ctx: Ctx,
+	state: RequestState<T>,
+	status: Omit<WorkItemValidationStatus, "kind" | "statusId">,
+): void {
+	state.statusSeq += 1;
+	const statusFact = {
+		kind: "work-item-validation-status",
+		statusId: `work-item-verification-request-status:${state.statusSeq}`,
+		...status,
+	} satisfies WorkItemValidationStatus;
+	emit(ctx, "status", statusFact);
+	emitAudit(ctx, state, "work-item-verification-request-status", statusFact);
+}
+
+function emitResultStatus<T>(
+	ctx: Ctx,
+	state: ResultState<T>,
+	status: Omit<WorkItemValidationStatus, "kind" | "statusId">,
+): void {
+	state.statusSeq += 1;
+	const statusFact = {
+		kind: "work-item-validation-status",
+		statusId: `work-item-verification-result-status:${state.statusSeq}`,
+		...status,
+	} satisfies WorkItemValidationStatus;
+	emit(ctx, "status", statusFact);
+	emitAudit(ctx, state, "work-item-verification-result-status", statusFact);
+}
+
+function _emit<T, K extends Fact<T>["kind"]>(
+	ctx: Ctx,
+	kind: K,
+	value: Extract<Fact<T>, { kind: K }>["value"],
+): void {
+	ctx.down([["DATA", { kind, value } as Fact<T>]]);
+}
+
+function validateEvidenceCoverage<T>(
+	workItem: WorkItemProjection<T>,
+	stepIds: readonly string[],
+	criterionIds: readonly string[],
+): DataIssue | undefined {
+	const plan = normalizePlan(workItem);
+	const validStepIds = new Set((plan?.steps ?? []).map((step) => step.stepId));
+	const validCriterionIds = new Set(
+		(workItem.acceptanceCriteria ?? []).map((criterion) => criterion.criterionId),
+	);
+	for (const stepId of stepIds) {
+		if (!validStepIds.has(stepId)) {
+			return issue("dangling-ref", `unknown verification step '${stepId}'`, workItem.workItemId, {
+				stepId,
+			});
+		}
+	}
+	for (const criterionId of criterionIds) {
+		if (!validCriterionIds.has(criterionId)) {
+			return issue(
+				"dangling-ref",
+				`unknown acceptance criterion '${criterionId}'`,
+				workItem.workItemId,
+				{ criterionId },
+			);
+		}
+	}
+	return undefined;
+}
+
+function isStepSatisfied<T>(
+	state: RequestState<T>,
+	workItem: WorkItemProjection<T>,
+	stepId: string,
+): boolean {
+	return (
+		state.passedSteps
+			.get(revisionKey(workItem.workItemId, workItem.executionInputRevision))
+			?.has(stepId) === true
+	);
+}
+
+function revisionKey(workItemId: string, executionInputRevision: number): string {
+	return `${workItemId}:${executionInputRevision}`;
+}
+
+function replayEvidence<T>(ctx: Ctx, state: ResultState<T>, workItemId: string): void {
+	for (const evidence of state.evidenceById.values()) {
+		if (evidence.workItemId === workItemId) mapEvidence(ctx, state, evidence, true);
+	}
+}
+
+function validateMappingPolicy(policy: WorkItemVerificationMappingPolicy): readonly DataIssue[] {
+	if (
+		!isRecord(policy) ||
+		policy.kind !== "work-item-verification-mapping-policy" ||
+		typeof policy.policyId !== "string" ||
+		policy.policyId.trim() === ""
+	) {
+		return [
+			issue(
+				"policy-mismatch",
+				"WorkItemVerificationMappingPolicy requires kind and policyId",
+				undefined,
+			),
+		];
+	}
+	if (policy.actionProposals !== undefined && !Array.isArray(policy.actionProposals)) {
+		return [
+			issue(
+				"policy-mismatch",
+				"WorkItemVerificationMappingPolicy.actionProposals must be an array",
+				undefined,
+				{
+					policyId: policy.policyId,
+				},
+			),
+		];
+	}
+	const out: DataIssue[] = [];
+	for (const [index, spec] of (policy.actionProposals ?? []).entries()) {
+		if (!isRecord(spec) || typeof spec.actionKind !== "string") {
+			out.push(
+				issue("policy-mismatch", "WorkItem action proposal requires actionKind", undefined, {
+					policyId: policy.policyId,
+					index,
+				}),
+			);
+		}
+	}
+	return out;
+}
+
+function resultStatus(status: EffectRunResultStatus): VerificationResultStatus {
+	if (status === "completed") return "passed";
+	if (status === "failed") return "failed";
+	if (status === "blocked") return "blocked";
+	if (status === "canceled") return "canceled";
+	if (status === "timeout") return "timeout";
+	return "waived";
+}
+
+function actionProposalPayload(
+	spec: WorkItemDomainActionProposalSpec,
+	evidence: WorkItemEvidenceRecorded,
+	result: VerificationResultRecorded,
+): unknown {
+	if (spec.payload !== undefined) return spec.payload;
+	if (spec.payloadFrom === "effect-run-result")
+		return { kind: "effect-run-result-ref", resultId: result.effectRunResultId };
+	if (spec.payloadFrom === "output") return evidence.output;
+	if (spec.payloadFrom === "evidence")
+		return { kind: "work-item-evidence-ref", evidenceId: evidence.evidenceId };
+	return undefined;
+}
+
+function actionProposalIssue(
+	policy: WorkItemVerificationMappingPolicy,
+	spec: WorkItemDomainActionProposalSpec,
+	evidence: WorkItemEvidenceRecorded,
+	reason: string,
+): DataIssue {
+	return issue(
+		"policy-mismatch",
+		`Verification mapping policy '${policy.policyId}' has an invalid action proposal: ${reason}`,
+		evidence.workItemId,
+		{ policyId: policy.policyId, actionKind: spec.actionKind },
+	);
+}
diff --git a/packages/ts/src/solutions/work-item/scheduling.ts b/packages/ts/src/solutions/work-item/scheduling.ts
new file mode 100644
index 00000000..87b4a91c
--- /dev/null
+++ b/packages/ts/src/solutions/work-item/scheduling.ts
@@ -0,0 +1,18 @@
+/**
+ * WorkItem authoring, verification, and scheduling facts (D333-D343).
+ *
+ * This focused solution subpath is data-first glue. It emits graph-visible
+ * projections, requests, results, status, issues, and audit facts; it does not
+ * run verification, claim queues, dispatch executors, or mutate WorkItems.
+ */
+
+export * from "./scheduling-authoring.js";
+export * from "./scheduling-constructors.js";
+export * from "./scheduling-effect-plan.js";
+export * from "./scheduling-effect-plan-validation.js";
+export * from "./scheduling-types.js";
+export * from "./scheduling-validation.js";
+export * from "./scheduling-verification.js";
+export * from "./workspace-family-applications.js";
+export * from "./workspace-model.js";
+export * from "./workspace-proposals.js";
diff --git a/packages/ts/src/solutions/work-item/work-queue.ts b/packages/ts/src/solutions/work-item/work-queue.ts
new file mode 100644
index 00000000..65e64672
--- /dev/null
+++ b/packages/ts/src/solutions/work-item/work-queue.ts
@@ -0,0 +1,386 @@
+/**
+ * WorkItem-over-workQueue recipe facts (D327/D331).
+ *
+ * This solution-layer recipe maps WorkItem effect facts to queue submit command facts and maps
+ * terminal queue records back to WorkItem evidence/status. It does not mutate WorkItems or bypass
+ * the generic workQueue admission path.
+ */
+
+import { type Ctx, depBatch } from "../../ctx/types.js";
+import type { DataIssue } from "../../data/index.js";
+import type { Graph } from "../../graph/graph.js";
+import type { Node } from "../../node/node.js";
+import type {
+	AgentOutputEnvelope,
+	AgentRuntimeAuditRecord,
+	EffectRunResultStatus,
+	SourceRef,
+} from "../../orchestration/agent-runtime.js";
+import type {
+	WorkItemEffectRequested,
+	WorkItemEvidenceRecorded,
+	WorkItemStatusRecord,
+} from "../../orchestration/work-item-runtime.js";
+import type { WorkQueueCommand, WorkQueueRecord } from "../../work-queue/index.js";
+
+export interface WorkItemQueuedWorkPayload {
+	readonly kind: "work-item-queued-work";
+	readonly workItemId: string;
+	readonly effectRunId: string;
+	readonly requestId: string;
+	readonly effectKind: string;
+	readonly executionInputRevision?: number;
+	readonly planId?: string;
+	readonly planMemberId?: string;
+	readonly requestedActionKind?: string;
+	readonly sourceEventId?: string;
+	readonly sourceDecisionId?: string;
+	readonly policyRefs?: readonly SourceRef[];
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly contextRefs?: readonly SourceRef[];
+	readonly artifactRefs?: readonly SourceRef[];
+	readonly idempotencyKey?: string;
+	readonly metadata?: Record<string, unknown>;
+}
+
+export type WorkItemQueuedWorkPayloadExtra = Partial<
+	Omit<
+		WorkItemQueuedWorkPayload,
+		"kind" | "workItemId" | "effectRunId" | "requestId" | "effectKind"
+	>
+>;
+
+export interface WorkItemWorkQueueSubmitOptions {
+	readonly workId?: string;
+	readonly priority?: number;
+	readonly tags?: readonly string[];
+	readonly requirements?: readonly string[];
+	readonly notBeforeMs?: number;
+	readonly deadlineMs?: number;
+}
+
+export interface WorkItemWorkQueuePolicy {
+	readonly policyId?: string;
+	readonly submit?: (request: WorkItemEffectRequested) => WorkItemWorkQueueSubmitOptions;
+	readonly payload?: (request: WorkItemEffectRequested) => WorkItemQueuedWorkPayloadExtra;
+	readonly evidenceStatuses?: readonly WorkQueueRecord["kind"][];
+}
+
+export interface WorkItemWorkQueueRecipeOptions {
+	readonly name?: string;
+	readonly effectRequests: Node<WorkItemEffectRequested>;
+	readonly records: Node<WorkQueueRecord<WorkItemQueuedWorkPayload>>;
+	readonly policy?: WorkItemWorkQueuePolicy;
+}
+
+export interface WorkItemWorkQueueRecipeBundle {
+	readonly submitCommands: Node<WorkQueueCommand<WorkItemQueuedWorkPayload>>;
+	readonly evidence: Node<WorkItemEvidenceRecorded>;
+	readonly status: Node<WorkItemStatusRecord>;
+	readonly issues: Node<DataIssue>;
+	readonly audit: Node<AgentRuntimeAuditRecord>;
+}
+
+type WorkItemQueueFact =
+	| { readonly kind: "evidence"; readonly evidence: WorkItemEvidenceRecorded }
+	| { readonly kind: "status"; readonly status: WorkItemStatusRecord }
+	| { readonly kind: "issue"; readonly issue: DataIssue }
+	| { readonly kind: "audit"; readonly audit: AgentRuntimeAuditRecord };
+
+interface WorkItemQueueState {
+	readonly payloads: Map<string, WorkItemQueuedWorkPayload>;
+	readonly terminalRecords: Set<string>;
+	statusSeq: number;
+	auditSeq: number;
+}
+
+const DEFAULT_EVIDENCE_RECORDS: readonly WorkQueueRecord["kind"][] = [
+	"work-completed",
+	"work-canceled",
+	"work-dead-lettered",
+];
+
+export function workItemWorkQueueRecipe(
+	graph: Graph,
+	opts: WorkItemWorkQueueRecipeOptions,
+): WorkItemWorkQueueRecipeBundle {
+	const name = opts.name ?? "workItemWorkQueue";
+	const submitCommands = graph.node<WorkQueueCommand<WorkItemQueuedWorkPayload>>(
+		[opts.effectRequests],
+		(ctx) => {
+			for (const raw of depBatch(ctx, 0) ?? []) {
+				const request = raw as WorkItemEffectRequested;
+				ctx.down([["DATA", workItemSubmitCommand(request, opts.policy)]]);
+			}
+		},
+		{ name: `${name}/submitCommands`, factory: "workItemWorkQueueSubmitCommands" },
+	);
+	const runtime = graph.node<WorkItemQueueFact>(
+		[opts.records],
+		(ctx) => {
+			const state = ctx.state.get<WorkItemQueueState>() ?? emptyState();
+			const evidenceKinds = new Set(opts.policy?.evidenceStatuses ?? DEFAULT_EVIDENCE_RECORDS);
+			for (const raw of depBatch(ctx, 0) ?? []) {
+				const record = raw as WorkQueueRecord<WorkItemQueuedWorkPayload>;
+				if (record.kind === "work-admitted") {
+					state.payloads.set(record.workId, record.payload);
+					continue;
+				}
+				if (!evidenceKinds.has(record.kind)) continue;
+				const key = `${record.kind}:${record.recordSeq}`;
+				if (state.terminalRecords.has(key)) continue;
+				state.terminalRecords.add(key);
+				const payload = "workId" in record ? state.payloads.get(record.workId ?? "") : undefined;
+				if (payload === undefined) {
+					emitIssue(ctx, state, record, "work-item-queue-record-without-payload");
+					continue;
+				}
+				const evidence = evidenceFromRecord(record, payload);
+				emitFact(ctx, { kind: "evidence", evidence });
+				emitStatus(ctx, state, payload, record, evidence.evidenceId, "evidence-recorded");
+				emitAudit(ctx, state, record, payload, "mapped");
+			}
+			ctx.state.set(state);
+		},
+		{
+			name: `${name}/runtime`,
+			factory: "workItemWorkQueueEvidenceProjector",
+			partial: true,
+			completeWhenDepsComplete: false,
+			errorWhenDepsError: false,
+		},
+	);
+	return {
+		submitCommands,
+		evidence: project(graph, runtime, `${name}/evidence`, "workItemWorkQueueEvidence", (fact) =>
+			fact.kind === "evidence" ? fact.evidence : undefined,
+		),
+		status: project(graph, runtime, `${name}/status`, "workItemWorkQueueStatus", (fact) =>
+			fact.kind === "status" ? fact.status : undefined,
+		),
+		issues: project(graph, runtime, `${name}/issues`, "workItemWorkQueueIssues", (fact) =>
+			fact.kind === "issue" ? fact.issue : undefined,
+		),
+		audit: project(graph, runtime, `${name}/audit`, "workItemWorkQueueAudit", (fact) =>
+			fact.kind === "audit" ? fact.audit : undefined,
+		),
+	};
+}
+
+export function workItemSubmitCommand(
+	request: WorkItemEffectRequested,
+	policy?: WorkItemWorkQueuePolicy,
+): WorkQueueCommand<WorkItemQueuedWorkPayload> {
+	const payloadExtra = policy?.payload?.(request) ?? {};
+	const submit = policy?.submit?.(request) ?? {};
+	const payload: WorkItemQueuedWorkPayload = {
+		...payloadExtra,
+		kind: "work-item-queued-work",
+		workItemId: request.workItemId,
+		effectRunId: request.effectRunId,
+		requestId: request.requestId,
+		effectKind: request.effectKind,
+		executionInputRevision: request.executionInputRevision,
+		planId: request.planId,
+		planMemberId: request.planMemberId,
+		policyRefs: request.policyRefs,
+		sourceRefs: request.sourceRefs,
+		idempotencyKey: request.idempotencyKey,
+		metadata: request.metadata,
+	};
+	return {
+		kind: "submit",
+		commandId: `${request.requestId}:work-queue-submit`,
+		payload,
+		workId: submit.workId ?? `${request.workItemId}:${request.effectRunId}`,
+		priority: submit.priority,
+		tags: submit.tags ?? ["work-item", request.effectKind],
+		requirements: submit.requirements,
+		notBeforeMs: submit.notBeforeMs,
+		deadlineMs: submit.deadlineMs,
+		idempotencyKey: request.idempotencyKey ?? request.requestId,
+		sourceRefs: stringRefs(request.sourceRefs),
+		policyRefs: stringRefs(request.policyRefs),
+	};
+}
+
+function evidenceFromRecord(
+	record: WorkQueueRecord<WorkItemQueuedWorkPayload>,
+	payload: WorkItemQueuedWorkPayload,
+): WorkItemEvidenceRecorded {
+	const status = evidenceStatus(record);
+	const base = {
+		kind: "work-item-evidence-recorded" as const,
+		evidenceId: `work-queue:${record.recordSeq}`,
+		workItemId: payload.workItemId,
+		requestId: payload.requestId,
+		effectRunId: payload.effectRunId,
+		effectRunResultId: `work-queue:${record.workId ?? payload.effectRunId}:${record.recordSeq}`,
+		executionInputRevision: payload.executionInputRevision,
+		planId: payload.planId,
+		planMemberId: payload.planMemberId,
+		status,
+		sourceRefs: [...(payload.sourceRefs ?? []), ref("work-queue-record", String(record.recordSeq))],
+		recordedAtMs: record.recordedAtMs,
+		metadata: {
+			...(payload.metadata ?? {}),
+			requestId: payload.requestId,
+			...(payload.executionInputRevision === undefined
+				? {}
+				: { executionInputRevision: payload.executionInputRevision }),
+			...(payload.planId === undefined ? {} : { planId: payload.planId }),
+			...(payload.planMemberId === undefined ? {} : { planMemberId: payload.planMemberId }),
+			queueRecordKind: record.kind,
+			workId: record.workId,
+		},
+	};
+	if (record.kind === "work-completed" || record.kind === "attempt-completed") {
+		return {
+			...base,
+			output: {
+				kind: "work-queue-completion",
+				value: record.result,
+				refs: [ref("work-queue-record", String(record.recordSeq))],
+			} satisfies AgentOutputEnvelope,
+		};
+	}
+	return {
+		...base,
+		error: queueIssue(record, `WorkQueue record '${record.kind}' mapped to WorkItem evidence`),
+		reason: "reason" in record ? record.reason : undefined,
+	};
+}
+
+function evidenceStatus(record: WorkQueueRecord): EffectRunResultStatus {
+	if (record.kind === "work-completed" || record.kind === "attempt-completed") return "completed";
+	if (record.kind === "work-canceled") return "canceled";
+	return "failed";
+}
+
+function emitStatus(
+	ctx: Ctx,
+	state: WorkItemQueueState,
+	payload: WorkItemQueuedWorkPayload,
+	record: WorkQueueRecord<WorkItemQueuedWorkPayload>,
+	evidenceId: string,
+	statusState: WorkItemStatusRecord["state"],
+): void {
+	state.statusSeq += 1;
+	emitFact(ctx, {
+		kind: "status",
+		status: {
+			kind: "work-item-status",
+			statusId: `work-item-work-queue-status:${state.statusSeq}`,
+			workItemId: payload.workItemId,
+			state: statusState,
+			effectRunId: payload.effectRunId,
+			requestId: payload.requestId,
+			evidenceId,
+			sourceRefs: [
+				ref("work-queue-record", String(record.recordSeq)),
+				...(payload.sourceRefs ?? []),
+			],
+			metadata: { queueRecordKind: record.kind, workId: record.workId },
+		},
+	});
+}
+
+function emitIssue(
+	ctx: Ctx,
+	state: WorkItemQueueState,
+	record: WorkQueueRecord<WorkItemQueuedWorkPayload>,
+	code: string,
+): void {
+	const issue = queueIssue(
+		record,
+		`WorkQueue record '${record.kind}' has no admitted WorkItem payload`,
+	);
+	emitFact(ctx, { kind: "issue", issue: { ...issue, code } });
+	state.statusSeq += 1;
+	emitFact(ctx, {
+		kind: "status",
+		status: {
+			kind: "work-item-status",
+			statusId: `work-item-work-queue-status:${state.statusSeq}`,
+			workItemId: record.workId ?? "unknown",
+			state: "mapping-issue",
+			issues: [{ ...issue, code }],
+			sourceRefs: [ref("work-queue-record", String(record.recordSeq))],
+		},
+	});
+}
+
+function emitAudit(
+	ctx: Ctx,
+	state: WorkItemQueueState,
+	record: WorkQueueRecord<WorkItemQueuedWorkPayload>,
+	payload: WorkItemQueuedWorkPayload,
+	outcome: "mapped" | "issue",
+): void {
+	state.auditSeq += 1;
+	emitFact(ctx, {
+		kind: "audit",
+		audit: {
+			id: `work-item-work-queue-audit:${state.auditSeq}`,
+			kind: "work-item-work-queue-record",
+			subjectId: payload.workItemId,
+			message: `WorkQueue record '${record.kind}' ${outcome} as WorkItem evidence`,
+			sourceRefs: [
+				ref("work-item", payload.workItemId),
+				ref("effect-run", payload.effectRunId),
+				ref("work-queue-record", String(record.recordSeq)),
+			],
+			metadata: { queueRecordKind: record.kind, workId: record.workId },
+		},
+	});
+}
+
+function project<T>(
+	graph: Graph,
+	runtime: Node<WorkItemQueueFact>,
+	name: string,
+	factory: string,
+	select: (fact: WorkItemQueueFact) => T | undefined,
+): Node<T> {
+	return graph.node<T>(
+		[runtime],
+		(ctx) => {
+			for (const raw of depBatch(ctx, 0) ?? []) {
+				const selected = select(raw as WorkItemQueueFact);
+				if (selected !== undefined) ctx.down([["DATA", selected]]);
+			}
+		},
+		{ name, factory, partial: true, completeWhenDepsComplete: false, errorWhenDepsError: false },
+	);
+}
+
+function emitFact(ctx: Ctx, fact: WorkItemQueueFact): void {
+	ctx.down([["DATA", fact]]);
+}
+
+function queueIssue(record: WorkQueueRecord, message: string): DataIssue {
+	return {
+		kind: "issue",
+		code: `work-item-${record.kind}`,
+		message,
+		refs: [`work-queue-record:${record.recordSeq}`],
+		metadata: { queueRecordKind: record.kind, workId: record.workId },
+	};
+}
+
+function emptyState(): WorkItemQueueState {
+	return {
+		payloads: new Map(),
+		terminalRecords: new Set(),
+		statusSeq: 0,
+		auditSeq: 0,
+	};
+}
+
+function ref(kind: string, id: string): SourceRef {
+	return { kind, id };
+}
+
+function stringRefs(refs: readonly SourceRef[] | undefined): readonly string[] | undefined {
+	return refs?.map((sourceRef) => `${sourceRef.kind}:${sourceRef.id}`);
+}
diff --git a/packages/ts/src/solutions/work-item/workspace-family-applications.ts b/packages/ts/src/solutions/work-item/workspace-family-applications.ts
new file mode 100644
index 00000000..b829ae21
--- /dev/null
+++ b/packages/ts/src/solutions/work-item/workspace-family-applications.ts
@@ -0,0 +1,10048 @@
+import { type Ctx, depBatch } from "../../ctx/types.js";
+import type { Graph } from "../../graph/graph.js";
+import type { Node } from "../../node/node.js";
+import type { SourceRef } from "../../orchestration/agent-runtime.js";
+import type { WorkItemDomainActionApplication } from "./actions-types.js";
+import { immutableClone, project } from "./scheduling-shared.js";
+import type {
+	WorkItemAuthoringFact,
+	WorkItemCreated,
+	WorkItemDraft,
+	WorkItemProjection,
+} from "./scheduling-types.js";
+import { validateWorkItemDraft } from "./scheduling-validation.js";
+import type {
+	RequiredInputGate,
+	RequiredInputRequest,
+	RequiredInputResponseApplied,
+	RequiredInputResponseProposed,
+	WorkItemLinked,
+	WorkItemLinkProjection,
+	WorkItemUnlinked,
+} from "./workspace-model.js";
+import {
+	projectWorkspaceProposalApplicationStatus,
+	validateWorkspaceProposalApplicationEnvelope,
+	type WorkspaceProposalAdmissionDecision,
+	type WorkspaceProposalApplicationFamilyRef,
+	type WorkspaceProposalApplicationRecorded,
+	type WorkspaceProposalApplicationResult,
+	type WorkspaceProposalApplicationState,
+	type WorkspaceProposalApplicationStatus,
+	type WorkspaceProposalAuditMaterial,
+	type WorkspaceProposalFamily,
+	type WorkspaceProposalReadyRequest,
+	type WorkspaceProposalRecorded,
+	type WorkspaceProposalRecordedIssue,
+	type WorkspaceProposalTargetRef,
+	workspaceProposalApplicationFamilyRef,
+	workspaceProposalDataOnlyIssues,
+} from "./workspace-proposals.js";
+
+export interface WorkspaceProposalRequiredInputResponseApplicationOptions {
+	readonly applicationId: string;
+	readonly gate: RequiredInputGate;
+	readonly request?: RequiredInputRequest;
+	readonly appliedAtMs?: number;
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly audit?: WorkspaceProposalAuditMaterial;
+}
+
+export interface WorkspaceProposalRequiredInputResponseApplicationResult<TValue = unknown>
+	extends WorkspaceProposalApplicationResult {
+	readonly applied?: RequiredInputResponseApplied<TValue>;
+}
+
+export interface WorkspaceProposalRequiredInputResponseApplicationContext {
+	readonly kind: "workspace-proposal-required-input-response-application-context";
+	readonly applicationId: string;
+	readonly proposalId: string;
+	readonly decisionId?: string;
+	readonly gateId?: string;
+	readonly requestId?: string;
+	readonly appliedAtMs?: number;
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly audit?: WorkspaceProposalAuditMaterial;
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface WorkspaceProposalRequiredInputResponseApplicationProjectorOptions<
+	TValue = unknown,
+> {
+	readonly name?: string;
+	readonly records: Node<WorkspaceProposalRecorded<RequiredInputResponseProposed<TValue>>>;
+	readonly decisions: Node<WorkspaceProposalAdmissionDecision>;
+	readonly contexts: Node<WorkspaceProposalRequiredInputResponseApplicationContext>;
+	readonly gates: Node<RequiredInputGate>;
+	readonly requests?: Node<RequiredInputRequest>;
+}
+
+export interface WorkspaceProposalRequiredInputResponseApplicationProjectorBundle<
+	TValue = unknown,
+> {
+	readonly applied: Node<RequiredInputResponseApplied<TValue>>;
+	readonly status: Node<WorkspaceProposalApplicationStatus>;
+	readonly recorded: Node<WorkspaceProposalApplicationRecorded>;
+	readonly issues: Node<WorkspaceProposalRecordedIssue>;
+	readonly audit: Node<WorkspaceProposalFamilyApplicationAuditRecord>;
+}
+
+export interface WorkspaceProposalWorkItemSpawnApplicationOptions<TInput = unknown> {
+	readonly applicationId: string;
+	readonly existingWorkItems?: readonly WorkItemProjection<TInput>[];
+	readonly linkParent?: boolean;
+	readonly createdAtMs?: number;
+	readonly linkedAtMs?: number;
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly audit?: WorkspaceProposalAuditMaterial;
+}
+
+export interface WorkspaceProposalWorkItemSpawnApplicationResult<TInput = unknown>
+	extends WorkspaceProposalApplicationResult {
+	readonly created?: WorkItemCreated<TInput>;
+	readonly linked?: WorkItemLinked;
+}
+
+export interface WorkspaceProposalWorkItemSpawnApplicationContext {
+	readonly kind: "workspace-proposal-work-item-spawn-application-context";
+	readonly applicationId: string;
+	readonly proposalId: string;
+	readonly decisionId?: string;
+	readonly linkParent?: boolean;
+	readonly createdAtMs?: number;
+	readonly linkedAtMs?: number;
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly audit?: WorkspaceProposalAuditMaterial;
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface WorkspaceProposalWorkItemSpawnApplicationProjectorOptions<TInput = unknown> {
+	readonly name?: string;
+	readonly records: Node<
+		WorkspaceProposalRecorded<{
+			readonly kind: "work-item-spawn-proposed";
+			readonly proposedWorkItemId?: string;
+			readonly parentWorkItemId?: string;
+			readonly draft: WorkItemDraft<TInput>;
+			readonly proposedBy?: string;
+			readonly idempotencyKey?: string;
+			readonly sourceRefs?: readonly SourceRef[];
+			readonly metadata?: Record<string, unknown>;
+		}>
+	>;
+	readonly decisions: Node<WorkspaceProposalAdmissionDecision>;
+	readonly contexts: Node<WorkspaceProposalWorkItemSpawnApplicationContext>;
+	readonly workItems?: Node<WorkItemProjection<TInput>>;
+}
+
+export interface WorkspaceProposalWorkItemSpawnApplicationProjectorBundle<TInput = unknown> {
+	readonly created: Node<WorkItemCreated<TInput>>;
+	readonly linked: Node<WorkItemLinked>;
+	readonly status: Node<WorkspaceProposalApplicationStatus>;
+	readonly recorded: Node<WorkspaceProposalApplicationRecorded>;
+	readonly issues: Node<WorkspaceProposalRecordedIssue>;
+	readonly audit: Node<WorkspaceProposalFamilyApplicationAuditRecord>;
+}
+
+export interface WorkItemLinkProposalDraft {
+	readonly kind: "work-item-link-proposal";
+	readonly action?: "link" | "unlink";
+	readonly eventId?: string;
+	readonly linkId: string;
+	readonly fromWorkItemId?: string;
+	readonly toWorkItemId?: string;
+	readonly linkKind?: string;
+	readonly direction?: WorkItemLinked["direction"];
+	readonly reason?: string;
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface WorkspaceProposalWorkItemLinkApplicationOptions<TInput = unknown> {
+	readonly applicationId: string;
+	readonly workItems?: readonly WorkItemProjection<TInput>[];
+	readonly links?: readonly WorkItemLinkProjection[];
+	readonly linkedAtMs?: number;
+	readonly unlinkedAtMs?: number;
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly audit?: WorkspaceProposalAuditMaterial;
+}
+
+export interface WorkspaceProposalWorkItemLinkApplicationResult
+	extends WorkspaceProposalApplicationResult {
+	readonly linked?: WorkItemLinked;
+	readonly unlinked?: WorkItemUnlinked;
+}
+
+export interface WorkspaceProposalWorkItemLinkApplicationContext {
+	readonly kind: "workspace-proposal-work-item-link-application-context";
+	readonly applicationId: string;
+	readonly proposalId: string;
+	readonly decisionId?: string;
+	readonly linkedAtMs?: number;
+	readonly unlinkedAtMs?: number;
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly audit?: WorkspaceProposalAuditMaterial;
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface WorkspaceProposalWorkItemLinkApplicationProjectorOptions<TInput = unknown> {
+	readonly name?: string;
+	readonly records: Node<WorkspaceProposalRecorded<WorkItemLinkProposalDraft>>;
+	readonly decisions: Node<WorkspaceProposalAdmissionDecision>;
+	readonly contexts: Node<WorkspaceProposalWorkItemLinkApplicationContext>;
+	readonly workItems?: Node<WorkItemProjection<TInput>>;
+	readonly links?: Node<WorkItemLinkProjection>;
+}
+
+export interface WorkspaceProposalWorkItemLinkApplicationProjectorBundle {
+	readonly linked: Node<WorkItemLinked>;
+	readonly unlinked: Node<WorkItemUnlinked>;
+	readonly status: Node<WorkspaceProposalApplicationStatus>;
+	readonly recorded: Node<WorkspaceProposalApplicationRecorded>;
+	readonly issues: Node<WorkspaceProposalRecordedIssue>;
+	readonly audit: Node<WorkspaceProposalFamilyApplicationAuditRecord>;
+}
+
+export interface WorkspaceProposalDomainActionApplicationStatusOptions {
+	readonly applicationId: string;
+	readonly emittedFacts: readonly WorkItemAuthoringFact[];
+	readonly domainApplication?: WorkItemDomainActionApplication;
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly audit?: WorkspaceProposalAuditMaterial;
+}
+
+export interface WorkspaceProposalDomainActionApplicationContext {
+	readonly kind: "workspace-proposal-domain-action-application-context";
+	readonly applicationId: string;
+	readonly proposalId: string;
+	readonly decisionId?: string;
+	readonly domainApplicationId?: string;
+	readonly emittedFactIds?: readonly string[];
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly audit?: WorkspaceProposalAuditMaterial;
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface WorkspaceProposalDomainActionApplicationProjectorOptions {
+	readonly name?: string;
+	readonly records: Node<WorkspaceProposalRecorded>;
+	readonly decisions: Node<WorkspaceProposalAdmissionDecision>;
+	readonly contexts: Node<WorkspaceProposalDomainActionApplicationContext>;
+	readonly emittedFacts: Node<WorkItemAuthoringFact>;
+	readonly domainApplications?: Node<WorkItemDomainActionApplication>;
+}
+
+export interface WorkspaceProposalDomainActionApplicationProjectorBundle {
+	readonly status: Node<WorkspaceProposalApplicationStatus>;
+	readonly recorded: Node<WorkspaceProposalApplicationRecorded>;
+	readonly issues: Node<WorkspaceProposalRecordedIssue>;
+	readonly audit: Node<WorkspaceProposalFamilyApplicationAuditRecord>;
+}
+
+export interface WorkspaceProposalFamilyApplicationAuditRecord {
+	readonly kind: "workspace-proposal-family-application-audit";
+	readonly auditId: string;
+	readonly applicationId: string;
+	readonly proposalId: string;
+	readonly decisionId?: string;
+	readonly proposalFamily: string;
+	readonly state: WorkspaceProposalApplicationState;
+	readonly emittedFactRefs: readonly WorkspaceProposalApplicationFamilyRef[];
+	readonly code?: string;
+	readonly issues?: readonly WorkspaceProposalRecordedIssue[];
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly audit?: WorkspaceProposalAuditMaterial;
+	readonly metadata?: Record<string, unknown>;
+}
+
+export type WorkspaceProposalFamilyOutcomeRecordState =
+	| "recorded"
+	| "not-recorded"
+	| "pending"
+	| "partial"
+	| "repair-needed"
+	| "idempotency-conflict";
+
+export type WorkspaceProposalFamilyOutcomeRecord =
+	| WorkspaceProposalRequiredInputResponseOutcomeRecorded
+	| WorkspaceProposalWorkItemSpawnOutcomeRecorded
+	| WorkspaceProposalWorkItemLinkOutcomeRecorded
+	| WorkspaceProposalDomainActionOutcomeRecorded;
+
+export interface WorkspaceProposalFamilyOutcomeRef {
+	readonly kind: "workspace-proposal-family-outcome-ref";
+	readonly applicationId: string;
+	readonly proposalId: string;
+	readonly decisionId: string;
+	readonly idempotencyKey: string;
+	readonly proposalFamily: WorkspaceProposalFamily;
+	readonly outcomeKind: WorkspaceProposalFamilyOutcomeRecord["kind"];
+	readonly outcomeId: string;
+	readonly sourceRefs: readonly SourceRef[];
+}
+
+export interface WorkspaceProposalFamilyOutcomeRecordStatus {
+	readonly kind: "workspace-proposal-family-outcome-record-status";
+	readonly outcomeId: string;
+	readonly applicationId: string;
+	readonly proposalId: string;
+	readonly decisionId: string;
+	readonly idempotencyKey: string;
+	readonly proposalFamily: WorkspaceProposalFamily;
+	readonly state: WorkspaceProposalFamilyOutcomeRecordState;
+	readonly code?: string;
+	readonly issues: readonly WorkspaceProposalRecordedIssue[];
+	readonly outcomeRefs: readonly WorkspaceProposalFamilyOutcomeRef[];
+	readonly sourceRefs: readonly SourceRef[];
+	readonly audit?: WorkspaceProposalAuditMaterial;
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface WorkspaceProposalFamilyOutcomeRecordResult<
+	TOutcome extends WorkspaceProposalFamilyOutcomeRecord,
+> {
+	readonly outcome?: TOutcome;
+	readonly status: WorkspaceProposalFamilyOutcomeRecordStatus;
+	readonly issues: readonly WorkspaceProposalRecordedIssue[];
+}
+
+export interface WorkspaceProposalFamilyEvidenceHorizon {
+	readonly kind: "workspace-proposal-family-evidence-horizon";
+	readonly horizonId: string;
+	readonly applicationId: string;
+	readonly state: "open" | "closed";
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly audit?: WorkspaceProposalAuditMaterial;
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface WorkspaceProposalFamilyCompletionPolicy {
+	readonly kind: "workspace-proposal-family-completion-policy";
+	readonly policyId: string;
+	readonly proposalFamily?: WorkspaceProposalFamily;
+	readonly domainActionCompletion?: "single-action" | "multi-step-partial";
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly audit?: WorkspaceProposalAuditMaterial;
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface WorkspaceProposalRequiredInputResponseOutcomeOptions {
+	readonly outcomeId: string;
+	readonly requiredInputRequestId?: string;
+	readonly responseRef?: SourceRef;
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly audit?: WorkspaceProposalAuditMaterial;
+	readonly horizon?: WorkspaceProposalFamilyEvidenceHorizon;
+	readonly policy?: WorkspaceProposalFamilyCompletionPolicy;
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface WorkspaceProposalWorkItemSpawnOutcomeOptions {
+	readonly outcomeId: string;
+	readonly workItemRef?: SourceRef;
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly audit?: WorkspaceProposalAuditMaterial;
+	readonly horizon?: WorkspaceProposalFamilyEvidenceHorizon;
+	readonly policy?: WorkspaceProposalFamilyCompletionPolicy;
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface WorkspaceProposalWorkItemLinkOutcomeOptions {
+	readonly outcomeId: string;
+	readonly linkRef?: SourceRef;
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly audit?: WorkspaceProposalAuditMaterial;
+	readonly horizon?: WorkspaceProposalFamilyEvidenceHorizon;
+	readonly policy?: WorkspaceProposalFamilyCompletionPolicy;
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface WorkspaceProposalDomainActionOutcomeOptions {
+	readonly outcomeId: string;
+	readonly actionRef?: SourceRef;
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly audit?: WorkspaceProposalAuditMaterial;
+	readonly horizon?: WorkspaceProposalFamilyEvidenceHorizon;
+	readonly policy?: WorkspaceProposalFamilyCompletionPolicy;
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface WorkspaceProposalRequiredInputResponseOutcomeRecorded {
+	readonly kind: "workspace-proposal-required-input-response-outcome-recorded";
+	readonly outcomeId: string;
+	readonly applicationId: string;
+	readonly proposalId: string;
+	readonly decisionId: string;
+	readonly idempotencyKey: string;
+	readonly proposalFamily: "required-input-response";
+	readonly requiredInputRequestId: string;
+	readonly responseRef: SourceRef;
+	readonly sourceRefs: readonly SourceRef[];
+	readonly audit?: WorkspaceProposalAuditMaterial;
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface WorkspaceProposalWorkItemSpawnOutcomeRecorded {
+	readonly kind: "workspace-proposal-work-item-spawn-outcome-recorded";
+	readonly outcomeId: string;
+	readonly applicationId: string;
+	readonly proposalId: string;
+	readonly decisionId: string;
+	readonly idempotencyKey: string;
+	readonly proposalFamily: "work-item-spawn";
+	readonly workItemRef: SourceRef;
+	readonly sourceRefs: readonly SourceRef[];
+	readonly audit?: WorkspaceProposalAuditMaterial;
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface WorkspaceProposalWorkItemLinkOutcomeRecorded {
+	readonly kind: "workspace-proposal-work-item-link-outcome-recorded";
+	readonly outcomeId: string;
+	readonly applicationId: string;
+	readonly proposalId: string;
+	readonly decisionId: string;
+	readonly idempotencyKey: string;
+	readonly proposalFamily: "work-item-link";
+	readonly linkRef: SourceRef;
+	readonly sourceRefs: readonly SourceRef[];
+	readonly audit?: WorkspaceProposalAuditMaterial;
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface WorkspaceProposalDomainActionOutcomeRecorded {
+	readonly kind: "workspace-proposal-domain-action-outcome-recorded";
+	readonly outcomeId: string;
+	readonly applicationId: string;
+	readonly proposalId: string;
+	readonly decisionId: string;
+	readonly idempotencyKey: string;
+	readonly proposalFamily: "work-item-domain-action";
+	readonly actionRef: SourceRef;
+	readonly sourceRefs: readonly SourceRef[];
+	readonly audit?: WorkspaceProposalAuditMaterial;
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface WorkspaceProposalFamilyOutcomeIndexEntry {
+	readonly kind: "workspace-proposal-family-outcome-index-entry";
+	readonly indexKey: string;
+	readonly applicationId: string;
+	readonly proposalId: string;
+	readonly decisionId: string;
+	readonly idempotencyKey: string;
+	readonly proposalFamily: WorkspaceProposalFamily;
+	readonly state: "recorded" | "idempotency-conflict";
+	readonly outcomeRefs: readonly WorkspaceProposalFamilyOutcomeRef[];
+	readonly sourceRefs: readonly SourceRef[];
+	readonly audit?: WorkspaceProposalAuditMaterial;
+	readonly issues: readonly WorkspaceProposalRecordedIssue[];
+}
+
+export interface WorkspaceProposalRepairReviewRequest {
+	readonly kind: "workspace-proposal-repair-review-request";
+	readonly repairRequestId: string;
+	readonly applicationId: string;
+	readonly proposalId: string;
+	readonly decisionId: string;
+	readonly idempotencyKey: string;
+	readonly proposalFamily: WorkspaceProposalFamily;
+	readonly code: string;
+	readonly issues: readonly WorkspaceProposalRecordedIssue[];
+	readonly subjectRefs?: readonly SourceRef[];
+	readonly sourceRefs: readonly SourceRef[];
+	readonly audit?: WorkspaceProposalAuditMaterial;
+}
+
+export type WorkspaceProposalRepairReviewDecisionIntent =
+	| "acknowledged"
+	| "resolved"
+	| "withdrawn"
+	| "superseded";
+
+export type WorkspaceProposalRepairReviewLifecycleState =
+	| "open"
+	| "acknowledged"
+	| "resolved"
+	| "withdrawn"
+	| "superseded"
+	| "conflict";
+
+export type WorkspaceProposalRepairReviewProofKind =
+	| "human-decision"
+	| "family-outcome-status"
+	| "family-outcome-index"
+	| "application-status"
+	| "application-recorded";
+
+export interface WorkspaceProposalRepairReviewDecision {
+	readonly kind: "workspace-proposal-repair-review-decision";
+	readonly reviewDecisionId: string;
+	readonly repairRequestId: string;
+	readonly applicationId: string;
+	readonly proposalId: string;
+	readonly decisionId: string;
+	readonly idempotencyKey: string;
+	readonly proposalFamily: WorkspaceProposalFamily;
+	readonly intent: WorkspaceProposalRepairReviewDecisionIntent;
+	readonly reviewerRef?: SourceRef;
+	readonly actorRef?: SourceRef;
+	readonly capabilityRefs?: readonly SourceRef[];
+	readonly policyRefs?: readonly SourceRef[];
+	readonly reason?: string;
+	readonly code?: string;
+	readonly resolvesRefs?: readonly SourceRef[];
+	readonly supersedesRefs?: readonly SourceRef[];
+	readonly decidedAtMs?: number;
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly audit?: WorkspaceProposalAuditMaterial;
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface WorkspaceProposalRepairReviewStatus {
+	readonly kind: "workspace-proposal-repair-review-status";
+	readonly repairRequestId: string;
+	readonly applicationId: string;
+	readonly proposalId: string;
+	readonly decisionId: string;
+	readonly idempotencyKey: string;
+	readonly proposalFamily: WorkspaceProposalFamily;
+	readonly state: WorkspaceProposalRepairReviewLifecycleState;
+	readonly code?: string;
+	readonly proofKind?: WorkspaceProposalRepairReviewProofKind;
+	readonly proofRefs: readonly SourceRef[];
+	readonly decisions: readonly WorkspaceProposalRepairReviewDecision[];
+	readonly conflicts: readonly WorkspaceProposalRepairReviewDecision[];
+	readonly issues: readonly WorkspaceProposalRecordedIssue[];
+	readonly sourceRefs: readonly SourceRef[];
+	readonly audit?: WorkspaceProposalAuditMaterial;
+	readonly metadata?: Record<string, unknown>;
+}
+
+/** D438/D434 diagnostic classes for Workspace family application view material. */
+export type WorkspaceProposalFamilyApplicationDiagnosticClass =
+	| "missing-durable-handoff"
+	| "missing-family-material"
+	| "idempotency-conflict"
+	| "malformed-family-material";
+
+/**
+ * Human-visible Workspace diagnostic view material.
+ *
+ * This is projection-only: it does not create proposal, admission, application,
+ * family truth, outcome, or repair authority (D438/D434/D437).
+ */
+export interface WorkspaceProposalFamilyApplicationDiagnostic {
+	readonly kind: "workspace-proposal-family-application-diagnostic";
+	readonly diagnosticId: string;
+	readonly classification: WorkspaceProposalFamilyApplicationDiagnosticClass;
+	readonly applicationId?: string;
+	readonly proposalId?: string;
+	readonly decisionId?: string;
+	readonly idempotencyKey?: string;
+	readonly proposalFamily?: WorkspaceProposalFamily;
+	readonly code: string;
+	readonly issues: readonly WorkspaceProposalRecordedIssue[];
+	readonly sourceRefs: readonly SourceRef[];
+	readonly audit?: WorkspaceProposalAuditMaterial;
+	readonly metadata?: Record<string, unknown>;
+}
+
+/** Existing material consumed by the family application diagnostic projector. */
+export interface WorkspaceProposalFamilyApplicationDiagnosticProjectionInput {
+	readonly issues?: readonly WorkspaceProposalRecordedIssue[];
+	readonly audit?: readonly WorkspaceProposalFamilyApplicationAuditRecord[];
+	readonly applicationStatuses?: readonly WorkspaceProposalApplicationStatus[];
+	readonly outcomeStatuses?: readonly WorkspaceProposalFamilyOutcomeRecordStatus[];
+	readonly outcomeIndex?: readonly WorkspaceProposalFamilyOutcomeIndexEntry[];
+}
+
+/** Graph inputs for the family application diagnostic projector. */
+export interface WorkspaceProposalFamilyApplicationDiagnosticProjectorOptions {
+	readonly name?: string;
+	readonly issues?: Node<WorkspaceProposalRecordedIssue>;
+	readonly audit?: Node<WorkspaceProposalFamilyApplicationAuditRecord>;
+	readonly applicationStatuses?: Node<WorkspaceProposalApplicationStatus>;
+	readonly outcomeStatuses?: Node<WorkspaceProposalFamilyOutcomeRecordStatus>;
+	readonly outcomeIndex?: Node<WorkspaceProposalFamilyOutcomeIndexEntry>;
+}
+
+/** Graph-visible diagnostic projection output. */
+export interface WorkspaceProposalFamilyApplicationDiagnosticProjectorBundle {
+	readonly diagnostics: Node<WorkspaceProposalFamilyApplicationDiagnostic>;
+}
+
+/** Existing durable status/outcome/index material eligible for repair review lowering. */
+export interface WorkspaceProposalRepairReviewProjectionInput {
+	readonly applicationStatuses?: readonly WorkspaceProposalApplicationStatus[];
+	readonly outcomeStatuses?: readonly WorkspaceProposalFamilyOutcomeRecordStatus[];
+	readonly outcomeIndex?: readonly WorkspaceProposalFamilyOutcomeIndexEntry[];
+}
+
+/** Graph inputs for human-visible repair review request projection. */
+export interface WorkspaceProposalRepairReviewProjectorOptions {
+	readonly name?: string;
+	readonly applicationStatuses?: Node<WorkspaceProposalApplicationStatus>;
+	readonly outcomeStatuses?: Node<WorkspaceProposalFamilyOutcomeRecordStatus>;
+	readonly outcomeIndex?: Node<WorkspaceProposalFamilyOutcomeIndexEntry>;
+}
+
+/** Graph-visible human review requests; requests do not authorize remutation. */
+export interface WorkspaceProposalRepairReviewProjectorBundle {
+	readonly requests: Node<WorkspaceProposalRepairReviewRequest>;
+}
+
+export interface WorkspaceProposalRepairReviewStatusProjectionInput {
+	readonly requests?: readonly WorkspaceProposalRepairReviewRequest[];
+	readonly decisions?: readonly WorkspaceProposalRepairReviewDecision[];
+	readonly applicationStatuses?: readonly WorkspaceProposalApplicationStatus[];
+	readonly applicationRecorded?: readonly WorkspaceProposalApplicationRecorded[];
+	readonly outcomeStatuses?: readonly WorkspaceProposalFamilyOutcomeRecordStatus[];
+	readonly outcomeIndex?: readonly WorkspaceProposalFamilyOutcomeIndexEntry[];
+}
+
+export interface WorkspaceProposalRepairReviewStatusProjectorOptions {
+	readonly name?: string;
+	readonly requests: Node<WorkspaceProposalRepairReviewRequest>;
+	readonly decisions?: Node<WorkspaceProposalRepairReviewDecision>;
+	readonly applicationStatuses?: Node<WorkspaceProposalApplicationStatus>;
+	readonly applicationRecorded?: Node<WorkspaceProposalApplicationRecorded>;
+	readonly outcomeStatuses?: Node<WorkspaceProposalFamilyOutcomeRecordStatus>;
+	readonly outcomeIndex?: Node<WorkspaceProposalFamilyOutcomeIndexEntry>;
+}
+
+export interface WorkspaceProposalRepairReviewStatusProjectorBundle {
+	readonly statuses: Node<WorkspaceProposalRepairReviewStatus>;
+}
+
+export type WorkspaceProposalRepairReviewDecisionRecordingStatus = "recorded" | "blocked";
+
+export interface WorkspaceProposalRepairReviewExpectedCurrentState {
+	readonly state?: WorkspaceProposalRepairReviewLifecycleState;
+	readonly code?: string;
+	readonly proofKind?: WorkspaceProposalRepairReviewProofKind;
+	readonly proofRefs?: readonly SourceRef[];
+}
+
+export interface WorkspaceProposalRepairReviewDecisionRecordingOptions {
+	readonly reviewDecisionId?: string;
+	readonly intent?: WorkspaceProposalRepairReviewDecisionIntent;
+	readonly reviewerRef?: SourceRef;
+	readonly actorRef?: SourceRef;
+	readonly capabilityRefs?: readonly SourceRef[];
+	readonly policyRefs?: readonly SourceRef[];
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly audit?: WorkspaceProposalAuditMaterial;
+	readonly reason?: string;
+	readonly code?: string;
+	readonly resolvesRefs?: readonly SourceRef[];
+	readonly supersedesRefs?: readonly SourceRef[];
+	readonly decidedAtMs?: number;
+	readonly metadata?: Record<string, unknown>;
+	readonly currentStatus?: WorkspaceProposalRepairReviewStatus;
+	readonly expectedCurrentState?: WorkspaceProposalRepairReviewExpectedCurrentState;
+}
+
+export interface WorkspaceProposalRepairReviewDecisionRecordingInput {
+	readonly kind: "workspace-proposal-repair-review-decision-recording-input";
+	readonly repairRequestId: string;
+	readonly reviewDecisionId: string;
+	readonly intent: WorkspaceProposalRepairReviewDecisionIntent;
+	readonly reviewerRef?: SourceRef;
+	readonly actorRef?: SourceRef;
+	readonly capabilityRefs?: readonly SourceRef[];
+	readonly policyRefs?: readonly SourceRef[];
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly audit?: WorkspaceProposalAuditMaterial;
+	readonly reason?: string;
+	readonly code?: string;
+	readonly resolvesRefs?: readonly SourceRef[];
+	readonly supersedesRefs?: readonly SourceRef[];
+	readonly decidedAtMs?: number;
+	readonly metadata?: Record<string, unknown>;
+	readonly expectedCurrentState?: WorkspaceProposalRepairReviewExpectedCurrentState;
+}
+
+export interface WorkspaceProposalRepairReviewDecisionRecordingResult {
+	readonly kind: "workspace-proposal-repair-review-decision-recording-result";
+	readonly status: WorkspaceProposalRepairReviewDecisionRecordingStatus;
+	readonly decision?: WorkspaceProposalRepairReviewDecision;
+	readonly issues: readonly WorkspaceProposalRecordedIssue[];
+	readonly audit?: WorkspaceProposalAuditMaterial;
+	readonly sourceRefs: readonly SourceRef[];
+}
+
+export interface WorkspaceProposalRepairReviewDecisionRecordingProjectionInput {
+	readonly requests?: readonly WorkspaceProposalRepairReviewRequest[];
+	readonly recordingInputs?: readonly WorkspaceProposalRepairReviewDecisionRecordingInput[];
+	readonly statuses?: readonly WorkspaceProposalRepairReviewStatus[];
+}
+
+export interface WorkspaceProposalRepairReviewDecisionRecordingProjectorOptions {
+	readonly name?: string;
+	readonly requests: Node<WorkspaceProposalRepairReviewRequest>;
+	readonly recordingInputs: Node<WorkspaceProposalRepairReviewDecisionRecordingInput>;
+	readonly statuses?: Node<WorkspaceProposalRepairReviewStatus>;
+}
+
+export interface WorkspaceProposalRepairReviewDecisionRecordingProjectorBundle {
+	readonly results: Node<WorkspaceProposalRepairReviewDecisionRecordingResult>;
+	readonly decisions: Node<WorkspaceProposalRepairReviewDecision>;
+	readonly issues: Node<WorkspaceProposalRecordedIssue>;
+}
+
+export interface WorkspaceProposalFamilyOutcomeDetail {
+	readonly kind: "workspace-proposal-family-outcome-detail";
+	readonly outcomeRef: WorkspaceProposalFamilyOutcomeRef;
+	readonly outcome?: WorkspaceProposalFamilyOutcomeRecord;
+	readonly status?: WorkspaceProposalFamilyOutcomeRecordStatus;
+}
+
+export interface WorkspaceProposalFamilyApplicationReadModelDisplayDiagnostic {
+	readonly kind: "workspace-proposal-family-application-read-model-display-diagnostic";
+	readonly diagnosticId: string;
+	readonly code:
+		| "incomplete-read-model-query"
+		| "malformed-read-model-query"
+		| "malformed-read-model-presentation-options"
+		| "malformed-outcome-detail-supply-request"
+		| "malformed-supplied-outcome-detail"
+		| "missing-supplied-outcome-detail"
+		| "mismatched-supplied-outcome-detail"
+		| "missing-outcome-detail"
+		| "mismatched-outcome-detail"
+		| "mismatched-outcome-status";
+	readonly message: string;
+	readonly queryId?: string;
+	readonly viewId?: string;
+	readonly applicationId?: string;
+	readonly proposalId?: string;
+	readonly decisionId?: string;
+	readonly idempotencyKey?: string;
+	readonly proposalFamily?: WorkspaceProposalFamily;
+	readonly outcomeRef?: WorkspaceProposalFamilyOutcomeRef;
+	readonly sourceRefs: readonly SourceRef[];
+}
+
+export type WorkspaceProposalFamilyApplicationReadModelSortField =
+	| "outcome-id"
+	| "outcome-kind"
+	| "diagnostic-code"
+	| "repair-state"
+	| "recorded-at-ms";
+
+export type WorkspaceProposalFamilyApplicationReadModelSortDirection = "asc" | "desc";
+
+export interface WorkspaceProposalFamilyApplicationReadModelSortOption {
+	readonly field: WorkspaceProposalFamilyApplicationReadModelSortField;
+	readonly direction: WorkspaceProposalFamilyApplicationReadModelSortDirection;
+}
+
+export type WorkspaceProposalFamilyApplicationReadModelGroupField =
+	| "outcome-kind"
+	| "repair-state"
+	| "diagnostic-code";
+
+export type WorkspaceProposalFamilyApplicationReadModelSearchField =
+	| "outcome-id"
+	| "outcome-kind"
+	| "diagnostic-code"
+	| "diagnostic-message"
+	| "repair-state";
+
+export interface WorkspaceProposalFamilyApplicationReadModelSearchOptions {
+	readonly text?: string;
+	readonly fields?: readonly WorkspaceProposalFamilyApplicationReadModelSearchField[];
+}
+
+export interface WorkspaceProposalFamilyApplicationReadModelNormalizedSearch {
+	readonly text: string;
+	readonly fields: readonly WorkspaceProposalFamilyApplicationReadModelSearchField[];
+}
+
+export interface WorkspaceProposalFamilyApplicationReadModelDisplayGroup {
+	readonly kind: "workspace-proposal-family-application-read-model-display-group";
+	readonly field: WorkspaceProposalFamilyApplicationReadModelGroupField;
+	readonly value: string;
+	readonly outcomeRefs: readonly WorkspaceProposalFamilyOutcomeRef[];
+	readonly count: number;
+}
+
+export interface WorkspaceProposalFamilyApplicationReadModel {
+	readonly kind: "workspace-proposal-family-application-read-model";
+	readonly readModelId: string;
+	readonly queryId?: string;
+	readonly viewId?: string;
+	readonly applicationId?: string;
+	readonly proposalId?: string;
+	readonly decisionId?: string;
+	readonly idempotencyKey?: string;
+	readonly proposalFamily?: WorkspaceProposalFamily;
+	readonly filters?: WorkspaceProposalFamilyApplicationReadModelNormalizedFilters;
+	readonly sort?: readonly WorkspaceProposalFamilyApplicationReadModelSortOption[];
+	readonly groupBy?: readonly WorkspaceProposalFamilyApplicationReadModelGroupField[];
+	readonly search?: WorkspaceProposalFamilyApplicationReadModelNormalizedSearch;
+	readonly diagnostics: readonly WorkspaceProposalFamilyApplicationDiagnostic[];
+	readonly repairReviewStatuses: readonly WorkspaceProposalRepairReviewStatus[];
+	readonly outcomeIndexes: readonly WorkspaceProposalFamilyOutcomeIndexEntry[];
+	readonly outcomeDetails: readonly WorkspaceProposalFamilyOutcomeDetail[];
+	readonly displayGroups: readonly WorkspaceProposalFamilyApplicationReadModelDisplayGroup[];
+	readonly displayDiagnostics: readonly WorkspaceProposalFamilyApplicationReadModelDisplayDiagnostic[];
+	readonly page: {
+		readonly offset: number;
+		readonly limit: number;
+		readonly totalOutcomeRefs: number;
+		readonly returnedOutcomeRefs: number;
+	};
+}
+
+export interface WorkspaceProposalFamilyApplicationReadModelPage {
+	readonly offset?: number;
+	readonly limit?: number;
+}
+
+export interface WorkspaceProposalFamilyApplicationReadModelFilters {
+	readonly outcomeIds?: readonly string[];
+	readonly outcomeKinds?: readonly WorkspaceProposalFamilyOutcomeRecord["kind"][];
+	readonly diagnosticCodes?: readonly string[];
+	readonly repairStates?: readonly WorkspaceProposalRepairReviewLifecycleState[];
+}
+
+export interface WorkspaceProposalFamilyApplicationReadModelNormalizedFilters {
+	readonly outcomeIds: readonly string[];
+	readonly outcomeKinds: readonly WorkspaceProposalFamilyOutcomeRecord["kind"][];
+	readonly diagnosticCodes: readonly string[];
+	readonly repairStates: readonly WorkspaceProposalRepairReviewLifecycleState[];
+}
+
+export interface WorkspaceProposalFamilyApplicationReadModelQuery {
+	readonly kind: "workspace-proposal-family-application-read-model-query";
+	readonly queryId: string;
+	readonly viewId?: string;
+	readonly applicationId: string;
+	readonly proposalId: string;
+	readonly decisionId: string;
+	readonly idempotencyKey: string;
+	readonly proposalFamily: WorkspaceProposalFamily;
+	readonly page?: WorkspaceProposalFamilyApplicationReadModelPage;
+	readonly filters?: WorkspaceProposalFamilyApplicationReadModelFilters;
+	readonly sort?: readonly WorkspaceProposalFamilyApplicationReadModelSortOption[];
+	readonly groupBy?: readonly WorkspaceProposalFamilyApplicationReadModelGroupField[];
+	readonly search?: WorkspaceProposalFamilyApplicationReadModelSearchOptions;
+	readonly sourceRefs: readonly SourceRef[];
+	readonly audit?: WorkspaceProposalAuditMaterial;
+	readonly metadata?: Record<string, unknown>;
+}
+
+/**
+ * Closed D472 current-view scopes that Workspace projection release material may target.
+ *
+ * Release targets are projector-local display/read-model retention scopes only; they are
+ * not proposal truth, permission proof, storage ownership, or history deletion handles.
+ */
+export type WorkspaceProposalProjectionReleaseTargetKind =
+	| "family-read-model-query"
+	| "outcome-detail-supply-request"
+	| "repair-action-advisory"
+	| "repair-action-intent"
+	| "repair-successor-preview"
+	| "repair-successor-preparation";
+
+/**
+ * D472 graph-visible request to release projector-local current-view material.
+ *
+ * A release may let a projector prune retained request/input/signature state, but it
+ * does not revoke DATA history, delete proposal/admission/application/family truth,
+ * satisfy policy validation, or carry runtime/storage/provider handles.
+ */
+export interface WorkspaceProposalProjectionRelease {
+	readonly kind: "workspace-proposal-projection-release";
+	readonly releaseId: string;
+	readonly targetKind: WorkspaceProposalProjectionReleaseTargetKind;
+	readonly targetId: string;
+	readonly sourceRefs: readonly SourceRef[];
+	readonly viewId?: string;
+	readonly applicationId?: string;
+	readonly proposalId?: string;
+	readonly decisionId?: string;
+	readonly idempotencyKey?: string;
+	readonly proposalFamily?: WorkspaceProposalFamily;
+	readonly queryId?: string;
+	readonly supplyRequestId?: string;
+	readonly descriptorId?: string;
+	readonly repairRequestId?: string;
+	readonly actionKind?: WorkspaceProposalRepairActionKind;
+	readonly intentId?: string;
+	readonly previewId?: string;
+	readonly preparationId?: string;
+	readonly audit?: WorkspaceProposalAuditMaterial;
+	readonly metadata?: Record<string, unknown>;
+}
+
+/**
+ * D473 validation result for projection release material.
+ *
+ * Accepted results carry a frozen data-only release DTO; blocked results are
+ * diagnostics input only and do not prove that any retained state existed.
+ */
+export interface WorkspaceProposalProjectionReleaseValidationResult {
+	readonly kind: "workspace-proposal-projection-release-validation-result";
+	readonly status: "accepted" | "blocked";
+	readonly release?: WorkspaceProposalProjectionRelease;
+	readonly releaseId?: string;
+	readonly targetKind?: WorkspaceProposalProjectionReleaseTargetKind;
+	readonly targetId?: string;
+	readonly issues: readonly WorkspaceProposalRecordedIssue[];
+	readonly sourceRefs: readonly SourceRef[];
+	readonly audit?: WorkspaceProposalAuditMaterial;
+}
+
+/**
+ * D473 data-only diagnostic for malformed or unsafe release material.
+ *
+ * Diagnostics report why a release was ignored; they are not permission,
+ * retention, deletion, revocation, or historical-truth evidence.
+ */
+export interface WorkspaceProposalProjectionReleaseDiagnostic {
+	readonly kind: "workspace-proposal-projection-release-diagnostic";
+	readonly diagnosticId: string;
+	readonly releaseId?: string;
+	readonly targetKind?: WorkspaceProposalProjectionReleaseTargetKind;
+	readonly targetId?: string;
+	readonly status: "blocked";
+	readonly issues: readonly WorkspaceProposalRecordedIssue[];
+	readonly sourceRefs: readonly SourceRef[];
+	readonly audit?: WorkspaceProposalAuditMaterial;
+}
+
+export interface WorkspaceProposalFamilyApplicationReadModelProjectionInput {
+	readonly diagnostics?: readonly WorkspaceProposalFamilyApplicationDiagnostic[];
+	readonly repairReviewStatuses?: readonly WorkspaceProposalRepairReviewStatus[];
+	readonly outcomeIndex?: readonly WorkspaceProposalFamilyOutcomeIndexEntry[];
+	readonly outcomeStatuses?: readonly WorkspaceProposalFamilyOutcomeRecordStatus[];
+	readonly outcomes?: readonly WorkspaceProposalFamilyOutcomeRecord[];
+	readonly queryId?: string;
+	readonly viewId?: string;
+	readonly applicationId?: string;
+	readonly proposalId?: string;
+	readonly decisionId?: string;
+	readonly idempotencyKey?: string;
+	readonly proposalFamily?: WorkspaceProposalFamily;
+	readonly offset?: number;
+	readonly limit?: number;
+	readonly filters?: WorkspaceProposalFamilyApplicationReadModelFilters;
+	readonly sort?: readonly WorkspaceProposalFamilyApplicationReadModelSortOption[];
+	readonly groupBy?: readonly WorkspaceProposalFamilyApplicationReadModelGroupField[];
+	readonly search?: WorkspaceProposalFamilyApplicationReadModelSearchOptions;
+	readonly displayDiagnostics?: readonly WorkspaceProposalFamilyApplicationReadModelDisplayDiagnostic[];
+}
+
+export interface WorkspaceProposalFamilyApplicationReadModelProjectorOptions {
+	readonly name?: string;
+	readonly diagnostics?: Node<WorkspaceProposalFamilyApplicationDiagnostic>;
+	readonly repairReviewStatuses?: Node<WorkspaceProposalRepairReviewStatus>;
+	readonly outcomeIndex?: Node<WorkspaceProposalFamilyOutcomeIndexEntry>;
+	readonly outcomeStatuses?: Node<WorkspaceProposalFamilyOutcomeRecordStatus>;
+	readonly outcomes?: Node<WorkspaceProposalFamilyOutcomeRecord>;
+	readonly applicationId?: string;
+	readonly proposalId?: string;
+	readonly decisionId?: string;
+	readonly idempotencyKey?: string;
+	readonly proposalFamily?: WorkspaceProposalFamily;
+	readonly offset?: number;
+	readonly limit?: number;
+	readonly sort?: readonly WorkspaceProposalFamilyApplicationReadModelSortOption[];
+	readonly groupBy?: readonly WorkspaceProposalFamilyApplicationReadModelGroupField[];
+	readonly search?: WorkspaceProposalFamilyApplicationReadModelSearchOptions;
+}
+
+export interface WorkspaceProposalFamilyApplicationReadModelsProjectionInput {
+	readonly queries?: readonly WorkspaceProposalFamilyApplicationReadModelQuery[];
+	readonly diagnostics?: readonly WorkspaceProposalFamilyApplicationDiagnostic[];
+	readonly repairReviewStatuses?: readonly WorkspaceProposalRepairReviewStatus[];
+	readonly outcomeIndex?: readonly WorkspaceProposalFamilyOutcomeIndexEntry[];
+	readonly outcomeStatuses?: readonly WorkspaceProposalFamilyOutcomeRecordStatus[];
+	readonly outcomes?: readonly WorkspaceProposalFamilyOutcomeRecord[];
+}
+
+export interface WorkspaceProposalFamilyApplicationReadModelsProjectorOptions {
+	readonly name?: string;
+	readonly queries: Node<WorkspaceProposalFamilyApplicationReadModelQuery>;
+	readonly releases?: Node<WorkspaceProposalProjectionRelease>;
+	readonly diagnostics?: Node<WorkspaceProposalFamilyApplicationDiagnostic>;
+	readonly repairReviewStatuses?: Node<WorkspaceProposalRepairReviewStatus>;
+	readonly outcomeIndex?: Node<WorkspaceProposalFamilyOutcomeIndexEntry>;
+	readonly outcomeStatuses?: Node<WorkspaceProposalFamilyOutcomeRecordStatus>;
+	readonly outcomes?: Node<WorkspaceProposalFamilyOutcomeRecord>;
+}
+
+/**
+ * Inputs for the D473 release diagnostic projector.
+ *
+ * The projector observes unknown release material and emits only blocked
+ * diagnostics; it does not apply release/prune behavior itself.
+ */
+export interface WorkspaceProposalProjectionReleaseDiagnosticProjectorOptions {
+	readonly name?: string;
+	readonly releases: Node<unknown>;
+}
+
+/** Data-only diagnostic projection bundle for rejected D472 release material. */
+export interface WorkspaceProposalProjectionReleaseDiagnosticProjectorBundle {
+	readonly diagnostics: Node<WorkspaceProposalProjectionReleaseDiagnostic>;
+}
+
+export interface WorkspaceProposalFamilyApplicationReadModelProjectorBundle {
+	readonly readModels: Node<WorkspaceProposalFamilyApplicationReadModel>;
+}
+
+export interface WorkspaceProposalFamilyOutcomeDetailSupplyRequest {
+	readonly kind: "workspace-proposal-family-outcome-detail-supply-request";
+	readonly supplyRequestId: string;
+	readonly viewId?: string;
+	readonly applicationId: string;
+	readonly proposalId: string;
+	readonly decisionId: string;
+	readonly idempotencyKey: string;
+	readonly proposalFamily: WorkspaceProposalFamily;
+	readonly requestedOutcomeRefs: readonly WorkspaceProposalFamilyOutcomeRef[];
+	readonly page?: WorkspaceProposalFamilyApplicationReadModelPage;
+	readonly filters?: WorkspaceProposalFamilyApplicationReadModelFilters;
+	readonly sourceRefs: readonly SourceRef[];
+	readonly audit?: WorkspaceProposalAuditMaterial;
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface WorkspaceProposalFamilyOutcomeDetailSupplyResult {
+	readonly kind: "workspace-proposal-family-outcome-detail-supply-result";
+	readonly supplyRequestId?: string;
+	readonly viewId?: string;
+	readonly currentViewId: string;
+	readonly applicationId?: string;
+	readonly proposalId?: string;
+	readonly decisionId?: string;
+	readonly idempotencyKey?: string;
+	readonly proposalFamily?: WorkspaceProposalFamily;
+	readonly suppliedOutcomeFacts: readonly WorkspaceProposalFamilyOutcomeRecord[];
+	readonly missingRefs: readonly WorkspaceProposalFamilyOutcomeRef[];
+	readonly mismatchedRefs: readonly WorkspaceProposalFamilyOutcomeRef[];
+	readonly displayDiagnostics: readonly WorkspaceProposalFamilyApplicationReadModelDisplayDiagnostic[];
+	readonly page: { readonly offset: number; readonly limit: number };
+	readonly filters: WorkspaceProposalFamilyApplicationReadModelNormalizedFilters;
+	readonly sourceRefs: readonly SourceRef[];
+	readonly audit?: WorkspaceProposalAuditMaterial;
+}
+
+export interface WorkspaceProposalFamilyOutcomeDetailSupplyProjectionInput {
+	readonly requests?: readonly WorkspaceProposalFamilyOutcomeDetailSupplyRequest[];
+	readonly suppliedOutcomes?: readonly WorkspaceProposalFamilyOutcomeRecord[];
+}
+
+export interface WorkspaceProposalFamilyOutcomeDetailSupplyProjectorOptions {
+	readonly name?: string;
+	readonly requests: Node<WorkspaceProposalFamilyOutcomeDetailSupplyRequest>;
+	readonly suppliedOutcomes: Node<WorkspaceProposalFamilyOutcomeRecord>;
+	readonly releases?: Node<WorkspaceProposalProjectionRelease>;
+}
+
+export interface WorkspaceProposalFamilyOutcomeDetailSupplyProjectorBundle {
+	readonly results: Node<WorkspaceProposalFamilyOutcomeDetailSupplyResult>;
+}
+
+export type WorkspaceProposalRepairActionKind =
+	| "acknowledge-review"
+	| "withdraw-review"
+	| "mark-human-resolved"
+	| "supersede-review"
+	| "open-successor-proposal-flow";
+
+export type WorkspaceProposalRepairActionDescriptorDisabledCode =
+	| "repair-review-already-acknowledged"
+	| "repair-review-conflict"
+	| "repair-review-terminal";
+
+export interface WorkspaceProposalRepairActionDescriptor {
+	readonly kind: "workspace-proposal-repair-action-descriptor";
+	readonly descriptorId: string;
+	readonly repairRequestId: string;
+	readonly repairState: WorkspaceProposalRepairReviewLifecycleState;
+	readonly repairStatusRef?: SourceRef;
+	readonly actionKind: WorkspaceProposalRepairActionKind;
+	readonly enabled: boolean;
+	readonly disabledCode?: WorkspaceProposalRepairActionDescriptorDisabledCode;
+	readonly applicationId: string;
+	readonly proposalId: string;
+	readonly decisionId: string;
+	readonly idempotencyKey: string;
+	readonly proposalFamily: WorkspaceProposalFamily;
+	readonly sourceRefs: readonly SourceRef[];
+	readonly audit?: WorkspaceProposalAuditMaterial;
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface WorkspaceProposalRepairActionDescriptorProjectionInput {
+	readonly requests?: readonly WorkspaceProposalRepairReviewRequest[];
+	readonly statuses?: readonly WorkspaceProposalRepairReviewStatus[];
+}
+
+export interface WorkspaceProposalRepairActionDescriptorProjectorOptions {
+	readonly name?: string;
+	readonly requests: Node<WorkspaceProposalRepairReviewRequest>;
+	readonly statuses?: Node<WorkspaceProposalRepairReviewStatus>;
+}
+
+export interface WorkspaceProposalRepairActionDescriptorProjectorBundle {
+	readonly descriptors: Node<WorkspaceProposalRepairActionDescriptor>;
+}
+
+export interface WorkspaceProposalRepairActionIntent {
+	readonly kind: "workspace-proposal-repair-action-intent";
+	readonly intentId: string;
+	readonly descriptorId: string;
+	readonly repairRequestId: string;
+	readonly actionKind: WorkspaceProposalRepairActionKind;
+	readonly applicationId: string;
+	readonly proposalId: string;
+	readonly decisionId: string;
+	readonly idempotencyKey: string;
+	readonly proposalFamily: WorkspaceProposalFamily;
+	readonly reviewerRef?: SourceRef;
+	readonly actorRef?: SourceRef;
+	readonly capabilityRefs?: readonly SourceRef[];
+	readonly policyRefs?: readonly SourceRef[];
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly audit?: WorkspaceProposalAuditMaterial;
+	readonly metadata?: Record<string, unknown>;
+	readonly expectedCurrentState?: WorkspaceProposalRepairReviewExpectedCurrentState;
+}
+
+export type WorkspaceProposalRepairActionIntentValidationStatus = "accepted" | "blocked";
+
+export interface WorkspaceProposalRepairActionIntentValidationOptions {
+	readonly descriptor?: WorkspaceProposalRepairActionDescriptor;
+	readonly request?: WorkspaceProposalRepairReviewRequest;
+	readonly currentStatus?: WorkspaceProposalRepairReviewStatus;
+	readonly expectedCurrentState?: WorkspaceProposalRepairReviewExpectedCurrentState;
+	readonly capabilityRefs?: readonly SourceRef[];
+	readonly policyRefs?: readonly SourceRef[];
+	readonly policyStatus?: "allowed" | "blocked" | "missing" | "unknown";
+	readonly policyIssues?: readonly WorkspaceProposalRecordedIssue[];
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly audit?: WorkspaceProposalAuditMaterial;
+}
+
+export interface WorkspaceProposalRepairActionIntentValidationResult {
+	readonly kind: "workspace-proposal-repair-action-intent-validation-result";
+	readonly status: WorkspaceProposalRepairActionIntentValidationStatus;
+	readonly intentId?: string;
+	readonly descriptorId?: string;
+	readonly repairRequestId?: string;
+	readonly actionKind?: WorkspaceProposalRepairActionKind;
+	readonly applicationId?: string;
+	readonly proposalId?: string;
+	readonly decisionId?: string;
+	readonly idempotencyKey?: string;
+	readonly proposalFamily?: WorkspaceProposalFamily;
+	readonly issues: readonly WorkspaceProposalRecordedIssue[];
+	readonly sourceRefs: readonly SourceRef[];
+	readonly audit?: WorkspaceProposalAuditMaterial;
+	readonly intent?: WorkspaceProposalRepairActionIntent;
+}
+
+export type WorkspaceProposalRepairActionDisplayPolicyAssessment =
+	| "not-evaluated"
+	| "no-known-blocker"
+	| "known-blocker"
+	| "needs-review"
+	| "unknown";
+
+export interface WorkspaceProposalRepairActionDisplayPolicyAdvisoryIssue {
+	readonly kind: string;
+	readonly message: string;
+	readonly severity?: "info" | "warning" | "error";
+	readonly ref?: SourceRef;
+	readonly metadata?: Record<string, unknown>;
+}
+
+/**
+ * D468 display-only policy advisory. This DTO is intentionally joinable by
+ * repair action coordinates but is never permission proof for intake.
+ */
+export interface WorkspaceProposalRepairActionDisplayPolicyAdvisory {
+	readonly kind: "workspace-proposal-repair-action-display-policy-advisory";
+	readonly authority: "display-only-advisory";
+	readonly descriptorId: string;
+	readonly repairRequestId: string;
+	readonly actionKind: WorkspaceProposalRepairActionKind;
+	readonly applicationId: string;
+	readonly proposalId: string;
+	readonly decisionId: string;
+	readonly idempotencyKey: string;
+	readonly proposalFamily: WorkspaceProposalFamily;
+	readonly displayAssessment: WorkspaceProposalRepairActionDisplayPolicyAssessment;
+	readonly policyEvidenceRefs?: readonly SourceRef[];
+	readonly capabilityEvidenceRefs?: readonly SourceRef[];
+	readonly advisoryIssues?: readonly WorkspaceProposalRepairActionDisplayPolicyAdvisoryIssue[];
+	readonly displayCode?: string;
+	readonly displayMessage?: string;
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly audit?: WorkspaceProposalAuditMaterial;
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface WorkspaceProposalRepairActionDisplayPolicyAdvisoryValidationResult {
+	readonly kind: "workspace-proposal-repair-action-display-policy-advisory-validation-result";
+	readonly status: "accepted" | "blocked";
+	readonly descriptorId?: string;
+	readonly repairRequestId?: string;
+	readonly actionKind?: WorkspaceProposalRepairActionKind;
+	readonly applicationId?: string;
+	readonly proposalId?: string;
+	readonly decisionId?: string;
+	readonly idempotencyKey?: string;
+	readonly proposalFamily?: WorkspaceProposalFamily;
+	readonly issues: readonly WorkspaceProposalRecordedIssue[];
+	readonly sourceRefs: readonly SourceRef[];
+	readonly audit?: WorkspaceProposalAuditMaterial;
+	readonly advisory?: WorkspaceProposalRepairActionDisplayPolicyAdvisory;
+}
+
+export interface WorkspaceProposalRepairActionDisplayPolicyAdvisoryValidationOptions {
+	readonly descriptor?: WorkspaceProposalRepairActionDescriptor;
+	readonly request?: WorkspaceProposalRepairReviewRequest;
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly audit?: WorkspaceProposalAuditMaterial;
+}
+
+export interface WorkspaceProposalRepairActionDisplayPolicyAdvisoryProjectorOptions {
+	readonly name?: string;
+	readonly descriptors: Node<WorkspaceProposalRepairActionDescriptor>;
+	readonly requests: Node<WorkspaceProposalRepairReviewRequest>;
+	readonly releases?: Node<WorkspaceProposalProjectionRelease>;
+	readonly displayAssessment?: WorkspaceProposalRepairActionDisplayPolicyAssessment;
+	readonly policyEvidenceRefs?: readonly SourceRef[];
+	readonly capabilityEvidenceRefs?: readonly SourceRef[];
+	readonly advisoryIssues?: readonly WorkspaceProposalRepairActionDisplayPolicyAdvisoryIssue[];
+	readonly displayCode?: string;
+	readonly displayMessage?: string;
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly audit?: WorkspaceProposalAuditMaterial;
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface WorkspaceProposalRepairActionDisplayPolicyAdvisoryProjectorBundle {
+	readonly advisories: Node<WorkspaceProposalRepairActionDisplayPolicyAdvisory>;
+}
+
+export interface WorkspaceProposalRepairReviewDecisionRecordingInputPreparationOptions {
+	readonly reviewDecisionId?: string;
+	readonly reviewerRef?: SourceRef;
+	readonly actorRef?: SourceRef;
+	readonly capabilityRefs?: readonly SourceRef[];
+	readonly policyRefs?: readonly SourceRef[];
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly audit?: WorkspaceProposalAuditMaterial;
+	readonly reason?: string;
+	readonly code?: string;
+	readonly resolvesRefs?: readonly SourceRef[];
+	readonly supersedesRefs?: readonly SourceRef[];
+	readonly decidedAtMs?: number;
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface WorkspaceProposalRepairReviewDecisionRecordingInputPreparationResult {
+	readonly kind: "workspace-proposal-repair-review-decision-recording-input-preparation-result";
+	readonly status: "prepared" | "blocked";
+	readonly recordingInput?: WorkspaceProposalRepairReviewDecisionRecordingInput;
+	readonly issues: readonly WorkspaceProposalRecordedIssue[];
+	readonly sourceRefs: readonly SourceRef[];
+	readonly audit?: WorkspaceProposalAuditMaterial;
+}
+
+export interface WorkspaceProposalRepairActionIntentProjectorOptions {
+	readonly name?: string;
+	readonly intents: Node<WorkspaceProposalRepairActionIntent>;
+	readonly descriptors: Node<WorkspaceProposalRepairActionDescriptor>;
+	readonly requests: Node<WorkspaceProposalRepairReviewRequest>;
+	readonly statuses?: Node<WorkspaceProposalRepairReviewStatus>;
+	readonly releases?: Node<WorkspaceProposalProjectionRelease>;
+	readonly capabilityRefs?: readonly SourceRef[];
+	readonly policyRefs?: readonly SourceRef[];
+	readonly policyStatus?: "allowed" | "blocked" | "missing" | "unknown";
+}
+
+export interface WorkspaceProposalRepairActionIntentProjectorBundle {
+	readonly results: Node<WorkspaceProposalRepairActionIntentValidationResult>;
+}
+
+export interface WorkspaceProposalRepairSuccessorProposalIntakePreviewOptions {
+	readonly previewId?: string;
+	readonly currentStatus?: WorkspaceProposalRepairReviewStatus;
+	readonly expectedCurrentState?: WorkspaceProposalRepairReviewExpectedCurrentState;
+	readonly capabilityRefs?: readonly SourceRef[];
+	readonly policyRefs?: readonly SourceRef[];
+	readonly policyStatus?: "allowed" | "blocked" | "missing" | "unknown";
+	readonly policyIssues?: readonly WorkspaceProposalRecordedIssue[];
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly audit?: WorkspaceProposalAuditMaterial;
+	readonly contextRefs?: readonly SourceRef[];
+	readonly suggestedFamily?: WorkspaceProposalFamily;
+	readonly suggestedLoweringKind?: string;
+	readonly reason?: string;
+	readonly code?: string;
+	readonly suggestedDraftPatch?: Record<string, unknown>;
+	readonly maxSuggestedDraftPatchBytes?: number;
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface WorkspaceProposalRepairSuccessorProposalIntakePreview {
+	readonly kind: "workspace-proposal-repair-successor-proposal-intake-preview";
+	readonly previewId: string;
+	readonly status: "proposal-context-ready" | "blocked";
+	readonly intentId: string;
+	readonly actionIntentId?: string;
+	readonly descriptorId: string;
+	readonly repairRequestId: string;
+	readonly actionKind: "open-successor-proposal-flow";
+	readonly applicationId: string;
+	readonly proposalId: string;
+	readonly decisionId: string;
+	readonly idempotencyKey: string;
+	readonly proposalFamily: WorkspaceProposalFamily;
+	readonly suggestedFamily?: WorkspaceProposalFamily;
+	readonly suggestedLoweringKind?: string;
+	readonly targetRefs: readonly SourceRef[];
+	readonly contextRefs: readonly SourceRef[];
+	readonly reason?: string;
+	readonly code?: string;
+	readonly suggestedDraftPatch?: Record<string, unknown>;
+	readonly diagnostics: readonly WorkspaceProposalRecordedIssue[];
+	readonly sourceRefs: readonly SourceRef[];
+	readonly audit?: WorkspaceProposalAuditMaterial;
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface WorkspaceProposalRepairSuccessorProposalReadyRequestPreparationInput<
+	TDraft = unknown,
+> {
+	readonly kind: "workspace-proposal-repair-successor-proposal-ready-request-preparation-input";
+	readonly preparationId: string;
+	readonly previewId: string;
+	readonly intent: WorkspaceProposalRepairActionIntent;
+	readonly descriptor: WorkspaceProposalRepairActionDescriptor;
+	readonly request: WorkspaceProposalRepairReviewRequest;
+	readonly intentValidation: WorkspaceProposalRepairActionIntentValidationResult;
+	readonly currentStatus?: WorkspaceProposalRepairReviewStatus;
+	readonly expectedCurrentState?: WorkspaceProposalRepairReviewExpectedCurrentState;
+	readonly successorProposalId: string;
+	readonly intakeRequestId: string;
+	readonly successorIdempotencyKey: string;
+	readonly workspaceId: string;
+	readonly actorRef: SourceRef;
+	readonly capabilityRefs: readonly SourceRef[];
+	readonly policyRefs: readonly SourceRef[];
+	readonly projectionBundleRefs: readonly SourceRef[];
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly audit: WorkspaceProposalAuditMaterial;
+	readonly targetRefs: readonly WorkspaceProposalTargetRef[];
+	readonly successorProposalFamily: WorkspaceProposalFamily;
+	readonly successorLoweringKind: string;
+	readonly draft?: TDraft;
+	readonly draftRefs?: readonly SourceRef[];
+	readonly finalDraftSourceRefs?: readonly SourceRef[];
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface WorkspaceProposalRepairSuccessorProposalReadyRequestPreparationResult<
+	TDraft = unknown,
+> {
+	readonly kind: "workspace-proposal-repair-successor-proposal-ready-request-preparation-result";
+	readonly status: "prepared" | "blocked";
+	readonly preparationId?: string;
+	readonly previewId?: string;
+	readonly repairRequestId?: string;
+	readonly descriptorId?: string;
+	readonly intentId?: string;
+	readonly readyRequest?: WorkspaceProposalReadyRequest<TDraft>;
+	readonly issues: readonly WorkspaceProposalRecordedIssue[];
+	readonly sourceRefs: readonly SourceRef[];
+	readonly audit?: WorkspaceProposalAuditMaterial;
+}
+
+export interface WorkspaceProposalRepairSuccessorProposalReadyRequestPreparationProjectorOptions<
+	TDraft = unknown,
+> {
+	readonly name?: string;
+	readonly previews: Node<WorkspaceProposalRepairSuccessorProposalIntakePreview>;
+	readonly preparationInputs: Node<
+		WorkspaceProposalRepairSuccessorProposalReadyRequestPreparationInput<TDraft>
+	>;
+	readonly releases?: Node<WorkspaceProposalProjectionRelease>;
+}
+
+export interface WorkspaceProposalRepairSuccessorProposalReadyRequestPreparationProjectorBundle<
+	TDraft = unknown,
+> {
+	readonly results: Node<
+		WorkspaceProposalRepairSuccessorProposalReadyRequestPreparationResult<TDraft>
+	>;
+	readonly readyRequests: Node<WorkspaceProposalReadyRequest<TDraft>>;
+	readonly issues: Node<WorkspaceProposalRecordedIssue>;
+}
+
+export interface WorkspaceProposalRepairSuccessorProposalIntakePreviewProjectorOptions {
+	readonly name?: string;
+	readonly intents: Node<WorkspaceProposalRepairActionIntent>;
+	readonly descriptors: Node<WorkspaceProposalRepairActionDescriptor>;
+	readonly requests: Node<WorkspaceProposalRepairReviewRequest>;
+	readonly statuses?: Node<WorkspaceProposalRepairReviewStatus>;
+	readonly releases?: Node<WorkspaceProposalProjectionRelease>;
+	readonly capabilityRefs?: readonly SourceRef[];
+	readonly policyRefs?: readonly SourceRef[];
+	readonly policyStatus?: "allowed" | "blocked" | "missing" | "unknown";
+	readonly maxSuggestedDraftPatchBytes?: number;
+}
+
+export interface WorkspaceProposalRepairSuccessorProposalIntakePreviewProjectorBundle {
+	readonly previews: Node<WorkspaceProposalRepairSuccessorProposalIntakePreview>;
+}
+
+type WorkspaceProposalFamilyApplicationRuntimeFact<TInput = unknown, TValue = unknown> =
+	| {
+			readonly kind: "required-input-response-applied";
+			readonly value: RequiredInputResponseApplied<TValue>;
+	  }
+	| { readonly kind: "work-item-created"; readonly value: WorkItemCreated<TInput> }
+	| { readonly kind: "work-item-linked"; readonly value: WorkItemLinked }
+	| { readonly kind: "work-item-unlinked"; readonly value: WorkItemUnlinked }
+	| { readonly kind: "status"; readonly value: WorkspaceProposalApplicationStatus }
+	| { readonly kind: "recorded"; readonly value: WorkspaceProposalApplicationRecorded }
+	| { readonly kind: "issue"; readonly value: WorkspaceProposalRecordedIssue }
+	| { readonly kind: "audit"; readonly value: WorkspaceProposalFamilyApplicationAuditRecord };
+
+type WorkspaceProposalFamilyApplicationDiagnosticInputFact =
+	| { readonly kind: "issue"; readonly value: WorkspaceProposalRecordedIssue }
+	| { readonly kind: "audit"; readonly value: WorkspaceProposalFamilyApplicationAuditRecord }
+	| { readonly kind: "application-status"; readonly value: WorkspaceProposalApplicationStatus }
+	| { readonly kind: "application-recorded"; readonly value: WorkspaceProposalApplicationRecorded }
+	| {
+			readonly kind: "outcome-status";
+			readonly value: WorkspaceProposalFamilyOutcomeRecordStatus;
+	  }
+	| { readonly kind: "outcome-index"; readonly value: WorkspaceProposalFamilyOutcomeIndexEntry }
+	| { readonly kind: "repair-request"; readonly value: WorkspaceProposalRepairReviewRequest }
+	| { readonly kind: "repair-decision"; readonly value: WorkspaceProposalRepairReviewDecision }
+	| { readonly kind: "repair-status"; readonly value: WorkspaceProposalRepairReviewStatus }
+	| {
+			readonly kind: "repair-decision-recording-input";
+			readonly value: WorkspaceProposalRepairReviewDecisionRecordingInput;
+	  }
+	| { readonly kind: "diagnostic"; readonly value: WorkspaceProposalFamilyApplicationDiagnostic }
+	| {
+			readonly kind: "read-model-query";
+			readonly value: WorkspaceProposalFamilyApplicationReadModelQuery;
+	  }
+	| { readonly kind: "outcome"; readonly value: WorkspaceProposalFamilyOutcomeRecord }
+	| { readonly kind: "projection-release"; readonly value: WorkspaceProposalProjectionRelease };
+
+interface WorkspaceProposalFamilyApplicationProjectionState {
+	readonly issues: Map<string, WorkspaceProposalRecordedIssue>;
+	readonly audit: Map<string, WorkspaceProposalFamilyApplicationAuditRecord>;
+	readonly applicationStatuses: Map<string, WorkspaceProposalApplicationStatus>;
+	readonly applicationRecorded: Map<string, WorkspaceProposalApplicationRecorded>;
+	readonly outcomeStatuses: Map<string, WorkspaceProposalFamilyOutcomeRecordStatus>;
+	readonly outcomeIndex: Map<string, WorkspaceProposalFamilyOutcomeIndexEntry>;
+	readonly repairRequests: Map<string, WorkspaceProposalRepairReviewRequest>;
+	readonly repairDecisions: Map<string, WorkspaceProposalRepairReviewDecision>;
+	readonly repairStatuses: Map<string, WorkspaceProposalRepairReviewStatus>;
+	readonly repairDecisionRecordingInputs: Map<
+		string,
+		WorkspaceProposalRepairReviewDecisionRecordingInput
+	>;
+	readonly diagnostics: Map<string, WorkspaceProposalFamilyApplicationDiagnostic>;
+	readonly readModelQueries: Map<string, WorkspaceProposalFamilyApplicationReadModelQuery>;
+	readonly outcomes: Map<string, WorkspaceProposalFamilyOutcomeRecord>;
+	readonly emittedDiagnostics: Map<string, string>;
+	readonly emittedRepairRequests: Map<string, string>;
+	readonly emittedRepairStatuses: Map<string, string>;
+	readonly emittedRepairDecisionRecordings: Map<string, string>;
+	readonly emittedReadModels: Map<string, string>;
+	readonly emittedRepairActionDescriptors: Map<string, string>;
+}
+
+interface WorkspaceProposalFamilyProjectorState<TInput = unknown, TDraft = unknown> {
+	readonly records: Map<string, WorkspaceProposalRecorded<TDraft>>;
+	readonly decisionsByProposal: Map<string, WorkspaceProposalAdmissionDecision>;
+	readonly decisionsById: Map<string, WorkspaceProposalAdmissionDecision>;
+	readonly contexts: Map<
+		string,
+		{
+			readonly applicationId: string;
+			readonly proposalId: string;
+			readonly decisionId?: string;
+			readonly sourceRefs?: readonly SourceRef[];
+			readonly audit?: WorkspaceProposalAuditMaterial;
+		}
+	>;
+	readonly gates: Map<string, RequiredInputGate>;
+	readonly requests: Map<string, RequiredInputRequest>;
+	readonly workItems: Map<string, WorkItemProjection<TInput>>;
+	readonly links: Map<string, WorkItemLinkProjection>;
+	readonly emittedDomainFacts: Map<string, WorkItemAuthoringFact>;
+	readonly domainApplications: Map<string, WorkItemDomainActionApplication>;
+	readonly applicationRefs: Map<string, WorkspaceProposalApplicationReplayEntry>;
+	readonly factOwners: Map<string, string>;
+	readonly durableHandoffDiagnostics: Set<string>;
+}
+
+interface WorkspaceProposalApplicationReplayEntry {
+	readonly proposalId: string;
+	readonly decisionId: string;
+	readonly idempotencyKey: string;
+	readonly emittedFactRefs: readonly WorkspaceProposalApplicationFamilyRef[];
+}
+
+export function workspaceProposalRequiredInputResponseApplicationProjector<TValue = unknown>(
+	graph: Graph,
+	opts: WorkspaceProposalRequiredInputResponseApplicationProjectorOptions<TValue>,
+): WorkspaceProposalRequiredInputResponseApplicationProjectorBundle<TValue> {
+	const name = opts.name ?? "workspaceProposalRequiredInputResponseApplication";
+	const deps =
+		opts.requests === undefined
+			? [opts.records, opts.decisions, opts.contexts, opts.gates]
+			: [opts.records, opts.decisions, opts.contexts, opts.gates, opts.requests];
+	const runtime = graph.node<WorkspaceProposalFamilyApplicationRuntimeFact<unknown, TValue>>(
+		deps,
+		(ctx) => {
+			const state = familyProjectorState<unknown, RequiredInputResponseProposed<TValue>>(ctx);
+			ingestRecords(ctx, state, 0);
+			ingestDecisions(ctx, state, 1);
+			ingestContexts(ctx, state, 2);
+			for (const raw of depBatch(ctx, 3) ?? []) {
+				const gate = raw as RequiredInputGate;
+				state.gates.set(gate.gateId, gate);
+				state.gates.set(`${gate.requestId}:${gate.workItemId}`, gate);
+			}
+			if (opts.requests !== undefined) {
+				for (const raw of depBatch(ctx, 4) ?? []) {
+					const request = raw as RequiredInputRequest;
+					state.requests.set(request.requestId, request);
+					state.requests.set(`${request.requestId}:${request.workItemId}`, request);
+				}
+			}
+			for (const context of state.contexts.values()) {
+				const record = state.records.get(context.proposalId);
+				const decision = decisionForContext(state, context);
+				if (record === undefined || decision === undefined) {
+					emitMissingDurableHandoffDiagnostics(ctx, state, context, "required-input-response");
+					continue;
+				}
+				const draft = record.draft;
+				const draftShapeIssues = requiredInputDraftShapeIssues(record, draft);
+				if (draftShapeIssues.length > 0) {
+					emitApplicationResult(
+						ctx,
+						state,
+						projectWorkspaceProposalApplicationStatus(record, decision, {
+							applicationId: context.applicationId,
+							familyIssues: draftShapeIssues,
+							sourceRefs: context.sourceRefs,
+							audit: context.audit,
+						}),
+						[],
+					);
+					continue;
+				}
+				const gate =
+					requiredInputContextGate(
+						state,
+						context as WorkspaceProposalRequiredInputResponseApplicationContext,
+						draft,
+					) ?? undefined;
+				if (gate === undefined) {
+					emitApplicationResult(
+						ctx,
+						state,
+						missingFamilyMaterialResult(record, decision, context, "missing-required-input-gate"),
+						[],
+					);
+					continue;
+				}
+				const request =
+					requiredInputContextRequest(
+						state,
+						context as WorkspaceProposalRequiredInputResponseApplicationContext,
+						draft,
+					) ?? undefined;
+				const result = projectWorkspaceProposalRequiredInputResponseApplication(record, decision, {
+					applicationId: context.applicationId,
+					gate,
+					request,
+					appliedAtMs: (context as WorkspaceProposalRequiredInputResponseApplicationContext)
+						.appliedAtMs,
+					sourceRefs: context.sourceRefs,
+					audit: context.audit,
+				});
+				emitApplicationResult(
+					ctx,
+					state,
+					result,
+					result.applied === undefined ? [] : [result.applied],
+				);
+			}
+			ctx.state.set(state);
+		},
+		runtimeOptions(name, "workspaceProposalRequiredInputResponseApplicationProjector"),
+	);
+	return familyBundle(graph, runtime, name, {
+		applied: "required-input-response-applied",
+	}) as unknown as WorkspaceProposalRequiredInputResponseApplicationProjectorBundle<TValue>;
+}
+
+export function workspaceProposalWorkItemSpawnApplicationProjector<TInput = unknown>(
+	graph: Graph,
+	opts: WorkspaceProposalWorkItemSpawnApplicationProjectorOptions<TInput>,
+): WorkspaceProposalWorkItemSpawnApplicationProjectorBundle<TInput> {
+	const name = opts.name ?? "workspaceProposalWorkItemSpawnApplication";
+	const deps =
+		opts.workItems === undefined
+			? [opts.records, opts.decisions, opts.contexts]
+			: [opts.records, opts.decisions, opts.contexts, opts.workItems];
+	const runtime = graph.node<WorkspaceProposalFamilyApplicationRuntimeFact<TInput>>(
+		deps,
+		(ctx) => {
+			const state = familyProjectorState<
+				TInput,
+				{
+					readonly kind: "work-item-spawn-proposed";
+					readonly proposedWorkItemId?: string;
+					readonly parentWorkItemId?: string;
+					readonly draft: WorkItemDraft<TInput>;
+					readonly proposedBy?: string;
+					readonly idempotencyKey?: string;
+					readonly sourceRefs?: readonly SourceRef[];
+					readonly metadata?: Record<string, unknown>;
+				}
+			>(ctx);
+			ingestRecords(ctx, state, 0);
+			ingestDecisions(ctx, state, 1);
+			ingestContexts(ctx, state, 2);
+			if (opts.workItems !== undefined) ingestWorkItems(ctx, state, 3);
+			for (const context of state.contexts.values()) {
+				const record = state.records.get(context.proposalId);
+				const decision = decisionForContext(state, context);
+				if (record === undefined || decision === undefined) {
+					emitMissingDurableHandoffDiagnostics(ctx, state, context, "work-item-spawn");
+					continue;
+				}
+				const spawnContext = context as WorkspaceProposalWorkItemSpawnApplicationContext;
+				const result = projectWorkspaceProposalWorkItemSpawnApplication(record, decision, {
+					applicationId: context.applicationId,
+					existingWorkItems: [...state.workItems.values()],
+					linkParent: spawnContext.linkParent,
+					createdAtMs: spawnContext.createdAtMs,
+					linkedAtMs: spawnContext.linkedAtMs,
+					sourceRefs: context.sourceRefs,
+					audit: context.audit,
+				});
+				emitApplicationResult(
+					ctx,
+					state,
+					result,
+					[result.created, result.linked].filter((item) => item !== undefined),
+				);
+			}
+			ctx.state.set(state);
+		},
+		runtimeOptions(name, "workspaceProposalWorkItemSpawnApplicationProjector"),
+	);
+	return familyBundle(graph, runtime, name, {
+		created: "work-item-created",
+		linked: "work-item-linked",
+	}) as unknown as WorkspaceProposalWorkItemSpawnApplicationProjectorBundle<TInput>;
+}
+
+export function workspaceProposalWorkItemLinkApplicationProjector<TInput = unknown>(
+	graph: Graph,
+	opts: WorkspaceProposalWorkItemLinkApplicationProjectorOptions<TInput>,
+): WorkspaceProposalWorkItemLinkApplicationProjectorBundle {
+	const name = opts.name ?? "workspaceProposalWorkItemLinkApplication";
+	const deps: Node<unknown>[] = [
+		opts.records as Node<unknown>,
+		opts.decisions as Node<unknown>,
+		opts.contexts as Node<unknown>,
+	];
+	if (opts.workItems !== undefined) deps.push(opts.workItems);
+	if (opts.links !== undefined) deps.push(opts.links);
+	const workItemsDep = opts.workItems === undefined ? undefined : 3;
+	const linksDep = opts.links === undefined ? undefined : opts.workItems === undefined ? 3 : 4;
+	const runtime = graph.node<WorkspaceProposalFamilyApplicationRuntimeFact<TInput>>(
+		deps,
+		(ctx) => {
+			const state = familyProjectorState<TInput, WorkItemLinkProposalDraft>(ctx);
+			ingestRecords(ctx, state, 0);
+			ingestDecisions(ctx, state, 1);
+			ingestContexts(ctx, state, 2);
+			if (workItemsDep !== undefined) ingestWorkItems(ctx, state, workItemsDep);
+			if (linksDep !== undefined) {
+				for (const raw of depBatch(ctx, linksDep) ?? []) {
+					const link = raw as WorkItemLinkProjection;
+					state.links.set(link.linkId, link);
+				}
+			}
+			for (const context of state.contexts.values()) {
+				const record = state.records.get(context.proposalId);
+				const decision = decisionForContext(state, context);
+				if (record === undefined || decision === undefined) {
+					emitMissingDurableHandoffDiagnostics(ctx, state, context, "work-item-link");
+					continue;
+				}
+				const linkContext = context as WorkspaceProposalWorkItemLinkApplicationContext;
+				const result = projectWorkspaceProposalWorkItemLinkApplication(record, decision, {
+					applicationId: context.applicationId,
+					workItems: [...state.workItems.values()],
+					links: [...state.links.values()],
+					linkedAtMs: linkContext.linkedAtMs,
+					unlinkedAtMs: linkContext.unlinkedAtMs,
+					sourceRefs: context.sourceRefs,
+					audit: context.audit,
+				});
+				emitApplicationResult(
+					ctx,
+					state,
+					result,
+					[result.linked, result.unlinked].filter((item) => item !== undefined),
+				);
+			}
+			ctx.state.set(state);
+		},
+		runtimeOptions(name, "workspaceProposalWorkItemLinkApplicationProjector"),
+	);
+	return familyBundle(graph, runtime, name, {
+		linked: "work-item-linked",
+		unlinked: "work-item-unlinked",
+	}) as unknown as WorkspaceProposalWorkItemLinkApplicationProjectorBundle;
+}
+
+export function workspaceProposalDomainActionApplicationProjector(
+	graph: Graph,
+	opts: WorkspaceProposalDomainActionApplicationProjectorOptions,
+): WorkspaceProposalDomainActionApplicationProjectorBundle {
+	const name = opts.name ?? "workspaceProposalDomainActionApplication";
+	const deps =
+		opts.domainApplications === undefined
+			? [opts.records, opts.decisions, opts.contexts, opts.emittedFacts]
+			: [opts.records, opts.decisions, opts.contexts, opts.emittedFacts, opts.domainApplications];
+	const runtime = graph.node<WorkspaceProposalFamilyApplicationRuntimeFact>(
+		deps,
+		(ctx) => {
+			const state = familyProjectorState(ctx);
+			ingestRecords(ctx, state, 0);
+			ingestDecisions(ctx, state, 1);
+			ingestContexts(ctx, state, 2);
+			for (const raw of depBatch(ctx, 3) ?? []) {
+				const fact = raw as WorkItemAuthoringFact;
+				state.emittedDomainFacts.set(fact.eventId, fact);
+			}
+			if (opts.domainApplications !== undefined) {
+				for (const raw of depBatch(ctx, 4) ?? []) {
+					const application = raw as WorkItemDomainActionApplication;
+					state.domainApplications.set(application.applicationId, application);
+				}
+			}
+			for (const context of state.contexts.values()) {
+				const record = state.records.get(context.proposalId);
+				const decision = decisionForContext(state, context);
+				if (record === undefined || decision === undefined) {
+					emitMissingDurableHandoffDiagnostics(ctx, state, context, "work-item-domain-action");
+					continue;
+				}
+				const domainContext = context as WorkspaceProposalDomainActionApplicationContext;
+				const selectedDomainFacts = selectDomainFacts(state, domainContext);
+				const domainApplication =
+					domainContext.domainApplicationId === undefined
+						? undefined
+						: state.domainApplications.get(domainContext.domainApplicationId);
+				if (
+					selectedDomainFacts.missingFactIds.length > 0 ||
+					(selectedDomainFacts.facts.length === 0 && domainApplication === undefined)
+				) {
+					emitApplicationResult(
+						ctx,
+						state,
+						missingFamilyMaterialResult(record, decision, context, "missing-domain-action-facts"),
+						[],
+					);
+					continue;
+				}
+				const result = projectWorkspaceProposalDomainActionApplicationStatus(record, decision, {
+					applicationId: context.applicationId,
+					emittedFacts: selectedDomainFacts.facts,
+					domainApplication,
+					sourceRefs: context.sourceRefs,
+					audit: context.audit,
+				});
+				emitApplicationResult(ctx, state, result, []);
+			}
+			ctx.state.set(state);
+		},
+		runtimeOptions(name, "workspaceProposalDomainActionApplicationProjector"),
+	);
+	return familyBundle(
+		graph,
+		runtime,
+		name,
+		{},
+	) as unknown as WorkspaceProposalDomainActionApplicationProjectorBundle;
+}
+
+export function recordWorkspaceProposalRequiredInputResponseOutcome(
+	status: WorkspaceProposalApplicationStatus,
+	options: WorkspaceProposalRequiredInputResponseOutcomeOptions,
+): WorkspaceProposalFamilyOutcomeRecordResult<WorkspaceProposalRequiredInputResponseOutcomeRecorded> {
+	return recordFamilyOutcome(status, "required-input-response", options, () => {
+		const requiredInputRequestId = options.requiredInputRequestId;
+		const responseRef = options.responseRef;
+		const issues = [
+			...nonBlankFieldIssue(status, requiredInputRequestId, "requiredInputRequestId"),
+			...sourceRefFieldIssue(status, responseRef, "responseRef"),
+		];
+		if (
+			issues.length > 0 ||
+			typeof requiredInputRequestId !== "string" ||
+			!isSourceRef(responseRef)
+		) {
+			return { issues };
+		}
+		return {
+			issues,
+			outcome: {
+				kind: "workspace-proposal-required-input-response-outcome-recorded",
+				...familyOutcomeCoordinates(status, options),
+				proposalFamily: "required-input-response",
+				requiredInputRequestId,
+				responseRef,
+			},
+		};
+	});
+}
+
+export function recordWorkspaceProposalWorkItemSpawnOutcome(
+	status: WorkspaceProposalApplicationStatus,
+	options: WorkspaceProposalWorkItemSpawnOutcomeOptions,
+): WorkspaceProposalFamilyOutcomeRecordResult<WorkspaceProposalWorkItemSpawnOutcomeRecorded> {
+	return recordFamilyOutcome(status, "work-item-spawn", options, () => {
+		const workItemRef = options.workItemRef;
+		const issues = sourceRefFieldIssue(status, workItemRef, "workItemRef");
+		if (issues.length > 0 || !isSourceRef(workItemRef)) return { issues };
+		return {
+			issues,
+			outcome: {
+				kind: "workspace-proposal-work-item-spawn-outcome-recorded",
+				...familyOutcomeCoordinates(status, options),
+				proposalFamily: "work-item-spawn",
+				workItemRef,
+			},
+		};
+	});
+}
+
+export function recordWorkspaceProposalWorkItemLinkOutcome(
+	status: WorkspaceProposalApplicationStatus,
+	options: WorkspaceProposalWorkItemLinkOutcomeOptions,
+): WorkspaceProposalFamilyOutcomeRecordResult<WorkspaceProposalWorkItemLinkOutcomeRecorded> {
+	return recordFamilyOutcome(status, "work-item-link", options, () => {
+		const linkRef = options.linkRef;
+		const issues = sourceRefFieldIssue(status, linkRef, "linkRef");
+		if (issues.length > 0 || !isSourceRef(linkRef)) return { issues };
+		return {
+			issues,
+			outcome: {
+				kind: "workspace-proposal-work-item-link-outcome-recorded",
+				...familyOutcomeCoordinates(status, options),
+				proposalFamily: "work-item-link",
+				linkRef,
+			},
+		};
+	});
+}
+
+export function recordWorkspaceProposalDomainActionOutcome(
+	status: WorkspaceProposalApplicationStatus,
+	options: WorkspaceProposalDomainActionOutcomeOptions,
+): WorkspaceProposalFamilyOutcomeRecordResult<WorkspaceProposalDomainActionOutcomeRecorded> {
+	return recordFamilyOutcome(status, "work-item-domain-action", options, () => {
+		const multiStepPartial = options.policy?.domainActionCompletion === "multi-step-partial";
+		if (options.actionRef === undefined) {
+			return {
+				issues: multiStepPartial ? [] : sourceRefFieldIssue(status, options.actionRef, "actionRef"),
+				partial: true,
+			};
+		}
+		const issues = sourceRefFieldIssue(status, options.actionRef, "actionRef");
+		if (issues.length > 0) return { issues, partial: true };
+		return {
+			issues,
+			outcome: {
+				kind: "workspace-proposal-domain-action-outcome-recorded",
+				...familyOutcomeCoordinates(status, options),
+				proposalFamily: "work-item-domain-action",
+				actionRef: options.actionRef,
+			},
+		};
+	});
+}
+
+export function workspaceProposalFamilyOutcomeRef(
+	outcome: WorkspaceProposalFamilyOutcomeRecord,
+): WorkspaceProposalFamilyOutcomeRef {
+	return {
+		kind: "workspace-proposal-family-outcome-ref",
+		applicationId: outcome.applicationId,
+		proposalId: outcome.proposalId,
+		decisionId: outcome.decisionId,
+		idempotencyKey: outcome.idempotencyKey,
+		proposalFamily: outcome.proposalFamily,
+		outcomeKind: outcome.kind,
+		outcomeId: outcome.outcomeId,
+		sourceRefs: immutableClone(outcome.sourceRefs),
+	};
+}
+
+export function projectWorkspaceProposalFamilyOutcomeIndex(
+	outcomes: readonly WorkspaceProposalFamilyOutcomeRecord[],
+): readonly WorkspaceProposalFamilyOutcomeIndexEntry[] {
+	const groups = new Map<string, WorkspaceProposalFamilyOutcomeRecord[]>();
+	for (const outcome of outcomes) {
+		const key = familyOutcomeIndexKey(outcome);
+		groups.set(key, [...(groups.get(key) ?? []), outcome]);
+	}
+	return [...groups.entries()].map(([indexKey, entries]) => {
+		const first = entries[0];
+		const refs = entries.map(workspaceProposalFamilyOutcomeRef);
+		const uniqueSignatures = new Set(entries.map(familyOutcomeSignature));
+		const conflict = uniqueSignatures.size > 1;
+		const issues = conflict
+			? [
+					familyOutcomeIssue(
+						first,
+						"idempotency-conflict",
+						"Workspace proposal family outcome replay conflicts with prior outcome refs",
+					),
+				]
+			: [];
+		return {
+			kind: "workspace-proposal-family-outcome-index-entry",
+			indexKey,
+			applicationId: first.applicationId,
+			proposalId: first.proposalId,
+			decisionId: first.decisionId,
+			idempotencyKey: first.idempotencyKey,
+			proposalFamily: first.proposalFamily,
+			state: conflict ? "idempotency-conflict" : "recorded",
+			outcomeRefs: conflict ? [] : [refs[0]],
+			sourceRefs: uniqueRefs(entries.flatMap((entry) => entry.sourceRefs)),
+			audit: first.audit,
+			issues,
+		} satisfies WorkspaceProposalFamilyOutcomeIndexEntry;
+	});
+}
+
+/**
+ * Projects D438/D434/D437 diagnostic view material from existing graph facts only.
+ *
+ * Missing durable handoff issues remain diagnostic-only and never synthesize
+ * application status, family truth, outcome, or repair review authority.
+ */
+export function projectWorkspaceProposalFamilyApplicationDiagnostics(
+	input: WorkspaceProposalFamilyApplicationDiagnosticProjectionInput,
+): readonly WorkspaceProposalFamilyApplicationDiagnostic[] {
+	const diagnostics = new Map<string, WorkspaceProposalFamilyApplicationDiagnostic>();
+	for (const issue of input.issues ?? []) {
+		const classification = diagnosticClassForIssue(issue);
+		if (classification === undefined) continue;
+		upsertDiagnostic(diagnostics, diagnosticFromIssue(issue, classification));
+	}
+	for (const audit of input.audit ?? []) {
+		if (audit.code === "missing-durable-handoff") {
+			upsertDiagnostic(diagnostics, diagnosticFromAudit(audit, "missing-durable-handoff"));
+		}
+	}
+	for (const status of input.applicationStatuses ?? []) {
+		const classification = diagnosticClassForApplicationStatus(status);
+		if (classification === undefined) continue;
+		upsertDiagnostic(diagnostics, diagnosticFromApplicationStatus(status, classification));
+	}
+	for (const status of input.outcomeStatuses ?? []) {
+		const classification = diagnosticClassForOutcomeStatus(status);
+		if (classification === undefined) continue;
+		upsertDiagnostic(diagnostics, diagnosticFromOutcomeStatus(status, classification));
+	}
+	for (const entry of input.outcomeIndex ?? []) {
+		if (entry.state !== "idempotency-conflict") continue;
+		upsertDiagnostic(diagnostics, diagnosticFromOutcomeIndex(entry));
+	}
+	return [...diagnostics.values()];
+}
+
+/** Graph-visible variant of `projectWorkspaceProposalFamilyApplicationDiagnostics`. */
+export function workspaceProposalFamilyApplicationDiagnosticProjector(
+	graph: Graph,
+	opts: WorkspaceProposalFamilyApplicationDiagnosticProjectorOptions,
+): WorkspaceProposalFamilyApplicationDiagnosticProjectorBundle {
+	const name = opts.name ?? "workspaceProposalFamilyApplicationDiagnostic";
+	const { deps, depKinds } = diagnosticProjectionDeps(opts);
+	const runtime = graph.node<
+		| { readonly kind: "diagnostic"; readonly value: WorkspaceProposalFamilyApplicationDiagnostic }
+		| undefined
+	>(
+		deps,
+		(ctx) => {
+			const state = familyProjectionState(ctx);
+			ingestDiagnosticInputFacts(ctx, state, depKinds);
+			for (const diagnostic of projectWorkspaceProposalFamilyApplicationDiagnostics({
+				issues: [...state.issues.values()],
+				audit: [...state.audit.values()],
+				applicationStatuses: [...state.applicationStatuses.values()],
+				outcomeStatuses: [...state.outcomeStatuses.values()],
+				outcomeIndex: [...state.outcomeIndex.values()],
+			})) {
+				const signature = diagnosticSignature(diagnostic);
+				if (state.emittedDiagnostics.get(diagnostic.diagnosticId) === signature) continue;
+				state.emittedDiagnostics.set(diagnostic.diagnosticId, signature);
+				ctx.down([["DATA", { kind: "diagnostic", value: diagnostic }]]);
+			}
+			ctx.state.set(state);
+		},
+		runtimeOptions(name, "workspaceProposalFamilyApplicationDiagnosticProjector"),
+	);
+	return {
+		diagnostics: project(graph, runtime, `${name}/diagnostics`, `${name}Diagnostics`, (fact) =>
+			fact?.kind === "diagnostic" ? fact.value : undefined,
+		),
+	};
+}
+
+/**
+ * Lowers durable repair-needed or idempotency-conflict material to human review.
+ *
+ * The lowerer requires durable application coordinates and never emits retry,
+ * remutation, family facts, or proposal/admission/application truth.
+ */
+export function projectWorkspaceProposalRepairReviewRequests(
+	input: WorkspaceProposalRepairReviewProjectionInput,
+): readonly WorkspaceProposalRepairReviewRequest[] {
+	const applicationStatuses = new Map(
+		(input.applicationStatuses ?? []).map((status) => [status.applicationId, status]),
+	);
+	const requests = new Map<string, WorkspaceProposalRepairReviewRequest>();
+	for (const status of applicationStatuses.values()) {
+		if (!repairReviewState(status.state)) continue;
+		if (!repairReviewClassification(diagnosticClassForApplicationStatus(status))) continue;
+		upsertRepairRequest(requests, repairRequestFromApplicationStatus(status));
+	}
+	for (const status of input.outcomeStatuses ?? []) {
+		if (!repairReviewState(status.state)) continue;
+		const applicationStatus = applicationStatuses.get(status.applicationId);
+		if (applicationStatus === undefined) continue;
+		if (!sameApplicationCoordinates(applicationStatus, status)) continue;
+		if (!repairReviewClassification(diagnosticClassForOutcomeStatus(status))) continue;
+		upsertRepairRequest(requests, repairRequestFromOutcomeStatus(status, applicationStatus));
+	}
+	for (const entry of input.outcomeIndex ?? []) {
+		if (entry.state !== "idempotency-conflict") continue;
+		const applicationStatus = applicationStatuses.get(entry.applicationId);
+		if (applicationStatus === undefined) continue;
+		if (!sameApplicationCoordinates(applicationStatus, entry)) continue;
+		upsertRepairRequest(requests, repairRequestFromOutcomeIndex(entry, applicationStatus));
+	}
+	return [...requests.values()];
+}
+
+/** Graph-visible variant of `projectWorkspaceProposalRepairReviewRequests`. */
+export function workspaceProposalRepairReviewProjector(
+	graph: Graph,
+	opts: WorkspaceProposalRepairReviewProjectorOptions,
+): WorkspaceProposalRepairReviewProjectorBundle {
+	const name = opts.name ?? "workspaceProposalRepairReview";
+	const { deps, depKinds } = repairReviewProjectionDeps(opts);
+	const runtime = graph.node<
+		| {
+				readonly kind: "repair-review-request";
+				readonly value: WorkspaceProposalRepairReviewRequest;
+		  }
+		| undefined
+	>(
+		deps,
+		(ctx) => {
+			const state = familyProjectionState(ctx);
+			ingestDiagnosticInputFacts(ctx, state, depKinds);
+			for (const request of projectWorkspaceProposalRepairReviewRequests({
+				applicationStatuses: [...state.applicationStatuses.values()],
+				outcomeStatuses: [...state.outcomeStatuses.values()],
+				outcomeIndex: [...state.outcomeIndex.values()],
+			})) {
+				const signature = repairRequestSignature(request);
+				if (state.emittedRepairRequests.get(request.repairRequestId) === signature) continue;
+				state.emittedRepairRequests.set(request.repairRequestId, signature);
+				ctx.down([["DATA", { kind: "repair-review-request", value: request }]]);
+			}
+			ctx.state.set(state);
+		},
+		runtimeOptions(name, "workspaceProposalRepairReviewProjector"),
+	);
+	return {
+		requests: project(graph, runtime, `${name}/requests`, `${name}Requests`, (fact) =>
+			fact?.kind === "repair-review-request" ? fact.value : undefined,
+		),
+	};
+}
+
+export function projectWorkspaceProposalRepairReviewStatuses(
+	input: WorkspaceProposalRepairReviewStatusProjectionInput,
+): readonly WorkspaceProposalRepairReviewStatus[] {
+	return (input.requests ?? []).map((request) =>
+		projectWorkspaceProposalRepairReviewStatus(request, {
+			decisions: input.decisions ?? [],
+			applicationStatuses: input.applicationStatuses ?? [],
+			applicationRecorded: input.applicationRecorded ?? [],
+			outcomeStatuses: input.outcomeStatuses ?? [],
+			outcomeIndex: input.outcomeIndex ?? [],
+		}),
+	);
+}
+
+export function recordWorkspaceProposalRepairReviewDecision(
+	request: WorkspaceProposalRepairReviewRequest,
+	options: WorkspaceProposalRepairReviewDecisionRecordingOptions,
+): WorkspaceProposalRepairReviewDecisionRecordingResult {
+	const issues = repairReviewDecisionRecordingIssues(request, options);
+	if (issues.length > 0) {
+		return {
+			kind: "workspace-proposal-repair-review-decision-recording-result",
+			status: "blocked",
+			issues,
+			sourceRefs: [],
+		};
+	}
+	const sourceRefs = immutableClone(
+		uniqueRefs([
+			...options.sourceRefs!.filter(repairReviewDecisionSourceRefIsValid),
+			...(repairReviewDecisionSourceRefIsValid(options.reviewerRef) ? [options.reviewerRef] : []),
+			...(repairReviewDecisionSourceRefIsValid(options.actorRef) ? [options.actorRef] : []),
+			...(Array.isArray(options.capabilityRefs)
+				? options.capabilityRefs.filter(repairReviewDecisionSourceRefIsValid)
+				: []),
+			...(Array.isArray(options.policyRefs)
+				? options.policyRefs.filter(repairReviewDecisionSourceRefIsValid)
+				: []),
+		]),
+	);
+	const decision: WorkspaceProposalRepairReviewDecision = {
+		kind: "workspace-proposal-repair-review-decision",
+		reviewDecisionId: options.reviewDecisionId!,
+		repairRequestId: request.repairRequestId,
+		applicationId: request.applicationId,
+		proposalId: request.proposalId,
+		decisionId: request.decisionId,
+		idempotencyKey: request.idempotencyKey,
+		proposalFamily: request.proposalFamily,
+		intent: options.intent!,
+		...(options.reviewerRef === undefined
+			? {}
+			: { reviewerRef: immutableClone(options.reviewerRef) }),
+		...(options.actorRef === undefined ? {} : { actorRef: immutableClone(options.actorRef) }),
+		...(options.capabilityRefs === undefined
+			? {}
+			: { capabilityRefs: immutableClone(options.capabilityRefs) }),
+		...(options.policyRefs === undefined ? {} : { policyRefs: immutableClone(options.policyRefs) }),
+		...(options.reason === undefined ? {} : { reason: options.reason }),
+		...(options.code === undefined ? {} : { code: options.code }),
+		...(options.resolvesRefs === undefined
+			? {}
+			: { resolvesRefs: immutableClone(options.resolvesRefs) }),
+		...(options.supersedesRefs === undefined
+			? {}
+			: { supersedesRefs: immutableClone(options.supersedesRefs) }),
+		...(options.decidedAtMs === undefined ? {} : { decidedAtMs: options.decidedAtMs }),
+		...(sourceRefs.length === 0 ? {} : { sourceRefs }),
+		...(options.audit === undefined ? {} : { audit: immutableClone(options.audit) }),
+		...(options.metadata === undefined ? {} : { metadata: immutableClone(options.metadata) }),
+	};
+	return {
+		kind: "workspace-proposal-repair-review-decision-recording-result",
+		status: "recorded",
+		decision,
+		issues: [],
+		audit: decision.audit,
+		sourceRefs: immutableClone(sourceRefs),
+	};
+}
+
+export function projectWorkspaceProposalRepairReviewDecisionRecordings(
+	input: WorkspaceProposalRepairReviewDecisionRecordingProjectionInput,
+): readonly WorkspaceProposalRepairReviewDecisionRecordingResult[] {
+	const requests = new Map<string, WorkspaceProposalRepairReviewRequest>();
+	for (const request of input.requests ?? []) requests.set(request.repairRequestId, request);
+	const statuses = new Map<string, WorkspaceProposalRepairReviewStatus>();
+	for (const status of input.statuses ?? [])
+		statuses.set(repairReviewStatusProjectionKey(status), status);
+	const groupedInputs = new Map<
+		string,
+		{
+			readonly input: WorkspaceProposalRepairReviewDecisionRecordingInput;
+			readonly signature: string;
+			readonly conflict: boolean;
+		}
+	>();
+	for (const recordingInput of input.recordingInputs ?? []) {
+		const key = recordingInput.reviewDecisionId;
+		const signature = repairReviewDecisionRecordingInputSignature(recordingInput);
+		const existing = groupedInputs.get(key);
+		if (existing === undefined) {
+			groupedInputs.set(key, { input: recordingInput, signature, conflict: false });
+			continue;
+		}
+		if (existing.signature !== signature) {
+			groupedInputs.set(key, { ...existing, conflict: true });
+		}
+	}
+	const results: WorkspaceProposalRepairReviewDecisionRecordingResult[] = [];
+	for (const entry of groupedInputs.values()) {
+		const request = requests.get(entry.input.repairRequestId);
+		if (entry.conflict) {
+			results.push(
+				blockedRepairReviewDecisionRecordingResult(entry.input, request, [
+					repairReviewDecisionRecordingInputIssue(
+						"conflicting-repair-review-decision-recording-input",
+						"Repair-review decision recording inputs conflict for the same reviewDecisionId.",
+						entry.input,
+						request,
+					),
+				]),
+			);
+			continue;
+		}
+		if (entry.input.kind !== "workspace-proposal-repair-review-decision-recording-input") {
+			results.push(
+				blockedRepairReviewDecisionRecordingResult(entry.input, request, [
+					repairReviewDecisionRecordingInputIssue(
+						"malformed-recording-options",
+						"Repair-review decision recording projector requires typed recording input material.",
+						entry.input,
+						request,
+					),
+				]),
+			);
+			continue;
+		}
+		if (request === undefined) {
+			results.push(
+				blockedRepairReviewDecisionRecordingResult(entry.input, undefined, [
+					repairReviewDecisionRecordingInputIssue(
+						"missing-repair-review-request",
+						"Repair-review decision recording input requires a matching repair-review request.",
+						entry.input,
+						undefined,
+					),
+				]),
+			);
+			continue;
+		}
+		const currentStatus = statuses.get(repairReviewStatusProjectionKeyFromRequest(request));
+		results.push(
+			recordWorkspaceProposalRepairReviewDecision(request, {
+				reviewDecisionId: entry.input.reviewDecisionId,
+				intent: entry.input.intent,
+				reviewerRef: entry.input.reviewerRef,
+				actorRef: entry.input.actorRef,
+				capabilityRefs: entry.input.capabilityRefs,
+				policyRefs: entry.input.policyRefs,
+				sourceRefs: entry.input.sourceRefs,
+				audit: entry.input.audit,
+				reason: entry.input.reason,
+				code: entry.input.code,
+				resolvesRefs: entry.input.resolvesRefs,
+				supersedesRefs: entry.input.supersedesRefs,
+				decidedAtMs: entry.input.decidedAtMs,
+				metadata: entry.input.metadata,
+				currentStatus,
+				expectedCurrentState: entry.input.expectedCurrentState,
+			}),
+		);
+	}
+	return results;
+}
+
+/** Graph-visible variant of `projectWorkspaceProposalRepairReviewDecisionRecordings`. */
+export function workspaceProposalRepairReviewDecisionRecordingProjector(
+	graph: Graph,
+	opts: WorkspaceProposalRepairReviewDecisionRecordingProjectorOptions,
+): WorkspaceProposalRepairReviewDecisionRecordingProjectorBundle {
+	const name = opts.name ?? "workspaceProposalRepairReviewDecisionRecording";
+	const { deps, depKinds } = repairReviewDecisionRecordingProjectionDeps(opts);
+	const runtime = graph.node<
+		| {
+				readonly kind: "repair-decision-recording-result";
+				readonly value: WorkspaceProposalRepairReviewDecisionRecordingResult;
+		  }
+		| {
+				readonly kind: "repair-decision";
+				readonly value: WorkspaceProposalRepairReviewDecision;
+		  }
+		| { readonly kind: "issue"; readonly value: WorkspaceProposalRecordedIssue }
+		| undefined
+	>(
+		deps,
+		(ctx) => {
+			const state = familyProjectionState(ctx);
+			ingestDiagnosticInputFacts(ctx, state, depKinds);
+			for (const result of projectWorkspaceProposalRepairReviewDecisionRecordings({
+				requests: [...state.repairRequests.values()],
+				recordingInputs: [...state.repairDecisionRecordingInputs.values()],
+				statuses: [...state.repairStatuses.values()],
+			})) {
+				const emissionKey = repairReviewDecisionRecordingResultKey(result);
+				const signature = stableStringify(result);
+				if (state.emittedRepairDecisionRecordings.get(emissionKey) === signature) continue;
+				state.emittedRepairDecisionRecordings.set(emissionKey, signature);
+				ctx.down([["DATA", { kind: "repair-decision-recording-result", value: result }]]);
+				for (const issue of result.issues) {
+					ctx.down([["DATA", { kind: "issue", value: issue }]]);
+				}
+				if (result.decision !== undefined) {
+					ctx.down([["DATA", { kind: "repair-decision", value: result.decision }]]);
+				}
+			}
+			ctx.state.set(state);
+		},
+		runtimeOptions(name, "workspaceProposalRepairReviewDecisionRecordingProjector"),
+	);
+	return {
+		results: project(graph, runtime, `${name}/results`, `${name}Results`, (fact) =>
+			fact?.kind === "repair-decision-recording-result" ? fact.value : undefined,
+		),
+		decisions: project(graph, runtime, `${name}/decisions`, `${name}Decisions`, (fact) =>
+			fact?.kind === "repair-decision" ? fact.value : undefined,
+		),
+		issues: project(graph, runtime, `${name}/issues`, `${name}Issues`, (fact) =>
+			fact?.kind === "issue" ? fact.value : undefined,
+		),
+	};
+}
+
+/** Graph-visible variant of `projectWorkspaceProposalRepairReviewStatuses`. */
+export function workspaceProposalRepairReviewStatusProjector(
+	graph: Graph,
+	opts: WorkspaceProposalRepairReviewStatusProjectorOptions,
+): WorkspaceProposalRepairReviewStatusProjectorBundle {
+	const name = opts.name ?? "workspaceProposalRepairReviewStatus";
+	const { deps, depKinds } = repairReviewStatusProjectionDeps(opts);
+	const runtime = graph.node<
+		| {
+				readonly kind: "repair-review-status";
+				readonly value: WorkspaceProposalRepairReviewStatus;
+		  }
+		| undefined
+	>(
+		deps,
+		(ctx) => {
+			const state = familyProjectionState(ctx);
+			ingestDiagnosticInputFacts(ctx, state, depKinds);
+			for (const status of projectWorkspaceProposalRepairReviewStatuses({
+				requests: [...state.repairRequests.values()],
+				decisions: [...state.repairDecisions.values()],
+				applicationStatuses: [...state.applicationStatuses.values()],
+				applicationRecorded: [...state.applicationRecorded.values()],
+				outcomeStatuses: [...state.outcomeStatuses.values()],
+				outcomeIndex: [...state.outcomeIndex.values()],
+			})) {
+				const signature = repairReviewStatusSignature(status);
+				if (state.emittedRepairStatuses.get(status.repairRequestId) === signature) continue;
+				state.emittedRepairStatuses.set(status.repairRequestId, signature);
+				ctx.down([["DATA", { kind: "repair-review-status", value: status }]]);
+			}
+			ctx.state.set(state);
+		},
+		runtimeOptions(name, "workspaceProposalRepairReviewStatusProjector"),
+	);
+	return {
+		statuses: project(graph, runtime, `${name}/statuses`, `${name}Statuses`, (fact) =>
+			fact?.kind === "repair-review-status" ? fact.value : undefined,
+		),
+	};
+}
+
+export function projectWorkspaceProposalFamilyApplicationReadModel(
+	input: WorkspaceProposalFamilyApplicationReadModelProjectionInput,
+): WorkspaceProposalFamilyApplicationReadModel {
+	const coordinates = readModelCoordinates(input);
+	const hasCompleteCoordinates = readModelCoordinatesComplete(coordinates);
+	const filters = normalizeReadModelFilters(input.filters).filters;
+	const presentation = normalizeReadModelPresentationOptions(
+		input.sort,
+		input.groupBy,
+		input.search,
+	);
+	const diagnostics = (input.diagnostics ?? []).filter((diagnostic) =>
+		hasCompleteCoordinates
+			? coordinatesMatchExact(coordinates, diagnostic) &&
+				matchesOptionalSet(filters.diagnosticCodes, diagnostic.code)
+			: false,
+	);
+	const repairReviewStatuses = (input.repairReviewStatuses ?? []).filter((status) =>
+		hasCompleteCoordinates
+			? coordinatesMatchExact(coordinates, status) &&
+				matchesOptionalSet(filters.repairStates, status.state)
+			: false,
+	);
+	const outcomeIndexes = (input.outcomeIndex ?? [])
+		.filter((entry) => (hasCompleteCoordinates ? coordinatesMatchExact(coordinates, entry) : false))
+		.map((entry) => filterOutcomeIndexEntry(entry, filters))
+		.filter((entry) => entry.outcomeRefs.length > 0 || entry.state === "idempotency-conflict");
+	const outcomes = groupByOutcomeId(input.outcomes ?? []);
+	const statuses = groupByOutcomeId(input.outcomeStatuses ?? []);
+	const allOutcomeRefs = sortReadModelOutcomeRefs(
+		outcomeIndexes
+			.flatMap((entry) => entry.outcomeRefs)
+			.filter((ref) =>
+				readModelSearchMatches(ref, presentation.search, diagnostics, repairReviewStatuses),
+			),
+		presentation.sort,
+		diagnostics,
+		repairReviewStatuses,
+		outcomes,
+		statuses,
+	);
+	const offset = normalizePageOffset(input.offset);
+	const limit = normalizePageLimit(input.limit);
+	const pagedRefs = allOutcomeRefs.slice(offset, offset + limit);
+	const outcomeDetails: WorkspaceProposalFamilyOutcomeDetail[] = [];
+	const displayDiagnostics: WorkspaceProposalFamilyApplicationReadModelDisplayDiagnostic[] = [
+		...(input.displayDiagnostics ?? []),
+		...presentation.diagnostics,
+	];
+	for (const outcomeRef of pagedRefs) {
+		const outcomeCandidates = outcomes.get(outcomeRef.outcomeId) ?? [];
+		const statusCandidates = statuses.get(outcomeRef.outcomeId) ?? [];
+		const outcome = outcomeCandidates.find((candidate) =>
+			sameOutcomeRefCoordinates(outcomeRef, candidate),
+		);
+		const status = statusCandidates.find((candidate) =>
+			sameOutcomeRefCoordinates(outcomeRef, candidate),
+		);
+		if (outcome === undefined && outcomeCandidates.length === 0) {
+			displayDiagnostics.push(readModelDisplayDiagnostic("missing-outcome-detail", outcomeRef));
+		} else if (outcome === undefined) {
+			displayDiagnostics.push(readModelDisplayDiagnostic("mismatched-outcome-detail", outcomeRef));
+		}
+		if (status === undefined && statusCandidates.length > 0) {
+			displayDiagnostics.push(readModelDisplayDiagnostic("mismatched-outcome-status", outcomeRef));
+		}
+		outcomeDetails.push({
+			kind: "workspace-proposal-family-outcome-detail",
+			outcomeRef,
+			...(outcome !== undefined ? { outcome } : {}),
+			...(status !== undefined ? { status } : {}),
+		});
+	}
+	const displayGroups = readModelDisplayGroups(
+		pagedRefs,
+		presentation.groupBy,
+		diagnostics,
+		repairReviewStatuses,
+	);
+	return {
+		kind: "workspace-proposal-family-application-read-model",
+		readModelId: `workspace-proposal-family-application-read-model:${stableStringify({
+			queryId: stringField(input.queryId),
+			viewId: stringField(input.viewId),
+			...coordinates,
+			offset,
+			limit,
+			filters,
+			sort: presentation.sort,
+			groupBy: presentation.groupBy,
+			search: presentation.search,
+		})}`,
+		...(stringField(input.queryId) === undefined ? {} : { queryId: stringField(input.queryId) }),
+		...(stringField(input.viewId) === undefined ? {} : { viewId: stringField(input.viewId) }),
+		...coordinates,
+		filters,
+		sort: presentation.sort,
+		groupBy: presentation.groupBy,
+		search: presentation.search,
+		diagnostics,
+		repairReviewStatuses,
+		outcomeIndexes,
+		outcomeDetails,
+		displayGroups,
+		displayDiagnostics,
+		page: {
+			offset,
+			limit,
+			totalOutcomeRefs: allOutcomeRefs.length,
+			returnedOutcomeRefs: pagedRefs.length,
+		},
+	};
+}
+
+export function projectWorkspaceProposalFamilyApplicationReadModels(
+	input: WorkspaceProposalFamilyApplicationReadModelsProjectionInput,
+): readonly WorkspaceProposalFamilyApplicationReadModel[] {
+	const currentQueries = new Map<string, WorkspaceProposalFamilyApplicationReadModelQuery>();
+	for (const query of input.queries ?? []) {
+		currentQueries.set(readModelQueryProjectionKey(query), query);
+	}
+	return [...currentQueries.values()].map((query) => {
+		const normalized = normalizeReadModelQuery(query);
+		if (!normalized.complete || normalized.malformed) {
+			return projectWorkspaceProposalFamilyApplicationReadModel({
+				queryId: normalized.queryId,
+				viewId: normalized.viewId,
+				offset: normalized.page.offset,
+				limit: normalized.page.limit,
+				filters: normalized.filters,
+				sort: normalized.sort,
+				groupBy: normalized.groupBy,
+				search: normalized.search,
+				displayDiagnostics: [
+					readModelQueryDisplayDiagnostic(
+						normalized.malformed ? "malformed-read-model-query" : "incomplete-read-model-query",
+						normalized,
+					),
+				],
+			});
+		}
+		return projectWorkspaceProposalFamilyApplicationReadModel({
+			diagnostics: input.diagnostics,
+			repairReviewStatuses: input.repairReviewStatuses,
+			outcomeIndex: input.outcomeIndex,
+			outcomeStatuses: input.outcomeStatuses,
+			outcomes: input.outcomes,
+			queryId: normalized.queryId,
+			viewId: normalized.viewId,
+			applicationId: normalized.coordinates.applicationId,
+			proposalId: normalized.coordinates.proposalId,
+			decisionId: normalized.coordinates.decisionId,
+			idempotencyKey: normalized.coordinates.idempotencyKey,
+			proposalFamily: normalized.coordinates.proposalFamily,
+			offset: normalized.page.offset,
+			limit: normalized.page.limit,
+			filters: normalized.filters,
+			sort: normalized.sort,
+			groupBy: normalized.groupBy,
+			search: normalized.search,
+		});
+	});
+}
+
+export function workspaceProposalProjectionReleaseDiagnosticProjector(
+	graph: Graph,
+	opts: WorkspaceProposalProjectionReleaseDiagnosticProjectorOptions,
+): WorkspaceProposalProjectionReleaseDiagnosticProjectorBundle {
+	const name = opts.name ?? "workspaceProposalProjectionReleaseDiagnostic";
+	const runtime = graph.node<
+		| {
+				readonly kind: "projection-release-diagnostic";
+				readonly value: WorkspaceProposalProjectionReleaseDiagnostic;
+		  }
+		| undefined
+	>(
+		[opts.releases],
+		(ctx) => {
+			for (const raw of depBatch(ctx, 0) ?? []) {
+				const validation = validateWorkspaceProposalProjectionReleaseMaterial(raw);
+				if (validation.status !== "blocked") continue;
+				const diagnostic = workspaceProposalProjectionReleaseDiagnosticFromValidation(validation);
+				ctx.down([["DATA", { kind: "projection-release-diagnostic", value: diagnostic }]]);
+			}
+		},
+		runtimeOptions(name, "workspaceProposalProjectionReleaseDiagnosticProjector"),
+	);
+	return {
+		diagnostics: project(graph, runtime, `${name}/diagnostics`, `${name}Diagnostics`, (fact) =>
+			fact?.kind === "projection-release-diagnostic" ? fact.value : undefined,
+		),
+	};
+}
+
+/** Graph-visible variant of `projectWorkspaceProposalFamilyApplicationReadModel`. */
+export function workspaceProposalFamilyApplicationReadModelProjector(
+	graph: Graph,
+	opts: WorkspaceProposalFamilyApplicationReadModelProjectorOptions,
+): WorkspaceProposalFamilyApplicationReadModelProjectorBundle {
+	const name = opts.name ?? "workspaceProposalFamilyApplicationReadModel";
+	const { deps, depKinds } = readModelProjectionDeps(opts);
+	const runtime = graph.node<
+		| {
+				readonly kind: "read-model";
+				readonly value: WorkspaceProposalFamilyApplicationReadModel;
+		  }
+		| undefined
+	>(
+		deps,
+		(ctx) => {
+			const state = familyProjectionState(ctx);
+			ingestDiagnosticInputFacts(ctx, state, depKinds);
+			const readModel = projectWorkspaceProposalFamilyApplicationReadModel({
+				diagnostics: [...state.diagnostics.values()],
+				repairReviewStatuses: [...state.repairStatuses.values()],
+				outcomeIndex: [...state.outcomeIndex.values()],
+				outcomeStatuses: [...state.outcomeStatuses.values()],
+				outcomes: [...state.outcomes.values()],
+				applicationId: opts.applicationId,
+				proposalId: opts.proposalId,
+				decisionId: opts.decisionId,
+				idempotencyKey: opts.idempotencyKey,
+				proposalFamily: opts.proposalFamily,
+				offset: opts.offset,
+				limit: opts.limit,
+				sort: opts.sort,
+				groupBy: opts.groupBy,
+				search: opts.search,
+			});
+			const signature = readModelSignature(readModel);
+			if (state.emittedReadModels.get(readModel.readModelId) !== signature) {
+				state.emittedReadModels.set(readModel.readModelId, signature);
+				ctx.down([["DATA", { kind: "read-model", value: readModel }]]);
+			}
+			ctx.state.set(state);
+		},
+		runtimeOptions(name, "workspaceProposalFamilyApplicationReadModelProjector"),
+	);
+	return {
+		readModels: project(graph, runtime, `${name}/readModels`, `${name}ReadModels`, (fact) =>
+			fact?.kind === "read-model" ? fact.value : undefined,
+		),
+	};
+}
+
+/** Graph-visible query-driven variant of `projectWorkspaceProposalFamilyApplicationReadModels`. */
+export function workspaceProposalFamilyApplicationReadModelsProjector(
+	graph: Graph,
+	opts: WorkspaceProposalFamilyApplicationReadModelsProjectorOptions,
+): WorkspaceProposalFamilyApplicationReadModelProjectorBundle {
+	const name = opts.name ?? "workspaceProposalFamilyApplicationReadModels";
+	const { deps, depKinds } = readModelsProjectionDeps(opts);
+	const runtime = graph.node<
+		| {
+				readonly kind: "read-model";
+				readonly value: WorkspaceProposalFamilyApplicationReadModel;
+		  }
+		| undefined
+	>(
+		deps,
+		(ctx) => {
+			const state = familyProjectionState(ctx);
+			ingestDiagnosticInputFacts(ctx, state, depKinds);
+			for (const readModel of projectWorkspaceProposalFamilyApplicationReadModels({
+				queries: [...state.readModelQueries.values()],
+				diagnostics: [...state.diagnostics.values()],
+				repairReviewStatuses: [...state.repairStatuses.values()],
+				outcomeIndex: [...state.outcomeIndex.values()],
+				outcomeStatuses: [...state.outcomeStatuses.values()],
+				outcomes: [...state.outcomes.values()],
+			})) {
+				const signature = readModelEmissionSignature(readModel);
+				if (state.emittedReadModels.get(readModelCurrentViewKey(readModel)) === signature) {
+					continue;
+				}
+				state.emittedReadModels.set(readModelCurrentViewKey(readModel), signature);
+				ctx.down([["DATA", { kind: "read-model", value: readModel }]]);
+			}
+			ctx.state.set(state);
+		},
+		runtimeOptions(name, "workspaceProposalFamilyApplicationReadModelsProjector"),
+	);
+	return {
+		readModels: project(graph, runtime, `${name}/readModels`, `${name}ReadModels`, (fact) =>
+			fact?.kind === "read-model" ? fact.value : undefined,
+		),
+	};
+}
+
+export function projectWorkspaceProposalFamilyOutcomeDetailSupplyResults(
+	input: WorkspaceProposalFamilyOutcomeDetailSupplyProjectionInput,
+): readonly WorkspaceProposalFamilyOutcomeDetailSupplyResult[] {
+	const suppliedByOutcomeId = groupByOutcomeId(input.suppliedOutcomes ?? []);
+	return [...currentSupplyRequests(input.requests ?? []).values()].map((request) =>
+		projectWorkspaceProposalFamilyOutcomeDetailSupplyResult(request, suppliedByOutcomeId),
+	);
+}
+
+export function projectWorkspaceProposalFamilyOutcomeDetailSupplyResult(
+	request: WorkspaceProposalFamilyOutcomeDetailSupplyRequest | unknown,
+	suppliedOutcomes:
+		| readonly WorkspaceProposalFamilyOutcomeRecord[]
+		| ReadonlyMap<string, readonly WorkspaceProposalFamilyOutcomeRecord[]> = [],
+): WorkspaceProposalFamilyOutcomeDetailSupplyResult {
+	const issues = outcomeDetailSupplyRequestIssues(request);
+	const requestRecord = isRecord(request) ? request : {};
+	const requestAudit = safeWorkspaceProposalAudit(requestRecord.audit);
+	const boundarySafeRequestAudit =
+		requestAudit === undefined ||
+		!workspaceProposalBoundarySourceRefsAreSafe(requestAudit.sourceRefs)
+			? undefined
+			: requestAudit;
+	const sourceRefs = repairActionSourceRefs([
+		...safeBoundarySourceRefs(requestRecord.sourceRefs),
+		...(boundarySafeRequestAudit?.sourceRefs ?? []),
+	]);
+	const pageRecord = isRecord(requestRecord.page) ? requestRecord.page : {};
+	const filters = normalizeReadModelFilters(
+		isRecord(requestRecord.filters)
+			? (requestRecord.filters as WorkspaceProposalFamilyApplicationReadModelFilters)
+			: undefined,
+	).filters;
+	const currentViewId =
+		stringField(requestRecord.viewId) ?? stringField(requestRecord.supplyRequestId) ?? "unknown";
+	const coordinates = {
+		applicationId: stringField(requestRecord.applicationId),
+		proposalId: stringField(requestRecord.proposalId),
+		decisionId: stringField(requestRecord.decisionId),
+		idempotencyKey: stringField(requestRecord.idempotencyKey),
+		proposalFamily: stringField(requestRecord.proposalFamily) as
+			| WorkspaceProposalFamily
+			| undefined,
+	};
+	if (issues.length > 0 || !isOutcomeDetailSupplyRequestMaterial(request)) {
+		return {
+			kind: "workspace-proposal-family-outcome-detail-supply-result",
+			...(stringField(requestRecord.supplyRequestId) === undefined
+				? {}
+				: { supplyRequestId: stringField(requestRecord.supplyRequestId) }),
+			...(stringField(requestRecord.viewId) === undefined
+				? {}
+				: { viewId: stringField(requestRecord.viewId) }),
+			currentViewId,
+			...coordinates,
+			suppliedOutcomeFacts: [],
+			missingRefs: [],
+			mismatchedRefs: [],
+			displayDiagnostics: [
+				outcomeDetailSupplyDiagnostic(
+					"malformed-outcome-detail-supply-request",
+					"Workspace proposal family outcome detail supply request is malformed",
+					undefined,
+					coordinates,
+					sourceRefs,
+				),
+			],
+			page: {
+				offset: normalizePageOffset(pageRecord.offset),
+				limit: normalizePageLimit(pageRecord.limit),
+			},
+			filters,
+			sourceRefs,
+			...(boundarySafeRequestAudit === undefined ? {} : { audit: boundarySafeRequestAudit }),
+		};
+	}
+	const suppliedMap: ReadonlyMap<string, readonly WorkspaceProposalFamilyOutcomeRecord[]> =
+		Array.isArray(suppliedOutcomes)
+			? groupByOutcomeId<WorkspaceProposalFamilyOutcomeRecord>(
+					suppliedOutcomes as readonly WorkspaceProposalFamilyOutcomeRecord[],
+				)
+			: (suppliedOutcomes as ReadonlyMap<string, readonly WorkspaceProposalFamilyOutcomeRecord[]>);
+	const offset = normalizePageOffset(request.page?.offset);
+	const limit = normalizePageLimit(request.page?.limit);
+	const pagedRequestRefs = request.requestedOutcomeRefs.slice(offset, offset + limit);
+	const pagedRefs = pagedRequestRefs.filter((ref) =>
+		supplyRequestRefMatches(request, ref, filters),
+	);
+	const suppliedOutcomeFacts: WorkspaceProposalFamilyOutcomeRecord[] = [];
+	const missingRefs: WorkspaceProposalFamilyOutcomeRef[] = [];
+	const mismatchedRefs: WorkspaceProposalFamilyOutcomeRef[] = [];
+	const displayDiagnostics: WorkspaceProposalFamilyApplicationReadModelDisplayDiagnostic[] = [];
+	for (const ref of pagedRefs) {
+		const candidates = suppliedMap.get(ref.outcomeId) ?? [];
+		const match = candidates.find((candidate) => sameOutcomeRefCoordinates(ref, candidate));
+		if (match !== undefined) {
+			const dataOnlyIssues = workspaceProposalDataOnlyIssues(match, "suppliedOutcomeDetail");
+			if (dataOnlyIssues.length === 0 && outcomeDetailSupplyOutcomeBoundaryRefsAreSafe(match)) {
+				suppliedOutcomeFacts.push(match);
+			} else {
+				mismatchedRefs.push(ref);
+				displayDiagnostics.push(
+					outcomeDetailSupplyDiagnostic(
+						"malformed-supplied-outcome-detail",
+						"Workspace proposal family supplied outcome detail is not data-only material",
+						ref,
+						request,
+						request.sourceRefs,
+					),
+				);
+			}
+			continue;
+		}
+		if (candidates.length === 0) {
+			missingRefs.push(ref);
+			displayDiagnostics.push(
+				outcomeDetailSupplyDiagnostic(
+					"missing-supplied-outcome-detail",
+					"Workspace proposal family outcome detail supply did not include a requested ref",
+					ref,
+					request,
+					request.sourceRefs,
+				),
+			);
+		} else {
+			mismatchedRefs.push(ref);
+			displayDiagnostics.push(
+				outcomeDetailSupplyDiagnostic(
+					"mismatched-supplied-outcome-detail",
+					"Workspace proposal family outcome detail supply mismatches a requested ref",
+					ref,
+					request,
+					request.sourceRefs,
+				),
+			);
+		}
+	}
+	for (const ref of pagedRequestRefs) {
+		if (sameSupplyRequestCoordinates(request, ref)) continue;
+		mismatchedRefs.push(ref);
+		displayDiagnostics.push(
+			outcomeDetailSupplyDiagnostic(
+				"mismatched-supplied-outcome-detail",
+				"Workspace proposal family outcome detail request ref mismatches supply coordinates",
+				ref,
+				request,
+				request.sourceRefs,
+			),
+		);
+	}
+	return {
+		kind: "workspace-proposal-family-outcome-detail-supply-result",
+		supplyRequestId: request.supplyRequestId,
+		...(request.viewId === undefined ? {} : { viewId: request.viewId }),
+		currentViewId: request.viewId ?? request.supplyRequestId,
+		applicationId: request.applicationId,
+		proposalId: request.proposalId,
+		decisionId: request.decisionId,
+		idempotencyKey: request.idempotencyKey,
+		proposalFamily: request.proposalFamily,
+		suppliedOutcomeFacts: dedupeOutcomes(suppliedOutcomeFacts),
+		missingRefs,
+		mismatchedRefs,
+		displayDiagnostics,
+		page: {
+			offset,
+			limit,
+		},
+		filters,
+		sourceRefs: repairActionSourceRefs([
+			...request.sourceRefs,
+			...(request.audit?.sourceRefs ?? []),
+		]),
+		...(request.audit === undefined ? {} : { audit: immutableClone(request.audit) }),
+	};
+}
+
+export function workspaceProposalFamilyOutcomeDetailSupplyProjector(
+	graph: Graph,
+	opts: WorkspaceProposalFamilyOutcomeDetailSupplyProjectorOptions,
+): WorkspaceProposalFamilyOutcomeDetailSupplyProjectorBundle {
+	const name = opts.name ?? "workspaceProposalFamilyOutcomeDetailSupply";
+	const deps =
+		opts.releases === undefined
+			? [opts.requests, opts.suppliedOutcomes]
+			: [opts.requests, opts.suppliedOutcomes, opts.releases];
+	const runtime = graph.node<
+		| {
+				readonly kind: "outcome-detail-supply-result";
+				readonly value: WorkspaceProposalFamilyOutcomeDetailSupplyResult;
+		  }
+		| undefined
+	>(
+		deps,
+		(ctx) => {
+			const state = ctx.state.get<{
+				readonly requests: Map<string, WorkspaceProposalFamilyOutcomeDetailSupplyRequest>;
+				readonly suppliedOutcomes: Map<string, WorkspaceProposalFamilyOutcomeRecord>;
+				readonly emittedResults: Map<string, string>;
+			}>() ?? {
+				requests: new Map(),
+				suppliedOutcomes: new Map(),
+				emittedResults: new Map(),
+			};
+			for (const raw of depBatch(ctx, 0) ?? []) {
+				const request = raw as WorkspaceProposalFamilyOutcomeDetailSupplyRequest;
+				state.requests.set(outcomeDetailSupplyRequestProjectionKey(request), request);
+			}
+			for (const raw of depBatch(ctx, 1) ?? []) {
+				const outcome = raw as WorkspaceProposalFamilyOutcomeRecord;
+				if (isOutcomeDetailSupplyOutcomeRecordShape(outcome)) {
+					state.suppliedOutcomes.set(outcomeProjectionKey(outcome), outcome);
+				}
+			}
+			if (opts.releases !== undefined) {
+				for (const raw of depBatch(ctx, 2) ?? []) {
+					pruneOutcomeDetailSupplyRelease(state, raw);
+				}
+			}
+			for (const result of projectWorkspaceProposalFamilyOutcomeDetailSupplyResults({
+				requests: [...state.requests.values()],
+				suppliedOutcomes: [...state.suppliedOutcomes.values()],
+			})) {
+				const signature = stableStringify(result);
+				if (state.emittedResults.get(result.currentViewId) === signature) continue;
+				state.emittedResults.set(result.currentViewId, signature);
+				ctx.down([["DATA", { kind: "outcome-detail-supply-result", value: result }]]);
+			}
+			ctx.state.set(state);
+		},
+		runtimeOptions(name, "workspaceProposalFamilyOutcomeDetailSupplyProjector"),
+	);
+	return {
+		results: project(graph, runtime, `${name}/results`, `${name}Results`, (fact) =>
+			fact?.kind === "outcome-detail-supply-result" ? fact.value : undefined,
+		),
+	};
+}
+
+export function projectWorkspaceProposalRepairActionDescriptors(
+	input: WorkspaceProposalRepairActionDescriptorProjectionInput,
+): readonly WorkspaceProposalRepairActionDescriptor[] {
+	const descriptors: WorkspaceProposalRepairActionDescriptor[] = [];
+	for (const request of input.requests ?? []) {
+		const status = matchingRepairReviewStatus(request, input.statuses ?? []);
+		const state = status?.state ?? "open";
+		for (const actionKind of repairActionKinds) {
+			descriptors.push(repairActionDescriptor(request, status, actionKind, state));
+		}
+	}
+	return descriptors;
+}
+
+export function workspaceProposalRepairActionDescriptorProjector(
+	graph: Graph,
+	opts: WorkspaceProposalRepairActionDescriptorProjectorOptions,
+): WorkspaceProposalRepairActionDescriptorProjectorBundle {
+	const name = opts.name ?? "workspaceProposalRepairActionDescriptor";
+	const deps =
+		opts.statuses === undefined ? [opts.requests as Node<unknown>] : [opts.requests, opts.statuses];
+	const depKinds: readonly WorkspaceProposalFamilyApplicationDiagnosticInputFact["kind"][] =
+		opts.statuses === undefined ? ["repair-request"] : ["repair-request", "repair-status"];
+	const runtime = graph.node<
+		| {
+				readonly kind: "repair-action-descriptor";
+				readonly value: WorkspaceProposalRepairActionDescriptor;
+		  }
+		| undefined
+	>(
+		deps,
+		(ctx) => {
+			const state = familyProjectionState(ctx);
+			ingestDiagnosticInputFacts(ctx, state, depKinds);
+			for (const descriptor of projectWorkspaceProposalRepairActionDescriptors({
+				requests: [...state.repairRequests.values()],
+				statuses: [...state.repairStatuses.values()],
+			})) {
+				const signature = repairActionDescriptorSignature(descriptor);
+				if (state.emittedRepairActionDescriptors.get(descriptor.descriptorId) === signature) {
+					continue;
+				}
+				state.emittedRepairActionDescriptors.set(descriptor.descriptorId, signature);
+				ctx.down([["DATA", { kind: "repair-action-descriptor", value: descriptor }]]);
+			}
+			ctx.state.set(state);
+		},
+		runtimeOptions(name, "workspaceProposalRepairActionDescriptorProjector"),
+	);
+	return {
+		descriptors: project(graph, runtime, `${name}/descriptors`, `${name}Descriptors`, (fact) =>
+			fact?.kind === "repair-action-descriptor" ? fact.value : undefined,
+		),
+	};
+}
+
+export function validateWorkspaceProposalRepairActionIntent(
+	intent: WorkspaceProposalRepairActionIntent | unknown,
+	optionsOrDescriptor:
+		| WorkspaceProposalRepairActionIntentValidationOptions
+		| WorkspaceProposalRepairActionDescriptor
+		| undefined = {},
+	request?: WorkspaceProposalRepairReviewRequest,
+	currentStatus?: WorkspaceProposalRepairReviewStatus,
+): WorkspaceProposalRepairActionIntentValidationResult {
+	const options = repairActionValidationOptions(optionsOrDescriptor, request, currentStatus);
+	const issues = repairActionIntentIssues(intent, options);
+	const accepted = issues.length === 0 && isRepairActionIntentMaterial(intent);
+	const normalized = accepted
+		? immutableClone(intent as WorkspaceProposalRepairActionIntent)
+		: undefined;
+	const record = isRecord(intent) ? intent : {};
+	const sourceRefs = repairActionSourceRefs([
+		...(isRepairActionIntentMaterial(intent) ? (intent.sourceRefs ?? []) : []),
+		...(options.sourceRefs ?? []),
+		...(safeWorkspaceProposalAudit(options.audit)?.sourceRefs ?? []),
+	]);
+	const audit =
+		safeWorkspaceProposalAudit(options.audit) ??
+		(accepted ? safeWorkspaceProposalAudit(normalized?.audit) : undefined);
+	return {
+		kind: "workspace-proposal-repair-action-intent-validation-result",
+		status: accepted ? "accepted" : "blocked",
+		...(normalized !== undefined
+			? {}
+			: {
+					intentId: stringField(record.intentId),
+					descriptorId: stringField(record.descriptorId),
+					repairRequestId: stringField(record.repairRequestId),
+					actionKind: repairActionKinds.includes(
+						record.actionKind as WorkspaceProposalRepairActionKind,
+					)
+						? (record.actionKind as WorkspaceProposalRepairActionKind)
+						: undefined,
+					applicationId: stringField(record.applicationId),
+					proposalId: stringField(record.proposalId),
+					decisionId: stringField(record.decisionId),
+					idempotencyKey: stringField(record.idempotencyKey),
+					proposalFamily: stringField(record.proposalFamily) as WorkspaceProposalFamily | undefined,
+				}),
+		...(normalized === undefined
+			? {}
+			: {
+					intentId: normalized.intentId,
+					descriptorId: normalized.descriptorId,
+					repairRequestId: normalized.repairRequestId,
+					actionKind: normalized.actionKind,
+					applicationId: normalized.applicationId,
+					proposalId: normalized.proposalId,
+					decisionId: normalized.decisionId,
+					idempotencyKey: normalized.idempotencyKey,
+					proposalFamily: normalized.proposalFamily,
+					...(accepted ? { intent: normalized } : {}),
+				}),
+		issues,
+		sourceRefs,
+		...(audit === undefined ? {} : { audit }),
+	};
+}
+
+export function prepareWorkspaceProposalRepairReviewDecisionRecordingInput(
+	intent: WorkspaceProposalRepairActionIntent | unknown,
+	optionsOrDescriptor:
+		| (WorkspaceProposalRepairActionIntentValidationOptions &
+				WorkspaceProposalRepairReviewDecisionRecordingInputPreparationOptions)
+		| WorkspaceProposalRepairActionDescriptor
+		| undefined,
+	request?: WorkspaceProposalRepairReviewRequest,
+	currentStatus?: WorkspaceProposalRepairReviewStatus,
+	preparationOptions?: WorkspaceProposalRepairReviewDecisionRecordingInputPreparationOptions,
+): WorkspaceProposalRepairReviewDecisionRecordingInputPreparationResult {
+	const options =
+		preparationOptions === undefined
+			? ((optionsOrDescriptor ?? {}) as WorkspaceProposalRepairActionIntentValidationOptions &
+					WorkspaceProposalRepairReviewDecisionRecordingInputPreparationOptions)
+			: {
+					...preparationOptions,
+					...repairActionValidationOptions(optionsOrDescriptor, request, currentStatus),
+				};
+	const validation = validateWorkspaceProposalRepairActionIntent(intent, options);
+	const issues: WorkspaceProposalRecordedIssue[] = [...validation.issues];
+	const safeAudit = safeWorkspaceProposalAudit(options.audit);
+	const sourceRefs = repairActionSourceRefs([
+		...(options.sourceRefs ?? []),
+		...(safeAudit?.sourceRefs ?? []),
+	]);
+	if (validation.intent === undefined || options.request === undefined) {
+		return {
+			kind: "workspace-proposal-repair-review-decision-recording-input-preparation-result",
+			status: "blocked",
+			issues: dedupeRepairActionIssues(issues),
+			sourceRefs,
+			...(safeAudit === undefined ? {} : { audit: safeAudit }),
+		};
+	}
+	const decisionIntent = repairActionDecisionIntent(validation.intent.actionKind);
+	if (decisionIntent === undefined) {
+		issues.push(
+			repairActionIntentIssue(
+				"unsupported-repair-action-intent",
+				"Successor proposal actions do not lower to repair-review decision recording input.",
+				validation.intent,
+				options.request,
+			),
+		);
+	}
+	const recordingOptions: WorkspaceProposalRepairReviewDecisionRecordingOptions = {
+		reviewDecisionId: options.reviewDecisionId,
+		intent: decisionIntent,
+		reviewerRef: options.reviewerRef ?? validation.intent.reviewerRef,
+		actorRef: options.actorRef ?? validation.intent.actorRef,
+		capabilityRefs: options.capabilityRefs,
+		policyRefs: options.policyRefs,
+		sourceRefs: options.sourceRefs,
+		audit: options.audit,
+		reason: options.reason,
+		code: options.code,
+		resolvesRefs: options.resolvesRefs,
+		supersedesRefs: options.supersedesRefs,
+		decidedAtMs: options.decidedAtMs,
+		metadata: {
+			...(options.metadata ?? {}),
+			repairActionIntentId: validation.intent.intentId,
+			repairActionDescriptorId: validation.intent.descriptorId,
+			repairActionKind: validation.intent.actionKind,
+		},
+		currentStatus: options.currentStatus,
+		expectedCurrentState: options.expectedCurrentState ?? validation.intent.expectedCurrentState,
+	};
+	if (decisionIntent !== undefined) {
+		issues.push(...repairReviewDecisionRecordingIssues(options.request, recordingOptions));
+	}
+	if (issues.length > 0 || decisionIntent === undefined) {
+		return {
+			kind: "workspace-proposal-repair-review-decision-recording-input-preparation-result",
+			status: "blocked",
+			issues: dedupeRepairActionIssues(issues),
+			sourceRefs,
+			...(safeAudit === undefined ? {} : { audit: safeAudit }),
+		};
+	}
+	const metadata = recordingOptions.metadata ?? {};
+	const recordingInput: WorkspaceProposalRepairReviewDecisionRecordingInput = {
+		kind: "workspace-proposal-repair-review-decision-recording-input",
+		repairRequestId: options.request.repairRequestId,
+		reviewDecisionId: options.reviewDecisionId!,
+		intent: decisionIntent,
+		...(recordingOptions.reviewerRef === undefined
+			? {}
+			: { reviewerRef: immutableClone(recordingOptions.reviewerRef) }),
+		...(recordingOptions.actorRef === undefined
+			? {}
+			: { actorRef: immutableClone(recordingOptions.actorRef) }),
+		...(recordingOptions.capabilityRefs === undefined
+			? {}
+			: { capabilityRefs: immutableClone(recordingOptions.capabilityRefs) }),
+		...(recordingOptions.policyRefs === undefined
+			? {}
+			: { policyRefs: immutableClone(recordingOptions.policyRefs) }),
+		...(recordingOptions.sourceRefs === undefined
+			? {}
+			: { sourceRefs: immutableClone(recordingOptions.sourceRefs) }),
+		audit: immutableClone(options.audit),
+		...(options.reason === undefined ? {} : { reason: options.reason }),
+		...(options.code === undefined ? {} : { code: options.code }),
+		...(options.resolvesRefs === undefined
+			? {}
+			: { resolvesRefs: immutableClone(options.resolvesRefs) }),
+		...(options.supersedesRefs === undefined
+			? {}
+			: { supersedesRefs: immutableClone(options.supersedesRefs) }),
+		...(options.decidedAtMs === undefined ? {} : { decidedAtMs: options.decidedAtMs }),
+		...(Object.keys(metadata).length === 0 ? {} : { metadata: immutableClone(metadata) }),
+		...(recordingOptions.expectedCurrentState === undefined
+			? {}
+			: { expectedCurrentState: immutableClone(recordingOptions.expectedCurrentState) }),
+	};
+	return {
+		kind: "workspace-proposal-repair-review-decision-recording-input-preparation-result",
+		status: "prepared",
+		recordingInput,
+		issues: [],
+		sourceRefs: recordingInput.sourceRefs ?? [],
+		audit: recordingInput.audit,
+	};
+}
+
+export function projectWorkspaceProposalRepairSuccessorProposalIntakePreview(
+	intent: WorkspaceProposalRepairActionIntent | unknown,
+	options: WorkspaceProposalRepairActionIntentValidationOptions &
+		WorkspaceProposalRepairSuccessorProposalIntakePreviewOptions = {},
+): WorkspaceProposalRepairSuccessorProposalIntakePreview {
+	const validation = validateWorkspaceProposalRepairActionIntent(intent, options);
+	const normalized = validation.intent;
+	const diagnostics: WorkspaceProposalRecordedIssue[] = [...validation.issues];
+	if (normalized === undefined) {
+		return blockedRepairSuccessorPreview(intent, diagnostics, options);
+	}
+	if (normalized.actionKind !== "open-successor-proposal-flow") {
+		diagnostics.push(
+			repairActionIntentIssue(
+				"unsupported-repair-action-intent",
+				"Only open-successor-proposal-flow lowers to successor proposal intake preview.",
+				normalized,
+				options.request,
+			),
+		);
+	}
+	diagnostics.push(...repairActionSuggestedDraftPatchIssues(normalized, options));
+	diagnostics.push(...repairActionPreviewMetadataIssues(normalized, options));
+	const targetRefs = repairActionSourceRefs([
+		...(options.request === undefined
+			? []
+			: [
+					{ kind: "workspace-proposal-repair-review-request", id: options.request.repairRequestId },
+				]),
+		...(options.request === undefined ? [] : repairReviewSubjectRefs(options.request)),
+	]);
+	const contextRefs = repairActionSourceRefs([
+		...targetRefs,
+		...(options.currentStatus === undefined
+			? []
+			: [
+					{
+						kind: "workspace-proposal-repair-review-status",
+						id: options.currentStatus.repairRequestId,
+					},
+				]),
+		...(options.contextRefs ?? []),
+	]);
+	const sourceRefs = repairActionSourceRefs([
+		...(normalized.sourceRefs ?? []),
+		...(options.descriptor?.sourceRefs ?? []),
+		...(options.request?.sourceRefs ?? []),
+		...(options.sourceRefs ?? []),
+		...(safeWorkspaceProposalAudit(options.audit)?.sourceRefs ?? []),
+	]);
+	const previewAudit =
+		safeWorkspaceProposalAudit(options.audit) ?? safeWorkspaceProposalAudit(normalized.audit);
+	const previewId =
+		options.previewId ??
+		`workspace-proposal-repair-successor-preview:${stableStringify({
+			intentId: normalized.intentId,
+			descriptorId: normalized.descriptorId,
+			repairRequestId: normalized.repairRequestId,
+		})}`;
+	return {
+		kind: "workspace-proposal-repair-successor-proposal-intake-preview",
+		previewId,
+		status: diagnostics.length === 0 ? "proposal-context-ready" : "blocked",
+		intentId: normalized.intentId,
+		actionIntentId: normalized.intentId,
+		descriptorId: normalized.descriptorId,
+		repairRequestId: normalized.repairRequestId,
+		actionKind: "open-successor-proposal-flow",
+		applicationId: normalized.applicationId,
+		proposalId: normalized.proposalId,
+		decisionId: normalized.decisionId,
+		idempotencyKey: normalized.idempotencyKey,
+		proposalFamily: normalized.proposalFamily,
+		suggestedFamily: options.suggestedFamily ?? normalized.proposalFamily,
+		...(options.suggestedLoweringKind === undefined
+			? {}
+			: { suggestedLoweringKind: options.suggestedLoweringKind }),
+		targetRefs,
+		contextRefs,
+		...(options.reason === undefined ? {} : { reason: options.reason }),
+		code: options.code ?? options.request?.code,
+		...(options.suggestedDraftPatch === undefined
+			? {}
+			: diagnostics.length === 0
+				? { suggestedDraftPatch: immutableClone(options.suggestedDraftPatch) }
+				: {}),
+		diagnostics: dedupeRepairActionIssues(diagnostics),
+		sourceRefs,
+		...(previewAudit === undefined ? {} : { audit: previewAudit }),
+		...(options.metadata === undefined || diagnostics.length > 0
+			? {}
+			: { metadata: immutableClone(options.metadata) }),
+	};
+}
+
+export function previewWorkspaceProposalRepairSuccessorProposalIntake(
+	intentOrRequest:
+		| WorkspaceProposalRepairActionIntent
+		| WorkspaceProposalRepairReviewRequest
+		| undefined,
+	optionsOrStatus?:
+		| (WorkspaceProposalRepairActionIntentValidationOptions &
+				WorkspaceProposalRepairSuccessorProposalIntakePreviewOptions)
+		| WorkspaceProposalRepairReviewStatus,
+	intent?: WorkspaceProposalRepairActionIntent | unknown,
+	options: WorkspaceProposalRepairSuccessorProposalIntakePreviewOptions = {},
+): WorkspaceProposalRepairSuccessorProposalIntakePreview {
+	if (isRepairActionIntentMaterial(intentOrRequest)) {
+		return projectWorkspaceProposalRepairSuccessorProposalIntakePreview(
+			intentOrRequest,
+			(optionsOrStatus ?? {}) as WorkspaceProposalRepairActionIntentValidationOptions &
+				WorkspaceProposalRepairSuccessorProposalIntakePreviewOptions,
+		);
+	}
+	const inlineOptions = isRepairReviewStatusMaterial(optionsOrStatus)
+		? {}
+		: ((optionsOrStatus ?? {}) as WorkspaceProposalRepairActionIntentValidationOptions &
+				WorkspaceProposalRepairSuccessorProposalIntakePreviewOptions);
+	return projectWorkspaceProposalRepairSuccessorProposalIntakePreview(intent, {
+		...inlineOptions,
+		...options,
+		request: intentOrRequest,
+		currentStatus: isRepairReviewStatusMaterial(optionsOrStatus)
+			? optionsOrStatus
+			: (options.currentStatus ?? inlineOptions.currentStatus),
+		expectedCurrentState:
+			options.expectedCurrentState ??
+			inlineOptions.expectedCurrentState ??
+			(isRepairActionIntentMaterial(intent) ? intent.expectedCurrentState : undefined),
+	});
+}
+
+export function validateWorkspaceProposalRepairActionDisplayPolicyAdvisory(
+	advisory: WorkspaceProposalRepairActionDisplayPolicyAdvisory | unknown,
+	options: WorkspaceProposalRepairActionDisplayPolicyAdvisoryValidationOptions = {},
+): WorkspaceProposalRepairActionDisplayPolicyAdvisoryValidationResult {
+	const issues: WorkspaceProposalRecordedIssue[] = [];
+	const record = isRecord(advisory) ? advisory : {};
+	const safeAudit = safeWorkspaceProposalAudit(record.audit ?? options.audit);
+	const boundarySafeAudit =
+		safeAudit === undefined || !workspaceProposalBoundarySourceRefsAreSafe(safeAudit.sourceRefs)
+			? undefined
+			: safeAudit;
+	const sourceRefs = repairActionSourceRefs([
+		...(Array.isArray(record.sourceRefs) ? (record.sourceRefs as SourceRef[]) : []),
+		...(options.sourceRefs ?? []),
+		...(boundarySafeAudit?.sourceRefs ?? []),
+	]);
+	if (!isRepairActionDisplayPolicyAdvisoryMaterial(advisory)) {
+		issues.push(
+			repairActionIntentIssue(
+				"malformed-repair-action-display-policy-advisory",
+				"Repair action display policy advisory requires typed display-only data material.",
+				record,
+				options.request,
+			),
+		);
+	} else {
+		for (const [label, value] of [
+			["repairActionDisplayPolicyAdvisory", advisory],
+			["repairActionDisplayPolicyAdvisoryOptions", options],
+		] as const) {
+			for (const entry of workspaceProposalDataOnlyIssues(value, label)) {
+				issues.push(
+					repairActionIssueFromDataOnly(
+						entry,
+						repairActionIssueIntentFallback(advisory),
+						options.request,
+					),
+				);
+			}
+		}
+		if (repairActionAdvisoryHasPermissionProofMaterial(advisory)) {
+			issues.push(
+				repairActionIntentIssue(
+					"forbidden-repair-action-permission-proof-vocabulary",
+					"Repair action display policy advisory must not use permission-proof vocabulary.",
+					advisory,
+					options.request,
+				),
+			);
+		}
+		if (
+			!workspaceProposalBoundarySourceRefsAreSafe(advisory.policyEvidenceRefs) ||
+			!workspaceProposalBoundarySourceRefsAreSafe(advisory.capabilityEvidenceRefs) ||
+			!workspaceProposalBoundarySourceRefsAreSafe(advisory.sourceRefs) ||
+			(advisory.audit !== undefined &&
+				!workspaceProposalBoundarySourceRefsAreSafe(advisory.audit.sourceRefs))
+		) {
+			issues.push(
+				repairActionIntentIssue(
+					"forbidden-runtime-material",
+					"Repair action display policy advisory refs must not carry runtime/provider/storage/query/client/file/network material.",
+					advisory,
+					options.request,
+				),
+			);
+		}
+		if (
+			isRecord(advisory.metadata) &&
+			workspaceProposalBoundaryMetadataSize(advisory.metadata) >
+				workspaceProposalRepairAdvisoryMetadataMaxBytes
+		) {
+			issues.push(
+				repairActionIntentIssue(
+					"malformed-metadata",
+					"Repair action display policy advisory metadata exceeds the bounded display limit.",
+					advisory,
+					options.request,
+				),
+			);
+		}
+		if (
+			options.descriptor !== undefined &&
+			(advisory.descriptorId !== options.descriptor.descriptorId ||
+				advisory.repairRequestId !== options.descriptor.repairRequestId ||
+				advisory.actionKind !== options.descriptor.actionKind ||
+				!repairActionCoordinatesMatchDescriptor(advisory, options.descriptor))
+		) {
+			issues.push(
+				repairActionIntentIssue(
+					"repair-action-advisory-coordinate-mismatch",
+					"Repair action display policy advisory must match descriptor coordinates.",
+					advisory,
+					options.request,
+				),
+			);
+		}
+		if (
+			options.request !== undefined &&
+			(advisory.repairRequestId !== options.request.repairRequestId ||
+				!repairReviewCoordinatesMatch(options.request, advisory))
+		) {
+			issues.push(
+				repairActionIntentIssue(
+					"repair-action-advisory-coordinate-mismatch",
+					"Repair action display policy advisory must match repair-review request coordinates.",
+					advisory,
+					options.request,
+				),
+			);
+		}
+	}
+	const accepted = isRepairActionDisplayPolicyAdvisoryMaterial(advisory) && issues.length === 0;
+	return {
+		kind: "workspace-proposal-repair-action-display-policy-advisory-validation-result",
+		status: accepted ? "accepted" : "blocked",
+		...(stringField(record.descriptorId) === undefined
+			? {}
+			: { descriptorId: stringField(record.descriptorId) }),
+		...(stringField(record.repairRequestId) === undefined
+			? {}
+			: { repairRequestId: stringField(record.repairRequestId) }),
+		...(repairActionKinds.includes(record.actionKind as WorkspaceProposalRepairActionKind)
+			? { actionKind: record.actionKind as WorkspaceProposalRepairActionKind }
+			: {}),
+		...(stringField(record.applicationId) === undefined
+			? {}
+			: { applicationId: stringField(record.applicationId) }),
+		...(stringField(record.proposalId) === undefined
+			? {}
+			: { proposalId: stringField(record.proposalId) }),
+		...(stringField(record.decisionId) === undefined
+			? {}
+			: { decisionId: stringField(record.decisionId) }),
+		...(stringField(record.idempotencyKey) === undefined
+			? {}
+			: { idempotencyKey: stringField(record.idempotencyKey) }),
+		...(stringField(record.proposalFamily) === undefined
+			? {}
+			: { proposalFamily: stringField(record.proposalFamily) as WorkspaceProposalFamily }),
+		issues: dedupeRepairActionIssues(issues),
+		sourceRefs,
+		...(boundarySafeAudit === undefined ? {} : { audit: boundarySafeAudit }),
+		...(accepted ? { advisory: immutableClone(advisory) } : {}),
+	};
+}
+
+export function projectWorkspaceProposalRepairActionDisplayPolicyAdvisory(
+	descriptor: WorkspaceProposalRepairActionDescriptor,
+	request: WorkspaceProposalRepairReviewRequest,
+	options: Omit<
+		WorkspaceProposalRepairActionDisplayPolicyAdvisoryProjectorOptions,
+		"name" | "descriptors" | "requests"
+	> = {},
+): WorkspaceProposalRepairActionDisplayPolicyAdvisory {
+	const policyEvidenceRefs = safeAdvisorySourceRefs(options.policyEvidenceRefs);
+	const capabilityEvidenceRefs = safeAdvisorySourceRefs(options.capabilityEvidenceRefs);
+	const advisoryIssues = safeAdvisoryIssues(options.advisoryIssues);
+	const displayCode = safeAdvisoryText(options.displayCode);
+	const displayMessage = safeAdvisoryText(options.displayMessage);
+	const sourceRefs = safeAdvisorySourceRefs(options.sourceRefs);
+	const audit = safeAdvisoryAudit(options.audit);
+	const metadata = safeAdvisoryMetadata(options.metadata);
+	return {
+		kind: "workspace-proposal-repair-action-display-policy-advisory",
+		authority: "display-only-advisory",
+		descriptorId: descriptor.descriptorId,
+		repairRequestId: request.repairRequestId,
+		actionKind: descriptor.actionKind,
+		applicationId: request.applicationId,
+		proposalId: request.proposalId,
+		decisionId: request.decisionId,
+		idempotencyKey: request.idempotencyKey,
+		proposalFamily: request.proposalFamily,
+		displayAssessment: options.displayAssessment ?? "not-evaluated",
+		...(policyEvidenceRefs.length === 0 ? {} : { policyEvidenceRefs }),
+		...(capabilityEvidenceRefs.length === 0 ? {} : { capabilityEvidenceRefs }),
+		...(advisoryIssues.length === 0 ? {} : { advisoryIssues }),
+		...(displayCode === undefined ? {} : { displayCode }),
+		...(displayMessage === undefined ? {} : { displayMessage }),
+		sourceRefs: repairActionSourceRefs([
+			...descriptor.sourceRefs,
+			...request.sourceRefs,
+			...sourceRefs,
+			...(audit?.sourceRefs ?? []),
+		]),
+		...(audit === undefined ? {} : { audit }),
+		...(metadata === undefined ? {} : { metadata }),
+	};
+}
+
+export function workspaceProposalRepairActionDisplayPolicyAdvisoryProjector(
+	graph: Graph,
+	opts: WorkspaceProposalRepairActionDisplayPolicyAdvisoryProjectorOptions,
+): WorkspaceProposalRepairActionDisplayPolicyAdvisoryProjectorBundle {
+	const name = opts.name ?? "workspaceProposalRepairActionDisplayPolicyAdvisory";
+	const deps =
+		opts.releases === undefined
+			? [opts.descriptors, opts.requests]
+			: [opts.descriptors, opts.requests, opts.releases];
+	const runtime = graph.node<
+		| {
+				readonly kind: "repair-action-display-policy-advisory";
+				readonly value: WorkspaceProposalRepairActionDisplayPolicyAdvisory;
+		  }
+		| undefined
+	>(
+		deps,
+		(ctx) => {
+			const state = ctx.state.get<{
+				readonly descriptors: Map<string, WorkspaceProposalRepairActionDescriptor>;
+				readonly requests: Map<string, WorkspaceProposalRepairReviewRequest>;
+				readonly emittedAdvisories: Map<string, string>;
+			}>() ?? {
+				descriptors: new Map(),
+				requests: new Map(),
+				emittedAdvisories: new Map(),
+			};
+			for (const raw of depBatch(ctx, 0) ?? []) {
+				const descriptor = raw as WorkspaceProposalRepairActionDescriptor;
+				state.descriptors.set(descriptor.descriptorId, descriptor);
+			}
+			for (const raw of depBatch(ctx, 1) ?? []) {
+				const request = raw as WorkspaceProposalRepairReviewRequest;
+				state.requests.set(request.repairRequestId, request);
+			}
+			if (opts.releases !== undefined) {
+				for (const raw of depBatch(ctx, 2) ?? []) {
+					pruneRepairActionAdvisoryRelease(state, raw);
+				}
+			}
+			for (const descriptor of state.descriptors.values()) {
+				const request = state.requests.get(descriptor.repairRequestId);
+				if (request === undefined || !repairReviewCoordinatesMatch(request, descriptor)) continue;
+				if (
+					repairActionAdvisoryHasPermissionProofMaterial({
+						policyEvidenceRefs: opts.policyEvidenceRefs,
+						capabilityEvidenceRefs: opts.capabilityEvidenceRefs,
+						advisoryIssues: opts.advisoryIssues,
+						displayCode: opts.displayCode,
+						displayMessage: opts.displayMessage,
+						sourceRefs: opts.sourceRefs,
+						audit: opts.audit,
+						metadata: opts.metadata,
+					})
+				) {
+					continue;
+				}
+				const advisory = projectWorkspaceProposalRepairActionDisplayPolicyAdvisory(
+					descriptor,
+					request,
+					{
+						displayAssessment: opts.displayAssessment,
+						policyEvidenceRefs: opts.policyEvidenceRefs,
+						capabilityEvidenceRefs: opts.capabilityEvidenceRefs,
+						advisoryIssues: opts.advisoryIssues,
+						displayCode: opts.displayCode,
+						displayMessage: opts.displayMessage,
+						sourceRefs: opts.sourceRefs,
+						audit: opts.audit,
+						metadata: opts.metadata,
+					},
+				);
+				const validation = validateWorkspaceProposalRepairActionDisplayPolicyAdvisory(advisory, {
+					descriptor,
+					request,
+				});
+				if (validation.status !== "accepted" || validation.advisory === undefined) continue;
+				const signature = stableStringify(advisory);
+				const key = stableStringify({
+					descriptorId: advisory.descriptorId,
+					repairRequestId: advisory.repairRequestId,
+					actionKind: advisory.actionKind,
+				});
+				if (state.emittedAdvisories.get(key) === signature) continue;
+				state.emittedAdvisories.set(key, signature);
+				ctx.down([["DATA", { kind: "repair-action-display-policy-advisory", value: advisory }]]);
+			}
+			ctx.state.set(state);
+		},
+		runtimeOptions(name, "workspaceProposalRepairActionDisplayPolicyAdvisoryProjector"),
+	);
+	return {
+		advisories: project(graph, runtime, `${name}/advisories`, `${name}Advisories`, (fact) =>
+			fact?.kind === "repair-action-display-policy-advisory" ? fact.value : undefined,
+		),
+	};
+}
+
+export function prepareWorkspaceProposalRepairSuccessorProposalReadyRequest<TDraft = unknown>(
+	preview: WorkspaceProposalRepairSuccessorProposalIntakePreview | unknown,
+	input: WorkspaceProposalRepairSuccessorProposalReadyRequestPreparationInput<TDraft> | unknown,
+): WorkspaceProposalRepairSuccessorProposalReadyRequestPreparationResult<TDraft> {
+	const issues: WorkspaceProposalRecordedIssue[] = [];
+	const previewRecord = isRecord(preview) ? preview : {};
+	const inputRecord = isRecord(input) ? input : {};
+	const validationRecord = isRecord(inputRecord.intentValidation)
+		? inputRecord.intentValidation
+		: {};
+	const validationAudit = safeWorkspaceProposalAudit(validationRecord.audit);
+	const boundarySafeValidationAudit =
+		validationAudit === undefined ||
+		!workspaceProposalBoundarySourceRefsAreSafe(validationAudit.sourceRefs)
+			? undefined
+			: validationAudit;
+	const safeAudit = safeWorkspaceProposalAudit(inputRecord.audit);
+	const boundarySafeAudit =
+		safeAudit === undefined || !workspaceProposalBoundarySourceRefsAreSafe(safeAudit.sourceRefs)
+			? undefined
+			: safeAudit;
+	const sourceRefs = repairActionSourceRefs([
+		...(Array.isArray(previewRecord.sourceRefs) ? (previewRecord.sourceRefs as SourceRef[]) : []),
+		...(Array.isArray(inputRecord.sourceRefs) ? (inputRecord.sourceRefs as SourceRef[]) : []),
+		...(Array.isArray(inputRecord.finalDraftSourceRefs)
+			? (inputRecord.finalDraftSourceRefs as SourceRef[])
+			: []),
+		...(Array.isArray(validationRecord.sourceRefs)
+			? (validationRecord.sourceRefs as SourceRef[])
+			: []),
+		...(boundarySafeValidationAudit?.sourceRefs ?? []),
+		...(boundarySafeAudit?.sourceRefs ?? []),
+	]);
+	if (!isRepairSuccessorPreviewMaterial(preview)) {
+		issues.push(
+			repairActionIntentIssue(
+				"malformed-repair-successor-preview",
+				"Repair successor ready-request preparation requires a typed successor preview.",
+				preview,
+				undefined,
+			),
+		);
+	}
+	if (!isRepairSuccessorReadyRequestPreparationInput(input)) {
+		issues.push(
+			repairActionIntentIssue(
+				"malformed-repair-successor-preparation-input",
+				"Repair successor ready-request preparation requires explicit typed preparation input.",
+				input,
+				undefined,
+			),
+		);
+	}
+	for (const [label, value] of [
+		["repairSuccessorPreview", preview],
+		["repairSuccessorReadyRequestPreparationInput", input],
+	] as const) {
+		for (const entry of workspaceProposalDataOnlyIssues(value, label)) {
+			issues.push(
+				repairActionIssueFromDataOnly(
+					entry,
+					repairActionIssueIntentFallback(input),
+					isRepairSuccessorReadyRequestPreparationInput(input) ? input.request : undefined,
+				),
+			);
+		}
+	}
+	if (isRepairSuccessorPreviewMaterial(preview) && preview.status !== "proposal-context-ready") {
+		issues.push(
+			repairActionIntentIssue(
+				"repair-successor-preview-not-ready",
+				"Repair successor preview must be proposal-context-ready before ready-request preparation.",
+				preview,
+				undefined,
+			),
+		);
+	}
+	if (
+		isRepairSuccessorPreviewMaterial(preview) &&
+		isRepairSuccessorReadyRequestPreparationInput(input)
+	) {
+		if (
+			input.previewId !== preview.previewId ||
+			input.intent.intentId !== preview.intentId ||
+			input.descriptor.descriptorId !== preview.descriptorId ||
+			input.request.repairRequestId !== preview.repairRequestId ||
+			input.intent.actionKind !== "open-successor-proposal-flow" ||
+			input.descriptor.actionKind !== "open-successor-proposal-flow" ||
+			!repairActionPreviewCoordinatesMatchInput(preview, input) ||
+			!repairActionIntentValidationMatchesPreparationInput(input.intentValidation, input)
+		) {
+			issues.push(
+				repairActionIntentIssue(
+					"repair-successor-preparation-coordinate-mismatch",
+					"Repair successor preparation input must match preview, intent, descriptor, and repair request coordinates.",
+					input.intent,
+					input.request,
+				),
+			);
+		}
+		if (input.intentValidation.status !== "accepted" || input.intentValidation.issues.length > 0) {
+			issues.push(
+				repairActionIntentIssue(
+					"blocked-repair-action-intent-validation",
+					"Repair successor preparation requires an accepted repair action intent validation result.",
+					input.intent,
+					input.request,
+				),
+			);
+		}
+		if (!workspaceProposalTargetRefsAreValid(input.targetRefs)) {
+			issues.push(
+				repairActionIntentIssue(
+					"malformed-repair-successor-preparation-input",
+					"Repair successor ready-request preparation requires bounded target refs.",
+					input.intent,
+					input.request,
+				),
+			);
+		}
+		if (input.draft === undefined && !nonEmptySourceRefs(input.draftRefs)) {
+			issues.push(
+				repairActionIntentIssue(
+					"missing-draft-material",
+					"Repair successor ready-request preparation requires final draft material or draft refs.",
+					input.intent,
+					input.request,
+				),
+			);
+		}
+		if (
+			(input.draft !== undefined || input.draftRefs !== undefined) &&
+			!nonEmptySourceRefs(input.finalDraftSourceRefs)
+		) {
+			issues.push(
+				repairActionIntentIssue(
+					"missing-final-draft-source",
+					"Repair successor final draft material requires explicit final draft source refs.",
+					input.intent,
+					input.request,
+				),
+			);
+		}
+		if (repairSuccessorPreparationMetadataHasTruthMaterial(input.metadata)) {
+			issues.push(
+				repairActionIntentIssue(
+					"malformed-repair-successor-preparation-input",
+					"Repair successor ready-request preparation metadata must not carry admission/application/recorded truth material.",
+					input.intent,
+					input.request,
+				),
+			);
+		}
+		if (boundarySafeAudit === undefined) {
+			issues.push(
+				repairActionIntentIssue(
+					"missing-audit",
+					"Repair successor ready-request preparation requires data-only audit material.",
+					input.intent,
+					input.request,
+				),
+			);
+		}
+	}
+	const cleanIssues = dedupeRepairActionIssues(issues);
+	const blockedPreviewId =
+		stringField(previewRecord.previewId) ?? stringField(inputRecord.previewId);
+	const blockedRepairRequestId =
+		stringField(previewRecord.repairRequestId) ?? stringField(inputRecord.repairRequestId);
+	if (
+		cleanIssues.length > 0 ||
+		!isRepairSuccessorPreviewMaterial(preview) ||
+		!isRepairSuccessorReadyRequestPreparationInput(input) ||
+		boundarySafeAudit === undefined
+	) {
+		return {
+			kind: "workspace-proposal-repair-successor-proposal-ready-request-preparation-result",
+			status: "blocked",
+			...(stringField(inputRecord.preparationId) === undefined
+				? {}
+				: { preparationId: stringField(inputRecord.preparationId) }),
+			...(blockedPreviewId === undefined ? {} : { previewId: blockedPreviewId }),
+			...(blockedRepairRequestId === undefined ? {} : { repairRequestId: blockedRepairRequestId }),
+			...(stringField(previewRecord.descriptorId) === undefined
+				? {}
+				: { descriptorId: stringField(previewRecord.descriptorId) }),
+			...(stringField(previewRecord.intentId) === undefined
+				? {}
+				: { intentId: stringField(previewRecord.intentId) }),
+			issues: cleanIssues,
+			sourceRefs,
+			...(boundarySafeAudit === undefined ? {} : { audit: boundarySafeAudit }),
+		};
+	}
+	const readyRequest = immutableClone<WorkspaceProposalReadyRequest<TDraft>>({
+		kind: "workspace-proposal-ready-request",
+		proposalId: input.successorProposalId,
+		intakeRequestId: input.intakeRequestId,
+		idempotencyKey: input.successorIdempotencyKey,
+		workspaceId: input.workspaceId,
+		proposalFamily: input.successorProposalFamily,
+		loweringKind: input.successorLoweringKind,
+		...(input.draft === undefined ? {} : { draft: immutableClone(input.draft) as TDraft }),
+		...(input.draftRefs === undefined ? {} : { draftRefs: immutableClone(input.draftRefs) }),
+		targetRefs: immutableClone(input.targetRefs),
+		actorRef: immutableClone(input.actorRef),
+		capabilityRefs: immutableClone(input.capabilityRefs),
+		policyRefs: immutableClone(input.policyRefs),
+		projectionBundleRefs: immutableClone(input.projectionBundleRefs),
+		sourceRefs,
+		audit: boundarySafeAudit,
+		metadata: immutableClone({
+			...(input.metadata ?? {}),
+			repairSuccessorPreviewId: preview.previewId,
+			repairActionIntentId: input.intent.intentId,
+			repairActionDescriptorId: input.descriptor.descriptorId,
+			repairRequestId: input.request.repairRequestId,
+			repairActionKind: input.intent.actionKind,
+			predecessorProposalId: preview.proposalId,
+			predecessorDecisionId: preview.decisionId,
+			predecessorIdempotencyKey: preview.idempotencyKey,
+			predecessorProposalFamily: preview.proposalFamily,
+		}),
+	});
+	return {
+		kind: "workspace-proposal-repair-successor-proposal-ready-request-preparation-result",
+		status: "prepared",
+		preparationId: input.preparationId,
+		previewId: preview.previewId,
+		repairRequestId: preview.repairRequestId,
+		descriptorId: preview.descriptorId,
+		intentId: preview.intentId,
+		readyRequest,
+		issues: [],
+		sourceRefs,
+		audit: boundarySafeAudit,
+	};
+}
+
+export function workspaceProposalRepairActionIntentProjector(
+	graph: Graph,
+	opts: WorkspaceProposalRepairActionIntentProjectorOptions,
+): WorkspaceProposalRepairActionIntentProjectorBundle {
+	const name = opts.name ?? "workspaceProposalRepairActionIntent";
+	const deps = repairActionIntentProjectorDeps(opts);
+	const runtime = graph.node<
+		| {
+				readonly kind: "repair-action-intent-validation-result";
+				readonly value: WorkspaceProposalRepairActionIntentValidationResult;
+		  }
+		| undefined
+	>(
+		deps,
+		(ctx) => {
+			const state = repairActionIntentGraphState(ctx);
+			ingestRepairActionIntentGraphFacts(ctx, state, opts.statuses !== undefined);
+			if (opts.releases !== undefined) {
+				for (const raw of depBatch(ctx, repairActionReleaseDepIndex(opts.statuses !== undefined)) ??
+					[]) {
+					pruneRepairActionIntentRelease(state, raw);
+				}
+			}
+			for (const entry of state.intents.values()) {
+				if (entry.conflict) {
+					const result = conflictingRepairActionIntentValidationResult(entry.intent);
+					const signature = stableStringify(result);
+					if (state.emittedResults.get(entry.intent.intentId) === signature) continue;
+					state.emittedResults.set(entry.intent.intentId, signature);
+					ctx.down([["DATA", { kind: "repair-action-intent-validation-result", value: result }]]);
+					continue;
+				}
+				const intent = entry.intent;
+				const request = state.requests.get(intent.repairRequestId);
+				const result = validateWorkspaceProposalRepairActionIntent(intent, {
+					descriptor: state.descriptors.get(intent.descriptorId),
+					request,
+					currentStatus:
+						request === undefined
+							? undefined
+							: state.statuses.get(repairReviewStatusProjectionKeyFromRequest(request)),
+					expectedCurrentState: intent.expectedCurrentState,
+					capabilityRefs: opts.capabilityRefs,
+					policyRefs: opts.policyRefs,
+					policyStatus: opts.policyStatus,
+				});
+				const signature = stableStringify(result);
+				if (state.emittedResults.get(intent.intentId) === signature) continue;
+				state.emittedResults.set(intent.intentId, signature);
+				ctx.down([["DATA", { kind: "repair-action-intent-validation-result", value: result }]]);
+			}
+			ctx.state.set(state);
+		},
+		runtimeOptions(name, "workspaceProposalRepairActionIntentProjector"),
+	);
+	return {
+		results: project(graph, runtime, `${name}/results`, `${name}Results`, (fact) =>
+			fact?.kind === "repair-action-intent-validation-result" ? fact.value : undefined,
+		),
+	};
+}
+
+export function workspaceProposalRepairSuccessorProposalIntakePreviewProjector(
+	graph: Graph,
+	opts: WorkspaceProposalRepairSuccessorProposalIntakePreviewProjectorOptions,
+): WorkspaceProposalRepairSuccessorProposalIntakePreviewProjectorBundle {
+	const name = opts.name ?? "workspaceProposalRepairSuccessorProposalIntakePreview";
+	const deps = repairActionIntentProjectorDeps(opts);
+	const runtime = graph.node<
+		| {
+				readonly kind: "successor-proposal-intake-preview";
+				readonly value: WorkspaceProposalRepairSuccessorProposalIntakePreview;
+		  }
+		| undefined
+	>(
+		deps,
+		(ctx) => {
+			const state = repairActionIntentGraphState(ctx);
+			ingestRepairActionIntentGraphFacts(ctx, state, opts.statuses !== undefined);
+			if (opts.releases !== undefined) {
+				for (const raw of depBatch(ctx, repairActionReleaseDepIndex(opts.statuses !== undefined)) ??
+					[]) {
+					pruneRepairSuccessorPreviewRelease(state, raw);
+				}
+			}
+			for (const entry of state.intents.values()) {
+				if (entry.intent.actionKind !== "open-successor-proposal-flow") continue;
+				const intent = entry.intent;
+				if (entry.conflict) {
+					const preview = blockedRepairSuccessorPreview(
+						intent,
+						[conflictingRepairActionIntentIssue(intent)],
+						{},
+					);
+					if (state.releasedPreviews.has(preview.previewId)) continue;
+					const signature = stableStringify(preview);
+					if (state.emittedPreviews.get(preview.previewId) === signature) continue;
+					state.emittedPreviews.set(preview.previewId, signature);
+					ctx.down([["DATA", { kind: "successor-proposal-intake-preview", value: preview }]]);
+					continue;
+				}
+				const request = state.requests.get(intent.repairRequestId);
+				const preview = projectWorkspaceProposalRepairSuccessorProposalIntakePreview(intent, {
+					descriptor: state.descriptors.get(intent.descriptorId),
+					request,
+					currentStatus:
+						request === undefined
+							? undefined
+							: state.statuses.get(repairReviewStatusProjectionKeyFromRequest(request)),
+					expectedCurrentState: intent.expectedCurrentState,
+					capabilityRefs: opts.capabilityRefs,
+					policyRefs: opts.policyRefs,
+					policyStatus: opts.policyStatus,
+					maxSuggestedDraftPatchBytes: opts.maxSuggestedDraftPatchBytes,
+				});
+				if (state.releasedPreviews.has(preview.previewId)) continue;
+				const signature = stableStringify(preview);
+				if (state.emittedPreviews.get(preview.previewId) === signature) continue;
+				state.emittedPreviews.set(preview.previewId, signature);
+				ctx.down([["DATA", { kind: "successor-proposal-intake-preview", value: preview }]]);
+			}
+			ctx.state.set(state);
+		},
+		runtimeOptions(name, "workspaceProposalRepairSuccessorProposalIntakePreviewProjector"),
+	);
+	return {
+		previews: project(graph, runtime, `${name}/previews`, `${name}Previews`, (fact) =>
+			fact?.kind === "successor-proposal-intake-preview" ? fact.value : undefined,
+		),
+	};
+}
+
+export function workspaceProposalRepairSuccessorProposalReadyRequestPreparationProjector<
+	TDraft = unknown,
+>(
+	graph: Graph,
+	opts: WorkspaceProposalRepairSuccessorProposalReadyRequestPreparationProjectorOptions<TDraft>,
+): WorkspaceProposalRepairSuccessorProposalReadyRequestPreparationProjectorBundle<TDraft> {
+	const name = opts.name ?? "workspaceProposalRepairSuccessorProposalReadyRequestPreparation";
+	const deps =
+		opts.releases === undefined
+			? [opts.previews, opts.preparationInputs]
+			: [opts.previews, opts.preparationInputs, opts.releases];
+	const runtime = graph.node<
+		| {
+				readonly kind: "successor-ready-request-preparation-result";
+				readonly value: WorkspaceProposalRepairSuccessorProposalReadyRequestPreparationResult<TDraft>;
+		  }
+		| {
+				readonly kind: "successor-ready-request";
+				readonly value: WorkspaceProposalReadyRequest<TDraft>;
+		  }
+		| {
+				readonly kind: "issue";
+				readonly value: WorkspaceProposalRecordedIssue;
+		  }
+		| undefined
+	>(
+		deps,
+		(ctx) => {
+			const state = repairSuccessorPreparationGraphState<TDraft>(ctx);
+			for (const raw of depBatch(ctx, 0) ?? []) {
+				const preview = raw as WorkspaceProposalRepairSuccessorProposalIntakePreview;
+				state.previews.set(preview.previewId, preview);
+			}
+			for (const raw of depBatch(ctx, 1) ?? []) {
+				const input =
+					raw as WorkspaceProposalRepairSuccessorProposalReadyRequestPreparationInput<TDraft>;
+				state.inputs.set(input.preparationId, input);
+			}
+			if (opts.releases !== undefined) {
+				for (const raw of depBatch(ctx, 2) ?? []) {
+					pruneRepairSuccessorPreparationRelease(state, raw);
+				}
+			}
+			for (const input of state.inputs.values()) {
+				const preview = state.previews.get(input.previewId);
+				let result: WorkspaceProposalRepairSuccessorProposalReadyRequestPreparationResult<TDraft> =
+					prepareWorkspaceProposalRepairSuccessorProposalReadyRequest<TDraft>(preview, input);
+				const preparedReadyRequest = state.preparedReadyRequests.get(input.preparationId);
+				if (preparedReadyRequest !== undefined) {
+					const resultReadySignature =
+						result.readyRequest === undefined ? undefined : stableStringify(result.readyRequest);
+					if (resultReadySignature !== preparedReadyRequest.signature) {
+						const issue = repairActionIntentIssue(
+							"repair-successor-preparation-already-prepared",
+							"Repair successor ready-request preparation is immutable after its first prepared ready request.",
+							input.intent,
+							input.request,
+						);
+						const { readyRequest: _readyRequest, ...blockedResult } = result;
+						result = {
+							...blockedResult,
+							status: "blocked",
+							issues: dedupeRepairActionIssues([...result.issues, issue]),
+						};
+					} else if (preparedReadyRequest.compacted) {
+						const { readyRequest: _readyRequest, ...preparedResult } = result;
+						result = preparedResult;
+					}
+				} else if (result.readyRequest !== undefined) {
+					state.preparedReadyRequests.set(input.preparationId, {
+						signature: stableStringify(result.readyRequest),
+						compacted: false,
+						value: immutableClone(result.readyRequest) as WorkspaceProposalReadyRequest<TDraft>,
+					});
+				}
+				const signature = stableStringify(result);
+				if (state.emittedResults.get(input.preparationId) === signature) continue;
+				state.emittedResults.set(input.preparationId, signature);
+				ctx.down([["DATA", { kind: "successor-ready-request-preparation-result", value: result }]]);
+				for (const issue of result.issues) {
+					ctx.down([["DATA", { kind: "issue", value: issue }]]);
+				}
+				if (result.readyRequest !== undefined) {
+					ctx.down([["DATA", { kind: "successor-ready-request", value: result.readyRequest }]]);
+				}
+			}
+			ctx.state.set(state);
+		},
+		runtimeOptions(
+			name,
+			"workspaceProposalRepairSuccessorProposalReadyRequestPreparationProjector",
+		),
+	);
+	return {
+		results: project(graph, runtime, `${name}/results`, `${name}Results`, (fact) =>
+			fact?.kind === "successor-ready-request-preparation-result" ? fact.value : undefined,
+		),
+		readyRequests: project(
+			graph,
+			runtime,
+			`${name}/readyRequests`,
+			`${name}ReadyRequests`,
+			(fact) => (fact?.kind === "successor-ready-request" ? fact.value : undefined),
+		),
+		issues: project(graph, runtime, `${name}/issues`, `${name}Issues`, (fact) =>
+			fact?.kind === "issue" ? fact.value : undefined,
+		),
+	};
+}
+
+interface RepairReviewStatusProjectionContext {
+	readonly decisions: readonly WorkspaceProposalRepairReviewDecision[];
+	readonly applicationStatuses: readonly WorkspaceProposalApplicationStatus[];
+	readonly applicationRecorded: readonly WorkspaceProposalApplicationRecorded[];
+	readonly outcomeStatuses: readonly WorkspaceProposalFamilyOutcomeRecordStatus[];
+	readonly outcomeIndex: readonly WorkspaceProposalFamilyOutcomeIndexEntry[];
+}
+
+interface RepairReviewDurableProof {
+	readonly state: "resolved" | "superseded";
+	readonly code: string;
+	readonly proofKind: Exclude<WorkspaceProposalRepairReviewProofKind, "human-decision">;
+	readonly proofRefs: readonly SourceRef[];
+	readonly sourceRefs: readonly SourceRef[];
+}
+
+function projectWorkspaceProposalRepairReviewStatus(
+	request: WorkspaceProposalRepairReviewRequest,
+	context: RepairReviewStatusProjectionContext,
+): WorkspaceProposalRepairReviewStatus {
+	const decisions = dedupeRepairReviewDecisions(
+		context.decisions.filter((decision) => repairReviewDecisionMatchesRequest(decision, request)),
+	);
+	const terminalDecisions = decisions.filter((decision) => decision.intent !== "acknowledged");
+	const activeTerminalDecisions = terminalDecisions.filter(
+		(decision) =>
+			!terminalDecisions.some((candidate) => repairReviewDecisionSupersedes(candidate, decision)),
+	);
+	if (activeTerminalDecisions.length > 1) {
+		const issue = repairReviewStatusIssue(
+			request,
+			"conflicting-repair-review-decisions",
+			"Workspace proposal repair review decisions conflict",
+			activeTerminalDecisions,
+		);
+		return repairReviewStatus(request, "conflict", {
+			code: issue.code,
+			decisions,
+			conflicts: activeTerminalDecisions,
+			issues: [issue],
+			sourceRefs: uniqueRefs([
+				...request.sourceRefs,
+				...activeTerminalDecisions.flatMap((decision) => decision.sourceRefs ?? []),
+			]),
+		});
+	}
+	const terminalDecision = activeTerminalDecisions[0];
+	if (terminalDecision !== undefined) {
+		return repairReviewStatus(request, terminalDecision.intent, {
+			code: terminalDecision.code ?? terminalDecision.intent,
+			proofKind: "human-decision",
+			proofRefs: [repairReviewDecisionSourceRef(terminalDecision)],
+			decisions,
+			sourceRefs: uniqueRefs([...request.sourceRefs, ...(terminalDecision.sourceRefs ?? [])]),
+			audit: terminalDecision.audit ?? request.audit,
+			metadata: terminalDecision.metadata,
+		});
+	}
+	const durableProof = repairReviewDurableProof(request, context);
+	if (durableProof !== undefined) {
+		return repairReviewStatus(request, durableProof.state, {
+			code: durableProof.code,
+			proofKind: durableProof.proofKind,
+			proofRefs: durableProof.proofRefs,
+			decisions,
+			sourceRefs: uniqueRefs([...request.sourceRefs, ...durableProof.sourceRefs]),
+		});
+	}
+	const acknowledgedDecision = decisions.find((decision) => decision.intent === "acknowledged");
+	if (acknowledgedDecision !== undefined) {
+		return repairReviewStatus(request, "acknowledged", {
+			code: acknowledgedDecision.code ?? "acknowledged",
+			proofKind: "human-decision",
+			proofRefs: [repairReviewDecisionSourceRef(acknowledgedDecision)],
+			decisions,
+			sourceRefs: uniqueRefs([...request.sourceRefs, ...(acknowledgedDecision.sourceRefs ?? [])]),
+			audit: acknowledgedDecision.audit ?? request.audit,
+			metadata: acknowledgedDecision.metadata,
+		});
+	}
+	return repairReviewStatus(request, "open", {
+		code: "open",
+		decisions,
+		sourceRefs: request.sourceRefs,
+		audit: request.audit,
+	});
+}
+
+function repairReviewStatus(
+	request: WorkspaceProposalRepairReviewRequest,
+	state: WorkspaceProposalRepairReviewLifecycleState,
+	options: {
+		readonly code?: string;
+		readonly proofKind?: WorkspaceProposalRepairReviewProofKind;
+		readonly proofRefs?: readonly SourceRef[];
+		readonly decisions?: readonly WorkspaceProposalRepairReviewDecision[];
+		readonly conflicts?: readonly WorkspaceProposalRepairReviewDecision[];
+		readonly issues?: readonly WorkspaceProposalRecordedIssue[];
+		readonly sourceRefs?: readonly SourceRef[];
+		readonly audit?: WorkspaceProposalAuditMaterial;
+		readonly metadata?: Record<string, unknown>;
+	} = {},
+): WorkspaceProposalRepairReviewStatus {
+	return {
+		kind: "workspace-proposal-repair-review-status",
+		repairRequestId: request.repairRequestId,
+		applicationId: request.applicationId,
+		proposalId: request.proposalId,
+		decisionId: request.decisionId,
+		idempotencyKey: request.idempotencyKey,
+		proposalFamily: request.proposalFamily,
+		state,
+		code: options.code,
+		proofKind: options.proofKind,
+		proofRefs: options.proofRefs ?? [],
+		decisions: immutableClone(options.decisions ?? []),
+		conflicts: immutableClone(options.conflicts ?? []),
+		issues: options.issues ?? [],
+		sourceRefs: uniqueRefs(options.sourceRefs ?? request.sourceRefs),
+		audit: options.audit ?? request.audit,
+		metadata: options.metadata,
+	};
+}
+
+function repairReviewDurableProof(
+	request: WorkspaceProposalRepairReviewRequest,
+	context: RepairReviewStatusProjectionContext,
+): RepairReviewDurableProof | undefined {
+	for (const status of context.outcomeStatuses) {
+		if (
+			status.state === "recorded" &&
+			status.outcomeRefs.length > 0 &&
+			repairReviewCoordinatesMatch(request, status) &&
+			repairRequestAllowsProof(
+				request,
+				"workspace-proposal-family-outcome-record-status",
+				status.outcomeId,
+			) &&
+			status.outcomeRefs.some((ref) => sameOutcomeRefCoordinates(ref, status))
+		) {
+			return {
+				state: "resolved",
+				code: status.code ?? "family-outcome-recorded",
+				proofKind: "family-outcome-status",
+				proofRefs: [
+					{ kind: "workspace-proposal-family-outcome-record-status", id: status.outcomeId },
+				],
+				sourceRefs: status.sourceRefs,
+			};
+		}
+	}
+	for (const entry of context.outcomeIndex) {
+		if (
+			entry.state === "recorded" &&
+			entry.outcomeRefs.length > 0 &&
+			repairReviewCoordinatesMatch(request, entry) &&
+			repairRequestAllowsProof(
+				request,
+				"workspace-proposal-family-outcome-index-entry",
+				entry.indexKey,
+			) &&
+			entry.outcomeRefs.some((ref) => sameOutcomeRefCoordinates(ref, entry))
+		) {
+			return {
+				state: "resolved",
+				code: "family-outcome-index-recorded",
+				proofKind: "family-outcome-index",
+				proofRefs: [{ kind: "workspace-proposal-family-outcome-index-entry", id: entry.indexKey }],
+				sourceRefs: entry.sourceRefs,
+			};
+		}
+	}
+	const applicationStatus = context.applicationStatuses.find((status) =>
+		repairReviewCoordinatesMatch(request, status),
+	);
+	const recorded = context.applicationRecorded.find(
+		(record) =>
+			applicationStatus !== undefined &&
+			applicationRecordedMatchesStatus(record, applicationStatus),
+	);
+	if (
+		recorded !== undefined &&
+		applicationStatus !== undefined &&
+		applicationRecordedMatchesStatus(recorded, applicationStatus) &&
+		repairReviewCoordinatesMatch(request, applicationStatus) &&
+		repairRequestAllowsProof(
+			request,
+			"workspace-proposal-application-status",
+			applicationStatus.applicationId,
+		) &&
+		applicationStatusResolvesRepairReview(applicationStatus)
+	) {
+		return {
+			state: "resolved",
+			code: "application-recorded",
+			proofKind: "application-recorded",
+			proofRefs: [
+				{ kind: "workspace-proposal-application-recorded", id: recorded.applicationRecordId },
+				{ kind: "workspace-proposal-application-status", id: applicationStatus.applicationId },
+			],
+			sourceRefs: uniqueRefs([...recorded.sourceRefs, ...applicationStatus.sourceRefs]),
+		};
+	}
+	if (
+		applicationStatus !== undefined &&
+		repairReviewCoordinatesMatch(request, applicationStatus) &&
+		repairRequestAllowsProof(
+			request,
+			"workspace-proposal-application-status",
+			applicationStatus.applicationId,
+		) &&
+		applicationStatusResolvesRepairReview(applicationStatus)
+	) {
+		return {
+			state: "resolved",
+			code: applicationStatus.code ?? "application-status-recorded",
+			proofKind: "application-status",
+			proofRefs: [
+				{ kind: "workspace-proposal-application-status", id: applicationStatus.applicationId },
+			],
+			sourceRefs: applicationStatus.sourceRefs,
+		};
+	}
+	return undefined;
+}
+
+function repairRequestAllowsProof(
+	request: WorkspaceProposalRepairReviewRequest,
+	kind: string,
+	id: string,
+): boolean {
+	const subjectRefs = request.subjectRefs ?? [];
+	const outcomeSubjectRefs = subjectRefs.filter(
+		(ref) =>
+			ref.kind === "workspace-proposal-family-outcome-record-status" ||
+			ref.kind === "workspace-proposal-family-outcome-index-entry",
+	);
+	return (
+		outcomeSubjectRefs.length === 0 ||
+		outcomeSubjectRefs.some((ref) => ref.kind === kind && ref.id === id)
+	);
+}
+
+function applicationStatusResolvesRepairReview(
+	status: WorkspaceProposalApplicationStatus,
+): boolean {
+	return (
+		(status.state === "applied" || status.state === "recorded") &&
+		status.emittedFactRefs.some((ref) => ref.proposalFamily === status.proposalFamily)
+	);
+}
+
+function applicationRecordedMatchesStatus(
+	recorded: WorkspaceProposalApplicationRecorded,
+	status: WorkspaceProposalApplicationStatus,
+): boolean {
+	return (
+		recorded.applicationId === status.applicationId &&
+		recorded.proposalId === status.proposalId &&
+		recorded.decisionId === status.decisionId &&
+		recorded.emittedFactRefs.length > 0 &&
+		recorded.emittedFactRefs.every((ref) =>
+			status.emittedFactRefs.some(
+				(statusRef) =>
+					statusRef.proposalFamily === ref.proposalFamily &&
+					statusRef.factKind === ref.factKind &&
+					statusRef.factId === ref.factId,
+			),
+		)
+	);
+}
+
+function repairReviewDecisionMatchesRequest(
+	decision: WorkspaceProposalRepairReviewDecision,
+	request: WorkspaceProposalRepairReviewRequest,
+): boolean {
+	return (
+		decision.kind === "workspace-proposal-repair-review-decision" &&
+		!blank(decision.reviewDecisionId) &&
+		decision.repairRequestId === request.repairRequestId &&
+		repairReviewCoordinatesMatch(request, decision) &&
+		(decision.intent === "acknowledged" ||
+			decision.intent === "resolved" ||
+			decision.intent === "withdrawn" ||
+			decision.intent === "superseded")
+	);
+}
+
+function repairReviewCoordinatesMatch(
+	request: WorkspaceProposalRepairReviewRequest,
+	material: {
+		readonly applicationId: string;
+		readonly proposalId: string;
+		readonly decisionId: string;
+		readonly idempotencyKey: string;
+		readonly proposalFamily: WorkspaceProposalFamily;
+	},
+): boolean {
+	return (
+		request.applicationId === material.applicationId &&
+		request.proposalId === material.proposalId &&
+		request.decisionId === material.decisionId &&
+		request.idempotencyKey === material.idempotencyKey &&
+		request.proposalFamily === material.proposalFamily
+	);
+}
+
+function repairReviewDecisionSupersedes(
+	candidate: WorkspaceProposalRepairReviewDecision,
+	decision: WorkspaceProposalRepairReviewDecision,
+): boolean {
+	return (candidate.supersedesRefs ?? []).some(
+		(ref) =>
+			ref.kind === "workspace-proposal-repair-review-decision" &&
+			ref.id === decision.reviewDecisionId,
+	);
+}
+
+function dedupeRepairReviewDecisions(
+	decisions: readonly WorkspaceProposalRepairReviewDecision[],
+): readonly WorkspaceProposalRepairReviewDecision[] {
+	const out = new Map<string, WorkspaceProposalRepairReviewDecision>();
+	for (const decision of decisions) out.set(decision.reviewDecisionId, decision);
+	return [...out.values()];
+}
+
+function repairReviewDecisionSourceRef(decision: WorkspaceProposalRepairReviewDecision): SourceRef {
+	return { kind: "workspace-proposal-repair-review-decision", id: decision.reviewDecisionId };
+}
+
+function repairReviewStatusIssue(
+	request: WorkspaceProposalRepairReviewRequest,
+	code: string,
+	message: string,
+	decisions: readonly WorkspaceProposalRepairReviewDecision[],
+): WorkspaceProposalRecordedIssue {
+	return {
+		kind: "issue",
+		source: "workspace-proposal",
+		severity: "error",
+		code,
+		message,
+		subjectId: request.proposalId,
+		refs: [
+			`workspace-proposal-repair-review-request:${request.repairRequestId}`,
+			...decisions.map(
+				(decision) => `workspace-proposal-repair-review-decision:${decision.reviewDecisionId}`,
+			),
+		],
+		metadata: {
+			applicationId: request.applicationId,
+			proposalId: request.proposalId,
+			decisionId: request.decisionId,
+			idempotencyKey: request.idempotencyKey,
+			proposalFamily: request.proposalFamily,
+		},
+	};
+}
+
+function repairReviewStatusSignature(status: WorkspaceProposalRepairReviewStatus): string {
+	return stableStringify({
+		state: status.state,
+		code: status.code,
+		proofKind: status.proofKind,
+		proofRefs: status.proofRefs,
+		decisions: status.decisions,
+		conflicts: status.conflicts,
+		issues: status.issues,
+		sourceRefs: status.sourceRefs,
+		audit: status.audit,
+		metadata: status.metadata,
+	});
+}
+
+const repairActionKinds = [
+	"acknowledge-review",
+	"withdraw-review",
+	"mark-human-resolved",
+	"supersede-review",
+	"open-successor-proposal-flow",
+] as const satisfies readonly WorkspaceProposalRepairActionKind[];
+
+function repairActionDescriptor(
+	request: WorkspaceProposalRepairReviewRequest,
+	status: WorkspaceProposalRepairReviewStatus | undefined,
+	actionKind: WorkspaceProposalRepairActionKind,
+	state: WorkspaceProposalRepairReviewLifecycleState,
+): WorkspaceProposalRepairActionDescriptor {
+	const disabledCode = repairActionDisabledCode(actionKind, state);
+	const repairStatusRef =
+		status === undefined
+			? undefined
+			: { kind: "workspace-proposal-repair-review-status", id: status.repairRequestId };
+	const audit = repairActionDescriptorAudit(status?.audit ?? request.audit);
+	return {
+		kind: "workspace-proposal-repair-action-descriptor",
+		descriptorId: `workspace-proposal-repair-action-descriptor:${stableStringify({
+			repairRequestId: request.repairRequestId,
+			actionKind,
+		})}`,
+		repairRequestId: request.repairRequestId,
+		repairState: state,
+		...(repairStatusRef === undefined ? {} : { repairStatusRef }),
+		actionKind,
+		enabled: disabledCode === undefined,
+		...(disabledCode === undefined ? {} : { disabledCode }),
+		applicationId: request.applicationId,
+		proposalId: request.proposalId,
+		decisionId: request.decisionId,
+		idempotencyKey: request.idempotencyKey,
+		proposalFamily: request.proposalFamily,
+		sourceRefs: repairActionDescriptorSourceRefs([
+			...request.sourceRefs,
+			...(status?.sourceRefs ?? []),
+			...(repairStatusRef === undefined ? [] : [repairStatusRef]),
+		]),
+		...(audit === undefined ? {} : { audit }),
+		metadata: {
+			repairRequestId: request.repairRequestId,
+			repairState: state,
+			route: repairActionRoute(actionKind),
+		},
+	};
+}
+
+function matchingRepairReviewStatus(
+	request: WorkspaceProposalRepairReviewRequest,
+	statuses: readonly WorkspaceProposalRepairReviewStatus[],
+): WorkspaceProposalRepairReviewStatus | undefined {
+	for (let index = statuses.length - 1; index >= 0; index -= 1) {
+		const status = statuses[index];
+		if (
+			status !== undefined &&
+			status.repairRequestId === request.repairRequestId &&
+			repairReviewCoordinatesMatch(request, status)
+		) {
+			return status;
+		}
+	}
+	return undefined;
+}
+
+function repairActionDescriptorSourceRefs(values: readonly SourceRef[]): readonly SourceRef[] {
+	return uniqueRefs(
+		values.filter(
+			(value) =>
+				isSourceRef(value) &&
+				workspaceProposalDataOnlyIssues(value, "repairActionDescriptorSourceRef").length === 0,
+		),
+	);
+}
+
+function repairActionDescriptorAudit(
+	audit: WorkspaceProposalAuditMaterial | undefined,
+): WorkspaceProposalAuditMaterial | undefined {
+	if (!isWorkspaceProposalAuditMaterial(audit)) return undefined;
+	const sourceRefs = repairActionDescriptorSourceRefs(audit.sourceRefs ?? []);
+	const { sourceRefs: _sourceRefs, ...rest } = audit;
+	return sourceRefs.length === 0 ? rest : { ...rest, sourceRefs };
+}
+
+function repairActionDisabledCode(
+	actionKind: WorkspaceProposalRepairActionKind,
+	state: WorkspaceProposalRepairReviewLifecycleState,
+): WorkspaceProposalRepairActionDescriptorDisabledCode | undefined {
+	if (state === "conflict") return "repair-review-conflict";
+	if (state === "resolved" || state === "withdrawn" || state === "superseded") {
+		return "repair-review-terminal";
+	}
+	if (state === "acknowledged" && actionKind === "acknowledge-review") {
+		return "repair-review-already-acknowledged";
+	}
+	return undefined;
+}
+
+function repairActionRoute(
+	actionKind: WorkspaceProposalRepairActionKind,
+): "repair-review-decision-intake" | "successor-proposal-intake-preview" {
+	return actionKind === "open-successor-proposal-flow"
+		? "successor-proposal-intake-preview"
+		: "repair-review-decision-intake";
+}
+
+function repairActionDecisionIntent(
+	actionKind: WorkspaceProposalRepairActionKind,
+): WorkspaceProposalRepairReviewDecisionIntent | undefined {
+	switch (actionKind) {
+		case "acknowledge-review":
+			return "acknowledged";
+		case "withdraw-review":
+			return "withdrawn";
+		case "mark-human-resolved":
+			return "resolved";
+		case "supersede-review":
+			return "superseded";
+		case "open-successor-proposal-flow":
+			return undefined;
+	}
+}
+
+function repairActionIntentIssues(
+	intent: WorkspaceProposalRepairActionIntent | unknown,
+	options: WorkspaceProposalRepairActionIntentValidationOptions,
+): readonly WorkspaceProposalRecordedIssue[] {
+	const issues: WorkspaceProposalRecordedIssue[] = [];
+	const request = options.request;
+	const descriptor = options.descriptor;
+	const currentStatus = options.currentStatus;
+	if (!isRepairActionIntentMaterial(intent)) {
+		return [
+			repairActionIntentIssue(
+				"malformed-repair-action-intent",
+				"Repair action intent requires typed data-only material.",
+				intent,
+				request,
+			),
+		];
+	}
+	const actionIntent = intent;
+	for (const [label, value] of [
+		["repairActionIntent", actionIntent],
+		["repairActionDescriptor", descriptor],
+		["repairReviewRequest", request],
+		["repairReviewStatus", currentStatus],
+		["repairActionIntentValidationOptions", options],
+	] as const) {
+		if (value === undefined) continue;
+		for (const issue of workspaceProposalDataOnlyIssues(value, label)) {
+			issues.push(repairActionIssueFromDataOnly(issue, actionIntent, request));
+		}
+	}
+	for (const [field, value] of [
+		["intentId", actionIntent.intentId],
+		["descriptorId", actionIntent.descriptorId],
+		["repairRequestId", actionIntent.repairRequestId],
+		["applicationId", actionIntent.applicationId],
+		["proposalId", actionIntent.proposalId],
+		["decisionId", actionIntent.decisionId],
+		["idempotencyKey", actionIntent.idempotencyKey],
+		["proposalFamily", actionIntent.proposalFamily],
+	] as const) {
+		if (blank(value)) {
+			issues.push(
+				repairActionIntentIssue(
+					"malformed-repair-action-intent",
+					`Repair action intent requires ${field}.`,
+					intent,
+					request,
+				),
+			);
+		}
+	}
+	if (!repairActionKinds.includes(actionIntent.actionKind)) {
+		issues.push(
+			repairActionIntentIssue(
+				"unsupported-repair-action-intent",
+				"Repair action intent requires a supported actionKind.",
+				intent,
+				request,
+			),
+		);
+	}
+	if (request === undefined) {
+		issues.push(
+			repairActionIntentIssue(
+				"missing-repair-review-request",
+				"Repair action intent requires a matching repair-review request.",
+				intent,
+				request,
+			),
+		);
+	} else if (!isRepairReviewRequestMaterial(request)) {
+		issues.push(
+			repairActionIntentIssue(
+				"malformed-repair-review-request",
+				"Repair action intent requires typed repair-review request material.",
+				intent,
+				request,
+			),
+		);
+	} else if (
+		actionIntent.repairRequestId !== request.repairRequestId ||
+		!repairReviewCoordinatesMatch(request, actionIntent)
+	) {
+		issues.push(
+			repairActionIntentIssue(
+				"repair-action-intent-coordinate-mismatch",
+				"Repair action intent coordinates must match the repair-review request.",
+				intent,
+				request,
+			),
+		);
+	}
+	if (descriptor === undefined) {
+		issues.push(
+			repairActionIntentIssue(
+				"missing-repair-action-descriptor",
+				"Repair action intent requires matching repair action descriptor material.",
+				intent,
+				request,
+			),
+		);
+	} else if (!isRepairActionDescriptorMaterial(descriptor)) {
+		issues.push(
+			repairActionIntentIssue(
+				"malformed-repair-action-descriptor",
+				"Repair action intent requires typed repair action descriptor material.",
+				intent,
+				request,
+			),
+		);
+	} else {
+		if (
+			actionIntent.descriptorId !== descriptor.descriptorId ||
+			actionIntent.repairRequestId !== descriptor.repairRequestId ||
+			actionIntent.actionKind !== descriptor.actionKind ||
+			!coordinatesMatchExact(actionIntent, descriptor)
+		) {
+			issues.push(
+				repairActionIntentIssue(
+					"repair-action-intent-descriptor-mismatch",
+					"Repair action intent must match descriptor id, request, action, and coordinates.",
+					intent,
+					request,
+				),
+			);
+		}
+		if (!descriptor.enabled) {
+			issues.push(
+				repairActionIntentIssue(
+					"repair-action-lifecycle-disabled",
+					"Repair action descriptor is disabled by lifecycle state.",
+					intent,
+					request,
+				),
+			);
+		}
+	}
+	const expectedCurrentState: WorkspaceProposalRepairReviewExpectedCurrentState | undefined =
+		options.expectedCurrentState ?? actionIntent.expectedCurrentState;
+	if (currentStatus !== undefined) {
+		if (request === undefined || !repairReviewCoordinatesMatch(request, currentStatus)) {
+			issues.push(
+				repairActionIntentIssue(
+					"current-status-coordinate-mismatch",
+					"Repair action current status guard must match the repair-review request.",
+					intent,
+					request,
+				),
+			);
+		} else if (
+			expectedCurrentState !== undefined &&
+			!repairReviewExpectedStateMatchesStatus(expectedCurrentState, currentStatus)
+		) {
+			issues.push(
+				repairActionIntentIssue(
+					"stale-repair-review-state",
+					"Repair action current status no longer matches the expected guard state.",
+					intent,
+					request,
+				),
+			);
+		}
+	} else if (expectedCurrentState !== undefined) {
+		issues.push(
+			repairActionIntentIssue(
+				"stale-repair-review-state",
+				"Repair action expected current state guard requires current status material.",
+				intent,
+				request,
+			),
+		);
+	}
+	if (actionIntent.reviewerRef === undefined && actionIntent.actorRef === undefined) {
+		issues.push(
+			repairActionIntentIssue(
+				"missing-repair-action-authority-material",
+				"Repair action intent requires reviewer or actor ref material.",
+				intent,
+				request,
+			),
+		);
+	}
+	if (
+		(options.capabilityRefs !== undefined &&
+			(!Array.isArray(options.capabilityRefs) || options.capabilityRefs.length === 0)) ||
+		(options.policyRefs !== undefined &&
+			(!Array.isArray(options.policyRefs) || options.policyRefs.length === 0))
+	) {
+		issues.push(
+			repairActionIntentIssue(
+				"missing-repair-action-policy-material",
+				"Repair action intent validation requires non-empty supplied capability or policy refs when present.",
+				intent,
+				request,
+			),
+		);
+	}
+	if (options.capabilityRefs === undefined && options.policyRefs === undefined) {
+		issues.push(
+			repairActionIntentIssue(
+				"missing-repair-action-policy-material",
+				"Repair action intent validation requires explicit intake policy or capability material.",
+				intent,
+				request,
+			),
+		);
+	}
+	for (const [field, refs] of [
+		["capabilityRefs", actionIntent.capabilityRefs],
+		["policyRefs", actionIntent.policyRefs],
+		["sourceRefs", actionIntent.sourceRefs],
+		["validationCapabilityRefs", options.capabilityRefs],
+		["validationPolicyRefs", options.policyRefs],
+		["validationSourceRefs", options.sourceRefs],
+	] as const) {
+		if (refs !== undefined && !repairReviewDecisionSourceRefsAreValid(refs)) {
+			issues.push(
+				repairActionIntentIssue(
+					"malformed-ref",
+					`Repair action intent ${field} must be a dense array of data-only refs.`,
+					intent,
+					request,
+				),
+			);
+		}
+	}
+	for (const [field, value] of [
+		["reviewerRef", actionIntent.reviewerRef],
+		["actorRef", actionIntent.actorRef],
+	] as const) {
+		if (value !== undefined && !repairReviewDecisionSourceRefIsValid(value)) {
+			issues.push(
+				repairActionIntentIssue(
+					"malformed-ref",
+					`Repair action intent ${field} must be a data-only ref.`,
+					intent,
+					request,
+				),
+			);
+		}
+	}
+	if (actionIntent.audit !== undefined && !isWorkspaceProposalAuditMaterial(actionIntent.audit)) {
+		issues.push(
+			repairActionIntentIssue(
+				"malformed-audit",
+				"Repair action intent audit material must be data-only audit material.",
+				intent,
+				request,
+			),
+		);
+	}
+	if (actionIntent.metadata !== undefined && !isRecord(actionIntent.metadata)) {
+		issues.push(
+			repairActionIntentIssue(
+				"malformed-metadata",
+				"Repair action intent metadata must be bounded object material.",
+				intent,
+				request,
+			),
+		);
+	}
+	if (options.policyStatus !== undefined && options.policyStatus !== "allowed") {
+		issues.push(
+			repairActionIntentIssue(
+				options.policyStatus === "blocked"
+					? "blocked-repair-action-policy"
+					: "missing-repair-action-policy",
+				"Repair action policy/capability validation failed closed at intake.",
+				intent,
+				request,
+			),
+		);
+	}
+	issues.push(
+		...(options.policyIssues ?? []).map((issue) =>
+			repairActionIssueFromDataOnly(issue, actionIntent, request),
+		),
+	);
+	return dedupeRepairActionIssues(issues);
+}
+
+function repairActionSourceRefs(values: readonly SourceRef[]): readonly SourceRef[] {
+	return immutableClone(
+		uniqueRefs(
+			values.filter(
+				(ref) =>
+					repairReviewDecisionSourceRefIsValid(ref) && workspaceProposalBoundaryRefIsSafe(ref),
+			),
+		),
+	);
+}
+
+function repairActionValidationOptions(
+	optionsOrDescriptor:
+		| WorkspaceProposalRepairActionIntentValidationOptions
+		| WorkspaceProposalRepairActionDescriptor
+		| undefined,
+	request: WorkspaceProposalRepairReviewRequest | undefined,
+	currentStatus: WorkspaceProposalRepairReviewStatus | undefined,
+): WorkspaceProposalRepairActionIntentValidationOptions {
+	if (optionsOrDescriptor === undefined || isRepairActionDescriptorMaterial(optionsOrDescriptor)) {
+		return { descriptor: optionsOrDescriptor, request, currentStatus };
+	}
+	return optionsOrDescriptor;
+}
+
+function isRepairActionIntentMaterial(
+	value: unknown,
+): value is WorkspaceProposalRepairActionIntent {
+	return isRecord(value) && value.kind === "workspace-proposal-repair-action-intent";
+}
+
+function isRepairActionDescriptorMaterial(
+	value: unknown,
+): value is WorkspaceProposalRepairActionDescriptor {
+	return (
+		isRecord(value) &&
+		value.kind === "workspace-proposal-repair-action-descriptor" &&
+		nonBlankString(value.descriptorId) &&
+		nonBlankString(value.repairRequestId) &&
+		repairActionKinds.includes(value.actionKind as WorkspaceProposalRepairActionKind) &&
+		typeof value.enabled === "boolean" &&
+		nonBlankString(value.applicationId) &&
+		nonBlankString(value.proposalId) &&
+		nonBlankString(value.decisionId) &&
+		nonBlankString(value.idempotencyKey) &&
+		nonBlankString(value.proposalFamily)
+	);
+}
+
+function isRepairReviewRequestMaterial(
+	value: unknown,
+): value is WorkspaceProposalRepairReviewRequest {
+	return (
+		isRecord(value) &&
+		value.kind === "workspace-proposal-repair-review-request" &&
+		nonBlankString(value.repairRequestId) &&
+		nonBlankString(value.applicationId) &&
+		nonBlankString(value.proposalId) &&
+		nonBlankString(value.decisionId) &&
+		nonBlankString(value.idempotencyKey) &&
+		nonBlankString(value.proposalFamily)
+	);
+}
+
+function isRepairActionIntentValidationResultMaterial(
+	value: unknown,
+): value is WorkspaceProposalRepairActionIntentValidationResult {
+	return (
+		isRecord(value) &&
+		value.kind === "workspace-proposal-repair-action-intent-validation-result" &&
+		(value.status === "accepted" || value.status === "blocked") &&
+		(value.intentId === undefined || nonBlankString(value.intentId)) &&
+		(value.descriptorId === undefined || nonBlankString(value.descriptorId)) &&
+		(value.repairRequestId === undefined || nonBlankString(value.repairRequestId)) &&
+		(value.actionKind === undefined ||
+			repairActionKinds.includes(value.actionKind as WorkspaceProposalRepairActionKind)) &&
+		(value.applicationId === undefined || nonBlankString(value.applicationId)) &&
+		(value.proposalId === undefined || nonBlankString(value.proposalId)) &&
+		(value.decisionId === undefined || nonBlankString(value.decisionId)) &&
+		(value.idempotencyKey === undefined || nonBlankString(value.idempotencyKey)) &&
+		(value.proposalFamily === undefined || nonBlankString(value.proposalFamily)) &&
+		Array.isArray(value.issues) &&
+		nonEmptySourceRefs(value.sourceRefs) &&
+		workspaceProposalBoundarySourceRefsAreSafe(value.sourceRefs) &&
+		(value.audit === undefined ||
+			(isWorkspaceProposalAuditMaterial(value.audit) &&
+				workspaceProposalBoundarySourceRefsAreSafe(value.audit.sourceRefs))) &&
+		(value.intent === undefined || isRepairActionIntentMaterial(value.intent))
+	);
+}
+
+const repairActionDisplayPolicyAssessments = [
+	"not-evaluated",
+	"no-known-blocker",
+	"known-blocker",
+	"needs-review",
+	"unknown",
+] as const satisfies readonly WorkspaceProposalRepairActionDisplayPolicyAssessment[];
+
+function isRepairActionDisplayPolicyAdvisoryMaterial(
+	value: unknown,
+): value is WorkspaceProposalRepairActionDisplayPolicyAdvisory {
+	if (!isRecord(value)) return false;
+	return (
+		value.kind === "workspace-proposal-repair-action-display-policy-advisory" &&
+		value.authority === "display-only-advisory" &&
+		nonBlankString(value.descriptorId) &&
+		nonBlankString(value.repairRequestId) &&
+		repairActionKinds.includes(value.actionKind as WorkspaceProposalRepairActionKind) &&
+		nonBlankString(value.applicationId) &&
+		nonBlankString(value.proposalId) &&
+		nonBlankString(value.decisionId) &&
+		nonBlankString(value.idempotencyKey) &&
+		nonBlankString(value.proposalFamily) &&
+		repairActionDisplayPolicyAssessments.includes(
+			value.displayAssessment as WorkspaceProposalRepairActionDisplayPolicyAssessment,
+		) &&
+		(value.policyEvidenceRefs === undefined ||
+			(nonEmptySourceRefs(value.policyEvidenceRefs) &&
+				workspaceProposalBoundarySourceRefsAreSafe(value.policyEvidenceRefs))) &&
+		(value.capabilityEvidenceRefs === undefined ||
+			(nonEmptySourceRefs(value.capabilityEvidenceRefs) &&
+				workspaceProposalBoundarySourceRefsAreSafe(value.capabilityEvidenceRefs))) &&
+		(value.sourceRefs === undefined ||
+			(nonEmptySourceRefs(value.sourceRefs) &&
+				workspaceProposalBoundarySourceRefsAreSafe(value.sourceRefs))) &&
+		(value.audit === undefined ||
+			(isWorkspaceProposalAuditMaterial(value.audit) &&
+				workspaceProposalBoundarySourceRefsAreSafe(value.audit.sourceRefs))) &&
+		(value.advisoryIssues === undefined ||
+			(Array.isArray(value.advisoryIssues) &&
+				value.advisoryIssues.length <= 25 &&
+				value.advisoryIssues.every(isRepairActionDisplayAdvisoryIssue))) &&
+		(value.displayCode === undefined || typeof value.displayCode === "string") &&
+		(value.displayMessage === undefined || typeof value.displayMessage === "string")
+	);
+}
+
+function isRepairActionDisplayAdvisoryIssue(
+	value: unknown,
+): value is WorkspaceProposalRepairActionDisplayPolicyAdvisoryIssue {
+	return (
+		isRecord(value) &&
+		nonBlankString(value.kind) &&
+		typeof value.message === "string" &&
+		(value.severity === undefined ||
+			value.severity === "info" ||
+			value.severity === "warning" ||
+			value.severity === "error") &&
+		(value.ref === undefined ||
+			(isSourceRef(value.ref) && workspaceProposalBoundaryRefIsSafe(value.ref))) &&
+		(value.metadata === undefined || isRecord(value.metadata))
+	);
+}
+
+function repairActionAdvisoryHasPermissionProofMaterial(value: unknown): boolean {
+	const forbidden = new Set(["allowed", "permitted", "authorized", "cansubmit"]);
+	const seen = new WeakSet<object>();
+	const visit = (entry: unknown): boolean => {
+		if (typeof entry === "string") {
+			const normalized = entry.toLowerCase().replace(/[-_\s]/g, "");
+			return [...forbidden].some((token) => normalized.includes(token));
+		}
+		if (Array.isArray(entry)) return entry.some(visit);
+		if (!isRecord(entry)) return false;
+		if (seen.has(entry)) return false;
+		seen.add(entry);
+		for (const [key, child] of Object.entries(entry)) {
+			const normalized = key.toLowerCase().replace(/[-_\s]/g, "");
+			if (forbidden.has(normalized)) return true;
+			if (visit(child)) return true;
+		}
+		return false;
+	};
+	return visit(value);
+}
+
+const workspaceProposalBoundaryRefForbiddenTokens = new Set([
+	"adapter",
+	"callback",
+	"client",
+	"credential",
+	"credentials",
+	"cursor",
+	"file",
+	"handle",
+	"network",
+	"provider",
+	"query",
+	"runtime",
+	"secret",
+	"storage",
+]);
+
+function workspaceProposalBoundaryTextHasForbiddenToken(text: string): boolean {
+	const tokens = text
+		.replace(/([a-z0-9])([A-Z])/gu, "$1 $2")
+		.toLowerCase()
+		.split(/[^a-z0-9]+/u)
+		.filter((token) => token.length > 0);
+	return tokens.some((token) => workspaceProposalBoundaryRefForbiddenTokens.has(token));
+}
+
+function workspaceProposalBoundaryRefIsSafe(ref: SourceRef | WorkspaceProposalTargetRef): boolean {
+	return (
+		!workspaceProposalBoundaryTextHasForbiddenToken(ref.kind) &&
+		!workspaceProposalBoundaryTextHasForbiddenToken(ref.id)
+	);
+}
+
+function workspaceProposalBoundarySourceRefsAreSafe(
+	value: readonly SourceRef[] | undefined,
+): boolean {
+	return value === undefined || value.every(workspaceProposalBoundaryRefIsSafe);
+}
+
+function safeBoundarySourceRefs(value: unknown): readonly SourceRef[] {
+	if (!Array.isArray(value)) return [];
+	return repairActionSourceRefs(
+		value.filter(
+			(ref): ref is SourceRef => isSourceRef(ref) && workspaceProposalBoundaryRefIsSafe(ref),
+		),
+	);
+}
+
+function workspaceProposalBoundaryMetadataSize(value: Record<string, unknown>): number {
+	try {
+		return new TextEncoder().encode(stableStringify(value)).byteLength;
+	} catch {
+		return Number.POSITIVE_INFINITY;
+	}
+}
+
+const workspaceProposalRepairAdvisoryMetadataMaxBytes = 4096;
+
+function safeAdvisoryText(value: string | undefined): string | undefined {
+	if (value === undefined || repairActionAdvisoryHasPermissionProofMaterial(value))
+		return undefined;
+	return value;
+}
+
+function safeAdvisorySourceRefs(value: readonly SourceRef[] | undefined): readonly SourceRef[] {
+	if (value === undefined) return [];
+	return repairActionSourceRefs(
+		value.filter(
+			(ref) =>
+				isSourceRef(ref) &&
+				workspaceProposalBoundaryRefIsSafe(ref) &&
+				!repairActionAdvisoryHasPermissionProofMaterial(ref),
+		),
+	);
+}
+
+function safeAdvisoryIssues(
+	value: readonly WorkspaceProposalRepairActionDisplayPolicyAdvisoryIssue[] | undefined,
+): readonly WorkspaceProposalRepairActionDisplayPolicyAdvisoryIssue[] {
+	if (value === undefined) return [];
+	return immutableClone(
+		value.filter(
+			(issue) =>
+				isRepairActionDisplayAdvisoryIssue(issue) &&
+				workspaceProposalDataOnlyIssues(issue, "repairActionDisplayPolicyAdvisoryIssue").length ===
+					0 &&
+				!repairActionAdvisoryHasPermissionProofMaterial(issue),
+		),
+	);
+}
+
+function safeAdvisoryAudit(
+	value: WorkspaceProposalAuditMaterial | undefined,
+): WorkspaceProposalAuditMaterial | undefined {
+	const audit = safeWorkspaceProposalAudit(value);
+	if (
+		audit === undefined ||
+		repairActionAdvisoryHasPermissionProofMaterial(audit) ||
+		!workspaceProposalBoundarySourceRefsAreSafe(audit.sourceRefs)
+	) {
+		return undefined;
+	}
+	return audit;
+}
+
+function safeAdvisoryMetadata(
+	value: Record<string, unknown> | undefined,
+): Record<string, unknown> | undefined {
+	if (
+		value === undefined ||
+		workspaceProposalDataOnlyIssues(value, "repairActionDisplayPolicyAdvisoryMetadata").length >
+			0 ||
+		repairActionAdvisoryHasPermissionProofMaterial(value) ||
+		workspaceProposalBoundaryMetadataSize(value) > workspaceProposalRepairAdvisoryMetadataMaxBytes
+	) {
+		return undefined;
+	}
+	return immutableClone(value);
+}
+
+function repairActionCoordinatesMatchDescriptor(
+	material: {
+		readonly applicationId: string;
+		readonly proposalId: string;
+		readonly decisionId: string;
+		readonly idempotencyKey: string;
+		readonly proposalFamily: WorkspaceProposalFamily;
+	},
+	descriptor: WorkspaceProposalRepairActionDescriptor,
+): boolean {
+	return (
+		material.applicationId === descriptor.applicationId &&
+		material.proposalId === descriptor.proposalId &&
+		material.decisionId === descriptor.decisionId &&
+		material.idempotencyKey === descriptor.idempotencyKey &&
+		material.proposalFamily === descriptor.proposalFamily
+	);
+}
+
+function isRepairSuccessorPreviewMaterial(
+	value: unknown,
+): value is WorkspaceProposalRepairSuccessorProposalIntakePreview {
+	return (
+		isRecord(value) &&
+		value.kind === "workspace-proposal-repair-successor-proposal-intake-preview" &&
+		nonBlankString(value.previewId) &&
+		(value.status === "proposal-context-ready" || value.status === "blocked") &&
+		nonBlankString(value.intentId) &&
+		nonBlankString(value.descriptorId) &&
+		nonBlankString(value.repairRequestId) &&
+		value.actionKind === "open-successor-proposal-flow" &&
+		nonBlankString(value.applicationId) &&
+		nonBlankString(value.proposalId) &&
+		nonBlankString(value.decisionId) &&
+		nonBlankString(value.idempotencyKey) &&
+		nonBlankString(value.proposalFamily) &&
+		nonEmptySourceRefs(value.targetRefs) &&
+		workspaceProposalBoundarySourceRefsAreSafe(value.targetRefs) &&
+		nonEmptySourceRefs(value.contextRefs) &&
+		workspaceProposalBoundarySourceRefsAreSafe(value.contextRefs) &&
+		Array.isArray(value.diagnostics) &&
+		nonEmptySourceRefs(value.sourceRefs) &&
+		workspaceProposalBoundarySourceRefsAreSafe(value.sourceRefs) &&
+		(value.audit === undefined ||
+			(isWorkspaceProposalAuditMaterial(value.audit) &&
+				workspaceProposalBoundarySourceRefsAreSafe(value.audit.sourceRefs)))
+	);
+}
+
+function isRepairSuccessorReadyRequestPreparationInput<TDraft>(
+	value: unknown,
+): value is WorkspaceProposalRepairSuccessorProposalReadyRequestPreparationInput<TDraft> {
+	if (!isRecord(value)) return false;
+	return (
+		value.kind === "workspace-proposal-repair-successor-proposal-ready-request-preparation-input" &&
+		nonBlankString(value.preparationId) &&
+		nonBlankString(value.previewId) &&
+		isRepairActionIntentMaterial(value.intent) &&
+		isRepairActionDescriptorMaterial(value.descriptor) &&
+		isRepairReviewRequestMaterial(value.request) &&
+		isRepairActionIntentValidationResultMaterial(value.intentValidation) &&
+		(value.currentStatus === undefined || isRepairReviewStatusMaterial(value.currentStatus)) &&
+		nonBlankString(value.successorProposalId) &&
+		nonBlankString(value.intakeRequestId) &&
+		nonBlankString(value.successorIdempotencyKey) &&
+		nonBlankString(value.workspaceId) &&
+		isSourceRef(value.actorRef) &&
+		workspaceProposalBoundaryRefIsSafe(value.actorRef) &&
+		nonEmptySourceRefs(value.capabilityRefs) &&
+		workspaceProposalBoundarySourceRefsAreSafe(value.capabilityRefs) &&
+		nonEmptySourceRefs(value.policyRefs) &&
+		workspaceProposalBoundarySourceRefsAreSafe(value.policyRefs) &&
+		nonEmptySourceRefs(value.projectionBundleRefs) &&
+		workspaceProposalBoundarySourceRefsAreSafe(value.projectionBundleRefs) &&
+		(value.sourceRefs === undefined ||
+			(nonEmptySourceRefs(value.sourceRefs) &&
+				workspaceProposalBoundarySourceRefsAreSafe(value.sourceRefs))) &&
+		isWorkspaceProposalAuditMaterial(value.audit) &&
+		workspaceProposalBoundarySourceRefsAreSafe(value.audit.sourceRefs) &&
+		workspaceProposalTargetRefsAreValid(value.targetRefs) &&
+		nonBlankString(value.successorProposalFamily) &&
+		nonBlankString(value.successorLoweringKind) &&
+		(value.draftRefs === undefined ||
+			(nonEmptySourceRefs(value.draftRefs) &&
+				workspaceProposalBoundarySourceRefsAreSafe(value.draftRefs))) &&
+		(value.finalDraftSourceRefs === undefined ||
+			(nonEmptySourceRefs(value.finalDraftSourceRefs) &&
+				workspaceProposalBoundarySourceRefsAreSafe(value.finalDraftSourceRefs))) &&
+		(value.metadata === undefined || isRecord(value.metadata))
+	);
+}
+
+function repairSuccessorPreparationMetadataHasTruthMaterial(value: unknown): boolean {
+	if (!isRecord(value)) return false;
+	const forbidden = new Set([
+		"admissionid",
+		"applicationstate",
+		"applicationstatus",
+		"emittedfactrefs",
+		"proposalrecorded",
+		"recordedproposal",
+		"successoradmissionid",
+		"workspaceproposalrecorded",
+	]);
+	const seen = new WeakSet<object>();
+	const visit = (entry: unknown): boolean => {
+		if (Array.isArray(entry)) return entry.some(visit);
+		if (!isRecord(entry)) return false;
+		if (seen.has(entry)) return false;
+		seen.add(entry);
+		for (const [key, child] of Object.entries(entry)) {
+			if (forbidden.has(key.toLowerCase().replace(/[-_\s]/g, ""))) return true;
+			if (visit(child)) return true;
+		}
+		return false;
+	};
+	return visit(value);
+}
+
+function repairActionPreviewCoordinatesMatchInput<TDraft>(
+	preview: WorkspaceProposalRepairSuccessorProposalIntakePreview,
+	input: WorkspaceProposalRepairSuccessorProposalReadyRequestPreparationInput<TDraft>,
+): boolean {
+	return (
+		preview.applicationId === input.intent.applicationId &&
+		preview.proposalId === input.intent.proposalId &&
+		preview.decisionId === input.intent.decisionId &&
+		preview.idempotencyKey === input.intent.idempotencyKey &&
+		preview.proposalFamily === input.intent.proposalFamily &&
+		repairReviewCoordinatesMatch(input.request, input.intent) &&
+		repairActionCoordinatesMatchDescriptor(input.intent, input.descriptor)
+	);
+}
+
+function repairActionIntentValidationMatchesPreparationInput<TDraft>(
+	validation: WorkspaceProposalRepairActionIntentValidationResult,
+	input: WorkspaceProposalRepairSuccessorProposalReadyRequestPreparationInput<TDraft>,
+): boolean {
+	return (
+		validation.intentId === input.intent.intentId &&
+		validation.descriptorId === input.descriptor.descriptorId &&
+		validation.repairRequestId === input.request.repairRequestId &&
+		validation.actionKind === input.intent.actionKind &&
+		validation.applicationId === input.request.applicationId &&
+		validation.proposalId === input.request.proposalId &&
+		validation.decisionId === input.request.decisionId &&
+		validation.idempotencyKey === input.request.idempotencyKey &&
+		validation.proposalFamily === input.request.proposalFamily &&
+		(validation.intent === undefined ||
+			stableStringify(validation.intent) === stableStringify(input.intent))
+	);
+}
+
+function nonEmptySourceRefs(value: unknown): value is readonly SourceRef[] {
+	return Array.isArray(value) && value.length > 0 && value.every(isSourceRef);
+}
+
+function workspaceProposalTargetRefsAreValid(
+	value: unknown,
+): value is readonly WorkspaceProposalTargetRef[] {
+	return (
+		Array.isArray(value) &&
+		value.length > 0 &&
+		value.every(
+			(ref) =>
+				isRecord(ref) &&
+				nonBlankString(ref.kind) &&
+				nonBlankString(ref.id) &&
+				workspaceProposalBoundaryRefIsSafe(ref as unknown as WorkspaceProposalTargetRef) &&
+				workspaceProposalDataOnlyIssues(ref, "repairSuccessorTargetRef").length === 0,
+		)
+	);
+}
+
+function repairActionIssueIntentFallback(value: unknown): WorkspaceProposalRepairActionIntent {
+	if (isRepairSuccessorReadyRequestPreparationInput(value)) return value.intent;
+	if (isRepairActionIntentMaterial(value)) return value;
+	return {
+		kind: "workspace-proposal-repair-action-intent",
+		intentId: stringField(isRecord(value) ? value.intentId : undefined) ?? "unknown",
+		descriptorId: stringField(isRecord(value) ? value.descriptorId : undefined) ?? "unknown",
+		repairRequestId: stringField(isRecord(value) ? value.repairRequestId : undefined) ?? "unknown",
+		actionKind: "open-successor-proposal-flow",
+		applicationId: stringField(isRecord(value) ? value.applicationId : undefined) ?? "unknown",
+		proposalId: stringField(isRecord(value) ? value.proposalId : undefined) ?? "unknown",
+		decisionId: stringField(isRecord(value) ? value.decisionId : undefined) ?? "unknown",
+		idempotencyKey: stringField(isRecord(value) ? value.idempotencyKey : undefined) ?? "unknown",
+		proposalFamily:
+			(stringField(
+				isRecord(value) ? value.proposalFamily : undefined,
+			) as WorkspaceProposalFamily) ?? "unknown",
+	};
+}
+
+function isOutcomeDetailSupplyRequestMaterial(
+	value: unknown,
+): value is WorkspaceProposalFamilyOutcomeDetailSupplyRequest {
+	return (
+		isRecord(value) &&
+		value.kind === "workspace-proposal-family-outcome-detail-supply-request" &&
+		nonBlankString(value.supplyRequestId) &&
+		nonBlankString(value.applicationId) &&
+		nonBlankString(value.proposalId) &&
+		nonBlankString(value.decisionId) &&
+		nonBlankString(value.idempotencyKey) &&
+		nonBlankString(value.proposalFamily) &&
+		Array.isArray(value.requestedOutcomeRefs) &&
+		value.requestedOutcomeRefs.length > 0 &&
+		value.requestedOutcomeRefs.every(isOutcomeDetailSupplyRequestedRefMaterial) &&
+		repairReviewDecisionSourceRefsAreValid(value.sourceRefs) &&
+		workspaceProposalBoundarySourceRefsAreSafe(value.sourceRefs) &&
+		(value.audit === undefined ||
+			(isWorkspaceProposalAuditMaterial(value.audit) &&
+				workspaceProposalBoundarySourceRefsAreSafe(value.audit.sourceRefs))) &&
+		(value.metadata === undefined || isRecord(value.metadata))
+	);
+}
+
+function isOutcomeDetailSupplyRequestedRefMaterial(
+	value: unknown,
+): value is WorkspaceProposalFamilyOutcomeRef {
+	return (
+		isRecord(value) &&
+		value.kind === "workspace-proposal-family-outcome-ref" &&
+		nonBlankString(value.outcomeId) &&
+		workspaceProposalFamilyOutcomeKinds.includes(
+			value.outcomeKind as WorkspaceProposalFamilyOutcomeRecord["kind"],
+		) &&
+		nonBlankString(value.applicationId) &&
+		nonBlankString(value.proposalId) &&
+		nonBlankString(value.decisionId) &&
+		nonBlankString(value.idempotencyKey) &&
+		nonBlankString(value.proposalFamily) &&
+		(value.sourceRefs === undefined ||
+			(repairReviewDecisionSourceRefsAreValid(value.sourceRefs) &&
+				workspaceProposalBoundarySourceRefsAreSafe(value.sourceRefs)))
+	);
+}
+
+function outcomeDetailSupplyRequestIssues(
+	request: WorkspaceProposalFamilyOutcomeDetailSupplyRequest | unknown,
+): readonly WorkspaceProposalRecordedIssue[] {
+	const issues: WorkspaceProposalRecordedIssue[] = [];
+	const record = isRecord(request) ? request : {};
+	for (const issue of workspaceProposalDataOnlyIssues(request, "outcomeDetailSupplyRequest")) {
+		issues.push({ ...issue, subjectId: issue.subjectId ?? stringField(record.proposalId) });
+	}
+	if (!isRecord(request)) {
+		issues.push(
+			repairActionIntentIssue(
+				"malformed-outcome-detail-supply-request",
+				"Outcome detail supply request requires typed object material.",
+				{},
+				undefined,
+			),
+		);
+		return issues;
+	}
+	for (const field of [
+		"supplyRequestId",
+		"applicationId",
+		"proposalId",
+		"decisionId",
+		"idempotencyKey",
+		"proposalFamily",
+	] as const) {
+		if (blank(record[field])) {
+			issues.push(
+				repairActionIntentIssue(
+					"malformed-outcome-detail-supply-request",
+					`Outcome detail supply request requires ${field}.`,
+					{ proposalId: record.proposalId },
+					undefined,
+				),
+			);
+		}
+	}
+	if (!Array.isArray(record.requestedOutcomeRefs) || record.requestedOutcomeRefs.length === 0) {
+		issues.push(
+			repairActionIntentIssue(
+				"malformed-outcome-detail-supply-request",
+				"Outcome detail supply request requires requested outcome refs.",
+				{ proposalId: record.proposalId },
+				undefined,
+			),
+		);
+	} else if (!record.requestedOutcomeRefs.every(isOutcomeDetailSupplyRequestedRefMaterial)) {
+		issues.push(
+			repairActionIntentIssue(
+				"malformed-outcome-detail-supply-request",
+				"Outcome detail supply request refs must carry full thin outcome coordinates.",
+				{ proposalId: record.proposalId },
+				undefined,
+			),
+		);
+	}
+	if (
+		!repairReviewDecisionSourceRefsAreValid(record.sourceRefs) ||
+		!workspaceProposalBoundarySourceRefsAreSafe(
+			record.sourceRefs as readonly SourceRef[] | undefined,
+		)
+	) {
+		issues.push(
+			repairActionIntentIssue(
+				"malformed-outcome-detail-supply-request",
+				"Outcome detail supply request requires data-only boundary-safe source refs.",
+				{ proposalId: record.proposalId },
+				undefined,
+			),
+		);
+	}
+	const auditRecord = record.audit;
+	if (
+		isRecord(auditRecord) &&
+		(!isWorkspaceProposalAuditMaterial(auditRecord) ||
+			!workspaceProposalBoundarySourceRefsAreSafe(
+				(auditRecord as { readonly sourceRefs?: readonly SourceRef[] }).sourceRefs,
+			))
+	) {
+		issues.push(
+			repairActionIntentIssue(
+				"malformed-outcome-detail-supply-request",
+				"Outcome detail supply request audit must be data-only boundary-safe material.",
+				{ proposalId: record.proposalId },
+				undefined,
+			),
+		);
+	}
+	return dedupeRepairActionIssues(issues);
+}
+
+function isOutcomeDetailSupplyOutcomeRecordShape(
+	value: unknown,
+): value is WorkspaceProposalFamilyOutcomeRecord {
+	return (
+		isRecord(value) &&
+		workspaceProposalFamilyOutcomeKinds.includes(
+			value.kind as WorkspaceProposalFamilyOutcomeRecord["kind"],
+		) &&
+		nonBlankString(value.outcomeId) &&
+		nonBlankString(value.applicationId) &&
+		nonBlankString(value.proposalId) &&
+		nonBlankString(value.decisionId) &&
+		nonBlankString(value.idempotencyKey) &&
+		nonBlankString(value.proposalFamily) &&
+		Array.isArray(value.sourceRefs)
+	);
+}
+
+function outcomeDetailSupplyOutcomeBoundaryRefsAreSafe(
+	outcome: WorkspaceProposalFamilyOutcomeRecord,
+): boolean {
+	const familyRef =
+		outcome.kind === "workspace-proposal-required-input-response-outcome-recorded"
+			? outcome.responseRef
+			: outcome.kind === "workspace-proposal-work-item-spawn-outcome-recorded"
+				? outcome.workItemRef
+				: outcome.kind === "workspace-proposal-work-item-link-outcome-recorded"
+					? outcome.linkRef
+					: outcome.actionRef;
+	return (
+		workspaceProposalBoundarySourceRefsAreSafe(outcome.sourceRefs) &&
+		(outcome.audit === undefined ||
+			workspaceProposalBoundarySourceRefsAreSafe(outcome.audit.sourceRefs)) &&
+		workspaceProposalBoundaryRefIsSafe(familyRef)
+	);
+}
+
+function currentSupplyRequests(
+	requests: readonly WorkspaceProposalFamilyOutcomeDetailSupplyRequest[],
+): ReadonlyMap<string, WorkspaceProposalFamilyOutcomeDetailSupplyRequest> {
+	const out = new Map<string, WorkspaceProposalFamilyOutcomeDetailSupplyRequest>();
+	for (const request of requests)
+		out.set(outcomeDetailSupplyRequestProjectionKey(request), request);
+	return out;
+}
+
+function outcomeDetailSupplyRequestProjectionKey(
+	request: WorkspaceProposalFamilyOutcomeDetailSupplyRequest,
+): string {
+	return stableStringify({
+		currentViewId:
+			stringField((request as { readonly viewId?: unknown }).viewId) ??
+			stringField((request as { readonly supplyRequestId?: unknown }).supplyRequestId),
+	});
+}
+
+function sameSupplyRequestCoordinates(
+	request: WorkspaceProposalFamilyOutcomeDetailSupplyRequest,
+	ref: WorkspaceProposalFamilyOutcomeRef,
+): boolean {
+	return (
+		request.applicationId === ref.applicationId &&
+		request.proposalId === ref.proposalId &&
+		request.decisionId === ref.decisionId &&
+		request.idempotencyKey === ref.idempotencyKey &&
+		request.proposalFamily === ref.proposalFamily
+	);
+}
+
+function supplyRequestRefMatches(
+	request: WorkspaceProposalFamilyOutcomeDetailSupplyRequest,
+	ref: WorkspaceProposalFamilyOutcomeRef,
+	filters: WorkspaceProposalFamilyApplicationReadModelNormalizedFilters,
+): boolean {
+	return (
+		sameSupplyRequestCoordinates(request, ref) &&
+		matchesOptionalSet(filters.outcomeIds, ref.outcomeId) &&
+		matchesOptionalSet(filters.outcomeKinds, ref.outcomeKind)
+	);
+}
+
+function outcomeDetailSupplyDiagnostic(
+	code:
+		| "malformed-outcome-detail-supply-request"
+		| "malformed-supplied-outcome-detail"
+		| "missing-supplied-outcome-detail"
+		| "mismatched-supplied-outcome-detail",
+	message: string,
+	outcomeRef: WorkspaceProposalFamilyOutcomeRef | undefined,
+	coordinates: {
+		readonly applicationId?: string;
+		readonly proposalId?: string;
+		readonly decisionId?: string;
+		readonly idempotencyKey?: string;
+		readonly proposalFamily?: WorkspaceProposalFamily;
+	},
+	sourceRefs: readonly SourceRef[],
+): WorkspaceProposalFamilyApplicationReadModelDisplayDiagnostic {
+	return {
+		kind: "workspace-proposal-family-application-read-model-display-diagnostic",
+		diagnosticId: `workspace-proposal-family-application-read-model-display-diagnostic:${stableStringify(
+			{ code, outcomeRef, coordinates },
+		)}`,
+		code,
+		message,
+		...coordinates,
+		...(outcomeRef === undefined ? {} : { outcomeRef }),
+		sourceRefs: repairActionSourceRefs(sourceRefs),
+	};
+}
+
+function dedupeOutcomes(
+	outcomes: readonly WorkspaceProposalFamilyOutcomeRecord[],
+): readonly WorkspaceProposalFamilyOutcomeRecord[] {
+	const out = new Map<string, WorkspaceProposalFamilyOutcomeRecord>();
+	for (const outcome of outcomes) out.set(outcomeProjectionKey(outcome), outcome);
+	return [...out.values()];
+}
+
+function dedupeRepairActionIssues(
+	issues: readonly WorkspaceProposalRecordedIssue[],
+): readonly WorkspaceProposalRecordedIssue[] {
+	const out = new Map<string, WorkspaceProposalRecordedIssue>();
+	for (const issue of issues) out.set(stableStringify(issue), issue);
+	return [...out.values()];
+}
+
+function blockedRepairSuccessorPreview(
+	intent: WorkspaceProposalRepairActionIntent | unknown,
+	diagnostics: readonly WorkspaceProposalRecordedIssue[],
+	options: WorkspaceProposalRepairSuccessorProposalIntakePreviewOptions,
+): WorkspaceProposalRepairSuccessorProposalIntakePreview {
+	const record = isRecord(intent) ? intent : {};
+	return {
+		kind: "workspace-proposal-repair-successor-proposal-intake-preview",
+		previewId:
+			options.previewId ??
+			`workspace-proposal-repair-successor-preview:blocked:${stringField(record.intentId) ?? "unknown"}`,
+		status: "blocked",
+		intentId: stringField(record.intentId) ?? "",
+		actionIntentId: stringField(record.intentId) ?? "",
+		descriptorId: stringField(record.descriptorId) ?? "",
+		repairRequestId: stringField(record.repairRequestId) ?? "",
+		actionKind: "open-successor-proposal-flow",
+		applicationId: stringField(record.applicationId) ?? "",
+		proposalId: stringField(record.proposalId) ?? "",
+		decisionId: stringField(record.decisionId) ?? "",
+		idempotencyKey: stringField(record.idempotencyKey) ?? "",
+		proposalFamily: (stringField(record.proposalFamily) ?? "") as WorkspaceProposalFamily,
+		targetRefs: [],
+		contextRefs: [],
+		diagnostics: dedupeRepairActionIssues(diagnostics),
+		sourceRefs: repairActionSourceRefs([
+			...(options.sourceRefs ?? []),
+			...(safeWorkspaceProposalAudit(options.audit)?.sourceRefs ?? []),
+		]),
+		...(safeWorkspaceProposalAudit(options.audit) === undefined
+			? {}
+			: { audit: safeWorkspaceProposalAudit(options.audit) }),
+	};
+}
+
+function repairActionSuggestedDraftPatchIssues(
+	intent: WorkspaceProposalRepairActionIntent,
+	options: WorkspaceProposalRepairSuccessorProposalIntakePreviewOptions,
+): readonly WorkspaceProposalRecordedIssue[] {
+	if (options.suggestedDraftPatch === undefined) return [];
+	const issues = workspaceProposalDataOnlyIssues(
+		options.suggestedDraftPatch,
+		"repairSuccessorProposalSuggestedDraftPatch",
+	).map((issue) => repairActionIssueFromDataOnly(issue, intent, undefined));
+	if (issues.length > 0) return issues;
+	const maxBytes = options.maxSuggestedDraftPatchBytes ?? 16 * 1024;
+	if (
+		new TextEncoder().encode(stableStringify(options.suggestedDraftPatch)).byteLength > maxBytes
+	) {
+		return [
+			...issues,
+			repairActionIntentIssue(
+				"suggested-draft-patch-too-large",
+				"Repair successor proposal suggested draft patch exceeds the bounded preview limit.",
+				intent,
+				undefined,
+			),
+		];
+	}
+	return [...issues, ...repairActionReservedPreviewKeyIssues(intent, options.suggestedDraftPatch)];
+}
+
+function repairActionPreviewMetadataIssues(
+	intent: WorkspaceProposalRepairActionIntent,
+	options: WorkspaceProposalRepairSuccessorProposalIntakePreviewOptions,
+): readonly WorkspaceProposalRecordedIssue[] {
+	if (options.metadata === undefined) return [];
+	const issues = workspaceProposalDataOnlyIssues(
+		options.metadata,
+		"repairSuccessorProposalMetadata",
+	).map((issue) => repairActionIssueFromDataOnly(issue, intent, undefined));
+	if (issues.length > 0) return issues;
+	return [...issues, ...repairActionReservedPreviewKeyIssues(intent, options.metadata)];
+}
+
+function repairActionReservedPreviewKeyIssues(
+	intent: WorkspaceProposalRepairActionIntent,
+	value: unknown,
+): readonly WorkspaceProposalRecordedIssue[] {
+	const reserved = new Set([
+		"successorProposalId",
+		"successorAdmissionId",
+		"successorApplicationId",
+		"admissionId",
+		"applicationId",
+		"proposalId",
+		"proposalRecorded",
+		"admissionDecision",
+		"applicationStatus",
+	]);
+	const issues: WorkspaceProposalRecordedIssue[] = [];
+	const visit = (entry: unknown): void => {
+		if (Array.isArray(entry)) {
+			for (const item of entry) visit(item);
+			return;
+		}
+		if (!isRecord(entry)) return;
+		for (const [key, child] of Object.entries(entry)) {
+			if (reserved.has(key) || repairActionPreviewKeyCarriesTruth(key)) {
+				issues.push(
+					repairActionIntentIssue(
+						"forbidden-successor-truth-material",
+						"Repair successor proposal preview must not carry proposal/admission/application truth identifiers.",
+						intent,
+						undefined,
+					),
+				);
+			}
+			visit(child);
+		}
+	};
+	visit(value);
+	return dedupeRepairActionIssues(issues);
+}
+
+function repairActionPreviewKeyCarriesTruth(key: string): boolean {
+	const normalized = key
+		.replace(/([a-z0-9])([A-Z])/gu, "$1-$2")
+		.toLowerCase()
+		.replace(/[^a-z0-9]+/gu, "-");
+	const tokens = normalized.split("-").filter((token) => token.length > 0);
+	const hasTruthDomain = tokens.some((token) =>
+		["proposal", "admission", "application", "successor"].includes(token),
+	);
+	const hasTruthHandle = tokens.some((token) =>
+		[
+			"id",
+			"ids",
+			"ref",
+			"refs",
+			"record",
+			"recorded",
+			"decision",
+			"status",
+			"truth",
+			"fact",
+		].includes(token),
+	);
+	return hasTruthDomain && hasTruthHandle;
+}
+
+function repairActionIntentIssue(
+	code: string,
+	message: string,
+	intent: Partial<WorkspaceProposalRepairActionIntent> | unknown,
+	request: WorkspaceProposalRepairReviewRequest | undefined,
+): WorkspaceProposalRecordedIssue {
+	const intentRecord = isRecord(intent) ? intent : {};
+	return {
+		kind: "issue",
+		source: "workspace-proposal",
+		severity: "error",
+		code,
+		message,
+		subjectId: request?.proposalId ?? stringField(intentRecord.proposalId),
+		refs: [
+			...(stringField(intentRecord.intentId) === undefined
+				? []
+				: [`workspace-proposal-repair-action-intent:${stringField(intentRecord.intentId)}`]),
+			...(request === undefined
+				? []
+				: [`workspace-proposal-repair-review-request:${request.repairRequestId}`]),
+		],
+	};
+}
+
+function repairActionIssueFromDataOnly(
+	issue: WorkspaceProposalRecordedIssue,
+	intent: WorkspaceProposalRepairActionIntent,
+	request: WorkspaceProposalRepairReviewRequest | undefined,
+): WorkspaceProposalRecordedIssue {
+	return {
+		...issue,
+		subjectId: issue.subjectId ?? request?.proposalId ?? intent.proposalId,
+		refs: issue.refs ?? [
+			`workspace-proposal-repair-action-intent:${intent.intentId}`,
+			...(request === undefined
+				? []
+				: [`workspace-proposal-repair-review-request:${request.repairRequestId}`]),
+		],
+	};
+}
+
+function repairReviewSubjectRefs(
+	request: WorkspaceProposalRepairReviewRequest,
+): readonly SourceRef[] {
+	return (request.subjectRefs ?? []).filter(repairReviewDecisionSourceRefIsValid);
+}
+
+function repairActionDescriptorSignature(
+	descriptor: WorkspaceProposalRepairActionDescriptor,
+): string {
+	return stableStringify(descriptor);
+}
+
+function repairActionIntentSignature(intent: WorkspaceProposalRepairActionIntent): string {
+	return stableStringify({
+		kind: intent.kind,
+		intentId: intent.intentId,
+		descriptorId: intent.descriptorId,
+		repairRequestId: intent.repairRequestId,
+		actionKind: intent.actionKind,
+		applicationId: intent.applicationId,
+		proposalId: intent.proposalId,
+		decisionId: intent.decisionId,
+		idempotencyKey: intent.idempotencyKey,
+		proposalFamily: intent.proposalFamily,
+		reviewerRef: intent.reviewerRef,
+		actorRef: intent.actorRef,
+		capabilityRefs: intent.capabilityRefs,
+		policyRefs: intent.policyRefs,
+		sourceRefs: intent.sourceRefs,
+		audit: intent.audit,
+		metadata: intent.metadata,
+		expectedCurrentState: intent.expectedCurrentState,
+	});
+}
+
+function repairReviewDecisionRecordingInputSignature(
+	input: WorkspaceProposalRepairReviewDecisionRecordingInput,
+): string {
+	return stableStringify({
+		kind: input.kind,
+		repairRequestId: input.repairRequestId,
+		reviewDecisionId: input.reviewDecisionId,
+		intent: input.intent,
+		reviewerRef: input.reviewerRef,
+		actorRef: input.actorRef,
+		capabilityRefs: input.capabilityRefs,
+		policyRefs: input.policyRefs,
+		sourceRefs: input.sourceRefs,
+		audit: input.audit,
+		reason: input.reason,
+		code: input.code,
+		resolvesRefs: input.resolvesRefs,
+		supersedesRefs: input.supersedesRefs,
+		decidedAtMs: input.decidedAtMs,
+		metadata: input.metadata,
+		expectedCurrentState: input.expectedCurrentState,
+	});
+}
+
+function repairReviewDecisionRecordingResultKey(
+	result: WorkspaceProposalRepairReviewDecisionRecordingResult,
+): string {
+	return stableStringify(result);
+}
+
+function blockedRepairReviewDecisionRecordingResult(
+	input: WorkspaceProposalRepairReviewDecisionRecordingInput,
+	request: WorkspaceProposalRepairReviewRequest | undefined,
+	issues: readonly WorkspaceProposalRecordedIssue[],
+): WorkspaceProposalRepairReviewDecisionRecordingResult {
+	const audit =
+		safeWorkspaceProposalAudit(input.audit) ?? safeWorkspaceProposalAudit(request?.audit);
+	return {
+		kind: "workspace-proposal-repair-review-decision-recording-result",
+		status: "blocked",
+		decision: undefined,
+		issues: [...dedupeRecordingIssues(issues)],
+		sourceRefs: repairActionSourceRefs(input.sourceRefs ?? []),
+		...(audit === undefined ? {} : { audit }),
+	};
+}
+
+function conflictingRepairActionIntentValidationResult(
+	intent: WorkspaceProposalRepairActionIntent,
+): WorkspaceProposalRepairActionIntentValidationResult {
+	const audit = safeWorkspaceProposalAudit(intent.audit);
+	return {
+		kind: "workspace-proposal-repair-action-intent-validation-result",
+		status: "blocked",
+		intentId: intent.intentId,
+		descriptorId: intent.descriptorId,
+		repairRequestId: intent.repairRequestId,
+		actionKind: intent.actionKind,
+		applicationId: intent.applicationId,
+		proposalId: intent.proposalId,
+		decisionId: intent.decisionId,
+		idempotencyKey: intent.idempotencyKey,
+		proposalFamily: intent.proposalFamily,
+		issues: [conflictingRepairActionIntentIssue(intent)],
+		sourceRefs: repairActionSourceRefs(intent.sourceRefs ?? []),
+		...(audit === undefined ? {} : { audit }),
+	};
+}
+
+function conflictingRepairActionIntentIssue(
+	intent: WorkspaceProposalRepairActionIntent,
+): WorkspaceProposalRecordedIssue {
+	return repairActionIntentIssue(
+		"conflicting-repair-action-intent",
+		"Repair action intent facts conflict for the same intentId.",
+		intent,
+		undefined,
+	);
+}
+
+function repairReviewDecisionRecordingInputIssue(
+	code: string,
+	message: string,
+	input: WorkspaceProposalRepairReviewDecisionRecordingInput,
+	request: WorkspaceProposalRepairReviewRequest | undefined,
+): WorkspaceProposalRecordedIssue {
+	return {
+		kind: "issue",
+		source: "workspace-proposal",
+		severity: "error",
+		code,
+		message,
+		subjectId: request?.proposalId,
+		refs: [
+			...(blank(input.reviewDecisionId)
+				? []
+				: [`workspace-proposal-repair-review-decision:${input.reviewDecisionId}`]),
+			...(request === undefined
+				? [`workspace-proposal-repair-review-request:${input.repairRequestId}`]
+				: [`workspace-proposal-repair-review-request:${request.repairRequestId}`]),
+		],
+	};
+}
+
+function repairReviewDecisionRecordingIssues(
+	request: WorkspaceProposalRepairReviewRequest,
+	options: WorkspaceProposalRepairReviewDecisionRecordingOptions | undefined,
+): WorkspaceProposalRecordedIssue[] {
+	const issues: WorkspaceProposalRecordedIssue[] = [];
+	if (!isRecord(request) || request.kind !== "workspace-proposal-repair-review-request") {
+		issues.push(
+			repairReviewDecisionRecordingIssue(
+				"malformed-repair-review-request",
+				"Repair-review decision recording requires an existing repair-review request.",
+				undefined,
+			),
+		);
+		return issues;
+	}
+	if (!isRecord(options)) {
+		issues.push(
+			repairReviewDecisionRecordingIssue(
+				"malformed-recording-options",
+				"Repair-review decision recording requires data-only options material.",
+				request,
+			),
+		);
+		return issues;
+	}
+	const requestDataOnlyIssues = workspaceProposalDataOnlyIssues(request, "repairReviewRequest");
+	for (const entry of requestDataOnlyIssues) {
+		issues.push(repairReviewDecisionIssueFromDataOnly(entry, request));
+	}
+	const optionDataOnlyIssues = workspaceProposalDataOnlyIssues(
+		options,
+		"repairReviewDecisionOptions",
+	);
+	for (const entry of optionDataOnlyIssues) {
+		issues.push(repairReviewDecisionIssueFromDataOnly(entry, request));
+	}
+	if (requestDataOnlyIssues.length > 0 || optionDataOnlyIssues.length > 0) {
+		return [...dedupeRecordingIssues(issues)];
+	}
+	for (const [field, value] of [
+		["repairRequestId", request.repairRequestId],
+		["applicationId", request.applicationId],
+		["proposalId", request.proposalId],
+		["decisionId", request.decisionId],
+		["idempotencyKey", request.idempotencyKey],
+		["proposalFamily", request.proposalFamily],
+	] as const) {
+		if (blank(value)) {
+			issues.push(
+				repairReviewDecisionRecordingIssue(
+					"malformed-repair-review-request",
+					`Repair-review request requires ${field}.`,
+					request,
+				),
+			);
+		}
+	}
+	if (blank(options.reviewDecisionId)) {
+		issues.push(
+			repairReviewDecisionRecordingIssue(
+				"missing-review-decision-id",
+				"Repair-review decision recording requires a Workspace-supplied reviewDecisionId.",
+				request,
+			),
+		);
+	}
+	if (!repairReviewDecisionIntentIsKnown(options.intent)) {
+		issues.push(
+			repairReviewDecisionRecordingIssue(
+				"unsupported-repair-review-intent",
+				"Repair-review decision recording requires a supported lifecycle intent.",
+				request,
+			),
+		);
+	}
+	if (options.reviewerRef === undefined && options.actorRef === undefined) {
+		issues.push(
+			repairReviewDecisionRecordingIssue(
+				"missing-review-authority-material",
+				"Repair-review decision recording requires reviewer or actor ref material.",
+				request,
+			),
+		);
+	}
+	if (
+		(!Array.isArray(options.capabilityRefs) || options.capabilityRefs.length === 0) &&
+		(!Array.isArray(options.policyRefs) || options.policyRefs.length === 0)
+	) {
+		issues.push(
+			repairReviewDecisionRecordingIssue(
+				"missing-review-authority-material",
+				"Repair-review decision recording requires explicit capability or policy material.",
+				request,
+			),
+		);
+	}
+	if (!Array.isArray(options.sourceRefs) || options.sourceRefs.length === 0) {
+		issues.push(
+			repairReviewDecisionRecordingIssue(
+				"missing-review-audit-material",
+				"Repair-review decision recording requires explicit source refs.",
+				request,
+			),
+		);
+	}
+	if (options.audit === undefined) {
+		issues.push(
+			repairReviewDecisionRecordingIssue(
+				"missing-review-audit-material",
+				"Repair-review decision recording requires explicit audit material.",
+				request,
+			),
+		);
+	}
+	if (blank(options.reason) && blank(options.code)) {
+		issues.push(
+			repairReviewDecisionRecordingIssue(
+				"missing-review-audit-material",
+				"Repair-review decision recording requires reason or code material.",
+				request,
+			),
+		);
+	}
+	for (const field of [
+		"repairRequestId",
+		"applicationId",
+		"proposalId",
+		"decisionId",
+		"idempotencyKey",
+		"proposalFamily",
+	] as const) {
+		if (Object.hasOwn(options, field)) {
+			issues.push(
+				repairReviewDecisionRecordingIssue(
+					"coordinate-override-forbidden",
+					"Repair-review decision recording copies coordinates from the request.",
+					request,
+				),
+			);
+			break;
+		}
+	}
+	for (const [field, value] of [
+		["reviewerRef", options.reviewerRef],
+		["actorRef", options.actorRef],
+	] as const) {
+		if (value !== undefined && !repairReviewDecisionSourceRefIsValid(value)) {
+			issues.push(
+				repairReviewDecisionRecordingIssue(
+					"malformed-ref",
+					`Repair-review decision ${field} must be a data-only source ref.`,
+					request,
+				),
+			);
+		}
+	}
+	for (const [field, refs] of [
+		["capabilityRefs", options.capabilityRefs],
+		["policyRefs", options.policyRefs],
+		["sourceRefs", options.sourceRefs],
+		["resolvesRefs", options.resolvesRefs],
+		["supersedesRefs", options.supersedesRefs],
+	] as const) {
+		if (refs !== undefined && !repairReviewDecisionSourceRefsAreValid(refs)) {
+			issues.push(
+				repairReviewDecisionRecordingIssue(
+					"malformed-ref",
+					`Repair-review decision ${field} must be a dense array of data-only refs.`,
+					request,
+				),
+			);
+		}
+	}
+	if (options.audit !== undefined && !isWorkspaceProposalAuditMaterial(options.audit)) {
+		issues.push(
+			repairReviewDecisionRecordingIssue(
+				"malformed-audit",
+				"Repair-review decision audit material must be data-only audit material.",
+				request,
+			),
+		);
+	}
+	if (options.metadata !== undefined && !isRecord(options.metadata)) {
+		issues.push(
+			repairReviewDecisionRecordingIssue(
+				"malformed-metadata",
+				"Repair-review decision metadata must be data-only object material.",
+				request,
+			),
+		);
+	}
+	if (
+		options.decidedAtMs !== undefined &&
+		(typeof options.decidedAtMs !== "number" || !Number.isFinite(options.decidedAtMs))
+	) {
+		issues.push(
+			repairReviewDecisionRecordingIssue(
+				"malformed-decision-time",
+				"Repair-review decision time must be a finite number when supplied.",
+				request,
+			),
+		);
+	}
+	if (options.currentStatus !== undefined) {
+		if (
+			!isRepairReviewStatusMaterial(options.currentStatus) ||
+			!repairReviewCoordinatesMatch(request, options.currentStatus)
+		) {
+			issues.push(
+				repairReviewDecisionRecordingIssue(
+					"current-status-coordinate-mismatch",
+					"Repair-review current status guard must match the request coordinates.",
+					request,
+				),
+			);
+		}
+	}
+	if (options.expectedCurrentState !== undefined) {
+		if (!isRecord(options.expectedCurrentState)) {
+			issues.push(
+				repairReviewDecisionRecordingIssue(
+					"stale-repair-review-state",
+					"Repair-review expected current state guard must be data-only state material.",
+					request,
+				),
+			);
+		} else if (options.currentStatus === undefined) {
+			issues.push(
+				repairReviewDecisionRecordingIssue(
+					"stale-repair-review-state",
+					"Repair-review expected current state guard requires current status material.",
+					request,
+				),
+			);
+		} else if (
+			isRepairReviewStatusMaterial(options.currentStatus) &&
+			repairReviewCoordinatesMatch(request, options.currentStatus) &&
+			!repairReviewExpectedStateMatchesStatus(options.expectedCurrentState, options.currentStatus)
+		) {
+			issues.push(
+				repairReviewDecisionRecordingIssue(
+					"stale-repair-review-state",
+					"Repair-review current status no longer matches the expected guard state.",
+					request,
+				),
+			);
+		}
+	}
+	return [...dedupeRecordingIssues(issues)];
+}
+
+function repairReviewDecisionIntentIsKnown(
+	intent: unknown,
+): intent is WorkspaceProposalRepairReviewDecisionIntent {
+	return (
+		intent === "acknowledged" ||
+		intent === "resolved" ||
+		intent === "withdrawn" ||
+		intent === "superseded"
+	);
+}
+
+function repairReviewDecisionSourceRefIsValid(value: unknown): value is SourceRef {
+	return (
+		isSourceRef(value) &&
+		workspaceProposalDataOnlyIssues(value, "repairReviewDecisionRef").length === 0
+	);
+}
+
+function repairReviewDecisionSourceRefsAreValid(value: unknown): value is readonly SourceRef[] {
+	return (
+		Array.isArray(value) &&
+		isDenseArray(value) &&
+		value.every((entry) => repairReviewDecisionSourceRefIsValid(entry))
+	);
+}
+
+function isRepairReviewStatusMaterial(
+	value: unknown,
+): value is WorkspaceProposalRepairReviewStatus {
+	return (
+		isRecord(value) &&
+		value.kind === "workspace-proposal-repair-review-status" &&
+		nonBlankString(value.repairRequestId) &&
+		nonBlankString(value.applicationId) &&
+		nonBlankString(value.proposalId) &&
+		nonBlankString(value.decisionId) &&
+		nonBlankString(value.idempotencyKey) &&
+		nonBlankString(value.proposalFamily) &&
+		(value.state === "open" ||
+			value.state === "acknowledged" ||
+			value.state === "resolved" ||
+			value.state === "withdrawn" ||
+			value.state === "superseded" ||
+			value.state === "conflict") &&
+		Array.isArray(value.proofRefs) &&
+		Array.isArray(value.decisions) &&
+		Array.isArray(value.conflicts) &&
+		Array.isArray(value.issues) &&
+		Array.isArray(value.sourceRefs)
+	);
+}
+
+function isWorkspaceProposalAuditMaterial(value: unknown): value is WorkspaceProposalAuditMaterial {
+	if (!isRecord(value)) return false;
+	return (
+		(value.auditId === undefined || typeof value.auditId === "string") &&
+		(value.actorId === undefined || typeof value.actorId === "string") &&
+		(value.recordedAtMs === undefined ||
+			(typeof value.recordedAtMs === "number" && Number.isFinite(value.recordedAtMs))) &&
+		(value.reason === undefined || typeof value.reason === "string") &&
+		(value.sourceRefs === undefined || repairReviewDecisionSourceRefsAreValid(value.sourceRefs)) &&
+		(value.metadata === undefined || isRecord(value.metadata)) &&
+		workspaceProposalDataOnlyIssues(value, "repairReviewDecisionAudit").length === 0
+	);
+}
+
+function safeWorkspaceProposalAudit(value: unknown): WorkspaceProposalAuditMaterial | undefined {
+	try {
+		return isWorkspaceProposalAuditMaterial(value)
+			? immutableClone(value as WorkspaceProposalAuditMaterial)
+			: undefined;
+	} catch {
+		return undefined;
+	}
+}
+
+function repairReviewExpectedStateMatchesStatus(
+	expected: WorkspaceProposalRepairReviewExpectedCurrentState,
+	status: WorkspaceProposalRepairReviewStatus,
+): boolean {
+	if (expected.state !== undefined && expected.state !== status.state) return false;
+	if (expected.code !== undefined && expected.code !== status.code) return false;
+	if (expected.proofKind !== undefined && expected.proofKind !== status.proofKind) return false;
+	if (
+		expected.proofRefs !== undefined &&
+		(!repairReviewDecisionSourceRefsAreValid(expected.proofRefs) ||
+			stableStringify(expected.proofRefs) !== stableStringify(status.proofRefs))
+	) {
+		return false;
+	}
+	return true;
+}
+
+function repairReviewDecisionIssueFromDataOnly(
+	issue: WorkspaceProposalRecordedIssue,
+	request: WorkspaceProposalRepairReviewRequest,
+): WorkspaceProposalRecordedIssue {
+	return {
+		...issue,
+		subjectId: issue.subjectId ?? request.proposalId,
+		refs: issue.refs ?? [`workspace-proposal-repair-review-request:${request.repairRequestId}`],
+	};
+}
+
+function repairReviewDecisionRecordingIssue(
+	code: string,
+	message: string,
+	request: WorkspaceProposalRepairReviewRequest | undefined,
+): WorkspaceProposalRecordedIssue {
+	return {
+		kind: "issue",
+		source: "workspace-proposal",
+		severity: "error",
+		code,
+		message,
+		...(request === undefined ? {} : { subjectId: request.proposalId }),
+		refs:
+			request === undefined
+				? []
+				: [`workspace-proposal-repair-review-request:${request.repairRequestId}`],
+	};
+}
+
+function dedupeRecordingIssues(
+	issues: readonly WorkspaceProposalRecordedIssue[],
+): readonly WorkspaceProposalRecordedIssue[] {
+	const out = new Map<string, WorkspaceProposalRecordedIssue>();
+	for (const issue of issues) out.set(stableStringify(issue), issue);
+	return [...out.values()];
+}
+
+function readModelCoordinates(input: WorkspaceProposalFamilyApplicationReadModelProjectionInput): {
+	readonly applicationId?: string;
+	readonly proposalId?: string;
+	readonly decisionId?: string;
+	readonly idempotencyKey?: string;
+	readonly proposalFamily?: WorkspaceProposalFamily;
+} {
+	return {
+		applicationId: stringField(input.applicationId),
+		proposalId: stringField(input.proposalId),
+		decisionId: stringField(input.decisionId),
+		idempotencyKey: stringField(input.idempotencyKey),
+		proposalFamily: stringField(input.proposalFamily) as WorkspaceProposalFamily | undefined,
+	};
+}
+
+function readModelCoordinatesComplete(coordinates: {
+	readonly applicationId?: string;
+	readonly proposalId?: string;
+	readonly decisionId?: string;
+	readonly idempotencyKey?: string;
+	readonly proposalFamily?: WorkspaceProposalFamily;
+}): coordinates is {
+	readonly applicationId: string;
+	readonly proposalId: string;
+	readonly decisionId: string;
+	readonly idempotencyKey: string;
+	readonly proposalFamily: WorkspaceProposalFamily;
+} {
+	return (
+		coordinates.applicationId !== undefined &&
+		coordinates.proposalId !== undefined &&
+		coordinates.decisionId !== undefined &&
+		coordinates.idempotencyKey !== undefined &&
+		coordinates.proposalFamily !== undefined
+	);
+}
+
+function coordinatesMatchExact(
+	expected: {
+		readonly applicationId: string;
+		readonly proposalId: string;
+		readonly decisionId: string;
+		readonly idempotencyKey: string;
+		readonly proposalFamily: WorkspaceProposalFamily;
+	},
+	material: {
+		readonly applicationId?: string;
+		readonly proposalId?: string;
+		readonly decisionId?: string;
+		readonly idempotencyKey?: string;
+		readonly proposalFamily?: WorkspaceProposalFamily;
+	},
+): boolean {
+	return (
+		material.applicationId === expected.applicationId &&
+		material.proposalId === expected.proposalId &&
+		material.decisionId === expected.decisionId &&
+		material.idempotencyKey === expected.idempotencyKey &&
+		material.proposalFamily === expected.proposalFamily
+	);
+}
+
+function sameOutcomeRefCoordinates(
+	ref: WorkspaceProposalFamilyOutcomeRef,
+	material:
+		| WorkspaceProposalFamilyOutcomeRecord
+		| WorkspaceProposalFamilyOutcomeRecordStatus
+		| WorkspaceProposalFamilyOutcomeIndexEntry,
+): boolean {
+	const coordinatesMatch =
+		ref.applicationId === material.applicationId &&
+		ref.proposalId === material.proposalId &&
+		ref.decisionId === material.decisionId &&
+		ref.idempotencyKey === material.idempotencyKey &&
+		ref.proposalFamily === material.proposalFamily;
+	if (!coordinatesMatch) return false;
+	if (material.kind === "workspace-proposal-family-outcome-index-entry") {
+		return material.outcomeRefs.some(
+			(entry) => entry.outcomeId === ref.outcomeId && entry.outcomeKind === ref.outcomeKind,
+		);
+	}
+	if (material.kind === "workspace-proposal-family-outcome-record-status") {
+		return (
+			material.outcomeId === ref.outcomeId &&
+			material.outcomeRefs.some(
+				(entry) => entry.outcomeId === ref.outcomeId && entry.outcomeKind === ref.outcomeKind,
+			)
+		);
+	}
+	return material.outcomeId === ref.outcomeId && material.kind === ref.outcomeKind;
+}
+
+function groupByOutcomeId<T extends { readonly outcomeId: string }>(
+	items: readonly T[],
+): ReadonlyMap<string, readonly T[]> {
+	const groups = new Map<string, T[]>();
+	for (const item of items)
+		groups.set(item.outcomeId, [...(groups.get(item.outcomeId) ?? []), item]);
+	return groups;
+}
+
+function readModelDisplayDiagnostic(
+	code: WorkspaceProposalFamilyApplicationReadModelDisplayDiagnostic["code"],
+	outcomeRef: WorkspaceProposalFamilyOutcomeRef,
+): WorkspaceProposalFamilyApplicationReadModelDisplayDiagnostic {
+	const message =
+		code === "missing-outcome-detail"
+			? "Workspace proposal family outcome detail was not supplied"
+			: code === "mismatched-outcome-detail"
+				? "Workspace proposal family outcome detail mismatches its thin ref"
+				: "Workspace proposal family outcome status mismatches its thin ref";
+	return {
+		kind: "workspace-proposal-family-application-read-model-display-diagnostic",
+		diagnosticId: `workspace-proposal-family-application-read-model-display-diagnostic:${stableStringify(
+			{
+				code,
+				outcomeRef,
+			},
+		)}`,
+		code,
+		message,
+		applicationId: outcomeRef.applicationId,
+		proposalId: outcomeRef.proposalId,
+		decisionId: outcomeRef.decisionId,
+		idempotencyKey: outcomeRef.idempotencyKey,
+		proposalFamily: outcomeRef.proposalFamily,
+		outcomeRef,
+		sourceRefs: outcomeRef.sourceRefs,
+	};
+}
+
+interface NormalizedReadModelQuery {
+	readonly complete: boolean;
+	readonly malformed: boolean;
+	readonly queryId?: string;
+	readonly viewId?: string;
+	readonly coordinates: {
+		readonly applicationId?: string;
+		readonly proposalId?: string;
+		readonly decisionId?: string;
+		readonly idempotencyKey?: string;
+		readonly proposalFamily?: WorkspaceProposalFamily;
+	};
+	readonly page: {
+		readonly offset: number;
+		readonly limit: number;
+	};
+	readonly filters: WorkspaceProposalFamilyApplicationReadModelNormalizedFilters;
+	readonly sort: readonly WorkspaceProposalFamilyApplicationReadModelSortOption[];
+	readonly groupBy: readonly WorkspaceProposalFamilyApplicationReadModelGroupField[];
+	readonly search: WorkspaceProposalFamilyApplicationReadModelNormalizedSearch;
+	readonly sourceRefs: readonly SourceRef[];
+}
+
+interface NormalizedReadModelFilterResult {
+	readonly filters: WorkspaceProposalFamilyApplicationReadModelNormalizedFilters;
+	readonly malformed: boolean;
+}
+
+function normalizeReadModelQuery(
+	query: WorkspaceProposalFamilyApplicationReadModelQuery,
+): NormalizedReadModelQuery {
+	const queryRecord: Record<string, unknown> = isRecord(query) ? query : {};
+	const sourceRefResult = readModelQuerySourceRefs(queryRecord.sourceRefs);
+	const auditSourceRefResult = readModelQuerySourceRefs(
+		isRecord(queryRecord.audit) ? queryRecord.audit.sourceRefs : undefined,
+	);
+	const dataOnlyIssues = workspaceProposalDataOnlyIssues(query, "readModelQuery");
+	const coordinates = {
+		applicationId: stringField(queryRecord.applicationId),
+		proposalId: stringField(queryRecord.proposalId),
+		decisionId: stringField(queryRecord.decisionId),
+		idempotencyKey: stringField(queryRecord.idempotencyKey),
+		proposalFamily: stringField(queryRecord.proposalFamily) as WorkspaceProposalFamily | undefined,
+	};
+	const page = isRecord(queryRecord.page) ? queryRecord.page : {};
+	const kind = stringField(queryRecord.kind);
+	const queryId = stringField(queryRecord.queryId);
+	const filterResult = normalizeReadModelFilters(
+		isRecord(queryRecord.filters) ? queryRecord.filters : undefined,
+	);
+	const presentation = normalizeReadModelPresentationOptions(
+		queryRecord.sort,
+		queryRecord.groupBy,
+		isRecord(queryRecord.search) ? queryRecord.search : queryRecord.search,
+	);
+	const complete =
+		queryId !== undefined &&
+		readModelCoordinatesComplete(coordinates) &&
+		kind === "workspace-proposal-family-application-read-model-query";
+	const malformed =
+		kind !== "workspace-proposal-family-application-read-model-query" ||
+		queryId === undefined ||
+		(queryRecord.sourceRefs !== undefined && !Array.isArray(queryRecord.sourceRefs)) ||
+		sourceRefResult.malformed ||
+		auditSourceRefResult.malformed ||
+		filterResult.malformed ||
+		presentation.malformed ||
+		dataOnlyIssues.length > 0;
+	return {
+		complete,
+		malformed,
+		queryId,
+		viewId: stringField(queryRecord.viewId),
+		coordinates,
+		page: {
+			offset: normalizePageOffset(page.offset),
+			limit: normalizePageLimit(page.limit),
+		},
+		filters: filterResult.filters,
+		sort: presentation.sort,
+		groupBy: presentation.groupBy,
+		search: presentation.search,
+		sourceRefs: uniqueRefs([...sourceRefResult.refs, ...auditSourceRefResult.refs]),
+	};
+}
+
+function readModelQueryDisplayDiagnostic(
+	code: "incomplete-read-model-query" | "malformed-read-model-query",
+	normalized: NormalizedReadModelQuery,
+): WorkspaceProposalFamilyApplicationReadModelDisplayDiagnostic {
+	return {
+		kind: "workspace-proposal-family-application-read-model-display-diagnostic",
+		diagnosticId: `workspace-proposal-family-application-read-model-display-diagnostic:${stableStringify(
+			{
+				code,
+				queryId: normalized.queryId,
+				viewId: normalized.viewId,
+				coordinates: normalized.coordinates,
+				page: normalized.page,
+				filters: normalized.filters,
+				sort: normalized.sort,
+				groupBy: normalized.groupBy,
+				search: normalized.search,
+			},
+		)}`,
+		code,
+		message:
+			code === "malformed-read-model-query"
+				? "Workspace proposal family read-model query is malformed"
+				: "Workspace proposal family read-model query is incomplete",
+		...(normalized.queryId === undefined ? {} : { queryId: normalized.queryId }),
+		...(normalized.viewId === undefined ? {} : { viewId: normalized.viewId }),
+		...normalized.coordinates,
+		sourceRefs: normalized.sourceRefs,
+	};
+}
+
+function readModelQuerySourceRefs(value: unknown): {
+	readonly refs: readonly SourceRef[];
+	readonly malformed: boolean;
+} {
+	if (value === undefined) return { refs: [], malformed: false };
+	if (!Array.isArray(value)) return { refs: [], malformed: true };
+	const refs: SourceRef[] = [];
+	let malformed = false;
+	for (const entry of value) {
+		if (!isSourceRef(entry) || workspaceProposalDataOnlyIssues(entry, "sourceRef").length > 0) {
+			malformed = true;
+			continue;
+		}
+		refs.push(entry);
+	}
+	return { refs: uniqueRefs(refs), malformed };
+}
+
+function normalizeReadModelFilters(
+	filters: WorkspaceProposalFamilyApplicationReadModelFilters | undefined,
+): NormalizedReadModelFilterResult {
+	const outcomeKinds = normalizeClosedStringFilter(
+		filters?.outcomeKinds,
+		workspaceProposalFamilyOutcomeKinds,
+	);
+	const repairStates = normalizeClosedStringFilter(
+		filters?.repairStates,
+		workspaceProposalRepairReviewLifecycleStates,
+	);
+	return {
+		filters: {
+			outcomeIds: normalizeStringFilter(filters?.outcomeIds),
+			outcomeKinds: outcomeKinds.values,
+			diagnosticCodes: normalizeStringFilter(filters?.diagnosticCodes),
+			repairStates: repairStates.values,
+		},
+		malformed: outcomeKinds.malformed || repairStates.malformed,
+	};
+}
+
+interface NormalizedReadModelPresentationResult {
+	readonly sort: readonly WorkspaceProposalFamilyApplicationReadModelSortOption[];
+	readonly groupBy: readonly WorkspaceProposalFamilyApplicationReadModelGroupField[];
+	readonly search: WorkspaceProposalFamilyApplicationReadModelNormalizedSearch;
+	readonly diagnostics: readonly WorkspaceProposalFamilyApplicationReadModelDisplayDiagnostic[];
+	readonly malformed: boolean;
+}
+
+function normalizeReadModelPresentationOptions(
+	sort: unknown,
+	groupBy: unknown,
+	search: unknown,
+): NormalizedReadModelPresentationResult {
+	const sortResult = normalizeReadModelSort(sort);
+	const groupResult = normalizeClosedStringFilter(
+		Array.isArray(groupBy) ? groupBy : groupBy === undefined ? undefined : [groupBy],
+		readModelGroupFields,
+	);
+	const searchResult = normalizeReadModelSearch(search);
+	const malformed =
+		sortResult.malformed ||
+		groupResult.malformed ||
+		searchResult.malformed ||
+		(sort !== undefined && !Array.isArray(sort)) ||
+		(groupBy !== undefined && !Array.isArray(groupBy));
+	const diagnostics = malformed
+		? [readModelPresentationDiagnostic(sortResult.sort, groupResult.values, searchResult.search)]
+		: [];
+	return {
+		sort: sortResult.sort,
+		groupBy: groupResult.values,
+		search: searchResult.search,
+		diagnostics,
+		malformed,
+	};
+}
+
+function normalizeReadModelSort(sort: unknown): {
+	readonly sort: readonly WorkspaceProposalFamilyApplicationReadModelSortOption[];
+	readonly malformed: boolean;
+} {
+	if (sort === undefined) return { sort: [], malformed: false };
+	if (!Array.isArray(sort)) return { sort: [], malformed: true };
+	const allowedFields = new Set<string>(readModelSortFields);
+	const allowedDirections = new Set<string>(["asc", "desc"]);
+	const byField = new Map<
+		WorkspaceProposalFamilyApplicationReadModelSortField,
+		WorkspaceProposalFamilyApplicationReadModelSortDirection
+	>();
+	let malformed = false;
+	for (const entry of sort) {
+		if (!isRecord(entry)) {
+			malformed = true;
+			continue;
+		}
+		const field = stringField(entry.field);
+		const direction = stringField(entry.direction);
+		if (
+			field === undefined ||
+			direction === undefined ||
+			!allowedFields.has(field) ||
+			!allowedDirections.has(direction)
+		) {
+			malformed = true;
+			continue;
+		}
+		byField.set(
+			field as WorkspaceProposalFamilyApplicationReadModelSortField,
+			direction as WorkspaceProposalFamilyApplicationReadModelSortDirection,
+		);
+	}
+	return {
+		sort: [...byField.entries()].map(([field, direction]) => ({ field, direction })),
+		malformed,
+	};
+}
+
+function normalizeReadModelSearch(search: unknown): {
+	readonly search: WorkspaceProposalFamilyApplicationReadModelNormalizedSearch;
+	readonly malformed: boolean;
+} {
+	if (search === undefined) return { search: { text: "", fields: [] }, malformed: false };
+	if (!isRecord(search)) return { search: { text: "", fields: [] }, malformed: true };
+	const fieldResult = normalizeClosedStringFilter(
+		Array.isArray(search.fields) ? search.fields : undefined,
+		readModelSearchFields,
+	);
+	return {
+		search: {
+			text: boundedSearchText(search.text),
+			fields: fieldResult.values.length === 0 ? [...readModelSearchFields] : fieldResult.values,
+		},
+		malformed:
+			fieldResult.malformed ||
+			(search.fields !== undefined && !Array.isArray(search.fields)) ||
+			(search.text !== undefined && typeof search.text !== "string"),
+	};
+}
+
+function boundedSearchText(value: unknown): string {
+	return typeof value === "string" ? value.trim().slice(0, 128) : "";
+}
+
+function readModelPresentationDiagnostic(
+	sort: readonly WorkspaceProposalFamilyApplicationReadModelSortOption[],
+	groupBy: readonly WorkspaceProposalFamilyApplicationReadModelGroupField[],
+	search: WorkspaceProposalFamilyApplicationReadModelNormalizedSearch,
+): WorkspaceProposalFamilyApplicationReadModelDisplayDiagnostic {
+	return {
+		kind: "workspace-proposal-family-application-read-model-display-diagnostic",
+		diagnosticId: `workspace-proposal-family-application-read-model-display-diagnostic:${stableStringify(
+			{
+				code: "malformed-read-model-presentation-options",
+				sort,
+				groupBy,
+				search,
+			},
+		)}`,
+		code: "malformed-read-model-presentation-options",
+		message: "Workspace proposal family read-model presentation options are malformed",
+		sourceRefs: [],
+	};
+}
+
+function normalizeStringFilter(values: readonly unknown[] | undefined): readonly string[] {
+	if (!Array.isArray(values)) return [];
+	return [...new Set(values.map(stringField).filter((value) => value !== undefined))].sort();
+}
+
+function normalizeClosedStringFilter<T extends string>(
+	values: readonly unknown[] | undefined,
+	allowedValues: readonly T[],
+): { readonly values: readonly T[]; readonly malformed: boolean } {
+	if (!Array.isArray(values)) return { values: [], malformed: false };
+	const allowed = new Set<string>(allowedValues);
+	const normalized = normalizeStringFilter(values);
+	return {
+		values: normalized.filter((value): value is T => allowed.has(value)),
+		malformed: normalized.some((value) => !allowed.has(value)),
+	};
+}
+
+const workspaceProposalFamilyOutcomeKinds = [
+	"workspace-proposal-required-input-response-outcome-recorded",
+	"workspace-proposal-work-item-spawn-outcome-recorded",
+	"workspace-proposal-work-item-link-outcome-recorded",
+	"workspace-proposal-domain-action-outcome-recorded",
+] as const satisfies readonly WorkspaceProposalFamilyOutcomeRecord["kind"][];
+
+const workspaceProposalRepairReviewLifecycleStates = [
+	"open",
+	"acknowledged",
+	"resolved",
+	"withdrawn",
+	"superseded",
+	"conflict",
+] as const satisfies readonly WorkspaceProposalRepairReviewLifecycleState[];
+
+const readModelSortFields = [
+	"diagnostic-code",
+	"outcome-id",
+	"outcome-kind",
+	"recorded-at-ms",
+	"repair-state",
+] as const satisfies readonly WorkspaceProposalFamilyApplicationReadModelSortField[];
+
+const readModelGroupFields = [
+	"diagnostic-code",
+	"outcome-kind",
+	"repair-state",
+] as const satisfies readonly WorkspaceProposalFamilyApplicationReadModelGroupField[];
+
+const readModelSearchFields = [
+	"diagnostic-code",
+	"diagnostic-message",
+	"outcome-id",
+	"outcome-kind",
+	"repair-state",
+] as const satisfies readonly WorkspaceProposalFamilyApplicationReadModelSearchField[];
+
+function matchesOptionalSet<T extends string>(values: readonly T[], value: T): boolean {
+	return values.length === 0 || values.includes(value);
+}
+
+function filterOutcomeIndexEntry(
+	entry: WorkspaceProposalFamilyOutcomeIndexEntry,
+	filters: WorkspaceProposalFamilyApplicationReadModelNormalizedFilters,
+): WorkspaceProposalFamilyOutcomeIndexEntry {
+	if (filters.outcomeIds.length === 0 && filters.outcomeKinds.length === 0) return entry;
+	const outcomeRefs = entry.outcomeRefs.filter(
+		(ref) =>
+			matchesOptionalSet(filters.outcomeIds, ref.outcomeId) &&
+			matchesOptionalSet(filters.outcomeKinds, ref.outcomeKind),
+	);
+	return {
+		...entry,
+		outcomeRefs,
+	};
+}
+
+function readModelSearchMatches(
+	ref: WorkspaceProposalFamilyOutcomeRef,
+	search: WorkspaceProposalFamilyApplicationReadModelNormalizedSearch,
+	diagnostics: readonly WorkspaceProposalFamilyApplicationDiagnostic[],
+	repairReviewStatuses: readonly WorkspaceProposalRepairReviewStatus[],
+): boolean {
+	if (search.text === "") return true;
+	const text = search.text.toLowerCase();
+	const haystack: string[] = [];
+	const fields = new Set(search.fields);
+	if (fields.has("outcome-id")) haystack.push(ref.outcomeId);
+	if (fields.has("outcome-kind")) haystack.push(ref.outcomeKind);
+	if (fields.has("diagnostic-code") || fields.has("diagnostic-message")) {
+		for (const diagnostic of diagnostics) {
+			if (!coordinatesMatchExact(ref, diagnostic)) continue;
+			if (fields.has("diagnostic-code")) haystack.push(diagnostic.code);
+			if (fields.has("diagnostic-message")) {
+				for (const issue of diagnostic.issues) haystack.push(issue.message);
+			}
+		}
+	}
+	if (fields.has("repair-state")) {
+		for (const status of repairReviewStatuses) {
+			if (coordinatesMatchExact(ref, status)) haystack.push(status.state);
+		}
+	}
+	return haystack.some((value) => value.toLowerCase().includes(text));
+}
+
+function sortReadModelOutcomeRefs(
+	refs: readonly WorkspaceProposalFamilyOutcomeRef[],
+	sort: readonly WorkspaceProposalFamilyApplicationReadModelSortOption[],
+	diagnostics: readonly WorkspaceProposalFamilyApplicationDiagnostic[],
+	repairReviewStatuses: readonly WorkspaceProposalRepairReviewStatus[],
+	outcomes: ReadonlyMap<string, readonly WorkspaceProposalFamilyOutcomeRecord[]>,
+	statuses: ReadonlyMap<string, readonly WorkspaceProposalFamilyOutcomeRecordStatus[]>,
+): readonly WorkspaceProposalFamilyOutcomeRef[] {
+	if (sort.length === 0) return refs;
+	return [...refs].sort((left, right) => {
+		for (const option of sort) {
+			const compared = compareReadModelSortValue(
+				readModelSortValue(
+					left,
+					option.field,
+					diagnostics,
+					repairReviewStatuses,
+					outcomes,
+					statuses,
+				),
+				readModelSortValue(
+					right,
+					option.field,
+					diagnostics,
+					repairReviewStatuses,
+					outcomes,
+					statuses,
+				),
+			);
+			if (compared !== 0) return option.direction === "asc" ? compared : -compared;
+		}
+		return compareReadModelSortValue(left.outcomeId, right.outcomeId);
+	});
+}
+
+function readModelSortValue(
+	ref: WorkspaceProposalFamilyOutcomeRef,
+	field: WorkspaceProposalFamilyApplicationReadModelSortField,
+	diagnostics: readonly WorkspaceProposalFamilyApplicationDiagnostic[],
+	repairReviewStatuses: readonly WorkspaceProposalRepairReviewStatus[],
+	outcomes: ReadonlyMap<string, readonly WorkspaceProposalFamilyOutcomeRecord[]>,
+	statuses: ReadonlyMap<string, readonly WorkspaceProposalFamilyOutcomeRecordStatus[]>,
+): string | number {
+	switch (field) {
+		case "outcome-id":
+			return ref.outcomeId;
+		case "outcome-kind":
+			return ref.outcomeKind;
+		case "diagnostic-code":
+			return diagnostics.find((diagnostic) => coordinatesMatchExact(ref, diagnostic))?.code ?? "";
+		case "repair-state":
+			return repairReviewStatuses.find((status) => coordinatesMatchExact(ref, status))?.state ?? "";
+		case "recorded-at-ms": {
+			const outcome = (outcomes.get(ref.outcomeId) ?? []).find((entry) =>
+				sameOutcomeRefCoordinates(ref, entry),
+			);
+			const status = (statuses.get(ref.outcomeId) ?? []).find((entry) =>
+				sameOutcomeRefCoordinates(ref, entry),
+			);
+			return outcome?.audit?.recordedAtMs ?? status?.audit?.recordedAtMs ?? 0;
+		}
+	}
+}
+
+function compareReadModelSortValue(left: string | number, right: string | number): number {
+	if (typeof left === "number" && typeof right === "number") return left - right;
+	const leftString = String(left);
+	const rightString = String(right);
+	if (leftString < rightString) return -1;
+	if (leftString > rightString) return 1;
+	return 0;
+}
+
+function readModelDisplayGroups(
+	refs: readonly WorkspaceProposalFamilyOutcomeRef[],
+	groupBy: readonly WorkspaceProposalFamilyApplicationReadModelGroupField[],
+	diagnostics: readonly WorkspaceProposalFamilyApplicationDiagnostic[],
+	repairReviewStatuses: readonly WorkspaceProposalRepairReviewStatus[],
+): readonly WorkspaceProposalFamilyApplicationReadModelDisplayGroup[] {
+	const groups: WorkspaceProposalFamilyApplicationReadModelDisplayGroup[] = [];
+	for (const field of groupBy) {
+		const byValue = new Map<string, WorkspaceProposalFamilyOutcomeRef[]>();
+		for (const ref of refs) {
+			for (const value of readModelGroupValues(ref, field, diagnostics, repairReviewStatuses)) {
+				byValue.set(value, [...(byValue.get(value) ?? []), ref]);
+			}
+		}
+		for (const [value, outcomeRefs] of [...byValue.entries()].sort(([left], [right]) =>
+			compareReadModelSortValue(left, right),
+		)) {
+			groups.push({
+				kind: "workspace-proposal-family-application-read-model-display-group",
+				field,
+				value,
+				outcomeRefs,
+				count: outcomeRefs.length,
+			});
+		}
+	}
+	return groups;
+}
+
+function readModelGroupValues(
+	ref: WorkspaceProposalFamilyOutcomeRef,
+	field: WorkspaceProposalFamilyApplicationReadModelGroupField,
+	diagnostics: readonly WorkspaceProposalFamilyApplicationDiagnostic[],
+	repairReviewStatuses: readonly WorkspaceProposalRepairReviewStatus[],
+): readonly string[] {
+	switch (field) {
+		case "outcome-kind":
+			return [ref.outcomeKind];
+		case "repair-state":
+			return uniqueStrings(
+				repairReviewStatuses
+					.filter((status) => coordinatesMatchExact(ref, status))
+					.map((status) => status.state),
+			);
+		case "diagnostic-code":
+			return uniqueStrings(
+				diagnostics
+					.filter((diagnostic) => coordinatesMatchExact(ref, diagnostic))
+					.map((diagnostic) => diagnostic.code),
+			);
+	}
+}
+
+function normalizePageOffset(value: unknown): number {
+	return typeof value === "number" && Number.isFinite(value) && value > 0 ? Math.floor(value) : 0;
+}
+
+function normalizePageLimit(value: unknown): number {
+	if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) return 50;
+	return Math.min(100, Math.floor(value));
+}
+
+function readModelSignature(readModel: WorkspaceProposalFamilyApplicationReadModel): string {
+	return stableStringify({
+		queryId: readModel.queryId,
+		viewId: readModel.viewId,
+		filters: readModel.filters,
+		diagnostics: readModel.diagnostics,
+		repairReviewStatuses: readModel.repairReviewStatuses,
+		outcomeIndexes: readModel.outcomeIndexes,
+		outcomeDetails: readModel.outcomeDetails,
+		displayDiagnostics: readModel.displayDiagnostics,
+		page: readModel.page,
+	});
+}
+
+function readModelCurrentViewKey(readModel: WorkspaceProposalFamilyApplicationReadModel): string {
+	return stableStringify({
+		currentViewId: readModel.viewId ?? readModel.queryId ?? readModel.readModelId,
+	});
+}
+
+function readModelEmissionSignature(
+	readModel: WorkspaceProposalFamilyApplicationReadModel,
+): string {
+	return stableStringify({
+		readModelId: readModel.readModelId,
+		signature: readModelSignature(readModel),
+	});
+}
+
+function diagnosticClassForIssue(
+	issue: WorkspaceProposalRecordedIssue,
+): WorkspaceProposalFamilyApplicationDiagnosticClass | undefined {
+	switch (issue.code) {
+		case "missing-workspace-proposal-recorded":
+		case "missing-workspace-proposal-admission-decision":
+			return "missing-durable-handoff";
+		case "idempotency-conflict":
+			return "idempotency-conflict";
+		case "missing-required-input-gate":
+		case "missing-domain-action-facts":
+		case "missing-family-application-ref":
+		case "application-not-recordable":
+		case "application-status-has-issues":
+		case "missing-required-field":
+			return "missing-family-material";
+		case "malformed-family-draft":
+		case "malformed-family-context":
+		case "malformed-family-evidence-horizon":
+		case "malformed-family-completion-policy":
+		case "malformed-application-status":
+		case "forbidden-runtime-material":
+			return "malformed-family-material";
+		default:
+			return undefined;
+	}
+}
+
+function diagnosticClassForApplicationStatus(
+	status: WorkspaceProposalApplicationStatus,
+): WorkspaceProposalFamilyApplicationDiagnosticClass | undefined {
+	if (status.state === "idempotency-conflict") return "idempotency-conflict";
+	const issueClass = firstDiagnosticClass(status.issues);
+	if (status.state === "repair-needed") return issueClass ?? "missing-family-material";
+	return issueClass === "missing-durable-handoff" ? undefined : issueClass;
+}
+
+function diagnosticClassForOutcomeStatus(
+	status: WorkspaceProposalFamilyOutcomeRecordStatus,
+): WorkspaceProposalFamilyApplicationDiagnosticClass | undefined {
+	if (status.state === "idempotency-conflict") return "idempotency-conflict";
+	if (status.state === "repair-needed" || status.state === "pending") {
+		const issueClass = firstDiagnosticClass(status.issues);
+		return issueClass ?? "missing-family-material";
+	}
+	return firstDiagnosticClass(status.issues);
+}
+
+function firstDiagnosticClass(
+	issues: readonly WorkspaceProposalRecordedIssue[],
+): WorkspaceProposalFamilyApplicationDiagnosticClass | undefined {
+	for (const issue of issues) {
+		const classification = diagnosticClassForIssue(issue);
+		if (classification !== undefined) return classification;
+	}
+	return undefined;
+}
+
+function diagnosticFromIssue(
+	issue: WorkspaceProposalRecordedIssue,
+	classification: WorkspaceProposalFamilyApplicationDiagnosticClass,
+): WorkspaceProposalFamilyApplicationDiagnostic {
+	const metadata = isRecord(issue.metadata) ? issue.metadata : {};
+	const applicationId = stringField(metadata.applicationId);
+	const proposalId = stringField(metadata.proposalId) ?? issue.subjectId;
+	const decisionId = stringField(metadata.decisionId);
+	return {
+		kind: "workspace-proposal-family-application-diagnostic",
+		diagnosticId: diagnosticId({
+			classification,
+			code: issue.code,
+			applicationId,
+			proposalId,
+			decisionId,
+			refs: issue.refs,
+		}),
+		classification,
+		applicationId,
+		proposalId,
+		decisionId,
+		code: issue.code,
+		issues: [issue],
+		sourceRefs: [],
+		metadata: { refs: issue.refs },
+	};
+}
+
+function diagnosticFromAudit(
+	audit: WorkspaceProposalFamilyApplicationAuditRecord,
+	classification: WorkspaceProposalFamilyApplicationDiagnosticClass,
+): WorkspaceProposalFamilyApplicationDiagnostic {
+	const code = audit.code ?? classification;
+	return {
+		kind: "workspace-proposal-family-application-diagnostic",
+		diagnosticId: diagnosticId({
+			classification,
+			code,
+			applicationId: audit.applicationId,
+			proposalId: audit.proposalId,
+			decisionId: audit.decisionId,
+			proposalFamily: audit.proposalFamily,
+		}),
+		classification,
+		applicationId: audit.applicationId,
+		proposalId: audit.proposalId,
+		decisionId: audit.decisionId,
+		proposalFamily: audit.proposalFamily,
+		code,
+		issues: audit.issues ?? [],
+		sourceRefs: audit.sourceRefs ?? [],
+		audit: audit.audit,
+		metadata: audit.metadata,
+	};
+}
+
+function diagnosticFromApplicationStatus(
+	status: WorkspaceProposalApplicationStatus,
+	classification: WorkspaceProposalFamilyApplicationDiagnosticClass,
+): WorkspaceProposalFamilyApplicationDiagnostic {
+	const code = status.code ?? status.issues[0]?.code ?? status.state;
+	return {
+		kind: "workspace-proposal-family-application-diagnostic",
+		diagnosticId: diagnosticId({
+			classification,
+			code,
+			applicationId: status.applicationId,
+			proposalId: status.proposalId,
+			decisionId: status.decisionId,
+			idempotencyKey: status.idempotencyKey,
+			proposalFamily: status.proposalFamily,
+		}),
+		classification,
+		applicationId: status.applicationId,
+		proposalId: status.proposalId,
+		decisionId: status.decisionId,
+		idempotencyKey: status.idempotencyKey,
+		proposalFamily: status.proposalFamily,
+		code,
+		issues: status.issues,
+		sourceRefs: status.sourceRefs,
+		audit: status.audit,
+		metadata: status.metadata,
+	};
+}
+
+function diagnosticFromOutcomeStatus(
+	status: WorkspaceProposalFamilyOutcomeRecordStatus,
+	classification: WorkspaceProposalFamilyApplicationDiagnosticClass,
+): WorkspaceProposalFamilyApplicationDiagnostic {
+	const code = status.code ?? status.issues[0]?.code ?? status.state;
+	return {
+		kind: "workspace-proposal-family-application-diagnostic",
+		diagnosticId: diagnosticId({
+			classification,
+			code,
+			applicationId: status.applicationId,
+			proposalId: status.proposalId,
+			decisionId: status.decisionId,
+			idempotencyKey: status.idempotencyKey,
+			proposalFamily: status.proposalFamily,
+			outcomeId: status.outcomeId,
+		}),
+		classification,
+		applicationId: status.applicationId,
+		proposalId: status.proposalId,
+		decisionId: status.decisionId,
+		idempotencyKey: status.idempotencyKey,
+		proposalFamily: status.proposalFamily,
+		code,
+		issues: status.issues,
+		sourceRefs: status.sourceRefs,
+		audit: status.audit,
+		metadata: status.metadata,
+	};
+}
+
+function diagnosticFromOutcomeIndex(
+	entry: WorkspaceProposalFamilyOutcomeIndexEntry,
+): WorkspaceProposalFamilyApplicationDiagnostic {
+	const code = entry.issues[0]?.code ?? "idempotency-conflict";
+	return {
+		kind: "workspace-proposal-family-application-diagnostic",
+		diagnosticId: diagnosticId({
+			classification: "idempotency-conflict",
+			code,
+			applicationId: entry.applicationId,
+			proposalId: entry.proposalId,
+			decisionId: entry.decisionId,
+			idempotencyKey: entry.idempotencyKey,
+			proposalFamily: entry.proposalFamily,
+			indexKey: entry.indexKey,
+		}),
+		classification: "idempotency-conflict",
+		applicationId: entry.applicationId,
+		proposalId: entry.proposalId,
+		decisionId: entry.decisionId,
+		idempotencyKey: entry.idempotencyKey,
+		proposalFamily: entry.proposalFamily,
+		code,
+		issues: entry.issues,
+		sourceRefs: entry.sourceRefs,
+		audit: entry.audit,
+		metadata: { indexKey: entry.indexKey },
+	};
+}
+
+function upsertDiagnostic(
+	diagnostics: Map<string, WorkspaceProposalFamilyApplicationDiagnostic>,
+	diagnostic: WorkspaceProposalFamilyApplicationDiagnostic,
+): void {
+	const existing = diagnostics.get(diagnostic.diagnosticId);
+	if (existing === undefined) {
+		diagnostics.set(diagnostic.diagnosticId, diagnostic);
+		return;
+	}
+	diagnostics.set(diagnostic.diagnosticId, {
+		...existing,
+		issues: uniqueIssues([...existing.issues, ...diagnostic.issues]),
+		sourceRefs: uniqueRefs([...existing.sourceRefs, ...diagnostic.sourceRefs]),
+		audit: existing.audit ?? diagnostic.audit,
+		metadata: { ...(diagnostic.metadata ?? {}), ...(existing.metadata ?? {}) },
+	});
+}
+
+function diagnosticId(parts: Record<string, unknown>): string {
+	return `workspace-proposal-family-application-diagnostic:${stableStringify(parts)}`;
+}
+
+function repairReviewState(
+	state: WorkspaceProposalApplicationState | WorkspaceProposalFamilyOutcomeRecordState,
+): boolean {
+	return state === "repair-needed" || state === "idempotency-conflict";
+}
+
+function repairReviewClassification(
+	classification: WorkspaceProposalFamilyApplicationDiagnosticClass | undefined,
+): boolean {
+	return classification === "missing-family-material" || classification === "idempotency-conflict";
+}
+
+function diagnosticSignature(diagnostic: WorkspaceProposalFamilyApplicationDiagnostic): string {
+	return stableStringify({
+		code: diagnostic.code,
+		issues: diagnostic.issues,
+		sourceRefs: diagnostic.sourceRefs,
+		audit: diagnostic.audit,
+		metadata: diagnostic.metadata,
+	});
+}
+
+function repairRequestSignature(request: WorkspaceProposalRepairReviewRequest): string {
+	return stableStringify({
+		code: request.code,
+		issues: request.issues,
+		subjectRefs: request.subjectRefs ?? [],
+		sourceRefs: request.sourceRefs,
+		audit: request.audit,
+	});
+}
+
+function sameApplicationCoordinates(
+	status: WorkspaceProposalApplicationStatus,
+	material: WorkspaceProposalFamilyOutcomeRecordStatus | WorkspaceProposalFamilyOutcomeIndexEntry,
+): boolean {
+	return (
+		status.applicationId === material.applicationId &&
+		status.proposalId === material.proposalId &&
+		status.decisionId === material.decisionId &&
+		status.idempotencyKey === material.idempotencyKey &&
+		status.proposalFamily === material.proposalFamily
+	);
+}
+
+function repairRequestFromApplicationStatus(
+	status: WorkspaceProposalApplicationStatus,
+): WorkspaceProposalRepairReviewRequest {
+	const code = status.code ?? status.issues[0]?.code ?? status.state;
+	return {
+		kind: "workspace-proposal-repair-review-request",
+		repairRequestId: repairRequestId(status, code),
+		applicationId: status.applicationId,
+		proposalId: status.proposalId,
+		decisionId: status.decisionId,
+		idempotencyKey: status.idempotencyKey,
+		proposalFamily: status.proposalFamily,
+		code,
+		issues: status.issues,
+		subjectRefs: [{ kind: "workspace-proposal-application-status", id: status.applicationId }],
+		sourceRefs: status.sourceRefs,
+		audit: status.audit,
+	};
+}
+
+function repairRequestFromOutcomeStatus(
+	status: WorkspaceProposalFamilyOutcomeRecordStatus,
+	applicationStatus: WorkspaceProposalApplicationStatus,
+): WorkspaceProposalRepairReviewRequest {
+	const code = status.code ?? status.issues[0]?.code ?? status.state;
+	return {
+		kind: "workspace-proposal-repair-review-request",
+		repairRequestId: repairRequestId(status, code, status.outcomeId),
+		applicationId: status.applicationId,
+		proposalId: status.proposalId,
+		decisionId: status.decisionId,
+		idempotencyKey: status.idempotencyKey,
+		proposalFamily: status.proposalFamily,
+		code,
+		issues: status.issues,
+		subjectRefs: [
+			{ kind: "workspace-proposal-family-outcome-record-status", id: status.outcomeId },
+		],
+		sourceRefs: uniqueRefs([
+			{ kind: "workspace-proposal-application-status", id: applicationStatus.applicationId },
+			...status.sourceRefs,
+		]),
+		audit: status.audit ?? applicationStatus.audit,
+	};
+}
+
+function repairRequestFromOutcomeIndex(
+	entry: WorkspaceProposalFamilyOutcomeIndexEntry,
+	applicationStatus: WorkspaceProposalApplicationStatus,
+): WorkspaceProposalRepairReviewRequest {
+	const code = entry.issues[0]?.code ?? "idempotency-conflict";
+	return {
+		kind: "workspace-proposal-repair-review-request",
+		repairRequestId: repairRequestId(entry, code, entry.indexKey),
+		applicationId: entry.applicationId,
+		proposalId: entry.proposalId,
+		decisionId: entry.decisionId,
+		idempotencyKey: entry.idempotencyKey,
+		proposalFamily: entry.proposalFamily,
+		code,
+		issues: entry.issues,
+		subjectRefs: [{ kind: "workspace-proposal-family-outcome-index-entry", id: entry.indexKey }],
+		sourceRefs: uniqueRefs([
+			{ kind: "workspace-proposal-application-status", id: applicationStatus.applicationId },
+			...entry.sourceRefs,
+		]),
+		audit: entry.audit ?? applicationStatus.audit,
+	};
+}
+
+function upsertRepairRequest(
+	requests: Map<string, WorkspaceProposalRepairReviewRequest>,
+	request: WorkspaceProposalRepairReviewRequest,
+): void {
+	const existing = requests.get(request.repairRequestId);
+	if (existing === undefined) {
+		requests.set(request.repairRequestId, request);
+		return;
+	}
+	requests.set(request.repairRequestId, {
+		...existing,
+		issues: uniqueIssues([...existing.issues, ...request.issues]),
+		sourceRefs: uniqueRefs([...existing.sourceRefs, ...request.sourceRefs]),
+		audit: existing.audit ?? request.audit,
+	});
+}
+
+function repairRequestId(
+	coordinates: Pick<
+		WorkspaceProposalRepairReviewRequest,
+		"applicationId" | "proposalId" | "decisionId" | "idempotencyKey" | "proposalFamily"
+	>,
+	code: string,
+	extra?: string,
+): string {
+	return `workspace-proposal-repair-review:${stableStringify({
+		applicationId: coordinates.applicationId,
+		proposalId: coordinates.proposalId,
+		decisionId: coordinates.decisionId,
+		idempotencyKey: coordinates.idempotencyKey,
+		proposalFamily: coordinates.proposalFamily,
+		code,
+		extra,
+	})}`;
+}
+
+function diagnosticProjectionDeps(
+	opts: WorkspaceProposalFamilyApplicationDiagnosticProjectorOptions,
+): {
+	readonly deps: readonly Node<unknown>[];
+	readonly depKinds: readonly WorkspaceProposalFamilyApplicationDiagnosticInputFact["kind"][];
+} {
+	const deps: Node<unknown>[] = [];
+	const depKinds: WorkspaceProposalFamilyApplicationDiagnosticInputFact["kind"][] = [];
+	pushProjectionDep(deps, depKinds, opts.issues, "issue");
+	pushProjectionDep(deps, depKinds, opts.audit, "audit");
+	pushProjectionDep(deps, depKinds, opts.applicationStatuses, "application-status");
+	pushProjectionDep(deps, depKinds, opts.outcomeStatuses, "outcome-status");
+	pushProjectionDep(deps, depKinds, opts.outcomeIndex, "outcome-index");
+	return { deps, depKinds };
+}
+
+function repairReviewProjectionDeps(opts: WorkspaceProposalRepairReviewProjectorOptions): {
+	readonly deps: readonly Node<unknown>[];
+	readonly depKinds: readonly WorkspaceProposalFamilyApplicationDiagnosticInputFact["kind"][];
+} {
+	const deps: Node<unknown>[] = [];
+	const depKinds: WorkspaceProposalFamilyApplicationDiagnosticInputFact["kind"][] = [];
+	pushProjectionDep(deps, depKinds, opts.applicationStatuses, "application-status");
+	pushProjectionDep(deps, depKinds, opts.outcomeStatuses, "outcome-status");
+	pushProjectionDep(deps, depKinds, opts.outcomeIndex, "outcome-index");
+	return { deps, depKinds };
+}
+
+function repairReviewStatusProjectionDeps(
+	opts: WorkspaceProposalRepairReviewStatusProjectorOptions,
+): {
+	readonly deps: readonly Node<unknown>[];
+	readonly depKinds: readonly WorkspaceProposalFamilyApplicationDiagnosticInputFact["kind"][];
+} {
+	const deps: Node<unknown>[] = [];
+	const depKinds: WorkspaceProposalFamilyApplicationDiagnosticInputFact["kind"][] = [];
+	pushProjectionDep(deps, depKinds, opts.requests, "repair-request");
+	pushProjectionDep(deps, depKinds, opts.decisions, "repair-decision");
+	pushProjectionDep(deps, depKinds, opts.applicationStatuses, "application-status");
+	pushProjectionDep(deps, depKinds, opts.applicationRecorded, "application-recorded");
+	pushProjectionDep(deps, depKinds, opts.outcomeStatuses, "outcome-status");
+	pushProjectionDep(deps, depKinds, opts.outcomeIndex, "outcome-index");
+	return { deps, depKinds };
+}
+
+function repairReviewDecisionRecordingProjectionDeps(
+	opts: WorkspaceProposalRepairReviewDecisionRecordingProjectorOptions,
+): {
+	readonly deps: readonly Node<unknown>[];
+	readonly depKinds: readonly WorkspaceProposalFamilyApplicationDiagnosticInputFact["kind"][];
+} {
+	const deps: Node<unknown>[] = [];
+	const depKinds: WorkspaceProposalFamilyApplicationDiagnosticInputFact["kind"][] = [];
+	pushProjectionDep(deps, depKinds, opts.requests, "repair-request");
+	pushProjectionDep(deps, depKinds, opts.recordingInputs, "repair-decision-recording-input");
+	pushProjectionDep(deps, depKinds, opts.statuses, "repair-status");
+	return { deps, depKinds };
+}
+
+function readModelProjectionDeps(
+	opts: WorkspaceProposalFamilyApplicationReadModelProjectorOptions,
+): {
+	readonly deps: readonly Node<unknown>[];
+	readonly depKinds: readonly WorkspaceProposalFamilyApplicationDiagnosticInputFact["kind"][];
+} {
+	const deps: Node<unknown>[] = [];
+	const depKinds: WorkspaceProposalFamilyApplicationDiagnosticInputFact["kind"][] = [];
+	pushProjectionDep(deps, depKinds, opts.diagnostics, "diagnostic");
+	pushProjectionDep(deps, depKinds, opts.repairReviewStatuses, "repair-status");
+	pushProjectionDep(deps, depKinds, opts.outcomeIndex, "outcome-index");
+	pushProjectionDep(deps, depKinds, opts.outcomeStatuses, "outcome-status");
+	pushProjectionDep(deps, depKinds, opts.outcomes, "outcome");
+	return { deps, depKinds };
+}
+
+function readModelsProjectionDeps(
+	opts: WorkspaceProposalFamilyApplicationReadModelsProjectorOptions,
+): {
+	readonly deps: readonly Node<unknown>[];
+	readonly depKinds: readonly WorkspaceProposalFamilyApplicationDiagnosticInputFact["kind"][];
+} {
+	const deps: Node<unknown>[] = [];
+	const depKinds: WorkspaceProposalFamilyApplicationDiagnosticInputFact["kind"][] = [];
+	pushProjectionDep(deps, depKinds, opts.queries, "read-model-query");
+	pushProjectionDep(deps, depKinds, opts.diagnostics, "diagnostic");
+	pushProjectionDep(deps, depKinds, opts.repairReviewStatuses, "repair-status");
+	pushProjectionDep(deps, depKinds, opts.outcomeIndex, "outcome-index");
+	pushProjectionDep(deps, depKinds, opts.outcomeStatuses, "outcome-status");
+	pushProjectionDep(deps, depKinds, opts.outcomes, "outcome");
+	pushProjectionDep(deps, depKinds, opts.releases, "projection-release");
+	return { deps, depKinds };
+}
+
+function pushProjectionDep(
+	deps: Node<unknown>[],
+	depKinds: WorkspaceProposalFamilyApplicationDiagnosticInputFact["kind"][],
+	node: Node<unknown> | undefined,
+	kind: WorkspaceProposalFamilyApplicationDiagnosticInputFact["kind"],
+): void {
+	if (node === undefined) return;
+	deps.push(node);
+	depKinds.push(kind);
+}
+
+function ingestDiagnosticInputFacts(
+	ctx: Ctx,
+	state: WorkspaceProposalFamilyApplicationProjectionState,
+	depKinds: readonly WorkspaceProposalFamilyApplicationDiagnosticInputFact["kind"][],
+): void {
+	for (let index = 0; index < depKinds.length; index += 1) {
+		for (const raw of depBatch(ctx, index) ?? []) {
+			ingestDiagnosticInputFact(state, depKinds[index], raw);
+		}
+	}
+}
+
+function ingestDiagnosticInputFact(
+	state: WorkspaceProposalFamilyApplicationProjectionState,
+	kind: WorkspaceProposalFamilyApplicationDiagnosticInputFact["kind"],
+	raw: unknown,
+): void {
+	switch (kind) {
+		case "issue": {
+			const issue = raw as WorkspaceProposalRecordedIssue;
+			state.issues.set(issueKey(issue), issue);
+			return;
+		}
+		case "audit": {
+			const audit = raw as WorkspaceProposalFamilyApplicationAuditRecord;
+			state.audit.set(audit.auditId, audit);
+			return;
+		}
+		case "application-status": {
+			const status = raw as WorkspaceProposalApplicationStatus;
+			state.applicationStatuses.set(applicationStatusProjectionKey(status), status);
+			return;
+		}
+		case "application-recorded": {
+			const record = raw as WorkspaceProposalApplicationRecorded;
+			state.applicationRecorded.set(applicationRecordedProjectionKey(record), record);
+			return;
+		}
+		case "outcome-status": {
+			const status = raw as WorkspaceProposalFamilyOutcomeRecordStatus;
+			state.outcomeStatuses.set(outcomeStatusProjectionKey(status), status);
+			return;
+		}
+		case "outcome-index": {
+			const entry = raw as WorkspaceProposalFamilyOutcomeIndexEntry;
+			state.outcomeIndex.set(outcomeIndexProjectionKey(entry), entry);
+			return;
+		}
+		case "repair-request": {
+			const request = raw as WorkspaceProposalRepairReviewRequest;
+			state.repairRequests.set(request.repairRequestId, request);
+			return;
+		}
+		case "repair-decision": {
+			const decision = raw as WorkspaceProposalRepairReviewDecision;
+			state.repairDecisions.set(decision.reviewDecisionId, decision);
+			return;
+		}
+		case "repair-status": {
+			const status = raw as WorkspaceProposalRepairReviewStatus;
+			state.repairStatuses.set(repairReviewStatusProjectionKey(status), status);
+			return;
+		}
+		case "repair-decision-recording-input": {
+			const input = raw as WorkspaceProposalRepairReviewDecisionRecordingInput;
+			state.repairDecisionRecordingInputs.set(repairReviewDecisionRecordingInputKey(input), input);
+			return;
+		}
+		case "diagnostic": {
+			const diagnostic = raw as WorkspaceProposalFamilyApplicationDiagnostic;
+			state.diagnostics.set(diagnostic.diagnosticId, diagnostic);
+			return;
+		}
+		case "read-model-query": {
+			const query = raw as WorkspaceProposalFamilyApplicationReadModelQuery;
+			state.readModelQueries.set(readModelQueryProjectionKey(query), query);
+			return;
+		}
+		case "outcome": {
+			const outcome = raw as WorkspaceProposalFamilyOutcomeRecord;
+			state.outcomes.set(outcomeProjectionKey(outcome), outcome);
+			return;
+		}
+		case "projection-release": {
+			pruneReadModelQueryRelease(state, raw);
+		}
+	}
+}
+
+function familyProjectionState(ctx: Ctx): WorkspaceProposalFamilyApplicationProjectionState {
+	return (
+		ctx.state.get<WorkspaceProposalFamilyApplicationProjectionState>() ?? {
+			issues: new Map(),
+			audit: new Map(),
+			applicationStatuses: new Map(),
+			applicationRecorded: new Map(),
+			outcomeStatuses: new Map(),
+			outcomeIndex: new Map(),
+			repairRequests: new Map(),
+			repairDecisions: new Map(),
+			repairStatuses: new Map(),
+			repairDecisionRecordingInputs: new Map(),
+			diagnostics: new Map(),
+			readModelQueries: new Map(),
+			outcomes: new Map(),
+			emittedDiagnostics: new Map(),
+			emittedRepairRequests: new Map(),
+			emittedRepairStatuses: new Map(),
+			emittedRepairDecisionRecordings: new Map(),
+			emittedReadModels: new Map(),
+			emittedRepairActionDescriptors: new Map(),
+		}
+	);
+}
+
+interface WorkspaceProposalRepairActionIntentGraphState {
+	readonly intents: Map<
+		string,
+		{
+			readonly intent: WorkspaceProposalRepairActionIntent;
+			readonly signature: string;
+			readonly conflict: boolean;
+		}
+	>;
+	readonly descriptors: Map<string, WorkspaceProposalRepairActionDescriptor>;
+	readonly requests: Map<string, WorkspaceProposalRepairReviewRequest>;
+	readonly statuses: Map<string, WorkspaceProposalRepairReviewStatus>;
+	readonly emittedResults: Map<string, string>;
+	readonly emittedPreviews: Map<string, string>;
+	readonly releasedPreviews: Set<string>;
+}
+
+interface WorkspaceProposalRepairSuccessorReadyRequestPreparationGraphState<TDraft = unknown> {
+	readonly previews: Map<string, WorkspaceProposalRepairSuccessorProposalIntakePreview>;
+	readonly inputs: Map<
+		string,
+		WorkspaceProposalRepairSuccessorProposalReadyRequestPreparationInput<TDraft>
+	>;
+	readonly emittedResults: Map<string, string>;
+	readonly preparedReadyRequests: Map<
+		string,
+		{
+			readonly signature: string;
+			readonly compacted: boolean;
+			readonly value?: WorkspaceProposalReadyRequest<TDraft>;
+		}
+	>;
+}
+
+const workspaceProposalProjectionReleaseTargetKinds = [
+	"family-read-model-query",
+	"outcome-detail-supply-request",
+	"repair-action-advisory",
+	"repair-action-intent",
+	"repair-successor-preview",
+	"repair-successor-preparation",
+] as const satisfies readonly WorkspaceProposalProjectionReleaseTargetKind[];
+
+const workspaceProposalProjectionReleaseKeys = new Set([
+	"kind",
+	"releaseId",
+	"targetKind",
+	"targetId",
+	"sourceRefs",
+	"viewId",
+	"applicationId",
+	"proposalId",
+	"decisionId",
+	"idempotencyKey",
+	"proposalFamily",
+	"queryId",
+	"supplyRequestId",
+	"descriptorId",
+	"repairRequestId",
+	"actionKind",
+	"intentId",
+	"previewId",
+	"preparationId",
+	"audit",
+	"metadata",
+]);
+
+function workspaceProjectionReleaseTargetIdIsWildcard(targetId: string | undefined): boolean {
+	return (
+		targetId === "*" ||
+		targetId === "all" ||
+		targetId === "workspace" ||
+		targetId === "workspace-wide" ||
+		targetId === "workspace:*"
+	);
+}
+
+/**
+ * Validate D472 projection release material before a projector treats it as a
+ * bounded current-view retention hint.
+ */
+export function isWorkspaceProposalProjectionReleaseMaterial(
+	value: unknown,
+): value is WorkspaceProposalProjectionRelease {
+	return workspaceProposalProjectionReleaseIssues(value).length === 0;
+}
+
+/**
+ * Validate D472 release material and clone accepted DTOs before projection use.
+ *
+ * Validation is fail-closed: malformed material is reportable through D473
+ * diagnostics but cannot prune current-view state or satisfy policy checks.
+ */
+export function validateWorkspaceProposalProjectionReleaseMaterial(
+	value: unknown,
+): WorkspaceProposalProjectionReleaseValidationResult {
+	const issues = workspaceProposalProjectionReleaseIssues(value);
+	const record = isRecord(value) ? value : {};
+	const targetKind = workspaceProposalProjectionReleaseTargetKinds.includes(
+		record.targetKind as WorkspaceProposalProjectionReleaseTargetKind,
+	)
+		? (record.targetKind as WorkspaceProposalProjectionReleaseTargetKind)
+		: undefined;
+	const base = {
+		kind: "workspace-proposal-projection-release-validation-result" as const,
+		releaseId: stringField(record.releaseId),
+		targetKind,
+		targetId: stringField(record.targetId),
+		issues,
+		sourceRefs: safeWorkspaceProposalProjectionReleaseSourceRefs(record),
+		audit: safeWorkspaceProposalProjectionReleaseAudit(record.audit),
+	};
+	if (issues.length === 0) {
+		return {
+			...base,
+			status: "accepted",
+			release: immutableClone(value as WorkspaceProposalProjectionRelease),
+		};
+	}
+	return { ...base, status: "blocked" };
+}
+
+function workspaceProposalProjectionReleaseIssues(
+	value: unknown,
+): readonly WorkspaceProposalRecordedIssue[] {
+	const issues: WorkspaceProposalRecordedIssue[] = [];
+	const record = isRecord(value) ? value : {};
+	if (!isRecord(value)) {
+		issues.push(
+			projectionReleaseIssue(
+				"malformed-projection-release",
+				"Projection release must be object material.",
+			),
+		);
+		return issues;
+	}
+	for (const key of Object.keys(record)) {
+		if (workspaceProposalProjectionReleaseKeys.has(key)) continue;
+		issues.push(
+			projectionReleaseIssue(
+				"forbidden-projection-release-material",
+				"Projection release must not carry truth, runtime, storage, proof, or private top-level material.",
+			),
+		);
+	}
+	const dataOnlyIssues = workspaceProposalDataOnlyIssues(value, "projectionRelease").map(
+		projectionReleaseDataOnlyIssue,
+	);
+	if (dataOnlyIssues.length > 0) {
+		return dedupeRepairActionIssues([...issues, ...dataOnlyIssues]);
+	}
+	if (record.kind !== "workspace-proposal-projection-release") {
+		issues.push(
+			projectionReleaseIssue("malformed-projection-release", "Projection release kind is invalid."),
+		);
+	}
+	if (stringField(record.releaseId) === undefined) {
+		issues.push(
+			projectionReleaseIssue(
+				"malformed-projection-release",
+				"Projection release requires releaseId.",
+			),
+		);
+	}
+	if (
+		!workspaceProposalProjectionReleaseTargetKinds.includes(
+			record.targetKind as WorkspaceProposalProjectionReleaseTargetKind,
+		)
+	) {
+		issues.push(
+			projectionReleaseIssue(
+				"unsupported-projection-release-target",
+				"Projection release targetKind is not a closed Workspace proposal projection target.",
+			),
+		);
+	}
+	if (stringField(record.targetId) === undefined) {
+		issues.push(
+			projectionReleaseIssue(
+				"malformed-projection-release",
+				"Projection release requires targetId.",
+			),
+		);
+	} else if (
+		workspaceProjectionReleaseTargetIdIsWildcard(stringField(record.targetId)?.toLowerCase())
+	) {
+		issues.push(
+			projectionReleaseIssue(
+				"malformed-projection-release",
+				"Projection release target must be concrete, not wildcard or workspace-wide.",
+			),
+		);
+	}
+	if (
+		!repairReviewDecisionSourceRefsAreValid(record.sourceRefs) ||
+		!workspaceProposalBoundarySourceRefsAreSafe(
+			record.sourceRefs as readonly SourceRef[] | undefined,
+		)
+	) {
+		issues.push(
+			projectionReleaseIssue(
+				"malformed-projection-release",
+				"Projection release requires boundary-safe sourceRefs.",
+			),
+		);
+	}
+	if (record.audit !== undefined) {
+		const audit = safeWorkspaceProposalAudit(record.audit);
+		if (audit === undefined || !workspaceProposalBoundarySourceRefsAreSafe(audit.sourceRefs)) {
+			issues.push(
+				projectionReleaseIssue(
+					"malformed-projection-release",
+					"Projection release audit must be boundary-safe data material.",
+				),
+			);
+		}
+		for (const issue of workspaceProposalDataOnlyIssues(record.audit, "projectionReleaseAudit")) {
+			issues.push(projectionReleaseDataOnlyIssue(issue));
+		}
+		if (
+			isRecord((record.audit as { readonly metadata?: unknown }).metadata) &&
+			projectionReleaseMetadataHasRevocationVocabulary(
+				(record.audit as { readonly metadata: Record<string, unknown> }).metadata,
+			)
+		) {
+			issues.push(
+				projectionReleaseIssue(
+					"forbidden-projection-release-vocabulary",
+					"Projection release audit metadata must not carry revocation, eviction, cache, storage, or proof vocabulary.",
+				),
+			);
+		}
+	}
+	for (const issue of workspaceProposalDataOnlyIssues(
+		record.sourceRefs,
+		"projectionReleaseSourceRefs",
+	)) {
+		issues.push(projectionReleaseDataOnlyIssue(issue));
+	}
+	if (record.metadata !== undefined) {
+		if (!isRecord(record.metadata)) {
+			issues.push(
+				projectionReleaseIssue(
+					"malformed-metadata",
+					"Projection release metadata must be bounded object material.",
+				),
+			);
+		} else {
+			for (const issue of workspaceProposalDataOnlyIssues(
+				record.metadata,
+				"projectionReleaseMetadata",
+			)) {
+				issues.push(projectionReleaseDataOnlyIssue(issue));
+			}
+			if (workspaceProposalBoundaryMetadataSize(record.metadata) > 4096) {
+				issues.push(
+					projectionReleaseIssue(
+						"malformed-metadata",
+						"Projection release metadata exceeds the bounded display limit.",
+					),
+				);
+			}
+			if (projectionReleaseMetadataHasRevocationVocabulary(record.metadata)) {
+				issues.push(
+					projectionReleaseIssue(
+						"forbidden-projection-release-vocabulary",
+						"Projection release metadata must not carry revocation, eviction, cache, storage, or truth-mutation vocabulary.",
+					),
+				);
+			}
+		}
+	}
+	for (const field of [
+		"viewId",
+		"applicationId",
+		"proposalId",
+		"decisionId",
+		"idempotencyKey",
+		"proposalFamily",
+		"queryId",
+		"supplyRequestId",
+		"descriptorId",
+		"repairRequestId",
+		"intentId",
+		"previewId",
+		"preparationId",
+	] as const) {
+		if (record[field] !== undefined && stringField(record[field]) === undefined) {
+			issues.push(
+				projectionReleaseIssue(
+					"malformed-projection-release",
+					`Projection release optional ${field} must be a nonblank string when present.`,
+				),
+			);
+		}
+	}
+	if (
+		record.actionKind !== undefined &&
+		!repairActionKinds.includes(record.actionKind as WorkspaceProposalRepairActionKind)
+	) {
+		issues.push(
+			projectionReleaseIssue(
+				"malformed-projection-release",
+				"Projection release actionKind is not a closed repair action kind.",
+			),
+		);
+	}
+	if (
+		record.targetKind === "repair-successor-preview" &&
+		stringField(record.intentId) === undefined
+	) {
+		issues.push(
+			projectionReleaseIssue(
+				"malformed-projection-release",
+				"Repair successor preview release requires intentId to avoid immediate re-preview.",
+			),
+		);
+	}
+	for (const issue of workspaceProposalProjectionReleaseTargetIdentityIssues(record)) {
+		issues.push(issue);
+	}
+	return dedupeRepairActionIssues(issues);
+}
+
+function workspaceProposalProjectionReleaseDiagnosticFromValidation(
+	validation: WorkspaceProposalProjectionReleaseValidationResult,
+): WorkspaceProposalProjectionReleaseDiagnostic {
+	return {
+		kind: "workspace-proposal-projection-release-diagnostic",
+		diagnosticId: workspaceProposalProjectionReleaseDiagnosticId(validation),
+		releaseId: validation.releaseId,
+		targetKind: validation.targetKind,
+		targetId: validation.targetId,
+		status: "blocked",
+		issues: validation.issues,
+		sourceRefs: validation.sourceRefs,
+		audit: validation.audit,
+	};
+}
+
+function workspaceProposalProjectionReleaseDiagnosticId(
+	validation: WorkspaceProposalProjectionReleaseValidationResult,
+): string {
+	const anchor =
+		validation.releaseId ??
+		validation.targetId ??
+		validation.targetKind ??
+		"malformed-projection-release";
+	return `workspace-proposal-projection-release-diagnostic:${anchor}:${stableStringify(
+		validation.issues.map((issue) => issue.code),
+	)}`;
+}
+
+function safeWorkspaceProposalProjectionReleaseSourceRefs(
+	record: Record<string, unknown>,
+): readonly SourceRef[] {
+	return repairReviewDecisionSourceRefsAreValid(record.sourceRefs) &&
+		workspaceProposalBoundarySourceRefsAreSafe(record.sourceRefs as readonly SourceRef[])
+		? (record.sourceRefs as readonly SourceRef[])
+		: [];
+}
+
+function safeWorkspaceProposalProjectionReleaseAudit(
+	value: unknown,
+): WorkspaceProposalAuditMaterial | undefined {
+	const audit = safeWorkspaceProposalAudit(value);
+	if (audit === undefined) return undefined;
+	if (!workspaceProposalBoundarySourceRefsAreSafe(audit.sourceRefs)) return undefined;
+	if (workspaceProposalDataOnlyIssues(value, "projectionReleaseAudit").length > 0) {
+		return undefined;
+	}
+	if (
+		isRecord((value as { readonly metadata?: unknown }).metadata) &&
+		projectionReleaseMetadataHasRevocationVocabulary(
+			(value as { readonly metadata: Record<string, unknown> }).metadata,
+		)
+	) {
+		return undefined;
+	}
+	return audit;
+}
+
+function workspaceProposalProjectionReleaseTargetIdentityIssues(
+	record: Record<string, unknown>,
+): readonly WorkspaceProposalRecordedIssue[] {
+	const targetId = stringField(record.targetId);
+	if (targetId === undefined) return [];
+	const issues: WorkspaceProposalRecordedIssue[] = [];
+	const mismatch = (message: string): void => {
+		issues.push(projectionReleaseIssue("projection-release-coordinate-mismatch", message));
+	};
+	const conflictsWithAll = (...values: readonly unknown[]): boolean => {
+		const ids = values
+			.map((value) => stringField(value))
+			.filter((value): value is string => value !== undefined);
+		return ids.length > 0 && !ids.includes(targetId);
+	};
+	switch (record.targetKind) {
+		case "family-read-model-query": {
+			if (conflictsWithAll(record.viewId, record.queryId)) {
+				mismatch("Read-model release targetId must match viewId or queryId when provided.");
+			}
+			break;
+		}
+		case "outcome-detail-supply-request": {
+			if (conflictsWithAll(record.viewId, record.supplyRequestId)) {
+				mismatch(
+					"Outcome detail supply release targetId must match viewId or supplyRequestId when provided.",
+				);
+			}
+			break;
+		}
+		case "repair-action-intent": {
+			if (conflictsWithAll(record.intentId)) {
+				mismatch("Repair action intent release targetId must match intentId when provided.");
+			}
+			break;
+		}
+		case "repair-successor-preview": {
+			if (conflictsWithAll(record.previewId)) {
+				mismatch("Repair successor preview release targetId must match previewId when provided.");
+			}
+			break;
+		}
+		case "repair-successor-preparation": {
+			if (conflictsWithAll(record.preparationId)) {
+				mismatch(
+					"Repair successor preparation release targetId must match preparationId when provided.",
+				);
+			}
+			break;
+		}
+		case "repair-action-advisory": {
+			const descriptorId = stringField(record.descriptorId);
+			if (descriptorId === undefined) {
+				issues.push(
+					projectionReleaseIssue(
+						"malformed-projection-release",
+						"Repair advisory release requires descriptorId; request-wide or actionKind-only release is too broad.",
+					),
+				);
+			} else if (!projectionReleaseAdvisoryTargetMatches(record, targetId, descriptorId)) {
+				mismatch(
+					"Repair advisory release targetId must match descriptorId or the full advisory key.",
+				);
+			}
+			break;
+		}
+	}
+	return issues;
+}
+
+function projectionReleaseAdvisoryTargetMatches(
+	record: Record<string, unknown>,
+	targetId: string,
+	descriptorId: string,
+): boolean {
+	if (targetId === descriptorId) return true;
+	const repairRequestId = stringField(record.repairRequestId);
+	const actionKind = repairActionKinds.includes(
+		record.actionKind as WorkspaceProposalRepairActionKind,
+	)
+		? (record.actionKind as WorkspaceProposalRepairActionKind)
+		: undefined;
+	return (
+		repairRequestId !== undefined &&
+		actionKind !== undefined &&
+		targetId === repairActionAdvisoryKey({ descriptorId, repairRequestId, actionKind })
+	);
+}
+
+function projectionReleaseIssue(code: string, message: string): WorkspaceProposalRecordedIssue {
+	return {
+		kind: "issue",
+		source: "workspace-proposal",
+		severity: "error",
+		code,
+		message,
+	};
+}
+
+function projectionReleaseDataOnlyIssue(
+	issue: WorkspaceProposalRecordedIssue,
+): WorkspaceProposalRecordedIssue {
+	return {
+		...issue,
+		code:
+			issue.code === "forbidden-runtime-material"
+				? "forbidden-projection-release-runtime-material"
+				: issue.code,
+	};
+}
+
+function projectionReleaseMetadataHasRevocationVocabulary(value: Record<string, unknown>): boolean {
+	const forbidden = new Set([
+		"delete",
+		"deleted",
+		"deletion",
+		"cache",
+		"evict",
+		"evicted",
+		"eviction",
+		"lru",
+		"proof",
+		"revoke",
+		"revoked",
+		"revocation",
+		"storage",
+		"storageowner",
+		"cacheowner",
+		"truthmutation",
+		"permissionproof",
+		"policyproof",
+	]);
+	const seen = new WeakSet<object>();
+	const visit = (entry: unknown): boolean => {
+		if (typeof entry === "string") {
+			const normalized = entry.toLowerCase().replace(/[-_\s]/g, "");
+			return [...forbidden].some((token) => normalized.includes(token));
+		}
+		if (Array.isArray(entry)) return entry.some(visit);
+		if (!isRecord(entry) || seen.has(entry)) return false;
+		seen.add(entry);
+		for (const [key, child] of Object.entries(entry)) {
+			const normalized = key.toLowerCase().replace(/[-_\s]/g, "");
+			if ([...forbidden].some((token) => normalized.includes(token)) || visit(child)) return true;
+		}
+		return false;
+	};
+	return visit(value);
+}
+
+function pruneReadModelQueryRelease(
+	state: WorkspaceProposalFamilyApplicationProjectionState,
+	raw: unknown,
+): void {
+	if (
+		!isWorkspaceProposalProjectionReleaseMaterial(raw) ||
+		raw.targetKind !== "family-read-model-query"
+	) {
+		return;
+	}
+	const currentViewId = raw.viewId ?? raw.queryId ?? raw.targetId;
+	const key = stableStringify({ currentViewId });
+	const query = state.readModelQueries.get(key);
+	if (query !== undefined && !projectionReleaseMatchesReadModelQuery(raw, query)) return;
+	if (query === undefined && projectionReleaseHasWorkspaceCoordinates(raw)) return;
+	state.readModelQueries.delete(key);
+	state.emittedReadModels.delete(key);
+}
+
+function pruneOutcomeDetailSupplyRelease(
+	state: {
+		readonly requests: Map<string, WorkspaceProposalFamilyOutcomeDetailSupplyRequest>;
+		readonly emittedResults: Map<string, string>;
+	},
+	raw: unknown,
+): void {
+	if (
+		!isWorkspaceProposalProjectionReleaseMaterial(raw) ||
+		raw.targetKind !== "outcome-detail-supply-request"
+	) {
+		return;
+	}
+	const currentViewId = raw.viewId ?? raw.supplyRequestId ?? raw.targetId;
+	const key = stableStringify({ currentViewId });
+	const request = state.requests.get(key);
+	if (request !== undefined && !projectionReleaseMatchesSupplyRequest(raw, request)) return;
+	if (request === undefined && projectionReleaseHasWorkspaceCoordinates(raw)) return;
+	state.requests.delete(key);
+	state.emittedResults.delete(currentViewId);
+}
+
+function pruneRepairActionAdvisoryRelease(
+	state: {
+		readonly descriptors: Map<string, WorkspaceProposalRepairActionDescriptor>;
+		readonly emittedAdvisories: Map<string, string>;
+	},
+	raw: unknown,
+): void {
+	if (
+		!isWorkspaceProposalProjectionReleaseMaterial(raw) ||
+		raw.targetKind !== "repair-action-advisory"
+	) {
+		return;
+	}
+	let matchedAdvisory = false;
+	for (const [descriptorId, descriptor] of state.descriptors) {
+		if (!projectionReleaseMatchesAdvisory(raw, descriptor)) continue;
+		state.descriptors.delete(descriptorId);
+		state.emittedAdvisories.delete(repairActionAdvisoryKey(descriptor));
+		matchedAdvisory = true;
+	}
+	if (!matchedAdvisory && projectionReleaseHasWorkspaceCoordinates(raw)) return;
+	if (
+		raw.descriptorId !== undefined &&
+		raw.repairRequestId !== undefined &&
+		raw.actionKind !== undefined
+	) {
+		state.emittedAdvisories.delete(
+			repairActionAdvisoryKey({
+				descriptorId: raw.descriptorId,
+				repairRequestId: raw.repairRequestId,
+				actionKind: raw.actionKind,
+			}),
+		);
+	}
+	state.emittedAdvisories.delete(raw.targetId);
+}
+
+function pruneRepairActionIntentRelease(
+	state: WorkspaceProposalRepairActionIntentGraphState,
+	raw: unknown,
+): void {
+	if (
+		!isWorkspaceProposalProjectionReleaseMaterial(raw) ||
+		raw.targetKind !== "repair-action-intent"
+	) {
+		return;
+	}
+	const intentId = raw.intentId ?? raw.targetId;
+	const entry = state.intents.get(intentId);
+	if (entry !== undefined && !projectionReleaseMatchesIntent(raw, entry.intent)) return;
+	if (entry === undefined && projectionReleaseHasWorkspaceCoordinates(raw)) return;
+	state.intents.delete(intentId);
+	state.emittedResults.delete(intentId);
+}
+
+function pruneRepairSuccessorPreviewRelease(
+	state: WorkspaceProposalRepairActionIntentGraphState,
+	raw: unknown,
+): void {
+	if (!isWorkspaceProposalProjectionReleaseMaterial(raw)) return;
+	if (raw.targetKind === "repair-action-intent") {
+		const intentId = raw.intentId ?? raw.targetId;
+		const entry = state.intents.get(intentId);
+		if (entry !== undefined && !projectionReleaseMatchesIntent(raw, entry.intent)) return;
+		if (entry === undefined && projectionReleaseHasWorkspaceCoordinates(raw)) return;
+		const previewId =
+			entry === undefined
+				? (raw.previewId ?? raw.targetId)
+				: repairSuccessorPreviewIdFromIntent(entry.intent);
+		if (entry !== undefined) state.emittedPreviews.delete(previewId);
+		state.intents.delete(intentId);
+		state.emittedResults.delete(intentId);
+		state.releasedPreviews.delete(previewId);
+		return;
+	}
+	if (raw.targetKind !== "repair-successor-preview" || raw.intentId === undefined) return;
+	const entry = state.intents.get(raw.intentId);
+	if (entry !== undefined && !projectionReleaseMatchesIntent(raw, entry.intent)) return;
+	if (entry === undefined && projectionReleaseHasWorkspaceCoordinates(raw)) return;
+	if (
+		entry !== undefined &&
+		raw.previewId !== undefined &&
+		raw.previewId !== repairSuccessorPreviewIdFromIntent(entry.intent)
+	) {
+		return;
+	}
+	if (entry !== undefined) {
+		state.emittedPreviews.delete(repairSuccessorPreviewIdFromIntent(entry.intent));
+	}
+	const previewId =
+		entry === undefined
+			? (raw.previewId ?? raw.targetId)
+			: repairSuccessorPreviewIdFromIntent(entry.intent);
+	state.releasedPreviews.add(previewId);
+	state.emittedPreviews.delete(previewId);
+}
+
+function pruneRepairSuccessorPreparationRelease<TDraft>(
+	state: WorkspaceProposalRepairSuccessorReadyRequestPreparationGraphState<TDraft>,
+	raw: unknown,
+): void {
+	if (
+		!isWorkspaceProposalProjectionReleaseMaterial(raw) ||
+		raw.targetKind !== "repair-successor-preparation"
+	) {
+		return;
+	}
+	const preparationId = raw.preparationId ?? raw.targetId;
+	const input = state.inputs.get(preparationId);
+	if (input !== undefined && !projectionReleaseMatchesPreparationInput(raw, input)) return;
+	if (input === undefined && projectionReleaseHasWorkspaceCoordinates(raw)) return;
+	state.inputs.delete(preparationId);
+	state.emittedResults.delete(preparationId);
+	const prepared = state.preparedReadyRequests.get(preparationId);
+	if (prepared !== undefined) {
+		state.preparedReadyRequests.set(preparationId, {
+			signature: prepared.signature,
+			compacted: true,
+		});
+	}
+}
+
+function projectionReleaseMatchesAdvisory(
+	release: WorkspaceProposalProjectionRelease,
+	descriptor: WorkspaceProposalRepairActionDescriptor,
+): boolean {
+	if (!projectionReleaseWorkspaceCoordinatesMatch(release, descriptor)) return false;
+	if (release.descriptorId === undefined || release.descriptorId !== descriptor.descriptorId) {
+		return false;
+	}
+	if (
+		release.repairRequestId !== undefined &&
+		release.repairRequestId !== descriptor.repairRequestId
+	) {
+		return false;
+	}
+	if (release.actionKind !== undefined && release.actionKind !== descriptor.actionKind) {
+		return false;
+	}
+	return (
+		release.targetId === descriptor.descriptorId ||
+		release.targetId === repairActionAdvisoryKey(descriptor)
+	);
+}
+
+function projectionReleaseMatchesReadModelQuery(
+	release: WorkspaceProposalProjectionRelease,
+	query: WorkspaceProposalFamilyApplicationReadModelQuery,
+): boolean {
+	const currentViewId = query.viewId ?? query.queryId;
+	return (
+		release.targetId === currentViewId &&
+		(release.viewId === undefined || release.viewId === currentViewId) &&
+		(release.queryId === undefined || release.queryId === query.queryId) &&
+		projectionReleaseWorkspaceCoordinatesMatch(release, query)
+	);
+}
+
+function projectionReleaseMatchesSupplyRequest(
+	release: WorkspaceProposalProjectionRelease,
+	request: WorkspaceProposalFamilyOutcomeDetailSupplyRequest,
+): boolean {
+	const currentViewId = request.viewId ?? request.supplyRequestId;
+	return (
+		release.targetId === currentViewId &&
+		(release.viewId === undefined || release.viewId === currentViewId) &&
+		(release.supplyRequestId === undefined ||
+			release.supplyRequestId === request.supplyRequestId) &&
+		projectionReleaseWorkspaceCoordinatesMatch(release, request)
+	);
+}
+
+function projectionReleaseMatchesIntent(
+	release: WorkspaceProposalProjectionRelease,
+	intent: WorkspaceProposalRepairActionIntent,
+): boolean {
+	return (
+		(release.intentId === undefined || release.intentId === intent.intentId) &&
+		(release.descriptorId === undefined || release.descriptorId === intent.descriptorId) &&
+		(release.repairRequestId === undefined || release.repairRequestId === intent.repairRequestId) &&
+		(release.actionKind === undefined || release.actionKind === intent.actionKind) &&
+		projectionReleaseWorkspaceCoordinatesMatch(release, intent)
+	);
+}
+
+function projectionReleaseMatchesPreparationInput<TDraft>(
+	release: WorkspaceProposalProjectionRelease,
+	input: WorkspaceProposalRepairSuccessorProposalReadyRequestPreparationInput<TDraft>,
+): boolean {
+	return (
+		release.targetId === input.preparationId &&
+		(release.preparationId === undefined || release.preparationId === input.preparationId) &&
+		(release.previewId === undefined || release.previewId === input.previewId) &&
+		(release.intentId === undefined || release.intentId === input.intent.intentId) &&
+		(release.descriptorId === undefined ||
+			release.descriptorId === input.descriptor.descriptorId) &&
+		(release.repairRequestId === undefined ||
+			release.repairRequestId === input.request.repairRequestId) &&
+		(release.actionKind === undefined || release.actionKind === input.intent.actionKind) &&
+		projectionReleaseWorkspaceCoordinatesMatch(release, input.request)
+	);
+}
+
+function projectionReleaseWorkspaceCoordinatesMatch(
+	release: WorkspaceProposalProjectionRelease,
+	value: {
+		readonly applicationId?: string;
+		readonly proposalId?: string;
+		readonly decisionId?: string;
+		readonly idempotencyKey?: string;
+		readonly proposalFamily?: WorkspaceProposalFamily;
+	},
+): boolean {
+	return (
+		(release.applicationId === undefined || release.applicationId === value.applicationId) &&
+		(release.proposalId === undefined || release.proposalId === value.proposalId) &&
+		(release.decisionId === undefined || release.decisionId === value.decisionId) &&
+		(release.idempotencyKey === undefined || release.idempotencyKey === value.idempotencyKey) &&
+		(release.proposalFamily === undefined || release.proposalFamily === value.proposalFamily)
+	);
+}
+
+function projectionReleaseHasWorkspaceCoordinates(
+	release: WorkspaceProposalProjectionRelease,
+): boolean {
+	return (
+		release.applicationId !== undefined ||
+		release.proposalId !== undefined ||
+		release.decisionId !== undefined ||
+		release.idempotencyKey !== undefined ||
+		release.proposalFamily !== undefined
+	);
+}
+
+function repairActionAdvisoryKey(
+	value: Pick<
+		WorkspaceProposalRepairActionDescriptor,
+		"descriptorId" | "repairRequestId" | "actionKind"
+	>,
+): string {
+	return stableStringify({
+		descriptorId: value.descriptorId,
+		repairRequestId: value.repairRequestId,
+		actionKind: value.actionKind,
+	});
+}
+
+function repairSuccessorPreviewIdFromIntent(intent: WorkspaceProposalRepairActionIntent): string {
+	return `workspace-proposal-repair-successor-preview:${stableStringify({
+		intentId: intent.intentId,
+		descriptorId: intent.descriptorId,
+		repairRequestId: intent.repairRequestId,
+	})}`;
+}
+
+function repairActionIntentProjectorDeps(
+	opts:
+		| WorkspaceProposalRepairActionIntentProjectorOptions
+		| WorkspaceProposalRepairSuccessorProposalIntakePreviewProjectorOptions,
+): readonly Node<unknown>[] {
+	const deps: Node<unknown>[] = [opts.intents, opts.descriptors, opts.requests];
+	if (opts.statuses !== undefined) deps.push(opts.statuses);
+	if (opts.releases !== undefined) deps.push(opts.releases);
+	return deps;
+}
+
+function repairActionReleaseDepIndex(hasStatuses: boolean): number {
+	return hasStatuses ? 4 : 3;
+}
+
+function repairActionIntentGraphState(ctx: Ctx): WorkspaceProposalRepairActionIntentGraphState {
+	return (
+		ctx.state.get<WorkspaceProposalRepairActionIntentGraphState>() ?? {
+			intents: new Map(),
+			descriptors: new Map(),
+			requests: new Map(),
+			statuses: new Map(),
+			emittedResults: new Map(),
+			emittedPreviews: new Map(),
+			releasedPreviews: new Set(),
+		}
+	);
+}
+
+function repairSuccessorPreparationGraphState<TDraft>(
+	ctx: Ctx,
+): WorkspaceProposalRepairSuccessorReadyRequestPreparationGraphState<TDraft> {
+	return (
+		ctx.state.get<WorkspaceProposalRepairSuccessorReadyRequestPreparationGraphState<TDraft>>() ?? {
+			previews: new Map(),
+			inputs: new Map(),
+			emittedResults: new Map(),
+			preparedReadyRequests: new Map(),
+		}
+	);
+}
+
+function ingestRepairActionIntentGraphFacts(
+	ctx: Ctx,
+	state: WorkspaceProposalRepairActionIntentGraphState,
+	hasStatuses: boolean,
+): void {
+	for (const raw of depBatch(ctx, 0) ?? []) {
+		const intent = raw as WorkspaceProposalRepairActionIntent;
+		const signature = repairActionIntentSignature(intent);
+		state.releasedPreviews.delete(repairSuccessorPreviewIdFromIntent(intent));
+		const existing = state.intents.get(intent.intentId);
+		if (existing === undefined) {
+			state.intents.set(intent.intentId, { intent, signature, conflict: false });
+		} else if (existing.signature !== signature) {
+			state.intents.set(intent.intentId, { ...existing, conflict: true });
+		}
+	}
+	for (const raw of depBatch(ctx, 1) ?? []) {
+		const descriptor = raw as WorkspaceProposalRepairActionDescriptor;
+		state.descriptors.set(descriptor.descriptorId, descriptor);
+	}
+	for (const raw of depBatch(ctx, 2) ?? []) {
+		const request = raw as WorkspaceProposalRepairReviewRequest;
+		state.requests.set(request.repairRequestId, request);
+	}
+	if (!hasStatuses) return;
+	for (const raw of depBatch(ctx, 3) ?? []) {
+		const status = raw as WorkspaceProposalRepairReviewStatus;
+		state.statuses.set(repairReviewStatusProjectionKey(status), status);
+	}
+}
+
+function uniqueIssues(
+	issues: readonly WorkspaceProposalRecordedIssue[],
+): readonly WorkspaceProposalRecordedIssue[] {
+	const seen = new Set<string>();
+	const out: WorkspaceProposalRecordedIssue[] = [];
+	for (const issue of issues) {
+		const key = issueKey(issue);
+		if (seen.has(key)) continue;
+		seen.add(key);
+		out.push(issue);
+	}
+	return out;
+}
+
+function issueKey(issue: WorkspaceProposalRecordedIssue): string {
+	return stableStringify({
+		code: issue.code,
+		subjectId: issue.subjectId,
+		refs: issue.refs,
+		metadata: issue.metadata,
+		message: issue.message,
+	});
+}
+
+function applicationStatusProjectionKey(status: WorkspaceProposalApplicationStatus): string {
+	return stableStringify({
+		kind: status.kind,
+		applicationId: status.applicationId,
+		proposalId: status.proposalId,
+		decisionId: status.decisionId,
+		idempotencyKey: status.idempotencyKey,
+		proposalFamily: status.proposalFamily,
+	});
+}
+
+function applicationRecordedProjectionKey(record: WorkspaceProposalApplicationRecorded): string {
+	return stableStringify({
+		kind: record.kind,
+		applicationRecordId: record.applicationRecordId,
+		applicationId: record.applicationId,
+		proposalId: record.proposalId,
+		decisionId: record.decisionId,
+	});
+}
+
+function outcomeStatusProjectionKey(status: WorkspaceProposalFamilyOutcomeRecordStatus): string {
+	return stableStringify({
+		kind: status.kind,
+		outcomeId: status.outcomeId,
+		applicationId: status.applicationId,
+		proposalId: status.proposalId,
+		decisionId: status.decisionId,
+		idempotencyKey: status.idempotencyKey,
+		proposalFamily: status.proposalFamily,
+	});
+}
+
+function outcomeIndexProjectionKey(entry: WorkspaceProposalFamilyOutcomeIndexEntry): string {
+	return stableStringify({
+		kind: entry.kind,
+		indexKey: entry.indexKey,
+		applicationId: entry.applicationId,
+		proposalId: entry.proposalId,
+		decisionId: entry.decisionId,
+		idempotencyKey: entry.idempotencyKey,
+		proposalFamily: entry.proposalFamily,
+	});
+}
+
+function outcomeProjectionKey(outcome: WorkspaceProposalFamilyOutcomeRecord): string {
+	return stableStringify({
+		ref: workspaceProposalFamilyOutcomeRef(outcome),
+	});
+}
+
+function repairReviewStatusProjectionKey(status: WorkspaceProposalRepairReviewStatus): string {
+	return stableStringify({
+		repairRequestId: status.repairRequestId,
+		applicationId: status.applicationId,
+		proposalId: status.proposalId,
+		decisionId: status.decisionId,
+		idempotencyKey: status.idempotencyKey,
+		proposalFamily: status.proposalFamily,
+	});
+}
+
+function repairReviewStatusProjectionKeyFromRequest(
+	request: WorkspaceProposalRepairReviewRequest,
+): string {
+	return stableStringify({
+		repairRequestId: request.repairRequestId,
+		applicationId: request.applicationId,
+		proposalId: request.proposalId,
+		decisionId: request.decisionId,
+		idempotencyKey: request.idempotencyKey,
+		proposalFamily: request.proposalFamily,
+	});
+}
+
+function repairReviewDecisionRecordingInputKey(
+	input: WorkspaceProposalRepairReviewDecisionRecordingInput,
+): string {
+	return stableStringify({
+		reviewDecisionId: stringField(
+			(input as { readonly reviewDecisionId?: unknown }).reviewDecisionId,
+		),
+		signature: repairReviewDecisionRecordingInputSignature(input),
+	});
+}
+
+function readModelQueryProjectionKey(
+	query: WorkspaceProposalFamilyApplicationReadModelQuery,
+): string {
+	const queryId = stringField((query as { readonly queryId?: unknown }).queryId);
+	const viewId = stringField((query as { readonly viewId?: unknown }).viewId);
+	return stableStringify({
+		currentViewId: viewId ?? queryId,
+	});
+}
+
+function stringField(value: unknown): string | undefined {
+	return typeof value === "string" && value.trim() !== "" ? value : undefined;
+}
+
+export function projectWorkspaceProposalRequiredInputResponseApplication<TValue = unknown>(
+	record: WorkspaceProposalRecorded<RequiredInputResponseProposed<TValue>>,
+	decision: WorkspaceProposalAdmissionDecision,
+	options: WorkspaceProposalRequiredInputResponseApplicationOptions,
+): WorkspaceProposalRequiredInputResponseApplicationResult<TValue> {
+	const envelopeIssues = validateWorkspaceProposalApplicationEnvelope(record, decision, {
+		expectedFamily: "required-input-response",
+	});
+	const familyIssues = familySpecificEnvelopeIssues(envelopeIssues);
+	const draft = record.draft;
+	const sourceRefs = applicationSourceRefs(
+		record,
+		decision,
+		options.applicationId,
+		options.sourceRefs,
+		options.audit,
+	);
+	const contextIssues = dataOnlyFamilyIssues(record, "requiredInputApplicationOptions", options);
+	const draftIssues = requiredInputDraftIssues(record, draft, options.gate, options.request);
+	const idIssues = applicationIdIssues(record, options.applicationId);
+	const issues = [...familyIssues, ...contextIssues, ...idIssues, ...draftIssues];
+	const applied =
+		envelopeIssues.length === 0 &&
+		contextIssues.length === 0 &&
+		idIssues.length === 0 &&
+		draftIssues.length === 0 &&
+		draft !== undefined
+			? ({
+					kind: "required-input-response-applied",
+					applicationId: options.applicationId,
+					admissionId: decision.decisionId,
+					proposalId: record.proposalId,
+					requestId: draft.requestId,
+					workItemId: draft.workItemId,
+					value: draft.value,
+					summary: draft.summary,
+					sourceRefs,
+					evidenceRefs: draft.evidenceRefs,
+					artifactRefs: draft.artifactRefs,
+					appliedAtMs: options.appliedAtMs,
+					metadata: familyMetadata(record, decision, options.audit, draft.metadata),
+				} satisfies RequiredInputResponseApplied<TValue>)
+			: undefined;
+	const emittedFactRefs =
+		applied === undefined
+			? []
+			: [workspaceProposalApplicationFamilyRef(record.proposalFamily, applied, { sourceRefs })];
+	const result = projectWorkspaceProposalApplicationStatus(record, decision, {
+		applicationId: options.applicationId,
+		emittedFactRefs,
+		familyIssues: issues,
+		sourceRefs,
+		audit: options.audit,
+	});
+	return { ...result, applied };
+}
+
+export function projectWorkspaceProposalWorkItemSpawnApplication<TInput = unknown>(
+	record: WorkspaceProposalRecorded<{
+		readonly kind: "work-item-spawn-proposed";
+		readonly proposedWorkItemId?: string;
+		readonly parentWorkItemId?: string;
+		readonly draft: WorkItemDraft<TInput>;
+		readonly proposedBy?: string;
+		readonly idempotencyKey?: string;
+		readonly sourceRefs?: readonly SourceRef[];
+		readonly metadata?: Record<string, unknown>;
+	}>,
+	decision: WorkspaceProposalAdmissionDecision,
+	options: WorkspaceProposalWorkItemSpawnApplicationOptions<TInput>,
+): WorkspaceProposalWorkItemSpawnApplicationResult<TInput> {
+	const envelopeIssues = validateWorkspaceProposalApplicationEnvelope(record, decision, {
+		expectedFamily: "work-item-spawn",
+	});
+	const familyIssues = familySpecificEnvelopeIssues(envelopeIssues);
+	const draft = record.draft;
+	const sourceRefs = applicationSourceRefs(
+		record,
+		decision,
+		options.applicationId,
+		options.sourceRefs,
+		options.audit,
+	);
+	const contextIssues = dataOnlyFamilyIssues(record, "workItemSpawnApplicationOptions", options);
+	const childWorkItemId =
+		typeof draft?.proposedWorkItemId === "string" ? draft.proposedWorkItemId : "";
+	const draftIssues = spawnDraftIssues(record, draft, childWorkItemId, options.existingWorkItems);
+	const idIssues = applicationIdIssues(record, options.applicationId);
+	const issues = [...familyIssues, ...contextIssues, ...idIssues, ...draftIssues];
+	const created =
+		envelopeIssues.length === 0 &&
+		contextIssues.length === 0 &&
+		idIssues.length === 0 &&
+		draftIssues.length === 0 &&
+		draft !== undefined
+			? ({
+					kind: "work-item-created",
+					eventId: `${options.applicationId}:work-item-created:${childWorkItemId}`,
+					workItemId: childWorkItemId,
+					draft: draft.draft,
+					authorId: draft.proposedBy,
+					createdAtMs: options.createdAtMs,
+					sourceRefs,
+					metadata: {
+						...(draft.metadata ?? {}),
+						...familyMetadata(record, decision, options.audit, {
+							idempotencyKey: draft.idempotencyKey ?? record.idempotencyKey,
+						}),
+					},
+				} satisfies WorkItemCreated<TInput>)
+			: undefined;
+	const linked =
+		created !== undefined &&
+		draft !== undefined &&
+		options.linkParent === true &&
+		typeof draft.parentWorkItemId === "string" &&
+		draft.parentWorkItemId.trim() !== ""
+			? ({
+					kind: "work-item-linked",
+					eventId: `${options.applicationId}:work-item-linked:${draft.parentWorkItemId}:${childWorkItemId}`,
+					linkId: `${draft.parentWorkItemId}:spawned-from:${childWorkItemId}`,
+					fromWorkItemId: childWorkItemId,
+					toWorkItemId: draft.parentWorkItemId,
+					linkKind: "spawned-from",
+					direction: "directed",
+					sourceRefs,
+					linkedAtMs: options.linkedAtMs,
+					idempotencyKey: `${record.idempotencyKey}:spawned-from`,
+					metadata: familyMetadata(record, decision, options.audit),
+				} satisfies WorkItemLinked)
+			: undefined;
+	const emittedFactRefs: WorkspaceProposalApplicationFamilyRef[] = [];
+	if (created !== undefined) {
+		emittedFactRefs.push(
+			workspaceProposalApplicationFamilyRef(record.proposalFamily, created, { sourceRefs }),
+		);
+	}
+	if (linked !== undefined) {
+		emittedFactRefs.push(
+			workspaceProposalApplicationFamilyRef(record.proposalFamily, linked, { sourceRefs }),
+		);
+	}
+	const result = projectWorkspaceProposalApplicationStatus(record, decision, {
+		applicationId: options.applicationId,
+		emittedFactRefs,
+		familyIssues: issues,
+		sourceRefs,
+		audit: options.audit,
+	});
+	return { ...result, created, linked };
+}
+
+export function projectWorkspaceProposalWorkItemLinkApplication<TInput = unknown>(
+	record: WorkspaceProposalRecorded<WorkItemLinkProposalDraft>,
+	decision: WorkspaceProposalAdmissionDecision,
+	options: WorkspaceProposalWorkItemLinkApplicationOptions<TInput>,
+): WorkspaceProposalWorkItemLinkApplicationResult {
+	const envelopeIssues = validateWorkspaceProposalApplicationEnvelope(record, decision, {
+		expectedFamily: "work-item-link",
+	});
+	const familyIssues = familySpecificEnvelopeIssues(envelopeIssues);
+	const draft = record.draft;
+	const sourceRefs = applicationSourceRefs(
+		record,
+		decision,
+		options.applicationId,
+		options.sourceRefs,
+		options.audit,
+	);
+	const contextIssues = dataOnlyFamilyIssues(record, "workItemLinkApplicationOptions", options);
+	const draftIssues = linkDraftIssues(record, draft, options.workItems, options.links);
+	const idIssues = applicationIdIssues(record, options.applicationId);
+	const issues = [...familyIssues, ...contextIssues, ...idIssues, ...draftIssues];
+	const action = draft?.action ?? "link";
+	const linked =
+		envelopeIssues.length === 0 &&
+		contextIssues.length === 0 &&
+		idIssues.length === 0 &&
+		draftIssues.length === 0 &&
+		draft !== undefined &&
+		action === "link"
+			? ({
+					kind: "work-item-linked",
+					eventId: draft.eventId ?? `${options.applicationId}:work-item-linked:${draft.linkId}`,
+					linkId: draft.linkId,
+					fromWorkItemId: draft.fromWorkItemId ?? "",
+					toWorkItemId: draft.toWorkItemId ?? "",
+					linkKind: draft.linkKind ?? "",
+					direction: draft.direction ?? "directed",
+					sourceRefs,
+					linkedAtMs: options.linkedAtMs,
+					idempotencyKey: record.idempotencyKey,
+					metadata: familyMetadata(record, decision, options.audit, draft.metadata),
+				} satisfies WorkItemLinked)
+			: undefined;
+	const unlinked =
+		envelopeIssues.length === 0 &&
+		contextIssues.length === 0 &&
+		idIssues.length === 0 &&
+		draftIssues.length === 0 &&
+		draft !== undefined &&
+		action === "unlink"
+			? ({
+					kind: "work-item-unlinked",
+					eventId: draft.eventId ?? `${options.applicationId}:work-item-unlinked:${draft.linkId}`,
+					linkId: draft.linkId,
+					reason: draft.reason,
+					sourceRefs,
+					unlinkedAtMs: options.unlinkedAtMs,
+					metadata: familyMetadata(record, decision, options.audit, draft.metadata),
+				} satisfies WorkItemUnlinked)
+			: undefined;
+	const emittedFactRefs: WorkspaceProposalApplicationFamilyRef[] = [];
+	if (linked !== undefined) {
+		emittedFactRefs.push(
+			workspaceProposalApplicationFamilyRef(record.proposalFamily, linked, { sourceRefs }),
+		);
+	}
+	if (unlinked !== undefined) {
+		emittedFactRefs.push(
+			workspaceProposalApplicationFamilyRef(record.proposalFamily, unlinked, { sourceRefs }),
+		);
+	}
+	const result = projectWorkspaceProposalApplicationStatus(record, decision, {
+		applicationId: options.applicationId,
+		emittedFactRefs,
+		familyIssues: issues,
+		sourceRefs,
+		audit: options.audit,
+	});
+	return { ...result, linked, unlinked };
+}
+
+export function projectWorkspaceProposalDomainActionApplicationStatus(
+	record: WorkspaceProposalRecorded,
+	decision: WorkspaceProposalAdmissionDecision,
+	options: WorkspaceProposalDomainActionApplicationStatusOptions,
+): WorkspaceProposalApplicationResult {
+	const envelopeIssues = validateWorkspaceProposalApplicationEnvelope(record, decision, {
+		expectedFamily: "work-item-domain-action",
+	});
+	const familyIssues = familySpecificEnvelopeIssues(envelopeIssues);
+	const sourceRefs = applicationSourceRefs(
+		record,
+		decision,
+		options.applicationId,
+		options.sourceRefs,
+		options.audit,
+	);
+	const contextIssues = dataOnlyFamilyIssues(record, "domainActionApplicationOptions", options);
+	const idIssues = applicationIdIssues(record, options.applicationId);
+	const provenanceIssues =
+		envelopeIssues.length === 0 && contextIssues.length === 0 && idIssues.length === 0
+			? domainActionProvenanceIssues(record, decision, options)
+			: [];
+	const emittedFactRefs =
+		envelopeIssues.length === 0 &&
+		contextIssues.length === 0 &&
+		idIssues.length === 0 &&
+		provenanceIssues.length === 0
+			? options.emittedFacts.map((fact) =>
+					workspaceProposalApplicationFamilyRef(record.proposalFamily, fact, { sourceRefs }),
+				)
+			: [];
+	const applicationRef =
+		envelopeIssues.length === 0 &&
+		contextIssues.length === 0 &&
+		idIssues.length === 0 &&
+		provenanceIssues.length === 0 &&
+		options.domainApplication !== undefined
+			? workspaceProposalApplicationFamilyRef(record.proposalFamily, options.domainApplication, {
+					sourceRefs,
+				})
+			: undefined;
+	return projectWorkspaceProposalApplicationStatus(record, decision, {
+		applicationId: options.applicationId,
+		emittedFactRefs:
+			applicationRef === undefined ? emittedFactRefs : [...emittedFactRefs, applicationRef],
+		familyIssues: [...familyIssues, ...contextIssues, ...idIssues, ...provenanceIssues],
+		sourceRefs,
+		audit: options.audit,
+	});
+}
+
+function applicationIdIssues(
+	record: WorkspaceProposalRecorded,
+	applicationId: string,
+): readonly WorkspaceProposalRecordedIssue[] {
+	return blank(applicationId)
+		? [
+				familyIssue(
+					"missing-application-id",
+					"Workspace proposal application requires applicationId",
+					record,
+				),
+			]
+		: [];
+}
+
+function domainActionProvenanceIssues(
+	record: WorkspaceProposalRecorded,
+	decision: WorkspaceProposalAdmissionDecision,
+	options: WorkspaceProposalDomainActionApplicationStatusOptions,
+): readonly WorkspaceProposalRecordedIssue[] {
+	const requiredRefs = [
+		{ kind: "workspace-proposal-recorded", id: record.proposalId },
+		{ kind: "workspace-proposal-admission-decision", id: decision.decisionId },
+		{ kind: "workspace-proposal-application-status", id: options.applicationId },
+	] as const;
+	const issues: WorkspaceProposalRecordedIssue[] = [];
+	const checkRefs = (
+		label: string,
+		id: string,
+		sourceRefs: readonly SourceRef[] | undefined,
+		metadata: Record<string, unknown> | undefined,
+	): void => {
+		for (const required of requiredRefs) {
+			if (
+				sourceRefs?.some(
+					(sourceRef) => sourceRef.kind === required.kind && sourceRef.id === required.id,
+				)
+			) {
+				continue;
+			}
+			issues.push(
+				familyIssue(
+					"missing-family-application-provenance",
+					`${label} '${id}' must carry D430 Workspace proposal application provenance`,
+					record,
+				),
+			);
+			return;
+		}
+		if (metadata?.applicationIdempotencyKey !== record.idempotencyKey) {
+			issues.push(
+				familyIssue(
+					"missing-family-application-provenance",
+					`${label} '${id}' must carry D430 idempotency provenance`,
+					record,
+				),
+			);
+		}
+	};
+	for (const fact of options.emittedFacts) {
+		checkRefs("WorkItem domain action fact", fact.eventId, fact.sourceRefs, fact.metadata);
+	}
+	if (options.domainApplication !== undefined) {
+		checkRefs(
+			"WorkItem domain action application",
+			options.domainApplication.applicationId,
+			options.domainApplication.sourceRefs,
+			options.domainApplication.metadata,
+		);
+	}
+	return issues;
+}
+
+type WorkspaceProposalFamilyOutcomeOptions =
+	| WorkspaceProposalRequiredInputResponseOutcomeOptions
+	| WorkspaceProposalWorkItemSpawnOutcomeOptions
+	| WorkspaceProposalWorkItemLinkOutcomeOptions
+	| WorkspaceProposalDomainActionOutcomeOptions;
+
+interface FamilyOutcomeBuilderResult<TOutcome extends WorkspaceProposalFamilyOutcomeRecord> {
+	readonly issues: readonly WorkspaceProposalRecordedIssue[];
+	readonly outcome?: Omit<TOutcome, "sourceRefs" | "audit" | "metadata">;
+	readonly partial?: boolean;
+}
+
+function recordFamilyOutcome<TOutcome extends WorkspaceProposalFamilyOutcomeRecord>(
+	status: WorkspaceProposalApplicationStatus,
+	expectedFamily: WorkspaceProposalFamily,
+	options: WorkspaceProposalFamilyOutcomeOptions,
+	build: () => FamilyOutcomeBuilderResult<TOutcome>,
+): WorkspaceProposalFamilyOutcomeRecordResult<TOutcome> {
+	const baseIssues = familyOutcomeBaseIssues(status, expectedFamily, options);
+	const built = baseIssues.length === 0 ? build() : { issues: [] };
+	const issues = [...baseIssues, ...built.issues];
+	const sourceRefs = familyOutcomeSourceRefs(status, options);
+	const outcome =
+		issues.length === 0 && built.outcome !== undefined
+			? ({
+					...built.outcome,
+					sourceRefs,
+					audit: options.audit ?? status.audit,
+					metadata: options.metadata,
+				} as TOutcome)
+			: undefined;
+	const outcomeRefs = outcome === undefined ? [] : [workspaceProposalFamilyOutcomeRef(outcome)];
+	return {
+		outcome,
+		status: {
+			kind: "workspace-proposal-family-outcome-record-status",
+			outcomeId: options.outcomeId,
+			applicationId: status.applicationId,
+			proposalId: status.proposalId,
+			decisionId: status.decisionId,
+			idempotencyKey: status.idempotencyKey,
+			proposalFamily: status.proposalFamily,
+			state:
+				baseIssues.length > 0
+					? "not-recorded"
+					: familyOutcomeRecordState(issues, built.partial === true, outcome, options.horizon),
+			code: issues[0]?.code,
+			issues,
+			outcomeRefs,
+			sourceRefs,
+			audit: options.audit ?? status.audit,
+			metadata: options.metadata,
+		},
+		issues,
+	};
+}
+
+function familyOutcomeBaseIssues(
+	status: WorkspaceProposalApplicationStatus,
+	expectedFamily: WorkspaceProposalFamily,
+	options: WorkspaceProposalFamilyOutcomeOptions,
+): readonly WorkspaceProposalRecordedIssue[] {
+	const issues: WorkspaceProposalRecordedIssue[] = [];
+	issues.push(...familyOutcomeDataOnlyIssues(status, "familyOutcomeApplicationStatus", status));
+	issues.push(...familyOutcomeDataOnlyIssues(status, "familyOutcomeOptions", options));
+	if (status.kind !== "workspace-proposal-application-status") {
+		issues.push(
+			familyOutcomeIssue(
+				status,
+				"malformed-application-status",
+				"Workspace family outcome requires application status material",
+			),
+		);
+	}
+	if (status.state !== "applied" && status.state !== "recorded") {
+		issues.push(
+			familyOutcomeIssue(
+				status,
+				"application-not-recordable",
+				"Workspace family outcome requires applied application status",
+			),
+		);
+	}
+	if (status.issues.length > 0) {
+		issues.push(
+			familyOutcomeIssue(
+				status,
+				"application-status-has-issues",
+				"Workspace family outcome requires issue-free application status",
+			),
+		);
+	}
+	if (status.proposalFamily !== expectedFamily) {
+		issues.push(
+			familyOutcomeIssue(
+				status,
+				"unexpected-proposal-family",
+				`Workspace family outcome expected '${expectedFamily}' application status`,
+			),
+		);
+	}
+	if (blank(options.outcomeId)) {
+		issues.push(
+			familyOutcomeIssue(status, "missing-required-field", "Family outcome requires outcomeId"),
+		);
+	}
+	if (!status.emittedFactRefs.some((ref) => ref.proposalFamily === expectedFamily)) {
+		issues.push(
+			familyOutcomeIssue(
+				status,
+				"missing-family-application-ref",
+				"Family outcome requires matching family application refs",
+			),
+		);
+	}
+	if (options.horizon !== undefined) {
+		if (options.horizon.kind !== "workspace-proposal-family-evidence-horizon") {
+			issues.push(
+				familyOutcomeIssue(
+					status,
+					"malformed-family-evidence-horizon",
+					"Evidence horizon is malformed",
+				),
+			);
+		}
+		if (options.horizon.applicationId !== status.applicationId) {
+			issues.push(
+				familyOutcomeIssue(
+					status,
+					"proposal-target-mismatch",
+					"Evidence horizon applicationId does not match application status",
+				),
+			);
+		}
+	}
+	if (options.policy !== undefined) {
+		if (options.policy.kind !== "workspace-proposal-family-completion-policy") {
+			issues.push(
+				familyOutcomeIssue(
+					status,
+					"malformed-family-completion-policy",
+					"Completion policy is malformed",
+				),
+			);
+		}
+		if (
+			options.policy.proposalFamily !== undefined &&
+			options.policy.proposalFamily !== expectedFamily
+		) {
+			issues.push(
+				familyOutcomeIssue(
+					status,
+					"unexpected-proposal-family",
+					"Completion policy proposalFamily does not match family outcome",
+				),
+			);
+		}
+	}
+	return issues;
+}
+
+function familyOutcomeRecordState(
+	issues: readonly WorkspaceProposalRecordedIssue[],
+	partial: boolean,
+	outcome: WorkspaceProposalFamilyOutcomeRecord | undefined,
+	horizon: WorkspaceProposalFamilyEvidenceHorizon | undefined,
+): WorkspaceProposalFamilyOutcomeRecordState {
+	if (outcome !== undefined) return "recorded";
+	if (partial && issues.length === 0) return "partial";
+	if (issues.length === 0) return "not-recorded";
+	return horizon?.state === "closed" ? "repair-needed" : "pending";
+}
+
+function familyOutcomeCoordinates(
+	status: WorkspaceProposalApplicationStatus,
+	options: WorkspaceProposalFamilyOutcomeOptions,
+) {
+	return {
+		outcomeId: options.outcomeId,
+		applicationId: status.applicationId,
+		proposalId: status.proposalId,
+		decisionId: status.decisionId,
+		idempotencyKey: status.idempotencyKey,
+	};
+}
+
+function familyOutcomeSourceRefs(
+	status: WorkspaceProposalApplicationStatus,
+	options: WorkspaceProposalFamilyOutcomeOptions,
+): readonly SourceRef[] {
+	return uniqueRefs([
+		{ kind: "workspace-proposal-application-status", id: status.applicationId },
+		...status.sourceRefs,
+		...(options.sourceRefs ?? []),
+		...(options.horizon?.sourceRefs ?? []),
+		...(options.policy?.sourceRefs ?? []),
+		...(options.audit?.sourceRefs ?? []),
+	]);
+}
+
+function nonBlankFieldIssue(
+	status: WorkspaceProposalApplicationStatus,
+	value: unknown,
+	field: string,
+): readonly WorkspaceProposalRecordedIssue[] {
+	return blank(value)
+		? [familyOutcomeIssue(status, "missing-required-field", `Family outcome requires ${field}`)]
+		: [];
+}
+
+function sourceRefFieldIssue(
+	status: WorkspaceProposalApplicationStatus,
+	value: unknown,
+	field: string,
+): readonly WorkspaceProposalRecordedIssue[] {
+	return isSourceRef(value)
+		? []
+		: [familyOutcomeIssue(status, "missing-required-field", `Family outcome requires ${field}`)];
+}
+
+function isSourceRef(value: unknown): value is SourceRef {
+	return isRecord(value) && nonBlankString(value.kind) && nonBlankString(value.id);
+}
+
+function familyOutcomeDataOnlyIssues(
+	status: WorkspaceProposalApplicationStatus,
+	label: string,
+	value: unknown,
+): readonly WorkspaceProposalRecordedIssue[] {
+	return workspaceProposalDataOnlyIssues(value, label).map((entry) => ({
+		...entry,
+		subjectId: entry.subjectId ?? status.proposalId,
+		refs: entry.refs ?? familyOutcomeIssueRefs(status),
+	}));
+}
+
+function familyOutcomeIssue(
+	subject:
+		| WorkspaceProposalApplicationStatus
+		| WorkspaceProposalFamilyOutcomeRecord
+		| Pick<
+				WorkspaceProposalFamilyOutcomeRecord,
+				"applicationId" | "proposalId" | "decisionId" | "idempotencyKey" | "sourceRefs"
+		  >,
+	code: string,
+	message: string,
+): WorkspaceProposalRecordedIssue {
+	return {
+		kind: "issue",
+		source: "workspace-proposal",
+		severity: "error",
+		code,
+		message,
+		subjectId: subject.proposalId,
+		refs: familyOutcomeIssueRefs(subject),
+	};
+}
+
+function familyOutcomeIssueRefs(
+	subject:
+		| WorkspaceProposalApplicationStatus
+		| WorkspaceProposalFamilyOutcomeRecord
+		| Pick<
+				WorkspaceProposalFamilyOutcomeRecord,
+				"applicationId" | "proposalId" | "decisionId" | "idempotencyKey" | "sourceRefs"
+		  >,
+): readonly string[] {
+	return [
+		`workspace-proposal-application-status:${subject.applicationId}`,
+		`workspace-proposal-recorded:${subject.proposalId}`,
+		`workspace-proposal-admission-decision:${subject.decisionId}`,
+		...subject.sourceRefs.map((sourceRef) => `${sourceRef.kind}:${sourceRef.id}`),
+	];
+}
+
+function familyOutcomeIndexKey(outcome: WorkspaceProposalFamilyOutcomeRecord): string {
+	return `${outcome.applicationId}:${outcome.idempotencyKey}`;
+}
+
+function familyOutcomeSignature(outcome: WorkspaceProposalFamilyOutcomeRecord): string {
+	return stableStringify({
+		ref: workspaceProposalFamilyOutcomeRef(outcome),
+		result: familyOutcomeResultSignatureMaterial(outcome),
+	});
+}
+
+function familyOutcomeResultSignatureMaterial(
+	outcome: WorkspaceProposalFamilyOutcomeRecord,
+): unknown {
+	switch (outcome.kind) {
+		case "workspace-proposal-required-input-response-outcome-recorded":
+			return {
+				requiredInputRequestId: outcome.requiredInputRequestId,
+				responseRef: outcome.responseRef,
+			};
+		case "workspace-proposal-work-item-spawn-outcome-recorded":
+			return { workItemRef: outcome.workItemRef };
+		case "workspace-proposal-work-item-link-outcome-recorded":
+			return { linkRef: outcome.linkRef };
+		case "workspace-proposal-domain-action-outcome-recorded":
+			return { actionRef: outcome.actionRef };
+	}
+}
+
+function dataOnlyFamilyIssues(
+	record: WorkspaceProposalRecorded,
+	label: string,
+	value: unknown,
+): readonly WorkspaceProposalRecordedIssue[] {
+	return workspaceProposalDataOnlyIssues(value, label).map((entry) => ({
+		...entry,
+		subjectId: entry.subjectId ?? record.proposalId,
+		refs: entry.refs ?? recordRefs(record),
+	}));
+}
+
+function familySpecificEnvelopeIssues(
+	issues: readonly WorkspaceProposalRecordedIssue[],
+): readonly WorkspaceProposalRecordedIssue[] {
+	return issues.filter((entry) => entry.code === "unexpected-proposal-family");
+}
+
+function requiredInputDraftIssues<TValue>(
+	record: WorkspaceProposalRecorded,
+	draft: RequiredInputResponseProposed<TValue> | undefined,
+	gate: RequiredInputGate,
+	request: RequiredInputRequest | undefined,
+): readonly WorkspaceProposalRecordedIssue[] {
+	const issues: WorkspaceProposalRecordedIssue[] = [
+		...requiredInputDraftShapeIssues(record, draft),
+	];
+	if (issues.length > 0) return issues;
+	const responseDraft = draft as RequiredInputResponseProposed<TValue>;
+	if (gate.kind !== "required-input-gate") {
+		issues.push(
+			familyIssue("malformed-family-context", "Required Input gate is malformed", record),
+		);
+		return issues;
+	}
+	if (gate.status !== "requested" && gate.status !== "response-proposed") {
+		issues.push(familyIssue("stale-target-ref", "Required Input gate is not open", record));
+	}
+	if (gate.requestId !== responseDraft.requestId || gate.workItemId !== responseDraft.workItemId) {
+		issues.push(
+			familyIssue(
+				"proposal-target-mismatch",
+				"Required Input response does not match gate target",
+				record,
+			),
+		);
+	}
+	if (
+		request !== undefined &&
+		(request.requestId !== responseDraft.requestId ||
+			request.workItemId !== responseDraft.workItemId)
+	) {
+		issues.push(
+			familyIssue(
+				"proposal-target-mismatch",
+				"Required Input response does not match request target",
+				record,
+			),
+		);
+	}
+	return issues;
+}
+
+function requiredInputDraftShapeIssues<TValue>(
+	record: WorkspaceProposalRecorded,
+	draft: RequiredInputResponseProposed<TValue> | undefined,
+): readonly WorkspaceProposalRecordedIssue[] {
+	return !isRecord(draft) || draft.kind !== "required-input-response-proposed"
+		? [familyIssue("malformed-family-draft", "Required Input response draft is malformed", record)]
+		: [];
+}
+
+function spawnDraftIssues<TInput>(
+	record: WorkspaceProposalRecorded,
+	draft:
+		| {
+				readonly kind: "work-item-spawn-proposed";
+				readonly proposedWorkItemId?: string;
+				readonly draft: WorkItemDraft<TInput>;
+		  }
+		| undefined,
+	childWorkItemId: string,
+	existingWorkItems: readonly WorkItemProjection<TInput>[] | undefined,
+): readonly WorkspaceProposalRecordedIssue[] {
+	const issues: WorkspaceProposalRecordedIssue[] = [];
+	if (!isRecord(draft) || draft.kind !== "work-item-spawn-proposed") {
+		issues.push(familyIssue("malformed-family-draft", "WorkItem spawn draft is malformed", record));
+		return issues;
+	}
+	if (childWorkItemId.trim() === "") {
+		issues.push(
+			familyIssue("missing-required-field", "WorkItem spawn requires proposedWorkItemId", record),
+		);
+		return issues;
+	}
+	if (existingWorkItems?.some((item) => item.workItemId === childWorkItemId) === true) {
+		issues.push(
+			familyIssue("duplicate-id", `WorkItem '${childWorkItemId}' already exists`, record),
+		);
+	}
+	for (const issue of validateWorkItemDraft(draft.draft, { workItemId: childWorkItemId })) {
+		issues.push({
+			kind: "issue",
+			source: "workspace-proposal",
+			severity: "error",
+			code: issue.code,
+			message: issue.message,
+			subjectId: record.proposalId,
+			refs: recordRefs(record),
+		});
+	}
+	return issues;
+}
+
+function linkDraftIssues<TInput>(
+	record: WorkspaceProposalRecorded,
+	draft: WorkItemLinkProposalDraft | undefined,
+	workItems: readonly WorkItemProjection<TInput>[] | undefined,
+	links: readonly WorkItemLinkProjection[] | undefined,
+): readonly WorkspaceProposalRecordedIssue[] {
+	const issues: WorkspaceProposalRecordedIssue[] = [];
+	if (!isRecord(draft) || draft.kind !== "work-item-link-proposal") {
+		issues.push(familyIssue("malformed-family-draft", "WorkItem link draft is malformed", record));
+		return issues;
+	}
+	if (!nonBlankString(draft.linkId)) {
+		issues.push(
+			familyIssue("missing-required-field", "WorkItem link proposal requires linkId", record),
+		);
+		return issues;
+	}
+	if (draft.action !== undefined && draft.action !== "link" && draft.action !== "unlink") {
+		issues.push(
+			familyIssue(
+				"unsupported-family-action",
+				"WorkItem link proposal action must be link or unlink",
+				record,
+			),
+		);
+		return issues;
+	}
+	if ((draft.action ?? "link") === "unlink") {
+		const existing = links?.find((link) => link.linkId === draft.linkId);
+		if (existing === undefined || !existing.active) {
+			issues.push(
+				familyIssue("unknown-target-ref", "WorkItem unlink references no active link", record),
+			);
+		}
+		return issues;
+	}
+	if (blank(draft.fromWorkItemId) || blank(draft.toWorkItemId) || blank(draft.linkKind)) {
+		issues.push(
+			familyIssue(
+				"missing-required-field",
+				"WorkItem link proposal requires fromWorkItemId, toWorkItemId, and linkKind",
+				record,
+			),
+		);
+		return issues;
+	}
+	if (
+		workItems !== undefined &&
+		(!workItems.some((item) => item.workItemId === draft.fromWorkItemId) ||
+			!workItems.some((item) => item.workItemId === draft.toWorkItemId))
+	) {
+		issues.push(
+			familyIssue(
+				"unknown-target-ref",
+				"WorkItem link proposal references unknown WorkItem",
+				record,
+			),
+		);
+	}
+	return issues;
+}
+
+function familyIssue(
+	code: string,
+	message: string,
+	record: WorkspaceProposalRecorded,
+): WorkspaceProposalRecordedIssue {
+	return {
+		kind: "issue",
+		source: "workspace-proposal",
+		severity: "error",
+		code,
+		message,
+		subjectId: record.proposalId,
+		refs: recordRefs(record),
+	};
+}
+
+function familyMetadata(
+	record: WorkspaceProposalRecorded,
+	decision: WorkspaceProposalAdmissionDecision,
+	audit: WorkspaceProposalAuditMaterial | undefined,
+	metadata: Record<string, unknown> = {},
+): Record<string, unknown> {
+	return {
+		...metadata,
+		applicationProposalId: record.proposalId,
+		applicationDecisionId: decision.decisionId,
+		applicationIntakeRequestId: record.intakeRequestId,
+		applicationIdempotencyKey: record.idempotencyKey,
+		applicationPolicyRefs: record.policyRefs,
+		applicationAudit: audit ?? record.audit ?? decision.audit,
+	};
+}
+
+function applicationSourceRefs(
+	record: WorkspaceProposalRecorded,
+	decision: WorkspaceProposalAdmissionDecision,
+	applicationId: string,
+	sourceRefs: readonly SourceRef[] | undefined,
+	audit: WorkspaceProposalAuditMaterial | undefined,
+): readonly SourceRef[] {
+	return uniqueRefs([
+		{ kind: "workspace-proposal-recorded", id: record.proposalId },
+		{ kind: "workspace-proposal-admission-decision", id: decision.decisionId },
+		{ kind: "workspace-proposal-application-status", id: applicationId },
+		...record.sourceRefs,
+		...decision.sourceRefs,
+		...(record.audit?.sourceRefs ?? []),
+		...(decision.audit?.sourceRefs ?? []),
+		...(audit?.sourceRefs ?? []),
+		...(sourceRefs ?? []),
+	]);
+}
+
+function uniqueRefs(sourceRefs: readonly SourceRef[]): readonly SourceRef[] {
+	const seen = new Set<string>();
+	const out: SourceRef[] = [];
+	for (const sourceRef of sourceRefs) {
+		const key = `${sourceRef.kind}:${sourceRef.id}:${JSON.stringify(sourceRef.metadata ?? {})}`;
+		if (seen.has(key)) continue;
+		seen.add(key);
+		out.push(sourceRef);
+	}
+	return out;
+}
+
+function uniqueStrings(values: readonly string[]): readonly string[] {
+	return [...new Set(values)].sort();
+}
+
+function recordRefs(record: WorkspaceProposalRecorded): readonly string[] {
+	return [
+		`workspace-proposal-recorded:${record.proposalId}`,
+		`workspace-proposal-intake-request:${record.intakeRequestId}`,
+		...record.sourceRefs.map((sourceRef) => `${sourceRef.kind}:${sourceRef.id}`),
+	];
+}
+
+function blank(value: unknown): value is undefined | null | "" {
+	return typeof value !== "string" || value.trim() === "";
+}
+
+function nonBlankString(value: unknown): value is string {
+	return typeof value === "string" && value.trim() !== "";
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return value !== null && typeof value === "object";
+}
+
+function isDenseArray(value: readonly unknown[]): boolean {
+	for (let index = 0; index < value.length; index += 1) {
+		if (!Object.hasOwn(value, index)) return false;
+	}
+	return true;
+}
+
+function familyProjectorState<TInput, TDraft>(
+	ctx: Ctx,
+): WorkspaceProposalFamilyProjectorState<TInput, TDraft> {
+	return (
+		ctx.state.get<WorkspaceProposalFamilyProjectorState<TInput, TDraft>>() ?? {
+			records: new Map(),
+			decisionsByProposal: new Map(),
+			decisionsById: new Map(),
+			contexts: new Map(),
+			gates: new Map(),
+			requests: new Map(),
+			workItems: new Map(),
+			links: new Map(),
+			emittedDomainFacts: new Map(),
+			domainApplications: new Map(),
+			applicationRefs: new Map(),
+			factOwners: new Map(),
+			durableHandoffDiagnostics: new Set(),
+		}
+	);
+}
+
+function runtimeOptions(name: string, factory: string) {
+	return {
+		name: `${name}/runtime`,
+		factory,
+		partial: true,
+		completeWhenDepsComplete: false,
+		errorWhenDepsError: false,
+	};
+}
+
+function familyBundle(
+	graph: Graph,
+	runtime: Node<WorkspaceProposalFamilyApplicationRuntimeFact>,
+	name: string,
+	familyOutputs: Partial<Record<"applied" | "created" | "linked" | "unlinked", string>>,
+): Record<string, Node<unknown>> {
+	const out: Record<string, Node<unknown>> = {
+		status: project(graph, runtime, `${name}/status`, `${name}Status`, (fact) =>
+			fact.kind === "status" ? fact.value : undefined,
+		),
+		recorded: project(graph, runtime, `${name}/recorded`, `${name}Recorded`, (fact) =>
+			fact.kind === "recorded" ? fact.value : undefined,
+		),
+		issues: project(graph, runtime, `${name}/issues`, `${name}Issues`, (fact) =>
+			fact.kind === "issue" ? fact.value : undefined,
+		),
+		audit: project(graph, runtime, `${name}/audit`, `${name}Audit`, (fact) =>
+			fact.kind === "audit" ? fact.value : undefined,
+		),
+	};
+	for (const [key, kind] of Object.entries(familyOutputs)) {
+		out[key] = project(graph, runtime, `${name}/${key}`, `${name}${capitalize(key)}`, (fact) =>
+			fact.kind === kind ? fact.value : undefined,
+		);
+	}
+	return out;
+}
+
+function ingestRecords<TInput, TDraft>(
+	ctx: Ctx,
+	state: WorkspaceProposalFamilyProjectorState<TInput, TDraft>,
+	depIndex: number,
+): void {
+	for (const raw of depBatch(ctx, depIndex) ?? []) {
+		const record = raw as WorkspaceProposalRecorded<TDraft>;
+		state.records.set(record.proposalId, record);
+	}
+}
+
+function ingestDecisions<TInput, TDraft>(
+	ctx: Ctx,
+	state: WorkspaceProposalFamilyProjectorState<TInput, TDraft>,
+	depIndex: number,
+): void {
+	for (const raw of depBatch(ctx, depIndex) ?? []) {
+		const decision = raw as WorkspaceProposalAdmissionDecision;
+		state.decisionsByProposal.set(decision.proposalId, decision);
+		state.decisionsById.set(decision.decisionId, decision);
+	}
+}
+
+function ingestContexts<TInput, TDraft>(
+	ctx: Ctx,
+	state: WorkspaceProposalFamilyProjectorState<TInput, TDraft>,
+	depIndex: number,
+): void {
+	for (const raw of depBatch(ctx, depIndex) ?? []) {
+		const context = raw as WorkspaceProposalFamilyProjectorState<
+			TInput,
+			TDraft
+		>["contexts"] extends Map<string, infer TContext>
+			? TContext
+			: never;
+		state.contexts.set(context.applicationId, context);
+	}
+}
+
+function ingestWorkItems<TInput, TDraft>(
+	ctx: Ctx,
+	state: WorkspaceProposalFamilyProjectorState<TInput, TDraft>,
+	depIndex: number,
+): void {
+	for (const raw of depBatch(ctx, depIndex) ?? []) {
+		const workItem = raw as WorkItemProjection<TInput>;
+		state.workItems.set(workItem.workItemId, workItem);
+	}
+}
+
+function decisionForContext<TInput, TDraft>(
+	state: WorkspaceProposalFamilyProjectorState<TInput, TDraft>,
+	context: { readonly proposalId: string; readonly decisionId?: string },
+): WorkspaceProposalAdmissionDecision | undefined {
+	return context.decisionId === undefined
+		? state.decisionsByProposal.get(context.proposalId)
+		: state.decisionsById.get(context.decisionId);
+}
+
+function requiredInputContextGate<TValue>(
+	state: WorkspaceProposalFamilyProjectorState<unknown, RequiredInputResponseProposed<TValue>>,
+	context: WorkspaceProposalRequiredInputResponseApplicationContext,
+	draft: RequiredInputResponseProposed<TValue> | undefined,
+): RequiredInputGate | undefined {
+	if (context.gateId !== undefined) return state.gates.get(context.gateId);
+	const requestId = context.requestId ?? draft?.requestId;
+	const workItemId = draft?.workItemId;
+	return requestId === undefined || workItemId === undefined
+		? undefined
+		: state.gates.get(`${requestId}:${workItemId}`);
+}
+
+function requiredInputContextRequest<TValue>(
+	state: WorkspaceProposalFamilyProjectorState<unknown, RequiredInputResponseProposed<TValue>>,
+	context: WorkspaceProposalRequiredInputResponseApplicationContext,
+	draft: RequiredInputResponseProposed<TValue> | undefined,
+): RequiredInputRequest | undefined {
+	const requestId = context.requestId ?? draft?.requestId;
+	const workItemId = draft?.workItemId;
+	if (requestId === undefined) return undefined;
+	return workItemId === undefined
+		? state.requests.get(requestId)
+		: (state.requests.get(`${requestId}:${workItemId}`) ?? state.requests.get(requestId));
+}
+
+function selectDomainFacts(
+	state: WorkspaceProposalFamilyProjectorState,
+	context: WorkspaceProposalDomainActionApplicationContext,
+): {
+	readonly facts: readonly WorkItemAuthoringFact[];
+	readonly missingFactIds: readonly string[];
+} {
+	if (context.emittedFactIds !== undefined) {
+		const facts: WorkItemAuthoringFact[] = [];
+		const missingFactIds: string[] = [];
+		for (const factId of context.emittedFactIds) {
+			const fact = state.emittedDomainFacts.get(factId);
+			if (fact === undefined) missingFactIds.push(factId);
+			else facts.push(fact);
+		}
+		return { facts, missingFactIds };
+	}
+	return {
+		facts: [...state.emittedDomainFacts.values()].filter((fact) =>
+			fact.sourceRefs?.some(
+				(sourceRef) =>
+					sourceRef.kind === "workspace-proposal-application-status" &&
+					sourceRef.id === context.applicationId,
+			),
+		),
+		missingFactIds: [],
+	};
+}
+
+function emitApplicationResult<TInput, TDraft>(
+	ctx: Ctx,
+	state: WorkspaceProposalFamilyProjectorState<TInput, TDraft>,
+	result: WorkspaceProposalApplicationResult,
+	familyFacts: readonly WorkspaceProposalEmittableFamilyFact[],
+): void {
+	if (result.status.state === "applied") {
+		const priorRefs = state.applicationRefs.get(result.status.applicationId);
+		if (priorRefs !== undefined) {
+			if (!sameReplayEntry(priorRefs, result)) {
+				emitApplicationStatusFacts(
+					ctx,
+					idempotencyConflictResult(result, "application-replay-provenance-conflict"),
+					"conflict",
+				);
+				return;
+			}
+			if (
+				refsSignature(priorRefs.emittedFactRefs) === refsSignature(result.status.emittedFactRefs)
+			) {
+				emitApplicationStatusFacts(ctx, result, "re-referenced");
+				return;
+			}
+			emitApplicationStatusFacts(
+				ctx,
+				idempotencyConflictResult(result, "application-replay-conflict"),
+				"conflict",
+			);
+			return;
+		}
+		const duplicateOwner = firstConflictingFactOwner(state, result);
+		if (duplicateOwner !== undefined) {
+			emitApplicationStatusFacts(
+				ctx,
+				idempotencyConflictResult(result, `family-fact-owned-by:${duplicateOwner}`),
+				"conflict",
+			);
+			return;
+		}
+		for (const ref of result.status.emittedFactRefs) {
+			state.factOwners.set(factKey(ref), result.status.applicationId);
+		}
+		state.applicationRefs.set(result.status.applicationId, replayEntry(result));
+		for (const fact of familyFacts) emitFamilyFact(ctx, fact);
+	}
+	emitApplicationStatusFacts(ctx, result);
+}
+
+function emitApplicationStatusFacts(
+	ctx: Ctx,
+	result: WorkspaceProposalApplicationResult,
+	replayState?: "re-referenced" | "conflict",
+): void {
+	emitRuntime(ctx, "status", result.status);
+	if (result.recorded !== undefined) emitRuntime(ctx, "recorded", result.recorded);
+	for (const issue of result.issues) emitRuntime(ctx, "issue", issue);
+	emitRuntime(ctx, "audit", {
+		kind: "workspace-proposal-family-application-audit",
+		auditId: `${result.status.applicationId}:${result.status.state}:audit`,
+		applicationId: result.status.applicationId,
+		proposalId: result.status.proposalId,
+		decisionId: result.status.decisionId,
+		proposalFamily: result.status.proposalFamily,
+		state: result.status.state,
+		emittedFactRefs: result.status.emittedFactRefs,
+		sourceRefs: result.status.sourceRefs,
+		audit: result.status.audit,
+		metadata: replayState === undefined ? undefined : { replayState },
+	});
+}
+
+function emitMissingDurableHandoffDiagnostics<TInput, TDraft>(
+	ctx: Ctx,
+	state: WorkspaceProposalFamilyProjectorState<TInput, TDraft>,
+	context: {
+		readonly applicationId: string;
+		readonly proposalId: string;
+		readonly decisionId?: string;
+		readonly sourceRefs?: readonly SourceRef[];
+		readonly audit?: WorkspaceProposalAuditMaterial;
+	},
+	proposalFamily: WorkspaceProposalFamily,
+): void {
+	const record = state.records.get(context.proposalId);
+	const decision = decisionForContext(state, context);
+	const issues: WorkspaceProposalRecordedIssue[] = [];
+	if (record === undefined) {
+		issues.push(
+			missingDurableHandoffIssue(
+				context,
+				"missing-workspace-proposal-recorded",
+				"Workspace family application context references a missing durable proposal record",
+			),
+		);
+	}
+	if (decision === undefined) {
+		issues.push(
+			missingDurableHandoffIssue(
+				context,
+				"missing-workspace-proposal-admission-decision",
+				"Workspace family application context references a missing durable admission decision",
+			),
+		);
+	}
+	const newIssues = issues.filter((issue) => {
+		const key = durableHandoffDiagnosticKey(context, issue.code);
+		if (state.durableHandoffDiagnostics.has(key)) return false;
+		state.durableHandoffDiagnostics.add(key);
+		return true;
+	});
+	if (newIssues.length === 0) return;
+	for (const issue of newIssues) emitRuntime(ctx, "issue", issue);
+	emitRuntime(ctx, "audit", {
+		kind: "workspace-proposal-family-application-audit",
+		auditId: `${context.applicationId}:missing-durable-handoff:audit`,
+		applicationId: context.applicationId,
+		proposalId: context.proposalId,
+		decisionId: context.decisionId,
+		proposalFamily,
+		state: "pending",
+		code: "missing-durable-handoff",
+		issues: newIssues,
+		emittedFactRefs: [],
+		sourceRefs: missingDurableHandoffSourceRefs(context),
+		audit: context.audit,
+		metadata: {
+			diagnostic: "missing-durable-handoff",
+			missingRecord: record === undefined,
+			missingDecision: decision === undefined,
+		},
+	});
+}
+
+function missingDurableHandoffIssue(
+	context: {
+		readonly applicationId: string;
+		readonly proposalId: string;
+		readonly decisionId?: string;
+		readonly sourceRefs?: readonly SourceRef[];
+	},
+	code: string,
+	message: string,
+): WorkspaceProposalRecordedIssue {
+	return {
+		kind: "issue",
+		source: "workspace-proposal",
+		severity: "error",
+		code,
+		message,
+		subjectId: context.proposalId,
+		refs: missingDurableHandoffRefs(context),
+		metadata: {
+			applicationId: context.applicationId,
+			proposalId: context.proposalId,
+			...(context.decisionId === undefined ? {} : { decisionId: context.decisionId }),
+		},
+	};
+}
+
+function durableHandoffDiagnosticKey(
+	context: {
+		readonly applicationId: string;
+		readonly proposalId: string;
+		readonly decisionId?: string;
+	},
+	code: string,
+): string {
+	return `${context.applicationId}:${context.proposalId}:${context.decisionId ?? "<by-proposal>"}:${code}`;
+}
+
+function missingDurableHandoffRefs(context: {
+	readonly applicationId: string;
+	readonly proposalId: string;
+	readonly decisionId?: string;
+	readonly sourceRefs?: readonly SourceRef[];
+}): readonly string[] {
+	return [
+		`workspace-proposal-application-context:${context.applicationId}`,
+		`workspace-proposal-recorded:${context.proposalId}`,
+		...(context.decisionId === undefined
+			? []
+			: [`workspace-proposal-admission-decision:${context.decisionId}`]),
+		...(context.sourceRefs ?? []).map((sourceRef) => `${sourceRef.kind}:${sourceRef.id}`),
+	];
+}
+
+function missingDurableHandoffSourceRefs(context: {
+	readonly applicationId: string;
+	readonly proposalId: string;
+	readonly decisionId?: string;
+	readonly sourceRefs?: readonly SourceRef[];
+}): readonly SourceRef[] {
+	return uniqueRefs([
+		{ kind: "workspace-proposal-application-context", id: context.applicationId },
+		{ kind: "workspace-proposal-recorded", id: context.proposalId },
+		...(context.decisionId === undefined
+			? []
+			: [{ kind: "workspace-proposal-admission-decision", id: context.decisionId }]),
+		...(context.sourceRefs ?? []),
+	]);
+}
+
+function emitFamilyFact(ctx: Ctx, fact: WorkspaceProposalEmittableFamilyFact): void {
+	emitRuntime(ctx, fact.kind, fact);
+}
+
+function emitRuntime<K extends WorkspaceProposalFamilyApplicationRuntimeFact["kind"]>(
+	ctx: Ctx,
+	kind: K,
+	value: Extract<WorkspaceProposalFamilyApplicationRuntimeFact, { readonly kind: K }>["value"],
+): void {
+	ctx.down([["DATA", { kind, value }]]);
+}
+
+type WorkspaceProposalEmittableFamilyFact =
+	| RequiredInputResponseApplied
+	| WorkItemCreated
+	| WorkItemLinked
+	| WorkItemUnlinked;
+
+function missingFamilyMaterialResult(
+	record: WorkspaceProposalRecorded,
+	decision: WorkspaceProposalAdmissionDecision,
+	context: {
+		readonly applicationId: string;
+		readonly sourceRefs?: readonly SourceRef[];
+		readonly audit?: WorkspaceProposalAuditMaterial;
+	},
+	code: string,
+): WorkspaceProposalApplicationResult {
+	const generic = projectWorkspaceProposalApplicationStatus(record, decision, {
+		applicationId: context.applicationId,
+		sourceRefs: context.sourceRefs,
+		audit: context.audit,
+	});
+	if (generic.status.state === "blocked") return generic;
+	return projectWorkspaceProposalApplicationStatus(record, decision, {
+		applicationId: context.applicationId,
+		familyIssues: [
+			familyIssue(code, "Workspace proposal family application material is missing", record),
+		],
+		state: "repair-needed",
+		code,
+		sourceRefs: context.sourceRefs,
+		audit: context.audit,
+	});
+}
+
+function idempotencyConflictResult(
+	result: WorkspaceProposalApplicationResult,
+	reason: string,
+): WorkspaceProposalApplicationResult {
+	const issue: WorkspaceProposalRecordedIssue = {
+		kind: "issue",
+		source: "workspace-proposal",
+		severity: "error",
+		code: "idempotency-conflict",
+		message: "Workspace proposal family application replay conflicts with prior emitted facts",
+		subjectId: result.status.proposalId,
+		refs: result.status.sourceRefs.map((sourceRef) => `${sourceRef.kind}:${sourceRef.id}`),
+		metadata: { reason },
+	};
+	return {
+		status: {
+			...result.status,
+			state: "idempotency-conflict",
+			code: "idempotency-conflict",
+			issues: [issue],
+			emittedFactRefs: [],
+		},
+		issues: [issue],
+	};
+}
+
+function replayEntry(
+	result: WorkspaceProposalApplicationResult,
+): WorkspaceProposalApplicationReplayEntry {
+	return {
+		proposalId: result.status.proposalId,
+		decisionId: result.status.decisionId,
+		idempotencyKey: result.status.idempotencyKey,
+		emittedFactRefs: immutableClone(result.status.emittedFactRefs),
+	};
+}
+
+function sameReplayEntry(
+	entry: WorkspaceProposalApplicationReplayEntry,
+	result: WorkspaceProposalApplicationResult,
+): boolean {
+	return (
+		entry.proposalId === result.status.proposalId &&
+		entry.decisionId === result.status.decisionId &&
+		entry.idempotencyKey === result.status.idempotencyKey
+	);
+}
+
+function firstConflictingFactOwner<TInput, TDraft>(
+	state: WorkspaceProposalFamilyProjectorState<TInput, TDraft>,
+	result: WorkspaceProposalApplicationResult,
+): string | undefined {
+	for (const ref of result.status.emittedFactRefs) {
+		const owner = state.factOwners.get(factKey(ref));
+		if (owner !== undefined && owner !== result.status.applicationId) return owner;
+	}
+	return undefined;
+}
+
+function refsSignature(refs: readonly WorkspaceProposalApplicationFamilyRef[]): string {
+	return stableStringify(
+		refs.map((ref) => ({
+			proposalFamily: ref.proposalFamily,
+			factKind: ref.factKind,
+			factId: ref.factId,
+			sourceRefs: ref.sourceRefs ?? [],
+		})),
+	);
+}
+
+function factKey(ref: WorkspaceProposalApplicationFamilyRef): string {
+	return `${ref.proposalFamily}:${ref.factKind}:${ref.factId}`;
+}
+
+function capitalize(value: string): string {
+	return `${value.slice(0, 1).toUpperCase()}${value.slice(1)}`;
+}
+
+function stableStringify(value: unknown, stack: WeakSet<object> = new WeakSet()): string {
+	if (typeof value === "object" && value !== null) {
+		if (stack.has(value)) return JSON.stringify("[Circular]");
+		stack.add(value);
+	}
+	try {
+		if (Array.isArray(value))
+			return `[${value.map((entry) => stableStringify(entry, stack)).join(",")}]`;
+		if (!isRecord(value)) return JSON.stringify(value);
+		return `{${Object.keys(value)
+			.sort()
+			.map((key) => `${JSON.stringify(key)}:${stableStringify(value[key], stack)}`)
+			.join(",")}}`;
+	} finally {
+		if (typeof value === "object" && value !== null) stack.delete(value);
+	}
+}
diff --git a/packages/ts/src/solutions/work-item/workspace-model.ts b/packages/ts/src/solutions/work-item/workspace-model.ts
new file mode 100644
index 00000000..1c711835
--- /dev/null
+++ b/packages/ts/src/solutions/work-item/workspace-model.ts
@@ -0,0 +1,413 @@
+import type { DataIssue } from "../../data/index.js";
+import type { SourceRef } from "../../orchestration/agent-runtime.js";
+import type {
+	WorkItemCreated,
+	WorkItemDraft,
+	WorkItemProjection,
+	WorkItemSpawnProposed,
+} from "./scheduling-types.js";
+
+/**
+ * Workspace-facing WorkItem policy effects (D398/D403/D407).
+ * These are projection hints, not commands, runtime bindings, or closed enums.
+ */
+export type WorkItemPolicyEffect =
+	| "attention-needs-me"
+	| "attention-review"
+	| "attention-waiting"
+	| "attention-recent"
+	| "side-panel-required-input"
+	| "side-panel-context"
+	| "side-panel-debug"
+	| "topology-edge"
+	| "duplicate-suppression"
+	| "navigation-rollup"
+	| "provenance-only"
+	| (string & {});
+
+/**
+ * Open WorkItem type catalog entry over WorkItemDraft.kind (D398).
+ * Default seeds are Task/Spike/Review, but callers may add or rename kinds.
+ */
+export interface WorkItemTypeCatalogEntry {
+	readonly kind: string;
+	readonly label: string;
+	readonly description?: string;
+	readonly hidden?: boolean;
+	readonly order?: number;
+	readonly requiredDraftFields?: readonly string[];
+	readonly defaultDraft?: Partial<WorkItemDraft>;
+	readonly projectionEffects?: readonly WorkItemPolicyEffect[];
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface WorkItemTypeCatalog {
+	readonly kind: "work-item-type-catalog";
+	readonly catalogId: string;
+	readonly entries: readonly WorkItemTypeCatalogEntry[];
+	readonly defaultKind?: string;
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface WorkItemActionPolicySeed {
+	readonly kind: "work-item-action-policy-seed";
+	readonly policyId: string;
+	readonly typeCatalogId?: string;
+	readonly allowedActionKinds?: readonly string[];
+	readonly requiresConfirmation?: readonly string[];
+	readonly requiresActorCapabilities?: readonly string[];
+	readonly projectionEffects?: readonly WorkItemPolicyEffect[];
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly metadata?: Record<string, unknown>;
+}
+
+export const DEFAULT_WORK_ITEM_TYPE_CATALOG_SEED = [
+	{ kind: "task", label: "Task", order: 10 },
+	{ kind: "spike", label: "Spike", order: 20 },
+	{ kind: "review", label: "Review", order: 30 },
+] as const satisfies readonly WorkItemTypeCatalogEntry[];
+
+export type WorkItemLinkDirection = "directed" | "bidirectional";
+
+/**
+ * Open WorkItem link type catalog entry over WorkItemLinked.linkKind (D402/D403).
+ * Projection effects describe display/attention behavior without owning link truth.
+ */
+export interface WorkItemLinkTypeCatalogEntry {
+	readonly linkKind: string;
+	readonly label: string;
+	readonly inverseLabel?: string;
+	readonly direction?: WorkItemLinkDirection;
+	readonly hidden?: boolean;
+	readonly order?: number;
+	readonly defaultCollapsed?: boolean;
+	readonly allowedFromKinds?: readonly string[];
+	readonly allowedToKinds?: readonly string[];
+	readonly cyclePolicy?: "allow" | "deny" | "review";
+	readonly projectionEffects?: readonly WorkItemPolicyEffect[];
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface WorkItemLinkTypeCatalog {
+	readonly kind: "work-item-link-type-catalog";
+	readonly catalogId: string;
+	readonly entries: readonly WorkItemLinkTypeCatalogEntry[];
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly metadata?: Record<string, unknown>;
+}
+
+export const DEFAULT_WORK_ITEM_LINK_TYPE_CATALOG_SEED = [
+	{
+		linkKind: "parent-child",
+		label: "Parent",
+		inverseLabel: "Child",
+		direction: "directed",
+		projectionEffects: ["navigation-rollup", "side-panel-context", "topology-edge"],
+	},
+	{
+		linkKind: "blocks",
+		label: "Blocks",
+		inverseLabel: "Blocked by",
+		direction: "directed",
+		projectionEffects: ["attention-waiting", "side-panel-context", "topology-edge"],
+	},
+	{
+		linkKind: "related",
+		label: "Related",
+		direction: "bidirectional",
+		projectionEffects: ["side-panel-context"],
+	},
+	{
+		linkKind: "duplicate",
+		label: "Duplicate",
+		inverseLabel: "Duplicate of",
+		direction: "directed",
+		projectionEffects: ["attention-review", "duplicate-suppression", "side-panel-context"],
+	},
+	{
+		linkKind: "spawned-from",
+		label: "Spawned from",
+		direction: "directed",
+		projectionEffects: ["provenance-only", "side-panel-context"],
+	},
+] as const satisfies readonly WorkItemLinkTypeCatalogEntry[];
+
+/**
+ * Append-only durable WorkItem relationship fact (D402).
+ * Canvas may project this fact but must not directly mutate link truth.
+ */
+export interface WorkItemLinked {
+	readonly kind: "work-item-linked";
+	readonly eventId: string;
+	readonly linkId: string;
+	readonly fromWorkItemId: string;
+	readonly toWorkItemId: string;
+	readonly linkKind: string;
+	readonly direction?: WorkItemLinkDirection;
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly linkedAtMs?: number;
+	readonly idempotencyKey?: string;
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface WorkItemUnlinked {
+	readonly kind: "work-item-unlinked";
+	readonly eventId: string;
+	readonly linkId: string;
+	readonly reason?: string;
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly unlinkedAtMs?: number;
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface WorkItemLinkProjection {
+	readonly linkId: string;
+	readonly fromWorkItemId: string;
+	readonly toWorkItemId: string;
+	readonly linkKind: string;
+	readonly direction: WorkItemLinkDirection;
+	readonly active: boolean;
+	readonly lastEventId: string;
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly issues?: readonly DataIssue[];
+	readonly metadata?: Record<string, unknown>;
+}
+
+export type WorkItemSpawnAdmissionOutcome = "admit" | "reject" | "defer" | "merge" | "duplicate";
+export type WorkItemSpawnAdmissionState =
+	| "admitted"
+	| "rejected"
+	| "deferred"
+	| "merged"
+	| "duplicate";
+
+export interface WorkItemSpawnAdmissionDecision {
+	readonly kind: "work-item-spawn-admission-decision";
+	readonly decisionId: string;
+	readonly admissionId: string;
+	readonly proposalId: string;
+	readonly outcome: WorkItemSpawnAdmissionOutcome;
+	readonly policyId?: string;
+	readonly targetProposalId?: string;
+	readonly targetWorkItemId?: string;
+	readonly reason?: string;
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly decidedAtMs?: number;
+	readonly metadata?: Record<string, unknown>;
+}
+
+/**
+ * Admission result for WorkItemSpawnProposed (D397/D401).
+ * This is visible domain material, not direct WorkItem mutation.
+ */
+export interface WorkItemSpawnAdmission {
+	readonly kind: "work-item-spawn-admission";
+	readonly admissionId: string;
+	readonly proposalId: string;
+	readonly state: WorkItemSpawnAdmissionState;
+	readonly decisionId: string;
+	readonly proposedWorkItemId?: string;
+	readonly policyId?: string;
+	readonly reason?: string;
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly admittedAtMs?: number;
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface WorkItemSpawnApplication<TInput = unknown> {
+	readonly kind: "work-item-spawn-application";
+	readonly applicationId: string;
+	readonly admissionId: string;
+	readonly proposalId: string;
+	readonly state: Exclude<WorkItemSpawnAdmissionState, "admitted"> | "applied";
+	readonly created?: WorkItemCreated<TInput>;
+	readonly linkFacts?: readonly WorkItemLinked[];
+	readonly issues?: readonly DataIssue[];
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly appliedAtMs?: number;
+	readonly metadata?: Record<string, unknown>;
+}
+
+export type RequiredInputGateStatus =
+	| "requested"
+	| "response-proposed"
+	| "satisfied"
+	| "rejected"
+	| "stale"
+	| "retention-gap"
+	| "mismatched";
+
+export interface RequiredInputRequest {
+	readonly kind: "required-input-request";
+	readonly requestId: string;
+	readonly workItemId: string;
+	readonly fieldId?: string;
+	readonly prompt: string;
+	readonly schema?: Record<string, unknown>;
+	readonly reason?: string;
+	readonly required?: boolean;
+	readonly authoringRevision?: number;
+	readonly executionInputRevision?: number;
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly evidenceRefs?: readonly SourceRef[];
+	readonly requestedAtMs?: number;
+	readonly metadata?: Record<string, unknown>;
+}
+
+/**
+ * Graph-visible Required Input gate projection (D406).
+ * User responses require proposal/admission/application before satisfaction.
+ */
+export interface RequiredInputGate {
+	readonly kind: "required-input-gate";
+	readonly gateId: string;
+	readonly requestId: string;
+	readonly workItemId: string;
+	readonly status: RequiredInputGateStatus;
+	readonly fieldId?: string;
+	readonly prompt: string;
+	readonly schema?: Record<string, unknown>;
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly evidenceRefs?: readonly SourceRef[];
+	readonly issues?: readonly DataIssue[];
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface RequiredInputResponseProposed<TValue = unknown> {
+	readonly kind: "required-input-response-proposed";
+	readonly proposalId: string;
+	readonly requestId: string;
+	readonly workItemId: string;
+	readonly value?: TValue;
+	readonly summary?: string;
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly evidenceRefs?: readonly SourceRef[];
+	readonly artifactRefs?: readonly SourceRef[];
+	readonly proposedBy?: string;
+	readonly proposedAtMs?: number;
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface RequiredInputResponseAdmission {
+	readonly kind: "required-input-response-admission";
+	readonly admissionId: string;
+	readonly proposalId: string;
+	readonly requestId: string;
+	readonly workItemId: string;
+	readonly state: "admitted" | "rejected" | "deferred" | "merged";
+	readonly reason?: string;
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly admittedAtMs?: number;
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface RequiredInputResponseApplied<TValue = unknown> {
+	readonly kind: "required-input-response-applied";
+	readonly applicationId: string;
+	readonly admissionId: string;
+	readonly proposalId: string;
+	readonly requestId: string;
+	readonly workItemId: string;
+	readonly value?: TValue;
+	readonly summary?: string;
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly evidenceRefs?: readonly SourceRef[];
+	readonly artifactRefs?: readonly SourceRef[];
+	readonly appliedAtMs?: number;
+	readonly metadata?: Record<string, unknown>;
+}
+
+export type RecommendedActionTone = "neutral" | "attention" | "success" | "warning" | "danger";
+
+export type RecommendedActionLoweringKind =
+	| "work-item-spawn-proposed"
+	| "work-item-domain-action-proposal-intake"
+	| "required-input-response-proposed"
+	| "work-item-link-proposal"
+	| "admission-decision-proposal"
+	| "ui-navigation"
+	| (string & {});
+
+/**
+ * Side Panel recommended action view material (D407).
+ * Button handlers lower to intents/proposals; this view is never a command.
+ */
+export interface RecommendedActionView {
+	readonly kind: "recommended-action-view";
+	readonly actionId: string;
+	readonly label: string;
+	readonly description?: string;
+	readonly tone?: RecommendedActionTone;
+	readonly priority?: number;
+	readonly rank?: number;
+	readonly disabledReason?: string;
+	readonly confirmationRequired?: boolean;
+	readonly formSchema?: Record<string, unknown>;
+	readonly draftSeed?: WorkItemDraft | WorkItemSpawnProposed | RequiredInputResponseProposed;
+	readonly targetRefs?: readonly SourceRef[];
+	readonly loweringKind?: RecommendedActionLoweringKind;
+	readonly loweringHints?: Record<string, unknown>;
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface SidePanelActionIntent<TDraft = unknown> {
+	readonly kind: "side-panel-action-intent";
+	readonly intentId: string;
+	readonly actionId: string;
+	readonly loweringKind: RecommendedActionLoweringKind;
+	readonly workItemId?: string;
+	readonly draft?: TDraft;
+	readonly targetRefs?: readonly SourceRef[];
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly submittedBy?: string;
+	readonly submittedAtMs?: number;
+	readonly metadata?: Record<string, unknown>;
+}
+
+export type WorkspaceMaterialSectionKind = "why-evidence" | "debug";
+
+export interface WorkspaceMaterialSectionRef {
+	readonly sectionKind: WorkspaceMaterialSectionKind;
+	readonly label: string;
+	readonly summary?: string;
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly evidenceRefs?: readonly SourceRef[];
+	readonly artifactRefs?: readonly SourceRef[];
+	readonly issues?: readonly DataIssue[];
+	readonly collapsedByDefault?: boolean;
+	readonly deliberateOpenOnly?: boolean;
+	readonly dryRunOrFixture?: boolean;
+	readonly metadata?: Record<string, unknown>;
+}
+
+export type WorkspaceFixtureBoundaryKind = "fixture" | "demo" | "story" | "dev-harness" | "test";
+
+/**
+ * Explicit marker for demo/test fixture entrypoints (D408).
+ * Production fallback is intentionally impossible in this shape.
+ */
+export interface WorkspaceFixtureBoundary {
+	readonly kind: "workspace-fixture-boundary";
+	readonly boundaryId: string;
+	readonly boundaryKind: WorkspaceFixtureBoundaryKind;
+	readonly label: string;
+	readonly visibleLabelRequired: true;
+	readonly productionFallbackAllowed: false;
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface WorkspaceWorkItemProjection<TInput = unknown> {
+	readonly workItem: WorkItemProjection<TInput>;
+	readonly typeCatalog?: WorkItemTypeCatalog;
+	readonly links?: readonly WorkItemLinkProjection[];
+	readonly requiredInput?: readonly RequiredInputGate[];
+	readonly recommendedActions?: readonly RecommendedActionView[];
+	readonly materialSections?: readonly WorkspaceMaterialSectionRef[];
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly metadata?: Record<string, unknown>;
+}
diff --git a/packages/ts/src/solutions/work-item/workspace-proposals.ts b/packages/ts/src/solutions/work-item/workspace-proposals.ts
new file mode 100644
index 00000000..db718ef5
--- /dev/null
+++ b/packages/ts/src/solutions/work-item/workspace-proposals.ts
@@ -0,0 +1,1404 @@
+import type { DataIssue } from "../../data/index.js";
+import type { SourceRef } from "../../orchestration/agent-runtime.js";
+import { immutableClone } from "./scheduling-shared.js";
+
+export type WorkspaceProposalFamily =
+	| "required-input-response"
+	| "work-item-spawn"
+	| "work-item-link"
+	| "work-item-domain-action"
+	| (string & {});
+
+export type WorkspaceProposalAdmissionStatus = "admitted" | "rejected" | "blocked" | "needs-review";
+
+export type WorkspaceProposalApplicationState =
+	| "applied"
+	| "blocked"
+	| "not-applied"
+	| "pending"
+	| "partial"
+	| "repair-needed"
+	| "idempotency-conflict"
+	| "recorded";
+
+export interface WorkspaceProposalAuditMaterial {
+	readonly auditId?: string;
+	readonly actorId?: string;
+	readonly recordedAtMs?: number;
+	readonly reason?: string;
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface WorkspaceProposalTargetRef {
+	readonly kind: string;
+	readonly id: string;
+	readonly revision?: string | number;
+	readonly freshnessToken?: string;
+	readonly workspaceId?: string;
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface WorkspaceProposalApplicationFamilyRef {
+	readonly proposalFamily: WorkspaceProposalFamily;
+	readonly factKind: string;
+	readonly factId: string;
+	readonly sourceRefs?: readonly SourceRef[];
+}
+
+export type WorkspaceProposalEmittedFactRefSource =
+	| {
+			readonly kind: string;
+			readonly eventId: string;
+			readonly sourceRefs?: readonly SourceRef[];
+	  }
+	| {
+			readonly kind: string;
+			readonly applicationId: string;
+			readonly sourceRefs?: readonly SourceRef[];
+	  };
+
+export interface WorkspaceProposalApplicationEnvelopeValidationOptions {
+	readonly expectedFamily?: WorkspaceProposalFamily;
+	readonly expectedLoweringKinds?: readonly string[];
+}
+
+export interface WorkspaceProposalProjectionFreshnessEvidence {
+	readonly kind: "workspace-proposal-projection-freshness-evidence";
+	readonly projectionBundleRef: SourceRef;
+	readonly state: "fresh" | "stale" | "unknown";
+	readonly currentRevision?: string | number;
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface WorkspaceProposalReadyRequest<TDraft = unknown> {
+	readonly kind: "workspace-proposal-ready-request";
+	readonly proposalId: string;
+	readonly intakeRequestId: string;
+	readonly idempotencyKey: string;
+	readonly workspaceId: string;
+	readonly proposalFamily: WorkspaceProposalFamily;
+	readonly loweringKind: string;
+	readonly draft?: TDraft;
+	readonly draftRefs?: readonly SourceRef[];
+	readonly targetRefs: readonly WorkspaceProposalTargetRef[];
+	readonly actorRef: SourceRef;
+	readonly capabilityRefs: readonly SourceRef[];
+	readonly policyRefs: readonly SourceRef[];
+	readonly projectionBundleRefs?: readonly SourceRef[];
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly audit?: WorkspaceProposalAuditMaterial;
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface WorkspaceProposalRecorded<TDraft = unknown> {
+	readonly kind: "workspace-proposal-recorded";
+	readonly proposalId: string;
+	readonly intakeRequestId: string;
+	readonly idempotencyKey: string;
+	readonly workspaceId: string;
+	readonly proposalFamily: WorkspaceProposalFamily;
+	readonly loweringKind: string;
+	readonly draft?: TDraft;
+	readonly draftRefs?: readonly SourceRef[];
+	readonly draftIdentity: string;
+	readonly targetRefs: readonly WorkspaceProposalTargetRef[];
+	readonly actorRef: SourceRef;
+	readonly capabilityRefs: readonly SourceRef[];
+	readonly policyRefs: readonly SourceRef[];
+	readonly projectionBundleRefs: readonly SourceRef[];
+	readonly sourceRefs: readonly SourceRef[];
+	readonly audit?: WorkspaceProposalAuditMaterial;
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface WorkspaceProposalRecordedIssue extends DataIssue {
+	readonly source: "workspace-proposal";
+}
+
+export interface WorkspaceProposalRecordStatus {
+	readonly kind: "workspace-proposal-record-status";
+	readonly statusId: string;
+	readonly proposalId?: string;
+	readonly intakeRequestId?: string;
+	readonly workspaceId?: string;
+	readonly state: "recorded" | "blocked";
+	readonly code?: string;
+	readonly issues?: readonly WorkspaceProposalRecordedIssue[];
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly audit?: WorkspaceProposalAuditMaterial;
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface WorkspaceProposalRecordResult<TDraft = unknown> {
+	readonly record?: WorkspaceProposalRecorded<TDraft>;
+	readonly status: WorkspaceProposalRecordStatus;
+	readonly issues: readonly WorkspaceProposalRecordedIssue[];
+}
+
+export interface WorkspaceProposalAdmissionPolicy {
+	readonly kind: "workspace-proposal-admission-policy";
+	readonly policyId: string;
+	readonly proposalFamilies?: readonly WorkspaceProposalFamily[];
+	readonly loweringKinds?: readonly string[];
+	readonly outcome?: WorkspaceProposalAdmissionStatus;
+	readonly requiresHumanReview?: boolean;
+	readonly requiredCapabilityRefs?: readonly SourceRef[];
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface WorkspaceProposalIdempotencyEvidence {
+	readonly kind: "workspace-proposal-idempotency-evidence";
+	readonly idempotencyKey: string;
+	readonly state: "unique" | "duplicate" | "conflict";
+	readonly existingProposalId?: string;
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface WorkspaceProposalFreshnessEvidence {
+	readonly kind: "workspace-proposal-freshness-evidence";
+	readonly targetRef: WorkspaceProposalTargetRef;
+	readonly state: "fresh" | "stale" | "unknown";
+	readonly currentRevision?: string | number;
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface WorkspaceProposalCapabilityEvidence {
+	readonly kind: "workspace-proposal-capability-evidence";
+	readonly capabilityRef: SourceRef;
+	readonly state: "present" | "missing" | "blocked";
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface WorkspaceProposalAdmissionMaterial {
+	readonly decisionId: string;
+	readonly policies?: readonly WorkspaceProposalAdmissionPolicy[];
+	readonly idempotencyEvidence?: WorkspaceProposalIdempotencyEvidence;
+	readonly freshnessEvidence?: readonly WorkspaceProposalFreshnessEvidence[];
+	readonly projectionFreshnessEvidence?: readonly WorkspaceProposalProjectionFreshnessEvidence[];
+	readonly capabilityEvidence?: readonly WorkspaceProposalCapabilityEvidence[];
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly audit?: WorkspaceProposalAuditMaterial;
+	readonly decidedAtMs?: number;
+}
+
+export interface WorkspaceProposalAdmissionDecision {
+	readonly kind: "workspace-proposal-admission-decision";
+	readonly decisionId: string;
+	readonly proposalId: string;
+	readonly intakeRequestId: string;
+	readonly idempotencyKey: string;
+	readonly workspaceId: string;
+	readonly proposalFamily: WorkspaceProposalFamily;
+	readonly loweringKind: string;
+	readonly draftIdentity: string;
+	readonly targetRefs: readonly WorkspaceProposalTargetRef[];
+	readonly actorRef: SourceRef;
+	readonly capabilityRefs: readonly SourceRef[];
+	readonly policyRefs: readonly SourceRef[];
+	readonly status: WorkspaceProposalAdmissionStatus;
+	readonly issues: readonly WorkspaceProposalRecordedIssue[];
+	readonly decidedAtMs?: number;
+	readonly sourceRefs: readonly SourceRef[];
+	readonly audit?: WorkspaceProposalAuditMaterial;
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface WorkspaceProposalAdmissionResult {
+	readonly decision: WorkspaceProposalAdmissionDecision;
+	readonly issues: readonly WorkspaceProposalRecordedIssue[];
+}
+
+export interface WorkspaceProposalApplicationStatus {
+	readonly kind: "workspace-proposal-application-status";
+	readonly applicationId: string;
+	readonly proposalId: string;
+	readonly intakeRequestId: string;
+	readonly idempotencyKey: string;
+	readonly workspaceId: string;
+	readonly decisionId: string;
+	readonly proposalFamily: WorkspaceProposalFamily;
+	readonly loweringKind: string;
+	readonly targetRefs: readonly WorkspaceProposalTargetRef[];
+	readonly policyRefs: readonly SourceRef[];
+	readonly state: WorkspaceProposalApplicationState;
+	readonly code?: string;
+	readonly issues: readonly WorkspaceProposalRecordedIssue[];
+	readonly emittedFactRefs: readonly WorkspaceProposalApplicationFamilyRef[];
+	readonly sourceRefs: readonly SourceRef[];
+	readonly audit?: WorkspaceProposalAuditMaterial;
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface WorkspaceProposalApplicationRecorded {
+	readonly kind: "workspace-proposal-application-recorded";
+	readonly applicationRecordId: string;
+	readonly applicationId: string;
+	readonly proposalId: string;
+	readonly decisionId: string;
+	readonly emittedFactRefs: readonly WorkspaceProposalApplicationFamilyRef[];
+	readonly sourceRefs: readonly SourceRef[];
+	readonly audit?: WorkspaceProposalAuditMaterial;
+	readonly metadata?: Record<string, unknown>;
+}
+
+export interface WorkspaceProposalApplicationResult {
+	readonly status: WorkspaceProposalApplicationStatus;
+	readonly recorded?: WorkspaceProposalApplicationRecorded;
+	readonly issues: readonly WorkspaceProposalRecordedIssue[];
+}
+
+export interface WorkspaceProposalProjectorOptions {
+	readonly supportedFamilies?: readonly WorkspaceProposalFamily[];
+	readonly maxInlineDraftBytes?: number;
+}
+
+export interface WorkspaceProposalApplicationOptions extends WorkspaceProposalProjectorOptions {
+	readonly applicationId: string;
+	readonly emittedFactRefs?: readonly WorkspaceProposalApplicationFamilyRef[];
+	readonly familyIssues?: readonly WorkspaceProposalRecordedIssue[];
+	readonly state?: WorkspaceProposalApplicationState;
+	readonly code?: string;
+	readonly sourceRefs?: readonly SourceRef[];
+	readonly audit?: WorkspaceProposalAuditMaterial;
+}
+
+const DEFAULT_MAX_INLINE_DRAFT_BYTES = 16 * 1024;
+const BUILT_IN_FAMILIES = new Set<WorkspaceProposalFamily>([
+	"required-input-response",
+	"work-item-spawn",
+	"work-item-link",
+	"work-item-domain-action",
+]);
+
+const FORBIDDEN_KEY_NAMES = new Set([
+	"accesstoken",
+	"apikey",
+	"callback",
+	"client",
+	"clienthandle",
+	"command",
+	"commandline",
+	"credential",
+	"credentials",
+	"fileedit",
+	"fileeditcommand",
+	"handler",
+	"handlername",
+	"mcp",
+	"privatekey",
+	"providerclient",
+	"refreshtoken",
+	"registry",
+	"provider",
+	"runtime",
+	"runtimehandle",
+	"secret",
+	"secrets",
+	"sql",
+	"sqlquery",
+	"cli",
+	"bash",
+]);
+
+const FORBIDDEN_KEY_PARTS = [
+	"accesstoken",
+	"apikey",
+	"callback",
+	"browser",
+	"clienthandle",
+	"command",
+	"credential",
+	"fileedit",
+	"handlername",
+	"mcp",
+	"privatekey",
+	"provider",
+	"refreshtoken",
+	"registry",
+	"runtime",
+	"secret",
+	"session",
+	"sql",
+	"cli",
+	"bash",
+] as const;
+
+const FAMILY_FACT_KINDS: Readonly<Record<string, readonly string[]>> = {
+	"required-input-response": ["required-input-response-applied"],
+	"work-item-spawn": ["work-item-created", "work-item-linked"],
+	"work-item-link": ["work-item-linked", "work-item-unlinked"],
+	"work-item-domain-action": [
+		"work-item-domain-action-application",
+		"work-item-created",
+		"work-item-patched",
+		"acceptance-criteria-changed",
+		"verification-plan-changed",
+	],
+};
+export function recordWorkspaceProposal<TDraft = unknown>(
+	input: WorkspaceProposalReadyRequest<TDraft> | unknown,
+	options: WorkspaceProposalProjectorOptions = {},
+): WorkspaceProposalRecordResult<TDraft> {
+	const issues = readyRequestIssues(input, options);
+	if (
+		issues.some(
+			(entry) =>
+				entry.code === "non-data-material" ||
+				entry.code === "cyclic-data-material" ||
+				entry.code === "forbidden-runtime-material",
+		)
+	) {
+		return {
+			status: recordStatus("blocked", {}, issues),
+			issues,
+		};
+	}
+	const request = immutableClone(input as WorkspaceProposalReadyRequest<TDraft>);
+	if (issues.length > 0) {
+		return {
+			status: recordStatus("blocked", request, issues),
+			issues,
+		};
+	}
+	const draftIdentity = draftIdentityFor(request);
+	const record: WorkspaceProposalRecorded<TDraft> = freezeRecord({
+		kind: "workspace-proposal-recorded",
+		proposalId: request.proposalId,
+		intakeRequestId: request.intakeRequestId,
+		idempotencyKey: request.idempotencyKey,
+		workspaceId: request.workspaceId,
+		proposalFamily: request.proposalFamily,
+		loweringKind: request.loweringKind,
+		...(request.draft === undefined ? {} : { draft: request.draft }),
+		...(request.draftRefs === undefined ? {} : { draftRefs: request.draftRefs }),
+		draftIdentity,
+		targetRefs: request.targetRefs,
+		actorRef: request.actorRef,
+		capabilityRefs: request.capabilityRefs,
+		policyRefs: request.policyRefs,
+		projectionBundleRefs: request.projectionBundleRefs ?? [],
+		sourceRefs: request.sourceRefs ?? [],
+		audit: request.audit,
+		metadata: request.metadata,
+	});
+	return {
+		record,
+		status: recordStatus("recorded", request, []),
+		issues: [],
+	};
+}
+
+export function decideWorkspaceProposalAdmission(
+	record: WorkspaceProposalRecorded,
+	material: WorkspaceProposalAdmissionMaterial,
+	options: WorkspaceProposalProjectorOptions = {},
+): WorkspaceProposalAdmissionResult {
+	const issues: WorkspaceProposalRecordedIssue[] = [];
+	issues.push(...dataOnlyIssues(record, "record"));
+	issues.push(...dataOnlyIssues(material, "admissionMaterial"));
+	if (
+		issues.some(
+			(entry) =>
+				entry.code === "non-data-material" ||
+				entry.code === "cyclic-data-material" ||
+				entry.code === "forbidden-runtime-material",
+		)
+	) {
+		const decision = blockedAdmissionDecision(record, material, issues);
+		return { decision, issues };
+	}
+	if (blank(material.decisionId))
+		issues.push(issue("missing-decision-id", "Workspace proposal admission requires decisionId"));
+	if (!familySupported(record.proposalFamily, options))
+		issues.push(
+			issue(
+				"unsupported-proposal-family",
+				`Unsupported proposal family '${record.proposalFamily}'`,
+				{
+					subjectId: record.proposalId,
+				},
+			),
+		);
+	const policies = material.policies ?? [];
+	const matchingPolicies = policies.filter((policy) => policyMatches(policy, record));
+	if (policies.length === 0 || matchingPolicies.length === 0) {
+		issues.push(
+			issue("missing-policy", "Workspace proposal admission has no matching policy material", {
+				subjectId: record.proposalId,
+				refs: recordRefs(record),
+			}),
+		);
+	}
+	const policyOutcomes = uniqueStrings(
+		matchingPolicies.flatMap((policy) => (policy.outcome === undefined ? [] : [policy.outcome])),
+	);
+	if (matchingPolicies.length > 0 && policyOutcomes.length === 0) {
+		issues.push(
+			issue("missing-admission-outcome", "Matching admission policy has no explicit outcome", {
+				subjectId: record.proposalId,
+				refs: recordRefs(record),
+			}),
+		);
+	}
+	if (policyOutcomes.length > 1) {
+		issues.push(
+			issue("conflicting-policy-outcome", "Workspace proposal admission policy outcomes conflict", {
+				subjectId: record.proposalId,
+				refs: recordRefs(record),
+			}),
+		);
+	}
+	if (record.capabilityRefs.length === 0) {
+		issues.push(
+			issue("missing-capability", "Workspace proposal admission requires capability refs", {
+				subjectId: record.proposalId,
+				refs: recordRefs(record),
+			}),
+		);
+	}
+	const policyCapabilityRefs = uniqueRefs(
+		matchingPolicies.flatMap((policy) => policy.requiredCapabilityRefs ?? []),
+	);
+	for (const capabilityRef of policyCapabilityRefs) {
+		if (!record.capabilityRefs.some((entry) => refEquals(entry, capabilityRef))) {
+			issues.push(
+				issue(
+					"missing-policy-required-capability",
+					"Workspace proposal record lacks a policy-required capability ref",
+					{ subjectId: record.proposalId, refs: [capabilityRef, ...recordRefs(record)] },
+				),
+			);
+		}
+	}
+	const requiredCapabilityRefs = uniqueRefs([...record.capabilityRefs, ...policyCapabilityRefs]);
+	const capabilityEvidence = material.capabilityEvidence ?? [];
+	for (const capabilityRef of requiredCapabilityRefs) {
+		const evidence = capabilityEvidence.filter((entry) =>
+			refEquals(entry.capabilityRef, capabilityRef),
+		);
+		const states = uniqueStrings(evidence.map((entry) => entry.state));
+		if (evidence.length === 0) {
+			issues.push(
+				issue(
+					"missing-capability-evidence",
+					"Workspace proposal admission requires capability evidence",
+					{
+						subjectId: record.proposalId,
+						refs: [capabilityRef, ...recordRefs(record)],
+					},
+				),
+			);
+		} else if (states.length > 1) {
+			issues.push(
+				issue(
+					"conflicting-capability-evidence",
+					"Workspace proposal capability evidence conflicts",
+					{ subjectId: record.proposalId, refs: [capabilityRef, ...recordRefs(record)] },
+				),
+			);
+		} else if (evidence.some((entry) => entry.state !== "present")) {
+			const state = evidence.find((entry) => entry.state !== "present")?.state;
+			issues.push(
+				issue(
+					state === "blocked" ? "blocked-capability" : "missing-capability",
+					"Workspace proposal capability evidence failed closed",
+					{ subjectId: record.proposalId, refs: [capabilityRef, ...recordRefs(record)] },
+				),
+			);
+		}
+	}
+	const idempotency = material.idempotencyEvidence;
+	if (idempotency === undefined) {
+		issues.push(
+			issue(
+				"missing-idempotency-evidence",
+				"Workspace proposal admission requires idempotency evidence",
+				{
+					subjectId: record.proposalId,
+					refs: recordRefs(record),
+				},
+			),
+		);
+	} else if (idempotency.idempotencyKey !== record.idempotencyKey) {
+		issues.push(
+			issue(
+				"idempotency-key-mismatch",
+				"Workspace proposal idempotency evidence mismatches record",
+				{
+					subjectId: record.proposalId,
+					refs: recordRefs(record),
+				},
+			),
+		);
+	} else if (idempotency.state !== "unique") {
+		issues.push(
+			issue(
+				idempotency.state === "conflict" ? "idempotency-conflict" : "duplicate-proposal",
+				"Workspace proposal idempotency evidence failed closed",
+				{ subjectId: record.proposalId, refs: recordRefs(record) },
+			),
+		);
+	}
+	const freshness = material.freshnessEvidence ?? [];
+	for (const target of record.targetRefs) {
+		const evidence = freshness.filter((entry) => targetRefEquals(entry.targetRef, target));
+		const states = uniqueStrings(evidence.map((entry) => entry.state));
+		if (evidence.length === 0) {
+			issues.push(
+				issue(
+					"missing-freshness-evidence",
+					"Workspace proposal admission requires target freshness evidence",
+					{
+						subjectId: record.proposalId,
+						refs: recordRefs(record),
+					},
+				),
+			);
+		} else if (states.length > 1) {
+			issues.push(
+				issue(
+					"conflicting-freshness-evidence",
+					"Workspace proposal target freshness evidence conflicts",
+					{ subjectId: record.proposalId, refs: recordRefs(record) },
+				),
+			);
+		} else if (evidence.some((entry) => entry.state !== "fresh")) {
+			const state = evidence.find((entry) => entry.state !== "fresh")?.state;
+			issues.push(
+				issue(
+					state === "stale" ? "stale-target-ref" : "unknown-target-ref",
+					"Workspace proposal target freshness evidence failed closed",
+					{ subjectId: record.proposalId, refs: recordRefs(record) },
+				),
+			);
+		}
+	}
+	const projectionFreshness = material.projectionFreshnessEvidence ?? [];
+	for (const projectionBundleRef of record.projectionBundleRefs) {
+		const evidence = projectionFreshness.filter((entry) =>
+			refEquals(entry.projectionBundleRef, projectionBundleRef),
+		);
+		const states = uniqueStrings(evidence.map((entry) => entry.state));
+		if (evidence.length === 0) {
+			issues.push(
+				issue(
+					"missing-projection-freshness-evidence",
+					"Workspace proposal admission requires projection bundle freshness evidence",
+					{ subjectId: record.proposalId, refs: [projectionBundleRef, ...recordRefs(record)] },
+				),
+			);
+		} else if (states.length > 1) {
+			issues.push(
+				issue(
+					"conflicting-projection-freshness-evidence",
+					"Workspace proposal projection freshness evidence conflicts",
+					{ subjectId: record.proposalId, refs: [projectionBundleRef, ...recordRefs(record)] },
+				),
+			);
+		} else if (evidence.some((entry) => entry.state !== "fresh")) {
+			const state = evidence.find((entry) => entry.state !== "fresh")?.state;
+			issues.push(
+				issue(
+					state === "stale" ? "stale-projection-ref" : "unknown-projection-ref",
+					"Workspace proposal projection freshness evidence failed closed",
+					{ subjectId: record.proposalId, refs: [projectionBundleRef, ...recordRefs(record)] },
+				),
+			);
+		}
+	}
+	const humanReview = matchingPolicies.some((policy) => policy.requiresHumanReview);
+	const policyOutcome =
+		policyOutcomes.length === 1
+			? (policyOutcomes[0] as WorkspaceProposalAdmissionStatus)
+			: undefined;
+	const status = admissionStatus(issues, humanReview, policyOutcome);
+	const decision: WorkspaceProposalAdmissionDecision = freezeRecord({
+		kind: "workspace-proposal-admission-decision",
+		decisionId: material.decisionId,
+		proposalId: record.proposalId,
+		intakeRequestId: record.intakeRequestId,
+		idempotencyKey: record.idempotencyKey,
+		workspaceId: record.workspaceId,
+		proposalFamily: record.proposalFamily,
+		loweringKind: record.loweringKind,
+		draftIdentity: record.draftIdentity,
+		targetRefs: immutableClone(record.targetRefs),
+		actorRef: immutableClone(record.actorRef),
+		capabilityRefs: immutableClone(record.capabilityRefs),
+		policyRefs: immutableClone(record.policyRefs),
+		status,
+		issues: immutableClone(issues),
+		decidedAtMs: material.decidedAtMs,
+		sourceRefs: uniqueRefs([...recordRefs(record), ...immutableClone(material.sourceRefs ?? [])]),
+		audit: immutableClone(material.audit ?? record.audit),
+		metadata: {
+			policyIds: matchingPolicies.map((policy) => policy.policyId),
+			idempotencyState: idempotency?.state,
+		},
+	});
+	return { decision, issues };
+}
+
+export function projectWorkspaceProposalApplicationStatus(
+	record: WorkspaceProposalRecorded,
+	decision: WorkspaceProposalAdmissionDecision,
+	options: WorkspaceProposalApplicationOptions,
+): WorkspaceProposalApplicationResult {
+	const issues: WorkspaceProposalRecordedIssue[] = [];
+	issues.push(...dataOnlyIssues(record, "record"));
+	issues.push(...dataOnlyIssues(decision, "decision"));
+	issues.push(...dataOnlyIssues(options, "applicationOptions"));
+	if (
+		issues.some(
+			(entry) =>
+				entry.code === "non-data-material" ||
+				entry.code === "cyclic-data-material" ||
+				entry.code === "forbidden-runtime-material",
+		)
+	) {
+		return blockedApplicationStatus(record, decision, options, issues);
+	}
+	if (blank(options.applicationId))
+		issues.push(
+			issue("missing-application-id", "Workspace proposal application requires applicationId"),
+		);
+	if (decision.kind !== "workspace-proposal-admission-decision") {
+		issues.push(
+			issue(
+				"malformed-admission-decision",
+				"Workspace proposal application requires durable admission decision material",
+				{ subjectId: record.proposalId, refs: recordRefs(record) },
+			),
+		);
+	}
+	if (!familySupported(record.proposalFamily, options)) {
+		issues.push(
+			issue(
+				"unsupported-proposal-family",
+				`Unsupported proposal family '${record.proposalFamily}'`,
+				{
+					subjectId: record.proposalId,
+				},
+			),
+		);
+	}
+	const mismatch = envelopeMismatch(record, decision);
+	if (mismatch !== undefined) {
+		issues.push(
+			issue("proposal-envelope-mismatch", mismatch, {
+				subjectId: record.proposalId,
+				refs: recordRefs(record),
+			}),
+		);
+	}
+	if (decision.status !== "admitted") {
+		issues.push(
+			issue("proposal-not-admitted", "Workspace proposal application requires admitted decision", {
+				subjectId: record.proposalId,
+				refs: recordRefs(record),
+			}),
+		);
+	}
+	if (decision.issues.length > 0) {
+		issues.push(
+			issue(
+				"admission-decision-has-issues",
+				"Workspace proposal application requires issue-free decision",
+				{
+					subjectId: record.proposalId,
+					refs: recordRefs(record),
+				},
+			),
+		);
+	}
+	issues.push(...immutableClone(options.familyIssues ?? []));
+	const emittedFactRefs = immutableClone(options.emittedFactRefs ?? []);
+	issues.push(...applicationFamilyRefIssues(emittedFactRefs, record));
+	const pendingFamilyRefs =
+		emittedFactRefs.length === 0 &&
+		familySupported(record.proposalFamily, options) &&
+		issues.length === 0;
+	const state = resolveApplicationState(issues, pendingFamilyRefs, options.state);
+	const terminalRecorded =
+		(state === "applied" || state === "recorded") &&
+		issues.length === 0 &&
+		emittedFactRefs.length > 0;
+	const status: WorkspaceProposalApplicationStatus = freezeRecord({
+		kind: "workspace-proposal-application-status",
+		applicationId: options.applicationId,
+		proposalId: record.proposalId,
+		intakeRequestId: record.intakeRequestId,
+		idempotencyKey: record.idempotencyKey,
+		workspaceId: record.workspaceId,
+		decisionId: decision.decisionId,
+		proposalFamily: record.proposalFamily,
+		loweringKind: record.loweringKind,
+		targetRefs: immutableClone(record.targetRefs),
+		policyRefs: immutableClone(record.policyRefs),
+		state,
+		code:
+			options.code ?? (pendingFamilyRefs ? "pending-family-emitted-fact-refs" : issues[0]?.code),
+		issues: immutableClone(issues),
+		emittedFactRefs: terminalRecorded ? emittedFactRefs : [],
+		sourceRefs: uniqueRefs([
+			...recordRefs(record),
+			{ kind: "workspace-proposal-admission-decision", id: decision.decisionId },
+			...immutableClone(decision.sourceRefs ?? []),
+			...immutableClone(options.sourceRefs ?? []),
+			...immutableClone(options.audit?.sourceRefs ?? []),
+		]),
+		audit: immutableClone(options.audit ?? record.audit),
+	});
+	const recorded = terminalRecorded
+		? freezeRecord({
+				kind: "workspace-proposal-application-recorded",
+				applicationRecordId: `${options.applicationId}:recorded`,
+				applicationId: options.applicationId,
+				proposalId: record.proposalId,
+				decisionId: decision.decisionId,
+				emittedFactRefs,
+				sourceRefs: status.sourceRefs,
+				audit: status.audit,
+			} satisfies WorkspaceProposalApplicationRecorded)
+		: undefined;
+	return { status, recorded, issues };
+}
+
+function resolveApplicationState(
+	issues: readonly WorkspaceProposalRecordedIssue[],
+	pendingFamilyRefs: boolean,
+	requestedState: WorkspaceProposalApplicationState | undefined,
+): WorkspaceProposalApplicationState {
+	if (issues.length > 0) {
+		return requestedState === "repair-needed" ||
+			requestedState === "idempotency-conflict" ||
+			requestedState === "not-applied" ||
+			requestedState === "partial"
+			? requestedState
+			: "blocked";
+	}
+	if (
+		pendingFamilyRefs &&
+		(requestedState === undefined || requestedState === "applied" || requestedState === "recorded")
+	) {
+		return "pending";
+	}
+	return requestedState ?? (pendingFamilyRefs ? "pending" : "applied");
+}
+
+export function validateWorkspaceProposalApplicationEnvelope(
+	record: WorkspaceProposalRecorded,
+	decision: WorkspaceProposalAdmissionDecision,
+	options: WorkspaceProposalApplicationEnvelopeValidationOptions = {},
+): readonly WorkspaceProposalRecordedIssue[] {
+	const issues: WorkspaceProposalRecordedIssue[] = [];
+	issues.push(...dataOnlyIssues(record, "record"));
+	issues.push(...dataOnlyIssues(decision, "decision"));
+	if (decision.kind !== "workspace-proposal-admission-decision") {
+		issues.push(
+			issue(
+				"malformed-admission-decision",
+				"Workspace proposal application requires durable admission decision material",
+				{ subjectId: record.proposalId, refs: recordRefs(record) },
+			),
+		);
+	}
+	if (options.expectedFamily !== undefined && record.proposalFamily !== options.expectedFamily) {
+		issues.push(
+			issue(
+				"unexpected-proposal-family",
+				`Workspace proposal family '${record.proposalFamily}' does not match expected family '${options.expectedFamily}'`,
+				{ subjectId: record.proposalId, refs: recordRefs(record) },
+			),
+		);
+	}
+	if (
+		options.expectedLoweringKinds !== undefined &&
+		!options.expectedLoweringKinds.includes(record.loweringKind)
+	) {
+		issues.push(
+			issue(
+				"unsupported-lowering-kind",
+				`Workspace proposal loweringKind '${record.loweringKind}' is not supported by this family application`,
+				{ subjectId: record.proposalId, refs: recordRefs(record) },
+			),
+		);
+	}
+	const mismatch = envelopeMismatch(record, decision);
+	if (mismatch !== undefined) {
+		issues.push(
+			issue("proposal-envelope-mismatch", mismatch, {
+				subjectId: record.proposalId,
+				refs: recordRefs(record),
+			}),
+		);
+	}
+	if (decision.status !== "admitted") {
+		issues.push(
+			issue("proposal-not-admitted", "Workspace proposal application requires admitted decision", {
+				subjectId: record.proposalId,
+				refs: recordRefs(record),
+			}),
+		);
+	}
+	if (decision.issues.length > 0) {
+		issues.push(
+			issue(
+				"admission-decision-has-issues",
+				"Workspace proposal application requires issue-free decision",
+				{ subjectId: record.proposalId, refs: recordRefs(record) },
+			),
+		);
+	}
+	if (!decision.sourceRefs.some((entry) => refEquals(entry, recordRefs(record)[0]))) {
+		issues.push(
+			issue(
+				"missing-admission-provenance",
+				"Workspace proposal admission decision must reference the recorded proposal",
+				{ subjectId: record.proposalId, refs: recordRefs(record) },
+			),
+		);
+	}
+	return issues;
+}
+
+export function workspaceProposalApplicationFamilyRef(
+	proposalFamily: WorkspaceProposalFamily,
+	emitted: WorkspaceProposalEmittedFactRefSource,
+	options: { readonly sourceRefs?: readonly SourceRef[] } = {},
+): WorkspaceProposalApplicationFamilyRef {
+	const factId = "eventId" in emitted ? emitted.eventId : emitted.applicationId;
+	if (blank(emitted.kind) || blank(factId)) {
+		throw new TypeError(
+			"Workspace proposal emitted fact refs require fact kind and append-only fact id",
+		);
+	}
+	return freezeRecord({
+		proposalFamily,
+		factKind: emitted.kind,
+		factId,
+		sourceRefs: uniqueRefs([...(emitted.sourceRefs ?? []), ...(options.sourceRefs ?? [])]),
+	});
+}
+
+export function workspaceProposalDataOnlyIssues(
+	value: unknown,
+	label = "value",
+): readonly WorkspaceProposalRecordedIssue[] {
+	return dataOnlyIssues(value, label);
+}
+
+export function assertWorkspaceProposalDataOnly(value: unknown, label = "value"): void {
+	const issues = dataOnlyIssues(value, label);
+	if (issues.length > 0) throw new TypeError(issues[0]?.message ?? `${label} is not data-only`);
+}
+
+function readyRequestIssues(
+	input: unknown,
+	options: WorkspaceProposalProjectorOptions,
+): WorkspaceProposalRecordedIssue[] {
+	const issues = dataOnlyIssues(input, "readyRequest");
+	if (!isRecord(input)) {
+		issues.push(
+			issue("malformed-proposal-envelope", "Workspace proposal ready request must be an object"),
+		);
+		return issues;
+	}
+	if (input.kind !== "workspace-proposal-ready-request")
+		issues.push(
+			issue("malformed-proposal-envelope", "Workspace proposal ready request kind is invalid"),
+		);
+	for (const key of [
+		"proposalId",
+		"intakeRequestId",
+		"idempotencyKey",
+		"workspaceId",
+		"proposalFamily",
+		"loweringKind",
+	] as const) {
+		if (blank(input[key])) issues.push(issue(`missing-${kebab(key)}`, `${key} is required`));
+	}
+	if (!isRef(input.actorRef)) issues.push(issue("missing-actor-ref", "actorRef is required"));
+	if (!nonEmptyRefs(input.capabilityRefs))
+		issues.push(issue("missing-capability", "capabilityRefs are required"));
+	if (!nonEmptyRefs(input.policyRefs))
+		issues.push(issue("missing-policy", "policyRefs are required"));
+	if (!Array.isArray(input.targetRefs) || input.targetRefs.length === 0) {
+		issues.push(issue("missing-target-ref", "targetRefs are required"));
+	} else if (!isDenseArray(input.targetRefs) || !input.targetRefs.every(isTargetRef)) {
+		issues.push(issue("malformed-target-ref", "targetRefs must be target ref data"));
+	}
+	if (!nonEmptyRefs(input.projectionBundleRefs))
+		issues.push(issue("missing-projection-bundle-ref", "projectionBundleRefs are required"));
+	if (!familySupported(input.proposalFamily as WorkspaceProposalFamily, options)) {
+		issues.push(
+			issue(
+				"unsupported-proposal-family",
+				`Unsupported proposal family '${String(input.proposalFamily)}'`,
+			),
+		);
+	}
+	if (input.draft === undefined && !nonEmptyRefs(input.draftRefs))
+		issues.push(issue("missing-draft-material", "draft or draftRefs are required"));
+	if (input.draft !== undefined && inlineDraftBytes(input.draft) > maxInlineDraftBytes(options))
+		issues.push(issue("oversized-inline-draft", "Workspace proposal inline draft exceeds bound"));
+	return issues;
+}
+
+function admissionStatus(
+	issues: readonly WorkspaceProposalRecordedIssue[],
+	humanReview: boolean,
+	policyOutcome: WorkspaceProposalAdmissionStatus | undefined,
+): WorkspaceProposalAdmissionStatus {
+	if (
+		issues.some(
+			(entry) => entry.code === "missing-policy" || entry.code === "missing-admission-outcome",
+		)
+	)
+		return "needs-review";
+	if (humanReview || policyOutcome === "needs-review") return "needs-review";
+	if (policyOutcome === "rejected" || issues.some((entry) => entry.code === "duplicate-proposal"))
+		return "rejected";
+	if (policyOutcome === "blocked" || issues.length > 0) return "blocked";
+	return policyOutcome === "admitted" ? "admitted" : "needs-review";
+}
+
+function policyMatches(
+	policy: WorkspaceProposalAdmissionPolicy,
+	record: WorkspaceProposalRecorded,
+) {
+	if (
+		policy.proposalFamilies !== undefined &&
+		!policy.proposalFamilies.includes(record.proposalFamily)
+	)
+		return false;
+	if (policy.loweringKinds !== undefined && !policy.loweringKinds.includes(record.loweringKind))
+		return false;
+	return true;
+}
+
+function envelopeMismatch(
+	record: WorkspaceProposalRecorded,
+	decision: WorkspaceProposalAdmissionDecision,
+): string | undefined {
+	const fields = [
+		"proposalId",
+		"intakeRequestId",
+		"idempotencyKey",
+		"workspaceId",
+		"proposalFamily",
+		"loweringKind",
+		"draftIdentity",
+	] as const;
+	for (const field of fields) if (record[field] !== decision[field]) return `${field} mismatch`;
+	if (!refEquals(record.actorRef, decision.actorRef)) return "actorRef mismatch";
+	if (stableStringify(record.capabilityRefs) !== stableStringify(decision.capabilityRefs))
+		return "capabilityRefs mismatch";
+	if (stableStringify(record.policyRefs) !== stableStringify(decision.policyRefs))
+		return "policyRefs mismatch";
+	if (stableStringify(record.targetRefs) !== stableStringify(decision.targetRefs))
+		return "targetRefs mismatch";
+	for (const sourceRef of record.sourceRefs) {
+		if (!decision.sourceRefs.some((entry) => refEquals(entry, sourceRef)))
+			return "sourceRefs mismatch";
+	}
+	return undefined;
+}
+
+function recordStatus(
+	state: "recorded" | "blocked",
+	request: Partial<WorkspaceProposalReadyRequest>,
+	issues: readonly WorkspaceProposalRecordedIssue[],
+): WorkspaceProposalRecordStatus {
+	return freezeRecord({
+		kind: "workspace-proposal-record-status",
+		statusId: `${request.proposalId ?? request.intakeRequestId ?? "unknown"}:${state}`,
+		proposalId: stringOrUndefined(request.proposalId),
+		intakeRequestId: stringOrUndefined(request.intakeRequestId),
+		workspaceId: stringOrUndefined(request.workspaceId),
+		state,
+		code: issues[0]?.code,
+		issues: issues.length === 0 ? undefined : issues,
+		sourceRefs: request.sourceRefs,
+		audit: request.audit,
+	});
+}
+
+function blockedAdmissionDecision(
+	record: WorkspaceProposalRecorded,
+	_material: Partial<WorkspaceProposalAdmissionMaterial>,
+	issues: readonly WorkspaceProposalRecordedIssue[],
+): WorkspaceProposalAdmissionDecision {
+	return freezeRecord({
+		kind: "workspace-proposal-admission-decision",
+		decisionId: `${record.proposalId}:admission-blocked`,
+		proposalId: record.proposalId,
+		intakeRequestId: record.intakeRequestId,
+		idempotencyKey: record.idempotencyKey,
+		workspaceId: record.workspaceId,
+		proposalFamily: record.proposalFamily,
+		loweringKind: record.loweringKind,
+		draftIdentity: record.draftIdentity,
+		targetRefs: record.targetRefs,
+		actorRef: record.actorRef,
+		capabilityRefs: record.capabilityRefs,
+		policyRefs: record.policyRefs,
+		status: "blocked",
+		issues,
+		sourceRefs: record.sourceRefs,
+		audit: record.audit,
+	});
+}
+
+function blockedApplicationStatus(
+	record: WorkspaceProposalRecorded,
+	decision: WorkspaceProposalAdmissionDecision,
+	options: WorkspaceProposalApplicationOptions,
+	issues: readonly WorkspaceProposalRecordedIssue[],
+): WorkspaceProposalApplicationResult {
+	const status: WorkspaceProposalApplicationStatus = freezeRecord({
+		kind: "workspace-proposal-application-status",
+		applicationId: options.applicationId,
+		proposalId: record.proposalId,
+		intakeRequestId: record.intakeRequestId,
+		idempotencyKey: record.idempotencyKey,
+		workspaceId: record.workspaceId,
+		decisionId: decision.decisionId,
+		proposalFamily: record.proposalFamily,
+		loweringKind: record.loweringKind,
+		targetRefs: record.targetRefs,
+		policyRefs: record.policyRefs,
+		state: "blocked",
+		code: issues[0]?.code,
+		issues,
+		emittedFactRefs: [],
+		sourceRefs: uniqueRefs([
+			...recordRefs(record),
+			{ kind: "workspace-proposal-admission-decision", id: decision.decisionId },
+			...record.sourceRefs,
+			...(options.audit?.sourceRefs ?? []),
+		]),
+		audit: options.audit ?? record.audit,
+	});
+	return { status, issues };
+}
+
+function dataOnlyIssues(value: unknown, label: string): WorkspaceProposalRecordedIssue[] {
+	const issues: WorkspaceProposalRecordedIssue[] = [];
+	const active = new WeakSet<object>();
+	const visit = (entry: unknown, path: string): void => {
+		if (
+			entry === null ||
+			typeof entry === "number" ||
+			typeof entry === "boolean" ||
+			typeof entry === "undefined"
+		)
+			return;
+		if (typeof entry === "string") {
+			if (forbiddenStringMaterial(entry))
+				issues.push(issue("forbidden-runtime-material", `${path} is not proposal data material`));
+			return;
+		}
+		if (typeof entry === "function" || typeof entry === "symbol" || typeof entry === "bigint") {
+			issues.push(issue("non-data-material", `${path} is not structured data`));
+			return;
+		}
+		if (typeof entry !== "object") return;
+		if (active.has(entry)) {
+			issues.push(issue("cyclic-data-material", `${path} contains a cycle`));
+			return;
+		}
+		active.add(entry);
+		if (Array.isArray(entry)) {
+			for (let index = 0; index < entry.length; index += 1) {
+				if (!Object.hasOwn(entry, index)) {
+					issues.push(issue("non-data-material", `${path}[${index}] is a sparse array hole`));
+					continue;
+				}
+				visit(entry[index], `${path}[${index}]`);
+			}
+			for (const key of Reflect.ownKeys(entry))
+				inspectOwnKey(entry, key, path, true, visit, issues);
+			active.delete(entry);
+			return;
+		}
+		const proto = Object.getPrototypeOf(entry);
+		if (proto !== Object.prototype && proto !== null) {
+			issues.push(issue("non-data-material", `${path} must be a plain object or array`));
+			active.delete(entry);
+			return;
+		}
+		for (const key of Reflect.ownKeys(entry)) {
+			inspectOwnKey(entry, key, path, false, visit, issues);
+		}
+		active.delete(entry);
+	};
+	visit(value, label);
+	return issues;
+}
+
+function inspectOwnKey(
+	entry: object,
+	key: string | symbol,
+	path: string,
+	arrayKey: boolean,
+	visit: (entry: unknown, path: string) => void,
+	issues: WorkspaceProposalRecordedIssue[],
+): void {
+	if (typeof key !== "string") {
+		issues.push(issue("non-data-material", `${path} contains a non-string key`));
+		return;
+	}
+	if (arrayKey && (key === "length" || arrayIndexKey(key))) return;
+	const childPath = arrayKey ? `${path}.${key}` : `${path}.${key}`;
+	const normalized = key.toLowerCase().replace(/[-_\s]/g, "");
+	if (forbiddenKeyName(normalized)) {
+		issues.push(issue("forbidden-runtime-material", `${childPath} is not proposal data material`));
+	}
+	const descriptor = Object.getOwnPropertyDescriptor(entry, key);
+	if (descriptor?.get !== undefined || descriptor?.set !== undefined) {
+		issues.push(issue("non-data-material", `${childPath} uses an accessor`));
+		return;
+	}
+	visit((entry as Record<string, unknown>)[key], childPath);
+}
+
+function forbiddenKeyName(normalized: string): boolean {
+	return (
+		FORBIDDEN_KEY_NAMES.has(normalized) ||
+		FORBIDDEN_KEY_PARTS.some((part) => normalized.includes(part))
+	);
+}
+
+function issue(
+	code: string,
+	message: string,
+	opts: { readonly subjectId?: string; readonly refs?: readonly SourceRef[] } = {},
+): WorkspaceProposalRecordedIssue {
+	return {
+		kind: "issue",
+		source: "workspace-proposal",
+		severity: "error",
+		code,
+		message,
+		subjectId: opts.subjectId,
+		refs: opts.refs?.map((entry) => `${entry.kind}:${entry.id}`),
+	};
+}
+
+function recordRefs(record: WorkspaceProposalRecorded): readonly SourceRef[] {
+	return [
+		{ kind: "workspace-proposal-recorded", id: record.proposalId },
+		{ kind: "workspace-proposal-intake-request", id: record.intakeRequestId },
+		...record.sourceRefs,
+	];
+}
+
+function draftIdentityFor(request: WorkspaceProposalReadyRequest): string {
+	if (request.draftRefs !== undefined && request.draftRefs.length > 0)
+		return `refs:${stableStringify(request.draftRefs)}`;
+	return `inline:${stableStringify(request.draft)}`;
+}
+
+function familySupported(
+	family: WorkspaceProposalFamily,
+	options: WorkspaceProposalProjectorOptions,
+): boolean {
+	const supported = options.supportedFamilies ?? Array.from(BUILT_IN_FAMILIES);
+	return supported.includes(family);
+}
+
+function inlineDraftBytes(value: unknown): number {
+	return new TextEncoder().encode(stableStringify(value)).byteLength;
+}
+
+function maxInlineDraftBytes(options: WorkspaceProposalProjectorOptions): number {
+	return options.maxInlineDraftBytes ?? DEFAULT_MAX_INLINE_DRAFT_BYTES;
+}
+
+function stableStringify(value: unknown): string {
+	if (Array.isArray(value)) return `[${value.map(stableStringify).join(",")}]`;
+	if (isRecord(value)) {
+		return `{${Object.keys(value)
+			.sort()
+			.map((key) => `${JSON.stringify(key)}:${stableStringify(value[key])}`)
+			.join(",")}}`;
+	}
+	return JSON.stringify(value);
+}
+
+function targetRefEquals(
+	left: WorkspaceProposalTargetRef,
+	right: WorkspaceProposalTargetRef,
+): boolean {
+	return stableStringify(left) === stableStringify(right);
+}
+
+function refEquals(left: SourceRef, right: SourceRef): boolean {
+	return left.kind === right.kind && left.id === right.id;
+}
+
+function uniqueRefs(refs: readonly SourceRef[]): readonly SourceRef[] {
+	const seen = new Set<string>();
+	const out: SourceRef[] = [];
+	for (const ref of refs) {
+		const key = `${ref.kind}:${ref.id}:${stableStringify(ref.metadata)}`;
+		if (seen.has(key)) continue;
+		seen.add(key);
+		out.push(ref);
+	}
+	return out;
+}
+
+function uniqueStrings(values: readonly string[]): readonly string[] {
+	return [...new Set(values)];
+}
+
+function applicationFamilyRefIssues(
+	refs: readonly WorkspaceProposalApplicationFamilyRef[],
+	record: WorkspaceProposalRecorded,
+): readonly WorkspaceProposalRecordedIssue[] {
+	const issues: WorkspaceProposalRecordedIssue[] = [];
+	for (const [index, value] of refs.entries()) {
+		if (!isRecord(value)) {
+			issues.push(
+				issue(
+					"malformed-family-emitted-fact-ref",
+					"Workspace proposal application emitted fact refs must be closed ref records",
+					{ subjectId: record.proposalId, refs: recordRefs(record) },
+				),
+			);
+			continue;
+		}
+		for (const key of Object.keys(value)) {
+			if (!["proposalFamily", "factKind", "factId", "sourceRefs"].includes(key)) {
+				issues.push(
+					issue(
+						"malformed-family-emitted-fact-ref",
+						`Workspace proposal application emitted fact ref contains unsupported field '${key}'`,
+						{ subjectId: record.proposalId, refs: recordRefs(record) },
+					),
+				);
+			}
+		}
+		if (value.proposalFamily !== record.proposalFamily) {
+			issues.push(
+				issue(
+					"family-ref-mismatch",
+					"Workspace proposal application emitted fact ref mismatches family",
+					{ subjectId: record.proposalId, refs: recordRefs(record) },
+				),
+			);
+		}
+		if (blank(value.factKind) || blank(value.factId)) {
+			issues.push(
+				issue(
+					"malformed-family-emitted-fact-ref",
+					`Workspace proposal application emitted fact ref at index ${index} requires factKind and factId`,
+					{ subjectId: record.proposalId, refs: recordRefs(record) },
+				),
+			);
+		}
+		const allowedFactKinds = FAMILY_FACT_KINDS[record.proposalFamily];
+		if (allowedFactKinds === undefined || !allowedFactKinds.includes(value.factKind as string)) {
+			issues.push(
+				issue(
+					"unsupported-family-fact-kind",
+					`Workspace proposal family '${record.proposalFamily}' does not allow emitted fact kind '${String(value.factKind)}'`,
+					{ subjectId: record.proposalId, refs: recordRefs(record) },
+				),
+			);
+		}
+		if (value.sourceRefs !== undefined && !refsShape(value.sourceRefs)) {
+			issues.push(
+				issue(
+					"malformed-family-emitted-fact-ref",
+					"Workspace proposal application emitted fact ref sourceRefs must be refs",
+					{ subjectId: record.proposalId, refs: recordRefs(record) },
+				),
+			);
+		}
+	}
+	return issues;
+}
+
+function isTargetRef(value: unknown): value is WorkspaceProposalTargetRef {
+	return isRecord(value) && nonBlankString(value.kind) && nonBlankString(value.id);
+}
+
+function isRef(value: unknown): value is SourceRef {
+	return isRecord(value) && nonBlankString(value.kind) && nonBlankString(value.id);
+}
+
+function nonEmptyRefs(value: unknown): value is readonly SourceRef[] {
+	return refsShape(value) && value.length > 0;
+}
+
+function refsShape(value: unknown): value is readonly SourceRef[] {
+	return Array.isArray(value) && isDenseArray(value) && value.every(isRef);
+}
+
+function isDenseArray(value: readonly unknown[]): boolean {
+	for (let index = 0; index < value.length; index += 1) {
+		if (!Object.hasOwn(value, index)) return false;
+	}
+	return true;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+function blank(value: unknown): boolean {
+	return !nonBlankString(value);
+}
+
+function nonBlankString(value: unknown): value is string {
+	return typeof value === "string" && value.trim() !== "";
+}
+
+function stringOrUndefined(value: unknown): string | undefined {
+	return typeof value === "string" ? value : undefined;
+}
+
+function kebab(value: string): string {
+	return value.replace(/[A-Z]/g, (char) => `-${char.toLowerCase()}`);
+}
+
+function arrayIndexKey(key: string): boolean {
+	if (key === "") return false;
+	const index = Number(key);
+	return Number.isInteger(index) && index >= 0 && String(index) === key;
+}
+
+function forbiddenStringMaterial(value: string): boolean {
+	const trimmed = value.trim();
+	if (trimmed === "") return false;
+	if (/^(https?|file|ssh|sftp|postgres|postgresql|mysql|sqlite|mongodb|redis):\/\//i.test(trimmed))
+		return true;
+	if (/^(bash|sh|zsh|fish|pwsh|powershell)\s+-[a-z]*c\b/i.test(trimmed)) return true;
+	if (/\b(rm\s+-rf|curl\s+https?:|wget\s+https?:|psql\s+|mysql\s+|sqlite3\s+)/i.test(trimmed))
+		return true;
+	if (
+		/\b(bearer\s+[a-z0-9._~+/=-]+|credential:|secret:|api[_-]?key\s*=|access[_-]?token\s*=)/i.test(
+			trimmed,
+		)
+	)
+		return true;
+	if (
+		/^\s*(select|insert|update|delete|drop|alter|create)\s+.+\b(from|into|table|database|where)\b/i.test(
+			trimmed,
+		)
+	)
+		return true;
+	return false;
+}
+
+function freezeRecord<T extends object>(value: T): T {
+	return immutableClone(value);
+}
diff --git a/packages/ts/src/sources/browser.ts b/packages/ts/src/sources/browser.ts
new file mode 100644
index 00000000..85012a64
--- /dev/null
+++ b/packages/ts/src/sources/browser.ts
@@ -0,0 +1,221 @@
+/**
+ * Browser-safe source factories. This subpath intentionally excludes
+ * Node-only adapters such as fromFSWatch.
+ */
+
+import type { Ctx } from "../ctx/types.js";
+import type { Operator } from "../graph/operators.js";
+import { errorPayload } from "../protocol/messages.js";
+
+export * from "./index.js";
+
+type IDBEventHandler<TThis> = {
+	bivarianceHack(this: TThis, event: unknown): unknown;
+}["bivarianceHack"];
+
+export interface IDBRequestLike<T> {
+	result: T;
+	error?: unknown;
+	onsuccess: null | IDBEventHandler<IDBRequestLike<T>>;
+	onerror: null | IDBEventHandler<IDBRequestLike<T>>;
+}
+
+export interface IDBTransactionLike {
+	error?: unknown;
+	oncomplete: null | IDBEventHandler<IDBTransactionLike>;
+	onerror: null | IDBEventHandler<IDBTransactionLike>;
+	onabort: null | IDBEventHandler<IDBTransactionLike>;
+}
+
+export type AnimationFrameHandle = number | ReturnType<typeof setTimeout>;
+
+export interface AnimationFrameScheduler {
+	requestAnimationFrame(callback: (time: number) => void): AnimationFrameHandle;
+	cancelAnimationFrame(handle: AnimationFrameHandle): void;
+}
+
+export interface VisibilityDocumentLike {
+	readonly visibilityState?: "hidden" | "visible" | "prerender" | string;
+	addEventListener?(type: "visibilitychange", listener: () => void): void;
+	removeEventListener?(type: "visibilitychange", listener: () => void): void;
+}
+
+export interface FromRafOptions {
+	/** Custom scheduler for tests or host wrappers. Defaults to browser rAF, then a timer fallback. */
+	readonly scheduler?: AnimationFrameScheduler;
+	/** Timer fallback cadence when requestAnimationFrame is unavailable. Default: 16ms. */
+	readonly fallbackMs?: number;
+	/** Fully park while the provided/browser document is hidden. Default: false. */
+	readonly pauseWhenHidden?: boolean;
+	/** Document-like visibility source for tests or embedded browser hosts. */
+	readonly document?: VisibilityDocumentLike;
+}
+
+function source<T>(
+	factory: string,
+	setup: (ctx: Ctx) => undefined | (() => void),
+): Operator<never, T> {
+	return {
+		factory,
+		body: (ctx) => {
+			const cleanup = setup(ctx);
+			if (typeof cleanup === "function") ctx.onDeactivation(cleanup);
+		},
+	};
+}
+
+function defaultAnimationFrameScheduler(fallbackMs: number): AnimationFrameScheduler {
+	const host = globalThis as {
+		requestAnimationFrame?: (callback: (time: number) => void) => number;
+		cancelAnimationFrame?: (handle: number) => void;
+	};
+	if (
+		typeof host.requestAnimationFrame === "function" &&
+		typeof host.cancelAnimationFrame === "function"
+	) {
+		return {
+			requestAnimationFrame: (callback) => host.requestAnimationFrame?.(callback) ?? 0,
+			cancelAnimationFrame: (handle) => {
+				if (typeof handle === "number") host.cancelAnimationFrame?.(handle);
+			},
+		};
+	}
+	return {
+		requestAnimationFrame(callback) {
+			return setTimeout(() => callback(Date.now()), fallbackMs);
+		},
+		cancelAnimationFrame(handle) {
+			clearTimeout(handle);
+		},
+	};
+}
+
+function defaultVisibilityDocument(): VisibilityDocumentLike | undefined {
+	return (globalThis as { document?: VisibilityDocumentLike }).document;
+}
+
+/**
+ * Browser animation-frame source.
+ *
+ * This is a browser/source boundary, not reactive-layout ownership (D181): every frame timestamp
+ * enters the graph as DATA through `ctx.down`, and teardown cancels the pending host callback.
+ */
+export function fromRaf(opts: FromRafOptions = {}): Operator<never, number> {
+	const fallbackMsOpt = opts.fallbackMs;
+	const fallbackMs =
+		Number.isFinite(fallbackMsOpt) && fallbackMsOpt !== undefined && fallbackMsOpt > 0
+			? fallbackMsOpt
+			: 16;
+	const scheduler = opts.scheduler ?? defaultAnimationFrameScheduler(fallbackMs);
+	const visibilityDocument = opts.document ?? defaultVisibilityDocument();
+	return {
+		factory: "fromRaf",
+		opts: { pool: "sync", pausable: false },
+		body: (ctx) => {
+			let active = true;
+			let frame: AnimationFrameHandle | undefined;
+			const cancelPending = () => {
+				if (frame === undefined) return;
+				scheduler.cancelAnimationFrame(frame);
+				frame = undefined;
+			};
+			const isHidden = () =>
+				opts.pauseWhenHidden === true && visibilityDocument?.visibilityState === "hidden";
+			const schedule = () => {
+				if (!active || frame !== undefined || isHidden()) return;
+				frame = scheduler.requestAnimationFrame((time) => {
+					frame = undefined;
+					if (!active || isHidden()) return;
+					ctx.down([["DATA", Number.isFinite(time) ? time : Date.now()]]);
+					schedule();
+				});
+			};
+			const onVisibilityChange = () => {
+				if (!active) return;
+				if (isHidden()) cancelPending();
+				else schedule();
+			};
+			if (
+				opts.pauseWhenHidden === true &&
+				visibilityDocument?.addEventListener &&
+				visibilityDocument.removeEventListener
+			) {
+				visibilityDocument.addEventListener("visibilitychange", onVisibilityChange);
+			}
+			ctx.onDeactivation(() => {
+				active = false;
+				cancelPending();
+				visibilityDocument?.removeEventListener?.("visibilitychange", onVisibilityChange);
+			});
+			schedule();
+		},
+	};
+}
+
+/** Wrap an IndexedDB request as a one-shot source. */
+export function fromIDBRequest<T>(request: IDBRequestLike<T>): Operator<never, T> {
+	return source<T>("fromIDBRequest", (ctx) => {
+		let done = false;
+		const clear = () => {
+			request.onsuccess = null;
+			request.onerror = null;
+		};
+		request.onsuccess = () => {
+			if (done) return;
+			done = true;
+			clear();
+			if (request.result === undefined) {
+				ctx.down([
+					["ERROR", new TypeError("fromIDBRequest: request.result is the substrate SENTINEL")],
+				]);
+				return;
+			}
+			ctx.down([["DATA", request.result], ["COMPLETE"]]);
+		};
+		request.onerror = () => {
+			if (done) return;
+			done = true;
+			clear();
+			ctx.down([["ERROR", errorPayload(request.error ?? new Error("IndexedDB request failed"))]]);
+		};
+		return () => {
+			done = true;
+			clear();
+		};
+	});
+}
+
+/**
+ * Wrap an IndexedDB transaction lifecycle as a terminal-only source.
+ *
+ * Success emits COMPLETE without DATA: undefined is the TypeScript SENTINEL and cannot be a DATA
+ * payload under R-data-payload.
+ */
+export function fromIDBTransaction(transaction: IDBTransactionLike): Operator<never, never> {
+	return source<never>("fromIDBTransaction", (ctx) => {
+		let done = false;
+		const clear = () => {
+			transaction.oncomplete = null;
+			transaction.onerror = null;
+			transaction.onabort = null;
+		};
+		const fail = (fallback: string) => {
+			if (done) return;
+			done = true;
+			clear();
+			ctx.down([["ERROR", errorPayload(transaction.error ?? new Error(fallback))]]);
+		};
+		transaction.oncomplete = () => {
+			if (done) return;
+			done = true;
+			clear();
+			ctx.down([["COMPLETE"]]);
+		};
+		transaction.onerror = () => fail("IndexedDB transaction failed");
+		transaction.onabort = () => fail("IndexedDB transaction aborted");
+		return () => {
+			done = true;
+			clear();
+		};
+	});
+}
diff --git a/packages/ts/src/sources/index.ts b/packages/ts/src/sources/index.ts
new file mode 100644
index 00000000..50573c36
--- /dev/null
+++ b/packages/ts/src/sources/index.ts
@@ -0,0 +1,53 @@
+export type {
+	DriverResult,
+	HttpRequest,
+	HttpResponse,
+	SseDriverEvent,
+	SseEvent,
+	SseRequest,
+	WebhookDriverEvent,
+	WebhookEvent,
+	WebhookRegistration,
+	WebSocketDriverEvent,
+	WebSocketEvent,
+	WebSocketRequest,
+} from "../graph/environment.js";
+export {
+	type AsyncSourceOpts,
+	type CronSchedule,
+	type EventListenerOptionsLike,
+	type EventTargetLike,
+	empty,
+	type FromCronOptions,
+	type FromEventOptions,
+	firstValueFrom,
+	fromAny,
+	fromAsyncIter,
+	fromCron,
+	fromEvent,
+	fromHttp,
+	fromHttpWithOptions,
+	fromIter,
+	fromPromise,
+	fromPushNotification,
+	fromSSE,
+	fromSSEWithOptions,
+	fromTimer,
+	fromWebhook,
+	fromWebhookWithOptions,
+	fromWebSocket,
+	fromWebSocketWithOptions,
+	interval,
+	matchesCron,
+	type NodeInput,
+	never,
+	of,
+	type PushRegister,
+	type PushUnsubscribe,
+	parseCron,
+	type SingleFromAnyOptions,
+	singleFromAny,
+	type TimerSourceOpts,
+	throwError,
+	timer,
+} from "../graph/sources.js";
diff --git a/packages/ts/src/sources/node.ts b/packages/ts/src/sources/node.ts
new file mode 100644
index 00000000..e28933f7
--- /dev/null
+++ b/packages/ts/src/sources/node.ts
@@ -0,0 +1,824 @@
+/**
+ * Node-only source factories. Import from `@graphrefly/ts/sources/node`; the universal
+ * `@graphrefly/ts/sources` barrel stays browser-safe.
+ */
+
+import { execFileSync, type SpawnOptions, spawn } from "node:child_process";
+import { type Dirent, existsSync, type FSWatcher, readdirSync, statSync, watch } from "node:fs";
+import { dirname, join, relative, resolve as resolvePath } from "node:path";
+import type { Ctx } from "../ctx/types.js";
+import type {
+	DriverResult,
+	ProcessResult as EnvironmentProcessResult,
+	LocalProcessDriver,
+	ProcessCommand,
+} from "../graph/environment.js";
+import type { Operator } from "../graph/operators.js";
+import { errorPayload } from "../protocol/messages.js";
+
+export type FSEventType = "change" | "rename" | "create" | "delete";
+
+export interface FSEvent {
+	readonly type: FSEventType;
+	readonly path: string;
+	readonly root: string;
+	readonly relativePath: string;
+}
+
+export interface FromFSWatchOptions {
+	/** Use Node's recursive fs.watch mode where the host platform supports it. Default: false. */
+	readonly recursive?: boolean;
+	/** Coalesce events per path for this many milliseconds. Default: 100. */
+	readonly debounceMs?: number;
+	/** Emit create events for existing files after watcher registration. Default: false. */
+	readonly initialScan?: boolean | "files";
+	/** Include glob patterns matched against absolute and relative slash-normalized paths. */
+	readonly include?: readonly string[];
+	/** Exclude glob patterns matched against absolute and relative slash-normalized paths. */
+	readonly exclude?: readonly string[];
+	/** AbortSignal aborts the source to ERROR and closes all watchers. */
+	readonly signal?: AbortSignal;
+}
+
+export type SpawnEvent =
+	| { readonly kind: "stdout"; readonly chunk: Buffer }
+	| { readonly kind: "stderr"; readonly chunk: Buffer }
+	| { readonly kind: "exit"; readonly code: number | null; readonly signal: NodeJS.Signals | null };
+
+export interface FromSpawnOptions {
+	readonly cwd?: string;
+	readonly env?: NodeJS.ProcessEnv;
+	readonly shell?: boolean | string;
+	readonly signal?: AbortSignal;
+	readonly stdio?: "pipe" | readonly ("pipe" | "ignore" | "inherit")[];
+	/** Milliseconds after teardown SIGTERM before sending SIGKILL. Default: 1000. */
+	readonly killGraceMs?: number;
+}
+
+/**
+ * Node-only process driver options for D130/D131 EnvironmentDrivers.
+ *
+ * These knobs configure host child-process behavior at the driver boundary only; they do not
+ * change graph wave, tier, or message semantics.
+ */
+export interface NodeProcessDriverOptions {
+	/** Milliseconds after cancellation SIGTERM before sending SIGKILL. Default: 1000. */
+	readonly killGraceMs?: number;
+	/** Maximum captured stdout + stderr bytes before terminating with ERROR. Default: 16 MiB. */
+	readonly maxBufferBytes?: number;
+	/** Optional shell mode passed to Node's child_process.spawn. Default: false. */
+	readonly shell?: boolean | string;
+}
+
+export interface ProcessResult {
+	readonly stdout: string;
+	readonly stderr: string;
+	readonly exitCode: number | null;
+	readonly signal: NodeJS.Signals | null;
+}
+
+export type GitHookType = "post-commit" | "post-merge" | "post-checkout" | "post-rewrite";
+
+export interface GitEvent {
+	readonly hook: GitHookType;
+	readonly commit: string;
+	readonly files: readonly string[];
+	readonly message: string;
+	readonly author: string;
+	readonly timestamp_ns: string;
+}
+
+export interface FromGitHookOptions {
+	readonly pollMs?: number;
+	readonly include?: readonly string[];
+	readonly exclude?: readonly string[];
+	readonly maxConsecutiveErrors?: number;
+	readonly signal?: AbortSignal;
+}
+
+function source<T>(
+	factory: string,
+	setup: (ctx: Ctx) => undefined | (() => void),
+): Operator<never, T> {
+	return {
+		factory,
+		body: (ctx) => {
+			const cleanup = setup(ctx);
+			if (typeof cleanup === "function") ctx.onDeactivation(cleanup);
+		},
+	};
+}
+
+function normalizePath(path: string): string {
+	return path.replaceAll("\\", "/");
+}
+
+function escapeRegExp(value: string): string {
+	return value.replace(/[|\\{}()[\]^$+?.]/g, "\\$&");
+}
+
+function globToRegExp(pattern: string): RegExp {
+	let out = "^";
+	for (let i = 0; i < pattern.length; i += 1) {
+		const ch = pattern[i];
+		if (ch === "*") {
+			if (pattern[i + 1] === "*") {
+				out += ".*";
+				i += 1;
+			} else {
+				out += "[^/]*";
+			}
+		} else {
+			out += escapeRegExp(ch);
+		}
+	}
+	return new RegExp(`${out}$`);
+}
+
+function matchesAny(value: string, patterns: readonly RegExp[]): boolean {
+	return patterns.some((pattern) => pattern.test(value));
+}
+
+function timestampNsNow(): string {
+	return (BigInt(Date.now()) * 1_000_000n).toString();
+}
+
+function validatePositiveFinite(name: string, value: number): void {
+	if (!Number.isFinite(value) || value <= 0) {
+		throw new RangeError(`${name} must be a positive finite number`);
+	}
+}
+
+function validateNonNegativeFinite(name: string, value: number): void {
+	if (!Number.isFinite(value) || value < 0) {
+		throw new RangeError(`${name} must be a non-negative finite number`);
+	}
+}
+
+function eventTypeFor(eventType: "rename" | "change", path: string): FSEventType {
+	if (eventType === "change") return "change";
+	try {
+		return existsSync(path) ? "create" : "delete";
+	} catch {
+		return "rename";
+	}
+}
+
+function scanFiles(
+	root: string,
+	recursive: boolean,
+	isExcluded: (abs: string, rel: string) => boolean,
+): readonly string[] {
+	const resolved = resolvePath(root);
+	try {
+		const st = statSync(resolved);
+		if (st.isFile()) return [resolved];
+		if (!st.isDirectory()) return [];
+	} catch {
+		return [];
+	}
+
+	const out: string[] = [];
+	function walk(dir: string): void {
+		let entries: Dirent[];
+		try {
+			entries = readdirSync(dir, { withFileTypes: true });
+		} catch {
+			return;
+		}
+		for (const entry of entries) {
+			const abs = join(dir, entry.name);
+			const rel = relative(resolved, abs);
+			if (entry.isFile()) {
+				out.push(abs);
+			} else if (recursive && entry.isDirectory() && !isExcluded(abs, rel)) {
+				walk(abs);
+			}
+		}
+	}
+	walk(resolved);
+	return out;
+}
+
+/**
+ * fromFSWatch: Node.js filesystem watcher source.
+ *
+ * External fs callbacks are a source boundary (R-no-raw-async): events enter the graph only via
+ * `ctx.down`, and cleanup is tied to node deactivation through `ctx.onDeactivation`.
+ */
+export function fromFSWatch(
+	paths: string | readonly string[],
+	opts: FromFSWatchOptions = {},
+): Operator<never, FSEvent> {
+	const list = (Array.isArray(paths) ? paths : [paths]).map((path) => resolvePath(path));
+	if (list.length === 0) throw new RangeError("fromFSWatch: paths must not be empty");
+	const {
+		recursive = false,
+		debounceMs = 100,
+		initialScan = false,
+		include,
+		exclude = ["**/node_modules/**", "**/.git/**", "**/dist/**"],
+		signal,
+	} = opts;
+	if (!Number.isFinite(debounceMs) || debounceMs < 0) {
+		throw new RangeError("fromFSWatch: debounceMs must be a non-negative finite number");
+	}
+	const includePatterns = (include ?? []).map(globToRegExp);
+	const excludePatterns = exclude.map(globToRegExp);
+
+	const accepts = (abs: string, rel: string): boolean => {
+		const normalized = normalizePath(abs);
+		const relNormalized = normalizePath(rel);
+		const included =
+			includePatterns.length === 0 ||
+			matchesAny(normalized, includePatterns) ||
+			matchesAny(relNormalized, includePatterns);
+		if (!included) return false;
+		return !isExcluded(normalized, relNormalized);
+	};
+	const isExcluded = (abs: string, rel: string): boolean => {
+		const normalized = normalizePath(abs);
+		const relNormalized = normalizePath(rel);
+		return (
+			matchesAny(normalized, excludePatterns) ||
+			matchesAny(relNormalized, excludePatterns) ||
+			matchesAny(`${normalized}/`, excludePatterns) ||
+			(relNormalized !== "" && matchesAny(`${relNormalized}/`, excludePatterns))
+		);
+	};
+
+	return source<FSEvent>("fromFSWatch", (ctx) => {
+		let stopped = false;
+		let terminal = false;
+		let ready = initialScan === false;
+		let generation = 0;
+		let timer: ReturnType<typeof setTimeout> | undefined;
+		const watchers: FSWatcher[] = [];
+		const pending = new Map<string, FSEvent>();
+		const buffered = new Map<string, FSEvent>();
+
+		const close = () => {
+			for (const watcher of watchers.splice(0)) watcher.close();
+		};
+		const cleanup = () => {
+			stopped = true;
+			generation += 1;
+			if (timer !== undefined) clearTimeout(timer);
+			timer = undefined;
+			signal?.removeEventListener("abort", onAbort);
+			close();
+			pending.clear();
+			buffered.clear();
+		};
+		const emitError = (err: unknown) => {
+			if (terminal) return;
+			terminal = true;
+			cleanup();
+			ctx.down([["ERROR", errorPayload(err)]]);
+		};
+		function onAbort() {
+			emitError(signal?.reason);
+		}
+		const flush = (token: number) => {
+			timer = undefined;
+			if (stopped || terminal || token !== generation || pending.size === 0) return;
+			const msgs = [...pending.values()].map((event): ["DATA", FSEvent] => ["DATA", event]);
+			pending.clear();
+			ctx.down(msgs);
+		};
+		const schedule = () => {
+			if (timer !== undefined) clearTimeout(timer);
+			const token = generation;
+			if (debounceMs === 0) flush(token);
+			else timer = setTimeout(() => flush(token), debounceMs);
+		};
+		const enqueue = (event: FSEvent) => {
+			if (!ready) {
+				buffered.set(event.path, event);
+				return;
+			}
+			pending.set(event.path, event);
+			schedule();
+		};
+		const eventFor = (
+			basePath: string,
+			eventType: "rename" | "change",
+			fileName: string | Buffer | null,
+		): FSEvent | undefined => {
+			const root = normalizePath(resolvePath(basePath));
+			const abs = normalizePath(fileName == null ? root : resolvePath(basePath, String(fileName)));
+			const rel = normalizePath(fileName == null ? "" : relative(root, abs));
+			if (!accepts(abs, rel)) return undefined;
+			return {
+				type: eventTypeFor(eventType, abs),
+				path: abs,
+				root,
+				relativePath: rel,
+			};
+		};
+
+		if (signal?.aborted) {
+			onAbort();
+			return cleanup;
+		}
+		signal?.addEventListener("abort", onAbort, { once: true });
+
+		try {
+			for (const basePath of list) {
+				const watcher = watch(basePath, { recursive }, (eventType, fileName) => {
+					if (stopped || terminal) return;
+					const event = eventFor(basePath, eventType, fileName);
+					if (event !== undefined) enqueue(event);
+				});
+				watcher.on("error", emitError);
+				watchers.push(watcher);
+			}
+		} catch (err) {
+			emitError(err);
+			return cleanup;
+		}
+
+		if (initialScan !== false) {
+			try {
+				for (const basePath of list) {
+					const root = normalizePath(resolvePath(basePath));
+					let relRoot = root;
+					try {
+						if (statSync(basePath).isFile()) relRoot = dirname(root);
+					} catch {
+						relRoot = root;
+					}
+					for (const absPath of scanFiles(basePath, recursive, isExcluded)) {
+						if (stopped || terminal) return cleanup;
+						const abs = normalizePath(absPath);
+						const rel = normalizePath(relative(relRoot, abs));
+						if (!accepts(abs, rel)) continue;
+						pending.set(abs, {
+							type: "create",
+							path: abs,
+							root,
+							relativePath: rel,
+						});
+					}
+				}
+				ready = true;
+				for (const [key, event] of buffered) pending.set(key, event);
+				buffered.clear();
+				if (pending.size > 0) schedule();
+			} catch (err) {
+				emitError(err);
+			}
+		}
+
+		return cleanup;
+	});
+}
+
+export function fromSpawn(
+	cmd: string,
+	args: readonly string[] = [],
+	opts: FromSpawnOptions = {},
+): Operator<never, SpawnEvent> {
+	if (typeof cmd !== "string" || cmd.length === 0) {
+		throw new TypeError("fromSpawn: cmd must be a non-empty string");
+	}
+	const killGraceMs = opts.killGraceMs ?? 1000;
+	validateNonNegativeFinite("fromSpawn: killGraceMs", killGraceMs);
+	return source<SpawnEvent>("fromSpawn", (ctx) => {
+		let alive = true;
+		let terminal = false;
+		let exitInfo: { code: number | null; signal: NodeJS.Signals | null } | undefined;
+		let child: ReturnType<typeof spawn>;
+		let killTimer: ReturnType<typeof setTimeout> | undefined;
+		const clearKillTimer = () => {
+			if (killTimer !== undefined) clearTimeout(killTimer);
+			killTimer = undefined;
+		};
+		const stop = () => {
+			alive = false;
+			child?.stdout?.removeAllListeners("data");
+			child?.stderr?.removeAllListeners("data");
+			if (!terminal) {
+				try {
+					child?.kill("SIGTERM");
+				} catch {
+					// Process may already have exited.
+				}
+				killTimer = setTimeout(() => {
+					if (!terminal) {
+						try {
+							child?.kill("SIGKILL");
+						} catch {
+							// Process may already have exited.
+						}
+					}
+				}, killGraceMs);
+				killTimer.unref?.();
+			}
+		};
+		try {
+			child = spawn(cmd, [...args], {
+				cwd: opts.cwd,
+				env: opts.env,
+				shell: opts.shell,
+				signal: opts.signal,
+				stdio: (opts.stdio as SpawnOptions["stdio"]) ?? "pipe",
+			});
+		} catch (err) {
+			terminal = true;
+			ctx.down([["ERROR", errorPayload(err)]]);
+			return () => undefined;
+		}
+		child.stdout?.on("data", (chunk: Buffer) => {
+			if (alive) ctx.down([["DATA", { kind: "stdout", chunk }]]);
+		});
+		child.stderr?.on("data", (chunk: Buffer) => {
+			if (alive) ctx.down([["DATA", { kind: "stderr", chunk }]]);
+		});
+		child.on("error", (err) => {
+			if (!alive || terminal) return;
+			terminal = true;
+			alive = false;
+			ctx.down([["ERROR", errorPayload(err)]]);
+		});
+		child.on("exit", (code, signal) => {
+			exitInfo = { code, signal: signal as NodeJS.Signals | null };
+		});
+		child.on("close", () => {
+			clearKillTimer();
+			if (!alive || terminal) return;
+			terminal = true;
+			alive = false;
+			const info = exitInfo ?? { code: null, signal: null };
+			ctx.down([["DATA", { kind: "exit", code: info.code, signal: info.signal }], ["COMPLETE"]]);
+		});
+		return stop;
+	});
+}
+
+/**
+ * Node.js process EnvironmentDriver for D130/D131 adapters.
+ *
+ * Import this from `@graphrefly/ts/sources/node` and install it with
+ * `EnvironmentDrivers.empty().withProcess(nodeProcessDriver())`. The child process is an
+ * adapter-boundary side effect; graph nodes only observe ordinary ProcessResult DATA or ERROR.
+ */
+export function nodeProcessDriver(opts: NodeProcessDriverOptions = {}): LocalProcessDriver {
+	const killGraceMs = opts.killGraceMs ?? 1000;
+	const maxBufferBytes = opts.maxBufferBytes ?? 16 * 1024 * 1024;
+	validateNonNegativeFinite("nodeProcessDriver: killGraceMs", killGraceMs);
+	validateNonNegativeFinite("nodeProcessDriver: maxBufferBytes", maxBufferBytes);
+	return {
+		run(command, callback) {
+			return runNodeProcessCommand(command, callback, {
+				killGraceMs,
+				maxBufferBytes,
+				shell: opts.shell,
+			});
+		},
+	};
+}
+
+export function runProcess(
+	cmd: string,
+	args: readonly string[] = [],
+	opts: FromSpawnOptions = {},
+): Operator<never, ProcessResult> {
+	if (typeof cmd !== "string" || cmd.length === 0) {
+		throw new TypeError("runProcess: cmd must be a non-empty string");
+	}
+	const killGraceMs = opts.killGraceMs ?? 1000;
+	validateNonNegativeFinite("runProcess: killGraceMs", killGraceMs);
+	return source<ProcessResult>("runProcess", (ctx) => {
+		let alive = true;
+		let terminal = false;
+		const stdoutChunks: Buffer[] = [];
+		const stderrChunks: Buffer[] = [];
+		let exitInfo: { code: number | null; signal: NodeJS.Signals | null } | undefined;
+		let child: ReturnType<typeof spawn>;
+		let killTimer: ReturnType<typeof setTimeout> | undefined;
+		const clearKillTimer = () => {
+			if (killTimer !== undefined) clearTimeout(killTimer);
+			killTimer = undefined;
+		};
+		const stop = () => {
+			alive = false;
+			child?.stdout?.removeAllListeners("data");
+			child?.stderr?.removeAllListeners("data");
+			if (!terminal) {
+				try {
+					child?.kill("SIGTERM");
+				} catch {
+					// Process may already have exited.
+				}
+				killTimer = setTimeout(() => {
+					if (!terminal) {
+						try {
+							child?.kill("SIGKILL");
+						} catch {
+							// Process may already have exited.
+						}
+					}
+				}, killGraceMs);
+				killTimer.unref?.();
+			}
+		};
+		try {
+			child = spawn(cmd, [...args], {
+				cwd: opts.cwd,
+				env: opts.env,
+				shell: opts.shell,
+				signal: opts.signal,
+				stdio: (opts.stdio as SpawnOptions["stdio"]) ?? "pipe",
+			});
+		} catch (err) {
+			terminal = true;
+			ctx.down([["ERROR", errorPayload(err)]]);
+			return () => undefined;
+		}
+		child.stdout?.on("data", (chunk: Buffer) => {
+			if (alive) stdoutChunks.push(chunk);
+		});
+		child.stderr?.on("data", (chunk: Buffer) => {
+			if (alive) stderrChunks.push(chunk);
+		});
+		child.on("error", (err) => {
+			if (!alive || terminal) return;
+			terminal = true;
+			alive = false;
+			ctx.down([["ERROR", errorPayload(err)]]);
+		});
+		child.on("exit", (code, signal) => {
+			exitInfo = { code, signal: signal as NodeJS.Signals | null };
+		});
+		child.on("close", () => {
+			clearKillTimer();
+			if (!alive || terminal) return;
+			terminal = true;
+			alive = false;
+			const info = exitInfo ?? { code: null, signal: null };
+			ctx.down([
+				[
+					"DATA",
+					{
+						stdout: Buffer.concat(stdoutChunks).toString("utf8"),
+						stderr: Buffer.concat(stderrChunks).toString("utf8"),
+						exitCode: info.code,
+						signal: info.signal,
+					},
+				],
+				["COMPLETE"],
+			]);
+		});
+		return stop;
+	});
+}
+
+function runNodeProcessCommand(
+	command: ProcessCommand,
+	callback: (result: DriverResult<EnvironmentProcessResult>) => void,
+	opts: {
+		readonly killGraceMs: number;
+		readonly maxBufferBytes: number;
+		readonly shell?: boolean | string;
+	},
+): () => void {
+	if (typeof command.program !== "string" || command.program.length === 0) {
+		callback({
+			ok: false,
+			error: new TypeError("nodeProcessDriver: program must be a non-empty string"),
+		});
+		return () => undefined;
+	}
+	let alive = true;
+	let terminal = false;
+	const stdoutChunks: Buffer[] = [];
+	const stderrChunks: Buffer[] = [];
+	let bufferedBytes = 0;
+	let exitInfo: { code: number | null; signal: string | null } | undefined;
+	let child: ReturnType<typeof spawn>;
+	let killTimer: ReturnType<typeof setTimeout> | undefined;
+	const clearKillTimer = () => {
+		if (killTimer !== undefined) clearTimeout(killTimer);
+		killTimer = undefined;
+	};
+	const stop = () => {
+		if (!alive) return;
+		alive = false;
+		child?.stdout?.removeAllListeners("data");
+		child?.stderr?.removeAllListeners("data");
+		if (!terminal) {
+			try {
+				child?.kill("SIGTERM");
+			} catch {
+				// Process may already have exited.
+			}
+			killTimer = setTimeout(() => {
+				if (!terminal) {
+					try {
+						child?.kill("SIGKILL");
+					} catch {
+						// Process may already have exited.
+					}
+				}
+			}, opts.killGraceMs);
+			killTimer.unref?.();
+		}
+	};
+	try {
+		child = spawn(command.program, [...command.args], {
+			cwd: command.cwd,
+			env: command.env === undefined ? undefined : Object.fromEntries(command.env),
+			shell: opts.shell,
+			stdio: ["ignore", "pipe", "pipe"],
+		});
+	} catch (err) {
+		terminal = true;
+		callback({ ok: false, error: err });
+		return () => undefined;
+	}
+	const fail = (error: unknown) => {
+		clearKillTimer();
+		if (!alive || terminal) return;
+		terminal = true;
+		alive = false;
+		child.stdout?.removeAllListeners("data");
+		child.stderr?.removeAllListeners("data");
+		try {
+			child.kill("SIGTERM");
+		} catch {
+			// Process may already have exited.
+		}
+		killTimer = setTimeout(() => {
+			try {
+				child.kill("SIGKILL");
+			} catch {
+				// Process may already have exited.
+			}
+		}, opts.killGraceMs);
+		killTimer.unref?.();
+		callback({ ok: false, error });
+	};
+	const pushOutput = (chunks: Buffer[], chunk: Buffer) => {
+		if (!alive) return;
+		bufferedBytes += chunk.byteLength;
+		if (bufferedBytes > opts.maxBufferBytes) {
+			fail(
+				new RangeError(
+					`nodeProcessDriver: stdout/stderr exceeded maxBufferBytes (${opts.maxBufferBytes})`,
+				),
+			);
+			return;
+		}
+		chunks.push(chunk);
+	};
+	child.stdout?.on("data", (chunk: Buffer) => {
+		pushOutput(stdoutChunks, chunk);
+	});
+	child.stderr?.on("data", (chunk: Buffer) => {
+		pushOutput(stderrChunks, chunk);
+	});
+	child.on("error", (err) => {
+		clearKillTimer();
+		if (!alive || terminal) return;
+		terminal = true;
+		alive = false;
+		callback({ ok: false, error: err });
+	});
+	child.on("exit", (code, signal) => {
+		exitInfo = { code, signal };
+	});
+	child.on("close", () => {
+		clearKillTimer();
+		if (!alive || terminal) return;
+		terminal = true;
+		alive = false;
+		const info = exitInfo ?? { code: null, signal: null };
+		callback({
+			ok: true,
+			value: {
+				stdout: Buffer.concat(stdoutChunks).toString("utf8"),
+				stderr: Buffer.concat(stderrChunks).toString("utf8"),
+				exitCode: info.code,
+				signal: info.signal,
+			},
+		});
+	});
+	return stop;
+}
+
+interface GitPollResult {
+	readonly head: string;
+	readonly files: readonly string[];
+	readonly message: string;
+	readonly author: string;
+}
+
+function stripFinalLineBreak(value: string): string {
+	return value.replace(/\r?\n$/, "");
+}
+
+function gitText(repoPath: string, args: readonly string[]): string {
+	return stripFinalLineBreak(execFileSync("git", ["-C", repoPath, ...args], { encoding: "utf8" }));
+}
+
+function gitPathList(repoPath: string, args: readonly string[]): readonly string[] {
+	const out = execFileSync("git", ["-C", repoPath, ...args, "-z"]) as Buffer;
+	const text = out.toString("utf8");
+	if (text.length === 0) return [];
+	return text.split("\0").filter((part) => part.length > 0);
+}
+
+function readGitHead(
+	repoPath: string,
+	previousHead: string | undefined,
+): GitPollResult | undefined {
+	const head = gitText(repoPath, ["rev-parse", "HEAD"]);
+	if (head.length === 0 || head === previousHead) return undefined;
+	const files =
+		previousHead === undefined
+			? []
+			: gitPathList(repoPath, ["diff", "--name-only", `${previousHead}..${head}`]);
+	return {
+		head,
+		files,
+		message: gitText(repoPath, ["log", "-1", "--format=%s", head]),
+		author: gitText(repoPath, ["log", "-1", "--format=%an", head]),
+	};
+}
+
+export function fromGitHook(
+	repoPath: string,
+	opts: FromGitHookOptions = {},
+): Operator<never, GitEvent> {
+	const { pollMs = 5000, include, exclude, maxConsecutiveErrors = 1, signal } = opts;
+	validatePositiveFinite("fromGitHook: pollMs", pollMs);
+	if (!Number.isFinite(maxConsecutiveErrors) && maxConsecutiveErrors !== Infinity) {
+		throw new RangeError("fromGitHook: maxConsecutiveErrors must be finite or Infinity");
+	}
+	if (maxConsecutiveErrors <= 0) {
+		throw new RangeError("fromGitHook: maxConsecutiveErrors must be positive");
+	}
+	const resolvedRepoPath = resolvePath(repoPath);
+	const includePatterns = (include ?? []).map(globToRegExp);
+	const excludePatterns = (exclude ?? []).map(globToRegExp);
+	const accepts = (file: string): boolean => {
+		const normalized = normalizePath(file);
+		const included = includePatterns.length === 0 || matchesAny(normalized, includePatterns);
+		return included && !matchesAny(normalized, excludePatterns);
+	};
+
+	return source<GitEvent>("fromGitHook", (ctx) => {
+		let done = false;
+		let lastSeen: string | undefined;
+		let consecutiveErrors = 0;
+		let intervalId: ReturnType<typeof setInterval> | undefined;
+		const cleanup = () => {
+			done = true;
+			if (intervalId !== undefined) clearInterval(intervalId);
+			intervalId = undefined;
+			signal?.removeEventListener("abort", onAbort);
+		};
+		const fail = (err: unknown) => {
+			if (done) return;
+			cleanup();
+			ctx.down([["ERROR", errorPayload(err)]]);
+		};
+		const onAbort = () => fail(signal?.reason);
+		const poll = () => {
+			if (done) return;
+			try {
+				const result = readGitHead(resolvedRepoPath, lastSeen);
+				consecutiveErrors = 0;
+				if (result === undefined) return;
+				const isBaseline = lastSeen === undefined;
+				lastSeen = result.head;
+				if (isBaseline) return;
+				ctx.down([
+					[
+						"DATA",
+						{
+							hook: "post-commit",
+							commit: result.head,
+							files: result.files.filter(accepts),
+							message: result.message,
+							author: result.author,
+							timestamp_ns: timestampNsNow(),
+						},
+					],
+				]);
+			} catch (err) {
+				consecutiveErrors += 1;
+				if (consecutiveErrors >= maxConsecutiveErrors) fail(err);
+			}
+		};
+		if (signal?.aborted) {
+			onAbort();
+			return cleanup;
+		}
+		signal?.addEventListener("abort", onAbort, { once: true });
+		poll();
+		if (!done) intervalId = setInterval(poll, pollMs);
+		return cleanup;
+	});
+}
diff --git a/packages/ts/src/storage/append-log.ts b/packages/ts/src/storage/append-log.ts
new file mode 100644
index 00000000..7b2c5c92
--- /dev/null
+++ b/packages/ts/src/storage/append-log.ts
@@ -0,0 +1,326 @@
+import type { KvStorageTier } from "./kv.js";
+import { memoryKv, requireKvPutIfAbsent } from "./kv.js";
+
+export const APPEND_LOG_SEQ_PAD = 20;
+
+/** One append-log record with its storage key and monotonic sequence. */
+export interface AppendLogEntry<T> {
+	readonly key: string;
+	readonly seq: number;
+	readonly value: T;
+}
+
+/** Cursor and page-size options for append-log reads. */
+export interface AppendLogReadOptions {
+	/** Return entries with seq > after. */
+	after?: number;
+	limit?: number;
+}
+
+/** One bounded append-log page with the cursor for the next read. */
+export interface AppendLogPage<T> {
+	readonly entries: readonly AppendLogEntry<T>[];
+	readonly nextAfter: number;
+	readonly done: boolean;
+}
+
+/**
+ * Append-only tier for durable event/change logs (D82), not graph restore replay.
+ *
+ * This first-cut helper serializes operations within one handle. Concurrent writers sharing the
+ * same KV prefix need an external single-writer discipline or a future CAS-capable backend.
+ */
+export interface AppendLogStorageTier<T = unknown> {
+	append(value: T): Promise<AppendLogEntry<T>>;
+	read(opts?: AppendLogReadOptions): Promise<readonly AppendLogEntry<T>[]>;
+	truncateAfter(seq: number): Promise<void>;
+	size(): Promise<number>;
+}
+
+/** D85 multi-writer append log; requires a passive conditional-create KV capability. */
+export type MultiWriterAppendLogStorageTier<T = unknown> = AppendLogStorageTier<T>;
+
+/** Build the deterministic storage key for an append-log sequence number. */
+export function appendLogKey(prefix: string, seq: number): string {
+	if (!Number.isSafeInteger(seq) || seq < 0) {
+		throw new RangeError(`appendLogKey: seq must be a non-negative safe integer, got ${seq}`);
+	}
+	return `${prefix}/${seq.toString().padStart(APPEND_LOG_SEQ_PAD, "0")}`;
+}
+
+function seqFromKey(prefix: string, key: string): number {
+	const head = `${prefix}/`;
+	if (!key.startsWith(head)) throw new Error(`append log key outside prefix: ${key}`);
+	const raw = key.slice(head.length);
+	if (!/^\d+$/.test(raw)) {
+		throw new Error(`append log key has a non-numeric sequence: ${key}`);
+	}
+	if (raw.length !== APPEND_LOG_SEQ_PAD) {
+		throw new Error(`append log key sequence must be ${APPEND_LOG_SEQ_PAD} padded digits: ${key}`);
+	}
+	const seq = Number(raw);
+	if (!Number.isSafeInteger(seq)) {
+		throw new Error(`append log key sequence is outside the safe integer range: ${key}`);
+	}
+	return seq;
+}
+
+function nextSeqFromKeys(prefix: string, keys: readonly string[]): number {
+	if (keys.length === 0) return 0;
+	const next = Math.max(...keys.map((key) => seqFromKey(prefix, key))) + 1;
+	if (!Number.isSafeInteger(next)) {
+		throw new RangeError(`append log next sequence is outside the safe integer range: ${prefix}`);
+	}
+	return next;
+}
+
+function sizeFromKeys(prefix: string, keys: readonly string[]): number {
+	for (const key of keys) seqFromKey(prefix, key);
+	return keys.length;
+}
+
+function validateReadOptions(opts: AppendLogReadOptions): {
+	after: number;
+	limit: number;
+} {
+	const after = opts.after ?? -1;
+	const limit = opts.limit ?? Number.POSITIVE_INFINITY;
+	if (!Number.isSafeInteger(after) || after < -1) {
+		throw new RangeError(
+			`appendLogStorage.read: after must be an integer cursor >= -1, got ${after}`,
+		);
+	}
+	if (limit !== Number.POSITIVE_INFINITY && (!Number.isSafeInteger(limit) || limit < 0)) {
+		throw new RangeError(
+			`appendLogStorage.read: limit must be a non-negative safe integer or Infinity, got ${limit}`,
+		);
+	}
+	return { after, limit };
+}
+
+function validatePageLimit(limit: number): number {
+	if (!Number.isSafeInteger(limit) || limit < 1) {
+		throw new RangeError(`readAppendLogPage: limit must be a positive safe integer, got ${limit}`);
+	}
+	if (limit >= Number.MAX_SAFE_INTEGER) {
+		throw new RangeError("readAppendLogPage: limit must leave room for one lookahead entry");
+	}
+	return limit;
+}
+
+function readAppendLogEntries<T>(
+	kv: KvStorageTier<T>,
+	prefix: string,
+	opts: AppendLogReadOptions,
+): Promise<readonly AppendLogEntry<T>[]> {
+	const { after, limit } = validateReadOptions(opts);
+	return kv.list(`${prefix}/`).then((listed) => {
+		const keys = listed
+			.map((key) => ({ key, seq: seqFromKey(prefix, key) }))
+			.filter(({ seq }) => seq > after)
+			.sort((a, b) => a.seq - b.seq)
+			.slice(0, limit);
+		return Promise.all(
+			keys.map(
+				({ key, seq }): Promise<AppendLogEntry<T> | undefined> =>
+					kv.get(key).then((value) => {
+						if (value === undefined) {
+							throw new Error(`append log listed key is missing: ${key}`);
+						}
+						return { key, seq, value };
+					}),
+			),
+		).then((entries) => {
+			const out: AppendLogEntry<T>[] = [];
+			for (const entry of entries) if (entry !== undefined) out.push(entry);
+			return out;
+		});
+	});
+}
+
+/** Read one ordered append-log page without assigning replay or restore semantics. */
+export function readAppendLogPage<T>(
+	log: AppendLogStorageTier<T>,
+	opts: AppendLogReadOptions = {},
+): Promise<AppendLogPage<T>> {
+	const { after, limit } = validateReadOptions({ after: opts.after, limit: opts.limit ?? 100 });
+	const pageLimit = validatePageLimit(limit);
+	return log.read({ after, limit: pageLimit + 1 }).then((entries) => {
+		const visible = entries.slice(0, pageLimit);
+		const last = visible[visible.length - 1];
+		return {
+			entries: visible,
+			nextAfter: last?.seq ?? after,
+			done: entries.length <= pageLimit,
+		};
+	});
+}
+
+function deleteAppendLogEntriesAfter<T>(
+	kv: KvStorageTier<T>,
+	prefix: string,
+	seq: number,
+): Promise<void> {
+	return kv
+		.list(`${prefix}/`)
+		.then((keys) =>
+			Promise.all(keys.filter((key) => seqFromKey(prefix, key) > seq).map((key) => kv.delete(key))),
+		)
+		.then(() => kv.list(`${prefix}/`))
+		.then(() => undefined);
+}
+
+/** Options for a typed append log over a KV tier. */
+export interface AppendLogOptions<T> {
+	kv: KvStorageTier<T>;
+	prefix?: string;
+}
+
+/** Options for D85 multi-writer append logs over conditional-create capable KV. */
+export interface MultiWriterAppendLogOptions<T> extends AppendLogOptions<T> {
+	/** Bound retry work before refreshing the listed tail after another writer wins slots. */
+	maxAttempts?: number;
+}
+
+/**
+ * Build a single-writer append-only log over a KV tier, serializing all operations in call order
+ * for this handle. D85 multi-handle concurrent appends require multiWriterAppendLogStorage.
+ */
+export function appendLogStorage<T = unknown>(opts: AppendLogOptions<T>): AppendLogStorageTier<T> {
+	const { kv, prefix = "event-log" } = opts;
+	let tail: Promise<unknown> = Promise.resolve();
+
+	function initNextSeq(): Promise<number> {
+		return kv.list(`${prefix}/`).then((keys) => {
+			return nextSeqFromKeys(prefix, keys);
+		});
+	}
+
+	function enqueue<R>(task: () => Promise<R>): Promise<R> {
+		const run = tail.then(task, task);
+		tail = run.then(
+			() => undefined,
+			() => undefined,
+		);
+		return run;
+	}
+
+	return {
+		append(value) {
+			return enqueue(() =>
+				initNextSeq().then((seq) => {
+					const key = appendLogKey(prefix, seq);
+					return kv.set(key, value).then(() => {
+						return { key, seq, value };
+					});
+				}),
+			);
+		},
+		read(opts = {}) {
+			return enqueue(() => readAppendLogEntries(kv, prefix, opts));
+		},
+		truncateAfter(seq) {
+			return enqueue(() => deleteAppendLogEntriesAfter(kv, prefix, seq));
+		},
+		size() {
+			return enqueue(() => kv.list(`${prefix}/`).then((keys) => sizeFromKeys(prefix, keys)));
+		},
+	};
+}
+
+/**
+ * Build a D85 multi-writer append log over a conditional-create capable KV tier.
+ *
+ * Sequence allocation is passive storage work: each writer proposes a padded key and retries the
+ * next key when another writer already created that slot. This does not provide general CAS,
+ * locks, leases, transactions, unsafe truncation, WAL replay, or graph restore semantics.
+ */
+export function multiWriterAppendLogStorage<T = unknown>(
+	opts: MultiWriterAppendLogOptions<T>,
+): MultiWriterAppendLogStorageTier<T> {
+	const { kv, prefix = "event-log", maxAttempts = 1024 } = opts;
+	const capableKv = requireKvPutIfAbsent(kv, "multiWriterAppendLogStorage");
+	let tail: Promise<unknown> = Promise.resolve();
+
+	if (!Number.isSafeInteger(maxAttempts) || maxAttempts < 1) {
+		throw new RangeError(
+			`multiWriterAppendLogStorage: maxAttempts must be a positive safe integer, got ${maxAttempts}`,
+		);
+	}
+
+	function initNextSeq(): Promise<number> {
+		return kv.list(`${prefix}/`).then((keys) => nextSeqFromKeys(prefix, keys));
+	}
+
+	function enqueue<R>(task: () => Promise<R>): Promise<R> {
+		const run = tail.then(task, task);
+		tail = run.then(
+			() => undefined,
+			() => undefined,
+		);
+		return run;
+	}
+
+	return {
+		append(value) {
+			return enqueue(() =>
+				initNextSeq().then((startSeq) => {
+					let seq = startSeq;
+					let attempt = 0;
+					const tryNext = (): Promise<AppendLogEntry<T>> => {
+						if (attempt >= maxAttempts) {
+							return initNextSeq().then((refreshedSeq) => {
+								seq = Math.max(seq, refreshedSeq);
+								attempt = 0;
+								return tryNext();
+							});
+						}
+						attempt += 1;
+						const key = appendLogKey(prefix, seq);
+						return capableKv.putIfAbsent(key, value).then((created) => {
+							if (created) return { key, seq, value };
+							seq += 1;
+							if (!Number.isSafeInteger(seq)) {
+								throw new RangeError(
+									`append log next sequence is outside the safe integer range: ${prefix}`,
+								);
+							}
+							return tryNext();
+						});
+					};
+					return tryNext();
+				}),
+			);
+		},
+		read(opts = {}) {
+			return enqueue(() => readAppendLogEntries(kv, prefix, opts));
+		},
+		truncateAfter(seq) {
+			return enqueue(() => {
+				if (!Number.isSafeInteger(seq) || seq < -1) {
+					throw new RangeError(
+						`multiWriterAppendLogStorage.truncateAfter: seq must be an integer cursor >= -1, got ${seq}`,
+					);
+				}
+				throw new Error(
+					"multiWriterAppendLogStorage.truncateAfter: unsupported without a stronger compaction capability",
+				);
+			});
+		},
+		size() {
+			return enqueue(() => kv.list(`${prefix}/`).then((keys) => sizeFromKeys(prefix, keys)));
+		},
+	};
+}
+
+/** Create an in-memory append log. */
+export function memoryAppendLog<T = unknown>(prefix?: string): AppendLogStorageTier<T> {
+	return appendLogStorage({ kv: memoryKv<T>(), prefix });
+}
+
+/** Create an in-memory D85 multi-writer append log. */
+export function memoryMultiWriterAppendLog<T = unknown>(
+	prefix?: string,
+): MultiWriterAppendLogStorageTier<T> {
+	return multiWriterAppendLogStorage({ kv: memoryKv<T>(), prefix });
+}
diff --git a/packages/ts/src/storage/backend.ts b/packages/ts/src/storage/backend.ts
new file mode 100644
index 00000000..1f38458b
--- /dev/null
+++ b/packages/ts/src/storage/backend.ts
@@ -0,0 +1,343 @@
+/**
+ * Byte storage backends (D82): passive adapter-owned storage, no graph methods.
+ */
+
+const HEX_TABLE = Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
+const NAMESPACE_SEPARATOR = "\u0000";
+
+function cloneBytes(bytes: Uint8Array): Uint8Array {
+	return Uint8Array.from(bytes);
+}
+
+function encodeNamespacePrefix(namespace: string): string {
+	return namespace.length > 0 ? `${namespace}${NAMESPACE_SEPARATOR}` : "";
+}
+
+function encodeBytesToHex(bytes: Uint8Array): string {
+	let out = "";
+	for (const byte of bytes) out += HEX_TABLE[byte];
+	return out;
+}
+
+function decodeHexToBytes(raw: string): Uint8Array {
+	if (raw.length % 2 !== 0 || !/^[0-9a-f]*$/i.test(raw)) {
+		throw new TypeError("webStorageBackend: malformed stored bytes");
+	}
+	const out = new Uint8Array(raw.length / 2);
+	for (let i = 0; i < raw.length; i += 2) {
+		const value = Number.parseInt(raw.slice(i, i + 2), 16);
+		if (Number.isNaN(value)) throw new TypeError("webStorageBackend: malformed stored bytes");
+		out[i / 2] = value;
+	}
+	return out;
+}
+
+function validateLogicalKey(label: string, key: string): string {
+	if (typeof key !== "string") {
+		throw new TypeError(`${label}: key must be a string`);
+	}
+	if (key.includes(NAMESPACE_SEPARATOR)) {
+		throw new TypeError(`${label}: key must not contain U+0000`);
+	}
+	return key;
+}
+
+function validateListPrefix(label: string, prefix: string): string {
+	if (typeof prefix !== "string") {
+		throw new TypeError(`${label}: list prefix must be a string`);
+	}
+	if (prefix.includes(NAMESPACE_SEPARATOR)) {
+		throw new TypeError(`${label}: list prefix must not contain U+0000`);
+	}
+	return prefix;
+}
+
+function validateNamespace(label: string, namespace: string): string {
+	if (typeof namespace !== "string") {
+		throw new TypeError(`${label}: namespace must be a string`);
+	}
+	if (namespace.includes(NAMESPACE_SEPARATOR)) {
+		throw new TypeError(`${label}: namespace must not contain U+0000`);
+	}
+	return namespace;
+}
+
+/** Passive byte-addressed backend used by D82 storage binding tiers. */
+export interface StorageBackend {
+	get(key: string): undefined | Uint8Array | PromiseLike<undefined | Uint8Array>;
+	put(key: string, value: Uint8Array): void | PromiseLike<void>;
+	putIfAbsent?(key: string, value: Uint8Array): boolean | PromiseLike<boolean>;
+	getVersioned?(key: string): StorageVersionedRead | PromiseLike<StorageVersionedRead>;
+	setIfMatch?(
+		key: string,
+		value: Uint8Array,
+		generation: StorageGeneration,
+	): boolean | PromiseLike<boolean>;
+	delete?(key: string): void | PromiseLike<void>;
+	list?(prefix?: string): readonly string[] | PromiseLike<readonly string[]>;
+}
+
+/** Passive D85 conditional-create capability for multi-writer storage helpers. */
+export interface PutIfAbsentStorageBackend extends StorageBackend {
+	putIfAbsent(key: string, value: Uint8Array): boolean | PromiseLike<boolean>;
+}
+
+/** Opaque D108 per-key generation token for passive storage versioned reads. */
+export type StorageGeneration = unknown;
+
+/** D108 versioned byte read result with explicit present/absent observations. */
+export type StorageVersionedRead =
+	| {
+			readonly kind: "hit";
+			readonly value: Uint8Array;
+			readonly generation: StorageGeneration;
+	  }
+	| {
+			readonly kind: "miss";
+			readonly generation: StorageGeneration;
+	  };
+
+/** Passive D108 versioned read + generation-conditional set capability. */
+export interface VersionedStorageBackend extends StorageBackend {
+	getVersioned(key: string): StorageVersionedRead | PromiseLike<StorageVersionedRead>;
+	setIfMatch(
+		key: string,
+		value: Uint8Array,
+		generation: StorageGeneration,
+	): boolean | PromiseLike<boolean>;
+}
+
+/** Runtime guard for D85 conditional-create capable byte backends. */
+export function hasStoragePutIfAbsent(
+	backend: StorageBackend,
+): backend is PutIfAbsentStorageBackend {
+	return typeof backend.putIfAbsent === "function";
+}
+
+/** Require D85 conditional-create support and produce a clear adapter error when absent. */
+export function requireStoragePutIfAbsent(
+	backend: StorageBackend,
+	label = "storage backend",
+): PutIfAbsentStorageBackend {
+	if (!hasStoragePutIfAbsent(backend)) {
+		throw new Error(`${label}: backend does not support putIfAbsent`);
+	}
+	return backend;
+}
+
+/** Runtime guard for D108 versioned byte backends. */
+export function hasStorageVersioned(backend: StorageBackend): backend is VersionedStorageBackend {
+	return typeof backend.getVersioned === "function" && typeof backend.setIfMatch === "function";
+}
+
+/** Require D108 versioned support and produce a clear adapter error when absent. */
+export function requireStorageVersioned(
+	backend: StorageBackend,
+	label = "storage backend",
+): VersionedStorageBackend {
+	if (!hasStorageVersioned(backend)) {
+		throw new Error(`${label}: backend does not support versioned get/set-if-match`);
+	}
+	return backend;
+}
+
+/** Browser/storage-adapter shape for deterministic byte helpers (DOM-free for portability). */
+export interface WebStorageLike {
+	readonly length?: number;
+	getItem(key: string): string | null | undefined;
+	setItem(key: string, value: string): void;
+	removeItem(key: string): void;
+	key?(index: number): string | null | undefined;
+	keys?(): readonly string[];
+}
+
+/** Storage helper options for namespace isolation and logical-key prefixing. */
+export interface StorageNamespaceOptions {
+	/**
+	 * Optional namespace for logical keys.
+	 *
+	 * Namespace is part of key mapping only and is not returned from `list()`.
+	 */
+	namespace?: string;
+}
+
+function toStorageKey(namespace: string, key: string): string {
+	return `${encodeNamespacePrefix(namespace)}${key}`;
+}
+
+function enumerateStorageKeys(storage: WebStorageLike): readonly unknown[] {
+	if (storage.keys) return [...storage.keys()];
+	if (typeof storage.key === "function" && typeof storage.length === "number") {
+		const keys: string[] = [];
+		for (let i = 0; i < storage.length; i += 1) {
+			const key = storage.key(i);
+			if (key !== null && key !== undefined) keys.push(key);
+		}
+		return keys;
+	}
+	const fallback = storage as unknown as Readonly<Record<string, unknown>>;
+	return Object.keys(fallback).filter((key) => typeof fallback[key] === "string");
+}
+
+function decodeStorageListKey(namespace: string, rawKey: unknown): string | undefined {
+	if (typeof rawKey !== "string") {
+		throw new TypeError("webStorageBackend: stored key must be a string");
+	}
+	const prefix = encodeNamespacePrefix(namespace);
+	if (!rawKey.startsWith(prefix)) return undefined;
+	const logical = rawKey.slice(prefix.length);
+	if (logical.includes(NAMESPACE_SEPARATOR)) {
+		throw new TypeError("webStorageBackend: malformed stored key");
+	}
+	return logical;
+}
+
+function listByPrefix(namespace: string, prefix: string, raw: readonly unknown[]): string[] {
+	const out: string[] = [];
+	for (const key of raw) {
+		const logical = decodeStorageListKey(namespace, key);
+		if (logical === undefined) continue;
+		if (!logical.startsWith(prefix)) continue;
+		out.push(logical);
+	}
+	out.sort();
+	return out;
+}
+
+/** Build a deterministic byte backend backed by a browser-like key/value store (D103/D82). */
+export function webStorageBackend(
+	storage: WebStorageLike,
+	opts: StorageNamespaceOptions = {},
+): StorageBackend {
+	const namespace =
+		opts.namespace === undefined ? "" : validateNamespace("webStorageBackend", opts.namespace);
+	return {
+		get(key) {
+			const raw = storage.getItem(
+				toStorageKey(namespace, validateLogicalKey("webStorageBackend", key)),
+			);
+			if (raw === null || raw === undefined) return undefined;
+			return decodeHexToBytes(raw);
+		},
+		put(key, value) {
+			storage.setItem(
+				toStorageKey(namespace, validateLogicalKey("webStorageBackend", key)),
+				encodeBytesToHex(cloneBytes(value)),
+			);
+		},
+		delete(key) {
+			storage.removeItem(toStorageKey(namespace, validateLogicalKey("webStorageBackend", key)));
+		},
+		list(prefix = "") {
+			return listByPrefix(
+				namespace,
+				validateListPrefix("webStorageBackend", prefix),
+				enumerateStorageKeys(storage),
+			);
+		},
+	};
+}
+
+/** In-memory backend for tests, adapters, and lightweight local storage. */
+export interface MemoryBackend extends StorageBackend {
+	readonly entries: ReadonlyMap<string, Uint8Array>;
+	clear(): void;
+}
+
+const MEMORY_GENERATION = Symbol("graphrefly.memoryBackend.generation");
+
+interface MemoryGeneration {
+	readonly [MEMORY_GENERATION]: readonly [epoch: number, key: string, version: number];
+}
+
+function memoryGeneration(epoch: number, key: string, version: number): MemoryGeneration {
+	return Object.freeze({ [MEMORY_GENERATION]: Object.freeze([epoch, key, version] as const) });
+}
+
+function readMemoryGeneration(
+	generation: StorageGeneration,
+): readonly [epoch: number, key: string, version: number] | undefined {
+	if (typeof generation !== "object" || generation === null) return undefined;
+	const maybe = generation as Partial<MemoryGeneration>;
+	const token = maybe[MEMORY_GENERATION];
+	if (
+		Array.isArray(token) &&
+		token.length === 3 &&
+		typeof token[0] === "number" &&
+		typeof token[1] === "string" &&
+		typeof token[2] === "number"
+	) {
+		return token as readonly [number, string, number];
+	}
+	return undefined;
+}
+
+/** Create a byte-cloning in-memory backend. */
+export function memoryBackend(
+	initial: Iterable<readonly [string, Uint8Array]> = [],
+): MemoryBackend {
+	const entries = new Map<string, Uint8Array>();
+	const versions = new Map<string, number>();
+	let epoch = 0;
+	for (const [key, value] of initial) {
+		entries.set(validateLogicalKey("memoryBackend", key), cloneBytes(value));
+	}
+	const versionOf = (key: string): number => versions.get(key) ?? 0;
+	const bump = (key: string): void => {
+		versions.set(key, versionOf(key) + 1);
+	};
+	return {
+		entries,
+		get(key) {
+			const value = entries.get(validateLogicalKey("memoryBackend", key));
+			return value === undefined ? undefined : cloneBytes(value);
+		},
+		put(key, value) {
+			validateLogicalKey("memoryBackend", key);
+			entries.set(key, cloneBytes(value));
+			bump(key);
+		},
+		putIfAbsent(key, value) {
+			validateLogicalKey("memoryBackend", key);
+			if (entries.has(key)) return false;
+			entries.set(key, cloneBytes(value));
+			bump(key);
+			return true;
+		},
+		getVersioned(key) {
+			validateLogicalKey("memoryBackend", key);
+			const value = entries.get(key);
+			const generation = memoryGeneration(epoch, key, versionOf(key));
+			if (value === undefined) return { kind: "miss", generation };
+			return { kind: "hit", value: cloneBytes(value), generation };
+		},
+		setIfMatch(key, value, generation) {
+			validateLogicalKey("memoryBackend", key);
+			const observed = readMemoryGeneration(generation);
+			if (
+				observed === undefined ||
+				observed[0] !== epoch ||
+				observed[1] !== key ||
+				observed[2] !== versionOf(key)
+			) {
+				return false;
+			}
+			entries.set(key, cloneBytes(value));
+			bump(key);
+			return true;
+		},
+		delete(key) {
+			validateLogicalKey("memoryBackend", key);
+			if (entries.delete(key)) bump(key);
+		},
+		list(prefix = "") {
+			const validatedPrefix = validateListPrefix("memoryBackend", prefix);
+			return [...entries.keys()].filter((key) => key.startsWith(validatedPrefix)).sort();
+		},
+		clear() {
+			entries.clear();
+			versions.clear();
+			epoch += 1;
+		},
+	};
+}
diff --git a/packages/ts/src/storage/browser.ts b/packages/ts/src/storage/browser.ts
new file mode 100644
index 00000000..6191c996
--- /dev/null
+++ b/packages/ts/src/storage/browser.ts
@@ -0,0 +1,341 @@
+/**
+ * Browser-only passive storage backend (D103).
+ *
+ * Uses DOM IndexedDB to provide async byte storage, no graph methods.
+ */
+
+/// <reference lib="dom" />
+
+import { type AppendLogStorageTier, appendLogStorage } from "./append-log.js";
+import type { StorageBackend } from "./backend.js";
+import type { Codec } from "./codec.js";
+import { type KvStorageOptions, type KvStorageTier, kvStorage } from "./kv.js";
+
+export type IndexedDbBackendSpec = {
+	dbName: string;
+	storeName: string;
+	version?: number;
+};
+
+export interface NamedIndexedDbBackend extends StorageBackend {
+	readonly name: string;
+}
+
+type IndexedDbError = DOMException | Error;
+
+const KEY_SEPARATOR = "\u0000";
+
+function isConstraintError(error: unknown): error is DOMException {
+	return error instanceof DOMException && error.name === "ConstraintError";
+}
+
+function validateKey(key: string): string {
+	if (typeof key !== "string") {
+		throw new TypeError("indexedDbBackend: key must be a string");
+	}
+	if (key.includes(KEY_SEPARATOR)) {
+		throw new TypeError("indexedDbBackend: key must not contain U+0000");
+	}
+	return key;
+}
+
+function validateListPrefix(prefix: string): string {
+	if (typeof prefix !== "string") {
+		throw new TypeError("indexedDbBackend: list prefix must be a string");
+	}
+	if (prefix.includes(KEY_SEPARATOR)) {
+		throw new TypeError("indexedDbBackend: list prefix must not contain U+0000");
+	}
+	return prefix;
+}
+
+function decodeStoredBytes(raw: unknown): Uint8Array | undefined {
+	if (raw === undefined || raw === null) return undefined;
+	if (raw instanceof Uint8Array) return Uint8Array.from(raw);
+	if (raw instanceof ArrayBuffer) return new Uint8Array(raw.slice(0));
+	throw new TypeError("indexedDbBackend: malformed stored bytes");
+}
+
+function normalizeKeys(prefix: string, raw: unknown[]): string[] {
+	const out: string[] = [];
+	for (const key of raw) {
+		if (typeof key !== "string") {
+			throw new TypeError("indexedDbBackend: stored key must be a string");
+		}
+		if (key.includes(KEY_SEPARATOR)) {
+			throw new TypeError("indexedDbBackend: malformed stored key");
+		}
+		if (key.startsWith(prefix)) out.push(key);
+	}
+	out.sort();
+	return out;
+}
+
+function openDb(spec: IndexedDbBackendSpec, version = spec.version): Promise<IDBDatabase> {
+	return new Promise<IDBDatabase>((resolve, reject) => {
+		if (typeof indexedDB === "undefined") {
+			reject(new TypeError("indexedDbBackend: indexedDB is not available in this environment"));
+			return;
+		}
+		const req =
+			version === undefined ? indexedDB.open(spec.dbName) : indexedDB.open(spec.dbName, version);
+		req.onupgradeneeded = () => {
+			const db = req.result;
+			if (!db.objectStoreNames.contains(spec.storeName)) {
+				db.createObjectStore(spec.storeName);
+			}
+		};
+		req.onblocked = () =>
+			reject(
+				new Error("indexedDbBackend: open blocked; close existing database connections and retry"),
+			);
+		req.onsuccess = () => resolve(req.result);
+		req.onerror = () => reject(req.error ?? new TypeError("indexedDbBackend: open failed"));
+	});
+}
+
+function openDbWithStore(spec: IndexedDbBackendSpec): Promise<IDBDatabase> {
+	return openDb(spec).then((db) => {
+		if (db.objectStoreNames.contains(spec.storeName)) return db;
+		if (spec.version !== undefined) {
+			db.close();
+			throw new Error(
+				`indexedDbBackend: object store "${spec.storeName}" is missing; bump the IndexedDB version to create it`,
+			);
+		}
+		const nextVersion = db.version + 1;
+		db.close();
+		return openDb(spec, nextVersion).then((upgraded) => {
+			if (upgraded.objectStoreNames.contains(spec.storeName)) return upgraded;
+			upgraded.close();
+			throw new Error(`indexedDbBackend: object store "${spec.storeName}" was not created`);
+		});
+	});
+}
+
+export type IndexedDbKvOptions<T> = Omit<KvStorageOptions<T>, "backend">;
+
+export interface IndexedDbAppendLogOptions<T> {
+	/** Optional append-log key prefix. */
+	prefix?: string;
+	/** Optional payload codec before persistence. */
+	codec?: Codec<T>;
+}
+
+/**
+ * Creates an IndexedDB backend for browser environments.
+ *
+ * All methods are async (`Promise`) and do not cross graph layer boundaries.
+ */
+export function indexedDbBackend(spec: IndexedDbBackendSpec): NamedIndexedDbBackend {
+	let dbCache: Promise<IDBDatabase> | undefined;
+	const db = (): Promise<IDBDatabase> => {
+		if (dbCache !== undefined) return dbCache;
+		const attempt = openDbWithStore(spec);
+		const cached = attempt.catch((error) => {
+			if (dbCache === cached) dbCache = undefined;
+			throw error;
+		});
+		dbCache = cached;
+		return dbCache;
+	};
+	return {
+		name: `idb:${spec.dbName}/${spec.storeName}`,
+		get(key) {
+			validateKey(key);
+			return db().then(
+				(database) =>
+					new Promise<Uint8Array | undefined>((resolve, reject) => {
+						try {
+							const tx = database.transaction(spec.storeName, "readonly");
+							const store = tx.objectStore(spec.storeName);
+							const req = store.get(key);
+							req.onsuccess = () => {
+								try {
+									resolve(decodeStoredBytes(req.result));
+								} catch (error) {
+									reject(error as IndexedDbError);
+								}
+							};
+							req.onerror = () => reject(req.error ?? new Error("indexedDbBackend: read failed"));
+							tx.onabort = () =>
+								reject(tx.error ?? new Error("indexedDbBackend: read transaction aborted"));
+							tx.oncomplete = () => {
+								/* read resolved already; no-op */
+							};
+						} catch (error) {
+							reject(error as IndexedDbError);
+						}
+					}),
+			);
+		},
+		put(key, value) {
+			validateKey(key);
+			return db().then(
+				(database) =>
+					new Promise<void>((resolve, reject) => {
+						try {
+							const tx = database.transaction(spec.storeName, "readwrite");
+							const store = tx.objectStore(spec.storeName);
+							const req = store.put(value, key);
+							req.onerror = () => reject(req.error ?? new Error("indexedDbBackend: write failed"));
+							tx.oncomplete = () => resolve();
+							tx.onabort = () =>
+								reject(tx.error ?? new Error("indexedDbBackend: write transaction aborted"));
+							tx.onerror = () =>
+								reject(tx.error ?? new Error("indexedDbBackend: write transaction failed"));
+						} catch (error) {
+							reject(error as IndexedDbError);
+						}
+					}),
+			);
+		},
+		putIfAbsent(key, value) {
+			validateKey(key);
+			return db().then(
+				(database) =>
+					new Promise<boolean>((resolve, reject) => {
+						let requestOk = false;
+						let requestConflict = false;
+						let requestError: unknown;
+						let settled = false;
+						const settle = (fn: () => void): void => {
+							if (settled) return;
+							settled = true;
+							fn();
+						};
+						try {
+							const tx = database.transaction(spec.storeName, "readwrite");
+							const store = tx.objectStore(spec.storeName);
+							const req = store.add(value, key);
+							req.onsuccess = () => {
+								requestOk = true;
+							};
+							req.onerror = (event) => {
+								const error = req.error;
+								if (isConstraintError(error)) {
+									requestConflict = true;
+									event.preventDefault();
+									return;
+								}
+								requestError = error ?? new Error("indexedDbBackend: write-if-absent failed");
+							};
+							tx.oncomplete = () =>
+								settle(() => {
+									if (requestConflict) {
+										resolve(false);
+									} else if (requestOk) {
+										resolve(true);
+									} else {
+										reject(
+											requestError ??
+												new Error("indexedDbBackend: write-if-absent did not complete"),
+										);
+									}
+								});
+							tx.onabort = () => {
+								const error = tx.error;
+								if (isConstraintError(error)) {
+									settle(() => resolve(false));
+									return;
+								}
+								settle(() =>
+									reject(
+										requestError ??
+											tx.error ??
+											new Error("indexedDbBackend: write-if-absent transaction aborted"),
+									),
+								);
+							};
+							tx.onerror = () => {
+								const error = tx.error;
+								if (isConstraintError(error)) {
+									settle(() => resolve(false));
+									return;
+								}
+								settle(() =>
+									reject(
+										requestError ??
+											error ??
+											new Error("indexedDbBackend: write-if-absent transaction failed"),
+									),
+								);
+							};
+						} catch (error) {
+							settle(() => reject(error as IndexedDbError));
+						}
+					}),
+			);
+		},
+		delete(key) {
+			validateKey(key);
+			return db().then(
+				(database) =>
+					new Promise<void>((resolve, reject) => {
+						try {
+							const tx = database.transaction(spec.storeName, "readwrite");
+							const store = tx.objectStore(spec.storeName);
+							const req = store.delete(key);
+							req.onerror = () => reject(req.error ?? new Error("indexedDbBackend: delete failed"));
+							tx.oncomplete = () => resolve();
+							tx.onabort = () =>
+								reject(tx.error ?? new Error("indexedDbBackend: delete transaction aborted"));
+							tx.onerror = () =>
+								reject(tx.error ?? new Error("indexedDbBackend: delete transaction failed"));
+						} catch (error) {
+							reject(error as IndexedDbError);
+						}
+					}),
+			);
+		},
+		list(prefix = "") {
+			const validatedPrefix = validateListPrefix(prefix);
+			return db().then(
+				(database) =>
+					new Promise<readonly string[]>((resolve, reject) => {
+						try {
+							const tx = database.transaction(spec.storeName, "readonly");
+							const store = tx.objectStore(spec.storeName);
+							const req = store.getAllKeys();
+							req.onsuccess = () => {
+								try {
+									resolve(normalizeKeys(validatedPrefix, req.result));
+								} catch (error) {
+									reject(error as IndexedDbError);
+								}
+							};
+							req.onerror = () => reject(req.error ?? new Error("indexedDbBackend: list failed"));
+							tx.onabort = () =>
+								reject(tx.error ?? new Error("indexedDbBackend: list transaction aborted"));
+						} catch (error) {
+							reject(error as IndexedDbError);
+						}
+					}),
+			);
+		},
+	};
+}
+
+/**
+ * Creates an IndexedDB-backed KV storage tier.
+ */
+export function indexedDbKv<T>(
+	spec: IndexedDbBackendSpec,
+	opts: IndexedDbKvOptions<T> = {},
+): KvStorageTier<T> {
+	return kvStorage<T>({ backend: indexedDbBackend(spec), ...opts });
+}
+
+/**
+ * Creates an IndexedDB-backed append-log storage tier.
+ */
+export function indexedDbAppendLog<T>(
+	spec: IndexedDbBackendSpec,
+	opts: IndexedDbAppendLogOptions<T> = {},
+): AppendLogStorageTier<T> {
+	const kv = kvStorage<T>({
+		backend: indexedDbBackend(spec),
+		codec: opts.codec,
+	});
+	return appendLogStorage<T>({ kv, prefix: opts.prefix ?? "append-log" });
+}
diff --git a/packages/ts/src/storage/change.ts b/packages/ts/src/storage/change.ts
new file mode 100644
index 00000000..48975480
--- /dev/null
+++ b/packages/ts/src/storage/change.ts
@@ -0,0 +1,102 @@
+/**
+ * Storage change envelopes (D82): persistence framing for raw graph/data-structure deltas.
+ */
+
+import type { Codec } from "./codec.js";
+import { strictJsonCodecFor } from "./codec.js";
+import {
+	assertNonNegativeDecimalIntegerString,
+	bigIntToNonNegativeDecimalString,
+	type NonNegativeDecimalIntegerString,
+} from "./scalar.js";
+
+/** Storage-side lifecycle namespace for change envelopes; presentation framing only. */
+export type ChangeLifecycle = "spec" | "data" | "ownership";
+
+/** D84 cross-runtime wall-clock nanosecond metadata: canonical non-negative decimal string. */
+export type StorageTimestampNs = NonNegativeDecimalIntegerString;
+
+/** Persistence envelope for raw graph/data-structure deltas (D82), not restore semantics. */
+export interface ChangeEnvelope<T = unknown> {
+	readonly lifecycle: ChangeLifecycle;
+	readonly structure: string;
+	readonly version: number | string;
+	readonly t_ns: StorageTimestampNs;
+	readonly seq?: number;
+	readonly change: T;
+}
+
+/** Options for wrapping a raw change in a storage envelope. */
+export interface ChangeEnvelopeOptions {
+	lifecycle?: ChangeLifecycle;
+	structure: string;
+	version?: number | string;
+	t_ns?: StorageTimestampNs;
+	seq?: number;
+}
+
+/** Wall-clock nanoseconds for storage metadata. */
+export function nowNs(): StorageTimestampNs {
+	return bigIntToNonNegativeDecimalString(BigInt(Date.now()) * 1_000_000n);
+}
+
+/** Wrap a raw change payload in a D82 storage envelope. */
+export function envelopeChange<T>(change: T, opts: ChangeEnvelopeOptions): ChangeEnvelope<T> {
+	const envelope = {
+		lifecycle: opts.lifecycle ?? "data",
+		structure: opts.structure,
+		version: opts.version ?? 1,
+		t_ns: opts.t_ns ?? nowNs(),
+		...(opts.seq === undefined ? {} : { seq: opts.seq }),
+		change,
+	};
+	return assertChangeEnvelope<T>(envelope);
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+function isLifecycle(value: unknown): value is ChangeLifecycle {
+	return value === "spec" || value === "data" || value === "ownership";
+}
+
+/** Validate a decoded D82 change envelope and return it with typed payload. */
+export function assertChangeEnvelope<T = unknown>(value: unknown): ChangeEnvelope<T> {
+	if (!isRecord(value)) throw new TypeError("changeEnvelopeCodec: frame must be an object");
+	if (!isLifecycle(value.lifecycle)) {
+		throw new TypeError("changeEnvelopeCodec: lifecycle must be spec, data, or ownership");
+	}
+	if (typeof value.structure !== "string" || value.structure.length === 0) {
+		throw new TypeError("changeEnvelopeCodec: structure must be a non-empty string");
+	}
+	if (
+		(typeof value.version !== "number" || !Number.isFinite(value.version)) &&
+		typeof value.version !== "string"
+	) {
+		throw new TypeError("changeEnvelopeCodec: version must be a finite number or string");
+	}
+	assertNonNegativeDecimalIntegerString(value.t_ns, "changeEnvelopeCodec: t_ns");
+	if (value.seq !== undefined && (!Number.isSafeInteger(value.seq) || (value.seq as number) < 0)) {
+		throw new TypeError(
+			"changeEnvelopeCodec: seq must be a non-negative safe integer when present",
+		);
+	}
+	if (!Object.hasOwn(value, "change")) {
+		throw new TypeError("changeEnvelopeCodec: change payload is required");
+	}
+	return value as unknown as ChangeEnvelope<T>;
+}
+
+/** Stable JSON codec for D82 change envelopes, with strict framing checks. */
+export function changeEnvelopeCodec<T = unknown>(): Codec<ChangeEnvelope<T>> {
+	const codec = strictJsonCodecFor<unknown>();
+	return {
+		encode(value) {
+			return codec.encode(assertChangeEnvelope(value));
+		},
+		decode(bytes) {
+			return assertChangeEnvelope<T>(codec.decode(bytes));
+		},
+	};
+}
diff --git a/packages/ts/src/storage/codec.ts b/packages/ts/src/storage/codec.ts
new file mode 100644
index 00000000..05b7db2f
--- /dev/null
+++ b/packages/ts/src/storage/codec.ts
@@ -0,0 +1,20 @@
+/**
+ * Storage codec re-exports.
+ *
+ * D96 moves stable/strict JSON to the neutral json module; storage keeps these public
+ * names stable for existing D82 binding consumers.
+ */
+
+export {
+	assertStrictJsonObject,
+	assertStrictJsonValue,
+	type Codec,
+	jsonCodec,
+	jsonCodecFor,
+	type StrictJsonObject,
+	type StrictJsonScalar,
+	type StrictJsonValue,
+	stableJsonString,
+	strictJsonCodec,
+	strictJsonCodecFor,
+} from "../json/codec.js";
diff --git a/packages/ts/src/storage/content-addressed.ts b/packages/ts/src/storage/content-addressed.ts
new file mode 100644
index 00000000..eb4fccf0
--- /dev/null
+++ b/packages/ts/src/storage/content-addressed.ts
@@ -0,0 +1,109 @@
+import { strictCanonicalJsonBytes } from "../json/codec.js";
+import type { KvStorageTier } from "./kv.js";
+
+/** Content-addressed KV access mode for D82 passive storage helpers. */
+export type ContentAddressedMode = "read" | "write" | "read-write" | "read-strict";
+
+/** Error thrown when a read-strict content-addressed lookup misses. */
+export class ContentAddressedMissError extends Error {
+	readonly key: string;
+	readonly context: unknown;
+
+	constructor(key: string, context: unknown) {
+		super(`content-addressed lookup miss in read-strict mode: ${key}`);
+		this.name = "ContentAddressedMissError";
+		this.key = key;
+		this.context = context;
+	}
+}
+
+/** Options for {@link contentAddressedKv}. */
+export interface ContentAddressedKvOptions<Ctx, V> {
+	/** Underlying D82 KV tier. */
+	kv: KvStorageTier<V>;
+	/** Select the JSON-encodable data that participates in the content key. */
+	keyContext?: (ctx: Ctx) => unknown;
+	/** Optional namespace prefix for sharing one KV tier across consumers. */
+	keyPrefix?: string;
+	/** Access mode. Defaults to read-write. */
+	mode?: ContentAddressedMode;
+}
+
+/** Content-addressed helper handle over a D82 KV tier. */
+export interface ContentAddressedKv<Ctx, V> {
+	keyFor(ctx: Ctx): Promise<string>;
+	lookup(ctx: Ctx): Promise<V | undefined>;
+	store(ctx: Ctx, value: V): Promise<void>;
+	forget(ctx: Ctx): Promise<void>;
+}
+
+export type ContentAddressedStorageOptions<Ctx, V> = ContentAddressedKvOptions<Ctx, V>;
+export type ContentAddressedStorage<Ctx, V> = ContentAddressedKv<Ctx, V>;
+
+const SHA_256 = "SHA-256";
+const HEX_TABLE = Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
+
+function bytesToHex(bytes: Uint8Array): string {
+	let out = "";
+	for (const byte of bytes) out += HEX_TABLE[byte];
+	return out;
+}
+
+function sha256Hex(data: Uint8Array): Promise<string> {
+	const digestInput = Uint8Array.from(data);
+	return globalThis.crypto.subtle
+		.digest(SHA_256, digestInput)
+		.then((buf) => bytesToHex(new Uint8Array(buf)));
+}
+
+/** Build a content-addressed helper over a D82 KV tier. */
+export function contentAddressedKv<Ctx, V>(
+	opts: ContentAddressedKvOptions<Ctx, V>,
+): ContentAddressedKv<Ctx, V> {
+	const { kv, keyContext, keyPrefix, mode = "read-write" } = opts;
+	const contextForKey = keyContext ?? ((ctx: Ctx) => ctx as unknown);
+
+	function keyFor(ctx: Ctx): Promise<string> {
+		let bytes: Uint8Array;
+		try {
+			bytes = strictCanonicalJsonBytes(contextForKey(ctx));
+		} catch (err) {
+			return Promise.resolve().then(() => {
+				throw err;
+			});
+		}
+		return Promise.resolve()
+			.then(() => sha256Hex(bytes))
+			.then((hex) => (keyPrefix ? `${keyPrefix}:${hex}` : hex));
+	}
+
+	return {
+		keyFor,
+		lookup(ctx) {
+			if (mode === "write") return Promise.resolve(undefined);
+			return keyFor(ctx).then((key) =>
+				kv.get(key).then((value) => {
+					if (value === undefined && mode === "read-strict") {
+						throw new ContentAddressedMissError(key, ctx);
+					}
+					return value;
+				}),
+			);
+		},
+		store(ctx, value) {
+			if (mode === "read") return Promise.resolve();
+			return keyFor(ctx).then((key) => kv.set(key, value));
+		},
+		forget(ctx) {
+			if (mode === "read" || mode === "write") return Promise.resolve();
+			return keyFor(ctx).then((key) => kv.delete(key));
+		},
+	};
+}
+
+/** Alias for consumers that name the same D82 helper by storage role rather than KV tier. */
+export function contentAddressedStorage<Ctx, V>(
+	opts: ContentAddressedStorageOptions<Ctx, V>,
+): ContentAddressedStorage<Ctx, V> {
+	return contentAddressedKv(opts);
+}
diff --git a/packages/ts/src/storage/index.ts b/packages/ts/src/storage/index.ts
new file mode 100644
index 00000000..7a27ba92
--- /dev/null
+++ b/packages/ts/src/storage/index.ts
@@ -0,0 +1,152 @@
+export {
+	APPEND_LOG_SEQ_PAD,
+	type AppendLogEntry,
+	type AppendLogPage,
+	type AppendLogReadOptions,
+	type AppendLogStorageTier,
+	appendLogKey,
+	appendLogStorage,
+	type MultiWriterAppendLogOptions,
+	type MultiWriterAppendLogStorageTier,
+	memoryAppendLog,
+	memoryMultiWriterAppendLog,
+	multiWriterAppendLogStorage,
+	readAppendLogPage,
+} from "./append-log.js";
+export {
+	hasStoragePutIfAbsent,
+	hasStorageVersioned,
+	type MemoryBackend,
+	memoryBackend,
+	type PutIfAbsentStorageBackend,
+	requireStoragePutIfAbsent,
+	requireStorageVersioned,
+	type StorageBackend,
+	type StorageGeneration,
+	type StorageNamespaceOptions,
+	type StorageVersionedRead,
+	type VersionedStorageBackend,
+	type WebStorageLike,
+	webStorageBackend,
+} from "./backend.js";
+export {
+	assertChangeEnvelope,
+	type ChangeEnvelope,
+	type ChangeEnvelopeOptions,
+	type ChangeLifecycle,
+	changeEnvelopeCodec,
+	envelopeChange,
+	nowNs,
+	type StorageTimestampNs,
+} from "./change.js";
+export {
+	assertStrictJsonObject,
+	assertStrictJsonValue,
+	type Codec,
+	jsonCodec,
+	jsonCodecFor,
+	type StrictJsonObject,
+	type StrictJsonScalar,
+	type StrictJsonValue,
+	stableJsonString,
+	strictJsonCodec,
+	strictJsonCodecFor,
+} from "./codec.js";
+export {
+	type ContentAddressedKv,
+	type ContentAddressedKvOptions,
+	ContentAddressedMissError,
+	type ContentAddressedMode,
+	type ContentAddressedStorage,
+	type ContentAddressedStorageOptions,
+	contentAddressedKv,
+	contentAddressedStorage,
+} from "./content-addressed.js";
+export {
+	dictKv,
+	hasKvPutIfAbsent,
+	hasKvVersioned,
+	type KvGeneration,
+	type KvStorageOptions,
+	type KvStorageTier,
+	type KvVersionedRead,
+	kvStorage,
+	listByPrefix,
+	memoryKv,
+	type PutIfAbsentKvStorageTier,
+	requireKvPutIfAbsent,
+	requireKvVersioned,
+	type VersionedKvStorageTier,
+} from "./kv.js";
+export {
+	assertObserveEventFrame,
+	type ObserveEventFrame,
+	type ObserveEventLogPage,
+	observeEventFrame,
+	observeEventFrameCodec,
+	readObserveEventLogPage,
+} from "./observe-event-log.js";
+export {
+	assertReactiveCollectionChangeFrame,
+	assertReactiveCollectionSnapshotFrame,
+	collectionSnapshotKey,
+	type LoadReactiveCollectionStateOptions,
+	loadReactiveIndexState,
+	loadReactiveListState,
+	loadReactiveLogState,
+	loadReactiveMapState,
+	REACTIVE_COLLECTION_CHANGE_FORMAT,
+	REACTIVE_COLLECTION_FRAME_VERSION,
+	REACTIVE_COLLECTION_SNAPSHOT_FORMAT,
+	type ReactiveCollectionChangeFrame,
+	type ReactiveCollectionRestoreState,
+	type ReactiveCollectionSnapshotFrame,
+	type ReactiveCollectionStorageKind,
+	type ReactiveIndexRestoreState,
+	type ReactiveListRestoreState,
+	type ReactiveLogRestoreState,
+	type ReactiveMapRestoreState,
+	reactiveCollectionChangeFrame,
+	reactiveCollectionChangeFrameCodec,
+	reactiveCollectionSnapshotFrame,
+	reactiveCollectionSnapshotFrameCodec,
+} from "./reactive-collection.js";
+export {
+	type ReadThroughErrorContext,
+	type ReadThroughLookupFact,
+	type ReadThroughLookupTier,
+	type ReadThroughMissContext,
+	type ReadThroughPromotionFact,
+	readThroughKv,
+	type TieredReadThroughOptions,
+	type TieredReadThroughResult,
+	tieredReadThrough,
+} from "./read-through.js";
+export {
+	assertDecimalIntegerString,
+	assertNonNegativeDecimalIntegerString,
+	bigIntToDecimalString,
+	bigIntToNonNegativeDecimalString,
+	type DecimalIntegerString,
+	decimalStringToBigInt,
+	isDecimalIntegerString,
+	isNonNegativeDecimalIntegerString,
+	type NonNegativeDecimalIntegerString,
+	nonNegativeDecimalStringToBigInt,
+} from "./scalar.js";
+export {
+	assertWalFrame,
+	verifyWalFrameChecksum,
+	WAL_FORMAT_VERSION,
+	WAL_FRAME_SEQ_PAD,
+	WAL_KEY_SEGMENT,
+	type WalFrame,
+	type WalFrameBody,
+	type WalFrameOptions,
+	type WalFrameTimestampNs,
+	walFrame,
+	walFrameChecksum,
+	walFrameCodec,
+	walFrameKey,
+	walFramePrefix,
+} from "./wal.js";
diff --git a/packages/ts/src/storage/kv.ts b/packages/ts/src/storage/kv.ts
new file mode 100644
index 00000000..685878aa
--- /dev/null
+++ b/packages/ts/src/storage/kv.ts
@@ -0,0 +1,164 @@
+import {
+	hasStoragePutIfAbsent,
+	hasStorageVersioned,
+	memoryBackend,
+	type StorageBackend,
+	type StorageGeneration,
+} from "./backend.js";
+import type { Codec } from "./codec.js";
+import { jsonCodecFor } from "./codec.js";
+
+/** Codec-backed key/value tier over a passive byte backend (D82). */
+export interface KvStorageTier<T = unknown> {
+	get(key: string): Promise<T | undefined>;
+	set(key: string, value: T): Promise<void>;
+	putIfAbsent?(key: string, value: T): Promise<boolean>;
+	getVersioned?(key: string): Promise<KvVersionedRead<T>>;
+	setIfMatch?(key: string, value: T, generation: StorageGeneration): Promise<boolean>;
+	delete(key: string): Promise<void>;
+	list(prefix?: string): Promise<readonly string[]>;
+}
+
+/** Typed D85 conditional-create capability over a KV tier. */
+export interface PutIfAbsentKvStorageTier<T = unknown> extends KvStorageTier<T> {
+	putIfAbsent(key: string, value: T): Promise<boolean>;
+}
+
+/** Opaque D108 per-key generation token for typed KV versioned reads. */
+export type KvGeneration = StorageGeneration;
+
+/** D108 versioned typed read result with explicit present/absent observations. */
+export type KvVersionedRead<T> =
+	| {
+			readonly kind: "hit";
+			readonly value: T;
+			readonly generation: KvGeneration;
+	  }
+	| {
+			readonly kind: "miss";
+			readonly generation: KvGeneration;
+	  };
+
+/** Typed D108 versioned read + generation-conditional set capability over a KV tier. */
+export interface VersionedKvStorageTier<T = unknown> extends KvStorageTier<T> {
+	getVersioned(key: string): Promise<KvVersionedRead<T>>;
+	setIfMatch(key: string, value: T, generation: KvGeneration): Promise<boolean>;
+}
+
+/** Runtime guard for typed KV tiers that expose D85 conditional create. */
+export function hasKvPutIfAbsent<T>(tier: KvStorageTier<T>): tier is PutIfAbsentKvStorageTier<T> {
+	return typeof tier.putIfAbsent === "function";
+}
+
+/** Require D85 conditional-create support and produce a clear adapter error when absent. */
+export function requireKvPutIfAbsent<T>(
+	tier: KvStorageTier<T>,
+	label = "kvStorage",
+): PutIfAbsentKvStorageTier<T> {
+	if (!hasKvPutIfAbsent(tier)) {
+		throw new Error(`${label}: KV tier does not support putIfAbsent`);
+	}
+	return tier;
+}
+
+/** Runtime guard for typed KV tiers that expose D108 versioned read/set-if-match. */
+export function hasKvVersioned<T>(tier: KvStorageTier<T>): tier is VersionedKvStorageTier<T> {
+	return typeof tier.getVersioned === "function" && typeof tier.setIfMatch === "function";
+}
+
+/** Require D108 versioned KV support and produce a clear adapter error when absent. */
+export function requireKvVersioned<T>(
+	tier: KvStorageTier<T>,
+	label = "kvStorage",
+): VersionedKvStorageTier<T> {
+	if (!hasKvVersioned(tier)) {
+		throw new Error(`${label}: KV tier does not support versioned get/set-if-match`);
+	}
+	return tier;
+}
+
+/** Options for wrapping a byte backend as a typed KV tier. */
+export interface KvStorageOptions<T> {
+	backend: StorageBackend;
+	codec?: Codec<T>;
+}
+
+function defer<T>(fn: () => T | PromiseLike<T>): Promise<T> {
+	return Promise.resolve().then(fn);
+}
+
+/** Build a typed KV tier from a byte backend and codec. */
+export function kvStorage<T = unknown>(opts: KvStorageOptions<T>): KvStorageTier<T> {
+	const codec = opts.codec ?? jsonCodecFor<T>();
+	const { backend } = opts;
+	const tier: KvStorageTier<T> = {
+		get(key) {
+			return defer(() => backend.get(key)).then((bytes) =>
+				bytes === undefined ? undefined : codec.decode(bytes),
+			);
+		},
+		set(key, value) {
+			return defer(() => backend.put(key, codec.encode(value))).then(() => undefined);
+		},
+		delete(key) {
+			return defer(() => backend.delete?.(key)).then(() => undefined);
+		},
+		list(prefix = "") {
+			return defer(() => {
+				if (!backend.list) throw new Error("kvStorage.list: backend does not support listing");
+				return backend.list(prefix);
+			}).then((keys) => [...keys].sort());
+		},
+	};
+	let out = tier;
+	if (hasStoragePutIfAbsent(backend)) {
+		out = {
+			...out,
+			putIfAbsent(key, value) {
+				return defer(() => backend.putIfAbsent(key, codec.encode(value)));
+			},
+		};
+	}
+	if (hasStorageVersioned(backend)) {
+		out = {
+			...out,
+			getVersioned(key) {
+				return defer(() => backend.getVersioned(key)).then((result) => {
+					if (result.kind === "miss") return { kind: "miss", generation: result.generation };
+					return {
+						kind: "hit",
+						value: codec.decode(result.value),
+						generation: result.generation,
+					};
+				});
+			},
+			setIfMatch(key, value, generation) {
+				return defer(() => backend.setIfMatch(key, codec.encode(value), generation));
+			},
+		};
+	}
+	return out;
+}
+
+/** Create an in-memory typed KV tier. */
+export function memoryKv<T = unknown>(codec: Codec<T> = jsonCodecFor<T>()): KvStorageTier<T> {
+	return kvStorage({ backend: memoryBackend(), codec });
+}
+
+/** Create an in-memory typed KV tier preloaded from a record. */
+export function dictKv<T = unknown>(
+	entries: Record<string, T> = {},
+	codec: Codec<T> = jsonCodecFor<T>(),
+): KvStorageTier<T> {
+	const backend = memoryBackend();
+	const kv = kvStorage({ backend, codec });
+	for (const [key, value] of Object.entries(entries)) {
+		backend.put(key, codec.encode(value as T));
+	}
+	return kv;
+}
+
+/** Convenience wrapper for deterministic prefix listing. */
+export function listByPrefix<T>(tier: KvStorageTier<T>, prefix = ""): Promise<readonly string[]> {
+	return tier.list(prefix);
+}
diff --git a/packages/ts/src/storage/node.ts b/packages/ts/src/storage/node.ts
new file mode 100644
index 00000000..cda4277e
--- /dev/null
+++ b/packages/ts/src/storage/node.ts
@@ -0,0 +1,564 @@
+/**
+ * Node-only passive storage backends (D103).
+ *
+ * Import from `@graphrefly/ts/storage/node`; the universal storage barrel stays browser-safe.
+ */
+
+import { randomBytes } from "node:crypto";
+import {
+	closeSync,
+	mkdirSync,
+	openSync,
+	readdirSync,
+	readFileSync,
+	renameSync,
+	unlinkSync,
+	writeFileSync,
+} from "node:fs";
+import { createRequire } from "node:module";
+import { basename, dirname, join } from "node:path";
+import { type AppendLogStorageTier, appendLogStorage } from "./append-log.js";
+import type { StorageBackend, StorageGeneration, StorageNamespaceOptions } from "./backend.js";
+import type { Codec } from "./codec.js";
+import { type KvStorageTier, kvStorage } from "./kv.js";
+
+export interface FileBackendOptions extends StorageNamespaceOptions {
+	/** File suffix used for stored byte blobs. Defaults to `.bin`. */
+	extension?: string;
+}
+
+export interface FileKvOptions<T> extends FileBackendOptions {
+	codec?: Codec<T>;
+}
+
+export interface FileAppendLogOptions<T> extends FileKvOptions<T> {
+	/** Append-log key prefix. Defaults to `event-log`. */
+	prefix?: string;
+}
+
+export interface SqliteBackendOptions extends StorageNamespaceOptions {
+	/** Table name used for passive byte storage. Defaults to `graphrefly_storage`. */
+	tableName?: string;
+}
+
+export interface SqliteKvOptions<T> extends SqliteBackendOptions {
+	codec?: Codec<T>;
+}
+
+export interface SqliteAppendLogOptions<T> extends SqliteKvOptions<T> {
+	/** Append-log key prefix. Defaults to `event-log`. */
+	prefix?: string;
+}
+
+export interface ClosableStorageBackend extends StorageBackend {
+	readonly name: string;
+	close(): void;
+}
+
+type SqliteDatabaseConstructor = new (path: string) => SqliteDatabase;
+
+interface SqliteDatabase {
+	exec(sql: string): void;
+	prepare(sql: string): SqliteStatement;
+	close(): void;
+}
+
+interface SqliteStatement {
+	get(...params: unknown[]): unknown;
+	run(...params: unknown[]): unknown;
+	all(...params: unknown[]): unknown[];
+}
+
+const FILE_STEM_PREFIX = "k-";
+const NAMESPACE_SEPARATOR = "\u0000";
+const SQLITE_GENERATION = Symbol("graphrefly.sqliteBackend.generation");
+const encoder = new TextEncoder();
+const decoder = new TextDecoder("utf-8", { fatal: true });
+const require = createRequire("/graphrefly-storage-node.js");
+
+interface SqliteGeneration {
+	readonly [SQLITE_GENERATION]: readonly [
+		storageId: object,
+		key: string,
+		rowGeneration: number | null,
+		epoch: number,
+	];
+}
+
+function isErrno(error: unknown, code: string): boolean {
+	return (
+		typeof error === "object" &&
+		error !== null &&
+		"code" in error &&
+		(error as { code?: unknown }).code === code
+	);
+}
+
+function keyToStem(key: string): string {
+	let out = "";
+	for (const ch of key) {
+		if (/^[a-zA-Z0-9_-]$/.test(ch)) {
+			out += ch;
+			continue;
+		}
+		for (const byte of encoder.encode(ch)) out += `%${byte.toString(16).padStart(2, "0")}`;
+	}
+	return out;
+}
+
+function stemToKey(stem: string): string | null {
+	const bytes: number[] = [];
+	let i = 0;
+	while (i < stem.length) {
+		const ch = stem[i]!;
+		if (ch === "%" && i + 2 < stem.length) {
+			const hex = stem.slice(i + 1, i + 3);
+			if (/^[0-9a-f]{2}$/i.test(hex)) {
+				bytes.push(Number.parseInt(hex, 16));
+				i += 3;
+				continue;
+			}
+		}
+		const code = ch.charCodeAt(0);
+		if (code > 0x7f) return null;
+		bytes.push(code);
+		i += 1;
+	}
+	try {
+		return decoder.decode(new Uint8Array(bytes));
+	} catch {
+		return null;
+	}
+}
+
+function validateExtension(extension: string): string {
+	if (
+		extension.length < 2 ||
+		!extension.startsWith(".") ||
+		extension.includes("..") ||
+		/[/\\\0]/.test(extension) ||
+		!/^[.A-Za-z0-9_-]+$/.test(extension)
+	) {
+		throw new TypeError("fileBackend: extension must be a simple suffix such as .bin");
+	}
+	return extension;
+}
+
+function validateNamespace(label: string, namespace: string): string {
+	if (typeof namespace !== "string") {
+		throw new TypeError(`${label}: namespace must be a string`);
+	}
+	if (namespace.includes(NAMESPACE_SEPARATOR)) {
+		throw new TypeError(`${label}: namespace must not contain U+0000`);
+	}
+	return namespace;
+}
+
+function validateLogicalKey(label: string, key: string): string {
+	if (typeof key !== "string") {
+		throw new TypeError(`${label}: key must be a string`);
+	}
+	if (key.includes(NAMESPACE_SEPARATOR)) {
+		throw new TypeError(`${label}: key must not contain U+0000`);
+	}
+	return key;
+}
+
+function validateListPrefix(label: string, prefix: string): string {
+	if (typeof prefix !== "string") {
+		throw new TypeError(`${label}: list prefix must be a string`);
+	}
+	if (prefix.includes(NAMESPACE_SEPARATOR)) {
+		throw new TypeError(`${label}: list prefix must not contain U+0000`);
+	}
+	return prefix;
+}
+
+function validateSqliteTableName(tableName: string): string {
+	if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(tableName)) {
+		throw new TypeError("sqliteBackend: tableName must be a simple SQLite identifier");
+	}
+	return tableName;
+}
+
+function sqliteGeneration(
+	storageId: object,
+	key: string,
+	rowGeneration: number | null,
+	epoch: number,
+): SqliteGeneration {
+	return Object.freeze({
+		[SQLITE_GENERATION]: Object.freeze([storageId, key, rowGeneration, epoch] as const),
+	});
+}
+
+function readSqliteGeneration(
+	generation: StorageGeneration,
+):
+	| readonly [storageId: object, key: string, rowGeneration: number | null, epoch: number]
+	| undefined {
+	if (typeof generation !== "object" || generation === null) return undefined;
+	const maybe = generation as Partial<SqliteGeneration>;
+	const token = maybe[SQLITE_GENERATION];
+	if (
+		Array.isArray(token) &&
+		token.length === 4 &&
+		typeof token[0] === "object" &&
+		token[0] !== null &&
+		typeof token[1] === "string" &&
+		(token[2] === null || typeof token[2] === "number") &&
+		typeof token[3] === "number"
+	) {
+		return token as readonly [object, string, number | null, number];
+	}
+	return undefined;
+}
+
+function sqliteChanges(result: unknown): number {
+	return typeof result === "object" &&
+		result !== null &&
+		"changes" in result &&
+		typeof (result as { changes?: unknown }).changes === "number"
+		? (result as { changes: number }).changes
+		: 0;
+}
+
+function sqliteBytes(value: Uint8Array | ArrayBuffer): Uint8Array {
+	return Uint8Array.from(value instanceof Uint8Array ? value : new Uint8Array(value));
+}
+
+function loadSqliteDatabaseSync(): SqliteDatabaseConstructor {
+	try {
+		const DatabaseSync = (require("node:sqlite") as { DatabaseSync?: unknown }).DatabaseSync;
+		if (typeof DatabaseSync !== "function") {
+			throw new TypeError("DatabaseSync export is missing");
+		}
+		return DatabaseSync as SqliteDatabaseConstructor;
+	} catch (error) {
+		throw new Error("sqliteBackend: node:sqlite is not available in this Node runtime", {
+			cause: error,
+		});
+	}
+}
+
+/** Node filesystem byte backend with atomic replace writes and D85 conditional create. */
+export function fileBackend(dir: string, opts: FileBackendOptions = {}): StorageBackend {
+	const extension = validateExtension(opts.extension ?? ".bin");
+	const namespace =
+		opts.namespace === undefined ? "" : validateNamespace("fileBackend", opts.namespace);
+	const namespacePrefix = namespace.length > 0 ? `${namespace}${NAMESPACE_SEPARATOR}` : "";
+	const storageKey = (key: string) => `${namespacePrefix}${validateLogicalKey("fileBackend", key)}`;
+	const pathFor = (key: string) =>
+		join(dir, `${FILE_STEM_PREFIX}${keyToStem(storageKey(key))}${extension}`);
+	const keyFromFilename = (filename: string): string | null => {
+		if (!filename.endsWith(extension)) return null;
+		const stem = filename.slice(0, -extension.length);
+		if (!stem.startsWith(FILE_STEM_PREFIX)) return null;
+		const key = stemToKey(stem.slice(FILE_STEM_PREFIX.length));
+		if (key === null || !key.startsWith(namespacePrefix)) return null;
+		const logical = key.slice(namespacePrefix.length);
+		if (logical.includes(NAMESPACE_SEPARATOR)) {
+			throw new TypeError("fileBackend: malformed stored key");
+		}
+		return logical;
+	};
+
+	return {
+		get(key) {
+			try {
+				return Uint8Array.from(readFileSync(pathFor(key)));
+			} catch (error) {
+				if (isErrno(error, "ENOENT")) return undefined;
+				throw error;
+			}
+		},
+		put(key, value) {
+			mkdirSync(dir, { recursive: true });
+			const filePath = pathFor(key);
+			const base = basename(filePath);
+			const parent = dirname(filePath);
+			const tmp = join(parent, `.${base}.${randomBytes(8).toString("hex")}.tmp`);
+			try {
+				writeFileSync(tmp, value);
+				renameSync(tmp, filePath);
+			} catch (error) {
+				try {
+					unlinkSync(tmp);
+				} catch {
+					// Ignore cleanup failures; the original write error is the useful one.
+				}
+				throw error;
+			}
+		},
+		putIfAbsent(key, value) {
+			mkdirSync(dir, { recursive: true });
+			const filePath = pathFor(key);
+			let fd: number | undefined;
+			try {
+				fd = openSync(filePath, "wx");
+				writeFileSync(fd, value);
+				return true;
+			} catch (error) {
+				if (isErrno(error, "EEXIST")) return false;
+				if (fd !== undefined) {
+					try {
+						unlinkSync(filePath);
+					} catch {
+						// Best effort cleanup of a partially-created file.
+					}
+				}
+				throw error;
+			} finally {
+				if (fd !== undefined) closeSync(fd);
+			}
+		},
+		delete(key) {
+			try {
+				unlinkSync(pathFor(key));
+			} catch (error) {
+				if (!isErrno(error, "ENOENT")) throw error;
+			}
+		},
+		list(prefix = "") {
+			const validatedPrefix = validateListPrefix("fileBackend", prefix);
+			let entries: string[];
+			try {
+				entries = readdirSync(dir);
+			} catch (error) {
+				if (isErrno(error, "ENOENT")) return [];
+				throw error;
+			}
+			const keys: string[] = [];
+			for (const entry of entries) {
+				if (entry.startsWith(".")) continue;
+				const key = keyFromFilename(entry);
+				if (key?.startsWith(validatedPrefix)) keys.push(key);
+			}
+			return keys.sort();
+		},
+	};
+}
+
+/**
+ * Create a typed KV tier over a Node filesystem backend (D106 passive storage).
+ */
+export function fileKv<T>(dir: string, opts: FileKvOptions<T> = {}): KvStorageTier<T> {
+	return kvStorage<T>({
+		backend: fileBackend(dir, opts),
+		codec: opts.codec,
+	});
+}
+
+/**
+ * Create an append-log tier over a Node filesystem backend (D106 passive storage).
+ */
+export function fileAppendLog<T>(
+	dir: string,
+	opts: FileAppendLogOptions<T> = {},
+): AppendLogStorageTier<T> {
+	return appendLogStorage<T>({
+		kv: fileKv<T>(dir, opts),
+		prefix: opts.prefix ?? "event-log",
+	});
+}
+
+/**
+ * Optional Node SQLite byte backend (D106 passive storage).
+ *
+ * Uses `node:sqlite` when the current Node runtime provides it; otherwise throws a clear
+ * runtime error at construction time. The caller owns `close()`.
+ */
+export function sqliteBackend(
+	path: string,
+	opts: SqliteBackendOptions = {},
+): ClosableStorageBackend {
+	const table = validateSqliteTableName(opts.tableName ?? "graphrefly_storage");
+	const metaTable = validateSqliteTableName(`${table}_meta`);
+	const namespace =
+		opts.namespace === undefined ? "" : validateNamespace("sqliteBackend", opts.namespace);
+	const DatabaseSync = loadSqliteDatabaseSync();
+	const namespacePrefix = namespace.length > 0 ? `${namespace}${NAMESPACE_SEPARATOR}` : "";
+	const storageKey = (key: string) =>
+		`${namespacePrefix}${validateLogicalKey("sqliteBackend", key)}`;
+	const storageId = Object.freeze({});
+	const logicalKey = (key: string): string | undefined => {
+		if (typeof key !== "string") {
+			throw new TypeError("sqliteBackend: stored key is corrupt");
+		}
+		if (!key.startsWith(namespacePrefix)) return undefined;
+		const logical = key.slice(namespacePrefix.length);
+		if (logical.includes(NAMESPACE_SEPARATOR)) {
+			throw new TypeError("sqliteBackend: malformed stored key");
+		}
+		return logical;
+	};
+	const db = new DatabaseSync(path);
+	db.exec(
+		`CREATE TABLE IF NOT EXISTS ${table} (k TEXT PRIMARY KEY, v BLOB NOT NULL, g INTEGER NOT NULL DEFAULT 0)`,
+	);
+	const columns = db.prepare(`PRAGMA table_info(${table})`).all() as Array<{ name?: string }>;
+	if (!columns.some((column) => column.name === "g")) {
+		db.exec(`ALTER TABLE ${table} ADD COLUMN g INTEGER NOT NULL DEFAULT 0`);
+	}
+	db.exec(`CREATE TABLE IF NOT EXISTS ${metaTable} (k TEXT PRIMARY KEY, v INTEGER NOT NULL)`);
+	db.exec(`
+		CREATE TRIGGER IF NOT EXISTS ${table}_generation_insert
+		AFTER INSERT ON ${table}
+		BEGIN
+			INSERT INTO ${metaTable} (k, v) VALUES (NEW.k, 1)
+			ON CONFLICT(k) DO UPDATE SET v = ${metaTable}.v + 1;
+		END
+	`);
+	db.exec(`
+		CREATE TRIGGER IF NOT EXISTS ${table}_generation_update
+		AFTER UPDATE ON ${table}
+		BEGIN
+			INSERT INTO ${metaTable} (k, v) VALUES (NEW.k, 1)
+			ON CONFLICT(k) DO UPDATE SET v = ${metaTable}.v + 1;
+		END
+	`);
+	db.exec(`
+		CREATE TRIGGER IF NOT EXISTS ${table}_generation_delete
+		AFTER DELETE ON ${table}
+		BEGIN
+			INSERT INTO ${metaTable} (k, v) VALUES (OLD.k, 1)
+			ON CONFLICT(k) DO UPDATE SET v = ${metaTable}.v + 1;
+		END
+	`);
+
+	const keyEpoch = (key: string): number => {
+		const row = db.prepare(`SELECT v FROM ${metaTable} WHERE k = ?`).get(key) as
+			| { v?: number }
+			| undefined;
+		const value = row?.v ?? 0;
+		if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0) {
+			throw new Error("sqliteBackend: per-key generation epoch is corrupt");
+		}
+		return value;
+	};
+	const readRow = (
+		key: string,
+	):
+		| {
+				readonly value: Uint8Array;
+				readonly generation: number;
+		  }
+		| undefined => {
+		const row = db.prepare(`SELECT v, g FROM ${table} WHERE k = ?`).get(storageKey(key)) as
+			| { v?: Uint8Array | ArrayBuffer; g?: number }
+			| undefined;
+		if (row?.v === undefined) return undefined;
+		const generation = row.g;
+		if (typeof generation !== "number" || !Number.isSafeInteger(generation) || generation < 0) {
+			throw new Error("sqliteBackend: row generation is corrupt");
+		}
+		return { value: sqliteBytes(row.v), generation };
+	};
+
+	return {
+		name: `sqlite:${path}/${table}`,
+		get(key) {
+			return readRow(key)?.value;
+		},
+		put(key, value) {
+			db.prepare(
+				`INSERT INTO ${table} (k, v, g) VALUES (?, ?, 0) ON CONFLICT(k) DO UPDATE SET v = excluded.v, g = ${table}.g + 1`,
+			).run(storageKey(key), value);
+		},
+		putIfAbsent(key, value) {
+			const result = db
+				.prepare(`INSERT OR IGNORE INTO ${table} (k, v, g) VALUES (?, ?, 0)`)
+				.run(storageKey(key), value) as { changes?: number };
+			return sqliteChanges(result) === 1;
+		},
+		getVersioned(key) {
+			const row = readRow(key);
+			if (row === undefined) {
+				return {
+					kind: "miss",
+					generation: sqliteGeneration(storageId, storageKey(key), null, keyEpoch(storageKey(key))),
+				};
+			}
+			return {
+				kind: "hit",
+				value: row.value,
+				generation: sqliteGeneration(
+					storageId,
+					storageKey(key),
+					row.generation,
+					keyEpoch(storageKey(key)),
+				),
+			};
+		},
+		setIfMatch(key, value, generation) {
+			const keyForStorage = storageKey(key);
+			const observed = readSqliteGeneration(generation);
+			if (observed === undefined || observed[0] !== storageId || observed[1] !== keyForStorage) {
+				return false;
+			}
+			if (observed[2] === null) {
+				return (
+					sqliteChanges(
+						db
+							.prepare(
+								`INSERT INTO ${table} (k, v, g) SELECT ?, ?, 0 WHERE COALESCE((SELECT v FROM ${metaTable} WHERE k = ?), 0) = ? AND NOT EXISTS (SELECT 1 FROM ${table} WHERE k = ?)`,
+							)
+							.run(keyForStorage, value, keyForStorage, observed[3], keyForStorage),
+					) === 1
+				);
+			}
+			return (
+				sqliteChanges(
+					db
+						.prepare(
+							`UPDATE ${table} SET v = ?, g = g + 1 WHERE k = ? AND g = ? AND COALESCE((SELECT v FROM ${metaTable} WHERE k = ?), 0) = ?`,
+						)
+						.run(value, keyForStorage, observed[2], keyForStorage, observed[3]),
+				) === 1
+			);
+		},
+		delete(key) {
+			db.prepare(`DELETE FROM ${table} WHERE k = ?`).run(storageKey(key));
+		},
+		list(prefix = "") {
+			const validatedPrefix = validateListPrefix("sqliteBackend", prefix);
+			const rows = db.prepare(`SELECT k FROM ${table} ORDER BY k`).all() as { k: string }[];
+			const out: string[] = [];
+			for (const row of rows) {
+				const key = logicalKey(row.k);
+				if (key?.startsWith(validatedPrefix)) out.push(key);
+			}
+			return out.sort();
+		},
+		close() {
+			db.close();
+		},
+	};
+}
+
+/**
+ * Create a typed KV tier over an optional Node SQLite backend.
+ */
+export function sqliteKv<T>(
+	path: string,
+	opts: SqliteKvOptions<T> = {},
+): KvStorageTier<T> & { close(): void } {
+	const backend = sqliteBackend(path, opts);
+	const tier = kvStorage<T>({
+		backend,
+		codec: opts.codec,
+	});
+	return Object.assign(tier, { close: () => backend.close() });
+}
+
+/**
+ * Create an append-log tier over an optional Node SQLite backend.
+ */
+export function sqliteAppendLog<T>(
+	path: string,
+	opts: SqliteAppendLogOptions<T> = {},
+): AppendLogStorageTier<T> & { close(): void } {
+	const kv = sqliteKv<T>(path, opts);
+	const log = appendLogStorage<T>({ kv, prefix: opts.prefix ?? "event-log" });
+	return Object.assign(log, { close: () => kv.close() });
+}
diff --git a/packages/ts/src/storage/observe-event-log.ts b/packages/ts/src/storage/observe-event-log.ts
new file mode 100644
index 00000000..718df5bc
--- /dev/null
+++ b/packages/ts/src/storage/observe-event-log.ts
@@ -0,0 +1,83 @@
+import type { AppendLogPage, AppendLogReadOptions, AppendLogStorageTier } from "./append-log.js";
+import { readAppendLogPage } from "./append-log.js";
+import { assertChangeEnvelope, type ChangeEnvelope, envelopeChange } from "./change.js";
+import type { Codec } from "./codec.js";
+import { strictJsonCodecFor } from "./codec.js";
+
+export interface ObserveEventLike {
+	readonly seq: number;
+	readonly path: string;
+}
+
+/** Storage frame for one Graph.observe() event, preserving graph observe sequence. */
+export interface ObserveEventFrame<T = unknown> extends ChangeEnvelope<T> {
+	readonly structure: "observe-event";
+	readonly observeSeq: number;
+	readonly path: string;
+	readonly stream?: string;
+}
+
+/** One ordered observe-event log page. It is not graph projection or restore replay. */
+export type ObserveEventLogPage<T = unknown> = AppendLogPage<ObserveEventFrame<T>>;
+
+/** Create a storage frame from one observe event and mapped payload. */
+export function observeEventFrame<T>(
+	event: ObserveEventLike,
+	value: T,
+	opts: { stream?: string } = {},
+): ObserveEventFrame<T> {
+	return {
+		...envelopeChange(value, {
+			lifecycle: "data",
+			structure: "observe-event",
+			version: 1,
+			seq: event.seq,
+		}),
+		structure: "observe-event",
+		observeSeq: event.seq,
+		path: event.path,
+		...(opts.stream === undefined ? {} : { stream: opts.stream }),
+	};
+}
+
+/** Validate a decoded D82 observe-event storage frame. */
+export function assertObserveEventFrame<T = unknown>(value: unknown): ObserveEventFrame<T> {
+	const frame = assertChangeEnvelope<T>(value);
+	const record = frame as unknown as Record<string, unknown>;
+	if (frame.structure !== "observe-event") {
+		throw new TypeError("observeEventFrameCodec: structure must be observe-event");
+	}
+	if (!Number.isSafeInteger(record.observeSeq) || (record.observeSeq as number) < 0) {
+		throw new TypeError("observeEventFrameCodec: observeSeq must be a non-negative safe integer");
+	}
+	if (typeof record.path !== "string") {
+		throw new TypeError("observeEventFrameCodec: path must be a string");
+	}
+	if (record.stream !== undefined && typeof record.stream !== "string") {
+		throw new TypeError("observeEventFrameCodec: stream must be a string when present");
+	}
+	return frame as ObserveEventFrame<T>;
+}
+
+/** Stable JSON codec for D82 observe-event frames, not restore records. */
+export function observeEventFrameCodec<T = unknown>(): Codec<ObserveEventFrame<T>> {
+	const codec = strictJsonCodecFor<unknown>();
+	return {
+		encode(value) {
+			return codec.encode(assertObserveEventFrame(value));
+		},
+		decode(bytes) {
+			return assertObserveEventFrame<T>(codec.decode(bytes));
+		},
+	};
+}
+
+/**
+ * Read one ordered observe-event log page without projecting it into graph state.
+ */
+export function readObserveEventLogPage<T = unknown>(
+	log: AppendLogStorageTier<ObserveEventFrame<T>>,
+	opts: AppendLogReadOptions = {},
+): Promise<ObserveEventLogPage<T>> {
+	return readAppendLogPage(log, opts);
+}
diff --git a/packages/ts/src/storage/reactive-collection.ts b/packages/ts/src/storage/reactive-collection.ts
new file mode 100644
index 00000000..f130bb07
--- /dev/null
+++ b/packages/ts/src/storage/reactive-collection.ts
@@ -0,0 +1,707 @@
+import type {
+	IndexChange,
+	ListChange,
+	LogChange,
+	MapChange,
+} from "../graph/data-structures/change.js";
+import type { IndexRow } from "../graph/data-structures/reactive-index.js";
+import { strictCanonicalJsonBytes, strictJsonCodecFor } from "../json/codec.js";
+import type { AppendLogStorageTier } from "./append-log.js";
+import type { Codec } from "./codec.js";
+import type { KvStorageTier } from "./kv.js";
+
+/** D161 strict-JSON snapshot frame format tag for reactive collection persistence. */
+export const REACTIVE_COLLECTION_SNAPSHOT_FORMAT =
+	"graphrefly.reactive-collection.snapshot.v1" as const;
+/** D161 strict-JSON change frame format tag for reactive collection persistence. */
+export const REACTIVE_COLLECTION_CHANGE_FORMAT =
+	"graphrefly.reactive-collection.change.v1" as const;
+/** D161 v1 frame version for reactive collection snapshot/change storage. */
+export const REACTIVE_COLLECTION_FRAME_VERSION = 1 as const;
+
+/** D161 collection kinds recognized by the unified persistence frame envelope. */
+export type ReactiveCollectionStorageKind =
+	| "reactiveList"
+	| "reactiveLog"
+	| "reactiveMap"
+	| "reactiveIndex";
+
+/** D161 durable baseline frame; storage is passive and does not own graph restore. */
+export interface ReactiveCollectionSnapshotFrame<
+	K extends ReactiveCollectionStorageKind = ReactiveCollectionStorageKind,
+	S = unknown,
+> {
+	readonly format: typeof REACTIVE_COLLECTION_SNAPSHOT_FORMAT;
+	readonly version: typeof REACTIVE_COLLECTION_FRAME_VERSION;
+	readonly kind: K;
+	/** Last append-log seq reflected by this snapshot; -1 means no change-log entry. */
+	readonly changeCursor: number;
+	readonly snapshot: S;
+}
+
+/** D161 append-log change frame; change-log replay is collection-state folding, not graph restore. */
+export interface ReactiveCollectionChangeFrame<
+	K extends ReactiveCollectionStorageKind = ReactiveCollectionStorageKind,
+	C = unknown,
+> {
+	readonly format: typeof REACTIVE_COLLECTION_CHANGE_FORMAT;
+	readonly version: typeof REACTIVE_COLLECTION_FRAME_VERSION;
+	readonly kind: K;
+	readonly change: C;
+}
+
+/** D161 passive load/fold result consumed by synchronous restoreReactive* helpers. */
+export interface ReactiveCollectionRestoreState<
+	K extends ReactiveCollectionStorageKind = ReactiveCollectionStorageKind,
+	S = unknown,
+> {
+	readonly kind: K;
+	readonly state: S;
+	readonly source: "empty" | "changes" | "snapshot" | "snapshot+changes";
+	readonly snapshot: { readonly found: boolean; readonly changeCursor: number };
+	readonly changes: { readonly applied: number; readonly cursor: number };
+}
+
+/** D161 restore state for a reactiveList materialized as a strict-JSON array snapshot. */
+export type ReactiveListRestoreState<T = unknown> = ReactiveCollectionRestoreState<
+	"reactiveList",
+	readonly T[]
+>;
+
+/** D161 restore state for a reactiveLog materialized as a strict-JSON array snapshot. */
+export type ReactiveLogRestoreState<T = unknown> = ReactiveCollectionRestoreState<
+	"reactiveLog",
+	readonly T[]
+>;
+
+/** D161 passive restore-state shape for reactiveMap; policy-aware restore remains deferred. */
+export type ReactiveMapRestoreState<K = unknown, V = unknown> = ReactiveCollectionRestoreState<
+	"reactiveMap",
+	readonly (readonly [K, V])[]
+>;
+
+/** D161 passive restore-state shape for reactiveIndex; key-codec restore remains deferred. */
+export type ReactiveIndexRestoreState<K = unknown, V = unknown> = ReactiveCollectionRestoreState<
+	"reactiveIndex",
+	readonly IndexRow<K, V>[]
+>;
+
+/** D161 passive storage inputs for collection load/fold helpers. */
+export interface LoadReactiveCollectionStateOptions {
+	readonly snapshotStore: KvStorageTier<unknown>;
+	readonly snapshotKey?: string;
+	readonly storagePrefix?: string;
+	readonly changeLog?: AppendLogStorageTier<unknown>;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+function ownKeys(value: Record<string, unknown>): readonly string[] {
+	return Object.keys(value).sort();
+}
+
+function assertKeys(
+	value: Record<string, unknown>,
+	expected: readonly string[],
+	label: string,
+): void {
+	const actual = ownKeys(value);
+	const want = [...expected].sort();
+	if (actual.length !== want.length || actual.some((key, i) => key !== want[i])) {
+		throw new TypeError(`${label}: unexpected frame fields ${actual.join(",")}`);
+	}
+}
+
+function assertSafeInteger(value: unknown, label: string, min = 0): number {
+	if (!Number.isSafeInteger(value) || (value as number) < min) {
+		throw new TypeError(`${label} must be a safe integer >= ${min}`);
+	}
+	return value as number;
+}
+
+function assertKind<K extends ReactiveCollectionStorageKind>(
+	value: unknown,
+	expected: K,
+	label: string,
+): K {
+	if (value !== expected) throw new TypeError(`${label}: kind must be ${expected}`);
+	return expected;
+}
+
+function assertArray<T = unknown>(value: unknown, label: string): readonly T[] {
+	if (!Array.isArray(value)) throw new TypeError(`${label}: snapshot must be an array`);
+	return value as readonly T[];
+}
+
+function strictJsonIdentity(value: unknown): string {
+	return Array.from(strictCanonicalJsonBytes(value)).join(",");
+}
+
+function assertEntryArray<K = unknown, V = unknown>(
+	value: unknown,
+	label: string,
+): readonly (readonly [K, V])[] {
+	const entries = assertArray<unknown>(value, label);
+	const seen = new Set<string>();
+	for (const [i, entry] of entries.entries()) {
+		if (!Array.isArray(entry) || entry.length !== 2) {
+			throw new TypeError(`${label}: entry ${i} must be [key,value]`);
+		}
+		const key = strictJsonIdentity(entry[0]);
+		if (seen.has(key)) throw new TypeError(`${label}: entry ${i} duplicates an earlier key`);
+		seen.add(key);
+	}
+	return entries as readonly (readonly [K, V])[];
+}
+
+function assertIndexRows<K = unknown, V = unknown>(
+	value: unknown,
+	label: string,
+): readonly IndexRow<K, V>[] {
+	const rows = assertArray<unknown>(value, label);
+	const seen = new Set<string>();
+	for (const [i, row] of rows.entries()) {
+		if (!isRecord(row)) throw new TypeError(`${label}: row ${i} must be an object`);
+		assertKeys(row, ["primary", "secondary", "value"], `${label} row`);
+		const primary = strictJsonIdentity(row.primary);
+		if (seen.has(primary)) {
+			throw new TypeError(`${label}: row ${i} duplicates an earlier primary`);
+		}
+		seen.add(primary);
+	}
+	return rows as readonly IndexRow<K, V>[];
+}
+
+/** Build the default D161 snapshot key for a storage prefix. */
+export function collectionSnapshotKey(storagePrefix = "reactive-collection"): string {
+	if (storagePrefix.length === 0) throw new TypeError("storagePrefix must be non-empty");
+	return `${storagePrefix}/snapshot`;
+}
+
+/** Build a D161 strict-JSON snapshot frame before validation/encoding. */
+export function reactiveCollectionSnapshotFrame<K extends ReactiveCollectionStorageKind, S>(
+	kind: K,
+	snapshot: S,
+	opts: { readonly changeCursor?: number } = {},
+): ReactiveCollectionSnapshotFrame<K, S> {
+	const changeCursor = opts.changeCursor ?? -1;
+	if (!Number.isSafeInteger(changeCursor) || changeCursor < -1) {
+		throw new RangeError("reactive collection snapshot changeCursor must be a safe integer >= -1");
+	}
+	return {
+		format: REACTIVE_COLLECTION_SNAPSHOT_FORMAT,
+		version: REACTIVE_COLLECTION_FRAME_VERSION,
+		kind,
+		changeCursor,
+		snapshot,
+	};
+}
+
+/** Build a D161 strict-JSON change frame before validation/encoding. */
+export function reactiveCollectionChangeFrame<K extends ReactiveCollectionStorageKind, C>(
+	kind: K,
+	change: C,
+): ReactiveCollectionChangeFrame<K, C> {
+	return {
+		format: REACTIVE_COLLECTION_CHANGE_FORMAT,
+		version: REACTIVE_COLLECTION_FRAME_VERSION,
+		kind,
+		change,
+	};
+}
+
+/** Validate a D161 snapshot frame and reject non-strict-JSON payloads honestly. */
+export function assertReactiveCollectionSnapshotFrame<
+	K extends ReactiveCollectionStorageKind,
+	S = unknown,
+>(value: unknown, expectedKind: K): ReactiveCollectionSnapshotFrame<K, S> {
+	if (!isRecord(value)) throw new TypeError("reactive collection snapshot frame must be an object");
+	assertKeys(value, ["changeCursor", "format", "kind", "snapshot", "version"], "snapshot frame");
+	if (value.format !== REACTIVE_COLLECTION_SNAPSHOT_FORMAT) {
+		throw new TypeError("snapshot frame: invalid format");
+	}
+	if (value.version !== REACTIVE_COLLECTION_FRAME_VERSION) {
+		throw new TypeError("snapshot frame: invalid version");
+	}
+	assertKind(value.kind, expectedKind, "snapshot frame");
+	assertSafeInteger(value.changeCursor, "snapshot frame changeCursor", -1);
+	strictJsonCodecFor<unknown>().encode(value);
+	return value as unknown as ReactiveCollectionSnapshotFrame<K, S>;
+}
+
+/** Validate a D161 change frame and reject non-strict-JSON payloads honestly. */
+export function assertReactiveCollectionChangeFrame<
+	K extends ReactiveCollectionStorageKind,
+	C = unknown,
+>(value: unknown, expectedKind: K): ReactiveCollectionChangeFrame<K, C> {
+	if (!isRecord(value)) throw new TypeError("reactive collection change frame must be an object");
+	assertKeys(value, ["change", "format", "kind", "version"], "change frame");
+	if (value.format !== REACTIVE_COLLECTION_CHANGE_FORMAT) {
+		throw new TypeError("change frame: invalid format");
+	}
+	if (value.version !== REACTIVE_COLLECTION_FRAME_VERSION) {
+		throw new TypeError("change frame: invalid version");
+	}
+	assertKind(value.kind, expectedKind, "change frame");
+	if (!Object.hasOwn(value, "change")) throw new TypeError("change frame: change is required");
+	strictJsonCodecFor<unknown>().encode(value);
+	return value as unknown as ReactiveCollectionChangeFrame<K, C>;
+}
+
+/** Codec for D161 snapshot frames with strict JSON validation on both encode and decode. */
+export function reactiveCollectionSnapshotFrameCodec<
+	K extends ReactiveCollectionStorageKind,
+	S = unknown,
+>(kind: K): Codec<ReactiveCollectionSnapshotFrame<K, S>> {
+	const codec = strictJsonCodecFor<unknown>();
+	return {
+		encode(value) {
+			return codec.encode(assertReactiveCollectionSnapshotFrame<K, S>(value, kind));
+		},
+		decode(bytes) {
+			return assertReactiveCollectionSnapshotFrame<K, S>(codec.decode(bytes), kind);
+		},
+	};
+}
+
+/** Codec for D161 change frames with strict JSON validation on both encode and decode. */
+export function reactiveCollectionChangeFrameCodec<
+	K extends ReactiveCollectionStorageKind,
+	C = unknown,
+>(kind: K): Codec<ReactiveCollectionChangeFrame<K, C>> {
+	const codec = strictJsonCodecFor<unknown>();
+	return {
+		encode(value) {
+			return codec.encode(assertReactiveCollectionChangeFrame<K, C>(value, kind));
+		},
+		decode(bytes) {
+			return assertReactiveCollectionChangeFrame<K, C>(codec.decode(bytes), kind);
+		},
+	};
+}
+
+function assertListChange<T>(value: unknown): ListChange<T> {
+	if (!isRecord(value) || typeof value.kind !== "string") {
+		throw new TypeError("reactiveList change must be an object with kind");
+	}
+	switch (value.kind) {
+		case "append":
+			if (!Object.hasOwn(value, "value")) throw new TypeError("reactiveList append.value required");
+			assertKeys(value, ["kind", "value"], "reactiveList append");
+			return value as unknown as ListChange<T>;
+		case "appendMany":
+			assertKeys(value, ["kind", "values"], "reactiveList appendMany");
+			assertArray<T>(value.values, "reactiveList appendMany.values");
+			return value as unknown as ListChange<T>;
+		case "insert":
+			assertKeys(value, ["index", "kind", "value"], "reactiveList insert");
+			assertSafeInteger(value.index, "reactiveList insert.index", 0);
+			return value as unknown as ListChange<T>;
+		case "insertMany":
+			assertKeys(value, ["index", "kind", "values"], "reactiveList insertMany");
+			assertSafeInteger(value.index, "reactiveList insertMany.index", 0);
+			assertArray<T>(value.values, "reactiveList insertMany.values");
+			return value as unknown as ListChange<T>;
+		case "pop":
+			assertKeys(value, ["index", "kind", "value"], "reactiveList pop");
+			assertSafeInteger(value.index, "reactiveList pop.index", 0);
+			return value as unknown as ListChange<T>;
+		case "trimHead":
+			assertKeys(value, ["kind", "n"], "reactiveList trimHead");
+			assertSafeInteger(value.n, "reactiveList trimHead.n", 0);
+			return value as unknown as ListChange<T>;
+		case "clear":
+			assertKeys(value, ["count", "kind"], "reactiveList clear");
+			assertSafeInteger(value.count, "reactiveList clear.count", 0);
+			return value as unknown as ListChange<T>;
+		default:
+			throw new TypeError(`unsupported reactiveList change kind ${value.kind}`);
+	}
+}
+
+function assertLogChange<T>(value: unknown): LogChange<T> {
+	if (!isRecord(value) || typeof value.kind !== "string") {
+		throw new TypeError("reactiveLog change must be an object with kind");
+	}
+	switch (value.kind) {
+		case "append":
+			if (!Object.hasOwn(value, "value")) throw new TypeError("reactiveLog append.value required");
+			assertKeys(value, ["kind", "value"], "reactiveLog append");
+			return value as unknown as LogChange<T>;
+		case "appendMany":
+			assertKeys(value, ["kind", "values"], "reactiveLog appendMany");
+			assertArray<T>(value.values, "reactiveLog appendMany.values");
+			return value as unknown as LogChange<T>;
+		case "trimHead":
+			assertKeys(value, ["kind", "n"], "reactiveLog trimHead");
+			assertSafeInteger(value.n, "reactiveLog trimHead.n", 0);
+			return value as unknown as LogChange<T>;
+		case "clear":
+			assertKeys(value, ["count", "kind"], "reactiveLog clear");
+			assertSafeInteger(value.count, "reactiveLog clear.count", 0);
+			return value as unknown as LogChange<T>;
+		default:
+			throw new TypeError(`unsupported reactiveLog change kind ${value.kind}`);
+	}
+}
+
+function assertMapChange<K, V>(value: unknown): MapChange<K, V> {
+	if (!isRecord(value) || typeof value.kind !== "string") {
+		throw new TypeError("reactiveMap change must be an object with kind");
+	}
+	switch (value.kind) {
+		case "set":
+			if (!Object.hasOwn(value, "key")) throw new TypeError("reactiveMap set.key required");
+			if (!Object.hasOwn(value, "value")) throw new TypeError("reactiveMap set.value required");
+			assertKeys(value, ["key", "kind", "value"], "reactiveMap set");
+			return value as unknown as MapChange<K, V>;
+		case "delete":
+			if (!Object.hasOwn(value, "key")) throw new TypeError("reactiveMap delete.key required");
+			if (!Object.hasOwn(value, "previous")) {
+				throw new TypeError("reactiveMap delete.previous required");
+			}
+			assertKeys(value, ["key", "kind", "previous", "reason"], "reactiveMap delete");
+			if (
+				value.reason !== "expired" &&
+				value.reason !== "lru-evict" &&
+				value.reason !== "archived" &&
+				value.reason !== "explicit"
+			) {
+				throw new TypeError("reactiveMap delete.reason is invalid");
+			}
+			return value as unknown as MapChange<K, V>;
+		case "clear":
+			assertKeys(value, ["count", "kind"], "reactiveMap clear");
+			assertSafeInteger(value.count, "reactiveMap clear.count", 0);
+			return value as unknown as MapChange<K, V>;
+		default:
+			throw new TypeError(`unsupported reactiveMap change kind ${value.kind}`);
+	}
+}
+
+function assertIndexChange<K, V>(value: unknown): IndexChange<K, V> {
+	if (!isRecord(value) || typeof value.kind !== "string") {
+		throw new TypeError("reactiveIndex change must be an object with kind");
+	}
+	switch (value.kind) {
+		case "upsert":
+			if (!Object.hasOwn(value, "primary")) {
+				throw new TypeError("reactiveIndex upsert.primary required");
+			}
+			if (!Object.hasOwn(value, "secondary")) {
+				throw new TypeError("reactiveIndex upsert.secondary required");
+			}
+			if (!Object.hasOwn(value, "value"))
+				throw new TypeError("reactiveIndex upsert.value required");
+			assertKeys(value, ["kind", "primary", "secondary", "value"], "reactiveIndex upsert");
+			return value as unknown as IndexChange<K, V>;
+		case "delete":
+			if (!Object.hasOwn(value, "primary")) {
+				throw new TypeError("reactiveIndex delete.primary required");
+			}
+			assertKeys(value, ["kind", "primary"], "reactiveIndex delete");
+			return value as unknown as IndexChange<K, V>;
+		case "deleteMany":
+			assertKeys(value, ["kind", "primaries"], "reactiveIndex deleteMany");
+			assertArray<K>(value.primaries, "reactiveIndex deleteMany.primaries");
+			return value as unknown as IndexChange<K, V>;
+		case "clear":
+			assertKeys(value, ["count", "kind"], "reactiveIndex clear");
+			assertSafeInteger(value.count, "reactiveIndex clear.count", 0);
+			return value as unknown as IndexChange<K, V>;
+		default:
+			throw new TypeError(`unsupported reactiveIndex change kind ${value.kind}`);
+	}
+}
+
+function applyListChange<T>(state: T[], change: ListChange<T>): void {
+	switch (change.kind) {
+		case "append":
+			state.push(change.value);
+			return;
+		case "appendMany":
+			state.push(...change.values);
+			return;
+		case "insert":
+			if (change.index > state.length)
+				throw new Error("reactiveList insert change is out of range");
+			state.splice(change.index, 0, change.value);
+			return;
+		case "insertMany":
+			if (change.index > state.length) {
+				throw new Error("reactiveList insertMany change is out of range");
+			}
+			state.splice(change.index, 0, ...change.values);
+			return;
+		case "pop":
+			if (change.index >= state.length) throw new Error("reactiveList pop change is out of range");
+			if (!strictJsonEquals(state[change.index], change.value)) {
+				throw new Error("reactiveList pop change value does not match current state");
+			}
+			state.splice(change.index, 1);
+			return;
+		case "trimHead":
+			if (change.n > state.length) throw new Error("reactiveList trimHead change is out of range");
+			state.splice(0, change.n);
+			return;
+		case "clear":
+			if (change.count !== state.length) {
+				throw new Error("reactiveList clear change count does not match current state");
+			}
+			state.length = 0;
+			return;
+	}
+}
+
+function strictJsonEquals(a: unknown, b: unknown): boolean {
+	const left = strictCanonicalJsonBytes(a);
+	const right = strictCanonicalJsonBytes(b);
+	if (left.byteLength !== right.byteLength) return false;
+	for (let i = 0; i < left.byteLength; i += 1) if (left[i] !== right[i]) return false;
+	return true;
+}
+
+function findJsonIndex<T>(
+	values: readonly T[],
+	match: (value: T) => unknown,
+	key: unknown,
+	label: string,
+): number {
+	let found = -1;
+	for (let i = 0; i < values.length; i += 1) {
+		if (strictJsonEquals(match(values[i] as T), key)) {
+			if (found !== -1) throw new Error(`${label} duplicate JSON key in restore state`);
+			found = i;
+		}
+	}
+	return found;
+}
+
+function cmpOrd(a: unknown, b: unknown): number {
+	if (a === b) return 0;
+	const ta = typeof a;
+	if (
+		ta === typeof b &&
+		(ta === "number" || ta === "string" || ta === "boolean" || ta === "bigint")
+	) {
+		const ax = a as number | string | bigint | boolean;
+		const bx = b as number | string | bigint | boolean;
+		return ax < bx ? -1 : ax > bx ? 1 : 0;
+	}
+	return String(a).localeCompare(String(b));
+}
+
+function applyLogChange<T>(state: T[], change: LogChange<T>): void {
+	switch (change.kind) {
+		case "append":
+			state.push(change.value);
+			return;
+		case "appendMany":
+			state.push(...change.values);
+			return;
+		case "trimHead":
+			if (change.n > state.length) throw new Error("reactiveLog trimHead change is out of range");
+			state.splice(0, change.n);
+			return;
+		case "clear":
+			if (change.count !== state.length) {
+				throw new Error("reactiveLog clear change count does not match current state");
+			}
+			state.length = 0;
+			return;
+	}
+}
+
+function applyMapChange<K, V>(state: Array<readonly [K, V]>, change: MapChange<K, V>): void {
+	switch (change.kind) {
+		case "set": {
+			const index = findJsonIndex(state, ([key]) => key, change.key, "reactiveMap");
+			if (index === -1) state.push([change.key, change.value] as const);
+			else state[index] = [change.key, change.value] as const;
+			return;
+		}
+		case "delete": {
+			const index = findJsonIndex(state, ([key]) => key, change.key, "reactiveMap");
+			if (index === -1) throw new Error("reactiveMap delete change key is missing");
+			if (!strictJsonEquals(state[index]?.[1], change.previous)) {
+				throw new Error("reactiveMap delete change previous value does not match current state");
+			}
+			state.splice(index, 1);
+			return;
+		}
+		case "clear":
+			if (change.count !== state.length) {
+				throw new Error("reactiveMap clear change count does not match current state");
+			}
+			state.length = 0;
+			return;
+	}
+}
+
+function sortIndexRows<K, V>(state: Array<IndexRow<K, V>>): void {
+	state.sort((a, b) => {
+		const bySecondary = cmpOrd(a.secondary, b.secondary);
+		return bySecondary === 0 ? cmpOrd(a.primary, b.primary) : bySecondary;
+	});
+}
+
+function applyIndexChange<K, V>(state: Array<IndexRow<K, V>>, change: IndexChange<K, V>): void {
+	switch (change.kind) {
+		case "upsert": {
+			const index = findJsonIndex(state, (row) => row.primary, change.primary, "reactiveIndex");
+			const row: IndexRow<K, V> = {
+				primary: change.primary,
+				secondary: change.secondary,
+				value: change.value,
+			};
+			if (index === -1) state.push(row);
+			else state[index] = row;
+			sortIndexRows(state);
+			return;
+		}
+		case "delete": {
+			const index = findJsonIndex(state, (row) => row.primary, change.primary, "reactiveIndex");
+			if (index === -1) throw new Error("reactiveIndex delete change primary is missing");
+			state.splice(index, 1);
+			return;
+		}
+		case "deleteMany": {
+			for (const primary of change.primaries) {
+				const index = findJsonIndex(state, (row) => row.primary, primary, "reactiveIndex");
+				if (index === -1) {
+					throw new Error("reactiveIndex deleteMany change primary is missing");
+				}
+				state.splice(index, 1);
+			}
+			return;
+		}
+		case "clear":
+			if (change.count !== state.length) {
+				throw new Error("reactiveIndex clear change count does not match current state");
+			}
+			state.length = 0;
+			return;
+	}
+}
+
+function finishState<K extends ReactiveCollectionStorageKind, T>(
+	kind: K,
+	state: T[],
+	snapshotFound: boolean,
+	snapshotCursor: number,
+	applied: number,
+	cursor: number,
+): ReactiveCollectionRestoreState<K, readonly T[]> {
+	return {
+		kind,
+		state,
+		source: snapshotFound
+			? applied > 0
+				? "snapshot+changes"
+				: "snapshot"
+			: applied > 0
+				? "changes"
+				: "empty",
+		snapshot: { found: snapshotFound, changeCursor: snapshotCursor },
+		changes: { applied, cursor },
+	};
+}
+
+function loadState<K extends ReactiveCollectionStorageKind, T, C>(
+	kind: K,
+	opts: LoadReactiveCollectionStateOptions,
+	assertSnapshot: (value: unknown) => readonly T[],
+	assertChange: (value: unknown) => C,
+	applyChange: (state: T[], change: C) => void,
+): Promise<ReactiveCollectionRestoreState<K, readonly T[]>> {
+	const key = opts.snapshotKey ?? collectionSnapshotKey(opts.storagePrefix);
+	return opts.snapshotStore.get(key).then((snapshotValue) => {
+		let snapshotFound = false;
+		let snapshotCursor = -1;
+		let state: T[] = [];
+
+		if (snapshotValue !== undefined) {
+			const frame = assertReactiveCollectionSnapshotFrame<K, readonly T[]>(snapshotValue, kind);
+			state = [...assertSnapshot(frame.snapshot)];
+			snapshotFound = true;
+			snapshotCursor = frame.changeCursor;
+		}
+
+		if (opts.changeLog === undefined) {
+			return finishState(kind, state, snapshotFound, snapshotCursor, 0, snapshotCursor);
+		}
+
+		return opts.changeLog.read({ after: snapshotCursor }).then((entries) => {
+			let applied = 0;
+			let cursor = snapshotCursor;
+			for (const entry of entries) {
+				const expectedSeq = cursor + 1;
+				if (!Number.isSafeInteger(entry.seq) || entry.seq !== expectedSeq) {
+					throw new Error(
+						`reactive collection change log is non-contiguous: expected seq ${expectedSeq}, got ${entry.seq}`,
+					);
+				}
+				const frame = assertReactiveCollectionChangeFrame<K, C>(entry.value, kind);
+				const change = assertChange(frame.change);
+				applyChange(state, change);
+				applied += 1;
+				cursor = entry.seq;
+			}
+			return finishState(kind, state, snapshotFound, snapshotCursor, applied, cursor);
+		});
+	});
+}
+
+/** D161 passive load/fold for reactiveList; reads storage but never mutates graph topology. */
+export function loadReactiveListState<T = unknown>(
+	opts: LoadReactiveCollectionStateOptions,
+): Promise<ReactiveListRestoreState<T>> {
+	return loadState<"reactiveList", T, ListChange<T>>(
+		"reactiveList",
+		opts,
+		(value) => assertArray<T>(value, "reactiveList snapshot"),
+		assertListChange,
+		applyListChange,
+	);
+}
+
+/** D161 passive load/fold for reactiveLog; reads storage but never mutates graph topology. */
+export function loadReactiveLogState<T = unknown>(
+	opts: LoadReactiveCollectionStateOptions,
+): Promise<ReactiveLogRestoreState<T>> {
+	return loadState<"reactiveLog", T, LogChange<T>>(
+		"reactiveLog",
+		opts,
+		(value) => assertArray<T>(value, "reactiveLog snapshot"),
+		assertLogChange,
+		applyLogChange,
+	);
+}
+
+/** D161 passive load/fold scaffold for reactiveMap; synchronous policy restore is deferred. */
+export function loadReactiveMapState<K = unknown, V = unknown>(
+	opts: LoadReactiveCollectionStateOptions,
+): Promise<ReactiveMapRestoreState<K, V>> {
+	return loadState<"reactiveMap", readonly [K, V], MapChange<K, V>>(
+		"reactiveMap",
+		opts,
+		(value) => assertEntryArray<K, V>(value, "reactiveMap snapshot"),
+		assertMapChange,
+		applyMapChange,
+	);
+}
+
+/** D161 passive load/fold scaffold for reactiveIndex; key-codec restore is deferred. */
+export function loadReactiveIndexState<K = unknown, V = unknown>(
+	opts: LoadReactiveCollectionStateOptions,
+): Promise<ReactiveIndexRestoreState<K, V>> {
+	return loadState<"reactiveIndex", IndexRow<K, V>, IndexChange<K, V>>(
+		"reactiveIndex",
+		opts,
+		(value) => assertIndexRows<K, V>(value, "reactiveIndex snapshot"),
+		assertIndexChange,
+		applyIndexChange,
+	);
+}
diff --git a/packages/ts/src/storage/read-through.ts b/packages/ts/src/storage/read-through.ts
new file mode 100644
index 00000000..d1929e9c
--- /dev/null
+++ b/packages/ts/src/storage/read-through.ts
@@ -0,0 +1,266 @@
+import { hasKvVersioned, type KvGeneration, type KvStorageTier } from "./kv.js";
+
+/** Result tier for read-through output facts. */
+export interface ReadThroughLookupTier {
+	/** Tier index in the ordered lookup list. `-1` = optional loader fallback. */
+	readonly index: number;
+	/** Optional human-facing tier name. */
+	readonly name?: string;
+}
+
+/** Ordered lookup result from a single tier or loader attempt. */
+type ReadThroughOutcome = "hit" | "miss" | "error";
+
+/** Fact for one lookup attempt (one tier or the optional loader fallback). */
+export interface ReadThroughLookupFact<T> {
+	readonly kind: ReadThroughOutcome;
+	readonly key: string;
+	readonly tier: ReadThroughLookupTier;
+	readonly value?: T;
+	readonly generation?: KvGeneration;
+	readonly error?: unknown;
+}
+
+/** Result of one promotion write attempt to an earlier tier. */
+export interface ReadThroughPromotionFact {
+	readonly tier: ReadThroughLookupTier;
+	readonly ok: boolean;
+	readonly error?: unknown;
+}
+
+/** Final read-through outcome, with explicit lookup facts and promotion facts. */
+export interface TieredReadThroughResult<T> {
+	readonly status: "hit" | "miss" | "error";
+	readonly key: string;
+	readonly value?: T;
+	readonly hitTier?: ReadThroughLookupTier;
+	readonly facts: readonly ReadThroughLookupFact<T>[];
+	readonly promotions: readonly ReadThroughPromotionFact[];
+}
+
+/** Optional hook/context for lookup misses. */
+export interface ReadThroughMissContext {
+	readonly key: string;
+	readonly tier: ReadThroughLookupTier;
+}
+
+/** Optional hook/context for get/load/promotion errors. */
+export interface ReadThroughErrorContext {
+	readonly key: string;
+	readonly tier: ReadThroughLookupTier;
+	readonly stage: "lookup" | "promotion";
+	readonly error: unknown;
+}
+
+/** Configuration for `tieredReadThrough`. */
+export interface TieredReadThroughOptions<T> {
+	/** Lookup key for all tiers. */
+	readonly key: string;
+	/** Ordered lookup tiers, index 0 = hottest/fastest. */
+	readonly tiers: readonly KvStorageTier<T>[];
+	/** Optional friendly tier names, matched by index. */
+	readonly tierNames?: readonly string[];
+	/**
+	 * Optional loader fallback for cache-miss. If provided and no tier hits, this runs
+	 * after all tiers are checked and may write-through by promotion logic.
+	 */
+	readonly load?: (key: string) => Promise<T | undefined> | T | undefined;
+	/**
+	 * Optional promotion policy: set hit values to earlier (lower-index) tiers.
+	 * `false` disables promotion; default promotes to all earlier tiers on any hit.
+	 * Explicit indices can narrow promotion targets.
+	 */
+	readonly promoteTo?: readonly number[] | false;
+	/** Optional callbacks for control-plane observability. */
+	readonly onMiss?: (context: ReadThroughMissContext) => void;
+	/** Called for lookup/load errors and promotion failures by default. */
+	readonly onError?: (context: ReadThroughErrorContext) => void;
+}
+
+function defer<T>(fn: () => T | PromiseLike<T>): Promise<T> {
+	return Promise.resolve().then(fn);
+}
+
+/** Alias for callers that prefer loader-oriented naming. */
+export function readThroughKv<T>(
+	opts: TieredReadThroughOptions<T>,
+): Promise<TieredReadThroughResult<T>> {
+	return tieredReadThrough(opts);
+}
+
+/**
+ * Build explicit lookup facts across tiers plus optional loader fallback (D104 layer 1).
+ *
+ * This is a passive storage/domain helper: it creates no graph nodes, performs no hydration or
+ * restore, and treats promotion writes as facts rather than a graph commit barrier.
+ */
+export function tieredReadThrough<T>(
+	opts: TieredReadThroughOptions<T>,
+): Promise<TieredReadThroughResult<T>> {
+	const { key, tiers, tierNames = [], load, promoteTo, onMiss, onError } = opts;
+
+	const lookupFacts: ReadThroughLookupFact<T>[] = [];
+	const promotions: ReadThroughPromotionFact[] = [];
+	let hitTier: ReadThroughLookupTier | undefined;
+	let value: T | undefined;
+
+	const safeOnMiss = (tier: ReadThroughLookupTier): void => {
+		if (!onMiss) return;
+		try {
+			onMiss({ key, tier });
+		} catch {
+			/* no-op */
+		}
+	};
+
+	const safeOnError = (context: ReadThroughErrorContext): void => {
+		if (!onError) return;
+		try {
+			onError(context);
+		} catch {
+			/* no-op */
+		}
+	};
+
+	const addFact = (fact: ReadThroughLookupFact<T>): void => {
+		lookupFacts.push(fact);
+	};
+
+	const lookupTier = (index: number): ReadThroughLookupTier => ({
+		index,
+		name: tierNames[index],
+	});
+
+	const lookupNext = (index: number): Promise<void> => {
+		if (hitTier !== undefined || index >= tiers.length) return defer(() => undefined);
+		const tier = tiers[index]!;
+		const info = lookupTier(index);
+		const read = hasKvVersioned(tier)
+			? defer(() => tier.getVersioned(key)).then((result) => {
+					if (result.kind === "miss") {
+						return { found: undefined, generation: result.generation } as const;
+					}
+					return { found: result.value, generation: result.generation } as const;
+				})
+			: defer(() => tier.get(key)).then((found) => ({ found, generation: undefined }) as const);
+		return read
+			.then(({ found, generation }) => {
+				if (found === undefined) {
+					addFact({ kind: "miss", key, tier: info, generation });
+					safeOnMiss(info);
+					return lookupNext(index + 1);
+				}
+				addFact({ kind: "hit", key, tier: info, value: found, generation });
+				hitTier = info;
+				value = found;
+			})
+			.catch((error) => {
+				addFact({ kind: "error", key, tier: info, error });
+				safeOnError({ key, tier: info, stage: "lookup", error });
+				return lookupNext(index + 1);
+			});
+	};
+
+	const runLoader = (): Promise<void> => {
+		if (hitTier !== undefined || typeof load !== "function") return defer(() => undefined);
+		const loaderTier: ReadThroughLookupTier = { index: -1, name: "load" };
+		return defer(() => load(key))
+			.then((loaded) => {
+				if (loaded === undefined) {
+					addFact({ kind: "miss", key, tier: loaderTier });
+					safeOnMiss(loaderTier);
+					return;
+				}
+				addFact({ kind: "hit", key, tier: loaderTier, value: loaded });
+				hitTier = loaderTier;
+				value = loaded;
+			})
+			.catch((error) => {
+				addFact({ kind: "error", key, tier: loaderTier, error });
+				safeOnError({ key, tier: loaderTier, stage: "lookup", error });
+			});
+	};
+
+	const promoteNext = (targets: readonly number[], offset: number): Promise<void> => {
+		if (offset >= targets.length || value === undefined) return defer(() => undefined);
+		const index = targets[offset]!;
+		const info = { index, name: tierNames[index] };
+		const tier = tiers[index]!;
+		const generation = generationForTier(lookupFacts, index);
+		const write = hasKvVersioned(tier)
+			? generation === undefined
+				? defer<boolean>(() => {
+						throw new Error(
+							"tieredReadThrough: versioned promotion target was not observed with a generation",
+						);
+					})
+				: defer(() => tier.setIfMatch(key, value as T, generation))
+			: defer(() => tier.set(key, value as T)).then(() => true);
+		return write
+			.then((ok) => {
+				promotions.push({ tier: info, ok });
+			})
+			.catch((error) => {
+				promotions.push({ tier: info, ok: false, error });
+				safeOnError({ key, tier: info, stage: "promotion", error });
+			})
+			.then(() => promoteNext(targets, offset + 1));
+	};
+
+	const promote = (): Promise<void> => {
+		if (hitTier === undefined || value === undefined) return defer(() => undefined);
+		const sourceIndex = hitTier.index === -1 ? tiers.length : hitTier.index;
+		const targets = buildPromotionTargets(tiers.length, sourceIndex, promoteTo);
+		return promoteNext(targets, 0);
+	};
+
+	const result = (): TieredReadThroughResult<T> => {
+		const status: TieredReadThroughResult<T>["status"] = (() => {
+			if (hitTier !== undefined && hitTier.index >= -1 && value !== undefined) return "hit";
+			if (lookupFacts.some((fact) => fact.kind === "error")) return "error";
+			return "miss";
+		})();
+
+		return {
+			status,
+			key,
+			value,
+			hitTier,
+			facts: lookupFacts,
+			promotions,
+		};
+	};
+
+	return lookupNext(0).then(runLoader).then(promote).then(result);
+}
+
+function generationForTier<T>(
+	facts: readonly ReadThroughLookupFact<T>[],
+	index: number,
+): KvGeneration | undefined {
+	return facts.find((fact) => fact.tier.index === index)?.generation;
+}
+
+function buildPromotionTargets(
+	tierCount: number,
+	hitIndex: number,
+	promoteTo?: readonly number[] | false,
+): number[] {
+	if (promoteTo === false || tierCount <= 0) return [];
+	const maxPromote = Math.max(0, Math.min(hitIndex, tierCount));
+	if (promoteTo === undefined) {
+		return [...Array(maxPromote).keys()];
+	}
+	const normalized: number[] = [];
+	const seen = new Set<number>();
+	for (const index of promoteTo) {
+		if (!Number.isSafeInteger(index) || index < 0 || index >= tierCount || index >= maxPromote) {
+			continue;
+		}
+		if (!seen.has(index)) {
+			seen.add(index);
+			normalized.push(index);
+		}
+	}
+	return normalized;
+}
diff --git a/packages/ts/src/storage/scalar.ts b/packages/ts/src/storage/scalar.ts
new file mode 100644
index 00000000..fc1b73b7
--- /dev/null
+++ b/packages/ts/src/storage/scalar.ts
@@ -0,0 +1,69 @@
+/**
+ * Storage scalar helpers (D88): host BigInt in memory, canonical decimal strings on JSON/storage.
+ */
+
+/** Canonical decimal integer string; no leading zeroes, and no negative zero. */
+export type DecimalIntegerString = string;
+
+/** Canonical non-negative decimal integer string. */
+export type NonNegativeDecimalIntegerString = DecimalIntegerString;
+
+const DECIMAL_INTEGER_RE = /^(0|-?[1-9]\d*)$/;
+const NON_NEGATIVE_DECIMAL_INTEGER_RE = /^(0|[1-9]\d*)$/;
+
+/** Test whether a value is a canonical decimal integer string. */
+export function isDecimalIntegerString(value: unknown): value is DecimalIntegerString {
+	return typeof value === "string" && DECIMAL_INTEGER_RE.test(value);
+}
+
+/** Test whether a value is a canonical non-negative decimal integer string. */
+export function isNonNegativeDecimalIntegerString(
+	value: unknown,
+): value is NonNegativeDecimalIntegerString {
+	return typeof value === "string" && NON_NEGATIVE_DECIMAL_INTEGER_RE.test(value);
+}
+
+/** Assert a canonical decimal integer string and return it typed. */
+export function assertDecimalIntegerString(
+	value: unknown,
+	label = "decimal integer",
+): DecimalIntegerString {
+	if (!isDecimalIntegerString(value)) {
+		throw new TypeError(`${label} must be a canonical decimal integer string`);
+	}
+	return value;
+}
+
+/** Assert a canonical non-negative decimal integer string and return it typed. */
+export function assertNonNegativeDecimalIntegerString(
+	value: unknown,
+	label = "decimal integer",
+): NonNegativeDecimalIntegerString {
+	if (!isNonNegativeDecimalIntegerString(value)) {
+		throw new TypeError(`${label} must be a canonical non-negative decimal integer string`);
+	}
+	return value;
+}
+
+/** Convert a host BigInt to the canonical decimal storage scalar. */
+export function bigIntToDecimalString(value: bigint): DecimalIntegerString {
+	return value.toString();
+}
+
+/** Convert a non-negative host BigInt to the canonical non-negative decimal storage scalar. */
+export function bigIntToNonNegativeDecimalString(value: bigint): NonNegativeDecimalIntegerString {
+	if (value < 0n) {
+		throw new TypeError("decimal integer must be non-negative");
+	}
+	return value.toString();
+}
+
+/** Parse a canonical decimal storage scalar into host BigInt. */
+export function decimalStringToBigInt(value: DecimalIntegerString): bigint {
+	return BigInt(assertDecimalIntegerString(value));
+}
+
+/** Parse a canonical non-negative decimal storage scalar into host BigInt. */
+export function nonNegativeDecimalStringToBigInt(value: NonNegativeDecimalIntegerString): bigint {
+	return BigInt(assertNonNegativeDecimalIntegerString(value));
+}
diff --git a/packages/ts/src/storage/wal.ts b/packages/ts/src/storage/wal.ts
new file mode 100644
index 00000000..86f5ea00
--- /dev/null
+++ b/packages/ts/src/storage/wal.ts
@@ -0,0 +1,209 @@
+import { strictCanonicalJsonBytes, strictJsonCodecFor } from "../json/codec.js";
+import type { ChangeLifecycle, StorageTimestampNs } from "./change.js";
+import { nowNs } from "./change.js";
+import type { Codec } from "./codec.js";
+import {
+	assertNonNegativeDecimalIntegerString,
+	type NonNegativeDecimalIntegerString,
+} from "./scalar.js";
+
+/** Storage key segment for passive WAL frame facts. */
+export const WAL_KEY_SEGMENT = "wal";
+
+/** Decimal sequence padding for lexicographically ordered WAL frame keys. */
+export const WAL_FRAME_SEQ_PAD = 20;
+
+/** First passive WAL frame format version. */
+export const WAL_FORMAT_VERSION = 1;
+
+/** Passive WAL frame body; this is a storage fact, not graph restore input. */
+export interface WalFrameBody<T = unknown> {
+	readonly t: "c";
+	readonly lifecycle: ChangeLifecycle;
+	readonly path: string;
+	readonly change: T;
+	readonly frame_seq: number;
+	readonly frame_t_ns: StorageTimestampNs;
+	readonly format_version: typeof WAL_FORMAT_VERSION;
+}
+
+/** Checksummed passive WAL frame. */
+export interface WalFrame<T = unknown> extends WalFrameBody<T> {
+	readonly checksum: string;
+}
+
+/** Options for constructing a passive WAL frame. */
+export interface WalFrameOptions<T = unknown> {
+	readonly path: string;
+	readonly change: T;
+	readonly frame_seq: number;
+	readonly lifecycle?: ChangeLifecycle;
+	readonly frame_t_ns?: StorageTimestampNs;
+}
+
+const SHA_256 = "SHA-256";
+const HEX_TABLE = Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
+const CHECKSUM_RE = /^[0-9a-f]{64}$/;
+const WAL_BODY_KEYS = new Set([
+	"t",
+	"lifecycle",
+	"path",
+	"change",
+	"frame_seq",
+	"frame_t_ns",
+	"format_version",
+]);
+const WAL_FRAME_KEYS = new Set([...WAL_BODY_KEYS, "checksum"]);
+
+function bytesToHex(bytes: Uint8Array): string {
+	let out = "";
+	for (const byte of bytes) out += HEX_TABLE[byte];
+	return out;
+}
+
+function sha256Hex(data: Uint8Array): Promise<string> {
+	const digestInput = Uint8Array.from(data);
+	return globalThis.crypto.subtle
+		.digest(SHA_256, digestInput)
+		.then((buf) => bytesToHex(new Uint8Array(buf)));
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+function isLifecycle(value: unknown): value is ChangeLifecycle {
+	return value === "spec" || value === "data" || value === "ownership";
+}
+
+function assertOnlyKeys(value: Record<string, unknown>, allowed: ReadonlySet<string>): void {
+	for (const key of Object.keys(value)) {
+		if (!allowed.has(key)) throw new TypeError(`walFrameCodec: unknown field ${key}`);
+	}
+}
+
+function assertFrameSeq(value: unknown, label: string): number {
+	if (!Number.isSafeInteger(value) || (value as number) < 0) {
+		throw new TypeError(`${label} must be a non-negative safe integer`);
+	}
+	return value as number;
+}
+
+function assertWalFrameBody<T = unknown>(
+	value: unknown,
+	allowedKeys: ReadonlySet<string> = WAL_BODY_KEYS,
+): WalFrameBody<T> {
+	if (!isRecord(value)) throw new TypeError("walFrameCodec: frame must be an object");
+	assertOnlyKeys(value, allowedKeys);
+	if (value.t !== "c") throw new TypeError("walFrameCodec: t must be c");
+	if (!isLifecycle(value.lifecycle)) {
+		throw new TypeError("walFrameCodec: lifecycle must be spec, data, or ownership");
+	}
+	if (typeof value.path !== "string" || value.path.length === 0) {
+		throw new TypeError("walFrameCodec: path must be a non-empty string");
+	}
+	if (!Object.hasOwn(value, "change")) {
+		throw new TypeError("walFrameCodec: change payload is required");
+	}
+	const frameSeq = assertFrameSeq(value.frame_seq, "walFrameCodec: frame_seq");
+	const frameTimestamp = assertNonNegativeDecimalIntegerString(
+		value.frame_t_ns,
+		"walFrameCodec: frame_t_ns",
+	);
+	if (value.format_version !== WAL_FORMAT_VERSION) {
+		throw new TypeError(`walFrameCodec: format_version must be ${WAL_FORMAT_VERSION}`);
+	}
+	return {
+		t: "c",
+		lifecycle: value.lifecycle,
+		path: value.path,
+		change: value.change as T,
+		frame_seq: frameSeq,
+		frame_t_ns: frameTimestamp,
+		format_version: WAL_FORMAT_VERSION,
+	};
+}
+
+/** Build the namespace prefix for passive WAL frame keys. */
+export function walFramePrefix(namespace: string): string {
+	if (namespace.length === 0) return WAL_KEY_SEGMENT;
+	return `${namespace}/${WAL_KEY_SEGMENT}`;
+}
+
+/** Build the deterministic storage key for a WAL frame sequence number. */
+export function walFrameKey(prefix: string, frameSeq: number): string {
+	if (!Number.isSafeInteger(frameSeq) || frameSeq < 0) {
+		throw new RangeError(
+			`walFrameKey: frameSeq must be a non-negative safe integer, got ${frameSeq}`,
+		);
+	}
+	return `${prefix}/${frameSeq.toString().padStart(WAL_FRAME_SEQ_PAD, "0")}`;
+}
+
+/** Hash the canonical WAL frame body, excluding the checksum field itself. */
+export function walFrameChecksum<T = unknown>(body: WalFrameBody<T>): Promise<string> {
+	let bytes: Uint8Array;
+	try {
+		bytes = strictCanonicalJsonBytes(assertWalFrameBody<T>(body));
+	} catch (err) {
+		return Promise.resolve().then(() => {
+			throw err;
+		});
+	}
+	return sha256Hex(bytes);
+}
+
+/** Construct a passive WAL frame with a canonical checksum. */
+export function walFrame<T = unknown>(opts: WalFrameOptions<T>): Promise<WalFrame<T>> {
+	const body: WalFrameBody<T> = {
+		t: "c",
+		lifecycle: opts.lifecycle ?? "data",
+		path: opts.path,
+		change: opts.change,
+		frame_seq: opts.frame_seq,
+		frame_t_ns: opts.frame_t_ns ?? nowNs(),
+		format_version: WAL_FORMAT_VERSION,
+	};
+	return walFrameChecksum(body).then((checksum) => ({ ...body, checksum }));
+}
+
+/** Validate a decoded passive WAL frame without verifying its checksum bytes. */
+export function assertWalFrame<T = unknown>(value: unknown): WalFrame<T> {
+	if (!isRecord(value)) throw new TypeError("walFrameCodec: frame must be an object");
+	assertOnlyKeys(value, WAL_FRAME_KEYS);
+	const body = assertWalFrameBody<T>(value, WAL_FRAME_KEYS);
+	const checksum = (value as Record<string, unknown>).checksum;
+	if (typeof checksum !== "string" || !CHECKSUM_RE.test(checksum)) {
+		throw new TypeError("walFrameCodec: checksum must be a lowercase sha256 hex string");
+	}
+	return { ...body, checksum } as WalFrame<T>;
+}
+
+/** Verify that a passive WAL frame checksum matches its body. */
+export function verifyWalFrameChecksum<T = unknown>(frame: WalFrame<T>): Promise<boolean> {
+	let checked: WalFrame<T>;
+	try {
+		checked = assertWalFrame<T>(frame);
+	} catch (err) {
+		return Promise.resolve().then(() => {
+			throw err;
+		});
+	}
+	const { checksum, ...body } = checked;
+	return walFrameChecksum(body).then((expected) => expected === checksum);
+}
+
+/** Strict canonical JSON codec for passive WAL frames; this is not a restore codec. */
+export function walFrameCodec<T = unknown>(): Codec<WalFrame<T>> {
+	const codec = strictJsonCodecFor<unknown>();
+	return {
+		encode(value) {
+			return codec.encode(assertWalFrame(value));
+		},
+		decode(bytes) {
+			return assertWalFrame<T>(codec.decode(bytes));
+		},
+	};
+}
+
+export type WalFrameTimestampNs = NonNegativeDecimalIntegerString;
diff --git a/packages/ts/src/testing/assertions.ts b/packages/ts/src/testing/assertions.ts
new file mode 100644
index 00000000..73287a60
--- /dev/null
+++ b/packages/ts/src/testing/assertions.ts
@@ -0,0 +1,64 @@
+/**
+ * Public testing assertions for clean-slate GraphReFly message streams.
+ *
+ * These helpers validate captured protocol output; they do not participate in propagation.
+ */
+
+import { isValueTier, type Message, type Wave } from "../protocol/messages.js";
+
+/** Captured subscriber messages grouped by wave. START/replay handshake messages occupy one wave. */
+export type MessageSequence = readonly Wave[];
+
+/**
+ * Assert that observed tier-3 settlements (DATA/RESOLVED) are preceded by DIRTY.
+ *
+ * This encodes R-dirty-before-data for wave-framed subscriber traces. The leading
+ * START push-on-subscribe/replay handshake wave is exempt because cached/replay DATA is
+ * advertised to a new subscriber without opening a propagation wave.
+ */
+export function assertDirtyPrecedesTerminalData(messages: MessageSequence): void {
+	for (let waveIndex = 0; waveIndex < messages.length; waveIndex += 1) {
+		const wave = messages[waveIndex];
+		let handshake = false;
+		let openedByDirty = false;
+
+		for (let msgIndex = 0; msgIndex < wave.length; msgIndex += 1) {
+			const msg = wave[msgIndex] as Message;
+			const type = msg[0];
+
+			if (msgIndex === 0 && type === "START") {
+				handshake = true;
+				continue;
+			}
+
+			if (handshake && type === "DATA") {
+				continue;
+			}
+			handshake = false;
+
+			if (type === "DIRTY") {
+				openedByDirty = true;
+				continue;
+			}
+
+			if (isValueTier(type)) {
+				if (!openedByDirty) {
+					throw new Error(
+						`assertDirtyPrecedesTerminalData: ${type} at wave ${waveIndex}, index ${msgIndex} arrived without a preceding DIRTY in the same wave (R-dirty-before-data). Wave: ${describeWave(wave, msgIndex)}`,
+					);
+				}
+				continue;
+			}
+
+			openedByDirty = false;
+		}
+	}
+}
+
+function describeWave(wave: Wave, around: number): string {
+	const parts: string[] = [];
+	for (let i = 0; i < wave.length; i += 1) {
+		parts.push(`${i === around ? "-> " : "   "}[${wave[i]?.[0] ?? "?"}]`);
+	}
+	return parts.join(", ");
+}
diff --git a/packages/ts/src/testing/index.ts b/packages/ts/src/testing/index.ts
new file mode 100644
index 00000000..5237f759
--- /dev/null
+++ b/packages/ts/src/testing/index.ts
@@ -0,0 +1,4 @@
+export {
+	assertDirtyPrecedesTerminalData,
+	type MessageSequence,
+} from "./assertions.js";
diff --git a/packages/ts/src/work-queue/index.ts b/packages/ts/src/work-queue/index.ts
new file mode 100644
index 00000000..a5bb1bea
--- /dev/null
+++ b/packages/ts/src/work-queue/index.ts
@@ -0,0 +1,964 @@
+/**
+ * MessageBus-backed generic work queue (D299-D324).
+ *
+ * The queue core is graph-visible facts: commands, records, status, issues. It is intentionally
+ * independent from orchestration/WorkItem/executor registries.
+ */
+
+import { depBatch } from "../ctx/types.js";
+import type { DataIssue } from "../data/index.js";
+import type { Graph } from "../graph/graph.js";
+import type {
+	MessageBusAvailablePage,
+	MessageBusCommand,
+	MessageBusMessage,
+	MessageBusStatus,
+} from "../messaging/index.js";
+import { attachMessageBusDeferredCommandSink } from "../messaging/internal.js";
+import { availablePage, deadLetterPage, workSnapshot } from "./projections.js";
+import type { QueueEvent, RuntimeState, WorkState } from "./runtime-types.js";
+import type {
+	WorkQueue,
+	WorkQueueAvailablePage,
+	WorkQueueAvailableParams,
+	WorkQueueCommand,
+	WorkQueueDeadLetterPage,
+	WorkQueueDeadLetterParams,
+	WorkQueueOptions,
+	WorkQueueRecord,
+	WorkQueueRetryPolicy,
+	WorkQueueStatus,
+	WorkQueueWorkSnapshot,
+} from "./types.js";
+import {
+	appendRecord,
+	assertNonEmpty,
+	clearLease,
+	commandNowMs,
+	decodeSubmittedPayload,
+	isExpiredLease,
+	isReady,
+	issueEvent,
+	isTerminal,
+	materializeLeaseExpired,
+	nextCommandId,
+	numberOrUndefined,
+	payloadAsRecord,
+	positiveLimit,
+	publishQueueCommand,
+	pullParams,
+	recordEvent,
+	rejectQueueCommand,
+	statusEvent,
+	stringArrayOrUndefined,
+	submitPayload,
+	validateQueueCommand,
+} from "./utils.js";
+
+export type {
+	WorkQueue,
+	WorkQueueAvailableItem,
+	WorkQueueAvailablePage,
+	WorkQueueAvailableParams,
+	WorkQueueAvailableProjection,
+	WorkQueueCommand,
+	WorkQueueDeadLetterPage,
+	WorkQueueDeadLetterParams,
+	WorkQueueDerivedState,
+	WorkQueueOptions,
+	WorkQueueProjection,
+	WorkQueueRecord,
+	WorkQueueRetryPolicy,
+	WorkQueueStatus,
+	WorkQueueWorkSnapshot,
+} from "./types.js";
+
+export function workQueue<T = unknown>(graph: Graph, opts: WorkQueueOptions<T>): WorkQueue<T> {
+	assertNonEmpty(opts.queueId, "workQueue.queueId");
+	assertNonEmpty(opts.topic, "workQueue.topic");
+	assertNonEmpty(opts.subscriptionId, "workQueue.subscriptionId");
+	const name = opts.name ?? `workQueue/${opts.queueId}`;
+	const now = opts.now ?? Date.now;
+	const leaseDurationMs = opts.leaseDurationMs ?? 30_000;
+	const retry = opts.retry ?? { maxAttempts: 3, delayMs: 0 };
+	const admission = opts.bus.subscription<T>({
+		topic: opts.topic,
+		subscriptionId: opts.subscriptionId,
+		from: opts.from ?? "earliest",
+		name: `${name}/admission`,
+	});
+	const commands = graph.node<WorkQueueCommand<T>>(
+		[],
+		(ctx) => {
+			for (const command of depBatch(ctx, 0) ?? []) ctx.down([["DATA", command]]);
+		},
+		{
+			name: `${name}/commands`,
+			factory: "workQueueCommands",
+			completeWhenDepsComplete: false,
+			errorWhenDepsError: false,
+		},
+	);
+	const state: RuntimeState<T> = {
+		recordSeq: 0,
+		leaseSeq: 0,
+		works: new Map(),
+		sourceSeqs: new Set(),
+		commandIds: new Set(),
+		idempotencyKeys: new Set(),
+		records: [],
+		deadLetters: [],
+	};
+	const admissionKick = graph.node<"poll">([], null, {
+		name: `${name}/admissionKick`,
+		factory: "workQueueAdmissionKick",
+		initial: "poll",
+		completeWhenDepsComplete: false,
+		errorWhenDepsError: false,
+	});
+	const admissionPages = graph.node<MessageBusAvailablePage<T>>(
+		[admission.available, admissionKick, opts.bus.messages, opts.bus.status],
+		(ctx) => {
+			for (const page of depBatch(ctx, 0) ?? []) {
+				ctx.down([["DATA", page as MessageBusAvailablePage<T>]]);
+			}
+			let shouldPull = (depBatch(ctx, 1)?.length ?? 0) > 0;
+			for (const message of depBatch(ctx, 2) ?? []) {
+				if ((message as MessageBusMessage<T>).topic === opts.topic) shouldPull = true;
+			}
+			for (const status of depBatch(ctx, 3) ?? []) {
+				if (shouldPollAdmission(status as MessageBusStatus, opts.topic, opts.subscriptionId)) {
+					shouldPull = true;
+				}
+			}
+			if (shouldPull) {
+				ctx.upNext([["PULL", { pullId: admission.availablePullId, params: { limit: 100 } }]], 0);
+			}
+		},
+		{
+			name: `${name}/admissionPages`,
+			factory: "workQueueAdmissionPages",
+			partial: true,
+			completeWhenDepsComplete: false,
+			errorWhenDepsError: false,
+		},
+	);
+	const runtime = graph.node<QueueEvent<T>>(
+		[commands, admissionPages],
+		(ctx) => {
+			for (const page of depBatch(ctx, 1) ?? []) {
+				for (const msg of (page as MessageBusAvailablePage<T>).messages) {
+					for (const event of admitMessage(opts, state, msg, now())) ctx.down([["DATA", event]]);
+				}
+			}
+			for (const command of depBatch(ctx, 0) ?? []) {
+				const commandTime = commandNowMs(command as WorkQueueCommand<T>, now());
+				for (const event of reduceQueueCommand(
+					opts,
+					state,
+					command as WorkQueueCommand<T>,
+					commandTime,
+					leaseDurationMs,
+					retry,
+				)) {
+					ctx.down([["DATA", event]]);
+				}
+			}
+		},
+		{
+			name: `${name}/runtime`,
+			factory: "workQueueRuntime",
+			partial: true,
+			completeWhenDepsComplete: false,
+			errorWhenDepsError: false,
+		},
+	);
+	const records = graph.node<WorkQueueRecord<T>>(
+		[runtime],
+		(ctx) => {
+			for (const event of depBatch(ctx, 0) ?? []) {
+				const typed = event as QueueEvent<T>;
+				if (typed.kind === "record") ctx.down([["DATA", typed.record]]);
+			}
+		},
+		{
+			name: `${name}/records`,
+			factory: "workQueueRecords",
+			completeWhenDepsComplete: false,
+			errorWhenDepsError: false,
+		},
+	);
+	const status = graph.node<WorkQueueStatus>(
+		[runtime],
+		(ctx) => {
+			for (const event of depBatch(ctx, 0) ?? []) {
+				const typed = event as QueueEvent<T>;
+				if (typed.kind === "status") ctx.down([["DATA", typed.status]]);
+			}
+		},
+		{
+			name: `${name}/status`,
+			factory: "workQueueStatus",
+			completeWhenDepsComplete: false,
+			errorWhenDepsError: false,
+		},
+	);
+	const issues = graph.node<DataIssue>(
+		[runtime],
+		(ctx) => {
+			for (const event of depBatch(ctx, 0) ?? []) {
+				const typed = event as QueueEvent<T>;
+				if (typed.kind === "issue") ctx.down([["DATA", typed.issue]]);
+			}
+		},
+		{
+			name: `${name}/issues`,
+			factory: "workQueueIssues",
+			completeWhenDepsComplete: false,
+			errorWhenDepsError: false,
+		},
+	);
+	const admissionAckCommands = graph.node<MessageBusCommand>(
+		[records],
+		(ctx) => {
+			for (const record of depBatch(ctx, 0) ?? []) {
+				const command = admissionAckCommand(record as WorkQueueRecord<T>);
+				if (command !== undefined) ctx.down([["DATA", command]]);
+			}
+		},
+		{
+			name: `${name}/admissionAckCommands`,
+			factory: "workQueueAdmissionAckCommands",
+			completeWhenDepsComplete: false,
+			errorWhenDepsError: false,
+		},
+	);
+	attachMessageBusDeferredCommandSink(graph, opts.bus, admissionAckCommands);
+	graph.retain(runtime, { reason: `${name}.workQueue.runtime` });
+	const queue: WorkQueue<T> = {
+		commands,
+		records,
+		status,
+		issues,
+		submit(payload, submitOpts = {}) {
+			const command = opts.bus.publish(
+				opts.topic,
+				submitPayload(payload, {
+					...(submitOpts.workId === undefined ? {} : { workId: submitOpts.workId }),
+					...(submitOpts.priority === undefined ? {} : { priority: submitOpts.priority }),
+					...(submitOpts.tags === undefined ? {} : { tags: submitOpts.tags }),
+					...(submitOpts.requirements === undefined
+						? {}
+						: { requirements: submitOpts.requirements }),
+					...(submitOpts.notBeforeMs === undefined ? {} : { notBeforeMs: submitOpts.notBeforeMs }),
+					...(submitOpts.deadlineMs === undefined ? {} : { deadlineMs: submitOpts.deadlineMs }),
+				}),
+				{
+					commandId: submitOpts.commandId ?? nextCommandId(opts.queueId, "submit"),
+					idempotencyKey: submitOpts.idempotencyKey,
+				},
+			);
+			return command;
+		},
+		claim(claimOpts) {
+			return publishQueueCommand(commands, {
+				...claimOpts,
+				kind: "claim",
+				commandId: claimOpts.commandId ?? nextCommandId(opts.queueId, "claim"),
+			} as WorkQueueCommand<T>);
+		},
+		renewLease(renewOpts) {
+			return publishQueueCommand(commands, {
+				...renewOpts,
+				kind: "renew-lease",
+				commandId: renewOpts.commandId ?? nextCommandId(opts.queueId, "renew"),
+			} as WorkQueueCommand<T>);
+		},
+		release(releaseOpts) {
+			return publishQueueCommand(commands, {
+				...releaseOpts,
+				kind: "release",
+				commandId: releaseOpts.commandId ?? nextCommandId(opts.queueId, "release"),
+			} as WorkQueueCommand<T>);
+		},
+		complete(completeOpts) {
+			return publishQueueCommand(commands, {
+				...completeOpts,
+				kind: "complete",
+				commandId: completeOpts.commandId ?? nextCommandId(opts.queueId, "complete"),
+			} as WorkQueueCommand<T>);
+		},
+		fail(failOpts) {
+			return publishQueueCommand(commands, {
+				...failOpts,
+				kind: "fail",
+				commandId: failOpts.commandId ?? nextCommandId(opts.queueId, "fail"),
+			} as WorkQueueCommand<T>);
+		},
+		cancel(cancelOpts) {
+			return publishQueueCommand(commands, {
+				...cancelOpts,
+				kind: "cancel",
+				commandId: cancelOpts.commandId ?? nextCommandId(opts.queueId, "cancel"),
+			} as WorkQueueCommand<T>);
+		},
+		schedule(scheduleOpts) {
+			return publishQueueCommand(commands, {
+				...scheduleOpts,
+				kind: "schedule",
+				commandId: scheduleOpts.commandId ?? nextCommandId(opts.queueId, "schedule"),
+			} as WorkQueueCommand<T>);
+		},
+		expireLeases(expireOpts = {}) {
+			return publishQueueCommand(commands, {
+				...expireOpts,
+				kind: "expire-leases",
+				commandId: expireOpts.commandId ?? nextCommandId(opts.queueId, "expire"),
+			} as WorkQueueCommand<T>);
+		},
+		available(projectionOpts = {}) {
+			const availablePullId = Symbol(`${name}/available`);
+			const available = graph.node<WorkQueueAvailablePage<T>>(
+				[records],
+				(ctx) => {
+					const params = pullParams<WorkQueueAvailableParams>(ctx.pull);
+					ctx.down([["DATA", availablePage(state, params)]]);
+				},
+				{
+					name: projectionOpts.name ?? `${name}/available`,
+					factory: "workQueueAvailable",
+					pullId: availablePullId,
+					partial: true,
+					completeWhenDepsComplete: false,
+					errorWhenDepsError: false,
+				},
+			);
+			return { available, availablePullId, status, issues };
+		},
+		work(workId, projectionOpts = {}) {
+			const snapshotPullId = Symbol(`${name}/${workId}/snapshot`);
+			const snapshot = graph.node<WorkQueueWorkSnapshot<T>>(
+				[records],
+				(ctx) => {
+					ctx.down([["DATA", workSnapshot(state, workId)]]);
+				},
+				{
+					name: projectionOpts.name ?? `${name}/${workId}`,
+					factory: "workQueueWorkSnapshot",
+					pullId: snapshotPullId,
+					partial: true,
+					completeWhenDepsComplete: false,
+					errorWhenDepsError: false,
+				},
+			);
+			return { snapshot, snapshotPullId, status, issues };
+		},
+		deadLetter(projectionOpts = {}) {
+			const snapshotPullId = Symbol(`${name}/deadLetter`);
+			const snapshot = graph.node<WorkQueueDeadLetterPage<T>>(
+				[records],
+				(ctx) => {
+					const params = pullParams<WorkQueueDeadLetterParams>(ctx.pull);
+					ctx.down([["DATA", deadLetterPage(state, params)]]);
+				},
+				{
+					name: projectionOpts.name ?? `${name}/deadLetter`,
+					factory: "workQueueDeadLetter",
+					pullId: snapshotPullId,
+					partial: true,
+					completeWhenDepsComplete: false,
+					errorWhenDepsError: false,
+				},
+			);
+			return { snapshot, snapshotPullId, status, issues };
+		},
+	};
+	return queue;
+}
+
+function shouldPollAdmission(
+	status: MessageBusStatus,
+	topic: string,
+	subscriptionId: string,
+): boolean {
+	if (status.topic !== topic) return false;
+	if (status.kind === "message-published" || status.kind === "retention-trimmed") return true;
+	return (
+		status.subscriptionId === subscriptionId &&
+		(status.kind === "subscription-acked" || status.kind === "subscription-sought")
+	);
+}
+
+function admissionAckCommand<T>(record: WorkQueueRecord<T>): MessageBusCommand | undefined {
+	const messageBus = admissionMessageBus(record);
+	if (messageBus === undefined) return undefined;
+	return {
+		kind: "ack",
+		topic: messageBus.topic,
+		subscriptionId: messageBus.subscriptionId,
+		seq: messageBus.seq,
+		commandId: `${record.queueId}:admission-ack:${messageBus.topic}:${messageBus.subscriptionId}:${messageBus.seq}`,
+	};
+}
+
+function admissionMessageBus<T>(
+	record: WorkQueueRecord<T>,
+): { readonly topic: string; readonly seq: number; readonly subscriptionId: string } | undefined {
+	return "messageBus" in record ? record.messageBus : undefined;
+}
+
+function admitMessage<T>(
+	opts: WorkQueueOptions<T>,
+	state: RuntimeState<T>,
+	message: MessageBusMessage<T>,
+	nowMs: number,
+): QueueEvent<T>[] {
+	const source = `${message.topic}:${message.seq}`;
+	if (state.sourceSeqs.has(source)) return [];
+	state.sourceSeqs.add(source);
+	const submitted = decodeSubmittedPayload(message.payload);
+	const payload = submitted.payload as T;
+	const payloadRecord = payloadAsRecord(submitted.meta);
+	const workId =
+		typeof payloadRecord.workId === "string"
+			? payloadRecord.workId
+			: `${opts.queueId}:${message.topic}:${message.seq}`;
+	if (state.works.has(workId)) {
+		const record = appendRecord(state, opts.queueId, {
+			kind: "admission-deduped",
+			workId,
+			messageBus: { topic: message.topic, seq: message.seq, subscriptionId: opts.subscriptionId },
+			reason: "duplicate-work",
+			existingWorkId: workId,
+			recordedAtMs: nowMs,
+		});
+		return [
+			recordEvent(record),
+			statusEvent(opts.queueId, "admission-rejected", nowMs, {
+				workId,
+				recordSeq: record.recordSeq,
+				issueCode: "duplicate-work",
+			}),
+		];
+	}
+	const work: WorkState<T> = {
+		workId,
+		payload,
+		state:
+			typeof payloadRecord.notBeforeMs === "number" && payloadRecord.notBeforeMs > nowMs
+				? "scheduled"
+				: "ready",
+		admissionSeq: message.seq,
+		priority: numberOrUndefined(payloadRecord.priority),
+		tags: stringArrayOrUndefined(payloadRecord.tags),
+		requirements: stringArrayOrUndefined(payloadRecord.requirements),
+		notBeforeMs: numberOrUndefined(payloadRecord.notBeforeMs),
+		deadlineMs: numberOrUndefined(payloadRecord.deadlineMs),
+		attempt: 0,
+	};
+	state.works.set(workId, work);
+	const record = appendRecord<T>(state, opts.queueId, {
+		kind: "work-admitted",
+		workId,
+		payload,
+		messageBus: { topic: message.topic, seq: message.seq, subscriptionId: opts.subscriptionId },
+		priority: work.priority,
+		tags: work.tags,
+		requirements: work.requirements,
+		notBeforeMs: work.notBeforeMs,
+		deadlineMs: work.deadlineMs,
+		recordedAtMs: nowMs,
+	});
+	return [
+		recordEvent(record),
+		statusEvent(opts.queueId, "admission-accepted", nowMs, { workId, recordSeq: record.recordSeq }),
+	];
+}
+
+function reduceQueueCommand<T>(
+	opts: WorkQueueOptions<T>,
+	state: RuntimeState<T>,
+	command: WorkQueueCommand<T>,
+	nowMs: number,
+	leaseDurationMs: number,
+	retry: WorkQueueRetryPolicy,
+): QueueEvent<T>[] {
+	const invalid = validateQueueCommand(opts.queueId, command);
+	if (invalid !== undefined)
+		return rejectQueueCommand<T>(opts.queueId, command, invalid.code, invalid.message, nowMs);
+	if (state.commandIds.has(command.commandId)) {
+		return rejectQueueCommand<T>(
+			opts.queueId,
+			command,
+			"duplicate-command",
+			"duplicate commandId",
+			nowMs,
+		);
+	}
+	if (command.idempotencyKey !== undefined && state.idempotencyKeys.has(command.idempotencyKey)) {
+		return rejectQueueCommand<T>(
+			opts.queueId,
+			command,
+			"duplicate-command",
+			"duplicate idempotencyKey",
+			nowMs,
+		);
+	}
+	state.commandIds.add(command.commandId);
+	if (command.idempotencyKey !== undefined) state.idempotencyKeys.add(command.idempotencyKey);
+	switch (command.kind) {
+		case "claim":
+			return claimWork(opts.queueId, state, command, nowMs, leaseDurationMs);
+		case "renew-lease":
+			return renewLease(opts.queueId, state, command, nowMs, leaseDurationMs);
+		case "release":
+			return releaseWork(opts.queueId, state, command, nowMs);
+		case "complete":
+			return completeWork(opts.queueId, state, command, nowMs);
+		case "fail":
+			return failWork(opts.queueId, state, command, nowMs, retry);
+		case "cancel":
+			return cancelWork(opts.queueId, state, command, nowMs);
+		case "schedule":
+			return scheduleWork(opts.queueId, state, command, nowMs);
+		case "expire-leases":
+			return expireLeases(opts.queueId, state, command, nowMs);
+		case "submit":
+			return [
+				statusEvent(opts.queueId, "command-accepted", nowMs, {
+					commandId: command.commandId,
+					details: { submitUsesMessageBus: true },
+				}),
+			];
+	}
+}
+
+function claimWork<T>(
+	queueId: string,
+	state: RuntimeState<T>,
+	command: Extract<WorkQueueCommand<T>, { kind: "claim" }>,
+	nowMs: number,
+	defaultLeaseDurationMs: number,
+): QueueEvent<T>[] {
+	const limit = positiveLimit(command.limit ?? command.requestedWorkIds?.length ?? 1);
+	const requested = new Set(command.requestedWorkIds ?? []);
+	const events: QueueEvent<T>[] = [];
+	for (const work of [...state.works.values()]
+		.filter((entry) => (requested.size === 0 ? true : requested.has(entry.workId)))
+		.filter((entry) => isExpiredLease(entry, nowMs))) {
+		events.push(...materializeLeaseExpired(queueId, state, work, command.commandId, nowMs));
+	}
+	const candidates = [...state.works.values()]
+		.filter((work) => (requested.size === 0 ? true : requested.has(work.workId)))
+		.filter((work) => isReady(work, nowMs))
+		.sort((a, b) => a.admissionSeq - b.admissionSeq)
+		.slice(0, limit);
+	if (candidates.length === 0)
+		return [
+			...events,
+			...(requested.size === 0
+				? rejectQueueCommand<T>(queueId, command, "not-ready", "no ready work", nowMs)
+				: claimMissEvents(queueId, state, command, requested, new Set(), nowMs)),
+		];
+	const claimed = new Set<string>();
+	for (const work of candidates) {
+		claimed.add(work.workId);
+		work.state = "leased";
+		work.attempt += 1;
+		work.leaseId = `${work.workId}:lease:${++state.leaseSeq}`;
+		work.workerId = command.workerId;
+		work.leaseExpiresAtMs = nowMs + (command.leaseDurationMs ?? defaultLeaseDurationMs);
+		const record = appendRecord(state, queueId, {
+			kind: "work-claimed",
+			workId: work.workId,
+			commandId: command.commandId,
+			leaseId: work.leaseId,
+			attempt: work.attempt,
+			workerId: command.workerId,
+			claimedAtMs: nowMs,
+			leaseExpiresAtMs: work.leaseExpiresAtMs,
+			recordedAtMs: nowMs,
+		});
+		events.push(
+			recordEvent(record),
+			statusEvent(queueId, "command-accepted", nowMs, {
+				workId: work.workId,
+				commandId: command.commandId,
+				recordSeq: record.recordSeq,
+			}),
+		);
+	}
+	if (requested.size > 0) {
+		events.push(...claimMissEvents(queueId, state, command, requested, claimed, nowMs));
+	}
+	return events;
+}
+
+function claimMissEvents<T>(
+	queueId: string,
+	state: RuntimeState<T>,
+	command: Extract<WorkQueueCommand<T>, { kind: "claim" }>,
+	requested: ReadonlySet<string>,
+	claimed: ReadonlySet<string>,
+	nowMs: number,
+): QueueEvent<T>[] {
+	const events: QueueEvent<T>[] = [];
+	for (const workId of requested) {
+		if (claimed.has(workId)) continue;
+		const work = state.works.get(workId);
+		if (work === undefined) {
+			events.push(
+				...rejectQueueCommand<T>(
+					queueId,
+					command,
+					"unknown-work",
+					`unknown work '${workId}'`,
+					nowMs,
+				),
+			);
+			continue;
+		}
+		if (isReady(work, nowMs)) continue;
+		const code = isTerminal(work.state)
+			? "terminal-work"
+			: work.state === "leased"
+				? "already-leased"
+				: "not-ready";
+		events.push(
+			...rejectQueueCommand<T>(
+				queueId,
+				command,
+				code,
+				`requested work '${workId}' is not claimable`,
+				nowMs,
+			),
+		);
+	}
+	return events;
+}
+
+function renewLease<T>(
+	queueId: string,
+	state: RuntimeState<T>,
+	command: Extract<WorkQueueCommand<T>, { kind: "renew-lease" }>,
+	nowMs: number,
+	defaultLeaseDurationMs: number,
+): QueueEvent<T>[] {
+	const checked = currentLease(queueId, state, command, nowMs);
+	if ("issue" in checked) return [checked.issue];
+	if ("events" in checked) return checked.events;
+	const work = checked.work;
+	const previous = work.leaseExpiresAtMs as number;
+	work.leaseExpiresAtMs =
+		command.leaseExpiresAtMs ?? nowMs + (command.leaseDurationMs ?? defaultLeaseDurationMs);
+	const record = appendRecord(state, queueId, {
+		kind: "lease-renewed",
+		workId: work.workId,
+		commandId: command.commandId,
+		leaseId: command.leaseId,
+		attempt: command.attempt,
+		workerId: command.workerId,
+		previousLeaseExpiresAtMs: previous,
+		leaseExpiresAtMs: work.leaseExpiresAtMs,
+		renewedAtMs: nowMs,
+		recordedAtMs: nowMs,
+	});
+	return [
+		recordEvent(record),
+		statusEvent(queueId, "command-accepted", nowMs, {
+			workId: work.workId,
+			commandId: command.commandId,
+			recordSeq: record.recordSeq,
+		}),
+	];
+}
+
+function releaseWork<T>(
+	queueId: string,
+	state: RuntimeState<T>,
+	command: Extract<WorkQueueCommand<T>, { kind: "release" }>,
+	nowMs: number,
+): QueueEvent<T>[] {
+	const checked = currentLease(queueId, state, command, nowMs);
+	if ("issue" in checked) return [checked.issue];
+	if ("events" in checked) return checked.events;
+	const work = checked.work;
+	work.state = "ready";
+	work.leaseId = undefined;
+	work.workerId = undefined;
+	work.leaseExpiresAtMs = undefined;
+	const record = appendRecord(state, queueId, {
+		kind: "work-released",
+		workId: work.workId,
+		commandId: command.commandId,
+		leaseId: command.leaseId,
+		attempt: command.attempt,
+		workerId: command.workerId,
+		releasedAtMs: nowMs,
+		reason: command.reason,
+		recordedAtMs: nowMs,
+	});
+	return [
+		recordEvent(record),
+		statusEvent(queueId, "command-accepted", nowMs, {
+			workId: work.workId,
+			commandId: command.commandId,
+			recordSeq: record.recordSeq,
+		}),
+	];
+}
+
+function completeWork<T>(
+	queueId: string,
+	state: RuntimeState<T>,
+	command: Extract<WorkQueueCommand<T>, { kind: "complete" }>,
+	nowMs: number,
+): QueueEvent<T>[] {
+	const checked = currentLease(queueId, state, command, nowMs);
+	if ("issue" in checked) return [checked.issue];
+	if ("events" in checked) return checked.events;
+	const work = checked.work;
+	work.state = "completed";
+	clearLease(work);
+	work.terminalRecordSeq = state.recordSeq + 2;
+	const attempt = appendRecord(state, queueId, {
+		kind: "attempt-completed",
+		workId: work.workId,
+		commandId: command.commandId,
+		leaseId: command.leaseId,
+		attempt: command.attempt,
+		workerId: command.workerId,
+		result: command.result,
+		recordedAtMs: nowMs,
+	});
+	const done = appendRecord(state, queueId, {
+		kind: "work-completed",
+		workId: work.workId,
+		commandId: command.commandId,
+		leaseId: command.leaseId,
+		attempt: command.attempt,
+		workerId: command.workerId,
+		result: command.result,
+		recordedAtMs: nowMs,
+	});
+	return [
+		recordEvent(attempt),
+		recordEvent(done),
+		statusEvent(queueId, "command-accepted", nowMs, {
+			workId: work.workId,
+			commandId: command.commandId,
+			recordSeq: done.recordSeq,
+		}),
+	];
+}
+
+function failWork<T>(
+	queueId: string,
+	state: RuntimeState<T>,
+	command: Extract<WorkQueueCommand<T>, { kind: "fail" }>,
+	nowMs: number,
+	retry: WorkQueueRetryPolicy,
+): QueueEvent<T>[] {
+	const checked = currentLease(queueId, state, command, nowMs);
+	if ("issue" in checked) return [checked.issue];
+	if ("events" in checked) return checked.events;
+	const work = checked.work;
+	const failed = appendRecord(state, queueId, {
+		kind: "attempt-failed",
+		workId: work.workId,
+		commandId: command.commandId,
+		leaseId: command.leaseId,
+		attempt: command.attempt,
+		workerId: command.workerId,
+		error: command.error,
+		retryable: command.retryable,
+		recordedAtMs: nowMs,
+	});
+	const maxAttempts = retry.maxAttempts ?? 3;
+	if (command.retryable === false || work.attempt >= maxAttempts) {
+		work.state = "dead-lettered";
+		clearLease(work);
+		work.retryAtMs = undefined;
+		const dead = appendRecord(state, queueId, {
+			kind: "work-dead-lettered",
+			workId: work.workId,
+			commandId: command.commandId,
+			reason: command.retryable === false ? "non-retryable" : "attempts-exhausted",
+			exhaustedAttempts: work.attempt,
+			recordedAtMs: nowMs,
+		});
+		state.deadLetters.push(dead);
+		return [
+			recordEvent(failed),
+			recordEvent(dead),
+			statusEvent(queueId, "command-accepted", nowMs, {
+				workId: work.workId,
+				commandId: command.commandId,
+				recordSeq: dead.recordSeq,
+			}),
+		];
+	}
+	const delayMs = retry.delayMs ?? 0;
+	work.state = delayMs > 0 ? "retry-wait" : "ready";
+	work.retryAtMs = nowMs + delayMs;
+	clearLease(work);
+	const retryRecord = appendRecord(state, queueId, {
+		kind: "retry-scheduled",
+		workId: work.workId,
+		commandId: command.commandId,
+		retryAtMs: work.retryAtMs,
+		delayMs,
+		reason: "retry-policy",
+		recordedAtMs: nowMs,
+	});
+	return [
+		recordEvent(failed),
+		recordEvent(retryRecord),
+		statusEvent(queueId, "command-accepted", nowMs, {
+			workId: work.workId,
+			commandId: command.commandId,
+			recordSeq: retryRecord.recordSeq,
+		}),
+	];
+}
+
+function cancelWork<T>(
+	queueId: string,
+	state: RuntimeState<T>,
+	command: Extract<WorkQueueCommand<T>, { kind: "cancel" }>,
+	nowMs: number,
+): QueueEvent<T>[] {
+	const work = state.works.get(command.workId);
+	if (work === undefined)
+		return [issueEvent(queueId, "unknown-work", "unknown work", nowMs, command)];
+	if (isTerminal(work.state))
+		return [issueEvent(queueId, "terminal-work", "work is terminal", nowMs, command)];
+	work.state = "canceled";
+	const canceledLeaseId = work.leaseId;
+	const attempt = work.attempt || undefined;
+	const record = appendRecord(state, queueId, {
+		kind: "work-canceled",
+		workId: work.workId,
+		commandId: command.commandId,
+		reason: command.reason,
+		canceledAtMs: nowMs,
+		canceledLeaseId,
+		attempt,
+		recordedAtMs: nowMs,
+	});
+	clearLease(work);
+	return [
+		recordEvent(record),
+		statusEvent(queueId, "command-accepted", nowMs, {
+			workId: work.workId,
+			commandId: command.commandId,
+			recordSeq: record.recordSeq,
+		}),
+	];
+}
+
+function scheduleWork<T>(
+	queueId: string,
+	state: RuntimeState<T>,
+	command: Extract<WorkQueueCommand<T>, { kind: "schedule" }>,
+	nowMs: number,
+): QueueEvent<T>[] {
+	const work = state.works.get(command.workId);
+	if (work === undefined)
+		return [issueEvent(queueId, "unknown-work", "unknown work", nowMs, command)];
+	if (isTerminal(work.state))
+		return [issueEvent(queueId, "terminal-work", "work is terminal", nowMs, command)];
+	work.state = "scheduled";
+	work.notBeforeMs = command.notBeforeMs;
+	work.deadlineMs = command.deadlineMs;
+	const record = appendRecord(state, queueId, {
+		kind: "work-scheduled",
+		workId: work.workId,
+		commandId: command.commandId,
+		scheduleId: command.scheduleId,
+		scheduleAtMs: command.scheduleAtMs,
+		runAtMs: command.runAtMs,
+		notBeforeMs: command.notBeforeMs,
+		deadlineMs: command.deadlineMs,
+		reason: command.reason,
+		recordedAtMs: nowMs,
+	});
+	return [
+		recordEvent(record),
+		statusEvent(queueId, "command-accepted", nowMs, {
+			workId: work.workId,
+			commandId: command.commandId,
+			recordSeq: record.recordSeq,
+		}),
+	];
+}
+
+function expireLeases<T>(
+	queueId: string,
+	state: RuntimeState<T>,
+	command: Extract<WorkQueueCommand<T>, { kind: "expire-leases" }>,
+	nowMs: number,
+): QueueEvent<T>[] {
+	const workIds = new Set(command.workIds ?? []);
+	const limit = positiveLimit(command.limit ?? Number.MAX_SAFE_INTEGER);
+	const expired = [...state.works.values()]
+		.filter(
+			(work) =>
+				work.state === "leased" &&
+				work.leaseExpiresAtMs !== undefined &&
+				work.leaseExpiresAtMs <= nowMs,
+		)
+		.filter((work) => workIds.size === 0 || workIds.has(work.workId))
+		.slice(0, limit);
+	if (expired.length === 0)
+		return [statusEvent(queueId, "maintenance-noop", nowMs, { commandId: command.commandId })];
+	const events: QueueEvent<T>[] = [];
+	for (const work of expired) {
+		events.push(...materializeLeaseExpired(queueId, state, work, command.commandId, nowMs));
+	}
+	events.push(
+		statusEvent(queueId, "maintenance-applied", nowMs, {
+			commandId: command.commandId,
+			details: { expired: expired.length },
+		}),
+	);
+	return events;
+}
+
+function currentLease<T>(
+	queueId: string,
+	state: RuntimeState<T>,
+	command: {
+		commandId?: string;
+		workId: string;
+		leaseId: string;
+		attempt: number;
+		workerId: string;
+	},
+	nowMs: number,
+): { work: WorkState<T> } | { issue: QueueEvent<T> } | { events: QueueEvent<T>[] } {
+	const work = state.works.get(command.workId);
+	if (work === undefined)
+		return { issue: issueEvent(queueId, "unknown-work", "unknown work", nowMs, command) };
+	if (isTerminal(work.state))
+		return { issue: issueEvent(queueId, "terminal-work", "work is terminal", nowMs, command) };
+	if (work.state !== "leased")
+		return {
+			issue: issueEvent(queueId, "lease-not-current", "work is not leased", nowMs, command),
+		};
+	if (work.leaseId !== command.leaseId)
+		return { issue: issueEvent(queueId, "stale-lease", "lease is not current", nowMs, command) };
+	if (work.attempt !== command.attempt)
+		return { issue: issueEvent(queueId, "attempt-mismatch", "attempt mismatch", nowMs, command) };
+	if (work.workerId !== command.workerId)
+		return { issue: issueEvent(queueId, "worker-mismatch", "worker mismatch", nowMs, command) };
+	if (isExpiredLease(work, nowMs))
+		return {
+			events: materializeLeaseExpired(queueId, state, work, command.commandId, nowMs, {
+				command,
+				code: "lease-expired",
+				message: "lease expired",
+			}),
+		};
+	return { work };
+}
diff --git a/packages/ts/src/work-queue/projections.ts b/packages/ts/src/work-queue/projections.ts
new file mode 100644
index 00000000..5fe8bcd3
--- /dev/null
+++ b/packages/ts/src/work-queue/projections.ts
@@ -0,0 +1,97 @@
+import type { RuntimeState } from "./runtime-types.js";
+import type {
+	WorkQueueAvailablePage,
+	WorkQueueAvailableParams,
+	WorkQueueDeadLetterPage,
+	WorkQueueDeadLetterParams,
+	WorkQueueWorkSnapshot,
+} from "./types.js";
+import { isReadyForProjection, positiveLimit } from "./utils.js";
+
+export function availablePage<T>(
+	state: RuntimeState<T>,
+	params: WorkQueueAvailableParams,
+): WorkQueueAvailablePage<T> {
+	const limit = positiveLimit(params.limit ?? 100);
+	const orderByWorkId = params.afterWorkId !== undefined && params.afterAdmissionSeq === undefined;
+	const all = [...state.works.values()]
+		.filter((work) => isReadyForProjection(work, params.nowMs))
+		.filter((work) => params.afterWorkId === undefined || work.workId > params.afterWorkId)
+		.filter(
+			(work) =>
+				params.afterAdmissionSeq === undefined || work.admissionSeq > params.afterAdmissionSeq,
+		)
+		.sort((a, b) =>
+			orderByWorkId
+				? a.workId.localeCompare(b.workId)
+				: a.admissionSeq - b.admissionSeq || a.workId.localeCompare(b.workId),
+		);
+	const items = all.map((work) => ({
+		workId: work.workId,
+		state: work.state,
+		payload: work.payload,
+		admissionSeq: work.admissionSeq,
+		priority: work.priority,
+		tags: work.tags,
+		requirements: work.requirements,
+		notBeforeMs: work.notBeforeMs,
+		retryAtMs: work.retryAtMs,
+		deadlineMs: work.deadlineMs,
+	}));
+	const page = items.slice(0, limit);
+	return {
+		items: page,
+		...(items.length > limit && page.length > 0
+			? { nextAfterWorkId: page[page.length - 1]?.workId }
+			: {}),
+		...(items.length > limit && page.length > 0
+			? { nextAfterAdmissionSeq: page[page.length - 1]?.admissionSeq }
+			: {}),
+		hasMore: items.length > limit,
+		asOfRecordSeq: state.recordSeq,
+	};
+}
+
+export function workSnapshot<T>(state: RuntimeState<T>, workId: string): WorkQueueWorkSnapshot<T> {
+	const work = state.works.get(workId);
+	return {
+		workId,
+		state: work?.state,
+		payload: work?.payload,
+		...(work?.state !== "leased" || work.leaseId === undefined
+			? {}
+			: {
+					activeLease: {
+						leaseId: work.leaseId,
+						attempt: work.attempt,
+						workerId: work.workerId as string,
+						leaseExpiresAtMs: work.leaseExpiresAtMs as number,
+					},
+				}),
+		records: state.records.filter((record) => record.workId === workId),
+		asOfRecordSeq: state.recordSeq,
+	};
+}
+
+export function deadLetterPage<T>(
+	state: RuntimeState<T>,
+	params: WorkQueueDeadLetterParams,
+): WorkQueueDeadLetterPage<T> {
+	const limit = positiveLimit(params.limit ?? 100);
+	const entries = state.deadLetters.filter((record) => {
+		if (params.afterDeadLetterSeq !== undefined && record.recordSeq <= params.afterDeadLetterSeq)
+			return false;
+		if (params.afterWorkId !== undefined && (record.workId ?? "") <= params.afterWorkId)
+			return false;
+		return true;
+	});
+	const page = entries.slice(0, limit);
+	return {
+		entries: page,
+		...(entries.length > limit && page.length > 0
+			? { nextAfterDeadLetterSeq: page[page.length - 1]?.recordSeq }
+			: {}),
+		hasMore: entries.length > limit,
+		asOfRecordSeq: state.recordSeq,
+	};
+}
diff --git a/packages/ts/src/work-queue/runtime-types.ts b/packages/ts/src/work-queue/runtime-types.ts
new file mode 100644
index 00000000..187e5e81
--- /dev/null
+++ b/packages/ts/src/work-queue/runtime-types.ts
@@ -0,0 +1,42 @@
+import type { DataIssue } from "../data/index.js";
+import type { WorkQueueDerivedState, WorkQueueRecord, WorkQueueStatus } from "./types.js";
+
+export type QueueEvent<T> =
+	| { readonly kind: "record"; readonly record: WorkQueueRecord<T> }
+	| { readonly kind: "status"; readonly status: WorkQueueStatus }
+	| { readonly kind: "issue"; readonly issue: DataIssue };
+
+export type WorkQueueRecordDraft = {
+	readonly kind: string;
+	readonly recordedAtMs: number;
+	readonly [key: string]: unknown;
+};
+
+export interface WorkState<T> {
+	workId: string;
+	payload: T;
+	state: WorkQueueDerivedState;
+	admissionSeq: number;
+	priority?: number;
+	tags?: readonly string[];
+	requirements?: readonly string[];
+	notBeforeMs?: number;
+	retryAtMs?: number;
+	deadlineMs?: number;
+	attempt: number;
+	leaseId?: string;
+	workerId?: string;
+	leaseExpiresAtMs?: number;
+	terminalRecordSeq?: number;
+}
+
+export interface RuntimeState<T> {
+	recordSeq: number;
+	leaseSeq: number;
+	works: Map<string, WorkState<T>>;
+	sourceSeqs: Set<string>;
+	commandIds: Set<string>;
+	idempotencyKeys: Set<string>;
+	records: WorkQueueRecord<T>[];
+	deadLetters: WorkQueueRecord<T>[];
+}
diff --git a/packages/ts/src/work-queue/types.ts b/packages/ts/src/work-queue/types.ts
new file mode 100644
index 00000000..a3c2b530
--- /dev/null
+++ b/packages/ts/src/work-queue/types.ts
@@ -0,0 +1,407 @@
+import type { DataIssue } from "../data/index.js";
+import type { MessageBus } from "../messaging/index.js";
+import type { Node } from "../node/node.js";
+import type { LockId } from "../protocol/messages.js";
+
+export interface WorkQueueOptions<_T = unknown> {
+	readonly queueId: string;
+	readonly bus: MessageBus;
+	readonly topic: string;
+	readonly subscriptionId: string;
+	readonly from?: "earliest" | "latest" | number;
+	readonly name?: string;
+	readonly now?: () => number;
+	readonly leaseDurationMs?: number;
+	readonly retry?: WorkQueueRetryPolicy;
+}
+
+export interface WorkQueueRetryPolicy {
+	readonly maxAttempts?: number;
+	readonly delayMs?: number;
+}
+
+interface WorkQueueCommandBase {
+	readonly commandId: string;
+	readonly queueId?: string;
+	readonly idempotencyKey?: string;
+	readonly correlationId?: string;
+	readonly causationId?: string;
+	readonly sourceRefs?: readonly string[];
+	readonly policyRefs?: readonly string[];
+	readonly actorRefs?: readonly string[];
+	readonly auditRefs?: readonly string[];
+	readonly nowMs?: number;
+}
+
+export type WorkQueueCommand<T = unknown> =
+	| (WorkQueueCommandBase & {
+			readonly kind: "submit";
+			readonly payload: T;
+			readonly workId?: string;
+			readonly priority?: number;
+			readonly tags?: readonly string[];
+			readonly requirements?: readonly string[];
+			readonly notBeforeMs?: number;
+			readonly deadlineMs?: number;
+	  })
+	| (WorkQueueCommandBase & {
+			readonly kind: "claim";
+			readonly workerId: string;
+			readonly requestedWorkIds?: readonly string[];
+			readonly limit?: number;
+			readonly leaseDurationMs?: number;
+	  })
+	| (WorkQueueCommandBase & {
+			readonly kind: "renew-lease";
+			readonly workId: string;
+			readonly leaseId: string;
+			readonly attempt: number;
+			readonly workerId: string;
+			readonly leaseDurationMs?: number;
+			readonly leaseExpiresAtMs?: number;
+	  })
+	| (WorkQueueCommandBase & {
+			readonly kind: "release";
+			readonly workId: string;
+			readonly leaseId: string;
+			readonly attempt: number;
+			readonly workerId: string;
+			readonly reason?: string;
+	  })
+	| (WorkQueueCommandBase & {
+			readonly kind: "complete";
+			readonly workId: string;
+			readonly leaseId: string;
+			readonly attempt: number;
+			readonly workerId: string;
+			readonly result?: unknown;
+	  })
+	| (WorkQueueCommandBase & {
+			readonly kind: "fail";
+			readonly workId: string;
+			readonly leaseId: string;
+			readonly attempt: number;
+			readonly workerId: string;
+			readonly error?: unknown;
+			readonly retryable?: boolean;
+	  })
+	| (WorkQueueCommandBase & {
+			readonly kind: "cancel";
+			readonly workId: string;
+			readonly reason?: string;
+	  })
+	| (WorkQueueCommandBase & {
+			readonly kind: "schedule";
+			readonly workId: string;
+			readonly scheduleId?: string;
+			readonly scheduleAtMs?: number;
+			readonly runAtMs?: number;
+			readonly notBeforeMs: number;
+			readonly deadlineMs?: number;
+			readonly reason?: string;
+	  })
+	| (WorkQueueCommandBase & {
+			readonly kind: "expire-leases";
+			readonly workIds?: readonly string[];
+			readonly limit?: number;
+	  });
+
+interface WorkQueueRecordBase {
+	readonly kind: string;
+	readonly recordSeq: number;
+	readonly queueId: string;
+	readonly workId?: string;
+	readonly commandId?: string;
+	readonly idempotencyKey?: string;
+	readonly correlationId?: string;
+	readonly causationId?: string;
+	readonly sourceRefs?: readonly string[];
+	readonly policyRefs?: readonly string[];
+	readonly actorRefs?: readonly string[];
+	readonly auditRefs?: readonly string[];
+	readonly issueRefs?: readonly string[];
+	readonly recordedAtMs: number;
+}
+
+export type WorkQueueRecord<T = unknown> =
+	| (WorkQueueRecordBase & {
+			readonly kind: "work-admitted";
+			readonly workId: string;
+			readonly payload: T;
+			readonly messageBus: {
+				readonly topic: string;
+				readonly seq: number;
+				readonly subscriptionId: string;
+			};
+			readonly priority?: number;
+			readonly tags?: readonly string[];
+			readonly requirements?: readonly string[];
+			readonly notBeforeMs?: number;
+			readonly deadlineMs?: number;
+	  })
+	| (WorkQueueRecordBase & {
+			readonly kind: "work-rejected" | "admission-rejected";
+			readonly workId?: string;
+			readonly messageBus?: {
+				readonly topic: string;
+				readonly seq: number;
+				readonly subscriptionId: string;
+			};
+			readonly reason: string;
+			readonly existingWorkId?: string;
+	  })
+	| (WorkQueueRecordBase & {
+			readonly kind: "work-scheduled";
+			readonly workId: string;
+			readonly scheduleId?: string;
+			readonly scheduleAtMs?: number;
+			readonly runAtMs?: number;
+			readonly notBeforeMs: number;
+			readonly deadlineMs?: number;
+			readonly reason?: string;
+	  })
+	| (WorkQueueRecordBase & {
+			readonly kind: "work-claimed";
+			readonly workId: string;
+			readonly leaseId: string;
+			readonly attempt: number;
+			readonly workerId: string;
+			readonly claimedAtMs: number;
+			readonly leaseExpiresAtMs: number;
+	  })
+	| (WorkQueueRecordBase & {
+			readonly kind: "lease-renewed";
+			readonly workId: string;
+			readonly leaseId: string;
+			readonly attempt: number;
+			readonly workerId: string;
+			readonly previousLeaseExpiresAtMs: number;
+			readonly leaseExpiresAtMs: number;
+			readonly renewedAtMs: number;
+	  })
+	| (WorkQueueRecordBase & {
+			readonly kind: "work-released";
+			readonly workId: string;
+			readonly leaseId: string;
+			readonly attempt: number;
+			readonly workerId: string;
+			readonly releasedAtMs: number;
+			readonly reason?: string;
+	  })
+	| (WorkQueueRecordBase & {
+			readonly kind: "lease-expired";
+			readonly workId: string;
+			readonly leaseId: string;
+			readonly attempt: number;
+			readonly workerId: string;
+			readonly leaseExpiresAtMs: number;
+			readonly expiredAtMs: number;
+	  })
+	| (WorkQueueRecordBase & {
+			readonly kind: "attempt-completed" | "work-completed";
+			readonly workId: string;
+			readonly leaseId: string;
+			readonly attempt: number;
+			readonly workerId: string;
+			readonly result?: unknown;
+	  })
+	| (WorkQueueRecordBase & {
+			readonly kind: "attempt-failed";
+			readonly workId: string;
+			readonly leaseId: string;
+			readonly attempt: number;
+			readonly workerId: string;
+			readonly error?: unknown;
+			readonly retryable?: boolean;
+	  })
+	| (WorkQueueRecordBase & {
+			readonly kind: "retry-scheduled";
+			readonly workId: string;
+			readonly retryAtMs: number;
+			readonly delayMs: number;
+			readonly reason?: string;
+	  })
+	| (WorkQueueRecordBase & {
+			readonly kind: "work-dead-lettered";
+			readonly workId: string;
+			readonly reason: string;
+			readonly exhaustedAttempts?: number;
+	  })
+	| (WorkQueueRecordBase & {
+			readonly kind: "work-canceled";
+			readonly workId: string;
+			readonly reason?: string;
+			readonly canceledAtMs: number;
+			readonly canceledLeaseId?: string;
+			readonly attempt?: number;
+	  })
+	| (WorkQueueRecordBase & {
+			readonly kind: "lifecycle-rejected" | "admission-deduped";
+			readonly workId?: string;
+			readonly messageBus?: {
+				readonly topic: string;
+				readonly seq: number;
+				readonly subscriptionId: string;
+			};
+			readonly reason: string;
+			readonly existingWorkId?: string;
+	  });
+
+export interface WorkQueueStatus {
+	readonly kind:
+		| "command-accepted"
+		| "command-rejected"
+		| "admission-accepted"
+		| "admission-rejected"
+		| "admission-retryable"
+		| "projection-ready"
+		| "projection-partial"
+		| "projection-stale"
+		| "maintenance-applied"
+		| "maintenance-noop"
+		| "policy-warning";
+	readonly queueId: string;
+	readonly workId?: string;
+	readonly commandId?: string;
+	readonly recordSeq?: number;
+	readonly asOfRecordSeq?: number;
+	readonly issueCode?: string;
+	readonly timestampMs: number;
+	readonly details?: unknown;
+}
+
+export interface WorkQueueAvailableItem<T = unknown> {
+	readonly workId: string;
+	readonly state: WorkQueueDerivedState;
+	readonly payload: T;
+	readonly admissionSeq: number;
+	readonly priority?: number;
+	readonly tags?: readonly string[];
+	readonly requirements?: readonly string[];
+	readonly notBeforeMs?: number;
+	readonly retryAtMs?: number;
+	readonly deadlineMs?: number;
+}
+
+export interface WorkQueueAvailablePage<T = unknown> {
+	readonly items: readonly WorkQueueAvailableItem<T>[];
+	readonly nextAfterWorkId?: string;
+	readonly nextAfterAdmissionSeq?: number;
+	readonly hasMore: boolean;
+	readonly asOfRecordSeq: number;
+}
+
+export interface WorkQueueWorkSnapshot<T = unknown> {
+	readonly workId: string;
+	readonly state?: WorkQueueDerivedState;
+	readonly payload?: T;
+	readonly activeLease?: {
+		readonly leaseId: string;
+		readonly attempt: number;
+		readonly workerId: string;
+		readonly leaseExpiresAtMs: number;
+	};
+	readonly records: readonly WorkQueueRecord<T>[];
+	readonly asOfRecordSeq: number;
+}
+
+export interface WorkQueueDeadLetterPage<T = unknown> {
+	readonly entries: readonly WorkQueueRecord<T>[];
+	readonly nextAfterDeadLetterSeq?: number;
+	readonly hasMore: boolean;
+	readonly asOfRecordSeq: number;
+}
+
+export interface WorkQueueAvailableParams {
+	readonly limit?: number;
+	readonly afterWorkId?: string;
+	readonly afterAdmissionSeq?: number;
+	readonly nowMs?: number;
+	readonly includeIssues?: boolean;
+}
+
+export interface WorkQueueDeadLetterParams {
+	readonly limit?: number;
+	readonly afterDeadLetterSeq?: number;
+	readonly afterWorkId?: string;
+}
+
+export type WorkQueueDerivedState =
+	| "scheduled"
+	| "ready"
+	| "leased"
+	| "retry-wait"
+	| "completed"
+	| "canceled"
+	| "dead-lettered";
+
+export interface WorkQueueProjection<TPage> {
+	readonly snapshot: Node<TPage>;
+	readonly snapshotPullId: LockId;
+	readonly status: Node<WorkQueueStatus>;
+	readonly issues: Node<DataIssue>;
+}
+
+export interface WorkQueueAvailableProjection<T = unknown> {
+	readonly available: Node<WorkQueueAvailablePage<T>>;
+	readonly availablePullId: LockId;
+	readonly status: Node<WorkQueueStatus>;
+	readonly issues: Node<DataIssue>;
+}
+
+export interface WorkQueue<T = unknown> {
+	readonly commands: Node<WorkQueueCommand<T>>;
+	readonly records: Node<WorkQueueRecord<T>>;
+	readonly status: Node<WorkQueueStatus>;
+	readonly issues: Node<DataIssue>;
+	submit(
+		payload: T,
+		opts?: Omit<
+			Partial<Extract<WorkQueueCommand<T>, { kind: "submit" }>>,
+			"kind" | "payload" | "commandId"
+		> & { commandId?: string },
+	): unknown;
+	claim(
+		opts: Omit<Extract<WorkQueueCommand<T>, { kind: "claim" }>, "kind" | "commandId"> & {
+			commandId?: string;
+		},
+	): WorkQueueCommand<T>;
+	renewLease(
+		opts: Omit<Extract<WorkQueueCommand<T>, { kind: "renew-lease" }>, "kind" | "commandId"> & {
+			commandId?: string;
+		},
+	): WorkQueueCommand<T>;
+	release(
+		opts: Omit<Extract<WorkQueueCommand<T>, { kind: "release" }>, "kind" | "commandId"> & {
+			commandId?: string;
+		},
+	): WorkQueueCommand<T>;
+	complete(
+		opts: Omit<Extract<WorkQueueCommand<T>, { kind: "complete" }>, "kind" | "commandId"> & {
+			commandId?: string;
+		},
+	): WorkQueueCommand<T>;
+	fail(
+		opts: Omit<Extract<WorkQueueCommand<T>, { kind: "fail" }>, "kind" | "commandId"> & {
+			commandId?: string;
+		},
+	): WorkQueueCommand<T>;
+	cancel(
+		opts: Omit<Extract<WorkQueueCommand<T>, { kind: "cancel" }>, "kind" | "commandId"> & {
+			commandId?: string;
+		},
+	): WorkQueueCommand<T>;
+	schedule(
+		opts: Omit<Extract<WorkQueueCommand<T>, { kind: "schedule" }>, "kind" | "commandId"> & {
+			commandId?: string;
+		},
+	): WorkQueueCommand<T>;
+	expireLeases(
+		opts?: Omit<Extract<WorkQueueCommand<T>, { kind: "expire-leases" }>, "kind" | "commandId"> & {
+			commandId?: string;
+		},
+	): WorkQueueCommand<T>;
+	available(opts?: { name?: string }): WorkQueueAvailableProjection<T>;
+	work(workId: string, opts?: { name?: string }): WorkQueueProjection<WorkQueueWorkSnapshot<T>>;
+	deadLetter(opts?: { name?: string }): WorkQueueProjection<WorkQueueDeadLetterPage<T>>;
+}
diff --git a/packages/ts/src/work-queue/utils.ts b/packages/ts/src/work-queue/utils.ts
new file mode 100644
index 00000000..36b1f383
--- /dev/null
+++ b/packages/ts/src/work-queue/utils.ts
@@ -0,0 +1,361 @@
+import type { Node } from "../node/node.js";
+import type { PullDemand } from "../protocol/messages.js";
+import type { QueueEvent, RuntimeState, WorkQueueRecordDraft, WorkState } from "./runtime-types.js";
+import type {
+	WorkQueueCommand,
+	WorkQueueDerivedState,
+	WorkQueueRecord,
+	WorkQueueStatus,
+} from "./types.js";
+
+export function appendRecord<T>(
+	state: RuntimeState<T>,
+	queueId: string,
+	record: WorkQueueRecordDraft,
+): WorkQueueRecord<T> {
+	const full = { ...record, queueId, recordSeq: ++state.recordSeq } as WorkQueueRecord<T>;
+	state.records.push(full);
+	return full;
+}
+
+export function recordEvent<T>(record: WorkQueueRecord<T>): QueueEvent<T> {
+	return { kind: "record", record };
+}
+
+export function statusEvent<T>(
+	queueId: string,
+	kind: WorkQueueStatus["kind"],
+	timestampMs: number,
+	fields: Partial<WorkQueueStatus> = {},
+): QueueEvent<T> {
+	return {
+		kind: "status",
+		status: {
+			kind,
+			queueId,
+			timestampMs,
+			...(fields.workId === undefined ? {} : { workId: fields.workId }),
+			...(fields.commandId === undefined ? {} : { commandId: fields.commandId }),
+			...(fields.recordSeq === undefined ? {} : { recordSeq: fields.recordSeq }),
+			...(fields.asOfRecordSeq === undefined ? {} : { asOfRecordSeq: fields.asOfRecordSeq }),
+			...(fields.issueCode === undefined ? {} : { issueCode: fields.issueCode }),
+			...(fields.details === undefined ? {} : { details: fields.details }),
+		},
+	};
+}
+
+export function issueEvent<T>(
+	queueId: string,
+	code: string,
+	message: string,
+	timestampMs: number,
+	details: unknown,
+): QueueEvent<T> {
+	return {
+		kind: "issue",
+		issue: {
+			kind: "issue",
+			code,
+			message,
+			severity: "error",
+			source: "workQueue",
+			details,
+			metadata: { queueId, timestampMs },
+		},
+	};
+}
+
+export function rejectQueueCommand<T>(
+	queueId: string,
+	command: unknown,
+	code: string,
+	message: string,
+	nowMs: number,
+	commandId = commandIdFrom(command),
+): QueueEvent<T>[] {
+	return [
+		issueEvent(queueId, code, message, nowMs, command),
+		statusEvent(queueId, "command-rejected", nowMs, {
+			...(commandId === undefined ? {} : { commandId }),
+			issueCode: code,
+		}),
+	];
+}
+
+export function validateQueueCommand(
+	queueId: string,
+	command: unknown,
+): { readonly code: string; readonly message: string } | undefined {
+	if (!isObjectRecord(command))
+		return { code: "malformed-command", message: "command must be an object" };
+	if (typeof command.kind !== "string")
+		return { code: "malformed-command", message: "command kind is required" };
+	if (!isWorkQueueCommandKind(command.kind))
+		return { code: "malformed-command", message: `unknown command kind '${command.kind}'` };
+	if (typeof command.commandId !== "string" || command.commandId.length === 0)
+		return { code: "malformed-command", message: "commandId must be a non-empty string" };
+	if (command.queueId !== undefined && command.queueId !== queueId)
+		return { code: "queue-mismatch", message: "command queueId does not match this queue" };
+	switch (command.kind) {
+		case "submit":
+			return command.payload === undefined
+				? { code: "malformed-command", message: "submit payload is required" }
+				: undefined;
+		case "claim":
+			if (typeof command.workerId !== "string" || command.workerId.length === 0)
+				return { code: "malformed-command", message: "claim workerId is required" };
+			if (command.limit !== undefined && !isPositiveInteger(command.limit))
+				return { code: "malformed-command", message: "claim limit must be a positive integer" };
+			if (
+				command.requestedWorkIds !== undefined &&
+				(!Array.isArray(command.requestedWorkIds) ||
+					!command.requestedWorkIds.every((id) => typeof id === "string" && id.length > 0))
+			) {
+				return { code: "malformed-command", message: "requestedWorkIds must be strings" };
+			}
+			if (command.leaseDurationMs !== undefined && !isPositiveInteger(command.leaseDurationMs))
+				return {
+					code: "malformed-command",
+					message: "leaseDurationMs must be a positive integer",
+				};
+			return undefined;
+		case "renew-lease":
+			if (command.leaseDurationMs !== undefined && !isPositiveInteger(command.leaseDurationMs))
+				return {
+					code: "malformed-command",
+					message: "leaseDurationMs must be a positive integer",
+				};
+			if (command.leaseExpiresAtMs !== undefined && !isFiniteNumber(command.leaseExpiresAtMs))
+				return { code: "malformed-command", message: "leaseExpiresAtMs must be finite" };
+			return validateLeaseCommand(command);
+		case "release":
+		case "complete":
+		case "fail":
+			return validateLeaseCommand(command);
+		case "cancel":
+			return requiredString(command.workId, "workId");
+		case "schedule": {
+			const workIdError = requiredString(command.workId, "workId");
+			if (workIdError !== undefined) return workIdError;
+			if (!isFiniteNumber(command.notBeforeMs))
+				return { code: "malformed-command", message: "notBeforeMs must be finite" };
+			if (command.deadlineMs !== undefined && !isFiniteNumber(command.deadlineMs))
+				return { code: "malformed-command", message: "deadlineMs must be finite" };
+			return undefined;
+		}
+		case "expire-leases":
+			if (command.limit !== undefined && !isPositiveInteger(command.limit))
+				return {
+					code: "malformed-command",
+					message: "expire-leases limit must be a positive integer",
+				};
+			if (
+				command.workIds !== undefined &&
+				(!Array.isArray(command.workIds) ||
+					!command.workIds.every((id) => typeof id === "string" && id.length > 0))
+			) {
+				return { code: "malformed-command", message: "workIds must be strings" };
+			}
+			return undefined;
+	}
+}
+
+export function validateLeaseCommand(
+	command: Record<string, unknown>,
+): { readonly code: string; readonly message: string } | undefined {
+	for (const key of ["workId", "leaseId", "workerId"]) {
+		const err = requiredString(command[key], key);
+		if (err !== undefined) return err;
+	}
+	if (!isPositiveInteger(command.attempt))
+		return { code: "malformed-command", message: "attempt must be a positive integer" };
+	return undefined;
+}
+
+export function requiredString(
+	value: unknown,
+	name: string,
+): { readonly code: string; readonly message: string } | undefined {
+	return typeof value === "string" && value.length > 0
+		? undefined
+		: { code: "malformed-command", message: `${name} must be a non-empty string` };
+}
+
+export function commandIdFrom(command: unknown): string | undefined {
+	return isObjectRecord(command) && typeof command.commandId === "string"
+		? command.commandId
+		: undefined;
+}
+
+export function isWorkQueueCommandKind(kind: string): kind is WorkQueueCommand["kind"] {
+	return (
+		kind === "submit" ||
+		kind === "claim" ||
+		kind === "renew-lease" ||
+		kind === "release" ||
+		kind === "complete" ||
+		kind === "fail" ||
+		kind === "cancel" ||
+		kind === "schedule" ||
+		kind === "expire-leases"
+	);
+}
+
+export function isObjectRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+export function isPositiveInteger(value: unknown): value is number {
+	return Number.isInteger(value) && (value as number) > 0;
+}
+
+export function isFiniteNumber(value: unknown): value is number {
+	return typeof value === "number" && Number.isFinite(value);
+}
+
+export function publishQueueCommand<T>(
+	node: Node<WorkQueueCommand<T>>,
+	command: WorkQueueCommand<T>,
+): WorkQueueCommand<T> {
+	node.down([["DATA", command]]);
+	return command;
+}
+
+let commandSeq = 0;
+export function nextCommandId(queueId: string, kind: string): string {
+	commandSeq += 1;
+	return `${queueId}:${kind}:${commandSeq}`;
+}
+
+export function isReady<T>(work: WorkState<T>, nowMs: number): boolean {
+	if (work.state === "scheduled")
+		return work.notBeforeMs !== undefined && work.notBeforeMs <= nowMs;
+	if (work.state === "retry-wait") return work.retryAtMs !== undefined && work.retryAtMs <= nowMs;
+	return work.state === "ready";
+}
+
+export function isReadyForProjection<T>(work: WorkState<T>, nowMs: number | undefined): boolean {
+	if (work.state === "scheduled" || work.state === "retry-wait") {
+		return nowMs === undefined ? false : isReady(work, nowMs);
+	}
+	return isReady(work, 0);
+}
+
+export function isTerminal(state: WorkQueueDerivedState): boolean {
+	return state === "completed" || state === "canceled" || state === "dead-lettered";
+}
+
+export function payloadAsRecord(value: unknown): Record<string, unknown> {
+	return typeof value === "object" && value !== null && !Array.isArray(value)
+		? (value as Record<string, unknown>)
+		: {};
+}
+
+export function numberOrUndefined(value: unknown): number | undefined {
+	return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+
+export function stringArrayOrUndefined(value: unknown): readonly string[] | undefined {
+	return Array.isArray(value) && value.every((entry) => typeof entry === "string")
+		? value
+		: undefined;
+}
+
+export function pullParams<T>(pull: PullDemand | undefined): T {
+	return (
+		typeof pull?.params === "object" && pull.params !== null && !Array.isArray(pull.params)
+			? pull.params
+			: {}
+	) as T;
+}
+
+const SUBMIT_ENVELOPE = "__graphreflyWorkQueueSubmit";
+
+export function submitPayload<T>(
+	payload: T,
+	meta: Record<string, unknown>,
+): T | (Record<string, unknown> & { readonly [SUBMIT_ENVELOPE]: true; readonly payload: T }) {
+	if (Object.keys(meta).length === 0) return payload;
+	return { [SUBMIT_ENVELOPE]: true, payload, ...meta };
+}
+
+export function decodeSubmittedPayload<T>(payload: T): {
+	payload: T;
+	meta: Record<string, unknown>;
+} {
+	if (
+		isObjectRecord(payload) &&
+		payload[SUBMIT_ENVELOPE] === true &&
+		Object.hasOwn(payload, "payload")
+	) {
+		const { payload: inner, [SUBMIT_ENVELOPE]: _tag, ...meta } = payload as Record<string, unknown>;
+		return { payload: inner as T, meta };
+	}
+	return { payload, meta: payloadAsRecord(payload) };
+}
+
+export function commandNowMs<T>(command: WorkQueueCommand<T>, fallback: number): number {
+	return typeof command.nowMs === "number" && Number.isFinite(command.nowMs)
+		? command.nowMs
+		: fallback;
+}
+
+export function positiveLimit(limit: number): number {
+	if (!Number.isInteger(limit) || limit < 1)
+		throw new Error("workQueue: limit must be a positive integer");
+	return limit;
+}
+
+export function assertNonEmpty(value: string, owner: string): void {
+	if (typeof value !== "string" || value.length === 0)
+		throw new Error(`${owner} must be a non-empty string`);
+}
+
+export function materializeLeaseExpired<T>(
+	queueId: string,
+	state: RuntimeState<T>,
+	work: WorkState<T>,
+	commandId: string | undefined,
+	nowMs: number,
+	rejection?: { readonly command: unknown; readonly code: string; readonly message: string },
+): QueueEvent<T>[] {
+	const record = appendRecord(state, queueId, {
+		kind: "lease-expired",
+		workId: work.workId,
+		...(commandId === undefined ? {} : { commandId }),
+		leaseId: work.leaseId as string,
+		attempt: work.attempt,
+		workerId: work.workerId as string,
+		leaseExpiresAtMs: work.leaseExpiresAtMs as number,
+		expiredAtMs: nowMs,
+		recordedAtMs: nowMs,
+	});
+	work.state = "ready";
+	clearLease(work);
+	const events: QueueEvent<T>[] = [recordEvent(record)];
+	if (rejection !== undefined) {
+		events.push(
+			...rejectQueueCommand<T>(
+				queueId,
+				rejection.command,
+				rejection.code,
+				rejection.message,
+				nowMs,
+				commandId,
+			),
+		);
+	}
+	return events;
+}
+
+export function isExpiredLease<T>(work: WorkState<T>, nowMs: number): boolean {
+	return (
+		work.state === "leased" && work.leaseExpiresAtMs !== undefined && work.leaseExpiresAtMs <= nowMs
+	);
+}
+
+export function clearLease<T>(work: WorkState<T>): void {
+	work.leaseId = undefined;
+	work.workerId = undefined;
+	work.leaseExpiresAtMs = undefined;
+}
diff --git a/packages/ts/tsconfig.json b/packages/ts/tsconfig.json
new file mode 100644
index 00000000..a12c2c97
--- /dev/null
+++ b/packages/ts/tsconfig.json
@@ -0,0 +1,17 @@
+{
+	"compilerOptions": {
+		"target": "ES2022",
+		"module": "ES2022",
+		"moduleResolution": "bundler",
+		"lib": ["ES2022"],
+		"declaration": true,
+		"outDir": "dist",
+		"rootDir": "src",
+		"strict": true,
+		"esModuleInterop": true,
+		"skipLibCheck": true,
+		"forceConsistentCasingInFileNames": true
+	},
+	"include": ["src"],
+	"exclude": ["node_modules", "dist", "**/*.test.ts"]
+}
diff --git a/packages/ts/tsup.config.ts b/packages/ts/tsup.config.ts
new file mode 100644
index 00000000..bd68b8f6
--- /dev/null
+++ b/packages/ts/tsup.config.ts
@@ -0,0 +1,59 @@
+import { defineConfig } from "tsup";
+
+export default defineConfig({
+	entry: [
+		"src/index.ts",
+		"src/adapters/index.ts",
+		"src/adapters/nestjs.ts",
+		"src/adapters/nestjs/microservices.ts",
+		"src/adapters/nestjs/native.ts",
+		"src/adapters/nestjs/websockets.ts",
+		"src/adapters/observe-storage.ts",
+		"src/adapters/react.ts",
+		"src/adapters/solid.ts",
+		"src/adapters/svelte.ts",
+		"src/adapters/vue.ts",
+		"src/composition/index.ts",
+		"src/cqrs/index.ts",
+		"src/cqrs/messaging.ts",
+		"src/cqrs/work-queue.ts",
+		"src/core/index.ts",
+		"src/data/index.ts",
+		"src/data-structures/index.ts",
+		"src/graph/index.ts",
+		"src/inspection/boundary.ts",
+		"src/executors/tool-provider.ts",
+		"src/executors/tool-provider-adapters.ts",
+		"src/executors/tool-provider-runtime.ts",
+		"src/executors/work-queue.ts",
+		"src/messaging/index.ts",
+		"src/operators/index.ts",
+		"src/orchestration/index.ts",
+		"src/orchestration/messaging.ts",
+		"src/orchestration/work-queue.ts",
+		"src/patterns/event-flow.ts",
+		"src/patterns/index.ts",
+		"src/render/index.ts",
+		"src/solutions/index.ts",
+		"src/solutions/work-item/actions.ts",
+		"src/solutions/work-item/scheduling.ts",
+		"src/solutions/work-item/work-queue.ts",
+		"src/solutions/reactive-layout/index.ts",
+		"src/solutions/reactive-layout/browser/index.ts",
+		"src/solutions/reactive-layout/node-canvas/index.ts",
+		"src/solutions/reactive-layout/react-native/index.ts",
+		"src/solutions/reactive-layout/skia/index.ts",
+		"src/sources/browser.ts",
+		"src/sources/index.ts",
+		"src/sources/node.ts",
+		"src/storage/index.ts",
+		"src/storage/node.ts",
+		"src/storage/browser.ts",
+		"src/testing/index.ts",
+		"src/work-queue/index.ts",
+	],
+	format: ["esm", "cjs"],
+	dts: true,
+	clean: true,
+	sourcemap: true,
+});
diff --git a/packages/ts/vitest.config.ts b/packages/ts/vitest.config.ts
new file mode 100644
index 00000000..2f671880
--- /dev/null
+++ b/packages/ts/vitest.config.ts
@@ -0,0 +1,7 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+	test: {
+		include: ["src/**/*.test.ts"],
+	},
+});
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 4bc3cdd1..e20d70ee 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -7,14 +7,7 @@ settings:
 importers:
 
   .:
-    dependencies:
-      '@graphrefly/pure-ts':
-        specifier: workspace:>=0.45.0
-        version: link:packages/pure-ts
     devDependencies:
-      '@anthropic-ai/sdk':
-        specifier: ^0.82.0
-        version: 0.82.0(zod@4.3.6)
       '@biomejs/biome':
         specifier: 2.4.6
         version: 2.4.6
@@ -24,15 +17,15 @@ importers:
       '@changesets/cli':
         specifier: ^2.31.0
         version: 2.31.0(@types/node@25.5.0)
-      '@google/genai':
-        specifier: ^1.48.0
-        version: 1.48.0(@modelcontextprotocol/sdk@1.29.0(zod@4.3.6))
       '@nestjs/common':
         specifier: ^11.1.17
         version: 11.1.17(reflect-metadata@0.2.2)(rxjs@7.8.2)
       '@nestjs/core':
         specifier: ^11.1.17
-        version: 11.1.17(@nestjs/common@11.1.17(reflect-metadata@0.2.2)(rxjs@7.8.2))(@nestjs/platform-express@11.1.18)(@nestjs/websockets@11.1.18)(reflect-metadata@0.2.2)(rxjs@7.8.2)
+        version: 11.1.17(@nestjs/common@11.1.17(reflect-metadata@0.2.2)(rxjs@7.8.2))(@nestjs/microservices@11.1.27)(@nestjs/platform-express@11.1.18)(@nestjs/websockets@11.1.18)(reflect-metadata@0.2.2)(rxjs@7.8.2)
+      '@nestjs/microservices':
+        specifier: ^11.1.27
+        version: 11.1.27(@nestjs/common@11.1.17(reflect-metadata@0.2.2)(rxjs@7.8.2))(@nestjs/core@11.1.17)(@nestjs/websockets@11.1.18)(reflect-metadata@0.2.2)(rxjs@7.8.2)
       '@nestjs/platform-express':
         specifier: ^11.1.18
         version: 11.1.18(@nestjs/common@11.1.17(reflect-metadata@0.2.2)(rxjs@7.8.2))(@nestjs/core@11.1.17)
@@ -41,7 +34,7 @@ importers:
         version: 11.1.18(@nestjs/common@11.1.17(reflect-metadata@0.2.2)(rxjs@7.8.2))(@nestjs/websockets@11.1.18)(rxjs@7.8.2)
       '@nestjs/testing':
         specifier: ^11.1.17
-        version: 11.1.17(@nestjs/common@11.1.17(reflect-metadata@0.2.2)(rxjs@7.8.2))(@nestjs/core@11.1.17)(@nestjs/platform-express@11.1.18)
+        version: 11.1.17(@nestjs/common@11.1.17(reflect-metadata@0.2.2)(rxjs@7.8.2))(@nestjs/core@11.1.17)(@nestjs/microservices@11.1.27)(@nestjs/platform-express@11.1.18)
       '@nestjs/websockets':
         specifier: ^11.1.18
         version: 11.1.18(@nestjs/common@11.1.17(reflect-metadata@0.2.2)(rxjs@7.8.2))(@nestjs/core@11.1.17)(reflect-metadata@0.2.2)(rxjs@7.8.2)
@@ -53,7 +46,7 @@ importers:
         version: 16.3.2(@testing-library/dom@10.4.1)(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)
       '@testing-library/svelte':
         specifier: ^5.3.1
-        version: 5.3.1(svelte@5.55.1)(vite@7.3.1(@types/node@25.5.0)(lightningcss@1.32.0)(terser@5.47.1)(tsx@4.21.0)(yaml@2.9.0))(vitest@3.2.4(@types/debug@4.1.13)(@types/node@25.5.0)(jsdom@29.0.1)(lightningcss@1.32.0)(terser@5.47.1)(tsx@4.21.0)(yaml@2.9.0))
+        version: 5.3.1(svelte@5.55.1)(vite@7.3.1(@types/node@25.5.0)(lightningcss@1.32.0)(terser@5.47.1)(tsx@4.21.0)(yaml@2.9.0))(vitest@3.2.4(@types/debug@4.1.13)(@types/node@25.5.0)(jsdom@29.0.1(canvas@3.2.3))(lightningcss@1.32.0)(terser@5.47.1)(tsx@4.21.0)(yaml@2.9.0))
       '@testing-library/vue':
         specifier: ^8.1.0
         version: 8.1.0(@vue/compiler-sfc@3.5.31)(vue@3.5.31(typescript@5.9.3))
@@ -77,10 +70,7 @@ importers:
         version: 250829098.0.10
       jsdom:
         specifier: ^29.0.1
-        version: 29.0.1
-      openai:
-        specifier: ^6.34.0
-        version: 6.34.0(ws@8.20.0)(zod@4.3.6)
+        version: 29.0.1(canvas@3.2.3)
       react:
         specifier: ^19.2.4
         version: 19.2.4
@@ -110,16 +100,16 @@ importers:
         version: 5.9.3
       vitest:
         specifier: ^3.0.0
-        version: 3.2.4(@types/debug@4.1.13)(@types/node@25.5.0)(jsdom@29.0.1)(lightningcss@1.32.0)(terser@5.47.1)(tsx@4.21.0)(yaml@2.9.0)
+        version: 3.2.4(@types/debug@4.1.13)(@types/node@25.5.0)(jsdom@29.0.1(canvas@3.2.3))(lightningcss@1.32.0)(terser@5.47.1)(tsx@4.21.0)(yaml@2.9.0)
       vue:
         specifier: ^3.5.31
         version: 3.5.31(typescript@5.9.3)
 
   apps/rn-hermes-fixture:
     dependencies:
-      '@graphrefly/pure-ts':
+      '@graphrefly/ts':
         specifier: workspace:*
-        version: link:../../packages/pure-ts
+        version: link:../../packages/ts
       expo:
         specifier: ^55.0.0
         version: 55.0.24(@babel/core@7.29.0)(@expo/dom-webview@55.0.6)(react-dom@19.2.4(react@19.2.0))(react-native@0.83.6(@babel/core@7.29.0)(@types/react@19.2.14)(react@19.2.0))(react@19.2.0)(typescript@5.9.3)
@@ -150,13 +140,13 @@ importers:
         version: 4.4.4(@types/node@25.5.0)(lightningcss@1.32.0)(solid-js@1.9.12)(terser@5.47.1)
       '@astrojs/svelte':
         specifier: ^7.2.5
-        version: 7.2.5(@types/node@25.5.0)(astro@5.18.1(@types/node@25.5.0)(lightningcss@1.32.0)(rollup@4.60.0)(terser@5.47.1)(tsx@4.21.0)(typescript@5.9.3)(yaml@2.9.0))(lightningcss@1.32.0)(svelte@5.55.1)(terser@5.47.1)(tsx@4.21.0)(typescript@5.9.3)(yaml@2.9.0)
+        version: 7.2.5(@types/node@25.5.0)(astro@5.18.1(@types/node@25.5.0)(lightningcss@1.32.0)(rollup@4.60.0)(terser@5.47.1)(tsx@4.21.0)(typescript@5.9.3)(yaml@2.9.0))(lightningcss@1.32.0)(svelte@5.56.3(@typescript-eslint/types@8.58.0))(terser@5.47.1)(tsx@4.21.0)(typescript@5.9.3)(yaml@2.9.0)
       '@astrojs/vue':
         specifier: ^5.1.4
         version: 5.1.4(@types/node@25.5.0)(astro@5.18.1(@types/node@25.5.0)(lightningcss@1.32.0)(rollup@4.60.0)(terser@5.47.1)(tsx@4.21.0)(typescript@5.9.3)(yaml@2.9.0))(lightningcss@1.32.0)(rollup@4.60.0)(terser@5.47.1)(tsx@4.21.0)(vue@3.5.31(typescript@5.9.3))(yaml@2.9.0)
-      '@graphrefly/graphrefly':
+      '@graphrefly/ts':
         specifier: workspace:*
-        version: link:../..
+        version: link:../../packages/ts
       '@types/react':
         specifier: ^19.0.0
         version: 19.2.14
@@ -180,79 +170,19 @@ importers:
         version: 1.9.12
       svelte:
         specifier: ^5.0.0
-        version: 5.55.1
+        version: 5.56.3(@typescript-eslint/types@8.58.0)
       vue:
         specifier: ^3.5.0
         version: 3.5.31(typescript@5.9.3)
 
-  demos/knowledge-graph:
-    dependencies:
-      '@astrojs/react':
-        specifier: ^4.0.0
-        version: 4.4.2(@types/node@25.5.0)(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(lightningcss@1.32.0)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)(terser@5.47.1)(tsx@4.21.0)(yaml@2.9.0)
-      '@graphrefly/graphrefly':
-        specifier: workspace:*
-        version: link:../..
-      '@graphrefly/pure-ts':
-        specifier: workspace:*
-        version: link:../../packages/pure-ts
-      '@types/react':
-        specifier: ^19.0.0
-        version: 19.2.14
-      '@types/react-dom':
-        specifier: ^19.0.0
-        version: 19.2.3(@types/react@19.2.14)
-      astro:
-        specifier: ^5.16.0
-        version: 5.18.1(@types/node@25.5.0)(lightningcss@1.32.0)(rollup@4.60.0)(terser@5.47.1)(tsx@4.21.0)(typescript@5.9.3)(yaml@2.9.0)
-      mermaid:
-        specifier: ^11.4.1
-        version: 11.14.0
-      react:
-        specifier: ^19.0.0
-        version: 19.2.4
-      react-dom:
-        specifier: ^19.0.0
-        version: 19.2.4(react@19.2.4)
-
-  demos/pagerduty-triage:
-    dependencies:
-      '@astrojs/react':
-        specifier: ^4.0.0
-        version: 4.4.2(@types/node@25.5.0)(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(lightningcss@1.32.0)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)(terser@5.47.1)(tsx@4.21.0)(yaml@2.9.0)
-      '@graphrefly/graphrefly':
-        specifier: workspace:*
-        version: link:../..
-      '@graphrefly/pure-ts':
-        specifier: workspace:*
-        version: link:../../packages/pure-ts
-      '@types/react':
-        specifier: ^19.0.0
-        version: 19.2.14
-      '@types/react-dom':
-        specifier: ^19.0.0
-        version: 19.2.3(@types/react@19.2.14)
-      astro:
-        specifier: ^5.16.0
-        version: 5.18.1(@types/node@25.5.0)(lightningcss@1.32.0)(rollup@4.60.0)(terser@5.47.1)(tsx@4.21.0)(typescript@5.9.3)(yaml@2.9.0)
-      mermaid:
-        specifier: ^11.4.1
-        version: 11.14.0
-      react:
-        specifier: ^19.0.0
-        version: 19.2.4
-      react-dom:
-        specifier: ^19.0.0
-        version: 19.2.4(react@19.2.4)
-
   demos/reactive-layout:
     dependencies:
       '@astrojs/react':
         specifier: ^4.0.0
         version: 4.4.2(@types/node@25.5.0)(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(lightningcss@1.32.0)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)(terser@5.47.1)(tsx@4.21.0)(yaml@2.9.0)
-      '@graphrefly/graphrefly':
+      '@graphrefly/ts':
         specifier: workspace:*
-        version: link:../..
+        version: link:../../packages/ts
       '@types/react':
         specifier: ^19.0.0
         version: 19.2.14
@@ -274,9 +204,9 @@ importers:
 
   examples/basic/state-and-derived:
     dependencies:
-      '@graphrefly/graphrefly':
+      '@graphrefly/ts':
         specifier: workspace:*
-        version: link:../../..
+        version: link:../../../packages/ts
     devDependencies:
       tsx:
         specifier: ^4.21.0
@@ -287,9 +217,9 @@ importers:
 
   examples/compat/jotai:
     dependencies:
-      '@graphrefly/graphrefly':
+      '@graphrefly/ts':
         specifier: workspace:*
-        version: link:../../..
+        version: link:../../../packages/ts
     devDependencies:
       tsx:
         specifier: ^4.21.0
@@ -300,9 +230,9 @@ importers:
 
   examples/compat/nanostores:
     dependencies:
-      '@graphrefly/graphrefly':
+      '@graphrefly/ts':
         specifier: workspace:*
-        version: link:../../..
+        version: link:../../../packages/ts
     devDependencies:
       tsx:
         specifier: ^4.21.0
@@ -313,9 +243,9 @@ importers:
 
   examples/compat/zustand:
     dependencies:
-      '@graphrefly/graphrefly':
+      '@graphrefly/ts':
         specifier: workspace:*
-        version: link:../../..
+        version: link:../../../packages/ts
     devDependencies:
       tsx:
         specifier: ^4.21.0
@@ -326,9 +256,9 @@ importers:
 
   examples/framework/react:
     dependencies:
-      '@graphrefly/graphrefly':
+      '@graphrefly/ts':
         specifier: workspace:*
-        version: link:../../..
+        version: link:../../../packages/ts
       react:
         specifier: ^19.0.0
         version: 19.2.4
@@ -354,9 +284,9 @@ importers:
 
   examples/framework/solid:
     dependencies:
-      '@graphrefly/graphrefly':
+      '@graphrefly/ts':
         specifier: workspace:*
-        version: link:../../..
+        version: link:../../../packages/ts
       solid-js:
         specifier: ^1.9.0
         version: 1.9.12
@@ -373,9 +303,9 @@ importers:
 
   examples/framework/svelte:
     dependencies:
-      '@graphrefly/graphrefly':
+      '@graphrefly/ts':
         specifier: workspace:*
-        version: link:../../..
+        version: link:../../../packages/ts
       svelte:
         specifier: ^5.0.0
         version: 5.55.1
@@ -392,9 +322,9 @@ importers:
 
   examples/framework/vue:
     dependencies:
-      '@graphrefly/graphrefly':
+      '@graphrefly/ts':
         specifier: workspace:*
-        version: link:../../..
+        version: link:../../../packages/ts
       vue:
         specifier: ^3.5.0
         version: 3.5.31(typescript@5.9.3)
@@ -412,37 +342,11 @@ importers:
         specifier: ^2.2.0
         version: 2.2.12(typescript@5.9.3)
 
-  examples/harness-refine-hello:
-    dependencies:
-      '@graphrefly/graphrefly':
-        specifier: workspace:*
-        version: link:../..
-    devDependencies:
-      tsx:
-        specifier: ^4.21.0
-        version: 4.21.0
-      typescript:
-        specifier: ^5.7.0
-        version: 5.9.3
-
-  examples/inbox-reducer:
-    dependencies:
-      '@graphrefly/graphrefly':
-        specifier: workspace:*
-        version: link:../..
-    devDependencies:
-      tsx:
-        specifier: ^4.21.0
-        version: 4.21.0
-      typescript:
-        specifier: ^5.7.0
-        version: 5.9.3
-
   examples/knowledge-graph:
     dependencies:
-      '@graphrefly/graphrefly':
+      '@graphrefly/ts':
         specifier: workspace:*
-        version: link:../..
+        version: link:../../packages/ts
     devDependencies:
       tsx:
         specifier: ^4.21.0
@@ -451,17 +355,20 @@ importers:
         specifier: ^5.7.0
         version: 5.9.3
 
-  examples/nestjs/order-flow:
+  examples/nestjs-graph-boundary:
     dependencies:
-      '@graphrefly/graphrefly':
+      '@graphrefly/ts':
         specifier: workspace:*
-        version: link:../../..
+        version: link:../../packages/ts
       '@nestjs/common':
         specifier: ^11.1.17
         version: 11.1.17(reflect-metadata@0.2.2)(rxjs@7.8.2)
       '@nestjs/core':
         specifier: ^11.1.17
-        version: 11.1.17(@nestjs/common@11.1.17(reflect-metadata@0.2.2)(rxjs@7.8.2))(@nestjs/platform-express@11.1.18)(@nestjs/websockets@11.1.18)(reflect-metadata@0.2.2)(rxjs@7.8.2)
+        version: 11.1.17(@nestjs/common@11.1.17(reflect-metadata@0.2.2)(rxjs@7.8.2))(@nestjs/microservices@11.1.27)(@nestjs/platform-express@11.1.18)(@nestjs/websockets@11.1.18)(reflect-metadata@0.2.2)(rxjs@7.8.2)
+      '@nestjs/microservices':
+        specifier: ^11.1.27
+        version: 11.1.27(@nestjs/common@11.1.17(reflect-metadata@0.2.2)(rxjs@7.8.2))(@nestjs/core@11.1.17)(@nestjs/websockets@11.1.18)(reflect-metadata@0.2.2)(rxjs@7.8.2)
       '@nestjs/platform-express':
         specifier: ^11.1.18
         version: 11.1.18(@nestjs/common@11.1.17(reflect-metadata@0.2.2)(rxjs@7.8.2))(@nestjs/core@11.1.17)
@@ -478,6 +385,9 @@ importers:
         specifier: ^7.8.2
         version: 7.8.2
     devDependencies:
+      '@types/node':
+        specifier: ^25.5.0
+        version: 25.5.0
       tsx:
         specifier: ^4.21.0
         version: 4.21.0
@@ -487,9 +397,9 @@ importers:
 
   examples/reactive-layout/flow:
     dependencies:
-      '@graphrefly/graphrefly':
+      '@graphrefly/ts':
         specifier: workspace:*
-        version: link:../../..
+        version: link:../../../packages/ts
     devDependencies:
       typescript:
         specifier: ^5.7.0
@@ -500,9 +410,9 @@ importers:
 
   examples/spending-alerts:
     dependencies:
-      '@graphrefly/graphrefly':
+      '@graphrefly/ts':
         specifier: workspace:*
-        version: link:../..
+        version: link:../../packages/ts
     devDependencies:
       tsx:
         specifier: ^4.21.0
@@ -511,112 +421,39 @@ importers:
         specifier: ^5.7.0
         version: 5.9.3
 
-  packages/cli:
+  packages/ts:
     dependencies:
-      '@graphrefly/graphrefly':
-        specifier: workspace:*
-        version: link:../..
-    devDependencies:
-      typescript:
-        specifier: ^5.7.0
-        version: 5.9.3
-      vitest:
-        specifier: ^3.0.0
-        version: 3.2.4(@types/debug@4.1.13)(@types/node@25.5.0)(jsdom@29.0.1)(lightningcss@1.32.0)(terser@5.47.1)(tsx@4.21.0)(yaml@2.9.0)
-
-  packages/parity-tests:
-    dependencies:
-      '@graphrefly/native':
-        specifier: ^0.0.5
-        version: 0.0.5
-      '@graphrefly/pure-ts':
-        specifier: workspace:*
-        version: link:../pure-ts
-    devDependencies:
-      '@types/node':
-        specifier: ^25.5.0
-        version: 25.5.0
-      typescript:
-        specifier: ^5.7.0
-        version: 5.9.3
-      vitest:
-        specifier: ^3.0.0
-        version: 3.2.4(@types/debug@4.1.13)(@types/node@25.5.0)(jsdom@29.0.1)(lightningcss@1.32.0)(terser@5.47.1)(tsx@4.21.0)(yaml@2.9.0)
-
-  packages/pure-ts:
-    devDependencies:
-      '@anthropic-ai/sdk':
-        specifier: ^0.82.0
-        version: 0.82.0(zod@4.3.6)
-      '@google/genai':
-        specifier: ^1.48.0
-        version: 1.48.0(@modelcontextprotocol/sdk@1.29.0(zod@4.3.6))
       '@nestjs/common':
-        specifier: ^11.1.17
+        specifier: ^11.0.0
         version: 11.1.17(reflect-metadata@0.2.2)(rxjs@7.8.2)
       '@nestjs/core':
-        specifier: ^11.1.17
-        version: 11.1.17(@nestjs/common@11.1.17(reflect-metadata@0.2.2)(rxjs@7.8.2))(@nestjs/platform-express@11.1.18)(@nestjs/websockets@11.1.18)(reflect-metadata@0.2.2)(rxjs@7.8.2)
-      '@nestjs/platform-express':
-        specifier: ^11.1.18
-        version: 11.1.18(@nestjs/common@11.1.17(reflect-metadata@0.2.2)(rxjs@7.8.2))(@nestjs/core@11.1.17)
-      '@nestjs/platform-ws':
-        specifier: ^11.1.18
-        version: 11.1.18(@nestjs/common@11.1.17(reflect-metadata@0.2.2)(rxjs@7.8.2))(@nestjs/websockets@11.1.18)(rxjs@7.8.2)
-      '@nestjs/testing':
-        specifier: ^11.1.17
-        version: 11.1.17(@nestjs/common@11.1.17(reflect-metadata@0.2.2)(rxjs@7.8.2))(@nestjs/core@11.1.17)(@nestjs/platform-express@11.1.18)
+        specifier: ^11.0.0
+        version: 11.1.17(@nestjs/common@11.1.17(reflect-metadata@0.2.2)(rxjs@7.8.2))(@nestjs/microservices@11.1.27)(@nestjs/platform-express@11.1.18)(@nestjs/websockets@11.1.18)(reflect-metadata@0.2.2)(rxjs@7.8.2)
+      '@nestjs/microservices':
+        specifier: ^11.0.0
+        version: 11.1.27(@nestjs/common@11.1.17(reflect-metadata@0.2.2)(rxjs@7.8.2))(@nestjs/core@11.1.17)(@nestjs/websockets@11.1.18)(reflect-metadata@0.2.2)(rxjs@7.8.2)
       '@nestjs/websockets':
-        specifier: ^11.1.18
+        specifier: ^11.0.0
         version: 11.1.18(@nestjs/common@11.1.17(reflect-metadata@0.2.2)(rxjs@7.8.2))(@nestjs/core@11.1.17)(reflect-metadata@0.2.2)(rxjs@7.8.2)
-      '@solidjs/testing-library':
-        specifier: ^0.8.10
-        version: 0.8.10(solid-js@1.9.12)
-      '@testing-library/react':
-        specifier: ^16.3.2
-        version: 16.3.2(@testing-library/dom@10.4.1)(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)
-      '@testing-library/svelte':
-        specifier: ^5.3.1
-        version: 5.3.1(svelte@5.55.1)(vite@7.3.1(@types/node@25.5.0)(lightningcss@1.32.0)(terser@5.47.1)(tsx@4.21.0)(yaml@2.9.0))(vitest@3.2.4(@types/debug@4.1.13)(@types/node@25.5.0)(jsdom@29.0.1)(lightningcss@1.32.0)(terser@5.47.1)(tsx@4.21.0)(yaml@2.9.0))
-      '@testing-library/vue':
-        specifier: ^8.1.0
-        version: 8.1.0(@vue/compiler-sfc@3.5.31)(vue@3.5.31(typescript@5.9.3))
-      '@types/node':
-        specifier: ^25.5.0
-        version: 25.5.0
-      '@types/react':
-        specifier: ^19.2.14
-        version: 19.2.14
-      '@types/react-dom':
-        specifier: ^19.2.3
-        version: 19.2.3(@types/react@19.2.14)
-      fast-check:
-        specifier: ^4.7.0
-        version: 4.7.0
-      jsdom:
-        specifier: ^29.0.1
-        version: 29.0.1
-      openai:
-        specifier: ^6.34.0
-        version: 6.34.0(ws@8.20.0)(zod@4.3.6)
+      canvas:
+        specifier: ^3.2.3
+        version: 3.2.3
       react:
-        specifier: ^19.2.4
+        specifier: ^18.0.0 || ^19.0.0
         version: 19.2.4
-      react-dom:
-        specifier: ^19.2.4
-        version: 19.2.4(react@19.2.4)
-      reflect-metadata:
-        specifier: ^0.2.2
-        version: 0.2.2
       rxjs:
-        specifier: ^7.8.2
+        specifier: ^7.8.0
         version: 7.8.2
       solid-js:
-        specifier: ^1.9.12
+        specifier: ^1.9.0
         version: 1.9.12
       svelte:
-        specifier: ^5.55.1
-        version: 5.55.1
+        specifier: ^5.0.0
+        version: 5.56.3(@typescript-eslint/types@8.58.0)
+      vue:
+        specifier: ^3.5.0
+        version: 3.5.31(typescript@5.9.3)
+    devDependencies:
       tsup:
         specifier: ^8.5.1
         version: 8.5.1(postcss@8.5.8)(tsx@4.21.0)(typescript@5.9.3)(yaml@2.9.0)
@@ -625,10 +462,20 @@ importers:
         version: 5.9.3
       vitest:
         specifier: ^3.0.0
-        version: 3.2.4(@types/debug@4.1.13)(@types/node@25.5.0)(jsdom@29.0.1)(lightningcss@1.32.0)(terser@5.47.1)(tsx@4.21.0)(yaml@2.9.0)
-      vue:
-        specifier: ^3.5.31
-        version: 3.5.31(typescript@5.9.3)
+        version: 3.2.4(@types/debug@4.1.13)(@types/node@25.5.0)(jsdom@29.0.1(canvas@3.2.3))(lightningcss@1.32.0)(terser@5.47.1)(tsx@4.21.0)(yaml@2.9.0)
+
+  scripts/hermes-smoke:
+    dependencies:
+      '@graphrefly/ts':
+        specifier: workspace:*
+        version: link:../../packages/ts
+    devDependencies:
+      esbuild:
+        specifier: ^0.28.0
+        version: 0.28.0
+      hermes-compiler:
+        specifier: 250829098.0.10
+        version: 250829098.0.10
 
   website:
     dependencies:
@@ -657,15 +504,6 @@ packages:
   '@antfu/utils@0.7.10':
     resolution: {integrity: sha512-+562v9k4aI80m1+VuMHehNJWLOFjBnXn3tdOitzD0il5b7smkSBal4+a3oKiQTbrwMmN/TBUMDvbdoWDehgOww==}
 
-  '@anthropic-ai/sdk@0.82.0':
-    resolution: {integrity: sha512-xdHTjL1GlUlDugHq/I47qdOKp/ROPvuHl7ROJCgUQigbvPu7asf9KcAcU1EqdrP2LuVhEKaTs7Z+ShpZDRzHdQ==}
-    hasBin: true
-    peerDependencies:
-      zod: ^3.25.0 || ^4.0.0
-    peerDependenciesMeta:
-      zod:
-        optional: true
-
   '@asamuzakjp/css-color@5.1.1':
     resolution: {integrity: sha512-iGWN8E45Ws0XWx3D44Q1t6vX2LqhCKcwfmwBYCDsFrYFS6m4q/Ks61L2veETaLv+ckDC6+dTETJoaAAb7VjLiw==}
     engines: {node: ^20.19.0 || ^22.12.0 || >=24.0.0}
@@ -2210,57 +2048,6 @@ packages:
   '@expressive-code/plugin-text-markers@0.41.7':
     resolution: {integrity: sha512-Ewpwuc5t6eFdZmWlFyeuy3e1PTQC0jFvw2Q+2bpcWXbOZhPLsT7+h8lsSIJxb5mS7wZko7cKyQ2RLYDyK6Fpmw==}
 
-  '@google/genai@1.48.0':
-    resolution: {integrity: sha512-plonYK4ML2PrxsRD9SeqmFt76eREWkQdPCglOA6aYDzL1AAbE+7PUnT54SvpWGfws13L0AZEqGSpL7+1IPnTxQ==}
-    engines: {node: '>=20.0.0'}
-    peerDependencies:
-      '@modelcontextprotocol/sdk': ^1.25.2
-    peerDependenciesMeta:
-      '@modelcontextprotocol/sdk':
-        optional: true
-
-  '@graphrefly/native-darwin-arm64@0.0.5':
-    resolution: {integrity: sha512-bSFy2EgJ4NIErqVla65Ol7D2LKyqAB7RDs04+J+DyxGh5IJYSBZFPnp4OdBjVM6PSVXIPHEMbe8ZY50uk9cmzA==}
-    engines: {node: '>=14'}
-    cpu: [arm64]
-    os: [darwin]
-
-  '@graphrefly/native-linux-arm64-gnu@0.0.5':
-    resolution: {integrity: sha512-UM6y0xk5dJGS7cFGw8MgHCOqnovNeOYrtplfOSLZytfEve2pvXf9BUzZdGOGeInt+QQhFxYd06SuDM/uG2SdJA==}
-    engines: {node: '>=14'}
-    cpu: [arm64]
-    os: [linux]
-    libc: [glibc]
-
-  '@graphrefly/native-linux-x64-gnu@0.0.5':
-    resolution: {integrity: sha512-TNxXZEKf0xgaGg0TJeBGtOQVqnp9clzwIncRdf6G+mqgYrZF/xaJVnAumk3I47iEHlZEa0Ohf+5AAChrmPp/UA==}
-    engines: {node: '>=14'}
-    cpu: [x64]
-    os: [linux]
-    libc: [glibc]
-
-  '@graphrefly/native-win32-arm64-msvc@0.0.5':
-    resolution: {integrity: sha512-z10zse0Zuxm4HweQMfY1rQk44IdECEMJbXCcc3wiev/CWE83Tjra9SAnHK5e9AtHsG8F1q6V+Sqo45FcJXNHfg==}
-    engines: {node: '>=14'}
-    cpu: [arm64]
-    os: [win32]
-
-  '@graphrefly/native-win32-x64-msvc@0.0.5':
-    resolution: {integrity: sha512-huTdocheZQr0WTS7DyV+soI00QREyaAi2hus7v964Fv2yqfabmTLQshUEwbCtySTWwVHIUAZ89Fu4n4Q0MFNgg==}
-    engines: {node: '>=14'}
-    cpu: [x64]
-    os: [win32]
-
-  '@graphrefly/native@0.0.5':
-    resolution: {integrity: sha512-4l7NsFWl35hSCeMyEPaXpYNIAr+wX+SIdnlvWfZg07KSYQy+8tT4vq6+yb3KusI6j+ad8BQmpZ2Ez8AfS0bSEA==}
-    engines: {node: '>=14'}
-
-  '@hono/node-server@1.19.14':
-    resolution: {integrity: sha512-GwtvgtXxnWsucXvbQXkRgqksiH2Qed37H9xHZocE5sA3N8O8O8/8FA3uclQXxXVzc9XBZuEOMK7+r02FmSpHtw==}
-    engines: {node: '>=18.14.1'}
-    peerDependencies:
-      hono: ^4
-
   '@iconify/types@2.0.0':
     resolution: {integrity: sha512-+wluvCrRhXrhyOmRDJ3q8mux9JkKy5SJ/v8ol2tu4FVjyYvtEzkc/3pK15ET6RKg4b4w4BmTk1+gsCUhf21Ykg==}
 
@@ -2504,16 +2291,6 @@ packages:
   '@mermaid-js/parser@1.1.0':
     resolution: {integrity: sha512-gxK9ZX2+Fex5zu8LhRQoMeMPEHbc73UKZ0FQ54YrQtUxE1VVhMwzeNtKRPAu5aXks4FasbMe4xB4bWrmq6Jlxw==}
 
-  '@modelcontextprotocol/sdk@1.29.0':
-    resolution: {integrity: sha512-zo37mZA9hJWpULgkRpowewez1y6ML5GsXJPY8FI0tBBCd77HEvza4jDqRKOXgHNn867PVGCyTdzqpz0izu5ZjQ==}
-    engines: {node: '>=18'}
-    peerDependencies:
-      '@cfworker/json-schema': ^4.1.1
-      zod: ^3.25 || ^4.0
-    peerDependenciesMeta:
-      '@cfworker/json-schema':
-        optional: true
-
   '@nestjs/common@11.1.17':
     resolution: {integrity: sha512-hLODw5Abp8OQgA+mUO4tHou4krKgDtUcM9j5Ihxncst9XeyxYBTt2bwZm4e4EQr5E352S4Fyy6V3iFx9ggxKAg==}
     peerDependencies:
@@ -2545,6 +2322,42 @@ packages:
       '@nestjs/websockets':
         optional: true
 
+  '@nestjs/microservices@11.1.27':
+    resolution: {integrity: sha512-wVUuNNFxILFtG6CvzvdcF/2/CtwWTKNR8AXsHzH7+JKoJY1xAXqvw8b6LArUKyRpOfsiKMLCC/KKvvA4Enh/xg==}
+    peerDependencies:
+      '@grpc/grpc-js': '*'
+      '@nestjs/common': ^11.0.0
+      '@nestjs/core': ^11.0.0
+      '@nestjs/websockets': ^11.0.0
+      amqp-connection-manager: '*'
+      amqplib: '*'
+      cache-manager: '*'
+      ioredis: '*'
+      kafkajs: '*'
+      mqtt: '*'
+      nats: '*'
+      reflect-metadata: ^0.1.12 || ^0.2.0
+      rxjs: ^7.1.0
+    peerDependenciesMeta:
+      '@grpc/grpc-js':
+        optional: true
+      '@nestjs/websockets':
+        optional: true
+      amqp-connection-manager:
+        optional: true
+      amqplib:
+        optional: true
+      cache-manager:
+        optional: true
+      ioredis:
+        optional: true
+      kafkajs:
+        optional: true
+      mqtt:
+        optional: true
+      nats:
+        optional: true
+
   '@nestjs/platform-express@11.1.18':
     resolution: {integrity: sha512-s6GdHMTa3qx0fJewR74Xa30ysPHfBEqxIwZ7BGSTLoAEQ1vTP24urNl+b6+s49NFLEIOyeNho5fN/9/I17QlOw==}
     peerDependencies:
@@ -2646,36 +2459,6 @@ packages:
   '@polka/url@1.0.0-next.29':
     resolution: {integrity: sha512-wwQAWhWSuHaag8c4q/KN/vCoeOJYshAIvMQwD4GpSb3OiZklFfvAgmj0VCBBImRpuF/aFgIRzllXlVX93Jevww==}
 
-  '@protobufjs/aspromise@1.1.2':
-    resolution: {integrity: sha512-j+gKExEuLmKwvz3OgROXtrJ2UG2x8Ch2YZUxahh+s1F2HZ+wAceUNLkvy6zKCPVRkU++ZWQrdxsUeQXmcg4uoQ==}
-
-  '@protobufjs/base64@1.1.2':
-    resolution: {integrity: sha512-AZkcAA5vnN/v4PDqKyMR5lx7hZttPDgClv83E//FMNhR2TMcLUhfRUBHCmSl0oi9zMgDDqRUJkSxO3wm85+XLg==}
-
-  '@protobufjs/codegen@2.0.4':
-    resolution: {integrity: sha512-YyFaikqM5sH0ziFZCN3xDC7zeGaB/d0IUb9CATugHWbd1FRFwWwt4ld4OYMPWu5a3Xe01mGAULCdqhMlPl29Jg==}
-
-  '@protobufjs/eventemitter@1.1.0':
-    resolution: {integrity: sha512-j9ednRT81vYJ9OfVuXG6ERSTdEL1xVsNgqpkxMsbIabzSo3goCjDIveeGv5d03om39ML71RdmrGNjG5SReBP/Q==}
-
-  '@protobufjs/fetch@1.1.0':
-    resolution: {integrity: sha512-lljVXpqXebpsijW71PZaCYeIcE5on1w5DlQy5WH6GLbFryLUrBD4932W/E2BSpfRJWseIL4v/KPgBFxDOIdKpQ==}
-
-  '@protobufjs/float@1.0.2':
-    resolution: {integrity: sha512-Ddb+kVXlXst9d+R9PfTIxh1EdNkgoRe5tOX6t01f1lYWOvJnSPDBlG241QLzcyPdoNTsblLUdujGSE4RzrTZGQ==}
-
-  '@protobufjs/inquire@1.1.0':
-    resolution: {integrity: sha512-kdSefcPdruJiFMVSbn801t4vFK7KB/5gd2fYvrxhuJYg8ILrmn9SKSX2tZdV6V+ksulWqS7aXjBcRXl3wHoD9Q==}
-
-  '@protobufjs/path@1.1.2':
-    resolution: {integrity: sha512-6JOcJ5Tm08dOHAbdR3GrvP+yUUfkjG5ePsHYczMFLq3ZmMkAD98cDgcT2iA1lJ9NVwFd4tH/iSSoe44YWkltEA==}
-
-  '@protobufjs/pool@1.1.0':
-    resolution: {integrity: sha512-0kELaGSIDBKvcgS4zkjz1PeddatrjYcmMWOlAuAPwAeccUrPHdUqo/J6LiymHHEiJT5NrF1UVwxY14f+fy4WQw==}
-
-  '@protobufjs/utf8@1.1.0':
-    resolution: {integrity: sha512-Vvn3zZrhQZkkBE8LSuW3em98c0FwgO4nxzv6OdSxPKJIEKY2bGbHn+mhGIPerzI4twdxaP8/0+06HBpwf345Lw==}
-
   '@react-native/assets-registry@0.83.6':
     resolution: {integrity: sha512-iljb4ue1yWJ3EhySz7EjV6CzSVrI2uNtR8BI2jzP5+QS5E4Cl3fdIJRmVwDEx1pu8uE97PGEusGRHnoaZ9Q3jg==}
     engines: {node: '>= 20.19.4'}
@@ -2745,9 +2528,6 @@ packages:
   '@rolldown/pluginutils@1.0.0-beta.27':
     resolution: {integrity: sha512-+d0F4MKMCbeVUJwG96uQ4SgAznZNSq93I3V+9NHA4OpvqG8mRCpGdKmK8l/dl02h2CCDHwW2FqilnTyDcAnqjA==}
 
-  '@rolldown/pluginutils@1.0.0-rc.16':
-    resolution: {integrity: sha512-45+YtqxLYKDWQouLKCrpIZhke+nXxhsw+qAHVzHDVwttyBlHNBVs2K25rDXrZzhpTp9w1FlAlvweV1H++fdZoA==}
-
   '@rollup/pluginutils@5.3.0':
     resolution: {integrity: sha512-5EdhGZtnu3V88ces7s53hhfK5KSASnJZv8Lulpc04cWO3REESroJXg73DFsOmgbU2BhwV0E20bu2IDZb3VKW4Q==}
     engines: {node: '>=14.0.0'}
@@ -2942,6 +2722,11 @@ packages:
       '@solidjs/router':
         optional: true
 
+  '@sveltejs/acorn-typescript@1.0.10':
+    resolution: {integrity: sha512-4WfKk68eTih+MiJD4fSbxN7E8kVBmTMPWHUPYjvl2N0rMs53YLTT8/YjKU5Dtnz5LqDjl7LEw4U7lXR2W3J5WA==}
+    peerDependencies:
+      acorn: ^8.9.0
+
   '@sveltejs/acorn-typescript@1.0.9':
     resolution: {integrity: sha512-lVJX6qEgs/4DOcRTpo56tmKzVPtoWAaVbL4hfO7t7NVwl9AAXzQR6cihesW1BmNMPl+bK6dreu2sOKBP2Q9CIA==}
     peerDependencies:
@@ -3194,9 +2979,6 @@ packages:
   '@types/react@19.2.14':
     resolution: {integrity: sha512-ilcTH/UniCkMdtexkoCN0bI7pMcJDvmQFPvuPvmEaYA/NSfFTAgdUSLAoVjaRJm7+6PvcM+q1zYOwS4wTYMF9w==}
 
-  '@types/retry@0.12.0':
-    resolution: {integrity: sha512-wWKOClTTiizcZhXnPY4wikVAwmdYHp8q6DmC+EJUzAMsycb7HB32Kh9RN4+0gExjmPmZSAQjgURXIGATPegAvA==}
-
   '@types/sax@1.2.7':
     resolution: {integrity: sha512-rO73L89PJxeYM3s3pPPjiPgVVcymqU490g0YO5n5By0k2Erzj6tay/4lr1CHAAU4JyOWd1rpQ8bCf6cZfHU96A==}
 
@@ -3395,17 +3177,6 @@ packages:
     resolution: {integrity: sha512-MnA+YT8fwfJPgBx3m60MNqakm30XOkyIoH1y6huTQvC0PwZG7ki8NacLBcrPbNoo8vEZy7Jpuk7+jMO+CUovTQ==}
     engines: {node: '>= 14'}
 
-  ajv-formats@3.0.1:
-    resolution: {integrity: sha512-8iUql50EUR+uUcdRQ3HDqa6EVyo3docL8g5WJ3FNcWmu62IbkGUue/pEyLBW8VGKKucTPgqeks4fIU1DA4yowQ==}
-    peerDependencies:
-      ajv: ^8.0.0
-    peerDependenciesMeta:
-      ajv:
-        optional: true
-
-  ajv@8.20.0:
-    resolution: {integrity: sha512-Thbli+OlOj+iMPYFBVBfJ3OmCAnaSyNn4M1vz9T6Gka5Jt9ba/HIR56joy65tY6kx/FCF5VXNB819Y7/GUrBGA==}
-
   alien-signals@1.0.13:
     resolution: {integrity: sha512-OGj9yyTnJEttvzhTUWuscOvtqxq5vrhF7vL9oS0xJ2mK0ItPYP1/y+vCFebfxoEyAz0++1AIwJ5CMr+Fk3nDmg==}
 
@@ -3654,12 +3425,12 @@ packages:
     resolution: {integrity: sha512-QxD8cf2eVqJOOz63z6JIN9BzvVs/dlySa5HGSBH5xtR8dPteIRQnBxxKqkNTiT6jbDTF6jAfrd4oMcND9RGbQg==}
     engines: {node: '>=0.6'}
 
-  bignumber.js@9.3.1:
-    resolution: {integrity: sha512-Ko0uX15oIUS7wJ3Rb30Fs6SkVbLmPBAKdlm7q9+ak9bbIeFf0MwuBsQV6z7+X768/cHsfg+WlysDWJcmthjsjQ==}
-
   birpc@2.9.0:
     resolution: {integrity: sha512-KrayHS5pBi69Xi9JmvoqrIgYGDkD6mcSe/i6YKi3w5kekCLzrX4+nawcXqrj2tIp50Kw/mT/s3p+GVK0A0sKxw==}
 
+  bl@4.1.0:
+    resolution: {integrity: sha512-1W07cM9gS6DcLperZfFSj+bWLtaPGSOHWhPiGzXmvVJbRLdG82sH/Kn8EtW1VqWVA54AKf2h5k5BbnIbwF3h6w==}
+
   body-parser@2.2.2:
     resolution: {integrity: sha512-oP5VkATKlNwcgvxi0vM0p/D3n2C3EReYVX+DNYs5TjZFn/oQt2j+4sVJtSMr18pdRr8wjTcBl6LoV+FUwzPmNA==}
     engines: {node: '>=18'}
@@ -3704,12 +3475,12 @@ packages:
   bser@2.1.1:
     resolution: {integrity: sha512-gQxTNE/GAfIIrmHLUE3oJyp5FO6HRBfhjnw4/wMmA63ZGDJnWBmgY/lyQBpnDUkGmAhbSe39tx2d/iTOAfglwQ==}
 
-  buffer-equal-constant-time@1.0.1:
-    resolution: {integrity: sha512-zRpUiDwd/xk6ADqPMATG8vc9VPrkck7T07OIx0gnjmJAnHnTVXNQG3vfvWNuiZIkwu9KrKdA1iJKfsfTVxE6NA==}
-
   buffer-from@1.1.2:
     resolution: {integrity: sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ==}
 
+  buffer@5.7.1:
+    resolution: {integrity: sha512-EHcyIPBQ4BSGlvjB16k5KgAJ27CIsHY/2JBmCRReo48y9rQ3MaUzWX3KVlBa4U7MyX02HdVj0K7C3WaB3ju7FQ==}
+
   bundle-name@4.1.0:
     resolution: {integrity: sha512-tjwM5exMg6BGRI+kNmTntNsvdZS1X8BFYS6tnJ2hdH0kVxM6/eVZ2xy+FqStSWvYmtfFMDLIxurorHwDKfDz5Q==}
     engines: {node: '>=18'}
@@ -3759,6 +3530,10 @@ packages:
   caniuse-lite@1.0.30001788:
     resolution: {integrity: sha512-6q8HFp+lOQtcf7wBK+uEenxymVWkGKkjFpCvw5W25cmMwEDU45p1xQFBQv8JDlMMry7eNxyBaR+qxgmTUZkIRQ==}
 
+  canvas@3.2.3:
+    resolution: {integrity: sha512-PzE5nJZPz72YUAfo8oTp0u3fqqY7IzlTubneAihqDYAUcBk7ryeCmBbdJBEdaH0bptSOe2VT2Zwcb3UaFyaSWw==}
+    engines: {node: ^18.12.0 || >= 20.9.0}
+
   ccount@2.0.1:
     resolution: {integrity: sha512-eyrF0jiFpY+3drT6383f1qhkbGsLSifNAjA61IUjZjmLCWjItY6LB9ft9YhoDgwfmclB2zhu51Lc7+95b8NRAg==}
 
@@ -3814,6 +3589,9 @@ packages:
     resolution: {integrity: sha512-TQMmc3w+5AxjpL8iIiwebF73dRDF4fBIieAqGn9RGCWaEVwQ6Fb2cGe31Yns0RRIzii5goJ1Y7xbMwo1TxMplw==}
     engines: {node: '>= 20.19.0'}
 
+  chownr@1.1.4:
+    resolution: {integrity: sha512-jJ0bqzaylmJtVnNgzTeSOs8DPavpbYgEr/b0YL8/2GO3xJEhInFmhKMUnEJQjZumK7KXGFhUy89PrsJWlakBVg==}
+
   chrome-launcher@0.15.2:
     resolution: {integrity: sha512-zdLEwNo3aUVzIhKhTtXfxhdvZhUghrnmkvcAq2NoDd+LeOHKf03H5jwZ8T/STsAlzyALkBVK552iaG1fGf1xVQ==}
     engines: {node: '>=12.13.0'}
@@ -4171,10 +3949,6 @@ packages:
   dagre-d3-es@7.0.14:
     resolution: {integrity: sha512-P4rFMVq9ESWqmOgK+dlXvOtLwYg0i7u0HBGJER0LZDJT2VHIPAMZ/riPxqJceWMStH5+E61QxFra9kIS3AqdMg==}
 
-  data-uri-to-buffer@4.0.1:
-    resolution: {integrity: sha512-0R9ikRb668HB7QDxT1vkpuUBtqc53YyAwMwGeUFKRojY/NWKvdZ+9UYtRfGmhqNbRkTSVpMbmyhXipFFv2cb/A==}
-    engines: {node: '>= 12'}
-
   data-urls@7.0.0:
     resolution: {integrity: sha512-23XHcCF+coGYevirZceTVD7NdJOqVn+49IHyxgszm+JIiHLoB2TkmPtsYkNWT1pvRSGkc35L6NHs0yHkN2SumA==}
     engines: {node: ^20.19.0 || ^22.12.0 || >=24.0.0}
@@ -4219,6 +3993,10 @@ packages:
   decode-named-character-reference@1.3.0:
     resolution: {integrity: sha512-GtpQYB283KrPp6nRw50q3U9/VfOutZOe103qlN7BPP6Ad27xYnOIWv4lPzo8HCAL+mMZofJ9KEy30fq6MfaK6Q==}
 
+  decompress-response@6.0.0:
+    resolution: {integrity: sha512-aW35yZM6Bb/4oJlZncMH2LCoZtJXTRxES17vE3hoRiowU2kWHaJKFkSBDnDR+cm9J+9QhXmREyIfv0pji9ejCQ==}
+    engines: {node: '>=10'}
+
   dedent-js@1.0.1:
     resolution: {integrity: sha512-OUepMozQULMLUmhxS95Vudo0jb0UchLimi3+pQ2plj61Fcy8axbP9hbiD4Sz6DPqn6XG3kfmziVfQ1rSys5AJQ==}
 
@@ -4230,6 +4008,10 @@ packages:
     resolution: {integrity: sha512-ZIwpnevOurS8bpT4192sqAowWM76JDKSHYzMLty3BZGSswgq6pBaH3DhCSW5xVAZICZyKdOBPjwww5wfgT/6PA==}
     engines: {node: '>= 0.4'}
 
+  deep-extend@0.6.0:
+    resolution: {integrity: sha512-LOHxIOaPYdHlJRtCQfDIVZtfw/ufM8+rVj649RIHzcm/vGwQRXFt6OPqIFWsm2XEMrNIEtWR64sY1LEKD2vAOA==}
+    engines: {node: '>=4.0.0'}
+
   deepmerge@4.3.1:
     resolution: {integrity: sha512-3sUqbMEc77XqpdNO7FRyRog+eW3ph+GYCbj+rK+uYyRMuwsVy0rMiVtPn+QJlKFvWP/1PYpapqYn0Me2knFn+A==}
     engines: {node: '>=0.10.0'}
@@ -4297,6 +4079,9 @@ packages:
   devalue@5.6.4:
     resolution: {integrity: sha512-Gp6rDldRsFh/7XuouDbxMH3Mx8GMCcgzIb1pDTvNyn8pZGQ22u+Wa+lGV9dQCltFQ7uVw0MhRyb8XDskNFOReA==}
 
+  devalue@5.8.1:
+    resolution: {integrity: sha512-4CXDYRBGqN+57wVJkuXBYmpAVUSg3L6JAQa/DFqm238G73E1wuyc/JhGQJzN7vUf/CMphYau2zXbfWzDR5aTEw==}
+
   devlop@1.1.0:
     resolution: {integrity: sha512-RWmIqhcFf1lRYBvNmr7qTNuyCt/7/ns2jbpp1+PalgE/rDQcBT0fioSMUpJ93irlUhC5hrg4cYqe6U+0ImW0rA==}
 
@@ -4352,9 +4137,6 @@ packages:
   eastasianwidth@0.2.0:
     resolution: {integrity: sha512-I88TYZWc9XiYHRQ4/3c5rjjfgkjhLyW2luGIheGERbNQ6OY7yTybanSpDXZa8y7VUP9YmDcYa+eyq4ca7iLqWA==}
 
-  ecdsa-sig-formatter@1.0.11:
-    resolution: {integrity: sha512-nagl3RYrbNv6kQkeJIpt6NJZy8twLB/2vtz6yN9Z4vRKHN4/QZJIEbqohALSgwKdnksuY3k5Addp5lg8sVoVcQ==}
-
   editorconfig@1.0.7:
     resolution: {integrity: sha512-e0GOtq/aTQhVdNyDU9e02+wz9oDDM+SIOQxWME2QRjzRX5yyLAuHDE+0aE8vHb9XRC8XD37eO2u57+F09JqFhw==}
     engines: {node: '>=14'}
@@ -4383,6 +4165,9 @@ packages:
     resolution: {integrity: sha512-Q0n9HRi4m6JuGIV1eFlmvJB7ZEVxu93IrMyiMsGC0lrMJMWzRgx6WGquyfQgZVb31vhGgXnfmPNNXmxnOkRBrg==}
     engines: {node: '>= 0.8'}
 
+  end-of-stream@1.4.5:
+    resolution: {integrity: sha512-ooEGc6HP26xXq/N+GCGOT0JKCLDGrq2bQUZrQ7gyrJiZANJ/8YDTxTpQBXGMn+WbIQXNVpyWymm7KYVICQnyOg==}
+
   enquirer@2.4.1:
     resolution: {integrity: sha512-rRqJg/6gd538VHvR3PSrdRBb/1Vy2YfzHqzvbhGIQpDRKIa4FgV/54b5Q1xYSxOOwKvjXweS26E0Q+nAMwp2pQ==}
     engines: {node: '>=8.6'}
@@ -4480,6 +4265,14 @@ packages:
     engines: {node: '>=4'}
     hasBin: true
 
+  esrap@2.2.11:
+    resolution: {integrity: sha512-gPdx+I+BjYEinNMQaBXFjbaJVyoPMU4ZODg5mE+M4DqVG9VusAVHHjcBX+zqyITlI0DIARwDMMzZwAWj36dRoQ==}
+    peerDependencies:
+      '@typescript-eslint/types': ^8.2.0
+    peerDependenciesMeta:
+      '@typescript-eslint/types':
+        optional: true
+
   esrap@2.2.4:
     resolution: {integrity: sha512-suICpxAmZ9A8bzJjEl/+rLJiDKC0X4gYWUxT6URAWBLvlXmtbZd5ySMu/N2ZGEtMCAmflUDPSehrP9BQcsGcSg==}
 
@@ -4518,18 +4311,14 @@ packages:
   eventemitter3@5.0.4:
     resolution: {integrity: sha512-mlsTRyGaPBjPedk6Bvw+aqbsXDtoAyAzm5MO7JgU+yVRyMQ5O8bD4Kcci7BS85f93veegeCPkL8R4GLClnjLFw==}
 
-  eventsource-parser@3.0.8:
-    resolution: {integrity: sha512-70QWGkr4snxr0OXLRWsFLeRBIRPuQOvt4s8QYjmUlmlkyTZkRqS7EDVRZtzU3TiyDbXSzaOeF0XUKy8PchzukQ==}
-    engines: {node: '>=18.0.0'}
-
-  eventsource@3.0.7:
-    resolution: {integrity: sha512-CRT1WTyuQoD771GW56XEZFQ/ZoSfWid1alKGDYMmkt2yl8UXrVR4pspqWNEcqKvVIzg6PAltWjxcSSPrboA4iA==}
-    engines: {node: '>=18.0.0'}
-
   execa@9.6.1:
     resolution: {integrity: sha512-9Be3ZoN4LmYR90tUoVu2te2BsbzHfhJyfEiAVfz7N5/zv+jduIfLrV2xdQXOHbaD6KgpGdO9PRPM1Y4Q9QkPkA==}
     engines: {node: ^18.19.0 || >=20.5.0}
 
+  expand-template@2.0.3:
+    resolution: {integrity: sha512-XYfuKMvj4O35f/pOXLObndIRvyQ+/+6AhODh+OKWj9S9498pHHn/IMszH+gt0fBCRWMNfk1ZSp5x3AifmnI2vg==}
+    engines: {node: '>=6'}
+
   expect-type@1.3.0:
     resolution: {integrity: sha512-knvyeauYhqjOYvQ66MznSMs83wmHrCycNEN6Ao+2AeYEfxUIkuiVxdEa1qlGEPK+We3n0THiDciYSsCcgW/DoA==}
     engines: {node: '>=12.0.0'}
@@ -4610,12 +4399,6 @@ packages:
   exponential-backoff@3.1.3:
     resolution: {integrity: sha512-ZgEeZXj30q+I0EN+CbSSpIyPaJ5HVQD18Z1m+u1FXbAeT94mr1zw50q4q6jiiC447Nl/YTcIYSAftiGqetwXCA==}
 
-  express-rate-limit@8.5.2:
-    resolution: {integrity: sha512-5Kb34ipNX694DH48vN9irak1Qx30nb0PLYHXfJgw4YEjiC3ZEmZJhwOp+VfiCYwFzvFTdB9QkArYS5kXa2cx2A==}
-    engines: {node: '>= 16'}
-    peerDependencies:
-      express: '>= 4.11'
-
   express@5.2.1:
     resolution: {integrity: sha512-hIS4idWWai69NezIdRt2xFVofaF4j+6INOpJlVOLDO8zXGpUVEVzIYk12UUi2JzjEzWL3IOAxcTubgz9Po0yXw==}
     engines: {node: '>= 18'}
@@ -4633,9 +4416,6 @@ packages:
     resolution: {integrity: sha512-NsZRtqvSSoCP0HbNjUD+r1JH8zqZalyp6gLY9e7OYs7NK9b6AHOs2baBFeBG7bVNsuoukh89x2Yg3rPsul8ziQ==}
     engines: {node: '>=12.17.0'}
 
-  fast-deep-equal@3.1.3:
-    resolution: {integrity: sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==}
-
   fast-glob@3.3.3:
     resolution: {integrity: sha512-7MptL8U0cqcFdzIzwOTHoilX9x5BrNqye7Z/LuC7kCMRio1EMSyqRK3BEAUD7sXRq4iT4AzTVuZdhgQ2TCvYLg==}
     engines: {node: '>=8.6.0'}
@@ -4646,9 +4426,6 @@ packages:
   fast-safe-stringify@2.1.1:
     resolution: {integrity: sha512-W+KJc2dmILlPplD/H4K9l9LcAHAfPtP6BY84uVLXQ6Evcz9Lcg33Y2z1IVblT6xdY54PXYVHEv+0Wpq8Io6zkA==}
 
-  fast-uri@3.1.2:
-    resolution: {integrity: sha512-rVjf7ArG3LTk+FS6Yw81V1DLuZl1bRbNrev6Tmd/9RaroeeRRJhAt7jg/6YFxbvAQXUCavSoZhPPj6oOx+5KjQ==}
-
   fast-xml-builder@1.1.4:
     resolution: {integrity: sha512-f2jhpN4Eccy0/Uz9csxh3Nu6q4ErKxf0XIsasomfOihuSUa3/xw6w8dnOtCDgEItQFJG8KyXPzQXzcODDrrbOg==}
 
@@ -4676,10 +4453,6 @@ packages:
       picomatch:
         optional: true
 
-  fetch-blob@3.2.0:
-    resolution: {integrity: sha512-7yAQpD2UMJzLi1Dqv7qFYnPbaPx7ZfFK6PiIxQ4PfkGPyNyl2Ugx+a/umUonmKqjhM4DnfbMvdX6otXq83soQQ==}
-    engines: {node: ^12.20 || >= 14.13}
-
   fetch-nodeshim@0.4.10:
     resolution: {integrity: sha512-m6I8ALe4L4XpdETy7MJZWs6L1IVMbjs99bwbpIKphxX+0CTns4IKDWJY0LWfr4YsFjfg+z1TjzTMU8lKl8rG0w==}
 
@@ -4735,10 +4508,6 @@ packages:
     resolution: {integrity: sha512-gIXjKqtFuWEgzFRJA9WCQeSJLZDjgJUOMCMzxtvFq/37KojM1BFGufqsCy0r4qSQmYLsZYMeyRqzIWOMup03sw==}
     engines: {node: '>=14'}
 
-  formdata-polyfill@4.0.10:
-    resolution: {integrity: sha512-buewHzMvYL29jdeQTVILecSaZKnt/RJWjoZCF5OW60Z67/GmSLBkOFM7qh1PI3zFNtJbaZL5eQu1vLfazOwj4g==}
-    engines: {node: '>=12.20.0'}
-
   forwarded@0.2.0:
     resolution: {integrity: sha512-buRG0fpBtRHSTCOASe6hD258tEubFoRLb4ZNA6NxMVHNw2gOcwHo9wyablzMzOA5z9xA9L1KNjk/Nt6MT9aYow==}
     engines: {node: '>= 0.6'}
@@ -4751,8 +4520,11 @@ packages:
     resolution: {integrity: sha512-Rx/WycZ60HOaqLKAi6cHRKKI7zxWbJ31MhntmtwMoaTeF7XFH9hhBp8vITaMidfljRQ6eYWCKkaTK+ykVJHP2A==}
     engines: {node: '>= 0.8'}
 
-  fs-extra@11.3.4:
-    resolution: {integrity: sha512-CTXd6rk/M3/ULNQj8FBqBWHYBVYybQ3VPBw0xGKFe3tuH7ytT6ACnvzpIQ3UZtB8yvUKC2cXn1a+x+5EVQLovA==}
+  fs-constants@1.0.0:
+    resolution: {integrity: sha512-y6OAwoSIf7FyjMIv94u+b5rdheZEjzR63GTyZJm5qh4Bi+2YgwLCcI/fPFZkL5PSixOt6ZNKm+w+Hfp/Bciwow==}
+
+  fs-extra@11.3.5:
+    resolution: {integrity: sha512-eKpRKAovdpZtR1WopLHxlBWvAgPny3c4gX1G5Jhwmmw4XJj0ifSD5qB5TOo8hmA0wlRKDAOAhEE1yVPgs6Fgcg==}
     engines: {node: '>=14.14'}
 
   fs-extra@7.0.1:
@@ -4777,14 +4549,6 @@ packages:
   functions-have-names@1.2.3:
     resolution: {integrity: sha512-xckBUXyTIqT97tq2x2AMb+g163b5JFysYk0x4qxNFwbfQkmNZoiRHb6sPzI9/QV33WeuvVYBUIiD4NzNIyqaRQ==}
 
-  gaxios@7.1.4:
-    resolution: {integrity: sha512-bTIgTsM2bWn3XklZISBTQX7ZSddGW+IO3bMdGaemHZ3tbqExMENHLx6kKZ/KlejgrMtj8q7wBItt51yegqalrA==}
-    engines: {node: '>=18'}
-
-  gcp-metadata@8.1.2:
-    resolution: {integrity: sha512-zV/5HKTfCeKWnxG0Dmrw51hEWFGfcF2xiXqcA3+J90WDuP0SvoiSO5ORvcBsifmx/FoIjgQN3oNOGaQ5PhLFkg==}
-    engines: {node: '>=18'}
-
   gensync@1.0.0-beta.2:
     resolution: {integrity: sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg==}
     engines: {node: '>=6.9.0'}
@@ -4820,6 +4584,9 @@ packages:
     resolution: {integrity: sha512-VilgtJj/ALgGY77fiLam5iD336eSWi96Q15JSAG1zi8NRBysm3LXKdGnHb4m5cuyxvOLQQKWpBZAT6ni4FI2iQ==}
     engines: {node: '>=6'}
 
+  github-from-package@0.0.0:
+    resolution: {integrity: sha512-SyHy3T1v2NUXn29OsWdxmK6RwHD+vkj3v8en8AOBZ1wBQ/hCAQ5bAQTD02kW4W9tUp/3Qh6J8r9EvntiyCmOOw==}
+
   github-slugger@2.0.0:
     resolution: {integrity: sha512-IaOQ9puYtjrkq7Y0Ygl9KDZnrf/aiUJYUpVf89y8kyaxbRG7Y1SrX/jaumrv81vc61+kiMempujsM3Yw7w5qcw==}
 
@@ -4844,14 +4611,6 @@ packages:
     resolution: {integrity: sha512-jhIXaOzy1sb8IyocaruWSn1TjmnBVs8Ayhcy83rmxNJ8q2uWKCAj3CnJY+KpGSXCueAPc0i05kVvVKtP1t9S3g==}
     engines: {node: '>=10'}
 
-  google-auth-library@10.6.2:
-    resolution: {integrity: sha512-e27Z6EThmVNNvtYASwQxose/G57rkRuaRbQyxM2bvYLLX/GqWZ5chWq2EBoUchJbCc57eC9ArzO5wMsEmWftCw==}
-    engines: {node: '>=18'}
-
-  google-logging-utils@1.1.3:
-    resolution: {integrity: sha512-eAmLkjDjAFCVXg7A1unxHsLf961m6y17QFqXqAXGj/gVkKFrEICfStRfwUlGNfeCEjNRa32JEWOUTlYXPyyKvA==}
-    engines: {node: '>=14'}
-
   gopd@1.2.0:
     resolution: {integrity: sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg==}
     engines: {node: '>= 0.4'}
@@ -4984,10 +4743,6 @@ packages:
   hermes-parser@0.35.0:
     resolution: {integrity: sha512-9JLjeHxBx8T4CAsydZR49PNZUaix+WpQJwu9p2010lu+7Kwl6D/7wYFFJxoz+aXkaaClp9Zfg6W6/zVlSJORaA==}
 
-  hono@4.12.23:
-    resolution: {integrity: sha512-eIaZ9qDgu7XV0pxOCrg7/WhnQ6Ivm22UcxhXx/A3dcbqbbYgBEkc6e/J/s7j2tS96zoB0S9VBdLwQNCWwUo4LA==}
-    engines: {node: '>=16.9.0'}
-
   hookable@5.5.3:
     resolution: {integrity: sha512-Yc+BQe8SvoXH1643Qez1zqLRmbA5rCL+sSmk6TVos0LWVfNIB7PGncdlId77WzLGSIB5KaWgTaNTs2lNVEI6VQ==}
 
@@ -5087,10 +4842,6 @@ packages:
   invariant@2.2.4:
     resolution: {integrity: sha512-phJfQVBuaJM5raOpJjSfkiD6BpbCE4Ns//LaXl6wGYtUBY83nWS6Rf9tXm2e8VaK60JEjYldbPif/A2B1C2gNA==}
 
-  ip-address@10.2.0:
-    resolution: {integrity: sha512-/+S6j4E9AHvW9SWMSEY9Xfy66O5PWvVEJ08O0y5JGyEKQpojb0K0GKpz/v5HJ/G0vi3D2sjGK78119oXZeE0qA==}
-    engines: {node: '>= 12'}
-
   ipaddr.js@1.9.1:
     resolution: {integrity: sha512-0KI/607xoxSToH7GjN1FfSbLoU0+btTicjsQSWQlh/hZykN8KpmMf7uYwPW3R+akZ6R/w18ZlXSHBYXiYUPO3g==}
     engines: {node: '>= 0.10'}
@@ -5310,9 +5061,6 @@ packages:
   jimp-compact@0.16.1:
     resolution: {integrity: sha512-dZ6Ra7u1G8c4Letq/B5EzAxj4tLFHL+cGtdpR+PVm4yzPDj+lCk+AbivWt1eOM+ikzkowtyV7qSqX6qr3t71Ww==}
 
-  jose@6.2.3:
-    resolution: {integrity: sha512-YYVDInQKFJfR/xa3ojUTl8c2KoTwiL1R5Wg9YCydwH0x0B9grbzlg5HC7mMjCtUJjbQ/YnGEZIhI5tCgfTb4Hw==}
-
   joycon@3.1.1:
     resolution: {integrity: sha512-34wB/Y7MW7bzjKRjUKTa46I2Z7eV62Rkhva+KkopW7Qvv/OSWBqvkSY7vusOPrNuZcUG3tApvdVgNB8POj3SPw==}
     engines: {node: '>=10'}
@@ -5357,19 +5105,6 @@ packages:
     engines: {node: '>=6'}
     hasBin: true
 
-  json-bigint@1.0.0:
-    resolution: {integrity: sha512-SiPv/8VpZuWbvLSMtTDU8hEfrZWg/mH/nV/b4o0CYbSxu1UIQPLdwKOCIyLQX+VIPO5vrLX3i8qtqFyhdPSUSQ==}
-
-  json-schema-to-ts@3.1.1:
-    resolution: {integrity: sha512-+DWg8jCJG2TEnpy7kOm/7/AxaYoaRbjVB4LFZLySZlWn8exGs3A4OLJR966cVvU26N7X9TWxl+Jsw7dzAqKT6g==}
-    engines: {node: '>=16'}
-
-  json-schema-traverse@1.0.0:
-    resolution: {integrity: sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug==}
-
-  json-schema-typed@8.0.2:
-    resolution: {integrity: sha512-fQhoXdcvc3V28x7C7BMs4P5+kNlgUURe2jmUT1T//oBRMDrqy1QPelJimwZGo7Hg9VPV3EQV5Bnq4hbFy2vetA==}
-
   json5@2.2.3:
     resolution: {integrity: sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg==}
     engines: {node: '>=6'}
@@ -5378,14 +5113,8 @@ packages:
   jsonfile@4.0.0:
     resolution: {integrity: sha512-m6F1R3z8jjlf2imQHS2Qez5sjKWQzbuuhuJ/FKYFRZvPE3PuHcSMVZzfsLhGVOkfd20obL5SWEBew5ShlquNxg==}
 
-  jsonfile@6.2.0:
-    resolution: {integrity: sha512-FGuPw30AdOIUTRMC2OMRtQV+jkVj2cfPqSeWXv1NEAJ1qZ5zb1X6z1mFhbfOB/iy3ssJCD+3KuZ8r8C3uVFlAg==}
-
-  jwa@2.0.1:
-    resolution: {integrity: sha512-hRF04fqJIP8Abbkq5NKGN0Bbr3JxlQ+qhZufXVr0DvujKy93ZCbXZMHDL4EOtodSbCWxOqR8MS1tXA5hwqCXDg==}
-
-  jws@4.0.1:
-    resolution: {integrity: sha512-EKI/M/yqPncGUUh44xz0PxSidXFr/+r0pA70+gIYhjv+et7yxM+s29Y+VGDkovRofQem0fs7Uvf4+YmAdyRduA==}
+  jsonfile@6.2.1:
+    resolution: {integrity: sha512-zwOTdL3rFQ/lRdBnntKVOX6k5cKJwEc1HdilT71BWEu7J41gXIB2MRp+vxduPSwZJPWBxEzv4yH1wYLJGUHX4Q==}
 
   katex@0.16.45:
     resolution: {integrity: sha512-pQpZbdBu7wCTmQUh7ufPmLr0pFoObnGUoL/yhtwJDgmmQpbkg/0HSVti25Fu4rmd1oCR6NGWe9vqTWuWv3GcNA==}
@@ -5542,9 +5271,6 @@ packages:
     resolution: {integrity: sha512-VeIAFslyIerEJLXHziedo2basKbMKtTw3vfn5IzG0XTjhAVEJyNHnL2p7vc+wBDSdQuUpNw3M2u6xb9QsAY5Eg==}
     engines: {node: '>=4'}
 
-  long@5.3.2:
-    resolution: {integrity: sha512-mNAgZ1GmyNhD7AuqnTG3/VQ26o760+ZYBPKjPvugO8+nLbYfX6TVpJPseBvopbdY+qpZ/lKUnmEc1LeZYS3QAA==}
-
   longest-streak@3.1.0:
     resolution: {integrity: sha512-9Ri+o0JYgehTaVBBDoMqIl8GXtbWg711O3srftcHhZ0dqnETqLaoIK0x17fUw9rFSlK/0NlsKe0Ahhyl5pXE2g==}
 
@@ -5906,6 +5632,10 @@ packages:
     resolution: {integrity: sha512-jf84uxzwiuiIVKiOLpfYk7N46TSy8ubTonmneY9vrpHNAnp0QBt2BxWV9dO3/j+BoVAb+a5G6YDPW3M5HOdMWQ==}
     engines: {node: '>=4'}
 
+  mimic-response@3.1.0:
+    resolution: {integrity: sha512-z0yWI+4FDrrweS8Zmt4Ej5HdJmky15+L2e6Wgn3+iK5fWzb6T3fhNFq2+MeTRb064c6Wr4N/wv0DzQTjNzHNGQ==}
+    engines: {node: '>=10'}
+
   minimatch@10.2.5:
     resolution: {integrity: sha512-MULkVLfKGYDFYejP07QOurDLLQpcjk7Fw+7jXS2R2czRQzR56yHRveU5NDJEOviH+hETZKSkIk5c+T23GjFUMg==}
     engines: {node: 18 || 20 || >=22}
@@ -5917,6 +5647,9 @@ packages:
     resolution: {integrity: sha512-OBwBN9AL4dqmETlpS2zasx+vTeWclWzkblfZk7KTA5j3jeOONz/tRCnZomUyvNg83wL5Zv9Ss6HMJXAgL8R2Yg==}
     engines: {node: '>=16 || 14 >=14.17'}
 
+  minimist@1.2.8:
+    resolution: {integrity: sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA==}
+
   minipass@7.1.3:
     resolution: {integrity: sha512-tEBHqDnIoM/1rXME1zgka9g6Q2lcoCkxHLuc7ODJ5BxbP5d4c2Z5cGgtXAku59200Cx7diuHTOYfSBD8n6mm8A==}
     engines: {node: '>=16 || 14 >=14.17'}
@@ -5924,6 +5657,9 @@ packages:
   mitt@3.0.1:
     resolution: {integrity: sha512-vKivATfr97l2/QBCYAkXYDbrIWPM2IIKEl7YPhjCvKlG3kE2gm+uBo6nEXK3M5/Ffh/FLpKExzOQ3JJoJGFKBw==}
 
+  mkdirp-classic@0.5.3:
+    resolution: {integrity: sha512-gKLcREMhtuZRwRAfqP3RFW+TK4JqApVBtOIftVgjuABpAtpxhPGaDcfvbhNvD0B8iD1oUr/txX35NjcaY6Ns/A==}
+
   mkdirp@1.0.4:
     resolution: {integrity: sha512-vVqVZQyf3WLx2Shd0qJ9xuvqgAyKPLAiqITEtqW0oIUjzo3PePDd6fW9iFz30ef7Ysp/oiWqbhszeGWW2T6Gzw==}
     engines: {node: '>=10'}
@@ -5964,11 +5700,14 @@ packages:
     engines: {node: ^10 || ^12 || ^13.7 || ^14 || >=15.0.1}
     hasBin: true
 
-  nanoid@5.1.9:
-    resolution: {integrity: sha512-ZUvP7KeBLe3OZ1ypw6dI/TzYJuvHP77IM4Ry73waSQTLn8/g8rpdjfyVAh7t1/+FjBtG4lCP42MEbDxOsRpBMw==}
+  nanoid@5.1.15:
+    resolution: {integrity: sha512-kBg3RpGtIe+RpTbyXwoI6pk5yD7KUiI3sygUqgeBMRst42KmhB4RZC7eiO9Wa1HIpaCCtpE2DJ6OI4Wi5ebwFw==}
     engines: {node: ^18 || >=20}
     hasBin: true
 
+  napi-build-utils@2.0.0:
+    resolution: {integrity: sha512-GEbrYkbfF7MoNaoh2iGG84Mnf/WZfB0GdGEsM8wz7Expx/LlWf5U8t9nvJKXSp3qr5IsEbK04cBGhol/KwOsWA==}
+
   negotiator@0.6.3:
     resolution: {integrity: sha512-+EUsqGPLsM+j/zdChZjsnX51g4XrHFOIXwfnCVPGlQk/k5giakcKsuxCObBRu6DSm9opw/O6slWbJdghQM4bBg==}
     engines: {node: '>= 0.6'}
@@ -5988,10 +5727,12 @@ packages:
   nlcst-to-string@4.0.0:
     resolution: {integrity: sha512-YKLBCcUYKAg0FNlOBT6aI91qFmSiFKiluk655WzPF+DDMA02qIyy8uiRqI8QXtcFpEvll12LpL5MXqEmAZ+dcA==}
 
-  node-domexception@1.0.0:
-    resolution: {integrity: sha512-/jKZoMpw0F8GRwl4/eLROPA3cfcXtLApP0QzLmUT/HuPCZWyB7IY9ZrMeKw2O/nFIqPQB3PVM9aYm0F312AXDQ==}
-    engines: {node: '>=10.5.0'}
-    deprecated: Use your platform's native DOMException instead
+  node-abi@3.92.0:
+    resolution: {integrity: sha512-KdHvFWZjEKDf0cakgFjebl371GPsISX2oZHcuyKqM7DtogIsHrqKeLTo8wBHxaXRAQlY2PsPlZmfo+9ZCxEREQ==}
+    engines: {node: '>=10'}
+
+  node-addon-api@7.1.1:
+    resolution: {integrity: sha512-5m3bsyrjFWE1xf7nz7YXdN4udnVtXK6/Yfgn5qnahL6bCkf2yKt4k3nuTKAtT4r3IG8JNR2ncsIMdZuAzJjHQQ==}
 
   node-fetch-native@1.6.7:
     resolution: {integrity: sha512-g9yhqoedzIUm0nTnTqAQvueMPVOuIY16bqgAJJC8XOOubYFNwz6IER9qs0Gq2Xd0+CecCKFjtdDTMA4u4xG06Q==}
@@ -6005,10 +5746,6 @@ packages:
       encoding:
         optional: true
 
-  node-fetch@3.3.2:
-    resolution: {integrity: sha512-dRB78srN/l6gqWulah9SrxeYnxeddIG30+GOqK/9OlLVyLg3HPnr6SqOWTWOXKRwC2eGYCkZ59NNuSgvSrpgOA==}
-    engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0}
-
   node-forge@1.4.0:
     resolution: {integrity: sha512-LarFH0+6VfriEhqMMcLX2F7SwSXeWwnEAJEsYm5QKWchiVYVvJyV9v7UDvUv+w5HO23ZpQTXDv/GxdDdMyOuoQ==}
     engines: {node: '>= 6.13.0'}
@@ -6116,18 +5853,6 @@ packages:
     resolution: {integrity: sha512-7x81NCL719oNbsq/3mh+hVrAWmFuEYUqrq/Iw3kUzH8ReypT9QQ0BLoJS7/G9k6N81XjW4qHWtjWwe/9eLy1EQ==}
     engines: {node: '>=12'}
 
-  openai@6.34.0:
-    resolution: {integrity: sha512-yEr2jdGf4tVFYG6ohmr3pF6VJuveP0EA/sS8TBx+4Eq5NT10alu5zg2dmxMXMgqpihRDQlFGpRt2XwsGj+Fyxw==}
-    hasBin: true
-    peerDependencies:
-      ws: ^8.18.0
-      zod: ^3.25 || ^4.0
-    peerDependenciesMeta:
-      ws:
-        optional: true
-      zod:
-        optional: true
-
   ora@3.4.0:
     resolution: {integrity: sha512-eNwHudNbO1folBP3JsZ19v9azXWtQZjICdr3Q0TDPIaeBQ3mXLrh54wM+er0+hSp+dWKf+Z8KM58CYzEyIYxYg==}
     engines: {node: '>=6'}
@@ -6159,10 +5884,6 @@ packages:
     resolution: {integrity: sha512-aNZ+VfjobsWryoiPnEApGGmf5WmNsCo9xu8dfaYamG5qaLP7ClhLN6NgsFe6SwJ2UbLEBK5dv9x8Mn5+RVhMWQ==}
     engines: {node: '>=18'}
 
-  p-retry@4.6.2:
-    resolution: {integrity: sha512-312Id396EbJdvRONlngUx0NydfrIQ5lsYu0znKVUzVvArzEIt08V1qhtyESbGVd1FGX7UKtiFp5uwKZdM8wIuQ==}
-    engines: {node: '>=8'}
-
   p-timeout@6.1.4:
     resolution: {integrity: sha512-MyIV3ZA/PmyBN/ud8vV9XzwTrNtR4jFrObymZYnZqMmW0zA8Z17vnT0rBgFE/TlohB+YCHqXMgZzb3Csp49vqg==}
     engines: {node: '>=14.16'}
@@ -6287,10 +6008,6 @@ packages:
     resolution: {integrity: sha512-TfySrs/5nm8fQJDcBDuUng3VOUKsd7S+zqvbOTiGXHfxX4wK31ard+hoNuvkicM/2YFzlpDgABOevKSsB4G/FA==}
     engines: {node: '>= 6'}
 
-  pkce-challenge@5.0.1:
-    resolution: {integrity: sha512-wQ0b/W4Fr01qtpHlqSqspcj3EhBvimsdh0KlHhH8HRZnMsEa0ea2fTULOXOS9ccQr3om+GcGRk4e+isrZWV8qQ==}
-    engines: {node: '>=16.20.0'}
-
   pkg-types@1.3.1:
     resolution: {integrity: sha512-/Jm5M4RvtBFVkKWRu2BLUTNP8/M2a+UwuAX+ae4770q1qVGtfjG+WTCupoZixokjmHiry8uI+dlY8KXYV5HVVQ==}
 
@@ -6348,6 +6065,12 @@ packages:
     resolution: {integrity: sha512-OW/rX8O/jXnm82Ey1k44pObPtdblfiuWnrd8X7GJ7emImCOstunGbXUpp7HdBrFQX6rJzn3sPT397Wp5aCwCHg==}
     engines: {node: ^10 || ^12 || >=14}
 
+  prebuild-install@7.1.3:
+    resolution: {integrity: sha512-8Mf2cbV7x1cXPUILADGI3wuhfqWvtiLA1iclTDbFRZkgRQS0NqsPZphna9V+HyTEadheuPmjaJMsbzKQFOzLug==}
+    engines: {node: '>=10'}
+    deprecated: No longer maintained. Please contact the author of the relevant native addon; alternatives are available.
+    hasBin: true
+
   prettier@2.8.8:
     resolution: {integrity: sha512-tdN8qQGvNjw4CHbY+XXk0JgCXn9QiF21a55rBe5LJAU+kDyC4WQn4+awm2Xfk2lQMk5fKup9XgzTZtGkjBdP9Q==}
     engines: {node: '>=10.13.0'}
@@ -6390,14 +6113,13 @@ packages:
   proto-list@1.2.4:
     resolution: {integrity: sha512-vtK/94akxsTMhe0/cbfpR+syPuszcuwhqVjJq26CuNDgFGj682oRBXOP5MJpv2r7JtE8MsiepGIqvvOTBwn2vA==}
 
-  protobufjs@7.5.4:
-    resolution: {integrity: sha512-CvexbZtbov6jW2eXAvLukXjXUW1TzFaivC46BpWc/3BpcCysb5Vffu+B3XHMm8lVEuy2Mm4XGex8hBSg1yapPg==}
-    engines: {node: '>=12.0.0'}
-
   proxy-addr@2.0.7:
     resolution: {integrity: sha512-llQsMLSUDUPT44jdrU/O37qlnifitDP+ZwrmmZcoSKyLKvtZxpyV0n2/bD/N4tBAAZ/gJEdZU7KMraoK1+XYAg==}
     engines: {node: '>= 0.10'}
 
+  pump@3.0.4:
+    resolution: {integrity: sha512-VS7sjc6KR7e1ukRFhQSY5LM2uBWAUPiOPa/A3mkKmiMwSmRFUITt0xuj+/lesgnCv+dPIEYlkzrcyXgquIHMcA==}
+
   punycode@2.3.1:
     resolution: {integrity: sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg==}
     engines: {node: '>=6'}
@@ -6429,6 +6151,10 @@ packages:
     resolution: {integrity: sha512-K5zQjDllxWkf7Z5xJdV0/B0WTNqx6vxG70zJE4N0kBs4LovmEYWJzQGxC9bS9RAKu3bgM40lrd5zoLJ12MQ5BA==}
     engines: {node: '>= 0.10'}
 
+  rc@1.2.8:
+    resolution: {integrity: sha512-y3bGgqKj3QBdxLbLkomlohkvsA8gdAiUQlSBJnBhfn+BPxg4bc62d8TcBW15wavDfgexCgccckhcZvywyQYPOw==}
+    hasBin: true
+
   react-devtools-core@6.1.5:
     resolution: {integrity: sha512-ePrwPfxAnB+7hgnEr8vpKxL9cmnp7F322t8oqcPshbIQQhDKgFDW4tjhF2wjVbdXF9O/nyuy3sQWd9JGpiLPvA==}
 
@@ -6625,10 +6351,6 @@ packages:
   retext@9.0.0:
     resolution: {integrity: sha512-sbMDcpHCNjvlheSgMfEcVrZko3cDzdbe1x/e7G66dFp0Ff7Mldvi2uv6JkJQzdRcvLYE8CA8Oe8siQx8ZOgTcA==}
 
-  retry@0.13.1:
-    resolution: {integrity: sha512-XQBQ3I8W1Cge0Seh+6gjj03LbmRFWuoszgK9ooCpwYIrhhoO80pfq4cUkU5DkknwfOfFteRwlZ56PYOGYyFWdg==}
-    engines: {node: '>= 4'}
-
   reusify@1.1.0:
     resolution: {integrity: sha512-g6QUff04oZpHs0eG5p83rFLhHeV00ug/Yf9nZM6fLeUrPguBTkTQOdpAWWspMh55TZfVQDPaN3NQJfbVRAxdIw==}
     engines: {iojs: '>=1.0.0', node: '>=0.10.0'}
@@ -6791,6 +6513,12 @@ packages:
     resolution: {integrity: sha512-bzyZ1e88w9O1iNJbKnOlvYTrWPDl46O1bG0D3XInv+9tkPrxrN8jUUTiFlDkkmKWgn1M6CfIA13SuGqOa9Korw==}
     engines: {node: '>=14'}
 
+  simple-concat@1.0.1:
+    resolution: {integrity: sha512-cSFtAPtRhljv69IK0hTVZQ+OfE9nePi/rtJmw5UjHeVyVroEqJXP1sFztKUy1qU+xvz3u/sfYJLa947b7nAN2Q==}
+
+  simple-get@4.0.1:
+    resolution: {integrity: sha512-brv7p5WgH0jmQJr1ZDDfKDOSeWWg+OVypG99A/5vYGPqJ6pxiaHLy8nxtFjBA7oMa01ebA9gfh1uMCFqOuXxvA==}
+
   simple-plist@1.3.1:
     resolution: {integrity: sha512-iMSw5i0XseMnrhtIzRb7XpQEXepa9xhWxGUojHBL43SIpQuDQkh3Wpy67ZbDzZVr6EKxvwVChnVpdl8hEVLDiw==}
 
@@ -6946,6 +6674,10 @@ packages:
     resolution: {integrity: sha512-aulFJcD6YK8V1G7iRB5tigAP4TsHBZZrOV8pjV++zdUwmeV8uzbY7yn6h9MswN62adStNZFuCIx4haBnRuMDaw==}
     engines: {node: '>=18'}
 
+  strip-json-comments@2.0.1:
+    resolution: {integrity: sha512-4gB8na07fecVVkOI6Rs4e7T6NOTki5EmL7TUduTs6bu3EdnSycntVJ4re8kgZA+wx9IueI2Y11bfbgwtzuE0KQ==}
+    engines: {node: '>=0.10.0'}
+
   strip-literal@3.1.0:
     resolution: {integrity: sha512-8r3mkIM/2+PpjHoOtiAW8Rg3jJLHaV7xPwG+YRGrv6FP0wwk/toTpATxWYOW0BKdWwl82VT2tFYi5DlROa0Mxg==}
 
@@ -6997,16 +6729,20 @@ packages:
     resolution: {integrity: sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w==}
     engines: {node: '>= 0.4'}
 
-  svelte2tsx@0.7.53:
-    resolution: {integrity: sha512-ljVSwmnYRDHRm8+7ICP6QoAN7U7vgOFfPBLN6T745YWNYqRRSzHxlrzUVqMjYls2Un8MzJissfziy/38e6Deeg==}
+  svelte2tsx@0.7.57:
+    resolution: {integrity: sha512-nQo0xEfUpSVjfkxan2UmC6Wl9UZVe9+/pglUiyBNMJ7KDQ9DDooucmXdToBOvzSfgYjj/kMYwf6CTTDz/z048w==}
     peerDependencies:
       svelte: ^3.55 || ^4.0.0-next.0 || ^4.0 || ^5.0.0-next.0
-      typescript: ^4.9.4 || ^5.0.0
+      typescript: ^4.9.4 || ^5.0.0 || ^6.0.0
 
   svelte@5.55.1:
     resolution: {integrity: sha512-QjvU7EFemf6mRzdMGlAFttMWtAAVXrax61SZYHdkD6yoVGQ89VeyKfZD4H1JrV1WLmJBxWhFch9H6ig/87VGjw==}
     engines: {node: '>=18'}
 
+  svelte@5.56.3:
+    resolution: {integrity: sha512-w7JvrM5IFl5cmfbY0TLik9o7mjRUJmRMhOR51tBPu708Gr/MjbGs7VnJnr/B0CaXeI4vtnOh7RKxDr0cwhMdDA==}
+    engines: {node: '>=18'}
+
   svgo@4.0.1:
     resolution: {integrity: sha512-XDpWUOPC6FEibaLzjfe0ucaV0YrOjYotGJO1WpF0Zd+n6ZGEQUsSugaoLq9QkEZtAfQIxT42UChcssDVPP3+/w==}
     engines: {node: '>=16'}
@@ -7015,6 +6751,13 @@ packages:
   symbol-tree@3.2.4:
     resolution: {integrity: sha512-9QNk5KwDF+Bvz+PyObkmSYjI5ksVUYtjW7AU22r2NKcfLJcXp96hkDWU3+XndOsUb+AQ9QhfzfCT2O+CNWT5Tw==}
 
+  tar-fs@2.1.4:
+    resolution: {integrity: sha512-mDAjwmZdh7LTT6pNleZ05Yt65HC3E+NiQzl672vQG38jIrehtJk/J3mNwIg+vShQPcLF/LV7CMnDW6vjj6sfYQ==}
+
+  tar-stream@2.2.0:
+    resolution: {integrity: sha512-ujeqbceABgwMZxEJnk2HDY2DlnUZ+9oEcb1KzTVfYHio0UE6dG71n60d8D2I4qNvleWrrXpmjpt7vZeF1LnMZQ==}
+    engines: {node: '>=6'}
+
   term-size@2.2.1:
     resolution: {integrity: sha512-wK0Ri4fOGjv/XPy8SBHZChl8CM7uMc5VML7SqiQ0zG7+J5Vr+RMQDoHa2CNT6KHUnTGIXH34UDMkPzAUyapBZg==}
     engines: {node: '>=8'}
@@ -7121,9 +6864,6 @@ packages:
   trough@2.2.0:
     resolution: {integrity: sha512-tmMpK00BjZiUyVyvrBK7knerNgmgvcV/KLVyuma/SC+TQN167GrMRciANTz09+k3zW8L8t60jWO1GpfkZdjTaw==}
 
-  ts-algebra@2.0.0:
-    resolution: {integrity: sha512-FPAhNPFMrkwz76P7cdjdmiShwMynZYN6SgOujD1urY4oNm80Ou9oMdmbR45LotcKOXoy7wSmHkRFE6Mxbrhefw==}
-
   ts-dedent@2.2.0:
     resolution: {integrity: sha512-q5W7tVM71e2xjHZTlgfTDoPF/SmqKG5hddq9SzR49CH2hayqRKJtQ4mtRlSxKaJlR/+9rEM+mnBHf7I2/BQcpQ==}
     engines: {node: '>=6.10'}
@@ -7134,6 +6874,7 @@ packages:
   tsconfck@3.1.6:
     resolution: {integrity: sha512-ks6Vjr/jEw0P1gmOVwutM3B7fWxoWBL2KRDb1JfqGVawBmO5UsvmWOQFGHBPl5yxYz4eERr19E6L7NMv+Fej4w==}
     engines: {node: ^18 || >=20}
+    deprecated: unmaintained
     hasBin: true
     peerDependencies:
       typescript: ^5.0.0
@@ -7168,6 +6909,9 @@ packages:
     engines: {node: '>=18.0.0'}
     hasBin: true
 
+  tunnel-agent@0.6.0:
+    resolution: {integrity: sha512-McnNiV1l8RYeY8tBgEpuodCC1mLUdbSN+CYBL7kJsJNInOP8UjDDEwdk6Mw60vdLLrr5NHKZhMAOSrR2NZuQ+w==}
+
   type-detect@4.0.8:
     resolution: {integrity: sha512-0fr/mIH1dlO+x7TlcMy+bIDqKPsw/70tVyeHW787goQjhmqaZe10uwLujubK9q9Lg6Fiho1KUKDYz0Z7k7g5/g==}
     engines: {node: '>=4'}
@@ -7399,10 +7143,10 @@ packages:
   vfile@6.0.3:
     resolution: {integrity: sha512-KzIbH/9tXat2u30jf+smMwFCsno4wHVdNmzFyL+T/L3UGqqk6JKfVqOFOZEpZSHADH1k40ab6NUIXZq422ov3Q==}
 
-  vite-hot-client@2.1.0:
-    resolution: {integrity: sha512-7SpgZmU7R+dDnSmvXE1mfDtnHLHQSisdySVR7lO8ceAXvM0otZeuQQ6C8LrS5d/aYyP/QZ0hI0L+dIPrm4YlFQ==}
+  vite-hot-client@2.2.0:
+    resolution: {integrity: sha512-76Zs9zrHbH7M7wqeyooGQKdX+yg0pQ0xuQ1PbFp4z5a0Lzn2e5IPFoCswnmqZ4GiwqB4Jo3WcDAMO9jARTJl8w==}
     peerDependencies:
-      vite: ^2.6.0 || ^3.0.0 || ^4.0.0 || ^5.0.0-0 || ^6.0.0-0 || ^7.0.0-0
+      vite: ^2.6.0 || ^3.0.0 || ^4.0.0 || ^5.0.0-0 || ^6.0.0-0 || ^7.0.0-0 || ^8.0.0
 
   vite-node@3.2.4:
     resolution: {integrity: sha512-EbKSKh+bh1E1IFxeO0pg1n4dvoOTt0UDiXMd/qn++r98+jPO1xtJilvXldeuQ8giIB5IkpjCgMleHMNEsGH6pg==}
@@ -7640,10 +7384,6 @@ packages:
   web-namespaces@2.0.1:
     resolution: {integrity: sha512-bKr1DkiNa2krS7qxNtdrtHAmzuYGFQLiQ13TsorsdT6ULTkPLKuu5+GsFpDlg6JFjUTwX2DyhMPG2be8uPrqsQ==}
 
-  web-streams-polyfill@3.3.3:
-    resolution: {integrity: sha512-d2JWLCivmZYTSIoge9MsgFCZrt571BikcWGYkjC1khllbTeDlGqZ2D8vD8E/lJa8WGWbb7Plm8/XJYV7IJHZZw==}
-    engines: {node: '>= 8'}
-
   webidl-conversions@3.0.1:
     resolution: {integrity: sha512-2JAn3z8AR6rjK8Sm8orRC0h/bcl/DqL7tRPdGZ4I1CjdF+EaMLmYxBHyXuKL849eucPFhvBoxMsflfOb8kxaeQ==}
 
@@ -7835,12 +7575,6 @@ snapshots:
 
   '@antfu/utils@0.7.10': {}
 
-  '@anthropic-ai/sdk@0.82.0(zod@4.3.6)':
-    dependencies:
-      json-schema-to-ts: 3.1.1
-    optionalDependencies:
-      zod: 4.3.6
-
   '@asamuzakjp/css-color@5.1.1':
     dependencies:
       '@csstools/css-calc': 3.1.1(@csstools/css-parser-algorithms@4.0.0(@csstools/css-tokenizer@4.0.0))(@csstools/css-tokenizer@4.0.0)
@@ -7998,12 +7732,12 @@ snapshots:
     transitivePeerDependencies:
       - supports-color
 
-  '@astrojs/svelte@7.2.5(@types/node@25.5.0)(astro@5.18.1(@types/node@25.5.0)(lightningcss@1.32.0)(rollup@4.60.0)(terser@5.47.1)(tsx@4.21.0)(typescript@5.9.3)(yaml@2.9.0))(lightningcss@1.32.0)(svelte@5.55.1)(terser@5.47.1)(tsx@4.21.0)(typescript@5.9.3)(yaml@2.9.0)':
+  '@astrojs/svelte@7.2.5(@types/node@25.5.0)(astro@5.18.1(@types/node@25.5.0)(lightningcss@1.32.0)(rollup@4.60.0)(terser@5.47.1)(tsx@4.21.0)(typescript@5.9.3)(yaml@2.9.0))(lightningcss@1.32.0)(svelte@5.56.3(@typescript-eslint/types@8.58.0))(terser@5.47.1)(tsx@4.21.0)(typescript@5.9.3)(yaml@2.9.0)':
     dependencies:
-      '@sveltejs/vite-plugin-svelte': 5.1.1(svelte@5.55.1)(vite@6.4.1(@types/node@25.5.0)(lightningcss@1.32.0)(terser@5.47.1)(tsx@4.21.0)(yaml@2.9.0))
+      '@sveltejs/vite-plugin-svelte': 5.1.1(svelte@5.56.3(@typescript-eslint/types@8.58.0))(vite@6.4.1(@types/node@25.5.0)(lightningcss@1.32.0)(terser@5.47.1)(tsx@4.21.0)(yaml@2.9.0))
       astro: 5.18.1(@types/node@25.5.0)(lightningcss@1.32.0)(rollup@4.60.0)(terser@5.47.1)(tsx@4.21.0)(typescript@5.9.3)(yaml@2.9.0)
-      svelte: 5.55.1
-      svelte2tsx: 0.7.53(svelte@5.55.1)(typescript@5.9.3)
+      svelte: 5.56.3(@typescript-eslint/types@8.58.0)
+      svelte2tsx: 0.7.57(svelte@5.56.3(@typescript-eslint/types@8.58.0))(typescript@5.9.3)
       typescript: 5.9.3
       vite: 6.4.1(@types/node@25.5.0)(lightningcss@1.32.0)(terser@5.47.1)(tsx@4.21.0)(yaml@2.9.0)
     transitivePeerDependencies:
@@ -9563,47 +9297,6 @@ snapshots:
     dependencies:
       '@expressive-code/core': 0.41.7
 
-  '@google/genai@1.48.0(@modelcontextprotocol/sdk@1.29.0(zod@4.3.6))':
-    dependencies:
-      google-auth-library: 10.6.2
-      p-retry: 4.6.2
-      protobufjs: 7.5.4
-      ws: 8.20.0
-    optionalDependencies:
-      '@modelcontextprotocol/sdk': 1.29.0(zod@4.3.6)
-    transitivePeerDependencies:
-      - bufferutil
-      - supports-color
-      - utf-8-validate
-
-  '@graphrefly/native-darwin-arm64@0.0.5':
-    optional: true
-
-  '@graphrefly/native-linux-arm64-gnu@0.0.5':
-    optional: true
-
-  '@graphrefly/native-linux-x64-gnu@0.0.5':
-    optional: true
-
-  '@graphrefly/native-win32-arm64-msvc@0.0.5':
-    optional: true
-
-  '@graphrefly/native-win32-x64-msvc@0.0.5':
-    optional: true
-
-  '@graphrefly/native@0.0.5':
-    optionalDependencies:
-      '@graphrefly/native-darwin-arm64': 0.0.5
-      '@graphrefly/native-linux-arm64-gnu': 0.0.5
-      '@graphrefly/native-linux-x64-gnu': 0.0.5
-      '@graphrefly/native-win32-arm64-msvc': 0.0.5
-      '@graphrefly/native-win32-x64-msvc': 0.0.5
-
-  '@hono/node-server@1.19.14(hono@4.12.23)':
-    dependencies:
-      hono: 4.12.23
-    optional: true
-
   '@iconify/types@2.0.0': {}
 
   '@iconify/utils@3.1.0':
@@ -9865,29 +9558,6 @@ snapshots:
     dependencies:
       langium: 4.2.2
 
-  '@modelcontextprotocol/sdk@1.29.0(zod@4.3.6)':
-    dependencies:
-      '@hono/node-server': 1.19.14(hono@4.12.23)
-      ajv: 8.20.0
-      ajv-formats: 3.0.1(ajv@8.20.0)
-      content-type: 1.0.5
-      cors: 2.8.6
-      cross-spawn: 7.0.6
-      eventsource: 3.0.7
-      eventsource-parser: 3.0.8
-      express: 5.2.1
-      express-rate-limit: 8.5.2(express@5.2.1)
-      hono: 4.12.23
-      jose: 6.2.3
-      json-schema-typed: 8.0.2
-      pkce-challenge: 5.0.1
-      raw-body: 3.0.2
-      zod: 4.3.6
-      zod-to-json-schema: 3.25.2(zod@4.3.6)
-    transitivePeerDependencies:
-      - supports-color
-    optional: true
-
   '@nestjs/common@11.1.17(reflect-metadata@0.2.2)(rxjs@7.8.2)':
     dependencies:
       file-type: 21.3.2
@@ -9900,7 +9570,7 @@ snapshots:
     transitivePeerDependencies:
       - supports-color
 
-  '@nestjs/core@11.1.17(@nestjs/common@11.1.17(reflect-metadata@0.2.2)(rxjs@7.8.2))(@nestjs/platform-express@11.1.18)(@nestjs/websockets@11.1.18)(reflect-metadata@0.2.2)(rxjs@7.8.2)':
+  '@nestjs/core@11.1.17(@nestjs/common@11.1.17(reflect-metadata@0.2.2)(rxjs@7.8.2))(@nestjs/microservices@11.1.27)(@nestjs/platform-express@11.1.18)(@nestjs/websockets@11.1.18)(reflect-metadata@0.2.2)(rxjs@7.8.2)':
     dependencies:
       '@nestjs/common': 11.1.17(reflect-metadata@0.2.2)(rxjs@7.8.2)
       '@nuxt/opencollective': 0.4.1
@@ -9912,13 +9582,25 @@ snapshots:
       tslib: 2.8.1
       uid: 2.0.2
     optionalDependencies:
+      '@nestjs/microservices': 11.1.27(@nestjs/common@11.1.17(reflect-metadata@0.2.2)(rxjs@7.8.2))(@nestjs/core@11.1.17)(@nestjs/websockets@11.1.18)(reflect-metadata@0.2.2)(rxjs@7.8.2)
       '@nestjs/platform-express': 11.1.18(@nestjs/common@11.1.17(reflect-metadata@0.2.2)(rxjs@7.8.2))(@nestjs/core@11.1.17)
       '@nestjs/websockets': 11.1.18(@nestjs/common@11.1.17(reflect-metadata@0.2.2)(rxjs@7.8.2))(@nestjs/core@11.1.17)(reflect-metadata@0.2.2)(rxjs@7.8.2)
 
+  '@nestjs/microservices@11.1.27(@nestjs/common@11.1.17(reflect-metadata@0.2.2)(rxjs@7.8.2))(@nestjs/core@11.1.17)(@nestjs/websockets@11.1.18)(reflect-metadata@0.2.2)(rxjs@7.8.2)':
+    dependencies:
+      '@nestjs/common': 11.1.17(reflect-metadata@0.2.2)(rxjs@7.8.2)
+      '@nestjs/core': 11.1.17(@nestjs/common@11.1.17(reflect-metadata@0.2.2)(rxjs@7.8.2))(@nestjs/microservices@11.1.27)(@nestjs/platform-express@11.1.18)(@nestjs/websockets@11.1.18)(reflect-metadata@0.2.2)(rxjs@7.8.2)
+      iterare: 1.2.1
+      reflect-metadata: 0.2.2
+      rxjs: 7.8.2
+      tslib: 2.8.1
+    optionalDependencies:
+      '@nestjs/websockets': 11.1.18(@nestjs/common@11.1.17(reflect-metadata@0.2.2)(rxjs@7.8.2))(@nestjs/core@11.1.17)(reflect-metadata@0.2.2)(rxjs@7.8.2)
+
   '@nestjs/platform-express@11.1.18(@nestjs/common@11.1.17(reflect-metadata@0.2.2)(rxjs@7.8.2))(@nestjs/core@11.1.17)':
     dependencies:
       '@nestjs/common': 11.1.17(reflect-metadata@0.2.2)(rxjs@7.8.2)
-      '@nestjs/core': 11.1.17(@nestjs/common@11.1.17(reflect-metadata@0.2.2)(rxjs@7.8.2))(@nestjs/platform-express@11.1.18)(@nestjs/websockets@11.1.18)(reflect-metadata@0.2.2)(rxjs@7.8.2)
+      '@nestjs/core': 11.1.17(@nestjs/common@11.1.17(reflect-metadata@0.2.2)(rxjs@7.8.2))(@nestjs/microservices@11.1.27)(@nestjs/platform-express@11.1.18)(@nestjs/websockets@11.1.18)(reflect-metadata@0.2.2)(rxjs@7.8.2)
       cors: 2.8.6
       express: 5.2.1
       multer: 2.1.1
@@ -9938,18 +9620,19 @@ snapshots:
       - bufferutil
       - utf-8-validate
 
-  '@nestjs/testing@11.1.17(@nestjs/common@11.1.17(reflect-metadata@0.2.2)(rxjs@7.8.2))(@nestjs/core@11.1.17)(@nestjs/platform-express@11.1.18)':
+  '@nestjs/testing@11.1.17(@nestjs/common@11.1.17(reflect-metadata@0.2.2)(rxjs@7.8.2))(@nestjs/core@11.1.17)(@nestjs/microservices@11.1.27)(@nestjs/platform-express@11.1.18)':
     dependencies:
       '@nestjs/common': 11.1.17(reflect-metadata@0.2.2)(rxjs@7.8.2)
-      '@nestjs/core': 11.1.17(@nestjs/common@11.1.17(reflect-metadata@0.2.2)(rxjs@7.8.2))(@nestjs/platform-express@11.1.18)(@nestjs/websockets@11.1.18)(reflect-metadata@0.2.2)(rxjs@7.8.2)
+      '@nestjs/core': 11.1.17(@nestjs/common@11.1.17(reflect-metadata@0.2.2)(rxjs@7.8.2))(@nestjs/microservices@11.1.27)(@nestjs/platform-express@11.1.18)(@nestjs/websockets@11.1.18)(reflect-metadata@0.2.2)(rxjs@7.8.2)
       tslib: 2.8.1
     optionalDependencies:
+      '@nestjs/microservices': 11.1.27(@nestjs/common@11.1.17(reflect-metadata@0.2.2)(rxjs@7.8.2))(@nestjs/core@11.1.17)(@nestjs/websockets@11.1.18)(reflect-metadata@0.2.2)(rxjs@7.8.2)
       '@nestjs/platform-express': 11.1.18(@nestjs/common@11.1.17(reflect-metadata@0.2.2)(rxjs@7.8.2))(@nestjs/core@11.1.17)
 
   '@nestjs/websockets@11.1.18(@nestjs/common@11.1.17(reflect-metadata@0.2.2)(rxjs@7.8.2))(@nestjs/core@11.1.17)(reflect-metadata@0.2.2)(rxjs@7.8.2)':
     dependencies:
       '@nestjs/common': 11.1.17(reflect-metadata@0.2.2)(rxjs@7.8.2)
-      '@nestjs/core': 11.1.17(@nestjs/common@11.1.17(reflect-metadata@0.2.2)(rxjs@7.8.2))(@nestjs/platform-express@11.1.18)(@nestjs/websockets@11.1.18)(reflect-metadata@0.2.2)(rxjs@7.8.2)
+      '@nestjs/core': 11.1.17(@nestjs/common@11.1.17(reflect-metadata@0.2.2)(rxjs@7.8.2))(@nestjs/microservices@11.1.27)(@nestjs/platform-express@11.1.18)(@nestjs/websockets@11.1.18)(reflect-metadata@0.2.2)(rxjs@7.8.2)
       iterare: 1.2.1
       object-hash: 3.0.0
       reflect-metadata: 0.2.2
@@ -10001,29 +9684,6 @@ snapshots:
 
   '@polka/url@1.0.0-next.29': {}
 
-  '@protobufjs/aspromise@1.1.2': {}
-
-  '@protobufjs/base64@1.1.2': {}
-
-  '@protobufjs/codegen@2.0.4': {}
-
-  '@protobufjs/eventemitter@1.1.0': {}
-
-  '@protobufjs/fetch@1.1.0':
-    dependencies:
-      '@protobufjs/aspromise': 1.1.2
-      '@protobufjs/inquire': 1.1.0
-
-  '@protobufjs/float@1.0.2': {}
-
-  '@protobufjs/inquire@1.1.0': {}
-
-  '@protobufjs/path@1.1.2': {}
-
-  '@protobufjs/pool@1.1.0': {}
-
-  '@protobufjs/utf8@1.1.0': {}
-
   '@react-native/assets-registry@0.83.6': {}
 
   '@react-native/babel-plugin-codegen@0.83.6(@babel/core@7.29.0)':
@@ -10151,8 +9811,6 @@ snapshots:
 
   '@rolldown/pluginutils@1.0.0-beta.27': {}
 
-  '@rolldown/pluginutils@1.0.0-rc.16': {}
-
   '@rollup/pluginutils@5.3.0(rollup@4.60.0)':
     dependencies:
       '@types/estree': 1.0.8
@@ -10288,6 +9946,10 @@ snapshots:
       '@testing-library/dom': 10.4.1
       solid-js: 1.9.12
 
+  '@sveltejs/acorn-typescript@1.0.10(acorn@8.16.0)':
+    dependencies:
+      acorn: 8.16.0
+
   '@sveltejs/acorn-typescript@1.0.9(acorn@8.16.0)':
     dependencies:
       acorn: 8.16.0
@@ -10301,6 +9963,15 @@ snapshots:
     transitivePeerDependencies:
       - supports-color
 
+  '@sveltejs/vite-plugin-svelte-inspector@4.0.1(@sveltejs/vite-plugin-svelte@5.1.1(svelte@5.56.3(@typescript-eslint/types@8.58.0))(vite@6.4.1(@types/node@25.5.0)(lightningcss@1.32.0)(terser@5.47.1)(tsx@4.21.0)(yaml@2.9.0)))(svelte@5.56.3(@typescript-eslint/types@8.58.0))(vite@6.4.1(@types/node@25.5.0)(lightningcss@1.32.0)(terser@5.47.1)(tsx@4.21.0)(yaml@2.9.0))':
+    dependencies:
+      '@sveltejs/vite-plugin-svelte': 5.1.1(svelte@5.56.3(@typescript-eslint/types@8.58.0))(vite@6.4.1(@types/node@25.5.0)(lightningcss@1.32.0)(terser@5.47.1)(tsx@4.21.0)(yaml@2.9.0))
+      debug: 4.4.3
+      svelte: 5.56.3(@typescript-eslint/types@8.58.0)
+      vite: 6.4.1(@types/node@25.5.0)(lightningcss@1.32.0)(terser@5.47.1)(tsx@4.21.0)(yaml@2.9.0)
+    transitivePeerDependencies:
+      - supports-color
+
   '@sveltejs/vite-plugin-svelte@5.1.1(svelte@5.55.1)(vite@6.4.1(@types/node@25.5.0)(lightningcss@1.32.0)(terser@5.47.1)(tsx@4.21.0)(yaml@2.9.0))':
     dependencies:
       '@sveltejs/vite-plugin-svelte-inspector': 4.0.1(@sveltejs/vite-plugin-svelte@5.1.1(svelte@5.55.1)(vite@6.4.1(@types/node@25.5.0)(lightningcss@1.32.0)(terser@5.47.1)(tsx@4.21.0)(yaml@2.9.0)))(svelte@5.55.1)(vite@6.4.1(@types/node@25.5.0)(lightningcss@1.32.0)(terser@5.47.1)(tsx@4.21.0)(yaml@2.9.0))
@@ -10314,6 +9985,19 @@ snapshots:
     transitivePeerDependencies:
       - supports-color
 
+  '@sveltejs/vite-plugin-svelte@5.1.1(svelte@5.56.3(@typescript-eslint/types@8.58.0))(vite@6.4.1(@types/node@25.5.0)(lightningcss@1.32.0)(terser@5.47.1)(tsx@4.21.0)(yaml@2.9.0))':
+    dependencies:
+      '@sveltejs/vite-plugin-svelte-inspector': 4.0.1(@sveltejs/vite-plugin-svelte@5.1.1(svelte@5.56.3(@typescript-eslint/types@8.58.0))(vite@6.4.1(@types/node@25.5.0)(lightningcss@1.32.0)(terser@5.47.1)(tsx@4.21.0)(yaml@2.9.0)))(svelte@5.56.3(@typescript-eslint/types@8.58.0))(vite@6.4.1(@types/node@25.5.0)(lightningcss@1.32.0)(terser@5.47.1)(tsx@4.21.0)(yaml@2.9.0))
+      debug: 4.4.3
+      deepmerge: 4.3.1
+      kleur: 4.1.5
+      magic-string: 0.30.21
+      svelte: 5.56.3(@typescript-eslint/types@8.58.0)
+      vite: 6.4.1(@types/node@25.5.0)(lightningcss@1.32.0)(terser@5.47.1)(tsx@4.21.0)(yaml@2.9.0)
+      vitefu: 1.1.2(vite@6.4.1(@types/node@25.5.0)(lightningcss@1.32.0)(terser@5.47.1)(tsx@4.21.0)(yaml@2.9.0))
+    transitivePeerDependencies:
+      - supports-color
+
   '@testing-library/dom@10.4.1':
     dependencies:
       '@babel/code-frame': 7.29.0
@@ -10350,14 +10034,14 @@ snapshots:
     dependencies:
       svelte: 5.55.1
 
-  '@testing-library/svelte@5.3.1(svelte@5.55.1)(vite@7.3.1(@types/node@25.5.0)(lightningcss@1.32.0)(terser@5.47.1)(tsx@4.21.0)(yaml@2.9.0))(vitest@3.2.4(@types/debug@4.1.13)(@types/node@25.5.0)(jsdom@29.0.1)(lightningcss@1.32.0)(terser@5.47.1)(tsx@4.21.0)(yaml@2.9.0))':
+  '@testing-library/svelte@5.3.1(svelte@5.55.1)(vite@7.3.1(@types/node@25.5.0)(lightningcss@1.32.0)(terser@5.47.1)(tsx@4.21.0)(yaml@2.9.0))(vitest@3.2.4(@types/debug@4.1.13)(@types/node@25.5.0)(jsdom@29.0.1(canvas@3.2.3))(lightningcss@1.32.0)(terser@5.47.1)(tsx@4.21.0)(yaml@2.9.0))':
     dependencies:
       '@testing-library/dom': 10.4.1
       '@testing-library/svelte-core': 1.0.0(svelte@5.55.1)
       svelte: 5.55.1
     optionalDependencies:
       vite: 7.3.1(@types/node@25.5.0)(lightningcss@1.32.0)(terser@5.47.1)(tsx@4.21.0)(yaml@2.9.0)
-      vitest: 3.2.4(@types/debug@4.1.13)(@types/node@25.5.0)(jsdom@29.0.1)(lightningcss@1.32.0)(terser@5.47.1)(tsx@4.21.0)(yaml@2.9.0)
+      vitest: 3.2.4(@types/debug@4.1.13)(@types/node@25.5.0)(jsdom@29.0.1(canvas@3.2.3))(lightningcss@1.32.0)(terser@5.47.1)(tsx@4.21.0)(yaml@2.9.0)
 
   '@testing-library/vue@8.1.0(@vue/compiler-sfc@3.5.31)(vue@3.5.31(typescript@5.9.3))':
     dependencies:
@@ -10586,8 +10270,6 @@ snapshots:
     dependencies:
       csstype: 3.2.3
 
-  '@types/retry@0.12.0': {}
-
   '@types/sax@1.2.7':
     dependencies:
       '@types/node': 25.5.0
@@ -10631,7 +10313,7 @@ snapshots:
     dependencies:
       '@babel/core': 7.29.0
       '@babel/plugin-transform-typescript': 7.28.6(@babel/core@7.29.0)
-      '@rolldown/pluginutils': 1.0.0-rc.16
+      '@rolldown/pluginutils': 1.0.0-beta.27
       '@vue/babel-plugin-jsx': 1.5.0(@babel/core@7.29.0)
       vite: 6.4.1(@types/node@25.5.0)(lightningcss@1.32.0)(terser@5.47.1)(tsx@4.21.0)(yaml@2.9.0)
       vue: 3.5.31(typescript@5.9.3)
@@ -10766,9 +10448,9 @@ snapshots:
       '@vue/devtools-kit': 7.7.9
       '@vue/devtools-shared': 7.7.9
       mitt: 3.0.1
-      nanoid: 5.1.9
+      nanoid: 5.1.15
       pathe: 2.0.3
-      vite-hot-client: 2.1.0(vite@6.4.1(@types/node@25.5.0)(lightningcss@1.32.0)(terser@5.47.1)(tsx@4.21.0)(yaml@2.9.0))
+      vite-hot-client: 2.2.0(vite@6.4.1(@types/node@25.5.0)(lightningcss@1.32.0)(terser@5.47.1)(tsx@4.21.0)(yaml@2.9.0))
       vue: 3.5.31(typescript@5.9.3)
     transitivePeerDependencies:
       - vite
@@ -10857,19 +10539,6 @@ snapshots:
 
   agent-base@7.1.4: {}
 
-  ajv-formats@3.0.1(ajv@8.20.0):
-    optionalDependencies:
-      ajv: 8.20.0
-    optional: true
-
-  ajv@8.20.0:
-    dependencies:
-      fast-deep-equal: 3.1.3
-      fast-uri: 3.1.2
-      json-schema-traverse: 1.0.0
-      require-from-string: 2.0.2
-    optional: true
-
   alien-signals@1.0.13: {}
 
   anser@1.4.10: {}
@@ -10979,7 +10648,7 @@ snapshots:
       cssesc: 3.0.0
       debug: 4.4.3
       deterministic-object-hash: 2.0.2
-      devalue: 5.6.4
+      devalue: 5.8.1
       diff: 8.0.4
       dlv: 1.1.3
       dset: 3.1.4
@@ -11249,10 +10918,14 @@ snapshots:
 
   big-integer@1.6.52: {}
 
-  bignumber.js@9.3.1: {}
-
   birpc@2.9.0: {}
 
+  bl@4.1.0:
+    dependencies:
+      buffer: 5.7.1
+      inherits: 2.0.4
+      readable-stream: 3.6.2
+
   body-parser@2.2.2:
     dependencies:
       bytes: 3.1.2
@@ -11321,10 +10994,13 @@ snapshots:
     dependencies:
       node-int64: 0.4.0
 
-  buffer-equal-constant-time@1.0.1: {}
-
   buffer-from@1.1.2: {}
 
+  buffer@5.7.1:
+    dependencies:
+      base64-js: 1.5.1
+      ieee754: 1.2.1
+
   bundle-name@4.1.0:
     dependencies:
       run-applescript: 7.1.0
@@ -11367,6 +11043,11 @@ snapshots:
 
   caniuse-lite@1.0.30001788: {}
 
+  canvas@3.2.3:
+    dependencies:
+      node-addon-api: 7.1.1
+      prebuild-install: 7.1.3
+
   ccount@2.0.1: {}
 
   chai@5.3.3:
@@ -11423,6 +11104,8 @@ snapshots:
     dependencies:
       readdirp: 5.0.0
 
+  chownr@1.1.4: {}
+
   chrome-launcher@0.15.2:
     dependencies:
       '@types/node': 25.5.0
@@ -11801,8 +11484,6 @@ snapshots:
       d3: 7.9.0
       lodash-es: 4.18.1
 
-  data-uri-to-buffer@4.0.1: {}
-
   data-urls@7.0.0:
     dependencies:
       whatwg-mimetype: 5.0.0
@@ -11834,6 +11515,10 @@ snapshots:
     dependencies:
       character-entities: 2.0.2
 
+  decompress-response@6.0.0:
+    dependencies:
+      mimic-response: 3.1.0
+
   dedent-js@1.0.1: {}
 
   deep-eql@5.0.2: {}
@@ -11859,6 +11544,8 @@ snapshots:
       which-collection: 1.0.2
       which-typed-array: 1.1.20
 
+  deep-extend@0.6.0: {}
+
   deepmerge@4.3.1: {}
 
   default-browser-id@5.0.1: {}
@@ -11912,6 +11599,8 @@ snapshots:
 
   devalue@5.6.4: {}
 
+  devalue@5.8.1: {}
+
   devlop@1.1.0:
     dependencies:
       dequal: 2.0.3
@@ -11964,10 +11653,6 @@ snapshots:
 
   eastasianwidth@0.2.0: {}
 
-  ecdsa-sig-formatter@1.0.11:
-    dependencies:
-      safe-buffer: 5.1.2
-
   editorconfig@1.0.7:
     dependencies:
       '@one-ini/wasm': 0.1.1
@@ -11989,6 +11674,10 @@ snapshots:
 
   encodeurl@2.0.0: {}
 
+  end-of-stream@1.4.5:
+    dependencies:
+      once: 1.4.0
+
   enquirer@2.4.1:
     dependencies:
       ansi-colors: 4.1.3
@@ -12171,6 +11860,12 @@ snapshots:
 
   esprima@4.0.1: {}
 
+  esrap@2.2.11(@typescript-eslint/types@8.58.0):
+    dependencies:
+      '@jridgewell/sourcemap-codec': 1.5.5
+    optionalDependencies:
+      '@typescript-eslint/types': 8.58.0
+
   esrap@2.2.4:
     dependencies:
       '@jridgewell/sourcemap-codec': 1.5.5
@@ -12217,14 +11912,6 @@ snapshots:
 
   eventemitter3@5.0.4: {}
 
-  eventsource-parser@3.0.8:
-    optional: true
-
-  eventsource@3.0.7:
-    dependencies:
-      eventsource-parser: 3.0.8
-    optional: true
-
   execa@9.6.1:
     dependencies:
       '@sindresorhus/merge-streams': 4.0.0
@@ -12240,6 +11927,8 @@ snapshots:
       strip-final-newline: 4.0.0
       yoctocolors: 2.1.2
 
+  expand-template@2.0.3: {}
+
   expect-type@1.3.0: {}
 
   expo-asset@55.0.17(expo@55.0.24)(react-native@0.83.6(@babel/core@7.29.0)(@types/react@19.2.14)(react@19.2.0))(react@19.2.0)(typescript@5.9.3):
@@ -12345,12 +12034,6 @@ snapshots:
 
   exponential-backoff@3.1.3: {}
 
-  express-rate-limit@8.5.2(express@5.2.1):
-    dependencies:
-      express: 5.2.1
-      ip-address: 10.2.0
-    optional: true
-
   express@5.2.1:
     dependencies:
       accepts: 2.0.0
@@ -12399,9 +12082,6 @@ snapshots:
     dependencies:
       pure-rand: 8.4.0
 
-  fast-deep-equal@3.1.3:
-    optional: true
-
   fast-glob@3.3.3:
     dependencies:
       '@nodelib/fs.stat': 2.0.5
@@ -12414,9 +12094,6 @@ snapshots:
 
   fast-safe-stringify@2.1.1: {}
 
-  fast-uri@3.1.2:
-    optional: true
-
   fast-xml-builder@1.1.4:
     dependencies:
       path-expression-matcher: 1.2.1
@@ -12441,11 +12118,6 @@ snapshots:
     optionalDependencies:
       picomatch: 4.0.4
 
-  fetch-blob@3.2.0:
-    dependencies:
-      node-domexception: 1.0.0
-      web-streams-polyfill: 3.3.3
-
   fetch-nodeshim@0.4.10: {}
 
   figures@6.1.0:
@@ -12522,20 +12194,18 @@ snapshots:
       cross-spawn: 7.0.6
       signal-exit: 4.1.0
 
-  formdata-polyfill@4.0.10:
-    dependencies:
-      fetch-blob: 3.2.0
-
   forwarded@0.2.0: {}
 
   fresh@0.5.2: {}
 
   fresh@2.0.0: {}
 
-  fs-extra@11.3.4:
+  fs-constants@1.0.0: {}
+
+  fs-extra@11.3.5:
     dependencies:
       graceful-fs: 4.2.11
-      jsonfile: 6.2.0
+      jsonfile: 6.2.1
       universalify: 2.0.1
 
   fs-extra@7.0.1:
@@ -12559,22 +12229,6 @@ snapshots:
 
   functions-have-names@1.2.3: {}
 
-  gaxios@7.1.4:
-    dependencies:
-      extend: 3.0.2
-      https-proxy-agent: 7.0.6
-      node-fetch: 3.3.2
-    transitivePeerDependencies:
-      - supports-color
-
-  gcp-metadata@8.1.2:
-    dependencies:
-      gaxios: 7.1.4
-      google-logging-utils: 1.1.3
-      json-bigint: 1.0.0
-    transitivePeerDependencies:
-      - supports-color
-
   gensync@1.0.0-beta.2: {}
 
   get-caller-file@2.0.5: {}
@@ -12612,6 +12266,8 @@ snapshots:
 
   getenv@2.0.0: {}
 
+  github-from-package@0.0.0: {}
+
   github-slugger@2.0.0: {}
 
   glob-parent@5.1.2:
@@ -12651,19 +12307,6 @@ snapshots:
       merge2: 1.4.1
       slash: 3.0.0
 
-  google-auth-library@10.6.2:
-    dependencies:
-      base64-js: 1.5.1
-      ecdsa-sig-formatter: 1.0.11
-      gaxios: 7.1.4
-      gcp-metadata: 8.1.2
-      google-logging-utils: 1.1.3
-      jws: 4.0.1
-    transitivePeerDependencies:
-      - supports-color
-
-  google-logging-utils@1.1.3: {}
-
   gopd@1.2.0: {}
 
   graceful-fs@4.2.11: {}
@@ -12919,9 +12562,6 @@ snapshots:
     dependencies:
       hermes-estree: 0.35.0
 
-  hono@4.12.23:
-    optional: true
-
   hookable@5.5.3: {}
 
   hosted-git-info@7.0.2:
@@ -13012,9 +12652,6 @@ snapshots:
     dependencies:
       loose-envify: 1.4.0
 
-  ip-address@10.2.0:
-    optional: true
-
   ipaddr.js@1.9.1: {}
 
   iron-webcrypto@1.2.1: {}
@@ -13247,9 +12884,6 @@ snapshots:
 
   jimp-compact@0.16.1: {}
 
-  jose@6.2.3:
-    optional: true
-
   joycon@3.1.1: {}
 
   js-beautify@1.15.4:
@@ -13277,7 +12911,7 @@ snapshots:
 
   jsc-safe-url@0.2.4: {}
 
-  jsdom@29.0.1:
+  jsdom@29.0.1(canvas@3.2.3):
     dependencies:
       '@asamuzakjp/css-color': 5.1.1
       '@asamuzakjp/dom-selector': 7.0.4
@@ -13300,49 +12934,25 @@ snapshots:
       whatwg-mimetype: 5.0.0
       whatwg-url: 16.0.1
       xml-name-validator: 5.0.0
+    optionalDependencies:
+      canvas: 3.2.3
     transitivePeerDependencies:
       - '@noble/hashes'
 
   jsesc@3.1.0: {}
 
-  json-bigint@1.0.0:
-    dependencies:
-      bignumber.js: 9.3.1
-
-  json-schema-to-ts@3.1.1:
-    dependencies:
-      '@babel/runtime': 7.29.2
-      ts-algebra: 2.0.0
-
-  json-schema-traverse@1.0.0:
-    optional: true
-
-  json-schema-typed@8.0.2:
-    optional: true
-
   json5@2.2.3: {}
 
   jsonfile@4.0.0:
     optionalDependencies:
       graceful-fs: 4.2.11
 
-  jsonfile@6.2.0:
+  jsonfile@6.2.1:
     dependencies:
       universalify: 2.0.1
     optionalDependencies:
       graceful-fs: 4.2.11
 
-  jwa@2.0.1:
-    dependencies:
-      buffer-equal-constant-time: 1.0.1
-      ecdsa-sig-formatter: 1.0.11
-      safe-buffer: 5.1.2
-
-  jws@4.0.1:
-    dependencies:
-      jwa: 2.0.1
-      safe-buffer: 5.1.2
-
   katex@0.16.45:
     dependencies:
       commander: 8.3.0
@@ -13456,8 +13066,6 @@ snapshots:
     dependencies:
       chalk: 2.4.2
 
-  long@5.3.2: {}
-
   longest-streak@3.1.0: {}
 
   loose-envify@1.4.0:
@@ -14213,6 +13821,8 @@ snapshots:
 
   mimic-fn@1.2.0: {}
 
+  mimic-response@3.1.0: {}
+
   minimatch@10.2.5:
     dependencies:
       brace-expansion: 5.0.6
@@ -14225,10 +13835,14 @@ snapshots:
     dependencies:
       brace-expansion: 2.0.3
 
+  minimist@1.2.8: {}
+
   minipass@7.1.3: {}
 
   mitt@3.0.1: {}
 
+  mkdirp-classic@0.5.3: {}
+
   mkdirp@1.0.4: {}
 
   mlly@1.8.2:
@@ -14265,7 +13879,9 @@ snapshots:
 
   nanoid@3.3.11: {}
 
-  nanoid@5.1.9: {}
+  nanoid@5.1.15: {}
+
+  napi-build-utils@2.0.0: {}
 
   negotiator@0.6.3: {}
 
@@ -14279,7 +13895,11 @@ snapshots:
     dependencies:
       '@types/nlcst': 2.0.3
 
-  node-domexception@1.0.0: {}
+  node-abi@3.92.0:
+    dependencies:
+      semver: 7.7.4
+
+  node-addon-api@7.1.1: {}
 
   node-fetch-native@1.6.7: {}
 
@@ -14287,12 +13907,6 @@ snapshots:
     dependencies:
       whatwg-url: 5.0.0
 
-  node-fetch@3.3.2:
-    dependencies:
-      data-uri-to-buffer: 4.0.1
-      fetch-blob: 3.2.0
-      formdata-polyfill: 4.0.10
-
   node-forge@1.4.0: {}
 
   node-int64@0.4.0: {}
@@ -14403,11 +14017,6 @@ snapshots:
       is-docker: 2.2.1
       is-wsl: 2.2.0
 
-  openai@6.34.0(ws@8.20.0)(zod@4.3.6):
-    optionalDependencies:
-      ws: 8.20.0
-      zod: 4.3.6
-
   ora@3.4.0:
     dependencies:
       chalk: 2.4.2
@@ -14442,11 +14051,6 @@ snapshots:
       eventemitter3: 5.0.4
       p-timeout: 6.1.4
 
-  p-retry@4.6.2:
-    dependencies:
-      '@types/retry': 0.12.0
-      retry: 0.13.1
-
   p-timeout@6.1.4: {}
 
   p-try@2.2.0: {}
@@ -14553,9 +14157,6 @@ snapshots:
 
   pirates@4.0.7: {}
 
-  pkce-challenge@5.0.1:
-    optional: true
-
   pkg-types@1.3.1:
     dependencies:
       confbox: 0.1.8
@@ -14609,6 +14210,21 @@ snapshots:
       picocolors: 1.1.1
       source-map-js: 1.2.1
 
+  prebuild-install@7.1.3:
+    dependencies:
+      detect-libc: 2.1.2
+      expand-template: 2.0.3
+      github-from-package: 0.0.0
+      minimist: 1.2.8
+      mkdirp-classic: 0.5.3
+      napi-build-utils: 2.0.0
+      node-abi: 3.92.0
+      pump: 3.0.4
+      rc: 1.2.8
+      simple-get: 4.0.1
+      tar-fs: 2.1.4
+      tunnel-agent: 0.6.0
+
   prettier@2.8.8: {}
 
   pretty-format@27.5.1:
@@ -14646,26 +14262,16 @@ snapshots:
 
   proto-list@1.2.4: {}
 
-  protobufjs@7.5.4:
-    dependencies:
-      '@protobufjs/aspromise': 1.1.2
-      '@protobufjs/base64': 1.1.2
-      '@protobufjs/codegen': 2.0.4
-      '@protobufjs/eventemitter': 1.1.0
-      '@protobufjs/fetch': 1.1.0
-      '@protobufjs/float': 1.0.2
-      '@protobufjs/inquire': 1.1.0
-      '@protobufjs/path': 1.1.2
-      '@protobufjs/pool': 1.1.0
-      '@protobufjs/utf8': 1.1.0
-      '@types/node': 25.5.0
-      long: 5.3.2
-
   proxy-addr@2.0.7:
     dependencies:
       forwarded: 0.2.0
       ipaddr.js: 1.9.1
 
+  pump@3.0.4:
+    dependencies:
+      end-of-stream: 1.4.5
+      once: 1.4.0
+
   punycode@2.3.1: {}
 
   pure-rand@8.4.0: {}
@@ -14693,6 +14299,13 @@ snapshots:
       iconv-lite: 0.7.2
       unpipe: 1.0.0
 
+  rc@1.2.8:
+    dependencies:
+      deep-extend: 0.6.0
+      ini: 1.3.8
+      minimist: 1.2.8
+      strip-json-comments: 2.0.1
+
   react-devtools-core@6.1.5:
     dependencies:
       shell-quote: 1.8.3
@@ -15013,8 +14626,6 @@ snapshots:
       retext-stringify: 4.0.0
       unified: 11.0.5
 
-  retry@0.13.1: {}
-
   reusify@1.1.0: {}
 
   rfdc@1.4.1: {}
@@ -15273,6 +14884,14 @@ snapshots:
 
   signal-exit@4.1.0: {}
 
+  simple-concat@1.0.1: {}
+
+  simple-get@4.0.1:
+    dependencies:
+      decompress-response: 6.0.0
+      once: 1.4.0
+      simple-concat: 1.0.1
+
   simple-plist@1.3.1:
     dependencies:
       bplist-creator: 0.1.0
@@ -15434,6 +15053,8 @@ snapshots:
 
   strip-final-newline@4.0.0: {}
 
+  strip-json-comments@2.0.1: {}
+
   strip-literal@3.1.0:
     dependencies:
       js-tokens: 9.0.1
@@ -15489,11 +15110,11 @@ snapshots:
 
   supports-preserve-symlinks-flag@1.0.0: {}
 
-  svelte2tsx@0.7.53(svelte@5.55.1)(typescript@5.9.3):
+  svelte2tsx@0.7.57(svelte@5.56.3(@typescript-eslint/types@8.58.0))(typescript@5.9.3):
     dependencies:
       dedent-js: 1.0.1
       scule: 1.3.0
-      svelte: 5.55.1
+      svelte: 5.56.3(@typescript-eslint/types@8.58.0)
       typescript: 5.9.3
 
   svelte@5.55.1:
@@ -15515,6 +15136,27 @@ snapshots:
       magic-string: 0.30.21
       zimmerframe: 1.1.4
 
+  svelte@5.56.3(@typescript-eslint/types@8.58.0):
+    dependencies:
+      '@jridgewell/remapping': 2.3.5
+      '@jridgewell/sourcemap-codec': 1.5.5
+      '@sveltejs/acorn-typescript': 1.0.10(acorn@8.16.0)
+      '@types/estree': 1.0.8
+      '@types/trusted-types': 2.0.7
+      acorn: 8.16.0
+      aria-query: 5.3.1
+      axobject-query: 4.1.0
+      clsx: 2.1.1
+      devalue: 5.8.1
+      esm-env: 1.2.2
+      esrap: 2.2.11(@typescript-eslint/types@8.58.0)
+      is-reference: 3.0.3
+      locate-character: 3.0.0
+      magic-string: 0.30.21
+      zimmerframe: 1.1.4
+    transitivePeerDependencies:
+      - '@typescript-eslint/types'
+
   svgo@4.0.1:
     dependencies:
       commander: 11.1.0
@@ -15527,6 +15169,21 @@ snapshots:
 
   symbol-tree@3.2.4: {}
 
+  tar-fs@2.1.4:
+    dependencies:
+      chownr: 1.1.4
+      mkdirp-classic: 0.5.3
+      pump: 3.0.4
+      tar-stream: 2.2.0
+
+  tar-stream@2.2.0:
+    dependencies:
+      bl: 4.1.0
+      end-of-stream: 1.4.5
+      fs-constants: 1.0.0
+      inherits: 2.0.4
+      readable-stream: 3.6.2
+
   term-size@2.2.1: {}
 
   terminal-link@2.1.1:
@@ -15616,8 +15273,6 @@ snapshots:
 
   trough@2.2.0: {}
 
-  ts-algebra@2.0.0: {}
-
   ts-dedent@2.2.0: {}
 
   ts-interface-checker@0.1.13: {}
@@ -15663,6 +15318,10 @@ snapshots:
     optionalDependencies:
       fsevents: 2.3.3
 
+  tunnel-agent@0.6.0:
+    dependencies:
+      safe-buffer: 5.2.1
+
   type-detect@4.0.8: {}
 
   type-fest@0.21.3: {}
@@ -15835,7 +15494,7 @@ snapshots:
       '@types/unist': 3.0.3
       vfile-message: 4.0.3
 
-  vite-hot-client@2.1.0(vite@6.4.1(@types/node@25.5.0)(lightningcss@1.32.0)(terser@5.47.1)(tsx@4.21.0)(yaml@2.9.0)):
+  vite-hot-client@2.2.0(vite@6.4.1(@types/node@25.5.0)(lightningcss@1.32.0)(terser@5.47.1)(tsx@4.21.0)(yaml@2.9.0)):
     dependencies:
       vite: 6.4.1(@types/node@25.5.0)(lightningcss@1.32.0)(terser@5.47.1)(tsx@4.21.0)(yaml@2.9.0)
 
@@ -15866,7 +15525,7 @@ snapshots:
       '@rollup/pluginutils': 5.3.0(rollup@4.60.0)
       debug: 4.4.3
       error-stack-parser-es: 0.1.5
-      fs-extra: 11.3.4
+      fs-extra: 11.3.5
       open: 10.2.0
       perfect-debounce: 1.0.0
       picocolors: 1.1.1
@@ -15984,7 +15643,7 @@ snapshots:
     optionalDependencies:
       vite: 6.4.1(@types/node@25.5.0)(lightningcss@1.32.0)(terser@5.47.1)(tsx@4.21.0)(yaml@2.9.0)
 
-  vitest@3.2.4(@types/debug@4.1.13)(@types/node@25.5.0)(jsdom@29.0.1)(lightningcss@1.32.0)(terser@5.47.1)(tsx@4.21.0)(yaml@2.9.0):
+  vitest@3.2.4(@types/debug@4.1.13)(@types/node@25.5.0)(jsdom@29.0.1(canvas@3.2.3))(lightningcss@1.32.0)(terser@5.47.1)(tsx@4.21.0)(yaml@2.9.0):
     dependencies:
       '@types/chai': 5.2.3
       '@vitest/expect': 3.2.4
@@ -16012,7 +15671,7 @@ snapshots:
     optionalDependencies:
       '@types/debug': 4.1.13
       '@types/node': 25.5.0
-      jsdom: 29.0.1
+      jsdom: 29.0.1(canvas@3.2.3)
     transitivePeerDependencies:
       - jiti
       - less
@@ -16078,8 +15737,6 @@ snapshots:
 
   web-namespaces@2.0.1: {}
 
-  web-streams-polyfill@3.3.3: {}
-
   webidl-conversions@3.0.1: {}
 
   webidl-conversions@8.0.1: {}
@@ -16228,11 +15885,6 @@ snapshots:
     dependencies:
       zod: 3.25.76
 
-  zod-to-json-schema@3.25.2(zod@4.3.6):
-    dependencies:
-      zod: 4.3.6
-    optional: true
-
   zod-to-ts@1.2.0(typescript@5.9.3)(zod@3.25.76):
     dependencies:
       typescript: 5.9.3
diff --git a/pnpm-workspace.yaml b/pnpm-workspace.yaml
index dfba6a65..ac4194db 100644
--- a/pnpm-workspace.yaml
+++ b/pnpm-workspace.yaml
@@ -1,18 +1,21 @@
 packages:
   - .
   - website
-  - demos/compat-matrix
   - demos/reactive-layout
-  - demos/knowledge-graph
-  - demos/pagerduty-triage
+  - demos/compat-matrix
   - examples/basic/*
   - examples/compat/*
   - examples/framework/*
+  - examples/nestjs-graph-boundary
   - examples/reactive-layout/*
   - examples/knowledge-graph
   - examples/spending-alerts
-  - examples/inbox-reducer
-  - examples/harness-refine-hello
-  - examples/nestjs/*
   - apps/*
+  - scripts/hermes-smoke
   - packages/*
+allowBuilds:
+  '@nestjs/core': true
+  canvas: false
+  esbuild: true
+  protobufjs: true
+  sharp: true
diff --git a/scripts/check-layer-boundary.ts b/scripts/check-layer-boundary.ts
deleted file mode 100644
index 5aa3cdad..00000000
--- a/scripts/check-layer-boundary.ts
+++ /dev/null
@@ -1,148 +0,0 @@
-/**
- * Layer-boundary enforcement (D201). Zero-dep standalone check — wired into
- * `pnpm lint`. GritQL (Biome's plugin language) cannot express a computed
- * import-path-rank comparison, so D201's "Biome custom rule" is realized as
- * this script (D201 mechanism note amended 2026-05-15).
- *
- * Rule: inside `@graphrefly/graphrefly` (root `src/`), imports must flow
- * strictly top-down:
- *
- *   substrate(0) ◄ base(1) ◄ utils(2) ◄ presets(3) ◄ solutions(4) ◄ compat(5)
- *
- * A file at rank R may import substrate (rank 0), its own layer (rank R), and
- * any lower rank. Importing a HIGHER rank is a violation. Substrate
- * (`@graphrefly/pure-ts` / `@graphrefly/native`) is always importable.
- *
- * Test files under `src/__tests__/<layer>/` take that layer's rank.
- */
-
-import { readdirSync, readFileSync, statSync } from "node:fs";
-import { dirname, join, relative, resolve } from "node:path";
-
-const ROOT = resolve(import.meta.dirname, "..");
-const SRC = join(ROOT, "src");
-
-/**
- * Baseline ratchet: known violations deferred to the next batch (cleave class
- * A + C). A baselined violation warns instead of failing; a NEW violation
- * fails; a baseline entry that no longer matches ALSO fails (forces removal as
- * fixes land). Key format: `<repoRelFile> -> <importSpec>`.
- */
-const baselineFile = join(ROOT, "scripts/layer-boundary-baseline.json");
-let baseline = new Set<string>();
-try {
-	baseline = new Set<string>(
-		(JSON.parse(readFileSync(baselineFile, "utf8")).baseline as string[]) ?? [],
-	);
-} catch {
-	/* no baseline file — treat all violations as hard failures */
-}
-const seenBaseline = new Set<string>();
-
-const RANK: Record<string, number> = {
-	base: 1,
-	utils: 2,
-	presets: 3,
-	solutions: 4,
-	compat: 5,
-	// `testing/` ships the `mockLLM` test fixture on the public
-	// `@graphrefly/graphrefly/testing` subpath. Ranked ABOVE every production
-	// layer so the ratchet hard-fails any base/utils/presets/solutions/compat
-	// source that imports a test mock into shipped code. Test files
-	// (`src/__tests__/**`) stay unranked and may import it freely.
-	testing: 6,
-};
-
-/**
- * Layer rank for a repo-relative path, or null if not layer-scoped.
- *
- * `src/__tests__/**` is intentionally unranked: integration tests legitimately
- * cross layers (a `base/` test exercising a `compat` adapter must import
- * compat). Test files aren't shipped, so they're not part of the dependency
- * DAG. The rule enforces the SHIPPED-source DAG only. (Supersedes the A1 doc's
- * "rule applies to tests too" — that produced 10 false positives.)
- */
-function rankOf(repoRelPath: string): number | null {
-	const m = repoRelPath.match(/^src\/([^/]+)\//);
-	if (!m || m[1] === "__tests__") return null; // root barrels / test files
-	return RANK[m[1]] ?? null;
-}
-
-/** Rank of an import specifier as seen from `fromFile` (repo-relative). */
-function targetRank(spec: string, fromFileAbs: string): number | null {
-	// Substrate peers — always rank 0 (importable from anywhere).
-	if (spec === "@graphrefly/pure-ts" || spec.startsWith("@graphrefly/pure-ts/")) return 0;
-	if (spec === "@graphrefly/native" || spec.startsWith("@graphrefly/native/")) return 0;
-	// Only relative imports can cross internal layers.
-	if (!spec.startsWith(".")) return null; // npm dep / node: builtin / vitest — ignore
-	const resolvedAbs = resolve(dirname(fromFileAbs), spec);
-	const repoRel = relative(ROOT, resolvedAbs).split("\\").join("/");
-	return rankOf(repoRel);
-}
-
-const IMPORT_RE =
-	/(?:^|\n)\s*(?:import|export)\b[^;'"]*?\bfrom\s*["']([^"']+)["']|(?:^|[^.\w])import\(\s*["']([^"']+)["']\s*\)/g;
-
-function walk(dir: string, out: string[]): void {
-	for (const e of readdirSync(dir, { withFileTypes: true })) {
-		if (e.name === "node_modules" || e.name === "dist") continue;
-		const p = join(dir, e.name);
-		if (e.isDirectory()) walk(p, out);
-		else if (/\.(ts|tsx|mts|cts)$/.test(e.name)) out.push(p);
-	}
-}
-
-let violations = 0;
-const files: string[] = [];
-try {
-	if (statSync(SRC).isDirectory()) walk(SRC, files);
-} catch {
-	console.error("layer-boundary: src/ not found");
-	process.exit(1);
-}
-
-for (const fileAbs of files) {
-	const repoRel = relative(ROOT, fileAbs).split("\\").join("/");
-	const srcRank = rankOf(repoRel);
-	if (srcRank == null) continue; // composition root / shared test helpers — unranked
-	const text = readFileSync(fileAbs, "utf8");
-	for (const m of text.matchAll(IMPORT_RE)) {
-		const spec = m[1] ?? m[2];
-		if (!spec) continue;
-		const tRank = targetRank(spec, fileAbs);
-		if (tRank == null) continue; // unranked target — not a layer edge
-		if (tRank > srcRank) {
-			const key = `${repoRel} -> ${spec}`;
-			if (baseline.has(key)) {
-				seenBaseline.add(key);
-				continue; // deferred to next batch — tracked, not a hard fail
-			}
-			violations++;
-			console.error(
-				`layer-boundary: ${repoRel} (rank ${srcRank}) imports "${spec}" (rank ${tRank}) — ` +
-					`imports must flow top-down: substrate < base < utils < presets < solutions < compat`,
-			);
-		}
-	}
-}
-
-// Ratchet integrity: a baseline entry that no longer fires has been fixed —
-// it MUST be removed so the baseline can only shrink.
-const stale = [...baseline].filter((k) => !seenBaseline.has(k));
-if (stale.length > 0) {
-	console.error(
-		`\nlayer-boundary: ${stale.length} baseline entr(y/ies) no longer violated — ` +
-			`remove from scripts/layer-boundary-baseline.json (the layering was fixed):`,
-	);
-	for (const k of stale) console.error(`  - ${k}`);
-	process.exit(1);
-}
-
-if (violations > 0) {
-	console.error(`\nlayer-boundary: ${violations} NEW violation(s) (not in baseline).`);
-	process.exit(1);
-}
-console.log(
-	`layer-boundary: ${files.length} files checked, no new violations ` +
-		`(${seenBaseline.size} baselined — deferred to next batch).`,
-);
diff --git a/scripts/check-no-raw-async.ts b/scripts/check-no-raw-async.ts
new file mode 100644
index 00000000..f3952ec5
--- /dev/null
+++ b/scripts/check-no-raw-async.ts
@@ -0,0 +1,171 @@
+/**
+ * R-no-raw-async enforcement for the clean-slate @graphrefly/ts package (B21 / D43).
+ *
+ * Raw async primitives must live ONLY at the sanctioned async boundary: sources,
+ * environment drivers/adapters, and the pool/runner layer (R-no-raw-async /
+ * F-SYNC-CORE). The sync wave core and the rest of the graph layer must stay sync. This catches a raw
+ * `setTimeout`/`Promise`/`for await`/`async` leaking outside that boundary.
+ *
+ * Biome's GritQL can't express this (same reason `check-layer-boundary.ts` is a
+ * script), and `noRestrictedGlobals` can't cover `new Promise`/`Promise.resolve`/
+ * `for await` (not globals) — so the full R-no-raw-async surface lives here, wired
+ * into `pnpm lint`.
+ *
+ * Comment-aware: strips `//` and block comments (newlines preserved) so prose
+ * mentions ("kicks off async work") don't trip the scan. Test files are exempt.
+ */
+
+import { readdirSync, readFileSync, statSync } from "node:fs";
+import { join, relative, resolve } from "node:path";
+
+const ROOT = resolve(import.meta.dirname, "..");
+const SRC = join(ROOT, "packages/ts/src");
+
+/**
+ * Files where raw async IS the sanctioned boundary (R-no-raw-async / D130). Keep this set
+ * as small as possible — every entry is a hole in the guard. When a real async pool
+ * (WorkerPool/RemotePool, D20) lands, add the pool/runner file here.
+ */
+const ALLOW_ALL = new Set<string>([
+	"packages/ts/src/adapters/bridge.ts",
+	"packages/ts/src/adapters/bridge-remote-responder.ts",
+	"packages/ts/src/adapters/environment.ts",
+	"packages/ts/src/adapters/environment-outbound.ts",
+	"packages/ts/src/adapters/environment-websocket-session.ts",
+	"packages/ts/src/adapters/nestjs/native.ts",
+	"packages/ts/src/graph/environment.ts",
+	"packages/ts/src/graph/sources.ts",
+	"packages/ts/src/graph/worker.ts",
+	"packages/ts/src/sources/browser.ts",
+	"packages/ts/src/sources/node.ts",
+]);
+
+/**
+ * Pattern-scoped exceptions. D82 storage binding helpers are adapter-owned async
+ * outside the sync wave core, but only the Promise forms used for adapter I/O
+ * normalization/serialization are allowed there. D416 allows the HTTP tool-provider
+ * runtime helper to host async driver execution at the Layer C adapter/runtime boundary.
+ * Timers, async/await, for-await, and unrelated Promise combinators remain banned
+ * unless explicitly listed for a sanctioned boundary file.
+ */
+const ALLOW_LABELS = new Map<string, ReadonlySet<string>>([
+	[
+		"packages/ts/src/executors/tool-provider-adapters.ts",
+		new Set<string>(["Promise.resolve()", "setTimeout("]),
+	],
+	["packages/ts/src/adapters/nestjs.ts", new Set<string>(["new Promise"])],
+	[
+		"packages/ts/src/adapters/nestjs/microservices.ts",
+		new Set<string>(["new Promise", "setTimeout("]),
+	],
+	[
+		"packages/ts/src/adapters/nestjs/websockets.ts",
+		new Set<string>(["new Promise", "setTimeout("]),
+	],
+	[
+		"packages/ts/src/storage/append-log.ts",
+		new Set<string>(["Promise.resolve()", "Promise.all()"]),
+	],
+	["packages/ts/src/storage/content-addressed.ts", new Set<string>(["Promise.resolve()"])],
+	["packages/ts/src/storage/kv.ts", new Set<string>(["Promise.resolve()"])],
+	["packages/ts/src/storage/read-through.ts", new Set<string>(["Promise.resolve()"])],
+	["packages/ts/src/storage/wal.ts", new Set<string>(["Promise.resolve()"])],
+	["packages/ts/src/storage/browser.ts", new Set<string>(["new Promise"])],
+]);
+
+/** Risky code patterns, matched AFTER comment-stripping. */
+const PATTERNS: Array<[RegExp, string]> = [
+	[/\bsetTimeout\s*\(/, "setTimeout("],
+	[/\bsetInterval\s*\(/, "setInterval("],
+	[/\bsetImmediate\s*\(/, "setImmediate("],
+	[/\bqueueMicrotask\s*\(/, "queueMicrotask("],
+	[/\bprocess\s*\.\s*nextTick\b/, "process.nextTick"],
+	[/\bnew\s+Promise\b/, "new Promise"],
+	[/\bPromise\s*\.\s*resolve\s*\(/, "Promise.resolve()"],
+	[/\bPromise\s*\.\s*all\s*\(/, "Promise.all()"],
+	[/\bPromise\s*\.\s*(?:reject|race|allSettled|any)\s*\(/, "Promise.<other>()"],
+	[/\bfor\s+await\b/, "for await"],
+	[/\basync\s+(?:function|\*|\(|[A-Za-z_$])/, "async function/method/arrow"],
+	[/\bawait\s/, "await"],
+];
+
+/** Strip `//` line comments and `/* *\/` block comments, preserving newlines for line numbers. */
+function stripComments(text: string): string {
+	let out = "";
+	let state: "code" | "line" | "block" = "code";
+	for (let i = 0; i < text.length; i++) {
+		const two = text.slice(i, i + 2);
+		if (state === "code") {
+			if (two === "//") {
+				state = "line";
+				i++;
+			} else if (two === "/*") {
+				state = "block";
+				i++;
+			} else {
+				out += text[i];
+			}
+		} else if (state === "line") {
+			if (text[i] === "\n") {
+				state = "code";
+				out += "\n";
+			}
+		} else {
+			// block
+			if (two === "*/") {
+				state = "code";
+				i++;
+			} else if (text[i] === "\n") {
+				out += "\n";
+			}
+		}
+	}
+	return out;
+}
+
+function walk(dir: string, out: string[]): void {
+	for (const e of readdirSync(dir, { withFileTypes: true })) {
+		if (e.name === "node_modules" || e.name === "dist" || e.name === "__tests__") continue;
+		const p = join(dir, e.name);
+		if (e.isDirectory()) walk(p, out);
+		else if (/\.(ts|tsx|mts|cts)$/.test(e.name)) out.push(p);
+	}
+}
+
+const files: string[] = [];
+try {
+	if (statSync(SRC).isDirectory()) walk(SRC, files);
+} catch {
+	console.error("check-no-raw-async: packages/ts/src not found");
+	process.exit(1);
+}
+
+let violations = 0;
+for (const fileAbs of files) {
+	const repoRel = relative(ROOT, fileAbs).split("\\").join("/");
+	if (ALLOW_ALL.has(repoRel)) continue;
+	const allowedLabels = ALLOW_LABELS.get(repoRel);
+	const lines = stripComments(readFileSync(fileAbs, "utf8")).split("\n");
+	for (let i = 0; i < lines.length; i++) {
+		for (const [re, label] of PATTERNS) {
+			if (re.test(lines[i])) {
+				if (allowedLabels?.has(label)) continue;
+				violations++;
+				console.error(
+					`check-no-raw-async: ${repoRel}:${i + 1} uses raw async \`${label}\` — ` +
+						"async boundaries live ONLY in sources / the pool-runner layer (R-no-raw-async / F-SYNC-CORE). " +
+						"Move it into a source (graph/sources.ts), or add this file to the ALLOW set if it IS the pool/runner boundary.",
+				);
+			}
+		}
+	}
+}
+
+if (violations > 0) {
+	console.error(`\ncheck-no-raw-async: ${violations} violation(s).`);
+	process.exit(1);
+}
+console.log(
+	`check-no-raw-async: ${files.length} files checked, no raw async outside the sanctioned boundary ` +
+		`(${ALLOW_ALL.size} whole-file allowlisted, ${ALLOW_LABELS.size} pattern-scoped).`,
+);
diff --git a/scripts/check-ts-package-exports.mjs b/scripts/check-ts-package-exports.mjs
new file mode 100644
index 00000000..29ae28b6
--- /dev/null
+++ b/scripts/check-ts-package-exports.mjs
@@ -0,0 +1,648 @@
+import { execFileSync } from "node:child_process";
+import {
+	cpSync,
+	existsSync,
+	mkdirSync,
+	mkdtempSync,
+	readFileSync,
+	rmSync,
+	symlinkSync,
+	writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+const PKG = join(ROOT, "packages", "ts");
+const TSC = join(ROOT, "node_modules", ".bin", "tsc");
+const packageJson = JSON.parse(readFileSync(join(PKG, "package.json"), "utf8"));
+const optionalPeers = [
+	"@nestjs/common",
+	"@nestjs/core",
+	"@nestjs/microservices",
+	"@nestjs/websockets",
+	"canvas",
+	"react",
+	"rxjs",
+	"solid-js",
+	"svelte",
+	"vue",
+];
+
+const expectedSubpaths = {
+	"./adapters": {
+		present: [
+			"CanonicalProtobufError",
+			"decodeCanonicalWireBridgeEnvelope",
+			"decodeCanonicalWireEdgeFrame",
+			"encodeCanonicalWireBridgeEnvelope",
+			"encodeCanonicalWireEdgeFrame",
+			"wireBridgeProtobuf",
+			"subscribeNodeValues",
+			"readableStore",
+			"writableStore",
+			"externalStore",
+			"recordReadableStore",
+		],
+		absent: [
+			"useNodeValue",
+			"useNodeInput",
+			"useNodeRecord",
+			"createNodeValue",
+			"createNodeInput",
+			"createNodeRecord",
+			"nodeReadable",
+			"nodeWritable",
+			"nodeRecord",
+			"fromNestReq",
+			"toNestHttp",
+		],
+	},
+	"./adapters/nestjs": {
+		present: [
+			"fromNestReq",
+			"fromNestGuard",
+			"fromNestIntercept",
+			"fromNestError",
+			"fromNestLifecycle",
+			"fromNestCron",
+			"toNestHttp",
+			"GraphReq",
+			"GraphGuard",
+			"GraphIntercept",
+			"GraphError",
+			"GraphLifecycle",
+			"GraphCron",
+			"GraphHttpReply",
+			"createNestGraphBoundaryRunner",
+			"createNestGraphBoundaryInterceptor",
+			"getNestBoundaryToken",
+		],
+		absent: [],
+	},
+	"./adapters/nestjs/native": {
+		present: [
+			"provideGraphBoundaryInterceptor",
+			"provideGraphGuard",
+			"provideGraphExceptionFilter",
+			"provideGraphCronScheduler",
+			"provideGraphLifecycleHooks",
+			"provideGraphGuardDeniedFilter",
+		],
+		absent: [],
+	},
+	"./adapters/nestjs/websockets": {
+		present: [
+			"fromNestWs",
+			"GraphWs",
+			"GraphWsAck",
+			"GraphWsReply",
+			"createGraphWsBridge",
+			"provideGraphWsBridge",
+		],
+		absent: ["fromNestMessage", "GraphMessage", "GraphMessageReply"],
+	},
+	"./adapters/nestjs/microservices": {
+		present: [
+			"fromNestMessage",
+			"GraphMessage",
+			"GraphMessageReply",
+			"createGraphMessageBridge",
+			"provideGraphMessageBridge",
+		],
+		absent: ["fromNestWs", "GraphWs", "GraphWsAck", "GraphWsReply"],
+	},
+	"./adapters/react": { present: ["useNodeValue", "useNodeInput", "useNodeRecord"], absent: [] },
+	"./adapters/vue": { present: ["useNodeValue", "useNodeInput", "useNodeRecord"], absent: [] },
+	"./adapters/solid": {
+		present: ["createNodeValue", "createNodeInput", "createNodeRecord"],
+		absent: [],
+	},
+	"./adapters/svelte": { present: ["nodeReadable", "nodeWritable", "nodeRecord"], absent: [] },
+	"./cqrs/messaging": { present: ["cqrsMessagingRecipe"], absent: [] },
+	"./cqrs/work-queue": { present: ["cqrsWorkQueueRecipe"], absent: [] },
+	"./executors/tool-provider": {
+		present: ["toolProviderExecutionRecipe"],
+		absent: [],
+	},
+	"./executors/tool-provider-adapters": {
+		present: [
+			"localBuiltinToolProviderBinding",
+			"localBuiltinToolProviderAdapterPack",
+			"processToolProviderBinding",
+			"processToolProviderAdapterPack",
+			"processToolProviderCatalog",
+			"httpToolProviderCatalog",
+			"httpToolProviderRuntime",
+		],
+		absent: ["attachToolProviderAdapterRuntime", "toolProviderExecutionRecipe"],
+	},
+	"./executors/tool-provider-runtime": {
+		present: ["attachToolProviderAdapterRuntime"],
+		absent: [],
+	},
+	"./inspection/boundary": { present: ["boundaryManifest"], absent: [] },
+	"./orchestration/messaging": { present: ["orchestrationMessagingRecipe"], absent: [] },
+	"./orchestration/work-queue": { present: ["orchestrationWorkQueueRecipe"], absent: [] },
+	"./solutions/work-item/scheduling": {
+		present: [
+			"isWorkspaceProposalProjectionReleaseMaterial",
+			"validateWorkspaceProposalProjectionReleaseMaterial",
+			"workspaceProposalProjectionReleaseDiagnosticProjector",
+		],
+		absent: [
+			"genericFamilyFactReader",
+			"readFamilyFact",
+			"recordFamilyOutcome",
+			"selectorAdapter",
+			"selectorAdapterRegistry",
+			"providerHandle",
+			"storageHandle",
+			"queryHandle",
+			"opaqueProviderCursor",
+			"providerCursor",
+		],
+	},
+};
+
+const forbiddenFrameworkSpecifiers = [
+	'from "react"',
+	"from 'react'",
+	'require("react")',
+	"require('react')",
+	'from "vue"',
+	"from 'vue'",
+	'require("vue")',
+	"require('vue')",
+	'from "solid-js"',
+	"from 'solid-js'",
+	'require("solid-js")',
+	"require('solid-js')",
+	'from "svelte/store"',
+	"from 'svelte/store'",
+	'require("svelte/store")',
+	"require('svelte/store')",
+];
+
+const rootAbsentExports = [
+	"attachToolProviderAdapterRuntime",
+	"toolProviderExecutionRecipe",
+	"localBuiltinToolProviderBinding",
+	"processToolProviderBinding",
+	"httpToolProviderCatalog",
+	"httpToolProviderRuntime",
+	"useNodeValue",
+	"useNodeInput",
+	"useNodeRecord",
+	"createNodeValue",
+	"createNodeInput",
+	"createNodeRecord",
+	"nodeReadable",
+	"nodeWritable",
+	"nodeRecord",
+	"boundaryManifest",
+	"isWorkspaceProposalProjectionReleaseMaterial",
+	"validateWorkspaceProposalProjectionReleaseMaterial",
+	"workspaceProposalProjectionReleaseDiagnosticProjector",
+];
+
+const rootAbsentTypeExports = [
+	"BoundaryManifest",
+	"BoundaryNode",
+	"BoundaryRole",
+	"InputBoundaryNode",
+	"OutputBoundaryNode",
+	"WorkspaceProposalProjectionRelease",
+	"WorkspaceProposalProjectionReleaseDiagnostic",
+	"WorkspaceProposalProjectionReleaseDiagnosticProjectorBundle",
+	"WorkspaceProposalProjectionReleaseDiagnosticProjectorOptions",
+	"WorkspaceProposalProjectionReleaseTargetKind",
+	"WorkspaceProposalProjectionReleaseValidationResult",
+];
+
+function fail(message) {
+	console.error(`check-ts-package-exports: ${message}`);
+	process.exit(1);
+}
+
+function assert(condition, message) {
+	if (!condition) fail(message);
+}
+
+function exportTarget(subpath, condition, key) {
+	const entry = packageJson.exports?.[subpath]?.[condition]?.[key];
+	assert(typeof entry === "string", `${subpath} missing exports.${condition}.${key}`);
+	return join(PKG, entry);
+}
+
+function errorOutput(err) {
+	const stdout =
+		typeof err.stdout === "string"
+			? err.stdout
+			: Buffer.isBuffer(err.stdout)
+				? err.stdout.toString("utf8")
+				: "";
+	const stderr =
+		typeof err.stderr === "string"
+			? err.stderr
+			: Buffer.isBuffer(err.stderr)
+				? err.stderr.toString("utf8")
+				: "";
+	return `${stdout}${stderr}`;
+}
+
+function validateExportTree(value, path) {
+	if (typeof value === "string") {
+		assert(value.startsWith("./"), `${path} must be a package-relative target`);
+		assert(existsSync(join(PKG, value)), `${path} target missing: ${value}`);
+		return;
+	}
+	assert(
+		value !== null && typeof value === "object",
+		`${path} must be a string or condition object`,
+	);
+	for (const [key, child] of Object.entries(value)) {
+		validateExportTree(child, `${path}.${key}`);
+	}
+}
+
+function expectTscFailure(tmp, file, expectedNames) {
+	const config = `tsconfig.${file}.json`;
+	writeFileSync(
+		join(tmp, config),
+		JSON.stringify(
+			{
+				compilerOptions: {
+					target: "ES2022",
+					module: "NodeNext",
+					moduleResolution: "NodeNext",
+					strict: true,
+					noEmit: true,
+					skipLibCheck: true,
+				},
+				include: [file],
+			},
+			null,
+			"\t",
+		),
+	);
+	try {
+		execFileSync(TSC, ["-p", config], { cwd: tmp, stdio: "pipe" });
+		fail(`${file} unexpectedly typechecked; forbidden type-only exports leaked`);
+	} catch (e) {
+		const out = errorOutput(e);
+		for (const name of expectedNames) {
+			assert(
+				out.includes(name),
+				`${file} failed for an unexpected reason; missing diagnostic for ${name}`,
+			);
+		}
+	}
+}
+
+validateExportTree(packageJson.exports, "exports");
+
+for (const subpath of Object.keys(expectedSubpaths)) {
+	assert(packageJson.exports?.[subpath] !== undefined, `${subpath} missing from package exports`);
+	for (const [condition, extension] of [
+		["import", ".js"],
+		["require", ".cjs"],
+	]) {
+		const runtimeTarget = exportTarget(subpath, condition, "default");
+		assert(
+			existsSync(runtimeTarget),
+			`${subpath} ${condition} runtime target missing: ${runtimeTarget}`,
+		);
+		assert(
+			runtimeTarget.endsWith(extension),
+			`${subpath} ${condition} runtime target should end with ${extension}`,
+		);
+		const typeTarget = exportTarget(subpath, condition, "types");
+		assert(existsSync(typeTarget), `${subpath} ${condition} type target missing: ${typeTarget}`);
+	}
+}
+
+for (const peer of optionalPeers) {
+	assert(
+		packageJson.peerDependencies?.[peer] !== undefined,
+		`optional peer ${peer} missing from peerDependencies`,
+	);
+	assert(
+		packageJson.peerDependenciesMeta?.[peer]?.optional === true,
+		`optional peer ${peer} missing peerDependenciesMeta optional:true`,
+	);
+}
+
+for (const rel of [
+	"dist/index.js",
+	"dist/index.cjs",
+	"dist/adapters/index.js",
+	"dist/adapters/index.cjs",
+]) {
+	const file = join(PKG, rel);
+	assert(existsSync(file), `${rel} missing; run pnpm --filter @graphrefly/ts build`);
+	const text = readFileSync(file, "utf8");
+	for (const specifier of forbiddenFrameworkSpecifiers) {
+		assert(
+			!text.includes(specifier),
+			`${rel} imports framework peer through the universal/adapters build: ${specifier}`,
+		);
+	}
+}
+
+const tmp = mkdtempSync(join(tmpdir(), "graphrefly-ts-export-smoke-"));
+
+try {
+	mkdirSync(join(tmp, "node_modules", "@graphrefly"), { recursive: true });
+	const tmpPkg = join(tmp, "node_modules", "@graphrefly", "ts");
+	mkdirSync(tmpPkg, { recursive: true });
+	cpSync(join(PKG, "package.json"), join(tmpPkg, "package.json"));
+	cpSync(join(PKG, "dist"), join(tmpPkg, "dist"), { recursive: true });
+	for (const peer of optionalPeers) {
+		const realPeer = join(ROOT, "node_modules", peer);
+		if (existsSync(realPeer)) {
+			const link = join(tmp, "node_modules", peer);
+			mkdirSync(dirname(link), { recursive: true });
+			symlinkSync(realPeer, link, "dir");
+		}
+	}
+	writeFileSync(
+		join(tmp, "package.json"),
+		JSON.stringify({ type: "module", private: true }, null, "\t"),
+	);
+
+	const rootAbsentChecks = rootAbsentExports
+		.map(
+			(name) =>
+				`assert(!Object.hasOwn(root, ${JSON.stringify(name)}), ${JSON.stringify(`@graphrefly/ts must not export ${name}`)});`,
+		)
+		.join("\n");
+
+	const runtimeAssertions = `{
+	const root = await load("@graphrefly/ts");
+	${rootAbsentChecks}
+}
+${Object.entries(expectedSubpaths)
+	.map(([subpath, { present, absent }]) => {
+		const specifier = `@graphrefly/ts${subpath.slice(1)}`;
+		const presentChecks = present
+			.map(
+				(name) =>
+					`assert(typeof mod[${JSON.stringify(name)}] === "function", ${JSON.stringify(`${specifier}.${name}`)});`,
+			)
+			.join("\n");
+		const absentChecks = absent
+			.map(
+				(name) =>
+					`assert(!Object.hasOwn(mod, ${JSON.stringify(name)}), ${JSON.stringify(`${specifier} must not export ${name}`)});`,
+			)
+			.join("\n");
+		return `{
+	const mod = await load(${JSON.stringify(specifier)});
+	${presentChecks}
+	${absentChecks}
+}`;
+	})
+	.join("\n")}`;
+
+	writeFileSync(
+		join(tmp, "esm-smoke.mjs"),
+		`import assert from "node:assert/strict";
+const load = (specifier) => import(specifier);
+${runtimeAssertions}
+`,
+	);
+
+	writeFileSync(
+		join(tmp, "cjs-smoke.cjs"),
+		`const assert = require("node:assert/strict");
+const load = (specifier) => require(specifier);
+${runtimeAssertions.replaceAll("await load", "load")}
+`,
+	);
+
+	writeFileSync(
+		join(tmp, "types-smoke.mts"),
+		`import { externalStore, readableStore, recordReadableStore, subscribeNodeValues, wireBridgeProtobuf, writableStore, type WireBridgeProtobufBundle, type WireBridgeProtobufData, type WireBridgeProtobufIssue, type WireBridgeProtobufOptions, type WireBridgeProtobufStatus } from "@graphrefly/ts/adapters";
+import { useNodeInput, useNodeRecord, useNodeValue } from "@graphrefly/ts/adapters/react";
+import { createNodeInput, createNodeRecord, createNodeValue } from "@graphrefly/ts/adapters/solid";
+import { nodeReadable, nodeRecord, nodeWritable } from "@graphrefly/ts/adapters/svelte";
+import { useNodeInput as useVueNodeInput, useNodeRecord as useVueNodeRecord, useNodeValue as useVueNodeValue } from "@graphrefly/ts/adapters/vue";
+import {
+	toolProviderExecutionRecipe,
+	type ToolProviderExecutionRecipeBundle,
+	type ToolProviderExecutionRecipeOptions,
+} from "@graphrefly/ts/executors/tool-provider";
+import {
+	httpToolProviderCatalog,
+	httpToolProviderRuntime,
+	localBuiltinToolProviderAdapterPack,
+	localBuiltinToolProviderBinding,
+	processToolProviderAdapterPack,
+	processToolProviderBinding,
+	processToolProviderCatalog,
+	type HttpToolProviderDriver,
+	type HttpToolProviderRuntimeBundle,
+	type HttpToolProviderRuntimeOptions,
+	type LocalBuiltinToolProviderBindingOptions,
+	type ProcessToolProviderBindingOptions,
+} from "@graphrefly/ts/executors/tool-provider-adapters";
+import {
+	attachToolProviderAdapterRuntime,
+	type ToolProviderAdapterBinding,
+	type ToolProviderAdapterExecutionRetentionEntry,
+	type ToolProviderAdapterInputRetentionEntry,
+	type ToolProviderAdapterRunContext,
+	type ToolProviderAdapterRunIssueRetentionEntry,
+	type ToolProviderAdapterRunRequestRetentionEntry,
+	type ToolProviderAdapterRunResult,
+	type ToolProviderAdapterRunStatusRetentionEntry,
+	type ToolProviderAdapterRuntimeHandle,
+	type ToolProviderAdapterRuntimeIndexRetentionPolicy,
+	type ToolProviderAdapterRuntimeOptions,
+	type ToolProviderAdapterRuntimeRetentionEvidenceEntry,
+	type ToolProviderAdapterRuntimeRetentionIndex,
+	type ToolProviderAdapterRuntimeRetentionOrder,
+	type ToolProviderAdapterRuntimeRetentionPolicy,
+	type ToolProviderAdapterRuntimeStatus,
+	type ToolProviderAdapterRuntimeStatusKind,
+	type ToolProviderPublicTextPolicy,
+} from "@graphrefly/ts/executors/tool-provider-runtime";
+import { boundaryManifest, type BoundaryManifest, type BoundaryNode, type BoundaryRole } from "@graphrefly/ts/inspection/boundary";
+import {
+	isWorkspaceProposalProjectionReleaseMaterial,
+	validateWorkspaceProposalProjectionReleaseMaterial,
+	workspaceProposalProjectionReleaseDiagnosticProjector,
+	type WorkspaceProposalProjectionRelease,
+	type WorkspaceProposalProjectionReleaseDiagnostic,
+	type WorkspaceProposalProjectionReleaseDiagnosticProjectorBundle,
+	type WorkspaceProposalProjectionReleaseDiagnosticProjectorOptions,
+	type WorkspaceProposalProjectionReleaseTargetKind,
+	type WorkspaceProposalProjectionReleaseValidationResult,
+} from "@graphrefly/ts/solutions/work-item/scheduling";
+
+void externalStore;
+void readableStore;
+void recordReadableStore;
+void subscribeNodeValues;
+void wireBridgeProtobuf;
+void writableStore;
+void useNodeInput;
+void useNodeRecord;
+void useNodeValue;
+void createNodeInput;
+void createNodeRecord;
+void createNodeValue;
+void nodeReadable;
+void nodeRecord;
+void nodeWritable;
+void useVueNodeInput;
+void useVueNodeRecord;
+void useVueNodeValue;
+void toolProviderExecutionRecipe;
+void attachToolProviderAdapterRuntime;
+void httpToolProviderCatalog;
+void httpToolProviderRuntime;
+void localBuiltinToolProviderAdapterPack;
+void localBuiltinToolProviderBinding;
+void processToolProviderAdapterPack;
+void processToolProviderBinding;
+void processToolProviderCatalog;
+void boundaryManifest;
+void isWorkspaceProposalProjectionReleaseMaterial;
+void validateWorkspaceProposalProjectionReleaseMaterial;
+void workspaceProposalProjectionReleaseDiagnosticProjector;
+
+declare const manifest: BoundaryManifest;
+const role: BoundaryRole = "input";
+const node: BoundaryNode | undefined = manifest.inputs[0] ?? manifest.outputs[0];
+declare const recipeBundle: ToolProviderExecutionRecipeBundle;
+declare const recipeOptions: ToolProviderExecutionRecipeOptions;
+declare const runtimeBinding: ToolProviderAdapterBinding;
+declare const runtimeExecutionRetentionEntry: ToolProviderAdapterExecutionRetentionEntry;
+declare const runtimeInputRetentionEntry: ToolProviderAdapterInputRetentionEntry;
+declare const runtimeRunContext: ToolProviderAdapterRunContext;
+declare const runtimeRunIssueRetentionEntry: ToolProviderAdapterRunIssueRetentionEntry;
+declare const runtimeRunRequestRetentionEntry: ToolProviderAdapterRunRequestRetentionEntry;
+declare const runtimeRunResult: ToolProviderAdapterRunResult;
+declare const runtimeRunStatusRetentionEntry: ToolProviderAdapterRunStatusRetentionEntry;
+declare const runtimeHandle: ToolProviderAdapterRuntimeHandle;
+declare const runtimeIndexRetentionPolicy: ToolProviderAdapterRuntimeIndexRetentionPolicy<unknown>;
+declare const runtimeOptions: ToolProviderAdapterRuntimeOptions;
+declare const runtimeRetentionEvidenceEntry: ToolProviderAdapterRuntimeRetentionEvidenceEntry;
+declare const runtimeRetentionIndex: ToolProviderAdapterRuntimeRetentionIndex;
+const runtimeRetentionOrder: ToolProviderAdapterRuntimeRetentionOrder = "fifo";
+declare const runtimeRetentionPolicy: ToolProviderAdapterRuntimeRetentionPolicy;
+declare const runtimeStatus: ToolProviderAdapterRuntimeStatus;
+declare const runtimeStatusKind: ToolProviderAdapterRuntimeStatusKind;
+declare const publicTextPolicy: ToolProviderPublicTextPolicy;
+declare const httpDriver: HttpToolProviderDriver;
+declare const httpRuntimeBundle: HttpToolProviderRuntimeBundle;
+declare const httpRuntimeOptions: HttpToolProviderRuntimeOptions;
+declare const localBindingOptions: LocalBuiltinToolProviderBindingOptions;
+declare const processBindingOptions: ProcessToolProviderBindingOptions;
+declare const projectionRelease: WorkspaceProposalProjectionRelease;
+declare const projectionReleaseDiagnostic: WorkspaceProposalProjectionReleaseDiagnostic;
+declare const projectionReleaseDiagnosticProjectorBundle: WorkspaceProposalProjectionReleaseDiagnosticProjectorBundle;
+declare const projectionReleaseDiagnosticProjectorOptions: WorkspaceProposalProjectionReleaseDiagnosticProjectorOptions;
+declare const projectionReleaseValidationResult: WorkspaceProposalProjectionReleaseValidationResult;
+declare const protobufBundle: WireBridgeProtobufBundle;
+declare const protobufData: WireBridgeProtobufData;
+declare const protobufIssue: WireBridgeProtobufIssue;
+declare const protobufOptions: WireBridgeProtobufOptions;
+declare const protobufStatus: WireBridgeProtobufStatus;
+const projectionReleaseTargetKind: WorkspaceProposalProjectionReleaseTargetKind = "family-read-model-query";
+void role;
+void node;
+void recipeBundle;
+void recipeOptions;
+void runtimeBinding;
+void runtimeExecutionRetentionEntry;
+void runtimeInputRetentionEntry;
+void runtimeRunContext;
+void runtimeRunIssueRetentionEntry;
+void runtimeRunRequestRetentionEntry;
+void runtimeRunResult;
+void runtimeRunStatusRetentionEntry;
+void runtimeHandle;
+void runtimeIndexRetentionPolicy;
+void runtimeOptions;
+void runtimeRetentionEvidenceEntry;
+void runtimeRetentionIndex;
+void runtimeRetentionOrder;
+void runtimeRetentionPolicy;
+void runtimeStatus;
+void runtimeStatusKind;
+void publicTextPolicy;
+void httpDriver;
+void httpRuntimeBundle;
+void httpRuntimeOptions;
+void localBindingOptions;
+void processBindingOptions;
+void projectionRelease;
+void projectionReleaseDiagnostic;
+void projectionReleaseDiagnosticProjectorBundle;
+void projectionReleaseDiagnosticProjectorOptions;
+void projectionReleaseValidationResult;
+void projectionReleaseTargetKind;
+void protobufBundle;
+void protobufData;
+void protobufIssue;
+void protobufOptions;
+void protobufStatus;
+`,
+	);
+	const rootForbiddenNames = [...rootAbsentExports, ...rootAbsentTypeExports].join(", ");
+	writeFileSync(
+		join(tmp, "root-negative.mts"),
+		`import type { ${rootForbiddenNames} } from "@graphrefly/ts";
+`,
+	);
+	writeFileSync(
+		join(tmp, "adapters-negative.mts"),
+		`import type { useNodeValue, useNodeInput, useNodeRecord, createNodeValue, createNodeInput, createNodeRecord, nodeReadable, nodeWritable, nodeRecord, fromNestReq, toNestHttp } from "@graphrefly/ts/adapters";
+`,
+	);
+	writeFileSync(
+		join(tmp, "scheduling-negative.mts"),
+		`import type { ${expectedSubpaths["./solutions/work-item/scheduling"].absent.join(", ")} } from "@graphrefly/ts/solutions/work-item/scheduling";
+`,
+	);
+
+	writeFileSync(
+		join(tmp, "tsconfig.json"),
+		JSON.stringify(
+			{
+				compilerOptions: {
+					target: "ES2022",
+					module: "NodeNext",
+					moduleResolution: "NodeNext",
+					strict: true,
+					noEmit: true,
+					skipLibCheck: true,
+				},
+				include: ["types-smoke.mts"],
+			},
+			null,
+			"\t",
+		),
+	);
+
+	execFileSync(process.execPath, ["esm-smoke.mjs"], { cwd: tmp, stdio: "pipe" });
+	execFileSync(process.execPath, ["cjs-smoke.cjs"], { cwd: tmp, stdio: "pipe" });
+	execFileSync(TSC, ["-p", "tsconfig.json"], { cwd: tmp, stdio: "pipe" });
+	expectTscFailure(tmp, "root-negative.mts", [...rootAbsentExports, ...rootAbsentTypeExports]);
+	expectTscFailure(tmp, "adapters-negative.mts", expectedSubpaths["./adapters"].absent);
+	expectTscFailure(
+		tmp,
+		"scheduling-negative.mts",
+		expectedSubpaths["./solutions/work-item/scheduling"].absent,
+	);
+} catch (e) {
+	fail(`${e.message ?? e}\n${errorOutput(e)}`.trim());
+} finally {
+	rmSync(tmp, { recursive: true, force: true });
+}
+
+console.log("check-ts-package-exports: package ESM/CJS/DTS subpath smoke passed");
diff --git a/scripts/check-typecheck.ts b/scripts/check-typecheck.ts
index cce5f93f..4cc010e3 100644
--- a/scripts/check-typecheck.ts
+++ b/scripts/check-typecheck.ts
@@ -1,25 +1,14 @@
 /**
- * Typecheck gate for the two workspace packages that nothing else
- * typechecks (surfaced 2026-05-17 by the D2/D3 parity-cleanup batch).
+ * Typecheck gate for legacy workspace packages that nothing else typechecks.
  *
- * `packages/parity-tests/` and `evals/` run via vitest / tsx — both strip
- * types through esbuild, so `tsc` never runs on them in `pnpm test`,
- * `pnpm build`, or CI. That left D3's `Impl`-contract intersection (and
- * any future native/contract drift) an *unenforced* contract. This
- * script closes the gap: it `tsc --noEmit`s each package and hard-fails
- * on ANY error.
+ * B66 note: the old structural Impl parity harness was retired to
+ * `archive/packages/parity-tests`; clean-slate parity is authority conformance
+ * in `~/src/graphrefly/spec/conformance.jsonl` (D24). Keep this gate empty
+ * until another active workspace package genuinely needs standalone tsc.
  *
- * **No baseline.** Both packages were driven to **zero** errors in the
- * same batch (the layer-boundary script keeps a ratchet baseline because
- * its violations were deferred; here there is nothing to defer). A new
- * type error — e.g. a `@graphrefly/native` wrapper signature drifting
- * from the parity `Impl` contract, or an eval script falling behind a
- * substrate API — fails `pnpm lint`. That IS the first-line parity gate
- * D3 asked for. Do not add a baseline to silence a new error; fix it.
- *
- * Zero-dep standalone, wired into `pnpm lint` after
- * `check-layer-boundary.ts` (same discipline, mechanism amended for the
- * typecheck case).
+ * B66 note: `evals/` was retired to `archive/evals` on 2026-06-27. CSP-8 may
+ * design a new clean-slate eval harness later, but this gate should not point
+ * at the archived legacy scripts.
  */
 
 import { execFileSync } from "node:child_process";
@@ -29,10 +18,7 @@ const ROOT = resolve(import.meta.dirname, "..");
 const TSC = resolve(ROOT, "node_modules/.bin/tsc");
 
 /** Previously-ungated packages this gate now enforces. */
-const TARGETS: readonly { name: string; project: string }[] = [
-	{ name: "parity-tests", project: "packages/parity-tests/tsconfig.json" },
-	{ name: "evals", project: "evals/tsconfig.json" },
-];
+const TARGETS: readonly { name: string; project: string }[] = [];
 
 let failed = false;
 
diff --git a/scripts/codemod-cleave-A.ts b/scripts/codemod-cleave-A.ts
deleted file mode 100644
index 2a59d94f..00000000
--- a/scripts/codemod-cleave-A.ts
+++ /dev/null
@@ -1,1637 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * codemod-cleave-A.ts — A2 execution: purify @graphrefly/pure-ts.
- *
- * Moves presentation files from packages/pure-ts/src/ to root src/{base,utils,presets,compat}/
- * Renames substrate files within pure-ts (sources/iter.ts → sources/sync/iter.ts, etc.)
- * Deletes 25 backward-compat shims at extra/*.ts (extra/storage.ts absent from disk)
- * Rewrites imports across the monorepo
- * Migrates presentation tests to root src/__tests__/ (Option B)
- * Moves trackingKey → utils/harness/_internal.ts (STOP #1 resolved)
- *
- * Usage:
- *   pnpm tsx scripts/codemod-cleave-A.ts [--dry]
- *
- * Provenance: archive/docs/SESSION-DS-cleave-A-file-moves.md
- * Escalations resolved: STOP #1 (trackingKey destination), STOP #2 (test migration Option B),
- *   MINOR (extra/storage.ts absent from disk).
- */
-
-import { existsSync, statSync } from "node:fs";
-import { copyFile, mkdir, readdir, readFile, rename, rm, writeFile } from "node:fs/promises";
-import { dirname, join, relative, resolve } from "node:path";
-
-const ROOT = resolve(import.meta.dirname, "..");
-const PURE_TS_SRC = join(ROOT, "packages/pure-ts/src");
-const PURE_TS_TESTS = join(ROOT, "packages/pure-ts/src/__tests__");
-const ROOT_SRC = join(ROOT, "src");
-const ROOT_TESTS = join(ROOT, "src/__tests__");
-
-const DRY = process.argv.includes("--dry");
-
-// ---------------------------------------------------------------------------
-// MOVES TABLE
-// ---------------------------------------------------------------------------
-// Format: [oldRelpath, newRelpath]
-// oldRelpath: relative to packages/pure-ts/src/
-// newRelpath: either relative to packages/pure-ts/src/ (substrate stays)
-//             or prefixed with "ROOT:" for moves to root src/
-//
-// Longest-prefix-first to avoid premature matches.
-
-type Move = {
-	from: string; // relative to PURE_TS_SRC
-	to: string; // relative to PURE_TS_SRC (substrate) or ROOT_SRC (presentation)
-	toRoot: boolean; // true = destination is ROOT_SRC
-};
-
-const MOVES: Move[] = [
-	// -------------------------------------------------------------------------
-	// Substrate renames (within pure-ts)
-	// -------------------------------------------------------------------------
-	{ from: "extra/sources/iter.ts", to: "extra/sources/sync/iter.ts", toRoot: false },
-	{ from: "extra/sources/event.ts", to: "extra/sources/event/_orig.ts", toRoot: false }, // handled via symbol split below
-	{ from: "extra/timer.ts", to: "core/_internal/timer.ts", toRoot: false },
-	{ from: "extra/utils/ring-buffer.ts", to: "core/_internal/ring-buffer.ts", toRoot: false },
-	{ from: "extra/utils/sizeof.ts", to: "core/_internal/sizeof.ts", toRoot: false },
-
-	// -------------------------------------------------------------------------
-	// Presentation → base/io/ (31 files from extra/io/)
-	// -------------------------------------------------------------------------
-	{ from: "extra/io/_internal.ts", to: "base/io/_internal.ts", toRoot: true },
-	{ from: "extra/io/checkpoint.ts", to: "base/io/checkpoint.ts", toRoot: true },
-	{ from: "extra/io/clickhouse-watch.ts", to: "base/io/clickhouse-watch.ts", toRoot: true },
-	{ from: "extra/io/csv.ts", to: "base/io/csv.ts", toRoot: true },
-	{ from: "extra/io/drizzle.ts", to: "base/io/drizzle.ts", toRoot: true },
-	{ from: "extra/io/http-error.ts", to: "base/io/http-error.ts", toRoot: true },
-	{ from: "extra/io/http.ts", to: "base/io/http.ts", toRoot: true },
-	{ from: "extra/io/index.ts", to: "base/io/index.ts", toRoot: true },
-	{ from: "extra/io/kafka.ts", to: "base/io/kafka.ts", toRoot: true },
-	{ from: "extra/io/kysely.ts", to: "base/io/kysely.ts", toRoot: true },
-	{ from: "extra/io/mcp.ts", to: "base/io/mcp.ts", toRoot: true },
-	{ from: "extra/io/nats.ts", to: "base/io/nats.ts", toRoot: true },
-	{ from: "extra/io/ndjson.ts", to: "base/io/ndjson.ts", toRoot: true },
-	{ from: "extra/io/otel.ts", to: "base/io/otel.ts", toRoot: true },
-	{ from: "extra/io/prisma.ts", to: "base/io/prisma.ts", toRoot: true },
-	{ from: "extra/io/prometheus.ts", to: "base/io/prometheus.ts", toRoot: true },
-	{ from: "extra/io/pulsar.ts", to: "base/io/pulsar.ts", toRoot: true },
-	{ from: "extra/io/rabbitmq.ts", to: "base/io/rabbitmq.ts", toRoot: true },
-	{ from: "extra/io/redis-stream.ts", to: "base/io/redis-stream.ts", toRoot: true },
-	{ from: "extra/io/sink.ts", to: "base/io/sink.ts", toRoot: true },
-	{ from: "extra/io/sqlite.ts", to: "base/io/sqlite.ts", toRoot: true },
-	{ from: "extra/io/sse.ts", to: "base/io/sse.ts", toRoot: true },
-	{ from: "extra/io/statsd.ts", to: "base/io/statsd.ts", toRoot: true },
-	{ from: "extra/io/syslog.ts", to: "base/io/syslog.ts", toRoot: true },
-	{ from: "extra/io/to-clickhouse.ts", to: "base/io/to-clickhouse.ts", toRoot: true },
-	{ from: "extra/io/to-csv.ts", to: "base/io/to-csv.ts", toRoot: true },
-	{ from: "extra/io/to-file.ts", to: "base/io/to-file.ts", toRoot: true },
-	{ from: "extra/io/to-loki.ts", to: "base/io/to-loki.ts", toRoot: true },
-	{ from: "extra/io/to-mongo.ts", to: "base/io/to-mongo.ts", toRoot: true },
-	{ from: "extra/io/to-postgres.ts", to: "base/io/to-postgres.ts", toRoot: true },
-	{ from: "extra/io/to-s3.ts", to: "base/io/to-s3.ts", toRoot: true },
-	{ from: "extra/io/to-tempo.ts", to: "base/io/to-tempo.ts", toRoot: true },
-	{ from: "extra/io/webhook.ts", to: "base/io/webhook.ts", toRoot: true },
-	{ from: "extra/io/websocket.ts", to: "base/io/websocket.ts", toRoot: true },
-	// reactive-sink → base/io/_sink.ts (Q15)
-	{ from: "extra/reactive-sink.ts", to: "base/io/_sink.ts", toRoot: true },
-
-	// -------------------------------------------------------------------------
-	// Presentation → base/composition/
-	// -------------------------------------------------------------------------
-	// Note: composite.ts is handled via SYMBOL_SPLITS (→ verifiable.ts + distill.ts)
-	{ from: "extra/composition/observable.ts", to: "base/composition/observable.ts", toRoot: true },
-	{ from: "extra/composition/materialize.ts", to: "base/composition/materialize.ts", toRoot: true },
-	{
-		from: "extra/composition/topology-diff.ts",
-		to: "base/composition/topology-diff.ts",
-		toRoot: true,
-	},
-	{ from: "extra/composition/pubsub.ts", to: "base/composition/pubsub.ts", toRoot: true },
-	{
-		from: "extra/composition/backpressure.ts",
-		to: "base/composition/backpressure.ts",
-		toRoot: true,
-	},
-	{
-		from: "extra/composition/external-register.ts",
-		to: "base/composition/external-register.ts",
-		toRoot: true,
-	},
-	{ from: "extra/single-from-any.ts", to: "base/composition/single-from-any.ts", toRoot: true },
-
-	// -------------------------------------------------------------------------
-	// Presentation → base/mutation/
-	// -------------------------------------------------------------------------
-	{ from: "extra/mutation/index.ts", to: "base/mutation/index.ts", toRoot: true },
-
-	// -------------------------------------------------------------------------
-	// Presentation → base/worker/
-	// -------------------------------------------------------------------------
-	{ from: "extra/worker/bridge.ts", to: "base/worker/bridge.ts", toRoot: true },
-	{ from: "extra/worker/index.ts", to: "base/worker/index.ts", toRoot: true },
-	{ from: "extra/worker/protocol.ts", to: "base/worker/protocol.ts", toRoot: true },
-	{ from: "extra/worker/self.ts", to: "base/worker/self.ts", toRoot: true },
-	{ from: "extra/worker/transport.ts", to: "base/worker/transport.ts", toRoot: true },
-
-	// -------------------------------------------------------------------------
-	// Presentation → base/render/ (13 files)
-	// -------------------------------------------------------------------------
-	{ from: "extra/render/_ascii-grid.ts", to: "base/render/_ascii-grid.ts", toRoot: true },
-	{ from: "extra/render/_ascii-width.ts", to: "base/render/_ascii-width.ts", toRoot: true },
-	{ from: "extra/render/_internal.ts", to: "base/render/_internal.ts", toRoot: true },
-	{ from: "extra/render/_layout-sugiyama.ts", to: "base/render/_layout-sugiyama.ts", toRoot: true },
-	{
-		from: "extra/render/graph-spec-to-ascii.ts",
-		to: "base/render/graph-spec-to-ascii.ts",
-		toRoot: true,
-	},
-	{ from: "extra/render/graph-spec-to-d2.ts", to: "base/render/graph-spec-to-d2.ts", toRoot: true },
-	{
-		from: "extra/render/graph-spec-to-json.ts",
-		to: "base/render/graph-spec-to-json.ts",
-		toRoot: true,
-	},
-	{
-		from: "extra/render/graph-spec-to-mermaid-url.ts",
-		to: "base/render/graph-spec-to-mermaid-url.ts",
-		toRoot: true,
-	},
-	{
-		from: "extra/render/graph-spec-to-mermaid.ts",
-		to: "base/render/graph-spec-to-mermaid.ts",
-		toRoot: true,
-	},
-	{
-		from: "extra/render/graph-spec-to-pretty.ts",
-		to: "base/render/graph-spec-to-pretty.ts",
-		toRoot: true,
-	},
-	{ from: "extra/render/index.ts", to: "base/render/index.ts", toRoot: true },
-	{
-		from: "extra/render/layout-frame-to-svg.ts",
-		to: "base/render/layout-frame-to-svg.ts",
-		toRoot: true,
-	},
-	{ from: "extra/render/layout-types.ts", to: "base/render/layout-types.ts", toRoot: true },
-
-	// -------------------------------------------------------------------------
-	// Presentation → base/meta/
-	// -------------------------------------------------------------------------
-	{ from: "extra/meta.ts", to: "base/meta/domain-meta.ts", toRoot: true },
-	// patterns/_internal/index.ts → split: emitToMeta + trackingKey (handled in SYMBOL_SPLITS)
-
-	// -------------------------------------------------------------------------
-	// Presentation → base/sources/ (settled, async, event splits)
-	// -------------------------------------------------------------------------
-	// settled.ts → base/sources/settled.ts (all except keepalive) + base/meta/keepalive.ts
-	// Note: handled via SYMBOL_SPLITS below
-	{ from: "extra/sources/async.ts", to: "base/sources/async.ts", toRoot: true },
-	// event.ts → split handled in SYMBOL_SPLITS
-
-	// -------------------------------------------------------------------------
-	// Presentation → base/sources/node/ (Q9)
-	// -------------------------------------------------------------------------
-	{ from: "extra/sources/fs.ts", to: "base/sources/node/fs.ts", toRoot: true },
-	{ from: "extra/sources/git.ts", to: "base/sources/node/git.ts", toRoot: true },
-	{ from: "extra/sources-fs.ts", to: "base/sources/node/fs-root.ts", toRoot: true },
-	{ from: "extra/sources-process.ts", to: "base/sources/node/process.ts", toRoot: true },
-	{ from: "extra/git-hook.ts", to: "base/sources/node/git-hook.ts", toRoot: true },
-
-	// -------------------------------------------------------------------------
-	// Presentation → base/sources/browser/ (Q23)
-	// -------------------------------------------------------------------------
-	{ from: "extra/storage-browser.ts", to: "base/sources/browser/idb.ts", toRoot: true },
-
-	// -------------------------------------------------------------------------
-	// Presentation → base/utils/
-	// -------------------------------------------------------------------------
-	{ from: "extra/utils/decay.ts", to: "base/utils/decay.ts", toRoot: true },
-
-	// -------------------------------------------------------------------------
-	// Presentation → base/composition (audited-success-tracker from extra/composition/)
-	// -------------------------------------------------------------------------
-	{
-		from: "extra/composition/audited-success-tracker.ts",
-		to: "utils/orchestration/audited-success-tracker.ts",
-		toRoot: true,
-	},
-
-	// -------------------------------------------------------------------------
-	// Presentation → utils/messaging/
-	// -------------------------------------------------------------------------
-	{
-		from: "patterns/messaging/audit-records.ts",
-		to: "utils/messaging/audit-records.ts",
-		toRoot: true,
-	},
-	{ from: "patterns/messaging/index.ts", to: "utils/messaging/index.ts", toRoot: true },
-	{ from: "patterns/messaging/message.ts", to: "utils/messaging/message.ts", toRoot: true },
-
-	// -------------------------------------------------------------------------
-	// Presentation → utils/orchestration/
-	// -------------------------------------------------------------------------
-	{
-		from: "patterns/orchestration/human-input.ts",
-		to: "utils/orchestration/human-input.ts",
-		toRoot: true,
-	},
-	{ from: "patterns/orchestration/index.ts", to: "utils/orchestration/index.ts", toRoot: true },
-	{
-		from: "patterns/orchestration/pipeline-graph.ts",
-		to: "utils/orchestration/pipeline-graph.ts",
-		toRoot: true,
-	},
-	{ from: "patterns/orchestration/tracker.ts", to: "utils/orchestration/tracker.ts", toRoot: true },
-
-	// -------------------------------------------------------------------------
-	// Presentation → utils/cqrs/
-	// -------------------------------------------------------------------------
-	{ from: "patterns/cqrs/index.ts", to: "utils/cqrs/index.ts", toRoot: true },
-
-	// -------------------------------------------------------------------------
-	// Presentation → utils/memory/
-	// -------------------------------------------------------------------------
-	{ from: "patterns/memory/index.ts", to: "utils/memory/index.ts", toRoot: true },
-
-	// -------------------------------------------------------------------------
-	// Presentation → utils/reduction/
-	// -------------------------------------------------------------------------
-	{ from: "patterns/reduction/index.ts", to: "utils/reduction/index.ts", toRoot: true },
-
-	// -------------------------------------------------------------------------
-	// Presentation → utils/inspect/
-	// -------------------------------------------------------------------------
-	{ from: "patterns/inspect/audit.ts", to: "utils/inspect/audit.ts", toRoot: true },
-	{ from: "patterns/inspect/lens.ts", to: "utils/inspect/lens.ts", toRoot: true },
-	{ from: "patterns/inspect/index.ts", to: "utils/inspect/index.ts", toRoot: true },
-
-	// -------------------------------------------------------------------------
-	// Presentation → utils/process/
-	// -------------------------------------------------------------------------
-	{ from: "patterns/process/index.ts", to: "utils/process/index.ts", toRoot: true },
-
-	// -------------------------------------------------------------------------
-	// Presentation → utils/job-queue/
-	// -------------------------------------------------------------------------
-	{ from: "patterns/job-queue/index.ts", to: "utils/job-queue/index.ts", toRoot: true },
-
-	// -------------------------------------------------------------------------
-	// Presentation → utils/surface/
-	// -------------------------------------------------------------------------
-	{ from: "patterns/surface/create.ts", to: "utils/surface/create.ts", toRoot: true },
-	{ from: "patterns/surface/errors.ts", to: "utils/surface/errors.ts", toRoot: true },
-	{ from: "patterns/surface/index.ts", to: "utils/surface/index.ts", toRoot: true },
-	{ from: "patterns/surface/reduce.ts", to: "utils/surface/reduce.ts", toRoot: true },
-	{ from: "patterns/surface/snapshot.ts", to: "utils/surface/snapshot.ts", toRoot: true },
-
-	// -------------------------------------------------------------------------
-	// Presentation → utils/topology-view/
-	// -------------------------------------------------------------------------
-	{
-		from: "patterns/topology-view/_internal.ts",
-		to: "utils/topology-view/_internal.ts",
-		toRoot: true,
-	},
-	{ from: "patterns/topology-view/index.ts", to: "utils/topology-view/index.ts", toRoot: true },
-	{ from: "patterns/topology-view/types.ts", to: "utils/topology-view/types.ts", toRoot: true },
-
-	// -------------------------------------------------------------------------
-	// Presentation → utils/reactive-layout/
-	// -------------------------------------------------------------------------
-	{ from: "patterns/reactive-layout/index.ts", to: "utils/reactive-layout/index.ts", toRoot: true },
-	{
-		from: "patterns/reactive-layout/measurement-adapters.ts",
-		to: "utils/reactive-layout/measurement-adapters.ts",
-		toRoot: true,
-	},
-	{
-		from: "patterns/reactive-layout/reactive-block-layout.ts",
-		to: "utils/reactive-layout/reactive-block-layout.ts",
-		toRoot: true,
-	},
-	{
-		from: "patterns/reactive-layout/reactive-flow-layout.ts",
-		to: "utils/reactive-layout/reactive-flow-layout.ts",
-		toRoot: true,
-	},
-	{
-		from: "patterns/reactive-layout/reactive-layout.ts",
-		to: "utils/reactive-layout/reactive-layout.ts",
-		toRoot: true,
-	},
-
-	// -------------------------------------------------------------------------
-	// Presentation → utils/graphspec/
-	// -------------------------------------------------------------------------
-	{ from: "patterns/graphspec/index.ts", to: "utils/graphspec/index.ts", toRoot: true },
-
-	// -------------------------------------------------------------------------
-	// Presentation → utils/demo-shell/
-	// -------------------------------------------------------------------------
-	{ from: "patterns/demo-shell/index.ts", to: "utils/demo-shell/index.ts", toRoot: true },
-
-	// -------------------------------------------------------------------------
-	// Presentation → utils/domain-templates/
-	// -------------------------------------------------------------------------
-	{
-		from: "patterns/domain-templates/index.ts",
-		to: "utils/domain-templates/index.ts",
-		toRoot: true,
-	},
-
-	// -------------------------------------------------------------------------
-	// Presentation → utils/ai/
-	// -------------------------------------------------------------------------
-	{ from: "patterns/ai/_internal.ts", to: "utils/ai/_internal.ts", toRoot: true },
-	{ from: "patterns/ai/index.ts", to: "utils/ai/index.ts", toRoot: true },
-	{ from: "patterns/ai/node.ts", to: "utils/ai/node.ts", toRoot: true },
-	{ from: "patterns/ai/browser.ts", to: "utils/ai/browser.ts", toRoot: true },
-	// ai/adapters subtree
-	{
-		from: "patterns/ai/adapters/_internal/content-addressed-cache.ts",
-		to: "utils/ai/adapters/_internal/content-addressed-cache.ts",
-		toRoot: true,
-	},
-	{
-		from: "patterns/ai/adapters/_internal/wrappers.ts",
-		to: "utils/ai/adapters/_internal/wrappers.ts",
-		toRoot: true,
-	},
-	{
-		from: "patterns/ai/adapters/core/capabilities.ts",
-		to: "utils/ai/adapters/core/capabilities.ts",
-		toRoot: true,
-	},
-	{
-		from: "patterns/ai/adapters/core/factory.ts",
-		to: "utils/ai/adapters/core/factory.ts",
-		toRoot: true,
-	},
-	{
-		from: "patterns/ai/adapters/core/index.ts",
-		to: "utils/ai/adapters/core/index.ts",
-		toRoot: true,
-	},
-	{
-		from: "patterns/ai/adapters/core/observable.ts",
-		to: "utils/ai/adapters/core/observable.ts",
-		toRoot: true,
-	},
-	{
-		from: "patterns/ai/adapters/core/pricing.ts",
-		to: "utils/ai/adapters/core/pricing.ts",
-		toRoot: true,
-	},
-	{
-		from: "patterns/ai/adapters/core/types.ts",
-		to: "utils/ai/adapters/core/types.ts",
-		toRoot: true,
-	},
-	{ from: "patterns/ai/adapters/index.ts", to: "utils/ai/adapters/index.ts", toRoot: true },
-	{
-		from: "patterns/ai/adapters/middleware/breaker.ts",
-		to: "utils/ai/adapters/middleware/breaker.ts",
-		toRoot: true,
-	},
-	{
-		from: "patterns/ai/adapters/middleware/budget-gate.ts",
-		to: "utils/ai/adapters/middleware/budget-gate.ts",
-		toRoot: true,
-	},
-	{
-		from: "patterns/ai/adapters/middleware/dry-run.ts",
-		to: "utils/ai/adapters/middleware/dry-run.ts",
-		toRoot: true,
-	},
-	{
-		from: "patterns/ai/adapters/middleware/http429-parser.ts",
-		to: "utils/ai/adapters/middleware/http429-parser.ts",
-		toRoot: true,
-	},
-	{
-		from: "patterns/ai/adapters/middleware/index.ts",
-		to: "utils/ai/adapters/middleware/index.ts",
-		toRoot: true,
-	},
-	{
-		from: "patterns/ai/adapters/middleware/rate-limiter.ts",
-		to: "utils/ai/adapters/middleware/rate-limiter.ts",
-		toRoot: true,
-	},
-	{
-		from: "patterns/ai/adapters/middleware/replay-cache.ts",
-		to: "utils/ai/adapters/middleware/replay-cache.ts",
-		toRoot: true,
-	},
-	{
-		from: "patterns/ai/adapters/middleware/resilient-adapter.ts",
-		to: "utils/ai/adapters/middleware/resilient-adapter.ts",
-		toRoot: true,
-	},
-	{
-		from: "patterns/ai/adapters/middleware/retry.ts",
-		to: "utils/ai/adapters/middleware/retry.ts",
-		toRoot: true,
-	},
-	{
-		from: "patterns/ai/adapters/middleware/timeout.ts",
-		to: "utils/ai/adapters/middleware/timeout.ts",
-		toRoot: true,
-	},
-	{
-		from: "patterns/ai/adapters/providers/anthropic.ts",
-		to: "utils/ai/adapters/providers/anthropic.ts",
-		toRoot: true,
-	},
-	{
-		from: "patterns/ai/adapters/providers/browser/chrome-nano.ts",
-		to: "utils/ai/adapters/providers/browser/chrome-nano.ts",
-		toRoot: true,
-	},
-	{
-		from: "patterns/ai/adapters/providers/browser/index.ts",
-		to: "utils/ai/adapters/providers/browser/index.ts",
-		toRoot: true,
-	},
-	{
-		from: "patterns/ai/adapters/providers/browser/webllm.ts",
-		to: "utils/ai/adapters/providers/browser/webllm.ts",
-		toRoot: true,
-	},
-	{
-		from: "patterns/ai/adapters/providers/dry-run.ts",
-		to: "utils/ai/adapters/providers/dry-run.ts",
-		toRoot: true,
-	},
-	{
-		from: "patterns/ai/adapters/providers/fallback-node.ts",
-		to: "utils/ai/adapters/providers/fallback-node.ts",
-		toRoot: true,
-	},
-	{
-		from: "patterns/ai/adapters/providers/fallback.ts",
-		to: "utils/ai/adapters/providers/fallback.ts",
-		toRoot: true,
-	},
-	{
-		from: "patterns/ai/adapters/providers/google.ts",
-		to: "utils/ai/adapters/providers/google.ts",
-		toRoot: true,
-	},
-	{
-		from: "patterns/ai/adapters/providers/index.ts",
-		to: "utils/ai/adapters/providers/index.ts",
-		toRoot: true,
-	},
-	{
-		from: "patterns/ai/adapters/providers/openai-compat.ts",
-		to: "utils/ai/adapters/providers/openai-compat.ts",
-		toRoot: true,
-	},
-	{
-		from: "patterns/ai/adapters/routing/browser-presets.ts",
-		to: "utils/ai/adapters/routing/browser-presets.ts",
-		toRoot: true,
-	},
-	{
-		from: "patterns/ai/adapters/routing/cascading.ts",
-		to: "utils/ai/adapters/routing/cascading.ts",
-		toRoot: true,
-	},
-	{
-		from: "patterns/ai/adapters/routing/index.ts",
-		to: "utils/ai/adapters/routing/index.ts",
-		toRoot: true,
-	},
-	// ai/agents subtree (agents/presets.ts → presets/ai/agents.ts)
-	{ from: "patterns/ai/agents/agent.ts", to: "utils/ai/agents/agent.ts", toRoot: true },
-	{ from: "patterns/ai/agents/chat-stream.ts", to: "utils/ai/agents/chat-stream.ts", toRoot: true },
-	{ from: "patterns/ai/agents/handoff.ts", to: "utils/ai/agents/handoff.ts", toRoot: true },
-	{
-		from: "patterns/ai/agents/tool-execution.ts",
-		to: "utils/ai/agents/tool-execution.ts",
-		toRoot: true,
-	},
-	{
-		from: "patterns/ai/agents/tool-registry.ts",
-		to: "utils/ai/agents/tool-registry.ts",
-		toRoot: true,
-	},
-	{
-		from: "patterns/ai/agents/tool-selector.ts",
-		to: "utils/ai/agents/tool-selector.ts",
-		toRoot: true,
-	},
-	// agents/presets.ts → presets/ (handled separately)
-	{
-		from: "patterns/ai/extractors/cost-meter.ts",
-		to: "utils/ai/extractors/cost-meter.ts",
-		toRoot: true,
-	},
-	{
-		from: "patterns/ai/extractors/keyword-flag.ts",
-		to: "utils/ai/extractors/keyword-flag.ts",
-		toRoot: true,
-	},
-	{
-		from: "patterns/ai/extractors/stream-extractor.ts",
-		to: "utils/ai/extractors/stream-extractor.ts",
-		toRoot: true,
-	},
-	{
-		from: "patterns/ai/extractors/tool-call.ts",
-		to: "utils/ai/extractors/tool-call.ts",
-		toRoot: true,
-	},
-	{
-		from: "patterns/ai/graph-integration/gauges-as-context.ts",
-		to: "utils/ai/graph-integration/gauges-as-context.ts",
-		toRoot: true,
-	},
-	{
-		from: "patterns/ai/graph-integration/graph-from-spec.ts",
-		to: "utils/ai/graph-integration/graph-from-spec.ts",
-		toRoot: true,
-	},
-	{
-		from: "patterns/ai/graph-integration/knobs-as-tools.ts",
-		to: "utils/ai/graph-integration/knobs-as-tools.ts",
-		toRoot: true,
-	},
-	{
-		from: "patterns/ai/graph-integration/suggest-strategy.ts",
-		to: "utils/ai/graph-integration/suggest-strategy.ts",
-		toRoot: true,
-	},
-	{
-		from: "patterns/ai/graph-integration/validate-graph-def.ts",
-		to: "utils/ai/graph-integration/validate-graph-def.ts",
-		toRoot: true,
-	},
-	{ from: "patterns/ai/memory/admission.ts", to: "utils/ai/memory/admission.ts", toRoot: true },
-	{
-		from: "patterns/ai/memory/memory-composers.ts",
-		to: "utils/ai/memory/memory-composers.ts",
-		toRoot: true,
-	},
-	{ from: "patterns/ai/memory/retrieval.ts", to: "utils/ai/memory/retrieval.ts", toRoot: true },
-	{ from: "patterns/ai/memory/tiers.ts", to: "utils/ai/memory/tiers.ts", toRoot: true },
-	{
-		from: "patterns/ai/prompts/frozen-context.ts",
-		to: "utils/ai/prompts/frozen-context.ts",
-		toRoot: true,
-	},
-	{
-		from: "patterns/ai/prompts/prompt-call.ts",
-		to: "utils/ai/prompts/prompt-call.ts",
-		toRoot: true,
-	},
-	{
-		from: "patterns/ai/prompts/prompt-node.ts",
-		to: "utils/ai/prompts/prompt-node.ts",
-		toRoot: true,
-	},
-	{ from: "patterns/ai/prompts/streaming.ts", to: "utils/ai/prompts/streaming.ts", toRoot: true },
-	{
-		from: "patterns/ai/prompts/system-prompt.ts",
-		to: "utils/ai/prompts/system-prompt.ts",
-		toRoot: true,
-	},
-	{
-		from: "patterns/ai/safety/content-gate.ts",
-		to: "utils/ai/safety/content-gate.ts",
-		toRoot: true,
-	},
-	{ from: "patterns/ai/safety/redactor.ts", to: "utils/ai/safety/redactor.ts", toRoot: true },
-
-	// -------------------------------------------------------------------------
-	// Presentation → utils/harness/
-	// -------------------------------------------------------------------------
-	{
-		from: "patterns/harness/actuator-executor.ts",
-		to: "utils/harness/actuator-executor.ts",
-		toRoot: true,
-	},
-	{ from: "patterns/harness/auto-solidify.ts", to: "utils/harness/auto-solidify.ts", toRoot: true },
-	{ from: "patterns/harness/bridge.ts", to: "utils/harness/bridge.ts", toRoot: true },
-	{ from: "patterns/harness/defaults.ts", to: "utils/harness/defaults.ts", toRoot: true },
-	{ from: "patterns/harness/eval-verifier.ts", to: "utils/harness/eval-verifier.ts", toRoot: true },
-	{ from: "patterns/harness/index.ts", to: "utils/harness/index.ts", toRoot: true },
-	{ from: "patterns/harness/profile.ts", to: "utils/harness/profile.ts", toRoot: true },
-	{
-		from: "patterns/harness/refine-executor.ts",
-		to: "utils/harness/refine-executor.ts",
-		toRoot: true,
-	},
-	{ from: "patterns/harness/strategy.ts", to: "utils/harness/strategy.ts", toRoot: true },
-	{ from: "patterns/harness/trace.ts", to: "utils/harness/trace.ts", toRoot: true },
-	{ from: "patterns/harness/types.ts", to: "utils/harness/types.ts", toRoot: true },
-
-	// -------------------------------------------------------------------------
-	// Presentation → utils/resilience/ (all except resilient-pipeline)
-	// -------------------------------------------------------------------------
-	{ from: "extra/resilience/_internal.ts", to: "utils/resilience/_internal.ts", toRoot: true },
-	{ from: "extra/resilience/backoff.ts", to: "utils/resilience/backoff.ts", toRoot: true },
-	{ from: "extra/resilience/breaker.ts", to: "utils/resilience/breaker.ts", toRoot: true },
-	{ from: "extra/resilience/budget-gate.ts", to: "utils/resilience/budget-gate.ts", toRoot: true },
-	{ from: "extra/resilience/fallback.ts", to: "utils/resilience/fallback.ts", toRoot: true },
-	{ from: "extra/resilience/gate-state.ts", to: "utils/resilience/gate-state.ts", toRoot: true },
-	{ from: "extra/resilience/index.ts", to: "utils/resilience/index.ts", toRoot: true },
-	{
-		from: "extra/resilience/rate-limiter.ts",
-		to: "utils/resilience/rate-limiter.ts",
-		toRoot: true,
-	},
-	{ from: "extra/resilience/retry.ts", to: "utils/resilience/retry.ts", toRoot: true },
-	{ from: "extra/resilience/status.ts", to: "utils/resilience/status.ts", toRoot: true },
-	{ from: "extra/resilience/timeout.ts", to: "utils/resilience/timeout.ts", toRoot: true },
-	{
-		from: "extra/adaptive-rate-limiter.ts",
-		to: "utils/resilience/adaptive-rate-limiter.ts",
-		toRoot: true,
-	},
-
-	// -------------------------------------------------------------------------
-	// Presentation → utils/_errors/
-	// -------------------------------------------------------------------------
-	{ from: "patterns/_internal/errors.ts", to: "utils/_errors/index.ts", toRoot: true },
-
-	// -------------------------------------------------------------------------
-	// Presentation → presets/ai/
-	// -------------------------------------------------------------------------
-	{ from: "patterns/ai/presets/agent-loop.ts", to: "presets/ai/agent-loop.ts", toRoot: true },
-	{ from: "patterns/ai/presets/agent-memory.ts", to: "presets/ai/agent-memory.ts", toRoot: true },
-	{ from: "patterns/ai/agents/presets.ts", to: "presets/ai/agents.ts", toRoot: true },
-
-	// -------------------------------------------------------------------------
-	// Presentation → presets/harness/
-	// -------------------------------------------------------------------------
-	{
-		from: "patterns/harness/presets/harness-loop.ts",
-		to: "presets/harness/harness-loop.ts",
-		toRoot: true,
-	},
-	{
-		from: "patterns/harness/presets/refine-loop.ts",
-		to: "presets/harness/refine-loop.ts",
-		toRoot: true,
-	},
-	{
-		from: "patterns/harness/presets/spawnable.ts",
-		to: "presets/harness/spawnable.ts",
-		toRoot: true,
-	},
-
-	// -------------------------------------------------------------------------
-	// Presentation → presets/inspect/
-	// -------------------------------------------------------------------------
-	{
-		from: "patterns/inspect/guarded-execution.ts",
-		to: "presets/inspect/guarded-execution.ts",
-		toRoot: true,
-	},
-	{ from: "patterns/inspect/presets/inspect.ts", to: "presets/inspect/composite.ts", toRoot: true },
-
-	// -------------------------------------------------------------------------
-	// Presentation → presets/resilience/
-	// -------------------------------------------------------------------------
-	{
-		from: "extra/resilience/resilient-pipeline.ts",
-		to: "presets/resilience/resilient-pipeline.ts",
-		toRoot: true,
-	},
-
-	// -------------------------------------------------------------------------
-	// Presentation → compat/ (path unchanged, just moves to root src/)
-	// -------------------------------------------------------------------------
-	{ from: "compat/index.ts", to: "compat/index.ts", toRoot: true },
-	{ from: "compat/jotai/index.ts", to: "compat/jotai/index.ts", toRoot: true },
-	{ from: "compat/nanostores/index.ts", to: "compat/nanostores/index.ts", toRoot: true },
-	{ from: "compat/nestjs/decorators.ts", to: "compat/nestjs/decorators.ts", toRoot: true },
-	{ from: "compat/nestjs/explorer.ts", to: "compat/nestjs/explorer.ts", toRoot: true },
-	{ from: "compat/nestjs/gateway.ts", to: "compat/nestjs/gateway.ts", toRoot: true },
-	{ from: "compat/nestjs/guard.ts", to: "compat/nestjs/guard.ts", toRoot: true },
-	{ from: "compat/nestjs/index.ts", to: "compat/nestjs/index.ts", toRoot: true },
-	{ from: "compat/nestjs/module.ts", to: "compat/nestjs/module.ts", toRoot: true },
-	{ from: "compat/nestjs/tokens.ts", to: "compat/nestjs/tokens.ts", toRoot: true },
-	{ from: "compat/react/index.ts", to: "compat/react/index.ts", toRoot: true },
-	{ from: "compat/signals/index.ts", to: "compat/signals/index.ts", toRoot: true },
-	{ from: "compat/solid/index.ts", to: "compat/solid/index.ts", toRoot: true },
-	{ from: "compat/svelte/index.ts", to: "compat/svelte/index.ts", toRoot: true },
-	{ from: "compat/vue/index.ts", to: "compat/vue/index.ts", toRoot: true },
-	{ from: "compat/zustand/index.ts", to: "compat/zustand/index.ts", toRoot: true },
-];
-
-// ---------------------------------------------------------------------------
-// SYMBOL SPLITS
-// ---------------------------------------------------------------------------
-
-// ---------------------------------------------------------------------------
-// DELETIONS (25 backward-compat shims; extra/storage.ts absent from disk)
-// ---------------------------------------------------------------------------
-const DELETE_FILES: string[] = [
-	"extra/adapters.ts",
-	"extra/backoff.ts",
-	"extra/backpressure.ts",
-	"extra/cascading-cache.ts",
-	"extra/composite.ts",
-	"extra/content-addressed-storage.ts",
-	"extra/external-register.ts",
-	"extra/http-error.ts",
-	"extra/observable.ts",
-	"extra/operators.ts",
-	"extra/pubsub.ts",
-	"extra/reactive-index.ts",
-	"extra/reactive-list.ts",
-	"extra/reactive-log.ts",
-	"extra/reactive-map.ts",
-	"extra/reactive.ts",
-	"extra/resilience.ts",
-	"extra/sources.ts",
-	// "extra/storage.ts", // ABSENT from disk — skip
-	"extra/storage-core.ts",
-	"extra/storage-node.ts",
-	"extra/storage-tiers.ts",
-	"extra/storage-tiers-node.ts",
-	"extra/storage-tiers-browser.ts",
-	"extra/storage-wal.ts",
-	"extra/stratify.ts",
-];
-
-// ---------------------------------------------------------------------------
-// TEST MOVES TABLE (Option B: presentation tests → root src/__tests__/)
-// ---------------------------------------------------------------------------
-// Each entry: [oldRelpath, newRelpath] relative to PURE_TS_TESTS / ROOT_TESTS
-// Substrate tests stay in pure-ts; presentation tests move to root.
-
-type TestMove = {
-	from: string; // relative to PURE_TS_TESTS
-	to: string; // relative to ROOT_TESTS
-};
-
-const TEST_MOVES: TestMove[] = [
-	// compat/* → compat/*
-	{ from: "compat/jotai.test.ts", to: "compat/jotai.test.ts" },
-	{ from: "compat/nanostores.test.ts", to: "compat/nanostores.test.ts" },
-	{ from: "compat/nestjs.test.ts", to: "compat/nestjs.test.ts" },
-	{ from: "compat/react.test.ts", to: "compat/react.test.ts" },
-	{ from: "compat/signals-autotrack.test.ts", to: "compat/signals-autotrack.test.ts" },
-	{ from: "compat/signals.test.ts", to: "compat/signals.test.ts" },
-	{ from: "compat/solid.test.ts", to: "compat/solid.test.ts" },
-	{ from: "compat/svelte.test.ts", to: "compat/svelte.test.ts" },
-	{ from: "compat/vue.test.ts", to: "compat/vue.test.ts" },
-	{ from: "compat/zustand.test.ts", to: "compat/zustand.test.ts" },
-
-	// patterns/* → mirror
-	{ from: "patterns/actuator-executor.test.ts", to: "utils/harness/actuator-executor.test.ts" },
-	{ from: "patterns/ai.test.ts", to: "utils/ai/ai.test.ts" },
-	{
-		from: "patterns/ai/adapters/abort-propagation.test.ts",
-		to: "utils/ai/adapters/abort-propagation.test.ts",
-	},
-	{
-		from: "patterns/ai/adapters/adaptive-rate-limiter.test.ts",
-		to: "utils/ai/adapters/adaptive-rate-limiter.test.ts",
-	},
-	{
-		from: "patterns/ai/adapters/anthropic-mapping.test.ts",
-		to: "utils/ai/adapters/anthropic-mapping.test.ts",
-	},
-	{
-		from: "patterns/ai/adapters/capabilities.test.ts",
-		to: "utils/ai/adapters/capabilities.test.ts",
-	},
-	{ from: "patterns/ai/adapters/cascading.test.ts", to: "utils/ai/adapters/cascading.test.ts" },
-	{ from: "patterns/ai/adapters/dry-run.test.ts", to: "utils/ai/adapters/dry-run.test.ts" },
-	{ from: "patterns/ai/adapters/fallback.test.ts", to: "utils/ai/adapters/fallback.test.ts" },
-	{
-		from: "patterns/ai/adapters/google-mapping.test.ts",
-		to: "utils/ai/adapters/google-mapping.test.ts",
-	},
-	{
-		from: "patterns/ai/adapters/http429-parser.test.ts",
-		to: "utils/ai/adapters/http429-parser.test.ts",
-	},
-	{ from: "patterns/ai/adapters/middleware.test.ts", to: "utils/ai/adapters/middleware.test.ts" },
-	{ from: "patterns/ai/adapters/observable.test.ts", to: "utils/ai/adapters/observable.test.ts" },
-	{
-		from: "patterns/ai/adapters/openai-compat-mapping.test.ts",
-		to: "utils/ai/adapters/openai-compat-mapping.test.ts",
-	},
-	{ from: "patterns/ai/adapters/pricing.test.ts", to: "utils/ai/adapters/pricing.test.ts" },
-	{
-		from: "patterns/ai/adapters/qa-regressions.test.ts",
-		to: "utils/ai/adapters/qa-regressions.test.ts",
-	},
-	{
-		from: "patterns/ai/adapters/resilient-adapter.test.ts",
-		to: "utils/ai/adapters/resilient-adapter.test.ts",
-	},
-	{ from: "patterns/ai/adapters/types.test.ts", to: "utils/ai/adapters/types.test.ts" },
-	{ from: "patterns/ai/agents/agent.test.ts", to: "utils/ai/agents/agent.test.ts" },
-	{
-		from: "patterns/ai/agents/multi-agent-example.test.ts",
-		to: "utils/ai/agents/multi-agent-example.test.ts",
-	},
-	{
-		from: "patterns/ai/agents/tool-execution.test.ts",
-		to: "utils/ai/agents/tool-execution.test.ts",
-	},
-	{ from: "patterns/audit.test.ts", to: "utils/inspect/audit.test.ts" },
-	{ from: "patterns/auto-solidify.test.ts", to: "utils/harness/auto-solidify.test.ts" },
-	{ from: "patterns/cqrs.test.ts", to: "utils/cqrs/cqrs.test.ts" },
-	{ from: "patterns/demo-shell.test.ts", to: "utils/demo-shell/demo-shell.test.ts" },
-	{
-		from: "patterns/domain-templates.test.ts",
-		to: "utils/domain-templates/domain-templates.test.ts",
-	},
-	{ from: "patterns/graphspec.test.ts", to: "utils/graphspec/graphspec.test.ts" },
-	{ from: "patterns/guarded-execution.test.ts", to: "presets/inspect/guarded-execution.test.ts" },
-	{
-		from: "patterns/harness-default-bridges.test.ts",
-		to: "utils/harness/harness-default-bridges.test.ts",
-	},
-	{ from: "patterns/harness.test.ts", to: "utils/harness/harness.test.ts" },
-	{ from: "patterns/harness/spawnable.test.ts", to: "presets/harness/spawnable.test.ts" },
-	{ from: "patterns/inspect-preset.test.ts", to: "presets/inspect/inspect-preset.test.ts" },
-	{ from: "patterns/lens.test.ts", to: "utils/inspect/lens.test.ts" },
-	{ from: "patterns/memory.test.ts", to: "utils/memory/memory.test.ts" },
-	{ from: "patterns/messaging.test.ts", to: "utils/messaging/messaging.test.ts" },
-	{ from: "patterns/orchestration.test.ts", to: "utils/orchestration/orchestration.test.ts" },
-	{
-		from: "patterns/orchestration/human-input-tracker.test.ts",
-		to: "utils/orchestration/human-input-tracker.test.ts",
-	},
-	{ from: "patterns/process.test.ts", to: "utils/process/process.test.ts" },
-	{
-		from: "patterns/reactive-layout/measurement-adapters.test.ts",
-		to: "utils/reactive-layout/measurement-adapters.test.ts",
-	},
-	{
-		from: "patterns/reactive-layout/reactive-block-layout.test.ts",
-		to: "utils/reactive-layout/reactive-block-layout.test.ts",
-	},
-	{
-		from: "patterns/reactive-layout/reactive-flow-layout.test.ts",
-		to: "utils/reactive-layout/reactive-flow-layout.test.ts",
-	},
-	{
-		from: "patterns/reactive-layout/reactive-layout.test.ts",
-		to: "utils/reactive-layout/reactive-layout.test.ts",
-	},
-	{ from: "patterns/reduction.test.ts", to: "utils/reduction/reduction.test.ts" },
-	{ from: "patterns/refine-executor.test.ts", to: "utils/harness/refine-executor.test.ts" },
-	{ from: "patterns/refine-loop.test.ts", to: "presets/harness/refine-loop.test.ts" },
-	{
-		from: "patterns/resilient-pipeline.test.ts",
-		to: "presets/resilience/resilient-pipeline.test.ts",
-	},
-	{ from: "patterns/surface/surface.test.ts", to: "utils/surface/surface.test.ts" },
-	{ from: "patterns/topology-view.test.ts", to: "utils/topology-view/topology-view.test.ts" },
-
-	// extra presentation tests → base/ or utils/
-	{ from: "extra/adapters.ingest.test.ts", to: "utils/ai/adapters/adapters.ingest.test.ts" },
-	{ from: "extra/adapters.storage.test.ts", to: "utils/ai/adapters/adapters.storage.test.ts" },
-	{ from: "extra/backpressure.test.ts", to: "base/composition/backpressure.test.ts" },
-	{ from: "extra/cascading-cache.test.ts", to: "utils/ai/adapters/cascading-cache.test.ts" },
-	{ from: "extra/composite.test.ts", to: "base/composition/composite.test.ts" },
-	{ from: "extra/external-register.test.ts", to: "base/composition/external-register.test.ts" },
-	{ from: "extra/materialize.test.ts", to: "base/composition/materialize.test.ts" },
-	{ from: "extra/mutation/mutation.test.ts", to: "base/mutation/mutation.test.ts" },
-	{ from: "extra/pubsub-stress.test.ts", to: "base/composition/pubsub-stress.test.ts" },
-	{ from: "extra/reactive-sink.test.ts", to: "base/io/reactive-sink.test.ts" },
-	{ from: "extra/resilience.test.ts", to: "utils/resilience/resilience.test.ts" },
-	{ from: "extra/single-from-any.test.ts", to: "base/composition/single-from-any.test.ts" },
-	{ from: "extra/sources-process.test.ts", to: "base/sources/node/sources-process.test.ts" },
-	{ from: "extra/sources.http.test.ts", to: "base/io/sources.http.test.ts" },
-	{ from: "extra/sources.test.ts", to: "base/sources/sources.test.ts" },
-	{
-		from: "extra/token-bucket-putback.test.ts",
-		to: "utils/resilience/token-bucket-putback.test.ts",
-	},
-	{ from: "extra/worker.test.ts", to: "base/worker/worker.test.ts" },
-
-	// graphspec tests → utils/graphspec/
-	{
-		from: "graphspec/factory-tags-audit.test.ts",
-		to: "utils/graphspec/factory-tags-audit.test.ts",
-	},
-	{
-		from: "graphspec/factory-tags-bundles.test.ts",
-		to: "utils/graphspec/factory-tags-bundles.test.ts",
-	},
-	{
-		from: "graphspec/factory-tags-memory-harness.test.ts",
-		to: "utils/graphspec/factory-tags-memory-harness.test.ts",
-	},
-	{
-		from: "graphspec/factory-tags-orchestration.test.ts",
-		to: "utils/graphspec/factory-tags-orchestration.test.ts",
-	},
-	{ from: "graphspec/spec-roundtrip.test.ts", to: "utils/graphspec/spec-roundtrip.test.ts" },
-
-	// evals tests → utils/harness/evals/
-	{
-		from: "evals/catalog-aware-evaluator.test.ts",
-		to: "utils/harness/evals/catalog-aware-evaluator.test.ts",
-	},
-	{ from: "evals/catalog-overlay.test.ts", to: "utils/harness/evals/catalog-overlay.test.ts" },
-	{
-		from: "evals/contrastive-resume.test.ts",
-		to: "utils/harness/evals/contrastive-resume.test.ts",
-	},
-	{ from: "evals/cost-safety.test.ts", to: "utils/harness/evals/cost-safety.test.ts" },
-	{ from: "evals/merge-runs.test.ts", to: "utils/harness/evals/merge-runs.test.ts" },
-	{ from: "evals/portable-catalog.test.ts", to: "utils/harness/evals/portable-catalog.test.ts" },
-	{
-		from: "evals/prompt-template-validity.test.ts",
-		to: "utils/harness/evals/prompt-template-validity.test.ts",
-	},
-	{
-		from: "evals/rate-limit-cache-order.test.ts",
-		to: "utils/harness/evals/rate-limit-cache-order.test.ts",
-	},
-
-	// top-level presentation tests
-	{ from: "adapter-contract.test.ts", to: "utils/ai/adapter-contract.test.ts" },
-	{ from: "phase5-llm-composition.test.ts", to: "utils/ai/phase5-llm-composition.test.ts" },
-
-	// helpers (presentation)
-	{ from: "helpers/mock-llm.ts", to: "helpers/mock-llm.ts" },
-];
-
-// ---------------------------------------------------------------------------
-// File system utilities
-// ---------------------------------------------------------------------------
-
-async function walk(dir: string): Promise<string[]> {
-	if (!existsSync(dir)) return [];
-	const out: string[] = [];
-	const entries = await readdir(dir, { withFileTypes: true });
-	for (const e of entries) {
-		const p = join(dir, e.name);
-		if (e.name === "node_modules" || e.name === "dist") continue;
-		if (e.isDirectory()) out.push(...(await walk(p)));
-		else if (/\.(ts|tsx|mts|cts)$/.test(e.name) && !e.name.endsWith(".d.ts")) {
-			out.push(p);
-		}
-	}
-	return out;
-}
-
-async function ensureDir(p: string): Promise<void> {
-	await mkdir(dirname(p), { recursive: true });
-}
-
-// ---------------------------------------------------------------------------
-// Build the move lookup: srcAbs → dstAbs
-// ---------------------------------------------------------------------------
-
-function buildMoveLookup(): Map<string, string> {
-	const lookup = new Map<string, string>();
-	for (const m of MOVES) {
-		const srcAbs = join(PURE_TS_SRC, m.from);
-		const dstAbs = m.toRoot ? join(ROOT_SRC, m.to) : join(PURE_TS_SRC, m.to);
-		lookup.set(srcAbs, dstAbs);
-	}
-	return lookup;
-}
-
-// ---------------------------------------------------------------------------
-// Import path resolver
-// ---------------------------------------------------------------------------
-
-function resolveImport(fromFile: string, spec: string): string | null {
-	if (!spec.startsWith(".")) return null;
-	const fromDir = dirname(fromFile);
-	// Strip .js extension — TypeScript ESM projects use .js in imports but .ts on disk
-	const specNoJs = spec.replace(/\.js$/, "");
-	const resolved = resolve(fromDir, specNoJs);
-	if (existsSync(resolved + ".ts")) return resolved + ".ts";
-	if (existsSync(join(resolved, "index.ts"))) return join(resolved, "index.ts");
-	// Also try the original (non-stripped) path
-	const resolvedOrig = resolve(fromDir, spec);
-	if (existsSync(resolvedOrig + ".ts")) return resolvedOrig + ".ts";
-	if (existsSync(join(resolvedOrig, "index.ts"))) return join(resolvedOrig, "index.ts");
-	if (existsSync(resolved) && statSync(resolved).isFile()) return resolved;
-	return null;
-}
-
-// ---------------------------------------------------------------------------
-// Import rewriter
-// ---------------------------------------------------------------------------
-
-let totalFilesModified = 0;
-const unresolvableImports: Array<{ file: string; spec: string }> = [];
-
-async function rewriteImports(absFile: string, moveLookup: Map<string, string>): Promise<boolean> {
-	const src = await readFile(absFile, "utf8");
-
-	const importRe = /^((?:import|export)[^"'`\n]*from\s+)(["'])([^"'`]+)\2/gm;
-
-	let changed = false;
-	let result = src;
-
-	const matches: Array<{
-		full: string;
-		prefix: string;
-		quote: string;
-		spec: string;
-		index: number;
-	}> = [];
-	importRe.lastIndex = 0;
-	for (let m = importRe.exec(src); m !== null; m = importRe.exec(src)) {
-		matches.push({ full: m[0], prefix: m[1], quote: m[2], spec: m[3], index: m.index });
-	}
-
-	const edits: Array<{ from: number; to: number; replacement: string }> = [];
-
-	for (const match of matches) {
-		const spec = match.spec;
-		if (!spec.startsWith(".")) continue;
-
-		const resolvedAbs = resolveImport(absFile, spec);
-		if (!resolvedAbs) {
-			if (spec.startsWith("./") || spec.startsWith("../")) {
-				unresolvableImports.push({ file: absFile, spec });
-			}
-			continue;
-		}
-
-		const newAbs = moveLookup.get(resolvedAbs);
-		if (!newAbs) continue;
-
-		// The importing file might also be moving
-		const importerNewAbs = moveLookup.get(absFile) ?? absFile;
-
-		const newRelRaw = relative(dirname(importerNewAbs), newAbs);
-		const newRel = newRelRaw.startsWith(".") ? newRelRaw : "./" + newRelRaw;
-		// newAbs has .ts extension; convert to .js for the import specifier (ESM convention)
-		// The project uses .js extensions in imports (TypeScript ESM convention)
-		const newSpecFinal = newRel.replace(/\.ts$/, ".js");
-
-		if (newSpecFinal !== spec) {
-			const newFull = match.prefix + match.quote + newSpecFinal + match.quote;
-			edits.push({ from: match.index, to: match.index + match.full.length, replacement: newFull });
-			changed = true;
-		}
-	}
-
-	if (edits.length > 0) {
-		edits.sort((a, b) => b.from - a.from);
-		for (const edit of edits) {
-			result = result.slice(0, edit.from) + edit.replacement + result.slice(edit.to);
-		}
-	}
-
-	if (changed) {
-		if (!DRY) {
-			await writeFile(absFile, result, "utf8");
-		}
-		totalFilesModified++;
-	}
-
-	return changed;
-}
-
-// ---------------------------------------------------------------------------
-// Phase 0: Symbol splits + _internal split
-// ---------------------------------------------------------------------------
-
-async function executeSplits(moveLookup: Map<string, string>): Promise<void> {
-	console.log("\n[Phase 0] Symbol splits...");
-
-	// Split composite.ts → verifiable.ts + distill.ts
-	const compositeSrc = join(PURE_TS_SRC, "extra/composition/composite.ts");
-	if (!existsSync(compositeSrc)) {
-		console.log("  SKIP: extra/composition/composite.ts not found");
-	} else {
-		const compositeContent = await readFile(compositeSrc, "utf8");
-		const extractionIdx = compositeContent.indexOf("export type Extraction<TMem>");
-		if (extractionIdx === -1) {
-			console.log("  ERROR: Could not find split point in composite.ts");
-		} else {
-			let verifiablePart = compositeContent.slice(0, extractionIdx);
-			let distillPart = compositeContent.slice(extractionIdx);
-
-			// distill imports from substrate
-			const distillImports = `import { batch } from "@graphrefly/pure-ts/core";
-import { DATA } from "@graphrefly/pure-ts/core";
-import { factoryTag } from "@graphrefly/pure-ts/core";
-import { type Node, type NodeOptions, node } from "@graphrefly/pure-ts/core";
-import {
-\ttype ReactiveMapBundle,
-\ttype ReactiveMapOptions,
-\treactiveMap,
-} from "@graphrefly/pure-ts/extra";
-import { switchMap, withLatestFrom } from "@graphrefly/pure-ts/extra";
-import { forEach, fromAny } from "@graphrefly/pure-ts/extra";
-
-`;
-			distillPart =
-				`/**
- * Budget-constrained reactive memory composition (roadmap §3.2b).
- *
- * Moved to base/composition/distill.ts during cleave A2.
- */
-
-` +
-				distillImports +
-				distillPart;
-
-			verifiablePart =
-				`/**
- * Verifiable composition pattern (roadmap §3.2b).
- *
- * Moved to base/composition/verifiable.ts during cleave A2.
- */
-
-` + verifiablePart;
-
-			const verifiableDst = join(ROOT_SRC, "base/composition/verifiable.ts");
-			const distillDst = join(ROOT_SRC, "base/composition/distill.ts");
-
-			if (!DRY) {
-				await ensureDir(verifiableDst);
-				await writeFile(verifiableDst, verifiablePart);
-				await ensureDir(distillDst);
-				await writeFile(distillDst, distillPart);
-				console.log(`  SPLIT composite.ts → verifiable.ts + distill.ts`);
-			} else {
-				console.log(`  [DRY] SPLIT composite.ts → verifiable.ts + distill.ts`);
-			}
-			// Register the split destinations in moveLookup so import rewriter can find them
-			moveLookup.set(compositeSrc, join(ROOT_SRC, "base/composition/verifiable.ts")); // primary
-		}
-	}
-
-	// Split event.ts → event/timer.ts (substrate) + base/sources/event/cron.ts + base/sources/event/dom.ts
-	const eventSrc = join(PURE_TS_SRC, "extra/sources/event.ts");
-	if (existsSync(eventSrc)) {
-		const eventContent = await readFile(eventSrc, "utf8");
-		const rafIdx = eventContent.indexOf("export function fromRaf");
-		const cronIdx = eventContent.indexOf("export function fromCron");
-		const fromEventIdx = eventContent.indexOf("export function fromEvent");
-
-		if (rafIdx === -1 || cronIdx === -1) {
-			console.log("  ERROR: Could not find split points in event.ts");
-		} else {
-			const firstSplit = Math.min(
-				rafIdx !== -1 ? rafIdx : Infinity,
-				cronIdx !== -1 ? cronIdx : Infinity,
-				fromEventIdx !== -1 ? fromEventIdx : Infinity,
-			);
-
-			const timerContent = eventContent.slice(0, firstSplit);
-			const timerDst = join(PURE_TS_SRC, "extra/sources/event/timer.ts");
-			if (!DRY) {
-				await ensureDir(timerDst);
-				await writeFile(
-					timerDst,
-					`/**
- * Timer-based reactive source (substrate — stays in pure-ts).
- *
- * Moved to extra/sources/event/timer.ts during cleave A2.
- */
-
-` + timerContent,
-				);
-				console.log(`  SPLIT event.ts → event/timer.ts`);
-			} else {
-				console.log(`  [DRY] SPLIT event.ts → event/timer.ts`);
-			}
-
-			// cron.ts: fromCron + extra/cron.ts content
-			const cronSrc = join(PURE_TS_SRC, "extra/cron.ts");
-			let cronContent = "";
-			if (existsSync(cronSrc)) {
-				cronContent = await readFile(cronSrc, "utf8");
-			}
-			const fromCronEnd = fromEventIdx !== -1 ? fromEventIdx : eventContent.length;
-			const fromCronSection = cronIdx !== -1 ? eventContent.slice(cronIdx, fromCronEnd) : "";
-			const cronDst = join(ROOT_SRC, "base/sources/event/cron.ts");
-			if (!DRY) {
-				await ensureDir(cronDst);
-				await writeFile(
-					cronDst,
-					`/**
- * Cron-based reactive sources and schedule types.
- *
- * Merged from extra/cron.ts + extra/sources/event.ts (fromCron) during cleave A2.
- */
-
-` +
-						cronContent +
-						"\n\n// fromCron extracted from extra/sources/event.ts\n" +
-						fromCronSection,
-				);
-				console.log(`  SPLIT event.ts (fromCron) + cron.ts → base/sources/event/cron.ts`);
-			} else {
-				console.log(`  [DRY] SPLIT event.ts (fromCron) + cron.ts → base/sources/event/cron.ts`);
-			}
-
-			// dom.ts: fromEvent + fromRaf
-			const domStartIdx = Math.min(
-				rafIdx !== -1 ? rafIdx : Infinity,
-				fromEventIdx !== -1 ? fromEventIdx : Infinity,
-			);
-			const domContent = domStartIdx < eventContent.length ? eventContent.slice(domStartIdx) : "";
-			const domDst = join(ROOT_SRC, "base/sources/event/dom.ts");
-			if (!DRY) {
-				await ensureDir(domDst);
-				await writeFile(
-					domDst,
-					`/**
- * DOM-based reactive event sources (browser-layer).
- *
- * Moved from extra/sources/event.ts (fromEvent, fromRaf) during cleave A2.
- */
-
-` + domContent,
-				);
-				console.log(`  SPLIT event.ts (fromEvent/fromRaf) → base/sources/event/dom.ts`);
-			} else {
-				console.log(`  [DRY] SPLIT event.ts (fromEvent/fromRaf) → base/sources/event/dom.ts`);
-			}
-		}
-	}
-
-	// Split settled.ts → base/sources/settled.ts + base/meta/keepalive.ts
-	const settledSrc = join(PURE_TS_SRC, "extra/sources/settled.ts");
-	if (existsSync(settledSrc)) {
-		const settledContent = await readFile(settledSrc, "utf8");
-		const keepaliveIdx = settledContent.indexOf(
-			"// ---------------------------------------------------------------------------\n// keepalive",
-		);
-		const reactiveCounterIdx = settledContent.indexOf(
-			"// ---------------------------------------------------------------------------\n// reactiveCounter",
-		);
-
-		if (keepaliveIdx === -1) {
-			console.log("  ERROR: Could not find keepalive section in settled.ts");
-		} else {
-			const settledPart = settledContent.slice(0, keepaliveIdx);
-			const settledWithCounter =
-				settledPart +
-				"\n" +
-				settledContent.slice(
-					reactiveCounterIdx !== -1 ? reactiveCounterIdx : settledContent.length,
-				);
-			const keepaliveEndIdx =
-				reactiveCounterIdx !== -1 ? reactiveCounterIdx : settledContent.length;
-			const keepalivePart = settledContent.slice(keepaliveIdx, keepaliveEndIdx);
-
-			const settledDst = join(ROOT_SRC, "base/sources/settled.ts");
-			const keepaliveDst = join(ROOT_SRC, "base/meta/keepalive.ts");
-
-			if (!DRY) {
-				await ensureDir(settledDst);
-				await writeFile(
-					settledDst,
-					`/**
- * Settled/signal helpers.
- *
- * Moved from extra/sources/settled.ts during cleave A2.
- * keepalive extracted to base/meta/keepalive.ts.
- */
-
-` + settledWithCounter,
-				);
-				await ensureDir(keepaliveDst);
-				await writeFile(
-					keepaliveDst,
-					`/**
- * keepalive — empty subscription to keep derived nodes wired.
- *
- * Extracted from extra/sources/settled.ts during cleave A2.
- */
-
-import type { Node } from "@graphrefly/pure-ts/core";
-
-` + keepalivePart,
-				);
-				console.log(`  SPLIT settled.ts → base/sources/settled.ts + base/meta/keepalive.ts`);
-			} else {
-				console.log(`  [DRY] SPLIT settled.ts → base/sources/settled.ts + base/meta/keepalive.ts`);
-			}
-		}
-	}
-
-	// Split patterns/_internal/index.ts:
-	//   emitToMeta → base/meta/emit-to-meta.ts
-	//   trackingKey → utils/harness/_internal.ts  (STOP #1 resolved)
-	// The original file stays (deleted in Phase 2 deletes after split)
-	const internalSrc = join(PURE_TS_SRC, "patterns/_internal/index.ts");
-	if (existsSync(internalSrc)) {
-		const internalContent = await readFile(internalSrc, "utf8");
-		const emitToMetaIdx = internalContent.indexOf("// emitToMeta");
-		const trackingKeyIdx = internalContent.indexOf("// trackingKey");
-
-		if (emitToMetaIdx === -1) {
-			console.log("  ERROR: Could not find emitToMeta section in _internal/index.ts");
-		} else {
-			// emitToMeta section (between its comment and trackingKey)
-			const emitToMetaSection = internalContent.slice(
-				emitToMetaIdx,
-				trackingKeyIdx !== -1 ? trackingKeyIdx : undefined,
-			);
-			const emitToMetaDst = join(ROOT_SRC, "base/meta/emit-to-meta.ts");
-
-			// trackingKey section
-			const trackingKeySection = trackingKeyIdx !== -1 ? internalContent.slice(trackingKeyIdx) : "";
-			const trackingKeyDst = join(ROOT_SRC, "utils/harness/_internal.ts");
-
-			if (!DRY) {
-				await ensureDir(emitToMetaDst);
-				await writeFile(
-					emitToMetaDst,
-					`/**
- * emitToMeta — forward DATA to a meta companion node via tier-3 deferral.
- *
- * Extracted from patterns/_internal/index.ts during cleave A2.
- */
-
-import { downWithBatch } from "@graphrefly/pure-ts/core";
-import { DATA } from "@graphrefly/pure-ts/core";
-import type { Node } from "@graphrefly/pure-ts/core";
-import { defaultConfig } from "@graphrefly/pure-ts/core";
-
-` + emitToMetaSection.replace(/^\/\/ emitToMeta\n\n/, ""),
-				);
-
-				await ensureDir(trackingKeyDst);
-				await writeFile(
-					trackingKeyDst,
-					`/**
- * Harness-domain internal helpers.
- *
- * trackingKey extracted from patterns/_internal/index.ts during cleave A2.
- * Destination decided per STOP #1 resolution: harness-domain shape,
- * used only by utils/harness/types.ts and presets/harness/harness-loop.ts.
- */
-
-` + trackingKeySection.replace(/^\/\/ trackingKey\n\n/, ""),
-				);
-
-				console.log(
-					`  SPLIT _internal/index.ts → base/meta/emit-to-meta.ts + utils/harness/_internal.ts`,
-				);
-			} else {
-				console.log(
-					`  [DRY] SPLIT _internal/index.ts → base/meta/emit-to-meta.ts + utils/harness/_internal.ts`,
-				);
-				console.log(`  [DRY]   emitToMeta → base/meta/emit-to-meta.ts`);
-				console.log(`  [DRY]   trackingKey → utils/harness/_internal.ts  (STOP #1 resolved)`);
-			}
-		}
-	}
-}
-
-// ---------------------------------------------------------------------------
-// Phase 1: Physical file moves (source files)
-// ---------------------------------------------------------------------------
-
-let totalMoved = 0;
-let totalSkipped = 0;
-
-async function executeMoves(moveLookup: Map<string, string>): Promise<void> {
-	console.log("\n[Phase 1] Moving source files...");
-
-	for (const [srcAbs, dstAbs] of moveLookup) {
-		if (!existsSync(srcAbs)) {
-			console.log(`  SKIP (missing): ${relative(ROOT, srcAbs)}`);
-			totalSkipped++;
-			continue;
-		}
-
-		if (!DRY) {
-			await ensureDir(dstAbs);
-			await rename(srcAbs, dstAbs);
-		}
-		console.log(
-			`  ${DRY ? "[DRY] " : ""}MOVE: ${relative(ROOT, srcAbs)} → ${relative(ROOT, dstAbs)}`,
-		);
-		totalMoved++;
-	}
-}
-
-// ---------------------------------------------------------------------------
-// Phase 2: Delete backward-compat shims + split source files
-// ---------------------------------------------------------------------------
-
-let totalDeleted = 0;
-
-async function executeDeletes(): Promise<void> {
-	console.log("\n[Phase 2] Deleting backward-compat shims...");
-
-	for (const relPath of DELETE_FILES) {
-		const absPath = join(PURE_TS_SRC, relPath);
-		if (!existsSync(absPath)) {
-			console.log(`  SKIP (missing): ${relPath}`);
-			continue;
-		}
-		if (!DRY) {
-			await rm(absPath);
-		}
-		console.log(`  ${DRY ? "[DRY] " : ""}DELETE: ${relPath}`);
-		totalDeleted++;
-	}
-
-	// Delete split sources
-	const splitSources = [
-		"extra/composition/composite.ts", // split → verifiable.ts + distill.ts
-		// extra/sources/event.ts: kept as _orig.ts via MOVES (event/timer.ts will be the live version)
-		// extra/sources/settled.ts: moved via MOVES table above
-		// patterns/_internal/index.ts: split → emit-to-meta.ts + utils/harness/_internal.ts
-		"patterns/_internal/index.ts",
-	];
-	for (const relPath of splitSources) {
-		const absPath = join(PURE_TS_SRC, relPath);
-		if (!existsSync(absPath)) continue;
-		if (!DRY) {
-			await rm(absPath);
-		}
-		console.log(`  ${DRY ? "[DRY] " : ""}DELETE (split source): ${relPath}`);
-		totalDeleted++;
-	}
-}
-
-// ---------------------------------------------------------------------------
-// Phase 3: Move test files (Option B)
-// ---------------------------------------------------------------------------
-
-let totalTestsMoved = 0;
-let totalTestsSkipped = 0;
-
-async function executeTestMoves(): Promise<void> {
-	console.log("\n[Phase 3] Moving presentation test files to root src/__tests__/...");
-
-	for (const tm of TEST_MOVES) {
-		const srcAbs = join(PURE_TS_TESTS, tm.from);
-		const dstAbs = join(ROOT_TESTS, tm.to);
-
-		if (!existsSync(srcAbs)) {
-			console.log(`  SKIP (missing): ${tm.from}`);
-			totalTestsSkipped++;
-			continue;
-		}
-
-		if (!DRY) {
-			await ensureDir(dstAbs);
-			await rename(srcAbs, dstAbs);
-		}
-		console.log(`  ${DRY ? "[DRY] " : ""}TEST MOVE: ${tm.from} → ${tm.to}`);
-		totalTestsMoved++;
-	}
-}
-
-// ---------------------------------------------------------------------------
-// Phase 4: Rewrite imports
-// ---------------------------------------------------------------------------
-
-async function executeImportRewrites(moveLookup: Map<string, string>): Promise<void> {
-	console.log("\n[Phase 4] Rewriting imports...");
-
-	// Build combined lookup that includes test moves
-	const combinedLookup = new Map(moveLookup);
-	for (const tm of TEST_MOVES) {
-		const srcAbs = join(PURE_TS_TESTS, tm.from);
-		const dstAbs = join(ROOT_TESTS, tm.to);
-		combinedLookup.set(srcAbs, dstAbs);
-	}
-
-	const roots = [
-		join(ROOT, "packages/pure-ts/src"),
-		ROOT_SRC,
-		join(ROOT, "packages/parity-tests"),
-		join(ROOT, "packages/cli/src"),
-		join(ROOT, "packages/cli/tests"),
-	];
-
-	for (const rootDir of roots) {
-		if (!existsSync(rootDir)) continue;
-		const files = await walk(rootDir);
-		for (const f of files) {
-			await rewriteImports(f, combinedLookup);
-		}
-	}
-}
-
-// ---------------------------------------------------------------------------
-// Phase 5: Create root vitest.config.ts + update package.json scripts
-// ---------------------------------------------------------------------------
-
-async function createRootVitestConfig(): Promise<void> {
-	console.log("\n[Phase 5] Creating root vitest.config.ts...");
-
-	const vitestConfigPath = join(ROOT, "vitest.config.ts");
-	const vitestConfigContent = `import path from "node:path";
-import { fileURLToPath } from "node:url";
-import { defineConfig } from "vitest/config";
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-
-export default defineConfig({
-\tresolve: {
-\t\talias: [
-\t\t\t{
-\t\t\t\tfind: /^@graphrefly\\/pure-ts\\/(.+)$/,
-\t\t\t\treplacement: path.resolve(__dirname, "packages/pure-ts/src/$1"),
-\t\t\t},
-\t\t\t{
-\t\t\t\tfind: "@graphrefly/pure-ts",
-\t\t\t\treplacement: path.resolve(__dirname, "packages/pure-ts/src/index.ts"),
-\t\t\t},
-\t\t],
-\t},
-\ttest: {
-\t\tinclude: ["src/**/*.test.ts"],
-\t\texclude: ["**/node_modules/**", "dist/**", "**/*.bench.ts"],
-\t\tenvironment: "node",
-\t},
-});
-`;
-
-	if (!DRY) {
-		await writeFile(vitestConfigPath, vitestConfigContent, "utf8");
-		console.log(`  CREATED: vitest.config.ts at root`);
-	} else {
-		console.log(`  [DRY] WOULD CREATE: vitest.config.ts at root`);
-	}
-}
-
-// ---------------------------------------------------------------------------
-// Main
-// ---------------------------------------------------------------------------
-
-async function main(): Promise<void> {
-	console.log(`\n=== codemod-cleave-A ${DRY ? "(DRY RUN)" : "(LIVE)"} ===\n`);
-
-	const moveLookup = buildMoveLookup();
-
-	console.log(`Total planned source moves: ${moveLookup.size}`);
-	console.log(`Total planned test moves: ${TEST_MOVES.length}`);
-
-	// Phase 0: Symbol splits
-	await executeSplits(moveLookup);
-
-	// Phase 1: Physical file moves (source)
-	await executeMoves(moveLookup);
-
-	// Phase 2: Deletions (shims + split sources)
-	await executeDeletes();
-
-	// Phase 3: Test file moves
-	await executeTestMoves();
-
-	// Phase 4: Import rewrites (after all files are in new locations)
-	await executeImportRewrites(moveLookup);
-
-	// Phase 5: Create root vitest config
-	await createRootVitestConfig();
-
-	// Summary
-	console.log("\n=== SUMMARY ===");
-	console.log(`  Source files moved:      ${totalMoved} (${totalSkipped} skipped/missing)`);
-	console.log(
-		`  Test files moved:        ${totalTestsMoved} (${totalTestsSkipped} skipped/missing)`,
-	);
-	console.log(`  Files deleted:           ${totalDeleted}`);
-	console.log(`  Files imports rewritten: ${totalFilesModified}`);
-
-	const benignImports = unresolvableImports.filter(
-		(u) => u.file.includes("__bench__") || u.file.includes("__experiments__"),
-	);
-	const realUnresolvable = unresolvableImports.filter(
-		(u) => !u.file.includes("__bench__") && !u.file.includes("__experiments__"),
-	);
-
-	if (realUnresolvable.length > 0) {
-		const top20 = realUnresolvable.slice(0, 20);
-		console.log(
-			`\n  Unresolvable imports (non-bench, top ${top20.length} of ${realUnresolvable.length}):`,
-		);
-		for (const u of top20) {
-			console.log(`    ${relative(ROOT, u.file)}: "${u.spec}"`);
-		}
-	} else {
-		console.log(`  Unresolvable imports (non-bench): 0`);
-	}
-
-	if (benignImports.length > 0) {
-		console.log(`  Benign unresolvable (bench/experiments): ${benignImports.length}`);
-	}
-
-	console.log("\n=== RESOLVED DECISIONS ===");
-	console.log("  STOP #1: trackingKey → utils/harness/_internal.ts");
-	console.log("  STOP #2: Test migration → Option B (move to root src/__tests__/)");
-	console.log("  MINOR: extra/storage.ts absent from disk — skipped (25 shims, not 26)");
-
-	console.log("\n=== DONE ===\n");
-}
-
-main().catch((e) => {
-	console.error(e);
-	process.exit(1);
-});
diff --git a/scripts/convert-sugar-transform.mjs b/scripts/convert-sugar-transform.mjs
index 9caa7904..9f25499a 100644
--- a/scripts/convert-sugar-transform.mjs
+++ b/scripts/convert-sugar-transform.mjs
@@ -526,7 +526,6 @@ const FILES = [
 	"src/__tests__/graphspec/spec-roundtrip.test.ts",
 	"src/__tests__/graphspec/factory-tags-audit.test.ts",
 	"src/__tests__/graphspec/factory-tags-bundles.test.ts",
-	"src/__tests__/evals/catalog-aware-evaluator.test.ts",
 	"src/__tests__/compat/nestjs.test.ts",
 	"src/__tests__/compat/zustand.test.ts",
 	"src/__tests__/properties/_invariants.ts",
diff --git a/scripts/convert-sugar.mjs b/scripts/convert-sugar.mjs
index 6e66cbe9..fcc94a1c 100644
--- a/scripts/convert-sugar.mjs
+++ b/scripts/convert-sugar.mjs
@@ -73,7 +73,6 @@ const FILES = [
 	"src/__tests__/graphspec/spec-roundtrip.test.ts",
 	"src/__tests__/graphspec/factory-tags-audit.test.ts",
 	"src/__tests__/graphspec/factory-tags-bundles.test.ts",
-	"src/__tests__/evals/catalog-aware-evaluator.test.ts",
 	"src/__tests__/compat/nestjs.test.ts",
 	"src/__tests__/compat/zustand.test.ts",
 	"src/__tests__/properties/_invariants.ts",
diff --git a/scripts/hermes-smoke/README.md b/scripts/hermes-smoke/README.md
index 73ac705b..ae1bb776 100644
--- a/scripts/hermes-smoke/README.md
+++ b/scripts/hermes-smoke/README.md
@@ -1,6 +1,6 @@
 # RN / Hermes verification (`graphrefly-ts#4`)
 
-The ongoing indicator that **`@graphrefly/pure-ts` stays compatible
+The ongoing indicator that **`@graphrefly/ts` stays compatible
 with the Hermes engine React Native ships**. Two tiers, because no
 single cheap check is fully faithful (see "Why three legs" below).
 
@@ -12,11 +12,11 @@ pnpm test:hermes
 
 `scripts/hermes-smoke/run.mjs`:
 
-1. **Bytecode gate** — esbuild-bundles the spike + pure-ts (modern
+1. **Bytecode gate** — esbuild-bundles the spike + @graphrefly/ts (modern
    `es2018`, real shipped syntax) and runs it through
    `hermesc -emit-binary -O`, the **exact compiler RN 0.85.3 uses**
    (npm `hermes-compiler@250829098.0.10`, version-pinned). `-O` =
-   release-optimized bytecode. Success ⇒ pure-ts parses, semantically
+   release-optimized bytecode. Success ⇒ @graphrefly/ts parses, semantically
    analyses and code-generates on RN's real Hermes toolchain.
 2. **Semantics gate** — runs the same spike under Node
    (`run-node.mjs`) asserting the two reactive blocks (basic
@@ -29,7 +29,7 @@ linux / win prebuilts ship in the npm package).
 ## Tier 2 — on-device fixture (periodic, manual)
 
 `apps/rn-hermes-fixture` — Expo SDK 55 (official matrix: RN 0.83.6 /
-React 19.2.0), `jsEngine: hermes`, importing `@graphrefly/pure-ts`
+React 19.2.0), `jsEngine: hermes`, importing `@graphrefly/ts`
 via the workspace. Covers the real Hermes **VM** + RN polyfills.
 
 ```bash
@@ -38,7 +38,7 @@ cd apps/rn-hermes-fixture
 pnpm bundle:check                       # automated: Metro + babel-preset-expo
                                         # + Hermes → emits an .hbc bundle.
                                         # Proves the RN pipeline compiles
-                                        # pure-ts. (CI-able if ever desired.)
+                                        # @graphrefly/ts. (CI-able if ever desired.)
 
 pnpm ios                                # dev build  — real Hermes VM
 pnpm ios:release                        # RELEASE build — Hermes bytecode +
@@ -59,15 +59,15 @@ The reactive assertions are kept equivalent to the canonical
 
 | Concern | Covered by | Tier |
 |---|---|---|
-| pure-ts's real syntax compiles to RN's optimized Hermes bytecode | RN-pinned `hermesc -O` | 1, per-commit |
+| @graphrefly/ts's real syntax compiles to RN's optimized Hermes bytecode | RN-pinned `hermesc -O` | 1, per-commit |
 | Reactive protocol math + diamond dedupe are correct | Node execution | 1, per-commit |
-| Full RN/Metro/Babel pipeline emits a valid `.hbc` for an app using pure-ts | `expo export` (`bundle:check`) | 2, automatable |
+| Full RN/Metro/Babel pipeline emits a valid `.hbc` for an app using @graphrefly/ts | `expo export` (`bundle:check`) | 2, automatable |
 | Real Hermes **VM** execution + RN polyfills on device | `expo run:ios[:release]` | 2, periodic manual |
 
 Dead ends ruled out (don't retry these): the **facebook/hermes
 standalone CLI _releases_ are frozen at an ancient pre-`class`
 v0.13.0**; building the RN-pinned tag from source yields an old
-(0.12.0, no-`class`) `hermes`; **esbuild cannot down-level pure-ts to
+(0.12.0, no-`class`) `hermes`; **esbuild cannot down-level @graphrefly/ts to
 es5** (classes / for-of). Raw Hermes never sees app code in RN
 anyway — Metro/Babel transforms first — so a standalone VM step
 would not be representative. Hence: faithful *compile* in Tier 1,
@@ -77,7 +77,7 @@ would not be representative. Hence: faithful *compile* in Tier 1,
 
 | Component | Pinned | Where |
 |---|---|---|
-| `@graphrefly/pure-ts` | 0.45.0 | workspace |
+| `@graphrefly/ts` | 0.0.1 | workspace |
 | `hermes-compiler` (RN 0.85.3's exact hermesc) | `250829098.0.10` | root devDep + `run.mjs` MATRIX |
 | React Native (fixture) | 0.83.6 | `apps/rn-hermes-fixture` (Expo SDK 55 matrix) |
 | Expo (fixture) | SDK 55 | `apps/rn-hermes-fixture` |
@@ -89,10 +89,10 @@ update this table and re-file the result on issue #4.
 
 ## Polyfills
 
-pure-ts is zero-dependency and universal (no `node:*`, no DOM). The
+@graphrefly/ts is zero-dependency on the verified graph-layer surface (no `node:*`, no DOM). The
 spike's probes (`globalThis`, `Symbol`, `BigInt`, `Promise`,
 `queueMicrotask`, `crypto.randomUUID`, `structuredClone`) are
 informational. **No polyfills are required** for the verified
 surface — the bytecode gate compiles clean and Node semantics pass.
 Record any `MISSING` probe from the on-device fixture run here if a
-future pure-ts change starts depending on one.
+future @graphrefly/ts change starts depending on one.
diff --git a/scripts/hermes-smoke/package.json b/scripts/hermes-smoke/package.json
new file mode 100644
index 00000000..12572e71
--- /dev/null
+++ b/scripts/hermes-smoke/package.json
@@ -0,0 +1,18 @@
+{
+	"name": "@graphrefly/hermes-smoke",
+	"version": "0.0.0",
+	"private": true,
+	"type": "module",
+	"description": "Private RN/Hermes smoke consumer for the @graphrefly/ts graph export map.",
+	"scripts": {
+		"test": "node run.mjs",
+		"test:node": "node run-node.mjs"
+	},
+	"dependencies": {
+		"@graphrefly/ts": "workspace:*"
+	},
+	"devDependencies": {
+		"esbuild": "^0.28.0",
+		"hermes-compiler": "250829098.0.10"
+	}
+}
diff --git a/scripts/hermes-smoke/run-hermes-entry.mjs b/scripts/hermes-smoke/run-hermes-entry.mjs
index 04b3c00a..9fdfe2fc 100644
--- a/scripts/hermes-smoke/run-hermes-entry.mjs
+++ b/scripts/hermes-smoke/run-hermes-entry.mjs
@@ -1,5 +1,5 @@
 /**
- * Hermes-engine entry. esbuild bundles this (+ @graphrefly/pure-ts)
+ * Hermes-engine entry. esbuild bundles this (+ @graphrefly/ts)
  * into one Hermes-safe file. The bare `hermes` CLI has no `console`
  * (only `print`) and no `process`; a banner shims `console`, and we
  * signal pass/fail purely via the `RESULT:` stdout marker that the
diff --git a/scripts/hermes-smoke/run-node.mjs b/scripts/hermes-smoke/run-node.mjs
index fec13e4b..7ac2860a 100644
--- a/scripts/hermes-smoke/run-node.mjs
+++ b/scripts/hermes-smoke/run-node.mjs
@@ -1,6 +1,6 @@
 /**
  * Node sanity runner for the RN/Hermes spike (graphrefly-ts#4).
- * Fast dev-loop check that the pure-ts API translation is correct
+ * Fast dev-loop check that the @graphrefly/ts API translation is correct
  * before involving the real Hermes engine. CI uses run-hermes instead.
  */
 import { probes, runSpike } from "./spike-core.mjs";
diff --git a/scripts/hermes-smoke/run.mjs b/scripts/hermes-smoke/run.mjs
index 7874056c..295839e3 100644
--- a/scripts/hermes-smoke/run.mjs
+++ b/scripts/hermes-smoke/run.mjs
@@ -1,14 +1,14 @@
 /**
  * RN/Hermes engine smoke — the ongoing per-commit indicator that
- * @graphrefly/pure-ts is compatible with the Hermes engine that
+ * @graphrefly/ts is compatible with the Hermes engine that
  * React Native 0.85.3 ships (graphrefly-ts#4).
  *
  * Two faithful, fast, pinned gates:
  *
- *   1. BYTECODE gate — esbuild-bundle the spike + pure-ts, then run
+ *   1. BYTECODE gate — esbuild-bundle the spike + @graphrefly/ts, then run
  *      it through `hermesc -emit-binary -O`, the EXACT compiler RN
  *      0.85.3 uses (npm `hermes-compiler@250829098.0.10`, pinned).
- *      `-O` mirrors a RN *release* build. Success = pure-ts's real
+ *      `-O` mirrors a RN *release* build. Success = @graphrefly/ts's real
  *      shipped syntax parses + semantically analyses + generates
  *      optimized Hermes bytecode against RN's actual toolchain.
  *
@@ -38,7 +38,7 @@ const require = createRequire(import.meta.url);
 
 // ─── Version matrix (bump deliberately; recorded in issue #4) ────────
 const MATRIX = {
-	"@graphrefly/pure-ts": "0.45.0",
+	"@graphrefly/ts": "0.0.1",
 	"hermes-compiler (= RN 0.85.3's exact hermesc)": "250829098.0.10",
 	"react-native (rn-hermes-fixture, Expo SDK 55 matrix)": "0.83.6",
 	"expo (rn-hermes-fixture)": "SDK 55 (55.x)",
@@ -67,7 +67,7 @@ async function bundle() {
 		format: "iife",
 		platform: "neutral",
 		// RN 0.85.3's hermesc is modern (full ES2015+ incl. classes);
-		// keep pure-ts's real shipped syntax so the gate tests what
+		// keep @graphrefly/ts's real shipped syntax so the gate tests what
 		// actually ships rather than a down-levelled variant.
 		target: "es2018",
 		// Bare Hermes has no `console`; route it to `print` (only
diff --git a/scripts/hermes-smoke/spike-core.mjs b/scripts/hermes-smoke/spike-core.mjs
index fb5763df..f293a55f 100644
--- a/scripts/hermes-smoke/spike-core.mjs
+++ b/scripts/hermes-smoke/spike-core.mjs
@@ -1,5 +1,5 @@
 /**
- * Portable RN/Hermes spike for @graphrefly/pure-ts (graphrefly-ts#4).
+ * Portable RN/Hermes spike for @graphrefly/ts (graphrefly-ts#4).
  *
  * Pure, runtime-agnostic. No `node:*`, no DOM, no RN imports. Consumed
  * by THREE runners so the same reactive assertions gate every target:
@@ -7,31 +7,22 @@
  *   - scripts/hermes-smoke/run-hermes.*  — real Hermes engine (CI gate)
  *   - apps/rn-hermes-fixture (Expo)      — periodic on-device RN build
  *
- * Issue #4's snippet uses `state()` / `derived()` / `.set()` as
- * illustrative pseudo-API. pure-ts's real public primitive is `node()`
- * (`state`/`derived` are Graph methods, not standalone exports). This
- * is the faithful translation: manual source = `node([], undefined,
- * {initial})`; derived = `node(deps, fn)` emitting via `actions.emit`.
+ * The spike uses the clean-slate graph layer: manual source = `g.state(initial)`;
+ * derived = `g.derived(deps, fn)`; updates go through `.set()`.
  */
-import { DATA, node } from "@graphrefly/pure-ts";
+import { graph } from "@graphrefly/ts/graph";
 
-function mkState(initial) {
-	return node([], undefined, { initial });
+function mkState(g, initial) {
+	return g.state(initial);
 }
 
-function mkDerived(deps, compute) {
-	return node(deps, (data, actions, ctx) => {
-		const args = deps.map((_, i) => {
-			const batch = data[i];
-			return batch?.length ? batch[batch.length - 1] : ctx.prevData[i];
-		});
-		actions.emit(compute(...args));
-	});
+function mkDerived(g, deps, compute) {
+	return g.derived(deps, compute);
 }
 
 function onData(n, cb) {
-	return n.subscribe((msgs) => {
-		for (const m of msgs) if (m[0] === DATA) cb(m[1]);
+	return n.subscribe((msg) => {
+		if (msg[0] === "DATA") cb(msg[1]);
 	});
 }
 
@@ -47,24 +38,25 @@ export function runSpike() {
 	};
 
 	try {
+		const g = graph();
 		// ---- Block 1: basic propagation ------------------------------
-		const a = mkState(1);
-		const b = mkState(2);
-		const sum = mkDerived([a, b], (x, y) => x + y);
+		const a = mkState(g, 1);
+		const b = mkState(g, 2);
+		const sum = mkDerived(g, [a, b], (x, y) => x + y);
 		const sumSeen = [];
 		onData(sum, (v) => sumSeen.push(v));
-		a.emit(10);
-		b.emit(20);
+		a.set(10);
+		b.set(20);
 		expect("block1 sum emissions", sumSeen, [3, 12, 30]);
 
 		// ---- Block 2: diamond fan-in (cascade dedupe) ----------------
-		const a2 = mkState(1);
-		const b2 = mkDerived([a2], (x) => x * 2);
-		const c2 = mkDerived([a2, b2], (x, y) => x + y);
+		const a2 = mkState(g, 1);
+		const b2 = mkDerived(g, [a2], (x) => x * 2);
+		const c2 = mkDerived(g, [a2, b2], (x, y) => x + y);
 		const c2Seen = [];
 		onData(c2, (v) => c2Seen.push(v));
 		const before = c2Seen.length;
-		a2.emit(5);
+		a2.set(5);
 		expect("block2 c2 initial", c2Seen.slice(0, before), [3]);
 		expect("block2 c2 after set==5 (ONCE, not twice)", c2Seen.slice(before), [15]);
 	} catch (err) {
diff --git a/scripts/layer-boundary-baseline.json b/scripts/layer-boundary-baseline.json
deleted file mode 100644
index e48b36a9..00000000
--- a/scripts/layer-boundary-baseline.json
+++ /dev/null
@@ -1,4 +0,0 @@
-{
-	"_comment": "Cleave A layer-boundary residuals — CLOSED 2026-05-15. The 4-layer DAG is now structurally clean: Class A (zero-domain resilience backoff/_internal/status/retry/timeout reclassified -> base/), Class B (utils/<domain> barrels no longer re-export presets; utils-path consumers repointed at presets/<domain>), Class C (preset-coupled files relocated out of utils/: ai/agents/agent.ts -> presets/ai/agent.ts; harness/{profile,trace,eval-verifier,refine-executor}.ts -> presets/harness/) all landed. Baseline is empty: the ratchet now fails ANY layer-boundary violation as a hard error. Do NOT add entries to silence new violations — fix the layering. Provenance: docs/optimizations.md 'Cleave A layer-boundary residuals', archive/docs/SESSION-DS-cleave-A-file-moves.md.",
-	"baseline": []
-}
diff --git a/src/__tests__/base/composition/backpressure.test.ts b/src/__tests__/base/composition/backpressure.test.ts
deleted file mode 100644
index 1c300882..00000000
--- a/src/__tests__/base/composition/backpressure.test.ts
+++ /dev/null
@@ -1,460 +0,0 @@
-import { COMPLETE, DATA, type Messages, node, PAUSE, RESUME } from "@graphrefly/pure-ts/core";
-import { Graph } from "@graphrefly/pure-ts/graph";
-import { describe, expect, it, vi } from "vitest";
-import { createWatermarkController } from "../../../base/composition/backpressure.js";
-import {
-	ObserveGateway,
-	type ObserveWsMessage,
-	observeSSE,
-	observeSubscription,
-} from "../../../compat/nestjs/gateway.js";
-
-// ---------------------------------------------------------------------------
-// WatermarkController unit tests
-// ---------------------------------------------------------------------------
-
-describe("WatermarkController", () => {
-	function setup(high = 3, low = 1) {
-		const sent: Messages[] = [];
-		const wm = createWatermarkController((msgs) => sent.push(msgs), {
-			highWaterMark: high,
-			lowWaterMark: low,
-		});
-		return { wm, sent };
-	}
-
-	it("tracks pending count", () => {
-		const { wm } = setup();
-		expect(wm.pending).toBe(0);
-		wm.onEnqueue();
-		expect(wm.pending).toBe(1);
-		wm.onEnqueue();
-		expect(wm.pending).toBe(2);
-		wm.onDequeue();
-		expect(wm.pending).toBe(1);
-	});
-
-	it("sends PAUSE at highWaterMark", () => {
-		const { wm, sent } = setup(3, 1);
-		wm.onEnqueue(); // 1
-		wm.onEnqueue(); // 2
-		expect(wm.paused).toBe(false);
-		expect(sent).toHaveLength(0);
-
-		const paused = wm.onEnqueue(); // 3 = highWaterMark
-		expect(paused).toBe(true);
-		expect(wm.paused).toBe(true);
-		expect(sent).toHaveLength(1);
-		expect(sent[0]![0]![0]).toBe(PAUSE);
-	});
-
-	it("sends RESUME at lowWaterMark after being paused", () => {
-		const { wm, sent } = setup(3, 1);
-		wm.onEnqueue();
-		wm.onEnqueue();
-		wm.onEnqueue(); // PAUSE sent
-		expect(wm.paused).toBe(true);
-
-		wm.onDequeue(); // 2 — still above lowWaterMark
-		expect(wm.paused).toBe(true);
-		expect(sent).toHaveLength(1); // only PAUSE
-
-		const resumed = wm.onDequeue(); // 1 = lowWaterMark
-		expect(resumed).toBe(true);
-		expect(wm.paused).toBe(false);
-		expect(sent).toHaveLength(2); // PAUSE + RESUME
-		expect(sent[1]![0]![0]).toBe(RESUME);
-	});
-
-	it("does not send RESUME when not paused", () => {
-		const { wm, sent } = setup(3, 1);
-		wm.onEnqueue();
-		wm.onDequeue();
-		expect(sent).toHaveLength(0);
-	});
-
-	it("does not send duplicate PAUSE", () => {
-		const { wm, sent } = setup(3, 1);
-		wm.onEnqueue();
-		wm.onEnqueue();
-		wm.onEnqueue(); // PAUSE
-		wm.onEnqueue(); // 4 — still paused, no duplicate
-		expect(sent).toHaveLength(1);
-	});
-
-	it("dispose sends RESUME if paused", () => {
-		const { wm, sent } = setup(2, 0);
-		wm.onEnqueue();
-		wm.onEnqueue(); // PAUSE
-		expect(wm.paused).toBe(true);
-		wm.dispose();
-		expect(wm.paused).toBe(false);
-		expect(sent).toHaveLength(2);
-		expect(sent[1]![0]![0]).toBe(RESUME);
-	});
-
-	it("dispose is no-op when not paused", () => {
-		const { wm, sent } = setup();
-		wm.dispose();
-		expect(sent).toHaveLength(0);
-	});
-
-	it("uses unique lockId per controller", () => {
-		const sent1: Messages[] = [];
-		const sent2: Messages[] = [];
-		const wm1 = createWatermarkController((m) => sent1.push(m), {
-			highWaterMark: 1,
-			lowWaterMark: 0,
-		});
-		const wm2 = createWatermarkController((m) => sent2.push(m), {
-			highWaterMark: 1,
-			lowWaterMark: 0,
-		});
-		wm1.onEnqueue();
-		wm2.onEnqueue();
-
-		const lockId1 = sent1[0]![0]![1];
-		const lockId2 = sent2[0]![0]![1];
-		expect(typeof lockId1).toBe("symbol");
-		expect(typeof lockId2).toBe("symbol");
-		expect(lockId1).not.toBe(lockId2);
-	});
-
-	it("pending does not go below zero", () => {
-		const { wm } = setup();
-		wm.onDequeue();
-		wm.onDequeue();
-		expect(wm.pending).toBe(0);
-	});
-
-	it("throws on invalid watermark options", () => {
-		const noop = () => {};
-		expect(() => createWatermarkController(noop, { highWaterMark: 0, lowWaterMark: 0 })).toThrow(
-			"highWaterMark must be >= 1",
-		);
-		expect(() => createWatermarkController(noop, { highWaterMark: 3, lowWaterMark: -1 })).toThrow(
-			"lowWaterMark must be >= 0",
-		);
-		expect(() => createWatermarkController(noop, { highWaterMark: 3, lowWaterMark: 3 })).toThrow(
-			"lowWaterMark must be < highWaterMark",
-		);
-		expect(() => createWatermarkController(noop, { highWaterMark: 3, lowWaterMark: 5 })).toThrow(
-			"lowWaterMark must be < highWaterMark",
-		);
-	});
-});
-
-// ---------------------------------------------------------------------------
-// GraphObserveOne.up() integration
-// ---------------------------------------------------------------------------
-
-describe("GraphObserveOne.up()", () => {
-	it("propagates PAUSE upstream through observed node", () => {
-		const s = node([], { initial: 0 });
-		const g = new Graph("bp-up");
-		g.add(s, { name: "s" });
-
-		const upMsgs: Messages[] = [];
-		const orig = s.up;
-		s.up = (msgs: Messages) => {
-			upMsgs.push(msgs);
-			orig?.call(s, msgs);
-		};
-
-		const handle = g.observe("s");
-		handle.subscribe(() => {});
-		handle.up([[PAUSE, "test-lock"]]);
-
-		expect(upMsgs.length).toBe(1);
-		expect(upMsgs[0]![0]![0]).toBe(PAUSE);
-		expect(upMsgs[0]![0]![1]).toBe("test-lock");
-		g.destroy();
-	});
-
-	it("graph-wide observe.up() targets specific path", () => {
-		const a = node([], { initial: 0 });
-		const b = node([], { initial: 0 });
-		const g = new Graph("bp-up-all");
-		g.add(a, { name: "a" });
-		g.add(b, { name: "b" });
-
-		const aMsgs: Messages[] = [];
-		const bMsgs: Messages[] = [];
-		const origA = a.up;
-		const origB = b.up;
-		a.up = (msgs: Messages) => {
-			aMsgs.push(msgs);
-			origA?.call(a, msgs);
-		};
-		b.up = (msgs: Messages) => {
-			bMsgs.push(msgs);
-			origB?.call(b, msgs);
-		};
-
-		const handle = g.observe();
-		handle.subscribe(() => {});
-		handle.up("a", [[PAUSE, "lock-a"]]);
-
-		expect(aMsgs.length).toBe(1);
-		expect(bMsgs.length).toBe(0);
-		g.destroy();
-	});
-});
-
-// ---------------------------------------------------------------------------
-// observeSubscription backpressure
-// ---------------------------------------------------------------------------
-
-describe("observeSubscription — backpressure", () => {
-	it("sends PAUSE when queue exceeds highWaterMark", () => {
-		const s = node<number>();
-		const g = new Graph("sub-bp");
-		g.add(s, { name: "n" });
-
-		const upMsgs: Messages[] = [];
-		const orig = s.up;
-		s.up = (msgs: Messages) => {
-			upMsgs.push(msgs);
-			orig?.call(s, msgs);
-		};
-
-		const iter = observeSubscription<number>(g, "n", {
-			highWaterMark: 2,
-			lowWaterMark: 1,
-		});
-
-		// Push 2 items without consuming — should trigger PAUSE at highWaterMark
-		s.down([[DATA, 1]]);
-		s.down([[DATA, 2]]);
-
-		expect(upMsgs.some((m) => m[0]![0] === PAUSE)).toBe(true);
-
-		// Drain via next() — should eventually trigger RESUME
-		void iter.next();
-		expect(upMsgs.some((m) => m[0]![0] === RESUME)).toBe(true);
-
-		void iter.return!();
-		g.destroy();
-	});
-
-	it("no backpressure when options not set", async () => {
-		const s = node<number>();
-		const g = new Graph("sub-no-bp");
-		g.add(s, { name: "n" });
-
-		const upMsgs: Messages[] = [];
-		const orig = s.up;
-		s.up = (msgs: Messages) => {
-			upMsgs.push(msgs);
-			orig?.call(s, msgs);
-		};
-
-		const iter = observeSubscription<number>(g, "n");
-		s.down([[DATA, 1]]);
-		s.down([[DATA, 2]]);
-		s.down([[DATA, 3]]);
-		s.down([[COMPLETE]]);
-
-		const results: number[] = [];
-		for await (const v of iter) results.push(v);
-		expect(results).toEqual([1, 2, 3]);
-		expect(upMsgs.length).toBe(0);
-		g.destroy();
-	});
-
-	it("dispose sends RESUME on iterator return", () => {
-		const s = node<number>([], { initial: 0 });
-		const g = new Graph("sub-bp-dispose");
-		g.add(s, { name: "n" });
-
-		const upMsgs: Messages[] = [];
-		const orig = s.up;
-		s.up = (msgs: Messages) => {
-			upMsgs.push(msgs);
-			orig?.call(s, msgs);
-		};
-
-		const iter = observeSubscription<number>(g, "n", {
-			highWaterMark: 1,
-			lowWaterMark: 0,
-		});
-
-		s.down([[DATA, 1]]); // triggers PAUSE
-		expect(upMsgs.some((m) => m[0]![0] === PAUSE)).toBe(true);
-
-		void iter.return!(); // dispose should RESUME
-		expect(upMsgs.filter((m) => m[0]![0] === RESUME).length).toBe(1);
-		g.destroy();
-	});
-});
-
-// ---------------------------------------------------------------------------
-// ObserveGateway backpressure
-// ---------------------------------------------------------------------------
-
-describe("ObserveGateway — backpressure", () => {
-	function makeMockClient(): { send: ReturnType<typeof vi.fn>; id: string } {
-		return { send: vi.fn(), id: Math.random().toString(36) };
-	}
-
-	it("sends PAUSE when messages exceed highWaterMark, RESUME on ack", () => {
-		const s = node<number>();
-		const g = new Graph("gw-bp");
-		g.add(s, { name: "counter" });
-
-		const upMsgs: Messages[] = [];
-		const orig = s.up;
-		s.up = (msgs: Messages) => {
-			upMsgs.push(msgs);
-			orig?.call(s, msgs);
-		};
-
-		const gw = new ObserveGateway(g, { highWaterMark: 2, lowWaterMark: 1 });
-		const client = makeMockClient();
-		gw.handleConnection(client);
-
-		const sent: ObserveWsMessage[] = [];
-		gw.handleMessage(client, { type: "subscribe", path: "counter" }, (msg) => sent.push(msg));
-
-		s.down([[DATA, 1]]);
-		s.down([[DATA, 2]]);
-
-		expect(upMsgs.some((m) => m[0]![0] === PAUSE)).toBe(true);
-
-		// Ack 1 item — should trigger RESUME (pending goes from 2 to 1 = lowWaterMark)
-		gw.handleMessage(client, { type: "ack", path: "counter", count: 1 });
-		expect(upMsgs.some((m) => m[0]![0] === RESUME)).toBe(true);
-
-		gw.destroy();
-		g.destroy();
-	});
-
-	it("disconnect disposes watermark controllers", () => {
-		const s = node<number>([], { initial: 0 });
-		const g = new Graph("gw-bp-dc");
-		g.add(s, { name: "n" });
-
-		const upMsgs: Messages[] = [];
-		const orig = s.up;
-		s.up = (msgs: Messages) => {
-			upMsgs.push(msgs);
-			orig?.call(s, msgs);
-		};
-
-		const gw = new ObserveGateway(g, { highWaterMark: 1, lowWaterMark: 0 });
-		const client = makeMockClient();
-		gw.handleConnection(client);
-
-		const sent: ObserveWsMessage[] = [];
-		gw.handleMessage(client, { type: "subscribe", path: "n" }, (msg) => sent.push(msg));
-
-		s.down([[DATA, 1]]); // PAUSE
-		expect(upMsgs.some((m) => m[0]![0] === PAUSE)).toBe(true);
-
-		gw.handleDisconnect(client); // should RESUME
-		expect(upMsgs.some((m) => m[0]![0] === RESUME)).toBe(true);
-
-		g.destroy();
-	});
-
-	it("no backpressure when watermarks not configured", () => {
-		const s = node<number>([], { initial: 0 });
-		const g = new Graph("gw-no-bp");
-		g.add(s, { name: "n" });
-
-		const upMsgs: Messages[] = [];
-		const orig = s.up;
-		s.up = (msgs: Messages) => {
-			upMsgs.push(msgs);
-			orig?.call(s, msgs);
-		};
-
-		const gw = new ObserveGateway(g);
-		const client = makeMockClient();
-		gw.handleConnection(client);
-
-		const sent: ObserveWsMessage[] = [];
-		gw.handleMessage(client, { type: "subscribe", path: "n" }, (msg) => sent.push(msg));
-
-		s.down([[DATA, 1]]);
-		s.down([[DATA, 2]]);
-		s.down([[DATA, 3]]);
-
-		expect(upMsgs.length).toBe(0);
-		gw.destroy();
-		g.destroy();
-	});
-});
-
-// ---------------------------------------------------------------------------
-// observeSSE backpressure
-// ---------------------------------------------------------------------------
-
-describe("observeSSE — backpressure", () => {
-	it("buffers and drains via pull when watermarks set", async () => {
-		const s = node<number>([], { initial: 0 });
-		const g = new Graph("sse-bp");
-		g.add(s, { name: "n" });
-
-		const upMsgs: Messages[] = [];
-		const orig = s.up;
-		s.up = (msgs: Messages) => {
-			upMsgs.push(msgs);
-			orig?.call(s, msgs);
-		};
-
-		const stream = observeSSE(g, "n", { highWaterMark: 2, lowWaterMark: 1 });
-		const reader = stream.getReader();
-		const decoder = new TextDecoder();
-
-		// Push enough to trigger PAUSE
-		s.down([[DATA, 1]]);
-		s.down([[DATA, 2]]);
-
-		expect(upMsgs.some((m) => m[0]![0] === PAUSE)).toBe(true);
-
-		// Read/drain items — pull() triggers onDequeue → RESUME
-		const { value: v1 } = await reader.read();
-		expect(decoder.decode(v1)).toContain("event: data");
-
-		// May need another read to cross lowWaterMark
-		const { value: v2 } = await reader.read();
-		expect(decoder.decode(v2)).toContain("event: data");
-
-		expect(upMsgs.some((m) => m[0]![0] === RESUME)).toBe(true);
-
-		// Clean up
-		s.down([[COMPLETE]]);
-		// Drain remaining
-		while (true) {
-			const { done } = await reader.read();
-			if (done) break;
-		}
-		g.destroy();
-	});
-
-	it("works without backpressure (default)", async () => {
-		const s = node<number>([], { initial: 0 });
-		const g = new Graph("sse-no-bp");
-		g.add(s, { name: "n" });
-
-		const stream = observeSSE(g, "n");
-		const reader = stream.getReader();
-		const decoder = new TextDecoder();
-
-		s.down([[DATA, 42]]);
-		s.down([[COMPLETE]]);
-
-		const chunks: string[] = [];
-		while (true) {
-			const { done, value } = await reader.read();
-			if (done) break;
-			chunks.push(decoder.decode(value));
-		}
-
-		const text = chunks.join("");
-		expect(text).toContain("event: data\ndata: 42\n\n");
-		expect(text).toContain("event: complete\n\n");
-		g.destroy();
-	});
-});
diff --git a/src/__tests__/base/composition/composite.test.ts b/src/__tests__/base/composition/composite.test.ts
deleted file mode 100644
index e393d81e..00000000
--- a/src/__tests__/base/composition/composite.test.ts
+++ /dev/null
@@ -1,367 +0,0 @@
-import { DATA, node } from "@graphrefly/pure-ts/core";
-import { describe, expect, it } from "vitest";
-import { distill } from "../../../base/composition/distill.js";
-import { verifiable } from "../../../base/composition/verifiable.js";
-
-function tick(ms = 0): Promise<void> {
-	return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-describe("extra composite verifiable (roadmap §3.2b)", () => {
-	it("runs verification from explicit trigger", () => {
-		const source = node([], { initial: 2 });
-		const trigger = node([], { initial: 0 });
-		const bundle = verifiable(source, (value) => ({ holds: value > 0, checked: value }), {
-			trigger,
-			autoVerify: false,
-		});
-
-		expect(bundle.verified.cache).toEqual({ holds: true, checked: 2 });
-		trigger.down([[DATA, 1]]);
-		expect(bundle.verified.cache).toEqual({ holds: true, checked: 2 });
-	});
-
-	it("cancels stale verification with switchMap", async () => {
-		const source = node([], { initial: 1 });
-		const trigger = node([], { initial: 0 });
-		const bundle = verifiable(
-			source,
-			(value) =>
-				new Promise<{ value: number }>((resolve) => {
-					setTimeout(() => resolve({ value }), value === 1 ? 40 : 5);
-				}),
-			{ trigger },
-		);
-
-		trigger.down([[DATA, 1]]);
-		source.down([[DATA, 2]]);
-		trigger.down([[DATA, 2]]);
-
-		await tick(15);
-		expect(bundle.verified.cache).toEqual({ value: 2 });
-
-		await tick(60);
-		expect(bundle.verified.cache).toEqual({ value: 2 });
-	});
-
-	it("accepts falsy scalar trigger values", () => {
-		const source = node([], { initial: 3 });
-		const bundle = verifiable(source, (value) => value * 10, { trigger: 0 as const });
-		expect(bundle.trigger).not.toBe(null);
-		expect(bundle.verified.cache).toBe(30);
-	});
-
-	it("stamps sourceVersion meta when source node has V0", () => {
-		const source = node([], { versioning: 0, initial: 2 });
-		const trigger = node([], { initial: 0 });
-		const bundle = verifiable(source, (value) => ({ checked: value }), {
-			trigger,
-			autoVerify: false,
-		});
-		trigger.down([[DATA, 1]]);
-		const sv = (bundle.verified.meta as any).sourceVersion.cache as {
-			id: string;
-			version: number;
-		};
-		expect(sv.id).toBe(source.v!.id);
-		expect(sv.version).toBe(source.v!.version);
-	});
-
-	// P11.5-D1 regression: explicit-trigger verifiable wires
-	// `withLatestFrom(trigger, source)` with `partial: false`. A regression
-	// that drops the withLatestFrom edge (e.g. back to a §28 closure-mirror)
-	// would call `verifyFn(undefined as T)` on the first trigger when source
-	// has not yet emitted DATA. This test pins that the gate holds until
-	// both deps settle.
-	it("trigger-before-source-DATA waits for source via withLatestFrom partial:false", () => {
-		const source = node<number>([]); // no initial DATA
-		const trigger = node<number>([]); // no initial DATA
-		const calls: unknown[] = [];
-		const bundle = verifiable(
-			source,
-			(value: number) => {
-				calls.push(value);
-				return value * 10;
-			},
-			{ trigger, autoVerify: false },
-		);
-		// Keepalive so verifyStream activates; verifying-side starts pending.
-		const off = bundle.verified.subscribe(() => undefined);
-
-		expect(calls).toEqual([]);
-		expect(bundle.verified.cache).toBeNull();
-
-		// Trigger alone — withLatestFrom must NOT release the fn yet.
-		trigger.down([[DATA, 1]]);
-		expect(calls).toEqual([]);
-		expect(bundle.verified.cache).toBeNull();
-
-		// Source emits — both deps have DATA, fn fires once.
-		source.down([[DATA, 7]]);
-		expect(calls).toEqual([7]);
-		expect(bundle.verified.cache).toBe(70);
-
-		// Subsequent trigger pairs with the new latest source value.
-		source.down([[DATA, 9]]);
-		trigger.down([[DATA, 2]]);
-		expect(calls.at(-1)).toBe(9);
-		expect(bundle.verified.cache).toBe(90);
-		off();
-	});
-});
-
-describe("extra composite distill (roadmap §3.2b)", () => {
-	it("extracts memories and builds compact view", () => {
-		const source = node([], { initial: "alpha" });
-		const bundle = distill(
-			source,
-			(rawNode) =>
-				node(
-					[rawNode],
-					(batchData, actions, ctx) => {
-						const data = batchData.map((batch, i) =>
-							batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-						);
-						const raw = data[0];
-						actions.emit({
-							upsert: [{ key: raw, value: { text: raw, points: raw.length } }],
-						});
-					},
-					{ describeKind: "derived" },
-				),
-			{
-				score: (mem) => mem.points,
-				cost: () => 1,
-				budget: 10,
-			},
-		);
-
-		source.down([[DATA, "beta"]]);
-		expect(bundle.store.get("beta")).toEqual({ text: "beta", points: 4 });
-		expect(bundle.size.cache).toBeGreaterThan(0);
-		expect(bundle.compact.cache.some((x) => x.key === "beta")).toBe(true);
-	});
-
-	it("reactively evicts via dynamicNode-tracked condition", () => {
-		const source = node([], { initial: "x" });
-		const evictToggle = node([], { initial: false });
-		const bundle = distill(
-			source,
-			(rawNode) =>
-				node(
-					[rawNode],
-					(batchData, actions, ctx) => {
-						const data = batchData.map((batch, i) =>
-							batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-						);
-						actions.emit({ upsert: [{ key: data[0], value: { text: data[0] } }] });
-					},
-					{ describeKind: "derived" },
-				),
-			{
-				score: () => 1,
-				cost: () => 1,
-				budget: 10,
-				evict: () => evictToggle,
-			},
-		);
-
-		source.down([[DATA, "keep-me"]]);
-		expect(bundle.store.has("keep-me")).toBe(true);
-		evictToggle.down([[DATA, true]]);
-		expect(bundle.store.has("keep-me")).toBe(false);
-	});
-
-	it("runs consolidation from trigger and keeps extraction atomic", () => {
-		const source = node([], { initial: "seed" });
-		const consolidateTrigger = node([], { initial: false });
-		const bundle = distill(
-			source,
-			(rawNode) =>
-				node(
-					[rawNode],
-					(batchData, actions, ctx) => {
-						const data = batchData.map((batch, i) =>
-							batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-						);
-						const raw = data[0];
-						actions.emit({
-							upsert: [{ key: raw, value: { text: raw, points: raw.length } }],
-						});
-					},
-					{ describeKind: "derived" },
-				),
-			{
-				score: (mem) => mem.points,
-				cost: () => 1,
-				budget: 10,
-				consolidate: () => ({
-					upsert: [{ key: "merged", value: { text: "merged", points: 99 } }],
-					remove: ["seed"],
-				}),
-				consolidateTrigger,
-			},
-		);
-
-		const sizes: number[] = [];
-		const unsub = bundle.size.subscribe((msgs) => {
-			for (const m of msgs) if (m[0] === DATA) sizes.push(m[1] as number);
-		});
-		consolidateTrigger.down([[DATA, true]]);
-		unsub();
-
-		expect(bundle.store.has("seed")).toBe(false);
-		expect(bundle.store.has("merged")).toBe(true);
-		expect(sizes.every((size) => size >= 1)).toBe(true);
-	});
-
-	it("accepts falsy scalar context and consolidateTrigger", () => {
-		const source = node([], { initial: "seed" });
-		const bundle = distill(
-			source,
-			(rawNode) =>
-				node(
-					[rawNode],
-					(batchData, actions, ctx) => {
-						const data = batchData.map((batch, i) =>
-							batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-						);
-						const raw = data[0];
-						actions.emit({
-							upsert: [{ key: raw, value: { text: raw, points: raw.length } }],
-						});
-					},
-					{ describeKind: "derived" },
-				),
-			{
-				score: (mem, context) => mem.points + (context as number),
-				cost: () => 1,
-				budget: 10,
-				context: 0 as const,
-				consolidateTrigger: 0 as const,
-				consolidate: () => ({
-					upsert: [{ key: "merged", value: { text: "merged", points: 99 } }],
-					remove: ["seed"],
-				}),
-			},
-		);
-		expect(bundle.store.has("seed")).toBe(false);
-		expect(bundle.store.has("merged")).toBe(true);
-		expect(bundle.compact.cache.some((x) => x.key === "merged")).toBe(true);
-	});
-
-	it("throws for invalid evict return type", () => {
-		const source = node([], { initial: "x" });
-		const bundle = distill(
-			source,
-			(rawNode) =>
-				node(
-					[rawNode],
-					(batchData, actions, ctx) => {
-						const data = batchData.map((batch, i) =>
-							batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-						);
-						actions.emit({ upsert: [{ key: data[0], value: { text: data[0] } }] });
-					},
-					{ describeKind: "derived" },
-				),
-			{
-				score: () => 1,
-				cost: () => 1,
-				budget: 10,
-				evict: () => "bad" as unknown as boolean,
-			},
-		);
-		expect(() => source.down([[DATA, "y"]])).not.toThrow();
-		expect(bundle.store.has("x")).toBe(true);
-	});
-
-	// P11.5-D1 regression: distill consolidate path wires
-	// `withLatestFrom(consolidateTrigger, store.entries)`. A regression that
-	// drops the withLatestFrom edge (e.g. closure-mirror) would either fire
-	// consolidate on every store mutation (wrong primary) or never fire when
-	// the trigger leads the store. This test pins both halves.
-	it("consolidate fires on trigger only, not on store mutation alone", () => {
-		const source = node([], { initial: "seed-1" });
-		const trigger = node<number>([]);
-		const consolidateCalls: number[] = [];
-		let callId = 0;
-
-		const bundle = distill(
-			source,
-			(rawNode) =>
-				node(
-					[rawNode],
-					(batchData, actions, ctx) => {
-						const data = batchData.map((batch, i) =>
-							batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-						);
-						const raw = data[0] as string;
-						actions.emit({ upsert: [{ key: raw, value: { text: raw, points: 1 } }] });
-					},
-					{ describeKind: "derived" },
-				),
-			{
-				score: () => 1,
-				cost: () => 1,
-				budget: 10,
-				consolidateTrigger: trigger,
-				consolidate: (entries) => {
-					consolidateCalls.push(callId++);
-					return { upsert: [{ key: `consol-${entries.size}`, value: { text: "c", points: 0 } }] };
-				},
-			},
-		);
-
-		// Source emit alone must NOT fire consolidate (trigger is the primary).
-		source.down([[DATA, "seed-2"]]);
-		expect(bundle.store.has("seed-2")).toBe(true);
-		expect(consolidateCalls).toEqual([]);
-
-		// Trigger fires — withLatestFrom releases with store.entries snapshot.
-		trigger.down([[DATA, 1]]);
-		expect(consolidateCalls).toEqual([0]);
-
-		// Subsequent store mutation alone — still no consolidate fire.
-		source.down([[DATA, "seed-3"]]);
-		expect(consolidateCalls).toEqual([0]);
-
-		// Trigger fires again — fresh store snapshot.
-		trigger.down([[DATA, 2]]);
-		expect(consolidateCalls).toEqual([0, 1]);
-	});
-
-	it("throws when extraction omits upsert", () => {
-		const source = node([], { initial: "seed" });
-		const bundle = distill(
-			source,
-			(rawNode) =>
-				node(
-					[rawNode],
-					(batchData, actions, ctx) => {
-						const data = batchData.map((batch, i) =>
-							batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-						);
-						const raw = data[0];
-						actions.emit(
-							raw === "seed"
-								? { upsert: [{ key: raw, value: { text: raw } }] }
-								: ({
-										remove: ["seed"],
-									} as unknown as {
-										upsert: Array<{ key: string; value: { text: string } }>;
-									}),
-						);
-					},
-					{ describeKind: "derived" },
-				),
-			{
-				score: () => 1,
-				cost: () => 1,
-				budget: 10,
-			},
-		);
-		expect(() => source.down([[DATA, "run"]])).not.toThrow();
-		expect(bundle.store.has("seed")).toBe(true);
-	});
-});
diff --git a/src/__tests__/base/composition/external-register.test.ts b/src/__tests__/base/composition/external-register.test.ts
deleted file mode 100644
index 8e2dcbf9..00000000
--- a/src/__tests__/base/composition/external-register.test.ts
+++ /dev/null
@@ -1,277 +0,0 @@
-/**
- * Tests for externalProducer / externalBundle (src/extra/external-register.ts).
- */
-
-import { COMPLETE, DATA, ERROR, type Messages } from "@graphrefly/pure-ts/core";
-import { describe, expect, it, vi } from "vitest";
-import {
-	type BundleTriad,
-	type EmitTriad,
-	externalBundle,
-	externalProducer,
-} from "../../../base/composition/external-register.js";
-
-type Collected<T> = {
-	values: T[];
-	errors: unknown[];
-	readonly completes: number;
-	unsub: () => void;
-};
-
-function collect<T>(node: { subscribe: (s: (m: Messages) => void) => () => void }): Collected<T> {
-	const values: T[] = [];
-	const errors: unknown[] = [];
-	const state = { completes: 0 };
-	const unsub = node.subscribe((msgs) => {
-		for (const m of msgs) {
-			if (m[0] === DATA) values.push(m[1] as T);
-			else if (m[0] === ERROR) errors.push(m[1]);
-			else if (m[0] === COMPLETE) state.completes++;
-		}
-	});
-	return {
-		values,
-		errors,
-		get completes() {
-			return state.completes;
-		},
-		unsub,
-	};
-}
-
-describe("externalProducer", () => {
-	it("invokes register on first subscribe and cleanup on last unsubscribe", () => {
-		const cleanup = vi.fn();
-		let triad!: EmitTriad<number>;
-		const register = vi.fn((t: EmitTriad<number>) => {
-			triad = t;
-			return cleanup;
-		});
-		const src = externalProducer<number>(register);
-		expect(register).toHaveBeenCalledTimes(0);
-
-		const a = collect<number>(src);
-		expect(register).toHaveBeenCalledTimes(1);
-		expect(cleanup).toHaveBeenCalledTimes(0);
-
-		triad.emit(1);
-		triad.emit(2);
-		expect(a.values).toEqual([1, 2]);
-
-		a.unsub();
-		expect(cleanup).toHaveBeenCalledTimes(1);
-	});
-
-	it("drops emits after cleanup (active flag guard)", () => {
-		let triad!: EmitTriad<number>;
-		const src = externalProducer<number>((t) => {
-			triad = t;
-			return () => {};
-		});
-		const a = collect<number>(src);
-		triad.emit(1);
-		a.unsub();
-		triad.emit(2); // post-teardown — must NOT reach a new subscriber
-
-		const b = collect<number>(src);
-		expect(b.values).toEqual([]);
-	});
-
-	it("error terminates the stream", () => {
-		let triad!: EmitTriad<number>;
-		const src = externalProducer<number>((t) => {
-			triad = t;
-			return () => {};
-		});
-		const a = collect<number>(src);
-		triad.emit(1);
-		triad.error(new Error("boom"));
-		triad.emit(2); // post-error — must be dropped
-
-		expect(a.values).toEqual([1]);
-		expect(a.errors).toHaveLength(1);
-		expect((a.errors[0] as Error).message).toBe("boom");
-	});
-
-	it("complete terminates the stream", () => {
-		let triad!: EmitTriad<number>;
-		const src = externalProducer<number>((t) => {
-			triad = t;
-			return () => {};
-		});
-		const a = collect<number>(src);
-		triad.emit(1);
-		triad.complete();
-		triad.emit(2); // post-complete — must be dropped
-
-		expect(a.values).toEqual([1]);
-		expect(a.completes).toBe(1);
-	});
-
-	it("synchronous throw from register surfaces as terminal ERROR", () => {
-		const src = externalProducer<number>(() => {
-			throw new Error("register failed");
-		});
-		const a = collect<number>(src);
-		expect(a.errors).toHaveLength(1);
-		expect((a.errors[0] as Error).message).toBe("register failed");
-	});
-
-	it("register returning void / undefined is accepted", () => {
-		let triad!: EmitTriad<number>;
-		const src = externalProducer<number>((t) => {
-			triad = t;
-			// no return — undefined cleanup
-		});
-		const a = collect<number>(src);
-		triad.emit(42);
-		expect(a.values).toEqual([42]);
-		expect(() => a.unsub()).not.toThrow();
-	});
-
-	it("cleanup throws are swallowed at the boundary", () => {
-		let triad!: EmitTriad<number>;
-		const src = externalProducer<number>((t) => {
-			triad = t;
-			return () => {
-				throw new Error("cleanup failed");
-			};
-		});
-		const a = collect<number>(src);
-		triad.emit(1);
-		expect(() => a.unsub()).not.toThrow();
-	});
-});
-
-describe("externalBundle", () => {
-	type Channels = { traces: { id: string }; metrics: { v: number }; logs: { msg: string } };
-
-	it("activates eagerly and cleanup fires after all channels tear down", () => {
-		const cleanup = vi.fn();
-		let bundle!: BundleTriad<Channels>;
-		const register = vi.fn((b: BundleTriad<Channels>) => {
-			bundle = b;
-			return cleanup;
-		});
-
-		const nodes = externalBundle<Channels>(register, ["traces", "metrics", "logs"]);
-		// Eager: register already ran
-		expect(register).toHaveBeenCalledTimes(1);
-		expect(cleanup).toHaveBeenCalledTimes(0);
-
-		const t = collect<{ id: string }>(nodes.traces);
-		const m = collect<{ v: number }>(nodes.metrics);
-		const l = collect<{ msg: string }>(nodes.logs);
-
-		bundle.traces({ id: "s1" });
-		bundle.metrics({ v: 42 });
-		bundle.logs({ msg: "hi" });
-
-		expect(t.values).toEqual([{ id: "s1" }]);
-		expect(m.values).toEqual([{ v: 42 }]);
-		expect(l.values).toEqual([{ msg: "hi" }]);
-
-		t.unsub();
-		expect(cleanup).toHaveBeenCalledTimes(0); // still two channels live
-		m.unsub();
-		expect(cleanup).toHaveBeenCalledTimes(0);
-		l.unsub();
-		expect(cleanup).toHaveBeenCalledTimes(1);
-	});
-
-	it("error propagates ERROR to all subscribed channels and runs cleanup", () => {
-		const cleanup = vi.fn();
-		let bundle!: BundleTriad<Channels>;
-		const nodes = externalBundle<Channels>(
-			(b) => {
-				bundle = b;
-				return cleanup;
-			},
-			["traces", "metrics", "logs"],
-		);
-
-		const t = collect<{ id: string }>(nodes.traces);
-		const m = collect<{ v: number }>(nodes.metrics);
-		const l = collect<{ msg: string }>(nodes.logs);
-
-		bundle.error(new Error("server down"));
-
-		expect(t.errors).toHaveLength(1);
-		expect(m.errors).toHaveLength(1);
-		expect(l.errors).toHaveLength(1);
-		expect(cleanup).toHaveBeenCalledTimes(1);
-
-		// Post-error emits must be dropped
-		bundle.traces({ id: "late" });
-		expect(t.values).toEqual([]);
-	});
-
-	it("complete propagates COMPLETE to all subscribed channels and runs cleanup", () => {
-		const cleanup = vi.fn();
-		let bundle!: BundleTriad<Channels>;
-		const nodes = externalBundle<Channels>(
-			(b) => {
-				bundle = b;
-				return cleanup;
-			},
-			["traces", "metrics", "logs"],
-		);
-
-		const t = collect<{ id: string }>(nodes.traces);
-		const m = collect<{ v: number }>(nodes.metrics);
-		const l = collect<{ msg: string }>(nodes.logs);
-
-		bundle.traces({ id: "s1" });
-		bundle.complete();
-
-		expect(t.completes).toBe(1);
-		expect(m.completes).toBe(1);
-		expect(l.completes).toBe(1);
-		expect(cleanup).toHaveBeenCalledTimes(1);
-	});
-
-	it("synchronous throw from register propagates to caller (eager activation)", () => {
-		type C2 = { a: number; b: string };
-		expect(() =>
-			externalBundle<C2>(() => {
-				throw new Error("bad register");
-			}, ["a", "b"]),
-		).toThrow("bad register");
-	});
-
-	it("names channel nodes with optional prefix", () => {
-		type C = { x: number };
-		const nodes = externalBundle<C>(
-			() => {
-				return () => {};
-			},
-			["x"],
-			{ name: "myhub" },
-		);
-		expect(nodes.x.name).toBe("myhub::x");
-	});
-
-	it("batches emits to multiple channels inside a single user call", () => {
-		type C = { a: number; b: number };
-		let bundle!: BundleTriad<C>;
-		const nodes = externalBundle<C>(
-			(h) => {
-				bundle = h;
-				return () => {};
-			},
-			["a", "b"],
-		);
-
-		const a = collect<number>(nodes.a);
-		const b = collect<number>(nodes.b);
-
-		// Caller can batch fan-out themselves — we don't auto-batch individual
-		// per-channel calls because the registrar knows best when to group.
-		bundle.a(1);
-		bundle.b(2);
-		bundle.a(3);
-
-		expect(a.values).toEqual([1, 3]);
-		expect(b.values).toEqual([2]);
-	});
-});
diff --git a/src/__tests__/base/composition/materialize.test.ts b/src/__tests__/base/composition/materialize.test.ts
deleted file mode 100644
index 01e21d8a..00000000
--- a/src/__tests__/base/composition/materialize.test.ts
+++ /dev/null
@@ -1,291 +0,0 @@
-/**
- * Phase 13.C — `selector` + `materialize` regression tests.
- */
-
-import { COMPLETE, DATA, node } from "@graphrefly/pure-ts/core";
-import { Graph } from "@graphrefly/pure-ts/graph";
-import { describe, expect, it } from "vitest";
-import { type GraphFactory, materialize, selector } from "../../../base/composition/materialize.js";
-import { collect } from "../test-helpers.js";
-
-// ---------------------------------------------------------------------------
-// selector
-// ---------------------------------------------------------------------------
-
-describe("selector (Phase 13.C / G2 lock C)", () => {
-	it("projects each upstream value to a routing key", () => {
-		const src = node<{ kind: string; n: number }>([], {
-			initial: { kind: "research", n: 1 },
-			equals: () => false,
-		});
-		const key = selector(src, (req) => req.kind);
-		const { messages, unsub } = collect(key, { flat: true });
-
-		src.emit({ kind: "summarize", n: 2 });
-		src.emit({ kind: "code", n: 3 });
-
-		const keys = messages.filter((m) => m[0] === DATA).map((m) => m[1]);
-		expect(keys).toEqual(["research", "summarize", "code"]);
-		unsub();
-	});
-
-	it("dedupes when the projected key does NOT change", () => {
-		const src = node<{ kind: string; n: number }>([], {
-			initial: { kind: "research", n: 1 },
-			equals: () => false,
-		});
-		const key = selector(src, (req) => req.kind);
-		const { messages, unsub } = collect(key, { flat: true });
-
-		// Multiple input emissions, same projected key — emits once.
-		src.emit({ kind: "research", n: 2 });
-		src.emit({ kind: "research", n: 3 });
-		// Now real change.
-		src.emit({ kind: "code", n: 4 });
-
-		const keys = messages.filter((m) => m[0] === DATA).map((m) => m[1]);
-		expect(keys).toEqual(["research", "code"]);
-		unsub();
-	});
-
-	it("custom `equals` controls when the key is considered changed", () => {
-		const src = node<{ tag: string; rev: number }>([], {
-			initial: { tag: "v", rev: 1 },
-			equals: () => false,
-		});
-		const key = selector(src, (req) => ({ tag: req.tag, rev: req.rev }), {
-			// Only `tag` matters — `rev` changes don't count as a key change.
-			equals: (a, b) => a.tag === b.tag,
-		});
-		const { messages, unsub } = collect(key, { flat: true });
-
-		src.emit({ tag: "v", rev: 2 });
-		src.emit({ tag: "v", rev: 3 });
-		src.emit({ tag: "w", rev: 4 });
-
-		const keys = messages.filter((m) => m[0] === DATA).map((m) => m[1]) as Array<{
-			tag: string;
-			rev: number;
-		}>;
-		expect(keys.map((k) => k.tag)).toEqual(["v", "w"]);
-		unsub();
-	});
-});
-
-// ---------------------------------------------------------------------------
-// materialize
-// ---------------------------------------------------------------------------
-
-class FakeAgentGraph extends Graph {
-	readonly id: string;
-	constructor(id: string) {
-		super(`agent-${id}`);
-		this.id = id;
-		// Add a state node so we can verify the slot's internals are mounted.
-		this.state("kind", id);
-	}
-}
-
-describe("materialize (Phase 13.C / G2 lock C)", () => {
-	it("mounts the factory output for the active key under parent", () => {
-		const parent = new Graph("parent");
-		const key = node<string>([], { initial: "research" });
-		const factories = node<ReadonlyMap<string, GraphFactory<FakeAgentGraph>>>([], {
-			initial: new Map([
-				["research", () => new FakeAgentGraph("research")],
-				["coder", () => new FakeAgentGraph("coder")],
-			]),
-		});
-		const slot = materialize(key, factories, parent, { slotName: "agent" });
-		const { unsub } = collect(slot);
-
-		// Mount happened: parent has an `agent::kind` resolvable path.
-		expect(parent.node("agent::kind").cache).toBe("research");
-		expect((slot.cache as FakeAgentGraph).id).toBe("research");
-
-		unsub();
-		parent.destroy();
-	});
-
-	it("re-mounts the slot when the key changes", () => {
-		const parent = new Graph("parent");
-		const key = node<string>([], { initial: "research" });
-		const factories = node<ReadonlyMap<string, GraphFactory<FakeAgentGraph>>>([], {
-			initial: new Map([
-				["research", () => new FakeAgentGraph("research")],
-				["coder", () => new FakeAgentGraph("coder")],
-			]),
-		});
-		const slot = materialize(key, factories, parent, { slotName: "agent" });
-		const { unsub } = collect(slot);
-
-		expect(parent.node("agent::kind").cache).toBe("research");
-
-		key.emit("coder");
-		expect(parent.node("agent::kind").cache).toBe("coder");
-		expect((slot.cache as FakeAgentGraph).id).toBe("coder");
-
-		unsub();
-		parent.destroy();
-	});
-
-	it("emits a fresh Graph reference on each key change", () => {
-		const parent = new Graph("parent");
-		const key = node<string>([], { initial: "a" });
-		const factories = node<ReadonlyMap<string, GraphFactory<FakeAgentGraph>>>([], {
-			initial: new Map([
-				["a", () => new FakeAgentGraph("a")],
-				["b", () => new FakeAgentGraph("b")],
-			]),
-		});
-		const slot = materialize(key, factories, parent, { slotName: "agent" });
-		const { messages, unsub } = collect(slot, { flat: true });
-
-		key.emit("b");
-		key.emit("a");
-
-		const graphs = messages.filter((m) => m[0] === DATA).map((m) => m[1]) as FakeAgentGraph[];
-		// Three distinct mounts: a, b, a. Each is a fresh instance.
-		expect(graphs.map((g) => g.id)).toEqual(["a", "b", "a"]);
-		expect(graphs[0]).not.toBe(graphs[2]); // fresh instance, not cached
-		unsub();
-		parent.destroy();
-	});
-
-	it("does NOT re-mount when factories change but key stays (G10 deferred)", () => {
-		const parent = new Graph("parent");
-		const key = node<string>([], { initial: "a" });
-		let factoryACalls = 0;
-		const initialFactories: ReadonlyMap<string, GraphFactory<FakeAgentGraph>> = new Map([
-			[
-				"a",
-				() => {
-					factoryACalls += 1;
-					return new FakeAgentGraph(`a-v${factoryACalls}`);
-				},
-			],
-		]);
-		const factories = node<ReadonlyMap<string, GraphFactory<FakeAgentGraph>>>([], {
-			initial: initialFactories,
-			equals: () => false,
-		});
-		const slot = materialize(key, factories, parent, { slotName: "agent" });
-		const { unsub } = collect(slot);
-
-		expect(factoryACalls).toBe(1);
-		expect(parent.node("agent::kind").cache).toBe("a-v1");
-
-		// Update factories with a new "a" implementation. Per G10 deferral, the
-		// active slot is NOT re-instantiated — the original factory output
-		// continues running.
-		const updatedFactories: ReadonlyMap<string, GraphFactory<FakeAgentGraph>> = new Map([
-			[
-				"a",
-				() => {
-					factoryACalls += 1;
-					return new FakeAgentGraph(`a-v${factoryACalls}`);
-				},
-			],
-		]);
-		factories.emit(updatedFactories);
-
-		expect(factoryACalls).toBe(1);
-		expect(parent.node("agent::kind").cache).toBe("a-v1");
-
-		// But on the next key transition, the new factory IS used.
-		key.emit("a"); // same value but with non-dedup factories — won't re-mount
-		expect(factoryACalls).toBe(1);
-
-		unsub();
-		parent.destroy();
-	});
-
-	it("unmounts the active slot when the materialize node tears down", () => {
-		const parent = new Graph("parent");
-		const key = node<string>([], { initial: "a" });
-		const factories = node<ReadonlyMap<string, GraphFactory<FakeAgentGraph>>>([], {
-			initial: new Map([["a", () => new FakeAgentGraph("a")]]),
-		});
-		const slot = materialize(key, factories, parent, { slotName: "agent" });
-		const { unsub } = collect(slot);
-
-		expect(parent.node("agent::kind").cache).toBe("a");
-
-		// Dispose the consumer — materialize's cleanup unmounts the slot.
-		unsub();
-
-		expect(() => parent.node("agent::kind")).toThrow();
-
-		parent.destroy();
-	});
-
-	it("emits no DATA when key has no matching factory; still allows later key matches", () => {
-		const parent = new Graph("parent");
-		const key = node<string>([], { initial: "missing" });
-		const factories = node<ReadonlyMap<string, GraphFactory<FakeAgentGraph>>>([], {
-			initial: new Map([["a", () => new FakeAgentGraph("a")]]),
-		});
-		const slot = materialize(key, factories, parent, { slotName: "agent" });
-		const { messages, unsub } = collect(slot, { flat: true });
-
-		// Initial wave: no factory for "missing" → no mount.
-		expect(slot.cache).toBeUndefined();
-		expect(messages.filter((m) => m[0] === DATA)).toHaveLength(0);
-
-		// Switch to a key that DOES have a factory.
-		key.emit("a");
-		expect(parent.node("agent::kind").cache).toBe("a");
-		expect((slot.cache as FakeAgentGraph).id).toBe("a");
-
-		unsub();
-		parent.destroy();
-	});
-
-	it("propagates COMPLETE from the key node", () => {
-		const parent = new Graph("parent");
-		const key = node<string>([], { initial: "a" });
-		const factories = node<ReadonlyMap<string, GraphFactory<FakeAgentGraph>>>([], {
-			initial: new Map([["a", () => new FakeAgentGraph("a")]]),
-		});
-		const slot = materialize(key, factories, parent, { slotName: "agent" });
-		const { messages, unsub } = collect(slot, { flat: true });
-
-		key.down([[COMPLETE]]);
-
-		expect(messages.filter((m) => m[0] === COMPLETE)).toHaveLength(1);
-		unsub();
-		parent.destroy();
-	});
-
-	it("composes with selector — projection key drives mount", () => {
-		const parent = new Graph("parent");
-		type Request = { kind: "a" | "b"; n: number };
-		const requests = node<Request>([], {
-			initial: { kind: "a", n: 1 },
-			equals: () => false,
-		});
-		const key = selector(requests, (r) => r.kind);
-		const factories = node<ReadonlyMap<"a" | "b", GraphFactory<FakeAgentGraph>>>([], {
-			initial: new Map<"a" | "b", GraphFactory<FakeAgentGraph>>([
-				["a", () => new FakeAgentGraph("a")],
-				["b", () => new FakeAgentGraph("b")],
-			]),
-		});
-		const slot = materialize(key, factories, parent, { slotName: "agent" });
-		const { unsub } = collect(slot);
-
-		expect((slot.cache as FakeAgentGraph).id).toBe("a");
-
-		// Same kind, different `n` — selector dedupes, no re-mount.
-		const beforeRef = slot.cache;
-		requests.emit({ kind: "a", n: 2 });
-		expect(slot.cache).toBe(beforeRef);
-
-		// Real kind change — re-mount.
-		requests.emit({ kind: "b", n: 3 });
-		expect((slot.cache as FakeAgentGraph).id).toBe("b");
-
-		unsub();
-		parent.destroy();
-	});
-});
diff --git a/src/__tests__/base/composition/observable.test.ts b/src/__tests__/base/composition/observable.test.ts
deleted file mode 100644
index 548a4144..00000000
--- a/src/__tests__/base/composition/observable.test.ts
+++ /dev/null
@@ -1,112 +0,0 @@
-// Base `toObservable` — dependency-free TC39 interop observable.
-// Locks the memo:Re P0 fix: the base barrel must NOT depend on rxjs, yet the
-// returned value must still be adoptable by rxjs `from()` via Symbol.observable.
-
-import { COMPLETE, DATA, ERROR, node } from "@graphrefly/pure-ts/core";
-import { firstValueFrom, from, take, toArray } from "rxjs";
-import { describe, expect, it } from "vitest";
-import { toObservable } from "../../../base/composition/observable.js";
-
-const OBSERVABLE_KEY: PropertyKey =
-	(typeof Symbol === "function" && (Symbol as unknown as { observable?: symbol }).observable) ||
-	"@@observable";
-
-describe("base/composition toObservable — Symbol.observable interop (no rxjs dep)", () => {
-	it("exposes the well-known interop method returning itself", () => {
-		const s = node<number>();
-		const obs = toObservable(s) as Record<PropertyKey, unknown>;
-		expect(typeof obs.subscribe).toBe("function");
-		expect(typeof obs[OBSERVABLE_KEY]).toBe("function");
-		expect((obs[OBSERVABLE_KEY] as () => unknown).call(obs)).toBe(obs);
-	});
-
-	it("is adoptable by rxjs from() and emits DATA values", async () => {
-		const s = node<number>();
-		const p = firstValueFrom(from(toObservable<number>(s)).pipe(take(2), toArray()));
-		s.down([[DATA, 1]]);
-		s.down([[DATA, 2]]);
-		expect(await p).toEqual([1, 2]);
-	});
-
-	it("maps ERROR to error()", async () => {
-		const s = node<number>();
-		const err = new Promise<unknown>((res) => {
-			toObservable<number>(s).subscribe({ next: () => {}, error: res });
-		});
-		s.down([[ERROR, new Error("boom")]]);
-		expect((await err) as Error).toBeInstanceOf(Error);
-	});
-
-	it("maps COMPLETE to complete() and supports a function observer", () => {
-		const s = node<number>([], { initial: 7 });
-		const seen: number[] = [];
-		let done = false;
-		// Function-form observer (TC39 shorthand) must be normalized.
-		toObservable<number>(s).subscribe((v) => seen.push(v));
-		toObservable<number>(s).subscribe({ complete: () => (done = true) });
-		s.down([[COMPLETE]]);
-		expect(seen).toEqual([7]);
-		expect(done).toBe(true);
-	});
-
-	it("raw mode emits message batches (incl. framing)", async () => {
-		const s = node<number>();
-		// Subscribe delivers framing (START, then DIRTY per down) before DATA;
-		// assert the extracted DATA payloads, order-preserved.
-		const p = firstValueFrom(from(toObservable(s, { raw: true })).pipe(take(5), toArray()));
-		s.down([[DATA, 1]]);
-		s.down([[DATA, 2]]);
-		const dataValues = (await p)
-			.flat()
-			.filter((m) => m[0] === DATA)
-			.map((m) => m[1]);
-		expect(dataValues).toEqual([1, 2]);
-	});
-
-	it("unsubscribe stops node delivery", () => {
-		const s = node<number>();
-		const seen: number[] = [];
-		const sub = toObservable<number>(s).subscribe((v) => seen.push(v));
-		s.down([[DATA, 1]]);
-		s.down([[DATA, 2]]);
-		sub.unsubscribe();
-		s.down([[DATA, 3]]);
-		expect(seen).toEqual([1, 2]);
-	});
-
-	// QA/D1 regression: direct (non-rxjs) TC39 consumer. The hand-rolled
-	// interop must latch on terminal and auto-unsubscribe the node — without
-	// this, a post-terminal node wave re-fires next/complete (terminal-once
-	// violated) and the node subscription leaks (rxjs `from()` masked both).
-	it("COMPLETE latches terminal + auto-unsubscribes the node (no rxjs)", () => {
-		const s = node<number>();
-		const seen: number[] = [];
-		let completes = 0;
-		toObservable<number>(s).subscribe({
-			next: (v) => seen.push(v),
-			complete: () => completes++,
-		});
-		s.down([[DATA, 1]]);
-		s.down([[COMPLETE]]);
-		s.down([[DATA, 99]]); // post-terminal — must NOT reach the observer
-		s.down([[COMPLETE]]); // must NOT re-fire complete
-		expect(seen).toEqual([1]);
-		expect(completes).toBe(1);
-	});
-
-	it("ERROR latches terminal + auto-unsubscribes the node (no rxjs)", () => {
-		const s = node<number>();
-		const seen: number[] = [];
-		let errors = 0;
-		toObservable<number>(s).subscribe({
-			next: (v) => seen.push(v),
-			error: () => errors++,
-		});
-		s.down([[DATA, 1]]);
-		s.down([[ERROR, new Error("boom")]]);
-		s.down([[DATA, 99]]);
-		s.down([[ERROR, new Error("again")]]);
-		expect(seen).toEqual([1]);
-		expect(errors).toBe(1);
-	});
-});
diff --git a/src/__tests__/base/composition/pubsub-stress.test.ts b/src/__tests__/base/composition/pubsub-stress.test.ts
deleted file mode 100644
index ab33e051..00000000
--- a/src/__tests__/base/composition/pubsub-stress.test.ts
+++ /dev/null
@@ -1,393 +0,0 @@
-/**
- * Stress tests for pubsub — Wave 4 audit + new APIs.
- *
- * Covers: lazy creation, publish-creates, multi-subscriber, push-on-subscribe,
- * TEARDOWN propagation, republish-after-remove, has/size/topicNames,
- * publishMany semantics, pluggable backend, version counter.
- */
-
-import { DATA, TEARDOWN } from "@graphrefly/pure-ts/core";
-import { describe, expect, it } from "vitest";
-import {
-	NativePubSubBackend,
-	type PubSubBackend,
-	pubsub,
-} from "../../../base/composition/pubsub.js";
-import { collect } from "../test-helpers.js";
-
-describe("pubsub stress tests", () => {
-	// ── Scenario 1: Lazy topic creation ─────────────────────────────────
-	it("S1: topic(name) creates on first call; second call returns same node", () => {
-		const hub = pubsub();
-		const t1 = hub.topic("x");
-		const t2 = hub.topic("x");
-		expect(t1).toBe(t2);
-	});
-
-	// ── Scenario 2: publish(name) auto-creates + delivers ───────────────
-	it("S2: publish to non-existent topic creates it + delivers", () => {
-		const hub = pubsub();
-		hub.publish("y", 42);
-
-		expect(hub.has("y")).toBe(true);
-		const { messages, unsub } = collect(hub.topic("y"), { flat: true });
-		const firstData = messages.find((m) => m[0] === DATA);
-		expect(firstData![1]).toBe(42);
-		unsub();
-	});
-
-	// ── Scenario 3: Multiple subscribers receive the same DATA ──────────
-	it("S3: multiple subscribers all receive published DATA", () => {
-		const hub = pubsub();
-		const t = hub.topic("broadcast");
-
-		const seen1: unknown[] = [];
-		const seen2: unknown[] = [];
-		const u1 = t.subscribe((msgs) => {
-			for (const m of msgs as [symbol, unknown][]) {
-				if (m[0] === DATA) seen1.push(m[1]);
-			}
-		});
-		const u2 = t.subscribe((msgs) => {
-			for (const m of msgs as [symbol, unknown][]) {
-				if (m[0] === DATA) seen2.push(m[1]);
-			}
-		});
-
-		hub.publish("broadcast", "hello");
-		hub.publish("broadcast", "world");
-
-		u1();
-		u2();
-
-		// Sentinel topic: no push-on-subscribe before first publish. Both subs
-		// joined before any publish, so they see only subsequent DATA.
-		expect(seen1).toEqual(["hello", "world"]);
-		expect(seen2).toEqual(["hello", "world"]);
-	});
-
-	// ── Scenario 4: Push-on-subscribe delivers cached last value ────────
-	it("S4: subscriber joining after publish receives cached last value", () => {
-		const hub = pubsub();
-		hub.publish("status", "ready");
-		hub.publish("status", "running");
-
-		// New subscriber joins after 2 publishes; gets only the latest
-		const { messages, unsub } = collect(hub.topic("status"), { flat: true });
-		const firstData = messages.find((m) => m[0] === DATA);
-		expect(firstData![1]).toBe("running");
-		unsub();
-	});
-
-	// ── Scenario 5: removeTopic sends TEARDOWN ──────────────────────────
-	it("S5: removeTopic propagates TEARDOWN to subscribers", () => {
-		const hub = pubsub();
-		hub.publish("bye", 1);
-
-		const seen: symbol[] = [];
-		const unsub = hub.topic("bye").subscribe((msgs) => {
-			for (const m of msgs as [symbol, unknown][]) seen.push(m[0]);
-		});
-
-		const removed = hub.removeTopic("bye");
-		expect(removed).toBe(true);
-
-		unsub();
-
-		// Expect TEARDOWN received by subscriber
-		expect(seen).toContain(TEARDOWN);
-		// And topic is gone from the hub
-		expect(hub.has("bye")).toBe(false);
-	});
-
-	// ── Scenario 6: Republish after remove silently recreates ───────────
-	it("S6: publish to a removed topic silently recreates (fresh node)", () => {
-		const hub = pubsub();
-		hub.publish("recycle", "first");
-		const oldNode = hub.topic("recycle");
-
-		hub.removeTopic("recycle");
-		expect(hub.has("recycle")).toBe(false);
-
-		hub.publish("recycle", "second");
-		expect(hub.has("recycle")).toBe(true);
-
-		const newNode = hub.topic("recycle");
-		// Fresh instance — old subscribers do NOT reconnect
-		expect(newNode).not.toBe(oldNode);
-
-		// New subscriber gets "second"
-		const { messages, unsub } = collect(newNode, { flat: true });
-		const firstData = messages.find((m) => m[0] === DATA);
-		expect(firstData![1]).toBe("second");
-		unsub();
-	});
-
-	// ── Scenario 7: has(name) does not create ───────────────────────────
-	it("S7: has(name) does not create the topic", () => {
-		const hub = pubsub();
-		expect(hub.has("never-created")).toBe(false);
-		expect(hub.size).toBe(0);
-
-		hub.has("check-1");
-		hub.has("check-2");
-		expect(hub.size).toBe(0); // still empty
-	});
-
-	// ── Scenario 8: size counts topics ──────────────────────────────────
-	it("S8: size reflects topic count after creates / removes", () => {
-		const hub = pubsub();
-		expect(hub.size).toBe(0);
-
-		hub.topic("a");
-		hub.publish("b", 1);
-		hub.topic("c");
-		expect(hub.size).toBe(3);
-
-		hub.removeTopic("b");
-		expect(hub.size).toBe(2);
-
-		hub.removeTopic("missing"); // no-op
-		expect(hub.size).toBe(2);
-	});
-
-	// ── Scenario 9: topicNames() enumeration ────────────────────────────
-	it("S9: topicNames() iterates over registered topics", () => {
-		const hub = pubsub();
-		hub.publish("x", 1);
-		hub.publish("y", 2);
-		hub.topic("z");
-
-		const names = [...hub.topicNames()];
-		expect(names.sort()).toEqual(["x", "y", "z"]);
-
-		hub.removeTopic("y");
-		const after = [...hub.topicNames()];
-		expect(after.sort()).toEqual(["x", "z"]);
-	});
-
-	// ── Scenario 10: publishMany delivers to multiple topics in one batch ─
-	it("S10: publishMany delivers DATA to each topic", () => {
-		const hub = pubsub();
-
-		const seenX: unknown[] = [];
-		const seenY: unknown[] = [];
-		const ux = hub.topic("x").subscribe((msgs) => {
-			for (const m of msgs as [symbol, unknown][]) if (m[0] === DATA) seenX.push(m[1]);
-		});
-		const uy = hub.topic("y").subscribe((msgs) => {
-			for (const m of msgs as [symbol, unknown][]) if (m[0] === DATA) seenY.push(m[1]);
-		});
-
-		hub.publishMany([
-			["x", 1],
-			["y", 2],
-			["x", 10],
-		]);
-
-		ux();
-		uy();
-
-		// Sentinel topics: no push-on-subscribe before first publish. Subs
-		// attached before publishMany, so they see only the published values.
-		expect(seenX).toEqual([1, 10]);
-		expect(seenY).toEqual([2]);
-	});
-
-	// ── Scenario 11: publishMany empty is no-op ─────────────────────────
-	it("S11: publishMany([]) emits nothing", () => {
-		const hub = pubsub();
-		const { messages, unsub } = collect(hub.topic("x"), { flat: true });
-		const beforeLen = messages.length;
-
-		hub.publishMany([]);
-
-		expect(messages.length).toBe(beforeLen);
-		unsub();
-	});
-
-	// ── Scenario 12: publishMany auto-creates topics on the fly ─────────
-	it("S12: publishMany creates topics that don't exist", () => {
-		const hub = pubsub();
-		hub.publishMany([
-			["new1", "a"],
-			["new2", "b"],
-		]);
-
-		expect(hub.has("new1")).toBe(true);
-		expect(hub.has("new2")).toBe(true);
-		expect(hub.size).toBe(2);
-	});
-
-	// ── Scenario 13: Publish undefined is valid ─────────────────────────
-	it("S13: publish(name, undefined) is valid", () => {
-		const hub = pubsub();
-		hub.publish("u", undefined);
-
-		const { unsub } = collect(hub.topic("u"), { flat: true });
-		// Topic is a sentinel node; publishing undefined may coalesce to RESOLVED
-		// via default equality. Either way, subscriber sees state and topic exists.
-		expect(hub.has("u")).toBe(true);
-		unsub();
-	});
-
-	// ── Scenario 14: removeTopic on non-existent returns false ──────────
-	it("S14: removeTopic(missing) returns false, no-op", () => {
-		const hub = pubsub();
-		expect(hub.removeTopic("never")).toBe(false);
-		expect(hub.size).toBe(0);
-	});
-
-	// ── Scenario 15: removeTopic inside batch — TEARDOWN deferred appropriately ─
-	it("S15: TEARDOWN from removeTopic (tier 5) delivers after phase-2 in same batch scope", () => {
-		const hub = pubsub();
-		hub.publish("x", "initial");
-
-		const received: symbol[] = [];
-		const unsub = hub.topic("x").subscribe((msgs) => {
-			for (const m of msgs as [symbol, unknown][]) received.push(m[0]);
-		});
-
-		// clear state from push-on-subscribe
-		received.length = 0;
-
-		// removeTopic is called outside any batch; TEARDOWN delivers immediately.
-		hub.removeTopic("x");
-		expect(received).toContain(TEARDOWN);
-
-		unsub();
-	});
-});
-
-// ── Native backend direct tests ────────────────────────────────────────
-
-describe("NativePubSubBackend", () => {
-	it("version counter advances on create / remove only", () => {
-		const b = new NativePubSubBackend();
-		expect(b.version).toBe(0);
-
-		expect(b.createTopic("a")).toBe(true);
-		expect(b.version).toBe(1);
-
-		expect(b.createTopic("a")).toBe(false); // already exists
-		expect(b.version).toBe(1);
-
-		expect(b.createTopic("b")).toBe(true);
-		expect(b.version).toBe(2);
-
-		expect(b.removeTopic("a")).toBe(true);
-		expect(b.version).toBe(3);
-
-		expect(b.removeTopic("a")).toBe(false); // no longer exists
-		expect(b.version).toBe(3);
-	});
-
-	it("hasTopic / topicCount / topicNames reflect state", () => {
-		const b = new NativePubSubBackend();
-		b.createTopic("x");
-		b.createTopic("y");
-
-		expect(b.hasTopic("x")).toBe(true);
-		expect(b.hasTopic("missing")).toBe(false);
-		expect(b.topicCount).toBe(2);
-		expect([...b.topicNames()].sort()).toEqual(["x", "y"]);
-	});
-});
-
-// ── Pluggable backend ──────────────────────────────────────────────────
-
-describe("pubsub with user-provided backend", () => {
-	it("can plug in a custom backend implementation", () => {
-		class AuditBackend implements PubSubBackend {
-			private readonly inner = new NativePubSubBackend();
-			createLog: string[] = [];
-			removeLog: string[] = [];
-
-			get version(): number {
-				return this.inner.version;
-			}
-			get topicCount(): number {
-				return this.inner.topicCount;
-			}
-			hasTopic(name: string): boolean {
-				return this.inner.hasTopic(name);
-			}
-			topicNames(): IterableIterator<string> {
-				return this.inner.topicNames();
-			}
-			createTopic(name: string): boolean {
-				const created = this.inner.createTopic(name);
-				if (created) this.createLog.push(name);
-				return created;
-			}
-			removeTopic(name: string): boolean {
-				const removed = this.inner.removeTopic(name);
-				if (removed) this.removeLog.push(name);
-				return removed;
-			}
-		}
-
-		const backend = new AuditBackend();
-		const hub = pubsub({ backend });
-
-		hub.publish("a", 1);
-		hub.publish("b", 2);
-		hub.publish("a", 11); // re-publish, no topic create
-		hub.removeTopic("a");
-		hub.removeTopic("missing");
-
-		expect(backend.createLog).toEqual(["a", "b"]);
-		expect(backend.removeLog).toEqual(["a"]);
-	});
-});
-
-describe("pubsub DS14R2 — mutationLog", () => {
-	type AnyPubSubChange = {
-		structure: string;
-		lifecycle: string;
-		change:
-			| { kind: "publish"; value: unknown }
-			| { kind: "remove"; name: string }
-			| { kind: "ack"; count: number; cursor: number };
-	};
-	function lastLog(node: Parameters<typeof collect>[0]): AnyPubSubChange[] {
-		const { messages, unsub } = collect(node, { flat: true });
-		unsub();
-		let out: AnyPubSubChange[] = [];
-		for (const m of messages) if (m[0] === DATA) out = m[1] as AnyPubSubChange[];
-		return out;
-	}
-
-	it("absent by default; present when configured", () => {
-		expect(pubsub().mutationLog).toBeUndefined();
-		expect(pubsub({ mutationLog: true }).mutationLog).toBeDefined();
-	});
-
-	it("publish / publishMany / removeTopic append typed records", () => {
-		const hub = pubsub({ mutationLog: true });
-		hub.publish("a", 1);
-		hub.publishMany([
-			["a", 2],
-			["b", 3],
-		]);
-		hub.removeTopic("a");
-		const log = lastLog(hub.mutationLog!.entries);
-		expect(log.map((c) => c.change.kind)).toEqual(["publish", "publish", "publish", "remove"]);
-		expect(log.every((c) => c.structure === "pubsub" && c.lifecycle === "data")).toBe(true);
-		const rem = log.find((c) => c.change.kind === "remove");
-		expect(rem?.change).toMatchObject({ kind: "remove", name: "a" });
-	});
-
-	it("same-wave: a topic subscriber and a mutationLog subscriber see consistent state", () => {
-		const hub = pubsub({ mutationLog: true });
-		const topicSeen: unknown[] = [];
-		const unsubT = hub.topic("t").subscribe((msgs) => {
-			for (const m of msgs) if (m[0] === DATA) topicSeen.push(m[1]);
-		});
-		hub.publish("t", 42);
-		const log = lastLog(hub.mutationLog!.entries);
-		expect(topicSeen).toContain(42);
-		expect(log.at(-1)?.change).toMatchObject({ kind: "publish", value: 42 });
-		unsubT();
-	});
-});
diff --git a/src/__tests__/base/composition/single-from-any.test.ts b/src/__tests__/base/composition/single-from-any.test.ts
deleted file mode 100644
index dc29ba37..00000000
--- a/src/__tests__/base/composition/single-from-any.test.ts
+++ /dev/null
@@ -1,117 +0,0 @@
-import { COMPLETE, node, TEARDOWN } from "@graphrefly/pure-ts/core";
-import { describe, expect, it } from "vitest";
-import { singleFromAny, singleNodeFromAny } from "../../../base/composition/single-from-any.js";
-
-describe("singleFromAny", () => {
-	it("dedupes concurrent calls with the same key", async () => {
-		let calls = 0;
-		const fn = singleFromAny<string, string>(async (k) => {
-			calls += 1;
-			await new Promise((r) => setTimeout(r, 10));
-			return `v:${k}`;
-		});
-		const [a, b, c] = await Promise.all([fn("x"), fn("x"), fn("x")]);
-		expect(a).toBe("v:x");
-		expect(b).toBe("v:x");
-		expect(c).toBe("v:x");
-		expect(calls).toBe(1);
-	});
-
-	it("different keys invoke factory separately", async () => {
-		let calls = 0;
-		const fn = singleFromAny<string, string>(async (k) => {
-			calls += 1;
-			return k;
-		});
-		await Promise.all([fn("a"), fn("b"), fn("a")]);
-		// "a" dedupes, "b" is separate.
-		expect(calls).toBeLessThanOrEqual(2);
-	});
-
-	it("clears cache on settle so next call reinvokes", async () => {
-		let calls = 0;
-		const fn = singleFromAny<string, string>(async (k) => {
-			calls += 1;
-			return k;
-		});
-		await fn("k");
-		await fn("k");
-		expect(calls).toBe(2);
-	});
-
-	it("handles sync factory return", async () => {
-		const fn = singleFromAny<string, number>((k) => Number(k) * 2);
-		expect(await fn("5")).toBe(10);
-	});
-
-	it("propagates rejection to all concurrent callers", async () => {
-		const err = new Error("boom");
-		const fn = singleFromAny<string, string>(async () => {
-			throw err;
-		});
-		await Promise.all([expect(fn("x")).rejects.toBe(err), expect(fn("x")).rejects.toBe(err)]);
-	});
-
-	it("custom keyFn stringifies object keys", async () => {
-		let calls = 0;
-		const fn = singleFromAny<{ id: number }, string>(
-			async (k) => {
-				calls += 1;
-				return `id:${k.id}`;
-			},
-			{ keyFn: (k) => String(k.id) },
-		);
-		await Promise.all([fn({ id: 1 }), fn({ id: 1 })]);
-		expect(calls).toBe(1);
-	});
-});
-
-describe("singleNodeFromAny", () => {
-	it("returns same Node for concurrent calls with same key", () => {
-		const fn = singleNodeFromAny<string, string>(async (k) => k);
-		const n1 = fn("x");
-		const n2 = fn("x");
-		expect(n1).toBe(n2);
-	});
-
-	it("different keys produce different Nodes", () => {
-		const fn = singleNodeFromAny<string, string>(async (k) => k);
-		expect(fn("a")).not.toBe(fn("b"));
-	});
-
-	it("evicts on TEARDOWN so a DATA-only source releases (M8)", () => {
-		let calls = 0;
-		// DATA-only `state(...)` source: emits DATA on subscribe, never
-		// ERROR/COMPLETE. Pre-M8 the cache entry + watcher subscription
-		// outlived the node's teardown forever.
-		const fn = singleNodeFromAny<string, number>((k) => {
-			calls += 1;
-			return node<number>([], { initial: Number(k), name: `state_${k}` });
-		});
-		const n1 = fn("1");
-		expect(calls).toBe(1);
-		// Still alive → shared (no terminal, no teardown yet).
-		expect(fn("1")).toBe(n1);
-		expect(calls).toBe(1);
-		// Tear the shared node down. A DATA-only source never emits
-		// ERROR/COMPLETE, so TEARDOWN is the only release signal.
-		n1.down([[TEARDOWN]]);
-		// Entry evicted → next call re-invokes the factory with a fresh Node.
-		const n2 = fn("1");
-		expect(n2).not.toBe(n1);
-		expect(calls).toBe(2);
-	});
-
-	it("still evicts on terminal COMPLETE (regression guard for M8)", () => {
-		let calls = 0;
-		const fn = singleNodeFromAny<string, number>((k) => {
-			calls += 1;
-			return node<number>([], { initial: Number(k), name: `state_${k}` });
-		});
-		const n1 = fn("7");
-		expect(calls).toBe(1);
-		n1.down([[COMPLETE]]);
-		expect(fn("7")).not.toBe(n1);
-		expect(calls).toBe(2);
-	});
-});
diff --git a/src/__tests__/base/io/reactive-sink.test.ts b/src/__tests__/base/io/reactive-sink.test.ts
deleted file mode 100644
index f3a0d68f..00000000
--- a/src/__tests__/base/io/reactive-sink.test.ts
+++ /dev/null
@@ -1,500 +0,0 @@
-/**
- * Tests for reactiveSink factory (src/extra/reactive-sink.ts).
- */
-
-import { COMPLETE, DATA, ERROR, type Messages, node } from "@graphrefly/pure-ts/core";
-import { afterEach, describe, expect, it, vi } from "vitest";
-
-// Helper: SENTINEL source that never pushes on subscribe but supports .down().
-function makeSrc<T>(): { src: import("../../core/node.js").Node<T>; emit: (v: T) => void } {
-	const src = node<T>();
-	return { src, emit: (v: T) => src.down([[DATA, v]]) };
-}
-
-import { reactiveSink, type SinkFailure, type SinkTransportError } from "../../../base/io/_sink.js";
-import { constant, NS_PER_MS } from "../../../base/resilience/backoff.js";
-
-type CompanionSnap = {
-	sent: unknown[];
-	failed: Array<SinkFailure<unknown>>;
-	inFlight: number[];
-	errors: SinkTransportError[];
-	buffered: number[];
-	paused: boolean[];
-};
-
-function snapCompanions(handle: {
-	sent: { subscribe: (s: (m: Messages) => void) => () => void };
-	failed: { subscribe: (s: (m: Messages) => void) => () => void };
-	inFlight: { subscribe: (s: (m: Messages) => void) => () => void };
-	errors: { subscribe: (s: (m: Messages) => void) => () => void };
-	buffered?: { subscribe: (s: (m: Messages) => void) => () => void };
-	paused?: { subscribe: (s: (m: Messages) => void) => () => void };
-}): { snap: CompanionSnap; unsub: () => void } {
-	const snap: CompanionSnap = {
-		sent: [],
-		failed: [],
-		inFlight: [],
-		errors: [],
-		buffered: [],
-		paused: [],
-	};
-	const unsubs: Array<() => void> = [];
-	const sub = <K extends keyof CompanionSnap>(
-		node: { subscribe: (s: (m: Messages) => void) => () => void } | undefined,
-		key: K,
-		transform: (v: unknown) => CompanionSnap[K][number] | undefined,
-	) => {
-		if (!node) return;
-		unsubs.push(
-			node.subscribe((msgs) => {
-				for (const m of msgs) {
-					if (m[0] === DATA) {
-						const v = transform(m[1]);
-						if (v !== undefined) (snap[key] as unknown[]).push(v);
-					}
-				}
-			}),
-		);
-	};
-	sub(handle.sent, "sent", (v) => v);
-	sub(handle.failed, "failed", (v) => (v == null ? undefined : (v as SinkFailure<unknown>)));
-	sub(handle.inFlight, "inFlight", (v) => v as number);
-	sub(handle.errors, "errors", (v) => (v == null ? undefined : (v as SinkTransportError)));
-	sub(handle.buffered, "buffered", (v) => v as number);
-	sub(handle.paused, "paused", (v) => v as boolean);
-	return {
-		snap,
-		unsub: () => {
-			for (const u of unsubs) u();
-		},
-	};
-}
-
-describe("reactiveSink — per-record write-through", () => {
-	afterEach(() => vi.useRealTimers());
-
-	it("forwards DATA to send(), populates sent/inFlight companions", async () => {
-		const { src, emit } = makeSrc<number>();
-		const received: number[] = [];
-		const h = reactiveSink<number>(src, {
-			send: (v) => {
-				received.push(v);
-			},
-		});
-		const { snap, unsub } = snapCompanions(h);
-
-		emit(1);
-		emit(2);
-		await vi.waitFor(() => expect(received).toEqual([1, 2]));
-		expect(snap.sent).toEqual([1, 2]);
-		// inFlight goes +1 -1 per send, so end-state is 0
-		expect(snap.inFlight.at(-1)).toBe(0);
-		unsub();
-		h.dispose();
-	});
-
-	it("reports send() rejection on errors + failed (maxAttempts=1)", async () => {
-		const { src, emit } = makeSrc<number>();
-		const err = new Error("boom");
-		const h = reactiveSink<number>(src, {
-			send: () => Promise.reject(err),
-		});
-		const { snap, unsub } = snapCompanions(h);
-
-		emit(99);
-		await vi.waitFor(() => expect(snap.errors).toHaveLength(1));
-		expect(snap.errors[0].stage).toBe("send");
-		expect(snap.errors[0].error.message).toBe("boom");
-		expect(snap.errors[0].value).toBe(99);
-		expect(snap.failed).toHaveLength(1);
-		expect(snap.failed[0].attempts).toBe(1);
-		expect(snap.sent).toEqual([]);
-		unsub();
-		h.dispose();
-	});
-
-	it("retries per-record up to maxAttempts, then fails", async () => {
-		vi.useFakeTimers();
-		const { src, emit } = makeSrc<number>();
-		let attempts = 0;
-		const h = reactiveSink<number>(src, {
-			retry: { maxAttempts: 3, backoff: constant(10 * NS_PER_MS) },
-			send: () => {
-				attempts += 1;
-				return Promise.reject(new Error(`fail-${attempts}`));
-			},
-		});
-		const { snap, unsub } = snapCompanions(h);
-
-		emit(1);
-		await vi.advanceTimersByTimeAsync(50);
-		expect(attempts).toBe(3);
-		expect(snap.errors).toHaveLength(3);
-		expect(snap.failed).toHaveLength(1);
-		expect(snap.failed[0].attempts).toBe(3);
-		unsub();
-		h.dispose();
-	});
-
-	it("retries per-record and succeeds before exhaustion", async () => {
-		vi.useFakeTimers();
-		const { src, emit } = makeSrc<number>();
-		let attempts = 0;
-		const h = reactiveSink<number>(src, {
-			retry: { maxAttempts: 3, backoff: constant(0) },
-			send: () => {
-				attempts += 1;
-				if (attempts < 2) return Promise.reject(new Error("once"));
-				return Promise.resolve();
-			},
-		});
-		const { snap, unsub } = snapCompanions(h);
-
-		emit(7);
-		await vi.advanceTimersByTimeAsync(10);
-		expect(attempts).toBe(2);
-		expect(snap.sent).toEqual([7]);
-		expect(snap.failed).toEqual([]);
-		unsub();
-		h.dispose();
-	});
-
-	it("shouldRetry=false stops retries early", async () => {
-		vi.useFakeTimers();
-		const { src, emit } = makeSrc<number>();
-		let attempts = 0;
-		const h = reactiveSink<number>(src, {
-			retry: {
-				maxAttempts: 5,
-				backoff: constant(0),
-				shouldRetry: (err) => !/non-retryable/.test(err.message),
-			},
-			send: () => {
-				attempts += 1;
-				return Promise.reject(new Error("non-retryable"));
-			},
-		});
-		const { snap, unsub } = snapCompanions(h);
-
-		emit(1);
-		await vi.advanceTimersByTimeAsync(10);
-		expect(attempts).toBe(1);
-		expect(snap.failed[0].attempts).toBe(1);
-		unsub();
-		h.dispose();
-	});
-
-	it("serialize transforms value before send", async () => {
-		const { src, emit } = makeSrc<number>();
-		const received: unknown[] = [];
-		const h = reactiveSink<number>(src, {
-			serialize: (v) => `v=${v}`,
-			send: (payload) => {
-				received.push(payload);
-			},
-		});
-		const { unsub } = snapCompanions(h);
-
-		emit(5);
-		await vi.waitFor(() => expect(received).toEqual(["v=5"]));
-		unsub();
-		h.dispose();
-	});
-
-	it("onTransportError hook fires alongside errors companion", async () => {
-		const { src, emit } = makeSrc<number>();
-		const hookErrs: SinkTransportError[] = [];
-		const h = reactiveSink<number>(src, {
-			onTransportError: (e) => hookErrs.push(e),
-			send: () => Promise.reject(new Error("x")),
-		});
-		const { snap, unsub } = snapCompanions(h);
-
-		emit(1);
-		await vi.waitFor(() => expect(hookErrs).toHaveLength(1));
-		expect(hookErrs[0].stage).toBe("send");
-		expect(snap.errors).toHaveLength(1);
-		unsub();
-		h.dispose();
-	});
-
-	it("dispose fires TEARDOWN on companions", () => {
-		const { src } = makeSrc<number>();
-		const h = reactiveSink<number>(src, {
-			send: () => {},
-		});
-		// Subscribe raw to capture TEARDOWN tuples
-		const received: unknown[] = [];
-		const unsub = h.errors.subscribe((msgs) => {
-			for (const m of msgs) received.push(String(m[0]));
-		});
-		h.dispose();
-		expect(received).toContain("Symbol(graphrefly/TEARDOWN)");
-		unsub();
-	});
-});
-
-describe("reactiveSink — buffered via sendBatch", () => {
-	afterEach(() => vi.useRealTimers());
-
-	it("flushes on batchSize and delivers chunks to sendBatch", async () => {
-		const { src, emit } = makeSrc<number>();
-		const chunks: number[][] = [];
-		const h = reactiveSink<number>(src, {
-			batchSize: 3,
-			sendBatch: (chunk) => {
-				chunks.push([...chunk]);
-			},
-		});
-		const { snap, unsub } = snapCompanions(h);
-
-		emit(1);
-		emit(2);
-		expect(chunks).toEqual([]);
-		emit(3);
-		await vi.waitFor(() => expect(chunks).toEqual([[1, 2, 3]]));
-		expect(snap.sent).toEqual([1, 2, 3]);
-		unsub();
-		h.dispose();
-	});
-
-	it("flushes on flushIntervalMs timer", async () => {
-		vi.useFakeTimers();
-		const { src, emit } = makeSrc<number>();
-		const chunks: number[][] = [];
-		const h = reactiveSink<number>(src, {
-			flushIntervalMs: 100,
-			sendBatch: (chunk) => {
-				chunks.push([...chunk]);
-			},
-		});
-		const { unsub } = snapCompanions(h);
-
-		emit(1);
-		emit(2);
-		expect(chunks).toEqual([]);
-		await vi.advanceTimersByTimeAsync(150);
-		expect(chunks).toEqual([[1, 2]]);
-		unsub();
-		h.dispose();
-	});
-
-	it("flushes on tier-3 terminal (COMPLETE)", async () => {
-		const chunks: number[][] = [];
-		const src = node<number>(
-			[],
-			(_data, a) => {
-				a.emit(1);
-				a.emit(2);
-				a.down([[COMPLETE]]);
-			},
-			{ describeKind: "producer" },
-		);
-		const h = reactiveSink<number>(src, {
-			batchSize: 100,
-			flushIntervalMs: 10_000,
-			sendBatch: (chunk) => {
-				chunks.push([...chunk]);
-			},
-		});
-		const { unsub } = snapCompanions(h);
-		await vi.waitFor(() => expect(chunks).toEqual([[1, 2]]));
-		unsub();
-		h.dispose();
-	});
-
-	it("buffered companion tracks buffer length", async () => {
-		const { src, emit } = makeSrc<number>();
-		const h = reactiveSink<number>(src, {
-			batchSize: 10,
-			flushIntervalMs: 1_000,
-			sendBatch: () => {},
-		});
-		const { snap, unsub } = snapCompanions(h);
-
-		emit(1);
-		emit(2);
-		emit(3);
-		// buffered emits after each push; last value is 3 (or 0 after flush)
-		expect(snap.buffered).toContain(1);
-		expect(snap.buffered).toContain(2);
-		expect(snap.buffered).toContain(3);
-		unsub();
-		h.dispose();
-	});
-
-	it("flush() drains pending buffer and awaits in-flight", async () => {
-		const { src, emit } = makeSrc<number>();
-		const chunks: number[][] = [];
-		let resolveSend!: () => void;
-		const h = reactiveSink<number>(src, {
-			batchSize: 100,
-			flushIntervalMs: 10_000,
-			sendBatch: (chunk) =>
-				new Promise<void>((r) => {
-					chunks.push([...chunk]);
-					resolveSend = r;
-				}),
-		});
-		const { unsub } = snapCompanions(h);
-		emit(1);
-		emit(2);
-		expect(chunks).toEqual([]);
-
-		const flushP = h.flush?.();
-		// flush is async — body defers to microtask, so wait one tick before
-		// asserting the sync `chunks.push(...)` inside sendBatch has fired.
-		await Promise.resolve();
-		expect(chunks).toEqual([[1, 2]]);
-		resolveSend();
-		await flushP;
-		unsub();
-		h.dispose();
-	});
-
-	it("retries whole batch on sendBatch rejection", async () => {
-		vi.useFakeTimers();
-		const { src, emit } = makeSrc<number>();
-		let calls = 0;
-		const h = reactiveSink<number>(src, {
-			batchSize: 2,
-			retry: { maxAttempts: 3, backoff: constant(0) },
-			sendBatch: () => {
-				calls += 1;
-				if (calls < 2) return Promise.reject(new Error("boom"));
-				return Promise.resolve();
-			},
-		});
-		const { snap, unsub } = snapCompanions(h);
-
-		emit(1);
-		emit(2);
-		await vi.advanceTimersByTimeAsync(10);
-		expect(calls).toBe(2);
-		expect(snap.sent).toEqual([1, 2]);
-		unsub();
-		h.dispose();
-	});
-});
-
-describe("reactiveSink — backpressure", () => {
-	afterEach(() => vi.useRealTimers());
-
-	it("drop-oldest strategy drops oldest items at maxBuffer", async () => {
-		const { src, emit } = makeSrc<number>();
-		const chunks: number[][] = [];
-		const h = reactiveSink<number>(src, {
-			batchSize: 100,
-			flushIntervalMs: 10_000,
-			backpressure: { maxBuffer: 2, strategy: "drop-oldest" },
-			sendBatch: (chunk) => {
-				chunks.push([...chunk]);
-			},
-		});
-		const { snap, unsub } = snapCompanions(h);
-
-		emit(1);
-		emit(2);
-		emit(3); // overflow — drops 1
-		emit(4); // overflow — drops 2
-
-		// Assert paused transitioned to true while overflowing (before flush
-		// drains the buffer and flips it back to false).
-		expect(snap.paused).toContain(true);
-		await h.flush?.();
-		expect(chunks).toEqual([[3, 4]]);
-		expect(snap.failed.map((f) => f.value)).toEqual([1, 2]);
-		expect(snap.failed.every((f) => /dropped oldest/.test(f.error.message))).toBe(true);
-		unsub();
-		h.dispose();
-	});
-
-	it("drop-newest strategy rejects incoming items at maxBuffer", async () => {
-		const { src, emit } = makeSrc<number>();
-		const chunks: number[][] = [];
-		const h = reactiveSink<number>(src, {
-			batchSize: 100,
-			flushIntervalMs: 10_000,
-			backpressure: { maxBuffer: 2, strategy: "drop-newest" },
-			sendBatch: (chunk) => {
-				chunks.push([...chunk]);
-			},
-		});
-		const { snap, unsub } = snapCompanions(h);
-
-		emit(1);
-		emit(2);
-		emit(3); // overflow — drops 3
-		emit(4); // overflow — drops 4
-
-		await h.flush?.();
-		expect(chunks).toEqual([[1, 2]]);
-		expect(snap.failed.map((f) => f.value)).toEqual([3, 4]);
-		unsub();
-		h.dispose();
-	});
-
-	it("error strategy emits ERROR via errors companion on overflow", async () => {
-		const { src, emit } = makeSrc<number>();
-		const h = reactiveSink<number>(src, {
-			batchSize: 100,
-			flushIntervalMs: 10_000,
-			backpressure: { maxBuffer: 1, strategy: "error" },
-			sendBatch: () => {},
-		});
-		const { snap, unsub } = snapCompanions(h);
-
-		emit(1);
-		emit(2); // overflow
-
-		expect(snap.errors).toHaveLength(1);
-		expect(snap.errors[0].error.message).toMatch(/buffer overflow/);
-		expect(snap.failed.map((f) => f.value)).toEqual([2]);
-		unsub();
-		h.dispose();
-	});
-});
-
-describe("reactiveSink — validation", () => {
-	it("throws without send or sendBatch", () => {
-		const { src } = makeSrc<number>();
-		expect(() => reactiveSink<number>(src, {} as never)).toThrow(/send.*sendBatch/);
-	});
-
-	// F-B-class smell sweep (2026-05-18) — F-SINK: a configured `backpressure`
-	// must seed an explicit `maxBuffer` (fail-loud per D4, mirroring rateLimiter).
-	it("F-SINK: backpressure without maxBuffer throws (fail-loud, no silent unbounded)", () => {
-		const { src } = makeSrc<number>();
-		expect(() =>
-			reactiveSink<number>(src, {
-				backpressure: { strategy: "drop-oldest" } as never,
-				sendBatch: () => {},
-			}),
-		).toThrow(/backpressure requires explicit maxBuffer/);
-	});
-
-	it("F-SINK: backpressure with maxBuffer: Infinity is an explicit unbounded opt-in", () => {
-		const { src } = makeSrc<number>();
-		expect(() =>
-			reactiveSink<number>(src, {
-				backpressure: { maxBuffer: Number.POSITIVE_INFINITY, strategy: "drop-oldest" },
-				sendBatch: () => {},
-			}),
-		).not.toThrow();
-	});
-
-	it("F-SINK: non-integer / <1 maxBuffer throws", () => {
-		const { src } = makeSrc<number>();
-		expect(() =>
-			reactiveSink<number>(src, {
-				backpressure: { maxBuffer: 0, strategy: "drop-oldest" },
-				sendBatch: () => {},
-			}),
-		).toThrow(/positive integer/);
-	});
-});
-
-// ERROR import keeps test compiling without unused-var warning even when the
-// matrix grows — referenced here to preserve the symbol.
-void ERROR;
diff --git a/src/__tests__/base/io/sources.http.test.ts b/src/__tests__/base/io/sources.http.test.ts
deleted file mode 100644
index 4670c092..00000000
--- a/src/__tests__/base/io/sources.http.test.ts
+++ /dev/null
@@ -1,179 +0,0 @@
-import { DATA, node } from "@graphrefly/pure-ts/core";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { fromHTTP, toHTTP } from "../../../base/io/http.js";
-
-describe("fromHTTP", () => {
-	const originalFetch = global.fetch;
-
-	beforeEach(() => {
-		global.fetch = vi.fn();
-	});
-
-	afterEach(() => {
-		global.fetch = originalFetch;
-		vi.useRealTimers();
-	});
-
-	it("fetches data and caches it without completing (default)", async () => {
-		const mockData = { foo: "bar" };
-		(global.fetch as any).mockResolvedValue({
-			ok: true,
-			json: async () => mockData,
-		});
-
-		const bundle = fromHTTP("https://example.com");
-		const unsub = bundle.node.subscribe(() => {});
-
-		await vi.waitUntil(() => bundle.node.cache !== undefined);
-
-		expect(bundle.node.cache).toEqual(mockData);
-		// Default does NOT emit COMPLETE — node stays live so late subscribers
-		// get the cached DATA via push-on-subscribe.
-		expect(bundle.status.cache).toBe("running");
-		expect(bundle.fetchCount.cache).toBe(1);
-		expect(bundle.lastUpdated.cache).toBeGreaterThan(0);
-		// `fetched` flips true on first successful fetch — the "fetch done"
-		// signal users reach for when `status` stays "running" under the
-		// cached default.
-		expect(bundle.fetched.cache).toBe(true);
-		expect(global.fetch).toHaveBeenCalledWith("https://example.com", expect.any(Object));
-
-		// Late subscriber receives cached DATA.
-		const late: unknown[] = [];
-		const unsubLate = bundle.node.subscribe((msgs) => {
-			for (const m of msgs) if (String(m[0]) === "Symbol(graphrefly/DATA)") late.push(m[1]);
-		});
-		expect(late).toEqual([mockData]);
-		expect(global.fetch).toHaveBeenCalledTimes(1); // no refetch
-		unsubLate();
-		unsub();
-	});
-
-	it("completeAfterFetch: true emits COMPLETE after first DATA", async () => {
-		const mockData = { foo: "bar" };
-		(global.fetch as any).mockResolvedValue({
-			ok: true,
-			json: async () => mockData,
-		});
-
-		const bundle = fromHTTP("https://example.com", { completeAfterFetch: true });
-		const unsub = bundle.node.subscribe(() => {});
-		await vi.waitUntil(() => bundle.status.cache === "completed");
-		expect(bundle.node.cache).toEqual(mockData);
-		expect(bundle.status.cache).toBe("completed");
-		unsub();
-	});
-
-	it("handles non-ok responses as ERROR", async () => {
-		(global.fetch as any).mockResolvedValue({
-			ok: false,
-			status: 404,
-			statusText: "Not Found",
-		});
-
-		const bundle = fromHTTP("https://example.com");
-		const unsub = bundle.node.subscribe(() => {});
-
-		await vi.waitUntil(() => bundle.status.cache === "errored");
-
-		expect(bundle.status.cache).toBe("errored");
-		expect(bundle.error.cache).toBeInstanceOf(Error);
-		expect((bundle.error.cache as Error).message).toContain("HTTP 404");
-		unsub();
-	});
-
-	it("handles fetch rejection as ERROR", async () => {
-		(global.fetch as any).mockRejectedValue(new Error("Network failure"));
-
-		const bundle = fromHTTP("https://example.com");
-		const unsub = bundle.node.subscribe(() => {});
-
-		await vi.waitUntil(() => bundle.status.cache === "errored");
-
-		expect(bundle.error.cache).toBeInstanceOf(Error);
-		expect((bundle.error.cache as Error).message).toBe("Network failure");
-		// `fetched` stays false when the fetch errored — only success flips it.
-		expect(bundle.fetched.cache).toBe(false);
-		unsub();
-	});
-
-	it("fetched stays true across resubscribes (cumulative semantics)", async () => {
-		const mockData = { ok: 1 };
-		(global.fetch as any).mockResolvedValue({
-			ok: true,
-			json: async () => mockData,
-		});
-
-		const bundle = fromHTTP("https://example.com", { refetchOnSubscribe: true });
-		const unsub1 = bundle.node.subscribe(() => {});
-		await vi.waitUntil(() => bundle.fetched.cache === true);
-		expect(bundle.fetched.cache).toBe(true);
-		unsub1();
-
-		// Resubscribe — `fetched` must stay true across activations.
-		const unsub2 = bundle.node.subscribe(() => {});
-		expect(bundle.fetched.cache).toBe(true);
-		unsub2();
-	});
-});
-
-describe("toHTTP", () => {
-	const originalFetch = global.fetch;
-	beforeEach(() => {
-		global.fetch = vi.fn();
-	});
-	afterEach(() => {
-		global.fetch = originalFetch;
-	});
-
-	it("POSTs each DATA as a JSON body by default", async () => {
-		(global.fetch as any).mockResolvedValue({
-			ok: true,
-			status: 200,
-			arrayBuffer: async () => new ArrayBuffer(0),
-		});
-		const src = node<{ v: number }>();
-		const handle = toHTTP(src, "https://example.com/ingest");
-		src.down([[DATA, { v: 1 }]]);
-		src.down([[DATA, { v: 2 }]]);
-		await vi.waitFor(() => expect((global.fetch as any).mock.calls.length).toBe(2));
-		const firstCall = (global.fetch as any).mock.calls[0];
-		expect(firstCall[0]).toBe("https://example.com/ingest");
-		expect(firstCall[1].method).toBe("POST");
-		expect(firstCall[1].body).toBe(JSON.stringify({ v: 1 }));
-		handle.dispose();
-	});
-
-	it("batches into a single JSON array request", async () => {
-		(global.fetch as any).mockResolvedValue({
-			ok: true,
-			status: 200,
-			arrayBuffer: async () => new ArrayBuffer(0),
-		});
-		const src = node<number>();
-		const handle = toHTTP(src, "https://example.com/bulk", { batchSize: 3 });
-		src.down([[DATA, 1]]);
-		src.down([[DATA, 2]]);
-		src.down([[DATA, 3]]);
-		await vi.waitFor(() => expect((global.fetch as any).mock.calls.length).toBe(1));
-		expect((global.fetch as any).mock.calls[0][1].body).toBe("[1,2,3]");
-		handle.dispose();
-	});
-
-	it("surfaces non-ok responses as send errors", async () => {
-		(global.fetch as any).mockResolvedValue({
-			ok: false,
-			status: 500,
-			statusText: "Server Error",
-		});
-		const src = node<number>();
-		const errs: unknown[] = [];
-		const handle = toHTTP(src, "https://example.com/bad", {
-			onTransportError: (e) => errs.push(e),
-		});
-		src.down([[DATA, 1]]);
-		await vi.waitFor(() => expect(errs).toHaveLength(1));
-		expect((errs[0] as { error: Error }).error.message).toContain("HTTP 500");
-		handle.dispose();
-	});
-});
diff --git a/src/__tests__/base/mutation/mutation.test.ts b/src/__tests__/base/mutation/mutation.test.ts
deleted file mode 100644
index 189ec79f..00000000
--- a/src/__tests__/base/mutation/mutation.test.ts
+++ /dev/null
@@ -1,517 +0,0 @@
-import { node } from "@graphrefly/pure-ts/core";
-import { Graph } from "@graphrefly/pure-ts/graph";
-import { describe, expect, it, vi } from "vitest";
-import {
-	type BaseAuditRecord,
-	bumpCursor,
-	createAuditLog,
-	mutate,
-	type ReadonlyAuditLog,
-	readonlyAuditLog,
-} from "../../../base/mutation/index.js";
-
-interface TestRecord extends BaseAuditRecord {
-	readonly action: "set" | "fail";
-	readonly key?: string;
-	readonly errorType?: string;
-}
-
-function makeAuditLog() {
-	const g = new Graph("test");
-	const audit = createAuditLog<TestRecord>({ name: "events", graph: g });
-	// Activate the entries node so .cache reflects appends synchronously.
-	const unsub = audit.entries.subscribe(() => undefined);
-	return { audit, dispose: unsub };
-}
-
-describe("mutate frame:inline", () => {
-	it("happy path: returns the action result and appends a success record", () => {
-		const { audit, dispose } = makeAuditLog();
-		const setKey = mutate((key: string, value: number) => `${key}=${value}`, {
-			frame: "inline",
-			log: audit,
-			onSuccessRecord: ([key], _r, m) => ({ action: "set" as const, key, t_ns: m.t_ns }),
-		});
-
-		const result = setKey("foo", 1);
-		expect(result).toBe("foo=1");
-
-		const entries = audit.entries.cache as readonly TestRecord[];
-		expect(entries).toHaveLength(1);
-		expect(entries[0]!.action).toBe("set");
-		expect(entries[0]!.key).toBe("foo");
-		expect(typeof entries[0]!.t_ns).toBe("number");
-
-		dispose();
-	});
-
-	it("freeze: true (default) freezes object args inside the action body", () => {
-		// Asserts only the contract: the action sees frozen args. Whether
-		// `deepFreeze` mutates the caller's object in-place or copies first
-		// is an implementation detail; don't lock that in.
-		const { audit, dispose } = makeAuditLog();
-		const seenFrozen: boolean[] = [];
-		const op = mutate(
-			(arg: { v: number }) => {
-				seenFrozen.push(Object.isFrozen(arg));
-				return arg.v;
-			},
-			{
-				frame: "inline",
-				log: audit,
-				onSuccessRecord: (_a, _r, m) => ({ action: "set" as const, t_ns: m.t_ns }),
-			},
-		);
-		op({ v: 1 });
-		expect(seenFrozen[0]).toBe(true);
-		dispose();
-	});
-
-	it("freeze: false opt-out leaves args mutable in the action body", () => {
-		const { audit, dispose } = makeAuditLog();
-		const seenFrozen: boolean[] = [];
-		const op = mutate(
-			(arg: { v: number }) => {
-				seenFrozen.push(Object.isFrozen(arg));
-				arg.v = 42;
-				return arg.v;
-			},
-			{
-				frame: "inline",
-				log: audit,
-				freeze: false,
-				onSuccessRecord: (_a, _r, m) => ({ action: "set" as const, t_ns: m.t_ns }),
-			},
-		);
-		const input = { v: 1 };
-		const result = op(input);
-		expect(seenFrozen[0]).toBe(false);
-		expect(result).toBe(42);
-		expect(input.v).toBe(42);
-		dispose();
-	});
-
-	it("throw path: appends a failure record with errorType and rethrows", () => {
-		const { audit, dispose } = makeAuditLog();
-		class MyError extends Error {
-			override name = "MyError";
-		}
-		const op = mutate(
-			() => {
-				throw new MyError("boom");
-			},
-			{
-				frame: "inline",
-				log: audit,
-				onSuccessRecord: (_a, _r, m) => ({ action: "set" as const, t_ns: m.t_ns }),
-				onFailureRecord: (_a, _err, m) => ({
-					action: "fail" as const,
-					t_ns: m.t_ns,
-					errorType: m.errorType,
-				}),
-			},
-		);
-
-		expect(() => op()).toThrow(MyError);
-		const entries = audit.entries.cache as readonly TestRecord[];
-		expect(entries).toHaveLength(1);
-		expect(entries[0]!.action).toBe("fail");
-		expect(entries[0]!.errorType).toBe("MyError");
-		dispose();
-	});
-
-	it("seq cursor: advances on each call; substrate-tier — bump persists on throw", () => {
-		const { audit, dispose } = makeAuditLog();
-		const cursor = node<number>([], { name: "seq", initial: 0 });
-		const sub = cursor.subscribe(() => undefined);
-		let callIndex = 0;
-		const op = mutate(
-			() => {
-				callIndex += 1;
-				if (callIndex === 2) throw new TypeError("fail-second");
-				return callIndex;
-			},
-			{
-				frame: "inline",
-				log: audit,
-				seq: cursor,
-				onSuccessRecord: (_a, _r, m) => ({ action: "set" as const, t_ns: m.t_ns, seq: m.seq }),
-				onFailureRecord: (_a, _e, m) => ({
-					action: "fail" as const,
-					t_ns: m.t_ns,
-					seq: m.seq,
-					errorType: m.errorType,
-				}),
-			},
-		);
-
-		op();
-		expect(cursor.cache).toBe(1);
-
-		expect(() => op()).toThrow(TypeError);
-		// Substrate-tier: no batch frame, so the seq bump persists even though the
-		// action threw. The failure record stamps the same seq so audit consumers
-		// see a contiguous sequence (1, 2, 3, ...).
-		expect(cursor.cache).toBe(2);
-
-		op();
-		expect(cursor.cache).toBe(3);
-
-		const entries = audit.entries.cache as readonly TestRecord[];
-		expect(entries.map((e) => e.seq)).toEqual([1, 2, 3]);
-		expect(entries.map((e) => e.action)).toEqual(["set", "fail", "set"]);
-
-		sub();
-		dispose();
-	});
-
-	it("handlerVersion is stamped onto every record", () => {
-		const { audit, dispose } = makeAuditLog();
-		const op = mutate((key: string) => key, {
-			frame: "inline",
-			log: audit,
-			handlerVersion: { id: "h1", version: "v1" },
-			onSuccessRecord: ([key], _r, m) => ({ action: "set" as const, key, t_ns: m.t_ns }),
-		});
-		op("x");
-		const entries = audit.entries.cache as readonly TestRecord[];
-		expect(entries[0]!.handlerVersion).toEqual({ id: "h1", version: "v1" });
-		dispose();
-	});
-
-	it("undefined record from builder skips the append", () => {
-		const { audit, dispose } = makeAuditLog();
-		const op = mutate(() => undefined, {
-			frame: "inline",
-			log: audit,
-			onSuccessRecord: () => undefined,
-		});
-		op();
-		expect(audit.entries.cache as readonly TestRecord[]).toHaveLength(0);
-		dispose();
-	});
-
-	// Tier 8 γ-0: audit-optional opt-in.
-	it("audit omitted: still freezes / re-throws / advances seq, but skips audit emission", () => {
-		const cursor = node<number>([], { name: "seq", initial: 0 });
-		const sub = cursor.subscribe(() => undefined);
-		const seenFrozen: boolean[] = [];
-
-		const op = mutate(
-			(arg: { v: number }) => {
-				seenFrozen.push(Object.isFrozen(arg));
-				return arg.v;
-			},
-			{ frame: "inline", seq: cursor }, // no log, no onSuccessRecord/onFailureRecord
-		);
-
-		// Freeze contract preserved.
-		op({ v: 1 });
-		expect(seenFrozen[0]).toBe(true);
-		// seq advanced even without log.
-		expect(cursor.cache).toBe(1);
-
-		// Throw still re-throws — and no record is emitted (there is no log).
-		const throwingOp = mutate(
-			() => {
-				throw new Error("boom");
-			},
-			{ frame: "inline", seq: cursor },
-		);
-		expect(() => throwingOp()).toThrow(/boom/);
-		// seq advanced once more for the failed call (inline frame is no-batch).
-		expect(cursor.cache).toBe(2);
-
-		sub();
-	});
-});
-
-describe("mutate frame:transactional", () => {
-	it("success: appends success record with stamped seq and handlerVersion", () => {
-		const { audit, dispose } = makeAuditLog();
-		const cursor = node<number>([], { name: "seq", initial: 0 });
-		const sub = cursor.subscribe(() => undefined);
-
-		const op = mutate((key: string) => key.toUpperCase(), {
-			frame: "transactional",
-			log: audit,
-			seq: cursor,
-			handlerVersion: { id: "h", version: 1 },
-			onSuccessRecord: ([key], _result, m) =>
-				({ action: "set" as const, key, t_ns: m.t_ns, seq: m.seq }) satisfies TestRecord,
-			onFailureRecord: (_a, _e, m) => ({
-				action: "fail" as const,
-				t_ns: m.t_ns,
-				seq: m.seq,
-				errorType: m.errorType,
-			}),
-		});
-
-		const result = op("foo");
-		expect(result).toBe("FOO");
-		const entries = audit.entries.cache as readonly TestRecord[];
-		expect(entries).toHaveLength(1);
-		expect(entries[0]!.action).toBe("set");
-		expect(entries[0]!.seq).toBe(1);
-		expect(entries[0]!.handlerVersion).toEqual({ id: "h", version: 1 });
-
-		sub();
-		dispose();
-	});
-
-	it("throw: appends failure record outside the rolled-back batch frame", () => {
-		const { audit, dispose } = makeAuditLog();
-		const cursor = node<number>([], { name: "seq", initial: 0 });
-		const sub = cursor.subscribe(() => undefined);
-
-		const op = mutate(
-			() => {
-				throw new TypeError("nope");
-			},
-			{
-				frame: "transactional",
-				log: audit,
-				seq: cursor,
-				onSuccessRecord: (_a, _r, m) => ({ action: "set" as const, t_ns: m.t_ns, seq: m.seq }),
-				onFailureRecord: (_a, _e, m) => ({
-					action: "fail" as const,
-					t_ns: m.t_ns,
-					seq: m.seq,
-					errorType: m.errorType,
-				}),
-			},
-		);
-
-		expect(() => op()).toThrow(TypeError);
-		// Failure record was committed outside the batch's rolled-back frame, so
-		// it persists even though the action threw.
-		const entries = audit.entries.cache as readonly TestRecord[];
-		expect(entries).toHaveLength(1);
-		expect(entries[0]!.action).toBe("fail");
-		expect(entries[0]!.errorType).toBe("TypeError");
-		// The failure record stamps the seq captured during the batch.
-		expect(entries[0]!.seq).toBe(1);
-
-		sub();
-		dispose();
-	});
-
-	it("throw: the failure record is NOT itself swallowed by the batch rollback", () => {
-		// Sanity check — mutate(frame:transactional) must still call
-		// `appendAudit(onFailureRecord, ...)` AFTER the batch rejects, not inside it.
-		// Validates the captureSet path in the catch block.
-		const { audit, dispose } = makeAuditLog();
-		const op = mutate(
-			() => {
-				throw new Error("e");
-			},
-			{
-				frame: "transactional",
-				log: audit,
-				onFailureRecord: (_a, _e, m) => ({
-					action: "fail" as const,
-					t_ns: m.t_ns,
-					errorType: m.errorType,
-				}),
-			},
-		);
-
-		expect(() => op()).toThrow(/e/);
-		expect(audit.entries.cache as readonly TestRecord[]).toHaveLength(1);
-		dispose();
-	});
-
-	// Tier 8 γ-0: log-optional opt-in.
-	it("log omitted: re-throws and freezes args, but skips record emission", () => {
-		// mutate(frame:transactional) without log still opens a batch frame,
-		// freezes args, advances seq, and re-throws.
-		const cursor = node<number>([], { name: "c", initial: 0 });
-		const sub = cursor.subscribe(() => undefined);
-		const seenFrozen: boolean[] = [];
-
-		const op = mutate(
-			(arg: { v: number }) => {
-				seenFrozen.push(Object.isFrozen(arg));
-				return arg.v;
-			},
-			{ frame: "transactional", seq: cursor }, // no log
-		);
-
-		op({ v: 1 });
-		expect(seenFrozen[0]).toBe(true);
-
-		// Throw still propagates without a log.
-		const throwingOp = mutate(
-			() => {
-				throw new Error("nope");
-			},
-			{ frame: "transactional", seq: cursor }, // no log
-		);
-		expect(() => throwingOp()).toThrow(/nope/);
-
-		sub();
-	});
-
-	it("down hook fires on throw after batch rollback", () => {
-		const { audit, dispose } = makeAuditLog();
-		let downCalled = false;
-		let downArgs: unknown[] = [];
-
-		const op = mutate(
-			{
-				up: (_key: string) => {
-					throw new Error("fail");
-				},
-				down: (key: string) => {
-					downCalled = true;
-					downArgs = [key];
-				},
-			},
-			{
-				frame: "transactional",
-				log: audit,
-				onFailureRecord: (_a, _e, m) => ({
-					action: "fail" as const,
-					t_ns: m.t_ns,
-					errorType: m.errorType,
-				}),
-			},
-		);
-
-		expect(() => op("test-key")).toThrow(/fail/);
-		expect(downCalled).toBe(true);
-		expect(downArgs).toEqual(["test-key"]);
-		// Failure record still persists
-		expect(audit.entries.cache as readonly TestRecord[]).toHaveLength(1);
-		dispose();
-	});
-});
-
-describe("imperative-audit / bumpCursor", () => {
-	it("emits DIRTY then DATA(next) and returns the new value", () => {
-		const cursor = node<number>([], { name: "c", initial: 5 });
-		const sub = cursor.subscribe(() => undefined);
-		const next = bumpCursor(cursor);
-		expect(next).toBe(6);
-		expect(cursor.cache).toBe(6);
-		sub();
-	});
-
-	it("starts from 0 when the cursor cache is undefined", () => {
-		const cursor = node<number>([], { name: "c", initial: undefined as unknown as number });
-		const sub = cursor.subscribe(() => undefined);
-		const next = bumpCursor(cursor);
-		expect(next).toBe(1);
-		sub();
-	});
-
-	it("updates cache even with no subscribers (substrate before consumers attach)", () => {
-		// JobQueueGraph.enqueue and similar primitives may bump the seq cursor
-		// before any consumer attaches. The contract: `bumpCursor` updates
-		// `cursor.cache` regardless of subscriber count.
-		const cursor = node<number>([], { name: "c", initial: 0 });
-		const next = bumpCursor(cursor);
-		expect(next).toBe(1);
-		expect(cursor.cache).toBe(1);
-	});
-
-	it("resets to 0 on NaN / non-finite / non-numeric cache (corrupted state)", () => {
-		const nanCursor = node<number>([], { name: "nan", initial: Number.NaN });
-		nanCursor.subscribe(() => undefined);
-		expect(bumpCursor(nanCursor)).toBe(1);
-
-		const infCursor = node<number>([], { name: "inf", initial: Number.POSITIVE_INFINITY });
-		infCursor.subscribe(() => undefined);
-		expect(bumpCursor(infCursor)).toBe(1);
-
-		const stringCursor = node<number>([], { name: "str", initial: "oops" as unknown as number });
-		stringCursor.subscribe(() => undefined);
-		expect(bumpCursor(stringCursor)).toBe(1);
-	});
-
-	it("EH-12: warns once per cursor on silent reset from non-numeric cache", () => {
-		const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => undefined);
-		try {
-			const cursor = node<number>([], { name: "warn", initial: "bad" as unknown as number });
-			cursor.subscribe(() => undefined);
-			// First bump on a malformed cache should warn.
-			expect(bumpCursor(cursor)).toBe(1);
-			expect(warnSpy).toHaveBeenCalledTimes(1);
-			expect(String(warnSpy.mock.calls[0]?.[0] ?? "")).toMatch(/non-numeric/);
-			// Second bump (now numeric) is silent.
-			expect(bumpCursor(cursor)).toBe(2);
-			expect(warnSpy).toHaveBeenCalledTimes(1);
-		} finally {
-			warnSpy.mockRestore();
-		}
-	});
-
-	it("EH-12: undefined cache (substrate-not-yet-emitted) does NOT warn", () => {
-		const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => undefined);
-		try {
-			// node<number>([], { initial: undefined as unknown }) treats the seed as the SENTINEL —
-			// `cache` is `undefined`. This is the legitimate "no DATA yet" branch
-			// and should not log; only string/NaN/Infinity-style corruption does.
-			const cursor = node<number>([], { name: "fresh", initial: undefined as unknown as number });
-			cursor.subscribe(() => undefined);
-			expect(bumpCursor(cursor)).toBe(1);
-			expect(warnSpy).not.toHaveBeenCalled();
-		} finally {
-			warnSpy.mockRestore();
-		}
-	});
-});
-
-describe("readonlyAuditLog (M7 — shared .audit read-only view)", () => {
-	it("shares the underlying log's reactive surface (zero-copy reads)", () => {
-		const { audit, dispose } = makeAuditLog();
-		const view = readonlyAuditLog(audit);
-		audit.append({ action: "set", key: "k", t_ns: 1n, seq: 0 });
-
-		// Read surface delegates live to the underlying log (same nodes).
-		expect(view.entries).toBe(audit.entries);
-		expect(view.size).toBe(audit.size);
-		expect(view.size).toBe(1);
-		expect(view.at(0)).toEqual(audit.at(0));
-		expect(view.lastValue).toBe(audit.lastValue);
-		expect(view.mutationLog).toBe(audit.mutationLog); // undefined here — preserved
-		dispose();
-	});
-
-	it("is frozen and exposes no mutators (cannot mutate the underlying log via the alias)", () => {
-		const { audit, dispose } = makeAuditLog();
-		const view: ReadonlyAuditLog<TestRecord> = readonlyAuditLog(audit);
-
-		expect(view).not.toBe(audit);
-		expect(Object.isFrozen(view)).toBe(true);
-		for (const mutator of [
-			"append",
-			"appendMany",
-			"clear",
-			"trimHead",
-			"attach",
-			"attachStorage",
-			"dispose",
-			"disposeAllViews",
-		]) {
-			expect(mutator in view).toBe(false);
-		}
-		dispose();
-	});
-
-	it("scan/view/withLatest stay bound to the underlying log", () => {
-		const { audit, dispose } = makeAuditLog();
-		const view = readonlyAuditLog(audit);
-		audit.append({ action: "set", key: "a", t_ns: 1n, seq: 0 });
-		audit.append({ action: "fail", key: "b", t_ns: 2n, seq: 1 });
-
-		// scan's generic survives `.bind` and folds over the live log.
-		const count = view.scan(0, (acc) => acc + 1);
-		const unsub = count.subscribe(() => undefined);
-		expect(count.cache).toBe(2);
-		audit.append({ action: "set", key: "c", t_ns: 3n, seq: 2 });
-		expect(count.cache).toBe(3);
-		unsub();
-		dispose();
-	});
-});
diff --git a/src/__tests__/base/sources/node/sources-process.test.ts b/src/__tests__/base/sources/node/sources-process.test.ts
deleted file mode 100644
index a2ddf338..00000000
--- a/src/__tests__/base/sources/node/sources-process.test.ts
+++ /dev/null
@@ -1,324 +0,0 @@
-/**
- * Tests for `fromSpawn` and `runProcess` — Node-only child-process reactive sources.
- *
- * Covers:
- *   - happy path: runProcess stdout + exit code 0
- *   - stderr capture + non-zero exit code
- *   - spawn error (ENOENT) → ERROR message
- *   - fromSpawn discriminated stream: stdout events then exit event
- *   - abort via opts.signal → SIGTERM, COMPLETE within timeout
- *   - producer teardown kills subprocess (marker-file approach)
- *   - large stdout buffering (regression for exit vs close)
- *   - concurrent subscribers share a single subprocess (multicast)
- */
-
-import { existsSync, unlinkSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { COMPLETE, DATA, ERROR } from "@graphrefly/pure-ts/core";
-import { describe, expect, it } from "vitest";
-import { fromSpawn, runProcess } from "../../../../base/sources/node/process.js";
-
-// ---------------------------------------------------------------------------
-// Helper: collect all messages until COMPLETE or ERROR, with timeout.
-// ---------------------------------------------------------------------------
-type AnyMsg = [number, unknown];
-
-async function collectUntilDone<_T>(
-	node: ReturnType<typeof fromSpawn> | ReturnType<typeof runProcess>,
-	timeoutMs = 5000,
-): Promise<AnyMsg[]> {
-	const collected: AnyMsg[] = [];
-	return new Promise((resolve, reject) => {
-		let resolved = false;
-		// no-op default — replaced before any synchronous terminal can fire
-		let unsub = (): void => {};
-		const timer = setTimeout(() => {
-			if (resolved) return;
-			resolved = true;
-			unsub();
-			reject(
-				new Error(
-					`collectUntilDone: no COMPLETE/ERROR within ${timeoutMs}ms — possible subprocess leak`,
-				),
-			);
-		}, timeoutMs);
-		const finish = (action: () => void): void => {
-			if (resolved) return;
-			resolved = true;
-			clearTimeout(timer);
-			unsub();
-			action();
-		};
-		unsub = node.subscribe((batch) => {
-			for (const m of batch) {
-				collected.push(m as AnyMsg);
-				if (m[0] === COMPLETE) {
-					finish(() => resolve(collected));
-					return;
-				}
-				if (m[0] === ERROR) {
-					finish(() => resolve(collected));
-					return;
-				}
-			}
-		});
-	});
-}
-
-// ---------------------------------------------------------------------------
-// runProcess — happy path
-// ---------------------------------------------------------------------------
-
-describe("runProcess — happy path", () => {
-	it("emits stdout, exitCode 0, signal null", async () => {
-		const n = runProcess("node", ["-e", "process.stdout.write('hi')"]);
-		const msgs = await collectUntilDone(n);
-
-		const dataMsg = msgs.find((m) => m[0] === DATA);
-		expect(dataMsg).toBeDefined();
-		const result = dataMsg![1] as {
-			stdout: string;
-			stderr: string;
-			exitCode: number | null;
-			signal: NodeJS.Signals | null;
-		};
-		expect(result.stdout).toBe("hi");
-		expect(result.stderr).toBe("");
-		expect(result.exitCode).toBe(0);
-		expect(result.signal).toBeNull();
-
-		expect(msgs.some((m) => m[0] === COMPLETE)).toBe(true);
-	});
-});
-
-// ---------------------------------------------------------------------------
-// runProcess — stderr capture + non-zero exit
-// ---------------------------------------------------------------------------
-
-describe("runProcess — stderr capture", () => {
-	it("captures stderr and non-zero exit code", async () => {
-		const n = runProcess("node", ["-e", "process.stderr.write('warn'); process.exit(2)"]);
-		const msgs = await collectUntilDone(n);
-
-		const dataMsg = msgs.find((m) => m[0] === DATA);
-		expect(dataMsg).toBeDefined();
-		const result = dataMsg![1] as {
-			stdout: string;
-			stderr: string;
-			exitCode: number | null;
-			signal: NodeJS.Signals | null;
-		};
-		expect(result.stderr).toBe("warn");
-		expect(result.exitCode).toBe(2);
-	});
-});
-
-// ---------------------------------------------------------------------------
-// fromSpawn — spawn error (ENOENT)
-// ---------------------------------------------------------------------------
-
-describe("fromSpawn — spawn error", () => {
-	it("emits ERROR when command does not exist", async () => {
-		const n = fromSpawn("definitely-not-a-real-command-xyz-abc-123", []);
-		const msgs = await collectUntilDone(n);
-
-		const errMsg = msgs.find((m) => m[0] === ERROR);
-		expect(errMsg).toBeDefined();
-		// The error should be a Node.js spawn error (ENOENT)
-		expect(errMsg![1]).toBeInstanceOf(Error);
-	});
-});
-
-// ---------------------------------------------------------------------------
-// fromSpawn — discriminated stream
-// ---------------------------------------------------------------------------
-
-describe("fromSpawn — discriminated stream", () => {
-	it("emits stdout events then exit event with code 0", async () => {
-		const n = fromSpawn("node", ["-e", "process.stdout.write('hello'); process.exit(0)"]);
-		const msgs = await collectUntilDone(n);
-
-		const dataMsgs = msgs.filter((m) => m[0] === DATA);
-		const stdoutEvents = dataMsgs.filter((m) => (m[1] as { kind: string }).kind === "stdout");
-		const exitEvents = dataMsgs.filter((m) => (m[1] as { kind: string }).kind === "exit");
-
-		expect(stdoutEvents.length).toBeGreaterThanOrEqual(1);
-		expect(exitEvents).toHaveLength(1);
-		const exit = exitEvents[0]![1] as {
-			kind: string;
-			code: number | null;
-			signal: NodeJS.Signals | null;
-		};
-		expect(exit.code).toBe(0);
-		expect(exit.signal).toBeNull();
-		// stdout must come before exit in the message sequence
-		const stdoutIdx = msgs.findIndex(
-			(m) => m[0] === DATA && (m[1] as { kind: string }).kind === "stdout",
-		);
-		const exitIdx = msgs.findIndex(
-			(m) => m[0] === DATA && (m[1] as { kind: string }).kind === "exit",
-		);
-		expect(stdoutIdx).toBeLessThan(exitIdx);
-	});
-});
-
-// ---------------------------------------------------------------------------
-// Abort via opts.signal (macOS/Linux only — Windows signal behavior differs)
-// ---------------------------------------------------------------------------
-
-describe("runProcess — abort via opts.signal", () => {
-	it("SIGTERM kills the subprocess when signal is aborted (non-Windows)", {
-		skip: process.platform === "win32",
-	}, async () => {
-		const ac = new AbortController();
-		const n = runProcess("node", ["-e", "setTimeout(() => {}, 60000)"], {
-			signal: ac.signal,
-		});
-
-		// Start collecting but don't await immediately — we want to abort.
-		const collectPromise = collectUntilDone(n, 3000);
-
-		// Give the process time to start, then abort.
-		await new Promise((r) => setTimeout(r, 50));
-		ac.abort();
-
-		const msgs = await collectPromise;
-
-		// After abort, Node's child_process sends SIGTERM and emits an error
-		// (AbortError) before the process exits — OR the process gets SIGTERM
-		// and emits exit with signal "SIGTERM". Either shape is acceptable.
-		const hasError = msgs.some((m) => m[0] === ERROR);
-		const hasExitWithSignal = msgs.some(
-			(m) =>
-				m[0] === DATA &&
-				(m[1] as { kind?: string; signal?: string }).kind === "exit" &&
-				(m[1] as { signal?: string }).signal != null,
-		);
-		// One of the two terminal paths must have fired
-		expect(hasError || hasExitWithSignal).toBe(true);
-	});
-});
-
-// ---------------------------------------------------------------------------
-// P7 — Producer teardown kills subprocess (marker-file approach)
-// ---------------------------------------------------------------------------
-
-describe("fromSpawn — producer teardown", () => {
-	it("kills subprocess on unsubscribe (verified via marker file absence)", {
-		skip: process.platform === "win32",
-	}, async () => {
-		const markerPath = join(
-			tmpdir(),
-			`graphrefly-spawn-test-${Date.now()}-${Math.random().toString(36).slice(2)}.marker`,
-		);
-		// Cleanup if a previous run leaked.
-		if (existsSync(markerPath)) unlinkSync(markerPath);
-		try {
-			// Child writes the marker file 200ms after spawn — long enough for us
-			// to unsub before it fires.
-			const node = fromSpawn("node", [
-				"-e",
-				`setTimeout(() => { require("fs").writeFileSync(${JSON.stringify(markerPath)}, "x"); }, 200)`,
-			]);
-			const unsub = node.subscribe(() => {});
-			// Give spawn ~50ms to actually start, then unsub.
-			await new Promise((r) => setTimeout(r, 50));
-			unsub();
-			// Wait long enough for the timer to fire IF SIGTERM didn't kill the child.
-			await new Promise((r) => setTimeout(r, 400));
-			expect(existsSync(markerPath)).toBe(false);
-		} finally {
-			if (existsSync(markerPath)) unlinkSync(markerPath);
-		}
-	});
-});
-
-// ---------------------------------------------------------------------------
-// P10a — runProcess large stdout + immediate exit (regression for P1 exit→close)
-// ---------------------------------------------------------------------------
-
-describe("runProcess — large stdout buffering", () => {
-	it("captures all stdout across multiple pipe-buffer chunks (regression for exit vs close)", async () => {
-		// 200 KB > pipe buffer (64 KB on Linux/macOS) → data arrives in multiple
-		// chunks. Child writes all data then exits via the write callback to
-		// ensure the OS drains the pipe before exit. The `exit` event fires
-		// before all `data` events are delivered; `close` waits for drain.
-		// The old `exit`-based implementation would only capture the first chunk.
-		const n = runProcess("node", [
-			"-e",
-			"const buf = Buffer.alloc(200 * 1024, 97); process.stdout.write(buf, () => process.exit(0));",
-		]);
-		const msgs = await collectUntilDone(n, 10000);
-		const dataMsg = msgs.find((m) => m[0] === DATA);
-		expect(dataMsg).toBeDefined();
-		const result = dataMsg![1] as { stdout: string; stderr: string; exitCode: number | null };
-		expect(result.exitCode).toBe(0);
-		expect(result.stdout.length).toBe(200 * 1024);
-		expect(result.stdout[0]).toBe("a");
-		expect(result.stdout[result.stdout.length - 1]).toBe("a");
-	});
-});
-
-// ---------------------------------------------------------------------------
-// P11 — Concurrent subscribers share a single subprocess (multicast)
-// ---------------------------------------------------------------------------
-//
-// `fromSpawn` returns a node backed by a single `producer` activation.
-// The subprocess is spawned once when the FIRST subscriber connects; all
-// subsequent subscribers are added to the shared sinks set and receive
-// the same events from that one subprocess. Unsubscribing the last subscriber
-// tears down the subprocess.
-
-describe("fromSpawn — concurrent subscribers (multicast)", () => {
-	it("two subscribers see the same events from a single subprocess spawn", async () => {
-		const n = fromSpawn("node", ["-e", "process.stdout.write('shared'); process.exit(0)"]);
-
-		const results1: AnyMsg[] = [];
-		const results2: AnyMsg[] = [];
-
-		const done1 = new Promise<void>((resolve) => {
-			let unsub = (): void => {};
-			unsub = n.subscribe((batch) => {
-				for (const m of batch) {
-					results1.push(m as AnyMsg);
-					if (m[0] === COMPLETE || m[0] === ERROR) {
-						unsub();
-						resolve();
-						return;
-					}
-				}
-			});
-		});
-
-		const done2 = new Promise<void>((resolve) => {
-			let unsub = (): void => {};
-			unsub = n.subscribe((batch) => {
-				for (const m of batch) {
-					results2.push(m as AnyMsg);
-					if (m[0] === COMPLETE || m[0] === ERROR) {
-						unsub();
-						resolve();
-						return;
-					}
-				}
-			});
-		});
-
-		await Promise.all([done1, done2]);
-
-		// Both subscribers must have received at least one DATA and a COMPLETE.
-		expect(results1.some((m) => m[0] === COMPLETE)).toBe(true);
-		expect(results2.some((m) => m[0] === COMPLETE)).toBe(true);
-
-		// Both must see the exit event (one spawn, shared stream).
-		const exitEvents1 = results1.filter(
-			(m) => m[0] === DATA && (m[1] as { kind: string }).kind === "exit",
-		);
-		const exitEvents2 = results2.filter(
-			(m) => m[0] === DATA && (m[1] as { kind: string }).kind === "exit",
-		);
-		expect(exitEvents1).toHaveLength(1);
-		expect(exitEvents2).toHaveLength(1);
-	});
-});
diff --git a/src/__tests__/base/sources/sources.test.ts b/src/__tests__/base/sources/sources.test.ts
deleted file mode 100644
index 02a64f69..00000000
--- a/src/__tests__/base/sources/sources.test.ts
+++ /dev/null
@@ -1,1367 +0,0 @@
-import { mkdtemp, rm, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { COMPLETE, DATA, DIRTY, ERROR, node, RESOLVED } from "@graphrefly/pure-ts/core";
-// Substrate sources (fromTimer, fromIter, etc.) from pure-ts
-import {
-	empty,
-	fromAny,
-	fromAsyncIter,
-	fromIter,
-	fromPromise,
-	fromTimer,
-	never,
-	of,
-	throwError,
-	valve,
-} from "@graphrefly/pure-ts/extra";
-import { afterEach, describe, expect, it, vi } from "vitest";
-import { fromMCP } from "../../../base/io/mcp.js";
-import { toSSE } from "../../../base/io/sse.js";
-import { fromWebhook } from "../../../base/io/webhook.js";
-import { fromWebSocket, fromWebSocketReconnect, toWebSocket } from "../../../base/io/websocket.js";
-// Presentation sources from base/sources
-import { cached, defer, forEach, replay, share, toArray } from "../../../base/sources/async.js";
-import { fromCron, parseCron } from "../../../base/sources/event/cron.js";
-import { fromEvent, fromRaf } from "../../../base/sources/event/dom.js";
-import { fromPushNotification } from "../../../base/sources/event/push.js";
-import { fromFSWatch } from "../../../base/sources/node/fs-root.js";
-import { fromGitHook } from "../../../base/sources/node/git-hook.js";
-import { awaitSettled, firstValueFrom, firstWhere } from "../../../base/sources/settled.js";
-import { collect } from "../test-helpers.js";
-
-/** Next macrotick (GraphReFly + Vitest: do not use `vi.waitFor` with a sync boolean — it resolves immediately). */
-function tick(ms = 0): Promise<void> {
-	return new Promise((r) => setTimeout(r, ms));
-}
-
-async function readSSE(stream: ReadableStream<Uint8Array>): Promise<string> {
-	const reader = stream.getReader();
-	const decoder = new TextDecoder();
-	let out = "";
-	while (true) {
-		const { value, done } = await reader.read();
-		if (done) break;
-		out += decoder.decode(value, { stream: true });
-	}
-	out += decoder.decode();
-	return out;
-}
-
-describe("extra sources & sinks (roadmap §2.3)", () => {
-	afterEach(() => {
-		vi.useRealTimers();
-		vi.restoreAllMocks();
-	});
-
-	it("fromTimer emits then completes", async () => {
-		const n = fromTimer(15);
-		const { batches, unsub } = collect(n);
-		await tick(50);
-		const data = batches.flat().filter((m) => m[0] === DATA);
-		expect(data.length).toBeGreaterThanOrEqual(1);
-		expect(data[0]?.[1]).toBe(0);
-		expect(batches.some((b) => b.some((m) => m[0] === COMPLETE))).toBe(true);
-		unsub();
-	});
-
-	it("fromTimer periodic mode", async () => {
-		vi.useFakeTimers();
-		const n = fromTimer(10, { period: 5 });
-		const { batches, unsub } = collect(n);
-		vi.advanceTimersByTime(10);
-		const d0 = batches.flat().filter((m) => m[0] === DATA);
-		expect(d0.map((m) => m[1])).toContain(0);
-		vi.advanceTimersByTime(5);
-		const d1 = batches.flat().filter((m) => m[0] === DATA);
-		expect(d1.map((m) => m[1])).toContain(1);
-		vi.advanceTimersByTime(5);
-		const d2 = batches.flat().filter((m) => m[0] === DATA);
-		expect(d2.map((m) => m[1])).toContain(2);
-		// Should NOT have completed
-		expect(batches.flat().some((m) => m[0] === COMPLETE)).toBe(false);
-		unsub();
-	});
-
-	it("fromRaf emits frame timestamps while subscribed", async () => {
-		const n = fromRaf();
-		const { batches, unsub } = collect(n);
-		// rAF fires at display refresh; give it a few frames.
-		await tick(120);
-		const data = batches.flat().filter((m) => m[0] === DATA);
-		expect(data.length).toBeGreaterThanOrEqual(2);
-		// Timestamps monotonically non-decreasing.
-		for (let i = 1; i < data.length; i++) {
-			expect((data[i]![1] as number) >= (data[i - 1]![1] as number)).toBe(true);
-		}
-		unsub();
-	});
-
-	it("fromRaf stops emitting after unsubscribe", async () => {
-		const n = fromRaf();
-		const { batches, unsub } = collect(n);
-		await tick(60);
-		unsub();
-		const countAfterUnsub = batches.flat().filter((m) => m[0] === DATA).length;
-		await tick(120);
-		const countLater = batches.flat().filter((m) => m[0] === DATA).length;
-		expect(countLater).toBe(countAfterUnsub);
-	});
-
-	it("fromRaf aborts with ERROR via signal", async () => {
-		const ac = new AbortController();
-		const n = fromRaf({ signal: ac.signal });
-		const { batches, unsub } = collect(n);
-		await tick(30);
-		ac.abort(new Error("raf-abort"));
-		expect(
-			batches.some((b) => b.some((m) => m[0] === ERROR && (m[1] as Error).message === "raf-abort")),
-		).toBe(true);
-		unsub();
-	});
-
-	/**
-	 * Install a controllable `document` (visibilitychange) + a real
-	 * `requestAnimationFrame`/`cancelAnimationFrame` stub so the
-	 * rAF-vs-setTimeout branch in `fromRaf.scheduleNext` is GENUINELY
-	 * exercised (node's vitest env has neither). `rafCalls` distinguishes
-	 * "ticked via rAF" from "ticked via the setTimeout fallback".
-	 */
-	function installRafDom(initial: "hidden" | "visible") {
-		const prevDoc = (globalThis as { document?: unknown }).document;
-		const prevRaf = (globalThis as { requestAnimationFrame?: unknown }).requestAnimationFrame;
-		const prevCaf = (globalThis as { cancelAnimationFrame?: unknown }).cancelAnimationFrame;
-		let handler: (() => void) | undefined;
-		const doc = {
-			visibilityState: initial as DocumentVisibilityState,
-			addEventListener: (t: string, h: () => void) => {
-				if (t === "visibilitychange") handler = h;
-			},
-			removeEventListener: (t: string) => {
-				if (t === "visibilitychange") handler = undefined;
-			},
-		};
-		let rafCalls = 0;
-		(globalThis as { document?: unknown }).document = doc;
-		(globalThis as { requestAnimationFrame?: unknown }).requestAnimationFrame = (
-			cb: (t: number) => void,
-		): number => {
-			rafCalls++;
-			return setTimeout(() => cb(performance.now()), 8) as unknown as number;
-		};
-		(globalThis as { cancelAnimationFrame?: unknown }).cancelAnimationFrame = (id: number) =>
-			clearTimeout(id as unknown as ReturnType<typeof setTimeout>);
-		return {
-			doc,
-			fireVisible: () => {
-				doc.visibilityState = "visible" as DocumentVisibilityState;
-				handler?.();
-			},
-			rafCalls: () => rafCalls,
-			restore: () => {
-				(globalThis as { document?: unknown }).document = prevDoc;
-				(globalThis as { requestAnimationFrame?: unknown }).requestAnimationFrame = prevRaf;
-				(globalThis as { cancelAnimationFrame?: unknown }).cancelAnimationFrame = prevCaf;
-			},
-		};
-	}
-
-	it("fromRaf({ pauseWhenHidden }) parks while hidden (no rAF, no timer), resumes via rAF on visible", async () => {
-		const env = installRafDom("hidden");
-		try {
-			const n = fromRaf({ pauseWhenHidden: true });
-			const { batches, unsub } = collect(n);
-			await tick(120);
-			// Parked: zero DATA AND zero rAF scheduled while hidden (proves the
-			// early-return — not an accidental no-raf fallback).
-			expect(batches.flat().filter((m) => m[0] === DATA).length).toBe(0);
-			expect(env.rafCalls()).toBe(0);
-			env.fireVisible();
-			await tick(120);
-			// Resumed specifically via the rAF branch (raf && !hidden).
-			expect(batches.flat().filter((m) => m[0] === DATA).length).toBeGreaterThanOrEqual(2);
-			expect(env.rafCalls()).toBeGreaterThan(0);
-			unsub();
-		} finally {
-			env.restore();
-		}
-	});
-
-	it("fromRaf (default) keeps ticking while hidden via setTimeout (NOT rAF), uses rAF when visible", async () => {
-		const env = installRafDom("hidden");
-		try {
-			const n = fromRaf(); // no pauseWhenHidden
-			const { batches, unsub } = collect(n);
-			await tick(120);
-			// Genuinely exercises the `raf && !hidden` gate: hidden ⇒ setTimeout
-			// keep-alive fired (DATA flows) while rAF was NOT used.
-			expect(batches.flat().filter((m) => m[0] === DATA).length).toBeGreaterThanOrEqual(2);
-			expect(env.rafCalls()).toBe(0);
-			env.fireVisible();
-			await tick(120);
-			// Visible ⇒ now routes through rAF.
-			expect(env.rafCalls()).toBeGreaterThan(0);
-			unsub();
-		} finally {
-			env.restore();
-		}
-	});
-
-	it("fromPushNotification emits each delivered payload; teardown unsubscribes", () => {
-		let deliver: ((p: { v: number }) => void) | undefined;
-		let unsubbed = false;
-		const n = fromPushNotification<{ v: number }>((d) => {
-			deliver = d;
-			return () => {
-				unsubbed = true;
-			};
-		});
-		const { batches, unsub } = collect(n);
-		deliver?.({ v: 1 });
-		deliver?.({ v: 2 });
-		const data = batches
-			.flat()
-			.filter((m) => m[0] === DATA)
-			.map((m) => m[1]);
-		expect(data).toEqual([{ v: 1 }, { v: 2 }]);
-		expect(unsubbed).toBe(false);
-		unsub();
-		expect(unsubbed).toBe(true);
-		// Post-teardown deliver is a no-op (done guard).
-		deliver?.({ v: 3 });
-		expect(batches.flat().filter((m) => m[0] === DATA).length).toBe(2);
-	});
-
-	it("fromPushNotification tolerates a void-returning register", () => {
-		let deliver: ((p: string) => void) | undefined;
-		const n = fromPushNotification<string>((d) => {
-			deliver = d;
-			// no unsubscribe returned
-		});
-		const { batches, unsub } = collect(n);
-		deliver?.("hello");
-		expect(
-			batches
-				.flat()
-				.filter((m) => m[0] === DATA)
-				.map((m) => m[1]),
-		).toEqual(["hello"]);
-		expect(() => unsub()).not.toThrow();
-	});
-
-	it("fromPushNotification rejects a non-function register", () => {
-		expect(() => fromPushNotification(undefined as never)).toThrow(TypeError);
-	});
-
-	it("fromTimer aborts with ERROR", () => {
-		vi.useFakeTimers();
-		const ac = new AbortController();
-		const n = fromTimer(1000, { signal: ac.signal });
-		const { batches, unsub } = collect(n);
-		ac.abort(new Error("x"));
-		expect(batches.some((b) => b.some((m) => m[0] === ERROR))).toBe(true);
-		unsub();
-	});
-
-	it("fromIter / of", () => {
-		const a = collect(fromIter([10, 20]));
-		// No post-terminal replay — terminal guard blocks push-on-subscribe (§1.3.4)
-		expect(
-			a.batches
-				.flat()
-				.filter((m) => m[0] === DATA)
-				.map((m) => m[1]),
-		).toEqual([10, 20]);
-		expect(a.batches.some((b) => b.some((m) => m[0] === COMPLETE))).toBe(true);
-		a.unsub();
-
-		const b = collect(of(1, 2, 3));
-		expect(
-			b.batches
-				.flat()
-				.filter((m) => m[0] === DATA)
-				.map((m) => m[1]),
-		).toEqual([1, 2, 3]);
-		b.unsub();
-	});
-
-	it("fromIter with throwing iterator emits ERROR", () => {
-		function* badIter() {
-			yield 1;
-			throw new Error("iter-boom");
-		}
-		const { batches, unsub } = collect(fromIter(badIter()));
-		expect(batches.flat().some((m) => m[0] === DATA && m[1] === 1)).toBe(true);
-		expect(
-			batches.flat().some((m) => m[0] === ERROR && (m[1] as Error).message === "iter-boom"),
-		).toBe(true);
-		unsub();
-	});
-
-	it("empty / never / throwError", () => {
-		const e = collect(empty());
-		expect(e.batches.some((b) => b.some((m) => m[0] === COMPLETE))).toBe(true);
-		expect(e.batches.flat().some((m) => m[0] === DATA)).toBe(false);
-		e.unsub();
-
-		const n = collect(never());
-		expect(n.batches.length).toBe(0);
-		n.unsub();
-
-		const t = collect(throwError("boom"));
-		expect(t.batches.some((b) => b.some((m) => m[0] === ERROR && m[1] === "boom"))).toBe(true);
-		t.unsub();
-	});
-
-	it("fromPromise", async () => {
-		const ok = collect(fromPromise(Promise.resolve(7)));
-		await tick(0);
-		expect(ok.batches.some((b) => b.some((m) => m[0] === COMPLETE))).toBe(true);
-		expect(ok.batches.flat().find((m) => m[0] === DATA)?.[1]).toBe(7);
-		ok.unsub();
-
-		const bad = collect(fromPromise(Promise.reject(new Error("no"))));
-		await tick(0);
-		expect(bad.batches.some((b) => b.some((m) => m[0] === ERROR))).toBe(true);
-		bad.unsub();
-	});
-
-	it("fromAny treats sync iterables as single values by default (DS-13.5 semantic)", () => {
-		const a = collect(fromAny([1, 2]));
-		// Default: array emitted as ONE DATA value (per-element streaming
-		// requires explicit { iter: true } or fromIter).
-		expect(
-			a.batches
-				.flat()
-				.filter((m) => m[0] === DATA)
-				.map((m) => m[1]),
-		).toEqual([[1, 2]]);
-		a.unsub();
-	});
-
-	it("fromAny with { iter: true } opts into per-element streaming", () => {
-		const a = collect(fromAny([1, 2], { iter: true }));
-		expect(
-			a.batches
-				.flat()
-				.filter((m) => m[0] === DATA)
-				.map((m) => m[1]),
-		).toEqual([1, 2]);
-		a.unsub();
-	});
-
-	it("fromAny with scalar fallback", () => {
-		const a = collect(fromAny(42));
-		expect(
-			a.batches
-				.flat()
-				.filter((m) => m[0] === DATA)
-				.map((m) => m[1]),
-		).toEqual([42]);
-		a.unsub();
-	});
-
-	it("fromAny handles null/undefined as scalar values", () => {
-		const a = collect(fromAny(null));
-		expect(
-			a.batches
-				.flat()
-				.filter((m) => m[0] === DATA)
-				.map((m) => m[1]),
-		).toEqual([null]);
-		a.unsub();
-
-		const b = collect(fromAny(undefined));
-		expect(b.batches.flat().some((m) => m[0] === COMPLETE)).toBe(true);
-		expect(b.batches.flat().some((m) => m[0] === ERROR)).toBe(false);
-		b.unsub();
-	});
-
-	it("fromAny with existing Node returns same reference", () => {
-		const s = node([], { initial: 99 });
-		const result = fromAny(s);
-		expect(result).toBe(s);
-	});
-
-	it("fromAsyncIter", async () => {
-		async function* gen() {
-			yield 1;
-			yield 2;
-		}
-		const { batches, unsub } = collect(fromAsyncIter(gen()));
-		await tick(0);
-		expect(
-			batches
-				.flat()
-				.filter((m) => m[0] === DATA)
-				.map((m) => m[1]),
-		).toEqual([1, 2]);
-		unsub();
-	});
-
-	it("toArray", () => {
-		const src = fromIter(["a", "b"]);
-		const { batches, unsub } = collect(toArray(src));
-		const data = batches.flat().filter((m) => m[0] === DATA);
-		expect(data[data.length - 1]?.[1]).toEqual(["a", "b"]);
-		unsub();
-	});
-
-	// DS-2.7.A QA F3 — pins the `toArray` opt-in motivation. An immediate-
-	// COMPLETE source (no prior DATA) must emit `[]` then COMPLETE downstream
-	// — `completeWhenDepsComplete: false` means auto-COMPLETE is OFF; fn fires
-	// via `terminalAsRealInput: true` and emits the empty buffer + COMPLETE.
-	it("toArray over an immediate-COMPLETE source emits [] then COMPLETE", () => {
-		const src = node<string>();
-		const { batches, unsub } = collect(toArray(src));
-		src.down([[COMPLETE]]);
-		const types = batches.flat().map((m) => m[0]);
-		const data = batches.flat().filter((m) => m[0] === DATA);
-		expect(data[data.length - 1]?.[1]).toEqual([]);
-		expect(types).toContain(COMPLETE);
-		unsub();
-	});
-
-	it("forEach runs side effect and returns unsub", () => {
-		const acc: number[] = [];
-		const src = fromIter([1, 2]);
-		const unsub = forEach(src, (v) => acc.push(v as number));
-		// No post-terminal replay — terminal guard blocks push-on-subscribe
-		expect(acc).toEqual([1, 2]);
-		expect(typeof unsub).toBe("function");
-		unsub();
-	});
-
-	it("share uses one upstream subscription", () => {
-		let subs = 0;
-		const src = node<number>(
-			[],
-			(_data, a) => {
-				subs += 1;
-				a.emit(1);
-				return () => {
-					subs -= 1;
-				};
-			},
-			{ describeKind: "producer" },
-		);
-		const hub = share(src);
-		const a = collect(hub);
-		const b = collect(hub);
-		expect(subs).toBe(1);
-		a.unsub();
-		b.unsub();
-	});
-
-	it("replay replays buffer to late subscriber WITHOUT double-delivering the last value", async () => {
-		const s = node([], { initial: 0 });
-		const r = replay(s, 2);
-		const first = collect(r);
-		await tick(0);
-		s.down([[DIRTY], [DATA, 1]]);
-		s.down([[DIRTY], [DATA, 2]]);
-		await tick(0);
-		const second = collect(r);
-		await tick(0);
-		const earlyData = second.batches
-			.flat()
-			.filter((m) => m[0] === DATA)
-			.map((m) => m[1]);
-		// Group-3 Edge #2 regression: the late subscriber must receive the
-		// last-2 buffer EXACTLY ([1, 2]) — not [1, 2, 2]. The old
-		// wrapSubscribeHook pattern flushed the buffer AND push-on-subscribed
-		// the cache, double-delivering `2`. The `.slice(0, 2)` the prior
-		// assertion used masked that dup. Assert the full sequence.
-		expect(earlyData).toEqual([1, 2]);
-		first.unsub();
-		second.unsub();
-	});
-
-	it("cached is replay(1)", async () => {
-		const s = node([], { initial: 0 });
-		const c = cached(s);
-		const { batches, unsub } = collect(c);
-		await tick(0);
-		s.down([[DIRTY], [DATA, 42]]);
-		await tick(0);
-		expect(batches.flat().some((m) => m[0] === DATA && m[1] === 42)).toBe(true);
-		unsub();
-	});
-
-	it("fromEvent", () => {
-		const target = {
-			listeners: [] as ((e: unknown) => void)[],
-			addEventListener(_type: string, fn: (e: unknown) => void) {
-				this.listeners.push(fn);
-			},
-			removeEventListener(_type: string, fn: (e: unknown) => void) {
-				const i = this.listeners.indexOf(fn);
-				if (i >= 0) this.listeners.splice(i, 1);
-			},
-		};
-		const { batches, unsub } = collect(fromEvent<{ x: number }>(target, "x"));
-		target.listeners[0]?.({ x: 1 });
-		expect(
-			batches.some((b) => b.some((m) => m[0] === DATA && (m[1] as { x: number }).x === 1)),
-		).toBe(true);
-		unsub();
-	});
-
-	it("fromFSWatch emits debounced filesystem changes without polling", async () => {
-		const dir = await mkdtemp(join(tmpdir(), "graphrefly-fswatch-"));
-		try {
-			const fileTs = join(dir, "alpha.ts");
-			const fileTxt = join(dir, "ignore.txt");
-			const fsNode = fromFSWatch(dir, {
-				debounce: 25,
-				recursive: true,
-				include: ["**/*.ts"],
-			});
-			const { batches, unsub } = collect(fsNode);
-			await writeFile(fileTs, "v1");
-			await writeFile(fileTs, "v2");
-			await writeFile(fileTxt, "nope");
-			await tick(200);
-			const events = batches
-				.flat()
-				.filter((m) => m[0] === DATA)
-				.map(
-					(m) =>
-						m[1] as {
-							type: "change" | "create" | "delete" | "rename";
-							path: string;
-							root: string;
-							relative_path: string;
-							timestamp_ns: number;
-						},
-				);
-			expect(events.some((evt) => evt.path.endsWith("alpha.ts"))).toBe(true);
-			expect(events.some((evt) => evt.path.endsWith("ignore.txt"))).toBe(false);
-			expect(events.length).toBeGreaterThanOrEqual(1);
-			expect(events[0]?.root).toContain("graphrefly-fswatch-");
-			expect(events[0]?.relative_path).toBe("alpha.ts");
-			expect(["change", "create", "delete", "rename"]).toContain(events[0]?.type);
-			expect(typeof events[0]?.timestamp_ns).toBe("number");
-			unsub();
-		} finally {
-			await rm(dir, { recursive: true, force: true });
-		}
-	});
-
-	it("fromFSWatch surfaces watcher setup failures as ERROR tuples", async () => {
-		// Remove the temp root so neither parent nor leaf exists — Linux
-		// recursive fs.watch may wait instead of throwing ENOENT synchronously.
-		const removedRoot = await mkdtemp(join(tmpdir(), "graphrefly-fswatch-err-"));
-		await rm(removedRoot, { recursive: true, force: true });
-		const badPath = join(removedRoot, "missing-leaf");
-		const node = fromFSWatch(badPath, { debounce: 5 });
-		const { batches, unsub } = collect(node);
-		await tick(50);
-		expect(batches.flat().some((m) => m[0] === ERROR)).toBe(true);
-		unsub();
-	});
-
-	it("fromFSWatch rejects empty path list", () => {
-		expect(() => fromFSWatch([])).toThrow("at least one path");
-	});
-
-	it("fromWebhook bridges callback payloads and cleanup", () => {
-		let hook:
-			| {
-					emit: (payload: { id: string }) => void;
-					error: (err: unknown) => void;
-					complete: () => void;
-			  }
-			| undefined;
-		let cleaned = false;
-		const node = fromWebhook<{ id: string }>((handlers) => {
-			hook = handlers;
-			return () => {
-				cleaned = true;
-			};
-		});
-		const { batches, unsub } = collect(node);
-		hook?.emit({ id: "evt-1" });
-		expect(
-			batches.some((b) => b.some((m) => m[0] === DATA && (m[1] as { id: string }).id === "evt-1")),
-		).toBe(true);
-		unsub();
-		expect(cleaned).toBe(true);
-	});
-
-	it("fromWebhook forwards register errors as ERROR", () => {
-		const node = fromWebhook(() => {
-			throw new Error("register-failed");
-		});
-		const { batches, unsub } = collect(node);
-		expect(
-			batches.some((b) =>
-				b.some((m) => m[0] === ERROR && (m[1] as Error).message === "register-failed"),
-			),
-		).toBe(true);
-		unsub();
-	});
-
-	it("fromWebSocket forwards message and close tuples", () => {
-		type WsEvent = { data?: unknown; error?: unknown };
-		class FakeWebSocket {
-			private readonly listeners = new Map<string, Set<(ev: unknown) => void>>();
-			removed = 0;
-			send(_data: string | ArrayBufferLike | Blob | ArrayBufferView) {}
-			close() {}
-			addEventListener(type: "message" | "error" | "close", listener: (ev: unknown) => void) {
-				const set = this.listeners.get(type) ?? new Set<(ev: unknown) => void>();
-				set.add(listener);
-				this.listeners.set(type, set);
-			}
-			removeEventListener(type: "message" | "error" | "close", listener: (ev: unknown) => void) {
-				this.listeners.get(type)?.delete(listener);
-				this.removed += 1;
-			}
-			emit(type: "message" | "error" | "close", event: WsEvent) {
-				for (const listener of this.listeners.get(type) ?? []) listener(event);
-			}
-		}
-		const ws = new FakeWebSocket();
-		const node = fromWebSocket<{ id: string }>(ws, {
-			parse: (payload) => payload as { id: string },
-		});
-		const { batches, unsub } = collect(node);
-		ws.emit("message", { data: { id: "m1" } });
-		ws.emit("close", {});
-		expect(
-			batches.some((b) => b.some((m) => m[0] === DATA && (m[1] as { id: string }).id === "m1")),
-		).toBe(true);
-		expect(batches.some((b) => b.some((m) => m[0] === COMPLETE))).toBe(true);
-		expect(ws.removed).toBe(3);
-		ws.emit("message", { data: { id: "m2" } });
-		expect(
-			batches.some((b) => b.some((m) => m[0] === DATA && (m[1] as { id: string }).id === "m2")),
-		).toBe(false);
-		unsub();
-	});
-
-	// F-B-class smell sweep (2026-05-18) — F-WS: `maxRetries` is now required.
-	// The underlying `retry()` is fail-loud (D4: backoff without explicit count
-	// throws). Previously `fromWebSocketReconnect(factory)` advertised a silent
-	// `Infinity` default but already threw at construction — the type now makes
-	// the explicit value mandatory and the stale JSDoc is corrected.
-	it("F-WS: fromWebSocketReconnect constructs with explicit maxRetries", () => {
-		class FakeWs {
-			send() {}
-			close() {}
-			addEventListener() {}
-			removeEventListener() {}
-		}
-		expect(() =>
-			fromWebSocketReconnect(() => new FakeWs() as never, { maxRetries: 5 }),
-		).not.toThrow();
-		// Explicit unbounded opt-in is allowed.
-		expect(() =>
-			fromWebSocketReconnect(() => new FakeWs() as never, {
-				maxRetries: Number.POSITIVE_INFINITY,
-			}),
-		).not.toThrow();
-	});
-
-	it("F-WS: omitting maxRetries (JS callers) is fail-loud via retry() D4", () => {
-		class FakeWs {
-			send() {}
-			close() {}
-			addEventListener() {}
-			removeEventListener() {}
-		}
-		// `{}` simulates a JS caller bypassing the now-required type — backoff
-		// defaults to "exponential", so retry() throws on the missing count.
-		expect(() => fromWebSocketReconnect(() => new FakeWs() as never, {} as never)).toThrow(/count/);
-	});
-
-	it("fromWebSocket supports register-style wiring and raw payload fallback", () => {
-		let emitFn: ((payload: unknown) => void) | undefined;
-		let completeFn: (() => void) | undefined;
-		let cleaned = false;
-		const node = fromWebSocket<{ id: string }>(
-			(emit, _error, complete) => {
-				emitFn = emit;
-				completeFn = complete;
-				return () => {
-					cleaned = true;
-				};
-			},
-			{ parse: (payload) => payload as { id: string } },
-		);
-		const { batches, unsub } = collect(node);
-		emitFn?.({ id: "direct" });
-		completeFn?.();
-		expect(
-			batches.some((b) => b.some((m) => m[0] === DATA && (m[1] as { id: string }).id === "direct")),
-		).toBe(true);
-		expect(batches.some((b) => b.some((m) => m[0] === COMPLETE))).toBe(true);
-		unsub();
-		expect(cleaned).toBe(true);
-	});
-
-	it("fromWebSocket emits ERROR when register throws", () => {
-		const node = fromWebSocket(() => {
-			throw new Error("register-failed");
-		});
-		const { batches, unsub } = collect(node);
-		expect(
-			batches.some((b) =>
-				b.some((m) => m[0] === ERROR && (m[1] as Error).message === "register-failed"),
-			),
-		).toBe(true);
-		unsub();
-	});
-
-	it("fromWebSocket enforces register cleanup contract", () => {
-		const node = fromWebSocket(
-			((_emit, _error, _complete) => undefined) as unknown as (
-				emit: (payload: { id: string }) => void,
-				error: (err: unknown) => void,
-				complete: () => void,
-			) => () => void,
-		);
-		const { batches, unsub } = collect(node);
-		expect(
-			batches.some((b) =>
-				b.some(
-					(m) =>
-						m[0] === ERROR && String(m[1]).includes("fromWebSocket register contract violation"),
-				),
-			),
-		).toBe(true);
-		unsub();
-	});
-
-	it("fromWebSocket forwards error tuple", () => {
-		class FakeWebSocket {
-			private readonly listeners = new Map<string, Set<(ev: unknown) => void>>();
-			send(_data: string | ArrayBufferLike | Blob | ArrayBufferView) {}
-			close() {}
-			addEventListener(type: "message" | "error" | "close", listener: (ev: unknown) => void) {
-				const set = this.listeners.get(type) ?? new Set<(ev: unknown) => void>();
-				set.add(listener);
-				this.listeners.set(type, set);
-			}
-			removeEventListener(type: "message" | "error" | "close", listener: (ev: unknown) => void) {
-				this.listeners.get(type)?.delete(listener);
-			}
-			emit(type: "message" | "error" | "close", event: { data?: unknown; error?: unknown }) {
-				for (const listener of this.listeners.get(type) ?? []) listener(event);
-			}
-		}
-		const ws = new FakeWebSocket();
-		const node = fromWebSocket(ws);
-		const { batches, unsub } = collect(node);
-		ws.emit("error", { error: "boom" });
-		expect(batches.some((b) => b.some((m) => m[0] === ERROR))).toBe(true);
-		unsub();
-	});
-
-	it("toWebSocket sends DATA and closes on COMPLETE", () => {
-		class FakeWebSocket {
-			sent: unknown[] = [];
-			closed = 0;
-			send(data: string | ArrayBufferLike | Blob | ArrayBufferView) {
-				this.sent.push(data);
-			}
-			close() {
-				this.closed += 1;
-			}
-			addEventListener(_type: "message" | "error" | "close", _listener: (ev: unknown) => void) {}
-			removeEventListener(_type: "message" | "error" | "close", _listener: (ev: unknown) => void) {}
-		}
-		const ws = new FakeWebSocket();
-		const handle = toWebSocket(fromIter([1, 2]), ws, { serialize: (v) => `n:${v}` });
-		expect(ws.sent).toEqual(["n:1", "n:2"]);
-		expect(ws.closed).toBe(1);
-		handle.dispose();
-	});
-
-	it("toWebSocket reports serialize-returning-undefined as serialize error", () => {
-		const errors: Array<{ stage: string; error: Error }> = [];
-		class FakeWebSocket {
-			sent: unknown[] = [];
-			send(data: string | ArrayBufferLike | Blob | ArrayBufferView) {
-				this.sent.push(data);
-			}
-			close() {}
-			addEventListener(_type: "message" | "error" | "close", _listener: (ev: unknown) => void) {}
-			removeEventListener(_type: "message" | "error" | "close", _listener: (ev: unknown) => void) {}
-		}
-		const ws = new FakeWebSocket();
-		const handle = toWebSocket(fromIter([1]), ws, {
-			serialize: () => undefined as never,
-			closeOnComplete: false,
-			onTransportError: (event) => errors.push({ stage: event.stage, error: event.error }),
-		});
-		expect(ws.sent).toEqual([]);
-		expect(errors).toHaveLength(1);
-		expect(errors[0].stage).toBe("serialize");
-		handle.dispose();
-	});
-
-	it("toWebSocket reports structured send failures", () => {
-		const errors: Array<{ stage: string; error: Error; value: unknown }> = [];
-		class FakeWebSocket {
-			send(_data: string | ArrayBufferLike | Blob | ArrayBufferView) {
-				throw new Error("send-failed");
-			}
-			close(_code?: number, _reason?: string) {}
-			addEventListener(_type: "message" | "error" | "close", _listener: (ev: unknown) => void) {}
-			removeEventListener(_type: "message" | "error" | "close", _listener: (ev: unknown) => void) {}
-		}
-		const ws = new FakeWebSocket();
-		expect(() =>
-			toWebSocket(fromIter([1]), ws, {
-				closeOnComplete: false,
-				onTransportError: (event) =>
-					errors.push({ stage: event.stage, error: event.error, value: event.value }),
-			}),
-		).not.toThrow();
-		expect(errors).toHaveLength(1);
-		expect(errors[0].stage).toBe("send");
-		expect(errors[0].error.message).toBe("send-failed");
-		expect(errors[0].value).toBe(1);
-	});
-
-	it("toWebSocket reports close failure and closes idempotently", () => {
-		const errors: Array<{ stage: string; error: Error; message?: [symbol, unknown?] | undefined }> =
-			[];
-		const repeatedTerminal = node(
-			[],
-			(_data, a) => {
-				a.down([[COMPLETE], [ERROR, new Error("late")]]);
-				return () => {};
-			},
-			{ describeKind: "producer" },
-		);
-		class FakeWebSocket {
-			closed = 0;
-			send(_data: string | ArrayBufferLike | Blob | ArrayBufferView) {}
-			close(_code?: number, _reason?: string) {
-				this.closed += 1;
-				throw new Error("close-failed");
-			}
-			addEventListener(_type: "message" | "error" | "close", _listener: (ev: unknown) => void) {}
-			removeEventListener(_type: "message" | "error" | "close", _listener: (ev: unknown) => void) {}
-		}
-		const ws = new FakeWebSocket();
-		expect(() =>
-			toWebSocket(repeatedTerminal, ws, {
-				onTransportError: (event) =>
-					errors.push({
-						stage: event.stage,
-						error: event.error,
-						message: event.message as [symbol, unknown?] | undefined,
-					}),
-			}),
-		).not.toThrow();
-		expect(ws.closed).toBe(1);
-		expect(errors).toHaveLength(1);
-		expect(errors[0]?.stage).toBe("close");
-		expect(errors[0]?.error.message).toBe("close-failed");
-		expect(errors[0]?.message?.[0]).toBe(COMPLETE);
-	});
-
-	it("parseCron rejects bad expressions", () => {
-		expect(() => parseCron("bad")).toThrow();
-		expect(() => parseCron("* *")).toThrow();
-	});
-
-	it("fromCron fires on matching minute (timestamp_ns)", () => {
-		vi.useFakeTimers();
-		vi.setSystemTime(new Date(2026, 2, 28, 9, 0, 0));
-		const n = fromCron("0 9 * * *", { tickMs: 1000 });
-		const { batches, unsub } = collect(n);
-		vi.advanceTimersByTime(0);
-		const data = batches.flat().filter((m) => m[0] === DATA);
-		expect(data.length).toBeGreaterThanOrEqual(1);
-		expect(typeof data[0]?.[1]).toBe("number");
-		// Should be a nanosecond timestamp
-		expect(data[0]?.[1]).toBeGreaterThan(1_000_000_000_000_000);
-		unsub();
-	});
-
-	it("firstValueFrom resolves with first DATA", async () => {
-		const result = await firstValueFrom(fromIter([10, 20, 30]));
-		expect(result).toBe(10);
-	});
-
-	it("firstValueFrom rejects on empty", async () => {
-		await expect(firstValueFrom(empty())).rejects.toThrow("completed without DATA");
-	});
-
-	it("firstValueFrom resolves synchronously — shouldUnsub path", async () => {
-		// node([], { initial: 42 }) pushes DATA synchronously inside subscribe; unsub is
-		// not yet assigned when the callback fires, so shouldUnsub = true
-		// must clean up after subscribe returns.
-		const result = await firstValueFrom(node([], { initial: 42 }));
-		expect(result).toBe(42);
-	});
-
-	it("firstValueFrom rejects on ERROR", async () => {
-		await expect(firstValueFrom(throwError(new Error("boom")))).rejects.toThrow("boom");
-	});
-
-	it("firstWhere resolves with first matching value (skips earlier)", async () => {
-		const result = await firstWhere(fromIter([1, 2, 3, 4]), (v) => v > 2);
-		expect(result).toBe(3);
-	});
-
-	it("awaitSettled resolves on first non-nullish DATA (default predicate)", async () => {
-		const s = node<string | null>([], { initial: null });
-		const p = awaitSettled(s);
-		s.emit("hello");
-		expect(await p).toBe("hello");
-	});
-
-	it("awaitSettled respects custom predicate", async () => {
-		const s = node<number>([], { initial: 0 });
-		const p = awaitSettled(s, { predicate: (v) => v > 5 });
-		s.emit(3);
-		s.emit(7);
-		expect(await p).toBe(7);
-	});
-
-	it("awaitSettled rejects with TimeoutError on deadline", async () => {
-		const s = node<string | null>([], { initial: null });
-		await expect(awaitSettled(s, { timeoutMs: 25 })).rejects.toThrow(/Timed out/);
-	});
-
-	it("awaitSettled with timeoutMs resolves before deadline", async () => {
-		const s = node<string | null>([], { initial: null });
-		const p = awaitSettled(s, { timeoutMs: 500 });
-		setTimeout(() => s.emit("before-deadline"), 5);
-		expect(await p).toBe("before-deadline");
-	});
-
-	it("firstWhere resolves on synchronous source — shouldUnsub path", async () => {
-		const result = await firstWhere(node([], { initial: 42 }), (v) => v === 42);
-		expect(result).toBe(42);
-	});
-
-	it("firstWhere rejects when predicate never satisfied (COMPLETE)", async () => {
-		await expect(firstWhere(fromIter([1, 2, 3]), (v) => v > 99)).rejects.toThrow(
-			"completed without matching value",
-		);
-	});
-
-	it("firstWhere rejects on ERROR before match", async () => {
-		await expect(firstWhere(throwError(new Error("fail")), (_v) => true)).rejects.toThrow("fail");
-	});
-
-	it("toSSE writes standard DATA and COMPLETE frames", async () => {
-		const text = await readSSE(toSSE(fromIter([1, 2])));
-		expect(text).toContain("event: data\ndata: 1\n\n");
-		expect(text).toContain("event: data\ndata: 2\n\n");
-		expect(text).toContain("event: complete\n\n");
-	});
-
-	it("toSSE writes ERROR frame and closes", async () => {
-		const text = await readSSE(toSSE(throwError(new Error("boom"))));
-		expect(text).toContain("event: error\n");
-		expect(text).toContain("data: boom");
-	});
-
-	it("toSSE supports custom serializer for Error payloads", async () => {
-		const text = await readSSE(
-			toSSE(throwError(new Error("boom")), {
-				serialize: (v) => (v instanceof Error ? v.message : JSON.stringify(v)),
-			}),
-		);
-		expect(text).toContain("event: error\ndata: boom\n\n");
-	});
-
-	it("toSSE abort closes without synthetic error frame", async () => {
-		const ac = new AbortController();
-		const stream = toSSE(never(), { signal: ac.signal });
-		ac.abort(new Error("stop"));
-		const text = await readSSE(stream);
-		expect(text).toBe("");
-	});
-
-	it("toSSE can include DIRTY and RESOLVED events", async () => {
-		const n = node(
-			[],
-			(_data, a) => {
-				a.down([[DIRTY], [RESOLVED], [COMPLETE]]);
-				return () => {};
-			},
-			{ describeKind: "producer" },
-		);
-		const text = await readSSE(toSSE(n, { includeDirty: true, includeResolved: true }));
-		expect(text).toContain(`event: ${String(DIRTY.description ?? "")}`);
-		expect(text).toContain(`event: ${String(RESOLVED.description ?? "")}`);
-	});
-
-	it("toSSE emits keepalive comments until abort", async () => {
-		const ac = new AbortController();
-		const stream = toSSE(never(), { keepAliveMs: 5, signal: ac.signal });
-		setTimeout(() => ac.abort(), 20);
-		const text = await readSSE(stream);
-		expect(text).toContain(": keepalive\n\n");
-	});
-
-	it("toSSE preserves trailing newline lines", async () => {
-		const text = await readSSE(toSSE(of("a\n")));
-		expect(text).toContain("event: data\ndata: a\ndata: \n\n");
-	});
-
-	it("valve forwards DATA when control is truthy", () => {
-		const src = node([], { initial: 42 });
-		const ctrl = node([], { initial: true });
-		const g = valve(src, ctrl);
-		const { batches, unsub } = collect(g);
-		expect(batches.flat().some((m) => m[0] === DATA && m[1] === 42)).toBe(true);
-		unsub();
-	});
-
-	it("valve emits RESOLVED when control is falsy", () => {
-		const src = node([], { initial: 42 });
-		const ctrl = node([], { initial: false });
-		const g = valve(src, ctrl);
-		const { batches, unsub } = collect(g);
-		expect(batches.flat().some((m) => m[0] === RESOLVED)).toBe(true);
-		expect(batches.flat().some((m) => m[0] === DATA && m[1] === 42)).toBe(false);
-		unsub();
-	});
-
-	// ——————————————————————————————————————————————————————————————
-	//  defer
-	// ——————————————————————————————————————————————————————————————
-
-	it("defer runs thunk on activation and forwards iterable values", () => {
-		let calls = 0;
-		const g = defer<number>(() => {
-			calls++;
-			return [1, 2, 3];
-		});
-		expect(calls).toBe(0); // lazy: not called until subscribe
-		const { batches, unsub } = collect(g);
-		const data = batches
-			.flat()
-			.filter((m) => m[0] === DATA)
-			.map((m) => m[1]);
-		expect(data).toEqual([1, 2, 3]);
-		expect(calls).toBe(1);
-		expect(batches.flat().some((m) => m[0] === COMPLETE)).toBe(true);
-		unsub();
-	});
-
-	it("defer thunk re-runs on each new activation (per-subscribe)", () => {
-		let calls = 0;
-		const g = defer<number>(() => {
-			calls++;
-			return [calls];
-		});
-		const a = collect(g);
-		a.unsub();
-		const b = collect(g);
-		const aData = a.batches
-			.flat()
-			.filter((m) => m[0] === DATA)
-			.map((m) => m[1]);
-		const bData = b.batches
-			.flat()
-			.filter((m) => m[0] === DATA)
-			.map((m) => m[1]);
-		expect(aData).toEqual([1]);
-		expect(bData).toEqual([2]);
-		b.unsub();
-	});
-
-	it("defer surfaces thunk throws as ERROR", () => {
-		const g = defer<number>(() => {
-			throw new Error("boom");
-		});
-		const { batches, unsub } = collect(g);
-		const errs = batches.flat().filter((m) => m[0] === ERROR);
-		expect(errs.length).toBe(1);
-		expect((errs[0]![1] as Error).message).toBe("boom");
-		unsub();
-	});
-
-	it("defer wraps undefined thunk-throw to satisfy spec §1.3 non-undefined ERROR payload", () => {
-		const g = defer<number>(() => {
-			throw undefined;
-		});
-		const { batches, unsub } = collect(g);
-		const errs = batches.flat().filter((m) => m[0] === ERROR);
-		expect(errs.length).toBe(1);
-		expect(errs[0]![1]).toBeInstanceOf(Error);
-		expect((errs[0]![1] as Error).message).toMatch(/threw undefined/);
-		unsub();
-	});
-
-	it("defer bridges a Promise input via fromAny", async () => {
-		const g = defer<number>(() => Promise.resolve(99));
-		const v = await firstValueFrom(g);
-		expect(v).toBe(99);
-	});
-
-	it("defer accepts a Node input and forwards DATA", () => {
-		const upstream = node([], { initial: 7 });
-		const g = defer<number>(() => upstream);
-		const { batches, unsub } = collect(g);
-		const data = batches
-			.flat()
-			.filter((m) => m[0] === DATA)
-			.map((m) => m[1]);
-		expect(data).toContain(7);
-		unsub();
-	});
-});
-
-// ——————————————————————————————————————————————————————————————
-//  fromMCP (roadmap §5.2)
-// ——————————————————————————————————————————————————————————————
-
-describe("fromMCP", () => {
-	it("emits DATA for each notification", () => {
-		let handler: ((n: unknown) => void) | undefined;
-		const client = {
-			setNotificationHandler(_method: string, h: (n: unknown) => void) {
-				handler = h;
-			},
-		};
-
-		const node = fromMCP(client, { method: "notifications/tools/list_changed" });
-		const { batches, unsub } = collect(node);
-
-		handler!({ tools: ["a", "b"] });
-		handler!({ tools: ["a", "b", "c"] });
-
-		const dataBatches = batches.filter((b) => b.some((m) => m[0] === DATA));
-		expect(dataBatches.length).toBe(2);
-		expect(dataBatches[0]).toEqual([[DATA, { tools: ["a", "b"] }]]);
-		expect(dataBatches[1]).toEqual([[DATA, { tools: ["a", "b", "c"] }]]);
-		unsub();
-	});
-
-	it("defaults to notifications/message method", () => {
-		let registeredMethod: string | undefined;
-		const client = {
-			setNotificationHandler(method: string, _h: (n: unknown) => void) {
-				registeredMethod = method;
-			},
-		};
-
-		const node = fromMCP(client);
-		const unsub = node.subscribe(() => {});
-		expect(registeredMethod).toBe("notifications/message");
-		unsub();
-	});
-
-	it("detaches handler on teardown (sets no-op)", () => {
-		const handlers: Array<(n: unknown) => void> = [];
-		const client = {
-			setNotificationHandler(_method: string, h: (n: unknown) => void) {
-				handlers.push(h);
-			},
-		};
-
-		const node = fromMCP(client);
-		const unsub = node.subscribe(() => {});
-		unsub();
-
-		// After teardown, the last registered handler should be a no-op (doesn't throw).
-		expect(handlers.length).toBeGreaterThanOrEqual(2);
-		const noopHandler = handlers[handlers.length - 1];
-		expect(() => noopHandler("should-not-propagate")).not.toThrow();
-	});
-
-	it("suppresses emissions after teardown", () => {
-		let handler: ((n: unknown) => void) | undefined;
-		const client = {
-			setNotificationHandler(_method: string, h: (n: unknown) => void) {
-				handler = h;
-			},
-		};
-
-		const node = fromMCP(client);
-		const { batches, unsub } = collect(node);
-
-		handler!("before");
-		unsub();
-		// Save ref to old handler before teardown replaced it.
-		// The producer's active flag prevents emission even if the old ref is called.
-		// (No new batches should appear.)
-		const countBefore = batches.length;
-		// Calling the *new* no-op handler should not emit.
-		handler!("after");
-		expect(batches.length).toBe(countBefore);
-	});
-
-	it("emits ERROR via onDisconnect hook", () => {
-		let disconnectCb: ((err?: unknown) => void) | undefined;
-		const client = {
-			setNotificationHandler(_method: string, _h: (n: unknown) => void) {},
-		};
-
-		const node = fromMCP(client, {
-			onDisconnect: (cb) => {
-				disconnectCb = cb;
-			},
-		});
-		const { batches, unsub } = collect(node);
-
-		disconnectCb!(new Error("transport closed"));
-
-		const errorBatches = batches.filter((b) => b.some((m) => m[0] === ERROR));
-		expect(errorBatches.length).toBe(1);
-		expect((errorBatches[0][0][1] as Error).message).toBe("transport closed");
-		unsub();
-	});
-});
-
-// ——————————————————————————————————————————————————————————————
-//  fromGitHook (roadmap §5.2)
-// ——————————————————————————————————————————————————————————————
-
-describe("fromGitHook", () => {
-	const childProcess = require("node:child_process");
-	const originalExecFileSync = childProcess.execFileSync;
-
-	afterEach(() => {
-		childProcess.execFileSync = originalExecFileSync;
-		vi.useRealTimers();
-	});
-
-	/** Mock helper: `execFileSync("git", args, ...)` receives args as an array. */
-	function mockGit(handler: (args: string[]) => string) {
-		childProcess.execFileSync = (_cmd: string, args: string[]) => handler(args);
-	}
-
-	it("emits GitEvent when HEAD changes", () => {
-		vi.useFakeTimers();
-		let callCount = 0;
-		const sha1 = "aaa111";
-		const sha2 = "bbb222";
-
-		mockGit((args) => {
-			const joined = args.join(" ");
-			if (joined.startsWith("rev-parse HEAD")) {
-				callCount++;
-				return callCount <= 1 ? sha1 : sha2;
-			}
-			if (joined.startsWith("diff --name-only")) return "src/foo.ts\nsrc/bar.ts\n";
-			if (joined.includes("--format=%s")) return "fix: something";
-			if (joined.includes("--format=%an")) return "Alice";
-			return "";
-		});
-
-		const node = fromGitHook("/fake/repo", { pollMs: 100 });
-		const { batches, unsub } = collect(node);
-
-		vi.advanceTimersByTime(100);
-
-		const dataBatches = batches.filter((b) => b.some((m) => m[0] === DATA));
-		expect(dataBatches.length).toBe(1);
-		const gitEvent = dataBatches[0][0][1] as {
-			commit: string;
-			files: string[];
-			message: string;
-			author: string;
-			timestamp_ns: number;
-		};
-		expect(gitEvent.commit).toBe(sha2);
-		expect(gitEvent.files).toEqual(["src/foo.ts", "src/bar.ts"]);
-		expect(gitEvent.message).toBe("fix: something");
-		expect(gitEvent.author).toBe("Alice");
-		expect(gitEvent.timestamp_ns).toBeGreaterThan(0);
-
-		unsub();
-	});
-
-	it("does not emit when HEAD is unchanged", () => {
-		vi.useFakeTimers();
-		mockGit(() => "aaa111");
-
-		const node = fromGitHook("/fake/repo", { pollMs: 100 });
-		const { batches, unsub } = collect(node);
-
-		vi.advanceTimersByTime(500);
-		// No DATA batches when HEAD doesn't change. Non-DATA tier-1 signals
-		// (DIRTY/RESOLVED) may appear from the switchMap pipeline and are
-		// filtered here.
-		const dataBatches = batches.filter((b) => b.some((m) => m[0] === DATA));
-		expect(dataBatches.length).toBe(0);
-
-		unsub();
-	});
-
-	it("filters files with include/exclude globs", () => {
-		vi.useFakeTimers();
-		let callCount = 0;
-
-		mockGit((args) => {
-			const joined = args.join(" ");
-			if (joined.startsWith("rev-parse HEAD")) {
-				callCount++;
-				return callCount <= 1 ? "aaa" : "bbb";
-			}
-			if (joined.startsWith("diff --name-only")) return "src/foo.ts\ndocs/readme.md\ntest/bar.ts\n";
-			if (joined.includes("--format=%s")) return "update";
-			if (joined.includes("--format=%an")) return "Bob";
-			return "";
-		});
-
-		const node = fromGitHook("/fake/repo", {
-			pollMs: 100,
-			include: ["src/**"],
-			exclude: ["**/*.md"],
-		});
-		const { batches, unsub } = collect(node);
-
-		vi.advanceTimersByTime(100);
-
-		const dataBatches = batches.filter((b) => b.some((m) => m[0] === DATA));
-		expect(dataBatches.length).toBe(1);
-		const gitEvent = dataBatches[0][0][1] as { files: string[] };
-		expect(gitEvent.files).toEqual(["src/foo.ts"]);
-
-		unsub();
-	});
-
-	it("emits ERROR when git command fails during poll", () => {
-		vi.useFakeTimers();
-		let callCount = 0;
-
-		mockGit((args) => {
-			if (args[0] === "rev-parse") {
-				callCount++;
-				if (callCount <= 1) return "aaa111";
-				throw new Error("git not found");
-			}
-			return "";
-		});
-
-		const node = fromGitHook("/fake/repo", { pollMs: 100 });
-		const { batches, unsub } = collect(node);
-
-		vi.advanceTimersByTime(100);
-
-		// switchMap pipeline may interleave tier-1 signals with the terminal
-		// ERROR; locate the ERROR batch instead of asserting exactly one batch.
-		const errorBatches = batches.filter((b) => b.some((m) => m[0] === ERROR));
-		expect(errorBatches.length).toBe(1);
-		expect(errorBatches[0].find((m) => m[0] === ERROR)?.[0]).toBe(ERROR);
-
-		unsub();
-	});
-
-	it("clears timer on teardown", () => {
-		vi.useFakeTimers();
-		mockGit(() => "aaa111");
-
-		const node = fromGitHook("/fake/repo", { pollMs: 100 });
-		const { batches, unsub } = collect(node);
-
-		unsub();
-
-		vi.advanceTimersByTime(500);
-		expect(batches.length).toBe(0);
-	});
-});
diff --git a/src/__tests__/base/test-helpers.ts b/src/__tests__/base/test-helpers.ts
deleted file mode 100644
index 46a20c54..00000000
--- a/src/__tests__/base/test-helpers.ts
+++ /dev/null
@@ -1,54 +0,0 @@
-/**
- * Shared test utilities for subscribing to nodes and collecting messages.
- */
-import { START } from "@graphrefly/pure-ts/core";
-
-type Subscribable = { subscribe: (fn: (m: unknown) => void) => () => void };
-
-export type CollectOptions = {
-	flat?: boolean;
-	raw?: boolean;
-};
-
-type CollectBatchResult = { messages: unknown[][]; batches: unknown[][]; unsub: () => void };
-type CollectFlatResult = {
-	messages: [symbol, unknown?][];
-	msgs: [symbol, unknown?][];
-	unsub: () => void;
-};
-
-export function collect(
-	node: Subscribable,
-	opts: CollectOptions & { flat: true },
-): CollectFlatResult;
-export function collect(node: Subscribable, opts?: CollectOptions): CollectBatchResult;
-export function collect(
-	node: Subscribable,
-	opts?: CollectOptions,
-): CollectBatchResult | CollectFlatResult {
-	const flat = opts?.flat === true;
-	const raw = opts?.raw === true;
-
-	if (flat) {
-		const messages: [symbol, unknown?][] = [];
-		const unsub = node.subscribe((m) => {
-			for (const msg of m as [symbol, unknown?][]) {
-				if (raw || msg[0] !== START) messages.push(msg);
-			}
-		});
-		return { messages, msgs: messages, unsub };
-	}
-
-	const messages: unknown[][] = [];
-	const unsub = node.subscribe((msgs) => {
-		const filtered = raw
-			? (msgs as unknown[])
-			: (msgs as unknown[]).filter((m) => (m as [symbol, unknown])[0] !== START);
-		if (filtered.length > 0) messages.push(filtered);
-	});
-	return { messages, batches: messages, unsub };
-}
-
-export function collectFlat(node: Subscribable) {
-	return collect(node, { flat: true });
-}
diff --git a/src/__tests__/base/validate-observability.test.ts b/src/__tests__/base/validate-observability.test.ts
deleted file mode 100644
index 1b67b22a..00000000
--- a/src/__tests__/base/validate-observability.test.ts
+++ /dev/null
@@ -1,91 +0,0 @@
-import { node } from "@graphrefly/pure-ts/core";
-import { Graph } from "@graphrefly/pure-ts/graph";
-import { describe, expect, it } from "vitest";
-import { validateGraphObservability } from "../../base/validate-observability.js";
-
-describe("validateGraphObservability (D4)", () => {
-	it("passes a clean graph with registered paths and reachable pairs", () => {
-		const g = new Graph("g");
-		const a = node([], { name: "a", initial: 1 });
-		const b = node(
-			[a],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as number) * 2);
-			},
-			{ describeKind: "derived", name: "b" },
-		);
-		g.add(a, { name: "a" });
-		g.add(b, { name: "b" });
-		const r = validateGraphObservability(g, {
-			paths: ["a", "b"],
-			pairs: [["a", "b"]],
-		});
-		expect(r.ok).toBe(true);
-		expect(r.failures).toEqual([]);
-		expect(r.checks.some((c) => c.kind === "describe" && c.ok === true)).toBe(true);
-		expect(r.summary()).toContain("OK");
-	});
-
-	it("reports an observe failure on a non-existent path", () => {
-		const g = new Graph("g");
-		g.add(node([], { name: "a", initial: 0 }), { name: "a" });
-		const r = validateGraphObservability(g, { paths: ["missing"] });
-		expect(r.ok).toBe(false);
-		const obs = r.failures.find((c) => c.kind === "observe");
-		expect(obs?.ok).toBe(false);
-		if (obs?.kind === "observe") expect(obs.path).toBe("missing");
-	});
-
-	it("reports an explain failure when requireFound is true and no path exists", () => {
-		const g = new Graph("g");
-		const a = node([], { name: "a", initial: 1 });
-		const b = node([], { name: "b", initial: 2 });
-		g.add(a, { name: "a" });
-		g.add(b, { name: "b" });
-		const r = validateGraphObservability(g, { pairs: [["a", "b"]] });
-		expect(r.ok).toBe(false);
-		expect(r.failures[0]?.kind).toBe("explain");
-	});
-
-	it("requireFound: false keeps no-path pairs as passing", () => {
-		const g = new Graph("g");
-		g.add(node([], { name: "a", initial: 1 }), { name: "a" });
-		g.add(node([], { name: "b", initial: 2 }), { name: "b" });
-		const r = validateGraphObservability(g, {
-			pairs: [["a", "b"]],
-			requireFound: false,
-		});
-		expect(r.ok).toBe(true);
-	});
-
-	it("D1 formats: exercises each requested describe format and reports render length", () => {
-		const g = new Graph("g");
-		const a = node([], { name: "a", initial: 1 });
-		const b = node(
-			[a],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as number) * 2);
-			},
-			{ describeKind: "derived", name: "b" },
-		);
-		g.add(a, { name: "a" });
-		g.add(b, { name: "b" });
-		const r = validateGraphObservability(g, {
-			formats: ["mermaid", "mermaid-url", "pretty", "json"],
-		});
-		expect(r.ok).toBe(true);
-		const fmts = r.checks.filter((c) => c.kind === "describe-format");
-		expect(fmts).toHaveLength(4);
-		for (const c of fmts) {
-			if (c.kind === "describe-format" && c.ok) {
-				expect(c.length).toBeGreaterThan(0);
-			}
-		}
-	});
-});
diff --git a/src/__tests__/base/worker/worker.test.ts b/src/__tests__/base/worker/worker.test.ts
deleted file mode 100644
index c14f5353..00000000
--- a/src/__tests__/base/worker/worker.test.ts
+++ /dev/null
@@ -1,590 +0,0 @@
-import { MessageChannel } from "node:worker_threads";
-import type { Messages } from "@graphrefly/pure-ts/core";
-import {
-	batch,
-	COMPLETE,
-	DATA,
-	DIRTY,
-	ERROR,
-	node,
-	RESOLVED,
-	TEARDOWN,
-} from "@graphrefly/pure-ts/core";
-import { afterEach, describe, expect, it, vi } from "vitest";
-
-import { workerBridge } from "../../../base/worker/bridge.js";
-import {
-	deserializeError,
-	nameToSignal,
-	serializeError,
-	signalToName,
-} from "../../../base/worker/protocol.js";
-import { workerSelf } from "../../../base/worker/self.js";
-import type { WorkerTransport } from "../../../base/worker/transport.js";
-import { collect } from "../test-helpers.js";
-
-/** Create a pair of WorkerTransport backed by a node:worker_threads MessageChannel. */
-function transportPair(): [WorkerTransport, WorkerTransport] {
-	const { port1, port2 } = new MessageChannel();
-	const makeTransport = (port: typeof port1): WorkerTransport => ({
-		post(data, transfer) {
-			port.postMessage(data, transfer ?? []);
-		},
-		listen(handler) {
-			const h = (data: unknown) => handler(data);
-			port.on("message", h);
-			return () => port.off("message", h);
-		},
-		terminate() {
-			port.close();
-		},
-	});
-	return [makeTransport(port1), makeTransport(port2)];
-}
-
-function tick(ms = 0): Promise<void> {
-	return new Promise((r) => setTimeout(r, ms));
-}
-
-// ---------------------------------------------------------------------------
-// Protocol serialization
-// ---------------------------------------------------------------------------
-
-describe("worker protocol", () => {
-	it("serializes and deserializes signal names", () => {
-		expect(signalToName(TEARDOWN)).toBe("TEARDOWN");
-		expect(signalToName(COMPLETE)).toBe("COMPLETE");
-		expect(signalToName(ERROR)).toBe("ERROR");
-		expect(nameToSignal("TEARDOWN")).toBe(TEARDOWN);
-		expect(nameToSignal("COMPLETE")).toBe(COMPLETE);
-		expect(nameToSignal("UNKNOWN")).toBeUndefined();
-		expect(signalToName(Symbol("bogus"))).toBe("UNKNOWN");
-	});
-
-	it("round-trips custom Symbol.for types", () => {
-		const CUSTOM = Symbol.for("custom/MY_TYPE");
-		const name = signalToName(CUSTOM);
-		expect(name).toBe("custom/MY_TYPE");
-		const restored = nameToSignal(name);
-		expect(restored).toBe(CUSTOM);
-	});
-
-	it("serializes and deserializes errors", () => {
-		const err = new Error("test error");
-		err.name = "TestError";
-		const serialized = serializeError(err);
-		expect(serialized.message).toBe("test error");
-		expect(serialized.name).toBe("TestError");
-		expect(serialized.stack).toBeDefined();
-
-		const restored = deserializeError(serialized);
-		expect(restored.message).toBe("test error");
-		expect(restored.name).toBe("TestError");
-	});
-
-	it("serializes non-Error values", () => {
-		const serialized = serializeError("string error");
-		expect(serialized.message).toBe("string error");
-		expect(serialized.name).toBe("Error");
-	});
-});
-
-// ---------------------------------------------------------------------------
-// Bridge + Self handshake & bidirectional flow
-// ---------------------------------------------------------------------------
-
-describe("workerBridge + workerSelf", () => {
-	let bridges: Array<{ destroy(): void }> = [];
-
-	afterEach(() => {
-		for (const b of bridges) b.destroy();
-		bridges = [];
-	});
-
-	it("completes handshake and exchanges initial values", async () => {
-		const [mainTransport, workerTransport] = transportPair();
-
-		const mainNode = node([], { name: "mainVal", initial: 42 });
-
-		const bridge = workerBridge(mainTransport, {
-			expose: { mainVal: mainNode },
-			import: ["workerVal"] as const,
-			name: "test",
-		});
-		bridges.push(bridge);
-
-		const self = workerSelf(workerTransport, {
-			import: ["mainVal"] as const,
-			expose: () => {
-				const w = node([], { name: "workerVal", initial: 100 });
-				return { workerVal: w };
-			},
-		});
-		bridges.push(self);
-
-		await tick(50);
-
-		// Bridge should be connected
-		expect(bridge.meta.status.cache).toBe("connected");
-
-		// Worker's initial value should be available on main
-		expect(bridge.workerVal.cache).toBe(100);
-	});
-
-	it("forwards value updates from main to worker", async () => {
-		const [mainTransport, workerTransport] = transportPair();
-
-		const mainNode = node([], { name: "msg", initial: "hello" });
-		const bridge = workerBridge(mainTransport, {
-			expose: { msg: mainNode },
-			import: ["echo"] as const,
-		});
-		bridges.push(bridge);
-
-		let workerProxy: { cache: unknown } | undefined;
-		const self = workerSelf(workerTransport, {
-			import: ["msg"] as const,
-			expose: (imported) => {
-				workerProxy = imported.msg;
-				// Echo: derive from imported msg
-				const echo = node(
-					[imported.msg],
-					(batchData, actions, ctx) => {
-						const data = batchData.map((batch, i) =>
-							batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-						);
-						actions.emit(`echo:${data[0]}`);
-					},
-					{ describeKind: "derived" },
-				);
-				return { echo };
-			},
-		});
-		bridges.push(self);
-
-		await tick(50);
-
-		// Worker should have received initial value
-		expect(workerProxy!.cache).toBe("hello");
-
-		// Update main node -> should propagate to worker and back as echo
-		mainNode.down([[DATA, "world"]]);
-		await tick(50);
-
-		expect(workerProxy!.cache).toBe("world");
-		expect(bridge.echo.cache).toBe("echo:world");
-	});
-
-	it("forwards value updates from worker to main", async () => {
-		const [mainTransport, workerTransport] = transportPair();
-
-		let workerCounter: { down(m: Messages): void } | undefined;
-		const bridge = workerBridge(mainTransport, {
-			import: ["counter"] as const,
-		});
-		bridges.push(bridge);
-
-		const self = workerSelf(workerTransport, {
-			expose: () => {
-				const c = node([], { name: "counter", initial: 0 });
-				workerCounter = c;
-				return { counter: c };
-			},
-		});
-		bridges.push(self);
-
-		await tick(50);
-		expect(bridge.counter.cache).toBe(0);
-
-		workerCounter!.down([[DATA, 1]]);
-		await tick(50);
-		expect(bridge.counter.cache).toBe(1);
-
-		workerCounter!.down([[DATA, 2]]);
-		await tick(50);
-		expect(bridge.counter.cache).toBe(2);
-	});
-
-	it("coalesces batch updates into single message", async () => {
-		const [mainTransport, workerTransport] = transportPair();
-
-		const a = node([], { name: "a", initial: 0 });
-		const b = node([], { name: "b", initial: 0 });
-
-		const postSpy = vi.fn(mainTransport.post);
-		mainTransport.post = postSpy;
-
-		const bridge = workerBridge(mainTransport, {
-			expose: { a, b },
-			import: ["ack"] as const,
-		});
-		bridges.push(bridge);
-
-		const self = workerSelf(workerTransport, {
-			expose: () => ({ ack: node([], { initial: "ok" }) }),
-		});
-		bridges.push(self);
-
-		await tick(50);
-		postSpy.mockClear();
-
-		// Batch update both nodes
-		batch(() => {
-			a.down([[DATA, 1]]);
-			b.down([[DATA, 2]]);
-		});
-		await tick(50);
-
-		// Should have sent a single batch message (type "b") for both updates
-		const batchMessages = postSpy.mock.calls.filter(
-			([msg]) => typeof msg === "object" && msg !== null && (msg as any).t === "b",
-		);
-		expect(batchMessages.length).toBe(1);
-		expect((batchMessages[0][0] as any).u).toEqual({ a: 1, b: 2 });
-	});
-
-	it("ignores stale batch updates when versions regress", async () => {
-		const [mainTransport, workerTransport] = transportPair();
-		const bridge = workerBridge(mainTransport, {
-			import: ["counter"] as const,
-		});
-		bridges.push(bridge);
-
-		workerTransport.post({ t: "b", u: { counter: 2 }, v: { counter: 2 } });
-		await tick(20);
-		expect(bridge.counter.cache).toBe(2);
-
-		// Stale update with older version must be ignored.
-		workerTransport.post({ t: "b", u: { counter: 1 }, v: { counter: 1 } });
-		await tick(20);
-		expect(bridge.counter.cache).toBe(2);
-	});
-
-	it("forwards COMPLETE from worker to main proxy", async () => {
-		const [mainTransport, workerTransport] = transportPair();
-
-		let workerNode: { down(m: Messages): void } | undefined;
-		const bridge = workerBridge(mainTransport, {
-			import: ["src"] as const,
-		});
-		bridges.push(bridge);
-
-		const self = workerSelf(workerTransport, {
-			expose: () => {
-				const s = node([], { name: "src", initial: 0 });
-				workerNode = s;
-				return { src: s };
-			},
-		});
-		bridges.push(self);
-
-		await tick(50);
-
-		const { batches, unsub } = collect(bridge.src);
-
-		workerNode!.down([[COMPLETE]]);
-		await tick(50);
-
-		const hasComplete = batches.some((b) => b.some((m) => (m as any)[0] === COMPLETE));
-		expect(hasComplete).toBe(true);
-		unsub();
-	});
-
-	it("forwards ERROR with serialized error payload", async () => {
-		const [mainTransport, workerTransport] = transportPair();
-
-		let workerNode: { down(m: Messages): void } | undefined;
-		const bridge = workerBridge(mainTransport, {
-			import: ["src"] as const,
-		});
-		bridges.push(bridge);
-
-		const self = workerSelf(workerTransport, {
-			expose: () => {
-				const s = node([], { name: "src", initial: 0 });
-				workerNode = s;
-				return { src: s };
-			},
-		});
-		bridges.push(self);
-
-		await tick(50);
-
-		const { batches, unsub } = collect(bridge.src);
-
-		workerNode!.down([[ERROR, new Error("boom")]]);
-		await tick(50);
-
-		const errorBatch = batches.find((b) => b.some((m) => (m as any)[0] === ERROR));
-		expect(errorBatch).toBeDefined();
-		const errorMsg = errorBatch!.find((m) => (m as any)[0] === ERROR) as any;
-		expect(errorMsg[1]).toBeInstanceOf(Error);
-		expect(errorMsg[1].message).toBe("boom");
-		unsub();
-	});
-
-	it("bridge.destroy() sends TEARDOWN and sets status to closed", async () => {
-		const [mainTransport, workerTransport] = transportPair();
-
-		// Spy on worker transport to verify TEARDOWN arrives
-		const workerMessages: unknown[] = [];
-		const origListen = workerTransport.listen;
-		workerTransport.listen = (handler) => {
-			return origListen((data) => {
-				workerMessages.push(data);
-				handler(data);
-			});
-		};
-
-		const bridge = workerBridge(mainTransport, {
-			import: ["val"] as const,
-		});
-		bridges.push(bridge);
-
-		const self = workerSelf(workerTransport, {
-			expose: () => ({ val: node([], { initial: 1 }) }),
-		});
-		bridges.push(self);
-
-		await tick(50);
-		expect(bridge.meta.status.cache).toBe("connected");
-
-		workerMessages.length = 0;
-		bridge.destroy();
-		await tick(100);
-
-		expect(bridge.meta.status.cache).toBe("closed");
-		// Verify bridge sent a TEARDOWN signal message
-		const teardownMsg = workerMessages.find(
-			(m: any) => m.t === "s" && m.sig === "TEARDOWN" && m.s === "*",
-		);
-		expect(teardownMsg).toBeDefined();
-	});
-
-	it("workerSelf.destroy() cleans up without crashing", async () => {
-		const [mainTransport, workerTransport] = transportPair();
-
-		const bridge = workerBridge(mainTransport, {
-			import: ["val"] as const,
-		});
-		bridges.push(bridge);
-
-		const self = workerSelf(workerTransport, {
-			expose: () => ({ val: node([], { initial: 99 }) }),
-		});
-
-		await tick(50);
-		expect(bridge.val.cache).toBe(99);
-
-		// Destroy worker side only
-		self.destroy();
-		bridges.push(bridge); // already there, just for cleanup
-
-		// Bridge should still be functional (no crash), proxy retains last value
-		expect(bridge.val.cache).toBe(99);
-	});
-
-	it("handles import-only bridge (no expose)", async () => {
-		const [mainTransport, workerTransport] = transportPair();
-
-		const bridge = workerBridge(mainTransport, {
-			import: ["data"] as const,
-		});
-		bridges.push(bridge);
-
-		const self = workerSelf(workerTransport, {
-			expose: () => ({ data: node([], { initial: { x: 1 } }) }),
-		});
-		bridges.push(self);
-
-		await tick(50);
-		expect(bridge.data.cache).toEqual({ x: 1 });
-	});
-
-	it("handles expose-only bridge (no import)", async () => {
-		const [mainTransport, workerTransport] = transportPair();
-
-		const mainNode = node([], { initial: "shared" });
-		const bridge = workerBridge(mainTransport, {
-			expose: { shared: mainNode },
-		});
-		bridges.push(bridge);
-
-		let workerProxy: { cache: unknown } | undefined;
-		const self = workerSelf(workerTransport, {
-			import: ["shared"] as const,
-			expose: (imported) => {
-				workerProxy = imported.shared;
-				return {};
-			},
-		});
-		bridges.push(self);
-
-		await tick(50);
-		// Worker proxy receives the initial value via the init message
-		expect(workerProxy!.cache).toBe("shared");
-	});
-
-	it("double destroy is idempotent", async () => {
-		const [mainTransport, workerTransport] = transportPair();
-
-		const bridge = workerBridge(mainTransport, {
-			import: ["v"] as const,
-		});
-
-		const self = workerSelf(workerTransport, {
-			expose: () => ({ v: node([], { initial: 1 }) }),
-		});
-
-		await tick(50);
-
-		// Should not throw
-		bridge.destroy();
-		bridge.destroy();
-		self.destroy();
-		self.destroy();
-	});
-
-	it("forwards RESOLVED from worker to main proxy", async () => {
-		const [mainTransport, workerTransport] = transportPair();
-
-		let workerNode: { down(m: Messages): void } | undefined;
-		const bridge = workerBridge(mainTransport, {
-			import: ["src"] as const,
-		});
-		bridges.push(bridge);
-
-		const self = workerSelf(workerTransport, {
-			expose: () => {
-				const s = node([], { name: "src", initial: 0 });
-				workerNode = s;
-				return { src: s };
-			},
-		});
-		bridges.push(self);
-
-		await tick(50);
-
-		const { batches, unsub } = collect(bridge.src);
-
-		workerNode!.down([[RESOLVED]]);
-		await tick(50);
-
-		const hasResolved = batches.some((b) => b.some((m) => (m as any)[0] === RESOLVED));
-		expect(hasResolved).toBe(true);
-		unsub();
-	});
-
-	it("forwards custom Symbol.for message types across wire", async () => {
-		const [mainTransport, workerTransport] = transportPair();
-		const CUSTOM = Symbol.for("custom/TEST_SIGNAL");
-
-		let workerNode: { down(m: Messages): void } | undefined;
-		const bridge = workerBridge(mainTransport, {
-			import: ["src"] as const,
-		});
-		bridges.push(bridge);
-
-		const self = workerSelf(workerTransport, {
-			expose: () => {
-				const s = node([], { name: "src", initial: 0 });
-				workerNode = s;
-				return { src: s };
-			},
-		});
-		bridges.push(self);
-
-		await tick(50);
-
-		const { batches, unsub } = collect(bridge.src);
-
-		workerNode!.down([[CUSTOM, "payload"]]);
-		await tick(50);
-
-		const customMsg = batches.flat().find((m) => (m as any)[0] === CUSTOM) as any;
-		expect(customMsg).toBeDefined();
-		expect(customMsg[1]).toBe("payload");
-		unsub();
-	});
-
-	it("forwards structured payloads for custom Symbol.for types", async () => {
-		const [mainTransport, workerTransport] = transportPair();
-		const CUSTOM = Symbol.for("custom/OBJECT_SIGNAL");
-		const payload = { nested: { ok: true }, values: [1, 2, 3] };
-
-		let workerNode: { down(m: Messages): void } | undefined;
-		const bridge = workerBridge(mainTransport, {
-			import: ["src"] as const,
-		});
-		bridges.push(bridge);
-
-		const self = workerSelf(workerTransport, {
-			expose: () => {
-				const s = node([], { name: "src", initial: 0 });
-				workerNode = s;
-				return { src: s };
-			},
-		});
-		bridges.push(self);
-
-		await tick(50);
-
-		const { batches, unsub } = collect(bridge.src);
-		workerNode!.down([[CUSTOM, payload]]);
-		await tick(50);
-
-		const customMsg = batches.flat().find((m) => (m as any)[0] === CUSTOM) as any;
-		expect(customMsg).toBeDefined();
-		expect(customMsg[1]).toEqual(payload);
-		unsub();
-	});
-
-	it("does NOT forward DIRTY across wire (tier 0 stays local)", async () => {
-		const [mainTransport, workerTransport] = transportPair();
-
-		let workerNode: { down(m: Messages): void } | undefined;
-		const bridge = workerBridge(mainTransport, {
-			import: ["src"] as const,
-		});
-		bridges.push(bridge);
-
-		const self = workerSelf(workerTransport, {
-			expose: () => {
-				const s = node([], { name: "src", initial: 0 });
-				workerNode = s;
-				return { src: s };
-			},
-		});
-		bridges.push(self);
-
-		await tick(50);
-
-		const { batches, unsub } = collect(bridge.src);
-
-		workerNode!.down([[DIRTY]]);
-		await tick(50);
-
-		const hasDirty = batches.some((b) => b.some((m) => (m as any)[0] === DIRTY));
-		expect(hasDirty).toBe(false);
-		unsub();
-	});
-
-	it("handshake timeout triggers error and closes bridge", async () => {
-		const [mainTransport, _workerTransport] = transportPair();
-
-		// No workerSelf — simulate worker never responding
-		const bridge = workerBridge(mainTransport, {
-			import: ["val"] as const,
-			timeoutMs: 100,
-		});
-		bridges.push(bridge);
-
-		expect(bridge.meta.status.cache).toBe("connecting");
-
-		await tick(150);
-
-		expect(bridge.meta.status.cache).toBe("closed");
-		expect(bridge.meta.error.cache).toBeInstanceOf(Error);
-		expect((bridge.meta.error.cache as Error)!.message).toContain("timeout");
-	});
-});
diff --git a/src/__tests__/compat/jotai.test.ts b/src/__tests__/compat/jotai.test.ts
deleted file mode 100644
index e749e15f..00000000
--- a/src/__tests__/compat/jotai.test.ts
+++ /dev/null
@@ -1,163 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import { atom, type GetFn, type SetFn } from "../../compat/jotai/index.js";
-
-describe("jotai compat", () => {
-	it("primitive atom: get and set", () => {
-		const count = atom(0);
-		expect(count.get()).toBe(0);
-		count.set(1);
-		expect(count.get()).toBe(1);
-	});
-
-	it("primitive atom: update", () => {
-		const count = atom(10);
-		count.update((c) => c + 5);
-		expect(count.get()).toBe(15);
-	});
-
-	it("read-only derived atom: tracks dependencies", () => {
-		const base = atom(2);
-		const doubled = atom((get: GetFn) => get(base)! * 2);
-
-		expect(doubled.get()).toBe(4);
-		base.set(5);
-		expect(doubled.get()).toBe(10);
-	});
-
-	it("read-only derived atom: dynamic dependency switching", () => {
-		const cond = atom(true);
-		const a = atom(1);
-		const b = atom(10);
-		const result = atom((get: GetFn) => (get(cond) ? get(a) : get(b)));
-
-		expect(result.get()).toBe(1);
-		cond.set(false);
-		expect(result.get()).toBe(10);
-
-		// Changing 'a' when cond is false should not trigger re-read from 'a'
-		a.set(2);
-		expect(result.get()).toBe(10);
-	});
-
-	it("writable derived atom: custom write logic", () => {
-		const base = atom(5);
-		const clamped = atom(
-			(get: GetFn) => get(base)!,
-			(_get, set, val: number) => {
-				set(base, Math.max(0, Math.min(10, val)));
-			},
-		);
-
-		expect(clamped.get()).toBe(5);
-		clamped.set(20);
-		expect(base.get()).toBe(10);
-		clamped.set(-5);
-		expect(base.get()).toBe(0);
-	});
-
-	it("atom subscribe: receives updates", () => {
-		const count = atom(0);
-		const cb = vi.fn();
-		count.subscribe(cb);
-
-		count.set(1);
-		expect(cb).toHaveBeenCalledWith(1);
-		count.set(2);
-		expect(cb).toHaveBeenCalledWith(2);
-	});
-
-	it("atom subscribe: returns unsubscribe function", () => {
-		const count = atom(0);
-		const cb = vi.fn();
-		const unsub = count.subscribe(cb);
-
-		count.set(1);
-		expect(cb).toHaveBeenCalledWith(1);
-		unsub();
-
-		count.set(2);
-		expect(cb).toHaveBeenCalledTimes(1);
-	});
-
-	it("atom options: name", () => {
-		const a = atom(0, { name: "my-atom" });
-		expect(a._node.name).toBe("my-atom");
-	});
-
-	it("atom options: meta", () => {
-		const a = atom(0, { meta: { description: "test counter" } });
-		expect(a.meta.description).toBeDefined();
-		expect(a.meta.description.cache).toBe("test counter");
-	});
-
-	it("derived atom options: meta", () => {
-		const a = atom(0);
-		const b = atom((get: GetFn) => (get(a) ?? 0) * 2, { meta: { tag: "derived" } });
-		expect(b.meta.tag).toBeDefined();
-		expect(b.meta.tag.cache).toBe("derived");
-	});
-
-	it("derived atom: error handling", () => {
-		const a = atom(1);
-		const b = atom((get: GetFn) => {
-			const val = get(a);
-			if (val === 0) throw new Error("Zero division");
-			return 10 / (val ?? 1);
-		});
-
-		expect(b.get()).toBe(10);
-		a.set(0);
-
-		// While sentinel, it won't recompute or show 'errored' until pulled.
-		expect(b._node.status).toBe("sentinel");
-
-		// Trigger pull via get() and check throwing behavior.
-		expect(() => b.get()).toThrow("Zero division");
-
-		// After get() throws, it returns to sentinel in GraphReFly.
-		expect(b._node.status).toBe("sentinel");
-
-		// Verify it stays errored while subscribed.
-		const unsub = b.subscribe(() => {});
-		expect(b._node.status).toBe("errored");
-		unsub();
-	});
-
-	it("derived atom: diamond resolution", () => {
-		// Focus: the diamond must produce the correct final value and
-		// (under an active subscriber) fire the subscriber exactly once
-		// per base update — no intermediate glitch values.
-		const base = atom<number>(2);
-		const left = atom<number>((get: GetFn) => get(base) * 2);
-		const right = atom<number>((get: GetFn) => get(base) + 1);
-		const combined = atom<number>((get: GetFn) => get(left) + get(right));
-
-		const seen: number[] = [];
-		const unsub = combined.subscribe((v) => seen.push(v));
-
-		expect(combined.get()).toBe(7); // (2*2) + (2+1) = 4 + 3 = 7
-		expect(seen).toEqual([]); // jotai subscribe skips initial push
-
-		base.set(10);
-		expect(combined.get()).toBe(31); // (10*2) + (10+1) = 20 + 11 = 31
-		expect(seen).toEqual([31]); // exactly one cb fire, final diamond value
-
-		base.set(5);
-		expect(combined.get()).toBe(16); // 10 + 6
-		expect(seen).toEqual([31, 16]);
-
-		unsub();
-	});
-
-	it("writable derived atom: update logic", () => {
-		const base = atom<number>(10);
-		const derived = atom<number>(
-			(get: GetFn) => get(base),
-			(_get: GetFn, set: SetFn, val: number) => set(base, val),
-		);
-
-		derived.update((c) => c + 5);
-		expect(base.get()).toBe(15);
-		expect(derived.get()).toBe(15);
-	});
-});
diff --git a/src/__tests__/compat/nanostores.test.ts b/src/__tests__/compat/nanostores.test.ts
deleted file mode 100644
index 5c965722..00000000
--- a/src/__tests__/compat/nanostores.test.ts
+++ /dev/null
@@ -1,214 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import {
-	action,
-	atom,
-	computed,
-	getValue,
-	map,
-	onMount,
-	onStart,
-} from "../../compat/nanostores/index.js";
-
-describe("nanostores compat", () => {
-	describe("atom", () => {
-		it("get and set", () => {
-			const count = atom(0);
-			expect(count.get()).toBe(0);
-			count.set(1);
-			expect(count.get()).toBe(1);
-		});
-
-		it("subscribe calls immediately", () => {
-			const count = atom(0);
-			const cb = vi.fn();
-			count.subscribe(cb);
-			expect(cb).toHaveBeenCalledWith(0);
-			count.set(1);
-			expect(cb).toHaveBeenCalledWith(1);
-		});
-
-		it("listen does not call immediately", () => {
-			const count = atom(0);
-			const cb = vi.fn();
-			count.listen(cb);
-			expect(cb).not.toHaveBeenCalled();
-			count.set(1);
-			expect(cb).toHaveBeenCalledWith(1);
-		});
-
-		it("unsubscribe stops updates", () => {
-			const count = atom(0);
-			const cb = vi.fn();
-			const unsub = count.subscribe(cb);
-			expect(cb).toHaveBeenCalledWith(0);
-			unsub();
-			count.set(1);
-			expect(cb).toHaveBeenCalledTimes(1);
-		});
-	});
-
-	describe("computed", () => {
-		it("tracks dependency", () => {
-			const base = atom(2);
-			const doubled = computed(base, (v) => v * 2);
-			expect(doubled.get()).toBe(4);
-			base.set(5);
-			expect(doubled.get()).toBe(10);
-		});
-
-		it("tracks multiple dependencies", () => {
-			const a = atom(10);
-			const b = atom(20);
-			const sum = computed([a, b], (va, vb) => va + vb);
-			expect(sum.get()).toBe(30);
-			a.set(5);
-			expect(sum.get()).toBe(25);
-			b.set(5);
-			expect(sum.get()).toBe(10);
-		});
-
-		it("dynamic dependency switching", () => {
-			const cond = atom(true);
-			const a = atom(1);
-			const b = atom(10);
-			// Note: result depends on all three, but 'get' in dynamicNode
-			// will only record what is actually read during execution if we used tracking.
-			// Our computed wrapper uses a fixed dependency list from stores.
-			const result = computed([cond, a, b], (c, va, vb) => (c ? va : vb));
-
-			expect(result.get()).toBe(1);
-			cond.set(false);
-			expect(result.get()).toBe(10);
-
-			// Changing 'a' when cond is false:
-			// Since our computed wrapper passes [cond, a, b] to dynamicNode,
-			// it will recompute when 'a' changes even if cond is false.
-			// This is slightly different from true Jotai-style dynamic tracking,
-			// but matches Nanostores 'computed' which takes a fixed array of deps.
-			a.set(2);
-			expect(result.get()).toBe(10);
-		});
-
-		// FLAG: v5 behavioral change — needs investigation
-		// v5 diamond resolution computation count differs from v4 expectations
-		it("diamond resolution", () => {
-			const base = atom(2);
-			const left = computed(base, (v) => v * 2);
-			const right = computed(base, (v) => v + 1);
-			const combined = computed([left, right], (l, r) => l + r);
-
-			// Live subscriber observes cb-count correctness: the diamond
-			// must collapse into exactly one cb fire per base update, with
-			// NO glitch values (e.g. 23 = new left + stale right).
-			const seen: number[] = [];
-			const unsub = combined.subscribe((v) => seen.push(v));
-
-			expect(combined.get()).toBe(7); // 4 + 3
-			expect(seen).toEqual([7]); // nanostores subscribe fires with initial
-
-			base.set(10);
-			expect(combined.get()).toBe(31); // 20 + 11
-			expect(seen).toEqual([7, 31]); // exactly one fire, no 23 glitch
-
-			base.set(5);
-			expect(combined.get()).toBe(16); // 10 + 6
-			expect(seen).toEqual([7, 31, 16]);
-
-			unsub();
-		});
-	});
-
-	describe("map", () => {
-		it("get and set", () => {
-			const profile = map({ name: "Alice", age: 30 });
-			expect(profile.get()).toEqual({ name: "Alice", age: 30 });
-			profile.set({ name: "Bob", age: 25 });
-			expect(profile.get()).toEqual({ name: "Bob", age: 25 });
-		});
-
-		it("setKey updates specific key", () => {
-			const profile = map({ name: "Alice", age: 30 });
-			profile.setKey("age", 31);
-			expect(profile.get()).toEqual({ name: "Alice", age: 31 });
-		});
-
-		it("emits on key change", () => {
-			const profile = map({ name: "Alice" });
-			const cb = vi.fn();
-			profile.listen(cb);
-			profile.setKey("name", "Alice");
-			// Since we use equals: () => false, it should emit.
-			expect(cb).toHaveBeenCalled();
-		});
-	});
-
-	describe("utilities", () => {
-		it("getValue returns current value", () => {
-			const count = atom(42);
-			const doubled = computed(count, (v) => v * 2);
-			const profile = map({ name: "Alice" });
-
-			expect(getValue(count)).toBe(42);
-			expect(getValue(doubled)).toBe(84);
-			expect(getValue(profile)).toEqual({ name: "Alice" });
-		});
-
-		it("action batches updates", () => {
-			const count = atom(0);
-			const cb = vi.fn();
-			count.listen(cb);
-
-			const incrementTwice = action(count, "inc", () => {
-				count.set(count.get() + 1);
-				count.set(count.get() + 1);
-				return "done";
-			});
-
-			const result = incrementTwice();
-			expect(result).toBe("done");
-			// In GraphReFly, batch() defers DATA until the end of the batch block,
-			// but it does not deduplicate them. Both emissions happen after the batch concludes.
-			expect(cb).toHaveBeenCalledTimes(2);
-			expect(cb).toHaveBeenNthCalledWith(1, 1);
-			expect(cb).toHaveBeenNthCalledWith(2, 2);
-		});
-	});
-
-	describe("lifecycle", () => {
-		it("onMount/onStart/onStop", () => {
-			const count = atom(0);
-			const startCb = vi.fn();
-			const stopCb = vi.fn();
-
-			onMount(count, () => {
-				startCb();
-				return () => stopCb();
-			});
-
-			expect(startCb).not.toHaveBeenCalled();
-
-			const unsub = count.listen(() => {});
-			expect(startCb).toHaveBeenCalledTimes(1);
-			expect(stopCb).not.toHaveBeenCalled();
-
-			unsub();
-			expect(stopCb).toHaveBeenCalledTimes(1);
-		});
-
-		it("multiple listeners share mount lifecycle", () => {
-			const count = atom(0);
-			const startCb = vi.fn();
-			onStart(count, startCb);
-
-			const unsub1 = count.subscribe(() => {});
-			expect(startCb).toHaveBeenCalledTimes(1);
-
-			const unsub2 = count.subscribe(() => {});
-			expect(startCb).toHaveBeenCalledTimes(1);
-
-			unsub1();
-			unsub2();
-			// Should still only have started once.
-		});
-	});
-});
diff --git a/src/__tests__/compat/nestjs.test.ts b/src/__tests__/compat/nestjs.test.ts
deleted file mode 100644
index fc3d5ca4..00000000
--- a/src/__tests__/compat/nestjs.test.ts
+++ /dev/null
@@ -1,2000 +0,0 @@
-import "reflect-metadata";
-import {
-	COMPLETE,
-	DATA,
-	DEFAULT_ACTOR,
-	DIRTY,
-	ERROR,
-	GuardDenied,
-	type Messages,
-	type Node,
-	node,
-	policy,
-	START,
-	TEARDOWN,
-} from "@graphrefly/pure-ts/core";
-import { Graph } from "@graphrefly/pure-ts/graph";
-import { Injectable } from "@nestjs/common";
-import { Test, type TestingModule } from "@nestjs/testing";
-import { firstValueFrom as rxFirstValueFrom, take, toArray } from "rxjs";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { GraphReflyEventExplorer } from "../../compat/nestjs/explorer.js";
-import {
-	ACTOR_KEY,
-	COMMAND_HANDLERS,
-	CommandHandler,
-	CQRS_EVENT_HANDLERS,
-	CRON_HANDLERS,
-	EVENT_HANDLERS,
-	EventHandler,
-	fromHeader,
-	fromJwtPayload,
-	GRAPHREFLY_ROOT_GRAPH,
-	GraphCron,
-	GraphInterval,
-	GraphReflyGuard,
-	GraphReflyGuardImpl,
-	GraphReflyModule,
-	getActor,
-	getGraphToken,
-	getNodeToken,
-	INTERVAL_HANDLERS,
-	ObserveGateway,
-	type ObserveWsMessage,
-	OnGraphEvent,
-	observeSSE,
-	observeSubscription,
-	QUERY_HANDLERS,
-	QueryHandler,
-	SAGA_HANDLERS,
-	SagaHandler,
-	toObservable,
-} from "../../compat/nestjs/index.js";
-import type { CommandActions, CqrsEvent, CqrsGraph } from "../../utils/cqrs/index.js";
-
-// ---------------------------------------------------------------------------
-// RxJS bridge
-// ---------------------------------------------------------------------------
-
-describe("nestjs compat — RxJS bridge", () => {
-	it("toObservable: emits DATA values", async () => {
-		const s = node<number>();
-		const values$ = toObservable(s).pipe(take(2), toArray());
-		const p = rxFirstValueFrom(values$);
-
-		s.down([[DATA, 1]]);
-		s.down([[DATA, 2]]);
-
-		const result = await p;
-		expect(result).toEqual([1, 2]);
-	});
-
-	it("toObservable: errors on ERROR", async () => {
-		const s = node<number>([], { initial: 0 });
-
-		const errorP = new Promise<unknown>((_, reject) => {
-			toObservable(s).subscribe({ next: () => {}, error: reject });
-		});
-
-		s.down([[ERROR, new Error("boom")]]);
-
-		await expect(errorP).rejects.toThrow("boom");
-	});
-
-	it("toObservable: completes on COMPLETE", async () => {
-		const s = node<number>();
-		const all = toObservable(s).pipe(toArray());
-		const p = rxFirstValueFrom(all);
-
-		// Emit a value then complete
-		s.down([[DATA, 42]]);
-		s.down([[COMPLETE]]);
-
-		const result = await p;
-		expect(result).toEqual([42]);
-	});
-
-	it("toObservable: skips protocol-internal signals (DIRTY, RESOLVED)", async () => {
-		const { RESOLVED } = await import("@graphrefly/pure-ts/core");
-		const s = node<number>();
-		const values: number[] = [];
-		const sub = toObservable(s).subscribe((v) => values.push(v));
-
-		// DIRTY + RESOLVED should not produce a value emission
-		s.down([[DIRTY], [RESOLVED]]);
-		// Only DATA produces a value
-		s.down([[DIRTY], [DATA, 5]]);
-
-		expect(values).toEqual([5]);
-		sub.unsubscribe();
-	});
-
-	it("toObservable({ raw: true }): emits raw message batches", async () => {
-		const s = node<number>();
-		// Subscribe delivers [[START]] first (tier 0), then s.down splits
-		// DIRTY (tier 1 immediate) from DATA (tier 3 deferred).
-		// Three emissions total: [[START]], [[DIRTY]], [[DATA, 1]].
-		const msgs$ = toObservable(s, { raw: true }).pipe(take(3), toArray());
-		const p = rxFirstValueFrom(msgs$);
-
-		s.down([[DIRTY], [DATA, 1]]);
-
-		const result = await p;
-		expect(result).toHaveLength(3);
-		expect(result[0]).toEqual([[START]]);
-		expect(result[1]).toEqual([[DIRTY]]);
-		expect(result[2]).toEqual([[DATA, 1]]);
-	});
-
-	it("toObservable({ raw: true }): terminal batch emitted before Observable error", async () => {
-		const s = node<number>([], { initial: 0 });
-		const batches: Messages[] = [];
-		let caughtError: unknown;
-
-		await new Promise<void>((resolve) => {
-			toObservable(s, { raw: true }).subscribe({
-				next: (msgs) => batches.push(msgs),
-				error: (err) => {
-					caughtError = err;
-					resolve();
-				},
-			});
-			s.down([[ERROR, new Error("fail")]]);
-		});
-
-		expect(batches.some((b) => b.some((m) => m[0] === ERROR))).toBe(true);
-		expect(caughtError).toBeInstanceOf(Error);
-	});
-
-	it("toObservable: graph node values via graph.resolve", async () => {
-		const g = new Graph("test");
-		const s = node<number>();
-		g.add(s, { name: "counter" });
-
-		const values$ = toObservable<number>(g.resolve("counter")).pipe(take(2), toArray());
-		const p = rxFirstValueFrom(values$);
-
-		s.down([[DATA, 20]]);
-		s.down([[DATA, 30]]);
-
-		const result = await p;
-		expect(result).toEqual([20, 30]);
-	});
-
-	it("toObservable: unsubscribing the Observable unsubscribes the node", () => {
-		const s = node<number>();
-		const values: number[] = [];
-		const sub = toObservable(s).subscribe((v) => values.push(v));
-
-		s.down([[DATA, 1]]);
-		sub.unsubscribe();
-		s.down([[DATA, 2]]); // should not be received
-
-		expect(values).toEqual([1]);
-	});
-
-	it("toObservable: works with derived nodes (reactive chain)", () => {
-		const count = node<number>();
-		const doubled = node(
-			[count],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data as number) * 2);
-			},
-			{ describeKind: "derived" },
-		);
-
-		const values: number[] = [];
-		const sub = toObservable(doubled).subscribe((v) => values.push(v));
-
-		count.down([[DATA, 0]]);
-		count.down([[DATA, 3]]);
-		count.down([[DATA, 5]]);
-
-		expect(values).toEqual([0, 6, 10]);
-		sub.unsubscribe();
-	});
-});
-
-// ---------------------------------------------------------------------------
-// Tokens
-// ---------------------------------------------------------------------------
-
-describe("nestjs compat — tokens", () => {
-	it("getGraphToken returns stable symbols for same name", () => {
-		expect(getGraphToken("foo")).toBe(getGraphToken("foo"));
-		expect(getNodeToken("bar")).toBe(getNodeToken("bar"));
-		expect(getGraphToken("foo")).not.toBe(getNodeToken("foo"));
-	});
-});
-
-// ---------------------------------------------------------------------------
-// Module — forRoot
-// ---------------------------------------------------------------------------
-
-describe("nestjs compat — GraphReflyModule.forRoot", () => {
-	it("provides root graph singleton", async () => {
-		const module: TestingModule = await Test.createTestingModule({
-			imports: [GraphReflyModule.forRoot()],
-		}).compile();
-
-		const graph = module.get<Graph>(GRAPHREFLY_ROOT_GRAPH);
-		expect(graph).toBeInstanceOf(Graph);
-		expect(graph.name).toBe("root");
-
-		await module.close();
-	});
-
-	it("accepts custom graph name", async () => {
-		const module = await Test.createTestingModule({
-			imports: [GraphReflyModule.forRoot({ name: "myapp" })],
-		}).compile();
-
-		const graph = module.get<Graph>(GRAPHREFLY_ROOT_GRAPH);
-		expect(graph.name).toBe("myapp");
-
-		await module.close();
-	});
-
-	it("runs build callback", async () => {
-		const module = await Test.createTestingModule({
-			imports: [
-				GraphReflyModule.forRoot({
-					build: (g) => {
-						g.add(node([], { initial: 42 }), { name: "counter" });
-					},
-				}),
-			],
-		}).compile();
-
-		const graph = module.get<Graph>(GRAPHREFLY_ROOT_GRAPH);
-		expect(graph.node("counter").cache).toBe(42);
-
-		await module.close();
-	});
-
-	it("restores from snapshot after build", async () => {
-		const seed = new Graph("root");
-		seed.add(node([], { initial: 0 }), { name: "counter" });
-		const snapshot = seed.snapshot();
-		snapshot.nodes.counter.value = 99;
-
-		const module = await Test.createTestingModule({
-			imports: [
-				GraphReflyModule.forRoot({
-					build: (g) => g.add(node([], { initial: 0 }), { name: "counter" }),
-					snapshot,
-				}),
-			],
-		}).compile();
-
-		const graph = module.get<Graph>(GRAPHREFLY_ROOT_GRAPH);
-		expect(graph.node("counter").cache).toBe(99);
-
-		await module.close();
-	});
-
-	it("exposes declared nodes as injectable providers", async () => {
-		const module = await Test.createTestingModule({
-			imports: [
-				GraphReflyModule.forRoot({
-					build: (g) => g.add(node([], { initial: 7 }), { name: "count" }),
-					nodes: ["count"],
-				}),
-			],
-		}).compile();
-
-		const countNode = module.get<Node<number>>(getNodeToken("count"));
-		expect(countNode.cache).toBe(7);
-
-		await module.close();
-	});
-
-	it("graph.destroy() called on module close (TEARDOWN propagation)", async () => {
-		const teardownSpy = vi.fn();
-
-		const module = await Test.createTestingModule({
-			imports: [
-				GraphReflyModule.forRoot({
-					build: (g) => {
-						const s = node([], { initial: 1 });
-						s.subscribe((msgs) => {
-							for (const m of msgs) {
-								if (m[0] === TEARDOWN) teardownSpy();
-							}
-						});
-						g.add(s, { name: "s" });
-					},
-				}),
-			],
-		}).compile();
-
-		await module.init();
-		await module.close();
-
-		expect(teardownSpy).toHaveBeenCalled();
-	});
-});
-
-// ---------------------------------------------------------------------------
-// Module — forFeature
-// ---------------------------------------------------------------------------
-
-describe("nestjs compat — GraphReflyModule.forFeature", () => {
-	it("mounts feature subgraph into root", async () => {
-		const module = await Test.createTestingModule({
-			imports: [
-				GraphReflyModule.forRoot(),
-				GraphReflyModule.forFeature({
-					name: "payments",
-					build: (g) => g.add(node([], { initial: 100 }), { name: "amount" }),
-				}),
-			],
-		}).compile();
-
-		const root = module.get<Graph>(GRAPHREFLY_ROOT_GRAPH);
-		expect(root.node("payments::amount").cache).toBe(100);
-
-		const feature = module.get<Graph>(getGraphToken("payments"));
-		expect(feature).toBeInstanceOf(Graph);
-		expect(feature.name).toBe("payments");
-
-		await module.close();
-	});
-
-	it("feature teardown cascades from root on module close", async () => {
-		const teardownSpy = vi.fn();
-
-		const module = await Test.createTestingModule({
-			imports: [
-				GraphReflyModule.forRoot(),
-				GraphReflyModule.forFeature({
-					name: "temp",
-					build: (g) => {
-						const s = node([], { initial: 1 });
-						s.subscribe((msgs) => {
-							for (const m of msgs) {
-								if (m[0] === TEARDOWN) teardownSpy();
-							}
-						});
-						g.add(s, { name: "x" });
-					},
-				}),
-			],
-		}).compile();
-
-		const root = module.get<Graph>(GRAPHREFLY_ROOT_GRAPH);
-		await module.init();
-		expect(root.node("temp::x").cache).toBe(1);
-
-		await module.close();
-		expect(teardownSpy).toHaveBeenCalled();
-	});
-
-	it("exposes feature-scoped nodes as injectable", async () => {
-		const module = await Test.createTestingModule({
-			imports: [
-				GraphReflyModule.forRoot(),
-				GraphReflyModule.forFeature({
-					name: "orders",
-					build: (g) => g.add(node([], { initial: 250 }), { name: "total" }),
-					nodes: ["total"],
-				}),
-			],
-		}).compile();
-
-		const totalNode = module.get<Node<number>>(getNodeToken("orders::total"));
-		expect(totalNode.cache).toBe(250);
-
-		await module.close();
-	});
-
-	it("multiple features coexist under root", async () => {
-		const module = await Test.createTestingModule({
-			imports: [
-				GraphReflyModule.forRoot(),
-				GraphReflyModule.forFeature({
-					name: "auth",
-					build: (g) => g.add(node([], { initial: "alice" }), { name: "user" }),
-				}),
-				GraphReflyModule.forFeature({
-					name: "billing",
-					build: (g) => g.add(node([], { initial: "pro" }), { name: "plan" }),
-				}),
-			],
-		}).compile();
-
-		const root = module.get<Graph>(GRAPHREFLY_ROOT_GRAPH);
-		expect(root.node("auth::user").cache).toBe("alice");
-		expect(root.node("billing::plan").cache).toBe("pro");
-
-		await module.close();
-	});
-});
-
-// ---------------------------------------------------------------------------
-// Decorators — unit test (verify they produce correct decorator functions)
-// ---------------------------------------------------------------------------
-
-describe("nestjs compat — decorators", () => {
-	it("InjectGraph() produces a decorator function", async () => {
-		const { InjectGraph } = await import("../../compat/nestjs/decorators.js");
-		expect(typeof InjectGraph()).toBe("function");
-	});
-
-	it("InjectGraph(name) produces a decorator function", async () => {
-		const { InjectGraph } = await import("../../compat/nestjs/decorators.js");
-		expect(typeof InjectGraph("payments")).toBe("function");
-	});
-
-	it("InjectNode(path) produces a decorator function", async () => {
-		const { InjectNode } = await import("../../compat/nestjs/decorators.js");
-		expect(typeof InjectNode("payment::validate")).toBe("function");
-	});
-
-	it("InjectGraph('request') produces a decorator function", async () => {
-		const { InjectGraph } = await import("../../compat/nestjs/decorators.js");
-		expect(typeof InjectGraph("request")).toBe("function");
-	});
-
-	it("OnGraphEvent() produces a decorator function", () => {
-		expect(typeof OnGraphEvent("orders::placed")).toBe("function");
-	});
-
-	it("GraphInterval() produces a decorator function", () => {
-		expect(typeof GraphInterval(1000)).toBe("function");
-	});
-
-	it("GraphCron() produces a decorator function", () => {
-		expect(typeof GraphCron("0 9 * * 1")).toBe("function");
-	});
-});
-
-// ---------------------------------------------------------------------------
-// EventEmitter replacement — @OnGraphEvent
-// ---------------------------------------------------------------------------
-
-describe("nestjs compat — @OnGraphEvent", () => {
-	beforeEach(() => {
-		EVENT_HANDLERS.clear();
-		INTERVAL_HANDLERS.clear();
-		CRON_HANDLERS.clear();
-	});
-
-	it("method called on DATA emission from named node", async () => {
-		const received: number[] = [];
-
-		@Injectable()
-		class OrderHandler {
-			@OnGraphEvent("counter")
-			onData(value: number) {
-				received.push(value);
-			}
-		}
-
-		const module = await Test.createTestingModule({
-			imports: [
-				GraphReflyModule.forRoot({
-					build: (g) => g.add(node<number>(), { name: "counter" }),
-				}),
-			],
-			providers: [OrderHandler],
-		}).compile();
-
-		await module.init();
-
-		const graph = module.get<Graph>(GRAPHREFLY_ROOT_GRAPH);
-		graph.set("counter", 42);
-		graph.set("counter", 99);
-
-		expect(received).toEqual([42, 99]);
-
-		await module.close();
-	});
-
-	it("method not called for DIRTY-only messages (DATA-only filtering)", async () => {
-		const received: unknown[] = [];
-
-		@Injectable()
-		class Listener {
-			@OnGraphEvent("s")
-			onData(value: unknown) {
-				received.push(value);
-			}
-		}
-
-		const s = node<number>();
-		const module = await Test.createTestingModule({
-			imports: [
-				GraphReflyModule.forRoot({
-					build: (g) => g.add(s, { name: "s" }),
-				}),
-			],
-			providers: [Listener],
-		}).compile();
-
-		await module.init();
-
-		// Send DIRTY without DATA — should not trigger the handler
-		s.down([[DIRTY]]);
-		expect(received).toEqual([]);
-
-		// DATA should trigger
-		s.down([[DATA, 10]]);
-		expect(received).toEqual([10]);
-
-		await module.close();
-	});
-
-	it("subscription disposed on module destroy", async () => {
-		const received: number[] = [];
-
-		@Injectable()
-		class Listener {
-			@OnGraphEvent("s")
-			onData(value: number) {
-				received.push(value);
-			}
-		}
-
-		const s = node<number>();
-		const module = await Test.createTestingModule({
-			imports: [
-				GraphReflyModule.forRoot({
-					build: (g) => g.add(s, { name: "s" }),
-				}),
-			],
-			providers: [Listener],
-		}).compile();
-
-		await module.init();
-		s.down([[DATA, 1]]);
-		expect(received).toEqual([1]);
-
-		await module.close();
-
-		// After destroy, handler should not be called
-		s.down([[DATA, 2]]);
-		expect(received).toEqual([1]);
-	});
-
-	it("works with feature-scoped nodes via qualified path", async () => {
-		const received: string[] = [];
-
-		@Injectable()
-		class PaymentHandler {
-			@OnGraphEvent("payments::status")
-			onStatus(value: string) {
-				received.push(value);
-			}
-		}
-
-		const module = await Test.createTestingModule({
-			imports: [
-				GraphReflyModule.forRoot(),
-				GraphReflyModule.forFeature({
-					name: "payments",
-					build: (g) => g.add(node<string>(), { name: "status" }),
-				}),
-			],
-			providers: [PaymentHandler],
-		}).compile();
-
-		await module.init();
-
-		const root = module.get<Graph>(GRAPHREFLY_ROOT_GRAPH);
-		root.set("payments::status", "completed");
-
-		expect(received).toEqual(["completed"]);
-
-		await module.close();
-	});
-
-	it("multiple @OnGraphEvent decorators on same class", async () => {
-		const aValues: number[] = [];
-		const bValues: number[] = [];
-
-		@Injectable()
-		class MultiHandler {
-			@OnGraphEvent("a")
-			onA(v: number) {
-				aValues.push(v);
-			}
-
-			@OnGraphEvent("b")
-			onB(v: number) {
-				bValues.push(v);
-			}
-		}
-
-		const module = await Test.createTestingModule({
-			imports: [
-				GraphReflyModule.forRoot({
-					build: (g) => {
-						g.add(node<number>(), { name: "a" });
-						g.add(node<number>(), { name: "b" });
-					},
-				}),
-			],
-			providers: [MultiHandler],
-		}).compile();
-
-		await module.init();
-
-		const graph = module.get<Graph>(GRAPHREFLY_ROOT_GRAPH);
-		graph.set("a", 1);
-		graph.set("b", 2);
-
-		expect(aValues).toEqual([1]);
-		expect(bValues).toEqual([2]);
-
-		await module.close();
-	});
-
-	// F-CATCH D-1: a decorated host that self-registered in EVENT_HANDLERS (its
-	// per-instance initializer ran in some DI scope) but is NOT resolvable from
-	// the explorer's root injector at wiring time must be surfaced loudly, not
-	// silently skipped. ModuleRef.get can fail two ways depending on the
-	// container — throw (UnknownElementException) or return a nullish value —
-	// and both previously ended in `if (!instance) continue;` with zero signal.
-	for (const variant of [
-		{
-			name: "throws",
-			get: () => {
-				throw new Error("UnknownElementException");
-			},
-		},
-		{ name: "returns null", get: () => null },
-	] as const) {
-		it(`F-CATCH D-1: resolveInstance DI-miss (${variant.name}) warns and skips wiring`, () => {
-			const fired: number[] = [];
-
-			@Injectable()
-			class Host {
-				@OnGraphEvent("counter")
-				onData(value: number) {
-					fired.push(value);
-				}
-			}
-			// Construct once so the standard-decorator addInitializer runs and
-			// registers Host in EVENT_HANDLERS (the registry is instance-keyed).
-			new Host();
-			expect(EVENT_HANDLERS.has(Host)).toBe(true);
-
-			const graph = new Graph("d1-root");
-			graph.add(node<number>(), { name: "counter" });
-			const fakeModuleRef = { get: variant.get } as unknown as ConstructorParameters<
-				typeof GraphReflyEventExplorer
-			>[1];
-			const explorer = new GraphReflyEventExplorer(graph, fakeModuleRef);
-
-			const warn = vi.spyOn(console, "warn").mockImplementation(() => undefined);
-			try {
-				explorer.onModuleInit();
-				graph.set("counter", 7);
-
-				// Handler never wired (DI miss) — but the miss is now diagnosable.
-				expect(fired).toEqual([]);
-				expect(
-					warn.mock.calls.some(
-						(c) => typeof c[0] === "string" && /Host.*not resolvable from DI/.test(c[0]),
-					),
-				).toBe(true);
-			} finally {
-				warn.mockRestore();
-				graph.destroy();
-			}
-		});
-	}
-});
-
-// ---------------------------------------------------------------------------
-// Schedule replacement — @GraphInterval
-// ---------------------------------------------------------------------------
-
-describe("nestjs compat — @GraphInterval", () => {
-	beforeEach(() => {
-		EVENT_HANDLERS.clear();
-		INTERVAL_HANDLERS.clear();
-		CRON_HANDLERS.clear();
-	});
-	afterEach(() => {
-		vi.useRealTimers();
-	});
-
-	it("creates timer node in graph, calls method on tick", async () => {
-		vi.useFakeTimers();
-		const calls: number[] = [];
-
-		@Injectable()
-		class TickService {
-			@GraphInterval(100)
-			onTick(count: number) {
-				calls.push(count);
-			}
-		}
-
-		const module = await Test.createTestingModule({
-			imports: [GraphReflyModule.forRoot()],
-			providers: [TickService],
-		}).compile();
-
-		await module.init();
-
-		// Timer node should be visible in the graph
-		const graph = module.get<Graph>(GRAPHREFLY_ROOT_GRAPH);
-		const desc = graph.describe();
-		const scheduleKeys = Object.keys(desc.nodes).filter((k) => k.startsWith("__schedule__."));
-		expect(scheduleKeys.length).toBeGreaterThanOrEqual(1);
-		expect(scheduleKeys[0]).toMatch(/TickService\.onTick\.\d+/);
-
-		// Advance time to trigger ticks
-		vi.advanceTimersByTime(100);
-		expect(calls.length).toBeGreaterThanOrEqual(1);
-
-		vi.advanceTimersByTime(100);
-		expect(calls.length).toBeGreaterThanOrEqual(2);
-
-		await module.close();
-	});
-
-	it("timer disposed on module destroy", async () => {
-		vi.useFakeTimers();
-		const calls: number[] = [];
-
-		@Injectable()
-		class TimerService {
-			@GraphInterval(50)
-			tick(count: number) {
-				calls.push(count);
-			}
-		}
-
-		const module = await Test.createTestingModule({
-			imports: [GraphReflyModule.forRoot()],
-			providers: [TimerService],
-		}).compile();
-
-		await module.init();
-		vi.advanceTimersByTime(50);
-		const countBefore = calls.length;
-		expect(countBefore).toBeGreaterThanOrEqual(1);
-
-		await module.close();
-
-		// After destroy, no more ticks
-		vi.advanceTimersByTime(200);
-		expect(calls.length).toBe(countBefore);
-	});
-
-	it("schedule nodes removed from graph on module destroy", async () => {
-		vi.useFakeTimers();
-
-		@Injectable()
-		class Svc {
-			@GraphInterval(100)
-			work() {}
-		}
-
-		const module = await Test.createTestingModule({
-			imports: [GraphReflyModule.forRoot()],
-			providers: [Svc],
-		}).compile();
-
-		await module.init();
-
-		const graph = module.get<Graph>(GRAPHREFLY_ROOT_GRAPH);
-		const before = Object.keys(graph.describe().nodes).filter((k) => k.startsWith("__schedule__."));
-		expect(before.length).toBe(1);
-
-		await module.close();
-
-		const after = Object.keys(graph.describe().nodes).filter((k) => k.startsWith("__schedule__."));
-		expect(after.length).toBe(0);
-	});
-});
-
-// ---------------------------------------------------------------------------
-// Schedule replacement — @GraphCron (decorator metadata only)
-// ---------------------------------------------------------------------------
-
-describe("nestjs compat — @GraphCron", () => {
-	beforeEach(() => {
-		EVENT_HANDLERS.clear();
-		INTERVAL_HANDLERS.clear();
-		CRON_HANDLERS.clear();
-	});
-
-	it("stores cron metadata in global registry after instantiation", () => {
-		@Injectable()
-		class CronService {
-			@GraphCron("0 3 * * *")
-			nightly() {}
-		}
-
-		// TC39 decorators: addInitializer runs on instance creation
-		new CronService();
-
-		const metas = CRON_HANDLERS.get(CronService);
-		expect(metas).toHaveLength(1);
-		expect(metas![0]).toMatchObject({
-			expr: "0 3 * * *",
-			methodKey: "nightly",
-		});
-	});
-
-	it("cron node added to graph and visible in describe()", async () => {
-		vi.useFakeTimers();
-
-		@Injectable()
-		class ReportService {
-			@GraphCron("* * * * *")
-			everyMinute() {}
-		}
-
-		const module = await Test.createTestingModule({
-			imports: [GraphReflyModule.forRoot()],
-			providers: [ReportService],
-		}).compile();
-
-		await module.init();
-
-		const graph = module.get<Graph>(GRAPHREFLY_ROOT_GRAPH);
-		const desc = graph.describe();
-		const cronKeys = Object.keys(desc.nodes).filter((k) =>
-			k.match(/ReportService\.everyMinute\.\d+/),
-		);
-		expect(cronKeys.length).toBe(1);
-
-		await module.close();
-		vi.useRealTimers();
-	});
-});
-
-// ---------------------------------------------------------------------------
-// Actor bridge (Phase 5.1)
-// ---------------------------------------------------------------------------
-
-describe("nestjs compat — actor bridge", () => {
-	function fakeExecutionContext(req: Record<string, unknown>) {
-		return {
-			switchToHttp: () => ({
-				getRequest: () => req,
-				getResponse: () => ({}),
-			}),
-			switchToWs: () => ({ getClient: () => ({}), getData: () => ({}) }),
-			switchToRpc: () => ({ getContext: () => ({}), getData: () => ({}) }),
-			getClass: () => Object,
-			getHandler: () => () => {},
-			getArgs: () => [req],
-			getArgByIndex: (i: number) => [req][i],
-			getType: () => "http" as const,
-		} as any;
-	}
-
-	it("fromJwtPayload: extracts actor from req.user", () => {
-		const extractor = fromJwtPayload();
-		const actor = extractor(fakeExecutionContext({ user: { type: "human", id: "u1" } }));
-		expect(actor).toEqual({ type: "human", id: "u1" });
-	});
-
-	it("fromJwtPayload: returns undefined when no user", () => {
-		const extractor = fromJwtPayload();
-		expect(extractor(fakeExecutionContext({}))).toBeUndefined();
-	});
-
-	it("fromJwtPayload: custom mapping", () => {
-		const extractor = fromJwtPayload((payload: any) => ({
-			type: payload.role === "admin" ? "human" : "llm",
-			id: payload.sub,
-		}));
-		const actor = extractor(fakeExecutionContext({ user: { role: "admin", sub: "u42" } }));
-		expect(actor).toEqual({ type: "human", id: "u42" });
-	});
-
-	it("fromHeader: extracts actor from JSON header", () => {
-		const extractor = fromHeader("x-actor");
-		const actor = extractor(
-			fakeExecutionContext({
-				headers: { "x-actor": JSON.stringify({ type: "llm", id: "agent-1" }) },
-			}),
-		);
-		expect(actor).toEqual({ type: "llm", id: "agent-1" });
-	});
-
-	it("fromHeader: returns undefined for missing header", () => {
-		const extractor = fromHeader();
-		expect(extractor(fakeExecutionContext({ headers: {} }))).toBeUndefined();
-	});
-
-	it("fromHeader: returns undefined for invalid JSON and warns (F-CATCH D-2)", () => {
-		const warn = vi.spyOn(console, "warn").mockImplementation(() => undefined);
-		try {
-			const extractor = fromHeader();
-			const result = extractor(
-				fakeExecutionContext({ headers: { "x-graphrefly-actor": "not json" } }),
-			);
-			expect(result).toBeUndefined();
-			// Surface-loud: a malformed actor header must be distinguishable
-			// from an absent one, not silently collapsed to DEFAULT_ACTOR.
-			expect(warn).toHaveBeenCalledTimes(1);
-			expect(warn.mock.calls[0]?.[0]).toMatch(/x-graphrefly-actor.*not valid JSON/);
-		} finally {
-			warn.mockRestore();
-		}
-	});
-
-	it("fromHeader: a MISSING header does NOT warn (F-CATCH D-2 — only malformed is loud)", () => {
-		const warn = vi.spyOn(console, "warn").mockImplementation(() => undefined);
-		try {
-			const extractor = fromHeader();
-			expect(extractor(fakeExecutionContext({ headers: {} }))).toBeUndefined();
-			expect(warn).not.toHaveBeenCalled();
-		} finally {
-			warn.mockRestore();
-		}
-	});
-
-	it("GraphReflyGuard: attaches actor to request", () => {
-		const guard = GraphReflyGuard(fromJwtPayload());
-		const req: Record<string, unknown> = { user: { type: "human", id: "u1" } };
-		const ctx = fakeExecutionContext(req);
-
-		const result = guard.canActivate(ctx);
-		expect(result).toBe(true);
-		expect(req[ACTOR_KEY]).toMatchObject({ type: "human", id: "u1" });
-	});
-
-	it("GraphReflyGuard: defaults to DEFAULT_ACTOR when extractor returns undefined", () => {
-		const guard = GraphReflyGuard(fromJwtPayload());
-		const req: Record<string, unknown> = {};
-		guard.canActivate(fakeExecutionContext(req));
-		expect(req[ACTOR_KEY]).toEqual(DEFAULT_ACTOR);
-	});
-
-	it("GraphReflyGuard: default factory uses fromJwtPayload", () => {
-		const guard = GraphReflyGuard();
-		const req: Record<string, unknown> = { user: { type: "wallet", id: "0xabc" } };
-		guard.canActivate(fakeExecutionContext(req));
-		expect(req[ACTOR_KEY]).toMatchObject({ type: "wallet", id: "0xabc" });
-	});
-
-	it("getActor: reads actor from request", () => {
-		const req = { [ACTOR_KEY]: { type: "human", id: "u1" } };
-		const actor = getActor(req);
-		expect(actor).toEqual({ type: "human", id: "u1" });
-	});
-
-	it("getActor: returns DEFAULT_ACTOR when not attached", () => {
-		expect(getActor({})).toEqual(DEFAULT_ACTOR);
-		expect(getActor(undefined)).toEqual(DEFAULT_ACTOR);
-	});
-
-	it("GraphReflyGuardImpl is a CanActivate", () => {
-		const impl = new GraphReflyGuardImpl(() => ({ type: "system", id: "test" }));
-		expect(typeof impl.canActivate).toBe("function");
-	});
-});
-
-// ---------------------------------------------------------------------------
-// Gateway helpers (Phase 5.1)
-// ---------------------------------------------------------------------------
-
-describe("nestjs compat — observeSSE", () => {
-	it("streams DATA values as SSE frames", async () => {
-		const s = node<number>([], { initial: 0 });
-		const g = new Graph("sse-test");
-		g.add(s, { name: "counter" });
-
-		const stream = observeSSE(g, "counter");
-		const reader = stream.getReader();
-		const decoder = new TextDecoder();
-
-		s.down([[DATA, 42]]);
-		s.down([[DATA, 99]]);
-		s.down([[COMPLETE]]);
-
-		const chunks: string[] = [];
-		while (true) {
-			const { done, value } = await reader.read();
-			if (done) break;
-			chunks.push(decoder.decode(value));
-		}
-
-		const text = chunks.join("");
-		expect(text).toContain("event: data\ndata: 42\n\n");
-		expect(text).toContain("event: data\ndata: 99\n\n");
-		expect(text).toContain("event: complete\n\n");
-		g.destroy();
-	});
-
-	it("closes on ERROR", async () => {
-		const s = node<number>([], { initial: 0 });
-		const g = new Graph("sse-err");
-		g.add(s, { name: "n" });
-
-		const stream = observeSSE(g, "n");
-		const reader = stream.getReader();
-		const decoder = new TextDecoder();
-
-		s.down([[ERROR, new Error("boom")]]);
-
-		const chunks: string[] = [];
-		while (true) {
-			const { done, value } = await reader.read();
-			if (done) break;
-			chunks.push(decoder.decode(value));
-		}
-
-		expect(chunks.join("")).toContain("event: error\ndata: boom\n\n");
-		g.destroy();
-	});
-
-	it("respects actor guard on observe", () => {
-		const s = node([], {
-			guard: policy((allow) => {
-				allow("observe", { where: (a) => a.type === "human" });
-			}),
-			initial: 0,
-		});
-		const g = new Graph("sse-guard");
-		g.add(s, { name: "guarded" });
-
-		// LLM actor should be denied
-		expect(() => observeSSE(g, "guarded", { actor: { type: "llm", id: "a1" } })).toThrow(
-			GuardDenied,
-		);
-
-		// Human actor should work
-		const stream = observeSSE(g, "guarded", { actor: { type: "human", id: "u1" } });
-		expect(stream).toBeInstanceOf(ReadableStream);
-		stream.cancel();
-		g.destroy();
-	});
-
-	it("supports keepAlive", async () => {
-		vi.useFakeTimers();
-		const s = node<number>([], { initial: 0 });
-		const g = new Graph("sse-ka");
-		g.add(s, { name: "n" });
-
-		const ac = new AbortController();
-		const stream = observeSSE(g, "n", { keepAliveMs: 100, signal: ac.signal });
-		const reader = stream.getReader();
-		const decoder = new TextDecoder();
-
-		vi.advanceTimersByTime(150);
-		ac.abort();
-
-		const chunks: string[] = [];
-		while (true) {
-			const { done, value } = await reader.read();
-			if (done) break;
-			chunks.push(decoder.decode(value));
-		}
-
-		expect(chunks.join("")).toContain(": keepalive");
-		g.destroy();
-		vi.useRealTimers();
-	});
-});
-
-describe("nestjs compat — observeSubscription", () => {
-	it("yields DATA values as async iterator", async () => {
-		const s = node<string>();
-		const g = new Graph("sub-test");
-		g.add(s, { name: "msg" });
-
-		const iter = observeSubscription<string>(g, "msg");
-
-		s.down([[DATA, "hello"]]);
-		s.down([[DATA, "world"]]);
-		s.down([[COMPLETE]]);
-
-		const results: string[] = [];
-		for await (const value of iter) {
-			results.push(value);
-		}
-
-		expect(results).toEqual(["hello", "world"]);
-		g.destroy();
-	});
-
-	it("rejects on ERROR", async () => {
-		const s = node<number>();
-		const g = new Graph("sub-err");
-		g.add(s, { name: "n" });
-
-		const iter = observeSubscription<number>(g, "n");
-		s.down([[ERROR, new Error("fail")]]);
-
-		await expect(iter.next()).rejects.toThrow("fail");
-		g.destroy();
-	});
-
-	it("supports filter option", async () => {
-		const s = node<number>([], { initial: 0 });
-		const g = new Graph("sub-filter");
-		g.add(s, { name: "n" });
-
-		const iter = observeSubscription<number>(g, "n", {
-			filter: (v) => v > 5,
-		});
-
-		s.down([[DATA, 1]]);
-		s.down([[DATA, 10]]);
-		s.down([[COMPLETE]]);
-
-		const result = await iter.next();
-		expect(result).toEqual({ done: false, value: 10 });
-
-		const end = await iter.next();
-		expect(end.done).toBe(true);
-		g.destroy();
-	});
-
-	it("return() disposes the subscription", async () => {
-		const s = node<number>();
-		const g = new Graph("sub-return");
-		g.add(s, { name: "n" });
-
-		const iter = observeSubscription<number>(g, "n");
-		s.down([[DATA, 1]]);
-
-		await iter.next();
-		const ret = await iter.return!();
-		expect(ret.done).toBe(true);
-
-		// Further next() after return should be done
-		const after = await iter.next();
-		expect(after.done).toBe(true);
-		g.destroy();
-	});
-
-	it("respects actor guard", () => {
-		const s = node([], {
-			guard: policy((_allow) => {
-				// no observe allowed
-			}),
-			initial: 0,
-		});
-		const g = new Graph("sub-guard");
-		g.add(s, { name: "n" });
-
-		expect(() => observeSubscription(g, "n", { actor: { type: "human", id: "u1" } })).toThrow(
-			GuardDenied,
-		);
-		g.destroy();
-	});
-});
-
-describe("nestjs compat — ObserveGateway", () => {
-	function makeMockClient(): { send: ReturnType<typeof vi.fn>; id: string } {
-		return { send: vi.fn(), id: Math.random().toString(36) };
-	}
-
-	it("subscribe and receive DATA", () => {
-		const s = node<number>([], { initial: 0 });
-		const g = new Graph("gw-test");
-		g.add(s, { name: "counter" });
-
-		const gw = new ObserveGateway(g);
-		const client = makeMockClient();
-		gw.handleConnection(client);
-
-		const sent: ObserveWsMessage[] = [];
-		gw.handleMessage(client, { type: "subscribe", path: "counter" }, (msg) => sent.push(msg));
-
-		expect(sent).toContainEqual({ type: "subscribed", path: "counter" });
-		expect(gw.subscriptionCount(client)).toBe(1);
-
-		s.down([[DATA, 42]]);
-
-		gw.handleMessage(client, { type: "subscribe", path: "counter" }, (msg) => sent.push(msg));
-		// Already subscribed — no duplicate
-
-		gw.handleDisconnect(client);
-		expect(gw.subscriptionCount(client)).toBe(0);
-		g.destroy();
-	});
-
-	it("unsubscribe removes subscription", () => {
-		const s = node<number>([], { initial: 0 });
-		const g = new Graph("gw-unsub");
-		g.add(s, { name: "n" });
-
-		const gw = new ObserveGateway(g);
-		const client = makeMockClient();
-		gw.handleConnection(client);
-
-		const sent: ObserveWsMessage[] = [];
-		const send = (msg: ObserveWsMessage) => sent.push(msg);
-		gw.handleMessage(client, { type: "subscribe", path: "n" }, send);
-		expect(gw.subscriptionCount(client)).toBe(1);
-
-		gw.handleMessage(client, { type: "unsubscribe", path: "n" }, send);
-		expect(sent).toContainEqual({ type: "unsubscribed", path: "n" });
-		expect(gw.subscriptionCount(client)).toBe(0);
-
-		g.destroy();
-	});
-
-	it("forwards DATA to client via default send", () => {
-		const s = node<number>();
-		const g = new Graph("gw-send");
-		g.add(s, { name: "n" });
-
-		const gw = new ObserveGateway(g);
-		const client = makeMockClient();
-		gw.handleConnection(client);
-
-		// Use default send (client.send)
-		gw.handleMessage(client, JSON.stringify({ type: "subscribe", path: "n" }));
-
-		s.down([[DATA, 7]]);
-
-		expect(client.send).toHaveBeenCalled();
-		const lastCall = client.send.mock.calls.find((c: string[]) => c[0].includes('"data"'));
-		expect(lastCall).toBeDefined();
-		const msg = JSON.parse(lastCall![0]);
-		expect(msg).toMatchObject({ type: "data", path: "n", value: 7 });
-
-		gw.destroy();
-		g.destroy();
-	});
-
-	it("handles invalid command gracefully", () => {
-		const g = new Graph("gw-invalid");
-		const gw = new ObserveGateway(g);
-		const client = makeMockClient();
-		gw.handleConnection(client);
-
-		const sent: ObserveWsMessage[] = [];
-		gw.handleMessage(client, "not json {{{", (msg) => sent.push(msg));
-		expect(sent).toContainEqual({ type: "err", message: "invalid command" });
-
-		gw.destroy();
-		g.destroy();
-	});
-
-	it("handles unknown command type", () => {
-		const g = new Graph("gw-unknown");
-		const gw = new ObserveGateway(g);
-		const client = makeMockClient();
-		gw.handleConnection(client);
-
-		const sent: ObserveWsMessage[] = [];
-		gw.handleMessage(client, { type: "ping" } as any, (msg) => sent.push(msg));
-		expect(sent[0]).toMatchObject({ type: "err" });
-
-		gw.destroy();
-		g.destroy();
-	});
-
-	it("respects actor guard via extractActor", () => {
-		const s = node([], {
-			guard: policy((allow) => {
-				allow("observe", { where: (a) => a.type === "human" });
-			}),
-			initial: 0,
-		});
-		const g = new Graph("gw-guard");
-		g.add(s, { name: "guarded" });
-
-		const gw = new ObserveGateway(g, {
-			extractActor: (client: any) => client.actor,
-		});
-
-		// LLM client — guard should deny
-		const llmClient = { ...makeMockClient(), actor: { type: "llm", id: "a1" } };
-		gw.handleConnection(llmClient);
-		const sent: ObserveWsMessage[] = [];
-		gw.handleMessage(llmClient, { type: "subscribe", path: "guarded" }, (msg) => sent.push(msg));
-		expect(sent.some((m) => m.type === "err")).toBe(true);
-		expect(gw.subscriptionCount(llmClient)).toBe(0);
-
-		// Human client — should succeed
-		const humanClient = { ...makeMockClient(), actor: { type: "human", id: "u1" } };
-		gw.handleConnection(humanClient);
-		const hSent: ObserveWsMessage[] = [];
-		gw.handleMessage(humanClient, { type: "subscribe", path: "guarded" }, (msg) => hSent.push(msg));
-		expect(hSent).toContainEqual({ type: "subscribed", path: "guarded" });
-		expect(gw.subscriptionCount(humanClient)).toBe(1);
-
-		gw.destroy();
-		g.destroy();
-	});
-
-	it("disconnect disposes all client subscriptions", () => {
-		const g = new Graph("gw-disc");
-		g.add(node([], { initial: 1 }), { name: "a" });
-		g.add(node([], { initial: 2 }), { name: "b" });
-
-		const gw = new ObserveGateway(g);
-		const client = makeMockClient();
-		gw.handleConnection(client);
-
-		const noop = () => {};
-		gw.handleMessage(client, { type: "subscribe", path: "a" }, noop);
-		gw.handleMessage(client, { type: "subscribe", path: "b" }, noop);
-		expect(gw.subscriptionCount(client)).toBe(2);
-
-		gw.handleDisconnect(client);
-		expect(gw.subscriptionCount(client)).toBe(0);
-
-		g.destroy();
-	});
-
-	it("forwards ERROR and COMPLETE to client", () => {
-		const s = node<number>([], { initial: 0 });
-		const g = new Graph("gw-term");
-		g.add(s, { name: "n" });
-
-		const gw = new ObserveGateway(g);
-		const client = makeMockClient();
-		gw.handleConnection(client);
-
-		const sent: ObserveWsMessage[] = [];
-		gw.handleMessage(client, { type: "subscribe", path: "n" }, (msg) => sent.push(msg));
-
-		s.down([[ERROR, new Error("oops")]]);
-
-		expect(sent).toContainEqual(expect.objectContaining({ type: "error", path: "n" }));
-
-		gw.destroy();
-		g.destroy();
-	});
-
-	it("COMPLETE auto-cleans subscription — allows resubscribe", () => {
-		const s = node<number>([], { initial: 0 });
-		const g = new Graph("gw-resub");
-		g.add(s, { name: "n" });
-
-		const gw = new ObserveGateway(g);
-		const client = makeMockClient();
-		gw.handleConnection(client);
-
-		const sent: ObserveWsMessage[] = [];
-		const send = (msg: ObserveWsMessage) => sent.push(msg);
-		gw.handleMessage(client, { type: "subscribe", path: "n" }, send);
-		expect(gw.subscriptionCount(client)).toBe(1);
-
-		s.down([[COMPLETE]]);
-		expect(sent).toContainEqual({ type: "complete", path: "n" });
-		// Subscription should be auto-cleaned
-		expect(gw.subscriptionCount(client)).toBe(0);
-
-		gw.destroy();
-		g.destroy();
-	});
-
-	it("TEARDOWN closes WS subscription", () => {
-		const s = node<number>([], { initial: 0 });
-		const g = new Graph("gw-td");
-		g.add(s, { name: "n" });
-
-		const gw = new ObserveGateway(g);
-		const client = makeMockClient();
-		gw.handleConnection(client);
-
-		const sent: ObserveWsMessage[] = [];
-		gw.handleMessage(client, { type: "subscribe", path: "n" }, (msg) => sent.push(msg));
-		expect(gw.subscriptionCount(client)).toBe(1);
-
-		s.down([[TEARDOWN]]);
-		expect(sent).toContainEqual({ type: "complete", path: "n" });
-		expect(gw.subscriptionCount(client)).toBe(0);
-
-		gw.destroy();
-		g.destroy();
-	});
-});
-
-describe("nestjs compat — TEARDOWN handling", () => {
-	it("observeSSE closes on TEARDOWN", async () => {
-		const s = node<number>([], { initial: 0 });
-		const g = new Graph("sse-td");
-		g.add(s, { name: "n" });
-
-		const stream = observeSSE(g, "n");
-		const reader = stream.getReader();
-		const decoder = new TextDecoder();
-
-		s.down([[DATA, 1]]);
-		s.down([[TEARDOWN]]);
-
-		const chunks: string[] = [];
-		while (true) {
-			const { done, value } = await reader.read();
-			if (done) break;
-			chunks.push(decoder.decode(value));
-		}
-
-		expect(chunks.join("")).toContain("event: data\ndata: 1\n\n");
-		g.destroy();
-	});
-
-	it("observeSubscription completes on TEARDOWN", async () => {
-		const s = node<string>();
-		const g = new Graph("sub-td");
-		g.add(s, { name: "n" });
-
-		const iter = observeSubscription<string>(g, "n");
-
-		s.down([[DATA, "val"]]);
-		s.down([[TEARDOWN]]);
-
-		const results: string[] = [];
-		for await (const v of iter) {
-			results.push(v);
-		}
-
-		expect(results).toEqual(["val"]);
-		g.destroy();
-	});
-
-	it("observeSubscription disposes subscription on COMPLETE", async () => {
-		const s = node<number>();
-		const g = new Graph("sub-dispose");
-		g.add(s, { name: "n" });
-
-		const iter = observeSubscription<number>(g, "n");
-		s.down([[DATA, 1]]);
-		s.down([[COMPLETE]]);
-
-		const r1 = await iter.next();
-		expect(r1).toEqual({ done: false, value: 1 });
-
-		const r2 = await iter.next();
-		expect(r2.done).toBe(true);
-
-		// Further calls should also be done (subscription disposed)
-		const r3 = await iter.next();
-		expect(r3.done).toBe(true);
-		g.destroy();
-	});
-});
-
-// ---------------------------------------------------------------------------
-// CQRS replacement — forCqrs
-// ---------------------------------------------------------------------------
-
-describe("nestjs compat — GraphReflyModule.forCqrs", () => {
-	beforeEach(() => {
-		EVENT_HANDLERS.clear();
-		INTERVAL_HANDLERS.clear();
-		CRON_HANDLERS.clear();
-		COMMAND_HANDLERS.clear();
-		CQRS_EVENT_HANDLERS.clear();
-		QUERY_HANDLERS.clear();
-		SAGA_HANDLERS.clear();
-	});
-
-	it("creates CqrsGraph and mounts into root", async () => {
-		const module = await Test.createTestingModule({
-			imports: [
-				GraphReflyModule.forRoot(),
-				GraphReflyModule.forCqrs({
-					name: "orders",
-					build: (g) => {
-						g.event("orderPlaced");
-						g.command("placeOrder", (_payload, { emit }) => {
-							emit("orderPlaced", { id: "1" });
-						});
-					},
-				}),
-			],
-		}).compile();
-
-		const root = module.get<Graph>(GRAPHREFLY_ROOT_GRAPH);
-		const cqrsGraph = module.get<CqrsGraph>(getGraphToken("orders"));
-		expect(cqrsGraph).toBeDefined();
-		expect(cqrsGraph.name).toBe("orders");
-
-		// Mounted into root — visible via qualified path
-		const desc = root.describe();
-		expect(desc.subgraphs).toContain("orders");
-
-		cqrsGraph.dispatch("placeOrder", { id: "1" });
-		await module.close();
-	});
-
-	it("build callback registers commands, events, projections", async () => {
-		const module = await Test.createTestingModule({
-			imports: [
-				GraphReflyModule.forRoot(),
-				GraphReflyModule.forCqrs({
-					name: "shop",
-					build: (g) => {
-						g.event("itemAdded");
-						g.command("addItem", (payload, { emit }) => {
-							emit("itemAdded", payload);
-						});
-						g.projection({
-							name: "itemCount",
-							events: ["itemAdded"],
-							reducer: (_s, events) => events.length,
-							initial: 0,
-							mode: "replay",
-						});
-					},
-				}),
-			],
-		}).compile();
-
-		const cqrsGraph = module.get<CqrsGraph>(getGraphToken("shop"));
-		cqrsGraph.dispatch("addItem", { name: "widget" });
-		cqrsGraph.dispatch("addItem", { name: "gadget" });
-
-		expect(cqrsGraph.node("itemCount").cache).toBe(2);
-		await module.close();
-	});
-
-	it("exposes node paths as injectable providers", async () => {
-		const module = await Test.createTestingModule({
-			imports: [
-				GraphReflyModule.forRoot(),
-				GraphReflyModule.forCqrs({
-					name: "inv",
-					build: (g) => {
-						g.event("added");
-						g.projection({
-							name: "total",
-							events: ["added"],
-							reducer: (_s, evts) => evts.length,
-							initial: 0,
-							mode: "replay",
-						});
-					},
-					nodes: ["total"],
-				}),
-			],
-		}).compile();
-
-		const totalNode = module.get<Node<number>>(getNodeToken("inv::total"));
-		expect(totalNode.cache).toBe(0);
-
-		await module.close();
-	});
-
-	it("teardown cascades from root on module close", async () => {
-		const teardownSpy = vi.fn();
-
-		const module = await Test.createTestingModule({
-			imports: [
-				GraphReflyModule.forRoot(),
-				GraphReflyModule.forCqrs({
-					name: "temp",
-					build: (g) => {
-						const evNode = g.event("ev");
-						evNode.subscribe((msgs) => {
-							for (const m of msgs) {
-								if (m[0] === TEARDOWN) teardownSpy();
-							}
-						});
-					},
-				}),
-			],
-		}).compile();
-
-		await module.init();
-		await module.close();
-		expect(teardownSpy).toHaveBeenCalled();
-	});
-});
-
-// ---------------------------------------------------------------------------
-// CQRS replacement — @CommandHandler decorator
-// ---------------------------------------------------------------------------
-
-describe("nestjs compat — @CommandHandler", () => {
-	beforeEach(() => {
-		EVENT_HANDLERS.clear();
-		INTERVAL_HANDLERS.clear();
-		CRON_HANDLERS.clear();
-		COMMAND_HANDLERS.clear();
-		CQRS_EVENT_HANDLERS.clear();
-		QUERY_HANDLERS.clear();
-		SAGA_HANDLERS.clear();
-	});
-
-	it("registers method as command handler, invoked via dispatch", async () => {
-		const payloads: unknown[] = [];
-
-		@Injectable()
-		class OrderService {
-			@CommandHandler("orders", "placeOrder")
-			handlePlace(payload: { id: string }, { emit }: CommandActions) {
-				payloads.push(payload);
-				emit("orderPlaced", payload);
-			}
-		}
-
-		const module = await Test.createTestingModule({
-			imports: [
-				GraphReflyModule.forRoot(),
-				GraphReflyModule.forCqrs({
-					name: "orders",
-					build: (g) => {
-						g.event("orderPlaced");
-					},
-				}),
-			],
-			providers: [OrderService],
-		}).compile();
-
-		await module.init();
-
-		const cqrsGraph = module.get<CqrsGraph>(getGraphToken("orders"));
-		cqrsGraph.dispatch("placeOrder", { id: "o1" });
-
-		expect(payloads).toEqual([{ id: "o1" }]);
-		await module.close();
-	});
-
-	it("multiple commands on same class", async () => {
-		const placed: unknown[] = [];
-		const cancelled: unknown[] = [];
-
-		@Injectable()
-		class OrderService {
-			@CommandHandler("orders", "place")
-			handlePlace(p: unknown) {
-				placed.push(p);
-			}
-
-			@CommandHandler("orders", "cancel")
-			handleCancel(p: unknown) {
-				cancelled.push(p);
-			}
-		}
-
-		const module = await Test.createTestingModule({
-			imports: [GraphReflyModule.forRoot(), GraphReflyModule.forCqrs({ name: "orders" })],
-			providers: [OrderService],
-		}).compile();
-
-		await module.init();
-
-		const g = module.get<CqrsGraph>(getGraphToken("orders"));
-		g.dispatch("place", { id: "1" });
-		g.dispatch("cancel", { id: "2" });
-
-		expect(placed).toEqual([{ id: "1" }]);
-		expect(cancelled).toEqual([{ id: "2" }]);
-
-		await module.close();
-	});
-});
-
-// ---------------------------------------------------------------------------
-// CQRS replacement — @EventHandler decorator
-// ---------------------------------------------------------------------------
-
-describe("nestjs compat — @EventHandler", () => {
-	beforeEach(() => {
-		EVENT_HANDLERS.clear();
-		INTERVAL_HANDLERS.clear();
-		CRON_HANDLERS.clear();
-		COMMAND_HANDLERS.clear();
-		CQRS_EVENT_HANDLERS.clear();
-		QUERY_HANDLERS.clear();
-		SAGA_HANDLERS.clear();
-	});
-
-	it("delivers new CqrsEvent envelopes to decorated method", async () => {
-		const received: CqrsEvent[] = [];
-
-		@Injectable()
-		class NotifyService {
-			@EventHandler("orders", "orderPlaced")
-			onPlaced(event: CqrsEvent) {
-				received.push(event);
-			}
-		}
-
-		const module = await Test.createTestingModule({
-			imports: [
-				GraphReflyModule.forRoot(),
-				GraphReflyModule.forCqrs({
-					name: "orders",
-					build: (g) => {
-						g.event("orderPlaced");
-						g.command("place", (_p, { emit }) => {
-							emit("orderPlaced", { id: _p.id });
-						});
-					},
-				}),
-			],
-			providers: [NotifyService],
-		}).compile();
-
-		await module.init();
-
-		const g = module.get<CqrsGraph>(getGraphToken("orders"));
-		g.dispatch("place", { id: "o1" });
-		g.dispatch("place", { id: "o2" });
-
-		expect(received).toHaveLength(2);
-		expect(received[0].type).toBe("orderPlaced");
-		expect(received[0].payload).toEqual({ id: "o1" });
-		expect(received[1].payload).toEqual({ id: "o2" });
-
-		await module.close();
-	});
-
-	it("only delivers new events, not historical", async () => {
-		const received: CqrsEvent[] = [];
-
-		@Injectable()
-		class Listener {
-			@EventHandler("shop", "itemAdded")
-			onItem(event: CqrsEvent) {
-				received.push(event);
-			}
-		}
-
-		const module = await Test.createTestingModule({
-			imports: [
-				GraphReflyModule.forRoot(),
-				GraphReflyModule.forCqrs({
-					name: "shop",
-					build: (g) => {
-						g.event("itemAdded");
-						g.command("add", (_p, { emit }) => emit("itemAdded", _p));
-					},
-				}),
-			],
-			providers: [Listener],
-		}).compile();
-
-		// Dispatch before init — events land in the log but handler isn't wired yet
-		const g = module.get<CqrsGraph>(getGraphToken("shop"));
-		g.dispatch("add", { name: "pre-init" });
-
-		await module.init();
-
-		// After init, new events should arrive
-		g.dispatch("add", { name: "post-init" });
-
-		// Only post-init event delivered
-		expect(received).toHaveLength(1);
-		expect(received[0].payload).toEqual({ name: "post-init" });
-
-		await module.close();
-	});
-});
-
-// ---------------------------------------------------------------------------
-// CQRS replacement — @QueryHandler decorator
-// ---------------------------------------------------------------------------
-
-describe("nestjs compat — @QueryHandler", () => {
-	beforeEach(() => {
-		EVENT_HANDLERS.clear();
-		INTERVAL_HANDLERS.clear();
-		CRON_HANDLERS.clear();
-		COMMAND_HANDLERS.clear();
-		CQRS_EVENT_HANDLERS.clear();
-		QUERY_HANDLERS.clear();
-		SAGA_HANDLERS.clear();
-	});
-
-	it("pushes projection value changes to decorated method", async () => {
-		const values: number[] = [];
-
-		@Injectable()
-		class DashboardService {
-			@QueryHandler("shop", "itemCount")
-			onCountChanged(count: number) {
-				values.push(count);
-			}
-		}
-
-		const module = await Test.createTestingModule({
-			imports: [
-				GraphReflyModule.forRoot(),
-				GraphReflyModule.forCqrs({
-					name: "shop",
-					build: (g) => {
-						g.event("itemAdded");
-						g.command("add", (_p, { emit }) => emit("itemAdded", _p));
-						g.projection({
-							name: "itemCount",
-							events: ["itemAdded"],
-							reducer: (_s, evts) => evts.length,
-							initial: 0,
-							mode: "replay",
-						});
-					},
-				}),
-			],
-			providers: [DashboardService],
-		}).compile();
-
-		await module.init();
-
-		const g = module.get<CqrsGraph>(getGraphToken("shop"));
-		g.dispatch("add", { name: "a" });
-		g.dispatch("add", { name: "b" });
-
-		// Initial projection value (0) is pushed on subscribe, then updates
-		expect(values).toEqual([0, 1, 2]);
-
-		await module.close();
-	});
-});
-
-// ---------------------------------------------------------------------------
-// CQRS replacement — @SagaHandler decorator
-// ---------------------------------------------------------------------------
-
-describe("nestjs compat — @SagaHandler", () => {
-	beforeEach(() => {
-		EVENT_HANDLERS.clear();
-		INTERVAL_HANDLERS.clear();
-		CRON_HANDLERS.clear();
-		COMMAND_HANDLERS.clear();
-		CQRS_EVENT_HANDLERS.clear();
-		QUERY_HANDLERS.clear();
-		SAGA_HANDLERS.clear();
-	});
-
-	it("registers saga subgraph, delivers new events", async () => {
-		const processed: CqrsEvent[] = [];
-
-		@Injectable()
-		class FulfillmentService {
-			@SagaHandler("orders", "fulfillment", ["orderPlaced"])
-			onOrder(event: CqrsEvent) {
-				processed.push(event);
-			}
-		}
-
-		const module = await Test.createTestingModule({
-			imports: [
-				GraphReflyModule.forRoot(),
-				GraphReflyModule.forCqrs({
-					name: "orders",
-					build: (g) => {
-						g.event("orderPlaced");
-						g.command("place", (_p, { emit }) => emit("orderPlaced", _p));
-					},
-				}),
-			],
-			providers: [FulfillmentService],
-		}).compile();
-
-		await module.init();
-
-		const g = module.get<CqrsGraph>(getGraphToken("orders"));
-		g.dispatch("place", { id: "o1" });
-		g.dispatch("place", { id: "o2" });
-
-		expect(processed).toHaveLength(2);
-		expect(processed[0].type).toBe("orderPlaced");
-		expect(processed[0].payload).toEqual({ id: "o1" });
-		expect(processed[1].payload).toEqual({ id: "o2" });
-
-		await module.close();
-	});
-
-	it("saga listens to multiple event streams", async () => {
-		const processed: CqrsEvent[] = [];
-
-		@Injectable()
-		class MultiSaga {
-			@SagaHandler("shop", "monitor", ["orderPlaced", "orderCancelled"])
-			onAny(event: CqrsEvent) {
-				processed.push(event);
-			}
-		}
-
-		const module = await Test.createTestingModule({
-			imports: [
-				GraphReflyModule.forRoot(),
-				GraphReflyModule.forCqrs({
-					name: "shop",
-					build: (g) => {
-						g.event("orderPlaced");
-						g.event("orderCancelled");
-						g.command("place", (_p, { emit }) => emit("orderPlaced", _p));
-						g.command("cancel", (_p, { emit }) => emit("orderCancelled", _p));
-					},
-				}),
-			],
-			providers: [MultiSaga],
-		}).compile();
-
-		await module.init();
-
-		const g = module.get<CqrsGraph>(getGraphToken("shop"));
-		g.dispatch("place", { id: "1" });
-		g.dispatch("cancel", { id: "2" });
-
-		expect(processed).toHaveLength(2);
-		expect(processed.map((e) => e.type)).toEqual(["orderPlaced", "orderCancelled"]);
-
-		await module.close();
-	});
-});
-
-// ---------------------------------------------------------------------------
-// CQRS decorator metadata — unit tests
-// ---------------------------------------------------------------------------
-
-describe("nestjs compat — CQRS decorators (metadata)", () => {
-	beforeEach(() => {
-		COMMAND_HANDLERS.clear();
-		CQRS_EVENT_HANDLERS.clear();
-		QUERY_HANDLERS.clear();
-		SAGA_HANDLERS.clear();
-	});
-
-	it("@CommandHandler stores metadata after instantiation", () => {
-		@Injectable()
-		class Svc {
-			@CommandHandler("orders", "place")
-			handle() {}
-		}
-
-		new Svc();
-		const metas = COMMAND_HANDLERS.get(Svc);
-		expect(metas).toHaveLength(1);
-		expect(metas![0]).toMatchObject({
-			cqrsName: "orders",
-			commandName: "place",
-			methodKey: "handle",
-		});
-	});
-
-	it("@EventHandler stores metadata after instantiation", () => {
-		@Injectable()
-		class Svc {
-			@EventHandler("orders", "placed")
-			on() {}
-		}
-
-		new Svc();
-		const metas = CQRS_EVENT_HANDLERS.get(Svc);
-		expect(metas).toHaveLength(1);
-		expect(metas![0]).toMatchObject({ cqrsName: "orders", eventName: "placed", methodKey: "on" });
-	});
-
-	it("@QueryHandler stores metadata after instantiation", () => {
-		@Injectable()
-		class Svc {
-			@QueryHandler("orders", "count")
-			on() {}
-		}
-
-		new Svc();
-		const metas = QUERY_HANDLERS.get(Svc);
-		expect(metas).toHaveLength(1);
-		expect(metas![0]).toMatchObject({
-			cqrsName: "orders",
-			projectionName: "count",
-			methodKey: "on",
-		});
-	});
-
-	it("@SagaHandler stores metadata after instantiation", () => {
-		@Injectable()
-		class Svc {
-			@SagaHandler("orders", "mySaga", ["placed", "shipped"])
-			handle() {}
-		}
-
-		new Svc();
-		const metas = SAGA_HANDLERS.get(Svc);
-		expect(metas).toHaveLength(1);
-		expect(metas![0]).toMatchObject({
-			cqrsName: "orders",
-			sagaName: "mySaga",
-			eventNames: ["placed", "shipped"],
-			methodKey: "handle",
-		});
-	});
-});
diff --git a/src/__tests__/compat/react.test.ts b/src/__tests__/compat/react.test.ts
deleted file mode 100644
index e1d6bae1..00000000
--- a/src/__tests__/compat/react.test.ts
+++ /dev/null
@@ -1,96 +0,0 @@
-/**
- * @vitest-environment jsdom
- */
-
-import { DATA, node } from "@graphrefly/pure-ts/core";
-import { act, renderHook } from "@testing-library/react";
-import { StrictMode } from "react";
-import { describe, expect, it } from "vitest";
-import { useStore, useSubscribe, useSubscribeRecord } from "../../compat/react/index.js";
-
-describe("React bindings", () => {
-	it("useSubscribe reads value and updates", () => {
-		const testNode = node({ initial: 0 });
-		const { result } = renderHook(() => useSubscribe(testNode));
-
-		expect(result.current).toBe(0);
-
-		act(() => {
-			testNode.down([[DATA, 1]]);
-		});
-
-		expect(result.current).toBe(1);
-	});
-
-	it("useSubscribe is stable under StrictMode (no fresh-closure re-subscribe loop)", () => {
-		// Regression for memo:Re Story 3.6 finding: fresh subscribe/getSnapshot
-		// closures per render caused useSyncExternalStore to re-subscribe each
-		// render, and push-on-subscribe nodes would loop into "Maximum update
-		// depth exceeded". The useCallback([node]) memoization fixes it.
-		const testNode = node({ initial: 42 });
-		let renderCount = 0;
-		const { result } = renderHook(
-			() => {
-				renderCount++;
-				return useSubscribe(testNode);
-			},
-			{ wrapper: StrictMode },
-		);
-
-		expect(result.current).toBe(42);
-		// StrictMode doubles the initial mount renders; bound is generous but
-		// catches any unbounded re-subscribe loop.
-		expect(renderCount).toBeLessThanOrEqual(5);
-
-		const before = renderCount;
-		act(() => {
-			testNode.down([[DATA, 43]]);
-		});
-		expect(result.current).toBe(43);
-		// Exactly one settled update should produce a small bounded delta.
-		expect(renderCount - before).toBeLessThanOrEqual(4);
-	});
-
-	it("useStore provides state and setter", () => {
-		const testNode = node({ initial: 10 });
-		const { result } = renderHook(() => useStore(testNode));
-
-		expect(result.current[0]).toBe(10);
-
-		act(() => {
-			result.current[1](20);
-		});
-
-		expect(result.current[0]).toBe(20);
-		expect(testNode.cache).toBe(20);
-	});
-
-	it("useSubscribeRecord tracks multiple nodes and re-subscribes properly", () => {
-		const a = node({ initial: "A" });
-		const b = node({ initial: "B" });
-		const keysNode = node<string[]>({ initial: ["a"] });
-
-		const factory = (key: string) => ({ val: key === "a" ? a : b });
-
-		const { result } = renderHook(() => useSubscribeRecord(keysNode, factory));
-
-		expect(result.current).toEqual({ a: { val: "A" } });
-
-		act(() => {
-			a.down([[DATA, "A+"]]);
-		});
-
-		expect(result.current).toEqual({ a: { val: "A+" } });
-
-		act(() => {
-			keysNode.down([[DATA, ["a", "b"]]]);
-		});
-
-		expect(result.current).toEqual({ a: { val: "A+" }, b: { val: "B" } });
-
-		act(() => {
-			b.down([[DATA, "B+"]]);
-		});
-		expect(result.current).toEqual({ a: { val: "A+" }, b: { val: "B+" } });
-	});
-});
diff --git a/src/__tests__/compat/signals-autotrack.test.ts b/src/__tests__/compat/signals-autotrack.test.ts
deleted file mode 100644
index 6c24bab6..00000000
--- a/src/__tests__/compat/signals-autotrack.test.ts
+++ /dev/null
@@ -1,535 +0,0 @@
-/**
- * Semantic edge cases for `autoTrackNode` via the Signal compat layer.
- *
- * Focus: value correctness (`.get()`) and cb count correctness
- * (subscriber fires). Fn call counts are an implementation detail and
- * are NOT asserted here — the compat contracts with Jotai and TC39
- * Signals only specify "cb fires on genuine value changes," not "fn
- * runs exactly N times."
- */
-
-import { DATA } from "@graphrefly/pure-ts/core";
-import { describe, expect, it } from "vitest";
-import { Signal } from "../../compat/signals/index.js";
-
-describe("compat/signals — autoTrackNode semantics", () => {
-	it("conditional branch switching fires cb only on value changes", () => {
-		const useA = new Signal.State(true);
-		const a = new Signal.State("a1");
-		const b = new Signal.State("b1");
-
-		const result = new Signal.Computed(() => (useA.get() ? a.get() : b.get()));
-
-		const seen: string[] = [];
-		const unsub = Signal.sub(result, (v) => seen.push(v));
-
-		expect(result.get()).toBe("a1");
-		expect(seen).toEqual([]); // Signal.sub skips initial push
-
-		// Flip to b's branch — exactly one fire with b's current value.
-		useA.set(false);
-		expect(result.get()).toBe("b1");
-		expect(seen).toEqual(["b1"]);
-
-		// a is no longer the active branch → no fire.
-		a.set("a2");
-		expect(result.get()).toBe("b1");
-		expect(seen).toEqual(["b1"]);
-
-		// Flip back — must reflect a's CURRENT value "a2", not stale "a1".
-		useA.set(true);
-		expect(result.get()).toBe("a2");
-		expect(seen).toEqual(["b1", "a2"]);
-
-		// Setting b while b is not the active branch → no fire.
-		b.set("b3");
-		expect(result.get()).toBe("a2");
-		expect(seen).toEqual(["b1", "a2"]);
-
-		// Flip again — must reflect b's latest value "b3".
-		useA.set(false);
-		expect(result.get()).toBe("b3");
-		expect(seen).toEqual(["b1", "a2", "b3"]);
-
-		unsub();
-	});
-
-	it("downstream computed chain advances when inner branch-switches", () => {
-		const useA = new Signal.State(true);
-		const a = new Signal.State("a1");
-		const b = new Signal.State("b1");
-
-		const inner = new Signal.Computed(() => (useA.get() ? a.get() : b.get()));
-		const outer = new Signal.Computed(() => `[${inner.get()}]`);
-
-		const seen: string[] = [];
-		const unsub = Signal.sub(outer, (v) => seen.push(v));
-
-		expect(outer.get()).toBe("[a1]");
-		expect(seen).toEqual([]);
-
-		useA.set(false);
-		expect(outer.get()).toBe("[b1]");
-		expect(seen).toEqual(["[b1]"]);
-
-		b.set("b2");
-		expect(outer.get()).toBe("[b2]");
-		expect(seen).toEqual(["[b1]", "[b2]"]);
-
-		// a change, but a is not in inner's currently-used branch.
-		a.set("a2");
-		expect(outer.get()).toBe("[b2]");
-		expect(seen).toEqual(["[b1]", "[b2]"]);
-
-		// Switch back — outer must see the fresh "a2".
-		useA.set(true);
-		expect(outer.get()).toBe("[a2]");
-		expect(seen).toEqual(["[b1]", "[b2]", "[a2]"]);
-
-		unsub();
-	});
-
-	it("transitive skip when mid-chain computed result is unchanged", () => {
-		// Classic equality-suppression case: x flips between odd values, so
-		// mod stays at 1. Downstream chain must not fire cb, because its
-		// underlying value hasn't changed.
-		const x = new Signal.State(1);
-		const mod = new Signal.Computed(() => x.get() % 2);
-		const chain = new Signal.Computed(() => mod.get() * 10);
-
-		const seen: number[] = [];
-		const unsub = Signal.sub(chain, (v) => seen.push(v));
-
-		expect(chain.get()).toBe(10);
-		expect(seen).toEqual([]);
-
-		// x: 1 → 3 → 5, mod stays 1, chain stays 10, subscriber silent.
-		x.set(3);
-		expect(chain.get()).toBe(10);
-		expect(seen).toEqual([]);
-
-		x.set(5);
-		expect(chain.get()).toBe(10);
-		expect(seen).toEqual([]);
-
-		// x: 5 → 4, mod flips to 0, chain becomes 0, subscriber fires.
-		x.set(4);
-		expect(chain.get()).toBe(0);
-		expect(seen).toEqual([0]);
-
-		// x: 4 → 6, mod stays 0, chain stays 0, silent.
-		x.set(6);
-		expect(chain.get()).toBe(0);
-		expect(seen).toEqual([0]);
-
-		// x: 6 → 7, mod flips to 1, chain back to 10.
-		x.set(7);
-		expect(chain.get()).toBe(10);
-		expect(seen).toEqual([0, 10]);
-
-		unsub();
-	});
-
-	it("sibling dep still advances outer when inner emits RESOLVED", () => {
-		// Two-way bridge regression: when inner's fn runs but produces an
-		// unchanged value (→ RESOLVED framed), outer's dep.inner must be
-		// cleared so a subsequent sibling update to outer still advances.
-		//
-		// An earlier implementation swallowed the no-op emission entirely,
-		// leaving outer's dep record stuck dirty and freezing the chain.
-		const useA = new Signal.State(true);
-		const a = new Signal.State("a1");
-		const b = new Signal.State("b1");
-		const inner = new Signal.Computed(() => (useA.get() ? a.get() : b.get()));
-
-		const other = new Signal.State("o1");
-		const outer = new Signal.Computed(() => `${inner.get()}|${other.get()}`);
-
-		const seen: string[] = [];
-		const unsub = Signal.sub(outer, (v) => seen.push(v));
-
-		expect(outer.get()).toBe("a1|o1");
-
-		useA.set(false);
-		expect(outer.get()).toBe("b1|o1");
-		expect(seen).toEqual(["b1|o1"]);
-
-		// a is now the unused branch. inner's wave is a no-op.
-		a.set("a2");
-		expect(outer.get()).toBe("b1|o1");
-		expect(seen).toEqual(["b1|o1"]);
-
-		// Sibling dep of outer — must still advance outer past the no-op.
-		other.set("o2");
-		expect(outer.get()).toBe("b1|o2");
-		expect(seen).toEqual(["b1|o1", "b1|o2"]);
-
-		// Another round of inner no-op + sibling update, to catch any
-		// residual "stuck once cleared stays stuck" bugs.
-		a.set("a3");
-		other.set("o3");
-		expect(outer.get()).toBe("b1|o3");
-		expect(seen).toEqual(["b1|o1", "b1|o2", "b1|o3"]);
-
-		unsub();
-	});
-
-	it("diamond where one leg is a no-op still fires subscriber exactly once", () => {
-		const base = new Signal.State(1);
-		const even = new Signal.Computed(() => base.get() % 2 === 0); // false
-		const doubled = new Signal.Computed(() => base.get() * 2); // 2
-		const final = new Signal.Computed(() => `${even.get()}:${doubled.get()}`);
-
-		const seen: string[] = [];
-		const unsub = Signal.sub(final, (v) => seen.push(v));
-
-		expect(final.get()).toBe("false:2");
-		expect(seen).toEqual([]);
-
-		// 1 → 3: even stays false (RESOLVED), doubled goes 2 → 6 (DATA).
-		// The diamond must collapse into exactly one cb fire at the final
-		// node — no intermediate "false:2" (stale doubled) or glitches.
-		base.set(3);
-		expect(final.get()).toBe("false:6");
-		expect(seen).toEqual(["false:6"]);
-
-		// 3 → 5: both legs stay the same parity → doubled changes, even
-		// stays false. One cb fire.
-		base.set(5);
-		expect(final.get()).toBe("false:10");
-		expect(seen).toEqual(["false:6", "false:10"]);
-
-		// 5 → 4: parity flips → both legs change. One cb fire with the
-		// final diamond-resolved value.
-		base.set(4);
-		expect(final.get()).toBe("true:8");
-		expect(seen).toEqual(["false:6", "false:10", "true:8"]);
-
-		unsub();
-	});
-
-	it("multi-level conditional with grow-only dep sets and cb-count fidelity", () => {
-		// Three-level switch:
-		//   level1 = useA ? a : b
-		//   level2 = useX ? x : level1.get()
-		//   top    = ${level2} + ${meta}
-		//
-		// Both the level1 and level2 autoTrackNodes grow their dep sets as
-		// the branches flip. top has meta as an unrelated dep to stress the
-		// "sibling dep must still advance after inner no-op" path. The
-		// observer `seen` is the source of truth for correctness.
-		const useA = new Signal.State(true);
-		const useX = new Signal.State(true);
-		const a = new Signal.State("a1");
-		const b = new Signal.State("b1");
-		const x = new Signal.State("x1");
-		const meta = new Signal.State(0);
-
-		const level1 = new Signal.Computed(() => (useA.get() ? a.get() : b.get()));
-		const level2 = new Signal.Computed(() => (useX.get() ? x.get() : level1.get()));
-		const top = new Signal.Computed(() => `${level2.get()}#${meta.get()}`);
-
-		const seen: string[] = [];
-		const unsub = Signal.sub(top, (v) => seen.push(v));
-
-		expect(top.get()).toBe("x1#0");
-		expect(seen).toEqual([]);
-
-		// Change unused dep of level2 — top must not fire.
-		a.set("a2");
-		expect(top.get()).toBe("x1#0");
-		expect(seen).toEqual([]);
-
-		// Change the active dep of level2 — top must fire once.
-		x.set("x2");
-		expect(top.get()).toBe("x2#0");
-		expect(seen).toEqual(["x2#0"]);
-
-		// Flip level2's branch. level2 now depends on level1, which still
-		// depends on a via useA=true. a.cache is "a2" from earlier.
-		useX.set(false);
-		expect(top.get()).toBe("a2#0");
-		expect(seen).toEqual(["x2#0", "a2#0"]);
-
-		// Change x — no longer used. top stays.
-		x.set("x3");
-		expect(top.get()).toBe("a2#0");
-		expect(seen).toEqual(["x2#0", "a2#0"]);
-
-		// Change a — propagates through level1 → level2 → top.
-		a.set("a3");
-		expect(top.get()).toBe("a3#0");
-		expect(seen).toEqual(["x2#0", "a2#0", "a3#0"]);
-
-		// Flip level1's branch inside level2's chain.
-		useA.set(false);
-		expect(top.get()).toBe("b1#0");
-		expect(seen).toEqual(["x2#0", "a2#0", "a3#0", "b1#0"]);
-
-		// Change a while a is unused at level1 AND x is unused at level2.
-		// Neither level1 nor level2 produces new data — no fires at top.
-		a.set("a4");
-		x.set("x4");
-		expect(top.get()).toBe("b1#0");
-		expect(seen).toEqual(["x2#0", "a2#0", "a3#0", "b1#0"]);
-
-		// meta (unrelated sibling dep of top) must still fire top.
-		meta.set(1);
-		expect(top.get()).toBe("b1#1");
-		expect(seen).toEqual(["x2#0", "a2#0", "a3#0", "b1#0", "b1#1"]);
-
-		// Flip all the way back to the original shape — values must be
-		// the CURRENT ones, not stale snapshots from earlier in the test.
-		useX.set(true);
-		expect(top.get()).toBe("x4#1"); // x was set to "x4" above
-		expect(seen).toEqual(["x2#0", "a2#0", "a3#0", "b1#0", "b1#1", "x4#1"]);
-
-		unsub();
-	});
-
-	it("multiple subscribers see the same value and the same fire count", () => {
-		// Two independent subscribers attached to the same computed must
-		// each see identical values in identical order. This catches
-		// "first subscriber gets DATA, second subscriber gets stale push-
-		// on-subscribe from a mid-discovery state" bugs.
-		const count = new Signal.State(0);
-		const doubled = new Signal.Computed(() => count.get() * 2);
-
-		const seenA: number[] = [];
-		const seenB: number[] = [];
-
-		const unsubA = Signal.sub(doubled, (v) => seenA.push(v));
-		const unsubB = Signal.sub(doubled, (v) => seenB.push(v));
-
-		expect(doubled.get()).toBe(0);
-		expect(seenA).toEqual([]);
-		expect(seenB).toEqual([]);
-
-		count.set(3);
-		expect(doubled.get()).toBe(6);
-		expect(seenA).toEqual([6]);
-		expect(seenB).toEqual([6]);
-
-		count.set(3); // same value → no fires (equals check in SignalState.set)
-		expect(seenA).toEqual([6]);
-		expect(seenB).toEqual([6]);
-
-		count.set(7);
-		expect(doubled.get()).toBe(14);
-		expect(seenA).toEqual([6, 14]);
-		expect(seenB).toEqual([6, 14]);
-
-		unsubA();
-
-		count.set(10);
-		expect(doubled.get()).toBe(20);
-		expect(seenA).toEqual([6, 14]); // A was unsubscribed
-		expect(seenB).toEqual([6, 14, 20]);
-
-		unsubB();
-	});
-
-	it("subscribe after value already set — initial push is skipped, subsequent changes fire", () => {
-		// Signal.sub's contract: initial push-on-subscribe is skipped, so a
-		// subscriber attached to an already-settled node should see zero
-		// fires until the next real change.
-		const count = new Signal.State(5);
-		const doubled = new Signal.Computed(() => count.get() * 2);
-
-		expect(doubled.get()).toBe(10); // warm up via pull
-
-		const seen: number[] = [];
-		const unsub = Signal.sub(doubled, (v) => seen.push(v));
-
-		// Attachment — no fire.
-		expect(seen).toEqual([]);
-
-		count.set(6);
-		expect(seen).toEqual([12]);
-
-		count.set(6); // no-op
-		expect(seen).toEqual([12]);
-
-		count.set(7);
-		expect(seen).toEqual([12, 14]);
-
-		unsub();
-	});
-
-	it("nested computed re-computes correctly across multiple updates", () => {
-		// Chain: count → doubled → quadrupled → formatted
-		// Each level is its own autoTrackNode. A change at count should
-		// yield exactly one fire at formatted with the final value.
-		const count = new Signal.State(1);
-		const doubled = new Signal.Computed(() => count.get() * 2);
-		const quadrupled = new Signal.Computed(() => doubled.get() * 2);
-		const formatted = new Signal.Computed(() => `v=${quadrupled.get()}`);
-
-		const seen: string[] = [];
-		const unsub = Signal.sub(formatted, (v) => seen.push(v));
-
-		expect(formatted.get()).toBe("v=4");
-		expect(seen).toEqual([]);
-
-		count.set(2);
-		expect(formatted.get()).toBe("v=8");
-		expect(seen).toEqual(["v=8"]);
-
-		count.set(3);
-		expect(formatted.get()).toBe("v=12");
-		expect(seen).toEqual(["v=8", "v=12"]);
-
-		// Setting same value — equals check should block fire at the
-		// source, so the chain should see nothing.
-		count.set(3);
-		expect(seen).toEqual(["v=8", "v=12"]);
-
-		count.set(0);
-		expect(formatted.get()).toBe("v=0");
-		expect(seen).toEqual(["v=8", "v=12", "v=0"]);
-
-		unsub();
-	});
-
-	it("equality at the middle of a chain absorbs upstream churn", () => {
-		// bucket = Math.floor(raw / 10)  — stays at 1 as raw goes 10..19
-		// label  = bucket === 1 ? "one" : "other"
-		// Both mid-chain nodes absorb upstream churn via equals-based
-		// RESOLVED framing. The subscriber at `label` must fire only when
-		// the label actually changes.
-		const raw = new Signal.State(12);
-		const bucket = new Signal.Computed(() => Math.floor(raw.get() / 10));
-		const label = new Signal.Computed(() => (bucket.get() === 1 ? "one" : "other"));
-
-		const seen: string[] = [];
-		const unsub = Signal.sub(label, (v) => seen.push(v));
-
-		expect(label.get()).toBe("one");
-		expect(seen).toEqual([]);
-
-		// Churn within bucket 1 — label must stay silent.
-		for (const v of [10, 13, 17, 19, 15, 11]) {
-			raw.set(v);
-			expect(label.get()).toBe("one");
-		}
-		expect(seen).toEqual([]);
-
-		// Cross bucket boundary — label flips to "other" once.
-		raw.set(25);
-		expect(label.get()).toBe("other");
-		expect(seen).toEqual(["other"]);
-
-		// More churn within bucket 2 — label stays "other".
-		raw.set(22);
-		raw.set(28);
-		expect(seen).toEqual(["other"]);
-
-		// Back to bucket 1 — label fires once.
-		raw.set(15);
-		expect(label.get()).toBe("one");
-		expect(seen).toEqual(["other", "one"]);
-
-		// Bucket 3 — "other" again.
-		raw.set(33);
-		expect(label.get()).toBe("other");
-		expect(seen).toEqual(["other", "one", "other"]);
-
-		unsub();
-	});
-
-	it("cb arguments survive rapid in-place updates", () => {
-		// Rapid-fire updates should produce exactly one cb per call (no
-		// coalescing beyond the equals check, no dropped updates).
-		const count = new Signal.State(0);
-
-		const seen: number[] = [];
-		const unsub = Signal.sub(count, (v) => seen.push(v));
-
-		const values = [1, 2, 3, 4, 5, 5, 5, 6, 6, 7];
-		for (const v of values) count.set(v);
-
-		// Equals check deduplicates consecutive same values at the source.
-		expect(seen).toEqual([1, 2, 3, 4, 5, 6, 7]);
-		expect(count.get()).toBe(7);
-
-		unsub();
-	});
-
-	it("derived over two independent states fires once per single-state update", () => {
-		const a = new Signal.State(1);
-		const b = new Signal.State(10);
-		const sum = new Signal.Computed(() => a.get() + b.get());
-
-		const seen: number[] = [];
-		const unsub = Signal.sub(sum, (v) => seen.push(v));
-
-		expect(sum.get()).toBe(11);
-		expect(seen).toEqual([]);
-
-		a.set(2);
-		expect(sum.get()).toBe(12);
-		expect(seen).toEqual([12]);
-
-		b.set(20);
-		expect(sum.get()).toBe(22);
-		expect(seen).toEqual([12, 22]);
-
-		// Set a to a new value that yields the same sum — the sum must
-		// still be recomputed once and, if the result is identical, the
-		// subscriber must NOT fire.
-		a.set(2); // no-op on a
-		b.set(20); // no-op on b
-		expect(seen).toEqual([12, 22]);
-
-		// Change a and b independently — since jotai/signals compat does
-		// NOT batch external set calls, we should see two separate fires,
-		// including when we bounce through an intermediate 25 and back
-		// to 22. The cache is 22 right before a.set(5), then becomes 25
-		// after a.set(5), then becomes 22 again after b.set(17) — each
-		// transition differs from the prior cache so each fires DATA.
-		a.set(5); // sum transitions 22 → 25
-		b.set(17); // sum transitions 25 → 22
-		expect(sum.get()).toBe(22);
-		expect(seen).toEqual([12, 22, 25, 22]);
-
-		unsub();
-	});
-
-	it("two-way bridge: native Node observing a Signal.Computed also sees correct cb count", () => {
-		// Bonus: the compat-Signal object is backed by a real Node
-		// accessible via ._node. A native derived() atop it should receive
-		// the same wave-correct sequence of values as a compat subscriber.
-		//
-		// This is the two-way bridge guarantee: stage-2 users who compose
-		// compat signals into a native graphrefly graph see the same
-		// semantics that pure-compat users see.
-		const count = new Signal.State(1);
-		const computed = new Signal.Computed(() => count.get() * 2);
-
-		// Native graphrefly subscription over the Signal's backing node.
-		// A native subscriber observes the raw wave, but filtered to DATA
-		// it should see the same value sequence the compat subscribe sees
-		// (plus the push-on-subscribe replay of the cached value, which
-		// Signal.sub filters out via its `initial = true` guard).
-		const nativeSeen: number[] = [];
-		const unsub = computed._node.subscribe((msgs) => {
-			for (const [t, v] of msgs) {
-				if (t === DATA) nativeSeen.push(v as number);
-			}
-		});
-
-		// Push-on-subscribe delivers initial value as DATA.
-		expect(nativeSeen).toEqual([2]);
-
-		count.set(3);
-		expect(nativeSeen).toEqual([2, 6]);
-
-		count.set(3); // same value → RESOLVED → not in nativeSeen
-		expect(nativeSeen).toEqual([2, 6]);
-
-		count.set(5);
-		expect(nativeSeen).toEqual([2, 6, 10]);
-
-		unsub();
-	});
-});
diff --git a/src/__tests__/compat/signals.test.ts b/src/__tests__/compat/signals.test.ts
deleted file mode 100644
index 3558d173..00000000
--- a/src/__tests__/compat/signals.test.ts
+++ /dev/null
@@ -1,174 +0,0 @@
-import { COMPLETE, ERROR } from "@graphrefly/pure-ts/core";
-import { describe, expect, it, vi } from "vitest";
-import { Signal } from "../../compat/signals/index.js";
-
-describe("compat/signals", () => {
-	it("State sets and gets values synchronously", () => {
-		const count = new Signal.State(0);
-		expect(count.get()).toBe(0);
-
-		count.set(1);
-		expect(count.get()).toBe(1);
-	});
-
-	it("Computed evaluates reactively based on State changes", () => {
-		const count = new Signal.State(2);
-		const doubled = new Signal.Computed(() => count.get() * 2);
-
-		expect(doubled.get()).toBe(4);
-
-		count.set(3);
-		expect(doubled.get()).toBe(6);
-	});
-
-	it("Computed tracks deps globally and fires cb only on genuine value changes", () => {
-		// Focus: value correctness + cb count correctness.
-		// Fn call counts are an implementation detail and not asserted.
-		const a = new Signal.State("a");
-		const b = new Signal.State("b");
-		const useA = new Signal.State(true);
-
-		const trackedResult = new Signal.Computed(() => (useA.get() ? a.get() : b.get()));
-
-		const seen: string[] = [];
-		const unsub = Signal.sub(trackedResult, (v) => seen.push(v));
-
-		// Initial value
-		expect(trackedResult.get()).toBe("a");
-		expect(seen).toEqual([]); // Signal.sub skips the initial push
-
-		// b is not in the currently-used branch, so mutating it must not
-		// change the observed value and must not fire the subscriber.
-		b.set("b2");
-		expect(trackedResult.get()).toBe("a");
-		expect(seen).toEqual([]);
-
-		// Flip the branch — value changes, subscriber fires exactly once
-		// with the current value of b.
-		useA.set(false);
-		expect(trackedResult.get()).toBe("b2");
-		expect(seen).toEqual(["b2"]);
-
-		// a is no longer the active branch. Mutating it must not fire the
-		// subscriber — the user-visible value is still b's value.
-		a.set("a2");
-		expect(trackedResult.get()).toBe("b2");
-		expect(seen).toEqual(["b2"]);
-
-		// Flip back — the re-activated a branch must reflect a's CURRENT
-		// value "a2", not a stale snapshot from when a was last read.
-		useA.set(true);
-		expect(trackedResult.get()).toBe("a2");
-		expect(seen).toEqual(["b2", "a2"]);
-
-		// Setting a to the same value must not fire the subscriber.
-		a.set("a2");
-		expect(seen).toEqual(["b2", "a2"]);
-
-		unsub();
-	});
-
-	it("Nested Computed properties track correctly", () => {
-		const count = new Signal.State(1);
-		const doubled = new Signal.Computed(() => count.get() * 2);
-		const quadrupled = new Signal.Computed(() => doubled.get() * 2);
-
-		expect(quadrupled.get()).toBe(4);
-
-		count.set(2);
-		expect(quadrupled.get()).toBe(8);
-	});
-
-	it("Signal.sub listens to DATA emissions and returns a cleanup function", () => {
-		const count = new Signal.State(0);
-		const cb = vi.fn();
-		const unsub = Signal.sub(count, cb);
-
-		count.set(1);
-		count.set(2);
-
-		expect(cb).toHaveBeenCalledTimes(2);
-		expect(cb).toHaveBeenNthCalledWith(1, 1);
-		expect(cb).toHaveBeenNthCalledWith(2, 2);
-
-		unsub();
-		count.set(3);
-		expect(cb).toHaveBeenCalledTimes(2); // no more calls
-	});
-
-	it("Signal.sub supports optional terminal hooks", () => {
-		const count = new Signal.State(0);
-		const data = vi.fn();
-		const error = vi.fn();
-		const complete = vi.fn();
-		const unsub = Signal.sub(count, { data, error, complete });
-		count.set(1);
-		(count as unknown as { _node: { down: (msgs: unknown[]) => void } })._node.down([
-			[ERROR, "boom"],
-		]);
-		(count as unknown as { _node: { down: (msgs: unknown[]) => void } })._node.down([[COMPLETE]]);
-		expect(data).toHaveBeenCalledTimes(1);
-		expect(data).toHaveBeenCalledWith(1);
-		expect(error).toHaveBeenCalledTimes(1);
-		expect(error).toHaveBeenCalledWith("boom");
-		expect(complete).toHaveBeenCalledTimes(1);
-		unsub();
-	});
-
-	it("Signal.State respects equals in set()", () => {
-		const count = new Signal.State(1, { equals: (a, b) => a === b });
-		const cb = vi.fn();
-		const unsub = Signal.sub(count, cb);
-		count.set(1);
-		count.set(2);
-		expect(cb).toHaveBeenCalledTimes(1);
-		expect(cb).toHaveBeenCalledWith(2);
-		unsub();
-	});
-
-	it("Signal.get does not throw after upstream error", () => {
-		const count = new Signal.State(1);
-		const doubled = new Signal.Computed(() => {
-			const value = count.get();
-			if (value === 2) {
-				throw new Error("boom");
-			}
-			return value * 2;
-		});
-		const unsub = Signal.sub(doubled, () => {});
-		expect(doubled.get()).toBe(2);
-		count.set(2);
-		expect(() => doubled.get()).not.toThrow();
-		expect(doubled.get()).toBe(2);
-		unsub();
-	});
-
-	it("Diamond patterns resolve without glitches", () => {
-		// Focus: the diamond must produce the correct final value and
-		// fire the subscriber EXACTLY ONCE per base update (not twice —
-		// that would be the glitch we care about).
-		const base = new Signal.State(1);
-		const left = new Signal.Computed(() => base.get() * 2);
-		const right = new Signal.Computed(() => base.get() + 2);
-		const final = new Signal.Computed(() => left.get() + right.get());
-
-		const seen: number[] = [];
-		const unsub = Signal.sub(final, (v) => seen.push(v));
-
-		expect(final.get()).toBe(5); // left(2) + right(3)
-		expect(seen).toEqual([]); // Signal.sub skips initial push
-
-		base.set(2);
-		expect(final.get()).toBe(8); // left(4) + right(4)
-		// Exactly one cb fire with the final diamond-resolved value —
-		// no intermediate glitch values like 6 (left=4, right=3 stale)
-		// or 7 (left=2 stale, right=4).
-		expect(seen).toEqual([8]);
-
-		base.set(3);
-		expect(final.get()).toBe(11); // left(6) + right(5)
-		expect(seen).toEqual([8, 11]);
-
-		unsub();
-	});
-});
diff --git a/src/__tests__/compat/solid.test.ts b/src/__tests__/compat/solid.test.ts
deleted file mode 100644
index 24f674a4..00000000
--- a/src/__tests__/compat/solid.test.ts
+++ /dev/null
@@ -1,69 +0,0 @@
-/**
- * @vitest-environment jsdom
- */
-
-import { DATA, node } from "@graphrefly/pure-ts/core";
-import { createRoot } from "solid-js";
-import { describe, expect, it } from "vitest";
-import { useStore, useSubscribe, useSubscribeRecord } from "../../compat/solid/index.js";
-
-describe("Solid bindings", () => {
-	it("useSubscribe reads value and updates", () => {
-		const testNode = node({ initial: "hello" });
-
-		createRoot((dispose: () => void) => {
-			const accessor = useSubscribe(testNode);
-
-			expect(accessor()).toBe("hello");
-
-			testNode.down([[DATA, "world"]]);
-			expect(accessor()).toBe("world");
-
-			dispose();
-
-			testNode.down([[DATA, "ignored"]]);
-			expect(accessor()).toBe("world");
-		});
-	});
-
-	it("useStore provides state and setter", () => {
-		const testNode = node({ initial: 10 });
-
-		createRoot((dispose: () => void) => {
-			const [accessor, setter] = useStore(testNode);
-
-			expect(accessor()).toBe(10);
-
-			setter(42);
-			expect(accessor()).toBe(42);
-			expect(testNode.cache).toBe(42);
-
-			dispose();
-		});
-	});
-
-	it("useSubscribeRecord syncs dynamic values", () => {
-		const a = node({ initial: 1 });
-		const b = node({ initial: 2 });
-		const keysNode = node<string[]>({ initial: ["a"] });
-
-		const factory = (key: string) => ({ item: key === "a" ? a : b });
-
-		createRoot((dispose: () => void) => {
-			const accessor = useSubscribeRecord(keysNode, factory);
-
-			expect(accessor()).toEqual({ a: { item: 1 } });
-
-			a.down([[DATA, 10]]);
-			expect(accessor()).toEqual({ a: { item: 10 } });
-
-			keysNode.down([[DATA, ["a", "b"]]]);
-			expect(accessor()).toEqual({ a: { item: 10 }, b: { item: 2 } });
-
-			b.down([[DATA, 20]]);
-			expect(accessor()).toEqual({ a: { item: 10 }, b: { item: 20 } });
-
-			dispose();
-		});
-	});
-});
diff --git a/src/__tests__/compat/svelte.test.ts b/src/__tests__/compat/svelte.test.ts
deleted file mode 100644
index e9a25b19..00000000
--- a/src/__tests__/compat/svelte.test.ts
+++ /dev/null
@@ -1,75 +0,0 @@
-import { DATA, node } from "@graphrefly/pure-ts/core";
-import { describe, expect, it } from "vitest";
-import { useStore, useSubscribe, useSubscribeRecord } from "../../compat/svelte/index.js";
-
-describe("Svelte bindings", () => {
-	it("useSubscribe reads value and updates", () => {
-		const testNode = node({ initial: "hello" });
-		const store = useSubscribe(testNode);
-		let val: any;
-
-		const unsub = store.subscribe((v) => {
-			val = v;
-		});
-
-		expect(val).toBe("hello");
-
-		testNode.down([[DATA, "world"]]);
-		expect(val).toBe("world");
-
-		unsub();
-		testNode.down([[DATA, "ignored"]]);
-		expect(val).toBe("world");
-	});
-
-	it("useStore acts as a writable store", () => {
-		const testNode = node({ initial: 10 });
-		const store = useStore(testNode);
-
-		let val: any;
-		const unsub = store.subscribe((v) => {
-			val = v;
-		});
-
-		expect(val).toBe(10);
-
-		// Test setter
-		store.set(42);
-		expect(val).toBe(42);
-		expect(testNode.cache).toBe(42);
-
-		// Test updater
-		store.update((n) => (n as number) + 1);
-		expect(val).toBe(43);
-		expect(testNode.cache).toBe(43);
-
-		unsub();
-	});
-
-	it("useSubscribeRecord syncs dynamic values", () => {
-		const a = node({ initial: 1 });
-		const b = node({ initial: 2 });
-		const keysNode = node<string[]>({ initial: ["a"] });
-
-		const factory = (key: string) => ({ item: key === "a" ? a : b });
-		const store = useSubscribeRecord(keysNode, factory);
-
-		let val: any;
-		const unsub = store.subscribe((v) => {
-			val = v;
-		});
-
-		expect(val).toEqual({ a: { item: 1 } });
-
-		a.down([[DATA, 10]]);
-		expect(val).toEqual({ a: { item: 10 } });
-
-		keysNode.down([[DATA, ["a", "b"]]]);
-		expect(val).toEqual({ a: { item: 10 }, b: { item: 2 } });
-
-		b.down([[DATA, 20]]);
-		expect(val).toEqual({ a: { item: 10 }, b: { item: 20 } });
-
-		unsub();
-	});
-});
diff --git a/src/__tests__/compat/vue.test.ts b/src/__tests__/compat/vue.test.ts
deleted file mode 100644
index 61ffd12c..00000000
--- a/src/__tests__/compat/vue.test.ts
+++ /dev/null
@@ -1,82 +0,0 @@
-import { DATA, node } from "@graphrefly/pure-ts/core";
-import { describe, expect, it } from "vitest";
-import { effectScope, isReadonly, isRef, nextTick, ref } from "vue";
-import { useStore, useSubscribe, useSubscribeRecord } from "../../compat/vue/index.js";
-
-describe("Vue bindings", () => {
-	it("useSubscribe returns a readonly ref synced with node", async () => {
-		const testNode = node({ initial: "hello" });
-		let r: any;
-
-		const scope = effectScope();
-		scope.run(() => {
-			r = useSubscribe(testNode);
-		});
-
-		expect(isRef(r)).toBe(true);
-		expect(isReadonly(r)).toBe(true);
-		expect(r.value).toBe("hello");
-
-		testNode.down([[DATA, "world"]]);
-		expect(r.value).toBe("world");
-
-		scope.stop(); // unsubscribes
-		testNode.down([[DATA, "ignored"]]);
-		expect(r.value).toBe("world"); // subscription was torn down
-	});
-
-	it("useStore returns a writable ref", () => {
-		const testNode = node({ initial: 10 });
-		let r: any;
-
-		const scope = effectScope();
-		scope.run(() => {
-			r = useStore(testNode);
-		});
-
-		expect(isRef(r)).toBe(true);
-		expect(isReadonly(r)).toBe(false);
-
-		// test write
-		r.value = 42;
-		expect(testNode.cache).toBe(42);
-
-		// test read
-		testNode.down([[DATA, 50]]);
-		expect(r.value).toBe(50);
-		scope.stop();
-	});
-
-	it("useSubscribeRecord creates reactive sync of dynamic records", async () => {
-		const a = node({ initial: 1 });
-		const b = node({ initial: 2 });
-		const keysRef = ref(["a"]);
-
-		const factory = (key: string) => ({ item: key === "a" ? a : b });
-
-		let r: any;
-		const scope = effectScope();
-		scope.run(() => {
-			r = useSubscribeRecord(keysRef, factory);
-		});
-
-		expect(r.value).toEqual({ a: { item: 1 } });
-
-		// update child node
-		a.down([[DATA, 100]]);
-		await nextTick(); // useSubscribeRecord queues batch update
-		expect(r.value).toEqual({ a: { item: 100 } });
-
-		// push new key
-		keysRef.value = ["a", "b"];
-		await nextTick();
-		expect(r.value).toEqual({ a: { item: 100 }, b: { item: 2 } });
-
-		// verify b updates
-		b.down([[DATA, 200]]);
-		await nextTick();
-		expect(r.value).toEqual({ a: { item: 100 }, b: { item: 200 } });
-
-		scope.stop();
-	});
-});
diff --git a/src/__tests__/compat/zustand.test.ts b/src/__tests__/compat/zustand.test.ts
deleted file mode 100644
index 5b7b480c..00000000
--- a/src/__tests__/compat/zustand.test.ts
+++ /dev/null
@@ -1,149 +0,0 @@
-import { DATA, node } from "@graphrefly/pure-ts/core";
-import { describe, expect, it, vi } from "vitest";
-import { create } from "../../compat/zustand/index.js";
-
-describe("zustand compat", () => {
-	it("create: initializes with state from initializer", () => {
-		const store = create(() => ({ count: 0 }));
-		expect(store.getState()).toEqual({ count: 0 });
-	});
-
-	it("setState: partial update merges by default", () => {
-		const store = create(() => ({ count: 0, tag: "init" }));
-		store.setState({ count: 1 });
-		expect(store.getState()).toEqual({ count: 1, tag: "init" });
-	});
-
-	it("setState: replacement when replace: true", () => {
-		const store = create<any>(() => ({ count: 0, tag: "init" }));
-		store.setState({ count: 1 }, true);
-		expect(store.getState()).toEqual({ count: 1 });
-	});
-
-	it("setState: functional update receives current state", () => {
-		const store = create(() => ({ count: 10 }));
-		store.setState((s) => ({ count: s.count + 5 }));
-		expect(store.getState()).toEqual({ count: 15 });
-	});
-
-	it("subscribe: listener receives (state, prevState)", () => {
-		const store = create(() => ({ count: 0 }));
-		const listener = vi.fn();
-		const unsub = store.subscribe(listener);
-
-		store.setState({ count: 1 });
-		expect(listener).toHaveBeenCalledWith({ count: 1 }, { count: 0 });
-
-		store.setState({ count: 2 });
-		expect(listener).toHaveBeenCalledWith({ count: 2 }, { count: 1 });
-
-		unsub();
-		store.setState({ count: 3 });
-		expect(listener).toHaveBeenCalledTimes(2);
-	});
-
-	it("actions inside state can call set/get", () => {
-		const store = create<any>((set, get) => ({
-			count: 0,
-			inc: () => set({ count: get().count + 1 }),
-		}));
-
-		store.getState().inc();
-		expect(store.getState().count).toBe(1);
-		store.getState().inc();
-		expect(store.getState().count).toBe(2);
-	});
-
-	it("behave as a Graph: access nodes and features", () => {
-		const store = create(() => ({ value: "init" }));
-		// Graph name is "zustand" internally by default
-		expect(store.name).toBe("zustand");
-		// Local node name is "state"
-		expect(store.node("state").cache).toEqual({ value: "init" });
-
-		store.set("state", { value: "changed" });
-		expect(store.getState()).toEqual({ value: "changed" });
-	});
-
-	it("getInitialState returns the starting value", () => {
-		const initial = { count: 0 };
-		const store = create(() => initial);
-		expect(store.getInitialState()).toBe(initial);
-	});
-
-	it("destroy: tears down the graph", () => {
-		const store = create(() => ({ count: 0 }));
-		const stateNode = store.node("state");
-		store.destroy();
-		expect(stateNode.status).toBe("sentinel");
-	});
-
-	it("two-way bridge: native diamond over store.node('state') resolves without glitches", () => {
-		// Regression: zustand's setState used to bypass the framed emit
-		// pipeline (`n.down([[DATA, v]])` instead of `n.emit(v)`), which
-		// meant no auto-prefixed `[DIRTY]`. Diamond legs built from the
-		// state node wouldn't coordinate and a downstream computed fired
-		// with glitch values mid-wave.
-		const store = create(() => ({ x: 1 }));
-		const state = store.node("state") as ReturnType<typeof store.node> & {
-			subscribe: (s: unknown) => () => void;
-		};
-
-		// Left leg: x * 10. Right leg: x + 100. Diamond: left + right.
-		const left = node(
-			[state],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as { x: number }).x * 10);
-			},
-			{ describeKind: "derived" },
-		);
-		const right = node(
-			[state],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as { x: number }).x + 100);
-			},
-			{ describeKind: "derived" },
-		);
-		const final = node(
-			[left, right],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as number) + (data[1] as number));
-			},
-			{ describeKind: "derived" },
-		);
-
-		const seen: number[] = [];
-		const unsub = final.subscribe((msgs) => {
-			for (const [t, v] of msgs) {
-				if (t === DATA) seen.push(v as number);
-			}
-		});
-
-		// Push-on-subscribe replay of the initial wave.
-		expect(final.cache).toBe(111); // (1 * 10) + (1 + 100) = 10 + 101
-		expect(seen).toEqual([111]);
-
-		// Setting x=5 via zustand's setState must collapse the diamond
-		// to exactly one fire with the final resolved value 155 — not a
-		// glitchy intermediate like 151 (new left 50 + stale right 101)
-		// or 110 (stale left 10 + new right 105).
-		store.setState({ x: 5 });
-		expect(final.cache).toBe(155); // 50 + 105
-		expect(seen).toEqual([111, 155]);
-
-		store.setState({ x: 10 });
-		expect(final.cache).toBe(210); // 100 + 110
-		expect(seen).toEqual([111, 155, 210]);
-
-		unsub();
-	});
-});
diff --git a/src/__tests__/no-rxjs-in-loaded-path.test.ts b/src/__tests__/no-rxjs-in-loaded-path.test.ts
deleted file mode 100644
index 21b7c5ac..00000000
--- a/src/__tests__/no-rxjs-in-loaded-path.test.ts
+++ /dev/null
@@ -1,50 +0,0 @@
-// Regression guard for the memo:Re P0: `@graphrefly/graphrefly` root + `/base`
-// barrels must NOT transitively import rxjs (an optional peer that bricks
-// RN/Hermes builds when absent). rxjs is allowed ONLY under the opt-in
-// `src/compat/nestjs` subpath, where `@nestjs/common` pulls it legitimately.
-
-import { readdirSync, readFileSync, statSync } from "node:fs";
-import { join } from "node:path";
-import { fileURLToPath } from "node:url";
-import { describe, expect, it } from "vitest";
-
-const SRC = join(fileURLToPath(new URL(".", import.meta.url)), "..");
-
-function walk(dir: string): string[] {
-	const out: string[] = [];
-	for (const name of readdirSync(dir)) {
-		const p = join(dir, name);
-		const st = statSync(p);
-		if (st.isDirectory()) {
-			// rxjs is allowed ONLY under compat/nestjs (where @nestjs/common
-			// legitimately pulls it). Every OTHER compat/* adapter (react, vue,
-			// solid, svelte, …) can be loaded by RN/Hermes and MUST stay
-			// guarded — so recurse into compat/, skipping only compat/nestjs.
-			const rel = p.replace(/\\/g, "/");
-			if (name === "__tests__" || rel.endsWith("/compat/nestjs")) continue;
-			out.push(...walk(p));
-		} else if (p.endsWith(".ts")) {
-			out.push(p);
-		}
-	}
-	return out;
-}
-
-describe("no rxjs in the always-loaded presentation path (memo:Re P0)", () => {
-	it("no src/ file outside compat/ references rxjs", () => {
-		const offenders = walk(SRC).filter((f) => {
-			// Strip comments so JSDoc usage examples (`import { from } from
-			// 'rxjs'`) don't count — only real import/require statements do.
-			const code = readFileSync(f, "utf8")
-				.replace(/\/\*[\s\S]*?\*\//g, "")
-				.replace(/^\s*\/\/.*$/gm, "");
-			// Catch: `… from "rxjs"`, `require("rxjs")`, dynamic `import("rxjs")`,
-			// and side-effect `import "rxjs"` — any path that re-introduces the
-			// optional peer into the always-loaded barrel.
-			return /\bfrom\s*["']rxjs["']|\brequire\(\s*["']rxjs["']\)|\bimport\s*\(\s*["']rxjs["']\s*\)|\bimport\s+["']rxjs["']/.test(
-				code,
-			);
-		});
-		expect(offenders).toEqual([]);
-	});
-});
diff --git a/src/__tests__/presets/ai/context.test.ts b/src/__tests__/presets/ai/context.test.ts
deleted file mode 100644
index 46b2bb4e..00000000
--- a/src/__tests__/presets/ai/context.test.ts
+++ /dev/null
@@ -1,198 +0,0 @@
-/**
- * DS-14.6.A U-A — tagged context substrate.
- */
-
-import { node } from "@graphrefly/pure-ts/core";
-import { Graph } from "@graphrefly/pure-ts/graph";
-import { describe, expect, it } from "vitest";
-import {
-	type ContextView,
-	renderContextView,
-	taggedContextPool,
-} from "../../../presets/ai/context/index.js";
-
-function pressureNode(initial: number) {
-	return node<number>([], { initial });
-}
-function lastRendered<T>(n: ReturnType<typeof renderContextView<T>>) {
-	let out: readonly unknown[] = [];
-	const unsub = n.subscribe((msgs) => {
-		for (const m of msgs) if (typeof m[0] === "symbol" && m[1] !== undefined) out = m[1] as never;
-	});
-	unsub();
-	return out as readonly { id: string; tier: number; payload: unknown; compressed: boolean }[];
-}
-
-describe("DS-14.6.A U-A — taggedContextPool", () => {
-	it("append-only pool: add / entries / byTag", () => {
-		const g = new Graph("g");
-		const pool = taggedContextPool<string>(g, { topic: "t" });
-		pool.add({ payload: "a", tags: ["x"], importance: 0.9, compressible: true, topic: "t" });
-		pool.add({ payload: "b", tags: ["y"], importance: 0.1, compressible: true, topic: "t" });
-		expect((pool.entries.cache ?? []).map((e) => e.payload)).toEqual(["a", "b"]);
-		const xs = pool.byTag("x");
-		xs.subscribe(() => {});
-		expect((xs.cache ?? []).map((e) => e.payload)).toEqual(["a"]);
-		pool.dispose();
-	});
-
-	it("pressure 0 → tier-0 passthrough; pressure>0 applies first matching rule", () => {
-		const g = new Graph("g");
-		const pool = taggedContextPool<string>(g, { topic: "t" });
-		pool.add({
-			id: "e1",
-			payload: "hello world this is long",
-			tags: ["doc"],
-			importance: 0.5,
-			compressible: true,
-			topic: "t",
-		});
-		const pressure = pressureNode(0);
-		const view: ContextView<string> = {
-			filter: () => true,
-			pressure,
-			budgetTokens: 10_000,
-			rules: [{ match: { tagsAny: ["doc"] }, action: "truncate", maxChars: 5 }],
-		};
-		const rv = renderContextView(pool, view);
-		rv.subscribe(() => {});
-		expect(lastRendered(rv)[0]).toMatchObject({
-			tier: 0,
-			compressed: false,
-			payload: "hello world this is long",
-		});
-		pressure.emit(1);
-		expect(lastRendered(rv)[0]).toMatchObject({ tier: 1, compressed: true, payload: "hello" });
-		pool.dispose();
-	});
-
-	it("evict rule removes the entry from the view; reference replaces payload", () => {
-		const g = new Graph("g");
-		const pool = taggedContextPool<string>(g, { topic: "t" });
-		pool.add({
-			id: "k",
-			payload: "secret",
-			tags: ["drop"],
-			importance: 0.2,
-			compressible: true,
-			topic: "t",
-		});
-		pool.add({
-			id: "r",
-			payload: "keep",
-			tags: ["ref"],
-			importance: 0.2,
-			compressible: true,
-			topic: "t",
-		});
-		const rv = renderContextView(pool, {
-			filter: () => true,
-			pressure: pressureNode(1),
-			budgetTokens: 10_000,
-			rules: [
-				{ match: { tagsAny: ["drop"] }, action: "evict" },
-				{ match: { tagsAny: ["ref"] }, action: "reference" },
-			],
-		});
-		rv.subscribe(() => {});
-		const out = lastRendered(rv);
-		expect(out.map((r) => r.id)).toEqual(["r"]);
-		expect(out[0]).toMatchObject({ payload: "[ref:r]", compressed: true });
-		pool.dispose();
-	});
-
-	it("llm-summary: throws at construction without llmCompress; caches (id,tier) across views with it", () => {
-		const g = new Graph("g");
-		const noLlm = taggedContextPool<string>(g, { topic: "n" });
-		expect(() =>
-			renderContextView(noLlm, {
-				filter: () => true,
-				pressure: pressureNode(1),
-				budgetTokens: 1000,
-				rules: [{ match: {}, action: "llm-summary", toTier: 2 }],
-			}),
-		).toThrow(/llm-summary/);
-
-		let calls = 0;
-		const pool = taggedContextPool<string>(g, {
-			topic: "s",
-			llmCompress: (e) => {
-				calls += 1;
-				return `sum(${e.id})`;
-			},
-		});
-		pool.add({
-			id: "z",
-			payload: "long original text",
-			tags: [],
-			importance: 0.5,
-			compressible: true,
-			topic: "s",
-		});
-		const mkView = (): ContextView<string> => ({
-			filter: () => true,
-			pressure: pressureNode(1),
-			budgetTokens: 1000,
-			rules: [{ match: {}, action: "llm-summary", toTier: 2 }],
-		});
-		const v1 = renderContextView(pool, mkView());
-		const v2 = renderContextView(pool, mkView());
-		v1.subscribe(() => {});
-		v2.subscribe(() => {});
-		expect(lastRendered(v1)[0]).toMatchObject({ tier: 2, payload: "sum(z)", compressed: true });
-		expect(lastRendered(v2)[0]).toMatchObject({ tier: 2, payload: "sum(z)" });
-		// Shared (id,tier) cache → exactly one llmCompress call across both views.
-		expect(calls).toBe(1);
-		pool.dispose();
-	});
-
-	it("token budget trims lowest-importance rendered entries", () => {
-		const g = new Graph("g");
-		const pool = taggedContextPool<string>(g, { topic: "t" });
-		pool.add({
-			id: "hi",
-			payload: "AAAAAAAA",
-			tags: [],
-			importance: 0.9,
-			compressible: false,
-			topic: "t",
-		});
-		pool.add({
-			id: "lo",
-			payload: "BBBBBBBB",
-			tags: [],
-			importance: 0.1,
-			compressible: false,
-			topic: "t",
-		});
-		const rv = renderContextView(pool, {
-			filter: () => true,
-			pressure: pressureNode(0),
-			budgetTokens: 2, // ~8 chars => 2 tokens each; only one fits
-			rules: [],
-		});
-		rv.subscribe(() => {});
-		const out = lastRendered(rv);
-		expect(out.map((r) => r.id)).toEqual(["hi"]); // low-importance "lo" trimmed
-		pool.dispose();
-	});
-
-	it("poolGC removes by policy and rewrites the append-only log", () => {
-		const g = new Graph("g");
-		const pool = taggedContextPool<string>(g, { topic: "t" });
-		for (let i = 0; i < 5; i++) {
-			pool.add({
-				id: `n${i}`,
-				payload: `v${i}`,
-				tags: [],
-				importance: i / 10,
-				compressible: true,
-				topic: "t",
-			});
-		}
-		const removed = pool.poolGC({ importanceBelow: 0.3 });
-		expect(removed).toBe(3); // i=0,1,2 → importance 0,0.1,0.2 < 0.3
-		expect((pool.entries.cache ?? []).map((e) => e.id)).toEqual(["n3", "n4"]);
-		pool.dispose();
-	});
-});
diff --git a/src/__tests__/presets/ai/debate.test.ts b/src/__tests__/presets/ai/debate.test.ts
deleted file mode 100644
index c3351668..00000000
--- a/src/__tests__/presets/ai/debate.test.ts
+++ /dev/null
@@ -1,144 +0,0 @@
-/**
- * DS-14.6.A U-C — heterogeneousDebate.
- */
-import { Graph } from "@graphrefly/pure-ts/graph";
-import { describe, expect, it } from "vitest";
-import { heterogeneousDebate, type Turn } from "../../../presets/ai/debate/index.js";
-import type { LLMAdapter, LLMResponse } from "../../../utils/ai/adapters/core/types.js";
-
-/** Adapter that replies with `reply(callIndex)`. */
-function scriptedAdapter(provider: string, reply: (n: number) => string): LLMAdapter {
-	let n = 0;
-	return {
-		provider,
-		model: `${provider}-m`,
-		invoke(): Promise<LLMResponse> {
-			const content = reply(n++);
-			return Promise.resolve({ content });
-		},
-		// biome-ignore lint/correctness/useYield: unused in debate
-		async *stream() {
-			throw new Error("unused");
-		},
-	};
-}
-
-describe("DS-14.6.A U-C — heterogeneousDebate", () => {
-	it("fixedRounds: N rounds × participants turns; heterogeneous adapters", async () => {
-		const g = new Graph("g");
-		const d = heterogeneousDebate(g, {
-			question: "Q?",
-			participants: [
-				{ adapter: scriptedAdapter("A", (n) => `a${n}`), role: "advocate", systemPrompt: "be for" },
-				{
-					adapter: scriptedAdapter("B", (n) => `b${n}`),
-					role: "skeptic",
-					systemPrompt: "be against",
-				},
-			],
-			rounds: 3,
-		});
-		const out = (await d.run()) as readonly Turn[];
-		expect(out).toHaveLength(6); // 3 rounds × 2 participants
-		expect(out.filter((t) => t.round === 1).map((t) => t.role)).toEqual(["advocate", "skeptic"]);
-		expect(d.status.cache).toBe("max-rounds");
-	});
-
-	it("D-C2: output 'synthesizer-final' without a synthesizer participant throws", () => {
-		const g = new Graph("g");
-		expect(() =>
-			heterogeneousDebate(g, {
-				question: "Q",
-				participants: [
-					{ adapter: scriptedAdapter("A", () => "x"), role: "advocate", systemPrompt: "" },
-				],
-				output: "synthesizer-final",
-			}),
-		).toThrow(/synth/i);
-	});
-
-	it("synthesizer-final returns the last synthesizer turn", async () => {
-		const g = new Graph("g");
-		const d = heterogeneousDebate(g, {
-			question: "Q",
-			participants: [
-				{ adapter: scriptedAdapter("A", (n) => `a${n}`), role: "advocate", systemPrompt: "" },
-				{
-					adapter: scriptedAdapter("S", (n) => `verdict-${n}`),
-					role: "synthesizer",
-					systemPrompt: "",
-				},
-			],
-			rounds: 2,
-			output: "synthesizer-final",
-		});
-		const out = await d.run();
-		expect(out).toBe("verdict-1"); // 2nd synthesizer call (index 1)
-	});
-
-	it("D-C1: until-converge stops when stances stabilize (default detector)", async () => {
-		const g = new Graph("g");
-		// Both adapters return a constant → round 2 == round 1 → converged.
-		const d = heterogeneousDebate(g, {
-			question: "Q",
-			participants: [
-				{ adapter: scriptedAdapter("A", () => "fixed-a"), role: "advocate", systemPrompt: "" },
-				{ adapter: scriptedAdapter("B", () => "fixed-b"), role: "skeptic", systemPrompt: "" },
-			],
-			rounds: "until-converge",
-			maxRounds: 8,
-		});
-		const out = (await d.run()) as readonly Turn[];
-		// Converges after round 2 (round 2 stances == round 1 stances).
-		expect(Math.max(...out.map((t) => t.round))).toBe(2);
-		expect(d.status.cache).toBe("converged");
-	});
-
-	it("output.project maps the transcript", async () => {
-		const g = new Graph("g");
-		const d = heterogeneousDebate(g, {
-			question: "Q",
-			participants: [
-				{ adapter: scriptedAdapter("A", (n) => `a${n}`), role: "advocate", systemPrompt: "" },
-			],
-			rounds: 2,
-			output: { project: (tr) => tr.length },
-		});
-		expect(await d.run()).toBe(2);
-	});
-
-	it("QA M1(b): the round loop is reactive topology (describe-visible, not an async while)", () => {
-		const g = new Graph("g");
-		const d = heterogeneousDebate(g, {
-			question: "Q",
-			participants: [
-				{ adapter: scriptedAdapter("A", (n) => `a${n}`), role: "advocate", systemPrompt: "" },
-			],
-			rounds: 2,
-		});
-		const desc = JSON.stringify(d.graph.describe());
-		// The feedback loop's nodes are registered on the graph → dry-run /
-		// explain / describe see the round structure (M1 redesign goal).
-		expect(desc).toContain("rounds");
-		expect(desc).toContain("transcript");
-		expect(desc).toContain("converged");
-		expect(desc).toContain("decide");
-	});
-
-	it("QA P4: re-entrant run() while pending throws RangeError", async () => {
-		const g = new Graph("g");
-		const d = heterogeneousDebate(g, {
-			question: "Q",
-			participants: [
-				{ adapter: scriptedAdapter("A", (n) => `a${n}`), role: "advocate", systemPrompt: "" },
-			],
-			rounds: 2,
-		});
-		const p1 = d.run();
-		// run() is async — the guard rejects rather than sync-throws.
-		await expect(d.run()).rejects.toThrow(RangeError);
-		await p1;
-		// after settle, a fresh run() is allowed again
-		await expect(d.run()).resolves.toBeDefined();
-	});
-});
diff --git a/src/__tests__/presets/ai/multi-writer-context.test.ts b/src/__tests__/presets/ai/multi-writer-context.test.ts
deleted file mode 100644
index 77e3ba0a..00000000
--- a/src/__tests__/presets/ai/multi-writer-context.test.ts
+++ /dev/null
@@ -1,81 +0,0 @@
-/**
- * DS-14.6.A delta-4 — multi-writer worked-example lock-test.
- *
- * Proves L2 (subgraph-level write isolation — two actors own different pool
- * segments, write concurrently) + L4 (per-view rendering — same entry at
- * different tiers in two views) + L5 (shared `(id, tier)` cache — one
- * `llmCompress` call across both views asking the same tier).
- */
-import { node } from "@graphrefly/pure-ts/core";
-import { Graph } from "@graphrefly/pure-ts/graph";
-import { describe, expect, it } from "vitest";
-import { type ContextView, renderContextView } from "../../../presets/ai/context/index.js";
-import { actorPool } from "../../../presets/harness/actor-pool.js";
-
-describe("DS-14.6.A delta-4 — multi-writer + per-view + cross-view cache", () => {
-	it("two actors write concurrently; two views render the same entry at different tiers; one cached LLM call", () => {
-		const g = new Graph("g");
-		let llmCalls = 0;
-		const pool = actorPool<string>(g, {
-			name: "mw",
-			llmCompress: (e, tier) => {
-				llmCalls += 1;
-				return `sum:${e.id}@${tier}`;
-			},
-		});
-
-		const view = (rules: ContextView<string>["rules"]): ContextView<string> => ({
-			filter: () => true,
-			pressure: node<number>([], { initial: 1 }),
-			budgetTokens: 10_000,
-			rules,
-		});
-
-		const a1 = pool.attachActor({ id: "w1", view: view([]) });
-		const a2 = pool.attachActor({ id: "w2", view: view([]) });
-
-		// L2: concurrent writers, different segments (own actor tag).
-		const id1 = a1.publish({
-			payload: "doc one",
-			tags: ["seg1"],
-			importance: 0.8,
-			compressible: true,
-			topic: "context",
-		});
-		a2.publish({
-			payload: "doc two",
-			tags: ["seg2"],
-			importance: 0.4,
-			compressible: true,
-			topic: "context",
-		});
-
-		const entries = pool.contextPool.entries.cache ?? [];
-		expect(entries.map((e) => e.id)).toEqual([id1, entries[1]?.id]);
-		expect(entries[0]?.tags).toContain("actor:w1");
-		expect(entries[1]?.tags).toContain("actor:w2");
-
-		// L4 + L5: two views both summarising seg1 to tier 2 → one cached call.
-		const summariseSeg1 = view([
-			{ match: { tagsAny: ["seg1"] }, action: "llm-summary" as const, toTier: 2 as const },
-		]);
-		const vA = renderContextView(pool.contextPool, summariseSeg1);
-		const vB = renderContextView(pool.contextPool, {
-			...summariseSeg1,
-			pressure: node<number>([], { initial: 1 }),
-		});
-		vA.subscribe(() => {});
-		vB.subscribe(() => {});
-
-		const pick = (n: typeof vA) =>
-			(n.cache ?? []).find((r) => r.id === id1) as { tier: number; payload: unknown } | undefined;
-		expect(pick(vA)).toMatchObject({ tier: 2, payload: `sum:${id1}@2` });
-		expect(pick(vB)).toMatchObject({ tier: 2, payload: `sum:${id1}@2` });
-		// L5: shared (id, tier) cache → exactly one llmCompress call.
-		expect(llmCalls).toBe(1);
-
-		a1.release();
-		a2.release();
-		pool.dispose();
-	});
-});
diff --git a/src/__tests__/presets/harness/actor-pool.test.ts b/src/__tests__/presets/harness/actor-pool.test.ts
deleted file mode 100644
index d901fb5b..00000000
--- a/src/__tests__/presets/harness/actor-pool.test.ts
+++ /dev/null
@@ -1,119 +0,0 @@
-/**
- * DS-14.6.A U-B — actorPool.
- */
-import { node } from "@graphrefly/pure-ts/core";
-import { Graph } from "@graphrefly/pure-ts/graph";
-import { describe, expect, it } from "vitest";
-import type { ContextView } from "../../../presets/ai/context/index.js";
-import { actorPool, type Todo } from "../../../presets/harness/actor-pool.js";
-
-function mkView(): ContextView<string> {
-	return {
-		filter: () => true,
-		pressure: node<number>([], { initial: 0 }),
-		budgetTokens: 10_000,
-		rules: [],
-	};
-}
-function snapshot<T>(n: {
-	subscribe: (cb: (m: readonly [symbol, T?][]) => void) => () => void;
-}): T | undefined {
-	let out: T | undefined;
-	const unsub = n.subscribe((msgs) => {
-		for (const m of msgs) if (m[1] !== undefined) out = m[1];
-	});
-	unsub();
-	return out;
-}
-
-describe("DS-14.6.A U-B — actorPool", () => {
-	it("attachActor adds to the single reactive `active` map (no per-actor subgraph)", () => {
-		const g = new Graph("g");
-		const pool = actorPool<string>(g, { name: "ap" });
-		const a = pool.attachActor({ id: "a1", view: mkView() });
-		const active = snapshot<ReadonlyMap<string, unknown>>(pool.active);
-		expect([...(active?.keys() ?? [])]).toEqual(["a1"]);
-		// D-B1: actor is NOT a subgraph — pool graph has the ctx pool mount only,
-		// not a mount per actor.
-		const before = pool.graph.describe?.() ? JSON.stringify(pool.graph.describe()).length : 0;
-		pool.attachActor({ id: "a2", view: mkView() });
-		const after = pool.graph.describe?.() ? JSON.stringify(pool.graph.describe()).length : 0;
-		expect(after).toBe(before); // topology unchanged by adding an actor
-		a.release();
-		pool.dispose();
-	});
-
-	it("depthCap: attach beyond cap throws (D-B2)", () => {
-		const g = new Graph("g");
-		const pool = actorPool<string>(g, { depthCap: 2 });
-		expect(() => pool.attachActor({ depth: 3, view: mkView() })).toThrow(/depthCap/);
-		expect(() => pool.attachActor({ depth: 2, view: mkView() })).not.toThrow();
-		pool.dispose();
-	});
-
-	// F-B-class smell sweep (2026-05-18) — F-ACTOR: depthCap defaults to a
-	// finite 8 (was silently Infinity), bounding runaway recursive fan-out.
-	it("F-ACTOR: default depthCap is a finite 8 (depth 9 throws, depth 8 ok)", () => {
-		const g = new Graph("g");
-		const pool = actorPool<string>(g);
-		expect(() => pool.attachActor({ depth: 9, view: mkView() })).toThrow(/depthCap 8/);
-		expect(() => pool.attachActor({ depth: 8, view: mkView() })).not.toThrow();
-		pool.dispose();
-	});
-
-	it("F-ACTOR: explicit Infinity depthCap opts back into unbounded recursion", () => {
-		const g = new Graph("g");
-		const pool = actorPool<string>(g, { depthCap: Number.POSITIVE_INFINITY });
-		expect(() => pool.attachActor({ depth: 10_000, view: mkView() })).not.toThrow();
-		pool.dispose();
-	});
-
-	it("publish writes to the shared pool with an actor tag; context view sees it", () => {
-		const g = new Graph("g");
-		const pool = actorPool<string>(g);
-		const a = pool.attachActor({ id: "writer", view: mkView() });
-		a.publish({
-			payload: "hello",
-			tags: ["doc"],
-			importance: 0.5,
-			compressible: true,
-			topic: "context",
-		});
-		const entries = pool.contextPool.entries.cache ?? [];
-		expect(entries[0]?.payload).toBe("hello");
-		expect(entries[0]?.tags).toContain("actor:writer");
-		a.release();
-		pool.dispose();
-	});
-
-	it("todoCursor surfaces assigned + unassigned todos only", () => {
-		const g = new Graph("g");
-		const pool = actorPool<string>(g);
-		const a = pool.attachActor({ id: "me", view: mkView() });
-		pool.attachActor({ id: "other", view: mkView() });
-		const mine: Todo = { id: "t1", assignee: "me", payload: 1 };
-		const shared: Todo = { id: "t2", payload: 2 };
-		const theirs: Todo = { id: "t3", assignee: "other", payload: 3 };
-		a.enqueueTodo(mine);
-		a.enqueueTodo(shared);
-		a.enqueueTodo(theirs);
-		const cur = snapshot<readonly Todo[]>(a.todoCursor) ?? [];
-		expect(cur.map((t) => t.id).sort()).toEqual(["t1", "t2"]);
-		a.release();
-		pool.dispose();
-	});
-
-	it("setStatus updates the active map; release is idempotent + cascades", () => {
-		const g = new Graph("g");
-		const pool = actorPool<string>(g);
-		const a = pool.attachActor({ id: "s1", view: mkView() });
-		a.setStatus("running");
-		expect(snapshot<ReadonlyMap<string, { status: string }>>(pool.active)?.get("s1")?.status).toBe(
-			"running",
-		);
-		a.release();
-		a.release(); // idempotent
-		expect(snapshot<ReadonlyMap<string, unknown>>(pool.active)?.has("s1")).toBe(false);
-		pool.dispose();
-	});
-});
diff --git a/src/__tests__/presets/harness/ownership-controller.test.ts b/src/__tests__/presets/harness/ownership-controller.test.ts
deleted file mode 100644
index 3c8b71de..00000000
--- a/src/__tests__/presets/harness/ownership-controller.test.ts
+++ /dev/null
@@ -1,216 +0,0 @@
-/**
- * DS-14.5.A delta #8 — `ownershipController()` preset tests.
- *
- * Covers: TTL expiry, heartbeat renew/miss, supervisor override arbitration
- * by level, and the Q7 reactive-options Guard auto-mount (non-owner write
- * hard-blocked).
- */
-
-import { DATA, GuardDenied, node } from "@graphrefly/pure-ts/core";
-import { Graph } from "@graphrefly/pure-ts/graph";
-import { describe, expect, it } from "vitest";
-import {
-	type OwnershipState,
-	ownershipController,
-} from "../../../presets/harness/ownership-controller.js";
-
-/** Read the resolved owner by subscribing (activates the lazy derivation). */
-function ownerOf(oc: ReturnType<typeof ownershipController>): string | null {
-	let last: OwnershipState | undefined;
-	const unsub = oc.current.subscribe((msgs) => {
-		for (const m of msgs) if (m[0] === DATA) last = m[1] as OwnershipState;
-	});
-	unsub();
-	return last?.owner ?? null;
-}
-
-const sleep = (ms: number) => new Promise((r) => setTimeout(r, ms));
-
-describe("ownershipController — claim / release", () => {
-	it("claim makes the actor the resolved owner; release clears it", () => {
-		const oc = ownershipController("g", { ttl: 60_000 });
-		expect(ownerOf(oc)).toBeNull();
-		oc.claim("agent-a");
-		expect(ownerOf(oc)).toBe("agent-a");
-		oc.release("agent-a");
-		expect(ownerOf(oc)).toBeNull();
-	});
-
-	it("release by a non-owner does not clear ownership", () => {
-		const oc = ownershipController("g", { ttl: 60_000 });
-		oc.claim("agent-a");
-		oc.release("agent-b"); // not the owner
-		expect(ownerOf(oc)).toBe("agent-a");
-	});
-});
-
-describe("ownershipController — L1 TTL expiry (Q4 strict)", () => {
-	it("a claim auto-releases once TTL elapses (evaluated reactively)", async () => {
-		const clock = node<number>([], { initial: 0 });
-		const oc = ownershipController("g", { ttl: 30, clock });
-		oc.claim("agent-a");
-		expect(ownerOf(oc)).toBe("agent-a");
-		await sleep(50); // exceed the 30ms TTL
-		// Tick the reactive clock → `current` recomputes and sees expiry.
-		clock.down([[DATA, 1]]);
-		expect(ownerOf(oc)).toBeNull();
-	});
-
-	it("within the TTL window the claim stays live", async () => {
-		const clock = node<number>([], { initial: 0 });
-		const oc = ownershipController("g", { ttl: 200, clock });
-		oc.claim("agent-a");
-		await sleep(20);
-		clock.down([[DATA, 1]]);
-		expect(ownerOf(oc)).toBe("agent-a"); // still inside 200ms
-	});
-});
-
-describe("ownershipController — L2 heartbeat renew / miss", () => {
-	it("a heartbeat emission resets the TTL countdown (renew)", async () => {
-		const heartbeat = node<number>([], { initial: 0 });
-		const oc = ownershipController("g", { ttl: 60, heartbeat });
-		oc.claim("agent-a", "L2");
-		await sleep(40);
-		heartbeat.down([[DATA, 1]]); // sign of life — resets countdown
-		await sleep(40); // 80ms since claim, but only 40ms since heartbeat
-		heartbeat.down([[DATA, 2]]);
-		expect(ownerOf(oc)).toBe("agent-a");
-	});
-
-	it("a missed heartbeat past TTL expires the claim", async () => {
-		const heartbeat = node<number>([], { initial: 0 });
-		const oc = ownershipController("g", { ttl: 30, heartbeat });
-		oc.claim("agent-a", "L2");
-		await sleep(60); // no heartbeat for > TTL
-		heartbeat.down([[DATA, 1]]); // late beat triggers recompute → expired
-		expect(ownerOf(oc)).toBeNull();
-	});
-});
-
-describe("ownershipController — L3 supervisor override (Q10 level priority)", () => {
-	it("supervisor override wins regardless of an existing live claim", () => {
-		const oc = ownershipController("g", { ttl: 60_000, supervisor: "lead" });
-		oc.claim("agent-a", "L2");
-		expect(ownerOf(oc)).toBe("agent-a");
-		oc.override("lead", "agent-a", "rebalance");
-		expect(ownerOf(oc)).toBe("lead");
-	});
-
-	it("a lower-level claim cannot displace a higher-level (L3) owner", () => {
-		const oc = ownershipController("g", { ttl: 60_000, supervisor: "lead" });
-		oc.override("lead", "none", "seed");
-		expect(ownerOf(oc)).toBe("lead");
-		oc.claim("agent-b", "L1"); // L1 < L3 → ignored
-		expect(ownerOf(oc)).toBe("lead");
-	});
-
-	it("F5 — a NON-supervisor override is a no-op (does not seize ownership)", () => {
-		const oc = ownershipController("g", { ttl: 60_000, supervisor: "lead" });
-		oc.claim("agent-a", "L2");
-		expect(ownerOf(oc)).toBe("agent-a");
-		// "mallory" is not the supervisor — override must be ignored.
-		oc.override("mallory", "agent-a", "steal");
-		expect(ownerOf(oc)).toBe("agent-a");
-	});
-
-	it("F5 — overrides are disabled when no supervisor is configured", () => {
-		const oc = ownershipController("g", { ttl: 60_000 }); // no supervisor
-		oc.claim("agent-a");
-		expect(ownerOf(oc)).toBe("agent-a");
-		oc.override("anyone", "agent-a", "no supervisor configured");
-		expect(ownerOf(oc)).toBe("agent-a"); // unchanged
-	});
-
-	it("F5/Q10 — supervisor override wins by level over a live L2 claim", () => {
-		const oc = ownershipController("g", { ttl: 60_000, supervisor: "lead" });
-		oc.claim("agent-a", "L2");
-		expect(ownerOf(oc)).toBe("agent-a");
-		oc.override("lead", "agent-a", "rebalance");
-		expect(ownerOf(oc)).toBe("lead"); // L3 > L2
-		// A subsequent lower-level claim cannot displace the L3 owner.
-		oc.claim("agent-b", "L2");
-		expect(ownerOf(oc)).toBe("lead");
-	});
-});
-
-describe("ownershipController — F3/F4 pure-fold idempotency", () => {
-	it("a recompute storm (clock ticks, no heartbeat) does NOT renew a dead claim", async () => {
-		const clock = node<number>([], { initial: 0 });
-		const oc = ownershipController("g", { ttl: 30, clock });
-		oc.claim("agent-a");
-		expect(ownerOf(oc)).toBe("agent-a");
-		await sleep(50); // exceed TTL
-		// Tick repeatedly — a non-idempotent fold (old instance-accumulator
-		// bug) could renew the sign-of-life on a recompute and keep the
-		// dead claim alive. Pure fold: stays expired.
-		clock.down([[DATA, 1]]);
-		clock.down([[DATA, 2]]);
-		clock.down([[DATA, 3]]);
-		expect(ownerOf(oc)).toBeNull();
-	});
-
-	it("a prior owner's stale heartbeat cannot extend a new owner's window", async () => {
-		const heartbeat = node<number>([], { initial: 0 });
-		const oc = ownershipController("g", { ttl: 40, heartbeat });
-		oc.claim("agent-a", "L2");
-		heartbeat.down([[DATA, 1]]); // agent-a sign of life
-		oc.release("agent-a");
-		oc.claim("agent-b", "L2"); // new owner, fresh window
-		await sleep(60); // exceed agent-b's 40ms TTL with NO new beat
-		// The stale agent-a beat (older than agent-b's claim) must NOT
-		// extend agent-b — owner-scoped sign-of-life.
-		heartbeat.down([[DATA, 2]]);
-		expect(ownerOf(oc)).toBeNull();
-	});
-
-	it("a heartbeat before lapse keeps a claim live across waves (carry-forward)", async () => {
-		const heartbeat = node<number>([], { initial: 0 });
-		const clock = node<number>([], { initial: 0 });
-		const oc = ownershipController("g", { ttl: 60, heartbeat, clock });
-		oc.claim("agent-a", "L2");
-		await sleep(30);
-		heartbeat.down([[DATA, 1]]); // sign of life at ~30ms → window resets
-		await sleep(40); // 70ms since claim, 40ms since beat (< 60ms TTL)
-		// A clock tick with NO beat must carry the prior sign-of-life
-		// forward (still live), not fall back to claim time (would expire).
-		clock.down([[DATA, 1]]);
-		expect(ownerOf(oc)).toBe("agent-a");
-	});
-});
-
-describe("ownershipController — Q7 Guard auto-mount (reactive policyAllowing)", () => {
-	it("non-owner write is hard-blocked; owner write succeeds; re-points on claim", () => {
-		const oc = ownershipController("g", { ttl: 60_000 });
-		const owned = new Graph("owned");
-		owned.add(node<number>([], { initial: 0, guard: oc.guard }), { name: "doc" });
-
-		const agentA = { type: "llm" as const, id: "agent-a" };
-		const agentB = { type: "llm" as const, id: "agent-b" };
-
-		// Unclaimed → deny-all (closed, not open).
-		expect(() => owned.set("doc", 1, { actor: agentA })).toThrow(GuardDenied);
-
-		oc.claim("agent-a");
-		// Owner writes succeed; non-owner is hard-blocked.
-		expect(() => owned.set("doc", 2, { actor: agentA })).not.toThrow();
-		expect(() => owned.set("doc", 3, { actor: agentB })).toThrow(GuardDenied);
-
-		// Hand-off via release + re-claim re-points the allow-set with NO
-		// rewire. (No supervisor configured here ⇒ overrides are disabled,
-		// per F5 — a non-supervisor override is a no-op, so a plain
-		// release/claim sequence is the hand-off path.)
-		oc.release("agent-a");
-		oc.claim("agent-b");
-		expect(() => owned.set("doc", 4, { actor: agentB })).not.toThrow();
-		expect(() => owned.set("doc", 5, { actor: agentA })).toThrow(GuardDenied);
-	});
-
-	it("observe is always allowed (ownership gates writes, not reads)", () => {
-		const oc = ownershipController("g", { ttl: 60_000 });
-		oc.claim("agent-a");
-		// A non-owner reading the allow-set guard for observe → true.
-		expect(oc.guard({ type: "llm", id: "agent-z" }, "observe")).toBe(true);
-		expect(oc.guard({ type: "llm", id: "agent-z" }, "write")).toBe(false);
-	});
-});
diff --git a/src/__tests__/presets/harness/refine-loop.test.ts b/src/__tests__/presets/harness/refine-loop.test.ts
deleted file mode 100644
index b56181a1..00000000
--- a/src/__tests__/presets/harness/refine-loop.test.ts
+++ /dev/null
@@ -1,910 +0,0 @@
-import { node } from "@graphrefly/pure-ts/core";
-import { describe, expect, it } from "vitest";
-
-import {
-	blindVariation,
-	type DatasetItem,
-	type ErrorCritiqueContext,
-	type EvalResult,
-	type Evaluator,
-	errorCritique,
-	type Feedback,
-	type RefineStrategy,
-	refineLoop,
-} from "../../../presets/harness/refine-loop.js";
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-const DS: readonly DatasetItem[] = [{ id: "t1" }, { id: "t2" }, { id: "t3" }];
-
-/**
- * Trivial evaluator — scores a numeric candidate by distance to the per-task
- * target. Higher score = closer. Each task has a different target so the
- * aggregate score reflects how well the candidate does overall.
- */
-const numericEvaluator: Evaluator<number> = (candidates, dataset) =>
-	node(
-		[candidates, dataset],
-		(batchData, actions, ctx) => {
-			const data = batchData.map((batch, i) =>
-				batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-			);
-			const candidate = (data[0] as readonly number[]).at(-1) ?? 0;
-			const targets = (data[1] as readonly DatasetItem[]).map((t) => Number(t.id.slice(1)));
-			const results: EvalResult[] = targets.map((target, i) => ({
-				taskId: (data[1] as readonly DatasetItem[])[i]!.id,
-				score: -Math.abs(candidate - target),
-			}));
-			actions.emit(results);
-		},
-		{ describeKind: "derived" },
-	);
-
-/** Drain any settled async work so iteration effects propagate. */
-async function tick(rounds = 30): Promise<void> {
-	for (let i = 0; i < rounds; i++) {
-		await new Promise((r) => setTimeout(r, 0));
-	}
-}
-
-// ---------------------------------------------------------------------------
-// Basic wiring
-// ---------------------------------------------------------------------------
-
-describe("refineLoop — basic wiring", () => {
-	it("runs iterations, publishes to all four topics, and converges on maxIterations", async () => {
-		const generateEvents: number[] = [];
-		const evaluateEvents: number[] = [];
-		const analyzeEvents: number[] = [];
-		const decideEvents: string[] = [];
-
-		const teacher = (ctx: { prior: number }) => ctx.prior + 1;
-
-		const loop = refineLoop(0, numericEvaluator, blindVariation({ teacher, width: 1 }), {
-			dataset: DS,
-			maxIterations: 3,
-		});
-
-		loop.generate.events.subscribe(() => undefined);
-		loop.evaluate.events.subscribe(() => undefined);
-		loop.analyze.events.subscribe(() => undefined);
-		loop.decide.events.subscribe(() => undefined);
-
-		const genUnsub = loop.generate.latest.subscribe((msgs) => {
-			for (const m of msgs) {
-				if (m[0] === Symbol.for("graphrefly.DATA")) {
-					// no-op: we use the events log below
-				}
-			}
-		});
-		void genUnsub;
-
-		// Activate the loop by subscribing to a terminal observable.
-		loop.status.subscribe(() => undefined);
-		loop.best.subscribe(() => undefined);
-		loop.history.subscribe(() => undefined);
-
-		await tick();
-		await tick();
-
-		for (const e of loop.generate.retained()) generateEvents.push(e.iteration);
-		for (const e of loop.evaluate.retained()) evaluateEvents.push(e.iteration);
-		for (const e of loop.analyze.retained()) analyzeEvents.push(e.iteration);
-		for (const e of loop.decide.retained()) decideEvents.push(e.decision);
-
-		// At least one iteration's worth of events flowed through every stage.
-		expect(generateEvents.length).toBeGreaterThanOrEqual(1);
-		expect(evaluateEvents.length).toBeGreaterThanOrEqual(1);
-		expect(analyzeEvents.length).toBeGreaterThanOrEqual(1);
-		expect(decideEvents.length).toBeGreaterThanOrEqual(1);
-		// maxIterations=3 should eventually surface "converged" in decide.
-		expect(decideEvents).toContain("converged");
-		expect(loop.status.cache).toBe("converged");
-	});
-});
-
-// ---------------------------------------------------------------------------
-// Convergence rules
-// ---------------------------------------------------------------------------
-
-describe("refineLoop — convergence rules", () => {
-	it("stops on minScore when the score crosses the threshold", async () => {
-		// Candidates just repeat the seed; evaluator returns a fixed high score.
-		const strategy: RefineStrategy<number> = {
-			name: "identity",
-			seed(s) {
-				return [s];
-			},
-			analyze(scores) {
-				return { summary: "", score: scores[0]?.score ?? 0 };
-			},
-			generate(_fb, candidates) {
-				return candidates;
-			},
-		};
-		const highScoreEvaluator: Evaluator<number> = (candidates, _ds) =>
-			node(
-				[candidates],
-				(batchData, actions, ctx) => {
-					const _data = batchData.map((batch, i) =>
-						batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-					);
-					actions.emit([{ taskId: "t1", score: 0.95 }] as const);
-				},
-				{ describeKind: "derived" },
-			);
-
-		const loop = refineLoop(0, highScoreEvaluator, strategy, {
-			dataset: DS,
-			minScore: 0.9,
-			maxIterations: 100,
-		});
-		loop.status.subscribe(() => undefined);
-		loop.history.subscribe(() => undefined);
-		await tick();
-
-		expect(loop.status.cache).toBe("converged");
-		const lastDecision = loop.decide.retained().at(-1)!;
-		expect(lastDecision.reason).toBe("min-score");
-	});
-
-	it("stops on maxEvaluations when the budget counter crosses the cap", async () => {
-		const strategy = blindVariation<number>({
-			width: 2,
-			teacher: (ctx) => ctx.prior,
-		});
-		const loop = refineLoop(0, numericEvaluator, strategy, {
-			dataset: DS,
-			maxEvaluations: 4,
-			maxIterations: 100,
-		});
-		loop.status.subscribe(() => undefined);
-		loop.history.subscribe(() => undefined);
-		await tick();
-
-		expect(loop.status.cache).toBe("converged");
-		const lastDecision = loop.decide.retained().at(-1)!;
-		expect(lastDecision.reason).toBe("max-evaluations");
-	});
-
-	it("stops on budget exhaustion (separate from maxEvaluations)", async () => {
-		const strategy = blindVariation<number>({
-			width: 2,
-			teacher: (ctx) => ctx.prior,
-		});
-		const loop = refineLoop(0, numericEvaluator, strategy, {
-			dataset: DS,
-			budget: 3,
-			maxIterations: 100,
-		});
-		loop.status.subscribe(() => undefined);
-		loop.history.subscribe(() => undefined);
-		await tick();
-
-		expect(loop.status.cache).toBe("budget");
-		const lastDecision = loop.decide.retained().at(-1)!;
-		expect(lastDecision.decision).toBe("budget");
-	});
-});
-
-// ---------------------------------------------------------------------------
-// Strategy swap (human-in-the-loop)
-// ---------------------------------------------------------------------------
-
-describe("refineLoop — strategy swap", () => {
-	it("setStrategy swaps the active strategy mid-run; next iteration uses the new one", async () => {
-		const calls: string[] = [];
-		// Strategies are intentionally async: a sync `generate` drains the whole
-		// loop synchronously inside the factory's activation cascade, leaving
-		// no window for `pause()` / `setStrategy()` to interleave. Real
-		// strategies are LLM calls (async); async variants here match that.
-		const stratA: RefineStrategy<number> = {
-			name: "A",
-			seed(s) {
-				calls.push("A.seed");
-				return [s];
-			},
-			analyze(scores) {
-				return { summary: "A", score: scores[0]?.score ?? 0 };
-			},
-			async generate(_fb, candidates) {
-				calls.push("A.generate");
-				return [...candidates];
-			},
-		};
-		const stratB: RefineStrategy<number> = {
-			name: "B",
-			seed(s) {
-				calls.push("B.seed");
-				return [s];
-			},
-			analyze(scores) {
-				return { summary: "B", score: scores[0]?.score ?? 0 };
-			},
-			async generate(_fb, candidates) {
-				calls.push("B.generate");
-				return candidates.map((c) => c + 100);
-			},
-		};
-
-		// Pause immediately so the loop halts after iter 0 (A.seed only).
-		// Under Promise.resolve-backed switchMap, the whole loop can drain in
-		// a single tick — pausing synchronously catches the first decide wave.
-		const loop = refineLoop(1, numericEvaluator, stratA, {
-			dataset: DS,
-			maxIterations: 20,
-		});
-		loop.status.subscribe(() => undefined);
-		loop.history.subscribe(() => undefined);
-
-		loop.pause();
-		await tick(5);
-		expect(calls[0]).toBe("A.seed");
-
-		// Swap and resume — iter 1+ should use B.generate.
-		loop.setStrategy(stratB);
-		loop.resume();
-		await tick(10);
-
-		expect(calls.some((c) => c === "B.generate")).toBe(true);
-	});
-});
-
-// ---------------------------------------------------------------------------
-// Pause / resume
-// ---------------------------------------------------------------------------
-
-describe("refineLoop — pause/resume", () => {
-	it("pause() stops the loop at the next decision and resume() continues it", async () => {
-		const strategy = blindVariation<number>({
-			width: 1,
-			teacher: (ctx) => ctx.prior + 1,
-		});
-		const loop = refineLoop(0, numericEvaluator, strategy, {
-			dataset: DS,
-			maxIterations: 100,
-		});
-		loop.status.subscribe(() => undefined);
-		loop.history.subscribe(() => undefined);
-
-		// Pause BEFORE letting the async microtask queue drain — the loop runs
-		// one iteration per microtask (fromAny + Promise.resolve), so by the
-		// time a single `await tick()` completes the whole 100-iteration run
-		// has already finished. Pausing synchronously catches the very next
-		// decide wave.
-		loop.pause();
-		await tick();
-
-		expect(loop.status.cache).toBe("paused");
-		const iterAtPause = loop._iteration.cache as number;
-
-		loop.resume();
-		await tick();
-
-		// After resume, status returns to running (or converged if the rest
-		// of maxIterations drained). Either way, iteration must have advanced.
-		expect(loop._iteration.cache as number).toBeGreaterThan(iterAtPause);
-	});
-});
-
-// ---------------------------------------------------------------------------
-// Observability
-// ---------------------------------------------------------------------------
-
-describe("refineLoop — observability", () => {
-	it("describe() surfaces all four stage topics + state nodes", async () => {
-		const loop = refineLoop(
-			0,
-			numericEvaluator,
-			blindVariation({ teacher: (ctx) => ctx.prior, width: 1 }),
-			{ dataset: DS, maxIterations: 1 },
-		);
-		const desc = loop.describe();
-		expect(desc.nodes).toHaveProperty("iteration");
-		expect(desc.nodes).toHaveProperty("strategy");
-		expect(desc.nodes).toHaveProperty("status");
-		expect(desc.nodes).toHaveProperty("best");
-		expect(desc.nodes).toHaveProperty("score");
-		expect(desc.nodes).toHaveProperty("history");
-		// Stage topics surface under stages::<stage>::events etc. (hub mount).
-		const pathList = Object.keys(desc.nodes);
-		expect(pathList.some((p) => p.startsWith("stages::generate::"))).toBe(true);
-		expect(pathList.some((p) => p.startsWith("stages::evaluate::"))).toBe(true);
-		expect(pathList.some((p) => p.startsWith("stages::analyze::"))).toBe(true);
-		expect(pathList.some((p) => p.startsWith("stages::decide::"))).toBe(true);
-	});
-
-	it("history accumulates one Iteration per completed iteration", async () => {
-		const strategy = blindVariation<number>({
-			width: 1,
-			teacher: (ctx) => ctx.prior + 1,
-		});
-		const loop = refineLoop(0, numericEvaluator, strategy, {
-			dataset: DS,
-			maxIterations: 3,
-		});
-		loop.status.subscribe(() => undefined);
-		loop.history.subscribe(() => undefined);
-		await tick();
-
-		const hist = loop.history.cache as readonly { n: number }[];
-		expect(hist.length).toBeGreaterThanOrEqual(1);
-		for (let i = 1; i < hist.length; i++) {
-			expect(hist[i]!.n).toBeGreaterThanOrEqual(hist[i - 1]!.n);
-		}
-	});
-
-	it("reactive dataset: wrapping a node([]) node allows mid-run dataset swap", async () => {
-		const datasetNode = node<readonly DatasetItem[]>([], { initial: DS });
-		const strategy = blindVariation<number>({
-			width: 1,
-			teacher: (ctx) => ctx.prior,
-		});
-		const loop = refineLoop(0, numericEvaluator, strategy, {
-			dataset: datasetNode,
-			maxIterations: 3,
-		});
-		loop.status.subscribe(() => undefined);
-		loop.history.subscribe(() => undefined);
-		await tick();
-
-		// Swap the dataset — next iteration's evaluation uses the new set.
-		datasetNode.emit([{ id: "t10" }, { id: "t20" }]);
-		await tick();
-
-		expect(loop.status.cache).toBe("converged"); // maxIterations=3
-	});
-});
-
-// ---------------------------------------------------------------------------
-// errorCritique strategy
-// ---------------------------------------------------------------------------
-
-describe("errorCritique — built-in strategy", () => {
-	/**
-	 * Evaluator that fans out scores across all candidates × all tasks and
-	 * stamps each score with `candidateIndex` so `pickBest` aggregates per
-	 * candidate (D1). Targets are parsed from task IDs (`"t1"` → 1, etc.);
-	 * higher score = closer to target.
-	 */
-	const perTaskEvaluator: Evaluator<number> = (candidates, dataset) =>
-		node(
-			[candidates, dataset],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				const cands = data[0] as readonly number[];
-				const tasks = data[1] as readonly DatasetItem[];
-				const out: EvalResult[] = [];
-				for (let ci = 0; ci < cands.length; ci++) {
-					const c = cands[ci]!;
-					for (const t of tasks) {
-						const target = Number(t.id.slice(1));
-						out.push({ taskId: t.id, score: -Math.abs(c - target), candidateIndex: ci });
-					}
-				}
-				actions.emit(out);
-			},
-			{ describeKind: "derived" },
-		);
-
-	it("seeds with just the seed at iteration 0", () => {
-		const strategy = errorCritique<number>({
-			teacher: (ctx) => ctx.prior + 1,
-			width: 4,
-		});
-		const out = strategy.seed(42);
-		expect(out).toEqual([42]);
-	});
-
-	it("calls the teacher `width` times per iteration", async () => {
-		const teacherCalls: ErrorCritiqueContext<number>[] = [];
-		const strategy = errorCritique<number>({
-			width: 3,
-			teacher: (ctx) => {
-				teacherCalls.push(ctx);
-				return ctx.prior + 1;
-			},
-		});
-		const loop = refineLoop(0, perTaskEvaluator, strategy, {
-			dataset: DS,
-			maxIterations: 2,
-		});
-		loop.status.subscribe(() => undefined);
-		loop.history.subscribe(() => undefined);
-		await tick();
-
-		// At least one iteration of critique-driven generation — so at least
-		// `width` teacher calls. maxIterations=2 means 1 critique pass after
-		// the seed iteration.
-		expect(teacherCalls.length).toBeGreaterThanOrEqual(3);
-	});
-
-	it("teacher receives the best candidate as `prior` (highest score wins)", async () => {
-		const priors: number[] = [];
-		// Strategy under test: capture prior values passed to the teacher.
-		const strategy = errorCritique<number>({
-			width: 1,
-			teacher: (ctx) => {
-				priors.push(ctx.prior);
-				// Return prior unchanged so candidates[0] stays stable across
-				// iterations (converges quickly via maxIterations).
-				return ctx.prior;
-			},
-		});
-		// Seed of 2 → perTaskEvaluator scores it against targets from DS
-		// ({t1: 1, t2: 2, t3: 3}). Best candidate is the seed itself at iter 0.
-		const loop = refineLoop(2, perTaskEvaluator, strategy, {
-			dataset: DS,
-			maxIterations: 3,
-		});
-		loop.status.subscribe(() => undefined);
-		loop.history.subscribe(() => undefined);
-		await tick();
-
-		// First teacher call (iter 1) must have received the seed (2) as prior
-		// since that was the only candidate at iter 0.
-		expect(priors[0]).toBe(2);
-	});
-
-	it("populates `failures` with tasks below the default (batch-mean) threshold", async () => {
-		const critiqueCalls: ErrorCritiqueContext<number>[] = [];
-		const strategy = errorCritique<number>({
-			width: 1,
-			teacher: (ctx) => {
-				critiqueCalls.push(ctx);
-				return ctx.prior;
-			},
-		});
-		const loop = refineLoop(0, perTaskEvaluator, strategy, {
-			dataset: DS,
-			maxIterations: 2,
-		});
-		loop.status.subscribe(() => undefined);
-		loop.history.subscribe(() => undefined);
-		await tick();
-
-		// Seed=0 scored against targets 1/2/3 gives scores [-1, -2, -3].
-		// Mean = -2. Only -3 (t3) is < -2, so failures should contain only t3.
-		expect(critiqueCalls.length).toBeGreaterThanOrEqual(1);
-		const firstCritique = critiqueCalls[0]!;
-		expect(firstCritique.failures.map((f) => f.taskId)).toEqual(["t3"]);
-	});
-
-	it("respects a numeric `failureThreshold` (absolute cut-off)", async () => {
-		const critiqueCalls: ErrorCritiqueContext<number>[] = [];
-		const strategy = errorCritique<number>({
-			width: 1,
-			failureThreshold: -1.5, // any task scoring below -1.5 is a failure
-			teacher: (ctx) => {
-				critiqueCalls.push(ctx);
-				return ctx.prior;
-			},
-		});
-		const loop = refineLoop(0, perTaskEvaluator, strategy, {
-			dataset: DS,
-			maxIterations: 2,
-		});
-		loop.status.subscribe(() => undefined);
-		loop.history.subscribe(() => undefined);
-		await tick();
-
-		// seed=0 → scores [-1, -2, -3]. Below -1.5: t2 and t3.
-		const first = critiqueCalls[0]!;
-		expect(first.failures.map((f) => f.taskId).sort()).toEqual(["t2", "t3"]);
-	});
-
-	it("accepts a function `failureThreshold` for per-batch computation", async () => {
-		const critiqueCalls: ErrorCritiqueContext<number>[] = [];
-		const strategy = errorCritique<number>({
-			width: 1,
-			// Threshold = the minimum score — nothing is strictly below it, so
-			// failures must be empty.
-			failureThreshold: (scores) => Math.min(...scores.map((s) => s.score)),
-			teacher: (ctx) => {
-				critiqueCalls.push(ctx);
-				return ctx.prior;
-			},
-		});
-		const loop = refineLoop(0, perTaskEvaluator, strategy, {
-			dataset: DS,
-			maxIterations: 2,
-		});
-		loop.status.subscribe(() => undefined);
-		loop.history.subscribe(() => undefined);
-		await tick();
-
-		expect(critiqueCalls[0]!.failures).toEqual([]);
-	});
-
-	it("clips failures to `maxFailureSamples`", async () => {
-		const critiqueCalls: ErrorCritiqueContext<number>[] = [];
-		// 5 tasks; set maxFailureSamples=2. Use an all-negative score range
-		// and threshold large enough that every task fails.
-		const bigDS: readonly DatasetItem[] = [
-			{ id: "t1" },
-			{ id: "t2" },
-			{ id: "t3" },
-			{ id: "t4" },
-			{ id: "t5" },
-		];
-		const strategy = errorCritique<number>({
-			width: 1,
-			failureThreshold: 0, // every score is < 0, everything fails
-			maxFailureSamples: 2,
-			teacher: (ctx) => {
-				critiqueCalls.push(ctx);
-				return ctx.prior;
-			},
-		});
-		const loop = refineLoop(0, perTaskEvaluator, strategy, {
-			dataset: bigDS,
-			maxIterations: 2,
-		});
-		loop.status.subscribe(() => undefined);
-		loop.history.subscribe(() => undefined);
-		await tick();
-
-		const first = critiqueCalls[0]!;
-		expect(first.failures.length).toBe(2);
-		// Worst failures are prioritised — t5 (-5) and t4 (-4) are the bottom 2.
-		expect(first.failures.map((f) => f.taskId)).toEqual(["t5", "t4"]);
-	});
-
-	it("uses a custom `formatCritique` when provided", async () => {
-		const seen: string[] = [];
-		const strategy = errorCritique<number>({
-			width: 1,
-			formatCritique: (failures) => `FAILS=${failures.length}`,
-			teacher: (ctx) => {
-				seen.push(ctx.critique);
-				return ctx.prior;
-			},
-		});
-		const loop = refineLoop(0, perTaskEvaluator, strategy, {
-			dataset: DS,
-			maxIterations: 2,
-		});
-		loop.status.subscribe(() => undefined);
-		loop.history.subscribe(() => undefined);
-		await tick();
-
-		expect(seen[0]).toMatch(/^FAILS=\d+$/);
-	});
-
-	it("generate throws on empty candidate batch (direct unit test)", async () => {
-		// N2: Test strategy.generate() directly with synthetic inputs — no loop,
-		// no timing races. Deterministic enforcement of the length-guard throw.
-		const strategy = errorCritique<number>({
-			width: 1,
-			teacher: (ctx) => ctx.prior,
-		});
-		const feedback: Feedback = { summary: "irrelevant", score: 0 };
-		await expect(strategy.generate(feedback, [])).rejects.toThrow(/empty candidate batch/);
-	});
-
-	it("generate falls back to candidates[last] + feedback.summary on foreign Feedback (direct unit test)", async () => {
-		// N2: Verify the strategy-swap fallback path as a pure unit test.
-		const seen: ErrorCritiqueContext<number>[] = [];
-		const strategy = errorCritique<number>({
-			width: 1,
-			teacher: (ctx) => {
-				seen.push(ctx);
-				return ctx.prior + 1;
-			},
-		});
-		// Foreign feedback — no errorCritique private payload.
-		const feedback: Feedback = { summary: "from-A", score: 0 };
-		const out = await strategy.generate(feedback, [10, 42]);
-
-		expect(seen).toHaveLength(1);
-		expect(seen[0]!.prior).toBe(42); // candidates[last]
-		expect(seen[0]!.critique).toBe("from-A"); // feedback.summary
-		expect(seen[0]!.failures).toEqual([]);
-		expect(out).toEqual([43]);
-	});
-
-	it("generate prefers priv.best over candidates[last] when the private payload is present (direct unit test)", async () => {
-		// N2 + D1: confirms priv-payload path works even when candidates[last]
-		// differs from priv.best.
-		const seen: ErrorCritiqueContext<number>[] = [];
-		const strategy = errorCritique<number>({
-			width: 1,
-			teacher: (ctx) => {
-				seen.push(ctx);
-				return ctx.prior;
-			},
-		});
-		// Inject a synthetic Feedback that claims best=99 via the priv channel.
-		// Use analyze to build a real priv payload, then replace the critique.
-		const synthetic = strategy.analyze(
-			[
-				{ taskId: "t1", score: 10, candidateIndex: 0 },
-				{ taskId: "t1", score: -5, candidateIndex: 1 },
-			],
-			[99, 7],
-		);
-		// priv.best should be 99 (higher score at candidateIndex 0).
-		const out = await strategy.generate(synthetic, [0, 0]); // candidates[last]=0
-		expect(seen).toHaveLength(1);
-		expect(seen[0]!.prior).toBe(99); // from priv, not candidates[last]
-		expect(out).toEqual([99]);
-	});
-
-	it("converges on minScore when the teacher improves toward the target", async () => {
-		// Teacher always moves prior up by 1. With seed=0 and targets {1,2,3},
-		// the single-task evaluator below will reach -0 (perfect) quickly.
-		const singleTaskEvaluator: Evaluator<number> = (candidates) =>
-			node(
-				[candidates],
-				(batchData, actions, ctx) => {
-					const data = batchData.map((batch, i) =>
-						batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-					);
-					const c = (data[0] as readonly number[]).at(-1) ?? 0;
-					actions.emit([{ taskId: "t2", score: -Math.abs(c - 2) }] as const);
-				},
-				{ describeKind: "derived" },
-			);
-
-		const strategy = errorCritique<number>({
-			width: 1,
-			teacher: (ctx) => ctx.prior + 1,
-		});
-		const loop = refineLoop(0, singleTaskEvaluator, strategy, {
-			dataset: [{ id: "t2" }],
-			minScore: -0.0001,
-			maxIterations: 20,
-		});
-		loop.status.subscribe(() => undefined);
-		loop.history.subscribe(() => undefined);
-		loop.best.subscribe(() => undefined);
-		await tick();
-
-		expect(loop.status.cache).toBe("converged");
-		expect(loop.best.cache).toBe(2);
-	});
-
-	// -------------------------------------------------------------------------
-	// A1: NaN threshold fallback
-	// -------------------------------------------------------------------------
-
-	it("treats all scores as failures when the default (batch-mean) threshold is non-finite", async () => {
-		// A1: evaluator produces NaN scores → meanScore is NaN → default
-		// threshold is NaN. Guard: all scores become failures instead of
-		// filtering with `< NaN` (always false → silent no-op).
-		const strategy = errorCritique<number>({
-			width: 1,
-			teacher: (ctx) => ctx.prior,
-		});
-		const fb = strategy.analyze(
-			[
-				{ taskId: "t1", score: Number.NaN },
-				{ taskId: "t2", score: Number.NaN },
-			],
-			[0],
-		);
-		const priv = fb.critique as { failures: readonly EvalResult[] };
-		expect(priv.failures).toHaveLength(2);
-		expect(priv.failures.map((f) => f.taskId).sort()).toEqual(["t1", "t2"]);
-	});
-
-	it("still respects a user-supplied numeric threshold when scores are NaN (no fallback)", async () => {
-		// A1 scope check: the all-failures fallback ONLY fires when the user
-		// didn't supply a threshold. A numeric threshold is used as-is.
-		const strategy = errorCritique<number>({
-			width: 1,
-			failureThreshold: 0,
-			teacher: (ctx) => ctx.prior,
-		});
-		const fb = strategy.analyze([{ taskId: "t1", score: Number.NaN }], [0]);
-		const priv = fb.critique as { failures: readonly EvalResult[] };
-		// NaN < 0 is false, so NO failures — user-threshold is honoured.
-		expect(priv.failures).toHaveLength(0);
-	});
-
-	// -------------------------------------------------------------------------
-	// D1: candidateIndex fan-out aggregation in pickBest
-	// -------------------------------------------------------------------------
-
-	it("pickBest aggregates mean per candidateIndex when scores fan out", async () => {
-		// Direct test via analyze: 2 candidates × 2 tasks = 4 scores. Candidate 0
-		// scores (10, 8) = mean 9; candidate 1 scores (5, 7) = mean 6. Best = 0.
-		const strategy = errorCritique<number>({
-			width: 1,
-			teacher: (ctx) => ctx.prior,
-		});
-		const fb = strategy.analyze(
-			[
-				{ taskId: "t1", score: 10, candidateIndex: 0 },
-				{ taskId: "t2", score: 8, candidateIndex: 0 },
-				{ taskId: "t1", score: 5, candidateIndex: 1 },
-				{ taskId: "t2", score: 7, candidateIndex: 1 },
-			],
-			[100, 200],
-		);
-		const priv = fb.critique as { best: number };
-		expect(priv.best).toBe(100); // candidates[0], mean 9 beats candidates[1], mean 6
-	});
-
-	it("pickBest falls back to positional alignment when candidateIndex is absent", async () => {
-		// Without candidateIndex, scores[i] ↔ candidates[i] by position.
-		const strategy = errorCritique<number>({
-			width: 1,
-			teacher: (ctx) => ctx.prior,
-		});
-		const fb = strategy.analyze(
-			[
-				{ taskId: "t1", score: 3 },
-				{ taskId: "t2", score: 9 },
-			],
-			[100, 200],
-		);
-		const priv = fb.critique as { best: number };
-		expect(priv.best).toBe(200); // scores[1]=9 > scores[0]=3 → candidates[1]
-	});
-
-	// -------------------------------------------------------------------------
-	// D2: tokens companion node (on success AND teacher-throw path)
-	// -------------------------------------------------------------------------
-
-	it("writes running-total tokens to `opts.tokens` after each iteration (success path)", async () => {
-		const tokens = node<number>([], { name: "tokens", initial: 0 });
-		const strategy = errorCritique<number>({
-			width: 2,
-			tokens,
-			teacher: (ctx) => {
-				ctx.reportCost(7);
-				return ctx.prior;
-			},
-		});
-		// Activate the tokens node so .cache stays fresh.
-		tokens.subscribe(() => undefined);
-		const fb: Feedback = { summary: "", score: 0 };
-		await strategy.generate(fb, [42]);
-		// 2 teacher calls × 7 tokens = 14. No prior value, so final is 14.
-		expect(tokens.cache).toBe(14);
-	});
-
-	it("delivers partial tokens on teacher throw via finally (no spend lost)", async () => {
-		const tokens = node<number>([], { name: "tokens-err", initial: 0 });
-		tokens.subscribe(() => undefined);
-		let calls = 0;
-		const strategy = errorCritique<number>({
-			width: 3,
-			tokens,
-			// Sequential mode so we can reason about call count before the throw.
-			parallel: false,
-			teacher: (ctx) => {
-				calls++;
-				ctx.reportCost(5);
-				if (calls === 3) throw new Error("teacher-failure");
-				return ctx.prior;
-			},
-		});
-		const fb: Feedback = { summary: "", score: 0 };
-		await expect(strategy.generate(fb, [1])).rejects.toThrow("teacher-failure");
-		// 3 calls reported cost before the 3rd threw: 15 tokens total.
-		expect(tokens.cache).toBe(15);
-	});
-
-	it("accumulates tokens across iterations (prev + delta)", async () => {
-		const tokens = node<number>([], { name: "tokens-prev", initial: 100 });
-		tokens.subscribe(() => undefined);
-		const strategy = errorCritique<number>({
-			width: 1,
-			tokens,
-			teacher: (ctx) => {
-				ctx.reportCost(30);
-				return ctx.prior;
-			},
-		});
-		const fb: Feedback = { summary: "", score: 0 };
-		await strategy.generate(fb, [1]);
-		expect(tokens.cache).toBe(130);
-		await strategy.generate(fb, [1]);
-		expect(tokens.cache).toBe(160);
-	});
-
-	it("no-op on tokens when the teacher never calls reportCost", async () => {
-		const tokens = node<number>([], { name: "tokens-unused", initial: 0 });
-		tokens.subscribe(() => undefined);
-		const strategy = errorCritique<number>({
-			width: 2,
-			tokens,
-			teacher: (ctx) => ctx.prior, // no reportCost call
-		});
-		const fb: Feedback = { summary: "", score: 0 };
-		await strategy.generate(fb, [1]);
-		expect(tokens.cache).toBe(0); // no write when iterCost === 0
-	});
-
-	// -------------------------------------------------------------------------
-	// D3: parallel vs sequential teacher invocation
-	// -------------------------------------------------------------------------
-
-	it("runs teacher calls in parallel by default (Promise.all)", async () => {
-		// If parallel, all N teachers start before any completes. Detect this
-		// by checking how many are "in-flight" when the first deferred resolves.
-		let inFlight = 0;
-		let maxInFlight = 0;
-		const strategy = errorCritique<number>({
-			width: 4,
-			// parallel: true (default)
-			teacher: async (ctx) => {
-				inFlight++;
-				maxInFlight = Math.max(maxInFlight, inFlight);
-				await new Promise((r) => setTimeout(r, 0));
-				inFlight--;
-				return ctx.prior;
-			},
-		});
-		const fb: Feedback = { summary: "", score: 0 };
-		await strategy.generate(fb, [1]);
-		expect(maxInFlight).toBe(4); // all 4 calls in-flight simultaneously
-	});
-
-	it("runs teacher calls sequentially when parallel: false", async () => {
-		let inFlight = 0;
-		let maxInFlight = 0;
-		const strategy = errorCritique<number>({
-			width: 4,
-			parallel: false,
-			teacher: async (ctx) => {
-				inFlight++;
-				maxInFlight = Math.max(maxInFlight, inFlight);
-				await new Promise((r) => setTimeout(r, 0));
-				inFlight--;
-				return ctx.prior;
-			},
-		});
-		const fb: Feedback = { summary: "", score: 0 };
-		await strategy.generate(fb, [1]);
-		expect(maxInFlight).toBe(1); // only one call in-flight at a time
-	});
-
-	it("blindVariation also supports parallel (default) vs sequential", async () => {
-		let maxInFlight = 0;
-		let inFlight = 0;
-		const makeStrategy = (parallel: boolean) =>
-			blindVariation<number>({
-				width: 3,
-				parallel,
-				teacher: async (ctx) => {
-					inFlight++;
-					maxInFlight = Math.max(maxInFlight, inFlight);
-					await new Promise((r) => setTimeout(r, 0));
-					inFlight--;
-					return ctx.prior;
-				},
-			});
-		// Sequential: at most 1 in-flight.
-		maxInFlight = 0;
-		inFlight = 0;
-		await makeStrategy(false).generate({ summary: "", score: 0 }, [1]);
-		expect(maxInFlight).toBe(1);
-		// Parallel (default): all 3 in-flight at once.
-		maxInFlight = 0;
-		inFlight = 0;
-		await makeStrategy(true).generate({ summary: "", score: 0 }, [1]);
-		expect(maxInFlight).toBe(3);
-	});
-
-	it("blindVariation also writes to opts.tokens", async () => {
-		const tokens = node<number>([], { name: "bv-tokens", initial: 0 });
-		tokens.subscribe(() => undefined);
-		const strategy = blindVariation<number>({
-			width: 2,
-			tokens,
-			teacher: (ctx) => {
-				ctx.reportCost(11);
-				return ctx.prior;
-			},
-		});
-		await strategy.generate({ summary: "", score: 0 }, [1]);
-		expect(tokens.cache).toBe(22);
-	});
-});
diff --git a/src/__tests__/presets/harness/spawnable.test.ts b/src/__tests__/presets/harness/spawnable.test.ts
deleted file mode 100644
index 5c68858d..00000000
--- a/src/__tests__/presets/harness/spawnable.test.ts
+++ /dev/null
@@ -1,432 +0,0 @@
-/**
- * Phase 13.I — `spawnable()` regression tests.
- */
-
-import { DATA } from "@graphrefly/pure-ts/core";
-import { describe, expect, it } from "vitest";
-import type { AgentBundle, AgentSpec } from "../../../presets/ai/index.js";
-import { presetRegistry } from "../../../presets/ai/index.js";
-import { type SpawnRejection, spawnable } from "../../../presets/harness/spawnable.js";
-import type { LLMAdapter, LLMResponse } from "../../../utils/ai/index.js";
-import { type Message, messagingHub, SPAWNS_TOPIC } from "../../../utils/messaging/index.js";
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-function syncAdapter(content: string): LLMAdapter {
-	const resp: LLMResponse = {
-		content,
-		finishReason: "end_turn",
-		usage: { input: { regular: 5 }, output: { regular: 5 } },
-	};
-	return {
-		provider: "mock",
-		invoke() {
-			return resp;
-		},
-		async *stream() {
-			yield { type: "token", delta: content };
-			yield { type: "finish", reason: "stop" };
-		},
-	};
-}
-
-function neverResolvingAdapter(): LLMAdapter {
-	return {
-		provider: "mock-never",
-		invoke() {
-			return new Promise<LLMResponse>(() => {
-				/* never resolves */
-			});
-		},
-		async *stream() {
-			yield { type: "finish", reason: "stop" };
-		},
-	};
-}
-
-function makeRequest(
-	id: string,
-	presetId: string,
-	taskInput: string,
-	extra?: Partial<Message<{ presetId: string; taskInput: string }>>,
-): Message<{ presetId: string; taskInput: string }> {
-	return {
-		id,
-		payload: { presetId, taskInput },
-		...extra,
-	};
-}
-
-// ---------------------------------------------------------------------------
-// Basic spawn / completion
-// ---------------------------------------------------------------------------
-
-describe("spawnable() — basic spawn lifecycle", () => {
-	it("spawns the matching preset's agent, runs it, and removes from activeSlot on done", async () => {
-		const hub = messagingHub("hub");
-		const presets = presetRegistry<AgentSpec<string, LLMResponse>>();
-		presets.put("researcher", {
-			name: "researcher", // overridden per-spawn
-			adapter: syncAdapter("answer: 42"),
-		});
-		const sp = spawnable<string, LLMResponse>({ hub, registry: presets });
-
-		// Track activeSlot snapshots so we can verify mid-flight presence.
-		const snaps: ReadonlyMap<string, AgentBundle<string, LLMResponse>>[] = [];
-		const unsub = sp.activeSlot.subscribe((msgs) => {
-			for (const m of msgs) {
-				if (m[0] === DATA)
-					snaps.push(m[1] as ReadonlyMap<string, AgentBundle<string, LLMResponse>>);
-			}
-		});
-
-		sp.spawnTopic.publish(makeRequest("req-1", "researcher", "what is 6 * 7?"));
-
-		// Synchronous adapter — by the time publish returns, the agent has
-		// been minted, run, and torn down. activeSlot transitioned size 0 →
-		// 1 → 0, and the final cache is the empty map.
-		const sizes = snaps.map((m) => m.size);
-		expect(sizes).toContain(1);
-		expect(sizes.at(-1)).toBe(0);
-
-		unsub();
-		hub.destroy();
-	});
-
-	it("forwards the request taskInput as the agent's bundle.in input", async () => {
-		const hub = messagingHub("hub");
-		const presets = presetRegistry<AgentSpec<string, LLMResponse>>();
-		presets.put("echo", {
-			name: "echo",
-			adapter: syncAdapter("ok"),
-		});
-		const sp = spawnable<string, LLMResponse>({ hub, registry: presets });
-
-		// Capture the bundle when it's mounted so we can assert chat saw the input.
-		let captured: AgentBundle<string, LLMResponse> | undefined;
-		const unsub = sp.activeSlot.subscribe((msgs) => {
-			for (const m of msgs) {
-				if (m[0] === DATA) {
-					const map = m[1] as ReadonlyMap<string, AgentBundle<string, LLMResponse>>;
-					if (map.size > 0) captured = [...map.values()][0];
-				}
-			}
-		});
-
-		sp.spawnTopic.publish(makeRequest("req-2", "echo", "hello world"));
-
-		expect(captured).toBeDefined();
-		const messages = captured?.graph.loop.chat.allMessages();
-		expect(messages?.[0]?.role).toBe("user");
-		expect(messages?.[0]?.content).toBe("hello world");
-
-		unsub();
-		hub.destroy();
-	});
-});
-
-// ---------------------------------------------------------------------------
-// Depth-cap rejection
-// ---------------------------------------------------------------------------
-
-describe("spawnable() — depth-cap", () => {
-	it("rejects requests over depthCap with a reason on the rejected topic", () => {
-		const hub = messagingHub("hub");
-		const presets = presetRegistry<AgentSpec<string, LLMResponse>>();
-		presets.put("slow", {
-			name: "slow",
-			adapter: neverResolvingAdapter(),
-		});
-		const sp = spawnable<string, LLMResponse>({
-			hub,
-			registry: presets,
-			depthCap: 2,
-		});
-
-		const rejections: SpawnRejection<string>[] = [];
-		const unsub = sp.rejected.events.subscribe((msgs) => {
-			for (const m of msgs) {
-				if (m[0] === DATA) {
-					for (const r of m[1] as readonly SpawnRejection<string>[]) rejections.push(r);
-				}
-			}
-		});
-
-		// First two spawn (slow adapter never finishes) → activeSlot = 2.
-		sp.spawnTopic.publish(makeRequest("req-1", "slow", "task1"));
-		sp.spawnTopic.publish(makeRequest("req-2", "slow", "task2"));
-		expect((sp.activeSlot.cache as ReadonlyMap<string, unknown>).size).toBe(2);
-
-		// Third over cap → rejected.
-		sp.spawnTopic.publish(makeRequest("req-3", "slow", "task3"));
-		expect((sp.activeSlot.cache as ReadonlyMap<string, unknown>).size).toBe(2);
-		expect(rejections).toHaveLength(1);
-		expect(rejections[0]?.request.id).toBe("req-3");
-		expect(rejections[0]?.reason).toMatch(/depth-cap/i);
-
-		unsub();
-		hub.destroy();
-	});
-});
-
-// ---------------------------------------------------------------------------
-// Unknown presetId rejection
-// ---------------------------------------------------------------------------
-
-describe("spawnable() — unknown presetId", () => {
-	it("rejects requests with no matching preset", () => {
-		const hub = messagingHub("hub");
-		const presets = presetRegistry<AgentSpec<string, LLMResponse>>();
-		presets.put("known", { name: "known", adapter: syncAdapter("ok") });
-		const sp = spawnable<string, LLMResponse>({ hub, registry: presets });
-
-		const rejections: SpawnRejection<string>[] = [];
-		const unsub = sp.rejected.events.subscribe((msgs) => {
-			for (const m of msgs) {
-				if (m[0] === DATA) {
-					for (const r of m[1] as readonly SpawnRejection<string>[]) rejections.push(r);
-				}
-			}
-		});
-
-		sp.spawnTopic.publish(makeRequest("req-x", "ghost", "task"));
-
-		expect(rejections).toHaveLength(1);
-		expect(rejections[0]?.reason).toMatch(/unknown presetId: ghost/i);
-
-		unsub();
-		hub.destroy();
-	});
-});
-
-// ---------------------------------------------------------------------------
-// Validator rejection
-// ---------------------------------------------------------------------------
-
-describe("spawnable() — validation", () => {
-	it("does NOT replay retained spawn requests on construction (from: 'now' default)", () => {
-		const hub = messagingHub("hub");
-		// Pre-publish a spawn request BEFORE the spawnable is constructed.
-		hub
-			.topic<Message<{ presetId: string; taskInput: string }>>(SPAWNS_TOPIC)
-			.publish(makeRequest("retained-r", "p", "stale"));
-
-		const presets = presetRegistry<AgentSpec<string, LLMResponse>>();
-		presets.put("p", { name: "p", adapter: syncAdapter("ok") });
-		const sp = spawnable<string, LLMResponse>({ hub, registry: presets });
-
-		// Default `from: "now"` skips the retained "stale" request.
-		expect((sp.activeSlot.cache as ReadonlyMap<string, unknown>).size).toBe(0);
-
-		// Live publish IS processed.
-		sp.spawnTopic.publish(makeRequest("live-r", "p", "fresh"));
-		expect((sp.activeSlot.cache as ReadonlyMap<string, unknown>).size).toBe(0); // sync adapter ran + cleaned up
-		hub.destroy();
-	});
-
-	it("from: 'retained' opts in to replaying pre-construction requests", () => {
-		const hub = messagingHub("hub");
-		hub
-			.topic<Message<{ presetId: string; taskInput: string }>>(SPAWNS_TOPIC)
-			.publish(makeRequest("retained-r", "p", "stale"));
-
-		const presets = presetRegistry<AgentSpec<string, LLMResponse>>();
-		presets.put("p", { name: "p", adapter: syncAdapter("ok") });
-		const sp = spawnable<string, LLMResponse>({
-			hub,
-			registry: presets,
-			from: "retained",
-		});
-
-		// `retained` replays — the stale request was processed (sync adapter
-		// ran + cleaned up).
-		void sp;
-		hub.destroy();
-	});
-
-	it("rejects requests with invalid (non-parseable) expiresAt", () => {
-		const hub = messagingHub("hub");
-		const presets = presetRegistry<AgentSpec<string, LLMResponse>>();
-		presets.put("p", { name: "p", adapter: syncAdapter("ok") });
-		const sp = spawnable<string, LLMResponse>({ hub, registry: presets });
-
-		const rejections: SpawnRejection<string>[] = [];
-		const unsub = sp.rejected.events.subscribe((msgs) => {
-			for (const m of msgs) {
-				if (m[0] === DATA) {
-					for (const r of m[1] as readonly SpawnRejection<string>[]) rejections.push(r);
-				}
-			}
-		});
-
-		sp.spawnTopic.publish(makeRequest("req-bad-exp", "p", "task", { expiresAt: "garbage" }));
-
-		expect(rejections).toHaveLength(1);
-		expect(rejections[0]?.reason).toBe("invalid expiresAt");
-		unsub();
-		hub.destroy();
-	});
-
-	it("rejects requests failing a custom validate predicate", () => {
-		const hub = messagingHub("hub");
-		const presets = presetRegistry<AgentSpec<string, LLMResponse>>();
-		presets.put("p", { name: "p", adapter: syncAdapter("ok") });
-		const sp = spawnable<string, LLMResponse>({
-			hub,
-			registry: presets,
-			validate: (req) => req.payload.taskInput.length >= 3,
-		});
-
-		const rejections: SpawnRejection<string>[] = [];
-		const unsub = sp.rejected.events.subscribe((msgs) => {
-			for (const m of msgs) {
-				if (m[0] === DATA) {
-					for (const r of m[1] as readonly SpawnRejection<string>[]) rejections.push(r);
-				}
-			}
-		});
-
-		sp.spawnTopic.publish(makeRequest("req-short", "p", "ab")); // length 2, rejected
-		sp.spawnTopic.publish(makeRequest("req-ok", "p", "abcd")); // length 4, accepted
-
-		expect(rejections).toHaveLength(1);
-		expect(rejections[0]?.request.id).toBe("req-short");
-
-		unsub();
-		hub.destroy();
-	});
-});
-
-// ---------------------------------------------------------------------------
-// expiresAt
-// ---------------------------------------------------------------------------
-
-describe("spawnable() — expiresAt envelope", () => {
-	it("rejects requests with an expired `expiresAt`", () => {
-		const hub = messagingHub("hub");
-		const presets = presetRegistry<AgentSpec<string, LLMResponse>>();
-		presets.put("p", { name: "p", adapter: syncAdapter("ok") });
-		const sp = spawnable<string, LLMResponse>({ hub, registry: presets });
-
-		const rejections: SpawnRejection<string>[] = [];
-		const unsub = sp.rejected.events.subscribe((msgs) => {
-			for (const m of msgs) {
-				if (m[0] === DATA) {
-					for (const r of m[1] as readonly SpawnRejection<string>[]) rejections.push(r);
-				}
-			}
-		});
-
-		// expiresAt in the past.
-		sp.spawnTopic.publish(
-			makeRequest("req-expired", "p", "task", { expiresAt: "2020-01-01T00:00:00Z" }),
-		);
-
-		expect(rejections).toHaveLength(1);
-		expect(rejections[0]?.reason).toBe("expired");
-
-		unsub();
-		hub.destroy();
-	});
-
-	it("accepts requests with future `expiresAt`", () => {
-		const hub = messagingHub("hub");
-		const presets = presetRegistry<AgentSpec<string, LLMResponse>>();
-		presets.put("p", { name: "p", adapter: syncAdapter("ok") });
-		const sp = spawnable<string, LLMResponse>({ hub, registry: presets });
-
-		sp.spawnTopic.publish(
-			makeRequest("req-future", "p", "task", {
-				expiresAt: new Date(Date.now() + 60_000).toISOString(),
-			}),
-		);
-
-		// Sync adapter — the agent ran, finished, and was removed.
-		expect((sp.activeSlot.cache as ReadonlyMap<string, unknown>).size).toBe(0);
-		// No rejection.
-		expect((sp.rejected.events.cache as readonly unknown[] | undefined) ?? []).toHaveLength(0);
-		hub.destroy();
-	});
-});
-
-// ---------------------------------------------------------------------------
-// SPAWNS_TOPIC well-known name
-// ---------------------------------------------------------------------------
-
-describe("spawnable() — SPAWNS_TOPIC integration", () => {
-	it("uses the well-known SPAWNS_TOPIC on the hub", () => {
-		const hub = messagingHub("hub");
-		const presets = presetRegistry<AgentSpec<string, LLMResponse>>();
-		const sp = spawnable<string, LLMResponse>({ hub, registry: presets });
-		expect(sp.spawnTopic).toBe(hub.topic(SPAWNS_TOPIC));
-	});
-
-	it("multiple spawnable instances on the same hub use distinct names", () => {
-		const hub = messagingHub("hub");
-		const presets = presetRegistry<AgentSpec<string, LLMResponse>>();
-		presets.put("p", { name: "p", adapter: syncAdapter("ok") });
-
-		const a = spawnable<string, LLMResponse>({
-			hub,
-			registry: presets,
-			name: "alpha",
-		});
-		const b = spawnable<string, LLMResponse>({
-			hub,
-			registry: presets,
-			name: "beta",
-		});
-
-		// Both share the same SPAWNS_TOPIC (well-known).
-		expect(a.spawnTopic).toBe(b.spawnTopic);
-		// Each has its own subgraph mounted under the hub.
-		expect(a.graph).not.toBe(b.graph);
-		expect(() => hub.node("alpha::active-slot")).not.toThrow();
-		expect(() => hub.node("beta::active-slot")).not.toThrow();
-		hub.destroy();
-	});
-});
-
-// ---------------------------------------------------------------------------
-// Multi-request flow
-// ---------------------------------------------------------------------------
-
-describe("spawnable() — multi-request flow", () => {
-	it("processes a batch of spawn requests, routing each to its preset", async () => {
-		const hub = messagingHub("hub");
-		const presets = presetRegistry<AgentSpec<string, LLMResponse>>();
-		presets.put("research", { name: "r", adapter: syncAdapter("research-result") });
-		presets.put("code", { name: "c", adapter: syncAdapter("code-result") });
-		const sp = spawnable<string, LLMResponse>({ hub, registry: presets });
-
-		// Capture each completed agent's outputs (last response on bundle.out).
-		const results = new Map<string, string>();
-		sp.activeSlot.subscribe((msgs) => {
-			for (const m of msgs) {
-				if (m[0] !== DATA) continue;
-				const map = m[1] as ReadonlyMap<string, AgentBundle<string, LLMResponse>>;
-				for (const [reqId, bundle] of map) {
-					// Capture the last response synchronously when present.
-					const out = bundle.out.cache as LLMResponse | undefined;
-					if (out != null && !results.has(reqId)) {
-						results.set(reqId, out.content);
-					}
-				}
-			}
-		});
-
-		sp.spawnTopic.publish(makeRequest("req-r", "research", "topic A"));
-		sp.spawnTopic.publish(makeRequest("req-c", "code", "topic B"));
-		// Allow microtasks to flush (sync adapter still settles synchronously,
-		// but the activeSlot snapshot may need a tick to capture the in-flight
-		// bundle). Then the final assertion just checks both ran.
-		await Promise.resolve();
-		await Promise.resolve();
-
-		// Each request was processed. activeSlot ended empty (both completed).
-		expect((sp.activeSlot.cache as ReadonlyMap<string, unknown>).size).toBe(0);
-		hub.destroy();
-	});
-});
diff --git a/src/__tests__/presets/inspect/guarded-execution.test.ts b/src/__tests__/presets/inspect/guarded-execution.test.ts
deleted file mode 100644
index 8294a15b..00000000
--- a/src/__tests__/presets/inspect/guarded-execution.test.ts
+++ /dev/null
@@ -1,504 +0,0 @@
-import type { Actor } from "@graphrefly/pure-ts/core";
-import { DATA, node, type PolicyRuleData, policy } from "@graphrefly/pure-ts/core";
-import { Graph } from "@graphrefly/pure-ts/graph";
-import { describe, expect, it } from "vitest";
-import { firstValueFrom } from "../../../base/sources/settled.js";
-import {
-	type GuardedExecutionLint,
-	type GuardedScope,
-	guardedExecution,
-} from "../../../presets/inspect/guarded-execution.js";
-
-const alice: Actor = { type: "human", id: "alice" };
-const bob: Actor = { type: "human", id: "bob" };
-const llm: Actor = { type: "llm", id: "agent-1" };
-
-describe("guardedExecution — write enforcement", () => {
-	it("wraps target with policyGate and blocks disallowed writes (enforce mode default)", () => {
-		const g = new Graph("g");
-		g.add(node([], { name: "a", initial: 0 }), { name: "a" });
-		guardedExecution(g, {
-			actor: alice,
-			policies: [
-				{ effect: "allow", action: "write", actorType: "human" },
-				{ effect: "deny", action: "write", actorType: "llm" },
-			],
-		});
-
-		// Human allowed
-		g.set("a", 1, { actor: alice });
-		expect(g.node("a").cache).toBe(1);
-		// LLM denied
-		expect(() => g.set("a", 99, { actor: llm })).toThrow();
-	});
-
-	it("audit mode records violations without blocking writes", () => {
-		const g = new Graph("g");
-		g.add(node([], { name: "a", guard: () => true, initial: 0 }), { name: "a" });
-		const guarded = guardedExecution(g, {
-			actor: alice,
-			policies: [{ effect: "deny", action: "write", actorType: "llm" }],
-			mode: "audit",
-		});
-
-		g.set("a", 42, { actor: llm });
-		// Write succeeded (audit mode)
-		expect(g.node("a").cache).toBe(42);
-		// Violation recorded
-		const violations = guarded.enforcer.all();
-		expect(violations).toHaveLength(1);
-		expect(violations[0]?.actor.type).toBe("llm");
-		expect(violations[0]?.result).toBe("observed");
-	});
-
-	it("policies can be a live Node for runtime updates", () => {
-		const g = new Graph("g");
-		g.add(node([], { name: "a", initial: 0 }), { name: "a" });
-		const policies = node<readonly PolicyRuleData[]>([], {
-			initial: [{ effect: "allow", action: "write" }],
-		});
-
-		guardedExecution(g, { actor: alice, policies });
-
-		// Initially allowed
-		g.set("a", 1, { actor: alice });
-
-		// Tighten: deny all
-		policies.emit([{ effect: "deny", action: "write" }]);
-		expect(() => g.set("a", 2, { actor: alice })).toThrow();
-	});
-
-	it("violations topic is exposed and composable", () => {
-		const g = new Graph("g");
-		g.add(node([], { name: "a", guard: () => true, initial: 0 }), { name: "a" });
-		const guarded = guardedExecution(g, {
-			actor: alice,
-			policies: [{ effect: "deny", action: "write" }],
-			mode: "audit",
-		});
-
-		g.set("a", 1, { actor: alice });
-		expect(guarded.violations.retained()).toHaveLength(1);
-	});
-
-	it("transitive dynamic coverage — nodes added to an already-mounted child are guarded", () => {
-		const g = new Graph("g");
-		const child = new Graph("child");
-		g.mount("kids", child); // BEFORE guardedExecution is built
-		guardedExecution(g, {
-			actor: alice,
-			policies: [{ effect: "deny", action: "write" }],
-		});
-
-		child.add(node([], { name: "x", initial: 0 }), { name: "x" });
-		expect(() => g.set("kids::x", 1, { actor: alice })).toThrow();
-	});
-
-	it("exposes .target escape hatch", () => {
-		const g = new Graph("g");
-		const guarded = guardedExecution(g, {
-			actor: alice,
-			policies: [] as readonly PolicyRuleData[],
-			mode: "audit",
-		});
-		expect(guarded.target).toBe(g);
-	});
-});
-
-describe("guardedExecution — scopedDescribe (mounted property — qa G1A)", () => {
-	it("exposes a single canonical reactive describe Node bound to the configured actor", async () => {
-		const g = new Graph("g");
-		const onlyAlice = policy((allow) => {
-			allow("observe", { where: (a) => a.id === "alice" });
-		});
-		g.add(node([], { name: "alice-only", guard: onlyAlice, initial: 0 }), { name: "alice-only" });
-		g.add(node([], { name: "public", initial: 1 }), { name: "public" });
-
-		const guarded = guardedExecution(g, {
-			actor: alice,
-			policies: [] as readonly PolicyRuleData[],
-			mode: "audit",
-		});
-
-		const view = await firstValueFrom(guarded.scopedDescribe);
-		expect(Object.keys(view.nodes).sort()).toEqual(["alice-only", "public"]);
-	});
-
-	it("re-derives when the actor Node emits a new identity (same instance, no per-call leak)", () => {
-		const g = new Graph("g");
-		const onlyAlice = policy((allow) => {
-			allow("observe", { where: (a) => a.id === "alice" });
-		});
-		g.add(node([], { name: "alice-only", guard: onlyAlice, initial: 0 }), { name: "alice-only" });
-		g.add(node([], { name: "public", initial: 1 }), { name: "public" });
-
-		const actorNode = node<Actor>([], { name: "current-actor", initial: alice });
-		const guarded = guardedExecution(g, {
-			actor: actorNode,
-			policies: [] as readonly PolicyRuleData[],
-			mode: "audit",
-		});
-
-		const seen: string[][] = [];
-		guarded.scopedDescribe.subscribe((msgs) => {
-			for (const m of msgs) {
-				if (m[0] === DATA) seen.push(Object.keys((m[1] as { nodes: object }).nodes).sort());
-			}
-		});
-
-		expect(seen.at(-1)).toEqual(["alice-only", "public"]);
-
-		actorNode.emit(bob);
-		expect(seen.at(-1)).toEqual(["public"]);
-	});
-
-	it("accepts a `Node<Actor | null>` actor without a cast (F8 type-honesty)", () => {
-		const g = new Graph("g");
-		const onlyAlice = policy((allow) => {
-			allow("observe", { where: (a) => a.id === "alice" });
-		});
-		g.add(node([], { name: "alice-only", guard: onlyAlice, initial: 0 }), { name: "alice-only" });
-		g.add(node([], { name: "public", initial: 1 }), { name: "public" });
-
-		// Explicitly `Node<Actor | null>` — pre-F8 this required an
-		// `as Node<Actor>` cast inside guardedExecution; the widened
-		// `GraphDescribeOptions.actor` now accepts it directly.
-		const actorNode = node<Actor | null>([], { name: "current-actor", initial: null });
-		const guarded = guardedExecution(g, {
-			actor: actorNode,
-			policies: [] as readonly PolicyRuleData[],
-			mode: "audit",
-		});
-
-		const seen: string[][] = [];
-		guarded.scopedDescribe.subscribe((msgs) => {
-			for (const m of msgs) {
-				if (m[0] === DATA) seen.push(Object.keys((m[1] as { nodes: object }).nodes).sort());
-			}
-		});
-
-		// `null` cache → no scoping → full visibility (resolveActorOption
-		// maps null/undefined to undefined).
-		expect(seen.at(-1)).toEqual(["alice-only", "public"]);
-		// A real actor scopes it; `null` again unscopes — round-trips cleanly.
-		actorNode.emit(alice);
-		expect(seen.at(-1)).toEqual(["alice-only", "public"]);
-		actorNode.emit(bob);
-		expect(seen.at(-1)).toEqual(["public"]);
-		actorNode.emit(null);
-		expect(seen.at(-1)).toEqual(["alice-only", "public"]);
-	});
-
-	it("scopedDescribe appears in wrapper.describe() as a mounted node", () => {
-		const g = new Graph("g");
-		g.add(node([], { name: "a", initial: 0 }), { name: "a" });
-		const guarded = guardedExecution(g, {
-			actor: alice,
-			policies: [{ effect: "allow", action: "*" }],
-		});
-		const desc = guarded.describe();
-		expect(desc.nodes.scopedDescribe).toBeDefined();
-	});
-});
-
-describe("guardedExecution — scopedDescribeNode (per-call escape hatch)", () => {
-	it("scopes the describe to the configured default actor (live Node)", async () => {
-		const g = new Graph("g");
-		const onlyAlice = policy((allow) => {
-			allow("observe", { where: (a) => a.id === "alice" });
-		});
-		g.add(node([], { name: "alice-only", guard: onlyAlice, initial: 0 }), { name: "alice-only" });
-		g.add(node([], { name: "public", initial: 1 }), { name: "public" });
-
-		// Audit mode: no extra guards stacked, so per-node guard alone gates visibility.
-		const guarded = guardedExecution(g, {
-			actor: alice,
-			policies: [] as readonly PolicyRuleData[],
-			mode: "audit",
-		});
-
-		const view = guarded.scopedDescribeNode();
-		try {
-			const initial = await firstValueFrom(view.node);
-			expect(Object.keys(initial.nodes).sort()).toEqual(["alice-only", "public"]);
-		} finally {
-			view.dispose();
-		}
-	});
-
-	it("re-derives when the actor Node emits a new identity", () => {
-		const g = new Graph("g");
-		const onlyAlice = policy((allow) => {
-			allow("observe", { where: (a) => a.id === "alice" });
-		});
-		g.add(node([], { name: "alice-only", guard: onlyAlice, initial: 0 }), { name: "alice-only" });
-		g.add(node([], { name: "public", initial: 1 }), { name: "public" });
-
-		const actorNode = node<Actor>([], { name: "current-actor", initial: alice });
-		const guarded = guardedExecution(g, {
-			actor: actorNode,
-			policies: [] as readonly PolicyRuleData[],
-			mode: "audit",
-		});
-
-		const view = guarded.scopedDescribeNode();
-		try {
-			const seen: string[][] = [];
-			view.node.subscribe((msgs) => {
-				for (const m of msgs) {
-					if (m[0] === DATA) seen.push(Object.keys((m[1] as { nodes: object }).nodes).sort());
-				}
-			});
-
-			// Alice sees both
-			expect(seen.at(-1)).toEqual(["alice-only", "public"]);
-
-			// Switch to bob — alice-only hides
-			actorNode.emit(bob);
-			expect(seen.at(-1)).toEqual(["public"]);
-		} finally {
-			view.dispose();
-		}
-	});
-
-	it("per-call actor override takes precedence", () => {
-		const g = new Graph("g");
-		const onlyAlice = policy((allow) => {
-			allow("observe", { where: (a) => a.id === "alice" });
-		});
-		g.add(node([], { name: "alice-only", guard: onlyAlice, initial: 0 }), { name: "alice-only" });
-		g.add(node([], { name: "public", initial: 1 }), { name: "public" });
-
-		const guarded = guardedExecution(g, {
-			actor: alice,
-			policies: [] as readonly PolicyRuleData[],
-			mode: "audit",
-		});
-
-		const bobView = guarded.scopedDescribeNode(bob);
-		try {
-			const seen: string[][] = [];
-			bobView.node.subscribe((msgs) => {
-				for (const m of msgs) {
-					if (m[0] === DATA) seen.push(Object.keys((m[1] as { nodes: object }).nodes).sort());
-				}
-			});
-			expect(seen.at(-1)).toEqual(["public"]);
-		} finally {
-			bobView.dispose();
-		}
-	});
-
-	it("passes through detail option to the target describe", async () => {
-		const g = new Graph("g");
-		g.add(node([], { name: "a", initial: 0 }), { name: "a" });
-		const guarded = guardedExecution(g, {
-			actor: alice,
-			policies: [{ effect: "allow", action: "*" }],
-		});
-
-		const minView = guarded.scopedDescribeNode(undefined, { detail: "minimal" });
-		const stdView = guarded.scopedDescribeNode(undefined, { detail: "standard" });
-		try {
-			const minimal = await firstValueFrom(minView.node);
-			const standard = await firstValueFrom(stdView.node);
-			const minKeys = Object.keys(minimal.nodes.a ?? {}).length;
-			const stdKeys = Object.keys(standard.nodes.a ?? {}).length;
-			expect(stdKeys).toBeGreaterThanOrEqual(minKeys);
-		} finally {
-			minView.dispose();
-			stdView.dispose();
-		}
-	});
-
-	it("dispose() is idempotent", () => {
-		const g = new Graph("g");
-		g.add(node([], { name: "a", initial: 0 }), { name: "a" });
-		const guarded = guardedExecution(g, {
-			actor: alice,
-			policies: [{ effect: "allow", action: "*" }],
-		});
-		const view = guarded.scopedDescribeNode();
-		expect(() => {
-			view.dispose();
-			view.dispose();
-		}).not.toThrow();
-	});
-});
-
-describe("guardedExecution — lints", () => {
-	it("throws RangeError on static empty policies in enforce mode", () => {
-		const g = new Graph("g");
-		expect(() =>
-			guardedExecution(g, {
-				actor: alice,
-				policies: [] as readonly PolicyRuleData[],
-				mode: "enforce",
-			}),
-		).toThrow(RangeError);
-	});
-
-	it("emits one-time empty-policies lint when a Node emits empty in enforce mode", () => {
-		const g = new Graph("g");
-		g.add(node([], { name: "a", initial: 0 }), { name: "a" });
-		const policies = node<readonly PolicyRuleData[]>([], {
-			initial: [{ effect: "allow", action: "*" }],
-		});
-		const guarded = guardedExecution(g, { actor: alice, policies, mode: "enforce" });
-
-		expect(guarded.lints.retained()).toHaveLength(0);
-
-		policies.emit([]);
-		const lints = guarded.lints.retained();
-		expect(lints).toHaveLength(1);
-		expect(lints[0]?.kind).toBe("empty-policies");
-
-		// Re-emit empty — lint is one-time-per-instance.
-		policies.emit([]);
-		expect(guarded.lints.retained()).toHaveLength(1);
-	});
-
-	it("tolerates empty policies in audit mode", () => {
-		const g = new Graph("g");
-		g.add(node([], { name: "a", guard: () => true, initial: 0 }), { name: "a" });
-		expect(() =>
-			guardedExecution(g, {
-				actor: alice,
-				policies: [] as readonly PolicyRuleData[],
-				mode: "audit",
-			}),
-		).not.toThrow();
-	});
-
-	it("emits audit-no-effect lint when audit mode + target has no per-node guards", () => {
-		const g = new Graph("g");
-		g.add(node([], { name: "a", initial: 0 }), { name: "a" }); // no guard
-		const guarded = guardedExecution(g, {
-			actor: alice,
-			policies: [{ effect: "deny", action: "write" }],
-			mode: "audit",
-		});
-		const lints = guarded.lints.retained();
-		expect(lints.some((l: GuardedExecutionLint) => l.kind === "audit-no-effect")).toBe(true);
-	});
-
-	it("does NOT emit audit-no-effect when target has per-node guards", () => {
-		const g = new Graph("g");
-		g.add(node([], { name: "a", guard: () => true, initial: 0 }), { name: "a" });
-		const guarded = guardedExecution(g, {
-			actor: alice,
-			policies: [{ effect: "deny", action: "write" }],
-			mode: "audit",
-		});
-		const lints = guarded.lints.retained();
-		expect(lints.some((l: GuardedExecutionLint) => l.kind === "audit-no-effect")).toBe(false);
-	});
-
-	it("emits no-actor lint when actor is omitted from configuration", () => {
-		const g = new Graph("g");
-		g.add(node([], { name: "a", initial: 0 }), { name: "a" });
-		const guarded = guardedExecution(g, {
-			policies: [{ effect: "allow", action: "*" }],
-		});
-		const lints = guarded.lints.retained();
-		expect(lints.some((l: GuardedExecutionLint) => l.kind === "no-actor")).toBe(true);
-	});
-});
-
-describe("guardedExecution — scope derived", () => {
-	it("publishes the configuration tuple and re-emits when policies update", () => {
-		const g = new Graph("g");
-		g.add(node([], { name: "a", initial: 0 }), { name: "a" });
-		const policies = node<readonly PolicyRuleData[]>([], {
-			initial: [{ effect: "allow", action: "*" }],
-		});
-		const guarded = guardedExecution(g, {
-			actor: alice,
-			policies,
-			mode: "enforce",
-		});
-
-		const seen: GuardedScope[] = [];
-		guarded.scope.subscribe((msgs) => {
-			for (const m of msgs) {
-				if (m[0] === DATA) seen.push(m[1] as GuardedScope);
-			}
-		});
-
-		const first = seen.at(-1)!;
-		expect(first.actor).toEqual(alice);
-		expect(first.mode).toBe("enforce");
-		expect(first.policiesCount).toBe(1);
-
-		policies.emit([
-			{ effect: "allow", action: "read" },
-			{ effect: "deny", action: "write" },
-		]);
-		expect(seen.at(-1)?.policiesCount).toBe(2);
-	});
-
-	it("scope.actor is null when no actor is configured", () => {
-		const g = new Graph("g");
-		g.add(node([], { name: "a", initial: 0 }), { name: "a" });
-		const guarded = guardedExecution(g, {
-			policies: [{ effect: "allow", action: "*" }],
-		});
-
-		const seen: GuardedScope[] = [];
-		guarded.scope.subscribe((msgs) => {
-			for (const m of msgs) {
-				if (m[0] === DATA) seen.push(m[1] as GuardedScope);
-			}
-		});
-		expect(seen.at(-1)?.actor).toBeNull();
-	});
-
-	it("scope fires even when caller-supplied Node<Actor> hasn't emitted yet (qa G1B SENTINEL bridge)", () => {
-		// Reproduces EC2: a producer-style actor Node with sentinel cache used to
-		// stall `scope`'s first-run gate. The internal bridge derived now seeds
-		// `null` so `scope` activates immediately; the actor Node forwards real
-		// Actor values once it emits.
-		const g = new Graph("g");
-		g.add(node([], { name: "a", initial: 0 }), { name: "a" });
-		// Sentinel actor — emits no DATA until we explicitly trigger.
-		const actorSentinel = node<Actor>([], {
-			name: "sentinel-actor",
-			initial: undefined as unknown as Actor,
-		});
-		const guarded = guardedExecution(g, {
-			actor: actorSentinel,
-			policies: [{ effect: "allow", action: "*" }],
-			mode: "audit",
-		});
-
-		const seen: GuardedScope[] = [];
-		guarded.scope.subscribe((msgs) => {
-			for (const m of msgs) {
-				if (m[0] === DATA) seen.push(m[1] as GuardedScope);
-			}
-		});
-
-		// Before the actor Node ever emits, scope already shows actor=null.
-		expect(seen.length).toBeGreaterThan(0);
-		expect(seen.at(-1)?.actor).toBeNull();
-
-		// Once the actor Node emits a real Actor, the bridge forwards it.
-		actorSentinel.emit(alice);
-		expect(seen.at(-1)?.actor).toEqual(alice);
-	});
-});
-
-describe("guardedExecution — domainMeta tagging", () => {
-	it("tags the scope derived with guarded_type metadata", () => {
-		const g = new Graph("g");
-		g.add(node([], { name: "a", initial: 0 }), { name: "a" });
-		const guarded = guardedExecution(g, {
-			actor: alice,
-			policies: [{ effect: "allow", action: "*" }],
-		});
-		const described = guarded.describe({ detail: "standard" });
-		const scopeNode = described.nodes.scope;
-		expect(scopeNode?.meta?.guarded).toBe(true);
-		expect(scopeNode?.meta?.guarded_type).toBe("scope");
-	});
-});
diff --git a/src/__tests__/presets/inspect/inspect-preset.test.ts b/src/__tests__/presets/inspect/inspect-preset.test.ts
deleted file mode 100644
index a110edf6..00000000
--- a/src/__tests__/presets/inspect/inspect-preset.test.ts
+++ /dev/null
@@ -1,187 +0,0 @@
-import { DATA, node } from "@graphrefly/pure-ts/core";
-import { Graph } from "@graphrefly/pure-ts/graph";
-import { describe, expect, it } from "vitest";
-import { InspectGraph, inspect } from "../../../presets/inspect/index.js";
-
-describe("inspect() preset (Tier 9.1 γ-form γ-II + Q5-6 medium scope)", () => {
-	it("returns an InspectGraph subclass", () => {
-		const target = new Graph("target");
-		target.add(node([], { name: "a", initial: 1 }), { name: "a" });
-		const view = inspect(target);
-		expect(view).toBeInstanceOf(InspectGraph);
-		expect(view).toBeInstanceOf(Graph);
-		view.destroy();
-	});
-
-	it("exposes lens nodes via `view.lens.*` (lens lives in a `lens::*` mounted subgraph)", () => {
-		const target = new Graph("target");
-		target.add(node([], { name: "a", initial: 1 }), { name: "a" });
-		const view = inspect(target);
-		const desc = view.describe({ detail: "minimal" });
-		// D1 (qa lock): lens lives under a child mount, so lens paths are
-		// qualified with `lens::*`. Avoids `Graph.topology` accessor collision.
-		expect(Object.keys(desc.nodes)).toEqual(
-			expect.arrayContaining(["lens::topology", "lens::health", "lens::flow"]),
-		);
-		expect(typeof view.lens.topology.subscribe).toBe("function");
-		expect(typeof view.lens.health.subscribe).toBe("function");
-		expect(typeof view.lens.flow.subscribe).toBe("function");
-		view.destroy();
-	});
-
-	it("exposes target reference + lens view + audit subgraph", () => {
-		const target = new Graph("target");
-		target.add(node([], { name: "a", initial: 1 }), { name: "a" });
-		const view = inspect(target);
-		expect(view.target).toBe(target);
-		expect(view.audit).toBeDefined();
-		view.destroy();
-	});
-
-	it("explainTarget delegates to target.explain (static form)", () => {
-		const target = new Graph("target");
-		const a = node([], { name: "a", initial: 1 });
-		const b = node(
-			[a],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as number) * 2);
-			},
-			{ describeKind: "derived", name: "b" },
-		);
-		target.add(a, { name: "a" });
-		target.add(b, { name: "b" });
-
-		const view = inspect(target);
-		const chain = view.explainTarget("a", "b");
-		expect(chain.found).toBe(true);
-		expect(chain.steps.length).toBeGreaterThan(0);
-		view.destroy();
-	});
-
-	it("explainTarget reactive form returns {node, dispose} that tears down cleanly (A4 qa)", () => {
-		const target = new Graph("target");
-		const a = node([], { name: "a", initial: 1 });
-		const b = node(
-			[a],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as number) * 2);
-			},
-			{ describeKind: "derived", name: "b" },
-		);
-		target.add(a, { name: "a" });
-		target.add(b, { name: "b" });
-
-		const view = inspect(target);
-		const result = view.explainTarget("a", "b", { reactive: true });
-		expect(result).toHaveProperty("node");
-		expect(result).toHaveProperty("dispose");
-		expect(typeof result.dispose).toBe("function");
-		// Subscribe + dispose chain doesn't throw.
-		const unsub = result.node.subscribe(() => undefined);
-		unsub();
-		result.dispose();
-		view.destroy();
-	});
-
-	it("complianceSnapshot pairs the target's persisted state with the audit log", () => {
-		const target = new Graph("target");
-		target.add(node([], { name: "a", initial: 42 }), { name: "a" });
-		const view = inspect(target, { actor: { id: "ops", role: "auditor" } });
-		const snap = view.complianceSnapshot();
-		expect(snap.format_version).toBe(1);
-		expect(snap.graph).toBeDefined();
-		expect(snap.audit).toBeDefined();
-		expect(snap.actor).toEqual({ id: "ops", role: "auditor" });
-		expect(typeof snap.fingerprint).toBe("string");
-		view.destroy();
-	});
-
-	it("mounts the auditTrail subgraph under `audit::*`", () => {
-		const target = new Graph("target");
-		target.add(node([], { name: "a", initial: 1 }), { name: "a" });
-		const view = inspect(target);
-		const desc = view.describe({ detail: "minimal" });
-		// Mounted child paths appear with the mount prefix.
-		const auditPaths = Object.keys(desc.nodes).filter((p) => p.startsWith("audit::"));
-		expect(auditPaths.length).toBeGreaterThan(0);
-		view.destroy();
-	});
-
-	it("self-tags via tagFactory (A1 qa) — `describe().factory === 'inspect'`", () => {
-		const target = new Graph("target");
-		target.add(node([], { name: "a", initial: 1 }), { name: "a" });
-		const view = inspect(target);
-		const desc = view.describe({ detail: "spec" });
-		expect(desc.factory).toBe("inspect");
-		view.destroy();
-	});
-
-	it("`inspect.topology` (base Graph accessor) is distinct from `inspect.lens.topology` (A4 qa disambiguation)", () => {
-		// A4 (qa): the base `Graph.topology` accessor returns
-		// `Node<TopologyEvent>` (mount/unmount stream of THIS graph), NOT the
-		// describe snapshot. `inspect.lens.topology` is `Node<GraphDescribeOutput>`
-		// (the wrapped target's describe). They MUST be different objects.
-		const target = new Graph("target");
-		target.add(node([], { name: "a", initial: 1 }), { name: "a" });
-		const view = inspect(target);
-		expect(view.topology).not.toBe(view.lens.topology);
-		view.destroy();
-	});
-
-	it("`view.destroy()` does not invalidate externally-held lens-node subscriptions before lens.dispose() runs (D1 qa regression)", () => {
-		// D1 regression: lens lives in a child mount, so `view.destroy()`'s
-		// signal cascade reaches the lens nodes via `_destroyClearOnly` (no
-		// TEARDOWN broadcast) rather than via `_signalDeliver` over the
-		// inspect graph's own `_nodes`. The lens nodes themselves are NOT
-		// directly registered under inspect's path table.
-		const target = new Graph("target");
-		const a = node([], { name: "a", initial: 1 });
-		target.add(a, { name: "a" });
-		const view = inspect(target);
-
-		// Verify the lens nodes are reachable through the mounted child path
-		// and NOT through the inspect graph's own `_nodes`.
-		expect(() => view.resolve("lens::topology")).not.toThrow();
-		// The unqualified names "topology" / "health" / "flow" should NOT
-		// resolve at the inspect-graph root because they live under the
-		// lens mount.
-		expect(() => view.resolve("topology")).toThrow();
-		expect(() => view.resolve("health")).toThrow();
-		expect(() => view.resolve("flow")).toThrow();
-		view.destroy();
-	});
-
-	it("constructor-time lens topology emit reflects the WRAPPED target's structure, not inspect's own (A4 qa)", () => {
-		// Confirms the lens always observes the target graph, NEVER the
-		// inspect wrapper itself.
-		const target = new Graph("target");
-		const a = node([], { name: "a", initial: 1 });
-		target.add(a, { name: "a" });
-		const view = inspect(target);
-
-		let lastTopology: unknown;
-		const unsub = view.lens.topology.subscribe((msgs) => {
-			for (const m of msgs) {
-				if (m[0] === DATA) lastTopology = m[1];
-			}
-		});
-
-		// The lens describes the TARGET, so node "a" appears.
-		expect(lastTopology).toBeDefined();
-		const topo = lastTopology as { nodes: Record<string, unknown> };
-		expect(topo.nodes).toHaveProperty("a");
-		// "audit::*" paths (which exist on `view`, NOT on `target`) do NOT
-		// appear in the lens topology.
-		const targetPaths = Object.keys(topo.nodes);
-		expect(targetPaths.some((p) => p.startsWith("audit::"))).toBe(false);
-
-		unsub();
-		view.destroy();
-	});
-});
diff --git a/src/__tests__/presets/resilience/resilient-pipeline.test.ts b/src/__tests__/presets/resilience/resilient-pipeline.test.ts
deleted file mode 100644
index 5ae60200..00000000
--- a/src/__tests__/presets/resilience/resilient-pipeline.test.ts
+++ /dev/null
@@ -1,356 +0,0 @@
-import {
-	DATA,
-	describeNode,
-	ERROR,
-	type NodeActions,
-	type NodeFn,
-	node,
-} from "@graphrefly/pure-ts/core";
-import { describe, expect, it } from "vitest";
-import { NS_PER_MS, NS_PER_SEC } from "../../../base/resilience/backoff.js";
-import {
-	ResilientPipelineGraph,
-	type ResilientPipelineOptions,
-	resilientPipeline,
-} from "../../../presets/resilience/resilient-pipeline.js";
-
-function collect<T>(n: { subscribe: (fn: (msgs: unknown[][]) => void) => () => void }): {
-	events: T[];
-	errors: unknown[];
-	stop: () => void;
-} {
-	const events: T[] = [];
-	const errors: unknown[] = [];
-	const off = n.subscribe((msgs) => {
-		for (const m of msgs) {
-			if (m[0] === DATA) events.push(m[1] as T);
-			else if (m[0] === ERROR) errors.push(m[1]);
-		}
-	});
-	return { events, errors, stop: off };
-}
-
-describe("resilientPipeline — basic shape", () => {
-	it("returns a ResilientPipelineGraph subclass", () => {
-		const src = node([], { initial: 0 });
-		const pipeline = resilientPipeline(src);
-		expect(pipeline).toBeInstanceOf(ResilientPipelineGraph);
-		expect(typeof pipeline.describe).toBe("function");
-		expect(typeof pipeline.output.subscribe).toBe("function");
-	});
-
-	it("degenerate case: no options — source passes through via withStatus only", () => {
-		const src = node([], { initial: 0 });
-		const pipeline = resilientPipeline(src);
-		const { events, stop } = collect<number>(pipeline.output);
-		src.emit(1);
-		src.emit(2);
-		expect(events).toEqual([0, 1, 2]);
-		expect(pipeline.status.cache).toBe("running");
-		expect(pipeline.lastError.cache).toBe(null);
-		expect(pipeline.breakerState).toBeUndefined();
-		expect(pipeline.droppedCount).toBeUndefined();
-		stop();
-	});
-
-	it("breaker option: exposes breakerState in the graph + describe surface", () => {
-		const src = node([], { initial: 0 });
-		const pipeline = resilientPipeline(src, {
-			breaker: { failureThreshold: 2 },
-		});
-		// Activate
-		pipeline.output.subscribe(() => {});
-		expect(pipeline.breakerState).toBeDefined();
-		expect((pipeline.breakerState?.cache as { status: string } | undefined)?.status).toBe("closed");
-
-		const desc = pipeline.describe();
-		expect(desc.nodes.breakerWrapped).toBeDefined();
-		expect(desc.nodes.breakerState).toBeDefined();
-	});
-
-	it("rateLimit option: exposes droppedCount + rateLimitState companions", () => {
-		const src = node([], { initial: 0 });
-		const pipeline = resilientPipeline(src, {
-			rateLimit: { maxEvents: 10, windowNs: NS_PER_SEC, maxBuffer: 100 },
-		});
-		pipeline.output.subscribe(() => {});
-		expect(pipeline.droppedCount).toBeDefined();
-		expect(pipeline.droppedCount?.cache).toBe(0);
-
-		expect(pipeline.rateLimitState).toBeDefined();
-		const stateCache = pipeline.rateLimitState?.cache as
-			| { droppedCount: number; pendingCount: number; paused: boolean }
-			| undefined;
-		expect(stateCache?.droppedCount).toBe(0);
-		expect(stateCache?.pendingCount).toBe(0);
-		expect(stateCache?.paused).toBe(false);
-
-		const desc = pipeline.describe();
-		expect(desc.nodes.rateLimited).toBeDefined();
-		expect(desc.nodes.droppedCount).toBeDefined();
-		expect(desc.nodes.rateLimitState).toBeDefined();
-	});
-});
-
-describe("resilientPipeline — domain meta tagging (D8)", () => {
-	it("each layer carries domainMeta('resilient', kind) on its produced node", () => {
-		const src = node([], { initial: 0 });
-		const allowed = node([], { initial: true });
-		const pipeline = resilientPipeline(src, {
-			rateLimit: { maxEvents: 10, windowNs: NS_PER_SEC, maxBuffer: 100 },
-			budget: [{ node: allowed, check: (v) => v === true }],
-			breaker: { failureThreshold: 5 },
-			timeoutMs: 5_000,
-			retry: { count: 2 },
-			fallback: -1,
-		});
-		pipeline.output.subscribe(() => {});
-
-		const desc = pipeline.describe({ detail: "standard" });
-		// Each layer's intermediate carries `resilient: true` + `resilient_type: <kind>`.
-		const expectations: Array<[string, string]> = [
-			["rateLimited", "rate-limit"],
-			["breakerWrapped", "breaker"],
-			["timeoutWrapped", "timeout"],
-			["retryWrapped", "retry"],
-			["fallbackWrapped", "fallback"],
-			["output", "status"],
-		];
-		for (const [path, kind] of expectations) {
-			const meta = desc.nodes[path]?.meta;
-			expect(meta?.resilient, `${path}: meta.resilient`).toBe(true);
-			expect(meta?.resilient_type, `${path}: meta.resilient_type`).toBe(kind);
-		}
-		// `budgetGate` already integrates domain meta via `domainMeta("resilience", "budget_gate", opts?.meta)`
-		// — caller meta nests in there. Confirm the budget node still surfaces `resilience_type` from the
-		// primitive's own tag (not overridden by our pass-through), then check that our `resilient` tag
-		// rides through as part of the merged meta object.
-		const budgetMeta = desc.nodes.budgetGated?.meta;
-		expect(budgetMeta).toBeDefined();
-		// Caller-supplied keys are merged via `domainMeta(domain, kind, extra)` so the
-		// resilient tag is preserved alongside the primitive's resilience_type.
-		expect(budgetMeta?.resilient).toBe(true);
-		expect(budgetMeta?.resilient_type).toBe("budget");
-	});
-});
-
-describe("resilientPipeline — layer behavior", () => {
-	it("timeoutMs throws on non-positive value", () => {
-		const src = node([], { initial: 0 });
-		expect(() => resilientPipeline(src, { timeoutMs: 0 })).toThrow(/timeoutMs must be > 0/);
-		expect(() => resilientPipeline(src, { timeoutMs: -1 })).toThrow(/timeoutMs must be > 0/);
-	});
-
-	it("timeoutMs throws on overflow risk (> 9_000_000 ms)", () => {
-		const src = node([], { initial: 0 });
-		expect(() => resilientPipeline(src, { timeoutMs: 9_000_001 })).toThrow(/9_000_000/);
-	});
-
-	it("rateLimit layer: permits through when under limit", () => {
-		const src = node([], { initial: 0 });
-		const pipeline = resilientPipeline(src, {
-			// F-B-root: value-form maxBuffer is required; Infinity = explicit unbounded.
-			rateLimit: { maxEvents: 10, windowNs: NS_PER_SEC, maxBuffer: Number.POSITIVE_INFINITY },
-		});
-		const { events, stop } = collect<number>(pipeline.output);
-		src.emit(1);
-		src.emit(2);
-		expect(events).toEqual([0, 1, 2]);
-		stop();
-	});
-
-	// F-B-class smell sweep (2026-05-18) — F-B-root: the value-form rateLimit
-	// no longer silently injects `maxBuffer: Infinity`; both forms are
-	// fail-loud (D4) via the rateLimiter primitive's validation.
-	it("F-B-root: value-form rateLimit omitting maxBuffer throws (no silent ?? Infinity)", () => {
-		const src = node([], { initial: 0 });
-		expect(() =>
-			resilientPipeline(src, {
-				rateLimit: { maxEvents: 10, windowNs: NS_PER_SEC } as never,
-			}),
-		).toThrow(/maxBuffer/);
-	});
-
-	it("F-B-root: value-form rateLimit with explicit maxBuffer: Infinity opts into unbounded", () => {
-		const src = node([], { initial: 0 });
-		expect(() =>
-			resilientPipeline(src, {
-				rateLimit: {
-					maxEvents: 10,
-					windowNs: NS_PER_SEC,
-					maxBuffer: Number.POSITIVE_INFINITY,
-				},
-			}),
-		).not.toThrow();
-	});
-
-	it("fallback layer: replaces terminal ERROR with fallback value", async () => {
-		const errorFn: NodeFn = (_data, a: NodeActions) => {
-			a.down([[ERROR, new Error("boom")]]);
-			return undefined;
-		};
-		const src = node<number>([], errorFn, {
-			describeKind: "producer",
-			initial: 0,
-			resubscribable: true,
-		});
-		const pipeline = resilientPipeline(src, { fallback: 99 });
-		const { events, errors, stop } = collect<number>(pipeline.output);
-		await new Promise((r) => setTimeout(r, 5));
-		expect(events.at(-1)).toBe(99);
-		expect(errors).toEqual([]);
-		stop();
-	});
-
-	it("withStatus reports status transitions through the pipeline", () => {
-		const src = node([], { initial: 0 });
-		const pipeline = resilientPipeline(src, { initialStatus: "pending" });
-		pipeline.output.subscribe(() => {});
-		expect(pipeline.status.cache).toBe("running");
-		expect(pipeline.lastError.cache).toBe(null);
-	});
-
-	it("composition order preserved: all layers chain without type errors", () => {
-		const src = node([], { initial: 0 });
-		const maxBudget = node([], { initial: 100 });
-		const opts: ResilientPipelineOptions<number> = {
-			rateLimit: { maxEvents: 10, windowNs: NS_PER_SEC, maxBuffer: Number.POSITIVE_INFINITY },
-			budget: [{ node: maxBudget, check: (v) => (v as number) > 0 }],
-			breaker: { failureThreshold: 5 },
-			retry: { count: 2 },
-			timeoutMs: 5_000,
-			fallback: -1,
-		};
-		const pipeline = resilientPipeline(src, opts);
-		pipeline.output.subscribe(() => {});
-		expect(pipeline.status.cache).toBeDefined();
-		expect(pipeline.lastError.cache).toBe(null);
-		expect((pipeline.breakerState?.cache as { status: string } | undefined)?.status).toBe("closed");
-		expect(pipeline.droppedCount?.cache).toBe(0);
-
-		// All intermediates are mounted — describe surfaces the full chain.
-		const desc = pipeline.describe();
-		expect(desc.nodes.rateLimited).toBeDefined();
-		expect(desc.nodes.budgetGated).toBeDefined();
-		expect(desc.nodes.breakerWrapped).toBeDefined();
-		expect(desc.nodes.timeoutWrapped).toBeDefined();
-		expect(desc.nodes.retryWrapped).toBeDefined();
-		expect(desc.nodes.fallbackWrapped).toBeDefined();
-	});
-
-	it("budget option: blocks DATA when constraint fails", () => {
-		const src = node([], { initial: 0 });
-		const allowed = node([], { initial: true });
-		const pipeline = resilientPipeline(src, {
-			budget: [{ node: allowed, check: (v) => v === true }],
-		});
-		const { events, stop } = collect<number>(pipeline.output);
-		src.emit(1);
-		expect(events.at(-1)).toBe(1);
-		allowed.emit(false);
-		src.emit(2); // should be buffered
-		expect(events.at(-1)).toBe(1);
-		allowed.emit(true);
-		expect(events.at(-1)).toBe(2);
-		stop();
-	});
-});
-
-describe("resilientPipeline — reactive options (switchMap rebuild — qa G1C-prime)", () => {
-	it("accepts a Node<RateLimiterOptions>; DS-13.5.B forwards Node directly (no switchMap rebuild)", () => {
-		const src = node([], { resubscribable: true, initial: 0 });
-		const rateOpts = node([], { initial: { maxEvents: 10, windowNs: NS_PER_SEC, maxBuffer: 100 } });
-		const pipeline = resilientPipeline(src, { rateLimit: rateOpts });
-		pipeline.output.subscribe(() => {});
-		// Layer mounted.
-		expect(pipeline.describe().nodes.rateLimited).toBeDefined();
-		// DS-13.5.B forwarding contract: companions ARE exposed in reactive
-		// mode now that the primitive's internal state is preserved across
-		// opts swaps (no per-rebuild instances).
-		expect(pipeline.droppedCount).toBeDefined();
-		expect(pipeline.rateLimitState).toBeDefined();
-	});
-
-	it("accepts a Node<RetryOptions>; layer rebuilds on each emission (state-loss caveat)", () => {
-		const src = node([], { resubscribable: true, initial: 0 });
-		const retryOpts = node([], { initial: { count: 3 } });
-		const pipeline = resilientPipeline(src, { retry: retryOpts });
-		pipeline.output.subscribe(() => {});
-		expect(pipeline.describe().nodes.retryWrapped).toBeDefined();
-
-		// Re-emit with a new count — switchMap rebuilds the layer.
-		retryOpts.emit({ count: 5 });
-		// Sanity: chain still composed (no crash); the new layer is in place.
-		expect(pipeline.describe().nodes.retryWrapped).toBeDefined();
-	});
-
-	it("accepts a Node<number> for timeoutMs; respects validation on each emission", () => {
-		const src = node([], { resubscribable: true, initial: 0 });
-		const timeoutNode = node([], { initial: 5_000 });
-		const pipeline = resilientPipeline(src, { timeoutMs: timeoutNode });
-		pipeline.output.subscribe(() => {});
-		expect(pipeline.describe().nodes.timeoutWrapped).toBeDefined();
-
-		// Switch to a different valid deadline — layer rebuilds.
-		timeoutNode.emit(2_000);
-		expect(pipeline.describe().nodes.timeoutWrapped).toBeDefined();
-	});
-
-	it("accepts a Node<readonly BudgetConstraint[]> with an initially-empty array; no layer until non-empty emits", () => {
-		const src = node([], { resubscribable: true, initial: 0 });
-		const allowed = node([], { initial: true });
-		const constraints = node<
-			ReadonlyArray<{ node: typeof allowed; check: (v: unknown) => boolean }>
-		>([], { initial: [] });
-		const pipeline = resilientPipeline(src, { budget: constraints });
-		pipeline.output.subscribe(() => {});
-		// Empty array — layer projection returns the upstream as-is. The
-		// `budgetGated` mount still exists (projection's result is what's
-		// mounted), but the gate is a pass-through.
-		const before = pipeline.describe().nodes.budgetGated;
-		expect(before).toBeDefined();
-
-		// Activate constraint set.
-		constraints.emit([{ node: allowed, check: (v) => v === true }]);
-		// Layer is rebuilt; mount continues to point at the new budgetGate output.
-		expect(pipeline.describe().nodes.budgetGated).toBeDefined();
-	});
-});
-
-describe("resilientPipeline — describe metadata", () => {
-	it("self-tags via tagFactory so describe() surfaces the factory + JSON-safe args", () => {
-		const src = node([], { initial: 0 });
-		const retryNode = node([], { initial: { count: 2 } });
-		const pipeline = resilientPipeline(src, {
-			retry: retryNode,
-			timeoutMs: 5_000,
-			fallback: -1,
-		});
-		const desc = pipeline.describe();
-		expect(desc.factory).toBe("resilientPipeline");
-		expect(desc.factoryArgs).toBeDefined();
-		// `placeholderArgs` substitutes Node-typed values with `"<Node>"`.
-		const args = desc.factoryArgs as { retry: unknown; timeoutMs: unknown; fallback: unknown };
-		expect(args.retry).toBe("<Node>");
-		expect(args.timeoutMs).toBe(5_000);
-		expect(args.fallback).toBe(-1);
-	});
-
-	it("primitives carry their own factoryTag meta on the externally-visible nodes", () => {
-		const src = node([], { initial: 0 });
-		const pipeline = resilientPipeline(src);
-		// `withStatus` (the always-last layer) stamps `meta.factory =
-		// "withStatus"` on the output node, so the Graph's `factory` ride is
-		// the canonical resilient-domain provenance and the primitive tag
-		// stays available on the inner node for tooling that drills in.
-		const nodeMeta = describeNode(pipeline.output).meta;
-		expect(nodeMeta?.factory).toBe("withStatus");
-	});
-});
-
-describe("resilientPipeline — exports", () => {
-	it("re-exports NS_PER_MS and NS_PER_SEC for call sites", () => {
-		expect(NS_PER_MS).toBe(1_000_000);
-		expect(NS_PER_SEC).toBe(1_000_000_000);
-	});
-});
diff --git a/src/__tests__/testing/mock-llm.test.ts b/src/__tests__/testing/mock-llm.test.ts
deleted file mode 100644
index 304a1a12..00000000
--- a/src/__tests__/testing/mock-llm.test.ts
+++ /dev/null
@@ -1,63 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { mockLLM } from "../../testing/mock-llm.js";
-
-const msg = (content: string) => [{ role: "user" as const, content }];
-
-describe("mockLLM (Phase 14.5.3 — public testing export)", () => {
-	it("detects built-in stages from prompt keywords", async () => {
-		const m = mockLLM({
-			stages: {
-				triage: { responses: [{ route: "auto" }] },
-				execute: { responses: [{ outcome: "ok" }] },
-			},
-		});
-		await m.invoke(msg("you are a triage classifier; here is the intake item"));
-		await m.invoke(msg("you are the implementation agent; produce a fix"));
-		expect(m.calls.map((c) => c.stage)).toEqual(["triage", "execute"]);
-		expect(m.stageCounts.get("triage")).toBe(1);
-		expect(m.callsFor("execute")).toHaveLength(1);
-	});
-
-	it("cycles responses per stage; last one repeats", async () => {
-		const m = mockLLM({
-			stages: { verify: { responses: [{ verified: false }, { verified: true }] } },
-		});
-		const r1 = await m.invoke(msg("qa reviewer: verify whether the fix works"));
-		const r2 = await m.invoke(msg("qa reviewer: verify whether the fix works"));
-		const r3 = await m.invoke(msg("qa reviewer: verify whether the fix works"));
-		expect(JSON.parse(r1.content)).toEqual({ verified: false });
-		expect(JSON.parse(r2.content)).toEqual({ verified: true });
-		// Last response repeats once exhausted.
-		expect(JSON.parse(r3.content)).toEqual({ verified: true });
-	});
-
-	it("falls back for unmatched prompts and supports custom stage names", async () => {
-		const m = mockLLM({
-			stages: { summarize: { responses: ["short summary"] } },
-			fallback: { note: "fallback" },
-		});
-		const matched = await m.invoke(msg("please summarize this"));
-		const unmatched = await m.invoke(msg("totally unrelated prompt text"));
-		expect(matched.content).toBe("short summary");
-		expect(JSON.parse(unmatched.content)).toEqual({ note: "fallback" });
-		expect(m.calls.at(-1)?.stage).toBe("unknown");
-	});
-
-	it("reset() clears calls, counts, and per-stage cursor", async () => {
-		const m = mockLLM({ stages: { triage: { responses: [{ a: 1 }, { a: 2 }] } } });
-		await m.invoke(msg("triage classifier intake item"));
-		m.reset();
-		expect(m.calls).toHaveLength(0);
-		expect(m.stageCounts.size).toBe(0);
-		// Cursor reset → next call yields the FIRST response again.
-		const r = await m.invoke(msg("triage classifier intake item"));
-		expect(JSON.parse(r.content)).toEqual({ a: 1 });
-	});
-
-	it("exposes a stream() that yields token/usage/finish deltas", async () => {
-		const m = mockLLM();
-		const kinds: string[] = [];
-		for await (const d of m.stream(msg("x"))) kinds.push(d.type);
-		expect(kinds).toEqual(["token", "usage", "finish"]);
-	});
-});
diff --git a/src/__tests__/utils/ai/adapter-contract.test.ts b/src/__tests__/utils/ai/adapter-contract.test.ts
deleted file mode 100644
index f1f796b4..00000000
--- a/src/__tests__/utils/ai/adapter-contract.test.ts
+++ /dev/null
@@ -1,235 +0,0 @@
-/**
- * Adapter behavior contract tests — verifies the 4 pillars from docs/ADAPTER-CONTRACT.md.
- *
- * Uses minimal mock adapters to test the contract generically via fromWebhook
- * and fromWebSocket (register-callback overload).
- */
-
-import { COMPLETE, DATA, ERROR } from "@graphrefly/pure-ts/core";
-import type { WebSocketRegister } from "@graphrefly/pure-ts/extra";
-import { describe, expect, it, vi } from "vitest";
-import { fromWebhook, fromWebSocket } from "../../../base/io/index.js";
-import { collectFlat } from "./test-helpers.js";
-
-// ---------------------------------------------------------------------------
-// Pillar 1 — Register callback expectations
-// ---------------------------------------------------------------------------
-
-describe("Pillar 1: register callback expectations", () => {
-	it("fromWebhook: register receives emit/error/complete and may return cleanup", () => {
-		const cleanup = vi.fn();
-		const n = fromWebhook(({ emit }) => {
-			emit("hello");
-			return cleanup;
-		});
-		const { msgs, unsub } = collectFlat(n);
-		expect(msgs).toContainEqual([DATA, "hello"]);
-		unsub();
-		expect(cleanup).toHaveBeenCalled();
-	});
-
-	it("fromWebhook: register may return undefined (no cleanup)", () => {
-		const n = fromWebhook(({ emit }) => {
-			emit("ok");
-			return undefined;
-		});
-		const { msgs, unsub } = collectFlat(n);
-		expect(msgs).toContainEqual([DATA, "ok"]);
-		unsub();
-	});
-
-	it("fromWebSocket: register must return cleanup callable", () => {
-		const n = fromWebSocket((_emit, _error, _complete) => {
-			return () => {};
-		});
-		const { unsub } = collectFlat(n);
-		unsub();
-	});
-
-	it("fromWebSocket: register returning non-function triggers ERROR", () => {
-		const n = fromWebSocket((() => undefined) as unknown as WebSocketRegister<unknown>);
-		const { msgs, unsub } = collectFlat(n);
-		const errorMsg = msgs.find((m) => m[0] === ERROR);
-		expect(errorMsg).toBeDefined();
-		expect((errorMsg![1] as Error).message).toContain("contract violation");
-		unsub();
-	});
-
-	it("registration errors are forwarded as ERROR tuples", () => {
-		const n = fromWebhook(() => {
-			throw new Error("register boom");
-		});
-		const { msgs, unsub } = collectFlat(n);
-		const errorMsg = msgs.find((m) => m[0] === ERROR);
-		expect(errorMsg).toBeDefined();
-		expect((errorMsg![1] as Error).message).toBe("register boom");
-		unsub();
-	});
-
-	it("fromWebSocket: registration errors are forwarded as ERROR tuples", () => {
-		const n = fromWebSocket(() => {
-			throw new Error("ws register boom");
-		});
-		const { msgs, unsub } = collectFlat(n);
-		const errorMsg = msgs.find((m) => m[0] === ERROR);
-		expect(errorMsg).toBeDefined();
-		expect((errorMsg![1] as Error).message).toBe("ws register boom");
-		unsub();
-	});
-});
-
-// ---------------------------------------------------------------------------
-// Pillar 2 — Terminal-time ordering
-// ---------------------------------------------------------------------------
-
-describe("Pillar 2: terminal-time ordering", () => {
-	it("cleanup runs before terminal emission (fromWebSocket register)", () => {
-		const order: string[] = [];
-		const n = fromWebSocket((emit, _error, complete) => {
-			// Emit one value, then trigger complete asynchronously.
-			emit("data");
-			queueMicrotask(() => complete());
-			return () => {
-				order.push("cleanup");
-			};
-		});
-		const { unsub } = collectFlat(n);
-		n.subscribe((msgs) => {
-			for (const m of msgs) {
-				if (m[0] === COMPLETE) order.push("complete-received");
-			}
-		});
-		// Allow microtask to fire.
-		return new Promise<void>((resolve) => {
-			setTimeout(() => {
-				// Cleanup should appear before (or at same time as) complete-received.
-				// The key invariant: cleanup is called, and the node reaches terminal.
-				expect(order).toContain("cleanup");
-				unsub();
-				resolve();
-			}, 50);
-		});
-	});
-
-	it("emit after terminal is a no-op (fromWebhook)", () => {
-		let emitFn: ((v: string) => void) | undefined;
-		const n = fromWebhook<string>(({ emit, complete }) => {
-			emitFn = emit;
-			emit("before");
-			complete();
-			return undefined;
-		});
-		const { msgs, unsub } = collectFlat(n);
-		// Try emitting after complete.
-		emitFn!("after-terminal");
-		const dataMessages = msgs.filter((m) => m[0] === DATA);
-		// No post-terminal replay — terminal guard blocks push-on-subscribe (§1.3.4)
-		expect(dataMessages).toHaveLength(1);
-		expect(dataMessages[0][1]).toBe("before");
-		unsub();
-	});
-});
-
-// ---------------------------------------------------------------------------
-// Pillar 3 — Sink transport failure handling
-// ---------------------------------------------------------------------------
-
-describe("Pillar 3: transport errors surface as ERROR tuples", () => {
-	it("fromWebSocket: parse error surfaces as ERROR", () => {
-		const n = fromWebSocket<string>(
-			(emit, _error, _complete) => {
-				emit("raw-value");
-				return () => {};
-			},
-			{
-				parse: () => {
-					throw new Error("parse failed");
-				},
-			},
-		);
-		const { msgs, unsub } = collectFlat(n);
-		const errorMsg = msgs.find((m) => m[0] === ERROR);
-		expect(errorMsg).toBeDefined();
-		expect((errorMsg![1] as Error).message).toBe("parse failed");
-		unsub();
-	});
-
-	it("fromWebhook: error() forwards as ERROR tuple without throwing", () => {
-		const n = fromWebhook(({ error }) => {
-			error(new Error("transport err"));
-			return undefined;
-		});
-		const { msgs, unsub } = collectFlat(n);
-		const errorMsg = msgs.find((m) => m[0] === ERROR);
-		expect(errorMsg).toBeDefined();
-		expect((errorMsg![1] as Error).message).toBe("transport err");
-		unsub();
-	});
-});
-
-// ---------------------------------------------------------------------------
-// Pillar 4 — Idempotency
-// ---------------------------------------------------------------------------
-
-describe("Pillar 4: idempotency", () => {
-	it("repeated COMPLETE is idempotent (fromWebhook)", () => {
-		let completeFn: (() => void) | undefined;
-		const n = fromWebhook(({ complete }) => {
-			completeFn = complete;
-			return undefined;
-		});
-		const { msgs, unsub } = collectFlat(n);
-		completeFn!();
-		completeFn!();
-		completeFn!();
-		const completes = msgs.filter((m) => m[0] === COMPLETE);
-		expect(completes).toHaveLength(1);
-		unsub();
-	});
-
-	it("repeated ERROR is idempotent (fromWebhook)", () => {
-		let errorFn: ((e: unknown) => void) | undefined;
-		const n = fromWebhook(({ error }) => {
-			errorFn = error;
-			return undefined;
-		});
-		const { msgs, unsub } = collectFlat(n);
-		errorFn!(new Error("first"));
-		errorFn!(new Error("second"));
-		const errors = msgs.filter((m) => m[0] === ERROR);
-		expect(errors).toHaveLength(1);
-		expect((errors[0][1] as Error).message).toBe("first");
-		unsub();
-	});
-
-	it("emit after error is a no-op (fromWebSocket register)", () => {
-		let emitFn: ((v: unknown) => void) | undefined;
-		const n = fromWebSocket((emit, error, _complete) => {
-			emitFn = emit;
-			error(new Error("done"));
-			return () => {};
-		});
-		const { msgs, unsub } = collectFlat(n);
-		emitFn!("late-data");
-		const dataMessages = msgs.filter((m) => m[0] === DATA);
-		expect(dataMessages).toHaveLength(0);
-		unsub();
-	});
-
-	it("COMPLETE then ERROR is idempotent (fromWebSocket register)", () => {
-		let completeFn: (() => void) | undefined;
-		let errorFn: ((e: unknown) => void) | undefined;
-		const n = fromWebSocket((_emit, error, complete) => {
-			completeFn = complete;
-			errorFn = error;
-			return () => {};
-		});
-		const { msgs, unsub } = collectFlat(n);
-		completeFn!();
-		errorFn!(new Error("late"));
-		const terminals = msgs.filter((m) => m[0] === COMPLETE || m[0] === ERROR);
-		expect(terminals).toHaveLength(1);
-		expect(terminals[0][0]).toBe(COMPLETE);
-		unsub();
-	});
-});
diff --git a/src/__tests__/utils/ai/adapters/abort-composition.test.ts b/src/__tests__/utils/ai/adapters/abort-composition.test.ts
deleted file mode 100644
index b930281c..00000000
--- a/src/__tests__/utils/ai/adapters/abort-composition.test.ts
+++ /dev/null
@@ -1,117 +0,0 @@
-/**
- * DS-14.5 / AB-3 (D-AB5) — composition-level abort test.
- *
- * `abort-propagation.test.ts` locks the *leaf* (every provider threads
- * `opts.signal` into `fetch` / SDK). This locks the *composition*: closing a
- * `valve` or superseding a `switchMap` actually fires the `AbortController`
- * the caller threaded into an in-flight `adapter.invoke({ signal })`, so the
- * call stops instead of burning tokens past the reactive cut. Without this,
- * the §6 gap #1 "panic button stops cost, not just propagation" claim is
- * aspirational end-to-end.
- */
-import { node } from "@graphrefly/pure-ts/core";
-import { switchMap, valve } from "@graphrefly/pure-ts/extra";
-import { describe, expect, it } from "vitest";
-import type {
-	ChatMessage,
-	LLMAdapter,
-	LLMResponse,
-} from "../../../../utils/ai/adapters/core/types.js";
-
-/** Adapter whose invoke hangs until its `opts.signal` aborts, recording the reason. */
-function hangingAdapter(): LLMAdapter & { lastSignal?: AbortSignal } {
-	const a: LLMAdapter & { lastSignal?: AbortSignal } = {
-		provider: "hang",
-		model: "hang-m",
-		invoke(_messages: readonly ChatMessage[], opts): Promise<LLMResponse> {
-			a.lastSignal = opts?.signal;
-			return new Promise<LLMResponse>((_resolve, reject) => {
-				if (opts?.signal) {
-					if (opts.signal.aborted) return reject(opts.signal.reason);
-					opts.signal.addEventListener("abort", () => reject((opts.signal as AbortSignal).reason), {
-						once: true,
-					});
-				}
-			});
-		},
-		// biome-ignore lint/correctness/useYield: never streams in this test
-		async *stream() {
-			throw new Error("unused");
-		},
-	};
-	return a;
-}
-
-describe("AB-3 — operator → adapter abort composition", () => {
-	it("valve close fires abortInFlight → in-flight adapter call aborts", async () => {
-		const adapter = hangingAdapter();
-		const ctrl = new AbortController();
-		const pending = Promise.resolve(
-			adapter.invoke([{ role: "user", content: "hi" }], { signal: ctrl.signal }),
-		).then(
-			() => "resolved",
-			(e) => `aborted:${(e as Error)?.name ?? e}`,
-		);
-
-		const src = node<number>([], { initial: 1 });
-		const open = node<boolean>([], { initial: true });
-		const gated = valve(src, open, { abortInFlight: ctrl });
-		const unsub = gated.subscribe(() => {});
-
-		expect(adapter.lastSignal?.aborted).toBe(false);
-		open.emit(false); // panic — truthy→falsy edge
-		expect(adapter.lastSignal?.aborted).toBe(true);
-		await expect(pending).resolves.toMatch(/^aborted:/);
-		unsub();
-	});
-
-	it("valve factory form mints fresh controller per panic-toggle cycle", () => {
-		// Caller owns the live controller; factory hands valve whichever is
-		// in flight at each close edge. Re-mint per cycle, no valve rebuild.
-		let live: AbortController | undefined;
-		const mint = (): AbortController => {
-			live = new AbortController();
-			return live;
-		};
-		const src = node<number>([], { initial: 1 });
-		const open = node<boolean>([], { initial: true });
-		const unsub = valve(src, open, { abortInFlight: () => live }).subscribe(() => {});
-
-		const c1 = mint();
-		open.emit(false); // close → abort c1
-		expect(c1.signal.aborted).toBe(true);
-
-		open.emit(true); // reopen
-		const c2 = mint(); // caller mints + rewires for the new in-flight call
-		expect(c2.signal.aborted).toBe(false);
-		open.emit(false); // close again → abort c2 (not the spent c1)
-		expect(c2.signal.aborted).toBe(true);
-		unsub();
-	});
-
-	it("switchMap supersede fires abortInFlight → prior inner's call aborts", async () => {
-		const adapter = hangingAdapter();
-		// Caller mints per outer value and threads the signal into the call;
-		// switchMap aborts the prior controller on supersede.
-		let current: AbortController | undefined;
-		const prompts = node<string>([], { initial: "p1" });
-		const out = switchMap(
-			prompts,
-			(p) => {
-				current = new AbortController();
-				const sig = current.signal;
-				return Promise.resolve(
-					adapter.invoke([{ role: "user", content: p as string }], { signal: sig }),
-				).catch((e) => ({ content: `aborted:${(e as Error)?.name ?? e}` }) as LLMResponse);
-			},
-			{ abortInFlight: () => current },
-		);
-		const unsub = out.subscribe(() => {});
-
-		const firstSignal = adapter.lastSignal;
-		expect(firstSignal?.aborted).toBe(false);
-		prompts.emit("p2"); // supersede → abort p1's controller
-		expect(firstSignal?.aborted).toBe(true);
-		unsub();
-	});
-});
diff --git a/src/__tests__/utils/ai/adapters/abort-propagation.test.ts b/src/__tests__/utils/ai/adapters/abort-propagation.test.ts
deleted file mode 100644
index aa6ee091..00000000
--- a/src/__tests__/utils/ai/adapters/abort-propagation.test.ts
+++ /dev/null
@@ -1,438 +0,0 @@
-/**
- * End-to-end abort signal propagation through every shipped provider adapter.
- *
- * Implementation-side note: every provider already plumbs
- * `LLMInvokeOptions.signal` into its underlying `fetch(..., { signal })` /
- * SDK call (audit done 2026-04-28). These tests lock that contract so a
- * future refactor that drops `signal:` from a provider's request init
- * fails loud rather than quietly turning the JSDoc cancellation claims on
- * `defaultLlmExecutor` / `defaultLlmVerifier` / `actuatorExecutor` /
- * `valve` panic-stop / `switchMap` steering into end-to-end aspirational
- * lies.
- *
- * Coverage axes: provider × call-method (`invoke` / `stream`).
- *   - anthropic: fetch + SDK on both invoke and stream
- *   - openai-compat: fetch + SDK on both invoke and stream
- *   - google: fetch on invoke (SDK path covered in google-mapping.test.ts)
- *   - chrome-nano (browser): invoke + streaming
- *   - webllm (browser): invoke + streaming
- *
- * `stream()` coverage closes the qa D1 gap — the SSE / sdk.*.stream paths
- * matter for streaming-shaped consumers (`valve` panic-stop, `switchMap`
- * steering, inline-edit/param-change patterns) where the abort plumbing
- * needs to thread through `parseSSEStream({ signal })` and
- * `sdk.*.stream({ signal })` rather than just the one-shot fetch init.
- */
-import { describe, expect, it } from "vitest";
-import { anthropicAdapter } from "../../../../utils/ai/adapters/providers/anthropic.js";
-import { chromeNanoAdapter } from "../../../../utils/ai/adapters/providers/browser/chrome-nano.js";
-import { webllmAdapter } from "../../../../utils/ai/adapters/providers/browser/webllm.js";
-import { googleAdapter } from "../../../../utils/ai/adapters/providers/google.js";
-import { openAICompatAdapter } from "../../../../utils/ai/adapters/providers/openai-compat.js";
-
-interface CapturedFetch {
-	calls: Array<{ url: string; init: RequestInit | undefined }>;
-	fetchImpl: typeof fetch;
-}
-
-function mockFetchCapturing(jsonBody: unknown, status = 200): CapturedFetch {
-	const calls: CapturedFetch["calls"] = [];
-	const fetchImpl: typeof fetch = (async (url: unknown, init?: RequestInit) => {
-		calls.push({ url: String(url), init });
-		return new Response(JSON.stringify(jsonBody), {
-			status,
-			headers: { "content-type": "application/json" },
-		});
-	}) as unknown as typeof fetch;
-	return { calls, fetchImpl };
-}
-
-/** Build a fetch impl that returns an SSE stream with the supplied raw body. */
-function mockSseFetchCapturing(sseBody: string): CapturedFetch {
-	const calls: CapturedFetch["calls"] = [];
-	const fetchImpl: typeof fetch = (async (url: unknown, init?: RequestInit) => {
-		calls.push({ url: String(url), init });
-		return new Response(sseBody, {
-			status: 200,
-			headers: { "content-type": "text/event-stream" },
-		});
-	}) as unknown as typeof fetch;
-	return { calls, fetchImpl };
-}
-
-/** Drain an async generator without caring about yielded values. */
-async function drain<T>(gen: AsyncGenerator<T> | AsyncIterable<T>): Promise<void> {
-	for await (const _ of gen as AsyncIterable<T>) {
-		void _;
-	}
-}
-
-describe("Adapter abort propagation (Tier 9.x audit)", () => {
-	describe("anthropicAdapter (fetch backend)", () => {
-		it("invoke threads invokeOpts.signal into fetch init", async () => {
-			const captured = mockFetchCapturing({
-				id: "msg_1",
-				content: [{ type: "text", text: "hello" }],
-				stop_reason: "end_turn",
-				model: "claude-sonnet-4-6",
-				usage: { input_tokens: 1, output_tokens: 1 },
-			});
-			const adapter = anthropicAdapter({
-				apiKey: "test",
-				model: "claude-sonnet-4-6",
-				fetchImpl: captured.fetchImpl,
-			});
-			const ac = new AbortController();
-			await adapter.invoke([{ role: "user", content: "hi" }], { signal: ac.signal });
-			expect(captured.calls).toHaveLength(1);
-			expect(captured.calls[0]?.init?.signal).toBe(ac.signal);
-		});
-
-		it("invoke without an explicit signal still works (signal init is undefined)", async () => {
-			const captured = mockFetchCapturing({
-				id: "msg_1",
-				content: [{ type: "text", text: "hello" }],
-				stop_reason: "end_turn",
-				model: "claude-sonnet-4-6",
-				usage: { input_tokens: 1, output_tokens: 1 },
-			});
-			const adapter = anthropicAdapter({
-				apiKey: "test",
-				model: "claude-sonnet-4-6",
-				fetchImpl: captured.fetchImpl,
-			});
-			await adapter.invoke([{ role: "user", content: "hi" }]);
-			expect(captured.calls[0]?.init?.signal).toBeUndefined();
-		});
-	});
-
-	describe("anthropicAdapter (SDK backend)", () => {
-		it("invoke forwards invokeOpts.signal to sdk.messages.create options", async () => {
-			let capturedSignal: AbortSignal | undefined;
-			const sdk = {
-				messages: {
-					create: async (_body: unknown, sdkOpts?: { signal?: AbortSignal }): Promise<unknown> => {
-						capturedSignal = sdkOpts?.signal;
-						return {
-							id: "msg_1",
-							content: [{ type: "text", text: "ok" }],
-							stop_reason: "end_turn",
-							model: "claude-sonnet-4-6",
-							usage: { input_tokens: 1, output_tokens: 1 },
-						};
-					},
-				},
-			};
-			const adapter = anthropicAdapter({ sdk, model: "claude-sonnet-4-6" });
-			const ac = new AbortController();
-			await adapter.invoke([{ role: "user", content: "hi" }], { signal: ac.signal });
-			expect(capturedSignal).toBe(ac.signal);
-		});
-	});
-
-	describe("openAICompatAdapter (fetch backend)", () => {
-		it("invoke threads invokeOpts.signal into fetch init", async () => {
-			const captured = mockFetchCapturing({
-				id: "cmpl_1",
-				model: "gpt-x",
-				choices: [
-					{ index: 0, message: { role: "assistant", content: "hi" }, finish_reason: "stop" },
-				],
-				usage: { prompt_tokens: 1, completion_tokens: 1, total_tokens: 2 },
-			});
-			const adapter = openAICompatAdapter({
-				baseURL: "https://api.example.com/v1",
-				apiKey: "test",
-				model: "gpt-x",
-				fetchImpl: captured.fetchImpl,
-			});
-			const ac = new AbortController();
-			await adapter.invoke([{ role: "user", content: "hi" }], { signal: ac.signal });
-			expect(captured.calls).toHaveLength(1);
-			expect(captured.calls[0]?.init?.signal).toBe(ac.signal);
-		});
-	});
-
-	describe("openAICompatAdapter (SDK backend)", () => {
-		it("invoke forwards invokeOpts.signal to sdk.chat.completions.create options", async () => {
-			let capturedSignal: AbortSignal | undefined;
-			const sdk = {
-				chat: {
-					completions: {
-						create: async (
-							_body: unknown,
-							sdkOpts?: { signal?: AbortSignal },
-						): Promise<unknown> => {
-							capturedSignal = sdkOpts?.signal;
-							return {
-								id: "cmpl_1",
-								model: "gpt-x",
-								choices: [
-									{
-										index: 0,
-										message: { role: "assistant", content: "ok" },
-										finish_reason: "stop",
-									},
-								],
-								usage: { prompt_tokens: 1, completion_tokens: 1, total_tokens: 2 },
-							};
-						},
-					},
-				},
-			};
-			const adapter = openAICompatAdapter({ sdk, model: "gpt-x" });
-			const ac = new AbortController();
-			await adapter.invoke([{ role: "user", content: "hi" }], { signal: ac.signal });
-			expect(capturedSignal).toBe(ac.signal);
-		});
-	});
-
-	describe("googleAdapter (fetch backend)", () => {
-		it("invoke threads invokeOpts.signal into fetch init", async () => {
-			const captured = mockFetchCapturing({
-				candidates: [{ content: { parts: [{ text: "ok" }] }, finishReason: "STOP" }],
-				usageMetadata: { promptTokenCount: 1, candidatesTokenCount: 1 },
-			});
-			const adapter = googleAdapter({
-				apiKey: "test",
-				model: "gemini-3.1-pro",
-				fetchImpl: captured.fetchImpl,
-			});
-			const ac = new AbortController();
-			await adapter.invoke([{ role: "user", content: "hi" }], { signal: ac.signal });
-			expect(captured.calls).toHaveLength(1);
-			expect(captured.calls[0]?.init?.signal).toBe(ac.signal);
-		});
-	});
-
-	describe("chromeNanoAdapter (browser SDK shim)", () => {
-		it("invoke forwards invokeOpts.signal to session.prompt options AND ai.languageModel.create options", async () => {
-			let promptSignal: AbortSignal | undefined;
-			let createSignal: AbortSignal | undefined;
-			const session = {
-				prompt: async (_input: string, opts?: { signal?: AbortSignal }): Promise<string> => {
-					promptSignal = opts?.signal;
-					return "ok";
-				},
-				promptStreaming: () =>
-					(async function* () {
-						yield "ok";
-					})(),
-				destroy: () => undefined,
-			};
-			const navigatorOverride = {
-				ai: {
-					languageModel: {
-						create: async (params?: { signal?: AbortSignal }) => {
-							createSignal = params?.signal;
-							return session;
-						},
-					},
-				},
-			} as unknown as Navigator;
-			const adapter = chromeNanoAdapter({ navigatorOverride });
-			const ac = new AbortController();
-			await adapter.invoke([{ role: "user", content: "hi" }], { signal: ac.signal });
-			// Both `create` (session opening) and `prompt` (the actual call) must
-			// receive the same signal — either source can stall mid-call so both
-			// must observe abort.
-			expect(createSignal).toBe(ac.signal);
-			expect(promptSignal).toBe(ac.signal);
-		});
-	});
-
-	describe("webllmAdapter (browser SDK)", () => {
-		it("invoke forwards invokeOpts.signal to chat.completions.create options", async () => {
-			let capturedSignal: AbortSignal | undefined;
-			const engine = {
-				chat: {
-					completions: {
-						create: async (
-							_body: unknown,
-							sdkOpts?: { signal?: AbortSignal },
-						): Promise<unknown> => {
-							capturedSignal = sdkOpts?.signal;
-							return {
-								id: "wll_1",
-								model: "Llama-3.1-8B-Instruct-q4f32_1-MLC",
-								choices: [
-									{
-										index: 0,
-										message: { role: "assistant", content: "ok" },
-										finish_reason: "stop",
-									},
-								],
-								usage: { prompt_tokens: 1, completion_tokens: 1, total_tokens: 2 },
-							};
-						},
-					},
-				},
-			};
-			const adapter = webllmAdapter({ engine, model: "Llama-3.1-8B-Instruct-q4f32_1-MLC" });
-			const ac = new AbortController();
-			await adapter.invoke([{ role: "user", content: "hi" }], { signal: ac.signal });
-			expect(capturedSignal).toBe(ac.signal);
-		});
-	});
-
-	// -------------------------------------------------------------------------
-	// stream() — qa D1 follow-up: lock that streaming-shaped abort plumbing
-	// (SSE / SDK iterator) also threads invokeOpts.signal end-to-end.
-	// -------------------------------------------------------------------------
-
-	describe("anthropicAdapter (fetch backend) stream()", () => {
-		it("threads invokeOpts.signal into both fetch init AND parseSSEStream", async () => {
-			// Anthropic SSE shape: minimal message_start + message_stop frames.
-			const sse =
-				'event: message_start\ndata: {"message":{"usage":{"input_tokens":1,"output_tokens":0}}}\n\n' +
-				'event: message_stop\ndata: {"type":"message_stop"}\n\n';
-			const captured = mockSseFetchCapturing(sse);
-			const adapter = anthropicAdapter({
-				apiKey: "test",
-				model: "claude-sonnet-4-6",
-				fetchImpl: captured.fetchImpl,
-			});
-			const ac = new AbortController();
-			await drain(adapter.stream([{ role: "user", content: "hi" }], { signal: ac.signal }));
-			expect(captured.calls).toHaveLength(1);
-			expect(captured.calls[0]?.init?.signal).toBe(ac.signal);
-		});
-	});
-
-	describe("anthropicAdapter (SDK backend) stream()", () => {
-		it("forwards invokeOpts.signal to sdk.messages.stream options", async () => {
-			let capturedSignal: AbortSignal | undefined;
-			const sdk = {
-				messages: {
-					create: async () => ({}),
-					stream: (_body: unknown, sdkOpts?: { signal?: AbortSignal }) => {
-						capturedSignal = sdkOpts?.signal;
-						return (async function* () {
-							yield { type: "message_stop" } as { type: string };
-						})();
-					},
-				},
-			};
-			const adapter = anthropicAdapter({ sdk, model: "claude-sonnet-4-6" });
-			const ac = new AbortController();
-			await drain(adapter.stream([{ role: "user", content: "hi" }], { signal: ac.signal }));
-			expect(capturedSignal).toBe(ac.signal);
-		});
-	});
-
-	describe("openAICompatAdapter (fetch backend) stream()", () => {
-		it("threads invokeOpts.signal into both fetch init AND parseSSEStream", async () => {
-			const sse =
-				'data: {"choices":[{"delta":{"content":"ok"},"finish_reason":"stop"}]}\n\ndata: [DONE]\n\n';
-			const captured = mockSseFetchCapturing(sse);
-			const adapter = openAICompatAdapter({
-				baseURL: "https://api.example.com/v1",
-				apiKey: "test",
-				model: "gpt-x",
-				fetchImpl: captured.fetchImpl,
-			});
-			const ac = new AbortController();
-			await drain(adapter.stream([{ role: "user", content: "hi" }], { signal: ac.signal }));
-			expect(captured.calls).toHaveLength(1);
-			expect(captured.calls[0]?.init?.signal).toBe(ac.signal);
-		});
-	});
-
-	describe("openAICompatAdapter (SDK backend) stream()", () => {
-		it("forwards invokeOpts.signal to sdk.chat.completions.create stream options", async () => {
-			let capturedSignal: AbortSignal | undefined;
-			const sdk = {
-				chat: {
-					completions: {
-						create: async (_body: unknown, sdkOpts?: { signal?: AbortSignal }) => {
-							capturedSignal = sdkOpts?.signal;
-							return (async function* () {
-								yield {
-									choices: [{ delta: { content: "ok" }, finish_reason: "stop" }],
-								};
-							})() as unknown;
-						},
-					},
-				},
-			};
-			const adapter = openAICompatAdapter({ sdk, model: "gpt-x" });
-			const ac = new AbortController();
-			await drain(adapter.stream([{ role: "user", content: "hi" }], { signal: ac.signal }));
-			expect(capturedSignal).toBe(ac.signal);
-		});
-	});
-
-	describe("googleAdapter (fetch backend) stream()", () => {
-		it("threads invokeOpts.signal into both fetch init AND parseSSEStream", async () => {
-			const sse =
-				'data: {"candidates":[{"content":{"parts":[{"text":"ok"}]},"finishReason":"STOP"}],"usageMetadata":{"promptTokenCount":1,"candidatesTokenCount":1}}\n\n';
-			const captured = mockSseFetchCapturing(sse);
-			const adapter = googleAdapter({
-				apiKey: "test",
-				model: "gemini-3.1-pro",
-				fetchImpl: captured.fetchImpl,
-			});
-			const ac = new AbortController();
-			await drain(adapter.stream([{ role: "user", content: "hi" }], { signal: ac.signal }));
-			expect(captured.calls).toHaveLength(1);
-			expect(captured.calls[0]?.init?.signal).toBe(ac.signal);
-		});
-	});
-
-	describe("chromeNanoAdapter (browser SDK) stream()", () => {
-		it("forwards invokeOpts.signal to ai.languageModel.create AND session.promptStreaming", async () => {
-			let createSignal: AbortSignal | undefined;
-			let promptStreamingSignal: AbortSignal | undefined;
-			const session = {
-				prompt: async () => "ok",
-				promptStreaming: (_input: string, opts?: { signal?: AbortSignal }) => {
-					promptStreamingSignal = opts?.signal;
-					return (async function* () {
-						yield "ok";
-					})();
-				},
-				destroy: () => undefined,
-			};
-			const navigatorOverride = {
-				ai: {
-					languageModel: {
-						create: async (params?: { signal?: AbortSignal }) => {
-							createSignal = params?.signal;
-							return session;
-						},
-					},
-				},
-			} as unknown as Navigator;
-			const adapter = chromeNanoAdapter({ navigatorOverride });
-			const ac = new AbortController();
-			await drain(adapter.stream([{ role: "user", content: "hi" }], { signal: ac.signal }));
-			expect(createSignal).toBe(ac.signal);
-			expect(promptStreamingSignal).toBe(ac.signal);
-		});
-	});
-
-	describe("webllmAdapter (browser SDK) stream()", () => {
-		it("forwards invokeOpts.signal to chat.completions.create stream options", async () => {
-			let capturedSignal: AbortSignal | undefined;
-			const engine = {
-				chat: {
-					completions: {
-						create: async (_body: unknown, sdkOpts?: { signal?: AbortSignal }) => {
-							capturedSignal = sdkOpts?.signal;
-							return (async function* () {
-								yield {
-									choices: [{ delta: { content: "ok" }, finish_reason: "stop" }],
-									usage: { prompt_tokens: 1, completion_tokens: 1 },
-								};
-							})() as unknown;
-						},
-					},
-				},
-			};
-			const adapter = webllmAdapter({ engine, model: "Llama-3.1-8B-Instruct-q4f32_1-MLC" });
-			const ac = new AbortController();
-			await drain(adapter.stream([{ role: "user", content: "hi" }], { signal: ac.signal }));
-			expect(capturedSignal).toBe(ac.signal);
-		});
-	});
-});
diff --git a/src/__tests__/utils/ai/adapters/adapters.ingest.test.ts b/src/__tests__/utils/ai/adapters/adapters.ingest.test.ts
deleted file mode 100644
index 153fd3ee..00000000
--- a/src/__tests__/utils/ai/adapters/adapters.ingest.test.ts
+++ /dev/null
@@ -1,1333 +0,0 @@
-/**
- * Tests for 5.2c ingest adapters (src/extra/adapters.ts).
- */
-
-import { COMPLETE, DATA, ERROR } from "@graphrefly/pure-ts/core";
-import { fromIter } from "@graphrefly/pure-ts/extra";
-import { afterEach, describe, expect, it, vi } from "vitest";
-import {
-	fromClickHouseWatch,
-	fromCSV,
-	fromKafka,
-	fromNATS,
-	fromNDJSON,
-	fromOTel,
-	fromPrometheus,
-	fromPulsar,
-	fromRabbitMQ,
-	fromRedisStream,
-	fromStatsD,
-	fromSyslog,
-	type KafkaConsumerLike,
-	type KafkaProducerLike,
-	type NATSClientLike,
-	type OTelLog,
-	type OTelMetric,
-	type OTelSpan,
-	type PulsarConsumerLike,
-	type PulsarProducerLike,
-	parsePrometheusText,
-	parseStatsD,
-	parseSyslog,
-	type RabbitMQChannelLike,
-	type RedisClientLike,
-	toKafka,
-	toNATS,
-	toPulsar,
-	toRabbitMQ,
-	toRedisStream,
-} from "../../../../base/io/index.js";
-
-function tick(ms = 0): Promise<void> {
-	return new Promise((r) => setTimeout(r, ms));
-}
-
-// ——————————————————————————————————————————————————————————————
-//  fromOTel
-// ——————————————————————————————————————————————————————————————
-
-describe("fromOTel", () => {
-	it("emits traces, metrics, and logs to separate nodes", () => {
-		const traces: unknown[] = [];
-		const metrics: unknown[] = [];
-		const logs: unknown[] = [];
-
-		// Capture handlers so we can fire after subscribing.
-		let fire!: {
-			onTraces: (spans: OTelSpan[]) => void;
-			onMetrics: (metrics: OTelMetric[]) => void;
-			onLogs: (logs: OTelLog[]) => void;
-		};
-
-		const bundle = fromOTel((handlers) => {
-			fire = handlers;
-			return () => {};
-		});
-
-		bundle.traces.subscribe((msgs) => {
-			for (const m of msgs) if (m[0] === DATA) traces.push(m[1]);
-		});
-		bundle.metrics.subscribe((msgs) => {
-			for (const m of msgs) if (m[0] === DATA) metrics.push(m[1]);
-		});
-		bundle.logs.subscribe((msgs) => {
-			for (const m of msgs) if (m[0] === DATA) logs.push(m[1]);
-		});
-
-		// Fire after subscribing.
-		fire.onTraces([
-			{
-				traceId: "abc",
-				spanId: "123",
-				operationName: "GET /api",
-				serviceName: "web",
-				startTimeNs: 0,
-				endTimeNs: 1000,
-				status: "OK",
-				attributes: {},
-				events: [],
-			},
-		]);
-		fire.onMetrics([
-			{
-				name: "http_requests_total",
-				type: "sum",
-				value: 42,
-				attributes: {},
-				timestampNs: 0,
-			},
-		]);
-		fire.onLogs([
-			{
-				timestampNs: 0,
-				body: "hello",
-				attributes: {},
-			},
-		]);
-
-		expect(traces).toHaveLength(1);
-		expect((traces[0] as OTelSpan).operationName).toBe("GET /api");
-		expect(metrics).toHaveLength(1);
-		expect((metrics[0] as OTelMetric).name).toBe("http_requests_total");
-		expect(logs).toHaveLength(1);
-		expect((logs[0] as OTelLog).body).toBe("hello");
-	});
-
-	it("propagates errors to all signal nodes", () => {
-		const errors: unknown[] = [];
-		let fireError!: (err: unknown) => void;
-
-		const bundle = fromOTel(({ onError }) => {
-			fireError = onError;
-			return () => {};
-		});
-
-		bundle.traces.subscribe((msgs) => {
-			for (const m of msgs) if (m[0] === ERROR) errors.push(m[1]);
-		});
-
-		fireError(new Error("receiver down"));
-
-		expect(errors).toHaveLength(1);
-		expect((errors[0] as Error).message).toBe("receiver down");
-	});
-});
-
-// ——————————————————————————————————————————————————————————————
-//  fromSyslog + parseSyslog
-// ——————————————————————————————————————————————————————————————
-
-describe("fromSyslog + parseSyslog", () => {
-	it("parses RFC 5424 syslog lines", () => {
-		const msg = parseSyslog("<134>1 2024-01-01T00:00:00Z myhost myapp 1234 ID47 Hello world");
-		expect(msg.facility).toBe(16); // 134 >> 3
-		expect(msg.severity).toBe(6); // 134 & 7
-		expect(msg.hostname).toBe("myhost");
-		expect(msg.appName).toBe("myapp");
-		expect(msg.procId).toBe("1234");
-		expect(msg.msgId).toBe("ID47");
-		expect(msg.message).toBe("Hello world");
-	});
-
-	it("handles unparseable lines gracefully", () => {
-		const msg = parseSyslog("just some raw text");
-		expect(msg.message).toBe("just some raw text");
-		expect(msg.hostname).toBe("-");
-	});
-
-	it("emits parsed syslog messages via register pattern", () => {
-		const received: unknown[] = [];
-
-		const node = fromSyslog(({ emit }) => {
-			emit(parseSyslog("<134>1 2024-01-01T00:00:00Z host app 1 - test message"));
-			return () => {};
-		});
-
-		node.subscribe((msgs) => {
-			for (const m of msgs) if (m[0] === DATA) received.push(m[1]);
-		});
-
-		// Producer emits once during _startProducer — single delivery.
-		expect(received).toHaveLength(1);
-		expect((received[0] as any).appName).toBe("app");
-	});
-});
-
-// ——————————————————————————————————————————————————————————————
-//  fromStatsD + parseStatsD
-// ——————————————————————————————————————————————————————————————
-
-describe("fromStatsD + parseStatsD", () => {
-	it("parses basic counter line", () => {
-		const m = parseStatsD("requests.count:1|c");
-		expect(m.name).toBe("requests.count");
-		expect(m.value).toBe(1);
-		expect(m.type).toBe("counter");
-	});
-
-	it("parses gauge with sample rate and DogStatsD tags", () => {
-		const m = parseStatsD("cpu.usage:72.5|g|@0.5|#region:us-east,env:prod");
-		expect(m.name).toBe("cpu.usage");
-		expect(m.value).toBe(72.5);
-		expect(m.type).toBe("gauge");
-		expect(m.sampleRate).toBe(0.5);
-		expect(m.tags).toEqual({ region: "us-east", env: "prod" });
-	});
-
-	it("parses timer, histogram, set, and distribution types", () => {
-		expect(parseStatsD("latency:250|ms").type).toBe("timer");
-		expect(parseStatsD("latency:250|h").type).toBe("histogram");
-		expect(parseStatsD("users:abc123|s").type).toBe("set");
-		expect(parseStatsD("latency:250|d").type).toBe("distribution");
-	});
-
-	it("throws on invalid StatsD line", () => {
-		expect(() => parseStatsD("")).toThrow("Invalid StatsD line");
-		expect(() => parseStatsD("novalue")).toThrow("Invalid StatsD line");
-	});
-
-	it("emits parsed metrics via register pattern", () => {
-		const received: unknown[] = [];
-
-		const node = fromStatsD(({ emit }) => {
-			emit(parseStatsD("hits:1|c"));
-			emit(parseStatsD("mem:512|g"));
-			return () => {};
-		});
-
-		node.subscribe((msgs) => {
-			for (const m of msgs) if (m[0] === DATA) received.push(m[1]);
-		});
-
-		// Two emits during _startProducer — single delivery per emit.
-		expect(received).toHaveLength(2);
-	});
-});
-
-// ——————————————————————————————————————————————————————————————
-//  fromPrometheus + parsePrometheusText
-// ——————————————————————————————————————————————————————————————
-
-describe("parsePrometheusText", () => {
-	it("parses exposition format with types, help, and labels", () => {
-		const text = `
-# HELP http_requests_total Total HTTP requests
-# TYPE http_requests_total counter
-http_requests_total{method="GET",code="200"} 1027
-http_requests_total{method="POST",code="200"} 42
-# TYPE node_cpu_seconds_total gauge
-node_cpu_seconds_total 3.14
-`;
-		const metrics = parsePrometheusText(text);
-		expect(metrics).toHaveLength(3);
-		expect(metrics[0].name).toBe("http_requests_total");
-		expect(metrics[0].value).toBe(1027);
-		expect(metrics[0].labels).toEqual({ method: "GET", code: "200" });
-		expect(metrics[0].type).toBe("counter");
-		expect(metrics[0].help).toBe("Total HTTP requests");
-		expect(metrics[2].name).toBe("node_cpu_seconds_total");
-		expect(metrics[2].value).toBe(3.14);
-		expect(metrics[2].type).toBe("gauge");
-	});
-
-	it("handles metrics with timestamps", () => {
-		const metrics = parsePrometheusText("up 1 1704067200000\n");
-		expect(metrics[0].value).toBe(1);
-		expect(metrics[0].timestampMs).toBe(1704067200000);
-	});
-
-	it("skips blank lines and comments", () => {
-		const metrics = parsePrometheusText("\n# just a comment\n\n");
-		expect(metrics).toHaveLength(0);
-	});
-});
-
-describe("fromPrometheus", () => {
-	const originalFetch = global.fetch;
-
-	afterEach(() => {
-		global.fetch = originalFetch;
-		vi.useRealTimers();
-	});
-
-	it("scrapes endpoint and emits parsed metrics", async () => {
-		vi.useFakeTimers();
-		const text = "up 1\nhttp_requests_total 42\n";
-		(global as any).fetch = vi.fn().mockResolvedValue({
-			ok: true,
-			text: async () => text,
-		});
-
-		const received: unknown[] = [];
-		const node = fromPrometheus("http://localhost:9090/metrics", { intervalNs: 10_000_000_000 });
-		const unsub = node.subscribe((msgs) => {
-			for (const m of msgs) if (m[0] === DATA) received.push(m[1]);
-		});
-
-		// Wait for initial scrape.
-		await vi.advanceTimersByTimeAsync(0);
-
-		expect(received).toHaveLength(2);
-		expect((received[0] as any).name).toBe("up");
-		expect((received[1] as any).name).toBe("http_requests_total");
-		unsub();
-	});
-});
-
-// ——————————————————————————————————————————————————————————————
-//  fromKafka / toKafka
-// ——————————————————————————————————————————————————————————————
-
-describe("fromKafka", () => {
-	it("emits structured messages from Kafka consumer", async () => {
-		let handler: ((payload: any) => Promise<void>) | undefined;
-
-		const consumer: KafkaConsumerLike = {
-			subscribe: vi.fn().mockResolvedValue(undefined),
-			run: vi.fn().mockImplementation(async (opts) => {
-				handler = opts.eachMessage;
-			}),
-			disconnect: vi.fn().mockResolvedValue(undefined),
-		};
-
-		const received: unknown[] = [];
-		const node = fromKafka(consumer, "events");
-		const unsub = node.subscribe((msgs) => {
-			for (const m of msgs) if (m[0] === DATA) received.push(m[1]);
-		});
-
-		await tick();
-
-		// Simulate Kafka message.
-		await handler!({
-			topic: "events",
-			partition: 0,
-			message: {
-				key: Buffer.from("key1"),
-				value: Buffer.from(JSON.stringify({ action: "click" })),
-				headers: { source: Buffer.from("web") },
-				offset: "5",
-				timestamp: "1704067200000",
-			},
-		});
-
-		expect(received).toHaveLength(1);
-		const msg = received[0] as any;
-		expect(msg.topic).toBe("events");
-		expect(msg.key).toBe("key1");
-		expect(msg.value).toEqual({ action: "click" });
-		expect(msg.headers).toEqual({ source: "web" });
-		expect(msg.offset).toBe("5");
-		unsub();
-	});
-
-	it("handles null key and value", async () => {
-		let handler: ((payload: any) => Promise<void>) | undefined;
-		const consumer: KafkaConsumerLike = {
-			subscribe: vi.fn().mockResolvedValue(undefined),
-			run: vi.fn().mockImplementation(async (opts) => {
-				handler = opts.eachMessage;
-			}),
-			disconnect: vi.fn().mockResolvedValue(undefined),
-		};
-
-		const received: unknown[] = [];
-		const node = fromKafka(consumer, "test");
-		const unsub = node.subscribe((msgs) => {
-			for (const m of msgs) if (m[0] === DATA) received.push(m[1]);
-		});
-
-		await tick();
-		await handler!({
-			topic: "test",
-			partition: 0,
-			message: { key: null, value: null, offset: "0", timestamp: "0" },
-		});
-
-		expect((received[0] as any).key).toBeNull();
-		expect((received[0] as any).value).toBeNull();
-		unsub();
-	});
-});
-
-describe("toKafka", () => {
-	it("forwards DATA to Kafka producer", async () => {
-		const kafkaProducer: KafkaProducerLike = {
-			send: vi.fn().mockResolvedValue(undefined),
-			disconnect: vi.fn().mockResolvedValue(undefined),
-		};
-
-		const { dispose: unsub } = toKafka(fromIter(["hello"]), kafkaProducer, "output");
-
-		await tick();
-
-		expect(kafkaProducer.send).toHaveBeenCalledWith({
-			topic: "output",
-			messages: [{ key: null, value: expect.any(Buffer) }],
-		});
-		unsub();
-	});
-
-	it("uses custom keyExtractor and serializer", async () => {
-		const kafkaProducer: KafkaProducerLike = {
-			send: vi.fn().mockResolvedValue(undefined),
-			disconnect: vi.fn().mockResolvedValue(undefined),
-		};
-
-		const { dispose: unsub } = toKafka(
-			fromIter([{ id: "abc", data: "xyz" }]),
-			kafkaProducer,
-			"output",
-			{
-				keyExtractor: (v) => v.id,
-				serialize: (v) => JSON.stringify(v),
-			},
-		);
-
-		await tick();
-
-		expect(kafkaProducer.send).toHaveBeenCalledWith({
-			topic: "output",
-			messages: [{ key: "abc", value: expect.any(Buffer) }],
-		});
-		unsub();
-	});
-});
-
-// ——————————————————————————————————————————————————————————————
-//  fromRedisStream / toRedisStream
-// ——————————————————————————————————————————————————————————————
-
-describe("fromRedisStream", () => {
-	it("emits entries from Redis stream via XREAD", async () => {
-		let callCount = 0;
-		const client: RedisClientLike = {
-			xadd: vi.fn().mockResolvedValue("1-0"),
-			xread: vi.fn().mockImplementation(async () => {
-				callCount++;
-				if (callCount === 1) {
-					return [
-						[
-							"mystream",
-							[
-								["1704067200000-0", ["data", '{"event":"click"}']],
-								["1704067200001-0", ["data", '{"event":"scroll"}']],
-							],
-						],
-					];
-				}
-				// Block forever on second call (simulate waiting).
-				return new Promise(() => {});
-			}),
-			disconnect: vi.fn(),
-		};
-
-		const received: unknown[] = [];
-		const node = fromRedisStream(client, "mystream");
-		const unsub = node.subscribe((msgs) => {
-			for (const m of msgs) if (m[0] === DATA) received.push(m[1]);
-		});
-
-		await tick(10);
-
-		expect(received).toHaveLength(2);
-		expect((received[0] as any).id).toBe("1704067200000-0");
-		expect((received[0] as any).data).toEqual({ event: "click" });
-		expect((received[1] as any).id).toBe("1704067200001-0");
-		unsub();
-	});
-
-	it("emits ERROR on XREAD failure", async () => {
-		const client: RedisClientLike = {
-			xadd: vi.fn().mockResolvedValue("1-0"),
-			xread: vi.fn().mockRejectedValue(new Error("connection lost")),
-			disconnect: vi.fn(),
-		};
-
-		const errors: unknown[] = [];
-		const node = fromRedisStream(client, "mystream");
-		const unsub = node.subscribe((msgs) => {
-			for (const m of msgs) if (m[0] === ERROR) errors.push(m[1]);
-		});
-
-		await tick(10);
-
-		expect(errors).toHaveLength(1);
-		expect((errors[0] as Error).message).toBe("connection lost");
-		unsub();
-	});
-});
-
-describe("toRedisStream", () => {
-	it("forwards DATA to Redis stream via XADD", async () => {
-		const client: RedisClientLike = {
-			xadd: vi.fn().mockResolvedValue("1-0"),
-			xread: vi.fn().mockResolvedValue(null),
-			disconnect: vi.fn(),
-		};
-
-		const { dispose: unsub } = toRedisStream(fromIter([{ event: "click" }]), client, "mystream");
-
-		await tick();
-
-		expect(client.xadd).toHaveBeenCalledWith(
-			"mystream",
-			"*",
-			"data",
-			JSON.stringify({ event: "click" }),
-		);
-		unsub();
-	});
-
-	it("uses MAXLEN when specified", async () => {
-		const client: RedisClientLike = {
-			xadd: vi.fn().mockResolvedValue("1-0"),
-			xread: vi.fn().mockResolvedValue(null),
-			disconnect: vi.fn(),
-		};
-
-		const { dispose: unsub } = toRedisStream(fromIter(["test"]), client, "mystream", {
-			maxLen: 1000,
-		});
-
-		await tick();
-
-		expect(client.xadd).toHaveBeenCalledWith(
-			"mystream",
-			"MAXLEN",
-			"~",
-			"1000",
-			"*",
-			"data",
-			'"test"',
-		);
-		unsub();
-	});
-});
-
-// ——————————————————————————————————————————————————————————————
-//  fromCSV
-// ——————————————————————————————————————————————————————————————
-
-describe("fromCSV", () => {
-	it("parses CSV with header row", async () => {
-		async function* gen() {
-			yield "name,age,city\n";
-			yield "Alice,30,NYC\n";
-			yield "Bob,25,SF\n";
-		}
-
-		const received: unknown[] = [];
-		let completed = false;
-		const node = fromCSV(gen());
-		node.subscribe((msgs) => {
-			for (const m of msgs) {
-				if (m[0] === DATA) received.push(m[1]);
-				if (m[0] === COMPLETE) completed = true;
-			}
-		});
-
-		await tick(10);
-
-		expect(received).toEqual([
-			{ name: "Alice", age: "30", city: "NYC" },
-			{ name: "Bob", age: "25", city: "SF" },
-		]);
-		expect(completed).toBe(true);
-	});
-
-	it("supports custom delimiter and explicit columns", async () => {
-		async function* gen() {
-			yield "Alice\t30\n";
-			yield "Bob\t25\n";
-		}
-
-		const received: unknown[] = [];
-		const node = fromCSV(gen(), {
-			delimiter: "\t",
-			hasHeader: false,
-			columns: ["name", "age"],
-		});
-		node.subscribe((msgs) => {
-			for (const m of msgs) if (m[0] === DATA) received.push(m[1]);
-		});
-
-		await tick(10);
-
-		expect(received).toEqual([
-			{ name: "Alice", age: "30" },
-			{ name: "Bob", age: "25" },
-		]);
-	});
-
-	it("handles quoted fields with embedded delimiters and newlines", async () => {
-		async function* gen() {
-			yield "name,note\n";
-			yield '"Smith, John","has ""quotes"""\n';
-		}
-
-		const received: unknown[] = [];
-		const node = fromCSV(gen());
-		node.subscribe((msgs) => {
-			for (const m of msgs) if (m[0] === DATA) received.push(m[1]);
-		});
-
-		await tick(10);
-
-		expect(received).toEqual([{ name: "Smith, John", note: 'has "quotes"' }]);
-	});
-
-	it("auto-generates column names when no header", async () => {
-		async function* gen() {
-			yield "a,b,c\n";
-		}
-
-		const received: unknown[] = [];
-		const node = fromCSV(gen(), { hasHeader: false });
-		node.subscribe((msgs) => {
-			for (const m of msgs) if (m[0] === DATA) received.push(m[1]);
-		});
-
-		await tick(10);
-
-		expect(received).toEqual([{ col0: "a", col1: "b", col2: "c" }]);
-	});
-});
-
-// ——————————————————————————————————————————————————————————————
-//  fromNDJSON
-// ——————————————————————————————————————————————————————————————
-
-describe("fromNDJSON", () => {
-	it("parses NDJSON lines from async iterable", async () => {
-		async function* gen() {
-			yield '{"level":"info","msg":"start"}\n';
-			yield '{"level":"error","msg":"fail"}\n';
-		}
-
-		const received: unknown[] = [];
-		let completed = false;
-		const node = fromNDJSON(gen());
-		node.subscribe((msgs) => {
-			for (const m of msgs) {
-				if (m[0] === DATA) received.push(m[1]);
-				if (m[0] === COMPLETE) completed = true;
-			}
-		});
-
-		await tick(10);
-
-		expect(received).toEqual([
-			{ level: "info", msg: "start" },
-			{ level: "error", msg: "fail" },
-		]);
-		expect(completed).toBe(true);
-	});
-
-	it("handles multi-line chunks", async () => {
-		async function* gen() {
-			yield '{"a":1}\n{"b":2}\n';
-		}
-
-		const received: unknown[] = [];
-		const node = fromNDJSON(gen());
-		node.subscribe((msgs) => {
-			for (const m of msgs) if (m[0] === DATA) received.push(m[1]);
-		});
-
-		await tick(10);
-
-		expect(received).toEqual([{ a: 1 }, { b: 2 }]);
-	});
-
-	it("emits ERROR on malformed JSON", async () => {
-		async function* gen() {
-			yield "not json\n";
-		}
-
-		const errors: unknown[] = [];
-		const node = fromNDJSON(gen());
-		node.subscribe((msgs) => {
-			for (const m of msgs) if (m[0] === ERROR) errors.push(m[1]);
-		});
-
-		await tick(10);
-
-		expect(errors).toHaveLength(1);
-	});
-
-	it("handles partial chunks across yields", async () => {
-		async function* gen() {
-			yield '{"x":';
-			yield "1}\n";
-		}
-
-		const received: unknown[] = [];
-		const node = fromNDJSON(gen());
-		node.subscribe((msgs) => {
-			for (const m of msgs) if (m[0] === DATA) received.push(m[1]);
-		});
-
-		await tick(10);
-
-		expect(received).toEqual([{ x: 1 }]);
-	});
-});
-
-// ——————————————————————————————————————————————————————————————
-//  fromClickHouseWatch
-// ——————————————————————————————————————————————————————————————
-
-describe("fromClickHouseWatch", () => {
-	it("polls ClickHouse query and emits rows", async () => {
-		vi.useFakeTimers();
-		let callCount = 0;
-		const client = {
-			query: vi.fn().mockImplementation(async () => {
-				callCount++;
-				return {
-					json: async () => [
-						{ error: "timeout", count: callCount * 10 },
-						{ error: "500", count: callCount * 5 },
-					],
-				};
-			}),
-		};
-
-		const received: unknown[] = [];
-		const node = fromClickHouseWatch(client, "SELECT * FROM errors_mv", {
-			intervalNs: 1_000_000_000,
-		});
-		const unsub = node.subscribe((msgs) => {
-			for (const m of msgs) if (m[0] === DATA) received.push(m[1]);
-		});
-
-		// Initial scrape.
-		await vi.advanceTimersByTimeAsync(0);
-		expect(received).toHaveLength(2);
-
-		// Next interval.
-		await vi.advanceTimersByTimeAsync(1000);
-		expect(received).toHaveLength(4);
-
-		unsub();
-		vi.useRealTimers();
-	});
-
-	it("emits ERROR on query failure", async () => {
-		vi.useFakeTimers();
-		const client = {
-			query: vi.fn().mockRejectedValue(new Error("connection refused")),
-		};
-
-		const errors: unknown[] = [];
-		const node = fromClickHouseWatch(client, "SELECT 1", { intervalNs: 1_000_000_000 });
-		const unsub = node.subscribe((msgs) => {
-			for (const m of msgs) if (m[0] === ERROR) errors.push(m[1]);
-		});
-
-		await vi.advanceTimersByTimeAsync(0);
-
-		expect(errors).toHaveLength(1);
-		expect((errors[0] as Error).message).toBe("connection refused");
-		unsub();
-		vi.useRealTimers();
-	});
-});
-
-// ————————————————��—————————————————————————————————————————————
-//  fromPulsar / toPulsar
-// ——————————————————————————————————————————————————————————————
-
-describe("fromPulsar", () => {
-	it("emits structured messages from Pulsar consumer", async () => {
-		let callCount = 0;
-		const mockMsg = {
-			getData: () => Buffer.from(JSON.stringify({ action: "click" })),
-			getMessageId: () => ({ toString: () => "msg-1" }),
-			getPartitionKey: () => "key1",
-			getProperties: () => ({ source: "web" }),
-			getPublishTimestamp: () => 1704067200000,
-			getEventTimestamp: () => 1704067200001,
-			getTopicName: () => "persistent://public/default/events",
-		};
-
-		const consumer: PulsarConsumerLike = {
-			receive: vi.fn().mockImplementation(async () => {
-				callCount++;
-				if (callCount === 1) return mockMsg;
-				return new Promise(() => {}); // Block on second call.
-			}),
-			acknowledge: vi.fn().mockResolvedValue(undefined),
-			close: vi.fn().mockResolvedValue(undefined),
-		};
-
-		const received: unknown[] = [];
-		const node = fromPulsar(consumer);
-		const unsub = node.subscribe((msgs) => {
-			for (const m of msgs) if (m[0] === DATA) received.push(m[1]);
-		});
-
-		await tick(10);
-
-		expect(received).toHaveLength(1);
-		const msg = received[0] as any;
-		expect(msg.topic).toBe("persistent://public/default/events");
-		expect(msg.messageId).toBe("msg-1");
-		expect(msg.key).toBe("key1");
-		expect(msg.value).toEqual({ action: "click" });
-		expect(msg.properties).toEqual({ source: "web" });
-		expect(msg.publishTime).toBe(1704067200000);
-		expect(msg.eventTime).toBe(1704067200001);
-		expect(consumer.acknowledge).toHaveBeenCalledTimes(1);
-		unsub();
-	});
-
-	it("emits ERROR on receive failure", async () => {
-		const consumer: PulsarConsumerLike = {
-			receive: vi.fn().mockRejectedValue(new Error("broker down")),
-			acknowledge: vi.fn().mockResolvedValue(undefined),
-			close: vi.fn().mockResolvedValue(undefined),
-		};
-
-		const errors: unknown[] = [];
-		const node = fromPulsar(consumer);
-		const unsub = node.subscribe((msgs) => {
-			for (const m of msgs) if (m[0] === ERROR) errors.push(m[1]);
-		});
-
-		await tick(10);
-
-		expect(errors).toHaveLength(1);
-		expect((errors[0] as Error).message).toBe("broker down");
-		unsub();
-	});
-
-	it("skips ack when autoAck is false", async () => {
-		let callCount = 0;
-		const mockMsg = {
-			getData: () => Buffer.from('"hello"'),
-			getMessageId: () => ({ toString: () => "msg-1" }),
-			getPartitionKey: () => "",
-			getProperties: () => ({}),
-			getPublishTimestamp: () => 0,
-			getEventTimestamp: () => 0,
-			getTopicName: () => "topic",
-		};
-
-		const consumer: PulsarConsumerLike = {
-			receive: vi.fn().mockImplementation(async () => {
-				callCount++;
-				if (callCount === 1) return mockMsg;
-				return new Promise(() => {});
-			}),
-			acknowledge: vi.fn().mockResolvedValue(undefined),
-			close: vi.fn().mockResolvedValue(undefined),
-		};
-
-		const node = fromPulsar(consumer, { autoAck: false });
-		const unsub = node.subscribe(() => {});
-		await tick(10);
-
-		expect(consumer.acknowledge).not.toHaveBeenCalled();
-		unsub();
-	});
-
-	it("emits AckableMessage envelope when autoAck is false", async () => {
-		let callCount = 0;
-		const mockMsg = {
-			getData: () => Buffer.from('"hello"'),
-			getMessageId: () => ({ toString: () => "msg-1" }),
-			getPartitionKey: () => "",
-			getProperties: () => ({}),
-			getPublishTimestamp: () => 0,
-			getEventTimestamp: () => 0,
-			getTopicName: () => "topic",
-		};
-
-		const consumer: PulsarConsumerLike & {
-			negativeAcknowledge?: (m: unknown) => Promise<void>;
-		} = {
-			receive: vi.fn().mockImplementation(async () => {
-				callCount++;
-				if (callCount === 1) return mockMsg;
-				return new Promise(() => {});
-			}),
-			acknowledge: vi.fn().mockResolvedValue(undefined),
-			close: vi.fn().mockResolvedValue(undefined),
-			negativeAcknowledge: vi.fn(),
-		};
-
-		const received: Array<{ value: unknown; ack: () => void; nack: () => void }> = [];
-		const node = fromPulsar(consumer, { autoAck: false });
-		const unsub = node.subscribe((msgs) => {
-			for (const m of msgs) {
-				if (m[0] === DATA) {
-					received.push(m[1] as { value: unknown; ack: () => void; nack: () => void });
-				}
-			}
-		});
-		await tick(10);
-
-		expect(received).toHaveLength(1);
-		expect((received[0].value as { value: unknown }).value).toBe("hello");
-		expect(consumer.acknowledge).not.toHaveBeenCalled();
-		// Caller invokes ack
-		received[0].ack();
-		await tick(0);
-		expect(consumer.acknowledge).toHaveBeenCalledTimes(1);
-		// Idempotent: second ack is a no-op
-		received[0].ack();
-		expect(consumer.acknowledge).toHaveBeenCalledTimes(1);
-		unsub();
-	});
-
-	it("envelope nack calls consumer.negativeAcknowledge", async () => {
-		let callCount = 0;
-		const mockMsg = {
-			getData: () => Buffer.from('"hello"'),
-			getMessageId: () => ({ toString: () => "msg-1" }),
-			getPartitionKey: () => "",
-			getProperties: () => ({}),
-			getPublishTimestamp: () => 0,
-			getEventTimestamp: () => 0,
-			getTopicName: () => "topic",
-		};
-
-		const consumer: PulsarConsumerLike & {
-			negativeAcknowledge?: (m: unknown) => void;
-		} = {
-			receive: vi.fn().mockImplementation(async () => {
-				callCount++;
-				if (callCount === 1) return mockMsg;
-				return new Promise(() => {});
-			}),
-			acknowledge: vi.fn().mockResolvedValue(undefined),
-			close: vi.fn().mockResolvedValue(undefined),
-			negativeAcknowledge: vi.fn(),
-		};
-
-		const received: Array<{ ack: () => void; nack: () => void }> = [];
-		const node = fromPulsar(consumer, { autoAck: false });
-		const unsub = node.subscribe((msgs) => {
-			for (const m of msgs) {
-				if (m[0] === DATA) received.push(m[1] as { ack: () => void; nack: () => void });
-			}
-		});
-		await tick(10);
-
-		received[0].nack();
-		expect(consumer.negativeAcknowledge).toHaveBeenCalledTimes(1);
-		expect(consumer.acknowledge).not.toHaveBeenCalled();
-		unsub();
-	});
-});
-
-describe("toPulsar", () => {
-	it("forwards DATA to Pulsar producer", async () => {
-		const pulsarProducer: PulsarProducerLike = {
-			send: vi.fn().mockResolvedValue(undefined),
-			close: vi.fn().mockResolvedValue(undefined),
-		};
-
-		const { dispose: unsub } = toPulsar(fromIter(["hello"]), pulsarProducer);
-
-		await tick();
-
-		expect(pulsarProducer.send).toHaveBeenCalledWith({
-			data: expect.any(Buffer),
-			partitionKey: undefined,
-			properties: undefined,
-		});
-		const sentData = (pulsarProducer.send as any).mock.calls[0][0].data;
-		expect(JSON.parse(sentData.toString())).toBe("hello");
-		unsub();
-	});
-
-	it("uses custom keyExtractor and propertiesExtractor", async () => {
-		const pulsarProducer: PulsarProducerLike = {
-			send: vi.fn().mockResolvedValue(undefined),
-			close: vi.fn().mockResolvedValue(undefined),
-		};
-
-		const { dispose: unsub } = toPulsar(fromIter([{ id: "abc", data: "xyz" }]), pulsarProducer, {
-			keyExtractor: (v) => v.id,
-			propertiesExtractor: (v) => ({ type: typeof v.data }),
-		});
-
-		await tick();
-
-		expect(pulsarProducer.send).toHaveBeenCalledWith({
-			data: expect.any(Buffer),
-			partitionKey: "abc",
-			properties: { type: "string" },
-		});
-		unsub();
-	});
-});
-
-// ————��———————————————————————————————————————————————��—————————
-//  fromNATS / toNATS
-// ——————————���——————————————————————————————————————���————————————
-
-describe("fromNATS", () => {
-	it("emits structured messages from NATS subscription", async () => {
-		const encoder = new TextEncoder();
-		const messages = [
-			{
-				subject: "events.click",
-				data: encoder.encode(JSON.stringify({ action: "click" })),
-				headers: {
-					get: (k: string) => (k === "source" ? "web" : ""),
-					keys: () => ["source"],
-				},
-				reply: "reply.1",
-				sid: 1,
-			},
-		];
-
-		let resolveIter: (() => void) | undefined;
-		const blockPromise = new Promise<void>((r) => {
-			resolveIter = r;
-		});
-
-		const client: NATSClientLike = {
-			subscribe: vi.fn().mockReturnValue({
-				[Symbol.asyncIterator]: () => {
-					let idx = 0;
-					return {
-						async next() {
-							if (idx < messages.length) return { value: messages[idx++], done: false };
-							await blockPromise;
-							return { value: undefined, done: true };
-						},
-					};
-				},
-			}),
-			publish: vi.fn(),
-			drain: vi.fn().mockResolvedValue(undefined),
-		};
-
-		const received: unknown[] = [];
-		const node = fromNATS(client, "events.>");
-		const unsub = node.subscribe((msgs) => {
-			for (const m of msgs) if (m[0] === DATA) received.push(m[1]);
-		});
-
-		await tick(10);
-
-		expect(received).toHaveLength(1);
-		const msg = received[0] as any;
-		expect(msg.subject).toBe("events.click");
-		expect(msg.data).toEqual({ action: "click" });
-		expect(msg.headers).toEqual({ source: "web" });
-		expect(msg.reply).toBe("reply.1");
-		expect(msg.sid).toBe(1);
-
-		resolveIter!();
-		unsub();
-	});
-
-	it("emits COMPLETE when subscription ends", async () => {
-		const client: NATSClientLike = {
-			subscribe: vi.fn().mockReturnValue({
-				[Symbol.asyncIterator]: () => ({
-					async next() {
-						return { value: undefined, done: true };
-					},
-				}),
-			}),
-			publish: vi.fn(),
-			drain: vi.fn().mockResolvedValue(undefined),
-		};
-
-		const completed: boolean[] = [];
-		const node = fromNATS(client, "test");
-		const unsub = node.subscribe((msgs) => {
-			for (const m of msgs) if (m[0] === COMPLETE) completed.push(true);
-		});
-
-		await tick(10);
-
-		expect(completed).toHaveLength(1);
-		unsub();
-	});
-
-	it("emits ERROR on iteration failure", async () => {
-		const client: NATSClientLike = {
-			subscribe: vi.fn().mockReturnValue({
-				[Symbol.asyncIterator]: () => ({
-					async next() {
-						throw new Error("connection lost");
-					},
-				}),
-			}),
-			publish: vi.fn(),
-			drain: vi.fn().mockResolvedValue(undefined),
-		};
-
-		const errors: unknown[] = [];
-		const node = fromNATS(client, "test");
-		const unsub = node.subscribe((msgs) => {
-			for (const m of msgs) if (m[0] === ERROR) errors.push(m[1]);
-		});
-
-		await tick(10);
-
-		expect(errors).toHaveLength(1);
-		expect((errors[0] as Error).message).toBe("connection lost");
-		unsub();
-	});
-});
-
-describe("toNATS", () => {
-	it("forwards DATA to NATS subject", async () => {
-		const client: NATSClientLike = {
-			subscribe: vi.fn().mockReturnValue({
-				[Symbol.asyncIterator]: () => ({ next: async () => ({ done: true, value: undefined }) }),
-			}),
-			publish: vi.fn(),
-			drain: vi.fn().mockResolvedValue(undefined),
-		};
-
-		const { dispose: unsub } = toNATS(fromIter(["hello"]), client, "events.out");
-
-		await tick();
-
-		expect(client.publish).toHaveBeenCalledWith("events.out", expect.any(Uint8Array));
-		const sentData = (client.publish as any).mock.calls[0][1];
-		expect(JSON.parse(new TextDecoder().decode(sentData))).toBe("hello");
-		unsub();
-	});
-});
-
-// ———————���——————————————————————————————————————————————————————
-//  fromRabbitMQ / toRabbitMQ
-// ——————————————————————————————————————————————————————————————
-
-describe("fromRabbitMQ", () => {
-	it("emits structured messages from RabbitMQ channel", async () => {
-		let handler: ((msg: any) => void) | undefined;
-
-		const channel: RabbitMQChannelLike = {
-			consume: vi.fn().mockImplementation(async (_queue: string, cb: any) => {
-				handler = cb;
-				return { consumerTag: "ctag-1" };
-			}),
-			cancel: vi.fn().mockResolvedValue(undefined),
-			ack: vi.fn(),
-			publish: vi.fn().mockReturnValue(true),
-			sendToQueue: vi.fn().mockReturnValue(true),
-		};
-
-		const received: unknown[] = [];
-		const node = fromRabbitMQ(channel, "events");
-		const unsub = node.subscribe((msgs) => {
-			for (const m of msgs) if (m[0] === DATA) received.push(m[1]);
-		});
-
-		await tick();
-
-		handler!({
-			content: Buffer.from(JSON.stringify({ action: "click" })),
-			fields: {
-				routingKey: "events",
-				exchange: "",
-				deliveryTag: 1,
-				redelivered: false,
-			},
-			properties: { contentType: "application/json" },
-		});
-
-		expect(received).toHaveLength(1);
-		const msg = received[0] as any;
-		expect(msg.queue).toBe("events");
-		expect(msg.routingKey).toBe("events");
-		expect(msg.content).toEqual({ action: "click" });
-		expect(msg.deliveryTag).toBe(1);
-		expect(msg.redelivered).toBe(false);
-		expect(channel.ack).toHaveBeenCalledTimes(1);
-		unsub();
-	});
-
-	it("emits ERROR on consume failure", async () => {
-		const channel: RabbitMQChannelLike = {
-			consume: vi.fn().mockRejectedValue(new Error("channel closed")),
-			cancel: vi.fn().mockResolvedValue(undefined),
-			ack: vi.fn(),
-			publish: vi.fn().mockReturnValue(true),
-			sendToQueue: vi.fn().mockReturnValue(true),
-		};
-
-		const errors: unknown[] = [];
-		const node = fromRabbitMQ(channel, "events");
-		const unsub = node.subscribe((msgs) => {
-			for (const m of msgs) if (m[0] === ERROR) errors.push(m[1]);
-		});
-
-		await tick(10);
-
-		expect(errors).toHaveLength(1);
-		expect((errors[0] as Error).message).toBe("channel closed");
-		unsub();
-	});
-
-	it("emits ERROR on broker-cancelled consumer (null message)", async () => {
-		let handler: ((msg: any) => void) | undefined;
-
-		const channel: RabbitMQChannelLike = {
-			consume: vi.fn().mockImplementation(async (_queue: string, cb: any) => {
-				handler = cb;
-				return { consumerTag: "ctag-1" };
-			}),
-			cancel: vi.fn().mockResolvedValue(undefined),
-			ack: vi.fn(),
-			publish: vi.fn().mockReturnValue(true),
-			sendToQueue: vi.fn().mockReturnValue(true),
-		};
-
-		const received: unknown[] = [];
-		const errors: unknown[] = [];
-		const node = fromRabbitMQ(channel, "events");
-		const unsub = node.subscribe((msgs) => {
-			for (const m of msgs) {
-				if (m[0] === DATA) received.push(m[1]);
-				if (m[0] === ERROR) errors.push(m[1]);
-			}
-		});
-
-		await tick();
-
-		handler!(null);
-		expect(received).toHaveLength(0);
-		expect(errors).toHaveLength(1);
-		expect((errors[0] as Error).message).toBe("Consumer cancelled by broker");
-		unsub();
-	});
-
-	it("emits AckableMessage envelope when autoAck is false; ack/nack call channel methods", async () => {
-		let handler!: (msg: unknown) => void;
-		const channel: RabbitMQChannelLike & { nack?: (m: unknown, a: boolean, r: boolean) => void } = {
-			consume: vi.fn().mockImplementation(async (_q, h) => {
-				handler = h;
-				return { consumerTag: "ctag" };
-			}),
-			cancel: vi.fn().mockResolvedValue(undefined),
-			ack: vi.fn(),
-			nack: vi.fn(),
-			publish: vi.fn(),
-			sendToQueue: vi.fn(),
-		};
-
-		const received: Array<{
-			value: unknown;
-			ack: () => void;
-			nack: (o?: { requeue?: boolean }) => void;
-		}> = [];
-		const node = fromRabbitMQ(channel, "events", { autoAck: false });
-		const unsub = node.subscribe((msgs) => {
-			for (const m of msgs) {
-				if (m[0] === DATA) {
-					received.push(
-						m[1] as {
-							value: unknown;
-							ack: () => void;
-							nack: (o?: { requeue?: boolean }) => void;
-						},
-					);
-				}
-			}
-		});
-		await tick();
-
-		const mockMsg = {
-			content: Buffer.from('{"v":1}'),
-			fields: { routingKey: "", exchange: "", deliveryTag: 1, redelivered: false },
-			properties: {},
-		};
-		handler(mockMsg);
-
-		expect(received).toHaveLength(1);
-		expect((received[0].value as { content: unknown }).content).toEqual({ v: 1 });
-		expect(channel.ack).not.toHaveBeenCalled();
-
-		received[0].ack();
-		expect(channel.ack).toHaveBeenCalledWith(mockMsg);
-
-		// Second message, nack with requeue
-		const mockMsg2 = {
-			content: Buffer.from('{"v":2}'),
-			fields: { routingKey: "", exchange: "", deliveryTag: 2, redelivered: false },
-			properties: {},
-		};
-		handler(mockMsg2);
-		received[1].nack({ requeue: false });
-		expect(channel.nack).toHaveBeenCalledWith(mockMsg2, false, false);
-		unsub();
-	});
-});
-
-describe("toRabbitMQ", () => {
-	it("forwards DATA to RabbitMQ exchange", async () => {
-		const channel: RabbitMQChannelLike = {
-			consume: vi.fn().mockResolvedValue({ consumerTag: "ctag" }),
-			cancel: vi.fn().mockResolvedValue(undefined),
-			ack: vi.fn(),
-			publish: vi.fn().mockReturnValue(true),
-			sendToQueue: vi.fn().mockReturnValue(true),
-		};
-
-		const { dispose: unsub } = toRabbitMQ(fromIter(["hello"]), channel, "my-exchange");
-
-		await tick();
-
-		expect(channel.publish).toHaveBeenCalledWith("my-exchange", "", expect.any(Buffer));
-		const sentContent = (channel.publish as any).mock.calls[0][2];
-		expect(JSON.parse(sentContent.toString())).toBe("hello");
-		unsub();
-	});
-
-	it("uses custom routingKeyExtractor", async () => {
-		const channel: RabbitMQChannelLike = {
-			consume: vi.fn().mockResolvedValue({ consumerTag: "ctag" }),
-			cancel: vi.fn().mockResolvedValue(undefined),
-			ack: vi.fn(),
-			publish: vi.fn().mockReturnValue(true),
-			sendToQueue: vi.fn().mockReturnValue(true),
-		};
-
-		const { dispose: unsub } = toRabbitMQ(
-			fromIter([{ id: "abc", type: "click" }]),
-			channel,
-			"events",
-			{
-				routingKeyExtractor: (v) => v.type,
-			},
-		);
-
-		await tick();
-
-		expect(channel.publish).toHaveBeenCalledWith("events", "click", expect.any(Buffer));
-		unsub();
-	});
-});
diff --git a/src/__tests__/utils/ai/adapters/adapters.storage.test.ts b/src/__tests__/utils/ai/adapters/adapters.storage.test.ts
deleted file mode 100644
index 197cb6df..00000000
--- a/src/__tests__/utils/ai/adapters/adapters.storage.test.ts
+++ /dev/null
@@ -1,1191 +0,0 @@
-/**
- * Tests for 5.2d storage & sink adapters (src/extra/adapters.ts).
- */
-
-import type { Node } from "@graphrefly/pure-ts/core";
-import { COMPLETE, DATA, DIRTY, ERROR, node } from "@graphrefly/pure-ts/core";
-import { fromIter } from "@graphrefly/pure-ts/extra";
-import { describe, expect, it, vi } from "vitest";
-import {
-	type ClickHouseInsertClientLike,
-	checkpointToRedis,
-	checkpointToS3,
-	type DrizzleQueryLike,
-	type FileWriterLike,
-	fromDrizzle,
-	fromKysely,
-	fromPrisma,
-	fromSqlite,
-	type KyselyQueryLike,
-	type LokiClientLike,
-	type MongoCollectionLike,
-	type PostgresClientLike,
-	type PrismaModelLike,
-	type S3ClientLike,
-	type SqliteDbLike,
-	type TempoClientLike,
-	toClickHouse,
-	toCSV,
-	toFile,
-	toLoki,
-	toMongo,
-	toPostgres,
-	toS3,
-	toSqlite,
-	toTempo,
-} from "../../../../base/io/index.js";
-import { collectFlat } from "../test-helpers.js";
-
-function tick(ms = 0): Promise<void> {
-	return new Promise((r) => setTimeout(r, ms));
-}
-
-/**
- * Creates a source node with no cached value (SENTINEL), so push-on-subscribe
- * does not replay any value. Call `send(v)` to push DATA, `complete()` to push
- * COMPLETE, `error(e)` to push ERROR.
- */
-function manualSource<T>(): {
-	src: Node<T>;
-	send: (v: T) => void;
-	complete: () => void;
-	error: (e: unknown) => void;
-} {
-	const src = node<T>();
-	return {
-		src,
-		send: (v: T) => src.down([[DATA, v]]),
-		complete: () => src.down([[COMPLETE]]),
-		error: (e: unknown) => src.down([[ERROR, e]]),
-	};
-}
-
-// ——————————————————————————————————————————————————————————————
-//  toFile
-// ——————————————————————————————————————————————————————————————
-
-describe("toFile", () => {
-	it("writes each DATA value immediately in write-through mode", () => {
-		const chunks: string[] = [];
-		const writer: FileWriterLike = {
-			write: (d) => {
-				chunks.push(d as string);
-			},
-			end: () => {},
-		};
-		const { src, send, complete } = manualSource<number>();
-		const handle = toFile(src, writer);
-		send(1);
-		send(2);
-		send(3);
-		complete();
-		expect(chunks).toEqual(["1\n", "2\n", "3\n"]);
-		handle.dispose();
-	});
-
-	it("uses custom serialize", () => {
-		const chunks: string[] = [];
-		const writer: FileWriterLike = {
-			write: (d) => {
-				chunks.push(d as string);
-			},
-			end: () => {},
-		};
-		const { src, send, complete } = manualSource<string>();
-		const handle = toFile(src, writer, { serialize: (v) => `LINE:${v}\n` });
-		send("a");
-		send("b");
-		complete();
-		expect(chunks).toEqual(["LINE:a\n", "LINE:b\n"]);
-		handle.dispose();
-	});
-
-	it("buffers with batchSize and flushes on COMPLETE", () => {
-		const chunks: string[] = [];
-		const writer: FileWriterLike = {
-			write: (d) => {
-				chunks.push(d as string);
-			},
-			end: () => {},
-		};
-		const src = fromIter([1, 2, 3]);
-		const handle = toFile(src, writer, { batchSize: 5 });
-		// COMPLETE from fromIter triggers flush of buffered items
-		expect(chunks).toEqual(["1\n2\n3\n"]);
-		handle.dispose();
-	});
-
-	it("auto-flushes when batchSize reached and on COMPLETE", () => {
-		const chunks: string[] = [];
-		const writer: FileWriterLike = {
-			write: (d) => {
-				chunks.push(d as string);
-			},
-			end: () => {},
-		};
-		const src = fromIter([1, 2, 3, 4, 5]);
-		const handle = toFile(src, writer, { batchSize: 2 });
-		// 2 full batches auto-flushed (1,2) and (3,4), remainder (5) flushed on COMPLETE
-		expect(chunks).toEqual(["1\n2\n", "3\n4\n", "5\n"]);
-		handle.dispose();
-	});
-
-	it("calls onTransportError on serialize failure", () => {
-		const errors: unknown[] = [];
-		const writer: FileWriterLike = {
-			write: () => {},
-			end: () => {},
-		};
-		const { src, send } = manualSource<number>();
-		const handle = toFile(src, writer, {
-			serialize: () => {
-				throw new Error("bad");
-			},
-			onTransportError: (e) => errors.push(e),
-		});
-		send(1);
-		expect(errors).toHaveLength(1);
-		expect((errors[0] as { stage: string }).stage).toBe("serialize");
-		handle.dispose();
-	});
-
-	it("calls onTransportError on write failure", () => {
-		const errors: unknown[] = [];
-		const writer: FileWriterLike = {
-			write: () => {
-				throw new Error("disk full");
-			},
-			end: () => {},
-		};
-		const { src, send } = manualSource<number>();
-		const handle = toFile(src, writer, {
-			onTransportError: (e) => errors.push(e),
-		});
-		send(1);
-		expect(errors).toHaveLength(1);
-		expect((errors[0] as { stage: string }).stage).toBe("send");
-		handle.dispose();
-	});
-});
-
-// ——————————————————————————————————————————————————————————————
-//  toCSV
-// ——————————————————————————————————————————————————————————————
-
-describe("toCSV", () => {
-	it("writes header + rows", () => {
-		const chunks: string[] = [];
-		const writer: FileWriterLike = {
-			write: (d) => {
-				chunks.push(d as string);
-			},
-			end: () => {},
-		};
-		const { src, send, complete } = manualSource<Record<string, string>>();
-		const handle = toCSV(src, writer, { columns: ["name", "age"] });
-		send({ name: "Alice", age: "30" });
-		send({ name: "Bob", age: "25" });
-		complete();
-		expect(chunks).toEqual(["name,age\nAlice,30\n", "Bob,25\n"]);
-		handle.dispose();
-	});
-
-	it("escapes fields with delimiters and quotes", () => {
-		const chunks: string[] = [];
-		const writer: FileWriterLike = {
-			write: (d) => {
-				chunks.push(d as string);
-			},
-			end: () => {},
-		};
-		const { src, send, complete } = manualSource<Record<string, string>>();
-		const handle = toCSV(src, writer, {
-			columns: ["val"],
-			writeHeader: false,
-		});
-		send({ val: "has,comma" });
-		send({ val: 'has"quote' });
-		complete();
-		expect(chunks).toEqual(['"has,comma"\n', '"has""quote"\n']);
-		handle.dispose();
-	});
-
-	it("supports custom delimiter", () => {
-		const chunks: string[] = [];
-		const writer: FileWriterLike = {
-			write: (d) => {
-				chunks.push(d as string);
-			},
-			end: () => {},
-		};
-		const { src, send, complete } = manualSource<Record<string, string>>();
-		const handle = toCSV(src, writer, {
-			columns: ["a", "b"],
-			delimiter: "\t",
-		});
-		send({ a: "1", b: "2" });
-		complete();
-		expect(chunks).toEqual(["a\tb\n1\t2\n"]);
-		handle.dispose();
-	});
-});
-
-// ——————————————————————————————————————————————————————————————
-//  toClickHouse
-// ——————————————————————————————————————————————————————————————
-
-describe("toClickHouse", () => {
-	it("buffers and flushes on batchSize", () => {
-		const inserted: unknown[][] = [];
-		const client: ClickHouseInsertClientLike = {
-			insert: async (params) => {
-				inserted.push(params.values);
-			},
-		};
-		const src = fromIter([1, 2, 3]);
-		const handle = toClickHouse(src, client, "events", { batchSize: 2 });
-		// 1 batch of [1,2] auto-flushed, remaining [3] flushed on COMPLETE
-		expect(inserted).toEqual([[1, 2], [3]]);
-		handle.dispose();
-	});
-
-	it("uses custom transform", () => {
-		const inserted: unknown[][] = [];
-		const client: ClickHouseInsertClientLike = {
-			insert: async (params) => {
-				inserted.push(params.values);
-			},
-		};
-		const { src, send, complete } = manualSource<number>();
-		const handle = toClickHouse(src, client, "t", {
-			batchSize: 10,
-			transform: (v) => ({ val: v * 10 }),
-		});
-		send(1);
-		send(2);
-		complete();
-		handle.dispose();
-		expect(inserted).toEqual([[{ val: 10 }, { val: 20 }]]);
-	});
-
-	it("reports transform errors via onTransportError", () => {
-		const errors: unknown[] = [];
-		const client: ClickHouseInsertClientLike = {
-			insert: async () => {},
-		};
-		const { src, send } = manualSource<number>();
-		const handle = toClickHouse(src, client, "t", {
-			batchSize: 10,
-			transform: () => {
-				throw new Error("transform fail");
-			},
-			onTransportError: (e) => errors.push(e),
-		});
-		send(1);
-		expect(errors).toHaveLength(1);
-		expect((errors[0] as { stage: string }).stage).toBe("serialize");
-		handle.dispose();
-	});
-});
-
-// ——————————————————————————————————————————————————————————————
-//  toS3
-// ——————————————————————————————————————————————————————————————
-
-describe("toS3", () => {
-	it("buffers and flushes NDJSON on dispose", () => {
-		const uploads: { key: string; body: string }[] = [];
-		const client: S3ClientLike = {
-			putObject: async (params) => {
-				uploads.push({ key: params.Key, body: params.Body as string });
-			},
-		};
-		const { src, send, complete } = manualSource<Record<string, number>>();
-		const handle = toS3(src, client, "my-bucket", {
-			batchSize: 10,
-			keyGenerator: (seq) => `batch-${seq}.ndjson`,
-		});
-		send({ a: 1 });
-		send({ b: 2 });
-		complete();
-		handle.dispose();
-		expect(uploads).toHaveLength(1);
-		expect(uploads[0].key).toBe("batch-1.ndjson");
-		expect(uploads[0].body).toBe('{"a":1}\n{"b":2}\n');
-	});
-
-	it("supports JSON format", () => {
-		const uploads: { body: string }[] = [];
-		const client: S3ClientLike = {
-			putObject: async (params) => {
-				uploads.push({ body: params.Body as string });
-			},
-		};
-		const src = fromIter([1, 2]);
-		const handle = toS3(src, client, "b", {
-			format: "json",
-			batchSize: 10,
-			keyGenerator: (seq) => `batch-${seq}.json`,
-		});
-		handle.dispose();
-		expect(uploads[0].body).toBe("[1,2]");
-	});
-});
-
-// ——————————————————————————————————————————————————————————————
-//  toPostgres
-// ——————————————————————————————————————————————————————————————
-
-describe("toPostgres", () => {
-	it("inserts each value as a row", async () => {
-		const queries: { sql: string; params: unknown[] }[] = [];
-		const client: PostgresClientLike = {
-			query: async (sql, params) => {
-				queries.push({ sql, params: params ?? [] });
-			},
-		};
-		const { src, send, complete } = manualSource<Record<string, number>>();
-		const { dispose: unsub } = toPostgres(src, client, "events");
-		send({ x: 1 });
-		send({ x: 2 });
-		complete();
-		await tick();
-		expect(queries).toHaveLength(2);
-		expect(queries[0].sql).toContain('INSERT INTO "events"');
-		unsub();
-	});
-
-	it("reports toSQL errors via onTransportError", () => {
-		const errors: unknown[] = [];
-		const client: PostgresClientLike = {
-			query: async () => {},
-		};
-		const { src, send } = manualSource<number>();
-		const { dispose: unsub } = toPostgres(src, client, "t", {
-			toSQL: () => {
-				throw new Error("bad sql");
-			},
-			onTransportError: (e) => errors.push(e),
-		});
-		send(1);
-		expect(errors).toHaveLength(1);
-		expect((errors[0] as { stage: string }).stage).toBe("serialize");
-		unsub();
-	});
-
-	it("errors node receives errors without callback", async () => {
-		const client: PostgresClientLike = {
-			query: async () => {
-				throw new Error("connection lost");
-			},
-		};
-		const src = fromIter([1]);
-		const handle = toPostgres(src, client, "t");
-		await tick();
-		expect(handle.errors.cache).not.toBeNull();
-		expect((handle.errors.cache as { stage: string }).stage).toBe("send");
-		handle.dispose();
-	});
-});
-
-// ——————————————————————————————————————————————————————————————
-//  toMongo
-// ——————————————————————————————————————————————————————————————
-
-describe("toMongo", () => {
-	it("inserts each value as a document", async () => {
-		const docs: unknown[] = [];
-		const collection: MongoCollectionLike = {
-			insertOne: async (doc) => {
-				docs.push(doc);
-			},
-		};
-		const { src, send, complete } = manualSource<Record<string, number>>();
-		const { dispose: unsub } = toMongo(src, collection);
-		send({ a: 1 });
-		send({ b: 2 });
-		complete();
-		await tick();
-		expect(docs).toEqual([{ a: 1 }, { b: 2 }]);
-		unsub();
-	});
-
-	it("uses custom toDocument", async () => {
-		const docs: unknown[] = [];
-		const collection: MongoCollectionLike = {
-			insertOne: async (doc) => {
-				docs.push(doc);
-			},
-		};
-		const { src, send, complete } = manualSource<number>();
-		const { dispose: unsub } = toMongo(src, collection, {
-			toDocument: (v) => ({ value: v, ts: "now" }),
-		});
-		send(1);
-		send(2);
-		complete();
-		await tick();
-		expect(docs).toEqual([
-			{ value: 1, ts: "now" },
-			{ value: 2, ts: "now" },
-		]);
-		unsub();
-	});
-});
-
-// ——————————————————————————————————————————————————————————————
-//  toLoki
-// ——————————————————————————————————————————————————————————————
-
-describe("toLoki", () => {
-	it("pushes log entries with labels", async () => {
-		const pushes: unknown[] = [];
-		const client: LokiClientLike = {
-			push: async (payload) => {
-				pushes.push(payload);
-			},
-		};
-		const { src, send, complete } = manualSource<string>();
-		const { dispose: unsub } = toLoki(src, client, {
-			labels: { job: "test" },
-			toLine: (v) => v,
-		});
-		send("log line 1");
-		complete();
-		await tick();
-		expect(pushes).toHaveLength(1);
-		const first = pushes[0] as {
-			streams: Array<{ stream: Record<string, string>; values: string[][] }>;
-		};
-		expect(first.streams[0].stream).toEqual({ job: "test" });
-		expect(first.streams[0].values[0][1]).toBe("log line 1");
-		unsub();
-	});
-
-	it("merges dynamic labels", async () => {
-		const pushes: unknown[] = [];
-		const client: LokiClientLike = {
-			push: async (payload) => {
-				pushes.push(payload);
-			},
-		};
-		const src = fromIter([{ level: "error", msg: "fail" }]);
-		const { dispose: unsub } = toLoki(src, client, {
-			labels: { job: "app" },
-			toLine: (v) => v.msg,
-			toLabels: (v) => ({ level: v.level }),
-		});
-		await tick();
-		const first = pushes[0] as { streams: Array<{ stream: Record<string, string> }> };
-		expect(first.streams[0].stream).toEqual({ job: "app", level: "error" });
-		unsub();
-	});
-});
-
-// ——————————————————————————————————————————————————————————————
-//  toTempo
-// ——————————————————————————————————————————————————————————————
-
-describe("toTempo", () => {
-	it("pushes trace spans", async () => {
-		const pushes: unknown[] = [];
-		const client: TempoClientLike = {
-			push: async (payload) => {
-				pushes.push(payload);
-			},
-		};
-		const span = { traceId: "abc", spans: [{ name: "op1" }] };
-		const { src, send, complete } = manualSource<typeof span>();
-		const { dispose: unsub } = toTempo(src, client);
-		send(span);
-		complete();
-		await tick();
-		expect(pushes).toHaveLength(1);
-		expect((pushes[0] as { resourceSpans: unknown[] }).resourceSpans).toEqual([span]);
-		unsub();
-	});
-});
-
-// ——————————————————————————————————————————————————————————————
-//  checkpointToS3
-// ——————————————————————————————————————————————————————————————
-
-describe("checkpointToS3", () => {
-	it("attaches a storage tier that saves to S3", () => {
-		const saved: unknown[] = [];
-		const s3: S3ClientLike = {
-			putObject: async (params) => {
-				saved.push(params);
-			},
-		};
-		type Tier = { save(data: unknown): void | Promise<void> };
-		let capturedTier: Tier | undefined;
-		const mockGraph = {
-			name: "test-graph",
-			attachSnapshotStorage: (pairs: readonly { snapshot: Tier }[], _opts?: unknown) => {
-				capturedTier = pairs[0]?.snapshot;
-				return { dispose: () => {} };
-			},
-		};
-		const handle = checkpointToS3(mockGraph, s3, "my-bucket", { prefix: "cp/" });
-		expect(handle.dispose).toBeTypeOf("function");
-		capturedTier!.save({ name: "test-graph", snapshot: true });
-		expect(saved).toHaveLength(1);
-		const params = saved[0] as { Bucket: string; Key: string };
-		expect(params.Bucket).toBe("my-bucket");
-		expect(params.Key).toMatch(/^cp\/test-graph\/checkpoint-/);
-	});
-
-	// F-B-class smell sweep (2026-05-18) — F-CKPT: a dropped checkpoint write
-	// is silent data loss. The default `onError` now surfaces via console.error
-	// (mirrors budgetGate A3) instead of being fully swallowed.
-	it("F-CKPT: default onError surfaces a serialize failure via console.error", () => {
-		const errSpy = vi.spyOn(console, "error").mockImplementation(() => {});
-		type Tier = { save(data: unknown): void | Promise<void> };
-		let capturedTier: Tier | undefined;
-		const mockGraph = {
-			name: "g",
-			attachSnapshotStorage: (pairs: readonly { snapshot: Tier }[]) => {
-				capturedTier = pairs[0]?.snapshot;
-				return { dispose: () => {} };
-			},
-		};
-		checkpointToS3(mockGraph, { putObject: async () => {} }, "b");
-		const circular: Record<string, unknown> = {};
-		circular.self = circular; // JSON.stringify throws
-		capturedTier!.save(circular);
-		expect(errSpy).toHaveBeenCalledWith(
-			expect.stringContaining("checkpointToS3(b): checkpoint persistence failed"),
-			expect.anything(),
-		);
-		errSpy.mockRestore();
-	});
-
-	it("F-CKPT: explicit no-op onError suppresses the default console.error", () => {
-		const errSpy = vi.spyOn(console, "error").mockImplementation(() => {});
-		type Tier = { save(data: unknown): void | Promise<void> };
-		let capturedTier: Tier | undefined;
-		const mockGraph = {
-			name: "g",
-			attachSnapshotStorage: (pairs: readonly { snapshot: Tier }[]) => {
-				capturedTier = pairs[0]?.snapshot;
-				return { dispose: () => {} };
-			},
-		};
-		checkpointToS3(mockGraph, { putObject: async () => {} }, "b", { onError: () => {} });
-		const circular: Record<string, unknown> = {};
-		circular.self = circular;
-		capturedTier!.save(circular);
-		expect(errSpy).not.toHaveBeenCalled();
-		errSpy.mockRestore();
-	});
-});
-
-// ——————————————————————————————————————————————————————————————
-//  checkpointToRedis
-// ——————————————————————————————————————————————————————————————
-
-describe("checkpointToRedis", () => {
-	it("attaches a storage tier that saves to Redis", () => {
-		const saved: { key: string; value: string }[] = [];
-		const redis = {
-			set: async (key: string, value: string) => {
-				saved.push({ key, value });
-			},
-			get: async () => null,
-		};
-		type Tier = { save(data: unknown): void | Promise<void> };
-		let capturedTier: Tier | undefined;
-		const mockGraph = {
-			name: "my-graph",
-			attachSnapshotStorage: (pairs: readonly { snapshot: Tier }[], _opts?: unknown) => {
-				capturedTier = pairs[0]?.snapshot;
-				return { dispose: () => {} };
-			},
-		};
-		const handle = checkpointToRedis(mockGraph, redis);
-		expect(handle.dispose).toBeTypeOf("function");
-		capturedTier!.save({ name: "my-graph", snapshot: true });
-		expect(saved).toHaveLength(1);
-		expect(saved[0].key).toBe("graphrefly:checkpoint:my-graph");
-		expect(JSON.parse(saved[0].value)).toEqual({ name: "my-graph", snapshot: true });
-	});
-});
-
-// ——————————————————————————————————————————————————————————————
-//  fromSqlite
-// ——————————————————————————————————————————————————————————————
-
-describe("fromSqlite", () => {
-	it("emits a single DATA with the rows array then COMPLETE", () => {
-		const rows = [
-			{ id: 1, name: "Alice" },
-			{ id: 2, name: "Bob" },
-		];
-		const db: SqliteDbLike = { query: () => rows };
-		const { msgs } = collectFlat(fromSqlite(db, "SELECT * FROM users"));
-		expect(msgs).toEqual([[DIRTY], [DATA, rows], [COMPLETE]]);
-	});
-
-	it("passes params to db.query", () => {
-		let captured: unknown[] | undefined;
-		const db: SqliteDbLike = {
-			query: (_sql, params) => {
-				captured = params;
-				return [{ x: 1 }];
-			},
-		};
-		fromSqlite(db, "SELECT * FROM t WHERE id = ?", { params: [42] }).subscribe(() => {});
-		expect(captured).toEqual([42]);
-	});
-
-	it("applies mapRow to each row (array-emit)", () => {
-		const db: SqliteDbLike = { query: () => [{ v: 10 }, { v: 20 }] };
-		let received: number[] | undefined;
-		fromSqlite<number>(db, "SELECT v FROM t", {
-			mapRow: (r) => (r as { v: number }).v * 2,
-		}).subscribe((m) => {
-			for (const msg of m) if (msg[0] === DATA) received = msg[1] as number[];
-		});
-		expect(received).toEqual([20, 40]);
-	});
-
-	it("emits ERROR when db.query throws", () => {
-		const db: SqliteDbLike = {
-			query: () => {
-				throw new Error("no such table");
-			},
-		};
-		const { msgs } = collectFlat(fromSqlite(db, "SELECT * FROM missing"));
-		expect(msgs).toHaveLength(1);
-		expect(msgs[0][0]).toBe(ERROR);
-		expect((msgs[0][1] as Error).message).toBe("no such table");
-	});
-
-	it("emits empty array DATA + COMPLETE with zero rows", () => {
-		const db: SqliteDbLike = { query: () => [] };
-		const { msgs } = collectFlat(fromSqlite(db, "SELECT * FROM empty"));
-		expect(msgs).toEqual([[DIRTY], [DATA, []], [COMPLETE]]);
-	});
-
-	it("emits ERROR with no partial DATA when mapRow throws", () => {
-		let callCount = 0;
-		const db: SqliteDbLike = { query: () => [{ v: 1 }, { v: 2 }, { v: 3 }] };
-		const { msgs } = collectFlat(
-			fromSqlite(db, "SELECT v FROM t", {
-				mapRow: (r) => {
-					callCount++;
-					if (callCount === 2) throw new Error("bad row");
-					return r;
-				},
-			}),
-		);
-		expect(msgs).toHaveLength(1);
-		expect(msgs[0][0]).toBe(ERROR);
-		expect((msgs[0][1] as Error).message).toBe("bad row");
-	});
-});
-
-// ——————————————————————————————————————————————————————————————
-//  toSqlite
-// ——————————————————————————————————————————————————————————————
-
-describe("toSqlite", () => {
-	it("inserts each value as a row", () => {
-		const queries: { sql: string; params: unknown[] }[] = [];
-		const db: SqliteDbLike = {
-			query: (sql, params) => {
-				queries.push({ sql, params: params ?? [] });
-				return [];
-			},
-		};
-		const { src, send, complete } = manualSource<Record<string, number>>();
-		const { dispose: unsub } = toSqlite(src, db, "events");
-		send({ x: 1 });
-		send({ x: 2 });
-		complete();
-		expect(queries).toHaveLength(2);
-		expect(queries[0].sql).toContain('INSERT INTO "events"');
-		expect(queries[0].params[0]).toBe(JSON.stringify({ x: 1 }));
-		unsub();
-	});
-
-	it("uses custom toSQL", () => {
-		const queries: { sql: string; params: unknown[] }[] = [];
-		const db: SqliteDbLike = {
-			query: (sql, params) => {
-				queries.push({ sql, params: params ?? [] });
-				return [];
-			},
-		};
-		const src = fromIter([42]);
-		const { dispose: unsub } = toSqlite(src, db, "nums", {
-			toSQL: (v, t) => ({ sql: `INSERT INTO "${t}" (n) VALUES (?)`, params: [v] }),
-		});
-		expect(queries[0].params).toEqual([42]);
-		unsub();
-	});
-
-	it("reports toSQL errors via onTransportError (serialize stage)", () => {
-		const errors: unknown[] = [];
-		const db: SqliteDbLike = { query: () => [] };
-		const { src, send } = manualSource<number>();
-		const { dispose: unsub } = toSqlite(src, db, "t", {
-			toSQL: () => {
-				throw new Error("bad sql");
-			},
-			onTransportError: (e) => errors.push(e),
-		});
-		send(1);
-		expect(errors).toHaveLength(1);
-		expect((errors[0] as { stage: string }).stage).toBe("serialize");
-		unsub();
-	});
-
-	it("reports db.query errors via onTransportError (send stage)", () => {
-		const errors: unknown[] = [];
-		const db: SqliteDbLike = {
-			query: () => {
-				throw new Error("disk full");
-			},
-		};
-		const { src, send } = manualSource<number>();
-		const { dispose: unsub } = toSqlite(src, db, "t", {
-			onTransportError: (e) => errors.push(e),
-		});
-		send(1);
-		expect(errors).toHaveLength(1);
-		expect((errors[0] as { stage: string }).stage).toBe("send");
-		expect((errors[0] as { error: Error }).error.message).toBe("disk full");
-		unsub();
-	});
-
-	it("errors node receives errors without callback", () => {
-		const db: SqliteDbLike = {
-			query: () => {
-				throw new Error("disk full");
-			},
-		};
-		const src = fromIter([1]);
-		const handle = toSqlite(src, db, "t");
-		expect(handle.errors.cache).not.toBeNull();
-		expect((handle.errors.cache as { stage: string }).stage).toBe("send");
-		handle.dispose();
-	});
-
-	it("rejects empty table name", () => {
-		const db: SqliteDbLike = { query: () => [] };
-		const src = fromIter([1]);
-		expect(() => toSqlite(src, db, "")).toThrow("invalid table name");
-	});
-
-	it("rejects table name with null byte", () => {
-		const db: SqliteDbLike = { query: () => [] };
-		const src = fromIter([1]);
-		expect(() => toSqlite(src, db, "foo\x00bar")).toThrow("invalid table name");
-	});
-
-	it("batchInsert wraps inserts in a transaction", () => {
-		const queries: string[] = [];
-		const db: SqliteDbLike = {
-			query: (sql, _params) => {
-				queries.push(sql);
-				return [];
-			},
-		};
-		const src = fromIter([{ x: 1 }, { x: 2 }, { x: 3 }]);
-		const { dispose: unsub } = toSqlite(src, db, "events", { batchInsert: true });
-		// Should see: BEGIN, 3 inserts, COMMIT
-		expect(queries[0]).toBe("BEGIN");
-		expect(queries.filter((q) => q.includes("INSERT"))).toHaveLength(3);
-		expect(queries[queries.length - 1]).toBe("COMMIT");
-		unsub();
-	});
-
-	it("batchInsert rolls back on first error and stops remaining inserts (EC4)", () => {
-		const queries: string[] = [];
-		const errors: unknown[] = [];
-		let callCount = 0;
-		const db: SqliteDbLike = {
-			query: (sql, _params) => {
-				queries.push(sql);
-				if (sql.includes("INSERT")) {
-					callCount++;
-					if (callCount === 2) throw new Error("constraint violation");
-				}
-				return [];
-			},
-		};
-		const src = fromIter([1, 2, 3]);
-		const { dispose: unsub } = toSqlite(src, db, "t", {
-			batchInsert: true,
-			onTransportError: (e) => errors.push(e),
-		});
-		expect(queries).toContain("BEGIN");
-		expect(queries).toContain("ROLLBACK");
-		expect(queries).not.toContain("COMMIT");
-		// EC4: only 2 INSERTs attempted (stops on first error, 3rd not attempted)
-		expect(queries.filter((q) => q.includes("INSERT"))).toHaveLength(2);
-		expect(errors).toHaveLength(1);
-		expect((errors[0] as { stage: string }).stage).toBe("send");
-		unsub();
-	});
-
-	it("batchInsert with no DATA does not emit transaction statements", () => {
-		const queries: string[] = [];
-		const db: SqliteDbLike = {
-			query: (sql) => {
-				queries.push(sql);
-				return [];
-			},
-		};
-		const src = fromIter<number>([]);
-		const { dispose: unsub } = toSqlite(src, db, "t", { batchInsert: true });
-		expect(queries.filter((q) => q === "BEGIN")).toHaveLength(0);
-		unsub();
-	});
-
-	it("batchInsert reports BEGIN failure without losing pending data (P1)", () => {
-		const errors: unknown[] = [];
-		let beginFails = true;
-		const queries: string[] = [];
-		const db: SqliteDbLike = {
-			query: (sql) => {
-				queries.push(sql);
-				if (sql === "BEGIN" && beginFails) throw new Error("locked");
-				return [];
-			},
-		};
-		const { src, send, complete } = manualSource<number>();
-		const handle = toSqlite(src, db, "t", {
-			batchInsert: true,
-			onTransportError: (e) => errors.push(e),
-		});
-		send(1);
-		complete();
-		// COMPLETE triggered flush, BEGIN failed — error reported
-		expect(errors).toHaveLength(1);
-		expect((errors[0] as { error: Error }).error.message).toBe("locked");
-		// No INSERTs attempted since BEGIN failed
-		expect(queries.filter((q) => q.includes("INSERT"))).toHaveLength(0);
-		// Manual flush after fixing the db succeeds — data was preserved
-		beginFails = false;
-		handle.flush!();
-		expect(queries).toContain("BEGIN");
-		expect(queries.filter((q) => q.includes("INSERT"))).toHaveLength(1);
-		expect(queries[queries.length - 1]).toBe("COMMIT");
-		handle.dispose();
-	});
-
-	it("batchInsert auto-flushes at maxBatchSize (BH10)", () => {
-		const queries: string[] = [];
-		const db: SqliteDbLike = {
-			query: (sql) => {
-				queries.push(sql);
-				return [];
-			},
-		};
-		const src = fromIter([1, 2, 3, 4, 5]);
-		const { dispose: unsub } = toSqlite(src, db, "t", {
-			batchInsert: true,
-			maxBatchSize: 2,
-		});
-		// 2 transactions: [1,2] auto-flushed at maxBatchSize, [3,4] auto-flushed, [5] flushed on COMPLETE
-		const begins = queries.filter((q) => q === "BEGIN");
-		const commits = queries.filter((q) => q === "COMMIT");
-		expect(begins.length).toBe(3);
-		expect(commits.length).toBe(3);
-		expect(queries.filter((q) => q.includes("INSERT"))).toHaveLength(5);
-		unsub();
-	});
-
-	it("batchInsert flushes remaining on dispose (P3)", () => {
-		const queries: string[] = [];
-		const db: SqliteDbLike = {
-			query: (sql) => {
-				queries.push(sql);
-				return [];
-			},
-		};
-		// Use a node with no initial value so push-on-subscribe does not fire
-		const s = node<number>();
-		const handle = toSqlite(s, db, "t", { batchInsert: true });
-		s.down([[DATA, 1]]);
-		s.down([[DATA, 2]]);
-		// 2 pending inserts, no terminal message → no flush yet
-		expect(queries.filter((q) => q === "BEGIN")).toHaveLength(0);
-		handle.dispose();
-		// dispose triggers final flush
-		expect(queries).toContain("BEGIN");
-		expect(queries).toContain("COMMIT");
-		expect(queries.filter((q) => q.includes("INSERT"))).toHaveLength(2);
-	});
-
-	it("batchInsert dispose is idempotent (BH6)", () => {
-		const queries: string[] = [];
-		const db: SqliteDbLike = {
-			query: (sql) => {
-				queries.push(sql);
-				return [];
-			},
-		};
-		const { src, send, complete } = manualSource<number>();
-		const handle = toSqlite(src, db, "t", { batchInsert: true });
-		send(1);
-		complete();
-		const countBefore = queries.length;
-		handle.dispose();
-		handle.dispose(); // second call should be no-op
-		expect(queries.length).toBe(countBefore);
-	});
-});
-
-// ——————————————————————————————————————————————————————————————
-//  fromPrisma
-// ——————————————————————————————————————————————————————————————
-
-describe("fromPrisma", () => {
-	it("emits a single DATA with the rows array then COMPLETE", async () => {
-		const rows = [
-			{ id: 1, name: "Alice" },
-			{ id: 2, name: "Bob" },
-		];
-		const model: PrismaModelLike = { findMany: () => Promise.resolve(rows) };
-		const { msgs } = collectFlat(fromPrisma(model));
-		await tick();
-		expect(msgs).toEqual([[DIRTY], [DATA, rows], [COMPLETE]]);
-	});
-
-	it("forwards findMany args", async () => {
-		let captured: unknown;
-		const model: PrismaModelLike = {
-			findMany: (args) => {
-				captured = args;
-				return Promise.resolve([]);
-			},
-		};
-		fromPrisma(model, { args: { where: { active: true } } }).subscribe(() => {});
-		await tick();
-		expect(captured).toEqual({ where: { active: true } });
-	});
-
-	it("applies mapRow across array elements", async () => {
-		const model: PrismaModelLike<{ v: number }> = {
-			findMany: () => Promise.resolve([{ v: 10 }, { v: 20 }]),
-		};
-		let received: number[] | undefined;
-		fromPrisma<{ v: number }, number>(model, {
-			mapRow: (r) => r.v * 2,
-		}).subscribe((m) => {
-			for (const msg of m) if (msg[0] === DATA) received = msg[1] as number[];
-		});
-		await tick();
-		expect(received).toEqual([20, 40]);
-	});
-
-	it("emits ERROR on query failure", async () => {
-		const model: PrismaModelLike = {
-			findMany: () => Promise.reject(new Error("connection lost")),
-		};
-		const { msgs } = collectFlat(fromPrisma(model));
-		await tick();
-		expect(msgs).toHaveLength(1);
-		expect(msgs[0][0]).toBe(ERROR);
-		expect((msgs[0][1] as Error).message).toBe("connection lost");
-	});
-
-	it("emits empty array DATA + COMPLETE for empty result", async () => {
-		const model: PrismaModelLike = { findMany: () => Promise.resolve([]) };
-		const { msgs } = collectFlat(fromPrisma(model));
-		await tick();
-		expect(msgs).toEqual([[DIRTY], [DATA, []], [COMPLETE]]);
-	});
-
-	it("cleanup prevents late emission", async () => {
-		let resolveFn!: (v: unknown[]) => void;
-		const model: PrismaModelLike = {
-			findMany: () =>
-				new Promise((r) => {
-					resolveFn = r;
-				}),
-		};
-		const { msgs, unsub } = collectFlat(fromPrisma(model));
-		unsub();
-		resolveFn([{ id: 1 }]);
-		await tick();
-		expect(msgs).toEqual([]);
-	});
-
-	it("emits ERROR when mapRow throws", async () => {
-		const model: PrismaModelLike = {
-			findMany: () => Promise.resolve([{ id: 1 }]),
-		};
-		const { msgs } = collectFlat(
-			fromPrisma(model, {
-				mapRow: () => {
-					throw new Error("bad map");
-				},
-			}),
-		);
-		await tick();
-		expect(msgs).toHaveLength(1);
-		expect(msgs[0][0]).toBe(ERROR);
-		expect((msgs[0][1] as Error).message).toBe("bad map");
-	});
-});
-
-// ——————————————————————————————————————————————————————————————
-//  fromDrizzle
-// ——————————————————————————————————————————————————————————————
-
-describe("fromDrizzle", () => {
-	it("emits a single DATA with the rows array then COMPLETE", async () => {
-		const rows = [{ id: 1 }, { id: 2 }];
-		const query: DrizzleQueryLike = { execute: () => Promise.resolve(rows) };
-		const { msgs } = collectFlat(fromDrizzle(query));
-		await tick();
-		expect(msgs).toEqual([[DIRTY], [DATA, rows], [COMPLETE]]);
-	});
-
-	it("applies mapRow across array elements", async () => {
-		const query: DrizzleQueryLike<{ v: number }> = {
-			execute: () => Promise.resolve([{ v: 5 }]),
-		};
-		let received: number[] | undefined;
-		fromDrizzle<{ v: number }, number>(query, {
-			mapRow: (r) => r.v + 1,
-		}).subscribe((m) => {
-			for (const msg of m) if (msg[0] === DATA) received = msg[1] as number[];
-		});
-		await tick();
-		expect(received).toEqual([6]);
-	});
-
-	it("emits ERROR on query failure", async () => {
-		const query: DrizzleQueryLike = {
-			execute: () => Promise.reject(new Error("timeout")),
-		};
-		const { msgs } = collectFlat(fromDrizzle(query));
-		await tick();
-		expect(msgs).toHaveLength(1);
-		expect(msgs[0][0]).toBe(ERROR);
-		expect((msgs[0][1] as Error).message).toBe("timeout");
-	});
-
-	it("emits empty array DATA + COMPLETE for empty result", async () => {
-		const query: DrizzleQueryLike = { execute: () => Promise.resolve([]) };
-		const { msgs } = collectFlat(fromDrizzle(query));
-		await tick();
-		expect(msgs).toEqual([[DIRTY], [DATA, []], [COMPLETE]]);
-	});
-
-	it("cleanup prevents late emission", async () => {
-		let resolveFn!: (v: unknown[]) => void;
-		const query: DrizzleQueryLike = {
-			execute: () =>
-				new Promise((r) => {
-					resolveFn = r;
-				}),
-		};
-		const { msgs, unsub } = collectFlat(fromDrizzle(query));
-		unsub();
-		resolveFn([{ id: 1 }]);
-		await tick();
-		expect(msgs).toEqual([]);
-	});
-
-	it("emits ERROR when mapRow throws", async () => {
-		const query: DrizzleQueryLike = {
-			execute: () => Promise.resolve([{ id: 1 }]),
-		};
-		const { msgs } = collectFlat(
-			fromDrizzle(query, {
-				mapRow: () => {
-					throw new Error("bad map");
-				},
-			}),
-		);
-		await tick();
-		expect(msgs).toHaveLength(1);
-		expect(msgs[0][0]).toBe(ERROR);
-		expect((msgs[0][1] as Error).message).toBe("bad map");
-	});
-});
-
-// ——————————————————————————————————————————————————————————————
-//  fromKysely
-// ——————————————————————————————————————————————————————————————
-
-describe("fromKysely", () => {
-	it("emits a single DATA with the rows array then COMPLETE", async () => {
-		const rows = [{ name: "Alice" }, { name: "Bob" }];
-		const query: KyselyQueryLike = { execute: () => Promise.resolve(rows) };
-		const { msgs } = collectFlat(fromKysely(query));
-		await tick();
-		expect(msgs).toEqual([[DIRTY], [DATA, rows], [COMPLETE]]);
-	});
-
-	it("applies mapRow across array elements", async () => {
-		const query: KyselyQueryLike<{ score: number }> = {
-			execute: () => Promise.resolve([{ score: 100 }]),
-		};
-		let received: string[] | undefined;
-		fromKysely<{ score: number }, string>(query, {
-			mapRow: (r) => `score:${r.score}`,
-		}).subscribe((m) => {
-			for (const msg of m) if (msg[0] === DATA) received = msg[1] as string[];
-		});
-		await tick();
-		expect(received).toEqual(["score:100"]);
-	});
-
-	it("emits ERROR on query failure", async () => {
-		const query: KyselyQueryLike = {
-			execute: () => Promise.reject(new Error("syntax error")),
-		};
-		const { msgs } = collectFlat(fromKysely(query));
-		await tick();
-		expect(msgs).toHaveLength(1);
-		expect(msgs[0][0]).toBe(ERROR);
-		expect((msgs[0][1] as Error).message).toBe("syntax error");
-	});
-
-	it("emits empty array DATA + COMPLETE for empty result", async () => {
-		const query: KyselyQueryLike = { execute: () => Promise.resolve([]) };
-		const { msgs } = collectFlat(fromKysely(query));
-		await tick();
-		expect(msgs).toEqual([[DIRTY], [DATA, []], [COMPLETE]]);
-	});
-
-	it("cleanup prevents late emission", async () => {
-		let resolveFn!: (v: unknown[]) => void;
-		const query: KyselyQueryLike = {
-			execute: () =>
-				new Promise((r) => {
-					resolveFn = r;
-				}),
-		};
-		const { msgs, unsub } = collectFlat(fromKysely(query));
-		unsub();
-		resolveFn([{ id: 1 }]);
-		await tick();
-		expect(msgs).toEqual([]);
-	});
-
-	it("emits ERROR when mapRow throws", async () => {
-		const query: KyselyQueryLike = {
-			execute: () => Promise.resolve([{ id: 1 }]),
-		};
-		const { msgs } = collectFlat(
-			fromKysely(query, {
-				mapRow: () => {
-					throw new Error("bad map");
-				},
-			}),
-		);
-		await tick();
-		expect(msgs).toHaveLength(1);
-		expect(msgs[0][0]).toBe(ERROR);
-		expect((msgs[0][1] as Error).message).toBe("bad map");
-	});
-});
diff --git a/src/__tests__/utils/ai/adapters/adaptive-rate-limiter.test.ts b/src/__tests__/utils/ai/adapters/adaptive-rate-limiter.test.ts
deleted file mode 100644
index ee224a04..00000000
--- a/src/__tests__/utils/ai/adapters/adaptive-rate-limiter.test.ts
+++ /dev/null
@@ -1,51 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-	adaptiveRateLimiter,
-	type RateLimitSignal,
-} from "../../../../utils/resilience/adaptive-rate-limiter.js";
-
-describe("adaptiveRateLimiter", () => {
-	it("acquire() resolves when rpm has capacity", async () => {
-		const limiter = adaptiveRateLimiter({ rpm: 60 });
-		await limiter.acquire();
-		await limiter.acquire();
-		limiter.dispose();
-	});
-
-	it("recordSignal with retryAfterMs blocks acquire", async () => {
-		const limiter = adaptiveRateLimiter({ rpm: 60 });
-		limiter.recordSignal({ retryAfterMs: 200 } as RateLimitSignal);
-		const start = Date.now();
-		await limiter.acquire();
-		const elapsed = Date.now() - start;
-		// Should wait at least close to 200ms.
-		expect(elapsed).toBeGreaterThanOrEqual(150);
-		limiter.dispose();
-	});
-
-	it("recordSignal with rpmCap tightens effective rpm", async () => {
-		const limiter = adaptiveRateLimiter({ rpm: 1000 });
-		expect(limiter.effectiveRpm.cache).toBe(1000);
-		limiter.recordSignal({ rpmCap: 5 } as RateLimitSignal);
-		expect(limiter.effectiveRpm.cache).toBe(5);
-		limiter.dispose();
-	});
-
-	it("lastSignal exposes the last recorded signal", async () => {
-		const limiter = adaptiveRateLimiter({ rpm: 60 });
-		limiter.recordSignal({ rpmCap: 30 } as RateLimitSignal);
-		expect(limiter.lastSignal.cache?.rpmCap).toBe(30);
-		limiter.dispose();
-	});
-
-	it("abort signal cancels a pending acquire", async () => {
-		const limiter = adaptiveRateLimiter({ rpm: 1 });
-		// Consume the one token.
-		await limiter.acquire();
-		const ac = new AbortController();
-		const promise = limiter.acquire({ signal: ac.signal });
-		ac.abort();
-		await expect(promise).rejects.toThrow(/abort/i);
-		limiter.dispose();
-	});
-});
diff --git a/src/__tests__/utils/ai/adapters/anthropic-mapping.test.ts b/src/__tests__/utils/ai/adapters/anthropic-mapping.test.ts
deleted file mode 100644
index 198ee720..00000000
--- a/src/__tests__/utils/ai/adapters/anthropic-mapping.test.ts
+++ /dev/null
@@ -1,113 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { anthropicAdapter } from "../../../../utils/ai/adapters/providers/anthropic.js";
-
-/** Build a mock fetch returning a fixed JSON body. */
-function mockFetch(body: unknown, opts?: { status?: number; contentType?: string }): typeof fetch {
-	return (async () =>
-		new Response(JSON.stringify(body), {
-			status: opts?.status ?? 200,
-			headers: { "content-type": opts?.contentType ?? "application/json" },
-		})) as unknown as typeof fetch;
-}
-
-describe("AnthropicAdapter usage mapping (fetch backend)", () => {
-	it("maps cache_creation.ephemeral_5m/1h and cache_read to TokenUsage classes", async () => {
-		const adapter = anthropicAdapter({
-			apiKey: "test",
-			model: "claude-sonnet-4-6",
-			fetchImpl: mockFetch({
-				id: "msg_1",
-				content: [{ type: "text", text: "hello" }],
-				stop_reason: "end_turn",
-				model: "claude-sonnet-4-6",
-				usage: {
-					input_tokens: 100,
-					output_tokens: 50,
-					cache_read_input_tokens: 200,
-					cache_creation: {
-						ephemeral_5m_input_tokens: 300,
-						ephemeral_1h_input_tokens: 400,
-					},
-				},
-			}),
-		});
-		const resp = await Promise.resolve(adapter.invoke([{ role: "user", content: "hi" }]));
-		expect(resp.content).toBe("hello");
-		expect(resp.usage.input.regular).toBe(100);
-		expect(resp.usage.output.regular).toBe(50);
-		expect(resp.usage.input.cacheRead).toBe(200);
-		expect(resp.usage.input.cacheWrite5m).toBe(300);
-		expect(resp.usage.input.cacheWrite1h).toBe(400);
-		expect(resp.usage.raw).toBeDefined();
-	});
-
-	it("falls back to cache_creation_input_tokens legacy field → cacheWrite5m", async () => {
-		const adapter = anthropicAdapter({
-			apiKey: "test",
-			model: "claude-sonnet-4-6",
-			fetchImpl: mockFetch({
-				id: "msg_1",
-				content: [{ type: "text", text: "x" }],
-				usage: {
-					input_tokens: 10,
-					output_tokens: 5,
-					cache_creation_input_tokens: 500,
-				},
-			}),
-		});
-		const resp = await Promise.resolve(adapter.invoke([{ role: "user", content: "hi" }]));
-		expect(resp.usage.input.cacheWrite5m).toBe(500);
-		expect(resp.usage.input.cacheWrite1h).toBeUndefined();
-	});
-
-	it("maps server_tool_use.web_search_requests to auxiliary", async () => {
-		const adapter = anthropicAdapter({
-			apiKey: "test",
-			model: "claude-sonnet-4-6",
-			fetchImpl: mockFetch({
-				content: [{ type: "text", text: "x" }],
-				usage: {
-					input_tokens: 10,
-					output_tokens: 5,
-					server_tool_use: { web_search_requests: 3 },
-				},
-			}),
-		});
-		const resp = await Promise.resolve(adapter.invoke([{ role: "user", content: "hi" }]));
-		expect(resp.usage.auxiliary?.webSearchRequests).toBe(3);
-	});
-
-	it("extracts tool_use blocks into toolCalls", async () => {
-		const adapter = anthropicAdapter({
-			apiKey: "test",
-			model: "claude-sonnet-4-6",
-			fetchImpl: mockFetch({
-				content: [
-					{ type: "text", text: "let me check" },
-					{ type: "tool_use", id: "tool_1", name: "get_weather", input: { city: "SF" } },
-				],
-				usage: { input_tokens: 10, output_tokens: 5 },
-			}),
-		});
-		const resp = await Promise.resolve(adapter.invoke([{ role: "user", content: "hi" }]));
-		expect(resp.toolCalls).toHaveLength(1);
-		expect(resp.toolCalls?.[0].name).toBe("get_weather");
-		expect(resp.toolCalls?.[0].arguments).toEqual({ city: "SF" });
-	});
-
-	it("throws HTTP error with status + headers", async () => {
-		const adapter = anthropicAdapter({
-			apiKey: "test",
-			model: "claude-sonnet-4-6",
-			fetchImpl: mockFetch({ error: "quota" }, { status: 429 }),
-		});
-		try {
-			await Promise.resolve(adapter.invoke([{ role: "user", content: "hi" }]));
-			throw new Error("expected throw");
-		} catch (err) {
-			const e = err as { status?: number; headers?: Headers };
-			expect(e.status).toBe(429);
-			expect(e.headers).toBeInstanceOf(Headers);
-		}
-	});
-});
diff --git a/src/__tests__/utils/ai/adapters/capabilities.test.ts b/src/__tests__/utils/ai/adapters/capabilities.test.ts
deleted file mode 100644
index df4b127e..00000000
--- a/src/__tests__/utils/ai/adapters/capabilities.test.ts
+++ /dev/null
@@ -1,49 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-	createCapabilitiesRegistry,
-	type ModelCapabilities,
-} from "../../../../utils/ai/adapters/core/capabilities.js";
-
-const cap = (
-	id: string,
-	provider: string,
-	extra?: Partial<ModelCapabilities>,
-): ModelCapabilities => ({
-	id,
-	provider,
-	...extra,
-});
-
-describe("CapabilitiesRegistry", () => {
-	it("exact and prefix lookup", () => {
-		const reg = createCapabilitiesRegistry();
-		const c1 = cap("claude-sonnet-4-6", "anthropic", { limits: { contextWindow: 200_000 } });
-		reg.register(c1);
-		expect(reg.lookup("anthropic", "claude-sonnet-4-6")).toBe(c1);
-		expect(reg.lookup("anthropic", "claude-sonnet-4-6-20260401")).toBe(c1);
-	});
-
-	it("exact wins over prefix (longest match)", () => {
-		const reg = createCapabilitiesRegistry();
-		const short = cap("gpt-5", "openai");
-		const long = cap("gpt-5.2", "openai");
-		reg.register(short);
-		reg.register(long);
-		expect(reg.lookup("openai", "gpt-5.2-codex")).toBe(long);
-	});
-
-	it("initial seed works", () => {
-		const reg = createCapabilitiesRegistry([cap("a", "p1"), cap("b", "p2")]);
-		expect(reg.lookup("p1", "a")?.id).toBe("a");
-		expect(reg.lookup("p2", "b")?.id).toBe("b");
-	});
-
-	it("remove + entries", () => {
-		const reg = createCapabilitiesRegistry();
-		reg.register(cap("a", "p"));
-		reg.register(cap("b", "p"));
-		expect([...reg.entries()].length).toBe(2);
-		reg.remove("p", "a");
-		expect([...reg.entries()].length).toBe(1);
-	});
-});
diff --git a/src/__tests__/utils/ai/adapters/cascading-cache.test.ts b/src/__tests__/utils/ai/adapters/cascading-cache.test.ts
deleted file mode 100644
index 0f2b998d..00000000
--- a/src/__tests__/utils/ai/adapters/cascading-cache.test.ts
+++ /dev/null
@@ -1,234 +0,0 @@
-import { TEARDOWN } from "@graphrefly/pure-ts/core";
-import type { KvStorageTier } from "@graphrefly/pure-ts/extra";
-import { cascadingCache, lru } from "@graphrefly/pure-ts/extra";
-import { describe, expect, it } from "vitest";
-
-describe("lru eviction policy", () => {
-	it("evicts least-recently-used entries", () => {
-		const policy = lru<string>();
-		policy.insert("a");
-		policy.insert("b");
-		policy.insert("c");
-		expect(policy.size()).toBe(3);
-		const evicted = policy.evict(1);
-		expect(evicted).toEqual(["a"]);
-		expect(policy.size()).toBe(2);
-	});
-
-	it("touch moves entry to front", () => {
-		const policy = lru<string>();
-		policy.insert("a");
-		policy.insert("b");
-		policy.insert("c");
-		policy.touch("a");
-		const evicted = policy.evict(1);
-		expect(evicted).toEqual(["b"]);
-	});
-
-	it("delete removes entry", () => {
-		const policy = lru<string>();
-		policy.insert("a");
-		policy.insert("b");
-		policy.delete("a");
-		expect(policy.size()).toBe(1);
-		expect(policy.evict(1)).toEqual(["b"]);
-	});
-
-	it("insert is idempotent (touches existing)", () => {
-		const policy = lru<string>();
-		policy.insert("a");
-		policy.insert("b");
-		policy.insert("a");
-		const evicted = policy.evict(1);
-		expect(evicted).toEqual(["b"]);
-	});
-});
-
-describe("cascadingCache", () => {
-	function memTier<V>(): KvStorageTier & { store: Map<string, V> } {
-		const store = new Map<string, V>();
-		return {
-			name: "test-mem",
-			store,
-			load: (key) => (store.has(key) ? (store.get(key) as V) : undefined),
-			save: (key, value) => {
-				store.set(key, value as V);
-			},
-			delete: (key) => {
-				store.delete(key);
-			},
-		};
-	}
-
-	it("creates a state node per key and cascades on miss", () => {
-		const hot = memTier<number>();
-		const cold = memTier<number>();
-		cold.store.set("x", 42);
-
-		const c = cascadingCache<number>([hot, cold]);
-		const nd = c.load("x");
-		expect(nd.cache).toBe(42);
-		expect(hot.store.get("x")).toBe(42);
-	});
-
-	it("returns same node for repeated loads", () => {
-		const tier = memTier<number>();
-		tier.store.set("k", 1);
-		const c = cascadingCache<number>([tier]);
-		const n1 = c.load("k");
-		const n2 = c.load("k");
-		expect(n1).toBe(n2);
-	});
-
-	it("save updates existing node in-place", () => {
-		const tier = memTier<string>();
-		const c = cascadingCache<string>([tier]);
-		const nd = c.load("k");
-		expect(nd.cache).toBeUndefined();
-		c.save("k", "hello");
-		expect(nd.cache).toBe("hello");
-		expect(tier.store.get("k")).toBe("hello");
-	});
-
-	it("save creates new node if key not yet loaded", () => {
-		const tier = memTier<number>();
-		const c = cascadingCache<number>([tier]);
-		c.save("new", 99);
-		expect(c.has("new")).toBe(true);
-		expect(c.load("new").cache).toBe(99);
-	});
-
-	it("writeThrough saves to all tiers", () => {
-		const hot = memTier<number>();
-		const cold = memTier<number>();
-		const c = cascadingCache<number>([hot, cold], { writeThrough: true });
-		c.save("k", 7);
-		expect(hot.store.get("k")).toBe(7);
-		expect(cold.store.get("k")).toBe(7);
-	});
-
-	it("default save writes to first tier only", () => {
-		const hot = memTier<number>();
-		const cold = memTier<number>();
-		const c = cascadingCache<number>([hot, cold]);
-		c.save("k", 7);
-		expect(hot.store.get("k")).toBe(7);
-		expect(cold.store.has("k")).toBe(false);
-	});
-
-	it("invalidate re-cascades from tiers", () => {
-		const hot = memTier<number>();
-		const cold = memTier<number>();
-		cold.store.set("k", 10);
-		const c = cascadingCache<number>([hot, cold]);
-		const nd = c.load("k");
-		expect(nd.cache).toBe(10);
-
-		cold.store.set("k", 20);
-		hot.store.delete("k");
-		c.invalidate("k");
-		expect(nd.cache).toBe(20);
-		expect(hot.store.get("k")).toBe(20);
-	});
-
-	it("delete removes from all tiers and teardowns node", () => {
-		const tier = memTier<number>();
-		tier.store.set("k", 5);
-		const c = cascadingCache<number>([tier]);
-		const nd = c.load("k");
-
-		const msgs: unknown[][] = [];
-		nd.subscribe((m) => msgs.push([...m]));
-
-		c.delete("k");
-		expect(c.has("k")).toBe(false);
-		expect(tier.store.has("k")).toBe(false);
-		expect(msgs.some((batch) => batch.some((m: unknown) => (m as [symbol])[0] === TEARDOWN))).toBe(
-			true,
-		);
-	});
-
-	it("has and size", () => {
-		const tier = memTier<number>();
-		const c = cascadingCache<number>([tier]);
-		expect(c.size).toBe(0);
-		expect(c.has("a")).toBe(false);
-		c.load("a");
-		expect(c.has("a")).toBe(true);
-		expect(c.size).toBe(1);
-	});
-
-	it("evicts when maxSize exceeded", () => {
-		const tier = memTier<number>();
-		const c = cascadingCache<number>([tier], { maxSize: 2 });
-		c.save("a", 1);
-		c.save("b", 2);
-		c.save("c", 3);
-		expect(c.has("a")).toBe(false);
-		expect(c.has("b")).toBe(true);
-		expect(c.has("c")).toBe(true);
-		expect(c.size).toBe(2);
-	});
-
-	it("eviction demotes to deepest tier with save", () => {
-		const hot = memTier<number>();
-		const cold = memTier<number>();
-		const c = cascadingCache<number>([hot, cold], { maxSize: 1 });
-		c.save("a", 10);
-		c.save("b", 20);
-		expect(cold.store.get("a")).toBe(10);
-	});
-
-	it("skips tiers that throw on load", () => {
-		const broken: KvStorageTier = {
-			name: "broken",
-			load() {
-				throw new Error("boom");
-			},
-			save() {
-				/* no-op — tier is effectively read-only for this test */
-			},
-		};
-		const good = memTier<number>();
-		good.store.set("k", 42);
-		const c = cascadingCache<number>([broken, good]);
-		expect(c.load("k").cache).toBe(42);
-	});
-
-	it("all tiers miss → value stays undefined", () => {
-		const empty = memTier<number>();
-		const c = cascadingCache<number>([empty]);
-		expect(c.load("missing").cache).toBeUndefined();
-	});
-
-	it("async tier load resolves via Promise", async () => {
-		const cold: KvStorageTier = {
-			name: "cold-async",
-			load: async (key) => (key === "k" ? 123 : undefined),
-			save: () => {
-				/* no-op */
-			},
-		};
-		const c = cascadingCache<number>([cold]);
-		const nd = c.load("k");
-		expect(nd.cache).toBeUndefined();
-		await new Promise((r) => setTimeout(r, 0));
-		expect(nd.cache).toBe(123);
-	});
-
-	it("async tier promotes to sync hot tier on hit", async () => {
-		const hot = memTier<number>();
-		const cold: KvStorageTier = {
-			name: "cold-async-promote",
-			load: async (key) => (key === "k" ? 77 : undefined),
-			save: () => {
-				/* no-op */
-			},
-		};
-		const c = cascadingCache<number>([hot, cold]);
-		const nd = c.load("k");
-		await new Promise((r) => setTimeout(r, 0));
-		expect(nd.cache).toBe(77);
-		expect(hot.store.get("k")).toBe(77);
-	});
-});
diff --git a/src/__tests__/utils/ai/adapters/cascading.test.ts b/src/__tests__/utils/ai/adapters/cascading.test.ts
deleted file mode 100644
index 7ebe8543..00000000
--- a/src/__tests__/utils/ai/adapters/cascading.test.ts
+++ /dev/null
@@ -1,113 +0,0 @@
-import { describe, expect, it } from "vitest";
-import type { LLMAdapter, LLMResponse } from "../../../../utils/ai/adapters/core/types.js";
-import {
-	AllTiersExhaustedError,
-	cascadingLlmAdapter,
-} from "../../../../utils/ai/adapters/routing/cascading.js";
-
-function tierAdapter(responses: readonly (LLMResponse | Error)[]): LLMAdapter & { calls: number } {
-	let i = 0;
-	const adapter: LLMAdapter & { calls: number } = {
-		provider: "mock",
-		model: "m",
-		calls: 0,
-		invoke(): Promise<LLMResponse> {
-			adapter.calls += 1;
-			const next = responses[Math.min(i, responses.length - 1)];
-			i += 1;
-			return next instanceof Error ? Promise.reject(next) : Promise.resolve(next);
-		},
-		async *stream() {},
-	};
-	return adapter;
-}
-
-const okResp = (content = "ok"): LLMResponse => ({
-	content,
-	usage: { input: { regular: 0 }, output: { regular: 0 } },
-});
-
-describe("cascadingLlmAdapter", () => {
-	it("first success wins", async () => {
-		const t0 = tierAdapter([okResp("A")]);
-		const t1 = tierAdapter([okResp("B")]);
-		const adapter = cascadingLlmAdapter([
-			{ name: "tier-0", adapter: t0 },
-			{ name: "tier-1", adapter: t1 },
-		]);
-		const r = await Promise.resolve(adapter.invoke([{ role: "user", content: "x" }]));
-		expect(r.content).toBe("A");
-		expect(t0.calls).toBe(1);
-		expect(t1.calls).toBe(0);
-	});
-
-	it("falls through on error", async () => {
-		const t0 = tierAdapter([new Error("nope")]);
-		const t1 = tierAdapter([okResp("B")]);
-		const fallbacks: string[] = [];
-		const adapter = cascadingLlmAdapter(
-			[
-				{ name: "tier-0", adapter: t0 },
-				{ name: "tier-1", adapter: t1 },
-			],
-			{ onFallback: (from, to) => fallbacks.push(`${from}->${to}`) },
-		);
-		const r = await Promise.resolve(adapter.invoke([{ role: "user", content: "x" }]));
-		expect(r.content).toBe("B");
-		expect(t0.calls).toBe(1);
-		expect(t1.calls).toBe(1);
-		expect(fallbacks).toEqual(["tier-0->tier-1"]);
-	});
-
-	it("all tiers exhausted → throws with failed map", async () => {
-		const t0 = tierAdapter([new Error("a")]);
-		const t1 = tierAdapter([new Error("b")]);
-		const adapter = cascadingLlmAdapter([
-			{ name: "tier-0", adapter: t0 },
-			{ name: "tier-1", adapter: t1 },
-		]);
-		try {
-			await Promise.resolve(adapter.invoke([{ role: "user", content: "x" }]));
-			throw new Error("expected throw");
-		} catch (err) {
-			expect(err).toBeInstanceOf(AllTiersExhaustedError);
-			const e = err as AllTiersExhaustedError;
-			expect(e.failed.size).toBe(2);
-			expect(e.skipped).toHaveLength(0);
-		}
-	});
-
-	it("filter skip shows in `skipped`, not `failed`", async () => {
-		const t0 = tierAdapter([okResp("A")]);
-		const t1 = tierAdapter([new Error("b")]);
-		const adapter = cascadingLlmAdapter([
-			{ name: "tier-0", adapter: t0, filter: () => false },
-			{ name: "tier-1", adapter: t1 },
-		]);
-		try {
-			await Promise.resolve(adapter.invoke([{ role: "user", content: "x" }]));
-			throw new Error("expected throw");
-		} catch (err) {
-			const e = err as AllTiersExhaustedError;
-			expect(e.skipped).toEqual([{ name: "tier-0", reason: "filter" }]);
-			expect(e.failed.size).toBe(1);
-			expect(e.failed.has("tier-1")).toBe(true);
-		}
-	});
-
-	it("filter skips tier", async () => {
-		const t0 = tierAdapter([okResp("should-not-run")]);
-		const t1 = tierAdapter([okResp("used")]);
-		const adapter = cascadingLlmAdapter([
-			{ name: "tier-0", adapter: t0, filter: (_m, opts) => !opts?.tools },
-			{ name: "tier-1", adapter: t1 },
-		]);
-		const r = await Promise.resolve(
-			adapter.invoke([{ role: "user", content: "x" }], {
-				tools: [{ name: "t", description: "", parameters: {}, handler: () => null }],
-			}),
-		);
-		expect(r.content).toBe("used");
-		expect(t0.calls).toBe(0);
-	});
-});
diff --git a/src/__tests__/utils/ai/adapters/dry-run.test.ts b/src/__tests__/utils/ai/adapters/dry-run.test.ts
deleted file mode 100644
index e9465f60..00000000
--- a/src/__tests__/utils/ai/adapters/dry-run.test.ts
+++ /dev/null
@@ -1,32 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { dryRunAdapter } from "../../../../utils/ai/adapters/providers/dry-run.js";
-
-describe("DryRunAdapter", () => {
-	it("echoes last user message by default", async () => {
-		const adapter = dryRunAdapter();
-		const resp = await Promise.resolve(adapter.invoke([{ role: "user", content: "hello world" }]));
-		expect(resp.content).toMatch(/hello world/);
-		expect(resp.usage.input.regular).toBeGreaterThan(0);
-		expect(resp.usage.output.regular).toBeGreaterThan(0);
-	});
-
-	it("honors custom respond fn", async () => {
-		const adapter = dryRunAdapter({ respond: () => "scripted" });
-		const resp = await Promise.resolve(adapter.invoke([{ role: "user", content: "anything" }]));
-		expect(resp.content).toBe("scripted");
-	});
-
-	it("streams tokens + terminal usage + finish", async () => {
-		const adapter = dryRunAdapter({ respond: () => "abcdef", streamChunkSize: 2 });
-		const deltas: unknown[] = [];
-		for await (const d of adapter.stream([{ role: "user", content: "x" }])) {
-			deltas.push(d);
-		}
-		const tokens = deltas.filter((d) => (d as { type: string }).type === "token");
-		const usage = deltas.find((d) => (d as { type: string }).type === "usage");
-		const finish = deltas.find((d) => (d as { type: string }).type === "finish");
-		expect(tokens.length).toBe(3); // "ab" "cd" "ef"
-		expect(usage).toBeDefined();
-		expect(finish).toBeDefined();
-	});
-});
diff --git a/src/__tests__/utils/ai/adapters/fallback.test.ts b/src/__tests__/utils/ai/adapters/fallback.test.ts
deleted file mode 100644
index bf08463e..00000000
--- a/src/__tests__/utils/ai/adapters/fallback.test.ts
+++ /dev/null
@@ -1,267 +0,0 @@
-/**
- * Tests for `fallbackAdapter` — fixture-backed LLMAdapter peer.
- */
-
-import { mkdirSync, mkdtempSync, readdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { memoryKv } from "@graphrefly/pure-ts/extra";
-import { describe, expect, it } from "vitest";
-import type {
-	ChatMessage,
-	LLMAdapter,
-	LLMResponse,
-	StreamDelta,
-} from "../../../../utils/ai/adapters/core/types.js";
-// Filesystem-backed fixture options (`fixturesDir`, `record.dir`) live in the
-// node subpath — the base `fallbackAdapter` is browser-safe and only accepts
-// inline `fixtures` or a pre-built `fixturesStorage` tier.
-import { fallbackAdapter } from "../../../../utils/ai/adapters/providers/fallback-node.js";
-import {
-	dryRunAdapter,
-	type FallbackFixture,
-	FallbackMissError,
-} from "../../../../utils/ai/adapters/providers/index.js";
-
-function tmp(): string {
-	return mkdtempSync(join(tmpdir(), "fallback-test-"));
-}
-
-function msg(role: ChatMessage["role"], content: string): ChatMessage {
-	return { role, content };
-}
-
-function resp(content: string): LLMResponse {
-	return {
-		content,
-		usage: { input: { regular: 10 }, output: { regular: 5 } },
-		finishReason: "stop",
-		model: "fallback",
-		provider: "fallback",
-	};
-}
-
-describe("fallbackAdapter", () => {
-	it("exposes provider='fallback' by default", () => {
-		const a = fallbackAdapter();
-		expect(a.provider).toBe("fallback");
-		expect(a.model).toBe("fallback");
-	});
-
-	it("invoke: returns a fixture written by record mode", async () => {
-		const dir = tmp();
-		const inner: LLMAdapter = dryRunAdapter({
-			model: "mock",
-			respond: () => "canned-response",
-		});
-		// Record writes under `dir/fallback/` (auto-namespaced by keyPrefix).
-		const recorder = fallbackAdapter({ record: { adapter: inner, dir } });
-		const messages = [msg("user", "hi")];
-		const r1 = await recorder.invoke(messages);
-		expect(r1.content).toBe("canned-response");
-
-		// Second adapter reads from the same dir — auto-namespacing puts it
-		// at the same `dir/fallback/` — so same prompt should hit.
-		const replay = fallbackAdapter({ fixturesDir: dir, onMiss: "throw" });
-		const r2 = await replay.invoke(messages);
-		expect(r2.content).toBe("canned-response");
-		rmSync(dir, { recursive: true });
-	});
-
-	it("invoke: onMiss='throw' raises FallbackMissError", async () => {
-		const a = fallbackAdapter({ onMiss: "throw" });
-		await expect(a.invoke([msg("user", "never-cached")])).rejects.toBeInstanceOf(FallbackMissError);
-	});
-
-	it("invoke: onMiss='respond' (default) uses caller's respond fn", async () => {
-		const a = fallbackAdapter({
-			respond: (msgs) => `degraded: ${msgs[msgs.length - 1]?.content}`,
-		});
-		const r = await a.invoke([msg("user", "ping")]);
-		expect(r.content).toBe("degraded: ping");
-		expect(r.metadata?.degraded).toBe(true);
-	});
-
-	it("invoke: onMiss without respond returns canned degraded response", async () => {
-		const a = fallbackAdapter();
-		const r = await a.invoke([msg("user", "anything")]);
-		expect(r.content).toMatch(/\[fallback:/);
-		expect(r.metadata?.degraded).toBe(true);
-		expect(r.metadata?.reason).toBe("no-fixture");
-	});
-
-	it("record mode: persists fixture under the namespaced subdir", async () => {
-		const dir = tmp();
-		const inner = dryRunAdapter({ model: "mock", respond: () => "recorded" });
-		const a = fallbackAdapter({ record: { adapter: inner, dir } });
-		await a.invoke([msg("user", "seed")]);
-		// Auto-namespace: files go into `dir/fallback/`, not `dir/`.
-		const namespaced = join(dir, "fallback");
-		const files = readdirSync(namespaced);
-		expect(files).toHaveLength(1);
-		const filename = files[0] as string;
-		// Filename encodes `fallback:<sha256>` — the `:` is URL-encoded as `%3a` by fileStorage.
-		expect(filename).toMatch(/^fallback(%3a|[:_])[0-9a-f]{64}/i);
-		const content = JSON.parse(readFileSync(join(namespaced, filename), "utf8")) as {
-			response: LLMResponse;
-			storedAtNs: number;
-		};
-		expect(content.response.content).toBe("recorded");
-		expect(typeof content.storedAtNs).toBe("number");
-		rmSync(dir, { recursive: true });
-	});
-
-	it("record mode: defaults record.dir to fixturesDir when omitted", async () => {
-		const dir = tmp();
-		const inner = dryRunAdapter({ model: "mock", respond: () => "inherited" });
-		// `record.dir` omitted; adapter inherits from `fixturesDir`.
-		// Empty dir → validator sees no .json, passes. Record writes fill it.
-		const a = fallbackAdapter({ fixturesDir: dir, record: { adapter: inner } });
-		await a.invoke([msg("user", "seed")]);
-		const files = readdirSync(join(dir, "fallback"));
-		expect(files).toHaveLength(1);
-		rmSync(dir, { recursive: true });
-	});
-
-	it("record + replay combined: second call hits cache, inner not re-invoked", async () => {
-		const dir = tmp();
-		let innerCalls = 0;
-		const inner: LLMAdapter = {
-			provider: "mock",
-			model: "mock",
-			async invoke() {
-				innerCalls++;
-				return resp("once");
-			},
-			async *stream() {
-				yield { type: "token", delta: "once" } as StreamDelta;
-			},
-		};
-		const a = fallbackAdapter({ record: { adapter: inner, dir } });
-		await a.invoke([msg("user", "seed")]);
-		expect(innerCalls).toBe(1);
-		const r2 = await a.invoke([msg("user", "seed")]);
-		expect(r2.content).toBe("once");
-		expect(innerCalls).toBe(1);
-		rmSync(dir, { recursive: true });
-	});
-
-	it("stream: replays recorded stream transcript in order", async () => {
-		const dir = tmp();
-		const inner = dryRunAdapter({
-			model: "mock",
-			respond: () => "streamed-out",
-			streamChunkSize: 4,
-		});
-		const rec = fallbackAdapter({ record: { adapter: inner, dir } });
-		const recChunks: StreamDelta[] = [];
-		for await (const c of rec.stream([msg("user", "s")])) recChunks.push(c);
-		expect(recChunks.some((c) => c.type === "token")).toBe(true);
-
-		const replay = fallbackAdapter({ fixturesDir: dir, onMiss: "throw" });
-		const playedChunks: StreamDelta[] = [];
-		for await (const c of replay.stream([msg("user", "s")])) playedChunks.push(c);
-
-		const joinTokens = (chunks: StreamDelta[]): string =>
-			chunks
-				.filter((c): c is Extract<StreamDelta, { type: "token" }> => c.type === "token")
-				.map((c) => c.delta)
-				.join("");
-		expect(joinTokens(playedChunks)).toBe(joinTokens(recChunks));
-		rmSync(dir, { recursive: true });
-	});
-
-	it("stream: invoke-only fixture synthesizes single-chunk stream from content", async () => {
-		const dir = tmp();
-		const inner = dryRunAdapter({ model: "mock", respond: () => "plain-content" });
-		const rec = fallbackAdapter({ record: { adapter: inner, dir } });
-		await rec.invoke([msg("user", "q")]); // record via invoke — no stream transcript
-
-		const replay = fallbackAdapter({ fixturesDir: dir, onMiss: "throw" });
-		const chunks: StreamDelta[] = [];
-		for await (const c of replay.stream([msg("user", "q")])) chunks.push(c);
-		const text = chunks
-			.filter((c): c is Extract<StreamDelta, { type: "token" }> => c.type === "token")
-			.map((c) => c.delta)
-			.join("");
-		expect(text).toBe("plain-content");
-		expect(chunks.some((c) => c.type === "finish")).toBe(true);
-		rmSync(dir, { recursive: true });
-	});
-
-	it("stream: onMiss='throw' raises FallbackMissError when cacheStreaming cache misses", async () => {
-		// With no fixtures + onMiss:throw, the stream-miss path throws via
-		// withReplayCache's read-strict mode — cacheStreaming: true is wired
-		// internally by fallbackAdapter, so streams ARE cache-checked.
-		const a = fallbackAdapter({ onMiss: "throw" });
-		const iter = a.stream([msg("user", "miss")]);
-		await expect(iter.next()).rejects.toBeInstanceOf(FallbackMissError);
-	});
-
-	it("fixturesDir that does not exist is treated as empty (no throw at init)", () => {
-		const a = fallbackAdapter({
-			fixturesDir: "/nonexistent/path/deliberately",
-			onMiss: "respond",
-		});
-		expect(a.provider).toBe("fallback");
-	});
-
-	it("fixturesDir with a hand-authored (non-cache-format) file throws at init", () => {
-		// Post-A5: validator throws instead of silently skipping. Users who
-		// want hand-authored fixtures should use the inline `fixtures: [...]`
-		// option, not drop files into the directory.
-		const dir = tmp();
-		const namespaced = join(dir, "fallback");
-		// Write a {messages, response} hand-authored-shaped JSON into the
-		// namespaced subdir. The validator should reject it.
-		mkdirSync(namespaced, { recursive: true });
-		writeFileSync(
-			join(namespaced, "hand.json"),
-			JSON.stringify({ messages: [msg("user", "x")], response: resp("y") }),
-		);
-		expect(() => fallbackAdapter({ fixturesDir: dir })).toThrow(/not in cache-file format/);
-		rmSync(dir, { recursive: true });
-	});
-
-	it("fixturesDir with invalid JSON throws a clear error at init", () => {
-		const dir = tmp();
-		const namespaced = join(dir, "fallback");
-		mkdirSync(namespaced, { recursive: true });
-		writeFileSync(join(namespaced, "broken.json"), "{not-json]");
-		expect(() => fallbackAdapter({ fixturesDir: dir })).toThrow(/not valid JSON/);
-		rmSync(dir, { recursive: true });
-	});
-
-	it("rejects multiple fixture sources set at once", () => {
-		expect(() =>
-			fallbackAdapter({
-				fixtures: [],
-				fixturesDir: "/tmp/x",
-			}),
-		).toThrow(/mutually exclusive/);
-	});
-
-	it("inline fixtures: messages-keyed auto-hashed at init", async () => {
-		const fixture: FallbackFixture = {
-			messages: [msg("user", "what's 2+2?")],
-			response: resp("4"),
-		};
-		const a = fallbackAdapter({ fixtures: [fixture], onMiss: "throw" });
-		// Same messages → adapter computes same hash → hit.
-		const r = await a.invoke([msg("user", "what's 2+2?")]);
-		expect(r.content).toBe("4");
-		// Different messages → miss → throw.
-		await expect(a.invoke([msg("user", "other question")])).rejects.toBeInstanceOf(
-			FallbackMissError,
-		);
-	});
-
-	it("rejects record.storage + record.dir together", () => {
-		const inner = dryRunAdapter({ model: "mock", respond: () => "x" });
-		expect(() =>
-			fallbackAdapter({
-				record: { adapter: inner, dir: "/tmp/x", storage: memoryKv() },
-			}),
-		).toThrow(/mutually exclusive/);
-	});
-});
diff --git a/src/__tests__/utils/ai/adapters/google-mapping.test.ts b/src/__tests__/utils/ai/adapters/google-mapping.test.ts
deleted file mode 100644
index 2dd35b36..00000000
--- a/src/__tests__/utils/ai/adapters/google-mapping.test.ts
+++ /dev/null
@@ -1,152 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-	type GoogleSdkLike,
-	type GoogleSdkRequestParams,
-	googleAdapter,
-} from "../../../../utils/ai/adapters/providers/google.js";
-
-function mockFetch(body: unknown, opts?: { status?: number }): typeof fetch {
-	return (async () =>
-		new Response(JSON.stringify(body), {
-			status: opts?.status ?? 200,
-			headers: { "content-type": "application/json" },
-		})) as unknown as typeof fetch;
-}
-
-describe("GoogleAdapter usage mapping", () => {
-	it("maps cachedContent / thoughts / tool-use / per-modality", async () => {
-		const adapter = googleAdapter({
-			apiKey: "test",
-			model: "gemini-3.1-pro",
-			fetchImpl: mockFetch({
-				candidates: [
-					{
-						content: { parts: [{ text: "hello" }] },
-						finishReason: "STOP",
-					},
-				],
-				usageMetadata: {
-					promptTokenCount: 2000,
-					candidatesTokenCount: 500,
-					cachedContentTokenCount: 1500,
-					thoughtsTokenCount: 300,
-					toolUsePromptTokenCount: 50,
-					promptTokensDetails: [
-						{ modality: "TEXT", tokenCount: 1400 },
-						{ modality: "IMAGE", tokenCount: 600 },
-					],
-				},
-				modelVersion: "gemini-3.1-pro",
-			}),
-		});
-		const resp = await Promise.resolve(adapter.invoke([{ role: "user", content: "hi" }]));
-		expect(resp.usage.input.cacheRead).toBe(1500);
-		expect(resp.usage.input.regular).toBe(500); // 2000 - 1500
-		expect(resp.usage.input.toolUse).toBe(50);
-		expect(resp.usage.input.image).toBe(600);
-		expect(resp.usage.output.regular).toBe(500);
-		expect(resp.usage.output.reasoning).toBe(300);
-	});
-
-	it("maps functionCall parts to toolCalls", async () => {
-		const adapter = googleAdapter({
-			apiKey: "test",
-			model: "gemini-3.1-pro",
-			fetchImpl: mockFetch({
-				candidates: [
-					{
-						content: {
-							parts: [
-								{ text: "thinking..." },
-								{ functionCall: { name: "lookup", args: { q: "pi" } } },
-							],
-						},
-						finishReason: "STOP",
-					},
-				],
-				usageMetadata: { promptTokenCount: 10, candidatesTokenCount: 5 },
-			}),
-		});
-		const resp = await Promise.resolve(adapter.invoke([{ role: "user", content: "hi" }]));
-		expect(resp.toolCalls).toHaveLength(1);
-		expect(resp.toolCalls?.[0].name).toBe("lookup");
-		expect(resp.toolCalls?.[0].arguments).toEqual({ q: "pi" });
-	});
-});
-
-describe("GoogleAdapter SDK-backed path (@google/genai shape)", () => {
-	it("reshapes request into { model, contents, config } and threads abortSignal", async () => {
-		const captured: GoogleSdkRequestParams[] = [];
-		const sdk: GoogleSdkLike = {
-			models: {
-				async generateContent(params) {
-					captured.push(params);
-					return {
-						candidates: [
-							{
-								content: { parts: [{ text: "ok" }] },
-								finishReason: "STOP",
-							},
-						],
-						usageMetadata: { promptTokenCount: 7, candidatesTokenCount: 3 },
-					};
-				},
-			},
-		};
-		const ac = new AbortController();
-		const adapter = googleAdapter({ sdk, model: "gemini-3.1-pro" });
-		await adapter.invoke([{ role: "user", content: "hi" }], {
-			temperature: 0.4,
-			maxTokens: 128,
-			systemPrompt: "be concise",
-			signal: ac.signal,
-		});
-		expect(captured).toHaveLength(1);
-		const params = captured[0];
-		expect(params.model).toBe("gemini-3.1-pro");
-		// Generation params + abortSignal land under config, not generationConfig.
-		expect(params.config?.temperature).toBe(0.4);
-		expect(params.config?.maxOutputTokens).toBe(128);
-		expect(params.config?.systemInstruction).toEqual({
-			role: "system",
-			parts: [{ text: "be concise" }],
-		});
-		expect(params.config?.abortSignal).toBe(ac.signal);
-		// generationConfig should NOT leak through to the SDK params.
-		expect((params as unknown as Record<string, unknown>).generationConfig).toBeUndefined();
-		expect((params.config as unknown as Record<string, unknown>).generationConfig).toBeUndefined();
-	});
-
-	it("awaits stream iterable returned as a Promise", async () => {
-		async function* chunks(): AsyncGenerator<{
-			candidates: { content: { parts: { text?: string }[] }; finishReason?: string }[];
-		}> {
-			yield {
-				candidates: [{ content: { parts: [{ text: "alpha" }] } }],
-			};
-			yield {
-				candidates: [{ content: { parts: [{ text: "-beta" }] }, finishReason: "STOP" }],
-			};
-		}
-		const sdk: GoogleSdkLike = {
-			models: {
-				async generateContent() {
-					throw new Error("invoke not used in this test");
-				},
-				generateContentStream(_params) {
-					// Match the new SDK shape: returns a Promise<AsyncIterable>.
-					return Promise.resolve(chunks());
-				},
-			},
-		};
-		const adapter = googleAdapter({ sdk, model: "gemini-3.1-pro" });
-		const tokens: string[] = [];
-		let finishReason: string | undefined;
-		for await (const delta of adapter.stream([{ role: "user", content: "go" }])) {
-			if (delta.type === "token") tokens.push(delta.delta);
-			else if (delta.type === "finish") finishReason = delta.reason;
-		}
-		expect(tokens).toEqual(["alpha", "-beta"]);
-		expect(finishReason).toBe("STOP");
-	});
-});
diff --git a/src/__tests__/utils/ai/adapters/http429-parser.test.ts b/src/__tests__/utils/ai/adapters/http429-parser.test.ts
deleted file mode 100644
index 6d0fed57..00000000
--- a/src/__tests__/utils/ai/adapters/http429-parser.test.ts
+++ /dev/null
@@ -1,51 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { parseRateLimitFromError } from "../../../../utils/ai/adapters/middleware/http429-parser.js";
-
-describe("parseRateLimitFromError", () => {
-	it("extracts retry-after seconds from 429", () => {
-		const sig = parseRateLimitFromError({
-			status: 429,
-			headers: { "retry-after": "5" },
-			message: "rate limit",
-		});
-		expect(sig?.retryAfterMs).toBe(5000);
-	});
-
-	it("parses x-ratelimit-limit-* headers", () => {
-		const sig = parseRateLimitFromError({
-			status: 429,
-			headers: {
-				"x-ratelimit-limit-requests": "60",
-				"x-ratelimit-limit-tokens": "100000",
-				"x-ratelimit-remaining-requests": "30",
-				"x-ratelimit-remaining-tokens": "75000",
-			},
-		});
-		expect(sig?.rpmCap).toBe(60);
-		expect(sig?.tpmCap).toBe(100000);
-		expect(sig?.usageHint?.rpm).toBeCloseTo(0.5);
-		expect(sig?.usageHint?.tpm).toBeCloseTo(0.25);
-	});
-
-	it("ignores non-rate-limit errors", () => {
-		const sig = parseRateLimitFromError({
-			status: 400,
-			message: "invalid request",
-		});
-		expect(sig).toBeUndefined();
-	});
-
-	it("extracts from error message fallback", () => {
-		const sig = parseRateLimitFromError({
-			status: 429,
-			message: "Please retry after 3 seconds",
-		});
-		expect(sig?.retryAfterMs).toBe(3000);
-	});
-
-	it("handles Headers-like objects", () => {
-		const headers = new Headers({ "retry-after": "10" });
-		const sig = parseRateLimitFromError({ status: 429, headers, message: "" });
-		expect(sig?.retryAfterMs).toBe(10_000);
-	});
-});
diff --git a/src/__tests__/utils/ai/adapters/middleware.test.ts b/src/__tests__/utils/ai/adapters/middleware.test.ts
deleted file mode 100644
index 560edf30..00000000
--- a/src/__tests__/utils/ai/adapters/middleware.test.ts
+++ /dev/null
@@ -1,356 +0,0 @@
-import { memoryKv } from "@graphrefly/pure-ts/extra";
-import { describe, expect, it, vi } from "vitest";
-import type { LLMAdapter, LLMResponse } from "../../../../utils/ai/adapters/core/types.js";
-import { withLLMBreaker } from "../../../../utils/ai/adapters/middleware/breaker.js";
-import {
-	BudgetExhaustedError,
-	withBudgetGate,
-} from "../../../../utils/ai/adapters/middleware/budget-gate.js";
-import { withDryRun } from "../../../../utils/ai/adapters/middleware/dry-run.js";
-import { withReplayCache } from "../../../../utils/ai/adapters/middleware/replay-cache.js";
-import { withRetry } from "../../../../utils/ai/adapters/middleware/retry.js";
-import {
-	LLMTimeoutError,
-	withLLMTimeout,
-} from "../../../../utils/ai/adapters/middleware/timeout.js";
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-function mockAdapter(
-	responses: readonly (LLMResponse | Error)[] = [],
-): LLMAdapter & { calls: number } {
-	let i = 0;
-	const adapter: LLMAdapter & { calls: number } = {
-		provider: "mock",
-		model: "mock-m",
-		calls: 0,
-		invoke(): Promise<LLMResponse> {
-			adapter.calls += 1;
-			const next = responses[i % responses.length];
-			i += 1;
-			if (next instanceof Error) return Promise.reject(next);
-			return Promise.resolve(next);
-		},
-		// biome-ignore lint/correctness/useYield: throws intentionally; test adapter never streams
-		async *stream() {
-			throw new Error("stream not implemented in mock");
-		},
-	};
-	return adapter;
-}
-
-const okResp = (content = "ok", inputTok = 10, outputTok = 5): LLMResponse => ({
-	content,
-	usage: { input: { regular: inputTok }, output: { regular: outputTok } },
-});
-
-// ---------------------------------------------------------------------------
-// withBudgetGate
-// ---------------------------------------------------------------------------
-
-describe("withBudgetGate", () => {
-	it("enforces calls cap", async () => {
-		const { adapter } = withBudgetGate(mockAdapter([okResp(), okResp(), okResp()]), {
-			caps: { calls: 2 },
-		});
-		await Promise.resolve(adapter.invoke([{ role: "user", content: "a" }]));
-		await Promise.resolve(adapter.invoke([{ role: "user", content: "b" }]));
-		await expect(
-			Promise.resolve(adapter.invoke([{ role: "user", content: "c" }])),
-		).rejects.toBeInstanceOf(BudgetExhaustedError);
-	});
-
-	it("QA D2: dispose() exists and is idempotent", async () => {
-		const inner = mockAdapter([okResp(), okResp()]);
-		const { adapter, budget } = withBudgetGate(inner, { caps: { calls: 5 } });
-		await Promise.resolve(adapter.invoke([{ role: "user", content: "a" }]));
-		expect(typeof budget.dispose).toBe("function");
-		// First call releases; second is a no-op.
-		expect(() => {
-			budget.dispose();
-			budget.dispose();
-		}).not.toThrow();
-	});
-
-	it("QA D2: dispose() aborts in-flight controllers", async () => {
-		// Inner adapter that hangs forever unless its signal aborts.
-		let externalAbortReason: unknown;
-		const slowInner: LLMAdapter = {
-			provider: "slow",
-			model: "slow-m",
-			invoke(_messages, opts): Promise<LLMResponse> {
-				return new Promise<LLMResponse>((_resolve, reject) => {
-					if (opts?.signal != null) {
-						if (opts.signal.aborted) {
-							externalAbortReason = opts.signal.reason;
-							reject(opts.signal.reason);
-							return;
-						}
-						opts.signal.addEventListener(
-							"abort",
-							() => {
-								externalAbortReason = (opts.signal as AbortSignal).reason;
-								reject((opts.signal as AbortSignal).reason);
-							},
-							{ once: true },
-						);
-					}
-				});
-			},
-			// biome-ignore lint/correctness/useYield: throws intentionally
-			async *stream() {
-				throw new Error("stream not implemented");
-			},
-		};
-		const { adapter, budget } = withBudgetGate(slowInner, { caps: { calls: 5 } });
-		// Kick off an invoke that will hang.
-		const inflight = Promise.resolve(adapter.invoke([{ role: "user", content: "a" }]));
-		// Dispose now — should abort the in-flight controller.
-		budget.dispose();
-		// The Promise should reject with the dispose reason.
-		await expect(inflight).rejects.toBeDefined();
-		expect(externalAbortReason).toBeDefined();
-	});
-
-	it("AB-1: withBudgetGate emits no abortCapable warning (flag removed)", () => {
-		const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
-		const inner = mockAdapter([]);
-		const { budget } = withBudgetGate(inner, { caps: { calls: 1 } });
-		expect(warnSpy).not.toHaveBeenCalled();
-		budget.dispose();
-		warnSpy.mockRestore();
-	});
-
-	it("enforces usd cap via pricingFn", async () => {
-		const { adapter } = withBudgetGate(
-			mockAdapter([okResp("a", 1_000_000, 0), okResp("b", 1_000_000, 0)]),
-			{
-				caps: { usd: 5 },
-				pricingFn: (u) => ({
-					total: (u.input.regular / 1_000_000) * 3,
-					currency: "USD",
-				}),
-			},
-		);
-		await Promise.resolve(adapter.invoke([{ role: "user", content: "a" }])); // $3
-		// Second call would put total at $6 → but isOpen at invoke time is based on what's logged.
-		// First call logs 1M * $3 = $3; second call would be $3 more. Cap $5 — after the 2nd call
-		// the gate closes. Third call trips.
-		await Promise.resolve(adapter.invoke([{ role: "user", content: "b" }])); // $6 total after this
-		await expect(
-			Promise.resolve(adapter.invoke([{ role: "user", content: "c" }])),
-		).rejects.toBeInstanceOf(BudgetExhaustedError);
-	});
-});
-
-// ---------------------------------------------------------------------------
-// withRetry
-// ---------------------------------------------------------------------------
-
-describe("withRetry", () => {
-	it("retries on transient 5xx", async () => {
-		const err500 = Object.assign(new Error("boom"), { status: 500 });
-		const inner = mockAdapter([err500, err500, okResp()]);
-		const adapter = withRetry(inner, { attempts: 3, baseDelayMs: 1, jitter: false });
-		const resp = await Promise.resolve(adapter.invoke([{ role: "user", content: "x" }]));
-		expect(resp.content).toBe("ok");
-		expect(inner.calls).toBe(3);
-	});
-
-	it("does not retry on 4xx (other than 429)", async () => {
-		const err400 = Object.assign(new Error("bad"), { status: 400 });
-		const inner = mockAdapter([err400]);
-		const adapter = withRetry(inner, { attempts: 3, baseDelayMs: 1 });
-		await expect(Promise.resolve(adapter.invoke([{ role: "user", content: "x" }]))).rejects.toBe(
-			err400,
-		);
-		expect(inner.calls).toBe(1);
-	});
-
-	it("does retry on 429", async () => {
-		const err429 = Object.assign(new Error("slow down"), { status: 429 });
-		const inner = mockAdapter([err429, okResp()]);
-		const adapter = withRetry(inner, { attempts: 3, baseDelayMs: 1, jitter: false });
-		const resp = await Promise.resolve(adapter.invoke([{ role: "user", content: "x" }]));
-		expect(resp.content).toBe("ok");
-	});
-});
-
-// ---------------------------------------------------------------------------
-// withLLMTimeout
-// ---------------------------------------------------------------------------
-
-describe("withLLMTimeout", () => {
-	it("aborts after ms elapse", async () => {
-		const slow: LLMAdapter = {
-			provider: "slow",
-			model: "s",
-			invoke(_msgs, opts): Promise<LLMResponse> {
-				return new Promise((resolve, reject) => {
-					const t = setTimeout(() => resolve(okResp()), 1000);
-					opts?.signal?.addEventListener("abort", () => {
-						clearTimeout(t);
-						reject(opts.signal?.reason ?? new Error("aborted"));
-					});
-				});
-			},
-			async *stream() {},
-		};
-		const adapter = withLLMTimeout(slow, 20);
-		await expect(
-			Promise.resolve(adapter.invoke([{ role: "user", content: "x" }])),
-		).rejects.toBeInstanceOf(LLMTimeoutError);
-	});
-});
-
-// ---------------------------------------------------------------------------
-// withBreaker
-// ---------------------------------------------------------------------------
-
-describe("withBreaker", () => {
-	it("opens after failureThreshold consecutive errors", async () => {
-		const inner = mockAdapter([new Error("e1"), new Error("e2"), new Error("e3"), okResp()]);
-		const { adapter } = withLLMBreaker(inner, { failureThreshold: 2 });
-		await expect(Promise.resolve(adapter.invoke([{ role: "user", content: "a" }]))).rejects.toThrow(
-			"e1",
-		);
-		await expect(Promise.resolve(adapter.invoke([{ role: "user", content: "b" }]))).rejects.toThrow(
-			"e2",
-		);
-		await expect(Promise.resolve(adapter.invoke([{ role: "user", content: "c" }]))).rejects.toThrow(
-			"Circuit breaker is open",
-		);
-		expect(inner.calls).toBe(2);
-	});
-});
-
-// ---------------------------------------------------------------------------
-// withReplayCache
-// ---------------------------------------------------------------------------
-
-describe("withReplayCache", () => {
-	it("returns cached response on second call", async () => {
-		const inner = mockAdapter([okResp("first"), okResp("second")]);
-		const adapter = withReplayCache(inner, { storage: memoryKv() });
-		const r1 = await Promise.resolve(adapter.invoke([{ role: "user", content: "x" }]));
-		const r2 = await Promise.resolve(adapter.invoke([{ role: "user", content: "x" }]));
-		expect(r1.content).toBe("first");
-		expect(r2.content).toBe("first"); // cached
-		expect((r2.metadata as { replayCache?: string })?.replayCache).toBe("hit");
-		expect(inner.calls).toBe(1); // miss only
-	});
-
-	it("different messages miss separately", async () => {
-		const inner = mockAdapter([okResp("a"), okResp("b")]);
-		const adapter = withReplayCache(inner, { storage: memoryKv() });
-		const r1 = await Promise.resolve(adapter.invoke([{ role: "user", content: "x" }]));
-		const r2 = await Promise.resolve(adapter.invoke([{ role: "user", content: "y" }]));
-		expect(r1.content).toBe("a");
-		expect(r2.content).toBe("b");
-		expect(inner.calls).toBe(2);
-	});
-
-	it("B4: keyFn receives ctx.context from invokeOpts.keyContext", async () => {
-		const inner = mockAdapter([okResp("tenantA"), okResp("tenantB"), okResp("tenantA-2")]);
-		const adapter = withReplayCache(inner, {
-			storage: memoryKv(),
-			// 1-arg ctx form — shards by tenant.
-			keyFn: (ctx) => {
-				const tenant = (ctx.context as { tenant?: string })?.tenant ?? "default";
-				return `t:${tenant}:${ctx.messages.at(-1)?.content ?? ""}`;
-			},
-		});
-		const msg = [{ role: "user" as const, content: "hi" }];
-		const r1 = await adapter.invoke(msg, { keyContext: { tenant: "A" } });
-		const r2 = await adapter.invoke(msg, { keyContext: { tenant: "B" } });
-		const r3 = await adapter.invoke(msg, { keyContext: { tenant: "A" } }); // cache hit on A
-		expect(r1.content).toBe("tenantA");
-		expect(r2.content).toBe("tenantB");
-		expect(r3.content).toBe("tenantA"); // served from A's cache
-		expect(inner.calls).toBe(2);
-	});
-
-	it("B4: legacy 2-arg keyFn form still works", async () => {
-		const inner = mockAdapter([okResp("one"), okResp("two")]);
-		let calls = 0;
-		const adapter = withReplayCache(inner, {
-			storage: memoryKv(),
-			keyFn: (messages, _opts) => {
-				calls += 1;
-				return `msg:${messages.length}`;
-			},
-		});
-		await adapter.invoke([{ role: "user", content: "a" }]);
-		await adapter.invoke([{ role: "user", content: "b" }]); // same length → same key → hit
-		expect(calls).toBeGreaterThan(0);
-		expect(inner.calls).toBe(1);
-	});
-
-	it("B4: default key function ignores keyContext", async () => {
-		const inner = mockAdapter([okResp("shared")]);
-		const adapter = withReplayCache(inner, { storage: memoryKv() });
-		const msg = [{ role: "user" as const, content: "ping" }];
-		const r1 = await adapter.invoke(msg, { keyContext: { any: 1 } });
-		const r2 = await adapter.invoke(msg, { keyContext: { any: 2 } });
-		// Without a custom keyFn, keyContext is stripped from canonical hashing
-		// — so the second call hits the cache even though keyContext differs.
-		expect(r1.content).toBe("shared");
-		expect(r2.content).toBe("shared");
-		expect(inner.calls).toBe(1);
-	});
-});
-
-// ---------------------------------------------------------------------------
-// withDryRun
-// ---------------------------------------------------------------------------
-
-// ---------------------------------------------------------------------------
-// withRateLimiter — A2: shared limiter across wraps
-// ---------------------------------------------------------------------------
-
-import { withRateLimiter } from "../../../../utils/ai/adapters/middleware/rate-limiter.js";
-import { adaptiveRateLimiter } from "../../../../utils/resilience/adaptive-rate-limiter.js";
-
-describe("withRateLimiter", () => {
-	it("A2: shared AdaptiveRateLimiterBundle is reused across wraps", () => {
-		const shared = adaptiveRateLimiter({ name: "shared", rpm: 60 });
-		const a = withRateLimiter(mockAdapter([okResp()]), { limiter: shared });
-		const b = withRateLimiter(mockAdapter([okResp()]), { limiter: shared });
-		expect(a.limiter).toBe(shared);
-		expect(b.limiter).toBe(shared);
-	});
-
-	it("A2: fresh limiter constructed when not supplied", () => {
-		const a = withRateLimiter(mockAdapter([okResp()]), {});
-		const b = withRateLimiter(mockAdapter([okResp()]), {});
-		expect(a.limiter).not.toBe(b.limiter);
-	});
-});
-
-describe("withDryRun", () => {
-	it("bypasses inner when enabled:true", async () => {
-		const inner = mockAdapter([okResp("real")]);
-		const { adapter, dispose } = withDryRun(inner, { enabled: true });
-		const resp = await Promise.resolve(adapter.invoke([{ role: "user", content: "x" }]));
-		expect(resp.content).not.toBe("real");
-		expect(inner.calls).toBe(0);
-		dispose();
-	});
-
-	it("passes through when enabled:false", async () => {
-		const inner = mockAdapter([okResp("real")]);
-		const { adapter, dispose } = withDryRun(inner, { enabled: false });
-		const resp = await Promise.resolve(adapter.invoke([{ role: "user", content: "x" }]));
-		expect(resp.content).toBe("real");
-		dispose();
-	});
-
-	it("dispose is idempotent and safe on literal-boolean flag (no keepalive)", () => {
-		const inner = mockAdapter([okResp("real")]);
-		const { dispose } = withDryRun(inner, { enabled: false });
-		dispose();
-		dispose(); // no throw
-	});
-});
diff --git a/src/__tests__/utils/ai/adapters/observable.test.ts b/src/__tests__/utils/ai/adapters/observable.test.ts
deleted file mode 100644
index 58103d52..00000000
--- a/src/__tests__/utils/ai/adapters/observable.test.ts
+++ /dev/null
@@ -1,52 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { firstValueFrom } from "../../../../base/sources/settled.js";
-import { observableAdapter } from "../../../../utils/ai/adapters/core/observable.js";
-import { dryRunAdapter } from "../../../../utils/ai/adapters/providers/dry-run.js";
-
-describe("observableAdapter", () => {
-	it("records invoke calls to allCalls + totals", async () => {
-		const inner = dryRunAdapter({ respond: () => "abcdefghij" });
-		const { adapter, stats } = observableAdapter(inner);
-		await Promise.resolve(adapter.invoke([{ role: "user", content: "hi" }]));
-		await Promise.resolve(adapter.invoke([{ role: "user", content: "hi" }]));
-		expect(stats.totalCalls.cache).toBe(2);
-		expect(stats.totalInputTokens.cache).toBeGreaterThan(0);
-		expect(stats.totalOutputTokens.cache).toBeGreaterThan(0);
-		expect(stats.allCalls.size).toBe(2);
-	});
-
-	it("lastCall emits null initially, then the event after invoke", async () => {
-		const inner = dryRunAdapter();
-		const { adapter, stats } = observableAdapter(inner);
-		// First subscribe gets push-on-subscribe with null.
-		expect(await firstValueFrom(stats.lastCall)).toBeNull();
-		// Kick the call and wait for the next event.
-		await Promise.resolve(adapter.invoke([{ role: "user", content: "hi" }]));
-		const ev = stats.lastCall.cache;
-		expect(ev).not.toBeNull();
-		expect(ev?.provider).toBe("dry-run");
-		expect(ev?.method).toBe("invoke");
-	});
-
-	it("reset clears log and counters", async () => {
-		const inner = dryRunAdapter();
-		const { adapter, stats } = observableAdapter(inner);
-		await Promise.resolve(adapter.invoke([{ role: "user", content: "hi" }]));
-		expect(stats.totalCalls.cache).toBe(1);
-		stats.reset();
-		expect(stats.totalCalls.cache).toBe(0);
-		expect(stats.allCalls.size).toBe(0);
-	});
-
-	it("streaming records usage from terminal usage delta", async () => {
-		const inner = dryRunAdapter({ respond: () => "hello" });
-		const { adapter, stats } = observableAdapter(inner);
-		for await (const _d of adapter.stream([{ role: "user", content: "x" }])) {
-			/* drain */
-		}
-		expect(stats.totalCalls.cache).toBe(1);
-		const last = stats.allCalls.at(0);
-		expect(last?.method).toBe("stream");
-		expect(last?.usage.output.regular).toBeGreaterThan(0);
-	});
-});
diff --git a/src/__tests__/utils/ai/adapters/openai-compat-mapping.test.ts b/src/__tests__/utils/ai/adapters/openai-compat-mapping.test.ts
deleted file mode 100644
index 66ae2d52..00000000
--- a/src/__tests__/utils/ai/adapters/openai-compat-mapping.test.ts
+++ /dev/null
@@ -1,103 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { openAICompatAdapter } from "../../../../utils/ai/adapters/providers/openai-compat.js";
-
-function mockFetch(body: unknown, opts?: { status?: number }): typeof fetch {
-	return (async () =>
-		new Response(JSON.stringify(body), {
-			status: opts?.status ?? 200,
-			headers: { "content-type": "application/json" },
-		})) as unknown as typeof fetch;
-}
-
-describe("OpenAICompatAdapter usage mapping", () => {
-	it("OpenAI shape: cached_tokens → input.cacheRead, reasoning_tokens → output.reasoning", async () => {
-		const adapter = openAICompatAdapter({
-			preset: "openai",
-			apiKey: "test",
-			model: "gpt-5.2",
-			fetchImpl: mockFetch({
-				choices: [{ message: { content: "hi" }, finish_reason: "stop" }],
-				usage: {
-					prompt_tokens: 1000,
-					completion_tokens: 500,
-					prompt_tokens_details: { cached_tokens: 800, audio_tokens: 0 },
-					completion_tokens_details: {
-						reasoning_tokens: 300,
-						accepted_prediction_tokens: 50,
-						rejected_prediction_tokens: 10,
-					},
-				},
-			}),
-		});
-		const resp = await Promise.resolve(adapter.invoke([{ role: "user", content: "hi" }]));
-		expect(resp.usage.input.cacheRead).toBe(800);
-		expect(resp.usage.input.regular).toBe(200); // 1000 - 800
-		expect(resp.usage.output.reasoning).toBe(300);
-		expect(resp.usage.output.regular).toBe(200); // 500 - 300
-		expect(resp.usage.output.predictionAccepted).toBe(50);
-		expect(resp.usage.output.predictionRejected).toBe(10);
-	});
-
-	it("DeepSeek shape: prompt_cache_hit_tokens + prompt_cache_miss_tokens", async () => {
-		const adapter = openAICompatAdapter({
-			preset: "deepseek",
-			apiKey: "test",
-			model: "deepseek-v3.2",
-			fetchImpl: mockFetch({
-				choices: [{ message: { content: "hi" } }],
-				usage: {
-					prompt_tokens: 1000,
-					completion_tokens: 100,
-					prompt_cache_hit_tokens: 900,
-					prompt_cache_miss_tokens: 100,
-				},
-			}),
-		});
-		const resp = await Promise.resolve(adapter.invoke([{ role: "user", content: "hi" }]));
-		expect(resp.usage.input.cacheRead).toBe(900);
-		expect(resp.usage.input.regular).toBe(100);
-	});
-
-	it("maps tool_calls and json-parses arguments", async () => {
-		const adapter = openAICompatAdapter({
-			preset: "openai",
-			apiKey: "test",
-			model: "gpt-5.2",
-			fetchImpl: mockFetch({
-				choices: [
-					{
-						message: {
-							content: null,
-							tool_calls: [
-								{
-									id: "call_1",
-									type: "function",
-									function: { name: "get_weather", arguments: '{"city":"NYC"}' },
-								},
-							],
-						},
-					},
-				],
-				usage: { prompt_tokens: 10, completion_tokens: 5 },
-			}),
-		});
-		const resp = await Promise.resolve(adapter.invoke([{ role: "user", content: "hi" }]));
-		expect(resp.toolCalls).toHaveLength(1);
-		expect(resp.toolCalls?.[0].name).toBe("get_weather");
-		expect(resp.toolCalls?.[0].arguments).toEqual({ city: "NYC" });
-	});
-
-	it("Ollama preset does not require apiKey", async () => {
-		const adapter = openAICompatAdapter({
-			preset: "ollama",
-			model: "gemma3:12b",
-			fetchImpl: mockFetch({
-				choices: [{ message: { content: "local" } }],
-				usage: { prompt_tokens: 5, completion_tokens: 3 },
-			}),
-		});
-		const resp = await Promise.resolve(adapter.invoke([{ role: "user", content: "hi" }]));
-		expect(resp.content).toBe("local");
-		expect(resp.provider).toBe("ollama");
-	});
-});
diff --git a/src/__tests__/utils/ai/adapters/pricing.test.ts b/src/__tests__/utils/ai/adapters/pricing.test.ts
deleted file mode 100644
index fcee9991..00000000
--- a/src/__tests__/utils/ai/adapters/pricing.test.ts
+++ /dev/null
@@ -1,205 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-	composePricing,
-	computePrice,
-	createPricingRegistry,
-	type ModelPricing,
-	registryPricing,
-} from "../../../../utils/ai/adapters/core/pricing.js";
-import type { TokenUsage } from "../../../../utils/ai/adapters/core/types.js";
-
-const usage1k = (): TokenUsage => ({
-	input: { regular: 1_000_000 }, // 1M tokens
-	output: { regular: 500_000 }, // 0.5M tokens
-});
-
-describe("computePrice", () => {
-	it("computes flat rate", () => {
-		const pricing: ModelPricing = {
-			input: { regular: 3 }, // $3 / 1M
-			output: { regular: 15 }, // $15 / 1M
-			currency: "USD",
-		};
-		const result = computePrice(usage1k(), pricing);
-		expect(result.total).toBeCloseTo(3 + 7.5); // 3 + 0.5 * 15
-		expect(result.currency).toBe("USD");
-	});
-
-	it("computes tiered rate (above threshold)", () => {
-		const pricing: ModelPricing = {
-			input: { regular: { pricePerMillion: 2, thresholdTokens: 200_000, pricePerMillionAbove: 4 } },
-			currency: "USD",
-		};
-		// 1M input tokens > 200K threshold → use $4/M
-		const result = computePrice(usage1k(), pricing);
-		expect(result.total).toBeCloseTo(4);
-	});
-
-	it("tiered rate stays at base when below threshold", () => {
-		const pricing: ModelPricing = {
-			input: {
-				regular: { pricePerMillion: 2, thresholdTokens: 2_000_000, pricePerMillionAbove: 4 },
-			},
-			currency: "USD",
-		};
-		const result = computePrice(usage1k(), pricing);
-		expect(result.total).toBeCloseTo(2);
-	});
-
-	it("prices cache classes independently (Anthropic shape)", () => {
-		const u: TokenUsage = {
-			input: {
-				regular: 100_000,
-				cacheRead: 500_000, // 10% of input
-				cacheWrite5m: 200_000, // 125% of input
-				cacheWrite1h: 100_000, // 200% of input
-			},
-			output: { regular: 10_000 },
-		};
-		const pricing: ModelPricing = {
-			input: {
-				regular: 3,
-				cacheRead: 0.3,
-				cacheWrite5m: 3.75,
-				cacheWrite1h: 6,
-			},
-			output: { regular: 15 },
-			currency: "USD",
-		};
-		const r = computePrice(u, pricing, { withBreakdown: true });
-		expect(r.breakdown!["input.regular"]).toBeCloseTo(0.3);
-		expect(r.breakdown!["input.cacheRead"]).toBeCloseTo(0.15);
-		expect(r.breakdown!["input.cacheWrite5m"]).toBeCloseTo(0.75);
-		expect(r.breakdown!["input.cacheWrite1h"]).toBeCloseTo(0.6);
-		expect(r.breakdown!["output.regular"]).toBeCloseTo(0.15);
-		expect(r.total).toBeCloseTo(0.3 + 0.15 + 0.75 + 0.6 + 0.15);
-	});
-
-	it("applies service-tier multiplier (batch)", () => {
-		const pricing: ModelPricing = {
-			input: { regular: 3 },
-			output: { regular: 15 },
-			tierMultipliers: { batch: 0.5 },
-			currency: "USD",
-		};
-		const r = computePrice(usage1k(), pricing, { tier: "batch" });
-		expect(r.total).toBeCloseTo((3 + 7.5) * 0.5);
-	});
-
-	it("returns zero when pricing has no matching class", () => {
-		const pricing: ModelPricing = { currency: "USD" };
-		const r = computePrice(usage1k(), pricing);
-		expect(r.total).toBe(0);
-	});
-
-	it("auxiliary costs are per-unit, not per-million", () => {
-		const u: TokenUsage = {
-			input: { regular: 0 },
-			output: { regular: 0 },
-			auxiliary: { webSearchRequests: 3 },
-		};
-		const pricing: ModelPricing = {
-			auxiliary: { webSearchRequests: 0.01 }, // $0.01 per request
-			currency: "USD",
-		};
-		const r = computePrice(u, pricing);
-		expect(r.total).toBeCloseTo(0.03);
-	});
-
-	it("tier multiplier applies to tokens but NOT to auxiliary", () => {
-		const u: TokenUsage = {
-			input: { regular: 1_000_000 },
-			output: { regular: 0 },
-			auxiliary: { webSearchRequests: 2 },
-		};
-		const pricing: ModelPricing = {
-			input: { regular: 3 }, // $3 for 1M tokens
-			auxiliary: { webSearchRequests: 0.01 }, // $0.01/request
-			tierMultipliers: { batch: 0.5 },
-			currency: "USD",
-		};
-		// Tokens: 3 * 0.5 = $1.50. Aux: 2 * 0.01 = $0.02 (NOT halved). Total: $1.52.
-		const r = computePrice(u, pricing, { tier: "batch" });
-		expect(r.total).toBeCloseTo(1.52);
-	});
-});
-
-describe("PricingRegistry", () => {
-	it("exact lookup wins over prefix", () => {
-		const reg = createPricingRegistry();
-		const exact: ModelPricing = { input: { regular: 1 }, currency: "USD" };
-		const prefix: ModelPricing = { input: { regular: 2 }, currency: "USD" };
-		reg.register("anthropic", "claude-sonnet-4-6", prefix);
-		reg.register("anthropic", "claude-sonnet-4-6-20260401", exact);
-		expect(reg.lookup("anthropic", "claude-sonnet-4-6-20260401")).toBe(exact);
-	});
-
-	it("prefix-match fallback for versioned model ids", () => {
-		const reg = createPricingRegistry();
-		const prefix: ModelPricing = { input: { regular: 3 }, currency: "USD" };
-		reg.register("anthropic", "claude-sonnet-4-6", prefix);
-		expect(reg.lookup("anthropic", "claude-sonnet-4-6-20260415")).toBe(prefix);
-	});
-
-	it("longest prefix wins", () => {
-		const reg = createPricingRegistry();
-		const shortP: ModelPricing = { input: { regular: 1 }, currency: "USD" };
-		const longP: ModelPricing = { input: { regular: 2 }, currency: "USD" };
-		reg.register("openai", "gpt-5", shortP);
-		reg.register("openai", "gpt-5.2", longP);
-		expect(reg.lookup("openai", "gpt-5.2-codex")).toBe(longP);
-	});
-
-	it("remove deletes entries", () => {
-		const reg = createPricingRegistry();
-		reg.register("p", "m", { currency: "USD" });
-		expect(reg.lookup("p", "m")).toBeDefined();
-		expect(reg.remove("p", "m")).toBe(true);
-		expect(reg.lookup("p", "m")).toBeUndefined();
-		expect(reg.remove("p", "m")).toBe(false);
-	});
-});
-
-describe("registryPricing", () => {
-	it("returns zero when model not in registry", () => {
-		const reg = createPricingRegistry();
-		const fn = registryPricing(reg);
-		const r = fn(usage1k(), { model: "unknown", provider: "unknown" });
-		expect(r.total).toBe(0);
-	});
-
-	it("delegates to computePrice with tier", () => {
-		const reg = createPricingRegistry([
-			[
-				"anthropic",
-				"claude-sonnet-4-6",
-				{
-					input: { regular: 3 },
-					output: { regular: 15 },
-					tierMultipliers: { batch: 0.5 },
-					currency: "USD",
-				},
-			],
-		]);
-		const fn = registryPricing(reg);
-		const base = fn(usage1k(), { model: "claude-sonnet-4-6", provider: "anthropic" });
-		const batch = fn(usage1k(), {
-			model: "claude-sonnet-4-6",
-			provider: "anthropic",
-			tier: "batch",
-		});
-		expect(batch.total).toBeCloseTo(base.total * 0.5);
-	});
-});
-
-describe("composePricing", () => {
-	it("first non-zero wins", () => {
-		const fn1 = registryPricing(createPricingRegistry()); // always 0
-		const fn2 = registryPricing(
-			createPricingRegistry([["p", "m", { input: { regular: 10 }, currency: "USD" }]]),
-		);
-		const composed = composePricing(fn1, fn2);
-		const r = composed(usage1k(), { model: "m", provider: "p" });
-		expect(r.total).toBeCloseTo(10);
-	});
-});
diff --git a/src/__tests__/utils/ai/adapters/qa-regressions.test.ts b/src/__tests__/utils/ai/adapters/qa-regressions.test.ts
deleted file mode 100644
index 5e60af39..00000000
--- a/src/__tests__/utils/ai/adapters/qa-regressions.test.ts
+++ /dev/null
@@ -1,260 +0,0 @@
-/**
- * Regression tests for the second-round QA fixes (P1–P10, ND1–ND2).
- */
-
-import { describe, expect, it } from "vitest";
-import { singleFromAny } from "../../../../base/composition/single-from-any.js";
-import type { LLMAdapter, LLMResponse } from "../../../../utils/ai/adapters/core/types.js";
-import { withBudgetGate } from "../../../../utils/ai/adapters/middleware/budget-gate.js";
-import { withDryRun } from "../../../../utils/ai/adapters/middleware/dry-run.js";
-import { dryRunAdapter } from "../../../../utils/ai/adapters/providers/dry-run.js";
-import { adaptiveRateLimiter } from "../../../../utils/resilience/adaptive-rate-limiter.js";
-import { tokenBucket } from "../../../../utils/resilience/rate-limiter.js";
-
-// ---------------------------------------------------------------------------
-// P1 — canonicalJson: sibling shared references should NOT be flagged as cycles
-// ---------------------------------------------------------------------------
-// Indirect test via withReplayCache: identical-structure prompts with shared
-// sub-objects produce the same cache key as freshly-reconstructed equivalents.
-
-import { memoryKv } from "@graphrefly/pure-ts/extra";
-import { withReplayCache } from "../../../../utils/ai/adapters/middleware/replay-cache.js";
-
-function mockAdapter(responses: LLMResponse[]): LLMAdapter & { calls: number } {
-	let i = 0;
-	const a: LLMAdapter & { calls: number } = {
-		provider: "mock",
-		model: "m",
-		calls: 0,
-		invoke(): Promise<LLMResponse> {
-			a.calls += 1;
-			const r = responses[Math.min(i, responses.length - 1)];
-			i += 1;
-			return Promise.resolve(r);
-		},
-		async *stream() {},
-	};
-	return a;
-}
-
-const okResp = (content = "ok"): LLMResponse => ({
-	content,
-	usage: { input: { regular: 0 }, output: { regular: 0 } },
-});
-
-describe("P1 canonicalJson: shared sibling refs are not cycles", () => {
-	it("shared tool-parameter object hashes same as reconstructed equivalent", async () => {
-		const shared = { type: "object", properties: { x: { type: "string" } } };
-		const freshA = { type: "object", properties: { x: { type: "string" } } };
-		const freshB = { type: "object", properties: { x: { type: "string" } } };
-
-		const inner = mockAdapter([okResp("A"), okResp("B")]);
-		const adapter = withReplayCache(inner, { storage: memoryKv() });
-
-		// First call: two tools sharing one reference.
-		await Promise.resolve(
-			adapter.invoke([{ role: "user", content: "x" }], {
-				tools: [
-					{ name: "t1", description: "", parameters: shared, handler: () => null },
-					{ name: "t2", description: "", parameters: shared, handler: () => null },
-				],
-			}),
-		);
-
-		// Second call: two tools with structurally-equal-but-distinct references.
-		const r2 = await Promise.resolve(
-			adapter.invoke([{ role: "user", content: "x" }], {
-				tools: [
-					{ name: "t1", description: "", parameters: freshA, handler: () => null },
-					{ name: "t2", description: "", parameters: freshB, handler: () => null },
-				],
-			}),
-		);
-
-		expect(r2.content).toBe("A"); // cache hit from first call
-		expect((r2.metadata as { replayCache?: string }).replayCache).toBe("hit");
-		expect(inner.calls).toBe(1);
-	});
-});
-
-// ---------------------------------------------------------------------------
-// P7 — singleFromAny: sync-resolved Promise no longer leaves stale cache entries
-// ---------------------------------------------------------------------------
-
-describe("P7 singleFromAny: sync-resolved promise clean-up", () => {
-	it("cache is clear after sync-resolved factory settles", async () => {
-		let calls = 0;
-		const fn = singleFromAny<string, number>((k) => {
-			calls += 1;
-			return Promise.resolve(Number(k)); // already-resolved
-		});
-		await fn("1");
-		await fn("1"); // reinvokes because prior settled
-		expect(calls).toBe(2);
-	});
-});
-
-// ---------------------------------------------------------------------------
-// P9 — EMPTY_TOTALS is frozen + reset emits fresh object
-// ---------------------------------------------------------------------------
-
-describe("P9 EMPTY_TOTALS is isolated across instances", () => {
-	it("mutation to one bundle's totals does not bleed into another", () => {
-		const inner = dryRunAdapter();
-		const { budget: b1 } = withBudgetGate(inner, { caps: { calls: 10 } });
-		const { budget: b2 } = withBudgetGate(inner, { caps: { calls: 10 } });
-		const t1 = b1.totals.cache as { calls: number } | undefined;
-		const t2 = b2.totals.cache as { calls: number } | undefined;
-		expect(t1).not.toBe(t2); // distinct objects per instance
-	});
-});
-
-// ---------------------------------------------------------------------------
-// B8 — withBudgetGate: onExhausted is edge-triggered (open → closed only)
-// ---------------------------------------------------------------------------
-
-describe("B8 withBudgetGate: onExhausted fires once on open→closed edge", () => {
-	it("onExhausted fires exactly once across many blocked attempts", async () => {
-		let exhaustedCalls = 0;
-		const keys: unknown[] = [];
-		const { adapter } = withBudgetGate(dryRunAdapter(), {
-			caps: { calls: 2 },
-			onExhausted: (which) => {
-				exhaustedCalls += 1;
-				keys.push(which);
-			},
-		});
-		// First two calls succeed, tipping totals.calls to 2, closing the gate.
-		await adapter.invoke([{ role: "user", content: "a" }]);
-		await adapter.invoke([{ role: "user", content: "b" }]);
-		// Subsequent attempts throw — but onExhausted must fire only once,
-		// at the edge, not per blocked attempt.
-		for (let i = 0; i < 5; i++) {
-			await expect(adapter.invoke([{ role: "user", content: "x" }])).rejects.toThrow();
-		}
-		expect(exhaustedCalls).toBe(1);
-		expect(keys).toEqual(["calls"]);
-	});
-});
-
-// ---------------------------------------------------------------------------
-// P6 — rpmCap: 0 honored as hard stop (doesn't silently fall through)
-// ---------------------------------------------------------------------------
-
-describe("P6 adaptiveRateLimiter rpmCap=0 hard-stop", () => {
-	it("acquire blocks when rpmCap=0 is signaled, resumes after decay", async () => {
-		const limiter = adaptiveRateLimiter({ rpm: 1000, clampCooldownMs: 120 });
-		limiter.recordSignal({ rpmCap: 0 });
-		expect(limiter.effectiveRpm.cache).toBe(0);
-
-		const ac = new AbortController();
-		const p = limiter.acquire({ signal: ac.signal });
-
-		// Give the decay timer time to fire and the polling loop to pick up.
-		await new Promise((r) => setTimeout(r, 250));
-		await p; // should resolve after decay relaxes the cap
-		limiter.dispose();
-	}, 10000);
-});
-
-// ---------------------------------------------------------------------------
-// P5 — adaptiveRateLimiter: bucket-swap race (putBack credits local ref)
-// ---------------------------------------------------------------------------
-
-describe("P5 adaptiveRateLimiter: putBack targets the acquire-time bucket", () => {
-	// A direct race test requires precise timing, so we validate the
-	// property structurally: putBack on a swapped-out bucket must not
-	// inflate the new bucket's available tokens.
-	it("rpm bucket rebuild during tpm-miss does not leak credit to the new bucket", async () => {
-		// The TokenBucket.putBack primitive is the only way to add — verified in
-		// its own test. The adaptive-rate-limiter now captures
-		// rpmAtAcquire/tpmAtAcquire locally, so this is an invariant test:
-		// the closure refs survive a rebuild.
-		const b = tokenBucket(5, 0); // non-refilling
-		b.tryConsume(5);
-		expect(b.available()).toBeCloseTo(0);
-		const held = b;
-		// "Rebuild" — new limiter bucket would be created; the old one is still
-		// the one `putBack` targets.
-		held.putBack(3);
-		expect(held.available()).toBeCloseTo(3);
-	});
-});
-
-// ---------------------------------------------------------------------------
-// ND1 — cascadingLlmAdapter: no onExhausted when single tier commits mid-stream
-// ---------------------------------------------------------------------------
-
-import { cascadingLlmAdapter } from "../../../../utils/ai/adapters/routing/cascading.js";
-
-describe("ND1 cascadingLlmAdapter: mid-stream commit failure doesn't call onExhausted", () => {
-	it("onExhausted is NOT called when the current tier throws after yielding", async () => {
-		let exhaustedCalls = 0;
-		const flaky: LLMAdapter = {
-			provider: "flaky",
-			model: "m",
-			invoke() {
-				return Promise.reject(new Error("not used"));
-			},
-			async *stream() {
-				yield { type: "token" as const, delta: "a" };
-				throw new Error("mid-stream fail");
-			},
-		};
-		const adapter = cascadingLlmAdapter([{ name: "tier-0", adapter: flaky }], {
-			onExhausted: () => exhaustedCalls++,
-		});
-		try {
-			for await (const _d of adapter.stream([{ role: "user", content: "x" }])) {
-				/* consume */
-			}
-		} catch {
-			// expected
-		}
-		expect(exhaustedCalls).toBe(0);
-	});
-
-	it("onExhausted IS called when all tiers fail pre-first-chunk", async () => {
-		let exhaustedCalls = 0;
-		const always: LLMAdapter = {
-			provider: "always-fail",
-			model: "m",
-			invoke() {
-				return Promise.reject(new Error("x"));
-			},
-			// biome-ignore lint/correctness/useYield: throws before yielding (pre-chunk fail test)
-			async *stream() {
-				throw new Error("pre-chunk");
-			},
-		};
-		const adapter = cascadingLlmAdapter(
-			[
-				{ name: "tier-0", adapter: always },
-				{ name: "tier-1", adapter: always },
-			],
-			{ onExhausted: () => exhaustedCalls++ },
-		);
-		try {
-			for await (const _d of adapter.stream([{ role: "user", content: "x" }])) {
-				/* consume */
-			}
-		} catch {
-			// expected
-		}
-		expect(exhaustedCalls).toBe(1);
-	});
-});
-
-// ---------------------------------------------------------------------------
-// ND2 — withDryRun returns { adapter, dispose }
-// ---------------------------------------------------------------------------
-
-describe("ND2 withDryRun: dispose API", () => {
-	it("returns an adapter + dispose tuple", () => {
-		const inner = dryRunAdapter();
-		const result = withDryRun(inner, { enabled: true });
-		expect(typeof result.dispose).toBe("function");
-		expect(result.adapter.provider).toBe(inner.provider);
-		result.dispose();
-	});
-});
diff --git a/src/__tests__/utils/ai/adapters/resilient-adapter.test.ts b/src/__tests__/utils/ai/adapters/resilient-adapter.test.ts
deleted file mode 100644
index 618a01d5..00000000
--- a/src/__tests__/utils/ai/adapters/resilient-adapter.test.ts
+++ /dev/null
@@ -1,311 +0,0 @@
-import { describe, expect, it } from "vitest";
-import type {
-	LLMAdapter,
-	LLMResponse,
-	StreamDelta,
-} from "../../../../utils/ai/adapters/core/types.js";
-import { BudgetExhaustedError } from "../../../../utils/ai/adapters/middleware/budget-gate.js";
-import { resilientAdapter } from "../../../../utils/ai/adapters/middleware/resilient-adapter.js";
-import { CircuitOpenError } from "../../../../utils/resilience/breaker.js";
-
-function mockAdapter(
-	responses: readonly (LLMResponse | Error)[] = [],
-): LLMAdapter & { calls: number } {
-	let i = 0;
-	const adapter: LLMAdapter & { calls: number } = {
-		provider: "mock",
-		model: "mock-m",
-		calls: 0,
-		invoke(): Promise<LLMResponse> {
-			adapter.calls += 1;
-			const next = responses[i % responses.length];
-			i += 1;
-			if (next instanceof Error) return Promise.reject(next);
-			return Promise.resolve(next);
-		},
-		// biome-ignore lint/correctness/useYield: throws intentionally; test adapter never streams
-		async *stream() {
-			throw new Error("stream not implemented in mock");
-		},
-	};
-	return adapter;
-}
-
-const okResp = (content = "ok", inputTok = 10, outputTok = 5): LLMResponse => ({
-	content,
-	usage: { input: { regular: inputTok }, output: { regular: outputTok } },
-});
-
-describe("resilientAdapter", () => {
-	it("returns inner adapter unchanged when no layers configured", () => {
-		const inner = mockAdapter([okResp()]);
-		const { adapter, rateLimiter, budget, breaker } = resilientAdapter(inner);
-		expect(adapter).toBe(inner);
-		expect(rateLimiter).toBeUndefined();
-		expect(budget).toBeUndefined();
-		expect(breaker).toBeUndefined();
-	});
-
-	it("applies retry + timeout (timeout rearms per attempt; default predicate retries)", async () => {
-		let call = 0;
-		// Model a real fetch-style adapter: rejects aborted requests with an
-		// AbortError regardless of `signal.reason`. `withLLMTimeout` must
-		// convert its own timer-fire path into `LLMTimeoutError` so the
-		// default retry predicate recognizes it.
-		const slow: LLMAdapter = {
-			provider: "slow",
-			model: "s",
-			invoke(_msgs, opts): Promise<LLMResponse> {
-				call += 1;
-				const hangMs = call === 1 ? 60 : 0;
-				return new Promise((resolve, reject) => {
-					const t = setTimeout(() => resolve(okResp("done")), hangMs);
-					opts?.signal?.addEventListener("abort", () => {
-						clearTimeout(t);
-						const abortErr = new Error("The operation was aborted");
-						abortErr.name = "AbortError";
-						reject(abortErr);
-					});
-				});
-			},
-			async *stream() {},
-		};
-		const { adapter } = resilientAdapter(slow, {
-			timeoutMs: 20,
-			retry: { attempts: 2, baseDelayMs: 1, jitter: false },
-		});
-		const resp = await Promise.resolve(adapter.invoke([{ role: "user", content: "x" }]));
-		expect(resp.content).toBe("done");
-		expect(call).toBe(2);
-	});
-
-	it("retry runs through breaker — each attempt checks circuit", async () => {
-		const err500 = Object.assign(new Error("boom"), { status: 500 });
-		const inner = mockAdapter([err500, err500, err500, err500, err500]);
-		const { adapter, breaker } = resilientAdapter(inner, {
-			breaker: { failureThreshold: 2 },
-			retry: { attempts: 5, baseDelayMs: 1, jitter: false },
-		});
-		// Breaker opens after 2 recorded failures, then retry hits
-		// CircuitOpenError (in defaultShouldRetry's no-retry list) and bails.
-		// The final error MUST be CircuitOpenError — asserting the class
-		// catches regressions where the breaker silently doesn't open.
-		await expect(
-			Promise.resolve(adapter.invoke([{ role: "user", content: "x" }])),
-		).rejects.toBeInstanceOf(CircuitOpenError);
-		expect(inner.calls).toBe(2);
-		expect(breaker?.state).toBe("open");
-	});
-
-	it("budget cap closes gate after N successful calls under retry", async () => {
-		// Budget `calls` counts only successful invocations — errors don't
-		// debit the cap. Once the cap is reached, subsequent calls fast-fail
-		// with BudgetExhaustedError; retry's defaultShouldRetry excludes that
-		// class so retries don't fire against a closed gate.
-		const inner = mockAdapter([okResp("a"), okResp("b"), okResp("c")]);
-		const { adapter } = resilientAdapter(inner, {
-			budget: { caps: { calls: 2 } },
-			retry: { attempts: 3, baseDelayMs: 1, jitter: false },
-		});
-		await adapter.invoke([{ role: "user", content: "1" }]);
-		await adapter.invoke([{ role: "user", content: "2" }]);
-		await expect(
-			Promise.resolve(adapter.invoke([{ role: "user", content: "3" }])),
-		).rejects.toBeInstanceOf(BudgetExhaustedError);
-		// Third call never reached inner — budget short-circuited + retry
-		// skipped BudgetExhaustedError → inner.calls stays at 2.
-		expect(inner.calls).toBe(2);
-	});
-
-	it("falls back to secondary adapter when primary exhausts retries", async () => {
-		const err500 = Object.assign(new Error("boom"), { status: 500 });
-		const primary = mockAdapter([err500, err500]);
-		const secondary = mockAdapter([okResp("from-fallback")]);
-		const { adapter } = resilientAdapter(primary, {
-			retry: { attempts: 2, baseDelayMs: 1, jitter: false },
-			fallback: secondary,
-		});
-		const resp = await Promise.resolve(adapter.invoke([{ role: "user", content: "x" }]));
-		expect(resp.content).toBe("from-fallback");
-		expect(primary.calls).toBe(2);
-		expect(secondary.calls).toBe(1);
-		// Cascading adapter stamps the tier name onto the response metadata.
-		expect((resp.metadata as { tier?: string })?.tier).toBe("fallback");
-	});
-
-	it("does not wrap fallback when no primary failure", async () => {
-		const primary = mockAdapter([okResp("primary-ok")]);
-		const secondary = mockAdapter([okResp("fallback-ok")]);
-		const { adapter } = resilientAdapter(primary, { fallback: secondary });
-		const resp = await Promise.resolve(adapter.invoke([{ role: "user", content: "x" }]));
-		expect(resp.content).toBe("primary-ok");
-		expect(primary.calls).toBe(1);
-		expect(secondary.calls).toBe(0);
-	});
-
-	it("exposes breaker / budget / rateLimiter bundles when configured", () => {
-		const { adapter, breaker, budget, rateLimiter } = resilientAdapter(mockAdapter(), {
-			breaker: { failureThreshold: 3 },
-			budget: { caps: { calls: 10 } },
-			rateLimit: { rpm: 60 },
-		});
-		expect(adapter).toBeDefined();
-		expect(breaker).toBeDefined();
-		expect(breaker?.state).toBe("closed");
-		expect(budget).toBeDefined();
-		expect(budget?.totals.cache?.calls).toBe(0);
-		expect(rateLimiter).toBeDefined();
-	});
-
-	it('rejects `name: "fallback"` — collides with the hardcoded secondary tier label', () => {
-		expect(() =>
-			resilientAdapter(mockAdapter(), {
-				name: "fallback",
-				fallback: mockAdapter([okResp()]),
-			}),
-		).toThrow(RangeError);
-	});
-
-	// Helper: build a streaming mock adapter whose per-call behavior is
-	// driven by a caller-supplied script.
-	type StreamScript =
-		| { kind: "chunks"; chunks: readonly StreamDelta[] }
-		| { kind: "failBeforeChunks"; error: Error }
-		| { kind: "failAfterFirst"; firstChunk: StreamDelta; error: Error };
-
-	function streamingMock(scripts: readonly StreamScript[]): LLMAdapter & { streamCalls: number } {
-		let i = 0;
-		const adapter: LLMAdapter & { streamCalls: number } = {
-			provider: "stream-mock",
-			model: "m",
-			streamCalls: 0,
-			invoke(): Promise<LLMResponse> {
-				return Promise.reject(new Error("invoke not used in stream tests"));
-			},
-			async *stream() {
-				const script = scripts[i % scripts.length];
-				i += 1;
-				adapter.streamCalls += 1;
-				switch (script.kind) {
-					case "chunks":
-						for (const c of script.chunks) yield c;
-						return;
-					case "failBeforeChunks":
-						throw script.error;
-					case "failAfterFirst":
-						yield script.firstChunk;
-						throw script.error;
-				}
-			},
-		};
-		return adapter;
-	}
-
-	const contentDelta = (text: string): StreamDelta => ({ type: "content", delta: text });
-
-	it("stream: primary fails pre-first-chunk → fallback tier streams", async () => {
-		const err500 = Object.assign(new Error("boom"), { status: 500 });
-		const primary = streamingMock([{ kind: "failBeforeChunks", error: err500 }]);
-		const secondary = streamingMock([
-			{ kind: "chunks", chunks: [contentDelta("fall"), contentDelta("back")] },
-		]);
-		const { adapter } = resilientAdapter(primary, {
-			// No retry — isolate the cascade path. Retry interaction is
-			// exercised in the next test.
-			fallback: secondary,
-		});
-		const chunks: string[] = [];
-		for await (const d of adapter.stream([{ role: "user", content: "x" }])) {
-			if (d.type === "content") chunks.push(d.delta);
-		}
-		expect(chunks.join("")).toBe("fallback");
-		expect(primary.streamCalls).toBe(1);
-		expect(secondary.streamCalls).toBe(1);
-	});
-
-	it("stream: mid-stream failure propagates; fallback does NOT replay partial output", async () => {
-		const err500 = Object.assign(new Error("boom"), { status: 500 });
-		const primary = streamingMock([
-			{
-				kind: "failAfterFirst",
-				firstChunk: contentDelta("partial-"),
-				error: err500,
-			},
-		]);
-		const secondary = streamingMock([{ kind: "chunks", chunks: [contentDelta("from-fallback")] }]);
-		const { adapter } = resilientAdapter(primary, { fallback: secondary });
-		const chunks: string[] = [];
-		let caught: unknown;
-		try {
-			for await (const d of adapter.stream([{ role: "user", content: "x" }])) {
-				if (d.type === "content") chunks.push(d.delta);
-			}
-		} catch (err) {
-			caught = err;
-		}
-		// Primary's partial output must be visible to the caller (we don't
-		// silently discard it). Error propagates. Fallback MUST NOT be
-		// engaged — mid-stream commit is the documented contract.
-		expect(chunks.join("")).toBe("partial-");
-		expect(caught).toBe(err500);
-		expect(secondary.streamCalls).toBe(0);
-	});
-
-	it("A1: onFallback is surfaced to resilientAdapter options", async () => {
-		const err500 = Object.assign(new Error("boom"), { status: 500 });
-		const primary = mockAdapter([err500]);
-		const secondary = mockAdapter([okResp("saved")]);
-		const calls: Array<{ from: string; to: string }> = [];
-		const { adapter } = resilientAdapter(primary, {
-			fallback: secondary,
-			name: "p1",
-			onFallback: (from, to) => calls.push({ from, to }),
-		});
-		await adapter.invoke([{ role: "user", content: "x" }]);
-		expect(calls).toEqual([{ from: "p1", to: "fallback" }]);
-	});
-
-	it("A1: onExhausted is surfaced when every cascade tier fails", async () => {
-		const err1 = new Error("primary failed");
-		const err2 = new Error("fallback failed");
-		const primary = mockAdapter([err1]);
-		const secondary = mockAdapter([err2]);
-		let report: unknown;
-		const { adapter } = resilientAdapter(primary, {
-			fallback: secondary,
-			onExhausted: (r) => {
-				report = r;
-			},
-		});
-		await expect(adapter.invoke([{ role: "user", content: "x" }])).rejects.toThrow();
-		expect(report).toBeDefined();
-		const failedNames = [...(report as { failed: ReadonlyMap<string, unknown> }).failed.keys()];
-		expect(failedNames.sort()).toEqual(["fallback", "primary"]);
-	});
-
-	it("stream: retry does not replay a partially-streamed output", async () => {
-		const err500 = Object.assign(new Error("boom"), { status: 500 });
-		const primary = streamingMock([
-			{ kind: "failAfterFirst", firstChunk: contentDelta("p1-"), error: err500 },
-			// This second script would run only if retry re-invoked stream; assertion
-			// that primary.streamCalls stays at 1 proves it doesn't.
-			{ kind: "chunks", chunks: [contentDelta("p2")] },
-		]);
-		const { adapter } = resilientAdapter(primary, {
-			retry: { attempts: 3, baseDelayMs: 1, jitter: false },
-		});
-		const chunks: string[] = [];
-		let caught: unknown;
-		try {
-			for await (const d of adapter.stream([{ role: "user", content: "x" }])) {
-				if (d.type === "content") chunks.push(d.delta);
-			}
-		} catch (err) {
-			caught = err;
-		}
-		expect(chunks.join("")).toBe("p1-");
-		expect(caught).toBe(err500);
-		// Retry commits after first chunk — exactly one stream() call.
-		expect(primary.streamCalls).toBe(1);
-	});
-});
diff --git a/src/__tests__/utils/ai/adapters/types.test.ts b/src/__tests__/utils/ai/adapters/types.test.ts
deleted file mode 100644
index 4dcdc262..00000000
--- a/src/__tests__/utils/ai/adapters/types.test.ts
+++ /dev/null
@@ -1,68 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-	emptyUsage,
-	isLLMAdapter,
-	sumInputTokens,
-	sumOutputTokens,
-	type TokenUsage,
-} from "../../../../utils/ai/adapters/core/types.js";
-
-describe("TokenUsage helpers", () => {
-	it("sumInputTokens sums all input classes + extensions", () => {
-		const u: TokenUsage = {
-			input: {
-				regular: 100,
-				cacheRead: 50,
-				cacheWrite5m: 10,
-				cacheWrite1h: 20,
-				cacheWriteOther: 5,
-				audio: 30,
-				image: 40,
-				video: 15,
-				toolUse: 25,
-				extensions: { exotic: 7 },
-			},
-			output: { regular: 0 },
-		};
-		expect(sumInputTokens(u)).toBe(100 + 50 + 10 + 20 + 5 + 30 + 40 + 15 + 25 + 7);
-	});
-
-	it("sumInputTokens handles missing optional fields", () => {
-		const u = emptyUsage();
-		u.input.regular = 100;
-		u.input.cacheRead = 10;
-		expect(sumInputTokens(u)).toBe(110);
-	});
-
-	it("sumOutputTokens sums all output classes + extensions", () => {
-		const u: TokenUsage = {
-			input: { regular: 0 },
-			output: {
-				regular: 100,
-				reasoning: 200,
-				audio: 30,
-				predictionAccepted: 5,
-				predictionRejected: 3,
-				extensions: { foo: 2 },
-			},
-		};
-		expect(sumOutputTokens(u)).toBe(100 + 200 + 30 + 5 + 3 + 2);
-	});
-
-	it("isLLMAdapter accepts well-formed adapter", () => {
-		expect(
-			isLLMAdapter({
-				provider: "test",
-				invoke: () => undefined,
-				stream: () => (async function* () {})(),
-			}),
-		).toBe(true);
-	});
-
-	it("isLLMAdapter rejects non-adapters", () => {
-		expect(isLLMAdapter(null)).toBe(false);
-		expect(isLLMAdapter({})).toBe(false);
-		expect(isLLMAdapter({ provider: "x" })).toBe(false);
-		expect(isLLMAdapter({ provider: "x", invoke: () => undefined })).toBe(false);
-	});
-});
diff --git a/src/__tests__/utils/ai/agents/agent.test.ts b/src/__tests__/utils/ai/agents/agent.test.ts
deleted file mode 100644
index afed68b2..00000000
--- a/src/__tests__/utils/ai/agents/agent.test.ts
+++ /dev/null
@@ -1,508 +0,0 @@
-/**
- * Phase 13.G + 13.H — `AgentBundle`, `class AgentGraph`, `agent()` preset,
- * `presetRegistry()` regression tests.
- */
-
-import { DATA, node } from "@graphrefly/pure-ts/core";
-import { Graph } from "@graphrefly/pure-ts/graph";
-import { describe, expect, it } from "vitest";
-import { awaitSettled } from "../../../../base/sources/settled.js";
-import {
-	type AgentBundle,
-	AgentGraph,
-	type AgentSpec,
-	type CostState,
-	ZERO_COST,
-} from "../../../../presets/ai/agent.js";
-import { agent, presetRegistry } from "../../../../presets/ai/agents.js";
-import type {
-	LLMAdapter,
-	LLMResponse,
-	ToolDefinition,
-} from "../../../../utils/ai/adapters/core/types.js";
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-function syncAdapter(content: string, opts?: { tokens?: number }): LLMAdapter {
-	const tokens = opts?.tokens ?? 10;
-	const resp: LLMResponse = {
-		content,
-		finishReason: "end_turn",
-		usage: {
-			input: { regular: Math.floor(tokens / 2) },
-			output: { regular: Math.ceil(tokens / 2) },
-		},
-	};
-	return {
-		provider: "mock-sync",
-		invoke() {
-			return resp;
-		},
-		async *stream() {
-			yield { type: "token", delta: content };
-			yield { type: "finish", reason: "stop" };
-		},
-	};
-}
-
-// ---------------------------------------------------------------------------
-// agent() basic flow
-// ---------------------------------------------------------------------------
-
-describe("agent() — basic reactive entry / exit", () => {
-	it("mounts under parent and produces an LLMResponse via in.emit", async () => {
-		const parent = new Graph("parent");
-		const a = agent(parent, {
-			name: "researcher",
-			adapter: syncAdapter("the answer is 42"),
-		});
-
-		expect(a.graph).toBeInstanceOf(AgentGraph);
-		expect(parent.node("researcher::out")).toBe(a.out);
-
-		const promise = awaitSettled(a.out, { skipCurrent: true });
-		a.in.emit("what is the answer?");
-		const resp = await promise;
-		expect(resp?.content).toBe("the answer is 42");
-
-		parent.destroy();
-	});
-
-	it("typed out — outMapper transforms LLMResponse → caller type", async () => {
-		const parent = new Graph("parent");
-		const a = agent<string, { upper: string }>(parent, {
-			name: "shouter",
-			adapter: syncAdapter("hello"),
-			outMapper: (r) => ({ upper: r.content.toUpperCase() }),
-		});
-
-		const promise = awaitSettled(a.out, { skipCurrent: true });
-		a.in.emit("say hi");
-		const out = await promise;
-		expect(out?.upper).toBe("HELLO");
-		parent.destroy();
-	});
-
-	it("typed in — inMapper translates caller type → string", async () => {
-		const parent = new Graph("parent");
-		const a = agent<{ topic: string; depth: number }, LLMResponse>(parent, {
-			name: "templated",
-			adapter: syncAdapter("response"),
-			inMapper: (req) => `Tell me about ${req.topic} at depth ${req.depth}`,
-		});
-
-		const promise = awaitSettled(a.out, { skipCurrent: true });
-		a.in.emit({ topic: "TLA+", depth: 3 });
-		const resp = await promise;
-		expect(resp?.content).toBe("response");
-		// chat.messages records the mapped string.
-		const messages = a.graph.loop.chat.allMessages();
-		expect(messages[0]?.content).toBe("Tell me about TLA+ at depth 3");
-		parent.destroy();
-	});
-
-	it("default inMapper throws when TIn isn't string", () => {
-		const parent = new Graph("parent");
-		const a = agent<{ x: number }, LLMResponse>(parent, {
-			name: "bad",
-			adapter: syncAdapter("x"),
-		} as AgentSpec<{ x: number }, LLMResponse>);
-
-		expect(() => a.in.emit({ x: 1 })).toThrow(TypeError);
-		parent.destroy();
-	});
-});
-
-// ---------------------------------------------------------------------------
-// Status mirror + cost rollup
-// ---------------------------------------------------------------------------
-
-describe("agent() — status + cost", () => {
-	it("status starts idle, transitions to done after a successful run", async () => {
-		const parent = new Graph("parent");
-		const a = agent(parent, {
-			name: "stat",
-			adapter: syncAdapter("ok"),
-		});
-
-		expect(a.status.cache).toBe("idle");
-		const promise = awaitSettled(a.out, { skipCurrent: true });
-		a.in.emit("go");
-		await promise;
-		expect(a.status.cache).toBe("done");
-		parent.destroy();
-	});
-
-	it("cost rolls forward from LLMResponse.usage (full TokenUsage)", async () => {
-		const parent = new Graph("parent");
-		const a = agent(parent, {
-			name: "cost-meter",
-			adapter: syncAdapter("ok", { tokens: 30 }),
-		});
-
-		expect(a.cost.cache).toEqual(ZERO_COST);
-		const promise = awaitSettled(a.out, { skipCurrent: true });
-		a.in.emit("go");
-		await promise;
-		const cost = a.cost.cache as CostState;
-		expect(cost.usage.input.regular + cost.usage.output.regular).toBe(30);
-		expect(cost.turns).toBeGreaterThan(0);
-		parent.destroy();
-	});
-
-	it("cost resets on each new in.emit (per-input scope)", async () => {
-		const parent = new Graph("parent");
-		const a = agent(parent, {
-			name: "per-input",
-			adapter: syncAdapter("ok", { tokens: 20 }),
-		});
-
-		const p1 = awaitSettled(a.out, { skipCurrent: true });
-		a.in.emit("first");
-		await p1;
-		const firstCost = a.cost.cache as CostState;
-		expect(firstCost.usage.input.regular + firstCost.usage.output.regular).toBe(20);
-
-		const p2 = awaitSettled(a.out, { skipCurrent: true });
-		a.in.emit("second");
-		await p2;
-		const secondCost = a.cost.cache as CostState;
-		expect(secondCost.usage.input.regular + secondCost.usage.output.regular).toBe(20);
-		parent.destroy();
-	});
-});
-
-// ---------------------------------------------------------------------------
-// Reactive tools (DF12 substrate)
-// ---------------------------------------------------------------------------
-
-describe("agent() — reactive tools (DF12 substrate)", () => {
-	it("static-array tools register at construction", () => {
-		const parent = new Graph("parent");
-		const tool: ToolDefinition = {
-			name: "calc",
-			description: "double a number",
-			parameters: {},
-			handler: (args) => (args.x as number) * 2,
-		};
-		const a = agent(parent, {
-			name: "with-tools",
-			adapter: syncAdapter("ok"),
-			tools: [tool],
-		});
-
-		expect(
-			((a.graph.loop.tools.schemas.cache as readonly ToolDefinition[]) ?? []).some(
-				(t) => t.name === "calc",
-			),
-		).toBe(true);
-		parent.destroy();
-	});
-
-	it("Node-form tools — registry reconciles add / remove on each emit", () => {
-		const parent = new Graph("parent");
-		const toolA: ToolDefinition = {
-			name: "alpha",
-			description: "",
-			parameters: {},
-			handler: () => null,
-		};
-		const toolB: ToolDefinition = {
-			name: "beta",
-			description: "",
-			parameters: {},
-			handler: () => null,
-		};
-		const toolsNode = node<readonly ToolDefinition[]>([], { initial: [toolA] });
-		const a = agent(parent, {
-			name: "reactive-tools",
-			adapter: syncAdapter("ok"),
-			tools: toolsNode,
-		});
-
-		const toolNames = () =>
-			((a.graph.loop.tools.schemas.cache as readonly ToolDefinition[]) ?? []).map((t) => t.name);
-
-		expect(toolNames()).toEqual(["alpha"]);
-
-		// Add beta, remove alpha.
-		toolsNode.emit([toolB]);
-		expect(toolNames()).toEqual(["beta"]);
-
-		// Add both back.
-		toolsNode.emit([toolA, toolB]);
-		expect(toolNames().sort()).toEqual(["alpha", "beta"]);
-		parent.destroy();
-	});
-});
-
-// ---------------------------------------------------------------------------
-// Memory partition (§29 default-private + explicit-shared)
-// ---------------------------------------------------------------------------
-
-describe("agent() — memory partition", () => {
-	it("default: no memory subgraph mounted (private; lazy)", () => {
-		const parent = new Graph("parent");
-		const a = agent(parent, {
-			name: "no-mem",
-			adapter: syncAdapter("ok"),
-		});
-		expect(a.graph.memory).toBeNull();
-		// `memory/` mount path is absent.
-		expect(() => a.graph.node("memory")).toThrow();
-		parent.destroy();
-	});
-
-	// NOTE: sharing AgentMemoryGraph requires constructing one — defer that
-	// integration test to the Phase 13.M / 13.G+H downstream consumer test.
-	// The contract is: passing the SAME `memory` instance to two agents
-	// mounts it once per agent. The mount-once rule of `Graph.mount` means
-	// the SECOND mount throws; sharing is via reference, not co-mount. The
-	// gap-analysis Q6-c lock acknowledges this — full sharing semantics are
-	// for the §29 handoff recipe, not 13.G surface.
-	it("explicit memory: passes through onto the bundle's graph", () => {
-		const parent = new Graph("parent");
-		const memorySubgraph = new Graph("shared-mem-stub");
-		const a = agent(parent, {
-			name: "with-mem",
-			adapter: syncAdapter("ok"),
-			memory: memorySubgraph as any,
-		});
-		expect(a.graph.memory).toBe(memorySubgraph);
-		// Mount actually happened — the subgraph is reachable as `<agent-name>::memory`
-		// under the parent (mount creates a hop, not a flat node).
-		expect(() => a.graph.node("memory")).toThrow(/unknown (node|name)/i);
-		parent.destroy();
-	});
-});
-
-// ---------------------------------------------------------------------------
-// presetRegistry()
-// ---------------------------------------------------------------------------
-
-describe("presetRegistry()", () => {
-	it("starts empty when initial omitted", () => {
-		const r = presetRegistry<number>();
-		expect(r.registry.size).toBe(0);
-	});
-
-	it("starts populated when initial passed", () => {
-		const r = presetRegistry<number>(
-			new Map([
-				["a", 1],
-				["b", 2],
-			]),
-		);
-		expect(r.registry.size).toBe(2);
-		expect(r.registry.get("a")).toBe(1);
-	});
-
-	it("put adds / replaces; remove returns existed flag", () => {
-		const r = presetRegistry<string>();
-		r.put("x", "first");
-		expect(r.registry.get("x")).toBe("first");
-
-		r.put("x", "second");
-		expect(r.registry.get("x")).toBe("second");
-
-		expect(r.remove("x")).toBe(true);
-		expect(r.remove("x")).toBe(false);
-		expect(r.registry.has("x")).toBe(false);
-	});
-
-	it("registry.entries is a reactive Node — subscribe sees live updates", () => {
-		const r = presetRegistry<string>();
-		const seen: ReadonlyMap<string, string>[] = [];
-		const unsub = r.registry.entries.subscribe((msgs) => {
-			for (const m of msgs) {
-				if (m[0] === DATA) seen.push(m[1] as ReadonlyMap<string, string>);
-			}
-		});
-
-		r.put("a", "alpha");
-		r.put("b", "beta");
-		r.remove("a");
-
-		// Initial push-on-subscribe + 3 mutations = 4 snapshots.
-		expect(seen.length).toBeGreaterThanOrEqual(3);
-		const last = seen.at(-1) as ReadonlyMap<string, string>;
-		expect(last.has("a")).toBe(false);
-		expect(last.get("b")).toBe("beta");
-		unsub();
-	});
-});
-
-// ---------------------------------------------------------------------------
-// Re-entrancy under nested drain (F2 reachability)
-// ---------------------------------------------------------------------------
-
-describe("agent() — F2 reachability", () => {
-	it("two-agent reactive handoff (subscriber on classifier.out kicks executor.in)", async () => {
-		const parent = new Graph("parent");
-		const classifier = agent(parent, {
-			name: "cls",
-			adapter: syncAdapter("ROUTE-A"),
-		});
-		const executor = agent(parent, {
-			name: "exe",
-			adapter: syncAdapter("EXEC-OK"),
-		});
-
-		// F2-fixed: subscriber on classifier.out can call executor.in.emit
-		// inside the classifier's drain without deadlocking.
-		const executorOuts: LLMResponse[] = [];
-		const subOut = executor.out.subscribe((msgs) => {
-			for (const m of msgs) {
-				if (m[0] === DATA) executorOuts.push(m[1] as LLMResponse);
-			}
-		});
-		const subBridge = classifier.out.subscribe((msgs) => {
-			for (const m of msgs) {
-				if (m[0] === DATA) {
-					executor.in.emit((m[1] as LLMResponse).content);
-				}
-			}
-		});
-
-		const promise = awaitSettled(executor.out, { skipCurrent: true });
-		classifier.in.emit("classify this");
-		await promise;
-		expect(executorOuts.map((r) => r.content)).toEqual(["EXEC-OK"]);
-
-		subOut();
-		subBridge();
-		parent.destroy();
-	});
-});
-
-// ---------------------------------------------------------------------------
-// Bundle contract — direct AgentGraph construction
-// ---------------------------------------------------------------------------
-
-// ---------------------------------------------------------------------------
-// Mid-run input queueing (N1(b) lock — /qa pass 2026-05-01)
-// ---------------------------------------------------------------------------
-
-describe("agent() — N1(b): mid-run input queue", () => {
-	it("queues mid-run inputs and processes them sequentially after the prior settles", async () => {
-		const parent = new Graph("parent");
-		// Per-input scripted responses so we can verify each input is
-		// processed in order with its own response.
-		const responses = ["A", "B", "C"];
-		let i = 0;
-		const adapter: LLMAdapter = {
-			provider: "queued-mock",
-			invoke() {
-				const c = responses[i++] ?? "X";
-				return {
-					content: c,
-					finishReason: "end_turn",
-					usage: { input: { regular: 1 }, output: { regular: 1 } },
-				} satisfies LLMResponse;
-			},
-			async *stream() {
-				yield { type: "finish", reason: "stop" };
-			},
-		};
-		const a = agent(parent, { name: "queued", adapter });
-		const seen: string[] = [];
-		const sub = a.out.subscribe((msgs) => {
-			for (const m of msgs) {
-				if (m[0] === DATA) seen.push((m[1] as LLMResponse).content);
-			}
-		});
-
-		// Three rapid emits — the first kicks the loop; the second and third
-		// queue while the first is in flight.
-		a.in.emit("first");
-		a.in.emit("second");
-		a.in.emit("third");
-
-		// The drain effect chains the next pull on each `done` transition;
-		// awaiting a tick lets the chain settle.
-		await Promise.resolve();
-
-		expect(seen).toEqual(["A", "B", "C"]);
-		// chat.messages records all three user inputs + three assistant
-		// responses, in order.
-		const messages = a.graph.loop.chat.allMessages();
-		expect(messages.filter((m) => m.role === "user").map((m) => m.content)).toEqual([
-			"first",
-			"second",
-			"third",
-		]);
-		sub();
-		parent.destroy();
-	});
-
-	it("rejects mid-run reset corruption — prior in-flight cost is NOT zeroed by next emit", async () => {
-		const parent = new Graph("parent");
-		// Each call has a unique cost (10, 20, 30) so we can verify per-input
-		// cost scoping under the queue.
-		let i = 0;
-		const adapter: LLMAdapter = {
-			provider: "cost-mock",
-			invoke() {
-				const tokens = (i + 1) * 10;
-				i++;
-				return {
-					content: `r${i}`,
-					finishReason: "end_turn",
-					usage: {
-						input: { regular: tokens / 2 },
-						output: { regular: tokens / 2 },
-					},
-				} satisfies LLMResponse;
-			},
-			async *stream() {
-				yield { type: "finish", reason: "stop" };
-			},
-		};
-		const a = agent(parent, { name: "cost-q", adapter });
-		const costs: number[] = [];
-		const sub = a.out.subscribe((msgs) => {
-			for (const m of msgs) {
-				if (m[0] === DATA) {
-					const cost = a.cost.cache as CostState;
-					costs.push(cost.usage.input.regular + cost.usage.output.regular);
-				}
-			}
-		});
-
-		a.in.emit("first");
-		a.in.emit("second");
-		await Promise.resolve();
-
-		// Cost is per-input: first is 10, second is 20 (NOT 30 = sum of both).
-		expect(costs).toEqual([10, 20]);
-		sub();
-		parent.destroy();
-	});
-});
-
-describe("AgentGraph — direct construction (no parent.mount)", () => {
-	it("can be constructed standalone and mounted later", async () => {
-		const standalone = new AgentGraph<string, LLMResponse>({
-			name: "standalone",
-			adapter: syncAdapter("hi"),
-		});
-		const parent = new Graph("parent");
-		parent.mount("standalone", standalone);
-
-		const promise = awaitSettled(standalone.out, { skipCurrent: true });
-		standalone.in.emit("ping");
-		const resp = await promise;
-		expect(resp?.content).toBe("hi");
-		parent.destroy();
-	});
-});
-
-// Type-level smoke: the bundle's TIn / TOut flow correctly through.
-type _CheckTypes = {
-	default: AgentBundle<string, LLMResponse>;
-	custom: AgentBundle<{ q: string }, { a: string }>;
-};
-const _typeCheck: _CheckTypes | undefined = undefined;
-void _typeCheck;
diff --git a/src/__tests__/utils/ai/agents/multi-agent-example.test.ts b/src/__tests__/utils/ai/agents/multi-agent-example.test.ts
deleted file mode 100644
index 855a4d66..00000000
--- a/src/__tests__/utils/ai/agents/multi-agent-example.test.ts
+++ /dev/null
@@ -1,479 +0,0 @@
-/**
- * Phase 13.M — Worked multi-agent example (design lock-test).
- *
- * Per `docs/implementation-plan.md` §13.M and
- * `archive/docs/SESSION-multi-agent-gap-analysis.md` §13 #9, this file demonstrates
- * a two-agent handoff topology using **only shipped primitives** —
- * `messagingHub`, `topic`, `topicBridge`, `agentLoop`, `valve`, `Graph.derived`,
- * `Graph.effect`, `Graph.state`, and `awaitSettled`.
- *
- * The point is NOT to ship a polished multi-agent API — that lands in
- * Phase 13.B–13.I. The point is to **lock the topology** under shipped primitives
- * BEFORE those new primitives are designed, so the friction surfaced here drives
- * the design of `Message<T>` (13.B), `selector` / `materialize` (13.C),
- * `valve` `abortInFlight` (13.E), `humanInput` / `tracker` (13.F),
- * `class AgentGraph` / `AgentBundle` / `agent()` (13.G–13.H), and
- * `spawnable()` (13.I).
- *
- * **Friction filed in `docs/optimizations.md` ("Phase 13 design-session inputs"):**
- * - `executor.run(...)` is imperatively invoked from a reactive subscribe
- *   handler. There is no reactive `bundle.in: NodeInput<TIn>` today — the
- *   `agentLoop` is kicked by Promise-bridge `run()`. This motivates 13.G's
- *   typed `AgentBundle.in`.
- * - Cost extraction reaches into `lastResponse.usage` shape directly. This
- *   motivates 13.G's `bundle.cost: Node<CostState>`.
- * - The spawn-topic + depth-valve recipe is hand-rolled. This motivates 13.I
- *   `spawnable()` wrapping `MessagingHubGraph` + presetRegistry + materialize +
- *   depth-cap valve + termination contract.
- * - `SpawnRequest` is an inline tuple (`{ presetId; payload; depth }`) with no
- *   `id` / `correlationId` / `expiresAt`. This motivates 13.B's standard
- *   `Message<T>` envelope.
- *
- * **Cross-graph `explain` (G6 / 13.K preview):** the final test asserts that
- * `parent.describe({ explain: { from, to } })` walks across the
- * `parent.mount("classifier", classifier)` boundary into the classifier's
- * internal `lastResponse` node. If this fails, file 13.K as a hard gap before
- * 13.G/H land — the static-face / dynamic-interior pitch depends on it.
- */
-
-import { batch, DATA } from "@graphrefly/pure-ts/core";
-import { valve } from "@graphrefly/pure-ts/extra";
-import { Graph } from "@graphrefly/pure-ts/graph";
-import { describe, expect, it } from "vitest";
-import { agentLoop } from "../../../../presets/ai/index.js";
-import type { SpawnPayload } from "../../../../presets/harness/spawnable.js";
-import type { LLMAdapter, LLMResponse } from "../../../../utils/ai/index.js";
-import { type Message, messagingHub, topic } from "../../../../utils/messaging/index.js";
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-/**
- * Spawn task input shape — `taskInput` carries the actual work (`payload`)
- * plus a `depth` counter so the depth-valve recipe can gate at value level
- * before any active-slot bookkeeping. The shipped {@link SpawnPayload}
- * envelope only carries `{ presetId, taskInput }`; depth is inlined into
- * `taskInput` because the pre-13.I recipe does not yet have access to the
- * `active-slot` Node from the inside.
- */
-interface SpawnTaskInput {
-	readonly payload: string;
-	readonly depth: number;
-}
-
-/** Convenience alias for the spawn-topic envelope used throughout this test. */
-type SpawnRequestMessage = Message<SpawnPayload<SpawnTaskInput>>;
-
-/** Sum input + output regular tokens out of an `LLMResponse`. */
-function tokensOf(resp: LLMResponse | undefined): number {
-	if (resp === undefined) return 0;
-	const inTok = resp.usage?.input?.regular ?? 0;
-	const outTok = resp.usage?.output?.regular ?? 0;
-	return inTok + outTok;
-}
-
-/**
- * Build a synchronous `LLMAdapter` that returns a single scripted response
- * with a configurable usage payload. The `usage` field is populated so the
- * cost-bubble assertion has non-zero numbers.
- */
-function adapterWithCost(content: string, tokens: number): LLMAdapter {
-	const resp: LLMResponse = {
-		content,
-		finishReason: "end_turn",
-		usage: {
-			input: { regular: Math.floor(tokens / 2) },
-			output: { regular: Math.ceil(tokens / 2) },
-		},
-	};
-	return {
-		provider: "mock-with-cost",
-		invoke() {
-			return resp;
-		},
-		async *stream() {
-			yield { type: "token", delta: content };
-			yield {
-				type: "usage",
-				usage: { input: { regular: tokens / 2 }, output: { regular: tokens / 2 } },
-			};
-			yield { type: "finish", reason: "stop" };
-		},
-	};
-}
-
-// ---------------------------------------------------------------------------
-// 1. Handoff: classifier → executor via topicBridge
-// ---------------------------------------------------------------------------
-
-describe("multi-agent example (Phase 13.M lock-test)", () => {
-	it("classifier → executor handoff via topicBridge", async () => {
-		const parent = new Graph("parent");
-
-		// Hub with two topics: intake (user request) + handoff (classifier → executor).
-		const hub = messagingHub("hub");
-		parent.mount("hub", hub);
-		const intakeTopic = hub.topic<string>("intake");
-		const handoffTopic = hub.topic<string>("handoff");
-
-		// Two real `agentLoop` instances. classifier maps "issue text" → "route
-		// label"; executor consumes the route label and produces a fix line.
-		const classifier = agentLoop("classifier", {
-			adapter: adapterWithCost("fix-bug-X", 20),
-			systemPrompt: "Classifier: emit a short route label.",
-		});
-		const executor = agentLoop("executor", {
-			adapter: adapterWithCost("fixed bug X", 40),
-			systemPrompt: "Executor: act on the routed task.",
-		});
-		parent.mount("classifier", classifier);
-		parent.mount("executor", executor);
-
-		// --- Bridge 1: classifier.lastResponse → handoffTopic.publish.
-		// FRICTION (filed in optimizations.md "Phase 13 design-session inputs" F4):
-		// `topicBridge` connects two `TopicGraph<T>`s, but
-		// `classifier.lastResponse` is a `Node<LLMResponse>` (post-F9-fix
-		// SENTINEL form — no `null` placeholder). Without 13.G's `bundle.out:
-		// Node<TOut>` typed as either a topic surface or a reactive emitter
-		// `topicBridge` accepts as a Node source, we hand-roll a `subscribe`
-		// that publishes the unwrapped content into the topic. Post-F9-fix
-		// the bridge no longer needs an `if (resp == null) continue` guard —
-		// the SENTINEL state guarantees no spurious push-on-subscribe DATA.
-		const handoffPublishes: string[] = [];
-		const subPublish = classifier.lastResponse.subscribe((msgs) => {
-			for (const m of msgs) {
-				if (m[0] !== DATA) continue;
-				const resp = m[1] as LLMResponse;
-				handoffTopic.publish(resp.content);
-				handoffPublishes.push(resp.content);
-			}
-		});
-
-		// --- Bridge 2: handoffTopic.latest → executor.run(...) reactive kick.
-		// agentLoop has no reactive `in: NodeInput<TIn>` (Phase 13.G will add
-		// it as `bundle.in`); until then the kick is imperative via
-		// `executor.run()`. F2 fix (2026-05-01) makes this safe under nested
-		// drains — the previous version deadlocked because `latestMessages`
-		// closure mirror lagged the actual `chat.messages.cache` when
-		// promptInput fired inside another agent's drain. promptInput now
-		// reads `chat.messages.cache` directly (sole-owner-reactive-reader
-		// per Phase 12 D1 lock); see `optimizations.md` F2.
-		const executorPromises: Promise<LLMResponse | null>[] = [];
-		const handoffSub = handoffTopic.latest.subscribe((msgs) => {
-			for (const m of msgs) {
-				if (m[0] !== DATA) continue;
-				const item = m[1] as string;
-				executorPromises.push(executor.run(item));
-			}
-		});
-
-		try {
-			// Kick the classifier with the user request.
-			intakeTopic.publish("Please classify and act on issue: missing fn");
-			const classified = await classifier.run("Please classify and act on issue: missing fn");
-			expect(classified?.content).toBe("fix-bug-X");
-
-			// The handoff fired reactively during classifier's drain, kicked
-			// the executor inside the same drain (post-F2-fix), and the
-			// executor's run Promise is now pending. Await it.
-			expect(executorPromises.length).toBe(1);
-			expect(handoffPublishes).toEqual(["fix-bug-X"]);
-			expect(handoffTopic.retained()).toContain("fix-bug-X");
-			const executed = await executorPromises[0]!;
-			expect(executed?.content).toBe("fixed bug X");
-		} finally {
-			handoffSub();
-			subPublish();
-			parent.destroy();
-		}
-	});
-
-	// -------------------------------------------------------------------------
-	// 2. Cost-bubble: parent.derived aggregates costs across both agents
-	// -------------------------------------------------------------------------
-
-	it("cost bubbles to a parent.derived aggregator", async () => {
-		const parent = new Graph("parent-cost");
-
-		const classifier = agentLoop("classifier", {
-			adapter: adapterWithCost("ok", 30),
-			systemPrompt: "Classifier",
-		});
-		const executor = agentLoop("executor", {
-			adapter: adapterWithCost("done", 50),
-			systemPrompt: "Executor",
-		});
-		parent.mount("classifier", classifier);
-		parent.mount("executor", executor);
-
-		// FRICTION: extracting cost from `lastResponse.usage` couples the
-		// aggregator to LLMResponse shape. Phase 13.G's `bundle.cost:
-		// Node<CostState>` removes this — parent reads `bundle.cost` directly.
-		const totalCost = parent.derived<number>(
-			"totalCost",
-			[classifier.lastResponse, executor.lastResponse],
-			(batchData, ctx) => {
-				const cBatch = batchData[0];
-				const eBatch = batchData[1];
-				// Post-F9-fix: lastResponse stays SENTINEL (`undefined`) until
-				// the first real response. `tokensOf` handles `undefined` as
-				// 0 tokens.
-				const cResp =
-					cBatch != null && cBatch.length > 0
-						? (cBatch.at(-1) as LLMResponse)
-						: (ctx.prevData[0] as LLMResponse | undefined);
-				const eResp =
-					eBatch != null && eBatch.length > 0
-						? (eBatch.at(-1) as LLMResponse)
-						: (ctx.prevData[1] as LLMResponse | undefined);
-				return [tokensOf(cResp) + tokensOf(eResp)];
-			},
-			{ keepAlive: true },
-		);
-
-		await classifier.run("classify something");
-		await executor.run("execute something");
-
-		expect(totalCost.cache).toBe(80);
-		parent.destroy();
-	});
-
-	// -------------------------------------------------------------------------
-	// 3. Depth valve: spawn topic gated by depth counter cuts forced recursion
-	// -------------------------------------------------------------------------
-
-	it("depth-valve cuts spawn requests past the cap", () => {
-		const parent = new Graph("parent-depth");
-
-		const spawnTopic = topic<SpawnRequestMessage>("spawns");
-		parent.mount("spawns", spawnTopic);
-
-		// Depth counter — the substrate for the depth-cap recipe (G5 reframe in
-		// gap-analysis §11). In `spawnable()` (Phase 13.I) this is a `derived`
-		// over the active-slot map's size; here we hand-emit it.
-		const depth = parent.state<number>("depth", 0);
-		const depthCap = 2;
-		const depthOpen = parent.derived<boolean>(
-			"depthOpen",
-			[depth],
-			(batchData, ctx) => {
-				const b = batchData[0];
-				const n = (b != null && b.length > 0 ? b.at(-1) : ctx.prevData[0]) as number;
-				return [n < depthCap];
-			},
-			{ keepAlive: true },
-		);
-
-		// `valve(spawnTopic.latest, depthOpen)` — gate at value level. RESOLVED
-		// when closed; forwards latest when open. We tap into the gated stream
-		// to record what made it through.
-		const gatedSpawns = valve(spawnTopic.latest, depthOpen);
-		parent.add(gatedSpawns as import("../../../../core/node.js").Node<unknown>, {
-			name: "gatedSpawns",
-		});
-
-		const gatedSeen: SpawnRequestMessage[] = [];
-		const sub = gatedSpawns.subscribe((msgs) => {
-			for (const m of msgs) if (m[0] === DATA) gatedSeen.push(m[1] as SpawnRequestMessage);
-		});
-
-		try {
-			// First two spawns at depth 0 / 1 — gate is open.
-			depth.emit(0);
-			spawnTopic.publish({
-				id: "s1",
-				payload: { presetId: "child", taskInput: { payload: "task-1", depth: 0 } },
-			});
-			depth.emit(1);
-			spawnTopic.publish({
-				id: "s2",
-				payload: { presetId: "child", taskInput: { payload: "task-2", depth: 1 } },
-			});
-			// Third spawn at depth 2 — gate closes (2 < 2 is false), valve drops.
-			depth.emit(2);
-			spawnTopic.publish({
-				id: "s3",
-				payload: { presetId: "child", taskInput: { payload: "task-3", depth: 2 } },
-			});
-
-			expect(gatedSeen.map((s) => s.id)).toEqual(["s1", "s2"]);
-		} finally {
-			sub();
-			parent.destroy();
-		}
-	});
-
-	// -------------------------------------------------------------------------
-	// 4. Cross-graph explain (G6 / 13.K preview)
-	// -------------------------------------------------------------------------
-
-	it("parent.describe({ explain }) walks across the mount boundary", async () => {
-		const parent = new Graph("parent-explain");
-
-		const classifier = agentLoop("classifier", {
-			adapter: adapterWithCost("label", 10),
-			systemPrompt: "Classifier",
-		});
-		parent.mount("classifier", classifier);
-
-		// Parent derived that depends on a child node — the simplest cross-graph
-		// edge. If this `explain` walk loses the mount segment, file 13.K.
-		// Post-F9-fix: lastResponse SENTINEL `undefined` until first response.
-		parent.derived<string>(
-			"costLabel",
-			[classifier.lastResponse],
-			(batchData, ctx) => {
-				const b = batchData[0];
-				const resp = (b != null && b.length > 0 ? b.at(-1) : ctx.prevData[0]) as
-					| LLMResponse
-					| undefined;
-				if (resp === undefined) return [];
-				return [`${resp.content}:${tokensOf(resp)}`];
-			},
-			{ keepAlive: true },
-		);
-
-		await classifier.run("classify");
-
-		const chain = parent.describe({
-			explain: { from: "classifier::lastResponse", to: "costLabel" },
-		});
-		expect(chain.found).toBe(true);
-		// Steps walk parent.costLabel ← classifier::lastResponse — every step
-		// must be a named, non-anonymous path so future debuggers can drill in.
-		for (const step of chain.steps) {
-			expect(step.path).not.toContain("<anonymous>");
-			expect(step.path).not.toBe("");
-		}
-
-		parent.destroy();
-	});
-
-	// -------------------------------------------------------------------------
-	// 5. SENTINEL guard (F9 fix landed) — `classifier.lastResponse` stays
-	//    SENTINEL (no DATA emitted) until the first real response. Bridge
-	//    subscribers see no spurious push-on-subscribe `null` and do NOT
-	//    need a `if (resp == null) continue` guard. Pins the §1a "stay
-	//    SENTINEL" invariant per `feedback_use_prevdata_for_sentinel`.
-	// -------------------------------------------------------------------------
-
-	it("lastResponse stays SENTINEL until first real response", () => {
-		const parent = new Graph("parent-sentinel");
-
-		const classifier = agentLoop("classifier", {
-			adapter: adapterWithCost("label", 10),
-			systemPrompt: "Classifier",
-		});
-		parent.mount("classifier", classifier);
-
-		const dataPayloads: unknown[] = [];
-		const sub = classifier.lastResponse.subscribe((msgs) => {
-			for (const m of msgs) {
-				if (m[0] === DATA) dataPayloads.push(m[1]);
-			}
-		});
-
-		try {
-			// Post-F9-fix: `lastResponse` has no `initial` — push-on-subscribe
-			// delivers START + the cached value, but the cached value is
-			// SENTINEL (`undefined`), so START is delivered with no DATA tuple.
-			// Bridge subscribers can subscribe-then-no-op without a `null`
-			// guard. Cache is `undefined` until the loop produces a response.
-			expect(dataPayloads).toEqual([]);
-			expect(classifier.lastResponse.cache).toBeUndefined();
-		} finally {
-			sub();
-			parent.destroy();
-		}
-	});
-
-	// -------------------------------------------------------------------------
-	// 5a. Bridge regression — wiring agent A's lastResponse into agent B's
-	//     in.emit must NOT kick agent B before A produces a real response.
-	//     Pre-F9-fix, the eager `null` from A would flow through the bridge
-	//     and trigger B's chat.append; post-fix the bridge stays quiet.
-	// -------------------------------------------------------------------------
-
-	it("bridge subscriber does not kick agent B before agent A emits", () => {
-		const parent = new Graph("parent-bridge");
-
-		// Agent A: synchronous adapter that emits one response.
-		const agentA = agentLoop("agentA", {
-			adapter: adapterWithCost("from-A", 10),
-			systemPrompt: "A",
-		});
-		// Agent B: also a real agentLoop so we can observe its chat-history.
-		const agentB = agentLoop("agentB", {
-			adapter: adapterWithCost("from-B", 10),
-			systemPrompt: "B",
-		});
-		parent.mount("agentA", agentA);
-		parent.mount("agentB", agentB);
-
-		// Bridge: A's lastResponse → B's chat.append (and we'd kick B's run).
-		// The body has NO `if (resp == null)` guard — relies on the SENTINEL
-		// invariant: no DATA arrives until A produces a real response.
-		const bWasKicked: string[] = [];
-		const subBridge = agentA.lastResponse.subscribe((msgs) => {
-			for (const m of msgs) {
-				if (m[0] !== DATA) continue;
-				const resp = m[1] as LLMResponse;
-				bWasKicked.push(resp.content);
-				agentB.chat.append("user", resp.content);
-			}
-		});
-
-		try {
-			// A has not been kicked yet. Bridge must not have fired.
-			expect(bWasKicked).toEqual([]);
-			expect(agentB.chat.allMessages()).toEqual([]);
-		} finally {
-			subBridge();
-			parent.destroy();
-		}
-	});
-
-	// -------------------------------------------------------------------------
-	// 6. SpawnRequest envelope (Phase 13.B preview) — confirm hand-rolled shape
-	//    is compatible with `topic<T>` round-tripping. When 13.B's `Message<T>`
-	//    lands, this test rewires to the standard envelope without changing the
-	//    topology.
-	// -------------------------------------------------------------------------
-
-	it("spawn topic round-trips a Message-shaped envelope", () => {
-		const parent = new Graph("parent-envelope");
-		const spawnTopic = topic<SpawnRequestMessage>("spawns");
-		parent.mount("spawns", spawnTopic);
-
-		const seen: SpawnRequestMessage[] = [];
-		const sub = spawnTopic.events.subscribe((msgs) => {
-			for (const m of msgs) {
-				if (m[0] === DATA) {
-					for (const v of m[1] as readonly SpawnRequestMessage[]) seen.push(v);
-				}
-			}
-		});
-
-		try {
-			batch(() => {
-				spawnTopic.publish({
-					id: "req-1",
-					correlationId: "user-session-42",
-					payload: {
-						presetId: "researcher",
-						taskInput: { payload: "Find prior incidents", depth: 0 },
-					},
-				});
-			});
-
-			expect(seen).toHaveLength(1);
-			expect(seen[0]?.correlationId).toBe("user-session-42");
-			expect(seen[0]?.payload.presetId).toBe("researcher");
-			expect(seen[0]?.payload.taskInput.payload).toBe("Find prior incidents");
-		} finally {
-			sub();
-			parent.destroy();
-		}
-	});
-});
diff --git a/src/__tests__/utils/ai/agents/tool-execution.test.ts b/src/__tests__/utils/ai/agents/tool-execution.test.ts
deleted file mode 100644
index ad1e06b9..00000000
--- a/src/__tests__/utils/ai/agents/tool-execution.test.ts
+++ /dev/null
@@ -1,209 +0,0 @@
-/**
- * Standalone unit tests for `toolExecution`. Exercises the primitive
- * directly with a hand-rolled `toolCalls` state node + a real
- * `ToolRegistryGraph`, without routing through the full `agentLoop`
- * pipeline. Catches contract regressions cheaply.
- *
- * Covers:
- *   - happy-path multi-call batch returns one ToolResult per call in order
- *   - empty batch throws the documented invariant violation
- *   - rescue mode: failed call emits `{error}` JSON, siblings continue
- *   - propagate mode: failed call ERRORs out the batch
- *   - retry: first attempt fails, second succeeds within retryCount
- *   - switchMap supersede aborts in-flight handler signal
- */
-
-import { DATA, ERROR, node } from "@graphrefly/pure-ts/core";
-import { describe, expect, it } from "vitest";
-import { awaitSettled } from "../../../../base/sources/settled.js";
-import type { ToolCall } from "../../../../utils/ai/adapters/core/types.js";
-import { type ToolResult, toolExecution } from "../../../../utils/ai/agents/tool-execution.js";
-import { toolRegistry } from "../../../../utils/ai/agents/tool-registry.js";
-
-function call(id: string, name: string, args: Record<string, unknown> = {}): ToolCall {
-	return { id, name, arguments: args };
-}
-
-describe("toolExecution — happy path", () => {
-	it("emits one ToolResult per ToolCall in batch order", async () => {
-		const tr = toolRegistry("hp-tools");
-		tr.register({
-			name: "echo",
-			description: "Echo back the message",
-			parameters: {},
-			handler: (args) => `echoed-${args.msg as string}`,
-		});
-		tr.register({
-			name: "add",
-			description: "Add two numbers",
-			parameters: {},
-			handler: (args) => (args.a as number) + (args.b as number),
-		});
-		const toolCalls = node<readonly ToolCall[]>([], {
-			initial: [call("c1", "echo", { msg: "hi" }), call("c2", "add", { a: 3, b: 4 })],
-		});
-		const out = toolExecution({ toolCalls, tools: tr });
-		const result = await awaitSettled(out);
-		expect(result).toEqual([
-			{ id: "c1", content: "echoed-hi" },
-			{ id: "c2", content: "7" },
-		]);
-	});
-});
-
-describe("toolExecution — empty batch", () => {
-	it("throws on empty batch (caller contract violation)", async () => {
-		const tr = toolRegistry("empty-tools");
-		const toolCalls = node<readonly ToolCall[]>([], { initial: [] });
-		const out = toolExecution({ toolCalls, tools: tr });
-		// switchMap dispatches the project fn synchronously on subscribe;
-		// the throw surfaces as ERROR on the node.
-		const errors: unknown[] = [];
-		out.subscribe((batch) => {
-			for (const m of batch) {
-				if (m[0] === ERROR) errors.push(m[1]);
-			}
-		});
-		expect(errors).toHaveLength(1);
-		expect((errors[0] as Error).message).toMatch(/empty tool-call batch/);
-	});
-});
-
-describe("toolExecution — error handling", () => {
-	it("rescue mode: failed call emits {error} JSON, sibling continues", async () => {
-		const tr = toolRegistry("err-tools");
-		tr.register({
-			name: "boom",
-			description: "Always fails",
-			parameters: {},
-			handler: () => {
-				throw new Error("kaboom");
-			},
-		});
-		tr.register({
-			name: "ok",
-			description: "Always works",
-			parameters: {},
-			handler: () => "fine",
-		});
-		const toolCalls = node<readonly ToolCall[]>([], {
-			initial: [call("c1", "boom"), call("c2", "ok")],
-		});
-		// Default onError is "rescue". retryCount=0 to stop retrying the doomed call.
-		const out = toolExecution({ toolCalls, tools: tr, retryCount: 0 });
-		const result = await awaitSettled(out);
-		expect(result).toHaveLength(2);
-		const c1 = (result as readonly ToolResult[])[0];
-		const c2 = (result as readonly ToolResult[])[1];
-		expect(c1.id).toBe("c1");
-		expect(JSON.parse(c1.content)).toEqual({ error: expect.stringContaining("kaboom") });
-		expect(c2).toEqual({ id: "c2", content: "fine" });
-	});
-
-	it("propagate mode: failed call ERRORs the batch", async () => {
-		const tr = toolRegistry("prop-tools");
-		tr.register({
-			name: "boom",
-			description: "Always fails",
-			parameters: {},
-			handler: () => {
-				throw new Error("propagated");
-			},
-		});
-		tr.register({
-			name: "ok",
-			description: "Always works",
-			parameters: {},
-			handler: () => "fine",
-		});
-		const toolCalls = node<readonly ToolCall[]>([], {
-			initial: [call("c1", "boom"), call("c2", "ok")],
-		});
-		const out = toolExecution({
-			toolCalls,
-			tools: tr,
-			retryCount: 0,
-			onError: "propagate",
-		});
-		const errors: unknown[] = [];
-		const datas: unknown[] = [];
-		out.subscribe((batch) => {
-			for (const m of batch) {
-				if (m[0] === ERROR) errors.push(m[1]);
-				if (m[0] === DATA) datas.push(m[1]);
-			}
-		});
-		// Microtasks for retrySource attempts to drain.
-		await Promise.resolve();
-		await Promise.resolve();
-		await Promise.resolve();
-		expect(errors.length).toBeGreaterThanOrEqual(1);
-		expect(datas).toEqual([]);
-	});
-});
-
-describe("toolExecution — retry", () => {
-	it("retries on transient failure and succeeds on attempt 2", async () => {
-		const tr = toolRegistry("retry-tools");
-		let attempts = 0;
-		tr.register({
-			name: "flaky",
-			description: "Fails first attempt",
-			parameters: {},
-			handler: () => {
-				attempts++;
-				if (attempts === 1) throw new Error("transient");
-				return "second-time-lucky";
-			},
-		});
-		const toolCalls = node<readonly ToolCall[]>([], { initial: [call("c1", "flaky")] });
-		const out = toolExecution({ toolCalls, tools: tr, retryCount: 1 });
-		const result = await awaitSettled(out);
-		expect(result).toEqual([{ id: "c1", content: "second-time-lucky" }]);
-		expect(attempts).toBe(2);
-	});
-});
-
-describe("toolExecution — supersede cancellation", () => {
-	it("aborts in-flight handler signal on superseding batch", async () => {
-		const tr = toolRegistry("supersede-tools");
-		const seenSignals: AbortSignal[] = [];
-		tr.register({
-			name: "longRunning",
-			description: "Never resolves until aborted",
-			parameters: {},
-			handler: (_args, opts) => {
-				if (opts?.signal) seenSignals.push(opts.signal);
-				return new Promise<string>((_resolve, reject) => {
-					if (opts?.signal?.aborted) {
-						reject(new DOMException("aborted", "AbortError"));
-						return;
-					}
-					opts?.signal?.addEventListener("abort", () =>
-						reject(new DOMException("aborted", "AbortError")),
-					);
-				});
-			},
-		});
-		tr.register({
-			name: "fast",
-			description: "Resolves immediately",
-			parameters: {},
-			handler: () => "done",
-		});
-		const toolCalls = node<readonly ToolCall[]>([], { initial: [call("c1", "longRunning")] });
-		const out = toolExecution({ toolCalls, tools: tr, retryCount: 0 });
-		out.subscribe(() => {});
-		await Promise.resolve();
-		await Promise.resolve();
-		expect(seenSignals).toHaveLength(1);
-		expect(seenSignals[0].aborted).toBe(false);
-		// Supersede with a new batch — switchMap unmounts the prior fan,
-		// which cascades through retrySource → executeReactive →
-		// AbortController.abort().
-		toolCalls.emit([call("c2", "fast")]);
-		await Promise.resolve();
-		await Promise.resolve();
-		expect(seenSignals[0].aborted).toBe(true);
-	});
-});
diff --git a/src/__tests__/utils/ai/ai.test.ts b/src/__tests__/utils/ai/ai.test.ts
deleted file mode 100644
index bddc17cb..00000000
--- a/src/__tests__/utils/ai/ai.test.ts
+++ /dev/null
@@ -1,3193 +0,0 @@
-import { DATA, node, TEARDOWN } from "@graphrefly/pure-ts/core";
-import { Graph } from "@graphrefly/pure-ts/graph";
-import { describe, expect, it } from "vitest";
-import { awaitSettled } from "../../../base/sources/settled.js";
-import { AgentLoopGraph, agentLoop, agentMemory } from "../../../presets/ai/index.js";
-import {
-	admissionFilter3D,
-	admissionScored,
-	type ChatMessage,
-	ChatStreamGraph,
-	chatStream,
-	costMeterExtractor,
-	type ExtractedToolCall,
-	frozenContext,
-	type GatedStreamHandle,
-	gatedStream,
-	gaugesAsContext,
-	graphFromSpec,
-	graphFromSpecReactive,
-	handoff,
-	type KeywordFlag,
-	keywordFlagExtractor,
-	knobsAsTools,
-	type LLMAdapter,
-	type LLMResponse,
-	llmConsolidator,
-	llmExtractor,
-	memoryRetrieval,
-	promptNode,
-	type StampedDelta,
-	type StrategyPlan,
-	streamExtractor,
-	streamingPromptNode,
-	suggestStrategy,
-	suggestStrategyReactive,
-	systemPromptBuilder,
-	type ToolCall,
-	type ToolDefinition,
-	ToolRegistryGraph,
-	toolCallExtractor,
-	toolInterceptor,
-	toolRegistry,
-	toolSelector,
-	validateGraphDef,
-} from "../../../utils/ai/index.js";
-
-// ---------------------------------------------------------------------------
-// Mock LLM adapter
-// ---------------------------------------------------------------------------
-
-/**
- * Mock LLM adapter. `stream()` yields tokens asynchronously (one microtask per
- * token) to match real adapter behavior — real LLM SDKs always involve I/O
- * between chunks. Tests MUST use reactive subscribe patterns (not synchronous
- * `.cache`) to observe stream results.
- */
-function mockAdapter(responses: LLMResponse[], streamChunks?: string[][]): LLMAdapter {
-	let idx = 0;
-	let streamIdx = 0;
-	return {
-		invoke(_messages, _opts) {
-			const resp = responses[idx] ?? responses[responses.length - 1]!;
-			idx++;
-			return resp;
-		},
-		async *stream(_messages, _opts) {
-			const chunks = streamChunks?.[streamIdx] ?? streamChunks?.[streamChunks.length - 1] ?? [];
-			streamIdx++;
-			for (const chunk of chunks) {
-				// Yield to microtask queue between tokens — real adapters always
-				// have async I/O between chunks (network, SSE frame parsing, etc.)
-				await Promise.resolve();
-				yield { type: "token" as const, delta: chunk };
-			}
-			yield {
-				type: "usage" as const,
-				usage: { input: { regular: 0 }, output: { regular: 0 } },
-			};
-			yield { type: "finish" as const, reason: "stop" };
-		},
-	};
-}
-
-// ---------------------------------------------------------------------------
-// chatStream
-// ---------------------------------------------------------------------------
-
-describe("patterns.ai.chatStream", () => {
-	it("creates a graph with messages, latest, and messageCount nodes", () => {
-		const cs = chatStream("test-chat");
-		expect(cs).toBeInstanceOf(ChatStreamGraph);
-		expect(cs.node("messageCount").cache).toBe(0);
-		// SENTINEL on empty (COMPOSITION-GUIDE §1a) — `latest.cache` is
-		// `undefined` until the first append, not a `null` placeholder.
-		expect(cs.node("latest").cache).toBeUndefined();
-	});
-
-	it("appends messages and updates derived nodes", () => {
-		const cs = chatStream("test-chat");
-		cs.append("user", "hello");
-		cs.append("assistant", "hi there");
-
-		expect(cs.node("messageCount").cache).toBe(2);
-		const latest = cs.node("latest").cache as ChatMessage;
-		expect(latest.role).toBe("assistant");
-		expect(latest.content).toBe("hi there");
-	});
-
-	it("appendToolResult adds tool role message", () => {
-		const cs = chatStream("test-chat");
-		cs.appendToolResult("call-1", '{"result": 42}');
-
-		const msgs = cs.allMessages();
-		expect(msgs.length).toBe(1);
-		expect(msgs[0]?.role).toBe("tool");
-		expect(msgs[0]?.toolCallId).toBe("call-1");
-	});
-
-	it("clear resets the stream", () => {
-		const cs = chatStream("test-chat");
-		cs.append("user", "test");
-		cs.clear();
-		expect(cs.node("messageCount").cache).toBe(0);
-		expect(cs.allMessages().length).toBe(0);
-	});
-
-	it("describe() shows expected node structure", () => {
-		const cs = chatStream("test-chat");
-		const desc = cs.describe() as { nodes: Record<string, unknown> };
-		expect(desc.nodes).toHaveProperty("messages");
-		expect(desc.nodes).toHaveProperty("latest");
-		expect(desc.nodes).toHaveProperty("messageCount");
-	});
-});
-
-// ---------------------------------------------------------------------------
-// toolRegistry
-// ---------------------------------------------------------------------------
-
-describe("patterns.ai.toolRegistry", () => {
-	it("creates a graph with definitions and schemas nodes", () => {
-		const tr = toolRegistry("test-tools");
-		expect(tr).toBeInstanceOf(ToolRegistryGraph);
-		const schemas = tr.schemas.cache as ToolDefinition[];
-		expect(schemas).toEqual([]);
-	});
-
-	it("register and unregister tools", () => {
-		const tr = toolRegistry("test-tools");
-		const tool: ToolDefinition = {
-			name: "add",
-			description: "Adds two numbers",
-			parameters: { type: "object" },
-			handler: (args) => (args.a as number) + (args.b as number),
-		};
-		tr.register(tool);
-		expect(tr.getDefinition("add")).toBeDefined();
-
-		const schemas = tr.schemas.cache as ToolDefinition[];
-		expect(schemas.length).toBe(1);
-		expect(schemas[0]?.name).toBe("add");
-
-		tr.unregister("add");
-		expect(tr.getDefinition("add")).toBeUndefined();
-		expect((tr.schemas.cache as ToolDefinition[]).length).toBe(0);
-	});
-
-	it("executeReactive runs the tool handler (scalar)", async () => {
-		const tr = toolRegistry("test-tools");
-		tr.register({
-			name: "greet",
-			description: "Greet",
-			parameters: {},
-			handler: (args) => `Hello, ${args.name}!`,
-		});
-		const result = await awaitSettled(tr.executeReactive("greet", { name: "world" }));
-		expect(result).toBe("Hello, world!");
-	});
-
-	it("executeReactive throws synchronously for unknown tool", () => {
-		const tr = toolRegistry("test-tools");
-		expect(() => tr.executeReactive("missing", {})).toThrow(/unknown tool/);
-	});
-
-	it("executeReactive forwards Node handler results", async () => {
-		const tr = toolRegistry("test-tools");
-		const n = node([], { initial: 42 });
-		tr.register({
-			name: "nodeVal",
-			description: "Reactive node",
-			parameters: {},
-			handler: () => n,
-		});
-		const result = await awaitSettled(tr.executeReactive("nodeVal", {}));
-		expect(result).toBe(42);
-	});
-
-	it("executeReactive resolves Promise handler results", async () => {
-		const tr = toolRegistry("test-tools");
-		tr.register({
-			name: "prom",
-			description: "Promise",
-			parameters: {},
-			handler: async () => 7,
-		});
-		const result = await awaitSettled(tr.executeReactive("prom", {}));
-		expect(result).toBe(7);
-	});
-
-	it("executeReactive aborts handler on supersede via threaded signal", async () => {
-		// Regression: executeReactive must thread `signal` into the handler
-		// so unsubscribing the returned node (e.g. switchMap supersede in
-		// toolExecution) actually cancels in-flight handler work.
-		let received: AbortSignal | undefined;
-		let aborted = false;
-		const tr = toolRegistry("test-tools");
-		tr.register({
-			name: "long",
-			description: "long-running",
-			parameters: {},
-			handler: (_args, opts) => {
-				received = opts?.signal;
-				received?.addEventListener("abort", () => {
-					aborted = true;
-				});
-				return new Promise(() => {
-					/* never resolves */
-				});
-			},
-		});
-		const node = tr.executeReactive("long", {});
-		const unsub = node.subscribe(() => {});
-		expect(received).toBeInstanceOf(AbortSignal);
-		expect(received?.aborted).toBe(false);
-		unsub();
-		expect(aborted).toBe(true);
-	});
-});
-
-// ---------------------------------------------------------------------------
-// toolSelector (D8)
-// ---------------------------------------------------------------------------
-
-describe("patterns.ai.toolSelector (D8)", () => {
-	const search: ToolDefinition = {
-		name: "search",
-		description: "search the web",
-		parameters: {},
-		handler: () => "ok",
-		meta: { expensive: false, destructive: false },
-	};
-	const write: ToolDefinition = {
-		name: "write",
-		description: "write a file",
-		parameters: {},
-		handler: () => "ok",
-		meta: { expensive: false, destructive: true },
-	};
-	const llm: ToolDefinition = {
-		name: "llm",
-		description: "nested LLM call",
-		parameters: {},
-		handler: () => "ok",
-		meta: { expensive: true, destructive: false },
-	};
-
-	it("filters tools reactively when predicates flip", () => {
-		const all = node<readonly ToolDefinition[]>([], { name: "all", initial: [search, write, llm] });
-		const hasBudget = node([], { name: "budget", initial: true });
-		const destructiveAllowed = node([], { name: "dstr", initial: true });
-		const sel = toolSelector(all, [
-			node(
-				[hasBudget],
-				(batchData, actions, ctx) => {
-					const data = batchData.map((batch, i) =>
-						batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-					);
-					actions.emit((t: ToolDefinition) => !(t.meta?.expensive === true) || data[0] === true);
-				},
-				{ describeKind: "derived" },
-			),
-			node(
-				[destructiveAllowed],
-				(batchData, actions, ctx) => {
-					const data = batchData.map((batch, i) =>
-						batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-					);
-					actions.emit((t: ToolDefinition) => !(t.meta?.destructive === true) || data[0] === true);
-				},
-				{ describeKind: "derived" },
-			),
-		]);
-		const unsub = sel.subscribe(() => {});
-		expect((sel.cache as readonly ToolDefinition[]).map((t) => t.name).sort()).toEqual([
-			"llm",
-			"search",
-			"write",
-		]);
-		// Deplete budget → drops expensive tools.
-		hasBudget.emit(false);
-		expect((sel.cache as readonly ToolDefinition[]).map((t) => t.name).sort()).toEqual([
-			"search",
-			"write",
-		]);
-		// Disallow destructive → drops write too.
-		destructiveAllowed.emit(false);
-		expect((sel.cache as readonly ToolDefinition[]).map((t) => t.name)).toEqual(["search"]);
-		unsub();
-	});
-
-	it("reactive allTools (e.g. registry.schemas) drives re-evaluation", () => {
-		const tr = toolRegistry("tools");
-		tr.register(search);
-		const sel = toolSelector(tr.schemas, []);
-		const unsub = sel.subscribe(() => {});
-		expect((sel.cache as readonly ToolDefinition[]).map((t) => t.name)).toEqual(["search"]);
-		tr.register(write);
-		expect((sel.cache as readonly ToolDefinition[]).map((t) => t.name).sort()).toEqual([
-			"search",
-			"write",
-		]);
-		unsub();
-	});
-
-	// Pins the documented contract (JSDoc aligned with toolInterceptor 2026-05-18):
-	// a constraint node SEEDED with `initial: null` is pass-through-while-loading
-	// (emitted null = "not-yet-ready, allow"), then enforces once a real predicate
-	// emits. Callers must seed an `initial` — never-emitted SENTINEL gating is
-	// unspecified (open core first-run-gate question); this test only exercises
-	// the seeded, deterministic path the JSDoc now promises.
-	it("seeded initial:null constraint is pass-through, then enforces on emit", () => {
-		const all = node<readonly ToolDefinition[]>([], {
-			name: "all2",
-			initial: [search, write, llm],
-		});
-		// Seeded pass-through-while-loading predicate (the JSDoc example shape).
-		const policy = node<((t: ToolDefinition) => boolean) | null>([], {
-			name: "policy",
-			initial: null,
-		});
-		const sel = toolSelector(all, [policy]);
-		const unsub = sel.subscribe(() => {});
-		// initial: null emitted → pass-through, every tool offered.
-		expect((sel.cache as readonly ToolDefinition[]).map((t) => t.name).sort()).toEqual([
-			"llm",
-			"search",
-			"write",
-		]);
-		// Real predicate emits → constraint now enforced (drops destructive).
-		policy.emit((t: ToolDefinition) => !(t.meta?.destructive === true));
-		expect((sel.cache as readonly ToolDefinition[]).map((t) => t.name).sort()).toEqual([
-			"llm",
-			"search",
-		]);
-		// Back to null → pass-through again ("not-yet-ready, allow", not "deny").
-		policy.emit(null);
-		expect((sel.cache as readonly ToolDefinition[]).map((t) => t.name).sort()).toEqual([
-			"llm",
-			"search",
-			"write",
-		]);
-		unsub();
-	});
-});
-
-// ---------------------------------------------------------------------------
-// systemPromptBuilder
-// ---------------------------------------------------------------------------
-
-describe("patterns.ai.systemPromptBuilder", () => {
-	it("assembles sections into a prompt", () => {
-		const prompt = systemPromptBuilder(["You are a helpful assistant.", "Be concise."]);
-		expect(prompt.cache).toBe("You are a helpful assistant.\n\nBe concise.");
-	});
-
-	it("reacts to section changes", () => {
-		const role = node([], { initial: "You are an assistant." });
-		const prompt = systemPromptBuilder([role, "Be concise."]);
-		expect(prompt.cache).toBe("You are an assistant.\n\nBe concise.");
-
-		role.down([[DATA, "You are a coding expert."]]);
-		expect(prompt.cache).toBe("You are a coding expert.\n\nBe concise.");
-	});
-
-	it("filters empty sections", () => {
-		const prompt = systemPromptBuilder(["hello", "", "world"]);
-		expect(prompt.cache).toBe("hello\n\nworld");
-	});
-
-	it("uses custom separator", () => {
-		const prompt = systemPromptBuilder(["a", "b"], { separator: " | " });
-		expect(prompt.cache).toBe("a | b");
-	});
-});
-
-// ---------------------------------------------------------------------------
-// promptNode({ format: "raw" }) — Tier 2.3 fold of the deleted `fromLLM`
-// ---------------------------------------------------------------------------
-
-describe("patterns.ai.promptNode (raw format — fromLLM fold)", () => {
-	it("emits the full LLMResponse object when format is 'raw'", () => {
-		const resp: LLMResponse = { content: "Hello!" };
-		const adapter = mockAdapter([resp]);
-		const msgs = node<ChatMessage[]>([], { initial: [{ role: "user", content: "hi" }] });
-		const result = promptNode<LLMResponse>(
-			adapter,
-			[msgs],
-			(m) => (m as ChatMessage[])[0]!.content,
-			{ format: "raw" },
-		);
-		const unsub = result.subscribe(() => {});
-		expect(result.cache).toEqual(resp);
-		unsub();
-	});
-});
-
-describe("patterns.ai.handoff (B10)", () => {
-	it("no condition: always routes through the specialist factory", () => {
-		const from = node<string | null>([], { initial: "hi" });
-		let factoryCalls = 0;
-		const routed = handoff(from, (input) => {
-			factoryCalls += 1;
-			return node(
-				[input],
-				(batchData, actions, ctx) => {
-					const data = batchData.map((batch, i) =>
-						batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-					);
-					actions.emit(`[specialist] ${data[0]}`);
-				},
-				{ describeKind: "derived" },
-			);
-		});
-		const unsub = routed.subscribe(() => {});
-		expect(routed.cache).toBe("[specialist] hi");
-		expect(factoryCalls).toBeGreaterThanOrEqual(1);
-		unsub();
-	});
-
-	it("condition gates specialist engagement", () => {
-		const from = node<string | null>([], { initial: "q" });
-		const urgent = node([], { initial: false });
-		const routed = handoff(
-			from,
-			(input) =>
-				node(
-					[input],
-					(batchData, actions, ctx) => {
-						const data = batchData.map((batch, i) =>
-							batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-						);
-						actions.emit(`[urgent] ${data[0]}`);
-					},
-					{ describeKind: "derived" },
-				),
-			{
-				condition: urgent,
-			},
-		);
-		const unsub = routed.subscribe(() => {});
-		// Condition closed — pass-through.
-		expect(routed.cache).toBe("q");
-		// Open the gate — specialist engages.
-		urgent.emit(true);
-		expect(routed.cache).toBe("[urgent] q");
-		// Close again — specialist output still shown (last) until src changes.
-		urgent.emit(false);
-		from.emit("q2");
-		expect(routed.cache).toBe("q2");
-		unsub();
-	});
-
-	it("null `from` value emits null regardless of condition", () => {
-		const from = node<string | null>([], { initial: null });
-		const routed = handoff(
-			from,
-			(input) =>
-				node(
-					[input],
-					(batchData, actions, ctx) => {
-						const data = batchData.map((batch, i) =>
-							batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-						);
-						actions.emit(`[s] ${data[0]}`);
-					},
-					{ describeKind: "derived" },
-				),
-			{
-				condition: node([], { initial: true }),
-			},
-		);
-		const unsub = routed.subscribe(() => {});
-		expect(routed.cache).toBeNull();
-		unsub();
-	});
-});
-
-describe("patterns.ai.frozenContext (B11)", () => {
-	it("materializes once without refresh trigger — source changes are ignored", () => {
-		const source = node([], { initial: "v1" });
-		const frozen = frozenContext(source);
-		const unsub = frozen.subscribe(() => {});
-		expect(frozen.cache).toBe("v1");
-		source.emit("v2");
-		source.emit("v3");
-		// Frozen stays at v1 regardless of source changes.
-		expect(frozen.cache).toBe("v1");
-		unsub();
-	});
-
-	it("with refreshTrigger: emits current source only when trigger fires", () => {
-		const source = node([], { initial: "s1" });
-		const trigger = node([], { initial: 0 });
-		const frozen = frozenContext(source, { refreshTrigger: trigger });
-		const unsub = frozen.subscribe(() => {});
-		// Activation: src fires first (captured), trigger fires in its own
-		// wave → frozen emits the src value.
-		expect(frozen.cache).toBe("s1");
-
-		// Source drifts without a trigger tick — frozen stays put.
-		source.emit("s2");
-		source.emit("s3");
-		expect(frozen.cache).toBe("s1");
-
-		// Trigger fires → frozen catches up to current src.
-		trigger.emit(1);
-		expect(frozen.cache).toBe("s3");
-
-		// Another trigger with no src change re-emits the same value (RESOLVED suppression).
-		trigger.emit(2);
-		expect(frozen.cache).toBe("s3");
-
-		unsub();
-	});
-});
-
-// ---------------------------------------------------------------------------
-// streamingPromptNode
-// ---------------------------------------------------------------------------
-
-describe("patterns.ai.streamingPromptNode", () => {
-	it("emits final result after stream completes", async () => {
-		const chunks = ["Hello", " ", "world", "!"];
-		const adapter = mockAdapter([], [chunks]);
-		const input = node([], { initial: "greet" });
-
-		const { output } = streamingPromptNode(adapter, [input], (v) => `say ${v}`);
-
-		const result = await new Promise<string | null>((resolve) => {
-			output.subscribe((messages) => {
-				for (const msg of messages) {
-					if (msg[0] === DATA && msg[1] !== null) {
-						resolve(msg[1] as string | null);
-					}
-				}
-			});
-		});
-
-		expect(result).toBe("Hello world!");
-	});
-
-	it("publishes stamped deltas to the delta topic", async () => {
-		const chunks = ["A", "B", "C"];
-		const adapter = mockAdapter([], [chunks]);
-		const input = node([], { initial: "go" });
-
-		const { output, deltaTopic } = streamingPromptNode(adapter, [input], (v) => `${v}`);
-
-		const received: StampedDelta[] = [];
-		deltaTopic.latest.subscribe((messages) => {
-			for (const msg of messages) {
-				if (msg[0] === DATA && msg[1] != null) {
-					received.push(msg[1] as StampedDelta);
-				}
-			}
-		});
-
-		await new Promise<void>((resolve) => {
-			output.subscribe((messages) => {
-				for (const msg of messages) {
-					if (msg[0] === DATA && msg[1] !== null) resolve();
-				}
-			});
-		});
-
-		const tokens = received.filter((d) => d.type === "token");
-		expect(tokens).toHaveLength(3);
-		expect(tokens.map((d) => (d as { delta: string }).delta)).toEqual(["A", "B", "C"]);
-		expect(tokens.map((d) => d.seq)).toEqual([0, 1, 2]);
-	});
-
-	it("cancels in-flight stream on new input via switchMap", async () => {
-		const chunks1 = ["slow", "stream"];
-		const chunks2 = ["fast"];
-		const adapter = mockAdapter([], [chunks1, chunks2]);
-		const input = node([], { initial: "first" });
-
-		const { output } = streamingPromptNode(adapter, [input], (v) => `${v}`);
-
-		const results: Array<string | null> = [];
-		output.subscribe((messages) => {
-			for (const msg of messages) {
-				if (msg[0] === DATA) results.push(msg[1] as string | null);
-			}
-		});
-
-		// Wait for first stream result
-		await new Promise<void>((resolve) => {
-			const unsub = output.subscribe((messages) => {
-				for (const msg of messages) {
-					if (msg[0] === DATA && msg[1] !== null) {
-						unsub();
-						resolve();
-					}
-				}
-			});
-		});
-		expect(results.filter((r) => r !== null).pop()).toBe("slowstream");
-
-		// Trigger second input — switchMap cancels first, starts fresh
-		input.down([[DATA, "second"]]);
-
-		// Wait for second stream result (skip cached push-on-subscribe)
-		await new Promise<void>((resolve) => {
-			let skipFirst = true;
-			const unsub = output.subscribe((messages) => {
-				for (const msg of messages) {
-					if (msg[0] === DATA && msg[1] !== null) {
-						if (skipFirst) {
-							skipFirst = false;
-							continue;
-						}
-						unsub();
-						resolve();
-					}
-				}
-			});
-		});
-
-		const nonNull = results.filter((r) => r !== null);
-		expect(nonNull[nonNull.length - 1]).toBe("fast");
-	});
-
-	it("emits null for nullish deps (SENTINEL gate)", () => {
-		const adapter = mockAdapter([], []);
-		const dep = node<string | null>([], { initial: null });
-
-		const { output } = streamingPromptNode(adapter, [dep], (v) => `${v}`);
-
-		const values: Array<unknown> = [];
-		output.subscribe((messages) => {
-			for (const msg of messages) {
-				if (msg[0] === DATA) values.push(msg[1]);
-			}
-		});
-
-		// null dep → empty messages → switchMap returns node([], { initial: null }) → pushed synchronously
-		expect(values).toContain(null);
-	});
-
-	it("parses JSON when format is json", async () => {
-		const adapter: LLMAdapter = {
-			provider: "mock",
-			invoke: () => ({
-				content: "",
-				usage: { input: { regular: 0 }, output: { regular: 0 } },
-			}),
-			async *stream() {
-				yield { type: "token" as const, delta: '{"key":' };
-				yield { type: "token" as const, delta: '"value"}' };
-				yield { type: "usage" as const, usage: { input: { regular: 0 }, output: { regular: 0 } } };
-				yield { type: "finish" as const, reason: "stop" };
-			},
-		};
-		const input = node([], { initial: "go" });
-
-		const { output } = streamingPromptNode<{ key: string }>(adapter, [input], (v) => `${v}`, {
-			format: "json",
-		});
-
-		const result = await new Promise<{ key: string } | null>((resolve) => {
-			output.subscribe((messages) => {
-				for (const msg of messages) {
-					if (msg[0] === DATA && msg[1] !== null) {
-						resolve(msg[1] as { key: string } | null);
-					}
-				}
-			});
-		});
-
-		expect(result).toEqual({ key: "value" });
-	});
-
-	it("dispose destroys the delta topic (TEARDOWN)", () => {
-		const { deltaTopic, dispose } = streamingPromptNode(
-			mockAdapter([], []),
-			[node([], { initial: "go" })],
-			(v) => `${v}`,
-		);
-
-		const received: unknown[] = [];
-		deltaTopic.latest.subscribe((messages) => {
-			for (const msg of messages) {
-				received.push(msg[0]);
-			}
-		});
-
-		dispose();
-
-		expect(received).toContain(TEARDOWN);
-	});
-});
-
-// ---------------------------------------------------------------------------
-// streamExtractor
-// ---------------------------------------------------------------------------
-
-describe("patterns.ai.streamExtractor", () => {
-	it("extracts values from an accumulated-text source", () => {
-		const textState = node<string>([], { initial: "" });
-
-		const extracted: Array<string | null> = [];
-		const extractor = streamExtractor(
-			textState,
-			(accumulated) => {
-				const match = accumulated.match(/hello/);
-				return match ? match[0] : null;
-			},
-			{ name: "hello-detector" },
-		);
-		extractor.subscribe((messages) => {
-			for (const msg of messages) {
-				if (msg[0] === DATA) extracted.push(msg[1] as string | null);
-			}
-		});
-
-		textState.emit("hel");
-		textState.emit("hello");
-
-		// First emission: no match → null; second: match → "hello"
-		expect(extracted).toContain(null);
-		expect(extracted).toContain("hello");
-	});
-
-	it("returns null for an empty accumulated-text source", () => {
-		const textState = node<string>([], { initial: "" });
-		const extractor = streamExtractor(textState, (t) => (t.length > 0 ? "found" : null));
-		extractor.subscribe(() => {});
-		expect(extractor.cache).toBe(null);
-	});
-});
-
-// ---------------------------------------------------------------------------
-// keywordFlagExtractor
-// ---------------------------------------------------------------------------
-
-describe("patterns.ai.keywordFlagExtractor", () => {
-	it("detects keyword matches in accumulated text", () => {
-		const textState = node<string>([], { initial: "" });
-
-		const flags: KeywordFlag[][] = [];
-		const extractor = keywordFlagExtractor(textState, {
-			patterns: [
-				{ pattern: /setTimeout/g, label: "invariant-violation" },
-				{ pattern: /\bSSN\b/i, label: "pii" },
-			],
-		});
-		extractor.subscribe((messages) => {
-			for (const msg of messages) {
-				if (msg[0] === DATA) flags.push(msg[1] as KeywordFlag[]);
-			}
-		});
-
-		textState.emit("use ");
-		textState.emit("use setTimeout and SSN");
-
-		const last = flags[flags.length - 1];
-		expect(last).toHaveLength(2);
-		expect(last[0].label).toBe("invariant-violation");
-		expect(last[0].match).toBe("setTimeout");
-		expect(last[1].label).toBe("pii");
-		expect(last[1].match).toBe("SSN");
-	});
-
-	it("returns empty array when no matches", () => {
-		const textState = node<string>([], { initial: "" });
-		const extractor = keywordFlagExtractor(textState, {
-			patterns: [{ pattern: /setTimeout/, label: "violation" }],
-		});
-		extractor.subscribe(() => {});
-		textState.emit("clean code");
-		expect(extractor.cache).toEqual([]);
-	});
-
-	it("finds multiple matches of the same pattern", () => {
-		const textState = node<string>([], { initial: "" });
-		const extractor = keywordFlagExtractor(textState, {
-			patterns: [{ pattern: /TODO/g, label: "todo" }],
-		});
-		extractor.subscribe(() => {});
-		textState.emit("TODO fix TODO later");
-		const result = extractor.cache!;
-		expect(result).toHaveLength(2);
-		expect(result[0].position).toBe(0);
-		expect(result[1].position).toBe(9);
-	});
-
-	it("throws at factory time when a pattern exceeds maxPatternLength", () => {
-		const textState = node<string>([], { initial: "" });
-		// 150-char pattern vs default 128 max → throw.
-		const long = new RegExp("x".repeat(150));
-		expect(() =>
-			keywordFlagExtractor(textState, {
-				patterns: [{ pattern: long, label: "overly-long" }],
-			}),
-		).toThrow(/maxPatternLength/);
-	});
-});
-
-// ---------------------------------------------------------------------------
-// toolCallExtractor
-// ---------------------------------------------------------------------------
-
-describe("patterns.ai.toolCallExtractor", () => {
-	it("extracts tool calls from accumulated text", () => {
-		const textState = node<string>([], { initial: "" });
-		const calls: ExtractedToolCall[][] = [];
-		const extractor = toolCallExtractor(textState);
-		extractor.subscribe((messages) => {
-			for (const msg of messages) {
-				if (msg[0] === DATA) calls.push(msg[1] as ExtractedToolCall[]);
-			}
-		});
-		const toolJson = JSON.stringify({ name: "get_weather", arguments: { city: "NYC" } });
-		textState.emit(`Sure, let me check. ${toolJson}`);
-
-		const last = calls[calls.length - 1];
-		expect(last).toHaveLength(1);
-		expect(last[0].name).toBe("get_weather");
-		expect(last[0].arguments).toEqual({ city: "NYC" });
-		expect(last[0].startIndex).toBe(20);
-	});
-
-	it("returns empty array for partial JSON", () => {
-		const textState = node<string>([], { initial: "" });
-		const extractor = toolCallExtractor(textState);
-		extractor.subscribe(() => {});
-		textState.emit('{"name": "run');
-		expect(extractor.cache).toEqual([]);
-	});
-
-	it("ignores JSON objects without name+arguments shape", () => {
-		const textState = node<string>([], { initial: "" });
-		const extractor = toolCallExtractor(textState);
-		extractor.subscribe(() => {});
-		textState.emit('{"foo": "bar"}');
-		expect(extractor.cache).toEqual([]);
-	});
-
-	it("handles braces inside JSON string values", () => {
-		const textState = node<string>([], { initial: "" });
-		const extractor = toolCallExtractor(textState);
-		extractor.subscribe(() => {});
-		const toolJson = JSON.stringify({
-			name: "run_code",
-			arguments: { code: 'if (x) { return "}" }' },
-		});
-		textState.emit(toolJson);
-		const result = extractor.cache!;
-		expect(result).toHaveLength(1);
-		expect(result[0].name).toBe("run_code");
-		expect(result[0].arguments).toEqual({ code: 'if (x) { return "}" }' });
-	});
-
-	it("extracts multiple tool calls from accumulated text", () => {
-		const textState = node<string>([], { initial: "" });
-		const extractor = toolCallExtractor(textState);
-		extractor.subscribe(() => {});
-		const call1 = JSON.stringify({ name: "a", arguments: { x: 1 } });
-		const call2 = JSON.stringify({ name: "b", arguments: { y: 2 } });
-		textState.emit(`${call1} then ${call2}`);
-		const result = extractor.cache!;
-		expect(result).toHaveLength(2);
-		expect(result[0].name).toBe("a");
-		expect(result[1].name).toBe("b");
-	});
-});
-
-// ---------------------------------------------------------------------------
-// costMeterExtractor
-// ---------------------------------------------------------------------------
-
-describe("patterns.ai.costMeterExtractor", () => {
-	function publish(
-		t: ReturnType<typeof streamingPromptNode>["deltaTopic"],
-		delta: string,
-		seq: number,
-	) {
-		t.publish({ type: "token", delta, seq, ts: BigInt(0) as unknown as number });
-	}
-
-	it("tracks chunk count, char count, and estimated tokens (fallback mode)", () => {
-		const { deltaTopic } = streamingPromptNode(
-			mockAdapter([], []),
-			[node([], { initial: "go" })],
-			(v) => `${v}`,
-		);
-		const extractor = costMeterExtractor(deltaTopic);
-		extractor.subscribe(() => {});
-
-		publish(deltaTopic, "hello", 0);
-		const reading = extractor.cache!;
-		expect(reading.chunkCount).toBe(1);
-		expect(reading.charCount).toBe(5);
-		expect(reading.estimatedTokens).toBe(2); // ceil(5/4)
-		expect(reading.estimated).toBe(true);
-	});
-
-	it("accumulates across token deltas", () => {
-		const { deltaTopic } = streamingPromptNode(
-			mockAdapter([], []),
-			[node([], { initial: "go" })],
-			(v) => `${v}`,
-		);
-		const extractor = costMeterExtractor(deltaTopic);
-		extractor.subscribe(() => {});
-
-		publish(deltaTopic, "hello", 0);
-		publish(deltaTopic, " world", 1);
-
-		const reading = extractor.cache!;
-		expect(reading.chunkCount).toBe(2);
-		expect(reading.charCount).toBe(11);
-		expect(reading.estimatedTokens).toBe(3); // ceil(11/4)
-	});
-
-	it("uses custom charsPerToken", () => {
-		const { deltaTopic } = streamingPromptNode(
-			mockAdapter([], []),
-			[node([], { initial: "go" })],
-			(v) => `${v}`,
-		);
-		const extractor = costMeterExtractor(deltaTopic, { charsPerToken: 2 });
-		extractor.subscribe(() => {});
-
-		publish(deltaTopic, "hello", 0);
-		expect(extractor.cache!.estimatedTokens).toBe(3); // ceil(5/2)
-	});
-
-	it("returns zero reading when no deltas", () => {
-		const { deltaTopic } = streamingPromptNode(
-			mockAdapter([], []),
-			[node([], { initial: "go" })],
-			(v) => `${v}`,
-		);
-		const extractor = costMeterExtractor(deltaTopic);
-		extractor.subscribe(() => {});
-		expect(extractor.cache).toEqual({
-			chunkCount: 0,
-			charCount: 0,
-			estimatedTokens: 0,
-			estimated: true,
-		});
-	});
-
-	it("prefers real usage delta over char estimate when present", () => {
-		const { deltaTopic } = streamingPromptNode(
-			mockAdapter([], []),
-			[node([], { initial: "go" })],
-			(v) => `${v}`,
-		);
-		const extractor = costMeterExtractor(deltaTopic);
-		extractor.subscribe(() => {});
-
-		publish(deltaTopic, "hello world", 0);
-		deltaTopic.publish({
-			type: "usage",
-			usage: { input: { regular: 3 }, output: { regular: 42 } },
-			seq: 1,
-			ts: BigInt(0) as unknown as number,
-		});
-		const reading = extractor.cache!;
-		expect(reading.estimatedTokens).toBe(45); // 3 + 42 from usage delta
-		expect(reading.estimated).toBe(false);
-	});
-});
-
-// ---------------------------------------------------------------------------
-// gatedStream
-// ---------------------------------------------------------------------------
-
-// Wave B follow-up (2026-04-24): the gatedStream activation bug was fixed by
-// keepaliving BOTH the switchMap `output` AND the gate's output node inside
-// `gatedStream`. Prior bug: the gate's fn body only ran when it had a live
-// subscriber on its output; without the extra keepalive, streamed values
-// reached the gate's input but never entered the pending queue, so
-// `gate.count` stayed at 0. The 4 previously-skipped tests below now exercise
-// the full pending → approve / reject / modify / delta-topic loop.
-describe("patterns.ai.gatedStream", () => {
-	/** Wait for gate.count to reach `n` by subscribing reactively. */
-	function waitForPending(handle: GatedStreamHandle<unknown>, n = 1): Promise<void> {
-		// If count already has the value, resolve immediately
-		if ((handle.gate.count.cache as number) >= n) return Promise.resolve();
-		return new Promise<void>((resolve) => {
-			let teardown: (() => void) | undefined;
-			teardown = handle.gate.count.subscribe((msgs) => {
-				for (const m of msgs) {
-					if (m[0] === DATA && (m[1] as number) >= n) {
-						teardown?.();
-						resolve();
-					}
-				}
-			});
-		});
-	}
-
-	it("gates output and allows approval", async () => {
-		const adapter = mockAdapter([], [["hello", " world"]]);
-		const graph = new Graph("test");
-		const dep = node([], { initial: "go" });
-
-		const handle = gatedStream(graph, "review", adapter, [dep], (v) => `say ${v}`);
-		const results: unknown[] = [];
-		handle.output.subscribe((msgs) => {
-			for (const m of msgs) if (m[0] === DATA && m[1] != null) results.push(m[1]);
-		});
-
-		await waitForPending(handle);
-		expect(handle.gate.count.cache).toBe(1);
-		handle.gate.approve();
-		expect(results.length).toBe(1);
-		expect(results[0]).toBe("hello world");
-		handle.dispose();
-	});
-
-	it("reject discards pending and aborts the stream", async () => {
-		let streamStarted = false;
-		const adapter: LLMAdapter = {
-			provider: "mock",
-			invoke: () => ({
-				content: "",
-				finishReason: "end_turn",
-				usage: { input: { regular: 0 }, output: { regular: 0 } },
-			}),
-			async *stream(_msgs, opts) {
-				streamStarted = true;
-				for (let i = 0; i < 100; i++) {
-					if (opts?.signal?.aborted) return;
-					yield { type: "token" as const, delta: `chunk${i} ` };
-					await new Promise((r) => setTimeout(r, 5));
-				}
-			},
-		};
-
-		const graph = new Graph("test");
-		const dep = node([], { initial: "go" });
-		const handle = gatedStream(graph, "review", adapter, [dep], (v) => `say ${v}`);
-		handle.output.subscribe(() => {});
-
-		// Wait for first chunk to confirm stream started, then reject
-		await new Promise<void>((resolve) => {
-			handle.deltaTopic.latest.subscribe((msgs) => {
-				for (const m of msgs) {
-					if (m[0] === DATA && m[1] != null) {
-						resolve();
-					}
-				}
-			});
-		});
-
-		expect(streamStarted).toBe(true);
-		handle.gate.reject();
-		expect(handle.gate.count.cache).toBe(0);
-		handle.dispose();
-	});
-
-	it("modify transforms pending value before forwarding", async () => {
-		const adapter = mockAdapter([], [["original"]]);
-		const graph = new Graph("test");
-		const dep = node([], { initial: "go" });
-
-		const handle = gatedStream(graph, "review", adapter, [dep], (v) => `say ${v}`);
-		const results: unknown[] = [];
-		handle.output.subscribe((msgs) => {
-			for (const m of msgs) if (m[0] === DATA && m[1] != null) results.push(m[1]);
-		});
-
-		await waitForPending(handle);
-		handle.gate.modify((v) => `${v} [reviewed]`);
-		expect(results.length).toBe(1);
-		expect(results[0]).toBe("original [reviewed]");
-		handle.dispose();
-	});
-
-	it("delta topic publishes stamped deltas while gate is pending", async () => {
-		const adapter = mockAdapter([], [["a", "b", "c"]]);
-		const graph = new Graph("test");
-		const dep = node([], { initial: "go" });
-
-		const handle = gatedStream(graph, "review", adapter, [dep], (v) => `${v}`);
-		const deltas: StampedDelta[] = [];
-		handle.deltaTopic.latest.subscribe((msgs) => {
-			for (const m of msgs) if (m[0] === DATA && m[1]) deltas.push(m[1] as StampedDelta);
-		});
-		// Activate gate chain so the output pipeline runs
-		handle.output.subscribe(() => {});
-
-		await waitForPending(handle);
-		// Deltas published even though gate hasn't approved
-		expect(deltas.length).toBeGreaterThan(0);
-		// `accumulatedText` carries the final "abc" view (test against that
-		// instead of the retired `StreamChunk.accumulated` field).
-		expect(handle.accumulatedText.cache).toBe("abc");
-		handle.gate.approve();
-		handle.dispose();
-	});
-
-	it("startOpen auto-approves without gating", async () => {
-		const adapter = mockAdapter([], [["auto"]]);
-		const graph = new Graph("test");
-		const dep = node([], { initial: "go" });
-
-		const handle = gatedStream(graph, "review", adapter, [dep], (v) => `${v}`, {
-			gate: { startOpen: true },
-		});
-
-		// With startOpen, value flows through without gating — wait for non-null result
-		const result = await new Promise<unknown>((resolve) => {
-			handle.output.subscribe((msgs) => {
-				for (const m of msgs) {
-					if (m[0] === DATA && m[1] != null) resolve(m[1]);
-				}
-			});
-		});
-
-		expect(result).toBe("auto");
-		handle.dispose();
-	});
-});
-
-// ---------------------------------------------------------------------------
-// agentLoop
-// ---------------------------------------------------------------------------
-
-describe("patterns.ai.agentLoop", () => {
-	it("creates an agent loop graph with subgraphs", () => {
-		const resp: LLMResponse = { content: "done", finishReason: "end_turn" };
-		const adapter = mockAdapter([resp]);
-		const loop = agentLoop("test-agent", { adapter });
-		expect(loop).toBeInstanceOf(AgentLoopGraph);
-		expect(loop.status.cache).toBe("idle");
-		expect(loop.turn.cache).toBe(0);
-	});
-
-	it("runs a simple conversation and reaches done status", async () => {
-		const resp: LLMResponse = { content: "Hello, human!", finishReason: "end_turn" };
-		const adapter = mockAdapter([resp]);
-		const loop = agentLoop("test-agent", { adapter });
-
-		const result = await loop.run("Hi!");
-		expect(result?.content).toBe("Hello, human!");
-		expect(loop.status.cache).toBe("done");
-		expect(loop.turn.cache).toBe(1);
-	});
-
-	it("executes tool calls and loops", async () => {
-		const toolCallResp: LLMResponse = {
-			content: "",
-			toolCalls: [{ id: "tc1", name: "calc", arguments: { x: 5 } }],
-		};
-		const finalResp: LLMResponse = {
-			content: "The result is 10",
-			finishReason: "end_turn",
-		};
-		const adapter = mockAdapter([toolCallResp, finalResp]);
-
-		const tool: ToolDefinition = {
-			name: "calc",
-			description: "Double a number",
-			parameters: {},
-			handler: (args) => (args.x as number) * 2,
-		};
-
-		const loop = agentLoop("test-agent", {
-			adapter,
-			tools: [tool],
-		});
-
-		const result = await loop.run("Double 5 for me");
-		expect(result?.content).toBe("The result is 10");
-		expect(loop.turn.cache).toBe(2);
-		// Chat should have: user, assistant (tool call), tool result, assistant (final)
-		const msgs = loop.chat.allMessages();
-		expect(msgs.length).toBe(4);
-		expect(msgs[2]?.role).toBe("tool");
-	});
-
-	it("respects maxTurns", async () => {
-		const resp: LLMResponse = {
-			content: "",
-			toolCalls: [{ id: "tc1", name: "noop", arguments: {} }],
-		};
-		const adapter = mockAdapter([resp]);
-		const tool: ToolDefinition = {
-			name: "noop",
-			description: "No-op",
-			parameters: {},
-			handler: () => null,
-		};
-
-		const loop = agentLoop("test-agent", {
-			adapter,
-			tools: [tool],
-			maxTurns: 2,
-		});
-
-		await loop.run("loop forever");
-		expect(loop.turn.cache).toBe(2);
-		expect(loop.status.cache).toBe("done");
-	});
-
-	it("EC-2: cap-reached with pending tool_use synthesizes denial tool_results (valid transcript)", async () => {
-		// Pre-fix: when `effResponse` hits the cap-reaching turn it flips
-		// `status="acting"→"done"` in the SAME batch that appends the
-		// assistant message with `toolCalls`. `toolCallsRaw` gates on
-		// `stat === "acting"`, so the next wave emits RESOLVED and
-		// `effFullDeny`'s diamond never delivers DATA. The chat transcript
-		// ends with an assistant `tool_use:*` block lacking matching
-		// `tool_result:*` blocks — an invalid transcript per
-		// Anthropic/OpenAI tool-use schemas (every `tool_use` needs a
-		// `tool_result`). Audit/replay consumers replaying
-		// `loop.chat.allMessages()` into a fresh `adapter.invoke` see the
-		// broken prompt. Post-fix: `effResponse`'s batch also synthesizes
-		// `"[tool call denied: maxTurns reached]"` `tool_result`s for every
-		// pending `tool_use` when `capReached && hasToolCalls`.
-		const resp: LLMResponse = {
-			content: "calling tools at the cap",
-			toolCalls: [
-				{ id: "tc1", name: "noop", arguments: {} },
-				{ id: "tc2", name: "noop", arguments: {} },
-			],
-		};
-		// Wrap mockAdapter with an invocation counter (BH-4 hardening):
-		// the cap-reached path must NOT re-invoke the LLM after Wave 0.
-		const inner = mockAdapter([resp]);
-		let invokeCalls = 0;
-		const adapter: LLMAdapter = {
-			...inner,
-			invoke(messages, opts) {
-				invokeCalls++;
-				return inner.invoke(messages, opts);
-			},
-		};
-		const tool: ToolDefinition = {
-			name: "noop",
-			description: "No-op",
-			parameters: {},
-			handler: () => null,
-		};
-		const loop = agentLoop("test-agent", {
-			adapter,
-			tools: [tool],
-			maxTurns: 1, // first turn IS the cap-reaching turn
-		});
-		await loop.run("kick");
-		expect(loop.status.cache).toBe("done");
-		expect(loop.turn.cache).toBe(1);
-		// Exactly one LLM round-trip — the cap-reached synthesis must not
-		// trigger a re-invoke (locks against a regression where status
-		// stays "acting" or "thinking" and loops back to the adapter).
-		expect(invokeCalls).toBe(1);
-
-		// Transcript: user, assistant (with 2 tool_use), 2 synthetic tool_results.
-		const msgs = loop.chat.allMessages();
-		expect(msgs).toHaveLength(4);
-		expect(msgs[0]?.role).toBe("user");
-		expect(msgs[1]?.role).toBe("assistant");
-		expect(msgs[1]?.toolCalls).toHaveLength(2);
-		// Both synthetic results paired with their tool_use ids, in order.
-		expect(msgs[2]).toMatchObject({
-			role: "tool",
-			toolCallId: "tc1",
-			content: "[tool call denied: maxTurns reached]",
-		});
-		expect(msgs[3]).toMatchObject({
-			role: "tool",
-			toolCallId: "tc2",
-			content: "[tool call denied: maxTurns reached]",
-		});
-	});
-
-	it("EC-2 guard: cap-reached WITHOUT tool_use leaves transcript untouched (no spurious synth)", async () => {
-		// Negative test pinning the `capReached && hasToolCalls` guard
-		// (BH-6 hardening): if the LLM's cap-reaching response carries no
-		// tool calls (plain text completion that happens to land on the
-		// cap), the new EC-2 branch MUST NOT append any synthetic
-		// tool_result. A regression that drops the `hasToolCalls` guard
-		// would emit an empty/garbage tool_result loop or otherwise
-		// pollute the transcript.
-		const resp: LLMResponse = {
-			content: "answer at the cap",
-			finishReason: "end_turn",
-		};
-		const adapter = mockAdapter([resp]);
-		const loop = agentLoop("test-agent", {
-			adapter,
-			maxTurns: 1, // cap reached on the first response
-		});
-		await loop.run("ask");
-		expect(loop.status.cache).toBe("done");
-		expect(loop.turn.cache).toBe(1);
-
-		const msgs = loop.chat.allMessages();
-		// user + assistant only — no synthetic tool_results.
-		expect(msgs).toHaveLength(2);
-		expect(msgs[0]?.role).toBe("user");
-		expect(msgs[1]?.role).toBe("assistant");
-		expect(msgs[1]?.toolCalls).toBeUndefined();
-		expect(msgs.filter((m) => m.role === "tool")).toHaveLength(0);
-	});
-
-	it("respects custom stopWhen", async () => {
-		const resp: LLMResponse = { content: "STOP_HERE" };
-		const adapter = mockAdapter([resp]);
-		const loop = agentLoop("test-agent", {
-			adapter,
-			stopWhen: (r) => r.content === "STOP_HERE",
-		});
-		const result = await loop.run("test");
-		expect(result?.content).toBe("STOP_HERE");
-		expect(loop.status.cache).toBe("done");
-	});
-
-	it("resolves async LLM adapter invoke (Promise)", async () => {
-		const resp: LLMResponse = {
-			content: "async-ok",
-			finishReason: "end_turn",
-			usage: { input: { regular: 0 }, output: { regular: 0 } },
-		};
-		const adapter: LLMAdapter = {
-			provider: "mock",
-			invoke() {
-				return Promise.resolve(resp);
-			},
-			async *stream() {
-				yield { type: "token" as const, delta: "" };
-				yield { type: "usage" as const, usage: { input: { regular: 0 }, output: { regular: 0 } } };
-				yield { type: "finish" as const, reason: "stop" };
-			},
-		};
-		const loop = agentLoop("test-agent", { adapter });
-		const result = await loop.run("hi");
-		expect(result?.content).toBe("async-ok");
-	});
-
-	// --- QA regressions (2026-04-22) ---
-
-	it("QA C1: concurrent run() rejects with RangeError", async () => {
-		// Use a never-resolving adapter so the first run() stays pending.
-		let pendingResolve: ((v: LLMResponse) => void) | undefined;
-		const adapter: LLMAdapter = {
-			provider: "mock",
-			invoke() {
-				return new Promise<LLMResponse>((resolve) => {
-					pendingResolve = resolve;
-				});
-			},
-			async *stream() {},
-		};
-		const loop = agentLoop("test-agent", { adapter });
-		const first = loop.run("first");
-		// `run()` is async → reentrant throw surfaces as a rejected Promise.
-		await expect(loop.run("second")).rejects.toThrow(RangeError);
-		// Release the first run so test teardown doesn't hang.
-		pendingResolve?.({ content: "done", finishReason: "end_turn" });
-		await first;
-	});
-
-	it("QA C2: abort() cancels in-flight invocation via AbortSignal", async () => {
-		let abortedSignal = false;
-		const adapter: LLMAdapter = {
-			provider: "mock",
-			invoke(_messages, opts) {
-				return new Promise<LLMResponse>((_resolve, reject) => {
-					opts?.signal?.addEventListener("abort", () => {
-						abortedSignal = true;
-						reject(new Error("aborted"));
-					});
-				});
-			},
-			async *stream() {},
-		};
-		const loop = agentLoop("test-agent", { adapter });
-		const running = loop.run("go");
-		// Give the invoke a turn to register its abort listener.
-		await new Promise((resolve) => setImmediate(resolve));
-		loop.abort();
-		await expect(running).rejects.toThrow();
-		expect(abortedSignal).toBe(true);
-	});
-
-	it("QA C3: abort before response rejects with AbortError", async () => {
-		const adapter: LLMAdapter = {
-			provider: "mock",
-			invoke() {
-				return new Promise<LLMResponse>(() => {
-					/* never resolves */
-				});
-			},
-			async *stream() {},
-		};
-		const loop = agentLoop("test-agent", { adapter });
-		const running = loop.run("go");
-		await new Promise((resolve) => setImmediate(resolve));
-		loop.abort();
-		await expect(running).rejects.toMatchObject({ name: "AbortError" });
-	});
-
-	it("QA C3 regression: second run() with pre-aborted signal rejects AbortError (no stale response leak)", async () => {
-		// Wave A Unit 4 retired `_runVersion`; stale-resolution safety now
-		// relies on `run()` clearing `lastResponse` during its reset batch.
-		// Without the clear, a second run() with a pre-aborted signal would
-		// resolve with the FIRST run's response: the reset doesn't touch
-		// `lastResponseState`, so when `effAbort` drives `status → "done"`,
-		// `_terminalResult` sees the stale cached response and emits it as
-		// fresh DATA past the `skipCurrent: true` sync-phase swallow.
-		const firstResp: LLMResponse = {
-			content: "first-run",
-			finishReason: "end_turn",
-		};
-		const adapter = mockAdapter([firstResp]);
-		const loop = agentLoop("test-agent", { adapter });
-
-		// Run 1: success — leaves `lastResponse.cache === firstResp`.
-		const result1 = await loop.run("prompt-1");
-		expect(result1?.content).toBe("first-run");
-		expect(loop.lastResponse.cache).toMatchObject({ content: "first-run" });
-
-		// Run 2: pre-aborted signal must reject with AbortError, not
-		// resolve with Run 1's cached response.
-		const controller = new AbortController();
-		controller.abort();
-		await expect(loop.run("prompt-2", controller.signal)).rejects.toMatchObject({
-			name: "AbortError",
-		});
-	});
-
-	it("D9: interceptToolCalls splices a reactive gate between toolCalls and executor", async () => {
-		// Two LLM responses: first requests two tools (allow + forbid); intercept
-		// drops the "forbid" tool; final response wraps up.
-		const toolCallResp: LLMResponse = {
-			content: "",
-			toolCalls: [
-				{ id: "tc1", name: "allow", arguments: {} },
-				{ id: "tc2", name: "forbid", arguments: {} },
-			],
-		};
-		const finalResp: LLMResponse = { content: "done", finishReason: "end_turn" };
-		const adapter = mockAdapter([toolCallResp, finalResp]);
-
-		const allowTool: ToolDefinition = {
-			name: "allow",
-			description: "",
-			parameters: {},
-			handler: () => "ok",
-		};
-		const forbidTool: ToolDefinition = {
-			name: "forbid",
-			description: "",
-			parameters: {},
-			handler: () => {
-				throw new Error("should not execute");
-			},
-		};
-
-		const loop = agentLoop("test-agent", {
-			adapter,
-			tools: [allowTool, forbidTool],
-			interceptToolCalls: (calls) =>
-				node(
-					[calls],
-					(batchData, actions, ctx) => {
-						const data = batchData.map((batch, i) =>
-							batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-						);
-						actions.emit((data[0] as readonly ToolCall[]).filter((c) => c.name !== "forbid"));
-					},
-					{ describeKind: "derived" },
-				),
-		});
-
-		await loop.run("go");
-		const msgs = loop.chat.allMessages();
-		const toolMsgs = msgs.filter((m) => m.role === "tool");
-		// Post-ND-3 (DS-2.7.A /qa, 2026-05-19): partial deny now also synthesizes
-		// a denial `tool_result` for the dropped subset, so every `tool_use`
-		// in the assistant message has a matching `tool_result` (valid
-		// transcript for the next `adapter.invoke`). Pre-ND-3 the dropped
-		// tool produced no result, leaving an orphan `tool_use` block — a
-		// transcript-validity hazard. Tool executor still saw only "allow"
-		// (no throw), since `effFullDeny` only synthesizes results, it
-		// doesn't invoke handlers.
-		expect(toolMsgs).toHaveLength(2);
-		// Public `toolCalls` surfaces the POST-intercept stream (auditable).
-		expect((loop.toolCalls.cache as readonly ToolCall[]).map((c) => c.name)).toEqual(["allow"]);
-	});
-
-	it("full-deny via toolInterceptor does not strand the loop — recovers with synthetic denial results", async () => {
-		// Turn 1: LLM requests a tool the interceptor fully denies (RESOLVED,
-		// no DATA). Pre-fix this stranded `status="acting"` forever and
-		// `run()` never resolved. Turn 2: LLM wraps up after seeing the
-		// synthetic "denied" tool-result fed back into the chat.
-		const toolCallResp: LLMResponse = {
-			content: "",
-			toolCalls: [{ id: "tc1", name: "forbid", arguments: {} }],
-		};
-		const finalResp: LLMResponse = { content: "done", finishReason: "end_turn" };
-		const adapter = mockAdapter([toolCallResp, finalResp]);
-		const forbidTool: ToolDefinition = {
-			name: "forbid",
-			description: "",
-			parameters: {},
-			handler: () => {
-				throw new Error("should not execute");
-			},
-		};
-		const loop = agentLoop("deny-agent", {
-			adapter,
-			tools: [forbidTool],
-			// The SHIPPED primitive (emits [[RESOLVED]] on full deny — the
-			// strand trigger), not a hand-rolled `actions.emit([])`.
-			interceptToolCalls: toolInterceptor({
-				allow: [
-					node<(c: ToolCall) => boolean>([], {
-						name: "deny-forbid",
-						initial: (c: ToolCall) => c.name !== "forbid",
-					}),
-				],
-			}),
-		});
-
-		const result = await loop.run("go");
-		// Loop resolved (no strand) and continued to the natural stop.
-		expect(result.content).toBe("done");
-		const toolMsgs = loop.chat.allMessages().filter((m) => m.role === "tool");
-		expect(toolMsgs).toHaveLength(1);
-		expect(toolMsgs[0]?.content).toBe("[tool call denied by interceptor]");
-	}, 4000);
-
-	it("repeated full-deny is bounded by maxTurns (no infinite loop)", async () => {
-		// mockAdapter clamps to the last response, so EVERY turn requests a
-		// denied tool and never naturally stops. The maxTurns cap must
-		// terminate the run rather than spin forever.
-		const denyResp: LLMResponse = {
-			content: "",
-			toolCalls: [{ id: "x", name: "forbid", arguments: {} }],
-		};
-		const adapter = mockAdapter([denyResp]);
-		const forbidTool: ToolDefinition = {
-			name: "forbid",
-			description: "",
-			parameters: {},
-			handler: () => {
-				throw new Error("should not execute");
-			},
-		};
-		const loop = agentLoop("deny-bounded", {
-			adapter,
-			tools: [forbidTool],
-			maxTurns: 2,
-			interceptToolCalls: toolInterceptor({
-				allow: [
-					node<(c: ToolCall) => boolean>([], {
-						name: "deny-forbid",
-						initial: (c: ToolCall) => c.name !== "forbid",
-					}),
-				],
-			}),
-		});
-
-		// State-machine trace with `maxTurns: 2`:
-		//   Wave A (turn 0→1, !capReached): effResponse sets status="acting";
-		//     toolCallsRaw emits → gated emits RESOLVED → effFullDeny fires →
-		//     1 synthetic "[tool call denied by interceptor]" + status →
-		//     "thinking".
-		//   Wave B (turn 1→2, capReached=TRUE): effResponse sets status="done"
-		//     DIRECTLY, never goes through "acting", so toolCallsRaw stays
-		//     RESOLVED → effFullDeny doesn't fire. However, the EC-2 fix
-		//     (2026-05-21) makes effResponse synthesize a
-		//     "[tool call denied: maxTurns reached]" tool_result for the
-		//     pending tool_use in the same batch — so Wave B contributes
-		//     1 synthetic tool message of its own. Net: TWO synthetic tool
-		//     messages, one per wave, each with the wave-appropriate reason.
-		// Pre-EC-2 this test asserted `toolMsgs.length === 1` and pinned
-		// the orphan-tool_use bug; the assertion was widened to lock the
-		// post-fix valid-transcript contract.
-		await loop.run("go");
-		const toolMsgs = loop.chat.allMessages().filter((m) => m.role === "tool");
-		expect(toolMsgs.length).toBe(2);
-		expect(toolMsgs[0]?.content).toBe("[tool call denied by interceptor]");
-		expect(toolMsgs[1]?.content).toBe("[tool call denied: maxTurns reached]");
-	}, 4000);
-
-	it("partial deny synthesizes tool_results for the denied subset (valid transcript for next adapter.invoke)", async () => {
-		// Two tools requested; interceptor allows "ok", denies "forbid".
-		// Without the partial-deny path in effFullDeny, the assistant
-		// message would carry tool_use:forbid with no matching
-		// tool_result — the next LLM call would see an invalid
-		// transcript. With it, the denied subset gets a synthetic
-		// "[tool call denied by interceptor]" result; the allowed
-		// subset's real result flows through effResults normally.
-		const partialResp: LLMResponse = {
-			content: "",
-			toolCalls: [
-				{ id: "tc-ok", name: "ok", arguments: {} },
-				{ id: "tc-no", name: "forbid", arguments: {} },
-			],
-		};
-		const finalResp: LLMResponse = { content: "done", finishReason: "end_turn" };
-		const adapter = mockAdapter([partialResp, finalResp]);
-		const okTool: ToolDefinition = {
-			name: "ok",
-			description: "",
-			parameters: {},
-			handler: () => "ok-result",
-		};
-		const forbidTool: ToolDefinition = {
-			name: "forbid",
-			description: "",
-			parameters: {},
-			handler: () => {
-				throw new Error("should not execute");
-			},
-		};
-		const loop = agentLoop("deny-partial", {
-			adapter,
-			tools: [okTool, forbidTool],
-			interceptToolCalls: toolInterceptor({
-				allow: [
-					node<(c: ToolCall) => boolean>([], {
-						name: "deny-forbid",
-						initial: (c: ToolCall) => c.name !== "forbid",
-					}),
-				],
-			}),
-		});
-
-		const result = await loop.run("go");
-		expect(result.content).toBe("done");
-		const toolMsgs = loop.chat.allMessages().filter((m) => m.role === "tool");
-		expect(toolMsgs.length).toBe(2);
-		// Every tool_use in the assistant message has a matching tool_result.
-		const resultsById = new Map<string, string | undefined>();
-		for (const m of toolMsgs) {
-			// ChatMessage shape for "tool" role carries the id on toolCallId
-			const id = (m as { readonly toolCallId?: string }).toolCallId;
-			if (id) resultsById.set(id, m.content);
-		}
-		expect(resultsById.get("tc-ok")).toBe("ok-result");
-		expect(resultsById.get("tc-no")).toBe("[tool call denied by interceptor]");
-	}, 4000);
-
-	it("QA m8: string tool-result is not double-JSON-stringified", async () => {
-		const toolCallResp: LLMResponse = {
-			content: "",
-			toolCalls: [{ id: "tc1", name: "search", arguments: { q: "x" } }],
-		};
-		const finalResp: LLMResponse = {
-			content: "done",
-			finishReason: "end_turn",
-		};
-		const adapter = mockAdapter([toolCallResp, finalResp]);
-		const searchTool: ToolDefinition = {
-			name: "search",
-			description: "",
-			parameters: {},
-			handler: () => "hello world",
-		};
-		const loop = agentLoop("test-agent", { adapter, tools: [searchTool] });
-		await loop.run("query");
-		const msgs = loop.chat.allMessages();
-		const toolMsg = msgs.find((m) => m.role === "tool");
-		expect(toolMsg?.content).toBe("hello world");
-	});
-});
-
-// ---------------------------------------------------------------------------
-// llmExtractor / llmConsolidator (callback shape tests)
-// ---------------------------------------------------------------------------
-
-describe("patterns.ai.llmExtractor", () => {
-	it("returns a function", () => {
-		const resp: LLMResponse = {
-			content: JSON.stringify({ upsert: [{ key: "k1", value: "v1" }] }),
-		};
-		const adapter = mockAdapter([resp]);
-		const fn = llmExtractor("Extract memories.", { adapter });
-		expect(typeof fn).toBe("function");
-	});
-});
-
-describe("patterns.ai.llmConsolidator", () => {
-	it("returns a function", () => {
-		const resp: LLMResponse = {
-			content: JSON.stringify({ upsert: [{ key: "merged", value: "combined" }] }),
-		};
-		const adapter = mockAdapter([resp]);
-		const fn = llmConsolidator("Consolidate memories.", { adapter });
-		expect(typeof fn).toBe("function");
-	});
-});
-
-// ---------------------------------------------------------------------------
-// agentMemory
-// ---------------------------------------------------------------------------
-
-describe("patterns.ai.agentMemory", () => {
-	it("creates a graph with store, compact, and size nodes", () => {
-		const source = node<string>([], { initial: "test input" });
-		const mem = agentMemory("test-mem", source, {
-			extractFn: (raw, _existing) => ({
-				upsert: [{ key: "k1", value: String(raw) }],
-			}),
-			score: () => 1,
-			cost: () => 10,
-			budget: 100,
-		});
-
-		expect(mem).toBeDefined();
-		const desc = mem.describe() as { nodes: Record<string, unknown> };
-		expect(desc.nodes).toHaveProperty("store");
-		expect(desc.nodes).toHaveProperty("compact");
-		expect(desc.nodes).toHaveProperty("size");
-	});
-
-	it("throws when neither extractFn nor adapter+extractPrompt provided", () => {
-		expect(() =>
-			agentMemory("bad", node([], { initial: null }), {
-				score: () => 1,
-				cost: () => 1,
-			}),
-		).toThrow(/extractFn or adapter/);
-	});
-
-	it("exposes null for optional features when not configured", () => {
-		const mem = agentMemory("test-mem", node([], { initial: "x" }), {
-			extractFn: () => ({ upsert: [] }),
-			score: () => 1,
-			cost: () => 1,
-		});
-		expect(mem.vectors).toBeNull();
-		expect(mem.kg).toBeNull();
-		expect(mem.memoryTiers).toBeNull();
-		expect(mem.retrieveReactive).toBeNull();
-		mem.destroy();
-	});
-
-	it("B20: retrieveReactive emits results when query node changes", () => {
-		type Mem = { text: string };
-		const mem = agentMemory<Mem>("reactive-retrieve", node<string>([], { initial: "seed" }), {
-			extractFn: (raw) => ({
-				upsert: [
-					{ key: "a", value: { text: String(raw) } },
-					{ key: "b", value: { text: "other" } },
-				],
-			}),
-			score: (m) => (m.text.startsWith("seed") ? 2 : 1),
-			cost: () => 1,
-			vectorDimensions: 2,
-			embedFn: () => [0.5, 0.5],
-		});
-		expect(mem.retrieveReactive).not.toBeNull();
-		const query = node<{ vector?: readonly number[] } | null>([], { initial: null });
-		const resultNode = mem.retrieveReactive!(query);
-		const unsub = resultNode.subscribe(() => {});
-		// Null query → empty.
-		expect(resultNode.cache).toEqual([]);
-		// Fire a query — packed entries materialize.
-		query.emit({ vector: [0.5, 0.5] });
-		const packed = resultNode.cache as ReadonlyArray<{ key: string; score: number }>;
-		expect(packed.length).toBeGreaterThan(0);
-		// Highest-score entry first (seed value scored 2).
-		expect(packed[0]!.score).toBeGreaterThanOrEqual(packed[packed.length - 1]!.score);
-		unsub();
-		mem.destroy();
-	});
-
-	it("C1: concurrent retrieveReactive calls keep mirrors independent (no crosstalk)", () => {
-		type Mem = { text: string; tag: "alpha" | "beta" };
-		const mem = agentMemory<Mem>("c1-concurrent", node<string>([], { initial: "seed" }), {
-			extractFn: () => ({
-				upsert: [
-					{ key: "a", value: { text: "alpha-doc", tag: "alpha" } },
-					{ key: "b", value: { text: "beta-doc", tag: "beta" } },
-				],
-			}),
-			// Score by tag so the two queries' rankings are deterministic and distinct.
-			score: (m, ctx) => {
-				const wantTag = (ctx as { tag?: string } | null)?.tag;
-				return m.tag === wantTag ? 10 : 1;
-			},
-			cost: () => 1,
-			vectorDimensions: 2,
-			embedFn: () => [0.5, 0.5],
-		});
-
-		const qA = node<{ vector?: readonly number[]; context?: readonly string[] } | null>([], {
-			initial: { vector: [0.5, 0.5] },
-		});
-		const qB = node<{ vector?: readonly number[]; context?: readonly string[] } | null>([], {
-			initial: { vector: [0.5, 0.5] },
-		});
-		// `agentMemory` only supports one shared `context` node — exercise the
-		// concurrency invariant with a single context node and two distinct
-		// reactive query inputs. The point is that each call gets its own
-		// mounted subgraph: the two projection nodes are independent.
-		const rA = mem.retrieveReactive!(qA);
-		const rB = mem.retrieveReactive!(qB);
-		const unsubA = rA.subscribe(() => {});
-		const unsubB = rB.subscribe(() => {});
-
-		// Both projections fire and produce results — they don't share a mirror.
-		expect(Array.isArray(rA.cache)).toBe(true);
-		expect(Array.isArray(rB.cache)).toBe(true);
-
-		// The per-call subgraphs are visible in describe() — locked-decision #3.
-		const desc = mem.describe() as { subgraphs?: string[] };
-		expect(desc.subgraphs).toContain("retrieval");
-		const retrievalDesc = (mem.tryResolve("retrieval::retrieve_1::projection") ?? null) as unknown;
-		expect(retrievalDesc).not.toBeNull();
-		expect(mem.tryResolve("retrieval::retrieve_2::projection")).toBeDefined();
-		expect(mem.tryResolve("retrieval::retrieve_1::result")).toBeDefined();
-		// QA F-9 (2026-04-30): the per-call `mirror` effect was dropped along
-		// with the shared `retrieval` / `retrievalTrace` state mirrors. The
-		// per-call subgraph now contains only `context`, `result`, `projection`.
-		expect(mem.tryResolve("retrieval::retrieve_1::context")).toBeDefined();
-
-		// Updating qA must not stomp qB's projection cache (independent mirrors).
-		const beforeBCache = rB.cache;
-		qA.emit({ vector: [0.5, 0.5] });
-		expect(rB.cache).toBe(beforeBCache);
-
-		unsubA();
-		unsubB();
-		mem.destroy();
-	});
-
-	it("C1: per-call subgraph is removable from describe() via parent retrieval graph", () => {
-		// Drive `memoryRetrieval` directly so we hold a `MemoryRetrievalGraph`
-		// reference and can call `remove(segment)` on it — `agentMemory` hides
-		// the inner mount.
-		const source = node<string>([], { initial: "seed" });
-		const mem = agentMemory<{ text: string }>("c1-remove", source, {
-			extractFn: () => ({ upsert: [{ key: "a", value: { text: "a" } }] }),
-			score: () => 1,
-			cost: () => 1,
-			vectorDimensions: 2,
-			embedFn: () => [0.5, 0.5],
-		});
-		const retrievalGraph = memoryRetrieval<{ text: string }>({
-			name: "retrieval-direct",
-			store: mem.distillBundle,
-			vectors: mem.vectors,
-			score: () => 1,
-			cost: () => 1,
-		});
-
-		const q = node<{ vector?: readonly number[] } | null>([], {
-			initial: { vector: [0.5, 0.5] },
-		});
-		const r1 = retrievalGraph.retrieveReactive(q);
-		const r2 = retrievalGraph.retrieveReactive(q);
-		const u1 = r1.subscribe(() => {});
-		const u2 = r2.subscribe(() => {});
-
-		// Both segments visible in describe()'s subgraph list.
-		const before = retrievalGraph.describe() as { subgraphs?: string[] };
-		expect(before.subgraphs).toContain("retrieve_1");
-		expect(before.subgraphs).toContain("retrieve_2");
-		expect(retrievalGraph.tryResolve("retrieve_1::projection")).toBeDefined();
-
-		// Disposing the per-call subgraph drops it from describe().
-		retrievalGraph.remove("retrieve_1");
-		const after = retrievalGraph.describe() as { subgraphs?: string[] };
-		expect(after.subgraphs).not.toContain("retrieve_1");
-		expect(after.subgraphs).toContain("retrieve_2");
-		expect(retrievalGraph.tryResolve("retrieve_1::projection")).toBeUndefined();
-		// Sibling untouched.
-		expect(retrievalGraph.tryResolve("retrieve_2::projection")).toBeDefined();
-
-		u1();
-		u2();
-		retrievalGraph.destroy();
-		mem.destroy();
-	});
-
-	// Regression: Pre-DS-13.5.C, the synthesized `_contextNode` (when
-	// opts.context wasn't supplied) was a raw `node([], { initial: null })`
-	// that wasn't registered on the parent graph — invisible to describe().
-	// Spec: docs/implementation-plan.md DS-13.5.C
-	it("DS-13.5.C: synthesized _context is registered on parent graph when opts.context absent", () => {
-		const source = node<string>([], { initial: "seed" });
-		const mem = agentMemory<{ text: string }>("dsC-synth", source, {
-			extractFn: () => ({ upsert: [{ key: "a", value: { text: "a" } }] }),
-			score: () => 1,
-			cost: () => 1,
-		});
-		const retrievalGraph = memoryRetrieval<{ text: string }>({
-			name: "retrieval-no-ctx",
-			store: mem.distillBundle,
-			score: () => 1,
-			cost: () => 1,
-			// no `context` supplied
-		});
-
-		// Synthesized `_context` is registered → describe() / tryResolve see it.
-		expect(retrievalGraph.tryResolve("_context")).toBeDefined();
-
-		retrievalGraph.destroy();
-		mem.destroy();
-	});
-
-	it("DS-13.5.C: caller-supplied opts.context is NOT registered on retrieval graph (cross-graph ownership)", () => {
-		const source = node<string>([], { initial: "seed" });
-		const mem = agentMemory<{ text: string }>("dsC-owned", source, {
-			extractFn: () => ({ upsert: [{ key: "a", value: { text: "a" } }] }),
-			score: () => 1,
-			cost: () => 1,
-		});
-		const callerOwnedCtx = node<unknown>([], { initial: { hint: "caller-owned" } });
-		const retrievalGraph = memoryRetrieval<{ text: string }>({
-			name: "retrieval-owned-ctx",
-			store: mem.distillBundle,
-			score: () => 1,
-			cost: () => 1,
-			context: callerOwnedCtx,
-		});
-
-		// Caller-owned node is NOT registered on retrievalGraph.
-		expect(retrievalGraph.tryResolve("_context")).toBeUndefined();
-
-		retrievalGraph.destroy();
-		mem.destroy();
-	});
-
-	// Regression: Pre-DS-13.5.C, per-call subgraph leaked when caller dropped
-	// projection — `retrieve_${id}` segments accumulated in the parent graph.
-	// Post-fix, projection's `deactivate` cleanup hook fires on last
-	// unsubscribe and removes the segment via `parent.remove(segment)`.
-	// Spec: docs/implementation-plan.md DS-13.5.C
-	it("DS-13.5.C: per-call subgraph auto-unmounts after subscribe-then-unsubscribe", () => {
-		const source = node<string>([], { initial: "seed" });
-		const mem = agentMemory<{ text: string }>("dsC-unmount", source, {
-			extractFn: () => ({ upsert: [{ key: "a", value: { text: "a" } }] }),
-			score: () => 1,
-			cost: () => 1,
-			vectorDimensions: 2,
-			embedFn: () => [0.5, 0.5],
-		});
-		const retrievalGraph = memoryRetrieval<{ text: string }>({
-			name: "retrieval-unmount",
-			store: mem.distillBundle,
-			vectors: mem.vectors,
-			score: () => 1,
-			cost: () => 1,
-		});
-
-		const q = node<{ vector?: readonly number[] } | null>([], {
-			initial: { vector: [0.5, 0.5] },
-		});
-
-		const r = retrievalGraph.retrieveReactive(q);
-		expect(retrievalGraph.tryResolve("retrieve_1::projection")).toBeDefined();
-
-		const unsub = r.subscribe(() => {});
-
-		// While subscriber is attached, segment stays mounted.
-		const subgraphsDuring = (retrievalGraph.describe() as { subgraphs?: string[] }).subgraphs;
-		expect(subgraphsDuring).toContain("retrieve_1");
-
-		// Last unsubscribe → projection's deactivate cleanup fires → segment removed.
-		unsub();
-
-		expect(retrievalGraph.tryResolve("retrieve_1::projection")).toBeUndefined();
-		const subgraphsAfter = (retrievalGraph.describe() as { subgraphs?: string[] }).subgraphs;
-		expect(subgraphsAfter ?? []).not.toContain("retrieve_1");
-
-		retrievalGraph.destroy();
-		mem.destroy();
-	});
-
-	it("DS-13.5.C: concurrent retrieveReactive calls auto-unmount independently", () => {
-		const source = node<string>([], { initial: "seed" });
-		const mem = agentMemory<{ text: string }>("dsC-concurrent", source, {
-			extractFn: () => ({ upsert: [{ key: "a", value: { text: "a" } }] }),
-			score: () => 1,
-			cost: () => 1,
-			vectorDimensions: 2,
-			embedFn: () => [0.5, 0.5],
-		});
-		const retrievalGraph = memoryRetrieval<{ text: string }>({
-			name: "retrieval-concurrent",
-			store: mem.distillBundle,
-			vectors: mem.vectors,
-			score: () => 1,
-			cost: () => 1,
-		});
-
-		const qA = node<{ vector?: readonly number[] } | null>([], {
-			initial: { vector: [0.5, 0.5] },
-		});
-		const qB = node<{ vector?: readonly number[] } | null>([], {
-			initial: { vector: [0.5, 0.5] },
-		});
-		const rA = retrievalGraph.retrieveReactive(qA);
-		const rB = retrievalGraph.retrieveReactive(qB);
-		const uA = rA.subscribe(() => {});
-		const uB = rB.subscribe(() => {});
-
-		// Both segments mounted.
-		expect(retrievalGraph.tryResolve("retrieve_1::projection")).toBeDefined();
-		expect(retrievalGraph.tryResolve("retrieve_2::projection")).toBeDefined();
-
-		// Unsubscribe A → only A's segment is removed; B stays.
-		uA();
-		expect(retrievalGraph.tryResolve("retrieve_1::projection")).toBeUndefined();
-		expect(retrievalGraph.tryResolve("retrieve_2::projection")).toBeDefined();
-
-		// Unsubscribe B → B's segment is removed too.
-		uB();
-		expect(retrievalGraph.tryResolve("retrieve_2::projection")).toBeUndefined();
-
-		retrievalGraph.destroy();
-		mem.destroy();
-	});
-
-	it("B12: contextWeight boosts entries whose breadcrumb matches the query", () => {
-		type Mem = { text: string; context: readonly string[] };
-		const mem = agentMemory<Mem>("hier", node<string>([], { initial: "seed" }), {
-			extractFn: () => ({
-				upsert: [
-					{ key: "authA", value: { text: "auth", context: ["projects", "auth", "tokens"] } },
-					{ key: "billA", value: { text: "bill", context: ["projects", "billing"] } },
-				],
-			}),
-			// Identical flat score — the hierarchical boost should decide ordering.
-			score: () => 1,
-			cost: () => 1,
-			contextOf: (m) => m.context,
-			contextWeight: 10,
-			vectorDimensions: 2,
-			embedFn: () => [0.5, 0.5],
-		});
-		const q = node<{ vector?: readonly number[]; context?: readonly string[] } | null>([], {
-			initial: {
-				vector: [0.5, 0.5],
-				context: ["projects", "auth"],
-			},
-		});
-		const r = mem.retrieveReactive!(q);
-		const unsub = r.subscribe(() => {});
-		const packed = r.cache as ReadonlyArray<{ key: string; score: number }>;
-		// authA shares prefix depth 2 of 2 → boosted; billA shares depth 1 → smaller boost.
-		const authEntry = packed.find((p) => p.key === "authA");
-		const billEntry = packed.find((p) => p.key === "billA");
-		expect(authEntry).toBeDefined();
-		expect(billEntry).toBeDefined();
-		expect(authEntry!.score).toBeGreaterThan(billEntry!.score);
-		unsub();
-		mem.destroy();
-	});
-
-	it("creates vector index when vectorDimensions + embedFn provided", () => {
-		const source = node<string>([], { initial: "hello" });
-		const mem = agentMemory<string>("vec-mem", source, {
-			extractFn: (raw) => ({
-				upsert: [{ key: "k1", value: String(raw) }],
-			}),
-			score: () => 1,
-			cost: () => 10,
-			budget: 100,
-			vectorDimensions: 3,
-			embedFn: (_mem) => [0.1, 0.2, 0.3],
-		});
-
-		expect(mem.vectors).not.toBeNull();
-		// Class B audit (2026-04-30): the vector index is mounted inside the
-		// `vectors` subgraph (`MemoryWithVectorsGraph`). Walking into the
-		// describe tree confirms the mount + the inner VectorIndexGraph.
-		const desc = mem.describe();
-		expect(desc.subgraphs).toContain("vectors");
-		// `vectors::vectorIndex` is a mount-of-a-mount; resolve a node inside
-		// the inner `VectorIndexGraph` to confirm wiring (its `entries`
-		// state node is registered top-level on the inner graph).
-		expect(mem.tryResolve("vectors::vectorIndex::entries")).toBeDefined();
-		mem.destroy();
-	});
-
-	it("mounts knowledge graph when enableKnowledgeGraph is true", () => {
-		const source = node<string>([], { initial: "hello" });
-		const mem = agentMemory<string>("kg-mem", source, {
-			extractFn: (raw) => ({
-				upsert: [{ key: "k1", value: String(raw) }],
-			}),
-			score: () => 1,
-			cost: () => 10,
-			enableKnowledgeGraph: true,
-			entityFn: (key, _mem) => ({
-				entities: [{ id: key, value: { name: key } }],
-			}),
-		});
-
-		expect(mem.kg).not.toBeNull();
-		mem.destroy();
-	});
-
-	it("sets up 3-tier storage with permanent filter", () => {
-		const source = node<string>([], { initial: "hello" });
-		const mem = agentMemory<string>("tier-mem", source, {
-			extractFn: (raw) => ({
-				upsert: [{ key: "core-profile", value: String(raw) }],
-			}),
-			score: () => 1,
-			cost: () => 10,
-			tiers: {
-				permanentFilter: (key) => key.startsWith("core-"),
-				maxActive: 100,
-			},
-		});
-
-		expect(mem.memoryTiers).not.toBeNull();
-		expect(mem.memoryTiers!.permanent).toBeDefined();
-		expect(typeof mem.memoryTiers!.tierOf).toBe("function");
-		expect(typeof mem.memoryTiers!.markPermanent).toBe("function");
-		mem.destroy();
-	});
-
-	it("Tier 4.1 B / 4.3 B: archives below-threshold entries via retention; permanentKeys/entryCreatedAtNs are reactive nodes", () => {
-		// Score function: anything <= 0.05 (decayed) gets archived.
-		// archiveThreshold = 0.1, so a base score of 0.05 falls under without decay.
-		let nextKey = 0;
-		const source = node<string>([], { initial: "hello" });
-		const mem = agentMemory<string>("tier-archive", source, {
-			extractFn: (raw, _existing) => {
-				// Each emit produces a unique low-score entry that retention should archive.
-				const key = `low-${++nextKey}`;
-				return { upsert: [{ key, value: String(raw) }] };
-			},
-			score: () => 0.05, // below archiveThreshold
-			cost: () => 1,
-			tiers: {
-				permanentFilter: (key) => key.startsWith("core-"),
-				archiveThreshold: 0.1,
-				maxActive: 100,
-			},
-		});
-
-		// Trigger a few extract cycles.
-		source.down([[DATA, "a"]]);
-		source.down([[DATA, "b"]]);
-		source.down([[DATA, "c"]]);
-
-		// Active store should be empty — every entry's score < threshold,
-		// retention archived synchronously inside each set().
-		expect(mem.size.cache).toBe(0);
-
-		// permanentKeys + entryCreatedAtNs nodes are reachable by path —
-		// describe()/explain() can now walk to them (Tier 4.3 B).
-		// Class B audit (2026-04-30): the tier nodes live inside the
-		// `tiers` subgraph (`MemoryWithTiersGraph`).
-		expect(mem.tryResolve("tiers::permanentKeys")).toBeDefined();
-		expect(mem.tryResolve("tiers::entryCreatedAtNs")).toBeDefined();
-
-		mem.destroy();
-	});
-
-	// Regression: Pre-DS-13.5.F, retention.score wrote
-	// `entryCreatedAtNs.set(key, nowNs)` from inside the score fn (D1).
-	// Post-fix, retention.score is read-only and the first-write happens via
-	// the `entryCreatedAtNs/sync` effect on store.entries.
-	// Spec: docs/implementation-plan.md DS-13.5.F
-	it("DS-13.5.F: entryCreatedAtNs/sync effect populates timestamps for new keys", () => {
-		const source = node<string>([], { initial: "v0" });
-		const mem = agentMemory<string>("f-sync-add", source, {
-			extractFn: (raw, _existing) => ({
-				upsert: [{ key: "k1", value: String(raw) }],
-			}),
-			score: () => 1.0, // above archiveThreshold → entry stays active
-			cost: () => 1,
-			tiers: { archiveThreshold: 0.1, maxActive: 100 },
-		});
-
-		source.down([[DATA, "v1"]]);
-
-		const createdNode = mem.tryResolve("tiers::entryCreatedAtNs");
-		expect(createdNode).toBeDefined();
-		const created = createdNode!.cache as ReadonlyMap<string, number> | undefined;
-		expect(created?.has("k1")).toBe(true);
-		expect(typeof created?.get("k1")).toBe("number");
-		expect(created?.get("k1")).toBeGreaterThan(0);
-
-		mem.destroy();
-	});
-
-	it("DS-13.5.F: entryCreatedAtNs/sync is idempotent — re-emission keeps original timestamp", () => {
-		const source = node<string>([], { initial: "v0" });
-		const mem = agentMemory<string>("f-idem", source, {
-			extractFn: (raw, _existing) => ({
-				upsert: [{ key: "k1", value: String(raw) }],
-			}),
-			score: () => 1.0,
-			cost: () => 1,
-			tiers: { archiveThreshold: 0.1, maxActive: 100 },
-		});
-
-		source.down([[DATA, "first"]]);
-		const created1 = mem.tryResolve("tiers::entryCreatedAtNs")!.cache as ReadonlyMap<
-			string,
-			number
-		>;
-		const ts1 = created1.get("k1");
-		expect(ts1).toBeDefined();
-
-		// Re-emit for the same key — sync effect should skip via has() guard.
-		source.down([[DATA, "second"]]);
-		source.down([[DATA, "third"]]);
-
-		const created2 = mem.tryResolve("tiers::entryCreatedAtNs")!.cache as ReadonlyMap<
-			string,
-			number
-		>;
-		const ts2 = created2.get("k1");
-		expect(ts2).toBe(ts1);
-
-		mem.destroy();
-	});
-
-	it("DS-13.5.F: entryCreatedAtNs/sync visible in describe()", () => {
-		const source = node<string>([], { initial: "v0" });
-		const mem = agentMemory<string>("f-describe", source, {
-			extractFn: (_raw, _existing) => ({
-				upsert: [{ key: "k1", value: "v" }],
-			}),
-			score: () => 1.0,
-			cost: () => 1,
-			tiers: { archiveThreshold: 0.1, maxActive: 100 },
-		});
-
-		// New effect is mounted at `entryCreatedAtNs/sync` on the inner
-		// MemoryWithTiersGraph (subgraph "tiers" from agentMemory's perspective).
-		expect(mem.tryResolve("tiers::entryCreatedAtNs/sync")).toBeDefined();
-
-		mem.destroy();
-	});
-
-	it("DS-13.5.F: entryCreatedAtNs GC still removes keys absent from active store", () => {
-		const source = node<string>([], { initial: "v0" });
-		// Use a score that flips: entry stays active during first wave,
-		// then archives on next emission via maxActive eviction.
-		let scoreVal = 1.0;
-		const mem = agentMemory<string>("f-gc", source, {
-			extractFn: (_raw, _existing) => ({
-				upsert: [{ key: "k1", value: "v" }],
-			}),
-			score: () => scoreVal,
-			cost: () => 1,
-			tiers: { archiveThreshold: 0.1, maxActive: 100 },
-		});
-
-		source.down([[DATA, "first"]]);
-		const beforeArchive = mem.tryResolve("tiers::entryCreatedAtNs")!.cache as ReadonlyMap<
-			string,
-			number
-		>;
-		expect(beforeArchive.has("k1")).toBe(true);
-
-		// Drop the score under archiveThreshold; next emission archives k1
-		// from the active store. The pre-existing GC subscriber on
-		// store.store.entries should then prune the entryCreatedAtNs entry.
-		scoreVal = 0.05;
-		source.down([[DATA, "second"]]);
-
-		const afterArchive = mem.tryResolve("tiers::entryCreatedAtNs")!.cache as ReadonlyMap<
-			string,
-			number
-		>;
-		expect(afterArchive.has("k1")).toBe(false);
-
-		mem.destroy();
-	});
-
-	it("retrieval pipeline returns packed results with vector search", () => {
-		const source = node<string>([], { initial: "test" });
-		const mem = agentMemory<string>("retr-mem", source, {
-			extractFn: (raw) => ({
-				upsert: [
-					{ key: "m1", value: `mem-${raw}` },
-					{ key: "m2", value: `other-${raw}` },
-				],
-			}),
-			score: (_mem, _ctx) => 0.8,
-			cost: () => 10,
-			budget: 100,
-			vectorDimensions: 3,
-			embedFn: (_mem) => [1.0, 0.0, 0.0],
-			retrieval: { topK: 5 },
-		});
-
-		expect(mem.retrieveReactive).not.toBeNull();
-
-		// Execute a retrieval query reactively. C1: imperative `retrieve()`
-		// dropped — wrap a one-shot query in a reactive node and read the
-		// projection node's cache after subscription drains.
-		const q = node<{ vector?: readonly number[] } | null>([], {
-			initial: { vector: [1.0, 0.0, 0.0] },
-		});
-		const r = mem.retrieveReactive!(q);
-		const unsub = r.subscribe(() => {});
-		const results = r.cache as ReadonlyArray<unknown> | undefined;
-		expect(Array.isArray(results)).toBe(true);
-		unsub();
-		mem.destroy();
-	});
-
-	it("retrieval trace captures pipeline stages", () => {
-		const source = node<string>([], { initial: "input" });
-		const mem = agentMemory<string>("trace-mem", source, {
-			extractFn: (raw) => ({
-				upsert: [{ key: "k1", value: String(raw) }],
-			}),
-			score: () => 1,
-			cost: () => 5,
-			budget: 100,
-			vectorDimensions: 3,
-			embedFn: () => [0.5, 0.5, 0.0],
-		});
-
-		const q = node<{ vector?: readonly number[] } | null>([], {
-			initial: { vector: [0.5, 0.5, 0.0] },
-		});
-		const r = mem.retrieveReactive!(q);
-		const unsub = r.subscribe(() => {});
-		// /qa F-9 (2026-04-30): the shared `retrievalTrace` mirror was
-		// dropped. The per-call `result` derived (upstream of `projection`)
-		// still carries `{ packed, trace }`. Resolve it via the per-call
-		// subgraph mount path: `retrieval::retrieve_${seq}::result`.
-		const resultNode = mem.resolve("retrieval::retrieve_1::result");
-		const resultCache = resultNode.cache as
-			| { packed: ReadonlyArray<unknown>; trace: unknown }
-			| undefined;
-		const trace = resultCache?.trace as Record<string, unknown> | null | undefined;
-		if (trace) {
-			expect(trace).toHaveProperty("vectorCandidates");
-			expect(trace).toHaveProperty("graphExpanded");
-			expect(trace).toHaveProperty("ranked");
-			expect(trace).toHaveProperty("packed");
-		}
-		unsub();
-		mem.destroy();
-	});
-});
-
-// ---------------------------------------------------------------------------
-// admissionFilter3D
-// ---------------------------------------------------------------------------
-
-describe("patterns.ai.admissionFilter3D", () => {
-	it("admits when all thresholds met", () => {
-		const filter = admissionFilter3D({
-			scoreFn: () => ({ persistence: 0.8, structure: 0.5, personalValue: 0.7 }),
-		});
-		expect(filter("test")).toBe(true);
-	});
-
-	it("rejects when persistence below threshold", () => {
-		const filter = admissionFilter3D({
-			scoreFn: () => ({ persistence: 0.1, structure: 0.5, personalValue: 0.7 }),
-			persistenceThreshold: 0.3,
-		});
-		expect(filter("test")).toBe(false);
-	});
-
-	it("rejects when personalValue below threshold", () => {
-		const filter = admissionFilter3D({
-			scoreFn: () => ({ persistence: 0.8, structure: 0.5, personalValue: 0.1 }),
-			personalValueThreshold: 0.3,
-		});
-		expect(filter("test")).toBe(false);
-	});
-
-	it("rejects unstructured when requireStructured is true", () => {
-		const filter = admissionFilter3D({
-			scoreFn: () => ({ persistence: 0.8, structure: 0, personalValue: 0.7 }),
-			requireStructured: true,
-		});
-		expect(filter("test")).toBe(false);
-	});
-
-	it("requires an explicit scoreFn (default 0.5 scorer was retired in Unit 8)", () => {
-		// `defaultAdmissionScorer` admitted everything in disguise — retired
-		// per Unit 8 review. Callers must supply a real scorer.
-		const filter = admissionFilter3D({
-			scoreFn: () => ({ persistence: 0.5, structure: 0.5, personalValue: 0.5 }),
-		});
-		expect(filter("anything")).toBe(true);
-	});
-
-	it("integrates with agentMemory admissionFilter option", () => {
-		const admitted: unknown[] = [];
-		const filter = admissionFilter3D({
-			scoreFn: (raw) => ({
-				persistence: raw === "keep" ? 0.8 : 0.1,
-				structure: 0.5,
-				personalValue: 0.5,
-			}),
-		});
-
-		const source = node<string>([], { initial: "keep" });
-		const mem = agentMemory<string>("3d-mem", source, {
-			extractFn: (raw) => {
-				admitted.push(raw);
-				return { upsert: [{ key: "k", value: String(raw) }] };
-			},
-			score: () => 1,
-			cost: () => 1,
-			admissionFilter: filter,
-		});
-
-		expect(mem).toBeDefined();
-		mem.destroy();
-	});
-});
-
-// ---------------------------------------------------------------------------
-// admissionScored (Unit 8 generic — admissionFilter3D is sugar over this)
-// ---------------------------------------------------------------------------
-
-describe("patterns.ai.admissionScored", () => {
-	it("admits when all gated dimensions meet thresholds", () => {
-		const filter = admissionScored<"a" | "b">({
-			scoreFn: () => ({ a: 0.7, b: 0.4 }),
-			thresholds: { a: 0.5, b: 0.3 },
-		});
-		expect(filter("x")).toBe(true);
-	});
-
-	it("rejects when any gated dimension is below threshold", () => {
-		const filter = admissionScored<"a" | "b">({
-			scoreFn: () => ({ a: 0.7, b: 0.1 }),
-			thresholds: { a: 0.5, b: 0.3 },
-		});
-		expect(filter("x")).toBe(false);
-	});
-
-	it("ignores dimensions without thresholds (telemetry-only)", () => {
-		const filter = admissionScored<"a" | "telemetry">({
-			scoreFn: () => ({ a: 0.6, telemetry: -100 }),
-			thresholds: { a: 0.5 },
-		});
-		// `telemetry` has no threshold → ungated, even though it's negative.
-		expect(filter("x")).toBe(true);
-	});
-
-	it("treats missing scores as below threshold", () => {
-		const filter = admissionScored<"a" | "b">({
-			scoreFn: () => ({ a: 0.9 }) as never,
-			thresholds: { a: 0.5, b: 0.3 },
-		});
-		// b is missing → fails the b ≥ 0.3 check.
-		expect(filter("x")).toBe(false);
-	});
-});
-
-// ---------------------------------------------------------------------------
-// knobsAsTools (5.4)
-// ---------------------------------------------------------------------------
-
-describe("knobsAsTools", () => {
-	it("generates tool schemas from state nodes with meta", () => {
-		const g = new Graph("test");
-		const temp = node([], {
-			name: "temperature",
-			meta: {
-				description: "Room temperature",
-				type: "number",
-				range: [60, 90],
-				unit: "°F",
-				access: "both",
-			},
-			initial: 72,
-		});
-		const mode = node([], {
-			name: "mode",
-			meta: {
-				description: "HVAC mode",
-				type: "enum",
-				values: ["auto", "cool", "heat", "off"],
-				access: "llm",
-			},
-			initial: "auto",
-		});
-		// Derived node should NOT appear as a tool
-		const summary = node(
-			[temp, mode],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit(`${data[1]}: ${data[0]}`);
-			},
-			{ describeKind: "derived", name: "summary", meta: { description: "Summary display" } },
-		);
-		g.add(temp, { name: "temperature" });
-		g.add(mode, { name: "mode" });
-		g.add(summary, { name: "summary" });
-
-		const result = knobsAsTools(g);
-
-		expect(result.openai).toHaveLength(2);
-		expect(result.mcp).toHaveLength(2);
-		expect(result.definitions).toHaveLength(2);
-
-		// Check OpenAI schema shape
-		const tempTool = result.openai.find((t) => t.function.name === "temperature");
-		expect(tempTool).toBeDefined();
-		expect(tempTool!.type).toBe("function");
-		expect(tempTool!.function.description).toBe("Room temperature");
-		expect(tempTool!.function.parameters).toEqual({
-			type: "object",
-			required: ["value"],
-			properties: {
-				value: {
-					type: "number",
-					minimum: 60,
-					maximum: 90,
-					description: "Unit: °F",
-				},
-			},
-			additionalProperties: false,
-		});
-
-		// Check MCP schema shape
-		const modeMcp = result.mcp.find((t) => t.name === "mode");
-		expect(modeMcp).toBeDefined();
-		expect(modeMcp!.description).toBe("HVAC mode");
-		expect((modeMcp!.inputSchema.properties as Record<string, unknown>).value).toEqual({
-			type: "string",
-			enum: ["auto", "cool", "heat", "off"],
-		});
-
-		// Handler calls graph.set
-		const tempDef = result.definitions.find((d) => d.name === "temperature");
-		tempDef!.handler({ value: 80 });
-		expect(temp.cache).toBe(80);
-
-		g.destroy();
-	});
-
-	it("excludes state nodes with access=human", () => {
-		const g = new Graph("test");
-		const secret = node([], {
-			name: "secret",
-			meta: { description: "Human-only secret", access: "human" },
-			initial: "pw",
-		});
-		g.add(secret, { name: "secret" });
-
-		const result = knobsAsTools(g);
-		expect(result.openai).toHaveLength(0);
-		g.destroy();
-	});
-
-	it("includes V0 version metadata for knob definitions", () => {
-		const g = new Graph("versioned-knobs");
-		const knob = node([], {
-			name: "knob",
-			versioning: 0,
-			meta: { description: "Versioned knob", access: "both" },
-			initial: 1,
-		});
-		g.add(knob, { name: "knob" });
-
-		const result = knobsAsTools(g);
-		const def = result.definitions.find((d) => d.name === "knob");
-		expect(def).toBeDefined();
-		expect(def!.version).toEqual({ id: knob.v!.id, version: knob.v!.version });
-		g.destroy();
-	});
-});
-
-// ---------------------------------------------------------------------------
-// gaugesAsContext (5.4)
-// ---------------------------------------------------------------------------
-
-describe("gaugesAsContext", () => {
-	it("formats gauge nodes as context string", () => {
-		const g = new Graph("dashboard");
-		const revenue = node([], {
-			name: "revenue",
-			meta: { description: "Monthly revenue", format: "currency", tags: ["finance"] },
-			initial: 1234.5,
-		});
-		const growth = node([], {
-			name: "growth",
-			meta: { description: "Growth rate", format: "percentage", tags: ["finance"] },
-			initial: 0.15,
-		});
-		const status = node([], {
-			name: "status",
-			meta: { description: "System status", format: "status" },
-			initial: "healthy",
-		});
-		g.add(revenue, { name: "revenue" });
-		g.add(growth, { name: "growth" });
-		g.add(status, { name: "status" });
-
-		const ctx = gaugesAsContext(g);
-
-		expect(ctx).toContain("Monthly revenue: $1234.50");
-		expect(ctx).toContain("Growth rate: 15.0%");
-		expect(ctx).toContain("System status: healthy");
-		// Finance group should be grouped together
-		expect(ctx).toContain("[finance]");
-		g.destroy();
-	});
-
-	it("returns empty string when no gauges", () => {
-		const g = new Graph("empty");
-		const plain = node([], { name: "plain", initial: 42 });
-		g.add(plain, { name: "plain" });
-
-		expect(gaugesAsContext(g)).toBe("");
-		g.destroy();
-	});
-
-	it("supports V0 delta filtering via sinceVersion", () => {
-		const g = new Graph("delta");
-		const metric = node([], {
-			name: "metric",
-			versioning: 0,
-			meta: { description: "Metric", access: "both" },
-			initial: 1,
-		});
-		g.add(metric, { name: "metric" });
-
-		const since = new Map<string, { id: string; version: number }>();
-		since.set("metric", { id: metric.v!.id, version: metric.v!.version });
-		expect(gaugesAsContext(g, undefined, { sinceVersion: since })).toBe("");
-
-		metric.down([[DATA, 2]]);
-		const ctx = gaugesAsContext(g, undefined, { sinceVersion: since });
-		expect(ctx).toContain("Metric: 2");
-		g.destroy();
-	});
-});
-
-// ---------------------------------------------------------------------------
-// validateGraphDef (5.4)
-// ---------------------------------------------------------------------------
-
-describe("validateGraphDef", () => {
-	it("accepts a valid graph definition", () => {
-		const def = {
-			name: "test",
-			nodes: {
-				input: { type: "state", status: "settled", deps: [], meta: {} },
-				compute: { type: "derived", status: "settled", deps: ["input"], meta: {} },
-			},
-			edges: [{ from: "input", to: "compute" }],
-			subgraphs: [],
-		};
-		const result = validateGraphDef(def);
-		expect(result.valid).toBe(true);
-		expect(result.errors).toHaveLength(0);
-	});
-
-	it("rejects missing name", () => {
-		const result = validateGraphDef({ nodes: {}, edges: [] });
-		expect(result.valid).toBe(false);
-		expect(result.errors.some((e) => e.includes("name"))).toBe(true);
-	});
-
-	it("rejects invalid node type", () => {
-		const result = validateGraphDef({
-			name: "test",
-			nodes: { a: { type: "unknown_type", deps: [], meta: {} } },
-			edges: [],
-		});
-		expect(result.valid).toBe(false);
-		expect(result.errors.some((e) => e.includes("invalid type"))).toBe(true);
-	});
-
-	it("rejects edges referencing nonexistent nodes", () => {
-		const result = validateGraphDef({
-			name: "test",
-			nodes: { a: { type: "state", deps: [], meta: {} } },
-			edges: [{ from: "a", to: "missing" }],
-		});
-		expect(result.valid).toBe(false);
-		expect(result.errors.some((e) => e.includes("missing"))).toBe(true);
-	});
-
-	it("detects duplicate edges", () => {
-		const result = validateGraphDef({
-			name: "test",
-			nodes: {
-				a: { type: "state", deps: [], meta: {} },
-				b: { type: "derived", deps: ["a"], meta: {} },
-			},
-			edges: [
-				{ from: "a", to: "b" },
-				{ from: "a", to: "b" },
-			],
-		});
-		expect(result.valid).toBe(false);
-		expect(result.errors.some((e) => e.includes("duplicate"))).toBe(true);
-	});
-
-	it("rejects non-object input", () => {
-		expect(validateGraphDef(null).valid).toBe(false);
-		expect(validateGraphDef("string").valid).toBe(false);
-		expect(validateGraphDef(42).valid).toBe(false);
-	});
-
-	it("rejects deps referencing nonexistent nodes", () => {
-		const result = validateGraphDef({
-			name: "test",
-			nodes: {
-				a: { type: "derived", deps: ["nonexistent"], meta: {} },
-			},
-			edges: [],
-		});
-		expect(result.valid).toBe(false);
-		expect(result.errors.some((e) => e.includes("nonexistent"))).toBe(true);
-	});
-});
-
-// ---------------------------------------------------------------------------
-// graphFromSpec (5.4)
-// ---------------------------------------------------------------------------
-
-describe("graphFromSpec", () => {
-	it("constructs a graph from LLM-generated GraphSpec JSON", async () => {
-		const spec = {
-			name: "calculator",
-			nodes: {
-				a: { type: "state", deps: [], value: 10, meta: { description: "Input A" } },
-				b: { type: "state", deps: [], value: 20, meta: { description: "Input B" } },
-			},
-		};
-
-		const adapter = mockAdapter([{ content: JSON.stringify(spec), finishReason: "end_turn" }]);
-
-		const g = await graphFromSpec("Build a calculator with two inputs", adapter);
-		expect(g.name).toBe("calculator");
-		expect(g.node("a").cache).toBe(10);
-		expect(g.node("b").cache).toBe(20);
-		g.destroy();
-	});
-
-	it("strips markdown fences from LLM response", async () => {
-		const spec = {
-			name: "simple",
-			nodes: {
-				x: { type: "state", deps: [], value: 1, meta: { description: "X" } },
-			},
-		};
-
-		const adapter = mockAdapter([
-			{
-				content: `\`\`\`json\n${JSON.stringify(spec)}\n\`\`\``,
-				finishReason: "end_turn",
-			},
-		]);
-
-		const g = await graphFromSpec("simple graph", adapter);
-		expect(g.name).toBe("simple");
-		g.destroy();
-	});
-
-	it("throws on invalid JSON from LLM", async () => {
-		const adapter = mockAdapter([{ content: "not json at all!", finishReason: "end_turn" }]);
-
-		await expect(graphFromSpec("bad", adapter)).rejects.toThrow("not valid JSON");
-	});
-
-	it("throws on validation failure", async () => {
-		const adapter = mockAdapter([
-			{
-				content: JSON.stringify({ nodes: {} }),
-				finishReason: "end_turn",
-			},
-		]);
-
-		await expect(graphFromSpec("missing name", adapter)).rejects.toThrow("invalid GraphSpec");
-	});
-
-	it("graphFromSpecReactive emits Graph for non-empty input, null otherwise", async () => {
-		const spec = {
-			name: "reactive",
-			nodes: { x: { type: "state", deps: [], value: 7, meta: { description: "X" } } },
-		};
-		const adapter = mockAdapter([{ content: JSON.stringify(spec), finishReason: "end_turn" }]);
-		const input = node([], { initial: "" });
-		const graphNode2 = graphFromSpecReactive(input, adapter);
-		const seen: (Graph | null)[] = [];
-		const unsub = graphNode2.subscribe((batch) => {
-			for (const m of batch) {
-				if (m[0] === DATA) seen.push(m[1] as Graph | null);
-			}
-		});
-
-		// Empty input → SENTINEL null
-		await new Promise((r) => setTimeout(r, 0));
-		expect(seen[seen.length - 1]).toBeNull();
-
-		// Push a real description → triggers LLM + compileSpec
-		input.down([[DATA, "make a reactive graph"]]);
-		await new Promise((r) => setTimeout(r, 50));
-		const last = seen[seen.length - 1];
-		expect(last).not.toBeNull();
-		expect((last as Graph).name).toBe("reactive");
-		(last as Graph).destroy();
-
-		unsub();
-	});
-});
-
-// ---------------------------------------------------------------------------
-// suggestStrategy (5.4)
-// ---------------------------------------------------------------------------
-
-describe("suggestStrategy", () => {
-	it("returns a structured strategy plan", async () => {
-		const plan = {
-			summary: "Add a rate limiter node",
-			reasoning: "The API calls node has no rate limiting, which could cause throttling.",
-			operations: [
-				{
-					type: "add_node",
-					name: "rate_limiter",
-					nodeType: "derived",
-					meta: { description: "Rate limiter" },
-				},
-				{ type: "connect", from: "rate_limiter", to: "api_calls" },
-				{ type: "set_value", name: "max_rate", value: 100 },
-			],
-		};
-
-		const adapter = mockAdapter([{ content: JSON.stringify(plan), finishReason: "end_turn" }]);
-
-		const g = new Graph("api");
-		const maxRate = node([], { name: "max_rate", meta: { description: "Max rate" }, initial: 50 });
-		g.add(maxRate, { name: "max_rate" });
-
-		const result = await suggestStrategy(g, "API calls are being throttled", adapter);
-
-		expect(result.summary).toBe("Add a rate limiter node");
-		expect(result.reasoning).toContain("rate limiting");
-		expect(result.operations).toHaveLength(3);
-		expect(result.operations[0]).toEqual({
-			type: "add_node",
-			name: "rate_limiter",
-			nodeType: "derived",
-			meta: { description: "Rate limiter" },
-		});
-
-		g.destroy();
-	});
-
-	it("throws on invalid LLM response", async () => {
-		const adapter = mockAdapter([{ content: "just some text", finishReason: "end_turn" }]);
-
-		const g = new Graph("test");
-		await expect(suggestStrategy(g, "problem", adapter)).rejects.toThrow("not valid JSON");
-		g.destroy();
-	});
-
-	it("throws on missing required fields", async () => {
-		const adapter = mockAdapter([
-			{ content: JSON.stringify({ operations: [] }), finishReason: "end_turn" },
-		]);
-
-		const g = new Graph("test");
-		await expect(suggestStrategy(g, "problem", adapter)).rejects.toThrow("missing 'summary'");
-		g.destroy();
-	});
-
-	it("suggestStrategyReactive emits a plan when problem fires", async () => {
-		const plan = {
-			summary: "tighten retries",
-			reasoning: "noise observed in flaky-tests bucket",
-			operations: [{ type: "set_value", name: "max_retries", value: 1 }],
-		};
-		const adapter = mockAdapter([{ content: JSON.stringify(plan), finishReason: "end_turn" }]);
-
-		const g = new Graph("rx");
-		g.add(node([], { name: "max_retries", meta: { description: "max" }, initial: 3 }), {
-			name: "max_retries",
-		});
-		const graphNode = node<Graph | null>([], { initial: g });
-		const problem = node([], { initial: "" });
-
-		const strategyNode = suggestStrategyReactive(graphNode, problem, adapter);
-		const seen: (StrategyPlan | null)[] = [];
-		const unsub = strategyNode.subscribe((batch) => {
-			for (const m of batch) {
-				if (m[0] === DATA) seen.push(m[1] as StrategyPlan | null);
-			}
-		});
-
-		await new Promise((r) => setTimeout(r, 0));
-		// withLatestFrom's documented initial-activation quirk: when both deps
-		// are node([]) nodes, the first paired emission is dropped (see comment
-		// in extra/operators.ts:866). So `seen` may be empty at this point —
-		// real DATA arrives after `problem` fires below.
-
-		problem.down([[DATA, "noisy retries"]]);
-		await new Promise((r) => setTimeout(r, 50));
-		const last = seen[seen.length - 1];
-		expect(last).not.toBeNull();
-		expect((last as StrategyPlan).summary).toBe("tighten retries");
-
-		unsub();
-		g.destroy();
-	});
-});
-
-// ---------------------------------------------------------------------------
-// promptNode
-// ---------------------------------------------------------------------------
-
-describe("patterns.ai.promptNode", () => {
-	const tick = () => new Promise((r) => setTimeout(r, 0));
-
-	it("forwards systemPrompt via invoke opts only (no double-send as message)", async () => {
-		let receivedMessages: readonly { role: string; content: string }[] = [];
-		let receivedOpts: Record<string, unknown> = {};
-		const adapter: LLMAdapter = {
-			provider: "mock",
-			invoke(messages, opts) {
-				receivedMessages = messages as readonly { role: string; content: string }[];
-				receivedOpts = opts as Record<string, unknown>;
-				return {
-					content: "ok",
-					finishReason: "end_turn",
-					usage: { input: { regular: 0 }, output: { regular: 0 } },
-				};
-			},
-			async *stream() {
-				yield { type: "token" as const, delta: "" };
-				yield { type: "usage" as const, usage: { input: { regular: 0 }, output: { regular: 0 } } };
-				yield { type: "finish" as const, reason: "stop" };
-			},
-		};
-
-		const dep = node([], { initial: "hello" });
-		const pn = promptNode<string>(adapter, [dep], (v: string) => `summarize: ${v}`, {
-			systemPrompt: "be terse",
-		});
-		const unsub = pn.subscribe(() => {});
-		await tick();
-
-		// systemPrompt only travels via opts — never injected into messages.
-		expect(receivedOpts.systemPrompt).toBe("be terse");
-		expect(receivedMessages.some((m) => m.role === "system")).toBe(false);
-		expect(receivedMessages.length).toBe(1);
-		expect(receivedMessages[0]?.role).toBe("user");
-
-		unsub();
-	});
-
-	it("aborts in-flight call when abort node emits true", async () => {
-		let lastSignal: AbortSignal | undefined;
-		const adapter: LLMAdapter = {
-			provider: "mock",
-			invoke(_messages, opts) {
-				lastSignal = opts?.signal;
-				return new Promise<LLMResponse>((resolve, reject) => {
-					if (opts?.signal?.aborted) {
-						reject(opts.signal.reason ?? new Error("aborted"));
-						return;
-					}
-					const onAbort = (): void => {
-						reject(opts?.signal?.reason ?? new Error("aborted"));
-					};
-					opts?.signal?.addEventListener("abort", onAbort, { once: true });
-					setTimeout(() => {
-						opts?.signal?.removeEventListener("abort", onAbort);
-						resolve({
-							content: "late",
-							finishReason: "end_turn",
-							usage: { input: { regular: 0 }, output: { regular: 0 } },
-						});
-					}, 100);
-				});
-			},
-			async *stream() {
-				yield { type: "token" as const, delta: "" };
-				yield { type: "usage" as const, usage: { input: { regular: 0 }, output: { regular: 0 } } };
-				yield { type: "finish" as const, reason: "stop" };
-			},
-		};
-
-		const dep = node([], { initial: "hello" });
-		const abort = node([], { initial: false });
-		const pn = promptNode<string>(adapter, [dep], (v: string) => `summarize: ${v}`, {
-			abort,
-		});
-		const unsub = pn.subscribe(() => {});
-		await tick();
-
-		// abort signal should be threaded through invoke opts
-		expect(lastSignal).toBeDefined();
-		expect(lastSignal?.aborted).toBe(false);
-
-		// Flip abort → signal aborts
-		abort.down([[DATA, true]]);
-		await tick();
-		expect(lastSignal?.aborted).toBe(true);
-
-		unsub();
-	});
-
-	it("emits nothing on true SENTINEL (no DATA ever); emits null when DATA(null) arrives", async () => {
-		const adapter: LLMAdapter = {
-			provider: "mock",
-			invoke(_messages, _opts) {
-				return {
-					content: "ok",
-					finishReason: "end_turn",
-					usage: { input: { regular: 0 }, output: { regular: 0 } },
-				};
-			},
-			async *stream() {
-				yield { type: "token" as const, delta: "" };
-				yield { type: "usage" as const, usage: { input: { regular: 0 }, output: { regular: 0 } } };
-				yield { type: "finish" as const, reason: "stop" };
-			},
-		};
-
-		// True SENTINEL: dep that NEVER emits DATA — first-run gate blocks
-		// messagesNode → switchMap doesn't fire → outer cache stays undefined.
-		const sentinelDep = node<string>();
-		const sentinelPn = promptNode<string>(adapter, [sentinelDep], (v) => `summarize: ${v}`);
-		const sentinelSeen: (string | null)[] = [];
-		const sentinelUnsub = sentinelPn.subscribe((batch) => {
-			for (const m of batch) if (m[0] === DATA) sentinelSeen.push(m[1] as string | null);
-		});
-		await tick();
-		expect(sentinelSeen).toEqual([]);
-		expect(sentinelPn.cache).toBe(undefined);
-		sentinelUnsub();
-
-		// DATA-seen path: dep starts as node([], { initial: null }) — first DATA value IS null.
-		// Per the SENTINEL convention (`prevData === undefined` is the only
-		// SENTINEL marker), this counts as "input arrived but is nullish" →
-		// emit `null` immediately.
-		const dep = node<string | null>([], { initial: null });
-		const pn = promptNode<string>(adapter, [dep], (v) => `summarize: ${v}`);
-		const seen: (string | null)[] = [];
-		const unsub = pn.subscribe((batch) => {
-			for (const m of batch) if (m[0] === DATA) seen.push(m[1] as string | null);
-		});
-		await tick();
-		expect(seen).toEqual([null]);
-		expect(pn.cache).toBe(null);
-
-		// Real input → LLM call → DATA emit.
-		dep.down([[DATA, "hello"]]);
-		await tick();
-		expect(seen[seen.length - 1]).toBe("ok");
-		expect(pn.cache).toBe("ok");
-
-		// Mid-flow drop back to null → emit `null` again.
-		dep.down([[DATA, null]]);
-		await tick();
-		expect(seen[seen.length - 1]).toBe(null);
-		expect(pn.cache).toBe(null);
-
-		unsub();
-	});
-
-	it("strips markdown fences for JSON format", async () => {
-		const adapter: LLMAdapter = {
-			provider: "mock",
-			invoke() {
-				return {
-					content: '```json\n{"key": "value"}\n```',
-					finishReason: "end_turn",
-					usage: { input: { regular: 0 }, output: { regular: 0 } },
-				};
-			},
-			async *stream() {
-				yield { type: "token" as const, delta: "" };
-				yield { type: "usage" as const, usage: { input: { regular: 0 }, output: { regular: 0 } } };
-				yield { type: "finish" as const, reason: "stop" };
-			},
-		};
-
-		const dep = node([], { initial: "x" });
-		const pn = promptNode<{ key: string }>(adapter, [dep], "extract", { format: "json" });
-		const unsub = pn.subscribe(() => {});
-		await tick();
-		expect(pn.cache).toEqual({ key: "value" });
-		unsub();
-	});
-
-	it("passes systemPrompt in invoke opts", async () => {
-		let receivedOpts: Record<string, unknown> = {};
-		const adapter: LLMAdapter = {
-			provider: "mock",
-			invoke(_messages, opts) {
-				receivedOpts = opts as Record<string, unknown>;
-				return {
-					content: "ok",
-					finishReason: "end_turn",
-					usage: { input: { regular: 0 }, output: { regular: 0 } },
-				};
-			},
-			async *stream() {
-				yield { type: "token" as const, delta: "" };
-				yield { type: "usage" as const, usage: { input: { regular: 0 }, output: { regular: 0 } } };
-				yield { type: "finish" as const, reason: "stop" };
-			},
-		};
-
-		const dep = node([], { initial: "x" });
-		const pn = promptNode<string>(adapter, [dep], "test", { systemPrompt: "be helpful" });
-		const unsub = pn.subscribe(() => {});
-		await tick();
-		expect(pn.cache).toBe("ok");
-		expect(receivedOpts.systemPrompt).toBe("be helpful");
-		unsub();
-	});
-
-	// DF12 (Tier 7): reactive `tools` is a declared dep on `messagesNode`,
-	// so tools changes re-invoke the LLM and the tools edge appears in
-	// `describe()` / `explain()`.
-	it("reactive tools: tools Node feeds the adapter and re-invokes on tools change", async () => {
-		const calls: Array<{ tools?: readonly ToolDefinition[] }> = [];
-		const adapter: LLMAdapter = {
-			provider: "mock",
-			invoke(_messages, opts) {
-				calls.push({ tools: opts?.tools });
-				return {
-					content: "ok",
-					finishReason: "end_turn",
-					usage: { input: { regular: 0 }, output: { regular: 0 } },
-				};
-			},
-			async *stream() {
-				yield { type: "token" as const, delta: "" };
-				yield { type: "usage" as const, usage: { input: { regular: 0 }, output: { regular: 0 } } };
-				yield { type: "finish" as const, reason: "stop" };
-			},
-		};
-
-		const toolA: ToolDefinition = {
-			name: "a",
-			description: "",
-			parameters: {},
-			handler: () => null,
-		};
-		const toolB: ToolDefinition = {
-			name: "b",
-			description: "",
-			parameters: {},
-			handler: () => null,
-		};
-
-		const dep = node([], { initial: "hello" });
-		const toolsNode = node<readonly ToolDefinition[]>([], { initial: [toolA] });
-		const pn = promptNode<string>(adapter, [dep], "echo", {
-			format: "raw",
-			tools: toolsNode,
-		});
-		const unsub = pn.subscribe(() => {});
-		await tick();
-
-		// First call: toolsNode primed [toolA] before subscribe → first wave
-		// fires with tools=[toolA].
-		expect(calls.length).toBeGreaterThanOrEqual(1);
-		expect(calls.at(-1)?.tools).toEqual([toolA]);
-
-		// Update tools — adapter is re-invoked because tools is a declared dep.
-		toolsNode.emit([toolA, toolB]);
-		await tick();
-		expect(calls.at(-1)?.tools).toEqual([toolA, toolB]);
-
-		unsub();
-	});
-});
diff --git a/src/__tests__/utils/ai/phase5-llm-composition.test.ts b/src/__tests__/utils/ai/phase5-llm-composition.test.ts
deleted file mode 100644
index 9b3e6c4f..00000000
--- a/src/__tests__/utils/ai/phase5-llm-composition.test.ts
+++ /dev/null
@@ -1,733 +0,0 @@
-/**
- * Phase 5: LLM composition validation.
- *
- * These compositions were written one-shot by an LLM (Claude) given only:
- * - GRAPHREFLY-SPEC.md (protocol behavior)
- * - COMPOSITION-GUIDE.md (patterns and recipes)
- * - Existing test examples for API signature reference
- *
- * Each scenario exercises a non-trivial composition pattern that an LLM agent
- * or human developer would need in practice. The test validates that:
- * 1. The composition compiles and runs correctly
- * 2. The push model is reasoned about naturally
- * 3. Surprising patterns or guide gaps are documented
- */
-
-import { batch, DATA, DIRTY, node } from "@graphrefly/pure-ts/core";
-import { merge, scan, withLatestFrom } from "@graphrefly/pure-ts/extra";
-import { Graph } from "@graphrefly/pure-ts/graph";
-import { describe, expect, it } from "vitest";
-import {
-	chatStream,
-	gaugesAsContext,
-	knobsAsTools,
-	type LLMAdapter,
-	type LLMResponse,
-	promptNode,
-	systemPromptBuilder,
-	type ToolDefinition,
-	toolRegistry,
-} from "../../../utils/ai/index.js";
-import { pipelineGraph } from "../../../utils/orchestration/index.js";
-
-// ---------------------------------------------------------------------------
-// Mock adapter
-// ---------------------------------------------------------------------------
-
-function mockAdapter(responses: LLMResponse[]): LLMAdapter {
-	let idx = 0;
-	return {
-		invoke() {
-			const resp = responses[idx] ?? responses[responses.length - 1]!;
-			idx++;
-			return resp;
-		},
-		async *stream() {
-			yield "mock";
-		},
-	};
-}
-
-// ===========================================================================
-// Scenario 1: Multi-stage document processing pipeline
-//
-// Composition insight: This tests the push model's cascading behavior —
-// setting the input state triggers the entire pipeline reactively.
-// No polling, no imperative "run next step" calls.
-// ===========================================================================
-
-describe("Phase 5 — Scenario 1: Multi-stage document processing", () => {
-	it("pipeline processes a document through classify → extract → validate → output", () => {
-		const g = pipelineGraph("doc-processor");
-
-		// Stage 1: Input source (human submits a document)
-		const input = node<{ text: string; source: string } | undefined>([], { initial: undefined });
-		g.add(input, { name: "input" });
-
-		// Stage 2: Classify document type (derived from input)
-		// KEY INSIGHT: Null guard needed (composition guide §3) because input
-		// starts with SENTINEL → task dep value is undefined on activation.
-		const _classify = g.task<string>(
-			"classify",
-			([doc]) => {
-				const d = doc as { text: string } | undefined;
-				if (d == null) return "pending";
-				if (d.text.includes("invoice")) return "invoice";
-				if (d.text.includes("contract")) return "contract";
-				return "unknown";
-			},
-			{ deps: ["input"] },
-		);
-
-		// Stage 3: Extract entities based on classification
-		const _extract = g.task<string[]>(
-			"extract",
-			([doc]) => {
-				const d = doc as { text: string } | undefined;
-				if (d == null) return [];
-				const amounts = d.text.match(/\$[\d,]+\.?\d*/g) ?? [];
-				return amounts;
-			},
-			{ deps: ["input"] },
-		);
-
-		// Stage 4: Combine classification + extraction for validation
-		const _validated = g.combine("validated", { classify: "classify", extract: "extract" });
-
-		// Stage 5: Output effect — use core `effect` + `graph.add` (post-A/B cleanup
-		// the old patterns/orchestration.forEach graph-registering sugar is gone).
-		const results: Array<{ type: string; entities: string[] }> = [];
-		const output = node(
-			[g.resolve("validated")],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				return (
-					(([val]) => {
-						const rec = val as { classify: string; extract: string[] };
-						results.push({ type: rec.classify, entities: rec.extract });
-					})(data, actions, ctx) ?? undefined
-				);
-			},
-			{ describeKind: "effect" },
-		);
-		g.add(output, { name: "output" });
-
-		// KEY INSIGHT: Every leaf node needs a subscriber to activate the
-		// chain (composition guide §5). Without this, the derived pipeline
-		// stays disconnected. This is the push model: subscribe = activate.
-		output.subscribe(() => {});
-
-		// Push model: setting input cascades through the entire pipeline
-		input.emit({ text: "Please pay this invoice for $500.00 and $1,200", source: "email" });
-
-		expect(g.node("classify").cache).toBe("invoice");
-		expect(g.node("extract").cache).toEqual(["$500.00", "$1,200"]);
-
-		// KEY INSIGHT: With null guards returning initial values ("pending", []),
-		// the combine node produces intermediate emissions as each dep settles.
-		// The FINAL result has the correct values. In a real system, you'd
-		// filter out the intermediate "pending" values, or use SENTINEL deps
-		// (no initial) so the pipeline only fires when ALL inputs are ready.
-		const final = results[results.length - 1]!;
-		expect(final.type).toBe("invoice");
-		expect(final.entities).toEqual(["$500.00", "$1,200"]);
-	});
-});
-
-// ===========================================================================
-// Scenario 2: Approval-gated deployment with timeout fallback
-//
-// Composition insight: gate + approval compose naturally because they're
-// just nodes. The "waiting for human" state is a reactive dependency,
-// not a polling loop. Push model means the gate opens the moment
-// the approver sets the state.
-// ===========================================================================
-
-describe("Phase 5 — Scenario 2: Approval-gated deployment", () => {
-	it("gates deployment behind approval, with fallback on rejection", () => {
-		const g = pipelineGraph("deploy");
-
-		// Build artifact
-		const artifact = node([], { initial: { version: "1.2.0", sha: "abc123" } });
-		g.add(artifact, { name: "artifact" });
-
-		// Human approval control
-		const isApproved = node([], { initial: false });
-		g.add(isApproved, { name: "approved" });
-
-		// Gate: holds artifact until approved
-		const reviewCtrl = g.approval<{ version: string; sha: string }>(
-			"review",
-			"artifact",
-			isApproved,
-		);
-		const gated = reviewCtrl.output;
-
-		// On approval: deploy
-		const deployed: string[] = [];
-		const deployNode = node<void>(
-			[gated],
-			(data, _actions, ctx) => {
-				const batch0 = data[0];
-				const a = (batch0 != null && batch0.length > 0 ? batch0.at(-1) : ctx.prevData[0]) as {
-					version: string;
-					sha: string;
-				};
-				if (a != null) deployed.push(a.version);
-			},
-			{ name: "deploy" },
-		);
-		g.add(deployNode, { name: "deploy" });
-		deployNode.subscribe(() => {});
-
-		// Initially: nothing deployed (approval is false)
-		expect(deployed.filter((v) => v === "1.2.0").length).toBe(0);
-
-		// Human approves — push model: value flows immediately
-		isApproved.down([[DATA, true]]);
-		expect(deployed).toContain("1.2.0");
-	});
-});
-
-// ===========================================================================
-// Scenario 3: Real-time metrics dashboard with derived aggregations
-//
-// Composition insight: combine + derived gives declarative aggregation.
-// The LLM naturally thinks "I need to combine these sources and derive
-// metrics" — the push model matches how dashboards actually work.
-// ===========================================================================
-
-describe("Phase 5 — Scenario 3: Real-time metrics aggregation", () => {
-	it("aggregates multiple metric sources into a derived dashboard state", () => {
-		// Source metrics (simulating live feeds)
-		const cpuLoad = node([], { initial: 0.45 });
-		const memUsage = node([], { initial: 0.62 });
-		const reqPerSec = node([], { initial: 150 });
-		const errorRate = node([], { initial: 0.02 });
-
-		// Derived: health score (weighted aggregate)
-		const healthScore = node(
-			[cpuLoad, memUsage, errorRate],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				const c = data[0] as number;
-				const m = data[1] as number;
-				const e = data[2] as number;
-				// Lower is worse: 1.0 = perfect health
-				actions.emit(Math.max(0, 1 - (c * 0.3 + m * 0.3 + e * 10 * 0.4)));
-			},
-			{ describeKind: "derived" },
-		);
-
-		// Derived: alert level
-		const alertLevel = node(
-			[healthScore],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				const s = data[0] as number;
-				if (s > 0.8) {
-					actions.emit("green");
-					return;
-				}
-				if (s > 0.5) {
-					actions.emit("yellow");
-					return;
-				}
-				actions.emit("red");
-			},
-			{ describeKind: "derived" },
-		);
-
-		// Derived: capacity forecast (combine throughput + resource usage)
-		const capacityForecast = node(
-			[reqPerSec, cpuLoad, memUsage],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				const r = data[0] as number;
-				const c = data[1] as number;
-				const m = data[2] as number;
-				const headroom = Math.min(1 - c, 1 - m);
-				actions.emit(Math.round(r / (1 - headroom + 0.001))); // projected max RPS
-			},
-			{ describeKind: "derived" },
-		);
-
-		// Activate all derived nodes (composition guide §5: subscribe to activate)
-		healthScore.subscribe(() => {});
-		alertLevel.subscribe(() => {});
-		capacityForecast.subscribe(() => {});
-
-		// Initial state
-		expect(alertLevel.cache).toBe("yellow");
-		expect(typeof healthScore.cache).toBe("number");
-		expect(typeof capacityForecast.cache).toBe("number");
-
-		// Metric spike — push model: all derived recompute instantly
-		batch(() => {
-			cpuLoad.down([[DATA, 0.95]]);
-			errorRate.down([[DATA, 0.15]]);
-		});
-
-		expect(alertLevel.cache).toBe("red");
-	});
-});
-
-// ===========================================================================
-// Scenario 4: LLM agent with tool use and memory accumulation
-//
-// Composition insight: This is where the push model truly shines for LLM
-// agents. The agent loop is reactive: new user message → promptNode fires
-// → tool calls detected → tools execute → results feed back in.
-// No imperative "while (hasToolCalls)" loop needed.
-// ===========================================================================
-
-describe("Phase 5 — Scenario 4: LLM agent with tool use", () => {
-	it("promptNode composes with tool registry and chat stream", () => {
-		const cs = chatStream("agent-chat");
-
-		// Tool registry with a simple calculator
-		const tr = toolRegistry("agent-tools");
-		tr.register({
-			name: "add",
-			description: "Add two numbers",
-			parameters: { type: "object", properties: { a: { type: "number" }, b: { type: "number" } } },
-			handler: (args) => (args.a as number) + (args.b as number),
-		});
-
-		// Verify composition: chatStream provides the message history,
-		// toolRegistry provides the tool definitions
-		cs.append("user", "What is 2 + 3?");
-		const msgs = cs.allMessages();
-		expect(msgs.length).toBe(1);
-
-		const schemas = tr.schemas.cache as ToolDefinition[];
-		expect(schemas.length).toBe(1);
-		expect(schemas[0]!.name).toBe("add");
-	});
-
-	it("promptNode gates on nullish deps (composition guide §8)", () => {
-		// SENTINEL dep — promptNode should NOT fire
-		const pendingInput = node<string>();
-		const adapter = mockAdapter([{ content: "should not reach" }]);
-
-		const result = promptNode(adapter, [pendingInput], (val) => {
-			return `Process: ${val}`;
-		});
-		result.subscribe(() => {});
-
-		// Composition guide §8 + per the QA-revised SENTINEL contract: on
-		// **initial** no-input, promptNode emits nothing (true SENTINEL —
-		// `cache` stays `undefined`). `null` is reserved for **mid-flow**
-		// drop-out (input that was previously real then went away), so
-		// downstream consumers can distinguish "haven't started" from
-		// "input gone."
-		expect(result.cache).toBe(undefined);
-
-		// Once pendingInput delivers DATA, the LLM adapter runs (async
-		// through the internal switchMap + Promise path). The
-		// `.not.toBe(null)` check is inherently racy for sync tests — the
-		// important invariant is that the chain exits the SENTINEL branch,
-		// which we verify by checking status.
-		pendingInput.down([[DATA, "hello"]]);
-		expect(result.status).not.toBe("pending");
-	});
-
-	it("prompt_node::response is transient — describe() does not surface it (Session C L9)", () => {
-		// Session C L9 acceptance: when no LLM call is in flight, describe()
-		// only shows ::messages + ::output. The per-wave producer (`::response`)
-		// activates inside switchMap during a wave and tears down on supersede
-		// or COMPLETE — it is intentionally transient.
-		//
-		// With a sync mockAdapter the producer activates and completes within
-		// the same synchronous wave, so any post-wave describe() never sees it.
-		// With a real (async) adapter, describe() called mid-wave WOULD see
-		// it via meta.ai = "prompt_node::response" — but that's an in-flight
-		// observation, not a steady-state expectation.
-		const adapter = mockAdapter([{ content: "ok" }]);
-		const input = node<string>();
-		const result = promptNode<string>(adapter, [input], (q) => `q: ${q}`);
-
-		const g = new Graph("g");
-		g.add(result, { name: "answer" });
-		// Force activation so the topology graph walks reach into promptNode internals.
-		const off = result.subscribe(() => {});
-		input.down([[DATA, "first"]]);
-
-		const snap = g.describe();
-		const paths = Object.keys(snap.nodes);
-
-		// `::messages` and `::output` are the steady-state shape.
-		expect(paths.some((p) => p.endsWith("prompt_node::messages"))).toBe(true);
-		expect(paths.some((p) => p === "answer" || p.endsWith("prompt_node::output"))).toBe(true);
-
-		// `::response` is per-wave; with a synchronous adapter it has already
-		// torn down by the time we describe.
-		expect(paths.some((p) => p.endsWith("prompt_node::response"))).toBe(false);
-
-		off();
-	});
-
-	it("promptNode emits exactly one DATA per upstream wave (Session C L8)", () => {
-		// Session C L8 acceptance gate: N upstream dep waves → exactly N DATAs
-		// on prompt_node::output, zero transient nulls, zero coalesce loss.
-		// Locks the path-(b) producer contract independent of harness entanglement
-		// (cf. archive/docs/SESSION-ai-harness-module-review.md line 3654).
-		const adapter = mockAdapter([
-			{ content: "response 1" },
-			{ content: "response 2" },
-			{ content: "response 3" },
-		]);
-		const input = node<string>(); // SENTINEL — no initial-no-input null leak
-		const result = promptNode<string>(adapter, [input], (q) => `q: ${q}`);
-
-		const dataValues: unknown[] = [];
-		result.subscribe((b) => {
-			for (const msg of b) {
-				if (msg[0] === DATA) dataValues.push(msg[1]);
-			}
-		});
-
-		// Wave 0 — SENTINEL: messagesNode's first-run gate blocks; switchMap
-		// never fires; outer cache stays undefined; subscriber sees nothing.
-		expect(dataValues).toEqual([]);
-
-		// Wave 1 → exactly 1 DATA.
-		input.down([[DATA, "first"]]);
-		expect(dataValues).toEqual(["response 1"]);
-
-		// Wave 2 → exactly 2 DATAs total (no transient null between waves).
-		input.down([[DATA, "second"]]);
-		expect(dataValues).toEqual(["response 1", "response 2"]);
-
-		// Wave 3 → exactly 3 DATAs total.
-		input.down([[DATA, "third"]]);
-		expect(dataValues).toEqual(["response 1", "response 2", "response 3"]);
-
-		// No transient nulls anywhere in the stream — the producer-shape inner
-		// emits parsed values via actions.emit only (never null pre-resolution).
-		expect(dataValues.filter((v) => v == null)).toEqual([]);
-	});
-});
-
-// ===========================================================================
-// Scenario 5: Event-sourced order processing with CQRS-style projections
-//
-// Composition insight: reactiveLog as event store + derived nodes as
-// projections. The push model means projections update reactively as
-// events arrive — classic CQRS but without the imperative event bus.
-// ===========================================================================
-
-describe("Phase 5 — Scenario 5: Event-sourced order processing", () => {
-	it("scan builds projections from an event stream", () => {
-		// Event source (orders coming in)
-		const orderEvent = node<{ type: string; orderId: string; amount?: number } | null>([], {
-			initial: null,
-		});
-
-		// Projection: running total revenue
-		const totalRevenue = scan(
-			orderEvent,
-			(acc, event) => {
-				const e = event as { type: string; amount?: number } | null;
-				if (e == null || e.type !== "completed") return acc;
-				return acc + (e.amount ?? 0);
-			},
-			0,
-		);
-
-		// Projection: order count by status
-		const orderCounts = scan(
-			orderEvent,
-			(acc, event) => {
-				const e = event as { type: string } | null;
-				if (e == null) return acc;
-				const counts = { ...acc };
-				counts[e.type] = (counts[e.type] ?? 0) + 1;
-				return counts;
-			},
-			{} as Record<string, number>,
-		);
-
-		// Activate projections
-		totalRevenue.subscribe(() => {});
-		orderCounts.subscribe(() => {});
-
-		// Emit events
-		orderEvent.down([[DATA, { type: "created", orderId: "A1" }]]);
-		orderEvent.down([[DATA, { type: "completed", orderId: "A1", amount: 99.99 }]]);
-		orderEvent.down([[DATA, { type: "created", orderId: "A2" }]]);
-		orderEvent.down([[DATA, { type: "completed", orderId: "A2", amount: 50.0 }]]);
-		orderEvent.down([[DATA, { type: "cancelled", orderId: "A3" }]]);
-
-		expect(totalRevenue.cache).toBeCloseTo(149.99);
-		expect(orderCounts.cache).toEqual({
-			created: 2,
-			completed: 2,
-			cancelled: 1,
-		});
-	});
-});
-
-// ===========================================================================
-// Scenario 6: Adaptive rate-limited API client with circuit breaker
-//
-// Composition insight: withLatestFrom is the key pattern for reading
-// config without creating reactive triggers (composition guide §7).
-// The circuit breaker state is advisory — it doesn't trigger new
-// requests, but is consulted when a request arrives.
-// ===========================================================================
-
-describe("Phase 5 — Scenario 6: Adaptive API client with config", () => {
-	it("withLatestFrom reads config without triggering on config changes", () => {
-		const request = node<string | null>([], { initial: null });
-		const config = node([], { initial: { maxRetries: 3, timeout: 5000 } });
-
-		// withLatestFrom: request triggers, config is sampled
-		const enriched = withLatestFrom(request, config);
-		enriched.subscribe(() => {});
-
-		// Config change alone should not produce a new emission
-		// (withLatestFrom only triggers on primary)
-		const emissions: unknown[] = [];
-		enriched.subscribe((msgs) => {
-			for (const m of msgs) {
-				if (m[0] === DATA) emissions.push(m[1]);
-			}
-		});
-
-		const before = emissions.length;
-		config.down([[DATA, { maxRetries: 5, timeout: 10000 }]]);
-		// No new emission from config change alone
-		expect(emissions.length).toBe(before);
-
-		// Request triggers with latest config
-		request.down([[DATA, "GET /api/users"]]);
-		const latest = emissions[emissions.length - 1] as [string | null, { maxRetries: number }];
-		expect(latest[0]).toBe("GET /api/users");
-		expect(latest[1].maxRetries).toBe(5); // picked up latest config
-	});
-});
-
-// ===========================================================================
-// Scenario 7: Graph introspection for LLM self-awareness
-//
-// Composition insight: describe() + gaugesAsContext is how an LLM reads
-// the graph it's operating within. knobsAsTools is how it writes back.
-// This is the "LLM as graph operator" pattern — the graph is both the
-// execution substrate and the LLM's interface to the system.
-// ===========================================================================
-
-describe("Phase 5 — Scenario 7: LLM graph self-awareness via describe + gauges", () => {
-	it("graph exposes knobs and gauges for LLM consumption", () => {
-		const g = new Graph("system");
-
-		// Knobs: LLM-writable configuration
-		const retryLimit = node([], {
-			name: "retry_limit",
-			meta: {
-				description: "Maximum retry attempts",
-				type: "integer",
-				range: [1, 10],
-				access: "both",
-			},
-			initial: 3,
-		});
-		const model = node([], {
-			name: "model",
-			meta: {
-				description: "LLM model to use",
-				type: "enum",
-				values: ["gpt-4", "claude-3"],
-				access: "both",
-			},
-			initial: "gpt-4",
-		});
-		g.add(retryLimit, { name: "retry_limit" });
-		g.add(model, { name: "model" });
-
-		// Gauges: read-only metrics
-		const successRate = node([], {
-			name: "success_rate",
-			meta: { description: "Current success rate", format: "percentage", access: "system" },
-			initial: 0.95,
-		});
-		g.add(successRate, { name: "success_rate" });
-
-		// LLM reads the graph
-		const desc = g.describe({ detail: "standard" });
-		expect(desc.nodes).toHaveProperty("retry_limit");
-		expect(desc.nodes).toHaveProperty("model");
-		expect(desc.nodes).toHaveProperty("success_rate");
-
-		// gaugesAsContext produces text the LLM can reason about
-		const context = gaugesAsContext(g);
-		expect(typeof context).toBe("string");
-
-		// knobsAsTools produces tool definitions the LLM can call
-		const tools = knobsAsTools(g);
-		expect(tools.definitions.length).toBeGreaterThanOrEqual(2);
-
-		// Verify tool names include our knobs
-		const toolNames = tools.definitions.map((t) => t.name);
-		expect(toolNames).toContain("retry_limit");
-		expect(toolNames).toContain("model");
-	});
-});
-
-// ===========================================================================
-// Scenario 8: Multi-source merge with error isolation
-//
-// Composition insight: merge + onFailure compose to build resilient
-// multi-source ingestion. Each source fails independently — the push
-// model means a failure in one source doesn't block others.
-// ===========================================================================
-
-describe("Phase 5 — Scenario 8: Multi-source merge with error isolation", () => {
-	it("merge combines multiple sources, catch isolates errors", () => {
-		const g = pipelineGraph("ingest");
-
-		// Three data sources
-		const source1 = node<number>([], { initial: 10 });
-		const source2 = node<number>([], { initial: 20 });
-		const source3 = node<number>([], { initial: 30 });
-		g.add(source1, { name: "s1" });
-		g.add(source2, { name: "s2" });
-		g.add(source3, { name: "s3" });
-
-		// Merge all sources
-		const merged = merge(source1, source2, source3);
-		g.add(merged, { name: "merged" });
-
-		// Collect values
-		const values: number[] = [];
-		merged.subscribe((msgs) => {
-			for (const m of msgs) {
-				if (m[0] === DATA) values.push(m[1] as number);
-			}
-		});
-
-		// Push model: initial values from all three sources arrive
-		expect(values).toContain(10);
-		expect(values).toContain(20);
-		expect(values).toContain(30);
-
-		// Update one source — only that value flows
-		const _countBefore = values.length;
-		source1.down([[DATA, 100]]);
-		expect(values[values.length - 1]).toBe(100);
-	});
-});
-
-// ===========================================================================
-// Scenario 9: Dynamic system prompt with reactive sections
-//
-// Composition insight: systemPromptBuilder accepts both static strings
-// and reactive Node<string> sections. The push model means the prompt
-// updates automatically when any section changes — the LLM always
-// gets the latest context without manual prompt management.
-// ===========================================================================
-
-describe("Phase 5 — Scenario 9: Dynamic system prompt composition", () => {
-	it("systemPromptBuilder reacts to section changes", () => {
-		const role = node([], { initial: "You are a helpful coding assistant." });
-		const rules = node([], { initial: "Always explain your reasoning." });
-		const context = node([], { initial: "The user is working on a TypeScript project." });
-
-		const prompt = systemPromptBuilder([role, rules, context]);
-
-		expect(prompt.cache).toContain("coding assistant");
-		expect(prompt.cache).toContain("explain your reasoning");
-		expect(prompt.cache).toContain("TypeScript project");
-
-		// Context changes reactively
-		context.down([[DATA, "The user is working on a Python project."]]);
-		expect(prompt.cache).toContain("Python project");
-		expect(prompt.cache).not.toContain("TypeScript project");
-	});
-});
-
-// ===========================================================================
-// Scenario 10: Diamond dependency — glitch-free derived computation
-//
-// Composition insight: The two-phase DIRTY/DATA protocol ensures D
-// computes exactly once when both B and C have settled. This is the
-// core advantage of the push model — glitch-free by construction,
-// not by accident.
-// ===========================================================================
-
-describe("Phase 5 — Scenario 10: Diamond dependency glitch-free guarantee", () => {
-	it("D computes exactly once when A changes (diamond: A→B,C→D)", () => {
-		//     A
-		//    / \
-		//   B   C
-		//    \ /
-		//     D
-		const a = node([], { initial: 1 });
-		const b = node(
-			[a],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as number) * 2);
-			},
-			{ describeKind: "derived" },
-		);
-		const c = node(
-			[a],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as number) + 10);
-			},
-			{ describeKind: "derived" },
-		);
-
-		let computeCount = 0;
-		const d = node(
-			[b, c],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				computeCount++;
-				actions.emit(`${data[0]}+${data[1]}`);
-			},
-			{ describeKind: "derived" },
-		);
-
-		d.subscribe(() => {});
-
-		// Connection-time diamond guarantee (spec §2.7): _connectUpstream defers
-		// settlement until all deps are subscribed, so fn runs exactly once
-		// with all deps settled — not once per dep.
-		expect(computeCount).toBe(1);
-		expect(d.cache).toBe("2+11");
-
-		// KEY INSIGHT #2 (composition guide addition candidate):
-		// Even for subsequent updates, glitch-free diamond resolution
-		// requires the TWO-PHASE protocol: DIRTY first, then DATA.
-		// Plain `down([[DATA, v]])` skips DIRTY, so each dep recomputes
-		// independently. Use `batch(() => { down([[DIRTY]]); down([[DATA]]); })`
-		// or let the framework handle it (derived nodes auto-emit two-phase).
-		//
-		// The existing diamond tests confirm this — they all use batch()
-		// with explicit DIRTY/DATA.
-		computeCount = 0;
-		batch(() => {
-			a.down([[DIRTY]]);
-			a.down([[DATA, 5]]);
-		});
-		expect(computeCount).toBe(1);
-		expect(d.cache).toBe("10+15");
-	});
-});
diff --git a/src/__tests__/utils/ai/test-helpers.ts b/src/__tests__/utils/ai/test-helpers.ts
deleted file mode 100644
index 0725b8bd..00000000
--- a/src/__tests__/utils/ai/test-helpers.ts
+++ /dev/null
@@ -1,22 +0,0 @@
-/**
- * Shared test utilities for AI adapter tests.
- */
-import { START } from "@graphrefly/pure-ts/core";
-
-type Subscribable = { subscribe: (fn: (m: unknown) => void) => () => void };
-
-type CollectFlatResult = {
-	messages: [symbol, unknown?][];
-	msgs: [symbol, unknown?][];
-	unsub: () => void;
-};
-
-export function collectFlat(node: Subscribable): CollectFlatResult {
-	const messages: [symbol, unknown?][] = [];
-	const unsub = node.subscribe((m) => {
-		for (const msg of m as [symbol, unknown?][]) {
-			if (msg[0] !== START) messages.push(msg);
-		}
-	});
-	return { messages, msgs: messages, unsub };
-}
diff --git a/src/__tests__/utils/ai/tool-interceptor.test.ts b/src/__tests__/utils/ai/tool-interceptor.test.ts
deleted file mode 100644
index 516ee566..00000000
--- a/src/__tests__/utils/ai/tool-interceptor.test.ts
+++ /dev/null
@@ -1,203 +0,0 @@
-import { DATA, type Node, node } from "@graphrefly/pure-ts/core";
-import { describe, expect, it } from "vitest";
-import { agentLoop } from "../../../presets/ai/agent-loop.js";
-import type { LLMAdapter, LLMResponse, ToolCall, ToolDefinition } from "../../../utils/ai/index.js";
-import { toolInterceptor } from "../../../utils/ai/index.js";
-
-// Dedicated file (NOT folded into ai.test.ts): activation of a SENTINEL dep
-// through the core first-run gate is sensitive to cross-test module state
-// (ai.test.ts's 100+ tests share one module instance). A clean per-file scope
-// keeps these assertions deterministic. The never-emitted-predicate outcome
-// itself is deliberately NOT asserted — see the NOTE below + optimizations.md.
-
-/** Minimal sequential mock adapter (mirrors ai.test.ts `mockAdapter`). */
-function mockAdapter(responses: LLMResponse[]): LLMAdapter {
-	let idx = 0;
-	return {
-		invoke() {
-			const resp = responses[idx] ?? responses[responses.length - 1]!;
-			idx++;
-			return resp;
-		},
-		async *stream() {
-			yield { type: "usage" as const, usage: { input: { regular: 0 }, output: { regular: 0 } } };
-			yield { type: "finish" as const, reason: "stop" };
-		},
-	};
-}
-
-describe("toolInterceptor (Phase 14.5.2)", () => {
-	const tc = (name: string): ToolCall => ({ id: `id-${name}`, name, arguments: {} });
-
-	/** Subscribe and capture every DATA batch as tool-name arrays. */
-	function capture(n: Node<readonly ToolCall[]>): { seen: string[][]; stop: () => void } {
-		const seen: string[][] = [];
-		const sub = n.subscribe((msgs) => {
-			for (const m of msgs) {
-				if (m[0] === DATA) seen.push((m[1] as readonly ToolCall[]).map((c) => c.name));
-			}
-		});
-		return { seen, stop: sub };
-	}
-
-	it("allow predicate filters denied calls; reactive policy re-opens", () => {
-		const calls = node<readonly ToolCall[]>([], {
-			name: "calls",
-			initial: [tc("read"), tc("delete")],
-		});
-		const policy = node<boolean>([], { name: "destructive-allowed", initial: false });
-		const gated = toolInterceptor({
-			allow: [
-				node(
-					[policy],
-					(b, a, c) => {
-						const d = b.map((x, i) => (x != null && x.length > 0 ? x.at(-1) : c.prevData[i]));
-						a.emit((call: ToolCall) => call.name !== "delete" || d[0] === true);
-					},
-					{ describeKind: "derived" },
-				),
-			],
-		})(calls);
-		const { seen, stop } = capture(gated);
-		// Initial: destructive "delete" filtered out.
-		expect(seen).toEqual([["read"]]);
-		// Opening the policy ALONE must NOT re-emit the in-flight batch
-		// (no buffer-and-replay) — `seen` is unchanged until a fresh
-		// `calls` wave arrives.
-		policy.emit(true);
-		expect(seen).toEqual([["read"]]);
-		// Fresh `calls` wave now re-filters under the opened policy.
-		calls.emit([tc("read"), tc("delete")]);
-		expect(seen).toEqual([["read"], ["read", "delete"]]);
-		stop();
-	});
-
-	it("null predicate value = pass-through (emitted null is not deny)", () => {
-		const calls = node<readonly ToolCall[]>([], {
-			name: "calls",
-			initial: [tc("a"), tc("b")],
-		});
-		// Predicate emits an explicit `null` DATA value (`null` is valid DATA;
-		// `undefined` would be the SENTINEL) — the author's "not-ready, allow".
-		const pending = node<(c: ToolCall) => boolean>([], {
-			name: "pending-pred",
-			initial: null as unknown as (c: ToolCall) => boolean,
-		});
-		const gated = toolInterceptor({ allow: [pending] })(calls);
-		const { seen, stop } = capture(gated);
-		expect(seen).toEqual([["a", "b"]]);
-		stop();
-	});
-
-	// NOTE: a predicate node that has NEVER emitted DATA (pure SENTINEL, no
-	// `initial`) has *unspecified* gating — the core first-run-gate outcome
-	// for a SENTINEL dep depends on activation ordering (it holds the turn in
-	// a clean scope but can pass through after prior subscriptions in the same
-	// module). The primitive's contract is therefore "always seed
-	// enabled/predicate with an `initial`" (see JSDoc), and we deliberately do
-	// NOT assert the never-emitted activation outcome here — that would be a
-	// brittle test of core activation, not of `toolInterceptor`. The seeded
-	// pass-through path is covered by "null predicate value = pass-through"
-	// above; the core observation is logged in docs/optimizations.md.
-
-	it("full-deny → RESOLVED (no DATA), and the gate is not stuck afterward", () => {
-		const calls = node<readonly ToolCall[]>([], { name: "calls", initial: [tc("forbid")] });
-		const allow = node<(c: ToolCall) => boolean>([], {
-			name: "deny-forbid",
-			initial: (c: ToolCall) => c.name !== "forbid",
-		});
-		const gated = toolInterceptor({ allow: [allow] })(calls);
-		const { seen, stop } = capture(gated);
-		// Every call denied → RESOLVED, zero DATA emissions.
-		expect(seen).toEqual([]);
-		// RESOLVED is a clean no-op, not a terminal lock: a later allowed
-		// batch still flows.
-		calls.emit([tc("read")]);
-		expect(seen).toEqual([["read"]]);
-		stop();
-	});
-
-	it("throwing predicate fails CLOSED — denies that call, no terminal ERROR", () => {
-		const calls = node<readonly ToolCall[]>([], {
-			name: "calls",
-			initial: [tc("safe"), tc("boom")],
-		});
-		const allow = node<(c: ToolCall) => boolean>([], {
-			name: "throwing-pred",
-			initial: (c: ToolCall) => {
-				if (c.name === "boom") throw new Error("policy bug");
-				return true;
-			},
-		});
-		const gated = toolInterceptor({ allow: [allow] })(calls);
-		const { seen, stop } = capture(gated);
-		// "boom" denied (predicate threw → fail-closed); "safe" still flows;
-		// the stream did NOT go terminal.
-		expect(seen).toEqual([["safe"]]);
-		calls.emit([tc("safe")]);
-		expect(seen).toEqual([["safe"], ["safe"]]);
-		stop();
-	});
-
-	it("kill-switch enabled:false denies all → RESOLVED; re-enable resumes (no replay)", () => {
-		const calls = node<readonly ToolCall[]>([], { name: "calls", initial: [tc("a")] });
-		const killSwitch = node<boolean>([], { name: "tools-enabled", initial: false });
-		const gated = toolInterceptor({ enabled: killSwitch })(calls);
-		const { seen, stop } = capture(gated);
-		expect(seen).toEqual([]); // switch off → all denied
-		// Flipping the switch ON with NO new `calls` must NOT replay the
-		// stale denied batch (the confused-deputy hole D1 closed).
-		killSwitch.emit(true);
-		expect(seen).toEqual([]);
-		// Only a fresh `calls` wave resumes flow.
-		calls.emit([tc("a")]);
-		expect(seen).toEqual([["a"]]);
-		stop();
-	});
-
-	it("agentLoop integration: partial deny keeps allowed, synthesizes denial result for forbidden", async () => {
-		const toolCallResp: LLMResponse = {
-			content: "",
-			toolCalls: [
-				{ id: "tc1", name: "allow", arguments: {} },
-				{ id: "tc2", name: "forbid", arguments: {} },
-			],
-		};
-		const finalResp: LLMResponse = { content: "done", finishReason: "end_turn" };
-		const adapter = mockAdapter([toolCallResp, finalResp]);
-		const allowTool: ToolDefinition = {
-			name: "allow",
-			description: "",
-			parameters: {},
-			handler: () => "ok",
-		};
-		const forbidTool: ToolDefinition = {
-			name: "forbid",
-			description: "",
-			parameters: {},
-			handler: () => {
-				throw new Error("should not execute");
-			},
-		};
-		const loop = agentLoop("ti-partial", {
-			adapter,
-			tools: [allowTool, forbidTool],
-			interceptToolCalls: toolInterceptor({
-				allow: [
-					node<(c: ToolCall) => boolean>([], {
-						name: "deny-forbid",
-						initial: (c: ToolCall) => c.name !== "forbid",
-					}),
-				],
-			}),
-		});
-		await loop.run("go");
-		const toolMsgs = loop.chat.allMessages().filter((m) => m.role === "tool");
-		// Post-ND-3 (DS-2.7.A /qa, 2026-05-19): every `tool_use` in the
-		// assistant message has a matching `tool_result` — allowed's real
-		// handler result + forbidden's synthetic denial.
-		expect(toolMsgs).toHaveLength(2);
-		// Public `toolCalls` surfaces the POST-intercept stream (auditable).
-		expect((loop.toolCalls.cache as readonly ToolCall[]).map((c) => c.name)).toEqual(["allow"]);
-	});
-});
diff --git a/src/__tests__/utils/cqrs/cqrs.test.ts b/src/__tests__/utils/cqrs/cqrs.test.ts
deleted file mode 100644
index 01851ffc..00000000
--- a/src/__tests__/utils/cqrs/cqrs.test.ts
+++ /dev/null
@@ -1,856 +0,0 @@
-import { GuardDenied } from "@graphrefly/pure-ts/core";
-import { memoryAppendLog, mergeReactiveLogs } from "@graphrefly/pure-ts/extra";
-import { describe, expect, it, vi } from "vitest";
-import { OptimisticConcurrencyError, UndeclaredEmitError } from "../../../utils/_errors/index.js";
-import { type CqrsEvent, CqrsGraph, cqrs } from "../../../utils/cqrs/index.js";
-
-describe("cqrs — roadmap §4.5", () => {
-	// -- Factory --------------------------------------------------------------
-
-	it("cqrs() returns a CqrsGraph", () => {
-		const app = cqrs("test");
-		expect(app).toBeInstanceOf(CqrsGraph);
-		app.destroy();
-	});
-
-	// -- Events ---------------------------------------------------------------
-
-	it("event() registers an observable event stream", () => {
-		const app = cqrs("test");
-		const evtNode = app.event("orderPlaced");
-		expect(evtNode).toBeDefined();
-		const entries = evtNode.cache as readonly unknown[];
-		expect(entries).toEqual([]);
-		app.destroy();
-	});
-
-	it("event() is idempotent — returns same node on second call", () => {
-		const app = cqrs("test");
-		const a = app.event("orderPlaced");
-		const b = app.event("orderPlaced");
-		expect(a).toBe(b);
-		app.destroy();
-	});
-
-	it("event node guard denies external write", () => {
-		const app = cqrs("test");
-		app.event("orderPlaced");
-		const evtNode = app.resolve("orderPlaced");
-		expect(() => {
-			evtNode.down([["DATA", "bad"]], { actor: { type: "human", id: "h1" } });
-		}).toThrow(GuardDenied);
-		app.destroy();
-	});
-
-	// -- Commands -------------------------------------------------------------
-
-	it("command() registers a write-only command node", () => {
-		const app = cqrs("test");
-		app.command("placeOrder", (_payload, { emit }) => {
-			emit("orderPlaced", { id: "1" });
-		});
-		const desc = app.describe({ detail: "standard" });
-		expect(desc.nodes.placeOrder).toBeDefined();
-		expect(desc.nodes.placeOrder.meta?.cqrs_type).toBe("command");
-		app.destroy();
-	});
-
-	it("command node guard denies observe", () => {
-		const app = cqrs("test");
-		app.command("placeOrder", () => {});
-		const cmdNode = app.resolve("placeOrder");
-		expect(() => {
-			cmdNode.subscribe(() => {}, { actor: { type: "human", id: "h1" } });
-		}).toThrow(GuardDenied);
-		app.destroy();
-	});
-
-	// -- Dispatch -------------------------------------------------------------
-
-	it("dispatch() runs handler and appends events", () => {
-		const app = cqrs("test");
-		app.event("orderPlaced");
-		app.command("placeOrder", (payload: any, { emit }) => {
-			emit("orderPlaced", { orderId: payload.id });
-		});
-		app.dispatch("placeOrder", { id: "order-1" });
-
-		const entries = app.event("orderPlaced").cache as readonly CqrsEvent[];
-		expect(entries).toHaveLength(1);
-		expect(entries[0].type).toBe("orderPlaced");
-		expect(entries[0].payload).toEqual({ orderId: "order-1" });
-		app.destroy();
-	});
-
-	it("dispatch() auto-registers events not explicitly declared", () => {
-		const app = cqrs("test");
-		app.command("placeOrder", (_payload: any, { emit }) => {
-			emit("orderPlaced", { id: "1" });
-		});
-		app.dispatch("placeOrder", {});
-		const desc = app.describe({ detail: "standard" });
-		expect(desc.nodes.orderPlaced).toBeDefined();
-		expect(desc.nodes.orderPlaced.meta?.cqrs_type).toBe("event");
-		app.destroy();
-	});
-
-	it("dispatch() throws for unknown command", () => {
-		const app = cqrs("test");
-		expect(() => app.dispatch("nonexistent", {})).toThrow(/Unknown command/);
-		app.destroy();
-	});
-
-	it("dispatch() sets command node value", () => {
-		const app = cqrs("test");
-		app.command("placeOrder", () => {});
-		app.dispatch("placeOrder", { id: "42" });
-		expect(app.node("placeOrder").cache).toEqual({ id: "42" });
-		app.destroy();
-	});
-
-	it("events carry timestampNs and seq fields", () => {
-		const app = cqrs("test");
-		app.event("orderPlaced");
-		app.command("placeOrder", (payload: any, { emit }) => {
-			emit("orderPlaced", payload);
-		});
-		app.dispatch("placeOrder", { id: "1" });
-		const entries = app.event("orderPlaced").cache as readonly CqrsEvent[];
-		const evt = entries[0];
-		expect(evt.timestampNs).toBeGreaterThan(0);
-		expect(evt.seq).toBe(1);
-		app.destroy();
-	});
-
-	it("events carry v0 identity when event log node is versioned", () => {
-		const app = cqrs("test");
-		app.event("orderPlaced");
-		app.command("placeOrder", (payload: any, { emit }) => {
-			emit("orderPlaced", payload);
-		});
-		app.dispatch("placeOrder", { id: "1" });
-		const entries = app.event("orderPlaced").cache as readonly CqrsEvent[];
-		expect(entries[0].v0).toBeDefined();
-		expect(entries[0].v0!.id).toBeTypeOf("string");
-		app.destroy();
-	});
-
-	it("seq increments monotonically across dispatches", () => {
-		const app = cqrs("test");
-		app.event("a");
-		app.event("b");
-		app.command("cmd", (_p: any, { emit }) => {
-			emit("a", 1);
-			emit("b", 2);
-		});
-		app.dispatch("cmd", {});
-		const entriesA = app.event("a").cache as readonly CqrsEvent[];
-		const entriesB = app.event("b").cache as readonly CqrsEvent[];
-		expect(entriesA[0].seq).toBe(1);
-		expect(entriesB[0].seq).toBe(2);
-		app.destroy();
-	});
-
-	// -- Dispatch failure audit (post-rollback) --------------------------------
-
-	it("dispatch() records failure audit record with errorType after throwing handler", () => {
-		const app = cqrs("test");
-		app.event("orderPlaced");
-		app.command("bad", (_p: any, { emit }) => {
-			emit("orderPlaced", { id: "1" });
-			throw new TypeError("handler boom");
-		});
-		expect(() => app.dispatch("bad", {})).toThrow("handler boom");
-
-		const dispatches = app.dispatches.entries
-			.cache as readonly import("../../../utils/cqrs/index.js").DispatchRecord[];
-		expect(dispatches).toHaveLength(1);
-		const record = dispatches[0];
-		expect(record.outcome).toBe("failure");
-		expect(record.error).toBeDefined();
-		expect(record.errorType).toBe("TypeError");
-		app.destroy();
-	});
-
-	it("dispatch() audit records emittedEvents list on failure as attempted list", () => {
-		const app = cqrs("test");
-		app.event("a");
-		app.event("b");
-		app.command("multi", (_p: any, { emit }) => {
-			emit("a", 1);
-			emit("b", 2);
-			throw new Error("mid-flight throw");
-		});
-		expect(() => app.dispatch("multi", {})).toThrow("mid-flight throw");
-
-		const dispatches = app.dispatches.entries
-			.cache as readonly import("../../../utils/cqrs/index.js").DispatchRecord[];
-		expect(dispatches[0].outcome).toBe("failure");
-		expect(dispatches[0].emittedEvents).toEqual(["a", "b"]);
-		app.destroy();
-	});
-
-	it("dispatch() audit records success on successful dispatch", () => {
-		const app = cqrs("test");
-		app.event("orderPlaced");
-		app.command("place", (_p: any, { emit }) => {
-			emit("orderPlaced", { id: "1" });
-		});
-		app.dispatch("place", { id: "x" });
-
-		const dispatches = app.dispatches.entries
-			.cache as readonly import("../../../utils/cqrs/index.js").DispatchRecord[];
-		expect(dispatches).toHaveLength(1);
-		expect(dispatches[0].outcome).toBe("success");
-		expect(dispatches[0].emittedEvents).toEqual(["orderPlaced"]);
-		expect(dispatches[0].errorType).toBeUndefined();
-		app.destroy();
-	});
-
-	it("dispatch() cmdNode.meta.error is set after rollback", () => {
-		const app = cqrs("test");
-		const err = new RangeError("bad range");
-		app.command("bad", () => {
-			throw err;
-		});
-		expect(() => app.dispatch("bad", {})).toThrow("bad range");
-		const cmdNode = app.resolve("bad");
-		expect(cmdNode.meta.error.cache).toBe(err);
-		app.destroy();
-	});
-
-	// -- Command handler error ------------------------------------------------
-
-	it("dispatch() sets meta.error on handler throw and re-throws", () => {
-		const app = cqrs("test");
-		const err = new Error("boom");
-		app.command("bad", () => {
-			throw err;
-		});
-		expect(() => app.dispatch("bad", {})).toThrow("boom");
-		const cmdNode = app.resolve("bad");
-		expect(cmdNode.meta.error.cache).toBe(err);
-		app.destroy();
-	});
-
-	it("dispatch() clears meta.error on success after prior error", () => {
-		const app = cqrs("test");
-		let shouldThrow = true;
-		app.command("maybe", (_p, { emit }) => {
-			if (shouldThrow) throw new Error("fail");
-			emit("ok", {});
-		});
-		expect(() => app.dispatch("maybe", {})).toThrow("fail");
-		const cmdNode = app.resolve("maybe");
-		expect(cmdNode.meta.error.cache).toBeInstanceOf(Error);
-		shouldThrow = false;
-		app.dispatch("maybe", {});
-		expect(cmdNode.meta.error.cache).toBeNull();
-		app.destroy();
-	});
-
-	// -- Projections ----------------------------------------------------------
-
-	it("projection() derives read model from events", () => {
-		const app = cqrs("test");
-		app.event("orderPlaced");
-		app.projection<number>({
-			name: "orderCount",
-			events: ["orderPlaced"],
-			reducer: (_state, events) => events.length,
-			initial: 0,
-			mode: "replay",
-		});
-		app.command("placeOrder", (payload: any, { emit }) => {
-			emit("orderPlaced", payload);
-		});
-
-		expect(app.node("orderCount").cache).toBe(0);
-		app.dispatch("placeOrder", { id: "1" });
-		expect(app.node("orderCount").cache).toBe(1);
-		app.dispatch("placeOrder", { id: "2" });
-		expect(app.node("orderCount").cache).toBe(2);
-		app.destroy();
-	});
-
-	it("projection from multiple event streams", () => {
-		const app = cqrs("test");
-		app.event("orderPlaced");
-		app.event("orderCancelled");
-
-		type Summary = { placed: number; cancelled: number };
-		app.projection<Summary>({
-			name: "summary",
-			events: ["orderPlaced", "orderCancelled"],
-			reducer: (_state, events) => ({
-				placed: events.filter((e) => e.type === "orderPlaced").length,
-				cancelled: events.filter((e) => e.type === "orderCancelled").length,
-			}),
-			initial: { placed: 0, cancelled: 0 },
-			mode: "replay",
-		});
-
-		app.command("placeOrder", (_p: any, { emit }) => emit("orderPlaced", {}));
-		app.command("cancelOrder", (_p: any, { emit }) => emit("orderCancelled", {}));
-
-		app.dispatch("placeOrder", {});
-		app.dispatch("placeOrder", {});
-		app.dispatch("cancelOrder", {});
-
-		const summary = app.node("summary").cache as Summary;
-		expect(summary.placed).toBe(2);
-		expect(summary.cancelled).toBe(1);
-		app.destroy();
-	});
-
-	it("projection node guard denies write", () => {
-		const app = cqrs("test");
-		app.event("orderPlaced");
-		app.projection({
-			name: "orderCount",
-			events: ["orderPlaced"],
-			reducer: (_s, e) => e.length,
-			initial: 0,
-		});
-		const projNode = app.resolve("orderCount");
-		expect(() => {
-			projNode.down([["DATA", 999]], { actor: { type: "human", id: "h1" } });
-		}).toThrow(GuardDenied);
-		app.destroy();
-	});
-
-	// -- Sagas ----------------------------------------------------------------
-
-	it("saga() runs handler on new events", () => {
-		const app = cqrs("test");
-		app.event("orderPlaced");
-
-		const sagaLog: CqrsEvent[] = [];
-		app.saga("notifyShipping", ["orderPlaced"], (evt) => {
-			sagaLog.push(evt);
-		});
-
-		app.command("placeOrder", (payload: any, { emit }) => {
-			emit("orderPlaced", payload);
-		});
-
-		app.dispatch("placeOrder", { id: "1" });
-		expect(sagaLog.length).toBeGreaterThanOrEqual(1);
-		expect(sagaLog[0].type).toBe("orderPlaced");
-		app.destroy();
-	});
-
-	it("saga() sets meta.error on handler throw and clears on later success", () => {
-		const app = cqrs("test");
-		app.event("orderPlaced");
-		let shouldThrow = true;
-		app.saga("sideFx", ["orderPlaced"], () => {
-			if (shouldThrow) throw new Error("saga boom");
-		});
-		app.command("placeOrder", (payload: any, { emit }) => {
-			emit("orderPlaced", payload);
-		});
-		app.dispatch("placeOrder", { id: "1" });
-		const sagaNode = app.resolve("sideFx");
-		expect(sagaNode.meta.error.cache).toBeInstanceOf(Error);
-		shouldThrow = false;
-		app.dispatch("placeOrder", { id: "2" });
-		expect(sagaNode.meta.error.cache).toBeNull();
-		app.destroy();
-	});
-
-	it("saga only processes new events, not historical replay", () => {
-		const app = cqrs("test");
-		app.event("orderPlaced");
-
-		const sagaLog: CqrsEvent[] = [];
-		app.saga("notifyShipping", ["orderPlaced"], (evt) => {
-			sagaLog.push(evt);
-		});
-
-		app.command("placeOrder", (payload: any, { emit }) => {
-			emit("orderPlaced", payload);
-		});
-
-		app.dispatch("placeOrder", { id: "1" });
-		const countAfterFirst = sagaLog.length;
-
-		app.dispatch("placeOrder", { id: "2" });
-		// Should only have processed the NEW event, not replayed event "1"
-		const newEvents = sagaLog.slice(countAfterFirst);
-		expect(newEvents).toHaveLength(1);
-		expect(newEvents[0].payload).toEqual({ id: "2" });
-		app.destroy();
-	});
-
-	// -- describe() -----------------------------------------------------------
-
-	it("describe() distinguishes command / event / projection / saga roles", () => {
-		const app = cqrs("test");
-		app.event("orderPlaced");
-		app.command("placeOrder", () => {});
-		app.projection({
-			name: "orderCount",
-			events: ["orderPlaced"],
-			reducer: (_s, e) => e.length,
-			initial: 0,
-		});
-		app.saga("notifyShipping", ["orderPlaced"], () => {});
-
-		const desc = app.describe({ detail: "standard" });
-		expect(desc.nodes.placeOrder.meta?.cqrs_type).toBe("command");
-		expect(desc.nodes.orderPlaced.meta?.cqrs_type).toBe("event");
-		expect(desc.nodes.orderCount.meta?.cqrs_type).toBe("projection");
-		expect(desc.nodes.notifyShipping.meta?.cqrs_type).toBe("saga");
-		app.destroy();
-	});
-
-	it("describe() shows edges from events to projections and sagas", () => {
-		const app = cqrs("test");
-		app.event("orderPlaced");
-		app.projection({
-			name: "orderCount",
-			events: ["orderPlaced"],
-			reducer: (_s, e) => e.length,
-			initial: 0,
-		});
-		app.saga("notifyShipping", ["orderPlaced"], () => {});
-
-		const desc = app.describe();
-		const edgePairs = desc.edges.map((e: any) => `${e.from}->${e.to}`);
-		expect(edgePairs).toContain("orderPlaced->orderCount");
-		expect(edgePairs).toContain("orderPlaced->notifyShipping");
-		app.destroy();
-	});
-
-	// -- UndeclaredEmitError --------------------------------------------------
-
-	it("dispatch() throws UndeclaredEmitError when emitting undeclared event (inside batch → re-thrown)", () => {
-		const app = cqrs("test");
-		app.event("orderPlaced");
-		app.command("place", {
-			handler: (_p: any, { emit }) => emit("orderShipped", {}),
-			emits: ["orderPlaced"],
-		});
-		expect(() => app.dispatch("place", {})).toThrow(UndeclaredEmitError);
-		app.destroy();
-	});
-
-	it("dispatch() allows any event name when emits is omitted (open mode)", () => {
-		const app = cqrs("test");
-		app.command("place", (_p: any, { emit }) => emit("anything", {}));
-		expect(() => app.dispatch("place", {})).not.toThrow();
-		app.destroy();
-	});
-
-	it("dispatch() succeeds when emitting a declared event name", () => {
-		const app = cqrs("test");
-		app.event("orderPlaced");
-		app.command("place", {
-			handler: (_p: any, { emit }) => emit("orderPlaced", { id: "1" }),
-			emits: ["orderPlaced"],
-		});
-		expect(() => app.dispatch("place", {})).not.toThrow();
-		app.destroy();
-	});
-
-	// -- attachEventStorage + projection.rebuild() ----------------------------
-
-	it("attachEventStorage persists events on dispatch", async () => {
-		const tier = memoryAppendLog<CqrsEvent>();
-		const app = cqrs("test");
-		app.attachEventStorage([tier]);
-		app.event("orderPlaced");
-		app.command("placeOrder", (payload: any, { emit }) => {
-			emit("orderPlaced", payload);
-		});
-
-		app.dispatch("placeOrder", { id: "1" });
-		app.dispatch("placeOrder", { id: "2" });
-
-		// Drain all microtask + promise-chain flushes. appendLogStorage flushes
-		// are chained via Promise microtasks. A macrotask break ensures all
-		// pending promise chains complete before we read.
-		await new Promise((r) => setTimeout(r, 0));
-
-		// Read back via loadEntries.
-		if (tier.loadEntries) {
-			const result = await tier.loadEntries();
-			expect(result.entries).toHaveLength(2);
-			expect((result.entries[0] as CqrsEvent).payload).toEqual({ id: "1" });
-		}
-		app.destroy();
-	});
-
-	it("projection.rebuild() replays from attached storage tier", async () => {
-		const tier = memoryAppendLog<CqrsEvent>();
-		const app = cqrs("test");
-		app.attachEventStorage([tier]);
-		app.event("orderPlaced");
-		app.command("placeOrder", (payload: any, { emit }) => {
-			emit("orderPlaced", payload);
-		});
-
-		app.dispatch("placeOrder", { id: "1" });
-		app.dispatch("placeOrder", { id: "2" });
-
-		// Drain async flush microtask chains (appendLogStorage batches via Promise.resolve chains).
-		await new Promise((r) => setTimeout(r, 0));
-
-		const { rebuild } = app.projection<number>({
-			name: "orderCount",
-			events: ["orderPlaced"],
-			// Reducer for rebuild: receives all persisted events in each page.
-			reducer: (acc, events) => acc + events.length,
-			initial: 0,
-		});
-
-		const rebuilt = await rebuild({ fromTier: tier });
-		expect(rebuilt).toBe(2);
-		app.destroy();
-	});
-
-	it("projection.reset() re-folds in-memory events on top of initial state", async () => {
-		const app = cqrs("test");
-		app.event("orderPlaced");
-		app.command("placeOrder", (payload: any, { emit }) => {
-			emit("orderPlaced", payload);
-		});
-		app.dispatch("placeOrder", { id: "1" });
-		app.dispatch("placeOrder", { id: "2" });
-
-		const { node: orderCountNode, reset } = app.projection<number>({
-			name: "orderCount",
-			events: ["orderPlaced"],
-			reducer: (_s, events) => events.length,
-			initial: 0,
-		});
-
-		// Initial state reflects dispatches made before projection was created.
-		const afterReset = await reset();
-		expect(afterReset).toBe(2);
-		expect(orderCountNode.cache).toBe(2);
-		app.destroy();
-	});
-
-	it("projection returns ProjectionController with node", () => {
-		const app = cqrs("test");
-		app.event("orderPlaced");
-		const ctrl = app.projection<number>({
-			name: "orderCount",
-			events: ["orderPlaced"],
-			reducer: (_s, e) => e.length,
-			initial: 0,
-		});
-		expect(ctrl.node).toBeDefined();
-		expect(typeof ctrl.rebuild).toBe("function");
-		expect(typeof ctrl.reset).toBe("function");
-		app.destroy();
-	});
-
-	it("projection mode=replay: reducer always receives initial state", () => {
-		const app = cqrs("test");
-		app.event("orderPlaced");
-		app.command("place", (p: any, { emit }) => emit("orderPlaced", p));
-		app.projection<number>({
-			name: "orderCount",
-			events: ["orderPlaced"],
-			reducer: (_state, events) => events.length,
-			initial: 0,
-			mode: "replay",
-		});
-		app.dispatch("place", { id: "1" });
-		expect(app.node("orderCount").cache).toBe(1);
-		app.dispatch("place", { id: "2" });
-		expect(app.node("orderCount").cache).toBe(2);
-		app.destroy();
-	});
-
-	it("projection mode=scan (default): incremental fold", () => {
-		let reducerCallCount = 0;
-		const app = cqrs("test");
-		app.event("orderPlaced");
-		app.command("place", (p: any, { emit }) => emit("orderPlaced", p));
-		app.projection<number>({
-			name: "orderCount",
-			events: ["orderPlaced"],
-			reducer: (state, events) => {
-				reducerCallCount++;
-				return state + events.length;
-			},
-			initial: 0,
-			mode: "scan",
-		});
-		// Capture the count after projection construction (includes the
-		// push-on-subscribe activation for the empty initial state).
-		const countAfterConstruction = reducerCallCount;
-		app.dispatch("place", { id: "1" });
-		expect(app.node("orderCount").cache).toBe(1);
-		app.dispatch("place", { id: "2" });
-		expect(app.node("orderCount").cache).toBe(2);
-		// Each dispatch fires the reducer exactly once (incremental, not full replay).
-		expect(reducerCallCount - countAfterConstruction).toBe(2);
-		app.destroy();
-	});
-
-	// -- D1 — per-aggregate streams + LRU + optimistic concurrency -----------
-
-	it("aggregateVersion increments per-(type, aggregateId) on emit", () => {
-		const app = cqrs("test");
-		app.event("orderPlaced");
-		app.command("place", (_: unknown, { emit }) => {
-			emit("orderPlaced", { id: "x" });
-		});
-		app.dispatch("place", { id: "1" }, { aggregateId: "agg-1" });
-		expect(app.aggregateVersion("orderPlaced", "agg-1")).toBe(1);
-		app.dispatch("place", { id: "2" }, { aggregateId: "agg-1" });
-		expect(app.aggregateVersion("orderPlaced", "agg-1")).toBe(2);
-		expect(app.aggregateVersion("orderPlaced", "agg-2")).toBe(0);
-		const events = app.event("orderPlaced", "agg-1").cache as readonly CqrsEvent[];
-		expect(events).toHaveLength(2);
-		expect(events[0].aggregateVersion).toBe(1);
-		expect(events[1].aggregateVersion).toBe(2);
-		app.destroy();
-	});
-
-	it("dispatch throws OptimisticConcurrencyError on version mismatch", () => {
-		const app = cqrs("test");
-		app.event("orderPlaced");
-		app.command("place", {
-			handler: (_: unknown, { emit }) => emit("orderPlaced", { id: "x" }),
-			emits: ["orderPlaced"],
-		});
-		app.dispatch("place", { id: "1" }, { aggregateId: "agg-1" });
-		// Aggregate is at v1; expecting v0 should throw.
-		expect(() =>
-			app.dispatch("place", { id: "2" }, { aggregateId: "agg-1", expectedAggregateVersion: 0 }),
-		).toThrow(OptimisticConcurrencyError);
-		// Expecting v1 should succeed.
-		app.dispatch("place", { id: "3" }, { aggregateId: "agg-1", expectedAggregateVersion: 1 });
-		expect(app.aggregateVersion("orderPlaced", "agg-1")).toBe(2);
-		app.destroy();
-	});
-
-	it("LRU eviction removes oldest aggregate streams when maxAggregates exceeded", () => {
-		const app = cqrs("test", { maxAggregates: 2 });
-		app.event("e");
-		app.command("emit", (_: unknown, { emit }) => emit("e", { v: 1 }));
-		app.dispatch("emit", {}, { aggregateId: "a" });
-		app.dispatch("emit", {}, { aggregateId: "b" });
-		app.dispatch("emit", {}, { aggregateId: "c" }); // evicts "a"
-		const evictions = app.aggregateEvictions.entries.cache as readonly {
-			aggregateId: string;
-			type: string;
-			lastVersion: number;
-		}[];
-		expect(evictions).toHaveLength(1);
-		expect(evictions[0].aggregateId).toBe("a");
-		expect(evictions[0].type).toBe("e");
-		expect(evictions[0].lastVersion).toBe(1);
-		// Aggregate "a" version is reset (its dedicated stream + counter were dropped).
-		expect(app.aggregateVersion("e", "a")).toBe(0);
-		expect(app.aggregateVersion("e", "b")).toBe(1);
-		app.destroy();
-	});
-
-	// ── C.1 E — per-aggregate streams (fan-in) ────────────────────────
-
-	it("event(type) and event(type, aggregateId) point at distinct streams; per-aggregate isolates", () => {
-		const app = cqrs("test");
-		app.event("orderPlaced");
-		app.command("place", {
-			handler: (p, a) => a.emit("orderPlaced", p),
-			emits: ["orderPlaced"],
-		});
-
-		app.dispatch("place", { id: 1 }, { aggregateId: "a" });
-		app.dispatch("place", { id: 2 }, { aggregateId: "b" });
-		app.dispatch("place", { id: 3 }, { aggregateId: "a" });
-
-		// Type-level (fan-in) stream — all events for the type, in dispatch order.
-		const all = app.event("orderPlaced").cache as readonly CqrsEvent[];
-		expect(all.map((e) => e.aggregateId)).toEqual(["a", "b", "a"]);
-
-		// Per-aggregate streams isolate.
-		const aOnly = app.event("orderPlaced", "a").cache as readonly CqrsEvent[];
-		const bOnly = app.event("orderPlaced", "b").cache as readonly CqrsEvent[];
-		expect(aOnly).toHaveLength(2);
-		expect(bOnly).toHaveLength(1);
-		expect(aOnly.every((e) => e.aggregateId === "a")).toBe(true);
-		expect(bOnly[0]!.aggregateId).toBe("b");
-
-		// aggregateVersion is per-(type, aggregateId).
-		expect(app.aggregateVersion("orderPlaced", "a")).toBe(2);
-		expect(app.aggregateVersion("orderPlaced", "b")).toBe(1);
-
-		app.destroy();
-	});
-
-	it("F-CATCH D-4: per-aggregate node name-collision fallback warns and still functions", () => {
-		const app = cqrs("test");
-		app.event("orderPlaced");
-		app.command("place", {
-			handler: (p, a) => a.emit("orderPlaced", p),
-			emits: ["orderPlaced"],
-		});
-
-		// Simulate the name-collision race: the de-dup loop resolves a free
-		// mount name, but `derived()` still throws (a concurrent constructor
-		// registered it between the resolveOptional() check and registration).
-		const realDerived = (app as unknown as { derived: (...a: unknown[]) => unknown }).derived.bind(
-			app,
-		);
-		const spy = vi
-			.spyOn(app as unknown as { derived: (...a: unknown[]) => unknown }, "derived")
-			.mockImplementation((...args: unknown[]) => {
-				if (typeof args[0] === "string" && args[0].startsWith("orderPlaced_agg")) {
-					throw new Error("simulated name-collision race");
-				}
-				return realDerived(...args);
-			});
-		const warn = vi.spyOn(console, "warn").mockImplementation(() => undefined);
-		try {
-			app.dispatch("place", { id: 1 }, { aggregateId: "agg-1" });
-			// Fallback unmounted node still carries the per-aggregate stream.
-			const aOnly = app.event("orderPlaced", "agg-1").cache as readonly CqrsEvent[];
-			expect(aOnly).toHaveLength(1);
-			expect(aOnly[0]!.aggregateId).toBe("agg-1");
-			// Surface-loud: the silent graph-visibility loss is now diagnosable.
-			expect(
-				warn.mock.calls.some(
-					(c) =>
-						typeof c[0] === "string" &&
-						/name-collision race.*will NOT appear in graph\.describe/s.test(c[0]),
-				),
-			).toBe(true);
-		} finally {
-			warn.mockRestore();
-			spy.mockRestore();
-			app.destroy();
-		}
-	});
-
-	it("mergeReactiveLogs over per-aggregate streams produces a stable fan-in stream", () => {
-		const app = cqrs("test");
-		app.event("orderPlaced");
-		app.command("place", {
-			handler: (p, a) => a.emit("orderPlaced", p),
-			emits: ["orderPlaced"],
-		});
-
-		// Touch both aggregate streams so they exist.
-		app.dispatch("place", { id: 1 }, { aggregateId: "a" });
-		app.dispatch("place", { id: 2 }, { aggregateId: "b" });
-
-		const aLog = app.event("orderPlaced", "a");
-		const bLog = app.event("orderPlaced", "b");
-		const merged = mergeReactiveLogs([aLog, bLog]);
-		expect((merged.node.cache as readonly CqrsEvent[]).length).toBe(2);
-
-		// New emission to "a" propagates through the merged stream.
-		app.dispatch("place", { id: 3 }, { aggregateId: "a" });
-		const after = merged.node.cache as readonly CqrsEvent[];
-		expect(after.length).toBe(3);
-		// Per-aggregate ordering preserved within each input log; merge is
-		// concatenation order across input identities.
-		expect(after.map((e) => e.aggregateId)).toEqual(["a", "a", "b"]);
-
-		merged.dispose();
-		app.destroy();
-	});
-
-	// ── Audit 2 — saga errorPolicy + invocations audit ────────────────
-
-	it("saga errorPolicy='advance' (default) skips past failure; invocations log captures both records", () => {
-		const app = cqrs<{ orderPlaced: { id: number } }>("test");
-		app.command("placeOrder", {
-			handler: (p, a) => a.emit("orderPlaced", p),
-			emits: ["orderPlaced"],
-		});
-		const seen: number[] = [];
-		const ctrl = app.saga<{ id: number }>("notifyShipping", ["orderPlaced"], (evt) => {
-			if ((evt.payload as { id: number }).id === 2) throw new Error("boom");
-			seen.push((evt.payload as { id: number }).id);
-		});
-
-		app.dispatch("placeOrder", { id: 1 });
-		app.dispatch("placeOrder", { id: 2 });
-		app.dispatch("placeOrder", { id: 3 });
-
-		// "advance" policy: failure is recorded but cursor moves past it, so
-		// id=3 is still processed.
-		expect(seen).toEqual([1, 3]);
-
-		const inv = ctrl.invocations.entries.cache as readonly {
-			outcome: string;
-			errorType?: string;
-		}[];
-		expect(inv.length).toBe(3);
-		expect(inv[0]!.outcome).toBe("success");
-		expect(inv[1]!.outcome).toBe("failure");
-		expect(inv[1]!.errorType).toBe("Error");
-		expect(inv[2]!.outcome).toBe("success");
-
-		app.destroy();
-	});
-
-	it("M7 — saga.audit is a read-only view of invocations (no silent mutation)", () => {
-		const app = cqrs<{ orderPlaced: { id: number } }>("test");
-		app.command("placeOrder", {
-			handler: (p, a) => a.emit("orderPlaced", p),
-			emits: ["orderPlaced"],
-		});
-		const ctrl = app.saga<{ id: number }>("notify", ["orderPlaced"], () => undefined);
-		app.dispatch("placeOrder", { id: 1 });
-
-		// Zero-copy: the audit view shares the canonical log's reactive surface.
-		expect(ctrl.audit.entries).toBe(ctrl.invocations.entries);
-		expect(ctrl.audit.size).toBe(ctrl.invocations.size);
-		expect(ctrl.audit.size).toBe(1);
-		// …but the alias is frozen and exposes no mutators — a consumer cannot
-		// `append`/`clear` `invocations` through `audit` (M7).
-		expect(ctrl.audit).not.toBe(ctrl.invocations);
-		expect("append" in ctrl.audit).toBe(false);
-		expect("clear" in ctrl.audit).toBe(false);
-		expect("attach" in ctrl.audit).toBe(false);
-		expect(Object.isFrozen(ctrl.audit)).toBe(true);
-
-		app.destroy();
-	});
-
-	it("saga errorPolicy='hold' stops cursor at failure; later events are NOT processed until handler stops throwing", () => {
-		const app = cqrs<{ orderPlaced: { id: number } }>("test");
-		app.command("placeOrder", {
-			handler: (p, a) => a.emit("orderPlaced", p),
-			emits: ["orderPlaced"],
-		});
-		let throwOnId: number | null = 2;
-		const seen: number[] = [];
-		app.saga<{ id: number }>(
-			"notifyShipping",
-			["orderPlaced"],
-			(evt) => {
-				const id = (evt.payload as { id: number }).id;
-				if (id === throwOnId) throw new Error("hold");
-				seen.push(id);
-			},
-			{ errorPolicy: "hold" },
-		);
-
-		app.dispatch("placeOrder", { id: 1 });
-		app.dispatch("placeOrder", { id: 2 });
-		app.dispatch("placeOrder", { id: 3 });
-
-		// "hold" policy: cursor stops at the failing event; id=3 is NOT seen
-		// because the saga didn't advance past id=2.
-		expect(seen).toEqual([1]);
-
-		// Disable the throw and emit a fresh event — the saga retries from the
-		// held cursor and processes id=2 + id=3 + id=4 in order.
-		throwOnId = null;
-		app.dispatch("placeOrder", { id: 4 });
-		expect(seen).toEqual([1, 2, 3, 4]);
-
-		app.destroy();
-	});
-});
diff --git a/src/__tests__/utils/demo-shell/demo-shell.test.ts b/src/__tests__/utils/demo-shell/demo-shell.test.ts
deleted file mode 100644
index 80a59408..00000000
--- a/src/__tests__/utils/demo-shell/demo-shell.test.ts
+++ /dev/null
@@ -1,541 +0,0 @@
-import { node } from "@graphrefly/pure-ts/core";
-import { Graph } from "@graphrefly/pure-ts/graph";
-import { describe, expect, it, vi } from "vitest";
-import {
-	type DemoShellHandle,
-	demoShell,
-	type GraphLabelSize,
-	type HighlightCallbacks,
-	type NodeRegistry,
-} from "../../../utils/demo-shell/index.js";
-import { CliMeasureAdapter } from "../../../utils/reactive-layout/measurement-adapters.js";
-import type { LineBreaksResult } from "../../../utils/reactive-layout/reactive-layout.js";
-
-describe("patterns.demoShell", () => {
-	// ── Factory & graph shape ────────────────────────────
-
-	it("creates a Graph named 'demo-shell'", () => {
-		const { graph } = demoShell();
-		expect(graph).toBeInstanceOf(Graph);
-		expect(graph.name).toBe("demo-shell");
-	});
-
-	it("describe() exposes all expected nodes", () => {
-		const { graph } = demoShell();
-		const desc = graph.describe();
-		const paths = Object.keys(desc.nodes).sort();
-		expect(paths).toContain("pane/main-ratio");
-		expect(paths).toContain("pane/side-split");
-		expect(paths).toContain("pane/fullscreen");
-		expect(paths).toContain("viewport/width");
-		expect(paths).toContain("pane/main-width");
-		expect(paths).toContain("pane/side-width");
-		expect(paths).toContain("pane/graph-height-ratio");
-		expect(paths).toContain("pane/code-height-ratio");
-		expect(paths).toContain("demo/graph-ref");
-		expect(paths).toContain("demo/graph-tick");
-		expect(paths).toContain("graph/mermaid");
-		expect(paths).toContain("graph/describe");
-		expect(paths).toContain("hover/target");
-		expect(paths).toContain("highlight/code-scroll");
-		expect(paths).toContain("highlight/visual");
-		expect(paths).toContain("highlight/graph");
-		expect(paths).toContain("inspect/selected-node");
-		expect(paths).toContain("inspect/node-detail");
-		expect(paths).toContain("inspect/trace-log");
-		expect(paths).toContain("meta/debug");
-		expect(paths).toContain("meta/shell-mermaid");
-	});
-
-	it("edges are registered in the graph", () => {
-		const { graph } = demoShell();
-		const edges = graph.edges();
-		expect(edges).toContainEqual(["pane/main-ratio", "pane/main-width"]);
-		expect(edges).toContainEqual(["viewport/width", "pane/main-width"]);
-		expect(edges).toContainEqual(["demo/graph-ref", "graph/mermaid"]);
-		expect(edges).toContainEqual(["hover/target", "highlight/graph"]);
-		expect(edges).toContainEqual(["meta/debug", "meta/shell-mermaid"]);
-	});
-
-	// ── Layout derivation ────────────────────────────────
-
-	it("derives pane widths from main-ratio and viewport", () => {
-		const shell = demoShell({ mainRatio: 0.6, viewportWidth: 1000 });
-		// Force subscription so derived nodes compute
-		subscribePath(shell, "pane/main-width");
-		subscribePath(shell, "pane/side-width");
-
-		expect(shell.graph.node("pane/main-width").cache).toBe(600);
-		expect(shell.graph.node("pane/side-width").cache).toBe(400);
-	});
-
-	it("setMainRatio clamps to [0,1] and updates widths", () => {
-		const shell = demoShell({ viewportWidth: 1000 });
-		subscribePath(shell, "pane/main-width");
-		subscribePath(shell, "pane/side-width");
-
-		shell.setMainRatio(0.8);
-		expect(shell.graph.node("pane/main-width").cache).toBe(800);
-		expect(shell.graph.node("pane/side-width").cache).toBe(200);
-
-		shell.setMainRatio(1.5); // clamped to 1
-		expect(shell.graph.node("pane/main-width").cache).toBe(1000);
-
-		shell.setMainRatio(-0.1); // clamped to 0
-		expect(shell.graph.node("pane/main-width").cache).toBe(0);
-	});
-
-	it("fullscreen=main gives main 100%, side 0%", () => {
-		const shell = demoShell({ viewportWidth: 1000 });
-		subscribePath(shell, "pane/main-width");
-		subscribePath(shell, "pane/side-width");
-
-		shell.setFullscreen("main");
-		expect(shell.graph.node("pane/main-width").cache).toBe(1000);
-		expect(shell.graph.node("pane/side-width").cache).toBe(0);
-	});
-
-	it("fullscreen=graph gives side 100%, main 0%", () => {
-		const shell = demoShell({ viewportWidth: 1000 });
-		subscribePath(shell, "pane/main-width");
-		subscribePath(shell, "pane/side-width");
-		subscribePath(shell, "pane/graph-height-ratio");
-		subscribePath(shell, "pane/code-height-ratio");
-
-		shell.setFullscreen("graph");
-		expect(shell.graph.node("pane/main-width").cache).toBe(0);
-		expect(shell.graph.node("pane/side-width").cache).toBe(1000);
-		expect(shell.graph.node("pane/graph-height-ratio").cache).toBe(1);
-		expect(shell.graph.node("pane/code-height-ratio").cache).toBe(0);
-	});
-
-	it("fullscreen=code gives code 100%", () => {
-		const shell = demoShell({ viewportWidth: 1000 });
-		subscribePath(shell, "pane/graph-height-ratio");
-		subscribePath(shell, "pane/code-height-ratio");
-
-		shell.setFullscreen("code");
-		expect(shell.graph.node("pane/graph-height-ratio").cache).toBe(0);
-		expect(shell.graph.node("pane/code-height-ratio").cache).toBe(1);
-	});
-
-	it("side-split controls graph/code ratio", () => {
-		const shell = demoShell({ sideSplit: 0.7 });
-		subscribePath(shell, "pane/graph-height-ratio");
-		subscribePath(shell, "pane/code-height-ratio");
-
-		expect(shell.graph.node("pane/graph-height-ratio").cache).toBe(0.7);
-		expect(shell.graph.node("pane/code-height-ratio").cache).toBeCloseTo(0.3);
-	});
-
-	it("setViewportWidth updates pane widths reactively", () => {
-		const shell = demoShell({ mainRatio: 0.5, viewportWidth: 800 });
-		subscribePath(shell, "pane/main-width");
-
-		expect(shell.graph.node("pane/main-width").cache).toBe(400);
-		shell.setViewportWidth(1200);
-		expect(shell.graph.node("pane/main-width").cache).toBe(600);
-	});
-
-	// ── External graph observation ───────────────────────
-
-	it("graph/mermaid is empty when no demo graph is set", () => {
-		const shell = demoShell();
-		subscribePath(shell, "graph/mermaid");
-
-		expect(shell.graph.node("graph/mermaid").cache).toBe("");
-	});
-
-	it("graph/mermaid derives from demo graph", () => {
-		const shell = demoShell();
-		subscribePath(shell, "graph/mermaid");
-
-		const demo = new Graph("test-demo");
-		const a = node([], { name: "a", initial: 1 });
-		demo.add(a, { name: "a" });
-		const b = node(
-			[a],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit(data[0]);
-			},
-			{ describeKind: "derived", name: "b" },
-		);
-		demo.add(b, { name: "b" });
-
-		shell.setDemoGraph(demo);
-		const mermaid = shell.graph.node("graph/mermaid").cache as string;
-		expect(mermaid).toContain("flowchart");
-		expect(mermaid).toContain("a");
-		expect(mermaid).toContain("b");
-		expect(mermaid).toContain("-->");
-	});
-
-	it("bumpGraphTick re-derives mermaid after demo graph changes", () => {
-		const shell = demoShell();
-		subscribePath(shell, "graph/mermaid");
-
-		const demo = new Graph("test-demo");
-		demo.add(node([], { name: "x", initial: 1 }), { name: "x" });
-		shell.setDemoGraph(demo);
-		const before = shell.graph.node("graph/mermaid").cache as string;
-		expect(before).toContain("x");
-
-		demo.add(node([], { name: "y", initial: 2 }), { name: "y" });
-		shell.bumpGraphTick();
-		const after = shell.graph.node("graph/mermaid").cache as string;
-		expect(after).toContain("y");
-	});
-
-	it("graph/describe returns null when no demo graph", () => {
-		const shell = demoShell();
-		subscribePath(shell, "graph/describe");
-
-		expect(shell.graph.node("graph/describe").cache).toBeNull();
-	});
-
-	it("graph/describe returns snapshot of demo graph", () => {
-		const shell = demoShell();
-		subscribePath(shell, "graph/describe");
-
-		const demo = new Graph("test-demo");
-		demo.add(node([], { name: "node1", initial: 42 }), { name: "node1" });
-		shell.setDemoGraph(demo);
-
-		const desc = shell.graph.node("graph/describe").cache as Record<string, unknown>;
-		expect(desc).not.toBeNull();
-		expect((desc as { name: string }).name).toBe("test-demo");
-	});
-
-	// ── Cross-highlighting ───────────────────────────────
-
-	it("hover target derives code-scroll from registry", () => {
-		const registry: NodeRegistry = new Map([
-			["myNode", { codeLine: 42, visualSelector: ".my-node" }],
-		]);
-		const shell = demoShell({ nodeRegistry: registry });
-		subscribePath(shell, "highlight/code-scroll");
-		subscribePath(shell, "highlight/visual");
-		subscribePath(shell, "highlight/graph");
-
-		shell.setHoverTarget({ pane: "graph", id: "myNode" });
-		expect(shell.graph.node("highlight/code-scroll").cache).toBe(42);
-		expect(shell.graph.node("highlight/visual").cache).toBe(".my-node");
-		expect(shell.graph.node("highlight/graph").cache).toBe("myNode");
-	});
-
-	it("null hover target clears all highlights", () => {
-		const registry: NodeRegistry = new Map([["myNode", { codeLine: 10, visualSelector: ".x" }]]);
-		const shell = demoShell({ nodeRegistry: registry });
-		subscribePath(shell, "highlight/code-scroll");
-		subscribePath(shell, "highlight/visual");
-		subscribePath(shell, "highlight/graph");
-
-		shell.setHoverTarget({ pane: "visual", id: "myNode" });
-		expect(shell.graph.node("highlight/code-scroll").cache).toBe(10);
-
-		shell.setHoverTarget(null);
-		expect(shell.graph.node("highlight/code-scroll").cache).toBeNull();
-		expect(shell.graph.node("highlight/visual").cache).toBeNull();
-		expect(shell.graph.node("highlight/graph").cache).toBeNull();
-	});
-
-	it("hover on unknown id returns null for code/visual", () => {
-		const shell = demoShell({ nodeRegistry: new Map() });
-		subscribePath(shell, "highlight/code-scroll");
-		subscribePath(shell, "highlight/visual");
-		subscribePath(shell, "highlight/graph");
-
-		shell.setHoverTarget({ pane: "graph", id: "unknown" });
-		expect(shell.graph.node("highlight/code-scroll").cache).toBeNull();
-		expect(shell.graph.node("highlight/visual").cache).toBeNull();
-		// graph highlight always returns the id
-		expect(shell.graph.node("highlight/graph").cache).toBe("unknown");
-	});
-
-	// ── Inspect panel ────────────────────────────────────
-
-	it("inspect/node-detail is null when no node selected", () => {
-		const shell = demoShell();
-		subscribePath(shell, "inspect/node-detail");
-
-		expect(shell.graph.node("inspect/node-detail").cache).toBeNull();
-	});
-
-	it("inspect/node-detail returns node description when selected", () => {
-		const shell = demoShell();
-		subscribePath(shell, "inspect/node-detail");
-
-		const demo = new Graph("test-demo");
-		demo.add(node([], { name: "counter", initial: 7 }), { name: "counter" });
-		shell.setDemoGraph(demo);
-		shell.selectNode("counter");
-
-		const detail = shell.graph.node("inspect/node-detail").cache as Record<string, unknown>;
-		expect(detail).not.toBeNull();
-		expect(detail.path).toBe("counter");
-		expect(detail.value).toBe(7);
-	});
-
-	it("inspect/node-detail handles invalid path gracefully", () => {
-		const shell = demoShell();
-		subscribePath(shell, "inspect/node-detail");
-
-		const demo = new Graph("test-demo");
-		shell.setDemoGraph(demo);
-		shell.selectNode("nonexistent");
-
-		expect(shell.graph.node("inspect/node-detail").cache).toBeNull();
-	});
-
-	it("inspect/trace-log returns empty array when no demo graph", () => {
-		const shell = demoShell();
-		subscribePath(shell, "inspect/trace-log");
-
-		expect(shell.graph.node("inspect/trace-log").cache).toEqual([]);
-	});
-
-	// ── Meta debug toggle ────────────────────────────────
-
-	it("meta/shell-mermaid is empty when debug is off", () => {
-		const shell = demoShell();
-		subscribePath(shell, "meta/shell-mermaid");
-
-		expect(shell.graph.node("meta/shell-mermaid").cache).toBe("");
-	});
-
-	it("meta/shell-mermaid renders the shell's own graph when debug is on", () => {
-		const shell = demoShell();
-		subscribePath(shell, "meta/shell-mermaid");
-
-		shell.setMetaDebug(true);
-		const mermaid = shell.graph.node("meta/shell-mermaid").cache as string;
-		expect(mermaid).toContain("flowchart");
-		// Should contain shell's own nodes
-		expect(mermaid).toContain("pane/main-ratio");
-		expect(mermaid).toContain("meta/shell-mermaid");
-	});
-
-	// ── Layout engine integration ────────────────────────
-
-	it("layout nodes are absent without adapter", () => {
-		const { graph } = demoShell();
-		const desc = graph.describe();
-		const paths = Object.keys(desc.nodes);
-		// code-text state always exists; derived layout nodes require adapter
-		expect(paths).toContain("layout/code-text");
-		expect(paths).not.toContain("layout/graph-labels");
-		expect(paths).not.toContain("layout/code-lines");
-		expect(paths).not.toContain("layout/side-width-hint");
-	});
-
-	it("layout nodes are created when adapter is provided", () => {
-		const adapter = new CliMeasureAdapter();
-		const { graph } = demoShell({ adapter });
-		const desc = graph.describe();
-		const paths = Object.keys(desc.nodes);
-		expect(paths).toContain("layout/graph-labels");
-		expect(paths).toContain("layout/code-lines");
-		expect(paths).toContain("layout/side-width-hint");
-	});
-
-	it("layout/graph-labels measures demo graph node labels", () => {
-		const adapter = new CliMeasureAdapter();
-		const shell = demoShell({ adapter });
-		// Subscribe to the full chain: graph/describe → layout/graph-labels
-		subscribePath(shell, "graph/describe");
-		subscribePath(shell, "layout/graph-labels");
-
-		const demo = new Graph("test-demo");
-		demo.add(node([], { name: "counter", initial: 1 }), { name: "counter" });
-		demo.add(
-			node(
-				[demo.node("counter")!],
-				(batchData, actions, ctx) => {
-					const data = batchData.map((batch, i) =>
-						batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-					);
-					actions.emit(data[0]);
-				},
-				{ describeKind: "derived", name: "display" },
-			),
-			{ name: "display" },
-		);
-		shell.setDemoGraph(demo);
-		shell.bumpGraphTick();
-
-		const labels = shell.graph.node("layout/graph-labels").cache as Map<string, GraphLabelSize>;
-		expect(labels).toBeInstanceOf(Map);
-		expect(labels.size).toBe(2);
-		expect(labels.has("counter")).toBe(true);
-		expect(labels.has("display")).toBe(true);
-		const counterSize = labels.get("counter")!;
-		expect(counterSize.width).toBeGreaterThan(0);
-		expect(counterSize.height).toBeGreaterThan(0);
-	});
-
-	it("layout/graph-labels is empty map when no demo graph", () => {
-		const adapter = new CliMeasureAdapter();
-		const shell = demoShell({ adapter });
-		subscribePath(shell, "graph/describe");
-		subscribePath(shell, "layout/graph-labels");
-
-		const labels = shell.graph.node("layout/graph-labels").cache as Map<string, GraphLabelSize>;
-		expect(labels).toBeInstanceOf(Map);
-		expect(labels.size).toBe(0);
-	});
-
-	it("layout/code-lines breaks text into lines", () => {
-		const adapter = new CliMeasureAdapter();
-		const shell = demoShell({ adapter });
-		subscribePath(shell, "layout/code-lines");
-
-		shell.setCodeText("hello world");
-		const result = shell.graph.node("layout/code-lines").cache as LineBreaksResult;
-		expect(result.lineCount).toBeGreaterThanOrEqual(1);
-		expect(result.lines.length).toBeGreaterThanOrEqual(1);
-	});
-
-	it("layout/code-lines returns empty for empty text", () => {
-		const adapter = new CliMeasureAdapter();
-		const shell = demoShell({ adapter });
-		subscribePath(shell, "layout/code-lines");
-
-		const result = shell.graph.node("layout/code-lines").cache as LineBreaksResult;
-		expect(result.lineCount).toBe(0);
-		expect(result.lines).toEqual([]);
-	});
-
-	it("layout/side-width-hint derives from graph label widths", () => {
-		const adapter = new CliMeasureAdapter();
-		const shell = demoShell({ adapter });
-		subscribePath(shell, "graph/describe");
-		subscribePath(shell, "layout/graph-labels");
-		subscribePath(shell, "layout/side-width-hint");
-
-		// No demo graph → default minimum
-		expect(shell.graph.node("layout/side-width-hint").cache).toBe(200);
-
-		const demo = new Graph("test-demo");
-		demo.add(node([], { name: "short", initial: 1 }), { name: "short" });
-		demo.add(node([], { name: "a-much-longer-node-name", initial: 2 }), {
-			name: "a-much-longer-node-name",
-		});
-		shell.setDemoGraph(demo);
-		shell.bumpGraphTick();
-
-		const hint = shell.graph.node("layout/side-width-hint").cache as number;
-		expect(hint).toBeGreaterThanOrEqual(200);
-	});
-
-	// ── Cross-highlighting effect nodes ──────────────────
-
-	it("effect nodes are absent without onHighlight", () => {
-		const { graph } = demoShell();
-		const paths = Object.keys(graph.describe().nodes);
-		expect(paths).not.toContain("highlight/apply-code-scroll");
-		expect(paths).not.toContain("highlight/apply-visual");
-		expect(paths).not.toContain("highlight/apply-graph");
-	});
-
-	it("effect nodes are created when onHighlight callbacks provided", () => {
-		const onHighlight: HighlightCallbacks = {
-			codeScroll: () => {},
-			visual: () => {},
-			graph: () => {},
-		};
-		const { graph } = demoShell({ onHighlight });
-		const paths = Object.keys(graph.describe().nodes);
-		expect(paths).toContain("highlight/apply-code-scroll");
-		expect(paths).toContain("highlight/apply-visual");
-		expect(paths).toContain("highlight/apply-graph");
-	});
-
-	it("effect nodes invoke callbacks on hover target change", () => {
-		const codeScrollCb = vi.fn();
-		const visualCb = vi.fn();
-		const graphCb = vi.fn();
-
-		const registry: NodeRegistry = new Map([
-			["myNode", { codeLine: 42, visualSelector: ".my-node" }],
-		]);
-		const shell = demoShell({
-			nodeRegistry: registry,
-			onHighlight: {
-				codeScroll: codeScrollCb,
-				visual: visualCb,
-				graph: graphCb,
-			},
-		});
-
-		// Subscribe to activate derived+effect chain
-		subscribePath(shell, "highlight/apply-code-scroll");
-		subscribePath(shell, "highlight/apply-visual");
-		subscribePath(shell, "highlight/apply-graph");
-
-		shell.setHoverTarget({ pane: "graph", id: "myNode" });
-		expect(codeScrollCb).toHaveBeenCalledWith(42);
-		expect(visualCb).toHaveBeenCalledWith(".my-node");
-		expect(graphCb).toHaveBeenCalledWith("myNode");
-
-		shell.setHoverTarget(null);
-		expect(codeScrollCb).toHaveBeenCalledWith(null);
-		expect(visualCb).toHaveBeenCalledWith(null);
-		expect(graphCb).toHaveBeenCalledWith(null);
-	});
-
-	it("partial onHighlight creates only specified effect nodes", () => {
-		const { graph } = demoShell({ onHighlight: { graph: () => {} } });
-		const paths = Object.keys(graph.describe().nodes);
-		expect(paths).not.toContain("highlight/apply-code-scroll");
-		expect(paths).not.toContain("highlight/apply-visual");
-		expect(paths).toContain("highlight/apply-graph");
-	});
-
-	// ── Batch helper ─────────────────────────────────────
-
-	it("batch() prevents intermediate recomputes", () => {
-		const shell = demoShell({ mainRatio: 0.5, viewportWidth: 1000 });
-		let computeCount = 0;
-
-		// Track recomputes on main-width via observe
-		const obs = shell.graph.observe("pane/main-width");
-		obs.subscribe(() => {
-			computeCount++;
-		});
-
-		// Reset count after initial subscription fires
-		computeCount = 0;
-
-		shell.batch(() => {
-			shell.setViewportWidth(1920);
-			shell.setMainRatio(0.7);
-		});
-
-		// After batch: final value must be correct
-		expect(shell.graph.node("pane/main-width").cache).toBe(Math.round(1920 * 0.7));
-		expect(computeCount).toBeGreaterThanOrEqual(1);
-	});
-
-	it("batch() is available on the handle", () => {
-		const shell = demoShell();
-		expect(typeof shell.batch).toBe("function");
-	});
-
-	// ── Destroy ──────────────────────────────────────────
-
-	it("destroy() tears down cleanly", () => {
-		const shell = demoShell();
-		expect(() => shell.destroy()).not.toThrow();
-	});
-});
-
-// ── Test helper ──────────────────────────────────────────
-
-/** Subscribe to a node path to activate lazy derived computation. */
-function subscribePath(shell: DemoShellHandle, path: string): () => void {
-	const obs = shell.graph.observe(path);
-	return obs.subscribe(() => {});
-}
diff --git a/src/__tests__/utils/domain-templates/domain-templates.test.ts b/src/__tests__/utils/domain-templates/domain-templates.test.ts
deleted file mode 100644
index 73894304..00000000
--- a/src/__tests__/utils/domain-templates/domain-templates.test.ts
+++ /dev/null
@@ -1,429 +0,0 @@
-// FLAG: v5 behavioral change — needs investigation
-// All tests in this file fail with:
-//   Graph "...": connect(source, target) — target must include source in its constructor deps (same node reference)
-// The underlying pattern factories (stratify, feedback, etc.) use Graph.connect() which now
-// enforces that the target node already has the source in its deps array.
-
-import { DATA, node } from "@graphrefly/pure-ts/core";
-import { describe, expect, it } from "vitest";
-
-import {
-	type AnomalyResult,
-	contentModerationGraph,
-	dataQualityGraph,
-	type ExtractedIssue,
-	issueTrackerGraph,
-	type ModerationResult,
-	observabilityGraph,
-	type ValidationResult,
-} from "../../../utils/domain-templates/index.js";
-
-// ---------------------------------------------------------------------------
-// observabilityGraph
-// ---------------------------------------------------------------------------
-
-describe("observabilityGraph", () => {
-	it("creates a graph with well-known nodes", () => {
-		const source = node<unknown>([], { initial: null });
-		const g = observabilityGraph("obs", { source });
-		const desc = g.describe();
-
-		expect(desc.name).toBe("obs");
-		expect(desc.nodes).toHaveProperty("source");
-		expect(desc.nodes).toHaveProperty("correlate");
-		expect(desc.nodes).toHaveProperty("slo_value");
-		expect(desc.nodes).toHaveProperty("slo_verified");
-		expect(desc.nodes).toHaveProperty("alerts");
-		expect(desc.nodes).toHaveProperty("output");
-	});
-
-	it("stratifies signals into branches by default", () => {
-		const source = node<unknown>([], { initial: null });
-		const g = observabilityGraph("obs", { source });
-		const desc = g.describe();
-
-		expect(desc.nodes).toHaveProperty("stratify::branch/errors");
-		expect(desc.nodes).toHaveProperty("stratify::branch/traces");
-		expect(desc.nodes).toHaveProperty("stratify::branch/metrics");
-	});
-
-	it("accepts custom branches", () => {
-		const source = node<unknown>([], { initial: null });
-		const g = observabilityGraph("obs", {
-			source,
-			branches: [{ name: "logs", classify: (v) => (v as Record<string, unknown>)?.type === "log" }],
-		});
-		const desc = g.describe();
-		expect(desc.nodes).toHaveProperty("stratify::branch/logs");
-	});
-
-	it("correlate node receives branch values", () => {
-		const source = node<unknown>([], { initial: null });
-		let correlatedValues: unknown[] | null = null;
-		const g = observabilityGraph("obs", {
-			source,
-			correlate: (vals) => {
-				correlatedValues = vals as unknown[];
-				return { correlated: true };
-			},
-		});
-
-		// Activate output chain
-		const output = g.node("output");
-		output.subscribe(() => {});
-
-		// Emit a signal
-		source.down([[DATA, { type: "error", msg: "fail" }]]);
-		expect(correlatedValues).not.toBeNull();
-	});
-
-	it("SLO check defaults to pass", () => {
-		const source = node<unknown>([], { initial: null });
-		const g = observabilityGraph("obs", { source });
-
-		const slo = g.node("slo_verified");
-		slo.subscribe(() => {});
-		const output = g.node("output");
-		output.subscribe(() => {});
-
-		source.down([[DATA, { type: "error", msg: "test" }]]);
-		const result = slo.cache as Record<string, unknown>;
-		expect(result).toEqual({ pass: true });
-	});
-
-	it("feedback wires up for SLO failures", () => {
-		const source = node<unknown>([], { initial: null });
-		const g = observabilityGraph("obs", {
-			source,
-			sloCheck: () => ({ pass: false, reason: "latency" }),
-			maxFeedbackIterations: 2,
-		});
-		const desc = g.describe();
-
-		expect(desc.nodes).toHaveProperty("feedback_reentry");
-		expect(desc.nodes).toHaveProperty("feedback_condition");
-	});
-
-	it("graph is destroyable", () => {
-		const source = node<unknown>([], { initial: null });
-		const g = observabilityGraph("obs", { source });
-		expect(() => g.destroy()).not.toThrow();
-	});
-});
-
-// ---------------------------------------------------------------------------
-// issueTrackerGraph
-// ---------------------------------------------------------------------------
-
-describe("issueTrackerGraph", () => {
-	it("creates a graph with well-known nodes", () => {
-		const source = node<unknown>([], { initial: null });
-		const g = issueTrackerGraph("issues", { source });
-		const desc = g.describe();
-
-		expect(desc.name).toBe("issues");
-		expect(desc.nodes).toHaveProperty("source");
-		expect(desc.nodes).toHaveProperty("extract");
-		expect(desc.nodes).toHaveProperty("verify");
-		expect(desc.nodes).toHaveProperty("known_patterns");
-		expect(desc.nodes).toHaveProperty("regression");
-		expect(desc.nodes).toHaveProperty("priority");
-		expect(desc.nodes).toHaveProperty("output");
-	});
-
-	it("extracts structured issues from raw findings", () => {
-		const source = node<unknown>([], { initial: null });
-		const g = issueTrackerGraph("issues", {
-			source,
-			extract: (raw) => ({
-				id: "issue-1",
-				title: String(raw),
-				severity: 3,
-				source: "test",
-				raw,
-			}),
-		});
-
-		const extract = g.node("extract");
-		extract.subscribe(() => {});
-		const output = g.node("output");
-		output.subscribe(() => {});
-
-		source.down([[DATA, "found a bug"]]);
-		const issue = extract.cache as ExtractedIssue;
-		expect(issue.id).toBe("issue-1");
-		expect(issue.severity).toBe(3);
-	});
-
-	it("verify defaults to valid", () => {
-		const source = node<unknown>([], { initial: null });
-		const g = issueTrackerGraph("issues", { source });
-
-		const verify = g.node("verify");
-		verify.subscribe(() => {});
-		const output = g.node("output");
-		output.subscribe(() => {});
-
-		source.down([[DATA, "test finding"]]);
-		const result = verify.cache as Record<string, unknown>;
-		expect(result.verification).toEqual({ valid: true });
-	});
-
-	it("regression detection works with custom fn", () => {
-		const source = node<unknown>([], { initial: null });
-		const g = issueTrackerGraph("issues", {
-			source,
-			detectRegression: (issue, _known) => ({
-				regression: issue.severity > 2,
-			}),
-		});
-
-		const regression = g.node("regression");
-		regression.subscribe(() => {});
-		const output = g.node("output");
-		output.subscribe(() => {});
-
-		source.down([[DATA, "critical bug"]]);
-		const result = regression.cache as Record<string, unknown>;
-		expect(result).toHaveProperty("regression");
-	});
-
-	it("priority scorer combines severity and regression signals", () => {
-		const source = node<unknown>([], { initial: null });
-		const g = issueTrackerGraph("issues", {
-			source,
-			extract: (raw) => ({
-				id: "1",
-				title: String(raw),
-				severity: 5,
-				source: "test",
-				raw,
-			}),
-			detectRegression: () => ({ regression: true }),
-		});
-
-		const priority = g.node("priority");
-		priority.subscribe(() => {});
-		const output = g.node("output");
-		output.subscribe(() => {});
-
-		source.down([[DATA, "regression bug"]]);
-		const scored = priority.cache as { score: number };
-		// severity=5 * weight=1 + regression=2 * weight=1.5 = 8
-		expect(scored.score).toBe(8);
-	});
-});
-
-// ---------------------------------------------------------------------------
-// contentModerationGraph
-// ---------------------------------------------------------------------------
-
-describe("contentModerationGraph", () => {
-	it("creates a graph with well-known nodes", () => {
-		const source = node<unknown>([], { initial: null });
-		const g = contentModerationGraph("moderation", { source });
-		const desc = g.describe();
-
-		expect(desc.name).toBe("moderation");
-		expect(desc.nodes).toHaveProperty("source");
-		expect(desc.nodes).toHaveProperty("classify");
-		expect(desc.nodes).toHaveProperty("review_queue");
-		expect(desc.nodes).toHaveProperty("policy");
-		expect(desc.nodes).toHaveProperty("priority");
-		expect(desc.nodes).toHaveProperty("output");
-	});
-
-	it("stratifies into safe/review/block branches", () => {
-		const source = node<unknown>([], { initial: null });
-		const g = contentModerationGraph("moderation", { source });
-		const desc = g.describe();
-
-		expect(desc.nodes).toHaveProperty("stratify::branch/safe");
-		expect(desc.nodes).toHaveProperty("stratify::branch/review");
-		expect(desc.nodes).toHaveProperty("stratify::branch/block");
-	});
-
-	it("classify defaults to review", () => {
-		const source = node<unknown>([], { initial: null });
-		const g = contentModerationGraph("moderation", { source });
-
-		const classify = g.node("classify");
-		classify.subscribe(() => {});
-		const output = g.node("output");
-		output.subscribe(() => {});
-
-		source.down([[DATA, "some content"]]);
-		const result = classify.cache as ModerationResult;
-		expect(result.label).toBe("review");
-		expect(result.confidence).toBe(0.5);
-	});
-
-	it("custom classify routes correctly", () => {
-		const source = node<unknown>([], { initial: null });
-		const g = contentModerationGraph("moderation", {
-			source,
-			classify: (content) => ({
-				label: String(content).includes("bad") ? "block" : "safe",
-				confidence: 0.9,
-				original: content,
-			}),
-		});
-
-		const classify = g.node("classify");
-		classify.subscribe(() => {});
-		const output = g.node("output");
-		output.subscribe(() => {});
-
-		source.down([[DATA, "bad content"]]);
-		const result = classify.cache as ModerationResult;
-		expect(result.label).toBe("block");
-	});
-
-	it("policy is writable state", () => {
-		const source = node<unknown>([], { initial: null });
-		const g = contentModerationGraph("moderation", { source });
-
-		const policy = g.node("policy");
-		policy.down([[DATA, { blockProfanity: true }]]);
-		expect(policy.cache).toEqual({ blockProfanity: true });
-	});
-});
-
-// ---------------------------------------------------------------------------
-// dataQualityGraph
-// ---------------------------------------------------------------------------
-
-describe("dataQualityGraph", () => {
-	it("creates a graph with well-known nodes", () => {
-		const source = node<unknown>([], { initial: null });
-		const g = dataQualityGraph("dq", { source });
-		const desc = g.describe();
-
-		expect(desc.name).toBe("dq");
-		expect(desc.nodes).toHaveProperty("source");
-		expect(desc.nodes).toHaveProperty("validate");
-		expect(desc.nodes).toHaveProperty("anomaly");
-		expect(desc.nodes).toHaveProperty("baseline");
-		expect(desc.nodes).toHaveProperty("drift");
-		expect(desc.nodes).toHaveProperty("remediate");
-		expect(desc.nodes).toHaveProperty("output");
-	});
-
-	it("validate defaults to valid", () => {
-		const source = node<unknown>([], { initial: null });
-		const g = dataQualityGraph("dq", { source });
-
-		const validate = g.node("validate");
-		validate.subscribe(() => {});
-		const output = g.node("output");
-		output.subscribe(() => {});
-
-		source.down([[DATA, { id: 1, name: "test" }]]);
-		const result = validate.cache as ValidationResult;
-		expect(result.valid).toBe(true);
-		expect(result.errors).toEqual([]);
-	});
-
-	it("custom validation catches invalid records", () => {
-		const source = node<unknown>([], { initial: null });
-		const g = dataQualityGraph("dq", {
-			source,
-			validate: (record) => {
-				const r = record as Record<string, unknown>;
-				const errors: string[] = [];
-				if (!r.name) errors.push("missing name");
-				return { valid: errors.length === 0, errors, record };
-			},
-		});
-
-		// Activate the full chain so derived nodes compute
-		const output = g.node("output");
-		output.subscribe(() => {});
-		const validate = g.node("validate");
-		validate.subscribe(() => {});
-
-		source.down([[DATA, { id: 1 }]]);
-		const result = validate.cache as ValidationResult;
-		expect(result.valid).toBe(false);
-		expect(result.errors).toContain("missing name");
-	});
-
-	it("anomaly detection works", () => {
-		const source = node<unknown>([], { initial: null });
-		const g = dataQualityGraph("dq", {
-			source,
-			detectAnomaly: (record) => {
-				const r = record as Record<string, number>;
-				return {
-					anomaly: r.value > 100,
-					score: r.value > 100 ? 0.9 : 0,
-					record,
-				};
-			},
-		});
-
-		// Activate the full chain
-		const output = g.node("output");
-		output.subscribe(() => {});
-		const anomaly = g.node("anomaly");
-		anomaly.subscribe(() => {});
-
-		source.down([[DATA, { value: 999 }]]);
-		const result = anomaly.cache as AnomalyResult;
-		expect(result.anomaly).toBe(true);
-		expect(result.score).toBe(0.9);
-	});
-
-	it("baseline updates on valid records", () => {
-		const source = node<unknown>([], { initial: null });
-		const g = dataQualityGraph("dq", { source });
-
-		// Activate the full chain including baseline updater effect
-		const output = g.node("output");
-		output.subscribe(() => {});
-		const baselineUpdater = g.node("__baseline_updater");
-		baselineUpdater.subscribe(() => {});
-
-		const baseline = g.node("baseline");
-
-		source.down([[DATA, { id: 1, name: "valid" }]]);
-		expect(baseline.cache).toEqual({ id: 1, name: "valid" });
-	});
-
-	it("output combines all quality checks", () => {
-		const source = node<unknown>([], { initial: null });
-		const g = dataQualityGraph("dq", { source });
-
-		const output = g.node("output");
-		output.subscribe(() => {});
-
-		source.down([[DATA, { id: 1, name: "test" }]]);
-		const result = output.cache as Record<string, unknown>;
-		expect(result).toHaveProperty("validation");
-		expect(result).toHaveProperty("anomaly");
-		expect(result).toHaveProperty("drift");
-		expect(result).toHaveProperty("remediation");
-	});
-
-	it("feedback wires anomalies to validation rules", () => {
-		const source = node<unknown>([], { initial: null });
-		const g = dataQualityGraph("dq", {
-			source,
-			detectAnomaly: (record) => ({
-				anomaly: true,
-				score: 1,
-				record,
-			}),
-		});
-		const desc = g.describe();
-
-		expect(desc.nodes).toHaveProperty("validation_rules");
-		expect(desc.nodes).toHaveProperty("feedback_condition");
-	});
-
-	it("graph is destroyable", () => {
-		const source = node<unknown>([], { initial: null });
-		const g = dataQualityGraph("dq", { source });
-		expect(() => g.destroy()).not.toThrow();
-	});
-});
diff --git a/src/__tests__/utils/graphspec/factory-tags-audit.test.ts b/src/__tests__/utils/graphspec/factory-tags-audit.test.ts
deleted file mode 100644
index 0fd9695b..00000000
--- a/src/__tests__/utils/graphspec/factory-tags-audit.test.ts
+++ /dev/null
@@ -1,48 +0,0 @@
-/**
- * Tier 1.5.3 Phase 2.5 — factory tagging for audit-layer factories.
- *
- * Mirrors `factory-tags-orchestration.test.ts`. Verifies that `policyGate`
- * (the renamed-from-`policyEnforcer` ABAC factory shipped in Tier 2.3)
- * self-tags via `g.tagFactory("policyGate", placeholderArgs(opts))` so
- * `graph.describe()` surfaces `factory: "policyGate"` provenance.
- *
- * `factoryArgs` is routed through `placeholderArgs` (DG2=ii) for non-JSON
- * fields, so we assert presence + select primitive fields rather than deep
- * equality.
- */
-
-import { node } from "@graphrefly/pure-ts/core";
-import { Graph } from "@graphrefly/pure-ts/graph";
-import { describe, expect, it } from "vitest";
-import { policyGate } from "../../../utils/inspect/audit.js";
-
-describe("Tier 1.5.3 Phase 2.5 — factory tags (audit)", () => {
-	it("policyGate tags the PolicyGateGraph with factory='policyGate' and factoryArgs", () => {
-		const target = new Graph("target");
-		target.add(node([], { name: "x", initial: 0 }), { name: "x" });
-
-		const gate = policyGate(target, [{ effect: "allow", action: "write" }], {
-			mode: "audit",
-			violationsLimit: 256,
-			name: "guard",
-		});
-
-		const out = gate.describe();
-		expect(out.factory).toBe("policyGate");
-		expect(out.factoryArgs).toBeDefined();
-		const args = out.factoryArgs as Record<string, unknown>;
-		expect(args.mode).toBe("audit");
-		expect(args.violationsLimit).toBe(256);
-		expect(args.name).toBe("guard");
-	});
-
-	it("policyGate tags with default opts — factoryArgs is the empty placeholder object", () => {
-		const target = new Graph("target");
-		target.add(node([], { name: "x", initial: 0 }), { name: "x" });
-
-		const gate = policyGate(target, []);
-		const out = gate.describe();
-		expect(out.factory).toBe("policyGate");
-		expect(out.factoryArgs).toEqual({});
-	});
-});
diff --git a/src/__tests__/utils/graphspec/factory-tags-bundles.test.ts b/src/__tests__/utils/graphspec/factory-tags-bundles.test.ts
deleted file mode 100644
index 645334ce..00000000
--- a/src/__tests__/utils/graphspec/factory-tags-bundles.test.ts
+++ /dev/null
@@ -1,131 +0,0 @@
-/**
- * Tier 1.5.3 Phase 2.5 design session — bundle-factory tagging (DT1=B, DT2=table-picks).
- *
- * Verifies that bundle-returning factories tag their primary output node with
- * `meta.factory: "<name>"`. compileSpec round-trip via these tags is lossy
- * (you can't recreate a bundle from one tagged node), but provenance / audit /
- * LLM-prompt value is preserved per the design session locks.
- *
- * Skipped (need LLM adapter mocks): streamingPromptNode, gatedStream — same
- * tagging pattern via switchMap-`opts.meta` override; covered in [streaming.ts]
- * indirectly via the existing AI-tests when they exercise the bundles.
- */
-
-import { node } from "@graphrefly/pure-ts/core";
-import { Graph } from "@graphrefly/pure-ts/graph";
-import { describe, expect, it } from "vitest";
-import { distill } from "../../../base/composition/distill.js";
-import { verifiable } from "../../../base/composition/verifiable.js";
-import { withStatus } from "../../../base/resilience/status.js";
-import { handoff } from "../../../utils/ai/agents/handoff.js";
-import { toolSelector } from "../../../utils/ai/agents/tool-selector.js";
-import { circuitBreaker, withBreaker } from "../../../utils/resilience/breaker.js";
-import { fallback } from "../../../utils/resilience/fallback.js";
-
-describe("Tier 1.5.3 Phase 2.5 — bundle-factory primary-node tagging", () => {
-	it("verifiable.verified self-tags with factory: 'verifiable'", () => {
-		const src = node([], { initial: 0 });
-		const bundle = verifiable(src, (v) => ({ ok: (v as number) >= 0 }));
-		const off = bundle.verified.subscribe(() => {});
-		const g = new Graph("g");
-		g.add(bundle.verified, { name: "verified" });
-		expect(g.describe({ detail: "spec" }).nodes.verified?.meta?.factory).toBe("verifiable");
-		off();
-	});
-
-	it("distill.compact self-tags with factory: 'distill'", () => {
-		const src = node([], { initial: "seed" });
-		const bundle = distill<string, { text: string }>(
-			src,
-			(_rawNode) => {
-				// Simple sync extractor; the new reactive extractFn shape from Tier 1.5.4.
-				// rawNode unused because this test only checks the tag, not the extraction.
-				return node([], { initial: { upsert: [{ key: "k", value: { text: "v" } }] } });
-			},
-			{ score: () => 1, cost: () => 1, budget: 100 },
-		);
-		const off = bundle.compact.subscribe(() => {});
-		const g = new Graph("g");
-		g.add(bundle.compact, { name: "compact" });
-		const meta = g.describe({ detail: "spec" }).nodes.compact?.meta;
-		expect(meta?.factory).toBe("distill");
-		expect((meta?.factoryArgs as { budget: number }).budget).toBe(100);
-		off();
-	});
-
-	it("withStatus.node self-tags with factory: 'withStatus'", () => {
-		const src = node([], { initial: 0 });
-		const bundle = withStatus(src);
-		const off = bundle.node.subscribe(() => {});
-		const g = new Graph("g");
-		g.add(bundle.node, { name: "wrapped" });
-		const meta = g.describe({ detail: "spec" }).nodes.wrapped?.meta;
-		expect(meta?.factory).toBe("withStatus");
-		expect((meta?.factoryArgs as { initialStatus: string }).initialStatus).toBe("pending");
-		off();
-	});
-
-	it("withBreaker.node self-tags with factory: 'withBreaker'", () => {
-		const breaker = circuitBreaker();
-		const wrap = withBreaker(breaker, { onOpen: "skip" });
-		const src = node([], { initial: 0 });
-		const bundle = wrap(src);
-		const off = bundle.node.subscribe(() => {});
-		const g = new Graph("g");
-		g.add(bundle.node, { name: "wrapped" });
-		const meta = g.describe({ detail: "spec" }).nodes.wrapped?.meta;
-		expect(meta?.factory).toBe("withBreaker");
-		expect((meta?.factoryArgs as { onOpen: string }).onOpen).toBe("skip");
-		off();
-	});
-
-	it("fallback self-tags with factory: 'fallback' (name-only per DT4)", () => {
-		const src = node([], { initial: 0 });
-		const fb = fallback(src, 99);
-		const off = fb.subscribe(() => {});
-		const g = new Graph("g");
-		g.add(fb, { name: "fb" });
-		const meta = g.describe({ detail: "spec" }).nodes.fb?.meta;
-		expect(meta?.factory).toBe("fallback");
-		// DT4: name-only tag — factoryArgs is omitted because `fb` is non-JSON.
-		expect("factoryArgs" in (meta ?? {})).toBe(false);
-		off();
-	});
-
-	it("handoff (no condition branch) self-tags with factory: 'handoff'", () => {
-		const src = node<number | null>([], { initial: null });
-		const result = handoff<number>(src, (input) => input);
-		const off = result.subscribe(() => {});
-		const g = new Graph("g");
-		g.add(result, { name: "h" });
-		expect(g.describe({ detail: "spec" }).nodes.h?.meta?.factory).toBe("handoff");
-		off();
-	});
-
-	it("handoff (condition branch) self-tags with factory: 'handoff'", () => {
-		const src = node<number | null>([], { initial: null });
-		const cond = node([], { initial: true });
-		const result = handoff<number>(src, (input) => input, { condition: cond });
-		const off = result.subscribe(() => {});
-		const g = new Graph("g");
-		g.add(result, { name: "h" });
-		expect(g.describe({ detail: "spec" }).nodes.h?.meta?.factory).toBe("handoff");
-		off();
-	});
-
-	it("toolSelector self-tags with factory: 'toolSelector'", () => {
-		const allTools = node([], {
-			initial: [
-				{ name: "a", description: "tool a", parameters: { type: "object", properties: {} } },
-				{ name: "b", description: "tool b", parameters: { type: "object", properties: {} } },
-			],
-		});
-		const cond = node([], { initial: () => true });
-		const filtered = toolSelector(allTools, [cond]);
-		const off = filtered.subscribe(() => {});
-		const g = new Graph("g");
-		g.add(filtered, { name: "tools" });
-		expect(g.describe({ detail: "spec" }).nodes.tools?.meta?.factory).toBe("toolSelector");
-		off();
-	});
-});
diff --git a/src/__tests__/utils/graphspec/factory-tags-memory-harness.test.ts b/src/__tests__/utils/graphspec/factory-tags-memory-harness.test.ts
deleted file mode 100644
index a7477bcb..00000000
--- a/src/__tests__/utils/graphspec/factory-tags-memory-harness.test.ts
+++ /dev/null
@@ -1,69 +0,0 @@
-/**
- * Tier 1.5.3 Phase 2.5 — factory tagging for memory + harness + agent factories.
- *
- * Verifies that each Graph-returning factory (`agentMemory`, `harnessLoop`,
- * `agentLoop`) calls `g.tagFactory(...)` so `graph.describe()` surfaces
- * `factory` + `factoryArgs` provenance. `factoryArgs` is routed through
- * `placeholderArgs` (DG2=ii) for non-JSON fields, so we only assert
- * presence + select primitive fields rather than deep equality.
- */
-
-import { describe, expect, it } from "vitest";
-import { agentLoop } from "../../../presets/ai/agent-loop.js";
-import { agentMemory } from "../../../presets/ai/agent-memory.js";
-import { harnessLoop } from "../../../presets/harness/harness-loop.js";
-import { mockLLM } from "../../../testing/mock-llm.js";
-
-describe("Tier 1.5.3 Phase 2.5 — factory tags (memory + harness + agent)", () => {
-	it("agentMemory tags the Graph with factory='agentMemory' and factoryArgs", () => {
-		const g = agentMemory<string>("mem", null, {
-			score: () => 1,
-			cost: () => 1,
-			budget: 1000,
-			extractFn: () => ({ upsert: [] }),
-		});
-
-		const out = g.describe();
-		expect(out.factory).toBe("agentMemory");
-		expect(out.factoryArgs).toBeDefined();
-		const args = out.factoryArgs as Record<string, unknown>;
-		// JSON-friendly primitives survive placeholderArgs verbatim.
-		expect(args.budget).toBe(1000);
-		// Function-typed args become "<function>" placeholders.
-		expect(args.extractFn).toBe("<function>");
-		expect(args.score).toBe("<function>");
-		expect(args.cost).toBe("<function>");
-	});
-
-	it("harnessLoop tags the HarnessGraph with factory='harnessLoop' and factoryArgs", () => {
-		const adapter = mockLLM();
-		const g = harnessLoop("h", {
-			adapter,
-			maxRetries: 3,
-		});
-
-		const out = g.describe();
-		expect(out.factory).toBe("harnessLoop");
-		expect(out.factoryArgs).toBeDefined();
-		const args = out.factoryArgs as Record<string, unknown>;
-		expect(args.maxRetries).toBe(3);
-		// adapter is an object with function members → placeholder-walked into
-		// a nested object (e.g. `{ invoke: "<function>", ... }`).
-		expect(typeof args.adapter).toBe("object");
-	});
-
-	it("agentLoop tags the AgentLoopGraph with factory='agentLoop' and factoryArgs", () => {
-		const adapter = mockLLM();
-		const g = agentLoop("a", {
-			adapter,
-			maxTurns: 5,
-		});
-
-		const out = g.describe();
-		expect(out.factory).toBe("agentLoop");
-		expect(out.factoryArgs).toBeDefined();
-		const args = out.factoryArgs as Record<string, unknown>;
-		expect(args.maxTurns).toBe(5);
-		expect(typeof args.adapter).toBe("object");
-	});
-});
diff --git a/src/__tests__/utils/graphspec/factory-tags-orchestration.test.ts b/src/__tests__/utils/graphspec/factory-tags-orchestration.test.ts
deleted file mode 100644
index 08d0fce8..00000000
--- a/src/__tests__/utils/graphspec/factory-tags-orchestration.test.ts
+++ /dev/null
@@ -1,65 +0,0 @@
-/**
- * Tier 1.5.3 Phase 2.5 — factory tagging for orchestration-layer factories.
- *
- * Verifies that each Graph-returning factory in this slice (`cqrs`,
- * `jobFlow`) calls `g.tagFactory(...)` so `graph.describe()` surfaces
- * `factory` + `factoryArgs` provenance. `factoryArgs` is routed through
- * `placeholderArgs` (DG2=ii) for non-JSON fields, so we only assert
- * presence + select primitive fields rather than deep equality.
- *
- * NOTE: `processManager` does NOT return a Graph (it returns a
- * `ProcessManagerResult` and mounts on a host `CqrsGraph`), so it is
- * intentionally excluded from this slice — there is no Graph instance
- * to tag.
- */
-
-import { describe, expect, it } from "vitest";
-import { cqrs } from "../../../utils/cqrs/index.js";
-import { jobFlow } from "../../../utils/job-queue/index.js";
-
-describe("Tier 1.5.3 Phase 2.5 — factory tags (orchestration)", () => {
-	it("cqrs tags the CqrsGraph with factory='cqrs' and factoryArgs", () => {
-		const g = cqrs("orders", {
-			retainedLimit: 256,
-			freezeCommandPayload: false,
-			maxAggregates: 500,
-		});
-
-		const out = g.describe();
-		expect(out.factory).toBe("cqrs");
-		expect(out.factoryArgs).toBeDefined();
-		const args = out.factoryArgs as Record<string, unknown>;
-		expect(args.retainedLimit).toBe(256);
-		expect(args.freezeCommandPayload).toBe(false);
-		expect(args.maxAggregates).toBe(500);
-	});
-
-	it("cqrs tags with no opts — factoryArgs is the empty placeholder object", () => {
-		const g = cqrs("bare");
-		const out = g.describe();
-		expect(out.factory).toBe("cqrs");
-		expect(out.factoryArgs).toEqual({});
-	});
-
-	it("jobFlow tags the JobFlowGraph with factory='jobFlow' and factoryArgs", () => {
-		const g = jobFlow<{ id: string }>("flow", {
-			stages: ["incoming", { name: "processing", work: async (env) => env.payload }, "done"],
-			maxPerPump: 64,
-		});
-
-		const out = g.describe();
-		expect(out.factory).toBe("jobFlow");
-		expect(out.factoryArgs).toBeDefined();
-		const args = out.factoryArgs as Record<string, unknown>;
-		expect(args.maxPerPump).toBe(64);
-		// `stages` walked by placeholderArgs: strings stay strings, the
-		// processing entry's `work` becomes "<function>".
-		const stages = args.stages as Array<unknown>;
-		expect(stages[0]).toBe("incoming");
-		expect(stages[1]).toEqual({
-			name: "processing",
-			work: "<function>",
-		});
-		expect(stages[2]).toBe("done");
-	});
-});
diff --git a/src/__tests__/utils/graphspec/graphspec.test.ts b/src/__tests__/utils/graphspec/graphspec.test.ts
deleted file mode 100644
index 898c412d..00000000
--- a/src/__tests__/utils/graphspec/graphspec.test.ts
+++ /dev/null
@@ -1,908 +0,0 @@
-import { DATA, factoryTag, type Messages, node } from "@graphrefly/pure-ts/core";
-import { Graph } from "@graphrefly/pure-ts/graph";
-import { describe, expect, it } from "vitest";
-import type { ChatMessage, LLMAdapter, LLMResponse } from "../../../utils/ai/index.js";
-import {
-	compileSpec,
-	decompileSpec,
-	type GraphSpec,
-	type GraphSpecCatalog,
-	llmCompose,
-	llmRefine,
-	specDiff,
-	validateOwnership,
-	validateSpec,
-} from "../../../utils/graphspec/index.js";
-
-// ---------------------------------------------------------------------------
-// helpers
-// ---------------------------------------------------------------------------
-
-function mockAdapter(responses: LLMResponse[]): LLMAdapter {
-	let idx = 0;
-	return {
-		invoke(_msgs: readonly ChatMessage[], _opts?: unknown) {
-			return Promise.resolve(responses[idx++]!);
-		},
-		stream: (async function* () {})(),
-	} as LLMAdapter;
-}
-
-/** Catalog with simple fns for testing. */
-const testCatalog: GraphSpecCatalog = {
-	fns: {
-		double: (deps) =>
-			node(
-				deps,
-				(batchData, actions, ctx) => {
-					const data = batchData.map((batch, i) =>
-						batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-					);
-					actions.emit((data[0] as number) * 2);
-				},
-				{ describeKind: "derived" },
-			),
-		sum: (deps) =>
-			node(
-				deps,
-				(batchData, actions, ctx) => {
-					const data = batchData.map((batch, i) =>
-						batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-					);
-					actions.emit((data as number[]).reduce((a, b) => a + b, 0));
-				},
-				{ describeKind: "derived" },
-			),
-		logEffect: (deps) =>
-			node(
-				deps,
-				(batchData, actions, ctx) => {
-					const data = batchData.map((batch, i) =>
-						batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-					);
-					return (
-						(() => {
-							/* side effect */
-						})(data, actions, ctx) ?? undefined
-					);
-				},
-				{ describeKind: "effect" },
-			),
-		identity: (deps) =>
-			node(
-				deps,
-				(batchData, actions, ctx) => {
-					const data = batchData.map((batch, i) =>
-						batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-					);
-					actions.emit(data[0]);
-				},
-				{ describeKind: "derived" },
-			),
-		timeout: (deps, _config) =>
-			node(
-				deps,
-				(batchData, actions, ctx) => {
-					const data = batchData.map((batch, i) =>
-						batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-					);
-					actions.emit(data[0]);
-				},
-				{ describeKind: "derived" },
-			), // simplified
-		retry: (deps, _config) =>
-			node(
-				deps,
-				(batchData, actions, ctx) => {
-					const data = batchData.map((batch, i) =>
-						batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-					);
-					actions.emit(data[0]);
-				},
-				{ describeKind: "derived" },
-			), // simplified
-		fallback: (deps, _config) =>
-			node(
-				deps,
-				(batchData, actions, ctx) => {
-					const data = batchData.map((batch, i) =>
-						batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-					);
-					actions.emit(data[0]);
-				},
-				{ describeKind: "derived" },
-			), // simplified
-	},
-	sources: {
-		"rest-api": (config) => node([], { meta: { source: "rest-api", ...config }, initial: null }),
-	},
-};
-
-// ---------------------------------------------------------------------------
-// validateSpec
-// ---------------------------------------------------------------------------
-
-describe("graphspec.validateSpec", () => {
-	it("validates a minimal valid spec", () => {
-		const spec: GraphSpec = {
-			name: "test",
-			nodes: {
-				a: { type: "state", deps: [], value: 1 },
-			},
-		};
-		const result = validateSpec(spec);
-		expect(result.valid).toBe(true);
-		expect(result.errors).toEqual([]);
-	});
-
-	it("rejects null input", () => {
-		expect(validateSpec(null).valid).toBe(false);
-	});
-
-	it("rejects missing name", () => {
-		const result = validateSpec({ nodes: {} });
-		expect(result.valid).toBe(false);
-		expect(result.errors[0]).toContain("name");
-	});
-
-	it("rejects invalid node type", () => {
-		const result = validateSpec({
-			name: "t",
-			nodes: { x: { type: "bogus" } },
-		});
-		expect(result.valid).toBe(false);
-		expect(result.errors[0]).toContain("invalid type");
-	});
-
-	it("rejects dep referencing non-existent node", () => {
-		const result = validateSpec({
-			name: "t",
-			nodes: {
-				a: { type: "derived", deps: ["missing"] },
-			},
-		});
-		expect(result.valid).toBe(false);
-		expect(result.errors[0]).toContain("missing");
-	});
-
-	it("validates template refs", () => {
-		const spec = {
-			name: "t",
-			templates: {
-				resilient: {
-					params: ["$source"],
-					nodes: {
-						inner: {
-							type: "derived",
-							deps: ["$source"],
-							meta: { ...factoryTag("identity") },
-						},
-					},
-					output: "inner",
-				},
-			},
-			nodes: {
-				src: { type: "state", deps: [], value: 0 },
-				wrapped: { type: "template", template: "resilient", bind: { $source: "src" } },
-			},
-		};
-		expect(validateSpec(spec).valid).toBe(true);
-	});
-
-	it("rejects template ref to non-existent template", () => {
-		const result = validateSpec({
-			name: "t",
-			nodes: {
-				wrapped: { type: "template", template: "missing", bind: {} },
-			},
-		});
-		expect(result.valid).toBe(false);
-		expect(result.errors[0]).toContain("not found");
-	});
-
-	it("validates feedback edges", () => {
-		const spec = {
-			name: "t",
-			nodes: {
-				interval: { type: "state", deps: [], value: 10000 },
-				compute: {
-					type: "derived",
-					deps: ["interval"],
-					meta: { ...factoryTag("double") },
-				},
-			},
-			feedback: [{ from: "compute", to: "interval", maxIterations: 5 }],
-		};
-		expect(validateSpec(spec).valid).toBe(true);
-	});
-
-	it("rejects feedback edge referencing non-existent node", () => {
-		const result = validateSpec({
-			name: "t",
-			nodes: { a: { type: "state", deps: [] } },
-			feedback: [{ from: "a", to: "missing" }],
-		});
-		expect(result.valid).toBe(false);
-		expect(result.errors[0]).toContain("missing");
-	});
-
-	it("rejects template with bad output ref", () => {
-		const result = validateSpec({
-			name: "t",
-			templates: {
-				bad: { params: [], nodes: { x: { type: "state", deps: [] } }, output: "nonexistent" },
-			},
-			nodes: {},
-		});
-		expect(result.valid).toBe(false);
-		expect(result.errors[0]).toContain("output");
-	});
-
-	it("rejects self-referencing deps", () => {
-		const result = validateSpec({
-			name: "t",
-			nodes: { a: { type: "derived", deps: ["a"] } },
-		});
-		expect(result.valid).toBe(false);
-		expect(result.errors[0]).toContain("self-referencing");
-	});
-
-	it("warns when derived/effect has no deps", () => {
-		const result = validateSpec({
-			name: "t",
-			nodes: { a: { type: "derived", meta: { ...factoryTag("identity") } } },
-		});
-		expect(result.valid).toBe(false);
-		expect(result.errors[0]).toContain("should have");
-	});
-
-	it("rejects feedback to non-state node", () => {
-		const result = validateSpec({
-			name: "t",
-			nodes: {
-				a: { type: "state", deps: [], value: 0 },
-				b: { type: "derived", deps: ["a"], meta: { ...factoryTag("double") } },
-			},
-			feedback: [{ from: "a", to: "b" }],
-		});
-		expect(result.valid).toBe(false);
-		expect(result.errors[0]).toContain("must be a state node");
-	});
-
-	it("rejects incomplete template bind", () => {
-		const result = validateSpec({
-			name: "t",
-			templates: {
-				tmpl: { params: ["$a", "$b"], nodes: { x: { type: "state", deps: [] } }, output: "x" },
-			},
-			nodes: {
-				src: { type: "state", deps: [] },
-				inst: { type: "template", template: "tmpl", bind: { $a: "src" } },
-			},
-		});
-		expect(result.valid).toBe(false);
-		expect(result.errors.some((e) => e.includes("$b") && e.includes("not bound"))).toBe(true);
-	});
-});
-
-// ---------------------------------------------------------------------------
-// validateOwnership (DS-14.5.A #5 — multi-agent subgraph ownership PR lint)
-// ---------------------------------------------------------------------------
-
-describe("graphspec.validateOwnership", () => {
-	/** A 2-node spec: "rl" tagged factory "rateLimiter" owned by "agent-a". */
-	const ownedSpec = {
-		name: "g",
-		nodes: {
-			rl: { type: "derived", deps: [], meta: { factory: "rateLimiter", owner: "agent-a" } },
-			plain: { type: "state", deps: [], meta: { factory: "state" } },
-		},
-	};
-
-	it("OK when the PR author IS the owner", () => {
-		const r = validateOwnership(ownedSpec, {
-			editedFactories: ["rateLimiter"],
-			author: "agent-a",
-		});
-		expect(r.ok).toBe(true);
-		expect(r.violations).toHaveLength(0);
-		expect(r.overridden).toHaveLength(0);
-	});
-
-	it("hard-fails on cross-owner edit (author !== meta.owner)", () => {
-		const r = validateOwnership(ownedSpec, {
-			editedFactories: ["rateLimiter"],
-			author: "agent-b",
-		});
-		expect(r.ok).toBe(false);
-		expect(r.violations).toHaveLength(1);
-		expect(r.violations[0]).toMatchObject({
-			node: "rl",
-			owner: "agent-a",
-			author: "agent-b",
-			factory: "rateLimiter",
-		});
-	});
-
-	it("silent when the edited node has no meta.owner annotation", () => {
-		const r = validateOwnership(ownedSpec, {
-			editedFactories: ["state"], // maps only to `plain` (no owner)
-			author: "agent-z",
-		});
-		expect(r.ok).toBe(true);
-		expect(r.violations).toHaveLength(0);
-	});
-
-	it("silent when the diff factory maps to no spec node (unmappable)", () => {
-		const r = validateOwnership(ownedSpec, {
-			editedFactories: ["somethingUnrelated"],
-			author: "agent-b",
-		});
-		expect(r.ok).toBe(true);
-		expect(r.violations).toHaveLength(0);
-	});
-
-	it("Override-Owner trailer bypasses the hard-fail and records audit trail", () => {
-		const r = validateOwnership(ownedSpec, {
-			editedFactories: ["rateLimiter"],
-			author: "agent-b",
-			commitMessage: "fix: urgent hotfix\n\nOverride-Owner: pager incident #42",
-		});
-		expect(r.ok).toBe(true);
-		expect(r.violations).toHaveLength(0);
-		expect(r.overridden).toHaveLength(1);
-		expect(r.overridden[0]).toMatchObject({ node: "rl", owner: "agent-a" });
-		expect(r.overrideReason).toBe("pager incident #42");
-	});
-
-	it("Override-Owner trailer is case-insensitive on the key", () => {
-		const r = validateOwnership(ownedSpec, {
-			editedFactories: ["rateLimiter"],
-			author: "agent-b",
-			commitMessage: "override-owner: lowercase works",
-		});
-		expect(r.ok).toBe(true);
-		expect(r.overrideReason).toBe("lowercase works");
-	});
-
-	it("empty-reason Override-Owner trailer does NOT bypass (must be non-empty)", () => {
-		const r = validateOwnership(ownedSpec, {
-			editedFactories: ["rateLimiter"],
-			author: "agent-b",
-			commitMessage: "Override-Owner:   ",
-		});
-		expect(r.ok).toBe(false);
-		expect(r.violations).toHaveLength(1);
-		expect(r.overrideReason).toBeUndefined();
-	});
-
-	it("meta.factory mapping flags every node sharing the edited factory", () => {
-		const multi = {
-			name: "g",
-			nodes: {
-				a: { type: "derived", deps: [], meta: { factory: "shared", owner: "agent-a" } },
-				b: { type: "derived", deps: [], meta: { factory: "shared", owner: "agent-a" } },
-				c: { type: "derived", deps: [], meta: { factory: "other", owner: "agent-a" } },
-			},
-		};
-		const r = validateOwnership(multi, { editedFactories: ["shared"], author: "agent-x" });
-		expect(r.ok).toBe(false);
-		expect(r.violations.map((v) => v.node).sort()).toEqual(["a", "b"]);
-	});
-
-	it("nodes without meta.factory are never flagged (cannot map from code diff)", () => {
-		const noFactory = {
-			name: "g",
-			nodes: { x: { type: "state", deps: [], meta: { owner: "agent-a" } } },
-		};
-		const r = validateOwnership(noFactory, { editedFactories: ["anything"], author: "agent-b" });
-		expect(r.ok).toBe(true);
-		expect(r.violations).toHaveLength(0);
-	});
-
-	it("non-object / malformed spec is silently OK (no spurious lint failure)", () => {
-		expect(validateOwnership(null, { editedFactories: ["x"], author: "a" }).ok).toBe(true);
-		expect(validateOwnership({}, { editedFactories: ["x"], author: "a" }).ok).toBe(true);
-		expect(validateOwnership({ nodes: [] }, { editedFactories: ["x"], author: "a" }).ok).toBe(true);
-	});
-
-	it("empty editedFactories yields no violations (nothing was edited)", () => {
-		const r = validateOwnership(ownedSpec, { editedFactories: [], author: "agent-b" });
-		expect(r.ok).toBe(true);
-		expect(r.violations).toHaveLength(0);
-	});
-});
-
-// ---------------------------------------------------------------------------
-// compileSpec
-// ---------------------------------------------------------------------------
-
-describe("graphspec.compileSpec", () => {
-	it("compiles a simple state + derived graph", () => {
-		const spec: GraphSpec = {
-			name: "calc",
-			nodes: {
-				a: { type: "state", deps: [], value: 5 },
-				b: { type: "derived", deps: ["a"], meta: { ...factoryTag("double") } },
-			},
-		};
-
-		const g = compileSpec(spec, { catalog: testCatalog });
-		expect(g).toBeInstanceOf(Graph);
-		expect(g.name).toBe("calc");
-		expect(g.node("a").cache).toBe(5);
-
-		// Subscribe to activate derived
-		const seen: number[] = [];
-		g.observe("b").subscribe((msgs: Messages) => {
-			for (const msg of msgs) {
-				if (msg[0] === DATA) seen.push(msg[1] as number);
-			}
-		});
-
-		g.set("a", 10);
-		expect(seen).toContain(20);
-		g.destroy();
-	});
-
-	it("compiles producer nodes from source catalog", () => {
-		const spec: GraphSpec = {
-			name: "api",
-			nodes: {
-				src: {
-					type: "producer",
-					deps: [],
-					meta: { ...factoryTag("rest-api", { url: "https://example.com" }) },
-				},
-			},
-		};
-
-		const g = compileSpec(spec, { catalog: testCatalog });
-		expect(g.node("src")).toBeDefined();
-		g.destroy();
-	});
-
-	it("compiles multi-dep derived nodes", () => {
-		const spec: GraphSpec = {
-			name: "multi",
-			nodes: {
-				x: { type: "state", deps: [], value: 3 },
-				y: { type: "state", deps: [], value: 7 },
-				total: { type: "derived", deps: ["x", "y"], meta: { ...factoryTag("sum") } },
-			},
-		};
-
-		const g = compileSpec(spec, { catalog: testCatalog });
-		const seen: number[] = [];
-		g.observe("total").subscribe((msgs: Messages) => {
-			for (const msg of msgs) {
-				if (msg[0] === DATA) seen.push(msg[1] as number);
-			}
-		});
-		g.set("x", 10);
-		expect(seen).toContain(17);
-		g.destroy();
-	});
-
-	it("compiles effect nodes", () => {
-		const spec: GraphSpec = {
-			name: "fx",
-			nodes: {
-				src: { type: "state", deps: [], value: 0 },
-				log: { type: "effect", deps: ["src"], meta: { ...factoryTag("logEffect") } },
-			},
-		};
-
-		const g = compileSpec(spec, { catalog: testCatalog });
-		expect(g.node("log")).toBeDefined();
-		g.destroy();
-	});
-
-	it("throws on invalid spec", () => {
-		expect(() => compileSpec({ name: "", nodes: {} } as GraphSpec)).toThrow("invalid GraphSpec");
-	});
-
-	it("throws on unresolvable deps", () => {
-		const spec: GraphSpec = {
-			name: "bad",
-			nodes: {
-				a: { type: "derived", deps: ["b"], meta: { ...factoryTag("identity") } },
-				b: { type: "derived", deps: ["a"], meta: { ...factoryTag("identity") } },
-			},
-		};
-		// Mutual dependency without a state root — unresolvable
-		expect(() => compileSpec(spec, { catalog: testCatalog })).toThrow("unresolvable");
-	});
-
-	it("compiles template instantiations as mounted subgraphs", () => {
-		const spec: GraphSpec = {
-			name: "tmpl-test",
-			templates: {
-				resilientSource: {
-					params: ["$source"],
-					nodes: {
-						timed: {
-							type: "derived",
-							deps: ["$source"],
-							meta: { ...factoryTag("timeout", { timeoutMs: 2000 }) },
-						},
-						retried: {
-							type: "derived",
-							deps: ["timed"],
-							meta: { ...factoryTag("retry", { maxAttempts: 2 }) },
-						},
-					},
-					output: "retried",
-				},
-			},
-			nodes: {
-				api1Source: { type: "state", deps: [], value: null },
-				api1: {
-					type: "template",
-					template: "resilientSource",
-					bind: { $source: "api1Source" },
-				},
-			},
-		};
-
-		const g = compileSpec(spec, { catalog: testCatalog });
-		expect(g).toBeInstanceOf(Graph);
-		// Template creates a mounted subgraph
-		const desc = g.describe({ detail: "standard" });
-		expect(desc.subgraphs).toContain("api1");
-		g.destroy();
-	});
-
-	it("wires feedback edges via reduction.feedback()", () => {
-		const spec: GraphSpec = {
-			name: "fb-test",
-			nodes: {
-				interval: { type: "state", deps: [], value: 10000 },
-				compute: { type: "derived", deps: ["interval"], meta: { ...factoryTag("double") } },
-			},
-			feedback: [{ from: "compute", to: "interval", maxIterations: 3 }],
-		};
-
-		const g = compileSpec(spec, { catalog: testCatalog });
-		// Feedback counter node should exist
-		const desc = g.describe({ detail: "standard" });
-		const nodeNames = Object.keys(desc.nodes);
-		expect(nodeNames.some((n) => n.startsWith("__feedback_"))).toBe(true);
-		g.destroy();
-	});
-
-	it("creates placeholder for producer without catalog entry", () => {
-		const spec: GraphSpec = {
-			name: "placeholder",
-			nodes: {
-				src: { type: "producer", deps: [], meta: { ...factoryTag("unknown-source") } },
-			},
-		};
-
-		const g = compileSpec(spec);
-		expect(g.node("src")).toBeDefined();
-		g.destroy();
-	});
-
-	it("onMissing: 'error' throws listing every missing catalog entry", () => {
-		const spec: GraphSpec = {
-			name: "missing",
-			nodes: {
-				a: { type: "producer", deps: [], meta: { ...factoryTag("missing-source") } },
-				b: { type: "derived", deps: ["a"], meta: { ...factoryTag("missing-fn") } },
-			},
-		};
-		expect(() => compileSpec(spec, { onMissing: "error" })).toThrow(
-			/missing source "missing-source"/,
-		);
-		expect(() => compileSpec(spec, { onMissing: "error" })).toThrow(/missing fn "missing-fn"/);
-	});
-
-	it("onMissing: 'warn' logs each miss via onWarn callback and still returns a graph", () => {
-		const spec: GraphSpec = {
-			name: "warn",
-			nodes: {
-				a: { type: "producer", deps: [], meta: { ...factoryTag("absent") } },
-			},
-		};
-		const warnings: string[] = [];
-		const g = compileSpec(spec, {
-			onMissing: "warn",
-			onWarn: (m) => warnings.push(m),
-		});
-		expect(g.node("a")).toBeDefined();
-		expect(warnings.length).toBe(1);
-		expect(warnings[0]).toMatch(/missing source "absent"/);
-		g.destroy();
-	});
-
-	it("onMissing: 'placeholder' (default) is silent", () => {
-		const spec: GraphSpec = {
-			name: "placeholder-default",
-			nodes: {
-				a: { type: "producer", deps: [], meta: { ...factoryTag("absent") } },
-			},
-		};
-		const warnings: string[] = [];
-		const g = compileSpec(spec, { onWarn: (m) => warnings.push(m) });
-		expect(g.node("a")).toBeDefined();
-		expect(warnings.length).toBe(0);
-		g.destroy();
-	});
-});
-
-// ---------------------------------------------------------------------------
-// decompileSpec
-// ---------------------------------------------------------------------------
-
-describe("graphspec.decompileSpec", () => {
-	it("decompiles a simple graph", () => {
-		const g = new Graph("simple");
-		const a = node([], { name: "a", meta: { description: "input" }, initial: 42 });
-		g.add(a, { name: "a" });
-
-		const spec = decompileSpec(g);
-		expect(spec.name).toBe("simple");
-		expect(spec.nodes.a).toBeDefined();
-		expect(spec.nodes.a!.type).toBe("state");
-		// State nodes preserve `value` in spec projection (path (b)).
-		expect((spec.nodes.a as { value: unknown }).value).toBe(42);
-		g.destroy();
-	});
-
-	it("decompiles a graph with derived node deps", () => {
-		const g = new Graph("deps");
-		const a = node([], { name: "a", initial: 1 });
-		const b = node(
-			[a],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as number) + 1);
-			},
-			{ describeKind: "derived", name: "b" },
-		);
-		g.add(a, { name: "a" });
-		g.add(b, { name: "b" });
-		b.subscribe(() => {});
-
-		const spec = decompileSpec(g);
-		expect(spec.nodes.a!.type).toBe("state");
-		expect(spec.nodes.b!.type).toBe("derived");
-		expect((spec.nodes.b as { deps?: string[] }).deps).toEqual(["a"]);
-		g.destroy();
-	});
-
-	it("decompiles feedback edges from counter meta", () => {
-		const spec: GraphSpec = {
-			name: "fb-decompile",
-			nodes: {
-				interval: { type: "state", deps: [], value: 10000 },
-				compute: { type: "derived", deps: ["interval"], meta: { ...factoryTag("double") } },
-			},
-			feedback: [{ from: "compute", to: "interval", maxIterations: 5 }],
-		};
-
-		const g = compileSpec(spec, { catalog: testCatalog });
-		// Activate the derived node
-		g.observe("compute").subscribe(() => {});
-
-		const decompiled = decompileSpec(g);
-		expect(decompiled.feedback).toBeDefined();
-		expect(decompiled.feedback!.length).toBe(1);
-		expect(decompiled.feedback![0]!.from).toBe("compute");
-		expect(decompiled.feedback![0]!.to).toBe("interval");
-		expect(decompiled.feedback![0]!.maxIterations).toBe(5);
-		g.destroy();
-	});
-
-	it("skips meta segment nodes", () => {
-		const g = new Graph("meta-skip");
-		const a = node([], { name: "a", meta: { label: "test" }, initial: 1 });
-		g.add(a, { name: "a" });
-
-		const spec = decompileSpec(g);
-		const paths = Object.keys(spec.nodes);
-		expect(paths.every((p) => !p.includes("__meta__"))).toBe(true);
-		g.destroy();
-	});
-});
-
-// ---------------------------------------------------------------------------
-// specDiff
-// ---------------------------------------------------------------------------
-
-describe("graphspec.specDiff", () => {
-	it("reports no changes for identical specs", () => {
-		const spec: GraphSpec = {
-			name: "same",
-			nodes: { a: { type: "state", deps: [], value: 1 } },
-		};
-		const result = specDiff(spec, spec);
-		expect(result.entries).toEqual([]);
-		expect(result.summary).toBe("no changes");
-	});
-
-	it("reports added nodes", () => {
-		const a: GraphSpec = { name: "g", nodes: { x: { type: "state", deps: [] } } };
-		const b: GraphSpec = {
-			name: "g",
-			nodes: { x: { type: "state", deps: [] }, y: { type: "derived", deps: ["x"] } },
-		};
-		const result = specDiff(a, b);
-		expect(result.entries.some((e) => e.type === "added" && e.path === "nodes.y")).toBe(true);
-	});
-
-	it("reports removed nodes", () => {
-		const a: GraphSpec = {
-			name: "g",
-			nodes: { x: { type: "state", deps: [] }, y: { type: "derived", deps: ["x"] } },
-		};
-		const b: GraphSpec = { name: "g", nodes: { x: { type: "state", deps: [] } } };
-		const result = specDiff(a, b);
-		expect(result.entries.some((e) => e.type === "removed" && e.path === "nodes.y")).toBe(true);
-	});
-
-	it("reports changed node config (meta.factory + meta.factoryArgs)", () => {
-		const a: GraphSpec = {
-			name: "g",
-			nodes: {
-				x: {
-					type: "derived",
-					deps: [],
-					meta: { ...factoryTag("a", { k: 1 }) },
-				},
-			},
-		};
-		const b: GraphSpec = {
-			name: "g",
-			nodes: {
-				x: {
-					type: "derived",
-					deps: [],
-					meta: { ...factoryTag("b", { k: 2 }) },
-				},
-			},
-		};
-		const result = specDiff(a, b);
-		expect(result.entries.some((e) => e.type === "changed" && e.path === "nodes.x")).toBe(true);
-		expect(result.entries[0]!.detail).toContain("fn");
-	});
-
-	it("reports name change", () => {
-		const a: GraphSpec = { name: "old", nodes: {} };
-		const b: GraphSpec = { name: "new", nodes: {} };
-		const result = specDiff(a, b);
-		expect(result.entries[0]!.path).toBe("name");
-	});
-
-	it("reports template changes", () => {
-		const a: GraphSpec = {
-			name: "g",
-			nodes: {},
-			templates: {
-				tmpl: { params: ["$x"], nodes: { inner: { type: "state", deps: [] } }, output: "inner" },
-			},
-		};
-		const b: GraphSpec = { name: "g", nodes: {} };
-		const result = specDiff(a, b);
-		expect(result.entries.some((e) => e.type === "removed" && e.path === "templates.tmpl")).toBe(
-			true,
-		);
-	});
-
-	it("reports feedback edge changes", () => {
-		const a: GraphSpec = {
-			name: "g",
-			nodes: { x: { type: "state", deps: [] }, y: { type: "derived", deps: ["x"] } },
-			feedback: [{ from: "y", to: "x", maxIterations: 5 }],
-		};
-		const b: GraphSpec = {
-			name: "g",
-			nodes: { x: { type: "state", deps: [] }, y: { type: "derived", deps: ["x"] } },
-			feedback: [{ from: "y", to: "x", maxIterations: 10 }],
-		};
-		const result = specDiff(a, b);
-		expect(result.entries.some((e) => e.type === "changed" && e.path.includes("feedback"))).toBe(
-			true,
-		);
-	});
-
-	it("generates human-readable summary", () => {
-		const a: GraphSpec = { name: "g", nodes: { x: { type: "state", deps: [] } } };
-		const b: GraphSpec = {
-			name: "g",
-			nodes: { x: { type: "state", deps: [] }, y: { type: "state", deps: [] } },
-		};
-		const result = specDiff(a, b);
-		expect(result.summary).toContain("1 added");
-	});
-});
-
-// ---------------------------------------------------------------------------
-// llmCompose
-// ---------------------------------------------------------------------------
-
-describe("graphspec.llmCompose", () => {
-	it("generates GraphSpec from LLM response", async () => {
-		const spec: GraphSpec = {
-			name: "email_triage",
-			nodes: {
-				inbox: {
-					type: "producer",
-					deps: [],
-					meta: { ...factoryTag("email"), description: "Email inbox source" },
-				},
-				classify: {
-					type: "derived",
-					deps: ["inbox"],
-					meta: { ...factoryTag("llmClassify"), description: "Classify emails" },
-				},
-			},
-		};
-
-		const adapter = mockAdapter([{ content: JSON.stringify(spec), finishReason: "end_turn" }]);
-
-		const result = await llmCompose("Build an email triage system", adapter);
-		expect(result.name).toBe("email_triage");
-		expect(result.nodes.inbox!.type).toBe("producer");
-		expect(result.nodes.classify!.type).toBe("derived");
-	});
-
-	it("strips markdown fences from LLM output", async () => {
-		const spec: GraphSpec = {
-			name: "test",
-			nodes: { a: { type: "state", deps: [], value: 1, meta: { description: "a" } } },
-		};
-
-		const adapter = mockAdapter([
-			{ content: `\`\`\`json\n${JSON.stringify(spec)}\n\`\`\``, finishReason: "end_turn" },
-		]);
-
-		const result = await llmCompose("test", adapter);
-		expect(result.name).toBe("test");
-	});
-
-	it("throws on invalid JSON", async () => {
-		const adapter = mockAdapter([{ content: "not json!", finishReason: "end_turn" }]);
-		await expect(llmCompose("bad", adapter)).rejects.toThrow("not valid JSON");
-	});
-
-	it("throws on invalid GraphSpec", async () => {
-		const adapter = mockAdapter([
-			{ content: JSON.stringify({ nodes: {} }), finishReason: "end_turn" },
-		]);
-		await expect(llmCompose("bad", adapter)).rejects.toThrow("invalid GraphSpec");
-	});
-});
-
-// ---------------------------------------------------------------------------
-// llmRefine
-// ---------------------------------------------------------------------------
-
-describe("graphspec.llmRefine", () => {
-	it("modifies existing spec based on feedback", async () => {
-		const original: GraphSpec = {
-			name: "v1",
-			nodes: { a: { type: "state", deps: [], value: 1, meta: { description: "src" } } },
-		};
-		const refined: GraphSpec = {
-			name: "v2",
-			nodes: {
-				a: { type: "state", deps: [], value: 1, meta: { description: "src" } },
-				b: {
-					type: "derived",
-					deps: ["a"],
-					meta: { ...factoryTag("double"), description: "doubled" },
-				},
-			},
-		};
-
-		const adapter = mockAdapter([{ content: JSON.stringify(refined), finishReason: "end_turn" }]);
-
-		const result = await llmRefine(original, "Add a doubling derived node", adapter);
-		expect(result.name).toBe("v2");
-		expect(result.nodes.b).toBeDefined();
-	});
-});
diff --git a/src/__tests__/utils/graphspec/spec-roundtrip.test.ts b/src/__tests__/utils/graphspec/spec-roundtrip.test.ts
deleted file mode 100644
index b94509e1..00000000
--- a/src/__tests__/utils/graphspec/spec-roundtrip.test.ts
+++ /dev/null
@@ -1,726 +0,0 @@
-/**
- * Tier 1.5.3 (Session A.1 lock) — Phase 3 unified-shape suite.
- *
- * Verifies:
- * - `describe({ detail: "spec" })` projects only structural fields and strips
- *   runtime state.
- * - `factoryTag(name, args)` stamps `meta.factory` + `meta.factoryArgs` on
- *   the resulting node.
- * - `compileSpec` reads `meta.factory` + `meta.factoryArgs` directly (Phase 3
- *   collapses the dual-read; the legacy `fn` / `source` / `config` /
- *   `initial` field-form is gone).
- * - `decompileSpec` is the canonical name (`decompileGraph` removed).
- * - State nodes self-tag via `factoryTag("state", { initial })` so initial
- *   values round-trip through `meta.factoryArgs.initial` (path (a)).
- */
-
-import { DATA, factoryTag, node } from "@graphrefly/pure-ts/core";
-import { Graph } from "@graphrefly/pure-ts/graph";
-import { describe, expect, it } from "vitest";
-import { compileSpec, decompileSpec, type GraphSpec } from "../../../utils/graphspec/index.js";
-
-describe("describe({ detail: 'spec' })", () => {
-	it("projects type/deps/meta and strips runtime fields", () => {
-		const g = new Graph("g");
-		const a = node([], {
-			name: "a",
-			meta: { ...factoryTag("counter", { initial: 42 }) },
-			initial: 42,
-		});
-		const b = node(
-			[a],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as number) * 2);
-			},
-			{
-				describeKind: "derived",
-				name: "b",
-				meta: { ...factoryTag("multiplier", { by: 2 }), domain: "math" },
-			},
-		);
-		g.add(a, { name: "a" });
-		g.add(b, { name: "b" });
-		// Activate so values populate; spec projection should still strip them.
-		const off = b.subscribe(() => {});
-
-		const spec = g.describe({ detail: "spec" });
-		expect(spec.nodes.a).toBeDefined();
-		expect(spec.nodes.b).toBeDefined();
-
-		// Structural fields preserved.
-		expect(spec.nodes.a!.type).toBe("state");
-		expect(spec.nodes.b!.type).toBe("derived");
-		expect(spec.nodes.b!.deps).toContain("a");
-
-		// Meta carries factory + factoryArgs.
-		expect(spec.nodes.a!.meta?.factory).toBe("counter");
-		expect((spec.nodes.a!.meta?.factoryArgs as { initial: number }).initial).toBe(42);
-		expect(spec.nodes.b!.meta?.factory).toBe("multiplier");
-		expect((spec.nodes.b!.meta?.factoryArgs as { by: number }).by).toBe(2);
-		// Domain meta also preserved.
-		expect(spec.nodes.b!.meta?.domain).toBe("math");
-
-		// Runtime fields stripped (status/guard/lastMutation always; `value`
-		// retained for state nodes only — path (b) lock).
-		expect(spec.nodes.a!.status).toBeUndefined();
-		expect(spec.nodes.a!.lastMutation).toBeUndefined();
-		expect(spec.nodes.a!.guard).toBeUndefined();
-		// State node: `value` retained as the seed initial.
-		expect(spec.nodes.a!.value).toBe(42);
-		// Derived node: `value` stripped (runtime artifact).
-		expect(spec.nodes.b!.value).toBeUndefined();
-
-		off();
-	});
-});
-
-describe("factoryTag", () => {
-	it("returns factory + factoryArgs object suitable for meta", () => {
-		const tag = factoryTag("rateLimiter", { permits: 10, intervalMs: 1_000 });
-		expect(tag).toEqual({
-			factory: "rateLimiter",
-			factoryArgs: { permits: 10, intervalMs: 1_000 },
-		});
-	});
-
-	it("omits factoryArgs when not provided", () => {
-		const tag = factoryTag("singleton");
-		expect(tag).toEqual({ factory: "singleton" });
-		expect("factoryArgs" in tag).toBe(false);
-	});
-
-	it("merges cleanly with other meta", () => {
-		const meta = { ...factoryTag("withTimeout", { ms: 500 }), domain: "resilience" };
-		expect(meta).toEqual({
-			factory: "withTimeout",
-			factoryArgs: { ms: 500 },
-			domain: "resilience",
-		});
-	});
-});
-
-describe("compileSpec reads meta.factory directly (Tier 1.5.3 Phase 3)", () => {
-	it("reads meta.factory + meta.factoryArgs for derived nodes", () => {
-		const spec: GraphSpec = {
-			name: "g",
-			nodes: {
-				input: { type: "state", value: 5, deps: [] },
-				doubled: {
-					type: "derived",
-					deps: ["input"],
-					meta: { ...factoryTag("multiply", { by: 2 }) },
-				},
-			},
-		};
-
-		const g = compileSpec(spec, {
-			catalog: {
-				fns: {
-					multiply: (deps, config) =>
-						node(
-							[deps[0] as Parameters<typeof derived>[0][number]],
-							(batchData, actions, ctx) => {
-								const data = batchData.map((batch, i) =>
-									batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-								);
-								actions.emit((data[0] as number) * (config.by as number));
-							},
-							{ describeKind: "derived" },
-						),
-				},
-			},
-		});
-
-		const doubled = g.resolve("doubled");
-		const off = doubled.subscribe(() => {});
-		expect(doubled.cache).toBe(10);
-		off();
-	});
-
-	it("reads meta.factory for producer nodes (resolves via catalog.sources)", () => {
-		const spec: GraphSpec = {
-			name: "g",
-			nodes: {
-				heartbeat: {
-					type: "producer",
-					deps: [],
-					meta: { ...factoryTag("seedSource", { value: 99 }) },
-				},
-			},
-		};
-
-		let receivedConfig: unknown = null;
-		const g = compileSpec(spec, {
-			catalog: {
-				sources: {
-					seedSource: (config) => {
-						receivedConfig = config;
-						return node([], { initial: config.value });
-					},
-				},
-			},
-		});
-
-		expect(receivedConfig).toEqual({ value: 99 });
-		const heartbeat = g.resolve("heartbeat");
-		const off = heartbeat.subscribe(() => {});
-		expect(heartbeat.cache).toBe(99);
-		off();
-	});
-
-	it("state node initial via top-level value field (path (b) canonical)", () => {
-		// Path (b) lock: spec projection retains `value` for state nodes so the
-		// seed initial round-trips via `value`, not via meta companion nodes.
-		const spec: GraphSpec = {
-			name: "g",
-			nodes: {
-				counter: { type: "state", deps: [], value: 7 },
-			},
-		};
-		const g = compileSpec(spec);
-		expect(g.resolve("counter").cache).toBe(7);
-	});
-
-	it("state node initial via meta.factoryArgs.initial also works (legacy / explicit form)", () => {
-		// A user-tagged state factory may stamp `meta.factoryArgs.initial`; the
-		// `compileSpec` `readStateInitial` helper prefers it before falling back
-		// to `value`. Both forms are accepted.
-		const spec: GraphSpec = {
-			name: "g",
-			nodes: {
-				counter: {
-					type: "state",
-					deps: [],
-					meta: { ...factoryTag("counter", { initial: 42 }) },
-				},
-			},
-		};
-		const g = compileSpec(spec);
-		expect(g.resolve("counter").cache).toBe(42);
-	});
-});
-
-describe("Phase 2 — tagged factories surface meta.factory in describe()", () => {
-	it("rateLimiter tags itself", async () => {
-		const { rateLimiter } = await import("../../../utils/resilience/index.js");
-		const { NS_PER_SEC } = await import("../../../base/resilience/backoff.js");
-
-		const src = node([], { initial: 0 });
-		const { node: limited } = rateLimiter(src, {
-			maxEvents: 5,
-			windowNs: NS_PER_SEC,
-			maxBuffer: Infinity,
-		});
-		const off = limited.subscribe(() => {});
-
-		const g = new Graph("g");
-		g.add(limited, { name: "limited" });
-		const spec = g.describe({ detail: "spec" });
-
-		expect(spec.nodes.limited?.meta?.factory).toBe("rateLimiter");
-		const args = spec.nodes.limited?.meta?.factoryArgs as {
-			maxEvents: number;
-			windowNs: number;
-		};
-		expect(args.maxEvents).toBe(5);
-		expect(args.windowNs).toBe(NS_PER_SEC);
-
-		off();
-	});
-
-	it("timeout tags itself", async () => {
-		const { withTimeout: timeout } = await import("../../../utils/resilience/index.js");
-		const { NS_PER_SEC } = await import("../../../base/resilience/backoff.js");
-
-		const src = node([], { initial: 0 });
-		const timed = timeout(src, { ns: 5 * NS_PER_SEC }).node;
-		const off = timed.subscribe(() => {});
-
-		const g = new Graph("g");
-		g.add(timed, { name: "timed" });
-		const spec = g.describe({ detail: "spec" });
-
-		expect(spec.nodes.timed?.meta?.factory).toBe("withTimeout");
-		const args = spec.nodes.timed?.meta?.factoryArgs as { ns: number };
-		expect(args.ns).toBe(5 * NS_PER_SEC);
-
-		off();
-	});
-
-	it("retry tags itself", async () => {
-		const { retry } = await import("../../../utils/resilience/index.js");
-
-		const src = node([], { initial: 0 });
-		const wrapped = retry(src, { count: 3, backoff: "exponential" }).node;
-		const off = wrapped.subscribe(() => {});
-
-		const g = new Graph("g");
-		g.add(wrapped, { name: "n" });
-		const spec = g.describe({ detail: "spec" });
-
-		expect(spec.nodes.n?.meta?.factory).toBe("retry");
-		const args = spec.nodes.n?.meta?.factoryArgs as { count?: number; backoff?: string };
-		expect(args.count).toBe(3);
-		expect(args.backoff).toBe("exponential");
-
-		off();
-	});
-
-	it("retry omits non-serializable backoff function from factoryArgs", async () => {
-		const { retry } = await import("../../../utils/resilience/index.js");
-
-		const src = node([], { initial: 0 });
-		const wrapped = retry(src, { count: 2, backoff: () => 100 }).node;
-		const off = wrapped.subscribe(() => {});
-
-		const g = new Graph("g");
-		g.add(wrapped, { name: "n" });
-		const spec = g.describe({ detail: "spec" });
-
-		expect(spec.nodes.n?.meta?.factory).toBe("retry");
-		const args = spec.nodes.n?.meta?.factoryArgs as { count?: number; backoff?: unknown };
-		expect(args.count).toBe(2);
-		expect(args.backoff).toBeUndefined();
-
-		off();
-	});
-
-	it("scan tags itself", async () => {
-		const { scan } = await import("@graphrefly/pure-ts/extra");
-
-		const src = node([], { initial: 0 });
-		const wrapped = scan(src, (a: number, x: number) => a + x, 10);
-		const off = wrapped.subscribe(() => {});
-
-		const g = new Graph("g");
-		g.add(wrapped, { name: "n" });
-		const spec = g.describe({ detail: "spec" });
-
-		expect(spec.nodes.n?.meta?.factory).toBe("scan");
-		const args = spec.nodes.n?.meta?.factoryArgs as { initial: number };
-		expect(args.initial).toBe(10);
-
-		off();
-	});
-
-	it("distinctUntilChanged tags itself", async () => {
-		const { distinctUntilChanged } = await import("@graphrefly/pure-ts/extra");
-
-		const src = node([], { initial: 0 });
-		const wrapped = distinctUntilChanged(src);
-		const off = wrapped.subscribe(() => {});
-
-		const g = new Graph("g");
-		g.add(wrapped, { name: "n" });
-		const spec = g.describe({ detail: "spec" });
-
-		expect(spec.nodes.n?.meta?.factory).toBe("distinctUntilChanged");
-		// equality fn isn't JSON-serializable — factoryArgs intentionally omitted.
-		expect(spec.nodes.n?.meta?.factoryArgs).toBeUndefined();
-
-		off();
-	});
-
-	it("merge tags itself", async () => {
-		const { merge } = await import("@graphrefly/pure-ts/extra");
-
-		const a = node([], { initial: 1 });
-		const b = node([], { initial: 2 });
-		const wrapped = merge(a, b);
-		const off = wrapped.subscribe(() => {});
-
-		const g = new Graph("g");
-		g.add(wrapped, { name: "n" });
-		const spec = g.describe({ detail: "spec" });
-
-		expect(spec.nodes.n?.meta?.factory).toBe("merge");
-		// variadic Node[] args aren't JSON-serializable — factoryArgs intentionally omitted.
-		expect(spec.nodes.n?.meta?.factoryArgs).toBeUndefined();
-
-		off();
-	});
-
-	it("switchMap tags itself", async () => {
-		const { switchMap } = await import("@graphrefly/pure-ts/extra");
-
-		const src = node([], { initial: 0 });
-		const wrapped = switchMap(src, (n: number) => node([], { initial: n * 2 }));
-		const off = wrapped.subscribe(() => {});
-
-		const g = new Graph("g");
-		g.add(wrapped, { name: "n" });
-		const spec = g.describe({ detail: "spec" });
-
-		expect(spec.nodes.n?.meta?.factory).toBe("switchMap");
-		// project fn isn't JSON-serializable — factoryArgs intentionally omitted.
-		expect(spec.nodes.n?.meta?.factoryArgs).toBeUndefined();
-
-		off();
-	});
-
-	it("debounce tags itself", async () => {
-		const { debounce } = await import("@graphrefly/pure-ts/extra");
-
-		const src = node([], { initial: 0 });
-		const wrapped = debounce(src, 50);
-		const off = wrapped.subscribe(() => {});
-
-		const g = new Graph("g");
-		g.add(wrapped, { name: "n" });
-		const spec = g.describe({ detail: "spec" });
-
-		expect(spec.nodes.n?.meta?.factory).toBe("debounce");
-		const args = spec.nodes.n?.meta?.factoryArgs as { ms: number };
-		expect(args.ms).toBe(50);
-
-		off();
-	});
-
-	it("throttle tags itself", async () => {
-		const { throttle } = await import("@graphrefly/pure-ts/extra");
-
-		const src = node([], { initial: 0 });
-		const wrapped = throttle(src, 75, { trailing: true });
-		const off = wrapped.subscribe(() => {});
-
-		const g = new Graph("g");
-		g.add(wrapped, { name: "n" });
-		const spec = g.describe({ detail: "spec" });
-
-		expect(spec.nodes.n?.meta?.factory).toBe("throttle");
-		const args = spec.nodes.n?.meta?.factoryArgs as {
-			ms: number;
-			leading: boolean;
-			trailing: boolean;
-		};
-		expect(args.ms).toBe(75);
-		expect(args.leading).toBe(true);
-		expect(args.trailing).toBe(true);
-
-		off();
-	});
-
-	it("bufferTime tags itself", async () => {
-		const { bufferTime } = await import("@graphrefly/pure-ts/extra");
-
-		const src = node([], { initial: 0 });
-		const wrapped = bufferTime(src, 100);
-		const off = wrapped.subscribe(() => {});
-
-		const g = new Graph("g");
-		g.add(wrapped, { name: "n" });
-		const spec = g.describe({ detail: "spec" });
-
-		expect(spec.nodes.n?.meta?.factory).toBe("bufferTime");
-		const args = spec.nodes.n?.meta?.factoryArgs as { ms: number };
-		expect(args.ms).toBe(100);
-
-		off();
-	});
-
-	it("frozenContext tags itself", async () => {
-		const { frozenContext } = await import("../../../utils/ai/prompts/frozen-context.js");
-
-		const src = node([], { initial: "hello" });
-		const wrapped = frozenContext(src, { name: "ctx" });
-		const off = wrapped.subscribe(() => {});
-
-		const g = new Graph("g");
-		g.add(wrapped, { name: "n" });
-		const spec = g.describe({ detail: "spec" });
-
-		expect(spec.nodes.n?.meta?.factory).toBe("frozenContext");
-		const args = spec.nodes.n?.meta?.factoryArgs as { name: string };
-		expect(args.name).toBe("ctx");
-
-		off();
-	});
-});
-
-describe("decompileSpec is the canonical name (Phase 3)", () => {
-	it("decompileGraph is no longer exported", async () => {
-		const mod = await import("../../../utils/graphspec/index.js");
-		expect((mod as Record<string, unknown>).decompileGraph).toBeUndefined();
-	});
-
-	it("decompileSpec(g) ≈ g.describe({ detail: 'spec' }) (modulo feedback sugar + meta-companion stripping)", () => {
-		const g = new Graph("g");
-		g.add(node([], { name: "a", initial: 7 }), { name: "a" });
-
-		const viaSpec = decompileSpec(g);
-		const viaDescribe = g.describe({ detail: "spec" });
-
-		expect(viaSpec.name).toBe(viaDescribe.name);
-		expect(viaSpec.name).toBe("g");
-		expect(viaSpec.nodes.a).toBeDefined();
-		// Path (b): state node retains `value` in spec projection so `initial`
-		// round-trips without polluting the graph with meta companion nodes.
-		expect(viaSpec.nodes.a!.value).toBe(7);
-		expect(viaSpec.nodes.a!.type).toBe("state");
-	});
-
-	it("state initial round-trips through decompileSpec → compileSpec", () => {
-		const g1 = new Graph("g");
-		g1.add(node([], { name: "counter", initial: 99 }), { name: "counter" });
-		const spec = decompileSpec(g1);
-		const g2 = compileSpec(spec);
-		expect(g2.resolve("counter").cache).toBe(99);
-	});
-});
-
-describe("decompileSpec → compileSpec round-trip", () => {
-	it("a graph using factoryTag-stamped derived survives decompile→compile", () => {
-		// 1) Build a graph using factoryTag on a derived node.
-		const g1 = new Graph("g");
-		const input = node([], { name: "input", initial: 6 });
-		const doubled = node(
-			[input],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as number) * 2);
-			},
-			{ describeKind: "derived", name: "doubled", meta: { ...factoryTag("multiply", { by: 2 }) } },
-		);
-		g1.add(input, { name: "input" });
-		g1.add(doubled, { name: "doubled" });
-		const offOriginal = doubled.subscribe(() => {});
-
-		// 2) decompileSpec — filters meta-companion paths, preserves factory tags.
-		const spec = decompileSpec(g1);
-
-		// Factory tag survived.
-		expect(spec.nodes.doubled?.meta?.factory).toBe("multiply");
-		expect((spec.nodes.doubled?.meta?.factoryArgs as { by: number }).by).toBe(2);
-
-		// 3) compileSpec normalizes meta.factory → fn (Phase 1 dual-read), looks
-		// up the catalog, recreates the node.
-		const g2 = compileSpec(spec, {
-			catalog: {
-				fns: {
-					multiply: (deps, config) =>
-						node(
-							[deps[0] as Parameters<typeof derived>[0][number]],
-							(batchData, actions, ctx) => {
-								const data = batchData.map((batch, i) =>
-									batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-								);
-								actions.emit((data[0] as number) * (config.by as number));
-							},
-							{ describeKind: "derived" },
-						),
-				},
-			},
-		});
-
-		const recreatedDoubled = g2.resolve("doubled");
-		const recreatedInput = g2.resolve("input");
-		const off = recreatedDoubled.subscribe(() => {});
-		expect(recreatedInput.cache).toBe(6);
-		expect(recreatedDoubled.cache).toBe(12);
-
-		// Push a new value — recreated topology propagates.
-		(recreatedInput as { down: (msgs: unknown) => void }).down([[DATA, 10]]);
-		expect(recreatedDoubled.cache).toBe(20);
-
-		off();
-		offOriginal();
-	});
-});
-
-describe("Tier 1.5.3 Phase 2.5 — Graph-level factory tagging (DG1=B)", () => {
-	it("Graph.tagFactory(name, args) surfaces top-level factory + factoryArgs in describe()", () => {
-		const g = new Graph("g");
-		g.tagFactory("agentMemory", { budget: 2000, vectorDimensions: 1536 });
-		g.add(node([], { name: "store", initial: 0 }), { name: "store" });
-
-		const out = g.describe();
-		expect(out.factory).toBe("agentMemory");
-		expect(out.factoryArgs).toEqual({ budget: 2000, vectorDimensions: 1536 });
-	});
-
-	it("GraphOptions.factory in constructor seeds the tag", () => {
-		const g = new Graph("g", { factory: "pipelineGraph", factoryArgs: { stages: ["a", "b"] } });
-		expect(g.describe().factory).toBe("pipelineGraph");
-		expect(g.describe().factoryArgs).toEqual({ stages: ["a", "b"] });
-	});
-
-	it("describe({ detail: 'spec' }) preserves Graph-level factory tag", () => {
-		const g = new Graph("g");
-		g.tagFactory("harnessLoop", { route: "auto-fix" });
-		const spec = g.describe({ detail: "spec" });
-		expect(spec.factory).toBe("harnessLoop");
-		expect(spec.factoryArgs).toEqual({ route: "auto-fix" });
-	});
-
-	it("Tier 3.4: placeholderArgs substitutes a Node<readonly string[]> field as `<Node>` (regression for reactive `paths` factory-tag round-trip)", async () => {
-		const { placeholderArgs } = await import("@graphrefly/pure-ts/core");
-		// Mirrors the Tier 3.4 `policyEnforcer({ paths: stateNode })` shape:
-		// `paths` may be a static array OR a Node-of-array. Both must survive
-		// `placeholderArgs` cleanly — the Node form collapses to `"<Node>"`,
-		// the array form recurses element-wise.
-		const pathsNode = node<readonly string[]>([], { initial: ["a", "b"] });
-		const args = placeholderArgs({
-			paths: pathsNode,
-			mode: "enforce",
-			violationsLimit: 100,
-		});
-		expect(args.paths).toBe("<Node>");
-		expect(args.mode).toBe("enforce");
-		expect(args.violationsLimit).toBe(100);
-
-		// Static-array form recurses element-wise (string primitives pass through).
-		const argsStatic = placeholderArgs({
-			paths: ["a", "b"],
-			mode: "audit",
-		});
-		expect(argsStatic.paths).toEqual(["a", "b"]);
-		expect(argsStatic.mode).toBe("audit");
-	});
-
-	it("placeholderArgs substitutes non-JSON fields with descriptive strings (DG2=ii)", async () => {
-		const { placeholderArgs } = await import("@graphrefly/pure-ts/core");
-		const adapter = { invoke: () => ({ content: "x" }) }; // not a Node, but has a function
-		const sourceNode = node([], { initial: 0 });
-		const args = placeholderArgs({
-			budget: 2000,
-			adapter,
-			extractFn: (raw: unknown) => ({ upsert: [{ key: "k", value: raw }] }),
-			source: sourceNode,
-			model: "claude-opus-4-7",
-			tags: ["a", "b"],
-		});
-
-		expect(args.budget).toBe(2000);
-		expect(args.model).toBe("claude-opus-4-7");
-		expect(args.tags).toEqual(["a", "b"]);
-		expect(args.extractFn).toBe("<function>");
-		expect(args.source).toBe("<Node>");
-		// adapter has invoke fn — recursive walk yields { invoke: "<function>" }.
-		expect((args.adapter as { invoke: string }).invoke).toBe("<function>");
-	});
-
-	it("compileSpec delegates to catalog.graphFactories when spec.factory is set", () => {
-		const spec: GraphSpec = {
-			name: "g",
-			nodes: {}, // ignored — graphFactory owns reconstruction
-			factory: "myAgentMemory",
-			factoryArgs: { budget: 500 },
-		};
-
-		let receivedArgs: unknown = null;
-		const built = compileSpec(spec, {
-			catalog: {
-				graphFactories: {
-					myAgentMemory: (args) => {
-						receivedArgs = args;
-						const sub = new Graph("g");
-						sub.add(node([], { name: "marker", initial: 123 }), { name: "marker" });
-						sub.tagFactory("myAgentMemory", args);
-						return sub;
-					},
-				},
-			},
-		});
-
-		expect(receivedArgs).toEqual({ budget: 500 });
-		expect(built.describe().factory).toBe("myAgentMemory");
-		expect(built.resolve("marker").cache).toBe(123);
-	});
-
-	it("falls back to per-node compile when spec.factory has no graphFactories entry", () => {
-		const spec: GraphSpec = {
-			name: "g",
-			nodes: { x: { type: "state", deps: [], value: 7 } },
-			factory: "unknownFactory",
-		};
-		// No graphFactories entry — should fall through and compile nodes normally.
-		const built = compileSpec(spec, { catalog: { fns: {}, sources: {} } });
-		expect(built.resolve("x").cache).toBe(7);
-	});
-
-	it("pipelineGraph self-tags with factory: 'pipelineGraph' (flagship Phase 2.5 migration)", async () => {
-		const { pipelineGraph } = await import("../../../utils/orchestration/index.js");
-		const p = pipelineGraph("flow", { traceCapacity: 256 });
-		const out = p.describe();
-		expect(out.factory).toBe("pipelineGraph");
-		expect((out.factoryArgs as { traceCapacity: number }).traceCapacity).toBe(256);
-	});
-});
-
-describe("Phase 2 operator mop-up — map/filter/reduce/take/tap/withLatestFrom self-tag", () => {
-	it("map tags itself", async () => {
-		const { map } = await import("@graphrefly/pure-ts/extra");
-		const src = node([], { initial: 0 });
-		const m = map(src, (v) => v * 2);
-		const off = m.subscribe(() => {});
-		const g = new Graph("g");
-		g.add(m, { name: "m" });
-		expect(g.describe({ detail: "spec" }).nodes.m?.meta?.factory).toBe("map");
-		off();
-	});
-
-	it("filter tags itself", async () => {
-		const { filter } = await import("@graphrefly/pure-ts/extra");
-		const src = node([], { initial: 0 });
-		const f = filter(src, (v) => v > 0);
-		const off = f.subscribe(() => {});
-		const g = new Graph("g");
-		g.add(f, { name: "f" });
-		expect(g.describe({ detail: "spec" }).nodes.f?.meta?.factory).toBe("filter");
-		off();
-	});
-
-	it("reduce tags itself with initial seed", async () => {
-		const { reduce } = await import("@graphrefly/pure-ts/extra");
-		const src = node([], { initial: 1 });
-		const r = reduce(src, (a, v) => a + v, 100);
-		const off = r.subscribe(() => {});
-		const g = new Graph("g");
-		g.add(r, { name: "r" });
-		const meta = g.describe({ detail: "spec" }).nodes.r?.meta;
-		expect(meta?.factory).toBe("reduce");
-		expect((meta?.factoryArgs as { initial: number }).initial).toBe(100);
-		off();
-	});
-
-	it("take tags itself with count", async () => {
-		const { take } = await import("@graphrefly/pure-ts/extra");
-		const src = node([], { initial: 0 });
-		const t = take(src, 3);
-		const off = t.subscribe(() => {});
-		const g = new Graph("g");
-		g.add(t, { name: "t" });
-		const meta = g.describe({ detail: "spec" }).nodes.t?.meta;
-		expect(meta?.factory).toBe("take");
-		expect((meta?.factoryArgs as { count: number }).count).toBe(3);
-		off();
-	});
-
-	it("tap tags itself (function form)", async () => {
-		const { tap } = await import("@graphrefly/pure-ts/extra");
-		const src = node([], { initial: 0 });
-		const t = tap(src, () => undefined);
-		const off = t.subscribe(() => {});
-		const g = new Graph("g");
-		g.add(t, { name: "t" });
-		expect(g.describe({ detail: "spec" }).nodes.t?.meta?.factory).toBe("tap");
-		off();
-	});
-
-	it("withLatestFrom tags itself", async () => {
-		const { withLatestFrom } = await import("@graphrefly/pure-ts/extra");
-		const a = node([], { initial: 1 });
-		const b = node([], { initial: 2 });
-		const w = withLatestFrom(a, b);
-		const off = w.subscribe(() => {});
-		const g = new Graph("g");
-		g.add(w, { name: "w" });
-		expect(g.describe({ detail: "spec" }).nodes.w?.meta?.factory).toBe("withLatestFrom");
-		off();
-	});
-});
diff --git a/src/__tests__/utils/harness/actuator-executor.test.ts b/src/__tests__/utils/harness/actuator-executor.test.ts
deleted file mode 100644
index 697c5b44..00000000
--- a/src/__tests__/utils/harness/actuator-executor.test.ts
+++ /dev/null
@@ -1,401 +0,0 @@
-/**
- * Unit tests for `actuatorExecutor` — the side-effecting EXECUTE work fn
- * primitive (Tier 6.5 C2 shape). Covers:
- *   - happy path (Promise apply → success payload with artifact)
- *   - skip path (shouldApply=false → failure payload)
- *   - synchronous throw + Promise reject mapping via onError
- *   - one-DATA-per-claim rule (later inner DATAs ignored by the producer)
- *   - end-to-end pairing with `evalVerifier` through `harnessLoop`
- */
-
-import { COMPLETE, DATA, type Node, node } from "@graphrefly/pure-ts/core";
-import { fromAny } from "@graphrefly/pure-ts/extra";
-import { describe, expect, it, vi } from "vitest";
-import { evalVerifier, harnessLoop } from "../../../presets/harness/index.js";
-import type { DatasetItem, EvalResult, Evaluator } from "../../../presets/harness/refine-loop.js";
-import { mockLLM } from "../../../testing/mock-llm.js";
-import {
-	actuatorExecutor,
-	dispatchActuator,
-	type HarnessJobPayload,
-	type TriagedItem,
-	type VerifyResult,
-} from "../../../utils/harness/index.js";
-import type { JobEnvelope } from "../../../utils/job-queue/index.js";
-
-const SAMPLE_ITEM: TriagedItem = {
-	source: "eval",
-	summary: "missing fn",
-	evidence: "fixture",
-	affectsAreas: ["catalog"],
-	rootCause: "missing-fn",
-	intervention: "catalog-fn",
-	route: "auto-fix",
-	priority: 80,
-};
-
-let _jobCounter = 0;
-function makeJob<R>(item: TriagedItem): JobEnvelope<HarnessJobPayload<R>> {
-	_jobCounter += 1;
-	return {
-		id: `test-job-${_jobCounter}`,
-		payload: { item },
-		attempts: 0,
-		metadata: Object.freeze({}),
-		state: "inflight",
-	};
-}
-
-function awaitFirstData<T>(node: Node<T | null>, timeoutMs = 1500): Promise<T> {
-	return new Promise((resolve, reject) => {
-		let unsub: () => void = () => {};
-		const timer = setTimeout(() => {
-			unsub();
-			reject(new Error(`no DATA within ${timeoutMs}ms`));
-		}, timeoutMs);
-		unsub = node.subscribe((msgs) => {
-			for (const [type, value] of msgs) {
-				if (type === DATA && value != null) {
-					clearTimeout(timer);
-					unsub();
-					resolve(value as T);
-					return;
-				}
-			}
-		});
-	});
-}
-
-describe("actuatorExecutor — happy path", () => {
-	it("emits success payload with artifact when apply resolves", async () => {
-		const applied: TriagedItem[] = [];
-		const exec = actuatorExecutor<{ wrote: string }>({
-			async apply(item) {
-				applied.push(item);
-				return { wrote: item.intervention };
-			},
-		});
-		const out = fromAny(exec(makeJob<{ wrote: string }>(SAMPLE_ITEM)));
-		const payload = await awaitFirstData(out);
-		expect(applied).toHaveLength(1);
-		expect(payload.execution?.outcome).toBe("success");
-		expect(payload.execution?.artifact).toEqual({ wrote: "catalog-fn" });
-		expect(payload.execution?.detail).toContain("catalog-fn");
-		expect(payload.item).toEqual(SAMPLE_ITEM);
-	});
-
-	it("custom toOutput shapes the execution payload", async () => {
-		const exec = actuatorExecutor<number>({
-			async apply() {
-				return 42;
-			},
-			toOutput: (record) => ({
-				outcome: "partial",
-				detail: `wrote=${record}`,
-				artifact: record,
-			}),
-		});
-		const payload = await awaitFirstData(fromAny(exec(makeJob<number>(SAMPLE_ITEM))));
-		expect(payload.execution?.outcome).toBe("partial");
-		expect(payload.execution?.detail).toBe("wrote=42");
-		expect(payload.execution?.artifact).toBe(42);
-	});
-});
-
-describe("actuatorExecutor — failure modes", () => {
-	it("synchronous throw maps to failure payload via onError", async () => {
-		const exec = actuatorExecutor<unknown>({
-			apply() {
-				throw new Error("sync boom");
-			},
-		});
-		const payload = await awaitFirstData(fromAny(exec(makeJob<unknown>(SAMPLE_ITEM))));
-		expect(payload.execution?.outcome).toBe("failure");
-		expect(payload.execution?.detail).toContain("sync boom");
-		expect(payload.execution?.artifact).toBeUndefined();
-	});
-
-	it("Promise reject maps to failure payload via onError", async () => {
-		const exec = actuatorExecutor<unknown>({
-			async apply() {
-				throw new Error("async boom");
-			},
-		});
-		const payload = await awaitFirstData(fromAny(exec(makeJob<unknown>(SAMPLE_ITEM))));
-		expect(payload.execution?.outcome).toBe("failure");
-		expect(payload.execution?.detail).toContain("async boom");
-	});
-
-	it("custom onError shapes the failure output", async () => {
-		const exec = actuatorExecutor<unknown>({
-			async apply() {
-				throw new Error("classify me");
-			},
-			onError: (err) => ({
-				outcome: "failure",
-				detail: `tagged: ${(err as Error).message}`,
-			}),
-		});
-		const payload = await awaitFirstData(fromAny(exec(makeJob<unknown>(SAMPLE_ITEM))));
-		expect(payload.execution?.detail).toBe("tagged: classify me");
-	});
-
-	it("shouldApply=false skips apply and emits failure with skipDetail", async () => {
-		let applyCalls = 0;
-		const exec = actuatorExecutor<unknown>({
-			apply() {
-				applyCalls++;
-				throw new Error("should not run");
-			},
-			shouldApply: () => false,
-			skipDetail: (item) => `skipped ${item.intervention}`,
-		});
-		const payload = await awaitFirstData(fromAny(exec(makeJob<unknown>(SAMPLE_ITEM))));
-		expect(applyCalls).toBe(0);
-		expect(payload.execution?.outcome).toBe("failure");
-		expect(payload.execution?.detail).toBe("skipped catalog-fn");
-	});
-});
-
-describe("actuatorExecutor — contract guarantees", () => {
-	it("ignores later inner DATAs after the first one is captured (rule 1)", async () => {
-		// An apply that returns a Node emitting MULTIPLE DATAs must collapse
-		// into exactly one execution payload.
-		const exec = actuatorExecutor<string>({
-			apply() {
-				return node<string>(
-					[],
-					(_data, actions) => {
-						actions.down([[DATA, "first"], [DATA, "second"], [DATA, "third"], [COMPLETE]]);
-						return () => {};
-					},
-					{ describeKind: "producer" },
-				);
-			},
-		});
-		const seen: HarnessJobPayload<string>[] = [];
-		const out = fromAny(exec(makeJob<string>(SAMPLE_ITEM)));
-		out.subscribe((msgs) => {
-			for (const m of msgs) {
-				if (m[0] === DATA && m[1] != null) seen.push(m[1] as HarnessJobPayload<string>);
-			}
-		});
-		// Allow microtasks for fromAny + producer settle.
-		await Promise.resolve();
-		await Promise.resolve();
-		expect(seen).toHaveLength(1);
-		expect(seen[0]?.execution?.artifact).toBe("first");
-	});
-});
-
-// ---------------------------------------------------------------------------
-// dispatchActuator
-// ---------------------------------------------------------------------------
-
-const CATALOG_ITEM: TriagedItem = { ...SAMPLE_ITEM, intervention: "catalog-fn" };
-const TEMPLATE_ITEM: TriagedItem = { ...SAMPLE_ITEM, intervention: "template" };
-const UNKNOWN_ITEM: TriagedItem = {
-	...SAMPLE_ITEM,
-	intervention: "investigate" as TriagedItem["intervention"],
-};
-
-describe("dispatchActuator — routes match", () => {
-	it("routes 'catalog-fn' to the correct apply callback", async () => {
-		const catalogCalls: string[] = [];
-		const exec = dispatchActuator<string>({
-			routes: {
-				"catalog-fn": (item) => {
-					catalogCalls.push(item.intervention);
-					return Promise.resolve("catalog-result");
-				},
-				template: () => Promise.resolve("template-result"),
-			},
-		});
-		const payload = await awaitFirstData(fromAny(exec(makeJob<string>(CATALOG_ITEM))));
-		expect(payload.execution?.outcome).toBe("success");
-		expect(payload.execution?.artifact).toBe("catalog-result");
-		expect(catalogCalls).toEqual(["catalog-fn"]);
-	});
-
-	it("routes 'template' to its apply callback independently", async () => {
-		const exec = dispatchActuator<string>({
-			routes: {
-				"catalog-fn": () => Promise.resolve("catalog-result"),
-				template: () => Promise.resolve("template-result"),
-			},
-		});
-		const payload = await awaitFirstData(fromAny(exec(makeJob<string>(TEMPLATE_ITEM))));
-		expect(payload.execution?.outcome).toBe("success");
-		expect(payload.execution?.artifact).toBe("template-result");
-	});
-});
-
-describe("dispatchActuator — default fallback", () => {
-	it("invokes default apply for unrouted interventions", async () => {
-		const defaultCalls: string[] = [];
-		const exec = dispatchActuator<string>({
-			routes: {
-				"catalog-fn": () => Promise.resolve("catalog-result"),
-			},
-			default: (item) => {
-				defaultCalls.push(item.intervention);
-				return Promise.resolve("default-result");
-			},
-		});
-		const payload = await awaitFirstData(fromAny(exec(makeJob<string>(UNKNOWN_ITEM))));
-		expect(payload.execution?.outcome).toBe("success");
-		expect(payload.execution?.artifact).toBe("default-result");
-		expect(defaultCalls).toEqual(["investigate"]);
-	});
-});
-
-describe("dispatchActuator — no route no default", () => {
-	it("emits failure with 'no route for intervention' detail", async () => {
-		const exec = dispatchActuator<string>({
-			routes: {
-				"catalog-fn": () => Promise.resolve("catalog-result"),
-			},
-		});
-		const payload = await awaitFirstData(fromAny(exec(makeJob<string>(UNKNOWN_ITEM))));
-		expect(payload.execution?.outcome).toBe("failure");
-		expect(payload.execution?.detail).toContain("no route for intervention 'investigate'");
-	});
-});
-
-// ---------------------------------------------------------------------------
-// End-to-end: actuatorExecutor + evalVerifier through harnessLoop
-// ---------------------------------------------------------------------------
-
-const REQUIRED = ["a", "b", "c"] as const;
-const DATASET: readonly DatasetItem[] = REQUIRED.map((kw) => ({ id: kw }));
-
-const presenceEvaluator: Evaluator<string> = (candidates, dataset) => {
-	const out = node<readonly EvalResult[]>([], { initial: [] });
-	let lastCands: readonly string[] = [];
-	let lastDs: readonly DatasetItem[] = [];
-	const recompute = (): void => {
-		const best = (lastCands[0] ?? "").toLowerCase();
-		out.emit(
-			lastDs.map((row) => ({
-				taskId: row.id,
-				score: best.includes(row.id.toLowerCase()) ? 1 : 0,
-			})),
-		);
-	};
-	candidates.subscribe((msgs) => {
-		for (const m of msgs) {
-			if (m[0] === DATA && m[1] != null) {
-				lastCands = m[1] as readonly string[];
-				recompute();
-			}
-		}
-	});
-	dataset.subscribe((msgs) => {
-		for (const m of msgs) {
-			if (m[0] === DATA && m[1] != null) {
-				lastDs = m[1] as readonly DatasetItem[];
-				recompute();
-			}
-		}
-	});
-	return out;
-};
-
-function awaitFirstVerify(latest: Node<VerifyResult>, timeoutMs = 3000): Promise<VerifyResult> {
-	return new Promise((resolve, reject) => {
-		let unsub: () => void = () => {};
-		const timer = setTimeout(() => {
-			unsub();
-			reject(new Error(`no VerifyResult within ${timeoutMs}ms`));
-		}, timeoutMs);
-		unsub = latest.subscribe((msgs) => {
-			for (const [type, value] of msgs) {
-				if (type === DATA && value != null) {
-					clearTimeout(timer);
-					unsub();
-					resolve(value as VerifyResult);
-				}
-			}
-		});
-	});
-}
-
-describe("actuatorExecutor + evalVerifier (end-to-end)", () => {
-	it("actuator writes artifact, verifier re-runs evaluator and passes", async () => {
-		const adapter = mockLLM({
-			fallback: {
-				rootCause: "missing-fn",
-				intervention: "catalog-fn",
-				route: "auto-fix",
-				priority: 80,
-				triageReasoning: "needs the abc string",
-			},
-		});
-
-		const harness = harnessLoop<string>("actuator-e2e", {
-			adapter,
-			executor: actuatorExecutor<string>({
-				// "Actuator" returns the artifact — a candidate string carrying
-				// every required keyword. Evaluator scores it 3/3 → verified.
-				async apply() {
-					return "a b c";
-				},
-			}),
-			verifier: evalVerifier<string>({
-				datasetFor: () => DATASET,
-				evaluator: presenceEvaluator,
-				threshold: 1.0,
-			}),
-		});
-
-		const verifyPromise = awaitFirstVerify(harness.verifyResults.latest);
-		harness.intake.publish({
-			source: "eval",
-			summary: "needs abc",
-			evidence: "fixture",
-			affectsAreas: ["catalog"],
-			affectsEvalTasks: [...REQUIRED],
-			severity: "high",
-		});
-
-		const verify = await verifyPromise;
-		expect(verify.verified).toBe(true);
-		expect(verify.execution.outcome).toBe("success");
-		expect(verify.execution.artifact).toBe("a b c");
-		expect(verify.findings[0]).toContain("3/3");
-
-		harness.destroy();
-	});
-});
-
-// ---------------------------------------------------------------------------
-// dispatchActuator regressions
-// ---------------------------------------------------------------------------
-
-describe("dispatchActuator — prototype-key intervention (P2 regression)", () => {
-	it("treats prototype-key interventions as no-route (skip-failure)", async () => {
-		const apply = vi.fn(() => Promise.resolve("c"));
-		const exec = dispatchActuator<string>({
-			routes: { "catalog-fn": apply },
-		});
-		// Simulate a malformed/hallucinated triage output whose intervention
-		// matches a prototype key — `Object.hasOwn` must reject it.
-		const item: TriagedItem = {
-			...CATALOG_ITEM,
-			intervention: "toString" as TriagedItem["intervention"],
-		};
-		const payload = await awaitFirstData(fromAny(exec(makeJob<string>(item))));
-		expect(payload.execution?.outcome).toBe("failure");
-		expect(payload.execution?.detail).toContain("no route for intervention 'toString'");
-		expect(apply).not.toHaveBeenCalled();
-	});
-});
-
-describe("dispatchActuator — empty routes no default", () => {
-	it("emits skip-failure for any item when routes is empty and no default", async () => {
-		const exec = dispatchActuator<string>({ routes: {} });
-		const payload = await awaitFirstData(fromAny(exec(makeJob<string>(CATALOG_ITEM))));
-		expect(payload.execution?.outcome).toBe("failure");
-		expect(payload.execution?.detail).toContain("no route for intervention");
-	});
-});
diff --git a/src/__tests__/utils/harness/auto-solidify.test.ts b/src/__tests__/utils/harness/auto-solidify.test.ts
deleted file mode 100644
index e8be5dd0..00000000
--- a/src/__tests__/utils/harness/auto-solidify.test.ts
+++ /dev/null
@@ -1,200 +0,0 @@
-/**
- * Unit tests for `autoSolidify` — the VERIFY-success → durable-artifact
- * promotion primitive. Covers:
- *   - happy path (verified=true → write called → node emits artifact)
- *   - skips verified=false
- *   - skips when extract returns null
- *   - predicate gates beyond verified flag
- *   - write throw surfaces as ERROR but does not break the loop
- *   - completes when verifyResults completes
- */
-
-import { DATA, ERROR, node } from "@graphrefly/pure-ts/core";
-import { describe, expect, it } from "vitest";
-
-import { autoSolidify } from "../../../utils/harness/auto-solidify.js";
-import type { ExecutionResult, TriagedItem, VerifyResult } from "../../../utils/harness/types.js";
-
-const SAMPLE_ITEM: TriagedItem = {
-	source: "eval",
-	summary: "needs catalog fn",
-	evidence: "fixture",
-	affectsAreas: ["catalog"],
-	rootCause: "missing-fn",
-	intervention: "catalog-fn",
-	route: "auto-fix",
-	priority: 80,
-};
-
-function makeVR<R>(opts: {
-	verified: boolean;
-	artifact?: R;
-	intervention?: TriagedItem["intervention"];
-	findings?: string[];
-}): VerifyResult<R> {
-	const item: TriagedItem = {
-		...SAMPLE_ITEM,
-		intervention: opts.intervention ?? SAMPLE_ITEM.intervention,
-	};
-	const execution: ExecutionResult<R> = {
-		item,
-		outcome: opts.verified ? "success" : "failure",
-		detail: "test",
-		artifact: opts.artifact,
-	};
-	return {
-		item,
-		execution,
-		verified: opts.verified,
-		findings: opts.findings ?? [],
-	};
-}
-
-describe("autoSolidify — happy path", () => {
-	it("invokes write and emits the artifact for verified=true", () => {
-		const verifyResults = node<VerifyResult<string> | null>([], { initial: null });
-		const writes: { artifact: string; vr: VerifyResult<string> }[] = [];
-		const emitted: string[] = [];
-		const solidifyNode = autoSolidify<string>({
-			verifyResults,
-			write: (artifact, vr) => writes.push({ artifact, vr }),
-		});
-		solidifyNode.subscribe((batch) => {
-			for (const m of batch) {
-				if (m[0] === DATA && m[1] != null) emitted.push(m[1] as string);
-			}
-		});
-		verifyResults.emit(makeVR({ verified: true, artifact: "promoted" }));
-		expect(writes).toHaveLength(1);
-		expect(writes[0].artifact).toBe("promoted");
-		expect(writes[0].vr.item.intervention).toBe("catalog-fn");
-		expect(emitted).toEqual(["promoted"]);
-	});
-
-	it("skips verified=false runs", () => {
-		const verifyResults = node<VerifyResult<string> | null>([], { initial: null });
-		const writes: string[] = [];
-		const solidifyNode = autoSolidify<string>({
-			verifyResults,
-			write: (artifact) => writes.push(artifact),
-		});
-		solidifyNode.subscribe(() => {});
-		verifyResults.emit(makeVR({ verified: false, artifact: "should-not-promote" }));
-		expect(writes).toEqual([]);
-	});
-
-	it("skips when extract returns null", () => {
-		const verifyResults = node<VerifyResult<string> | null>([], { initial: null });
-		const writes: string[] = [];
-		const solidifyNode = autoSolidify<string, string>({
-			verifyResults,
-			extract: () => null,
-			write: (artifact) => writes.push(artifact),
-		});
-		solidifyNode.subscribe(() => {});
-		verifyResults.emit(makeVR({ verified: true, artifact: "ignored-by-extract" }));
-		expect(writes).toEqual([]);
-	});
-
-	it("transforms the artifact via custom extract", () => {
-		const verifyResults = node<VerifyResult<{ raw: number }> | null>([], { initial: null });
-		const writes: number[] = [];
-		const solidifyNode = autoSolidify<{ raw: number }, number>({
-			verifyResults,
-			extract: (vr) => vr.execution.artifact?.raw ?? null,
-			write: (n) => writes.push(n),
-		});
-		solidifyNode.subscribe(() => {});
-		verifyResults.emit(makeVR({ verified: true, artifact: { raw: 7 } }));
-		expect(writes).toEqual([7]);
-	});
-});
-
-describe("autoSolidify — predicate gating", () => {
-	it("predicate=false suppresses the promotion", () => {
-		const verifyResults = node<VerifyResult<string> | null>([], { initial: null });
-		const writes: string[] = [];
-		const solidifyNode = autoSolidify<string>({
-			verifyResults,
-			predicate: (vr) => vr.item.intervention === "template",
-			write: (a) => writes.push(a),
-		});
-		solidifyNode.subscribe(() => {});
-		// catalog-fn is verified but predicate rejects.
-		verifyResults.emit(makeVR({ verified: true, artifact: "no", intervention: "catalog-fn" }));
-		expect(writes).toEqual([]);
-		// template intervention passes both gates.
-		verifyResults.emit(makeVR({ verified: true, artifact: "yes", intervention: "template" }));
-		expect(writes).toEqual(["yes"]);
-	});
-});
-
-describe("autoSolidify — error surfaces", () => {
-	it("write throw emits terminal ERROR; later verifies do NOT solidify", () => {
-		// Spec-conforming behavior: `[[ERROR]]` is a terminal frame.
-		// `autoSolidify` tears down its upstream subscription on first
-		// user-callback throw. Callers who want the solidify node to stay
-		// live across throws must wrap their `write` with try/catch
-		// internally.
-		const verifyResults = node<VerifyResult<string> | null>([], { initial: null });
-		const errors: unknown[] = [];
-		const writes: string[] = [];
-		const datas: string[] = [];
-		const solidifyNode = autoSolidify<string>({
-			verifyResults,
-			write: (a) => {
-				if (a === "boom") throw new Error("write boom");
-				writes.push(a);
-			},
-		});
-		solidifyNode.subscribe((batch) => {
-			for (const m of batch) {
-				if (m[0] === ERROR) errors.push(m[1]);
-				if (m[0] === DATA && m[1] != null) datas.push(m[1] as string);
-			}
-		});
-		verifyResults.emit(makeVR({ verified: true, artifact: "boom" }));
-		verifyResults.emit(makeVR({ verified: true, artifact: "ok" }));
-		expect(errors).toHaveLength(1);
-		expect((errors[0] as Error).message).toBe("write boom");
-		// Second verify did NOT trigger a write — node is terminal.
-		expect(writes).toEqual([]);
-		expect(datas).toEqual([]);
-	});
-
-	it("predicate throw emits terminal ERROR (mirrors write semantics)", () => {
-		const verifyResults = node<VerifyResult<string> | null>([], { initial: null });
-		const errors: unknown[] = [];
-		const solidifyNode = autoSolidify<string>({
-			verifyResults,
-			predicate: () => {
-				throw new Error("predicate boom");
-			},
-			write: () => {},
-		});
-		solidifyNode.subscribe((batch) => {
-			for (const m of batch) if (m[0] === ERROR) errors.push(m[1]);
-		});
-		verifyResults.emit(makeVR({ verified: true, artifact: "x" }));
-		expect(errors).toHaveLength(1);
-		expect((errors[0] as Error).message).toBe("predicate boom");
-	});
-
-	it("extract throw emits terminal ERROR", () => {
-		const verifyResults = node<VerifyResult<string> | null>([], { initial: null });
-		const errors: unknown[] = [];
-		const solidifyNode = autoSolidify<string, string>({
-			verifyResults,
-			extract: () => {
-				throw new Error("extract boom");
-			},
-			write: () => {},
-		});
-		solidifyNode.subscribe((batch) => {
-			for (const m of batch) if (m[0] === ERROR) errors.push(m[1]);
-		});
-		verifyResults.emit(makeVR({ verified: true, artifact: "x" }));
-		expect(errors).toHaveLength(1);
-		expect((errors[0] as Error).message).toBe("extract boom");
-	});
-});
diff --git a/src/__tests__/utils/harness/evals/catalog-aware-evaluator.test.ts b/src/__tests__/utils/harness/evals/catalog-aware-evaluator.test.ts
deleted file mode 100644
index c5879bed..00000000
--- a/src/__tests__/utils/harness/evals/catalog-aware-evaluator.test.ts
+++ /dev/null
@@ -1,158 +0,0 @@
-/**
- * Unit tests for the dogfood `catalogAwareEvaluator` composer:
- *   - reads the live `catalog` from `overlay.effective` per scoring wave
- *   - re-runs when candidates / dataset / catalog settles
- *   - cancels in-flight scoring when a new wave supersedes
- *   - surfaces `runEvalSuite` rejects as ERROR
- */
-
-import { DATA, ERROR, node } from "@graphrefly/pure-ts/core";
-import { describe, expect, it } from "vitest";
-import { catalogAwareEvaluator } from "../../../../../evals/lib/catalog-aware-evaluator.js";
-import { catalogOverlay } from "../../../../../evals/lib/catalog-overlay.js";
-import { portableCatalog, portableFns } from "../../../../../evals/lib/portable-catalog.js";
-import type { DatasetItem, EvalResult } from "../../../presets/harness/refine-loop.js";
-import type { CatalogFnEntry } from "../../../utils/graphspec/index.js";
-
-const sentinelEntry: CatalogFnEntry = {
-	factory: () =>
-		({ subscribe: () => () => {} }) as unknown as ReturnType<CatalogFnEntry["factory"]>,
-	description: "sentinel",
-	tags: ["test"],
-};
-
-describe("catalogAwareEvaluator — happy path", () => {
-	it("invokes runEvalSuite with overlay catalog + candidates + dataset", async () => {
-		const overlay = catalogOverlay({ base: portableCatalog });
-		const calls: {
-			catalogSize: number;
-			candidates: readonly string[];
-			dataset: readonly DatasetItem[];
-		}[] = [];
-		const evaluator = catalogAwareEvaluator<string>({
-			overlay,
-			async runEvalSuite({ catalog, candidates, dataset }) {
-				calls.push({
-					catalogSize: Object.keys(catalog.fns ?? {}).length,
-					candidates,
-					dataset,
-				});
-				return dataset.map((d) => ({ taskId: d.id, score: 1 }));
-			},
-		});
-		const candidates = node<readonly string[]>([], { initial: ["c1"] });
-		const dataset = node<readonly DatasetItem[]>([], { initial: [{ id: "t1" }] });
-		const evalNode = evaluator(candidates, dataset);
-		const seen: readonly EvalResult[][] = [];
-		evalNode.subscribe((batch) => {
-			for (const m of batch) {
-				if (m[0] === DATA && m[1] != null) (seen as EvalResult[][]).push(m[1] as EvalResult[]);
-			}
-		});
-		// Microtasks for the producer + Promise resolution.
-		await Promise.resolve();
-		await Promise.resolve();
-		await Promise.resolve();
-		expect(calls).toHaveLength(1);
-		expect(calls[0].catalogSize).toBe(Object.keys(portableFns).length);
-		expect(calls[0].candidates).toEqual(["c1"]);
-		expect(calls[0].dataset).toEqual([{ id: "t1" }]);
-		expect(seen[0]).toEqual([{ taskId: "t1", score: 1 }]);
-	});
-
-	it("snapshots overlay per candidates/dataset wave (no feedback loop on overlay change)", async () => {
-		// The evaluator reads `overlay.effective.cache` at scoring time
-		// rather than subscribing to it — this prevents the autoSolidify
-		// feedback cycle (verifier writes to overlay → overlay settles →
-		// reactive evaluator re-fires → autoSolidify writes again …).
-		const overlay = catalogOverlay({ base: portableCatalog });
-		const sizes: number[] = [];
-		const evaluator = catalogAwareEvaluator<string>({
-			overlay,
-			async runEvalSuite({ catalog }) {
-				sizes.push(Object.keys(catalog.fns ?? {}).length);
-				return [];
-			},
-		});
-		const candidates = node<readonly string[]>([], { initial: ["c"] });
-		const dataset = node<readonly DatasetItem[]>([], { initial: [{ id: "t1" }] });
-		const evalNode = evaluator(candidates, dataset);
-		evalNode.subscribe(() => {});
-		await Promise.resolve();
-		await Promise.resolve();
-		const baselineCount = sizes.length;
-		// Mutate overlay — must NOT trigger an evaluator recompute on its own.
-		overlay.upsertFn("brandNewFn", sentinelEntry);
-		await Promise.resolve();
-		await Promise.resolve();
-		expect(sizes.length).toBe(baselineCount);
-		// New candidates wave — picks up the post-mutation overlay snapshot.
-		candidates.emit(["c2"]);
-		await Promise.resolve();
-		await Promise.resolve();
-		expect(sizes.length).toBe(baselineCount + 1);
-		expect(sizes[sizes.length - 1]).toBe(Object.keys(portableFns).length + 1);
-		overlay.dispose();
-	});
-});
-
-describe("catalogAwareEvaluator — failure surfacing", () => {
-	it("surfaces runEvalSuite reject as ERROR", async () => {
-		const overlay = catalogOverlay({ base: portableCatalog });
-		const evaluator = catalogAwareEvaluator<string>({
-			overlay,
-			async runEvalSuite() {
-				throw new Error("eval boom");
-			},
-		});
-		const candidates = node<readonly string[]>([], { initial: ["c"] });
-		const dataset = node<readonly DatasetItem[]>([], { initial: [{ id: "t1" }] });
-		const evalNode = evaluator(candidates, dataset);
-		const errors: unknown[] = [];
-		evalNode.subscribe((batch) => {
-			for (const m of batch) {
-				if (m[0] === ERROR) errors.push(m[1]);
-			}
-		});
-		await Promise.resolve();
-		await Promise.resolve();
-		await Promise.resolve();
-		expect(errors).toHaveLength(1);
-		expect((errors[0] as Error).message).toBe("eval boom");
-	});
-});
-
-describe("catalogAwareEvaluator — supersede cancellation", () => {
-	it("aborts in-flight scoring when a new candidates wave fires", async () => {
-		const overlay = catalogOverlay({ base: portableCatalog });
-		const seenSignals: AbortSignal[] = [];
-		const evaluator = catalogAwareEvaluator<string>({
-			overlay,
-			async runEvalSuite({ signal }) {
-				seenSignals.push(signal);
-				return new Promise<readonly EvalResult[]>((_resolve, reject) => {
-					if (signal.aborted) {
-						reject(new DOMException("aborted", "AbortError"));
-						return;
-					}
-					signal.addEventListener("abort", () => reject(new DOMException("aborted", "AbortError")));
-				});
-			},
-		});
-		const candidates = node<readonly string[]>([], { initial: ["c1"] });
-		const dataset = node<readonly DatasetItem[]>([], { initial: [{ id: "t1" }] });
-		const evalNode = evaluator(candidates, dataset);
-		evalNode.subscribe(() => {});
-		await Promise.resolve();
-		await Promise.resolve();
-		expect(seenSignals).toHaveLength(1);
-		expect(seenSignals[0].aborted).toBe(false);
-		// New candidates wave — triggers a new recompute → prior signal aborts.
-		candidates.emit(["c2"]);
-		await Promise.resolve();
-		await Promise.resolve();
-		expect(seenSignals[0].aborted).toBe(true);
-		expect(seenSignals.length).toBeGreaterThanOrEqual(2);
-		overlay.dispose();
-	});
-});
diff --git a/src/__tests__/utils/harness/evals/catalog-overlay.test.ts b/src/__tests__/utils/harness/evals/catalog-overlay.test.ts
deleted file mode 100644
index 4eab65f1..00000000
--- a/src/__tests__/utils/harness/evals/catalog-overlay.test.ts
+++ /dev/null
@@ -1,123 +0,0 @@
-/**
- * Unit tests for the dogfood `catalogOverlay` reactive overlay over
- * `portableCatalog`. Validates that:
- *   - effective catalog merges base ∪ overlay
- *   - overlay upserts shadow base entries with matching names
- *   - tombstones (delete patches) shadow base entries
- *   - templates use a separate overlay surface
- *   - `effective` re-emits exactly when overlay state changes
- */
-
-import { DATA } from "@graphrefly/pure-ts/core";
-import { describe, expect, it } from "vitest";
-import { type CatalogPatch, catalogOverlay } from "../../../../../evals/lib/catalog-overlay.js";
-import { portableCatalog, portableFns } from "../../../../../evals/lib/portable-catalog.js";
-import { portableTemplates } from "../../../../../evals/lib/portable-templates.js";
-import type { CatalogFnEntry, GraphSpecCatalog } from "../../../utils/graphspec/index.js";
-
-const sentinelEntry: CatalogFnEntry = {
-	factory: () =>
-		({ subscribe: () => () => {} }) as unknown as ReturnType<CatalogFnEntry["factory"]>,
-	description: "sentinel test entry",
-	tags: ["test"],
-};
-
-function snapshot(node: { cache?: GraphSpecCatalog | undefined }): GraphSpecCatalog {
-	const cached = node.cache;
-	if (!cached) throw new Error("expected effective catalog node to have cached value");
-	return cached;
-}
-
-describe("catalogOverlay — base passthrough", () => {
-	it("effective catalog equals base when overlay is empty", () => {
-		const overlay = catalogOverlay({ base: portableCatalog });
-		// Force the derived to settle by subscribing.
-		overlay.effective.subscribe(() => {});
-		const eff = snapshot(overlay.effective);
-		expect(Object.keys(eff.fns ?? {})).toEqual(Object.keys(portableFns));
-		// No accidental aliasing — overlay returns a fresh record.
-		expect(eff.fns).not.toBe(portableFns);
-		overlay.dispose();
-	});
-});
-
-describe("catalogOverlay — fn upsert / shadow / delete", () => {
-	it("upsertFn adds a new entry visible in effective", () => {
-		const overlay = catalogOverlay({ base: portableCatalog });
-		overlay.effective.subscribe(() => {});
-		const patch = overlay.upsertFn("brandNewFn", sentinelEntry);
-		expect(patch.kind).toBe("fn-upsert");
-		const eff = snapshot(overlay.effective);
-		expect(eff.fns?.brandNewFn).toBe(sentinelEntry);
-		overlay.dispose();
-	});
-
-	it("upsertFn shadows a base entry with the same name", () => {
-		const overlay = catalogOverlay({ base: portableCatalog });
-		overlay.effective.subscribe(() => {});
-		// `filterBy` exists in portableFns — overlay should win.
-		overlay.upsertFn("filterBy", sentinelEntry);
-		const eff = snapshot(overlay.effective);
-		expect(eff.fns?.filterBy).toBe(sentinelEntry);
-		expect(eff.fns?.filterBy).not.toBe(portableFns.filterBy);
-		overlay.dispose();
-	});
-
-	it("fn-delete patch tombstones a base entry", () => {
-		const overlay = catalogOverlay({ base: portableCatalog });
-		overlay.effective.subscribe(() => {});
-		const before = snapshot(overlay.effective);
-		expect(before.fns?.filterBy).toBeDefined();
-		overlay.applyPatch({ kind: "fn-delete", name: "filterBy" } as CatalogPatch);
-		const after = snapshot(overlay.effective);
-		expect(after.fns?.filterBy).toBeUndefined();
-		overlay.dispose();
-	});
-
-	it("reset() restores base view", () => {
-		const overlay = catalogOverlay({ base: portableCatalog });
-		overlay.effective.subscribe(() => {});
-		overlay.upsertFn("brandNewFn", sentinelEntry);
-		overlay.applyPatch({ kind: "fn-delete", name: "filterBy" } as CatalogPatch);
-		overlay.reset();
-		const eff = snapshot(overlay.effective);
-		expect(eff.fns?.filterBy).toBeDefined();
-		expect(eff.fns?.brandNewFn).toBeUndefined();
-		overlay.dispose();
-	});
-});
-
-describe("catalogOverlay — templates", () => {
-	it("effective templates expose base + overlay merge", () => {
-		const overlay = catalogOverlay({ baseTemplates: portableTemplates });
-		overlay.effectiveTemplates.subscribe(() => {});
-		const before = overlay.effectiveTemplates.cache;
-		expect(before).toBeDefined();
-		expect(Object.keys(before ?? {}).length).toBe(Object.keys(portableTemplates).length);
-
-		const newTpl = { params: ["x"], nodes: {}, output: "x" };
-		overlay.upsertTemplate("brandNew", newTpl);
-		const after = overlay.effectiveTemplates.cache;
-		expect(after?.brandNew).toBe(newTpl);
-		overlay.dispose();
-	});
-});
-
-describe("catalogOverlay — reactive emission cadence", () => {
-	it("effective emits a fresh snapshot on every patch", () => {
-		const overlay = catalogOverlay({ base: portableCatalog });
-		const seen: GraphSpecCatalog[] = [];
-		overlay.effective.subscribe((msgs) => {
-			for (const m of msgs) {
-				if (m[0] === DATA && m[1] != null) seen.push(m[1] as GraphSpecCatalog);
-			}
-		});
-		// Initial subscription gives one DATA.
-		const initialCount = seen.length;
-		overlay.upsertFn("brandNewFn", sentinelEntry);
-		overlay.upsertFn("anotherOne", sentinelEntry);
-		// Each upsert should produce a new effective snapshot.
-		expect(seen.length - initialCount).toBe(2);
-		overlay.dispose();
-	});
-});
diff --git a/src/__tests__/utils/harness/evals/contrastive-resume.test.ts b/src/__tests__/utils/harness/evals/contrastive-resume.test.ts
deleted file mode 100644
index b7446138..00000000
--- a/src/__tests__/utils/harness/evals/contrastive-resume.test.ts
+++ /dev/null
@@ -1,57 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-	type ContrastiveResumeConfig,
-	sliceContrastiveTasksForResume,
-} from "../../../../../evals/lib/contrastive.js";
-import type { EvalTask } from "../../../../../evals/lib/types.js";
-
-const tasks: EvalTask[] = [
-	{
-		id: "a",
-		category: "linear",
-		nl_description: "x",
-		complexity: "low",
-	},
-	{
-		id: "b",
-		category: "linear",
-		nl_description: "y",
-		complexity: "low",
-	},
-	{
-		id: "c",
-		category: "linear",
-		nl_description: "z",
-		complexity: "low",
-	},
-];
-
-describe("sliceContrastiveTasksForResume", () => {
-	it("returns full list when no resume options", () => {
-		const cfg: ContrastiveResumeConfig = {};
-		expect(sliceContrastiveTasksForResume(tasks, cfg)).toEqual(tasks);
-	});
-
-	it("slices from EVAL_L0_FROM (inclusive)", () => {
-		const cfg: ContrastiveResumeConfig = { l0FromTaskId: "b" };
-		expect(sliceContrastiveTasksForResume(tasks, cfg)).toEqual([tasks[1], tasks[2]]);
-	});
-
-	it("slices after EVAL_L0_AFTER (exclusive)", () => {
-		const cfg: ContrastiveResumeConfig = { l0ResumeAfterTaskId: "b" };
-		expect(sliceContrastiveTasksForResume(tasks, cfg)).toEqual([tasks[2]]);
-	});
-
-	it("rejects unknown task id", () => {
-		const cfg: ContrastiveResumeConfig = { l0FromTaskId: "nope" };
-		expect(() => sliceContrastiveTasksForResume(tasks, cfg)).toThrow(/unknown task id/);
-	});
-
-	it("rejects both from and after", () => {
-		const cfg: ContrastiveResumeConfig = {
-			l0FromTaskId: "a",
-			l0ResumeAfterTaskId: "b",
-		};
-		expect(() => sliceContrastiveTasksForResume(tasks, cfg)).toThrow(/only one of/);
-	});
-});
diff --git a/src/__tests__/utils/harness/evals/cost-safety.test.ts b/src/__tests__/utils/harness/evals/cost-safety.test.ts
deleted file mode 100644
index 65b4ba69..00000000
--- a/src/__tests__/utils/harness/evals/cost-safety.test.ts
+++ /dev/null
@@ -1,250 +0,0 @@
-import { mkdtempSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import {
-	BudgetExceededError,
-	type BudgetGateOptions,
-	withBudgetGate,
-} from "../../../../../evals/lib/budget-gate.js";
-import { createDryRunProvider } from "../../../../../evals/lib/dry-run-provider.js";
-import type { LLMProvider, LLMRequest, LLMResponse } from "../../../../../evals/lib/llm-client.js";
-import { ReplayCacheMissError, withReplayCache } from "../../../../../evals/lib/replay-cache.js";
-
-// ---------------------------------------------------------------------------
-// Test provider — counts calls, parameterizable response.
-// ---------------------------------------------------------------------------
-
-function makeMockProvider(
-	responses: readonly LLMResponse[] | ((req: LLMRequest, n: number) => LLMResponse),
-): LLMProvider & { calls: number } {
-	let n = 0;
-	const provider = {
-		name: "mock",
-		limits: {
-			contextWindow: 100_000,
-			maxOutputTokens: 10_000,
-			rpm: 60,
-			rpd: 1_000,
-			tpm: 100_000,
-		},
-		async generate(req: LLMRequest): Promise<LLMResponse> {
-			n += 1;
-			provider.calls = n;
-			if (typeof responses === "function") return responses(req, n);
-			return responses[Math.min(n - 1, responses.length - 1)];
-		},
-		calls: 0,
-	};
-	return provider;
-}
-
-const sampleReq: LLMRequest = {
-	system: "sys",
-	user: "hi",
-	model: "claude-haiku-4-5-20251001", // known in cost.ts pricing table
-	maxTokens: 50,
-};
-
-// ---------------------------------------------------------------------------
-// Dry-run provider
-// ---------------------------------------------------------------------------
-
-describe("createDryRunProvider", () => {
-	it("returns canned content and zero tokens", async () => {
-		const p = createDryRunProvider({ cannedContent: "stub" });
-		const r = await p.generate(sampleReq);
-		expect(r.content).toBe("stub");
-		expect(r.inputTokens).toBe(0);
-		expect(r.outputTokens).toBe(0);
-		expect(r.latencyMs).toBe(0);
-	});
-
-	it("fires onCall with incrementing call numbers", async () => {
-		const seen: number[] = [];
-		const p = createDryRunProvider({ onCall: (_req, n) => seen.push(n) });
-		await p.generate(sampleReq);
-		await p.generate(sampleReq);
-		await p.generate(sampleReq);
-		expect(seen).toEqual([1, 2, 3]);
-	});
-});
-
-// ---------------------------------------------------------------------------
-// Budget gate
-// ---------------------------------------------------------------------------
-
-describe("withBudgetGate", () => {
-	it("enforces maxCalls", async () => {
-		const mock = makeMockProvider([
-			{ content: "a", inputTokens: 10, outputTokens: 5, latencyMs: 1 },
-		]);
-		const gated = withBudgetGate(mock, { caps: { maxCalls: 2 } });
-		await gated.generate(sampleReq);
-		await gated.generate(sampleReq);
-		await expect(gated.generate(sampleReq)).rejects.toBeInstanceOf(BudgetExceededError);
-		expect(mock.calls).toBe(2); // third call never reached the inner provider
-	});
-
-	it("enforces maxPriceUsd post-call and surfaces on the crossing call", async () => {
-		// haiku pricing: 0.8 input / 4 output per 1M. 1000 input + 500 output = $0.0028 per call.
-		const mock = makeMockProvider([
-			{ content: "a", inputTokens: 1000, outputTokens: 500, latencyMs: 1 },
-		]);
-		const exceeded: BudgetExceededError[] = [];
-		const gated = withBudgetGate(mock, {
-			caps: { maxPriceUsd: 0.005 },
-			onExceed: (err) => exceeded.push(err),
-		});
-		// First call: priceUsd = 0.0028 < 0.005 → ok.
-		await gated.generate(sampleReq);
-		// Second call: 0.0056 ≥ 0.005 → inner runs, then post-call check throws.
-		await expect(gated.generate(sampleReq)).rejects.toThrow(BudgetExceededError);
-		expect(exceeded).toHaveLength(1);
-		expect(exceeded[0].cap).toBe("maxPriceUsd");
-		expect(mock.calls).toBe(2); // crossing call DID hit the inner provider
-	});
-
-	it("fires onUpdate after each successful call", async () => {
-		const mock = makeMockProvider([
-			{ content: "a", inputTokens: 10, outputTokens: 5, latencyMs: 1 },
-		]);
-		const states: number[] = [];
-		const gated = withBudgetGate(mock, {
-			caps: { maxCalls: 10 },
-			onUpdate: (s) => states.push(s.calls),
-		});
-		await gated.generate(sampleReq);
-		await gated.generate(sampleReq);
-		expect(states).toEqual([1, 2]);
-	});
-
-	it("reset() clears state", async () => {
-		const mock = makeMockProvider([
-			{ content: "a", inputTokens: 10, outputTokens: 5, latencyMs: 1 },
-		]);
-		const gated = withBudgetGate(mock, { caps: { maxCalls: 2 } });
-		await gated.generate(sampleReq);
-		await gated.generate(sampleReq);
-		await expect(gated.generate(sampleReq)).rejects.toThrow(BudgetExceededError);
-		gated.reset();
-		await expect(gated.generate(sampleReq)).resolves.toBeDefined();
-	});
-
-	it("unknown model contributes 0 price; relies on call/token caps", async () => {
-		const mock = makeMockProvider([
-			{ content: "a", inputTokens: 100, outputTokens: 100, latencyMs: 1 },
-		]);
-		const gated = withBudgetGate(mock, {
-			caps: { maxPriceUsd: 0.01, maxCalls: 3 },
-		});
-		const reqUnknown: LLMRequest = { ...sampleReq, model: "unknown-model-xyz" };
-		await gated.generate(reqUnknown);
-		await gated.generate(reqUnknown);
-		expect(gated.state.priceUsd).toBe(0); // unknown → zero
-		// Call cap still enforced.
-		await gated.generate(reqUnknown);
-		await expect(gated.generate(reqUnknown)).rejects.toThrow(BudgetExceededError);
-	});
-});
-
-// ---------------------------------------------------------------------------
-// Replay cache
-// ---------------------------------------------------------------------------
-
-describe("withReplayCache", () => {
-	let cacheDir: string;
-	beforeEach(() => {
-		cacheDir = mkdtempSync(join(tmpdir(), "replay-cache-test-"));
-	});
-	afterEach(() => {
-		rmSync(cacheDir, { recursive: true, force: true });
-	});
-
-	it("writes on miss, reads on hit (read-write default)", async () => {
-		const mock = makeMockProvider([
-			{ content: "first", inputTokens: 10, outputTokens: 5, latencyMs: 123 },
-		]);
-		const wrapped = withReplayCache(mock, { cacheDir });
-		const r1 = await wrapped.generate(sampleReq);
-		expect(r1.content).toBe("first");
-		expect(mock.calls).toBe(1);
-		// Second call: cache hit — inner not invoked, latencyMs zeroed.
-		const r2 = await wrapped.generate(sampleReq);
-		expect(r2.content).toBe("first");
-		expect(r2.latencyMs).toBe(0);
-		expect(mock.calls).toBe(1);
-	});
-
-	it("read-only throws on miss", async () => {
-		const mock = makeMockProvider([
-			{ content: "x", inputTokens: 1, outputTokens: 1, latencyMs: 1 },
-		]);
-		const wrapped = withReplayCache(mock, { cacheDir, mode: "read-only" });
-		await expect(wrapped.generate(sampleReq)).rejects.toBeInstanceOf(ReplayCacheMissError);
-		expect(mock.calls).toBe(0);
-	});
-
-	it("write-only always calls inner and overwrites cache", async () => {
-		const mock = makeMockProvider((_req, n) => ({
-			content: `call-${n}`,
-			inputTokens: n,
-			outputTokens: n,
-			latencyMs: 10,
-		}));
-		const wrapped = withReplayCache(mock, { cacheDir, mode: "write-only" });
-		const r1 = await wrapped.generate(sampleReq);
-		const r2 = await wrapped.generate(sampleReq);
-		expect(r1.content).toBe("call-1");
-		expect(r2.content).toBe("call-2");
-		expect(mock.calls).toBe(2);
-	});
-
-	it("off: passthrough, nothing cached", async () => {
-		const mock = makeMockProvider((_req, n) => ({
-			content: `call-${n}`,
-			inputTokens: n,
-			outputTokens: n,
-			latencyMs: 10,
-		}));
-		const wrapped = withReplayCache(mock, { cacheDir, mode: "off" });
-		const r1 = await wrapped.generate(sampleReq);
-		const r2 = await wrapped.generate(sampleReq);
-		expect(r1.content).toBe("call-1");
-		expect(r2.content).toBe("call-2");
-	});
-
-	it("different models yield different cache keys", async () => {
-		const mock = makeMockProvider((req, n) => ({
-			content: `${req.model}-${n}`,
-			inputTokens: 1,
-			outputTokens: 1,
-			latencyMs: 1,
-		}));
-		const wrapped = withReplayCache(mock, { cacheDir });
-		const a = await wrapped.generate({ ...sampleReq, model: "model-a" });
-		const b = await wrapped.generate({ ...sampleReq, model: "model-b" });
-		expect(a.content).toBe("model-a-1");
-		expect(b.content).toBe("model-b-2");
-		expect(mock.calls).toBe(2);
-	});
-
-	it("composes with budget gate — cache hit does NOT charge budget", async () => {
-		const mock = makeMockProvider([
-			{ content: "hello", inputTokens: 1000, outputTokens: 500, latencyMs: 20 },
-		]);
-		// Wrapping order per llm-client.ts: cache OUTSIDE budget.
-		const budgetOpts: BudgetGateOptions = { caps: { maxCalls: 2 } };
-		const gated = withBudgetGate(mock, budgetOpts);
-		const cached = withReplayCache(gated, { cacheDir });
-		// First call: miss → inner (budget charged).
-		await cached.generate(sampleReq);
-		expect(gated.state.calls).toBe(1);
-		// Second call: hit → inner NOT called, budget NOT charged.
-		await cached.generate(sampleReq);
-		expect(gated.state.calls).toBe(1);
-		// Third call: still a hit, still no budget charge.
-		await cached.generate(sampleReq);
-		expect(gated.state.calls).toBe(1);
-	});
-});
diff --git a/src/__tests__/utils/harness/evals/merge-runs.test.ts b/src/__tests__/utils/harness/evals/merge-runs.test.ts
deleted file mode 100644
index 6b45bfde..00000000
--- a/src/__tests__/utils/harness/evals/merge-runs.test.ts
+++ /dev/null
@@ -1,166 +0,0 @@
-import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { mergeAndWriteResults, mergeRuns } from "../../../../../evals/lib/reporter.js";
-import type { EvalRun, TaskResult } from "../../../../../evals/lib/types.js";
-
-function task(id: string, treatment: "graphspec" | "functions", valid: boolean): TaskResult {
-	return {
-		task_id: id,
-		treatment,
-		raw_output: "",
-		valid,
-		runnable: valid,
-		judge_scores: [],
-		latency_ms: 100,
-		token_count: { input: 1000, output: 200 },
-		cost_usd: 0.01,
-	};
-}
-
-function makeRun(runId: string, tasks: TaskResult[], totalCost = 0.1): EvalRun {
-	return {
-		run_id: runId,
-		timestamp: new Date().toISOString(),
-		layer: "L0",
-		model: "gemini-2.0-flash",
-		provider: "google",
-		schema_version: "scaffold",
-		scores: {
-			"L0-M1-graphspec-error-rate": 0,
-			"L0-M1-functions-error-rate": 0,
-			"L0-M1-ratio": 0,
-		},
-		tasks,
-		total_cost_usd: totalCost,
-		rate_limit_stats: {
-			total_retries: 1,
-			total_wait_ms: 500,
-			effective_rpm: 60,
-			effective_tpm: 100_000,
-		},
-	};
-}
-
-describe("mergeRuns", () => {
-	it("carries over prior tasks not in the new run", () => {
-		const prev = makeRun("l0-trial1", [
-			task("t1", "graphspec", true),
-			task("t1", "functions", true),
-		]);
-		const current = makeRun("l0-trial1", [
-			task("t2", "graphspec", true),
-			task("t2", "functions", true),
-		]);
-		const merged = mergeRuns(prev, current);
-		expect(merged.tasks).toHaveLength(4);
-		const ids = merged.tasks.map((t) => `${t.task_id}::${t.treatment}`);
-		expect(ids).toEqual(["t1::graphspec", "t1::functions", "t2::graphspec", "t2::functions"]);
-	});
-
-	it("dedupes by task_id+treatment, last write wins", () => {
-		const prev = makeRun("l0-trial1", [task("t1", "graphspec", false)]);
-		const current = makeRun("l0-trial1", [task("t1", "graphspec", true)]);
-		const merged = mergeRuns(prev, current);
-		expect(merged.tasks).toHaveLength(1);
-		expect(merged.tasks[0]?.valid).toBe(true);
-	});
-
-	it("recomputes L0 scores over the merged set", () => {
-		// 2 graphspec tasks: 1 valid, 1 invalid → graphspec error rate = 0.5
-		// 2 functions tasks: 0 valid, 2 invalid → functions error rate = 1.0
-		const prev = makeRun("l0-trial1", [
-			task("t1", "graphspec", true),
-			task("t1", "functions", false),
-		]);
-		const current = makeRun("l0-trial1", [
-			task("t2", "graphspec", false),
-			task("t2", "functions", false),
-		]);
-		const merged = mergeRuns(prev, current);
-		expect(merged.scores["L0-M1-graphspec-error-rate"]).toBeCloseTo(0.5);
-		expect(merged.scores["L0-M1-functions-error-rate"]).toBeCloseTo(1.0);
-		expect(merged.scores["L0-M1-ratio"]).toBeCloseTo(0.5);
-	});
-
-	it("recomputes total_cost_usd from merged task set (no double counting on resume)", () => {
-		// Each task fixture has cost_usd=0.01 → 2 unique tasks merged = $0.02.
-		// A naive prev+current sum would give $0.05+$0.07=$0.12, wrong because
-		// cached task costs re-appear in `current.total_cost_usd`.
-		const prev = makeRun("l0-trial1", [task("t1", "graphspec", true)], 0.05);
-		const current = makeRun("l0-trial1", [task("t2", "graphspec", true)], 0.07);
-		const merged = mergeRuns(prev, current);
-		expect(merged.total_cost_usd).toBeCloseTo(0.02);
-		expect(merged.rate_limit_stats?.total_retries).toBe(2);
-		expect(merged.rate_limit_stats?.total_wait_ms).toBe(1000);
-	});
-
-	it("total_cost_usd reflects dedupe — a resume that re-runs cached tasks doesn't double-count", () => {
-		const t1 = task("t1", "graphspec", true);
-		const t2 = task("t2", "graphspec", true);
-		// Scenario: Run 1 completes t1+t2 (cost $0.02), Run 2 resumes and
-		// re-sees both as cache hits (cost $0.02), then completes t3.
-		const prev = makeRun("l0-trial1", [t1, t2], 0.02);
-		const current = makeRun("l0-trial1", [t1, t2, task("t3", "graphspec", true)], 0.03);
-		const merged = mergeRuns(prev, current);
-		expect(merged.tasks).toHaveLength(3);
-		expect(merged.total_cost_usd).toBeCloseTo(0.03); // 3 tasks × $0.01, not $0.05
-	});
-
-	it("uses the new run's timestamp + scores' shape (newer metadata wins)", () => {
-		const prev = makeRun("l0-trial1", [task("t1", "graphspec", true)]);
-		prev.timestamp = "2026-01-01T00:00:00.000Z";
-		prev.model = "old-model";
-		const current = makeRun("l0-trial1", [task("t2", "graphspec", true)]);
-		const merged = mergeRuns(prev, current);
-		expect(merged.timestamp).toBe(current.timestamp);
-		expect(merged.model).toBe(current.model);
-	});
-});
-
-describe("mergeAndWriteResults", () => {
-	let dir: string;
-	beforeEach(() => {
-		dir = mkdtempSync(join(tmpdir(), "merge-runs-"));
-	});
-	afterEach(() => {
-		rmSync(dir, { recursive: true, force: true });
-	});
-
-	it("writes the run as-is when no prior file exists", async () => {
-		const path = join(dir, "fresh.json");
-		const run = makeRun("l0-fresh", [task("t1", "graphspec", true)]);
-		const persisted = await mergeAndWriteResults(run, path);
-		expect(persisted.tasks).toHaveLength(1);
-		const ondisk = JSON.parse(readFileSync(path, "utf-8")) as EvalRun;
-		expect(ondisk.run_id).toBe("l0-fresh");
-	});
-
-	it("merges new tasks into an existing file with the same run_id", async () => {
-		const path = join(dir, "trial1.json");
-		const first = makeRun("l0-trial1", [
-			task("t1", "graphspec", true),
-			task("t1", "functions", true),
-		]);
-		await mergeAndWriteResults(first, path);
-
-		const second = makeRun("l0-trial1", [
-			task("t2", "graphspec", true),
-			task("t2", "functions", true),
-		]);
-		const persisted = await mergeAndWriteResults(second, path);
-
-		expect(persisted.tasks).toHaveLength(4);
-		const ondisk = JSON.parse(readFileSync(path, "utf-8")) as EvalRun;
-		expect(ondisk.tasks).toHaveLength(4);
-	});
-
-	it("throws on run_id mismatch — refuses to silently overwrite", async () => {
-		const path = join(dir, "trial1.json");
-		writeFileSync(path, JSON.stringify(makeRun("l0-existing", [task("t1", "graphspec", true)])));
-
-		const wrong = makeRun("l0-different", [task("t2", "graphspec", true)]);
-		await expect(mergeAndWriteResults(wrong, path)).rejects.toThrow(/Run id mismatch/);
-	});
-});
diff --git a/src/__tests__/utils/harness/evals/portable-catalog.test.ts b/src/__tests__/utils/harness/evals/portable-catalog.test.ts
deleted file mode 100644
index 241ae1cf..00000000
--- a/src/__tests__/utils/harness/evals/portable-catalog.test.ts
+++ /dev/null
@@ -1,226 +0,0 @@
-import { factoryTag } from "@graphrefly/pure-ts/core";
-import { describe, expect, it } from "vitest";
-import {
-	portableCatalog,
-	portableFns,
-	portableSources,
-} from "../../../../../evals/lib/portable-catalog.js";
-import {
-	adaptivePollerTemplate,
-	portableTemplates,
-	resilientFetchTemplate,
-} from "../../../../../evals/lib/portable-templates.js";
-import {
-	type GraphSpec,
-	generateCatalogPrompt,
-	validateSpec,
-	validateSpecAgainstCatalog,
-} from "../../../../utils/graphspec/index.js";
-
-// ---------------------------------------------------------------------------
-// Catalog shape
-// ---------------------------------------------------------------------------
-
-describe("portableCatalog — shape", () => {
-	it("exposes fns and sources", () => {
-		expect(Object.keys(portableFns).length).toBeGreaterThan(40);
-		expect(Object.keys(portableSources).length).toBeGreaterThan(15);
-		expect(portableCatalog.fns).toBe(portableFns);
-		expect(portableCatalog.sources).toBe(portableSources);
-	});
-
-	it("every fn has a description and a single tag", () => {
-		for (const [name, entry] of Object.entries(portableFns)) {
-			expect(entry.description, `${name} description`).toBeTruthy();
-			expect(entry.tags?.length ?? 0, `${name} tags`).toBeGreaterThanOrEqual(1);
-		}
-	});
-
-	it("every source has a description", () => {
-		for (const [name, entry] of Object.entries(portableSources)) {
-			expect(entry.description, `${name} description`).toBeTruthy();
-		}
-	});
-
-	it("Treatment-D additions are present", () => {
-		// `conditionalMap` fn (T6 interval-computation gap)
-		expect(portableFns.conditionalMap).toBeDefined();
-
-		// `median` op added to `aggregate` (T8a "avg ≠ median" gap)
-		const aggregate = portableFns.aggregate;
-		expect(aggregate?.configSchema?.op?.enum).toContain("median");
-
-		// `llmScore` description carries DB-comparison guidance (T11 gap)
-		expect(portableFns.llmScore?.description).toMatch(/database/i);
-	});
-});
-
-// ---------------------------------------------------------------------------
-// generateCatalogPrompt
-// ---------------------------------------------------------------------------
-
-describe("portableCatalog — generateCatalogPrompt", () => {
-	const prompt = generateCatalogPrompt(portableCatalog);
-
-	it("includes every fn name", () => {
-		for (const name of Object.keys(portableFns)) {
-			expect(prompt, `fn ${name} should appear in prompt`).toContain(`- ${name}:`);
-		}
-	});
-
-	it("includes every source name", () => {
-		for (const name of Object.keys(portableSources)) {
-			expect(prompt, `source ${name} should appear in prompt`).toContain(`- ${name}:`);
-		}
-	});
-
-	it("groups by section header (matching the manual prompt)", () => {
-		expect(prompt).toContain("Transforms & filters:");
-		expect(prompt).toContain("AI / LLM:");
-		expect(prompt).toContain("Resilience:");
-		expect(prompt).toContain("Effects (sinks):");
-		expect(prompt).toContain("Sources:");
-	});
-
-	it("encodes config field schemas as `Config: { ... }`", () => {
-		// filterBy's three required fields are in the prompt
-		expect(prompt).toMatch(/filterBy:.*Config:.*field.*op.*\(eq\|gt\|lt\|contains\).*value/s);
-	});
-});
-
-// ---------------------------------------------------------------------------
-// validateSpecAgainstCatalog
-// ---------------------------------------------------------------------------
-
-describe("portableCatalog — validateSpecAgainstCatalog", () => {
-	it("accepts a hand-coded spec using catalog names", () => {
-		const spec: GraphSpec = {
-			name: "rss-to-slack",
-			nodes: {
-				rss: {
-					type: "producer",
-					deps: [],
-					meta: { ...factoryTag("rss", { url: "https://example.com/feed" }) },
-				},
-				filter: {
-					type: "derived",
-					deps: ["rss"],
-					meta: {
-						...factoryTag("filterBy", { field: "title", op: "contains", value: "AI" }),
-					},
-				},
-				notify: {
-					type: "effect",
-					deps: ["filter"],
-					meta: { ...factoryTag("sendSlack", { channel: "#ai-news" }) },
-				},
-			},
-		};
-		expect(validateSpec(spec).valid).toBe(true);
-		const result = validateSpecAgainstCatalog(spec, portableCatalog);
-		expect(result.valid, result.errors.join("; ")).toBe(true);
-	});
-
-	it("rejects a typo'd fn name with a 'did you mean?' suggestion", () => {
-		const spec: GraphSpec = {
-			name: "typo",
-			nodes: {
-				a: { type: "state", deps: [], value: 1 },
-				b: { type: "derived", deps: ["a"], meta: { ...factoryTag("filterBys") } }, // typo
-			},
-		};
-		const result = validateSpecAgainstCatalog(spec, portableCatalog);
-		expect(result.valid).toBe(false);
-		expect(result.errors[0]).toMatch(/filterBys.*not found/);
-		expect(result.errors[0]).toMatch(/Did you mean.*filterBy/);
-	});
-
-	it("rejects an aggregate with an unsupported op (Treatment D added 'median')", () => {
-		const spec: GraphSpec = {
-			name: "agg",
-			nodes: {
-				items: { type: "state", deps: [], value: [] },
-				avg: {
-					type: "derived",
-					deps: ["items"],
-					meta: { ...factoryTag("aggregate", { op: "stddev", field: "x" }) },
-				},
-			},
-		};
-		const result = validateSpecAgainstCatalog(spec, portableCatalog);
-		expect(result.valid).toBe(false);
-		expect(result.errors[0]).toMatch(/op.*expected one of.*median/);
-	});
-
-	it("accepts aggregate with op=median (Treatment D fix)", () => {
-		const spec: GraphSpec = {
-			name: "agg-median",
-			nodes: {
-				items: { type: "state", deps: [], value: [] },
-				med: {
-					type: "derived",
-					deps: ["items"],
-					meta: { ...factoryTag("aggregate", { op: "median", field: "price" }) },
-				},
-			},
-		};
-		expect(validateSpecAgainstCatalog(spec, portableCatalog).valid).toBe(true);
-	});
-});
-
-// ---------------------------------------------------------------------------
-// Treatment D templates
-// ---------------------------------------------------------------------------
-
-describe("portableTemplates", () => {
-	it("ships resilientFetch and adaptivePoller", () => {
-		expect(portableTemplates.resilientFetch).toBe(resilientFetchTemplate);
-		expect(portableTemplates.adaptivePoller).toBe(adaptivePollerTemplate);
-	});
-
-	it("resilientFetch has the canonical resilience nesting (rateLimiter → breaker → retry → timeout → fallback)", () => {
-		const t = resilientFetchTemplate;
-		expect(t.params).toEqual(["$source"]);
-		expect(t.output).toBe("status");
-		expect(t.nodes.rateLimited?.deps).toEqual(["$source"]);
-		expect(t.nodes.breaker?.deps).toEqual(["rateLimited"]);
-		expect(t.nodes.retried?.deps).toEqual(["breaker"]);
-		expect(t.nodes.timed?.deps).toEqual(["retried"]);
-		expect(t.nodes.withFallback?.deps).toEqual(["timed"]);
-		// fallback uses the cache state (closes T8a cache-bug gap)
-		const fallbackArgs = t.nodes.withFallback?.meta?.factoryArgs as
-			| { fallbackSource?: string }
-			| undefined;
-		expect(fallbackArgs?.fallbackSource).toBe("cache");
-		expect(t.nodes.cache?.type).toBe("state");
-	});
-
-	it("adaptivePoller has the dynamic-interval pattern", () => {
-		const t = adaptivePollerTemplate;
-		expect(t.params).toEqual(["$rateComputer"]);
-		expect(t.nodes.interval?.type).toBe("state");
-		expect(t.nodes.timer?.type).toBe("producer");
-		expect(t.nodes.fetch?.meta?.factory).toBe("conditionalMap");
-		expect(t.nodes.rateComputed?.deps).toEqual(["$rateComputer"]);
-	});
-
-	it("template inner-node factory names all resolve in the catalog", () => {
-		for (const [tName, template] of Object.entries(portableTemplates)) {
-			for (const [nName, node] of Object.entries(template.nodes)) {
-				const factoryName = node.meta?.factory as string | undefined;
-				if (!factoryName) continue;
-				if (node.type === "producer") {
-					expect(
-						portableSources[factoryName],
-						`${tName}.${nName} source=${factoryName} must be in catalog`,
-					).toBeDefined();
-				} else if (node.type !== "state") {
-					expect(
-						portableFns[factoryName],
-						`${tName}.${nName} fn=${factoryName} must be in catalog`,
-					).toBeDefined();
-				}
-			}
-		}
-	});
-});
diff --git a/src/__tests__/utils/harness/evals/prompt-template-validity.test.ts b/src/__tests__/utils/harness/evals/prompt-template-validity.test.ts
deleted file mode 100644
index cd50dbc9..00000000
--- a/src/__tests__/utils/harness/evals/prompt-template-validity.test.ts
+++ /dev/null
@@ -1,103 +0,0 @@
-/**
- * Fail-fast: the example specs embedded in eval prompt templates MUST
- * validate against `validateSpec()`. If you add a required field to the
- * validator and forget to update the prompt, this test fails — surfaces
- * the prompt/validator drift in CI before any LLM call is made.
- *
- * Discovered during a Treatment-A run on z-ai/glm-4.7: 100% graphspec
- * failures because the prompt described `{ nodes: {...} }` but the
- * validator required a top-level `name`. Cost: $0.33 + a half-day of
- * confused debugging. Cost of this test: 5 ms per CI run.
- */
-
-import { existsSync, readFileSync } from "node:fs";
-import { homedir } from "node:os";
-import { join } from "node:path";
-import { factoryTag } from "@graphrefly/pure-ts/core";
-import { describe, expect, it } from "vitest";
-import { portableCatalog } from "../../../../../evals/lib/portable-catalog.js";
-import {
-	type GraphSpec,
-	generateCatalogPrompt,
-	validateSpec,
-} from "../../../../utils/graphspec/index.js";
-
-/** Extract every ```json … ``` block from a markdown file as parsed JSON. */
-function extractJsonBlocks(md: string): unknown[] {
-	const pattern = /```json\n([\s\S]*?)\n```/g;
-	const blocks: unknown[] = [];
-	let m: RegExpExecArray | null;
-	m = pattern.exec(md);
-	while (m !== null) {
-		try {
-			blocks.push(JSON.parse(m[1] ?? ""));
-		} catch {
-			// non-JSON block (template literal, etc.) — skip
-		}
-		m = pattern.exec(md);
-	}
-	return blocks;
-}
-
-const SPEC_TEMPLATE_PATH = join(
-	process.env.SPEC_EVALS_PATH ?? join(homedir(), "src", "graphrefly", "evals"),
-	"templates",
-	"graphspec-treatment.md",
-);
-
-describe("Treatment A prompt template — example specs validate", () => {
-	if (!existsSync(SPEC_TEMPLATE_PATH)) {
-		it.skip("spec repo not present at SPEC_EVALS_PATH — skipping", () => {});
-		return;
-	}
-
-	const md = readFileSync(SPEC_TEMPLATE_PATH, "utf-8");
-	const examples = extractJsonBlocks(md);
-
-	it("contains at least two example specs", () => {
-		expect(examples.length).toBeGreaterThanOrEqual(2);
-	});
-
-	it.each(examples.map((ex, i) => [i, ex]))("example %d is a valid GraphSpec", (_i, ex) => {
-		const result = validateSpec(ex);
-		if (!result.valid) {
-			throw new Error(
-				`Treatment A prompt example failed validateSpec(): ${result.errors.join("; ")}\n` +
-					`Spec: ${JSON.stringify(ex, null, 2)}\n` +
-					`Path: ${SPEC_TEMPLATE_PATH}`,
-			);
-		}
-		expect(result.valid).toBe(true);
-	});
-});
-
-describe("Treatment B auto-gen prompt — round-trip with a minimal spec", () => {
-	// The auto-gen prompt doesn't embed example specs; it describes the schema.
-	// The fail-fast here: a minimal "from-the-prompt-description" spec must
-	// validate. If validateSpec() ever requires a new field, update the
-	// schema description in `contrastive.ts` AND the spec below in lockstep.
-	it("a minimal spec following the prompt's described shape validates", () => {
-		const spec: GraphSpec = {
-			name: "minimal-from-prompt-description",
-			nodes: {
-				src: { type: "state", deps: [], value: 0 },
-				out: { type: "derived", deps: ["src"], meta: { ...factoryTag("filterBy") } },
-			},
-		};
-		const result = validateSpec(spec);
-		expect(result.errors, JSON.stringify(result.errors)).toEqual([]);
-		expect(result.valid).toBe(true);
-	});
-
-	it("auto-generated catalog prompt mentions every required top-level field", () => {
-		// This is the prompt the LLM sees in Treatment B. It must describe the
-		// schema such that an LLM producing matching output gets a valid spec.
-		const prompt = generateCatalogPrompt(portableCatalog);
-		// generateCatalogPrompt only emits the catalog; the schema description
-		// lives in contrastive.ts TREATMENT_B_HEADER. The constraint we
-		// enforce here is positive: the prompt must NOT reference fields the
-		// validator doesn't accept. (Use catalog presence as a sanity check.)
-		expect(prompt).toContain("filterBy");
-		expect(prompt).toContain("Sources:");
-	});
-});
diff --git a/src/__tests__/utils/harness/evals/rate-limit-cache-order.test.ts b/src/__tests__/utils/harness/evals/rate-limit-cache-order.test.ts
deleted file mode 100644
index 7e5ece4c..00000000
--- a/src/__tests__/utils/harness/evals/rate-limit-cache-order.test.ts
+++ /dev/null
@@ -1,200 +0,0 @@
-import { mkdtempSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import type { LLMProvider, LLMRequest, LLMResponse } from "../../../../../evals/lib/llm-client.js";
-import { AdaptiveRateLimiter, withRateLimiter } from "../../../../../evals/lib/rate-limiter.js";
-import { withReplayCache } from "../../../../../evals/lib/replay-cache.js";
-
-// Tight stub provider — counts calls; no real I/O.
-function makeMockProvider(): LLMProvider & { calls: number } {
-	const provider = {
-		name: "mock",
-		limits: {
-			contextWindow: 100_000,
-			maxOutputTokens: 10_000,
-			// Aggressively low to make pacing observable in test time.
-			rpm: 2,
-			rpd: 1_000,
-			tpm: 100_000,
-		},
-		async generate(_req: LLMRequest): Promise<LLMResponse> {
-			provider.calls += 1;
-			return { content: "ok", inputTokens: 10, outputTokens: 5, latencyMs: 1 };
-		},
-		calls: 0,
-	};
-	return provider;
-}
-
-const sampleReq: LLMRequest = {
-	system: "sys",
-	user: "hi",
-	model: "claude-haiku-4-5-20251001",
-	maxTokens: 50,
-};
-
-describe("rate limiter wrapping order — cache hits skip pacing", () => {
-	let dir: string;
-	beforeEach(() => {
-		dir = mkdtempSync(join(tmpdir(), "rl-cache-order-"));
-	});
-	afterEach(() => {
-		rmSync(dir, { recursive: true, force: true });
-	});
-
-	it("withReplayCache(withRateLimiter(base)) — cache hits never reach the limiter window", async () => {
-		const base = makeMockProvider();
-		const limiter = new AdaptiveRateLimiter(base.limits);
-		const limited = withRateLimiter(base, limiter, { enabled: true });
-		const cached = withReplayCache(limited, { cacheDir: dir, mode: "read-write" });
-
-		// First call — cache miss → limiter records 1 request.
-		await cached.generate(sampleReq);
-		expect(base.calls).toBe(1);
-		const statsAfter1 = limiter.stats();
-		expect(statsAfter1.totalCalls).toBe(1);
-
-		// 50 cache hits — base never re-called, limiter window must NOT grow.
-		const start = Date.now();
-		for (let i = 0; i < 50; i++) {
-			await cached.generate(sampleReq);
-		}
-		const elapsed = Date.now() - start;
-
-		expect(base.calls).toBe(1); // still 1 — all 50 served from cache
-		// With pacing inside the cache, RPM=2 would have made this take 25+ minutes.
-		// Cache short-circuit means it should complete in <1s.
-		expect(elapsed).toBeLessThan(1_000);
-
-		// Limiter's own counter must not have been bumped by cache hits.
-		const statsAfter51 = limiter.stats();
-		expect(statsAfter51.totalCalls).toBe(1);
-	});
-
-	it("withRateLimiter labels itself for debug — cache key stability is owned by ReplayCacheOptions.providerKey", () => {
-		const base = makeMockProvider();
-		const limiter = new AdaptiveRateLimiter(base.limits);
-		const limited = withRateLimiter(base, limiter, { enabled: true });
-		// Honest debug label. Stability of cache keys across wrapper reshuffles
-		// is now the responsibility of `withReplayCache({ providerKey })`, not
-		// of every inner wrapper carefully not modifying inner.name.
-		expect(limited.name).toBe(`${base.name}+ratelimit`);
-	});
-
-	it("changing keyMaterialExtra invalidates the cache (registry-resolved maxOutput salt)", async () => {
-		const base = makeMockProvider();
-		const cacheV1 = withReplayCache(base, {
-			cacheDir: dir,
-			providerKey: "openrouter",
-			keyMaterialExtra: "maxOutput=4096",
-		});
-		const cacheV2 = withReplayCache(base, {
-			cacheDir: dir,
-			providerKey: "openrouter",
-			keyMaterialExtra: "maxOutput=32768", // bumped registry default
-		});
-
-		await cacheV1.generate(sampleReq);
-		expect(base.calls).toBe(1);
-		// Same provider, same prompt, but different keyMaterialExtra → cache miss.
-		await cacheV2.generate(sampleReq);
-		expect(base.calls).toBe(2);
-	});
-
-	it("dry-run and real responses must NOT share a cache key", async () => {
-		const baseReal = makeMockProvider();
-		const baseReal2 = makeMockProvider();
-		// Two providers with different responses, simulating real vs dry-run.
-		baseReal.calls = 0;
-		const cacheReal = withReplayCache(baseReal, {
-			cacheDir: dir,
-			providerKey: "openrouter",
-		});
-		const cacheDry = withReplayCache(baseReal2, {
-			cacheDir: dir,
-			providerKey: "openrouter+dryrun",
-		});
-
-		await cacheReal.generate(sampleReq);
-		expect(baseReal.calls).toBe(1);
-
-		// Different providerKey → different cache key → cacheDry is a miss
-		// even though every other parameter matches.
-		await cacheDry.generate(sampleReq);
-		expect(baseReal2.calls).toBe(1);
-	});
-
-	it("withReplayCache key is stable when providerKey is set, regardless of inner.name", async () => {
-		const base = makeMockProvider();
-		const limiter = new AdaptiveRateLimiter(base.limits);
-		const limited = withRateLimiter(base, limiter, { enabled: true });
-		// Two cache wrappers — one over `base`, one over `limited`. Different
-		// inner.name. With providerKey set, both compute the same key and share
-		// the same disk file.
-		const cacheBase = withReplayCache(base, { cacheDir: dir, providerKey: "stable-id" });
-		const cacheLimited = withReplayCache(limited, { cacheDir: dir, providerKey: "stable-id" });
-
-		await cacheBase.generate(sampleReq);
-		expect(base.calls).toBe(1);
-		// Second wrapper reads the same key — cache hit, base not re-called.
-		const r = await cacheLimited.generate(sampleReq);
-		expect(base.calls).toBe(1);
-		expect(r.content).toBe("ok");
-	});
-
-	it("split ITPM/OTPM caps each pace their own window independently", async () => {
-		// Tight OTPM, generous ITPM — output window should be the binding
-		// constraint. Two calls each recording 8K output → 16K sits above
-		// effectiveOtpm (10K × 0.85 = 8.5K). Third call's pace loop exits when
-		// window drains naturally; we can't assert the wait here without
-		// fake timers, so we assert the limiter counted the calls (no crash
-		// from split pacing path).
-		const base = makeMockProvider();
-		const limiter = new AdaptiveRateLimiter({
-			contextWindow: 100_000,
-			maxOutputTokens: 10_000,
-			rpm: 100, // RPM not binding
-			rpd: 10_000,
-			tpm: Infinity, // split caps take over
-			itpm: 100_000,
-			otpm: 10_000,
-		});
-		const limited = withRateLimiter(base, limiter, { enabled: true });
-
-		await limited.generate({ ...sampleReq, maxTokens: 5_000 });
-		await limited.generate({ ...sampleReq, maxTokens: 5_000 });
-		expect(base.calls).toBe(2);
-		expect(limiter.stats().totalCalls).toBe(2);
-	});
-
-	it("single-TPM provider still works — combined window paces when itpm/otpm absent", async () => {
-		const base = makeMockProvider();
-		const limiter = new AdaptiveRateLimiter({
-			contextWindow: 100_000,
-			maxOutputTokens: 10_000,
-			rpm: 100,
-			rpd: 10_000,
-			tpm: 50_000, // combined only, no itpm/otpm
-		});
-		const limited = withRateLimiter(base, limiter, { enabled: true });
-
-		await limited.generate(sampleReq);
-		expect(base.calls).toBe(1);
-		expect(limiter.stats().totalCalls).toBe(1);
-	});
-
-	it("withRateLimiter wrapper passes through unmetered calls when disabled", async () => {
-		const base = makeMockProvider();
-		const limiter = new AdaptiveRateLimiter(base.limits);
-		const limited = withRateLimiter(base, limiter, { enabled: false });
-
-		// 10 calls in immediate succession — no pacing, no cap.
-		for (let i = 0; i < 10; i++) {
-			await limited.generate(sampleReq);
-		}
-		expect(base.calls).toBe(10);
-		// Disabled limiter still records usage for stats but does not gate.
-		expect(limiter.stats().totalCalls).toBe(0);
-	});
-});
diff --git a/src/__tests__/utils/harness/harness-default-bridges.test.ts b/src/__tests__/utils/harness/harness-default-bridges.test.ts
deleted file mode 100644
index 3d9f1ae9..00000000
--- a/src/__tests__/utils/harness/harness-default-bridges.test.ts
+++ /dev/null
@@ -1,484 +0,0 @@
-/**
- * Unit tests for the default LLM bridge work fns introduced in Tier 6.5 C2
- * and the cancel-on-teardown contract on `actuatorExecutor`. Coverage
- * targets the bridge-layer producer paths that don't go through `harnessLoop`
- * end-to-end (those are exercised in harness.test.ts).
- *
- * Failure-mode taxonomy under test:
- *   1. Synchronous `adapter.invoke` throw → failure payload.
- *   2. Adapter returns a Node that emits ERROR → failure payload.
- *   3. Adapter returns malformed JSON → parse-error failure.
- *   4. Adapter returns non-object JSON (`null` / number / array) → parse-error failure.
- *   5. Adapter returns a Node that COMPLETEs without emitting DATA → failure payload (qa F1 regression).
- *   6. AbortSignal threading: pump teardown fires `ac.abort()`; downstream
- *      sees `signal.aborted === true` (qa F2 regression for actuator-executor).
- */
-
-import { COMPLETE, DATA, ERROR, type Messages, type Node, node } from "@graphrefly/pure-ts/core";
-import { fromAny } from "@graphrefly/pure-ts/extra";
-import { describe, expect, it } from "vitest";
-import { defaultLlmExecutor, defaultLlmVerifier } from "../../../presets/harness/index.js";
-import type {
-	ChatMessage,
-	LLMAdapter,
-	LLMInvokeOptions,
-	LLMResponse,
-} from "../../../utils/ai/index.js";
-import {
-	actuatorExecutor,
-	type HarnessJobPayload,
-	type TriagedItem,
-} from "../../../utils/harness/index.js";
-import type { JobEnvelope } from "../../../utils/job-queue/index.js";
-
-const ITEM: TriagedItem = {
-	source: "eval",
-	summary: "test item",
-	evidence: "fixture",
-	affectsAreas: ["core"],
-	rootCause: "missing-fn",
-	intervention: "catalog-fn",
-	route: "auto-fix",
-	priority: 50,
-};
-
-let _id = 0;
-function jobFor<A>(payload: HarnessJobPayload<A>): JobEnvelope<HarnessJobPayload<A>> {
-	_id += 1;
-	return {
-		id: `j-${_id}`,
-		payload,
-		attempts: 0,
-		metadata: Object.freeze({}),
-		state: "inflight",
-	};
-}
-
-function awaitFirstData<T>(node: Node<T | null>, timeoutMs = 1000): Promise<T> {
-	return new Promise((resolve, reject) => {
-		let unsub: () => void = () => {};
-		const timer = setTimeout(() => {
-			unsub();
-			reject(new Error(`no DATA within ${timeoutMs}ms`));
-		}, timeoutMs);
-		unsub = node.subscribe((msgs) => {
-			for (const [type, value] of msgs) {
-				if (type === DATA && value != null) {
-					clearTimeout(timer);
-					unsub();
-					resolve(value as T);
-					return;
-				}
-			}
-		});
-	});
-}
-
-/** Build a minimal LLMAdapter that returns whatever the test scripts. */
-function adapterReturning(
-	build: (msgs: readonly ChatMessage[], opts?: LLMInvokeOptions) => unknown,
-): LLMAdapter {
-	return {
-		provider: "test",
-		invoke: build as LLMAdapter["invoke"],
-		stream: async function* () {
-			yield { type: "finish" as const, reason: "stop" };
-		},
-	};
-}
-
-// ---------------------------------------------------------------------------
-// defaultLlmExecutor — failure-mode coverage
-// ---------------------------------------------------------------------------
-
-describe("defaultLlmExecutor — bridge-layer failure modes", () => {
-	it("synchronous adapter throw maps to failure payload", async () => {
-		const adapter = adapterReturning(() => {
-			throw new Error("sync boom");
-		});
-		const exec = defaultLlmExecutor(adapter);
-		const payload = await awaitFirstData(fromAny(exec(jobFor({ item: ITEM }))));
-		expect(payload.execution?.outcome).toBe("failure");
-		expect(payload.execution?.detail).toContain("sync boom");
-	});
-
-	it("adapter Promise reject maps to failure payload via ERROR arm", async () => {
-		const adapter = adapterReturning(() => Promise.reject(new Error("async boom")));
-		const exec = defaultLlmExecutor(adapter);
-		const payload = await awaitFirstData(fromAny(exec(jobFor({ item: ITEM }))));
-		expect(payload.execution?.outcome).toBe("failure");
-		expect(payload.execution?.detail).toContain("async boom");
-	});
-
-	it("malformed JSON in response.content surfaces as parse error", async () => {
-		const adapter = adapterReturning(() =>
-			Promise.resolve({
-				content: "not json {",
-				usage: { input: { regular: 0 }, output: { regular: 0 } },
-			}),
-		);
-		const exec = defaultLlmExecutor(adapter);
-		const payload = await awaitFirstData(fromAny(exec(jobFor({ item: ITEM }))));
-		expect(payload.execution?.outcome).toBe("failure");
-		expect(payload.execution?.detail).toContain("execute parse error");
-	});
-
-	it("non-object JSON (literal null) surfaces as parse error", async () => {
-		const adapter = adapterReturning(() =>
-			Promise.resolve({
-				content: "null",
-				usage: { input: { regular: 0 }, output: { regular: 0 } },
-			}),
-		);
-		const exec = defaultLlmExecutor(adapter);
-		const payload = await awaitFirstData(fromAny(exec(jobFor({ item: ITEM }))));
-		expect(payload.execution?.outcome).toBe("failure");
-		expect(payload.execution?.detail).toContain("non-object response");
-	});
-
-	it("non-object JSON (array) surfaces as parse error", async () => {
-		const adapter = adapterReturning(() =>
-			Promise.resolve({
-				content: "[1,2,3]",
-				usage: { input: { regular: 0 }, output: { regular: 0 } },
-			}),
-		);
-		const exec = defaultLlmExecutor(adapter);
-		const payload = await awaitFirstData(fromAny(exec(jobFor({ item: ITEM }))));
-		expect(payload.execution?.outcome).toBe("failure");
-		expect(payload.execution?.detail).toContain("non-object response");
-	});
-
-	it("Node-shaped invokeResult that COMPLETEs without DATA surfaces as failure (qa F1 regression)", async () => {
-		const adapter = adapterReturning(() =>
-			node<LLMResponse>(
-				[],
-				(_data, actions) => {
-					actions.down([[COMPLETE]] satisfies Messages);
-					return () => {};
-				},
-				{ describeKind: "producer" },
-			),
-		);
-		const exec = defaultLlmExecutor(adapter);
-		const payload = await awaitFirstData(fromAny(exec(jobFor({ item: ITEM }))));
-		expect(payload.execution?.outcome).toBe("failure");
-		expect(payload.execution?.detail).toContain("adapter completed without emitting DATA");
-	});
-
-	it("Node-shaped invokeResult that emits ERROR surfaces as failure", async () => {
-		const adapter = adapterReturning(() =>
-			node<LLMResponse>(
-				[],
-				(_data, actions) => {
-					actions.down([[ERROR, new Error("upstream node error")]] satisfies Messages);
-					return () => {};
-				},
-				{ describeKind: "producer" },
-			),
-		);
-		const exec = defaultLlmExecutor(adapter);
-		const payload = await awaitFirstData(fromAny(exec(jobFor({ item: ITEM }))));
-		expect(payload.execution?.outcome).toBe("failure");
-		expect(payload.execution?.detail).toContain("upstream node error");
-	});
-
-	it("threads `signal` into adapter.invoke (qa F2 regression)", async () => {
-		let receivedSignal: AbortSignal | undefined;
-		const adapter = adapterReturning((_msgs, opts) => {
-			receivedSignal = opts?.signal;
-			return Promise.resolve({
-				content: JSON.stringify({ outcome: "success", detail: "ok" }),
-				usage: { input: { regular: 0 }, output: { regular: 0 } },
-			});
-		});
-		const exec = defaultLlmExecutor(adapter);
-		await awaitFirstData(fromAny(exec(jobFor({ item: ITEM }))));
-		expect(receivedSignal).toBeInstanceOf(AbortSignal);
-	});
-});
-
-// ---------------------------------------------------------------------------
-// defaultLlmVerifier — bridge-layer failure modes
-// ---------------------------------------------------------------------------
-
-describe("defaultLlmVerifier — bridge-layer failure modes", () => {
-	const baseExec = {
-		item: ITEM,
-		execution: {
-			item: ITEM,
-			outcome: "success" as const,
-			detail: "executed",
-		},
-	};
-
-	it("missing prior execution → STRUCTURAL defensive guard", async () => {
-		// This is the only structural-classified path in defaultLlmVerifier:
-		// indicates a topology bug, not a bridge-layer flake.
-		const adapter = adapterReturning(() =>
-			Promise.resolve({
-				content: "{}",
-				usage: { input: { regular: 0 }, output: { regular: 0 } },
-			}),
-		);
-		const verifier = defaultLlmVerifier(adapter);
-		const payload = await awaitFirstData(fromAny(verifier(jobFor<unknown>({ item: ITEM }))));
-		expect(payload.verify?.verified).toBe(false);
-		expect(payload.verify?.errorClass).toBe("structural");
-		expect(payload.verify?.findings.join(" ")).toContain("no execution");
-	});
-
-	it("synchronous adapter throw → SELF-CORRECTABLE failure (qa F3)", async () => {
-		const adapter = adapterReturning(() => {
-			throw new Error("sync boom");
-		});
-		const verifier = defaultLlmVerifier(adapter);
-		const payload = await awaitFirstData(fromAny(verifier(jobFor(baseExec))));
-		expect(payload.verify?.verified).toBe(false);
-		expect(payload.verify?.errorClass).toBe("self-correctable");
-		expect(payload.verify?.findings.join(" ")).toContain("sync boom");
-	});
-
-	it("malformed JSON → SELF-CORRECTABLE parse-error failure", async () => {
-		const adapter = adapterReturning(() =>
-			Promise.resolve({
-				content: "not json {",
-				usage: { input: { regular: 0 }, output: { regular: 0 } },
-			}),
-		);
-		const verifier = defaultLlmVerifier(adapter);
-		const payload = await awaitFirstData(fromAny(verifier(jobFor(baseExec))));
-		expect(payload.verify?.verified).toBe(false);
-		expect(payload.verify?.errorClass).toBe("self-correctable");
-		expect(payload.verify?.findings.join(" ")).toContain("verify parse error");
-	});
-
-	it("non-object JSON → SELF-CORRECTABLE parse-error failure", async () => {
-		const adapter = adapterReturning(() =>
-			Promise.resolve({
-				content: "42",
-				usage: { input: { regular: 0 }, output: { regular: 0 } },
-			}),
-		);
-		const verifier = defaultLlmVerifier(adapter);
-		const payload = await awaitFirstData(fromAny(verifier(jobFor(baseExec))));
-		expect(payload.verify?.verified).toBe(false);
-		expect(payload.verify?.errorClass).toBe("self-correctable");
-		expect(payload.verify?.findings.join(" ")).toContain("non-object response");
-	});
-
-	it("Node-shaped invokeResult COMPLETEs without DATA → SELF-CORRECTABLE failure (qa F1)", async () => {
-		const adapter = adapterReturning(() =>
-			node<LLMResponse>(
-				[],
-				(_data, actions) => {
-					actions.down([[COMPLETE]] satisfies Messages);
-					return () => {};
-				},
-				{ describeKind: "producer" },
-			),
-		);
-		const verifier = defaultLlmVerifier(adapter);
-		const payload = await awaitFirstData(fromAny(verifier(jobFor(baseExec))));
-		expect(payload.verify?.verified).toBe(false);
-		expect(payload.verify?.errorClass).toBe("self-correctable");
-		expect(payload.verify?.findings.join(" ")).toContain(
-			"verifier completed without emitting DATA",
-		);
-	});
-
-	it("threads `signal` into adapter.invoke (qa F2)", async () => {
-		let receivedSignal: AbortSignal | undefined;
-		const adapter = adapterReturning((_msgs, opts) => {
-			receivedSignal = opts?.signal;
-			return Promise.resolve({
-				content: JSON.stringify({ verified: true, findings: ["ok"] }),
-				usage: { input: { regular: 0 }, output: { regular: 0 } },
-			});
-		});
-		const verifier = defaultLlmVerifier(adapter);
-		await awaitFirstData(fromAny(verifier(jobFor(baseExec))));
-		expect(receivedSignal).toBeInstanceOf(AbortSignal);
-	});
-});
-
-// ---------------------------------------------------------------------------
-// evalVerifier — §9a batch-coalescing for synchronous-emit-during-subscribe
-// evaluators (qa D5 regression)
-// ---------------------------------------------------------------------------
-
-describe("evalVerifier — async-evaluator §9a coverage", () => {
-	it("captures the FINAL settled scores when the evaluator emits across microtask boundaries", async () => {
-		// Async-evaluator regression: evaluator's `subscribe`-time recompute
-		// fires through `Promise.resolve().then(...)`, so the first emission
-		// happens AFTER the synchronous wave ends. The §9a `batch()` wrap
-		// inside evalVerifier was specifically aimed at sync-emit
-		// coalescing; async emits skip the §9a hazard entirely (no nested
-		// emit during subscribe), so the JobFlow pump should still see the
-		// final settled scores via the standard first-DATA capture path.
-		const { evalVerifier } = await import("../../../presets/harness/eval-verifier.js");
-		type Row = { id: string };
-		type Score = { taskId: string; score: number };
-		const evaluator = (cands: Node<readonly string[]>, ds: Node<readonly Row[]>) => {
-			// SENTINEL initial value (no cached DATA) so the JobFlow pump's
-			// first-DATA capture waits for the actual computed scores. This
-			// is the canonical async-evaluator pattern — emit only AFTER
-			// both deps have arrived. Seeding with `[]` would fire an empty
-			// scores DATA on subscribe, giving the pump a stale "0/0
-			// verified" payload before the real recompute completes.
-			const out = node<readonly Score[]>([]);
-			let lastCands: readonly string[] | null = null;
-			let lastDs: readonly Row[] | null = null;
-			let scheduled = false;
-			const recomputeAsync = (): void => {
-				if (scheduled) return;
-				if (lastCands == null || lastDs == null) return;
-				scheduled = true;
-				Promise.resolve().then(() => {
-					scheduled = false;
-					if (lastCands == null || lastDs == null) return;
-					const best = (lastCands[0] ?? "").toLowerCase();
-					out.emit(
-						lastDs.map((row) => ({
-							taskId: row.id,
-							score: best.includes(row.id.toLowerCase()) ? 1 : 0,
-						})),
-					);
-				});
-			};
-			cands.subscribe((msgs) => {
-				for (const m of msgs) {
-					if (m[0] === DATA && m[1] != null) {
-						lastCands = m[1] as readonly string[];
-						recomputeAsync();
-					}
-				}
-			});
-			ds.subscribe((msgs) => {
-				for (const m of msgs) {
-					if (m[0] === DATA && m[1] != null) {
-						lastDs = m[1] as readonly Row[];
-						recomputeAsync();
-					}
-				}
-			});
-			return out;
-		};
-		const verifier = evalVerifier<string>({
-			evaluator,
-			datasetFor: () => [{ id: "a" }, { id: "b" }, { id: "c" }],
-			threshold: 1.0,
-		});
-		const job = jobFor<string>({
-			item: ITEM,
-			execution: { item: ITEM, outcome: "success", detail: "ok", artifact: "a b c" },
-		});
-		const payload = await awaitFirstData(fromAny(verifier(job)), 2000);
-		// Async-evaluator coalesce: scheduling guard + microtask boundary
-		// means recompute fires once with both deps captured. JobFlow pump
-		// captures that single final emit as the verify result.
-		expect(payload.verify?.verified).toBe(true);
-		expect(payload.verify?.findings.join(" ")).toContain("3/3");
-	});
-});
-
-describe("evalVerifier — synchronous-emit-during-subscribe evaluator coalescing", () => {
-	it("coalesces evaluator's intra-construction emits via batch() so first DATA is the settled value", async () => {
-		// Import inside the test to avoid pulling refine-loop types into the
-		// top-level deps when not needed elsewhere.
-		const { evalVerifier } = await import("../../../presets/harness/eval-verifier.js");
-		// A "presenceEvaluator"-shaped evaluator: subscribes to candidates AND
-		// dataset; each subscribe-callback fires synchronously with the cached
-		// value, calls recompute() which emits to `out`. Without the §9a
-		// `batch()` wrap inside evalVerifier, the first recompute (after
-		// candidates.subscribe but BEFORE dataset.subscribe) emits an empty
-		// scores array — and the JobFlow pump's first-DATA capture would see
-		// that intermediate empty value as the verify result. With the batch,
-		// both emits coalesce and the derived sees only the LAST value.
-		type Row = { id: string };
-		type Score = { taskId: string; score: number };
-		const evaluator = (cands: Node<readonly string[]>, ds: Node<readonly Row[]>) => {
-			const out = node<readonly Score[]>([], { initial: [] });
-			let lastCands: readonly string[] = [];
-			let lastDs: readonly Row[] = [];
-			const recompute = (): void => {
-				const best = (lastCands[0] ?? "").toLowerCase();
-				out.emit(
-					lastDs.map((row) => ({
-						taskId: row.id,
-						score: best.includes(row.id.toLowerCase()) ? 1 : 0,
-					})),
-				);
-			};
-			cands.subscribe((msgs) => {
-				for (const m of msgs) {
-					if (m[0] === DATA && m[1] != null) {
-						lastCands = m[1] as readonly string[];
-						recompute();
-					}
-				}
-			});
-			ds.subscribe((msgs) => {
-				for (const m of msgs) {
-					if (m[0] === DATA && m[1] != null) {
-						lastDs = m[1] as readonly Row[];
-						recompute();
-					}
-				}
-			});
-			return out;
-		};
-		const verifier = evalVerifier<string>({
-			evaluator,
-			datasetFor: () => [{ id: "a" }, { id: "b" }, { id: "c" }],
-			threshold: 1.0,
-		});
-		const job = jobFor<string>({
-			item: ITEM,
-			execution: { item: ITEM, outcome: "success", detail: "ok", artifact: "a b c" },
-		});
-		const payload = await awaitFirstData(fromAny(verifier(job)));
-		// First DATA captured by the pump must be the FINAL settled scores
-		// (3/3 verified), NOT the intermediate empty-scores emit.
-		expect(payload.verify?.verified).toBe(true);
-		expect(payload.verify?.findings.join(" ")).toContain("3/3");
-	});
-});
-
-// ---------------------------------------------------------------------------
-// actuatorExecutor — cancel-on-teardown contract (qa F2 regression)
-// ---------------------------------------------------------------------------
-
-describe("actuatorExecutor — cancel-on-teardown", () => {
-	it("aborts the AbortSignal when the result Node is unsubscribed before settling", async () => {
-		let capturedSignal: AbortSignal | undefined;
-		const exec = actuatorExecutor<string>({
-			apply(_item, { signal }) {
-				capturedSignal = signal;
-				// Long-tail Promise that never resolves naturally.
-				return new Promise<string>((resolve, reject) => {
-					if (signal.aborted) {
-						reject(new DOMException("aborted", "AbortError"));
-						return;
-					}
-					signal.addEventListener("abort", () => {
-						reject(new DOMException("aborted", "AbortError"));
-					});
-					setTimeout(() => resolve("never"), 30_000);
-				});
-			},
-		});
-		const out = fromAny(exec(jobFor<string>({ item: ITEM })));
-		// Subscribe to activate the producer (apply runs), then immediately
-		// unsubscribe — mirrors what the JobFlow pump does after capturing
-		// first DATA, or what graph teardown does mid-flight.
-		const unsub = out.subscribe(() => {});
-		// Yield a microtask so the producer's apply runs and captures the signal.
-		await Promise.resolve();
-		expect(capturedSignal).toBeInstanceOf(AbortSignal);
-		expect(capturedSignal?.aborted).toBe(false);
-		unsub();
-		// Producer cleanup → ac.abort() fires synchronously.
-		expect(capturedSignal?.aborted).toBe(true);
-	});
-});
diff --git a/src/__tests__/utils/harness/harness.test.ts b/src/__tests__/utils/harness/harness.test.ts
deleted file mode 100644
index 46b4a747..00000000
--- a/src/__tests__/utils/harness/harness.test.ts
+++ /dev/null
@@ -1,2245 +0,0 @@
-import { DATA, node } from "@graphrefly/pure-ts/core";
-import { monotonicNs } from "@graphrefly/pure-ts/core/clock.js";
-import { Graph } from "@graphrefly/pure-ts/graph";
-import { describe, expect, it, vi } from "vitest";
-import { HarnessGraph, harnessLoop } from "../../../presets/harness/harness-loop.js";
-import { mockLLM } from "../../../testing/mock-llm.js";
-import { contentGate, redactor } from "../../../utils/ai/index.js";
-import { trackingKey } from "../../../utils/harness/_internal.js";
-import {
-	affectedTaskFilter,
-	beforeAfterCompare,
-	type CodeChange,
-	codeChangeBridge,
-	type EvalRunResult,
-	evalIntakeBridge,
-	evalSource,
-	notifyEffect,
-} from "../../../utils/harness/bridge.js";
-import {
-	priorityScore,
-	type StrategySnapshot,
-	strategyModel,
-} from "../../../utils/harness/strategy.js";
-import {
-	DEFAULT_PRESET_ID,
-	defaultErrorClassifier,
-	type ExecutionResult,
-	type IntakeItem,
-	strategyKey,
-	type TriagedItem,
-} from "../../../utils/harness/types.js";
-import { TopicGraph, topic } from "../../../utils/messaging/index.js";
-
-// ---------------------------------------------------------------------------
-// types
-// ---------------------------------------------------------------------------
-
-describe("harness types", () => {
-	it("strategyKey formats presetId|rootCause→intervention (Phase 13.I axis extension)", () => {
-		expect(strategyKey(DEFAULT_PRESET_ID, "composition", "template")).toBe(
-			"default|composition→template",
-		);
-		expect(strategyKey(DEFAULT_PRESET_ID, "missing-fn", "catalog-fn")).toBe(
-			"default|missing-fn→catalog-fn",
-		);
-		// Custom presetId on the new axis.
-		expect(strategyKey("researcher", "composition", "template")).toBe(
-			"researcher|composition→template",
-		);
-	});
-
-	it("defaultErrorClassifier classifies parse/config as self-correctable", () => {
-		const result: ExecutionResult = {
-			item: {} as TriagedItem,
-			outcome: "failure",
-			detail: "JSON parse error at line 3",
-		};
-		expect(defaultErrorClassifier(result)).toBe("self-correctable");
-
-		result.detail = "Config validation failed: missing field";
-		expect(defaultErrorClassifier(result)).toBe("self-correctable");
-	});
-
-	it("defaultErrorClassifier classifies structural errors", () => {
-		const result: ExecutionResult = {
-			item: {} as TriagedItem,
-			outcome: "failure",
-			detail: "Missing node: rateLimiter not found in catalog",
-		};
-		expect(defaultErrorClassifier(result)).toBe("structural");
-	});
-
-	// Regression: routeJobIds collision contract — items lacking
-	// relatedTo[0] produce last-write-wins on identical summary derivations.
-	// COMPOSITION-GUIDE-PATTERNS L2 §17 (stable identity for retried items).
-	// Spec: docs/implementation-plan.md DS-13.5.D.3
-	it("DS-13.5.D.3: trackingKey collides for two items with identical summary and no relatedTo[0]", () => {
-		const a: IntakeItem = {
-			source: "human",
-			summary: "fix login bug",
-			evidence: "evidence-a",
-			affectsAreas: ["auth"],
-		};
-		const b: IntakeItem = {
-			source: "llm",
-			summary: "fix login bug",
-			evidence: "different evidence",
-			affectsAreas: ["auth", "ux"],
-		};
-		// Same summary + no relatedTo → identical tracking key →
-		// `routeJobIds.set()` is last-write-wins (publishing `b` overwrites `a`).
-		expect(trackingKey(a)).toBe(trackingKey(b));
-	});
-
-	it("DS-13.5.D.3: trackingKey preserves identity via relatedTo[0] across decorated retry summaries", () => {
-		const original: IntakeItem = {
-			source: "human",
-			summary: "fix login bug",
-			evidence: "ev",
-			affectsAreas: ["auth"],
-		};
-		const originalKey = trackingKey(original);
-
-		// Retry decorates summary; relatedTo[0] carries the original key.
-		const retry: IntakeItem = {
-			source: "human",
-			summary: "[RETRY 1/3] fix login bug — prior failure: timeout",
-			evidence: "ev",
-			affectsAreas: ["auth"],
-			relatedTo: [originalKey],
-		};
-		expect(trackingKey(retry)).toBe(originalKey);
-
-		// Reingest path keeps the original key at index 0 even when chained.
-		const reingest: IntakeItem = {
-			source: "llm",
-			summary: "(reingest) fix login bug",
-			evidence: "ev2",
-			affectsAreas: ["auth"],
-			relatedTo: [originalKey, "intermediate-cycle-2"],
-		};
-		expect(trackingKey(reingest)).toBe(originalKey);
-	});
-
-	it("DS-13.5.D.3: caller-supplied relatedTo[0] disambiguates colliding summaries", () => {
-		const summary = "fix login bug";
-		const a: IntakeItem = {
-			source: "human",
-			summary,
-			evidence: "",
-			affectsAreas: [],
-			relatedTo: ["request-A"],
-		};
-		const b: IntakeItem = {
-			source: "human",
-			summary,
-			evidence: "",
-			affectsAreas: [],
-			relatedTo: ["request-B"],
-		};
-		// Same summary, but distinct relatedTo[0] → distinct tracking keys.
-		expect(trackingKey(a)).not.toBe(trackingKey(b));
-	});
-});
-
-// ---------------------------------------------------------------------------
-// strategy model
-// ---------------------------------------------------------------------------
-
-describe("strategyModel", () => {
-	it("starts empty", () => {
-		const sm = strategyModel();
-		expect(sm.entries.cache.size).toBe(0);
-		expect(sm.lookup(strategyKey(DEFAULT_PRESET_ID, "composition", "template"))).toBeUndefined();
-	});
-
-	it("records successes and failures with correct rates", () => {
-		const sm = strategyModel();
-		sm.record(strategyKey(DEFAULT_PRESET_ID, "composition", "template"), true, {
-			rootCause: "composition",
-			intervention: "template",
-		});
-		sm.record(strategyKey(DEFAULT_PRESET_ID, "composition", "template"), true, {
-			rootCause: "composition",
-			intervention: "template",
-		});
-		sm.record(strategyKey(DEFAULT_PRESET_ID, "composition", "template"), false, {
-			rootCause: "composition",
-			intervention: "template",
-		});
-
-		const entry = sm.lookup(strategyKey(DEFAULT_PRESET_ID, "composition", "template"));
-		expect(entry).toBeDefined();
-		expect(entry!.attempts).toBe(3);
-		expect(entry!.successes).toBe(2);
-		expect(entry!.successRate).toBeCloseTo(2 / 3);
-	});
-
-	it("tracks multiple rootCause→intervention pairs independently", () => {
-		const sm = strategyModel();
-		sm.record(strategyKey(DEFAULT_PRESET_ID, "composition", "template"), true, {
-			rootCause: "composition",
-			intervention: "template",
-		});
-		sm.record(strategyKey(DEFAULT_PRESET_ID, "missing-fn", "catalog-fn"), true, {
-			rootCause: "missing-fn",
-			intervention: "catalog-fn",
-		});
-		sm.record(strategyKey(DEFAULT_PRESET_ID, "missing-fn", "catalog-fn"), true, {
-			rootCause: "missing-fn",
-			intervention: "catalog-fn",
-		});
-
-		expect(sm.lookup(strategyKey(DEFAULT_PRESET_ID, "composition", "template"))!.attempts).toBe(1);
-		expect(sm.lookup(strategyKey(DEFAULT_PRESET_ID, "missing-fn", "catalog-fn"))!.attempts).toBe(2);
-	});
-
-	it("reactive node updates on record()", () => {
-		const sm = strategyModel();
-		const values: StrategySnapshot[] = [];
-		sm.entries.subscribe((msgs) => {
-			for (const msg of msgs) {
-				if (msg[0] === DATA) values.push(msg[1] as StrategySnapshot);
-			}
-		});
-
-		sm.record(strategyKey(DEFAULT_PRESET_ID, "bad-docs", "docs"), true, {
-			rootCause: "bad-docs",
-			intervention: "docs",
-		});
-		expect(values.length).toBeGreaterThanOrEqual(1);
-		const last = values[values.length - 1];
-		expect(last.get("default|bad-docs→docs")).toBeDefined();
-	});
-});
-
-// ---------------------------------------------------------------------------
-// priority score
-// ---------------------------------------------------------------------------
-
-describe("priorityScore", () => {
-	it("computes score from severity and decay", () => {
-		const item = node<TriagedItem>([], {
-			initial: {
-				source: "eval",
-				summary: "test",
-				evidence: "test",
-				affectsAreas: [],
-				rootCause: "composition",
-				intervention: "template",
-				route: "auto-fix",
-				priority: 50,
-				severity: "high",
-			},
-		});
-
-		const sm = strategyModel();
-		const lastInteraction = node<number>([], { initial: monotonicNs() }); // recent
-
-		const score = priorityScore(item, sm.entries, lastInteraction);
-		score.subscribe(() => undefined); // activate
-
-		const val = score.cache;
-		expect(typeof val).toBe("number");
-		expect(val).toBeGreaterThan(0);
-	});
-
-	it("boosts score when strategy model shows high effectiveness", () => {
-		const item = node<TriagedItem>([], {
-			initial: {
-				source: "eval",
-				summary: "test",
-				evidence: "test",
-				affectsAreas: [],
-				rootCause: "composition",
-				intervention: "template",
-				route: "auto-fix",
-				priority: 50,
-				severity: "medium",
-			},
-		});
-
-		const sm = strategyModel();
-		const lastInteraction = node<number>([], { initial: monotonicNs() });
-
-		// Without strategy data
-		const scoreWithout = priorityScore(item, sm.entries, lastInteraction);
-		scoreWithout.subscribe(() => undefined);
-		const valWithout = scoreWithout.cache;
-
-		// Record high effectiveness
-		sm.record(strategyKey(DEFAULT_PRESET_ID, "composition", "template"), true, {
-			rootCause: "composition",
-			intervention: "template",
-		});
-		sm.record(strategyKey(DEFAULT_PRESET_ID, "composition", "template"), true, {
-			rootCause: "composition",
-			intervention: "template",
-		});
-		sm.record(strategyKey(DEFAULT_PRESET_ID, "composition", "template"), true, {
-			rootCause: "composition",
-			intervention: "template",
-		});
-
-		const scoreWith = priorityScore(item, sm.entries, lastInteraction);
-		scoreWith.subscribe(() => undefined);
-		const valWith = scoreWith.cache;
-
-		expect(valWith).toBeGreaterThan(valWithout);
-	});
-});
-
-// ---------------------------------------------------------------------------
-// eval intake bridge
-// ---------------------------------------------------------------------------
-
-describe("evalIntakeBridge", () => {
-	it("publishes per-criterion findings for failing judge scores", () => {
-		// Start with null — bridge fires on value change, not initial
-		// EC2/EC7 (2026-04-30): bridges use `=== undefined` SENTINEL — start
-		// the source without `initial` so its cache is the protocol SENTINEL
-		// until the test emits real DATA.
-		const evalResults = node<EvalRunResult>([]);
-
-		const intake = new TopicGraph<IntakeItem>("test-intake");
-		const g = new Graph("test-bridge-1");
-		const bridgeNode = evalIntakeBridge({
-			graph: g,
-			source: evalResults as any,
-			intakeTopic: intake,
-		});
-
-		// Activate bridge + subscribe to intake before emitting data
-		bridgeNode.subscribe(() => undefined);
-		const items: IntakeItem[] = [];
-		intake.latest.subscribe((msgs) => {
-			for (const msg of msgs) {
-				if (msg[0] === DATA && msg[1] != null) items.push(msg[1] as IntakeItem);
-			}
-		});
-
-		// Now emit the eval result
-		evalResults.down([
-			[
-				DATA,
-				{
-					run_id: "run-1",
-					model: "claude",
-					tasks: [
-						{
-							task_id: "T1",
-							valid: true,
-							judge_scores: [
-								{ claim: "correct topology", pass: true, reasoning: "ok" },
-								{ claim: "uses feedback edges", pass: false, reasoning: "missing feedback" },
-								{ claim: "handles errors", pass: false, reasoning: "no error handling" },
-							],
-						},
-					],
-				},
-			],
-		]);
-
-		// Should produce 2 items (2 failing criteria), not 1 per task
-		expect(items.length).toBe(2);
-		expect(items[0].summary).toContain("uses feedback edges");
-		expect(items[1].summary).toContain("handles errors");
-		expect(items[0].source).toBe("eval");
-		expect(items[0].affectsEvalTasks).toEqual(["T1"]);
-	});
-
-	it("handles task-level invalidity without judge scores", () => {
-		// EC2/EC7 (2026-04-30): bridges use `=== undefined` SENTINEL — start
-		// the source without `initial` so its cache is the protocol SENTINEL
-		// until the test emits real DATA.
-		const evalResults = node<EvalRunResult>([]);
-
-		const intake = new TopicGraph<IntakeItem>("test-intake-2");
-		const g = new Graph("test-bridge-2");
-		const bridgeNode = evalIntakeBridge({
-			graph: g,
-			source: evalResults as any,
-			intakeTopic: intake,
-		});
-		bridgeNode.subscribe(() => undefined);
-
-		const items: IntakeItem[] = [];
-		intake.latest.subscribe((msgs) => {
-			for (const msg of msgs) {
-				if (msg[0] === DATA && msg[1] != null) items.push(msg[1] as IntakeItem);
-			}
-		});
-
-		evalResults.down([
-			[
-				DATA,
-				{
-					run_id: "run-2",
-					model: "gemini",
-					tasks: [{ task_id: "T2", valid: false }],
-				},
-			],
-		]);
-
-		expect(items.length).toBe(1);
-		expect(items[0].summary).toContain("T2 invalid");
-	});
-
-	it("skips fully passing tasks", () => {
-		// EC2/EC7 (2026-04-30): bridges use `=== undefined` SENTINEL — start
-		// the source without `initial` so its cache is the protocol SENTINEL
-		// until the test emits real DATA.
-		const evalResults = node<EvalRunResult>([]);
-
-		const intake = new TopicGraph<IntakeItem>("test-intake-3");
-		const g = new Graph("test-bridge-3");
-		const bridgeNode = evalIntakeBridge({
-			graph: g,
-			source: evalResults as any,
-			intakeTopic: intake,
-		});
-		bridgeNode.subscribe(() => undefined);
-
-		const items: IntakeItem[] = [];
-		intake.latest.subscribe((msgs) => {
-			for (const msg of msgs) {
-				if (msg[0] === DATA && msg[1] != null) items.push(msg[1] as IntakeItem);
-			}
-		});
-
-		evalResults.down([
-			[
-				DATA,
-				{
-					run_id: "run-3",
-					model: "claude",
-					tasks: [
-						{
-							task_id: "T3",
-							valid: true,
-							judge_scores: [{ claim: "correct", pass: true, reasoning: "ok" }],
-						},
-					],
-				},
-			],
-		]);
-
-		expect(items.length).toBe(0);
-	});
-});
-
-// ---------------------------------------------------------------------------
-// harnessLoop
-// ---------------------------------------------------------------------------
-
-// FLAG: v5 behavioral change — needs investigation
-// harnessLoop tests fail with:
-//   Graph "gates": connect(needs-decision/source, needs-decision/gate) — target must include source in its constructor deps (same node reference)
-// The gate factory in orchestration.ts uses Graph.connect() which now enforces deps.
-describe("harnessLoop", () => {
-	// Mock LLM adapter that returns predictable JSON
-	function mockAdapter(responses: Record<string, unknown>) {
-		let callIndex = 0;
-		return {
-			invoke: () => {
-				const keys = Object.keys(responses);
-				const key = keys[callIndex % keys.length];
-				callIndex++;
-				return Promise.resolve({ content: JSON.stringify(responses[key]) });
-			},
-		};
-	}
-
-	it("creates a HarnessGraph with all expected surfaces", () => {
-		const adapter = mockAdapter({
-			triage: { rootCause: "unknown", intervention: "investigate", route: "backlog", priority: 10 },
-		});
-		const harness = harnessLoop("test-harness", { adapter });
-
-		expect(harness).toBeInstanceOf(HarnessGraph);
-		expect(harness.intake).toBeInstanceOf(TopicGraph);
-		// queues is the hub — 4 route topics + intake + triage-output + retry +
-		// verify-results + __unrouted = 9 topics. Enumerate them so an
-		// accidental duplicate / renamed / missing topic trips the test.
-		expect(harness.queues.size).toBe(9);
-		for (const name of [
-			"intake",
-			"triage-output",
-			"retry",
-			"verify-results",
-			"__unrouted",
-			"auto-fix",
-			"needs-decision",
-			"investigation",
-			"backlog",
-		]) {
-			expect(harness.queues.has(name)).toBe(true);
-		}
-		expect(harness.strategy).toBeDefined();
-		expect(harness.verifyResults).toBeInstanceOf(TopicGraph);
-	});
-
-	it("gates are created for needs-decision and investigation by default", () => {
-		const adapter = mockAdapter({});
-		const harness = harnessLoop("test-harness-2", { adapter });
-
-		expect(harness.gates.has("needs-decision")).toBe(true);
-		expect(harness.gates.has("investigation")).toBe(true);
-		expect(harness.gates.has("auto-fix")).toBe(false);
-		expect(harness.gates.has("backlog")).toBe(false);
-	});
-
-	it("respects custom queue config overrides", () => {
-		const adapter = mockAdapter({});
-		const harness = harnessLoop("test-harness-3", {
-			adapter,
-			queues: {
-				"auto-fix": { gated: true },
-				"needs-decision": { gated: false },
-			},
-		});
-
-		expect(harness.gates.has("auto-fix")).toBe(true);
-		expect(harness.gates.has("needs-decision")).toBe(false);
-	});
-
-	it("intake.publish() is callable without error", () => {
-		const adapter = mockAdapter({});
-		const harness = harnessLoop("test-harness-4", { adapter });
-
-		expect(() => {
-			harness.intake.publish({
-				source: "human",
-				summary: "Test issue",
-				evidence: "Test evidence",
-				affectsAreas: ["core"],
-			});
-		}).not.toThrow();
-	});
-
-	it("strategy model is accessible and functional", () => {
-		const adapter = mockAdapter({});
-		const harness = harnessLoop("test-harness-5", { adapter });
-
-		harness.strategy.record(strategyKey(DEFAULT_PRESET_ID, "composition", "template"), true, {
-			rootCause: "composition",
-			intervention: "template",
-		});
-		const entry = harness.strategy.lookup(
-			strategyKey(DEFAULT_PRESET_ID, "composition", "template"),
-		);
-		expect(entry).toBeDefined();
-		expect(entry!.successRate).toBe(1);
-	});
-
-	it("exposes global counters at zero", () => {
-		const adapter = mockAdapter({});
-		const harness = harnessLoop("test-harness-6", { adapter });
-
-		expect(harness.totalRetries.cache).toBe(0);
-		expect(harness.totalReingestions.cache).toBe(0);
-	});
-
-	it("queueTopics map covers exactly the four QUEUE_NAMES routes", () => {
-		const adapter = mockAdapter({});
-		const harness = harnessLoop("test-harness-7", { adapter });
-		const routes = [...harness.queueTopics.keys()].sort();
-		expect(routes).toEqual(["auto-fix", "backlog", "investigation", "needs-decision"]);
-		// Each entry is the same TopicGraph instance the hub holds — no
-		// double-registration / wrapper.
-		for (const [route, topic] of harness.queueTopics) {
-			expect(topic).toBe(harness.queues.topic(route));
-		}
-	});
-
-	it("queueTopics iteration sees published triaged items", () => {
-		const adapter = mockAdapter({});
-		const harness = harnessLoop("test-harness-8", { adapter });
-		const seen: TriagedItem[] = [];
-		for (const [, topic] of harness.queueTopics) {
-			topic.latest.subscribe((msgs) => {
-				for (const m of msgs) {
-					if (m[0] === DATA && m[1] != null) seen.push(m[1] as TriagedItem);
-				}
-			});
-		}
-		// Direct publish to a queue topic — bypassing intake/triage to
-		// keep the test focused on the iteration mechanism.
-		harness.queueTopics.get("auto-fix")?.publish({
-			source: "test",
-			summary: "queueTopics-iter",
-			evidence: "fixture",
-			affectsAreas: ["core"],
-			rootCause: "missing-fn",
-			intervention: "catalog-fn",
-			route: "auto-fix",
-			priority: 50,
-		});
-		const matched = seen.find((s) => s.summary === "queueTopics-iter");
-		expect(matched).toBeDefined();
-	});
-
-	// Tier 6.1 reconciliation regression — items whose route is unknown to
-	// the harness flow into the `__unrouted` dead-letter topic. The router
-	// fans triage output to per-route bridges + an `__unrouted` bridge whose
-	// `map:` predicate fires when `knownRoutes.has(item.route) === false`.
-	// Without this dead-letter, an LLM that hallucinates a non-canonical
-	// route would silently drop the item — the bridge instead surfaces it
-	// for diagnostics.
-	it("Tier 6.1: items with unknown routes flow into the __unrouted dead-letter topic", () => {
-		const adapter = mockAdapter({});
-		const harness = harnessLoop("test-unrouted", { adapter });
-		const unrouted = harness.queues.topic<TriagedItem>("__unrouted");
-		const seen: TriagedItem[] = [];
-		unrouted.latest.subscribe((msgs) => {
-			for (const m of msgs) {
-				if (m[0] === DATA && m[1] != null) seen.push(m[1] as TriagedItem);
-			}
-		});
-		// Bypass triage — publish directly to triage-output with a route the
-		// hub doesn't know about so the `bridge/__unrouted` predicate fires.
-		harness.queues.topic<TriagedItem>("triage-output").publish({
-			source: "eval",
-			summary: "rogue-route",
-			evidence: "fixture",
-			affectsAreas: ["core"],
-			rootCause: "unknown",
-			intervention: "investigate",
-			route: "not-a-real-route" as TriagedItem["route"],
-			priority: 50,
-		});
-		const matched = seen.find((s) => s.summary === "rogue-route");
-		expect(matched).toBeDefined();
-		expect(matched?.route).toBe("not-a-real-route");
-	});
-
-	// Tier 6.2 reconciliation regression — C3 ownership: foreign sources
-	// wrapped in local proxy. Session B.1's "no wrapper node" invariant
-	// (`gateSource === hubTopicLatest`) was retired by the C3 lock: a Node
-	// may belong to at most one Graph, so the gate cannot share-register the
-	// hub's topic node under `gates::…/gate/source`. Instead, the gate's
-	// foreign-source path wraps the hub topic in a local proxy derived
-	// (`describeKind: "derived"`, `meta.factory: "proxy"`). Identity is
-	// broken (locked trade-off); causal chain is preserved via the dep edge,
-	// so `describe()` still walks from the hub topic into the gate.
-	it("Tier 6.2: C3 ownership — gates wrap foreign hub topic in a local proxy", () => {
-		const adapter = mockAdapter({});
-		const harness = harnessLoop("test-foreign-accept", { adapter });
-		// Both gated routes (needs-decision, investigation) get GateController
-		// instances. The controller's own .node IS the gated output — no
-		// pipeline wrapper appears between the topic and the gate.
-		const ndGate = harness.gates.get("needs-decision");
-		expect(ndGate).toBeDefined();
-		// (a) — Identity is broken (Session B.1 retired). The gate's source
-		// inside gateGraph is now a *proxy*, NOT the hub topic node. The
-		// proxy is owned by the gateGraph; the hub topic stays owned by the
-		// hub. Same Node could not legally be registered on both graphs
-		// under C3.
-		const hubTopicLatest = harness.node("queues::needs-decision::latest");
-		const gateSource = harness.node("gates::needs-decision/gate/source");
-		expect(gateSource).not.toBe(hubTopicLatest);
-		// (b) — Causal chain preserved via the dep edge. The proxy's dep is
-		// the hub topic; describe walks deps via nodeToPath, which
-		// canonicalizes to the first (hub) registration.
-		const desc = harness.describe();
-		const gateSourceEntry = desc.nodes["gates::needs-decision/gate/source"];
-		expect(gateSourceEntry).toBeDefined();
-		const gateSourceDeps = (gateSourceEntry?.deps as readonly string[] | undefined) ?? [];
-		expect(gateSourceDeps).toContain("queues::needs-decision::latest");
-		// (c) — The gate itself depends on the proxy (its locally-registered
-		// source), so its deps still resolve cleanly inside the gateGraph.
-		const gateEntry = desc.nodes["gates::needs-decision/gate"];
-		expect(gateEntry).toBeDefined();
-		const gateDeps = (gateEntry?.deps as readonly string[] | undefined) ?? [];
-		expect(gateDeps).toContain("gates::needs-decision/gate/source");
-	});
-
-	// Tier 6.3 — named-node regression. Walks the causal chain from intake to
-	// reflect and asserts no step has an `<anonymous>` path. With triage-input,
-	// router-input, execute-input, execute-enqueue, verify-dispatch, and the
-	// stage-queue/pump nodes inside `executeFlow` all named, the chain should
-	// resolve cleanly end-to-end.
-	it("explain(intake.latest, reflect) returns a chain with no <anonymous> steps", () => {
-		const adapter = mockAdapter({
-			triage: {
-				rootCause: "unknown",
-				intervention: "investigate",
-				route: "backlog",
-				priority: 10,
-			},
-		});
-		const harness = harnessLoop("test-explain-named", { adapter });
-		const chain = harness.describe({ explain: { from: "queues::intake::latest", to: "reflect" } });
-		// We don't assert `found: true` because some intermediate paths (e.g.
-		// gate output for ungated routes) may not be present at construction
-		// time. What we DO assert: every step's path is a named, non-empty,
-		// non-`<anonymous>` qualified path.
-		for (const step of chain.steps) {
-			expect(step.path, `chain step ${step.hop}`).not.toContain("<anonymous>");
-			expect(step.path, `chain step ${step.hop}`).not.toBe("");
-		}
-	});
-});
-
-// ---------------------------------------------------------------------------
-// e2e: full 7-stage flow
-// ---------------------------------------------------------------------------
-
-// FLAG: v5 behavioral change — needs investigation (same Graph.connect() deps enforcement)
-describe("harnessLoop e2e", () => {
-	/**
-	 * Stage-aware mock adapter.
-	 * Returns different JSON depending on which stage is calling.
-	 * Stage detection uses the prompt content.
-	 */
-	function stageAdapter() {
-		const calls: string[] = [];
-		return {
-			calls,
-			invoke: (msgs: Array<{ role: string; content: string }>) => {
-				const text = msgs
-					.map((m) => m.content)
-					.join(" ")
-					.toLowerCase();
-				calls.push(text.slice(0, 80));
-
-				if (text.includes("triage") || text.includes("intake item")) {
-					return Promise.resolve({
-						content: JSON.stringify({
-							rootCause: "missing-fn",
-							intervention: "catalog-fn",
-							route: "auto-fix",
-							priority: 80,
-							triageReasoning: "Missing catalog function for this pattern",
-						}),
-					});
-				}
-				if (text.includes("implementation") || text.includes("triaged issue")) {
-					return Promise.resolve({
-						content: JSON.stringify({
-							outcome: "success",
-							detail: "Added the missing catalog function",
-						}),
-					});
-				}
-				if (text.includes("qa") || text.includes("verify") || text.includes("execution")) {
-					return Promise.resolve({
-						content: JSON.stringify({
-							verified: true,
-							findings: ["Fix looks correct"],
-						}),
-					});
-				}
-				// Fallback
-				return Promise.resolve({ content: "{}" });
-			},
-		};
-	}
-
-	it("intake → triage → queue → execute → verify → strategy", async () => {
-		// Track all adapter calls with their prompts
-		const calls: string[] = [];
-		const adapter = {
-			invoke: (msgs: Array<{ role: string; content: string }>) => {
-				const text = msgs
-					.map((m) => m.content)
-					.join(" ")
-					.toLowerCase();
-				calls.push(text.slice(0, 60));
-
-				if (text.includes("triage") || text.includes("intake item")) {
-					return Promise.resolve({
-						content: JSON.stringify({
-							rootCause: "missing-fn",
-							intervention: "catalog-fn",
-							route: "auto-fix",
-							priority: 80,
-						}),
-					});
-				}
-				if (text.includes("implementation") || text.includes("triaged issue")) {
-					return Promise.resolve({
-						content: JSON.stringify({
-							outcome: "success",
-							detail: "Fixed",
-						}),
-					});
-				}
-				if (text.includes("qa") || text.includes("verify") || text.includes("execution")) {
-					return Promise.resolve({
-						content: JSON.stringify({
-							verified: true,
-							findings: ["ok"],
-						}),
-					});
-				}
-				return Promise.resolve({ content: "{}" });
-			},
-		};
-
-		const harness = harnessLoop("e2e", { adapter });
-
-		// Publish and wait for full chain
-		harness.intake.publish({
-			source: "eval",
-			summary: "T5: missing resilience ordering",
-			evidence: "wrong order",
-			affectsAreas: ["graphspec"],
-			severity: "high",
-		});
-
-		// Wait for strategy model to record at least one outcome
-		// (proves: triage → route → execute → verify → strategy.record)
-		await vi.waitFor(
-			() => {
-				expect(harness.strategy.entries.cache.size).toBeGreaterThan(0);
-			},
-			{ timeout: 5000, interval: 50 },
-		);
-
-		// Verify full chain executed
-		expect(
-			harness.strategy.lookup(strategyKey(DEFAULT_PRESET_ID, "missing-fn", "catalog-fn")),
-		).toBeDefined();
-		expect(calls.length).toBeGreaterThanOrEqual(3); // triage + execute + verify (SENTINEL skips initial empty)
-	});
-
-	it("failed verification triggers fast-retry for self-correctable errors", async () => {
-		let verifyCallCount = 0;
-		const adapter = {
-			invoke: (msgs: Array<{ role: string; content: string }>) => {
-				const text = msgs
-					.map((m) => m.content)
-					.join(" ")
-					.toLowerCase();
-
-				if (text.includes("triage") || text.includes("intake item")) {
-					return Promise.resolve({
-						content: JSON.stringify({
-							rootCause: "schema-gap",
-							intervention: "schema-change",
-							route: "auto-fix",
-							priority: 60,
-						}),
-					});
-				}
-				if (text.includes("implementation") || text.includes("triaged issue")) {
-					return Promise.resolve({
-						content: JSON.stringify({
-							outcome: "failure",
-							detail: "JSON parse error in config",
-						}),
-					});
-				}
-				if (text.includes("qa") || text.includes("verify") || text.includes("execution")) {
-					verifyCallCount++;
-					if (verifyCallCount <= 1) {
-						// First verify: fail with self-correctable
-						return Promise.resolve({
-							content: JSON.stringify({
-								verified: false,
-								findings: ["JSON parse error in output"],
-								errorClass: "self-correctable",
-							}),
-						});
-					}
-					// Subsequent: pass
-					return Promise.resolve({
-						content: JSON.stringify({
-							verified: true,
-							findings: ["Fixed after retry"],
-						}),
-					});
-				}
-				return Promise.resolve({ content: "{}" });
-			},
-		};
-
-		const harness = harnessLoop("e2e-retry", { adapter, maxRetries: 2 });
-
-		const results: VerifyResult[] = [];
-		harness.verifyResults.latest.subscribe((msgs) => {
-			for (const msg of msgs) {
-				if (msg[0] === DATA && msg[1] != null) results.push(msg[1] as VerifyResult);
-			}
-		});
-
-		harness.intake.publish({
-			source: "eval",
-			summary: "T8: parse error in config",
-			evidence: "config validation failed",
-			affectsAreas: ["graphspec"],
-			severity: "medium",
-		});
-
-		// The verify stage should be called at least once (initial activation + real item)
-		await vi.waitFor(
-			() => {
-				expect(verifyCallCount).toBeGreaterThanOrEqual(1);
-			},
-			{ timeout: 3000, interval: 20 },
-		);
-
-		// Global retry counter should have recorded retry attempts
-		expect(harness.totalRetries.cache).toBeGreaterThanOrEqual(0);
-	});
-
-	it("evalIntakeBridge → harnessLoop integration", async () => {
-		const adapter = stageAdapter();
-		const harness = harnessLoop("e2e-bridge", { adapter });
-
-		// Wire the bridge — harness extends Graph, so register on it directly.
-		// EC2/EC7 (2026-04-30): no `initial: null`; bridges use SENTINEL.
-		const evalSource = node<EvalRunResult>([]);
-		const bridgeNode = evalIntakeBridge({
-			graph: harness,
-			source: evalSource as any,
-			intakeTopic: harness.intake,
-		});
-		bridgeNode.subscribe(() => undefined);
-
-		// Emit an eval result with 1 failing criterion
-		evalSource.down([
-			[
-				DATA,
-				{
-					run_id: "run-e2e",
-					model: "claude",
-					tasks: [
-						{
-							task_id: "T5",
-							valid: true,
-							judge_scores: [
-								{ claim: "correct topology", pass: true, reasoning: "ok" },
-								{ claim: "resilience ordering", pass: false, reasoning: "wrong order" },
-							],
-						},
-					],
-				},
-			],
-		]);
-
-		// The bridge should have published 1 failing criterion to intake
-		await vi.waitFor(
-			() => {
-				const intakeItems = harness.intake.retained();
-				expect(intakeItems.length).toBeGreaterThanOrEqual(1);
-			},
-			{ timeout: 1000, interval: 20 },
-		);
-
-		const intakeItems = harness.intake.retained();
-		expect(intakeItems.some((i) => i.summary.includes("resilience ordering"))).toBe(true);
-	});
-});
-
-// ---------------------------------------------------------------------------
-// mockLLM-based scenario tests
-// ---------------------------------------------------------------------------
-
-// FLAG: v5 behavioral change — needs investigation (same Graph.connect() deps enforcement)
-describe("harnessLoop with mockLLM", () => {
-	it("full 7-stage happy path — each stage fires in order, strategy records success", async () => {
-		const mock = mockLLM({
-			stages: {
-				triage: {
-					responses: [
-						{
-							rootCause: "missing-fn",
-							intervention: "catalog-fn",
-							route: "auto-fix",
-							priority: 80,
-						},
-					],
-				},
-				execute: { responses: [{ outcome: "success", detail: "Added missing fn" }] },
-				verify: { responses: [{ verified: true, findings: ["Looks correct"] }] },
-			},
-		});
-
-		const harness = harnessLoop("mock-happy", { adapter: mock });
-		const results: VerifyResult[] = [];
-		harness.verifyResults.latest.subscribe((msgs) => {
-			for (const msg of msgs) {
-				if (msg[0] === DATA && msg[1] != null) results.push(msg[1] as VerifyResult);
-			}
-		});
-
-		harness.intake.publish({
-			source: "eval",
-			summary: "T1: missing catalog function",
-			evidence: "fn not found",
-			affectsAreas: ["graphspec"],
-			severity: "high",
-		});
-
-		await vi.waitFor(
-			() => {
-				expect(results.length).toBeGreaterThanOrEqual(1);
-			},
-			{ timeout: 5000, interval: 50 },
-		);
-
-		// All 3 stages should have been called
-		expect(mock.callsFor("triage").length).toBeGreaterThanOrEqual(1);
-		expect(mock.callsFor("execute").length).toBeGreaterThanOrEqual(1);
-		expect(mock.callsFor("verify").length).toBeGreaterThanOrEqual(1);
-
-		// Strategy model should record a success
-		const entry = harness.strategy.lookup(
-			strategyKey(DEFAULT_PRESET_ID, "missing-fn", "catalog-fn"),
-		);
-		expect(entry).toBeDefined();
-		expect(entry!.successes).toBeGreaterThanOrEqual(1);
-
-		// Verify result should be verified=true
-		expect(results[0].verified).toBe(true);
-	});
-
-	it("multi-item pipeline — items route to different queues", async () => {
-		const mock = mockLLM({
-			stages: {
-				triage: {
-					responses: [
-						{
-							rootCause: "missing-fn",
-							intervention: "catalog-fn",
-							route: "auto-fix",
-							priority: 80,
-						},
-						{
-							rootCause: "schema-gap",
-							intervention: "schema-change",
-							route: "auto-fix",
-							priority: 60,
-						},
-						{
-							rootCause: "bad-docs",
-							intervention: "docs",
-							route: "auto-fix",
-							priority: 40,
-						},
-					],
-				},
-				execute: { responses: [{ outcome: "success", detail: "Fixed" }] },
-				verify: { responses: [{ verified: true, findings: ["ok"] }] },
-			},
-		});
-
-		const harness = harnessLoop("mock-multi", { adapter: mock });
-
-		harness.intake.publish({
-			source: "eval",
-			summary: "Item A",
-			evidence: "evidence A",
-			affectsAreas: ["core"],
-		});
-		harness.intake.publish({
-			source: "eval",
-			summary: "Item B",
-			evidence: "evidence B",
-			affectsAreas: ["extra"],
-		});
-		harness.intake.publish({
-			source: "test",
-			summary: "Item C",
-			evidence: "evidence C",
-			affectsAreas: ["graph"],
-		});
-
-		// Wait for strategy to accumulate entries
-		await vi.waitFor(
-			() => {
-				expect(harness.strategy.entries.cache.size).toBeGreaterThanOrEqual(1);
-			},
-			{ timeout: 5000, interval: 50 },
-		);
-
-		// Multiple triage calls should have occurred
-		expect(mock.callsFor("triage").length).toBeGreaterThanOrEqual(1);
-	});
-
-	it("fast-retry exhaustion — self-correctable fails maxRetries times, then records failure", async () => {
-		const mock = mockLLM({
-			stages: {
-				triage: {
-					responses: [
-						{
-							rootCause: "schema-gap",
-							intervention: "schema-change",
-							route: "auto-fix",
-							priority: 70,
-						},
-					],
-				},
-				execute: {
-					responses: [{ outcome: "failure", detail: "JSON parse error" }],
-				},
-				verify: {
-					responses: [
-						{
-							verified: false,
-							findings: ["parse error in output"],
-							errorClass: "self-correctable",
-						},
-					],
-				},
-			},
-		});
-
-		const harness = harnessLoop("mock-retry-exhaust", {
-			adapter: mock,
-			maxRetries: 2,
-			maxReingestions: 0, // disable reingestion to prevent infinite loop
-		});
-
-		harness.intake.publish({
-			source: "eval",
-			summary: "T5: parse failure",
-			evidence: "broken JSON",
-			affectsAreas: ["graphspec"],
-			severity: "high",
-		});
-
-		// Wait for strategy model to record the failure (proves retries exhausted)
-		await vi.waitFor(
-			() => {
-				const entry = harness.strategy.lookup(
-					strategyKey(DEFAULT_PRESET_ID, "schema-gap", "schema-change"),
-				);
-				expect(entry).toBeDefined();
-			},
-			{ timeout: 15000, interval: 100 },
-		);
-
-		// Global retry counter should show retries occurred
-		expect(harness.totalRetries.cache).toBe(2);
-
-		// Strategy should record failure
-		const entry = harness.strategy.lookup(
-			strategyKey(DEFAULT_PRESET_ID, "schema-gap", "schema-change"),
-		)!;
-		expect(entry.successes).toBe(0);
-	});
-
-	it("structural failure — no fast-retry, straight to strategy.record(false)", async () => {
-		const mock = mockLLM({
-			stages: {
-				triage: {
-					responses: [
-						{
-							rootCause: "composition",
-							intervention: "template",
-							route: "auto-fix",
-							priority: 90,
-						},
-					],
-				},
-				execute: {
-					responses: [{ outcome: "failure", detail: "fundamental architecture issue" }],
-				},
-				verify: {
-					responses: [
-						{
-							verified: false,
-							findings: ["wrong architecture"],
-							errorClass: "structural",
-						},
-					],
-				},
-			},
-		});
-
-		const harness = harnessLoop("mock-structural", {
-			adapter: mock,
-			maxRetries: 2,
-			maxReingestions: 0, // disable reingestion to prevent loop
-		});
-
-		harness.intake.publish({
-			source: "eval",
-			summary: "T9: architecture mismatch",
-			evidence: "wrong pattern",
-			affectsAreas: ["graphspec"],
-			severity: "critical",
-		});
-
-		// Wait for strategy model to record the failure (proves full chain executed)
-		await vi.waitFor(
-			() => {
-				const entry = harness.strategy.lookup(
-					strategyKey(DEFAULT_PRESET_ID, "composition", "template"),
-				);
-				expect(entry).toBeDefined();
-			},
-			{ timeout: 5000, interval: 50 },
-		);
-
-		// Structural failure should NOT trigger fast-retry
-		expect(harness.totalRetries.cache).toBe(0);
-
-		// Strategy should record failure
-		const entry = harness.strategy.lookup(
-			strategyKey(DEFAULT_PRESET_ID, "composition", "template"),
-		)!;
-		expect(entry.successes).toBe(0);
-		expect(entry.attempts).toBeGreaterThanOrEqual(1);
-	});
-
-	it("reingestion — verify failure reingests to intake", async () => {
-		const mock = mockLLM({
-			stages: {
-				triage: {
-					responses: [
-						{
-							rootCause: "regression",
-							intervention: "investigate",
-							route: "auto-fix",
-							priority: 50,
-						},
-					],
-				},
-				execute: {
-					responses: [{ outcome: "failure", detail: "structural issue" }],
-				},
-				verify: {
-					responses: [
-						// First: fail → triggers reingestion
-						{
-							verified: false,
-							findings: ["still broken"],
-							errorClass: "structural",
-						},
-						// Second (reingested item): succeed → stops loop
-						{
-							verified: true,
-							findings: ["fixed on retry"],
-						},
-					],
-				},
-			},
-		});
-
-		const harness = harnessLoop("mock-reingestion", {
-			adapter: mock,
-			maxRetries: 0,
-			maxReingestions: 1,
-		});
-
-		harness.intake.publish({
-			source: "eval",
-			summary: "T10: recurring failure",
-			evidence: "keeps failing",
-			affectsAreas: ["core"],
-		});
-
-		// Wait for the global reingestion counter to record the first reingestion
-		await vi.waitFor(
-			() => {
-				expect(harness.totalReingestions.cache).toBe(1);
-			},
-			{ timeout: 5000, interval: 50 },
-		);
-
-		// Strategy should have recorded outcomes
-		expect(harness.strategy.entries.cache.size).toBeGreaterThanOrEqual(1);
-	});
-
-	// Tier 6.4 / 6.5 reconciliation — the dispatch effect's verdict routing
-	// is exercised by three existing tests in isolation:
-	//   - "full 7-stage happy path" → verified branch.
-	//   - "fast-retry exhaustion"   → retry branch (then structural fallback).
-	//   - "structural failure"      → structural branch (no retry).
-	// A bundled mixed-batch test adds timing fragility without protection
-	// the per-branch tests don't already provide. The structural-only
-	// regression below adds a missing assertion: the dispatch effect emits
-	// a verifyResults publish on EVERY terminal verdict (verified +
-	// structural), not just verified ones. Pre-Tier-6.5 this was easy to
-	// regress because fastRetry's terminal-record path was conditional.
-	// Tier 6.5 §35 reentrancy regression — under a synchronous mock adapter,
-	// the dispatch effect's `intake.publish(...)` cascade can re-enter
-	// `executeFlow.completed` while the dispatch's outer `for` loop is still
-	// iterating. The dispatchCursor + WeakSet/cursor dedupe protects today's
-	// semantics; this test locks the invariant by counting verifyResults
-	// publishes vs intake items: no double-publish, no audit-ledger drift.
-	it("Tier 6.5: synchronous reingest cascades do not double-dispatch verdicts (§35)", async () => {
-		const mock = mockLLM({
-			stages: {
-				triage: {
-					responses: [
-						{
-							rootCause: "regression",
-							intervention: "investigate",
-							route: "auto-fix",
-							priority: 50,
-						},
-					],
-				},
-				execute: { responses: [{ outcome: "failure", detail: "structural" }] },
-				// First pass: structural failure → reingest. Second pass:
-				// verified → terminal.
-				verify: {
-					responses: [
-						{ verified: false, findings: ["initial fail"], errorClass: "structural" },
-						{ verified: true, findings: ["fixed on reingest"] },
-					],
-				},
-			},
-		});
-		const harness = harnessLoop("mock-reentrancy", {
-			adapter: mock,
-			maxRetries: 0,
-			maxReingestions: 1,
-		});
-		const verifyResults: VerifyResult[] = [];
-		harness.verifyResults.latest.subscribe((msgs) => {
-			for (const m of msgs) {
-				if (m[0] === DATA && m[1] != null) verifyResults.push(m[1] as VerifyResult);
-			}
-		});
-		harness.intake.publish({
-			source: "eval",
-			summary: "T-reentrancy",
-			evidence: "fixture",
-			affectsAreas: ["core"],
-		});
-		// Wait until the reingestion counter shows 1 AND a verified verdict
-		// landed; that's the full cycle (initial fail → reingest →
-		// verified).
-		await vi.waitFor(
-			() => {
-				expect(harness.totalReingestions.cache).toBe(1);
-				expect(verifyResults.some((r) => r.verified === true)).toBe(true);
-			},
-			{ timeout: 5000, interval: 50 },
-		);
-		// Exactly two verdicts: one structural (initial), one verified
-		// (post-reingest). Reentrancy guard prevents either being published
-		// twice. dispatchCursor advancing past the prior length on each
-		// emission is what protects this.
-		expect(verifyResults.filter((r) => r.verified === false).length).toBe(1);
-		expect(verifyResults.filter((r) => r.verified === true).length).toBe(1);
-	});
-
-	// Tier 6.5 reflectNode tick-count regression — `reflectNode = derived(...,
-	// () => null, { equals: () => false })`. Each `executeFlow.completed`
-	// emission ticks the reflect node exactly once. Drive N items, assert
-	// the reflect node's emission count tracks the verdict count.
-	it("Tier 6.5: reflectNode ticks once per terminal verdict (no over-count under reactive-log trim emits)", {
-		timeout: 15000,
-	}, async () => {
-		const mock = mockLLM({
-			stages: {
-				triage: {
-					responses: [{ rootCause: "a", intervention: "x", route: "auto-fix", priority: 50 }],
-				},
-				execute: { responses: [{ outcome: "success", detail: "ok" }] },
-				verify: { responses: [{ verified: true, findings: ["clean"] }] },
-			},
-		});
-		const harness = harnessLoop("mock-reflect-tick", {
-			adapter: mock,
-			maxRetries: 0,
-			maxReingestions: 0,
-		});
-		// Subscribe to reflect via the harness's typed field (qa D4) — using
-		// `harness.reflect` rather than `harness.node("reflect")` locks the
-		// reference at the type level, so a future rename would surface as
-		// a build error instead of a string-lookup runtime fallthrough.
-		let reflectTicks = 0;
-		const reflectUnsub = harness.reflect.subscribe((msgs) => {
-			for (const m of msgs) {
-				if (m[0] === DATA) reflectTicks++;
-			}
-		});
-		const verdicts: VerifyResult[] = [];
-		harness.verifyResults.latest.subscribe((msgs) => {
-			for (const m of msgs) {
-				if (m[0] === DATA && m[1] != null) verdicts.push(m[1] as VerifyResult);
-			}
-		});
-		// Publish two items with a small await between so each terminates
-		// before the next enters — mockLLM's stages serialize via Promise
-		// resolution, but rapid fire-and-forget publishes can interleave in
-		// ways that drop late completions out of the retained log under high
-		// load. The reflect-count contract is the same either way (one tick
-		// per terminal verdict); we just want a deterministic count for the
-		// assertion.
-		harness.intake.publish({
-			source: "eval",
-			summary: "T-reflect-0",
-			evidence: "fixture",
-			affectsAreas: ["core"],
-		});
-		await vi.waitFor(
-			() => {
-				expect(verdicts.length).toBeGreaterThanOrEqual(1);
-			},
-			{ timeout: 5000, interval: 30 },
-		);
-		harness.intake.publish({
-			source: "eval",
-			summary: "T-reflect-1",
-			evidence: "fixture",
-			affectsAreas: ["core"],
-		});
-		await vi.waitFor(
-			() => {
-				expect(verdicts.length).toBeGreaterThanOrEqual(2);
-			},
-			{ timeout: 5000, interval: 30 },
-		);
-		// reflect ticks once per executeFlow.completed emission. Each verdict
-		// produces one new completion; reflect's `equals: () => false` keeps
-		// each emit observable (no Object.is collapse). The contract: tick
-		// count equals the verdict count, plus at most one subscribe-time
-		// activation tick (push-on-subscribe of the cached completed log, if
-		// activation arrives before the first verdict lands). qa P3:
-		// tightened from `+2` to `+1` so a 1-tick over-count regression
-		// (e.g. RESOLVED leaking to DATA on the reflect derived) actually
-		// fails the test.
-		expect(reflectTicks).toBeGreaterThanOrEqual(verdicts.length);
-		expect(reflectTicks).toBeLessThanOrEqual(verdicts.length + 1);
-		reflectUnsub();
-	});
-
-	it("Tier 6.4: structural verdict still publishes a VerifyResult to verifyResults topic", async () => {
-		const mock = mockLLM({
-			stages: {
-				triage: {
-					responses: [
-						{
-							rootCause: "composition",
-							intervention: "rewrite",
-							route: "auto-fix",
-							priority: 80,
-						},
-					],
-				},
-				execute: { responses: [{ outcome: "failure", detail: "missing dependency" }] },
-				verify: {
-					responses: [
-						{
-							verified: false,
-							findings: ["dep missing — not parseable"],
-							errorClass: "structural",
-						},
-					],
-				},
-			},
-		});
-		const harness = harnessLoop("mock-structural-publish", {
-			adapter: mock,
-			maxRetries: 0,
-			maxReingestions: 0,
-		});
-		const verifyResults: VerifyResult[] = [];
-		harness.verifyResults.latest.subscribe((msgs) => {
-			for (const m of msgs) {
-				if (m[0] === DATA && m[1] != null) verifyResults.push(m[1] as VerifyResult);
-			}
-		});
-		harness.intake.publish({
-			source: "eval",
-			summary: "T-structural-publish",
-			evidence: "fixture",
-			affectsAreas: ["core"],
-		});
-		await vi.waitFor(
-			() => {
-				expect(verifyResults.some((r) => r.verified === false)).toBe(true);
-			},
-			{ timeout: 5000, interval: 50 },
-		);
-		const structResult = verifyResults.find((r) => r.verified === false)!;
-		expect(structResult.findings).toContain("dep missing — not parseable");
-		// Strategy should also have recorded the failure.
-		const entry = harness.strategy.lookup(strategyKey(DEFAULT_PRESET_ID, "composition", "rewrite"));
-		expect(entry).toBeDefined();
-		expect(entry?.successes).toBe(0);
-		// qa P4: lock "no extra verdict" — single-item run with maxRetries=0
-		// + maxReingestions=0 produces EXACTLY one structural verdict and
-		// zero verified verdicts. A regression that publishes both a
-		// structural and a stray verified verdict for the same item would
-		// have passed the `some(...)` checks above but is caught here.
-		// Wait one extra tick to absorb any post-waitFor late emissions.
-		await new Promise((resolve) => setTimeout(resolve, 50));
-		expect(verifyResults.filter((r) => r.verified === false).length).toBe(1);
-		expect(verifyResults.filter((r) => r.verified === true).length).toBe(0);
-	});
-
-	it("gate blocking — needs-decision item waits at gate, approve releases it", async () => {
-		const mock = mockLLM({
-			stages: {
-				triage: {
-					responses: [
-						{
-							rootCause: "unknown",
-							intervention: "investigate",
-							route: "needs-decision",
-							priority: 60,
-						},
-					],
-				},
-				execute: { responses: [{ outcome: "success", detail: "Investigated" }] },
-				verify: { responses: [{ verified: true, findings: ["ok"] }] },
-			},
-		});
-
-		const harness = harnessLoop("mock-gate", { adapter: mock });
-
-		harness.intake.publish({
-			source: "human",
-			summary: "T11: needs human review",
-			evidence: "ambiguous case",
-			affectsAreas: ["patterns"],
-		});
-		// Wait for triage → router → queue propagation (async due to promptNode Promise)
-		await new Promise((r) => setTimeout(r, 500));
-
-		const qLen = harness.queues.topic<TriagedItem>("needs-decision").retained().length;
-		const triageCalls = mock.callsFor("triage").length;
-		const allStages = mock.calls.map((c) => c.stage);
-
-		// If queue is empty, something in the triage chain didn't fire.
-		// Provide diagnostic info for debugging.
-		if (qLen === 0) {
-			throw new Error(
-				`Queue empty after 500ms. Triage calls: ${triageCalls}, all stages: [${allStages}]`,
-			);
-		}
-
-		// Gate should have pending items (may include initial push-on-subscribe null)
-		const gateCtrl = harness.gates.get("needs-decision")!;
-		expect(gateCtrl).toBeDefined();
-
-		// Approve ALL pending items in the gate (includes push-on-subscribe initial + real item)
-		const pendingCount = (gateCtrl.count.cache as number) ?? 0;
-		gateCtrl.approve(pendingCount);
-
-		// Wait for the item to flow through execute → verify
-		await vi.waitFor(
-			() => {
-				expect(harness.strategy.entries.cache.size).toBeGreaterThanOrEqual(1);
-			},
-			{ timeout: 5000, interval: 50 },
-		);
-	});
-
-	it("gate.modify() overrides rootCause/intervention before forwarding", async () => {
-		const mock = mockLLM({
-			stages: {
-				triage: {
-					responses: [
-						{
-							rootCause: "unknown",
-							intervention: "investigate",
-							route: "needs-decision",
-							priority: 60,
-						},
-					],
-				},
-				execute: { responses: [{ outcome: "success", detail: "Fixed with template" }] },
-				verify: { responses: [{ verified: true, findings: ["ok"] }] },
-			},
-		});
-
-		const harness = harnessLoop("mock-gate-modify", { adapter: mock });
-
-		// Wire harnessTrace with structured events to validate stage ordering
-		const { harnessTrace } = await import("../../../presets/harness/trace.js");
-		const trace = harnessTrace(harness);
-
-		harness.intake.publish({
-			source: "eval",
-			summary: "T5: resilience ordering wrong",
-			evidence: "wrong order in retry stack",
-			affectsAreas: ["graphspec"],
-			severity: "high",
-		});
-
-		// Wait for the item to arrive at the needs-decision gate (reactive, no polling).
-		await new Promise<void>((resolve) => {
-			const queue = harness.queues.topic<TriagedItem>("needs-decision");
-			const unsub = queue.latest.subscribe((msgs) => {
-				for (const msg of msgs) {
-					if (msg[0] === DATA && queue.retained().length >= 1) {
-						unsub();
-						resolve();
-						return;
-					}
-				}
-			});
-		});
-
-		const gateCtrl = harness.gates.get("needs-decision")!;
-
-		// Human steering: override triage classification with structured metadata.
-		// Approve all pending items (push-on-subscribe may have buffered initial null).
-		const pendingCount = (gateCtrl.count.cache as number) ?? 0;
-		gateCtrl.modify(
-			(item: TriagedItem) => ({
-				...item,
-				rootCause: "composition",
-				intervention: "template",
-			}),
-			pendingCount,
-		);
-
-		// Wait for modified item to flow through execute → verify → strategy
-		// (reactive subscription, no polling — §5.8).
-		await new Promise<void>((resolve) => {
-			const unsub = harness.strategy.entries.subscribe((msgs) => {
-				for (const msg of msgs) {
-					if (
-						msg[0] === DATA &&
-						harness.strategy.lookup(strategyKey(DEFAULT_PRESET_ID, "composition", "template"))
-					) {
-						unsub();
-						resolve();
-						return;
-					}
-				}
-			});
-		});
-		// Original classification should NOT appear (modify replaced it).
-		expect(
-			harness.strategy.lookup(strategyKey(DEFAULT_PRESET_ID, "unknown", "investigate")),
-		).toBeUndefined();
-
-		const entry = harness.strategy.lookup(
-			strategyKey(DEFAULT_PRESET_ID, "composition", "template"),
-		)!;
-		expect(entry.successes).toBeGreaterThanOrEqual(1);
-
-		// Structured events revalidation: verify stage ordering without string parsing
-		trace.dispose();
-		const stages = trace.events.filter((e) => e.type === "data").map((e) => e.stage);
-		expect(stages).toContain("INTAKE");
-		expect(stages).toContain("TRIAGE");
-		expect(stages).toContain("STRATEGY");
-
-		// INTAKE before TRIAGE before STRATEGY (use lastIndexOf to skip
-		// initial push-on-subscribe events that fire during harnessTrace wiring)
-		const intakeIdx = stages.lastIndexOf("INTAKE");
-		const triageIdx = stages.lastIndexOf("TRIAGE");
-		const strategyIdx = stages.lastIndexOf("STRATEGY");
-		expect(intakeIdx).toBeLessThan(triageIdx);
-		expect(triageIdx).toBeLessThan(strategyIdx);
-	});
-
-	it("harnessProfile inspects node states and memory", async () => {
-		const mock = mockLLM({
-			stages: {
-				triage: {
-					responses: [
-						{
-							rootCause: "missing-fn",
-							intervention: "catalog-fn",
-							route: "auto-fix",
-							priority: 80,
-						},
-					],
-				},
-				execute: { responses: [{ outcome: "success", detail: "Fixed" }] },
-				verify: { responses: [{ verified: true, findings: ["ok"] }] },
-			},
-		});
-
-		const harness = harnessLoop("mock-diag", {
-			adapter: mock,
-			maxRetries: 1,
-			maxReingestions: 0,
-		});
-
-		const { harnessProfile } = await import("../../../presets/harness/profile.js");
-		const before = harnessProfile(harness);
-		expect(before.nodeCount).toBeGreaterThan(0);
-		expect(before.strategyEntries).toBe(0);
-		expect(before.totalRetries).toBe(0);
-
-		harness.intake.publish({
-			source: "eval",
-			summary: "Diag item 1",
-			evidence: "test evidence",
-			affectsAreas: ["core"],
-		});
-
-		await vi.waitFor(
-			() => {
-				expect(harness.strategy.entries.cache.size).toBeGreaterThanOrEqual(1);
-			},
-			{ timeout: 3000, interval: 50 },
-		);
-
-		const after = harnessProfile(harness);
-		expect(after.nodeCount).toBeGreaterThan(0);
-		expect(after.strategyEntries).toBe(1);
-		expect(after.queueDepths["auto-fix"]).toBe(1);
-		expect(after.totalValueSizeBytes).toBeGreaterThan(before.totalValueSizeBytes);
-		expect(after.hotspots.byValueSize[0]?.status).toBe("settled");
-	});
-
-	it("strategy model accumulates across multiple items", async () => {
-		const mock = mockLLM({
-			stages: {
-				triage: {
-					responses: [
-						{
-							rootCause: "missing-fn",
-							intervention: "catalog-fn",
-							route: "auto-fix",
-							priority: 80,
-						},
-						{
-							rootCause: "missing-fn",
-							intervention: "catalog-fn",
-							route: "auto-fix",
-							priority: 70,
-						},
-						{
-							rootCause: "bad-docs",
-							intervention: "docs",
-							route: "auto-fix",
-							priority: 50,
-						},
-					],
-				},
-				execute: { responses: [{ outcome: "success", detail: "Fixed" }] },
-				verify: {
-					responses: [
-						{ verified: true, findings: ["ok"] },
-						{ verified: true, findings: ["ok"] },
-						{ verified: false, findings: ["nope"], errorClass: "structural" },
-					],
-				},
-			},
-		});
-
-		const harness = harnessLoop("mock-strategy-accum", {
-			adapter: mock,
-			maxReingestions: 0, // prevent reingestion loops
-		});
-
-		harness.intake.publish({
-			source: "eval",
-			summary: "Item 1",
-			evidence: "e1",
-			affectsAreas: ["core"],
-		});
-
-		// Wait for first item to complete
-		await vi.waitFor(
-			() => {
-				expect(harness.strategy.entries.cache.size).toBeGreaterThanOrEqual(1);
-			},
-			{ timeout: 5000, interval: 50 },
-		);
-
-		// Strategy should have at least one entry recorded
-		const snapshot = harness.strategy.entries.cache;
-		expect(snapshot.size).toBeGreaterThanOrEqual(1);
-
-		// At least one key should have attempts > 0
-		let totalAttempts = 0;
-		for (const entry of snapshot.values()) {
-			totalAttempts += entry.attempts;
-		}
-		expect(totalAttempts).toBeGreaterThanOrEqual(1);
-	});
-
-	it("harnessTrace captures stage events and disposes cleanly", async () => {
-		const mock = mockLLM({
-			stages: {
-				triage: {
-					responses: [
-						{
-							rootCause: "missing-fn",
-							intervention: "catalog-fn",
-							route: "auto-fix",
-							priority: 80,
-						},
-					],
-				},
-				execute: { responses: [{ outcome: "success", detail: "Fixed" }] },
-				verify: { responses: [{ verified: true, findings: ["ok"] }] },
-			},
-		});
-
-		const harness = harnessLoop("trace-test", {
-			adapter: mock,
-			maxRetries: 1,
-			retainedLimit: 100,
-		});
-
-		const lines: string[] = [];
-		const { harnessTrace } = await import("../../../presets/harness/trace.js");
-		const handle = harnessTrace(harness, { logger: (line) => lines.push(line) });
-
-		harness.intake.publish({
-			source: "eval",
-			summary: "Trace test item",
-			evidence: "test evidence",
-			affectsAreas: ["core"],
-		});
-
-		await vi.waitFor(
-			() => {
-				expect(harness.strategy.entries.cache.size).toBeGreaterThanOrEqual(1);
-			},
-			{ timeout: 3000, interval: 50 },
-		);
-
-		// Should have captured at least INTAKE and STRATEGY events
-		expect(lines.length).toBeGreaterThanOrEqual(2);
-		expect(lines.some((l) => l.includes("INTAKE"))).toBe(true);
-		expect(lines.some((l) => l.includes("STRATEGY"))).toBe(true);
-
-		// Each line should have elapsed time format
-		for (const line of lines) {
-			expect(line).toMatch(/^\[\d+\.\d{3}s\]/);
-		}
-
-		// Dispose should not throw
-		handle.dispose();
-		// Double dispose is safe
-		handle.dispose();
-	});
-});
-
-// ---------------------------------------------------------------------------
-// Composition A: evalSource
-// ---------------------------------------------------------------------------
-
-describe("evalSource", () => {
-	it("fires runner on trigger and emits the result reactively", async () => {
-		// Use state so trigger has an initial value on subscribe, then update it.
-		// evalSource fires runner for every trigger DATA — including the initial one.
-		const trigger = node([], { initial: "run-a" });
-		const runner = (id: string) =>
-			Promise.resolve({ run_id: id, model: "test", tasks: [] as EvalRunResult["tasks"] });
-
-		const results: EvalRunResult[] = [];
-		// Bind the trigger value into the runner so we can identify which run emitted.
-		const resultNode = evalSource(trigger as ReturnType<typeof state<unknown>>, () =>
-			runner(trigger.cache as string),
-		);
-		const unsub = resultNode.subscribe((msgs) => {
-			for (const [type, data] of msgs) {
-				if (type === DATA && data != null) results.push(data as EvalRunResult);
-			}
-		});
-
-		await new Promise<void>((resolve) => setTimeout(resolve, 20));
-		// The runner fired (at least once — for the initial trigger value or on subscribe).
-		expect(results.length).toBeGreaterThanOrEqual(1);
-		unsub();
-	});
-
-	it("emits the result for each trigger — last-write wins via switchMap", async () => {
-		// Each trigger value determines the run_id so we can track which run resolved.
-		const trigger = node<string | null>([], { initial: null });
-		const runner = () => {
-			const id = trigger.cache;
-			// Slow promise so earlier runs haven't resolved yet when a new trigger fires.
-			return new Promise<EvalRunResult>((resolve) =>
-				setTimeout(() => resolve({ run_id: id ?? "null", model: "test", tasks: [] }), 40),
-			);
-		};
-
-		const results: string[] = [];
-		const resultNode = evalSource(trigger as ReturnType<typeof state<unknown>>, runner);
-		const unsub = resultNode.subscribe((msgs) => {
-			for (const [type, data] of msgs) {
-				if (type === DATA && data != null) results.push((data as EvalRunResult).run_id);
-			}
-		});
-
-		// Fire two rapid triggers — switchMap should cancel the first before it resolves.
-		trigger.down([[DATA, "first"]]);
-		trigger.down([[DATA, "second"]]);
-		await new Promise<void>((resolve) => setTimeout(resolve, 80));
-
-		// "first" should be cancelled (not emitted), "second" should win.
-		expect(results).not.toContain("first");
-		expect(results).toContain("second");
-		unsub();
-	});
-});
-
-// ---------------------------------------------------------------------------
-// Composition A: beforeAfterCompare
-// ---------------------------------------------------------------------------
-
-describe("beforeAfterCompare", () => {
-	const makeResult = (
-		runId: string,
-		tasks: Array<{ id: string; valid: boolean; passes?: number; total?: number }>,
-	): EvalRunResult => ({
-		run_id: runId,
-		model: "test",
-		tasks: tasks.map((t) => ({
-			task_id: t.id,
-			valid: t.valid,
-			judge_scores:
-				t.total !== undefined
-					? Array.from({ length: t.total }, (_, i) => ({
-							claim: `c${i}`,
-							pass: i < (t.passes ?? 0),
-							reasoning: "",
-						}))
-					: undefined,
-		})),
-	});
-
-	it("identifies new failures and resolved tasks", () => {
-		const before = node([], {
-			initial: makeResult("b", [
-				{ id: "t1", valid: true },
-				{ id: "t2", valid: false },
-			]),
-		});
-		const after = node([], {
-			initial: makeResult("a", [
-				{ id: "t1", valid: false },
-				{ id: "t2", valid: true },
-			]),
-		});
-
-		const g = new Graph("delta-test-1");
-		const delta = beforeAfterCompare({ graph: g, before, after });
-		const unsub = delta.subscribe(() => {});
-
-		const d = delta.cache!;
-		expect(d.newFailures).toEqual(["t1"]);
-		expect(d.resolved).toEqual(["t2"]);
-		expect(d.overallImproved).toBe(false); // 1 resolved, 1 failure — equal
-
-		unsub();
-	});
-
-	it("overall improved when more resolved than failures", () => {
-		const before = node([], {
-			initial: makeResult("b", [
-				{ id: "t1", valid: false },
-				{ id: "t2", valid: false },
-				{ id: "t3", valid: true },
-			]),
-		});
-		const after = node([], {
-			initial: makeResult("a", [
-				{ id: "t1", valid: true },
-				{ id: "t2", valid: true },
-				{ id: "t3", valid: false },
-			]),
-		});
-
-		const g = new Graph("delta-test-2");
-		const delta = beforeAfterCompare({ graph: g, before, after });
-		const unsub = delta.subscribe(() => {});
-
-		const d = delta.cache!;
-		expect(d.resolved).toHaveLength(2);
-		expect(d.newFailures).toHaveLength(1);
-		expect(d.overallImproved).toBe(true);
-
-		unsub();
-	});
-
-	it("computes scoreDiff when judge_scores present", () => {
-		const before = node([], {
-			initial: makeResult("b", [{ id: "t1", valid: true, passes: 2, total: 4 }]),
-		});
-		const after = node([], {
-			initial: makeResult("a", [{ id: "t1", valid: true, passes: 3, total: 4 }]),
-		});
-
-		const g = new Graph("delta-test-3");
-		const delta = beforeAfterCompare({ graph: g, before, after });
-		const unsub = delta.subscribe(() => {});
-
-		const td = delta.cache!.taskDeltas[0];
-		expect(td.scoreDiff).toBe(1); // 3 - 2
-		unsub();
-	});
-});
-
-// ---------------------------------------------------------------------------
-// Composition A: affectedTaskFilter
-// ---------------------------------------------------------------------------
-
-describe("affectedTaskFilter", () => {
-	function mkTI(tasks: string[]): TriagedItem {
-		return {
-			affectsEvalTasks: tasks,
-			source: "eval",
-			summary: "",
-			evidence: "",
-			affectsAreas: [],
-			rootCause: "unknown",
-			intervention: "investigate",
-			route: "backlog",
-			priority: 0,
-		} as TriagedItem;
-	}
-
-	it("collects affected task IDs from triaged items", () => {
-		const issuesNode = node<readonly TriagedItem[]>([], {
-			initial: [mkTI(["T1", "T2"]), mkTI(["T2", "T3"])],
-		});
-		const g = new Graph("affected-test-1");
-		const filtered = affectedTaskFilter({ graph: g, issues: issuesNode });
-		const unsub = filtered.subscribe(() => {});
-
-		expect(filtered.cache).toEqual(["T1", "T2", "T3"]);
-		unsub();
-	});
-
-	it("intersects with fullTaskSet when provided", () => {
-		const issuesNode = node<readonly TriagedItem[]>([], { initial: [mkTI(["T1", "T2", "T3"])] });
-		const g = new Graph("affected-test-2");
-		const filtered = affectedTaskFilter({
-			graph: g,
-			issues: issuesNode,
-			fullTaskSet: ["T1", "T3", "T5"] as readonly string[],
-		});
-		const unsub = filtered.subscribe(() => {});
-
-		expect(filtered.cache).toEqual(["T1", "T3"]); // T2 excluded, T5 not affected
-		unsub();
-	});
-});
-
-// ---------------------------------------------------------------------------
-// Composition D: codeChangeBridge
-// ---------------------------------------------------------------------------
-
-describe("codeChangeBridge", () => {
-	it("publishes IntakeItems for lint errors and test failures", () => {
-		// EC2/EC7 (2026-04-30): bridges use `=== undefined` SENTINEL — `null`
-		// is no longer treated as "empty". Construct without `initial` so the
-		// source's cache is the protocol SENTINEL until the test emits real DATA.
-		const source = node<CodeChange>([]);
-		const intakeTopic = topic<IntakeItem>("intake");
-
-		const published: IntakeItem[] = [];
-		const unsubIntake = intakeTopic.latest.subscribe((msgs) => {
-			for (const [type, data] of msgs) {
-				if (type === DATA && data != null) published.push(data as IntakeItem);
-			}
-		});
-
-		const g = new Graph("code-change-test");
-		const bridge = codeChangeBridge({
-			graph: g,
-			source: source as ReturnType<typeof state<CodeChange>>,
-			intakeTopic: intakeTopic as unknown as TopicGraph<IntakeItem>,
-		});
-		const unsubBridge = bridge.subscribe(() => {});
-
-		const change: CodeChange = {
-			files: ["src/foo.ts"],
-			lintErrors: [
-				{ file: "src/foo.ts", line: 10, col: 3, rule: "no-any", message: "Use unknown" },
-			],
-			testFailures: [{ testId: "foo.test", file: "src/foo.ts", message: "expected true" }],
-		};
-		source.down([[DATA, change]]);
-
-		expect(published.length).toBeGreaterThanOrEqual(2);
-		const sources = published.map((i) => i.source);
-		expect(sources).toContain("code-change");
-		expect(sources).toContain("test");
-		unsubIntake();
-		unsubBridge();
-	});
-});
-
-// ---------------------------------------------------------------------------
-// Composition D: notifyEffect
-// ---------------------------------------------------------------------------
-
-describe("notifyEffect", () => {
-	it("calls transport for each new topic entry", () => {
-		const alertTopic = topic<string>("alerts");
-		const calls: string[] = [];
-		const g = new Graph("notify-test-1");
-		const eff = notifyEffect({
-			graph: g,
-			topic: alertTopic as unknown as TopicGraph<string>,
-			transport: (item: string) => calls.push(item),
-		});
-		const unsub = eff.subscribe(() => {});
-
-		alertTopic.publish("first");
-		alertTopic.publish("second");
-
-		expect(calls).toContain("first");
-		expect(calls).toContain("second");
-		unsub();
-	});
-
-	it("supports async transport (fire-and-forget)", async () => {
-		const alertTopic = topic<string>("async-alerts");
-		const calls: string[] = [];
-		const transport = async (item: string) => {
-			await Promise.resolve();
-			calls.push(item);
-		};
-		const g = new Graph("notify-test-2");
-		const eff = notifyEffect({
-			graph: g,
-			topic: alertTopic as unknown as TopicGraph<string>,
-			transport,
-		});
-		const unsub = eff.subscribe(() => {});
-
-		alertTopic.publish("hello");
-		await new Promise<void>((r) => setTimeout(r, 10));
-		expect(calls).toContain("hello");
-		unsub();
-	});
-
-	// EC2/EC7 regression — bridge guards migrated from `== null` to
-	// `=== undefined` per feedback_guard_patterns v5. The "topic empty"
-	// case is disambiguated at the source: `topic.latest` stays SENTINEL
-	// (no DATA emit) on empty per COMPOSITION-GUIDE §1a, so the partial-
-	// false first-run gate holds notifyEffect's fn until the first publish.
-	// Legit `null` then reaches the transport because `null` is valid DATA
-	// (only `undefined` is the protocol SENTINEL; `topic.publish(undefined)`
-	// is rejected at the API layer).
-	it("propagates legit null DATA when T includes null (does NOT fire on initial empty topic)", () => {
-		const nullable = topic<string | null>("nullable-alerts");
-		const calls: (string | null)[] = [];
-		const g = new Graph("notify-test-null");
-		const eff = notifyEffect({
-			graph: g,
-			topic: nullable as unknown as TopicGraph<string | null>,
-			transport: (item: string | null) => calls.push(item),
-		});
-		const unsub = eff.subscribe(() => {});
-
-		// Initial state: topic empty → no transport call.
-		expect(calls).toEqual([]);
-
-		// Legit null publish → transport called with null (was silently
-		// dropped under the prior `item == null` guard).
-		nullable.publish(null);
-		nullable.publish("after-null");
-
-		expect(calls).toEqual([null, "after-null"]);
-		unsub();
-	});
-});
-
-// ---------------------------------------------------------------------------
-// Composition B: redactor
-// ---------------------------------------------------------------------------
-
-describe("redactor", () => {
-	it("replaces matched patterns with [REDACTED]", () => {
-		const text = node<string>([], { initial: "" });
-		const sanitized = redactor(text, [/\d{3}-\d{2}-\d{4}/g]); // SSN pattern
-		const results: string[] = [];
-		const unsub = sanitized.subscribe((msgs) => {
-			for (const [type, data] of msgs) {
-				if (type === DATA && data != null) results.push(data as string);
-			}
-		});
-
-		text.emit("My SSN is 123-45-6789.");
-
-		expect(results[results.length - 1]).toBe("My SSN is [REDACTED].");
-		unsub();
-	});
-
-	it("uses custom replaceFn when provided", () => {
-		const text = node<string>([], { initial: "" });
-		const sanitized = redactor(text, [/secret/gi], () => "***");
-		const results: string[] = [];
-		const unsub = sanitized.subscribe((msgs) => {
-			for (const [type, data] of msgs) {
-				if (type === DATA && data != null) results.push(data as string);
-			}
-		});
-
-		text.emit("my secret data");
-
-		expect(results[results.length - 1]).toBe("my *** data");
-		unsub();
-	});
-});
-
-// ---------------------------------------------------------------------------
-// Composition B: contentGate
-// ---------------------------------------------------------------------------
-
-describe("contentGate", () => {
-	it("returns allow when score is below threshold", () => {
-		const text = node<string>([], { initial: "" });
-		const gate = contentGate(text, (t) => t.length / 100, 0.5); // low threshold
-		const decisions: string[] = [];
-		const unsub = gate.subscribe((msgs) => {
-			for (const [type, data] of msgs) {
-				if (type === DATA && data != null) decisions.push(data as string);
-			}
-		});
-
-		text.emit("hi"); // length 2 / 100 = 0.02 — well below 0.5
-		expect(decisions[decisions.length - 1]).toBe("allow");
-		unsub();
-	});
-
-	it("returns review when score is in [threshold, hard)", () => {
-		const text = node<string>([], { initial: "" });
-		// hardMultiplier default 1.5 → hard = 0.5 × 1.5 = 0.75
-		const gate = contentGate(text, () => 0.6, 0.5);
-		const decisions: string[] = [];
-		const unsub = gate.subscribe((msgs) => {
-			for (const [type, data] of msgs) {
-				if (type === DATA && data != null) decisions.push(data as string);
-			}
-		});
-
-		text.emit("x");
-		expect(decisions[decisions.length - 1]).toBe("review");
-		unsub();
-	});
-
-	it("returns block when score exceeds hard threshold", () => {
-		const text = node<string>([], { initial: "" });
-		const gate = contentGate(text, () => 0.9, 0.5); // 0.9 ≥ 0.75
-		const decisions: string[] = [];
-		const unsub = gate.subscribe((msgs) => {
-			for (const [type, data] of msgs) {
-				if (type === DATA && data != null) decisions.push(data as string);
-			}
-		});
-
-		text.emit("x");
-		expect(decisions[decisions.length - 1]).toBe("block");
-		unsub();
-	});
-
-	it("accepts a Node<number> classifier", () => {
-		const text = node<string>([], { initial: "" });
-		const score = node([], { initial: 0.8 });
-		const gate = contentGate(text, score, 0.5); // 0.8 ≥ 0.75 → block
-		const decisions: string[] = [];
-		const unsub = gate.subscribe((msgs) => {
-			for (const [type, data] of msgs) {
-				if (type === DATA && data != null) decisions.push(data as string);
-			}
-		});
-
-		text.emit("x");
-		expect(decisions[decisions.length - 1]).toBe("block");
-
-		// Lower the score to allow
-		score.down([[DATA, 0.1]]);
-		text.emit("y");
-		expect(decisions[decisions.length - 1]).toBe("allow");
-		unsub();
-	});
-});
diff --git a/src/__tests__/utils/harness/refine-executor.test.ts b/src/__tests__/utils/harness/refine-executor.test.ts
deleted file mode 100644
index 32287697..00000000
--- a/src/__tests__/utils/harness/refine-executor.test.ts
+++ /dev/null
@@ -1,390 +0,0 @@
-/**
- * Unit tests for the EXECUTE/VERIFY actuator pair:
- *   - `refineExecutor` — wraps `refineLoop` into the harness EXECUTE slot.
- *   - `evalVerifier`   — re-runs the evaluator against the artifact EXECUTE emitted.
- *
- * Plus the pluggable-slot contract: the default LLM executor/verifier still
- * works when the caller doesn't pass `executor` / `verifier`.
- */
-
-import { DATA, type Node, node } from "@graphrefly/pure-ts/core";
-import { Graph } from "@graphrefly/pure-ts/graph";
-import { describe, expect, it } from "vitest";
-import { evalVerifier, harnessLoop, refineExecutor } from "../../../presets/harness/index.js";
-import type {
-	DatasetItem,
-	EvalResult,
-	Evaluator,
-	RefineStrategy,
-} from "../../../presets/harness/refine-loop.js";
-import { mockLLM } from "../../../testing/mock-llm.js";
-import type { HarnessJobPayload, VerifyResult } from "../../../utils/harness/index.js";
-import type { JobEnvelope } from "../../../utils/job-queue/index.js";
-
-const REQUIRED = ["reactive", "composable", "inspectable"] as const;
-const DATASET: readonly DatasetItem[] = REQUIRED.map((kw) => ({ id: kw }));
-
-const keywordEvaluator: Evaluator<string> = (candidates, dataset) =>
-	node<readonly EvalResult[]>(
-		[candidates as Node<unknown>, dataset as Node<unknown>],
-		(batchData, actions, ctx) => {
-			const data = batchData.map((batch, i) =>
-				batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-			);
-			const cs = data[0] as readonly string[];
-			const ds = data[1] as readonly DatasetItem[];
-			const best = (cs[0] ?? "").toLowerCase();
-			actions.emit(
-				ds.map((row) => ({
-					taskId: row.id,
-					score: best.includes(row.id.toLowerCase()) ? 1 : 0,
-				})),
-			);
-		},
-		{ describeKind: "derived" },
-	);
-
-const keywordAppender: RefineStrategy<string> = {
-	name: "keyword-appender",
-	seed: (s) => [s],
-	analyze: (_scores, candidates) => {
-		const best = (candidates[0] ?? "").toLowerCase();
-		const missing = REQUIRED.filter((kw) => !best.includes(kw));
-		return {
-			summary: `${missing.length} missing`,
-			score: (REQUIRED.length - missing.length) / REQUIRED.length,
-			weakTasks: [...missing],
-		};
-	},
-	generate: async (feedback, prior) => {
-		const missing = (feedback.weakTasks ?? []) as readonly string[];
-		const base = prior[0] ?? "";
-		return [`${base} ${missing[0] ?? ""}`.trim()];
-	},
-};
-
-function cannedTriageAdapter() {
-	return mockLLM({
-		fallback: {
-			rootCause: "missing-fn",
-			intervention: "template",
-			route: "auto-fix",
-			priority: 80,
-			triageReasoning: "needs keywords",
-		},
-	});
-}
-
-function awaitFirstVerify(latest: Node<VerifyResult>, timeoutMs = 2000): Promise<VerifyResult> {
-	return new Promise((resolve, reject) => {
-		// Pre-declare with a no-op so the timeout callback can't hit TDZ if
-		// `subscribe` ever becomes async-dispatching in a future refactor.
-		let unsub: () => void = () => {};
-		const timer = setTimeout(() => {
-			unsub();
-			reject(new Error(`no VerifyResult within ${timeoutMs}ms`));
-		}, timeoutMs);
-		unsub = latest.subscribe((msgs) => {
-			for (const [type, value] of msgs) {
-				if (type === DATA && value) {
-					clearTimeout(timer);
-					unsub();
-					resolve(value as VerifyResult);
-				}
-			}
-		});
-	});
-}
-
-describe("refineExecutor + evalVerifier (end-to-end)", () => {
-	it("converges on the expected artifact and verifies reactively", async () => {
-		const adapter = cannedTriageAdapter();
-		const harness = harnessLoop("test-refine-hello", {
-			adapter,
-			executor: refineExecutor<string>({
-				seedFrom: () => "base",
-				datasetFor: () => DATASET,
-				evaluator: keywordEvaluator,
-				strategy: keywordAppender,
-				refine: { minScore: 1.0, maxIterations: 8 },
-			}),
-			verifier: evalVerifier<string>({
-				datasetFor: () => DATASET,
-				evaluator: keywordEvaluator,
-				threshold: 1.0,
-			}),
-		});
-
-		const verifyPromise = awaitFirstVerify(harness.verifyResults.latest);
-
-		harness.intake.publish({
-			source: "eval",
-			summary: "seed missing keywords",
-			evidence: "fixture",
-			affectsAreas: ["catalog"],
-			affectsEvalTasks: [...REQUIRED],
-			severity: "high",
-		});
-
-		const verify = await verifyPromise;
-		expect(verify.verified).toBe(true);
-		expect(verify.findings[0]).toContain("3/3 eval tasks passed");
-		expect(verify.execution.outcome).toBe("success");
-		expect(verify.execution.artifact).toBe("base reactive composable inspectable");
-
-		harness.destroy();
-	});
-
-	it("destroy() after first convergence does not throw on late inner-loop drain", async () => {
-		// Teardown regression: the inner `refineLoop` + evaluator subgraphs are
-		// built inside switchMap's project fn and NOT registered on the harness.
-		// `harness.destroy()` must not leave orphan nodes live or throw if a late
-		// wave lands during teardown. This test publishes an item, awaits the
-		// first verify, destroys the harness, then waits a microtask and
-		// re-publishes to ensure no uncaught rejections.
-		const adapter = cannedTriageAdapter();
-		const harness = harnessLoop("test-refine-teardown", {
-			adapter,
-			executor: refineExecutor<string>({
-				seedFrom: () => "base",
-				datasetFor: () => DATASET,
-				evaluator: keywordEvaluator,
-				strategy: keywordAppender,
-				refine: { minScore: 1.0, maxIterations: 8 },
-			}),
-			verifier: evalVerifier<string>({
-				datasetFor: () => DATASET,
-				evaluator: keywordEvaluator,
-				threshold: 1.0,
-			}),
-		});
-
-		const verifyPromise = awaitFirstVerify(harness.verifyResults.latest);
-		harness.intake.publish({
-			source: "eval",
-			summary: "teardown-case",
-			evidence: "fixture",
-			affectsAreas: ["catalog"],
-			affectsEvalTasks: [...REQUIRED],
-			severity: "high",
-		});
-		await verifyPromise;
-
-		// Capture any late rejections / errors. Vitest fails the test if an
-		// unhandled error fires.
-		expect(() => harness.destroy()).not.toThrow();
-
-		// Drain the microtask queue — any pending inner-loop promise resolving
-		// after destroy must not throw.
-		await Promise.resolve();
-		await Promise.resolve();
-	});
-
-	it("verifier marks failure when EXECUTE emits no artifact", async () => {
-		const adapter = cannedTriageAdapter();
-		const harness = harnessLoop<string>("test-refine-no-artifact", {
-			adapter,
-			// Custom work-fn executor that emits a payload WITHOUT artifact to
-			// exercise the evalVerifier fallback. Synchronous payload return —
-			// `fromAny` wraps it for the JobFlow pump.
-			executor: (job) =>
-				({
-					...job.payload,
-					execution: {
-						item: job.payload.item,
-						outcome: "success",
-						detail: "no-artifact",
-					},
-				}) satisfies HarnessJobPayload<string>,
-			verifier: evalVerifier<string>({
-				datasetFor: () => DATASET,
-				evaluator: keywordEvaluator,
-				threshold: 1.0,
-			}),
-		});
-
-		const verifyPromise = awaitFirstVerify(harness.verifyResults.latest);
-		harness.intake.publish({
-			source: "eval",
-			summary: "no-artifact case",
-			evidence: "fixture",
-			affectsAreas: ["catalog"],
-			affectsEvalTasks: [...REQUIRED],
-			severity: "high",
-		});
-
-		// With no artifact, the no-op executor still emits — verifier will
-		// route through its "no artifact" structural-failure path. But fast-retry
-		// may reingest up to maxReingestions before surfacing on verifyResults.
-		// For this test, we just confirm the first verify emission is a failure.
-		const verify = await verifyPromise;
-		expect(verify.verified).toBe(false);
-		expect(verify.findings.join(" ")).toContain("artifact");
-
-		harness.destroy();
-	});
-});
-
-// Regression: per-claim eval subgraph mounting (DS-13.5.D.4, locked
-// 2026-05-01). When `evalVerifier` is configured with a `graph` parent,
-// each claim mounts its own `Graph(\`eval_${claimId}\`)` subgraph at
-// `eval/${claimId}` so describe() walks see the per-claim topology while
-// the claim is in flight; the segment is removed via the output node's
-// `deactivate` cleanup hook when JobFlow unsubscribes after ack/nack.
-//
-// Spec: docs/implementation-plan.md DS-13.5.D.4
-describe("evalVerifier — per-claim subgraph mounting (DS-13.5.D.4)", () => {
-	function makeJob(id: string): JobEnvelope<HarnessJobPayload<string>> {
-		return {
-			id,
-			payload: {
-				item: {
-					source: "eval" as const,
-					summary: "test",
-					evidence: "",
-					affectsAreas: [],
-					severity: "low" as const,
-					rootCause: "missing-fn" as const,
-					intervention: "template" as const,
-					route: "auto-fix" as const,
-					priority: 50,
-				},
-				execution: {
-					item: {} as never,
-					outcome: "success",
-					detail: "ok",
-					artifact: "reactive composable inspectable",
-				},
-			},
-			attempts: 0,
-			metadata: {},
-			state: "inflight",
-		};
-	}
-
-	it("mounts per-claim subgraph at eval/<claimId> during the verify wave", () => {
-		const parent = new Graph("parent");
-		const verifier = evalVerifier<string>({
-			datasetFor: () => DATASET,
-			evaluator: keywordEvaluator,
-			threshold: 1.0,
-			graph: parent,
-		});
-
-		const job = makeJob("job-A");
-		const result = verifier(job);
-
-		// Subscribe to drive the evaluator and the output node.
-		const unsub = result.subscribe(() => {});
-
-		// While subscribed, the per-claim subgraph is mounted.
-		expect(parent.tryResolve("eval/job-A::candidates")).toBeDefined();
-		expect(parent.tryResolve("eval/job-A::dataset")).toBeDefined();
-		expect(parent.tryResolve("eval/job-A::output")).toBeDefined();
-		const subgraphsDuring = (parent.describe() as { subgraphs?: string[] }).subgraphs;
-		expect(subgraphsDuring).toContain("eval/job-A");
-
-		// JobFlow's pump unsubscribes from the result on settle (ack/nack);
-		// last unsub fires the output node's deactivate cleanup, which
-		// removes the segment from the parent graph.
-		unsub();
-
-		expect(parent.tryResolve("eval/job-A::candidates")).toBeUndefined();
-		expect(parent.tryResolve("eval/job-A::output")).toBeUndefined();
-		const subgraphsAfter = (parent.describe() as { subgraphs?: string[] }).subgraphs;
-		expect(subgraphsAfter ?? []).not.toContain("eval/job-A");
-	});
-
-	it("concurrent claims have independent eval subgraphs", () => {
-		const parent = new Graph("parent");
-		const verifier = evalVerifier<string>({
-			datasetFor: () => DATASET,
-			evaluator: keywordEvaluator,
-			threshold: 1.0,
-			graph: parent,
-		});
-
-		const jobA = makeJob("job-A");
-		const jobB = makeJob("job-B");
-		const rA = verifier(jobA);
-		const rB = verifier(jobB);
-		const uA = rA.subscribe(() => {});
-		const uB = rB.subscribe(() => {});
-
-		// Both segments mounted independently.
-		expect(parent.tryResolve("eval/job-A::output")).toBeDefined();
-		expect(parent.tryResolve("eval/job-B::output")).toBeDefined();
-
-		// Unsubscribing one cleans up only that segment.
-		uA();
-		expect(parent.tryResolve("eval/job-A::output")).toBeUndefined();
-		expect(parent.tryResolve("eval/job-B::output")).toBeDefined();
-
-		uB();
-		expect(parent.tryResolve("eval/job-B::output")).toBeUndefined();
-	});
-
-	it("without `graph` config, behavior is unchanged (no segment mount)", () => {
-		const verifier = evalVerifier<string>({
-			datasetFor: () => DATASET,
-			evaluator: keywordEvaluator,
-			threshold: 1.0,
-			// no `graph` supplied
-		});
-
-		const job = makeJob("job-A");
-		const result = verifier(job);
-		const unsub = result.subscribe(() => {});
-
-		// When no parent graph is supplied, internal nodes float —
-		// nothing to assert about the parent (there isn't one). The
-		// result node still emits the verify payload as before.
-		expect(result).toBeDefined();
-
-		unsub();
-	});
-});
-
-describe("pluggable slot defaults", () => {
-	it("default LLM executor + verifier still wire when no custom slots supplied", async () => {
-		const adapter = mockLLM({
-			stages: {
-				triage: {
-					responses: [
-						{
-							rootCause: "missing-fn",
-							intervention: "template",
-							route: "auto-fix",
-							priority: 80,
-							triageReasoning: "seed missing keywords",
-						},
-					],
-				},
-				execute: {
-					responses: [{ outcome: "success", detail: "defaulted execute" }],
-				},
-				verify: {
-					responses: [{ verified: true, findings: ["looks fine"] }],
-				},
-			},
-		});
-		const harness = harnessLoop("test-default-slots", { adapter });
-
-		const verifyPromise = awaitFirstVerify(harness.verifyResults.latest);
-		harness.intake.publish({
-			source: "eval",
-			summary: "default-path",
-			evidence: "fixture",
-			affectsAreas: ["catalog"],
-			severity: "high",
-		});
-
-		const verify = await verifyPromise;
-		expect(verify.verified).toBe(true);
-		expect(verify.execution.detail).toBe("defaulted execute");
-		// Default LLM executor doesn't populate artifact.
-		expect(verify.execution.artifact).toBeUndefined();
-
-		harness.destroy();
-	});
-});
diff --git a/src/__tests__/utils/inspect/audit.test.ts b/src/__tests__/utils/inspect/audit.test.ts
deleted file mode 100644
index 23944e6d..00000000
--- a/src/__tests__/utils/inspect/audit.test.ts
+++ /dev/null
@@ -1,772 +0,0 @@
-import { node, type PolicyRuleData, policy } from "@graphrefly/pure-ts/core";
-import { Graph } from "@graphrefly/pure-ts/graph";
-import { describe, expect, it } from "vitest";
-import { auditTrail, complianceSnapshot, policyGate } from "../../../utils/inspect/audit.js";
-
-describe("auditTrail (roadmap §9.2)", () => {
-	it("records DATA mutations with seq, timestamps, value", () => {
-		const g = new Graph("g");
-		g.add(node([], { name: "a", initial: 0 }), { name: "a" });
-		const audit = auditTrail(g);
-
-		g.set("a", 1);
-		g.set("a", 2);
-		g.set("a", 3);
-
-		const all = audit.all();
-		expect(all).toHaveLength(3);
-		expect(all.map((e) => e.value)).toEqual([1, 2, 3]);
-		expect(all.map((e) => e.seq)).toEqual([0, 1, 2]);
-		// Wall + monotonic timestamps populated.
-		expect(all[0]?.timestamp_ns).toBeGreaterThan(0);
-		expect(all[0]?.wall_clock_ns).toBeGreaterThan(0);
-		expect(all.map((e) => e.path)).toEqual(["a", "a", "a"]);
-	});
-
-	it("byNode / byActor / byTimeRange queries", () => {
-		const g = new Graph("g");
-		g.add(node([], { name: "a", guard: () => true, initial: 0 }), { name: "a" });
-		g.add(node([], { name: "b", guard: () => true, initial: 0 }), { name: "b" });
-		const audit = auditTrail(g);
-
-		const t0 = performance.now() * 1e6;
-		g.set("a", 1, { actor: { type: "human", id: "alice" } });
-		g.set("b", "x", { actor: { type: "llm", id: "agent-1" } });
-		g.set("a", 2, { actor: { type: "human", id: "alice" } });
-
-		expect(audit.byNode("a")).toHaveLength(2);
-		expect(audit.byNode("b")).toHaveLength(1);
-		expect(audit.byActor("alice")).toHaveLength(2);
-		expect(audit.byActorType("llm")).toHaveLength(1);
-		const range = audit.byTimeRange(t0);
-		expect(range.length).toBeGreaterThanOrEqual(3);
-	});
-
-	it("captures graph.trace() reason annotations on entries", () => {
-		const g = new Graph("g");
-		g.add(node([], { name: "a", initial: 0 }), { name: "a" });
-		const audit = auditTrail(g);
-
-		g.trace("a", "set by pricing rule R7");
-		g.set("a", 99);
-
-		const all = audit.all();
-		expect(all[0]?.annotation).toBe("set by pricing rule R7");
-	});
-
-	it("respects includeTypes filter", () => {
-		const g = new Graph("g");
-		g.add(node([], { name: "a", initial: 0 }), { name: "a" });
-		const audit = auditTrail(g, { includeTypes: ["data"] });
-
-		g.set("a", 1);
-		expect(audit.all()).toHaveLength(1);
-	});
-
-	it("EH-18: exposes effective includeTypes as a readonly Set", () => {
-		// Caller-supplied includeTypes is reflected verbatim.
-		const g1 = new Graph("g1");
-		g1.add(node([], { name: "a", initial: 0 }), { name: "a" });
-		const customAudit = auditTrail(g1, { includeTypes: ["data", "error"] });
-		expect(customAudit.includeTypes).toBeInstanceOf(Set);
-		expect([...customAudit.includeTypes].sort()).toEqual(["data", "error"]);
-
-		// Default set surfaces when no override is passed.
-		const g2 = new Graph("g2");
-		g2.add(node([], { name: "a", initial: 0 }), { name: "a" });
-		const defaultAudit = auditTrail(g2);
-		expect([...defaultAudit.includeTypes].sort()).toEqual([
-			"complete",
-			"data",
-			"error",
-			"teardown",
-		]);
-	});
-
-	it("EH-18 (qa P1): default-using trails own distinct includeTypes Sets (no module-singleton sharing)", () => {
-		// Two trails constructed without `opts.includeTypes` must each own a
-		// fresh clone of the default. A cast-and-mutate on one MUST NOT leak
-		// into the other (the original singleton-share bug).
-		const g1 = new Graph("g1-default");
-		g1.add(node([], { name: "a", initial: 0 }), { name: "a" });
-		const audit1 = auditTrail(g1);
-
-		const g2 = new Graph("g2-default");
-		g2.add(node([], { name: "a", initial: 0 }), { name: "a" });
-		const audit2 = auditTrail(g2);
-
-		expect(audit1.includeTypes).not.toBe(audit2.includeTypes);
-		// Mutate via unsafe cast (unsupported but the runtime mechanism still
-		// proves isolation): adding to audit1 must not appear in audit2.
-		(audit1.includeTypes as Set<"dirty">).add("dirty");
-		expect(audit1.includeTypes.has("dirty")).toBe(true);
-		expect(audit2.includeTypes.has("dirty")).toBe(false);
-	});
-
-	it("respects custom filter predicate", () => {
-		const g = new Graph("g");
-		g.add(node([], { name: "a", initial: 0 }), { name: "a" });
-		const audit = auditTrail(g, {
-			filter: (e) => typeof e.value === "number" && (e.value as number) >= 10,
-		});
-
-		g.set("a", 1);
-		g.set("a", 5);
-		g.set("a", 10);
-		g.set("a", 20);
-
-		expect(audit.all().map((e) => e.value)).toEqual([10, 20]);
-	});
-
-	it("count node updates reactively as entries accrue", () => {
-		const g = new Graph("g");
-		g.add(node([], { name: "a", initial: 0 }), { name: "a" });
-		const audit = auditTrail(g);
-		audit.observe("count").subscribe(() => {});
-
-		g.set("a", 1);
-		g.set("a", 2);
-		expect(audit.count.cache).toBe(2);
-	});
-
-	it("attributes actor on unguarded nodes (QA fix A1)", () => {
-		// Previously _lastMutation only populated when a guard ran; auditTrail
-		// missed actor attribution for the common case of unguarded nodes.
-		const g = new Graph("g");
-		g.add(node([], { name: "a", initial: 0 }), { name: "a" }); // no guard
-		const audit = auditTrail(g);
-
-		g.set("a", 1, { actor: { type: "llm", id: "agent-7" } });
-		g.set("a", 2, { actor: { type: "human", id: "alice" } });
-
-		const all = audit.all();
-		expect(all).toHaveLength(2);
-		expect(all[0]?.actor?.type).toBe("llm");
-		expect(all[0]?.actor?.id).toBe("agent-7");
-		expect(all[1]?.actor?.id).toBe("alice");
-	});
-
-	it("ring-buffer cap (maxSize) drops oldest entries", () => {
-		const g = new Graph("g");
-		g.add(node([], { name: "a", initial: 0 }), { name: "a" });
-		const audit = auditTrail(g, { maxSize: 3 });
-
-		for (let i = 1; i <= 5; i++) g.set("a", i);
-
-		const all = audit.all();
-		expect(all).toHaveLength(3);
-		expect(all.map((e) => e.value)).toEqual([3, 4, 5]);
-	});
-});
-
-describe("policyGate (roadmap §9.2)", () => {
-	const denyLlmWrites: readonly PolicyRuleData[] = [
-		{ effect: "allow", action: "write", actorType: "human" },
-		{ effect: "deny", action: "write", actorType: "llm" },
-	];
-
-	it("audit mode: records would-be denials without blocking writes", () => {
-		const g = new Graph("g");
-		g.add(node([], { name: "a", guard: () => true, initial: 0 }), { name: "a" });
-		const enforcer = policyGate(g, denyLlmWrites, { mode: "audit" });
-
-		// LLM write should succeed (audit mode doesn't block) but be recorded.
-		g.set("a", 7, { actor: { type: "llm", id: "agent-1" } });
-		expect(g.node("a").cache).toBe(7);
-
-		const violations = enforcer.all();
-		expect(violations).toHaveLength(1);
-		expect(violations[0]?.actor.type).toBe("llm");
-		expect(violations[0]?.result).toBe("observed");
-		expect(violations[0]?.path).toBe("a");
-		expect(enforcer.violationCount.cache).toBe(1);
-	});
-
-	it("audit mode: human writes pass without recording violations", () => {
-		const g = new Graph("g");
-		g.add(node([], { name: "a", guard: () => true, initial: 0 }), { name: "a" });
-		const enforcer = policyGate(g, denyLlmWrites, { mode: "audit" });
-
-		g.set("a", 5, { actor: { type: "human", id: "alice" } });
-		expect(enforcer.all()).toHaveLength(0);
-	});
-
-	it("B9: audit mode records anonymous writes under system actor instead of skipping", () => {
-		// Policy: deny *any* write that is not human.
-		const denyNonHuman = [
-			{ effect: "allow" as const, action: "write" as const, actorType: "human" },
-			{ effect: "deny" as const, action: "write" as const },
-		];
-		const g = new Graph("g");
-		g.add(node([], { name: "a", guard: () => true, initial: 0 }), { name: "a" });
-		const enforcer = policyGate(g, denyNonHuman, { mode: "audit" });
-
-		// Write with no actor — previously silently skipped, now must be
-		// recorded under the DEFAULT_ACTOR (type "system").
-		g.set("a", 42);
-		const violations = enforcer.all();
-		expect(violations).toHaveLength(1);
-		expect(violations[0]?.actor.type).toBe("system");
-		expect(violations[0]?.result).toBe("observed");
-		expect(violations[0]?.path).toBe("a");
-	});
-
-	it("enforce mode: blocks disallowed writes by throwing GuardDenied", () => {
-		const g = new Graph("g");
-		g.add(node([], { name: "a", initial: 0 }), { name: "a" });
-		const enforcer = policyGate(g, denyLlmWrites, { mode: "enforce" });
-
-		// Human ok
-		g.set("a", 1, { actor: { type: "human", id: "alice" } });
-		expect(g.node("a").cache).toBe(1);
-
-		// LLM blocked
-		expect(() => g.set("a", 2, { actor: { type: "llm", id: "bot" } })).toThrow();
-		expect(g.node("a").cache).toBe(1); // unchanged
-
-		const violations = enforcer.all();
-		expect(violations).toHaveLength(1);
-		expect(violations[0]?.result).toBe("blocked");
-		expect(violations[0]?.path).toBe("a");
-	});
-
-	it("enforce mode: dispose restores original guards", () => {
-		const g = new Graph("g");
-		g.add(node([], { name: "a", initial: 0 }), { name: "a" });
-		const enforcer = policyGate(g, denyLlmWrites, { mode: "enforce" });
-
-		expect(() => g.set("a", 1, { actor: { type: "llm", id: "bot" } })).toThrow();
-		enforcer.destroy();
-		// After dispose, LLM writes work again (no original guard, no enforcer).
-		g.set("a", 99, { actor: { type: "llm", id: "bot" } });
-		expect(g.node("a").cache).toBe(99);
-	});
-
-	it("reactive policies: updating policies node changes enforcement", () => {
-		const g = new Graph("g");
-		g.add(node([], { name: "a", initial: 0 }), { name: "a" });
-		const policies = node<readonly PolicyRuleData[]>([], {
-			name: "policies",
-			initial: denyLlmWrites,
-		});
-		policyGate(g, policies, { mode: "enforce" });
-
-		// Initially LLMs blocked.
-		expect(() => g.set("a", 1, { actor: { type: "llm", id: "bot" } })).toThrow();
-
-		// Update policies to allow LLMs.
-		policies.emit([{ effect: "allow", action: "write" }]);
-		g.set("a", 42, { actor: { type: "llm", id: "bot" } });
-		expect(g.node("a").cache).toBe(42);
-
-		// Tighten back: deny everyone.
-		policies.emit([{ effect: "deny", action: "write" }]);
-		expect(() => g.set("a", 100, { actor: { type: "human", id: "alice" } })).toThrow();
-	});
-
-	it("composes with existing per-node guards (AND semantics)", () => {
-		// Original guard: only humans can write. Enforcer adds: only Alice can write.
-		const onlyHumans = policy((allow) => {
-			allow("write", { where: (a) => a.type === "human" });
-		});
-		const g = new Graph("g");
-		g.add(node([], { name: "a", guard: onlyHumans, initial: 0 }), { name: "a" });
-		policyGate(g, [{ effect: "allow", action: "write", actorId: "alice" }], {
-			mode: "enforce",
-		});
-
-		// Alice (human) — both guards allow.
-		g.set("a", 1, { actor: { type: "human", id: "alice" } });
-		// Bob (human) — original allows, enforcer denies.
-		expect(() => g.set("a", 2, { actor: { type: "human", id: "bob" } })).toThrow();
-		// LLM Alice — original denies (not human), enforcer would allow (id matches).
-		expect(() => g.set("a", 3, { actor: { type: "llm", id: "alice" } })).toThrow();
-	});
-
-	it("paths option restricts which nodes are watched", () => {
-		const g = new Graph("g");
-		g.add(node([], { name: "a", initial: 0 }), { name: "a" });
-		g.add(node([], { name: "b", initial: 0 }), { name: "b" });
-		const enforcer = policyGate(g, [{ effect: "deny", action: "write" }], {
-			mode: "enforce",
-			paths: ["a"],
-		});
-
-		expect(() => g.set("a", 1, { actor: { type: "human", id: "x" } })).toThrow();
-		// b is unguarded.
-		g.set("b", 1, { actor: { type: "human", id: "x" } });
-		expect(g.node("b").cache).toBe(1);
-		expect(enforcer.all()).toHaveLength(1);
-	});
-
-	it("enforce mode: dynamic coverage — nodes added after construction are guarded (closes optimizations.md dynamic-coverage gap)", () => {
-		const g = new Graph("g");
-		g.add(node([], { name: "a", initial: 0 }), { name: "a" });
-		// paths omitted → dynamic coverage mode
-		policyGate(g, [{ effect: "deny", action: "write" }], { mode: "enforce" });
-
-		// Pre-existing node blocked.
-		expect(() => g.set("a", 1, { actor: { type: "human", id: "x" } })).toThrow();
-
-		// Add a new node AFTER enforcer is built — it should be guarded too.
-		g.add(node([], { name: "b", initial: 0 }), { name: "b" });
-		expect(() => g.set("b", 1, { actor: { type: "human", id: "x" } })).toThrow();
-	});
-
-	it("enforce mode: static paths option does NOT dynamically cover late adds (documented caveat)", () => {
-		const g = new Graph("g");
-		g.add(node([], { name: "a", initial: 0 }), { name: "a" });
-		policyGate(g, [{ effect: "deny", action: "write" }], {
-			mode: "enforce",
-			paths: ["a"],
-		});
-
-		expect(() => g.set("a", 1, { actor: { type: "human", id: "x" } })).toThrow();
-
-		// Late-added node — NOT covered because paths was explicit.
-		g.add(node([], { name: "b", initial: 0 }), { name: "b" });
-		g.set("b", 1, { actor: { type: "human", id: "x" } });
-		expect(g.node("b").cache).toBe(1);
-	});
-
-	it("enforce mode: dynamic coverage — mount added after construction gets its contents guarded", () => {
-		const g = new Graph("g");
-		const child = new Graph("child");
-		child.add(node([], { name: "x", initial: 0 }), { name: "x" });
-		// paths omitted → dynamic coverage mode
-		policyGate(g, [{ effect: "deny", action: "write" }], { mode: "enforce" });
-
-		// No coverage yet — child not mounted
-		child.set("x", 1, { actor: { type: "human", id: "a" } });
-		expect(child.node("x").cache).toBe(1);
-
-		// Mount after enforcer built — contents get guarded
-		g.mount("kids", child);
-		expect(() => g.set("kids::x", 5, { actor: { type: "human", id: "a" } })).toThrow();
-	});
-
-	it("enforce mode: dynamic coverage — removed node releases guard bookkeeping (re-add under same name re-wraps)", () => {
-		const g = new Graph("g");
-		g.add(node([], { name: "a", initial: 0 }), { name: "a" });
-		policyGate(g, [{ effect: "deny", action: "write" }], { mode: "enforce" });
-
-		expect(() => g.set("a", 1, { actor: { type: "human", id: "x" } })).toThrow();
-
-		// Remove and re-add under the same name — the new node should be guarded too.
-		g.remove("a");
-		g.add(node([], { name: "a", initial: 0 }), { name: "a" });
-		expect(() => g.set("a", 1, { actor: { type: "human", id: "x" } })).toThrow();
-	});
-
-	it("enforce mode: transitive dynamic coverage — nodes added to a subgraph mounted BEFORE the enforcer was built are guarded (closes watchTopologyTree gap)", () => {
-		const g = new Graph("g");
-		const child = new Graph("child");
-		g.mount("kids", child); // mount BEFORE enforcer
-		policyGate(g, [{ effect: "deny", action: "write" }], { mode: "enforce" });
-
-		// Add to the already-mounted child — watchTopologyTree should cover this.
-		child.add(node([], { name: "x", initial: 0 }), { name: "x" });
-		expect(() => g.set("kids::x", 1, { actor: { type: "human", id: "a" } })).toThrow();
-	});
-
-	it("enforce mode: transitive dynamic coverage — deeply nested mount additions are guarded", () => {
-		const root = new Graph("root");
-		const mid = new Graph("mid");
-		const leaf = new Graph("leaf");
-		mid.mount("leaf", leaf);
-		root.mount("mid", mid);
-		policyGate(root, [{ effect: "deny", action: "write" }], { mode: "enforce" });
-
-		leaf.add(node([], { name: "x", initial: 0 }), { name: "x" });
-		expect(() => root.set("mid::leaf::x", 1, { actor: { type: "human", id: "a" } })).toThrow();
-	});
-
-	// ------------------------------------------------------------------
-	// Tier 3.4 — reactive `paths` (F.9 reactive primitive carve-out)
-	// ------------------------------------------------------------------
-
-	it("Tier 3.4 enforce mode: reactive `paths` — Node<readonly string[]> initial sweep guards starting set", () => {
-		const g = new Graph("g");
-		g.add(node([], { name: "a", initial: 0 }), { name: "a" });
-		g.add(node([], { name: "b", initial: 0 }), { name: "b" });
-		const pathsNode = node<readonly string[]>([], { name: "paths", initial: ["a"] });
-		policyGate(g, [{ effect: "deny", action: "write" }], {
-			mode: "enforce",
-			paths: pathsNode,
-		});
-
-		expect(() => g.set("a", 1, { actor: { type: "human", id: "x" } })).toThrow();
-		// b is NOT in the initial set — write succeeds.
-		g.set("b", 1, { actor: { type: "human", id: "x" } });
-		expect(g.node("b").cache).toBe(1);
-	});
-
-	it("Tier 3.4 enforce mode: reactive `paths` rebinds — paths added to set get wrapped, paths removed get released", () => {
-		const g = new Graph("g");
-		g.add(node([], { name: "a", initial: 0 }), { name: "a" });
-		g.add(node([], { name: "b", initial: 0 }), { name: "b" });
-		const pathsNode = node<readonly string[]>([], { name: "paths", initial: ["a"] });
-		policyGate(g, [{ effect: "deny", action: "write" }], {
-			mode: "enforce",
-			paths: pathsNode,
-		});
-
-		// Initially: a guarded, b not.
-		expect(() => g.set("a", 1, { actor: { type: "human", id: "x" } })).toThrow();
-		g.set("b", 1, { actor: { type: "human", id: "x" } });
-
-		// Reactive flip: now b is guarded, a is not.
-		pathsNode.emit(["b"]);
-		expect(() => g.set("b", 2, { actor: { type: "human", id: "x" } })).toThrow();
-		// a no longer guarded — write succeeds.
-		g.set("a", 99, { actor: { type: "human", id: "x" } });
-		expect(g.node("a").cache).toBe(99);
-	});
-
-	it("Tier 3.4 enforce mode: reactive `paths` — adding to set wraps newly-included path without re-wrapping existing", () => {
-		const g = new Graph("g");
-		g.add(node([], { name: "a", initial: 0 }), { name: "a" });
-		g.add(node([], { name: "b", initial: 0 }), { name: "b" });
-		const pathsNode = node<readonly string[]>([], { name: "paths", initial: ["a"] });
-		policyGate(g, [{ effect: "deny", action: "write" }], {
-			mode: "enforce",
-			paths: pathsNode,
-		});
-
-		expect(() => g.set("a", 1, { actor: { type: "human", id: "x" } })).toThrow();
-		g.set("b", 1, { actor: { type: "human", id: "x" } }); // b not yet guarded
-
-		// Add b to the path set; a stays guarded.
-		pathsNode.emit(["a", "b"]);
-		expect(() => g.set("a", 2, { actor: { type: "human", id: "x" } })).toThrow();
-		expect(() => g.set("b", 2, { actor: { type: "human", id: "x" } })).toThrow();
-	});
-
-	it("Tier 3.4 audit mode: reactive `paths` filter rebinds on emission", () => {
-		const g = new Graph("g");
-		g.add(node([], { name: "a", guard: () => true, initial: 0 }), { name: "a" });
-		g.add(node([], { name: "b", guard: () => true, initial: 0 }), { name: "b" });
-		const pathsNode = node<readonly string[]>([], { name: "paths", initial: ["a"] });
-		const enforcer = policyGate(g, [{ effect: "deny", action: "write" }], {
-			mode: "audit",
-			paths: pathsNode,
-		});
-
-		// Initially only "a" recorded.
-		g.set("a", 1, { actor: { type: "human", id: "x" } });
-		g.set("b", 1, { actor: { type: "human", id: "x" } });
-		expect(enforcer.all().map((v) => v.path)).toEqual(["a"]);
-
-		// Switch filter: now only "b" recorded.
-		pathsNode.emit(["b"]);
-		g.set("a", 2, { actor: { type: "human", id: "x" } });
-		g.set("b", 2, { actor: { type: "human", id: "x" } });
-		expect(enforcer.all().map((v) => v.path)).toEqual(["a", "b"]);
-	});
-});
-
-describe("graph.describe({ explain, reactive: true }) (roadmap §9.2)", () => {
-	it("B21: graph.describe({ explain, reactive: true }) returns the same reactive chain", () => {
-		const g = new Graph("g");
-		const a = node([], { name: "a", initial: 1 });
-		const b = node(
-			[a],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as number) * 2);
-			},
-			{ describeKind: "derived", name: "b" },
-		);
-		g.add(a, { name: "a" });
-		g.add(b, { name: "b" });
-		g.observe("b").subscribe(() => {});
-
-		const direct = g.describe({ explain: { from: "a", to: "b" }, reactive: true });
-		const unsub = direct.node.subscribe(() => {});
-		expect(direct.node.cache?.found).toBe(true);
-		expect(direct.node.cache?.steps[0]?.value).toBe(1);
-		g.set("a", 7);
-		expect(direct.node.cache?.steps[0]?.value).toBe(7);
-		expect(direct.node.cache?.steps[1]?.value).toBe(14);
-		unsub();
-		direct.dispose();
-	});
-
-	it("D5: debounces recompute across a batch — N events in one batch → one recompute", async () => {
-		const { batch } = await import("@graphrefly/pure-ts/core");
-		const g = new Graph("g");
-		const a = node([], { name: "a", initial: 1 });
-		const b = node(
-			[a],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as number) * 2);
-			},
-			{ describeKind: "derived", name: "b" },
-		);
-		const c = node(
-			[b],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as number) + 1);
-			},
-			{ describeKind: "derived", name: "c" },
-		);
-		g.add(a, { name: "a" });
-		g.add(b, { name: "b" });
-		g.add(c, { name: "c" });
-		g.observe("c").subscribe(() => {});
-
-		const live = g.describe({ explain: { from: "a", to: "c" }, reactive: true });
-		let fnRuns = 0;
-		const unsub = live.node.subscribe((msgs) => {
-			for (const m of msgs) if (m[0] === Symbol.for("graphrefly.DATA")) fnRuns++;
-		});
-		const initialRuns = fnRuns;
-		// Batched mutation touches a, b, c inside one outermost drain — without
-		// debouncing, each settled event bumps version and the explain derived
-		// recomputes N times. With the D5 flush-hook coalescer, one bump, one
-		// recompute (equals-dedup may even absorb it).
-		batch(() => {
-			g.set("a", 2);
-			g.set("a", 3);
-			g.set("a", 4);
-		});
-		// At most ONE new DATA delivery from the derived (equals may absorb).
-		expect(fnRuns - initialRuns).toBeLessThanOrEqual(1);
-		unsub();
-		live.dispose();
-	});
-
-	it("recomputes when audited graph mutates", () => {
-		const g = new Graph("g");
-		const a = node([], { name: "a", initial: 1 });
-		const b = node(
-			[a],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as number) * 2);
-			},
-			{ describeKind: "derived", name: "b" },
-		);
-		g.add(a, { name: "a" });
-		g.add(b, { name: "b" });
-		g.observe("b").subscribe(() => {});
-
-		const live = g.describe({ explain: { from: "a", to: "b" }, reactive: true });
-		const seen: number[] = [];
-		const unsub = live.node.subscribe((msgs) => {
-			for (const m of msgs) {
-				if (m[0] === Symbol.for("graphrefly.DATA")) {
-					// noop — discriminator differs in package; use cache check below
-				}
-			}
-			void msgs;
-		});
-
-		expect(live.node.cache?.found).toBe(true);
-		expect(live.node.cache?.steps).toHaveLength(2);
-		const v0 = live.node.cache?.steps[0]?.value;
-		expect(v0).toBe(1);
-
-		g.set("a", 10);
-		const v1 = live.node.cache?.steps[0]?.value;
-		expect(v1).toBe(10);
-		expect(live.node.cache?.steps[1]?.value).toBe(20);
-
-		unsub();
-		live.dispose();
-		void seen;
-	});
-
-	// ------------------------------------------------------------------
-	// Tier 3.5 — reactive `from`/`to`/`maxDepth`/`findCycle` opts
-	// ------------------------------------------------------------------
-
-	it("Tier 3.5: reactive `from` and `to` recompute the chain when the path nodes emit", () => {
-		const g = new Graph("g");
-		const a = node([], { name: "a", initial: 1 });
-		const b = node(
-			[a],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as number) * 2);
-			},
-			{ describeKind: "derived", name: "b" },
-		);
-		const c = node(
-			[b],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as number) + 100);
-			},
-			{ describeKind: "derived", name: "c" },
-		);
-		g.add(a, { name: "a" });
-		g.add(b, { name: "b" });
-		g.add(c, { name: "c" });
-		g.observe("c").subscribe(() => {});
-
-		const fromNode = node<string>([], { name: "from", initial: "a" });
-		const toNode = node<string>([], { name: "to", initial: "b" });
-		const live = g.describe({ explain: { from: fromNode, to: toNode }, reactive: true });
-		const unsub = live.node.subscribe(() => {});
-
-		// Initial: a → b
-		expect(live.node.cache?.found).toBe(true);
-		expect(live.node.cache?.steps.map((s) => s.path)).toEqual(["a", "b"]);
-
-		// Switch `to` to "c" — expect a → b → c
-		toNode.emit("c");
-		expect(live.node.cache?.steps.map((s) => s.path)).toEqual(["a", "b", "c"]);
-
-		// Switch `from` to "b" — expect b → c
-		fromNode.emit("b");
-		expect(live.node.cache?.steps.map((s) => s.path)).toEqual(["b", "c"]);
-
-		unsub();
-		live.dispose();
-	});
-
-	it("Tier 3.5: reactive `maxDepth` recomputes the chain when the limit changes", () => {
-		const g = new Graph("g");
-		const a = node([], { name: "a", initial: 1 });
-		const b = node(
-			[a],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as number) * 2);
-			},
-			{ describeKind: "derived", name: "b" },
-		);
-		const c = node(
-			[b],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as number) + 100);
-			},
-			{ describeKind: "derived", name: "c" },
-		);
-		g.add(a, { name: "a" });
-		g.add(b, { name: "b" });
-		g.add(c, { name: "c" });
-		g.observe("c").subscribe(() => {});
-
-		const maxDepth = node<number>([], { name: "max", initial: 1 });
-		const live = g.describe({ explain: { from: "a", to: "c", maxDepth }, reactive: true });
-		const unsub = live.node.subscribe(() => {});
-
-		// At depth 1, a→c is unreachable in 1 hop.
-		expect(live.node.cache?.found).toBe(false);
-
-		// Loosen depth to 5 — chain should resolve.
-		maxDepth.emit(5);
-		expect(live.node.cache?.found).toBe(true);
-		expect(live.node.cache?.steps.map((s) => s.path)).toEqual(["a", "b", "c"]);
-
-		unsub();
-		live.dispose();
-	});
-
-	it("Tier 3.5: static call (no `reactive: true`) accepts reactive args by snapshotting their cache", () => {
-		const g = new Graph("g");
-		const a = node([], { name: "a", initial: 1 });
-		const b = node(
-			[a],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as number) * 2);
-			},
-			{ describeKind: "derived", name: "b" },
-		);
-		g.add(a, { name: "a" });
-		g.add(b, { name: "b" });
-
-		const fromNode = node<string>([], { name: "from", initial: "a" });
-		// Static call returns a CausalChain snapshot, not a reactive handle.
-		const chain = g.describe({ explain: { from: fromNode, to: "b" } });
-		expect("steps" in chain && Array.isArray(chain.steps)).toBe(true);
-		expect((chain as { found: boolean }).found).toBe(true);
-	});
-
-	it("Tier 3.5: deletion regression — `reactiveExplainPath` is no longer importable from patterns/audit", async () => {
-		const auditModule: Record<string, unknown> = await import("../../../utils/inspect/audit.js");
-		expect(auditModule.reactiveExplainPath).toBeUndefined();
-	});
-});
-
-describe("complianceSnapshot (roadmap §9.2)", () => {
-	it("returns full graph state + audit + policies + fingerprint", () => {
-		const g = new Graph("g");
-		g.add(node([], { name: "a", guard: () => true, initial: 1 }), { name: "a" });
-		const audit = auditTrail(g);
-		const enforcer = policyGate(g, [{ effect: "allow", action: "write" }], { mode: "audit" });
-
-		g.set("a", 42, { actor: { type: "human", id: "alice" } });
-
-		const snap = complianceSnapshot(g, {
-			audit,
-			policies: enforcer,
-			actor: { type: "system", id: "compliance-job" },
-		});
-
-		expect(snap.format_version).toBe(1);
-		expect(snap.actor?.id).toBe("compliance-job");
-		expect(snap.graph.name).toBe("g");
-		expect(snap.audit?.count).toBe(1);
-		expect(snap.audit?.entries[0]?.value).toBe(42);
-		expect(snap.policies?.rules).toHaveLength(1);
-		expect(snap.fingerprint).toMatch(/^[0-9a-f]{16}$/);
-	});
-
-	it("fingerprint is deterministic across calls with same input", () => {
-		const g = new Graph("g");
-		g.add(node([], { name: "a", initial: 1 }), { name: "a" });
-
-		const s1 = complianceSnapshot(g);
-		const s2 = complianceSnapshot(g);
-		// Timestamps differ but the *graph payload* fingerprint base differs too
-		// because we include timestamps in the hashed object. Build a stable
-		// payload variant by recomputing fingerprint over just the graph slice.
-		expect(typeof s1.fingerprint).toBe("string");
-		expect(typeof s2.fingerprint).toBe("string");
-		// The graph snapshot itself is identical between calls.
-		expect(s1.graph.nodes).toEqual(s2.graph.nodes);
-	});
-
-	it("fingerprint changes when graph state changes", () => {
-		const g = new Graph("g");
-		g.add(node([], { name: "a", initial: 1 }), { name: "a" });
-		const snap1 = complianceSnapshot(g);
-		g.set("a", 999);
-		const snap2 = complianceSnapshot(g);
-		expect(snap1.fingerprint).not.toBe(snap2.fingerprint);
-	});
-
-	it("works without optional audit/policies bundles", () => {
-		const g = new Graph("g");
-		g.add(node([], { name: "a", initial: 1 }), { name: "a" });
-		const snap = complianceSnapshot(g);
-		expect(snap.audit).toBeUndefined();
-		expect(snap.policies).toBeUndefined();
-		expect(snap.graph).toBeDefined();
-	});
-});
diff --git a/src/__tests__/utils/inspect/lens.test.ts b/src/__tests__/utils/inspect/lens.test.ts
deleted file mode 100644
index 27551fe9..00000000
--- a/src/__tests__/utils/inspect/lens.test.ts
+++ /dev/null
@@ -1,451 +0,0 @@
-import { DATA, describeNode, node } from "@graphrefly/pure-ts/core";
-import type { LensFlowChange } from "@graphrefly/pure-ts/extra";
-import { Graph } from "@graphrefly/pure-ts/graph";
-import { describe, expect, it } from "vitest";
-import { type FlowEntry, graphLens, type HealthReport } from "../../../utils/inspect/lens.js";
-
-function getLogCache(n: { cache: unknown }): readonly LensFlowChange[] {
-	return (n.cache ?? []) as readonly LensFlowChange[];
-}
-
-function getHealthCache(node: { cache: unknown }): HealthReport {
-	return node.cache as HealthReport;
-}
-function getFlowCache(node: { cache: unknown }): ReadonlyMap<string, FlowEntry> {
-	return (node.cache ?? new Map<string, FlowEntry>()) as ReadonlyMap<string, FlowEntry>;
-}
-
-describe("graphLens — topology", () => {
-	it("topology is a live describe of the target", () => {
-		const g = new Graph("g");
-		const a = node([], { name: "a", initial: 0 });
-		const b = node(
-			[a],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as number) + 1);
-			},
-			{ describeKind: "derived", name: "b" },
-		);
-		g.add(a, { name: "a" });
-		g.add(b, { name: "b" });
-
-		const lens = graphLens(g);
-		try {
-			lens.topology.subscribe(() => {});
-			const desc = lens.topology.cache as { nodes: Record<string, unknown> };
-			expect(Object.keys(desc.nodes).sort()).toEqual(["a", "b"]);
-		} finally {
-			lens.dispose();
-		}
-	});
-
-	it("topology re-emits when a node is added to the target", () => {
-		const g = new Graph("g");
-		g.add(node([], { name: "a", initial: 0 }), { name: "a" });
-		const lens = graphLens(g);
-
-		try {
-			const seen: number[] = [];
-			lens.topology.subscribe((msgs) => {
-				for (const m of msgs) {
-					if (m[0] === DATA) {
-						const desc = m[1] as { nodes: Record<string, unknown> };
-						seen.push(Object.keys(desc.nodes).length);
-					}
-				}
-			});
-			expect(seen.at(-1)).toBe(1);
-
-			g.add(node([], { name: "b", initial: 1 }), { name: "b" });
-			expect(seen.at(-1)).toBe(2);
-		} finally {
-			lens.dispose();
-		}
-	});
-
-	it("topology covers transitively-mounted subgraphs", () => {
-		const g = new Graph("g");
-		g.add(node([], { name: "a", initial: 0 }), { name: "a" });
-		const child = new Graph("child");
-		child.add(node([], { name: "x", initial: 1 }), { name: "x" });
-		g.mount("kids", child);
-
-		const lens = graphLens(g);
-		try {
-			lens.topology.subscribe(() => {});
-			const desc = lens.topology.cache as { nodes: Record<string, unknown> };
-			expect(Object.keys(desc.nodes).sort()).toEqual(["a", "kids::x"]);
-		} finally {
-			lens.dispose();
-		}
-	});
-});
-
-describe("graphLens — health", () => {
-	it("ok=true when no nodes are errored", () => {
-		const g = new Graph("g");
-		g.add(node([], { name: "a", initial: 0 }), { name: "a" });
-		const lens = graphLens(g);
-		try {
-			lens.health.subscribe(() => {});
-			expect(getHealthCache(lens.health).ok).toBe(true);
-			expect(getHealthCache(lens.health).problems).toHaveLength(0);
-		} finally {
-			lens.dispose();
-		}
-	});
-
-	it("flips to ok=false with a problem entry when a node errors", () => {
-		const g = new Graph("g");
-		const a = node([], { name: "a", initial: 0 });
-		const b = node(
-			[a],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				if ((data[0] as number) < 0) throw new Error("negative");
-				actions.emit((data[0] as number) + 1);
-			},
-			{ describeKind: "derived", name: "b" },
-		);
-		g.add(a, { name: "a" });
-		g.add(b, { name: "b" });
-
-		const lens = graphLens(g);
-		try {
-			lens.health.subscribe(() => {});
-			expect(getHealthCache(lens.health).ok).toBe(true);
-
-			a.emit(-1); // triggers b's fn to throw → b errors
-			const report = getHealthCache(lens.health);
-			expect(report.ok).toBe(false);
-			expect(report.problems).toHaveLength(1);
-			expect(report.problems[0]?.path).toBe("b");
-			expect(report.problems[0]?.status).toBe("errored");
-		} finally {
-			lens.dispose();
-		}
-	});
-
-	it("sets upstreamCause when the error originates upstream", () => {
-		const g = new Graph("g");
-		const a = node([], { name: "a", initial: 0 });
-		const b = node(
-			[a],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				if ((data[0] as number) < 0) throw new Error("from b");
-				actions.emit((data[0] as number) + 1);
-			},
-			{ describeKind: "derived", name: "b" },
-		);
-		const c = node(
-			[b],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as number) * 2);
-			},
-			{ describeKind: "derived", name: "c" },
-		);
-		g.add(a, { name: "a" });
-		g.add(b, { name: "b" });
-		g.add(c, { name: "c" });
-
-		const lens = graphLens(g);
-		try {
-			lens.health.subscribe(() => {});
-			a.emit(-1);
-			const report = getHealthCache(lens.health);
-			expect(report.ok).toBe(false);
-			const cProblem = report.problems.find((p) => p.path === "c");
-			expect(cProblem?.upstreamCause).toBe("b");
-		} finally {
-			lens.dispose();
-		}
-	});
-});
-
-describe("graphLens — flow", () => {
-	it("counts DATA emissions per qualified path", () => {
-		const g = new Graph("g");
-		const a = node([], { name: "a", initial: 0 });
-		g.add(a, { name: "a" });
-
-		const lens = graphLens(g);
-		try {
-			lens.flow.subscribe(() => {});
-			a.emit(1);
-			a.emit(2);
-			a.emit(3);
-
-			const map = getFlowCache(lens.flow);
-			const entry = map.get("a");
-			// Initial subscription state push counts as a data event too — assert
-			// the counter is monotonic and ≥ 3.
-			expect(entry?.count).toBeGreaterThanOrEqual(3);
-			expect(entry?.lastUpdate_ns).not.toBeNull();
-		} finally {
-			lens.dispose();
-		}
-	});
-
-	it("uses qualified path keys for transitively-mounted nodes", () => {
-		const g = new Graph("g");
-		const child = new Graph("child");
-		g.mount("kids", child);
-		child.add(node([], { name: "x", initial: 0 }), { name: "x" });
-
-		const lens = graphLens(g);
-		try {
-			lens.flow.subscribe(() => {});
-			child.set("x", 1);
-			const map = getFlowCache(lens.flow);
-			expect(map.has("kids::x")).toBe(true);
-			expect(map.has("x")).toBe(false);
-		} finally {
-			lens.dispose();
-		}
-	});
-
-	it("reconciles entries when a node is removed from the target", () => {
-		const g = new Graph("g");
-		g.add(node([], { name: "a", initial: 0 }), { name: "a" });
-		g.add(node([], { name: "b", initial: 0 }), { name: "b" });
-
-		const lens = graphLens(g);
-		try {
-			lens.flow.subscribe(() => {});
-			g.set("a", 1);
-			g.set("b", 1);
-			expect(getFlowCache(lens.flow).has("b")).toBe(true);
-
-			g.remove("b");
-			expect(getFlowCache(lens.flow).has("b")).toBe(false);
-		} finally {
-			lens.dispose();
-		}
-	});
-
-	it("emits a fresh map snapshot on each settle (no in-place mutation)", () => {
-		const g = new Graph("g");
-		const a = node([], { name: "a", initial: 0 });
-		g.add(a, { name: "a" });
-
-		const lens = graphLens(g);
-		try {
-			const snapshots: ReadonlyMap<string, FlowEntry>[] = [];
-			lens.flow.subscribe((msgs) => {
-				for (const m of msgs) {
-					if (m[0] === DATA) snapshots.push(m[1] as ReadonlyMap<string, FlowEntry>);
-				}
-			});
-			a.emit(1);
-			a.emit(2);
-
-			// Each emission should produce a distinct map reference.
-			expect(snapshots.length).toBeGreaterThan(1);
-			const distinct = new Set(snapshots).size;
-			expect(distinct).toBe(snapshots.length);
-		} finally {
-			lens.dispose();
-		}
-	});
-});
-
-describe("graphLens — flowMutations (delta companion)", () => {
-	it("is absent by default (zero overhead, off)", () => {
-		const g = new Graph("g");
-		g.add(node([], { name: "a", initial: 0 }), { name: "a" });
-		const lens = graphLens(g);
-		try {
-			expect(lens.flowMutations).toBeUndefined();
-			// `flow` still works with the companion disabled.
-			lens.flow.subscribe(() => {});
-			g.set("a", 1);
-			expect(getFlowCache(lens.flow).get("a")?.count).toBeGreaterThanOrEqual(1);
-		} finally {
-			lens.dispose();
-		}
-	});
-
-	it("appends a typed tick LensFlowChange per per-path DATA emission", () => {
-		const g = new Graph("g");
-		const a = node([], { name: "a", initial: 0 });
-		g.add(a, { name: "a" });
-
-		const lens = graphLens(g, { mutations: true });
-		try {
-			expect(lens.flowMutations).toBeDefined();
-			lens.flow.subscribe(() => {});
-			lens.flowMutations!.entries.subscribe(() => {});
-			a.emit(1);
-			a.emit(2);
-
-			const log = getLogCache(lens.flowMutations!.entries);
-			const ticks = log.filter((c) => c.change.kind === "tick");
-			expect(ticks.length).toBeGreaterThanOrEqual(2);
-			for (const rec of ticks) {
-				expect(rec.structure).toBe("lensFlow");
-				expect(rec.lifecycle).toBe("data");
-				expect(typeof rec.t_ns).toBe("number");
-				if (rec.change.kind === "tick") expect(rec.change.path).toBe("a");
-			}
-			// `version` is strictly monotonic across the companion.
-			const versions = log.map((c) => c.version as number);
-			for (let i = 1; i < versions.length; i++) {
-				expect(versions[i]!).toBeGreaterThan(versions[i - 1]!);
-			}
-			// tick `count` mirrors the snapshot counter for the same path.
-			const lastTick = [...ticks].reverse().find((c) => c.change.kind === "tick");
-			if (lastTick?.change.kind === "tick") {
-				expect(lastTick.change.count).toBe(getFlowCache(lens.flow).get("a")?.count);
-			}
-		} finally {
-			lens.dispose();
-		}
-	});
-
-	it("appends an evict LensFlowChange when a tracked path drops from topology", () => {
-		const g = new Graph("g");
-		g.add(node([], { name: "a", initial: 0 }), { name: "a" });
-		g.add(node([], { name: "b", initial: 0 }), { name: "b" });
-
-		const lens = graphLens(g, { mutations: true });
-		try {
-			lens.flow.subscribe(() => {});
-			lens.flowMutations!.entries.subscribe(() => {});
-			g.set("a", 1);
-			g.set("b", 1);
-			expect(getFlowCache(lens.flow).has("b")).toBe(true);
-
-			g.remove("b");
-			expect(getFlowCache(lens.flow).has("b")).toBe(false);
-
-			const evicts = getLogCache(lens.flowMutations!.entries).filter(
-				(c) => c.change.kind === "evict",
-			);
-			expect(evicts.some((c) => c.change.kind === "evict" && c.change.path === "b")).toBe(true);
-		} finally {
-			lens.dispose();
-		}
-	});
-
-	it("honors a bounded maxSize on the companion log", () => {
-		const g = new Graph("g");
-		const a = node([], { name: "a", initial: 0 });
-		g.add(a, { name: "a" });
-
-		const lens = graphLens(g, { mutations: { maxSize: 2 } });
-		try {
-			lens.flow.subscribe(() => {});
-			lens.flowMutations!.entries.subscribe(() => {});
-			for (let i = 1; i <= 6; i++) a.emit(i);
-			expect(getLogCache(lens.flowMutations!.entries).length).toBeLessThanOrEqual(2);
-		} finally {
-			lens.dispose();
-		}
-	});
-
-	it("captures the initial tick even when the lens is built over already-cached state (QA-P1)", () => {
-		const g = new Graph("g");
-		const a = node([], { name: "a", initial: 0 });
-		g.add(a, { name: "a" });
-		// Drive emissions BEFORE the lens exists so describe/observe have
-		// cached changesets — pre-fix `keepalive(flow)` ran before the
-		// drain was wired, so this activation's deltas were collapsed into
-		// the drain's first flush. Post-fix the drain is subscribed first.
-		a.emit(1);
-		a.emit(2);
-
-		const lens = graphLens(g, { mutations: true });
-		try {
-			lens.flow.subscribe(() => {});
-			lens.flowMutations!.entries.subscribe(() => {});
-			a.emit(3);
-
-			const ticks = getLogCache(lens.flowMutations!.entries).filter(
-				(c) => c.change.kind === "tick",
-			);
-			// At least the post-construction tick is present and its count
-			// mirrors the live snapshot counter (no collapse/loss).
-			expect(ticks.length).toBeGreaterThanOrEqual(1);
-			const last = [...ticks].reverse().find((c) => c.change.kind === "tick");
-			if (last?.change.kind === "tick") {
-				expect(last.change.count).toBe(getFlowCache(lens.flow).get("a")?.count);
-			}
-		} finally {
-			lens.dispose();
-		}
-	});
-
-	it("stops appending + is idempotent after dispose() even with flow kept warm (QA-P2/P3)", () => {
-		const g = new Graph("g");
-		const a = node([], { name: "a", initial: 0 });
-		g.add(a, { name: "a" });
-
-		const lens = graphLens(g, { mutations: true });
-		// External subscriber keeps `flow` warm past dispose().
-		const stop = lens.flow.subscribe(() => {});
-		lens.flowMutations!.entries.subscribe(() => {});
-		a.emit(1);
-		a.emit(2);
-		const beforeDispose = getLogCache(lens.flowMutations!.entries).length;
-		expect(beforeDispose).toBeGreaterThan(0);
-
-		lens.dispose();
-		// Idempotent — second dispose must not throw.
-		expect(() => lens.dispose()).not.toThrow();
-
-		// `flow` is still warm (stop not called) — drive more activity.
-		a.emit(3);
-		a.emit(4);
-		// QA-P3: buffer push is gated on !disposed → no new records.
-		expect(getLogCache(lens.flowMutations!.entries).length).toBe(beforeDispose);
-
-		stop();
-	});
-});
-
-describe("graphLens — domain meta tagging", () => {
-	it("tags the health and flow deriveds with lens_type metadata", () => {
-		const g = new Graph("g");
-		g.add(node([], { name: "a", initial: 0 }), { name: "a" });
-		const lens = graphLens(g);
-		try {
-			const healthMeta = describeNode(lens.health).meta;
-			expect(healthMeta?.lens).toBe(true);
-			expect(healthMeta?.lens_type).toBe("health");
-			const flowMeta = describeNode(lens.flow).meta;
-			expect(flowMeta?.lens).toBe(true);
-			expect(flowMeta?.lens_type).toBe("flow");
-		} finally {
-			lens.dispose();
-		}
-	});
-});
-
-describe("graphLens — lifecycle", () => {
-	it("dispose tears down the topology subscription cleanly", () => {
-		const g = new Graph("g");
-		g.add(node([], { name: "a", initial: 0 }), { name: "a" });
-		const lens = graphLens(g);
-		lens.topology.subscribe(() => {});
-		lens.health.subscribe(() => {});
-		lens.flow.subscribe(() => {});
-		// Just call dispose — if a handler leaked it would throw or corrupt later asserts.
-		lens.dispose();
-		// Idempotent — second dispose is a no-op.
-		expect(() => lens.dispose()).not.toThrow();
-		// Mutate after dispose; lens should not react (no assertion beyond "no crash").
-		g.add(node([], { initial: 1 }), { name: "b" });
-		g.set("a", 99);
-	});
-});
diff --git a/src/__tests__/utils/memory/fact-store.test.ts b/src/__tests__/utils/memory/fact-store.test.ts
deleted file mode 100644
index 10d6c32c..00000000
--- a/src/__tests__/utils/memory/fact-store.test.ts
+++ /dev/null
@@ -1,1362 +0,0 @@
-import { DATA, monotonicNs, node } from "@graphrefly/pure-ts/core";
-import {
-	appendLogStorage,
-	bigintJsonCodecFor,
-	keepalive,
-	memoryBackend,
-} from "@graphrefly/pure-ts/extra";
-import { describe, expect, it } from "vitest";
-import {
-	type CascadeEvent,
-	type CascadeOverflow,
-	type DecayPolicy,
-	type FactStore,
-	type MemoryAnswer,
-	type MemoryFragment,
-	type MemoryQuery,
-	type OutcomeSignal,
-	type PersistentReactiveFactStoreGraph,
-	persistentReactiveFactStore,
-	ReactiveFactStoreGraph,
-	type ReviewRequest,
-	reactiveFactStore,
-	type ScoringPolicy,
-	simpleFactStore,
-} from "../../../utils/memory/index.js";
-
-// ── Fixture helpers ──────────────────────────────────────────────────────
-
-function frag<T>(id: string, payload: T, opts: Partial<MemoryFragment<T>> = {}): MemoryFragment<T> {
-	return {
-		id,
-		payload,
-		t_ns: BigInt(monotonicNs()),
-		confidence: opts.confidence ?? 1,
-		tags: opts.tags ?? [],
-		sources: opts.sources ?? [],
-		...opts,
-	};
-}
-
-function ingestNode<T>() {
-	return node<MemoryFragment<T>>([], { initial: undefined });
-}
-
-// ── Topology ─────────────────────────────────────────────────────────────
-
-describe("utils.memory.reactiveFactStore — topology", () => {
-	it("mounts the ~12 fixed operator nodes and the cascade cycle edges", () => {
-		const ingest = ingestNode<string>();
-		const mem = reactiveFactStore<string>({
-			ingest,
-			extractDependencies: (f) => f.sources,
-		});
-		const desc = mem.describe();
-		const names = Object.keys(desc.nodes);
-		// Static topology — count is independent of how many facts land.
-		for (const n of [
-			"shard_0",
-			"shard_1",
-			"shard_2",
-			"shard_3",
-			"fact_store",
-			"dependents_index",
-			"extract_op",
-			"invalidation_detector",
-			"cascade",
-			"cascade_processor",
-			"cascade_overflow",
-			"review",
-			"answer",
-			"consolidated",
-		]) {
-			expect(names).toContain(n);
-		}
-		// Cascade cycle edges visible in describe().
-		const edges = desc.edges.map((e) => `${e.from}->${e.to}`);
-		expect(edges).toContain("invalidation_detector->cascade");
-		expect(edges).toContain("cascade->cascade_processor");
-		mem.destroy();
-	});
-
-	it("is a `class extends Graph` — instanceof narrows (consistency sweep)", () => {
-		const ingest = ingestNode<string>();
-		const mem = reactiveFactStore<string>({ ingest, extractDependencies: (f) => f.sources });
-		// `reactiveFactStore` migrated from `Object.assign(graph, …)` to a real
-		// `class extends Graph` — `instanceof` now narrows (parity with the
-		// other 47 extends-Graph subclasses + constructor invariants).
-		expect(mem).toBeInstanceOf(ReactiveFactStoreGraph);
-		// Direct construction is equivalent to the factory.
-		const direct = new ReactiveFactStoreGraph<string>({
-			ingest: ingestNode<string>(),
-			extractDependencies: (f) => f.sources,
-		});
-		expect(direct).toBeInstanceOf(ReactiveFactStoreGraph);
-		expect(typeof direct.itemNode).toBe("function");
-		expect(direct.shards.length).toBe(4);
-		mem.destroy();
-		direct.destroy();
-	});
-
-	it("does not grow topology as facts are ingested", () => {
-		const ingest = ingestNode<string>();
-		const mem = reactiveFactStore<string>({ ingest, extractDependencies: (f) => f.sources });
-		const before = Object.keys(mem.describe().nodes).length;
-		for (let i = 0; i < 50; i += 1) ingest.emit(frag(`f${i}`, `v${i}`));
-		const after = Object.keys(mem.describe().nodes).length;
-		expect(after).toBe(before);
-		mem.destroy();
-	});
-});
-
-// ── cascade-feeder inspection completeness (COMPOSITION-GUIDE §24) ────────
-
-describe("utils.memory.reactiveFactStore — cascade-feeder inspection", () => {
-	it("tags `consolidated` + `decay_processor` as cascade-store feeders (feeds:cascade, drivesRoot:false)", () => {
-		const ingest = ingestNode<string>();
-		const consolidateTrigger = node<number>([], { initial: undefined });
-		const decayTrigger = node<number>([], { initial: undefined });
-		const decay = node<DecayPolicy>([], { initial: (c) => c * 0.5 });
-		const mem = reactiveFactStore<string>({
-			ingest,
-			extractDependencies: (f) => f.sources,
-			consolidateTrigger,
-			consolidate: () => [],
-			decay,
-			decayTrigger,
-		});
-		// `meta` is projected at detail "standard"/"spec" (default
-		// "minimal" strips it) — the spec projection is what
-		// describe()/explain() causal-chain rendering reads.
-		const nodes = mem.describe({ detail: "standard" }).nodes;
-		// Both cascade-store mutators are now visible AS such — the prior
-		// gap was they wrote into the cascade store like `cascade_processor`
-		// but carried no feeder tag, so describe()/explain() showed an
-		// incomplete picture of "what can mutate the cascade store".
-		for (const name of ["consolidated", "decay_processor"]) {
-			const meta = nodes[name]?.meta as Record<string, unknown> | undefined;
-			expect(meta).toBeDefined();
-			expect(meta?.feeds).toBe("cascade");
-			expect(meta?.drivesRoot).toBe(false);
-		}
-		// Convention stays uniform: domain tag preserved alongside the feeder tag.
-		expect((nodes.consolidated?.meta as Record<string, unknown>).memory_type).toBe("consolidator");
-		expect((nodes.decay_processor?.meta as Record<string, unknown>).memory_type).toBe("decay");
-		mem.destroy();
-	});
-
-	it("decay audit record carries a `count` of affected facts (batch-action forensics)", () => {
-		const ingest = ingestNode<string>();
-		const decayTrigger = node<number>([], { initial: undefined });
-		const decay = node<DecayPolicy>([], { initial: (c) => c * 0.5 });
-		const mem = reactiveFactStore<string>({
-			ingest,
-			extractDependencies: (f) => f.sources,
-			decay,
-			decayTrigger,
-		});
-		mem.events.entries.subscribe(() => undefined);
-		ingest.emit(frag("a", "A", { confidence: 1 }));
-		ingest.emit(frag("b", "B", { confidence: 1 }));
-		decayTrigger.emit(1);
-		const decayRecs = (mem.events.entries.cache ?? []).filter((r) => r.action === "decay");
-		expect(decayRecs.length).toBe(1);
-		expect(decayRecs[0]?.count).toBe(2); // both facts decayed this tick
-		mem.destroy();
-	});
-});
-
-// ── MEME L1: direct replace ──────────────────────────────────────────────
-
-describe("utils.memory.reactiveFactStore — MEME L1 (direct replace)", () => {
-	it("re-ingesting an id overwrites the stored fragment", () => {
-		const ingest = ingestNode<string>();
-		const mem = reactiveFactStore<string>({ ingest, extractDependencies: (f) => f.sources });
-		const item = mem.itemNode("loc");
-		item.subscribe(() => undefined);
-		ingest.emit(frag("loc", "Beijing"));
-		expect((item.cache as MemoryFragment<string>).payload).toBe("Beijing");
-		ingest.emit(frag("loc", "Shanghai"));
-		expect((item.cache as MemoryFragment<string>).payload).toBe("Shanghai");
-		mem.destroy();
-	});
-});
-
-// ── MEME L2: cascade invalidation ────────────────────────────────────────
-
-describe("utils.memory.reactiveFactStore — MEME L2 (cascade)", () => {
-	it("invalidating a source cascades validTo onto its dependents", () => {
-		const ingest = ingestNode<string>();
-		const mem = reactiveFactStore<string>({ ingest, extractDependencies: (f) => f.sources });
-		mem.cascade.subscribe(() => undefined);
-		const dep = mem.itemNode("commute");
-		dep.subscribe(() => undefined);
-		// `commute` depends on `home`.
-		ingest.emit(frag("home", "Beijing"));
-		ingest.emit(frag("commute", "15-min bike", { sources: ["home"] }));
-		expect((dep.cache as MemoryFragment<string>).validTo).toBeUndefined();
-		// Now `home` becomes obsolete (move). Cascade must flip `commute`.
-		ingest.emit(frag("home", "Shanghai", { validTo: BigInt(monotonicNs()) }));
-		const after = dep.cache as MemoryFragment<string>;
-		expect(after.validTo).toBeDefined();
-		mem.destroy();
-	});
-
-	it("emits cascade messages carrying a causalReason (explain visibility)", () => {
-		const ingest = ingestNode<string>();
-		const mem = reactiveFactStore<string>({ ingest, extractDependencies: (f) => f.sources });
-		const seen: CascadeEvent[] = [];
-		mem.cascade.subscribe((msgs) => {
-			for (const m of msgs)
-				if (m[0] === DATA) for (const e of m[1] as readonly CascadeEvent[]) seen.push(e);
-		});
-		ingest.emit(frag("a", "A"));
-		ingest.emit(frag("b", "B", { sources: ["a"] }));
-		ingest.emit(frag("a", "A2", { validTo: BigInt(monotonicNs()) }));
-		const cascadeForB = seen.find((e) => e.factId === "b");
-		expect(cascadeForB).toBeDefined();
-		expect(cascadeForB!.reason).toBe("obsolete");
-		expect(cascadeForB!.causalReason).toMatch(/dependentsIndex\[a\] → b/);
-		mem.destroy();
-	});
-
-	it("reaches a fixpoint on a transitive dependency chain", () => {
-		const ingest = ingestNode<string>();
-		const mem = reactiveFactStore<string>({ ingest, extractDependencies: (f) => f.sources });
-		mem.cascade.subscribe(() => undefined);
-		const cN = mem.itemNode("c");
-		cN.subscribe(() => undefined);
-		// a → b → c chain.
-		ingest.emit(frag("a", "A"));
-		ingest.emit(frag("b", "B", { sources: ["a"] }));
-		ingest.emit(frag("c", "C", { sources: ["b"] }));
-		ingest.emit(frag("a", "A2", { validTo: BigInt(monotonicNs()) }));
-		// Transitive: a obsolete → b flipped → c flipped. Fixpoint, no overflow.
-		expect((cN.cache as MemoryFragment<string>).validTo).toBeDefined();
-		expect(mem.cascadeOverflow.cache).toBeNull();
-		mem.destroy();
-	});
-});
-
-// ── Deterministic cascade validTo (memo:Re P1 — rebuildable projection) ──
-
-describe("utils.memory.reactiveFactStore — deterministic cascade validTo", () => {
-	it("cascade-invalidated dependent inherits the root's validTo, not a fresh clock read", () => {
-		const ingest = ingestNode<string>();
-		const mem = reactiveFactStore<string>({ ingest, extractDependencies: (f) => f.sources });
-		mem.cascade.subscribe(() => undefined);
-		const dep = mem.itemNode("commute");
-		dep.subscribe(() => undefined);
-		ingest.emit(frag("home", "Beijing"));
-		ingest.emit(frag("commute", "15-min bike", { sources: ["home"] }));
-		// Obsolete `home` with an explicit, well-known validTo.
-		const ROOT_VALID_TO = 1_234_567_890n;
-		ingest.emit(frag("home", "Shanghai", { validTo: ROOT_VALID_TO }));
-		expect((dep.cache as MemoryFragment<string>).validTo).toBe(ROOT_VALID_TO);
-		mem.destroy();
-	});
-
-	it("transitive chain inherits the original root's validTo at every link", () => {
-		const ingest = ingestNode<string>();
-		const mem = reactiveFactStore<string>({ ingest, extractDependencies: (f) => f.sources });
-		mem.cascade.subscribe(() => undefined);
-		const bN = mem.itemNode("b");
-		const cN = mem.itemNode("c");
-		bN.subscribe(() => undefined);
-		cN.subscribe(() => undefined);
-		ingest.emit(frag("a", "A"));
-		ingest.emit(frag("b", "B", { sources: ["a"] }));
-		ingest.emit(frag("c", "C", { sources: ["b"] }));
-		const ROOT_VALID_TO = 999_000n;
-		ingest.emit(frag("a", "A2", { validTo: ROOT_VALID_TO }));
-		expect((bN.cache as MemoryFragment<string>).validTo).toBe(ROOT_VALID_TO);
-		expect((cN.cache as MemoryFragment<string>).validTo).toBe(ROOT_VALID_TO);
-		mem.destroy();
-	});
-
-	it("replaying the same ingest stream yields byte-identical cascade validTo", () => {
-		const run = () => {
-			const ingest = ingestNode<string>();
-			const mem = reactiveFactStore<string>({
-				ingest,
-				extractDependencies: (f) => f.sources,
-			});
-			mem.cascade.subscribe(() => undefined);
-			const dep = mem.itemNode("y");
-			dep.subscribe(() => undefined);
-			ingest.emit(frag("x", "X"));
-			ingest.emit(frag("y", "Y", { sources: ["x"] }));
-			ingest.emit(frag("x", "X2", { validTo: 555n }));
-			const v = (dep.cache as MemoryFragment<string>).validTo;
-			mem.destroy();
-			return v;
-		};
-		// Two independent runs of the identical stream → identical store.
-		expect(run()).toBe(run());
-		expect(run()).toBe(555n);
-	});
-
-	it("CascadeEvent carries the deterministic rootValidTo", () => {
-		const ingest = ingestNode<string>();
-		const mem = reactiveFactStore<string>({ ingest, extractDependencies: (f) => f.sources });
-		const seen: CascadeEvent[] = [];
-		mem.cascade.subscribe((msgs) => {
-			for (const m of msgs)
-				if (m[0] === DATA) for (const e of m[1] as readonly CascadeEvent[]) seen.push(e);
-		});
-		ingest.emit(frag("p", "P"));
-		ingest.emit(frag("q", "Q", { sources: ["p"] }));
-		ingest.emit(frag("p", "P2", { validTo: 7777n }));
-		const ev = seen.find((e) => e.factId === "q");
-		expect(ev).toBeDefined();
-		expect(ev!.rootValidTo).toBe(7777n);
-		mem.destroy();
-	});
-});
-
-// ── MEME L3: obsolescence / bi-temporal ──────────────────────────────────
-
-describe("utils.memory.reactiveFactStore — MEME L3 (obsolescence)", () => {
-	it("query with asOf excludes facts whose validTo has passed", () => {
-		const ingest = ingestNode<string>();
-		const query = node<MemoryQuery>([], { initial: undefined });
-		const mem = reactiveFactStore<string>({
-			ingest,
-			query,
-			extractDependencies: (f) => f.sources,
-		});
-		mem.answer.subscribe(() => undefined);
-		const t0 = BigInt(monotonicNs());
-		ingest.emit(frag("colleague", "we are colleagues", { validFrom: t0, validTo: t0 + 100n }));
-		// As-of after validTo — fact is obsolete ("we WERE colleagues").
-		query.emit({ asOf: t0 + 500n });
-		expect((mem.answer.cache as MemoryAnswer<string>).results.length).toBe(0);
-		// As-of within validity window — fact is current.
-		query.emit({ asOf: t0 + 50n });
-		expect((mem.answer.cache as MemoryAnswer<string>).results.length).toBe(1);
-		mem.destroy();
-	});
-});
-
-// ── Cascade overflow cap ─────────────────────────────────────────────────
-
-describe("utils.memory.reactiveFactStore — cascade overflow cap", () => {
-	it("emits a per-batch overflow summary when the cycle exceeds maxIterations", () => {
-		const ingest = ingestNode<string>();
-		const mem = reactiveFactStore<string>({
-			ingest,
-			extractDependencies: (f) => f.sources,
-			cascadeMaxIterations: 2,
-		});
-		mem.cascade.subscribe(() => undefined);
-		const overflows: CascadeOverflow[] = [];
-		mem.cascadeOverflow.subscribe((msgs) => {
-			for (const m of msgs)
-				if (m[0] === DATA && m[1] != null) overflows.push(m[1] as CascadeOverflow);
-		});
-		// Long chain: f0 → f1 → ... → f10. Each cascade round flips one more,
-		// re-triggering the detector; with maxIterations=2 it overflows.
-		ingest.emit(frag("f0", "v0"));
-		for (let i = 1; i <= 10; i += 1) {
-			ingest.emit(frag(`f${i}`, `v${i}`, { sources: [`f${i - 1}`] }));
-		}
-		ingest.emit(frag("f0", "v0b", { validTo: BigInt(monotonicNs()) }));
-		expect(overflows.length).toBeGreaterThan(0);
-		const o = overflows[0]!;
-		expect(o.droppedCount).toBeGreaterThan(0);
-		expect(Array.isArray(o.sample)).toBe(true);
-		expect(o.sample.length).toBeLessThanOrEqual(8);
-		mem.destroy();
-	});
-});
-
-// ── Sharding fan-out ─────────────────────────────────────────────────────
-
-describe("utils.memory.reactiveFactStore — sharding", () => {
-	it("distributes facts across shards via the default hash-mod sharder", () => {
-		const ingest = ingestNode<string>();
-		const mem = reactiveFactStore<string>({ ingest, extractDependencies: (f) => f.sources });
-		mem.factStore.subscribe(() => undefined);
-		for (let i = 0; i < 40; i += 1) ingest.emit(frag(`fact-${i}`, `v${i}`));
-		const populated = mem.shards.filter((s) => (s.cache as FactStore<string>).byId.size > 0).length;
-		// 40 hashed ids across 4 shards — overwhelmingly likely to use >1 shard.
-		expect(populated).toBeGreaterThan(1);
-		const total = mem.shards.reduce((acc, s) => acc + (s.cache as FactStore<string>).byId.size, 0);
-		expect(total).toBe(40);
-		mem.destroy();
-	});
-
-	it("honors a caller-supplied shardBy override", () => {
-		const ingest = ingestNode<string>();
-		const mem = reactiveFactStore<string>({
-			ingest,
-			extractDependencies: (f) => f.sources,
-			shardCount: 2,
-			shardBy: (f) => (f.tags.includes("hot") ? 0 : 1),
-		});
-		mem.factStore.subscribe(() => undefined);
-		ingest.emit(frag("a", "A", { tags: ["hot"] }));
-		ingest.emit(frag("b", "B", { tags: ["cold"] }));
-		expect((mem.shards[0]!.cache as FactStore<string>).byId.has("a")).toBe(true);
-		expect((mem.shards[1]!.cache as FactStore<string>).byId.has("b")).toBe(true);
-		mem.destroy();
-	});
-});
-
-// ── The four extension faces ─────────────────────────────────────────────
-
-describe("utils.memory.reactiveFactStore — extension faces", () => {
-	it("① plain fn: extractDependencies feeds the dependentsIndex", () => {
-		const ingest = ingestNode<string>();
-		const mem = reactiveFactStore<string>({
-			ingest,
-			extractDependencies: (f) => f.sources,
-		});
-		mem.dependentsIndex.subscribe(() => undefined);
-		ingest.emit(frag("src", "S"));
-		ingest.emit(frag("der", "D", { sources: ["src"] }));
-		const idx = mem.dependentsIndex.cache as ReadonlyMap<string, readonly string[]>;
-		expect(idx.get("src")).toEqual(["der"]);
-		mem.destroy();
-	});
-
-	it("② Node<Policy>: reactive scoring policy drives outcome write-back", () => {
-		const ingest = ingestNode<string>();
-		const outcome = node<OutcomeSignal>([], { initial: undefined });
-		const scoring = node<ScoringPolicy<string>>([], {
-			initial: (f) => Math.min(1, f.confidence + 0.5),
-		});
-		const mem = reactiveFactStore<string>({
-			ingest,
-			outcome,
-			scoring,
-			extractDependencies: (f) => f.sources,
-		});
-		const item = mem.itemNode("x");
-		item.subscribe(() => undefined);
-		ingest.emit(frag("x", "X", { confidence: 0.2 }));
-		outcome.emit({ factId: "x", reward: 0 });
-		expect((item.cache as MemoryFragment<string>).confidence).toBeCloseTo(0.7, 5);
-		mem.destroy();
-	});
-
-	it("③ topic input: outcome topic without scoring nudges confidence by reward", () => {
-		const ingest = ingestNode<string>();
-		const outcome = node<OutcomeSignal>([], { initial: undefined });
-		const mem = reactiveFactStore<string>({
-			ingest,
-			outcome,
-			extractDependencies: (f) => f.sources,
-		});
-		const item = mem.itemNode("y");
-		item.subscribe(() => undefined);
-		ingest.emit(frag("y", "Y", { confidence: 0.5 }));
-		outcome.emit({ factId: "y", reward: 0.3 });
-		expect((item.cache as MemoryFragment<string>).confidence).toBeCloseTo(0.8, 5);
-		mem.destroy();
-	});
-
-	it("④ topic output subscribe: cascade events observable for routing", () => {
-		const ingest = ingestNode<string>();
-		const mem = reactiveFactStore<string>({ ingest, extractDependencies: (f) => f.sources });
-		const observed: CascadeEvent[] = [];
-		// Caller composes a derived over the cascade output.
-		const tap = node([mem.cascade], (b, a, c) => {
-			const evts = (b[0]?.at(-1) ?? c.prevData[0] ?? []) as readonly CascadeEvent[];
-			for (const e of evts) observed.push(e);
-			a.emit(evts.length);
-		});
-		tap.subscribe(() => undefined);
-		ingest.emit(frag("p", "P"));
-		ingest.emit(frag("q", "Q", { sources: ["p"] }));
-		ingest.emit(frag("p", "P2", { validTo: BigInt(monotonicNs()) }));
-		expect(observed.some((e) => e.factId === "q")).toBe(true);
-		mem.destroy();
-	});
-
-	it("consolidator: cron-triggered summary wires back into ingest", () => {
-		const ingest = ingestNode<string>();
-		const trigger = node<number>([], { initial: undefined });
-		const mem = reactiveFactStore<string>({
-			ingest,
-			extractDependencies: (f) => f.sources,
-			consolidateTrigger: trigger,
-			consolidate: (store) => {
-				const all = [...store.values()];
-				if (all.length < 2) return [];
-				// Order-independent: count + a deterministic parent reference.
-				const parent = store.has("e1") ? "e1" : all[0]!.id;
-				return [
-					frag("summary", `consolidated:${all.length}`, {
-						parent_fragment_id: parent,
-					}),
-				];
-			},
-		});
-		mem.consolidated.subscribe(() => undefined);
-		const summary = mem.itemNode("summary");
-		summary.subscribe(() => undefined);
-		ingest.emit(frag("e1", "episode 1"));
-		ingest.emit(frag("e2", "episode 2"));
-		trigger.emit(1);
-		const s = summary.cache as MemoryFragment<string>;
-		expect(s.payload).toBe("consolidated:2");
-		expect(s.parent_fragment_id).toBe("e1");
-		mem.destroy();
-	});
-});
-
-// ── ② decay face (DS-14.7 PART 4.1 / §5.8) ───────────────────────────────
-
-describe("utils.memory.reactiveFactStore — decay face", () => {
-	it("decayTrigger tick applies the policy and clamps to [0,1]", () => {
-		const ingest = ingestNode<string>();
-		const decayTrigger = node<number>([], { initial: undefined });
-		const decay = node<DecayPolicy>([], { initial: (c) => c * 0.5 });
-		const mem = reactiveFactStore<string>({
-			ingest,
-			extractDependencies: (f) => f.sources,
-			decay,
-			decayTrigger,
-		});
-		const item = mem.itemNode("a");
-		item.subscribe(() => undefined);
-		ingest.emit(frag("a", "A", { confidence: 1 }));
-		decayTrigger.emit(1);
-		expect((item.cache as MemoryFragment<string>).confidence).toBe(0.5);
-		decayTrigger.emit(2);
-		expect((item.cache as MemoryFragment<string>).confidence).toBe(0.25);
-		mem.destroy();
-	});
-
-	it("skips obsolete facts (validTo set) — decay never resurrects", () => {
-		const ingest = ingestNode<string>();
-		const decayTrigger = node<number>([], { initial: undefined });
-		const decay = node<DecayPolicy>([], { initial: () => 0 });
-		const mem = reactiveFactStore<string>({
-			ingest,
-			extractDependencies: (f) => f.sources,
-			decay,
-			decayTrigger,
-		});
-		const item = mem.itemNode("g");
-		item.subscribe(() => undefined);
-		ingest.emit(frag("g", "G", { confidence: 0.9, validTo: 42n }));
-		decayTrigger.emit(1);
-		const f = item.cache as MemoryFragment<string>;
-		expect(f.confidence).toBe(0.9); // untouched
-		expect(f.validTo).toBe(42n);
-		mem.destroy();
-	});
-
-	it("policy swap is push-on-update (decay Node is a reactive dep)", () => {
-		const ingest = ingestNode<string>();
-		const decayTrigger = node<number>([], { initial: undefined });
-		// Identity policy — a trigger tick is a quiescent no-op.
-		const decay = node<DecayPolicy>([], { initial: (c) => c });
-		const mem = reactiveFactStore<string>({
-			ingest,
-			extractDependencies: (f) => f.sources,
-			decay,
-			decayTrigger,
-		});
-		const item = mem.itemNode("p");
-		item.subscribe(() => undefined);
-		ingest.emit(frag("p", "P", { confidence: 1 }));
-		decayTrigger.emit(1);
-		expect((item.cache as MemoryFragment<string>).confidence).toBe(1); // no-op
-		// Swapping the policy itself fires the processor (push-on-update).
-		decay.emit((c) => c * 0.25);
-		expect((item.cache as MemoryFragment<string>).confidence).toBe(0.25);
-		mem.destroy();
-	});
-
-	it("a confidence drop below reviewThreshold surfaces via review (no validTo set)", () => {
-		const ingest = ingestNode<string>();
-		const decayTrigger = node<number>([], { initial: undefined });
-		const decay = node<DecayPolicy>([], { initial: (c) => c * 0.2 });
-		const mem = reactiveFactStore<string>({
-			ingest,
-			extractDependencies: (f) => f.sources,
-			decay,
-			decayTrigger,
-			reviewThreshold: 0.3,
-		});
-		const item = mem.itemNode("r");
-		item.subscribe(() => undefined);
-		mem.review.subscribe(() => undefined);
-		ingest.emit(frag("r", "R", { confidence: 1 }));
-		decayTrigger.emit(1); // 1 → 0.2 (< 0.3)
-		expect(mem.review.cache as ReviewRequest).toMatchObject({
-			factId: "r",
-			threshold: 0.3,
-		});
-		// Decay mutates confidence only — it must not set validTo / cascade.
-		expect((item.cache as MemoryFragment<string>).validTo).toBeUndefined();
-		mem.destroy();
-	});
-
-	it("emits one `decay` audit record per tick that changed ≥1 fact; none on a no-op", () => {
-		const ingest = ingestNode<string>();
-		const decayTrigger = node<number>([], { initial: undefined });
-		const decay = node<DecayPolicy>([], { initial: (c) => c * 0.5 });
-		const mem = reactiveFactStore<string>({
-			ingest,
-			extractDependencies: (f) => f.sources,
-			decay,
-			decayTrigger,
-		});
-		mem.events.entries.subscribe(() => undefined);
-		ingest.emit(frag("a", "A", { confidence: 1 }));
-		decayTrigger.emit(1); // 1 → 0.5 (change)
-		decayTrigger.emit(2); // 0.5 → 0.25 (change)
-		const decayRecs = (mem.events.entries.cache ?? []).filter((r) => r.action === "decay");
-		expect(decayRecs.length).toBe(2);
-		mem.destroy();
-	});
-
-	it("decayTrigger without a decay policy is an inert documented no-op", () => {
-		const ingest = ingestNode<string>();
-		const decayTrigger = node<number>([], { initial: undefined });
-		const mem = reactiveFactStore<string>({
-			ingest,
-			extractDependencies: (f) => f.sources,
-			decayTrigger, // no `decay`
-		});
-		const item = mem.itemNode("n");
-		item.subscribe(() => undefined);
-		mem.events.entries.subscribe(() => undefined);
-		ingest.emit(frag("n", "N", { confidence: 0.7 }));
-		expect(() => decayTrigger.emit(1)).not.toThrow();
-		expect((item.cache as MemoryFragment<string>).confidence).toBe(0.7);
-		expect((mem.events.entries.cache ?? []).some((r) => r.action === "decay")).toBe(false);
-		mem.destroy();
-	});
-
-	it("age-aware policy receives a sane monotonic ageNs (not a wall-clock-domain garbage age)", () => {
-		// Regression for the clock-domain bug: `t_ns` is monotonic-stamped (see
-		// `frag()`), so `ageNs` MUST be `monotonicNs() - t_ns` — a small
-		// non-negative duration, NOT `wallClockNs() - t_ns` (≈ Unix-epoch ns,
-		// ~1.8e18, a ~57-year garbage age that breaks every forgetting curve).
-		const ingest = ingestNode<string>();
-		const decayTrigger = node<number>([], { initial: undefined });
-		let captured: bigint | undefined;
-		const decay = node<DecayPolicy>([], {
-			initial: (c, age) => {
-				captured = age;
-				return c;
-			},
-		});
-		const mem = reactiveFactStore<string>({
-			ingest,
-			extractDependencies: (f) => f.sources,
-			decay,
-			decayTrigger,
-		});
-		mem.itemNode("a").subscribe(() => undefined);
-		ingest.emit(frag("a", "A", { confidence: 1 }));
-		decayTrigger.emit(1);
-		expect(captured).toBeDefined();
-		expect(captured! >= 0n).toBe(true);
-		// A freshly-ingested fact's age is sub-second; anything ≥ ~11 days
-		// (1e15 ns) means the wall-clock/monotonic domains were mixed.
-		expect(captured! < 1_000_000_000_000_000n).toBe(true);
-		mem.destroy();
-	});
-
-	it("decays every live fact across all shards in one tick", () => {
-		const ingest = ingestNode<string>();
-		const decayTrigger = node<number>([], { initial: undefined });
-		const decay = node<DecayPolicy>([], { initial: (c) => c * 0.5 });
-		const mem = reactiveFactStore<string>({
-			ingest,
-			extractDependencies: (f) => f.sources,
-			decay,
-			decayTrigger,
-		});
-		const ids = ["fa", "fb", "fc", "fd", "fe", "ff", "fg", "fh"]; // FNV-spread across 4 shards
-		const items = ids.map((id) => mem.itemNode(id));
-		for (const it of items) it.subscribe(() => undefined);
-		for (const id of ids) ingest.emit(frag(id, id, { confidence: 1 }));
-		decayTrigger.emit(1);
-		for (const it of items) {
-			expect((it.cache as MemoryFragment<string>).confidence).toBe(0.5);
-		}
-		const decayRecs = (mem.events.entries.cache ?? []).filter((r) => r.action === "decay");
-		expect(decayRecs.length).toBe(1); // ONE batch record for the whole tick
-		mem.destroy();
-	});
-
-	it("resurrection guard: a fact obsoleted by an in-flight cascade is not re-confidence'd by decay", () => {
-		const ingest = ingestNode<string>();
-		const decayTrigger = node<number>([], { initial: undefined });
-		const decay = node<DecayPolicy>([], { initial: (c) => c * 0.5 });
-		const mem = reactiveFactStore<string>({
-			ingest,
-			extractDependencies: (f) => f.sources,
-			decay,
-			decayTrigger,
-		});
-		const a = mem.itemNode("a");
-		const b = mem.itemNode("b");
-		a.subscribe(() => undefined);
-		b.subscribe(() => undefined);
-		ingest.emit(frag("a", "A", { confidence: 1 }));
-		ingest.emit(frag("b", "B", { confidence: 1, sources: ["a"] }));
-		// Obsolete A → cascade sets b.validTo (b becomes obsolete).
-		ingest.emit(frag("a", "A2", { confidence: 1, validTo: 999n }));
-		const bObs = b.cache as MemoryFragment<string>;
-		expect(bObs.validTo).toBeDefined();
-		const bConfBefore = bObs.confidence;
-		// Decay tick: a (obsolete) + b (cascade-obsoleted) both skipped; no drift.
-		decayTrigger.emit(1);
-		const bAfter = b.cache as MemoryFragment<string>;
-		expect(bAfter.confidence).toBe(bConfBefore); // untouched
-		expect(bAfter.validTo).toBe(bObs.validTo); // still obsolete
-		expect((mem.events.entries.cache ?? []).some((r) => r.action === "decay")).toBe(false);
-		mem.destroy();
-	});
-});
-
-// ── Audit-log replay ─────────────────────────────────────────────────────
-
-describe("utils.memory.reactiveFactStore — audit log", () => {
-	it("records ingest / consolidate / overflow with a monotonic seq", () => {
-		const ingest = ingestNode<string>();
-		const mem = reactiveFactStore<string>({ ingest, extractDependencies: (f) => f.sources });
-		mem.events.entries.subscribe(() => undefined);
-		ingest.emit(frag("a", "A"));
-		ingest.emit(frag("b", "B"));
-		const records = mem.events.entries.cache!;
-		const ingests = records.filter((r) => r.action === "ingest");
-		expect(ingests.length).toBe(2);
-		expect(ingests.map((r) => r.id)).toEqual(["a", "b"]);
-		const seqs = records.map((r) => r.seq).filter((s): s is number => s != null);
-		for (let i = 1; i < seqs.length; i += 1) expect(seqs[i]!).toBeGreaterThan(seqs[i - 1]!);
-		mem.destroy();
-	});
-});
-
-// ── describe / explain cycle visibility ──────────────────────────────────
-
-describe("utils.memory.reactiveFactStore — describe/explain", () => {
-	it("tags the cascade-cycle nodes with meta.cycle='cascade' (visible in describe)", () => {
-		const ingest = ingestNode<string>();
-		const mem = reactiveFactStore<string>({ ingest, extractDependencies: (f) => f.sources });
-		const names = Object.keys(mem.describe().nodes);
-		// Reactive meta is mounted as `<node>::__meta__::cycle` sub-nodes — the
-		// cascade-cycle tag surfaces through `describe()` exactly there
-		// (COMPOSITION-GUIDE §24 explainability mitigation).
-		for (const n of ["invalidation_detector", "cascade", "cascade_processor"]) {
-			expect(names).toContain(`${n}::__meta__::cycle`);
-			const metaNode = mem.node(`${n}::__meta__::cycle`);
-			expect(metaNode.cache).toBe("cascade");
-		}
-		mem.destroy();
-	});
-
-	it("explain(shard_0 → fact_store) closes without islands", () => {
-		const ingest = ingestNode<string>();
-		const mem = reactiveFactStore<string>({ ingest, extractDependencies: (f) => f.sources });
-		const ex = mem.describe({ explain: { from: "shard_0", to: "fact_store" } }) as {
-			found: boolean;
-			reason: string;
-			steps: unknown[];
-		};
-		expect(ex.found).toBe(true);
-		expect(ex.steps.length).toBeGreaterThan(0);
-		mem.destroy();
-	});
-});
-
-// ── SENTINEL / null guards ───────────────────────────────────────────────
-
-describe("utils.memory.reactiveFactStore — SENTINEL / null guards", () => {
-	it("answer emits null until a query is issued (=== null guard)", () => {
-		const ingest = ingestNode<string>();
-		const query = node<MemoryQuery>([], { initial: undefined });
-		const mem = reactiveFactStore<string>({
-			ingest,
-			query,
-			extractDependencies: (f) => f.sources,
-		});
-		const seen: Array<MemoryAnswer<string> | null> = [];
-		mem.answer.subscribe((msgs) => {
-			for (const m of msgs) if (m[0] === DATA) seen.push(m[1] as MemoryAnswer<string> | null);
-		});
-		ingest.emit(frag("a", "A", { tags: ["t"] }));
-		// No query yet — answer must be exactly null.
-		expect(seen.at(-1)).toBe(null);
-		query.emit({ tags: ["t"] });
-		const last = seen.at(-1);
-		expect(last).not.toBe(null);
-		expect((last as MemoryAnswer<string>).results.length).toBe(1);
-		mem.destroy();
-	});
-
-	it("review emits null when no fact is below the threshold", () => {
-		const ingest = ingestNode<string>();
-		const mem = reactiveFactStore<string>({
-			ingest,
-			extractDependencies: (f) => f.sources,
-			reviewThreshold: 0.3,
-		});
-		mem.review.subscribe(() => undefined);
-		mem.addDisposer(keepalive(mem.review));
-		ingest.emit(frag("hi", "trusted", { confidence: 0.9 }));
-		expect(mem.review.cache).toBe(null);
-		ingest.emit(frag("lo", "shaky", { confidence: 0.1 }));
-		const r = mem.review.cache as ReviewRequest;
-		expect(r.factId).toBe("lo");
-		expect(r.confidence).toBe(0.1);
-		mem.destroy();
-	});
-});
-
-// ── F1/F5/F3 cascade-termination semantic fixes ──────────────────────────
-
-describe("utils.memory.reactiveFactStore — cascade convergence (F1/F5/F3)", () => {
-	// Count non-empty cascade DATA emissions — the convergence witness.
-	function cascadeCounter(mem: ReturnType<typeof reactiveFactStore<string>>) {
-		let nonEmpty = 0;
-		let total = 0;
-		mem.cascade.subscribe((msgs) => {
-			for (const m of msgs) {
-				if (m[0] !== DATA) continue;
-				total += 1;
-				if ((m[1] as readonly CascadeEvent[]).length > 0) nonEmpty += 1;
-			}
-		});
-		return {
-			get nonEmpty() {
-				return nonEmpty;
-			},
-			get total() {
-				return total;
-			},
-		};
-	}
-
-	it("F1/F5(a): a low-confidence-but-still-live root does NOT drive the cascade (no perpetual re-emit)", () => {
-		const ingest = ingestNode<string>();
-		const mem = reactiveFactStore<string>({
-			ingest,
-			extractDependencies: (f) => f.sources,
-			reviewThreshold: 0.5,
-		});
-		const c = cascadeCounter(mem);
-		mem.review.subscribe(() => undefined);
-		mem.addDisposer(keepalive(mem.review));
-		const depItem = mem.itemNode("dep");
-		depItem.subscribe(() => undefined);
-
-		// `root` is low-confidence (0.1 < 0.5) but NEVER obsolete (no validTo);
-		// `dep` is a live dependent. Pre-fix this looped: the detector re-emitted
-		// a cascade for `dep` on every detector pass forever.
-		ingest.emit(frag("root", "R", { confidence: 0.1 }));
-		ingest.emit(frag("dep", "D", { sources: ["root"], confidence: 0.9 }));
-
-		// Convergence: the low-confidence root produced ZERO cascade waves and
-		// the dependent stays live. The fact is surfaced through `review`.
-		expect(c.nonEmpty).toBe(0);
-		expect((depItem.cache as MemoryFragment<string>).validTo).toBeUndefined();
-		expect((mem.review.cache as ReviewRequest).factId).toBe("root");
-		expect(mem.cascadeOverflow.cache).toBeNull();
-
-		// Re-running the detector (another ingest) still emits no cascade for
-		// the still-live low-confidence root — bounded, not perpetual.
-		ingest.emit(frag("other", "O", { confidence: 0.95 }));
-		expect(c.nonEmpty).toBe(0);
-		mem.destroy();
-	});
-
-	it("F1/F5(b): an obsolete root emits its cascade exactly once across waves", () => {
-		const ingest = ingestNode<string>();
-		const mem = reactiveFactStore<string>({
-			ingest,
-			extractDependencies: (f) => f.sources,
-		});
-		const c = cascadeCounter(mem);
-		const dItem = mem.itemNode("d");
-		dItem.subscribe(() => undefined);
-
-		ingest.emit(frag("r", "R"));
-		ingest.emit(frag("d", "D", { sources: ["r"] }));
-		const before = c.nonEmpty;
-		// `r` → obsolete: drives the cascade exactly once.
-		ingest.emit(frag("r", "R2", { validTo: BigInt(monotonicNs()) }));
-		expect((dItem.cache as MemoryFragment<string>).validTo).toBeDefined();
-		const afterFirst = c.nonEmpty;
-		expect(afterFirst).toBe(before + 1);
-
-		// Many subsequent unrelated ingests re-run the detector; `r` stays
-		// obsolete but is in processedRoots → no further cascade waves.
-		for (let i = 0; i < 20; i += 1) ingest.emit(frag(`x${i}`, `v${i}`));
-		expect(c.nonEmpty).toBe(afterFirst);
-		expect(mem.cascadeOverflow.cache).toBeNull();
-		mem.destroy();
-	});
-
-	it("F1/F5: concurrent wire-back ingest during an in-flight cascade still converges", () => {
-		const ingest = ingestNode<string>();
-		const trigger = node<number>([], { initial: undefined });
-		const mem = reactiveFactStore<string>({
-			ingest,
-			extractDependencies: (f) => f.sources,
-			// Consolidator wire-back ingests a successor mid-life; pre-fix this
-			// reset the shared counter and could defeat the backstop.
-			consolidateTrigger: trigger,
-			consolidate: (store) => {
-				if (!store.has("a")) return [];
-				return [frag("summary", `n:${store.size}`, { sources: ["a"] })];
-			},
-		});
-		const c = cascadeCounter(mem);
-		const bItem = mem.itemNode("b");
-		bItem.subscribe(() => undefined);
-		mem.consolidated.subscribe(() => undefined);
-
-		ingest.emit(frag("a", "A"));
-		ingest.emit(frag("b", "B", { sources: ["a"] }));
-		// Fire a consolidation wire-back (commits `summary` dep on `a`), THEN
-		// make `a` obsolete. Cascade must converge despite the interleaved
-		// ingest-driven counter reset.
-		trigger.emit(1);
-		ingest.emit(frag("a", "A2", { validTo: BigInt(monotonicNs()) }));
-
-		expect((bItem.cache as MemoryFragment<string>).validTo).toBeDefined();
-		// Bounded number of cascade waves (finite, no hang). The exact count is
-		// small; we assert a generous upper bound to prove convergence.
-		expect(c.total).toBeLessThan(50);
-		expect(mem.cascadeOverflow.cache).toBeNull();
-		mem.destroy();
-	});
-
-	it("F3: phantom edge (extractDependencies names an un-ingested id) converges", () => {
-		const ingest = ingestNode<string>();
-		const mem = reactiveFactStore<string>({
-			ingest,
-			// `b` declares a dependency on `ghost`, which is never ingested.
-			extractDependencies: (f) => f.sources,
-		});
-		const c = cascadeCounter(mem);
-		mem.cascade.subscribe(() => undefined);
-
-		ingest.emit(frag("real", "R"));
-		ingest.emit(frag("b", "B", { sources: ["ghost", "real"] }));
-		// `real` becomes obsolete; its dependent set via dependentsIndex is
-		// empty (b depends on ghost+real but the index keys by source id).
-		ingest.emit(frag("real", "R2", { validTo: BigInt(monotonicNs()) }));
-		// Now make `ghost`'s phantom presence the trigger: ingest then obsolete
-		// a fact that lists a never-existing dependent path. The phantom-edge
-		// `!depFact` guard prevents an infinite cascade.
-		ingest.emit(frag("ghost", "G", { validTo: BigInt(monotonicNs()) }));
-
-		// Converges: bounded waves, no overflow, no hang.
-		expect(c.total).toBeLessThan(50);
-		expect(mem.cascadeOverflow.cache).toBeNull();
-		mem.destroy();
-	});
-
-	it("F1/F5: transitive chain fully propagates and converges (no overflow) within the iteration budget", () => {
-		const ingest = ingestNode<string>();
-		const mem = reactiveFactStore<string>({
-			ingest,
-			extractDependencies: (f) => f.sources,
-			// Budget comfortably exceeds the chain length so termination is
-			// the per-root contract + empty-array fixpoint, not the backstop.
-			cascadeMaxIterations: 16,
-		});
-		const c = cascadeCounter(mem);
-		const tail = mem.itemNode("f5");
-		tail.subscribe(() => undefined);
-		// f0 → f1 → ... → f5 chain. Each link becomes obsolete in turn and
-		// drives its cascade exactly once; the wave count is bounded and the
-		// cascade converges to the tail without tripping the overflow cap.
-		ingest.emit(frag("f0", "v0"));
-		for (let i = 1; i <= 5; i += 1) {
-			ingest.emit(frag(`f${i}`, `v${i}`, { sources: [`f${i - 1}`] }));
-		}
-		ingest.emit(frag("f0", "v0b", { validTo: BigInt(monotonicNs()) }));
-		expect((tail.cache as MemoryFragment<string>).validTo).toBeDefined();
-		expect(mem.cascadeOverflow.cache).toBeNull();
-		// Bounded, finite emission count — the convergence witness.
-		expect(c.total).toBeLessThan(40);
-		expect(c.nonEmpty).toBeLessThanOrEqual(6);
-		mem.destroy();
-	});
-});
-
-// ── Opt-in payload-carrying ingest log (memo:Re P1 — rebuildable proj.) ──
-
-describe("utils.memory.reactiveFactStore — recordIngest / ingestLog", () => {
-	it("ingestLog is absent unless recordIngest is enabled", () => {
-		const ingest = ingestNode<string>();
-		const mem = reactiveFactStore<string>({ ingest, extractDependencies: (f) => f.sources });
-		expect(mem.ingestLog).toBeUndefined();
-		mem.destroy();
-	});
-
-	it("records every committed fragment with full payload", () => {
-		const ingest = ingestNode<string>();
-		const mem = reactiveFactStore<string>({
-			ingest,
-			extractDependencies: (f) => f.sources,
-			recordIngest: true,
-		});
-		expect(mem.ingestLog).toBeDefined();
-		mem.ingestLog!.entries.subscribe(() => undefined);
-		ingest.emit(frag("a", "A"));
-		ingest.emit(frag("b", "B", { sources: ["a"] }));
-		const logged = mem.ingestLog!.entries.cache as readonly MemoryFragment<string>[];
-		expect(logged.map((f) => [f.id, f.payload])).toEqual([
-			["a", "A"],
-			["b", "B"],
-		]);
-		mem.destroy();
-	});
-
-	it("persist ingestLog + replay rebuilds a byte-identical store", async () => {
-		const backend = memoryBackend();
-		const tier = appendLogStorage<MemoryFragment<string>>(backend, {
-			name: "facts-ingest",
-			codec: bigintJsonCodecFor<readonly MemoryFragment<string>[]>(),
-		});
-
-		// ── Original store: ingest a→b, then obsolete `a` (cascade flips b). ──
-		const ingest1 = ingestNode<string>();
-		const mem1 = reactiveFactStore<string>({
-			ingest: ingest1,
-			extractDependencies: (f) => f.sources,
-			recordIngest: true,
-		});
-		mem1.cascade.subscribe(() => undefined);
-		mem1.factStore.subscribe(() => undefined);
-		mem1.ingestLog!.attachStorage([tier]);
-		ingest1.emit(frag("a", "A", { t_ns: 100n }));
-		ingest1.emit(frag("b", "B", { sources: ["a"], t_ns: 200n }));
-		ingest1.emit(frag("a", "A2", { t_ns: 300n, validTo: 4242n }));
-		await tier.flush?.();
-		const store1 = (mem1.factStore.cache as { byId: ReadonlyMap<string, MemoryFragment<string>> })
-			.byId;
-		mem1.destroy();
-
-		// ── Restart: replay persisted fragments into a fresh store. ──
-		const { entries } = await tier.loadEntries!();
-		const ingest2 = ingestNode<string>();
-		const mem2 = reactiveFactStore<string>({
-			ingest: ingest2,
-			extractDependencies: (f) => f.sources,
-		});
-		mem2.cascade.subscribe(() => undefined);
-		mem2.factStore.subscribe(() => undefined);
-		for (const f of entries) ingest2.emit(f);
-		const store2 = (mem2.factStore.cache as { byId: ReadonlyMap<string, MemoryFragment<string>> })
-			.byId;
-
-		// Byte-identical: same ids, payloads, and (deterministic) validTo.
-		expect([...store2.keys()].sort()).toEqual([...store1.keys()].sort());
-		for (const [id, f1] of store1) {
-			const f2 = store2.get(id)!;
-			expect(f2.payload).toBe(f1.payload);
-			expect(f2.validTo).toBe(f1.validTo);
-			expect(f2.t_ns).toBe(f1.t_ns);
-		}
-		// `b` was cascade-invalidated; its validTo is the deterministic root time.
-		expect(store2.get("b")!.validTo).toBe(4242n);
-		mem2.destroy();
-	});
-});
-
-describe("utils.memory.persistentReactiveFactStore", () => {
-	async function until(cond: () => boolean, tries = 200): Promise<void> {
-		for (let i = 0; i < tries; i += 1) {
-			if (cond()) return;
-			await new Promise((r) => setTimeout(r, 0));
-		}
-		throw new Error("persistentReactiveFactStore: condition timed out");
-	}
-
-	it("is a SYNCHRONOUS factory returning the fact-store graph (no Promise)", () => {
-		const ingest = ingestNode<string>();
-		const mem = persistentReactiveFactStore<string>({
-			ingest,
-			extractDependencies: (f) => f.sources,
-			storage: memoryBackend(),
-		});
-		// Not a thenable — `utils/` stays reactive/composable, no await path.
-		expect((mem as unknown as { then?: unknown }).then).toBeUndefined();
-		expect(mem.factStore).toBeDefined();
-		expect(mem.ingestLog).toBeDefined();
-		expect(mem.cascade).toBeDefined();
-		expect(mem.position).toBeDefined();
-		expect(mem.replayedCount).toBeDefined();
-		expect(mem.tier).toBeDefined();
-		expect(typeof mem.flush).toBe("function");
-		mem.destroy();
-	});
-
-	it("first run: live fragments persist; flush() makes them durable; replay-dedup on restart", async () => {
-		const backend = memoryBackend();
-
-		// ── Run 1: ingest a→b, then obsolete `a` (cascade flips b). ──
-		const ingest1 = ingestNode<string>();
-		const mem1 = persistentReactiveFactStore<string>({
-			ingest: ingest1,
-			extractDependencies: (f) => f.sources,
-			storage: backend,
-		});
-		ingest1.emit(frag("a", "A", { t_ns: 100n }));
-		ingest1.emit(frag("b", "B", { sources: ["a"], t_ns: 200n }));
-		ingest1.emit(frag("a", "A2", { t_ns: 300n, validTo: 4242n }));
-		// 3 committed ingests; pre-attach (emitted in the construction tick) —
-		// the one-shot reconciliation must still persist them.
-		await until(() => (mem1.position.cache as number) === 3);
-		await mem1.flush();
-		const persisted1 = await mem1.tier.loadEntries!();
-		expect(persisted1.entries).toHaveLength(3);
-		const store1 = (mem1.factStore.cache as { byId: ReadonlyMap<string, MemoryFragment<string>> })
-			.byId;
-		mem1.destroy();
-
-		// ── Run 2 (restart, same backend): replay rebuilds the store
-		//    automatically; no double-persist. ──
-		const ingest2 = ingestNode<string>();
-		const mem2 = persistentReactiveFactStore<string>({
-			ingest: ingest2,
-			extractDependencies: (f) => f.sources,
-			storage: backend,
-		});
-		await until(() => (mem2.replayedCount.cache as number) === 3);
-		await until(() => (mem2.position.cache as number) === 3);
-
-		const store2 = (mem2.factStore.cache as { byId: ReadonlyMap<string, MemoryFragment<string>> })
-			.byId;
-		// Byte-identical rebuild incl. deterministic cascade validTo.
-		expect([...store2.keys()].sort()).toEqual([...store1.keys()].sort());
-		for (const [id, f1] of store1) {
-			const f2 = store2.get(id)!;
-			expect(f2.payload).toBe(f1.payload);
-			expect(f2.validTo).toBe(f1.validTo);
-			expect(f2.t_ns).toBe(f1.t_ns);
-		}
-		expect(store2.get("b")!.validTo).toBe(4242n);
-
-		// No double-persist: replayed history is NOT re-written (substrate-owned
-		// cursor). Still exactly 3 after a restart flush.
-		await mem2.flush();
-		const persisted2 = await mem2.tier.loadEntries!();
-		expect(persisted2.entries).toHaveLength(3);
-
-		// A NEW live fragment after replay DOES persist (cursor advances).
-		ingest2.emit(frag("c", "C", { t_ns: 400n }));
-		await until(() => (mem2.position.cache as number) === 4);
-		await mem2.flush();
-		const persisted3 = await mem2.tier.loadEntries!();
-		expect(persisted3.entries).toHaveLength(4);
-		mem2.destroy();
-	});
-
-	it("position is 0 until replay completes, then tracks the durable count", async () => {
-		const backend = memoryBackend();
-		const ingest1 = ingestNode<string>();
-		const mem1 = persistentReactiveFactStore<string>({
-			ingest: ingest1,
-			extractDependencies: (f) => f.sources,
-			storage: backend,
-		});
-		// Synchronously after construction, before the async replay drains.
-		expect(mem1.position.cache).toBe(0);
-		expect(mem1.replayedCount.cache).toBe(0);
-		ingest1.emit(frag("x", "X", { t_ns: 1n }));
-		await until(() => (mem1.position.cache as number) === 1);
-		await mem1.flush();
-		mem1.destroy();
-
-		// Restart: replayedCount reflects the rebuilt history.
-		const ingest2 = ingestNode<string>();
-		const mem2: PersistentReactiveFactStoreGraph<string> = persistentReactiveFactStore<string>({
-			ingest: ingest2,
-			extractDependencies: (f) => f.sources,
-			storage: backend,
-		});
-		await until(() => (mem2.replayedCount.cache as number) === 1);
-		expect(mem2.position.cache).toBe(1);
-		mem2.destroy();
-	});
-
-	it("empty backend: replay completes with nothing; live ingest still persists", async () => {
-		const backend = memoryBackend();
-		const ingest = ingestNode<string>();
-		const mem = persistentReactiveFactStore<string>({
-			ingest,
-			extractDependencies: (f) => f.sources,
-			storage: backend,
-		});
-		// Give the (empty) replay a chance to COMPLETE + attach, then ingest.
-		await new Promise((r) => setTimeout(r, 0));
-		await new Promise((r) => setTimeout(r, 0));
-		ingest.emit(frag("only", "ONE", { t_ns: 9n }));
-		await until(() => (mem.position.cache as number) === 1);
-		await mem.flush();
-		const { entries } = await mem.tier.loadEntries!();
-		expect(entries.map((f) => f.id)).toEqual(["only"]);
-		mem.destroy();
-	});
-
-	it("destroy() mid-replay aborts cleanly — no throw, no unhandled rejection (QA-G)", async () => {
-		const backend = memoryBackend();
-		// Seed durable history so a restart has something to replay.
-		const ingest1 = ingestNode<string>();
-		const mem1 = persistentReactiveFactStore<string>({
-			ingest: ingest1,
-			extractDependencies: (f) => f.sources,
-			storage: backend,
-		});
-		ingest1.emit(frag("a", "A", { t_ns: 1n }));
-		ingest1.emit(frag("b", "B", { t_ns: 2n }));
-		await until(() => (mem1.position.cache as number) === 2);
-		await mem1.flush();
-		mem1.destroy();
-
-		// Restart, then destroy synchronously BEFORE the async replay drains.
-		const ingest2 = ingestNode<string>();
-		const mem2 = persistentReactiveFactStore<string>({
-			ingest: ingest2,
-			extractDependencies: (f) => f.sources,
-			storage: backend,
-		});
-		expect(mem2.replayedCount.cache).toBe(0); // replay hasn't run yet
-		expect(() => mem2.destroy()).not.toThrow();
-		// Let the aborted replay async chain settle — must not throw / leak.
-		await new Promise((r) => setTimeout(r, 0));
-		await new Promise((r) => setTimeout(r, 0));
-		expect(() => mem2.destroy()).not.toThrow(); // idempotent double-dispose
-	});
-});
-
-// ── simpleFactStore — 80%-case ergonomic wrapper (DS-14.7 follow-up #2) ───
-
-describe("utils.memory.simpleFactStore", () => {
-	async function until(cond: () => boolean, tries = 200): Promise<void> {
-		for (let i = 0; i < tries; i += 1) {
-			if (cond()) return;
-			await new Promise((r) => setTimeout(r, 0));
-		}
-		throw new Error("simpleFactStore: condition timed out");
-	}
-
-	it("remember() normalizes minimal input to a MemoryFragment (auto t_ns/confidence/tags)", () => {
-		const mem = simpleFactStore<string>();
-		const item = mem.itemNode("user:lang");
-		item.subscribe(() => undefined);
-		mem.remember("user:lang", "TypeScript");
-		const f = item.cache as MemoryFragment<string>;
-		expect(f.payload).toBe("TypeScript");
-		expect(f.confidence).toBe(1);
-		expect(f.tags).toEqual([]);
-		expect(f.sources).toEqual([]);
-		expect(typeof f.t_ns).toBe("bigint");
-		expect(f.t_ns).toBeGreaterThan(0n);
-		mem.destroy();
-	});
-
-	it("re-remember()ing an id is MEME L1 direct-replace; opts override defaults", () => {
-		const mem = simpleFactStore<string>();
-		const item = mem.itemNode("loc");
-		item.subscribe(() => undefined);
-		mem.remember("loc", "Beijing", { tags: ["geo"], confidence: 0.8 });
-		expect((item.cache as MemoryFragment<string>).payload).toBe("Beijing");
-		expect((item.cache as MemoryFragment<string>).tags).toEqual(["geo"]);
-		expect((item.cache as MemoryFragment<string>).confidence).toBe(0.8);
-		mem.remember("loc", "Shanghai");
-		expect((item.cache as MemoryFragment<string>).payload).toBe("Shanghai");
-		expect((item.cache as MemoryFragment<string>).confidence).toBe(1); // default restored
-		// BH-1 (/qa): explicit `confidence: 0` must survive — `?? 1` (not
-		// `|| 1`) so a falsy-but-valid 0 is NOT clobbered by the default.
-		mem.remember("loc", "Faded", { confidence: 0 });
-		expect((item.cache as MemoryFragment<string>).confidence).toBe(0);
-		mem.destroy();
-	});
-
-	it("decay is ON by default (decay_exponential driver mounted)", () => {
-		const mem = simpleFactStore<string>();
-		expect(Object.keys(mem.describe().nodes)).toContain("decay_exponential");
-		mem.destroy();
-	});
-
-	it("opts.consolidate wires the consolidator (BH-1 /qa: covers the wired-iff path)", () => {
-		// Without consolidate: `consolidated` has no trigger dep (factory builds
-		// it with `[]` deps when no `consolidateTrigger`).
-		const bare = simpleFactStore<string>();
-		expect(bare.describe().nodes.consolidated?.deps ?? []).toEqual([]);
-		bare.destroy();
-		// With consolidate: `consolidationRem` supplies a `fromTimer`
-		// `consolidateTrigger`, so `consolidated` gains a trigger dep.
-		const mem = simpleFactStore<string>({
-			consolidate: {
-				periodMs: 3_600_000,
-				topK: 5,
-				summarize: (replayed) =>
-					replayed.length > 0 ? [{ ...replayed[0]!, id: "summary", payload: "consolidated" }] : [],
-			},
-		});
-		expect((mem.describe().nodes.consolidated?.deps ?? []).length).toBeGreaterThanOrEqual(1);
-		mem.destroy();
-	});
-
-	it("decay:false disables the forgetting loop (no driver mounted)", () => {
-		const mem = simpleFactStore<string>({ decay: false });
-		expect(Object.keys(mem.describe().nodes)).not.toContain("decay_exponential");
-		mem.destroy();
-	});
-
-	it("extractDependencies defaults to () => [] (flat store, cascade inert)", () => {
-		const mem = simpleFactStore<string>();
-		const dep = mem.itemNode("commute");
-		dep.subscribe(() => undefined);
-		mem.remember("home", "Beijing");
-		mem.remember("commute", "15-min bike", { sources: ["home"] });
-		// Obsolete `home`. With the default no-op extractor, `commute` must NOT
-		// cascade (no dependency edges were extracted).
-		mem.remember("home", "Shanghai", { validTo: BigInt(monotonicNs()) });
-		expect((dep.cache as MemoryFragment<string>).validTo).toBeUndefined();
-		mem.destroy();
-	});
-
-	it("supplying extractDependencies opts into MEME L2 cascade", () => {
-		const mem = simpleFactStore<string>({ extractDependencies: (f) => f.sources });
-		const dep = mem.itemNode("commute");
-		dep.subscribe(() => undefined);
-		mem.remember("home", "Beijing");
-		mem.remember("commute", "15-min bike", { sources: ["home"] });
-		mem.remember("home", "Shanghai", { validTo: BigInt(monotonicNs()) });
-		expect((dep.cache as MemoryFragment<string>).validTo).toBeDefined();
-		mem.destroy();
-	});
-
-	it("storage present → durable path; remember() round-trips through replay", async () => {
-		const backend = memoryBackend();
-		const m1 = simpleFactStore<string>({
-			storage: backend,
-			decay: false,
-		}) as PersistentReactiveFactStoreGraph<string> & {
-			remember: (id: string, p: string) => void;
-		};
-		m1.remember("k", "v1");
-		await until(() => (m1.position.cache as number) === 1);
-		await m1.flush();
-		m1.destroy();
-		const m2 = simpleFactStore<string>({
-			storage: backend,
-			decay: false,
-		}) as PersistentReactiveFactStoreGraph<string> & {
-			itemNode: (id: string) => { cache: unknown; subscribe: (f: () => void) => void };
-		};
-		const item = m2.itemNode("k");
-		item.subscribe(() => undefined);
-		await until(() => (m2.replayedCount.cache as number) === 1);
-		expect((item.cache as MemoryFragment<string>).payload).toBe("v1");
-		m2.destroy();
-	});
-});
diff --git a/src/__tests__/utils/memory/memory.test.ts b/src/__tests__/utils/memory/memory.test.ts
deleted file mode 100644
index 93d9a4a9..00000000
--- a/src/__tests__/utils/memory/memory.test.ts
+++ /dev/null
@@ -1,444 +0,0 @@
-import { DATA, node } from "@graphrefly/pure-ts/core";
-import { keepalive } from "@graphrefly/pure-ts/extra";
-import { describe, expect, it, vi } from "vitest";
-import { decay } from "../../../base/utils/decay.js";
-import {
-	type CollectionEntry,
-	collection,
-	type HnswAdapter,
-	type KnowledgeEdge,
-	knowledgeGraph,
-	type RankedCollectionEntry,
-	type VectorIndexAuditRecord,
-	type VectorSearchResult,
-	vectorIndex,
-} from "../../../utils/memory/index.js";
-
-describe("patterns.memory.decay", () => {
-	it("decays score with floor", () => {
-		const score = decay(10, 10, 0.5, 2);
-		expect(score).toBeGreaterThanOrEqual(2);
-		expect(score).toBeLessThan(10);
-	});
-
-	it("non-positive rate disables decay (returns max(min, base))", () => {
-		expect(decay(7, 100, 0)).toBe(7);
-		expect(decay(7, 100, -1)).toBe(7);
-		expect(decay(7, 100, 0, 9)).toBe(9);
-	});
-
-	it("non-finite baseScore collapses to minScore", () => {
-		expect(decay(Number.POSITIVE_INFINITY, 1, 1, 0)).toBe(0);
-		expect(decay(Number.NaN, 1, 1, 0)).toBe(0);
-	});
-});
-
-describe("patterns.memory.collection({ ranked: false }) — Tier 2.3 lightCollection fold", () => {
-	it("evicts least recently used entry under default LRU", () => {
-		const c = collection<number>("c", { maxSize: 2, ranked: false });
-		c.upsert("a", 1);
-		c.upsert("b", 2);
-		// `b` is the most recent; upserting `c` evicts `a` (oldest by lastAccessNs).
-		c.upsert("c", 3);
-		const snap = c.items.cache as ReadonlyMap<string, CollectionEntry<number>>;
-		expect(snap.has("a")).toBe(false);
-		expect(snap.has("b")).toBe(true);
-		expect(snap.has("c")).toBe(true);
-	});
-
-	it("re-upsert preserves createdAtNs but bumps lastAccessNs", () => {
-		const c = collection<number>("c", { maxSize: 4, ranked: false });
-		c.upsert("a", 1);
-		const first = (c.items.cache as ReadonlyMap<string, CollectionEntry<number>>).get("a")!;
-		c.upsert("a", 99);
-		const second = (c.items.cache as ReadonlyMap<string, CollectionEntry<number>>).get("a")!;
-		expect(second.value).toBe(99);
-		expect(second.createdAtNs).toBe(first.createdAtNs);
-		expect(second.lastAccessNs).toBeGreaterThanOrEqual(first.lastAccessNs);
-	});
-
-	it("remove and clear short-circuit on no-op", () => {
-		const c = collection<number>("c", { ranked: false });
-		const seen: number[] = [];
-		c.items.subscribe((msgs) => {
-			for (const m of msgs)
-				if (m[0] === DATA) seen.push((m[1] as ReadonlyMap<string, unknown>).size);
-		});
-		// Initial subscribe pushes the empty map snapshot.
-		const initialEmits = seen.length;
-		c.remove("nope");
-		c.clear();
-		expect(seen.length).toBe(initialEmits);
-		c.upsert("a", 1);
-		expect(seen.at(-1)).toBe(1);
-		c.remove("a");
-		expect(seen.at(-1)).toBe(0);
-	});
-
-	it("itemNode reactively reflects upsert / remove", () => {
-		const c = collection<number>("c", { ranked: false });
-		const idNode = node([], { initial: "a" });
-		const itemN = c.itemNode(idNode);
-		const seen: Array<CollectionEntry<number> | undefined> = [];
-		itemN.subscribe((msgs) => {
-			for (const m of msgs)
-				if (m[0] === DATA) seen.push(m[1] as CollectionEntry<number> | undefined);
-		});
-		c.upsert("a", 1);
-		c.upsert("b", 2);
-		c.upsert("a", 3);
-		c.remove("a");
-		const values = seen.map((e) => e?.value);
-		expect(values).toContain(1);
-		expect(values).toContain(3);
-		expect(values.at(-1)).toBeUndefined();
-	});
-
-	it("hasNode reactively reflects upsert / remove", () => {
-		const c = collection<number>("c", { ranked: false });
-		const idNode = node([], { initial: "a" });
-		const hasN = c.hasNode(idNode);
-		const seen: boolean[] = [];
-		hasN.subscribe((msgs) => {
-			for (const m of msgs) if (m[0] === DATA) seen.push(m[1] as boolean);
-		});
-		c.upsert("a", 1);
-		c.remove("a");
-		expect(seen).toContain(true);
-		expect(seen.at(-1)).toBe(false);
-	});
-
-	it("events log records upsert / remove / clear", () => {
-		const c = collection<number>("demo", { ranked: false });
-		c.events.entries.subscribe(() => undefined);
-		c.upsert("a", 1);
-		c.remove("a");
-		c.clear();
-		const records = c.events.entries.cache!;
-		expect(records.length).toBe(3);
-		expect(records[0]?.action).toBe("upsert");
-		expect(records[0]?.id).toBe("a");
-		expect(records[1]?.action).toBe("remove");
-		expect(records[2]?.action).toBe("clear");
-	});
-});
-
-describe("patterns.memory.collection", () => {
-	it("ranked is lazy: undefined until subscribed", () => {
-		const g = collection<number>("mem", { score: (v) => v });
-		g.upsert("x", 1);
-		expect(g.node("ranked").cache).toBeUndefined();
-		g.addDisposer(keepalive(g.ranked));
-		expect(Array.isArray(g.node("ranked").cache)).toBe(true);
-	});
-
-	it("size keepalive stays warm without external subscriber", () => {
-		const g = collection<number>("mem", { maxSize: 2, score: (v) => v });
-		g.upsert("x", 1);
-		g.upsert("y", 5);
-		g.upsert("z", 3);
-		expect(g.node("size").cache).toBe(2);
-	});
-
-	it("ranks by descending score with maxSize eviction", () => {
-		const g = collection<number>("mem", { maxSize: 2, score: (v) => v });
-		g.addDisposer(keepalive(g.ranked));
-		g.upsert("x", 1);
-		g.upsert("y", 5);
-		g.upsert("z", 3);
-		const ranked = g.ranked.cache as readonly RankedCollectionEntry<number>[];
-		expect(ranked.length).toBe(2);
-		// Lowest score (`x:1`) evicted; remaining sorted by score desc.
-		expect(ranked.map((r) => r.id)).toEqual(["y", "z"]);
-		expect(ranked[0]!.score).toBeGreaterThanOrEqual(ranked[1]!.score);
-	});
-
-	it("itemNode reactively returns the entry by id", () => {
-		const g = collection<number>("mem", { score: (v) => v });
-		const idN = node([], { initial: "a" });
-		const itemN = g.itemNode(idN);
-		itemN.subscribe(() => undefined);
-		g.upsert("a", 4);
-		const entry = itemN.cache as CollectionEntry<number> | undefined;
-		expect(entry?.value).toBe(4);
-		expect(entry?.baseScore).toBe(4);
-	});
-
-	it("rescore re-applies the latest score fn to existing entries", () => {
-		const scoreFnNode = node<(v: number) => number>([], { initial: (v: number) => v });
-		const g = collection<number>("mem", { score: scoreFnNode });
-		g.addDisposer(keepalive(g.ranked));
-		g.upsert("a", 2);
-		g.upsert("b", 5);
-		// Initial baseScores are 2 and 5; ranked has b first.
-		const before = g.ranked.cache as readonly RankedCollectionEntry<number>[];
-		expect(before.map((r) => r.id)).toEqual(["b", "a"]);
-		// Flip to a different scorer that inverts the ranking but stays
-		// above `minScore: 0` so decay's floor doesn't collapse both to 0
-		// (smaller raw value = higher new score).
-		scoreFnNode.emit((v) => 100 - v);
-		// `ranked` re-derives because scoreFnNode is a dep, but baseScore on
-		// entries is still 2 / 5 → ranking unchanged until rescore.
-		const stillBefore = g.ranked.cache as readonly RankedCollectionEntry<number>[];
-		expect(stillBefore.map((r) => r.id)).toEqual(["b", "a"]);
-		g.rescore();
-		const after = g.ranked.cache as readonly RankedCollectionEntry<number>[];
-		expect(after.map((r) => r.id)).toEqual(["a", "b"]);
-		expect(after.find((r) => r.id === "a")?.baseScore).toBe(98);
-		expect(after.find((r) => r.id === "b")?.baseScore).toBe(95);
-	});
-
-	it("events log records upsert / remove / clear / rescore with seq cursor", () => {
-		const g = collection<number>("mem", { score: (v) => v });
-		g.events.entries.subscribe(() => undefined);
-		g.upsert("a", 1);
-		g.upsert("b", 2);
-		g.remove("a");
-		g.rescore();
-		g.clear();
-		const records = g.events.entries.cache!;
-		expect(records.map((r) => r.action)).toEqual([
-			"upsert",
-			"upsert",
-			"remove",
-			"rescore",
-			"clear",
-		]);
-		// seq is monotonic
-		const seqs = records.map((r) => r.seq).filter((s): s is number => s != null);
-		for (let i = 1; i < seqs.length; i += 1) expect(seqs[i]!).toBeGreaterThan(seqs[i - 1]!);
-	});
-
-	it("decay-driven ranked re-derives on the refresh tick (without upsert)", async () => {
-		vi.useFakeTimers();
-		try {
-			const g = collection<number>("mem", {
-				score: (v) => v,
-				decayRate: 1,
-				refreshIntervalMs: 50,
-			});
-			g.addDisposer(keepalive(g.ranked));
-			g.upsert("a", 100);
-			const initialScore = (g.ranked.cache as readonly RankedCollectionEntry<number>[])[0]!.score;
-			// Advance well past one refresh interval — a tick should fire and
-			// `ranked` re-derives with a smaller decayed score even though no
-			// upsert occurred.
-			await vi.advanceTimersByTimeAsync(2_000);
-			const laterScore = (g.ranked.cache as readonly RankedCollectionEntry<number>[])[0]!.score;
-			expect(laterScore).toBeLessThan(initialScore);
-		} finally {
-			vi.useRealTimers();
-		}
-	});
-});
-
-describe("patterns.memory.vectorIndex", () => {
-	it("searchNode reactively returns top-K cosine matches", () => {
-		const idx = vectorIndex<{ label: string }>({
-			backend: "flat",
-			dimension: 2,
-		});
-		idx.upsert("a", [1, 0], { label: "x-axis" });
-		idx.upsert("b", [0, 1], { label: "y-axis" });
-		const query = node<readonly number[]>([], { initial: [0.9, 0.1] });
-		const results = idx.searchNode(query, 1);
-		results.subscribe(() => undefined);
-		const out = results.cache as readonly VectorSearchResult<{ label: string }>[];
-		expect(out[0]?.id).toBe("a");
-		expect(out[0]?.meta?.label).toBe("x-axis");
-	});
-
-	it("searchNode re-derives when entries change", () => {
-		const idx = vectorIndex<{ label: string }>({ backend: "flat", dimension: 2 });
-		const query = node<readonly number[]>([], { initial: [1, 0] });
-		const results = idx.searchNode(query, 5);
-		results.subscribe(() => undefined);
-		idx.upsert("a", [1, 0], { label: "x" });
-		expect((results.cache as readonly VectorSearchResult<{ label: string }>[]).length).toBe(1);
-		idx.upsert("b", [0.5, 0.5], { label: "diag" });
-		expect((results.cache as readonly VectorSearchResult<{ label: string }>[]).length).toBe(2);
-	});
-
-	it("requires optional hnsw adapter when backend is hnsw", () => {
-		expect(() => vectorIndex({ backend: "hnsw" })).toThrow(/optional dependency adapter/i);
-	});
-
-	it("strictDimension default throws on mixed-length upserts", () => {
-		const idx = vectorIndex<{ label: string }>({ backend: "flat" });
-		idx.upsert("a", [1, 0], { label: "two" });
-		expect(() => idx.upsert("b", [1, 0, 0], { label: "three" })).toThrow(/dimension/i);
-	});
-
-	it("strictDimension: false opts into zero-pad search behavior", () => {
-		const idx = vectorIndex<{ label: string }>({
-			backend: "flat",
-			strictDimension: false,
-		});
-		idx.upsert("long", [1, 0, 0, 1], { label: "four" });
-		const query = node<readonly number[]>([], { initial: [1, 0] });
-		const results = idx.searchNode(query, 1);
-		results.subscribe(() => undefined);
-		const out = results.cache as readonly VectorSearchResult<{ label: string }>[];
-		expect(out[0]?.score).toBeCloseTo(1 / Math.SQRT2, 5);
-	});
-
-	it("maxSize retention evicts oldest upsert and notifies HNSW adapter", () => {
-		const removed: string[] = [];
-		const adapter: HnswAdapter<{ label: string }> = {
-			upsert: vi.fn(),
-			remove: (id) => removed.push(id),
-			clear: vi.fn(),
-			search: vi.fn(),
-		};
-		const idx = vectorIndex<{ label: string }>({
-			backend: "hnsw",
-			dimension: 2,
-			maxSize: 2,
-			hnswFactory: () => adapter,
-		});
-		idx.upsert("a", [1, 0], { label: "x" });
-		idx.upsert("b", [0, 1], { label: "y" });
-		idx.upsert("c", [0.5, 0.5], { label: "z" }); // evicts "a"
-		expect(removed).toContain("a");
-	});
-
-	it("reindex re-pushes every live entry to the HNSW adapter", () => {
-		const upsertSpy = vi.fn();
-		const adapter: HnswAdapter<{ label: string }> = {
-			upsert: upsertSpy,
-			remove: vi.fn(),
-			clear: vi.fn(),
-			search: vi.fn(),
-		};
-		const idx = vectorIndex<{ label: string }>({
-			backend: "hnsw",
-			dimension: 2,
-			hnswFactory: () => adapter,
-		});
-		idx.upsert("a", [1, 0]);
-		idx.upsert("b", [0, 1]);
-		upsertSpy.mockClear();
-		idx.reindex();
-		expect(upsertSpy).toHaveBeenCalledTimes(2);
-	});
-
-	it("adapter dispose runs on graph teardown", () => {
-		const dispose = vi.fn();
-		const adapter: HnswAdapter<unknown> = {
-			upsert: vi.fn(),
-			remove: vi.fn(),
-			clear: vi.fn(),
-			search: vi.fn(),
-			dispose,
-		};
-		const idx = vectorIndex<unknown>({
-			backend: "hnsw",
-			dimension: 2,
-			hnswFactory: () => adapter,
-		});
-		idx.destroy();
-		expect(dispose).toHaveBeenCalledOnce();
-	});
-
-	it("events log records every mutation", () => {
-		const idx = vectorIndex<{ label: string }>({ backend: "flat", dimension: 2 });
-		idx.events.entries.subscribe(() => undefined);
-		idx.upsert("a", [1, 0]);
-		idx.remove("a");
-		idx.clear();
-		const records = idx.events.entries.cache as readonly VectorIndexAuditRecord[];
-		expect(records.map((r) => r.action)).toEqual(["upsert", "remove", "clear"]);
-	});
-});
-
-describe("patterns.memory.knowledgeGraph", () => {
-	it("link / unlink update edges by triple key", () => {
-		const kg = knowledgeGraph<{ name: string }>("kg");
-		kg.upsertEntity("a", { name: "A" });
-		kg.upsertEntity("b", { name: "B" });
-		kg.link("a", "b", "knows", 1);
-		expect(kg.node("edgeCount").cache).toBe(1);
-		kg.link("a", "b", "knows", 5); // replace weight
-		expect(kg.node("edgeCount").cache).toBe(1);
-		const edges = kg.edges.cache as ReadonlyMap<string, KnowledgeEdge>;
-		const onlyEdge = [...edges.values()][0]!;
-		expect(onlyEdge.weight).toBe(5);
-		kg.unlink("a", "b", "knows");
-		expect(kg.node("edgeCount").cache).toBe(0);
-	});
-
-	it("relatedNode returns inbound and outbound edges (symmetric)", () => {
-		const kg = knowledgeGraph<{ name: string }>("kg");
-		kg.upsertEntity("a", { name: "A" });
-		kg.upsertEntity("b", { name: "B" });
-		kg.upsertEntity("c", { name: "C" });
-		kg.link("a", "b", "knows");
-		kg.link("c", "b", "knows");
-		const idN = node([], { initial: "b" });
-		const related = kg.relatedNode(idN);
-		related.subscribe(() => undefined);
-		const edges = related.cache as readonly KnowledgeEdge[];
-		expect(edges.length).toBe(2);
-		const fromIds = edges.map((e) => e.from).sort();
-		expect(fromIds).toEqual(["a", "c"]);
-	});
-
-	it("relatedNode filters by relation when supplied; switching the relation node re-derives", () => {
-		const kg = knowledgeGraph<{ name: string }, "knows" | "owes">("kg");
-		kg.link("a", "b", "knows");
-		kg.link("a", "b", "owes");
-		const idN = node([], { initial: "a" });
-		const relN = node<"knows" | "owes">([], { initial: "knows" });
-		const filtered = kg.relatedNode(idN, relN);
-		filtered.subscribe(() => undefined);
-		expect((filtered.cache as readonly KnowledgeEdge[]).length).toBe(1);
-		relN.emit("owes");
-		expect((filtered.cache as readonly KnowledgeEdge[]).length).toBe(1);
-		expect((filtered.cache as readonly KnowledgeEdge[])[0]?.relation).toBe("owes");
-		// Omitting the relation arg disables filtering — separate call site.
-		const all = kg.relatedNode(idN);
-		all.subscribe(() => undefined);
-		expect((all.cache as readonly KnowledgeEdge[]).length).toBe(2);
-	});
-
-	it("removeEntity cascades to all involving edges", () => {
-		const kg = knowledgeGraph<{ name: string }>("kg");
-		kg.upsertEntity("a", { name: "A" });
-		kg.upsertEntity("b", { name: "B" });
-		kg.upsertEntity("c", { name: "C" });
-		kg.link("a", "b", "knows");
-		kg.link("c", "a", "knows");
-		expect(kg.node("edgeCount").cache).toBe(2);
-		kg.removeEntity("a");
-		expect(kg.node("edgeCount").cache).toBe(0);
-		expect(kg.node("entityCount").cache).toBe(2);
-	});
-
-	it("orphanGC: 'remove' deletes entities after their last edge unlinks", () => {
-		const kg = knowledgeGraph<{ name: string }>("kg", { orphanGC: "remove" });
-		kg.upsertEntity("a", { name: "A" });
-		kg.upsertEntity("b", { name: "B" });
-		kg.link("a", "b", "knows");
-		kg.unlink("a", "b", "knows");
-		expect(kg.node("entityCount").cache).toBe(0);
-	});
-
-	it("entityCount and edgeCount keep keepalive without external subscriber", () => {
-		const kg = knowledgeGraph<{ name: string }>("kg");
-		kg.upsertEntity("a", { name: "A" });
-		kg.link("a", "a", "self");
-		expect(kg.node("entityCount").cache).toBe(1);
-		expect(kg.node("edgeCount").cache).toBe(1);
-	});
-
-	it("events log records every mutation", () => {
-		const kg = knowledgeGraph<{ name: string }>("kg");
-		kg.events.entries.subscribe(() => undefined);
-		kg.upsertEntity("a", { name: "A" });
-		kg.link("a", "a", "self");
-		kg.unlink("a", "a", "self");
-		kg.removeEntity("a");
-		const actions = kg.events.entries.cache!.map((r) => r.action);
-		expect(actions).toEqual(["upsertEntity", "link", "unlink", "removeEntity"]);
-	});
-});
diff --git a/src/__tests__/utils/memory/recipes.test.ts b/src/__tests__/utils/memory/recipes.test.ts
deleted file mode 100644
index 7c8df132..00000000
--- a/src/__tests__/utils/memory/recipes.test.ts
+++ /dev/null
@@ -1,381 +0,0 @@
-/**
- * DS-14.7 follow-up #1 — recipe library tests.
- *
- * Each recipe is a shipped composition over a `reactiveFactStore` extension
- * face; tests assert the composed behavior end-to-end (inspection-as-test:
- * drive `ingest`, read `itemNode`/outputs synchronously, fake-timer the two
- * timer-driven recipes).
- */
-
-import { batch, DATA, monotonicNs, node, wallClockNs } from "@graphrefly/pure-ts/core";
-import { afterEach, describe, expect, it, vi } from "vitest";
-import {
-	admissionLlmJudge,
-	bitemporalQuery,
-	consolidationRem,
-	decayExponential,
-	type FactId,
-	influenceAnalysis,
-	invalidationTracer,
-	type MemoryFragment,
-	type OutcomeSignal,
-	reactiveFactStore,
-	type StoreReadHandle,
-	scoringByOutcome,
-	shardByTenant,
-} from "../../../utils/memory/index.js";
-
-function frag<T>(id: string, payload: T, opts: Partial<MemoryFragment<T>> = {}): MemoryFragment<T> {
-	return {
-		id,
-		payload,
-		t_ns: BigInt(monotonicNs()),
-		confidence: opts.confidence ?? 1,
-		tags: opts.tags ?? [],
-		sources: opts.sources ?? [],
-		...opts,
-	};
-}
-function ingestNode<T>() {
-	return node<MemoryFragment<T>>([], { initial: undefined });
-}
-function readHandleOf<T>(frags: readonly MemoryFragment<T>[]): StoreReadHandle<T> {
-	const m = new Map(frags.map((f) => [f.id, f] as const));
-	return { get: (id) => m.get(id), has: (id) => m.has(id), size: m.size, values: () => m.values() };
-}
-
-afterEach(() => vi.useRealTimers());
-
-// ── scoring-by-outcome ───────────────────────────────────────────────────
-describe("recipes.scoringByOutcome", () => {
-	it("feeds an outcome signal back into the applied scoring policy (continual learning)", () => {
-		const ingest = ingestNode<string>();
-		const outcomes = node<OutcomeSignal>([], { initial: undefined });
-		const mem = reactiveFactStore<string>({
-			ingest,
-			extractDependencies: (f) => f.sources,
-			outcome: outcomes,
-			scoring: scoringByOutcome<string>(outcomes, { base: () => 0.5 }),
-		});
-		const it0 = mem.itemNode("x");
-		it0.subscribe(() => undefined);
-		ingest.emit(frag("x", "X", { confidence: 0.5 }));
-		outcomes.emit({ factId: "x", reward: 0.3 });
-		expect((it0.cache as MemoryFragment<string>).confidence).toBeCloseTo(0.8, 6);
-		// Cumulative + clamped at 1.
-		outcomes.emit({ factId: "x", reward: 0.9 });
-		expect((it0.cache as MemoryFragment<string>).confidence).toBe(1);
-		mem.destroy();
-	});
-
-	it("accumulates EVERY signal in a batched wave (full-wave fold, not last-only)", () => {
-		const ingest = ingestNode<string>();
-		const outcomes = node<OutcomeSignal>([], { initial: undefined });
-		const mem = reactiveFactStore<string>({
-			ingest,
-			extractDependencies: (f) => f.sources,
-			outcome: outcomes,
-			scoring: scoringByOutcome<string>(outcomes, { base: () => 0 }),
-		});
-		const it0 = mem.itemNode("x");
-		it0.subscribe(() => undefined);
-		ingest.emit(frag("x", "X", { confidence: 0 }));
-		// Two signals for the same id IN ONE WAVE — a last-only fold would drop
-		// the first (0.4); the contract folds both ⇒ 0.4 + 0.5 = 0.9.
-		batch(() => {
-			outcomes.emit({ factId: "x", reward: 0.4 });
-			outcomes.emit({ factId: "x", reward: 0.5 });
-		});
-		expect((it0.cache as MemoryFragment<string>).confidence).toBeCloseTo(0.9, 6);
-		mem.destroy();
-	});
-});
-
-// ── decay-exponential ────────────────────────────────────────────────────
-describe("recipes.decayExponential", () => {
-	it("drifts live confidence to the floor on the timer, leaves obsolete facts, then quiesces", () => {
-		vi.useFakeTimers();
-		const ingest = ingestNode<string>();
-		const mem = reactiveFactStore<string>({ ingest, extractDependencies: (f) => f.sources });
-		const driver = decayExponential<string>(mem, ingest, {
-			halfLifeNs: 1n,
-			periodMs: 100,
-			floor: 0.1,
-		});
-		const batches: (readonly MemoryFragment<string>[])[] = [];
-		driver.subscribe((msgs) => {
-			for (const m of msgs)
-				if (m[0] === DATA) batches.push(m[1] as readonly MemoryFragment<string>[]);
-		});
-		const live = mem.itemNode("live");
-		const dead = mem.itemNode("dead");
-		live.subscribe(() => undefined);
-		dead.subscribe(() => undefined);
-		// t_ns 0 ⇒ astronomically old ⇒ one pass collapses it to the floor.
-		ingest.emit(frag("live", "L", { confidence: 1, t_ns: 0n }));
-		ingest.emit(frag("dead", "D", { confidence: 0.9, t_ns: 0n, validTo: 5n }));
-
-		vi.advanceTimersByTime(100); // first forgetting pass
-		expect((live.cache as MemoryFragment<string>).confidence).toBe(0.1);
-		expect((dead.cache as MemoryFragment<string>).confidence).toBe(0.9); // obsolete untouched
-		const lastBatch = batches.at(-1) ?? [];
-		expect(lastBatch.map((f) => f.id)).toEqual(["live"]);
-
-		vi.advanceTimersByTime(100); // already at floor ⇒ no churn
-		expect(batches.at(-1)).toEqual([]);
-		mem.destroy();
-	});
-
-	it("quiesces via epsilon (floor=0, never reached) — drift below epsilon stops re-ingest", () => {
-		vi.useFakeTimers();
-		const ingest = ingestNode<string>();
-		const mem = reactiveFactStore<string>({ ingest, extractDependencies: (f) => f.sources });
-		// half-life == period ⇒ confidence halves each tick; floor 0 is never
-		// reached exactly, so quiescence must come from epsilon.
-		const periodNs = 100n * 1_000_000n;
-		const driver = decayExponential<string>(mem, ingest, {
-			halfLifeNs: periodNs,
-			periodMs: 100,
-			floor: 0,
-		});
-		const batches: (readonly MemoryFragment<string>[])[] = [];
-		driver.subscribe((msgs) => {
-			for (const m of msgs)
-				if (m[0] === DATA) batches.push(m[1] as readonly MemoryFragment<string>[]);
-		});
-		const f = mem.itemNode("f");
-		f.subscribe(() => undefined);
-		// t_ns = the (frozen) fake-clock now ⇒ first-tick elapsed == one period.
-		ingest.emit(frag("f", "F", { confidence: 1, t_ns: BigInt(wallClockNs()) }));
-		let quiescedAt = -1;
-		for (let i = 1; i <= 30 && quiescedAt < 0; i += 1) {
-			vi.advanceTimersByTime(100);
-			if ((batches.at(-1) ?? []).length === 0) quiescedAt = i;
-		}
-		expect(quiescedAt).toBeGreaterThan(1); // took several halvings, not instant
-		const conf = (f.cache as MemoryFragment<string>).confidence;
-		expect(conf).toBeGreaterThan(0); // quiesced by epsilon, NOT by hitting floor 0
-		expect(conf).toBeLessThan(0.01);
-		mem.destroy();
-	});
-});
-
-// ── consolidation-rem ────────────────────────────────────────────────────
-describe("recipes.consolidationRem", () => {
-	it("consolidate() replays top-K recent live facts through summarize", () => {
-		const { consolidate, consolidateTrigger } = consolidationRem<string>({
-			periodMs: 1000,
-			topK: 2,
-			summarize: (replayed) => [
-				frag("summary", replayed.map((f) => f.payload).join("+"), {
-					parent_fragment_id: replayed[0]!.id,
-				}),
-			],
-		});
-		expect(consolidateTrigger).toBeTruthy();
-		const out = consolidate(
-			readHandleOf<string>([
-				frag("a", "A", { confidence: 0.9 }),
-				frag("b", "B", { confidence: 0.7 }),
-				frag("c", "C", { confidence: 0.3 }),
-				frag("z", "Z", { confidence: 1, validTo: 9n }), // obsolete ⇒ excluded
-			]),
-		);
-		expect(out).toHaveLength(1);
-		expect(out[0]!.payload).toBe("A+B"); // top-2 by confidence, obsolete dropped
-		expect(out[0]!.parent_fragment_id).toBe("a");
-	});
-
-	it("recentWindowNs gates the pool to facts within the window of the newest", () => {
-		const { consolidate } = consolidationRem<string>({
-			periodMs: 1000,
-			topK: 5,
-			recentWindowNs: 100n,
-			summarize: (replayed) => [frag("s", replayed.map((f) => f.id).join(","))],
-		});
-		const out = consolidate(
-			readHandleOf<string>([
-				frag("new", "N", { confidence: 0.5, t_ns: 1000n }), // newest
-				frag("edge", "E", { confidence: 0.5, t_ns: 900n }), // exactly at cutoff (>=)
-				frag("old", "O", { confidence: 1, t_ns: 800n }), // outside window — excluded
-			]),
-		);
-		expect(out).toHaveLength(1);
-		// `old` has the highest confidence but is filtered out by the window.
-		expect(out[0]!.payload).toBe("new,edge");
-	});
-
-	it("wires successor fragments back into the store on the cron tick", () => {
-		vi.useFakeTimers();
-		const ingest = ingestNode<string>();
-		const mem = reactiveFactStore<string>({
-			ingest,
-			extractDependencies: (f) => f.sources,
-			...consolidationRem<string>({
-				periodMs: 50,
-				topK: 5,
-				summarize: (r) => [frag("digest", `n=${r.length}`)],
-			}),
-		});
-		const digest = mem.itemNode("digest");
-		digest.subscribe(() => undefined);
-		ingest.emit(frag("f1", "one"));
-		ingest.emit(frag("f2", "two"));
-		vi.advanceTimersByTime(50);
-		expect((digest.cache as MemoryFragment<string>).payload).toBe("n=2");
-		mem.destroy();
-	});
-});
-
-// ── admission-llm-judge ──────────────────────────────────────────────────
-describe("recipes.admissionLlmJudge", () => {
-	it("deny-by-default until a verdict admits the fragment", () => {
-		const ingest = ingestNode<string>();
-		const verdicts = node<ReadonlyMap<FactId, boolean>>([], { initial: undefined });
-		const mem = reactiveFactStore<string>({
-			ingest,
-			extractDependencies: (f) => f.sources,
-			admissionFilter: admissionLlmJudge<string>(verdicts),
-		});
-		const a = mem.itemNode("a");
-		a.subscribe(() => undefined);
-		ingest.emit(frag("a", "A")); // no verdict ⇒ rejected
-		expect(a.cache).toBeUndefined();
-		verdicts.emit(new Map([["a", true]]));
-		ingest.emit(frag("a", "A")); // now admitted
-		expect((a.cache as MemoryFragment<string>).payload).toBe("A");
-		mem.destroy();
-	});
-});
-
-// ── shard-by-tenant ──────────────────────────────────────────────────────
-describe("recipes.shardByTenant", () => {
-	it("strict mode isolates each tenant in its own shard (+ overflow)", () => {
-		const cfg = shardByTenant<{ t: string }>((f) => f.payload.t, {
-			tenants: ["acme", "globex"],
-		});
-		expect(cfg.shardCount).toBe(3);
-		expect(cfg.shardBy(frag("1", { t: "acme" }))).toBe(0);
-		expect(cfg.shardBy(frag("2", { t: "globex" }))).toBe(1);
-		expect(cfg.shardBy(frag("3", { t: "other" }))).toBe(2); // overflow
-
-		const ingest = ingestNode<{ t: string }>();
-		const mem = reactiveFactStore<{ t: string }>({
-			ingest,
-			extractDependencies: (f) => f.sources,
-			...cfg,
-		});
-		mem.factStore.subscribe(() => undefined);
-		ingest.emit(frag("a1", { t: "acme" }));
-		ingest.emit(frag("g1", { t: "globex" }));
-		const shard0 = mem.shards[0]!.cache as { byId: ReadonlyMap<string, unknown> };
-		const shard1 = mem.shards[1]!.cache as { byId: ReadonlyMap<string, unknown> };
-		expect(shard0.byId.has("a1")).toBe(true);
-		expect(shard1.byId.has("g1")).toBe(true);
-		expect(shard0.byId.has("g1")).toBe(false);
-		mem.destroy();
-	});
-
-	it("soft mode hashes the tenant key into shardCount buckets", () => {
-		const cfg = shardByTenant<{ t: string }>((f) => f.payload.t, { shardCount: 4 });
-		expect(cfg.shardCount).toBe(4);
-		expect(cfg.shardBy(frag("1", { t: "acme" }))).toBe("acme");
-	});
-});
-
-// ── invalidation-tracer ──────────────────────────────────────────────────
-describe("recipes.invalidationTracer", () => {
-	it("accumulates causal trace entries for cascade events", () => {
-		const ingest = ingestNode<string>();
-		const mem = reactiveFactStore<string>({ ingest, extractDependencies: (f) => f.sources });
-		const trace = invalidationTracer(mem, { limit: 16 });
-		trace.subscribe(() => undefined);
-		ingest.emit(frag("home", "Beijing"));
-		ingest.emit(frag("commute", "bike", { sources: ["home"] }));
-		ingest.emit(frag("home", "Shanghai", { validTo: BigInt(monotonicNs()) }));
-		const entries = trace.cache as readonly { factId: string; causalReason: string }[];
-		const hit = entries.find((e) => e.factId === "commute");
-		expect(hit).toBeTruthy();
-		expect(hit!.causalReason).toContain("dependentsIndex");
-		mem.destroy();
-	});
-
-	it("records the cascade-overflow branch", () => {
-		const ingest = ingestNode<string>();
-		// cascadeMaxIterations:1 + a 3-deep chain ⇒ the b→c step overflows.
-		const mem = reactiveFactStore<string>({
-			ingest,
-			extractDependencies: (f) => f.sources,
-			cascadeMaxIterations: 1,
-		});
-		const trace = invalidationTracer(mem, { limit: 16 });
-		trace.subscribe(() => undefined);
-		mem.cascadeOverflow.subscribe(() => undefined);
-		ingest.emit(frag("a", "A"));
-		ingest.emit(frag("b", "B", { sources: ["a"] }));
-		ingest.emit(frag("c", "C", { sources: ["b"] }));
-		ingest.emit(frag("a", "A2", { validTo: BigInt(monotonicNs()) }));
-		const entries = trace.cache as readonly { kind: string; causalReason: string }[];
-		const ov = entries.find((e) => e.kind === "overflow");
-		expect(ov).toBeTruthy();
-		expect(ov!.causalReason).toContain("overflow");
-		mem.destroy();
-	});
-});
-
-// ── bitemporal-query ─────────────────────────────────────────────────────
-describe("recipes.bitemporalQuery", () => {
-	it("SENTINEL asOf ⇒ currently-valid; explicit asOf ⇒ historical window", () => {
-		const ingest = ingestNode<string>();
-		const asOf = node<bigint>([], { initial: undefined });
-		const mem = reactiveFactStore<string>({ ingest, extractDependencies: (f) => f.sources });
-		const view = bitemporalQuery(mem, asOf);
-		view.subscribe(() => undefined);
-		ingest.emit(frag("live", "L", { validFrom: 10n }));
-		ingest.emit(frag("old", "O", { validFrom: 1n, validTo: 5n }));
-		// No asOf yet ⇒ currently-valid only (validTo unset).
-		expect((view.cache as readonly MemoryFragment<string>[]).map((f) => f.id)).toEqual(["live"]);
-		// As of t=3 ⇒ only `old` was valid then.
-		asOf.emit(3n);
-		expect((view.cache as readonly MemoryFragment<string>[]).map((f) => f.id)).toEqual(["old"]);
-		mem.destroy();
-	});
-});
-
-// ── influence-analysis ───────────────────────────────────────────────────
-describe("recipes.influenceAnalysis", () => {
-	it("exposes the transitive dependent closure and influence ranking", () => {
-		const ingest = ingestNode<string>();
-		const mem = reactiveFactStore<string>({ ingest, extractDependencies: (f) => f.sources });
-		const inf = influenceAnalysis(mem, { maxRanked: 8 });
-		inf.ranked.subscribe(() => undefined);
-		const ofA = inf.influenceOf("a");
-		ofA.subscribe(() => undefined);
-		ingest.emit(frag("a", "A"));
-		ingest.emit(frag("b", "B", { sources: ["a"] }));
-		ingest.emit(frag("c", "C", { sources: ["b"] }));
-		expect([...(ofA.cache as readonly string[])].sort()).toEqual(["b", "c"]);
-		const ranked = inf.ranked.cache as readonly { factId: string; influence: number }[];
-		expect(ranked.find((r) => r.factId === "a")?.influence).toBe(2);
-		expect(ranked.find((r) => r.factId === "b")?.influence).toBe(1);
-		// `c` is a leaf — no dependents, absent from the index keys.
-		expect(ranked.find((r) => r.factId === "c")).toBeUndefined();
-		mem.destroy();
-	});
-
-	it("influenceOf is idempotent on repeat call with the same id (no graph.add collision)", () => {
-		const ingest = ingestNode<string>();
-		const mem = reactiveFactStore<string>({ ingest, extractDependencies: (f) => f.sources });
-		const inf = influenceAnalysis(mem);
-		const first = inf.influenceOf("home");
-		// Documented usage calls this again for the same root — must NOT throw
-		// (Graph.add rejects duplicate names) and must return the SAME node.
-		const second = inf.influenceOf("home");
-		expect(second).toBe(first);
-		first.subscribe(() => undefined);
-		ingest.emit(frag("home", "H"));
-		ingest.emit(frag("commute", "C", { sources: ["home"] }));
-		expect([...(first.cache as readonly string[])]).toEqual(["commute"]);
-		mem.destroy();
-	});
-});
diff --git a/src/__tests__/utils/messaging/messaging.test.ts b/src/__tests__/utils/messaging/messaging.test.ts
deleted file mode 100644
index 4b4e9bbd..00000000
--- a/src/__tests__/utils/messaging/messaging.test.ts
+++ /dev/null
@@ -1,1130 +0,0 @@
-import { DATA, node } from "@graphrefly/pure-ts/core";
-import { reactiveLog } from "@graphrefly/pure-ts/extra";
-import { describe, expect, it } from "vitest";
-
-import { createAuditLog, mutate } from "../../../base/mutation/index.js";
-import { type JobEvent, jobFlow, jobQueue } from "../../../utils/job-queue/index.js";
-import {
-	CONTEXT_TOPIC,
-	DEFERRED_TOPIC,
-	type DeadLetterEntry,
-	type HubRemoveTopicRecord,
-	hubRemoveTopicKeyOf,
-	INJECTIONS_TOPIC,
-	logProjector,
-	type Message,
-	type MessagingAuditRecord,
-	messagingHub,
-	PROMPTS_TOPIC,
-	RESPONSES_TOPIC,
-	SPAWNS_TOPIC,
-	STANDARD_TOPICS,
-	type StandardTopic,
-	type SubscriptionAckRecord,
-	type SubscriptionPullAndAckRecord,
-	subscription,
-	subscriptionAckKeyOf,
-	subscriptionPullAndAckKeyOf,
-	TODOS_TOPIC,
-	type TopicPublishRecord,
-	topic,
-	topicBridge,
-	topicPublishKeyOf,
-} from "../../../utils/messaging/index.js";
-
-describe("patterns.messaging", () => {
-	it("topic retains events and updates latest value", () => {
-		const t = topic<number>("events");
-		t.publish(1);
-		t.publish(2);
-		expect(t.node("latest").cache).toBe(2);
-		expect(t.retained()).toEqual([1, 2]);
-	});
-
-	it("subscription tracks cursor and acknowledges consumed values", () => {
-		const t = topic<number>("events");
-		t.publish(10);
-		t.publish(20);
-		const sub = subscription("sub", t);
-		expect(sub.pull()).toEqual([10, 20]);
-		sub.ack(1);
-		expect(sub.pull()).toEqual([20]);
-		// B.1 Unit 12 lock: pullAndAck replaces pull({ ack: true }). Returns { items, cursor }.
-		const result = sub.pullAndAck();
-		expect(result.items).toEqual([20]);
-		expect(sub.pull()).toEqual([]);
-		// D1(e): topic is NOT mounted under the subscription — the "topic::events"
-		// edge no longer exists; verify via the externalized `sub.topic` reference
-		// instead (data dependency lives at the node layer via derived-deps).
-		expect(sub.topic).toBe(t);
-		// B.1 Unit 12 lock: `source` passthrough removed — available depends directly
-		// on topic.events + cursor (cross-graph edge). No "source" node in sub graph.
-		expect(sub.edges()).not.toContainEqual(["source", "available"]);
-	});
-
-	it("jobQueue supports enqueue, claim, ack, and nack requeue", () => {
-		const q = jobQueue<number>("emails");
-		const id1 = q.enqueue(1);
-		const id2 = q.enqueue(2);
-		expect(q.node("depth").cache).toBe(2);
-		const claimed = q.claim(2);
-		expect(claimed.map((j) => j.id)).toEqual([id1, id2]);
-		expect(claimed.every((j) => j.state === "inflight")).toBe(true);
-		expect(q.ack(id1)).toBe(true);
-		expect(q.nack(id2, { requeue: true })).toBe(true);
-		const second = q.claim(1);
-		expect(second).toHaveLength(1);
-		expect(second[0]?.id).toBe(id2);
-	});
-
-	it("jobQueue supports nack without requeue (drop)", () => {
-		const q = jobQueue<number>("emails");
-		const id = q.enqueue(1);
-		const claimed = q.claim(1);
-		expect(claimed).toHaveLength(1);
-		expect(claimed[0]?.id).toBe(id);
-		expect(q.nack(id, { requeue: false })).toBe(true);
-		expect(q.claim(1)).toEqual([]);
-	});
-
-	it("F-CATCH D-3: no-requeue nack records the failure cause on the JobEvent", () => {
-		const q = jobQueue<number>("emails");
-		const unsub = q.events.entries.subscribe(() => undefined);
-		const id = q.enqueue(1);
-		q.claim(1);
-		const cause = new Error("handler exploded");
-		expect(q.nack(id, { requeue: false, error: cause })).toBe(true);
-		const events = q.events.entries.cache as readonly JobEvent<number>[];
-		const nackEvt = events.find((e) => e.action === "nack");
-		expect(nackEvt).toBeDefined();
-		expect(nackEvt!.error).toBe(cause);
-		unsub();
-	});
-
-	it("F-CATCH D-3: a requeue nack carries NO error (retry is not a failure)", () => {
-		const q = jobQueue<number>("emails");
-		const unsub = q.events.entries.subscribe(() => undefined);
-		const id = q.enqueue(1);
-		q.claim(1);
-		// An error passed alongside requeue:true must be ignored — a retry is
-		// not a terminal failure, so the nack event stays error-free.
-		q.nack(id, { requeue: true, error: new Error("should be ignored") });
-		const events = q.events.entries.cache as readonly JobEvent<number>[];
-		const nackEvt = events.find((e) => e.action === "nack");
-		expect(nackEvt).toBeDefined();
-		expect("error" in nackEvt!).toBe(false);
-		unsub();
-	});
-
-	it("F-CATCH D-3: jobFlow sync-throw work nack carries the thrown error (:622)", async () => {
-		const flow = jobFlow<number>("flow-throw", {
-			stages: [
-				{
-					name: "a",
-					work: () => {
-						throw new Error("sync-boom");
-					},
-				},
-				"b",
-			],
-		});
-		const stageA = flow.queue("a");
-		const unsub = stageA.events.entries.subscribe(() => undefined);
-		flow.enqueue(1);
-		// Deterministic settle: drain microtask turns (bounded) until the nack
-		// event lands — no wall-clock sleep (the result-Node ERROR path settles
-		// on a microtask via fromAny; the sync-throw path is immediate).
-		let nackEvt: JobEvent<number> | undefined;
-		for (let i = 0; i < 100 && nackEvt === undefined; i += 1) {
-			nackEvt = (stageA.events.entries.cache as readonly JobEvent<number>[]).find(
-				(e) => e.action === "nack",
-			);
-			if (nackEvt === undefined) await Promise.resolve();
-		}
-		expect(nackEvt).toBeDefined();
-		expect(nackEvt!.error).toBeInstanceOf(Error);
-		expect((nackEvt!.error as Error).message).toBe("sync-boom");
-		unsub();
-		flow.destroy();
-	});
-
-	it("F-CATCH D-3: jobFlow result-ERROR nack carries the ERROR payload (:688)", async () => {
-		const cause = new Error("async-boom");
-		const flow = jobFlow<number>("flow-reject", {
-			stages: [{ name: "a", work: () => Promise.reject(cause) }, "b"],
-		});
-		const stageA = flow.queue("a");
-		const unsub = stageA.events.entries.subscribe(() => undefined);
-		flow.enqueue(1);
-		// Deterministic settle (see :622 test) — bounded microtask drain.
-		let nackEvt: JobEvent<number> | undefined;
-		for (let i = 0; i < 100 && nackEvt === undefined; i += 1) {
-			nackEvt = (stageA.events.entries.cache as readonly JobEvent<number>[]).find(
-				(e) => e.action === "nack",
-			);
-			if (nackEvt === undefined) await Promise.resolve();
-		}
-		expect(nackEvt).toBeDefined();
-		expect(nackEvt!.error).toBe(cause);
-		unsub();
-		flow.destroy();
-	});
-
-	it("jobQueue rejects duplicate job ids", () => {
-		const q = jobQueue<number>("emails");
-		q.enqueue(1, { id: "fixed" });
-		expect(() => q.enqueue(2, { id: "fixed" })).toThrow(/duplicate job id/i);
-	});
-
-	it("jobQueue claim(0) is a no-op", () => {
-		const q = jobQueue<number>("emails");
-		q.enqueue(1);
-		expect(q.claim(0)).toEqual([]);
-		expect(q.node("depth").cache).toBe(1);
-	});
-
-	it("rejects invalid non-negative integer parameters", () => {
-		const t = topic<number>("events");
-		expect(() => subscription("sub_bad_cursor", t, { cursor: Number.NaN })).toThrow(
-			/non-negative integer/i,
-		);
-		const sub = subscription("sub_ok", t);
-		expect(() => sub.ack(Number.POSITIVE_INFINITY)).toThrow(/non-negative integer/i);
-		expect(() => sub.pull(-1)).toThrow(/non-negative integer/i);
-		const q = jobQueue<number>("emails");
-		expect(() => q.claim(-1)).toThrow(/non-negative integer/i);
-		expect(() => jobFlow<number>("flow_bad", { maxPerPump: Number.POSITIVE_INFINITY })).toThrow(
-			/non-negative integer/i,
-		);
-		expect(() =>
-			topicBridge<number>("bridge_bad", t, topic<number>("dst_bad"), { maxPerPump: -1 }),
-		).toThrow(/non-negative integer/i);
-	});
-
-	it("jobQueue metadata is immutable after enqueue", () => {
-		const q = jobQueue<number>("emails");
-		const input = { lane: "high" };
-		const id = q.enqueue(1, { metadata: input });
-		input.lane = "low";
-		const claimed = q.claim(1);
-		expect(claimed[0]?.id).toBe(id);
-		expect(claimed[0]?.metadata.lane).toBe("high");
-	});
-
-	it("topicBridge relays source events into target topic", () => {
-		const source = topic<number>("src");
-		const target = topic<number>("dst");
-		const bridge = topicBridge("bridge", source, target);
-		source.publish(3);
-		source.publish(4);
-		expect(target.retained()).toEqual([3, 4]);
-		expect(bridge.node("bridgedCount").cache).toBe(2);
-	});
-
-	it("topicBridge supports map/drop behavior", () => {
-		const source = topic<number>("src");
-		const target = topic<number>("dst");
-		topicBridge("bridge", source, target, {
-			map(value) {
-				if (value % 2 === 0) return undefined;
-				return value * 10;
-			},
-		});
-		source.publish(1);
-		source.publish(2);
-		source.publish(3);
-		expect(target.retained()).toEqual([10, 30]);
-	});
-
-	it("subscription from:'now' skips retained history", () => {
-		const t = topic<number>("events");
-		t.publish(1);
-		t.publish(2);
-		// from: "now" — cursor starts at current topic length
-		const sub = subscription("sub-now", t, { from: "now" });
-		expect(sub.pull()).toEqual([]);
-		t.publish(3);
-		expect(sub.pull()).toEqual([3]);
-	});
-
-	it("subscription from: number sets explicit cursor", () => {
-		const t = topic<number>("events");
-		t.publish(10);
-		t.publish(20);
-		t.publish(30);
-		const sub = subscription("sub-from1", t, { from: 1 });
-		expect(sub.pull()).toEqual([20, 30]);
-	});
-
-	it("subscription dispose() stops pullAndAck from returning items", () => {
-		const t = topic<number>("events");
-		t.publish(42);
-		const sub = subscription("sub-dispose", t);
-		expect(sub.pull()).toEqual([42]);
-		sub.dispose();
-		expect(sub.pullAndAck().items).toEqual([]);
-		expect(sub.pull()).toEqual([]);
-	});
-
-	it("subscription advanceOn auto-advances cursor on signal", () => {
-		const t = topic<number>("events");
-		t.publish(1);
-		t.publish(2);
-		t.publish(3);
-		// advanceOn: use a state node that starts with NO initial value trigger.
-		// We publish AFTER construction so the pump has no initial dep.
-		const sig = topic<boolean>("advance-signal");
-		const sub = subscription("sub-advance", t, { advanceOn: sig.events });
-		// All 3 items visible before signal fires (cursor is 0).
-		expect(sub.pull()).toHaveLength(3);
-		sig.publish(true); // trigger advance — cursor advances to 3
-		expect(sub.pull()).toEqual([]);
-	});
-
-	it("topicBridge output node is derived from available (reactive edge)", () => {
-		const source = topic<number>("src");
-		const target = topic<number>("dst");
-		const bridge = topicBridge("bridge", source, target, {
-			map: (v) => v * 2,
-		});
-		// Verify edge: output depends on subscription::available.
-		// Use recursive:true so cross-graph deps are qualified with subgraph prefix.
-		expect(bridge.edges({ recursive: true })).toContainEqual(["subscription::available", "output"]);
-		// Verify target gets bridged items.
-		source.publish(5);
-		expect(target.retained()).toEqual([10]);
-	});
-
-	it("jobFlow tracks job_flow_path across stages", () => {
-		const flow = jobFlow<number>("flow", { stages: ["a", "b", "c"] });
-		flow.enqueue(99);
-		const completed = flow.retainedCompleted();
-		expect(completed).toHaveLength(1);
-		const path = completed[0]?.metadata.job_flow_path as string[];
-		expect(path).toEqual(["a", "b", "c"]);
-	});
-
-	it("JobQueueGraph.consumeFrom wires an external source into the queue", () => {
-		const q = jobQueue<number>("q");
-		// Use node([], { initial: 7 }) which pushes DATA(7) on subscribe (that's expected behaviour).
-		// Count from initial subscribe + 1 more emit = depth of 2, then dispose.
-		const src = node<number>([], { initial: 7 });
-		const disposer = q.consumeFrom(src);
-		// After subscribe: depth = 1 (push-on-subscribe with initial 7).
-		src.emit(8);
-		expect(q.node("depth").cache).toBe(2);
-		disposer();
-		src.emit(9); // after dispose — should not enqueue
-		expect(q.node("depth").cache).toBe(2);
-	});
-
-	it("jobFlow auto-advances jobs across stages into completed log", () => {
-		const flow = jobFlow<number>("flow", { stages: ["incoming", "work", "done"] });
-		flow.enqueue(10);
-		flow.enqueue(20);
-		expect(flow.retainedCompleted().map((j) => j.payload)).toEqual([10, 20]);
-		expect(flow.node("completedCount").cache).toBe(2);
-		expect(flow.queue("incoming").node("depth").cache).toBe(0);
-		expect(flow.queue("work").node("depth").cache).toBe(0);
-		expect(flow.queue("done").node("depth").cache).toBe(0);
-	});
-
-	// Tier 6.5 D1 — per-stage `maxPerPump` override on `StageDef`.
-	it("jobFlow honors per-stage maxPerPump override", () => {
-		// Stage A caps at 1 claim per pump tick; stage B inherits the
-		// top-level cap of 100. Enqueue 3 items; only 1 advances per A's
-		// pending-tick. Each enqueue triggers A's pump independently, so all
-		// 3 still drain through; the assertion is that A's pump body
-		// processes at most 1 per call (verified by stage-A "depth" never
-		// dropping below 0 mid-tick — synchronous propagation here means we
-		// can only check the steady-state outcome).
-		const stageACalls: number[] = [];
-		const flow = jobFlow<number>("flow-cap", {
-			stages: [
-				{
-					name: "a",
-					work: (job) => {
-						stageACalls.push(job.payload as number);
-						return Promise.resolve(job.payload as number);
-					},
-					maxPerPump: 1,
-				},
-				{ name: "b" },
-			],
-			maxPerPump: 100,
-		});
-		flow.enqueue(1);
-		flow.enqueue(2);
-		flow.enqueue(3);
-		// All 3 should eventually flow through (each enqueue triggers A's
-		// pump again; the cap limits per-tick claims, not total throughput).
-		// We can't assert per-tick claim counts directly without a pump
-		// hook, but we CAN assert all 3 made it through stage A.
-		return new Promise<void>((resolve) => {
-			setTimeout(() => {
-				expect(stageACalls.length).toBe(3);
-				resolve();
-			}, 50);
-		});
-	});
-
-	it("jobFlow rejects negative or zero per-stage maxPerPump at construction", () => {
-		expect(() =>
-			jobFlow<number>("flow-bad", {
-				stages: [{ name: "a", work: (j) => Promise.resolve(j.payload), maxPerPump: -1 }, "b"],
-			}),
-		).toThrow();
-	});
-
-	it("jobFlow stage maxInflight caps concurrent inflight; resumes on settle (Tier 6.5 3.1)", async () => {
-		// Two slots open per stage. Emit 5 items into stage1; assert at most 2
-		// are in-flight at once. Resolve one held promise → next claim should
-		// kick off (the inflightCounter dep re-fires the pump).
-		const concurrency: number[] = [];
-		let live = 0;
-		const resolvers: Array<(v: number) => void> = [];
-		const flow = jobFlow<number>("flow-cap", {
-			stages: [
-				{
-					name: "work",
-					maxInflight: 2,
-					work: (job) => {
-						live += 1;
-						concurrency.push(live);
-						return new Promise<number>((r) => {
-							resolvers.push((v) => {
-								live -= 1;
-								r(v);
-							});
-						}).then((v) => v + job.payload);
-					},
-				},
-				"done",
-			],
-		});
-		const unsub = flow.completed.subscribe(() => undefined);
-		for (let i = 0; i < 5; i++) flow.queue("work").enqueue(i);
-		// Without maxInflight, all 5 work fns would have started.
-		expect(resolvers.length).toBe(2);
-		expect(concurrency.every((c) => c <= 2)).toBe(true);
-		// Settle one → counter decrements → pump re-fires → next claim starts.
-		resolvers.shift()?.(100);
-		await Promise.resolve();
-		await Promise.resolve();
-		expect(resolvers.length).toBe(2);
-		expect(concurrency.every((c) => c <= 2)).toBe(true);
-		// Drain the rest.
-		while (resolvers.length > 0) {
-			resolvers.shift()?.(0);
-			await Promise.resolve();
-			await Promise.resolve();
-		}
-		flow.destroy();
-		unsub();
-	});
-
-	it("jobFlow pump aborts inflight per-claim signal on destroy (Tier 6.5 2.5a)", () => {
-		// Long-running work fn that resolves never inside the test's scope —
-		// the inflight subscription stays open. Capture the signal from opts so
-		// the test can assert teardown propagates abort to user-supplied work.
-		const seen: AbortSignal[] = [];
-		const flow = jobFlow<number>("flow-abort", {
-			stages: [
-				{
-					name: "work",
-					work: (_job, opts) => {
-						if (opts?.signal != null) seen.push(opts.signal);
-						return new Promise<number>(() => {
-							/* never resolves — held until abort */
-						});
-					},
-				},
-				"done",
-			],
-		});
-		// Activation: subscribe so the pump effect runs.
-		const unsub = flow.completed.subscribe(() => undefined);
-		flow.queue("work").enqueue(1);
-		flow.queue("work").enqueue(2);
-		// Two claims → two inflight subscriptions → two signals captured.
-		expect(seen.length).toBe(2);
-		expect(seen.every((s) => !s.aborted)).toBe(true);
-		// Destroy the flow graph — pump teardown drains inflight signals.
-		flow.destroy();
-		expect(seen.every((s) => s.aborted)).toBe(true);
-		unsub();
-	});
-});
-
-describe("patterns.messagingHub", () => {
-	it("lazy-creates topics on first access", () => {
-		const hub = messagingHub("hub");
-		expect(hub.has("orders")).toBe(false);
-		expect(hub.size).toBe(0);
-
-		const t = hub.topic<number>("orders");
-		expect(hub.has("orders")).toBe(true);
-		expect(hub.size).toBe(1);
-
-		// Second call returns same instance
-		expect(hub.topic<number>("orders")).toBe(t);
-	});
-
-	it("publish lazily creates topic + delivers", () => {
-		const hub = messagingHub("hub");
-		hub.publish<number>("events", 42);
-
-		expect(hub.has("events")).toBe(true);
-		expect(hub.topic<number>("events").retained()).toEqual([42]);
-	});
-
-	it("applies defaultTopicOptions and per-call override", () => {
-		const hub = messagingHub("hub", { defaultTopicOptions: { retainedLimit: 3 } });
-
-		const t1 = hub.topic<number>("a");
-		for (let i = 0; i < 10; i++) t1.publish(i);
-		// retainedLimit=3 from defaults
-		expect(t1.retained()).toEqual([7, 8, 9]);
-
-		// Per-call override only applies on first creation
-		const t2 = hub.topic<number>("b", { retainedLimit: 5 });
-		for (let i = 0; i < 10; i++) t2.publish(i);
-		expect(t2.retained()).toEqual([5, 6, 7, 8, 9]);
-	});
-
-	it("publishMany publishes across multiple topics", () => {
-		const hub = messagingHub("hub");
-		hub.publishMany([
-			["orders", { id: 1 }],
-			["shipments", { id: 10 }],
-			["orders", { id: 2 }],
-		]);
-
-		expect(hub.size).toBe(2);
-		expect(hub.topic("orders").retained()).toEqual([{ id: 1 }, { id: 2 }]);
-		expect(hub.topic("shipments").retained()).toEqual([{ id: 10 }]);
-	});
-
-	it("publishMany empty is a no-op", () => {
-		const hub = messagingHub("hub");
-		hub.publishMany([]);
-		expect(hub.size).toBe(0);
-	});
-
-	it("subscribe() creates a cursor-based SubscriptionGraph", () => {
-		const hub = messagingHub("hub");
-		hub.publishMany<number>([
-			["events", 1],
-			["events", 2],
-			["events", 3],
-		] as Iterable<[string, unknown]>);
-
-		const sub = hub.subscribe<number>("consumer", "events");
-		expect(sub.pull()).toEqual([1, 2, 3]);
-		sub.ack(1);
-		expect(sub.pull()).toEqual([2, 3]);
-	});
-
-	it("subscribe() lazily creates the topic if missing", () => {
-		const hub = messagingHub("hub");
-		const sub = hub.subscribe<number>("consumer", "late-topic");
-
-		expect(hub.has("late-topic")).toBe(true);
-		expect(sub.pull()).toEqual([]);
-
-		hub.publish<number>("late-topic", 99);
-		expect(sub.pull()).toEqual([99]);
-	});
-
-	it("removeTopic unmounts and returns true", () => {
-		const hub = messagingHub("hub");
-		hub.publish<number>("x", 1);
-		expect(hub.size).toBe(1);
-
-		const removed = hub.removeTopic("x");
-		expect(removed).toBe(true);
-		expect(hub.has("x")).toBe(false);
-		expect(hub.size).toBe(0);
-
-		// re-publish recreates
-		hub.publish<number>("x", 99);
-		expect(hub.size).toBe(1);
-		expect(hub.topic<number>("x").retained()).toEqual([99]);
-	});
-
-	it("removeTopic on non-existent returns false", () => {
-		const hub = messagingHub("hub");
-		expect(hub.removeTopic("never")).toBe(false);
-	});
-
-	it("version counter advances on create / remove only", () => {
-		const hub = messagingHub("hub");
-		// B.2 Unit 14 lock: version is now a reactive Node<number>.
-		expect(hub.node("version").cache).toBe(0);
-
-		hub.topic("a");
-		expect(hub.node("version").cache).toBe(1);
-
-		hub.topic("a"); // already exists — no advance
-		expect(hub.node("version").cache).toBe(1);
-
-		hub.publish("a", 1); // publish doesn't advance
-		expect(hub.node("version").cache).toBe(1);
-
-		hub.topic("b");
-		expect(hub.node("version").cache).toBe(2);
-
-		hub.removeTopic("a");
-		expect(hub.node("version").cache).toBe(3);
-
-		hub.removeTopic("missing"); // no-op
-		expect(hub.node("version").cache).toBe(3);
-	});
-
-	it("topicNames iterates over registered topics", () => {
-		const hub = messagingHub("hub");
-		hub.topic("x");
-		hub.publish("y", 1);
-		hub.topic("z");
-
-		expect([...hub.topicNames()].sort()).toEqual(["x", "y", "z"]);
-
-		hub.removeTopic("y");
-		expect([...hub.topicNames()].sort()).toEqual(["x", "z"]);
-	});
-
-	it("mounts topics under the hub — accessible via qualified paths", () => {
-		const hub = messagingHub("hub");
-		hub.publish<number>("orders", 42);
-
-		// hub.orders::events should be resolvable through the mounted subgraph
-		const ordersEvents = hub.node("orders::events");
-		expect(ordersEvents.cache).toEqual([42]);
-	});
-});
-
-// ---------------------------------------------------------------------------
-// Phase 13.B — Message<T> envelope + standard topic constants
-// ---------------------------------------------------------------------------
-
-describe("patterns.messaging — Message envelope + standard topic constants (Phase 13.B)", () => {
-	it("exposes the well-known topic constants with stable names", () => {
-		expect(PROMPTS_TOPIC).toBe("prompts");
-		expect(RESPONSES_TOPIC).toBe("responses");
-		expect(INJECTIONS_TOPIC).toBe("injections");
-		expect(DEFERRED_TOPIC).toBe("deferred");
-		expect(SPAWNS_TOPIC).toBe("spawns");
-		expect(CONTEXT_TOPIC).toBe("context");
-		expect(TODOS_TOPIC).toBe("todos");
-	});
-
-	it("STANDARD_TOPICS tuple contains all well-known constants in declared order", () => {
-		expect(STANDARD_TOPICS).toEqual([
-			PROMPTS_TOPIC,
-			RESPONSES_TOPIC,
-			INJECTIONS_TOPIC,
-			DEFERRED_TOPIC,
-			SPAWNS_TOPIC,
-			CONTEXT_TOPIC,
-			TODOS_TOPIC,
-		]);
-		// Compile-time check: StandardTopic is the union of the literal types.
-		const _t: StandardTopic = "prompts";
-		void _t;
-	});
-
-	it("Message<T> round-trips through a hub topic with all envelope fields", () => {
-		const hub = messagingHub("hub");
-		const t = hub.topic<Message<{ text: string }>>(PROMPTS_TOPIC);
-
-		const msg: Message<{ text: string }> = {
-			id: "msg-1",
-			schema: {
-				type: "object",
-				properties: { text: { type: "string" } },
-				required: ["text"],
-			},
-			expiresAt: "2026-12-31T23:59:59Z",
-			correlationId: "session-42",
-			payload: { text: "hello" },
-		};
-		t.publish(msg);
-
-		const received = t.retained()[0]!;
-		expect(received.id).toBe("msg-1");
-		expect(received.correlationId).toBe("session-42");
-		expect(received.expiresAt).toBe("2026-12-31T23:59:59Z");
-		expect(received.payload.text).toBe("hello");
-		expect(received.schema?.properties?.text?.type).toBe("string");
-	});
-
-	it("Message<T> round-trips through a hub topic with only the required `id` + `payload`", () => {
-		const hub = messagingHub("hub-min");
-		const t = hub.topic<Message<number>>(SPAWNS_TOPIC);
-
-		t.publish({ id: "msg-2", payload: 42 });
-
-		const received = t.retained()[0]!;
-		expect(received.id).toBe("msg-2");
-		expect(received.payload).toBe(42);
-		expect(received.schema).toBeUndefined();
-		expect(received.correlationId).toBeUndefined();
-		expect(received.expiresAt).toBeUndefined();
-	});
-
-	it("filtering envelopes by correlationId works via derived (request/response pairing)", () => {
-		const hub = messagingHub("hub-corr");
-		const responses = hub.topic<Message<string>>(RESPONSES_TOPIC);
-
-		responses.publish({ id: "r1", correlationId: "req-A", payload: "ans-A" });
-		responses.publish({ id: "r2", correlationId: "req-B", payload: "ans-B" });
-		responses.publish({ id: "r3", correlationId: "req-A", payload: "ans-A2" });
-
-		const all = responses.retained();
-		const matchingA = all.filter((m) => m.correlationId === "req-A");
-		expect(matchingA).toHaveLength(2);
-		expect(matchingA.map((m) => m.payload)).toEqual(["ans-A", "ans-A2"]);
-	});
-});
-
-// Regression: messaging audit-record schemas added pre-1.0 for symmetry with
-// ProcessInstance.
-// Spec: docs/implementation-plan.md DS-13.5.E (alt A, 4 records)
-describe("patterns.messaging — audit-record schemas (DS-13.5.E)", () => {
-	it("topicPublishKeyOf returns topicName::itemKey format", () => {
-		const r: TopicPublishRecord = {
-			t_ns: 0,
-			seq: 1,
-			kind: "topic.publish",
-			topicName: "orders",
-			itemKey: "abc",
-		};
-		expect(topicPublishKeyOf(r)).toBe("orders::abc");
-	});
-
-	it("subscriptionAckKeyOf returns subscriptionId::cursor format", () => {
-		const r: SubscriptionAckRecord = {
-			t_ns: 0,
-			seq: 1,
-			kind: "subscription.ack",
-			subscriptionId: "worker-1",
-			cursor: 7,
-		};
-		expect(subscriptionAckKeyOf(r)).toBe("worker-1::7");
-	});
-
-	it("subscriptionPullAndAckKeyOf returns subscriptionId::cursor format", () => {
-		const r: SubscriptionPullAndAckRecord = {
-			t_ns: 0,
-			seq: 1,
-			kind: "subscription.pullAndAck",
-			subscriptionId: "worker-2",
-			cursor: 12,
-			itemCount: 3,
-		};
-		expect(subscriptionPullAndAckKeyOf(r)).toBe("worker-2::12");
-	});
-
-	it("hubRemoveTopicKeyOf returns topicName", () => {
-		const r: HubRemoveTopicRecord = {
-			t_ns: 0,
-			seq: 1,
-			kind: "hub.removeTopic",
-			topicName: "stale",
-		};
-		expect(hubRemoveTopicKeyOf(r)).toBe("stale");
-	});
-
-	it("kind discriminator narrows record types in MessagingAuditRecord union", () => {
-		const records: MessagingAuditRecord[] = [
-			{ t_ns: 1, kind: "topic.publish", topicName: "t", itemKey: "k" },
-			{ t_ns: 2, kind: "subscription.ack", subscriptionId: "s", cursor: 1 },
-			{
-				t_ns: 3,
-				kind: "subscription.pullAndAck",
-				subscriptionId: "s",
-				cursor: 2,
-				itemCount: 1,
-			},
-			{ t_ns: 4, kind: "hub.removeTopic", topicName: "t" },
-		];
-
-		const keys = records.map((r): string => {
-			switch (r.kind) {
-				case "topic.publish":
-					// Narrowed: TopicPublishRecord
-					return topicPublishKeyOf(r);
-				case "subscription.ack":
-					return subscriptionAckKeyOf(r);
-				case "subscription.pullAndAck":
-					return subscriptionPullAndAckKeyOf(r);
-				case "hub.removeTopic":
-					return hubRemoveTopicKeyOf(r);
-				default: {
-					const _exhaustive: never = r;
-					return _exhaustive;
-				}
-			}
-		});
-
-		expect(keys).toEqual(["t::k", "s::1", "s::2", "t"]);
-	});
-
-	it("TopicPublishRecord composes with mutate audit opts (opt-in emission)", () => {
-		const t = topic<{ id: string; payload: string }>("orders");
-		const log = createAuditLog<TopicPublishRecord>({ name: "publishes" });
-		// Activate the entries node so .cache reflects appends synchronously.
-		const unsub = log.entries.subscribe(() => undefined);
-
-		const auditedPublish = mutate(
-			(item: { id: string; payload: string }): void => t.publish(item),
-			{
-				frame: "inline",
-				log,
-				onSuccessRecord: ([item], _r, m) => ({
-					t_ns: m.t_ns,
-					seq: m.seq,
-					kind: "topic.publish" as const,
-					topicName: t.name,
-					itemKey: item.id,
-				}),
-			},
-		);
-
-		auditedPublish({ id: "a", payload: "first" });
-		auditedPublish({ id: "b", payload: "second" });
-
-		const entries = log.entries.cache as readonly TopicPublishRecord[];
-		expect(entries).toHaveLength(2);
-		expect(entries[0]!.kind).toBe("topic.publish");
-		expect(entries[0]!.topicName).toBe("orders");
-		expect(entries[0]!.itemKey).toBe("a");
-		expect(entries[1]!.itemKey).toBe("b");
-
-		unsub();
-	});
-
-	it("SubscriptionAckRecord composes with mutate audit opts", () => {
-		const t = topic<number>("nums");
-		t.publish(10);
-		t.publish(20);
-		t.publish(30);
-		const sub = subscription<number>("worker", t);
-
-		const log = createAuditLog<SubscriptionAckRecord>({ name: "acks" });
-		const unsub = log.entries.subscribe(() => undefined);
-
-		const auditedAck = mutate((count: number): number => sub.ack(count), {
-			frame: "inline",
-			log,
-			onSuccessRecord: (_args, cursor, m) => ({
-				t_ns: m.t_ns,
-				seq: m.seq,
-				kind: "subscription.ack" as const,
-				subscriptionId: sub.name,
-				cursor,
-			}),
-		});
-
-		auditedAck(2);
-		auditedAck(1);
-
-		const entries = log.entries.cache as readonly SubscriptionAckRecord[];
-		expect(entries).toHaveLength(2);
-		expect(entries[0]!.kind).toBe("subscription.ack");
-		expect(entries[0]!.subscriptionId).toBe("worker");
-		expect(entries[0]!.cursor).toBe(2);
-		expect(entries[1]!.cursor).toBe(3);
-
-		unsub();
-	});
-
-	it("SubscriptionPullAndAckRecord composes with mutate audit opts", () => {
-		const t = topic<string>("letters");
-		t.publish("a");
-		t.publish("b");
-		t.publish("c");
-		const sub = subscription<string>("reader", t);
-
-		const log = createAuditLog<SubscriptionPullAndAckRecord>({ name: "pulls" });
-		const unsub = log.entries.subscribe(() => undefined);
-
-		const auditedPullAndAck = mutate((limit: number) => sub.pullAndAck(limit), {
-			frame: "inline",
-			log,
-			onSuccessRecord: (_args, result, m) => ({
-				t_ns: m.t_ns,
-				seq: m.seq,
-				kind: "subscription.pullAndAck" as const,
-				subscriptionId: sub.name,
-				cursor: result.cursor,
-				itemCount: result.items.length,
-			}),
-		});
-
-		auditedPullAndAck(2);
-		auditedPullAndAck(5);
-
-		const entries = log.entries.cache as readonly SubscriptionPullAndAckRecord[];
-		expect(entries).toHaveLength(2);
-		expect(entries[0]!.itemCount).toBe(2);
-		expect(entries[0]!.cursor).toBe(2);
-		expect(entries[1]!.itemCount).toBe(1);
-		expect(entries[1]!.cursor).toBe(3);
-
-		unsub();
-	});
-
-	it("HubRemoveTopicRecord composes with mutate audit opts", () => {
-		const hub = messagingHub("hub");
-		hub.topic<number>("alpha");
-		hub.topic<number>("beta");
-
-		const log = createAuditLog<HubRemoveTopicRecord>({ name: "removals" });
-		const unsub = log.entries.subscribe(() => undefined);
-
-		const auditedRemove = mutate((name: string): boolean => hub.removeTopic(name), {
-			frame: "inline",
-			log,
-			onSuccessRecord: ([name], removed, m) =>
-				removed
-					? {
-							t_ns: m.t_ns,
-							seq: m.seq,
-							kind: "hub.removeTopic" as const,
-							topicName: name,
-						}
-					: undefined,
-		});
-
-		auditedRemove("alpha");
-		auditedRemove("does-not-exist"); // should NOT emit (returns false → undefined)
-
-		const entries = log.entries.cache as readonly HubRemoveTopicRecord[];
-		expect(entries).toHaveLength(1);
-		expect(entries[0]!.kind).toBe("hub.removeTopic");
-		expect(entries[0]!.topicName).toBe("alpha");
-
-		unsub();
-	});
-
-	it("audit field stays optional — Topic.publish without audit opts emits no records", () => {
-		// Without mutate/audit wiring, the topic's mutation site does
-		// not emit any records (audit field stays optional at all four sites).
-		const t = topic<number>("plain");
-		t.publish(1);
-		t.publish(2);
-		// No audit log to assert against — the absence of an audit surface IS
-		// the contract. Confirm the topic still works as expected.
-		expect(t.retained()).toEqual([1, 2]);
-	});
-});
-
-describe("patterns.messaging.logProjector", () => {
-	// Drain the serialized async chain until `position` stops advancing.
-	// NOTE (QA-G): every test below constructs the projector AFTER the
-	// synchronous `topic.publish(...)`/`log.append(...)` seeding, so the
-	// `keepalive(drain)` push-on-subscribe schedules the first drain
-	// synchronously during construction — `_inFlight` is a real chain before
-	// `settle` runs (so it cannot vacuously return at position 0 before any
-	// projection). Keep that ordering when adding cases.
-	async function settle(proj: {
-		idle: () => Promise<void>;
-		position: { cache: unknown };
-	}): Promise<void> {
-		let prev = -1;
-		for (let i = 0; i < 30; i += 1) {
-			await proj.idle();
-			const pos = proj.position.cache as number;
-			if (pos === prev) return;
-			prev = pos;
-		}
-	}
-
-	it("projects retained + live entries in order; position tracks the cursor (topic source)", async () => {
-		const t = topic<number>("nums");
-		t.publish(1);
-		t.publish(2);
-		const seen: number[] = [];
-		const proj = logProjector("p", t, { sink: (n) => void seen.push(n) });
-		await settle(proj);
-		expect(seen).toEqual([1, 2]);
-		expect(proj.position.cache).toBe(2);
-
-		t.publish(3);
-		await settle(proj);
-		expect(seen).toEqual([1, 2, 3]);
-		expect(proj.position.cache).toBe(3);
-		proj.destroy();
-	});
-
-	it("from:'now' skips retained history (projects only future appends)", async () => {
-		const t = topic<string>("evts");
-		t.publish("old");
-		const seen: string[] = [];
-		const proj = logProjector("p", t, { from: "now", sink: (s) => void seen.push(s) });
-		await settle(proj);
-		expect(seen).toEqual([]);
-		t.publish("new");
-		await settle(proj);
-		expect(seen).toEqual(["new"]);
-		proj.destroy();
-	});
-
-	it("onPoison:'deadLetter' routes the poison entry and projects newer ones", async () => {
-		const t = topic<number>("nums");
-		t.publish(1);
-		t.publish(2); // poison
-		t.publish(3);
-		const seen: number[] = [];
-		const proj = logProjector<number>("p", t, {
-			onPoison: "deadLetter",
-			sink: (n) => {
-				if (n === 2) throw new Error("boom-2");
-				seen.push(n);
-			},
-		});
-		await settle(proj);
-		// 1 and 3 projected; 2 dead-lettered; cursor advanced past all three.
-		expect(seen).toEqual([1, 3]);
-		expect(proj.position.cache).toBe(3);
-		const dl = proj.deadLetter.retained() as readonly DeadLetterEntry<number>[];
-		expect(dl).toHaveLength(1);
-		expect(dl[0]!.item).toBe(2);
-		expect(dl[0]!.error).toBe("boom-2");
-		expect(dl[0]!.cursorPos).toBe(1); // 0-based position of the poison entry
-		proj.destroy();
-	});
-
-	it("onPoison:'halt' (default) stops at the poison — head-of-line, position stalls", async () => {
-		const t = topic<number>("nums");
-		t.publish(1);
-		t.publish(2); // poison
-		t.publish(3);
-		const seen: number[] = [];
-		const proj = logProjector<number>("p", t, {
-			sink: (n) => {
-				if (n === 2) throw new Error("stuck");
-				seen.push(n);
-			},
-		});
-		await settle(proj);
-		expect(seen).toEqual([1]); // 1 projected, halted before 2
-		expect(proj.position.cache).toBe(1); // cursor did NOT pass the poison
-		// A newer append does not unblock — still head-of-line on the poison.
-		t.publish(4);
-		await settle(proj);
-		expect(seen).toEqual([1]);
-		expect(proj.position.cache).toBe(1);
-		// No dead-letter under halt.
-		expect(proj.deadLetter.retained() as readonly unknown[]).toHaveLength(0);
-		proj.destroy();
-	});
-
-	it("serializes an async sink; processes items strictly in order", async () => {
-		const t = topic<number>("nums");
-		for (let i = 1; i <= 5; i += 1) t.publish(i);
-		const seen: number[] = [];
-		let active = 0;
-		let maxConcurrent = 0;
-		const proj = logProjector<number>("p", t, {
-			sink: async (n) => {
-				active += 1;
-				maxConcurrent = Math.max(maxConcurrent, active);
-				await Promise.resolve();
-				seen.push(n);
-				active -= 1;
-			},
-		});
-		await settle(proj);
-		expect(seen).toEqual([1, 2, 3, 4, 5]);
-		expect(maxConcurrent).toBe(1); // strictly serialized
-		expect(proj.position.cache).toBe(5);
-		proj.destroy();
-	});
-
-	it("transient-vs-poison contract: a sink that RETURNS (skips) advances; only THROW is poison", async () => {
-		const t = topic<number>("nums");
-		t.publish(1);
-		t.publish(2); // sink chooses to skip (returns, no throw) — handled
-		t.publish(3);
-		const handled: number[] = [];
-		const proj = logProjector<number>("p", t, {
-			onPoison: "deadLetter",
-			sink: (n) => {
-				if (n === 2) return; // transient/skip = sink's responsibility, NOT poison
-				handled.push(n);
-			},
-		});
-		await settle(proj);
-		expect(handled).toEqual([1, 3]);
-		expect(proj.position.cache).toBe(3); // 2 was advanced past (handled, not poison)
-		expect(proj.deadLetter.retained() as readonly unknown[]).toHaveLength(0);
-		proj.destroy();
-	});
-
-	it("works over a ReactiveLogBundle source (memo:Re's changesetLog shape)", async () => {
-		const log = reactiveLog<string>([], { name: "changeset" });
-		log.append("a");
-		log.append("b");
-		const seen: string[] = [];
-		const proj = logProjector<string>("p", log, { sink: (s) => void seen.push(s) });
-		await settle(proj);
-		expect(seen).toEqual(["a", "b"]);
-		expect(proj.position.cache).toBe(2);
-		log.append("c");
-		await settle(proj);
-		expect(seen).toEqual(["a", "b", "c"]);
-		expect(proj.position.cache).toBe(3);
-		proj.destroy();
-		log.dispose();
-	});
-
-	it("dead-letter is a real, subscribable topic node (visible in describe)", async () => {
-		const t = topic<number>("nums");
-		t.publish(7); // poison
-		const dlSeen: DeadLetterEntry<number>[] = [];
-		const proj = logProjector<number>("p", t, {
-			onPoison: "deadLetter",
-			sink: () => {
-				throw new Error("always");
-			},
-		});
-		proj.deadLetter.events.subscribe((msgs) => {
-			for (const m of msgs) {
-				if (m[0] === DATA) {
-					for (const e of m[1] as readonly DeadLetterEntry<number>[]) dlSeen.push(e);
-				}
-			}
-		});
-		await settle(proj);
-		expect(dlSeen.at(-1)?.item).toBe(7);
-		// Mounted under the projector graph → present in describe().
-		expect(Object.keys(proj.describe().nodes).length).toBeGreaterThan(0);
-		proj.destroy();
-	});
-
-	it("halt latches: sink is invoked on the poison item EXACTLY ONCE, even after later appends (QA-C)", async () => {
-		const t = topic<number>("nums");
-		t.publish(1);
-		t.publish(2); // poison
-		const calls: number[] = [];
-		const proj = logProjector<number>("p", t, {
-			sink: (n) => {
-				calls.push(n);
-				if (n === 2) throw new Error("poison");
-			},
-		});
-		await settle(proj);
-		expect(calls).toEqual([1, 2]); // 1 ok, 2 thrown — once
-		// Subsequent unrelated appends must NOT re-invoke sink on the poison
-		// (pre-fix this hot-looped sink(2) once per append, forever).
-		t.publish(3);
-		t.publish(4);
-		await settle(proj);
-		await new Promise((r) => setTimeout(r, 0));
-		expect(calls).toEqual([1, 2]); // still exactly once on the poison; frozen
-		expect(proj.position.cache).toBe(1);
-		proj.destroy();
-	});
-});
diff --git a/src/__tests__/utils/orchestration/human-input-tracker.test.ts b/src/__tests__/utils/orchestration/human-input-tracker.test.ts
deleted file mode 100644
index 0f6835a9..00000000
--- a/src/__tests__/utils/orchestration/human-input-tracker.test.ts
+++ /dev/null
@@ -1,273 +0,0 @@
-/**
- * Phase 13.F — `humanInput<T>` + `tracker` regression tests.
- */
-
-import { DATA, node } from "@graphrefly/pure-ts/core";
-import { describe, expect, it } from "vitest";
-import {
-	DEFERRED_TOPIC,
-	type Message,
-	messagingHub,
-	PROMPTS_TOPIC,
-	RESPONSES_TOPIC,
-} from "../../../utils/messaging/index.js";
-import { humanInput, tracker } from "../../../utils/orchestration/index.js";
-
-// ---------------------------------------------------------------------------
-// humanInput
-// ---------------------------------------------------------------------------
-
-describe("humanInput<T> (Phase 13.F)", () => {
-	it("publishes a Message envelope to PROMPTS_TOPIC on each prompt", () => {
-		const hub = messagingHub("hub");
-		const promptN = node<string>([], { name: "prompt", initial: "first?" });
-
-		const reply = humanInput<{ ok: boolean }>({ hub, prompt: promptN });
-		// Subscribe to wake the pipeline.
-		const replyUnsub = reply.subscribe(() => {});
-
-		const promptsTopic = hub.topic<Message<{ prompt: string }>>(PROMPTS_TOPIC);
-		const published = promptsTopic.retained();
-		expect(published).toHaveLength(1);
-		expect(published[0]?.payload.prompt).toBe("first?");
-		expect(typeof published[0]?.id).toBe("string");
-		expect(typeof published[0]?.correlationId).toBe("string");
-
-		// New prompt → new envelope with fresh correlationId.
-		promptN.emit("second?");
-		const after = promptsTopic.retained();
-		expect(after).toHaveLength(2);
-		expect(after[1]?.payload.prompt).toBe("second?");
-		expect(after[1]?.correlationId).not.toBe(after[0]?.correlationId);
-
-		replyUnsub();
-		hub.destroy();
-	});
-
-	it("emits the response payload when RESPONSES_TOPIC delivers a matching correlationId", () => {
-		const hub = messagingHub("hub");
-		const promptN = node<string>([], { name: "prompt", initial: "approve?" });
-
-		const reply = humanInput<{ ok: boolean }>({ hub, prompt: promptN });
-		const seen: { ok: boolean }[] = [];
-		const unsub = reply.subscribe((msgs) => {
-			for (const m of msgs) {
-				if (m[0] === DATA) seen.push(m[1] as { ok: boolean });
-			}
-		});
-
-		const promptsTopic = hub.topic<Message<{ prompt: string }>>(PROMPTS_TOPIC);
-		const responsesTopic = hub.topic<Message<{ ok: boolean }>>(RESPONSES_TOPIC);
-		const sentEnv = promptsTopic.retained()[0]!;
-
-		// Mock human responding.
-		responsesTopic.publish({
-			id: "resp-1",
-			correlationId: sentEnv.correlationId,
-			payload: { ok: true },
-		});
-
-		expect(seen).toEqual([{ ok: true }]);
-
-		unsub();
-		hub.destroy();
-	});
-
-	it("ignores responses with non-matching correlationId", () => {
-		const hub = messagingHub("hub");
-		const promptN = node<string>([], { name: "prompt", initial: "x" });
-
-		const reply = humanInput<{ ok: boolean }>({ hub, prompt: promptN });
-		const seen: { ok: boolean }[] = [];
-		const unsub = reply.subscribe((msgs) => {
-			for (const m of msgs) {
-				if (m[0] === DATA) seen.push(m[1] as { ok: boolean });
-			}
-		});
-
-		const responsesTopic = hub.topic<Message<{ ok: boolean }>>(RESPONSES_TOPIC);
-
-		// Unrelated response (different correlationId).
-		responsesTopic.publish({
-			id: "stale",
-			correlationId: "completely-unrelated",
-			payload: { ok: false },
-		});
-
-		expect(seen).toEqual([]);
-
-		unsub();
-		hub.destroy();
-	});
-
-	it("switchMap semantics — new prompt abandons the prior in-flight watcher", () => {
-		const hub = messagingHub("hub");
-		const promptN = node<string>([], { name: "prompt", initial: "first" });
-
-		const reply = humanInput<{ tag: string }>({ hub, prompt: promptN });
-		const seen: { tag: string }[] = [];
-		const unsub = reply.subscribe((msgs) => {
-			for (const m of msgs) {
-				if (m[0] === DATA) seen.push(m[1] as { tag: string });
-			}
-		});
-
-		const promptsTopic = hub.topic<Message<{ prompt: string }>>(PROMPTS_TOPIC);
-		const responsesTopic = hub.topic<Message<{ tag: string }>>(RESPONSES_TOPIC);
-
-		const firstEnv = promptsTopic.retained()[0]!;
-
-		// Issue a second prompt before the first response arrives.
-		promptN.emit("second");
-		const secondEnv = promptsTopic.retained()[1]!;
-
-		// A response for the FIRST prompt is now stale — should be ignored.
-		responsesTopic.publish({
-			id: "r1",
-			correlationId: firstEnv.correlationId,
-			payload: { tag: "stale" },
-		});
-		expect(seen).toEqual([]);
-
-		// A response for the SECOND prompt is delivered.
-		responsesTopic.publish({
-			id: "r2",
-			correlationId: secondEnv.correlationId,
-			payload: { tag: "fresh" },
-		});
-		expect(seen).toEqual([{ tag: "fresh" }]);
-
-		unsub();
-		hub.destroy();
-	});
-
-	it("carries optional schema in the envelope", () => {
-		const hub = messagingHub("hub");
-		const promptN = node<string>([], { name: "prompt", initial: "?" });
-		const schema = { type: "object" as const, required: ["ok"] };
-
-		const reply = humanInput<{ ok: boolean }>({ hub, prompt: promptN, schema });
-		const unsub = reply.subscribe(() => {});
-
-		const promptsTopic = hub.topic<Message<{ prompt: string }>>(PROMPTS_TOPIC);
-		const env = promptsTopic.retained()[0]!;
-		// Schema is carried at envelope-level only (Phase 13.B contract);
-		// payload stays the typed `HumanPromptPayload` without the duplicate.
-		expect(env.schema).toEqual(schema);
-		expect((env.payload as unknown as { schema?: unknown }).schema).toBeUndefined();
-
-		unsub();
-		hub.destroy();
-	});
-});
-
-// ---------------------------------------------------------------------------
-// tracker
-// ---------------------------------------------------------------------------
-
-describe("tracker (Phase 13.F)", () => {
-	it("uses DEFERRED_TOPIC by default", () => {
-		const hub = messagingHub("hub");
-		const t = tracker<string>({ hub });
-		expect(t.topic).toBe(hub.topic(DEFERRED_TOPIC));
-		hub.destroy();
-	});
-
-	it("add() appends to the topic; pending reflects unconsumed items", () => {
-		const hub = messagingHub("hub");
-		const t = tracker<{ summary: string }>({ hub });
-
-		t.add({ summary: "investigate" });
-		t.add({ summary: "follow up" });
-
-		const pending = t.pending.cache as readonly { summary: string }[];
-		expect(pending).toHaveLength(2);
-		expect(pending.map((p) => p.summary)).toEqual(["investigate", "follow up"]);
-		expect(t.total.cache).toBe(2);
-
-		hub.destroy();
-	});
-
-	it("ack(n) advances the cursor; pending excludes acked items", () => {
-		const hub = messagingHub("hub");
-		const t = tracker<number>({ hub });
-		t.add(1);
-		t.add(2);
-		t.add(3);
-
-		expect(t.pending.cache as readonly number[]).toEqual([1, 2, 3]);
-		t.ack(2);
-		expect(t.pending.cache as readonly number[]).toEqual([3]);
-
-		hub.destroy();
-	});
-
-	it("pullAndAck returns items + new cursor in one call", () => {
-		const hub = messagingHub("hub");
-		const t = tracker<string>({ hub });
-		t.add("a");
-		t.add("b");
-		t.add("c");
-
-		const r = t.pullAndAck(2);
-		expect(r.items).toEqual(["a", "b"]);
-		expect(r.cursor).toBe(2);
-
-		const r2 = t.pullAndAck();
-		expect(r2.items).toEqual(["c"]);
-		expect(r2.cursor).toBe(3);
-		hub.destroy();
-	});
-
-	it("multiple trackers on the same hub topic get independent cursors", () => {
-		const hub = messagingHub("hub");
-		const a = tracker<number>({ hub, name: "tracker-a" });
-		const b = tracker<number>({ hub, name: "tracker-b" });
-
-		a.add(1);
-		a.add(2);
-
-		// Both see the same items (shared topic).
-		expect(a.pending.cache as readonly number[]).toEqual([1, 2]);
-		expect(b.pending.cache as readonly number[]).toEqual([1, 2]);
-
-		// `a` acks its first; `b` is independent.
-		a.ack(1);
-		expect(a.pending.cache as readonly number[]).toEqual([2]);
-		expect(b.pending.cache as readonly number[]).toEqual([1, 2]);
-
-		hub.destroy();
-	});
-
-	it("custom topicName routes to the chosen topic", () => {
-		const hub = messagingHub("hub");
-		const t = tracker<string>({ hub, topicName: "custom-queue" });
-		expect(t.topic).toBe(hub.topic("custom-queue"));
-		t.add("x");
-		expect(t.pending.cache as readonly string[]).toEqual(["x"]);
-		hub.destroy();
-	});
-
-	it("from: 'now' starts cursor at the current topic length", () => {
-		const hub = messagingHub("hub");
-		// Pre-populate the topic before mounting the tracker.
-		hub.topic<number>(DEFERRED_TOPIC).publish(99);
-
-		const t = tracker<number>({ hub, from: "now" });
-		// `now` cursor skips the pre-existing item; pending starts empty.
-		expect(t.pending.cache as readonly number[]).toEqual([]);
-		t.add(100);
-		expect(t.pending.cache as readonly number[]).toEqual([100]);
-		hub.destroy();
-	});
-
-	it("total tracks topic event count", () => {
-		const hub = messagingHub("hub");
-		const t = tracker<string>({ hub });
-		expect(t.total.cache).toBe(0);
-		t.add("a");
-		t.add("b");
-		expect(t.total.cache).toBe(2);
-		hub.destroy();
-	});
-});
diff --git a/src/__tests__/utils/orchestration/orchestration.test.ts b/src/__tests__/utils/orchestration/orchestration.test.ts
deleted file mode 100644
index de41a7b6..00000000
--- a/src/__tests__/utils/orchestration/orchestration.test.ts
+++ /dev/null
@@ -1,528 +0,0 @@
-import { COMPLETE, DATA, node, TEARDOWN } from "@graphrefly/pure-ts/core";
-import { delay, valve } from "@graphrefly/pure-ts/extra";
-import { Graph } from "@graphrefly/pure-ts/graph";
-import { describe, expect, it } from "vitest";
-import { pipelineGraph } from "../../../utils/orchestration/index.js";
-
-describe("patterns.orchestration", () => {
-	it("pipelineGraph creates a PipelineGraph container", () => {
-		const g = pipelineGraph("wf");
-		expect(g).toBeInstanceOf(Graph);
-		expect(g.name).toBe("wf");
-	});
-
-	// FLAG: v5 behavioral change — needs investigation (expected undefined to be 6)
-	it("task registers a computed step and wires dependency edges", () => {
-		const g = pipelineGraph("wf");
-		const input = node([], { initial: 1 });
-		g.add(input, { name: "input" });
-		const doubled = g.task<number>("double", ([v]) => ((v as number) * 2) as number, {
-			deps: ["input"],
-		});
-		doubled.subscribe(() => undefined);
-		g.set("input", 3);
-		expect(g.node("double").cache).toBe(6);
-		expect(g.edges()).toContainEqual(["input", "double"]);
-	});
-
-	it("task with Node deps still records explicit graph edges", () => {
-		const g = pipelineGraph("wf");
-		const input = node([], { initial: 2 });
-		g.add(input, { name: "input" });
-		g.task<number>("doubleByRef", ([v]) => ((v as number) * 2) as number, {
-			deps: [input],
-		});
-		expect(g.edges()).toContainEqual(["input", "doubleByRef"]);
-	});
-
-	it("classify emits tagged results", () => {
-		const g = pipelineGraph("wf");
-		const input = node([], { initial: 1 });
-		g.add(input, { name: "input" });
-		const out = g.classify<"then" | "else", number>("route", "input", (v) =>
-			v >= 2 ? "then" : "else",
-		);
-		const seen: Array<"then" | "else"> = [];
-		out.subscribe((msgs) => {
-			for (const msg of msgs) {
-				if (msg[0] === DATA) {
-					const payload = msg[1] as { tag: "then" | "else" };
-					seen.push(payload.tag);
-				}
-			}
-		});
-		g.set("input", 2);
-		expect(seen).toContain("else");
-		expect(seen).toContain("then");
-	});
-
-	it("task and classify describe as derived with canonical orchestration metadata", () => {
-		const g = pipelineGraph("wf");
-		const input = node([], { initial: 1 });
-		g.add(input, { name: "input" });
-		g.task<number>("t", ([v]) => v as number, { deps: ["input"] });
-		g.classify<"pos" | "neg", number>("b", "input", (v) => (v > 0 ? "pos" : "neg"));
-		const desc = g.describe({ detail: "standard" });
-		const tKey = Object.keys(desc.nodes).find((k) => k === "t" || k.endsWith("::t"));
-		const bKey = Object.keys(desc.nodes).find((k) => k === "b" || k.endsWith("::b"));
-		expect(tKey).toBeDefined();
-		expect(bKey).toBeDefined();
-		const tNode = desc.nodes[tKey as string];
-		const bNode = desc.nodes[bKey as string];
-		expect(tNode?.type).toBe("derived");
-		expect(bNode?.type).toBe("derived");
-		expect(tNode?.meta?.orchestration_type).toBe("task");
-		expect(bNode?.meta?.orchestration_type).toBe("classify");
-	});
-
-	it("valve and approval hold value when control is false", () => {
-		const g = pipelineGraph("wf");
-		const input = node([], { initial: 1 });
-		const open = node([], { initial: true });
-		const approved = node([], { initial: true });
-		g.add(input, { name: "input" });
-		g.add(open, { name: "open" });
-		g.add(approved, { name: "approved" });
-		const gated = valve<number>(input, open);
-		g.add(gated, { name: "gated" });
-		const reviewCtrl = g.approval<number>("reviewed", "gated", approved);
-		gated.subscribe(() => undefined);
-		reviewCtrl.output.subscribe(() => undefined);
-
-		g.set("input", 2);
-		expect(g.node("reviewed").cache).toBe(2);
-		g.set("open", false);
-		g.set("input", 3);
-		expect(g.node("reviewed").cache).toBe(2);
-		g.set("open", true);
-		g.set("approved", false);
-		g.set("input", 4);
-		expect(g.node("reviewed").cache).toBe(3);
-	});
-
-	// forEach removed — use `node([source], fn, { describeKind: "effect" })` + `graph.add()`.
-	it("effect-based side-effect runs per value and is graph-observable", () => {
-		const g = pipelineGraph("wf");
-		const input = node<number>();
-		g.add(input, { name: "input" });
-		const seen: number[] = [];
-		const sink = node(
-			[input],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				return (
-					(([value]) => {
-						seen.push(value as number);
-					})(data, actions, ctx) ?? undefined
-				);
-			},
-			{ describeKind: "effect" },
-		);
-		g.add(sink, { name: "sink" });
-		sink.subscribe(() => undefined);
-		g.set("input", 2);
-		g.set("input", 3);
-		expect(seen).toEqual([2, 3]);
-	});
-
-	it("combine emits keyed record of latest dependency values", () => {
-		const g = pipelineGraph("wf");
-		const a = node([], { initial: 1 });
-		const b = node([], { initial: "x" });
-		g.add(a, { name: "a" });
-		g.add(b, { name: "b" });
-		const j = g.combine("j", { a: "a", b: "b" });
-		j.subscribe(() => undefined);
-		g.set("a", 5);
-		expect(g.node("j").cache).toEqual({ a: 5, b: "x" });
-	});
-
-	it("mount mounts child workflow graph", () => {
-		const root = pipelineGraph("root");
-		const child = new Graph("child");
-		child.add(node([], { initial: 1 }), { name: "n" });
-		root.mount("child", child);
-		expect(root.node("child::n").cache).toBe(1);
-	});
-
-	it("delay shifts DATA by ms while forwarding eventual updates", async () => {
-		const g = pipelineGraph("wf");
-		const input = node([], { initial: 1 });
-		g.add(input, { name: "input" });
-		const delayed = delay<number>(input, 10);
-		g.add(delayed, { name: "delayed" });
-		delayed.subscribe(() => undefined);
-		// extra/delay uses a per-DATA timer; initial 1 fires after the delay.
-		await new Promise((resolve) => setTimeout(resolve, 25));
-		expect(g.node("delayed").cache).toBe(1);
-		g.set("input", 2);
-		expect(g.node("delayed").cache).toBe(1);
-		await new Promise((resolve) => setTimeout(resolve, 25));
-		expect(g.node("delayed").cache).toBe(2);
-	});
-
-	// FLAG: v5 behavioral change — needs investigation (Graph.connect() deps enforcement)
-	it("catch recovers from errors", () => {
-		const g = pipelineGraph("wf");
-		const src = node([], { initial: 1 });
-		g.add(src, { name: "src" });
-		const failing = g.task<number>(
-			"failing",
-			([v]) => {
-				if ((v as number) > 1) throw new Error("boom");
-				return v as number;
-			},
-			{ deps: ["src"] },
-		);
-		const recovered = g.catch<number>("recovered", failing, (cause) => {
-			if (cause.kind === "errored") return 999;
-			return 0;
-		});
-		recovered.subscribe(() => undefined);
-		g.set("src", 2);
-		expect(g.node("recovered").cache).toBe(999);
-	});
-
-	// node([source], fn, { describeKind: "effect" }) with a throwing fn terminates the
-	// effect node via auto-error propagation; downstream subscribers stop firing.
-	it("effect-based side-effect stops running user fn after an error", () => {
-		const g = pipelineGraph("wf");
-		const src = node<number>();
-		g.add(src, { name: "src" });
-		const seen: number[] = [];
-		const sink = node(
-			[src],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				return (
-					(([value]) => {
-						seen.push(value as number);
-						if ((value as number) >= 1) {
-							throw new Error("stop");
-						}
-					})(data, actions, ctx) ?? undefined
-				);
-			},
-			{ describeKind: "effect" },
-		);
-		g.add(sink, { name: "sink" });
-		sink.subscribe(() => undefined);
-		g.set("src", 1);
-		g.set("src", 2);
-		expect(seen).toEqual([1]);
-	});
-
-	it("delay cancels pending timers on teardown", async () => {
-		const g = pipelineGraph("wf");
-		const input = node<number>();
-		g.add(input, { name: "input" });
-		const delayed = delay<number>(input, 20);
-		g.add(delayed, { name: "delayed" });
-		delayed.subscribe(() => undefined);
-		g.set("input", 2);
-		delayed.down([[TEARDOWN]]);
-		await new Promise((resolve) => setTimeout(resolve, 35));
-		expect(g.node("delayed").cache).toBeUndefined();
-	});
-
-	// FLAG: v5 behavioral change — needs investigation (Graph.connect() deps enforcement)
-	it("catch stops recovery attempts after terminal error", () => {
-		const g = pipelineGraph("wf");
-		const src = node([], { initial: 0 });
-		g.add(src, { name: "src" });
-		const failing = g.task<number>(
-			"failing",
-			([v]) => {
-				if ((v as number) >= 1) throw new Error("boom");
-				return v as number;
-			},
-			{ deps: ["src"] },
-		);
-		let recoverCalls = 0;
-		const recovered = g.catch<number>("recovered", failing, (cause) => {
-			recoverCalls += 1;
-			if (cause.kind === "errored") throw new Error("recover-failed");
-			return 0;
-		});
-		recovered.subscribe(() => undefined);
-		g.set("src", 1);
-		g.set("src", 2);
-		expect(recoverCalls).toBe(1);
-	});
-
-	// ---------------------------------------------------------------
-	// gate (human-in-the-loop approval queue)
-	// ---------------------------------------------------------------
-
-	// FLAG: v5 behavioral change — needs investigation (Graph.connect() deps enforcement)
-	it("gate queues values and approve forwards them", () => {
-		const g = pipelineGraph("wf");
-		const input = node<number>();
-		g.add(input, { name: "input" });
-		const ctrl = g.approvalGate<number>("gated", "input");
-
-		const approved: number[] = [];
-		ctrl.output.subscribe((msgs) => {
-			for (const msg of msgs) if (msg[0] === DATA) approved.push(msg[1] as number);
-		});
-
-		g.set("input", 1);
-		g.set("input", 2);
-		expect(ctrl.pending.cache).toEqual([1, 2]);
-		expect(ctrl.count.cache).toBe(2);
-		expect(approved).toEqual([]);
-
-		ctrl.approve();
-		expect(approved).toEqual([1]);
-		expect(ctrl.pending.cache).toEqual([2]);
-		expect(ctrl.count.cache).toBe(1);
-
-		ctrl.approve();
-		expect(approved).toEqual([1, 2]);
-		expect(ctrl.pending.cache).toEqual([]);
-	});
-
-	// FLAG: v5 behavioral change — needs investigation (Graph.connect() deps enforcement)
-	it("gate reject discards pending values", () => {
-		const g = pipelineGraph("wf");
-		const input = node<number>();
-		g.add(input, { name: "input" });
-		const ctrl = g.approvalGate<number>("gated", "input");
-		ctrl.output.subscribe(() => undefined);
-		g.set("input", 10);
-		g.set("input", 20);
-		expect(ctrl.pending.cache).toEqual([10, 20]);
-		ctrl.reject();
-		expect(ctrl.pending.cache).toEqual([20]);
-		ctrl.reject();
-		expect(ctrl.pending.cache).toEqual([]);
-	});
-
-	// FLAG: v5 behavioral change — needs investigation (Graph.connect() deps enforcement)
-	it("gate modify transforms and forwards", () => {
-		const g = pipelineGraph("wf");
-		const input = node<number>();
-		g.add(input, { name: "input" });
-		const ctrl = g.approvalGate<number>("gated", "input");
-
-		const approved: number[] = [];
-		ctrl.output.subscribe((msgs) => {
-			for (const msg of msgs) if (msg[0] === DATA) approved.push(msg[1] as number);
-		});
-
-		g.set("input", 5);
-		ctrl.modify((v, _i, _pending) => v * 10);
-		expect(approved).toEqual([50]);
-		expect(ctrl.pending.cache).toEqual([]);
-	});
-
-	// FLAG: v5 behavioral change — needs investigation (Graph.connect() deps enforcement)
-	it("gate open flushes pending and auto-approves future", () => {
-		const g = pipelineGraph("wf");
-		const input = node<number>();
-		g.add(input, { name: "input" });
-		const ctrl = g.approvalGate<number>("gated", "input");
-
-		const approved: number[] = [];
-		ctrl.output.subscribe((msgs) => {
-			for (const msg of msgs) if (msg[0] === DATA) approved.push(msg[1] as number);
-		});
-
-		g.set("input", 1);
-		g.set("input", 2);
-		ctrl.open();
-		expect(approved).toEqual([1, 2]);
-		expect(ctrl.isOpen.cache).toBe(true);
-
-		// Future values pass through immediately
-		g.set("input", 3);
-		expect(approved).toEqual([1, 2, 3]);
-	});
-
-	// FLAG: v5 behavioral change — needs investigation (Graph.connect() deps enforcement)
-	it("gate close re-enables manual gating", () => {
-		const g = pipelineGraph("wf");
-		const input = node<number>();
-		g.add(input, { name: "input" });
-		const ctrl = g.approvalGate<number>("gated", "input", { startOpen: true });
-
-		const approved: number[] = [];
-		ctrl.output.subscribe((msgs) => {
-			for (const msg of msgs) if (msg[0] === DATA) approved.push(msg[1] as number);
-		});
-
-		g.set("input", 1);
-		expect(approved).toEqual([1]);
-		ctrl.close();
-		g.set("input", 2);
-		expect(approved).toEqual([1]);
-		expect(ctrl.pending.cache).toEqual([2]);
-	});
-
-	// FLAG: v5 behavioral change — needs investigation (Graph.connect() deps enforcement)
-	it("gate maxPending drops oldest values (FIFO)", () => {
-		const g = pipelineGraph("wf");
-		const input = node([], { initial: 0 });
-		g.add(input, { name: "input" });
-		const ctrl = g.approvalGate<number>("gated", "input", { maxPending: 2 });
-		ctrl.output.subscribe(() => undefined);
-		g.set("input", 1);
-		g.set("input", 2);
-		g.set("input", 3);
-		expect(ctrl.pending.cache).toEqual([2, 3]);
-	});
-
-	// FLAG: v5 behavioral change — needs investigation (Graph.connect() deps enforcement)
-	it("gate approve(n) forwards multiple values", () => {
-		const g = pipelineGraph("wf");
-		const input = node<number>();
-		g.add(input, { name: "input" });
-		const ctrl = g.approvalGate<number>("gated", "input");
-
-		const approved: number[] = [];
-		ctrl.output.subscribe((msgs) => {
-			for (const msg of msgs) if (msg[0] === DATA) approved.push(msg[1] as number);
-		});
-
-		g.set("input", 1);
-		g.set("input", 2);
-		g.set("input", 3);
-		ctrl.approve(2);
-		expect(approved).toEqual([1, 2]);
-		expect(ctrl.pending.cache).toEqual([3]);
-	});
-
-	// FLAG: v5 behavioral change — needs investigation (Graph.connect() deps enforcement)
-	it("gate registers internal state nodes in graph", () => {
-		const g = pipelineGraph("wf");
-		const input = node([], { initial: 0 });
-		g.add(input, { name: "input" });
-		g.approvalGate<number>("gated", "input");
-		const desc = g.describe();
-		expect(desc.nodes).toHaveProperty("gated");
-		expect(desc.nodes).toHaveProperty("gated-state::pending");
-		expect(desc.nodes).toHaveProperty("gated-state::isOpen");
-		expect(desc.nodes).toHaveProperty("gated-state::count");
-	});
-
-	it("gate maxPending < 1 throws RangeError", () => {
-		const g = pipelineGraph("wf");
-		const input = node([], { initial: 0 });
-		g.add(input, { name: "input" });
-		expect(() => g.approvalGate<number>("gated", "input", { maxPending: 0 })).toThrow(RangeError);
-	});
-
-	// ── Rollback-on-throw (Audit 2 / C.2 F) ──────────────────────────────
-
-	it("gate.modify throw rolls back in-band emissions; failure record persists", () => {
-		const g = pipelineGraph("wf");
-		const input = node<number>([], { initial: 0 });
-		g.add(input, { name: "input" });
-		const ctrl = g.approvalGate<number>("gated", "input");
-		const collected: number[] = [];
-		ctrl.output.subscribe((msgs) => {
-			for (const m of msgs) if (m[0] === DATA) collected.push(m[1] as number);
-		});
-
-		// Queue two items.
-		input.emit(1);
-		input.emit(2);
-
-		// modify throws on the first item — wrapMutation catches the throw
-		// inside batch (rolls back any in-band downstream emissions for that
-		// wave), then commits a failure audit record OUTSIDE the rolled-back
-		// transaction so the audit trail still captures the failed attempt.
-		expect(() =>
-			ctrl.modify(() => {
-				throw new TypeError("nope");
-			}, 1),
-		).toThrow(TypeError);
-
-		// No item was emitted to the output for the failed modify wave.
-		expect(collected).toEqual([]);
-
-		// Audit log captured a "drop" record with errorType.
-		const dec = ctrl.decisions.entries.cache as readonly { action: string; errorType?: string }[];
-		expect(dec.length).toBeGreaterThanOrEqual(1);
-		const last = dec[dec.length - 1]!;
-		expect(last.action).toBe("drop");
-		expect(last.errorType).toBe("TypeError");
-
-		// A subsequent successful approve still works — gate is not torn down.
-		ctrl.approve(1);
-		expect(collected.length).toBeGreaterThanOrEqual(1);
-	});
-
-	it("gate.modify success path commits a normal `modify` audit record", () => {
-		const g = pipelineGraph("wf");
-		const input = node<number>([], { initial: 0 });
-		g.add(input, { name: "input" });
-		const ctrl = g.approvalGate<number>("gated", "input");
-		input.emit(10);
-
-		ctrl.modify((v) => v * 2, 1);
-
-		const dec = ctrl.decisions.entries.cache as readonly {
-			action: string;
-			errorType?: string;
-		}[];
-		const last = dec[dec.length - 1]!;
-		expect(last.action).toBe("modify");
-		expect(last.errorType).toBeUndefined();
-	});
-
-	// DS-2.7.A QA F3 — pins the approvalGate.output `terminalAsRealInput: true`
-	// opt-in. An immediate-COMPLETE source (no prior DATA) must:
-	//   (a) record a `"teardown"` decision in the audit log
-	//   (b) forward COMPLETE downstream
-	// Without the opt-in the gate held on the terminal-only wave, fn never
-	// fired, and (a) was silently lost.
-	it("gate output records teardown decision and forwards COMPLETE on immediate-COMPLETE source", () => {
-		const g = pipelineGraph("wf");
-		const input = node<number>();
-		g.add(input, { name: "input" });
-		const ctrl = g.approvalGate<number>("gated", "input");
-
-		const types: symbol[] = [];
-		const unsub = ctrl.output.subscribe((msgs) => {
-			for (const m of msgs) types.push(m[0] as symbol);
-		});
-
-		// Immediately COMPLETE the upstream — no DATA was ever queued.
-		input.down([[COMPLETE]]);
-
-		// (a) Audit captures the teardown decision (recorded inside fn).
-		const dec = ctrl.decisions.entries.cache as readonly { action: string }[];
-		expect(dec.map((d) => d.action)).toContain("teardown");
-		// (b) COMPLETE propagates downstream.
-		expect(types).toContain(COMPLETE);
-		unsub();
-	});
-
-	// DS-2.7.A QA F3 — pins the catch `terminalAsRealInput: true` opt-in.
-	// `mode: "completed"` over an immediate-COMPLETE source must call
-	// `recover(cause)` with `cause.kind === "completed"`. Without the opt-in
-	// the gate held on the terminal-only wave and recover never ran.
-	it("catch with mode:'completed' recovers on immediate-COMPLETE source (no prior DATA)", () => {
-		const g = pipelineGraph("wf");
-		const src = node<number>();
-		g.add(src, { name: "src" });
-		const recovered = g.catch<number>(
-			"recovered",
-			src,
-			(cause) => (cause.kind === "completed" ? 777 : -1),
-			{ on: "completed" },
-		);
-		const dataVals: number[] = [];
-		const unsub = recovered.subscribe((msgs) => {
-			for (const m of msgs) if (m[0] === DATA) dataVals.push(m[1] as number);
-		});
-		src.down([[COMPLETE]]);
-		expect(dataVals).toContain(777);
-		unsub();
-	});
-});
diff --git a/src/__tests__/utils/process/process.test.ts b/src/__tests__/utils/process/process.test.ts
deleted file mode 100644
index 8b369b27..00000000
--- a/src/__tests__/utils/process/process.test.ts
+++ /dev/null
@@ -1,1361 +0,0 @@
-import { DATA } from "@graphrefly/pure-ts/core";
-import {
-	type KvStorageTier,
-	kvStorage,
-	memoryAppendLog,
-	memoryBackend,
-} from "@graphrefly/pure-ts/extra";
-import { describe, expect, it, vi } from "vitest";
-import type { CqrsEvent } from "../../../utils/cqrs/index.js";
-import { cqrs } from "../../../utils/cqrs/index.js";
-import {
-	type ProcessInstance,
-	type ProcessStateSnapshot,
-	processInstanceKeyOf,
-	processManager,
-} from "../../../utils/process/index.js";
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-/** Collect all DATA values emitted by a node into an array. Returns unsub. */
-function _collectData<T>(node: {
-	subscribe: (sink: (msgs: readonly [symbol, unknown?][]) => void) => () => void;
-}): {
-	values: T[];
-	unsub: () => void;
-} {
-	const values: T[] = [];
-	const unsub = node.subscribe((msgs) => {
-		for (const m of msgs) {
-			if (m[0] === DATA) values.push(m[1] as T);
-		}
-	});
-	return { values, unsub };
-}
-
-/**
- * Wait for pending async steps to complete.
- * Uses a chain of Promise.resolve() ticks to drain the microtask queue,
- * followed by a setTimeout(0) to catch any subsequent microtask waves.
- */
-async function flushPromises(): Promise<void> {
-	// Multiple Promise.resolve() ticks to drain nested async chains.
-	for (let i = 0; i < 10; i++) {
-		await Promise.resolve();
-	}
-	// setTimeout(0) to yield to any freshly-scheduled microtasks.
-	await new Promise<void>((r) => setTimeout(r, 0));
-	// One more microtask drain after the setTimeout.
-	for (let i = 0; i < 5; i++) {
-		await Promise.resolve();
-	}
-}
-
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-
-describe("processManager", () => {
-	// ── 1. Happy path ────────────────────────────────────────────────────────
-
-	describe("happy path — start + continue", () => {
-		it("start() registers instance with initial state; getState() reflects it", () => {
-			const app = cqrs<{ orderPlaced: { orderId: string } }>("orders");
-			const pm = processManager(app, "fulfillment", {
-				initial: { step: "new", orderId: "" },
-				watching: ["orderPlaced"],
-				steps: {
-					orderPlaced(state, event) {
-						return {
-							outcome: "success",
-							state: { ...state, orderId: event.payload.orderId, step: "processing" },
-						};
-					},
-				},
-			});
-
-			pm.start("corr-1");
-			expect(pm.getState("corr-1")).toEqual({ step: "new", orderId: "" });
-			app.destroy();
-		});
-
-		it("watched event fires → step runs → getState updates", async () => {
-			const app = cqrs<{ orderPlaced: { orderId: string } }>("orders");
-			app.command("placeOrder", (payload: { id: string; corrId: string }, { emit }) => {
-				emit("orderPlaced", { orderId: payload.id });
-			});
-
-			const pm = processManager(app, "fulfillment", {
-				initial: { step: "new", orderId: "" },
-				watching: ["orderPlaced"],
-				steps: {
-					orderPlaced(state, event) {
-						return {
-							outcome: "success",
-							state: { ...state, orderId: event.payload.orderId, step: "processing" },
-						};
-					},
-				},
-			});
-
-			pm.start("corr-1");
-			app.dispatch("placeOrder", { id: "order-42", corrId: "corr-1" }, { correlationId: "corr-1" });
-			await flushPromises();
-
-			const state = pm.getState("corr-1");
-			expect(state?.orderId).toBe("order-42");
-			expect(state?.step).toBe("processing");
-			app.destroy();
-		});
-
-		it("instances audit log receives a record on start", async () => {
-			const app = cqrs<{ orderPlaced: { orderId: string } }>("orders");
-			const pm = processManager(app, "audit-test", {
-				initial: { count: 0 },
-				watching: ["orderPlaced"],
-				steps: {},
-			});
-
-			pm.start("corr-audit");
-			await flushPromises();
-
-			const entries = pm.instances.entries.cache as readonly ProcessInstance<{ count: number }>[];
-			expect(entries.length).toBeGreaterThanOrEqual(1);
-			const first = entries[0]!;
-			expect(first.correlationId).toBe("corr-audit");
-			expect(first.status).toBe("running");
-			app.destroy();
-		});
-
-		it("audit is a read-only view of instances (M7 — no silent mutation)", () => {
-			const app = cqrs("orders");
-			const pm = processManager(app, "alias-test", {
-				initial: {},
-				watching: [],
-				steps: {},
-			});
-			// Shares the canonical log's reactive surface (zero-copy)…
-			expect(pm.audit.entries).toBe(pm.instances.entries);
-			expect(pm.audit.size).toBe(pm.instances.size);
-			// …but is NOT the live bundle and exposes no mutators (M7): a
-			// consumer cannot `append`/`clear` `instances` through the alias.
-			expect(pm.audit).not.toBe(pm.instances);
-			expect("append" in pm.audit).toBe(false);
-			expect("clear" in pm.audit).toBe(false);
-			expect(Object.isFrozen(pm.audit)).toBe(true);
-			app.destroy();
-		});
-
-		it("processInstanceKeyOf returns correlationId", () => {
-			const record: ProcessInstance<number> = {
-				correlationId: "cid-1",
-				state: 0,
-				status: "running",
-				startedAt: 0,
-				updatedAt: 0,
-				t_ns: 0,
-			};
-			expect(processInstanceKeyOf(record)).toBe("cid-1");
-		});
-	});
-
-	// ── 2. Terminate ─────────────────────────────────────────────────────────
-
-	describe("terminate — step returns terminate", () => {
-		it("step returning terminate sets status to terminated and removes from getState", async () => {
-			const app = cqrs<{ done: { result: string } }>("workflow");
-			app.command("finish", (payload: { corrId: string; result: string }, { emit }) => {
-				emit("done", { result: payload.result });
-			});
-
-			const pm = processManager(app, "term-test", {
-				initial: { result: "" },
-				watching: ["done"],
-				steps: {
-					done(_state, event) {
-						return {
-							outcome: "terminate",
-							state: { result: event.payload.result },
-							reason: "all done",
-						};
-					},
-				},
-			});
-
-			pm.start("corr-term");
-			app.dispatch(
-				"finish",
-				{ corrId: "corr-term", result: "success" },
-				{ correlationId: "corr-term" },
-			);
-			await flushPromises();
-
-			// After terminate, getState should return undefined (removed from active).
-			expect(pm.getState("corr-term")).toBeUndefined();
-
-			// Audit log should contain a terminated record.
-			const entries = pm.instances.entries.cache as readonly ProcessInstance<{ result: string }>[];
-			const terminated = entries.find((e) => e.status === "completed");
-			expect(terminated).toBeDefined();
-			expect(terminated?.correlationId).toBe("corr-term");
-			app.destroy();
-		});
-
-		it("subsequent events for a terminated correlationId are ignored", async () => {
-			let stepCallCount = 0;
-			const app = cqrs<{ ev: unknown }>("workflow");
-			app.command("fireEv", (_payload: unknown, { emit }) => {
-				emit("ev", {});
-			});
-
-			const pm = processManager(app, "term-ignore", {
-				initial: { n: 0 },
-				watching: ["ev"],
-				steps: {
-					ev(state) {
-						stepCallCount++;
-						if (stepCallCount === 1) {
-							return { outcome: "terminate", state };
-						}
-						// Should never be called a second time.
-						return { outcome: "success", state: { ...state, n: state.n + 1 } };
-					},
-				},
-			});
-
-			pm.start("corr-ignore");
-			app.dispatch("fireEv", {}, { correlationId: "corr-ignore" });
-			await flushPromises();
-
-			// Fire a second event with the same correlationId — should be ignored.
-			app.dispatch("fireEv", {}, { correlationId: "corr-ignore" });
-			await flushPromises();
-
-			expect(stepCallCount).toBe(1);
-			app.destroy();
-		});
-
-		it("isTerminal predicate terminates after continue step", async () => {
-			// In CQRS pattern, commands and events have distinct names.
-			// Command "doTick" emits event "ticked"; processManager watches "ticked".
-			const app = cqrs<{ ticked: unknown }>("workflow");
-			app.command("doTick", (_payload: unknown, { emit }) => {
-				emit("ticked", {});
-			});
-
-			const pm = processManager(app, "terminal-pred", {
-				initial: { count: 0 },
-				watching: ["ticked"],
-				steps: {
-					ticked(state) {
-						return { outcome: "success", state: { count: state.count + 1 } };
-					},
-				},
-				isTerminal: (state) => state.count >= 2,
-			});
-
-			pm.start("corr-pred");
-			app.dispatch("doTick", {}, { correlationId: "corr-pred" });
-			await flushPromises();
-			// count=1, not terminal yet
-			expect(pm.getState("corr-pred")).toEqual({ count: 1 });
-
-			app.dispatch("doTick", {}, { correlationId: "corr-pred" });
-			await flushPromises();
-			// count=2, isTerminal → terminated
-			expect(pm.getState("corr-pred")).toBeUndefined();
-
-			const entries = pm.instances.entries.cache as readonly ProcessInstance<{ count: number }>[];
-			const terminated = entries.find((e) => e.status === "completed");
-			expect(terminated).toBeDefined();
-			app.destroy();
-		});
-	});
-
-	// ── 3. Fail + compensate ──────────────────────────────────────────────────
-
-	describe("fail + compensate", () => {
-		it("step returning outcome:failure triggers compensate; status becomes compensated", async () => {
-			let compensateCalled = false;
-			const app = cqrs<{ ev: unknown }>("workflow");
-			app.command("fireEv", (_payload: unknown, { emit }) => {
-				emit("ev", {});
-			});
-
-			const pm = processManager(app, "fail-test", {
-				initial: { value: 1 },
-				watching: ["ev"],
-				steps: {
-					ev() {
-						return { outcome: "failure", error: new Error("step failed") };
-					},
-				},
-				compensate(state, _error) {
-					compensateCalled = true;
-					expect(state).toEqual({ value: 1 });
-				},
-			});
-
-			pm.start("corr-fail");
-			app.dispatch("fireEv", {}, { correlationId: "corr-fail" });
-			await flushPromises();
-
-			expect(compensateCalled).toBe(true);
-			expect(pm.getState("corr-fail")).toBeUndefined();
-
-			const entries = pm.instances.entries.cache as readonly ProcessInstance<unknown>[];
-			const comp = entries.find((e) => e.status === "cancelled");
-			expect(comp?.correlationId).toBe("corr-fail");
-			app.destroy();
-		});
-
-		it("step throwing triggers compensate; status becomes compensated", async () => {
-			let compensateCalled = false;
-			const app = cqrs<{ ev: unknown }>("workflow");
-			app.command("fireEv", (_payload: unknown, { emit }) => {
-				emit("ev", {});
-			});
-
-			const pm = processManager(app, "throw-test", {
-				initial: {},
-				watching: ["ev"],
-				steps: {
-					ev() {
-						throw new Error("step threw");
-					},
-				},
-				compensate(_state, _error) {
-					compensateCalled = true;
-				},
-			});
-
-			pm.start("corr-throw");
-			app.dispatch("fireEv", {}, { correlationId: "corr-throw" });
-			await flushPromises();
-
-			expect(compensateCalled).toBe(true);
-			expect(pm.getState("corr-throw")).toBeUndefined();
-			app.destroy();
-		});
-
-		it("without compensate, fail sets status to failed", async () => {
-			const app = cqrs<{ ev: unknown }>("workflow");
-			app.command("fireEv", (_payload: unknown, { emit }) => {
-				emit("ev", {});
-			});
-
-			const pm = processManager(app, "no-compensate", {
-				initial: {},
-				watching: ["ev"],
-				steps: {
-					ev() {
-						return { outcome: "failure", error: new Error("boom") };
-					},
-				},
-				// no compensate
-			});
-
-			pm.start("corr-nocomp");
-			app.dispatch("fireEv", {}, { correlationId: "corr-nocomp" });
-			await flushPromises();
-
-			const entries = pm.instances.entries.cache as readonly ProcessInstance<unknown>[];
-			const failed = entries.find((e) => e.status === "errored");
-			expect(failed?.correlationId).toBe("corr-nocomp");
-			app.destroy();
-		});
-	});
-
-	// ── 4. Retry ─────────────────────────────────────────────────────────────
-
-	describe("retry", () => {
-		it("retries up to retryMax on throw; succeeds on attempt N+1", async () => {
-			let attempts = 0;
-			const app = cqrs<{ ev: unknown }>("workflow");
-			app.command("fireEv", (_payload: unknown, { emit }) => {
-				emit("ev", {});
-			});
-
-			const pm = processManager(app, "retry-test", {
-				initial: { done: false },
-				watching: ["ev"],
-				steps: {
-					ev(state) {
-						attempts++;
-						if (attempts < 3) throw new Error(`fail attempt ${attempts}`);
-						return { outcome: "success", state: { ...state, done: true } };
-					},
-				},
-				retryMax: 3,
-				backoffMs: [0],
-			});
-
-			pm.start("corr-retry");
-			app.dispatch("fireEv", {}, { correlationId: "corr-retry" });
-			await flushPromises();
-			// Attempt 1 fails, 2 fails, 3 succeeds.
-			expect(attempts).toBe(3);
-			expect(pm.getState("corr-retry")).toEqual({ done: true });
-			app.destroy();
-		});
-
-		it("exhausts retryMax → fails and triggers compensate", async () => {
-			let attempts = 0;
-			let compensateCalled = false;
-			const app = cqrs<{ ev: unknown }>("workflow");
-			app.command("fireEv", (_payload: unknown, { emit }) => {
-				emit("ev", {});
-			});
-
-			const pm = processManager(app, "exhaust-retry", {
-				initial: {},
-				watching: ["ev"],
-				steps: {
-					ev() {
-						attempts++;
-						throw new Error("always fails");
-					},
-				},
-				retryMax: 2,
-				backoffMs: [0],
-				compensate(_state, _error) {
-					compensateCalled = true;
-				},
-			});
-
-			pm.start("corr-exhaust");
-			app.dispatch("fireEv", {}, { correlationId: "corr-exhaust" });
-			await flushPromises();
-
-			// 1 initial + 2 retries = 3 total attempts
-			expect(attempts).toBe(3);
-			expect(compensateCalled).toBe(true);
-			expect(pm.getState("corr-exhaust")).toBeUndefined();
-			app.destroy();
-		});
-	});
-
-	// ── 5. Cancel ────────────────────────────────────────────────────────────
-
-	describe("cancel", () => {
-		it("cancel() on running instance triggers compensate + marks compensated", async () => {
-			let compensateCalled = false;
-			const app = cqrs("workflow");
-
-			const pm = processManager(app, "cancel-test", {
-				initial: { value: 42 },
-				watching: [],
-				steps: {},
-				compensate(_state, _error) {
-					compensateCalled = true;
-				},
-			});
-
-			pm.start("corr-cancel");
-			expect(pm.getState("corr-cancel")).toEqual({ value: 42 });
-
-			pm.cancel("corr-cancel", "user requested");
-			await flushPromises();
-
-			expect(compensateCalled).toBe(true);
-			expect(pm.getState("corr-cancel")).toBeUndefined();
-
-			const entries = pm.instances.entries.cache as readonly ProcessInstance<unknown>[];
-			const comp = entries.find((e) => e.status === "cancelled");
-			expect(comp?.correlationId).toBe("corr-cancel");
-			app.destroy();
-		});
-
-		it("cancel() on non-running instance is a no-op", async () => {
-			let compensateCalled = false;
-			const app = cqrs("workflow");
-
-			const pm = processManager(app, "cancel-noop", {
-				initial: {},
-				watching: [],
-				steps: {},
-				compensate() {
-					compensateCalled = true;
-				},
-			});
-
-			// Never started — cancel is a no-op.
-			pm.cancel("not-started");
-			await flushPromises();
-			expect(compensateCalled).toBe(false);
-			app.destroy();
-		});
-
-		it("start() is idempotent — second call with same correlationId is no-op", () => {
-			const app = cqrs("workflow");
-			const pm = processManager(app, "idempotent", {
-				initial: { n: 0 },
-				watching: [],
-				steps: {},
-			});
-
-			pm.start("corr-idem");
-			pm.start("corr-idem"); // second call — no-op
-
-			const entries = pm.instances.entries.cache as readonly ProcessInstance<{ n: number }>[];
-			const running = entries.filter(
-				(e) => e.correlationId === "corr-idem" && e.status === "running",
-			);
-			// Only one start record.
-			expect(running.length).toBe(1);
-			app.destroy();
-		});
-	});
-
-	// ── 6. Multiple instances ─────────────────────────────────────────────────
-
-	describe("multiple instances", () => {
-		it("two correlationIds running concurrently receive their own steps independently", async () => {
-			const _results: Record<string, string> = {};
-			const app = cqrs<{ ev: { value: string } }>("workflow");
-			app.command("fireEv", (payload: { value: string }, { emit }) => {
-				emit("ev", { value: payload.value });
-			});
-
-			const pm = processManager(app, "multi", {
-				initial: { value: "" },
-				watching: ["ev"],
-				steps: {
-					ev(state, event) {
-						return { outcome: "success", state: { ...state, value: event.payload.value } };
-					},
-				},
-			});
-
-			pm.start("corr-A");
-			pm.start("corr-B");
-
-			// Dispatch with correlationId = corr-A
-			app.dispatch("fireEv", { value: "hello-A" }, { correlationId: "corr-A" });
-			// Dispatch with correlationId = corr-B
-			app.dispatch("fireEv", { value: "hello-B" }, { correlationId: "corr-B" });
-
-			await flushPromises();
-
-			expect(pm.getState("corr-A")?.value).toBe("hello-A");
-			expect(pm.getState("corr-B")?.value).toBe("hello-B");
-			app.destroy();
-		});
-
-		it("event without correlationId is ignored by all instances", async () => {
-			let stepCallCount = 0;
-			const app = cqrs<{ ev: unknown }>("workflow");
-			app.command("fireEv", (_payload: unknown, { emit }) => {
-				emit("ev", {});
-			});
-
-			const pm = processManager(app, "no-corr", {
-				initial: {},
-				watching: ["ev"],
-				steps: {
-					ev(state) {
-						stepCallCount++;
-						return { outcome: "success", state };
-					},
-				},
-			});
-
-			pm.start("corr-X");
-			// Dispatch WITHOUT correlationId — should be ignored.
-			app.dispatch("fireEv", {});
-			await flushPromises();
-
-			expect(stepCallCount).toBe(0);
-			app.destroy();
-		});
-
-		it("events for unknown correlationId are ignored", async () => {
-			let stepCallCount = 0;
-			const app = cqrs<{ ev: unknown }>("workflow");
-			app.command("fireEv", (_payload: unknown, { emit }) => {
-				emit("ev", {});
-			});
-
-			const pm = processManager(app, "unknown-corr", {
-				initial: {},
-				watching: ["ev"],
-				steps: {
-					ev(state) {
-						stepCallCount++;
-						return { outcome: "success", state };
-					},
-				},
-			});
-
-			pm.start("corr-Y");
-			// Dispatch with a different correlationId that has no instance.
-			app.dispatch("fireEv", {}, { correlationId: "corr-other" });
-			await flushPromises();
-
-			expect(stepCallCount).toBe(0);
-			app.destroy();
-		});
-	});
-
-	// ── 7. Schedule (timer) ───────────────────────────────────────────────────
-
-	describe("schedule — step returns schedule", () => {
-		it("schedule fires synthetic event after delay and routes to matching step", async () => {
-			vi.useFakeTimers();
-			const stepLog: string[] = [];
-			const app = cqrs<{ start: unknown; timeout: unknown }>("workflow");
-			app.command("fireStart", (_payload: unknown, { emit }) => {
-				emit("start", {});
-			});
-
-			const pm = processManager(app, "sched-test", {
-				initial: { phase: "init" },
-				watching: ["start", "timeout"],
-				steps: {
-					start(state) {
-						stepLog.push("start");
-						return {
-							outcome: "success",
-							state: { ...state, phase: "waiting" },
-							schedule: { afterMs: 100, eventType: "timeout" },
-						};
-					},
-					timeout(state) {
-						stepLog.push("timeout");
-						return { outcome: "terminate", state: { ...state, phase: "timed-out" } };
-					},
-				},
-			});
-
-			pm.start("corr-sched");
-			app.dispatch("fireStart", {}, { correlationId: "corr-sched" });
-
-			// Flush microtasks so handleStepResult runs and sets up the fromTimer.
-			for (let i = 0; i < 20; i++) await Promise.resolve();
-			// Now advance fake timers past the scheduled delay.
-			await vi.advanceTimersByTimeAsync(200);
-			// Flush microtasks so the timeout step completes.
-			for (let i = 0; i < 20; i++) await Promise.resolve();
-
-			vi.useRealTimers();
-
-			expect(stepLog).toContain("start");
-			expect(stepLog).toContain("timeout");
-			// After terminate, instance should be gone.
-			expect(pm.getState("corr-sched")).toBeUndefined();
-			app.destroy();
-		});
-
-		it("schedule does not fire if instance is cancelled before timer fires", async () => {
-			vi.useFakeTimers();
-			const stepLog: string[] = [];
-			const app = cqrs<{ start: unknown; timeout: unknown }>("workflow");
-			app.command("fireStart", (_payload: unknown, { emit }) => {
-				emit("start", {});
-			});
-
-			const pm = processManager(app, "sched-cancel", {
-				initial: { phase: "init" },
-				watching: ["start", "timeout"],
-				steps: {
-					start(state) {
-						stepLog.push("start");
-						return {
-							outcome: "success",
-							state: { ...state, phase: "waiting" },
-							schedule: { afterMs: 500, eventType: "timeout" },
-						};
-					},
-					timeout(state) {
-						stepLog.push("timeout");
-						return { outcome: "terminate", state };
-					},
-				},
-			});
-
-			pm.start("corr-sched-cancel");
-			app.dispatch("fireStart", {}, { correlationId: "corr-sched-cancel" });
-
-			// Flush microtasks so start step completes and timer is registered.
-			for (let i = 0; i < 20; i++) await Promise.resolve();
-			expect(stepLog).toContain("start");
-
-			// Cancel the instance BEFORE the 500ms timer fires.
-			pm.cancel("corr-sched-cancel");
-			// Flush microtasks for compensation.
-			for (let i = 0; i < 20; i++) await Promise.resolve();
-
-			// Now advance timers past the 500ms delay — timer fires, but the
-			// guard in the timer callback checks activeInstances (instance gone)
-			// so the timeout step is NOT called.
-			await vi.advanceTimersByTimeAsync(600);
-			for (let i = 0; i < 10; i++) await Promise.resolve();
-
-			vi.useRealTimers();
-
-			expect(stepLog).not.toContain("timeout");
-			app.destroy();
-		});
-	});
-
-	// ── 8. Async step ────────────────────────────────────────────────────────
-
-	describe("async step (Promise)", () => {
-		it("step returning a Promise resolves correctly", async () => {
-			const app = cqrs<{ ev: { value: number } }>("workflow");
-			app.command("fireEv", (payload: { value: number }, { emit }) => {
-				emit("ev", { value: payload.value });
-			});
-
-			const pm = processManager(app, "async-test", {
-				initial: { doubled: 0 },
-				watching: ["ev"],
-				steps: {
-					async ev(state, event) {
-						// Simulate async work.
-						await Promise.resolve();
-						return { outcome: "success", state: { ...state, doubled: event.payload.value * 2 } };
-					},
-				},
-			});
-
-			pm.start("corr-async");
-			app.dispatch("fireEv", { value: 5 }, { correlationId: "corr-async" });
-			await flushPromises();
-
-			expect(pm.getState("corr-async")?.doubled).toBe(10);
-			app.destroy();
-		});
-	});
-
-	// ── 9. Side-effect emit ───────────────────────────────────────────────────
-
-	describe("side-effect emit from step result", () => {
-		it("step result emit adds events to CQRS graph", async () => {
-			const app = cqrs<{ trigger: unknown; sideEffect: { from: string } }>("workflow");
-			app.command("fireTrigger", (_payload: unknown, { emit }) => {
-				emit("trigger", {});
-			});
-			// Register the side-effect event stream so dispatch can see it.
-			const sideEffectEvents = app.event("sideEffect");
-
-			const pm = processManager(app, "emit-test", {
-				initial: {},
-				watching: ["trigger"],
-				steps: {
-					trigger(state) {
-						return {
-							outcome: "success",
-							state,
-							emit: [{ type: "sideEffect", payload: { from: "step" } }],
-						};
-					},
-				},
-			});
-
-			pm.start("corr-emit");
-			app.dispatch("fireTrigger", {}, { correlationId: "corr-emit" });
-			await flushPromises();
-
-			// The side-effect event should have been appended.
-			const events = sideEffectEvents.cache as readonly { payload: { from: string } }[];
-			expect(events.length).toBeGreaterThanOrEqual(1);
-			const found = events.find(
-				(e) => (e as { payload: { from: string } }).payload.from === "step",
-			);
-			expect(found).toBeDefined();
-			app.destroy();
-		});
-	});
-
-	// ── 10. Concurrency / dispose ────────────────────────────────────────────
-
-	describe("concurrency and dispose", () => {
-		it("cancel() during async step doesn't double-compensate (C1)", async () => {
-			let compensateCallCount = 0;
-			let resolveStep!: () => void;
-			const stepDone = new Promise<void>((r) => {
-				resolveStep = r;
-			});
-
-			const app = cqrs<{ ev: unknown }>("workflow");
-			app.command("fireEv", (_payload: unknown, { emit }) => {
-				emit("ev", {});
-			});
-
-			const pm = processManager(app, "double-cancel", {
-				initial: {},
-				watching: ["ev"],
-				steps: {
-					ev(_state) {
-						// Async step: pause until resolveStep is called.
-						return new Promise<never>(() => {
-							resolveStep();
-							// Never resolves — simulates a long-running step.
-						}) as Promise<{ outcome: "success"; state: Record<string, never> }>;
-					},
-				},
-				compensate(_state, _error) {
-					compensateCallCount++;
-				},
-			});
-
-			pm.start("corr-double");
-			app.dispatch("fireEv", {}, { correlationId: "corr-double" });
-
-			// Wait until the step has started (step body executed).
-			await stepDone;
-
-			// cancel() while the step is in-flight.
-			pm.cancel("corr-double");
-			await flushPromises();
-
-			// compensate should have been called exactly once (from cancel).
-			// The step itself never settles, so it doesn't trigger a second compensate.
-			expect(compensateCallCount).toBe(1);
-			app.destroy();
-		});
-
-		it("double-cancel is idempotent (C1)", async () => {
-			let compensateCallCount = 0;
-			const app = cqrs("workflow");
-
-			const pm = processManager(app, "idempotent-cancel", {
-				initial: { v: 0 },
-				watching: [],
-				steps: {},
-				compensate(_state, _error) {
-					compensateCallCount++;
-				},
-			});
-
-			pm.start("corr-dc");
-			// Two cancel calls in rapid succession — only one compensation should run.
-			pm.cancel("corr-dc");
-			pm.cancel("corr-dc"); // second call — no-op after eager delete
-			await flushPromises();
-
-			expect(compensateCallCount).toBe(1);
-			app.destroy();
-		});
-
-		it("multiple events for same correlationId serialize (C2)", async () => {
-			const stateLog: number[] = [];
-			const app = cqrs<{ ev: unknown }>("workflow");
-			app.command("fireEv", (_payload: unknown, { emit }) => {
-				emit("ev", {});
-			});
-
-			const pm = processManager(app, "serialize", {
-				initial: { count: 0 },
-				watching: ["ev"],
-				steps: {
-					ev(state) {
-						// Increment count; use async to make serialization observable.
-						return Promise.resolve().then(() => {
-							const next = { count: state.count + 1 };
-							stateLog.push(next.count);
-							return { outcome: "success" as const, state: next };
-						});
-					},
-				},
-			});
-
-			pm.start("corr-ser");
-
-			// Dispatch two commands — they emit two events in the same reactive wave.
-			app.dispatch("fireEv", {}, { correlationId: "corr-ser" });
-			app.dispatch("fireEv", {}, { correlationId: "corr-ser" });
-			await flushPromises();
-
-			// Both steps must have run and each must have seen the prior step's output.
-			// stateLog should be [1, 2] not [1, 1] (C2: no state corruption).
-			expect(stateLog).toEqual([1, 2]);
-			expect(pm.getState("corr-ser")).toEqual({ count: 2 });
-			app.destroy();
-		});
-
-		it("dispose() releases watch subscriptions and stops processing (C3)", async () => {
-			let stepCallCount = 0;
-			const app = cqrs<{ ev: unknown }>("workflow");
-			app.command("fireEv", (_payload: unknown, { emit }) => {
-				emit("ev", {});
-			});
-
-			const pm = processManager(app, "dispose-test", {
-				initial: { n: 0 },
-				watching: ["ev"],
-				steps: {
-					ev(state) {
-						stepCallCount++;
-						return { outcome: "success", state: { n: state.n + 1 } };
-					},
-				},
-			});
-
-			pm.start("corr-dispose");
-
-			// Verify step runs before dispose.
-			app.dispatch("fireEv", {}, { correlationId: "corr-dispose" });
-			await flushPromises();
-			expect(stepCallCount).toBe(1);
-
-			// Dispose — releases watch subscriptions.
-			pm.dispose();
-
-			// Dispatch another event — should NOT reach the step (subscriptions gone).
-			app.dispatch("fireEv", {}, { correlationId: "corr-dispose" });
-			await flushPromises();
-
-			expect(stepCallCount).toBe(1); // unchanged
-			app.destroy();
-		});
-
-		it("dispose() unmounts the audit-log + seq-cursor subgraph (EH-16, Tier 6.5 3.3)", () => {
-			const app = cqrs("eh16-app");
-			const pm1 = processManager(app, "wf", {
-				initial: { value: 0 },
-				watching: ["fireEv" as const],
-				steps: { fireEv: (s) => ({ outcome: "success" as const, state: s }) },
-			});
-			// Subgraph mounted at __processManagers__/wf — its `seq` cursor
-			// is reachable via the qualified path. Pre-dispose: present.
-			expect(app.tryResolve("__processManagers__/wf::seq")).toBeDefined();
-			pm1.dispose();
-			// After dispose, the mount is gone — repeated create-dispose
-			// cycles no longer leak nodes on the CQRS graph.
-			expect(app.tryResolve("__processManagers__/wf::seq")).toBeUndefined();
-			// A fresh manager with the SAME name must construct cleanly post-dispose.
-			const pm2 = processManager(app, "wf", {
-				initial: { value: 0 },
-				watching: ["fireEv" as const],
-				steps: { fireEv: (s) => ({ outcome: "success" as const, state: s }) },
-			});
-			expect(app.tryResolve("__processManagers__/wf::seq")).toBeDefined();
-			pm2.dispose();
-			expect(app.tryResolve("__processManagers__/wf::seq")).toBeUndefined();
-			app.destroy();
-		});
-	});
-
-	// ── 11. persistence — eventStorage wiring (Audit 3 + Audit 4) ──────────
-
-	describe("persistence", () => {
-		it("eventStorage tiers persist `_process_<name>_started` events for each start()", async () => {
-			const app = cqrs("workflow");
-			const tier = memoryAppendLog<CqrsEvent>({ name: "process-events" });
-
-			const pm = processManager(app, "persisted", {
-				initial: { step: 0 },
-				watching: [],
-				steps: {},
-				persistence: { eventStorage: [tier] },
-			});
-
-			pm.start("corr-1");
-			pm.start("corr-2");
-			await flushPromises();
-			await tier.flush?.();
-
-			const result = await tier.loadEntries?.();
-			const startedType = "_process_persisted_started";
-			const started = (result?.entries ?? []).filter((e) => e.type === startedType);
-
-			// Pins the auto-wired `cqrs.attachEventStorage(eventStorage)`
-			// plumbing — every `start()` produces at least one persisted
-			// started-event. The impl wires storage to BOTH the fan-in event
-			// stream and the per-aggregate streams (per Audit 4), so the same
-			// event may be persisted under multiple backend keys; what we
-			// assert is the correlationId set is round-tripped end-to-end.
-			expect(started.length).toBeGreaterThanOrEqual(2);
-			const correlationIds = new Set(started.map((e) => e.aggregateId));
-			expect(correlationIds).toEqual(new Set(["corr-1", "corr-2"]));
-
-			app.destroy();
-		});
-
-		it("stateStorage round-trip — save on start, restore() on fresh manager (Tier 6.5 3.5)", async () => {
-			// Shared backend so the second processManager sees what the first wrote.
-			const backend = memoryBackend();
-			const tier1: KvStorageTier<unknown> = kvStorage(backend, { name: "states" });
-
-			const app1 = cqrs("wf-app-1");
-			app1.command("dispatchEv", (_payload: unknown, { emit }) => {
-				emit("fireEv", _payload);
-			});
-			const pm1 = processManager(app1, "wf", {
-				initial: { step: "init" },
-				watching: ["fireEv" as const],
-				steps: {
-					fireEv: (_s) => ({ outcome: "success" as const, state: { step: "advanced" } }),
-				},
-				persistence: {
-					stateStorage: [tier1 as KvStorageTier<ProcessStateSnapshot<{ step: string }>>],
-				},
-			});
-			pm1.start("corr-A");
-			pm1.start("corr-B");
-			app1.dispatch("dispatchEv", {}, { correlationId: "corr-A" });
-			await flushPromises();
-			await tier1.flush?.();
-
-			// First manager goes away (simulate restart).
-			pm1.dispose();
-			app1.destroy();
-
-			// Fresh manager + fresh CQRS graph; state tier reattached.
-			const app2 = cqrs("wf-app-2");
-			app2.command("dispatchEv", (_payload: unknown, { emit }) => {
-				emit("fireEv", _payload);
-			});
-			const tier2: KvStorageTier<unknown> = kvStorage(backend, { name: "states" });
-			const pm2 = processManager(app2, "wf", {
-				initial: { step: "init" },
-				watching: ["fireEv" as const],
-				steps: {
-					fireEv: (s) => ({ outcome: "success" as const, state: { ...s, step: "advanced-2" } }),
-				},
-				persistence: {
-					stateStorage: [tier2 as KvStorageTier<ProcessStateSnapshot<{ step: string }>>],
-				},
-			});
-			// B5: restore() returns Promise<void> that resolves when
-			// restoreState transitions to "completed". The count of restored
-			// instances is observable via getState() / restoreState.cache.
-			await pm2.restore();
-			expect(pm2.restoreState.cache).toBe("completed");
-			// corr-A had advanced before restart; the persisted state reflects "advanced".
-			expect(pm2.getState("corr-A")).toEqual({ step: "advanced" });
-			expect(pm2.getState("corr-B")).toEqual({ step: "init" });
-
-			pm2.dispose();
-			app2.destroy();
-		});
-
-		it("stateStorage deletes terminal records (Tier 6.5 3.5)", async () => {
-			const tier: KvStorageTier<unknown> = kvStorage(memoryBackend(), { name: "states" });
-			const app = cqrs("wf-term");
-			app.command("dispatchEv", (_payload: unknown, { emit }) => {
-				emit("fireEv", _payload);
-			});
-			const pm = processManager(app, "wf", {
-				initial: { step: "init" },
-				watching: ["fireEv" as const],
-				steps: {
-					fireEv: (s) => ({ outcome: "terminate" as const, state: { ...s, step: "done" } }),
-				},
-				persistence: {
-					stateStorage: [tier as KvStorageTier<ProcessStateSnapshot<{ step: string }>>],
-				},
-			});
-			pm.start("corr-T");
-			expect(await tier.load("corr-T")).toBeDefined();
-			app.dispatch("dispatchEv", {}, { correlationId: "corr-T" });
-			await flushPromises();
-			expect(await tier.load("corr-T")).toBeUndefined();
-			pm.dispose();
-			app.destroy();
-		});
-	});
-
-	// ── 12. handlerVersion stamping ───────────────────────────────────────────
-
-	describe("handlerVersion", () => {
-		it("handlerVersion is stamped onto audit records", async () => {
-			const app = cqrs("workflow");
-
-			const pm = processManager(app, "version-test", {
-				initial: {},
-				watching: [],
-				steps: {},
-				handlerVersion: { id: "fulfillment-handler", version: "1.2.3" },
-			});
-
-			pm.start("corr-v");
-			await flushPromises();
-
-			const entries = pm.instances.entries.cache as readonly ProcessInstance<unknown>[];
-			const record = entries.find((e) => e.correlationId === "corr-v");
-			expect(record?.handlerVersion).toEqual({ id: "fulfillment-handler", version: "1.2.3" });
-			app.destroy();
-		});
-	});
-
-	// ── 13. B4 — persistState inside wrapMutation rollback boundary ──────
-	//
-	// D2 (locked 2026-05-01): a sync-throwing stateStorage tier must roll
-	// back the audit-log entry too. Pre-fix: persistState lived OUTSIDE the
-	// wrapMutation in `start()`, so a tier that threw synchronously would
-	// leave the audit log saying "running" while the snapshot was missing.
-
-	describe("B4 — persistState rollback (D2)", () => {
-		it("sync-throwing tier rolls back the audit-log entry too", () => {
-			const app = cqrs("rollback-app");
-			// Tier whose save() synchronously throws on write attempts.
-			const sinkErr = new Error("sync-throwing tier");
-			const throwingTier: KvStorageTier<ProcessStateSnapshot<{ step: string }>> = {
-				load() {
-					return undefined;
-				},
-				save() {
-					throw sinkErr;
-				},
-				list() {
-					return [];
-				},
-			};
-			const pm = processManager(app, "rollback", {
-				initial: { step: "init" },
-				watching: [],
-				steps: {},
-				persistence: { stateStorage: [throwingTier] },
-				// Don't auto-restore: this test is about start(), not restore().
-				deferRestore: true,
-			});
-
-			expect(() => pm.start("corr-X")).toThrow("sync-throwing tier");
-
-			// B4 assertion: audit log empty after the throw — neither the
-			// "running" record nor any failure record was committed (the
-			// in-band batch was rolled back). The state snapshot is also
-			// missing because save() never returned. Coherent failure mode.
-			const entries = pm.instances.entries.cache as
-				| readonly ProcessInstance<{ step: string }>[]
-				| undefined;
-			expect(entries ?? []).toEqual([]);
-
-			pm.dispose();
-			app.destroy();
-		});
-	});
-
-	// ── 14. B5 — fully reactive restore() ────────────────────────────────
-	//
-	// D3 / D5 (locked 2026-05-01): restore() must not rely on async/await
-	// inside the reactive layer. Watched events are valve-gated on a
-	// `restoreState` lifecycle node so events arriving mid-restore do NOT
-	// race with the fallback `opts.initial` state, and dispose() during
-	// restore does NOT mutate closure state on a torn-down manager.
-
-	describe("B5 — reactive restore (D3 + D5)", () => {
-		it("watch event mid-restore is valve-deferred and processed after gate opens", async () => {
-			// Scriptable tier: tier.list() returns one key immediately, but
-			// tier.load() returns a Promise we control via a deferred
-			// resolver — emulating "snapshot loads slowly while events
-			// arrive at the cqrs source."
-			let loadResolver: ((v: ProcessStateSnapshot<{ n: number }>) => void) | undefined;
-			const loadPromise = new Promise<ProcessStateSnapshot<{ n: number }>>((res) => {
-				loadResolver = res;
-			});
-			const fakeTier: KvStorageTier<ProcessStateSnapshot<{ n: number }>> = {
-				load() {
-					return loadPromise;
-				},
-				save() {
-					return undefined;
-				},
-				list() {
-					return ["corr-mid"];
-				},
-			};
-
-			const app = cqrs<{ tickEv: { delta: number } }>("mid-app");
-			app.command("tick", (payload: { delta: number; corrId: string }, { emit }) => {
-				emit("tickEv", { delta: payload.delta });
-			});
-
-			let stepCallCount = 0;
-			const pm = processManager(app, "mid-restore", {
-				initial: { n: 0 },
-				watching: ["tickEv"],
-				steps: {
-					tickEv(state, event) {
-						stepCallCount++;
-						return {
-							outcome: "success" as const,
-							state: { n: state.n + event.payload.delta },
-						};
-					},
-				},
-				persistence: { stateStorage: [fakeTier] },
-				// Auto-restore default: the factory kicks off restore on
-				// construction, but tier.load is held open by loadPromise.
-			});
-
-			expect(pm.restoreState.cache).toBe("pending");
-
-			// Dispatch an event while restore is still pending — it lands
-			// on the cqrs event log but the watch valve is closed.
-			app.dispatch("tick", { delta: 5, corrId: "corr-mid" }, { correlationId: "corr-mid" });
-			await flushPromises();
-
-			// No step yet: the valve dropped the event because gate was closed.
-			expect(stepCallCount).toBe(0);
-			expect(pm.restoreState.cache).toBe("pending");
-
-			// Resolve the load: snapshot arrives, restoreState flips to
-			// "completed", valve opens, the queued event is delivered, step runs.
-			loadResolver!({
-				correlationId: "corr-mid",
-				state: { n: 100 },
-				status: "running",
-				startedAt: 0,
-				updatedAt: 0,
-			});
-			await pm.restore();
-			expect(pm.restoreState.cache).toBe("completed");
-			await flushPromises();
-
-			expect(stepCallCount).toBe(1);
-			// Step ran against the RESTORED state (n=100), not the
-			// fallback opts.initial (n=0). 100 + 5 = 105.
-			expect(pm.getState("corr-mid")).toEqual({ n: 105 });
-
-			pm.dispose();
-			app.destroy();
-		});
-
-		it("dispose() mid-restore — no post-dispose mutations; restore() Promise resolves via teardown", async () => {
-			// Hold tier.load() open so restore() is pending when dispose() fires.
-			let loadResolver: ((v: ProcessStateSnapshot<{ n: number }>) => void) | undefined;
-			const loadPromise = new Promise<ProcessStateSnapshot<{ n: number }>>((res) => {
-				loadResolver = res;
-			});
-			const fakeTier: KvStorageTier<ProcessStateSnapshot<{ n: number }>> = {
-				load() {
-					return loadPromise;
-				},
-				save() {
-					return undefined;
-				},
-				list() {
-					return ["corr-mid-dispose"];
-				},
-			};
-
-			const app = cqrs("dispose-mid-app");
-			const pm = processManager(app, "dispose-mid", {
-				initial: { n: 0 },
-				watching: [],
-				steps: {},
-				persistence: { stateStorage: [fakeTier] },
-			});
-
-			expect(pm.restoreState.cache).toBe("pending");
-
-			// Kick off the public restore() promise — it should resolve
-			// when dispose() tears down restoreState (not hang). The
-			// firstWhere COMPLETE-rejection is swallowed at the API edge.
-			const restorePromise = pm.restore();
-
-			// dispose() while load is in flight.
-			pm.dispose();
-			// restoreState stayed at "pending" (no transition fired before
-			// teardown); subsequent reads of `.cache` see the last-emitted
-			// value. The "alive" check uses the closure `_disposed` flag,
-			// not the reactive node — pre-empts the teardown cascade.
-			expect(pm.restoreState.cache).toBe("pending");
-
-			// restore() promise resolves (does NOT hang) via the .catch
-			// swallowing firstWhere's COMPLETE-rejection on teardown.
-			await restorePromise;
-
-			// Now resolve the load — the snapshot arrives, but the
-			// restoreEffect has been torn down by dispose() and the
-			// `_disposed` guard inside the effect fires.
-			// No mutation to instanceStates / activeInstances.
-			loadResolver!({
-				correlationId: "corr-mid-dispose",
-				state: { n: 999 },
-				status: "running",
-				startedAt: 0,
-				updatedAt: 0,
-			});
-			await flushPromises();
-
-			expect(pm.getState("corr-mid-dispose")).toBeUndefined();
-			app.destroy();
-		});
-
-		it("restore() Promise resolves at the right moment (after all loads complete)", async () => {
-			const tier: KvStorageTier<ProcessStateSnapshot<{ step: string }>> = kvStorage(
-				memoryBackend(),
-				{
-					name: "restore-resolve-states",
-				},
-			) as KvStorageTier<ProcessStateSnapshot<{ step: string }>>;
-			// Pre-seed a record so list() returns one key.
-			await tier.save("corr-R", {
-				correlationId: "corr-R",
-				state: { step: "loaded" },
-				status: "running",
-				startedAt: 0,
-				updatedAt: 0,
-			});
-			await tier.flush?.();
-
-			const app = cqrs("restore-resolve");
-			const pm = processManager(app, "resolve", {
-				initial: { step: "init" },
-				watching: [],
-				steps: {},
-				persistence: { stateStorage: [tier] },
-				deferRestore: true,
-			});
-
-			// Before restore() is called, restoreState stays "pending"
-			// (deferRestore: true suppresses the auto-kick).
-			expect(pm.restoreState.cache).toBe("pending");
-			expect(pm.getState("corr-R")).toBeUndefined();
-
-			await pm.restore();
-
-			// After restore() resolves, restoreState is "completed" and the
-			// rehydrated instance is observable via getState().
-			expect(pm.restoreState.cache).toBe("completed");
-			expect(pm.getState("corr-R")).toEqual({ step: "loaded" });
-
-			pm.dispose();
-			app.destroy();
-		});
-
-		it("{ deferRestore: true } doesn't auto-restore on construction", async () => {
-			const tier: KvStorageTier<ProcessStateSnapshot<{ step: string }>> = kvStorage(
-				memoryBackend(),
-				{
-					name: "defer-states",
-				},
-			) as KvStorageTier<ProcessStateSnapshot<{ step: string }>>;
-			await tier.save("corr-D", {
-				correlationId: "corr-D",
-				state: { step: "loaded" },
-				status: "running",
-				startedAt: 0,
-				updatedAt: 0,
-			});
-			await tier.flush?.();
-
-			const app = cqrs("defer-app");
-			const pm = processManager(app, "defer", {
-				initial: { step: "init" },
-				watching: [],
-				steps: {},
-				persistence: { stateStorage: [tier] },
-				deferRestore: true,
-			});
-
-			// Wait long enough that an auto-restore would have completed.
-			await flushPromises();
-
-			// deferRestore: true → restoreState stays "pending" until the
-			// caller explicitly invokes restore().
-			expect(pm.restoreState.cache).toBe("pending");
-			expect(pm.getState("corr-D")).toBeUndefined();
-
-			pm.dispose();
-			app.destroy();
-		});
-	});
-});
diff --git a/src/__tests__/utils/reactive-layout/measurement-adapters.test.ts b/src/__tests__/utils/reactive-layout/measurement-adapters.test.ts
deleted file mode 100644
index 6596a25b..00000000
--- a/src/__tests__/utils/reactive-layout/measurement-adapters.test.ts
+++ /dev/null
@@ -1,628 +0,0 @@
-/**
- * Tests for MeasurementAdapter implementations (roadmap §7.1).
- */
-import { describe, expect, it } from "vitest";
-import {
-	_resetDefaultSegmentAdapterForTests,
-	CanvasMeasureAdapter,
-	type CanvasModule,
-	CliMeasureAdapter,
-	getDefaultSegmentAdapter,
-	InjectedMeasureAdapter,
-	IntlSegmentAdapter,
-	NodeCanvasMeasureAdapter,
-	PrecomputedAdapter,
-} from "../../../utils/reactive-layout/measurement-adapters.js";
-import type {
-	MeasurementAdapter,
-	SegmentAdapter,
-	SegmentInfo,
-} from "../../../utils/reactive-layout/reactive-layout.js";
-import {
-	analyzeAndMeasure,
-	reactiveLayout,
-} from "../../../utils/reactive-layout/reactive-layout.js";
-
-// ---------------------------------------------------------------------------
-// CliMeasureAdapter
-// ---------------------------------------------------------------------------
-
-describe("CliMeasureAdapter", () => {
-	it("measures ASCII text as 1 cell per character", () => {
-		const adapter = new CliMeasureAdapter();
-		expect(adapter.measureSegment("hello", "mono").width).toBe(40); // 5 * 8
-	});
-
-	it("measures CJK characters as 2 cells each", () => {
-		const adapter = new CliMeasureAdapter();
-		// 3 CJK chars → 6 cells → 48px
-		expect(adapter.measureSegment("你好世", "mono").width).toBe(48);
-	});
-
-	it("measures mixed ASCII + CJK", () => {
-		const adapter = new CliMeasureAdapter();
-		// "hi你" → 2 ASCII (2 cells) + 1 CJK (2 cells) = 4 cells → 32px
-		expect(adapter.measureSegment("hi你", "mono").width).toBe(32);
-	});
-
-	it("respects custom cellPx", () => {
-		const adapter = new CliMeasureAdapter({ cellPx: 10 });
-		expect(adapter.measureSegment("ab", "mono").width).toBe(20);
-	});
-
-	it("handles empty string", () => {
-		const adapter = new CliMeasureAdapter();
-		expect(adapter.measureSegment("", "mono").width).toBe(0);
-	});
-
-	it("measures fullwidth forms as 2 cells", () => {
-		const adapter = new CliMeasureAdapter();
-		// Ａ (U+FF21, fullwidth A) → 2 cells
-		expect(adapter.measureSegment("\uff21", "mono").width).toBe(16);
-	});
-
-	it("measures Hangul syllables as 2 cells", () => {
-		const adapter = new CliMeasureAdapter();
-		// 한 (U+D55C) → 2 cells → 16px
-		expect(adapter.measureSegment("한", "mono").width).toBe(16);
-	});
-
-	it("treats combining marks as zero-width", () => {
-		const adapter = new CliMeasureAdapter();
-		// "e\u0301" = e + combining acute accent → 1 cell (not 2)
-		expect(adapter.measureSegment("e\u0301", "mono").width).toBe(8);
-	});
-
-	it("ignores font parameter", () => {
-		const adapter = new CliMeasureAdapter();
-		const w1 = adapter.measureSegment("test", "12px serif");
-		const w2 = adapter.measureSegment("test", "48px monospace");
-		expect(w1.width).toBe(w2.width);
-	});
-
-	it("integrates with reactiveLayout", () => {
-		const adapter = new CliMeasureAdapter({ cellPx: 8 });
-		const bundle = reactiveLayout({
-			adapter,
-			text: "hello world",
-			maxWidth: 60,
-		});
-		// Subscribe to trigger computation
-		const unsub = bundle.lineBreaks.subscribe(() => {});
-		// "hello" = 40px, " " = 8px, "world" = 40px → total 88px > 60px
-		// Should wrap into 2 lines
-		const lb = bundle.lineBreaks.cache;
-		expect(lb).not.toBeNull();
-		expect(lb!.lineCount).toBe(2);
-		unsub();
-		bundle.graph.destroy();
-	});
-});
-
-// ---------------------------------------------------------------------------
-// PrecomputedAdapter
-// ---------------------------------------------------------------------------
-
-describe("PrecomputedAdapter", () => {
-	const metrics = {
-		"16px mono": {
-			hello: 40,
-			world: 40,
-			" ": 8,
-			h: 8,
-			e: 8,
-			l: 8,
-			o: 8,
-			w: 8,
-			r: 8,
-			d: 8,
-		},
-	};
-
-	it("looks up exact segment width", () => {
-		const adapter = new PrecomputedAdapter({ metrics });
-		expect(adapter.measureSegment("hello", "16px mono").width).toBe(40);
-	});
-
-	it("falls back to per-char sum for unknown segments", () => {
-		const adapter = new PrecomputedAdapter({ metrics });
-		// "held" → h(8) + e(8) + l(8) + d(8) = 32
-		expect(adapter.measureSegment("held", "16px mono").width).toBe(32);
-	});
-
-	it("returns 0 for completely unknown font", () => {
-		const adapter = new PrecomputedAdapter({ metrics });
-		expect(adapter.measureSegment("hello", "unknown-font").width).toBe(0);
-	});
-
-	it("throws in error mode for unknown segment", () => {
-		const adapter = new PrecomputedAdapter({ metrics, fallback: "error" });
-		expect(() => adapter.measureSegment("xyz", "16px mono")).toThrow("no metrics");
-	});
-
-	it("validates fallback at runtime", () => {
-		// Simulate runtime JS misuse: bypass TS unions.
-		expect(() => new PrecomputedAdapter({ metrics, fallback: "bogus" as any })).toThrow(
-			"fallback must be 'per-char' or 'error'",
-		);
-	});
-
-	it("returns exact match even in error mode", () => {
-		const adapter = new PrecomputedAdapter({ metrics, fallback: "error" });
-		expect(adapter.measureSegment("hello", "16px mono").width).toBe(40);
-	});
-
-	it("integrates with analyzeAndMeasure", () => {
-		const adapter = new PrecomputedAdapter({ metrics });
-		const segs = analyzeAndMeasure("hello world", "16px mono", adapter, new Map());
-		expect(segs.length).toBeGreaterThan(0);
-		const textSegs = segs.filter((s) => s.kind === "text");
-		expect(textSegs.length).toBe(2); // "hello", "world"
-	});
-});
-
-// ---------------------------------------------------------------------------
-// NodeCanvasMeasureAdapter (mock canvas module)
-// ---------------------------------------------------------------------------
-
-describe("NodeCanvasMeasureAdapter", () => {
-	function mockCanvasModule(): CanvasModule {
-		return {
-			createCanvas(_w: number, _h: number) {
-				let currentFont = "";
-				return {
-					getContext(_type: "2d") {
-						return {
-							get font() {
-								return currentFont;
-							},
-							set font(f: string) {
-								currentFont = f;
-							},
-							measureText(text: string) {
-								// Simple mock: 10px per char
-								return { width: text.length * 10 };
-							},
-						};
-					},
-				};
-			},
-		};
-	}
-
-	it("measures text via injected canvas module", () => {
-		const adapter = new NodeCanvasMeasureAdapter(mockCanvasModule());
-		expect(adapter.measureSegment("hello", "16px mono").width).toBe(50);
-	});
-
-	it("lazily creates canvas context on first call", () => {
-		let createCount = 0;
-		const mod: CanvasModule = {
-			createCanvas(w, h) {
-				createCount++;
-				return mockCanvasModule().createCanvas(w, h);
-			},
-		};
-		const adapter = new NodeCanvasMeasureAdapter(mod);
-		expect(createCount).toBe(0);
-		adapter.measureSegment("a", "mono");
-		expect(createCount).toBe(1);
-		adapter.measureSegment("b", "mono");
-		expect(createCount).toBe(1); // reuses context
-	});
-
-	it("sets font on context when font changes", () => {
-		const fonts: string[] = [];
-		const mod: CanvasModule = {
-			createCanvas() {
-				let f = "";
-				return {
-					getContext() {
-						return {
-							get font() {
-								return f;
-							},
-							set font(v: string) {
-								f = v;
-								fonts.push(v);
-							},
-							measureText(text: string) {
-								return { width: text.length * 10 };
-							},
-						};
-					},
-				};
-			},
-		};
-		const adapter = new NodeCanvasMeasureAdapter(mod);
-		adapter.measureSegment("a", "12px serif");
-		adapter.measureSegment("b", "12px serif"); // same font, no set
-		adapter.measureSegment("c", "16px mono"); // different font
-		expect(fonts).toEqual(["12px serif", "16px mono"]);
-	});
-
-	it("clearCache resets font tracking", () => {
-		const adapter = new NodeCanvasMeasureAdapter(mockCanvasModule());
-		adapter.measureSegment("a", "12px serif");
-		adapter.clearCache();
-		// After clear, next call should set font again even if same
-		adapter.measureSegment("b", "12px serif");
-		// No error — works correctly
-		expect(adapter.measureSegment("c", "12px serif").width).toBe(10);
-	});
-});
-
-// ---------------------------------------------------------------------------
-// CanvasMeasureAdapter (limited test — no OffscreenCanvas in Node)
-// ---------------------------------------------------------------------------
-
-describe("CanvasMeasureAdapter", () => {
-	it("can be constructed without options", () => {
-		// Just verify it doesn't throw at construction time
-		const adapter = new CanvasMeasureAdapter();
-		expect(adapter).toBeDefined();
-	});
-
-	it("can be constructed with emoji correction", () => {
-		const adapter = new CanvasMeasureAdapter({ emojiCorrection: 0.85 });
-		expect(adapter).toBeDefined();
-	});
-
-	// OffscreenCanvas is not available in Node/vitest — skip actual measurement.
-	// Integration tests in a browser environment would cover measureSegment().
-});
-
-// ---------------------------------------------------------------------------
-// All adapters satisfy MeasurementAdapter interface
-// ---------------------------------------------------------------------------
-
-describe("MeasurementAdapter interface conformance", () => {
-	const adapters: [string, MeasurementAdapter][] = [
-		["CliMeasureAdapter", new CliMeasureAdapter()],
-		[
-			"PrecomputedAdapter",
-			new PrecomputedAdapter({
-				metrics: { mono: { a: 8 } },
-			}),
-		],
-		[
-			"NodeCanvasMeasureAdapter",
-			new NodeCanvasMeasureAdapter({
-				createCanvas() {
-					return {
-						getContext() {
-							return {
-								font: "",
-								measureText(t: string) {
-									return { width: t.length * 8 };
-								},
-							};
-						},
-					};
-				},
-			}),
-		],
-	];
-
-	for (const [name, adapter] of adapters) {
-		it(`${name} has measureSegment(text, font) → { width: number }`, () => {
-			const result = adapter.measureSegment("test", "mono");
-			expect(result).toHaveProperty("width");
-			expect(typeof result.width).toBe("number");
-		});
-	}
-});
-
-// ---------------------------------------------------------------------------
-// InjectedMeasureAdapter (RN/Hermes reference adapter)
-// ---------------------------------------------------------------------------
-
-describe("InjectedMeasureAdapter", () => {
-	it("delegates to the injected sync (text, font) => widthPx fn", () => {
-		const calls: Array<[string, string]> = [];
-		const adapter = new InjectedMeasureAdapter((text, font) => {
-			calls.push([text, font]);
-			return text.length * 7;
-		});
-		expect(adapter.measureSegment("abc", "16px Kalam")).toEqual({ width: 21 });
-		expect(calls).toEqual([["abc", "16px Kalam"]]);
-	});
-
-	it("satisfies the MeasurementAdapter contract", () => {
-		const adapter: MeasurementAdapter = new InjectedMeasureAdapter((t) => t.length);
-		const r = adapter.measureSegment("xy", "mono");
-		expect(typeof r.width).toBe("number");
-	});
-
-	it("caches by font+text when cache:true and clearCache resets it", () => {
-		let n = 0;
-		const adapter = new InjectedMeasureAdapter(
-			(t) => {
-				n++;
-				return t.length;
-			},
-			{ cache: true },
-		);
-		adapter.measureSegment("aa", "f1");
-		adapter.measureSegment("aa", "f1"); // cache hit
-		expect(n).toBe(1);
-		adapter.measureSegment("aa", "f2"); // different font → miss
-		expect(n).toBe(2);
-		adapter.clearCache();
-		adapter.measureSegment("aa", "f1"); // miss after clear
-		expect(n).toBe(3);
-	});
-
-	it("cache key does not collide across (font, text) boundary shifts", () => {
-		// Regression: the cache separator must be collision-safe. A naive
-		// space (or an empty/stripped delimiter) collides `(font,text)`
-		// pairs whose concatenation is equal — e.g. ("a","bc") vs ("ab","c"),
-		// and ("a","b c") vs ("a b","c"). Encode width from BOTH args so a
-		// wrong cache hit returns the wrong width.
-		let calls = 0;
-		const adapter = new InjectedMeasureAdapter(
-			(text, font) => {
-				calls++;
-				return text.length * 1000 + font.length;
-			},
-			{ cache: true },
-		);
-		// measureSegment(text, font)
-		expect(adapter.measureSegment("bc", "a").width).toBe(2001); // 2*1000+1
-		expect(adapter.measureSegment("c", "ab").width).toBe(1002); // 1*1000+2 (NOT 2003)
-		expect(adapter.measureSegment("b c", "a").width).toBe(3001); // 3*1000+1
-		expect(adapter.measureSegment("c", "a b").width).toBe(1003); // 1*1000+3 (NOT 3001)
-		expect(calls).toBe(4); // four distinct keys → four fn calls, no false hit
-		// And a genuine repeat IS a hit (no over-keying).
-		expect(adapter.measureSegment("bc", "a").width).toBe(2001);
-		expect(calls).toBe(4);
-	});
-
-	it("does not cache by default (fn called every time)", () => {
-		let n = 0;
-		const adapter = new InjectedMeasureAdapter(() => {
-			n++;
-			return 1;
-		});
-		adapter.measureSegment("a", "f");
-		adapter.measureSegment("a", "f");
-		expect(n).toBe(2);
-	});
-
-	it("works as a reactiveLayout adapter (RN drop-in seam)", () => {
-		// Stand-in for a host Skia/RN measure fn: width = chars × 9px.
-		// "hello"=45 " "=9 "world"=45 → 99 > 50 ⇒ wraps to 2 lines.
-		const bundle = reactiveLayout({
-			adapter: new InjectedMeasureAdapter((t) => t.length * 9),
-			text: "hello world",
-			maxWidth: 50,
-		});
-		const unsub = bundle.lineBreaks.subscribe(() => {});
-		expect(bundle.lineBreaks.cache).not.toBeNull();
-		expect(bundle.lineBreaks.cache!.lineCount).toBe(2);
-		unsub();
-		bundle.graph.destroy();
-	});
-
-	it("rejects a non-function measure fn", () => {
-		expect(() => new InjectedMeasureAdapter(undefined as never)).toThrow(TypeError);
-	});
-});
-
-// ---------------------------------------------------------------------------
-// IntlSegmentAdapter (default reference SegmentAdapter)
-//
-// DS-2026-05-20 — `optimizations.md` 🟠 (d). Hermes-runtime-gap follow-up:
-// these tests pin the cross-port contract (delegate to platform
-// `Intl.Segmenter` when present; throw a clear "supply a SegmentAdapter"
-// error when absent — the runtime that bit memo:Re Story 3.6).
-// ---------------------------------------------------------------------------
-
-describe("IntlSegmentAdapter", () => {
-	it("constructs on a runtime with Intl.Segmenter", () => {
-		const a = new IntlSegmentAdapter();
-		expect(a).toBeInstanceOf(IntlSegmentAdapter);
-	});
-
-	it("segmentWords yields { segment, index, isWordLike } matching Intl.Segmenter shape", () => {
-		const a = new IntlSegmentAdapter();
-		const segs = [...a.segmentWords("hello world")];
-		// Expect at least one wordLike + one non-wordLike (space). Be tolerant
-		// of Intl.Segmenter implementation-detail boundaries; structural-only.
-		expect(segs.length).toBeGreaterThan(0);
-		const wordLikes = segs.filter((s) => s.isWordLike === true).map((s) => s.segment);
-		expect(wordLikes).toContain("hello");
-		expect(wordLikes).toContain("world");
-		for (const s of segs) {
-			expect(typeof s.segment).toBe("string");
-			expect(typeof s.index).toBe("number");
-		}
-	});
-
-	it("segmentGraphemes yields { segment, index } per grapheme cluster", () => {
-		const a = new IntlSegmentAdapter();
-		// "a‍‍" is one grapheme; "ab" is two graphemes.
-		const ab = [...a.segmentGraphemes("ab")].map((s) => s.segment);
-		expect(ab).toEqual(["a", "b"]);
-	});
-
-	it("caches per-granularity Intl.Segmenter across calls (allocates once)", () => {
-		const a = new IntlSegmentAdapter();
-		// Spying on the constructor is brittle; instead, exercise both paths
-		// and assert the iterator output stays consistent (same instance
-		// behavior). This is a smoke test, not a perf assertion.
-		const a1 = [...a.segmentGraphemes("xy")].map((s) => s.segment);
-		const a2 = [...a.segmentGraphemes("xy")].map((s) => s.segment);
-		expect(a1).toEqual(a2);
-		const w1 = [...a.segmentWords("a b")].map((s) => s.segment);
-		const w2 = [...a.segmentWords("a b")].map((s) => s.segment);
-		expect(w1).toEqual(w2);
-	});
-
-	// R-RL-Hermes-2026-05-20: the failure shape memo:Re Story 3.6 hit.
-	// Stubbing `Intl.Segmenter` to undefined emulates Hermes / iOS 26.5
-	// (where `Intl.Segmenter typeof === "undefined"`). The pre-DS substrate
-	// would throw `Cannot read property 'prototype' of undefined` deep in
-	// the reactive wave; post-DS, IntlSegmentAdapter throws a clear,
-	// recipe-naming TypeError at construction time.
-	it("throws a clear TypeError when Intl.Segmenter is undefined (Hermes shape)", () => {
-		const orig = (Intl as unknown as { Segmenter: unknown }).Segmenter;
-		try {
-			(Intl as unknown as { Segmenter: unknown }).Segmenter = undefined;
-			expect(() => new IntlSegmentAdapter()).toThrow(TypeError);
-			try {
-				new IntlSegmentAdapter();
-				expect.fail("Expected TypeError");
-			} catch (e) {
-				expect((e as Error).message).toMatch(/Intl\.Segmenter is not available/);
-				expect((e as Error).message).toMatch(/segmentAdapter/);
-				expect((e as Error).message).toMatch(/polyfill/i);
-			}
-		} finally {
-			(Intl as unknown as { Segmenter: unknown }).Segmenter = orig;
-		}
-	});
-
-	it("getDefaultSegmentAdapter returns a lazy, module-shared instance", () => {
-		_resetDefaultSegmentAdapterForTests();
-		const d1 = getDefaultSegmentAdapter();
-		const d2 = getDefaultSegmentAdapter();
-		expect(d1).toBe(d2);
-		expect(d1).toBeInstanceOf(IntlSegmentAdapter);
-	});
-});
-
-// ---------------------------------------------------------------------------
-// Host-injected SegmentAdapter — end-to-end (the actual Hermes-shape coverage)
-// ---------------------------------------------------------------------------
-
-describe("Host-injected SegmentAdapter end-to-end", () => {
-	/**
-	 * Build a fake SegmentAdapter that does NOT reference `Intl.Segmenter` —
-	 * this proves the substrate routes through `opts.segmentAdapter` and
-	 * never touches the platform global. On Hermes, a host wires the same
-	 * shape over a polyfill (or RN-native segmenter); here we stub the
-	 * minimum a polyfill would expose: word + grapheme iteration.
-	 */
-	function makeFakeSegmentAdapter(): SegmentAdapter & { sawWord: number; sawGrapheme: number } {
-		let sawWord = 0;
-		let sawGrapheme = 0;
-		const adapter: SegmentAdapter & { sawWord: number; sawGrapheme: number } = {
-			sawWord: 0,
-			sawGrapheme: 0,
-			segmentWords(text: string): Iterable<SegmentInfo> {
-				sawWord += 1;
-				adapter.sawWord = sawWord;
-				// Naive word split on space — sufficient for the smoke-test
-				// shape; production Hermes consumers wrap a proper polyfill.
-				const out: SegmentInfo[] = [];
-				let i = 0;
-				let acc = "";
-				let accStart = 0;
-				for (let k = 0; k < text.length; k++) {
-					const ch = text[k]!;
-					if (ch === " ") {
-						if (acc) {
-							out.push({ segment: acc, index: accStart, isWordLike: true });
-							acc = "";
-						}
-						out.push({ segment: " ", index: k, isWordLike: false });
-						accStart = k + 1;
-					} else {
-						if (acc === "") accStart = k;
-						acc += ch;
-					}
-					i = k;
-				}
-				if (acc) out.push({ segment: acc, index: accStart, isWordLike: true });
-				void i;
-				return out;
-			},
-			segmentGraphemes(text: string): Iterable<SegmentInfo> {
-				sawGrapheme += 1;
-				adapter.sawGrapheme = sawGrapheme;
-				const out: SegmentInfo[] = [];
-				for (let k = 0; k < text.length; k++) {
-					out.push({ segment: text[k]!, index: k });
-				}
-				return out;
-			},
-		};
-		return adapter;
-	}
-
-	it("reactiveLayout({ segmentAdapter }) routes through the injected adapter (no Intl.Segmenter access)", () => {
-		const fake = makeFakeSegmentAdapter();
-		const bundle = reactiveLayout({
-			adapter: new InjectedMeasureAdapter((t) => t.length * 9),
-			segmentAdapter: fake,
-			text: "hello world",
-			font: "16px mono",
-			maxWidth: 200,
-		});
-		const unsub = bundle.segments.subscribe(() => {});
-		// Adapter must have been consulted at least once for word + grapheme.
-		expect(fake.sawWord).toBeGreaterThan(0);
-		expect(bundle.segments.cache).not.toBeNull();
-		expect((bundle.segments.cache as { text: string }[]).length).toBeGreaterThan(0);
-		unsub();
-		bundle.graph.destroy();
-	});
-
-	it("reactiveLayout still works on Hermes-shape runtime when segmentAdapter is supplied (Intl.Segmenter stubbed undefined)", () => {
-		// Reset the module-shared default so this test doesn't pick up a
-		// previously-constructed live IntlSegmentAdapter.
-		_resetDefaultSegmentAdapterForTests();
-		const orig = (Intl as unknown as { Segmenter: unknown }).Segmenter;
-		try {
-			(Intl as unknown as { Segmenter: unknown }).Segmenter = undefined;
-			const fake = makeFakeSegmentAdapter();
-			// Must NOT throw — substrate never reaches `Intl.Segmenter` because
-			// `segmentAdapter` short-circuits `getDefaultSegmentAdapter()`.
-			const bundle = reactiveLayout({
-				adapter: new InjectedMeasureAdapter((t) => t.length * 9),
-				segmentAdapter: fake,
-				text: "hello world",
-				font: "16px mono",
-				maxWidth: 200,
-			});
-			const unsub = bundle.segments.subscribe(() => {});
-			expect(fake.sawWord).toBeGreaterThan(0);
-			expect(bundle.segments.cache).not.toBeNull();
-			unsub();
-			bundle.graph.destroy();
-		} finally {
-			(Intl as unknown as { Segmenter: unknown }).Segmenter = orig;
-			_resetDefaultSegmentAdapterForTests();
-		}
-	});
-
-	it("reactiveLayout({}) without segmentAdapter on Hermes-shape runtime throws the clear-message TypeError at factory construction", () => {
-		_resetDefaultSegmentAdapterForTests();
-		const orig = (Intl as unknown as { Segmenter: unknown }).Segmenter;
-		try {
-			(Intl as unknown as { Segmenter: unknown }).Segmenter = undefined;
-			expect(() =>
-				reactiveLayout({
-					adapter: new InjectedMeasureAdapter((t) => t.length * 9),
-					text: "hello",
-					font: "16px mono",
-					maxWidth: 100,
-				}),
-			).toThrow(/Intl\.Segmenter is not available/);
-		} finally {
-			(Intl as unknown as { Segmenter: unknown }).Segmenter = orig;
-			_resetDefaultSegmentAdapterForTests();
-		}
-	});
-
-	it("analyzeAndMeasure(segmentAdapter) is honored when explicitly passed", () => {
-		const fake = makeFakeSegmentAdapter();
-		const adapter: MeasurementAdapter = {
-			measureSegment: (t) => ({ width: t.length * 9 }),
-		};
-		const segs = analyzeAndMeasure("hello world", "16px mono", adapter, new Map(), undefined, fake);
-		expect(segs.length).toBeGreaterThan(0);
-		expect(fake.sawWord).toBeGreaterThan(0);
-	});
-});
diff --git a/src/__tests__/utils/reactive-layout/reactive-block-layout.test.ts b/src/__tests__/utils/reactive-layout/reactive-block-layout.test.ts
deleted file mode 100644
index 2e8e897f..00000000
--- a/src/__tests__/utils/reactive-layout/reactive-block-layout.test.ts
+++ /dev/null
@@ -1,543 +0,0 @@
-/**
- * Tests for reactive multi-content block layout engine (roadmap §7.1 — mixed content).
- *
- * Uses mock adapters with deterministic dimensions (8px per char for text,
- * fixed sizes for images/SVGs) so tests are environment-independent.
- */
-
-import { INVALIDATE } from "@graphrefly/pure-ts/core";
-import { describe, expect, it } from "vitest";
-import {
-	ImageSizeAdapter,
-	SvgBoundsAdapter,
-} from "../../../utils/reactive-layout/measurement-adapters.js";
-import {
-	type BlockAdapters,
-	type ContentBlock,
-	computeBlockFlow,
-	computeTotalHeight,
-	type MeasuredBlock,
-	measureBlock,
-	measureBlocks,
-	type PositionedBlock,
-	reactiveBlockLayout,
-} from "../../../utils/reactive-layout/reactive-block-layout.js";
-import type { MeasurementAdapter } from "../../../utils/reactive-layout/reactive-layout.js";
-
-// ---------------------------------------------------------------------------
-// Mock adapters
-// ---------------------------------------------------------------------------
-
-const CHAR_WIDTH = 8;
-
-function mockTextAdapter(): MeasurementAdapter {
-	return {
-		measureSegment(text: string, _font: string) {
-			return { width: text.length * CHAR_WIDTH };
-		},
-	};
-}
-
-function mockAdapters(extras?: {
-	svg?: Record<string, { width: number; height: number }>;
-	image?: Record<string, { width: number; height: number }>;
-}): BlockAdapters {
-	return {
-		text: mockTextAdapter(),
-		svg: extras?.svg
-			? { measureSvg: (content: string) => extras.svg![content] ?? { width: 100, height: 100 } }
-			: undefined,
-		image: extras?.image ? new ImageSizeAdapter(extras.image) : undefined,
-	};
-}
-
-// ---------------------------------------------------------------------------
-// SvgBoundsAdapter
-// ---------------------------------------------------------------------------
-
-describe("SvgBoundsAdapter", () => {
-	const adapter = new SvgBoundsAdapter();
-
-	it("extracts dimensions from viewBox", () => {
-		const svg = '<svg viewBox="0 0 200 100" xmlns="http://www.w3.org/2000/svg"></svg>';
-		expect(adapter.measureSvg(svg)).toEqual({ width: 200, height: 100 });
-	});
-
-	it("extracts dimensions from viewBox with commas", () => {
-		const svg = '<svg viewBox="0,0,300,150"></svg>';
-		expect(adapter.measureSvg(svg)).toEqual({ width: 300, height: 150 });
-	});
-
-	it("falls back to width/height attributes", () => {
-		const svg = '<svg width="120" height="60"></svg>';
-		expect(adapter.measureSvg(svg)).toEqual({ width: 120, height: 60 });
-	});
-
-	it("prefers viewBox over width/height", () => {
-		const svg = '<svg viewBox="0 0 200 100" width="400" height="200"></svg>';
-		expect(adapter.measureSvg(svg)).toEqual({ width: 200, height: 100 });
-	});
-
-	it("throws for SVG without dimensions", () => {
-		expect(() => adapter.measureSvg("<svg><circle r='10'/></svg>")).toThrow(
-			/cannot determine dimensions/,
-		);
-	});
-
-	it("throws when viewBox dimensions are not positive", () => {
-		const svg = '<svg viewBox="0 0 0 100"></svg>';
-		expect(() => adapter.measureSvg(svg)).toThrow(/viewBox width\/height/);
-	});
-
-	it("throws when width/height attributes are not positive", () => {
-		const svg = '<svg width="0" height="60"></svg>';
-		expect(() => adapter.measureSvg(svg)).toThrow(/width\/height attributes/);
-	});
-});
-
-// ---------------------------------------------------------------------------
-// ImageSizeAdapter
-// ---------------------------------------------------------------------------
-
-describe("ImageSizeAdapter", () => {
-	const adapter = new ImageSizeAdapter({
-		"hero.png": { width: 1200, height: 630 },
-		"logo.svg": { width: 120, height: 40 },
-	});
-
-	it("returns registered dimensions", () => {
-		expect(adapter.measureImage("hero.png")).toEqual({ width: 1200, height: 630 });
-	});
-
-	it("throws for unregistered src", () => {
-		expect(() => adapter.measureImage("unknown.png")).toThrow(/no dimensions registered/);
-	});
-});
-
-// ---------------------------------------------------------------------------
-// measureBlock — text
-// ---------------------------------------------------------------------------
-
-describe("measureBlock", () => {
-	const adapters = mockAdapters();
-	const cache = new Map<string, Map<string, number>>();
-	const font = "16px mono";
-	const lh = 20;
-
-	it("measures a text block", () => {
-		const block: ContentBlock = { type: "text", text: "hello world" };
-		const m = measureBlock(block, 800, adapters, cache, font, lh, 0);
-		expect(m.type).toBe("text");
-		expect(m.index).toBe(0);
-		expect(m.height).toBeGreaterThan(0);
-		expect(m.textSegments).toBeDefined();
-		expect(m.textLineBreaks).toBeDefined();
-		expect(m.textCharPositions).toBeDefined();
-	});
-
-	it("measures a text block with line wrapping", () => {
-		const block: ContentBlock = { type: "text", text: "hello world" };
-		// "hello" = 5*8=40, " "=8, "world"=5*8=40 → total ~88px
-		// maxWidth 50 should wrap
-		const m = measureBlock(block, 50, adapters, cache, font, lh, 0);
-		expect(m.textLineBreaks!.lineCount).toBeGreaterThan(1);
-		expect(m.height).toBe(m.textLineBreaks!.lineCount * lh);
-	});
-
-	it("measures an image block with explicit dimensions", () => {
-		const block: ContentBlock = {
-			type: "image",
-			src: "pic.png",
-			naturalWidth: 400,
-			naturalHeight: 300,
-		};
-		const m = measureBlock(block, 800, adapters, cache, font, lh, 1);
-		expect(m).toEqual({ index: 1, type: "image", width: 400, height: 300 });
-	});
-
-	it("scales image proportionally when wider than maxWidth", () => {
-		const block: ContentBlock = {
-			type: "image",
-			src: "wide.png",
-			naturalWidth: 1600,
-			naturalHeight: 900,
-		};
-		const m = measureBlock(block, 800, adapters, cache, font, lh, 0);
-		expect(m.width).toBe(800);
-		expect(m.height).toBe(450); // 900 * (800/1600)
-	});
-
-	it("measures an image block via adapter", () => {
-		const a = mockAdapters({ image: { "hero.png": { width: 1200, height: 630 } } });
-		const block: ContentBlock = { type: "image", src: "hero.png" };
-		const m = measureBlock(block, 800, a, cache, font, lh, 0);
-		// Scaled: 1200 > 800, so 630 * (800/1200) = 420
-		expect(m.width).toBe(800);
-		expect(m.height).toBe(420);
-	});
-
-	it("throws for image without dimensions or adapter", () => {
-		const block: ContentBlock = { type: "image", src: "no-dims.png" };
-		expect(() => measureBlock(block, 800, adapters, cache, font, lh, 0)).toThrow(
-			/no naturalWidth\/naturalHeight and no ImageMeasurer/,
-		);
-	});
-
-	it("measures an SVG block with viewBox", () => {
-		const block: ContentBlock = {
-			type: "svg",
-			content: '<svg viewBox="0 0 200 100"></svg>',
-			viewBox: { width: 200, height: 100 },
-		};
-		const m = measureBlock(block, 800, adapters, cache, font, lh, 2);
-		expect(m).toEqual({ index: 2, type: "svg", width: 200, height: 100 });
-	});
-
-	it("scales SVG proportionally when wider than maxWidth", () => {
-		const block: ContentBlock = {
-			type: "svg",
-			content: "<svg></svg>",
-			viewBox: { width: 1000, height: 500 },
-		};
-		const m = measureBlock(block, 800, adapters, cache, font, lh, 0);
-		expect(m.width).toBe(800);
-		expect(m.height).toBe(400); // 500 * (800/1000)
-	});
-
-	it("throws for SVG without viewBox or adapter", () => {
-		const block: ContentBlock = { type: "svg", content: "<svg><rect/></svg>" };
-		expect(() => measureBlock(block, 800, adapters, cache, font, lh, 0)).toThrow(
-			/no viewBox and no SvgMeasurer/,
-		);
-	});
-});
-
-// ---------------------------------------------------------------------------
-// measureBlocks
-// ---------------------------------------------------------------------------
-
-describe("measureBlocks", () => {
-	it("measures mixed content blocks", () => {
-		const adapters = mockAdapters();
-		const blocks: ContentBlock[] = [
-			{ type: "text", text: "hello" },
-			{ type: "image", src: "pic.png", naturalWidth: 200, naturalHeight: 100 },
-			{ type: "text", text: "world" },
-		];
-		const result = measureBlocks(blocks, 800, adapters, new Map(), "16px mono", 20);
-		expect(result).toHaveLength(3);
-		expect(result[0]!.type).toBe("text");
-		expect(result[1]!.type).toBe("image");
-		expect(result[2]!.type).toBe("text");
-		expect(result[0]!.index).toBe(0);
-		expect(result[1]!.index).toBe(1);
-		expect(result[2]!.index).toBe(2);
-	});
-
-	it("returns empty for empty blocks", () => {
-		expect(measureBlocks([], 800, mockAdapters(), new Map(), "16px mono", 20)).toEqual([]);
-	});
-});
-
-// ---------------------------------------------------------------------------
-// computeBlockFlow
-// ---------------------------------------------------------------------------
-
-describe("computeBlockFlow", () => {
-	const blocks: MeasuredBlock[] = [
-		{ index: 0, type: "text", width: 200, height: 40 },
-		{ index: 1, type: "image", width: 300, height: 150 },
-		{ index: 2, type: "text", width: 200, height: 60 },
-	];
-
-	it("stacks blocks vertically with zero gap", () => {
-		const flow = computeBlockFlow(blocks, 0);
-		expect(flow).toHaveLength(3);
-		expect(flow[0]).toMatchObject({ x: 0, y: 0, height: 40 });
-		expect(flow[1]).toMatchObject({ x: 0, y: 40, height: 150 });
-		expect(flow[2]).toMatchObject({ x: 0, y: 190, height: 60 });
-	});
-
-	it("stacks blocks vertically with gap", () => {
-		const flow = computeBlockFlow(blocks, 10);
-		expect(flow[0]).toMatchObject({ x: 0, y: 0 });
-		expect(flow[1]).toMatchObject({ x: 0, y: 50 }); // 40 + 10
-		expect(flow[2]).toMatchObject({ x: 0, y: 210 }); // 50 + 150 + 10
-	});
-
-	it("returns empty for empty input", () => {
-		expect(computeBlockFlow([], 0)).toEqual([]);
-	});
-});
-
-// ---------------------------------------------------------------------------
-// computeTotalHeight
-// ---------------------------------------------------------------------------
-
-describe("computeTotalHeight", () => {
-	it("returns 0 for empty flow", () => {
-		expect(computeTotalHeight([])).toBe(0);
-	});
-
-	it("returns last block y + height", () => {
-		const flow: PositionedBlock[] = [
-			{ index: 0, type: "text", width: 200, height: 40, x: 0, y: 0 },
-			{ index: 1, type: "image", width: 300, height: 150, x: 0, y: 50 },
-		];
-		expect(computeTotalHeight(flow)).toBe(200); // 50 + 150
-	});
-});
-
-// ---------------------------------------------------------------------------
-// reactiveBlockLayout — factory
-// ---------------------------------------------------------------------------
-
-describe("reactiveBlockLayout", () => {
-	it("creates a graph with expected nodes", () => {
-		const bundle = reactiveBlockLayout({ adapters: mockAdapters() });
-		const desc = bundle.graph.describe();
-		expect(desc.nodes).toHaveProperty("blocks");
-		expect(desc.nodes).toHaveProperty("max-width");
-		expect(desc.nodes).toHaveProperty("gap");
-		expect(desc.nodes).toHaveProperty("measured-blocks");
-		expect(desc.nodes).toHaveProperty("block-flow");
-		expect(desc.nodes).toHaveProperty("total-height");
-	});
-
-	it("has correct edges for describe() visibility", () => {
-		const bundle = reactiveBlockLayout({ adapters: mockAdapters() });
-		const desc = bundle.graph.describe();
-		const edgeStrings = desc.edges.map((e: { from: string; to: string }) => `${e.from}->${e.to}`);
-		expect(edgeStrings).toContain("blocks->measured-blocks");
-		expect(edgeStrings).toContain("max-width->measured-blocks");
-		expect(edgeStrings).toContain("measured-blocks->block-flow");
-		expect(edgeStrings).toContain("gap->block-flow");
-		expect(edgeStrings).toContain("block-flow->total-height");
-	});
-
-	it("computes correct height for text blocks", () => {
-		const bundle = reactiveBlockLayout({
-			adapters: mockAdapters(),
-			blocks: [{ type: "text", text: "hello world" }],
-			maxWidth: 800,
-		});
-		const unsub = bundle.totalHeight.subscribe(() => {});
-		expect(bundle.totalHeight.cache).toBeGreaterThan(0);
-		unsub();
-	});
-
-	it("computes correct height for mixed blocks", () => {
-		const bundle = reactiveBlockLayout({
-			adapters: mockAdapters(),
-			blocks: [
-				{ type: "text", text: "hello" },
-				{ type: "image", src: "pic.png", naturalWidth: 200, naturalHeight: 100 },
-			],
-			maxWidth: 800,
-		});
-		const unsub = bundle.totalHeight.subscribe(() => {});
-		const flow = bundle.blockFlow.cache as PositionedBlock[];
-		expect(flow).toHaveLength(2);
-		expect(flow[0]!.type).toBe("text");
-		expect(flow[1]!.type).toBe("image");
-		expect(flow[1]!.width).toBe(200);
-		expect(flow[1]!.height).toBe(100);
-		const total = bundle.totalHeight.cache;
-		expect(total).toBe(flow[0]!.height + flow[1]!.height);
-		unsub();
-	});
-
-	it("recomputes on setBlocks", () => {
-		const bundle = reactiveBlockLayout({
-			adapters: mockAdapters(),
-			blocks: [{ type: "text", text: "hello" }],
-			maxWidth: 800,
-		});
-		const unsub = bundle.totalHeight.subscribe(() => {});
-		const h1 = bundle.totalHeight.cache;
-		bundle.setBlocks([
-			{ type: "text", text: "hello" },
-			{ type: "image", src: "x.png", naturalWidth: 100, naturalHeight: 50 },
-		]);
-		const h2 = bundle.totalHeight.cache;
-		expect(h2).toBeGreaterThan(h1);
-		unsub();
-	});
-
-	it("recomputes on setMaxWidth", () => {
-		const bundle = reactiveBlockLayout({
-			adapters: mockAdapters(),
-			blocks: [{ type: "image", src: "wide.png", naturalWidth: 1600, naturalHeight: 900 }],
-			maxWidth: 800,
-		});
-		const unsub = bundle.totalHeight.subscribe(() => {});
-		const m1 = bundle.measuredBlocks.cache as MeasuredBlock[];
-		expect(m1[0]!.width).toBe(800);
-		expect(m1[0]!.height).toBe(450);
-
-		bundle.setMaxWidth(400);
-		const m2 = bundle.measuredBlocks.cache as MeasuredBlock[];
-		expect(m2[0]!.width).toBe(400);
-		expect(m2[0]!.height).toBe(225);
-		unsub();
-	});
-
-	it("respects gap setting", () => {
-		const bundle = reactiveBlockLayout({
-			adapters: mockAdapters(),
-			blocks: [
-				{ type: "image", src: "a.png", naturalWidth: 100, naturalHeight: 50 },
-				{ type: "image", src: "b.png", naturalWidth: 100, naturalHeight: 50 },
-			],
-			maxWidth: 800,
-			gap: 10,
-		});
-		const unsub = bundle.totalHeight.subscribe(() => {});
-		const flow = bundle.blockFlow.cache as PositionedBlock[];
-		expect(flow[0]!.y).toBe(0);
-		expect(flow[1]!.y).toBe(60); // 50 + 10
-		expect(bundle.totalHeight.cache).toBe(110); // 60 + 50
-		unsub();
-	});
-
-	it("setGap recomputes flow", () => {
-		const bundle = reactiveBlockLayout({
-			adapters: mockAdapters(),
-			blocks: [
-				{ type: "image", src: "a.png", naturalWidth: 100, naturalHeight: 50 },
-				{ type: "image", src: "b.png", naturalWidth: 100, naturalHeight: 50 },
-			],
-			maxWidth: 800,
-			gap: 0,
-		});
-		const unsub = bundle.totalHeight.subscribe(() => {});
-		expect(bundle.totalHeight.cache).toBe(100);
-		bundle.setGap(20);
-		expect(bundle.totalHeight.cache).toBe(120);
-		unsub();
-	});
-
-	it("INVALIDATE clears measurement cache", () => {
-		let clearCount = 0;
-		const adapter: MeasurementAdapter = {
-			measureSegment(text: string, _font: string) {
-				return { width: text.length * CHAR_WIDTH };
-			},
-			clearCache() {
-				clearCount++;
-			},
-		};
-		const bundle = reactiveBlockLayout({
-			adapters: { text: adapter },
-			blocks: [{ type: "text", text: "hello" }],
-			maxWidth: 800,
-		});
-		const unsub = bundle.measuredBlocks.subscribe(() => {});
-		// Force initial computation
-		bundle.measuredBlocks.cache;
-
-		// Send INVALIDATE to the graph — signal broadcasts to all nodes,
-		// so clearCache may be called more than once (once per INVALIDATE delivery)
-		bundle.graph.signal([[INVALIDATE]]);
-		expect(clearCount).toBeGreaterThanOrEqual(1);
-		unsub();
-	});
-
-	it("graph is snapshotable", () => {
-		const bundle = reactiveBlockLayout({
-			adapters: mockAdapters(),
-			blocks: [{ type: "text", text: "hello" }],
-			maxWidth: 800,
-		});
-		const snap = bundle.graph.snapshot();
-		expect(snap).toBeDefined();
-		expect(snap.nodes).toHaveProperty("blocks");
-		expect(snap.nodes).toHaveProperty("total-height");
-	});
-
-	it("measured-blocks meta has block-count and layout-time-ns", () => {
-		const bundle = reactiveBlockLayout({
-			adapters: mockAdapters(),
-			blocks: [
-				{ type: "text", text: "hello" },
-				{ type: "image", src: "a.png", naturalWidth: 100, naturalHeight: 50 },
-			],
-			maxWidth: 800,
-		});
-		const unsub = bundle.measuredBlocks.subscribe(() => {});
-		// Force computation
-		bundle.measuredBlocks.cache;
-		const mbNode = bundle.graph.node("measured-blocks");
-		expect(mbNode.meta).toBeDefined();
-		expect(mbNode.meta["block-count"]?.cache).toBe(2);
-		expect(typeof mbNode.meta["layout-time-ns"]?.cache).toBe("number");
-		unsub();
-	});
-
-	it("INVALIDATE preserves meta values (spec §2.3 — meta survives INVALIDATE)", () => {
-		const bundle = reactiveBlockLayout({
-			adapters: mockAdapters(),
-			blocks: [
-				{ type: "text", text: "hello" },
-				{ type: "image", src: "a.png", naturalWidth: 100, naturalHeight: 50 },
-			],
-			maxWidth: 800,
-		});
-		const unsub = bundle.measuredBlocks.subscribe(() => {});
-		bundle.measuredBlocks.cache;
-
-		const mbNode = bundle.graph.node("measured-blocks");
-		const countBefore = mbNode.meta["block-count"]?.cache;
-		expect(countBefore).toBe(2);
-
-		bundle.graph.signal([[INVALIDATE]]);
-
-		// Meta should survive INVALIDATE (spec §2.3)
-		expect(mbNode.meta["block-count"]?.cache).toBe(countBefore);
-		unsub();
-	});
-
-	it("handles negative gap (overlapping blocks)", () => {
-		const bundle = reactiveBlockLayout({
-			adapters: mockAdapters(),
-			blocks: [
-				{ type: "image", src: "a.png", naturalWidth: 100, naturalHeight: 50 },
-				{ type: "image", src: "b.png", naturalWidth: 100, naturalHeight: 50 },
-			],
-			maxWidth: 800,
-			gap: -10,
-		});
-		const unsub = bundle.totalHeight.subscribe(() => {});
-		const flow = bundle.blockFlow.cache as PositionedBlock[];
-		expect(flow[0]!.y).toBe(0);
-		expect(flow[1]!.y).toBe(40); // 50 + (-10)
-		expect(bundle.totalHeight.cache).toBe(90); // 40 + 50
-		unsub();
-	});
-
-	it("handles zero maxWidth (degenerate)", () => {
-		// Zero maxWidth: images scale to 0, text wraps per-grapheme
-		const bundle = reactiveBlockLayout({
-			adapters: mockAdapters(),
-			blocks: [{ type: "image", src: "a.png", naturalWidth: 100, naturalHeight: 50 }],
-			maxWidth: 0,
-		});
-		const unsub = bundle.totalHeight.subscribe(() => {});
-		const m = bundle.measuredBlocks.cache as MeasuredBlock[];
-		// Image wider than maxWidth=0: scales to w=0, h=0
-		expect(m[0]!.width).toBe(0);
-		expect(m[0]!.height).toBe(0);
-		unsub();
-	});
-
-	it("clamps negative maxWidth to 0 on init and setMaxWidth", () => {
-		const bundle = reactiveBlockLayout({
-			adapters: mockAdapters(),
-			blocks: [],
-			maxWidth: -100,
-		});
-		expect(bundle.graph.node("max-width").cache).toBe(0);
-		bundle.setMaxWidth(-5);
-		expect(bundle.graph.node("max-width").cache).toBe(0);
-	});
-});
diff --git a/src/__tests__/utils/reactive-layout/reactive-flow-layout.test.ts b/src/__tests__/utils/reactive-layout/reactive-flow-layout.test.ts
deleted file mode 100644
index 0ae243da..00000000
--- a/src/__tests__/utils/reactive-layout/reactive-flow-layout.test.ts
+++ /dev/null
@@ -1,402 +0,0 @@
-/**
- * Tests for cursor-based single-line layout + slot carving + flow-layout factory.
- *
- * Mock adapter is 8px per character (deterministic, no Canvas).
- */
-import { describe, expect, it } from "vitest";
-import {
-	circleIntervalForBand,
-	computeFlowLines,
-	reactiveFlowLayout,
-	rectIntervalForBand,
-} from "../../../utils/reactive-layout/reactive-flow-layout.js";
-import {
-	analyzeAndMeasure,
-	carveTextLineSlots,
-	type LayoutCursor,
-	layoutNextLine,
-	type MeasurementAdapter,
-	type PreparedSegment,
-} from "../../../utils/reactive-layout/reactive-layout.js";
-
-const CHAR_WIDTH = 8;
-
-function mockAdapter(): MeasurementAdapter {
-	return {
-		measureSegment(text: string, _font: string) {
-			return { width: text.length * CHAR_WIDTH };
-		},
-	};
-}
-
-function prep(text: string): PreparedSegment[] {
-	return analyzeAndMeasure(text, "16px mono", mockAdapter(), new Map());
-}
-
-// ---------------------------------------------------------------------------
-// carveTextLineSlots
-// ---------------------------------------------------------------------------
-
-describe("carveTextLineSlots", () => {
-	it("returns base when no blockers", () => {
-		expect(carveTextLineSlots({ left: 0, right: 600 }, [])).toEqual([{ left: 0, right: 600 }]);
-	});
-
-	it("carves a single centered blocker into two slots", () => {
-		const out = carveTextLineSlots({ left: 0, right: 600 }, [{ left: 200, right: 280 }]);
-		expect(out).toEqual([
-			{ left: 0, right: 200 },
-			{ left: 280, right: 600 },
-		]);
-	});
-
-	it("drops the left slot when blocker overlaps left edge", () => {
-		const out = carveTextLineSlots({ left: 100, right: 600 }, [{ left: 50, right: 200 }]);
-		expect(out).toEqual([{ left: 200, right: 600 }]);
-	});
-
-	it("returns empty when blocker fully covers base", () => {
-		const out = carveTextLineSlots({ left: 100, right: 400 }, [{ left: 50, right: 500 }]);
-		expect(out).toEqual([]);
-	});
-
-	it("filters slots narrower than minSlotWidth", () => {
-		const out = carveTextLineSlots({ left: 0, right: 600 }, [{ left: 30, right: 580 }], 40);
-		// Left: width 30 (dropped). Right: width 20 (dropped).
-		expect(out).toEqual([]);
-	});
-
-	it("handles multiple non-overlapping blockers", () => {
-		const out = carveTextLineSlots({ left: 0, right: 1000 }, [
-			{ left: 100, right: 200 },
-			{ left: 400, right: 500 },
-			{ left: 700, right: 800 },
-		]);
-		expect(out).toEqual([
-			{ left: 0, right: 100 },
-			{ left: 200, right: 400 },
-			{ left: 500, right: 700 },
-			{ left: 800, right: 1000 },
-		]);
-	});
-});
-
-// ---------------------------------------------------------------------------
-// layoutNextLine
-// ---------------------------------------------------------------------------
-
-describe("layoutNextLine", () => {
-	it("returns null for empty input", () => {
-		expect(layoutNextLine([], { segmentIndex: 0, graphemeIndex: 0 }, 200)).toBeNull();
-	});
-
-	it("fits one line when text fits entirely", () => {
-		const segs = prep("hello world");
-		const line = layoutNextLine(segs, { segmentIndex: 0, graphemeIndex: 0 }, 200);
-		expect(line).not.toBeNull();
-		expect(line?.text).toBe("hello world");
-		expect(line?.end.segmentIndex).toBeGreaterThanOrEqual(segs.length - 1);
-	});
-
-	it("breaks at the last pending space when overflowing (trailing space hangs)", () => {
-		// Each char 8px → "alpha" = 40, " " = 8. Budget 60 → "alpha " fits (48),
-		// "beta" overflows. Break at pending space: line is "alpha " (trailing space hangs).
-		const segs = prep("alpha beta gamma");
-		const line = layoutNextLine(segs, { segmentIndex: 0, graphemeIndex: 0 }, 60);
-		expect(line).not.toBeNull();
-		expect(line?.text).toBe("alpha ");
-		// Width excludes the hanging trailing space (CSS behavior).
-		expect(line?.width).toBe(5 * CHAR_WIDTH);
-	});
-
-	it("advances cursor across multiple calls, seamlessly", () => {
-		const segs = prep("one two three four five six");
-		let cursor: LayoutCursor = { segmentIndex: 0, graphemeIndex: 0 };
-		const lines: string[] = [];
-		for (let i = 0; i < 20; i++) {
-			const ln = layoutNextLine(segs, cursor, 60);
-			if (ln === null) break;
-			lines.push(ln.text);
-			cursor = ln.end;
-		}
-		// Concatenating preserves the source text (trailing spaces hang on wrapped lines).
-		expect(lines.join("")).toBe("one two three four five six");
-	});
-
-	it("returns an empty line at hard-breaks and advances past them", () => {
-		// Manually construct — analyzeAndMeasure normalizes \n to space.
-		const segs: PreparedSegment[] = [
-			{ text: "line1", width: 40, kind: "text", graphemeWidths: null },
-			{ text: "\n", width: 0, kind: "hard-break", graphemeWidths: null },
-			{ text: "line2", width: 40, kind: "text", graphemeWidths: null },
-		];
-		const first = layoutNextLine(segs, { segmentIndex: 0, graphemeIndex: 0 }, 200);
-		expect(first?.text).toBe("line1");
-		expect(first?.end.segmentIndex).toBe(1);
-		const second = layoutNextLine(segs, first!.end, 200);
-		// Hard-break at cursor → empty line advancing past it.
-		expect(second?.text).toBe("");
-		expect(second?.end.segmentIndex).toBe(2);
-		const third = layoutNextLine(segs, second!.end, 200);
-		expect(third?.text).toBe("line2");
-	});
-
-	it("yields null when cursor is past all segments", () => {
-		const segs = prep("hi");
-		const first = layoutNextLine(segs, { segmentIndex: 0, graphemeIndex: 0 }, 200);
-		expect(first).not.toBeNull();
-		expect(layoutNextLine(segs, first!.end, 200)).toBeNull();
-	});
-
-	it("skips leading whitespace on a fresh line", () => {
-		// Start mid-stream at a space-kind segment → skip it, start on the next word.
-		const segs = prep("alpha beta");
-		// segments: [text("alpha"), space(" "), text("beta")]
-		// Start at index 1 (the space) — leading whitespace must be skipped.
-		const line = layoutNextLine(segs, { segmentIndex: 1, graphemeIndex: 0 }, 40);
-		expect(line?.text).toBe("beta");
-		expect(line?.width).toBe(4 * CHAR_WIDTH);
-	});
-});
-
-// ---------------------------------------------------------------------------
-// circleIntervalForBand / rectIntervalForBand
-// ---------------------------------------------------------------------------
-
-describe("circleIntervalForBand", () => {
-	it("returns null when band is fully above the circle", () => {
-		const iv = circleIntervalForBand({ kind: "circle", cx: 100, cy: 200, r: 50 }, 0, 100);
-		expect(iv).toBeNull();
-	});
-
-	it("returns null when band is fully below the circle", () => {
-		const iv = circleIntervalForBand({ kind: "circle", cx: 100, cy: 200, r: 50 }, 300, 400);
-		expect(iv).toBeNull();
-	});
-
-	it("returns full diameter interval when band passes through center", () => {
-		const iv = circleIntervalForBand({ kind: "circle", cx: 100, cy: 200, r: 50 }, 190, 210);
-		expect(iv).not.toBeNull();
-		expect(iv!.left).toBeCloseTo(50, 5);
-		expect(iv!.right).toBeCloseTo(150, 5);
-	});
-
-	it("applies padding to the returned interval", () => {
-		const iv = circleIntervalForBand(
-			{ kind: "circle", cx: 100, cy: 200, r: 50, hPad: 10 },
-			190,
-			210,
-		);
-		expect(iv!.left).toBeCloseTo(40, 5);
-		expect(iv!.right).toBeCloseTo(160, 5);
-	});
-});
-
-describe("rectIntervalForBand", () => {
-	it("returns null when band is above the rect", () => {
-		const iv = rectIntervalForBand({ kind: "rect", x: 100, y: 200, w: 50, h: 50 }, 0, 100);
-		expect(iv).toBeNull();
-	});
-
-	it("returns the rect's left/right when band intersects", () => {
-		const iv = rectIntervalForBand({ kind: "rect", x: 100, y: 200, w: 50, h: 50 }, 220, 230);
-		expect(iv).toEqual({ left: 100, right: 150 });
-	});
-});
-
-// ---------------------------------------------------------------------------
-// computeFlowLines (pure)
-// ---------------------------------------------------------------------------
-
-describe("computeFlowLines", () => {
-	it("lays out a single column with no obstacles", () => {
-		const segs = prep("alpha beta gamma delta");
-		const { lines } = computeFlowLines(
-			segs,
-			{ width: 80, height: 200, paddingX: 0, paddingY: 0 },
-			{ count: 1, gap: 0 },
-			[],
-			20,
-			10,
-		);
-		expect(lines.length).toBeGreaterThan(0);
-		for (const l of lines) {
-			expect(l.x).toBe(0);
-			expect(l.columnIndex).toBe(0);
-		}
-	});
-
-	it("carries the cursor from column 1 to column 2 (no duplication)", () => {
-		const segs = prep("one two three four five six seven eight nine ten");
-		const { lines } = computeFlowLines(
-			segs,
-			{ width: 200, height: 40, paddingX: 0, paddingY: 0 },
-			{ count: 2, gap: 20 },
-			[],
-			20,
-			10,
-		);
-		const col0 = lines.filter((l) => l.columnIndex === 0).map((l) => l.text);
-		const col1 = lines.filter((l) => l.columnIndex === 1).map((l) => l.text);
-		expect(col0.length).toBeGreaterThan(0);
-		expect(col1.length).toBeGreaterThan(0);
-		// No text appears in both columns
-		for (const t of col0) expect(col1).not.toContain(t);
-	});
-
-	it("splits a line into two slots around a centered circle obstacle", () => {
-		// Long text so both slots at band y=0 are filled (not exhausted early).
-		const word = "quick brown fox jumps over the lazy dog and ";
-		const segs = prep(word.repeat(8).trim());
-		const { lines } = computeFlowLines(
-			segs,
-			{ width: 600, height: 40, paddingX: 0, paddingY: 0 },
-			{ count: 1, gap: 0 },
-			[{ kind: "circle", cx: 300, cy: 10, r: 80, hPad: 8 }],
-			20,
-			20,
-		);
-		// First band (y=0..20) has two slots carved by the circle — expect lines
-		// on both sides of the obstacle at the same y.
-		const band = lines.filter((l) => l.y === 0);
-		expect(band.length).toBe(2);
-		const xs = band.map((l) => l.x).sort((a, b) => a - b);
-		expect(xs[0]).toBe(0);
-		expect(xs[1]).toBeGreaterThan(300);
-	});
-
-	it("reports overflow cursor when container can't fit all text", () => {
-		const segs = prep("one two three four five six seven eight nine ten eleven twelve");
-		const { lines, cursor } = computeFlowLines(
-			segs,
-			// Very small container → text truncates.
-			{ width: 40, height: 40, paddingX: 0, paddingY: 0 },
-			{ count: 1, gap: 0 },
-			[],
-			20,
-			10,
-		);
-		expect(lines.length).toBeGreaterThan(0);
-		// Cursor didn't reach end of segments → overflow.
-		expect(cursor.segmentIndex).toBeLessThan(segs.length);
-	});
-
-	it("hard-break advances the band (produces visible paragraph gap)", () => {
-		// Manually build segments with a hard-break between two words.
-		const segs: PreparedSegment[] = [
-			{ text: "alpha", width: 40, kind: "text", graphemeWidths: null },
-			{ text: "\n", width: 0, kind: "hard-break", graphemeWidths: null },
-			{ text: "beta", width: 32, kind: "text", graphemeWidths: null },
-		];
-		const { lines } = computeFlowLines(
-			segs,
-			{ width: 400, height: 200, paddingX: 0, paddingY: 0 },
-			{ count: 1, gap: 0 },
-			[],
-			20,
-			10,
-		);
-		expect(lines.map((l) => l.text)).toEqual(["alpha", "beta"]);
-		// Paragraph gap: "beta" sits at least 2 line-heights below "alpha".
-		const alpha = lines.find((l) => l.text === "alpha");
-		const beta = lines.find((l) => l.text === "beta");
-		expect(beta!.y - alpha!.y).toBeGreaterThanOrEqual(40);
-	});
-
-	it("D7: paragraphSpacing default tracks lineHeight reactively", () => {
-		// Pure `computeFlowLines` side: default is lineHeight when opts omitted.
-		const segs: PreparedSegment[] = [
-			{ text: "alpha", width: 40, kind: "text", graphemeWidths: null },
-			{ text: "\n", width: 0, kind: "hard-break", graphemeWidths: null },
-			{ text: "beta", width: 32, kind: "text", graphemeWidths: null },
-		];
-		const container = { width: 400, height: 400, paddingX: 0, paddingY: 0 };
-		const columns = { count: 1, gap: 0 };
-		// Default (no opts) = lineHeight → beta sits 2 * lineHeight below alpha.
-		const outA = computeFlowLines(segs, container, columns, [], 20, 10);
-		expect(outA.lines.find((l) => l.text === "beta")!.y).toBe(40);
-		const outB = computeFlowLines(segs, container, columns, [], 40, 10);
-		// With lineHeight=40 the gap scales: beta at 80 (= one line of alpha + one
-		// line-height gap). Proves default "= lineHeight" follows the parameter,
-		// not a snapshot.
-		expect(outB.lines.find((l) => l.text === "beta")!.y).toBe(80);
-	});
-
-	it("D7: paragraphSpacing controls the hard-break gap", () => {
-		const segs: PreparedSegment[] = [
-			{ text: "alpha", width: 40, kind: "text", graphemeWidths: null },
-			{ text: "\n", width: 0, kind: "hard-break", graphemeWidths: null },
-			{ text: "beta", width: 32, kind: "text", graphemeWidths: null },
-		];
-		const container = { width: 400, height: 400, paddingX: 0, paddingY: 0 };
-		const columns = { count: 1, gap: 0 };
-		// paragraphSpacing: 0 → "beta" is one line-height below "alpha" (no gap).
-		const tight = computeFlowLines(segs, container, columns, [], 20, 10, {
-			paragraphSpacing: 0,
-		}).lines;
-		const tightAlpha = tight.find((l) => l.text === "alpha")!;
-		const tightBeta = tight.find((l) => l.text === "beta")!;
-		expect(tightBeta.y - tightAlpha.y).toBe(20);
-
-		// paragraphSpacing: 60 → "beta" sits 20 (alpha's line) + 60 (gap) below.
-		const loose = computeFlowLines(segs, container, columns, [], 20, 10, {
-			paragraphSpacing: 60,
-		}).lines;
-		const looseAlpha = loose.find((l) => l.text === "alpha")!;
-		const looseBeta = loose.find((l) => l.text === "beta")!;
-		expect(looseBeta.y - looseAlpha.y).toBe(80);
-	});
-});
-
-// ---------------------------------------------------------------------------
-// reactiveFlowLayout (reactive graph)
-// ---------------------------------------------------------------------------
-
-describe("reactiveFlowLayout", () => {
-	it("initial flow-lines populates on first read", () => {
-		const flow = reactiveFlowLayout({
-			adapter: mockAdapter(),
-			text: "alpha beta gamma delta epsilon",
-			font: "16px mono",
-			lineHeight: 20,
-			container: { width: 80, height: 200 },
-			columns: { count: 1, gap: 0 },
-		});
-		const unsub = flow.flowLines.subscribe(() => {});
-		const lines = flow.flowLines.cache;
-		expect(Array.isArray(lines)).toBe(true);
-		expect((lines as unknown[]).length).toBeGreaterThan(0);
-		unsub();
-	});
-
-	it("setObstacles re-runs flow-lines but NOT segments (cached)", () => {
-		const flow = reactiveFlowLayout({
-			adapter: mockAdapter(),
-			text: "alpha beta gamma delta epsilon zeta eta theta iota kappa lambda mu nu xi",
-			font: "16px mono",
-			lineHeight: 20,
-			container: { width: 400, height: 200 },
-			columns: { count: 1, gap: 0 },
-		});
-
-		const u1 = flow.segments.subscribe(() => {});
-		const u2 = flow.flowLines.subscribe(() => {});
-
-		const segsBefore = flow.segments.cache;
-		const linesBefore = flow.flowLines.cache as Array<{ text: string }>;
-
-		flow.setObstacles([{ kind: "circle", cx: 200, cy: 30, r: 80 }]);
-
-		const segsAfter = flow.segments.cache;
-		const linesAfter = flow.flowLines.cache as Array<{ text: string }>;
-
-		// Segments unchanged (reference-equal — text/font didn't change).
-		expect(segsAfter).toBe(segsBefore);
-		// Flow lines re-ran → new array, different layout.
-		expect(linesAfter).not.toBe(linesBefore);
-		expect(linesAfter.length).toBeGreaterThan(linesBefore.length);
-
-		u1();
-		u2();
-	});
-});
diff --git a/src/__tests__/utils/reactive-layout/reactive-layout.test.ts b/src/__tests__/utils/reactive-layout/reactive-layout.test.ts
deleted file mode 100644
index 7ccbcf40..00000000
--- a/src/__tests__/utils/reactive-layout/reactive-layout.test.ts
+++ /dev/null
@@ -1,607 +0,0 @@
-/**
- * Tests for reactive text layout engine (roadmap §7.1 — Pretext parity).
- *
- * Uses a MockMeasureAdapter with deterministic widths (8px per character)
- * so tests are environment-independent (no Canvas/DOM).
- */
-
-import { INVALIDATE } from "@graphrefly/pure-ts/core";
-import { afterEach, describe, expect, it } from "vitest";
-import {
-	analyzeAndMeasure,
-	computeCharPositions,
-	computeLineBreaks,
-	type LineBreaksResult,
-	type MeasurementAdapter,
-	type PreparedSegment,
-	reactiveLayout,
-	type SegmentMeasureStats,
-} from "../../../utils/reactive-layout/reactive-layout.js";
-
-// ---------------------------------------------------------------------------
-// Mock adapter: 8px per character (deterministic, no Canvas)
-// ---------------------------------------------------------------------------
-
-const CHAR_WIDTH = 8;
-
-function mockAdapter(): MeasurementAdapter {
-	return {
-		measureSegment(text: string, _font: string) {
-			return { width: text.length * CHAR_WIDTH };
-		},
-	};
-}
-
-// ---------------------------------------------------------------------------
-// Text analysis
-// ---------------------------------------------------------------------------
-
-describe("analyzeAndMeasure", () => {
-	const adapter = mockAdapter();
-
-	it("segments simple text into words and spaces", () => {
-		const segs = analyzeAndMeasure("hello world", "16px mono", adapter, new Map());
-		// Should have at least: "hello", " ", "world"
-		const texts = segs.map((s) => s.text);
-		expect(texts).toContain("hello");
-		expect(texts).toContain("world");
-		// Space segment(s) present
-		const spaceSegs = segs.filter((s) => s.kind === "space");
-		expect(spaceSegs.length).toBeGreaterThan(0);
-	});
-
-	it("returns empty array for empty text", () => {
-		expect(analyzeAndMeasure("", "16px mono", adapter, new Map())).toEqual([]);
-	});
-
-	it("returns empty array for whitespace-only text", () => {
-		expect(analyzeAndMeasure("   ", "16px mono", adapter, new Map())).toEqual([]);
-	});
-
-	it("normalizes collapsible whitespace", () => {
-		const segs = analyzeAndMeasure("hello   world", "16px mono", adapter, new Map());
-		// Multiple spaces collapse to single space
-		const spaceSegs = segs.filter((s) => s.kind === "space");
-		for (const s of spaceSegs) {
-			expect(s.text).toBe(" ");
-		}
-	});
-
-	it("merges left-sticky punctuation into preceding word", () => {
-		const segs = analyzeAndMeasure("hello, world", "16px mono", adapter, new Map());
-		// "hello," should be a single segment (comma merged)
-		const helloSeg = segs.find((s) => s.text.startsWith("hello"));
-		expect(helloSeg).toBeDefined();
-		expect(helloSeg!.text).toBe("hello,");
-	});
-
-	it("measures segment widths correctly", () => {
-		const segs = analyzeAndMeasure("abc", "16px mono", adapter, new Map());
-		const textSeg = segs.find((s) => s.kind === "text");
-		expect(textSeg).toBeDefined();
-		expect(textSeg!.width).toBe(3 * CHAR_WIDTH);
-	});
-
-	it("caches measurements per font", () => {
-		const cache = new Map<string, Map<string, number>>();
-		analyzeAndMeasure("abc", "16px mono", adapter, cache);
-		expect(cache.has("16px mono")).toBe(true);
-		// Second call uses cache
-		analyzeAndMeasure("abc def", "16px mono", adapter, cache);
-		expect(cache.get("16px mono")!.has("abc")).toBe(true);
-	});
-
-	it("splits CJK text into per-grapheme segments", () => {
-		const segs = analyzeAndMeasure("你好世界", "16px mono", adapter, new Map());
-		// CJK characters should be split for per-character line breaking
-		expect(segs.length).toBeGreaterThanOrEqual(2);
-		for (const seg of segs) {
-			if (seg.kind === "text") {
-				// Each CJK grapheme should be its own segment (or small clusters with kinsoku)
-				expect(seg.text.length).toBeLessThanOrEqual(2);
-			}
-		}
-	});
-
-	it("pre-computes grapheme widths for long words (break-word)", () => {
-		const segs = analyzeAndMeasure("superlongword", "16px mono", adapter, new Map());
-		const wordSeg = segs.find((s) => s.kind === "text" && s.text === "superlongword");
-		expect(wordSeg).toBeDefined();
-		expect(wordSeg!.graphemeWidths).not.toBeNull();
-		expect(wordSeg!.graphemeWidths!.length).toBe(13);
-	});
-
-	it("handles soft hyphens", () => {
-		const segs = analyzeAndMeasure("auto\u00ADmatic", "16px mono", adapter, new Map());
-		const kinds = segs.map((s) => s.kind);
-		expect(kinds).toContain("soft-hyphen");
-	});
-
-	it("optional stats bag records hits and misses for cache ratio", () => {
-		const cache = new Map<string, Map<string, number>>();
-		const stats: SegmentMeasureStats = { hits: 0, misses: 0 };
-		analyzeAndMeasure("aa", "16px mono", adapter, cache, stats);
-		expect(stats.misses).toBeGreaterThan(0);
-		const missesAfterFirst = stats.misses;
-		const hitsAfterFirst = stats.hits;
-		analyzeAndMeasure("aa", "16px mono", adapter, cache, stats);
-		expect(stats.hits).toBeGreaterThan(hitsAfterFirst);
-		expect(stats.misses).toBe(missesAfterFirst);
-	});
-});
-
-// ---------------------------------------------------------------------------
-// Line breaking
-// ---------------------------------------------------------------------------
-
-describe("computeLineBreaks", () => {
-	const adapter = mockAdapter();
-	const font = "16px mono";
-
-	function breakLines(text: string, maxWidth: number): LineBreaksResult {
-		const cache = new Map<string, Map<string, number>>();
-		const segs = analyzeAndMeasure(text, font, adapter, cache);
-		return computeLineBreaks(segs, maxWidth, adapter, font, cache);
-	}
-
-	it("single line when text fits", () => {
-		const result = breakLines("hello", 100);
-		expect(result.lineCount).toBe(1);
-		expect(result.lines[0]!.text).toBe("hello");
-		expect(result.lines[0]!.width).toBe(5 * CHAR_WIDTH);
-	});
-
-	it("wraps at word boundary", () => {
-		// "hello world" = 5*8 + 8 + 5*8 = 88px; maxWidth=60 forces wrap
-		const result = breakLines("hello world", 60);
-		expect(result.lineCount).toBe(2);
-		// Trailing space hangs past line edge (CSS behavior), included in line text
-		expect(result.lines[0]!.text).toBe("hello ");
-		expect(result.lines[1]!.text).toBe("world");
-	});
-
-	it("handles multiple words wrapping across lines", () => {
-		// "aa bb cc" → each word = 16px, space = 8px
-		// maxWidth = 30: "aa" fits (16), "aa bb" = 40 > 30
-		const result = breakLines("aa bb cc", 30);
-		expect(result.lineCount).toBe(3);
-	});
-
-	it("empty text produces no lines", () => {
-		const result = breakLines("", 100);
-		expect(result.lineCount).toBe(0);
-		expect(result.lines).toEqual([]);
-	});
-
-	it("break-word splits long words at grapheme boundaries", () => {
-		// "abcdefghij" = 80px; maxWidth=40 → needs 2 lines
-		const result = breakLines("abcdefghij", 40);
-		expect(result.lineCount).toBe(2);
-		// First line should have 5 chars (40px), second line 5 chars
-		expect(result.lines[0]!.text.length).toBe(5);
-		expect(result.lines[1]!.text.length).toBe(5);
-	});
-
-	it("trailing space hangs past line edge", () => {
-		// "hello " + "world"; maxWidth exactly fits "hello" (40px)
-		// Space should hang, "world" goes to next line
-		const result = breakLines("hello world", 40);
-		expect(result.lineCount).toBe(2);
-		expect(result.lines[0]!.text).toBe("hello ");
-		expect(result.lines[1]!.text).toBe("world");
-	});
-
-	it("handles hard breaks (newline)", () => {
-		// analyzeAndMeasure normalizes whitespace, so hard breaks inside
-		// normalized text are preserved only if present after normalization.
-		// For this test, use the raw computeLineBreaks with manual segments.
-		const segs: PreparedSegment[] = [
-			{ text: "line1", width: 40, kind: "text", graphemeWidths: null },
-			{ text: "\n", width: 0, kind: "hard-break", graphemeWidths: null },
-			{ text: "line2", width: 40, kind: "text", graphemeWidths: null },
-		];
-		const cache = new Map<string, Map<string, number>>();
-		const result = computeLineBreaks(segs, 200, adapter, font, cache);
-		expect(result.lineCount).toBe(2);
-		expect(result.lines[0]!.text).toBe("line1");
-		expect(result.lines[1]!.text).toBe("line2");
-	});
-
-	it("soft hyphen creates break opportunity with visible hyphen", () => {
-		// "auto" + soft-hyphen + "matic" — if maxWidth forces break at hyphen
-		const segs: PreparedSegment[] = [
-			{ text: "auto", width: 32, kind: "text", graphemeWidths: null },
-			{ text: "\u00AD", width: 0, kind: "soft-hyphen", graphemeWidths: null },
-			{ text: "matic", width: 40, kind: "text", graphemeWidths: null },
-		];
-		const cache = new Map<string, Map<string, number>>();
-		// maxWidth = 40: "auto" (32) + soft-hyphen (0) + "matic" (40) = 72 > 40
-		const result = computeLineBreaks(segs, 40, adapter, font, cache);
-		expect(result.lineCount).toBe(2);
-		expect(result.lines[0]!.text).toBe("auto-");
-		expect(result.lines[1]!.text).toBe("matic");
-	});
-});
-
-// ---------------------------------------------------------------------------
-// Char positions
-// ---------------------------------------------------------------------------
-
-describe("computeCharPositions", () => {
-	const lineHeight = 20;
-
-	it("computes x,y for single-line text", () => {
-		const segs: PreparedSegment[] = [
-			{
-				text: "abc",
-				width: 24,
-				kind: "text",
-				graphemeWidths: [8, 8, 8],
-			},
-		];
-		const lb: LineBreaksResult = {
-			lineCount: 1,
-			lines: [
-				{
-					text: "abc",
-					width: 24,
-					startSegment: 0,
-					startGrapheme: 0,
-					endSegment: 1,
-					endGrapheme: 0,
-				},
-			],
-		};
-		const positions = computeCharPositions(lb, segs, lineHeight);
-		expect(positions.length).toBe(3);
-		expect(positions[0]).toEqual({
-			x: 0,
-			y: 0,
-			width: 8,
-			height: 20,
-			line: 0,
-		});
-		expect(positions[1]).toEqual({
-			x: 8,
-			y: 0,
-			width: 8,
-			height: 20,
-			line: 0,
-		});
-		expect(positions[2]).toEqual({
-			x: 16,
-			y: 0,
-			width: 8,
-			height: 20,
-			line: 0,
-		});
-	});
-
-	it("computes y offset for second line", () => {
-		const segs: PreparedSegment[] = [
-			{
-				text: "ab",
-				width: 16,
-				kind: "text",
-				graphemeWidths: [8, 8],
-			},
-			{ text: " ", width: 8, kind: "space", graphemeWidths: null },
-			{
-				text: "cd",
-				width: 16,
-				kind: "text",
-				graphemeWidths: [8, 8],
-			},
-		];
-		const lb: LineBreaksResult = {
-			lineCount: 2,
-			lines: [
-				{
-					text: "ab",
-					width: 16,
-					startSegment: 0,
-					startGrapheme: 0,
-					endSegment: 1,
-					endGrapheme: 0,
-				},
-				{
-					text: "cd",
-					width: 16,
-					startSegment: 2,
-					startGrapheme: 0,
-					endSegment: 3,
-					endGrapheme: 0,
-				},
-			],
-		};
-		const positions = computeCharPositions(lb, segs, lineHeight);
-		// Line 2 chars should have y = 20
-		const line2Pos = positions.filter((p) => p.line === 1);
-		expect(line2Pos.length).toBe(2);
-		expect(line2Pos[0]!.y).toBe(20);
-	});
-
-	it("skips empty TEXT segments without dividing by zero", () => {
-		const segs: PreparedSegment[] = [{ text: "", width: 0, kind: "text", graphemeWidths: null }];
-		const lb: LineBreaksResult = {
-			lineCount: 1,
-			lines: [
-				{
-					text: "",
-					width: 0,
-					startSegment: 0,
-					startGrapheme: 0,
-					endSegment: 1,
-					endGrapheme: 0,
-				},
-			],
-		};
-		expect(computeCharPositions(lb, segs, 20)).toEqual([]);
-	});
-});
-
-// ---------------------------------------------------------------------------
-// Reactive graph factory
-// ---------------------------------------------------------------------------
-
-describe("reactiveLayout", () => {
-	let layout: ReturnType<typeof reactiveLayout>;
-
-	afterEach(() => {
-		layout?.graph.destroy();
-	});
-
-	it("creates a graph with all expected nodes", () => {
-		layout = reactiveLayout({
-			adapter: mockAdapter(),
-			text: "hello world",
-			maxWidth: 200,
-		});
-		const desc = layout.graph.describe();
-		expect(desc.nodes).toHaveProperty("text");
-		expect(desc.nodes).toHaveProperty("font");
-		expect(desc.nodes).toHaveProperty("line-height");
-		expect(desc.nodes).toHaveProperty("max-width");
-		expect(desc.nodes).toHaveProperty("segments");
-		expect(desc.nodes).toHaveProperty("line-breaks");
-		expect(desc.nodes).toHaveProperty("height");
-		expect(desc.nodes).toHaveProperty("char-positions");
-	});
-
-	it("computes correct height for single-line text", () => {
-		layout = reactiveLayout({
-			adapter: mockAdapter(),
-			text: "hello",
-			font: "16px mono",
-			lineHeight: 20,
-			maxWidth: 200,
-		});
-		const unsub = layout.height.subscribe(() => {});
-		expect(layout.height.cache).toBe(20); // 1 line * 20px
-		unsub();
-	});
-
-	it("recomputes on text change", () => {
-		layout = reactiveLayout({
-			adapter: mockAdapter(),
-			text: "hello",
-			font: "16px mono",
-			lineHeight: 20,
-			maxWidth: 48, // 6 chars fit
-		});
-
-		const unsub = layout.height.subscribe(() => {});
-
-		// Initial: "hello" (5 chars = 40px) fits in 48px → 1 line
-		expect(layout.height.cache).toBe(20);
-
-		// Change text to something that wraps
-		layout.setText("hello world"); // 11 chars + space → wraps
-		expect(layout.height.cache).toBe(40); // 2 lines
-		unsub();
-	});
-
-	it("recomputes on maxWidth change", () => {
-		layout = reactiveLayout({
-			adapter: mockAdapter(),
-			text: "hello world",
-			font: "16px mono",
-			lineHeight: 20,
-			maxWidth: 200,
-		});
-
-		const unsub = layout.height.subscribe(() => {});
-		expect(layout.height.cache).toBe(20); // Fits in 1 line
-
-		layout.setMaxWidth(40); // Force wrap
-		expect(layout.height.cache).toBe(40); // 2 lines
-		unsub();
-	});
-
-	it("clamps negative maxWidth to 0 on init and setMaxWidth", () => {
-		layout = reactiveLayout({
-			adapter: mockAdapter(),
-			text: "hi",
-			maxWidth: -50,
-		});
-		expect(layout.graph.node("max-width").cache).toBe(0);
-		layout.setMaxWidth(-20);
-		expect(layout.graph.node("max-width").cache).toBe(0);
-	});
-
-	it("segments node has meta for observability", () => {
-		layout = reactiveLayout({
-			adapter: mockAdapter(),
-			text: "hello world",
-			maxWidth: 200,
-		});
-		const desc = layout.graph.describe({ detail: "standard" });
-		const segDesc = desc.nodes.segments;
-		expect(segDesc).toBeDefined();
-		expect(segDesc!.meta).toBeDefined();
-		expect(segDesc!.meta).toHaveProperty("cache-hit-rate");
-		expect(segDesc!.meta).toHaveProperty("segment-count");
-		expect(segDesc!.meta).toHaveProperty("layout-time-ns");
-	});
-
-	it("RESOLVED optimization: unchanged text/font skips re-measure", () => {
-		layout = reactiveLayout({
-			adapter: mockAdapter(),
-			text: "hello",
-			font: "16px mono",
-			lineHeight: 20,
-			maxWidth: 200,
-		});
-
-		const unsub = layout.segments.subscribe(() => {});
-		const segs1 = layout.segments.cache;
-		// Set same text — should trigger RESOLVED (no change)
-		layout.setText("hello");
-		const segs2 = layout.segments.cache;
-		expect(segs1).toEqual(segs2);
-		unsub();
-	});
-
-	it("segments equality includes grapheme widths (no stale char widths on font change)", () => {
-		// `segments` has `{ text, width, kind, graphemeWidths }`.
-		// This adapter keeps overall segment width constant across fonts, but swaps
-		// grapheme widths for `a` and `b`.
-		const adapter: MeasurementAdapter = {
-			measureSegment(text: string, font: string) {
-				if (text === "ab") return { width: 16 };
-				if (text === "a") return { width: font === "f1" ? 6 : 10 };
-				if (text === "b") return { width: font === "f1" ? 10 : 6 };
-				if (text === "-") return { width: 0 }; // hyphen never used in this test
-				return { width: text.length * 8 };
-			},
-		};
-
-		layout = reactiveLayout({
-			adapter,
-			text: "ab",
-			font: "f1",
-			lineHeight: 20,
-			maxWidth: 200,
-		});
-
-		const unsub = layout.charPositions.subscribe(() => {});
-		const initial = layout.charPositions.cache;
-		expect(initial).not.toBeNull();
-		expect(initial!.map((p) => p.width)).toEqual([6, 10]);
-
-		layout.setFont("f2");
-		const updated = layout.charPositions.cache;
-		expect(updated).not.toBeNull();
-		expect(updated!.map((p) => p.width)).toEqual([10, 6]);
-		unsub();
-	});
-
-	it("INVALIDATE clears measurement cache (height changes after cache flush)", async () => {
-		let multiplier = 1;
-		let clearCalls = 0;
-
-		const adapter: MeasurementAdapter = {
-			measureSegment(text: string, _font: string) {
-				return { width: text.length * 8 * multiplier };
-			},
-			clearCache() {
-				clearCalls++;
-			},
-		};
-
-		layout = reactiveLayout({
-			adapter,
-			text: "hello world",
-			font: "16px mono",
-			lineHeight: 20,
-			maxWidth: 90, // 88px (1x) fits, 176px (2x) wraps
-		});
-
-		const unsub = layout.height.subscribe(() => {});
-		expect(layout.height.cache).toBe(20);
-
-		multiplier = 2;
-		layout.graph.signal([[INVALIDATE]]);
-		// INVALIDATE clears cached state of *all* nodes in the graph, including
-		// source nodes like `line-height` — restore them so recomputation yields
-		// deterministic, non-NaN values.
-		layout.setText("hello world");
-		layout.setFont("16px mono");
-		layout.setLineHeight(20);
-		layout.setMaxWidth(90);
-
-		// Give derived nodes a chance to settle after the INVALIDATE + DATA write.
-		await Promise.resolve();
-
-		expect(layout.height.cache).toBe(40);
-		expect(clearCalls).toBeGreaterThanOrEqual(1);
-		unsub();
-	});
-
-	it("char positions are computed correctly", () => {
-		layout = reactiveLayout({
-			adapter: mockAdapter(),
-			text: "ab",
-			font: "16px mono",
-			lineHeight: 20,
-			maxWidth: 200,
-		});
-
-		const unsub = layout.charPositions.subscribe(() => {});
-		const positions = layout.charPositions.cache;
-		expect(positions.length).toBe(2);
-		expect(positions[0]!.x).toBe(0);
-		expect(positions[0]!.y).toBe(0);
-		expect(positions[0]!.width).toBe(CHAR_WIDTH);
-		expect(positions[1]!.x).toBe(CHAR_WIDTH);
-		unsub();
-	});
-
-	it("graph is snapshotable", () => {
-		layout = reactiveLayout({
-			adapter: mockAdapter(),
-			text: "test",
-			maxWidth: 200,
-		});
-		const snapshot = layout.graph.snapshot();
-		expect(snapshot).toBeDefined();
-		expect(snapshot.name).toBe("reactive-layout");
-	});
-
-	it("graph is describable with edges", () => {
-		layout = reactiveLayout({
-			adapter: mockAdapter(),
-			text: "test",
-			maxWidth: 200,
-		});
-		const desc = layout.graph.describe();
-		expect(desc.edges.length).toBeGreaterThan(0);
-	});
-
-	it("meta companion DATA runs after segments DATA (batch-deferred ordering)", () => {
-		layout = reactiveLayout({
-			adapter: mockAdapter(),
-			text: "a",
-			maxWidth: 200,
-		});
-		const order: string[] = [];
-		const u1 = layout.segments.subscribe(() => {
-			order.push("segments");
-		});
-		const u2 = layout.segments.meta?.["cache-hit-rate"]?.subscribe(() => {
-			order.push("meta");
-		});
-		const start = order.length;
-		layout.setText("b");
-		// Meta is delivered via batch deferral (downWithBatch) — runs
-		// synchronously during the batch drain, after segments settles.
-		// All events should be delivered by the time setText returns.
-		const events = order.slice(start);
-		// Meta is delivered synchronously (no microtask needed).
-		// Verify meta appears somewhere in the synchronous delivery.
-		expect(events).toContain("segments");
-		expect(events).toContain("meta");
-		u1();
-		u2?.();
-	});
-});
diff --git a/src/__tests__/utils/reduction/reduction.test.ts b/src/__tests__/utils/reduction/reduction.test.ts
deleted file mode 100644
index 22ee0fd0..00000000
--- a/src/__tests__/utils/reduction/reduction.test.ts
+++ /dev/null
@@ -1,661 +0,0 @@
-// FLAG: v5 behavioral change — needs investigation
-// stratify and feedback tests fail with:
-//   Graph "...": connect(source, target) — target must include source in its constructor deps (same node reference)
-// The underlying pattern factories use Graph.connect() which now enforces deps.
-
-import {
-	batch,
-	COMPLETE,
-	DATA,
-	ERROR,
-	type Messages,
-	node,
-	RESOLVED,
-} from "@graphrefly/pure-ts/core";
-import { type StratifyRule, stratify } from "@graphrefly/pure-ts/extra";
-import { Graph } from "@graphrefly/pure-ts/graph";
-import { describe, expect, it } from "vitest";
-import { feedback, funnel, scorer } from "../../../utils/reduction/index.js";
-import { budgetGate } from "../../../utils/resilience/budget-gate.js";
-
-// ---------------------------------------------------------------------------
-// stratify
-// ---------------------------------------------------------------------------
-
-describe("reduction.stratify", () => {
-	it("routes values to matching branches", () => {
-		const source = node<number>([], { initial: 0 });
-		const rules: StratifyRule<number>[] = [
-			{ name: "even", classify: (v) => v % 2 === 0 },
-			{ name: "odd", classify: (v) => v % 2 !== 0 },
-		];
-
-		const g = stratify("classify", source, rules);
-		expect(g).toBeInstanceOf(Graph);
-
-		const evenSeen: number[] = [];
-		const oddSeen: number[] = [];
-
-		g.resolve("branch/even").subscribe((msgs: Messages) => {
-			for (const msg of msgs) {
-				if (msg[0] === DATA) evenSeen.push(msg[1] as number);
-			}
-		});
-		g.resolve("branch/odd").subscribe((msgs: Messages) => {
-			for (const msg of msgs) {
-				if (msg[0] === DATA) oddSeen.push(msg[1] as number);
-			}
-		});
-		// Clear initial push-on-subscribe emissions
-		evenSeen.length = 0;
-		oddSeen.length = 0;
-
-		source.down([[DATA, 2]]);
-		source.down([[DATA, 3]]);
-		source.down([[DATA, 4]]);
-		source.down([[DATA, 7]]);
-
-		expect(evenSeen).toEqual([2, 4]);
-		expect(oddSeen).toEqual([3, 7]);
-	});
-
-	it("reactive rules: rewriting rules at runtime changes classification", () => {
-		const source = node<string>([], { initial: "" });
-		const rules: StratifyRule<string>[] = [{ name: "match", classify: (v) => v === "a" }];
-
-		const g = stratify("dynamic", source, rules);
-
-		const seen: string[] = [];
-		g.resolve("branch/match").subscribe((msgs: Messages) => {
-			for (const msg of msgs) {
-				if (msg[0] === DATA) seen.push(msg[1] as string);
-			}
-		});
-		// Clear initial push-on-subscribe emissions (initial "" doesn't match rule)
-		seen.length = 0;
-
-		source.down([[DATA, "a"]]);
-		expect(seen).toEqual(["a"]);
-
-		// Rewrite rules: now match "b" instead
-		g.set("rules", [{ name: "match", classify: (v: string) => v === "b" }]);
-		source.down([[DATA, "a"]]);
-		source.down([[DATA, "b"]]);
-		expect(seen).toEqual(["a", "b"]);
-	});
-
-	it("graph has source node and branch node registered", () => {
-		// Stratify's branch nodes use the producer pattern (manual subscription
-		// to `source`), so the source→branch wire is not a constructor dep and
-		// is not reflected in edges() / describe(). This test asserts the
-		// registry-level surface rather than the derived edge.
-		const source = node([], { initial: 0 });
-		const rules: StratifyRule<number>[] = [{ name: "pos", classify: (v) => v > 0 }];
-
-		const g = stratify("edges", source, rules);
-		expect(g.node("source")).toBeDefined();
-		expect(g.node("branch/pos")).toBeDefined();
-	});
-
-	it("propagates COMPLETE through branches", () => {
-		const source = node<number>([], { initial: 0 });
-		const rules: StratifyRule<number>[] = [{ name: "all", classify: () => true }];
-
-		const g = stratify("term", source, rules);
-		let completed = false;
-		g.resolve("branch/all").subscribe((msgs: Messages) => {
-			for (const msg of msgs) {
-				if (msg[0] === COMPLETE) completed = true;
-			}
-		});
-
-		source.down([[COMPLETE]]);
-		expect(completed).toBe(true);
-	});
-
-	it("two-dep gating: batch source + rules uses settled rules", () => {
-		const source = node<string>([], { initial: "x" });
-		const rules: StratifyRule<string>[] = [{ name: "match", classify: (v) => v === "a" }];
-
-		const g = stratify("gate", source, rules);
-
-		const seen: string[] = [];
-		g.resolve("branch/match").subscribe((msgs: Messages) => {
-			for (const msg of msgs) {
-				if (msg[0] === DATA) seen.push(msg[1] as string);
-			}
-		});
-
-		// Batch: update rules to match "b" AND send source "b" simultaneously.
-		// Without two-dep gating, classification would use old rules (match "a")
-		// and "b" would be dropped.  With gating, both settle first.
-		batch(() => {
-			g.set("rules", [{ name: "match", classify: (v: string) => v === "b" }]);
-			source.down([[DATA, "b"]]);
-		});
-
-		expect(seen).toEqual(["b"]);
-	});
-
-	it("source-only update still classifies correctly", () => {
-		const source = node<number>([], { initial: 0 });
-		const rules: StratifyRule<number>[] = [{ name: "pos", classify: (v) => v > 0 }];
-
-		const g = stratify("src-only", source, rules);
-		const seen: number[] = [];
-		g.resolve("branch/pos").subscribe((msgs: Messages) => {
-			for (const msg of msgs) {
-				if (msg[0] === DATA) seen.push(msg[1] as number);
-			}
-		});
-
-		source.down([[DATA, 5]]);
-		source.down([[DATA, -1]]);
-		source.down([[DATA, 3]]);
-		expect(seen).toEqual([5, 3]);
-	});
-
-	it("rules-only update produces no downstream emission", () => {
-		const source = node<string>([], { initial: "a" });
-		const rules: StratifyRule<string>[] = [{ name: "match", classify: (v) => v === "a" }];
-
-		const g = stratify("rules-only", source, rules);
-		const emissions: Messages = [];
-		g.resolve("branch/match").subscribe((msgs: Messages) => {
-			emissions.push(...msgs);
-		});
-
-		source.down([[DATA, "a"]]);
-		const initialCount = emissions.length;
-
-		// Change rules only — should NOT produce any new downstream messages
-		g.set("rules", [{ name: "match", classify: (v: string) => v === "b" }]);
-		expect(emissions.length).toBe(initialCount);
-	});
-
-	it("rules-only update after source settlement produces no spurious data", () => {
-		const source = node<string>([], { initial: "" });
-		const rules: StratifyRule<string>[] = [{ name: "match", classify: (v) => v === "x" }];
-
-		const g = stratify("resolved", source, rules);
-
-		const dataSeen: string[] = [];
-		g.resolve("branch/match").subscribe((msgs: Messages) => {
-			for (const msg of msgs) {
-				if (msg[0] === DATA) dataSeen.push(msg[1] as string);
-			}
-		});
-		// Clear initial push-on-subscribe emissions (initial "" doesn't match)
-		dataSeen.length = 0;
-
-		// Initial emission
-		source.down([[DATA, "x"]]);
-		expect(dataSeen).toEqual(["x"]);
-
-		// Update rules in isolation — source not involved
-		g.set("rules", [{ name: "match", classify: (v: string) => v === "y" }]);
-		// No new data should appear
-		expect(dataSeen).toEqual(["x"]);
-	});
-});
-
-// ---------------------------------------------------------------------------
-// funnel
-// ---------------------------------------------------------------------------
-
-describe("reduction.funnel", () => {
-	it("merges sources and pipes through stages", () => {
-		const s1 = node<number>([], { initial: 0 });
-		const s2 = node<number>([], { initial: 0 });
-
-		const g = funnel(
-			"pipe",
-			[s1, s2],
-			[
-				{
-					name: "double",
-					build(sub) {
-						const input = node<number>([], { initial: 0 });
-						sub.add(input, { name: "input" });
-						const output = node<number>([], { initial: 0 });
-						sub.add(output, { name: "output" });
-						// Wire: when input gets DATA, double it and set output
-						input.subscribe((msgs: Messages) => {
-							for (const msg of msgs) {
-								if (msg[0] === DATA) {
-									output.down([[DATA, (msg[1] as number) * 2]]);
-								}
-							}
-						});
-					},
-				},
-			],
-		);
-
-		expect(g).toBeInstanceOf(Graph);
-
-		const results: number[] = [];
-		g.resolve("double::output").subscribe((msgs: Messages) => {
-			for (const msg of msgs) {
-				if (msg[0] === DATA) results.push(msg[1] as number);
-			}
-		});
-		// Clear initial push-on-subscribe emissions
-		results.length = 0;
-
-		s1.down([[DATA, 5]]);
-		s2.down([[DATA, 3]]);
-
-		expect(results).toEqual([10, 6]);
-	});
-
-	it("rejects empty sources", () => {
-		expect(() => funnel("bad", [], [{ name: "s", build: () => {} }])).toThrow(
-			"at least one source",
-		);
-	});
-
-	it("rejects empty stages", () => {
-		expect(() => funnel("bad", [node([], { initial: 0 })], [])).toThrow("at least one stage");
-	});
-
-	it("rejects stage without input node", () => {
-		expect(() =>
-			funnel(
-				"bad",
-				[node([], { initial: 0 })],
-				[
-					{
-						name: "noInput",
-						build(sub) {
-							sub.add(node([], { initial: 0 }), { name: "output" });
-						},
-					},
-				],
-			),
-		).toThrow('must define an "input" node');
-	});
-
-	it("rejects stage without output node", () => {
-		expect(() =>
-			funnel(
-				"bad",
-				[node([], { initial: 0 })],
-				[
-					{
-						name: "noOutput",
-						build(sub) {
-							sub.add(node([], { initial: 0 }), { name: "input" });
-						},
-					},
-				],
-			),
-		).toThrow('must define an "output" node');
-	});
-});
-
-// ---------------------------------------------------------------------------
-// feedback
-// ---------------------------------------------------------------------------
-
-describe("reduction.feedback", () => {
-	it("routes condition output back to reentry", () => {
-		const g = new Graph("fb");
-		const input = node<number>([], { initial: 0 });
-		g.add(input, { name: "input" });
-
-		// Condition: pass through if < 5
-		const cond = node<number | null>([], { initial: null });
-		g.add(cond, { name: "condition" });
-
-		// Wire: input → condition (simplified: effect watches input, writes to condition)
-		const inputNode = g.resolve("input");
-		inputNode.subscribe((msgs: Messages) => {
-			for (const msg of msgs) {
-				if (msg[0] === DATA) {
-					const v = msg[1] as number;
-					cond.down([[DATA, v < 5 ? v + 1 : null]]);
-				}
-			}
-		});
-
-		feedback(g, "condition", "input", { maxIterations: 10 });
-
-		const seen: number[] = [];
-		inputNode.subscribe((msgs: Messages) => {
-			for (const msg of msgs) {
-				if (msg[0] === DATA) seen.push(msg[1] as number);
-			}
-		});
-
-		// Kick off: set input to 1 → condition emits 2 → feedback → input=2 → ... → 5 → null (stops)
-		input.down([[DATA, 1]]);
-
-		// Should have iterated: 1, 2, 3, 4, 5
-		expect(seen).toContain(1);
-		expect(seen.length).toBeGreaterThanOrEqual(1);
-		// The counter should have advanced
-		const counter = g.node("__feedback_condition").cache as number;
-		expect(counter).toBeGreaterThan(0);
-	});
-
-	it("respects maxIterations bound", () => {
-		const g = new Graph("bounded");
-		const input = node<number>([], { initial: 0 });
-		g.add(input, { name: "input" });
-
-		// Always-true condition → infinite feedback without bound
-		const cond = node<number>([], { initial: 0 });
-		g.add(cond, { name: "condition" });
-
-		input.subscribe((msgs: Messages) => {
-			for (const msg of msgs) {
-				if (msg[0] === DATA) {
-					cond.down([[DATA, (msg[1] as number) + 1]]);
-				}
-			}
-		});
-
-		feedback(g, "condition", "input", { maxIterations: 3 });
-
-		// Subscribe to activate
-		cond.subscribe(() => undefined);
-
-		input.down([[DATA, 0]]);
-
-		const counter = g.node("__feedback_condition").cache as number;
-		expect(counter).toBeLessThanOrEqual(3);
-	});
-});
-
-// ---------------------------------------------------------------------------
-// budgetGate
-// ---------------------------------------------------------------------------
-
-describe("reduction.budgetGate", () => {
-	it("passes DATA when budget is available", () => {
-		const source = node<number>([], { initial: 0 });
-		const budget = node<number>([], { initial: 100 }); // budget = 100
-		const gated = budgetGate(source, [{ node: budget, check: (v) => (v as number) > 0 }]).node;
-
-		const seen: number[] = [];
-		gated.subscribe((msgs: Messages) => {
-			for (const msg of msgs) {
-				if (msg[0] === DATA) seen.push(msg[1] as number);
-			}
-		});
-		// Clear initial push-on-subscribe emissions
-		seen.length = 0;
-
-		source.down([[DATA, 42]]);
-		expect(seen).toEqual([42]);
-	});
-
-	it("buffers DATA when budget exhausted, flushes on replenish", () => {
-		const source = node<number>([], { initial: 0 });
-		const budget = node<number>([], { initial: 0 }); // exhausted
-
-		const gated = budgetGate(source, [{ node: budget, check: (v) => (v as number) > 0 }]).node;
-
-		const seen: number[] = [];
-		gated.subscribe((msgs: Messages) => {
-			for (const msg of msgs) {
-				if (msg[0] === DATA) seen.push(msg[1] as number);
-			}
-		});
-
-		// Push-on-subscribe delivers initial 0 which gets buffered (budget=0).
-		// Clear the seen array; the buffered initial is still in the gate's internal buffer.
-		seen.length = 0;
-
-		source.down([[DATA, 1]]);
-		source.down([[DATA, 2]]);
-		expect(seen).toEqual([]); // buffered
-
-		// Replenish budget — flushes buffered initial 0, plus 1 and 2
-		budget.down([[DATA, 50]]);
-		expect(seen).toEqual([0, 1, 2]); // flushed (includes initial push-on-subscribe value)
-	});
-
-	it("rejects zero constraints with RangeError (regression — Tier 3.3.4)", () => {
-		// Documented contract: empty constraints throws `RangeError`. The error
-		// class shape matters for caller `instanceof` checks in compositors.
-		let caught: unknown;
-		try {
-			budgetGate(node([], { initial: 0 }), []);
-		} catch (e) {
-			caught = e;
-		}
-		expect(caught).toBeInstanceOf(RangeError);
-		expect((caught as Error).message).toMatch(/at least one constraint/);
-	});
-
-	it("propagates COMPLETE and force-flushes buffered DATA before terminal (invariant 1)", () => {
-		// Note: source `node<number>([], { initial: 0 })` push-on-subscribe delivers the initial
-		// 0 to the gate while the gate is closed — so the initial value is part
-		// of the FIFO buffer and force-flushes BEFORE COMPLETE alongside the
-		// later DATA. This is correct behavior (the initial value is real DATA).
-		const source = node<number>([], { initial: 0 });
-		const budget = node<number>([], { initial: 0 }); // closed
-		const gated = budgetGate(source, [{ node: budget, check: (v) => (v as number) > 0 }]).node;
-
-		const events: Array<["DATA", number] | ["COMPLETE"]> = [];
-		gated.subscribe((msgs: Messages) => {
-			for (const msg of msgs) {
-				if (msg[0] === DATA) events.push(["DATA", msg[1] as number]);
-				if (msg[0] === COMPLETE) events.push(["COMPLETE"]);
-			}
-		});
-
-		// Three more DATA arrive while gate is closed → all buffered behind initial 0.
-		source.down([[DATA, 10]]);
-		source.down([[DATA, 20]]);
-		source.down([[DATA, 30]]);
-		expect(events).toEqual([]);
-
-		source.down([[COMPLETE]]);
-
-		// Invariant 1: every buffered item emits BEFORE COMPLETE, in FIFO order,
-		// regardless of the still-closed budget.
-		expect(events).toEqual([["DATA", 0], ["DATA", 10], ["DATA", 20], ["DATA", 30], ["COMPLETE"]]);
-	});
-
-	it("propagates ERROR and force-flushes buffered DATA before terminal (invariant 1)", () => {
-		const source = node<number>([], { initial: 0 });
-		const budget = node<number>([], { initial: 0 }); // closed
-		const gated = budgetGate(source, [{ node: budget, check: (v) => (v as number) > 0 }]).node;
-
-		const events: Array<["DATA", number] | ["ERROR"]> = [];
-		gated.subscribe((msgs: Messages) => {
-			for (const msg of msgs) {
-				if (msg[0] === DATA) events.push(["DATA", msg[1] as number]);
-				if (msg[0] === ERROR) events.push(["ERROR"]);
-			}
-		});
-
-		source.down([[DATA, 1]]);
-		source.down([[DATA, 2]]);
-		expect(events).toEqual([]); // initial 0 + 1 + 2 still buffered
-
-		source.down([[ERROR, new Error("boom")]]);
-
-		// Initial push-on-subscribe 0 + 1 + 2, then ERROR.
-		expect(events).toEqual([["DATA", 0], ["DATA", 1], ["DATA", 2], ["ERROR"]]);
-	});
-
-	it("drains buffer FIFO when constraint releases — PAUSE→RESUME ordering (invariant 2)", () => {
-		const source = node<number>([], { initial: 0 });
-		const budget = node<number>([], { initial: 0 }); // closed initially
-		const gated = budgetGate(source, [{ node: budget, check: (v) => (v as number) > 0 }]).node;
-
-		const order: number[] = [];
-		gated.subscribe((msgs: Messages) => {
-			for (const msg of msgs) {
-				if (msg[0] === DATA) order.push(msg[1] as number);
-			}
-		});
-
-		// Push 5 items while closed — all queued (behind push-on-subscribe initial 0).
-		source.down([[DATA, 10]]);
-		source.down([[DATA, 20]]);
-		source.down([[DATA, 30]]);
-		source.down([[DATA, 40]]);
-		source.down([[DATA, 50]]);
-		expect(order).toEqual([]);
-
-		// Constraint releases — queue must drain in arrival order BEFORE any new
-		// upstream DATA could interleave (invariant 2).
-		budget.down([[DATA, 100]]);
-		expect(order).toEqual([0, 10, 20, 30, 40, 50]);
-
-		// Subsequent DATA passes through immediately (queue empty, gate open).
-		source.down([[DATA, 60]]);
-		expect(order).toEqual([0, 10, 20, 30, 40, 50, 60]);
-	});
-
-	it("queue scales to many items with O(1) shift (Tier 3.3.1 perf parity smoke)", () => {
-		// Regression for the prior `buffer.slice(1)` O(N²) drain. With the
-		// HeadIndexQueue substitution this completes in ~milliseconds even for
-		// thousands of items; with `slice(1)` it would have been quadratic.
-		// We assert correctness (FIFO over many items) — the perf gain is
-		// implicit in not timing out.
-		const N = 5_000;
-		const source = node<number>([], { initial: 0 });
-		const budget = node<number>([], { initial: 0 }); // closed
-		const gated = budgetGate(source, [{ node: budget, check: (v) => (v as number) > 0 }]).node;
-
-		const order: number[] = [];
-		gated.subscribe((msgs: Messages) => {
-			for (const msg of msgs) {
-				if (msg[0] === DATA) order.push(msg[1] as number);
-			}
-		});
-
-		batch(() => {
-			for (let i = 1; i <= N; i++) {
-				source.emit(i);
-			}
-		});
-		expect(order).toEqual([]);
-
-		// One drain — push-on-subscribe initial 0 plus N items emit FIFO.
-		budget.down([[DATA, 100]]);
-		expect(order.length).toBe(N + 1);
-		expect(order[0]).toBe(0); // initial push-on-subscribe
-		expect(order[1]).toBe(1);
-		expect(order[N]).toBe(N);
-		// Spot-check FIFO at the midpoint.
-		expect(order[N / 2]).toBe(N / 2);
-	});
-
-	it("RESOLVED is deferred until buffer drains (invariant 3)", () => {
-		const source = node<number>([], { initial: 0 });
-		const budget = node<number>([], { initial: 0 }); // closed
-		const gated = budgetGate(source, [{ node: budget, check: (v) => (v as number) > 0 }]).node;
-
-		const events: Array<["DATA", number] | ["RESOLVED"]> = [];
-		gated.subscribe((msgs: Messages) => {
-			for (const msg of msgs) {
-				if (msg[0] === DATA) events.push(["DATA", msg[1] as number]);
-				if (msg[0] === RESOLVED) events.push(["RESOLVED"]);
-			}
-		});
-
-		source.down([[DATA, 7]]);
-		// Send a RESOLVED while buffer is non-empty — should be deferred.
-		source.down([[RESOLVED]]);
-		expect(events).toEqual([]);
-
-		// Open the gate — drain emits buffered DATA (initial 0 + 7), then the
-		// deferred RESOLVED.
-		budget.down([[DATA, 100]]);
-		expect(events).toEqual([["DATA", 0], ["DATA", 7], ["RESOLVED"]]);
-	});
-});
-
-// ---------------------------------------------------------------------------
-// scorer
-// ---------------------------------------------------------------------------
-
-describe("reduction.scorer", () => {
-	it("computes weighted scores from signal and weight nodes", () => {
-		const sig1 = node<number>([], { initial: 0 });
-		const sig2 = node<number>([], { initial: 0 });
-		const w1 = node<number>([], { initial: 1 });
-		const w2 = node<number>([], { initial: 1 });
-
-		const s = scorer([sig1, sig2], [w1, w2]);
-
-		let result: { value: number[]; score: number; breakdown: number[] } | undefined;
-		s.subscribe((msgs: Messages) => {
-			for (const msg of msgs) {
-				if (msg[0] === DATA)
-					result = msg[1] as { value: number[]; score: number; breakdown: number[] };
-			}
-		});
-
-		sig1.down([[DATA, 3]]);
-		sig2.down([[DATA, 7]]);
-
-		expect(result).toBeDefined();
-		expect(result!.value).toEqual([3, 7]);
-		expect(result!.score).toBe(10); // 3*1 + 7*1
-		expect(result!.breakdown).toEqual([3, 7]);
-	});
-
-	it("reacts to weight changes", () => {
-		const sig1 = node<number>([], { initial: 5 });
-		const w1 = node<number>([], { initial: 1 });
-
-		const s = scorer([sig1], [w1]);
-
-		let result: { score: number } | undefined;
-		s.subscribe((msgs: Messages) => {
-			for (const msg of msgs) {
-				if (msg[0] === DATA) result = msg[1] as { score: number };
-			}
-		});
-
-		sig1.down([[DATA, 5]]);
-		expect(result!.score).toBe(5);
-
-		w1.down([[DATA, 3]]);
-		expect(result!.score).toBe(15); // 5 * 3
-	});
-
-	it("supports custom scoreFns", () => {
-		const sig1 = node<number>([], { initial: 0 });
-		const w1 = node<number>([], { initial: 1 });
-
-		const s = scorer([sig1], [w1], {
-			scoreFns: [(v) => (v as number) ** 2], // square the signal
-		});
-
-		let result: { score: number } | undefined;
-		s.subscribe((msgs: Messages) => {
-			for (const msg of msgs) {
-				if (msg[0] === DATA) result = msg[1] as { score: number };
-			}
-		});
-
-		sig1.down([[DATA, 4]]);
-		expect(result!.score).toBe(16); // 4^2 * 1
-	});
-
-	it("rejects mismatched sources/weights", () => {
-		expect(() =>
-			scorer([node([], { initial: 0 }), node([], { initial: 0 })], [node([], { initial: 1 })]),
-		).toThrow("same number of sources and weights");
-	});
-
-	it("rejects empty sources", () => {
-		expect(() => scorer([], [])).toThrow("at least one source");
-	});
-
-	it("has reduction meta", () => {
-		const s = scorer([node([], { initial: 0 })], [node([], { initial: 1 })]);
-		const meta = s.meta;
-		expect(meta.reduction.cache).toBe(true);
-		expect(meta.reduction_type.cache).toBe("scorer");
-	});
-});
diff --git a/src/__tests__/utils/resilience/resilience.test.ts b/src/__tests__/utils/resilience/resilience.test.ts
deleted file mode 100644
index 473fdde8..00000000
--- a/src/__tests__/utils/resilience/resilience.test.ts
+++ /dev/null
@@ -1,1551 +0,0 @@
-import { COMPLETE, DATA, ERROR, node, RESOLVED } from "@graphrefly/pure-ts/core";
-import { throwError } from "@graphrefly/pure-ts/extra";
-import { Graph } from "@graphrefly/pure-ts/graph";
-import { afterEach, describe, expect, it, vi } from "vitest";
-import {
-	constant,
-	decorrelatedJitter,
-	exponential,
-	fibonacci,
-	linear,
-	NS_PER_MS,
-	NS_PER_SEC,
-	resolveBackoffPreset,
-	withMaxAttempts,
-} from "../../../base/resilience/backoff.js";
-import {
-	type BudgetGateState,
-	budgetGate,
-	type CircuitBreakerOptions,
-	CircuitOpenError,
-	circuitBreaker,
-	fallback,
-	type RateLimiterOptions,
-	RateLimiterOverflowError,
-	type RateLimiterState,
-	type RetryOptions,
-	rateLimiter,
-	retry,
-	TimeoutError,
-	type TimeoutOptions,
-	type TimeoutState,
-	withTimeout as timeout,
-	tokenBucket,
-	withBreaker,
-	withStatus,
-} from "../../../utils/resilience/index.js";
-import { collect } from "../test-helpers.js";
-
-describe("extra resilience (roadmap §3.1)", () => {
-	afterEach(() => {
-		vi.useRealTimers();
-	});
-
-	describe("backoff (nanosecond units)", () => {
-		it("constant returns fixed delay in ns", () => {
-			const s = constant(500 * NS_PER_MS);
-			expect(s(0)).toBe(500_000_000);
-			expect(s(5)).toBe(500_000_000);
-		});
-
-		it("linear grows with attempt", () => {
-			const s = linear(1 * NS_PER_SEC, 0.5 * NS_PER_SEC);
-			expect(s(0)).toBe(1 * NS_PER_SEC);
-			expect(s(1)).toBe(1.5 * NS_PER_SEC);
-			expect(s(2)).toBe(2 * NS_PER_SEC);
-		});
-
-		it("fibonacci scales base", () => {
-			const s = fibonacci(1 * NS_PER_SEC, 100 * NS_PER_SEC);
-			expect(s(0)).toBe(1 * NS_PER_SEC);
-			expect(s(1)).toBe(2 * NS_PER_SEC);
-			expect(s(2)).toBe(3 * NS_PER_SEC);
-		});
-
-		it("resolveBackoffPreset returns strategies for all presets", () => {
-			expect(typeof resolveBackoffPreset("constant")(0)).toBe("number");
-			expect(typeof resolveBackoffPreset("exponential")(0)).toBe("number");
-			expect(typeof resolveBackoffPreset("decorrelatedJitter")(0)).toBe("number");
-		});
-
-		it("resolveBackoffPreset throws on unknown", () => {
-			expect(() => resolveBackoffPreset("nope" as never)).toThrow(/Unknown backoff preset/);
-		});
-
-		it("exponential caps maxDelayNs", () => {
-			const s = exponential({
-				baseNs: 1 * NS_PER_SEC,
-				factor: 10,
-				maxDelayNs: 5 * NS_PER_SEC,
-				jitter: "none",
-			});
-			expect(s(100)).toBe(5 * NS_PER_SEC);
-		});
-	});
-
-	describe("decorrelatedJitter", () => {
-		it("returns values between base and ceiling", () => {
-			const s = decorrelatedJitter(100 * NS_PER_MS, 10 * NS_PER_SEC);
-			for (let i = 0; i < 50; i++) {
-				const d = s(i, undefined, null);
-				expect(d).toBeGreaterThanOrEqual(100 * NS_PER_MS);
-				expect(d).toBeLessThanOrEqual(10 * NS_PER_SEC);
-			}
-		});
-
-		it("uses prevDelay to compute ceiling", () => {
-			const s = decorrelatedJitter(100 * NS_PER_MS, 10 * NS_PER_SEC);
-			const d = s(1, undefined, 200 * NS_PER_MS);
-			expect(d).toBeGreaterThanOrEqual(100 * NS_PER_MS);
-			expect(d).toBeLessThanOrEqual(600 * NS_PER_MS); // min(10s, 200ms * 3)
-		});
-
-		it("defaults prevDelay to base", () => {
-			const s = decorrelatedJitter(100 * NS_PER_MS, 10 * NS_PER_SEC);
-			const d = s(0);
-			expect(d).toBeGreaterThanOrEqual(100 * NS_PER_MS);
-			expect(d).toBeLessThanOrEqual(300 * NS_PER_MS); // min(10s, 100ms * 3)
-		});
-	});
-
-	describe("withMaxAttempts", () => {
-		it("returns null after max attempts", () => {
-			const inner = constant(1 * NS_PER_SEC);
-			const capped = withMaxAttempts(inner, 3);
-			expect(capped(0)).toBe(1 * NS_PER_SEC);
-			expect(capped(1)).toBe(1 * NS_PER_SEC);
-			expect(capped(2)).toBe(1 * NS_PER_SEC);
-			expect(capped(3)).toBeNull();
-			expect(capped(100)).toBeNull();
-		});
-
-		it("passes through inner strategy args", () => {
-			const inner = linear(1 * NS_PER_SEC);
-			const capped = withMaxAttempts(inner, 5);
-			expect(capped(0)).toBe(1 * NS_PER_SEC);
-			expect(capped(2)).toBe(3 * NS_PER_SEC);
-		});
-	});
-
-	describe("retry", () => {
-		it("forwards ERROR when count is 0", () => {
-			const src = node(
-				[],
-				(_data, a) => {
-					a.down([[ERROR, new Error("x")]]);
-				},
-				{ describeKind: "producer", resubscribable: true },
-			);
-			const out = retry(src, { count: 0 }).node;
-			const { batches, unsub } = collect(out);
-			expect(batches.flat().some((m) => m[0] === ERROR)).toBe(true);
-			unsub();
-		});
-
-		it("resubscribes after ERROR when producer is resubscribable", async () => {
-			vi.useFakeTimers();
-			let runs = 0;
-			const src = node(
-				[],
-				(_data, a) => {
-					runs += 1;
-					if (runs === 1) {
-						a.down([[ERROR, new Error("fail")]]);
-					} else {
-						a.emit(42);
-					}
-				},
-				{ describeKind: "producer", resubscribable: true },
-			);
-			const out = retry(src, { count: 2, backoff: constant(0) }).node;
-			const { batches, unsub } = collect(out);
-			await vi.advanceTimersByTimeAsync(10);
-			const data = batches.flat().filter((m) => m[0] === DATA);
-			expect(data.some((m) => m[1] === 42)).toBe(true);
-			unsub();
-		});
-
-		// DF2 regression: an ERROR delivered in the SAME wave as a COMPLETE
-		// (after disconnectUpstream() runs but before the teardown closure
-		// would set `stopped`) must NOT schedule a new retry timer. The
-		// COMPLETE branch sets `stopped = true` synchronously so the trailing
-		// ERROR hits the `if (stopped) return` guard in
-		// `scheduleRetryOrFinish`. Without the fix, `count: 5 + backoff:0`
-		// would arm a timer that re-subscribes a completed machine.
-		it("DF2: ERROR in the same wave as COMPLETE does not schedule a retry", async () => {
-			vi.useFakeTimers();
-			let runs = 0;
-			const src = node(
-				[],
-				(_data, a) => {
-					runs += 1;
-					// COMPLETE then ERROR in one batch — the race window.
-					a.down([[COMPLETE], [ERROR, new Error("late ERROR after COMPLETE")]]);
-				},
-				{ describeKind: "producer", resubscribable: true },
-			);
-			const out = retry(src, { count: 5, backoff: constant(0) }).node;
-			const { batches, unsub } = collect(out);
-			// If the race were live, a retry timer would fire here and re-run
-			// the producer (runs === 2) and re-deliver the trailing ERROR.
-			await vi.advanceTimersByTimeAsync(100);
-			expect(runs).toBe(1);
-			const flat = batches.flat();
-			expect(flat.filter((m) => m[0] === COMPLETE).length).toBe(1);
-			// The trailing ERROR is swallowed by the stopped-machine guard —
-			// it must NOT propagate downstream as a fresh ERROR after COMPLETE.
-			expect(flat.some((m) => m[0] === ERROR)).toBe(false);
-			unsub();
-		});
-
-		// DF6 regression: source-mode retry on a non-`resubscribable` upstream
-		// warns exactly once per source (WeakSet dedup), and never warns when
-		// the upstream IS resubscribable.
-		it("DF6: warns once when source is not resubscribable", () => {
-			const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
-			try {
-				// Default node — `_resubscribable === false`.
-				const src = node([], (_data, a) => a.down([[ERROR, new Error("x")]]), {
-					describeKind: "producer",
-				});
-				retry(src, { count: 1, backoff: constant(0) });
-				retry(src, { count: 1, backoff: constant(0) }); // same source — deduped
-				expect(warnSpy).toHaveBeenCalledTimes(1);
-				expect(warnSpy.mock.calls[0]?.[0]).toMatch(/requires `resubscribable: true`/);
-
-				// A resubscribable source must not trip the warn.
-				const ok = node([], (_data, a) => a.down([[ERROR, new Error("x")]]), {
-					describeKind: "producer",
-					resubscribable: true,
-				});
-				retry(ok, { count: 1, backoff: constant(0) });
-				expect(warnSpy).toHaveBeenCalledTimes(1);
-			} finally {
-				warnSpy.mockRestore();
-			}
-		});
-	});
-
-	describe("retry + withMaxAttempts", () => {
-		it("null from strategy stops retry immediately", async () => {
-			vi.useFakeTimers();
-			let runs = 0;
-			const src = node(
-				[],
-				(_data, a) => {
-					runs += 1;
-					a.down([[ERROR, new Error(`fail-${runs}`)]]);
-				},
-				{ describeKind: "producer", resubscribable: true },
-			);
-			// withMaxAttempts(constant(0), 2) → attempts 0,1 get 0 delay; attempt 2 → null → stop.
-			// `count: Infinity` because the strategy's null-return is what bounds the retries here.
-			const capped = withMaxAttempts(constant(0), 2);
-			const out = retry(src, { count: Infinity, backoff: capped }).node;
-			const { batches, unsub } = collect(out);
-			await vi.advanceTimersByTimeAsync(50);
-			const errors = batches.flat().filter((m) => m[0] === ERROR);
-			expect(errors.length).toBe(1);
-			// 1 initial + 2 retries = 3 total runs
-			expect(runs).toBe(3);
-			unsub();
-		});
-	});
-
-	describe("retry (factory form, formerly retrySource)", () => {
-		it("builds a fresh source per attempt", async () => {
-			vi.useFakeTimers();
-			let builds = 0;
-			const factory = () => {
-				builds += 1;
-				return node<number>(
-					[],
-					(_data, a) => {
-						if (builds < 3) {
-							a.down([[ERROR, new Error(`boom-${builds}`)]]);
-						} else {
-							a.emit(42);
-						}
-					},
-					{ describeKind: "producer" },
-				);
-			};
-			const out = retry(factory, { count: 5, backoff: constant(0) }).node;
-			const { batches, unsub } = collect(out);
-			await vi.advanceTimersByTimeAsync(10);
-			const data = batches.flat().filter((m) => m[0] === DATA);
-			expect(data.some((m) => m[1] === 42)).toBe(true);
-			// 1 initial attempt + 2 retries after errors = 3 builds total
-			expect(builds).toBe(3);
-			unsub();
-		});
-
-		it("surfaces ERROR when count is 0", () => {
-			const factory = () =>
-				node<number>(
-					[],
-					(_data, a) => {
-						a.down([[ERROR, new Error("x")]]);
-					},
-					{ describeKind: "producer" },
-				);
-			const out = retry(factory, { count: 0 }).node;
-			const { batches, unsub } = collect(out);
-			expect(batches.flat().some((m) => m[0] === ERROR)).toBe(true);
-			unsub();
-		});
-
-		it("surfaces ERROR when maxRetries exhausted", async () => {
-			vi.useFakeTimers();
-			let builds = 0;
-			const factory = () => {
-				builds += 1;
-				return node<number>(
-					[],
-					(_data, a) => {
-						a.down([[ERROR, new Error(`build-${builds}`)]]);
-					},
-					{ describeKind: "producer" },
-				);
-			};
-			const out = retry(factory, { count: 2, backoff: constant(0) }).node;
-			const { batches, unsub } = collect(out);
-			await vi.advanceTimersByTimeAsync(10);
-			const errors = batches.flat().filter((m) => m[0] === ERROR);
-			expect(errors.length).toBe(1);
-			// 1 initial + 2 retries = 3 builds
-			expect(builds).toBe(3);
-			unsub();
-		});
-
-		it("synchronous throw from factory is retried like inner ERROR", async () => {
-			vi.useFakeTimers();
-			let builds = 0;
-			const factory = () => {
-				builds += 1;
-				if (builds < 2) throw new Error("factory threw");
-				return node<number>(
-					[],
-					(_data, a) => {
-						a.emit(7);
-					},
-					{ describeKind: "producer" },
-				);
-			};
-			const out = retry(factory, { count: 3, backoff: constant(0) }).node;
-			const { batches, unsub } = collect(out);
-			await vi.advanceTimersByTimeAsync(10);
-			const data = batches.flat().filter((m) => m[0] === DATA);
-			expect(data.some((m) => m[1] === 7)).toBe(true);
-			expect(builds).toBe(2);
-			unsub();
-		});
-
-		it("forwards COMPLETE without building a new source", () => {
-			let builds = 0;
-			const factory = () => {
-				builds += 1;
-				return node<number>(
-					[],
-					(_data, a) => {
-						a.emit(1);
-						a.down([[COMPLETE]]);
-					},
-					{ describeKind: "producer" },
-				);
-			};
-			const out = retry(factory, { count: 5, backoff: constant(0) }).node;
-			const { batches, unsub } = collect(out);
-			expect(batches.flat().some((m) => m[0] === COMPLETE)).toBe(true);
-			expect(builds).toBe(1);
-			unsub();
-		});
-
-		it("resets attempt counter after a successful DATA", async () => {
-			vi.useFakeTimers();
-			let builds = 0;
-			const factory = () => {
-				builds += 1;
-				return node<number>(
-					[],
-					(_data, a) => {
-						if (builds === 1) {
-							a.emit(10);
-							// Then error — next build should start fresh (attempt=0)
-							a.down([[ERROR, new Error("mid-stream")]]);
-						} else if (builds <= 4) {
-							a.down([[ERROR, new Error(`e-${builds}`)]]);
-						} else {
-							a.emit(20);
-						}
-					},
-					{ describeKind: "producer" },
-				);
-			};
-			// Without reset-on-DATA, count=4 permits builds 1..5 regardless.
-			// With reset-on-DATA semantics, after build=1 emits 10 the attempt
-			// counter is cleared, so the subsequent errors all fit within the
-			// same retry budget. We assert the happy path reaches build 5.
-			const out = retry(factory, { count: 4, backoff: constant(0) }).node;
-			const { batches, unsub } = collect(out);
-			await vi.advanceTimersByTimeAsync(20);
-			const data = batches.flat().filter((m) => m[0] === DATA);
-			expect(data.map((m) => m[1])).toEqual([10, 20]);
-			expect(builds).toBe(5);
-			unsub();
-		});
-
-		it("teardown cancels pending retry timer and unsubs active source", async () => {
-			vi.useFakeTimers();
-			let builds = 0;
-			let innerTeardowns = 0;
-			const factory = () => {
-				builds += 1;
-				return node<number>(
-					(_a) => {
-						return {
-							onDeactivation: () => {
-								innerTeardowns += 1;
-							},
-						};
-					},
-					{ describeKind: "producer" },
-				);
-			};
-			const out = retry(factory, { count: 10, backoff: constant(1 * NS_PER_SEC) }).node;
-			const { unsub } = collect(out);
-			unsub();
-			await vi.advanceTimersByTimeAsync(10 * NS_PER_SEC);
-			// No further builds should happen after unsub
-			expect(builds).toBe(1);
-			expect(innerTeardowns).toBe(1);
-		});
-
-		it("forwards DATA / DIRTY / RESOLVED transparently", async () => {
-			const src = node<number>([], { initial: 1 });
-			const out = retry(() => src, { count: 0 }).node;
-			const { batches, unsub } = collect(out);
-			src.down([[DATA, 2]]);
-			const data = batches.flat().filter((m) => m[0] === DATA);
-			expect(data.map((m) => m[1])).toEqual([1, 2]);
-			unsub();
-		});
-	});
-
-	describe("circuitBreaker (factory)", () => {
-		it("opens after threshold failures", () => {
-			const b = circuitBreaker({ failureThreshold: 2, cooldownNs: 60 * NS_PER_SEC });
-			expect(b.canExecute()).toBe(true);
-			b.recordFailure();
-			b.recordFailure();
-			expect(b.state).toBe("open");
-			expect(b.canExecute()).toBe(false);
-		});
-
-		it("exposes failureCount", () => {
-			const b = circuitBreaker({ failureThreshold: 5 });
-			expect(b.failureCount).toBe(0);
-			b.recordFailure();
-			expect(b.failureCount).toBe(1);
-			b.recordFailure();
-			expect(b.failureCount).toBe(2);
-		});
-
-		it("reset() returns to closed", () => {
-			const b = circuitBreaker({ failureThreshold: 1 });
-			b.recordFailure();
-			expect(b.state).toBe("open");
-			b.reset();
-			expect(b.state).toBe("closed");
-			expect(b.failureCount).toBe(0);
-			expect(b.canExecute()).toBe(true);
-		});
-
-		it("injectable now() for testing", () => {
-			let clock = 1 * NS_PER_SEC;
-			const b = circuitBreaker({
-				failureThreshold: 1,
-				cooldownNs: 5 * NS_PER_SEC,
-				now: () => clock,
-			});
-			b.recordFailure();
-			expect(b.state).toBe("open");
-			expect(b.canExecute()).toBe(false);
-
-			clock += 5 * NS_PER_SEC - NS_PER_MS;
-			expect(b.canExecute()).toBe(false);
-
-			clock += 2 * NS_PER_MS;
-			expect(b.canExecute()).toBe(true);
-			expect(b.state).toBe("half-open");
-		});
-
-		it("escalating cooldown via backoff strategy", () => {
-			let clock = 0;
-			const b = circuitBreaker({
-				failureThreshold: 1,
-				cooldown: (openCycle) => (openCycle + 1) * NS_PER_SEC,
-				now: () => clock,
-			});
-
-			// First open cycle: cooldown = 1s
-			b.recordFailure();
-			expect(b.state).toBe("open");
-			clock += 1 * NS_PER_SEC;
-			expect(b.canExecute()).toBe(true);
-			expect(b.state).toBe("half-open");
-
-			// Fail in half-open → open cycle increments
-			b.recordFailure();
-			expect(b.state).toBe("open");
-
-			// Second open cycle: cooldown = 2s
-			clock += 2 * NS_PER_SEC - NS_PER_MS;
-			expect(b.canExecute()).toBe(false);
-			clock += 2 * NS_PER_MS;
-			expect(b.canExecute()).toBe(true);
-			expect(b.state).toBe("half-open");
-
-			// Success resets open cycle
-			b.recordSuccess();
-			expect(b.state).toBe("closed");
-		});
-
-		it("half-open respects halfOpenMax", () => {
-			let clock = 0;
-			const b = circuitBreaker({
-				failureThreshold: 1,
-				cooldownNs: 1 * NS_PER_SEC,
-				halfOpenMax: 2,
-				now: () => clock,
-			});
-			b.recordFailure();
-			clock += 1 * NS_PER_SEC;
-			expect(b.canExecute()).toBe(true); // trial 1
-			expect(b.canExecute()).toBe(true); // trial 2
-			expect(b.canExecute()).toBe(false); // max reached
-		});
-	});
-
-	describe("withBreaker", () => {
-		it("skip emits RESOLVED when open", () => {
-			const b = circuitBreaker({ failureThreshold: 1, cooldownNs: 600 * NS_PER_SEC });
-			b.recordFailure();
-			const s = node([], { initial: 1 });
-			const { node: out } = withBreaker(b)(s);
-			const { batches, unsub } = collect(out);
-			s.down([[DATA, 2]]);
-			expect(batches.flat().some((m) => m[0] === RESOLVED)).toBe(true);
-			unsub();
-		});
-
-		it("onOpen error emits CircuitOpenError", () => {
-			const b = circuitBreaker({ failureThreshold: 1, cooldownNs: 600 * NS_PER_SEC });
-			b.recordFailure();
-			const s = node([], { initial: 1 });
-			const { node: out } = withBreaker(b, { onOpen: "error" })(s);
-			const { batches, unsub } = collect(out);
-			s.down([[DATA, 2]]);
-			const errBatch = batches.flat().find((m) => m[0] === ERROR);
-			expect(errBatch).toBeDefined();
-			expect(errBatch?.[1]).toBeInstanceOf(CircuitOpenError);
-			unsub();
-		});
-	});
-
-	describe("tokenBucket / rateLimiter", () => {
-		it("tokenBucket tryConsume respects capacity", () => {
-			const tb = tokenBucket(2, 0);
-			expect(tb.tryConsume(1)).toBe(true);
-			expect(tb.tryConsume(1)).toBe(true);
-			expect(tb.tryConsume(1)).toBe(false);
-		});
-
-		it("tokenBucket clock injection drives refill deterministically (qa A12)", () => {
-			let t = 0;
-			const tb = tokenBucket(5, 1, { clock: () => t });
-			// Exhaust the bucket
-			expect(tb.tryConsume(5)).toBe(true);
-			expect(tb.tryConsume(1)).toBe(false);
-			// Advance virtual clock 1s — refill rate is 1 token/sec, so 1 token added
-			t = 1_000_000_000;
-			expect(tb.tryConsume(1)).toBe(true);
-			expect(tb.tryConsume(1)).toBe(false);
-			// Advance another 2s → 2 more tokens
-			t = 3_000_000_000;
-			expect(tb.tryConsume(2)).toBe(true);
-			expect(tb.tryConsume(1)).toBe(false);
-			// Available is float-valued (qa A12 / JSDoc claim)
-			t = 3_500_000_000;
-			expect(tb.available()).toBeCloseTo(0.5, 5);
-		});
-
-		it("rateLimiter queues beyond rate (fake timers + performance)", async () => {
-			const now = { v: 1_000_000 };
-			const spy = vi.spyOn(performance, "now").mockImplementation(() => now.v);
-			vi.useFakeTimers();
-			const s = node([], { initial: 0 });
-			const { node: out } = rateLimiter(s, {
-				maxEvents: 1,
-				windowNs: 1 * NS_PER_SEC,
-				maxBuffer: Infinity,
-			});
-			const { batches, unsub } = collect(out);
-			s.down([[DATA, 1]]);
-			s.down([[DATA, 2]]);
-			const dataImmediate = batches
-				.flat()
-				.filter((m) => m[0] === DATA)
-				.map((m) => m[1]);
-			// Push-on-subscribe delivers the initial cached value (0), consuming the single token.
-			// DATA 1 and DATA 2 are queued.
-			expect(dataImmediate).toEqual([0]);
-			now.v += 1001;
-			await vi.advanceTimersByTimeAsync(1100);
-			const dataAfter = batches
-				.flat()
-				.filter((m) => m[0] === DATA)
-				.map((m) => m[1]);
-			// After token refill, queued item 1 drains
-			expect(dataAfter).toContain(0);
-			expect(dataAfter).toContain(1);
-			unsub();
-			spy.mockRestore();
-		});
-
-		it("rateLimiter maxBuffer + drop-newest drops incoming overflow", () => {
-			const s = node([], { initial: 0 });
-			const { node: out } = rateLimiter(s, {
-				maxEvents: 1,
-				windowNs: 10 * NS_PER_SEC,
-				maxBuffer: 1,
-				onOverflow: "drop-newest",
-			});
-			const { batches, unsub } = collect(out);
-			// Push-on-subscribe emits 0 (consumes the one token).
-			// DATA 1 → queued (pending=1). DATA 2 → dropped (pending already at maxBuffer=1).
-			// DATA 3 → dropped as well.
-			s.down([[DATA, 1]]);
-			s.down([[DATA, 2]]);
-			s.down([[DATA, 3]]);
-			const dataValues = batches
-				.flat()
-				.filter((m) => m[0] === DATA)
-				.map((m) => m[1]);
-			expect(dataValues).toEqual([0]); // only the initial token-consuming emission
-			unsub();
-		});
-
-		it("rateLimiter maxBuffer + drop-oldest evicts the oldest pending item", () => {
-			const s = node([], { initial: 0 });
-			const { node: out } = rateLimiter(s, {
-				maxEvents: 1,
-				windowNs: 10 * NS_PER_SEC,
-				maxBuffer: 1,
-				onOverflow: "drop-oldest",
-			});
-			const { unsub } = collect(out);
-			// Push-on-subscribe emits 0 (consumes token).
-			s.down([[DATA, 1]]); // queued
-			s.down([[DATA, 2]]); // overflow → drop 1, queue 2
-			s.down([[DATA, 3]]); // overflow → drop 2, queue 3
-			// pending[] should contain only [3]; no way to observe without advancing time
-			unsub();
-		});
-
-		it("rateLimiter maxBuffer + error emits RateLimiterOverflowError", () => {
-			const s = node([], { initial: 0 });
-			const { node: out } = rateLimiter(s, {
-				maxEvents: 1,
-				windowNs: 10 * NS_PER_SEC,
-				maxBuffer: 1,
-				onOverflow: "error",
-			});
-			const { batches, unsub } = collect(out);
-			s.down([[DATA, 1]]); // queued (fills buffer)
-			s.down([[DATA, 2]]); // overflow → ERROR
-			const errBatch = batches.flat().find((m) => m[0] === ERROR);
-			expect(errBatch).toBeDefined();
-			expect(errBatch?.[1]).toBeInstanceOf(RateLimiterOverflowError);
-			unsub();
-		});
-	});
-
-	describe("withStatus", () => {
-		it("tracks active, completed, errored", () => {
-			const s = node<number>();
-			const { node: out, status } = withStatus(s);
-			const { batches, unsub } = collect(out);
-			expect(status.cache).toBe("pending");
-			s.down([[DATA, 1]]);
-			expect(status.cache).toBe("running");
-			s.down([[COMPLETE]]);
-			expect(status.cache).toBe("completed");
-			expect(batches.flat().some((m) => m[0] === COMPLETE)).toBe(true);
-			unsub();
-		});
-
-		it("clears error on DATA after errored (batched)", () => {
-			const s = node([], { resubscribable: true, initial: 0 });
-			const { node: out, status, error } = withStatus(s);
-			const { unsub } = collect(out);
-			s.down([[ERROR, new Error("e")]]);
-			expect(status.cache).toBe("errored");
-			expect(error.cache).toBeInstanceOf(Error);
-			s.down([[DATA, 1]]);
-			expect(status.cache).toBe("running");
-			expect(error.cache).toBeNull();
-			unsub();
-		});
-	});
-
-	describe("meta integration (spec §2.3)", () => {
-		it("withBreaker breakerState is accessible via node.meta", () => {
-			const b = circuitBreaker({ failureThreshold: 2 });
-			const s = node([], { initial: 1 });
-			const bundle = withBreaker(b)(s);
-			expect(bundle.node.meta.breakerState).toBe(bundle.breakerState);
-			expect((bundle.breakerState.cache as { status: string }).status).toBe("closed");
-		});
-
-		it("withStatus companions are accessible via node.meta", () => {
-			const s = node([], { initial: 0 });
-			const bundle = withStatus(s);
-			expect(bundle.node.meta.status).toBe(bundle.status);
-			expect(bundle.node.meta.error).toBe(bundle.error);
-			expect(bundle.status.cache).toBe("pending");
-		});
-
-		it("withBreaker breakerState appears in graph.describe()", () => {
-			const b = circuitBreaker({ failureThreshold: 2 });
-			const s = node([], { initial: 1 });
-			const bundle = withBreaker(b)(s);
-			const g = new Graph("test");
-			g.add(s, { name: "src" });
-			g.add(bundle.node, { name: "guarded" });
-			const desc = g.describe({ detail: "standard" });
-			const metaPath = "guarded::__meta__::breakerState";
-			expect(desc.nodes[metaPath]).toBeDefined();
-			expect((desc.nodes[metaPath].value as { status: string }).status).toBe("closed");
-		});
-
-		it("withStatus companions appear in graph.describe()", () => {
-			const s = node([], { initial: 0 });
-			const bundle = withStatus(s);
-			const g = new Graph("test");
-			g.add(s, { name: "src" });
-			g.add(bundle.node, { name: "tracked" });
-			const desc = g.describe({ detail: "standard" });
-			expect(desc.nodes["tracked::__meta__::status"]).toBeDefined();
-			expect(desc.nodes["tracked::__meta__::status"].value).toBe("pending");
-			expect(desc.nodes["tracked::__meta__::error"]).toBeDefined();
-			expect(desc.nodes["tracked::__meta__::error"].value).toBeNull();
-		});
-	});
-
-	describe("pipe composition", () => {
-		it("pipe accepts retry operator", () => {
-			const s = node([], { initial: 1 });
-			const out = retry(s, { count: 0 }).node;
-			expect(out.cache).toBe(1);
-		});
-	});
-
-	// ——————————————————————————————————————————————————————————————
-	//  §3.1c — fallback, timeout, cache
-	// ——————————————————————————————————————————————————————————————
-
-	describe("fallback", () => {
-		it("passes through DATA/COMPLETE from healthy source", () => {
-			const src = node([], { initial: 42 });
-			const out = fallback(src, 0);
-			const { batches, unsub } = collect(out);
-			src.down([[DATA, 99]]);
-			const flat = batches.flat();
-			expect(
-				flat.some(
-					(m) => (m as [symbol, unknown])[0] === DATA && (m as [symbol, unknown])[1] === 99,
-				),
-			).toBe(true);
-			unsub();
-		});
-
-		it("emits fallback value on ERROR (value mode)", () => {
-			const src = throwError(new Error("boom"));
-			const out = fallback(src, "default");
-			const { batches, unsub } = collect(out);
-			const flat = batches.flat();
-			expect(
-				flat.some(
-					(m) => (m as [symbol, unknown])[0] === DATA && (m as [symbol, unknown])[1] === "default",
-				),
-			).toBe(true);
-			expect(flat.some((m) => (m as [symbol])[0] === COMPLETE)).toBe(true);
-			expect(flat.some((m) => (m as [symbol])[0] === ERROR)).toBe(false);
-			unsub();
-		});
-
-		it("switches to fallback node on ERROR (node mode)", () => {
-			const src = throwError(new Error("boom"));
-			const fb = node([], { initial: "fallback-value" });
-			const out = fallback(src, fb);
-			const { batches, unsub } = collect(out);
-			const flat = batches.flat();
-			expect(
-				flat.some(
-					(m) =>
-						(m as [symbol, unknown])[0] === DATA &&
-						(m as [symbol, unknown])[1] === "fallback-value",
-				),
-			).toBe(true);
-			expect(flat.some((m) => (m as [symbol])[0] === ERROR)).toBe(false);
-			unsub();
-		});
-
-		it("resolves a Promise fallback on ERROR", async () => {
-			const src = throwError(new Error("boom"));
-			const out = fallback(src, Promise.resolve("async-default"));
-			const { batches, unsub } = collect(out);
-			await new Promise((r) => setTimeout(r, 10));
-			const flat = batches.flat();
-			expect(
-				flat.some(
-					(m) =>
-						(m as [symbol, unknown])[0] === DATA && (m as [symbol, unknown])[1] === "async-default",
-				),
-			).toBe(true);
-			expect(flat.some((m) => (m as [symbol])[0] === ERROR)).toBe(false);
-			unsub();
-		});
-
-		it("streams an AsyncIterable fallback on ERROR", async () => {
-			const src = throwError(new Error("boom"));
-			async function* gen(): AsyncIterable<number> {
-				yield 1;
-				yield 2;
-				yield 3;
-			}
-			const out = fallback(src, gen());
-			const { batches, unsub } = collect(out);
-			await new Promise((r) => setTimeout(r, 20));
-			const values = batches
-				.flat()
-				.filter((m) => (m as [symbol])[0] === DATA)
-				.map((m) => (m as [symbol, unknown])[1]);
-			expect(values).toContain(1);
-			expect(values).toContain(2);
-			expect(values).toContain(3);
-			unsub();
-		});
-
-		it("emits a bare string as a scalar value (not split into chars)", () => {
-			const src = throwError(new Error("boom"));
-			const out = fallback(src, "default");
-			const { batches, unsub } = collect(out);
-			const values = batches
-				.flat()
-				.filter((m) => (m as [symbol])[0] === DATA)
-				.map((m) => (m as [symbol, unknown])[1]);
-			// Must be the whole string, not ["d","e","f","a","u","l","t"]
-			expect(values).toEqual(["default"]);
-			unsub();
-		});
-
-		it("composes with retry: retry then fallback", async () => {
-			const src = node(
-				[],
-				(_data, a) => {
-					a.down([[ERROR, new Error("x")]]);
-				},
-				{ describeKind: "producer", resubscribable: true },
-			);
-			// retry with count: 0 means no retries — ERROR propagates immediately
-			const out = fallback(retry(src, { count: 0 }).node, "safe");
-			const { batches, unsub } = collect(out);
-			await new Promise((r) => setTimeout(r, 20));
-			const flat = batches.flat();
-			expect(
-				flat.some(
-					(m) => (m as [symbol, unknown])[0] === DATA && (m as [symbol, unknown])[1] === "safe",
-				),
-			).toBe(true);
-			unsub();
-		});
-	});
-
-	describe("timeout", () => {
-		it("throws RangeError for non-positive timeoutNs", () => {
-			expect(() => timeout(node([], { initial: 1 }), { ns: 0 })).toThrow(RangeError);
-			expect(() => timeout(node([], { initial: 1 }), { ns: -1 })).toThrow(RangeError);
-		});
-
-		it("emits TimeoutError when no DATA arrives", () => {
-			vi.useFakeTimers();
-			const src = node(() => undefined, { describeKind: "producer" }); // never emits
-			const out = timeout(src, { ns: 100 * NS_PER_MS }).node;
-			const { batches, unsub } = collect(out);
-			vi.advanceTimersByTime(150);
-			const flat = batches.flat();
-			expect(
-				flat.some(
-					(m) =>
-						(m as [symbol, unknown])[0] === ERROR &&
-						(m as [symbol, unknown])[1] instanceof TimeoutError,
-				),
-			).toBe(true);
-			unsub();
-		});
-
-		it("DATA resets the timer", () => {
-			vi.useFakeTimers();
-			const src = node([], { initial: 0 });
-			const out = timeout(src, { ns: 100 * NS_PER_MS }).node;
-			const { batches, unsub } = collect(out);
-			vi.advanceTimersByTime(80);
-			src.down([[DATA, 1]]); // resets timer
-			vi.advanceTimersByTime(80);
-			// Should not have timed out yet (80 < 100 since reset)
-			const flat = batches.flat();
-			expect(flat.some((m) => (m as [symbol])[0] === ERROR)).toBe(false);
-			vi.advanceTimersByTime(30); // now 110ms since last DATA
-			const flat2 = batches.flat();
-			expect(flat2.some((m) => (m as [symbol])[0] === ERROR)).toBe(true);
-			unsub();
-		});
-
-		it("COMPLETE cancels the timer", () => {
-			vi.useFakeTimers();
-			const src = node(
-				[],
-				(_data, a) => {
-					a.down([[COMPLETE]]);
-				},
-				{ describeKind: "producer" },
-			);
-			const out = timeout(src, { ns: 100 * NS_PER_MS }).node;
-			const { batches, unsub } = collect(out);
-			vi.advanceTimersByTime(200);
-			const flat = batches.flat();
-			expect(flat.some((m) => (m as [symbol])[0] === COMPLETE)).toBe(true);
-			expect(flat.some((m) => (m as [symbol])[0] === ERROR)).toBe(false);
-			unsub();
-		});
-
-		it("passes DATA through on time", () => {
-			const src = node([], { initial: 42 });
-			const out = timeout(src, { ns: 10 * NS_PER_SEC }).node;
-			const { batches, unsub } = collect(out);
-			src.down([[DATA, 99]]);
-			const flat = batches.flat();
-			expect(
-				flat.some(
-					(m) => (m as [symbol, unknown])[0] === DATA && (m as [symbol, unknown])[1] === 99,
-				),
-			).toBe(true);
-			unsub();
-		});
-
-		// DS-13.5.B locked 2026-05-01: timeout returns TimeoutBundle<T>;
-		// `timeoutState` companion tracks the lifecycle. Tests below pin
-		// the bundle shape, the lifecycle transitions, the empty-{}-no-op
-		// rule, and the rebind-preserves-deadline contract.
-		describe("DS-13.5.B — TimeoutBundle + reactive opts", () => {
-			it("returns a bundle with `node` and `timeoutState`", () => {
-				const src = node([], { initial: 0 });
-				const bundle = timeout(src, { ns: 10 * NS_PER_SEC });
-				expect(bundle.node).toBeDefined();
-				expect(bundle.timeoutState).toBeDefined();
-				// Type-level: TimeoutBundle<number>.node is Node<number>.
-				const _typeCheck: TimeoutOptions = { ns: 100 };
-				expect(_typeCheck.ns).toBe(100);
-			});
-
-			it("timeoutState transitions pending → running on first DATA", () => {
-				vi.useFakeTimers();
-				const src = node([], { initial: 0 });
-				const { node: out, timeoutState } = timeout(src, { ns: 100 * NS_PER_MS });
-				const { batches, unsub } = collect(timeoutState);
-				const outUnsub = out.subscribe(() => {});
-				src.down([[DATA, 1]]);
-				const states = batches
-					.flat()
-					.filter((m) => m[0] === DATA)
-					.map((m) => m[1] as TimeoutState);
-				expect(states.some((s) => s.status === "pending")).toBe(true);
-				expect(states.some((s) => s.status === "running")).toBe(true);
-				outUnsub();
-				unsub();
-			});
-
-			it("timeoutState transitions to errored on timer fire", () => {
-				vi.useFakeTimers();
-				const src = node(() => undefined, { describeKind: "producer" });
-				const { node: out, timeoutState } = timeout(src, { ns: 100 * NS_PER_MS });
-				const { batches, unsub } = collect(timeoutState);
-				const outUnsub = out.subscribe(() => {});
-				vi.advanceTimersByTime(150);
-				const states = batches
-					.flat()
-					.filter((m) => m[0] === DATA)
-					.map((m) => m[1] as TimeoutState);
-				const errored = states.find((s) => s.status === "errored");
-				expect(errored).toBeDefined();
-				if (errored && errored.status === "errored") {
-					expect(errored.deadline_ns).toBe(100 * NS_PER_MS);
-					expect(typeof errored.firedAt_ns).toBe("number");
-				}
-				outUnsub();
-				unsub();
-			});
-
-			it("timeoutState transitions to completed on source COMPLETE", () => {
-				vi.useFakeTimers();
-				const src = node(
-					[],
-					(_data, a) => {
-						a.down([[COMPLETE]]);
-					},
-					{ describeKind: "producer" },
-				);
-				const { node: out, timeoutState } = timeout(src, { ns: 100 * NS_PER_MS });
-				const { batches, unsub } = collect(timeoutState);
-				const outUnsub = out.subscribe(() => {});
-				const states = batches
-					.flat()
-					.filter((m) => m[0] === DATA)
-					.map((m) => m[1] as TimeoutState);
-				expect(states.some((s) => s.status === "completed")).toBe(true);
-				outUnsub();
-				unsub();
-			});
-
-			it("reactive Node<Partial<TimeoutOptions>> rebind: ns change applies to next attempt only", () => {
-				vi.useFakeTimers();
-				const src = node(() => undefined, { describeKind: "producer" });
-				const optNode = node<Partial<TimeoutOptions>>([], { initial: { ns: 50 * NS_PER_MS } });
-				const { node: out } = timeout(src, optNode);
-				const { batches, unsub } = collect(out);
-				vi.advanceTimersByTime(30);
-				expect(batches.flat().some((m) => m[0] === ERROR)).toBe(false);
-				// Rebind to 200ms — does NOT affect in-flight timer.
-				optNode.emit({ ns: 200 * NS_PER_MS });
-				vi.advanceTimersByTime(25); // 30 + 25 = 55ms — past original 50ms
-				expect(
-					batches.flat().some((m) => m[0] === ERROR && (m[1] as Error) instanceof TimeoutError),
-				).toBe(true);
-				unsub();
-			});
-
-			it("empty {} emit on opts Node is a no-op", () => {
-				vi.useFakeTimers();
-				const src = node(() => undefined, { describeKind: "producer" });
-				const optNode = node<Partial<TimeoutOptions>>([], { initial: { ns: 100 * NS_PER_MS } });
-				const { node: out, timeoutState } = timeout(src, optNode);
-				const { batches: stateBatches, unsub: stateUnsub } = collect(timeoutState);
-				const outUnsub = out.subscribe(() => {});
-				const baselineCount = stateBatches.flat().filter((m) => m[0] === DATA).length;
-				optNode.emit({}); // no-op
-				const afterCount = stateBatches.flat().filter((m) => m[0] === DATA).length;
-				expect(afterCount).toBe(baselineCount);
-				outUnsub();
-				stateUnsub();
-			});
-
-			it("construction-time validation throws RangeError for missing ns (static form)", () => {
-				const src = node([], { initial: 0 });
-				expect(() => timeout(src, {})).toThrow(RangeError);
-			});
-
-			it("construction-time validation throws RangeError for invalid ns in defined-cache opts Node", () => {
-				const src = node([], { initial: 0 });
-				const optNode = node<Partial<TimeoutOptions>>([], { initial: { ns: -5 } });
-				expect(() => timeout(src, optNode)).toThrow(RangeError);
-			});
-
-			it("opts Node with cache === undefined pauses source until first valid opts emit", () => {
-				vi.useFakeTimers();
-				let srcEmitted = false;
-				const src = node(
-					[],
-					(_data, a) => {
-						srcEmitted = true;
-						a.emit(42);
-					},
-					{ describeKind: "producer" },
-				);
-				const optNode = node<Partial<TimeoutOptions>>([]); // SENTINEL: no initial
-				const { node: out } = timeout(src, optNode);
-				const { unsub } = collect(out);
-				// Source not yet attached because opts hasn't settled.
-				expect(srcEmitted).toBe(false);
-				// Provide valid opts → source attaches, fires.
-				optNode.emit({ ns: 100 * NS_PER_MS });
-				expect(srcEmitted).toBe(true);
-				unsub();
-			});
-		});
-	});
-
-	// DS-13.5.B locked 2026-05-01: budgetGate returns BudgetGateBundle<T>;
-	// `budgetGateState` companion tracks "open" / "closed" with per-constraint
-	// snapshot. Bundle return is a pre-1.0 break vs the prior `Node<T>`.
-	describe("DS-13.5.B — BudgetGateBundle + budgetGateState companion", () => {
-		it("returns a bundle with `node` and `budgetGateState`", () => {
-			const src = node<number>([], { initial: 0 });
-			const budget = node<number>([], { initial: 100 });
-			const bundle = budgetGate(src, [
-				{ node: budget, check: (v) => (v as number) > 0, name: "main" },
-			]);
-			expect(bundle.node).toBeDefined();
-			expect(bundle.budgetGateState).toBeDefined();
-		});
-
-		it("budgetGateState transitions open ↔ closed as constraints change", () => {
-			const src = node<number>([], { initial: 0 });
-			const budget = node<number>([], { initial: 100 });
-			const { node: gated, budgetGateState } = budgetGate(src, [
-				{ node: budget, check: (v) => (v as number) > 0, name: "main" },
-			]);
-			const gatedUnsub = gated.subscribe(() => {});
-			const { batches, unsub } = collect(budgetGateState);
-			// Open initially (budget=100>0).
-			const states = batches
-				.flat()
-				.filter((m) => m[0] === DATA)
-				.map((m) => m[1] as BudgetGateState);
-			expect(states.some((s) => s.status === "open")).toBe(true);
-			// Drain budget.
-			budget.down([[DATA, 0]]);
-			const after = batches
-				.flat()
-				.filter((m) => m[0] === DATA)
-				.map((m) => m[1] as BudgetGateState);
-			expect(after.some((s) => s.status === "closed")).toBe(true);
-			// Replenish.
-			budget.down([[DATA, 50]]);
-			const final = batches
-				.flat()
-				.filter((m) => m[0] === DATA)
-				.map((m) => m[1] as BudgetGateState);
-			expect(final[final.length - 1]?.status).toBe("open");
-			gatedUnsub();
-			unsub();
-		});
-
-		it("constraintsSnapshot reflects per-constraint name + satisfied + value", () => {
-			const src = node<number>([], { initial: 0 });
-			const budget = node<number>([], { initial: 25 });
-			const { node: gated, budgetGateState } = budgetGate(src, [
-				{ node: budget, check: (v) => (v as number) > 0, name: "tokens" },
-			]);
-			const gatedUnsub = gated.subscribe(() => {});
-			const { batches, unsub } = collect(budgetGateState);
-			const states = batches
-				.flat()
-				.filter((m) => m[0] === DATA)
-				.map((m) => m[1] as BudgetGateState);
-			const latest = states[states.length - 1];
-			expect(latest).toBeDefined();
-			expect(latest?.constraintsSnapshot).toHaveLength(1);
-			expect(latest?.constraintsSnapshot[0]?.name).toBe("tokens");
-			expect(latest?.constraintsSnapshot[0]?.satisfied).toBe(true);
-			expect(latest?.constraintsSnapshot[0]?.value).toBe(25);
-			gatedUnsub();
-			unsub();
-		});
-	});
-
-	// ——————————————————————————————————————————————————————————————
-	//  Tier 3.1 — Supervisors footgun + dedup
-	// ——————————————————————————————————————————————————————————————
-
-	describe("Tier 3.1 footgun: retry({ backoff }) without count", () => {
-		it("source mode throws RangeError when backoff is set without count", () => {
-			const src = node([], { initial: 0 });
-			expect(() => retry(src, { backoff: constant(0) })).toThrow(
-				/retry\(\{ backoff \}\) requires explicit count/,
-			);
-		});
-
-		it("factory mode throws RangeError when backoff is set without count", () => {
-			const factory = () => node([], { initial: 0 });
-			expect(() => retry(factory, { backoff: constant(0) })).toThrow(
-				/retry\(\{ backoff \}\) requires explicit count/,
-			);
-		});
-
-		it("count: Infinity opts in to unbounded retries (no throw)", () => {
-			const src = node([], { initial: 0 });
-			expect(() => retry(src, { count: Infinity, backoff: constant(0) })).not.toThrow();
-		});
-
-		it("backoff omitted does not require count (back-compat for default-zero retries)", () => {
-			const src = node([], { initial: 0 });
-			expect(() => retry(src)).not.toThrow();
-			expect(() => retry(src, {})).not.toThrow();
-			expect(() => retry(src, { count: 5 })).not.toThrow();
-		});
-	});
-
-	describe("Tier 3.1 dedup: source/factory parity", () => {
-		it("identical retry behavior across source-mode and factory-mode on a sequence", async () => {
-			vi.useFakeTimers();
-			// Build a sequence that errors twice then emits 99.
-			let sourceRuns = 0;
-			const sharedSrc = node<number>(
-				[],
-				(_data, a) => {
-					sourceRuns += 1;
-					if (sourceRuns < 3) a.down([[ERROR, new Error(`fail-${sourceRuns}`)]]);
-					else a.emit(99);
-				},
-				{ describeKind: "producer", resubscribable: true },
-			);
-			const sourceOut = retry(sharedSrc, { count: 5, backoff: constant(0) }).node;
-			const sourceCollect = collect(sourceOut);
-			await vi.advanceTimersByTimeAsync(50);
-
-			let factoryBuilds = 0;
-			const factoryOut = retry(
-				() => {
-					factoryBuilds += 1;
-					return node<number>(
-						[],
-						(_data, a) => {
-							if (factoryBuilds < 3) a.down([[ERROR, new Error(`fail-${factoryBuilds}`)]]);
-							else a.emit(99);
-						},
-						{ describeKind: "producer" },
-					);
-				},
-				{ count: 5, backoff: constant(0) },
-			).node;
-			const factoryCollect = collect(factoryOut);
-			await vi.advanceTimersByTimeAsync(50);
-
-			const sourceData = sourceCollect.batches.flat().filter((m) => m[0] === DATA);
-			const factoryData = factoryCollect.batches.flat().filter((m) => m[0] === DATA);
-			expect(sourceData.map((m) => m[1])).toEqual([99]);
-			expect(factoryData.map((m) => m[1])).toEqual([99]);
-			expect(sourceRuns).toBe(3);
-			expect(factoryBuilds).toBe(3);
-			sourceCollect.unsub();
-			factoryCollect.unsub();
-		});
-	});
-
-	// ——————————————————————————————————————————————————————————————
-	//  Tier 3.2 — Throttles & status footgun + companion + clock
-	// ——————————————————————————————————————————————————————————————
-
-	describe("Tier 3.2 footgun: rateLimiter without maxBuffer", () => {
-		it("throws RangeError when maxBuffer is omitted", () => {
-			const s = node([], { initial: 0 });
-			expect(() => rateLimiter(s, { maxEvents: 5, windowNs: NS_PER_SEC } as never)).toThrow(
-				/rateLimiter requires explicit maxBuffer/,
-			);
-		});
-
-		it("accepts Infinity for opt-in unbounded buffer", () => {
-			const s = node([], { initial: 0 });
-			expect(() =>
-				rateLimiter(s, { maxEvents: 5, windowNs: NS_PER_SEC, maxBuffer: Infinity }),
-			).not.toThrow();
-		});
-
-		it("accepts a positive integer maxBuffer", () => {
-			const s = node([], { initial: 0 });
-			expect(() =>
-				rateLimiter(s, { maxEvents: 5, windowNs: NS_PER_SEC, maxBuffer: 100 }),
-			).not.toThrow();
-		});
-
-		it("rejects fractional maxBuffer values", () => {
-			const s = node([], { initial: 0 });
-			expect(() => rateLimiter(s, { maxEvents: 5, windowNs: NS_PER_SEC, maxBuffer: 1.5 })).toThrow(
-				/maxBuffer must be a positive integer/,
-			);
-		});
-
-		it("D4 — throws when reactive (Node-form) opts has no cached value at construction", () => {
-			const s = node([], { initial: 0 });
-			const optsNode = node<RateLimiterOptions>([], { name: "rl-opts" }); // un-seeded → SENTINEL
-			expect(() => rateLimiter(s, optsNode)).toThrow(
-				/reactive \(Node-form\) opts must carry a cached value at construction/,
-			);
-		});
-
-		it("D4 — a seeded reactive opts Node constructs fine and validates the seed", () => {
-			const s = node([], { initial: 0 });
-			const good = node<RateLimiterOptions>([], {
-				name: "rl-opts-good",
-				initial: { maxEvents: 5, windowNs: NS_PER_SEC, maxBuffer: 10 },
-			});
-			expect(() => rateLimiter(s, good)).not.toThrow();
-			// The resolved seed runs through the same validation gate as static opts.
-			const bad = node<RateLimiterOptions>([], {
-				name: "rl-opts-bad",
-				initial: { maxEvents: 5, windowNs: NS_PER_SEC, maxBuffer: 1.5 },
-			});
-			expect(() => rateLimiter(s, bad)).toThrow(/maxBuffer must be a positive integer/);
-		});
-	});
-
-	describe("Tier 3.2 droppedCount reactive companion", () => {
-		it("increments on drop-newest overflow", () => {
-			const s = node([], { initial: 0 });
-			const { node: out, droppedCount } = rateLimiter(s, {
-				maxEvents: 1,
-				windowNs: 10 * NS_PER_SEC,
-				maxBuffer: 1,
-				onOverflow: "drop-newest",
-			});
-			const { unsub } = collect(out);
-			// push-on-subscribe consumes the only token; pending=[]. DATA 1 → queued (pending=1).
-			s.down([[DATA, 1]]);
-			expect(droppedCount.cache).toBe(0);
-			s.down([[DATA, 2]]); // overflow → drop
-			expect(droppedCount.cache).toBe(1);
-			s.down([[DATA, 3]]); // overflow → drop
-			expect(droppedCount.cache).toBe(2);
-			unsub();
-		});
-
-		it("increments on drop-oldest overflow", () => {
-			const s = node([], { initial: 0 });
-			const { node: out, droppedCount } = rateLimiter(s, {
-				maxEvents: 1,
-				windowNs: 10 * NS_PER_SEC,
-				maxBuffer: 1,
-				onOverflow: "drop-oldest",
-			});
-			const { unsub } = collect(out);
-			s.down([[DATA, 1]]); // queued
-			expect(droppedCount.cache).toBe(0);
-			s.down([[DATA, 2]]); // evicts 1, queues 2
-			expect(droppedCount.cache).toBe(1);
-			s.down([[DATA, 3]]); // evicts 2, queues 3
-			expect(droppedCount.cache).toBe(2);
-			unsub();
-		});
-
-		it("preserves final droppedCount on terminal (qa A1 — no rewind)", () => {
-			// qa A1: the prior contract reset droppedCount to 0 on terminal,
-			// emitting `[DATA, N], [DATA, 0]` then no terminal — consumers
-			// thought drops were undone. New contract: final count is the
-			// last observable state. Next subscription cycle re-zeros for
-			// the new cycle (see `cache !== 0` reset path at activation).
-			const s = node([], { resubscribable: true, initial: 0 });
-			const { node: out, droppedCount } = rateLimiter(s, {
-				maxEvents: 1,
-				windowNs: 10 * NS_PER_SEC,
-				maxBuffer: 1,
-				onOverflow: "drop-newest",
-			});
-			const { unsub } = collect(out);
-			s.down([[DATA, 1]]);
-			s.down([[DATA, 2]]); // dropped
-			s.down([[DATA, 3]]); // dropped
-			expect(droppedCount.cache).toBe(2);
-			s.down([[COMPLETE]]);
-			expect(droppedCount.cache).toBe(2); // final count preserved
-			unsub();
-		});
-
-		it("droppedCount appears as a reactive companion via node.meta", () => {
-			const s = node([], { initial: 0 });
-			const bundle = rateLimiter(s, {
-				maxEvents: 1,
-				windowNs: 10 * NS_PER_SEC,
-				maxBuffer: 1,
-			});
-			expect(bundle.node.meta.droppedCount).toBe(bundle.droppedCount);
-			expect(bundle.droppedCount.cache).toBe(0);
-		});
-	});
-
-	describe("Tier 3.2 tokenBucket clock injection", () => {
-		it("uses injected clock for refill scheduling (no fake timers needed)", () => {
-			let now = 0;
-			const tb = tokenBucket(2, 1, { clock: () => now });
-			expect(tb.tryConsume(2)).toBe(true);
-			expect(tb.tryConsume(1)).toBe(false);
-
-			now = NS_PER_SEC; // advance 1s → +1 token
-			expect(tb.available()).toBe(1);
-			expect(tb.tryConsume(1)).toBe(true);
-			expect(tb.tryConsume(1)).toBe(false);
-
-			now = 3 * NS_PER_SEC; // advance 2s more → +2 tokens, capped at 2
-			expect(tb.available()).toBe(2);
-		});
-
-		it("default clock is monotonicNs (no opts param)", () => {
-			const tb = tokenBucket(5, 1);
-			expect(tb.available()).toBeGreaterThanOrEqual(0);
-		});
-
-		it("putBack honors injected clock for refill timing", () => {
-			const now = 0;
-			const tb = tokenBucket(3, 0, { clock: () => now });
-			expect(tb.tryConsume(3)).toBe(true);
-			expect(tb.available()).toBe(0);
-			tb.putBack(2);
-			expect(tb.available()).toBe(2);
-		});
-	});
-
-	// ── Tier 6.5 3.2: reactive option swaps (NodeOrValue<Options>) ──────────
-
-	describe("Tier 6.5 3.2: reactive options widening", () => {
-		it("3.2.1 timeout: Node<Partial<TimeoutOptions>> re-read on next attempt boundary", () => {
-			vi.useFakeTimers();
-			const src = node(() => undefined, { describeKind: "producer" }); // never emits
-			const optNode = node<{ ns: number }>([], { initial: { ns: 50 * NS_PER_MS } });
-			const out = timeout(src, optNode).node;
-			const { batches, unsub } = collect(out);
-			// Initial 50ms — no fire yet at 30ms.
-			vi.advanceTimersByTime(30);
-			expect(batches.flat().some((m) => (m as [symbol])[0] === ERROR)).toBe(false);
-			// Swap option to 200ms — applies to the NEXT timer (current
-			// in-flight timer keeps its 50ms deadline). Past 50ms total → fire.
-			optNode.emit({ ns: 200 * NS_PER_MS });
-			vi.advanceTimersByTime(30); // total 60ms — original deadline crossed
-			const flat = batches.flat();
-			expect(
-				flat.some(
-					(m) =>
-						(m as [symbol, unknown])[0] === ERROR &&
-						(m as [symbol, unknown])[1] instanceof TimeoutError,
-				),
-			).toBe(true);
-			unsub();
-			vi.useRealTimers();
-		});
-
-		it("3.2.2 retry: Node<RetryOptions> swap shrinks count → next attempt fails immediately", () => {
-			vi.useFakeTimers();
-			let attemptCount = 0;
-			const optNode = node<RetryOptions>([], { initial: { count: 5 } });
-			const factory = (): Node<number> => {
-				attemptCount += 1;
-				return node(
-					[],
-					(_data, a) => {
-						a.down([[ERROR, new Error(`attempt ${attemptCount}`)]]);
-					},
-					{ describeKind: "producer" },
-				);
-			};
-			const out = retry(factory, optNode).node;
-			const { batches, unsub } = collect(out);
-			// First attempt fires synchronously via the producer body; further
-			// retries are scheduled via 1ms-floor timer. Drive timer drain.
-			vi.advanceTimersByTime(50);
-			const afterFirstWindow = attemptCount;
-			expect(afterFirstWindow).toBeGreaterThanOrEqual(2);
-			// Shrink count to 0 → next attempt's `getCfg()` reads count=0,
-			// `attempt >= 0` → finishes immediately with ERROR.
-			optNode.emit({ count: 0 });
-			vi.advanceTimersByTime(50);
-			// Retry chain emits final ERROR after exhaustion under new count.
-			const flat = batches.flat();
-			expect(flat.some((m) => (m as [symbol])[0] === ERROR)).toBe(true);
-			// No further attempts after the swap (locked semantic).
-			expect(attemptCount).toBeLessThanOrEqual(afterFirstWindow + 1);
-			unsub();
-			vi.useRealTimers();
-		});
-
-		it("3.2.3 rateLimiter: Node<Options> swap shrinks maxBuffer → drop-oldest until fit", () => {
-			vi.useFakeTimers();
-			const src = node<number>([], { initial: 0 });
-			const optNode = node<RateLimiterOptions>([], {
-				initial: {
-					maxEvents: 1,
-					windowNs: NS_PER_SEC,
-					maxBuffer: 10,
-					onOverflow: "drop-newest",
-				},
-			});
-			const bundle = rateLimiter(src, optNode);
-			const { unsub } = collect(bundle.node);
-			// Push 5 DATAs into the source. The bucket (capacity=1) consumes
-			// one token per push attempt; subsequent pushes accumulate in
-			// pending until a token refills.
-			for (let i = 1; i <= 5; i++) src.down([[DATA, i]]);
-			const before = bundle.rateLimitState.cache as RateLimiterState;
-			// All pushed items land in `pending` then `tryEmit` consumes
-			// available tokens. With cap=1 and 5 inputs (plus initial state 0
-			// push-on-subscribe) the steady pending count is 5 (one consumed
-			// emit, the rest waiting for refill).
-			expect(before.pendingCount).toBe(5);
-			expect(before.droppedCount).toBe(0);
-			// Shrink maxBuffer to 2 — drop-oldest until pending.size <= 2.
-			optNode.emit({
-				maxEvents: 1,
-				windowNs: NS_PER_SEC,
-				maxBuffer: 2,
-				onOverflow: "drop-newest",
-			});
-			const after = bundle.rateLimitState.cache as RateLimiterState;
-			expect(after.pendingCount).toBe(2);
-			expect(after.droppedCount).toBe(3); // 5 - 2 = 3 dropped
-			unsub();
-			vi.useRealTimers();
-		});
-
-		it("3.2.4 circuitBreaker: Node<Options> swap preserves state (DS-13.5.B locked 2026-05-01)", () => {
-			const now = 0;
-			const optNode = node<CircuitBreakerOptions>([], {
-				initial: {
-					failureThreshold: 2,
-					cooldownNs: NS_PER_SEC,
-					now: () => now,
-				},
-			});
-			const breaker = circuitBreaker(optNode);
-			breaker.recordFailure();
-			breaker.recordFailure();
-			expect(breaker.state).toBe("open"); // hit threshold
-			expect(breaker.failureCount).toBe(2);
-			// DS-13.5.B: state-preserving rebind. Today's "reset on opts swap"
-			// is gone — counters and `_state` carry across the swap.
-			const fixedNow = optNode.cache?.now;
-			optNode.emit({ failureThreshold: 5, cooldownNs: NS_PER_SEC, now: fixedNow });
-			expect(breaker.state).toBe("open");
-			expect(breaker.failureCount).toBe(2);
-			breaker.dispose();
-		});
-
-		it("3.2.4 circuitBreaker: empty {} opts emit is a no-op", () => {
-			const optNode = node<CircuitBreakerOptions>([], {
-				initial: { failureThreshold: 2, cooldownNs: NS_PER_SEC, now: () => 0 },
-			});
-			const breaker = circuitBreaker(optNode);
-			breaker.recordFailure();
-			expect(breaker.failureCount).toBe(1);
-			optNode.emit({} as CircuitBreakerOptions);
-			expect(breaker.failureCount).toBe(1);
-			breaker.dispose();
-		});
-
-		it("3.2.4 circuitBreaker: changing `now` mid-flight is logged + skipped (mode-locked, QA A2)", () => {
-			const optNode = node<CircuitBreakerOptions>([], {
-				initial: { failureThreshold: 2, cooldownNs: NS_PER_SEC, now: () => 0 },
-			});
-			const breaker = circuitBreaker(optNode);
-			breaker.recordFailure();
-			expect(breaker.failureCount).toBe(1);
-			const errSpy = vi.spyOn(console, "error").mockImplementation(() => undefined);
-			// QA A2 (2026-05-03): no longer throws — sync throw inside subscribe
-			// callback corrupted the host scheduler's wave dispatch. The bad
-			// `now` change is logged and skipped; prior state is preserved.
-			expect(() => optNode.emit({ now: () => 999 } as CircuitBreakerOptions)).not.toThrow();
-			expect(errSpy).toHaveBeenCalled();
-			expect(breaker.failureCount).toBe(1);
-			errSpy.mockRestore();
-			breaker.dispose();
-		});
-	});
-});
diff --git a/src/__tests__/utils/resilience/token-bucket-putback.test.ts b/src/__tests__/utils/resilience/token-bucket-putback.test.ts
deleted file mode 100644
index 15b39191..00000000
--- a/src/__tests__/utils/resilience/token-bucket-putback.test.ts
+++ /dev/null
@@ -1,34 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { tokenBucket } from "../../../utils/resilience/rate-limiter.js";
-
-describe("TokenBucket.putBack", () => {
-	it("returns consumed tokens to the bucket", () => {
-		const b = tokenBucket(10, 0);
-		expect(b.tryConsume(5)).toBe(true);
-		expect(b.available()).toBeCloseTo(5);
-		b.putBack(3);
-		expect(b.available()).toBeCloseTo(8);
-	});
-
-	it("caps at capacity", () => {
-		const b = tokenBucket(10, 0);
-		expect(b.tryConsume(2)).toBe(true);
-		b.putBack(100);
-		expect(b.available()).toBeCloseTo(10);
-	});
-
-	it("no-op on non-positive cost", () => {
-		const b = tokenBucket(10, 0);
-		b.tryConsume(5);
-		b.putBack(0);
-		b.putBack(-5);
-		expect(b.available()).toBeCloseTo(5);
-	});
-
-	it("default cost is 1", () => {
-		const b = tokenBucket(10, 0);
-		b.tryConsume(5);
-		b.putBack();
-		expect(b.available()).toBeCloseTo(6);
-	});
-});
diff --git a/src/__tests__/utils/surface/surface.test.ts b/src/__tests__/utils/surface/surface.test.ts
deleted file mode 100644
index 3765919f..00000000
--- a/src/__tests__/utils/surface/surface.test.ts
+++ /dev/null
@@ -1,397 +0,0 @@
-import { factoryTag, node } from "@graphrefly/pure-ts/core";
-import { memoryKv } from "@graphrefly/pure-ts/extra";
-import { Graph } from "@graphrefly/pure-ts/graph";
-import { describe, expect, it } from "vitest";
-import type { GraphSpec, GraphSpecCatalog } from "../../../utils/graphspec/index.js";
-import {
-	createGraph,
-	deleteSnapshot,
-	diffSnapshots,
-	listSnapshots,
-	restoreSnapshot,
-	runReduction,
-	SurfaceError,
-	saveSnapshot,
-} from "../../../utils/surface/index.js";
-
-/** Shared catalog for surface tests. Mirrors the style in graphspec tests. */
-const catalog: GraphSpecCatalog = {
-	fns: {
-		double: (deps) =>
-			node(
-				deps,
-				(batchData, actions, ctx) => {
-					const data = batchData.map((batch, i) =>
-						batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-					);
-					actions.emit((data[0] as number) * 2);
-				},
-				{ describeKind: "derived" },
-			),
-		addOne: (deps) =>
-			node(
-				deps,
-				(batchData, actions, ctx) => {
-					const data = batchData.map((batch, i) =>
-						batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-					);
-					actions.emit((data[0] as number) + 1);
-				},
-				{ describeKind: "derived" },
-			),
-		identity: (deps) =>
-			node(
-				deps,
-				(batchData, actions, ctx) => {
-					const data = batchData.map((batch, i) =>
-						batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-					);
-					actions.emit(data[0]);
-				},
-				{ describeKind: "derived" },
-			),
-	},
-};
-
-const basicSpec: GraphSpec = {
-	name: "basic-reduce",
-	nodes: {
-		input: { type: "state", deps: [], value: 0 },
-		doubled: { type: "derived", deps: ["input"], meta: { ...factoryTag("double") } },
-		output: { type: "derived", deps: ["doubled"], meta: { ...factoryTag("addOne") } },
-	},
-};
-
-describe("surface.createGraph", () => {
-	it("builds a graph from a valid spec", () => {
-		const g = createGraph(basicSpec, { catalog });
-		expect(g).toBeInstanceOf(Graph);
-		expect(g.name).toBe("basic-reduce");
-		g.destroy();
-	});
-
-	it("throws SurfaceError(invalid-spec) on structural errors", () => {
-		const bad: unknown = { name: "bad", nodes: { x: { type: "nonsense" } } };
-		try {
-			createGraph(bad as GraphSpec, { catalog });
-			expect.fail("expected throw");
-		} catch (err) {
-			expect(err).toBeInstanceOf(SurfaceError);
-			const se = err as SurfaceError;
-			expect(se.code).toBe("invalid-spec");
-			expect(se.details?.errors).toBeDefined();
-		}
-	});
-
-	it("throws SurfaceError(catalog-error) on unknown fn name", () => {
-		const spec: GraphSpec = {
-			name: "missing-fn",
-			nodes: {
-				input: { type: "state", deps: [], value: 0 },
-				output: { type: "derived", deps: ["input"], meta: { ...factoryTag("doesNotExist") } },
-			},
-		};
-		try {
-			createGraph(spec, { catalog });
-			expect.fail("expected throw");
-		} catch (err) {
-			expect(err).toBeInstanceOf(SurfaceError);
-			expect((err as SurfaceError).code).toBe("catalog-error");
-		}
-	});
-
-	it("serializes SurfaceError as JSON-safe payload", () => {
-		try {
-			createGraph({ name: "", nodes: {} } as GraphSpec);
-		} catch (err) {
-			const payload = (err as SurfaceError).toJSON();
-			expect(payload.code).toBe("invalid-spec");
-			expect(typeof payload.message).toBe("string");
-			expect(JSON.parse(JSON.stringify(payload))).toEqual(payload);
-		}
-	});
-});
-
-describe("surface.runReduction", () => {
-	it("runs input → pipeline → output in one shot", async () => {
-		const result = await runReduction(basicSpec, 5, { catalog });
-		// doubled(5)=10, addOne(10)=11
-		expect(result).toBe(11);
-	});
-
-	it("respects custom inputPath/outputPath", async () => {
-		const spec: GraphSpec = {
-			name: "custom-paths",
-			nodes: {
-				src: { type: "state", deps: [], value: 0 },
-				result: { type: "derived", deps: ["src"], meta: { ...factoryTag("double") } },
-			},
-		};
-		const result = await runReduction(spec, 7, { catalog, inputPath: "src", outputPath: "result" });
-		expect(result).toBe(14);
-	});
-
-	it("throws node-not-found when inputPath is missing", async () => {
-		await expect(runReduction(basicSpec, 1, { catalog, inputPath: "nope" })).rejects.toMatchObject({
-			code: "node-not-found",
-		});
-	});
-
-	it("throws node-not-found when outputPath is missing", async () => {
-		await expect(runReduction(basicSpec, 1, { catalog, outputPath: "nope" })).rejects.toMatchObject(
-			{
-				code: "node-not-found",
-			},
-		);
-	});
-
-	it("resolves via outputNode.cache on RESOLVED (input changed, output equal)", async () => {
-		// Spec §1.3.3 equals-substitution: when the input changes but the
-		// output recomputes to a value equal to its cached value, the
-		// graph emits [[RESOLVED]] instead of [[DATA, v]]. runReduction
-		// must return the cache rather than timeout.
-		const alwaysOne: GraphSpecCatalog = {
-			fns: {
-				double: (deps) =>
-					node(
-						deps,
-						(batchData, actions, ctx) => {
-							const data = batchData.map((batch, i) =>
-								batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-							);
-							actions.emit((data[0] as number) * 2);
-						},
-						{ describeKind: "derived" },
-					),
-				constOne: (deps) =>
-					node(
-						deps,
-						(batchData, actions, ctx) => {
-							const _data = batchData.map((batch, i) =>
-								batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-							);
-							actions.emit(1);
-						},
-						{ describeKind: "derived" },
-					),
-			},
-		};
-		const spec: GraphSpec = {
-			name: "resolved-test",
-			nodes: {
-				input: { type: "state", deps: [], value: 0 },
-				doubled: { type: "derived", deps: ["input"], meta: { ...factoryTag("double") } },
-				output: { type: "derived", deps: ["doubled"], meta: { ...factoryTag("constOne") } },
-			},
-		};
-		const result = await runReduction(spec, 7, { catalog: alwaysOne, timeoutMs: 200 });
-		expect(result).toBe(1);
-	});
-
-	it("throws reduce-timeout when output never settles post-push", async () => {
-		// Build a graph whose output node never re-emits because there's no
-		// dep chain from input to output.
-		const spec: GraphSpec = {
-			name: "no-chain",
-			nodes: {
-				input: { type: "state", deps: [], value: 0 },
-				unrelated: { type: "state", deps: [], value: "stuck" },
-				output: { type: "derived", deps: ["unrelated"], meta: { ...factoryTag("identity") } },
-			},
-		};
-		await expect(runReduction(spec, 1, { catalog, timeoutMs: 50 })).rejects.toMatchObject({
-			code: "reduce-timeout",
-		});
-	});
-});
-
-describe("surface.snapshot", () => {
-	it("saves and restores a state-only graph through a StorageTier", async () => {
-		const stateSpec: GraphSpec = {
-			name: "state-only",
-			nodes: {
-				input: { type: "state", deps: [], value: 0 },
-				note: { type: "state", deps: [], value: "hello" },
-			},
-		};
-		const g = createGraph(stateSpec, { catalog });
-		g.set("input", 12);
-		g.set("note", "world");
-		const tier = memoryKv();
-		const result = await saveSnapshot(g, "snap-1", tier);
-		expect(result.snapshotId).toBe("snap-1");
-		expect(result.timestamp_ns).toBeGreaterThan(0);
-		g.destroy();
-
-		const restored = await restoreSnapshot("snap-1", tier);
-		expect(restored.name).toBe("state-only");
-		expect(restored.node("input").cache).toBe(12);
-		expect(restored.node("note").cache).toBe("world");
-		restored.destroy();
-	});
-
-	it("passes factories through to Graph.fromSnapshot for derived restore", async () => {
-		const g = createGraph(basicSpec, { catalog });
-		g.set("input", 3);
-		const tier = memoryKv();
-		await saveSnapshot(g, "with-derived", tier);
-		g.destroy();
-
-		const seen: string[] = [];
-		const restored = await restoreSnapshot("with-derived", tier, {
-			factories: {
-				"**": (_name, ctx) => {
-					seen.push(ctx.path);
-					const nodePath = ctx.path;
-					return node(
-						ctx.resolvedDeps,
-						(batchData, actions, fnCtx) => {
-							const data = batchData.map((batch, i) =>
-								batch != null && batch.length > 0 ? batch.at(-1) : fnCtx.prevData[i],
-							);
-							const v = data[0];
-							const result =
-								nodePath === "doubled"
-									? (v as number) * 2
-									: nodePath === "output"
-										? (v as number) + 1
-										: v;
-							actions.emit(result);
-						},
-						{ describeKind: "derived" },
-					);
-				},
-			},
-		});
-		// Factories were invoked for non-state paths only; state auto-hydrates.
-		expect(seen.sort()).toEqual(["doubled", "output"]);
-		expect(restored.node("input").cache).toBe(3);
-		// Derived nodes activate lazily — subscribing primes their cache.
-		restored.resolve("output").subscribe(() => {});
-		expect(restored.node("doubled").cache).toBe(6);
-		expect(restored.node("output").cache).toBe(7);
-		restored.destroy();
-	});
-
-	it("throws snapshot-not-found on missing id", async () => {
-		const tier = memoryKv();
-		await expect(restoreSnapshot("ghost", tier)).rejects.toMatchObject({
-			code: "snapshot-not-found",
-		});
-	});
-
-	it("lists saved snapshot ids", async () => {
-		const g = createGraph(basicSpec, { catalog });
-		const tier = memoryKv();
-		await saveSnapshot(g, "a", tier);
-		await saveSnapshot(g, "c", tier);
-		await saveSnapshot(g, "b", tier);
-		const ids = await listSnapshots(tier);
-		expect([...ids]).toEqual(["a", "b", "c"]);
-		g.destroy();
-	});
-
-	it("deletes a saved snapshot", async () => {
-		const g = createGraph(basicSpec, { catalog });
-		const tier = memoryKv();
-		await saveSnapshot(g, "x", tier);
-		await deleteSnapshot("x", tier);
-		await expect(restoreSnapshot("x", tier)).rejects.toMatchObject({
-			code: "snapshot-not-found",
-		});
-		g.destroy();
-	});
-
-	it("computes a structural diff between two snapshots", async () => {
-		const g = createGraph(basicSpec, { catalog });
-		const tier = memoryKv();
-		g.set("input", 1);
-		await saveSnapshot(g, "before", tier);
-		g.set("input", 99);
-		await saveSnapshot(g, "after", tier);
-		const d = await diffSnapshots("before", "after", tier);
-		expect(d.summary).not.toBe("no changes");
-		g.destroy();
-	});
-
-	it("throws tier-no-list when tier lacks list()", async () => {
-		const tier = { save() {}, load: () => null };
-		await expect(listSnapshots(tier)).rejects.toMatchObject({
-			code: "tier-no-list",
-		});
-	});
-
-	it("listSnapshots filters non-surface keys on a shared tier (B6 namespacing)", async () => {
-		const g = createGraph(basicSpec, { catalog });
-		const tier = memoryKv();
-		// Surface-written snapshot — should appear in listSnapshots.
-		await saveSnapshot(g, "surface-1", tier);
-		// Simulate an attachSnapshotStorage-style bare key — should NOT appear.
-		await tier.save("some-graph-name", {
-			mode: "full",
-			seq: 0,
-			timestamp_ns: 0,
-			format_version: 1,
-			snapshot: g.snapshot(),
-		});
-		const ids = await listSnapshots(tier);
-		expect([...ids]).toEqual(["surface-1"]);
-		// Opt-in to legacy behavior for users reading pre-namespacing sets.
-		const all = await listSnapshots(tier, { includeUnprefixed: true });
-		expect([...all].sort()).toEqual(["some-graph-name", "surface-1"]);
-		g.destroy();
-	});
-
-	it("restoreSnapshot reads both namespaced and bare keys (back-compat)", async () => {
-		const g = createGraph(basicSpec, { catalog });
-		const tier = memoryKv();
-		await saveSnapshot(g, "ns", tier);
-		// Bare-key write for legacy compat simulation.
-		await tier.save("legacy", {
-			mode: "full",
-			seq: 0,
-			timestamp_ns: 0,
-			format_version: 1,
-			snapshot: g.snapshot(),
-		});
-		const factories = {
-			"spec:basic-reduce/doubled": basicSpec.nodes.doubled,
-			"spec:basic-reduce/output": basicSpec.nodes.output,
-		};
-		await expect(
-			restoreSnapshot("ns", tier, {
-				factories: { doubled: catalog.fns!.double, output: catalog.fns!.addOne },
-			}),
-		).resolves.toBeInstanceOf(Graph);
-		await expect(
-			restoreSnapshot("legacy", tier, {
-				factories: { doubled: catalog.fns!.double, output: catalog.fns!.addOne },
-			}),
-		).resolves.toBeInstanceOf(Graph);
-		void factories; // avoid unused-var
-		g.destroy();
-	});
-
-	it("saveSnapshot / restoreSnapshot / deleteSnapshot / diffSnapshots reject ids with reserved prefix (D8)", async () => {
-		const g = createGraph(basicSpec, { catalog });
-		const tier = memoryKv();
-		await expect(saveSnapshot(g, "snapshot:boom", tier)).rejects.toMatchObject({
-			code: "snapshot-failed",
-			message: expect.stringContaining('must not start with "snapshot:"'),
-		});
-		await expect(restoreSnapshot("snapshot:boom", tier)).rejects.toMatchObject({
-			code: "snapshot-failed",
-		});
-		await expect(deleteSnapshot("snapshot:boom", tier)).rejects.toMatchObject({
-			code: "snapshot-failed",
-		});
-		await expect(diffSnapshots("snapshot:a", "snapshot:b", tier)).rejects.toMatchObject({
-			code: "snapshot-failed",
-		});
-		// External id "snapshot" (no colon) is allowed — only the full prefix is reserved.
-		await expect(saveSnapshot(g, "snapshot", tier)).resolves.toMatchObject({
-			snapshotId: "snapshot",
-		});
-		g.destroy();
-	});
-});
diff --git a/src/__tests__/utils/test-helpers.ts b/src/__tests__/utils/test-helpers.ts
deleted file mode 100644
index 46a20c54..00000000
--- a/src/__tests__/utils/test-helpers.ts
+++ /dev/null
@@ -1,54 +0,0 @@
-/**
- * Shared test utilities for subscribing to nodes and collecting messages.
- */
-import { START } from "@graphrefly/pure-ts/core";
-
-type Subscribable = { subscribe: (fn: (m: unknown) => void) => () => void };
-
-export type CollectOptions = {
-	flat?: boolean;
-	raw?: boolean;
-};
-
-type CollectBatchResult = { messages: unknown[][]; batches: unknown[][]; unsub: () => void };
-type CollectFlatResult = {
-	messages: [symbol, unknown?][];
-	msgs: [symbol, unknown?][];
-	unsub: () => void;
-};
-
-export function collect(
-	node: Subscribable,
-	opts: CollectOptions & { flat: true },
-): CollectFlatResult;
-export function collect(node: Subscribable, opts?: CollectOptions): CollectBatchResult;
-export function collect(
-	node: Subscribable,
-	opts?: CollectOptions,
-): CollectBatchResult | CollectFlatResult {
-	const flat = opts?.flat === true;
-	const raw = opts?.raw === true;
-
-	if (flat) {
-		const messages: [symbol, unknown?][] = [];
-		const unsub = node.subscribe((m) => {
-			for (const msg of m as [symbol, unknown?][]) {
-				if (raw || msg[0] !== START) messages.push(msg);
-			}
-		});
-		return { messages, msgs: messages, unsub };
-	}
-
-	const messages: unknown[][] = [];
-	const unsub = node.subscribe((msgs) => {
-		const filtered = raw
-			? (msgs as unknown[])
-			: (msgs as unknown[]).filter((m) => (m as [symbol, unknown])[0] !== START);
-		if (filtered.length > 0) messages.push(filtered);
-	});
-	return { messages, batches: messages, unsub };
-}
-
-export function collectFlat(node: Subscribable) {
-	return collect(node, { flat: true });
-}
diff --git a/src/__tests__/utils/topology-view/topology-view.test.ts b/src/__tests__/utils/topology-view/topology-view.test.ts
deleted file mode 100644
index bacc1b1c..00000000
--- a/src/__tests__/utils/topology-view/topology-view.test.ts
+++ /dev/null
@@ -1,266 +0,0 @@
-/**
- * `topologyView` integration tests (D3 — Three-layer view).
- */
-
-import { DATA, node } from "@graphrefly/pure-ts/core";
-import { Graph, type GraphDescribeOutput } from "@graphrefly/pure-ts/graph";
-import { describe, expect, it } from "vitest";
-import { layoutFrameToSvg } from "../../../base/render/index.js";
-import {
-	type LayoutFn,
-	type LayoutFrame,
-	topologyView,
-} from "../../../utils/topology-view/index.js";
-
-// ---------------------------------------------------------------------------
-// Helper — build a small target graph with N source nodes
-// ---------------------------------------------------------------------------
-
-function makeTarget(): Graph {
-	const g = new Graph("target");
-	const a = node<number>([], { name: "a", initial: 1 });
-	const b = node<number>([], { name: "b", initial: 2 });
-	g.add(a, { name: "a" });
-	g.add(b, { name: "b" });
-	g.derived("c", ["a", "b"], (data, ctx) => {
-		const av =
-			data[0] != null && data[0].length > 0
-				? (data[0].at(-1) as number)
-				: (ctx.prevData[0] as number);
-		const bv =
-			data[1] != null && data[1].length > 0
-				? (data[1].at(-1) as number)
-				: (ctx.prevData[1] as number);
-		return [av + bv];
-	});
-	return g;
-}
-
-function collect(view: {
-	frame: { subscribe(s: (msgs: readonly (readonly [symbol, unknown?])[]) => void): () => void };
-}): { frames: LayoutFrame[]; off: () => void } {
-	const frames: LayoutFrame[] = [];
-	const off = view.frame.subscribe((msgs) => {
-		for (const m of msgs) {
-			if (m[0] === DATA) frames.push(m[1] as LayoutFrame);
-		}
-	});
-	return { frames, off };
-}
-
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-
-describe("topologyView", () => {
-	it("emits an initial frame on subscribe (push-on-subscribe)", () => {
-		const target = makeTarget();
-		const view = topologyView({ graph: target });
-		const { frames, off } = collect(view);
-
-		expect(frames.length).toBeGreaterThan(0);
-		const initial = frames[0]!;
-		// Target has 3 nodes: a, b, c → 3 boxes laid out.
-		expect(initial.boxes).toHaveLength(3);
-		const ids = initial.boxes.map((b) => b.id).sort();
-		expect(ids).toEqual(["a", "b", "c"]);
-		// Initial frame has no `changes` (consumer seeded from describe).
-		expect(initial.changes).toEqual([]);
-
-		off();
-	});
-
-	it("recomputes layout when a 4th node is added (topology change)", () => {
-		const target = makeTarget();
-		const view = topologyView({ graph: target });
-		const { frames, off } = collect(view);
-
-		const initialCount = frames[0]!.boxes.length;
-		expect(initialCount).toBe(3);
-
-		// Reset accumulator, then add a new node.
-		frames.length = 0;
-		const d = node<number>([], { name: "d", initial: 0 });
-		target.add(d, { name: "d" });
-
-		// Some frames were emitted; at least one should reflect the new topology.
-		expect(frames.length).toBeGreaterThan(0);
-		const last = frames[frames.length - 1]!;
-		expect(last.boxes).toHaveLength(4);
-		expect(last.boxes.map((b) => b.id).sort()).toEqual(["a", "b", "c", "d"]);
-		// The wave that delivered the topology change should carry a topology change.
-		const topologyFrame = frames.find((f) =>
-			f.changes.some((c) => c.type === "node-added" && c.scope === "d"),
-		);
-		expect(topologyFrame).toBeDefined();
-
-		off();
-	});
-
-	it("emits a frame with `changes` populated on data change without recomputing layout", () => {
-		const target = makeTarget();
-		const view = topologyView({ graph: target });
-		const { frames, off } = collect(view);
-
-		const initialBoxes = frames[0]!.boxes;
-		frames.length = 0;
-
-		// Trigger a data change — set "a" to 99.
-		target.set("a", 99);
-
-		// At least one frame should have a `data` change for "a".
-		const dataFrame = frames.find((f) =>
-			f.changes.some((c) => c.type === "data" && c.scope === "a"),
-		);
-		expect(dataFrame).toBeDefined();
-		// Layout boxes are reference-equal — no recomputation on data-only events.
-		expect(dataFrame!.boxes).toBe(initialBoxes);
-
-		off();
-	});
-
-	it("honors a custom `opts.layout` plug-in", () => {
-		const target = makeTarget();
-
-		const customCalls: GraphDescribeOutput[] = [];
-		const customLayout: LayoutFn = (spec) => {
-			customCalls.push(spec);
-			const ids = Object.keys(spec.nodes).sort();
-			return {
-				boxes: ids.map((id, i) => ({ id, x: i * 10, y: 0, w: 5, h: 1 })),
-				edges: [],
-			};
-		};
-
-		const view = topologyView({ graph: target, layout: customLayout });
-		const { frames, off } = collect(view);
-
-		// Custom layout was called at least once (seed).
-		expect(customCalls.length).toBeGreaterThan(0);
-		const initial = frames[0]!;
-		// Custom layout's boxes are at x = 0, 10, 20.
-		expect(initial.boxes.map((b) => b.x).sort((a, b) => a - b)).toEqual([0, 10, 20]);
-		expect(initial.edges).toEqual([]);
-
-		off();
-	});
-
-	it("layoutFrameToSvg round-trip — every box id appears in output", () => {
-		const target = makeTarget();
-		const view = topologyView({ graph: target });
-		const { frames, off } = collect(view);
-
-		const initial = frames[0]!;
-		const svg = layoutFrameToSvg(initial);
-		expect(svg.startsWith("<svg")).toBe(true);
-		expect(svg.endsWith("</svg>")).toBe(true);
-		for (const b of initial.boxes) {
-			expect(svg).toContain(`data-id="${b.id}"`);
-		}
-		for (const e of initial.edges) {
-			expect(svg).toContain(`data-from="${e.from}"`);
-			expect(svg).toContain(`data-to="${e.to}"`);
-		}
-
-		off();
-	});
-
-	// /qa F-5: target.destroy() degrades gracefully (empty layout, no crash).
-	it("/qa F-5: target.destroy() yields a degraded empty-layout frame without crashing", () => {
-		const target = makeTarget();
-		const view = topologyView({ graph: target });
-		const { frames, off } = collect(view);
-
-		const initial = frames[0]!;
-		expect(initial.boxes.length).toBeGreaterThan(0);
-
-		// Destroy the target — subsequent frames (if any fire) should reflect
-		// the empty layout rather than throw or report stale topology.
-		target.destroy();
-
-		// The view itself is still alive; the frame node continues to settle on
-		// any further activations. Reading the latest frame after teardown
-		// should not crash.
-		const latest = view.frame.cache as LayoutFrame | undefined;
-		expect(latest).toBeDefined();
-		// The view's layout fn was last called pre-destroy; the seeded frame
-		// is still readable. Subsequent computations on the destroyed target
-		// would short-circuit to empty boxes/edges (no crash).
-		off();
-	});
-
-	// /qa F-23: data-only wave — layout settles RESOLVED but changeset emits
-	// DATA. The frame derived must emit a frame with `changes` populated and
-	// the same boxes/edges (no recompute).
-	it("/qa F-23: data-only wave emits a frame with changes populated and prior layout", () => {
-		const target = makeTarget();
-		const view = topologyView({ graph: target });
-		const { frames, off } = collect(view);
-
-		expect(frames.length).toBeGreaterThan(0);
-		const initialBoxes = frames[0]!.boxes;
-		const initialEdges = frames[0]!.edges;
-
-		// Drive a data event on `a` — no topology change, layout should not
-		// recompute. The frame derived's `changes` field should reflect the
-		// data event.
-		frames.length = 0;
-		target.set("a", 5);
-
-		// Find the data-only frame. The changes array should include at least
-		// one `data` GraphChange.
-		const dataFrame = frames.find((f) => f.changes.some((c) => c.type === "data"));
-		expect(dataFrame).toBeDefined();
-		// boxes / edges arrays are reused across data-only waves (no recompute).
-		expect(dataFrame!.boxes).toEqual(initialBoxes);
-		expect(dataFrame!.edges).toEqual(initialEdges);
-		off();
-	});
-
-	// /qa F-24: edge attribution — fromPath / fromDepIndex on derived nodes.
-	it("/qa F-24: data events on derived nodes attribute fromPath + fromDepIndex via inspector", () => {
-		const target = new Graph("target", { inspectorEnabled: true });
-		const a = node<number>([], { name: "a", initial: 1, equals: () => false });
-		const b = node<number>([], { name: "b", initial: 2, equals: () => false });
-		target.add(a, { name: "a" });
-		target.add(b, { name: "b" });
-		target.derived("c", ["a", "b"], (data, ctx) => {
-			const av =
-				data[0] != null && data[0].length > 0
-					? (data[0].at(-1) as number)
-					: (ctx.prevData[0] as number);
-			const bv =
-				data[1] != null && data[1].length > 0
-					? (data[1].at(-1) as number)
-					: (ctx.prevData[1] as number);
-			return [av + bv];
-		});
-
-		const changeset = target.observe({ changeset: true });
-		const events: import("../../graph/changeset.js").GraphChange[] = [];
-		const off = changeset.subscribe((msgs) => {
-			for (const m of msgs) {
-				if (m[0] === DATA) events.push(m[1] as import("../../graph/changeset.js").GraphChange);
-			}
-		});
-		// Activate `c` so the inspector hook fires on dep messages.
-		target.resolve("c").subscribe(() => {});
-		events.length = 0;
-
-		target.set("b", 9);
-
-		// Find the data event on `c` driven by `b`.
-		const onC = events.filter(
-			(e): e is import("../../graph/changeset.js").GraphChange & { type: "data" } =>
-				e.type === "data" && e.scope === "c",
-		);
-		expect(onC.length).toBeGreaterThan(0);
-		// fromPath should be `b` (upstream emitter), fromDepIndex should be 1
-		// (b is the second dep of c).
-		const last = onC.at(-1)!;
-		expect(last.fromPath).toBe("b");
-		expect(last.fromDepIndex).toBe(1);
-		off();
-		target.destroy();
-	});
-});
diff --git a/src/base/composition/backpressure.ts b/src/base/composition/backpressure.ts
deleted file mode 100644
index e36cdf5f..00000000
--- a/src/base/composition/backpressure.ts
+++ /dev/null
@@ -1,119 +0,0 @@
-/**
- * Watermark-based backpressure controller — reactive PAUSE/RESUME flow control.
- *
- * Purely synchronous, event-driven. No timers, no polling, no Promises.
- * Each controller instance uses a unique lockId so multiple controllers
- * on the same upstream node do not collide.
- *
- * @module
- */
-
-import { type Messages, PAUSE, RESUME } from "@graphrefly/pure-ts/core";
-
-// ---------------------------------------------------------------------------
-// Types
-// ---------------------------------------------------------------------------
-
-export type WatermarkOptions = {
-	/** Pending count at which PAUSE is sent upstream. */
-	highWaterMark: number;
-	/** Pending count at which RESUME is sent upstream (after being paused). */
-	lowWaterMark: number;
-};
-
-export type WatermarkController = {
-	/** Call when a DATA message is buffered/enqueued. Returns `true` if PAUSE was just sent. */
-	onEnqueue(): boolean;
-	/** Call when a buffered item is consumed. Returns `true` if RESUME was just sent. */
-	onDequeue(): boolean;
-	/** Current un-consumed item count. */
-	readonly pending: number;
-	/** Whether upstream is currently paused by this controller. */
-	readonly paused: boolean;
-	/** Dispose: if paused, sends RESUME to unblock upstream. */
-	dispose(): void;
-};
-
-// ---------------------------------------------------------------------------
-// Factory
-// ---------------------------------------------------------------------------
-
-let nextLockId = 0;
-
-/**
- * Creates a watermark-based backpressure controller.
- *
- * @param sendUp - Callback that delivers messages upstream (typically `handle.up`).
- * @param opts - High/low watermark thresholds (item counts).
- * @returns A {@link WatermarkController}.
- *
- * @example
- * ```ts
- * const handle = graph.observe("fast-source");
- * const wm = createWatermarkController(
- *   (msgs) => handle.up(msgs),
- *   { highWaterMark: 64, lowWaterMark: 16 },
- * );
- *
- * // In sink callback:
- * handle.subscribe((msgs) => {
- *   for (const msg of msgs) {
- *     if (msg[0] === DATA) {
- *       buffer.push(msg[1]);
- *       wm.onEnqueue();
- *     }
- *   }
- * });
- *
- * // When consumer drains:
- * const item = buffer.shift();
- * wm.onDequeue();
- * ```
- *
- * @category extra
- */
-export function createWatermarkController(
-	sendUp: (messages: Messages) => void,
-	opts: WatermarkOptions,
-): WatermarkController {
-	if (opts.highWaterMark < 1) throw new RangeError("highWaterMark must be >= 1");
-	if (opts.lowWaterMark < 0) throw new RangeError("lowWaterMark must be >= 0");
-	if (opts.lowWaterMark >= opts.highWaterMark)
-		throw new RangeError("lowWaterMark must be < highWaterMark");
-	const lockId = Symbol(`bp-${++nextLockId}`);
-	let pending = 0;
-	let paused = false;
-
-	return {
-		onEnqueue(): boolean {
-			pending += 1;
-			if (!paused && pending >= opts.highWaterMark) {
-				paused = true;
-				sendUp([[PAUSE, lockId]]);
-				return true;
-			}
-			return false;
-		},
-		onDequeue(): boolean {
-			if (pending > 0) pending -= 1;
-			if (paused && pending <= opts.lowWaterMark) {
-				paused = false;
-				sendUp([[RESUME, lockId]]);
-				return true;
-			}
-			return false;
-		},
-		get pending() {
-			return pending;
-		},
-		get paused() {
-			return paused;
-		},
-		dispose() {
-			if (paused) {
-				paused = false;
-				sendUp([[RESUME, lockId]]);
-			}
-		},
-	};
-}
diff --git a/src/base/composition/distill.ts b/src/base/composition/distill.ts
deleted file mode 100644
index 383b8275..00000000
--- a/src/base/composition/distill.ts
+++ /dev/null
@@ -1,241 +0,0 @@
-/**
- * Budget-constrained reactive memory composition (roadmap §3.2b).
- *
- * Moved to base/composition/distill.ts during cleave A2.
- */
-
-import { batch, factoryTag, type Node, node } from "@graphrefly/pure-ts/core";
-import {
-	fromAny,
-	type NodeInput,
-	type ReactiveMapBundle,
-	type ReactiveMapOptions,
-	reactiveMap,
-	switchMap,
-	withLatestFrom,
-} from "@graphrefly/pure-ts/extra";
-import { forEach } from "../sources/async.js";
-
-function isNodeLike<T>(value: unknown): value is Node<T> {
-	return (
-		typeof value === "object" &&
-		value !== null &&
-		"cache" in (value as Node<T>) &&
-		typeof (value as Node<T>).subscribe === "function"
-	);
-}
-
-export type Extraction<TMem> = {
-	upsert: Array<{ key: string; value: TMem }>;
-	remove?: string[];
-};
-
-export type DistillOptions<TMem> = {
-	score: (mem: TMem, context: unknown) => number;
-	cost: (mem: TMem) => number;
-	budget?: number;
-	evict?: (key: string, mem: TMem) => boolean | Node<boolean>;
-	consolidate?: (entries: ReadonlyMap<string, TMem>) => NodeInput<Extraction<TMem>>;
-	consolidateTrigger?: NodeInput<unknown>;
-	context?: NodeInput<unknown>;
-	mapOptions?: ReactiveMapOptions<string, TMem>;
-};
-
-export type DistillBundle<TMem> = {
-	store: ReactiveMapBundle<string, TMem>;
-	compact: Node<Array<{ key: string; value: TMem; score: number }>>;
-	size: Node<number>;
-};
-
-function keepalive(node: Node): void {
-	node.subscribe(() => undefined);
-}
-
-/**
- * Defensive snapshot → ReadonlyMap coercion (D2 /qa lock, Tier 9.1).
- *
- * `ReactiveMapBundle.entries` always emits a real `Map` on the live emit
- * path. The non-Map case happens on snapshot **restore**: the default
- * `JsonGraphCodec` serializes a `Map` to `null`/`{}`/`[]` depending on the
- * codec configuration, and `Graph.restore` writes that decoded value back
- * to the cache. A naive `(snapshot as ReadonlyMap) ?? new Map()` would
- * pass a plain object through and then `.entries()` / `.size` access would
- * silently yield wrong results (or throw). The runtime `instanceof Map`
- * check below restores the safety net the previous `mapFromSnapshot` helper
- * provided before its initial deletion in Tier 10.1.
- */
-function mapFromSnapshot<TMem>(snapshot: unknown): ReadonlyMap<string, TMem> {
-	if (snapshot instanceof Map) return snapshot as ReadonlyMap<string, TMem>;
-	return new Map<string, TMem>();
-}
-
-function applyExtraction<TMem>(
-	store: ReactiveMapBundle<string, TMem>,
-	extraction: Extraction<TMem>,
-): void {
-	if (!Array.isArray(extraction.upsert)) {
-		throw new TypeError("distill extraction requires upsert: Array<{ key, value }>");
-	}
-	batch(() => {
-		for (const { key, value } of extraction.upsert) {
-			store.set(key, value);
-		}
-		for (const key of extraction.remove ?? []) {
-			store.delete(key);
-		}
-	});
-}
-
-/**
- * Budget-constrained reactive memory composition.
- *
- * **Tier 1.5.4 (Session A.5 lock, 2026-04-27):** `extractFn` receives the
- * source and existing-store as `Node`s. Distill calls `extractFn` ONCE at
- * wiring time and consumes the returned stream of extractions. The user
- * controls reactive composition — wrap with `switchMap` for cancel-on-new-input,
- * `mergeMap` for parallel, `derived` for sync transforms. See COMPOSITION-GUIDE
- * §40 for the recipe.
- */
-export function distill<TRaw, TMem>(
-	source: NodeInput<TRaw>,
-	extractFn: (
-		raw: Node<TRaw>,
-		existing: Node<ReadonlyMap<string, TMem>>,
-	) => NodeInput<Extraction<TMem>>,
-	opts: DistillOptions<TMem>,
-): DistillBundle<TMem> {
-	const sourceNode = fromAny(source);
-	const store = reactiveMap<string, TMem>(opts.mapOptions ?? {});
-	const budget = opts.budget ?? 2000;
-	const hasContext = opts.context !== undefined && opts.context !== null;
-	const contextNode = hasContext ? fromAny(opts.context) : node<unknown>([], { initial: null });
-
-	// `latestStore` (formerly a §28 closure-mirror) is no longer needed —
-	// Phase 10.5 (`withLatestFrom` flipped to `partial: false`) fixed the
-	// W1 initial-pair drop. `consolidate` now uses
-	// `withLatestFrom(trigger, store.entries)` below to pair each trigger
-	// with the latest store snapshot via a real reactive edge (visible in
-	// `describe()`). The `mapFromSnapshot` transform runs inside the
-	// switchMap fn body.
-
-	// Tier 1.5.4: one-shot wire. User's `extractFn` returns the reactive
-	// extraction stream — distill just `forEach`s and applies. No internal
-	// switchMap; user picks the cancellation / queueing semantics.
-	const extractionStream = fromAny(
-		extractFn(sourceNode, store.entries as Node<ReadonlyMap<string, TMem>>),
-	);
-	forEach(extractionStream, (extraction) => {
-		applyExtraction(store, extraction);
-	});
-
-	if (opts.evict) {
-		// Track active verdict-node subscriptions so we can react to Node<boolean> changes.
-		const verdictUnsubs = new Map<string, () => void>();
-
-		const evictionKeys = node<string[]>(
-			[store.entries],
-			(batchData, actions, ctx) => {
-				const batch0 = batchData[0];
-				const snapshot = batch0 != null && batch0.length > 0 ? batch0.at(-1) : ctx.prevData[0];
-				const out: string[] = [];
-				const entries = mapFromSnapshot<TMem>(snapshot);
-				// Clean up verdict subscriptions for removed keys.
-				for (const key of verdictUnsubs.keys()) {
-					if (!entries.has(key)) {
-						verdictUnsubs.get(key)!();
-						verdictUnsubs.delete(key);
-					}
-				}
-				for (const [key, mem] of entries) {
-					const verdict = opts.evict!(key, mem);
-					if (isNodeLike<boolean>(verdict)) {
-						// Subscribe if not already — push-on-subscribe fires with
-						// the verdict's current value on first subscribe, so an
-						// already-true verdict deletes via the callback without
-						// needing a `verdict.cache` read (closes P3 audit #3).
-						// Future transitions to `true` flow through the same path.
-						if (!verdictUnsubs.has(key)) {
-							const unsub = forEach(verdict, (val) => {
-								if (val === true && store.has(key)) {
-									store.delete(key);
-								}
-							});
-							verdictUnsubs.set(key, unsub);
-						}
-						continue;
-					}
-					if (typeof verdict === "boolean") {
-						if (verdict) out.push(key);
-						continue;
-					}
-					throw new TypeError("distill evict() must return boolean or Node<boolean>");
-				}
-				actions.emit(out);
-			},
-			{ describeKind: "derived" },
-		);
-		forEach(evictionKeys, (keys) => {
-			for (const key of keys) store.delete(key);
-		});
-	}
-
-	const hasConsolidateTrigger =
-		opts.consolidateTrigger !== undefined && opts.consolidateTrigger !== null;
-	if (opts.consolidate && hasConsolidateTrigger) {
-		const consolidateTriggerNode = fromAny(opts.consolidateTrigger);
-		const consolidatePaired = withLatestFrom(
-			consolidateTriggerNode,
-			store.entries as Node<unknown>,
-		);
-		const consolidationStream = switchMap(consolidatePaired, ([, entries]) =>
-			opts.consolidate!(mapFromSnapshot<TMem>(entries)),
-		);
-		forEach(consolidationStream, (extraction) => {
-			applyExtraction(store, extraction);
-		});
-	}
-
-	const compact = node<Array<{ key: string; value: TMem; score: number }>>(
-		[store.entries, contextNode],
-		(batchData, actions, ctx) => {
-			const data = batchData.map((batch, i) =>
-				batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-			);
-			const snapshot = data[0];
-			const context = data[1];
-			const map = mapFromSnapshot<TMem>(snapshot);
-			const entries = [...map.entries()].map(([key, value]) => ({
-				key,
-				value,
-				score: opts.score(value, context),
-				cost: opts.cost(value),
-			}));
-			entries.sort((a, b) => b.score - a.score);
-
-			const packed: Array<{ key: string; value: TMem; score: number }> = [];
-			let remaining = budget;
-			for (const item of entries) {
-				if (item.cost <= remaining) {
-					packed.push({ key: item.key, value: item.value, score: item.score });
-					remaining -= item.cost;
-				}
-			}
-			actions.emit(packed);
-		},
-		{ describeKind: "derived", meta: { ...factoryTag("distill", { budget }) } },
-	);
-
-	const size = node<number>(
-		[store.entries],
-		(batchData, actions, ctx) => {
-			const batch0 = batchData[0];
-			const snapshot = batch0 != null && batch0.length > 0 ? batch0.at(-1) : ctx.prevData[0];
-			actions.emit(mapFromSnapshot<TMem>(snapshot).size);
-		},
-		{ describeKind: "derived" },
-	);
-	keepalive(compact);
-	keepalive(size);
-
-	return { store, compact, size };
-}
diff --git a/src/base/composition/external-register.ts b/src/base/composition/external-register.ts
deleted file mode 100644
index a5275487..00000000
--- a/src/base/composition/external-register.ts
+++ /dev/null
@@ -1,294 +0,0 @@
-/**
- * External-register helpers — the common `register({emit, error, complete})`
- * contract shared by webhook, MCP, syslog, StatsD, OTel and other callback-
- * based integrations. Absorbs the `active` flag that every such adapter needs
- * to guard against emits after teardown (§5.10 boundary pattern).
- *
- * Two shapes:
- *
- * - {@link externalProducer} — single channel. Lazy activation: the register
- *   fn runs when the node gains its first subscriber; its returned cleanup
- *   runs on deactivation.
- *
- * - {@link externalBundle} — multiple named channels. Eager activation: the
- *   register fn runs at bundle construction time so externally-owned servers
- *   (HTTP endpoints, UDP sockets) start accepting traffic immediately. A
- *   shared refcount fires the returned cleanup once every channel has fully
- *   torn down.
- */
-
-import {
-	batch,
-	COMPLETE,
-	DATA,
-	ERROR,
-	type Node,
-	type NodeOptions,
-	node,
-} from "@graphrefly/pure-ts/core";
-
-type ExtraOpts = Omit<NodeOptions<unknown>, "describeKind">;
-
-function sourceOpts<T>(opts?: ExtraOpts): NodeOptions<T> {
-	return { describeKind: "producer", ...opts } as NodeOptions<T>;
-}
-
-/**
- * Standard emit-triad passed to a single-channel external registrar.
- *
- * Post-teardown calls on any of these are automatically no-ops — the
- * registrar does not need its own guard flag.
- *
- * @category extra
- */
-export type EmitTriad<T> = {
-	/** Emit a value as `DATA`. */
-	emit: (value: T) => void;
-	/** Terminate with `ERROR`. Subsequent `emit` / `error` / `complete` are ignored. */
-	error: (err: unknown) => void;
-	/** Terminate with `COMPLETE`. Subsequent `emit` / `error` / `complete` are ignored. */
-	complete: () => void;
-};
-
-/**
- * Multi-channel emit bundle. Each declared channel name maps to an emit fn;
- * `error` and `complete` terminate every channel atomically.
- *
- * @category extra
- */
-export type BundleTriad<TChannels extends Record<string, unknown>> = {
-	[K in keyof TChannels]: (value: TChannels[K]) => void;
-} & {
-	/** Terminate every channel with `ERROR`. */
-	error: (err: unknown) => void;
-	/** Terminate every channel with `COMPLETE`. */
-	complete: () => void;
-};
-
-/**
- * Generic external registrator contract. The caller installs handlers into a
- * third-party library / framework / server and optionally returns a cleanup
- * callback. Returning `undefined` / `void` is equivalent to a no-op cleanup.
- *
- * @category extra
- */
-export type ExternalRegister<H> = (handlers: H) => (() => void) | undefined;
-
-/**
- * Wraps a callback-style external integration as a reactive source.
- *
- * The registrar installs the supplied `emit` / `error` / `complete` handlers
- * into the external SDK; post-teardown calls are silently dropped. Synchronous
- * exceptions thrown by the registrar surface as terminal `ERROR`.
- *
- * @param register - Installs handlers. Optionally returns a cleanup fn.
- * @param opts - Node options (name, equals, resubscribable, ...).
- *
- * @example
- * ```ts
- * import { externalProducer } from "@graphrefly/graphrefly";
- *
- * const hook$ = externalProducer<Payload>(({ emit, error }) => {
- *   const id = transport.onMessage((raw) => {
- *     try { emit(parse(raw)); } catch (e) { error(e); }
- *   });
- *   return () => transport.off(id);
- * });
- * ```
- *
- * @category extra
- */
-export function externalProducer<T = unknown>(
-	register: ExternalRegister<EmitTriad<T>>,
-	opts?: ExtraOpts,
-): Node<T> {
-	return node<T>((_data, a) => {
-		let active = true;
-		const triad: EmitTriad<T> = {
-			emit(value) {
-				if (!active) return;
-				a.emit(value);
-			},
-			error(err) {
-				if (!active) return;
-				active = false;
-				a.down([[ERROR, err]]);
-			},
-			complete() {
-				if (!active) return;
-				active = false;
-				a.down([[COMPLETE]]);
-			},
-		};
-		let cleanup: (() => void) | undefined;
-		try {
-			const ret = register(triad);
-			cleanup = typeof ret === "function" ? ret : undefined;
-		} catch (err) {
-			triad.error(err);
-			return {
-				onDeactivation: () => {
-					active = false;
-				},
-			};
-		}
-		return {
-			onDeactivation: () => {
-				active = false;
-				try {
-					cleanup?.();
-				} catch {
-					/* registrar cleanup failure is not a reactive signal */
-				}
-			},
-		};
-	}, sourceOpts(opts));
-}
-
-/**
- * Options for {@link externalBundle}.
- *
- * @category extra
- */
-export type ExternalBundleOptions<TChannels extends Record<string, unknown>> = {
-	/** Base name prefix for channel nodes; each node is named `${name}::${channel}`. */
-	name?: string;
-	/** Per-channel node options (equals, resubscribable, ...). */
-	channelOpts?: { [K in keyof TChannels]?: ExtraOpts };
-};
-
-/**
- * Multi-channel variant — one `Node<T>` per named channel, sharing a single
- * registrar. Activation is eager: the registrar runs at construction time so
- * externally-owned servers (HTTP, UDP, queue consumers) can start accepting
- * traffic immediately. The returned cleanup fires once every channel has been
- * subscribed and then fully deactivated (refcount-on-teardown).
- *
- * Any call to `error` or `complete` propagates to every channel atomically.
- *
- * @param register - Installs handlers for each channel plus shared error/complete.
- * @param channels - Ordered channel names; determines the returned object shape.
- * @param opts - Optional name prefix and per-channel node options.
- *
- * @example
- * ```ts
- * import { externalBundle } from "@graphrefly/graphrefly";
- *
- * type OTelChannels = { traces: Span; metrics: Metric; logs: LogRec };
- * const otel = externalBundle<OTelChannels>(
- *   ({ traces, metrics, logs, error }) => {
- *     app.post("/v1/traces",  (req, res) => { traces(req.body);  res.sendStatus(200); });
- *     app.post("/v1/metrics", (req, res) => { metrics(req.body); res.sendStatus(200); });
- *     app.post("/v1/logs",    (req, res) => { logs(req.body);    res.sendStatus(200); });
- *     server.on("error", error);
- *     return () => server.close();
- *   },
- *   ["traces", "metrics", "logs"],
- * );
- * otel.traces.subscribe(...);
- * ```
- *
- * @category extra
- */
-export function externalBundle<TChannels extends Record<string, unknown>>(
-	register: ExternalRegister<BundleTriad<TChannels>>,
-	channels: readonly (keyof TChannels & string)[],
-	opts?: ExternalBundleOptions<TChannels>,
-): { [K in keyof TChannels]: Node<TChannels[K]> } & { dispose(): void } {
-	let active = true;
-	let cleanup: (() => void) | undefined;
-	let activatedCount = 0;
-	let teardownCount = 0;
-
-	const nodes = {} as { [K in keyof TChannels]: Node<TChannels[K]> };
-	const channelNodes: Array<Node<unknown>> = [];
-
-	const finishCleanup = () => {
-		const fn = cleanup;
-		cleanup = undefined;
-		try {
-			fn?.();
-		} catch {
-			/* registrar cleanup failure is not a reactive signal */
-		}
-	};
-
-	for (const ch of channels) {
-		const name = opts?.name ? `${opts.name}::${ch}` : ch;
-		const chOpts = opts?.channelOpts?.[ch];
-		const n = node<TChannels[typeof ch]>(
-			(_data, _a) => {
-				activatedCount++;
-				return {
-					onDeactivation: () => {
-						teardownCount++;
-						// Cleanup fires once every channel has activated at least once
-						// and then deactivated. Channels that never subscribe do not
-						// gate cleanup — use the explicit `.dispose()` method for
-						// unconditional teardown.
-						if (
-							activatedCount > 0 &&
-							teardownCount >= activatedCount &&
-							teardownCount >= channels.length
-						) {
-							finishCleanup();
-						}
-					},
-				};
-			},
-			sourceOpts({ ...chOpts, name }),
-		);
-		nodes[ch as keyof TChannels] = n as Node<TChannels[typeof ch]>;
-		channelNodes.push(n as Node<unknown>);
-	}
-
-	const bundle = {} as BundleTriad<TChannels>;
-	for (const ch of channels) {
-		(bundle as Record<string, unknown>)[ch] = (value: unknown) => {
-			if (!active) return;
-			(nodes[ch as keyof TChannels] as Node<unknown>).down([[DATA, value]]);
-		};
-	}
-	bundle.error = (err: unknown) => {
-		if (!active) return;
-		active = false;
-		batch(() => {
-			for (const n of channelNodes) n.down([[ERROR, err]]);
-		});
-		finishCleanup();
-	};
-	bundle.complete = () => {
-		if (!active) return;
-		active = false;
-		batch(() => {
-			for (const n of channelNodes) n.down([[COMPLETE]]);
-		});
-		finishCleanup();
-	};
-
-	// Eager activation — register fires at construction time so externally-
-	// owned servers can start accepting traffic immediately. Synchronous throws
-	// propagate to the caller (no subscribers exist yet, so there is no
-	// reactive ERROR path to deliver to). This matches the existing `fromOTel`
-	// contract.
-	const ret = register(bundle);
-	cleanup = typeof ret === "function" ? ret : undefined;
-
-	const dispose = () => {
-		if (!active) return;
-		active = false;
-		// Fire COMPLETE on every channel so downstream sees a clean terminal.
-		batch(() => {
-			for (const n of channelNodes) {
-				try {
-					n.down([[COMPLETE]]);
-				} catch {
-					/* terminal filter / re-entrance — swallow */
-				}
-			}
-		});
-		finishCleanup();
-	};
-
-	return Object.assign(nodes, { dispose });
-}
diff --git a/src/base/composition/index.ts b/src/base/composition/index.ts
deleted file mode 100644
index d311f37a..00000000
--- a/src/base/composition/index.ts
+++ /dev/null
@@ -1,15 +0,0 @@
-/**
- * Base composition — domain-agnostic composition helpers.
- *
- * @module
- */
-
-export * from "./backpressure.js";
-export * from "./distill.js";
-export * from "./external-register.js";
-export * from "./materialize.js";
-export * from "./observable.js";
-export * from "./pubsub.js";
-export * from "./single-from-any.js";
-export * from "./verifiable.js";
-// topology-diff is substrate (pure-ts); consumers import from @graphrefly/pure-ts/extra
diff --git a/src/base/composition/materialize.ts b/src/base/composition/materialize.ts
deleted file mode 100644
index 7dc7c38e..00000000
--- a/src/base/composition/materialize.ts
+++ /dev/null
@@ -1,336 +0,0 @@
-/**
- * Phase 13.C — `selector` + `materialize` composers (DS-13.C / G2 lock C).
- *
- * Two paired primitives for dynamic-mount routing:
- *
- * - {@link selector} — projects an input value to a routing key, deduped.
- *   Equivalent to `map + distinctUntilChanged`, but the dedup is the
- *   semantic point: the key changes ONLY when the routed-to slot should
- *   change. Fires `materialize` re-mounts efficiently.
- *
- * - {@link materialize} — given a reactive `key` and a reactive map of
- *   `key → factory` thunks, mounts the matching factory's Graph under
- *   `parent` at a stable slot name. When `key` changes, unmounts the old
- *   slot and mounts the new factory's output. When `factories` mutates but
- *   `key` stays the same, the current slot continues to run on the OLD
- *   factory ("current sessions complete on old factory; new sessions use
- *   new factory" — full hot-swap correctness deferred to G10, parked).
- *
- * Reusable beyond the agent layer:
- * - `harnessLoop` strategy routing — the strategy node IS a `selector`.
- * - `pipelineGraph` dynamic stage selection.
- * - `refineLoop` strategy swap.
- * - Phase 13.I `spawnable()` mounts agent slots via `materialize`.
- */
-
-import {
-	COMPLETE,
-	DATA,
-	ERROR,
-	factoryTag,
-	type Node,
-	type NodeOptions,
-	node,
-	RESOLVED,
-} from "@graphrefly/pure-ts/core";
-import type { Graph } from "@graphrefly/pure-ts/graph";
-
-/** Options for operator nodes: NodeOptions without `describeKind` (set internally). */
-export type ExtraOpts = Omit<NodeOptions<unknown>, "describeKind">;
-
-function operatorOpts<T = unknown>(opts?: ExtraOpts): NodeOptions<T> {
-	return { describeKind: "derived", ...opts } as NodeOptions<T>;
-}
-
-// ---------------------------------------------------------------------------
-// selector
-// ---------------------------------------------------------------------------
-
-/** Options for {@link selector}. */
-export type SelectorOpts<TKey> = ExtraOpts & {
-	/**
-	 * Equality comparator for the projected key. Defaults to {@link Object.is}.
-	 * Used to suppress re-emits when the input changes but the projected key
-	 * does not — this is the load-bearing behavior that lets downstream
-	 * `materialize` skip unnecessary unmount/remount cycles.
-	 */
-	equals?: (a: TKey, b: TKey) => boolean;
-};
-
-/**
- * Projects each upstream value to a routing key, deduped on the key. The
- * output node emits a key only when the projected key actually changes —
- * pairs cleanly with {@link materialize}, which re-mounts only on key
- * change.
- *
- * **Differs from `map`:** `map(input, fn)` fires on every upstream wave
- * regardless of output value. `selector(input, fn)` fires only when the
- * projected key CHANGES (under `equals`), so downstream re-mount logic is
- * stable.
- *
- * @param input - Upstream node carrying the value to project.
- * @param fn - Synchronous projection function.
- * @param opts - Optional {@link SelectorOpts}.
- * @returns `Node<TKey>` carrying the latest projected key (deduped).
- *
- * @example
- * ```ts
- * import { selector, materialize, state } from "@graphrefly/graphrefly";
- *
- * type Request = { kind: "research" | "summarize" | "code"; payload: unknown };
- * const requestNode = state<Request>({ kind: "research", payload: {} });
- *
- * const presetId = selector(requestNode, (req) => req.kind);
- * // presetId is `Node<"research" | "summarize" | "code">`, deduped.
- * // Downstream materialize re-mounts ONLY when the kind axis changes.
- * ```
- *
- * @category extra
- */
-export function selector<TIn, TKey>(
-	input: Node<TIn>,
-	fn: (input: TIn) => TKey,
-	opts?: SelectorOpts<TKey>,
-): Node<TKey> {
-	const equals = opts?.equals ?? Object.is;
-	// Lock 6.D (Phase 13.6.B): clear prev/hasPrev on deactivation so a
-	// resubscribable selector doesn't dedupe the next cycle's first
-	// projected key against a stale prev from the prior cycle.
-	let cleanup: { onDeactivation: () => void } | undefined;
-	return node<TKey>(
-		[input as Node],
-		(data, a, ctx) => {
-			if (cleanup === undefined) {
-				const store = ctx.store;
-				cleanup = {
-					onDeactivation: () => {
-						delete store.prev;
-						delete store.hasPrev;
-					},
-				};
-			}
-			const batch0 = data[0];
-			if (batch0 == null || batch0.length === 0) {
-				a.down([[RESOLVED]]);
-				return cleanup;
-			}
-			// A11 (QA fix 2026-05-01): pre-pass — compute every projected
-			// key + dedup decision FIRST, surface any user `equals` throw
-			// as ERROR before any DATA goes out. The previous in-loop
-			// emission interleaved partial DATA with ERROR mid-batch; that
-			// left subscribers inconsistent (some had read the early DATA,
-			// some treated ERROR as "discard everything since RESOLVED")
-			// and left `ctx.store.prev` mutated to the last successful key,
-			// which made selector "stuck" until the next throw-free batch.
-			const toEmit: TKey[] = [];
-			let prev: TKey | undefined = ctx.store.hasPrev ? (ctx.store.prev as TKey) : undefined;
-			let hasPrev = ctx.store.hasPrev;
-			for (const v of batch0 as TIn[]) {
-				const key = fn(v);
-				if (hasPrev) {
-					let same: boolean;
-					try {
-						same = equals(prev as TKey, key);
-					} catch (err) {
-						// Pre-pass throw — abandon the whole batch (no DATA emits)
-						// and surface ERROR. ctx.store stays at its pre-batch
-						// state so the next batch starts from a known-good prev.
-						a.down([[ERROR, err]]);
-						return;
-					}
-					if (same) continue;
-				}
-				prev = key;
-				hasPrev = true;
-				toEmit.push(key);
-			}
-			if (toEmit.length === 0) {
-				a.down([[RESOLVED]]);
-				return cleanup;
-			}
-			ctx.store.prev = prev as TKey;
-			ctx.store.hasPrev = true;
-			for (const k of toEmit) a.emit(k);
-			return cleanup;
-		},
-		{
-			...operatorOpts(opts),
-			meta: { ...factoryTag("selector"), ...(opts?.meta ?? {}) },
-		},
-	);
-}
-
-// ---------------------------------------------------------------------------
-// materialize
-// ---------------------------------------------------------------------------
-
-/**
- * Factory thunk for a {@link materialize} slot. Called once per mount cycle
- * to mint a fresh `TGraph` instance. The instance is mounted under
- * `parent.mount(slotName, ...)` and unmounted via `parent.remove(slotName)`
- * when `key` next changes.
- *
- * Each invocation MUST return a fresh, never-before-mounted Graph instance —
- * `Graph.mount` rejects re-mounting an instance that is already mounted
- * elsewhere in the tree. Caching factory output is unsafe.
- */
-export type GraphFactory<TGraph extends Graph> = () => TGraph;
-
-/** Options for {@link materialize}. */
-export type MaterializeOpts = ExtraOpts & {
-	/**
-	 * Local mount name on the parent graph. Default `"materialized"`.
-	 *
-	 * Two materialize calls on the SAME parent must use distinct `slotName`
-	 * values, otherwise the second mount throws "mount already exists".
-	 * For a hub mounting many slots (e.g. {@link spawnable}'s preset
-	 * registry), use `slotName: \`preset-\${id}\`` or similar.
-	 */
-	slotName?: string;
-};
-
-/**
- * Reactive dynamic mount: mounts the Graph instance for `key` under
- * `parent.mount(slotName, ...)`, and re-mounts when `key` changes.
- *
- * **Lifecycle.** First DATA on `key` triggers a mount: look up
- * `factories.get(key)`, call the factory thunk, mount the result under
- * `parent`. Each subsequent `key` change unmounts the previous slot and
- * mounts the new one. When this materialize node terminates (subscriber
- * teardown, `COMPLETE` from `key`, `Graph.destroy`), the active slot is
- * unmounted via `parent.remove(slotName)`.
- *
- * **Hot-swap policy (G10 deferred).** When `factories` mutates but `key`
- * stays the same, the currently-mounted slot is NOT re-instantiated —
- * "current sessions complete on old factory; new sessions use new
- * factory." Atomic disconnect/reconnect of an in-flight slot to a new
- * factory is parked under G10 (see `optimizations.md` "G10 atomic
- * registry hot-swap").
- *
- * **Output.** The returned `Node<TGraph>` emits the currently-mounted
- * Graph reference whenever a mount occurs. Consumers can subscribe to
- * watch slot changes, or read `.cache` for the active mount. SENTINEL
- * (no DATA) when no slot is currently mounted (e.g. `key` has no matching
- * factory).
- *
- * **Spec compliance.**
- * - No polling: mount transitions are reactive on `key` / `factories`.
- * - No raw async: factory invocation is synchronous; if a factory needs
- *   async setup, it returns a Graph that handles its own setup internally.
- * - Mount/unmount happens as side-effects inside the reactive `subscribe`
- *   handler — sanctioned per spec §5.9 (Graph topology mutations are
- *   imperative writes at the system boundary, not in-flight reactive
- *   triggers).
- *
- * @param key - Reactive routing key. Re-mounts on each key change (deduped
- *   by reference; pair with {@link selector} for projection-based dedup).
- * @param factories - Reactive map of `key → factory thunk`. Factory map
- *   mutations don't disturb the active slot until the next key change.
- * @param parent - Graph to mount slots under. The `slotName` (default
- *   `"materialized"`) must be free on `parent` at construction time.
- * @param opts - Optional {@link MaterializeOpts}.
- * @returns `Node<TGraph>` carrying the active mount.
- *
- * @example
- * ```ts
- * import { materialize, selector, state, Graph } from "@graphrefly/graphrefly";
- *
- * const parent = new Graph("parent");
- * const factories = state<ReadonlyMap<string, () => Graph>>(new Map([
- *   ["researcher", () => new ResearchAgentGraph()],
- *   ["coder",      () => new CoderAgentGraph()],
- * ]));
- * const key = selector(requestNode, (r) => r.kind);
- * const slot = materialize(key, factories, parent, { slotName: "agent" });
- * // `slot.cache` is the active agent graph; `parent.node("agent::out")`
- * // resolves into whichever agent is currently mounted.
- * ```
- *
- * @category extra
- */
-export function materialize<TKey, TGraph extends Graph>(
-	key: Node<TKey>,
-	factories: Node<ReadonlyMap<TKey, GraphFactory<TGraph>>>,
-	parent: Graph,
-	opts?: MaterializeOpts,
-): Node<TGraph> {
-	const slotName = opts?.slotName ?? "materialized";
-	return node<TGraph>(
-		(_data, a) => {
-			let currentKey: TKey | undefined;
-			let hasCurrentKey = false;
-			let currentGraph: TGraph | undefined;
-			let latestFactories: ReadonlyMap<TKey, GraphFactory<TGraph>> | undefined;
-			let terminated = false;
-
-			function unmountCurrent(): void {
-				if (currentGraph === undefined) return;
-				try {
-					parent.remove(slotName);
-				} catch {
-					// Slot already gone (parent destroyed, or external `remove`).
-				}
-				currentGraph = undefined;
-			}
-
-			// Closure mirror for the factories map. Subscribed FIRST so
-			// `latestFactories` is populated by the time the first `key` DATA
-			// arrives. Same §28 factory-time-seed pattern used elsewhere.
-			const facUnsub = factories.subscribe((msgs) => {
-				if (terminated) return;
-				for (const m of msgs) {
-					if (m[0] === DATA) {
-						latestFactories = m[1] as ReadonlyMap<TKey, GraphFactory<TGraph>>;
-					}
-				}
-			});
-
-			// Primary trigger: key DATA drives mount transitions.
-			const keyUnsub = key.subscribe((msgs) => {
-				if (terminated) return;
-				for (const m of msgs) {
-					if (m[0] === DATA) {
-						const newKey = m[1] as TKey;
-						const keyChanged = !hasCurrentKey || newKey !== currentKey;
-						if (keyChanged) {
-							unmountCurrent();
-							if (latestFactories !== undefined) {
-								const factory = latestFactories.get(newKey);
-								if (factory !== undefined) {
-									currentGraph = factory();
-									parent.mount(slotName, currentGraph);
-								}
-							}
-							currentKey = newKey;
-							hasCurrentKey = true;
-						}
-						if (currentGraph !== undefined) {
-							a.emit(currentGraph);
-						} else {
-							a.down([[RESOLVED]]);
-						}
-					} else if (m[0] === COMPLETE) {
-						terminated = true;
-						a.down([[COMPLETE]]);
-					} else if (m[0] === ERROR) {
-						terminated = true;
-						a.down([m]);
-					}
-				}
-			});
-
-			return {
-				onDeactivation: () => {
-					terminated = true;
-					keyUnsub();
-					facUnsub();
-					unmountCurrent();
-				},
-			};
-		},
-		{
-			...operatorOpts(opts),
-			meta: { ...factoryTag("materialize"), slotName, ...(opts?.meta ?? {}) },
-		},
-	);
-}
diff --git a/src/base/composition/observable.ts b/src/base/composition/observable.ts
deleted file mode 100644
index af0a4b76..00000000
--- a/src/base/composition/observable.ts
+++ /dev/null
@@ -1,199 +0,0 @@
-// ---------------------------------------------------------------------------
-// Observable bridge — reactive interop between GraphReFly nodes and the TC39
-// Observable contract (the well-known `Symbol.observable` / "@@observable"
-// method). **Zero runtime dependency on rxjs**: the returned value is a
-// spec-interop observable that rxjs `from()`, Angular, the NestJS compat
-// layer, and any `Symbol.observable` consumer can adopt. Consumers wanting
-// rxjs operators do `from(toObservable(node))`.
-//
-// Usage:
-//   import { toObservable } from '@graphrefly/graphrefly/base';
-//   import { from } from 'rxjs';
-//   const values$ = from(toObservable(myNode));               // Observable<T>
-//   const msgs$   = from(toObservable(myNode, { raw: true })); // Observable<Messages>
-// ---------------------------------------------------------------------------
-
-import type { Node } from "@graphrefly/pure-ts/core";
-import { COMPLETE, DATA, ERROR, type Messages } from "@graphrefly/pure-ts/core";
-
-/** Observer passed to {@link InteropObservable.subscribe}. */
-export interface InteropObserver<T> {
-	next?(value: T): void;
-	error?(err: unknown): void;
-	complete?(): void;
-	/** rxjs `Subscriber` sets this; we short-circuit delivery when closed. */
-	closed?: boolean;
-}
-
-/** Teardown handle returned by {@link InteropObservable.subscribe}. */
-export interface InteropSubscription {
-	unsubscribe(): void;
-}
-
-/**
- * Minimal TC39 Observable. rxjs `from()` (and any `Symbol.observable`
- * consumer) adopts it at runtime via the well-known interop method attached
- * by {@link toObservable}. Pass the result through `from(...)` to get a
- * pipeable rxjs `Observable`.
- */
-export interface InteropObservable<T> {
-	subscribe(observer: InteropObserver<T> | ((value: T) => void)): InteropSubscription;
-}
-
-/** Options for {@link toObservable}. */
-export type ToObservableOptions = {
-	/**
-	 * When `true`, emit raw `Messages` batches instead of extracted `DATA`
-	 * values. Terminal batches are still emitted as the final `next()` before
-	 * the error/complete signal.
-	 */
-	raw?: boolean;
-};
-
-// Well-known Observable interop key. Mirrors the rxjs / `symbol-observable`
-// resolution (the global `Symbol.observable` when the runtime or a polyfill
-// provides it, otherwise the `"@@observable"` string) so rxjs `from()` adopts
-// our object regardless of polyfill state.
-const OBSERVABLE_KEY: PropertyKey =
-	(typeof Symbol === "function" && (Symbol as unknown as { observable?: symbol }).observable) ||
-	"@@observable";
-
-function normalizeObserver<T>(
-	observer: InteropObserver<T> | ((value: T) => void),
-): InteropObserver<T> {
-	return typeof observer === "function" ? { next: observer } : observer;
-}
-
-function makeInterop<T>(
-	onSubscribe: (observer: InteropObserver<T>) => () => void,
-): InteropObservable<T> {
-	const obs: InteropObservable<T> = {
-		subscribe(rawObserver): InteropSubscription {
-			const observer = normalizeObserver(rawObserver);
-			let closed = false;
-			let teardown: (() => void) | undefined;
-			let teardownPending = false;
-			const runTeardown = (): void => {
-				if (teardown) teardown();
-				else teardownPending = true; // sync push-on-subscribe terminal
-			};
-			// Guarded observer: latch `closed` and auto-unsubscribe the node on
-			// terminal. The prior rxjs-backed impl got this from rxjs's
-			// `Subscriber` (closed flag + teardown-on-terminal); a plain TC39
-			// consumer has no such machinery, so without this a post-terminal
-			// node wave would re-fire next/error/complete and the node
-			// subscription would leak until a manual unsubscribe(). `closed` is
-			// also read by toObservable's per-message loop to short-circuit.
-			const guarded: InteropObserver<T> = {
-				get closed() {
-					return closed;
-				},
-				next(value) {
-					if (!closed) observer.next?.(value);
-				},
-				error(err) {
-					if (closed) return;
-					closed = true;
-					try {
-						observer.error?.(err);
-					} finally {
-						runTeardown();
-					}
-				},
-				complete() {
-					if (closed) return;
-					closed = true;
-					try {
-						observer.complete?.();
-					} finally {
-						runTeardown();
-					}
-				},
-			};
-			teardown = onSubscribe(guarded);
-			if (teardownPending) teardown(); // terminal fired before assignment
-			return {
-				unsubscribe() {
-					if (closed) return;
-					closed = true;
-					teardown?.();
-				},
-			};
-		},
-	};
-	// TC39 interop: `x[Symbol.observable]()` returns the observable itself.
-	(obs as unknown as Record<PropertyKey, unknown>)[OBSERVABLE_KEY] = function (
-		this: InteropObservable<T>,
-	) {
-		return this;
-	};
-	return obs;
-}
-
-/**
- * Bridge a `Node<T>` to a TC39 interop observable (no rxjs dependency).
- *
- * Default mode emits the node's value on each `DATA` message. Maps `ERROR` to
- * `observer.error()` and `COMPLETE` to `observer.complete()`.
- * Protocol-internal signals (DIRTY, RESOLVED, PAUSE, etc.) are skipped.
- *
- * With `{ raw: true }`, emits full `[[Type, Data?], ...]` message batches.
- * The stream terminates on ERROR or COMPLETE (the terminal batch is still
- * emitted as the final `next()` before the error/complete signal).
- *
- * The returned value is a spec-interop observable, **not** a concrete rxjs
- * `Observable`. Wrap with `from(toObservable(node))` for rxjs operators, or
- * use the NestJS compat layer's `toObservable` which returns a real rxjs
- * `Observable`. For graph-level observation, use
- * `toObservable(graph.resolve(path))` or subscribe to `graph.observe()`.
- *
- * Unsubscribing unsubscribes the node.
- */
-export function toObservable<T>(
-	node: Node<T>,
-	options?: ToObservableOptions & { raw?: false },
-): InteropObservable<T>;
-export function toObservable<T>(
-	node: Node<T>,
-	options: ToObservableOptions & { raw: true },
-): InteropObservable<Messages>;
-export function toObservable<T>(
-	node: Node<T>,
-	options?: ToObservableOptions,
-): InteropObservable<T | Messages> {
-	if (options?.raw) {
-		return makeInterop<Messages>((observer) => {
-			return node.subscribe((msgs) => {
-				if (observer.closed) return;
-				observer.next?.(msgs);
-				for (const m of msgs) {
-					if (m[0] === ERROR) {
-						observer.error?.(m[1]);
-						return;
-					}
-					if (m[0] === COMPLETE) {
-						observer.complete?.();
-						return;
-					}
-				}
-			});
-		});
-	}
-
-	return makeInterop<T>((observer) => {
-		return node.subscribe((msgs) => {
-			for (const m of msgs) {
-				if (observer.closed) return;
-				if (m[0] === DATA) {
-					observer.next?.(m[1] as T);
-				} else if (m[0] === ERROR) {
-					observer.error?.(m[1]);
-					return;
-				} else if (m[0] === COMPLETE) {
-					observer.complete?.();
-					return;
-				}
-			}
-		});
-	});
-}
diff --git a/src/base/composition/pubsub.ts b/src/base/composition/pubsub.ts
deleted file mode 100644
index 3959dac9..00000000
--- a/src/base/composition/pubsub.ts
+++ /dev/null
@@ -1,280 +0,0 @@
-/**
- * Lazy per-topic state hub (roadmap §3.2) — lightweight last-value broadcasts.
- *
- * Each topic is a sentinel `node<unknown>()` with push-on-subscribe replay of
- * the most recent published value (no push until the first `publish`). For
- * Pulsar-inspired retained message logs,
- * cursor-based subscriptions, and job-queue semantics, use `messagingHub()` in
- * `utils/messaging` — built on `TopicGraph` / `SubscriptionGraph` with
- * retention policies, absolute cursor tracking, and per-subscriber state.
- *
- * Presentation layer (base/composition). Moved from pure-ts during cleave A3
- * (no substrate core/graph dependency on pubsub found).
- */
-
-import { batch, type Node, node, TEARDOWN, wallClockNs } from "@graphrefly/pure-ts/core";
-import {
-	type PubSubChange,
-	type PubSubChangePayload,
-	type ReactiveLogBundle,
-	reactiveLog,
-} from "@graphrefly/pure-ts/extra";
-
-// ── Backend interface ─────────────────────────────────────────────────────
-
-/**
- * Storage contract for {@link pubsub} — registry only.
- *
- * Tracks the set of topic names plus a monotonic `version` counter that
- * advances on topic create/remove. Does NOT own per-topic message storage —
- * per-topic cached last values live in the topic nodes themselves (sentinel
- * until the first publish).
- *
- * For distributed / persistent per-topic storage, use `messagingHub()` in
- * `utils/messaging`, which composes `TopicGraph` under a lazy registry.
- *
- * @category base
- */
-export interface PubSubBackend {
-	/** Monotonic counter; advances on topic create/remove. */
-	readonly version: number;
-	readonly topicCount: number;
-	hasTopic(name: string): boolean;
-	topicNames(): IterableIterator<string>;
-	/** Records topic creation. Returns `true` if newly added (advances `version`). */
-	createTopic(name: string): boolean;
-	/** Records topic removal. Returns `true` if it existed (advances `version`). */
-	removeTopic(name: string): boolean;
-}
-
-/**
- * Default in-memory registry backend.
- *
- * @category base
- */
-export class NativePubSubBackend implements PubSubBackend {
-	private _version = 0;
-	private readonly _topics = new Set<string>();
-
-	get version(): number {
-		return this._version;
-	}
-
-	get topicCount(): number {
-		return this._topics.size;
-	}
-
-	hasTopic(name: string): boolean {
-		return this._topics.has(name);
-	}
-
-	topicNames(): IterableIterator<string> {
-		return this._topics.values();
-	}
-
-	createTopic(name: string): boolean {
-		if (this._topics.has(name)) return false;
-		this._topics.add(name);
-		this._version += 1;
-		return true;
-	}
-
-	removeTopic(name: string): boolean {
-		const had = this._topics.delete(name);
-		if (had) this._version += 1;
-		return had;
-	}
-}
-
-// ── Hub ───────────────────────────────────────────────────────────────────
-
-export type PubSubHubOptions = {
-	/**
-	 * Storage backend. Defaults to `NativePubSubBackend`. Pluggable for audit /
-	 * monitoring / mirror-to-external-broker use cases.
-	 */
-	backend?: PubSubBackend;
-	/**
-	 * DS-14 / DS14R2 — opt-in delta companion. When set, the hub appends a
-	 * typed {@link PubSubChange} record in the **same batch frame** as the
-	 * topic emission / teardown (same-wave consistency — subscribers reading
-	 * both a topic and `mutationLog` never see torn state).
-	 *
-	 * Records the locked `PubSubChange` verbs that apply to this last-value
-	 * hub: `publish` (per `publish` / `publishMany`) and `remove` (per
-	 * `removeTopic`). The `ack` verb is a cursor concern of `messagingHub()`
-	 * and does not apply here. **Note:** the locked `publish` payload carries
-	 * `value` only (no topic name) — callers needing per-topic delta
-	 * correlation should embed identity in the value or use `messagingHub()`.
-	 *
-	 * `true` = defaults; object form forwards `maxSize` / `name` to the inner
-	 * `reactiveLog`.
-	 */
-	mutationLog?: true | { maxSize?: number; name?: string };
-};
-
-/**
- * Lazy per-topic state hub. Topics are single-value sentinel nodes
- * with push-on-subscribe replay of the most recent publish.
- *
- * @category base
- */
-export interface PubSubHub {
-	/**
-	 * Returns the topic node, creating it on first use.
-	 *
-	 * @param name - Topic key.
-	 * @returns `Node` whose value is the last published payload. Starts in
-	 *   sentinel state — no push-on-subscribe until the first publish.
-	 */
-	topic(name: string): Node<unknown>;
-	/** Publishes a value to the topic (lazily creating the topic if missing). */
-	publish(name: string, value: unknown): void;
-	/**
-	 * Bulk publish — single outer batch for all entries. No-op if empty.
-	 *
-	 * **Iterable consumption (F6):** `entries` is consumed once (single-pass).
-	 * Pass an array or `Set` for multi-shot callers. Iteration happens INSIDE
-	 * the batch frame — if the iterator throws mid-way, the batch is discarded
-	 * and NO publishes are visible to subscribers (all-or-nothing within one
-	 * call).
-	 */
-	publishMany(entries: Iterable<[string, unknown]>): void;
-	/** Removes a topic; sends `TEARDOWN` to its node. Returns `true` if it existed. */
-	removeTopic(name: string): boolean;
-	/** Checks topic existence without creating. O(1). */
-	has(name: string): boolean;
-	/** Number of topics currently registered. O(1). */
-	readonly size: number;
-	/** Iterator over topic names. */
-	topicNames(): IterableIterator<string>;
-	/**
-	 * DS14R2 — present iff `mutationLog` was configured. Append-only log of
-	 * `publish` / `remove` deltas, same-wave-consistent with topic emissions.
-	 */
-	readonly mutationLog?: ReactiveLogBundle<PubSubChange>;
-}
-
-/**
- * Creates a lazy per-topic state hub.
- *
- * @param options - Optional pluggable `backend` (defaults to `NativePubSubBackend`).
- * @returns Hub with lazy `topic()` / `publish()` / `publishMany()` / `removeTopic()` /
- *   `has()` / `size` / `topicNames()`.
- *
- * @remarks
- * **Scope:** Each topic is a sentinel node — retains only the last published
- * value (no push-on-subscribe before the first publish). For Pulsar-inspired
- * retention + cursor reading, use `messagingHub()` in `utils/messaging`.
- *
- * **`removeTopic`:** Sends `TEARDOWN` to the topic node; all subscribers receive
- * the TEARDOWN message. Subsequent `publish(name, value)` silently recreates the
- * topic with a fresh node — existing subscribers to the old node do NOT reconnect.
- *
- * @example
- * ```ts
- * import { pubsub } from "@graphrefly/graphrefly";
- *
- * const hub = pubsub();
- * const t = hub.topic("events");
- * t.subscribe((msgs) => console.log(msgs));
- * hub.publish("events", { ok: true });
- * hub.publishMany([["events", 1], ["status", "ready"]]);
- * ```
- *
- * @category base
- */
-export function pubsub(options: PubSubHubOptions = {}): PubSubHub {
-	const { backend: userBackend, mutationLog: mutLogOpt } = options;
-	const backend: PubSubBackend = userBackend ?? new NativePubSubBackend();
-	const nodes = new Map<string, Node<unknown>>();
-
-	// ── DS14R2 — mutation log companion ──────────────────────────────────────
-	const mutLog: ReactiveLogBundle<PubSubChange> | undefined = mutLogOpt
-		? reactiveLog<PubSubChange>(undefined, {
-				name: mutLogOpt === true ? "pubsub.mutationLog" : (mutLogOpt.name ?? "pubsub.mutationLog"),
-				maxSize: mutLogOpt === true ? undefined : mutLogOpt.maxSize,
-			})
-		: undefined;
-	let mutVersion = 0;
-	function recordChange(change: PubSubChangePayload): void {
-		if (!mutLog) return;
-		mutLog.append({
-			structure: "pubsub",
-			version: ++mutVersion,
-			t_ns: wallClockNs(),
-			lifecycle: "data",
-			change,
-		});
-	}
-
-	function ensureTopic(name: string): Node<unknown> {
-		let n = nodes.get(name);
-		if (n === undefined) {
-			n = node<unknown>({ describeKind: "state" });
-			nodes.set(name, n);
-			backend.createTopic(name);
-		}
-		return n;
-	}
-
-	return {
-		topic(name: string): Node<unknown> {
-			return ensureTopic(name);
-		},
-
-		publish(name: string, value: unknown): void {
-			if (!mutLog) {
-				ensureTopic(name).emit(value);
-				return;
-			}
-			// Same-wave: topic emit + change record in one batch frame.
-			batch(() => {
-				ensureTopic(name).emit(value);
-				recordChange({ kind: "publish", value });
-			});
-		},
-
-		publishMany(entries: Iterable<[string, unknown]>): void {
-			batch(() => {
-				for (const [name, value] of entries) {
-					ensureTopic(name).emit(value);
-					recordChange({ kind: "publish", value });
-				}
-			});
-		},
-
-		removeTopic(name: string): boolean {
-			const n = nodes.get(name);
-			if (n === undefined) return false;
-			nodes.delete(name);
-			backend.removeTopic(name);
-			if (!mutLog) {
-				n.down([[TEARDOWN]]);
-				return true;
-			}
-			batch(() => {
-				// QA P3: record BEFORE TEARDOWN. A subscriber wired to both a
-				// topic and `mutationLog` that self-detaches on TEARDOWN would
-				// otherwise miss the `remove` delta (same-wave consistency).
-				recordChange({ kind: "remove", name });
-				n.down([[TEARDOWN]]);
-			});
-			return true;
-		},
-
-		has(name: string): boolean {
-			return backend.hasTopic(name);
-		},
-
-		get size(): number {
-			return backend.topicCount;
-		},
-
-		topicNames(): IterableIterator<string> {
-			return backend.topicNames();
-		},
-
-		mutationLog: mutLog,
-	};
-}
diff --git a/src/base/composition/single-from-any.ts b/src/base/composition/single-from-any.ts
deleted file mode 100644
index c81576af..00000000
--- a/src/base/composition/single-from-any.ts
+++ /dev/null
@@ -1,201 +0,0 @@
-/**
- * `singleFromAny` — keyed promise/Node de-duplication ("singleflight").
- *
- * Given a `factory: (key) => NodeInput<T>`, returns a callable that dedupes
- * concurrent invocations sharing the same key — all callers with the same
- * key while a request is in-flight receive the same `Promise<T>`. Once the
- * underlying source settles (DATA, ERROR, or COMPLETE), the cache entry is
- * cleared so the next call re-invokes the factory.
- *
- * This is the classic "singleflight" pattern from Go, generalised over the
- * library's `NodeInput<T>` bridge so callers can pass Promise-returning
- * factories, Node-returning factories, or plain value factories with
- * identical semantics.
- *
- * Use cases:
- * - `withReplayCache` cache-miss thundering-herd dedup
- * - Shared HTTP fetches keyed by URL
- * - Expensive compute keyed by request fingerprint
- *
- * @example
- * ```ts
- * const fetchUser = singleFromAny<string, User>((id) => fetch(`/users/${id}`).then(r => r.json()));
- * // Two concurrent callers with id="42" → one underlying fetch, two Promises resolving to the same User.
- * const [a, b] = await Promise.all([fetchUser("42"), fetchUser("42")]);
- * ```
- *
- * @category extra
- */
-
-import type { Node } from "@graphrefly/pure-ts/core";
-import { COMPLETE, ERROR, TEARDOWN } from "@graphrefly/pure-ts/core";
-// Import directly from the source sub-files (rather than the `./sources.js`
-// barrel) so the `single-from-any` module is NOT part of any cycle that runs
-// through `extra/sources/index.ts` — eager re-exports through the barrel were
-// observed to leave `firstValueFrom` / `keepalive` unresolved during nested
-// import chains under vite-node.
-import { fromAny, type NodeInput } from "@graphrefly/pure-ts/extra";
-import { firstValueFrom } from "../sources/settled.js";
-
-export interface SingleFromAnyOptions<K> {
-	/**
-	 * Convert a typed key into a cache-string. Defaults to `String(key)`, which
-	 * works for primitive keys; callers with object keys should provide a
-	 * stable serializer (e.g., canonical JSON).
-	 */
-	keyFn?: (key: K) => string;
-}
-
-/**
- * Dedupe concurrent `factory(key)` invocations. Returns a bound callable.
- *
- * @param factory - Produces a `NodeInput<T>` for each unique key.
- * @param opts - Optional key-stringification.
- * @returns A function `(key: K) => Promise<T>` whose inflight results are shared per key.
- */
-export function singleFromAny<K, T>(
-	factory: (key: K) => NodeInput<T>,
-	opts: SingleFromAnyOptions<K> = {},
-): (key: K) => Promise<T> {
-	const keyFn = opts.keyFn ?? ((k: K) => String(k));
-	const inFlight = new Map<string, Promise<T>>();
-
-	return (key: K): Promise<T> => {
-		const k = keyFn(key);
-		const existing = inFlight.get(k);
-		if (existing) return existing;
-
-		const input = factory(key);
-
-		// Resolve the NodeInput to a Promise<T>. Different input shapes need
-		// different bridges — Promise/Node/AsyncIterable/Iterable/plain value.
-		let rawPromise: Promise<T>;
-		if (input != null && typeof (input as PromiseLike<T>).then === "function") {
-			rawPromise = Promise.resolve(input as PromiseLike<T>);
-		} else if (
-			input != null &&
-			typeof input === "object" &&
-			"subscribe" in (input as object) &&
-			"cache" in (input as object)
-		) {
-			// Node: bridge via firstValueFrom.
-			rawPromise = firstValueFrom(input as Node<T>);
-		} else if (
-			input != null &&
-			typeof input === "object" &&
-			Symbol.asyncIterator in (input as object)
-		) {
-			// AsyncIterable — take the first value, then close the iterator so
-			// any owned resources (HTTP body, subscription, timer) are released.
-			rawPromise = (async () => {
-				const iter = (input as AsyncIterable<T>)[Symbol.asyncIterator]();
-				try {
-					const { value, done } = await iter.next();
-					if (done) throw new Error("singleFromAny: factory returned empty async iterable");
-					return value as T;
-				} finally {
-					await iter.return?.();
-				}
-			})();
-		} else if (input != null && typeof input === "object" && Symbol.iterator in (input as object)) {
-			// Iterable — take the first value, close the iterator.
-			rawPromise = (async () => {
-				const iter = (input as Iterable<T>)[Symbol.iterator]();
-				try {
-					const { value, done } = iter.next();
-					if (done) throw new Error("singleFromAny: factory returned empty iterable");
-					return value as T;
-				} finally {
-					iter.return?.();
-				}
-			})();
-		} else {
-			// Plain value.
-			rawPromise = Promise.resolve(input as T);
-		}
-
-		// Install the cache entry BEFORE attaching `.finally`. Otherwise a
-		// sync-resolved Promise's finally microtask could run before the
-		// `inFlight.set` below, leaving a stale entry installed afterwards.
-		// We wrap in a holder whose reference we capture *before* chaining.
-		let tracked!: Promise<T>;
-		const cleanup = (): void => {
-			if (inFlight.get(k) === tracked) inFlight.delete(k);
-		};
-		tracked = rawPromise.then(
-			(v) => {
-				cleanup();
-				return v;
-			},
-			(e) => {
-				cleanup();
-				throw e;
-			},
-		);
-		inFlight.set(k, tracked);
-		return tracked;
-	};
-}
-
-/**
- * Reactive variant: returns a bound callable that hands out `Node<T>` values.
- * All concurrent callers with the same key during an in-flight source share
- * the same Node. The cache entry is evicted (so the next call re-invokes
- * `factory`) when the underlying source either:
- *
- * - **terminally settles** — `ERROR` or `COMPLETE`; or
- * - **tears down** — `TEARDOWN` (M8 fix). A DATA-only source (e.g. a
- *   long-lived `state(...)`) never emits `ERROR`/`COMPLETE`, so without
- *   the TEARDOWN arm a destroyed shared Node — plus this watcher
- *   subscription — would be pinned in the `inFlight` Map forever. Evicting
- *   on TEARDOWN bounds the entry's lifetime to the Node's own lifetime.
- *
- * DATA is NOT an eviction trigger — callers subscribing after the first
- * DATA still receive the shared Node (and push-on-subscribe per the spec's
- * cached-DATA contract). The Node stays shared while alive (the dedup
- * contract); only its death (terminal or teardown) releases the entry.
- *
- * Use when downstream wants reactive subscription (not a one-shot Promise).
- *
- * @category extra
- */
-export function singleNodeFromAny<K, T>(
-	factory: (key: K) => NodeInput<T>,
-	opts: SingleFromAnyOptions<K> = {},
-): (key: K) => Node<T> {
-	const keyFn = opts.keyFn ?? ((k: K) => String(k));
-	const inFlight = new Map<string, Node<T>>();
-
-	return (key: K): Node<T> => {
-		const k = keyFn(key);
-		const existing = inFlight.get(k);
-		if (existing) return existing;
-
-		const node = fromAny(factory(key));
-		inFlight.set(k, node);
-
-		// Evict on Node death — terminal settle (ERROR / COMPLETE) OR
-		// TEARDOWN (M8). DATA is a value emission, not a lifecycle
-		// transition; multi-emitting Nodes continue to share across
-		// subscribers after the first value. The TEARDOWN arm is what
-		// releases DATA-only `state(...)` sources, which never terminate.
-		// `unsub` is hoisted (mirrors `singleFromAny`'s `let tracked!`): the
-		// sink closes over it, and a `fromAny` source that synchronously
-		// replays a cached terminal/TEARDOWN on subscribe would otherwise hit
-		// `unsub` in its TDZ. In that sync-terminal case `unsub` is still
-		// `undefined` when the sink runs — `unsub?.()` no-ops, but the
-		// load-bearing `inFlight.delete(k)` eviction still runs and an
-		// already-terminal node won't re-emit (the dangling sub is inert).
-		let unsub: (() => void) | undefined;
-		unsub = node.subscribe((msgs) => {
-			for (const m of msgs) {
-				if (m[0] === ERROR || m[0] === COMPLETE || m[0] === TEARDOWN) {
-					if (inFlight.get(k) === node) inFlight.delete(k);
-					unsub?.();
-					return;
-				}
-			}
-		});
-		return node;
-	};
-}
diff --git a/src/base/composition/verifiable.ts b/src/base/composition/verifiable.ts
deleted file mode 100644
index 416ac66b..00000000
--- a/src/base/composition/verifiable.ts
+++ /dev/null
@@ -1,122 +0,0 @@
-/**
- * Composite data patterns (roadmap §3.2b).
- *
- * These helpers compose existing primitives (`node`, `switchMap`, `reactiveMap`,
- * `dynamicNode`, `fromAny`) without introducing new protocol semantics.
- */
-
-import {
-	batch,
-	DATA,
-	factoryTag,
-	type Node,
-	type NodeOptions,
-	node,
-} from "@graphrefly/pure-ts/core";
-import {
-	fromAny,
-	merge,
-	type NodeInput,
-	switchMap,
-	withLatestFrom,
-} from "@graphrefly/pure-ts/extra";
-import { forEach } from "../sources/async.js";
-
-// Re-export distill from its canonical module (co-located here pre-split;
-// moved to distill.ts to avoid duplicate-export conflict at the barrel level).
-export {
-	type DistillBundle,
-	type DistillOptions,
-	distill,
-	type Extraction,
-} from "./distill.js";
-
-/**
- * Verification payload shape is intentionally user-defined.
- */
-export type VerifyValue = unknown;
-
-export type VerifiableOptions<TVerify = VerifyValue> = Omit<
-	NodeOptions,
-	"describeKind" | "initial"
-> & {
-	/** Reactive re-verification trigger. */
-	trigger?: NodeInput<unknown>;
-	/** Re-run verification whenever `source` settles. */
-	autoVerify?: boolean;
-	/** Initial verification companion value. */
-	initialVerified?: TVerify | null;
-};
-
-export type VerifiableBundle<T, TVerify = VerifyValue> = {
-	/** Coerced source node. */
-	node: Node<T>;
-	/** Latest verification result (`null` before first verification). */
-	verified: Node<TVerify | null>;
-	/** Effective trigger node used for verification, if any. */
-	trigger: Node<unknown> | null;
-};
-
-/**
- * Composes a value node with a reactive verification companion.
- *
- * Uses `switchMap` so newer triggers cancel stale in-flight verification work.
- */
-export function verifiable<T, TVerify = VerifyValue>(
-	source: NodeInput<T>,
-	verifyFn: (value: T) => NodeInput<TVerify>,
-	opts?: VerifiableOptions<TVerify>,
-): VerifiableBundle<T, TVerify> {
-	const sourceNode = fromAny(source);
-	const hasSourceVersioning = sourceNode.v != null;
-	const verified = node<TVerify | null>([], {
-		initial: opts?.initialVerified ?? null,
-		meta: {
-			...factoryTag("verifiable"),
-			...(hasSourceVersioning ? { sourceVersion: null } : {}),
-		},
-	});
-	const hasTrigger = opts?.trigger !== undefined && opts.trigger !== null;
-
-	let triggerNode: Node<unknown> | null = null;
-	if (hasTrigger && opts?.autoVerify) {
-		triggerNode = merge(fromAny(opts.trigger) as Node<unknown>, sourceNode as Node<unknown>);
-	} else if (hasTrigger) {
-		triggerNode = fromAny(opts.trigger);
-	} else if (opts?.autoVerify) {
-		triggerNode = sourceNode as Node<unknown>;
-	}
-
-	if (triggerNode !== null) {
-		// Two patterns depending on trigger shape:
-		//  - autoVerify-only (triggerNode === sourceNode): the projected
-		//    switchMap value IS the source DATA, pass it directly.
-		//  - explicit trigger: `withLatestFrom(trigger, source)` pairs each
-		//    trigger emission with the latest source value. Phase 10.5
-		//    (`withLatestFrom` flipped to `partial: false`) fixed the W1
-		//    initial-pair drop — both deps settle before fn fires, so the
-		//    first trigger correctly pairs with the seeded source cache.
-		//    Replaces the §28 closure-mirror that was canonical pre-10.5.
-		let verifyStream: Node<TVerify>;
-		if (triggerNode === (sourceNode as Node<unknown>)) {
-			verifyStream = switchMap(sourceNode, (src) => verifyFn(src as T));
-		} else {
-			const paired = withLatestFrom(triggerNode, sourceNode);
-			verifyStream = switchMap(paired, ([, source]) => verifyFn(source as T));
-		}
-		forEach(verifyStream, (value) => {
-			batch(() => {
-				verified.down([[DATA, value]]);
-				// V0 backfill: stamp which source version was verified (§6.0b).
-				if (hasSourceVersioning) {
-					const sv = sourceNode.v;
-					if (sv != null) {
-						verified.meta.sourceVersion.down([[DATA, { id: sv.id, version: sv.version }]]);
-					}
-				}
-			});
-		});
-	}
-
-	return { node: sourceNode, verified, trigger: triggerNode };
-}
diff --git a/src/base/index.ts b/src/base/index.ts
deleted file mode 100644
index d83719c0..00000000
--- a/src/base/index.ts
+++ /dev/null
@@ -1,19 +0,0 @@
-/**
- * Base layer — domain-agnostic infrastructure.
- *
- * Exports: io, composition, mutation, worker, render, meta, sources, utils.
- *
- * Node-only subpath: @graphrefly/graphrefly/base/sources/node
- * Browser-only subpath: @graphrefly/graphrefly/base/sources/browser
- *
- * @module
- */
-
-export * from "./composition/index.js";
-export * from "./io/index.js";
-export * from "./meta/index.js";
-export * from "./mutation/index.js";
-export * from "./render/index.js";
-export * from "./sources/index.js";
-export * from "./utils/index.js";
-export * from "./worker/index.js";
diff --git a/src/base/io/_internal.ts b/src/base/io/_internal.ts
deleted file mode 100644
index d4b1ebd5..00000000
--- a/src/base/io/_internal.ts
+++ /dev/null
@@ -1,102 +0,0 @@
-/**
- * Internal helpers shared by IO sub-files.
- *
- * - `ExtraOpts` / `sourceOpts` — common opts + the `describeKind: "producer"`
- *   wrapper used by every producer-shaped IO source.
- * - `SinkHandle` / `BufferedSinkHandle` — public sink handle shapes shared by
- *   per-record and buffered sinks across multiple protocols.
- * - `AdapterHandlers` / `AckableMessage` — alias of `EmitTriad` and the
- *   manual-ack envelope used by Pulsar / RabbitMQ ingest sub-files.
- * - `AttachStorageGraphLike` — duck-typed graph shape used by
- *   `checkpointToS3` / `checkpointToRedis`.
- */
-
-import type { Node, NodeOptions } from "@graphrefly/pure-ts/core";
-import type { SnapshotStorageTier } from "@graphrefly/pure-ts/extra/storage";
-import type { GraphCheckpointRecord } from "@graphrefly/pure-ts/graph";
-import type { EmitTriad } from "../composition/external-register.js";
-import type { SinkTransportError } from "./_sink.js";
-
-export type ExtraOpts = Omit<NodeOptions, "describeKind">;
-
-export function sourceOpts<T>(opts?: ExtraOpts): NodeOptions<T> {
-	return { describeKind: "producer", ...opts } as NodeOptions<T>;
-}
-
-/** Handle returned by per-record and buffered sinks. */
-export type SinkHandle = {
-	/** Stop the sink (unsubscribe from source). */
-	dispose: () => void;
-	/** Reactive node that emits the latest transport error (or `null`). */
-	errors: Node<SinkTransportError | null>;
-	/** Manually drain the internal buffer (buffered sinks only). */
-	flush?: () => Promise<void>;
-};
-
-/** Handle returned by buffered sinks. `flush()` drains remaining buffer. */
-export type BufferedSinkHandle = SinkHandle & {
-	/** Manually drain the internal buffer. */
-	flush: () => Promise<void>;
-};
-
-/** Standard handler triple for adapters that accept injected registrations. Alias of {@link EmitTriad}. */
-export type AdapterHandlers<T> = EmitTriad<T>;
-
-/**
- * Message envelope emitted by queue consumers when `autoAck: false`. The
- * caller is responsible for calling `ack()` after successful processing or
- * `nack()` to re-queue / dead-letter. Pairs cleanly with reactive pipelines:
- *
- * ```ts
- * const messages$ = fromPulsar(consumer, { autoAck: false });
- * effect([messages$], ([m]) => {
- *   try {
- *     process(m.value);
- *     m.ack();
- *   } catch (err) {
- *     m.nack({ requeue: true });
- *   }
- * });
- * ```
- *
- * Ack/nack are imperative callbacks (§5.10 boundary) because the underlying
- * SDKs expose them as such. Reactive-all-the-way ack flows can be built by
- * piping `msg.ack` calls into a `reactiveSink` if desired.
- *
- * **Caller contract — must settle every emitted message.** The envelope holds
- * a closure reference to the raw SDK message; unsettled envelopes keep the
- * broker's in-flight window full and leak memory proportional to consumer
- * throughput. Patterns that drop messages (filter, take-first, switchMap
- * discard) must explicitly `nack({ requeue: true })` the discarded ones, or
- * wrap the source to force-settle on teardown.
- *
- * **Ack/nack transport failures.** Both methods route exceptions through
- * the source's `onAckError` option (when provided) — SDK rejections from
- * `acknowledge()`/`negativeAcknowledge()` don't escape as unhandled
- * rejections. Default (no `onAckError`): swallow. The broker handles
- * redelivery on its own timeline.
- *
- * @category extra
- */
-export type AckableMessage<T> = {
-	/** The wrapped message body. */
-	value: T;
-	/** Acknowledge successful processing. Safe to call more than once — idempotent. */
-	ack(): void;
-	/**
-	 * Negative-acknowledge — signals the broker the message was not processed
-	 * successfully. `requeue: true` asks the broker to redeliver; `requeue: false`
-	 * may route to a dead-letter queue (SDK-specific). Omit `requeue` to
-	 * defer to the SDK's own default.
-	 */
-	nack(opts?: { requeue?: boolean }): void;
-};
-
-/** Duck-typed graph shape consumed by `checkpointToS3` / `checkpointToRedis`. */
-export type AttachStorageGraphLike = {
-	attachSnapshotStorage: (
-		pairs: readonly { snapshot: SnapshotStorageTier<GraphCheckpointRecord> }[],
-		opts?: unknown,
-	) => { dispose(): void };
-	name: string;
-};
diff --git a/src/base/io/_sink.ts b/src/base/io/_sink.ts
deleted file mode 100644
index d0b0fbe1..00000000
--- a/src/base/io/_sink.ts
+++ /dev/null
@@ -1,789 +0,0 @@
-/**
- * {@link reactiveSink} — canonical sink factory for Wave 5 adapters.
- *
- * Every `to*` adapter in {@link ./adapters.ts} can be expressed as a thin
- * config wrapper around this one factory. It centralizes:
- *
- * - **Transport boundary** — the sole place in the sink layer where a raw
- *   Promise / `.then` / `.catch` sits (§5.10 boundary documented here).
- * - **Retry** — delegates to {@link BackoffStrategy} from `backoff.ts`.
- * - **Buffering** — `batchSize` / `flushIntervalMs` with tier-3 flush-on-
- *   terminal per spec §5.11. Buffered mode activates when `sendBatch` is
- *   supplied or a batching knob is set.
- * - **Backpressure** — bounded internal queue with `drop-oldest` /
- *   `drop-newest` / `error` strategies. The `"wait"` strategy is deferred
- *   to external composition (`source | valve(...) | reactiveSink(...)`).
- * - **Companions** — `sent` / `failed` / `inFlight` / `errors` (+ `buffered`
- *   / `paused` when buffering or backpressure is active). These surface
- *   every transport outcome as reactive nodes so downstream operators can
- *   build retry fallbacks, dead-letter queues, or SLO gauges without
- *   touching callback soup.
- */
-
-import {
-	COMPLETE,
-	DATA,
-	defaultConfig,
-	ERROR,
-	type Message,
-	type Node,
-	node,
-	RingBuffer,
-	TEARDOWN,
-} from "@graphrefly/pure-ts/core";
-import {
-	type BackoffPreset,
-	type BackoffStrategy,
-	NS_PER_MS,
-	resolveBackoffPreset,
-} from "../resilience/backoff.js";
-
-/**
- * Dual-mode buffer for the sink's backpressure queue.
- * - Bounded (finite `maxBuf`): wraps {@link RingBuffer} so drop-oldest is O(1)
- *   instead of O(n) via `Array.prototype.shift`.
- * - Unbounded (`Infinity`): plain array — no drops, no need for ring semantics.
- * `drain()` always returns the current contents and resets to empty.
- */
-class BackpressureBuffer<T> {
-	private ring: RingBuffer<T> | null;
-	private arr: T[] | null;
-	constructor(cap: number) {
-		if (cap === Number.POSITIVE_INFINITY || cap <= 0) {
-			this.arr = [];
-			this.ring = null;
-		} else {
-			this.ring = new RingBuffer<T>(cap);
-			this.arr = null;
-		}
-	}
-	get length(): number {
-		return this.ring != null ? this.ring.size : this.arr!.length;
-	}
-	push(item: T): void {
-		if (this.ring != null) this.ring.push(item);
-		else this.arr!.push(item);
-	}
-	/** Drop-oldest — O(1) in bounded mode. Returns undefined when empty. */
-	shift(): T | undefined {
-		if (this.ring != null) return this.ring.shift();
-		return this.arr!.shift();
-	}
-	/** Full drain — returns contents, resets to empty. */
-	drain(): T[] {
-		if (this.ring != null) {
-			const out = this.ring.toArray();
-			this.ring.clear();
-			return out;
-		}
-		const out = this.arr!;
-		this.arr = [];
-		return out;
-	}
-}
-
-// ---------------------------------------------------------------------------
-// Types
-// ---------------------------------------------------------------------------
-
-/**
- * Structured transport-failure record. Every sink routes both recoverable
- * (pre-retry) and terminal (post-exhaustion) failures through this shape.
- *
- * @category extra
- */
-export type SinkTransportError = {
-	/**
-	 * Failure stage. Known values: `"serialize"`, `"send"`, `"close"`,
-	 * `"routing_key"`, `"ack"`, `"retry_exhausted"`. Open to extension for
-	 * protocol-specific stages.
-	 */
-	stage: string;
-	/** The error. */
-	error: Error;
-	/** Unwrapped DATA value (present for per-record failures). */
-	value: unknown;
-	/** Full message tuple (present for non-DATA stages like `"close"`). */
-	message?: Message;
-	/** Attempt number when `retry` is active — `1` = initial send. */
-	attempt?: number;
-};
-
-/**
- * Terminal failure record delivered on the `failed` companion after retries
- * are exhausted (or `shouldRetry` returned `false`).
- *
- * @category extra
- */
-export type SinkFailure<T> = {
-	value: T;
-	error: Error;
-	/** Total attempts made, including the initial send. */
-	attempts: number;
-};
-
-/**
- * Handle returned by every Wave 5 sink.
- *
- * @category extra
- */
-export type ReactiveSinkHandle<T> = {
-	/** Unsubscribe from source, cancel timers, fire `TEARDOWN` on companions. */
-	dispose(): void;
-	/** Drain buffer + await in-flight sends (buffered mode only). */
-	flush?(): Promise<void>;
-	/** DATA values that successfully reached the transport. */
-	sent: Node<T>;
-	/** Values that permanently failed (after any retries). */
-	failed: Node<SinkFailure<T> | null>;
-	/** Number of pending transport operations. */
-	inFlight: Node<number>;
-	/** Every transient transport error (pre-retry). Latest-only. */
-	errors: Node<SinkTransportError | null>;
-	/** Items currently buffered (buffered mode / backpressure only). */
-	buffered?: Node<number>;
-	/** `true` when a backpressure strategy has dropped / rejected items. */
-	paused?: Node<boolean>;
-};
-
-/**
- * Retry configuration for {@link reactiveSink}.
- *
- * @category extra
- */
-export type ReactiveSinkRetryOptions = {
-	/** Total attempts including the initial send. Default: `1` (no retry). */
-	maxAttempts?: number;
-	/** Backoff strategy (ns) or preset name. Default: `"exponential"` when `maxAttempts > 1`. */
-	backoff?: BackoffStrategy | BackoffPreset;
-	/** Predicate — return `false` to short-circuit retry for a given error. */
-	shouldRetry?: (err: Error, attempt: number) => boolean;
-};
-
-/**
- * Backpressure configuration for {@link reactiveSink}. When omitted, the
- * sink has no internal buffer cap beyond the natural `batchSize` /
- * `flushIntervalMs` limits.
- *
- * @category extra
- */
-export type ReactiveSinkBackpressureOptions = {
-	/**
-	 * Hard cap on buffered items; further items trigger `strategy`.
-	 *
-	 * **Required when `backpressure` is configured** — fail-loud per D4
-	 * (F-SINK, 2026-05-18 smell sweep), mirroring {@link rateLimiter}'s
-	 * `maxBuffer` contract. Pass a finite positive integer for a bounded
-	 * buffer, or the literal `Infinity` to explicitly opt in to an unbounded
-	 * buffer (silently defaulting to unbounded is the most common backpressure
-	 * mis-configuration). A `backpressure` object omitting `maxBuffer` throws
-	 * `RangeError` at construction.
-	 */
-	maxBuffer: number;
-	/** Policy when the buffer is full. Default: `"drop-oldest"`. */
-	strategy?: "drop-oldest" | "drop-newest" | "error";
-};
-
-/**
- * Base options shared by every sink built on {@link reactiveSink}.
- *
- * @category extra
- */
-export type ReactiveSinkOptions<T> = {
-	/** Optional name used for companion node naming. */
-	name?: string;
-	/** Invoked synchronously for every transient transport error. */
-	onTransportError?: (err: SinkTransportError) => void;
-	/** Retry configuration. */
-	retry?: ReactiveSinkRetryOptions;
-	/** Backpressure configuration. */
-	backpressure?: ReactiveSinkBackpressureOptions;
-	/** Batch size before auto-flush (buffered mode). */
-	batchSize?: number;
-	/** Flush interval in ms; `0` = write-through (buffered mode). */
-	flushIntervalMs?: number;
-	/** Optional transform applied before `send` / `sendBatch`. */
-	serialize?: (value: T) => unknown;
-	/**
-	 * Reactive stop signal — when this node emits any DATA or terminal, the
-	 * sink tears down. Gives callers a reactive alternative to the imperative
-	 * `handle.dispose()` call so teardown can be wired through the graph.
-	 */
-	stopOn?: Node<unknown>;
-	/**
-	 * Optional hook invoked for each upstream non-DATA message (COMPLETE /
-	 * ERROR / etc.) observed by the sink. Used by adapters like
-	 * {@link toWebSocket} to close the underlying resource when the source
-	 * terminates, without the caller having to subscribe twice.
-	 */
-	onUpstreamMessage?: (msg: Message) => void;
-	/**
-	 * Invoked once during `dispose()` after the sink's own cleanup (unsub,
-	 * final drain, TEARDOWN on companions). Adapters wrap external resources
-	 * (socket listeners, file handles) by passing their cleanup here —
-	 * avoids hand-rolling a wrapper around `handle.dispose`.
-	 */
-	onDispose?: () => void;
-	/**
-	 * Ignored — reserved for future parity with `source.pipe(...)` style.
-	 *
-	 * @internal
-	 */
-	_reserved?: never;
-};
-
-/**
- * Full config accepted by {@link reactiveSink}. One of `send` / `sendBatch`
- * is required.
- *
- * @category extra
- */
-export type ReactiveSinkConfig<T, Ctx = unknown> = ReactiveSinkOptions<T> & {
-	/** Per-record transport call. */
-	send?: (value: T, ctx: Ctx) => Promise<void> | void;
-	/** Batched transport call. When supplied, buffering activates automatically. */
-	sendBatch?: (batch: T[], ctx: Ctx) => Promise<void> | void;
-	/** Context object threaded into every `send` / `sendBatch` call. */
-	ctx?: Ctx;
-};
-
-// ---------------------------------------------------------------------------
-// Internal helpers
-// ---------------------------------------------------------------------------
-
-function coerceError(err: unknown): Error {
-	return err instanceof Error ? err : new Error(String(err));
-}
-
-function resolveBackoff(
-	backoff: BackoffStrategy | BackoffPreset | undefined,
-): BackoffStrategy | null {
-	if (backoff === undefined) return null;
-	if (typeof backoff === "string") return resolveBackoffPreset(backoff);
-	return backoff;
-}
-
-// ---------------------------------------------------------------------------
-// Factory
-// ---------------------------------------------------------------------------
-
-/**
- * Build a reactive sink with retry / buffering / backpressure / observability
- * companions. Every Wave 5 `to*` adapter is a thin config wrapper around
- * this factory.
- *
- * **Modes:**
- * - `send` only, no batching knobs → **per-record write-through**
- * - `send` + `batchSize` or `flushIntervalMs` → **per-record buffered**
- *   (buffer drains via repeated `send` calls — one-by-one in order)
- * - `sendBatch` → **batched** (whole chunks handed to the transport)
- *
- * @category extra
- */
-export function reactiveSink<T, Ctx = unknown>(
-	source: Node<T>,
-	config: ReactiveSinkConfig<T, Ctx>,
-): ReactiveSinkHandle<T> {
-	const {
-		name,
-		onTransportError,
-		retry,
-		backpressure,
-		batchSize = Number.POSITIVE_INFINITY,
-		flushIntervalMs = 0,
-		serialize,
-		stopOn,
-		onUpstreamMessage,
-		onDispose,
-		send,
-		sendBatch,
-		ctx: ctxValue,
-	} = config;
-
-	if (!send && !sendBatch) {
-		throw new Error("reactiveSink: `send` or `sendBatch` must be provided");
-	}
-
-	const ctx = ctxValue as Ctx;
-	const maxAttempts = Math.max(1, retry?.maxAttempts ?? 1);
-	const backoffStrategy = resolveBackoff(
-		retry?.backoff ?? (maxAttempts > 1 ? "exponential" : undefined),
-	);
-	const shouldRetry = retry?.shouldRetry ?? (() => true);
-
-	const useBuffering =
-		sendBatch !== undefined || batchSize < Number.POSITIVE_INFINITY || flushIntervalMs > 0;
-
-	const nameFor = (suffix: string) => (name ? `${name}::${suffix}` : undefined);
-
-	const sent = node<T | undefined>([], {
-		initial: undefined,
-		equals: () => false,
-		name: nameFor("sent"),
-	}) as unknown as Node<T>;
-	const failed = node<SinkFailure<T> | null>([], { initial: null, name: nameFor("failed") });
-	const inFlightCountNode = node([], { initial: 0, name: nameFor("inFlight") });
-	const errorsNode = node<SinkTransportError | null>([], {
-		initial: null,
-		name: nameFor("errors"),
-	});
-	const bufferedNode = useBuffering
-		? node([], { initial: 0, name: nameFor("buffered") })
-		: undefined;
-	const pausedNode = backpressure
-		? node([], { initial: false, name: nameFor("paused") })
-		: undefined;
-
-	let inFlightCount = 0;
-	const bumpInFlight = (delta: number) => {
-		inFlightCount += delta;
-		inFlightCountNode.down([[DATA, inFlightCount]]);
-	};
-
-	const reportError = (err: SinkTransportError) => {
-		try {
-			onTransportError?.(err);
-		} catch {
-			/* user hook must not escape */
-		}
-		try {
-			errorsNode.down([[DATA, err]]);
-		} catch {
-			/* re-entrant drain — swallow */
-		}
-	};
-
-	const inFlightPromises = new Set<Promise<void>>();
-
-	const trackPromise = (p: Promise<void>) => {
-		inFlightPromises.add(p);
-		const done = () => inFlightPromises.delete(p);
-		p.then(done, done);
-	};
-
-	// Retry scheduling shared by per-record + batched paths.
-	const scheduleRetry = (runAgain: () => Promise<void>, attempt: number, error: Error) => {
-		const raw = backoffStrategy ? backoffStrategy(attempt - 1, error, null) : 0;
-		const delayNs =
-			raw === null || raw === undefined ? 0 : typeof raw === "number" && raw > 0 ? raw : 0;
-		// Clamp to >=1ms — sub-ms delays via integer division collapse to 0 and
-		// create synchronous retry loops that starve the event loop.
-		const delayMs = Math.max(1, Math.ceil(delayNs / NS_PER_MS));
-		return new Promise<void>((resolve) => {
-			// §5.10: retry delay at the transport boundary.
-			setTimeout(() => resolve(runAgain()), delayMs);
-		});
-	};
-
-	const isThenable = (v: unknown): v is Promise<void> =>
-		v != null && typeof v === "object" && typeof (v as { then?: unknown }).then === "function";
-
-	// -------------------------------------------------------------------
-	// Per-record send path — handles retry for a single value.
-	//
-	// Sync throws in `serialize` → reported synchronously as stage:"serialize".
-	// Sync throws in `send`      → reported synchronously as stage:"send".
-	// Async rejections from send → reported as stage:"send" on the next tick.
-	// -------------------------------------------------------------------
-	const performSend = (value: T): Promise<void> => {
-		let payload: unknown;
-		try {
-			payload = serialize ? serialize(value) : value;
-		} catch (rawErr) {
-			const error = coerceError(rawErr);
-			reportError({ stage: "serialize", error, value });
-			failed.down([[DATA, { value, error, attempts: 0 } satisfies SinkFailure<T>]]);
-			return Promise.resolve();
-		}
-
-		let attempt = 0;
-
-		const onError = (rawErr: unknown): Promise<void> | undefined => {
-			bumpInFlight(-1);
-			const error = coerceError(rawErr);
-			reportError({ stage: "send", error, value, attempt });
-			const more = attempt < maxAttempts && shouldRetry(error, attempt);
-			if (!more) {
-				failed.down([[DATA, { value, error, attempts: attempt } satisfies SinkFailure<T>]]);
-				return undefined;
-			}
-			return scheduleRetry(run, attempt, error);
-		};
-
-		const onSuccess = () => {
-			bumpInFlight(-1);
-			sent.down([[DATA, value]]);
-		};
-
-		function run(): Promise<void> {
-			attempt += 1;
-			bumpInFlight(+1);
-			let result: Promise<void> | void;
-			try {
-				result = (send as (v: unknown, c: Ctx) => Promise<void> | void)(payload, ctx);
-			} catch (rawErr) {
-				return onError(rawErr) ?? Promise.resolve();
-			}
-			if (isThenable(result)) {
-				return result.then(onSuccess, (rawErr) => onError(rawErr));
-			}
-			onSuccess();
-			return Promise.resolve();
-		}
-
-		return run();
-	};
-
-	// -------------------------------------------------------------------
-	// Buffer management (buffered mode).
-	//
-	// Buffer entries keep the original value (for failure reporting) alongside
-	// the post-serialize payload (for the transport call). Serializing at push
-	// time guarantees sync `stage: "serialize"` error reporting — the old
-	// hand-rolled sinks relied on this ordering.
-	// -------------------------------------------------------------------
-	type BufferEntry = { value: T; payload: unknown };
-	// F-SINK (2026-05-18 smell sweep): fail-loud — a configured `backpressure`
-	// MUST seed an explicit `maxBuffer` (use `Infinity` for explicit unbounded).
-	// Silently defaulting to an unbounded buffer is the same footgun class the
-	// `rateLimiter` primitive is fail-loud about (D4).
-	let maxBuf = Number.POSITIVE_INFINITY;
-	if (backpressure) {
-		const mb = backpressure.maxBuffer;
-		if (mb === undefined) {
-			throw new RangeError(
-				"reactiveSink: backpressure requires explicit maxBuffer (use Infinity to opt in to unbounded)",
-			);
-		}
-		if (mb !== Number.POSITIVE_INFINITY && (!Number.isInteger(mb) || mb < 1)) {
-			throw new RangeError(
-				"reactiveSink: backpressure.maxBuffer must be a positive integer (or Infinity for unbounded)",
-			);
-		}
-		maxBuf = mb;
-	}
-	const buffer = new BackpressureBuffer<BufferEntry>(maxBuf);
-	let flushTimer: ReturnType<typeof setTimeout> | undefined;
-	let disposed = false;
-
-	const updateBuffered = () => {
-		bufferedNode?.down([[DATA, buffer.length]]);
-	};
-
-	const markPaused = (paused: boolean) => {
-		if (!pausedNode) return;
-		pausedNode.down([[DATA, paused]]);
-	};
-
-	const bpStrategy = backpressure?.strategy ?? "drop-oldest";
-
-	const pushWithBackpressure = (value: T, payload: unknown): boolean => {
-		const entry: BufferEntry = { value, payload };
-		if (buffer.length < maxBuf) {
-			buffer.push(entry);
-			updateBuffered();
-			return true;
-		}
-		// At cap — apply strategy.
-		if (bpStrategy === "drop-oldest") {
-			const dropped = buffer.shift() as BufferEntry;
-			buffer.push(entry);
-			updateBuffered();
-			markPaused(true);
-			failed.down([
-				[
-					DATA,
-					{
-						value: dropped.value,
-						error: new Error("backpressure: buffer overflow — dropped oldest"),
-						attempts: 0,
-					} satisfies SinkFailure<T>,
-				],
-			]);
-			return true;
-		}
-		if (bpStrategy === "drop-newest") {
-			markPaused(true);
-			failed.down([
-				[
-					DATA,
-					{
-						value,
-						error: new Error("backpressure: buffer overflow — dropped newest"),
-						attempts: 0,
-					} satisfies SinkFailure<T>,
-				],
-			]);
-			return false;
-		}
-		// "error"
-		const err = new Error("backpressure: buffer overflow");
-		reportError({ stage: "send", error: err, value });
-		failed.down([[DATA, { value, error: err, attempts: 0 } satisfies SinkFailure<T>]]);
-		markPaused(true);
-		return false;
-	};
-
-	// Buffered flush: chunk is already serialized at push time. Retry the whole
-	// chunk on sendBatch failure (or per-record send failure).
-	const performBufferedBatchFlush = (chunk: BufferEntry[]): Promise<void> => {
-		let attempt = 0;
-		const payloads = chunk.map((e) => e.payload);
-
-		const onError = (rawErr: unknown): Promise<void> | undefined => {
-			bumpInFlight(-1);
-			const error = coerceError(rawErr);
-			reportError({ stage: "send", error, value: chunk.map((e) => e.value), attempt });
-			const more = attempt < maxAttempts && shouldRetry(error, attempt);
-			if (!more) {
-				for (const { value: v } of chunk) {
-					failed.down([[DATA, { value: v, error, attempts: attempt } satisfies SinkFailure<T>]]);
-				}
-				return undefined;
-			}
-			return scheduleRetry(run, attempt, error);
-		};
-
-		const onSuccess = () => {
-			bumpInFlight(-1);
-			for (const { value: v } of chunk) sent.down([[DATA, v]]);
-		};
-
-		function run(): Promise<void> {
-			attempt += 1;
-			bumpInFlight(+1);
-			let result: Promise<void> | void;
-			try {
-				result = (sendBatch as (b: unknown[], c: Ctx) => Promise<void> | void)(payloads, ctx);
-			} catch (rawErr) {
-				return onError(rawErr) ?? Promise.resolve();
-			}
-			if (isThenable(result)) {
-				return result.then(onSuccess, (rawErr) => onError(rawErr));
-			}
-			onSuccess();
-			return Promise.resolve();
-		}
-		return run();
-	};
-
-	const performBufferedPerRecordFlush = async (chunk: BufferEntry[]): Promise<void> => {
-		for (const entry of chunk) {
-			// Intentionally do NOT check `disposed` here — a dispose() mid-
-			// drain must let the already-captured chunk finish; otherwise
-			// buffered items would be dropped silently. `teardownRequested`
-			// prevents NEW work from starting (no new subscribe batches past
-			// this point), which is the right guard.
-			await performPreSerializedSend(entry.value, entry.payload);
-		}
-	};
-
-	// Per-record send that skips re-serialization (buffer already serialized).
-	const performPreSerializedSend = (value: T, payload: unknown): Promise<void> => {
-		let attempt = 0;
-		const onError = (rawErr: unknown): Promise<void> | undefined => {
-			bumpInFlight(-1);
-			const error = coerceError(rawErr);
-			reportError({ stage: "send", error, value, attempt });
-			const more = attempt < maxAttempts && shouldRetry(error, attempt);
-			if (!more) {
-				failed.down([[DATA, { value, error, attempts: attempt } satisfies SinkFailure<T>]]);
-				return undefined;
-			}
-			return scheduleRetry(run, attempt, error);
-		};
-		const onSuccess = () => {
-			bumpInFlight(-1);
-			sent.down([[DATA, value]]);
-		};
-		function run(): Promise<void> {
-			attempt += 1;
-			bumpInFlight(+1);
-			let result: Promise<void> | void;
-			try {
-				result = (send as (v: unknown, c: Ctx) => Promise<void> | void)(payload, ctx);
-			} catch (rawErr) {
-				return onError(rawErr) ?? Promise.resolve();
-			}
-			if (isThenable(result)) {
-				return result.then(onSuccess, (rawErr) => onError(rawErr));
-			}
-			onSuccess();
-			return Promise.resolve();
-		}
-		return run();
-	};
-
-	const doFlush = (): Promise<void> => {
-		if (disposed || buffer.length === 0) return Promise.resolve();
-		const chunk = buffer.drain();
-		updateBuffered();
-		markPaused(false);
-		if (sendBatch !== undefined) {
-			const p = performBufferedBatchFlush(chunk);
-			trackPromise(p);
-			return p;
-		}
-		const p = performBufferedPerRecordFlush(chunk);
-		trackPromise(p);
-		return p;
-	};
-
-	const scheduleFlush = () => {
-		if (flushTimer !== undefined || disposed) return;
-		if (flushIntervalMs <= 0) return;
-		flushTimer = setTimeout(() => {
-			/* §5.10: flush deadline timer — not reactive scheduling */
-			flushTimer = undefined;
-			void doFlush();
-		}, flushIntervalMs);
-	};
-
-	// -------------------------------------------------------------------
-	// Upstream subscription.
-	// -------------------------------------------------------------------
-	const unsub = source.subscribe((msgs) => {
-		for (const msg of msgs) {
-			const type = msg[0];
-			if (type !== DATA) {
-				try {
-					onUpstreamMessage?.(msg);
-				} catch {
-					/* user hook must not escape */
-				}
-			}
-			if (type === DATA) {
-				const value = msg[1] as T;
-				if (useBuffering) {
-					// Serialize sync at push time so `stage: "serialize"` errors
-					// surface on the same tick as the upstream DATA emission.
-					let payload: unknown;
-					if (serialize) {
-						try {
-							payload = serialize(value);
-						} catch (rawErr) {
-							const error = coerceError(rawErr);
-							reportError({ stage: "serialize", error, value });
-							failed.down([[DATA, { value, error, attempts: 0 } satisfies SinkFailure<T>]]);
-							continue;
-						}
-					} else {
-						payload = value;
-					}
-					const admitted = pushWithBackpressure(value, payload);
-					if (!admitted) continue;
-					if (buffer.length >= batchSize) void doFlush();
-					else scheduleFlush();
-				} else {
-					const p = performSend(value);
-					trackPromise(p);
-				}
-			} else if (defaultConfig.messageTier(type) >= 3) {
-				// Spec §5.11 — flush on tier-3+ terminal / teardown. INVALIDATE
-				// (tier 4) hits an empty buffer and is a no-op.
-				if (useBuffering) {
-					if (flushTimer !== undefined) {
-						clearTimeout(flushTimer);
-						flushTimer = undefined;
-					}
-					void doFlush();
-				}
-			}
-		}
-	});
-
-	// -------------------------------------------------------------------
-	// Reactive stop signal — a *fresh* emission on `stopOn` tears the sink
-	// down. The first batch delivered through subscribe contains the cached
-	// push-on-subscribe DATA (§2.2) and must be skipped; any emission
-	// arriving in a later batch is a real stop request.
-	// -------------------------------------------------------------------
-	let stopUnsub: (() => void) | undefined;
-	if (stopOn) {
-		let firstBatchSeen = false;
-		stopUnsub = stopOn.subscribe((msgs) => {
-			if (!firstBatchSeen) {
-				firstBatchSeen = true;
-				return;
-			}
-			if (msgs.length > 0 && !teardownRequested) dispose();
-		});
-	}
-
-	// -------------------------------------------------------------------
-	// Dispose.
-	//
-	// Two flags:
-	// - `teardownRequested`: set synchronously when `dispose()` is entered.
-	//   Gates further subscribe / buffer work and short-circuits stopOn
-	//   re-entry.
-	// - `disposed`: set only after the final drain + unsub + TEARDOWN fan-
-	//   out have landed. In-flight per-record drain loops read this to
-	//   decide "am I mid-cleanup vs fully-torn-down?" They only stop on
-	//   `disposed`, so a dispose mid-drain doesn't truncate the current
-	//   buffer — it just prevents further work from being scheduled.
-	// -------------------------------------------------------------------
-	let teardownRequested = false;
-	const dispose = () => {
-		if (teardownRequested) return;
-		teardownRequested = true;
-		if (flushTimer !== undefined) {
-			clearTimeout(flushTimer);
-			flushTimer = undefined;
-		}
-		// Final drain of buffered items. Fire-and-forget — the per-record
-		// drain loop reads `disposed` (still false) to keep draining the
-		// already-captured chunk.
-		if (useBuffering) void doFlush();
-		disposed = true;
-		stopUnsub?.();
-		unsub();
-		// Fire TEARDOWN on companions so downstream subscribers observe
-		// the sink's lifecycle end.
-		const tearDown = (n: Node<unknown>) => {
-			try {
-				n.down([[TEARDOWN]]);
-			} catch {
-				/* drain re-entrance — swallow */
-			}
-		};
-		tearDown(errorsNode as Node<unknown>);
-		tearDown(failed as Node<unknown>);
-		tearDown(sent as Node<unknown>);
-		tearDown(inFlightCountNode as Node<unknown>);
-		if (bufferedNode) tearDown(bufferedNode as Node<unknown>);
-		if (pausedNode) tearDown(pausedNode as Node<unknown>);
-		// Run adapter-supplied cleanup AFTER our own teardown completes so
-		// external resources (socket listeners, file handles) tear down with
-		// the sink as an atomic boundary.
-		try {
-			onDispose?.();
-		} catch {
-			/* adapter cleanup failure must not escape */
-		}
-	};
-
-	const handle: ReactiveSinkHandle<T> = {
-		dispose,
-		sent,
-		failed,
-		inFlight: inFlightCountNode,
-		errors: errorsNode,
-	};
-	if (useBuffering) {
-		handle.buffered = bufferedNode;
-		handle.flush = async () => {
-			if (disposed) return;
-			await doFlush();
-			await Promise.all(inFlightPromises);
-		};
-	}
-	if (pausedNode) handle.paused = pausedNode;
-
-	// Silence "unused" warnings for COMPLETE / ERROR — they're handled as
-	// part of the messageTier(type) >= 3 branch above.
-	void COMPLETE;
-	void ERROR;
-
-	return handle;
-}
diff --git a/src/base/io/checkpoint.ts b/src/base/io/checkpoint.ts
deleted file mode 100644
index 8cab0c10..00000000
--- a/src/base/io/checkpoint.ts
+++ /dev/null
@@ -1,160 +0,0 @@
-/**
- * Graph checkpoint sinks — `checkpointToS3` and `checkpointToRedis` wire a
- * graph's `attachSnapshotStorage` with an S3- or Redis-backed
- * {@link SnapshotStorageTier}.
- */
-
-import { wallClockNs } from "@graphrefly/pure-ts/core";
-import type { SnapshotStorageTier } from "@graphrefly/pure-ts/extra/storage";
-import type { GraphCheckpointRecord } from "@graphrefly/pure-ts/graph";
-import type { AttachStorageGraphLike } from "./_internal.js";
-import type { S3ClientLike } from "./to-s3.js";
-
-/** Options for {@link checkpointToS3}. */
-export type CheckpointToS3Options = {
-	/** S3 key prefix. Default: `"checkpoints/"`. */
-	prefix?: string;
-	/** Debounce ms on the S3 tier. Default: `500`. */
-	debounceMs?: number;
-	/** Full snapshot compaction interval. Default: `10`. */
-	compactEvery?: number;
-	/**
-	 * Invoked on checkpoint serialize/persist failure. Default: `console.error`
-	 * (F-CKPT, 2026-05-18 smell sweep — a dropped checkpoint write is silent
-	 * data loss; pass an explicit no-op `() => {}` to suppress).
-	 */
-	onError?: (error: unknown) => void;
-};
-
-/**
- * Wires `graph.attachSnapshotStorage()` with an S3-backed tier.
- *
- * @param graph - Graph instance to checkpoint.
- * @param client - S3-compatible client with `putObject()`.
- * @param bucket - S3 bucket name.
- * @param opts - Key prefix, debounce, and compaction options.
- * @returns Dispose handle.
- *
- * @category extra
- */
-export function checkpointToS3(
-	graph: AttachStorageGraphLike,
-	client: S3ClientLike,
-	bucket: string,
-	opts?: CheckpointToS3Options,
-): { dispose(): void } {
-	const {
-		prefix = "checkpoints/",
-		debounceMs = 500,
-		compactEvery = 10,
-		onError = (err: unknown) =>
-			console.error(`checkpointToS3(${bucket}): checkpoint persistence failed`, err),
-	} = opts ?? {};
-	const tier: SnapshotStorageTier<GraphCheckpointRecord> = {
-		name: `s3:${bucket}`,
-		debounceMs,
-		compactEvery,
-		save(record) {
-			const ms = Math.floor(wallClockNs() / 1_000_000);
-			const s3Key = `${prefix}${graph.name}/checkpoint-${ms}.json`;
-			let body: string;
-			try {
-				body = JSON.stringify(record);
-			} catch (err) {
-				onError(err);
-				return;
-			}
-			void client
-				.putObject({
-					Bucket: bucket,
-					Key: s3Key,
-					Body: body,
-					ContentType: "application/json",
-				})
-				.catch((err) => onError(err));
-		},
-		// S3 tier is write-only here — one object per checkpoint timestamp,
-		// no canonical "latest" key for load.
-	};
-	return graph.attachSnapshotStorage([{ snapshot: tier }], {
-		onError: (err: unknown) => onError(err),
-	});
-}
-
-/** Duck-typed Redis client for checkpoint storage. */
-export type RedisCheckpointClientLike = {
-	set(key: string, value: string): Promise<unknown>;
-	get(key: string): Promise<string | null>;
-};
-
-/** Options for {@link checkpointToRedis}. */
-export type CheckpointToRedisOptions = {
-	/** Key prefix. Default: `"graphrefly:checkpoint:"`. */
-	prefix?: string;
-	/** Debounce ms on the Redis tier. Default: `500`. */
-	debounceMs?: number;
-	/** Full snapshot compaction interval. Default: `10`. */
-	compactEvery?: number;
-	/**
-	 * Invoked on checkpoint serialize/persist/load failure. Default:
-	 * `console.error` (F-CKPT, 2026-05-18 smell sweep — a dropped checkpoint
-	 * write or an unparseable stored checkpoint is silent data loss; pass an
-	 * explicit no-op `() => {}` to suppress).
-	 */
-	onError?: (error: unknown) => void;
-};
-
-/**
- * Wires `graph.attachSnapshotStorage()` with a Redis-backed tier.
- *
- * @param graph - Graph instance to checkpoint.
- * @param client - Redis client with `set()`/`get()`.
- * @param opts - Key prefix, debounce, and compaction options.
- * @returns Dispose handle.
- *
- * @category extra
- */
-export function checkpointToRedis(
-	graph: AttachStorageGraphLike,
-	client: RedisCheckpointClientLike,
-	opts?: CheckpointToRedisOptions,
-): { dispose(): void } {
-	const {
-		prefix = "graphrefly:checkpoint:",
-		debounceMs = 500,
-		compactEvery = 10,
-		onError = (err: unknown) =>
-			console.error(`checkpointToRedis(${graph.name}): checkpoint persistence failed`, err),
-	} = opts ?? {};
-	const redisKey = `${prefix}${graph.name}`;
-	const tier: SnapshotStorageTier<GraphCheckpointRecord> = {
-		name: `redis:${redisKey}`,
-		debounceMs,
-		compactEvery,
-		save(record) {
-			let body: string;
-			try {
-				body = JSON.stringify(record);
-			} catch (err) {
-				onError(err);
-				return;
-			}
-			void client.set(redisKey, body).catch((err) => onError(err));
-		},
-		async load() {
-			const raw = await client.get(redisKey);
-			if (raw == null) return undefined;
-			try {
-				return JSON.parse(raw) as GraphCheckpointRecord;
-			} catch (err) {
-				// F-CKPT: an unparseable stored checkpoint is silent data loss
-				// if swallowed — surface it, then fall back to "no checkpoint".
-				onError(err);
-				return undefined;
-			}
-		},
-	};
-	return graph.attachSnapshotStorage([{ snapshot: tier }], {
-		onError: (err: unknown) => onError(err),
-	});
-}
diff --git a/src/base/io/clickhouse-watch.ts b/src/base/io/clickhouse-watch.ts
deleted file mode 100644
index 9d0d1d11..00000000
--- a/src/base/io/clickhouse-watch.ts
+++ /dev/null
@@ -1,104 +0,0 @@
-/**
- * ClickHouse live materialized view IO — `fromClickHouseWatch` polls a query
- * via `fromTimer + switchMap` (reactive timer, switch semantics cancel
- * in-flight queries) and emits one `DATA` per result row per scrape.
- */
-
-import { COMPLETE, ERROR, type Node, node } from "@graphrefly/pure-ts/core";
-import { type AsyncSourceOpts, fromTimer, switchMap } from "@graphrefly/pure-ts/extra";
-import { NS_PER_MS, NS_PER_SEC } from "../resilience/backoff.js";
-
-/** Structured ClickHouse query result row. */
-export type ClickHouseRow = Record<string, unknown>;
-
-/** Duck-typed ClickHouse client. */
-export type ClickHouseClientLike = {
-	query(opts: { query: string; format?: string }): Promise<{
-		json<T = unknown>(): Promise<T[]>;
-	}>;
-};
-
-/** Options for {@link fromClickHouseWatch}. */
-export type FromClickHouseWatchOptions = AsyncSourceOpts & {
-	/** Polling interval in nanoseconds. Default: `5 * NS_PER_SEC` (5s). */
-	intervalNs?: number;
-	/** JSON format to request. Default: `"JSONEachRow"`. */
-	format?: string;
-	/**
-	 * Maximum consecutive query errors before terminating the source. Prevents
-	 * error storms when the database is unavailable. Default: `5`. Set to
-	 * `Infinity` to keep retrying indefinitely.
-	 */
-	maxConsecutiveErrors?: number;
-};
-
-/**
- * ClickHouse live materialized view as a reactive source.
- *
- * Polls a ClickHouse query on a reactive timer interval and emits new/changed rows.
- * Uses a timer-driven approach (not busy-wait polling).
- *
- * @param client - ClickHouse client instance (caller owns connection).
- * @param query - SQL query to execute on each interval.
- * @param opts - Polling interval and format options.
- * @returns `Node<ClickHouseRow>` — one `DATA` per result row per scrape.
- *
- * @example
- * ```ts
- * import { createClient } from "@clickhouse/client";
- * import { fromClickHouseWatch } from "@graphrefly/graphrefly";
- *
- * const client = createClient({ url: "http://localhost:8123" });
- * const rows$ = fromClickHouseWatch(client, "SELECT * FROM errors_mv ORDER BY timestamp DESC LIMIT 100");
- * ```
- *
- * @category extra
- */
-export function fromClickHouseWatch(
-	client: ClickHouseClientLike,
-	query: string,
-	opts?: FromClickHouseWatchOptions,
-): Node<ClickHouseRow> {
-	const {
-		intervalNs = 5 * NS_PER_SEC,
-		format = "JSONEachRow",
-		signal: externalSignal,
-		maxConsecutiveErrors = 1,
-	} = opts ?? {};
-	const intervalMs = Math.ceil(intervalNs / NS_PER_MS);
-	// Circuit breaker shared across switchMap inners.
-	let consecutiveErrors = 0;
-
-	// `fromTimer | switchMap(producer(one-query))` — timer ticks drive a single
-	// query each; switchMap cancels any in-flight inner when the next tick
-	// arrives. First tick at t=0, then every intervalMs.
-	return switchMap(fromTimer(0, { period: intervalMs, signal: externalSignal }), () =>
-		node<ClickHouseRow>([], (_data, a) => {
-			let active = true;
-			const run = async () => {
-				try {
-					const result = await client.query({ query, format });
-					if (!active) return;
-					const rows = await result.json<ClickHouseRow>();
-					if (!active) return;
-					for (const row of rows) a.emit(row);
-					consecutiveErrors = 0;
-					a.down([[COMPLETE]]);
-				} catch (err) {
-					if (!active) return;
-					consecutiveErrors += 1;
-					if (consecutiveErrors >= maxConsecutiveErrors) {
-						a.down([[ERROR, err]]);
-					}
-					// else: swallow transient error; next tick retries.
-				}
-			};
-			void run();
-			return {
-				onDeactivation: () => {
-					active = false;
-				},
-			};
-		}),
-	);
-}
diff --git a/src/base/io/csv.ts b/src/base/io/csv.ts
deleted file mode 100644
index 88eb864b..00000000
--- a/src/base/io/csv.ts
+++ /dev/null
@@ -1,228 +0,0 @@
-/**
- * CSV ingest IO — `fromCSV` reads an `AsyncIterable<string>` of CSV chunks
- * (one node per row), and `csvRows` is the stateful operator variant for
- * existing reactive `Node<string>` upstreams. Both share the local
- * `parseCSVLine` helper so quoted fields and embedded delimiters are handled
- * uniformly.
- */
-
-import { COMPLETE, ERROR, type Node, type NodeOptions, node } from "@graphrefly/pure-ts/core";
-import { type ExtraOpts, sourceOpts } from "./_internal.js";
-
-/** Parsed CSV row. */
-export type CSVRow = Record<string, string>;
-
-/** Options for {@link fromCSV}. */
-export type FromCSVOptions = ExtraOpts & {
-	/** Column delimiter. Default: `","`. */
-	delimiter?: string;
-	/** Whether the first row is a header. Default: `true`. */
-	hasHeader?: boolean;
-	/** Explicit column names (overrides header row). */
-	columns?: string[];
-	/** Custom line parser (e.g. wrapping a library like `csv-parse`). Overrides built-in parser + delimiter. */
-	parseLine?: (line: string) => string[];
-};
-
-/**
- * CSV file/stream ingest for batch replay.
- *
- * Reads a CSV from a `ReadableStream<string>` or an `AsyncIterable<string>` of lines,
- * emitting one `DATA` per row. `COMPLETE` after all rows are emitted.
- *
- * @param source - Async iterable of CSV text chunks (lines or multi-line chunks).
- * @param opts - Delimiter, header, and column options.
- * @returns `Node<CSVRow>` — one `DATA` per parsed row.
- *
- * @example
- * ```ts
- * import { createReadStream } from "node:fs";
- * import { fromCSV } from "@graphrefly/graphrefly";
- *
- * const csv$ = fromCSV(createReadStream("data.csv", "utf-8"));
- * ```
- *
- * @category extra
- */
-export function fromCSV(source: AsyncIterable<string>, opts?: FromCSVOptions): Node<CSVRow> {
-	const {
-		delimiter = ",",
-		hasHeader = true,
-		columns: explicitColumns,
-		parseLine,
-		...rest
-	} = opts ?? {};
-	const parse = parseLine ?? ((line: string) => parseCSVLine(line, delimiter));
-
-	return node<CSVRow>(
-		[],
-		(_data, a) => {
-			let cancelled = false;
-
-			const run = async () => {
-				try {
-					let headers: string[] | undefined = explicitColumns;
-					let buffer = "";
-
-					for await (const chunk of source) {
-						if (cancelled) return;
-						buffer += chunk;
-
-						const lines = buffer.split(/\r?\n/);
-						// Keep last partial line in buffer.
-						buffer = lines.pop() ?? "";
-
-						for (const line of lines) {
-							if (cancelled) return;
-							if (!line.trim()) continue;
-
-							const values = parse(line);
-
-							if (!headers && hasHeader) {
-								headers = values;
-								continue;
-							}
-
-							if (!headers) {
-								headers = values.map((_, i) => `col${i}`);
-							}
-
-							const row: CSVRow = {};
-							for (let i = 0; i < headers.length; i++) {
-								row[headers[i]] = values[i] ?? "";
-							}
-							a.emit(row);
-						}
-					}
-
-					// Process remaining buffer.
-					if (!cancelled && buffer.trim()) {
-						const values = parse(buffer);
-						if (headers) {
-							const row: CSVRow = {};
-							for (let i = 0; i < headers.length; i++) {
-								row[headers[i]] = values[i] ?? "";
-							}
-							a.emit(row);
-						}
-					}
-
-					if (!cancelled) a.down([[COMPLETE]]);
-				} catch (err) {
-					if (!cancelled) a.down([[ERROR, err]]);
-				}
-			};
-
-			void run();
-
-			return {
-				onDeactivation: () => {
-					cancelled = true;
-				},
-			};
-		},
-		sourceOpts(rest),
-	);
-}
-
-/**
- * Stateful CSV parser operator — takes a `Node<string>` emitting raw text
- * chunks (from any source: {@link fromAsyncIter}, {@link fromHTTPStream},
- * WebSocket, file watcher, etc.) and emits one `DATA` per parsed row.
- *
- * Buffers incomplete lines across chunks. Mirrors {@link fromCSV}'s parsing
- * logic without committing to an async-iterable-only input.
- *
- * @example
- * ```ts
- * import { fromHTTPStream, csvRows } from "@graphrefly/graphrefly";
- * const bytes$ = fromHTTPStream("https://example.com/data.csv");
- * const text$ = decodeText(bytes$);   // caller-provided byte→string decoder
- * const rows$ = csvRows(text$, { columns: ["name", "age"] });
- * ```
- *
- * @category extra
- */
-export function csvRows(source: Node<string>, opts?: FromCSVOptions): Node<CSVRow> {
-	const {
-		delimiter = ",",
-		hasHeader = true,
-		columns: explicitColumns,
-		parseLine,
-		...rest
-	} = opts ?? {};
-	const parse = parseLine ?? ((line: string) => parseCSVLine(line, delimiter));
-	// Lock 6.D (Phase 13.6.B): clear parser state on deactivation so
-	// `csvRows` under retry/resubscribe patterns doesn't leak a stale
-	// half-parsed line or sticky header detection from a prior run.
-	let cleanup: { onDeactivation: () => void } | undefined;
-	return node<CSVRow>(
-		[source as Node],
-		(data, a, ctx) => {
-			if (cleanup === undefined) {
-				const store = ctx.store;
-				cleanup = {
-					onDeactivation: () => {
-						delete store.buffer;
-						delete store.headers;
-					},
-				};
-			}
-			const batch0 = data[0];
-			if (batch0 == null || batch0.length === 0) return cleanup;
-			const s = ctx.store as { buffer: string; headers: string[] | undefined };
-			if (typeof s.buffer !== "string") s.buffer = "";
-			if (s.headers === undefined && explicitColumns) s.headers = explicitColumns.slice();
-			for (const chunkRaw of batch0) {
-				s.buffer = s.buffer + (chunkRaw as string);
-				const lines: string[] = s.buffer.split(/\r?\n/);
-				s.buffer = lines.pop() ?? "";
-				for (const line of lines) {
-					if (!line.trim()) continue;
-					const values = parse(line);
-					if (!s.headers && hasHeader) {
-						s.headers = values;
-						continue;
-					}
-					if (!s.headers) s.headers = values.map((_, i) => `col${i}`);
-					const row: CSVRow = {};
-					for (let i = 0; i < s.headers.length; i++) row[s.headers[i]] = values[i] ?? "";
-					a.emit(row);
-				}
-			}
-			return cleanup;
-		},
-		{ describeKind: "derived", ...rest } as NodeOptions<CSVRow>,
-	);
-}
-
-function parseCSVLine(line: string, delimiter: string): string[] {
-	const values: string[] = [];
-	let current = "";
-	let inQuotes = false;
-
-	for (let i = 0; i < line.length; i++) {
-		const ch = line[i];
-		if (inQuotes) {
-			if (ch === '"') {
-				if (line[i + 1] === '"') {
-					current += '"';
-					i++;
-				} else {
-					inQuotes = false;
-				}
-			} else {
-				current += ch;
-			}
-		} else if (ch === '"') {
-			inQuotes = true;
-		} else if (ch === delimiter) {
-			values.push(current);
-			current = "";
-		} else {
-			current += ch;
-		}
-	}
-	values.push(current);
-	return values;
-}
diff --git a/src/base/io/drizzle.ts b/src/base/io/drizzle.ts
deleted file mode 100644
index 01140abb..00000000
--- a/src/base/io/drizzle.ts
+++ /dev/null
@@ -1,82 +0,0 @@
-/**
- * Drizzle adapter (5.2b) — `fromDrizzle` runs `query.execute()` and emits one
- * `DATA` containing the full mapped row array, then `COMPLETE`.
- */
-
-import { COMPLETE, ERROR, type Node, type NodeOptions, node } from "@graphrefly/pure-ts/core";
-import type { ExtraOpts } from "./_internal.js";
-
-/**
- * Duck-typed Drizzle query builder result.
- *
- * Drizzle query builders (e.g. `db.select().from(users)`) expose `.execute()`
- * which returns `Promise<T[]>`. This interface captures that contract without
- * depending on `drizzle-orm`.
- */
-export type DrizzleQueryLike<T = unknown> = {
-	execute(): Promise<T[]>;
-};
-
-/** Options for {@link fromDrizzle}. */
-export type FromDrizzleOptions<T, U = T> = ExtraOpts & {
-	/** Map each row to the desired shape. Default: identity cast. */
-	mapRow?: (row: T) => U;
-};
-
-/**
- * One-shot Drizzle query as a reactive source.
- *
- * Calls `query.execute()`, emits one `DATA` per result row, then `COMPLETE`.
- * Compose with `switchMap` + `fromTimer` for periodic re-query.
- *
- * @param query - Drizzle query builder (e.g. `db.select().from(users).where(...)`).
- * @param opts - Row mapper and node options.
- * @returns `Node<U>` — one `DATA` per row, then `COMPLETE`.
- *
- * @example
- * ```ts
- * import { drizzle } from "drizzle-orm/node-postgres";
- * import { fromDrizzle } from "@graphrefly/graphrefly";
- *
- * const db = drizzle(pool);
- * const rows$ = fromDrizzle(db.select().from(users).where(eq(users.active, true)));
- * ```
- *
- * @category extra
- */
-export function fromDrizzle<T = unknown, U = T>(
-	query: DrizzleQueryLike<T>,
-	opts?: FromDrizzleOptions<T, U>,
-): Node<U[]> {
-	const { mapRow = (r: T) => r as unknown as U, ...rest } = opts ?? {};
-
-	return node<U[]>(
-		[],
-		(_data, a) => {
-			let active = true;
-
-			void query
-				.execute()
-				.then((rows) => {
-					if (!active) return;
-					a.emit(rows.map(mapRow));
-					a.down([[COMPLETE]]);
-				})
-				.catch((err) => {
-					if (!active) return;
-					try {
-						a.down([[ERROR, err instanceof Error ? err : new Error(String(err))]]);
-					} catch {
-						/* node already torn down — swallow */
-					}
-				});
-
-			return {
-				onDeactivation: () => {
-					active = false;
-				},
-			};
-		},
-		{ ...rest, describeKind: "producer", completeWhenDepsComplete: false } as NodeOptions<U[]>,
-	);
-}
diff --git a/src/base/io/http-error.ts b/src/base/io/http-error.ts
deleted file mode 100644
index efc120e1..00000000
--- a/src/base/io/http-error.ts
+++ /dev/null
@@ -1,42 +0,0 @@
-/**
- * HTTP error builder — companion to {@link ./adapters.ts}'s `fromHTTP` /
- * `fromHTTPStream` / `toHTTP`. Pure, zero-dep function that turns a failed
- * `Response` into an `Error` exposing the `{status, headers, message}` shape
- * that `HttpErrorLike` consumers (rate-limit parsers, retry predicates,
- * observability layers) expect.
- *
- * Universal tier — safe for browser and Node. No Node-only imports.
- */
-
-/**
- * Construct an `Error` carrying `status` + `headers` fields from a non-ok
- * `Response`. Reads the body with `resp.text()` for diagnostic context; a
- * body read failure is swallowed (empty string) so the returned error always
- * reflects the original status/statusText at minimum.
- *
- * @param resp - The offending `Response` object.
- * @param provider - Optional prefix (e.g. `"Anthropic"`, `"openai"`) used in
- *   the error message. Defaults to `"HTTP"`.
- * @returns An `Error` whose `message` is `"${provider} API <status>: <statusText>[ — body]"`,
- *   with `status: number` and `headers: Headers` attached.
- *
- * @category extra
- */
-export async function makeHttpError(resp: Response, provider?: string): Promise<Error> {
-	let body: string;
-	try {
-		body = await resp.text();
-	} catch {
-		body = "";
-	}
-	const prefix = provider ?? "HTTP";
-	const err = new Error(
-		`${prefix} API ${resp.status}: ${resp.statusText}${body ? ` — ${body}` : ""}`,
-	) as Error & {
-		status: number;
-		headers: Headers;
-	};
-	err.status = resp.status;
-	err.headers = resp.headers;
-	return err;
-}
diff --git a/src/base/io/http.ts b/src/base/io/http.ts
deleted file mode 100644
index 7fd21b83..00000000
--- a/src/base/io/http.ts
+++ /dev/null
@@ -1,419 +0,0 @@
-/**
- * HTTP IO — `fromHTTP` (one-shot fetch with `withStatus` companion bundle),
- * `toHTTP` (per-record / buffered sink with retry support), `fromHTTPStream`
- * (raw `Uint8Array` byte stream), `fromHTTPPoll` (interval-driven re-fetch).
- *
- * Uses the platform `fetch` API (Node 18+, browsers, Deno, Bun). Timeouts use
- * `AbortController` driven by `setTimeout` per spec §5.10's resilience-operator
- * carve-out.
- */
-
-import {
-	batch,
-	COMPLETE,
-	DATA,
-	ERROR,
-	type Node,
-	node,
-	wallClockNs,
-} from "@graphrefly/pure-ts/core";
-import { type AsyncSourceOpts, fromTimer, switchMap } from "@graphrefly/pure-ts/extra";
-import { NS_PER_MS, NS_PER_SEC } from "../resilience/backoff.js";
-import { type WithStatusBundle, withStatus } from "../resilience/status.js";
-import { type ExtraOpts, sourceOpts } from "./_internal.js";
-import { type ReactiveSinkHandle, reactiveSink, type SinkTransportError } from "./_sink.js";
-
-/**
- * Options for {@link fromHTTP}.
- *
- * @category extra
- */
-export interface FromHTTPOptions extends AsyncSourceOpts {
-	/** HTTP method. Default: `"GET"`. */
-	method?: string;
-	/** Request headers. */
-	headers?: Record<string, string>;
-	/** Request body (for POST/PUT/PATCH). */
-	body?: any;
-	/** Transform the Response before emitting. Default: `response.json()`. */
-	transform?: (response: Response) => any | Promise<any>;
-	/** Request timeout in **nanoseconds**. Default: `30s` (30 * NS_PER_SEC). */
-	timeoutNs?: number;
-	/**
-	 * When `true`, emit `COMPLETE` after the first successful fetch. Useful for
-	 * one-shot semantics where downstream wants to know "no more values ever."
-	 * Default: `false` — the node stays live and replays cached DATA to late
-	 * subscribers via push-on-subscribe (spec §2.2).
-	 */
-	completeAfterFetch?: boolean;
-	/**
-	 * When `true`, trigger a fresh fetch on each new subscriber instead of
-	 * sharing one cached result. Default: `false` — one shared fetch whose
-	 * result is cached and replayed to every subscriber.
-	 */
-	refetchOnSubscribe?: boolean;
-}
-
-/**
- * Result of {@link fromHTTP}: main source plus status, error, and fetch count companions.
- *
- * @category extra
- */
-export type HTTPBundle<T> = WithStatusBundle<T> & {
-	/** Number of successful fetches. */
-	fetchCount: Node<number>;
-	/** Nanosecond wall-clock timestamp of the last successful fetch. */
-	lastUpdated: Node<number>;
-	/**
-	 * `true` after at least one successful fetch; stays `true` across
-	 * resubscribes. Orthogonal to {@link withStatus}'s `active`/`completed`
-	 * lifecycle — use this as the "fetch done" signal under the default
-	 * (cached, stays-live) behavior where `withStatus` never transitions to
-	 * `"completed"` unless `completeAfterFetch: true` is set.
-	 */
-	fetched: Node<boolean>;
-};
-
-/**
- * Creates a one-shot fetch-based HTTP source with lifecycle tracking.
- *
- * @category extra
- */
-export function fromHTTP<T = any>(url: string, opts?: FromHTTPOptions): HTTPBundle<T> {
-	const {
-		method = "GET",
-		headers,
-		body: bodyOpt,
-		transform = (r: Response) => r.json(),
-		timeoutNs = 30 * NS_PER_SEC,
-		signal: externalSignal,
-		completeAfterFetch = false,
-		refetchOnSubscribe = false,
-		...rest
-	} = opts ?? {};
-
-	const fetchCount = node<number>([], { initial: 0, name: `${rest.name ?? "http"}/fetchCount` });
-	const lastUpdated = node<number>([], { initial: 0, name: `${rest.name ?? "http"}/lastUpdated` });
-	const fetched = node<boolean>([], { initial: false, name: `${rest.name ?? "http"}/fetched` });
-	// Closure-owned counter: `fetchCount` is a write-only observable of this
-	// local count. Avoids the `fetchCount.cache + 1` read-modify-write pattern
-	// (P3 audit #6) — the node stays in sync because every write flows through
-	// here.
-	let fetchCountLocal = 0;
-
-	const body =
-		bodyOpt !== undefined
-			? typeof bodyOpt === "string"
-				? bodyOpt
-				: JSON.stringify(bodyOpt)
-			: undefined;
-
-	// Fetch body + lifecycle — shared between the default "one shared fetch"
-	// path and the refetch-on-subscribe resubscribable producer path.
-	const runFetch = (a: {
-		emit: (v: T) => void;
-		down: (msgs: [symbol, ...unknown[]][]) => void;
-	}): (() => void) => {
-		const abort = new AbortController();
-		let active = true;
-
-		if (externalSignal?.aborted) {
-			// Abort already fired before activation — short-circuit with ERROR
-			// and flip `active` so the idempotent cleanup below is coherent.
-			active = false;
-			a.down([[ERROR, externalSignal.reason ?? new Error("Aborted")]]);
-			return () => {};
-		}
-		externalSignal?.addEventListener("abort", () => abort.abort(externalSignal.reason), {
-			once: true,
-		});
-
-		const timeoutId = setTimeout(
-			() => abort.abort(new Error("Request timeout")),
-			Math.ceil(timeoutNs / NS_PER_MS),
-		);
-
-		fetch(url, { method, headers, body, signal: abort.signal })
-			.then(async (res) => {
-				clearTimeout(timeoutId);
-				if (!active) return;
-				if (!res.ok) throw new Error(`HTTP ${res.status}: ${res.statusText}`);
-				const data = await transform(res);
-				if (!active) return;
-				batch(() => {
-					fetchCountLocal += 1;
-					fetchCount.down([[DATA, fetchCountLocal]]);
-					lastUpdated.down([[DATA, wallClockNs()]]);
-					fetched.down([[DATA, true]]);
-					a.emit(data as T);
-				});
-				if (completeAfterFetch) a.down([[COMPLETE]]);
-			})
-			.catch((err) => {
-				clearTimeout(timeoutId);
-				if (!active) return;
-				if (err && (err as Error).name === "AbortError") return;
-				a.down([[ERROR, err]]);
-			});
-
-		return () => {
-			active = false;
-			abort.abort();
-		};
-	};
-
-	const sourceNode = node<T>(
-		[],
-		(_data, a) => ({
-			onDeactivation: runFetch({
-				emit: (v) => a.emit(v),
-				down: (msgs) => a.down(msgs as unknown as [symbol, unknown?][]),
-			}),
-		}),
-		{
-			...sourceOpts(rest),
-			// `resubscribable: true` when refetchOnSubscribe — each new activation
-			// (subscribe after full deactivation) re-runs the producer fn → fresh
-			// fetch. Default (cache-once) stays non-resubscribable: producer runs
-			// once on first activation, cached DATA replays to late subscribers.
-			resubscribable: refetchOnSubscribe,
-		},
-	);
-
-	const tracked = withStatus(sourceNode);
-
-	return {
-		...tracked,
-		fetchCount,
-		lastUpdated,
-		fetched,
-	};
-}
-
-/** Options for {@link toHTTP}. */
-export type ToHTTPOptions<T> = ExtraOpts & {
-	/** HTTP method. Default: `"POST"`. */
-	method?: string;
-	/** Request headers applied to every call. Caller sets Content-Type. */
-	headers?: Record<string, string>;
-	/** Serialize a value to a request body. Default: `JSON.stringify`. */
-	serialize?: (value: T) => string | Uint8Array;
-	/** Optional request timeout in nanoseconds. */
-	timeoutNs?: number;
-	/**
-	 * Format used when `batchSize` / `flushIntervalMs` is set:
-	 * - `"json-array"` — body is `JSON.stringify(batch)`
-	 * - `"ndjson"` — body is newline-delimited JSON.
-	 * Default: `"json-array"`.
-	 */
-	batchFormat?: "json-array" | "ndjson";
-	/** Batch size before auto-flush (buffered mode). */
-	batchSize?: number;
-	/** Flush interval in ms (buffered mode). */
-	flushIntervalMs?: number;
-	/** Retry configuration — same shape as {@link ReactiveSinkRetryOptions}. */
-	retry?: Parameters<typeof reactiveSink<T>>[1]["retry"];
-	onTransportError?: (err: SinkTransportError) => void;
-};
-
-/**
- * HTTP sink — forwards upstream `DATA` values as HTTP requests.
- *
- * Per-record mode (default, no batching knobs): one request per DATA.
- * Buffered mode (`batchSize` / `flushIntervalMs`): one request per chunk,
- * body is JSON-array or NDJSON depending on `batchFormat`.
- *
- * @param source - Upstream node.
- * @param url - Request URL.
- * @param opts - Serialization, batching, retry options.
- * @returns {@link ReactiveSinkHandle}.
- *
- * @category extra
- */
-export function toHTTP<T>(
-	source: Node<T>,
-	url: string,
-	opts?: ToHTTPOptions<T>,
-): ReactiveSinkHandle<T> {
-	const {
-		method = "POST",
-		headers = { "Content-Type": "application/json" },
-		serialize = (v: T) => JSON.stringify(v),
-		timeoutNs,
-		batchFormat = "json-array",
-		batchSize,
-		flushIntervalMs,
-		retry,
-		onTransportError,
-	} = opts ?? {};
-
-	const sendOne = async (body: string | Uint8Array): Promise<void> => {
-		const controller = timeoutNs !== undefined ? new AbortController() : undefined;
-		let timeoutId: ReturnType<typeof setTimeout> | undefined;
-		if (controller && timeoutNs !== undefined) {
-			timeoutId = setTimeout(
-				() => controller.abort(new Error("Request timeout")),
-				Math.ceil(timeoutNs / NS_PER_MS),
-			);
-		}
-		try {
-			const res = await fetch(url, {
-				method,
-				headers,
-				body: body as BodyInit | null | undefined,
-				signal: controller?.signal,
-			});
-			// Drain the response body in every branch — un-drained bodies on
-			// non-ok responses hold the connection open in Node's fetch pool
-			// until GC, which starves the pool during retry storms.
-			const drain = async () => {
-				try {
-					await res.arrayBuffer?.();
-				} catch {
-					/* body already consumed / socket dead — nothing to drain */
-				}
-			};
-			if (!res.ok) {
-				await drain();
-				throw new Error(`HTTP ${res.status}: ${res.statusText}`);
-			}
-			await drain();
-		} finally {
-			if (timeoutId !== undefined) clearTimeout(timeoutId);
-		}
-	};
-
-	const buffered = batchSize !== undefined || flushIntervalMs !== undefined;
-	if (buffered) {
-		// Buffered mode: batchFormat decides the body shape; per-item `serialize`
-		// is only applied for ndjson (line-oriented). json-array format sends the
-		// raw batch through `JSON.stringify` as a single array.
-		return reactiveSink<T>(source, {
-			onTransportError,
-			retry,
-			batchSize,
-			flushIntervalMs,
-			sendBatch: async (chunk) => {
-				let body: string | Uint8Array;
-				if (batchFormat === "ndjson") {
-					body = (chunk as T[])
-						.map((v) => {
-							const s = serialize(v);
-							return typeof s === "string" ? s : new TextDecoder().decode(s);
-						})
-						.join("\n");
-				} else {
-					body = JSON.stringify(chunk);
-				}
-				await sendOne(body);
-			},
-		});
-	}
-
-	return reactiveSink<T>(source, {
-		onTransportError,
-		retry,
-		serialize,
-		send: async (payload) => {
-			await sendOne(payload as string | Uint8Array);
-		},
-	});
-}
-
-/** Options for {@link fromHTTPStream}. */
-export type FromHTTPStreamOptions = ExtraOpts & {
-	method?: string;
-	headers?: Record<string, string>;
-	body?: unknown;
-	signal?: AbortSignal;
-};
-
-/**
- * Streaming HTTP source — emits each chunk from the response body as a
- * `Uint8Array` `DATA`. `COMPLETE` when the stream ends; `ERROR` on non-ok
- * response or fetch failure.
- *
- * Useful for ingesting server-push APIs (LLM streaming, SSE endpoints — pair
- * with {@link fromSSE}, NDJSON endpoints — pair with {@link fromNDJSON}).
- *
- * @category extra
- */
-export function fromHTTPStream(url: string, opts?: FromHTTPStreamOptions): Node<Uint8Array> {
-	const { method = "GET", headers, body: bodyOpt, signal: externalSignal, ...rest } = opts ?? {};
-	return node<Uint8Array>(
-		[],
-		(_data, a) => {
-			let active = true;
-			const abort = new AbortController();
-			if (externalSignal?.aborted) {
-				a.down([[ERROR, externalSignal.reason ?? new Error("Aborted")]]);
-				return { onDeactivation: () => {} };
-			}
-			externalSignal?.addEventListener("abort", () => abort.abort(externalSignal.reason), {
-				once: true,
-			});
-			const body =
-				bodyOpt !== undefined
-					? typeof bodyOpt === "string"
-						? bodyOpt
-						: JSON.stringify(bodyOpt)
-					: undefined;
-
-			const run = async () => {
-				try {
-					const res = await fetch(url, { method, headers, body, signal: abort.signal });
-					if (!active) return;
-					if (!res.ok) throw new Error(`HTTP ${res.status}: ${res.statusText}`);
-					if (!res.body) throw new Error("HTTP response has no body");
-					const reader = res.body.getReader();
-					while (active) {
-						const { value, done } = await reader.read();
-						if (done) break;
-						if (value) a.emit(value);
-					}
-					if (active) a.down([[COMPLETE]]);
-				} catch (err) {
-					if (!active) return;
-					if (err && (err as Error).name === "AbortError") return;
-					a.down([[ERROR, err]]);
-				}
-			};
-			void run();
-			return {
-				onDeactivation: () => {
-					active = false;
-					abort.abort();
-				},
-			};
-		},
-		sourceOpts(rest),
-	);
-}
-
-/** Options for {@link fromHTTPPoll}. */
-export type FromHTTPPollOptions = FromHTTPOptions & {
-	/** Poll interval in milliseconds. Default: `5000`. */
-	intervalMs?: number;
-};
-
-/**
- * Repeatedly-fetching HTTP source — a reactive composition of
- * {@link fromTimer} + {@link switchMap} + {@link fromHTTP} that fetches on an
- * interval and emits the latest response. Previous in-flight fetches are
- * cancelled when a new tick arrives (switch semantics).
- *
- * @example
- * ```ts
- * import { fromHTTPPoll } from "@graphrefly/graphrefly";
- * const health$ = fromHTTPPoll<{ ok: boolean }>("https://example.com/health", { intervalMs: 10_000 });
- * ```
- *
- * @category extra
- */
-export function fromHTTPPoll<T = unknown>(url: string, opts?: FromHTTPPollOptions): Node<T> {
-	const { intervalMs = 5000, ...httpOpts } = opts ?? {};
-	return switchMap(
-		fromTimer(intervalMs, { period: intervalMs }),
-		() => fromHTTP<T>(url, { ...httpOpts, completeAfterFetch: true }).node,
-	);
-}
diff --git a/src/base/io/index.ts b/src/base/io/index.ts
deleted file mode 100644
index 63cee01a..00000000
--- a/src/base/io/index.ts
+++ /dev/null
@@ -1,98 +0,0 @@
-/**
- * Protocol, system, and ingest adapters (roadmap §5.2, §5.2c).
- *
- * Each adapter wraps an external protocol or system as a reactive {@link Node}
- * built on {@link producer} / {@link node} — no second protocol.
- *
- * **Moved from sources.ts:** fromHTTP, fromWebSocket/toWebSocket, fromWebhook,
- * toSSE, fromMCP, fromGitHook.
- *
- * **5.2c:** fromOTel, fromSyslog, fromStatsD, fromPrometheus,
- * fromKafka/toKafka, fromRedisStream/toRedisStream, fromCSV, fromNDJSON,
- * fromClickHouseWatch, fromPulsar/toPulsar, fromNATS/toNATS,
- * fromRabbitMQ/toRabbitMQ.
- *
- * Thin barrel — every adapter lives in a category sub-file:
- * - `_internal.ts` — shared `ExtraOpts` / `sourceOpts` / `SinkHandle` /
- *   `BufferedSinkHandle` / `AdapterHandlers` / `AckableMessage` /
- *   `AttachStorageGraphLike`
- * - `websocket.ts` — `fromWebSocket`, `toWebSocket`, `fromWebSocketReconnect`
- * - `webhook.ts` — `fromWebhook`
- * - `http.ts` — `fromHTTP`, `toHTTP`, `fromHTTPStream`, `fromHTTPPoll`
- * - `sse.ts` — `toSSE`, `toSSEBytes`, `toReadableStream`, `fromSSE`,
- *   `parseSSEStream`
- * - `mcp.ts` — `fromMCP`
- * - `otel.ts` — `fromOTel`
- * - `syslog.ts` — `fromSyslog`, `parseSyslog`
- * - `statsd.ts` — `fromStatsD`, `parseStatsD`
- * - `prometheus.ts` — `fromPrometheus`, `parsePrometheusText`
- * - `kafka.ts` — `fromKafka`, `toKafka`
- * - `redis-stream.ts` — `fromRedisStream`, `toRedisStream`
- * - `csv.ts` — `fromCSV`, `csvRows`
- * - `ndjson.ts` — `fromNDJSON`, `ndjsonRows`
- * - `clickhouse-watch.ts` — `fromClickHouseWatch`
- * - `pulsar.ts` — `fromPulsar`, `toPulsar`
- * - `nats.ts` — `fromNATS`, `toNATS`
- * - `rabbitmq.ts` — `fromRabbitMQ`, `toRabbitMQ`
- * - `to-file.ts` — `toFile` (and shared `FileWriterLike`)
- * - `to-csv.ts` — `toCSV`
- * - `to-clickhouse.ts` — `toClickHouse`
- * - `to-s3.ts` — `toS3` (and shared `S3ClientLike`)
- * - `to-postgres.ts` — `toPostgres`
- * - `to-mongo.ts` — `toMongo`
- * - `to-loki.ts` — `toLoki`
- * - `to-tempo.ts` — `toTempo`
- * - `checkpoint.ts` — `checkpointToS3`, `checkpointToRedis`
- * - `sqlite.ts` — `fromSqlite`, `fromSqliteCursor`, `toSqlite`
- * - `prisma.ts` — `fromPrisma`
- * - `drizzle.ts` — `fromDrizzle`
- * - `kysely.ts` — `fromKysely`
- * - `http-error.ts` — re-export of `../http-error.js`
- * - `sink.ts` — re-export of `../reactive-sink.js`
- *
- * `fromGitHook` and other Node-only ingest adapters live separately in
- * `extra/git-hook.ts` etc. so the universal `extra/index` barrel stays
- * browser-safe (those entries are reached via `extra/node`).
- */
-
-// Shared public re-exports from helpers + reactive-sink. Kept here so the
-// barrel surface still includes `SinkHandle` / `AdapterHandlers` / etc. that
-// historically lived alongside the bodies.
-export type {
-	AckableMessage,
-	AdapterHandlers,
-	BufferedSinkHandle,
-	SinkHandle,
-} from "./_internal.js";
-export type { SinkTransportError } from "./_sink.js";
-
-export * from "./checkpoint.js";
-export * from "./clickhouse-watch.js";
-export * from "./csv.js";
-export * from "./drizzle.js";
-export * from "./http.js";
-export * from "./kafka.js";
-export * from "./kysely.js";
-export * from "./mcp.js";
-export * from "./nats.js";
-export * from "./ndjson.js";
-export * from "./otel.js";
-export * from "./prisma.js";
-export * from "./prometheus.js";
-export * from "./pulsar.js";
-export * from "./rabbitmq.js";
-export * from "./redis-stream.js";
-export * from "./sqlite.js";
-export * from "./sse.js";
-export * from "./statsd.js";
-export * from "./syslog.js";
-export * from "./to-clickhouse.js";
-export * from "./to-csv.js";
-export * from "./to-file.js";
-export * from "./to-loki.js";
-export * from "./to-mongo.js";
-export * from "./to-postgres.js";
-export * from "./to-s3.js";
-export * from "./to-tempo.js";
-export * from "./webhook.js";
-export * from "./websocket.js";
diff --git a/src/base/io/kafka.ts b/src/base/io/kafka.ts
deleted file mode 100644
index d7b73665..00000000
--- a/src/base/io/kafka.ts
+++ /dev/null
@@ -1,190 +0,0 @@
-/**
- * Kafka IO — `fromKafka` (KafkaJS-compatible consumer source) and
- * `toKafka` (producer sink). Compatible with Pulsar via KoP (Kafka-on-Pulsar).
- */
-
-import { ERROR, type Node, node, wallClockNs } from "@graphrefly/pure-ts/core";
-import { type ExtraOpts, sourceOpts } from "./_internal.js";
-import { type ReactiveSinkHandle, reactiveSink, type SinkTransportError } from "./_sink.js";
-
-/** Duck-typed Kafka consumer (compatible with kafkajs, confluent-kafka, Pulsar KoP). */
-export type KafkaConsumerLike = {
-	subscribe(opts: { topic: string; fromBeginning?: boolean }): Promise<void>;
-	run(opts: {
-		eachMessage: (payload: {
-			topic: string;
-			partition: number;
-			message: {
-				key: Buffer | null;
-				value: Buffer | null;
-				headers?: Record<string, Buffer | string | undefined>;
-				offset: string;
-				timestamp: string;
-			};
-		}) => Promise<void>;
-	}): Promise<void>;
-	disconnect(): Promise<void>;
-};
-
-/** Duck-typed Kafka producer. */
-export type KafkaProducerLike = {
-	send(record: {
-		topic: string;
-		messages: Array<{
-			key?: string | Buffer | null;
-			value: string | Buffer | null;
-			headers?: Record<string, string | Buffer>;
-		}>;
-	}): Promise<void>;
-	disconnect(): Promise<void>;
-};
-
-/** Structured Kafka message. */
-export type KafkaMessage<T = unknown> = {
-	topic: string;
-	partition: number;
-	key: string | null;
-	value: T;
-	headers: Record<string, string>;
-	offset: string;
-	timestamp: string;
-	timestampNs: number;
-};
-
-/** Options for {@link fromKafka}. */
-export type FromKafkaOptions = ExtraOpts & {
-	/** Start from beginning of topic. Default: `false`. */
-	fromBeginning?: boolean;
-	/** Deserialize message value. Default: `JSON.parse(buffer.toString())`. */
-	deserialize?: (value: Buffer | null) => unknown;
-};
-
-/**
- * Kafka consumer as a reactive source.
- *
- * Wraps a KafkaJS-compatible consumer. Each message becomes a `DATA` emission.
- * Compatible with Pulsar via KoP (Kafka-on-Pulsar).
- *
- * @param consumer - KafkaJS-compatible consumer instance (caller owns connect/disconnect lifecycle).
- * @param topic - Topic to consume from.
- * @param opts - Deserialization and source options.
- * @returns `Node<KafkaMessage<T>>` — one `DATA` per Kafka message.
- *
- * @example
- * ```ts
- * import { Kafka } from "kafkajs";
- * import { fromKafka } from "@graphrefly/graphrefly";
- *
- * const kafka = new Kafka({ brokers: ["localhost:9092"] });
- * const consumer = kafka.consumer({ groupId: "my-group" });
- * await consumer.connect();
- *
- * const events$ = fromKafka(consumer, "events", { deserialize: (buf) => JSON.parse(buf!.toString()) });
- * ```
- *
- * @category extra
- */
-export function fromKafka<T = unknown>(
-	consumer: KafkaConsumerLike,
-	topic: string,
-	opts?: FromKafkaOptions,
-): Node<KafkaMessage<T>> {
-	const {
-		fromBeginning = false,
-		deserialize = (buf: Buffer | null) => {
-			if (buf === null) return null;
-			try {
-				return JSON.parse(buf.toString());
-			} catch {
-				return buf.toString();
-			}
-		},
-		...rest
-	} = opts ?? {};
-
-	return node<KafkaMessage<T>>(
-		[],
-		(_data, a) => {
-			let active = true;
-
-			const start = async () => {
-				try {
-					await consumer.subscribe({ topic, fromBeginning });
-					await consumer.run({
-						eachMessage: async ({ topic: t, partition, message: msg }) => {
-							if (!active) return;
-							const headers: Record<string, string> = {};
-							if (msg.headers) {
-								for (const [k, v] of Object.entries(msg.headers)) {
-									if (v !== undefined) headers[k] = typeof v === "string" ? v : v.toString();
-								}
-							}
-							a.emit({
-								topic: t,
-								partition,
-								key: msg.key?.toString() ?? null,
-								value: deserialize(msg.value) as T,
-								headers,
-								offset: msg.offset,
-								timestamp: msg.timestamp,
-								timestampNs: wallClockNs(),
-							});
-						},
-					});
-				} catch (err) {
-					if (active) a.down([[ERROR, err]]);
-				}
-			};
-
-			void start();
-
-			return {
-				onDeactivation: () => {
-					active = false;
-				},
-			};
-		},
-		sourceOpts(rest),
-	);
-}
-
-/** Options for {@link toKafka}. */
-export type ToKafkaOptions<T> = ExtraOpts & {
-	/** Serialize value for Kafka. Default: `JSON.stringify`. */
-	serialize?: (value: T) => string | Buffer;
-	/** Extract message key from value. Default: `null` (no key). */
-	keyExtractor?: (value: T) => string | null;
-	/** Called on serialization or send failures. */
-	onTransportError?: (err: SinkTransportError) => void;
-};
-
-/**
- * Kafka producer sink — forwards upstream `DATA` to a Kafka topic.
- *
- * @param source - Upstream node to forward.
- * @param kafkaProducer - KafkaJS-compatible producer instance.
- * @param topic - Target topic.
- * @param opts - Serialization and key extraction options.
- * @returns Unsubscribe function.
- *
- * @category extra
- */
-export function toKafka<T>(
-	source: Node<T>,
-	kafkaProducer: KafkaProducerLike,
-	topic: string,
-	opts?: ToKafkaOptions<T>,
-): ReactiveSinkHandle<T> {
-	const { serialize = (v: T) => JSON.stringify(v), keyExtractor, onTransportError } = opts ?? {};
-	return reactiveSink<T>(source, {
-		onTransportError,
-		send: async (value) => {
-			const key = keyExtractor?.(value) ?? null;
-			const serialized = serialize(value);
-			await kafkaProducer.send({
-				topic,
-				messages: [{ key, value: Buffer.from(serialized as string) }],
-			});
-		},
-	});
-}
diff --git a/src/base/io/kysely.ts b/src/base/io/kysely.ts
deleted file mode 100644
index c60e9e49..00000000
--- a/src/base/io/kysely.ts
+++ /dev/null
@@ -1,81 +0,0 @@
-/**
- * Kysely adapter (5.2b) — `fromKysely` runs `query.execute()` and emits one
- * `DATA` containing the full mapped row array, then `COMPLETE`.
- */
-
-import { COMPLETE, ERROR, type Node, type NodeOptions, node } from "@graphrefly/pure-ts/core";
-import type { ExtraOpts } from "./_internal.js";
-
-/**
- * Duck-typed Kysely query builder result.
- *
- * Kysely query builders expose `.execute()` which returns `Promise<T[]>`.
- * This interface captures that contract without depending on `kysely`.
- */
-export type KyselyQueryLike<T = unknown> = {
-	execute(): Promise<T[]>;
-};
-
-/** Options for {@link fromKysely}. */
-export type FromKyselyOptions<T, U = T> = ExtraOpts & {
-	/** Map each row to the desired shape. Default: identity cast. */
-	mapRow?: (row: T) => U;
-};
-
-/**
- * One-shot Kysely query as a reactive source.
- *
- * Calls `query.execute()`, emits one `DATA` per result row, then `COMPLETE`.
- * Compose with `switchMap` + `fromTimer` for periodic re-query.
- *
- * @param query - Kysely query builder (e.g. `db.selectFrom("users").selectAll()`).
- * @param opts - Row mapper and node options.
- * @returns `Node<U>` — one `DATA` per row, then `COMPLETE`.
- *
- * @example
- * ```ts
- * import { Kysely, PostgresDialect } from "kysely";
- * import { fromKysely } from "@graphrefly/graphrefly";
- *
- * const db = new Kysely<DB>({ dialect: new PostgresDialect({ pool }) });
- * const rows$ = fromKysely(db.selectFrom("users").selectAll().where("active", "=", true));
- * ```
- *
- * @category extra
- */
-export function fromKysely<T = unknown, U = T>(
-	query: KyselyQueryLike<T>,
-	opts?: FromKyselyOptions<T, U>,
-): Node<U[]> {
-	const { mapRow = (r: T) => r as unknown as U, ...rest } = opts ?? {};
-
-	return node<U[]>(
-		[],
-		(_data, a) => {
-			let active = true;
-
-			void query
-				.execute()
-				.then((rows) => {
-					if (!active) return;
-					a.emit(rows.map(mapRow));
-					a.down([[COMPLETE]]);
-				})
-				.catch((err) => {
-					if (!active) return;
-					try {
-						a.down([[ERROR, err instanceof Error ? err : new Error(String(err))]]);
-					} catch {
-						/* node already torn down — swallow */
-					}
-				});
-
-			return {
-				onDeactivation: () => {
-					active = false;
-				},
-			};
-		},
-		{ ...rest, describeKind: "producer", completeWhenDepsComplete: false } as NodeOptions<U[]>,
-	);
-}
diff --git a/src/base/io/mcp.ts b/src/base/io/mcp.ts
deleted file mode 100644
index 09dae0c5..00000000
--- a/src/base/io/mcp.ts
+++ /dev/null
@@ -1,39 +0,0 @@
-/**
- * MCP (Model Context Protocol) IO — `fromMCP` wraps an MCP client's
- * notification surface as a reactive source via `externalProducer`.
- */
-
-import type { Node } from "@graphrefly/pure-ts/core";
-import { externalProducer } from "../composition/external-register.js";
-import type { ExtraOpts } from "./_internal.js";
-
-/**
- * Duck-typed MCP (Model Context Protocol) client — only the notification
- * registration surface is required so callers are not coupled to a specific SDK.
- */
-export type MCPClientLike = {
-	setNotificationHandler(method: string, handler: (notification: unknown) => void): void;
-};
-
-/** Options for {@link fromMCP}. */
-export type FromMCPOptions = ExtraOpts & {
-	/** MCP notification method to subscribe to. Default `"notifications/message"`. */
-	method?: string;
-	onDisconnect?: (cb: (err?: unknown) => void) => void;
-};
-
-/**
- * Wraps an MCP client's server-push notifications as a reactive source.
- *
- * @category extra
- */
-export function fromMCP<T = unknown>(client: MCPClientLike, opts?: FromMCPOptions): Node<T> {
-	const { method = "notifications/message", onDisconnect, ...rest } = opts ?? {};
-	return externalProducer<T>(({ emit, error }) => {
-		client.setNotificationHandler(method, (notification) => emit(notification as T));
-		onDisconnect?.((err?: unknown) => error(err ?? new Error("MCP client disconnected")));
-		// MCP SDKs do not expose handler deregistration — replace with a no-op
-		// on teardown. Caller owns the client lifecycle for full cleanup.
-		return () => client.setNotificationHandler(method, () => {});
-	}, rest);
-}
diff --git a/src/base/io/nats.ts b/src/base/io/nats.ts
deleted file mode 100644
index 77d5f898..00000000
--- a/src/base/io/nats.ts
+++ /dev/null
@@ -1,168 +0,0 @@
-/**
- * NATS IO — `fromNATS` (subject-subscription consumer source) and `toNATS`
- * (publish sink). Compatible with `nats.js`-style clients.
- */
-
-import { COMPLETE, ERROR, type Node, node, wallClockNs } from "@graphrefly/pure-ts/core";
-import { type ExtraOpts, sourceOpts } from "./_internal.js";
-import { type ReactiveSinkHandle, reactiveSink, type SinkTransportError } from "./_sink.js";
-
-/** Duck-typed NATS subscription (compatible with nats.js). */
-export type NATSSubscriptionLike = AsyncIterable<{
-	subject: string;
-	data: Uint8Array;
-	headers?: { get(key: string): string; keys(): string[] };
-	reply?: string;
-	sid: number;
-}>;
-
-/** Duck-typed NATS client (compatible with nats.js). */
-export type NATSClientLike = {
-	subscribe(subject: string, opts?: { queue?: string }): NATSSubscriptionLike;
-	publish(subject: string, data?: Uint8Array, opts?: { headers?: unknown; reply?: string }): void;
-	drain(): Promise<void>;
-};
-
-/** Structured NATS message. */
-export type NATSMessage<T = unknown> = {
-	subject: string;
-	data: T;
-	headers: Record<string, string>;
-	reply: string | undefined;
-	sid: number;
-	timestampNs: number;
-};
-
-/** Options for {@link fromNATS}. */
-export type FromNATSOptions = ExtraOpts & {
-	/** Queue group name for load balancing. */
-	queue?: string;
-	/** Deserialize message data. Default: `JSON.parse(textDecoder.decode(data))`. */
-	deserialize?: (data: Uint8Array) => unknown;
-};
-
-/**
- * NATS consumer as a reactive source.
- *
- * Wraps a `nats.js`-compatible client subscription. Each message becomes a `DATA` emission.
- *
- * @param client - NATS client instance (caller owns connect/drain lifecycle).
- * @param subject - Subject to subscribe to (supports wildcards).
- * @param opts - Queue group, deserialization, and source options.
- * @returns `Node<NATSMessage<T>>` — one `DATA` per NATS message.
- *
- * @remarks
- * Teardown sets an internal flag but cannot break the async iterator. The loop
- * exits on the next message or when the subscription is drained/unsubscribed
- * externally. Call `client.drain()` after unsubscribing for prompt cleanup.
- *
- * @example
- * ```ts
- * import { connect } from "nats";
- * import { fromNATS } from "@graphrefly/graphrefly";
- *
- * const nc = await connect({ servers: "localhost:4222" });
- * const events$ = fromNATS(nc, "events.>");
- * ```
- *
- * @category extra
- */
-export function fromNATS<T = unknown>(
-	client: NATSClientLike,
-	subject: string,
-	opts?: FromNATSOptions,
-): Node<NATSMessage<T>> {
-	const decoder = new TextDecoder();
-	const {
-		queue,
-		deserialize = (data: Uint8Array) => {
-			const text = decoder.decode(data);
-			try {
-				return JSON.parse(text);
-			} catch {
-				return text;
-			}
-		},
-		...rest
-	} = opts ?? {};
-
-	return node<NATSMessage<T>>(
-		[],
-		(_data, a) => {
-			let active = true;
-			const sub = client.subscribe(subject, queue ? { queue } : undefined);
-
-			const loop = async () => {
-				try {
-					for await (const msg of sub) {
-						if (!active) return;
-						const headers: Record<string, string> = {};
-						if (msg.headers) {
-							for (const k of msg.headers.keys()) {
-								headers[k] = msg.headers.get(k);
-							}
-						}
-						a.emit({
-							subject: msg.subject,
-							data: deserialize(msg.data) as T,
-							headers,
-							reply: msg.reply,
-							sid: msg.sid,
-							timestampNs: wallClockNs(),
-						});
-					}
-					// Subscription closed (drain or unsubscribe) — complete.
-					if (active) a.down([[COMPLETE]]);
-				} catch (err) {
-					if (active) a.down([[ERROR, err]]);
-				}
-			};
-
-			void loop();
-
-			return {
-				onDeactivation: () => {
-					active = false;
-				},
-			};
-		},
-		sourceOpts(rest),
-	);
-}
-
-/** Options for {@link toNATS}. */
-export type ToNATSOptions<T> = ExtraOpts & {
-	/** Serialize value for NATS. Default: `JSON.stringify` → Uint8Array. */
-	serialize?: (value: T) => Uint8Array;
-	/** Called on serialization failures. */
-	onTransportError?: (err: SinkTransportError) => void;
-};
-
-/**
- * NATS publisher sink — forwards upstream `DATA` to a NATS subject.
- *
- * @param source - Upstream node to forward.
- * @param client - NATS client instance.
- * @param subject - Target subject.
- * @param opts - Serialization options.
- * @returns Unsubscribe function.
- *
- * @category extra
- */
-export function toNATS<T>(
-	source: Node<T>,
-	client: NATSClientLike,
-	subject: string,
-	opts?: ToNATSOptions<T>,
-): ReactiveSinkHandle<T> {
-	const encoder = new TextEncoder();
-	const { serialize = (v: T) => encoder.encode(JSON.stringify(v)), onTransportError } = opts ?? {};
-	return reactiveSink<T>(source, {
-		onTransportError,
-		send: (value) => {
-			// NATS publish is synchronous; wrap in a resolved Promise for the
-			// reactiveSink transport boundary.
-			client.publish(subject, serialize(value));
-		},
-	});
-}
diff --git a/src/base/io/ndjson.ts b/src/base/io/ndjson.ts
deleted file mode 100644
index 101ed29b..00000000
--- a/src/base/io/ndjson.ts
+++ /dev/null
@@ -1,129 +0,0 @@
-/**
- * NDJSON (newline-delimited JSON) IO — `fromNDJSON` reads an
- * `AsyncIterable<string>` of NDJSON chunks (one node per line) and
- * `ndjsonRows` is the stateful operator variant for existing reactive
- * `Node<string>` upstreams.
- */
-
-import { COMPLETE, ERROR, type Node, type NodeOptions, node } from "@graphrefly/pure-ts/core";
-import { type ExtraOpts, sourceOpts } from "./_internal.js";
-
-/**
- * Stateful NDJSON parser operator — takes a `Node<string>` of raw text chunks
- * and emits one `DATA` per parsed JSON object. Buffers partial lines across
- * chunks.
- *
- * @category extra
- */
-export function ndjsonRows<T = unknown>(source: Node<string>, opts?: ExtraOpts): Node<T> {
-	// Lock 6.D (Phase 13.6.B): clear parser buffer on deactivation so a
-	// resubscribed operator doesn't bleed a half-line from a prior run.
-	let cleanup: { onDeactivation: () => void } | undefined;
-	return node<T>(
-		[source as Node],
-		(data, a, ctx) => {
-			if (cleanup === undefined) {
-				const store = ctx.store;
-				cleanup = {
-					onDeactivation: () => {
-						delete store.buffer;
-					},
-				};
-			}
-			const batch0 = data[0];
-			if (batch0 == null || batch0.length === 0) return cleanup;
-			const s = ctx.store as { buffer: string };
-			if (typeof s.buffer !== "string") s.buffer = "";
-			for (const chunkRaw of batch0) {
-				s.buffer = s.buffer + (chunkRaw as string);
-				const lines: string[] = s.buffer.split(/\r?\n/);
-				s.buffer = lines.pop() ?? "";
-				for (const line of lines) {
-					if (!line.trim()) continue;
-					try {
-						a.emit(JSON.parse(line) as T);
-					} catch (err) {
-						a.down([[ERROR, err]]);
-						return cleanup;
-					}
-				}
-			}
-			return cleanup;
-		},
-		{ describeKind: "derived", ...(opts ?? {}) } as NodeOptions<T>,
-	);
-}
-
-/** Options for {@link fromNDJSON}. */
-export type FromNDJSONOptions = ExtraOpts & {};
-
-/**
- * Newline-delimited JSON stream ingest for batch replay.
- *
- * Reads an async iterable of text chunks, splits by newline, parses each line
- * as JSON, and emits one `DATA` per parsed object. `COMPLETE` after stream ends.
- *
- * @param source - Async iterable of NDJSON text chunks.
- * @param opts - Optional producer options.
- * @returns `Node<T>` — one `DATA` per JSON line.
- *
- * @example
- * ```ts
- * import { createReadStream } from "node:fs";
- * import { fromNDJSON } from "@graphrefly/graphrefly";
- *
- * const logs$ = fromNDJSON(createReadStream("logs.ndjson", "utf-8"));
- * ```
- *
- * @category extra
- */
-export function fromNDJSON<T = unknown>(
-	source: AsyncIterable<string>,
-	opts?: FromNDJSONOptions,
-): Node<T> {
-	return node<T>(
-		[],
-		(_data, a) => {
-			let cancelled = false;
-
-			const run = async () => {
-				try {
-					let buffer = "";
-
-					for await (const chunk of source) {
-						if (cancelled) return;
-						buffer += chunk;
-
-						const lines = buffer.split(/\r?\n/);
-						buffer = lines.pop() ?? "";
-
-						for (const line of lines) {
-							if (cancelled) return;
-							const trimmed = line.trim();
-							if (!trimmed) continue;
-							a.emit(JSON.parse(trimmed) as T);
-						}
-					}
-
-					// Process remaining buffer.
-					if (!cancelled && buffer.trim()) {
-						a.emit(JSON.parse(buffer.trim()) as T);
-					}
-
-					if (!cancelled) a.down([[COMPLETE]]);
-				} catch (err) {
-					if (!cancelled) a.down([[ERROR, err]]);
-				}
-			};
-
-			void run();
-
-			return {
-				onDeactivation: () => {
-					cancelled = true;
-				},
-			};
-		},
-		sourceOpts(opts),
-	);
-}
diff --git a/src/base/io/otel.ts b/src/base/io/otel.ts
deleted file mode 100644
index 1b4d945b..00000000
--- a/src/base/io/otel.ts
+++ /dev/null
@@ -1,125 +0,0 @@
-/**
- * OpenTelemetry (OTLP/HTTP) IO — `fromOTel` exposes traces/metrics/logs as
- * three reactive nodes via `externalBundle`. The caller owns the HTTP server
- * and wires the registrar callback to OTLP routes.
- */
-
-import type { Node } from "@graphrefly/pure-ts/core";
-import { batch } from "@graphrefly/pure-ts/core";
-import { type BundleTriad, externalBundle } from "../composition/external-register.js";
-import type { ExtraOpts } from "./_internal.js";
-
-/** Structured OTel span. */
-export type OTelSpan = {
-	traceId: string;
-	spanId: string;
-	operationName: string;
-	serviceName: string;
-	startTimeNs: number;
-	endTimeNs: number;
-	status: "OK" | "ERROR" | "UNSET";
-	attributes: Record<string, unknown>;
-	events: Array<{ name: string; timestampNs: number; attributes?: Record<string, unknown> }>;
-};
-
-/** Structured OTel metric data point. */
-export type OTelMetric = {
-	name: string;
-	description?: string;
-	unit?: string;
-	type: "gauge" | "sum" | "histogram" | "summary";
-	value: number;
-	attributes: Record<string, unknown>;
-	timestampNs: number;
-};
-
-/** Structured OTel log record. */
-export type OTelLog = {
-	timestampNs: number;
-	severityNumber?: number;
-	severityText?: string;
-	body: unknown;
-	attributes: Record<string, unknown>;
-	traceId?: string;
-	spanId?: string;
-};
-
-/** Registration callback for the OTLP/HTTP receiver. */
-export type OTelRegister = (handlers: {
-	onTraces: (spans: OTelSpan[]) => void;
-	onMetrics: (metrics: OTelMetric[]) => void;
-	onLogs: (logs: OTelLog[]) => void;
-	onError: (err: unknown) => void;
-}) => (() => void) | undefined;
-
-/** Options for {@link fromOTel}. */
-export type FromOTelOptions = ExtraOpts & {};
-
-/** Bundle returned by {@link fromOTel}. */
-export type OTelBundle = {
-	traces: Node<OTelSpan>;
-	metrics: Node<OTelMetric>;
-	logs: Node<OTelLog>;
-	/** Unconditional teardown — calls the registrar's cleanup and fires COMPLETE on every channel. */
-	dispose(): void;
-};
-
-/**
- * OTLP/HTTP receiver — accepts traces, metrics, and logs as separate reactive nodes.
- *
- * The caller owns the HTTP server. `fromOTel` receives a `register` callback that
- * wires OTLP POST endpoints to the three signal handlers. Each signal type gets
- * its own `Node` so downstream can subscribe selectively.
- *
- * @param register - Wires OTLP HTTP routes to `onTraces`, `onMetrics`, `onLogs` handlers.
- * @param opts - Optional producer options.
- * @returns {@link OTelBundle} — `{ traces, metrics, logs }` nodes.
- *
- * @example
- * ```ts
- * import express from "express";
- * import { fromOTel } from "@graphrefly/graphrefly";
- *
- * const app = express();
- * app.use(express.json());
- *
- * const otel = fromOTel(({ onTraces, onMetrics, onLogs }) => {
- *   app.post("/v1/traces", (req, res) => { onTraces(req.body.resourceSpans ?? []); res.sendStatus(200); });
- *   app.post("/v1/metrics", (req, res) => { onMetrics(req.body.resourceMetrics ?? []); res.sendStatus(200); });
- *   app.post("/v1/logs", (req, res) => { onLogs(req.body.resourceLogs ?? []); res.sendStatus(200); });
- *   return () => {};
- * });
- * ```
- *
- * @category extra
- */
-export function fromOTel(register: OTelRegister, opts?: FromOTelOptions): OTelBundle {
-	type OTelChannels = { traces: OTelSpan; metrics: OTelMetric; logs: OTelLog };
-	const nodes = externalBundle<OTelChannels>(
-		({ traces, metrics, logs, error }: BundleTriad<OTelChannels>) => {
-			return (
-				register({
-					onTraces: (spans) => {
-						batch(() => {
-							for (const s of spans) traces(s);
-						});
-					},
-					onMetrics: (ms) => {
-						batch(() => {
-							for (const m of ms) metrics(m);
-						});
-					},
-					onLogs: (ls) => {
-						batch(() => {
-							for (const l of ls) logs(l);
-						});
-					},
-					onError: error,
-				}) ?? undefined
-			);
-		},
-		["traces", "metrics", "logs"],
-		opts?.name ? { name: opts.name } : undefined,
-	);
-	return nodes;
-}
diff --git a/src/base/io/prisma.ts b/src/base/io/prisma.ts
deleted file mode 100644
index b517ab90..00000000
--- a/src/base/io/prisma.ts
+++ /dev/null
@@ -1,85 +0,0 @@
-/**
- * Prisma adapter (5.2b) — `fromPrisma` runs `model.findMany(args)` and emits
- * one `DATA` containing the full mapped row array, then `COMPLETE`.
- */
-
-import { COMPLETE, ERROR, type Node, type NodeOptions, node } from "@graphrefly/pure-ts/core";
-import type { ExtraOpts } from "./_internal.js";
-
-/**
- * Duck-typed Prisma model delegate.
- *
- * Compatible with any Prisma model's `findMany` method (e.g. `prisma.user`).
- * The consumer passes the model delegate directly — no dependency on `@prisma/client`.
- */
-export type PrismaModelLike<T = unknown> = {
-	findMany(args?: unknown): Promise<T[]>;
-};
-
-/** Options for {@link fromPrisma}. */
-export type FromPrismaOptions<T, U = T> = ExtraOpts & {
-	/** Prisma `findMany` args (where, orderBy, select, include, take, skip, etc.). */
-	args?: unknown;
-	/** Map each row to the desired shape. Default: identity cast. */
-	mapRow?: (row: T) => U;
-};
-
-/**
- * One-shot Prisma query as a reactive source.
- *
- * Calls `model.findMany(args)`, emits one `DATA` per result row, then `COMPLETE`.
- * Compose with `switchMap` + `fromTimer` for periodic re-query.
- *
- * @param model - Prisma model delegate (e.g. `prisma.user`).
- * @param opts - `findMany` args, row mapper, and node options.
- * @returns `Node<U>` — one `DATA` per row, then `COMPLETE`.
- *
- * @example
- * ```ts
- * import { PrismaClient } from "@prisma/client";
- * import { fromPrisma } from "@graphrefly/graphrefly";
- *
- * const prisma = new PrismaClient();
- * const activeUsers = fromPrisma(prisma.user, {
- *   args: { where: { active: true } },
- * });
- * ```
- *
- * @category extra
- */
-export function fromPrisma<T = unknown, U = T>(
-	model: PrismaModelLike<T>,
-	opts?: FromPrismaOptions<T, U>,
-): Node<U[]> {
-	const { args, mapRow = (r: T) => r as unknown as U, ...rest } = opts ?? {};
-
-	return node<U[]>(
-		[],
-		(_data, a) => {
-			let active = true;
-
-			void model
-				.findMany(args)
-				.then((rows) => {
-					if (!active) return;
-					a.emit(rows.map(mapRow));
-					a.down([[COMPLETE]]);
-				})
-				.catch((err) => {
-					if (!active) return;
-					try {
-						a.down([[ERROR, err instanceof Error ? err : new Error(String(err))]]);
-					} catch {
-						/* node already torn down — swallow */
-					}
-				});
-
-			return {
-				onDeactivation: () => {
-					active = false;
-				},
-			};
-		},
-		{ ...rest, describeKind: "producer", completeWhenDepsComplete: false } as NodeOptions<U[]>,
-	);
-}
diff --git a/src/base/io/prometheus.ts b/src/base/io/prometheus.ts
deleted file mode 100644
index 4e3acbe3..00000000
--- a/src/base/io/prometheus.ts
+++ /dev/null
@@ -1,208 +0,0 @@
-/**
- * Prometheus scrape IO — `fromPrometheus` polls a `/metrics` endpoint via
- * `fromTimer + switchMap` (reactive timer, not bare `setInterval`) and emits
- * one `DATA` per parsed metric per scrape. `parsePrometheusText` exposes the
- * exposition-format parser as a pure helper.
- */
-
-import { COMPLETE, ERROR, type Node, node, wallClockNs } from "@graphrefly/pure-ts/core";
-import type { AsyncSourceOpts } from "@graphrefly/pure-ts/extra";
-import { fromTimer, switchMap } from "@graphrefly/pure-ts/extra";
-import { NS_PER_MS, NS_PER_SEC } from "../resilience/backoff.js";
-
-/** Parsed Prometheus metric. */
-export type PrometheusMetric = {
-	name: string;
-	labels: Record<string, string>;
-	value: number;
-	timestampMs?: number;
-	type?: "counter" | "gauge" | "histogram" | "summary" | "untyped";
-	help?: string;
-	timestampNs: number;
-};
-
-/** Options for {@link fromPrometheus}. */
-export type FromPrometheusOptions = AsyncSourceOpts & {
-	/** Scrape interval in nanoseconds. Default `15 * NS_PER_SEC` (15s). */
-	intervalNs?: number;
-	/** Request headers for the scrape. */
-	headers?: Record<string, string>;
-	/** Request timeout in nanoseconds. Default `10 * NS_PER_SEC` (10s). */
-	timeoutNs?: number;
-	/**
-	 * Maximum consecutive scrape errors before terminating the source. Prevents
-	 * error storms when the endpoint is down. Default: `1` (terminate on first error — preserves pre-switchMap back-compat). Raise it (or set `Infinity`)
-	 * to keep retrying indefinitely.
-	 */
-	maxConsecutiveErrors?: number;
-};
-
-/**
- * Scrapes a Prometheus `/metrics` endpoint on a reactive timer interval.
- *
- * Each scrape parses the exposition format and emits one `DATA` per metric line.
- * Uses `fromTimer` semantics internally (reactive timer source, not polling).
- *
- * @param endpoint - URL of the Prometheus metrics endpoint.
- * @param opts - Scrape interval, headers, timeout.
- * @returns `Node<PrometheusMetric>` — one `DATA` per metric per scrape.
- *
- * @example
- * ```ts
- * import { fromPrometheus } from "@graphrefly/graphrefly";
- *
- * const prom$ = fromPrometheus("http://localhost:9090/metrics", { intervalNs: 30 * NS_PER_SEC });
- * ```
- *
- * @category extra
- */
-export function fromPrometheus(
-	endpoint: string,
-	opts?: FromPrometheusOptions,
-): Node<PrometheusMetric> {
-	const {
-		intervalNs = 15 * NS_PER_SEC,
-		headers,
-		timeoutNs = 10 * NS_PER_SEC,
-		signal: externalSignal,
-		maxConsecutiveErrors = 1,
-	} = opts ?? {};
-	const intervalMs = Math.ceil(intervalNs / NS_PER_MS);
-	// Circuit breaker shared across switchMap inners — resets on any successful
-	// scrape, trips when consecutive errors hit the cap.
-	let consecutiveErrors = 0;
-
-	// Timer drives scrapes: first tick at t=0, then every intervalMs. Each tick
-	// switches to a fresh inner producer that does one scrape and completes —
-	// switchMap cancels any in-flight scrape when the next tick arrives.
-	return switchMap(fromTimer(0, { period: intervalMs, signal: externalSignal }), () =>
-		node<PrometheusMetric>([], (_data, a) => {
-			let active = true;
-			const abort = new AbortController();
-			const timeoutId = setTimeout(
-				() => abort.abort(new Error("Scrape timeout")),
-				Math.ceil(timeoutNs / NS_PER_MS),
-			);
-			const run = async () => {
-				try {
-					const res = await fetch(endpoint, {
-						headers: { Accept: "text/plain", ...headers },
-						signal: abort.signal,
-					});
-					clearTimeout(timeoutId);
-					if (!active) return;
-					if (!res.ok) throw new Error(`Prometheus scrape ${res.status}: ${res.statusText}`);
-					const text = await res.text();
-					if (!active) return;
-					const metrics = parsePrometheusText(text);
-					for (const m of metrics) a.emit(m);
-					consecutiveErrors = 0;
-					a.down([[COMPLETE]]);
-				} catch (err) {
-					clearTimeout(timeoutId);
-					if (!active) return;
-					if (err instanceof Error && err.name === "AbortError") return;
-					consecutiveErrors += 1;
-					if (consecutiveErrors >= maxConsecutiveErrors) {
-						a.down([[ERROR, err]]);
-					}
-					// else: swallow transient error; next tick retries.
-				}
-			};
-			void run();
-			return {
-				onDeactivation: () => {
-					active = false;
-					clearTimeout(timeoutId);
-					abort.abort();
-				},
-			};
-		}),
-	);
-}
-
-/**
- * Parses Prometheus exposition format text into structured metrics.
- *
- * @category extra
- */
-export function parsePrometheusText(text: string): PrometheusMetric[] {
-	const results: PrometheusMetric[] = [];
-	const types = new Map<string, string>();
-	const helps = new Map<string, string>();
-
-	for (const rawLine of text.split("\n")) {
-		const line = rawLine.trim();
-		if (!line) continue;
-
-		if (line.startsWith("# TYPE ")) {
-			const rest = line.slice(7);
-			const spaceIdx = rest.indexOf(" ");
-			if (spaceIdx > 0) {
-				types.set(rest.slice(0, spaceIdx), rest.slice(spaceIdx + 1).trim());
-			}
-			continue;
-		}
-		if (line.startsWith("# HELP ")) {
-			const rest = line.slice(7);
-			const spaceIdx = rest.indexOf(" ");
-			if (spaceIdx > 0) {
-				helps.set(rest.slice(0, spaceIdx), rest.slice(spaceIdx + 1).trim());
-			}
-			continue;
-		}
-		if (line.startsWith("#")) continue;
-
-		// metric_name{label="value"} 123 timestamp?
-		let name: string;
-		let labels: Record<string, string> = {};
-		let valueStr: string;
-		let tsStr: string | undefined;
-
-		const braceIdx = line.indexOf("{");
-		if (braceIdx >= 0) {
-			name = line.slice(0, braceIdx);
-			const closeBrace = line.indexOf("}", braceIdx);
-			if (closeBrace < 0) continue;
-			const labelStr = line.slice(braceIdx + 1, closeBrace);
-			labels = parsePrometheusLabels(labelStr);
-			const after = line
-				.slice(closeBrace + 1)
-				.trim()
-				.split(/\s+/);
-			valueStr = after[0] ?? "";
-			tsStr = after[1];
-		} else {
-			const parts = line.split(/\s+/);
-			name = parts[0] ?? "";
-			valueStr = parts[1] ?? "";
-			tsStr = parts[2];
-		}
-
-		if (!name || !valueStr) continue;
-
-		const baseName = name.replace(/(_total|_count|_sum|_bucket|_created|_info)$/, "");
-		results.push({
-			name,
-			labels,
-			value: Number(valueStr),
-			timestampMs: tsStr ? Number(tsStr) : undefined,
-			type: (types.get(baseName) ?? types.get(name)) as PrometheusMetric["type"],
-			help: helps.get(baseName) ?? helps.get(name),
-			timestampNs: wallClockNs(),
-		});
-	}
-
-	return results;
-}
-
-function parsePrometheusLabels(str: string): Record<string, string> {
-	const labels: Record<string, string> = {};
-	const re = /(\w+)="((?:[^"\\]|\\.)*)"/g;
-	let m: RegExpExecArray | null = re.exec(str);
-	while (m !== null) {
-		labels[m[1]] = m[2].replace(/\\(.)/g, "$1");
-		m = re.exec(str);
-	}
-	return labels;
-}
diff --git a/src/base/io/pulsar.ts b/src/base/io/pulsar.ts
deleted file mode 100644
index 189dd15f..00000000
--- a/src/base/io/pulsar.ts
+++ /dev/null
@@ -1,241 +0,0 @@
-/**
- * Apache Pulsar IO — `fromPulsar` (native-client consumer source with optional
- * manual ack via {@link AckableMessage} envelopes) and `toPulsar` (producer
- * sink). For Kafka-on-Pulsar (KoP), use the Kafka adapter instead.
- */
-
-import { ERROR, type Node, node, wallClockNs } from "@graphrefly/pure-ts/core";
-import { type AckableMessage, type ExtraOpts, sourceOpts } from "./_internal.js";
-import { type ReactiveSinkHandle, reactiveSink, type SinkTransportError } from "./_sink.js";
-
-/** Duck-typed Pulsar consumer (compatible with pulsar-client). */
-export type PulsarConsumerLike = {
-	receive(): Promise<{
-		getData(): Buffer;
-		getMessageId(): { toString(): string };
-		getPartitionKey(): string;
-		getProperties(): Record<string, string>;
-		getPublishTimestamp(): number;
-		getEventTimestamp(): number;
-		getTopicName(): string;
-	}>;
-	acknowledge(msg: unknown): Promise<void>;
-	close(): Promise<void>;
-};
-
-/** Duck-typed Pulsar producer. */
-export type PulsarProducerLike = {
-	send(msg: {
-		data: Buffer;
-		partitionKey?: string;
-		properties?: Record<string, string>;
-	}): Promise<void>;
-	close(): Promise<void>;
-};
-
-/** Structured Pulsar message. */
-export type PulsarMessage<T = unknown> = {
-	topic: string;
-	messageId: string;
-	key: string;
-	value: T;
-	properties: Record<string, string>;
-	publishTime: number;
-	eventTime: number;
-	timestampNs: number;
-};
-
-/** Options for {@link fromPulsar}. */
-export type FromPulsarOptions = ExtraOpts & {
-	/** Deserialize message data. Default: `JSON.parse(buffer.toString())`. */
-	deserialize?: (data: Buffer) => unknown;
-	/** Acknowledge messages automatically. Default: `true`. */
-	autoAck?: boolean;
-	/**
-	 * Routes ack/nack transport failures to the caller. Covers:
-	 * - `autoAck: true` — post-emit `acknowledge()` promise rejections.
-	 * - `autoAck: false` — envelope `ack()` / `nack()` promise rejections.
-	 * Default: swallow (SDK handles redelivery on its own).
-	 */
-	onAckError?: (err: Error) => void;
-};
-
-/**
- * Apache Pulsar consumer as a reactive source (native client).
- *
- * Wraps a `pulsar-client`-compatible consumer. Each message becomes a `DATA` emission.
- * For Kafka-on-Pulsar (KoP), use {@link fromKafka} instead.
- *
- * @param consumer - Pulsar consumer instance (caller owns create/close lifecycle).
- * @param opts - Deserialization and source options.
- * @returns `Node<PulsarMessage<T>>` — one `DATA` per Pulsar message.
- *
- * @remarks
- * Teardown sets an internal flag but cannot interrupt a pending `consumer.receive()`.
- * The loop exits on the next message or when the consumer is closed externally.
- * Callers should call `consumer.close()` after unsubscribing for prompt cleanup.
- *
- * @example
- * ```ts
- * import Pulsar from "pulsar-client";
- * import { fromPulsar } from "@graphrefly/graphrefly";
- *
- * const client = new Pulsar.Client({ serviceUrl: "pulsar://localhost:6650" });
- * const consumer = await client.subscribe({ topic: "events", subscription: "my-sub" });
- * const events$ = fromPulsar(consumer);
- * ```
- *
- * @category extra
- */
-export function fromPulsar<T = unknown>(
-	consumer: PulsarConsumerLike,
-	opts?: FromPulsarOptions & { autoAck?: true },
-): Node<PulsarMessage<T>>;
-export function fromPulsar<T = unknown>(
-	consumer: PulsarConsumerLike,
-	opts: FromPulsarOptions & { autoAck: false },
-): Node<AckableMessage<PulsarMessage<T>>>;
-export function fromPulsar<T = unknown>(
-	consumer: PulsarConsumerLike,
-	opts?: FromPulsarOptions,
-): Node<PulsarMessage<T> | AckableMessage<PulsarMessage<T>>> {
-	const {
-		autoAck = true,
-		deserialize = (buf: Buffer) => {
-			try {
-				return JSON.parse(buf.toString());
-			} catch {
-				return buf.toString();
-			}
-		},
-		onAckError,
-		...rest
-	} = opts ?? {};
-
-	const reportAckError = (err: unknown) => {
-		if (!onAckError) return;
-		try {
-			onAckError(err instanceof Error ? err : new Error(String(err)));
-		} catch {
-			/* user hook must not escape */
-		}
-	};
-
-	return node<PulsarMessage<T> | AckableMessage<PulsarMessage<T>>>(
-		[],
-		(_data, a) => {
-			let active = true;
-
-			const loop = async () => {
-				while (active) {
-					try {
-						const rawMsg = await consumer.receive();
-						if (!active) return;
-						const structured: PulsarMessage<T> = {
-							topic: rawMsg.getTopicName(),
-							messageId: rawMsg.getMessageId().toString(),
-							key: rawMsg.getPartitionKey(),
-							value: deserialize(rawMsg.getData()) as T,
-							properties: rawMsg.getProperties(),
-							publishTime: rawMsg.getPublishTimestamp(),
-							eventTime: rawMsg.getEventTimestamp(),
-							timestampNs: wallClockNs(),
-						};
-						if (autoAck) {
-							a.emit(structured);
-							void consumer.acknowledge(rawMsg).catch(reportAckError);
-						} else {
-							// Manual ack — wrap in AckableMessage. Pulsar's SDK has no
-							// per-message nack(requeue=false) — a plain `nack` re-delivers
-							// after the subscription's negativeAckRedeliveryDelay. `requeue`
-							// is honored as "always redeliver" (SDK default).
-							let settled = false;
-							const envelope: AckableMessage<PulsarMessage<T>> = {
-								value: structured,
-								ack() {
-									if (settled) return;
-									settled = true;
-									void consumer.acknowledge(rawMsg).catch(reportAckError);
-								},
-								nack(_opts) {
-									if (settled) return;
-									settled = true;
-									const anyConsumer = consumer as unknown as {
-										negativeAcknowledge?: (m: unknown) => Promise<void> | void;
-									};
-									try {
-										const result = anyConsumer.negativeAcknowledge?.(rawMsg);
-										// nack may return Promise (some SDKs) — route rejection.
-										if (result && typeof (result as Promise<void>).then === "function") {
-											void (result as Promise<void>).catch(reportAckError);
-										}
-									} catch (err) {
-										reportAckError(err);
-									}
-								},
-							};
-							a.emit(envelope);
-						}
-					} catch (err) {
-						if (active) a.down([[ERROR, err]]);
-						return;
-					}
-				}
-			};
-
-			void loop();
-
-			return {
-				onDeactivation: () => {
-					active = false;
-				},
-			};
-		},
-		sourceOpts(rest),
-	);
-}
-
-/** Options for {@link toPulsar}. */
-export type ToPulsarOptions<T> = ExtraOpts & {
-	/** Serialize value for Pulsar. Default: `JSON.stringify` → Buffer. */
-	serialize?: (value: T) => Buffer;
-	/** Extract partition key from value. Default: none. */
-	keyExtractor?: (value: T) => string | undefined;
-	/** Extract properties from value. */
-	propertiesExtractor?: (value: T) => Record<string, string> | undefined;
-	/** Called on serialization or send failures. */
-	onTransportError?: (err: SinkTransportError) => void;
-};
-
-/**
- * Pulsar producer sink — forwards upstream `DATA` to a Pulsar topic.
- *
- * @param source - Upstream node to forward.
- * @param pulsarProducer - Pulsar producer instance (caller owns lifecycle).
- * @param opts - Serialization options.
- * @returns Unsubscribe function.
- *
- * @category extra
- */
-export function toPulsar<T>(
-	source: Node<T>,
-	pulsarProducer: PulsarProducerLike,
-	opts?: ToPulsarOptions<T>,
-): ReactiveSinkHandle<T> {
-	const {
-		serialize = (v: T) => Buffer.from(JSON.stringify(v)),
-		keyExtractor,
-		propertiesExtractor,
-		onTransportError,
-	} = opts ?? {};
-	return reactiveSink<T>(source, {
-		onTransportError,
-		send: async (value) => {
-			await pulsarProducer.send({
-				data: serialize(value),
-				partitionKey: keyExtractor?.(value),
-				properties: propertiesExtractor?.(value),
-			});
-		},
-	});
-}
diff --git a/src/base/io/rabbitmq.ts b/src/base/io/rabbitmq.ts
deleted file mode 100644
index 96639bd6..00000000
--- a/src/base/io/rabbitmq.ts
+++ /dev/null
@@ -1,269 +0,0 @@
-/**
- * RabbitMQ IO — `fromRabbitMQ` (queue-consumer source with optional manual
- * ack via {@link AckableMessage} envelopes) and `toRabbitMQ` (publisher
- * sink). Compatible with `amqplib`-style channels.
- */
-
-import { ERROR, type Node, node, wallClockNs } from "@graphrefly/pure-ts/core";
-import { type AckableMessage, type ExtraOpts, sourceOpts } from "./_internal.js";
-import { type ReactiveSinkHandle, reactiveSink, type SinkTransportError } from "./_sink.js";
-
-/** Duck-typed RabbitMQ channel (compatible with amqplib). */
-export type RabbitMQChannelLike = {
-	consume(
-		queue: string,
-		onMessage: (
-			msg: {
-				content: Buffer;
-				fields: {
-					routingKey: string;
-					exchange: string;
-					deliveryTag: number;
-					redelivered: boolean;
-				};
-				properties: Record<string, unknown>;
-			} | null,
-		) => void,
-		opts?: { noAck?: boolean },
-	): Promise<{ consumerTag: string }>;
-	cancel(consumerTag: string): Promise<void>;
-	ack(msg: unknown): void;
-	publish(
-		exchange: string,
-		routingKey: string,
-		content: Buffer,
-		opts?: Record<string, unknown>,
-	): boolean;
-	sendToQueue(queue: string, content: Buffer, opts?: Record<string, unknown>): boolean;
-};
-
-/** Structured RabbitMQ message. */
-export type RabbitMQMessage<T = unknown> = {
-	queue: string;
-	routingKey: string;
-	exchange: string;
-	content: T;
-	properties: Record<string, unknown>;
-	deliveryTag: number;
-	redelivered: boolean;
-	timestampNs: number;
-};
-
-/** Options for {@link fromRabbitMQ}. */
-export type FromRabbitMQOptions = ExtraOpts & {
-	/** Deserialize message content. Default: `JSON.parse(buffer.toString())`. */
-	deserialize?: (content: Buffer) => unknown;
-	/** Auto-acknowledge messages. Default: `true`. */
-	autoAck?: boolean;
-	/**
-	 * Routes envelope ack/nack transport failures (including "SDK exposes no
-	 * `nack` method") to the caller. Default: swallow.
-	 */
-	onAckError?: (err: Error) => void;
-};
-
-/**
- * RabbitMQ consumer as a reactive source.
- *
- * Wraps an `amqplib`-compatible channel. Each message becomes a `DATA` emission.
- *
- * @param channel - AMQP channel instance (caller owns connection/channel lifecycle).
- * @param queue - Queue to consume from.
- * @param opts - Deserialization and acknowledgment options.
- * @returns `Node<RabbitMQMessage<T>>` — one `DATA` per RabbitMQ message.
- *
- * @remarks
- * When `autoAck` is `false`, the adapter opens the channel with `noAck: false`
- * (broker requires acks) but does not call `channel.ack()`. The caller must ack
- * messages externally using the `deliveryTag` from the emitted {@link RabbitMQMessage}:
- * ```ts
- * channel.ack({ fields: { deliveryTag: msg.deliveryTag } } as any);
- * ```
- *
- * @example
- * ```ts
- * import amqplib from "amqplib";
- * import { fromRabbitMQ } from "@graphrefly/graphrefly";
- *
- * const conn = await amqplib.connect("amqp://localhost");
- * const ch = await conn.createChannel();
- * await ch.assertQueue("events");
- * const events$ = fromRabbitMQ(ch, "events");
- * ```
- *
- * @category extra
- */
-export function fromRabbitMQ<T = unknown>(
-	channel: RabbitMQChannelLike,
-	queue: string,
-	opts?: FromRabbitMQOptions & { autoAck?: true },
-): Node<RabbitMQMessage<T>>;
-export function fromRabbitMQ<T = unknown>(
-	channel: RabbitMQChannelLike,
-	queue: string,
-	opts: FromRabbitMQOptions & { autoAck: false },
-): Node<AckableMessage<RabbitMQMessage<T>>>;
-export function fromRabbitMQ<T = unknown>(
-	channel: RabbitMQChannelLike,
-	queue: string,
-	opts?: FromRabbitMQOptions,
-): Node<RabbitMQMessage<T> | AckableMessage<RabbitMQMessage<T>>> {
-	const {
-		autoAck = true,
-		deserialize = (buf: Buffer) => {
-			try {
-				return JSON.parse(buf.toString());
-			} catch {
-				return buf.toString();
-			}
-		},
-		onAckError,
-		...rest
-	} = opts ?? {};
-
-	const reportAckError = (err: unknown) => {
-		if (!onAckError) return;
-		try {
-			onAckError(err instanceof Error ? err : new Error(String(err)));
-		} catch {
-			/* user hook must not escape */
-		}
-	};
-
-	return node<RabbitMQMessage<T> | AckableMessage<RabbitMQMessage<T>>>(
-		[],
-		(_data, a) => {
-			let active = true;
-			let consumerTag: string | undefined;
-
-			const start = async () => {
-				try {
-					const result = await channel.consume(
-						queue,
-						(rawMsg) => {
-							if (!active) return;
-							if (rawMsg === null) {
-								// Broker cancelled the consumer (queue deleted, etc.).
-								if (active) a.down([[ERROR, new Error("Consumer cancelled by broker")]]);
-								return;
-							}
-							const structured: RabbitMQMessage<T> = {
-								queue,
-								routingKey: rawMsg.fields.routingKey,
-								exchange: rawMsg.fields.exchange,
-								content: deserialize(rawMsg.content) as T,
-								properties: rawMsg.properties,
-								deliveryTag: rawMsg.fields.deliveryTag,
-								redelivered: rawMsg.fields.redelivered,
-								timestampNs: wallClockNs(),
-							};
-							if (autoAck) {
-								a.emit(structured);
-								try {
-									channel.ack(rawMsg);
-								} catch (err) {
-									reportAckError(err);
-								}
-							} else {
-								let settled = false;
-								const channelWithNack = channel as unknown as {
-									nack?: (msg: unknown, allUpTo?: boolean, requeue?: boolean) => void;
-								};
-								const envelope: AckableMessage<RabbitMQMessage<T>> = {
-									value: structured,
-									ack() {
-										if (settled) return;
-										settled = true;
-										try {
-											channel.ack(rawMsg);
-										} catch (err) {
-											reportAckError(err);
-										}
-									},
-									nack(nackOpts) {
-										if (settled) return;
-										settled = true;
-										// `requeue` passes through to SDK — `undefined` lets the
-										// SDK apply its own default (amqplib: true). Explicit
-										// `false` routes to DLX if configured.
-										const requeue = nackOpts?.requeue;
-										if (!channelWithNack.nack) {
-											reportAckError(
-												new Error("RabbitMQ channel does not expose `nack`; cannot negative-ack"),
-											);
-											return;
-										}
-										try {
-											channelWithNack.nack(rawMsg, false, requeue);
-										} catch (err) {
-											reportAckError(err);
-										}
-									},
-								};
-								a.emit(envelope);
-							}
-						},
-						{ noAck: false },
-					);
-					consumerTag = result.consumerTag;
-				} catch (err) {
-					if (active) a.down([[ERROR, err]]);
-				}
-			};
-
-			void start();
-
-			return {
-				onDeactivation: () => {
-					active = false;
-					if (consumerTag !== undefined) {
-						void channel.cancel(consumerTag);
-					}
-				},
-			};
-		},
-		sourceOpts(rest),
-	);
-}
-
-/** Options for {@link toRabbitMQ}. */
-export type ToRabbitMQOptions<T> = ExtraOpts & {
-	/** Serialize value for RabbitMQ. Default: `Buffer.from(JSON.stringify(value))`. */
-	serialize?: (value: T) => Buffer;
-	/** Extract routing key from value. Default: `""`. */
-	routingKeyExtractor?: (value: T) => string;
-	/** Called on serialization or send failures. */
-	onTransportError?: (err: SinkTransportError) => void;
-};
-
-/**
- * RabbitMQ producer sink — forwards upstream `DATA` to a RabbitMQ exchange/queue.
- *
- * @param source - Upstream node to forward.
- * @param channel - AMQP channel instance.
- * @param exchange - Target exchange (use `""` for default exchange + queue routing).
- * @param opts - Serialization and routing options.
- * @returns Unsubscribe function.
- *
- * @category extra
- */
-export function toRabbitMQ<T>(
-	source: Node<T>,
-	channel: RabbitMQChannelLike,
-	exchange: string,
-	opts?: ToRabbitMQOptions<T>,
-): ReactiveSinkHandle<T> {
-	const {
-		serialize = (v: T) => Buffer.from(JSON.stringify(v)),
-		routingKeyExtractor = () => "",
-		onTransportError,
-	} = opts ?? {};
-	return reactiveSink<T>(source, {
-		onTransportError,
-		send: (value) => {
-			const routingKey = routingKeyExtractor(value);
-			const content = serialize(value);
-			channel.publish(exchange, routingKey, content);
-		},
-	});
-}
diff --git a/src/base/io/redis-stream.ts b/src/base/io/redis-stream.ts
deleted file mode 100644
index e1616cfa..00000000
--- a/src/base/io/redis-stream.ts
+++ /dev/null
@@ -1,174 +0,0 @@
-/**
- * Redis Streams IO — `fromRedisStream` (XREAD-BLOCK consumer source) and
- * `toRedisStream` (XADD producer sink). Caller owns the Redis client
- * lifecycle.
- */
-
-import { ERROR, type Node, node, wallClockNs } from "@graphrefly/pure-ts/core";
-import { type ExtraOpts, sourceOpts } from "./_internal.js";
-import { type ReactiveSinkHandle, reactiveSink, type SinkTransportError } from "./_sink.js";
-
-/** Duck-typed Redis client (compatible with ioredis, redis). */
-export type RedisClientLike = {
-	xadd(key: string, id: string, ...fieldsAndValues: string[]): Promise<string>;
-	xread(
-		...args: Array<string | number>
-	): Promise<Array<[string, Array<[string, string[]]>]> | null>;
-	disconnect(): void;
-};
-
-/** Structured Redis Stream entry. */
-export type RedisStreamEntry<T = unknown> = {
-	id: string;
-	key: string;
-	data: T;
-	timestampNs: number;
-};
-
-/** Options for {@link fromRedisStream}. */
-export type FromRedisStreamOptions = ExtraOpts & {
-	/** Block timeout in ms for XREAD. Default: `5000`. */
-	blockMs?: number;
-	/** Start ID. Default: `"$"` (new entries only). */
-	startId?: string;
-	/** Parse raw Redis hash fields to structured data. Default: parses `data` field as JSON. */
-	parse?: (fields: string[]) => unknown;
-};
-
-/**
- * Redis Streams consumer as a reactive source.
- *
- * Uses XREAD with BLOCK to reactively consume stream entries.
- *
- * @param client - ioredis/redis-compatible client (caller owns connection).
- * @param key - Redis stream key.
- * @param opts - Block timeout, start ID, and parsing options.
- * @returns `Node<RedisStreamEntry<T>>` — one `DATA` per stream entry.
- *
- * @remarks
- * **COMPLETE:** This source never emits `COMPLETE` under normal operation — it
- * is a long-lived stream consumer that runs until teardown or error, same as
- * Kafka consumers. If you need a bounded read, wrap with `take()` or
- * `takeUntil()`.
- *
- * **Client lifecycle:** The caller owns the Redis client connection. The adapter
- * does not call `disconnect()` on teardown — the caller is responsible for
- * closing the connection (same contract as `fromKafka`).
- *
- * @category extra
- */
-export function fromRedisStream<T = unknown>(
-	client: RedisClientLike,
-	key: string,
-	opts?: FromRedisStreamOptions,
-): Node<RedisStreamEntry<T>> {
-	const {
-		blockMs = 5000,
-		startId = "$",
-		parse = (fields: string[]) => {
-			// Redis returns flat [field, value, field, value, ...] arrays.
-			for (let i = 0; i < fields.length; i += 2) {
-				if (fields[i] === "data") {
-					try {
-						return JSON.parse(fields[i + 1]);
-					} catch {
-						return fields[i + 1];
-					}
-				}
-			}
-			// Return as object if no "data" field.
-			const obj: Record<string, string> = {};
-			for (let i = 0; i < fields.length; i += 2) {
-				obj[fields[i]] = fields[i + 1];
-			}
-			return obj;
-		},
-		...rest
-	} = opts ?? {};
-
-	return node<RedisStreamEntry<T>>(
-		[],
-		(_data, a) => {
-			let active = true;
-			let lastId = startId;
-
-			const poll = async () => {
-				while (active) {
-					try {
-						const result = await client.xread("BLOCK", blockMs, "STREAMS", key, lastId);
-						if (!active) return;
-						if (result) {
-							for (const [_streamKey, entries] of result) {
-								for (const [id, fields] of entries) {
-									lastId = id;
-									a.emit({
-										id,
-										key,
-										data: parse(fields) as T,
-										timestampNs: wallClockNs(),
-									});
-								}
-							}
-						}
-					} catch (err) {
-						if (!active) return;
-						a.down([[ERROR, err]]);
-						return;
-					}
-				}
-			};
-
-			void poll();
-
-			return {
-				onDeactivation: () => {
-					active = false;
-				},
-			};
-		},
-		sourceOpts(rest),
-	);
-}
-
-/** Options for {@link toRedisStream}. */
-export type ToRedisStreamOptions<T> = ExtraOpts & {
-	/** Serialize value to Redis hash fields. Default: `["data", JSON.stringify(value)]`. */
-	serialize?: (value: T) => string[];
-	/** Max stream length (MAXLEN ~). Default: no trimming. */
-	maxLen?: number;
-	/** Called on serialization or send failures. */
-	onTransportError?: (err: SinkTransportError) => void;
-};
-
-/**
- * Redis Streams producer sink — forwards upstream `DATA` to a Redis stream.
- *
- * @param source - Upstream node to forward.
- * @param client - ioredis/redis-compatible client.
- * @param key - Redis stream key.
- * @param opts - Serialization options.
- * @returns Unsubscribe function.
- *
- * @category extra
- */
-export function toRedisStream<T>(
-	source: Node<T>,
-	client: RedisClientLike,
-	key: string,
-	opts?: ToRedisStreamOptions<T>,
-): ReactiveSinkHandle<T> {
-	const {
-		serialize = (v: T) => ["data", JSON.stringify(v)],
-		maxLen,
-		onTransportError,
-	} = opts ?? {};
-	return reactiveSink<T>(source, {
-		onTransportError,
-		send: async (value) => {
-			const fields = serialize(value);
-			await (maxLen !== undefined
-				? client.xadd(key, "MAXLEN", "~", String(maxLen), "*", ...fields)
-				: client.xadd(key, "*", ...fields));
-		},
-	});
-}
diff --git a/src/base/io/sink.ts b/src/base/io/sink.ts
deleted file mode 100644
index d2cc18c5..00000000
--- a/src/base/io/sink.ts
+++ /dev/null
@@ -1,7 +0,0 @@
-/**
- * Reactive sink IO — re-exports from `./_sink.js`.
- *
- * Physical code was moved from `src/extra/reactive-sink.ts` to `./_sink.ts` in A2.
- */
-
-export * from "./_sink.js";
diff --git a/src/base/io/sqlite.ts b/src/base/io/sqlite.ts
deleted file mode 100644
index 67e4ca1f..00000000
--- a/src/base/io/sqlite.ts
+++ /dev/null
@@ -1,401 +0,0 @@
-/**
- * SQLite IO (roadmap §5.2b) — `fromSqlite` (one-shot synchronous query),
- * `fromSqliteCursor` (row-by-row streaming via `iterate()`), and `toSqlite`
- * (insert sink with optional transactional batching).
- *
- * Synchronous boundaries: SQLite drivers are typically synchronous
- * (`better-sqlite3`, `node:sqlite`), so errors propagate immediately rather
- * than via promise rejection. The duck-typed `SqliteDbLike.query` matches the
- * project-wide `query(sql, params)` convention used by Postgres/ClickHouse.
- */
-
-import {
-	batch,
-	COMPLETE,
-	DATA,
-	defaultConfig,
-	ERROR,
-	type Node,
-	type NodeOptions,
-	node,
-	TEARDOWN,
-} from "@graphrefly/pure-ts/core";
-import type { ExtraOpts } from "./_internal.js";
-import {
-	type ReactiveSinkHandle,
-	reactiveSink,
-	type SinkFailure,
-	type SinkTransportError,
-} from "./_sink.js";
-
-/**
- * Duck-typed synchronous SQLite database.
- *
- * Compatible with `better-sqlite3` (`.prepare().all()` / `.prepare().run()`)
- * and Node.js `node:sqlite` `DatabaseSync`. The user wraps their driver behind
- * this uniform contract — method name `query` matches the project-wide
- * convention (`PostgresClientLike.query`, `ClickHouseClientLike.query`).
- */
-export type SqliteDbLike = {
-	query(sql: string, params?: unknown[]): unknown[];
-};
-
-/** Options for {@link fromSqlite}. */
-export type FromSqliteOptions<T> = ExtraOpts & {
-	/** Map a raw row object to the desired type. Default: identity cast. */
-	mapRow?: (row: unknown) => T;
-	/** Bind parameters for the query. */
-	params?: unknown[];
-};
-
-/**
- * One-shot SQLite query as a reactive source.
- *
- * Executes `query` synchronously via `db.query()`, emits **one `DATA` containing
- * the full result array**, then `COMPLETE`. Downstream flattens with
- * `mergeAll` / a custom operator if per-row semantics are required — the
- * array shape is the simpler default and matches how every SQL driver returns
- * results natively. Use {@link fromSqliteCursor} for streaming row-by-row.
- *
- * @param db - SQLite database (caller owns connection).
- * @param query - SQL string to execute.
- * @param opts - Row mapper, params, and node options.
- * @returns `Node<T[]>` — one `DATA` with the full row array, then `COMPLETE`.
- *
- * @example
- * ```ts
- * import Database from "better-sqlite3";
- * import { fromSqlite } from "@graphrefly/graphrefly";
- *
- * const raw = new Database("app.db");
- * const db = { query: (sql, params) => raw.prepare(sql).all(...(params ?? [])) };
- * const rows$ = fromSqlite(db, "SELECT * FROM users WHERE active = ?", { params: [1] });
- * ```
- *
- * @category extra
- */
-export function fromSqlite<T = unknown>(
-	db: SqliteDbLike,
-	query: string,
-	opts?: FromSqliteOptions<T>,
-): Node<T[]> {
-	const { mapRow = (r: unknown) => r as T, params, ...rest } = opts ?? {};
-
-	return node<T[]>(
-		[],
-		(_data, a) => {
-			try {
-				const rows = db.query(query, params);
-				const mapped = rows.map(mapRow);
-				a.emit(mapped);
-				a.down([[COMPLETE]]);
-			} catch (err) {
-				a.down([[ERROR, err instanceof Error ? err : new Error(String(err))]]);
-			}
-			return undefined;
-		},
-		{ describeKind: "producer", completeWhenDepsComplete: false, ...rest } as NodeOptions<T[]>,
-	);
-}
-
-/**
- * Duck-typed iterable-capable SQLite database — `iterate(sql, params)` returns
- * a synchronous iterator over rows, avoiding the "all-rows-in-memory" cost of
- * `db.query`. Compatible with `better-sqlite3`'s `.prepare().iterate()`.
- *
- * @category extra
- */
-export type SqliteIterableDbLike = {
-	iterate(sql: string, params?: unknown[]): Iterable<unknown>;
-};
-
-/**
- * Cursor-streaming SQLite query — emits one `DATA` per row from a synchronous
- * row iterator, then `COMPLETE`. Use when result sets are too large to
- * materialize fully into an array.
- *
- * @category extra
- */
-export function fromSqliteCursor<T = unknown>(
-	db: SqliteIterableDbLike,
-	query: string,
-	opts?: FromSqliteOptions<T>,
-): Node<T> {
-	const { mapRow = (r: unknown) => r as T, params, ...rest } = opts ?? {};
-	return node<T>(
-		[],
-		(_data, a) => {
-			try {
-				const it = db.iterate(query, params);
-				batch(() => {
-					for (const row of it) a.emit(mapRow(row));
-					a.down([[COMPLETE]]);
-				});
-			} catch (err) {
-				a.down([[ERROR, err instanceof Error ? err : new Error(String(err))]]);
-			}
-			return undefined;
-		},
-		{ describeKind: "producer", completeWhenDepsComplete: false, ...rest } as NodeOptions<T>,
-	);
-}
-
-/** Options for {@link toSqlite}. */
-export type ToSqliteOptions<T> = ExtraOpts & {
-	/** Build SQL + params for an insert. Default: JSON insert into `(data)` column. */
-	toSQL?: (value: T, table: string) => { sql: string; params: unknown[] };
-	onTransportError?: (err: SinkTransportError) => void;
-	/**
-	 * When `true`, buffer DATA values and execute all inserts inside a single
-	 * `BEGIN`/`COMMIT` transaction when the batch drains.  This avoids per-row
-	 * fsync overhead and dramatically reduces event-loop blocking for
-	 * high-throughput sources.  The first insert error stops the batch and
-	 * triggers a `ROLLBACK`; the error is reported via `onTransportError`.
-	 */
-	batchInsert?: boolean;
-	/** Auto-flush when buffer reaches this size. Default: `1000`. Only applies when `batchInsert` is `true`. */
-	maxBatchSize?: number;
-	/** Periodic flush interval in ms. `0` = no timer (flush on terminal messages only). Default: `0`. Only applies when `batchInsert` is `true`. */
-	flushIntervalMs?: number;
-};
-
-/**
- * SQLite sink — inserts each upstream `DATA` value as a row.
- *
- * Follows the same pattern as {@link toPostgres} / {@link toMongo}. Since SQLite
- * is synchronous, errors propagate immediately (no `void promise.catch`).
- *
- * @param source - Upstream node.
- * @param db - SQLite database (caller owns connection).
- * @param table - Target table name.
- * @param opts - SQL builder and error options.
- * @returns Unsubscribe function.
- *
- * @example
- * ```ts
- * import Database from "better-sqlite3";
- * import { toSqlite, state } from "@graphrefly/graphrefly";
- *
- * const raw = new Database("app.db");
- * const db = { query: (sql, params) => (raw.prepare(sql).run(...(params ?? [])), []) };
- * const source = state({ name: "Alice", score: 42 });
- * const unsub = toSqlite(source, db, "events");
- * ```
- *
- * @category extra
- */
-export function toSqlite<T>(
-	source: Node<T>,
-	db: SqliteDbLike,
-	table: string,
-	opts?: ToSqliteOptions<T>,
-): ReactiveSinkHandle<T> {
-	if (table.includes("\0") || table.length === 0) {
-		throw new Error(`toSqlite: invalid table name: ${JSON.stringify(table)}`);
-	}
-	const {
-		toSQL = (v: T, t: string) => ({
-			sql: `INSERT INTO "${t.replace(/"/g, '""')}" (data) VALUES (?)`,
-			params: [JSON.stringify(v)],
-		}),
-		onTransportError,
-		batchInsert = false,
-		maxBatchSize = 1000,
-		flushIntervalMs = 0,
-	} = opts ?? {};
-
-	const serialize = (value: T) => toSQL(value, table);
-	type Query = { sql: string; params: unknown[] };
-
-	if (!batchInsert) {
-		return reactiveSink<T>(source, {
-			onTransportError,
-			serialize,
-			send: (q) => {
-				const query = q as Query;
-				db.query(query.sql, query.params);
-			},
-		});
-	}
-
-	// Batched mode — transactional: BEGIN → inserts → COMMIT (or ROLLBACK on
-	// first insert error). Must preserve pending queries when BEGIN itself
-	// fails (e.g. "database is locked") so a subsequent `flush()` can retry
-	// with the same data intact. The generic `reactiveSink` clears its buffer
-	// before invoking `sendBatch`, so we keep a bespoke transactional loop on
-	// top of the reactiveSink skeleton: custom `flush()` + local pending
-	// queue with re-queue semantics on BEGIN failure.
-	const errorsNode = node<SinkTransportError | null>([], { initial: null });
-	const sentNode = node<T | undefined>([], {
-		initial: undefined,
-		equals: () => false,
-	}) as unknown as Node<T>;
-	const failedNode = node<SinkFailure<T> | null>([], { initial: null });
-	const inFlightNode = node<number>([], { initial: 0 });
-	const bufferedNode = node<number>([], { initial: 0 });
-
-	const reportError = (err: SinkTransportError) => {
-		try {
-			onTransportError?.(err);
-		} catch {
-			/* user hook must not escape */
-		}
-		try {
-			errorsNode.down([[DATA, err]]);
-		} catch {
-			/* drain re-entrance */
-		}
-	};
-
-	type PendingEntry = { value: T; query: Query };
-	let pending: PendingEntry[] = [];
-	let flushing = false;
-	let timer: ReturnType<typeof setTimeout> | undefined;
-	let disposed = false;
-
-	const updateBuffered = () => bufferedNode.down([[DATA, pending.length]]);
-
-	// Guarded emit helpers — drop post-TEARDOWN writes silently (spec §1.3.4
-	// terminal filter already blocks them downstream; this skips the
-	// allocation). Prevents "emit after TEARDOWN" observable in subscribers
-	// that race with in-flight flushes.
-	const safeEmitSent = (v: T) => {
-		if (disposed) return;
-		sentNode.down([[DATA, v]]);
-	};
-	const safeEmitFailed = (f: SinkFailure<T>) => {
-		if (disposed) return;
-		failedNode.down([[DATA, f]]);
-	};
-	const safeSetInFlight = (n: number) => {
-		if (disposed) return;
-		inFlightNode.down([[DATA, n]]);
-	};
-	const safeReportError = (err: SinkTransportError) => {
-		if (disposed) return;
-		reportError(err);
-	};
-
-	const flushTransaction = () => {
-		if (pending.length === 0 || flushing) return;
-		flushing = true;
-		safeSetInFlight(1);
-		try {
-			db.query("BEGIN", []);
-		} catch (err) {
-			// BEGIN failed — keep `pending` intact so a later flush can retry.
-			flushing = false;
-			safeSetInFlight(0);
-			safeReportError({
-				stage: "send",
-				error: err instanceof Error ? err : new Error(String(err)),
-				value: undefined,
-			});
-			return;
-		}
-		const chunk = pending;
-		pending = [];
-		updateBuffered();
-
-		let firstError: Error | undefined;
-		let committedCount = 0;
-		for (const entry of chunk) {
-			try {
-				db.query(entry.query.sql, entry.query.params);
-				committedCount += 1;
-			} catch (err) {
-				firstError = err instanceof Error ? err : new Error(String(err));
-				break;
-			}
-		}
-
-		if (firstError) {
-			try {
-				db.query("ROLLBACK", []);
-			} catch {
-				/* ROLLBACK failure — firstError already captured */
-			}
-			safeReportError({ stage: "send", error: firstError, value: undefined });
-			for (const entry of chunk) {
-				safeEmitFailed({ value: entry.value, error: firstError, attempts: 1 });
-			}
-		} else {
-			try {
-				db.query("COMMIT", []);
-				for (const entry of chunk) safeEmitSent(entry.value);
-			} catch (err) {
-				const error = err instanceof Error ? err : new Error(String(err));
-				safeReportError({ stage: "send", error, value: undefined });
-				for (let i = 0; i < committedCount; i++) {
-					safeEmitFailed({ value: chunk[i].value, error, attempts: 1 });
-				}
-			}
-		}
-		flushing = false;
-		safeSetInFlight(0);
-	};
-
-	const scheduleFlush = () => {
-		if (flushIntervalMs > 0 && timer === undefined && !disposed) {
-			timer = setTimeout(() => {
-				/* I/O flush timer — not reactive scheduling (§5.10) */
-				timer = undefined;
-				flushTransaction();
-			}, flushIntervalMs);
-		}
-	};
-
-	const unsub = source.subscribe((msgs) => {
-		for (const msg of msgs) {
-			const t = msg[0];
-			if (t === DATA) {
-				const value = msg[1] as T;
-				let query: Query;
-				try {
-					query = serialize(value);
-				} catch (err) {
-					const error = err instanceof Error ? err : new Error(String(err));
-					reportError({ stage: "serialize", error, value });
-					failedNode.down([[DATA, { value, error, attempts: 0 } satisfies SinkFailure<T>]]);
-					continue;
-				}
-				pending.push({ value, query });
-				updateBuffered();
-				if (pending.length >= maxBatchSize) flushTransaction();
-				else scheduleFlush();
-			} else if (defaultConfig.messageTier(t) >= 3) {
-				flushTransaction();
-			}
-		}
-	});
-
-	const dispose = () => {
-		if (disposed) return;
-		if (timer !== undefined) {
-			clearTimeout(timer);
-			timer = undefined;
-		}
-		flushTransaction();
-		disposed = true;
-		unsub();
-		for (const n of [errorsNode, sentNode, failedNode, inFlightNode, bufferedNode]) {
-			try {
-				(n as Node<unknown>).down([[TEARDOWN]]);
-			} catch {
-				/* drain re-entrance */
-			}
-		}
-	};
-
-	return {
-		dispose,
-		sent: sentNode,
-		failed: failedNode,
-		inFlight: inFlightNode,
-		errors: errorsNode,
-		buffered: bufferedNode,
-		flush: async () => {
-			if (!disposed) flushTransaction();
-		},
-	};
-}
diff --git a/src/base/io/sse.ts b/src/base/io/sse.ts
deleted file mode 100644
index b644eee7..00000000
--- a/src/base/io/sse.ts
+++ /dev/null
@@ -1,544 +0,0 @@
-/**
- * Server-Sent Events IO — `toSSE` / `toSSEBytes` (encode any node into the
- * `text/event-stream` wire format), `toReadableStream` (web-stream sink),
- * `parseSSEStream` (async-iterator parser), `fromSSE` (line-delimited parser
- * source).
- */
-
-import {
-	COMPLETE,
-	DATA,
-	DIRTY,
-	defaultConfig,
-	ERROR,
-	type Node,
-	node,
-	RESOLVED,
-} from "@graphrefly/pure-ts/core";
-import { type ExtraOpts, sourceOpts } from "./_internal.js";
-
-/** Options for {@link toSSE}. */
-export type ToSSEOptions = {
-	/** Custom payload serializer for non-string payloads. Default: `JSON.stringify` fallback to `String(value)`. */
-	serialize?: (value: unknown) => string;
-	/** Event name for DATA tuples. Default: `"data"`. */
-	dataEvent?: string;
-	/** Event name for ERROR tuples. Default: `"error"`. */
-	errorEvent?: string;
-	/** Event name for COMPLETE tuples. Default: `"complete"`. */
-	completeEvent?: string;
-	/** Emit `event: resolved` when RESOLVED arrives. Default: `false`. */
-	includeResolved?: boolean;
-	/** Emit `event: dirty` when DIRTY arrives. Default: `false`. */
-	includeDirty?: boolean;
-	/** Add SSE comment keepalive frames (`: keepalive`) on an interval. Disabled when unset. */
-	keepAliveMs?: number;
-	/** Optional abort signal to terminate the stream early. */
-	signal?: AbortSignal;
-	/** Maps custom message types to SSE event names. */
-	eventNameResolver?: (type: symbol) => string;
-};
-
-function messageTypeLabel(t: symbol): string {
-	return Symbol.keyFor(t) ?? t.description ?? "message";
-}
-
-function serializeSseData(value: unknown, serialize: (value: unknown) => string): string {
-	if (typeof value === "string") return value;
-	return serialize(value);
-}
-
-function sseFrame(event: string, data?: string): string {
-	let out = `event: ${event}\n`;
-	if (data !== undefined) {
-		const lines = data.split(/\r?\n/);
-		for (const line of lines) {
-			out += `data: ${line}\n`;
-		}
-	}
-	return `${out}\n`;
-}
-
-/**
- * Creates a standard Server-Sent Events stream from node messages.
- *
- * @category extra
- */
-export function toSSE<T>(source: Node<T>, opts?: ToSSEOptions): ReadableStream<Uint8Array> {
-	const {
-		serialize = (value: unknown) => {
-			if (value instanceof Error) return value.message;
-			try {
-				return JSON.stringify(value);
-			} catch {
-				return String(value);
-			}
-		},
-		dataEvent = "data",
-		errorEvent = "error",
-		completeEvent = "complete",
-		includeResolved = false,
-		includeDirty = false,
-		keepAliveMs,
-		signal,
-		eventNameResolver = messageTypeLabel,
-	} = opts ?? {};
-	const encoder = new TextEncoder();
-	let stop: (() => void) | undefined;
-
-	return new ReadableStream<Uint8Array>({
-		start(controller) {
-			let closed = false;
-			let keepAlive: ReturnType<typeof setInterval> | undefined;
-			let unsub: () => void = () => {};
-			const close = () => {
-				if (closed) return;
-				closed = true;
-				if (keepAlive !== undefined) clearInterval(keepAlive);
-				signal?.removeEventListener("abort", onAbort);
-				unsub();
-				controller.close();
-			};
-			stop = close;
-			const write = (event: string, data?: string) => {
-				if (closed) return;
-				controller.enqueue(encoder.encode(sseFrame(event, data)));
-			};
-			const onAbort = () => {
-				if (closed) return;
-				close();
-			};
-			unsub = source.subscribe((msgs) => {
-				for (const msg of msgs) {
-					const t = msg[0];
-					// Skip graph-local signals (tier < 3: START, DIRTY, INVALIDATE,
-					// PAUSE, RESUME). DIRTY is opt-in for observability.
-					if (defaultConfig.isLocalOnly(t)) {
-						if (t === DIRTY && includeDirty) {
-							/* fall through to write */
-						} else continue;
-					}
-					if (t === DATA) {
-						write(dataEvent, serializeSseData(msg[1], serialize));
-						continue;
-					}
-					if (t === ERROR) {
-						write(errorEvent, serializeSseData(msg[1], serialize));
-						close();
-						return;
-					}
-					if (t === COMPLETE) {
-						write(completeEvent);
-						close();
-						return;
-					}
-					// RESOLVED (tier 3) is opt-in for observability.
-					if (!includeResolved && t === RESOLVED) continue;
-					write(
-						eventNameResolver(t),
-						msg.length > 1 ? serializeSseData(msg[1], serialize) : undefined,
-					);
-				}
-			});
-			if (keepAliveMs !== undefined && keepAliveMs > 0) {
-				keepAlive = setInterval(() => {
-					if (closed) return;
-					controller.enqueue(encoder.encode(": keepalive\n\n"));
-				}, keepAliveMs);
-			}
-			if (signal?.aborted) onAbort();
-			else signal?.addEventListener("abort", onAbort, { once: true });
-		},
-		cancel() {
-			stop?.();
-		},
-	});
-}
-
-/**
- * Composable variant of {@link toSSE} — emits encoded SSE frames as
- * `Uint8Array` through a reactive `Node`. Use this when you want to pipe SSE
- * bytes through the reactive graph (persist to file, tee to multiple streams,
- * etc.). Wrap with {@link toReadableStream} to expose a `ReadableStream` for
- * `new Response(...)` use cases.
- *
- * @category extra
- */
-export function toSSEBytes<T>(source: Node<T>, opts?: ToSSEOptions): Node<Uint8Array> {
-	const {
-		serialize = (value: unknown) => {
-			if (value instanceof Error) return value.message;
-			try {
-				return JSON.stringify(value);
-			} catch {
-				return String(value);
-			}
-		},
-		dataEvent = "data",
-		errorEvent = "error",
-		completeEvent = "complete",
-		includeResolved = false,
-		includeDirty = false,
-		keepAliveMs,
-		signal,
-		eventNameResolver = messageTypeLabel,
-	} = opts ?? {};
-	const encoder = new TextEncoder();
-	return node<Uint8Array>([], (_data, a) => {
-		let active = true;
-		let keepAlive: ReturnType<typeof setInterval> | undefined;
-		const emitFrame = (event: string, data?: string) => {
-			if (!active) return;
-			a.emit(encoder.encode(sseFrame(event, data)));
-		};
-		const onAbort = () => {
-			if (!active) return;
-			active = false;
-			a.down([[COMPLETE]]);
-		};
-		const unsub = source.subscribe((msgs) => {
-			if (!active) return;
-			for (const msg of msgs) {
-				const t = msg[0];
-				if (defaultConfig.isLocalOnly(t)) {
-					if (t === DIRTY && includeDirty) {
-						/* fall through */
-					} else continue;
-				}
-				if (t === DATA) {
-					emitFrame(dataEvent, serializeSseData(msg[1], serialize));
-					continue;
-				}
-				if (t === ERROR) {
-					emitFrame(errorEvent, serializeSseData(msg[1], serialize));
-					active = false;
-					a.down([[COMPLETE]]);
-					return;
-				}
-				if (t === COMPLETE) {
-					emitFrame(completeEvent);
-					active = false;
-					a.down([[COMPLETE]]);
-					return;
-				}
-				if (!includeResolved && t === RESOLVED) continue;
-				emitFrame(
-					eventNameResolver(t),
-					msg.length > 1 ? serializeSseData(msg[1], serialize) : undefined,
-				);
-			}
-		});
-		if (keepAliveMs !== undefined && keepAliveMs > 0) {
-			keepAlive = setInterval(() => {
-				if (!active) return;
-				a.emit(encoder.encode(": keepalive\n\n"));
-			}, keepAliveMs);
-		}
-		if (signal?.aborted) onAbort();
-		else signal?.addEventListener("abort", onAbort, { once: true });
-		return {
-			onDeactivation: () => {
-				active = false;
-				if (keepAlive !== undefined) clearInterval(keepAlive);
-				signal?.removeEventListener("abort", onAbort);
-				unsub();
-			},
-		};
-	});
-}
-
-/**
- * Converts a `Node<Uint8Array>` into a WHATWG `ReadableStream<Uint8Array>`.
- * Useful for composing with `new Response(...)` / `fetch` bodies.
- *
- * @category extra
- */
-export function toReadableStream(bytes: Node<Uint8Array>): ReadableStream<Uint8Array> {
-	let unsub: (() => void) | undefined;
-	let closed = false;
-	return new ReadableStream<Uint8Array>({
-		start(controller) {
-			unsub = bytes.subscribe((msgs) => {
-				for (const m of msgs) {
-					const t = m[0];
-					if (closed) return;
-					if (t === DATA) {
-						try {
-							controller.enqueue(m[1] as Uint8Array);
-						} catch {
-							/* controller closed mid-batch — upstream unsub will follow */
-							closed = true;
-							unsub?.();
-						}
-					} else if (t === ERROR) {
-						closed = true;
-						try {
-							controller.error(m[1]);
-						} catch {
-							/* controller already closed */
-						}
-						return;
-					} else if (t === COMPLETE) {
-						closed = true;
-						try {
-							controller.close();
-						} catch {
-							/* controller already closed */
-						}
-						return;
-					}
-				}
-			});
-		},
-		cancel() {
-			closed = true;
-			unsub?.();
-		},
-	});
-}
-
-/** Parsed Server-Sent Event. */
-export type SSEEvent<T = string> = {
-	event: string;
-	data: T;
-	id?: string;
-	retry?: number;
-};
-
-/** Options for {@link fromSSE}. */
-export type FromSSEOptions<T = string> = ExtraOpts & {
-	/** Parse the raw `data:` payload. Default: identity (string). */
-	parse?: (raw: string) => T;
-};
-
-/** Options for {@link parseSSEStream}. */
-export type ParseSSEStreamOptions<T = string> = {
-	/** Parse the raw `data:` payload. Default: identity (string). */
-	parse?: (raw: string) => T;
-	/**
-	 * External abort signal. If aborted, the generator returns early after
-	 * cancelling the underlying reader / iterator. Does not emit an error —
-	 * the generator simply ends.
-	 */
-	signal?: AbortSignal;
-};
-
-/**
- * Parses a Server-Sent Events byte stream into an async-iterator of structured
- * `{event, data, id, retry}` records. Pure async generator with no reactive
- * dependency — safe to consume anywhere an `AsyncIterable<SSEEvent>` is
- * expected (LLM provider adapters, tests, non-reactive transports).
- *
- * Handles:
- * - Arbitrary chunk boundaries (internal text buffer + `TextDecoder` streaming).
- * - `\n` and `\r\n` line endings.
- * - `event:` / `data:` (multi-line via repeated fields) / `id:` / `retry:`.
- * - Comments (`:` prefix).
- * - Cancels the underlying reader / iterator on external abort or consumer
- *   break, so a quiet stream doesn't leak pending `read()` calls.
- *
- * Used internally by {@link fromSSE} (reactive `Node<SSEEvent>`) — exposed as a
- * pure helper so LLM provider adapters (Anthropic, OpenAI, Google) can parse
- * their SSE streams without building a reactive node per call.
- *
- * @param source - SSE byte source (`ReadableStream`, `Response`, or `AsyncIterable<Uint8Array>`).
- * @param opts - `{ parse?, signal? }`.
- * @returns `AsyncGenerator<SSEEvent<T>>` — yields one event per SSE block; returns on stream end / abort.
- *
- * @category extra
- */
-export async function* parseSSEStream<T = string>(
-	source: ReadableStream<Uint8Array> | Response | AsyncIterable<Uint8Array>,
-	opts?: ParseSSEStreamOptions<T>,
-): AsyncGenerator<SSEEvent<T>, void, unknown> {
-	const parse = opts?.parse ?? ((raw: string) => raw as unknown as T);
-	const externalSignal = opts?.signal;
-
-	const decoder = new TextDecoder();
-	let buffer = "";
-	let currentEvent = "message";
-	let currentData: string[] = [];
-	let currentId: string | undefined;
-	let currentRetry: number | undefined;
-	const queue: SSEEvent<T>[] = [];
-
-	const flushEvent = () => {
-		if (currentData.length === 0 && currentEvent === "message" && currentId === undefined) {
-			currentData = [];
-			return;
-		}
-		const raw = currentData.join("\n");
-		queue.push({
-			event: currentEvent,
-			data: parse(raw),
-			id: currentId,
-			retry: currentRetry,
-		});
-		currentEvent = "message";
-		currentData = [];
-		currentId = undefined;
-		currentRetry = undefined;
-	};
-
-	const processLine = (line: string) => {
-		if (line === "") {
-			flushEvent();
-			return;
-		}
-		if (line.startsWith(":")) return; // comment
-		const colon = line.indexOf(":");
-		const field = colon < 0 ? line : line.slice(0, colon);
-		let value = colon < 0 ? "" : line.slice(colon + 1);
-		if (value.startsWith(" ")) value = value.slice(1);
-		switch (field) {
-			case "event":
-				currentEvent = value;
-				break;
-			case "data":
-				currentData.push(value);
-				break;
-			case "id":
-				if (!value.includes("\0")) currentId = value;
-				break;
-			case "retry": {
-				const n = Number(value);
-				if (Number.isFinite(n)) currentRetry = n;
-				break;
-			}
-		}
-	};
-
-	const processChunk = (chunk: Uint8Array, done: boolean) => {
-		buffer += decoder.decode(chunk, { stream: !done });
-		const parts = buffer.split(/\r?\n/);
-		buffer = parts.pop() ?? "";
-		for (const line of parts) processLine(line);
-	};
-
-	// Resolve the underlying byte source into either a `ReadableStream` or an
-	// `AsyncIterator<Uint8Array>` — identical dispatch as the legacy fromSSE.
-	const resp = source as Response;
-	const stream =
-		source instanceof ReadableStream
-			? source
-			: resp && typeof resp === "object" && resp.body instanceof ReadableStream
-				? resp.body
-				: null;
-
-	let reader: ReadableStreamDefaultReader<Uint8Array> | undefined;
-	let iter: AsyncIterator<Uint8Array> | undefined;
-	// `cleanupDone` flips once we've invoked `reader.cancel()` / `iter.return()`
-	// — guards against the `onAbort` listener + the `finally` path both
-	// cancelling the same underlying resource (WHATWG streams allow double-
-	// cancel but custom `AsyncIterator.return` implementations are not
-	// required to be idempotent).
-	let cleanupDone = false;
-	const cleanupReader = (): void => {
-		if (cleanupDone) return;
-		cleanupDone = true;
-		if (reader) {
-			void reader.cancel().catch(() => undefined);
-		}
-		if (iter && typeof iter.return === "function") {
-			void Promise.resolve(iter.return()).catch(() => undefined);
-		}
-	};
-
-	// Wire the external abort signal to cancel the reader / iterator promptly
-	// instead of waiting for the next chunk.
-	const onAbort = (): void => {
-		cleanupReader();
-	};
-	if (externalSignal) {
-		if (externalSignal.aborted) return;
-		externalSignal.addEventListener("abort", onAbort, { once: true });
-	}
-
-	try {
-		if (stream) {
-			reader = stream.getReader();
-			while (!externalSignal?.aborted) {
-				const { value, done } = await reader.read();
-				if (done) break;
-				processChunk(value, false);
-				while (queue.length > 0) {
-					const ev = queue.shift() as SSEEvent<T>;
-					yield ev;
-				}
-			}
-			processChunk(new Uint8Array(), true);
-		} else {
-			const asyncIter = source as AsyncIterable<Uint8Array>;
-			iter = asyncIter[Symbol.asyncIterator]();
-			while (!externalSignal?.aborted) {
-				const step = await iter.next();
-				if (step.done) break;
-				processChunk(step.value, false);
-				while (queue.length > 0) {
-					const ev = queue.shift() as SSEEvent<T>;
-					yield ev;
-				}
-			}
-			processChunk(new Uint8Array(), true);
-		}
-		if (buffer.trim()) {
-			for (const line of buffer.split(/\r?\n/)) processLine(line);
-			flushEvent();
-		}
-		while (queue.length > 0) {
-			const ev = queue.shift() as SSEEvent<T>;
-			yield ev;
-		}
-	} finally {
-		if (externalSignal) {
-			externalSignal.removeEventListener("abort", onAbort);
-		}
-		// Idempotent cleanup — if `onAbort` already ran the cancel, this is a
-		// no-op. Covers the normal consumer-break path (generator exits → finally
-		// runs → cancel underlying reader / iterator so a quiet upstream
-		// doesn't leak its `read()` call).
-		cleanupReader();
-	}
-}
-
-/**
- * Parses a Server-Sent Events stream into structured `{event, data, id}` records.
- *
- * @param source - SSE byte source (`ReadableStream`, `Response`, or `AsyncIterable<Uint8Array>`).
- * @param opts - Parse function and node options.
- * @returns `Node<SSEEvent<T>>` — one `DATA` per SSE event; `COMPLETE` on stream end.
- *
- * @category extra
- */
-export function fromSSE<T = string>(
-	source: ReadableStream<Uint8Array> | Response | AsyncIterable<Uint8Array>,
-	opts?: FromSSEOptions<T>,
-): Node<SSEEvent<T>> {
-	const { parse, ...rest } = opts ?? {};
-	return node<SSEEvent<T>>(
-		[],
-		(_data, a) => {
-			let active = true;
-			const ctrl = new AbortController();
-			const run = async () => {
-				try {
-					for await (const ev of parseSSEStream<T>(source, { parse, signal: ctrl.signal })) {
-						if (!active) return;
-						a.emit(ev);
-					}
-					if (active) a.down([[COMPLETE]]);
-				} catch (err) {
-					if (active) a.down([[ERROR, err]]);
-				}
-			};
-			void run();
-			return {
-				onDeactivation: () => {
-					active = false;
-					ctrl.abort();
-				},
-			};
-		},
-		sourceOpts(rest),
-	);
-}
diff --git a/src/base/io/statsd.ts b/src/base/io/statsd.ts
deleted file mode 100644
index e859bec9..00000000
--- a/src/base/io/statsd.ts
+++ /dev/null
@@ -1,111 +0,0 @@
-/**
- * StatsD / DogStatsD IO — `fromStatsD` registrar-based source plus
- * `parseStatsD` helper for the line format. The caller owns the UDP socket;
- * the adapter only wires the `emit` triad.
- */
-
-import type { Node } from "@graphrefly/pure-ts/core";
-import { wallClockNs } from "@graphrefly/pure-ts/core";
-import {
-	type EmitTriad,
-	type ExternalRegister,
-	externalProducer,
-} from "../composition/external-register.js";
-import type { ExtraOpts } from "./_internal.js";
-
-/** Parsed StatsD metric. */
-export type StatsDMetric = {
-	name: string;
-	value: number;
-	type: "counter" | "gauge" | "timer" | "histogram" | "set" | "distribution";
-	sampleRate?: number;
-	tags: Record<string, string>;
-	timestampNs: number;
-};
-
-/** Registration callback for StatsD receiver. Alias of {@link ExternalRegister} over {@link EmitTriad}. */
-export type StatsDRegister = ExternalRegister<EmitTriad<StatsDMetric>>;
-
-/** Options for {@link fromStatsD}. */
-export type FromStatsDOptions = ExtraOpts & {};
-
-/**
- * StatsD/DogStatsD UDP receiver as a reactive source.
- *
- * The caller owns the UDP socket. `fromStatsD` receives a `register` callback
- * that wires datagrams to the `emit` handler with parsed metrics.
- *
- * @param register - Wires socket to emit/error/complete handlers.
- * @param opts - Optional producer options.
- * @returns `Node<StatsDMetric>` — one `DATA` per metric line.
- *
- * @example
- * ```ts
- * import dgram from "node:dgram";
- * import { fromStatsD, parseStatsD } from "@graphrefly/graphrefly";
- *
- * const server = dgram.createSocket("udp4");
- * const stats$ = fromStatsD(({ emit, error }) => {
- *   server.on("message", (buf) => {
- *     for (const line of buf.toString().split("\\n")) {
- *       if (line.trim()) {
- *         try { emit(parseStatsD(line)); }
- *         catch (e) { error(e); }
- *       }
- *     }
- *   });
- *   server.bind(8125);
- *   return () => server.close();
- * });
- * ```
- *
- * @category extra
- */
-export function fromStatsD(register: StatsDRegister, opts?: FromStatsDOptions): Node<StatsDMetric> {
-	return externalProducer<StatsDMetric>(register, opts);
-}
-
-const STATSD_TYPES: Record<string, StatsDMetric["type"]> = {
-	c: "counter",
-	g: "gauge",
-	ms: "timer",
-	h: "histogram",
-	s: "set",
-	d: "distribution",
-};
-
-/**
- * Parses a raw StatsD/DogStatsD line into a structured {@link StatsDMetric}.
- *
- * Format: `metric.name:value|type|@sampleRate|#tag1:val1,tag2:val2`
- *
- * @category extra
- */
-export function parseStatsD(line: string): StatsDMetric {
-	const parts = line.split("|");
-	const [name, valueStr] = (parts[0] ?? "").split(":");
-	if (!name || valueStr === undefined) {
-		throw new Error(`Invalid StatsD line: ${line}`);
-	}
-	const typeCode = parts[1]?.trim() ?? "c";
-	const type = STATSD_TYPES[typeCode] ?? "counter";
-	// Set type uses string identifiers (e.g. unique user IDs), not numeric values.
-	const value = type === "set" ? 0 : Number(valueStr);
-
-	let sampleRate: number | undefined;
-	const tags: Record<string, string> = {};
-
-	for (let i = 2; i < parts.length; i++) {
-		const part = parts[i].trim();
-		if (part.startsWith("@")) {
-			sampleRate = Number(part.slice(1));
-		} else if (part.startsWith("#")) {
-			for (const tag of part.slice(1).split(",")) {
-				const [k, v] = tag.split(":");
-				if (k) tags[k] = v ?? "";
-			}
-		}
-	}
-
-	return { name: name.trim(), value, type, sampleRate, tags, timestampNs: wallClockNs() };
-}
diff --git a/src/base/io/syslog.ts b/src/base/io/syslog.ts
deleted file mode 100644
index 009b401c..00000000
--- a/src/base/io/syslog.ts
+++ /dev/null
@@ -1,105 +0,0 @@
-/**
- * Syslog (RFC 5424) IO — `fromSyslog` registrar-based source plus
- * `parseSyslog` helper for the line format. The caller owns the UDP/TCP
- * socket; the adapter only wires the `emit` triad.
- */
-
-import type { Node } from "@graphrefly/pure-ts/core";
-import { wallClockNs } from "@graphrefly/pure-ts/core";
-import {
-	type EmitTriad,
-	type ExternalRegister,
-	externalProducer,
-} from "../composition/external-register.js";
-import type { ExtraOpts } from "./_internal.js";
-
-/** Parsed syslog message (RFC 5424). */
-export type SyslogMessage = {
-	facility: number;
-	severity: number;
-	timestamp: string;
-	hostname: string;
-	appName: string;
-	procId: string;
-	msgId: string;
-	message: string;
-	timestampNs: number;
-};
-
-/** Registration callback for syslog receiver. Alias of {@link ExternalRegister} over {@link EmitTriad}. */
-export type SyslogRegister = ExternalRegister<EmitTriad<SyslogMessage>>;
-
-/** Options for {@link fromSyslog}. */
-export type FromSyslogOptions = ExtraOpts & {};
-
-/**
- * RFC 5424 syslog receiver as a reactive source.
- *
- * The caller owns the UDP/TCP socket. `fromSyslog` receives a `register` callback
- * that wires socket data events to the `emit` handler with parsed syslog messages.
- *
- * @param register - Wires socket to emit/error/complete handlers.
- * @param opts - Optional producer options.
- * @returns `Node<SyslogMessage>` — one `DATA` per syslog message.
- *
- * @example
- * ```ts
- * import dgram from "node:dgram";
- * import { fromSyslog, parseSyslog } from "@graphrefly/graphrefly";
- *
- * const server = dgram.createSocket("udp4");
- * const syslog$ = fromSyslog(({ emit, error }) => {
- *   server.on("message", (buf) => {
- *     try { emit(parseSyslog(buf.toString())); }
- *     catch (e) { error(e); }
- *   });
- *   server.bind(514);
- *   return () => server.close();
- * });
- * ```
- *
- * @category extra
- */
-export function fromSyslog(
-	register: SyslogRegister,
-	opts?: FromSyslogOptions,
-): Node<SyslogMessage> {
-	return externalProducer<SyslogMessage>(register, opts);
-}
-
-/**
- * Parses a raw RFC 5424 syslog line into a structured {@link SyslogMessage}.
- *
- * Format: `<PRI>VERSION TIMESTAMP HOSTNAME APP-NAME PROCID MSGID MSG`
- *
- * @category extra
- */
-export function parseSyslog(raw: string): SyslogMessage {
-	const match = raw.match(/^<(\d{1,3})>\d?\s*(\S+)\s+(\S+)\s+(\S+)\s+(\S+)\s+(\S+)\s*(.*)/s);
-	if (!match) {
-		const nowNs = wallClockNs();
-		return {
-			facility: 1,
-			severity: 6,
-			timestamp: new Date(Math.floor(nowNs / 1_000_000)).toISOString(),
-			hostname: "-",
-			appName: "-",
-			procId: "-",
-			msgId: "-",
-			message: raw.trim(),
-			timestampNs: nowNs,
-		};
-	}
-	const pri = Number(match[1]);
-	return {
-		facility: pri >> 3,
-		severity: pri & 7,
-		timestamp: match[2],
-		hostname: match[3],
-		appName: match[4],
-		procId: match[5],
-		msgId: match[6],
-		message: (match[7] ?? "").trim(),
-		timestampNs: wallClockNs(),
-	};
-}
diff --git a/src/base/io/to-clickhouse.ts b/src/base/io/to-clickhouse.ts
deleted file mode 100644
index 149b0b54..00000000
--- a/src/base/io/to-clickhouse.ts
+++ /dev/null
@@ -1,64 +0,0 @@
-/**
- * ClickHouse insert sink IO — `toClickHouse` accumulates upstream `DATA`
- * values and inserts them in batches via the duck-typed
- * {@link ClickHouseInsertClientLike}.
- */
-
-import type { Node } from "@graphrefly/pure-ts/core";
-import type { ExtraOpts } from "./_internal.js";
-import { type ReactiveSinkHandle, reactiveSink, type SinkTransportError } from "./_sink.js";
-
-/** Duck-typed ClickHouse client for batch inserts. */
-export type ClickHouseInsertClientLike = {
-	insert(params: { table: string; values: unknown[]; format?: string }): Promise<void>;
-};
-
-/** Options for {@link toClickHouse}. */
-export type ToClickHouseOptions<T> = ExtraOpts & {
-	/** Batch size before auto-flush. Default: `1000`. */
-	batchSize?: number;
-	/** Flush interval in ms. Default: `5000`. */
-	flushIntervalMs?: number;
-	/** Insert format. Default: `"JSONEachRow"`. */
-	format?: string;
-	/** Transform value before insert. Default: identity. */
-	transform?: (value: T) => unknown;
-	onTransportError?: (err: SinkTransportError) => void;
-};
-
-/**
- * ClickHouse buffered batch insert sink.
- *
- * Accumulates upstream `DATA` values and inserts in batches.
- *
- * @param source - Upstream node.
- * @param client - ClickHouse client with `insert()`.
- * @param table - Target table name.
- * @param opts - Batch size, flush interval, and transform options.
- * @returns `BufferedSinkHandle`.
- *
- * @category extra
- */
-export function toClickHouse<T>(
-	source: Node<T>,
-	client: ClickHouseInsertClientLike,
-	table: string,
-	opts?: ToClickHouseOptions<T>,
-): ReactiveSinkHandle<T> {
-	const {
-		batchSize = 1000,
-		flushIntervalMs = 5000,
-		format = "JSONEachRow",
-		transform = (v: T) => v,
-		onTransportError,
-	} = opts ?? {};
-	return reactiveSink<T>(source, {
-		onTransportError,
-		batchSize,
-		flushIntervalMs,
-		serialize: transform,
-		sendBatch: async (batch) => {
-			await client.insert({ table, values: batch, format });
-		},
-	});
-}
diff --git a/src/base/io/to-csv.ts b/src/base/io/to-csv.ts
deleted file mode 100644
index 7ceb9206..00000000
--- a/src/base/io/to-csv.ts
+++ /dev/null
@@ -1,83 +0,0 @@
-/**
- * CSV file sink IO — `toCSV` adds CSV row formatting on top of
- * {@link toFile}. Uses the local `escapeCSVField` helper to quote cells that
- * contain delimiters / quotes / newlines.
- */
-
-import type { Node } from "@graphrefly/pure-ts/core";
-import type { ExtraOpts } from "./_internal.js";
-import type { ReactiveSinkHandle, SinkTransportError } from "./_sink.js";
-import { type FileWriterLike, toFile } from "./to-file.js";
-
-/** Options for {@link toCSV}. */
-export type ToCSVOptions<T> = ExtraOpts & {
-	/** Column names. Required — determines header row and field order. */
-	columns: string[];
-	/** Column delimiter. Default: `","`. */
-	delimiter?: string;
-	/** Whether to write a header row on first flush. Default: `true`. */
-	writeHeader?: boolean;
-	/** Extract a cell value from the row object. Default: `String(row[col] ?? "")`. */
-	cellExtractor?: (row: T, column: string) => string;
-	/** Flush interval in ms. Default: `0` (write-through). */
-	flushIntervalMs?: number;
-	/** Buffer size before auto-flush. Default: `Infinity`. */
-	batchSize?: number;
-	onTransportError?: (err: SinkTransportError) => void;
-};
-
-function escapeCSVField(value: string, delimiter: string): string {
-	if (value.includes(delimiter) || value.includes('"') || value.includes("\n")) {
-		return `"${value.replace(/"/g, '""')}"`;
-	}
-	return value;
-}
-
-/**
- * CSV file sink — writes upstream `DATA` as CSV rows.
- *
- * @param source - Upstream node.
- * @param writer - Writable file handle.
- * @param opts - Column definition, delimiter, and buffering options.
- * @returns `BufferedSinkHandle`.
- *
- * @category extra
- */
-export function toCSV<T>(
-	source: Node<T>,
-	writer: FileWriterLike,
-	opts: ToCSVOptions<T>,
-): ReactiveSinkHandle<T> {
-	const {
-		columns,
-		delimiter = ",",
-		writeHeader = true,
-		cellExtractor = (row: T, col: string) => String((row as Record<string, unknown>)[col] ?? ""),
-		flushIntervalMs = 0,
-		batchSize = Number.POSITIVE_INFINITY,
-		onTransportError,
-		...rest
-	} = opts;
-
-	let headerWritten = false;
-
-	const serializeRow = (row: T): string => {
-		if (!headerWritten && writeHeader) {
-			headerWritten = true;
-			const header = columns.map((c) => escapeCSVField(c, delimiter)).join(delimiter);
-			const data = columns
-				.map((c) => escapeCSVField(cellExtractor(row, c), delimiter))
-				.join(delimiter);
-			return `${header}\n${data}\n`;
-		}
-		return `${columns.map((c) => escapeCSVField(cellExtractor(row, c), delimiter)).join(delimiter)}\n`;
-	};
-
-	return toFile<T>(source, writer, {
-		serialize: serializeRow,
-		flushIntervalMs,
-		batchSize,
-		onTransportError,
-		...rest,
-	});
-}
diff --git a/src/base/io/to-file.ts b/src/base/io/to-file.ts
deleted file mode 100644
index 8e84915e..00000000
--- a/src/base/io/to-file.ts
+++ /dev/null
@@ -1,91 +0,0 @@
-/**
- * File-writer sink IO — `toFile` writes upstream `DATA` to any
- * `FileWriterLike` (e.g. `fs.createWriteStream`). Buffered or write-through
- * depending on `flushIntervalMs` / `batchSize`.
- *
- * Uses a duck-typed writable so the universal `extra/io` entry stays
- * browser-safe — the caller injects the Node `fs` writer at the boundary.
- */
-
-import type { Node } from "@graphrefly/pure-ts/core";
-import type { ExtraOpts } from "./_internal.js";
-import { type ReactiveSinkHandle, reactiveSink, type SinkTransportError } from "./_sink.js";
-
-/** Duck-typed writable file handle (compatible with `fs.createWriteStream`). */
-export type FileWriterLike = {
-	write(data: string | Uint8Array): boolean | undefined;
-	end(): void;
-};
-
-/** Options for {@link toFile}. */
-export type ToFileOptions<T> = ExtraOpts & {
-	/** Serialize a value to a string line. Default: `JSON.stringify(v) + "\n"`. */
-	serialize?: (value: T) => string;
-	/** `"append"` (default) or `"overwrite"` — controls initial file behavior hint. */
-	mode?: "append" | "overwrite";
-	/** Flush interval in ms. `0` = write-through (no buffering). Default: `0`. */
-	flushIntervalMs?: number;
-	/** Buffer size (item count) before auto-flush. Default: `Infinity` (timer only). */
-	batchSize?: number;
-	onTransportError?: (err: SinkTransportError) => void;
-};
-
-/**
- * File sink — writes upstream `DATA` values to a file-like writable.
- *
- * When `flushIntervalMs > 0` or `batchSize` is set, values are buffered and
- * flushed in batches. Otherwise, each value is written immediately.
- *
- * @param source - Upstream node.
- * @param writer - Writable file handle (e.g. `fs.createWriteStream(path, { flags: "a" })`).
- * @param opts - Serialization, buffering, and mode options.
- * @returns `BufferedSinkHandle` with `dispose()` and `flush()`.
- *
- * @category extra
- */
-export function toFile<T>(
-	source: Node<T>,
-	writer: FileWriterLike,
-	opts?: ToFileOptions<T>,
-): ReactiveSinkHandle<T> {
-	const {
-		serialize = (v: T) => `${JSON.stringify(v)}\n`,
-		flushIntervalMs = 0,
-		batchSize = Number.POSITIVE_INFINITY,
-		onTransportError,
-		mode: _mode,
-	} = opts ?? {};
-
-	const buffered = flushIntervalMs > 0 || batchSize < Number.POSITIVE_INFINITY;
-	// Pass `serialize` via reactiveSink's config so sync throws are classified as
-	// `stage:"serialize"` rather than `stage:"send"`. Inside send/sendBatch the
-	// payload is already a string (serialize output).
-	const handle: ReactiveSinkHandle<T> = buffered
-		? reactiveSink<T>(source, {
-				onTransportError,
-				batchSize,
-				flushIntervalMs,
-				serialize,
-				sendBatch: (chunk) => {
-					writer.write((chunk as unknown as string[]).join(""));
-				},
-			})
-		: reactiveSink<T>(source, {
-				onTransportError,
-				serialize,
-				send: (line) => {
-					writer.write(line as unknown as string);
-				},
-			});
-
-	const originalDispose = handle.dispose;
-	handle.dispose = () => {
-		originalDispose();
-		try {
-			writer.end();
-		} catch {
-			/* writer may already be closed */
-		}
-	};
-	return handle;
-}
diff --git a/src/base/io/to-loki.ts b/src/base/io/to-loki.ts
deleted file mode 100644
index 3945dc60..00000000
--- a/src/base/io/to-loki.ts
+++ /dev/null
@@ -1,69 +0,0 @@
-/**
- * Grafana Loki sink IO — `toLoki` pushes upstream `DATA` values as log
- * entries via the duck-typed {@link LokiClientLike} `push()` surface.
- */
-
-import type { Node } from "@graphrefly/pure-ts/core";
-import { wallClockNs } from "@graphrefly/pure-ts/core";
-import type { ExtraOpts } from "./_internal.js";
-import { type ReactiveSinkHandle, reactiveSink, type SinkTransportError } from "./_sink.js";
-
-/** Loki log stream entry. */
-export type LokiStream = {
-	stream: Record<string, string>;
-	values: [string, string][];
-};
-
-/** Duck-typed Loki push client (HTTP push API). */
-export type LokiClientLike = {
-	push(streams: { streams: LokiStream[] }): Promise<unknown>;
-};
-
-/** Options for {@link toLoki}. */
-export type ToLokiOptions<T> = ExtraOpts & {
-	/** Static labels applied to every log entry. */
-	labels?: Record<string, string>;
-	/** Extract the log line from a value. Default: `JSON.stringify(v)`. */
-	toLine?: (value: T) => string;
-	/** Extract additional labels from a value. Default: none. */
-	toLabels?: (value: T) => Record<string, string>;
-	onTransportError?: (err: SinkTransportError) => void;
-};
-
-/**
- * Grafana Loki sink — pushes upstream `DATA` values as log entries.
- *
- * @param source - Upstream node.
- * @param client - Loki-compatible client with `push()`.
- * @param opts - Label, serialization, and error options.
- * @returns Unsubscribe function.
- *
- * @category extra
- */
-export function toLoki<T>(
-	source: Node<T>,
-	client: LokiClientLike,
-	opts?: ToLokiOptions<T>,
-): ReactiveSinkHandle<T> {
-	const {
-		labels = {},
-		toLine = (v: T) => JSON.stringify(v),
-		toLabels,
-		onTransportError,
-	} = opts ?? {};
-	return reactiveSink<T>(source, {
-		onTransportError,
-		serialize: (value) => ({
-			line: toLine(value),
-			labels: toLabels ? { ...labels, ...toLabels(value) } : labels,
-		}),
-		send: async (payload) => {
-			const { line, labels: streamLabels } = payload as {
-				line: string;
-				labels: Record<string, string>;
-			};
-			const ts = `${wallClockNs()}`;
-			await client.push({ streams: [{ stream: streamLabels, values: [[ts, line]] }] });
-		},
-	});
-}
diff --git a/src/base/io/to-mongo.ts b/src/base/io/to-mongo.ts
deleted file mode 100644
index 4bc2b3df..00000000
--- a/src/base/io/to-mongo.ts
+++ /dev/null
@@ -1,45 +0,0 @@
-/**
- * MongoDB insert sink IO — `toMongo` inserts each upstream `DATA` value via
- * the duck-typed {@link MongoCollectionLike} `insertOne()`.
- */
-
-import type { Node } from "@graphrefly/pure-ts/core";
-import type { ExtraOpts } from "./_internal.js";
-import { type ReactiveSinkHandle, reactiveSink, type SinkTransportError } from "./_sink.js";
-
-/** Duck-typed MongoDB collection (compatible with `mongodb` driver). */
-export type MongoCollectionLike = {
-	insertOne(doc: unknown): Promise<unknown>;
-};
-
-/** Options for {@link toMongo}. */
-export type ToMongoOptions<T> = ExtraOpts & {
-	/** Transform value to a MongoDB document. Default: identity. */
-	toDocument?: (value: T) => unknown;
-	onTransportError?: (err: SinkTransportError) => void;
-};
-
-/**
- * MongoDB sink — inserts each upstream `DATA` value as a document.
- *
- * @param source - Upstream node.
- * @param collection - MongoDB collection with `insertOne()`.
- * @param opts - Document transform and error options.
- * @returns Unsubscribe function.
- *
- * @category extra
- */
-export function toMongo<T>(
-	source: Node<T>,
-	collection: MongoCollectionLike,
-	opts?: ToMongoOptions<T>,
-): ReactiveSinkHandle<T> {
-	const { toDocument = (v: T) => v, onTransportError } = opts ?? {};
-	return reactiveSink<T>(source, {
-		onTransportError,
-		serialize: toDocument,
-		send: async (doc) => {
-			await collection.insertOne(doc);
-		},
-	});
-}
diff --git a/src/base/io/to-postgres.ts b/src/base/io/to-postgres.ts
deleted file mode 100644
index ea3a6ddd..00000000
--- a/src/base/io/to-postgres.ts
+++ /dev/null
@@ -1,54 +0,0 @@
-/**
- * Postgres insert sink IO — `toPostgres` inserts each upstream `DATA` value
- * via the duck-typed {@link PostgresClientLike} `query()` surface.
- */
-
-import type { Node } from "@graphrefly/pure-ts/core";
-import type { ExtraOpts } from "./_internal.js";
-import { type ReactiveSinkHandle, reactiveSink, type SinkTransportError } from "./_sink.js";
-
-/** Duck-typed Postgres client (compatible with `pg.Client` / `pg.Pool`). */
-export type PostgresClientLike = {
-	query(sql: string, params?: unknown[]): Promise<unknown>;
-};
-
-/** Options for {@link toPostgres}. */
-export type ToPostgresOptions<T> = ExtraOpts & {
-	/** Build the SQL + params for an insert. Default: JSON insert into `table`. */
-	toSQL?: (value: T, table: string) => { sql: string; params: unknown[] };
-	onTransportError?: (err: SinkTransportError) => void;
-};
-
-/**
- * PostgreSQL sink — inserts each upstream `DATA` value as a row.
- *
- * @param source - Upstream node.
- * @param client - Postgres client with `query()`.
- * @param table - Target table name.
- * @param opts - SQL builder and error options.
- * @returns Unsubscribe function.
- *
- * @category extra
- */
-export function toPostgres<T>(
-	source: Node<T>,
-	client: PostgresClientLike,
-	table: string,
-	opts?: ToPostgresOptions<T>,
-): ReactiveSinkHandle<T> {
-	const {
-		toSQL = (v: T, t: string) => ({
-			sql: `INSERT INTO "${t.replace(/"/g, '""')}" (data) VALUES ($1)`,
-			params: [JSON.stringify(v)],
-		}),
-		onTransportError,
-	} = opts ?? {};
-	return reactiveSink<T>(source, {
-		onTransportError,
-		serialize: (value) => toSQL(value, table),
-		send: async (q) => {
-			const query = q as unknown as { sql: string; params: unknown[] };
-			await client.query(query.sql, query.params);
-		},
-	});
-}
diff --git a/src/base/io/to-s3.ts b/src/base/io/to-s3.ts
deleted file mode 100644
index cc92dc40..00000000
--- a/src/base/io/to-s3.ts
+++ /dev/null
@@ -1,87 +0,0 @@
-/**
- * S3 object-storage sink IO — `toS3` buffers upstream `DATA` values and
- * uploads them as NDJSON or JSON objects via the duck-typed
- * {@link S3ClientLike}.
- *
- * `S3ClientLike` is also used by `checkpointToS3` (in `./checkpoint.ts`).
- */
-
-import type { Node } from "@graphrefly/pure-ts/core";
-import { wallClockNs } from "@graphrefly/pure-ts/core";
-import type { ExtraOpts } from "./_internal.js";
-import { type ReactiveSinkHandle, reactiveSink, type SinkTransportError } from "./_sink.js";
-
-/** Duck-typed S3 client (compatible with AWS SDK v3 `S3Client.send(PutObjectCommand(...))`). */
-export type S3ClientLike = {
-	putObject(params: {
-		Bucket: string;
-		Key: string;
-		Body: string | Uint8Array;
-		ContentType?: string;
-	}): Promise<unknown>;
-};
-
-/** Options for {@link toS3}. */
-export type ToS3Options<T> = ExtraOpts & {
-	/** Output format. Default: `"ndjson"`. */
-	format?: "ndjson" | "json";
-	/** Generate the S3 key for each batch. Receives `(seq, wallClockNs)`. Default: ISO timestamp + sequence. */
-	keyGenerator?: (seq: number, timestampNs: number) => string;
-	/** Batch size before auto-flush. Default: `1000`. */
-	batchSize?: number;
-	/** Flush interval in ms. Default: `10000`. */
-	flushIntervalMs?: number;
-	/** Transform value before serialization. Default: identity. */
-	transform?: (value: T) => unknown;
-	onTransportError?: (err: SinkTransportError) => void;
-};
-
-/**
- * S3 object storage sink — buffers values and uploads as NDJSON or JSON objects.
- *
- * @param source - Upstream node.
- * @param client - S3-compatible client with `putObject()`.
- * @param bucket - S3 bucket name.
- * @param opts - Format, key generation, batching options.
- * @returns `BufferedSinkHandle`.
- *
- * @category extra
- */
-export function toS3<T>(
-	source: Node<T>,
-	client: S3ClientLike,
-	bucket: string,
-	opts?: ToS3Options<T>,
-): ReactiveSinkHandle<T> {
-	const {
-		format = "ndjson",
-		keyGenerator = (seq: number, timestampNs: number) => {
-			const ms = Math.floor(timestampNs / 1_000_000);
-			const ts = new Date(ms).toISOString().replace(/[:.]/g, "-");
-			return `data/${ts}-${seq}.${format === "ndjson" ? "ndjson" : "json"}`;
-		},
-		batchSize = 1000,
-		flushIntervalMs = 10000,
-		transform = (v: T) => v,
-		onTransportError,
-	} = opts ?? {};
-
-	const contentType = format === "ndjson" ? "application/x-ndjson" : "application/json";
-	let seq = 0;
-
-	return reactiveSink<T>(source, {
-		onTransportError,
-		batchSize,
-		flushIntervalMs,
-		serialize: transform,
-		sendBatch: async (batch) => {
-			seq += 1;
-			const body =
-				format === "ndjson"
-					? `${batch.map((v) => JSON.stringify(v)).join("\n")}\n`
-					: JSON.stringify(batch);
-			const key = keyGenerator(seq, wallClockNs());
-			await client.putObject({ Bucket: bucket, Key: key, Body: body, ContentType: contentType });
-		},
-	});
-}
diff --git a/src/base/io/to-tempo.ts b/src/base/io/to-tempo.ts
deleted file mode 100644
index 551fe13f..00000000
--- a/src/base/io/to-tempo.ts
+++ /dev/null
@@ -1,45 +0,0 @@
-/**
- * Grafana Tempo sink IO — `toTempo` pushes upstream `DATA` values as trace
- * spans (OTLP/HTTP shape) via the duck-typed {@link TempoClientLike}.
- */
-
-import type { Node } from "@graphrefly/pure-ts/core";
-import type { ExtraOpts } from "./_internal.js";
-import { type ReactiveSinkHandle, reactiveSink, type SinkTransportError } from "./_sink.js";
-
-/** Duck-typed Tempo span push client (OTLP/HTTP shape). */
-export type TempoClientLike = {
-	push(payload: { resourceSpans: unknown[] }): Promise<unknown>;
-};
-
-/** Options for {@link toTempo}. */
-export type ToTempoOptions<T> = ExtraOpts & {
-	/** Transform a value into OTLP resourceSpans entries. */
-	toResourceSpans?: (value: T) => unknown[];
-	onTransportError?: (err: SinkTransportError) => void;
-};
-
-/**
- * Grafana Tempo sink — pushes upstream `DATA` values as trace spans.
- *
- * @param source - Upstream node.
- * @param client - Tempo-compatible client with `push()`.
- * @param opts - Span transform and error options.
- * @returns Unsubscribe function.
- *
- * @category extra
- */
-export function toTempo<T>(
-	source: Node<T>,
-	client: TempoClientLike,
-	opts?: ToTempoOptions<T>,
-): ReactiveSinkHandle<T> {
-	const { toResourceSpans = (v: T) => [v], onTransportError } = opts ?? {};
-	return reactiveSink<T>(source, {
-		onTransportError,
-		serialize: toResourceSpans,
-		send: async (spans) => {
-			await client.push({ resourceSpans: spans as unknown[] });
-		},
-	});
-}
diff --git a/src/base/io/webhook.ts b/src/base/io/webhook.ts
deleted file mode 100644
index 2c52bd21..00000000
--- a/src/base/io/webhook.ts
+++ /dev/null
@@ -1,81 +0,0 @@
-/**
- * Webhook IO — `fromWebhook` is a thin wrapper over `externalProducer` that
- * exposes the standard `EmitTriad` (`emit` / `error` / `complete`) callback
- * shape to the caller's framework integration (Express, Fastify, Hono,
- * Cloudflare Workers, etc.).
- */
-
-import type { Node } from "@graphrefly/pure-ts/core";
-import {
-	type EmitTriad,
-	type ExternalRegister,
-	externalProducer,
-} from "../composition/external-register.js";
-import type { ExtraOpts } from "./_internal.js";
-
-/** Registration callback for {@link fromWebhook}. Alias of {@link ExternalRegister} over {@link EmitTriad}. */
-export type WebhookRegister<T> = ExternalRegister<EmitTriad<T>>;
-
-/**
- * Bridges HTTP webhook callbacks into a GraphReFly source.
- *
- * The `register` callback wires your runtime/framework callback to GraphReFly and may return a
- * cleanup function. This keeps the adapter runtime-agnostic while following the same producer
- * pattern as {@link fromEvent}.
- *
- * @param register - Registers webhook handlers (`emit`, `error`, `complete`) and optionally returns cleanup.
- * @param opts - Optional producer options.
- * @returns `Node<T>` — webhook payloads as `DATA`; teardown runs returned cleanup.
- *
- * @example
- * ```ts
- * import express from "express";
- * import { fromWebhook } from "@graphrefly/graphrefly";
- *
- * type HookPayload = { event: string; data: unknown };
- * const app = express();
- * app.use(express.json());
- *
- * const hook$ = fromWebhook<HookPayload>(({ emit, error }) => {
- *   const handler = (req: express.Request, res: express.Response) => {
- *     try {
- *       emit(req.body as HookPayload);
- *       res.status(200).send("ok");
- *     } catch (e) {
- *       error(e);
- *       res.status(500).send("error");
- *     }
- *   };
- *   app.post("/webhook", handler);
- *   return () => {
- *     // Express has no direct route-removal API in common use.
- *   };
- * });
- * ```
- *
- * @example Fastify
- * ```ts
- * import Fastify from "fastify";
- * import { fromWebhook } from "@graphrefly/graphrefly";
- *
- * const fastify = Fastify();
- * const hook$ = fromWebhook<any>(({ emit, error }) => {
- *   const handler = async (req: any, reply: any) => {
- *     try {
- *       emit(req.body);
- *       reply.code(200).send({ ok: true });
- *     } catch (e) {
- *       error(e);
- *       reply.code(500).send({ ok: false });
- *     }
- *   };
- *   fastify.post("/webhook", handler);
- *   return () => {};
- * });
- * ```
- *
- * @category extra
- */
-export function fromWebhook<T = unknown>(register: WebhookRegister<T>, opts?: ExtraOpts): Node<T> {
-	return externalProducer<T>(register, opts);
-}
diff --git a/src/base/io/websocket.ts b/src/base/io/websocket.ts
deleted file mode 100644
index 4f6a3cb5..00000000
--- a/src/base/io/websocket.ts
+++ /dev/null
@@ -1,322 +0,0 @@
-/**
- * WebSocket IO — `fromWebSocket` (DOM-style `WebSocketLike` source / register
- * variant), `toWebSocket` (sink with optional ack-tracking + retry),
- * `fromWebSocketReconnect` (`fromWebSocket` wrapped in retry-on-disconnect with
- * exponential backoff).
- */
-
-import { COMPLETE, ERROR, type Message, type Node, node } from "@graphrefly/pure-ts/core";
-import { retry } from "../resilience/retry.js";
-import { type ExtraOpts, sourceOpts } from "./_internal.js";
-import { type ReactiveSinkHandle, reactiveSink, type SinkTransportError } from "./_sink.js";
-
-/** WebSocket-like transport accepted by {@link fromWebSocket} / {@link toWebSocket}. */
-export type WebSocketLike = {
-	send(data: string | ArrayBufferLike | Blob | ArrayBufferView): void;
-	close(code?: number, reason?: string): void;
-	addEventListener(type: "message" | "error" | "close", listener: (ev: unknown) => void): void;
-	removeEventListener(type: "message" | "error" | "close", listener: (ev: unknown) => void): void;
-};
-
-export type WebSocketMessageEventLike = { data: unknown };
-export type WebSocketRegister<T> = (
-	emit: (payload: T) => void,
-	error: (err: unknown) => void,
-	complete: () => void,
-) => () => void;
-
-/**
- * Wraps a WebSocket as a GraphReFly producer source.
- *
- * Incoming socket messages are emitted as `DATA`; socket `error` emits `ERROR`; socket `close`
- * emits `COMPLETE`. Teardown detaches listeners and optionally closes the socket.
- *
- * @category extra
- */
-export function fromWebSocket<T = unknown>(
-	socket: WebSocketLike,
-	opts?: ExtraOpts & {
-		parse?: (payload: unknown, event: unknown) => T;
-		closeOnTeardown?: boolean;
-	},
-): Node<T>;
-export function fromWebSocket<T = unknown>(
-	register: WebSocketRegister<T>,
-	opts?: ExtraOpts & {
-		parse?: (payload: unknown, event: unknown) => T;
-		closeOnTeardown?: boolean;
-	},
-): Node<T>;
-export function fromWebSocket<T = unknown>(
-	socketOrRegister: WebSocketLike | WebSocketRegister<T>,
-	opts?: ExtraOpts & {
-		parse?: (payload: unknown, event: unknown) => T;
-		closeOnTeardown?: boolean;
-	},
-): Node<T> {
-	const { parse, closeOnTeardown = false, ...rest } = opts ?? {};
-	return node<T>(
-		[],
-		(_data, a) => {
-			let active = true;
-			let cleanup: (() => void) | undefined;
-			const runCleanup = () => {
-				const fn = cleanup;
-				cleanup = undefined;
-				fn?.();
-			};
-			const terminate = (message: Message) => {
-				if (!active) return;
-				active = false;
-				a.down([message]);
-				runCleanup();
-			};
-			const emit = (raw: unknown, event: unknown = raw) => {
-				if (!active) return;
-				try {
-					const payload =
-						raw !== null && typeof raw === "object" && "data" in (raw as Record<string, unknown>)
-							? (raw as WebSocketMessageEventLike).data
-							: raw;
-					const parsed = parse ? parse(payload, event) : (payload as T);
-					a.emit(parsed);
-				} catch (err) {
-					terminate([ERROR, err]);
-				}
-			};
-			const error = (err: unknown) => {
-				terminate([ERROR, err]);
-			};
-			const complete = () => {
-				terminate([COMPLETE]);
-			};
-			if (typeof socketOrRegister === "function") {
-				try {
-					cleanup = socketOrRegister(emit, error, complete);
-					if (typeof cleanup !== "function") {
-						throw new Error(
-							"fromWebSocket register contract violation: register must return cleanup callable",
-						);
-					}
-				} catch (err) {
-					terminate([ERROR, err]);
-				}
-				return {
-					onDeactivation: () => {
-						active = false;
-						runCleanup();
-					},
-				};
-			}
-
-			const ws = socketOrRegister;
-			const onMessage = (event: unknown) => emit(event, event);
-			const onError = (event: unknown) => error(event);
-			const onClose = () => complete();
-			ws.addEventListener("message", onMessage);
-			ws.addEventListener("error", onError);
-			ws.addEventListener("close", onClose);
-			cleanup = () => {
-				ws.removeEventListener("message", onMessage);
-				ws.removeEventListener("error", onError);
-				ws.removeEventListener("close", onClose);
-				if (closeOnTeardown) ws.close();
-			};
-			return {
-				onDeactivation: () => {
-					active = false;
-					runCleanup();
-				},
-			};
-		},
-		sourceOpts(rest),
-	);
-}
-
-/** Options for {@link toWebSocket}. */
-export type ToWebSocketOptions<T> = {
-	/** Serialize DATA payloads before `socket.send(...)`. */
-	serialize?: (value: T) => string | ArrayBufferLike | Blob | ArrayBufferView;
-	/** Close socket when upstream emits COMPLETE. Default: `true`. */
-	closeOnComplete?: boolean;
-	/** Close socket when upstream emits ERROR. Default: `true`. */
-	closeOnError?: boolean;
-	/** Optional close code used when close is triggered by terminal tuples. */
-	closeCode?: number;
-	/** Optional close reason used when close is triggered by terminal tuples. */
-	closeReason?: string;
-	/** Structured callback — uses the unified {@link SinkTransportError} shape. */
-	onTransportError?: (event: SinkTransportError) => void;
-	/** Retry configuration — passed through to {@link reactiveSink}. */
-	retry?: ReactiveSinkHandle<T> extends infer _
-		? Parameters<typeof reactiveSink<T>>[1]["retry"]
-		: never;
-	/** Backpressure configuration — passed through to {@link reactiveSink}. */
-	backpressure?: Parameters<typeof reactiveSink<T>>[1]["backpressure"];
-	/** Reactive stop signal — when it emits any DATA / terminal, the sink tears down. */
-	stopOn?: Node<unknown>;
-};
-
-/**
- * Forwards upstream `DATA` payloads to a WebSocket via `send`.
- *
- * Returns a {@link ReactiveSinkHandle} — every transport outcome (including
- * socket `close` events) surfaces on the `errors` / `failed` / `sent` /
- * `inFlight` companions.
- *
- * @category extra
- */
-export function toWebSocket<T>(
-	source: Node<T>,
-	socket: WebSocketLike,
-	opts?: ToWebSocketOptions<T>,
-): ReactiveSinkHandle<T> {
-	const {
-		serialize = (value: T) => {
-			if (
-				typeof value === "string" ||
-				value instanceof Blob ||
-				value instanceof ArrayBuffer ||
-				ArrayBuffer.isView(value)
-			) {
-				return value as string | ArrayBufferLike | Blob | ArrayBufferView;
-			}
-			try {
-				return JSON.stringify(value);
-			} catch {
-				return String(value);
-			}
-		},
-		closeOnComplete = true,
-		closeOnError = true,
-		closeCode,
-		closeReason,
-		onTransportError,
-		retry: retryOpt,
-		backpressure,
-		stopOn,
-	} = opts ?? {};
-
-	let socketClosed = false;
-	const closeSocket = (trigger?: Message) => {
-		if (socketClosed) return;
-		socketClosed = true;
-		try {
-			socket.close(closeCode, closeReason);
-		} catch (err) {
-			const error = err instanceof Error ? err : new Error(String(err));
-			try {
-				onTransportError?.({ stage: "close", error, value: undefined, message: trigger });
-			} catch {
-				/* user hook must not escape */
-			}
-		}
-	};
-
-	// External close listener — installed before sink construction so we can
-	// pass its cleanup via reactiveSink's `onDispose` hook. That hook fires on
-	// any teardown path (user `.dispose()`, `stopOn` signal, upstream
-	// terminal) — guaranteeing the listener is removed even when the reactive
-	// sink's internal dispose fires without going through a wrapper.
-	let externalCloseHandler: ((ev: unknown) => void) | null = null;
-	const removeExternalCloseHandler = () => {
-		if (externalCloseHandler) {
-			try {
-				socket.removeEventListener("close", externalCloseHandler);
-			} catch {
-				/* removeEventListener may throw on some environments when socket is dead */
-			}
-			externalCloseHandler = null;
-		}
-	};
-
-	const handle = reactiveSink<T>(source, {
-		onTransportError,
-		serialize: (value) => {
-			const s = serialize(value);
-			if (s === undefined) {
-				throw new Error("serialize returned undefined");
-			}
-			return s;
-		},
-		retry: retryOpt,
-		backpressure,
-		stopOn,
-		onDispose: removeExternalCloseHandler,
-		send: (payload) => {
-			socket.send(payload as string | ArrayBufferLike | Blob | ArrayBufferView);
-		},
-		onUpstreamMessage: (msg) => {
-			if (msg[0] === COMPLETE && closeOnComplete) closeSocket(msg);
-			else if (msg[0] === ERROR && closeOnError) closeSocket(msg);
-		},
-	});
-
-	// Listen for external socket `close` events to tear the sink down.
-	externalCloseHandler = () => {
-		socketClosed = true;
-		handle.dispose();
-	};
-	socket.addEventListener("close", externalCloseHandler);
-	return handle;
-}
-
-/** Options for {@link fromWebSocketReconnect}. */
-export type FromWebSocketReconnectOptions<T> = ExtraOpts & {
-	/** Optional parser applied to incoming messages. */
-	parse?: (payload: unknown, event: unknown) => T;
-	/**
-	 * Max reconnect attempts. **Required** — forwarded to {@link retry} as
-	 * `count`, which is fail-loud (D4): `retry({ backoff })` without an explicit
-	 * `count` throws. Pass `Number.POSITIVE_INFINITY` to explicitly opt in to
-	 * unbounded reconnection (F-WS, 2026-05-18 smell sweep — previously the
-	 * `Infinity` default was advertised but already threw at construction).
-	 */
-	maxRetries: number;
-	/** Backoff strategy (ns) or preset name. Default: `"exponential"`. */
-	backoff?: Parameters<typeof retry>[1] extends infer O
-		? O extends { backoff?: infer B }
-			? B
-			: never
-		: never;
-	/** Close the socket on teardown. Default: `true`. */
-	closeOnTeardown?: boolean;
-};
-
-/**
- * Reconnecting WebSocket source — each connection attempt calls `factory` to
- * obtain a fresh {@link WebSocketLike}; on `close` (treated as terminal
- * `COMPLETE`), {@link retry} rebuilds the inner source and reconnects.
- *
- * For transient errors, {@link retry} retries with the configured
- * backoff. On `maxRetries` exhaustion, terminal `ERROR` propagates.
- *
- * @param factory - Invoked per reconnect to create a fresh WebSocket.
- * @param opts - Parse, retry, and close options.
- *
- * @example
- * ```ts
- * import { fromWebSocketReconnect } from "@graphrefly/graphrefly";
- * const ws$ = fromWebSocketReconnect(
- *   () => new WebSocket("wss://example/stream"),
- *   { backoff: "exponential", maxRetries: 10 },
- * );
- * ```
- *
- * @category extra
- */
-export function fromWebSocketReconnect<T = unknown>(
-	factory: () => WebSocketLike,
-	opts: FromWebSocketReconnectOptions<T>,
-): Node<T> {
-	const { parse, maxRetries, backoff = "exponential", closeOnTeardown = true, ...rest } = opts;
-	return retry<T>(
-		() =>
-			fromWebSocket<T>(factory(), {
-				parse,
-				closeOnTeardown,
-				...rest,
-			}),
-		{ count: maxRetries, backoff },
-	).node;
-}
diff --git a/src/base/meta/attach-edge-meta.ts b/src/base/meta/attach-edge-meta.ts
deleted file mode 100644
index 720199b3..00000000
--- a/src/base/meta/attach-edge-meta.ts
+++ /dev/null
@@ -1,62 +0,0 @@
-/**
- * Attach-edge meta — a "soft forward edge" declaration for nodes that
- * imperatively publish into a target node via subscribe-and-emit
- * (sanctioned per spec §5.9, but invisible to the dep-graph walker).
- *
- * Visible to:
- *
- * - **`Graph.describe()`** — resolves the {@link Node} ref to its qualified
- *   path string at snapshot time, the same way dep-list entries are
- *   resolved. After `describe()`, `meta.attachTarget` is a path string,
- *   not a Node ref.
- * - **{@link explainPath}** — treats the resolved path as a "soft forward
- *   edge" so the causal chain walks past imperative-attach hops (e.g.,
- *   `topicBridge.attach → dst::events`) that have no declared dep.
- *
- * Wave propagation does NOT follow soft forward edges — the protocol-level
- * dep graph is unchanged. Soft edges are an **explainability concern only**.
- * If the wave needs to see the edge, declare a normal `dep`; if a human
- * (or `explain()`) needs to see the edge but the protocol doesn't, this is
- * the right tool.
- *
- * @example
- * ```ts
- * // Inside a factory whose body does `source.subscribe(... target.publish(v))`:
- * this.attach = this.effect(
- *   "attach",
- *   ["output"],
- *   () => {
- *     for (const v of outputRef.cache) targetTopic.publish(v);
- *   },
- *   {
- *     meta: {
- *       ...messagingMeta("topic_bridge_attach"),
- *       ...attachEdgeMeta(targetTopic.events),
- *     },
- *   },
- * );
- * ```
- *
- * **Single-target only.** If a factory forwards into multiple targets,
- * mount one `attach` effect per target. A future `attachTargets: Node[]`
- * shape may land when a real consumer surfaces — single target covers
- * topicBridge / worker-bridge / single-sink relay today.
- *
- * @module
- */
-
-import type { Node } from "@graphrefly/pure-ts/core";
-
-/**
- * Build a meta fragment declaring a soft forward edge into `target`.
- * Composes with `domainMeta` / `messagingMeta` / etc. via spread.
- *
- * The returned object has a single key, `attachTarget`, carrying the Node
- * reference at construction time. {@link Graph.describe} replaces the Node
- * ref with the target's qualified path string at snapshot time.
- *
- * @param target - The Node this factory imperatively publishes into.
- */
-export function attachEdgeMeta(target: Node<unknown>): { attachTarget: Node<unknown> } {
-	return { attachTarget: target };
-}
diff --git a/src/base/meta/domain-meta.ts b/src/base/meta/domain-meta.ts
deleted file mode 100644
index 9365abcc..00000000
--- a/src/base/meta/domain-meta.ts
+++ /dev/null
@@ -1,33 +0,0 @@
-/**
- * Metadata helpers for pattern-layer nodes (Tier 2.2 promotion from
- * `patterns/_internal/`).
- *
- * Each domain (orchestration, messaging, reduction, ai, cqrs, domain_template,
- * memory, lens, audit, harness) shares the same metadata convention. Promoted
- * to `extra/` so non-patterns code (and downstream consumers building their
- * own domain primitives) can use the same shape.
- *
- * @module
- */
-
-/**
- * Build a domain metadata object for pattern-layer nodes.
- *
- * Each domain follows the same shape: `{ [domain]: true, [domain]_type: kind, ...extra }`.
- *
- * @param domain - The domain tag (e.g. `"orchestration"`, `"ai"`, `"cqrs"`).
- * @param kind - The specific type within the domain (e.g. `"gate"`, `"prompt"`).
- * @param extra - Additional metadata to merge.
- * @returns Metadata object.
- */
-export function domainMeta(
-	domain: string,
-	kind: string,
-	extra?: Record<string, unknown>,
-): Record<string, unknown> {
-	return {
-		[domain]: true,
-		[`${domain}_type`]: kind,
-		...(extra ?? {}),
-	};
-}
diff --git a/src/base/meta/emit-to-meta.ts b/src/base/meta/emit-to-meta.ts
deleted file mode 100644
index ab969b23..00000000
--- a/src/base/meta/emit-to-meta.ts
+++ /dev/null
@@ -1,29 +0,0 @@
-/**
- * emitToMeta — forward DATA to a meta companion node via tier-3 deferral.
- *
- * Extracted from patterns/_internal/index.ts during cleave A2.
- */
-
-import type { Node } from "@graphrefly/pure-ts/core";
-import { DATA, defaultConfig, downWithBatch } from "@graphrefly/pure-ts/core";
-
-// emitToMeta
-// ---------------------------------------------------------------------------
-
-/**
- * Forward a single `[DATA, value]` to a meta companion node via tier-3
- * deferral, tolerating absent companions. Used by patterns that publish
- * per-wave statistics alongside their main output (cache-hit-rate,
- * segment-count, layout-time-ns, etc.) — subscribers see the parent's
- * DATA first because phase-2 completes before phase-3 during drain.
- *
- * // Expands to: `if (meta) downWithBatch(meta, [[Type, value]])` with null-guard.
- *
- * @internal
- */
-export function emitToMeta<T>(metaNode: Node<T> | undefined, value: T): void {
-	if (metaNode == null) return;
-	downWithBatch((msgs) => metaNode.down(msgs), [[DATA, value]], defaultConfig.tierOf);
-}
-
-// ---------------------------------------------------------------------------
diff --git a/src/base/meta/index.ts b/src/base/meta/index.ts
deleted file mode 100644
index 8f5deeac..00000000
--- a/src/base/meta/index.ts
+++ /dev/null
@@ -1,11 +0,0 @@
-/**
- * Base meta — domain-meta and emit-to-meta utilities.
- *
- * keepalive is substrate (pure-ts/extra); import from @graphrefly/pure-ts/extra.
- *
- * @module
- */
-
-export * from "./attach-edge-meta.js";
-export * from "./domain-meta.js";
-export * from "./emit-to-meta.js";
diff --git a/src/base/mutation/index.ts b/src/base/mutation/index.ts
deleted file mode 100644
index d0f59194..00000000
--- a/src/base/mutation/index.ts
+++ /dev/null
@@ -1,483 +0,0 @@
-/**
- * Universal mutation framework (Phase 14 — DS-14 locked 2026-05-05).
- *
- * Single `mutate(act, opts)` factory replaces the prior `lightMutation` +
- * `wrapMutation` two-tier split (pre-1.0 break per Q-O2).
- *
- * Two frames:
- * - `"inline"` — no batch; up() runs raw. Seq bumps before action; persists
- *   on throw. Hot-path-friendly for atomic single-write mutations.
- * - `"transactional"` — opens `batch(() => up(...))`. On throw: batch discards
- *   deferred deliveries, then `down()` runs (if provided), then failure record.
- *
- * Phase-4 primitives share the same shape: imperative mutation methods +
- * closure state + reactive audit log + freeze-at-entry + rollback-on-throw.
- * This module factors out the common machinery so each primitive becomes
- * declarative wiring over typed audit records.
- */
-
-import {
-	batch,
-	DATA,
-	DIRTY,
-	type Node,
-	type NodeGuard,
-	node,
-	policy,
-	wallClockNs,
-} from "@graphrefly/pure-ts/core";
-import {
-	type ReactiveLogBundle,
-	type ReactiveLogOptions,
-	reactiveLog,
-} from "@graphrefly/pure-ts/extra";
-import { Graph } from "@graphrefly/pure-ts/graph";
-
-// ── tryIncrementBounded ──────────────────────────────────────────────────
-
-/**
- * Bounded increment for a self-owned counter state node.
- *
- * Reads `counter.cache`, bumps by `by` (default 1) if `cur + by <= cap`,
- * writes back. Returns `false` when the cap would be exceeded (no-op write).
- * Documented P3 exception: the counter is not a declared dep of the caller —
- * it's a private budget read+written from a single call site. This helper
- * keeps the `.cache` access in one named place so caller bodies (which may
- * be inside reactive fn execution paths) stay free of cross-node `.cache`
- * reads.
- *
- * **Safety today:**
- *   1. Single-threaded JS runner never invokes the caller concurrently.
- *   2. `counter.down` writes the cache synchronously before returning, so
- *      synchronous re-entry through a downstream publish reads the
- *      freshly-incremented value — no double-count.
- *
- * **Future risk:** under a free-threaded runner (PY no-GIL or hypothetical
- * concurrent TS runner), two concurrent firings could still race. Revisit
- * when that surfaces.
- *
- * @param counter - Self-owned counter Node. Caller is the sole writer.
- * @param cap - Upper bound (inclusive). Pass `Number.MAX_SAFE_INTEGER` for
- *              "effectively unbounded" use cases (e.g. token meters).
- * @param by - Delta to add (default `1`). Must be a finite non-negative
- *             number; callers should pre-validate. Overflow-safe via
- *             `by > cap - cur` check rather than `cur + by >= cap`.
- */
-export function tryIncrementBounded(counter: Node<number>, cap: number, by = 1): boolean {
-	const cur = (counter.cache as number | undefined) ?? 0;
-	if (by > cap - cur) return false;
-	counter.down([[DIRTY], [DATA, cur + by]]);
-	return true;
-}
-
-// ── Audit record schema ──────────────────────────────────────────────────
-
-/** Shared base shape for every audit record. Per-primitive types extend this. */
-export interface BaseAuditRecord {
-	readonly t_ns: number;
-	readonly seq?: number;
-	readonly handlerVersion?: { id: string; version: string | number };
-}
-
-// ── Default audit guard ──────────────────────────────────────────────────
-
-/**
- * Allow `observe` and `signal`; deny external `write` on the audit log so
- * consumers can subscribe + signal-bridge but cannot inject fake records.
- */
-export const DEFAULT_AUDIT_GUARD: NodeGuard = policy((allow, deny) => {
-	allow("observe");
-	allow("signal");
-	deny("write");
-});
-
-// ── createAuditLog ───────────────────────────────────────────────────────
-
-export type AuditLogOpts<R extends BaseAuditRecord> = {
-	name: string;
-	/** Bounded retention; default 1024 per Audit 2 / cross-cutting bounded-default policy. */
-	retainedLimit?: number;
-	/** Override the default audit guard. */
-	guard?: NodeGuard;
-	/** Mount the audit `entries` Node under this graph (and activate withLatest). */
-	graph?: Graph;
-	/** Pass-through to {@link reactiveLog}. */
-	versioning?: ReactiveLogOptions<R>["versioning"];
-};
-
-/**
- * Build a reactive audit log with sane defaults: bounded retention, deny-write
- * guard, `withLatest()` companions activated. Returns the {@link ReactiveLogBundle}
- * directly — primitives expose this as `<primitive>.events` / `.decisions` /
- * `.dispatches` / `.invocations` and alias it as `.audit`.
- *
- * @category internal
- */
-export function createAuditLog<R extends BaseAuditRecord>(
-	opts: AuditLogOpts<R>,
-): ReactiveLogBundle<R> {
-	const log = reactiveLog<R>([], {
-		name: opts.name,
-		maxSize: opts.retainedLimit ?? 1024,
-		guard: opts.guard ?? DEFAULT_AUDIT_GUARD,
-		...(opts.versioning != null ? { versioning: opts.versioning } : {}),
-	});
-	// Lazy companion activation up-front so `bundle.lastValue` / `hasLatest`
-	// are queryable without an explicit `withLatest()` call.
-	log.withLatest();
-	if (opts.graph) {
-		opts.graph.add(log.entries, { name: opts.name });
-	}
-	return log;
-}
-
-/**
- * Read-only projection of a {@link ReactiveLogBundle}. Exposes only the
- * observation surface (`entries` / `size` / `at` / `withLatest` / `lastValue`
- * / `view` / `scan` / `mutationLog`) — the mutators (`append` / `appendMany`
- * / `clear` / `trimHead` / `attach` / `attachStorage`) and the lifecycle
- * disposers are intentionally absent.
- */
-export type ReadonlyAuditLog<R> = Pick<
-	ReactiveLogBundle<R>,
-	"entries" | "size" | "at" | "withLatest" | "lastValue" | "view" | "scan" | "mutationLog"
->;
-
-/**
- * Wrap an audit log so the `.audit` alias a primitive exposes (the Audit-2
- * `.audit` duplication convention — `saga.audit` / `cqrs.audit` /
- * `jobQueue.audit` / `processManager.audit`) is a **stable read-only view**,
- * not the live mutable bundle. Closes M7: a consumer calling
- * `someGraph.audit.append(...)` would otherwise silently mutate the owning
- * primitive's canonical log. The returned object is frozen and shares the
- * underlying log's nodes (zero copy) — reads are byte-identical to the live
- * bundle; mutators are simply not present (compile-time) and the object is
- * frozen (run-time defense for JS callers).
- *
- * @category internal
- */
-export function readonlyAuditLog<R>(log: ReactiveLogBundle<R>): ReadonlyAuditLog<R> {
-	return Object.freeze({
-		get entries() {
-			return log.entries;
-		},
-		get size() {
-			return log.size;
-		},
-		get lastValue() {
-			return log.lastValue;
-		},
-		get mutationLog() {
-			return log.mutationLog;
-		},
-		at: log.at.bind(log),
-		withLatest: log.withLatest.bind(log),
-		view: log.view.bind(log),
-		scan: log.scan.bind(log),
-	}) satisfies ReadonlyAuditLog<R>;
-}
-
-// ── Universal mutation factory (Phase 14 — DS-14 lock Q-O2/Q-O3) ────────
-//
-// Single `mutate(act, opts)` factory. Two frames:
-//
-// - `"inline"` — no batch frame; up() runs raw. Seq bumps before action;
-//   persists on throw. Hot-path-friendly for atomic single-write mutations.
-//
-// - `"transactional"` — opens `batch(() => up(...))`. On throw: batch discards
-//   deferred deliveries, then `down()` runs, then failure record persists.
-//
-// **Heuristic:** if your imperative method's body is one or two lines (mutate
-// state, emit), use `frame: "inline"`. If it runs a user-supplied handler or
-// has multiple steps that could leave inconsistent state mid-throw, use
-// `frame: "transactional"`.
-
-export type FailureMeta = {
-	t_ns: number;
-	seq?: number;
-	errorType: string;
-};
-
-export type SuccessMeta = {
-	t_ns: number;
-	seq?: number;
-};
-
-/**
- * Mutation action shape. Plain function shorthand auto-wraps as `{ up: fn }`.
- *
- * - `up` — the mutation action (the "up migration").
- * - `down` — optional rollback for closure mutations that `batch()` can't
- *   reach. Receives the SAME frozen args as `up`. Runs AFTER batch reactive
- *   rollback, BEFORE the failure record. Throws inside `down` are
- *   console.error'd without masking the original error. Only meaningful
- *   with `frame: "transactional"`.
- */
-export type MutationAct<TArgs extends readonly unknown[], TResult> = {
-	up: (...args: TArgs) => TResult;
-	down?: (...args: TArgs) => void;
-};
-
-export type MutationFrame = "inline" | "transactional";
-
-export type MutateOpts<TArgs extends readonly unknown[], TResult, R extends BaseAuditRecord> = {
-	/** Frame mode. `"inline"` = no batch; `"transactional"` = batch + rollback. */
-	frame: MutationFrame;
-	/**
-	 * Optional log to append records to. When omitted, the wrapper still
-	 * provides freeze / seq-advance / rollback-on-throw but skips record
-	 * emission — useful for primitives that want centralized mutation
-	 * semantics without a dedicated log surface (e.g. `Topic.publish`).
-	 */
-	log?: ReactiveLogBundle<R>;
-	/** Build the success record from the action's args + result + meta. */
-	onSuccessRecord?: (args: TArgs, result: TResult, meta: SuccessMeta) => R | undefined;
-	/** Build the failure record from the args + error + meta. */
-	onFailureRecord?: (args: TArgs, error: unknown, meta: FailureMeta) => R | undefined;
-	/** Deep-freeze args at entry (default `true`). Opt out for hot paths. */
-	freeze?: boolean;
-	/** Optional sequence cursor — auto-advanced and stamped onto records. */
-	seq?: Node<number>;
-	/** Optional handler version — stamped per Audit 5. */
-	handlerVersion?: { id: string; version: string | number };
-};
-
-function deepFreeze<T>(value: T): T {
-	if (value === null || typeof value !== "object" || Object.isFrozen(value)) return value;
-	for (const k of Object.keys(value as Record<string, unknown>)) {
-		deepFreeze((value as Record<string, unknown>)[k]);
-	}
-	return Object.freeze(value);
-}
-
-/**
- * Universal mutation factory (Phase 14 — DS-14 Q-O2).
- *
- * Replaces the prior `lightMutation` + `wrapMutation` two-tier split.
- * Single factory with `frame: "inline" | "transactional"` discriminant.
- *
- * @param act - The mutation action. Either a plain function (auto-wrapped as
- *   `{ up: fn }`) or a `{ up, down? }` object for explicit rollback.
- * @param opts - Configuration: frame, log, record builders, freeze, seq.
- * @returns A typed wrapper function with the same signature as `act.up`.
- */
-export function mutate<TArgs extends readonly unknown[], TResult, R extends BaseAuditRecord>(
-	act: MutationAct<TArgs, TResult> | ((...args: TArgs) => TResult),
-	opts: MutateOpts<TArgs, TResult, R>,
-): (...args: TArgs) => TResult {
-	const { up, down } = typeof act === "function" ? { up: act, down: undefined } : act;
-	const freeze = opts.freeze ?? true;
-
-	if (opts.frame === "inline") {
-		return function wrapped(...args: TArgs): TResult {
-			const sealed = freeze ? (args.map(deepFreeze) as unknown as TArgs) : args;
-			const t_ns = wallClockNs();
-			const seq = opts.seq ? bumpCursor(opts.seq) : undefined;
-			try {
-				const result = up(...sealed);
-				if (opts.log && opts.onSuccessRecord) {
-					appendAudit<TArgs, TResult, R, SuccessMeta>(
-						opts.log,
-						opts.onSuccessRecord,
-						sealed,
-						result,
-						{ t_ns, seq },
-						opts.handlerVersion,
-					);
-				}
-				return result;
-			} catch (err) {
-				if (opts.log && opts.onFailureRecord) {
-					const errorType = err instanceof Error ? err.name : typeof err;
-					appendAudit<TArgs, unknown, R, FailureMeta>(
-						opts.log,
-						opts.onFailureRecord,
-						sealed,
-						err,
-						{ t_ns, seq, errorType },
-						opts.handlerVersion,
-					);
-				}
-				throw err;
-			}
-		};
-	}
-
-	// frame === "transactional"
-	return function wrapped(...args: TArgs): TResult {
-		const sealed = freeze ? (args.map(deepFreeze) as unknown as TArgs) : args;
-		const t_ns = wallClockNs();
-		let result: TResult;
-		let captured: unknown;
-		let captureSet = false;
-		let seq: number | undefined;
-		try {
-			batch(() => {
-				if (opts.seq) seq = bumpCursor(opts.seq);
-				try {
-					result = up(...sealed);
-					if (opts.log && opts.onSuccessRecord) {
-						appendAudit<TArgs, TResult, R, SuccessMeta>(
-							opts.log,
-							opts.onSuccessRecord,
-							sealed,
-							result,
-							{ t_ns, seq },
-							opts.handlerVersion,
-						);
-					}
-				} catch (err) {
-					captured = err;
-					captureSet = true;
-					throw err;
-				}
-			});
-		} catch (outerErr) {
-			// Fire `down` AFTER batch's reactive rollback, BEFORE failure record.
-			// Gate on `captureSet` — if the throw came from outside the inner try
-			// (framework-level batch error before action ran), don't fire down.
-			if (captureSet && down) {
-				try {
-					down(...sealed);
-				} catch (downErr) {
-					console.error(
-						`mutate: down hook threw — original action error preserved (${
-							captured instanceof Error ? captured.name : typeof captured
-						}). Down error:`,
-						downErr,
-					);
-				}
-			}
-			if (captureSet && opts.log && opts.onFailureRecord) {
-				const errorType = captured instanceof Error ? captured.name : typeof captured;
-				appendAudit<TArgs, unknown, R, FailureMeta>(
-					opts.log,
-					opts.onFailureRecord,
-					sealed,
-					captured,
-					{ t_ns, seq, errorType },
-					opts.handlerVersion,
-				);
-			}
-			throw captureSet ? captured : outerErr;
-		}
-		return result!;
-	};
-}
-
-/**
- * Advance a cursor node and return the new value. Emits `[DIRTY], [DATA, next]`
- * directly on the cursor — atomic outside a batch, rollback-discardable inside.
- *
- * Resets to `0` if the cursor cache is missing, non-numeric, `NaN`, or
- * non-finite (e.g. corrupted by `restore()` from a malformed snapshot, or
- * by a misbehaving codec). `??` alone would let `NaN` and `""` pass through
- * and silently corrupt audit ordering downstream.
- *
- * **Silent reset diagnostic (EH-12).** When the cache holds a non-numeric
- * value at bump time, the cursor restarts at 0 and the next bump returns 1
- * — colliding with the seq stamped on the very first record after construct.
- * To make seq-monotonicity violations after a restore visible to operators,
- * the helper emits a one-shot `console.warn` per cursor instance describing
- * the offending value. The cursor is identified by a `WeakSet<Node<number>>`
- * so the warning fires exactly once per node — repeat malformed bumps stay
- * quiet to avoid log spam. Production callers wanting to suppress can swap
- * the global `console` (universal-safe code path; no Node-only API used).
- *
- * Works whether or not the cursor has any subscribers — `down` updates the
- * cache regardless, so primitives that bump before consumers attach (e.g.
- * `JobQueueGraph.enqueue`) still see a coherent sequence.
- *
- * @category internal
- */
-const _bumpCursorWarned = new WeakSet<Node<number>>();
-export function bumpCursor(seq: Node<number>): number {
-	const raw = seq.cache;
-	const valid = typeof raw === "number" && Number.isFinite(raw);
-	if (!valid && raw !== undefined && !_bumpCursorWarned.has(seq)) {
-		_bumpCursorWarned.add(seq);
-		console.warn(
-			`bumpCursor: cursor cache held a non-numeric value (${String(raw)}); resetting to 0. ` +
-				"Causes include: a snapshot codec round-tripping the cursor as a string / null / NaN, " +
-				"OR a malformed initial seed (e.g. state<number>(NaN)). " +
-				"Audit consumers may see colliding seq values after this point.",
-		);
-	}
-	const cur = valid ? raw : 0;
-	const next = cur + 1;
-	seq.down([[DIRTY], [DATA, next]]);
-	return next;
-}
-
-/**
- * Build a record via the supplied builder, stamp `handlerVersion` if present,
- * and append it to the audit log. `undefined` records are skipped (callers
- * pass an `onSuccess` / `onFailure` that returns `undefined` to opt out per
- * call).
- *
- * @category internal
- */
-export function appendAudit<
-	TArgs extends readonly unknown[],
-	TValue,
-	R extends BaseAuditRecord,
-	M extends SuccessMeta | FailureMeta,
->(
-	audit: ReactiveLogBundle<R>,
-	builder: (args: TArgs, value: TValue, meta: M) => R | undefined,
-	args: TArgs,
-	value: TValue,
-	meta: M,
-	handlerVersion?: { id: string; version: string | number },
-): void {
-	const record = builder(args, value, meta);
-	if (record === undefined) return;
-	const stamped = handlerVersion != null ? ({ ...record, handlerVersion } as R) : record;
-	audit.append(stamped);
-}
-
-// ── registerCursor / registerCursorMap ───────────────────────────────────
-
-/**
- * Promote a closure counter to a state node mounted under `graph`.
- * Replaces ad-hoc `let _seq = 0` patterns with a node observable in
- * `describe()` and persistable via storage tiers.
- *
- * @category internal
- */
-export function registerCursor(graph: Graph, name: string, initial = 0): Node<number> {
-	const cursor = node<number>([], { initial, name, describeKind: "state" });
-	graph.add(cursor, { name });
-	return cursor;
-}
-
-/**
- * Promote a closure `Map<K, number>` to N state nodes (one per key) mounted
- * under `<graph>::<name>::<key>`. Used by saga (per-event-type cursor).
- *
- * @category internal
- */
-export function registerCursorMap<K extends string>(
-	graph: Graph,
-	name: string,
-	keys: readonly K[],
-	initial = 0,
-): { readonly [P in K]: Node<number> } {
-	const out = {} as { [P in K]: Node<number> };
-	// Mount cursors under a child plain-Graph so per-key node names stay flat
-	// (path-separator `::` is reserved by Graph.add). Using `Graph` directly
-	// rather than `graph.constructor` avoids spawning a typed subclass with
-	// an incompatible constructor signature (e.g., CqrsGraph(name, opts)).
-	const sub = new Graph(name);
-	for (const k of keys) {
-		const cursor = node<number>([], {
-			initial,
-			name: k,
-			describeKind: "state",
-		});
-		sub.add(cursor, { name: k });
-		out[k] = cursor;
-	}
-	graph.mount(name, sub);
-	return out;
-}
diff --git a/src/base/render/_ascii-grid.ts b/src/base/render/_ascii-grid.ts
deleted file mode 100644
index cd85342f..00000000
--- a/src/base/render/_ascii-grid.ts
+++ /dev/null
@@ -1,424 +0,0 @@
-/**
- * Character-grid blitter for the ASCII describe renderer.
- *
- * Given a [LayoutResult](./_layout-sugiyama.ts) (boxes + polyline edges on
- * an integer cell grid), produce a newline-joined string using Unicode
- * box-drawing glyphs (or plain ASCII when `charset: "ascii"` is requested).
- *
- * Invariants:
- *   - Multi-cell CJK labels still count as 2 cells via
- *     [_ascii-width.ts](./_ascii-width.ts).
- *   - Edge crossings (two segments perpendicular at the same cell) collapse
- *     to `┼` / `+`. Corner-vs-line collisions resolve to a corner glyph.
- *   - Boxes overwrite edge glyphs — boxes are blitted last so an edge that
- *     happens to pass under a box body is hidden.
- */
-
-import { countCells } from "./_ascii-width.js";
-import type { LayoutBox, LayoutEdge, LayoutResult } from "./_layout-sugiyama.js";
-
-export type AsciiCharset = "unicode" | "ascii";
-
-export type GridOptions = {
-	readonly charset: AsciiCharset;
-	readonly labelOf: (id: string) => string;
-};
-
-type Glyphs = {
-	readonly horizontal: string;
-	readonly vertical: string;
-	readonly cornerTL: string;
-	readonly cornerTR: string;
-	readonly cornerBL: string;
-	readonly cornerBR: string;
-	readonly tDown: string;
-	readonly tUp: string;
-	readonly tRight: string;
-	readonly tLeft: string;
-	readonly cross: string;
-	readonly arrowRight: string;
-	readonly arrowDown: string;
-	readonly arrowLeft: string;
-	readonly arrowUp: string;
-	readonly boxTL: string;
-	readonly boxTR: string;
-	readonly boxBL: string;
-	readonly boxBR: string;
-	readonly boxH: string;
-	readonly boxV: string;
-};
-
-const UNICODE: Glyphs = {
-	horizontal: "─",
-	vertical: "│",
-	cornerTL: "┌",
-	cornerTR: "┐",
-	cornerBL: "└",
-	cornerBR: "┘",
-	tDown: "┬",
-	tUp: "┴",
-	tRight: "├",
-	tLeft: "┤",
-	cross: "┼",
-	arrowRight: "▶",
-	arrowDown: "▼",
-	arrowLeft: "◀",
-	arrowUp: "▲",
-	boxTL: "┌",
-	boxTR: "┐",
-	boxBL: "└",
-	boxBR: "┘",
-	boxH: "─",
-	boxV: "│",
-};
-
-const ASCII: Glyphs = {
-	horizontal: "-",
-	vertical: "|",
-	cornerTL: "+",
-	cornerTR: "+",
-	cornerBL: "+",
-	cornerBR: "+",
-	tDown: "+",
-	tUp: "+",
-	tRight: "+",
-	tLeft: "+",
-	cross: "+",
-	arrowRight: ">",
-	arrowDown: "v",
-	arrowLeft: "<",
-	arrowUp: "^",
-	boxTL: "+",
-	boxTR: "+",
-	boxBL: "+",
-	boxBR: "+",
-	boxH: "-",
-	boxV: "|",
-};
-
-// Set of glyphs considered "edge lines" when resolving collisions. A later
-// put() into an edge cell that conflicts produces `cross`; corners and
-// T-junctions are preserved (they carry more information).
-type CellKind =
-	| "empty"
-	| "boxH"
-	| "boxV"
-	| "boxCorner"
-	| "edgeH"
-	| "edgeV"
-	| "edgeCorner"
-	| "arrow"
-	| "label";
-
-export function renderGrid(layout: LayoutResult, options: GridOptions): string {
-	const glyphs = options.charset === "ascii" ? ASCII : UNICODE;
-	const width = layout.width;
-	const height = layout.height;
-	const grid: string[][] = Array.from({ length: height }, () =>
-		Array.from({ length: width }, () => " "),
-	);
-	const kind: CellKind[][] = Array.from({ length: height }, () =>
-		Array.from({ length: width }, () => "empty" as CellKind),
-	);
-
-	// 1. Draw edges first (boxes overwrite).
-	for (const edge of layout.edges) {
-		drawEdge(grid, kind, glyphs, edge);
-	}
-
-	// 2. Draw boxes on top.
-	for (const box of layout.boxes) {
-		drawBox(grid, kind, glyphs, box, options.labelOf(box.id));
-	}
-
-	return grid.map((row) => stripTrailing(row.join(""))).join("\n");
-}
-
-// ---------------------------------------------------------------------------
-// Box drawing
-// ---------------------------------------------------------------------------
-
-function drawBox(
-	grid: string[][],
-	kind: CellKind[][],
-	glyphs: Glyphs,
-	box: LayoutBox,
-	label: string,
-): void {
-	const { x, y, w, h } = box;
-	if (w < 2 || h < 2) {
-		// Degenerate — just paint the label.
-		if (h > 0) writeLabel(grid, kind, x, y, w, label);
-		return;
-	}
-	// Top border
-	putBoxCell(grid, kind, x, y, glyphs.boxTL);
-	for (let cx = x + 1; cx < x + w - 1; cx += 1) putBoxCell(grid, kind, cx, y, glyphs.boxH);
-	putBoxCell(grid, kind, x + w - 1, y, glyphs.boxTR);
-	// Middle rows — side borders + content (only middle row carries the label)
-	for (let cy = y + 1; cy < y + h - 1; cy += 1) {
-		putBoxCell(grid, kind, x, cy, glyphs.boxV);
-		for (let cx = x + 1; cx < x + w - 1; cx += 1) {
-			putBoxCellAs(grid, kind, cx, cy, " ", "empty");
-		}
-		putBoxCell(grid, kind, x + w - 1, cy, glyphs.boxV);
-	}
-	// Bottom border
-	putBoxCell(grid, kind, x, y + h - 1, glyphs.boxBL);
-	for (let cx = x + 1; cx < x + w - 1; cx += 1) putBoxCell(grid, kind, cx, y + h - 1, glyphs.boxH);
-	putBoxCell(grid, kind, x + w - 1, y + h - 1, glyphs.boxBR);
-	// Label in vertical middle (h >= 3 expected)
-	const midY = y + Math.floor(h / 2);
-	writeLabel(grid, kind, x + 1, midY, w - 2, label);
-}
-
-function putBoxCell(
-	grid: string[][],
-	kind: CellKind[][],
-	x: number,
-	y: number,
-	glyph: string,
-): void {
-	const k: CellKind =
-		glyph === " "
-			? "empty"
-			: glyph === "─" || glyph === "-"
-				? "boxH"
-				: glyph === "│" || glyph === "|"
-					? "boxV"
-					: "boxCorner";
-	putBoxCellAs(grid, kind, x, y, glyph, k);
-}
-
-function putBoxCellAs(
-	grid: string[][],
-	kind: CellKind[][],
-	x: number,
-	y: number,
-	glyph: string,
-	k: CellKind,
-): void {
-	if (y < 0 || y >= grid.length) return;
-	const row = grid[y]!;
-	if (x < 0 || x >= row.length) return;
-	row[x] = glyph;
-	kind[y]![x] = k;
-}
-
-function writeLabel(
-	grid: string[][],
-	kind: CellKind[][],
-	x: number,
-	y: number,
-	maxWidthCells: number,
-	label: string,
-): void {
-	// The grid is cell-indexed (one array slot per terminal cell). Wide
-	// characters (CJK, fullwidth) occupy TWO cells visually; we store the
-	// char in the first slot and an empty string in the second slot so
-	// join("") collapses to a single visible wide glyph and neighboring
-	// writes don't add spurious narrow spaces next to the wide char.
-	if (y < 0 || y >= grid.length) return;
-	let cursor = x;
-	let cellsLeft = maxWidthCells;
-	for (const ch of label) {
-		const cw = countCells(ch);
-		if (cw === 0) continue;
-		if (cellsLeft < cw) break;
-		if (cursor >= 0 && cursor < grid[y]!.length) {
-			grid[y]![cursor] = ch;
-			kind[y]![cursor] = "label";
-			if (cw === 2 && cursor + 1 < grid[y]!.length) {
-				grid[y]![cursor + 1] = "";
-				kind[y]![cursor + 1] = "label";
-			}
-		}
-		cursor += cw;
-		cellsLeft -= cw;
-	}
-	// Pad remaining cells with spaces so any edge glyphs lurking under the
-	// box body don't leak into the label row.
-	while (cellsLeft > 0) {
-		if (cursor >= 0 && cursor < grid[y]!.length) {
-			grid[y]![cursor] = " ";
-			kind[y]![cursor] = "empty";
-		}
-		cursor += 1;
-		cellsLeft -= 1;
-	}
-}
-
-// ---------------------------------------------------------------------------
-// Edge drawing
-// ---------------------------------------------------------------------------
-
-function drawEdge(grid: string[][], kind: CellKind[][], glyphs: Glyphs, edge: LayoutEdge): void {
-	const pts = edge.points;
-	if (pts.length < 2) return;
-	// Draw segments
-	for (let i = 0; i + 1 < pts.length; i += 1) {
-		drawSegment(grid, kind, glyphs, pts[i]!, pts[i + 1]!);
-	}
-	// Draw corners at interior points
-	for (let i = 1; i + 1 < pts.length; i += 1) {
-		const a = pts[i - 1]!;
-		const b = pts[i]!;
-		const c = pts[i + 1]!;
-		const corner = cornerGlyph(a, b, c, glyphs);
-		if (corner) putEdgeCell(grid, kind, b.x, b.y, corner, "edgeCorner");
-	}
-	// Arrow tip at the final point, aimed from the penultimate point.
-	// Four cardinal directions — covers backward and upward tips produced
-	// by routing past virtual nodes or dense-gutter fallbacks.
-	const tip = pts[pts.length - 1]!;
-	const prev = pts[pts.length - 2]!;
-	const arrow = arrowGlyph(prev, tip, glyphs);
-	if (arrow) putEdgeCell(grid, kind, tip.x, tip.y, arrow, "arrow");
-}
-
-function drawSegment(
-	grid: string[][],
-	kind: CellKind[][],
-	glyphs: Glyphs,
-	a: { x: number; y: number },
-	b: { x: number; y: number },
-): void {
-	if (a.x === b.x && a.y === b.y) return;
-	if (a.y === b.y) {
-		// Horizontal
-		const y = a.y;
-		const x0 = Math.min(a.x, b.x);
-		const x1 = Math.max(a.x, b.x);
-		for (let x = x0; x <= x1; x += 1) {
-			putEdgeLine(grid, kind, x, y, glyphs, "h");
-		}
-	} else if (a.x === b.x) {
-		// Vertical
-		const x = a.x;
-		const y0 = Math.min(a.y, b.y);
-		const y1 = Math.max(a.y, b.y);
-		for (let y = y0; y <= y1; y += 1) {
-			putEdgeLine(grid, kind, x, y, glyphs, "v");
-		}
-	}
-	// Diagonal shouldn't happen — routing is orthogonal.
-}
-
-function putEdgeLine(
-	grid: string[][],
-	kind: CellKind[][],
-	x: number,
-	y: number,
-	glyphs: Glyphs,
-	orientation: "h" | "v",
-): void {
-	if (y < 0 || y >= grid.length) return;
-	const row = grid[y]!;
-	if (x < 0 || x >= row.length) return;
-	const existing = kind[y]![x];
-	if (
-		existing === "boxH" ||
-		existing === "boxV" ||
-		existing === "boxCorner" ||
-		existing === "label"
-	) {
-		// Box wins — do nothing. Boxes are drawn after edges, but if order
-		// is reversed the edge must not clobber the box.
-		return;
-	}
-	if (existing === "empty") {
-		row[x] = orientation === "h" ? glyphs.horizontal : glyphs.vertical;
-		kind[y]![x] = orientation === "h" ? "edgeH" : "edgeV";
-		return;
-	}
-	if (existing === "edgeH" && orientation === "v") {
-		row[x] = glyphs.cross;
-		kind[y]![x] = "edgeCorner";
-		return;
-	}
-	if (existing === "edgeV" && orientation === "h") {
-		row[x] = glyphs.cross;
-		kind[y]![x] = "edgeCorner";
-		return;
-	}
-	// Same-orientation overlay: keep existing glyph.
-}
-
-function putEdgeCell(
-	grid: string[][],
-	kind: CellKind[][],
-	x: number,
-	y: number,
-	glyph: string,
-	k: CellKind,
-): void {
-	if (y < 0 || y >= grid.length) return;
-	const row = grid[y]!;
-	if (x < 0 || x >= row.length) return;
-	const existing = kind[y]![x];
-	if (
-		existing === "boxH" ||
-		existing === "boxV" ||
-		existing === "boxCorner" ||
-		existing === "label"
-	)
-		return;
-	row[x] = glyph;
-	kind[y]![x] = k;
-}
-
-// ---------------------------------------------------------------------------
-// Corner + arrow glyph selection
-// ---------------------------------------------------------------------------
-
-function cornerGlyph(
-	a: { x: number; y: number },
-	b: { x: number; y: number },
-	c: { x: number; y: number },
-	glyphs: Glyphs,
-): string | undefined {
-	const inHoriz = a.y === b.y;
-	const outHoriz = b.y === c.y;
-	if (inHoriz === outHoriz) return undefined; // not a turn
-	// In from horizontal, out to vertical (or vice versa). Figure out which
-	// of the four corners we're at.
-	if (inHoriz) {
-		// Coming from the left (a.x < b.x) or right (a.x > b.x)
-		const fromLeft = a.x < b.x;
-		const goingDown = c.y > b.y;
-		if (fromLeft && goingDown) return glyphs.cornerTR;
-		if (fromLeft && !goingDown) return glyphs.cornerBR;
-		if (!fromLeft && goingDown) return glyphs.cornerTL;
-		return glyphs.cornerBL;
-	}
-	// Vertical in, horizontal out
-	const fromAbove = a.y < b.y;
-	const goingRight = c.x > b.x;
-	if (fromAbove && goingRight) return glyphs.cornerBL;
-	if (fromAbove && !goingRight) return glyphs.cornerBR;
-	if (!fromAbove && goingRight) return glyphs.cornerTL;
-	return glyphs.cornerTR;
-}
-
-function arrowGlyph(
-	prev: { x: number; y: number },
-	tip: { x: number; y: number },
-	glyphs: Glyphs,
-): string | undefined {
-	if (tip.x > prev.x) return glyphs.arrowRight;
-	if (tip.x < prev.x) return glyphs.arrowLeft;
-	if (tip.y > prev.y) return glyphs.arrowDown;
-	if (tip.y < prev.y) return glyphs.arrowUp;
-	return undefined; // zero-length segment — no tip
-}
-
-// ---------------------------------------------------------------------------
-// Output trimming
-// ---------------------------------------------------------------------------
-
-function stripTrailing(line: string): string {
-	// Trim trailing spaces only; preserve internal grid alignment.
-	let end = line.length;
-	while (end > 0 && line.charCodeAt(end - 1) === 32) end -= 1;
-	return line.slice(0, end);
-}
diff --git a/src/base/render/_ascii-width.ts b/src/base/render/_ascii-width.ts
deleted file mode 100644
index 324652c1..00000000
--- a/src/base/render/_ascii-width.ts
+++ /dev/null
@@ -1,169 +0,0 @@
-/**
- * Monospace-terminal cell-width utilities shared by the CLI measurement
- * adapter ([src/patterns/reactive-layout/measurement-adapters.ts](../patterns/reactive-layout/measurement-adapters.ts))
- * and the ASCII describe renderer ([graph-spec-to-ascii.ts](./graph-spec-to-ascii.ts)).
- *
- * Approximates UAX #11 East_Asian_Width (W/F → 2) plus known combining-mark
- * ranges (→ 0). Not a full EAW table — covers CJK, Hangul, fullwidth forms,
- * common emoji, and Extensions B-G. Does not handle ZWJ emoji sequences
- * (multi-codepoint clusters rendered as a single glyph) — terminal support
- * for those varies widely.
- */
-
-export function cellWidth(code: number): 0 | 1 | 2 {
-	// Combining marks (Mn, Mc, Me) → 0 cells
-	if (
-		(code >= 0x0300 && code <= 0x036f) || // Combining Diacritical Marks
-		(code >= 0x0483 && code <= 0x0489) || // Cyrillic combining marks
-		(code >= 0x0591 && code <= 0x05bd) || // Hebrew combining marks
-		(code >= 0x0610 && code <= 0x061a) || // Arabic combining marks
-		(code >= 0x064b && code <= 0x065f) || // Arabic combining marks
-		(code >= 0x0670 && code === 0x0670) || // Arabic superscript alef
-		(code >= 0x06d6 && code <= 0x06dc) || // Arabic combining marks
-		(code >= 0x06df && code <= 0x06e4) || // Arabic combining marks
-		(code >= 0x06e7 && code <= 0x06e8) || // Arabic combining marks
-		(code >= 0x06ea && code <= 0x06ed) || // Arabic combining marks
-		(code >= 0x0730 && code <= 0x074a) || // Syriac combining marks
-		(code >= 0x07a6 && code <= 0x07b0) || // Thaana combining marks
-		(code >= 0x0900 && code <= 0x0903) || // Devanagari combining marks
-		(code >= 0x093a && code <= 0x094f) || // Devanagari combining marks
-		(code >= 0x0951 && code <= 0x0957) || // Devanagari combining marks
-		(code >= 0x0962 && code <= 0x0963) || // Devanagari combining marks
-		(code >= 0x0981 && code <= 0x0983) || // Bengali combining marks
-		(code >= 0x09bc && code <= 0x09cd) || // Bengali combining marks
-		(code >= 0x0a01 && code <= 0x0a03) || // Gurmukhi combining marks
-		(code >= 0x0a3c && code <= 0x0a51) || // Gurmukhi combining marks
-		(code >= 0x0a70 && code <= 0x0a71) || // Gurmukhi combining marks
-		(code >= 0x0a75 && code === 0x0a75) || // Gurmukhi combining mark
-		(code >= 0x0e31 && code === 0x0e31) || // Thai combining mark
-		(code >= 0x0e34 && code <= 0x0e3a) || // Thai combining marks
-		(code >= 0x0e47 && code <= 0x0e4e) || // Thai combining marks
-		(code >= 0x0eb1 && code === 0x0eb1) || // Lao combining mark
-		(code >= 0x0eb4 && code <= 0x0ebc) || // Lao combining marks
-		(code >= 0x0ec8 && code <= 0x0ece) || // Lao combining marks
-		(code >= 0x1dc0 && code <= 0x1dff) || // Combining Diacritical Marks Supplement
-		(code >= 0x20d0 && code <= 0x20ff) || // Combining Diacritical Marks for Symbols
-		(code >= 0xfe00 && code <= 0xfe0f) || // Variation Selectors
-		(code >= 0xfe20 && code <= 0xfe2f) || // Combining Half Marks
-		code === 0x200d // Zero Width Joiner
-	) {
-		return 0;
-	}
-	// Wide / fullwidth → 2 cells
-	if (
-		(code >= 0x1100 && code <= 0x115f) || // Hangul Jamo
-		(code >= 0x231a && code <= 0x231b) || // Watch, Hourglass
-		(code >= 0x2329 && code <= 0x232a) || // Angle brackets
-		(code >= 0x23e9 && code <= 0x23f3) || // Media control symbols
-		(code >= 0x23f8 && code <= 0x23fa) || // Media control symbols
-		(code >= 0x25fd && code <= 0x25fe) || // Medium squares
-		(code >= 0x2614 && code <= 0x2615) || // Umbrella, Hot Beverage
-		(code >= 0x2648 && code <= 0x2653) || // Zodiac symbols
-		code === 0x267f || // Wheelchair
-		code === 0x2693 || // Anchor
-		code === 0x26a1 || // High Voltage
-		(code >= 0x26aa && code <= 0x26ab) || // Medium circles
-		(code >= 0x26bd && code <= 0x26be) || // Soccer, Baseball
-		(code >= 0x26c4 && code <= 0x26c5) || // Snowman, Sun behind cloud
-		code === 0x26ce || // Ophiuchus
-		code === 0x26d4 || // No Entry
-		code === 0x26ea || // Church
-		(code >= 0x26f2 && code <= 0x26f3) || // Fountain, Golf
-		code === 0x26f5 || // Sailboat
-		code === 0x26fa || // Tent
-		code === 0x26fd || // Fuel Pump
-		code === 0x2702 || // Scissors
-		code === 0x2705 || // Check Mark
-		(code >= 0x2708 && code <= 0x270d) || // Airplane...Writing Hand
-		code === 0x270f || // Pencil
-		(code >= 0x2753 && code <= 0x2755) || // Question marks
-		code === 0x2757 || // Exclamation
-		(code >= 0x2795 && code <= 0x2797) || // Plus, Minus, Divide
-		code === 0x27b0 || // Curly Loop
-		code === 0x27bf || // Double Curly Loop
-		(code >= 0x2934 && code <= 0x2935) || // Arrows
-		(code >= 0x2b05 && code <= 0x2b07) || // Arrows
-		(code >= 0x2b1b && code <= 0x2b1c) || // Squares
-		code === 0x2b50 || // Star
-		code === 0x2b55 || // Circle
-		(code >= 0x2e80 && code <= 0x303e) || // CJK Radicals, Symbols, Punctuation
-		(code >= 0x3040 && code <= 0x309f) || // Hiragana
-		(code >= 0x30a0 && code <= 0x30ff) || // Katakana
-		(code >= 0x3105 && code <= 0x312f) || // Bopomofo
-		(code >= 0x3131 && code <= 0x318e) || // Hangul Compatibility Jamo
-		(code >= 0x3190 && code <= 0x31e3) || // Kanbun, CJK Strokes
-		(code >= 0x31f0 && code <= 0x321e) || // Katakana Phonetic Extensions
-		(code >= 0x3220 && code <= 0x3247) || // Enclosed CJK
-		(code >= 0x3250 && code <= 0x4dbf) || // CJK Extensions + Unified block
-		(code >= 0x4e00 && code <= 0x9fff) || // CJK Unified Ideographs
-		(code >= 0xa960 && code <= 0xa97c) || // Hangul Jamo Extended-A
-		(code >= 0xac00 && code <= 0xd7a3) || // Hangul Syllables
-		(code >= 0xf900 && code <= 0xfaff) || // CJK Compatibility Ideographs
-		(code >= 0xfe10 && code <= 0xfe19) || // Vertical forms
-		(code >= 0xfe30 && code <= 0xfe6b) || // CJK Compatibility Forms
-		(code >= 0xff01 && code <= 0xff60) || // Fullwidth Forms (excl. halfwidth)
-		(code >= 0xffe0 && code <= 0xffe6) || // Fullwidth Signs
-		(code >= 0x1f004 && code === 0x1f004) || // Mahjong Red Dragon
-		code === 0x1f0cf || // Joker
-		(code >= 0x1f170 && code <= 0x1f171) || // A/B buttons
-		code === 0x1f17e || // O button
-		code === 0x1f17f || // P button
-		code === 0x1f18e || // AB button
-		(code >= 0x1f191 && code <= 0x1f19a) || // Squared symbols
-		(code >= 0x1f1e0 && code <= 0x1f1ff) || // Regional Indicator Symbols
-		(code >= 0x1f200 && code <= 0x1f202) || // Enclosed ideographic
-		code === 0x1f21a || // Squared CJK
-		code === 0x1f22f || // Squared CJK
-		(code >= 0x1f232 && code <= 0x1f23a) || // Squared CJK
-		(code >= 0x1f250 && code <= 0x1f251) || // Circled ideographic
-		(code >= 0x1f300 && code <= 0x1f9ff) || // Misc Symbols / Emoticons / Emoji
-		(code >= 0x1fa00 && code <= 0x1faff) || // Chess, Symbols Extended-A
-		(code >= 0x1fb00 && code <= 0x1fbff) || // Symbols for Legacy Computing
-		(code >= 0x20000 && code <= 0x2fffd) || // CJK Extension B-F (excl. nonchars)
-		(code >= 0x30000 && code <= 0x3fffd) // CJK Extension G+ (excl. nonchars)
-	) {
-		return 2;
-	}
-	return 1;
-}
-
-/**
- * Count total display cells for a string in a monospace terminal.
- *
- * Combining marks contribute 0 cells; CJK / fullwidth contribute 2.
- * Does not handle ZWJ emoji sequences.
- */
-export function countCells(text: string): number {
-	let cells = 0;
-	for (const ch of text) {
-		cells += cellWidth(ch.codePointAt(0)!);
-	}
-	return cells;
-}
-
-/**
- * Truncate `text` to at most `maxCells` terminal cells, appending an ellipsis
- * ("…" → 1 cell) when truncation occurs. Grapheme-unaware — splits at
- * codepoints; ZWJ sequences may be cut mid-cluster.
- */
-export function truncateToCells(text: string, maxCells: number): string {
-	if (maxCells <= 0) return "";
-	let cells = 0;
-	let out = "";
-	for (const ch of text) {
-		const w = cellWidth(ch.codePointAt(0)!);
-		if (cells + w > maxCells) {
-			if (maxCells <= 1) return "…";
-			// Drop last wide char if we'd exceed budget with the ellipsis
-			while (cells + 1 > maxCells && out.length > 0) {
-				const last = [...out].pop()!;
-				out = out.slice(0, -last.length);
-				cells -= cellWidth(last.codePointAt(0)!);
-			}
-			return `${out}…`;
-		}
-		out += ch;
-		cells += w;
-	}
-	return out;
-}
diff --git a/src/base/render/_internal.ts b/src/base/render/_internal.ts
deleted file mode 100644
index 0f684257..00000000
--- a/src/base/render/_internal.ts
+++ /dev/null
@@ -1,93 +0,0 @@
-/**
- * Internal helpers shared across renderers in `extra/render/`.
- *
- * These are pure functions over `GraphDescribeOutput` — no Graph instance
- * dependency. Extracted from `src/graph/graph.ts` (the consolidated
- * ex-dumpGraph / ex-graphSpecToMermaid / ex-graphSpecToD2 renderers) per
- * Tier 2.1 A2.
- */
-
-import type { GraphDescribeOutput } from "@graphrefly/pure-ts/graph";
-
-/** Direction options for diagram exports. */
-export type DiagramDirection = "TD" | "LR" | "BT" | "RL";
-
-/** Recursively sort object keys for deterministic JSON (git-diffable). */
-export function sortJsonValue(value: unknown): unknown {
-	if (value === null || typeof value !== "object") {
-		return value;
-	}
-	if (Array.isArray(value)) {
-		return value.map(sortJsonValue);
-	}
-	const obj = value as Record<string, unknown>;
-	const keys = Object.keys(obj).sort();
-	const out: Record<string, unknown> = {};
-	for (const k of keys) {
-		out[k] = sortJsonValue(obj[k]);
-	}
-	return out;
-}
-
-/** Escape characters that are illegal inside a quoted Mermaid label. */
-export function escapeMermaidLabel(value: string): string {
-	return value.replaceAll("\\", "\\\\").replaceAll('"', '\\"');
-}
-
-/** Escape characters that are illegal inside a quoted D2 label. */
-export function escapeD2Label(value: string): string {
-	return value.replaceAll("\\", "\\\\").replaceAll('"', '\\"');
-}
-
-/** Map our 4-direction enum to D2's `direction:` keyword. */
-export function d2DirectionFromGraphDirection(direction: DiagramDirection): string {
-	if (direction === "TD") return "down";
-	if (direction === "BT") return "up";
-	if (direction === "RL") return "left";
-	return "right";
-}
-
-/** Collect deduplicated (from, to) arrows from deps + edges. */
-export function collectDiagramArrows(described: GraphDescribeOutput): [string, string][] {
-	const seen = new Set<string>();
-	const arrows: [string, string][] = [];
-	function add(from: string, to: string): void {
-		const key = `${from}\0${to}`;
-		if (seen.has(key)) return;
-		seen.add(key);
-		arrows.push([from, to]);
-	}
-	for (const [path, info] of Object.entries(described.nodes)) {
-		const deps: string[] | undefined = (info as Record<string, unknown>).deps as
-			| string[]
-			| undefined;
-		if (deps) {
-			for (const dep of deps) add(dep, path);
-		}
-	}
-	for (const edge of described.edges) add(edge.from, edge.to);
-	return arrows;
-}
-
-/** Default to "LR"; throw on unknown values to surface caller bugs early. */
-export function normalizeDiagramDirection(direction: unknown): DiagramDirection {
-	if (direction === undefined) return "LR";
-	if (direction === "TD" || direction === "LR" || direction === "BT" || direction === "RL") {
-		return direction;
-	}
-	throw new Error(
-		`invalid diagram direction ${String(direction)}; expected one of: TD, LR, BT, RL`,
-	);
-}
-
-/** JSON-aware single-value formatter (used by `graphSpecToPretty`). */
-export function describeData(value: unknown): string {
-	if (typeof value === "string") return JSON.stringify(value);
-	if (typeof value === "number" || typeof value === "boolean" || value == null)
-		return String(value);
-	try {
-		return JSON.stringify(value);
-	} catch {
-		return "[unserializable]";
-	}
-}
diff --git a/src/base/render/_layout-sugiyama.ts b/src/base/render/_layout-sugiyama.ts
deleted file mode 100644
index 26f56d63..00000000
--- a/src/base/render/_layout-sugiyama.ts
+++ /dev/null
@@ -1,686 +0,0 @@
-/**
- * Sugiyama-style layered DAG layout on an integer grid.
- *
- * Pipeline:
- *   1. Longest-path layer assignment (sources at layer 0).
- *   2. Virtual-node splitting — every edge spanning more than one layer
- *      becomes a chain of synthetic nodes on intermediate layers. Downstream
- *      passes treat real and virtual nodes identically; crossing
- *      minimization therefore works on wide + deep DAGs, not only
- *      adjacent-layer cases.
- *   3. Crossing minimization — barycenter heuristic with alternating up /
- *      down sweeps plus an adjacent-transposition polish pass.
- *   4. Coordinate assignment — greedy median-aligned packing with collision
- *      resolution. Straightens vertical runs of virtual nodes so long edges
- *      become straight lines where topology allows.
- *   5. Orthogonal edge routing — per-gutter x-track assignment; horizontal
- *      segments sit at endpoint centerlines, vertical segments pack into the
- *      gutter column range without overlap. Remaining crossings are
- *      topologically unavoidable and will render as `┼` at draw time.
- *
- * Output coordinates are cell-grid integers (LR direction). TD rendering
- * swaps axes at draw time — the layout is direction-agnostic by
- * construction.
- *
- * Used only by [graph-spec-to-ascii.ts](./graph-spec-to-ascii.ts); not part of the public
- * `extra/render/index.ts` surface (underscore-prefixed).
- */
-
-export type LayoutDirection = "LR" | "TD";
-
-export type LayoutInput = {
-	/** Node ids in stable iteration order. Determines initial tie-break. */
-	readonly nodes: readonly string[];
-	/** Edges by (from, to) path. Endpoints must be present in `nodes`. */
-	readonly edges: ReadonlyArray<{ from: string; to: string }>;
-	/** Label width in cells for each node (independent of direction). */
-	readonly widthCells: (id: string) => number;
-	/** Label height in cells for each node (independent of direction). */
-	readonly heightCells: (id: string) => number;
-	/**
-	 * Gap between layer "columns" (LR) or "rows" (TD), in cells.
-	 * Must allow enough room for per-gutter edge tracks.
-	 */
-	readonly layerGap: number;
-	/**
-	 * Gap between neighboring nodes *within* a layer, in cells.
-	 * LR: vertical gap; TD: horizontal gap.
-	 */
-	readonly nodeGap: number;
-	/**
-	 * Axis orientation. LR: layers = columns (x grows), order = rows (y grows).
-	 * TD: layers = rows (y grows), order = columns (x grows).
-	 */
-	readonly direction: LayoutDirection;
-};
-
-export type LayoutBox = {
-	readonly id: string;
-	readonly layer: number;
-	readonly order: number;
-	readonly x: number;
-	readonly y: number;
-	readonly w: number;
-	readonly h: number;
-};
-
-export type LayoutEdgePoint = { readonly x: number; readonly y: number };
-
-export type LayoutEdge = {
-	readonly from: string;
-	readonly to: string;
-	/** Polyline of waypoints (start → corners → end). Minimum 2 entries. */
-	readonly points: readonly LayoutEdgePoint[];
-};
-
-export type LayoutResult = {
-	readonly boxes: readonly LayoutBox[];
-	readonly edges: readonly LayoutEdge[];
-	readonly width: number;
-	readonly height: number;
-};
-
-// ---------------------------------------------------------------------------
-// Internal types — carried through the pipeline
-// ---------------------------------------------------------------------------
-
-type Hop = {
-	chainId: number;
-	chainFrom: string;
-	chainTo: string;
-	fromId: string;
-	toId: string;
-	/** 0-based hop index along the chain. */
-	hopIndex: number;
-	/** Total hops in the chain (1 = direct, 2+ = spans virtuals). */
-	chainLen: number;
-};
-
-type InternalNode = {
-	id: string;
-	isVirtual: boolean;
-	layer: number;
-	order: number;
-	x: number;
-	y: number;
-	w: number;
-	h: number;
-	in: Hop[];
-	out: Hop[];
-};
-
-type Layer = InternalNode[];
-
-type PipelineState = {
-	nodes: Map<string, InternalNode>;
-	layers: Layer[];
-	hops: Hop[];
-};
-
-// ---------------------------------------------------------------------------
-// Pipeline entry
-// ---------------------------------------------------------------------------
-
-export function sugiyamaLayout(input: LayoutInput): LayoutResult {
-	const state = buildInitial(input);
-	assignLayers(state);
-	insertVirtualNodes(state);
-	minimizeCrossings(state);
-	assignCoordinates(state, input);
-	const edges = routeEdges(state, input);
-	const { width, height } = boundingBox(state);
-	const boxes: LayoutBox[] = [];
-	for (const layer of state.layers) {
-		for (const n of layer) {
-			if (n.isVirtual) continue;
-			boxes.push({
-				id: n.id,
-				layer: n.layer,
-				order: n.order,
-				x: n.x,
-				y: n.y,
-				w: n.w,
-				h: n.h,
-			});
-		}
-	}
-	return { boxes, edges, width, height };
-}
-
-// ---------------------------------------------------------------------------
-// 1. Build internal graph
-// ---------------------------------------------------------------------------
-
-function buildInitial(input: LayoutInput): PipelineState {
-	const nodes = new Map<string, InternalNode>();
-	for (const id of input.nodes) {
-		nodes.set(id, {
-			id,
-			isVirtual: false,
-			layer: -1,
-			order: 0,
-			x: 0,
-			y: 0,
-			w: input.widthCells(id),
-			h: input.heightCells(id),
-			in: [],
-			out: [],
-		});
-	}
-	const hops: Hop[] = [];
-	let chainId = 0;
-	for (const e of input.edges) {
-		if (e.from === e.to) continue; // drop self-loops
-		const f = nodes.get(e.from);
-		const t = nodes.get(e.to);
-		if (!f || !t) continue; // drop dangling endpoints
-		const hop: Hop = {
-			chainId: chainId++,
-			chainFrom: e.from,
-			chainTo: e.to,
-			fromId: e.from,
-			toId: e.to,
-			hopIndex: 0,
-			chainLen: 1,
-		};
-		f.out.push(hop);
-		t.in.push(hop);
-		hops.push(hop);
-	}
-	return { nodes, layers: [], hops };
-}
-
-// ---------------------------------------------------------------------------
-// 2. Longest-path layer assignment (Kahn's algorithm)
-// ---------------------------------------------------------------------------
-
-function assignLayers(state: PipelineState): void {
-	const indeg = new Map<string, number>();
-	for (const n of state.nodes.values()) indeg.set(n.id, n.in.length);
-
-	const queue: InternalNode[] = [];
-	for (const n of state.nodes.values()) {
-		if ((indeg.get(n.id) ?? 0) === 0) {
-			n.layer = 0;
-			queue.push(n);
-		}
-	}
-
-	// Cursor-based BFS — `Array.prototype.shift` is O(n), so the naive form
-	// is O(n²) and degrades past ~1000 nodes. Cursor keeps it linear.
-	const visited = new Set<string>();
-	let head = 0;
-	while (head < queue.length) {
-		const n = queue[head++]!;
-		if (visited.has(n.id)) continue;
-		visited.add(n.id);
-		for (const hop of n.out) {
-			const t = state.nodes.get(hop.toId)!;
-			t.layer = Math.max(t.layer, n.layer + 1);
-			const d = (indeg.get(t.id) ?? 0) - 1;
-			indeg.set(t.id, d);
-			if (d <= 0) queue.push(t);
-		}
-	}
-	// Nodes trapped in a cycle default to layer 0. The edges that would
-	// close the cycle are dropped in `insertVirtualNodes` (any hop whose
-	// span is not a positive integer). GraphReFly graphs are DAGs by spec;
-	// this path is defensive against malformed describe snapshots.
-	for (const n of state.nodes.values()) if (n.layer < 0) n.layer = 0;
-}
-
-// ---------------------------------------------------------------------------
-// 3. Virtual-node insertion — critical for scaling past adjacent-layer edges
-// ---------------------------------------------------------------------------
-
-function insertVirtualNodes(state: PipelineState): void {
-	const maxLayer = Math.max(0, ...Array.from(state.nodes.values(), (n) => n.layer));
-	const layers: Layer[] = Array.from({ length: maxLayer + 1 }, () => []);
-	for (const n of state.nodes.values()) layers[n.layer]!.push(n);
-
-	const newHops: Hop[] = [];
-	let virtCounter = 0;
-	for (const hop of state.hops) {
-		const f = state.nodes.get(hop.fromId)!;
-		const t = state.nodes.get(hop.toId)!;
-		const span = t.layer - f.layer;
-		if (span <= 0) {
-			// Same-layer or back-edge — the input violated the DAG invariant
-			// (self-loop was already dropped in `buildInitial`; this catches
-			// cycles whose nodes collapsed to layer 0 in `assignLayers`).
-			// Drop from both endpoints so routing never sees the hop; same
-			// render-best-effort policy as the self-loop / dangling-endpoint
-			// filters in `buildInitial`.
-			f.out = f.out.filter((h) => h !== hop);
-			t.in = t.in.filter((h) => h !== hop);
-			continue;
-		}
-		if (span === 1) {
-			hop.hopIndex = 0;
-			hop.chainLen = 1;
-			newHops.push(hop);
-			continue;
-		}
-		// Multi-hop: f → v1 → v2 → ... → t
-		// Detach the original edge from f.out / t.in; we rewrite as chain.
-		f.out = f.out.filter((h) => h !== hop);
-		t.in = t.in.filter((h) => h !== hop);
-
-		let prev = f;
-		for (let i = 1; i < span; i += 1) {
-			const vid = `__virt_${virtCounter++}__`;
-			const v: InternalNode = {
-				id: vid,
-				isVirtual: true,
-				layer: f.layer + i,
-				order: 0,
-				x: 0,
-				y: 0,
-				w: 0,
-				h: 1,
-				in: [],
-				out: [],
-			};
-			state.nodes.set(vid, v);
-			layers[v.layer]!.push(v);
-			const h: Hop = {
-				chainId: hop.chainId,
-				chainFrom: hop.chainFrom,
-				chainTo: hop.chainTo,
-				fromId: prev.id,
-				toId: vid,
-				hopIndex: i - 1,
-				chainLen: span,
-			};
-			prev.out.push(h);
-			v.in.push(h);
-			newHops.push(h);
-			prev = v;
-		}
-		const finalHop: Hop = {
-			chainId: hop.chainId,
-			chainFrom: hop.chainFrom,
-			chainTo: hop.chainTo,
-			fromId: prev.id,
-			toId: t.id,
-			hopIndex: span - 1,
-			chainLen: span,
-		};
-		prev.out.push(finalHop);
-		t.in.push(finalHop);
-		newHops.push(finalHop);
-	}
-
-	// Stable initial order within each layer.
-	for (const layer of layers) {
-		for (let i = 0; i < layer.length; i += 1) layer[i]!.order = i;
-	}
-	state.layers = layers;
-	state.hops = newHops;
-}
-
-// ---------------------------------------------------------------------------
-// 4. Crossing minimization
-// ---------------------------------------------------------------------------
-
-function minimizeCrossings(state: PipelineState): void {
-	const SWEEPS = 4;
-	for (let sweep = 0; sweep < SWEEPS; sweep += 1) {
-		// Down-sweep
-		for (let li = 1; li < state.layers.length; li += 1) {
-			sortByBarycenter(state, state.layers[li]!, "in");
-			reindex(state.layers[li]!);
-		}
-		// Up-sweep
-		for (let li = state.layers.length - 2; li >= 0; li -= 1) {
-			sortByBarycenter(state, state.layers[li]!, "out");
-			reindex(state.layers[li]!);
-		}
-	}
-	// Polish — adjacent-transposition pass, bounded iterations.
-	for (let iter = 0; iter < 2; iter += 1) {
-		let improved = false;
-		for (let li = 1; li < state.layers.length; li += 1) {
-			const layer = state.layers[li]!;
-			for (let i = 0; i + 1 < layer.length; i += 1) {
-				const before = pairCrossings(state, layer[i]!, layer[i + 1]!, "in");
-				[layer[i], layer[i + 1]] = [layer[i + 1]!, layer[i]!];
-				reindex(layer);
-				const after = pairCrossings(state, layer[i]!, layer[i + 1]!, "in");
-				if (after < before) {
-					improved = true;
-				} else {
-					[layer[i], layer[i + 1]] = [layer[i + 1]!, layer[i]!];
-					reindex(layer);
-				}
-			}
-		}
-		if (!improved) break;
-	}
-}
-
-function sortByBarycenter(state: PipelineState, layer: Layer, direction: "in" | "out"): void {
-	const bary = new Map<string, number>();
-	for (const n of layer) {
-		const neighbors = direction === "in" ? n.in : n.out;
-		if (neighbors.length === 0) {
-			bary.set(n.id, n.order);
-			continue;
-		}
-		let sum = 0;
-		let count = 0;
-		for (const h of neighbors) {
-			const other = state.nodes.get(direction === "in" ? h.fromId : h.toId);
-			if (!other) continue;
-			sum += other.order;
-			count += 1;
-		}
-		bary.set(n.id, count === 0 ? n.order : sum / count);
-	}
-	layer.sort((a, b) => {
-		const ba = bary.get(a.id)!;
-		const bb = bary.get(b.id)!;
-		if (ba !== bb) return ba - bb;
-		return a.order - b.order;
-	});
-}
-
-function reindex(layer: Layer): void {
-	for (let i = 0; i < layer.length; i += 1) layer[i]!.order = i;
-}
-
-function pairCrossings(
-	state: PipelineState,
-	a: InternalNode,
-	b: InternalNode,
-	direction: "in" | "out",
-): number {
-	const aEdges = direction === "in" ? a.in : a.out;
-	const bEdges = direction === "in" ? b.in : b.out;
-	let crossings = 0;
-	for (const ea of aEdges) {
-		for (const eb of bEdges) {
-			const oa = state.nodes.get(direction === "in" ? ea.fromId : ea.toId)?.order ?? 0;
-			const ob = state.nodes.get(direction === "in" ? eb.fromId : eb.toId)?.order ?? 0;
-			if ((a.order < b.order && oa > ob) || (a.order > b.order && oa < ob)) {
-				crossings += 1;
-			}
-		}
-	}
-	return crossings;
-}
-
-// ---------------------------------------------------------------------------
-// 5. Coordinate assignment (direction-aware)
-// ---------------------------------------------------------------------------
-
-function assignCoordinates(state: PipelineState, input: LayoutInput): void {
-	if (input.direction === "LR") assignCoordinatesLR(state, input);
-	else assignCoordinatesTD(state, input);
-}
-
-function assignCoordinatesLR(state: PipelineState, input: LayoutInput): void {
-	// x: per-layer column based on cumulative max width.
-	const layerX: number[] = [];
-	let cursorX = 0;
-	for (let li = 0; li < state.layers.length; li += 1) {
-		layerX.push(cursorX);
-		let maxW = 0;
-		for (const n of state.layers[li]!) maxW = Math.max(maxW, n.w);
-		cursorX += maxW + input.layerGap;
-	}
-	for (let li = 0; li < state.layers.length; li += 1) {
-		for (const n of state.layers[li]!) n.x = layerX[li]!;
-	}
-	// y: greedy pack per layer.
-	for (const layer of state.layers) {
-		let y = 0;
-		for (const n of layer) {
-			n.y = y;
-			y += n.h + input.nodeGap;
-		}
-	}
-	// Median alignment — straightens chains through virtuals.
-	runMedianPasses(state, input, "y");
-}
-
-function assignCoordinatesTD(state: PipelineState, input: LayoutInput): void {
-	// y: per-layer row based on cumulative max height.
-	const layerY: number[] = [];
-	let cursorY = 0;
-	for (let li = 0; li < state.layers.length; li += 1) {
-		layerY.push(cursorY);
-		let maxH = 0;
-		for (const n of state.layers[li]!) maxH = Math.max(maxH, n.h);
-		cursorY += maxH + input.layerGap;
-	}
-	for (let li = 0; li < state.layers.length; li += 1) {
-		for (const n of state.layers[li]!) n.y = layerY[li]!;
-	}
-	// x: greedy pack per layer.
-	for (const layer of state.layers) {
-		let x = 0;
-		for (const n of layer) {
-			n.x = x;
-			x += n.w + input.nodeGap;
-		}
-	}
-	runMedianPasses(state, input, "x");
-}
-
-/**
- * Median alignment passes — pulls each node toward the median position of
- * its in-layer neighbors along the private axis ("y" for LR, "x" for TD),
- * then resolves collisions greedily while preserving layer order.
- */
-function runMedianPasses(state: PipelineState, input: LayoutInput, axis: "x" | "y"): void {
-	const sizeOf = (n: InternalNode) => (axis === "y" ? n.h : n.w);
-	const gap = input.nodeGap;
-	for (let pass = 0; pass < 2; pass += 1) {
-		const walk = pass === 0 ? state.layers.slice(1) : state.layers.slice(0, -1).reverse();
-		for (const layer of walk) {
-			const preferred = new Map<string, number>();
-			for (const n of layer) {
-				const neighbors = pass === 0 ? n.in : n.out;
-				if (neighbors.length === 0) continue;
-				const centers: number[] = [];
-				for (const h of neighbors) {
-					const other = state.nodes.get(pass === 0 ? h.fromId : h.toId);
-					if (!other) continue;
-					const base = axis === "y" ? other.y : other.x;
-					centers.push(base + Math.floor(sizeOf(other) / 2));
-				}
-				if (centers.length === 0) continue;
-				centers.sort((a, b) => a - b);
-				const mid = centers[Math.floor(centers.length / 2)]!;
-				preferred.set(n.id, mid - Math.floor(sizeOf(n) / 2));
-			}
-			let floor = 0;
-			for (const n of layer) {
-				const p = preferred.get(n.id);
-				const current = axis === "y" ? n.y : n.x;
-				const target = p ?? current;
-				const clamped = Math.max(target, floor);
-				if (axis === "y") n.y = clamped;
-				else n.x = clamped;
-				floor = clamped + sizeOf(n) + gap;
-			}
-		}
-	}
-}
-
-// ---------------------------------------------------------------------------
-// 6. Orthogonal edge routing (direction-aware)
-//
-// For both LR and TD the algorithm is symmetric — it just operates on a
-// different pair of "primary" vs "cross" axes:
-//
-//   LR: primary = x (layer axis); cross = y. Gutters are vertical strips
-//       between columns; tracks within a gutter are distinct x-values.
-//   TD: primary = y (layer axis); cross = x. Gutters are horizontal strips
-//       between rows; tracks within a gutter are distinct y-values.
-// ---------------------------------------------------------------------------
-
-function routeEdges(state: PipelineState, input: LayoutInput): LayoutEdge[] {
-	// Group hops by chainId → one LayoutEdge per user-facing edge.
-	const byChain = new Map<number, Hop[]>();
-	for (const h of state.hops) {
-		const arr = byChain.get(h.chainId);
-		if (arr) arr.push(h);
-		else byChain.set(h.chainId, [h]);
-	}
-	for (const arr of byChain.values()) arr.sort((a, b) => a.hopIndex - b.hopIndex);
-
-	const isLR = input.direction === "LR";
-	const primary = (n: InternalNode): number => (isLR ? n.x : n.y);
-	const primarySize = (n: InternalNode): number => (isLR ? n.w : n.h);
-	const crossCenter = (n: InternalNode): number =>
-		isLR ? n.y + Math.floor(n.h / 2) : n.x + Math.floor(n.w / 2);
-
-	// Per-gutter cross-axis track assignment. Two passes:
-	//   1. Assign each hop to a track INDEX using disjoint-interval packing
-	//      (an existing track may host multiple hops as long as their
-	//      cross-axis ranges don't overlap pairwise).
-	//   2. Map each track index to a primary-axis position using the final
-	//      track count so the distribution is uniform across the gutter —
-	//      per-hop recomputation (old behavior) collapsed late tracks onto
-	//      `gEnd`, producing bundled overlaps in dense gutters.
-	const hopTrackCross = new Map<Hop, number>();
-	for (let g = 0; g + 1 < state.layers.length; g += 1) {
-		const srcLayer = state.layers[g]!;
-		const dstLayer = state.layers[g + 1]!;
-
-		let gutterStart = 0;
-		for (const n of srcLayer) gutterStart = Math.max(gutterStart, primary(n) + primarySize(n));
-		let gutterEnd = Number.POSITIVE_INFINITY;
-		for (const n of dstLayer) gutterEnd = Math.min(gutterEnd, primary(n));
-		const gEnd = Number.isFinite(gutterEnd) ? (gutterEnd as number) - 1 : gutterStart;
-		const gutterWidth = Math.max(1, gEnd - gutterStart + 1);
-
-		const gutterHops: Hop[] = [];
-		for (const n of srcLayer) for (const h of n.out) gutterHops.push(h);
-		gutterHops.sort((a, b) => {
-			const sa = crossCenter(state.nodes.get(a.fromId)!);
-			const sb = crossCenter(state.nodes.get(b.fromId)!);
-			if (sa !== sb) return sa - sb;
-			const da = crossCenter(state.nodes.get(a.toId)!);
-			const db = crossCenter(state.nodes.get(b.toId)!);
-			return da - db;
-		});
-
-		// Pass 1: assign track indexes. Each track is an ARRAY of disjoint
-		// intervals — two hops share a track iff their cross-axis ranges
-		// don't overlap any existing interval on that track.
-		const tracks: Array<Array<{ lo: number; hi: number }>> = [];
-		const hopToTrackIdx = new Map<Hop, number>();
-		for (const h of gutterHops) {
-			const sc = crossCenter(state.nodes.get(h.fromId)!);
-			const dc = crossCenter(state.nodes.get(h.toId)!);
-			const lo = Math.min(sc, dc);
-			const hi = Math.max(sc, dc);
-			let idx = -1;
-			for (let t = 0; t < tracks.length; t += 1) {
-				const intervals = tracks[t]!;
-				let fits = true;
-				for (const iv of intervals) {
-					if (iv.lo <= hi && lo <= iv.hi) {
-						fits = false;
-						break;
-					}
-				}
-				if (fits) {
-					intervals.push({ lo, hi });
-					idx = t;
-					break;
-				}
-			}
-			if (idx < 0) {
-				tracks.push([{ lo, hi }]);
-				idx = tracks.length - 1;
-			}
-			hopToTrackIdx.set(h, idx);
-		}
-
-		// Pass 2: distribute track indexes uniformly across the gutter's
-		// **interior** (reserve 1-cell margin from each boundary when the
-		// gutter is wide enough). A track placed exactly at `gutterStart`
-		// or `gEnd` collapses the final turn-segment into the adjacent
-		// node's border row, producing a visually misleading arrow; the
-		// margin avoids that whenever geometry allows.
-		const count = tracks.length;
-		const hasMargin = gutterWidth >= Math.max(3, count + 2);
-		const usableStart = hasMargin ? gutterStart + 1 : gutterStart;
-		const usableEnd = hasMargin ? gEnd - 1 : gEnd;
-		const usableWidth = Math.max(1, usableEnd - usableStart + 1);
-		for (const h of gutterHops) {
-			const idx = hopToTrackIdx.get(h)!;
-			let trackPrimary: number;
-			if (count <= 1) {
-				trackPrimary = usableStart + Math.floor(usableWidth / 2);
-			} else {
-				const step = (usableWidth - 1) / (count - 1);
-				trackPrimary = usableStart + Math.floor(idx * step);
-			}
-			hopTrackCross.set(h, Math.max(gutterStart, Math.min(gEnd, trackPrimary)));
-		}
-	}
-
-	// Build polylines.
-	const out: LayoutEdge[] = [];
-	for (const [, hops] of byChain) {
-		const points: LayoutEdgePoint[] = [];
-		for (let i = 0; i < hops.length; i += 1) {
-			const h = hops[i]!;
-			const src = state.nodes.get(h.fromId)!;
-			const dst = state.nodes.get(h.toId)!;
-			const track = hopTrackCross.get(h)!;
-			// Endpoints in (primary, cross) space.
-			const srcPrimary = src.isVirtual ? primary(src) : primary(src) + primarySize(src);
-			const dstPrimary = dst.isVirtual ? primary(dst) : primary(dst) - 1;
-			const sc = crossCenter(src);
-			const dc = crossCenter(dst);
-			if (i === 0) pushPoint(points, isLR, srcPrimary, sc);
-			if (sc !== dc) {
-				pushPoint(points, isLR, track, sc);
-				pushPoint(points, isLR, track, dc);
-			}
-			pushPoint(points, isLR, dstPrimary, dc);
-		}
-		const chain = hops[0]!;
-		out.push({
-			from: chain.chainFrom,
-			to: chain.chainTo,
-			points: dedupWaypoints(points),
-		});
-	}
-	return out;
-}
-
-function pushPoint(acc: LayoutEdgePoint[], isLR: boolean, primary: number, cross: number): void {
-	acc.push(isLR ? { x: primary, y: cross } : { x: cross, y: primary });
-}
-
-function dedupWaypoints(points: readonly LayoutEdgePoint[]): LayoutEdgePoint[] {
-	const out: LayoutEdgePoint[] = [];
-	for (const p of points) {
-		const last = out[out.length - 1];
-		if (!last || last.x !== p.x || last.y !== p.y) out.push(p);
-	}
-	return out;
-}
-
-// ---------------------------------------------------------------------------
-// Bounding box
-// ---------------------------------------------------------------------------
-
-function boundingBox(state: PipelineState): { width: number; height: number } {
-	let w = 0;
-	let h = 0;
-	for (const layer of state.layers) {
-		for (const n of layer) {
-			w = Math.max(w, n.x + n.w);
-			h = Math.max(h, n.y + n.h);
-		}
-	}
-	return { width: w, height: h };
-}
diff --git a/src/base/render/graph-spec-to-ascii.ts b/src/base/render/graph-spec-to-ascii.ts
deleted file mode 100644
index 6c3b47b7..00000000
--- a/src/base/render/graph-spec-to-ascii.ts
+++ /dev/null
@@ -1,91 +0,0 @@
-/**
- * `graphSpecToAscii(g, opts?)` — stdout-native DAG flowchart renderer for a
- * {@link GraphDescribeOutput}.
- *
- * Zero external dependencies, graph-size independent via proper Sugiyama
- * (layer assignment → virtual-node splitting → barycenter crossing
- * minimization → median-aligned coordinate assignment → per-gutter
- * track-assigned orthogonal routing). See
- * [_layout-sugiyama.ts](./_layout-sugiyama.ts) for the layout pipeline and
- * [_ascii-grid.ts](./_ascii-grid.ts) for the character blitter.
- *
- * Pure function over the describe snapshot; no Graph instance dependency.
- *
- * @category extra
- */
-
-import type { GraphDescribeOutput } from "@graphrefly/pure-ts/graph";
-import { renderGrid } from "./_ascii-grid.js";
-import { countCells, truncateToCells } from "./_ascii-width.js";
-import type { LayoutDirection } from "./_layout-sugiyama.js";
-import { sugiyamaLayout } from "./_layout-sugiyama.js";
-
-const DEFAULT_LABEL_WIDTH = 24;
-const LAYER_GAP = 4;
-const NODE_GAP = 1;
-const BOX_HEIGHT = 3;
-
-export type GraphSpecToAsciiOptions = {
-	/**
-	 * ASCII layout direction. ASCII grid semantics are meaningful only for
-	 * `"LR"` (default) and `"TD"`.
-	 */
-	direction?: LayoutDirection;
-	/** Per-box label cell cap; longer labels are truncated with `…`. Default `24`. */
-	maxLabelWidth?: number;
-	/** Glyph set: `"unicode"` (default, box-drawing) or `"ascii"` (`-|+<>v`). */
-	asciiCharset?: "unicode" | "ascii";
-	/** Optional logger hook; fires with the rendered text before return. */
-	logger?: (text: string) => void;
-};
-
-export function graphSpecToAscii(g: GraphDescribeOutput, opts?: GraphSpecToAsciiOptions): string {
-	const direction = normalizeAsciiDirection(opts?.direction);
-	const maxLabel = Math.max(3, opts?.maxLabelWidth ?? DEFAULT_LABEL_WIDTH);
-	const charset = opts?.asciiCharset ?? "unicode";
-
-	// Deterministic paths ordering — match the rest of describe rendering.
-	const paths = Object.keys(g.nodes).sort();
-	// Drop edges whose endpoints aren't in the current visible path set
-	// (respects actor filtering that the caller already applied).
-	const nodeSet = new Set(paths);
-	const edges = g.edges.filter((e) => nodeSet.has(e.from) && nodeSet.has(e.to));
-
-	// Precompute truncated labels + cell widths so the layout knows box
-	// dimensions without re-measuring.
-	const labels = new Map<string, string>();
-	const widths = new Map<string, number>();
-	for (const p of paths) {
-		const label = truncateToCells(p, maxLabel);
-		labels.set(p, label);
-		// Box width = label cells + 2 side borders + 2 cells of padding.
-		widths.set(p, countCells(label) + 4);
-	}
-
-	const layout = sugiyamaLayout({
-		nodes: paths,
-		edges,
-		widthCells: (id) => widths.get(id) ?? 3,
-		heightCells: () => BOX_HEIGHT,
-		layerGap: LAYER_GAP,
-		nodeGap: NODE_GAP,
-		direction,
-	});
-
-	const text = renderGrid(layout, {
-		charset,
-		labelOf: (id) => labels.get(id) ?? id,
-	});
-
-	opts?.logger?.(text);
-	return text;
-}
-
-function normalizeAsciiDirection(direction: unknown): LayoutDirection {
-	if (direction === undefined || direction === "LR") return "LR";
-	if (direction === "TD") return "TD";
-	// BT / RL are valid for the vector diagram formats but ASCII grid
-	// semantics are meaningful only for LR and TD — reject early with a
-	// clear message rather than silently ignoring.
-	throw new Error(`ascii describe supports direction "LR" or "TD" only; got ${String(direction)}`);
-}
diff --git a/src/base/render/graph-spec-to-d2.ts b/src/base/render/graph-spec-to-d2.ts
deleted file mode 100644
index 8638f4d2..00000000
--- a/src/base/render/graph-spec-to-d2.ts
+++ /dev/null
@@ -1,41 +0,0 @@
-/**
- * `graphSpecToD2(g, opts?)` — render a {@link GraphDescribeOutput} as D2
- * diagram text.
- *
- * Pure function over the describe snapshot; no Graph instance dependency.
- *
- * @category extra
- */
-
-import type { GraphDescribeOutput } from "@graphrefly/pure-ts/graph";
-import {
-	collectDiagramArrows,
-	type DiagramDirection,
-	d2DirectionFromGraphDirection,
-	escapeD2Label,
-	normalizeDiagramDirection,
-} from "./_internal.js";
-
-export type GraphSpecToD2Options = {
-	/** Diagram direction; default `"LR"`. */
-	direction?: DiagramDirection;
-};
-
-export function graphSpecToD2(g: GraphDescribeOutput, opts?: GraphSpecToD2Options): string {
-	const direction = normalizeDiagramDirection(opts?.direction);
-	const paths = Object.keys(g.nodes).sort();
-	const ids = new Map<string, string>();
-	for (let i = 0; i < paths.length; i += 1) ids.set(paths[i]!, `n${i}`);
-	const lines: string[] = [`direction: ${d2DirectionFromGraphDirection(direction)}`];
-	for (const path of paths) {
-		const id = ids.get(path)!;
-		lines.push(`${id}: "${escapeD2Label(path)}"`);
-	}
-	for (const [from, to] of collectDiagramArrows(g)) {
-		const fromId = ids.get(from);
-		const toId = ids.get(to);
-		if (!fromId || !toId) continue;
-		lines.push(`${fromId} -> ${toId}`);
-	}
-	return lines.join("\n");
-}
diff --git a/src/base/render/graph-spec-to-json.ts b/src/base/render/graph-spec-to-json.ts
deleted file mode 100644
index e7e58681..00000000
--- a/src/base/render/graph-spec-to-json.ts
+++ /dev/null
@@ -1,36 +0,0 @@
-/**
- * `graphSpecToJson(g, opts?)` — render a {@link GraphDescribeOutput} as
- * deterministic JSON text with sorted keys.
- *
- * Pure function over the describe snapshot; no Graph instance dependency.
- *
- * @category extra
- */
-
-import type { GraphDescribeOutput } from "@graphrefly/pure-ts/graph";
-import { sortJsonValue } from "./_internal.js";
-
-export type GraphSpecToJsonOptions = {
-	/** Include the Edges section (default `true`). */
-	includeEdges?: boolean;
-	/** Include the Subgraphs section (default `true`). */
-	includeSubgraphs?: boolean;
-	/** JSON indent (default `2`). */
-	indent?: number;
-	/** Optional logger hook; fires with the rendered text before return. */
-	logger?: (text: string) => void;
-};
-
-export function graphSpecToJson(g: GraphDescribeOutput, opts?: GraphSpecToJsonOptions): string {
-	const includeEdges = opts?.includeEdges ?? true;
-	const includeSubgraphs = opts?.includeSubgraphs ?? true;
-	const { expand: _expand, ...rest } = g;
-	const payload: GraphDescribeOutput = {
-		...rest,
-		edges: includeEdges ? g.edges : [],
-		subgraphs: includeSubgraphs ? g.subgraphs : [],
-	};
-	const text = JSON.stringify(sortJsonValue(payload), null, opts?.indent ?? 2);
-	opts?.logger?.(text);
-	return text;
-}
diff --git a/src/base/render/graph-spec-to-mermaid-url.ts b/src/base/render/graph-spec-to-mermaid-url.ts
deleted file mode 100644
index 324017c4..00000000
--- a/src/base/render/graph-spec-to-mermaid-url.ts
+++ /dev/null
@@ -1,50 +0,0 @@
-/**
- * `graphSpecToMermaidUrl(g, opts?)` — encode a {@link GraphDescribeOutput}
- * as a `https://mermaid.live/edit#base64:…` deep link.
- *
- * Round-trip with the mermaid.live editor's `/edit#base64:` share format —
- * payload is `base64url(JSON({code, mermaid: {theme}, ...}))`. No network
- * calls; the payload is encoded into the URL fragment.
- *
- * @category extra
- */
-
-import type { GraphDescribeOutput } from "@graphrefly/pure-ts/graph";
-import { type GraphSpecToMermaidOptions, graphSpecToMermaid } from "./graph-spec-to-mermaid.js";
-
-export type MermaidLiveTheme = "default" | "dark" | "forest" | "neutral" | "base";
-
-export type GraphSpecToMermaidUrlOptions = GraphSpecToMermaidOptions & {
-	theme?: MermaidLiveTheme;
-	autoSync?: boolean;
-};
-
-/**
- * Encode an arbitrary mermaid source string to a `mermaid.live` deep link.
- * Exported separately so callers that already rendered mermaid text can
- * upgrade to a live-editor URL without re-rendering.
- */
-export function mermaidLiveUrl(
-	mermaidSrc: string,
-	opts?: { theme?: MermaidLiveTheme; autoSync?: boolean },
-): string {
-	const theme = opts?.theme ?? "default";
-	const autoSync = opts?.autoSync ?? true;
-	const payload = { code: mermaidSrc, mermaid: { theme }, autoSync };
-	const json = JSON.stringify(payload);
-	// Browsers + Node both expose globalThis.btoa; encode UTF-8 bytes first so
-	// non-ASCII node names don't explode btoa. Then url-safe base64 (`+/=`→`-_` strip).
-	const bytes = new TextEncoder().encode(json);
-	let binary = "";
-	for (let i = 0; i < bytes.length; i++) binary += String.fromCharCode(bytes[i]!);
-	const b64 = globalThis.btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
-	return `https://mermaid.live/edit#base64:${b64}`;
-}
-
-export function graphSpecToMermaidUrl(
-	g: GraphDescribeOutput,
-	opts?: GraphSpecToMermaidUrlOptions,
-): string {
-	const mermaidSrc = graphSpecToMermaid(g, opts);
-	return mermaidLiveUrl(mermaidSrc, opts);
-}
diff --git a/src/base/render/graph-spec-to-mermaid.ts b/src/base/render/graph-spec-to-mermaid.ts
deleted file mode 100644
index 02c53973..00000000
--- a/src/base/render/graph-spec-to-mermaid.ts
+++ /dev/null
@@ -1,54 +0,0 @@
-/**
- * `graphSpecToMermaid(g, opts?)` — render a {@link GraphDescribeOutput} as
- * Mermaid flowchart text.
- *
- * Pure function over the describe snapshot; no Graph instance dependency.
- * Compose with `derived` for live formatted output:
- *
- * ```ts
- * import { graphSpecToMermaid } from "@graphrefly/graphrefly/extra/render";
- * import { derived } from "@graphrefly/graphrefly";
- *
- * const live = derived(
- *   [graph.describe({ reactive: true }).node],
- *   ([g]) => graphSpecToMermaid(g),
- * );
- * ```
- *
- * @category extra
- */
-
-import type { GraphDescribeOutput } from "@graphrefly/pure-ts/graph";
-import {
-	collectDiagramArrows,
-	type DiagramDirection,
-	escapeMermaidLabel,
-	normalizeDiagramDirection,
-} from "./_internal.js";
-
-export type GraphSpecToMermaidOptions = {
-	/** Diagram direction; default `"LR"`. */
-	direction?: DiagramDirection;
-};
-
-export function graphSpecToMermaid(
-	g: GraphDescribeOutput,
-	opts?: GraphSpecToMermaidOptions,
-): string {
-	const direction = normalizeDiagramDirection(opts?.direction);
-	const paths = Object.keys(g.nodes).sort();
-	const ids = new Map<string, string>();
-	for (let i = 0; i < paths.length; i += 1) ids.set(paths[i]!, `n${i}`);
-	const lines: string[] = [`flowchart ${direction}`];
-	for (const path of paths) {
-		const id = ids.get(path)!;
-		lines.push(`  ${id}["${escapeMermaidLabel(path)}"]`);
-	}
-	for (const [from, to] of collectDiagramArrows(g)) {
-		const fromId = ids.get(from);
-		const toId = ids.get(to);
-		if (!fromId || !toId) continue;
-		lines.push(`  ${fromId} --> ${toId}`);
-	}
-	return lines.join("\n");
-}
diff --git a/src/base/render/graph-spec-to-pretty.ts b/src/base/render/graph-spec-to-pretty.ts
deleted file mode 100644
index eed8a1a1..00000000
--- a/src/base/render/graph-spec-to-pretty.ts
+++ /dev/null
@@ -1,48 +0,0 @@
-/**
- * `graphSpecToPretty(g, opts?)` — render a {@link GraphDescribeOutput} as
- * human-readable plaintext (Node list with values, plus optional Edges and
- * Subgraphs sections).
- *
- * Pure function over the describe snapshot; no Graph instance dependency.
- *
- * @category extra
- */
-
-import type { GraphDescribeOutput } from "@graphrefly/pure-ts/graph";
-import { describeData } from "./_internal.js";
-
-export type GraphSpecToPrettyOptions = {
-	/** Include the Edges section (default `true`). */
-	includeEdges?: boolean;
-	/** Include the Subgraphs section (default `true`). */
-	includeSubgraphs?: boolean;
-	/** Optional logger hook; fires with the rendered text before return. */
-	logger?: (text: string) => void;
-};
-
-export function graphSpecToPretty(g: GraphDescribeOutput, opts?: GraphSpecToPrettyOptions): string {
-	const includeEdges = opts?.includeEdges ?? true;
-	const includeSubgraphs = opts?.includeSubgraphs ?? true;
-	const lines: string[] = [];
-	lines.push(`Graph ${g.name}`);
-	lines.push("Nodes:");
-	for (const path of Object.keys(g.nodes).sort()) {
-		const n = g.nodes[path]!;
-		lines.push(`- ${path} (${n.type}/${n.status}): ${describeData(n.value)}`);
-	}
-	if (includeEdges) {
-		lines.push("Edges:");
-		for (const edge of g.edges) {
-			lines.push(`- ${edge.from} -> ${edge.to}`);
-		}
-	}
-	if (includeSubgraphs) {
-		lines.push("Subgraphs:");
-		for (const sg of g.subgraphs) {
-			lines.push(`- ${sg}`);
-		}
-	}
-	const text = lines.join("\n");
-	opts?.logger?.(text);
-	return text;
-}
diff --git a/src/base/render/index.ts b/src/base/render/index.ts
deleted file mode 100644
index d5ed8479..00000000
--- a/src/base/render/index.ts
+++ /dev/null
@@ -1,39 +0,0 @@
-/**
- * Renderers barrel — pure functions over `GraphDescribeOutput` (Tier 2.1 A2).
- *
- * Each function takes a describe snapshot and returns a formatted string.
- * Compose with `derived` for live formatted output:
- *
- * ```ts
- * import { graphSpecToMermaid } from "@graphrefly/graphrefly/extra/render";
- * import { derived } from "@graphrefly/graphrefly";
- *
- * const live = derived(
- *   [graph.describe({ reactive: true }).node],
- *   ([g]) => graphSpecToMermaid(g),
- * );
- * ```
- *
- * Replaces the old `describe({ format })` dispatch — the `format` sugar option
- * was removed in the D1 three-layer-view refactor (pre-1.0 breaking, no shim).
- *
- * @module
- */
-
-export type { DiagramDirection } from "./_internal.js";
-export type { LayoutDirection } from "./_layout-sugiyama.js";
-export { type GraphSpecToAsciiOptions, graphSpecToAscii } from "./graph-spec-to-ascii.js";
-export { type GraphSpecToD2Options, graphSpecToD2 } from "./graph-spec-to-d2.js";
-export { type GraphSpecToJsonOptions, graphSpecToJson } from "./graph-spec-to-json.js";
-export { type GraphSpecToMermaidOptions, graphSpecToMermaid } from "./graph-spec-to-mermaid.js";
-export {
-	type GraphSpecToMermaidUrlOptions,
-	graphSpecToMermaidUrl,
-	type MermaidLiveTheme,
-	mermaidLiveUrl,
-} from "./graph-spec-to-mermaid-url.js";
-export { type GraphSpecToPrettyOptions, graphSpecToPretty } from "./graph-spec-to-pretty.js";
-export {
-	type LayoutFrameToSvgOptions,
-	layoutFrameToSvg,
-} from "./layout-frame-to-svg.js";
diff --git a/src/base/render/layout-frame-to-svg.ts b/src/base/render/layout-frame-to-svg.ts
deleted file mode 100644
index 3314b7ec..00000000
--- a/src/base/render/layout-frame-to-svg.ts
+++ /dev/null
@@ -1,118 +0,0 @@
-/**
- * `layoutFrameToSvg(frame, opts?)` — render a {@link LayoutFrame} as an SVG
- * markup string.
- *
- * Universal-safe — emits a string, not a DOM tree. Browser code embeds via
- * `el.innerHTML = svg`; Node code writes to a file. Cell-grid coordinates from
- * the layout are scaled by `cellWidth` / `cellHeight` (default 12 × 18 px,
- * roughly matching a monospace baseline).
- *
- * Each box gets `data-id="<path>"` for change-event highlighting; each edge
- * gets `data-from="<from>" data-to="<to>"` so renderers can animate flowing
- * data per `LayoutFrame.changes`.
- *
- * @category extra
- */
-
-import type { LayoutFrame } from "./layout-types.js";
-
-export interface LayoutFrameToSvgOptions {
-	/** Pixel width of one cell. Default: `12`. */
-	readonly cellWidth?: number;
-	/** Pixel height of one cell. Default: `18`. */
-	readonly cellHeight?: number;
-	/** Outer margin in pixels. Default: `16`. */
-	readonly padding?: number;
-	/** Box stroke color. Default: `"#444"`. */
-	readonly boxStroke?: string;
-	/** Box fill color. Default: `"#fff"`. */
-	readonly boxFill?: string;
-	/** Edge stroke color. Default: `"#888"`. */
-	readonly edgeStroke?: string;
-	/** Box label text color. Default: `"#111"`. */
-	readonly textColor?: string;
-	/** Font family. Default: `"ui-monospace, monospace"`. */
-	readonly fontFamily?: string;
-	/** Font size in pixels. Default: `12`. */
-	readonly fontSize?: number;
-}
-
-const SPECIAL_CHARS: Record<string, string> = {
-	"&": "&amp;",
-	"<": "&lt;",
-	">": "&gt;",
-	'"': "&quot;",
-	"'": "&apos;",
-};
-
-function escapeXml(s: string): string {
-	return s.replace(/[&<>"']/g, (c) => SPECIAL_CHARS[c] ?? c);
-}
-
-/**
- * Render a {@link LayoutFrame} to SVG markup. Pure function — call from
- * `derived` to drive a live `<svg>` element from a `topologyView` output.
- */
-export function layoutFrameToSvg(frame: LayoutFrame, opts?: LayoutFrameToSvgOptions): string {
-	const cellW = opts?.cellWidth ?? 12;
-	const cellH = opts?.cellHeight ?? 18;
-	const pad = opts?.padding ?? 16;
-	// /qa F-10: route option-bag string attributes through escapeXml so that
-	// user-supplied themes (URL params, dashboard config, etc.) cannot inject
-	// `"/><script>...` and break out of the attribute. Numeric `fontSize` has
-	// no XSS surface; escape only when caller passes a string.
-	const boxStroke = escapeXml(opts?.boxStroke ?? "#444");
-	const boxFill = escapeXml(opts?.boxFill ?? "#fff");
-	const edgeStroke = escapeXml(opts?.edgeStroke ?? "#888");
-	const textColor = escapeXml(opts?.textColor ?? "#111");
-	const fontFamily = opts?.fontFamily ?? "ui-monospace, monospace";
-	const fontSize = opts?.fontSize ?? 12;
-
-	let maxX = 0;
-	let maxY = 0;
-	for (const b of frame.boxes) {
-		maxX = Math.max(maxX, b.x + b.w);
-		maxY = Math.max(maxY, b.y + b.h);
-	}
-	for (const e of frame.edges) {
-		for (const [x, y] of e.points) {
-			maxX = Math.max(maxX, x);
-			maxY = Math.max(maxY, y);
-		}
-	}
-	const width = Math.max(1, maxX) * cellW + pad * 2;
-	const height = Math.max(1, maxY) * cellH + pad * 2;
-
-	const lines: string[] = [];
-	lines.push(
-		`<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 ${width} ${height}" width="${width}" height="${height}">`,
-	);
-
-	// Edges first (so boxes overlay them at endpoints).
-	for (const e of frame.edges) {
-		if (e.points.length < 2) continue;
-		const pts = e.points.map(([x, y]) => `${x * cellW + pad},${y * cellH + pad}`).join(" ");
-		lines.push(
-			`  <polyline points="${pts}" fill="none" stroke="${edgeStroke}" stroke-width="1" data-from="${escapeXml(e.from)}" data-to="${escapeXml(e.to)}" data-dep-index="${e.depIndex}" />`,
-		);
-	}
-
-	// Boxes.
-	for (const b of frame.boxes) {
-		const px = b.x * cellW + pad;
-		const py = b.y * cellH + pad;
-		const pw = Math.max(1, b.w) * cellW;
-		const ph = Math.max(1, b.h) * cellH;
-		// Local segment for label so deeply-mounted nodes stay readable.
-		const local = b.id.includes("::") ? (b.id.split("::").pop() ?? b.id) : b.id;
-		lines.push(
-			`  <g data-id="${escapeXml(b.id)}">`,
-			`    <rect x="${px}" y="${py}" width="${pw}" height="${ph}" fill="${boxFill}" stroke="${boxStroke}" stroke-width="1" />`,
-			`    <text x="${px + pw / 2}" y="${py + ph / 2}" fill="${textColor}" font-family="${escapeXml(fontFamily)}" font-size="${fontSize}" text-anchor="middle" dominant-baseline="central">${escapeXml(local)}</text>`,
-			`  </g>`,
-		);
-	}
-
-	lines.push("</svg>");
-	return lines.join("\n");
-}
diff --git a/src/base/render/layout-types.ts b/src/base/render/layout-types.ts
deleted file mode 100644
index 5472fa65..00000000
--- a/src/base/render/layout-types.ts
+++ /dev/null
@@ -1,73 +0,0 @@
-/**
- * Canonical home for layout types. Lives in `extra/render/` because the SVG
- * renderer (`layout-frame-to-svg.ts`) consumes them; `patterns/topology-view`
- * re-exports them through its public types module. Keeping the layering
- * downward (extra/ → patterns/) avoids the inverted import that flagged in
- * /qa F-17.
- *
- * @module
- */
-
-import type { GraphChange, GraphDescribeOutput } from "@graphrefly/pure-ts/graph";
-
-/**
- * One node placement in cell-grid coordinates.
- *
- * `id` is the node's qualified path (`::`-delimited). `x`/`y`/`w`/`h` are
- * direction-agnostic integer cell coordinates produced by the layout; the
- * default direction is `"LR"` (layers grow along x). Renderers map cells →
- * pixels (or characters) at draw time.
- *
- * `meta` is forwarded from the source describe snapshot (read-only) — useful
- * for renderers that color/style by `kind`, factory tag, or domain meta.
- */
-export interface LayoutBox {
-	readonly id: string;
-	readonly x: number;
-	readonly y: number;
-	readonly w: number;
-	readonly h: number;
-	readonly meta?: Record<string, unknown>;
-}
-
-/**
- * One edge placement. `from`/`to` are qualified node paths. `depIndex` is
- * the positional dep index on the `to` node (matches `fromDepIndex` on
- * {@link GraphChange} `data` events). `points` is the polyline of waypoints
- * (start → corners → end) in cell-grid coordinates.
- */
-export interface LayoutEdge {
-	readonly from: string;
-	readonly to: string;
-	readonly depIndex: number;
-	readonly points: ReadonlyArray<readonly [number, number]>;
-}
-
-/**
- * One frame of the live topology view.
- *
- * - `boxes` — current node placements (full set, not a delta).
- * - `edges` — current edge polylines (full set).
- * - `changes` — the {@link GraphChange} events that flowed in the wave that
- *   produced this frame. Empty on the initial push-on-subscribe frame
- *   (consumers seeded from `graph.describe()`); populated on subsequent
- *   batches. Renderers can highlight changed nodes / animate flowing edges
- *   per change-event scope.
- */
-export interface LayoutFrame {
-	readonly boxes: readonly LayoutBox[];
-	readonly edges: readonly LayoutEdge[];
-	readonly changes: readonly GraphChange[];
-}
-
-/**
- * Pluggable layout function — receives a {@link GraphDescribeOutput} snapshot
- * and returns the box / edge placements for the current topology. Pure-fn
- * shape so the default in `_internal.ts` and third-party adapters
- * (e.g. wrapping `dagre`, `elk`, `cytoscape`) share the same signature.
- *
- * `changes` (the per-frame batch) is overlaid on the layout's output by
- * `topologyView`'s internal `frame` derived — layout fns don't need to
- * handle batched events themselves.
- */
-export type LayoutFn = (spec: GraphDescribeOutput) => Pick<LayoutFrame, "boxes" | "edges">;
diff --git a/src/base/resilience/_internal.ts b/src/base/resilience/_internal.ts
deleted file mode 100644
index 7fbf5c70..00000000
--- a/src/base/resilience/_internal.ts
+++ /dev/null
@@ -1,111 +0,0 @@
-/**
- * Internal helpers shared by resilience sub-files.
- *
- * Not part of the public surface. The base-layer resilience operators
- * co-located here (`retry.ts`, `status.ts`, `timeout.ts`) import what they
- * need from this file directly; the utils-layer resilience primitives that
- * stayed in `utils/resilience/` (`breaker.ts`, `rate-limiter.ts`,
- * `fallback.ts`) import it top-down via `../../base/resilience/_internal.js`.
- *
- * `NodeOrValue<T>` is the only export re-surfaced publicly — there is no
- * `base/resilience/index.ts`; it ships through `utils/resilience/index.ts`
- * (and `utils/memory/index.ts`). Every resilience primitive that accepts
- * reactive options uses it as the option-arg shape.
- */
-
-import type { Node, NodeOptions } from "@graphrefly/pure-ts/core";
-import { DATA, type Message } from "@graphrefly/pure-ts/core";
-
-export type ExtraOpts = Omit<NodeOptions, "describeKind">;
-
-export function operatorOpts<T>(opts?: ExtraOpts): NodeOptions<T> {
-	return { describeKind: "derived", ...opts } as NodeOptions<T>;
-}
-
-export function clampNonNegative(value: number): number {
-	return value < 0 ? 0 : value;
-}
-
-export function msgVal(m: Message): unknown {
-	return m[1];
-}
-
-export function coerceDelayNs(raw: number): number {
-	if (typeof raw !== "number" || !Number.isFinite(raw)) {
-		throw new TypeError("backoff strategy must return a finite number");
-	}
-	return raw < 0 ? 0 : raw;
-}
-
-export function isNode(x: unknown): x is Node {
-	return (
-		x != null &&
-		typeof x === "object" &&
-		"cache" in x &&
-		typeof (x as Node).subscribe === "function"
-	);
-}
-
-/**
- * Either a literal value or a reactive Node carrying it. Mirrors
- * {@link FallbackInput}'s precedent for "options that may be reactive."
- *
- * Used by {@link timeout} / {@link retry} / {@link rateLimiter} /
- * {@link circuitBreaker} / {@link budgetGate} to accept reactive option
- * configurations (Tier 6.5 3.2, 2026-04-29). Each primitive subscribes
- * to the option Node via {@link resolveReactiveOption} and rebinds
- * internal state per its locked swap-semantic rule (see each primitive's
- * JSDoc for the rule).
- *
- * @category extra
- */
-export type NodeOrValue<T> = T | Node<T>;
-
-/**
- * Closure-mirror helper for `NodeOrValue<T>` options
- * (COMPOSITION-GUIDE §28). Returns:
- * - `current()` — read the latest value (cached at construction; updated
- *   on each Node DATA emission).
- * - `unsub()` — release the subscription. Static-form arg never
- *   subscribes; `unsub` is a no-op there.
- *
- * `onChange` fires on each DATA after the initial value (skips the
- * cache-seed read). Use to rebind primitive-internal state per the
- * primitive's locked swap-semantic rule.
- *
- * @internal
- */
-export function resolveReactiveOption<T>(
-	arg: NodeOrValue<T>,
-	onChange?: (next: T) => void,
-): { current: () => T; unsub: () => void } {
-	if (!isNode(arg)) {
-		return { current: () => arg, unsub: () => undefined };
-	}
-	const node = arg as Node<T>;
-	let latest: T = node.cache as T;
-	const unsub = node.subscribe((msgs) => {
-		for (const m of msgs) {
-			if (m[0] === DATA) {
-				latest = m[1] as T;
-				if (onChange) onChange(latest);
-			}
-		}
-	});
-	return {
-		current: () => latest,
-		unsub,
-	};
-}
-
-export function isThenable(x: unknown): x is PromiseLike<unknown> {
-	return x != null && typeof (x as PromiseLike<unknown>).then === "function";
-}
-
-export function isAsyncIterable(x: unknown): x is AsyncIterable<unknown> {
-	return (
-		x != null &&
-		typeof x === "object" &&
-		typeof (x as AsyncIterable<unknown>)[Symbol.asyncIterator] === "function"
-	);
-}
diff --git a/src/base/resilience/backoff.ts b/src/base/resilience/backoff.ts
deleted file mode 100644
index 76f7b04c..00000000
--- a/src/base/resilience/backoff.ts
+++ /dev/null
@@ -1,264 +0,0 @@
-/**
- * Backoff strategies for {@link retry} (roadmap §3.1). Delays are in **nanoseconds**.
- *
- * Convention: all graphrefly-ts timestamps and durations use nanoseconds (`_ns` suffix).
- * 1 second = 1_000_000_000 ns, 1 ms = 1_000_000 ns.
- */
-
-export const NS_PER_MS = 1_000_000;
-export const NS_PER_SEC = 1_000_000_000;
-
-export type JitterMode = "none" | "full" | "equal";
-
-export type BackoffPreset =
-	| "constant"
-	| "linear"
-	| "exponential"
-	| "fibonacci"
-	| "decorrelatedJitter";
-
-/** `(attempt, error?, previousDelayNs?) => delayNs | null` — `null` means zero delay. */
-export type BackoffStrategy = (
-	attempt: number,
-	error?: unknown,
-	prevDelayNs?: number | null,
-) => number | null;
-
-function clampNonNegative(value: number): number {
-	return value < 0 ? 0 : value;
-}
-
-function applyJitter(delay: number, jitter: JitterMode): number {
-	if (jitter === "none") return delay;
-	if (jitter === "full") return Math.random() * delay;
-	return delay / 2 + Math.random() * (delay / 2);
-}
-
-function randomBetween(min: number, max: number): number {
-	return min + Math.random() * (max - min);
-}
-
-/**
- * Builds a strategy that always returns the same delay in nanoseconds.
- *
- * @param delayNs - Non-negative delay in nanoseconds; values below zero are clamped to zero.
- * @returns `BackoffStrategy` for use with {@link retry} or custom timers.
- *
- * @example
- * ```ts
- * import { constant, retry, NS_PER_SEC } from "@graphrefly/graphrefly";
- *
- * const out = retry(source, { count: 3, backoff: constant(0.25 * NS_PER_SEC) });
- * ```
- *
- * @category extra
- */
-export function constant(delayNs: number): BackoffStrategy {
-	const safe = clampNonNegative(delayNs);
-	return () => safe;
-}
-
-/**
- * Builds linear backoff: `baseNs + stepNs * attempt` (`stepNs` defaults to `baseNs`).
- *
- * @param baseNs - Base delay in nanoseconds (clamped non-negative).
- * @param stepNs - Added per retry attempt in nanoseconds (clamped non-negative).
- * @returns `BackoffStrategy` for {@link retry}.
- *
- * @example
- * ```ts
- * import { linear, retry, NS_PER_SEC } from "@graphrefly/graphrefly";
- *
- * // Attempt 0 → 1 s, attempt 1 → 2 s, attempt 2 → 3 s …
- * const out = retry(source, { count: 4, backoff: linear(NS_PER_SEC) });
- * ```
- *
- * @category extra
- */
-export function linear(baseNs: number, stepNs?: number): BackoffStrategy {
-	const safeBase = clampNonNegative(baseNs);
-	const safeStep = stepNs === undefined ? safeBase : clampNonNegative(stepNs);
-	return (attempt: number) => safeBase + safeStep * Math.max(0, attempt);
-}
-
-export type ExponentialBackoffOptions = {
-	baseNs?: number;
-	factor?: number;
-	maxDelayNs?: number;
-	jitter?: JitterMode;
-};
-
-/**
- * Builds exponential backoff in nanoseconds, capped by `maxDelayNs`, with optional jitter.
- *
- * @param options - Base, factor, cap, and jitter mode.
- * @returns `BackoffStrategy` for {@link retry}.
- *
- * @remarks
- * **Jitter:** `"full"` spreads delay across `[0, delay]`; `"equal"` uses `[delay/2, delay]`.
- *
- * @example
- * ```ts
- * import { exponential, retry, NS_PER_SEC } from "@graphrefly/graphrefly";
- *
- * // 100 ms → 200 ms → 400 ms … capped at 30 s, with full jitter
- * const out = retry(source, {
- *   count: 5,
- *   backoff: exponential({ baseNs: 100 * NS_PER_SEC / 1000, jitter: "full" }),
- * });
- * ```
- *
- * @category extra
- */
-export function exponential(options?: ExponentialBackoffOptions): BackoffStrategy {
-	const baseNs = clampNonNegative(options?.baseNs ?? 100 * NS_PER_MS);
-	const factor = options?.factor !== undefined && options.factor < 1 ? 1 : (options?.factor ?? 2);
-	const maxDelayNs = clampNonNegative(options?.maxDelayNs ?? 30 * NS_PER_SEC);
-	const jitter = options?.jitter ?? "none";
-
-	return (attempt: number) => {
-		let delay: number;
-		if (baseNs === 0) {
-			delay = 0;
-		} else if (factor === 1) {
-			delay = baseNs;
-		} else {
-			const capRatio = maxDelayNs / baseNs;
-			let growth = 1;
-			for (let i = 0; i < Math.max(0, attempt); i++) {
-				if (growth >= capRatio) {
-					growth = capRatio;
-					break;
-				}
-				growth *= factor;
-			}
-			delay = baseNs * growth;
-			if (delay > maxDelayNs) delay = maxDelayNs;
-		}
-		return applyJitter(delay, jitter);
-	};
-}
-
-/**
- * Builds Fibonacci-scaled delays: `1, 2, 3, 5, … × baseNs`, capped at `maxDelayNs`.
- *
- * @param baseNs - Multiplier applied to the Fibonacci unit (default `100ms` in nanoseconds).
- * @param maxDelayNs - Upper bound in nanoseconds (default `30s`).
- * @returns `BackoffStrategy` for {@link retry}.
- *
- * @example
- * ```ts
- * import { fibonacci, retry, NS_PER_MS } from "@graphrefly/graphrefly";
- *
- * // Delays: 100 ms, 200 ms, 300 ms, 500 ms, 800 ms … (× 100 ms base)
- * const out = retry(source, { count: 5, backoff: fibonacci(100 * NS_PER_MS) });
- * ```
- *
- * @category extra
- */
-export function fibonacci(baseNs = 100 * NS_PER_MS, maxDelayNs = 30 * NS_PER_SEC): BackoffStrategy {
-	const safeBase = clampNonNegative(baseNs);
-	const safeMax = clampNonNegative(maxDelayNs);
-
-	function fibUnit(attempt: number): number {
-		if (attempt <= 0) return 1;
-		let prev = 1;
-		let cur = 2;
-		for (let i = 1; i < attempt; i++) {
-			const next = prev + cur;
-			prev = cur;
-			cur = next;
-		}
-		return cur;
-	}
-
-	return (attempt: number) => {
-		const raw = fibUnit(attempt) * safeBase;
-		return raw <= safeMax ? raw : safeMax;
-	};
-}
-
-/**
- * Decorrelated jitter (AWS-recommended): `random(baseNs, min(maxNs, lastDelay * 3))`.
- *
- * Stateless — uses `prevDelayNs` (passed by the consumer) instead of closure state.
- * Safe to share across concurrent retry sequences.
- *
- * @param baseNs - Floor of the random range (default `100ms` in nanoseconds).
- * @param maxNs - Ceiling cap (default `30s` in nanoseconds).
- * @returns `BackoffStrategy` for {@link retry}.
- *
- * @example
- * ```ts
- * import { decorrelatedJitter, retry, NS_PER_MS, NS_PER_SEC } from "@graphrefly/graphrefly";
- *
- * const out = retry(source, {
- *   count: 6,
- *   backoff: decorrelatedJitter(100 * NS_PER_MS, 10 * NS_PER_SEC),
- * });
- * ```
- *
- * @category extra
- */
-export function decorrelatedJitter(
-	baseNs = 100 * NS_PER_MS,
-	maxNs = 30 * NS_PER_SEC,
-): BackoffStrategy {
-	return (_attempt, _error, prevDelayNs) => {
-		const last = prevDelayNs ?? baseNs;
-		const ceiling = Math.min(maxNs, last * 3);
-		return randomBetween(baseNs, ceiling);
-	};
-}
-
-/**
- * Decorator that caps any strategy at `maxAttempts`. Returns `null` (stop retrying) after the cap.
- *
- * @param strategy - Inner strategy to wrap.
- * @param maxAttempts - Maximum number of attempts (inclusive).
- * @returns Wrapped `BackoffStrategy`.
- *
- * @example
- * ```ts
- * import { withMaxAttempts, exponential } from "@graphrefly/graphrefly";
- *
- * const capped = withMaxAttempts(exponential(), 3);
- * capped(3); // null — no more retries beyond attempt 3
- * ```
- *
- * @category extra
- */
-export function withMaxAttempts(strategy: BackoffStrategy, maxAttempts: number): BackoffStrategy {
-	return (attempt, error, prevDelayNs) => {
-		if (attempt >= maxAttempts) return null;
-		return strategy(attempt, error, prevDelayNs);
-	};
-}
-
-/**
- * Maps a preset name to a concrete {@link BackoffStrategy} with library-default parameters.
- *
- * @param name - One of `constant`, `linear`, `exponential`, `fibonacci`, or `decorrelatedJitter`.
- * @returns Configured strategy with default parameters.
- * @throws Error when `name` is not a known preset.
- *
- * @example
- * ```ts
- * import { resolveBackoffPreset, retry } from "@graphrefly/graphrefly";
- *
- * const out = retry(source, { count: 3, backoff: resolveBackoffPreset("exponential") });
- * // Equivalent to retry(source, { count: 3, backoff: exponential() })
- * ```
- *
- * @category extra
- */
-export function resolveBackoffPreset(name: BackoffPreset): BackoffStrategy {
-	if (name === "constant") return constant(1 * NS_PER_SEC);
-	if (name === "linear") return linear(1 * NS_PER_SEC);
-	if (name === "exponential") return exponential();
-	if (name === "fibonacci") return fibonacci();
-	if (name === "decorrelatedJitter") return decorrelatedJitter();
-	throw new Error(
-		`Unknown backoff preset: "${String(name)}". Use one of: constant, linear, exponential, fibonacci, decorrelatedJitter`,
-	);
-}
diff --git a/src/base/resilience/retry.ts b/src/base/resilience/retry.ts
deleted file mode 100644
index 559af1d5..00000000
--- a/src/base/resilience/retry.ts
+++ /dev/null
@@ -1,468 +0,0 @@
-/**
- * Retry — re-attempt a node on terminal failure.
- *
- * Two modes selected by the type of `input`:
- * - **Source mode** (`Node<T>`): resubscribes the same node after each ERROR.
- *   Upstream must be `resubscribable: true` or retries are silent no-ops.
- * - **Factory mode** (`() => Node<T>`): builds a fresh node per attempt.
- *
- * Shared with `circuitBreaker` / `rateLimiter`: `NodeOrValue<RetryOptions>`
- * lets callers swap retry config reactively (re-validates on each attempt).
- */
-
-import {
-	COMPLETE,
-	DATA,
-	DIRTY,
-	ERROR,
-	factoryTag,
-	type Message,
-	type Node,
-	node,
-	RESOLVED,
-	ResettableTimer,
-} from "@graphrefly/pure-ts/core";
-import { coerceDelayNs, isNode, msgVal, type NodeOrValue, operatorOpts } from "./_internal.js";
-import {
-	type BackoffPreset,
-	type BackoffStrategy,
-	NS_PER_MS,
-	resolveBackoffPreset,
-} from "./backoff.js";
-import type { StatusValue } from "./status.js";
-
-/**
- * Lifecycle-shaped state companion emitted by {@link retry} (DS-13.5.B,
- * locked 2026-05-01). Tracks the retry state machine's current status,
- * the attempt counter, and the last scheduled delay (null before the
- * first retry).
- *
- * @category extra/resilience
- */
-export interface RetryState {
-	status: StatusValue;
-	attempt: number;
-	lastDelay_ns: number | null;
-}
-
-/**
- * Bundle returned by {@link retry}: the retry-wrapped output node and its
- * lifecycle state companion. Pre-1.0 break vs the prior `Node<T>` return.
- *
- * **Single-subscriber / pipeline-only contract (DS-13.5.B QA, N1, 2026-05-03).**
- * The `retryState` companion is allocated once at factory time and shared
- * across all subscribers to `node`. With one subscriber (the typical use
- * case — wire `node` into your downstream chain, optionally observe
- * `retryState` separately) the companion reflects a coherent timeline.
- * With **two or more subscribers** to `node`, each subscriber re-runs the
- * producer body and writes into the same `retryState`, including
- * `publish("pending")` resets that can clobber an in-flight machine's
- * `running`/`paused` state. Don't fan out `node` to multiple subscribers
- * and rely on `retryState` accuracy unless you use
- * {@link keepalive} / `share`-style consolidation.
- *
- * @category extra/resilience
- */
-export interface RetryBundle<T> {
-	node: Node<T>;
-	retryState: Node<RetryState>;
-}
-
-export type RetryOptions = {
-	/**
-	 * Max retry attempts after each terminal `ERROR` (not counting the first failure).
-	 *
-	 * **Required when `backoff` is set.** Pass `Infinity` to opt in to unbounded retries
-	 * — the explicit value rules out the silent-infinite-budget footgun (a flaky provider
-	 * + exponential backoff + omitted `count` would previously default to ~2.1B retries).
-	 */
-	count?: number;
-	/** Delay between attempts; strategies use **nanoseconds**. */
-	backoff?: BackoffStrategy | BackoffPreset;
-	/**
-	 * Caller-supplied metadata merged into the produced node's `meta` (Tier 5.2
-	 * D8 widening). Use {@link domainMeta} to tag the layer for `describe()`
-	 * grouping. The primitive's `factoryTag("retry", …)` always wins against
-	 * caller keys.
-	 */
-	meta?: Record<string, unknown>;
-};
-
-/** Factory-mode-only options. `initial` seeds the outer node's cache before the first attempt. */
-export type RetryFactoryOptions<T> = RetryOptions & {
-	/** Initial cache value for the outer node before the factory runs the first time. */
-	initial?: T;
-};
-
-/**
- * Resolved retry config shared by source-mode and factory-mode wrappers.
- * Centralises the unbounded-retry footgun guard and strategy resolution.
- */
-type ResolvedRetryConfig = {
-	maxRetries: number;
-	strategy: BackoffStrategy | null;
-};
-
-function resolveRetryConfig(opts?: RetryOptions): ResolvedRetryConfig {
-	const count = opts?.count;
-	const backoffOpt = opts?.backoff;
-
-	// Unbounded-retry footgun fix: if `backoff` is set without explicit `count`,
-	// throw at construction time. Caller must opt in to `Infinity` for unbounded.
-	if (backoffOpt !== undefined && count === undefined) {
-		throw new RangeError(
-			"retry({ backoff }) requires explicit count to prevent unbounded retries; pass { count: <n>, backoff: ... }",
-		);
-	}
-
-	const maxRetries = count !== undefined ? count : 0;
-	if (maxRetries < 0) throw new RangeError("retry count must be >= 0");
-
-	const strategy: BackoffStrategy | null =
-		backoffOpt === undefined
-			? null
-			: typeof backoffOpt === "string"
-				? resolveBackoffPreset(backoffOpt)
-				: backoffOpt;
-
-	return { maxRetries, strategy };
-}
-
-function retryFactoryArgs(opts?: RetryOptions): Record<string, unknown> | undefined {
-	const args: Record<string, unknown> = {};
-	if (opts?.count !== undefined) args.count = opts.count;
-	if (typeof opts?.backoff === "string") args.backoff = opts.backoff;
-	return Object.keys(args).length > 0 ? args : undefined;
-}
-
-/**
- * Shared retry state machine. Both `_retrySource` and `_retryFactory` thin-wrap this:
- * the only per-mode logic is supplied via `acquireSource` (returns a fresh `Node<T>`
- * per attempt — for source-mode it just returns the captured `Node`; for factory-mode
- * it calls the user factory and forwards synchronous throws into the same retry path).
- *
- * **Reactive cfg (Tier 6.5 3.2.2, 2026-04-29).** `getCfg` is invoked at
- * every decision point (`scheduleRetryOrFinish` count + strategy reads)
- * so option swaps mid-flight take effect at the next attempt boundary
- * per the locked semantic rule: "next attempt fails immediately if
- * already exhausted under new count; `backoff` swap takes effect at next
- * retry's delay calculation."
- */
-function _runRetryStateMachine<T>(
-	getCfg: () => ResolvedRetryConfig,
-	acquireSource: () => Node<T>,
-	a: { emit: (v: T) => void; down: (msgs: Message[]) => void },
-	emitState?: (next: RetryState) => void,
-): () => void {
-	let attempt = 0;
-	let stopped = false;
-	let prevDelay: number | null = null;
-	let unsub: (() => void) | undefined;
-	const timer = new ResettableTimer();
-	const publish = (status: StatusValue): void => {
-		emitState?.({ status, attempt, lastDelay_ns: prevDelay });
-	};
-	publish("pending");
-
-	function disconnectUpstream(): void {
-		unsub?.();
-		unsub = undefined;
-	}
-
-	function scheduleRetryOrFinish(err: unknown): void {
-		if (stopped) return;
-		const cfg = getCfg();
-		if (attempt >= cfg.maxRetries) {
-			disconnectUpstream();
-			publish("errored");
-			a.down([[ERROR, err]]);
-			return;
-		}
-		const raw = cfg.strategy === null ? 0 : cfg.strategy(attempt, err, prevDelay);
-		// null from strategy = "stop retrying" (e.g. withMaxAttempts cap reached)
-		if (raw === null || raw === undefined) {
-			disconnectUpstream();
-			publish("errored");
-			a.down([[ERROR, err]]);
-			return;
-		}
-		// A misbehaving strategy (returns NaN / non-finite / negative) MUST NOT
-		// escape into the upstream drain. Treat it like `strategy === null`
-		// (stop retrying) and emit the original error — the strategy bug is a
-		// separate concern the user can inspect via the emitted error's stack.
-		let delayNs: number;
-		try {
-			delayNs = coerceDelayNs(raw);
-		} catch {
-			disconnectUpstream();
-			publish("errored");
-			a.down([[ERROR, err]]);
-			return;
-		}
-		prevDelay = delayNs;
-		attempt += 1;
-		disconnectUpstream();
-		publish("paused");
-		// `Math.max(1, …)` floor: every backoff schedule floors at 1ms even when
-		// the strategy returns 0ns. Avoids 0-delay re-entrancy on the active
-		// stack frame (which would risk stack overflow on a tight ERROR loop).
-		const delayMs = delayNs > 0 ? delayNs / NS_PER_MS : 1;
-		// §5.10: setTimeout (not fromTimer) — retry delay needs clearTimeout/setTimeout;
-		// fromTimer creates a new Node per reset, adding lifecycle overhead per retry.
-		timer.start(delayMs, () => {
-			if (stopped) return;
-			connect();
-		});
-	}
-
-	function connect(): void {
-		timer.cancel();
-		disconnectUpstream();
-		let src: Node<T>;
-		try {
-			src = acquireSource();
-		} catch (err) {
-			scheduleRetryOrFinish(err);
-			return;
-		}
-		publish("running");
-		unsub = src.subscribe((msgs) => {
-			if (stopped) return;
-			for (const m of msgs) {
-				const t = m[0];
-				if (t === DIRTY) a.down([[DIRTY]]);
-				else if (t === DATA) {
-					attempt = 0;
-					prevDelay = null;
-					a.emit(m[1] as T);
-					publish("running");
-				} else if (t === RESOLVED) a.down([[RESOLVED]]);
-				else if (t === COMPLETE) {
-					// DF2 (2026-04-29): set `stopped = true` BEFORE
-					// `disconnectUpstream()` so a re-entrant ERROR delivered
-					// in the same wave (after disconnect runs but before the
-					// teardown closure fires `stopped = true`) hits the
-					// `if (stopped) return` guard at line 159 and cannot
-					// schedule a new retry timer.
-					stopped = true;
-					disconnectUpstream();
-					publish("completed");
-					a.down([[COMPLETE]]);
-				} else if (t === ERROR) {
-					scheduleRetryOrFinish(msgVal(m));
-					return;
-				} else a.down([m]);
-			}
-		});
-	}
-
-	connect();
-
-	return () => {
-		const wasStopped = stopped;
-		stopped = true;
-		timer.cancel();
-		disconnectUpstream();
-		if (!wasStopped) publish("cancelled");
-	};
-}
-
-/**
- * Retry operator — two modes selected by the type of `input`:
- *
- * **Source mode** (`input: Node<T>`): resubscribes to the same node after each terminal
- * `ERROR`. The upstream should use `resubscribable: true` if it must emit again after `ERROR`.
- *
- * **Factory mode** (`input: () => Node<T>`): invokes the factory to build a fresh `Node<T>`
- * on every connect / reconnect. Ideal for producers that capture per-attempt resources
- * (sockets, clients, file handles) that become unusable after an error. Synchronous
- * exceptions thrown by the factory are treated as terminal ERROR and run through the
- * same retry pipeline as inner-node ERROR.
- *
- * @param input - Upstream node or factory that returns a fresh node per attempt.
- * @param opts - `count` caps attempts (**required when `backoff` is set**; pass `Infinity` to opt in to unbounded); `backoff` supplies delay in **nanoseconds** (or a preset name); `initial` seeds the outer node cache (factory mode only).
- * @returns Node that retries on error.
- *
- * @throws {RangeError} when `backoff` is provided without an explicit `count` (unbounded-retry footgun guard) or when `count < 0`.
- *
- * @remarks
- * **Protocol:** Forwards unknown message tuples unchanged; handles `DIRTY`, `DATA`, `RESOLVED`, `COMPLETE`, `ERROR`.
- *
- * **Backoff floor:** every scheduled delay is floored at 1ms via `Math.max(1, delayNs / NS_PER_MS)` even when the strategy returns 0ns. This avoids 0-delay re-entrancy on the active stack frame on a tight ERROR loop. Strategies that return `null`/`undefined` stop retrying immediately and forward the original error.
- *
- * @example
- * ```ts
- * // Source mode — resubscribe the same node:
- * import { ERROR, NS_PER_SEC, producer, retry, constant } from "@graphrefly/graphrefly";
- *
- * const src = producer(
- *   (a) => { a.down([[ERROR, new Error("x")]]); },
- *   { resubscribable: true },
- * );
- * const out = retry(src, { count: 2, backoff: constant(0.25 * NS_PER_SEC) });
- *
- * // Factory mode — fresh node per attempt (e.g. reconnecting WebSocket):
- * import { NS_PER_SEC, exponential, retry, fromWebSocket } from "@graphrefly/graphrefly";
- *
- * const connected$ = retry(
- *   () => fromWebSocket(new WebSocket("wss://example/stream")),
- *   { count: 10, backoff: exponential({ baseNs: 1 * NS_PER_SEC }) },
- * );
- * ```
- *
- * @category extra
- */
-export function retry<T>(input: Node<T>, opts?: NodeOrValue<RetryOptions>): RetryBundle<T>;
-export function retry<T>(
-	input: () => Node<T>,
-	opts?: NodeOrValue<RetryFactoryOptions<T>>,
-): RetryBundle<T>;
-export function retry<T>(
-	input: Node<T> | (() => Node<T>),
-	opts?: NodeOrValue<RetryOptions | RetryFactoryOptions<T>>,
-): RetryBundle<T> {
-	const retryState = node<RetryState>([], {
-		name: "retryState",
-		describeKind: "state",
-		initial: { status: "pending", attempt: 0, lastDelay_ns: null },
-		equals: (a, b) =>
-			a === b ||
-			(a != null &&
-				b != null &&
-				typeof a === "object" &&
-				typeof b === "object" &&
-				JSON.stringify(a) === JSON.stringify(b)),
-	});
-	const emit = (s: RetryState): void => {
-		retryState.down([[DIRTY], [DATA, s]]);
-	};
-	if (typeof input === "function") {
-		return {
-			node: _retryFactory(input, opts as NodeOrValue<RetryFactoryOptions<T>> | undefined, emit),
-			retryState,
-		};
-	}
-	return {
-		node: _retrySource(input, opts as NodeOrValue<RetryOptions> | undefined, emit),
-		retryState,
-	};
-}
-
-// DS-13.5.B helper: like `resolveReactiveOption` but shallow-merges each
-// reactive emit over the prior opts and treats empty `{}` as a no-op
-// (per the locked cross-cutting rule). Static-form arg returns the value
-// as-is and never subscribes.
-function makeMergedOptsMirror<R extends Record<string, unknown>>(
-	arg: NodeOrValue<R> | undefined,
-): { current: () => R | undefined; unsub: () => void } {
-	if (arg === undefined) {
-		return { current: () => undefined, unsub: () => undefined };
-	}
-	if (!isNode(arg)) {
-		return { current: () => arg as R, unsub: () => undefined };
-	}
-	const optsNode = arg as Node<R>;
-	let merged: R | undefined = (optsNode.cache as R | undefined) ?? undefined;
-	const unsub = optsNode.subscribe((msgs) => {
-		for (const m of msgs) {
-			if (m[0] !== DATA) continue;
-			const next = m[1] as R | undefined;
-			if (next == null || typeof next !== "object") continue;
-			if (Object.keys(next).length === 0) continue; // empty {} no-op
-			merged = { ...(merged ?? ({} as R)), ...next } as R;
-		}
-	});
-	return { current: () => merged, unsub };
-}
-
-// DF6 (2026-04-29): once-per-source dedup for the source-mode-retry warn.
-// Mirrors the `_bumpCursorWarned` pattern in `extra/mutation/index.ts`.
-const _retrySourceNonResubscribableWarned = new WeakSet<Node<unknown>>();
-
-function _retrySource<T>(
-	source: Node<T>,
-	opts?: NodeOrValue<RetryOptions>,
-	emitState?: (s: RetryState) => void,
-): Node<T> {
-	// Source-mode retry re-subscribes to the SAME source node after each
-	// terminal ERROR. If the upstream was constructed with the default
-	// `resubscribable: false`, the second subscribe-after-terminal is a
-	// silent no-op and retries effectively never re-deliver. Surface
-	// once-per-source so misconfigurations fail loud without log spam.
-	const sourceWithFlag = source as unknown as { _resubscribable?: boolean };
-	if (
-		sourceWithFlag._resubscribable === false &&
-		!_retrySourceNonResubscribableWarned.has(source)
-	) {
-		_retrySourceNonResubscribableWarned.add(source);
-		console.warn(
-			"retry(source, opts): source-mode requires `resubscribable: true` on the upstream " +
-				"node. Retries will be silent no-ops after the first ERROR. Either pass " +
-				"`resubscribable: true` to the source factory, OR use factory-mode retry " +
-				"`retry(() => buildSource(), opts)` so each attempt builds a fresh node.",
-		);
-	}
-	const staticOpts = isNode(opts) ? undefined : (opts as RetryOptions | undefined);
-	// Eager validation for static-form opts (preserves construction-time
-	// "backoff without count" RangeError). Reactive-form opts re-validate
-	// per `getCfg()` call inside the state machine.
-	if (!isNode(opts)) resolveRetryConfig(staticOpts);
-	return node<T>(
-		(_data, a) => {
-			const merged = makeMergedOptsMirror<RetryOptions>(opts);
-			const getCfg = (): ResolvedRetryConfig => resolveRetryConfig(merged.current());
-			const inner = _runRetryStateMachine(getCfg, () => source, a, emitState);
-			return {
-				onDeactivation: () => {
-					inner();
-					merged.unsub();
-				},
-			};
-		},
-		{
-			...operatorOpts(),
-			initial: source.cache,
-			meta: {
-				...(staticOpts?.meta ?? {}),
-				...factoryTag(
-					"retry",
-					isNode(opts) ? { reactiveOpts: true } : retryFactoryArgs(staticOpts),
-				),
-			},
-		},
-	);
-}
-
-function _retryFactory<T>(
-	factory: () => Node<T>,
-	opts?: NodeOrValue<RetryFactoryOptions<T>>,
-	emitState?: (s: RetryState) => void,
-): Node<T> {
-	const staticOpts = isNode(opts) ? undefined : (opts as RetryFactoryOptions<T> | undefined);
-	// Eager validation for static-form opts (Tier 3.1 footgun preservation).
-	if (!isNode(opts)) resolveRetryConfig(staticOpts);
-	return node<T>(
-		(_data, a) => {
-			const merged = makeMergedOptsMirror<RetryFactoryOptions<T>>(opts);
-			const getCfg = (): ResolvedRetryConfig => resolveRetryConfig(merged.current());
-			const inner = _runRetryStateMachine(getCfg, factory, a, emitState);
-			return {
-				onDeactivation: () => {
-					inner();
-					merged.unsub();
-				},
-			};
-		},
-		{
-			...operatorOpts(),
-			initial: staticOpts?.initial as T | undefined,
-			meta: {
-				...(staticOpts?.meta ?? {}),
-				...factoryTag(
-					"retry",
-					isNode(opts) ? { reactiveOpts: true } : retryFactoryArgs(staticOpts),
-				),
-			},
-		},
-	);
-}
diff --git a/src/base/resilience/status.ts b/src/base/resilience/status.ts
deleted file mode 100644
index 4e8a270b..00000000
--- a/src/base/resilience/status.ts
+++ /dev/null
@@ -1,173 +0,0 @@
-/**
- * Status wrapper — surface lifecycle state alongside output.
- *
- * `withStatus` mirrors a source `Node<T>` and produces companion `status` /
- * `error` reactive nodes for UI and meta-snapshot consumers.
- */
-
-import {
-	batch,
-	COMPLETE,
-	DATA,
-	DIRTY,
-	ERROR,
-	factoryTag,
-	type Node,
-	node,
-	RESOLVED,
-} from "@graphrefly/pure-ts/core";
-import { msgVal, operatorOpts } from "./_internal.js";
-
-/**
- * Central lifecycle vocabulary for resilience primitives + `processManager`.
- *
- * **DS-13.5.B follow-on (2026-05-01).** Widened from
- * `"pending" | "running" | "completed" | "errored"` to add `"cancelled"`
- * (replaces `processManager`'s prior `"compensated"` semantics) and
- * `"paused"` (carried by `<Primitive>State` lifecycle-shaped companions
- * on `retry` / `circuitBreaker` / `rateLimiter`).
- *
- * Resilience primitives use this enum as the literal vocabulary inside
- * lifecycle-shaped state nodes; `withStatus` (legacy) only emits the
- * original four (pre-widening) — the cancelled / paused values are added
- * for downstream consumers that need richer lifecycle reporting.
- */
-export type StatusValue = "pending" | "running" | "completed" | "errored" | "cancelled" | "paused";
-
-export type WithStatusBundle<T> = {
-	node: Node<T>;
-	status: Node<StatusValue>;
-	error: Node<unknown | null>;
-};
-
-/**
- * Wraps `src` with `status` and `error` {@link state} companions for UI or meta snapshots.
- *
- * @param src - Upstream node to mirror.
- * @param options - `initialStatus` defaults to `"pending"`.
- * @returns `{ node, status, error }` where `out` is the mirrored stream, `status` is a
- *   reactive `Node<StatusValue>` (`"pending" | "running" | "completed" | "errored"`),
- *   and `error` holds the last `ERROR` payload (cleared to `null` on the next `DATA`
- *   after `errored`).
- *
- * @remarks
- * **Lifecycle:** `pending` (no DATA yet) → `running` (on first DATA) → `completed`
- * (on COMPLETE) or `errored` (on ERROR). After `errored`, the next `DATA` clears
- * `error` and re-enters `running` inside a {@link batch} so subscribers see one
- * consistent transition (matches graphrefly-py).
- *
- * **Producer-pattern visibility:** `out` is built via `node([], fn, …)`, so `src`
- * appears as the source dependency in `describe()` traversal but the `status` /
- * `error` companions are mirrored via subscribe-callback effects — they appear
- * under `out.meta.status` / `out.meta.error` (and as `<name>::__meta__::status`
- * paths in `describe()`) rather than as separate top-level edges. Subscribers
- * to `out` see the throttled DATA stream; `status` / `error` companions may not
- * appear as edges in `describe()` if no consumer subscribes to them (per
- * COMPOSITION-GUIDE §1, push-on-subscribe semantics).
- *
- * **Per-subscribe lifecycle (DF8, 2026-04-29 doc lock).** When the wrapped
- * source is `resubscribable: true` and multiple consumers attach in
- * sequence, each new subscription cycle re-runs the producer fn AND
- * re-emits the initial `pending` + `null` companion DATAs. Downstream
- * subscribers to the `status` / `error` companions see thrash:
- * `pending → running → completed → pending → running …`. This is the
- * intended fresh-cycle semantic (each subscription cycle reports its own
- * lifecycle); consumers that need a "stable" status across cycles should
- * derive a snapshot via a separate `state()` mirror rather than depending
- * on the per-cycle reset.
- *
- * @example
- * ```ts
- * import { withStatus, state } from "@graphrefly/graphrefly";
- *
- * const src = state<number>(0);
- * const { node, status, error } = withStatus(src);
- *
- * status.subscribe((msgs) => console.log("status:", msgs));
- * src.down([[DATA, 42]]); // status → "running"
- * ```
- *
- * @category extra
- */
-export function withStatus<T>(
-	src: Node<T>,
-	options?: { initialStatus?: StatusValue; meta?: Record<string, unknown> },
-): WithStatusBundle<T> {
-	const initialStatus = options?.initialStatus ?? "pending";
-	const callerMeta = options?.meta;
-
-	const out = node<T>(
-		[],
-		(_deps, a) => {
-			let currentStatus: StatusValue = initialStatus;
-			out.meta.status.down([[DATA, initialStatus]]);
-			out.meta.error.down([[DATA, null]]);
-
-			const unsub = src.subscribe((msgs) => {
-				for (const m of msgs) {
-					const t = m[0];
-					if (t === DIRTY) a.down([[DIRTY]]);
-					else if (t === DATA) {
-						if (currentStatus === "errored") {
-							batch(() => {
-								out.meta.error.down([[DATA, null]]);
-								out.meta.status.down([[DATA, "running"]]);
-								a.emit(m[1] as T);
-							});
-							currentStatus = "running";
-						} else if (currentStatus !== "running") {
-							// First DATA after `pending` (or another non-running state):
-							// flip status to "running" alongside the DATA emit so external
-							// observers see one coherent wave (no torn reads between the
-							// status companion and the mirrored stream).
-							batch(() => {
-								out.meta.status.down([[DATA, "running"]]);
-								a.emit(m[1] as T);
-							});
-							currentStatus = "running";
-						} else {
-							// A9 (QA fix 2026-05-01): already in "running" — skip the
-							// redundant status emit that the previous code did on every
-							// DATA. Saves a wave walk per DATA on hot streams (e.g. SSE
-							// token streams through withStatus).
-							a.emit(m[1] as T);
-						}
-					} else if (t === RESOLVED) a.down([[RESOLVED]]);
-					else if (t === COMPLETE) {
-						out.meta.status.down([[DATA, "completed"]]);
-						currentStatus = "completed";
-						a.down([[COMPLETE]]);
-					} else if (t === ERROR) {
-						const err = msgVal(m);
-						batch(() => {
-							out.meta.error.down([[DATA, err]]);
-							out.meta.status.down([[DATA, "errored"]]);
-						});
-						currentStatus = "errored";
-						a.down([m]);
-					} else a.down([m]);
-				}
-			});
-
-			return { onDeactivation: unsub };
-		},
-		{
-			...operatorOpts(),
-			meta: {
-				...(callerMeta ?? {}),
-				status: initialStatus,
-				error: null,
-				...factoryTag("withStatus", { initialStatus }),
-			},
-			completeWhenDepsComplete: false,
-			resubscribable: true,
-			initial: src.cache,
-		},
-	);
-
-	return {
-		node: out,
-		status: out.meta.status as Node<StatusValue>,
-		error: out.meta.error as Node<unknown | null>,
-	};
-}
diff --git a/src/base/resilience/timeout.ts b/src/base/resilience/timeout.ts
deleted file mode 100644
index 093c830a..00000000
--- a/src/base/resilience/timeout.ts
+++ /dev/null
@@ -1,383 +0,0 @@
-/**
- * Timeout — emits `ERROR` with `TimeoutError` if no `DATA` arrives within the deadline.
- *
- * §3.1c — caching, fallback & composition sugar. Uses
- * `core/clock.js`-style nanoseconds and a `ResettableTimer` so the deadline
- * resets on each DATA. Distinct from the `operators/control.ts` timeout
- * (which forwards a caller-supplied error/value) — this one is the
- * resilience family's "deadline → ERROR" primitive.
- *
- * **DS-13.5.B (locked 2026-05-01).** Pre-1.0 break: returns
- * {@link TimeoutBundle} with `node` + `timeoutState` companion. Opts
- * accept `Partial<TimeoutOptions>` or `Node<Partial<TimeoutOptions>>`
- * (object-shape, replacing the old `NodeOrValue<number>` flat shape).
- * State preservation across rebind: `ns` change does NOT reset the
- * in-flight deadline — new `ns` applies to next attempt only.
- */
-
-import {
-	COMPLETE,
-	DATA,
-	DIRTY,
-	ERROR,
-	factoryTag,
-	monotonicNs,
-	type Node,
-	node,
-	RESOLVED,
-	ResettableTimer,
-	TEARDOWN,
-} from "@graphrefly/pure-ts/core";
-import { isNode, operatorOpts } from "./_internal.js";
-import { NS_PER_MS } from "./backoff.js";
-
-/**
- * Thrown by {@link withTimeout} when no `DATA` arrives within the deadline.
- *
- * @category extra
- */
-export class TimeoutError extends Error {
-	override name = "TimeoutError";
-	constructor(ns: number) {
-		super(`Timed out after ${ns / NS_PER_MS}ms`);
-	}
-}
-
-/**
- * Options accepted by {@link withTimeout}.
- *
- * - `ns` — deadline in nanoseconds (must be `> 0`). Required at the
- *   first opts settle; missing / non-positive values throw at
- *   construction.
- * - `meta` — optional metadata merged onto the result node's `meta`
- *   for describe()/explain() introspection. Reactive `meta` updates
- *   are picked up on the next attempt's emission.
- *
- * @category extra/resilience
- */
-export interface TimeoutOptions {
-	ns: number;
-	meta?: Record<string, unknown>;
-}
-
-/**
- * Lifecycle-shaped state companion emitted by {@link withTimeout}.
- *
- * Default `equals` dedups on the `status` field — subscribers don't
- * re-fire on identical-shape transitions, but DO fire on every state
- * transition AND on payload changes within the same status (e.g. when
- * `running.startedAt_ns` advances on a fresh attempt).
- *
- * @category extra/resilience
- */
-export type TimeoutState =
-	| { status: "pending" }
-	| { status: "running"; startedAt_ns: number; deadline_ns: number }
-	| { status: "completed"; settledAt_ns: number }
-	| { status: "errored"; firedAt_ns: number; deadline_ns: number };
-
-/**
- * Bundle returned by {@link withTimeout}: the timeout-wrapped output node and
- * its lifecycle-shaped state companion.
- *
- * **Single-subscriber / pipeline-only contract (DS-13.5.B QA, N1, 2026-05-03).**
- * The `timeoutState` companion is allocated once at factory time and shared
- * across all subscribers to `node`. With one subscriber (the typical use
- * case — wire `node` into your downstream chain, optionally observe
- * `timeoutState` separately) the companion reflects a coherent timeline.
- * With **two or more subscribers** to `node`, each subscriber re-runs the
- * producer body and writes into the same `timeoutState`, which can flip
- * between states from different in-flight machines. Don't fan out
- * `node` to multiple subscribers and rely on `timeoutState` accuracy
- * unless you use {@link keepalive} / {@link share}-style consolidation.
- *
- * @category extra/resilience
- */
-export interface TimeoutBundle<T> {
-	node: Node<T>;
-	timeoutState: Node<TimeoutState>;
-}
-
-interface TimeoutExtraOpts {
-	meta?: Record<string, unknown>;
-}
-
-/**
- * Wrap `source` with a deadline. If no `DATA` arrives within `opts.ns`
- * nanoseconds, the result node emits `[[ERROR, TimeoutError]]` and
- * transitions `timeoutState` to `"errored"`.
- *
- * The timer starts on subscription and resets on each `DATA`. `DIRTY`
- * does NOT reset the timer. Terminal messages (`COMPLETE` / `ERROR`)
- * cancel the timer.
- *
- * **Reactive opts (DS-13.5.B, locked 2026-05-01).**
- *
- * - Static-form callers pass `Partial<TimeoutOptions>` (today's path).
- *   `ns` is validated at construction; missing / non-positive throws
- *   `RangeError`.
- * - Reactive-form callers pass `Node<Partial<TimeoutOptions>>` — each
- *   emission shallow-merges over the prior opts. Empty `{}` emissions
- *   are no-ops (no rebind, no companion fire). Mid-flight opts swap
- *   does NOT reset the in-flight deadline; new `ns` applies to the
- *   next `startTimer()` call.
- * - When the opts Node has `cache === undefined` (SENTINEL: no opts
- *   emitted yet), the source is paused until the first valid opts
- *   settle. The first valid settle must carry `ns > 0` or the timer
- *   layer emits an ERROR (downstream observable) — distinct from the
- *   construction-time `RangeError` thrown for static / cache-defined
- *   invalid values.
- *
- * @param source - Upstream node.
- * @param opts - `Partial<TimeoutOptions>` (static) or
- *   `Node<Partial<TimeoutOptions>>` (reactive).
- * @param extraOpts - Forwarded factory metadata (meta field merged
- *   onto the result node).
- * @returns {@link TimeoutBundle} with `node` and `timeoutState`.
- *
- * @throws {RangeError} when the first opts settle is missing or has
- *   non-positive `ns`.
- *
- * @category extra
- */
-export function withTimeout<T>(
-	source: Node<T>,
-	opts: Partial<TimeoutOptions> | Node<Partial<TimeoutOptions>>,
-	extraOpts?: TimeoutExtraOpts,
-): TimeoutBundle<T> {
-	const isReactive = isNode(opts);
-
-	// Construction-time validation:
-	// - Static form: validate the supplied object eagerly.
-	// - Node form with defined cache: validate the cache value eagerly.
-	// - Node form with `cache === undefined`: defer validation to first
-	//   DATA emission; source is paused in the meantime.
-	let latestOpts: TimeoutOptions | null = null;
-	if (!isReactive) {
-		const staticOpts = opts as Partial<TimeoutOptions>;
-		if (
-			staticOpts.ns === undefined ||
-			typeof staticOpts.ns !== "number" ||
-			!Number.isFinite(staticOpts.ns) ||
-			staticOpts.ns <= 0
-		) {
-			throw new RangeError("withTimeout: opts.ns must be a positive finite number");
-		}
-		latestOpts = {
-			ns: staticOpts.ns,
-			...(staticOpts.meta != null ? { meta: staticOpts.meta } : {}),
-		};
-	} else {
-		const cached = (opts as Node<Partial<TimeoutOptions>>).cache as
-			| Partial<TimeoutOptions>
-			| undefined;
-		if (cached !== undefined) {
-			if (
-				cached.ns === undefined ||
-				typeof cached.ns !== "number" ||
-				!Number.isFinite(cached.ns) ||
-				cached.ns <= 0
-			) {
-				throw new RangeError(
-					"withTimeout: opts.ns must be a positive finite number on first settle",
-				);
-			}
-			latestOpts = {
-				ns: cached.ns,
-				...(cached.meta != null ? { meta: cached.meta } : {}),
-			};
-		}
-	}
-
-	const callerMeta = extraOpts?.meta;
-	const factoryArgs: Record<string, unknown> = isReactive
-		? { ns: "Node<Partial<TimeoutOptions>>" }
-		: { ns: latestOpts!.ns };
-
-	// Companion state node — lifecycle-shaped. Default Object.is-on-status
-	// dedup so identical-shape transitions don't re-fire downstream.
-	const timeoutState = node<TimeoutState>([], {
-		name: "timeoutState",
-		describeKind: "state",
-		initial: { status: "pending" },
-		equals: (a, b) =>
-			a === b ||
-			(a != null &&
-				b != null &&
-				typeof a === "object" &&
-				typeof b === "object" &&
-				(a as { status: string }).status === (b as { status: string }).status &&
-				JSON.stringify(a) === JSON.stringify(b)),
-	});
-
-	const out = node<T>(
-		(_data, a) => {
-			let stopped = false;
-			let lastDeadlineNs = 0;
-			const timer = new ResettableTimer();
-			let optsUnsub: (() => void) | null = null;
-			let srcUnsub: (() => void) | null = null;
-
-			function emitState(next: TimeoutState): void {
-				timeoutState.down([[DIRTY], [DATA, next]]);
-			}
-
-			function startTimer(): void {
-				if (stopped) return;
-				// QA A4 (2026-05-03): defensive guard — `latestOpts.ns`
-				// reaching `undefined` / `NaN` / non-finite is a Class-of-
-				// bugs source: an explicit `{ ns: undefined }` emit would
-				// pass the per-key validation (which only checks
-				// `next.ns !== undefined`) and shallow-merge over a valid
-				// prior `ns`. Without this guard, `delayMs = NaN`, which
-				// `setTimeout` treats as `0` → spurious immediate timeout.
-				if (
-					latestOpts == null ||
-					typeof latestOpts.ns !== "number" ||
-					!Number.isFinite(latestOpts.ns) ||
-					latestOpts.ns <= 0
-				) {
-					return;
-				}
-				const ns = latestOpts.ns;
-				lastDeadlineNs = ns;
-				const startedAt = monotonicNs();
-				const delayMs = ns / NS_PER_MS;
-				emitState({
-					status: "running",
-					startedAt_ns: startedAt,
-					deadline_ns: ns,
-				});
-				timer.start(delayMs, () => {
-					if (stopped) return;
-					stopped = true;
-					srcUnsub?.();
-					emitState({
-						status: "errored",
-						firedAt_ns: monotonicNs(),
-						deadline_ns: ns,
-					});
-					a.down([[ERROR, new TimeoutError(ns)]]);
-				});
-			}
-
-			function attachSource(): void {
-				if (srcUnsub != null || stopped) return;
-				srcUnsub = source.subscribe((msgs) => {
-					for (const m of msgs) {
-						if (stopped) return;
-						const t = m[0];
-						if (t === DIRTY) a.down([[DIRTY]]);
-						else if (t === DATA) {
-							startTimer();
-							a.emit(m[1] as T);
-						} else if (t === RESOLVED) a.down([[RESOLVED]]);
-						else if (t === COMPLETE) {
-							timer.cancel();
-							stopped = true;
-							emitState({
-								status: "completed",
-								settledAt_ns: monotonicNs(),
-							});
-							a.down([[COMPLETE]]);
-							return;
-						} else if (t === ERROR) {
-							timer.cancel();
-							stopped = true;
-							emitState({
-								status: "errored",
-								firedAt_ns: monotonicNs(),
-								deadline_ns: lastDeadlineNs,
-							});
-							a.down([m]);
-							return;
-						} else if (t === TEARDOWN) {
-							timer.cancel();
-							stopped = true;
-							a.down([m]);
-							return;
-						} else a.down([m]);
-					}
-				});
-				// Kick the initial timer if we already have valid opts.
-				if (latestOpts != null && latestOpts.ns > 0) {
-					startTimer();
-				}
-			}
-
-			if (isReactive) {
-				const optsNode = opts as Node<Partial<TimeoutOptions>>;
-				optsUnsub = optsNode.subscribe((msgs) => {
-					for (const m of msgs) {
-						if (m[0] !== DATA) continue;
-						const next = m[1] as Partial<TimeoutOptions>;
-						if (next == null || typeof next !== "object") continue;
-						// Empty `{}` emit is a no-op (lock spec).
-						const keys = Object.keys(next);
-						if (keys.length === 0) continue;
-						// QA A4 (2026-05-03): validate ns whenever it APPEARS
-						// in the emit's keys — including `{ ns: undefined }`,
-						// which would otherwise skip validation and shallow-
-						// merge over a valid prior `ns` with `undefined`,
-						// producing `delayMs = NaN` ≈ 0 ms in startTimer().
-						// `'ns' in next` covers both "explicitly undefined"
-						// and "explicitly invalid" forms.
-						if ("ns" in next) {
-							if (typeof next.ns !== "number" || !Number.isFinite(next.ns) || next.ns <= 0) {
-								if (latestOpts == null) {
-									// First settle invalid — emit ERROR rather
-									// than throw (mid-subscribe; sync throw
-									// would corrupt the host scheduler).
-									stopped = true;
-									a.down([
-										[
-											ERROR,
-											new RangeError(
-												"withTimeout: opts.ns must be a positive finite number on first settle",
-											),
-										],
-									]);
-									return;
-								}
-								// Ignore invalid mid-flight ns updates; keep
-								// prior latestOpts.
-								continue;
-							}
-						}
-						const wasNull = latestOpts == null;
-						latestOpts = {
-							...(latestOpts ?? { ns: 0 }),
-							...next,
-						} as TimeoutOptions;
-						// First valid settle activates the source attach.
-						if (wasNull && latestOpts.ns > 0) {
-							attachSource();
-						}
-					}
-				});
-			}
-
-			// Static form: attach immediately. Reactive form with defined
-			// cache also attaches immediately (latestOpts pre-populated).
-			if (latestOpts != null) {
-				attachSource();
-			}
-
-			return {
-				onDeactivation: () => {
-					stopped = true;
-					timer.cancel();
-					if (srcUnsub) srcUnsub();
-					if (optsUnsub) optsUnsub();
-				},
-			};
-		},
-		{
-			...operatorOpts(),
-			initial: source.cache,
-			meta: { ...(callerMeta ?? {}), ...factoryTag("withTimeout", factoryArgs) },
-		},
-	);
-
-	return { node: out, timeoutState };
-}
diff --git a/src/base/sources/async.ts b/src/base/sources/async.ts
deleted file mode 100644
index 4868705d..00000000
--- a/src/base/sources/async.ts
+++ /dev/null
@@ -1,352 +0,0 @@
-/**
- * Async sources, sinks, and multicast — presentation layer.
- *
- * `fromPromise`, `fromAsyncIter`, `fromAny` are substrate primitives; they are
- * re-exported here from `@graphrefly/pure-ts` for ergonomic single-import use.
- * This file owns the presentation-only async utilities: `defer`, `forEach`,
- * `toArray`, `share`, `replay`, `cached`, `shareReplay`.
- *
- * `singleFromAny` and `singleNodeFromAny` (keyed singleflight) live in
- * `base/composition/single-from-any.ts`.
- */
-
-import {
-	COMPLETE,
-	DATA,
-	ERROR,
-	type Node,
-	type NodeOptions,
-	node,
-	RESOLVED,
-	START,
-} from "@graphrefly/pure-ts/core";
-import { type AsyncSourceOpts, type NodeInput, sourceOpts } from "@graphrefly/pure-ts/extra";
-
-/** Options for presentation-layer async operators: NodeOptions without `describeKind`. */
-type ExtraOpts = Omit<NodeOptions, "describeKind">;
-
-// Import fromAny from substrate — used internally by defer. The three async
-// substrate sources (fromAny, fromAsyncIter, fromPromise) are already
-// re-exported from @graphrefly/pure-ts; do NOT re-export here to avoid
-// duplicate-export conflicts at the root barrel level.
-import { fromAny } from "@graphrefly/pure-ts/extra";
-
-/**
- * Lazily constructs a {@link Node} from a thunk that runs at **activation
- * time** (first subscriber after a teardown to zero sinks), not factory time.
- *
- * **Resubscribable by default.** Diverges from `fromPromise` / `fromIter` /
- * `fromAsyncIter` (which are single-shot — second subscriber sees the cached
- * terminal value). `defer`'s contract matches RxJS `defer`: every fresh
- * activation cycle re-runs the thunk. To opt out and get one-shot semantics,
- * pass `{ resubscribable: false }`.
- *
- * **Sharing across overlapping subscribers.** The thunk only re-runs on a
- * fresh activation cycle (zero → one sink). Overlapping subscribers share
- * the single activation; the thunk does NOT re-run for each subscriber. If
- * the thunk returns an existing `Node`, that Node is shared across activations
- * — `defer` will subscribe to it on each activation but does not isolate state
- * across subscribers. For per-subscriber isolation, the thunk must construct
- * a fresh source (`state(...)`, `fromPromise(fetch(...))`, etc.) on each call.
- *
- * **Use cases:**
- * - Lazy upstream construction (avoid eager evaluation of expensive factories
- *   at module load — the thunk runs only when something subscribes).
- * - Per-activation resource construction (open a connection / file handle on
- *   subscribe, when paired with full teardown between sessions).
- * - Bridging non-Node inputs (Promise, AsyncIterable, Iterable, scalar) into
- *   the graph behind a lazy boundary.
- *
- * The thunk's return value is bridged via {@link fromAny}. Errors thrown by
- * the thunk surface as a single `[[ERROR, err]]` on the output (with `err`
- * coerced to a non-`undefined` value to satisfy spec §1.3 — bare `throw` and
- * `throw undefined` are wrapped in a `defer: thunk threw undefined` Error).
- *
- * Upstream messages are forwarded transparently (DIRTY / DATA / RESOLVED /
- * COMPLETE / ERROR / INVALIDATE / PAUSE / RESUME / TEARDOWN), preserving
- * batch boundaries. The producer's own `START` handshake is delivered to
- * subscribers automatically; the upstream's `START` is filtered.
- *
- * @param thunk - Called on each activation; returns the upstream input.
- * @param opts - Forwarded to `fromAny` (e.g. `signal` for async inputs).
- *   `signal` is only consumed by `fromAny` for async input shapes (Promise,
- *   AsyncIterable); it does NOT abort a Node-input or scalar-input defer.
- * @returns `Node<T>` — lazy upstream-on-activation.
- *
- * @example
- * ```ts
- * import { defer } from "@graphrefly/graphrefly";
- *
- * // Lazy fetch — runs on the first activation, NOT at factory time.
- * // Each fresh activation cycle (after teardown) re-runs the thunk →
- * // a new fetch. Overlapping subscribers share the single activation.
- * const live = defer(() => fetch("/api/feed").then((r) => r.json()));
- * ```
- *
- * @category extra
- */
-export function defer<T>(thunk: () => NodeInput<T>, opts?: AsyncSourceOpts): Node<T> {
-	// A4: strip `signal` before forwarding to NodeOptions — sibling sources
-	// (fromTimer / fromPromise / fromAsyncIter) destructure first; signal
-	// continues to flow into fromAny(input, opts) for async input shapes.
-	const { signal: _sig, ...nodeOpts } = (opts ?? {}) as AsyncSourceOpts;
-	const sOpts = sourceOpts<T>(nodeOpts);
-	const merged = sOpts.resubscribable === undefined ? { ...sOpts, resubscribable: true } : sOpts;
-	return node<T>((_data, a) => {
-		let unsub: (() => void) | undefined;
-		let stopped = false;
-		try {
-			const input = thunk();
-			// `iter: true` preserves defer's RxJS-aligned per-element
-			// streaming for sync iterable thunk returns (post DS-13.5
-			// fromAny default flip; defer's documented contract is
-			// "forwards iterable values" per-element).
-			const src = fromAny(input, { ...opts, iter: true });
-			unsub = src.subscribe((msgs) => {
-				if (stopped) return;
-				for (const m of msgs) {
-					const t = m[0];
-					if (t === START) continue; // producer's own START is delivered separately
-					if (t === DATA) {
-						a.emit(m[1] as T);
-					} else if (t === COMPLETE) {
-						stopped = true;
-						a.down([[COMPLETE]]);
-						break; // A2: don't forward post-terminal messages in the same batch
-					} else if (t === ERROR) {
-						stopped = true;
-						a.down([[ERROR, m[1]]]);
-						break; // A2
-					} else {
-						// Forward DIRTY / RESOLVED / INVALIDATE / PAUSE / RESUME /
-						// TEARDOWN, plus any unknown types (spec §1.3.6 forward-compat).
-						a.down([m]);
-					}
-				}
-			});
-		} catch (err) {
-			// A5: spec §1.3 — ERROR payload must not be undefined. Wrap a
-			// `throw` or `throw undefined` so dispatch doesn't reject the emit.
-			const safe = err === undefined ? new Error("defer: thunk threw undefined") : err;
-			a.down([[ERROR, safe]]);
-		}
-		return {
-			onDeactivation: () => {
-				stopped = true;
-				unsub?.();
-			},
-		};
-	}, merged);
-}
-
-/**
- * Subscribes immediately and runs `fn` for each upstream `DATA`; returns unsubscribe.
- *
- * @param source - Upstream node.
- * @param fn - Side effect per value.
- * @param opts - Effect node options.
- * @returns Unsubscribe function (idempotent).
- *
- * @example
- * ```ts
- * import { forEach, state } from "@graphrefly/graphrefly";
- *
- * const u = forEach(state(1), (v) => console.log(v));
- * u();
- * ```
- *
- * @category extra
- */
-export function forEach<T>(source: Node<T>, fn: (value: T) => void, opts?: ExtraOpts): () => void {
-	const inner = node(
-		[source as Node],
-		(data, _actions) => {
-			const batch0 = data[0];
-			if (batch0 != null && batch0.length > 0) {
-				for (const v of batch0) fn(v as T);
-			}
-		},
-		{ describeKind: "effect", ...opts } as NodeOptions,
-	);
-	return inner.subscribe(() => {});
-}
-
-/**
- * Buffers every `DATA`; on upstream `COMPLETE` emits one `DATA` with the full array then `COMPLETE`.
- *
- * @param source - Upstream node.
- * @param opts - Optional node options (derived describe kind).
- * @returns `Node<T[]>` — single array emission before completion.
- *
- * @example
- * ```ts
- * import { of, toArray } from "@graphrefly/graphrefly";
- *
- * toArray(of(1, 2, 3));
- * ```
- *
- * @category extra
- */
-export function toArray<T>(source: Node<T>, opts?: ExtraOpts): Node<T[]> {
-	// Lock 6.D (Phase 13.6.B): clear the accumulator buffer on
-	// deactivation so a resubscribable toArray restarts with an empty
-	// array on the next cycle — pre-flip this came for free via
-	// `_deactivate`'s store wipe.
-	let cleanup: { onDeactivation: () => void } | undefined;
-	return node<T[]>(
-		[source as Node],
-		(data, actions, ctx) => {
-			if (cleanup === undefined) {
-				const store = ctx.store;
-				cleanup = {
-					onDeactivation: () => {
-						delete store.buf;
-					},
-				};
-			}
-			if (!ctx.store.buf) ctx.store.buf = [];
-			const buf = ctx.store.buf as T[];
-			// Accumulate DATA first — must happen before the COMPLETE check so
-			// that a same-wave DATA+COMPLETE batch (e.g. fromTimer one-shot,
-			// fromIter last item) is included in the emitted array.
-			const batch0 = data[0];
-			if (batch0 != null && batch0.length > 0) {
-				for (const v of batch0) buf.push(v as T);
-			}
-			// COMPLETE: emit accumulated array then complete.
-			// ERROR: autoError propagates; do NOT emit the partial buffer.
-			if (ctx.terminalDeps[0] === true) {
-				actions.emit([...buf]);
-				actions.down([[COMPLETE]]);
-				return cleanup;
-			}
-			// RESOLVED wave: propagate RESOLVED. Covers first-wave case; after first
-			// call the pre-fn skip handles this automatically.
-			if (batch0 == null || batch0.length === 0) {
-				actions.down([[RESOLVED]]);
-			}
-			return cleanup;
-		},
-		{
-			describeKind: "derived",
-			...opts,
-			// Operator-required flags spread AFTER user `opts` so a caller
-			// cannot accidentally override them (QA F2 spread-order fix,
-			// DS-2.7.A `/qa` 2026-05-20 — matches the
-			// `reduce`/`scan`/`take`/`last` substrate pattern). Spec §2.7
-			// R2.7.1 (DS-2.7.A): Reduce-class shape — fn must fire on
-			// upstream COMPLETE to emit the accumulated array (or `[]` for an
-			// empty source) followed by its own `[[COMPLETE]]`. Required
-			// because `completeWhenDepsComplete: false` means auto-COMPLETE
-			// is OFF; without the opt-in `toArray(empty())` never completes.
-			completeWhenDepsComplete: false,
-			terminalAsRealInput: true,
-		} as NodeOptions<T[]>,
-	);
-}
-
-/**
- * Multicasts upstream: one subscription to `source` while this wrapper has subscribers (via {@link producer}).
- *
- * @param source - Upstream node to share.
- * @param opts - Producer options; `initial` seeds from `source.cache` when set by factory.
- * @returns `Node<T>` — hot ref-counted bridge.
- *
- * @example
- * ```ts
- * import { share, state } from "@graphrefly/graphrefly";
- *
- * share(state(0));
- * ```
- *
- * @category extra
- */
-export function share<T>(source: Node<T>, opts?: ExtraOpts): Node<T> {
-	return node<T>(
-		(_data, a) => ({
-			onDeactivation: source.subscribe((msgs) => {
-				a.down(msgs);
-			}),
-		}),
-		{ ...sourceOpts<T>(opts), initial: source.cache },
-	);
-}
-
-/**
- * Like {@link share} with a bounded replay buffer: new subscribers receive the last `bufferSize`
- * `DATA` payloads (as separate batches) before live updates.
- *
- * @param source - Upstream node.
- * @param bufferSize - Maximum past values to replay (≥ 1).
- * @param opts - Producer options.
- * @returns `Node<T>` — multicast with replay on subscribe.
- *
- * @example
- * ```ts
- * import { replay, state } from "@graphrefly/graphrefly";
- *
- * replay(state(0), 3);
- * ```
- *
- * @category extra
- */
-export function replay<T>(source: Node<T>, bufferSize: number, opts?: ExtraOpts): Node<T> {
-	if (bufferSize < 1) throw new RangeError("replay expects bufferSize >= 1");
-	// Spec §2.5 / Lock 6.G: the built-in `replayBuffer` NodeOption retains the
-	// last-N outgoing DATA and `defaultOnSubscribe` delivers them to a late
-	// subscriber INSTEAD of the cache-DATA push — so there is no double-deliver
-	// of the most-recent value. Supersedes the old `wrapSubscribeHook` +
-	// manual-buffer pattern (which flushed the buffer AND then push-on-
-	// subscribed the cache, double-delivering the last value).
-	return node<T>(
-		(_data, a) => ({
-			onDeactivation: source.subscribe((msgs) => {
-				a.down(msgs);
-			}),
-		}),
-		{ ...sourceOpts<T>(opts), initial: source.cache, replayBuffer: bufferSize },
-	);
-}
-
-/**
- * {@link replay} with `bufferSize === 1` — replays the latest `DATA` to new subscribers.
- *
- * @param source - Upstream node.
- * @param opts - Producer options.
- * @returns `Node<T>` — share + last-value replay.
- *
- * @example
- * ```ts
- * import { cached, state } from "@graphrefly/graphrefly";
- *
- * cached(state(0));
- * ```
- *
- * @category extra
- */
-export function cached<T>(source: Node<T>, opts?: ExtraOpts): Node<T> {
-	return replay(source, 1, opts);
-}
-
-// ——————————————————————————————————————————————————————————————
-//  RxJS-compatible aliases
-// ——————————————————————————————————————————————————————————————
-
-/**
- * RxJS-named alias for {@link replay} — multicast with a replay buffer of size `bufferSize`.
- *
- * @param source - Upstream node.
- * @param bufferSize - Replay depth (≥ 1).
- * @param opts - Producer options.
- * @returns Same behavior as `replay`.
- *
- * @example
- * ```ts
- * import { shareReplay, state } from "@graphrefly/graphrefly";
- *
- * shareReplay(state(0), 5);
- * ```
- *
- * @category extra
- */
-export const shareReplay = replay;
diff --git a/src/base/sources/browser/idb.ts b/src/base/sources/browser/idb.ts
deleted file mode 100644
index 0efd7d8f..00000000
--- a/src/base/sources/browser/idb.ts
+++ /dev/null
@@ -1,101 +0,0 @@
-/**
- * Browser-only IndexedDB reactive sources.
- *
- * `fromIDBRequest` / `fromIDBTransaction` wrap raw IDB primitives as reactive
- * sources. The old `indexedDbStorage` kv adapter has been replaced by
- * `indexedDbKv` in `./storage-tiers-browser.js` (Audit 4, 2026-04-24).
- *
- * Imports require the DOM lib — not safe to pull into Node-only bundles
- * without `lib: ["dom"]` in the consumer's tsconfig.
- *
- * @module
- */
-/// <reference lib="dom" />
-
-import { COMPLETE, DATA, ERROR, type Node, node } from "@graphrefly/pure-ts/core";
-
-// IndexedDbStorageSpec is no longer needed here — it's defined in storage-tiers-browser.ts.
-
-/**
- * Wraps an `IDBRequest` as a one-shot reactive source.
- *
- * @param req - Request whose callbacks are converted to protocol messages.
- * @returns `Node<T>` that emits `DATA` once on success then `COMPLETE`;
- *   emits `ERROR` on failure.
- *
- * @category extra
- */
-export function fromIDBRequest<T>(req: IDBRequest<T>): Node<T> {
-	return node<T>((_data, a) => {
-		let done = false;
-		const clear = () => {
-			req.onsuccess = null;
-			req.onerror = null;
-		};
-		req.onsuccess = () => {
-			if (done) return;
-			done = true;
-			clear();
-			a.down([[DATA, req.result], [COMPLETE]]);
-		};
-		req.onerror = () => {
-			if (done) return;
-			done = true;
-			clear();
-			a.down([[ERROR, req.error ?? new Error("IndexedDB request failed")]]);
-		};
-		return {
-			onDeactivation: () => {
-				done = true;
-				clear();
-			},
-		};
-	});
-}
-
-/**
- * Wraps an `IDBTransaction` terminal lifecycle as a one-shot reactive source.
- *
- * @param tx - Transaction to observe.
- * @returns `Node<void>` that emits `DATA` (`undefined`) then `COMPLETE` on
- *   success; emits `ERROR` on `error`/`abort`.
- *
- * @category extra
- */
-export function fromIDBTransaction(tx: IDBTransaction): Node<void> {
-	return node<void>((_data, a) => {
-		let done = false;
-		const clear = () => {
-			tx.oncomplete = null;
-			tx.onerror = null;
-			tx.onabort = null;
-		};
-		tx.oncomplete = () => {
-			if (done) return;
-			done = true;
-			clear();
-			a.down([[DATA, undefined], [COMPLETE]]);
-		};
-		tx.onerror = () => {
-			if (done) return;
-			done = true;
-			clear();
-			a.down([[ERROR, tx.error ?? new Error("IndexedDB transaction failed")]]);
-		};
-		tx.onabort = () => {
-			if (done) return;
-			done = true;
-			clear();
-			a.down([[ERROR, tx.error ?? new Error("IndexedDB transaction aborted")]]);
-		};
-		return {
-			onDeactivation: () => {
-				done = true;
-				clear();
-			},
-		};
-	});
-}
-
-// The old `indexedDbStorage` kv adapter has been removed.
-// Use `indexedDbKv` from `./storage-tiers-browser.js` instead (Audit 4, 2026-04-24).
diff --git a/src/base/sources/browser/index.ts b/src/base/sources/browser/index.ts
deleted file mode 100644
index 55c5d710..00000000
--- a/src/base/sources/browser/index.ts
+++ /dev/null
@@ -1,11 +0,0 @@
-/**
- * Browser-only sources — IDB (IndexedDB) reactive adapters, DOM events.
- *
- * All entries in this subpath may use DOM globals.
- * Import via @graphrefly/graphrefly/base/sources/browser.
- *
- * @module
- */
-
-export * from "../event/dom.js";
-export * from "./idb.js";
diff --git a/src/base/sources/event/cron.ts b/src/base/sources/event/cron.ts
deleted file mode 100644
index a93f2091..00000000
--- a/src/base/sources/event/cron.ts
+++ /dev/null
@@ -1,170 +0,0 @@
-/**
- * Cron-based reactive sources and schedule types.
- *
- * Merged from extra/cron.ts + extra/sources/event.ts (fromCron) during cleave A2.
- * `fromCron` relocated here from `dom.ts` (post-cleave /qa A1): it uses zero DOM
- * APIs (only `setInterval` + `new Date()`), so it belongs on the universal
- * `event/index.ts` barrel, not the browser-only `dom.ts` subpath.
- */
-
-import { type Node, type NodeOptions, node, wallClockNs } from "@graphrefly/pure-ts/core";
-
-type ExtraOpts = Omit<NodeOptions, "describeKind">;
-
-function sourceOpts<T = unknown>(opts?: ExtraOpts): NodeOptions<T> {
-	return { describeKind: "producer", ...opts } as NodeOptions<T>;
-}
-
-/** Options for {@link fromCron}. */
-export type FromCronOptions = ExtraOpts & {
-	/** Polling interval in ms. Default `60_000`. */
-	tickMs?: number;
-	/** Output format: `"timestamp_ns"` (default) emits wall-clock nanoseconds; `"date"` emits a `Date` object. */
-	output?: "timestamp_ns" | "date";
-};
-
-/**
- * Minimal 5-field cron parser and matcher (minute hour day-of-month month day-of-week).
- * Ported from callbag-recharge `extra/cron.ts` for `fromCron` (roadmap §2.3).
- */
-export interface CronSchedule {
-	minutes: Set<number>;
-	hours: Set<number>;
-	daysOfMonth: Set<number>;
-	months: Set<number>;
-	daysOfWeek: Set<number>;
-}
-
-function parseField(field: string, min: number, max: number): Set<number> {
-	const result = new Set<number>();
-	for (const part of field.split(",")) {
-		const [range, stepStr] = part.split("/");
-		const step = stepStr ? Number.parseInt(stepStr, 10) : 1;
-		if (Number.isNaN(step) || step < 1) throw new Error(`Invalid cron step: ${part}`);
-		let start: number;
-		let end: number;
-		if (range === "*") {
-			start = min;
-			end = max;
-		} else if (range.includes("-")) {
-			const [a, b] = range.split("-");
-			start = Number.parseInt(a, 10);
-			end = Number.parseInt(b, 10);
-		} else {
-			start = Number.parseInt(range, 10);
-			end = start;
-		}
-		if (Number.isNaN(start) || Number.isNaN(end)) throw new Error(`Invalid cron field: ${field}`);
-		if (start < min || end > max)
-			throw new Error(`Cron field out of range: ${field} (${min}-${max})`);
-		if (start > end) throw new Error(`Invalid cron range: ${start}-${end} in ${field}`);
-		for (let i = start; i <= end; i += step) result.add(i);
-	}
-	return result;
-}
-
-/**
- * Parses a standard 5-field cron expression into a {@link CronSchedule}.
- *
- * Supports `*`, ranges (`1-5`), steps (`*\/5`, `0-30/10`), and comma-separated
- * lists. Fields are: minute (0–59), hour (0–23), day-of-month (1–31),
- * month (1–12), day-of-week (0–6, Sunday = 0).
- *
- * @param expr - Five-field whitespace-separated cron string (e.g. `"0 9 * * 1-5"`).
- * @returns Parsed {@link CronSchedule} with one `Set<number>` per field.
- * @throws Error when the expression does not have exactly 5 fields, contains
- *   out-of-range values, or uses an invalid step.
- *
- * @example
- * ```ts
- * import { parseCron } from "@graphrefly/graphrefly";
- *
- * const sched = parseCron("0 9 * * 1-5"); // weekdays at 09:00
- * sched.hours;      // Set { 9 }
- * sched.daysOfWeek; // Set { 1, 2, 3, 4, 5 }
- * ```
- */
-export function parseCron(expr: string): CronSchedule {
-	const parts = expr.trim().split(/\s+/);
-	if (parts.length !== 5) throw new Error(`Invalid cron: expected 5 fields, got ${parts.length}`);
-	return {
-		minutes: parseField(parts[0], 0, 59),
-		hours: parseField(parts[1], 0, 23),
-		daysOfMonth: parseField(parts[2], 1, 31),
-		months: parseField(parts[3], 1, 12),
-		daysOfWeek: parseField(parts[4], 0, 6),
-	};
-}
-
-/**
- * Returns `true` if `date` satisfies every field of `schedule`.
- *
- * @param schedule - Parsed schedule from {@link parseCron}.
- * @param date - Moment to test (local time via `getMinutes`, `getHours`, etc.).
- * @returns `true` when all five cron fields match the given date.
- *
- * @example
- * ```ts
- * import { parseCron, matchesCron } from "@graphrefly/graphrefly";
- *
- * const sched = parseCron("30 8 * * 1"); // Mondays at 08:30
- * const monday = new Date("2026-03-30T08:30:00"); // a Monday
- * matchesCron(sched, monday); // true
- * ```
- */
-export function matchesCron(schedule: CronSchedule, date: Date): boolean {
-	return (
-		schedule.minutes.has(date.getMinutes()) &&
-		schedule.hours.has(date.getHours()) &&
-		schedule.daysOfMonth.has(date.getDate()) &&
-		schedule.months.has(date.getMonth() + 1) &&
-		schedule.daysOfWeek.has(date.getDay())
-	);
-}
-
-/**
- * Polls on an interval; when the current minute matches a 5-field cron expression, emits once (see {@link parseCron}).
- *
- * @param expr - Cron string (`min hour dom month dow`).
- * @param opts - Producer options plus `tickMs` (default `60_000`) and `output` (`timestamp_ns` default, or `date` for `Date` values).
- * @returns `Node<number>` (nanosecond timestamp) or `Node<Date>` when `output: "date"`.
- *
- * @example
- * ```ts
- * import { fromCron } from "@graphrefly/graphrefly";
- *
- * fromCron("0 9 * * 1");
- * ```
- *
- * @category extra
- */
-export function fromCron(expr: string, opts?: FromCronOptions & { output: "date" }): Node<Date>;
-export function fromCron(expr: string, opts?: FromCronOptions): Node<number>;
-export function fromCron(expr: string, opts?: FromCronOptions): Node<number | Date> {
-	const schedule: CronSchedule = parseCron(expr);
-	const { tickMs: tickOpt, output, ...rest } = opts ?? {};
-	const tickMs = tickOpt ?? 60_000;
-	const emitDate = output === "date";
-	return node<number | Date>(
-		(_data, a) => {
-			let lastFiredKey = -1;
-			const check = () => {
-				const now = new Date();
-				const key =
-					now.getFullYear() * 100_000_000 +
-					(now.getMonth() + 1) * 1_000_000 +
-					now.getDate() * 10_000 +
-					now.getHours() * 100 +
-					now.getMinutes();
-				if (key !== lastFiredKey && matchesCron(schedule, now)) {
-					lastFiredKey = key;
-					a.emit(emitDate ? now : wallClockNs());
-				}
-			};
-			check();
-			const id = setInterval(check, tickMs);
-			return { onDeactivation: () => clearInterval(id) };
-		},
-		{ ...sourceOpts(rest), name: rest.name ?? `cron:${expr}` },
-	);
-}
diff --git a/src/base/sources/event/dom.ts b/src/base/sources/event/dom.ts
deleted file mode 100644
index fc14dd59..00000000
--- a/src/base/sources/event/dom.ts
+++ /dev/null
@@ -1,167 +0,0 @@
-/**
- * DOM-based reactive event sources (browser-layer).
- *
- * Moved from extra/sources/event.ts (fromEvent, fromRaf) during cleave A2.
- */
-
-import { ERROR, type Node, type NodeOptions, node } from "@graphrefly/pure-ts/core";
-
-type ExtraOpts = Omit<NodeOptions, "describeKind">;
-type AsyncSourceOpts = ExtraOpts & { signal?: AbortSignal };
-
-function sourceOpts<T = unknown>(opts?: ExtraOpts): NodeOptions<T> {
-	return { describeKind: "producer", ...opts } as NodeOptions<T>;
-}
-
-/** DOM-style event target (browser or `node:events`). */
-export type EventTargetLike = {
-	addEventListener(
-		type: string,
-		listener: (ev: unknown) => void,
-		options?: boolean | { capture?: boolean; passive?: boolean; once?: boolean },
-	): void;
-	removeEventListener(
-		type: string,
-		listener: (ev: unknown) => void,
-		options?: boolean | { capture?: boolean; passive?: boolean; once?: boolean },
-	): void;
-};
-
-/** Options for {@link fromRaf}. */
-export type FromRafOptions = AsyncSourceOpts & {
-	/**
-	 * When `true`, the source **fully parks** while the document is hidden
-	 * (`document.visibilityState === "hidden"`) instead of falling back to a
-	 * `setTimeout(16ms)` keep-alive. It resumes from the next animation frame
-	 * on `visibilitychange` back to visible. Strict battery-correctness for
-	 * mobile/background consumers — a backgrounded recompute/timer loop is a
-	 * footgun for them. Default `false` (legacy: keep ticking via setTimeout).
-	 *
-	 * **No `document` ⇒ never auto-pauses.** React Native / Hermes has no
-	 * `document`, so visibility cannot be observed here; the host must drive
-	 * background pause itself (e.g. an `AppState`-fed source gating the
-	 * downstream, or unsubscribing this node on background). This option only
-	 * affects environments that expose `document.visibilityState`.
-	 */
-	pauseWhenHidden?: boolean;
-};
-
-export function fromRaf(opts?: FromRafOptions): Node<number> {
-	const { signal, pauseWhenHidden = false, ...rest } = opts ?? {};
-	return node<number>((_data, a) => {
-		let done = false;
-		let rafId: number | undefined;
-		let fallbackTimer: ReturnType<typeof setTimeout> | undefined;
-		let abortListenerAdded = false;
-		let visibilityListenerAdded = false;
-
-		const raf: typeof requestAnimationFrame | undefined =
-			typeof requestAnimationFrame === "function" ? requestAnimationFrame : undefined;
-		const caf: typeof cancelAnimationFrame | undefined =
-			typeof cancelAnimationFrame === "function" ? cancelAnimationFrame : undefined;
-		const doc: Document | undefined = typeof document !== "undefined" ? document : undefined;
-
-		const clearPending = () => {
-			if (rafId !== undefined && caf) caf(rafId);
-			if (fallbackTimer !== undefined) clearTimeout(fallbackTimer);
-			rafId = undefined;
-			fallbackTimer = undefined;
-		};
-		const cleanup = () => {
-			done = true;
-			clearPending();
-			if (abortListenerAdded) {
-				signal?.removeEventListener("abort", onAbort);
-				abortListenerAdded = false;
-			}
-			if (visibilityListenerAdded && doc) {
-				doc.removeEventListener("visibilitychange", onVisibilityChange);
-				visibilityListenerAdded = false;
-			}
-		};
-		const onAbort = () => {
-			if (done) return;
-			cleanup();
-			a.down([[ERROR, signal!.reason]]);
-		};
-		const tick = (now: number) => {
-			if (done) return;
-			a.emit(now);
-			scheduleNext();
-		};
-		const scheduleNext = () => {
-			if (done) return;
-			const hidden = doc !== undefined && doc.visibilityState === "hidden";
-			// Strict pause: when hidden and the consumer opted in, schedule
-			// nothing at all (no rAF, no setTimeout keep-alive). The
-			// `visibilitychange` listener re-enters `scheduleNext()` when the
-			// document becomes visible again, resuming from the next frame.
-			if (pauseWhenHidden && hidden) return;
-			// Prefer rAF for display-synced ticks when the tab is visible; when
-			// hidden, rAF is throttled to ~0 by the browser, so fall back to
-			// setTimeout so downstream state continues updating.
-			if (raf && !hidden) {
-				rafId = raf(tick);
-			} else {
-				fallbackTimer = setTimeout(() => tick(performance.now()), 16);
-			}
-		};
-		const onVisibilityChange = () => {
-			if (done) return;
-			// Cancel any pending schedule and re-schedule via the path now
-			// appropriate for the current visibility state.
-			clearPending();
-			scheduleNext();
-		};
-
-		if (signal?.aborted) {
-			// Already aborted before activation — `onAbort()` ran `cleanup()`
-			// and emitted ERROR. No listeners/timers were registered yet, so
-			// there is nothing to tear down on deactivation; returning a
-			// cleanup here would just re-run the (idempotent) no-op.
-			onAbort();
-			return;
-		}
-		signal?.addEventListener("abort", onAbort, { once: true });
-		abortListenerAdded = signal !== undefined;
-		if (doc && (raf || pauseWhenHidden)) {
-			doc.addEventListener("visibilitychange", onVisibilityChange);
-			visibilityListenerAdded = true;
-		}
-		scheduleNext();
-		return { onDeactivation: cleanup };
-	}, sourceOpts(rest));
-}
-
-/**
- * Wraps a DOM-style `addEventListener` target; each event becomes a `DATA` emission.
- *
- * @param target - Object with `addEventListener` / `removeEventListener`.
- * @param type - Event name (e.g. `"click"`).
- * @param opts - Producer options plus listener options (`capture`, `passive`, `once`).
- * @returns `Node<T>` — event payloads; teardown removes the listener.
- *
- * @example
- * ```ts
- * import { fromEvent } from "@graphrefly/graphrefly";
- *
- * fromEvent(document.body, "click");
- * ```
- *
- * @category extra
- */
-export function fromEvent<T = unknown>(
-	target: EventTargetLike,
-	type: string,
-	opts?: ExtraOpts & { capture?: boolean; passive?: boolean; once?: boolean },
-): Node<T> {
-	const { capture, passive, once, ...rest } = opts ?? {};
-	return node<T>((_data, a) => {
-		const handler = (e: unknown) => {
-			a.emit(e as T);
-		};
-		const options = { capture, passive, once };
-		target.addEventListener(type, handler, options);
-		return { onDeactivation: () => target.removeEventListener(type, handler, options) };
-	}, sourceOpts(rest));
-}
diff --git a/src/base/sources/event/index.ts b/src/base/sources/event/index.ts
deleted file mode 100644
index d880f333..00000000
--- a/src/base/sources/event/index.ts
+++ /dev/null
@@ -1,12 +0,0 @@
-/**
- * Event sources — cron + push (universal) and DOM (browser-only).
- *
- * For the DOM subpath, import from @graphrefly/graphrefly/base/sources/browser.
- * fromTimer is substrate; import from @graphrefly/pure-ts/extra.
- *
- * @module
- */
-
-export * from "./cron.js";
-export * from "./push.js";
-// dom.ts is browser-only; exposed via the browser subpath entry
diff --git a/src/base/sources/event/push.ts b/src/base/sources/event/push.ts
deleted file mode 100644
index a88f48f9..00000000
--- a/src/base/sources/event/push.ts
+++ /dev/null
@@ -1,95 +0,0 @@
-/**
- * Push-notification reactive source (universal — transport-agnostic).
- *
- * `fromPushNotification` turns host-delivered push messages (FCM / APNS /
- * Expo push / Web Push / a NestJS gateway fan-out — any transport) into a
- * reactive `Node<T>`. It is the sanctioned async/external boundary for the
- * two-reactive-island architecture: a mobile/web island and a backend island,
- * each reactive internally, with push as the transport between them (spec
- * §5.10 — async boundaries live in sources, NOT in node fns/operators; this
- * is the same shape as `fromEvent`, not an imperative trigger into the graph).
- *
- * The native/network bridge stays entirely inside the host-supplied
- * `register` callback — this primitive owns only the reactive emission and
- * teardown, so it carries zero `node:*` / DOM / SDK dependency and is
- * Hermes-safe by construction.
- */
-
-import { type Node, type NodeOptions, node } from "@graphrefly/pure-ts/core";
-
-type ExtraOpts = Omit<NodeOptions, "describeKind">;
-
-function sourceOpts<T = unknown>(opts?: ExtraOpts): NodeOptions<T> {
-	return { describeKind: "producer", ...opts } as NodeOptions<T>;
-}
-
-/** Tears down a push registration (remove listener, close channel, abort). */
-export type PushUnsubscribe = () => void;
-
-/**
- * Host registration callback for {@link fromPushNotification}.
- *
- * Called once on node activation with a `deliver` sink. Wire your push
- * transport here and call `deliver(payload)` for **each** incoming message.
- * Return a {@link PushUnsubscribe} (or nothing if there is no teardown).
- *
- * Any async/native setup belongs **inside** this callback (spec §5.10). The
- * returned unsubscribe must be synchronous; if your SDK registration is
- * async, kick it off here and return a function that aborts/detaches it
- * (the async boundary stays in the host, not in the reactive layer).
- */
-export type PushRegister<T> = (deliver: (payload: T) => void) => PushUnsubscribe | undefined;
-
-/**
- * Wraps a host push transport; each delivered message becomes a `DATA`
- * emission. Teardown invokes the registration's unsubscribe.
- *
- * @param register - Called on activation with a `deliver(payload)` sink;
- *   returns an optional unsubscribe.
- * @param opts - Producer node options (`name`, `meta`, …).
- * @returns `Node<T>` — push payloads as a reactive stream.
- *
- * @example
- * ```ts
- * import { fromPushNotification } from "@graphrefly/graphrefly";
- *
- * // memo:Re premium backend — opt-in cloud audit pushed (not polled).
- * const auditPushes = fromPushNotification<AuditEvent>((deliver) => {
- *   const sub = messaging.onMessage((msg) => deliver(msg.data as AuditEvent));
- *   return () => sub.remove();
- * });
- * ```
- *
- * @remarks
- * A synchronous throw inside `register` propagates as an activation failure
- * (it is not caught here) — same shape as `fromEvent`. Push transports are
- * open-ended: this source never emits `COMPLETE`/`ERROR` on its own; the
- * stream ends only via `onDeactivation` (unsubscribe). Surface a terminal
- * yourself (e.g. compose a downstream operator) if the host needs one.
- *
- * @category extra
- */
-export function fromPushNotification<T = unknown>(
-	register: PushRegister<T>,
-	opts?: ExtraOpts,
-): Node<T> {
-	if (typeof register !== "function") {
-		throw new TypeError(
-			"fromPushNotification: a (deliver) => unsubscribe registration function is required",
-		);
-	}
-	return node<T>((_data, a) => {
-		let done = false;
-		const deliver = (payload: T) => {
-			if (done) return;
-			a.emit(payload);
-		};
-		const unsubscribe = register(deliver);
-		return {
-			onDeactivation: () => {
-				done = true;
-				if (typeof unsubscribe === "function") unsubscribe();
-			},
-		};
-	}, sourceOpts(opts));
-}
diff --git a/src/base/sources/index.ts b/src/base/sources/index.ts
deleted file mode 100644
index 86083dc5..00000000
--- a/src/base/sources/index.ts
+++ /dev/null
@@ -1,12 +0,0 @@
-/**
- * Base sources — universal async sources, settled, and event/cron.
- *
- * Node-only sources: @graphrefly/graphrefly/base/sources/node
- * Browser-only sources: @graphrefly/graphrefly/base/sources/browser
- *
- * @module
- */
-
-export * from "./async.js";
-export * from "./event/index.js";
-export * from "./settled.js";
diff --git a/src/base/sources/node/fs-root.ts b/src/base/sources/node/fs-root.ts
deleted file mode 100644
index dedafdd1..00000000
--- a/src/base/sources/node/fs-root.ts
+++ /dev/null
@@ -1,157 +0,0 @@
-/**
- * Filesystem-watching source. Isolated from `./sources.ts` so bundlers
- * targeting the browser can import browser-safe sources (`fromTimer`,
- * `fromRaf`, etc.) without pulling in `node:fs`/`node:path`.
- */
-
-import { existsSync, statSync, watch } from "node:fs";
-import { resolve as resolvePath } from "node:path";
-import {
-	DATA,
-	ERROR,
-	type Message,
-	type Node,
-	type NodeOptions,
-	node,
-	wallClockNs,
-} from "@graphrefly/pure-ts/core";
-import { globToRegExp, matchesAnyPattern } from "@graphrefly/pure-ts/extra";
-
-type ExtraOpts = Omit<NodeOptions<unknown>, "describeKind">;
-
-function sourceOpts<T = unknown>(opts?: ExtraOpts): NodeOptions<T> {
-	return { describeKind: "producer", ...opts } as NodeOptions<T>;
-}
-
-export type FSEventType = "change" | "rename" | "create" | "delete";
-export type FSEvent = {
-	type: FSEventType;
-	path: string;
-	root: string;
-	relative_path: string;
-	src_path?: string;
-	dest_path?: string;
-	timestamp_ns: number;
-};
-
-export type FromFSWatchOptions = ExtraOpts & {
-	recursive?: boolean;
-	debounce?: number;
-	include?: string[];
-	exclude?: string[];
-};
-
-/**
- * Watches filesystem paths and emits debounced change events.
- *
- * Uses `fs.watch` only (no polling fallback). Teardown closes all watchers.
- *
- * @category extra
- */
-export function fromFSWatch(paths: string | string[], opts?: FromFSWatchOptions): Node<FSEvent> {
-	const list = Array.isArray(paths) ? paths : [paths];
-	if (list.length === 0) {
-		throw new RangeError("fromFSWatch expects at least one path");
-	}
-	const { recursive = true, debounce = 100, include, exclude, ...rest } = opts ?? {};
-	const includePatterns = include?.map(globToRegExp) ?? [];
-	const excludePatterns = (exclude ?? ["**/node_modules/**", "**/.git/**", "**/dist/**"]).map(
-		globToRegExp,
-	);
-	return node<FSEvent>((_data, a) => {
-		const pending = new Map<string, FSEvent>();
-		const watchers: ReturnType<typeof watch>[] = [];
-		let stopped = false;
-		let terminalEmitted = false;
-		let generation = 0;
-		const closeWatchers = () => {
-			for (const watcher of watchers.splice(0)) watcher.close();
-		};
-		const emitError = (err: unknown) => {
-			if (terminalEmitted) return;
-			terminalEmitted = true;
-			stopped = true;
-			if (timer !== undefined) clearTimeout(timer);
-			timer = undefined;
-			pending.clear();
-			closeWatchers();
-			a.down([[ERROR, err]]);
-		};
-		let timer: ReturnType<typeof setTimeout> | undefined;
-		const flush = (token: number) => {
-			timer = undefined;
-			if (stopped || terminalEmitted) return;
-			if (pending.size === 0) return;
-			const batchMessages: Message[] = [];
-			for (const evt of pending.values()) batchMessages.push([DATA, evt]);
-			pending.clear();
-			if (stopped || terminalEmitted || token !== generation) return;
-			a.down(batchMessages);
-		};
-		const onDeactivation = () => {
-			stopped = true;
-			generation += 1;
-			if (timer !== undefined) clearTimeout(timer);
-			timer = undefined;
-			closeWatchers();
-			pending.clear();
-		};
-		try {
-			for (const basePath of list) {
-				const resolved = resolvePath(basePath);
-				// Linux recursive fs.watch may not throw for missing paths (waits instead).
-				try {
-					statSync(resolved);
-				} catch (err) {
-					emitError(err);
-					return { onDeactivation };
-				}
-				const watcher = watch(
-					resolved,
-					{ recursive },
-					(eventType: "rename" | "change", fileName: string | Buffer | null) => {
-						if (stopped || terminalEmitted) return;
-						if (fileName == null) return;
-						const rel = String(fileName).replaceAll("\\", "/");
-						const abs = resolvePath(resolved, String(fileName));
-						const normalized = abs.replaceAll("\\", "/");
-						const root = resolved.replaceAll("\\", "/");
-						const relForMatch = rel.startsWith("./") ? rel.slice(2) : rel;
-						const included =
-							includePatterns.length === 0 ||
-							matchesAnyPattern(normalized, includePatterns) ||
-							matchesAnyPattern(relForMatch, includePatterns);
-						if (!included) return;
-						const excluded =
-							matchesAnyPattern(normalized, excludePatterns) ||
-							matchesAnyPattern(relForMatch, excludePatterns);
-						if (excluded) return;
-						let kind: FSEventType = "change";
-						if (eventType === "rename") {
-							try {
-								kind = existsSync(normalized) ? "create" : "delete";
-							} catch {
-								kind = "rename";
-							}
-						}
-						pending.set(normalized, {
-							type: kind,
-							path: normalized,
-							root,
-							relative_path: relForMatch,
-							timestamp_ns: wallClockNs(),
-						});
-						if (timer !== undefined) clearTimeout(timer);
-						const token = generation;
-						timer = setTimeout(() => flush(token), debounce);
-					},
-				);
-				watcher.on("error", (err) => emitError(err));
-				watchers.push(watcher);
-			}
-		} catch (err) {
-			emitError(err);
-		}
-		return { onDeactivation };
-	}, sourceOpts(rest));
-}
diff --git a/src/base/sources/node/fs.ts b/src/base/sources/node/fs.ts
deleted file mode 100644
index cea17802..00000000
--- a/src/base/sources/node/fs.ts
+++ /dev/null
@@ -1,9 +0,0 @@
-/**
- * Filesystem sources (Node-only). Re-exports from `./fs-root.js`.
- *
- * Importing this sub-file pulls a Node builtin transitively; only consume from
- * `@graphrefly/graphrefly/base/sources/node` and not from the browser-safe
- * `@graphrefly/graphrefly/base/sources` barrel.
- */
-
-export * from "./fs-root.js";
diff --git a/src/base/sources/node/git-hook.ts b/src/base/sources/node/git-hook.ts
deleted file mode 100644
index 9cac3885..00000000
--- a/src/base/sources/node/git-hook.ts
+++ /dev/null
@@ -1,118 +0,0 @@
-/**
- * Git hook source — Node-only reactive source that polls a repository's HEAD
- * and emits structured `GitEvent`s on every new commit.
- *
- * Isolated from `./adapters.ts` so that the universal `extra/index` barrel
- * stays browser-safe. Access via `@graphrefly/graphrefly/extra/node`, which
- * re-exports this module.
- *
- * @module
- */
-
-import { ERROR, type Node, type NodeOptions, node, wallClockNs } from "@graphrefly/pure-ts/core";
-import { fromTimer, globToRegExp, matchesAnyPattern, switchMap } from "@graphrefly/pure-ts/extra";
-
-type ExtraOpts = Omit<NodeOptions, "describeKind">;
-
-/** Git hook type for {@link fromGitHook}. */
-export type GitHookType = "post-commit" | "post-merge" | "post-checkout" | "post-rewrite";
-
-/** Structured git event emitted by {@link fromGitHook}. */
-export type GitEvent = {
-	hook: GitHookType;
-	commit: string;
-	files: string[];
-	message: string;
-	author: string;
-	timestamp_ns: number;
-};
-
-/** Options for {@link fromGitHook}. */
-export type FromGitHookOptions = ExtraOpts & {
-	pollMs?: number;
-	include?: string[];
-	exclude?: string[];
-	/**
-	 * Maximum consecutive poll errors before terminating the source. Prevents
-	 * error storms when the repository is unavailable (e.g. deleted, corrupt,
-	 * permissions lost). Default: `1` (terminate on first error — preserves
-	 * pre-switchMap back-compat). Raise it (or set `Infinity`) to keep
-	 * retrying indefinitely (legacy behavior).
-	 */
-	maxConsecutiveErrors?: number;
-};
-
-/**
- * Git change detection as a reactive source.
- *
- * @category extra
- */
-export function fromGitHook(repoPath: string, opts?: FromGitHookOptions): Node<GitEvent> {
-	const { pollMs = 5000, include, exclude, maxConsecutiveErrors = 1 } = opts ?? {};
-	const includePatterns = include?.map(globToRegExp) ?? [];
-	const excludePatterns = exclude?.map(globToRegExp) ?? [];
-	const { execFileSync } = require("node:child_process") as typeof import("node:child_process");
-
-	const gitQuery = (args: string[]): string =>
-		execFileSync("git", args, { cwd: repoPath, encoding: "utf-8" }).trim();
-
-	// Shared across ticks: the previous HEAD we committed to. Undefined on the
-	// very first poll (we record the initial HEAD without emitting).
-	let lastSeen: string | undefined;
-	// Circuit breaker: consecutive error count. Resets on any successful poll.
-	let consecutiveErrors = 0;
-
-	// `fromTimer | switchMap(sync-git-diff)` — ticks drive the poll, switchMap
-	// cancels any in-flight inner on next tick. First tick at t=0 records the
-	// baseline HEAD silently; subsequent ticks emit `GitEvent` on HEAD change.
-	return switchMap(fromTimer(0, { period: pollMs }), () =>
-		node<GitEvent>((_data, a) => {
-			try {
-				const head = gitQuery(["rev-parse", "HEAD"]);
-				if (!head) {
-					consecutiveErrors = 0;
-					return { onDeactivation: () => {} };
-				}
-				if (lastSeen === undefined) {
-					// First poll: record baseline; stay idle until next tick
-					// disposes this inner.
-					lastSeen = head;
-					consecutiveErrors = 0;
-					return { onDeactivation: () => {} };
-				}
-				if (head === lastSeen) {
-					consecutiveErrors = 0;
-					return { onDeactivation: () => {} };
-				}
-				let files = gitQuery(["diff", "--name-only", `${lastSeen}..${head}`])
-					.split("\n")
-					.filter(Boolean);
-				if (includePatterns.length > 0) {
-					files = files.filter((f) => matchesAnyPattern(f, includePatterns));
-				}
-				if (excludePatterns.length > 0) {
-					files = files.filter((f) => !matchesAnyPattern(f, excludePatterns));
-				}
-				const message = gitQuery(["log", "-1", "--format=%s", head]);
-				const author = gitQuery(["log", "-1", "--format=%an", head]);
-				a.emit({
-					hook: "post-commit" as GitHookType,
-					commit: head,
-					files,
-					message,
-					author,
-					timestamp_ns: wallClockNs(),
-				});
-				lastSeen = head;
-				consecutiveErrors = 0;
-			} catch (err) {
-				consecutiveErrors += 1;
-				if (consecutiveErrors >= maxConsecutiveErrors) {
-					a.down([[ERROR, err]]);
-				}
-				// else: transient error — next tick will retry; don't spam ERROR.
-			}
-			return { onDeactivation: () => {} };
-		}),
-	);
-}
diff --git a/src/base/sources/node/git.ts b/src/base/sources/node/git.ts
deleted file mode 100644
index 016090bd..00000000
--- a/src/base/sources/node/git.ts
+++ /dev/null
@@ -1,10 +0,0 @@
-/**
- * Git hook source (Node-only). Re-exports from `../git-hook.js`.
- *
- * Importing this sub-file may pull a Node builtin transitively; only consume
- * from `@graphrefly/graphrefly/extra/node` and not from the browser-safe
- * `@graphrefly/graphrefly/extra` barrel.
- */
-
-export type { FromGitHookOptions, GitEvent, GitHookType } from "./git-hook.js";
-export { fromGitHook } from "./git-hook.js";
diff --git a/src/base/sources/node/index.ts b/src/base/sources/node/index.ts
deleted file mode 100644
index abdd3079..00000000
--- a/src/base/sources/node/index.ts
+++ /dev/null
@@ -1,13 +0,0 @@
-/**
- * Node-only sources — fs, git, git-hook, process.
- *
- * All entries in this subpath may import node:* builtins.
- * Import via @graphrefly/graphrefly/base/sources/node.
- *
- * @module
- */
-
-export * from "./fs.js";
-export * from "./git.js";
-export * from "./git-hook.js";
-export * from "./process.js";
diff --git a/src/base/sources/node/process.ts b/src/base/sources/node/process.ts
deleted file mode 100644
index 6b9da426..00000000
--- a/src/base/sources/node/process.ts
+++ /dev/null
@@ -1,274 +0,0 @@
-/**
- * Child-process reactive sources — Node-only.
- *
- * Isolated from `./sources.ts` so bundlers targeting the browser can import
- * browser-safe sources without pulling in `node:child_process`.
- *
- * Access via `@graphrefly/graphrefly/extra/node`, which re-exports this module.
- *
- * @module
- */
-
-import { type SpawnOptions, spawn } from "node:child_process";
-import { COMPLETE, DATA, ERROR, type Messages, type Node, node } from "@graphrefly/pure-ts/core";
-
-// ---------------------------------------------------------------------------
-// Types
-// ---------------------------------------------------------------------------
-
-/**
- * SpawnEvent — discriminated stream emitted by {@link fromSpawn}.
- *
- * @category extra
- */
-export type SpawnEvent =
-	| { kind: "stdout"; chunk: Buffer }
-	| { kind: "stderr"; chunk: Buffer }
-	| { kind: "exit"; code: number | null; signal: NodeJS.Signals | null };
-
-/** Options for {@link fromSpawn}. Mirrors `child_process.SpawnOptions`. */
-export interface FromSpawnOptions {
-	cwd?: string;
-	env?: NodeJS.ProcessEnv;
-	shell?: boolean | string;
-	/**
-	 * Optional caller-owned AbortSignal. When fired, the subprocess is sent
-	 * SIGTERM (per `child_process.spawn` signal semantics). The producer's own
-	 * teardown also sends SIGTERM regardless of caller signal — so `switchMap`
-	 * supersede in `actuatorExecutor` cancels in-flight subprocesses without
-	 * the caller wiring extra signals.
-	 */
-	signal?: AbortSignal;
-	/** Extra args forwarded to spawn — e.g. stdio configuration. */
-	stdio?: "pipe" | readonly ("pipe" | "ignore" | "inherit")[];
-}
-
-// ---------------------------------------------------------------------------
-// fromSpawn
-// ---------------------------------------------------------------------------
-
-/**
- * Spawn `cmd args` as a child process and stream stdout/stderr/exit as a
- * single discriminated `SpawnEvent` stream.
- *
- * Lifecycle:
- * - Stdout/stderr chunks emit as `DATA { kind: "stdout"|"stderr", chunk }`.
- * - Process exit emits one final `DATA { kind: "exit", code, signal }` then
- *   `COMPLETE`.
- * - Spawn-error (ENOENT, EPERM, …) emits `ERROR`.
- * - Producer teardown sends `SIGTERM` to the subprocess if it is still alive.
- *
- * **Multicast semantics:** `fromSpawn` returns a node backed by a single
- * `producer` activation — the subprocess is spawned once when the first
- * subscriber connects, and all subsequent subscribers share the same event
- * stream. Unsubscribing the last subscriber tears down the subprocess.
- *
- * @example
- * ```ts
- * import { fromSpawn } from "@graphrefly/graphrefly/extra/node";
- *
- * const stream = fromSpawn("git", ["log", "--oneline"]);
- * stream.subscribe((msgs) => {
- *   for (const [type, value] of msgs) {
- *     if (type === DATA) console.log(value);
- *   }
- * });
- * ```
- *
- * @category extra
- */
-export function fromSpawn(
-	cmd: string,
-	args: readonly string[],
-	opts?: FromSpawnOptions,
-): Node<SpawnEvent> {
-	return node<SpawnEvent>(
-		(_data, actions) => {
-			const child = spawn(cmd, args as string[], {
-				cwd: opts?.cwd,
-				env: opts?.env,
-				shell: opts?.shell,
-				signal: opts?.signal,
-				stdio: (opts?.stdio as SpawnOptions["stdio"]) ?? "pipe",
-			});
-
-			let alive = true;
-			let exitInfo: { code: number | null; signal: NodeJS.Signals | null } | null = null;
-
-			child.stdout?.on("data", (chunk: Buffer) => {
-				if (!alive) return;
-				actions.down([[DATA, { kind: "stdout", chunk }]] satisfies Messages);
-			});
-
-			child.stderr?.on("data", (chunk: Buffer) => {
-				if (!alive) return;
-				actions.down([[DATA, { kind: "stderr", chunk }]] satisfies Messages);
-			});
-
-			child.on("error", (err) => {
-				if (!alive) return;
-				alive = false;
-				actions.down([[ERROR, err]] satisfies Messages);
-			});
-
-			child.on("exit", (code, signal) => {
-				// Capture exit info, but defer terminal emission to "close" — by which
-				// time all stdout/stderr "data" events have been delivered.
-				if (exitInfo == null) exitInfo = { code, signal: signal as NodeJS.Signals | null };
-			});
-
-			child.on("close", () => {
-				if (!alive) return;
-				alive = false;
-				const info = exitInfo ?? { code: null, signal: null };
-				actions.down([
-					[DATA, { kind: "exit", code: info.code, signal: info.signal }],
-					[COMPLETE],
-				] satisfies Messages);
-			});
-
-			return {
-				onDeactivation: () => {
-					if (alive) {
-						alive = false;
-						child.stdout?.removeAllListeners();
-						child.stderr?.removeAllListeners();
-						child.removeAllListeners("error");
-						child.removeAllListeners("exit");
-						child.removeAllListeners("close");
-						try {
-							child.kill("SIGTERM");
-						} catch {
-							// already dead — ignore
-						}
-					}
-				},
-			};
-		},
-		{ name: "from_spawn" },
-	);
-}
-
-// ---------------------------------------------------------------------------
-// runProcess
-// ---------------------------------------------------------------------------
-
-/**
- * Run `cmd args` to completion and emit one DATA with aggregated output.
- *
- * Convenience over {@link fromSpawn} for the "wait for the process to finish,
- * capture stdout/stderr as strings, get exit code" case.
- *
- * Aggregation policy: stdout and stderr are concatenated as `Buffer`s and
- * decoded as utf-8 once at exit, so multi-byte sequences split across chunks
- * are handled correctly. Actuators that need byte-exact stdout should use
- * `fromSpawn` directly.
- *
- * @example
- * ```ts
- * import { runProcess } from "@graphrefly/graphrefly/extra/node";
- *
- * const result = runProcess("git", ["rev-parse", "HEAD"]);
- * result.subscribe((msgs) => {
- *   for (const [type, value] of msgs) {
- *     if (type === DATA) console.log(value.stdout.trim());
- *   }
- * });
- * ```
- *
- * @category extra
- */
-export function runProcess(
-	cmd: string,
-	args: readonly string[],
-	opts?: FromSpawnOptions,
-): Node<{
-	stdout: string;
-	stderr: string;
-	exitCode: number | null;
-	signal: NodeJS.Signals | null;
-}> {
-	type Result = {
-		stdout: string;
-		stderr: string;
-		exitCode: number | null;
-		signal: NodeJS.Signals | null;
-	};
-	return node<Result>(
-		(_data, actions) => {
-			const child = spawn(cmd, args as string[], {
-				cwd: opts?.cwd,
-				env: opts?.env,
-				shell: opts?.shell,
-				signal: opts?.signal,
-				stdio: (opts?.stdio as SpawnOptions["stdio"]) ?? "pipe",
-			});
-
-			let alive = true;
-			const stdoutChunks: Buffer[] = [];
-			const stderrChunks: Buffer[] = [];
-			let exitInfo: { code: number | null; signal: NodeJS.Signals | null } | null = null;
-
-			child.stdout?.on("data", (chunk: Buffer) => {
-				if (!alive) return;
-				stdoutChunks.push(chunk);
-			});
-
-			child.stderr?.on("data", (chunk: Buffer) => {
-				if (!alive) return;
-				stderrChunks.push(chunk);
-			});
-
-			child.on("error", (err) => {
-				if (!alive) return;
-				alive = false;
-				actions.down([[ERROR, err]] satisfies Messages);
-			});
-
-			child.on("exit", (code, signal) => {
-				// Capture exit info, but defer terminal emission to "close" — by which
-				// time all stdout/stderr "data" events have been delivered.
-				if (exitInfo == null) exitInfo = { code, signal: signal as NodeJS.Signals | null };
-			});
-
-			child.on("close", () => {
-				if (!alive) return;
-				alive = false;
-				const info = exitInfo ?? { code: null, signal: null };
-				const stdout = Buffer.concat(stdoutChunks).toString("utf8");
-				const stderr = Buffer.concat(stderrChunks).toString("utf8");
-				actions.down([
-					[
-						DATA,
-						{
-							stdout,
-							stderr,
-							exitCode: info.code,
-							signal: info.signal,
-						},
-					],
-					[COMPLETE],
-				] satisfies Messages);
-			});
-
-			return {
-				onDeactivation: () => {
-					if (alive) {
-						alive = false;
-						child.stdout?.removeAllListeners();
-						child.stderr?.removeAllListeners();
-						child.removeAllListeners("error");
-						child.removeAllListeners("exit");
-						child.removeAllListeners("close");
-						try {
-							child.kill("SIGTERM");
-						} catch {
-							// already dead — ignore
-						}
-					}
-				},
-			};
-		},
-		{ name: "run_process" },
-	);
-}
diff --git a/src/base/sources/settled.ts b/src/base/sources/settled.ts
deleted file mode 100644
index 28d946c2..00000000
--- a/src/base/sources/settled.ts
+++ /dev/null
@@ -1,489 +0,0 @@
-/**
- * Settled/signal helpers.
- *
- * Moved from extra/sources/settled.ts during cleave A2.
- * `keepalive` is substrate — it lives at `@graphrefly/pure-ts`
- * (`packages/pure-ts/src/extra/sources/_keepalive.ts`), not here.
- */
-
-/**
- * Settled / signal helpers — boundary primitives for converting reactive
- * sources into Promise/AbortSignal endpoints.
- *
- * - {@link firstValueFrom} / {@link firstWhere} — Promise of the first
- *   matching DATA.
- * - {@link awaitSettled} — composition over `firstWhere` + reactive
- *   `timeout` from `extra/resilience` (lazy import to avoid a
- *   resilience → sources cycle).
- * - {@link nodeSignal} — `Node<boolean>` → `AbortSignal` bridge.
- * - {@link reactiveCounter} — capped counter exposed as a `Node<number>`.
- */
-
-import {
-	COMPLETE,
-	DATA,
-	DIRTY,
-	ERROR,
-	type Messages,
-	type Node,
-	node,
-} from "@graphrefly/pure-ts/core";
-
-/**
- * Converts the first `DATA` on `source` into a Promise; rejects on `ERROR` or `COMPLETE` without data.
- *
- * **Important:** This subscribes and waits for a **future** emission. Data that
- * has already flowed is gone and will not be seen. Call this *before* the upstream
- * emits, or use `source.cache` / `source.status` for already-cached state.
- * See COMPOSITION-GUIDE §2 (subscription ordering).
- *
- * @param source - Node to read once.
- * @returns Promise of the first value.
- *
- * @example
- * ```ts
- * import { firstValueFrom, of } from "@graphrefly/graphrefly";
- *
- * await firstValueFrom(of(42));
- * ```
- *
- * @category extra
- */
-export function firstValueFrom<T>(source: Node<T>): Promise<T> {
-	return new Promise<T>((resolve, reject) => {
-		let settled = false;
-		let shouldUnsub = false;
-		let unsub: (() => void) | undefined;
-		unsub = source.subscribe((msgs) => {
-			for (const m of msgs) {
-				if (settled) return;
-				if (m[0] === DATA) {
-					settled = true;
-					resolve(m[1] as T);
-					if (unsub) {
-						unsub();
-						unsub = undefined;
-					} else shouldUnsub = true;
-					return;
-				}
-				if (m[0] === ERROR) {
-					settled = true;
-					reject(m[1]);
-					if (unsub) {
-						unsub();
-						unsub = undefined;
-					} else shouldUnsub = true;
-					return;
-				}
-				if (m[0] === COMPLETE) {
-					settled = true;
-					reject(new Error("completed without DATA"));
-					if (unsub) {
-						unsub();
-						unsub = undefined;
-					} else shouldUnsub = true;
-					return;
-				}
-			}
-		});
-		if (shouldUnsub) {
-			unsub?.();
-			unsub = undefined;
-		}
-	});
-}
-
-/**
- * Wait for the first DATA value from `source` that satisfies `predicate`.
- *
- * Subscribes directly and resolves on the first DATA value where
- * `predicate` returns true. Reactive, no polling. Use in tests and
- * bridging code where you need a single matching value as a Promise.
- *
- * **Important:** This only captures **future** emissions — data that has
- * already flowed through the node is gone. Call this *before* the upstream
- * emits. For already-cached values, use `source.cache` / `source.status`.
- * See COMPOSITION-GUIDE §2 (subscription ordering).
- *
- * ```ts
- * const val = await firstWhere(strategy.snapshot, snap => snap.size > 0);
- * ```
- *
- * @param source - Upstream node to observe.
- * @param predicate - Returns `true` for the value to resolve on.
- * @param opts - `{ skipCurrent?: boolean }`. When `skipCurrent: true`, any DATA
- *   delivered during the synchronous `subscribe()` call (push-on-subscribe §2.2
- *   replay of the cached value) is ignored — the promise resolves only on the
- *   next future emission. Useful when the caller wants to await the next
- *   settlement event after an imperative action (e.g. `run()` minting a new
- *   runVersion, where the currently-cached value belongs to the previous run).
- *
- * @category extra
- */
-export function firstWhere<T>(
-	source: Node<T>,
-	predicate: (value: T) => boolean,
-	opts?: { skipCurrent?: boolean; kick?: () => void },
-): Promise<T> {
-	// Lock 3.A (Phase 13.6.B): subscribe synchronously inside the function
-	// body — NOT inside the Promise executor. Subscribing inside the
-	// executor would defer the subscription past any synchronous `kick()`
-	// the caller fires after the call returns, race-losing the very wave
-	// the caller wants to observe.
-	//
-	// To bridge sync-subscribe with the async Promise contract, we record
-	// any settlement that fires *before* the Promise constructor runs, and
-	// the executor immediately resolves/rejects with the recorded value.
-	// Settlements after the executor runs go straight through resolve/reject.
-	type Pending =
-		| { kind: "data"; value: T }
-		| { kind: "error"; err: unknown }
-		| { kind: "complete" };
-	let pending: Pending | undefined;
-	let resolveFn: ((value: T) => void) | undefined;
-	let rejectFn: ((err: unknown) => void) | undefined;
-	let settled = false;
-	let shouldUnsub = false;
-	let unsub: (() => void) | undefined;
-	let inInitialSyncPhase = opts?.skipCurrent === true;
-
-	// QA P1: every settler short-circuits when `settled === true` so a
-	// later settle attempt (e.g. `kick()` throwing AFTER it synchronously
-	// fired matching DATA, OR a `[DATA matched, ERROR]` wave during
-	// push-on-subscribe) cannot overwrite an earlier `pending` outcome.
-	// Without this gate, a kick that races sink-callback settlement could
-	// reject a Promise the user already has resolved-DATA for.
-	const settleData = (v: T): void => {
-		if (settled) return;
-		settled = true;
-		if (resolveFn != null) resolveFn(v);
-		else pending = { kind: "data", value: v };
-	};
-	const settleError = (err: unknown): void => {
-		if (settled) return;
-		settled = true;
-		if (rejectFn != null) rejectFn(err);
-		else pending = { kind: "error", err };
-	};
-	const settleComplete = (): void => {
-		if (settled) return;
-		settled = true;
-		const err = new Error("completed without matching value");
-		if (rejectFn != null) rejectFn(err);
-		else pending = { kind: "complete" };
-	};
-	const detach = (): void => {
-		if (unsub) {
-			unsub();
-			unsub = undefined;
-		} else shouldUnsub = true;
-	};
-
-	const sink: (msgs: Messages) => void = (msgs) => {
-		if (settled) return;
-		for (const m of msgs) {
-			if (settled) return;
-			// During the initial sync phase, swallow only cached DATA
-			// (push-on-subscribe §2.2). Terminal ERROR / COMPLETE must
-			// still reject the promise — otherwise an already-terminated
-			// source synchronously delivering `[[ERROR, ...]]` or
-			// `[[COMPLETE]]` during `subscribe()` would hang forever
-			// under `skipCurrent: true`.
-			if (inInitialSyncPhase && m[0] === DATA) continue;
-			if (m[0] === DATA) {
-				const v = m[1] as T;
-				if (predicate(v)) {
-					settleData(v);
-					detach();
-					return;
-				}
-			}
-			if (m[0] === ERROR) {
-				settleError(m[1]);
-				detach();
-				return;
-			}
-			if (m[0] === COMPLETE) {
-				settleComplete();
-				detach();
-				return;
-			}
-		}
-	};
-	unsub = source.subscribe(sink);
-	inInitialSyncPhase = false;
-	// Lock 3.A: fire `kick` AFTER subscribe is in place. With sync
-	// subscribe + sync kick, the resulting wave reaches `sink` before
-	// control returns — making subscribe-before-kick ordering structurally
-	// impossible to misuse.
-	if (opts?.kick != null && !settled) {
-		try {
-			opts.kick();
-		} catch (err) {
-			settleError(err);
-			detach();
-		}
-	}
-	if (shouldUnsub) {
-		unsub?.();
-		unsub = undefined;
-	}
-
-	return new Promise<T>((resolve, reject) => {
-		// If a settlement landed synchronously before the executor runs,
-		// flush it through immediately.
-		if (pending != null) {
-			if (pending.kind === "data") resolve(pending.value);
-			else if (pending.kind === "error") reject(pending.err);
-			else reject(new Error("completed without matching value"));
-			return;
-		}
-		resolveFn = resolve;
-		rejectFn = reject;
-	});
-}
-
-/**
- * Await the first non-nullish DATA value from `source`, with optional
- * timeout. Composition sugar over `firstWhere` + reactive timeout.
- *
- * Designed as the CLI/boundary sink for reactive pipelines that end in a
- * nullable node (e.g. `promptNode` — per COMPOSITION-GUIDE §8, it emits
- * `null` before it settles with a real value). Replaces the common pattern
- * `firstValueFrom(filter(source, v => v != null))` with a deadline.
- *
- * - Rejects with `TimeoutError` (from `extra/resilience`) if no matching
- *   value arrives within `timeoutMs`. Omit `timeoutMs` for unbounded wait.
- * - `predicate` defaults to `v => v != null`. Pass a custom predicate to
- *   gate on a stronger condition (e.g. `v => typeof v === "string"`).
- * - Pass `skipCurrent: true` to ignore the currently-cached value delivered
- *   synchronously via push-on-subscribe and resolve only on the *next*
- *   matching emission. Useful after an imperative action that should produce
- *   a fresh settlement (e.g. `run()` minting a new version — the stale
- *   cached value from the previous run must not resolve the new caller).
- *
- * ```ts
- * const brief = await awaitSettled(briefNode, { timeoutMs: 120_000 });
- * // or with a predicate:
- * const rich = await awaitSettled(node, {
- *   predicate: (v): v is MyShape => typeof v === "object" && v != null && "key" in v,
- *   timeoutMs: 60_000,
- * });
- * // or after kicking off a fresh run:
- * kickOff();
- * const fresh = await awaitSettled(resultNode, { skipCurrent: true });
- * ```
- *
- * Reactive inside, sync propagation — the one async boundary is the
- * returned `Promise<T>` (spec §5.10: async belongs at sources and
- * boundaries, not in the graph).
- *
- * @param source - Upstream node to observe.
- * @param opts - `{ predicate?, timeoutMs?, skipCurrent? }`.
- * @returns Promise that resolves with the first matching value, or rejects on timeout / ERROR / COMPLETE-without-DATA.
- *
- * @category extra
- */
-// Lazy module-cache for the `withTimeout` resilience operator. The dynamic
-// import keeps `settled` free of an eager edge into the resilience family;
-// first call pays the one-shot import, subsequent calls hit cached refs.
-let _timeoutOp: typeof import("../resilience/timeout.js").withTimeout | undefined;
-let _nsPerMs: number | undefined;
-
-export async function awaitSettled<T>(
-	source: Node<T>,
-	opts?: {
-		predicate?: (value: T) => boolean;
-		timeoutMs?: number;
-		skipCurrent?: boolean;
-		/**
-		 * Lock 3.A (Phase 13.6.B): fired AFTER subscribe is in place but
-		 * BEFORE the helper's async boundary is exposed to the caller.
-		 * Subscribe-before-kick is structurally enforced — the kick's
-		 * synchronous wave reaches `sink` before control returns. Replaces
-		 * the prior load-bearing-comment pattern (M.20-load-bearing) with
-		 * a misuse-impossible API shape.
-		 *
-		 * Common pattern:
-		 *   await awaitSettled(node, {
-		 *     skipCurrent: true,
-		 *     kick: () => producer.emit(value),
-		 *   });
-		 *
-		 * Omit `kick` for external-trigger cases where the wave is fired
-		 * by code outside the helper's caller; subscribe still lands
-		 * synchronously inside the helper body so the next external wave
-		 * is not lost.
-		 */
-		kick?: () => void;
-	},
-): Promise<NonNullable<T>> {
-	const predicate = opts?.predicate ?? ((v: T) => v != null);
-	const skipCurrent = opts?.skipCurrent;
-	const kick = opts?.kick;
-	if (opts?.timeoutMs == null || opts.timeoutMs <= 0) {
-		return (await firstWhere(source, predicate, { skipCurrent, kick })) as NonNullable<T>;
-	}
-	// Reactive composition: `timeout()` wraps the source as a Node that
-	// emits ERROR(TimeoutError) on deadline. `firstWhere` then resolves on
-	// the first matching DATA or rejects on that ERROR. One async boundary
-	// (the returned Promise), everything inside is sync reactive.
-	if (_timeoutOp === undefined) {
-		const [timeoutMod, backoff] = await Promise.all([
-			import("../resilience/timeout.js"),
-			import("../resilience/backoff.js"),
-		]);
-		_timeoutOp = timeoutMod.withTimeout;
-		_nsPerMs = backoff.NS_PER_MS;
-	}
-	const guarded = _timeoutOp(source, { ns: opts.timeoutMs * (_nsPerMs as number) }).node;
-	return (await firstWhere(guarded, predicate, { skipCurrent, kick })) as NonNullable<T>;
-}
-
-/**
- * Converts a reactive `Node<boolean>` into a browser-standard `AbortSignal`
- * that fires when the node settles on `true`. Useful for threading a reactive
- * "cancel" flag into any async boundary that accepts a signal (fetch, LLM SDK
- * calls, child-process APIs, timers).
- *
- * **Contract.**
- * - `signal.abort(reason)` fires exactly once, on the first DATA emission with
- *   a truthy value. Subsequent emissions are ignored (AbortSignal is
- *   single-shot).
- * - Null / `false` / sentinel values are ignored. Push-on-subscribe will
- *   check the currently-cached value on subscribe and abort immediately if
- *   it's already `true`.
- * - `reason` defaults to `"cancelled via nodeSignal"`; pass `opts.reason` to
- *   override (`DOMException`, `Error`, or any value accepted by
- *   `AbortController.abort`).
- *
- * **Lifecycle.**
- * - Returns a `{signal, dispose}` bundle. Call `dispose()` when you're done
- *   with the signal (e.g. in a `finally` after the async operation completes).
- *   `dispose()` unsubscribes from the node and is a no-op once the signal has
- *   fired.
- * - **Memory note:** without `dispose()` the subscription keeps the reactive
- *   node alive for the lifetime of the process. For bridge calls inside a
- *   `switchMap` project fn, the switchMap supersede tears the inner subgraph
- *   down, which is usually the right lifetime — but still call `dispose()`
- *   from the caller's `finally` for clarity.
- *
- * @example
- * ```ts
- * const aborted = state(false);
- * const { signal, dispose } = nodeSignal(aborted);
- * try {
- *   const resp = await adapter.invoke(msgs, { signal });
- *   return resp;
- * } finally {
- *   dispose();
- * }
- * ```
- *
- * @category extra
- */
-export function nodeSignal(
-	source: Node<boolean>,
-	opts?: { reason?: unknown },
-): { signal: AbortSignal; dispose: () => void } {
-	const ctrl = new AbortController();
-	const reason = opts?.reason ?? new Error("cancelled via nodeSignal");
-	let unsub: (() => void) | undefined;
-	let shouldUnsub = false;
-	const done = () => {
-		if (unsub) {
-			unsub();
-			unsub = undefined;
-		} else shouldUnsub = true;
-	};
-	unsub = source.subscribe((msgs) => {
-		if (ctrl.signal.aborted) return;
-		for (const m of msgs) {
-			if (m[0] === DATA && m[1] === true) {
-				ctrl.abort(reason);
-				done();
-				return;
-			}
-			if (m[0] === ERROR) {
-				// Treat an ERROR on the abort source as a cancel signal too —
-				// a broken control channel should fail closed, not leak the
-				// in-flight call. Use the error as the abort reason.
-				ctrl.abort(m[1]);
-				done();
-				return;
-			}
-			if (m[0] === COMPLETE) {
-				// Source completed without aborting — no-op. `done()` already
-				// released the subscription here, so a later `dispose()` call
-				// from the caller is a no-op (safe / idempotent).
-				done();
-				return;
-			}
-		}
-	});
-	if (shouldUnsub) {
-		unsub?.();
-		unsub = undefined;
-	}
-	return {
-		signal: ctrl.signal,
-		dispose: () => {
-			if (unsub) {
-				unsub();
-				unsub = undefined;
-			}
-		},
-	};
-}
-
-// ---------------------------------------------------------------------------
-// reactiveCounter
-// ---------------------------------------------------------------------------
-
-/** Bundle returned by {@link reactiveCounter}. */
-export type ReactiveCounterBundle = {
-	/** Reactive node holding the current count. */
-	readonly node: Node<number>;
-	/** Increment by 1. Returns `false` if cap would be exceeded. */
-	increment(): boolean;
-	/** Current count (synchronous read). */
-	get(): number;
-	/** Whether the counter has reached its cap. */
-	atCap(): boolean;
-};
-
-/**
- * Reactive counter with a cap — the building block for circuit breakers.
- *
- * Wraps a `state(0)` node with `increment()` that respects a maximum.
- * The `node` is subscribable and composable like any reactive node. When
- * the cap is reached, `increment()` returns `false`.
- *
- * ```ts
- * const retries = reactiveCounter(10);
- * retries.increment(); // true — count is now 1
- * retries.node.subscribe(...); // reactive updates
- * retries.atCap(); // false
- * ```
- *
- * @param cap - Maximum value (inclusive). 0 = no increments allowed.
- * @category extra
- */
-export function reactiveCounter(cap: number): ReactiveCounterBundle {
-	const counter = node([], { initial: 0 });
-	return {
-		node: counter,
-		increment() {
-			const current = counter.cache ?? 0;
-			if (current >= cap) return false;
-			counter.down([[DIRTY], [DATA, current + 1]]);
-			return true;
-		},
-		get() {
-			return counter.cache ?? 0;
-		},
-		atCap() {
-			return (counter.cache ?? 0) >= cap;
-		},
-	};
-}
diff --git a/src/base/utils/decay.ts b/src/base/utils/decay.ts
deleted file mode 100644
index 7aeaba3e..00000000
--- a/src/base/utils/decay.ts
+++ /dev/null
@@ -1,48 +0,0 @@
-/**
- * Pure exponential-decay utility (Tier 2.2 promotion from `patterns/memory/`).
- *
- * Used by `collection`, `agentMemory`, harness `strategy.ts`, and any
- * downstream consumer that needs decay-with-floor scoring. Promoted to
- * `extra/utils/` because the math has zero domain semantics and is reusable
- * by non-memory primitives (e.g. routing weight decay, retry-attempt aging).
- *
- * @module
- */
-
-/**
- * Default exponential-decay rate corresponding to a 7-day half-life.
- *
- * `Math.LN2 / (7 × 86_400)` ≈ `1.146e-6`. Imported by memory tiers + any
- * consumer that wants the same default cadence as `agentMemory`'s active
- * tier. Tier 4.4 (Wave AM Unit 1) — promoted from
- * `patterns/ai/memory/tiers.ts` so non-memory consumers can share the
- * canonical default without reaching across domains.
- */
-export const DEFAULT_DECAY_RATE = Math.LN2 / (7 * 86_400);
-
-/**
- * Exponential decay with floor: `score = max(minScore, baseScore * exp(-ratePerSecond * ageSeconds))`.
- *
- * Tolerant fallbacks (deliberate for use inside reactive derived fns):
- * - non-finite `baseScore` → `minScore`
- * - non-positive `ageSeconds` (incl. clock skew) → `max(minScore, baseScore)` (no decay)
- * - non-positive `ratePerSecond` → `max(minScore, baseScore)` (no decay; rate=0 disables)
- *
- * Underflow boundary: `Math.exp(-745) === 0`. For very long ages × rates the
- * result clamps to `minScore`; if you need slow decay over years, choose a
- * smaller `ratePerSecond` rather than relying on graceful underflow.
- *
- * Half-life conversion: `ratePerSecond = Math.LN2 / halfLifeSeconds`.
- */
-export function decay(
-	baseScore: number,
-	ageSeconds: number,
-	ratePerSecond: number,
-	minScore = 0,
-): number {
-	if (!Number.isFinite(baseScore)) return minScore;
-	if (!Number.isFinite(ageSeconds) || ageSeconds <= 0) return Math.max(minScore, baseScore);
-	if (!Number.isFinite(ratePerSecond) || ratePerSecond <= 0) return Math.max(minScore, baseScore);
-	const decayed = baseScore * Math.exp(-ratePerSecond * ageSeconds);
-	return Math.max(minScore, decayed);
-}
diff --git a/src/base/utils/index.ts b/src/base/utils/index.ts
deleted file mode 100644
index 867f573d..00000000
--- a/src/base/utils/index.ts
+++ /dev/null
@@ -1,7 +0,0 @@
-/**
- * Base utils — domain-agnostic helper functions (decay, etc.).
- *
- * @module
- */
-
-export * from "./decay.js";
diff --git a/src/base/validate-observability.ts b/src/base/validate-observability.ts
deleted file mode 100644
index 2be41b80..00000000
--- a/src/base/validate-observability.ts
+++ /dev/null
@@ -1,302 +0,0 @@
-/**
- * Graph observability validation — smoke-exercise helper (D4).
- *
- * One library-level utility that walks every observability surface the library
- * ships — `describe()`, `explain(from, to)`, `observe(path)` — and reports
- * failures as a structured result. Non-throwing by default; composable into
- * example dry-run paths, CI smoke tests, and MCP reduce-path validators.
- *
- * **Motivation.** Dry-run equivalence (CLAUDE.md) requires every observability
- * call the real run exercises to also run under dry-run. Previously each
- * example reimplemented the walk (inbox-reducer caught a `describe()`
- * dangling-pointer bug only after adding an ad-hoc `graph.explain` check).
- * This utility centralizes the smoke-exercise so regressions in
- * `describe` / `explain` / `observe` surface BEFORE any wire spend.
- *
- * **Non-goals.** Not a deep correctness check. `describe()` structural
- * invariants (dangling deps, duplicate paths) are what this catches; actual
- * data assertions belong in application tests.
- *
- * @module
- */
-
-import type { Graph, GraphDescribeOutput } from "@graphrefly/pure-ts/graph";
-import type { CausalChain } from "@graphrefly/pure-ts/graph/explain.js";
-import {
-	graphSpecToAscii,
-	graphSpecToD2,
-	graphSpecToJson,
-	graphSpecToMermaid,
-	graphSpecToMermaidUrl,
-	graphSpecToPretty,
-} from "./render/index.js";
-
-/** Describe render formats exercised by {@link validateGraphObservability}. */
-export type ObservabilityDescribeFormat =
-	| "json"
-	| "pretty"
-	| "mermaid"
-	| "mermaid-url"
-	| "d2"
-	| "ascii";
-
-const FORMAT_RENDERERS: Record<ObservabilityDescribeFormat, (g: GraphDescribeOutput) => string> = {
-	json: (g) => graphSpecToJson(g),
-	pretty: (g) => graphSpecToPretty(g),
-	mermaid: (g) => graphSpecToMermaid(g),
-	"mermaid-url": (g) => graphSpecToMermaidUrl(g),
-	d2: (g) => graphSpecToD2(g),
-	ascii: (g) => graphSpecToAscii(g),
-};
-
-/** One observability check performed by {@link validateGraphObservability}. */
-export type ObservabilityCheck =
-	/** `describe()` was exercised and its structural invariants (nodes ⊇ deps) held. */
-	| { kind: "describe"; ok: true; nodeCount: number; edgeCount: number }
-	| { kind: "describe"; ok: false; reason: string; danglingDeps?: readonly string[] }
-	/** A `graphSpecTo*` renderer was exercised and produced non-empty output. */
-	| { kind: "describe-format"; ok: true; format: ObservabilityDescribeFormat; length: number }
-	| {
-			kind: "describe-format";
-			ok: false;
-			format: ObservabilityDescribeFormat;
-			reason: string;
-	  }
-	/** `observe(path)` succeeded / failed. `path` is the requested path. */
-	| { kind: "observe"; ok: true; path: string }
-	| { kind: "observe"; ok: false; path: string; reason: string }
-	/** `explain(from, to)` succeeded / failed. `found` is the chain's found flag. */
-	| { kind: "explain"; ok: true; from: string; to: string; found: boolean; steps: number }
-	| { kind: "explain"; ok: false; from: string; to: string; reason: string };
-
-/** Structured result returned by {@link validateGraphObservability}. */
-export interface ValidateObservabilityResult {
-	/** `true` iff every performed check passed (`ok: true`). */
-	readonly ok: boolean;
-	/** All checks performed, in the order they ran. */
-	readonly checks: readonly ObservabilityCheck[];
-	/** Convenience — checks with `ok: false`. */
-	readonly failures: readonly ObservabilityCheck[];
-	/** Single-line summary (e.g. for `process.stderr`). */
-	summary(): string;
-}
-
-/** Options for {@link validateGraphObservability}. */
-export interface ValidateObservabilityOptions {
-	/**
-	 * Paths to exercise via `graph.observe(path)`. Each path is resolved against
-	 * the same path grammar `graph.observe` / `graph.resolve` use. Non-existent
-	 * paths are reported as observe failures.
-	 */
-	readonly paths?: readonly string[];
-	/**
-	 * `(from, to)` pairs to exercise via `graph.describe({ explain: {from, to} })`.
-	 * Each pair records `found` and `steps`; a pair where `found === false` does
-	 * NOT fail the overall result — pass `requireFound: true` to tighten that.
-	 */
-	readonly pairs?: ReadonlyArray<readonly [from: string, to: string]>;
-	/**
-	 * When `true`, `explain` pairs that return `found: false` count as failures.
-	 * Default `true` — the common case is "assert this chain exists."
-	 */
-	readonly requireFound?: boolean;
-	/**
-	 * When `true`, skip the `describe()` structural check (nodes ⊇ deps).
-	 * Default `false`. Turn off only when your graph intentionally keeps
-	 * untracked deps (rare — COMPOSITION-GUIDE §24 argues against it).
-	 */
-	readonly skipDescribe?: boolean;
-	/**
-	 * Renderers to exercise on `graph.describe()`. Each format renders the
-	 * graph once via the matching `graphSpecTo*` pure function from
-	 * `@graphrefly/graphrefly/extra/render` and checks that the result is a
-	 * non-empty string. Useful in dry-run blocks so regressions in the render
-	 * paths (ascii, mermaid, pretty, json, d2, mermaid-url) surface before any
-	 * wire spend.
-	 */
-	readonly formats?: readonly ObservabilityDescribeFormat[];
-}
-
-/**
- * Exercise every observability surface on `graph` and report failures.
- *
- * Does NOT throw — returns a structured result so callers (dry-run blocks,
- * CLI smoke tests, MCP reduce-path validators) can exit non-zero with a
- * diagnostic instead of letting the process crash mid-inspection.
- *
- * @example
- * ```ts
- * const result = validateGraphObservability(graph, {
- *   paths: ["input", "output"],
- *   pairs: [["input", "output"]],
- * });
- * if (!result.ok) {
- *   console.error(result.summary());
- *   for (const f of result.failures) console.error(f);
- *   process.exit(3);
- * }
- * ```
- */
-export function validateGraphObservability(
-	graph: Graph,
-	opts: ValidateObservabilityOptions = {},
-): ValidateObservabilityResult {
-	const checks: ObservabilityCheck[] = [];
-	const requireFound = opts.requireFound ?? true;
-
-	// 1. describe() — structural invariant: every edge.from / edge.to / deps[]
-	//    entry resolves to a node in `nodes`.
-	if (opts.skipDescribe !== true) {
-		try {
-			const d = graph.describe();
-			const nodeKeys = new Set(Object.keys(d.nodes));
-			const dangling: string[] = [];
-			for (const [path, entry] of Object.entries(d.nodes)) {
-				for (const dep of entry.deps) {
-					if (dep !== "" && !nodeKeys.has(dep)) {
-						dangling.push(`${path} → ${dep}`);
-					}
-				}
-			}
-			for (const edge of d.edges) {
-				if (!nodeKeys.has(edge.from)) dangling.push(`edge.from: ${edge.from}`);
-				if (!nodeKeys.has(edge.to)) dangling.push(`edge.to: ${edge.to}`);
-			}
-			if (dangling.length > 0) {
-				checks.push({
-					kind: "describe",
-					ok: false,
-					reason: `describe() has ${dangling.length} dangling pointer(s); nodes ⊉ deps`,
-					danglingDeps: dangling,
-				});
-			} else {
-				checks.push({
-					kind: "describe",
-					ok: true,
-					nodeCount: nodeKeys.size,
-					edgeCount: d.edges.length,
-				});
-			}
-		} catch (err) {
-			checks.push({
-				kind: "describe",
-				ok: false,
-				reason: `describe() threw: ${err instanceof Error ? err.message : String(err)}`,
-			});
-		}
-	}
-
-	// 1b. Renderers — exercise each requested render path once. Composes the
-	//     pure renderers from `extra/render` directly (Tier 2.1 A2 dropped
-	//     `describe({ format })`; renderers now consume the describe snapshot).
-	//     A regression in any renderer (e.g. mermaid producing empty output
-	//     after a refactor) surfaces here instead of on the paid run.
-	if ((opts.formats?.length ?? 0) > 0) {
-		const snapshot = graph.describe();
-		for (const format of opts.formats!) {
-			try {
-				const rendered = FORMAT_RENDERERS[format](snapshot);
-				if (typeof rendered !== "string" || rendered.length === 0) {
-					checks.push({
-						kind: "describe-format",
-						ok: false,
-						format,
-						reason: `${format} renderer returned empty or non-string output`,
-					});
-				} else {
-					checks.push({
-						kind: "describe-format",
-						ok: true,
-						format,
-						length: rendered.length,
-					});
-				}
-			} catch (err) {
-				checks.push({
-					kind: "describe-format",
-					ok: false,
-					format,
-					reason: err instanceof Error ? err.message : String(err),
-				});
-			}
-		}
-	}
-
-	// 2. observe(path) — path must resolve. `graph.resolve` throws on missing
-	//    path; that's the only signal we need. We deliberately do NOT
-	//    subscribe: waking a lazy producer (e.g. `fromTimer` / `fromPromise`)
-	//    just to probe resolvability would fire real side effects (timers,
-	//    HTTP requests) in a validation pass that should be observationally
-	//    inert.
-	for (const path of opts.paths ?? []) {
-		try {
-			graph.resolve(path);
-			checks.push({ kind: "observe", ok: true, path });
-		} catch (err) {
-			checks.push({
-				kind: "observe",
-				ok: false,
-				path,
-				reason: err instanceof Error ? err.message : String(err),
-			});
-		}
-	}
-
-	// 3. describe({explain: {...}}) — returns CausalChain. When `requireFound: true`
-	//    (default), a `found: false` result counts as a failure.
-	for (const [from, to] of opts.pairs ?? []) {
-		try {
-			const chain: CausalChain = graph.describe({ explain: { from, to } });
-			if (requireFound && chain.found === false) {
-				checks.push({
-					kind: "explain",
-					ok: false,
-					from,
-					to,
-					reason: `explain(${from} → ${to}) found no path${chain.reason ? `: ${chain.reason}` : ""}`,
-				});
-			} else {
-				checks.push({
-					kind: "explain",
-					ok: true,
-					from,
-					to,
-					found: chain.found,
-					steps: chain.steps.length,
-				});
-			}
-		} catch (err) {
-			checks.push({
-				kind: "explain",
-				ok: false,
-				from,
-				to,
-				reason: err instanceof Error ? err.message : String(err),
-			});
-		}
-	}
-
-	const failures = checks.filter((c): c is Extract<ObservabilityCheck, { ok: false }> => !c.ok);
-	const ok = failures.length === 0;
-	const paths = opts.paths?.length ?? 0;
-	const pairs = opts.pairs?.length ?? 0;
-	const formatCount = opts.formats?.length ?? 0;
-
-	return {
-		ok,
-		checks,
-		failures,
-		summary(): string {
-			const bits = [
-				opts.skipDescribe === true ? null : "describe",
-				formatCount > 0 ? `${formatCount} format${formatCount === 1 ? "" : "s"}` : null,
-				paths > 0 ? `${paths} observe path${paths === 1 ? "" : "s"}` : null,
-				pairs > 0 ? `${pairs} explain pair${pairs === 1 ? "" : "s"}` : null,
-			].filter((b): b is string => b != null);
-			const scope = bits.length > 0 ? bits.join(", ") : "describe-only";
-			return ok
-				? `validateGraphObservability: OK (${scope})`
-				: `validateGraphObservability: ${failures.length} failure(s) across ${scope}`;
-		},
-	};
-}
diff --git a/src/base/worker/bridge.ts b/src/base/worker/bridge.ts
deleted file mode 100644
index c9b873c6..00000000
--- a/src/base/worker/bridge.ts
+++ /dev/null
@@ -1,376 +0,0 @@
-/**
- * workerBridge — main-thread reactive node bridge to a worker.
- *
- * Creates proxy nodes for imported worker nodes, subscribes to exposed
- * nodes and sends values across the wire. Uses derived() + effect() for
- * natural batch coalescing via two-phase push + bitmask resolution.
- *
- * Wire filtering: graph-local signals ({@link isLocalOnly}) stay local;
- * DATA values go through the coalescing path; RESOLVED, COMPLETE, ERROR,
- * TEARDOWN, and unknown {@link Symbol.for} types go through the signal
- * subscription.
- *
- * Handshake:
- *   1. Main creates bridge, starts listening
- *   2. Worker sends { t: 'r', stores: { name: initialValue, ... } }
- *   3. Main creates proxy nodes, marks meta.status "connected"
- *   4. Main sends { t: 'i', stores: { name: currentValue, ... } }
- *   5. Bidirectional value flow begins
- */
-
-import {
-	batch,
-	DATA,
-	defaultConfig,
-	ERROR,
-	type Messages,
-	type Node,
-	type NodeSink,
-	node,
-	TEARDOWN,
-} from "@graphrefly/pure-ts/core";
-import { filter, first, fromTimer, map, merge } from "@graphrefly/pure-ts/extra";
-import type { BatchMessage, BridgeMessage } from "./protocol.js";
-import { deserializeError, nameToSignal, serializeError, signalToName } from "./protocol.js";
-import type { WorkerTransport } from "./transport.js";
-import { createTransport } from "./transport.js";
-
-// ---------------------------------------------------------------------------
-// Types
-// ---------------------------------------------------------------------------
-
-export interface WorkerBridgeOptions<
-	TExpose extends Record<string, Node<any>>,
-	TImport extends readonly string[],
-> {
-	/** Nodes to send to the worker. */
-	expose?: TExpose;
-	/** Node names the worker will provide. */
-	import?: TImport;
-	/** Per-node transferable extractors for zero-copy ArrayBuffer passing. */
-	transfer?: Partial<Record<keyof TExpose, (value: any) => Transferable[]>>;
-	/** Debug name. */
-	name?: string;
-	/**
-	 * Handshake timeout in milliseconds. If the worker doesn't send READY
-	 * within this window, `meta.status` transitions to `"closed"` and
-	 * `meta.error` is set. Default: no timeout.
-	 */
-	timeoutMs?: number;
-}
-
-/** Proxy nodes created from imported worker node names. */
-type ImportedNodes<T extends readonly string[]> = {
-	readonly [K in T[number]]: Node<any>;
-};
-
-export type WorkerBridge<
-	_TExpose extends Record<string, Node<any>>,
-	TImport extends readonly string[],
-> = ImportedNodes<TImport> & {
-	/** Connection status meta node. */
-	meta: {
-		status: Node<"connecting" | "connected" | "closed">;
-		error: Node<Error | null>;
-	};
-	/** Destroy the bridge: sends TEARDOWN, disconnects, terminates worker. */
-	destroy(): void;
-};
-
-// ---------------------------------------------------------------------------
-// Implementation
-// ---------------------------------------------------------------------------
-
-function isTransport(t: unknown): t is WorkerTransport {
-	return (
-		typeof t === "object" &&
-		t !== null &&
-		typeof (t as any).post === "function" &&
-		typeof (t as any).listen === "function"
-	);
-}
-
-export function workerBridge<
-	TExpose extends Record<string, Node<any>>,
-	TImport extends readonly string[],
->(
-	target: unknown | WorkerTransport,
-	opts: WorkerBridgeOptions<TExpose, TImport>,
-): WorkerBridge<TExpose, TImport> {
-	const transport = isTransport(target) ? target : createTransport(target);
-	const bridgeName = opts.name ?? "workerBridge";
-	const exposeEntries = Object.entries(opts.expose ?? {});
-	const importNames = (opts.import ?? []) as readonly string[];
-	const transferFns = opts.transfer ?? {};
-
-	// -- Meta: connection status -----------------------------------------------
-	const statusNode = node<"connecting" | "connected" | "closed">([], {
-		initial: "connecting",
-		name: `${bridgeName}::meta::status`,
-	});
-	const errorNode = node<Error | null>([], {
-		initial: null,
-		name: `${bridgeName}::meta::error`,
-	});
-
-	// -- Proxy nodes for imports (worker -> main) ------------------------------
-	const proxyNodes = new Map<string, Node<any>>();
-	const lastSeenImportVersions = new Map<string, number>();
-	for (const name of importNames) {
-		const proxy = node([], { initial: undefined, name: `${bridgeName}::${name}` });
-		proxyNodes.set(name, proxy);
-	}
-
-	// -- Send coalescing via raw `node` + `effect` -----------------------------
-	//
-	// Aggregator uses raw `node([deps], (data, a) => ...)` so it can inspect
-	// the full **wave-form** `data[i]`: a per-dep batch of DATA values emitted
-	// this wave (or `undefined` if the dep was silent). Deps whose `equals`
-	// absorb a repeat emission send `RESOLVED` instead of `DATA`, so silent
-	// slots correctly mean "no change" and are omitted from the wire message.
-	//
-	// Net effect: no `.cache` reads inside fn, no `equals: () => false`, no
-	// closure `lastSent` Map — Option B shape under v5 semantics.
-	let effectUnsub: (() => void) | undefined;
-
-	if (exposeEntries.length > 0) {
-		const exposedNodes = exposeEntries.map(([, n]) => n) as Node[];
-
-		const aggregated = node<Record<string, unknown>>(
-			exposedNodes,
-			(data, a) => {
-				const updates: Record<string, unknown> = {};
-				for (let i = 0; i < exposeEntries.length; i++) {
-					const [name] = exposeEntries[i];
-					const batch0 = data[i];
-					if (batch0 != null && batch0.length > 0) {
-						updates[name] = batch0.at(-1);
-					}
-				}
-				if (Object.keys(updates).length === 0) return;
-				a.emit(updates);
-			},
-			// Each `updates` object is a fresh allocation, so default reference
-			// equality correctly propagates every aggregation wave — no
-			// `equals: () => false` override needed. `partial: true` opts out
-			// of the §2.7 first-run gate so the aggregator can fire on
-			// any-dep-settles waves (the worker may not expose all sources at
-			// the same time).
-			{ name: `${bridgeName}::aggregated`, partial: true },
-		);
-
-		const effectNode = node(
-			[aggregated],
-			(batchData, _actions, ctx) => {
-				const batch0 = batchData[0];
-				const data0 = batch0 != null && batch0.length > 0 ? batch0.at(-1) : ctx.prevData[0];
-				const updates = data0 as Record<string, unknown> | undefined;
-				if (updates == null || Object.keys(updates).length === 0) return undefined;
-
-				const transferList: Transferable[] = [];
-				for (const name of Object.keys(updates)) {
-					const fn = (transferFns as any)[name];
-					if (fn) transferList.push(...fn(updates[name]));
-				}
-
-				// V0 delta sync: include version counters when available (§6.0b).
-				let versions: Record<string, number> | undefined;
-				for (const [name, n] of exposeEntries) {
-					if (name in updates && n.v != null) {
-						if (versions == null) versions = {};
-						versions[name] = n.v.version;
-					}
-				}
-				const msg: BatchMessage = { t: "b", u: updates, ...(versions ? { v: versions } : {}) };
-				try {
-					transport.post(msg, transferList.length > 0 ? transferList : undefined);
-				} catch (err) {
-					errorNode.down([[DATA, err instanceof Error ? err : new Error(String(err))]]);
-				}
-				return undefined;
-			},
-			{ describeKind: "effect" },
-		);
-		// Effect nodes are lazy — subscribe to activate the chain
-		effectUnsub = effectNode.subscribe(() => {});
-	}
-
-	// -- Receive handler -------------------------------------------------------
-	let destroyed = false;
-
-	const unlisten = transport.listen((data) => {
-		if (destroyed) return;
-		const msg = data as BridgeMessage;
-
-		switch (msg.t) {
-			// Worker ready — set proxy nodes with initial values.
-			// The handshake deadline auto-cancels via the reactive race
-			// (`statusNode → "connected"` wins) — no explicit clearTimeout.
-			case "r": {
-				batch(() => {
-					for (const [name, value] of Object.entries(msg.stores)) {
-						const proxy = proxyNodes.get(name);
-						if (proxy) proxy.down([[DATA, value]]);
-					}
-				});
-				statusNode.down([[DATA, "connected"]]);
-
-				// Send initial values of exposed nodes.
-				// `.cache` here is a documented transport-boundary read: at the
-				// worker's "ready" moment we need a point-in-time snapshot of
-				// every exposed node, not a reactive wave. (§5.10 boundary.)
-				const initValues: Record<string, unknown> = {};
-				for (const [name, n] of exposeEntries) {
-					initValues[name] = n.cache;
-				}
-				transport.post({ t: "i", stores: initValues } satisfies BridgeMessage);
-				break;
-			}
-
-			// Single value update from worker
-			case "v": {
-				const proxy = proxyNodes.get(msg.s);
-				if (proxy) proxy.down([[DATA, msg.d]]);
-				break;
-			}
-
-			// Batch value update from worker
-			case "b": {
-				batch(() => {
-					for (const [name, value] of Object.entries(msg.u)) {
-						const incomingVersion = msg.v?.[name];
-						if (incomingVersion != null) {
-							const lastSeen = lastSeenImportVersions.get(name);
-							if (lastSeen != null && incomingVersion <= lastSeen) continue;
-							lastSeenImportVersions.set(name, incomingVersion);
-						}
-						const proxy = proxyNodes.get(name);
-						if (proxy) proxy.down([[DATA, value]]);
-					}
-				});
-				break;
-			}
-
-			// Error from worker node
-			case "e": {
-				const proxy = proxyNodes.get(msg.s);
-				if (proxy) proxy.down([[ERROR, deserializeError(msg.err)]]);
-				break;
-			}
-
-			// Lifecycle signal from worker
-			case "s": {
-				const sig = nameToSignal(msg.sig);
-				if (!sig) break;
-
-				const targets: Node<any>[] =
-					msg.s === "*"
-						? [...proxyNodes.values()]
-						: proxyNodes.has(msg.s)
-							? [proxyNodes.get(msg.s)!]
-							: [];
-
-				for (const proxy of targets) {
-					proxy.down((msg.d === undefined ? [[sig]] : [[sig, msg.d]]) as Messages);
-				}
-				break;
-			}
-		}
-	});
-
-	// -- Subscribe to exposed nodes: forward tier >= 3 messages -----------------
-	const exposeUnsubs: Array<() => void> = [];
-	for (const [name, n] of exposeEntries) {
-		const unsub = n.subscribe(((msgs: Messages) => {
-			if (destroyed) return;
-			for (const m of msgs) {
-				const type = m[0] as symbol;
-				// DATA goes through the coalescing path — skip here
-				if (type === DATA) continue;
-				// Block graph-local signals (START, DIRTY, INVALIDATE, PAUSE, RESUME).
-				// Unknown types forward (spec §1.3.6).
-				if (defaultConfig.isLocalOnly(type)) continue;
-				// ERROR: serialize payload
-				if (type === ERROR) {
-					transport.post({
-						t: "e",
-						s: name,
-						err: serializeError(m[1]),
-					} satisfies BridgeMessage);
-				} else {
-					// RESOLVED, COMPLETE, TEARDOWN, and unknown Symbol.for types
-					transport.post({
-						t: "s",
-						s: name,
-						sig: signalToName(type),
-						d: m.length > 1 ? m[1] : undefined,
-					} satisfies BridgeMessage);
-				}
-			}
-		}) as NodeSink);
-		exposeUnsubs.push(unsub);
-	}
-
-	// -- Handshake timeout — reactive race between status→"connected" and a
-	// one-shot `fromTimer` deadline. Whichever fires first wins via `first()`,
-	// which completes and auto-unsubs upstream (cancelling the deadline if
-	// ready arrived first, or vice-versa).
-	let handshakeUnsub: (() => void) | undefined;
-	if (opts.timeoutMs != null && opts.timeoutMs > 0) {
-		const deadline$ = fromTimer(opts.timeoutMs);
-		const ready$ = filter(statusNode, (s) => s === "connected");
-		const race$ = first(
-			merge(
-				map(deadline$, () => "timeout" as const),
-				map(ready$, () => "ready" as const),
-			),
-		);
-		handshakeUnsub = race$.subscribe((msgs) => {
-			for (const m of msgs) {
-				if (m[0] === DATA && m[1] === "timeout") {
-					errorNode.down([[DATA, new Error("Worker bridge handshake timeout")]]);
-					destroy();
-				}
-			}
-		});
-	}
-
-	// -- Build result object ---------------------------------------------------
-	function destroy() {
-		if (destroyed) return;
-		destroyed = true;
-
-		handshakeUnsub?.();
-
-		// Send bridge-level TEARDOWN to worker
-		transport.post({
-			t: "s",
-			s: "*",
-			sig: signalToName(TEARDOWN),
-		} satisfies BridgeMessage);
-
-		// Cleanup: unsub effect first (stops sending), then unsub expose
-		// listeners, then unlisten on transport
-		if (effectUnsub) effectUnsub();
-		for (const unsub of exposeUnsubs) unsub();
-		exposeUnsubs.length = 0;
-		unlisten();
-
-		statusNode.down([[DATA, "closed"]]);
-
-		lastSeenImportVersions.clear();
-		proxyNodes.clear();
-	}
-
-	const result: any = {
-		meta: { status: statusNode, error: errorNode },
-		destroy,
-	};
-
-	// Attach proxy nodes as properties
-	for (const [name, proxy] of proxyNodes) {
-		result[name] = proxy;
-	}
-
-	return result as WorkerBridge<TExpose, TImport>;
-}
diff --git a/src/base/worker/index.ts b/src/base/worker/index.ts
deleted file mode 100644
index 00a0098e..00000000
--- a/src/base/worker/index.ts
+++ /dev/null
@@ -1,17 +0,0 @@
-/** Worker bridge — reactive cross-thread communication (roadmap §5.3). */
-export type { WorkerBridge, WorkerBridgeOptions } from "./bridge.js";
-export { workerBridge } from "./bridge.js";
-export type {
-	BatchMessage,
-	BridgeMessage,
-	ErrorMessage,
-	InitMessage,
-	ReadyMessage,
-	SignalMessage,
-	ValueMessage,
-} from "./protocol.js";
-export { deserializeError, nameToSignal, serializeError, signalToName } from "./protocol.js";
-export type { WorkerSelfHandle, WorkerSelfOptions } from "./self.js";
-export { workerSelf } from "./self.js";
-export type { WorkerTransport } from "./transport.js";
-export { createTransport } from "./transport.js";
diff --git a/src/base/worker/protocol.ts b/src/base/worker/protocol.ts
deleted file mode 100644
index 75a1ac6e..00000000
--- a/src/base/worker/protocol.ts
+++ /dev/null
@@ -1,144 +0,0 @@
-/**
- * Wire protocol for worker bridge communication.
- *
- * Graph-local signals ({@link isLocalOnly}) stay local to each side's
- * reactive graph. DATA values cross via coalescing; RESOLVED/COMPLETE/TEARDOWN
- * as signals; ERROR as serialized payloads.
- *
- * Lifecycle signals serialize as string names since Symbols can't survive
- * structured clone. Unknown {@link Symbol.for} symbols are round-tripped
- * via their registered key.
- */
-
-import { COMPLETE, ERROR, INVALIDATE, PAUSE, RESUME, TEARDOWN } from "@graphrefly/pure-ts/core";
-
-// ---------------------------------------------------------------------------
-// Wire message types
-// ---------------------------------------------------------------------------
-
-/** Value update — one node changed. */
-export interface ValueMessage {
-	t: "v";
-	/** Node name. */
-	s: string;
-	/** Serialized value. */
-	d: unknown;
-}
-
-/** Lifecycle signal — serialized symbol name. */
-export interface SignalMessage {
-	t: "s";
-	/** Node name, or `"*"` for bridge-wide. */
-	s: string;
-	/** Signal name string (e.g. "TEARDOWN"). */
-	sig: string;
-	/** Optional payload for custom symbols (spec §1.3.6 forward unchanged). */
-	d?: unknown;
-}
-
-/** Ready — worker declares its exported nodes with initial values. */
-export interface ReadyMessage {
-	t: "r";
-	stores: Record<string, unknown>;
-}
-
-/** Init — main sends initial values of its exposed nodes. */
-export interface InitMessage {
-	t: "i";
-	stores: Record<string, unknown>;
-}
-
-/** Batch value update — multiple nodes changed in one reactive cycle. */
-export interface BatchMessage {
-	t: "b";
-	u: Record<string, unknown>;
-	/** V0 versions per node for delta sync — peer skips if version <= lastSeen (§6.0b). */
-	v?: Record<string, number>;
-}
-
-/** Error payload — serialized since Error objects don't survive structured clone. */
-export interface ErrorMessage {
-	t: "e";
-	/** Node name. */
-	s: string;
-	/** Serialized error. */
-	err: { message: string; name: string; stack?: string };
-}
-
-export type BridgeMessage =
-	| ValueMessage
-	| SignalMessage
-	| ReadyMessage
-	| InitMessage
-	| BatchMessage
-	| ErrorMessage;
-
-// ---------------------------------------------------------------------------
-// Signal serialization — Symbol <-> string for structured clone
-// ---------------------------------------------------------------------------
-
-const signalToNameMap = new Map<symbol, string>([
-	[INVALIDATE, "INVALIDATE"],
-	[PAUSE, "PAUSE"],
-	[RESUME, "RESUME"],
-	[TEARDOWN, "TEARDOWN"],
-	[COMPLETE, "COMPLETE"],
-	[ERROR, "ERROR"],
-]);
-
-const nameToSignalMap = new Map<string, symbol>([
-	["INVALIDATE", INVALIDATE],
-	["PAUSE", PAUSE],
-	["RESUME", RESUME],
-	["TEARDOWN", TEARDOWN],
-	["COMPLETE", COMPLETE],
-	["ERROR", ERROR],
-]);
-
-/**
- * Serialize a message type symbol to a string for structured clone transfer.
- *
- * Known GraphReFly symbols map to their canonical names. Unknown symbols
- * registered via {@link Symbol.for} use their registered key. Unregistered
- * symbols return `"UNKNOWN"`.
- */
-export function signalToName(s: symbol): string {
-	const known = signalToNameMap.get(s);
-	if (known) return known;
-	const key = Symbol.keyFor(s);
-	return key ?? "UNKNOWN";
-}
-
-/**
- * Deserialize a string back to a message type symbol.
- *
- * Known GraphReFly names map to their canonical symbols. Other non-empty
- * strings are reconstructed via {@link Symbol.for} (round-trip safe for
- * custom message types). Returns `undefined` for `"UNKNOWN"`.
- */
-export function nameToSignal(name: string): symbol | undefined {
-	const known = nameToSignalMap.get(name);
-	if (known) return known;
-	if (name && name !== "UNKNOWN") return Symbol.for(name);
-	return undefined;
-}
-
-/** Serialize an error for structured clone transfer. */
-export function serializeError(err: unknown): { message: string; name: string; stack?: string } {
-	if (err instanceof Error) {
-		return { message: err.message, name: err.name, stack: err.stack };
-	}
-	return { message: String(err), name: "Error" };
-}
-
-/** Deserialize an error payload back to an Error object. */
-export function deserializeError(payload: {
-	message: string;
-	name: string;
-	stack?: string;
-}): Error {
-	const err = new Error(payload.message);
-	err.name = payload.name;
-	if (payload.stack) err.stack = payload.stack;
-	return err;
-}
diff --git a/src/base/worker/self.ts b/src/base/worker/self.ts
deleted file mode 100644
index 4b8b6a85..00000000
--- a/src/base/worker/self.ts
+++ /dev/null
@@ -1,295 +0,0 @@
-/**
- * workerSelf — worker-side reactive node bridge.
- *
- * Mirror of workerBridge() for the worker side. Creates proxy nodes for
- * imports from main thread, exposes local nodes via the same wire protocol.
- * Uses derived() + effect() for batch coalescing.
- *
- * Wire filtering: graph-local signals ({@link isLocalOnly}) stay local;
- * DATA values go through the coalescing path; RESOLVED, COMPLETE, ERROR,
- * TEARDOWN, and unknown {@link Symbol.for} types go through the signal
- * subscription.
- *
- * Handshake (worker perspective):
- *   1. workerSelf() called — creates proxy nodes for imports
- *   2. Runs expose factory with proxy nodes -> gets nodes to expose
- *   3. Sends { t: 'r', stores: { name: initialValue, ... } } to main
- *   4. Receives { t: 'i', stores: { name: value, ... } } from main
- *   5. Updates proxy nodes -> triggers local effects
- */
-
-import {
-	batch,
-	DATA,
-	defaultConfig,
-	ERROR,
-	type Messages,
-	type Node,
-	type NodeSink,
-	node,
-	TEARDOWN,
-} from "@graphrefly/pure-ts/core";
-import type { BatchMessage, BridgeMessage } from "./protocol.js";
-import { deserializeError, nameToSignal, serializeError, signalToName } from "./protocol.js";
-import type { WorkerTransport } from "./transport.js";
-import { createTransport } from "./transport.js";
-
-// ---------------------------------------------------------------------------
-// Types
-// ---------------------------------------------------------------------------
-
-export interface WorkerSelfOptions<TImport extends readonly string[]> {
-	/** Node names that the main thread will provide. */
-	import?: TImport;
-	/** Factory that receives imported proxy nodes and returns nodes to expose. */
-	expose: (imported: WorkerImported<TImport>) => Record<string, Node<any>>;
-	/** Per-node transferable extractors for zero-copy ArrayBuffer passing. */
-	transfer?: Record<string, (value: any) => Transferable[]>;
-}
-
-/** Proxy nodes available inside the worker from main-thread exposed nodes. */
-type WorkerImported<T extends readonly string[]> = {
-	readonly [K in T[number]]: Node<any>;
-};
-
-export interface WorkerSelfHandle {
-	/** Dispose all subscriptions and stop the bridge. */
-	destroy(): void;
-}
-
-// ---------------------------------------------------------------------------
-// Implementation
-// ---------------------------------------------------------------------------
-
-function isTransport(t: unknown): t is WorkerTransport {
-	return (
-		typeof t === "object" &&
-		t !== null &&
-		typeof (t as any).post === "function" &&
-		typeof (t as any).listen === "function"
-	);
-}
-
-export function workerSelf<TImport extends readonly string[]>(
-	target: unknown | WorkerTransport,
-	opts: WorkerSelfOptions<TImport>,
-): WorkerSelfHandle {
-	const transport = isTransport(target) ? target : createTransport(target);
-	const importNames = (opts.import ?? []) as readonly string[];
-	const transferFns = opts.transfer ?? {};
-
-	// -- Proxy nodes for imports (main -> worker) ------------------------------
-	const proxyNodes = new Map<string, Node<any>>();
-	const lastSeenImportVersions = new Map<string, number>();
-	const importedObj: any = {};
-	for (const name of importNames) {
-		const s = node([], { initial: undefined, name: `worker::${name}` });
-		proxyNodes.set(name, s);
-		importedObj[name] = s;
-	}
-
-	// -- Run expose factory ----------------------------------------------------
-	const exposedNodes = opts.expose(importedObj as WorkerImported<TImport>);
-	const exposeEntries = Object.entries(exposedNodes);
-
-	// -- Send coalescing via raw `node` + `effect` ----------------------------
-	// See bridge.ts for the Option B rationale — raw `node([deps], fn)` with
-	// wave-form `data[]` replaces the prior `lastSent` diff + `.cache` reads.
-	let effectUnsub: (() => void) | undefined;
-	let destroyed = false;
-
-	if (exposeEntries.length > 0) {
-		const nodes = exposeEntries.map(([, n]) => n) as Node[];
-
-		const aggregated = node<Record<string, unknown>>(
-			nodes,
-			(data, a) => {
-				const updates: Record<string, unknown> = {};
-				for (let i = 0; i < exposeEntries.length; i++) {
-					const [name] = exposeEntries[i];
-					const batch0 = data[i];
-					if (batch0 != null && batch0.length > 0) {
-						updates[name] = batch0.at(-1);
-					}
-				}
-				if (Object.keys(updates).length === 0) return;
-				a.emit(updates);
-			},
-			// Fresh `updates` object per wave → default reference equality is
-			// correct; no `equals: () => false` override needed. `partial: true`
-			// opts out of the §2.7 first-run gate so the aggregator can fire on
-			// any-dep-settles waves (deps deliver asynchronously).
-			{ name: "workerSelf::aggregated", partial: true },
-		);
-
-		const effectNode = node(
-			[aggregated],
-			(batchData, _actions, ctx) => {
-				const batch0 = batchData[0];
-				const data0 = batch0 != null && batch0.length > 0 ? batch0.at(-1) : ctx.prevData[0];
-				if (destroyed) return undefined;
-				const updates = data0 as Record<string, unknown> | undefined;
-				if (updates == null || Object.keys(updates).length === 0) return undefined;
-
-				const transferList: Transferable[] = [];
-				for (const name of Object.keys(updates)) {
-					const fn = (transferFns as any)[name];
-					if (fn) transferList.push(...fn(updates[name]));
-				}
-
-				// V0 delta sync: include version counters when available (§6.0b).
-				let versions: Record<string, number> | undefined;
-				for (const [name, n] of exposeEntries) {
-					if (name in updates && n.v != null) {
-						if (versions == null) versions = {};
-						versions[name] = n.v.version;
-					}
-				}
-				const msg: BatchMessage = { t: "b", u: updates, ...(versions ? { v: versions } : {}) };
-				try {
-					transport.post(msg, transferList.length > 0 ? transferList : undefined);
-				} catch (_err) {
-					// Transport failure — bridge is likely destroyed; swallow
-				}
-				return undefined;
-			},
-			{ describeKind: "effect" },
-		);
-		// Effect nodes are lazy — subscribe to activate the chain
-		effectUnsub = effectNode.subscribe(() => {});
-	}
-
-	// -- Subscribe to exposed nodes: forward tier >= 3 messages -----------------
-	const exposeUnsubs: Array<() => void> = [];
-	for (const [name, n] of exposeEntries) {
-		const unsub = n.subscribe(((msgs: Messages) => {
-			if (destroyed) return;
-			for (const m of msgs) {
-				const type = m[0] as symbol;
-				// DATA goes through the coalescing path — skip here
-				if (type === DATA) continue;
-				// Block graph-local signals (START, DIRTY, INVALIDATE, PAUSE, RESUME).
-				// Unknown types forward (spec §1.3.6).
-				if (defaultConfig.isLocalOnly(type)) continue;
-				// ERROR: serialize payload
-				if (type === ERROR) {
-					transport.post({
-						t: "e",
-						s: name,
-						err: serializeError(m[1]),
-					} satisfies BridgeMessage);
-				} else {
-					// RESOLVED, COMPLETE, TEARDOWN, and unknown Symbol.for types
-					transport.post({
-						t: "s",
-						s: name,
-						sig: signalToName(type),
-						d: m.length > 1 ? m[1] : undefined,
-					} satisfies BridgeMessage);
-				}
-			}
-		}) as NodeSink);
-		exposeUnsubs.push(unsub);
-	}
-
-	// -- Receive handler -------------------------------------------------------
-	const unlisten = transport.listen((data) => {
-		if (destroyed) return;
-		const msg = data as BridgeMessage;
-
-		switch (msg.t) {
-			// Init from main — set proxy node values
-			case "i": {
-				batch(() => {
-					for (const [name, value] of Object.entries(msg.stores)) {
-						const proxy = proxyNodes.get(name);
-						if (proxy) proxy.down([[DATA, value]]);
-					}
-				});
-				break;
-			}
-
-			// Single value update from main
-			case "v": {
-				const proxy = proxyNodes.get(msg.s);
-				if (proxy) proxy.down([[DATA, msg.d]]);
-				break;
-			}
-
-			// Batch value update from main
-			case "b": {
-				batch(() => {
-					for (const [name, value] of Object.entries(msg.u)) {
-						const incomingVersion = msg.v?.[name];
-						if (incomingVersion != null) {
-							const lastSeen = lastSeenImportVersions.get(name);
-							if (lastSeen != null && incomingVersion <= lastSeen) continue;
-							lastSeenImportVersions.set(name, incomingVersion);
-						}
-						const proxy = proxyNodes.get(name);
-						if (proxy) proxy.down([[DATA, value]]);
-					}
-				});
-				break;
-			}
-
-			// Error from main node
-			case "e": {
-				const proxy = proxyNodes.get(msg.s);
-				if (proxy) proxy.down([[ERROR, deserializeError(msg.err)]]);
-				break;
-			}
-
-			// Lifecycle signal from main
-			case "s": {
-				const sig = nameToSignal(msg.sig);
-				if (!sig) break;
-
-				if (sig === TEARDOWN && msg.s === "*") {
-					destroy();
-					return;
-				}
-
-				const targets: Node<any>[] =
-					msg.s === "*"
-						? [...proxyNodes.values()]
-						: proxyNodes.has(msg.s)
-							? [proxyNodes.get(msg.s)!]
-							: [];
-
-				for (const proxy of targets) {
-					proxy.down((msg.d === undefined ? [[sig]] : [[sig, msg.d]]) as Messages);
-				}
-				break;
-			}
-		}
-	});
-
-	// -- Send ready message ----------------------------------------------------
-	// `.cache` is a documented transport-boundary snapshot read here — not a
-	// reactive access (§5.10 boundary).
-	const readyValues: Record<string, unknown> = {};
-	for (const [name, n] of exposeEntries) {
-		readyValues[name] = n.cache;
-	}
-	transport.post({ t: "r", stores: readyValues } satisfies BridgeMessage);
-
-	// -- Destroy ---------------------------------------------------------------
-	function destroy() {
-		if (destroyed) return;
-		destroyed = true;
-
-		// Cleanup: unsub effect first (stops sending), then expose listeners,
-		// then unlisten on transport
-		if (effectUnsub) effectUnsub();
-		for (const unsub of exposeUnsubs) unsub();
-		exposeUnsubs.length = 0;
-		unlisten();
-		transport.terminate?.();
-
-		lastSeenImportVersions.clear();
-		proxyNodes.clear();
-	}
-
-	return { destroy };
-}
diff --git a/src/base/worker/transport.ts b/src/base/worker/transport.ts
deleted file mode 100644
index 1f46397d..00000000
--- a/src/base/worker/transport.ts
+++ /dev/null
@@ -1,110 +0,0 @@
-/**
- * WorkerTransport — normalized message channel for all worker types.
- *
- * Abstracts Worker, SharedWorker, ServiceWorker, BroadcastChannel, and
- * MessagePort behind a uniform post/listen/terminate interface.
- */
-
-/** Normalized bidirectional message channel. */
-export interface WorkerTransport {
-	/** Send data to the other side. Optional transferables for zero-copy. */
-	post(data: unknown, transfer?: Transferable[]): void;
-	/** Listen for incoming messages. Returns unsubscribe function. */
-	listen(handler: (data: unknown) => void): () => void;
-	/** Terminate the connection (if supported by the underlying transport). */
-	terminate?(): void;
-}
-
-/**
- * Auto-detect transport type and create a normalized WorkerTransport.
- *
- * Supports:
- * - `Worker` — direct postMessage/onmessage
- * - `SharedWorker` — port-based postMessage/onmessage
- * - `ServiceWorker` — postMessage via controller, listen via navigator.serviceWorker
- * - `BroadcastChannel` — postMessage/onmessage (no Transferable support)
- * - `MessagePort` — direct postMessage/onmessage (worker-side SharedWorker port)
- */
-export function createTransport(target: unknown): WorkerTransport {
-	// MessagePort (SharedWorker port from inside the worker, or raw MessagePort)
-	if (typeof MessagePort !== "undefined" && target instanceof MessagePort) {
-		return {
-			post(data, transfer) {
-				target.postMessage(data, transfer ?? []);
-			},
-			listen(handler) {
-				const h = (e: MessageEvent) => handler(e.data);
-				target.addEventListener("message", h);
-				target.start();
-				return () => target.removeEventListener("message", h);
-			},
-			terminate() {
-				target.close();
-			},
-		};
-	}
-
-	// SharedWorker — use its port
-	if (typeof SharedWorker !== "undefined" && target instanceof SharedWorker) {
-		return createTransport(target.port);
-	}
-
-	// Web Worker
-	if (typeof Worker !== "undefined" && target instanceof Worker) {
-		return {
-			post(data, transfer) {
-				target.postMessage(data, transfer ?? []);
-			},
-			listen(handler) {
-				const h = (e: MessageEvent) => handler(e.data);
-				target.addEventListener("message", h);
-				return () => target.removeEventListener("message", h);
-			},
-			terminate() {
-				target.terminate();
-			},
-		};
-	}
-
-	// BroadcastChannel — no Transferable support
-	if (typeof BroadcastChannel !== "undefined" && target instanceof BroadcastChannel) {
-		return {
-			post(data, transfer?) {
-				if (transfer && transfer.length > 0) {
-					console.warn(
-						"[graphrefly] WorkerTransport: BroadcastChannel does not support Transferable objects. The transfer argument is ignored and objects will be cloned instead.",
-					);
-				}
-				target.postMessage(data);
-			},
-			listen(handler) {
-				const h = (e: MessageEvent) => handler(e.data);
-				target.addEventListener("message", h);
-				return () => target.removeEventListener("message", h);
-			},
-			terminate() {
-				target.close();
-			},
-		};
-	}
-
-	// ServiceWorker
-	if (typeof ServiceWorker !== "undefined" && target instanceof ServiceWorker) {
-		return {
-			post(data, transfer) {
-				target.postMessage(data, transfer ?? []);
-			},
-			listen(handler) {
-				const h = (e: MessageEvent) => {
-					if (e.source === target) handler(e.data);
-				};
-				navigator.serviceWorker.addEventListener("message", h);
-				return () => navigator.serviceWorker.removeEventListener("message", h);
-			},
-		};
-	}
-
-	throw new Error(
-		"createTransport: unsupported target type. Expected Worker, SharedWorker, ServiceWorker, BroadcastChannel, or MessagePort.",
-	);
-}
diff --git a/src/compat/index.ts b/src/compat/index.ts
deleted file mode 100644
index 85ee8cab..00000000
--- a/src/compat/index.ts
+++ /dev/null
@@ -1,18 +0,0 @@
-/**
- * Compat layer: compatibility wrappers for other state management libraries (Phase 5.1b).
- *
- * Framework adapters are optional peers. Install only what you use:
- * - `@graphrefly/graphrefly/compat/react` -> `react`, `react-dom`
- * - `@graphrefly/graphrefly/compat/vue` -> `vue`
- * - `@graphrefly/graphrefly/compat/svelte` -> `svelte`
- * - `@graphrefly/graphrefly/compat/solid` -> `solid-js`
- */
-export * as jotai from "./jotai/index.js";
-export * as nanostores from "./nanostores/index.js";
-export * as nestjs from "./nestjs/index.js";
-export * as react from "./react/index.js";
-export * as signals from "./signals/index.js";
-export * as solid from "./solid/index.js";
-export * as svelte from "./svelte/index.js";
-export * as vue from "./vue/index.js";
-export * as zustand from "./zustand/index.js";
diff --git a/src/compat/jotai/index.ts b/src/compat/jotai/index.ts
deleted file mode 100644
index 50c47d20..00000000
--- a/src/compat/jotai/index.ts
+++ /dev/null
@@ -1,225 +0,0 @@
-import {
-	autoTrackNode,
-	DATA,
-	ERROR,
-	type Messages,
-	type Node,
-	node,
-} from "@graphrefly/pure-ts/core";
-
-/**
- * Options for creating an atom.
- *
- * @category compat
- */
-export interface AtomOptions {
-	/** Optional identifier for the underlying node. */
-	name?: string;
-	/** Optional companion meta nodes. */
-	meta?: Record<string, unknown>;
-}
-
-/**
- * A read-only Jotai-compatible atom.
- *
- * @category compat
- */
-export interface ReadableAtom<T> {
-	/** Returns the current cached value. */
-	get(): T;
-	/** Subscribes to value changes. Returns an unsubscribe function. */
-	subscribe(callback: (value: T) => void): () => void;
-	/** Access to companion meta nodes. */
-	readonly meta: Record<string, Node>;
-	/** @internal The underlying GraphReFly node. */
-	_node: Node<T>;
-}
-
-/**
- * A writable Jotai-compatible atom.
- *
- * @category compat
- */
-export interface WritableAtom<T> extends ReadableAtom<T> {
-	/** Sets a new value. */
-	set(value: T): void;
-	/** Updates the value using a transformation function. */
-	update(fn: (current: T) => T): void;
-}
-
-/** Function type for reading other atoms inside a derived atom. */
-export type GetFn = <V>(a: ReadableAtom<V>) => V;
-/** Function type for writing to other atoms inside a writable derived atom. */
-export type SetFn = <V>(a: WritableAtom<V>, value: V) => void;
-
-/** Function that computes the atom's value. */
-export type ReadFn<T> = (get: GetFn) => T;
-/** Function that handles writes to the atom. */
-export type WriteFn<T> = (get: GetFn, set: SetFn, value: T) => void;
-
-/**
- * Creates a Jotai-compatible atom built on GraphReFly primitives.
- *
- * Supports three overloads:
- * 1. `atom(initial)` — Writable primitive atom (wraps `state()`).
- * 2. `atom(read)` — Read-only derived atom (wraps `dynamicNode()`).
- * 3. `atom(read, write)` — Writable derived atom.
- *
- * @param initialOrRead - Initial value or a read function.
- * @param writeOrOptions - Write function or options object.
- * @param options - Optional configuration.
- * @returns WritableAtom or ReadableAtom.
- *
- * @example
- * ```ts
- * const count = atom(0);
- * count.set(1);
- * const doubled = atom((get) => get(count)! * 2);
- * ```
- *
- * @category compat
- */
-export function atom<T>(initial: T, options?: AtomOptions): WritableAtom<T>;
-export function atom<T>(read: ReadFn<T>, options?: AtomOptions): ReadableAtom<T>;
-export function atom<T>(read: ReadFn<T>, write: WriteFn<T>, options?: AtomOptions): WritableAtom<T>;
-export function atom<T>(
-	initialOrRead: T | ReadFn<T>,
-	writeOrOptions?: WriteFn<T> | AtomOptions,
-	options?: AtomOptions,
-): ReadableAtom<T> | WritableAtom<T> {
-	if (typeof initialOrRead === "function") {
-		const read = initialOrRead as ReadFn<T>;
-		if (typeof writeOrOptions === "function") {
-			return createDerivedAtom(read, writeOrOptions as WriteFn<T>, options);
-		}
-		return createDerivedAtom(read, undefined, writeOrOptions as AtomOptions);
-	}
-
-	return createPrimitiveAtom(initialOrRead as T, writeOrOptions as AtomOptions);
-}
-
-function pull<T>(n: Node<T>): T {
-	let val: T | undefined | null = n.cache;
-	let err: any;
-	const unsub = n.subscribe((msgs: Messages) => {
-		for (const [t, v] of msgs) {
-			if (t === DATA) val = v as T;
-			if (t === ERROR) err = v;
-		}
-	});
-	unsub();
-	if (err) throw err;
-	return val as T;
-}
-
-function createPrimitiveAtom<T>(initial: T, options?: AtomOptions): WritableAtom<T> {
-	const n = node([], {
-		initial,
-		...options,
-		resubscribable: true,
-		resetOnTeardown: true,
-	});
-	return {
-		get: () => {
-			if (n.status === "sentinel") {
-				return pull(n);
-			}
-			return n.cache as T;
-		},
-		// Use `n.emit` (not raw `n.down`) so writes go through the framed
-		// emit pipeline: bundle() auto-prefixes DIRTY (diamond-safe wave
-		// coordination) and the equals check folds same-value writes to
-		// RESOLVED (no spurious subscriber fires).
-		set: (value: T) => n.emit(value),
-		update: (fn: (current: T) => T) => {
-			const current = n.status === "sentinel" ? pull(n) : (n.cache as T);
-			n.emit(fn(current));
-		},
-		subscribe: (cb: (value: T) => void) => {
-			// Skip the initial push-on-subscribe DATA — jotai subscribe fires on changes only.
-			let initial = true;
-			return n.subscribe((msgs: Messages) => {
-				for (const [t, v] of msgs) {
-					if (t === DATA) {
-						if (initial) {
-							initial = false;
-							continue;
-						}
-						cb(v as T);
-					}
-				}
-			});
-		},
-		meta: n.meta,
-		_node: n,
-	};
-}
-
-function createDerivedAtom<T>(
-	read: ReadFn<T>,
-	write?: WriteFn<T>,
-	options?: AtomOptions,
-): ReadableAtom<T> | WritableAtom<T> {
-	const n = autoTrackNode(
-		(track) =>
-			read(<V>(a: ReadableAtom<V>) => {
-				const dn = a._node;
-				if (dn.status === "sentinel") {
-					pull(dn);
-				}
-				return track(dn) as V;
-			}),
-		{
-			...options,
-			resubscribable: true,
-			resetOnTeardown: true,
-			// Jotai `atom(read)` consumers expect `read(get)` to return a
-			// well-typed `T`, not `undefined` from a freshly-discovered branch
-			// dep. Opt OUT of Lock 6.C′'s `partial:true` default — fn is
-			// gated until every tracked dep delivers DATA so `get(a)` always
-			// returns the atom's value.
-			partial: false,
-		},
-	);
-
-	const result: ReadableAtom<T> = {
-		get: () => {
-			if (n.status === "sentinel") {
-				return pull(n);
-			}
-			return n.cache as T;
-		},
-		subscribe: (cb: (value: T) => void) => {
-			// Skip the initial push-on-subscribe DATA — jotai subscribe fires on changes only.
-			let initial = true;
-			return n.subscribe((msgs: Messages) => {
-				for (const [t, v] of msgs) {
-					if (t === DATA) {
-						if (initial) {
-							initial = false;
-							continue;
-						}
-						cb(v as T);
-					}
-				}
-			});
-		},
-		meta: n.meta,
-		_node: n,
-	};
-
-	if (write) {
-		const getFn: GetFn = <V>(a: ReadableAtom<V>) => a.get();
-		const setFn: SetFn = <V>(a: WritableAtom<V>, value: V) => a.set(value);
-
-		const writable = result as WritableAtom<T>;
-		writable.set = (value: T) => write(getFn, setFn, value);
-		writable.update = (fn: (current: T) => T) => {
-			const current = n.status === "sentinel" ? pull(n) : (n.cache as T);
-			return write(getFn, setFn, fn(current));
-		};
-		return writable;
-	}
-
-	return result;
-}
diff --git a/src/compat/nanostores/index.ts b/src/compat/nanostores/index.ts
deleted file mode 100644
index 84999579..00000000
--- a/src/compat/nanostores/index.ts
+++ /dev/null
@@ -1,322 +0,0 @@
-import {
-	batch,
-	DATA,
-	dynamicNode,
-	ERROR,
-	type Messages,
-	type Node,
-	node,
-	type TrackFn,
-} from "@graphrefly/pure-ts/core";
-
-/**
- * A Nanostores-compatible atom.
- *
- * @category compat
- */
-export interface NanoAtom<T> {
-	/** Get current value. */
-	get(): T;
-	/** Set a new value (writable atoms only). */
-	set(value: T): void;
-	/** Subscribe to value changes. Callback receives the new value.
-	 * Returns unsubscribe function. Called immediately with current value. */
-	subscribe(cb: (value: T) => void): () => void;
-	/** Listen to value changes (no immediate call). Returns unsubscribe. */
-	listen(cb: (value: T) => void): () => void;
-	/** The underlying GraphReFly node. */
-	readonly _node: Node<T>;
-}
-
-/**
- * A Nanostores-compatible computed store.
- *
- * @category compat
- */
-export interface NanoComputed<T> {
-	/** Get current value. */
-	get(): T;
-	/** Subscribe to value changes. Called immediately with current value.
-	 * Returns unsubscribe function. */
-	subscribe(cb: (value: T) => void): () => void;
-	/** Listen to value changes (no immediate call). Returns unsubscribe. */
-	listen(cb: (value: T) => void): () => void;
-	/** The underlying GraphReFly node. */
-	readonly _node: Node<T>;
-}
-
-/**
- * A Nanostores-compatible map.
- *
- * @category compat
- */
-export interface NanoMap<T extends Record<string, unknown>> extends NanoAtom<T> {
-	/** Set a single key. */
-	setKey<K extends keyof T>(key: K, value: T[K]): void;
-}
-
-const START_LISTENERS = new WeakMap<Node<any>, Set<() => void>>();
-const STOP_LISTENERS = new WeakMap<Node<any>, Set<() => void>>();
-
-function trigger(node: Node<any>, map: WeakMap<Node<any>, Set<() => void>>) {
-	const callbacks = map.get(node);
-	if (callbacks) {
-		for (const cb of callbacks) cb();
-	}
-}
-
-function createStore<T>(node: Node<T>, extra: any = {}): any {
-	let listeners = 0;
-	const store = {
-		...extra,
-		get: () => getVal(node),
-		subscribe: (cb: (value: T) => void) => {
-			if (listeners === 0) trigger(node, START_LISTENERS);
-			listeners++;
-			// Push-on-subscribe delivers the initial value via DATA — no explicit cb() needed.
-			const sub = node.subscribe((msgs: Messages) => {
-				for (const [t, v] of msgs) {
-					if (t === DATA) cb(v as T);
-				}
-			});
-			return () => {
-				sub();
-				listeners--;
-				if (listeners === 0) trigger(node, STOP_LISTENERS);
-			};
-		},
-		listen: (cb: (value: T) => void) => {
-			if (listeners === 0) trigger(node, START_LISTENERS);
-			listeners++;
-			// Skip the initial push-on-subscribe DATA — listen() fires on changes only.
-			let initial = true;
-			const sub = node.subscribe((msgs: Messages) => {
-				for (const [t, v] of msgs) {
-					if (t === DATA) {
-						if (initial) {
-							initial = false;
-							continue;
-						}
-						cb(v as T);
-					}
-				}
-			});
-			return () => {
-				sub();
-				listeners--;
-				if (listeners === 0) trigger(node, STOP_LISTENERS);
-			};
-		},
-		_node: node,
-	};
-	return store;
-}
-
-function pull<T>(n: Node<T>): T {
-	let val: T | undefined | null = n.cache;
-	let err: any;
-	const unsub = n.subscribe((msgs: Messages) => {
-		for (const [t, v] of msgs) {
-			if (t === DATA) val = v as T;
-			if (t === ERROR) err = v;
-		}
-	});
-	unsub();
-	if (err) throw err;
-	return val as T;
-}
-
-function getVal<T>(n: Node<T>): T {
-	if (n.status === "sentinel") {
-		return pull(n);
-	}
-	return n.cache as T;
-}
-
-/**
- * Creates a nanostores-compatible atom.
- *
- * @param initial - Initial value.
- * @returns `NanoAtom<T>`
- *
- * @category compat
- */
-export function atom<T>(initial: T): NanoAtom<T> {
-	const n = node<T>([], {
-		initial,
-		resubscribable: true,
-		resetOnTeardown: true,
-	});
-
-	return createStore(n, {
-		// `n.emit` routes through the framed pipeline: `bundle()` auto-
-		// prefixes `[DIRTY]` (diamond-safe wave coordination) and the
-		// node's `equals` (default `Object.is`) folds same-value writes
-		// into `RESOLVED`. Matches nanostores' documented Object.is
-		// dedup semantics without any custom check.
-		set: (value: T) => n.emit(value),
-	});
-}
-
-/**
- * Creates a nanostores-compatible computed store.
- *
- * @param stores - One or more atoms/computed stores.
- * @param fn - Compute function.
- * @returns `NanoComputed<T>`
- *
- * @category compat
- */
-export function computed<T, A>(
-	storeA: NanoAtom<A> | NanoComputed<A>,
-	fn: (a: A) => T,
-): NanoComputed<T>;
-export function computed<T, A, B>(
-	stores: [NanoAtom<A> | NanoComputed<A>, NanoAtom<B> | NanoComputed<B>],
-	fn: (a: A, b: B) => T,
-): NanoComputed<T>;
-export function computed<T, A, B, C>(
-	stores: [
-		NanoAtom<A> | NanoComputed<A>,
-		NanoAtom<B> | NanoComputed<B>,
-		NanoAtom<C> | NanoComputed<C>,
-	],
-	fn: (a: A, b: B, c: C) => T,
-): NanoComputed<T>;
-export function computed<T>(stores: any, fn: (...args: any[]) => T): NanoComputed<T> {
-	const storeArray: Array<NanoAtom<any> | NanoComputed<any>> = Array.isArray(stores)
-		? stores
-		: [stores];
-
-	const depNodes = storeArray.map((s) => s._node);
-	const n = dynamicNode(
-		depNodes,
-		(track: TrackFn) => {
-			const vals = storeArray.map((s) => {
-				const node = s._node;
-				if (node.status === "sentinel") {
-					pull(node);
-				}
-				return track(node);
-			});
-			return fn(...vals);
-		},
-		{
-			resubscribable: true,
-			resetOnTeardown: true,
-			equals: Object.is as any,
-			// nanostores `computed` calls `fn(a, b, ...)` with the resolved dep
-			// values; producing `undefined` for not-yet-delivered deps would
-			// hand `fn` arguments it never expected (e.g. `NaN` from `undefined
-			// + 3`). Opt OUT of Lock 6.C′'s `partial:true` default — fn is
-			// gated until every dep delivers DATA, matching nanostores'
-			// store-shaped consumer contract.
-			partial: false,
-		},
-	);
-
-	return createStore(n);
-}
-
-/**
- * Creates a nanostores-compatible map.
- *
- * @param initial - Initial object value.
- * @returns `NanoMap<T>`
- *
- * @category compat
- */
-export function map<T extends Record<string, unknown>>(initial: T): NanoMap<T> {
-	const n = node<T>([], {
-		initial,
-		resubscribable: true,
-		resetOnTeardown: true,
-		equals: () => false,
-	});
-
-	return createStore(n, {
-		// `map`'s state node is configured with `equals: () => false`
-		// above, so every `emit` produces DATA (even for same-key same-
-		// value sets). The `emit` path is still required for diamond
-		// coordination (`[DIRTY]` auto-prefix via `bundle()`).
-		set: (value: T) => n.emit(value),
-		setKey: <K extends keyof T>(key: K, value: T[K]) => {
-			const current = getVal(n);
-			n.emit({ ...current, [key]: value });
-		},
-	});
-}
-
-/**
- * Returns the current value of the store.
- *
- * @category compat
- */
-export function getValue<T>(store: NanoAtom<T> | NanoComputed<T>): T {
-	return store.get();
-}
-
-/**
- * Adds a listener for the store start (first listener connected).
- *
- * @category compat
- */
-export function onStart(store: NanoAtom<any> | NanoComputed<any>, cb: () => void): void {
-	const node = store._node;
-	let callbacks = START_LISTENERS.get(node);
-	if (!callbacks) {
-		callbacks = new Set();
-		START_LISTENERS.set(node, callbacks);
-	}
-	callbacks.add(cb);
-}
-
-/**
- * Adds a listener for the store stop (last listener disconnected).
- *
- * @category compat
- */
-export function onStop(store: NanoAtom<any> | NanoComputed<any>, cb: () => void): void {
-	const node = store._node;
-	let callbacks = STOP_LISTENERS.get(node);
-	if (!callbacks) {
-		callbacks = new Set();
-		STOP_LISTENERS.set(node, callbacks);
-	}
-	callbacks.add(cb);
-}
-
-/**
- * Adds a listener for the store mount (first listener connected).
- *
- * @returns A cleanup function called when the last listener is removed.
- * @category compat
- */
-export function onMount(
-	store: NanoAtom<any> | NanoComputed<any>,
-	cb: () => (() => void) | undefined,
-): void {
-	onStart(store, () => {
-		const stop = cb();
-		if (typeof stop === "function") onStop(store, stop);
-	});
-}
-
-/**
- * Batches multiple store updates.
- *
- * @category compat
- */
-export function action<Args extends any[], Return>(
-	_store: NanoAtom<any> | NanoComputed<any>,
-	_name: string,
-	fn: (...args: Args) => Return,
-): (...args: Args) => Return {
-	return (...args: Args) => {
-		let result: any;
-		batch(() => {
-			result = fn(...args);
-		});
-		return result as Return;
-	};
-}
diff --git a/src/compat/nestjs/decorators.ts b/src/compat/nestjs/decorators.ts
deleted file mode 100644
index 240b8fb8..00000000
--- a/src/compat/nestjs/decorators.ts
+++ /dev/null
@@ -1,407 +0,0 @@
-// ---------------------------------------------------------------------------
-// NestJS decorators for GraphReFly DI, events, and scheduling.
-// ---------------------------------------------------------------------------
-// NOTE: esbuild (used by vitest/vite) uses TC39 Stage 3 decorators, not
-// legacy TypeScript experimental decorators. Method decorators receive
-// (value: DecoratorBoundMethod, context: ClassMethodDecoratorContext). We use
-// context.addInitializer() to register metadata when the class instance is
-// created, which runs before NestJS lifecycle hooks.
-// ---------------------------------------------------------------------------
-
-import { Inject } from "@nestjs/common";
-import {
-	GRAPHREFLY_REQUEST_GRAPH,
-	GRAPHREFLY_ROOT_GRAPH,
-	getGraphToken,
-	getNodeToken,
-} from "./tokens.js";
-
-/** Class constructor key for decorator registries and Nest `ModuleRef.get()`. */
-export type DecoratorHostConstructor = abstract new (...args: unknown[]) => unknown;
-
-/**
- * TC39 Stage 3 class method decorator first argument (the method itself).
- * Narrower than `Function` for Biome `noBannedTypes`.
- */
-export type DecoratorBoundMethod = (...args: unknown[]) => unknown;
-
-// ---------------------------------------------------------------------------
-// Global registries (populated by decorator initializers, read by explorer)
-// ---------------------------------------------------------------------------
-
-export interface OnGraphEventMeta {
-	nodeName: string;
-	methodKey: string | symbol;
-}
-
-export interface GraphIntervalMeta {
-	ms: number;
-	methodKey: string | symbol;
-}
-
-export interface GraphCronMeta {
-	expr: string;
-	methodKey: string | symbol;
-}
-
-/** Registry: constructor → event handler metadata. */
-export const EVENT_HANDLERS = new Map<DecoratorHostConstructor, OnGraphEventMeta[]>();
-/** Registry: constructor → interval metadata. */
-export const INTERVAL_HANDLERS = new Map<DecoratorHostConstructor, GraphIntervalMeta[]>();
-/** Registry: constructor → cron metadata. */
-export const CRON_HANDLERS = new Map<DecoratorHostConstructor, GraphCronMeta[]>();
-
-// ---------------------------------------------------------------------------
-// CQRS decorator metadata & registries (Phase 5.5 — CQRS replacement)
-// ---------------------------------------------------------------------------
-
-export interface CommandHandlerMeta {
-	cqrsName: string;
-	commandName: string;
-	methodKey: string | symbol;
-}
-
-export interface EventHandlerMeta {
-	cqrsName: string;
-	eventName: string;
-	methodKey: string | symbol;
-}
-
-export interface QueryHandlerMeta {
-	cqrsName: string;
-	projectionName: string;
-	methodKey: string | symbol;
-}
-
-export interface SagaHandlerMeta {
-	cqrsName: string;
-	eventNames: readonly string[];
-	sagaName: string;
-	methodKey: string | symbol;
-}
-
-/** Registry: constructor → command handler metadata. */
-export const COMMAND_HANDLERS = new Map<DecoratorHostConstructor, CommandHandlerMeta[]>();
-/** Registry: constructor → event handler metadata. */
-export const CQRS_EVENT_HANDLERS = new Map<DecoratorHostConstructor, EventHandlerMeta[]>();
-/** Registry: constructor → query handler metadata. */
-export const QUERY_HANDLERS = new Map<DecoratorHostConstructor, QueryHandlerMeta[]>();
-/** Registry: constructor → saga handler metadata. */
-export const SAGA_HANDLERS = new Map<DecoratorHostConstructor, SagaHandlerMeta[]>();
-
-// ---------------------------------------------------------------------------
-// DI decorators
-// ---------------------------------------------------------------------------
-
-/**
- * Inject a `Graph` instance into a NestJS service or controller.
- *
- * - No argument → injects the root graph (from `forRoot()`).
- * - With `name` → injects the named feature graph (from `forFeature({ name })`).
- * - With `"request"` → injects the request-scoped graph (requires `requestScope: true`).
- *
- * @example
- * ```ts
- * @Injectable()
- * export class PaymentService {
- *   constructor(
- *     @InjectGraph() private root: Graph,
- *     @InjectGraph("payments") private payments: Graph,
- *   ) {}
- * }
- * ```
- */
-export function InjectGraph(name?: string): ParameterDecorator & PropertyDecorator {
-	if (name === "request") return Inject(GRAPHREFLY_REQUEST_GRAPH);
-	return Inject(name ? getGraphToken(name) : GRAPHREFLY_ROOT_GRAPH);
-}
-
-/**
- * Inject a `CqrsGraph` instance into a NestJS service or controller.
- *
- * Typed alternative to `@InjectGraph(name)` — returns `CqrsGraph` instead of `Graph`,
- * giving access to `.command()`, `.dispatch()`, `.event()`, `.projection()`, `.saga()`.
- *
- * @param name - The CQRS graph name (from `forCqrs({ name })`).
- *
- * @example
- * ```ts
- * @Injectable()
- * export class OrderService {
- *   constructor(@InjectCqrsGraph("orders") private orders: CqrsGraph) {
- *     orders.dispatch("placeOrder", { id: "1" }); // fully typed
- *   }
- * }
- * ```
- */
-export function InjectCqrsGraph(name: string): ParameterDecorator & PropertyDecorator {
-	return Inject(getGraphToken(name));
-}
-
-/**
- * Inject a `Node` from the graph by its qualified path.
- *
- * The path must be declared in the `nodes` array of `forRoot()` or `forFeature()`.
- * The module registers a factory provider that resolves the node from the root graph
- * at injection time.
- *
- * @example
- * ```ts
- * GraphReflyModule.forRoot({ nodes: ["payment::validate"] })
- *
- * @Injectable()
- * export class PaymentService {
- *   constructor(@InjectNode("payment::validate") private validate: Node<boolean>) {}
- * }
- * ```
- */
-export function InjectNode(path: string): ParameterDecorator & PropertyDecorator {
-	return Inject(getNodeToken(path));
-}
-
-// ---------------------------------------------------------------------------
-// Event & schedule method decorators (TC39 Stage 3 decorator API)
-// ---------------------------------------------------------------------------
-
-/**
- * Subscribe a method to a graph node's DATA emissions — replaces `@OnEvent()`.
- *
- * The method is called with the value payload on each `DATA` message from the
- * named node. Routes through `graph.observe()` so actor guards are respected.
- * Subscription is created on module init and disposed on destroy.
- *
- * For full protocol access (DIRTY, COMPLETE, ERROR, custom types), use
- * `graph.observe()` directly instead of this decorator.
- *
- * @param nodeName - Qualified node path (e.g. `"orders::placed"`).
- *
- * @example
- * ```ts
- * @Injectable()
- * export class OrderService {
- *   @OnGraphEvent("orders::placed")
- *   handleOrder(value: Order) { ... }
- * }
- * ```
- */
-export function OnGraphEvent(
-	nodeName: string,
-): (value: DecoratorBoundMethod, context: ClassMethodDecoratorContext) => void {
-	return (_value: DecoratorBoundMethod, context: ClassMethodDecoratorContext) => {
-		const methodKey = context.name;
-		context.addInitializer(function (this: unknown) {
-			const ctor = (this as { constructor: DecoratorHostConstructor }).constructor;
-			const existing = EVENT_HANDLERS.get(ctor) ?? [];
-			existing.push({ nodeName, methodKey });
-			EVENT_HANDLERS.set(ctor, existing);
-		});
-	};
-}
-
-/**
- * Run a method on a fixed interval — replaces `@Interval()` from `@nestjs/schedule`.
- *
- * Backed by a `fromTimer` node added to the root graph as `__schedule__.<className>.<methodName>`.
- * Visible in `graph.describe()`, pausable via `graph.signal(name, [[PAUSE, lockId]])`.
- *
- * @param ms - Interval in milliseconds.
- *
- * @example
- * ```ts
- * @Injectable()
- * export class CleanupService {
- *   @GraphInterval(5000)
- *   pruneStale() { ... }
- * }
- * ```
- */
-export function GraphInterval(
-	ms: number,
-): (value: DecoratorBoundMethod, context: ClassMethodDecoratorContext) => void {
-	return (_value: DecoratorBoundMethod, context: ClassMethodDecoratorContext) => {
-		const methodKey = context.name;
-		context.addInitializer(function (this: unknown) {
-			const ctor = (this as { constructor: DecoratorHostConstructor }).constructor;
-			const existing = INTERVAL_HANDLERS.get(ctor) ?? [];
-			existing.push({ ms, methodKey });
-			INTERVAL_HANDLERS.set(ctor, existing);
-		});
-	};
-}
-
-/**
- * Run a method on a cron schedule — replaces `@Cron()` from `@nestjs/schedule`.
- *
- * Backed by a `fromCron` node added to the root graph as `__schedule__.<className>.<methodName>`.
- * Visible in `graph.describe()`, pausable via PAUSE/RESUME signals.
- *
- * @param expr - 5-field cron expression (`min hour dom month dow`).
- *
- * @example
- * ```ts
- * @Injectable()
- * export class ReportService {
- *   @GraphCron("0 9 * * 1")
- *   weeklyReport() { ... }
- * }
- * ```
- */
-export function GraphCron(
-	expr: string,
-): (value: DecoratorBoundMethod, context: ClassMethodDecoratorContext) => void {
-	return (_value: DecoratorBoundMethod, context: ClassMethodDecoratorContext) => {
-		const methodKey = context.name;
-		context.addInitializer(function (this: unknown) {
-			const ctor = (this as { constructor: DecoratorHostConstructor }).constructor;
-			const existing = CRON_HANDLERS.get(ctor) ?? [];
-			existing.push({ expr, methodKey });
-			CRON_HANDLERS.set(ctor, existing);
-		});
-	};
-}
-
-// ---------------------------------------------------------------------------
-// CQRS method decorators (Phase 5.5 — CQRS replacement)
-// ---------------------------------------------------------------------------
-
-/**
- * Register a method as a CQRS command handler — replaces `@CommandHandler()` from `@nestjs/cqrs`.
- *
- * The method receives `(payload, { emit })` — same signature as `CqrsGraph.command()` handlers.
- * Wired reactively via the explorer on module init.
- *
- * @param cqrsName - Name of the CQRS graph (from `forCqrs({ name })`).
- * @param commandName - Command to handle.
- *
- * @example
- * ```ts
- * @Injectable()
- * export class OrderService {
- *   @CommandHandler("orders", "placeOrder")
- *   handlePlace(payload: PlaceOrderDto, { emit }: CommandActions) {
- *     emit("orderPlaced", { orderId: payload.id, amount: payload.amount });
- *   }
- * }
- * ```
- */
-export function CommandHandler(
-	cqrsName: string,
-	commandName: string,
-): (value: DecoratorBoundMethod, context: ClassMethodDecoratorContext) => void {
-	return (_value: DecoratorBoundMethod, context: ClassMethodDecoratorContext) => {
-		const methodKey = context.name;
-		context.addInitializer(function (this: unknown) {
-			const ctor = (this as { constructor: DecoratorHostConstructor }).constructor;
-			const existing = COMMAND_HANDLERS.get(ctor) ?? [];
-			existing.push({ cqrsName, commandName, methodKey });
-			COMMAND_HANDLERS.set(ctor, existing);
-		});
-	};
-}
-
-/**
- * Subscribe a method to CQRS event stream DATA — replaces `@EventsHandler()` from `@nestjs/cqrs`.
- *
- * The method receives each `CqrsEvent` envelope as events arrive. Subscription is reactive
- * via `graph.observe()` — actor guards are respected.
- *
- * @param cqrsName - Name of the CQRS graph.
- * @param eventName - Event stream to subscribe to.
- *
- * @example
- * ```ts
- * @Injectable()
- * export class NotificationService {
- *   @EventHandler("orders", "orderPlaced")
- *   onOrderPlaced(event: CqrsEvent<{ orderId: string }>) {
- *     console.log("Order placed:", event.payload.orderId);
- *   }
- * }
- * ```
- */
-export function EventHandler(
-	cqrsName: string,
-	eventName: string,
-): (value: DecoratorBoundMethod, context: ClassMethodDecoratorContext) => void {
-	return (_value: DecoratorBoundMethod, context: ClassMethodDecoratorContext) => {
-		const methodKey = context.name;
-		context.addInitializer(function (this: unknown) {
-			const ctor = (this as { constructor: DecoratorHostConstructor }).constructor;
-			const existing = CQRS_EVENT_HANDLERS.get(ctor) ?? [];
-			existing.push({ cqrsName, eventName, methodKey });
-			CQRS_EVENT_HANDLERS.set(ctor, existing);
-		});
-	};
-}
-
-/**
- * Subscribe a method to CQRS projection changes — replaces `@QueryHandler()` from `@nestjs/cqrs`.
- *
- * The method is called reactively whenever the projection's value changes (DATA emission).
- * This is push-based, not request-response — the projection recomputes on upstream events.
- *
- * @param cqrsName - Name of the CQRS graph.
- * @param projectionName - Projection to observe.
- *
- * @example
- * ```ts
- * @Injectable()
- * export class DashboardService {
- *   @QueryHandler("orders", "orderCount")
- *   onCountChanged(count: number) {
- *     this.broadcast({ type: "orderCount", value: count });
- *   }
- * }
- * ```
- */
-export function QueryHandler(
-	cqrsName: string,
-	projectionName: string,
-): (value: DecoratorBoundMethod, context: ClassMethodDecoratorContext) => void {
-	return (_value: DecoratorBoundMethod, context: ClassMethodDecoratorContext) => {
-		const methodKey = context.name;
-		context.addInitializer(function (this: unknown) {
-			const ctor = (this as { constructor: DecoratorHostConstructor }).constructor;
-			const existing = QUERY_HANDLERS.get(ctor) ?? [];
-			existing.push({ cqrsName, projectionName, methodKey });
-			QUERY_HANDLERS.set(ctor, existing);
-		});
-	};
-}
-
-/**
- * Register a method as a CQRS saga — replaces RxJS saga streams from `@nestjs/cqrs`.
- *
- * The method receives each new `CqrsEvent` from the specified event streams. Backed by
- * `CqrsGraph.saga()` — tracks last-processed entry, only delivers new events.
- *
- * @param cqrsName - Name of the CQRS graph.
- * @param sagaName - Name for this saga node in the graph.
- * @param eventNames - Event streams to react to.
- *
- * @example
- * ```ts
- * @Injectable()
- * export class FulfillmentService {
- *   @SagaHandler("orders", "fulfillment", ["orderPlaced", "paymentConfirmed"])
- *   onOrderFlow(event: CqrsEvent) {
- *     if (event.type === "paymentConfirmed") this.shipOrder(event.payload);
- *   }
- * }
- * ```
- */
-export function SagaHandler(
-	cqrsName: string,
-	sagaName: string,
-	eventNames: readonly string[],
-): (value: DecoratorBoundMethod, context: ClassMethodDecoratorContext) => void {
-	return (_value: DecoratorBoundMethod, context: ClassMethodDecoratorContext) => {
-		const methodKey = context.name;
-		context.addInitializer(function (this: unknown) {
-			const ctor = (this as { constructor: DecoratorHostConstructor }).constructor;
-			const existing = SAGA_HANDLERS.get(ctor) ?? [];
-			existing.push({ cqrsName, eventNames, sagaName, methodKey });
-			SAGA_HANDLERS.set(ctor, existing);
-		});
-	};
-}
diff --git a/src/compat/nestjs/explorer.ts b/src/compat/nestjs/explorer.ts
deleted file mode 100644
index 8569b982..00000000
--- a/src/compat/nestjs/explorer.ts
+++ /dev/null
@@ -1,392 +0,0 @@
-// ---------------------------------------------------------------------------
-// GraphReflyEventExplorer — discovers @OnGraphEvent, @GraphInterval, @GraphCron
-// decorated methods and wires them to the root graph.
-// ---------------------------------------------------------------------------
-// Registered by `forRoot()`. On module init, reads global decorator registries,
-// resolves provider instances via ModuleRef, and creates reactive subscriptions
-// / timer nodes. On module destroy, disposes all subscriptions and removes
-// schedule nodes from the graph.
-//
-// Runtime is fully reactive — push-based via graph.observe().
-// No polling, no microtasks, no promises. Timer nodes use central fromTimer /
-// fromCron primitives.
-// ---------------------------------------------------------------------------
-
-import { DATA, type Messages } from "@graphrefly/pure-ts/core";
-import { fromTimer } from "@graphrefly/pure-ts/extra";
-import type { Graph, GraphObserveOne } from "@graphrefly/pure-ts/graph";
-import type { OnModuleDestroy, OnModuleInit } from "@nestjs/common";
-import type { ModuleRef } from "@nestjs/core";
-import { fromCron } from "../../base/sources/event/cron.js";
-import type { CqrsGraph } from "../../utils/cqrs/index.js";
-import {
-	COMMAND_HANDLERS,
-	type CommandHandlerMeta,
-	CQRS_EVENT_HANDLERS,
-	CRON_HANDLERS,
-	type DecoratorBoundMethod,
-	type DecoratorHostConstructor,
-	EVENT_HANDLERS,
-	type EventHandlerMeta,
-	type GraphCronMeta,
-	type GraphIntervalMeta,
-	INTERVAL_HANDLERS,
-	type OnGraphEventMeta,
-	QUERY_HANDLERS,
-	type QueryHandlerMeta,
-	SAGA_HANDLERS,
-	type SagaHandlerMeta,
-} from "./decorators.js";
-import { getGraphToken } from "./tokens.js";
-
-/** Monotonic counter for schedule node name disambiguation. */
-let scheduleSeq = 0;
-
-export class GraphReflyEventExplorer implements OnModuleInit, OnModuleDestroy {
-	private readonly disposers: Array<() => void> = [];
-	private readonly scheduleNodeNames: string[] = [];
-	// F-CATCH D-1 (qa F-b): de-dup the DI-miss warning. `resolveInstance` is
-	// called once per handler-registry that a host appears in (EVENT / CRON /
-	// CQRS / …), so an unresolvable host decorated in multiple families would
-	// otherwise emit one warning per registry for a single root cause. Scoped
-	// per explorer instance (one instance per module via the useFactory).
-	private readonly warnedUnresolved = new Set<DecoratorHostConstructor>();
-
-	constructor(
-		private readonly graph: Graph,
-		private readonly moduleRef: ModuleRef,
-	) {}
-
-	onModuleInit(): void {
-		this.wireEvents();
-		this.wireIntervals();
-		this.wireCrons();
-		this.wireCqrsCommands();
-		this.wireCqrsEvents();
-		this.wireCqrsQueries();
-		this.wireCqrsSagas();
-	}
-
-	onModuleDestroy(): void {
-		for (const dispose of this.disposers) dispose();
-		this.disposers.length = 0;
-
-		for (const name of this.scheduleNodeNames) {
-			try {
-				this.graph.remove(name);
-			} catch {
-				// Node may already be gone if graph.destroy() ran first.
-			}
-		}
-		this.scheduleNodeNames.length = 0;
-	}
-
-	// -----------------------------------------------------------------------
-	// @OnGraphEvent — reactive subscription via graph.observe()
-	// -----------------------------------------------------------------------
-
-	private wireEvents(): void {
-		for (const [ctor, metas] of EVENT_HANDLERS) {
-			const instance = this.resolveInstance(ctor);
-			if (!instance) continue;
-
-			for (const meta of metas) {
-				this.wireEventHandler(instance, meta);
-			}
-		}
-	}
-
-	private wireEventHandler(instance: object, meta: OnGraphEventMeta): void {
-		const method = (instance as Record<string | symbol, DecoratorBoundMethod>)[meta.methodKey];
-		if (typeof method !== "function") return;
-
-		const bound = method.bind(instance);
-
-		// Route through graph.observe() so actor guards are respected.
-		const handle = this.observeNode(meta.nodeName);
-		const unsub = handle.subscribe((msgs: Messages) => {
-			for (const m of msgs) {
-				if (m[0] === DATA) {
-					bound(m[1]);
-				}
-			}
-		});
-		this.disposers.push(unsub);
-	}
-
-	// -----------------------------------------------------------------------
-	// @GraphInterval — reactive via fromTimer central timer primitive
-	// -----------------------------------------------------------------------
-
-	private wireIntervals(): void {
-		for (const [ctor, metas] of INTERVAL_HANDLERS) {
-			const instance = this.resolveInstance(ctor);
-			if (!instance) continue;
-
-			for (const meta of metas) {
-				this.wireIntervalHandler(instance, ctor, meta);
-			}
-		}
-	}
-
-	private wireIntervalHandler(
-		instance: object,
-		ctor: DecoratorHostConstructor,
-		meta: GraphIntervalMeta,
-	): void {
-		const method = (instance as Record<string | symbol, DecoratorBoundMethod>)[meta.methodKey];
-		if (typeof method !== "function") return;
-
-		const bound = method.bind(instance);
-		const className = ctor.name ?? "anonymous";
-		const nodeName = `__schedule__.${className}.${String(meta.methodKey)}.${scheduleSeq++}`;
-
-		const timerNode = fromTimer(meta.ms, { period: meta.ms, name: nodeName });
-		this.graph.add(timerNode);
-		this.scheduleNodeNames.push(nodeName);
-
-		// Subscribe through graph.observe() for consistency.
-		const handle = this.observeNode(nodeName);
-		const unsub = handle.subscribe((msgs: Messages) => {
-			for (const m of msgs) {
-				if (m[0] === DATA) bound(m[1]);
-			}
-		});
-		this.disposers.push(unsub);
-	}
-
-	// -----------------------------------------------------------------------
-	// @GraphCron — reactive via fromCron central timer primitive
-	// -----------------------------------------------------------------------
-
-	private wireCrons(): void {
-		for (const [ctor, metas] of CRON_HANDLERS) {
-			const instance = this.resolveInstance(ctor);
-			if (!instance) continue;
-
-			for (const meta of metas) {
-				this.wireCronHandler(instance, ctor, meta);
-			}
-		}
-	}
-
-	private wireCronHandler(
-		instance: object,
-		ctor: DecoratorHostConstructor,
-		meta: GraphCronMeta,
-	): void {
-		const method = (instance as Record<string | symbol, DecoratorBoundMethod>)[meta.methodKey];
-		if (typeof method !== "function") return;
-
-		const bound = method.bind(instance);
-		const className = ctor.name ?? "anonymous";
-		const nodeName = `__schedule__.${className}.${String(meta.methodKey)}.${scheduleSeq++}`;
-
-		const cronNode = fromCron(meta.expr, { name: nodeName });
-		this.graph.add(cronNode);
-		this.scheduleNodeNames.push(nodeName);
-
-		// Subscribe through graph.observe() for consistency.
-		const handle = this.observeNode(nodeName);
-		const unsub = handle.subscribe((msgs: Messages) => {
-			for (const m of msgs) {
-				if (m[0] === DATA) bound(m[1]);
-			}
-		});
-		this.disposers.push(unsub);
-	}
-
-	// -----------------------------------------------------------------------
-	// @CommandHandler — register method as CqrsGraph command handler
-	// -----------------------------------------------------------------------
-
-	private wireCqrsCommands(): void {
-		for (const [ctor, metas] of COMMAND_HANDLERS) {
-			const instance = this.resolveInstance(ctor);
-			if (!instance) continue;
-
-			for (const meta of metas) {
-				this.wireCqrsCommand(instance, meta);
-			}
-		}
-	}
-
-	private wireCqrsCommand(instance: object, meta: CommandHandlerMeta): void {
-		const method = (instance as Record<string | symbol, DecoratorBoundMethod>)[meta.methodKey];
-		if (typeof method !== "function") return;
-
-		const bound = method.bind(instance);
-		const cqrsGraph = this.resolveCqrsGraph(meta.cqrsName);
-		if (!cqrsGraph) return;
-
-		cqrsGraph.command(meta.commandName, bound);
-	}
-
-	// -----------------------------------------------------------------------
-	// @EventHandler — subscribe method to CQRS event stream
-	// -----------------------------------------------------------------------
-
-	private wireCqrsEvents(): void {
-		for (const [ctor, metas] of CQRS_EVENT_HANDLERS) {
-			const instance = this.resolveInstance(ctor);
-			if (!instance) continue;
-
-			for (const meta of metas) {
-				this.wireCqrsEventHandler(instance, meta);
-			}
-		}
-	}
-
-	private wireCqrsEventHandler(instance: object, meta: EventHandlerMeta): void {
-		const method = (instance as Record<string | symbol, DecoratorBoundMethod>)[meta.methodKey];
-		if (typeof method !== "function") return;
-
-		const bound = method.bind(instance);
-		const cqrsGraph = this.resolveCqrsGraph(meta.cqrsName);
-		if (!cqrsGraph) return;
-
-		// Ensure the event stream exists.
-		cqrsGraph.event(meta.eventName);
-
-		// Snapshot the highest seq already in the log so we only deliver new events.
-		// Tracking by seq (monotonic per-graph) is robust against reactive log trim.
-		const eventNode = cqrsGraph.resolve(meta.eventName);
-		const existingEntries = eventNode.cache as readonly { seq: number }[] | undefined;
-		let lastSeq =
-			existingEntries && existingEntries.length > 0
-				? existingEntries[existingEntries.length - 1].seq
-				: 0;
-
-		// Subscribe reactively via graph.observe() — respects actor guards.
-		const handle = this.observeNodeOn(cqrsGraph, meta.eventName);
-		const unsub = handle.subscribe((msgs: Messages) => {
-			for (const m of msgs) {
-				if (m[0] === DATA) {
-					const entries = m[1] as readonly { seq: number }[];
-					for (const entry of entries) {
-						if (entry.seq > lastSeq) {
-							bound(entry);
-							lastSeq = entry.seq;
-						}
-					}
-				}
-			}
-		});
-		this.disposers.push(unsub);
-	}
-
-	// -----------------------------------------------------------------------
-	// @QueryHandler — subscribe method to CQRS projection changes
-	// -----------------------------------------------------------------------
-
-	private wireCqrsQueries(): void {
-		for (const [ctor, metas] of QUERY_HANDLERS) {
-			const instance = this.resolveInstance(ctor);
-			if (!instance) continue;
-
-			for (const meta of metas) {
-				this.wireCqrsQuery(instance, meta);
-			}
-		}
-	}
-
-	private wireCqrsQuery(instance: object, meta: QueryHandlerMeta): void {
-		const method = (instance as Record<string | symbol, DecoratorBoundMethod>)[meta.methodKey];
-		if (typeof method !== "function") return;
-
-		const bound = method.bind(instance);
-		const cqrsGraph = this.resolveCqrsGraph(meta.cqrsName);
-		if (!cqrsGraph) return;
-
-		// Subscribe reactively to the projection node — push on every DATA.
-		const handle = this.observeNodeOn(cqrsGraph, meta.projectionName);
-		const unsub = handle.subscribe((msgs: Messages) => {
-			for (const m of msgs) {
-				if (m[0] === DATA) {
-					bound(m[1]);
-				}
-			}
-		});
-		this.disposers.push(unsub);
-	}
-
-	// -----------------------------------------------------------------------
-	// @SagaHandler — register method as CqrsGraph saga (subgraph side effect)
-	// -----------------------------------------------------------------------
-
-	private wireCqrsSagas(): void {
-		for (const [ctor, metas] of SAGA_HANDLERS) {
-			const instance = this.resolveInstance(ctor);
-			if (!instance) continue;
-
-			for (const meta of metas) {
-				this.wireCqrsSaga(instance, meta);
-			}
-		}
-	}
-
-	private wireCqrsSaga(instance: object, meta: SagaHandlerMeta): void {
-		const method = (instance as Record<string | symbol, DecoratorBoundMethod>)[meta.methodKey];
-		if (typeof method !== "function") return;
-
-		const bound = method.bind(instance);
-		const cqrsGraph = this.resolveCqrsGraph(meta.cqrsName);
-		if (!cqrsGraph) return;
-
-		cqrsGraph.saga(meta.sagaName, meta.eventNames, bound);
-	}
-
-	// -----------------------------------------------------------------------
-	// Helpers
-	// -----------------------------------------------------------------------
-
-	private observeNode(name: string): GraphObserveOne {
-		// Overload resolution picks ObserveResult; cast to the correct single-node type.
-		return this.graph.observe(name) as unknown as GraphObserveOne;
-	}
-
-	private observeNodeOn(graph: Graph, name: string): GraphObserveOne {
-		return graph.observe(name) as unknown as GraphObserveOne;
-	}
-
-	private resolveCqrsGraph(name: string): CqrsGraph | null {
-		try {
-			return this.moduleRef.get(getGraphToken(name), { strict: false }) as CqrsGraph;
-		} catch {
-			console.warn(
-				`[GraphReFly] CqrsGraph "${name}" not found in DI — ` +
-					`did you import GraphReflyModule.forCqrs({ name: "${name}" })?`,
-			);
-			return null;
-		}
-	}
-
-	private resolveInstance(ctor: DecoratorHostConstructor): object | null {
-		// F-CATCH D-1: surface-loud, mirroring resolveCqrsGraph's diagnostic.
-		// A silent null here makes the caller `if (!instance) continue;` skip
-		// ALL of this class's @OnGraphEvent/@Cron/@CqrsHandler wiring with zero
-		// signal — a typo'd or unregistered provider then looks like the
-		// decorators "just don't fire". Cover BOTH failure shapes: `get` may
-		// throw (UnknownElementException) OR return a nullish value depending
-		// on the DI container, and both end in the same silent skip.
-		let instance: object | null = null;
-		try {
-			instance = this.moduleRef.get(ctor, { strict: false }) ?? null;
-		} catch {
-			instance = null;
-		}
-		if (instance == null) {
-			if (!this.warnedUnresolved.has(ctor)) {
-				this.warnedUnresolved.add(ctor);
-				const name = (ctor as { name?: string }).name ?? String(ctor);
-				console.warn(
-					`[GraphReFly] decorator host "${name}" not resolvable from DI — ` +
-						`is it registered as a provider in the same module as GraphReflyModule? ` +
-						`Its @OnGraphEvent/@Cron/@CqrsHandler handlers will NOT be wired.`,
-				);
-			}
-			return null;
-		}
-		return instance;
-	}
-}
diff --git a/src/compat/nestjs/gateway.ts b/src/compat/nestjs/gateway.ts
deleted file mode 100644
index e6d49254..00000000
--- a/src/compat/nestjs/gateway.ts
+++ /dev/null
@@ -1,621 +0,0 @@
-// ---------------------------------------------------------------------------
-// NestJS Gateway helpers — reactive bridges from graph.observe() to transports.
-// ---------------------------------------------------------------------------
-// All helpers are push-based: they subscribe to `graph.observe()` with actor
-// context and forward DATA messages to the transport. No polling.
-//
-// Actor-scoped observation respects node guards (Phase 1.5). Clients only
-// see DATA values from nodes their Actor is allowed to observe.
-// ---------------------------------------------------------------------------
-
-import {
-	type Actor,
-	COMPLETE,
-	DATA,
-	ERROR,
-	type Messages,
-	TEARDOWN,
-} from "@graphrefly/pure-ts/core";
-import type { Graph, GraphObserveOne } from "@graphrefly/pure-ts/graph";
-import {
-	createWatermarkController,
-	type WatermarkController,
-} from "../../base/composition/backpressure.js";
-
-// ---------------------------------------------------------------------------
-// Shared types
-// ---------------------------------------------------------------------------
-
-/**
- * Client-to-server commands for the WebSocket observe protocol.
- */
-export type ObserveWsCommand =
-	| { type: "subscribe"; path: string }
-	| { type: "unsubscribe"; path: string }
-	| { type: "ack"; path: string; count?: number };
-
-/**
- * Server-to-client messages for the WebSocket observe protocol.
- */
-export type ObserveWsMessage<T = unknown> =
-	| { type: "data"; path: string; value: T }
-	| { type: "error"; path: string; error: string }
-	| { type: "complete"; path: string }
-	| { type: "subscribed"; path: string }
-	| { type: "unsubscribed"; path: string }
-	| { type: "err"; message: string };
-
-// ---------------------------------------------------------------------------
-// observeSSE — graph.observe() → SSE ReadableStream
-// ---------------------------------------------------------------------------
-
-export type ObserveSSEOptions = {
-	actor?: Actor;
-	serialize?: (value: unknown) => string;
-	keepAliveMs?: number;
-	signal?: AbortSignal;
-	/** Pending DATA count at which PAUSE is sent upstream. Enables backpressure when set. */
-	highWaterMark?: number;
-	/** Pending DATA count at which RESUME is sent upstream. Defaults to `Math.floor(highWaterMark / 2)`. */
-	lowWaterMark?: number;
-};
-
-/**
- * Creates an SSE `ReadableStream` that streams DATA values from a graph node.
- *
- * Routes through `graph.observe(path, { actor })` so node guards are respected.
- * The stream emits `event: data` for DATA, `event: error` for ERROR, and
- * `event: complete` for COMPLETE (then closes). TEARDOWN also closes the stream.
- *
- * @param graph - The graph to observe.
- * @param path - Qualified node path to observe.
- * @param opts - Actor context, serialization, keep-alive.
- * @returns A `ReadableStream<Uint8Array>` suitable for NestJS SSE endpoints.
- *
- * @example
- * ```ts
- * @Sse("events/:path")
- * streamEvents(@Param("path") path: string, @Req() req: Request) {
- *   return observeSSE(this.graph, path, { actor: getActor(req) });
- * }
- * ```
- */
-export function observeSSE(
-	graph: Graph,
-	path: string,
-	opts?: ObserveSSEOptions,
-): ReadableStream<Uint8Array> {
-	const { actor, serialize = defaultSerialize, keepAliveMs, signal } = opts ?? {};
-	const encoder = new TextEncoder();
-	let stop: (() => void) | undefined;
-	const useBackpressure = opts?.highWaterMark != null;
-
-	let wm: WatermarkController | undefined;
-	let pullResolve: (() => void) | undefined;
-
-	// When backpressure is enabled we tag buffered entries so pull() only calls
-	// onDequeue for DATA frames (not keepalive, ERROR, or COMPLETE frames).
-	type BufEntry = { frame: Uint8Array; counted: boolean };
-	const taggedBuf: BufEntry[] = [];
-	let closed = false;
-
-	return new ReadableStream<Uint8Array>({
-		start(controller) {
-			let keepAlive: ReturnType<typeof setInterval> | undefined;
-			let unsub: () => void = () => {};
-			const close = () => {
-				if (closed) return;
-				closed = true;
-				if (keepAlive !== undefined) clearInterval(keepAlive);
-				signal?.removeEventListener("abort", onAbort);
-				// Unsub first to prevent further sink callbacks during dispose.
-				unsub();
-				wm?.dispose();
-				// Resolve any parked pull() promise so the stream can finish.
-				pullResolve?.();
-				pullResolve = undefined;
-				// Flush remaining buffered frames before closing.
-				for (const entry of taggedBuf) controller.enqueue(entry.frame);
-				taggedBuf.length = 0;
-				controller.close();
-			};
-			stop = close;
-			const onAbort = () => close();
-
-			const handle = graph.observe(path, { actor }) as unknown as GraphObserveOne;
-
-			if (useBackpressure) {
-				wm = createWatermarkController((msgs) => handle.up(msgs), {
-					highWaterMark: opts!.highWaterMark!,
-					lowWaterMark: opts!.lowWaterMark ?? Math.floor(opts!.highWaterMark! / 2),
-				});
-			}
-
-			unsub = handle.subscribe((msgs: Messages) => {
-				for (const msg of msgs) {
-					if (closed) return;
-					const t = msg[0];
-					if (t === DATA) {
-						const frame = encoder.encode(sseFrame("data", serialize(msg[1])));
-						if (useBackpressure) {
-							taggedBuf.push({ frame, counted: true });
-							wm!.onEnqueue();
-							pullResolve?.();
-							pullResolve = undefined;
-						} else {
-							controller.enqueue(frame);
-						}
-					} else if (t === ERROR) {
-						const frame = encoder.encode(sseFrame("error", serialize(msg[1])));
-						if (useBackpressure) {
-							taggedBuf.push({ frame, counted: false });
-							pullResolve?.();
-							pullResolve = undefined;
-						} else {
-							controller.enqueue(frame);
-						}
-						close();
-						return;
-					} else if (t === COMPLETE || t === TEARDOWN) {
-						if (t === COMPLETE) {
-							const frame = encoder.encode(sseFrame("complete"));
-							if (useBackpressure) {
-								taggedBuf.push({ frame, counted: false });
-								pullResolve?.();
-								pullResolve = undefined;
-							} else {
-								controller.enqueue(frame);
-							}
-						}
-						close();
-						return;
-					}
-					// DIRTY, RESOLVED, and other protocol internals are not exposed to SSE clients
-				}
-			});
-
-			if (keepAliveMs !== undefined && keepAliveMs > 0) {
-				keepAlive = setInterval(() => {
-					if (closed) return;
-					if (useBackpressure) {
-						// Keepalive frames bypass watermark accounting entirely.
-						taggedBuf.push({ frame: encoder.encode(": keepalive\n\n"), counted: false });
-						pullResolve?.();
-						pullResolve = undefined;
-					} else {
-						controller.enqueue(encoder.encode(": keepalive\n\n"));
-					}
-				}, keepAliveMs);
-			}
-			if (signal?.aborted) onAbort();
-			else signal?.addEventListener("abort", onAbort, { once: true });
-		},
-		pull(controller) {
-			if (!useBackpressure) return;
-			if (closed) return;
-			if (taggedBuf.length > 0) {
-				const entry = taggedBuf.shift()!;
-				controller.enqueue(entry.frame);
-				if (entry.counted) wm!.onDequeue();
-				return;
-			}
-			// No data available — park until the sink callback pushes more.
-			return new Promise<void>((resolve) => {
-				pullResolve = resolve;
-			});
-		},
-		cancel() {
-			// Guard against double-close (cancel may fire after COMPLETE/ERROR already closed).
-			try {
-				stop?.();
-			} catch {
-				/* already closed */
-			}
-		},
-	});
-}
-
-// ---------------------------------------------------------------------------
-// observeSubscription — graph.observe() → AsyncIterableIterator (GraphQL)
-// ---------------------------------------------------------------------------
-
-export type ObserveSubscriptionOptions<T = unknown> = {
-	actor?: Actor;
-	/**
-	 * Optional value filter. Only matching DATA values are enqueued.
-	 *
-	 * **Note:** `filter` and `highWaterMark` are semantically decoupled — the
-	 * watermark counts items that pass the filter, not total upstream work.
-	 * If the filter rejects most items, backpressure may never engage despite
-	 * high upstream throughput. For upstream-level resource protection, place a
-	 * filtering derived node in the graph before the observe point instead.
-	 */
-	filter?: (value: T) => boolean;
-	/** Pending DATA count at which PAUSE is sent upstream. Enables backpressure when set. */
-	highWaterMark?: number;
-	/** Pending DATA count at which RESUME is sent upstream. Defaults to `Math.floor(highWaterMark / 2)`. */
-	lowWaterMark?: number;
-};
-
-/**
- * Creates an `AsyncIterableIterator` that yields DATA values from a graph node.
- *
- * Designed for GraphQL subscription resolvers (Apollo, Mercurius, etc.).
- * Routes through `graph.observe(path, { actor })` for guard-scoped access.
- *
- * The iterator completes on COMPLETE/TEARDOWN and throws on ERROR.
- *
- * @param graph - The graph to observe.
- * @param path - Qualified node path to observe.
- * @param opts - Actor context, optional value filter.
- * @returns An async iterable that yields DATA payloads.
- *
- * @example
- * ```ts
- * // Apollo-style resolver
- * Subscription: {
- *   orderStatus: {
- *     subscribe: (_parent, args, ctx) =>
- *       observeSubscription(ctx.graph, `orders::${args.id}::status`, {
- *         actor: ctx.actor,
- *       }),
- *   },
- * }
- * ```
- */
-export function observeSubscription<T = unknown>(
-	graph: Graph,
-	path: string,
-	opts?: ObserveSubscriptionOptions<T>,
-): AsyncIterableIterator<T> {
-	const { actor, filter } = opts ?? {};
-
-	type QueueItem = { done: false; value: T } | { done: true; value?: undefined; error?: Error };
-
-	const queue: QueueItem[] = [];
-	const waiters: Array<{
-		resolve: (result: IteratorResult<T>) => void;
-		reject: (err: unknown) => void;
-	}> = [];
-	let disposed = false;
-
-	const handle = graph.observe(path, { actor }) as unknown as GraphObserveOne;
-
-	const wm =
-		opts?.highWaterMark != null
-			? createWatermarkController((msgs) => handle.up(msgs), {
-					highWaterMark: opts.highWaterMark,
-					lowWaterMark: opts.lowWaterMark ?? Math.floor(opts.highWaterMark / 2),
-				})
-			: undefined;
-
-	const dispose = () => {
-		if (disposed) return;
-		disposed = true;
-		wm?.dispose();
-		unsub();
-	};
-
-	const push = (item: QueueItem) => {
-		if (disposed) return;
-		if (waiters.length > 0) {
-			const w = waiters.shift()!;
-			if (item.done && item.error) w.reject(item.error);
-			else if (item.done) w.resolve({ done: true, value: undefined });
-			else w.resolve({ done: false, value: item.value as T });
-			// Direct handoff to waiter — no queue growth, no watermark increment.
-		} else {
-			queue.push(item);
-			if (!item.done) wm?.onEnqueue();
-		}
-	};
-
-	const unsub = handle.subscribe((msgs: Messages) => {
-		for (const msg of msgs) {
-			const t = msg[0];
-			if (t === DATA) {
-				const value = msg[1] as T;
-				if (filter && !filter(value)) continue;
-				push({ done: false, value });
-			} else if (t === ERROR) {
-				const err = msg[1] instanceof Error ? msg[1] : new Error(String(msg[1]));
-				push({ done: true, error: err });
-				dispose();
-				return;
-			} else if (t === COMPLETE || t === TEARDOWN) {
-				push({ done: true });
-				dispose();
-				return;
-			}
-		}
-	});
-
-	const iterator: AsyncIterableIterator<T> = {
-		next(): Promise<IteratorResult<T>> {
-			if (queue.length > 0) {
-				const item = queue.shift()!;
-				if (!item.done) wm?.onDequeue();
-				if (item.done && item.error) return Promise.reject(item.error);
-				return Promise.resolve(
-					item.done ? { done: true, value: undefined } : { done: false, value: item.value as T },
-				);
-			}
-			if (disposed) return Promise.resolve({ done: true, value: undefined });
-			return new Promise<IteratorResult<T>>((resolve, reject) => {
-				waiters.push({ resolve, reject });
-			});
-		},
-		return(): Promise<IteratorReturnResult<undefined>> {
-			dispose();
-			// Resolve any pending waiters
-			for (const w of waiters) w.resolve({ done: true, value: undefined });
-			waiters.length = 0;
-			return Promise.resolve({ done: true, value: undefined });
-		},
-		throw(err: unknown): Promise<IteratorResult<T>> {
-			dispose();
-			return Promise.reject(err);
-		},
-		[Symbol.asyncIterator]() {
-			return this;
-		},
-	};
-
-	return iterator;
-}
-
-// ---------------------------------------------------------------------------
-// ObserveGateway — graph.observe() → WebSocket (multi-path subscription)
-// ---------------------------------------------------------------------------
-
-export type ObserveGatewayOptions = {
-	extractActor?: (client: unknown) => Actor | undefined;
-	parse?: (data: string) => ObserveWsCommand;
-	/** Pending DATA count per subscription at which PAUSE is sent upstream. Enables backpressure when set. */
-	highWaterMark?: number;
-	/** Pending DATA count per subscription at which RESUME is sent upstream. Defaults to `Math.floor(highWaterMark / 2)`. */
-	lowWaterMark?: number;
-};
-
-/**
- * Manages per-client WebSocket subscriptions to graph nodes via `observe()`.
- *
- * Not a NestJS decorator or base class — a standalone helper that can be
- * wired into any WebSocket gateway. Each client can subscribe/unsubscribe
- * to individual node paths. Actor-scoped observation respects node guards.
- *
- * @example
- * ```ts
- * @WebSocketGateway()
- * export class GraphGateway {
- *   private gw = new ObserveGateway(this.graph);
- *
- *   constructor(@InjectGraph() private graph: Graph) {}
- *
- *   handleConnection(client: WebSocket) {
- *     this.gw.handleConnection(client);
- *   }
- *
- *   handleDisconnect(client: WebSocket) {
- *     this.gw.handleDisconnect(client);
- *   }
- *
- *   @SubscribeMessage("observe")
- *   onObserve(client: WebSocket, data: unknown) {
- *     this.gw.handleMessage(client, data);
- *   }
- * }
- * ```
- */
-export class ObserveGateway {
-	private readonly clients = new Map<
-		unknown,
-		Map<string, { unsub: () => void; wm?: WatermarkController }>
-	>();
-	private readonly extractActor: (client: unknown) => Actor | undefined;
-	private readonly parse: (data: string) => ObserveWsCommand;
-	private readonly highWaterMark: number | undefined;
-	private readonly lowWaterMark: number | undefined;
-
-	constructor(
-		private readonly graph: Graph,
-		opts?: ObserveGatewayOptions,
-	) {
-		this.extractActor = opts?.extractActor ?? (() => undefined);
-		this.parse = opts?.parse ?? defaultParseCommand;
-		this.highWaterMark = opts?.highWaterMark;
-		this.lowWaterMark = opts?.lowWaterMark;
-	}
-
-	/**
-	 * Register a new client. Call from `handleConnection`.
-	 */
-	handleConnection(client: unknown): void {
-		if (!this.clients.has(client)) {
-			this.clients.set(client, new Map());
-		}
-	}
-
-	/**
-	 * Unregister a client and dispose all its subscriptions. Call from `handleDisconnect`.
-	 */
-	handleDisconnect(client: unknown): void {
-		const subs = this.clients.get(client);
-		if (!subs) return;
-		for (const entry of subs.values()) {
-			entry.wm?.dispose();
-			entry.unsub();
-		}
-		this.clients.delete(client);
-	}
-
-	/**
-	 * Handle an incoming client message (subscribe/unsubscribe/ack command).
-	 *
-	 * @param client - The WebSocket client reference.
-	 * @param raw - Raw message data (string or parsed object).
-	 * @param send - Function to send a message back to the client.
-	 *   Defaults to `client.send(JSON.stringify(msg))`.
-	 */
-	handleMessage(client: unknown, raw: unknown, send?: (msg: ObserveWsMessage) => void): void {
-		const sender = send ?? defaultSend.bind(null, client);
-		let cmd: ObserveWsCommand;
-		try {
-			cmd = typeof raw === "string" ? this.parse(raw) : (raw as ObserveWsCommand);
-		} catch {
-			sender({ type: "err", message: "invalid command" });
-			return;
-		}
-
-		if (cmd.type === "subscribe") {
-			this.subscribe(client, cmd.path, sender);
-		} else if (cmd.type === "unsubscribe") {
-			this.unsubscribe(client, cmd.path, sender);
-		} else if (cmd.type === "ack") {
-			this.ack(client, cmd.path, cmd.count ?? 1);
-		} else {
-			sender({ type: "err", message: `unknown command type: ${(cmd as { type: string }).type}` });
-		}
-	}
-
-	/**
-	 * Number of active subscriptions for a client. Useful for tests.
-	 */
-	subscriptionCount(client: unknown): number {
-		return this.clients.get(client)?.size ?? 0;
-	}
-
-	/**
-	 * Dispose all clients and subscriptions.
-	 */
-	destroy(): void {
-		for (const [client] of this.clients) {
-			this.handleDisconnect(client);
-		}
-	}
-
-	// -----------------------------------------------------------------------
-	// Internal
-	// -----------------------------------------------------------------------
-
-	private subscribe(client: unknown, path: string, send: (msg: ObserveWsMessage) => void): void {
-		let subs = this.clients.get(client);
-		if (!subs) {
-			subs = new Map();
-			this.clients.set(client, subs);
-		}
-		if (subs.has(path)) {
-			send({ type: "subscribed", path });
-			return;
-		}
-
-		const actor = this.extractActor(client);
-		let handle: GraphObserveOne;
-		try {
-			handle = this.graph.observe(path, { actor }) as unknown as GraphObserveOne;
-		} catch (err) {
-			const message = err instanceof Error ? err.message : String(err);
-			send({ type: "err", message });
-			return;
-		}
-
-		const wm =
-			this.highWaterMark != null
-				? createWatermarkController((msgs) => handle.up(msgs), {
-						highWaterMark: this.highWaterMark,
-						lowWaterMark: this.lowWaterMark ?? Math.floor(this.highWaterMark / 2),
-					})
-				: undefined;
-
-		const cleanup = () => {
-			wm?.dispose();
-			unsub();
-			subs!.delete(path);
-		};
-
-		const unsub = handle.subscribe((msgs: Messages) => {
-			for (const msg of msgs) {
-				const t = msg[0];
-				if (t === DATA) {
-					wm?.onEnqueue();
-					trySend(send, { type: "data", path, value: msg[1] });
-				} else if (t === ERROR) {
-					const errMsg = msg[1] instanceof Error ? msg[1].message : String(msg[1]);
-					trySend(send, { type: "error", path, error: errMsg });
-					cleanup();
-					return;
-				} else if (t === COMPLETE || t === TEARDOWN) {
-					trySend(send, { type: "complete", path });
-					cleanup();
-					return;
-				}
-				// DIRTY, RESOLVED not exposed to WS clients
-			}
-		});
-
-		subs.set(path, { unsub, wm });
-		send({ type: "subscribed", path });
-	}
-
-	private unsubscribe(client: unknown, path: string, send: (msg: ObserveWsMessage) => void): void {
-		const subs = this.clients.get(client);
-		const entry = subs?.get(path);
-		if (entry) {
-			entry.wm?.dispose();
-			entry.unsub();
-			subs!.delete(path);
-		}
-		send({ type: "unsubscribed", path });
-	}
-
-	private ack(client: unknown, path: string, count: number): void {
-		const entry = this.clients.get(client)?.get(path);
-		if (!entry?.wm) return;
-		const n = Math.min(Math.max(0, Math.floor(count)), 1024);
-		for (let i = 0; i < n; i++) entry.wm.onDequeue();
-	}
-}
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-function defaultSerialize(value: unknown): string {
-	if (value instanceof Error) return value.message;
-	try {
-		return JSON.stringify(value);
-	} catch {
-		return String(value);
-	}
-}
-
-function sseFrame(event: string, data?: string): string {
-	let frame = `event: ${event}\n`;
-	if (data !== undefined) {
-		for (const line of data.split("\n")) {
-			frame += `data: ${line}\n`;
-		}
-	}
-	frame += "\n";
-	return frame;
-}
-
-function defaultParseCommand(data: string): ObserveWsCommand {
-	return JSON.parse(data) as ObserveWsCommand;
-}
-
-function defaultSend(client: unknown, msg: ObserveWsMessage): void {
-	try {
-		(client as { send: (data: string) => void }).send(JSON.stringify(msg));
-	} catch {
-		/* client may have disconnected — swallow transport errors */
-	}
-}
-
-function trySend(send: (msg: ObserveWsMessage) => void, msg: ObserveWsMessage): void {
-	try {
-		send(msg);
-	} catch {
-		/* transport error — client may have disconnected */
-	}
-}
diff --git a/src/compat/nestjs/guard.ts b/src/compat/nestjs/guard.ts
deleted file mode 100644
index 7f51fb1b..00000000
--- a/src/compat/nestjs/guard.ts
+++ /dev/null
@@ -1,166 +0,0 @@
-// ---------------------------------------------------------------------------
-// NestJS Actor bridge — maps NestJS ExecutionContext to GraphReFly Actor.
-// ---------------------------------------------------------------------------
-// Implements the NestJS `CanActivate` interface to extract an `Actor` from the
-// request (JWT payload, session, custom header, etc.) and attach it to the
-// request object for downstream graph operations.
-//
-// The decorator does NOT enforce access control — it merely bridges the NestJS
-// authentication context to GraphReFly's ABAC model. Actual access control
-// flows through node `policy()` guards reactively.
-// ---------------------------------------------------------------------------
-
-import { type Actor, DEFAULT_ACTOR, normalizeActor } from "@graphrefly/pure-ts/core";
-import type { CanActivate, ExecutionContext } from "@nestjs/common";
-
-/**
- * Property name under which the extracted {@link Actor} is stored on the
- * request object. Downstream code (controllers, gateways) reads
- * `req[ACTOR_KEY]` to pass actor context to graph operations.
- */
-export const ACTOR_KEY = "graphReflyActor" as const;
-
-/**
- * Extracts a GraphReFly {@link Actor} from a NestJS {@link ExecutionContext}.
- *
- * Return `undefined` to fall back to {@link DEFAULT_ACTOR}.
- */
-export type ActorExtractor = (context: ExecutionContext) => Actor | undefined;
-
-/**
- * Creates an {@link ActorExtractor} that reads a JWT payload from `req.user`
- * (the standard Passport.js location) and maps it to a GraphReFly {@link Actor}.
- *
- * @param mapping - Optional transform from the JWT payload to an Actor.
- *   When omitted, the payload is used directly (must have `type` and `id`).
- *
- * @example
- * ```ts
- * // Default: req.user is already { type, id, ... }
- * GraphReflyGuard(fromJwtPayload())
- *
- * // Custom mapping from your JWT claims
- * GraphReflyGuard(fromJwtPayload((payload) => ({
- *   type: payload.role === "admin" ? "human" : "llm",
- *   id: payload.sub,
- *   org: payload.org_id,
- * })))
- * ```
- */
-export function fromJwtPayload(mapping?: (payload: unknown) => Actor): ActorExtractor {
-	return (context: ExecutionContext): Actor | undefined => {
-		const req = context.switchToHttp().getRequest();
-		const user = req?.user;
-		if (user == null) return undefined;
-		if (mapping) return mapping(user);
-		return user as Actor;
-	};
-}
-
-/**
- * Creates an {@link ActorExtractor} that reads an Actor from a request header.
- *
- * The header value is parsed as JSON. Useful for service-to-service calls
- * where the caller embeds actor context in a custom header.
- *
- * @param headerName - HTTP header name (case-insensitive). Default: `"x-graphrefly-actor"`.
- *
- * @example
- * ```ts
- * GraphReflyGuard(fromHeader("x-actor"))
- * ```
- */
-export function fromHeader(headerName = "x-graphrefly-actor"): ActorExtractor {
-	return (context: ExecutionContext): Actor | undefined => {
-		const req = context.switchToHttp().getRequest();
-		const raw = req?.headers?.[headerName.toLowerCase()];
-		if (typeof raw !== "string" || raw.length === 0) return undefined;
-		try {
-			return JSON.parse(raw) as Actor;
-		} catch {
-			// F-CATCH D-2: surface-loud. A malformed actor header is otherwise
-			// silently indistinguishable from an absent one — the request runs
-			// as DEFAULT_ACTOR and downstream `policy()` denials read as
-			// "default actor denied" instead of "your actor header was
-			// malformed". Still falls back to DEFAULT_ACTOR (extractor contract
-			// is unchanged: undefined → DEFAULT_ACTOR; this guard is
-			// attribution-only and always allows the request through).
-			console.warn(
-				`[GraphReFly] fromHeader: header "${headerName}" is present but not valid JSON — ` +
-					`ignoring it and falling back to DEFAULT_ACTOR.`,
-			);
-			return undefined;
-		}
-	};
-}
-
-/**
- * Reads the extracted {@link Actor} from a request object (set by {@link GraphReflyGuardImpl}).
- *
- * Returns {@link DEFAULT_ACTOR} if no actor was attached.
- *
- * @example
- * ```ts
- * @Get("status")
- * getStatus(@Req() req: Request) {
- *   const actor = getActor(req);
- *   return this.graph.describe({ actor });
- * }
- * ```
- */
-export function getActor(req: unknown): Actor {
-	const actor = (req as Record<string, unknown>)?.[ACTOR_KEY];
-	return actor != null ? normalizeActor(actor as Actor) : DEFAULT_ACTOR;
-}
-
-/**
- * NestJS guard that extracts a GraphReFly {@link Actor} from the execution
- * context and attaches it to the request as `req.graphReflyActor`.
- *
- * This guard always returns `true` (allows the request through). Access
- * control is handled by GraphReFly node guards (`policy()`), not by this
- * NestJS guard. The purpose is purely to **bridge** authentication context.
- *
- * @example
- * ```ts
- * // Global guard — every request gets an Actor
- * app.useGlobalGuards(new GraphReflyGuardImpl(fromJwtPayload()));
- *
- * // Controller-scoped
- * @UseGuards(GraphReflyGuard(fromJwtPayload()))
- * @Controller("api")
- * export class ApiController { ... }
- * ```
- */
-export class GraphReflyGuardImpl implements CanActivate {
-	constructor(private readonly extractor: ActorExtractor) {}
-
-	canActivate(context: ExecutionContext): boolean {
-		const actor = normalizeActor(this.extractor(context));
-		const req = context.switchToHttp().getRequest();
-		if (req != null) {
-			(req as Record<string, unknown>)[ACTOR_KEY] = actor;
-		}
-		return true;
-	}
-}
-
-/**
- * Factory that creates a {@link GraphReflyGuardImpl} instance. Use with
- * NestJS `@UseGuards()` or `app.useGlobalGuards()`.
- *
- * @param extractor - How to extract an Actor from the request context.
- *   Defaults to {@link fromJwtPayload} (reads `req.user`).
- *
- * @example
- * ```ts
- * import { GraphReflyGuard, fromJwtPayload } from "@graphrefly/graphrefly/compat/nestjs";
- *
- * @UseGuards(GraphReflyGuard())
- * @Controller("graph")
- * export class GraphController { ... }
- * ```
- */
-export function GraphReflyGuard(extractor?: ActorExtractor): GraphReflyGuardImpl {
-	return new GraphReflyGuardImpl(extractor ?? fromJwtPayload());
-}
diff --git a/src/compat/nestjs/index.ts b/src/compat/nestjs/index.ts
deleted file mode 100644
index 9c48b38b..00000000
--- a/src/compat/nestjs/index.ts
+++ /dev/null
@@ -1,79 +0,0 @@
-// ---------------------------------------------------------------------------
-// NestJS integration — Module, DI, Lifecycle, RxJS bridge (Phase 5.5)
-// ---------------------------------------------------------------------------
-// Bridges GraphReFly into NestJS's DI container and RxJS-based ecosystem.
-// NestJS and RxJS are peer dependencies — install them in your NestJS app.
-//
-// Usage:
-//   import { GraphReflyModule, InjectGraph, InjectNode, toObservable }
-//     from '@graphrefly/graphrefly/compat/nestjs';
-// ---------------------------------------------------------------------------
-
-// Decorators
-export {
-	COMMAND_HANDLERS,
-	CommandHandler,
-	type CommandHandlerMeta,
-	CQRS_EVENT_HANDLERS,
-	CRON_HANDLERS,
-	EVENT_HANDLERS,
-	EventHandler,
-	type EventHandlerMeta,
-	GraphCron,
-	type GraphCronMeta,
-	GraphInterval,
-	type GraphIntervalMeta,
-	INTERVAL_HANDLERS,
-	InjectCqrsGraph,
-	InjectGraph,
-	InjectNode,
-	OnGraphEvent,
-	type OnGraphEventMeta,
-	QUERY_HANDLERS,
-	QueryHandler,
-	type QueryHandlerMeta,
-	SAGA_HANDLERS,
-	SagaHandler,
-	type SagaHandlerMeta,
-} from "./decorators.js";
-// Explorer (event/schedule discovery)
-export { GraphReflyEventExplorer } from "./explorer.js";
-// Gateway helpers (Phase 5.1)
-export {
-	ObserveGateway,
-	type ObserveGatewayOptions,
-	type ObserveSSEOptions,
-	type ObserveSubscriptionOptions,
-	type ObserveWsCommand,
-	type ObserveWsMessage,
-	observeSSE,
-	observeSubscription,
-} from "./gateway.js";
-// Actor bridge (Phase 5.1)
-export {
-	ACTOR_KEY,
-	type ActorExtractor,
-	fromHeader,
-	fromJwtPayload,
-	GraphReflyGuard,
-	GraphReflyGuardImpl,
-	getActor,
-} from "./guard.js";
-// Module & DI
-export {
-	type GraphReflyCqrsOptions,
-	type GraphReflyFeatureOptions,
-	GraphReflyModule,
-	type GraphReflyRootOptions,
-} from "./module.js";
-// RxJS bridge — NestJS-flavored: returns a real rxjs `Observable` (the base
-// `toObservable` is dependency-free and returns a Symbol.observable interop;
-// this layer wraps it with rxjs `from()` since `@nestjs/common` pulls rxjs).
-export { type ToObservableOptions, toObservable } from "./observable.js";
-// Injection tokens
-export {
-	GRAPHREFLY_REQUEST_GRAPH,
-	GRAPHREFLY_ROOT_GRAPH,
-	getGraphToken,
-	getNodeToken,
-} from "./tokens.js";
diff --git a/src/compat/nestjs/module.ts b/src/compat/nestjs/module.ts
deleted file mode 100644
index 2bac239b..00000000
--- a/src/compat/nestjs/module.ts
+++ /dev/null
@@ -1,294 +0,0 @@
-// ---------------------------------------------------------------------------
-// GraphReflyModule — NestJS dynamic module for GraphReFly integration.
-// ---------------------------------------------------------------------------
-// Provides `forRoot()` and `forFeature()` following the standard NestJS
-// dynamic-module pattern. Lifecycle hooks wire graph creation on init and
-// `graph.destroy()` on teardown — TEARDOWN propagates through the graph
-// per GRAPHREFLY-SPEC §3.7.
-//
-// No decorator usage in this file — all DI is done via factory providers
-// so the library doesn't require `experimentalDecorators` in consumer's
-// tsconfig (only the consumer's NestJS app needs it).
-// ---------------------------------------------------------------------------
-
-import type { AppendLogStorageTier } from "@graphrefly/pure-ts/extra";
-import { Graph, type GraphPersistSnapshot } from "@graphrefly/pure-ts/graph";
-import {
-	type DynamicModule,
-	Module,
-	type OnModuleDestroy,
-	type Provider,
-	Scope,
-} from "@nestjs/common";
-import { ModuleRef } from "@nestjs/core";
-import { type CqrsGraph, type CqrsOptions, cqrs } from "../../utils/cqrs/index.js";
-import { GraphReflyEventExplorer } from "./explorer.js";
-import {
-	GRAPHREFLY_REQUEST_GRAPH,
-	GRAPHREFLY_ROOT_GRAPH,
-	getGraphToken,
-	getNodeToken,
-} from "./tokens.js";
-
-// ---------------------------------------------------------------------------
-// Option types
-// ---------------------------------------------------------------------------
-
-export interface GraphReflyRootOptions {
-	/** Root graph name (default: `"root"`). */
-	name?: string;
-	/** Snapshot to hydrate via `graph.restore()` after build. */
-	snapshot?: GraphPersistSnapshot;
-	/** Build callback — registers nodes/mounts on the graph. */
-	build?: (graph: Graph) => void;
-	/** Qualified node paths to expose as injectable providers. */
-	nodes?: readonly string[];
-	/** Enable a request-scoped graph (injectable via `@InjectGraph("request")`). */
-	requestScope?: boolean;
-}
-
-export interface GraphReflyCqrsOptions {
-	/** Feature name — becomes the mount name in the root graph. */
-	name: string;
-	/** CQRS graph options (forwarded to `cqrs()` factory). */
-	cqrs?: CqrsOptions;
-	/** Build callback — registers commands, events, projections, sagas on the CqrsGraph. */
-	build?: (graph: CqrsGraph) => void;
-	/** Append-log storage tiers for event persistence (wired via `attachEventStorage()`). */
-	eventStorage?: readonly AppendLogStorageTier<import("../../utils/cqrs/index.js").CqrsEvent>[];
-	/**
-	 * Node paths (local to this feature) to expose as injectable providers.
-	 * Tokens are auto-qualified as `featureName::path`.
-	 */
-	nodes?: readonly string[];
-}
-
-export interface GraphReflyFeatureOptions {
-	/** Feature name — becomes the mount name in the root graph. */
-	name: string;
-	/** Build callback — registers nodes/mounts on the feature graph. */
-	build?: (graph: Graph) => void;
-	/** Snapshot to hydrate after build. */
-	snapshot?: GraphPersistSnapshot;
-	/**
-	 * Node paths (local to this feature) to expose as injectable providers.
-	 * Tokens are auto-qualified as `featureName::path` to avoid collisions.
-	 */
-	nodes?: readonly string[];
-}
-
-// ---------------------------------------------------------------------------
-// Lifecycle classes (no decorators — DI is handled via factory providers)
-// ---------------------------------------------------------------------------
-
-class GraphReflyRootLifecycle implements OnModuleDestroy {
-	constructor(readonly graph: Graph) {}
-
-	onModuleDestroy(): void {
-		this.graph.destroy();
-	}
-}
-
-class GraphReflyRequestLifecycle implements OnModuleDestroy {
-	readonly graph = new Graph("request");
-
-	onModuleDestroy(): void {
-		this.graph.destroy();
-	}
-}
-
-// ---------------------------------------------------------------------------
-// Module
-// ---------------------------------------------------------------------------
-
-// NestJS dynamic modules convention: static `forRoot` / `forFeature` factories on a `@Module` class.
-@Module({})
-// biome-ignore lint/complexity/noStaticOnlyClass: NestJS `DynamicModule` pattern (`@Module` + static factories)
-export class GraphReflyModule {
-	/**
-	 * Register the root `Graph` singleton in the NestJS DI container.
-	 *
-	 * The root graph is `@Global()` — injectable everywhere without importing
-	 * the module again. Use `@InjectGraph()` to inject it.
-	 *
-	 * Lifecycle:
-	 * - **init:** Graph created in factory. If `build` is provided, it runs
-	 *   first (registers nodes/mounts). If `snapshot` is provided, values
-	 *   are restored via `graph.restore()`.
-	 * - **destroy:** Calls `graph.destroy()` — sends `[[TEARDOWN]]` to all
-	 *   nodes, including mounted feature subgraphs (cascading teardown).
-	 */
-	static forRoot(opts?: GraphReflyRootOptions): DynamicModule {
-		const options = opts ?? {};
-		const graphName = options.name ?? "root";
-
-		const providers: Provider[] = [
-			{
-				provide: GRAPHREFLY_ROOT_GRAPH,
-				useFactory: () => {
-					const g = new Graph(graphName);
-					if (options.build) options.build(g);
-					if (options.snapshot) g.restore(options.snapshot);
-					return g;
-				},
-			},
-			{
-				provide: Symbol.for("graphrefly:root-lifecycle"),
-				useFactory: (graph: Graph) => new GraphReflyRootLifecycle(graph),
-				inject: [GRAPHREFLY_ROOT_GRAPH],
-			},
-			{
-				provide: GraphReflyEventExplorer,
-				useFactory: (graph: Graph, moduleRef: InstanceType<typeof ModuleRef>) =>
-					new GraphReflyEventExplorer(graph, moduleRef),
-				inject: [GRAPHREFLY_ROOT_GRAPH, ModuleRef],
-			},
-		];
-
-		// Node factory providers — each declared path gets a factory that
-		// resolves the node from the root graph at injection time.
-		if (options.nodes) {
-			for (const path of options.nodes) {
-				providers.push({
-					provide: getNodeToken(path),
-					useFactory: (graph: Graph) => graph.resolve(path),
-					inject: [GRAPHREFLY_ROOT_GRAPH],
-				});
-			}
-		}
-
-		// Request-scoped graph provider (opt-in).
-		if (options.requestScope) {
-			providers.push(
-				{
-					provide: Symbol.for("graphrefly:request-lifecycle"),
-					useFactory: () => new GraphReflyRequestLifecycle(),
-					scope: Scope.REQUEST,
-				},
-				{
-					provide: GRAPHREFLY_REQUEST_GRAPH,
-					useFactory: (lifecycle: GraphReflyRequestLifecycle) => lifecycle.graph,
-					inject: [Symbol.for("graphrefly:request-lifecycle")],
-					scope: Scope.REQUEST,
-				},
-			);
-		}
-
-		return {
-			module: GraphReflyModule,
-			global: true,
-			providers,
-			exports: [
-				GRAPHREFLY_ROOT_GRAPH,
-				...(options.nodes ?? []).map(getNodeToken),
-				...(options.requestScope ? [GRAPHREFLY_REQUEST_GRAPH] : []),
-			],
-		};
-	}
-
-	/**
-	 * Register a feature subgraph that auto-mounts into the root graph.
-	 *
-	 * The feature graph is created in the factory, built/restored, then
-	 * mounted into root via `root.mount(name, featureGraph)`. On app
-	 * shutdown, root's `graph.destroy()` cascades TEARDOWN through all
-	 * mounted subgraphs (no explicit remove needed).
-	 *
-	 * Node tokens are auto-qualified as `featureName::path` to prevent
-	 * collisions between features declaring nodes with the same local name.
-	 *
-	 * Injectable via `@InjectGraph(name)`.
-	 */
-	static forFeature(opts: GraphReflyFeatureOptions): DynamicModule {
-		const providers: Provider[] = [
-			{
-				provide: getGraphToken(opts.name),
-				useFactory: (rootGraph: Graph) => {
-					const g = new Graph(opts.name);
-					if (opts.build) opts.build(g);
-					if (opts.snapshot) g.restore(opts.snapshot);
-					rootGraph.mount(opts.name, g);
-					return g;
-				},
-				inject: [GRAPHREFLY_ROOT_GRAPH],
-			},
-		];
-
-		// Node factory providers for feature-scoped nodes.
-		// Tokens are qualified as `featureName::path` to avoid cross-feature collisions.
-		if (opts.nodes) {
-			for (const path of opts.nodes) {
-				providers.push({
-					provide: getNodeToken(`${opts.name}::${path}`),
-					useFactory: (graph: Graph) => graph.resolve(path),
-					inject: [getGraphToken(opts.name)],
-				});
-			}
-		}
-
-		return {
-			module: GraphReflyModule,
-			providers,
-			exports: [
-				getGraphToken(opts.name),
-				...(opts.nodes ?? []).map((p) => getNodeToken(`${opts.name}::${p}`)),
-			],
-		};
-	}
-
-	/**
-	 * Register a CQRS subgraph that auto-mounts into the root graph.
-	 *
-	 * Creates a `CqrsGraph` via the `cqrs()` factory (roadmap §4.5), mounts it
-	 * into the root graph, and exposes it for DI via `@InjectGraph(name)`.
-	 *
-	 * CQRS decorators (`@CommandHandler`, `@EventHandler`, `@QueryHandler`,
-	 * `@SagaHandler`) are discovered by the explorer and wired to this graph
-	 * on module init.
-	 *
-	 * @example
-	 * ```ts
-	 * GraphReflyModule.forCqrs({
-	 *   name: "orders",
-	 *   build: (g) => {
-	 *     g.event("orderPlaced");
-	 *     g.projection({ name: "orderCount", events: ["orderPlaced"], reducer: (_s, evts) => evts.length, initial: 0 });
-	 *   },
-	 * })
-	 * ```
-	 */
-	static forCqrs(opts: GraphReflyCqrsOptions): DynamicModule {
-		const providers: Provider[] = [
-			{
-				provide: getGraphToken(opts.name),
-				useFactory: (rootGraph: Graph) => {
-					const g = cqrs(opts.name, opts.cqrs);
-					if (opts.eventStorage) g.attachEventStorage(opts.eventStorage);
-					if (opts.build) opts.build(g);
-					rootGraph.mount(opts.name, g);
-					return g;
-				},
-				inject: [GRAPHREFLY_ROOT_GRAPH],
-			},
-		];
-
-		if (opts.nodes) {
-			for (const path of opts.nodes) {
-				providers.push({
-					provide: getNodeToken(`${opts.name}::${path}`),
-					useFactory: (graph: Graph) => graph.resolve(path),
-					inject: [getGraphToken(opts.name)],
-				});
-			}
-		}
-
-		return {
-			module: GraphReflyModule,
-			providers,
-			exports: [
-				getGraphToken(opts.name),
-				...(opts.nodes ?? []).map((p) => getNodeToken(`${opts.name}::${p}`)),
-			],
-		};
-	}
-}
diff --git a/src/compat/nestjs/observable.ts b/src/compat/nestjs/observable.ts
deleted file mode 100644
index 13974039..00000000
--- a/src/compat/nestjs/observable.ts
+++ /dev/null
@@ -1,47 +0,0 @@
-// ---------------------------------------------------------------------------
-// NestJS RxJS bridge — returns a real rxjs `Observable` (so NestJS route
-// handlers' `isObservable()` recognizes it and `.pipe()` works directly).
-//
-// rxjs lives ONLY here, under the opt-in `compat/nestjs` subpath, where it is
-// legitimately available (`@nestjs/common` depends on rxjs). The base
-// `toObservable` (`@graphrefly/graphrefly/base`) is dependency-free and is
-// what RN/Hermes/web consumers load — this wrapper just adopts it via
-// rxjs `from()`.
-// ---------------------------------------------------------------------------
-
-import type { Messages, Node } from "@graphrefly/pure-ts/core";
-import { from, type Observable, type ObservableInput } from "rxjs";
-import {
-	toObservable as baseToObservable,
-	type ToObservableOptions,
-} from "../../base/composition/observable.js";
-
-export type { ToObservableOptions };
-
-/**
- * Bridge a `Node<T>` to a real rxjs `Observable` for NestJS controllers,
- * gateways, and interceptors. Wraps the dependency-free base interop
- * observable with rxjs `from()` so `isObservable()` / `.pipe()` work.
- *
- * See {@link baseToObservable} for the DATA/ERROR/COMPLETE mapping and the
- * `{ raw: true }` message-batch mode.
- */
-export function toObservable<T>(
-	node: Node<T>,
-	options?: ToObservableOptions & { raw?: false },
-): Observable<T>;
-export function toObservable<T>(
-	node: Node<T>,
-	options: ToObservableOptions & { raw: true },
-): Observable<Messages>;
-export function toObservable<T>(
-	node: Node<T>,
-	options?: ToObservableOptions,
-): Observable<T | Messages> {
-	// The base interop observable exposes `subscribe` + the well-known
-	// `Symbol.observable` method at runtime; rxjs `from()` adopts it. Branch
-	// so each call hits a concrete base overload (the union impl signature is
-	// not visible to callers), and cast the minimal base type to rxjs input.
-	const base = options?.raw ? baseToObservable(node, { raw: true }) : baseToObservable<T>(node);
-	return from(base as unknown as ObservableInput<T | Messages>);
-}
diff --git a/src/compat/nestjs/tokens.ts b/src/compat/nestjs/tokens.ts
deleted file mode 100644
index 14f6fd1f..00000000
--- a/src/compat/nestjs/tokens.ts
+++ /dev/null
@@ -1,32 +0,0 @@
-// ---------------------------------------------------------------------------
-// NestJS DI tokens for GraphReFly integration.
-// ---------------------------------------------------------------------------
-
-/** Injection token for the root `Graph` singleton created by `forRoot()`. */
-export const GRAPHREFLY_ROOT_GRAPH = Symbol.for("graphrefly:root-graph");
-
-/** Injection token for `forRoot()` / `forFeature()` options. */
-export const GRAPHREFLY_MODULE_OPTIONS = Symbol.for("graphrefly:module-options");
-
-/** Injection token for the request-scoped `Graph` created by request scope config. */
-export const GRAPHREFLY_REQUEST_GRAPH = Symbol.for("graphrefly:request-graph");
-
-/**
- * Get the injection token for a named feature graph.
- *
- * Feature graphs registered via `GraphReflyModule.forFeature({ name })` are
- * injectable using this token (or via the `@InjectGraph(name)` decorator).
- */
-export function getGraphToken(name: string): symbol {
-	return Symbol.for(`graphrefly:graph:${name}`);
-}
-
-/**
- * Get the injection token for a node at a qualified path.
- *
- * Nodes declared in `forRoot({ nodes })` or `forFeature({ nodes })` are
- * injectable using this token (or via the `@InjectNode(path)` decorator).
- */
-export function getNodeToken(path: string): symbol {
-	return Symbol.for(`graphrefly:node:${path}`);
-}
diff --git a/src/compat/react/index.ts b/src/compat/react/index.ts
deleted file mode 100644
index 7a89da71..00000000
--- a/src/compat/react/index.ts
+++ /dev/null
@@ -1,143 +0,0 @@
-// ---------------------------------------------------------------------------
-// React bindings — useStore / useSubscribe
-// ---------------------------------------------------------------------------
-// Bridges GraphReFly nodes into React via useSyncExternalStore.
-// Works with any Node<T>, including companion nodes (node.meta.status).
-//
-// Usage:
-//   import { useStore, useSubscribe } from '@graphrefly/graphrefly/compat/react';
-//   // Optional peer install (only for this adapter): pnpm add react react-dom
-//   const value = useSubscribe(myNode);          // T | undefined (read-only)
-//   const [count, setCount] = useStore(counter); // [T | undefined, setter]
-// ---------------------------------------------------------------------------
-
-import { DATA, DIRTY, type Messages, type Node, RESOLVED } from "@graphrefly/pure-ts/core";
-import { useCallback, useMemo, useRef, useSyncExternalStore } from "react";
-
-/**
- * Subscribe to a read-only `Node<T>` as a React value. Re-renders on node value settlement.
- * Subscription lifecycle is tied to React mount/unmount (not node terminal messages).
- *
- * @param node - Any `Node<T>`.
- * @returns `T | undefined` — the current node value, kept in sync via `useSyncExternalStore`.
- */
-export function useSubscribe<T>(node: Node<T>): T | undefined | null {
-	const subscribe = useCallback(
-		(onStoreChange: () => void) => {
-			let disposed = false;
-			const unsub = node.subscribe(() => {
-				if (!disposed) onStoreChange();
-			});
-			return () => {
-				disposed = true;
-				unsub();
-			};
-		},
-		[node],
-	);
-	const getSnapshot = useCallback(() => node.cache, [node]);
-	return useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
-}
-
-/**
- * Bind a writable `Node<T>` as a React `[value, setter]` tuple.
- * Setting the value always pushes `[[DIRTY], [DATA, value]]`, including `value === undefined`.
- * Subscription lifecycle is tied to React mount/unmount (not node terminal messages).
- *
- * @param node - A `Node<T>` (e.g. state node).
- * @returns `[T | undefined, (value: T) => void]` — current value and setter function.
- */
-export function useStore<T>(node: Node<T>): [T | undefined | null, (value: T) => void] {
-	const value = useSubscribe(node);
-	const setter = useCallback(
-		(v: T) => {
-			node.down([[DIRTY], [DATA, v]]);
-		},
-		[node],
-	);
-	return [value, setter];
-}
-
-/** Maps a key to an object of nodes. Used by `useSubscribeRecord`. */
-export type NodeFactory<K, R extends Record<string, any>> = (key: K) => {
-	[P in keyof R]: Node<R[P]>;
-};
-
-/**
- * Subscribe to a dynamic set of keyed node records.
- * Re-subscribes all per-key fields whenever `keysNode` changes.
- * Key re-sync is gated to settled batches (`messageTier >= 3`) to avoid DIRTY-phase churn.
- * Guaranteed to clean up strictly with React hook lifecycle, utilizing no global mappings.
- *
- * @param keysNode - Node of current keys (e.g. node IDs)
- * @param factory - Function returning `{ [field]: Node<V> }` for each key.
- * @returns `Record<K, R>` — snapshot of resolved values for all keys.
- */
-export function useSubscribeRecord<K extends string, R extends Record<string, any>>(
-	keysNode: Node<K[]>,
-	factory: NodeFactory<K, R>,
-): Record<K, R> {
-	const factoryRef = useRef(factory);
-	factoryRef.current = factory;
-
-	const store = useMemo(() => {
-		const computeSnap = () => {
-			const snap = {} as Record<K, R>;
-			const keys = keysNode.cache ?? [];
-			for (const key of keys) {
-				const nodes = factoryRef.current(key);
-				const values = {} as R;
-				for (const field of Object.keys(nodes) as (keyof R)[]) {
-					values[field] = nodes[field].cache as R[keyof R];
-				}
-				snap[key] = values;
-			}
-			return snap;
-		};
-
-		let currentSnapshot = computeSnap();
-
-		return {
-			subscribe: (onStoreChange: () => void) => {
-				let disposed = false;
-				let entrySubs: Array<() => void> = [];
-
-				const cleanupEntries = () => {
-					for (const unsub of entrySubs) unsub();
-					entrySubs = [];
-				};
-
-				const sync = (nextKeys: K[]) => {
-					cleanupEntries();
-					for (const key of nextKeys) {
-						const nodes = factoryRef.current(key);
-						for (const field of Object.keys(nodes) as (keyof R)[]) {
-							const unsub = nodes[field].subscribe(() => {
-								currentSnapshot = computeSnap();
-								if (!disposed) onStoreChange();
-							});
-							entrySubs.push(unsub);
-						}
-					}
-					currentSnapshot = computeSnap();
-					if (!disposed) onStoreChange();
-				};
-
-				const keysUnsub = keysNode.subscribe((msgs: Messages) => {
-					const hasSettled = msgs.some((m) => m[0] === DATA || m[0] === RESOLVED);
-					if (!disposed && hasSettled) sync(keysNode.cache ?? []);
-				});
-				sync(keysNode.cache ?? []);
-
-				return () => {
-					disposed = true;
-					keysUnsub();
-					cleanupEntries();
-				};
-			},
-			getSnapshot: () => currentSnapshot,
-		};
-	}, [keysNode]);
-
-	return useSyncExternalStore(store.subscribe, store.getSnapshot, store.getSnapshot);
-}
diff --git a/src/compat/signals/index.ts b/src/compat/signals/index.ts
deleted file mode 100644
index 5b3865f6..00000000
--- a/src/compat/signals/index.ts
+++ /dev/null
@@ -1,222 +0,0 @@
-import {
-	autoTrackNode,
-	batch,
-	COMPLETE,
-	DATA,
-	DIRTY,
-	ERROR,
-	type Messages,
-	type Node,
-	node,
-	type TrackFn,
-} from "@graphrefly/pure-ts/core";
-
-/**
- * Options for creating signals.
- *
- * @category compat
- */
-export interface SignalOptions {
-	/** Optional identifier for the underlying node. */
-	name?: string;
-	/** Custom equality function for change detection. */
-	equals?: (a: any, b: any) => boolean;
-}
-
-/**
- * Common interface for all reactive signals.
- *
- * @category compat
- */
-export interface AnySignal<T> {
-	/** Returns the current value of the signal. */
-	get(): T;
-	/** @internal The underlying GraphReFly node. */
-	_node: Node<T>;
-}
-
-/**
- * Global stack of active tracking contexts.
- * Since computation evaluation is fully synchronous, we push the tracking `get`
- * function before execution and pop it after. This prevents memory leaks without
- * needing WeakRefs, as the stack is always empty when idle.
- */
-const trackingStack: TrackFn[] = [];
-
-/**
- * Helper to pull a disconnected node, forcing a synchronous resolution
- * cycle so that `get()` returns a fresh value even if the signal is unmounted.
- */
-function pull<T>(n: Node<T>): T {
-	let val: T | undefined | null = n.cache;
-	const unsub = n.subscribe((msgs: Messages) => {
-		for (const [t, v] of msgs) {
-			if (t === DATA) val = v as T;
-		}
-	});
-	unsub();
-	return val as T;
-}
-
-/**
- * TC39 `Signal.State` — a writable signal backed by a GraphReFly `state` node.
- * Automatically registers itself as a dependency if read inside a `Computed`.
- *
- * @example
- * ```ts
- * const count = new Signal.State(0);
- * count.get(); // 0
- * count.set(1);
- * count.get(); // 1
- * ```
- */
-class SignalState<T> implements AnySignal<T> {
-	/** @internal */
-	_node: Node<T>;
-	private readonly _equals: (a: T, b: T) => boolean;
-
-	constructor(initial: T, opts?: SignalOptions) {
-		this._equals = (opts?.equals ?? Object.is) as (a: T, b: T) => boolean;
-		this._node = node<T>([], {
-			initial,
-			...opts,
-			resubscribable: true,
-			resetOnTeardown: true,
-		});
-	}
-
-	get(): T {
-		// If we are evaluating inside a computed node, track this read!
-		const tracker = trackingStack[trackingStack.length - 1];
-		if (tracker) {
-			if (this._node.status === "sentinel") {
-				pull(this._node);
-			}
-			return tracker(this._node) as T;
-		}
-
-		if (this._node.status === "sentinel") {
-			return pull(this._node);
-		}
-		return this._node.cache as T;
-	}
-
-	set(value: T): void {
-		if (this._equals(this.get(), value)) return;
-		batch(() => {
-			this._node.down([[DIRTY], [DATA, value]]);
-		});
-	}
-}
-
-/**
- * TC39 `Signal.Computed` — a read-only signal backed by `dynamicNode`.
- * Automatically tracks dependencies when `get()` is called on other signals
- * during its computation.
- *
- * @example
- * ```ts
- * const count = new Signal.State(0);
- * const doubled = new Signal.Computed(() => count.get() * 2);
- * ```
- */
-class SignalComputed<T> implements AnySignal<T> {
-	/** @internal */
-	_node: Node<T>;
-
-	constructor(computation: () => T, opts?: SignalOptions) {
-		this._node = autoTrackNode<T>(
-			(track) => {
-				trackingStack.push(track);
-				try {
-					return computation();
-				} finally {
-					trackingStack.pop();
-				}
-			},
-			{
-				...opts,
-				describeKind: "derived",
-				resubscribable: true,
-				resetOnTeardown: true,
-				// TC39 Signal semantics require `Signal.Computed` to return
-				// the user-provided computation value, never `undefined` from
-				// a not-yet-discovered branch dep. Opt OUT of Lock 6.C′'s
-				// partial:true default — the gate suppresses fn until newly
-				// discovered branch deps deliver their first DATA, so `track`
-				// never returns `undefined` after a branch flip.
-				partial: false,
-			},
-		);
-	}
-
-	get(): T {
-		// Computed nodes can themselves be dependencies of other Computed nodes.
-		const tracker = trackingStack[trackingStack.length - 1];
-		if (tracker) {
-			if (this._node.status === "sentinel") {
-				pull(this._node);
-			}
-			return tracker(this._node) as T;
-		}
-
-		if (this._node.status === "sentinel") {
-			return pull(this._node);
-		}
-		return this._node.cache as T;
-	}
-}
-
-/**
- * TC39 Signals-compatible namespace. Wraps GraphReFly primitives.
- * Provides auto-tracking conforming to the TS39 signals proposal.
- *
- * @category compat
- */
-export const Signal = {
-	State: SignalState,
-	Computed: SignalComputed,
-
-	/**
-	 * Subscribes to changes on a signal.
-	 * Returns an unsubscribe callback.
-	 *
-	 * @example
-	 * ```ts
-	 * const count = new Signal.State(0);
-	 * const unsub = Signal.sub(count, v => console.log(v));
-	 * ```
-	 */
-	sub: <T>(
-		signal: AnySignal<T>,
-		callback:
-			| ((value: T) => void)
-			| {
-					data?: (value: T) => void;
-					error?: (err: unknown) => void;
-					complete?: () => void;
-			  },
-	): (() => void) => {
-		const handlers =
-			typeof callback === "function"
-				? { data: callback as (value: T) => void, error: undefined, complete: undefined }
-				: callback;
-		// Skip the initial push-on-subscribe DATA — Signal.sub fires on changes only.
-		let initial = true;
-		return signal._node.subscribe((msgs) => {
-			for (const [t, v] of msgs) {
-				if (t === DATA) {
-					if (initial) {
-						initial = false;
-						continue;
-					}
-					handlers.data?.(v as T);
-				}
-				if (t === ERROR) handlers.error?.(v);
-				if (t === COMPLETE) handlers.complete?.();
-			}
-		});
-	},
-} as const;
-
-export type { SignalComputed, SignalState };
diff --git a/src/compat/solid/index.ts b/src/compat/solid/index.ts
deleted file mode 100644
index 4523ba65..00000000
--- a/src/compat/solid/index.ts
+++ /dev/null
@@ -1,123 +0,0 @@
-// ---------------------------------------------------------------------------
-// Solid bindings — useSubscribe / useStore
-// ---------------------------------------------------------------------------
-// Bridges GraphReFly nodes into Solid reactivity via createSignal.
-// Works with any Node<T>, including companion nodes (node.meta.status).
-//
-// Usage:
-//   import { useSubscribe, useStore } from '@graphrefly/graphrefly/compat/solid';
-//   // Optional peer install (only for this adapter): pnpm add solid-js
-//   const status = useSubscribe(wsStatusNode);     // Accessor<string | undefined>
-//   const [count, setCount] = useStore(countNode); // [Accessor<number | undefined>, Setter]
-// ---------------------------------------------------------------------------
-
-import { DATA, DIRTY, type Messages, type Node, RESOLVED } from "@graphrefly/pure-ts/core";
-import { createSignal, getOwner, onCleanup } from "solid-js";
-
-/** Solid accessor function — returns current value when called. */
-export type Accessor<T> = () => T;
-
-/**
- * Subscribe to a `Node<T>` as a Solid signal. Auto-cleans up with the owning scope.
- * Subscription lifecycle is tied to Solid scope cleanup (not node terminal messages).
- */
-export function useSubscribe<T>(node: Node<T>): Accessor<T | undefined | null> {
-	const [value, setValue] = createSignal(node.cache, { equals: false });
-
-	const unsub = node.subscribe(() => {
-		setValue(() => node.cache);
-	});
-
-	if (getOwner()) {
-		onCleanup(() => unsub());
-	} else if (typeof console !== "undefined") {
-		console.warn(
-			"[graphrefly-ts] useSubscribe called outside a Solid reactive owner — subscription will not be auto-disposed.",
-		);
-	}
-
-	return value;
-}
-
-/**
- * Bind a writable `Node<T>` as a Solid resource tuple `[accessor, setter]`.
- * Setter always forwards `[[DIRTY], [DATA, value]]`, including `value === undefined`.
- * Subscription lifecycle is tied to Solid scope cleanup (not node terminal messages).
- */
-export function useStore<T>(node: Node<T>): [Accessor<T | undefined | null>, (v: T) => void] {
-	const value = useSubscribe(node);
-	const setter = (v: T) => {
-		node.down([[DIRTY], [DATA, v]]);
-	};
-	return [value, setter];
-}
-
-/** Maps a key to an object of nodes. Used by `useSubscribeRecord`. */
-export type NodeFactory<K, R extends Record<string, any>> = (key: K) => {
-	[P in keyof R]: Node<R[P]>;
-};
-
-/**
- * Subscribe to a dynamic set of keyed node records as a Solid accessor.
- * Re-subscribes all per-key fields whenever `keys` changes.
- * Key re-sync is gated to settled batches (`messageTier >= 3`) to avoid DIRTY-phase churn.
- */
-export function useSubscribeRecord<K extends string, R extends Record<string, any>>(
-	keysNode: Node<K[]>,
-	factory: NodeFactory<K, R>,
-): Accessor<Record<K, R>> {
-	const [value, setValue] = createSignal({} as Record<K, R>, { equals: false });
-	let entrySubs: Array<() => void> = [];
-
-	const cleanupEntries = () => {
-		for (const unsub of entrySubs) unsub();
-		entrySubs = [];
-	};
-
-	const buildSnapshot = (): Record<K, R> => {
-		const snap = {} as Record<K, R>;
-		for (const key of keysNode.cache ?? []) {
-			const nodes = factory(key);
-			const values = {} as R;
-			for (const field of Object.keys(nodes) as (keyof R)[]) {
-				values[field] = nodes[field].cache as R[keyof R];
-			}
-			snap[key] = values;
-		}
-		return snap;
-	};
-
-	const sync = (nextKeys: K[]) => {
-		cleanupEntries();
-		for (const key of nextKeys) {
-			const nodes = factory(key);
-			for (const field of Object.keys(nodes) as (keyof R)[]) {
-				const unsub = nodes[field].subscribe(() => {
-					setValue(() => buildSnapshot());
-				});
-				entrySubs.push(unsub);
-			}
-		}
-		setValue(() => buildSnapshot());
-	};
-
-	const keysUnsub = keysNode.subscribe((msgs: Messages) => {
-		if (msgs.some((m) => m[0] === DATA || m[0] === RESOLVED)) {
-			sync(keysNode.cache ?? []);
-		}
-	});
-	sync(keysNode.cache ?? []);
-
-	if (getOwner()) {
-		onCleanup(() => {
-			keysUnsub();
-			cleanupEntries();
-		});
-	} else if (typeof console !== "undefined") {
-		console.warn(
-			"[graphrefly-ts] useSubscribeRecord called outside a Solid reactive owner — subscription will not be auto-disposed.",
-		);
-	}
-
-	return value;
-}
diff --git a/src/compat/svelte/index.ts b/src/compat/svelte/index.ts
deleted file mode 100644
index c88e8d80..00000000
--- a/src/compat/svelte/index.ts
+++ /dev/null
@@ -1,133 +0,0 @@
-// ---------------------------------------------------------------------------
-// Svelte bindings — useSubscribe / useStore
-// ---------------------------------------------------------------------------
-// Bridges GraphReFly nodes into Svelte's store contract. Works with any
-// Node<T>, including companion nodes (node.meta.status).
-//
-// Usage:
-//   import { useSubscribe, useStore } from '@graphrefly/graphrefly/compat/svelte';
-//   // Optional peer install (only for this adapter): pnpm add svelte
-//   const status = useSubscribe(wsStatusNode);   // Svelte readable store
-//   const count = useStore(countNode);           // Svelte writable store
-//   // In template: $status, $count
-//   // $count = 42
-// ---------------------------------------------------------------------------
-
-import { DATA, DIRTY, type Messages, type Node, RESOLVED } from "@graphrefly/pure-ts/core";
-
-/** Svelte store contract — implements the minimal `subscribe` method. */
-export interface SvelteReadable<T> {
-	subscribe(run: (value: T) => void): () => void;
-}
-
-/** Svelte writable store contract. */
-export interface SvelteWritable<T> extends SvelteReadable<T> {
-	set(value: T): void;
-	update(updater: (value: T) => T): void;
-}
-
-/**
- * Subscribe to a `Node<T>` as a Svelte readable store (implements Svelte store contract).
- * Subscription lifecycle is tied to Svelte store unsubscription (not node terminal messages).
- */
-export function useSubscribe<T>(node: Node<T>): SvelteReadable<T | undefined | null> {
-	return {
-		subscribe(run: (value: T | undefined | null) => void): () => void {
-			const unsub = node.subscribe(() => {
-				run(node.cache);
-			});
-			run(node.cache);
-			return unsub;
-		},
-	};
-}
-
-/**
- * Bind a writable `Node<T>` as a Svelte writable store.
- * Reads and writes adapt seamlessly.
- * Setter/update always forward `[[DIRTY], [DATA, value]]`, including `value === undefined`.
- * Subscription lifecycle is tied to Svelte store unsubscription (not node terminal messages).
- */
-export function useStore<T>(node: Node<T>): SvelteWritable<T | undefined | null> {
-	return {
-		subscribe(run: (value: T | undefined | null) => void): () => void {
-			const unsub = node.subscribe(() => {
-				run(node.cache);
-			});
-			run(node.cache);
-			return unsub;
-		},
-		set(value: T | undefined | null) {
-			node.down([[DIRTY], [DATA, value]]);
-		},
-		update(updater: (value: T | undefined | null) => T | undefined | null) {
-			const next = updater(node.cache);
-			node.down([[DIRTY], [DATA, next]]);
-		},
-	};
-}
-
-/** Maps a key to an object of nodes. Used by `useSubscribeRecord`. */
-export type NodeFactory<K, R extends Record<string, any>> = (key: K) => {
-	[P in keyof R]: Node<R[P]>;
-};
-
-/**
- * Subscribe to a dynamic keyed record of nodes as a Svelte readable store.
- * Re-subscribes all per-key fields whenever `keysNode` changes.
- * Key re-sync is gated to settled batches (`messageTier >= 3`) to avoid DIRTY-phase churn.
- */
-export function useSubscribeRecord<K extends string, R extends Record<string, any>>(
-	keysNode: Node<K[]>,
-	factory: NodeFactory<K, R>,
-): SvelteReadable<Record<K, R>> {
-	return {
-		subscribe(run: (value: Record<K, R>) => void): () => void {
-			let entrySubs: Array<() => void> = [];
-
-			const cleanupEntries = () => {
-				for (const unsub of entrySubs) unsub();
-				entrySubs = [];
-			};
-
-			const buildSnapshot = (): Record<K, R> => {
-				const snap = {} as Record<K, R>;
-				for (const key of keysNode.cache ?? []) {
-					const nodes = factory(key);
-					const values = {} as R;
-					for (const field of Object.keys(nodes) as (keyof R)[]) {
-						values[field] = nodes[field].cache as R[keyof R];
-					}
-					snap[key] = values;
-				}
-				return snap;
-			};
-
-			const sync = (nextKeys: K[]) => {
-				cleanupEntries();
-				for (const key of nextKeys) {
-					const nodes = factory(key);
-					for (const field of Object.keys(nodes) as (keyof R)[]) {
-						const unsub = nodes[field].subscribe(() => {
-							run(buildSnapshot());
-						});
-						entrySubs.push(unsub);
-					}
-				}
-				run(buildSnapshot());
-			};
-
-			const keysUnsub = keysNode.subscribe((msgs: Messages) => {
-				if (msgs.some((m) => m[0] === DATA || m[0] === RESOLVED)) {
-					sync(keysNode.cache ?? []);
-				}
-			});
-			sync(keysNode.cache ?? []);
-
-			return () => {
-				keysUnsub();
-				cleanupEntries();
-			};
-		},
-	};
-}
diff --git a/src/compat/vue/index.ts b/src/compat/vue/index.ts
deleted file mode 100644
index 1465603c..00000000
--- a/src/compat/vue/index.ts
+++ /dev/null
@@ -1,156 +0,0 @@
-// ---------------------------------------------------------------------------
-// Vue bindings — useStore / useSubscribe
-// ---------------------------------------------------------------------------
-// Bridges GraphReFly nodes into Vue reactivity. Works with any
-// Node<T>, including companion nodes (node.meta.status).
-//
-// Usage:
-//   import { useStore, useSubscribe } from '@graphrefly/graphrefly/compat/vue';
-//   // Optional peer install (only for this adapter): pnpm add vue
-//   const count = useStore(counterNode);       // Ref<number | undefined> (read + write)
-//   const status = useSubscribe(wsStatusNode); // Readonly<Ref<string | undefined>>
-// ---------------------------------------------------------------------------
-
-import { DATA, DIRTY, type Node } from "@graphrefly/pure-ts/core";
-import {
-	computed,
-	getCurrentScope,
-	isRef,
-	onScopeDispose,
-	type Ref,
-	readonly,
-	shallowRef,
-	type WatchSource,
-	watch,
-} from "vue";
-
-/**
- * Subscribe to a read-only `Node<T>` as a Vue `Ref<T>`. Auto-unsubscribes on scope disposal.
- * Subscription lifecycle is tied to Vue scope disposal (not node terminal messages).
- */
-export function useSubscribe<T>(node: Node<T>): Readonly<Ref<T | undefined | null>> {
-	const ref = shallowRef(node.cache) as Ref<T | undefined | null>;
-
-	const unsub = node.subscribe(() => {
-		ref.value = node.cache;
-	});
-
-	if (getCurrentScope()) {
-		onScopeDispose(() => unsub());
-	} else if (typeof console !== "undefined") {
-		console.warn(
-			"[graphrefly-ts] useSubscribe called outside a Vue scope — subscription will not be auto-disposed.",
-		);
-	}
-
-	return readonly(ref) as Readonly<Ref<T | undefined | null>>;
-}
-
-/**
- * Bind a writable `Node<T>` as a Vue `Ref<T>`. Reads and writes are bidirectional.
- * Value sets always dispatch `[[DIRTY], [DATA, value]]`, including `value === undefined`.
- * Subscription lifecycle is tied to Vue scope disposal (not node terminal messages).
- */
-export function useStore<T>(node: Node<T>): Ref<T | undefined | null> {
-	const inner = shallowRef(node.cache) as Ref<T | undefined | null>;
-
-	const unsub = node.subscribe(() => {
-		inner.value = node.cache;
-	});
-
-	if (getCurrentScope()) {
-		onScopeDispose(() => unsub());
-	} else if (typeof console !== "undefined") {
-		console.warn(
-			"[graphrefly-ts] useStore called outside a Vue scope — subscription will not be auto-disposed.",
-		);
-	}
-
-	return computed({
-		get: () => inner.value,
-		set: (v: T | undefined | null) => {
-			node.down([[DIRTY], [DATA, v]]);
-		},
-	});
-}
-
-/** Maps a key to an object of nodes. Used by `useSubscribeRecord` factory. */
-export type NodeFactory<K, R extends Record<string, any>> = (key: K) => {
-	[P in keyof R]: Node<R[P]>;
-};
-
-/**
- * Subscribe to a dynamic set of keyed node records. When keys change,
- * old subscriptions are torn down and new ones created automatically.
- * Must be called during Vue `setup()`.
- */
-export function useSubscribeRecord<K extends string, R extends Record<string, any>>(
-	keys: WatchSource<K[] | undefined>,
-	factory: NodeFactory<K, R>,
-): Readonly<Ref<Record<K, R>>> {
-	const result = shallowRef<Record<K, R>>({} as Record<K, R>);
-
-	// Track active subscriptions per key (strictly enclosed memory mapping)
-	const activeSubs = new Map<K, { subs: Array<() => void>; values: R }>();
-	function flushResult() {
-		const snap = {} as Record<K, R>;
-		for (const [key, entry] of activeSubs) {
-			snap[key] = { ...entry.values };
-		}
-		result.value = snap;
-	}
-
-	function sync(newKeys: K[]) {
-		for (const entry of activeSubs.values()) {
-			for (const unsub of entry.subs) unsub();
-		}
-		activeSubs.clear();
-
-		for (const key of newKeys) {
-			const nodes = factory(key);
-			const fields = Object.keys(nodes) as (keyof R)[];
-			const values = {} as R;
-			const subs: Array<() => void> = [];
-
-			for (const field of fields) {
-				const node = nodes[field];
-				values[field] = node.cache as R[keyof R];
-				const unsub = node.subscribe(() => {
-					values[field] = node.cache as R[keyof R];
-					flushResult();
-				});
-				subs.push(unsub);
-			}
-
-			activeSubs.set(key, { subs, values });
-		}
-
-		const snap = {} as Record<K, R>;
-		for (const [key, entry] of activeSubs) {
-			snap[key] = { ...entry.values };
-		}
-		result.value = snap;
-	}
-
-	const readKeys = (): K[] => {
-		const current = typeof keys === "function" ? keys() : isRef(keys) ? keys.value : keys;
-		return [...(current ?? [])];
-	};
-
-	watch(readKeys, (newKeys) => sync(newKeys ?? []), { immediate: true });
-
-	if (getCurrentScope()) {
-		onScopeDispose(() => {
-			for (const entry of activeSubs.values()) {
-				for (const unsub of entry.subs) unsub();
-			}
-			activeSubs.clear();
-		});
-	} else if (typeof console !== "undefined") {
-		console.warn(
-			"[graphrefly-ts] useSubscribeRecord called outside a Vue scope — subscription will not be auto-disposed.",
-		);
-	}
-
-	return readonly(result) as Readonly<Ref<Record<K, R>>>;
-}
diff --git a/src/compat/zustand/index.ts b/src/compat/zustand/index.ts
deleted file mode 100644
index 0d615bea..00000000
--- a/src/compat/zustand/index.ts
+++ /dev/null
@@ -1,94 +0,0 @@
-import { DATA, node as nodeFactory } from "@graphrefly/pure-ts/core";
-import { Graph } from "@graphrefly/pure-ts/graph";
-
-// Zustand fires listeners on every setState, regardless of reference
-// equality. Configure the state node with a permissive equals so every
-// emit produces DATA (not RESOLVED). Diamond coordination still works
-// because `n.emit` routes through the framed pipeline which auto-
-// prefixes `[DIRTY]`.
-const alwaysDiffer = () => false;
-
-/** Zustand-compatible Store API. */
-export interface StoreApi<T> {
-	getState: () => T;
-	setState: (partial: T | Partial<T> | ((state: T) => T | Partial<T>), replace?: boolean) => void;
-	getInitialState: () => T;
-	subscribe: (listener: (state: T, prevState: T) => void) => () => void;
-	destroy: () => void;
-}
-
-/** Function type for initializing the store. */
-export type StateCreator<T> = (
-	set: StoreApi<T>["setState"],
-	get: StoreApi<T>["getState"],
-	api: StoreApi<T>,
-) => T;
-
-/**
- * Creates a Zustand-compatible store backed by a GraphReFly state node.
- * returns an object that is both a Graph and a StoreApi.
- *
- * @example
- * ```ts
- * const store = create((set) => ({
- *   count: 0,
- *   inc: () => set((s) => ({ count: s.count + 1 }))
- * }));
- * store.getState().inc();
- * ```
- *
- * @category compat
- */
-export function create<T extends object>(initializer: StateCreator<T>): Graph & StoreApi<T> {
-	const g = new Graph("zustand");
-	const s = nodeFactory<T>([], {
-		initial: undefined as unknown as T,
-		name: "state",
-		equals: alwaysDiffer,
-	});
-	g.add(s, { name: "state" });
-
-	// `getState` and `setState` read/write through `s` directly — the single
-	// source of truth. `s.cache` is `undefined` (SENTINEL) until `emit()` is
-	// called, but action closures (e.g. `inc: () => set(...)`) are only ever
-	// invoked after initialization, so `s.cache` is valid by that time.
-	const getState = () => s.cache as T;
-	const setState = (partial: any, replace?: boolean): void => {
-		const prev = s.cache as T;
-		const next = typeof partial === "function" ? partial(prev) : partial;
-		// `n.emit` goes through `_actionEmit` → `bundle()`, which auto-
-		// prefixes `[DIRTY]` so diamond legs coordinate under downstream
-		// composition. The `alwaysDiffer` equals keeps zustand's "fire
-		// on every setState" semantics.
-		s.emit(replace ? next : { ...prev, ...next });
-	};
-
-	const api: StoreApi<T> = {
-		getState,
-		setState,
-		getInitialState: () => initialValue,
-		subscribe: (listener) => {
-			// Skip the initial push-on-subscribe DATA — zustand subscribe fires on changes only.
-			let initial = true;
-			let prev = s.cache as T;
-			return s.subscribe((msgs) => {
-				for (const [t, v] of msgs) {
-					if (t === DATA) {
-						if (initial) {
-							initial = false;
-							continue;
-						}
-						listener(v as T, prev);
-						prev = v as T;
-					}
-				}
-			});
-		},
-		destroy: g.destroy.bind(g),
-	};
-
-	const initialValue = initializer(setState, getState, api);
-	s.emit(initialValue);
-
-	return Object.assign(g, api);
-}
diff --git a/src/index.ts b/src/index.ts
deleted file mode 100644
index cf6ac5ff..00000000
--- a/src/index.ts
+++ /dev/null
@@ -1,38 +0,0 @@
-/**
- * @graphrefly/graphrefly — presentation layer for the GraphReFly reactive graph protocol.
- *
- * This package composes:
- * 1. Substrate re-export from @graphrefly/pure-ts (ergonomic single-import: node,
- *    state, graph, derived, effect, produce, batch, operators, data-structures,
- *    storage, stratify, fromTimer, fromPromise, fromAsyncIter, fromAny, etc.)
- * 2. Presentation layers (base → utils → presets → solutions) — patterns, IO
- *    adapters, composition helpers, mutation wrappers, render, compat adapters.
- *
- * Peer dependency: @graphrefly/pure-ts.
- *
- * NOTE (D206, 2026-05-15): npm/pnpm `overrides` to swap this peer to
- * `@graphrefly/native` (Q28/D198 option c) is NOT a working sync
- * drop-in — native's Core runs on a tokio blocking pool and every
- * Core-touching call is async (D070/D077), while this package consumes
- * pure-ts's sync substrate API. Use `@graphrefly/pure-ts` here.
- * `@graphrefly/native` is for direct async-tolerant consumers and the
- * parity-tests rust arm (`createNativeImpl()`). Presentation async
- * rebase (D080) remains deferred. See `docs/rust-port-decisions.md`
- * D206 and `archive/docs/SESSION-DS-native-substrate-contract.md`.
- *
- * Node-only subpath: @graphrefly/graphrefly/base/sources/node
- * Browser-only subpath: @graphrefly/graphrefly/base/sources/browser
- * Compat per-framework: @graphrefly/graphrefly/compat/<framework>
- *
- * @module
- */
-
-// 1. Substrate — node, state, graph, extra (operators, data-structures, storage, sources)
-export * from "@graphrefly/pure-ts";
-
-// 2. Presentation layers (top-down per 4-layer model; CI-enforced by Biome layer-boundary rule)
-export * from "./base/index.js";
-export * from "./presets/index.js";
-export * from "./solutions/index.js";
-export * from "./utils/index.js";
-// compat is namespaced; import from @graphrefly/graphrefly/compat/<framework>
diff --git a/src/loader.ts b/src/loader.ts
deleted file mode 100644
index 252ecf1d..00000000
--- a/src/loader.ts
+++ /dev/null
@@ -1,23 +0,0 @@
-// Phase 13.9.A native-loader marker (no-op).
-//
-// When `@graphrefly/native` (the napi-rs binding compiled from
-// `~/src/graphrefly-rs/crates/graphrefly-bindings-js/`) publishes its
-// per-platform packages and the per-Rust-milestone swap-overs land
-// (`docs/implementation-plan.md` Phase 13.9 step 2), this file becomes the
-// shim's resolution mechanism: try `@graphrefly/native` first, fall back to
-// `@graphrefly/pure-ts` when the native binary is unavailable
-// (sandboxed JS, restricted enterprise, edge runtimes without WASM).
-//
-// Until the binding scaffolds its publishable shape (currently the napi crate
-// has no `package.json`; benches load it via absolute path), this file is a
-// no-op marker. The shim's individual subpath entries directly re-export from
-// `@graphrefly/pure-ts`. Do NOT add `@graphrefly/native` to
-// `optionalDependencies` until that package actually publishes — npm install
-// will fail loud rather than skip an unfindable optional dep.
-//
-// No public exports until the loader actually activates — keeping the symbol
-// shape open avoids locking consumers to a const that future dynamic
-// detection would have to break (see `archive/docs/SESSION-rust-port-architecture.md`
-// Part 12 Q6 for the shim selection contract).
-
-export {};
diff --git a/src/presets/ai/agent-loop.ts b/src/presets/ai/agent-loop.ts
deleted file mode 100644
index 9ddf81ad..00000000
--- a/src/presets/ai/agent-loop.ts
+++ /dev/null
@@ -1,959 +0,0 @@
-/**
- * Reactive agent loop — autonomous multi-turn LLM agent with tool execution.
- */
-
-export type AgentLoopStatus = "idle" | "thinking" | "acting" | "done" | "error";
-
-import {
-	batch,
-	DATA,
-	ERROR,
-	INVALIDATE,
-	type Node,
-	node,
-	node as nodeFactory,
-	placeholderArgs,
-	RESOLVED,
-} from "@graphrefly/pure-ts/core";
-import { fromAny, keepalive, switchMap } from "@graphrefly/pure-ts/extra";
-import { Graph, type GraphOptions } from "@graphrefly/pure-ts/graph";
-import { awaitSettled } from "../../base/sources/settled.js";
-import { aiMeta } from "../../utils/ai/_internal.js";
-import type {
-	ChatMessage,
-	LLMAdapter,
-	LLMResponse,
-	ToolCall,
-	ToolDefinition,
-} from "../../utils/ai/adapters/core/types.js";
-import { type ChatStreamGraph, chatStream } from "../../utils/ai/agents/chat-stream.js";
-import { type ToolResult, toolExecution } from "../../utils/ai/agents/tool-execution.js";
-import { type ToolRegistryGraph, toolRegistry } from "../../utils/ai/agents/tool-registry.js";
-
-export type { ToolResult } from "../../utils/ai/agents/tool-execution.js";
-
-// ---------------------------------------------------------------------------
-// agentLoop
-// ---------------------------------------------------------------------------
-
-export type AgentLoopOptions = {
-	graph?: GraphOptions;
-	adapter: LLMAdapter;
-	tools?: readonly ToolDefinition[];
-	systemPrompt?: string;
-	maxTurns?: number;
-	stopWhen?: (response: LLMResponse) => boolean;
-	onToolCall?: (call: ToolCall) => void;
-	maxMessages?: number;
-	model?: string;
-	temperature?: number;
-	maxTokens?: number;
-	/**
-	 * Reactive tool-call splice (COMPOSITION-GUIDE §31 "interception is security").
-	 * When set, the raw `toolCalls` node is piped through this transform before
-	 * reaching the executor. The transform is a pure reactive composition —
-	 * `(calls: Node<readonly ToolCall[]>) => Node<readonly ToolCall[]>` — so the
-	 * gate is visible in `describe()` / `explain()` as a real edge (no hidden
-	 * imperative wraps; §24).
-	 *
-	 * Typical uses:
-	 * - **Filter / block** — `derived([calls, policy], ([raw, p]) => raw.filter(p))`
-	 * - **Throttle / debounce** — `throttle(calls, windowMs)`
-	 * - **Human-in-the-loop approval** — pipe through a `gate` controller so
-	 *   calls wait for human approval before reaching the executor.
-	 *
-	 * The public `agent.toolCalls` node surfaces the POST-intercept stream, so
-	 * audit / telemetry consumers see what the executor actually runs. The raw
-	 * pre-intercept stream is not exposed — tests that need it should run
-	 * without `interceptToolCalls` set (the identity case).
-	 */
-	interceptToolCalls?: (calls: Node<readonly ToolCall[]>) => Node<readonly ToolCall[]>;
-};
-
-/**
- * Reactive agent loop.
- *
- * The loop is a reactive state machine wired entirely from graph primitives:
- * `chat.messages` + `tools.schemas` + gating state feed a `promptInput`
- * derived; `switchMap` turns non-null inputs into an LLM invocation via
- * `fromAny(adapter.invoke(...))`. The LLM response drives chat writes and
- * status transitions via effects. Tool calls flow through a reactive
- * executor (`retrySource` + `rescue`) that retries once on error and
- * surfaces terminal errors as JSON-shaped `ToolResult` payloads for the
- * LLM to react to.
- *
- * **No imperative control flow inside the reactive layer** (spec §5.8-5.12):
- * no `while` loops, no manual `await adapter.invoke`, no polling.
- * `agent.run()` is a thin `awaitSettled` bridge so callers can still `await`
- * the loop if they want a Promise.
- *
- * Public surface:
- * - `chat` / `tools` — subgraphs (imperative `append` at boundary, reactive `executeReactive` for tool invocation)
- * - `status` / `turn` / `aborted` — state nodes with explicit initials
- * - `lastResponse` / `toolCalls` / `toolResults` — reactive outputs (SENTINEL until first emission; callers use `awaitSettled` / `subscribe`)
- * - `run(userMessage?, signal?)` — optional user append + Promise bridge
- * - `abort()` — imperative abort shim; flips `aborted` state
- *
- * **Lifecycle: single-mount.** `AgentLoopGraph` instances expect to be
- * constructed once and used until `destroy()`. The internal closure mirrors
- * (`latestTurn` / `latestAborted` / `latestStatus`) are wired by
- * subscribe-and-capture at construction time; their `addDisposer`-registered
- * subscriptions are torn down on subgraph unmount or `destroy()`. After
- * teardown the mirrors freeze at their last value, so re-using a destroyed
- * instance — calling `run()` again, or remounting under a new parent —
- * would silently feed stale mirror data into reactive fn bodies. If you
- * need to "reset" an agent, build a fresh `AgentLoopGraph` instance instead
- * of recycling.
- */
-export class AgentLoopGraph extends Graph {
-	readonly chat: ChatStreamGraph;
-	readonly tools: ToolRegistryGraph;
-
-	/** Current agent status. `initial: "idle"` — always has a real value. */
-	readonly status: Node<AgentLoopStatus>;
-	/** Turn count (completed LLM invocations this run). `initial: 0`. */
-	readonly turn: Node<number>;
-	/** Aborted flag; flipped by `abort()` or external `AbortSignal`. `initial: false`. */
-	readonly aborted: Node<boolean>;
-
-	/**
-	 * Most recent LLM response. State-backed mirror driven by the response
-	 * effect. **Stays SENTINEL** (`cache === undefined`, no DATA emitted)
-	 * until the first real response — bridge subscribers see no spurious
-	 * push-on-subscribe DATA. After a real response, holds the latest
-	 * `LLMResponse`. Reset between `run()` calls via `[[INVALIDATE]]` (clears
-	 * cache back to SENTINEL) so a second run with a pre-aborted signal
-	 * cannot leak the prior run's response. Bridge with
-	 * `awaitSettled(lastResponse)` for the first DATA as a Promise; consumers
-	 * inside reactive fns gate on `ctx.prevData[i] === undefined`.
-	 */
-	readonly lastResponse: Node<LLMResponse>;
-	/** Tool-call batch emitted by the most recent LLM response. SENTINEL. */
-	readonly toolCalls: Node<readonly ToolCall[]>;
-	/** Tool-result batch (one entry per call) after reactive execution. SENTINEL. */
-	readonly toolResults: Node<readonly ToolResult[]>;
-
-	private readonly _terminalResult: Node<LLMResponse>;
-	private readonly _disposeRunWiring: () => void;
-	/** Guards against overlapping `run()` calls. */
-	private _running = false;
-	/**
-	 * Abort controller for the currently-running `adapter.invoke`. Minted per
-	 * switchMap project; aborted when the reactive `aborted` node flips true
-	 * OR when the caller's external `AbortSignal` fires. Threaded into
-	 * `adapter.invoke({ signal })` AND `fromAny(promise, { signal })`, so the
-	 * reactive layer sees ERROR when the wire call is cancelled.
-	 */
-	private _currentAbortController: AbortController | null = null;
-
-	constructor(name: string, opts: AgentLoopOptions) {
-		super(name, opts.graph);
-
-		// Mount chat subgraph
-		this.chat = chatStream(`${name}-chat`, { maxMessages: opts.maxMessages });
-		this.mount("chat", this.chat);
-
-		// Mount tool registry subgraph
-		this.tools = toolRegistry(`${name}-tools`);
-		this.mount("tools", this.tools);
-
-		if (opts.tools) {
-			for (const tool of opts.tools) {
-				this.tools.register(tool);
-			}
-		}
-
-		// --- State nodes (always have a real value; explicit initials) ---
-		this.status = node<AgentLoopStatus>([], {
-			...{
-				name: "status",
-				describeKind: "state",
-				meta: aiMeta("agent_status"),
-			},
-			initial: "idle",
-		});
-		this.add(this.status, { name: "status" });
-
-		this.turn = node<number>([], {
-			...{
-				name: "turn",
-				describeKind: "state",
-				meta: aiMeta("agent_turn_count"),
-			},
-			initial: 0,
-		});
-		this.add(this.turn, { name: "turn" });
-
-		this.aborted = node<boolean>([], {
-			...{
-				name: "aborted",
-				describeKind: "state",
-				meta: aiMeta("agent_aborted"),
-			},
-			initial: false,
-		});
-		this.add(this.aborted, { name: "aborted" });
-
-		// --- Reactive pipeline ---
-		//
-		// **Read pattern (Phase 12 D1 lock + F2 fix 2026-05-01).** State
-		// scratchpad held on this `AgentLoopGraph` (turn / aborted / chat /
-		// tools) is read inside reactive fn bodies via either:
-		//   (a) `data[i]` / `ctx.prevData[i]` for declared deps, OR
-		//   (b) sole-owner `.cache` reads on subgraph-mounted state Nodes
-		//       (chat / tools mounted as subgraphs of this Graph; the agent
-		//       is the sole owner; promptInput / effResponse / effResults
-		//       live in the same enclosing constructor scope — sanctioned
-		//       form per Phase 12 D1 read-pattern lock).
-		//
-		// Closure mirrors (`latestTurn` / `latestAborted` / `latestStatus`)
-		// are kept ONLY for fields where (b) doesn't simplify the call site
-		// — turn / aborted / status are state Nodes registered on `this`
-		// directly (not subgraphs), and the closure form keeps
-		// effResponse's batch logic readable. They are CORRECT but are NOT
-		// safe under nested drains (the subscribe handler may not have run
-		// yet when a downstream fn reads the closure). For nested-drain-
-		// reachable reads (promptInput, called via `agentLoop.run` from
-		// inside another graph's reactive subscribe handler), prefer (a) or
-		// (b) over the closure mirror. F2 root cause: chat.messages.cache
-		// is updated DURING the DATA-settle phase (before subscribers
-		// run), so `.cache` reads are always at least as fresh as closure
-		// mirrors. See `optimizations.md` "Phase 13 design-session inputs
-		// from §13.M lock-test" F2.
-		//
-		// **Pattern note on `latestTurn` staleness under in-batch reads.**
-		// Effect 1 emits `turnNode.emit(next)` inside its batch; Effect 2
-		// reads `latestTurn` on the following wave (after toolResults
-		// settle). Because batch drain is FIFO, `turnSub`'s handler runs
-		// before Effect 2's next wave fires, so `latestTurn` is up-to-date
-		// by the time Effect 2 reads it. This invariant is stable as long
-		// as `turnNode.emit` remains inside Effect 1's batch — a future
-		// refactor that un-batches the emit would regress silently.
-		let latestTurn = 0;
-		const turnSub = this.turn.subscribe((msgs) => {
-			for (const m of msgs) if (m[0] === DATA) latestTurn = m[1] as number;
-		});
-		let latestAborted = false;
-		const abortedSub = this.aborted.subscribe((msgs) => {
-			for (const m of msgs) if (m[0] === DATA) latestAborted = m[1] as boolean;
-		});
-
-		const adapter = opts.adapter;
-		const systemPrompt = opts.systemPrompt;
-		const model = opts.model;
-		const temperature = opts.temperature;
-		const maxTokens = opts.maxTokens;
-		const maxTurns = opts.maxTurns ?? 10;
-		const stopWhen = opts.stopWhen;
-
-		// Capture `this` for closures that don't bind `this`.
-		const chat = this.chat;
-		const tools = this.tools;
-		const statusNode = this.status;
-		const turnNode = this.turn;
-		const abortedNode = this.aborted;
-
-		// promptInput: STATUS is the only reactive trigger — chat.messages,
-		// tools.schemas, turn, aborted are sampled via closure-held mirrors
-		// (all populated by subscribe-and-capture above). This prevents the
-		// classic feedback cycle (COMPOSITION-GUIDE §7): if chat.messageCount
-		// were a reactive dep here, effect 1's `chat.append` would trigger a
-		// promptInput wave, which under effect-1's batch would see status
-		// STILL "thinking" (pre-drain) and fire a spurious LLM invocation.
-		// By gating only on status, chat writes don't re-trigger — only
-		// explicit status transitions do.
-		const promptInput: Node<InvokeInput> = nodeFactory<InvokeInput>(
-			[statusNode],
-			(data, actions, ctx) => {
-				const stat = readLatest<AgentLoopStatus>(data, ctx.prevData, 0, "idle");
-				if (stat !== "thinking" || latestAborted || latestTurn >= maxTurns) {
-					actions.down([[RESOLVED]]);
-					return;
-				}
-				// F2 fix (2026-05-01): under nested drains, the closure mirrors
-				// `latestMessages` / `latestSchemas` lag the actual node state —
-				// messagesSub / schemasSub subscribers may not have run yet when
-				// promptInput fires (the drain processes status's downstream
-				// before chat.messages's subscribers fire, even though
-				// chat.messages.cache is already settled). Read `.cache`
-				// directly per Phase 12 D1 read-pattern lock: chat / tools are
-				// mounted as subgraphs of this AgentLoopGraph (sole owner) and
-				// promptInput is a reactive reader in the same enclosing
-				// constructor scope — sanctioned `.cache` form. See
-				// `optimizations.md` "Phase 13 design-session inputs from §13.M
-				// lock-test" F2.
-				const messages = (this.chat.messages.cache as readonly ChatMessage[] | undefined) ?? [];
-				if (messages.length === 0) {
-					actions.down([[RESOLVED]]);
-					return;
-				}
-				const schemas = (this.tools.schemas.cache as readonly ToolDefinition[] | undefined) ?? [];
-				actions.emit({ messages, tools: schemas });
-			},
-			{
-				name: "promptInput",
-				describeKind: "derived",
-				meta: aiMeta("agent_prompt_input", {
-					// State this fn body samples beyond its declared `statusNode`
-					// dep. `aborted` / `turn` come from §28 closure mirrors
-					// (`latestAborted` / `latestTurn`); `chat.messages` /
-					// `tools.schemas` come from sole-owner `.cache` reads
-					// (Phase 12 D1 lock + F2 fix; see comment block above).
-					// Listed here so inspection tooling can surface fold-in
-					// state without grepping source.
-					closureReads: ["aborted", "turn", "chat.messages", "tools.schemas"],
-				}),
-			},
-		);
-
-		const llmResponse: Node<LLMResponse> = switchMap(
-			promptInput,
-			(input) => {
-				const controller = new AbortController();
-				this._currentAbortController = controller;
-				if (latestAborted) {
-					controller.abort(new Error("agentLoop: aborted"));
-				}
-				// Wave A Unit B-CC fix: drop the `Promise.resolve(adapter.invoke(...))`
-				// wrapper. `adapter.invoke` returns a `NodeInput<LLMResponse>`
-				// (Promise | Node | raw). `fromAny` already handles all three
-				// shapes; the manual `Promise.resolve` wrapper would force a
-				// Node-returning adapter into an extra microtask hop and lose
-				// reactivity (see Unit 11 + Unit 1 for the parallel cleanup).
-				return fromAny(
-					adapter.invoke(input.messages, {
-						tools: input.tools.length > 0 ? input.tools : undefined,
-						systemPrompt,
-						model,
-						temperature,
-						maxTokens,
-						signal: controller.signal,
-					}),
-					{ signal: controller.signal },
-				);
-			},
-			{ equals: () => false },
-		);
-
-		// State mirror for `lastResponse` — exists for **cross-run reset
-		// semantics**, NOT the §32 mid-wave hazard.
-		//
-		// Why: `llmResponse` is a switchMap output; its cache persists across
-		// `run()` calls (switchMap's output node has no built-in reset path —
-		// the cache stays at the last DATA the inner emitted). A second
-		// `run()` with a pre-aborted signal would otherwise have
-		// `_terminalResult` evaluate `stat=done` (driven by `effAbort`) +
-		// `resp=<prior run's response>` (cached on `llmResponse`) and resolve
-		// the Promise with stale data instead of rejecting with AbortError.
-		// The mirror is **reset via `[[INVALIDATE]]`** in `run()`'s reset
-		// batch — INVALIDATE clears `_cached` back to `undefined` (SENTINEL)
-		// AND clears the `prevData` slot on every dependent (`_terminalResult`,
-		// `toolCallsRaw`), so the abort path correctly emits
-		// `[[ERROR, AbortError]]` from terminalResult's `stat="done" &&
-		// prevData[lastResponse] === undefined → ERROR` guard.
-		//
-		// **No `T | null` placeholder.** Per `feedback_use_prevdata_for_sentinel`
-		// + COMPOSITION-GUIDE §1a, the SENTINEL state IS the "never sent
-		// real DATA yet" signal. An eager `initial: null` would push `[null]`
-		// to every fresh subscriber — a footgun for bridge subscribers that
-		// would otherwise need `if (resp == null) continue` guards. Stay
-		// SENTINEL; consumers detect "no response yet" via
-		// `ctx.prevData[i] === undefined` (or `cache === undefined` outside
-		// reactive fns). F9 lock-test (`multi-agent-example.test.ts` test 5)
-		// pins this invariant.
-		//
-		// What this does NOT solve: the §32 mid-wave "stale peer-read"
-		// hazard. Investigation (2026-04-25) confirmed `_dirtyDepCount`
-		// gating in `_maybeRunFnOnSettlement` already prevents that — when
-		// `effResponse`'s nested batch fires `status="done"` mid-iteration,
-		// terminal's status dep settles but its `llmResponse` (or mirror)
-		// dep is still DIRTY from Phase 1, so the fn does not run until
-		// Phase 2 visits both deps. Verified by fast-check invariant `#12b
-		// nested-drain-peer-consistency-compound` and by the multi-turn
-		// `executes tool calls and loops` test passing under either dep
-		// shape (`[statusNode, llmResponse]` or `[statusNode, lastResponseState]`).
-		//
-		// Verified by: QA C3 regression tests (`run() with pre-aborted
-		// signal rejects AbortError` and `second run() with pre-aborted
-		// signal rejects AbortError (no stale response leak)`) — both
-		// fail when `_terminalResult` is rewired to depend on `llmResponse`
-		// directly. See COMPOSITION-GUIDE §32 (cross-wave reset reframe).
-		const lastResponseState = node<LLMResponse>([], {
-			name: "lastResponse",
-			describeKind: "state",
-			meta: aiMeta("agent_last_response"),
-		});
-		this.lastResponse = lastResponseState;
-
-		// toolCalls: raw node that emits DATA only when status === "acting" and
-		// the current response has tool calls. Otherwise emits RESOLVED. Using
-		// DATA([]) for the idle case would cause switchMap(toolCalls) to
-		// re-dispatch its inner (creating a fresh node([], { initial: [] }) source whose
-		// emissions re-trigger effects downstream). RESOLVED keeps the inner
-		// alive and lets upstream waves pass through without re-dispatch.
-		// Inner raw tool-call stream — name `toolCallsRaw` so the post-intercept
-		// public surface (`this.toolCalls`) is unambiguous in `describe()`.
-		// QA-fix: previously the inner was named `"toolCalls"`, which collided
-		// with `this.toolCalls` if the user-supplied interceptor returned a
-		// wrapper that internally retained a reference to this raw node —
-		// `describe()` would render two distinct nodes both labeled `"toolCalls"`.
-		const toolCallsRaw = nodeFactory<readonly ToolCall[]>(
-			[lastResponseState, statusNode],
-			(data, actions, ctx) => {
-				// SENTINEL guard: `lastResponseState` stays `undefined` (cache
-				// + prevData) until the first real response. `readLatest`'s
-				// fallback returns `undefined` here so the no-DATA branch is
-				// indistinguishable from the protocol SENTINEL — both gate to
-				// RESOLVED. Per `feedback_use_prevdata_for_sentinel`.
-				const resp = readLatest<LLMResponse | undefined>(data, ctx.prevData, 0, undefined);
-				const stat = readLatest<AgentLoopStatus>(data, ctx.prevData, 1, "idle");
-				if (stat !== "acting") {
-					actions.down([[RESOLVED]]);
-					return;
-				}
-				const calls = resp?.toolCalls;
-				if (calls == null || calls.length === 0) {
-					actions.down([[RESOLVED]]);
-					return;
-				}
-				actions.emit(calls);
-			},
-			{
-				name: "toolCallsRaw",
-				describeKind: "derived",
-				meta: aiMeta("agent_tool_calls_raw"),
-			},
-		);
-		// Reactive splice (D9 / COMPOSITION-GUIDE §31). When `interceptToolCalls`
-		// is set, the raw tool-call stream is transformed in the graph — the
-		// executor sees the gated stream, and `agent.toolCalls` surfaces the
-		// post-intercept view so audit / telemetry match reality.
-		const gatedToolCallsNode = opts.interceptToolCalls
-			? opts.interceptToolCalls(toolCallsRaw)
-			: toolCallsRaw;
-		this.toolCalls = gatedToolCallsNode;
-
-		// Delegate per-call fan-out + retry + rescue to the `toolExecution`
-		// primitive. `toolCallsRaw` already gates empty batches to RESOLVED,
-		// so `toolExecution`'s "non-empty batch only" contract is satisfied
-		// upstream. `retryCount: 1` matches the pre-extraction behaviour
-		// (one retry after first failure = 2 attempts total).
-		const toolResultsNode: Node<readonly ToolResult[]> = toolExecution({
-			toolCalls: gatedToolCallsNode,
-			tools,
-			retryCount: 1,
-		});
-		this.toolResults = toolResultsNode;
-
-		// --- State-machine effects ---
-		// Effect 1: LLM response landed → write lastResponse mirror + chat,
-		// transition status, increment turn. Emission ORDER inside the batch
-		// matters (drain is FIFO under any outer-batch depth):
-		//   1. `lastResponseState.emit(response)` FIRST — so when the drain
-		//      fires the status=done wave later in the queue, `_terminalResult`'s
-		//      dep on `lastResponseState` has already been updated.
-		//   2. `statusNode.emit(nextStatus)` — drives state machine.
-		//   3. `turnNode.emit(next)` — counter.
-		//   4. `chat.append(...)` LAST — chat.messageCount wave now sees the
-		//      new status (so `promptInput` gates correctly).
-		// Without (1) first, `_terminalResult` reads stale `prevData` for
-		// lastResponse when status transitions synchronously during drain.
-		//
-		// **Invariant independence from outer batch depth.** `downWithBatch`
-		// preserves FIFO drain order regardless of nesting — whether the
-		// outer batch is at depth 0 (common: Promise microtask) or depth >0
-		// (user-composed `batch()` scope around `agent.run()`), the emissions
-		// above drain in the order they were enqueued. The state-mirror
-		// pattern holds in both cases.
-		//
-		// **Abort guard (C2 defense-in-depth).** If the `aborted` state has
-		// flipped true between `adapter.invoke`'s Promise resolution and this
-		// effect firing (micro-race), bail out so we don't append to chat or
-		// execute tool calls for an abandoned run. The controller.abort() in
-		// effAbort also fires the signal, which causes `fromAny` to emit
-		// ERROR — but that ERROR propagation arrives in a separate wave, so
-		// this guard covers the "Promise already resolved before abort hit
-		// the controller" case.
-		const effResponse = node(
-			[llmResponse],
-			(batchData, _actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				if (latestAborted) return;
-				const response = data[0] as LLMResponse;
-				const next = latestTurn + 1;
-				const hasToolCalls = response.toolCalls != null && response.toolCalls.length > 0;
-				const naturalStop =
-					response.finishReason === "end_turn" &&
-					(!response.toolCalls || response.toolCalls.length === 0);
-				const customStop = stopWhen?.(response) === true;
-				const capReached = next >= maxTurns;
-				const nextStatus: AgentLoopStatus =
-					customStop || naturalStop || !hasToolCalls || capReached ? "done" : "acting";
-				batch(() => {
-					lastResponseState.emit(response);
-					statusNode.emit(nextStatus);
-					turnNode.emit(next);
-					chat.append("assistant", response.content, {
-						toolCalls: response.toolCalls,
-					});
-					// EC-2 (DS-2.7.A /qa carry, resolved 2026-05-21):
-					// cap-reached with pending `tool_use` blocks needs synthetic
-					// `tool_result`s — every `tool_use` requires a paired
-					// `tool_result` per Anthropic/OpenAI tool-use schemas, else
-					// audit/replay consumers replaying `loop.chat.allMessages()`
-					// into a fresh `adapter.invoke` see an invalid transcript.
-					// `effFullDeny` (when wired) CANNOT help here: status flips
-					// to `"done"` in this same batch, so `toolCallsRaw` gates
-					// RESOLVED on the next wave (its `stat === "acting"` guard)
-					// and `effFullDeny`'s diamond never delivers DATA. Mirrors
-					// `effFullDeny`'s `"[tool call denied by interceptor]"`
-					// pattern with a maxTurns-specific reason string.
-					if (capReached && hasToolCalls) {
-						for (const tc of response.toolCalls as readonly ToolCall[]) {
-							chat.appendToolResult(tc.id, "[tool call denied: maxTurns reached]");
-						}
-					}
-				});
-			},
-			{ describeKind: "effect" },
-		);
-
-		// Effect 2: Tool results landed → append to chat, transition to
-		// thinking (or done if turn cap reached). Same ordering discipline —
-		// status emits before chat mutations. Abort guard mirrors effResponse.
-		const effResults = node(
-			[toolResultsNode],
-			(batchData, _actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				if (latestAborted) return;
-				const arr = data[0] as readonly ToolResult[];
-				if (arr.length === 0) return;
-				const nextStatus: AgentLoopStatus = latestTurn >= maxTurns ? "done" : "thinking";
-				batch(() => {
-					statusNode.emit(nextStatus);
-					for (const r of arr) chat.appendToolResult(r.id, r.content);
-				});
-			},
-			{ describeKind: "effect" },
-		);
-
-		// Effect 2b: interceptor-denial recovery. `effResponse` commits
-		// `status="acting"` from the LLM's *pre-intercept* `response.toolCalls`.
-		// When an interceptor denies EVERY call, the post-intercept stream emits
-		// RESOLVED (no DATA) — `toolExecution` no-ops, `effResults` never fires,
-		// and `status` is stranded at "acting" forever (`run()` never resolves;
-		// the original liveness bug). On partial deny, `effResults` advances
-		// status correctly for the allowed subset, but the *denied* subset has
-		// no matching `tool_result` — every assistant `tool_use` block needs
-		// one for the next `adapter.invoke` to see a valid transcript per the
-		// LLM-vendor schemas. This effect handles both: it synthesizes
-		// `"[tool call denied by interceptor]"` `tool_result`s for whichever
-		// calls were dropped (the full set on full deny, the dropped subset on
-		// partial deny) so the LLM can adapt under the policy (user-locked:
-		// continue, not terminate).
-		//
-		// **Why a [raw, gated] diamond with explicit `partial: true` and NO
-		// `ctx.latestData[1]` fallback.** `gatedToolCallsNode` derives from
-		// `toolCallsRaw`, so the two deps form a diamond — the fn recomputes
-		// once after both settle (spec §1.4 / §2.7), with `batchData[0]` = the
-		// raw requested calls and `batchData[1]` = the gate's emission *this
-		// wave*. The core `node()` default is `partial: false` (node.ts
-		// `opts.partial ?? false`); under that default, an R2.7.0 first-run
-		// gate would hold this fn forever once the gate hits a RESOLVED-only
-		// dep (the gate releases only on real DATA per R2.7.0). Explicit
-		// `partial: true` opts into spec R2.7.2 (DS-2.7.A, 2026-05-19): the
-		// gate is OFF and the fn-body is contractually responsible for
-		// guarding SENTINEL slots. We DELIBERATELY do not fall back to
-		// `ctx.latestData[1]` (the public name for `DepRecord.prevData`):
-		// the signal IS "the gate delivered no DATA this wave" (RESOLVED on
-		// the full-deny branch). A fallback would read a *prior allowed
-		// turn*'s calls and mask the deny.
-		//
-		// Only wired when an interceptor is configured (`gatedToolCallsNode
-		// !== toolCallsRaw`): without one there is no deny path, and a
-		// `[toolCallsRaw, toolCallsRaw]` duplicate-dep node would be pointless.
-		//
-		// **Closure-mirror staleness** — the `latestTurn` read below relies on
-		// the same FIFO drain ordering invariant the existing block at lines
-		// ~224–231 documents for `effResults`. `turnNode.emit` lives inside
-		// `effResponse`'s outer batch; `turnSub` drains BEFORE the diamond
-		// settles `effFullDeny`. A future refactor that un-batches that emit
-		// would regress all three effects together — keep the discipline.
-		//
-		// **Belt-and-suspenders maxTurns guard.** On normal flow `effResponse`
-		// already sets `status="done"` when `next >= maxTurns`, so by the time
-		// `toolCallsRaw` would fire (status==="acting" gate) we're past the
-		// cap-reaching turn and `effFullDeny` doesn't run. The
-		// `latestTurn >= maxTurns ? "done" : "thinking"` check below is
-		// defense-in-depth in case a future refactor inverts the ordering
-		// (cheap, no path to a runtime bug).
-		const effFullDeny =
-			gatedToolCallsNode !== toolCallsRaw
-				? node(
-						[toolCallsRaw, gatedToolCallsNode],
-						(batchData) => {
-							if (latestAborted) return;
-							const rawBatch = batchData[0];
-							const gatedBatch = batchData[1];
-							const rawCalls =
-								rawBatch != null && rawBatch.length > 0
-									? (rawBatch.at(-1) as readonly ToolCall[])
-									: null;
-							// No real request this wave (RESOLVED upstream) — nothing to recover.
-							if (rawCalls == null || rawCalls.length === 0) return;
-							// Gate's emission this wave — null/empty when the interceptor
-							// produced RESOLVED (full deny); non-empty array of the allowed
-							// subset on partial deny / full allow.
-							const gatedCalls =
-								gatedBatch != null && gatedBatch.length > 0
-									? (gatedBatch.at(-1) as readonly ToolCall[])
-									: null;
-							// Denied subset = calls in raw not present in gated (by id).
-							// Full deny → all rawCalls. Partial deny → subtraction.
-							// Full allow → empty array (no recovery needed).
-							const allowedIds = gatedCalls === null ? null : new Set(gatedCalls.map((c) => c.id));
-							const denied =
-								allowedIds === null ? rawCalls : rawCalls.filter((c) => !allowedIds.has(c.id));
-							if (denied.length === 0) return; // full allow — effResults owns it
-							const isFullDeny = gatedCalls === null;
-							batch(() => {
-								// Full deny → advance status here (effResults never fires).
-								// Partial deny → DON'T touch status; effResults will transition
-								// after the allowed subset's tool-execution completes, so we
-								// only fill in the missing tool_results for the denied subset.
-								if (isFullDeny) {
-									statusNode.emit(latestTurn >= maxTurns ? "done" : "thinking");
-								}
-								for (const c of denied)
-									chat.appendToolResult(c.id, "[tool call denied by interceptor]");
-							});
-						},
-						{
-							name: "fullDenyRecovery",
-							describeKind: "effect",
-							meta: aiMeta("agent_full_deny_recovery"),
-							// MUST be explicit: the core `node()` default is
-							// `partial: false` (node.ts `opts.partial ?? false`),
-							// and `gatedToolCallsNode` only ever emits RESOLVED on the
-							// full-deny path (never DATA/terminal). Spec R2.7.0
-							// (DS-2.7.A, 2026-05-19) holds the `partial: false`
-							// first-run gate until every dep has contributed real
-							// DATA, so a `partial: false` effFullDeny would hold the
-							// fn FOREVER. Spec R2.7.2 = `partial: true` disables the
-							// gate; the fn body's `denied`-subtraction guard above
-							// covers the SENTINEL slot per the R2.7.2 author
-							// contract.
-							partial: true,
-						},
-					)
-				: null;
-
-		// Effect 3: external abort → cancel in-flight wire call + terminal status.
-		// Aborting the controller causes the switchMap inner's `fromAny` to
-		// emit ERROR (signal-bound), which tears down the subscription. The
-		// `status="done"` emit drives `_terminalResult` to resolve `run()`'s
-		// Promise (via AbortError when `resp == null`, see C3).
-		//
-		// Unit 4 Q5: status guard — if status is already "done" (the natural-
-		// completion path raced the abort), skip the redundant emit so the
-		// status-node event log isn't polluted with a trailing duplicate.
-		// Closure-mirror `latestStatus` keeps the comparison synchronous and
-		// P3-compliant (closure read, not `.cache` read — see §28). Seeded
-		// from `statusNode.cache` to match the §28 factory-time-seed pattern
-		// that `latestTurn` / `latestAborted` use — the literal `"idle"` would
-		// silently drift if the constructor initial value ever changed.
-		let latestStatus: AgentLoopStatus = (statusNode.cache as AgentLoopStatus | undefined) ?? "idle";
-		const statusSub = statusNode.subscribe((msgs) => {
-			for (const m of msgs) if (m[0] === DATA) latestStatus = m[1] as AgentLoopStatus;
-		});
-		const effAbort = node(
-			[abortedNode],
-			(batchData, _actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				if (data[0] === true) {
-					this._currentAbortController?.abort(new Error("agentLoop: aborted"));
-					if (latestStatus !== "done") statusNode.emit("done");
-				}
-			},
-			{ describeKind: "effect" },
-		);
-
-		// Keepalive so the pipeline stays activated even without external
-		// subscribers. Callers don't need to subscribe to `llmResponse` /
-		// `toolResults` for the loop to run.
-		const kaResponse = keepalive(effResponse);
-		const kaResults = keepalive(effResults);
-		const kaFullDeny = effFullDeny ? keepalive(effFullDeny) : null;
-		const kaAbort = keepalive(effAbort);
-
-		// terminalResult emits the final `LLMResponse` on each "done"
-		// transition. The old compound `{response, runVersion}` shape existed
-		// to let a re-entrant caller's `awaitSettled` predicate filter out
-		// the PREVIOUS run's cached DATA; that job now belongs to
-		// `awaitSettled({skipCurrent: true})` (extra/sources.ts) which
-		// ignores the initial push-on-subscribe DATA and resolves only on
-		// fresh post-subscribe emissions. Retiring the stamp removes a
-		// closure-held counter and a per-emission object allocation from
-		// the hot path.
-		//
-		// C3 (abort-before-response) post-SENTINEL: when `stat === "done"` but
-		// `lastResponseState` is SENTINEL (no DATA ever delivered for this
-		// run — `prevData[1] === undefined`, equivalently `resp === undefined`
-		// after `readLatest`'s fallback), emit `ERROR(AbortError)` so the
-		// awaiting Promise rejects instead of hanging on a RESOLVED. The
-		// SENTINEL state is restored at every `run()` boundary by
-		// `lastResponse.down([[INVALIDATE]])` (clears `_cached` AND clears
-		// each dependent's `prevData` slot for this dep), so a second run
-		// after a successful first run still detects the abort cleanly —
-		// no stale `prevData` leak.
-		this._terminalResult = nodeFactory<LLMResponse>(
-			[statusNode, lastResponseState],
-			(data, actions, ctx) => {
-				const stat = readLatest<AgentLoopStatus>(data, ctx.prevData, 0, "idle");
-				const resp = readLatest<LLMResponse | undefined>(data, ctx.prevData, 1, undefined);
-				if (stat === "done") {
-					if (resp !== undefined) {
-						actions.emit(resp);
-						return;
-					}
-					const err = new Error("agentLoop: aborted") as Error & { name: string };
-					err.name = "AbortError";
-					actions.down([[ERROR, err]]);
-					return;
-				}
-				if (stat === "error") {
-					actions.down([[ERROR, new Error("agentLoop: errored")]]);
-					return;
-				}
-				actions.down([[RESOLVED]]);
-			},
-			{
-				name: "terminalResult",
-				describeKind: "derived",
-				meta: aiMeta("agent_terminal_result"),
-				// `lastResponseState` is SENTINEL until the first real response
-				// arrives — without `partial: true`, the spec §2.7 first-run
-				// gate would block this fn from ever firing on the abort-
-				// before-response path (`status → "done"` while `lastResponse`
-				// has never delivered DATA). The fn explicitly handles the
-				// SENTINEL case (`resp === undefined → ERROR(AbortError)`),
-				// so partial-fire is safe by design.
-				partial: true,
-			},
-		);
-		// Wave B-CC Q2/C: register intermediate pipeline nodes so consumers
-		// can `observe(path)` them by name (e.g. `agent.observe("promptInput")`).
-		// They were already visible in `describe()` via dep traversal, but not
-		// path-addressable. Tools using the `observe`-by-path API now work.
-		//
-		// QA-fix (#5 stability): registrations live AFTER ALL dependent nodes
-		// are constructed (`promptInput → llmResponse → effResponse →
-		// lastResponseState → toolCallsRaw → toolResultsNode → effResults →
-		// effAbort → _terminalResult`). Topology event-stream consumers
-		// subscribed at construction time now see registrations in an order
-		// where every edge between two registered nodes is already valid —
-		// no transient partial graph slipping through to live mermaid / d2
-		// renderers.
-		this.add(promptInput as Node<unknown>, { name: "promptInput" });
-		this.add(llmResponse as Node<unknown>, { name: "llmResponse" });
-		this.add(this.lastResponse as Node<unknown>, { name: "lastResponse" });
-		// When no interceptor is configured, `this.toolCalls === toolCallsRaw` —
-		// registering the same instance under two names trips the per-graph
-		// `_nodeToName` collision check. Register the raw under `toolCalls`
-		// directly in that case; otherwise register both (raw + post-intercept).
-		if (this.toolCalls === toolCallsRaw) {
-			this.add(this.toolCalls as Node<unknown>, { name: "toolCalls" });
-		} else {
-			this.add(toolCallsRaw as Node<unknown>, { name: "toolCallsRaw" });
-			this.add(this.toolCalls as Node<unknown>, { name: "toolCalls" });
-		}
-		this.add(toolResultsNode as Node<unknown>, { name: "toolResults" });
-		this.add(this._terminalResult as Node<unknown>, { name: "terminalResult" });
-
-		// Register subscriptions via `addDisposer` so they tear down on
-		// subgraph unmount (not just explicit `destroy()`). A caller that
-		// unmounts the AgentLoopGraph from its parent via `graph.remove(...)`
-		// would otherwise keep `turnSub` / `abortedSub` live against dead state.
-		this.addDisposer(turnSub);
-		this.addDisposer(abortedSub);
-		this.addDisposer(statusSub);
-		this.addDisposer(kaResponse);
-		this.addDisposer(kaResults);
-		if (kaFullDeny) this.addDisposer(kaFullDeny);
-		this.addDisposer(kaAbort);
-		this._disposeRunWiring = (): void => {
-			// addDisposer takes care of teardown; this shim stays for the
-			// `destroy()` override's idempotency contract (safe no-op if the
-			// disposers already fired).
-		};
-	}
-
-	/**
-	 * Bridge to `Promise<LLMResponse>` over the reactive pipeline.
-	 *
-	 * - If `userMessage` is provided, appends it as a user message and
-	 *   transitions status to `"thinking"` to kick the loop.
-	 * - If `signal` is provided, binds it to the reactive `aborted` node
-	 *   AND threads into `adapter.invoke({ signal })` so the wire call can
-	 *   cancel mid-flight. The reactive `aborted` state + effect 3 guarantee
-	 *   that even an adapter that ignores `signal` will stop emitting into
-	 *   the agent graph.
-	 * - Resolves when `status === "done"` with the final LLM response.
-	 *   Rejects with `AbortError` when the abort signal fires pre-response.
-	 *   Rejects with the stage error when `status === "error"`.
-	 *
-	 * **Concurrency:** `run()` refuses to overlap with a pending call on the
-	 * same agent. Attempting to call `run()` while a previous `run()` is
-	 * still in-flight throws a `RangeError` immediately. Stale-resolution
-	 * safety is provided by `awaitSettled({skipCurrent: true})`, which
-	 * ignores the cached initial DATA from any previous run and resolves
-	 * only on a fresh post-subscribe emission of `_terminalResult`.
-	 */
-	async run(userMessage?: string, signal?: AbortSignal): Promise<LLMResponse | null> {
-		if (this._running) {
-			throw new RangeError(
-				`agentLoop "${this.name}": run() called while a previous run() is still pending — await the previous run before starting another, or call abort() first`,
-			);
-		}
-		this._running = true;
-
-		let offAbort: (() => void) | undefined;
-		try {
-			// Reset per-run state. `lastResponse` MUST be cleared here —
-			// without it, `_terminalResult` would read the prior run's
-			// cached response during a second `run()` with a pre-aborted
-			// signal: `effAbort` drives `status → "done"`, `_terminalResult`
-			// evaluates `stat="done"` + `resp=<prior respA>` and emits DATA
-			// as a fresh post-subscribe signal → `awaitSettled` resolves
-			// with the stale response instead of rejecting with AbortError.
-			// The C3 `stat=done && resp===undefined → ERROR` guard in
-			// `_terminalResult` is only correct once the reset clears the
-			// cache.
-			//
-			// **SENTINEL reset via plain `[[INVALIDATE]]`** (DS-13.5.A,
-			// 2026-05-01). Pre-DS-13.5.A this required a paired
-			// `[[INVALIDATE], [RESOLVED]]` because INVALIDATE alone left
-			// dependents wedged in DIRTY. With INVALIDATE settling the wave
-			// (decrementing `_dirtyDepCount` like RESOLVED) and clearing
-			// `_cached` + each dependent's `prevData[lastResponse]` slot
-			// back to `undefined`, a single emission restores SENTINEL state
-			// AND lets dependents fire on the next status transition.
-			// `lastResponse` is a `Node<LLMResponse>` with no `initial` —
-			// it stays SENTINEL until the first real response; resetting
-			// via `emit(null)` would push a `null` DATA placeholder (the
-			// F9 trap), which is why INVALIDATE rather than emit is used.
-			batch(() => {
-				this.lastResponse.down([[INVALIDATE]]);
-				this.turn.emit(0);
-				this.aborted.emit(false);
-				this.status.emit("idle");
-			});
-			if (userMessage != null) this.chat.append("user", userMessage);
-
-			// Subscribe to `_terminalResult` BEFORE transitioning to
-			// "thinking" — otherwise a synchronous adapter (mock tests,
-			// offline stubs) would drain status → done → DATA on
-			// `_terminalResult` before `awaitSettled` had a chance to
-			// subscribe, and `skipCurrent: true` would swallow the only
-			// DATA this run will produce. `awaitSettled` / `firstWhere`
-			// subscribes synchronously during the `async` function's
-			// initial execution slice, so calling it before the kick
-			// guarantees the subscription is in place when the pipeline
-			// starts draining.
-			//
-			// `skipCurrent: true` still matters: on the second `run()`
-			// call `_terminalResult` holds cached DATA from the prior run,
-			// and push-on-subscribe would resolve immediately with that
-			// stale value without the skip.
-			const resultPromise = awaitSettled(this._terminalResult, { skipCurrent: true });
-
-			if (signal != null) {
-				if (signal.aborted) {
-					this.aborted.emit(true);
-				} else {
-					const listener = (): void => this.aborted.emit(true);
-					signal.addEventListener("abort", listener, { once: true });
-					offAbort = (): void => signal.removeEventListener("abort", listener);
-				}
-			}
-
-			// Kick — transition to "thinking" fires promptInput → llmResponse.
-			// Skip the kick when the signal was already aborted: `effAbort`
-			// has driven `status → "done"` above, and a trailing
-			// `thinking` emit would produce a non-monotonic `idle → done →
-			// thinking` sequence in the status-event log for no reactive
-			// benefit (promptInput gates on `!latestAborted` anyway).
-			if (signal?.aborted !== true) {
-				this.status.emit("thinking");
-			}
-
-			return await resultPromise;
-		} finally {
-			offAbort?.();
-			this._running = false;
-			this._currentAbortController = null;
-		}
-	}
-
-	/**
-	 * Flip the reactive `aborted` state. Equivalent to setting an external
-	 * `AbortSignal` — the pipeline observes and transitions to `"done"`.
-	 */
-	abort(): void {
-		this.aborted.emit(true);
-	}
-
-	override destroy(): void {
-		try {
-			this._disposeRunWiring();
-		} catch {
-			/* best-effort: disposing keepalives shouldn't block destroy */
-		}
-		super.destroy();
-	}
-}
-
-/**
- * Read the latest value for dep `i` inside a raw-`node()` fn body.
- *
- * Checks `batchData[i]` first (this-wave DATA from the dep), falls back to
- * `ctx.prevData[i]` (last DATA from prior waves), and finally to `fallback`
- * when the dep has never emitted (SENTINEL). Matches the unwrap semantics
- * `derived`'s sugar applies, so raw nodes can read deps uniformly.
- *
- * @internal
- */
-function readLatest<T>(
-	batchData: readonly (readonly unknown[] | undefined)[],
-	prevData: readonly unknown[],
-	index: number,
-	fallback: T,
-): T {
-	const batch = batchData[index];
-	if (batch != null && batch.length > 0) return batch[batch.length - 1] as T;
-	const prev = prevData[index];
-	return (prev !== undefined ? prev : fallback) as T;
-}
-
-/** @internal Shape of the LLM invocation input — constructed inside `promptInput`. */
-interface InvokeInput {
-	readonly messages: readonly ChatMessage[];
-	readonly tools: readonly ToolDefinition[];
-}
-
-export function agentLoop(name: string, opts: AgentLoopOptions): AgentLoopGraph {
-	const g = new AgentLoopGraph(name, opts);
-	// Tier 1.5.3 Phase 2.5 (DG1=B): tag the Graph with its constructing
-	// factory so `describe()` exposes provenance. Opts include non-JSON
-	// fields (`adapter`, `tools`, `stopWhen`, `onToolCall`,
-	// `interceptToolCalls`, etc.) so route through `placeholderArgs`
-	// (DG2=ii).
-	g.tagFactory("agentLoop", placeholderArgs(opts as unknown as Record<string, unknown>));
-	return g;
-}
diff --git a/src/presets/ai/agent-memory.ts b/src/presets/ai/agent-memory.ts
deleted file mode 100644
index 1bef61b9..00000000
--- a/src/presets/ai/agent-memory.ts
+++ /dev/null
@@ -1,398 +0,0 @@
-// ---------------------------------------------------------------------------
-// agentMemory — sugar over the memoryWith* composers (Unit 7 B).
-//
-// Thin wiring: distill() builds the core store (when no tiers configured);
-// optional capabilities delegate to the composer Graph subclasses in
-// `memory-composers.ts`. Each composer is a self-contained
-// `MemoryWithXxxGraph` that AgentMemoryGraph mounts on itself (Class B
-// audit, 2026-04-30) — teardown cascades via `Graph.destroy()`.
-//
-// **Phase 12.D (2026-04-30):** Migrated from the `Object.assign(graph, ...)`
-// factory pattern to `class extends Graph` (mirrors the
-// `MemoryWith*Graph` precedent). Required by Phase 13.G `agent(spec)` —
-// `AgentBundle.graph: AgentGraph<TIn, TOut>` consumers want `instanceof`
-// narrowing on agent-memory subgraphs.
-// ---------------------------------------------------------------------------
-
-import { DATA, type Node, node, placeholderArgs, RESOLVED } from "@graphrefly/pure-ts/core";
-import { fromAny, fromTimer, type NodeInput, switchMap } from "@graphrefly/pure-ts/extra";
-import { Graph, type GraphOptions } from "@graphrefly/pure-ts/graph";
-import {
-	type DistillBundle,
-	type DistillOptions,
-	distill,
-	type Extraction,
-} from "../../base/composition/distill.js";
-import type { LLMAdapter } from "../../utils/ai/adapters/core/types.js";
-import {
-	type MemoryWithTiersGraph,
-	memoryRetrieval,
-	memoryWithKG,
-	memoryWithTiers,
-	memoryWithVectors,
-} from "../../utils/ai/memory/memory-composers.js";
-import type { RetrievalEntry, RetrievalQuery } from "../../utils/ai/memory/retrieval.js";
-import type { MemoryTiersBundle, MemoryTiersOptions } from "../../utils/ai/memory/tiers.js";
-import { llmConsolidator, llmExtractor } from "../../utils/ai/prompts/prompt-call.js";
-import type { KnowledgeGraph, VectorIndexGraph } from "../../utils/memory/index.js";
-
-export type AgentMemoryOptions<TMem = unknown> = {
-	graph?: GraphOptions;
-	/** LLM adapter for extraction and consolidation. */
-	adapter?: LLMAdapter;
-	/** System prompt for the extractor LLM. */
-	extractPrompt?: string;
-	/** Custom extractFn (overrides adapter + extractPrompt). */
-	extractFn?: (raw: unknown, existing: ReadonlyMap<string, TMem>) => NodeInput<Extraction<TMem>>;
-	/** System prompt for the consolidation LLM. */
-	consolidatePrompt?: string;
-	/** Custom consolidateFn (overrides adapter + consolidatePrompt). */
-	consolidateFn?: (entries: ReadonlyMap<string, TMem>) => NodeInput<Extraction<TMem>>;
-	/** Reactive trigger for consolidation (caller supplies e.g. `fromTimer`). */
-	consolidateTrigger?: NodeInput<unknown>;
-	/** Score function for budget packing (required). */
-	score: (mem: TMem, context: unknown) => number;
-	/** Cost function for budget packing (required). */
-	cost: (mem: TMem) => number;
-	/** Token budget for compact view (default 2000). */
-	budget?: number;
-	/** Context node for scoring. */
-	context?: NodeInput<unknown>;
-	/** Admission filter (default: admit all). */
-	admissionFilter?: (candidate: unknown) => boolean;
-	/** Vector index dimensions (> 0 enables vector index for retrieval). */
-	vectorDimensions?: number;
-	/**
-	 * B12: optional accessor for an entry's hierarchical context breadcrumb
-	 * (e.g. `["projects", "auth", "tokens"]`). When supplied alongside
-	 * `contextWeight > 0`, retrieval applies a score boost for entries whose
-	 * context shares a prefix with the query's `context`. Entries without
-	 * a breadcrumb are scored flatly.
-	 */
-	contextOf?: (mem: TMem) => readonly string[] | undefined;
-	/**
-	 * B12: hierarchical context boost multiplier. Score is scaled by
-	 * `(1 + contextWeight * sharedDepth / queryDepth)` when both the query
-	 * and entry supply a `context`. Default: 0.
-	 */
-	contextWeight?: number;
-
-	// --- In-factory composition (new) ---
-
-	/** Extract embedding vector from a memory entry (enables vector index). */
-	embedFn?: (mem: TMem) => readonly number[] | undefined;
-	/** Enable knowledge graph for entity/relation tracking. */
-	enableKnowledgeGraph?: boolean;
-	/** Extract entities and relations from a memory entry. */
-	entityFn?: (
-		key: string,
-		mem: TMem,
-	) =>
-		| {
-				entities?: Array<{ id: string; value: unknown }>;
-				relations?: Array<{ from: string; to: string; relation: string; weight?: number }>;
-		  }
-		| undefined;
-
-	/** 3-tier storage configuration. Omit to use single-tier (existing behavior). */
-	tiers?: MemoryTiersOptions<TMem>;
-
-	/** Retrieval pipeline configuration. Requires vector index or knowledge graph. */
-	retrieval?: {
-		/** Max candidates from vector search (default 20). */
-		topK?: number;
-		/** KG expansion depth in hops (default 1). */
-		graphDepth?: number;
-	};
-
-	/** Periodic reflection/consolidation configuration. */
-	reflection?: {
-		/** Interval in ms between consolidation runs (default 300_000 = 5 min). */
-		interval?: number;
-		/** Enable/disable periodic reflection (default true when consolidateFn is available). */
-		enabled?: boolean;
-	};
-};
-
-/**
- * Pre-wired agentic memory graph. Sugar over `distill` plus the
- * `memoryWithVectors` / `memoryWithKG` / `memoryWithTiers` / `memoryRetrieval`
- * composers. Power users who want a subset of capabilities can call those
- * composers directly; this class bundles them into one ergonomic Graph subclass.
- *
- * Mounts:
- * - `tiers/*`     — present when `opts.tiers` configured (replaces the
- *                   default distill bundle).
- * - `vectors/*`   — present when `opts.vectorDimensions > 0 && opts.embedFn`.
- * - `knowledge/*` — present when `opts.enableKnowledgeGraph`.
- * - `retrieval/*` — present when vectors or kg configured.
- *
- * When `opts.tiers` is omitted, `store` / `compact` / `size` are added as
- * top-level nodes on this graph (visible in `describe()` / `explain()`).
- */
-export class AgentMemoryGraph<TMem = unknown> extends Graph {
-	readonly distillBundle: DistillBundle<TMem>;
-	readonly compact: Node<Array<{ key: string; value: TMem; score: number }>>;
-	readonly size: Node<number>;
-	/** Vector index bundle (null if not enabled). */
-	readonly vectors: VectorIndexGraph<TMem> | null;
-	/** Knowledge graph (null if not enabled). */
-	readonly kg: KnowledgeGraph<unknown, string> | null;
-	/** Memory tiers bundle (null if not configured). */
-	readonly memoryTiers: MemoryTiersBundle<TMem> | null;
-	/**
-	 * The mounted `MemoryWithTiersGraph` subgraph (null when `opts.tiers` was
-	 * omitted). Surfaces the inner graph for `describe()` / `explain()` walks
-	 * and for callers that need direct access to the tiers subgraph (e.g.
-	 * to register additional disposers or attach storage). Companion to
-	 * `memoryTiers`, which carries only the bundle's reactive surface (B5e).
-	 */
-	readonly tiers: MemoryWithTiersGraph<unknown, TMem> | null;
-	/**
-	 * Reactive consumer API. Given a reactive `RetrievalQuery | null` source,
-	 * returns a `Node` emitting the packed retrieval results. Composable with
-	 * graph topology — subscribe it, chain it into `promptNode`, or switchMap
-	 * over a user-input node.
-	 *
-	 * Each call mounts its own per-input subgraph at
-	 * `retrieval::retrieve_${id}` (via `MemoryRetrievalGraph`); concurrent
-	 * calls don't share state mirrors. One-shot consumers wrap with
-	 * `awaitSettled(retrieveReactive(query))`.
-	 *
-	 * Null when no retrieval pipeline is configured.
-	 *
-	 * **QA F-9 (2026-04-30):** the prior `retrieval` / `retrievalTrace`
-	 * shared state-node mirrors have been dropped. Use `retrieveReactive`
-	 * for per-call reactive results; one-shot trace consumers should
-	 * subscribe to the projection's upstream `result` derived directly
-	 * via `view.target.resolve("retrieval::retrieve_${id}::result")`.
-	 */
-	readonly retrieveReactive:
-		| ((queryInput: NodeInput<RetrievalQuery | null>) => Node<ReadonlyArray<RetrievalEntry<TMem>>>)
-		| null;
-
-	constructor(name: string, source: NodeInput<unknown>, opts: AgentMemoryOptions<TMem>) {
-		super(name, opts.graph);
-
-		// --- Extract function resolution ---
-		// /qa A3 (2026-04-30): validate BEFORE tagFactory so an invalid-opts
-		// throw doesn't leave a tagged-but-empty Graph instance behind.
-		let rawExtractFn: (
-			raw: unknown,
-			existing: ReadonlyMap<string, TMem>,
-		) => NodeInput<Extraction<TMem>>;
-		if (opts.extractFn) {
-			rawExtractFn = opts.extractFn;
-		} else if (opts.adapter && opts.extractPrompt) {
-			rawExtractFn = llmExtractor<unknown, TMem>(opts.extractPrompt, { adapter: opts.adapter });
-		} else {
-			throw new Error("agentMemory: provide either extractFn or adapter + extractPrompt");
-		}
-
-		// Tier 1.5.3 Phase 2.5 (DG1=B): tag the Graph with its constructing
-		// factory so `describe()` exposes provenance. Opts contain non-JSON
-		// fields (`adapter`, `extractFn`, `embedFn`, `score`, `cost`, `evict`,
-		// callbacks, etc.) so route through `placeholderArgs` (DG2=ii).
-		this.tagFactory("agentMemory", placeholderArgs(opts as unknown as Record<string, unknown>));
-		// Tier 1.5.4 — distill's `extractFn` is now reactive (called once with
-		// nodes). Adapt the AgentMemoryOptions callback shape via switchMap +
-		// closure-mirror for `existing` (COMPOSITION-GUIDE §40 recipe).
-		// QA F9: register the closure-mirror's unsub with the host graph so
-		// `graph.destroy()` reclaims it — was previously leaked.
-		//
-		// **Phase 16 attempt (2026-04-29) reverted.** Tried `withLatestFrom(
-		// rawNode, existingNode) + switchMap`; this is the WRONG migration per
-		// COMPOSITION-GUIDE §28. **Phase 10.5 (same-day partial-flag flip on
-		// `withLatestFrom`)** removes the initial-pair drop, but this site stays
-		// on closure-mirror form pending Phase 11 restricted signatures. See
-		// `archive/docs/SESSION-graph-narrow-waist.md` § "Status of existing
-		// modifications" + § "Phase 10.5".
-		const extractFn = (
-			rawNode: Node<unknown>,
-			existingNode: Node<ReadonlyMap<string, TMem>>,
-		): NodeInput<Extraction<TMem>> => {
-			let latestExisting: ReadonlyMap<string, TMem> =
-				(existingNode.cache as ReadonlyMap<string, TMem> | undefined) ?? new Map();
-			const unsubExisting = existingNode.subscribe((msgs) => {
-				for (const m of msgs) {
-					if (m[0] === DATA) latestExisting = m[1] as ReadonlyMap<string, TMem>;
-				}
-			});
-			this.addDisposer(unsubExisting);
-			return switchMap(rawNode, (raw) => {
-				if (raw == null) return { upsert: [] };
-				return rawExtractFn(raw, latestExisting);
-			});
-		};
-
-		// --- Admission filter ---
-		let filteredSource = source;
-		if (opts.admissionFilter) {
-			const srcNode = fromAny(source);
-			const filter = opts.admissionFilter;
-			filteredSource = node(
-				[srcNode],
-				(batchData, actions, ctx) => {
-					const data = batchData.map((batch, i) =>
-						batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-					);
-					const raw = data[0];
-					if (filter(raw)) {
-						actions.emit(raw);
-					} else {
-						// EC1 (qa 2026-04-30): emitting `undefined` would violate spec §5.12
-						// (undefined is the protocol SENTINEL — TopicGraph.publish even
-						// throws on it). Downstream `batch.at(-1) : ctx.prevData[i]`
-						// would also resolve `undefined` back to the prior accepted
-						// value, leaking past-the-filter. Emit a tier-3 RESOLVED so the
-						// wave settles cleanly without surfacing a stale DATA.
-						actions.down([[RESOLVED]]);
-					}
-				},
-				{ name: "admissionFilter", describeKind: "derived" },
-			);
-		}
-
-		// --- Consolidation ---
-		let consolidateFn:
-			| ((entries: ReadonlyMap<string, TMem>) => NodeInput<Extraction<TMem>>)
-			| undefined;
-		if (opts.consolidateFn) {
-			consolidateFn = opts.consolidateFn;
-		} else if (opts.adapter && opts.consolidatePrompt) {
-			consolidateFn = llmConsolidator<TMem>(opts.consolidatePrompt, { adapter: opts.adapter });
-		}
-
-		// --- Reflection: default consolidateTrigger from fromTimer ---
-		let consolidateTrigger = opts.consolidateTrigger;
-		if (!consolidateTrigger && consolidateFn && opts.reflection?.enabled !== false) {
-			const interval = opts.reflection?.interval ?? 300_000;
-			consolidateTrigger = fromTimer(interval, { period: interval });
-		}
-
-		// --- Build distill bundle (the core) ---
-		// Tier 4.1 B (2026-04-29): when tiers are configured, `memoryWithTiers`
-		// is the construction site for the distill bundle so it can wire
-		// `reactiveMap.retention` into the store at construction (no §7 cycle).
-		// When tiers are NOT configured, agentMemory calls `distill` directly.
-		const distillOpts: DistillOptions<TMem> = {
-			score: opts.score,
-			cost: opts.cost,
-			budget: opts.budget ?? 2000,
-			context: opts.context,
-			consolidate: consolidateFn,
-			consolidateTrigger,
-		};
-
-		let distillBundle: DistillBundle<TMem>;
-		let memoryTiersBundle: MemoryTiersBundle<TMem> | null = null;
-		let tiersSubgraph: MemoryWithTiersGraph<unknown, TMem> | null = null;
-		if (opts.tiers) {
-			const tiersGraph = memoryWithTiers<unknown, TMem>({
-				// User customization first; canonical agent-memory-level overrides
-				// last so they always win even if `MemoryTiersOptions` later adds
-				// any of the same keys.
-				...opts.tiers,
-				name: "tiers",
-				source: filteredSource,
-				extractFn,
-				score: opts.score,
-				cost: opts.cost,
-				...(opts.budget !== undefined ? { budget: opts.budget } : { budget: 2000 }),
-				...(opts.context !== undefined ? { context: opts.context } : {}),
-				...(consolidateFn !== undefined ? { consolidate: consolidateFn } : {}),
-				...(consolidateTrigger !== undefined ? { consolidateTrigger } : {}),
-			});
-			this.mount("tiers", tiersGraph);
-			distillBundle = tiersGraph.store;
-			memoryTiersBundle = tiersGraph.tiers;
-			tiersSubgraph = tiersGraph;
-		} else {
-			distillBundle = distill<unknown, TMem>(filteredSource, extractFn, distillOpts);
-			this.add(distillBundle.store.entries, { name: "store" });
-			this.add(distillBundle.compact, { name: "compact" });
-			this.add(distillBundle.size, { name: "size" });
-		}
-
-		// --- Vector index (composer) ---
-		let vectors: VectorIndexGraph<TMem> | null = null;
-		if (opts.vectorDimensions && opts.vectorDimensions > 0 && opts.embedFn) {
-			const vectorsGraph = memoryWithVectors<TMem>({
-				name: "vectors",
-				store: distillBundle,
-				dimension: opts.vectorDimensions,
-				embedFn: opts.embedFn,
-			});
-			this.mount("vectors", vectorsGraph);
-			vectors = vectorsGraph.vectors;
-		}
-
-		// --- Knowledge graph (composer) ---
-		let kg: KnowledgeGraph<unknown, string> | null = null;
-		if (opts.enableKnowledgeGraph) {
-			const kgGraph = memoryWithKG<TMem>({
-				name: "knowledge",
-				store: distillBundle,
-				kgName: `${name}-kg`,
-				mountPath: "knowledge-kg",
-				...(opts.entityFn !== undefined ? { entityFn: opts.entityFn } : {}),
-			});
-			this.mount("knowledge", kgGraph);
-			kg = kgGraph.kg;
-		}
-
-		// --- Retrieval pipeline (composer) ---
-		let retrieveReactive:
-			| ((
-					queryInput: NodeInput<RetrievalQuery | null>,
-			  ) => Node<ReadonlyArray<RetrievalEntry<TMem>>>)
-			| null = null;
-
-		if (vectors || kg) {
-			const retrievalGraph = memoryRetrieval<TMem>({
-				name: "retrieval",
-				store: distillBundle,
-				vectors,
-				kg,
-				score: opts.score,
-				cost: opts.cost,
-				...(opts.budget !== undefined ? { budget: opts.budget } : {}),
-				...(opts.retrieval?.topK !== undefined ? { topK: opts.retrieval.topK } : {}),
-				...(opts.retrieval?.graphDepth !== undefined
-					? { graphDepth: opts.retrieval.graphDepth }
-					: {}),
-				...(opts.contextOf !== undefined ? { contextOf: opts.contextOf } : {}),
-				...(opts.contextWeight !== undefined ? { contextWeight: opts.contextWeight } : {}),
-				...(opts.context !== undefined ? { context: opts.context } : {}),
-			});
-			this.mount("retrieval", retrievalGraph);
-			retrieveReactive = retrievalGraph.retrieveReactive.bind(retrievalGraph);
-		}
-
-		this.distillBundle = distillBundle;
-		this.compact = distillBundle.compact;
-		this.size = distillBundle.size;
-		this.vectors = vectors;
-		this.kg = kg;
-		this.memoryTiers = memoryTiersBundle;
-		this.tiers = tiersSubgraph;
-		this.retrieveReactive = retrieveReactive;
-	}
-}
-
-/**
- * Pre-wired agentic memory graph. Sugar over `distill` plus the
- * `memoryWithVectors` / `memoryWithKG` / `memoryWithTiers` / `memoryRetrieval`
- * composers. Power users who want a subset of capabilities can call those
- * composers directly; this factory bundles them into one ergonomic call.
- *
- * Returns an {@link AgentMemoryGraph} subclass instance — `instanceof
- * AgentMemoryGraph` narrows in callers (e.g. Phase 13.G `agent(spec)`).
- */
-export function agentMemory<TMem = unknown>(
-	name: string,
-	source: NodeInput<unknown>,
-	opts: AgentMemoryOptions<TMem>,
-): AgentMemoryGraph<TMem> {
-	return new AgentMemoryGraph<TMem>(name, source, opts);
-}
diff --git a/src/presets/ai/agent.ts b/src/presets/ai/agent.ts
deleted file mode 100644
index a04a059f..00000000
--- a/src/presets/ai/agent.ts
+++ /dev/null
@@ -1,638 +0,0 @@
-/**
- * Phase 13.G — `AgentBundle<TIn, TOut>` interface + `class AgentGraph extends Graph`.
- *
- * Source: `archive/docs/SESSION-multi-agent-gap-analysis.md` G1 lock B.
- *
- * Composes the existing substrate (`agentLoop`, `toolRegistry`,
- * `agentMemory`) into a typed inbox/outbox subgraph that other parts of a
- * multi-agent system can wire to. Sibling preset `agent()` (in
- * `./agents.ts`) is the ergonomic factory; this file is the contract.
- *
- * **Cross-cut #1 lock (no `agent.run()`):** caller-side runtime entry is
- * `bundle.in.emit(input)` + `awaitSettled(bundle.out)`. The legacy
- * `agentLoop.run()` is still available on `bundle.graph.loop` for
- * single-shot Promise-bridge use cases, but `agent()` does NOT expose a
- * `run()` method on the bundle.
- *
- * **Memory partition default:** private memory per agent (each `agent(...)`
- * call creates its own `AgentMemoryGraph` if none passed). Pass an explicit
- * shared instance for §29 handoff context-transfer.
- */
-
-import { batch, DATA, INVALIDATE, type Node, node, RESOLVED } from "@graphrefly/pure-ts/core";
-import { keepalive } from "@graphrefly/pure-ts/extra";
-import { Graph, type GraphOptions } from "@graphrefly/pure-ts/graph";
-import { aiMeta } from "../../utils/ai/_internal.js";
-import type {
-	InputTokens,
-	LLMAdapter,
-	LLMResponse,
-	OutputTokens,
-	TokenUsage,
-	ToolDefinition,
-} from "../../utils/ai/adapters/core/types.js";
-import {
-	type SubscriptionGraph,
-	subscription,
-	type TopicGraph,
-	topic,
-} from "../../utils/messaging/index.js";
-import { type AgentLoopGraph, agentLoop } from "./agent-loop.js";
-import type { AgentMemoryGraph } from "./agent-memory.js";
-
-// ---------------------------------------------------------------------------
-// Types
-// ---------------------------------------------------------------------------
-
-/**
- * Lifecycle status of an {@link AgentGraph}.
- *
- * - `idle` — no input has been received since construction or last reset.
- * - `running` — inputs are flowing through the underlying agentLoop
- *   (collapses the loop's `thinking` + `acting` substates so consumers
- *   don't have to model the tool-call inner loop).
- * - `verifying` — verifier subgraph is in flight (reserved; lights up when
- *   the verifier slot is added in a future wave per G7 recipe).
- * - `done` — the most recent input has settled with a verified response.
- * - `error` — the loop or verifier produced a terminal error.
- *
- * **Note (Phase 13.G, 2026-05-01):** v1 of `agent()` has no built-in
- * verifier slot — `verifying` is reserved but never produced. When a
- * verifier consumer surfaces, this enum widens (non-breaking type
- * widening; existing consumers see the same `idle | running | done | error`
- * subset).
- */
-export type AgentStatus = "idle" | "running" | "verifying" | "done" | "error";
-
-/**
- * Aggregated cost for an agent's run, surfaced as a `Node<CostState>` on
- * the bundle. **Wraps the canonical {@link TokenUsage}** so consumers get
- * the full provider-disaggregated token classes (cache-read /
- * cache-write-5m / cache-write-1h / audio / image / video / tool-use /
- * reasoning / prediction-accepted / prediction-rejected / extensions /
- * auxiliary non-token costs / raw escape-hatch) without losing fidelity
- * for downstream pricing. USD conversion is a downstream `derived` over
- * `usage`.
- *
- * - `usage` — accumulated {@link TokenUsage} across all turns of the
- *   current input.
- * - `turns` — number of completed agentLoop iterations (LLM invocations).
- *
- * **Counter scope:** resets to {@link ZERO_COST} on each new `bundle.in`
- * emit (per-input cost rather than per-agent-lifetime). Sum across multiple
- * inputs by snapshotting `cost` at `done` and accumulating externally —
- * a per-lifetime cost is a downstream `scan` over this.
- *
- * **Helpers.** Use `sumInputTokens(usage)` / `sumOutputTokens(usage)` from
- * `@graphrefly/graphrefly` to flatten to scalars when the caller wants
- * a single number.
- */
-export interface CostState {
-	readonly usage: TokenUsage;
-	readonly turns: number;
-}
-
-const EMPTY_INPUT: InputTokens = Object.freeze({ regular: 0 });
-const EMPTY_OUTPUT: OutputTokens = Object.freeze({ regular: 0 });
-const EMPTY_USAGE: TokenUsage = Object.freeze({ input: EMPTY_INPUT, output: EMPTY_OUTPUT });
-
-/** Empty cost. Used as the initial value and the per-input reset baseline. */
-export const ZERO_COST: CostState = Object.freeze({ usage: EMPTY_USAGE, turns: 0 });
-
-// ---------------------------------------------------------------------------
-// TokenUsage accumulator
-// ---------------------------------------------------------------------------
-
-function addOptional(a: number | undefined, b: number | undefined): number | undefined {
-	if (a == null && b == null) return undefined;
-	return (a ?? 0) + (b ?? 0);
-}
-
-function addExtensions(
-	a: Record<string, number> | undefined,
-	b: Record<string, number> | undefined,
-): Record<string, number> | undefined {
-	if (a == null && b == null) return undefined;
-	const out: Record<string, number> = { ...(a ?? {}) };
-	for (const [k, v] of Object.entries(b ?? {})) {
-		out[k] = (out[k] ?? 0) + v;
-	}
-	return out;
-}
-
-/**
- * Accumulates two {@link TokenUsage} snapshots. All field classes are
- * summed; optional fields propagate as `undefined` when absent from both
- * sides, otherwise treated as 0 for the missing side. `auxiliary` and
- * `extensions` merge by key. `raw` is dropped — it's a per-call escape
- * hatch, not summable.
- *
- * @category extra
- */
-export function addUsage(a: TokenUsage, b: TokenUsage): TokenUsage {
-	const out: TokenUsage = {
-		input: {
-			regular: a.input.regular + b.input.regular,
-			...(addOptional(a.input.cacheRead, b.input.cacheRead) !== undefined && {
-				cacheRead: addOptional(a.input.cacheRead, b.input.cacheRead) as number,
-			}),
-			...(addOptional(a.input.cacheWrite5m, b.input.cacheWrite5m) !== undefined && {
-				cacheWrite5m: addOptional(a.input.cacheWrite5m, b.input.cacheWrite5m) as number,
-			}),
-			...(addOptional(a.input.cacheWrite1h, b.input.cacheWrite1h) !== undefined && {
-				cacheWrite1h: addOptional(a.input.cacheWrite1h, b.input.cacheWrite1h) as number,
-			}),
-			...(addOptional(a.input.cacheWriteOther, b.input.cacheWriteOther) !== undefined && {
-				cacheWriteOther: addOptional(a.input.cacheWriteOther, b.input.cacheWriteOther) as number,
-			}),
-			...(addOptional(a.input.audio, b.input.audio) !== undefined && {
-				audio: addOptional(a.input.audio, b.input.audio) as number,
-			}),
-			...(addOptional(a.input.image, b.input.image) !== undefined && {
-				image: addOptional(a.input.image, b.input.image) as number,
-			}),
-			...(addOptional(a.input.video, b.input.video) !== undefined && {
-				video: addOptional(a.input.video, b.input.video) as number,
-			}),
-			...(addOptional(a.input.toolUse, b.input.toolUse) !== undefined && {
-				toolUse: addOptional(a.input.toolUse, b.input.toolUse) as number,
-			}),
-			...(addExtensions(a.input.extensions, b.input.extensions) !== undefined && {
-				extensions: addExtensions(a.input.extensions, b.input.extensions) as Record<string, number>,
-			}),
-		},
-		output: {
-			regular: a.output.regular + b.output.regular,
-			...(addOptional(a.output.reasoning, b.output.reasoning) !== undefined && {
-				reasoning: addOptional(a.output.reasoning, b.output.reasoning) as number,
-			}),
-			...(addOptional(a.output.audio, b.output.audio) !== undefined && {
-				audio: addOptional(a.output.audio, b.output.audio) as number,
-			}),
-			...(addOptional(a.output.predictionAccepted, b.output.predictionAccepted) !== undefined && {
-				predictionAccepted: addOptional(
-					a.output.predictionAccepted,
-					b.output.predictionAccepted,
-				) as number,
-			}),
-			...(addOptional(a.output.predictionRejected, b.output.predictionRejected) !== undefined && {
-				predictionRejected: addOptional(
-					a.output.predictionRejected,
-					b.output.predictionRejected,
-				) as number,
-			}),
-			...(addExtensions(a.output.extensions, b.output.extensions) !== undefined && {
-				extensions: addExtensions(a.output.extensions, b.output.extensions) as Record<
-					string,
-					number
-				>,
-			}),
-		},
-		...(addExtensions(a.auxiliary, b.auxiliary) !== undefined && {
-			auxiliary: addExtensions(a.auxiliary, b.auxiliary) as Record<string, number>,
-		}),
-	};
-	return out;
-}
-
-/**
- * Spec for {@link agent} (in `./agents.ts`). Required fields are minimal —
- * `name` and `adapter` cover the common case where the input is a string
- * and the output is the raw `LLMResponse`. Optional fields shape the
- * agent's behavior:
- *
- * - **Mappers** (`inMapper` / `outMapper`) translate between caller-typed
- *   `TIn` / `TOut` and the loop's internal `string` / `LLMResponse`. Default
- *   identity mappers are wired automatically when `TIn` extends `string`
- *   and `TOut` extends `LLMResponse`.
- * - **`tools`** is a reactive `NodeInput<readonly ToolDefinition[]>` —
- *   `agent()` subscribes and reconciles the underlying `toolRegistry`'s
- *   registrations on each emit. Static-array form is also accepted.
- * - **`memory`** is an explicit `AgentMemoryGraph` instance for shared
- *   memory across agents (§29 handoff context transfer). Default: private
- *   memory per agent (each `agent()` call mints its own).
- * - **`maxIterations`** caps the underlying agentLoop's tool-call inner
- *   loop. Default 10 (matches `agentLoop`).
- * - **Verifier slot** is intentionally not in v1 — G7 reframe locks it as
- *   a caller-composed recipe. When a real consumer surfaces, a
- *   `verifier?: (out: Node<TOut>) => NodeInput<VerifierResult>` field
- *   lands here additively.
- */
-export interface AgentSpec<TIn, TOut> {
-	/** Local mount name when wired to a parent graph. Required. */
-	readonly name: string;
-	/** LLM adapter for the underlying agentLoop. Required. */
-	readonly adapter: LLMAdapter;
-	/** Optional system prompt. Static today; reactive widening pending. */
-	readonly systemPrompt?: string;
-	/**
-	 * Optional reactive tool list. When a Node, the agent subscribes and
-	 * reconciles the underlying `toolRegistry` registrations on each emit
-	 * (additions registered, removals unregistered). When a static array,
-	 * tools are registered once at construction.
-	 */
-	readonly tools?: Node<readonly ToolDefinition[]> | readonly ToolDefinition[];
-	/**
-	 * Optional shared memory. Default: private (agent mints its own
-	 * `AgentMemoryGraph` if needed; not yet wired into the loop's chat —
-	 * that wiring is a separate follow-up). Pass an explicit instance to
-	 * share memory across agents for §29 handoff context transfer.
-	 */
-	readonly memory?: AgentMemoryGraph<unknown>;
-	/**
-	 * Maps caller-typed input → string for the underlying chat. Defaults to
-	 * identity when `TIn extends string`; required otherwise.
-	 */
-	readonly inMapper?: (input: TIn) => string;
-	/**
-	 * Maps the agentLoop's `LLMResponse` → caller-typed output. Defaults to
-	 * identity when `TOut extends LLMResponse`; required otherwise.
-	 */
-	readonly outMapper?: (response: LLMResponse) => TOut;
-	/** Caps tool-call inner-loop iterations. Default 10. */
-	readonly maxIterations?: number;
-	/** Escape hatch for non-core fields. Surfaced in `describe()` via meta. */
-	readonly meta?: Record<string, unknown>;
-}
-
-/**
- * Public contract for an agent — typed inbox/outbox + lifecycle / cost
- * observables + the underlying graph for inspection / mounting.
- *
- * **Reactive entry:** caller writes to `in` (e.g. `bundle.in.emit(input)`).
- * The agent reactively kicks the underlying loop and produces `out`.
- *
- * **Reactive exit:** caller reads `out` via `subscribe` (continuous) or
- * `awaitSettled(out)` (single-shot). Both `in` and `out` stay SENTINEL
- * (`cache === undefined`) until the first real emission — no `null`
- * push-on-subscribe trap (per `feedback_use_prevdata_for_sentinel`).
- *
- * **Cross-graph wiring:** the bundle's `graph` is mountable under any
- * parent via `parent.mount(name, bundle.graph)`. After mount, the bundle's
- * Nodes are reachable through both the bundle reference (direct) and via
- * `parent.node("<name>::out")` etc. (qualified path).
- */
-export interface AgentBundle<TIn, TOut> {
-	readonly in: Node<TIn>;
-	readonly out: Node<TOut>;
-	readonly status: Node<AgentStatus>;
-	readonly cost: Node<CostState>;
-	readonly graph: AgentGraph<TIn, TOut>;
-}
-
-// ---------------------------------------------------------------------------
-// AgentGraph
-// ---------------------------------------------------------------------------
-
-const TERMINAL_STATUSES = new Set<AgentStatus>(["done", "error"]);
-
-/**
- * Graph subclass implementing {@link AgentBundle}. Mounts an inner
- * {@link AgentLoopGraph} at `loop/`; `in` / `out` / `status` / `cost`
- * surface the bundle contract as top-level nodes.
- *
- * Construction is internal — use the {@link agent} factory in
- * `./agents.ts` for normal use. Direct `new AgentGraph(name, spec)` is
- * supported for callers that want full control over mount order.
- *
- * **Topology:**
- * ```
- * <name>
- * ├── loop                  (AgentLoopGraph subgraph)
- * │   ├── chat
- * │   ├── tools
- * │   ├── status / turn / aborted / lastResponse / ...
- * ├── in                    (Node<TIn>, SENTINEL until first emit)
- * ├── out                   (Node<TOut>, SENTINEL until first response)
- * ├── status                (Node<AgentStatus>, mirror of loop.status)
- * └── cost                  (Node<CostState>)
- * ```
- *
- * **Lifecycle:**
- * - On `in` emit: `inMapper` projects to `string`; appended to
- *   `loop.chat`; loop status reset (`turn=0`, `aborted=false`,
- *   `status="thinking"`); per-input cost counters reset to zero.
- * - On `loop.lastResponse` emit: cost rolls forward; `out` emits
- *   `outMapper(response)`.
- * - On `loop.status="done"`: agent's status emits `"done"`.
- * - On `loop.status="error"` (or any ERROR propagation): agent's status
- *   emits `"error"`.
- */
-export class AgentGraph<TIn, TOut> extends Graph {
-	/** The agent's typed inbox. Writable; `in.emit(value)` kicks the loop. */
-	readonly in: Node<TIn>;
-	/** The agent's typed outbox. SENTINEL until first response. */
-	readonly out: Node<TOut>;
-	/** Lifecycle status (translated from the underlying loop's substates). */
-	readonly status: Node<AgentStatus>;
-	/** Cumulative cost for the current / most-recent input. */
-	readonly cost: Node<CostState>;
-	/** The underlying agentLoop — exposed for inspection / advanced wiring. */
-	readonly loop: AgentLoopGraph;
-	/** Optional shared memory subgraph (mounted at `memory/` if provided). */
-	readonly memory: AgentMemoryGraph<unknown> | null;
-
-	constructor(spec: AgentSpec<TIn, TOut>, opts?: GraphOptions) {
-		super(spec.name, opts);
-
-		// --- 1. Mount the agentLoop subgraph. ------------------------------
-		const initialTools = Array.isArray(spec.tools)
-			? (spec.tools as readonly ToolDefinition[])
-			: undefined;
-		this.loop = agentLoop(`${spec.name}-loop`, {
-			adapter: spec.adapter,
-			...(spec.systemPrompt != null ? { systemPrompt: spec.systemPrompt } : {}),
-			...(initialTools != null ? { tools: initialTools } : {}),
-			...(spec.maxIterations != null ? { maxTurns: spec.maxIterations } : {}),
-		});
-		this.mount("loop", this.loop);
-
-		// --- 2. Reactive tools subscription (if Node-form). ----------------
-		// agentLoop's tools are static-array at construction; we reconcile
-		// dynamically by subscribing to the user's reactive Node and
-		// register/unregister against the inner toolRegistry.
-		if (spec.tools != null && !Array.isArray(spec.tools)) {
-			const toolsNode = spec.tools as Node<readonly ToolDefinition[]>;
-			const registered = new Set<string>();
-			const unsubTools = toolsNode.subscribe((msgs) => {
-				for (const m of msgs) {
-					if (m[0] !== DATA) continue;
-					const next = m[1] as readonly ToolDefinition[];
-					const nextNames = new Set(next.map((t) => t.name));
-					// Unregister missing.
-					for (const name of registered) {
-						if (!nextNames.has(name)) {
-							this.loop.tools.unregister(name);
-							registered.delete(name);
-						}
-					}
-					// Register new (idempotent guard via local tracking).
-					for (const tool of next) {
-						if (!registered.has(tool.name)) {
-							this.loop.tools.register(tool);
-							registered.add(tool.name);
-						}
-					}
-				}
-			});
-			this.addDisposer(unsubTools);
-		}
-
-		// --- 3. Optional shared memory subgraph (passed through). ----------
-		// v1: memory is mounted but NOT yet wired into the loop's chat — the
-		// chat-context-from-memory glue is a separate follow-up. Mounting it
-		// here gives the bundle a stable surface for §29 handoff (callers
-		// can pass the SAME instance to multiple agents for shared memory).
-		this.memory = spec.memory ?? null;
-		if (this.memory != null) {
-			this.mount("memory", this.memory);
-		}
-
-		// --- 4. `in` — the typed inbox. ------------------------------------
-		// SENTINEL until first emit; `equals: () => false` so re-emitting the
-		// same value still kicks (no spurious dedup of repeat inputs).
-		this.in = node<TIn>([], {
-			name: "in",
-			describeKind: "state",
-			meta: aiMeta("agent_in"),
-			equals: () => false,
-		});
-		this.add(this.in, { name: "in" });
-
-		// --- 5. `cost` — per-input token counters. -------------------------
-		const costNode = node<CostState>([], {
-			name: "cost",
-			describeKind: "state",
-			meta: aiMeta("agent_cost"),
-			initial: ZERO_COST,
-		});
-		this.add(costNode, { name: "cost" });
-		this.cost = costNode;
-
-		// --- 6. `out` — the typed outbox. ----------------------------------
-		// Derived from `loop.lastResponse`. SENTINEL while `loop.lastResponse`
-		// has never emitted a real response (F9 fix: the loop now stays
-		// SENTINEL too — no more eager `null` placeholder), so the SENTINEL
-		// detector inside the fn is `prevData[0] === undefined`. Between
-		// runs, `loop.lastResponse.down([[INVALIDATE]])` clears that
-		// `prevData` slot back to undefined, so this derived correctly gates
-		// to RESOLVED on the next status="idle" wave.
-		const outMapper = spec.outMapper ?? defaultOutMapper<TOut>();
-		const outNode = node<TOut>(
-			[this.loop.lastResponse],
-			(data, a, ctx) => {
-				const batch0 = data[0];
-				const resp =
-					batch0 != null && batch0.length > 0
-						? (batch0.at(-1) as LLMResponse | undefined)
-						: (ctx.prevData[0] as LLMResponse | undefined);
-				if (resp === undefined) {
-					a.down([[RESOLVED]]);
-					return;
-				}
-				a.emit(outMapper(resp));
-			},
-			{
-				name: "out",
-				describeKind: "derived",
-				meta: aiMeta("agent_out"),
-				// Each in.emit may produce a structurally-equal response (e.g.
-				// from a deterministic adapter) — disable framework dedup so
-				// repeat emits propagate and `awaitSettled({skipCurrent:true})`
-				// sees them. Callers can wrap with `distinctUntilChanged` if
-				// they want change-only semantics.
-				equals: () => false,
-			},
-		);
-		this.add(outNode, { name: "out" });
-		this.out = outNode;
-
-		// --- 7. `status` — translated from loop.status. --------------------
-		// Mirror via §32 pattern: a state node downstream consumers depend on,
-		// reset and updated by an effect listening to loop.status.
-		const statusNode = node<AgentStatus>([], {
-			name: "status",
-			describeKind: "state",
-			meta: aiMeta("agent_status"),
-			initial: "idle",
-		});
-		this.add(statusNode, { name: "status" });
-		this.status = statusNode;
-
-		const statusMirrorEff = node(
-			[this.loop.status],
-			(data, _a, ctx) => {
-				const batch0 = data[0];
-				const loopStatus =
-					batch0 != null && batch0.length > 0
-						? (batch0.at(-1) as string)
-						: ((ctx.prevData[0] as string | undefined) ?? "idle");
-				const next: AgentStatus =
-					loopStatus === "idle"
-						? "idle"
-						: loopStatus === "thinking" || loopStatus === "acting"
-							? "running"
-							: loopStatus === "done"
-								? "done"
-								: loopStatus === "error"
-									? "error"
-									: "idle";
-				if (statusNode.cache !== next) statusNode.emit(next);
-			},
-			{ describeKind: "effect", meta: aiMeta("agent_status_mirror") },
-		);
-		this.addDisposer(keepalive(statusMirrorEff));
-
-		// --- 8. Cost-rollup effect. ---------------------------------------
-		// Rolls forward on each loop.lastResponse emission. Reads
-		// loop.turn.cache for the iteration count (sole-owner-reactive-reader
-		// per Phase 12 D1 lock — loop is mounted as a subgraph of this Graph).
-		// SENTINEL gate: `prevData[0] === undefined` means no response has
-		// ever been delivered for this run (post-INVALIDATE reset between
-		// runs), so the rollup short-circuits.
-		const costEff = node(
-			[this.loop.lastResponse],
-			(data, _a, ctx) => {
-				const batch0 = data[0];
-				const resp =
-					batch0 != null && batch0.length > 0
-						? (batch0.at(-1) as LLMResponse | undefined)
-						: (ctx.prevData[0] as LLMResponse | undefined);
-				if (resp === undefined) return;
-				const prev = (costNode.cache as CostState | undefined) ?? ZERO_COST;
-				const turns = (this.loop.turn.cache as number | undefined) ?? prev.turns;
-				const next: CostState = {
-					usage: resp.usage != null ? addUsage(prev.usage, resp.usage) : prev.usage,
-					turns,
-				};
-				costNode.emit(next);
-			},
-			{ describeKind: "effect", meta: aiMeta("agent_cost_rollup") },
-		);
-		this.addDisposer(keepalive(costEff));
-
-		// --- 9. `in` → input queue → drain → kick the loop. ----------------
-		// Phase 13.G/H + /qa N1(b) lock (2026-05-01): bundle.in is a
-		// writable surface, but kicks are queued through an internal
-		// hub-style topic + cursor subscription. Out-of-the-box queueing —
-		// caller fires `in.emit(x)` while the agent is mid-run; the input
-		// is parked on the queue and picked up when the loop returns to
-		// `idle` / `done` / `error`. No mid-run reset / cost-leak hazard
-		// (which the prior raw `in.subscribe → kick` path had).
-		//
-		// Topology:
-		//   `in` (state Node, writable) → `inputBridge` (subscribe →
-		//   publish) → `inputTopic` (TopicGraph<TIn>) → `inputSub`
-		//   (SubscriptionGraph<TIn>) → `drainEffect` (effect on
-		//   [inputSub.available, loop.status]) → loop kick.
-		const inMapper = spec.inMapper ?? defaultInMapper<TIn>();
-		const inputTopic: TopicGraph<TIn> = topic<TIn>("input-topic");
-		this.mount("input-topic", inputTopic);
-		const inputSub: SubscriptionGraph<TIn> = subscription<TIn>("input-sub", inputTopic, {
-			from: "now",
-		});
-		this.mount("input-sub", inputSub);
-
-		// Bridge: `in.emit(x)` publishes to the topic. Validates the
-		// caller-supplied input via `inMapper` at the boundary so the
-		// type error surfaces in the caller's stack frame (not later
-		// during drain). Per the F9 SENTINEL trap, `in` cache is
-		// `undefined` until the first emit; push-on-subscribe delivers
-		// nothing.
-		const inputBridge = this.in.subscribe((msgs) => {
-			for (const m of msgs) {
-				if (m[0] !== DATA) continue;
-				const input = m[1] as TIn;
-				// Boundary type-check: throws if TIn is not string and no
-				// inMapper supplied. Better here than at drain time so the
-				// caller's `in.emit(...)` raises synchronously.
-				inMapper(input);
-				inputTopic.publish(input);
-			}
-		});
-		this.addDisposer(inputBridge);
-
-		// Drain effect: when an input is pending AND the loop is ready
-		// (`idle` / `done` / `error`), pull one and kick. Re-entrancy
-		// guard via `loop.status` — `thinking` / `acting` skip.
-		const drainEffect = node(
-			[inputSub.available, this.loop.status],
-			(data, _a, ctx) => {
-				const availBatch = data[0];
-				const statusBatch = data[1];
-				const avail =
-					(availBatch != null && availBatch.length > 0
-						? (availBatch.at(-1) as readonly TIn[])
-						: ((ctx.prevData[0] as readonly TIn[] | undefined) ?? [])) ?? [];
-				const stat =
-					(statusBatch != null && statusBatch.length > 0
-						? (statusBatch.at(-1) as string)
-						: ((ctx.prevData[1] as string | undefined) ?? "idle")) ?? "idle";
-				if (avail.length === 0) return;
-				if (stat === "thinking" || stat === "acting") return;
-				const result = inputSub.pullAndAck(1);
-				if (result.items.length === 0) return;
-				const input = result.items[0] as TIn;
-				const userMsg = inMapper(input);
-				batch(() => {
-					// Reset per-input accumulators so cost/turns don't include
-					// the previous input. `lastResponse` is reset via plain
-					// `[[INVALIDATE]]` — under DS-13.5.A INVALIDATE both clears
-					// `_cached` AND settles the consuming wave (decrements
-					// `_dirtyDepCount` like RESOLVED), so dependents like
-					// `out` / `costEff` fire on the next status transition
-					// without staying wedged in DIRTY. Pre-DS-13.5.A this used
-					// the `[[INVALIDATE], [RESOLVED]]` paired-reset workaround.
-					this.loop.lastResponse.down([[INVALIDATE]]);
-					this.loop.turn.emit(0);
-					this.loop.aborted.emit(false);
-					costNode.emit(ZERO_COST);
-					this.loop.chat.append("user", userMsg);
-					this.loop.status.emit("thinking");
-				});
-			},
-			{ describeKind: "effect", meta: aiMeta("agent_input_drain") },
-		);
-		this.addDisposer(keepalive(drainEffect));
-
-		// `out` and `status` keepalives are unnecessary because the cost /
-		// status effects above already activate `loop.lastResponse` and
-		// `loop.status` — the derived `out` reads from a kept-alive source.
-		// We do keep `out` alive explicitly so `awaitSettled(bundle.out,
-		// { skipCurrent: true })` works even when no other consumer
-		// subscribes between input and response.
-		this.addDisposer(keepalive(this.out));
-
-		// Surface in describe.
-		void TERMINAL_STATUSES;
-	}
-}
-
-// ---------------------------------------------------------------------------
-// Default mappers
-// ---------------------------------------------------------------------------
-
-/**
- * Default `inMapper` for `TIn extends string`. Asserts the runtime type at
- * the boundary so callers who omit `inMapper` for a non-string `TIn` get a
- * clear error rather than a silent passthrough.
- */
-function defaultInMapper<TIn>(): (input: TIn) => string {
-	return (input) => {
-		if (typeof input !== "string") {
-			throw new TypeError(
-				`agent: inMapper is required when TIn is not a string (got ${typeof input}). Pass spec.inMapper.`,
-			);
-		}
-		return input;
-	};
-}
-
-/**
- * Default `outMapper` for `TOut extends LLMResponse`. Asserts the response
- * shape at the boundary; callers with a non-LLMResponse `TOut` must
- * provide `outMapper`.
- */
-function defaultOutMapper<TOut>(): (response: LLMResponse) => TOut {
-	return (response) => response as unknown as TOut;
-}
diff --git a/src/presets/ai/agents.ts b/src/presets/ai/agents.ts
deleted file mode 100644
index 3a024489..00000000
--- a/src/presets/ai/agents.ts
+++ /dev/null
@@ -1,170 +0,0 @@
-/**
- * Phase 13.H — `agent(spec)` preset + `presetRegistry` sugar.
- *
- * Source: `archive/docs/SESSION-multi-agent-gap-analysis.md` G1 + G2.
- *
- * `agent()` is the ergonomic factory — given a parent Graph and an
- * `AgentSpec`, mints an `AgentGraph`, mounts it under the parent at
- * `spec.name`, and returns the `AgentBundle` contract.
- *
- * `presetRegistry()` is thin sugar over `reactiveMap` — a typed reactive
- * map of `<id, preset>`. Pairs with `materialize` (Phase 13.C) for
- * dynamic preset selection: callers store specs / factories / configs in
- * the registry and `materialize` mounts the matching one based on a
- * routing key.
- *
- * **Cross-cut #1 lock:** no `agent.run()` imperative sugar — caller-side
- * runtime is `bundle.in.emit(input)` + `awaitSettled(bundle.out)`.
- */
-
-import { type ReactiveMapBundle, reactiveMap } from "@graphrefly/pure-ts/extra";
-import type { Graph } from "@graphrefly/pure-ts/graph";
-import type { LLMResponse } from "../../utils/ai/adapters/core/types.js";
-import { type AgentBundle, AgentGraph, type AgentSpec } from "./agent.js";
-
-// ---------------------------------------------------------------------------
-// agent() factory
-// ---------------------------------------------------------------------------
-
-/**
- * Mints an {@link AgentGraph} from `spec`, mounts it under `parent` at
- * `spec.name`, and returns the {@link AgentBundle} contract.
- *
- * **Default type parameters.** When called without explicit type params,
- * `TIn` defaults to `string` and `TOut` to `LLMResponse` — the common
- * case where the caller writes a user message and reads the raw response.
- * Custom types require both `inMapper` and `outMapper` in the spec; the
- * default mappers throw at runtime if `TIn` / `TOut` aren't string /
- * LLMResponse.
- *
- * **Memory partition default.** Each `agent()` call mints its own
- * `AgentMemoryGraph` if `spec.memory` is omitted (private memory; the
- * common case). Pass an explicit shared instance — e.g.
- * `agent(parent, { ..., memory: sharedMemory })` for two agents — to
- * implement §29 handoff context transfer.
- *
- * **Reactive entry / exit:**
- * - `bundle.in.emit(input)` kicks the loop reactively (no imperative
- *   `.run()` per cross-cut #1 lock).
- * - `awaitSettled(bundle.out, { skipCurrent: true })` resolves on the
- *   first response after the kick. `skipCurrent` matters for the second
- *   call onward — `out` caches the prior response.
- *
- * **Mounting.** The factory mounts under `parent.mount(spec.name, ...)`.
- * The slot name must be free on `parent` at construction time. To keep
- * the agent unmounted, construct `new AgentGraph(spec)` directly.
- *
- * @example
- * ```ts
- * import { agent, awaitSettled, Graph } from "@graphrefly/graphrefly";
- *
- * const parent = new Graph("parent");
- * const a = agent(parent, {
- *   name: "researcher",
- *   adapter: openaiAdapter,
- *   systemPrompt: "Research the user's question carefully.",
- * });
- * a.in.emit("What's the capital of France?");
- * const resp = await awaitSettled(a.out, { skipCurrent: true });
- * ```
- *
- * @category patterns
- */
-export function agent<TIn = string, TOut = LLMResponse>(
-	parent: Graph,
-	spec: AgentSpec<TIn, TOut>,
-): AgentBundle<TIn, TOut> {
-	const graph = new AgentGraph<TIn, TOut>(spec);
-	parent.mount(spec.name, graph);
-	return {
-		in: graph.in,
-		out: graph.out,
-		status: graph.status,
-		cost: graph.cost,
-		graph,
-	};
-}
-
-// ---------------------------------------------------------------------------
-// presetRegistry()
-// ---------------------------------------------------------------------------
-
-/**
- * The bundle returned by {@link presetRegistry}. Wraps a `reactiveMap`
- * with imperative `put` / `remove` shortcuts and exposes the underlying
- * `registry` for direct reactive consumption (`.entries` is a
- * `Node<ReadonlyMap<string, TPreset>>`).
- *
- * Use the `registry.entries` Node directly with {@link materialize} (Phase
- * 13.C) — pass it as the `factories` argument when `TPreset` is itself
- * a `() => Graph` factory thunk, or transform via `derived` when
- * `TPreset` is a richer spec type that needs a `spec → factory` adapter.
- */
-export interface PresetRegistryBundle<TPreset> {
-	/**
-	 * The underlying reactive map. `registry.entries` is the
-	 * `Node<ReadonlyMap<string, TPreset>>` — pass directly to
-	 * {@link materialize} when preset shape matches the factories arg.
-	 */
-	readonly registry: ReactiveMapBundle<string, TPreset>;
-	/** Imperative add / replace. Always emits a fresh snapshot. */
-	put(id: string, preset: TPreset): void;
-	/** Imperative remove. Returns `true` if the id was present. */
-	remove(id: string): boolean;
-}
-
-/**
- * Thin sugar over `reactiveMap` — a typed registry of `<id, preset>` for
- * agent / strategy / persona / skill catalogs.
- *
- * **Generic over preset shape.** `TPreset` is open — could be an
- * {@link AgentSpec}, a `() => Graph` factory thunk, a static config
- * object, or anything else. Decoupled from `agent()` so the same primitive
- * powers harnessLoop strategy registries, pipelineGraph stage catalogs,
- * etc.
- *
- * **Composes with `materialize`.** When `TPreset` is a `() => Graph`
- * factory, pass `registry.entries` directly to
- * {@link materialize} as the `factories` argument. When `TPreset` is a
- * spec, transform via `derived` to build a `Map<id, () => Graph>` adapter:
- *
- * ```ts
- * const presets = presetRegistry<AgentSpec<string, LLMResponse>>();
- * presets.put("researcher", { name: "researcher", adapter, systemPrompt: "..." });
- *
- * // Adapter: spec → factory.
- * const factories = derived(
- *   [presets.registry.entries],
- *   ([m]) => new Map(
- *     [...m].map(([id, spec]) => [id, () => new AgentGraph(spec)]),
- *   ),
- * );
- * const slot = materialize(activeKey, factories, parent);
- * ```
- *
- * @param initial - Optional initial entries.
- * @returns {@link PresetRegistryBundle}.
- *
- * @category patterns
- */
-export function presetRegistry<TPreset>(
-	initial?: ReadonlyMap<string, TPreset>,
-): PresetRegistryBundle<TPreset> {
-	const registry = reactiveMap<string, TPreset>({ name: "presetRegistry" });
-	if (initial != null) {
-		for (const [id, preset] of initial) {
-			registry.set(id, preset);
-		}
-	}
-	return {
-		registry,
-		put(id, preset) {
-			registry.set(id, preset);
-		},
-		remove(id) {
-			if (!registry.has(id)) return false;
-			registry.delete(id);
-			return true;
-		},
-	};
-}
diff --git a/src/presets/ai/context/index.ts b/src/presets/ai/context/index.ts
deleted file mode 100644
index 92e6cbab..00000000
--- a/src/presets/ai/context/index.ts
+++ /dev/null
@@ -1,399 +0,0 @@
-/**
- * DS-14.6.A U-A — tagged context substrate (Phase 14.5).
- *
- * Per-view tagged context (SESSION-DS-14.6-A L3–L6 + SESSION-DS-14.6-A-9Q
- * implementation walk). Pool stores immutable tier-0 originals on an
- * **append-only `reactiveLog`** (D-A4 — structural tier-0 immutability, free
- * `LogChange` mutations, side-steps the DS14R1 TTL/LRU prune-fidelity bug).
- * Each consumer holds a `ContextView` that materialises its own filtered +
- * compressed slice (`Node<readonly RenderedEntry[]>`). Routing is mechanical
- * tag comparison (zero LLM); only `llm-summary` rules cross to an injected
- * `llmCompress` (D-A3). Compression cache is one shared `(id, tier)` map in
- * the pool bundle, bounded LRU (D-A5). Schema is pure data, presentation
- * layer (D-A1) — no `@graphrefly/pure-ts` consumer.
- *
- * @module
- */
-
-import { type Node, node, wallClockNs } from "@graphrefly/pure-ts/core";
-import { type ReactiveLogBundle, reactiveLog } from "@graphrefly/pure-ts/extra";
-import { Graph } from "@graphrefly/pure-ts/graph";
-import { aiMeta } from "../../../utils/ai/_internal.js";
-
-// ── Schema (pure data — D-A1) ────────────────────────────────────────────────
-
-export type Tag = string;
-
-/** Compression tier. 0 = original; higher = more compressed. */
-export type Tier = 0 | 1 | 2 | 3;
-
-export interface ContextEntry<T> {
-	/** Stable id — cache key component `(id, tier)`. Auto-assigned if omitted. */
-	readonly id: string;
-	readonly payload: T;
-	readonly tags: readonly Tag[];
-	/** 0..1. Budget/GC ordering. */
-	readonly importance: number;
-	readonly compressible: boolean;
-	readonly topic: string;
-	/** Wall-clock at add (ns) — used by `poolGC({ olderThanNs })`. */
-	readonly t_ns: number;
-}
-
-export interface RuleMatch {
-	readonly topic?: string | RegExp;
-	readonly tagsAny?: readonly Tag[];
-	readonly importanceMin?: number;
-	readonly importanceMax?: number;
-	readonly compressible?: boolean;
-}
-
-export type CompressionRule =
-	| { readonly match: RuleMatch; readonly action: "evict" }
-	| { readonly match: RuleMatch; readonly action: "truncate"; readonly maxChars: number }
-	| { readonly match: RuleMatch; readonly action: "reference" }
-	| { readonly match: RuleMatch; readonly action: "llm-summary"; readonly toTier: Tier };
-
-export interface RenderedEntry<T> {
-	readonly id: string;
-	readonly topic: string;
-	readonly tags: readonly Tag[];
-	readonly tier: Tier;
-	/** Original payload at tier 0; compressed `string` otherwise. */
-	readonly payload: T | string;
-	readonly compressed: boolean;
-}
-
-export interface ContextView<T> {
-	readonly filter: (e: ContextEntry<T>) => boolean;
-	/** 0..1. A rule fires when `pressure > 0` and the entry matches. */
-	readonly pressure: Node<number>;
-	readonly budgetTokens: number;
-	readonly rules: readonly CompressionRule[];
-	/** Default `s => Math.ceil(s.length / 4)`. */
-	readonly tokenizer?: (s: string) => number;
-}
-
-export interface PoolGCPolicy {
-	/** Drop entries with `t_ns < (now - olderThanNs)`. */
-	readonly olderThanNs?: number;
-	/** Drop entries with `importance < importanceBelow`. */
-	readonly importanceBelow?: number;
-	/**
-	 * **Scope**, not a match-to-evict rule: when set, GC only considers
-	 * entries whose `topic === this`; entries of other topics always survive.
-	 * `olderThanNs` / `importanceBelow` are ANDed *within* this scope.
-	 */
-	readonly topic?: string;
-	/** Keep at most this many most-recent entries. */
-	readonly max?: number;
-}
-
-/** `(entry, toTier) => compressedText`. Injected; required iff a view uses `llm-summary`. */
-export type LlmCompress<T> = (entry: ContextEntry<T>, toTier: Tier) => string;
-
-export interface TaggedContextPoolOptions<T> {
-	readonly topic: string;
-	/** Forwarded to the backing append-only `reactiveLog` (poolGC ceiling). */
-	readonly maxEntries?: number;
-	/** Required iff any rendered view uses an `llm-summary` rule (D-A3). */
-	readonly llmCompress?: LlmCompress<T>;
-	/** Shared `(id, tier)` compression cache cap (D-A5). Default 512. */
-	readonly cacheMax?: number;
-	readonly name?: string;
-}
-
-export interface TaggedContextPoolBundle<T> {
-	/**
-	 * Append an entry (immutable tier-0). Returns its id (auto-assigned
-	 * `ctx-N` per-pool if omitted).
-	 *
-	 * **Caller-supplied ids must be unique within the pool.** The log is
-	 * append-only and does NOT dedupe; the compression cache is keyed by
-	 * `(id, tier)`, so appending two different entries with the same explicit
-	 * `id` makes the second render the first's cached summary (QA P11).
-	 */
-	add(entry: Omit<ContextEntry<T>, "id" | "t_ns"> & { id?: string }): string;
-	/** All live tier-0 entries. */
-	readonly entries: Node<readonly ContextEntry<T>[]>;
-	/** Entries carrying `tag`. */
-	byTag(tag: Tag): Node<readonly ContextEntry<T>[]>;
-	/** Pool-global retention (L6 — distinct from per-view filtering). Returns removed count. */
-	poolGC(policy: PoolGCPolicy): number;
-	readonly graph: Graph;
-	/** Internal — shared compression cache (one per pool, D-A5). */
-	readonly _cache: CompressionCache;
-	readonly _opts: TaggedContextPoolOptions<T>;
-	dispose(): void;
-}
-
-// ── Shared bounded (id,tier) compression cache (D-A5) ────────────────────────
-
-/**
- * Bounded LRU cache keyed by `(id, tier)`. Uses a nested `Map<id, Map<tier,
- * value>>` (NOT a `${id}::${tier}` string key) so a caller-supplied `id`
- * containing the separator cannot collide (QA P5). LRU is tracked at the
- * (id,tier) leaf via a flat insertion-order key list.
- */
-export class CompressionCache {
-	private readonly _m = new Map<string, Map<Tier, string>>();
-	/** Insertion-order list of `id` keys for LRU eviction at the id granularity. */
-	private readonly _order: string[] = [];
-	constructor(private readonly _max: number) {}
-	get(id: string, tier: Tier): string | undefined {
-		const inner = this._m.get(id);
-		const v = inner?.get(tier);
-		if (v !== undefined) {
-			const i = this._order.indexOf(id);
-			if (i >= 0) this._order.splice(i, 1);
-			this._order.push(id);
-		}
-		return v;
-	}
-	set(id: string, tier: Tier, value: string): void {
-		let inner = this._m.get(id);
-		if (inner === undefined) {
-			inner = new Map<Tier, string>();
-			this._m.set(id, inner);
-		}
-		inner.set(tier, value);
-		const i = this._order.indexOf(id);
-		if (i >= 0) this._order.splice(i, 1);
-		this._order.push(id);
-		while (this._m.size > this._max) {
-			const evict = this._order.shift();
-			if (evict === undefined) break;
-			this._m.delete(evict);
-		}
-	}
-}
-
-// ── Pool ─────────────────────────────────────────────────────────────────────
-
-/** Process-wide sequence for collision-safe default mount names (QA P6). */
-let _poolSeq = 0;
-
-/**
- * Append-only tagged context pool (D-A4). The pool is a `reactiveLog` of
- * immutable tier-0 entries plus a derived `entries` node; `byTag` derives a
- * filtered view; `poolGC` is the explicit pool-global retention (L6).
- */
-export function taggedContextPool<T>(
-	parent: Graph,
-	opts: TaggedContextPoolOptions<T>,
-): TaggedContextPoolBundle<T> {
-	// QA P6: collision-safe default mount name — two pools with the same
-	// `topic` under one parent must not collide on `parent.mount`. Explicit
-	// `opts.name` is respected verbatim (caller owns uniqueness then).
-	const mountName = opts.name ?? `ctxpool-${opts.topic}-${++_poolSeq}`;
-	const graph = new Graph(mountName);
-	parent.mount(mountName, graph);
-
-	const log: ReactiveLogBundle<ContextEntry<T>> = reactiveLog<ContextEntry<T>>(undefined, {
-		name: `${mountName}.log`,
-		maxSize: opts.maxEntries,
-	});
-	const cache = new CompressionCache(opts.cacheMax ?? 512);
-	// QA P5: per-pool id counter (was module-global → test-pollution +
-	// cross-pool cache-key cross-talk).
-	let autoId = 0;
-
-	const entries: Node<readonly ContextEntry<T>[]> = log.entries;
-
-	function add(e: Omit<ContextEntry<T>, "id" | "t_ns"> & { id?: string }): string {
-		const id = e.id ?? `ctx-${++autoId}`;
-		log.append({
-			id,
-			payload: e.payload,
-			tags: e.tags,
-			importance: e.importance,
-			compressible: e.compressible,
-			topic: e.topic,
-			t_ns: wallClockNs(), // QA P2 — clock.ts invariant (was Date.now()*1e6)
-		});
-		return id;
-	}
-
-	function byTag(tag: Tag): Node<readonly ContextEntry<T>[]> {
-		return node<readonly ContextEntry<T>[]>(
-			[entries as Node],
-			(data, actions, ctx) => {
-				const cur = (data[0] != null && data[0].length > 0 ? data[0].at(-1) : ctx.prevData[0]) as
-					| readonly ContextEntry<T>[]
-					| undefined;
-				actions.emit((cur ?? []).filter((x) => x.tags.includes(tag)));
-			},
-			{ describeKind: "derived", meta: aiMeta("contextPool.byTag", { tag }) },
-		);
-	}
-
-	function poolGC(policy: PoolGCPolicy): number {
-		const all = log.entries.cache ?? [];
-		const nowNs = wallClockNs();
-		let survivors = all.filter((e) => {
-			// QA P1: `topic` is a SCOPE, not a match-to-evict rule — entries
-			// outside the topic are never GC'd by this call; eviction criteria
-			// (olderThanNs / importanceBelow) are ANDed within the scope.
-			if (policy.topic != null && e.topic !== policy.topic) return true;
-			if (policy.olderThanNs != null && nowNs - e.t_ns >= policy.olderThanNs) return false;
-			if (policy.importanceBelow != null && e.importance < policy.importanceBelow) return false;
-			return true;
-		});
-		if (policy.max != null && survivors.length > policy.max) {
-			survivors = survivors.slice(survivors.length - policy.max);
-		}
-		const removed = all.length - survivors.length;
-		if (removed > 0) {
-			log.clear();
-			log.appendMany(survivors);
-		}
-		return removed;
-	}
-
-	return {
-		add,
-		entries,
-		byTag,
-		poolGC,
-		graph,
-		_cache: cache,
-		_opts: opts,
-		dispose(): void {
-			log.dispose();
-		},
-	};
-}
-
-// ── tierCompress + renderContextView ─────────────────────────────────────────
-
-const DEFAULT_TOKENIZER = (s: string): number => Math.ceil(s.length / 4);
-
-function matches(e: ContextEntry<unknown>, m: RuleMatch): boolean {
-	if (m.topic != null) {
-		if (typeof m.topic === "string" ? e.topic !== m.topic : !m.topic.test(e.topic)) return false;
-	}
-	if (m.tagsAny != null && !m.tagsAny.some((t) => e.tags.includes(t))) return false;
-	if (m.importanceMin != null && e.importance < m.importanceMin) return false;
-	if (m.importanceMax != null && e.importance > m.importanceMax) return false;
-	if (m.compressible != null && e.compressible !== m.compressible) return false;
-	return true;
-}
-
-/**
- * Apply the first matching rule to one entry under `pressure`. Non-LLM
- * strategies (truncate / evict / reference) are pure data; `llm-summary`
- * calls the injected `llmCompress`, caching by `(id, toTier)` (D-A5).
- * Returns `undefined` for evicted / pressure-filtered entries.
- */
-export function tierCompress<T>(
-	e: ContextEntry<T>,
-	rules: readonly CompressionRule[],
-	pressure: number,
-	cache: CompressionCache,
-	llmCompress?: LlmCompress<T>,
-): RenderedEntry<T> | undefined {
-	const base: RenderedEntry<T> = {
-		id: e.id,
-		topic: e.topic,
-		tags: e.tags,
-		tier: 0,
-		payload: e.payload,
-		compressed: false,
-	};
-	if (pressure <= 0) return base;
-	for (const rule of rules) {
-		if (!matches(e, rule.match)) continue;
-		switch (rule.action) {
-			case "evict":
-				return undefined;
-			case "reference":
-				return { ...base, tier: 1, payload: `[ref:${e.id}]`, compressed: true };
-			case "truncate": {
-				const s = typeof e.payload === "string" ? e.payload : JSON.stringify(e.payload);
-				return {
-					...base,
-					tier: 1,
-					payload: s.length > rule.maxChars ? s.slice(0, rule.maxChars) : s,
-					compressed: s.length > rule.maxChars,
-				};
-			}
-			case "llm-summary": {
-				if (!llmCompress) {
-					// Defence-in-depth — construction guard should have thrown.
-					throw new Error("tierCompress: 'llm-summary' rule requires `llmCompress`");
-				}
-				const cached = cache.get(e.id, rule.toTier);
-				const text = cached ?? llmCompress(e, rule.toTier);
-				if (cached === undefined) cache.set(e.id, rule.toTier, text);
-				return { ...base, tier: rule.toTier, payload: text, compressed: true };
-			}
-		}
-	}
-	return base;
-}
-
-/**
- * Per-consumer reactive rendering (D-A2). Materialises a
- * `Node<readonly RenderedEntry[]>` over the pool: filter → per-entry rule
- * application under `pressure` → token-budget trim (lowest-importance first).
- *
- * Recomputes the slice per `(entries | pressure)` wave (O(n) — behaviourally
- * identical to the incremental closure-mirror; incremental is a perf
- * follow-up, not a correctness gap).
- *
- * @throws if any rule is `llm-summary` and the pool has no `llmCompress`
- *   (D-A3 construction guard).
- */
-export function renderContextView<T>(
-	pool: TaggedContextPoolBundle<T>,
-	view: ContextView<T>,
-): Node<readonly RenderedEntry<T>[]> {
-	const usesLlm = view.rules.some((r) => r.action === "llm-summary");
-	if (usesLlm && !pool._opts.llmCompress) {
-		throw new Error(
-			"renderContextView: view has an 'llm-summary' rule but the pool was created without `llmCompress` (DS-14.6.A D-A3).",
-		);
-	}
-	const tokenize = view.tokenizer ?? DEFAULT_TOKENIZER;
-	const llmCompress = pool._opts.llmCompress;
-
-	return node<readonly RenderedEntry<T>[]>(
-		[pool.entries as Node, view.pressure as Node],
-		(data, actions, ctx) => {
-			const entries = (data[0] != null && data[0].length > 0 ? data[0].at(-1) : ctx.prevData[0]) as
-				| readonly ContextEntry<T>[]
-				| undefined;
-			const pressure = (data[1] != null && data[1].length > 0 ? data[1].at(-1) : ctx.prevData[1]) as
-				| number
-				| undefined;
-			if (entries === undefined) {
-				actions.emit([]);
-				return;
-			}
-			const p = pressure ?? 0;
-			const rendered: RenderedEntry<T>[] = [];
-			for (const e of entries) {
-				if (!view.filter(e)) continue;
-				const r = tierCompress(e, view.rules, p, pool._cache, llmCompress);
-				if (r !== undefined) rendered.push(r);
-			}
-			// Token-budget trim: drop lowest-importance entries until under budget.
-			const cost = (r: RenderedEntry<T>): number =>
-				tokenize(typeof r.payload === "string" ? r.payload : JSON.stringify(r.payload));
-			let total = 0;
-			for (const r of rendered) total += cost(r);
-			if (total > view.budgetTokens) {
-				const byImp = entries.reduce<Map<string, number>>(
-					(acc, e) => acc.set(e.id, e.importance),
-					new Map(),
-				);
-				rendered.sort((a, b) => (byImp.get(a.id) ?? 0) - (byImp.get(b.id) ?? 0));
-				while (total > view.budgetTokens && rendered.length > 0) {
-					total -= cost(rendered.shift() as RenderedEntry<T>);
-				}
-			}
-			actions.emit(rendered);
-		},
-		{ describeKind: "derived", meta: aiMeta("contextView", { topic: pool._opts.topic }) },
-	);
-}
diff --git a/src/presets/ai/debate/index.ts b/src/presets/ai/debate/index.ts
deleted file mode 100644
index 1974b330..00000000
--- a/src/presets/ai/debate/index.ts
+++ /dev/null
@@ -1,379 +0,0 @@
-/**
- * DS-14.6.A U-C — `heterogeneousDebate()` (Phase 14.5).
- *
- * Stanford-MAD heterogeneity thesis (SESSION-DS-14.6-A L9): participants get
- * **different model adapters + different role prompts**. Closed reasoning
- * loop — no tools / side effects / persistent state beyond the transcript.
- *
- * **Reactive topology (QA M1→b, 2026-05-15).** The round loop is NOT a
- * top-level `async while` driver. It mirrors `refineLoop`'s §7 feedback
- * shape so `describe()` / `explain()` / dry-run see the structure:
- *
- * ```
- *   roundTrigger(state) ──▶ roundWork(switchMap→producer, per-round
- *                            sequential adapter.invoke) ──▶ transcript(scan)
- *                            └─▶ converged(derived)              │
- *        ▲                                                       │
- *        └────────────  decideEffect (feedback + trigger)  ◀─────┘
- * ```
- *
- * The per-round participant calls are an async **source boundary** inside
- * the switchMap producer (spec §5.10 — async belongs in sources), with an
- * abort-on-deactivate `AbortController` (COMPOSITION-GUIDE §45) so a
- * superseded / torn-down round cancels its in-flight LLM calls. `decideEffect`
- * is the sole feedback authority (computes termination inline from the round
- * envelope + closure history, §28); `converged` is a parallel derived purely
- * for external `status` observability. Termination: `fixedRounds |
- * "until-converge" | { until: Node<boolean> }` — `until` is a real reactive
- * dep, not a `.cache` poll. `"until-converge"` uses a pluggable `converge?`
- * fn, default = no participant changed stance across the last 2 rounds
- * (D-C1, zero extra LLM cost). `output:"synthesizer-final"` with no
- * synthesizer-role participant throws at construction (D-C2).
- *
- * @module
- */
-
-import {
-	batch,
-	node as createNode,
-	ERROR,
-	INVALIDATE,
-	type Node,
-	RESOLVED,
-} from "@graphrefly/pure-ts/core";
-import { fromAny, switchMap } from "@graphrefly/pure-ts/extra";
-import { Graph } from "@graphrefly/pure-ts/graph";
-import { awaitSettled, firstValueFrom } from "../../../base/sources/settled.js";
-import type {
-	ChatMessage,
-	LLMAdapter,
-	LLMResponse,
-	NodeInput,
-} from "../../../utils/ai/adapters/core/types.js";
-
-export interface Turn {
-	readonly round: number;
-	readonly role: string;
-	readonly content: string;
-}
-
-export interface DebateParticipant {
-	readonly adapter: LLMAdapter;
-	/** e.g. "advocate" | "skeptic" | "synthesizer" | custom. */
-	readonly role: string;
-	readonly systemPrompt: string;
-}
-
-export type DebateTermination = number | "until-converge" | { readonly until: Node<boolean> };
-
-export type DebateOutput =
-	| "transcript"
-	| "synthesizer-final"
-	| { readonly project: (transcript: readonly Turn[]) => unknown };
-
-export type DebateStatus = "running" | "converged" | "max-rounds" | "error";
-
-export interface HeterogeneousDebateOptions {
-	readonly question: string;
-	readonly participants: readonly DebateParticipant[];
-	/** Default `3`. */
-	readonly rounds?: DebateTermination;
-	/** Default `"transcript"`. */
-	readonly output?: DebateOutput;
-	/**
-	 * D-C1 — `"until-converge"` detector. Default: no participant's latest
-	 * content changed vs the previous round (structural compare, no LLM).
-	 */
-	readonly converge?: (transcript: readonly Turn[]) => boolean;
-	readonly name?: string;
-	/** Hard ceiling for `"until-converge"` / `{ until }` (default 12). */
-	readonly maxRounds?: number;
-}
-
-export interface HeterogeneousDebateBundle {
-	readonly transcript: Node<readonly Turn[]>;
-	readonly result: Node<unknown>;
-	readonly status: Node<DebateStatus>;
-	readonly graph: DebateGraph;
-	/**
-	 * Thin `awaitSettled` bridge (mirrors `agentLoop.run()`): kicks the
-	 * reactive round loop and resolves the final `result`. Throws
-	 * `RangeError` if a prior `run()` is still pending (QA P4 re-entrancy).
-	 */
-	run(): Promise<unknown>;
-}
-
-export class DebateGraph extends Graph {}
-
-const SYNTH_RE = /synth/i;
-
-/** Default converge: every role's latest two rounds are identical. */
-function defaultConverge(transcript: readonly Turn[]): boolean {
-	const rounds = transcript.reduce((m, t) => Math.max(m, t.round), 0);
-	if (rounds < 2) return false;
-	const at = (r: number): Map<string, string> => {
-		const m = new Map<string, string>();
-		for (const t of transcript) if (t.round === r) m.set(t.role, t.content);
-		return m;
-	};
-	const prev = at(rounds - 1);
-	const cur = at(rounds);
-	if (prev.size === 0 || prev.size !== cur.size) return false;
-	for (const [role, content] of cur) if (prev.get(role) !== content) return false;
-	return true;
-}
-
-/** Process-wide sequence for collision-safe default mount names (QA P6). */
-let _debateSeq = 0;
-
-interface RoundEnvelope {
-	readonly round: number;
-	readonly turns: readonly Turn[];
-}
-
-export function heterogeneousDebate(
-	parent: Graph,
-	opts: HeterogeneousDebateOptions,
-): HeterogeneousDebateBundle {
-	const output = opts.output ?? "transcript";
-	if (output === "synthesizer-final" && !opts.participants.some((p) => SYNTH_RE.test(p.role))) {
-		throw new Error(
-			"heterogeneousDebate: output 'synthesizer-final' requires a participant whose role matches /synth/i (DS-14.6.A D-C2).",
-		);
-	}
-	if (opts.participants.length === 0) {
-		throw new Error("heterogeneousDebate: at least one participant is required");
-	}
-
-	const name = opts.name ?? `debate-${++_debateSeq}`;
-	const graph = new DebateGraph(name);
-	parent.mount(name, graph);
-
-	const term = opts.rounds ?? 3;
-	const maxRounds = opts.maxRounds ?? 12;
-	const converge = opts.converge ?? defaultConverge;
-	// `{ until }` becomes a real reactive dep (QA P10 — no `.cache` poll);
-	// non-until modes use a constant-false node for stable dep arity.
-	const untilNode: Node<boolean> =
-		typeof term === "object" ? term.until : createNode<boolean>([], { initial: false });
-
-	// --- state / output nodes -------------------------------------------------
-	const roundTrigger = createNode<number>([], { name: `${name}.round`, initial: 0 });
-	const statusState = createNode<DebateStatus>([], { name: `${name}.status`, initial: "running" });
-	const resultState = createNode<unknown>([], { name: `${name}.result`, initial: undefined });
-
-	// Closure history (§28 factory-time mirror) — the feedback authority's
-	// view of the transcript without a declared dep cycle.
-	let history: Turn[] = [];
-
-	function buildMessages(p: DebateParticipant): ChatMessage[] {
-		const msgs: ChatMessage[] = [
-			{ role: "system", content: p.systemPrompt },
-			{ role: "user", content: opts.question },
-		];
-		for (const t of history) {
-			msgs.push({ role: "assistant", content: `[${t.role} r${t.round}] ${t.content}` });
-		}
-		return msgs;
-	}
-
-	// --- GENERATE: roundTrigger → per-round sequential participant calls -------
-	// switchMap producer = async source boundary (spec §5.10). The producer's
-	// deactivate cleanup aborts in-flight calls (COMPOSITION-GUIDE §45 + the
-	// switchMap supersede path), so a torn-down round burns no extra tokens.
-	const roundWork = switchMap<number, RoundEnvelope>(
-		roundTrigger,
-		(r) =>
-			createNode<RoundEnvelope>(
-				[],
-				(_data, actions) => {
-					if (r < 1) {
-						actions.down([[RESOLVED]]);
-						return undefined;
-					}
-					const ac = new AbortController();
-					let cancelled = false;
-					(async () => {
-						const turns: Turn[] = [];
-						try {
-							for (const p of opts.participants) {
-								const res = await firstValueFrom(
-									fromAny<LLMResponse>(
-										p.adapter.invoke(buildMessages(p), {
-											signal: ac.signal,
-										}) as NodeInput<LLMResponse>,
-									),
-								);
-								if (cancelled) return;
-								turns.push({ round: r, role: p.role, content: res.content });
-							}
-							if (!cancelled) actions.emit({ round: r, turns });
-						} catch (err) {
-							if (!cancelled) actions.down([[ERROR, err]]);
-						}
-					})();
-					return {
-						onDeactivation: () => {
-							cancelled = true;
-							ac.abort();
-						},
-					};
-				},
-				{ describeKind: "producer", name: `${name}.round-work` },
-			),
-		{ name: `${name}.rounds` },
-	);
-	graph.add(roundWork, { name: "rounds" });
-
-	// --- transcript: scan-accumulate (external observability) -----------------
-	const transcript = createNode<readonly Turn[]>(
-		[roundWork],
-		(batchData, actions, ctx) => {
-			const env = (
-				batchData[0] != null && batchData[0].length > 0 ? batchData[0].at(-1) : ctx.prevData[0]
-			) as RoundEnvelope | undefined;
-			if (env === undefined) {
-				actions.down([[RESOLVED]]);
-				return;
-			}
-			actions.emit(history.slice());
-		},
-		{ name: `${name}.transcript`, describeKind: "derived" },
-	);
-	graph.add(transcript, { name: "transcript" });
-
-	// --- converged: parallel derived for external `status` (NOT authority) ----
-	const converged = createNode<{ done: boolean; reason: DebateStatus }>(
-		[transcript as Node, untilNode as Node],
-		(batchData, actions, ctx) => {
-			const tr = (
-				batchData[0] != null && batchData[0].length > 0 ? batchData[0].at(-1) : ctx.prevData[0]
-			) as readonly Turn[] | undefined;
-			const untilV = (
-				batchData[1] != null && batchData[1].length > 0 ? batchData[1].at(-1) : ctx.prevData[1]
-			) as boolean | undefined;
-			const rounds = (tr ?? []).reduce((m, t) => Math.max(m, t.round), 0);
-			if (typeof term === "number") {
-				actions.emit({ done: rounds >= term, reason: "max-rounds" });
-				return;
-			}
-			if (term === "until-converge") {
-				if (converge(tr ?? [])) actions.emit({ done: true, reason: "converged" });
-				else actions.emit({ done: rounds >= maxRounds, reason: "max-rounds" });
-				return;
-			}
-			actions.emit({ done: untilV === true || rounds >= maxRounds, reason: "max-rounds" });
-		},
-		{ name: `${name}.converged`, describeKind: "derived" },
-	);
-	graph.add(converged, { name: "converged" });
-
-	// --- decideEffect: SOLE feedback authority (§7 single-trigger) ------------
-	// Computes termination INLINE (round envelope + closure history + the
-	// reactive `untilNode` dep) — does NOT read `converged.cache` (avoids the
-	// same-wave drain-order hazard refineLoop documents). `converged` above is
-	// purely for external observation.
-	const decideEffect = createNode(
-		[roundWork as Node, untilNode as Node],
-		(batchData, _actions, ctx) => {
-			const env = (
-				batchData[0] != null && batchData[0].length > 0 ? batchData[0].at(-1) : undefined
-			) as RoundEnvelope | undefined;
-			const untilV = (
-				batchData[1] != null && batchData[1].length > 0 ? batchData[1].at(-1) : ctx.prevData[1]
-			) as boolean | undefined;
-			if (env === undefined) {
-				// `until` flipped with no new round — finalize if it went true.
-				if (typeof term === "object" && untilV === true && statusState.cache === "running") {
-					finalize("max-rounds");
-				}
-				return;
-			}
-			// New round settled — fold into the closure history first.
-			history = [...history, ...env.turns];
-			const r = env.round;
-			let done = false;
-			let reason: DebateStatus = "max-rounds";
-			if (typeof term === "number") done = r >= term;
-			else if (term === "until-converge") {
-				if (converge(history)) {
-					done = true;
-					reason = "converged";
-				} else done = r >= maxRounds;
-			} else done = untilV === true || r >= maxRounds;
-
-			if (done) finalize(reason);
-			else roundTrigger.emit(r + 1); // §7 feedback edge
-		},
-		{ name: `${name}.decide`, describeKind: "effect", errorWhenDepsError: false },
-	);
-	graph.add(decideEffect, { name: "decide" });
-
-	function finalize(reason: DebateStatus): void {
-		let out: unknown;
-		if (output === "transcript") out = history.slice();
-		else if (output === "synthesizer-final") {
-			const synth = [...history].reverse().find((t) => SYNTH_RE.test(t.role));
-			out = synth?.content ?? null;
-		} else out = output.project(history.slice());
-		batch(() => {
-			statusState.emit(reason);
-			resultState.emit(out);
-		});
-	}
-
-	// Error watcher — adapter throw surfaces as ERROR on roundWork.
-	const errorWatcher = createNode(
-		[roundWork as Node],
-		(_b, _a, ec) => {
-			const t = ec.terminalDeps[0];
-			if (t !== undefined && t !== true && statusState.cache === "running") {
-				batch(() => {
-					statusState.emit("error");
-					resultState.emit(new Error("heterogeneousDebate: a participant adapter errored"));
-				});
-			}
-		},
-		{ name: `${name}.error-watcher`, describeKind: "effect", errorWhenDepsError: false },
-	);
-	graph.add(errorWatcher, { name: "error-watcher" });
-
-	// Keepalive: activate the feedback + observability nodes so the loop runs
-	// and `.cache` stays warm without an external subscriber. These live for
-	// the graph's lifetime (torn down on parent-graph destroy).
-	decideEffect.subscribe(() => undefined);
-	errorWatcher.subscribe(() => undefined);
-	transcript.subscribe(() => undefined);
-	converged.subscribe(() => undefined);
-
-	let running = false;
-
-	return {
-		transcript,
-		result: resultState,
-		status: statusState,
-		graph,
-		async run(): Promise<unknown> {
-			if (running) {
-				throw new RangeError(
-					`heterogeneousDebate "${name}": run() called while a previous run() is still pending`,
-				);
-			}
-			running = true;
-			try {
-				history = [];
-				batch(() => {
-					statusState.emit("running");
-					resultState.down([[INVALIDATE]]);
-				});
-				// Subscribe BEFORE the kick (sync adapters would otherwise drain
-				// the terminal before awaitSettled subscribes).
-				const settled = awaitSettled(resultState, { skipCurrent: true });
-				roundTrigger.emit(1); // kick
-				return await settled;
-			} finally {
-				running = false;
-			}
-		},
-	};
-}
diff --git a/src/presets/ai/index.ts b/src/presets/ai/index.ts
deleted file mode 100644
index 853df96e..00000000
--- a/src/presets/ai/index.ts
+++ /dev/null
@@ -1,12 +0,0 @@
-/**
- * AI presets — opinionated compositions of ai utils.
- *
- * @module
- */
-
-export * from "./agent.js";
-export * from "./agent-loop.js";
-export * from "./agent-memory.js";
-export * from "./agents.js";
-export * from "./context/index.js";
-export * from "./debate/index.js";
diff --git a/src/presets/harness/actor-pool.ts b/src/presets/harness/actor-pool.ts
deleted file mode 100644
index 5b440659..00000000
--- a/src/presets/harness/actor-pool.ts
+++ /dev/null
@@ -1,214 +0,0 @@
-/**
- * DS-14.6.A U-B — `actorPool()` (Phase 14.5).
- *
- * The dynamic-track complement to `spawnable()` (SESSION-DS-14.6-A L7/L8 +
- * 9Q walk). An actor is **identity + cursor + tool closure, NOT a subgraph**
- * (D-B1): no per-actor mount, so `describe()` shows only the pool / todo /
- * context-hub collections and the actor count drifts inside a single
- * reactive `active` map node. `depthCap` is enforced via the depth carried
- * on the attach request (D-B2); `release()` cascades teardown to the
- * actor's context view + todo cursor subscriptions (§3i — free).
- *
- * Contrast `spawnable()`: agent IS a subgraph, topology reflects the agent
- * set, `describe()`-visible — use it when agent identities are pre-known.
- * Use `actorPool()` for runtime recursive fan-out where agent count drifts.
- *
- * @module
- */
-
-import { type Node, node } from "@graphrefly/pure-ts/core";
-import { type ReactiveLogBundle, reactiveLog } from "@graphrefly/pure-ts/extra";
-import { Graph } from "@graphrefly/pure-ts/graph";
-import {
-	type ContextEntry,
-	type ContextView,
-	type RenderedEntry,
-	renderContextView,
-	type TaggedContextPoolBundle,
-	taggedContextPool,
-} from "../ai/context/index.js";
-
-export type ActorId = string;
-
-export interface Todo {
-	readonly id: string;
-	readonly assignee?: ActorId;
-	readonly payload: unknown;
-}
-
-export type ActorStatus = "idle" | "running" | "blocked" | "done";
-
-export interface ActorState {
-	readonly id: ActorId;
-	readonly depth: number;
-	readonly status: ActorStatus;
-}
-
-export interface ActorSpec<T> {
-	readonly id?: ActorId;
-	/** Recursion depth — gated against `depthCap` (D-B2). Default 0 (root). */
-	readonly depth?: number;
-	/** Per-actor compression view over the shared context pool. */
-	readonly view: Omit<ContextView<T>, "pressure"> & { readonly pressure: Node<number> };
-}
-
-export interface ActorHandle<T> {
-	readonly id: ActorId;
-	/** This actor's compressed context slice. */
-	readonly context: Node<readonly RenderedEntry<T>[]>;
-	/** Todos currently assigned to this actor (or unassigned). */
-	readonly todoCursor: Node<readonly Todo[]>;
-	/** Write an entry into the shared pool, stamped with this actor's id tag. */
-	publish(entry: Omit<ContextEntry<T>, "id" | "t_ns"> & { id?: string }): string;
-	enqueueTodo(t: Todo): void;
-	readonly status: Node<ActorStatus>;
-	setStatus(s: ActorStatus): void;
-	/** Idempotent. Tears the actor's subscriptions + removes it from `active`. */
-	release(): void;
-}
-
-export interface ActorPoolOptions<T> {
-	readonly name?: string;
-	/**
-	 * Max recursion depth; `attachActor` with `depth > depthCap` throws.
-	 * Default: `8` (F-ACTOR, 2026-05-18 smell sweep — a finite default bounds
-	 * runaway recursive fan-out; previously silently `Infinity`). Pass an
-	 * explicit `Number.POSITIVE_INFINITY` to opt in to unbounded recursion.
-	 */
-	readonly depthCap?: number;
-	/** Forwarded to the backing context pool. */
-	readonly contextTopic?: string;
-	readonly llmCompress?: TaggedContextPoolBundle<T>["_opts"]["llmCompress"];
-}
-
-export interface ActorPoolBundle<T> {
-	attachActor(spec: ActorSpec<T>): ActorHandle<T>;
-	readonly contextPool: TaggedContextPoolBundle<T>;
-	readonly todos: ReactiveLogBundle<Todo>;
-	/** Single reactive map of live actors — `describe()`-coherent (D-B1). */
-	readonly active: Node<ReadonlyMap<ActorId, ActorState>>;
-	readonly graph: Graph;
-	dispose(): void;
-}
-
-/** Process-wide sequence for collision-safe default mount names (QA P6). */
-let _actorPoolSeq = 0;
-
-export function actorPool<T = unknown>(
-	parent: Graph,
-	opts: ActorPoolOptions<T> = {},
-): ActorPoolBundle<T> {
-	// QA P6: collision-safe default — recursive fan-out spins nested pools
-	// under one parent; static "actorPool" would collide on `parent.mount`.
-	const name = opts.name ?? `actorPool-${++_actorPoolSeq}`;
-	const graph = new Graph(name);
-	parent.mount(name, graph);
-	const depthCap = opts.depthCap ?? 8;
-	// QA P5: per-pool actor counter (was module-global → test-pollution).
-	let autoActor = 0;
-	// QA P7: track live handles so dispose() can release them all.
-	const liveHandles = new Set<ActorHandle<T>>();
-
-	const contextPool = taggedContextPool<T>(graph, {
-		topic: opts.contextTopic ?? "context",
-		llmCompress: opts.llmCompress,
-		name: `${name}.ctx`,
-	});
-	const todos: ReactiveLogBundle<Todo> = reactiveLog<Todo>(undefined, { name: `${name}.todos` });
-
-	// Single reactive `active` map node — actor count drifts inside it; no
-	// per-actor subgraph mount (D-B1, describe-coherent).
-	const stateMap = new Map<ActorId, ActorState>();
-	const active = node<ReadonlyMap<ActorId, ActorState>>([], {
-		name: `${name}.active`,
-		initial: new Map(),
-	});
-	function pushActive(): void {
-		active.emit(new Map(stateMap));
-	}
-
-	function attachActor(spec: ActorSpec<T>): ActorHandle<T> {
-		const depth = spec.depth ?? 0;
-		if (depth > depthCap) {
-			throw new RangeError(`actorPool: depth ${depth} exceeds depthCap ${depthCap}`);
-		}
-		const id = spec.id ?? `actor-${++autoActor}`;
-
-		const context = renderContextView(contextPool, spec.view as ContextView<T>);
-		// Per-actor todo cursor — assigned-to-me or unassigned.
-		const todoCursor = node<readonly Todo[]>(
-			[todos.entries as Node],
-			(data, actions, ctx) => {
-				const all = (data[0] != null && data[0].length > 0 ? data[0].at(-1) : ctx.prevData[0]) as
-					| readonly Todo[]
-					| undefined;
-				actions.emit((all ?? []).filter((t) => t.assignee === id || t.assignee === undefined));
-			},
-			{ describeKind: "derived" },
-		);
-		const status = node<ActorStatus>([], { name: `${name}.${id}.status`, initial: "idle" });
-
-		stateMap.set(id, { id, depth, status: "idle" });
-		pushActive();
-
-		// Keepalive subs so `.cache` stays warm; torn on release (cascade-cancel).
-		const subs = [
-			context.subscribe(() => {}),
-			todoCursor.subscribe(() => {}),
-			status.subscribe(() => {}),
-		];
-		let released = false;
-
-		const handle: ActorHandle<T> = {
-			id,
-			context,
-			todoCursor,
-			status,
-			publish(entry) {
-				const tags = [...(entry.tags ?? []), `actor:${id}`];
-				return contextPool.add({ ...entry, tags });
-			},
-			enqueueTodo(t) {
-				todos.append(t);
-			},
-			setStatus(s) {
-				status.emit(s);
-				const prev = stateMap.get(id);
-				if (prev) {
-					stateMap.set(id, { ...prev, status: s });
-					pushActive();
-				}
-			},
-			release() {
-				if (released) return;
-				released = true;
-				// Cascade-cancel: tearing the keepalive subs deactivates the
-				// per-actor derived nodes (lazy-deactivation — COMPOSITION-GUIDE
-				// §1), detaching `context`/`todoCursor`/`status` from the shared
-				// pool/todos logs once no other subscriber remains.
-				for (const u of subs) u();
-				stateMap.delete(id);
-				liveHandles.delete(handle);
-				pushActive();
-			},
-		};
-		liveHandles.add(handle);
-		return handle;
-	}
-
-	return {
-		attachActor,
-		contextPool,
-		todos,
-		active,
-		graph,
-		dispose(): void {
-			// QA P7: release outstanding actors first (tears their keepalive
-			// subs / deactivates per-actor derived nodes) before disposing the
-			// shared pool + todo log.
-			for (const h of [...liveHandles]) h.release();
-			contextPool.dispose();
-			todos.dispose();
-		},
-	};
-}
diff --git a/src/presets/harness/eval-verifier.ts b/src/presets/harness/eval-verifier.ts
deleted file mode 100644
index 84e4535f..00000000
--- a/src/presets/harness/eval-verifier.ts
+++ /dev/null
@@ -1,389 +0,0 @@
-/**
- * evalVerifier — re-run the affected eval tasks against the execute-stage
- * artifact instead of asking an LLM to opine on the fix.
- *
- * Pairs naturally with {@link refineExecutor}: refineExecutor emits an
- * `ExecuteOutput<T>.artifact` holding the converged candidate; evalVerifier
- * pulls it out via `extractArtifact` and feeds a single-candidate batch
- * into the same `Evaluator<T>` shape that `refineLoop` used. Consistent
- * scoring between EXECUTE and VERIFY — no "LLM said it looks fine" gap.
- *
- * **C2 lifecycle (Tier 6.5).** The work fn is invoked once per claimed
- * verify-stage job. A fresh single-candidate eval subgraph is mounted
- * inside the work fn and tears down when the JobFlow pump ack/unsubs.
- *
- * @module
- */
-
-import { batch, type Node, node } from "@graphrefly/pure-ts/core";
-import { filter } from "@graphrefly/pure-ts/extra";
-import { Graph } from "@graphrefly/pure-ts/graph";
-import type {
-	ExecuteOutput,
-	HarnessExecutor,
-	HarnessJobPayload,
-	HarnessVerifier,
-	TriagedItem,
-	VerifyOutput,
-} from "../../utils/harness/types.js";
-import type { JobEnvelope } from "../../utils/job-queue/index.js";
-import { refineExecutor } from "./refine-executor.js";
-import type {
-	DatasetItem,
-	EvalResult,
-	Evaluator,
-	RefineLoopOptions,
-	RefineStrategy,
-} from "./refine-loop.js";
-
-/** Summary of the re-eval wave passed to a custom `toOutput` mapper. */
-export interface EvalVerifierSummary {
-	readonly scores: readonly EvalResult[];
-	readonly meanScore: number;
-	readonly passCount: number;
-	readonly total: number;
-	readonly threshold: number;
-	/**
-	 * True when the EXECUTE stage did not produce an artifact (i.e.
-	 * `extractArtifact` returned `null` / `undefined`). Downstream mappers
-	 * can distinguish this from "evaluator ran but everything scored zero".
-	 */
-	readonly missingArtifact?: boolean;
-}
-
-/** Configuration for {@link evalVerifier}. */
-export interface EvalVerifierConfig<T> {
-	/**
-	 * Pull the artifact that should be re-evaluated out of the execute-stage
-	 * output. Default: `(exec) => exec.artifact as T` — works out-of-the-box
-	 * with `refineExecutor` (which populates `artifact` by default).
-	 */
-	extractArtifact?: (exec: ExecuteOutput<T>, item: TriagedItem) => T | null | undefined;
-
-	/**
-	 * Reactive evaluator — same contract as `refineLoop`'s `Evaluator<T>`.
-	 */
-	evaluator: Evaluator<T>;
-
-	/**
-	 * Resolve which dataset rows to score this verification against.
-	 */
-	datasetFor: (item: TriagedItem) => readonly DatasetItem[];
-
-	/** Mean score required to pass verification. Default `0.5`. */
-	threshold?: number;
-
-	/** Optional output mapper — override the default findings / errorClass shape. */
-	toOutput?: (summary: EvalVerifierSummary) => VerifyOutput;
-
-	/** Node name prefix for introspection. */
-	name?: string;
-
-	/**
-	 * Optional parent graph on which per-claim eval subgraphs mount at
-	 * `eval/${claimId}` (DS-13.5.D.4, locked 2026-05-01). When provided,
-	 * each claim creates a fresh `Graph(\`eval_${claimId}\`)` subgraph
-	 * carrying `candidates` / `dataset` / `output` and mounts it at
-	 * `eval/${claimId}` on this parent — `describe()` walks the parent
-	 * see the per-claim topology while the claim is in flight, and the
-	 * subgraph is removed via `parent.remove("eval/${claimId}")` on the
-	 * output node's `deactivate` cleanup (fires when JobFlow's pump
-	 * unsubscribes after ack/nack).
-	 *
-	 * **claimId source.** `JobEnvelope.id` (assigned at enqueue time);
-	 * unique within a JobFlow lifetime — uniqueness within a single pump
-	 * cycle is the JobFlow's contract.
-	 *
-	 * When omitted, internal nodes float (pre-DS-13.5.D.4 behavior).
-	 */
-	graph?: Graph;
-}
-
-function meanScore(scores: readonly EvalResult[]): number {
-	if (scores.length === 0) return Number.NEGATIVE_INFINITY;
-	let sum = 0;
-	for (const s of scores) sum += s.score;
-	return sum / scores.length;
-}
-
-function defaultToOutput(summary: EvalVerifierSummary): VerifyOutput {
-	const { passCount, total, meanScore: mean, threshold, missingArtifact } = summary;
-	const meanStr = Number.isFinite(mean) ? mean.toFixed(3) : String(mean);
-	const verified = !missingArtifact && total > 0 && mean >= threshold;
-	const findings = missingArtifact
-		? ["EXECUTE stage did not emit an artifact; cannot verify reactively"]
-		: verified
-			? [`${passCount}/${total} eval tasks passed; mean score ${meanStr} ≥ ${threshold}`]
-			: total === 0
-				? ["No eval tasks were selected for this item — cannot verify"]
-				: [
-						`${passCount}/${total} eval tasks passed; mean score ${meanStr} < threshold ${threshold}`,
-					];
-	return verified
-		? { verified: true, findings }
-		: { verified: false, findings, errorClass: "structural" };
-}
-
-function defaultExtractArtifact<T>(exec: ExecuteOutput<T>): T | null | undefined {
-	return exec.artifact ?? null;
-}
-
-/**
- * Build a {@link HarnessVerifier} that re-runs the eval suite against the
- * artifact produced by EXECUTE.
- *
- * Reads `job.payload.execution` (filled by the upstream execute work fn)
- * and runs the evaluator against `extractArtifact(execution, item)`.
- * Returns the same payload with `verify` filled in.
- *
- * @example Pair with refineExecutor for end-to-end eval consistency.
- * ```ts
- * const evaluator: Evaluator<CatalogEntry> = (cands, ds) => runEval(cands, ds);
- * const harness = harnessLoop("repair", {
- *   adapter,
- *   executor: refineExecutor({ ..., evaluator, ...strategyConfig }),
- *   verifier: evalVerifier({ evaluator, datasetFor, threshold: 0.8 }),
- * });
- * ```
- */
-export function evalVerifier<T>(config: EvalVerifierConfig<T>): HarnessVerifier<T> {
-	const name = config.name ?? "eval-verifier";
-	const threshold = config.threshold ?? 0.5;
-	const toOutput = config.toOutput ?? defaultToOutput;
-	const extract = config.extractArtifact ?? defaultExtractArtifact<T>;
-	const parentGraph = config.graph;
-	// DS-13.5.B QA A7 (2026-05-03): per-claimId collision counter.
-	// Reingest paths preserve identity per DS-13.5.D.3 so the same
-	// claimId can land on the verifier while a prior cycle is still
-	// in-flight. Without disambiguation, `parentGraph.mount(
-	// "eval/${id}", sub)` would either silently overwrite the prior
-	// mount or throw "mount already exists". The counter is keyed by
-	// claimId so DISTINCT ids start at seq=0 (`eval/${id}`) and only
-	// REPEAT ids get a `_${seq}` suffix.
-	const mountSeqByClaimId = new Map<string, number>();
-
-	return (job: JobEnvelope<HarnessJobPayload<T>>) => {
-		const { item, execution } = job.payload;
-		// Defensive: verify stage should always run AFTER execute stage with
-		// `execution` populated. If it isn't, surface that as a structural
-		// failure so the dispatch effect can route the item.
-		if (execution == null) {
-			return {
-				...job.payload,
-				verify: {
-					verified: false,
-					findings: ["evalVerifier: prior execute stage produced no execution"],
-					errorClass: "structural" as const,
-				},
-			} satisfies HarnessJobPayload<T>;
-		}
-		const artifact = extract(execution, item);
-		if (artifact == null) {
-			return {
-				...job.payload,
-				verify: toOutput({
-					scores: [],
-					meanScore: Number.NEGATIVE_INFINITY,
-					passCount: 0,
-					total: 0,
-					threshold,
-					missingArtifact: true,
-				}),
-			} satisfies HarnessJobPayload<T>;
-		}
-
-		// Per-claim eval subgraph. State seeds with the single candidate +
-		// resolved dataset; the evaluator returns a Node<readonly EvalResult[]>.
-		// The terminal payload emits when the evaluator settles; intermediate
-		// nulls are filtered.
-		//
-		// **Batch-coalescing for synchronous-emit-during-subscribe evaluators
-		// (COMPOSITION-GUIDE §9a).** This `batch()` wrap is load-bearing for a
-		// SPECIFIC evaluator pattern: evaluators that, during the
-		// `evaluator(candidates, dataset)` constructor call, synchronously
-		// `subscribe()` to BOTH inputs and emit on each subscribe-callback
-		// firing. Each subscribe pushes the cached value to its callback, the
-		// callback runs `out.emit(...)`, and that emit becomes its own wave
-		// when not inside a batch — leaving multiple DATA messages visible to
-		// the downstream `derived` once it activates. The JobFlow pump's
-		// "first DATA wins" capture would then fire on the FIRST intermediate
-		// emit (e.g. empty scores from a pre-dataset recompute) instead of
-		// the final settled value.
-		//
-		// Wrapping the constructor call in `batch()` coalesces those internal
-		// emits into one multi-message delivery (§9a); sugar `derived`
-		// auto-unwraps to the LAST value per its snapshot/combine semantics
-		// (sugar.ts), so the downstream sees only the final settled scores.
-		//
-		// **Async evaluators are NOT covered by this fix.** Evaluators that
-		// subscribe via microtask / Promise.then() / setTimeout don't see the
-		// §9a hazard at all — their emits land in separate waves regardless
-		// of whether the constructor call is batched. The fix is strictly
-		// for the synchronous-emit-during-subscribe pattern (today's tests:
-		// `presenceEvaluator` in actuator-executor.test.ts; `keywordEvaluator`
-		// in refine-executor.test.ts uses `derived` and is naturally
-		// single-emit). See `harness-default-bridges.test.ts` regression test
-		// "evalVerifier coalesces synchronous-emit-during-subscribe
-		// evaluators" for the locked contract.
-		// DS-13.5.D.4 (locked 2026-05-01): when `parentGraph` is configured,
-		// each claim creates its own subgraph `eval_${claimId}` and mounts
-		// it at `eval/${claimId}` on the parent. Internal node names use
-		// the simple shape (`candidates`, `dataset`, `output`) since each
-		// subgraph is a fresh namespace. Cleanup attaches to `raw`'s
-		// deactivate hook so the segment is removed when JobFlow
-		// unsubscribes after ack/nack (canonical "last unsubscribe"
-		// signal via the existing NodeFnCleanup.onDeactivation protocol).
-		const claimId = job.id;
-		// QA A7: only append a `_${seq}` suffix when this claimId has
-		// already been mounted (collision case). Distinct claimIds
-		// resolve to `eval/${claimId}` as before.
-		const seq = mountSeqByClaimId.get(claimId) ?? 0;
-		mountSeqByClaimId.set(claimId, seq + 1);
-		const segmentSuffix = seq === 0 ? "" : `_${seq}`;
-		const segmentPath = `eval/${claimId}${segmentSuffix}`;
-		const sub = parentGraph != null ? new Graph(`eval_${claimId}${segmentSuffix}`) : null;
-		const candidatesName = sub != null ? "candidates" : `${name}/candidates`;
-		const datasetName = sub != null ? "dataset" : `${name}/dataset`;
-		const outputName = sub != null ? "output" : `${name}/output`;
-		const gateName = sub != null ? "gate-out" : `${name}/gate-out`;
-
-		const candidates = node<readonly T[]>([], {
-			initial: [artifact as T],
-			name: candidatesName,
-		});
-		const dataset = node<readonly DatasetItem[]>([], {
-			initial: config.datasetFor(item),
-			name: datasetName,
-		});
-		if (sub != null) {
-			sub.add(candidates, { name: "candidates" });
-			sub.add(dataset, { name: "dataset" });
-		}
-		let scoresNode!: ReturnType<Evaluator<T>>;
-		batch(() => {
-			scoresNode = config.evaluator(candidates, dataset);
-		});
-		// DS-13.5.B QA A1 (2026-05-03): the deactivate cleanup hook MUST
-		// be returned on every fn run, including the early-return path
-		// where `arr == null` (evaluator emits a placeholder before
-		// settling). Cleanup capture happens at the END of fn execution
-		// (NodeFnCleanup contract), so a fn that returned early without
-		// the cleanup object would leak `eval/${claimId}` if its first
-		// run produced null and the consumer unsubscribed before
-		// scoresNode emits non-null.
-		const cleanup =
-			parentGraph != null
-				? () => ({
-						onDeactivation: () => {
-							// Auto-unmount on JobFlow's pump unsubscribe after
-							// ack/nack (DS-13.5.D.4). Idempotent: try/catch
-							// covers the case where the segment was already
-							// removed (e.g. parent destroy cascade ran first).
-							try {
-								parentGraph.remove(segmentPath);
-							} catch {
-								/* best-effort cleanup */
-							}
-						},
-					})
-				: () => undefined;
-		const raw = node<HarnessJobPayload<T> | null>(
-			[scoresNode as Node<unknown>],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				const arr = data[0] as readonly EvalResult[] | null | undefined;
-				if (arr == null) {
-					actions.emit(null);
-					return cleanup();
-				}
-				const mean = meanScore(arr);
-				const passCount = arr.filter((s) => s.score >= threshold).length;
-				actions.emit({
-					...job.payload,
-					verify: toOutput({
-						scores: arr,
-						meanScore: mean,
-						passCount,
-						total: arr.length,
-						threshold,
-					}),
-				});
-				return cleanup();
-			},
-			{ name: outputName, describeKind: "derived" },
-		);
-		const gateOut = filter(raw, (v) => v != null, { name: gateName }) as ReturnType<
-			HarnessVerifier<T>
-		>;
-		if (sub != null) {
-			sub.add(raw, { name: "output" });
-			// QA A6: register the gate-out filter on the per-claim
-			// subgraph so describe() walks see the consumer-facing node
-			// alongside candidates/dataset/output. Without this, the
-			// returned filter floats and the subgraph's external surface
-			// is incomplete in topology snapshots.
-			sub.add(gateOut as Node<unknown>, { name: "gate-out" });
-			(parentGraph as Graph).mount(segmentPath, sub);
-		}
-		return gateOut;
-	};
-}
-
-/**
- * Config for {@link harnessEvalPair} — the typed bundle that produces a
- * matched `refineExecutor<T>` + `evalVerifier<T>` pair sharing one
- * {@link Evaluator} and one `datasetFor` resolver.
- */
-export interface HarnessEvalPairConfig<T> {
-	/** Map a triaged item to the seed candidate. */
-	seedFrom: (item: TriagedItem) => T;
-	/** The reactive evaluator used by BOTH executor and verifier. */
-	evaluator: Evaluator<T>;
-	/** The refinement strategy (e.g. `errorCritique(teacher)`). */
-	strategy: RefineStrategy<T>;
-	/** Resolve dataset rows per triaged item. */
-	datasetFor: (item: TriagedItem) => readonly DatasetItem[];
-	/** Pass-threshold for the verifier. Default `0.5`. */
-	threshold?: number;
-	/** Convergence / budget options forwarded to each inner `refineLoop`. */
-	refine?: Omit<RefineLoopOptions, "dataset" | "name">;
-	/**
-	 * Shared node-name prefix — the executor becomes `${name}-exec` and the
-	 * verifier `${name}-verify` for distinct but related describe() paths.
-	 * Default `"harness-pair"`.
-	 */
-	name?: string;
-}
-
-/**
- * Typed factory that returns a matched `{ executor, verifier }` pair.
- *
- * Prevents the "executor wrote `A`, verifier expected `B`" class of runtime
- * cast errors — `T` is threaded through both sides, so mixing up the
- * configuration is a compile error instead of a silent `as T` in
- * `extractArtifact`. Shares the evaluator so EXECUTE and VERIFY score with
- * identical semantics (the whole point of `evalVerifier`).
- */
-export function harnessEvalPair<T>(config: HarnessEvalPairConfig<T>): {
-	executor: HarnessExecutor<T>;
-	verifier: HarnessVerifier<T>;
-} {
-	const baseName = config.name ?? "harness-pair";
-	const executor = refineExecutor<T>({
-		name: `${baseName}-exec`,
-		seedFrom: config.seedFrom,
-		evaluator: config.evaluator,
-		strategy: config.strategy,
-		datasetFor: config.datasetFor,
-		refine: config.refine,
-	});
-	const verifier = evalVerifier<T>({
-		name: `${baseName}-verify`,
-		evaluator: config.evaluator,
-		datasetFor: config.datasetFor,
-		threshold: config.threshold,
-	});
-	return { executor, verifier };
-}
diff --git a/src/presets/harness/harness-loop.ts b/src/presets/harness/harness-loop.ts
deleted file mode 100644
index 46fc14cf..00000000
--- a/src/presets/harness/harness-loop.ts
+++ /dev/null
@@ -1,1033 +0,0 @@
-/**
- * harnessLoop() factory (roadmap §9.0).
- *
- * Wires the static 7-stage topology: INTAKE → TRIAGE → QUEUE → GATE →
- * EXECUTE → VERIFY → REFLECT. Static topology, flowing data — the Kafka
- * insight applied to human+LLM collaboration.
- *
- * **Hub model (Wave B Unit 20 C + Q1).** All reactive-wire-crossing topics
- * live in one `MessagingHubGraph` exposed as `HarnessGraph.queues`: the
- * four per-route queues, an `__unrouted` dead-letter, plus `intake`,
- * `retry`, `verify-results`, and the `triage-output` fan-in topic. The
- * router is a single derived/effect pair that publishes to `triage-output`;
- * per-route `topicBridge`s fan out by `map:` predicate. Routing is data
- * (topic name), not code — every routing decision is a visible edge in
- * `describe()` / `explain()`.
- *
- * **EXECUTE/VERIFY via JobFlow (Tier 6.5 C2 lock, 2026-04-28).** The
- * stages 5–6 EXECUTE → VERIFY pair runs through an internal `executeFlow`
- * JobFlow with two stages (`execute`, `verify`). Each stage's pump owns
- * `claim → work → ack` for one claim; the verify stage's payload contains
- * `{ item, execution, verify }` so the post-completed dispatch effect can
- * route the 3-way verdict (verified / self-correctable retry / structural
- * + reingest) without any cross-wave `withLatestFrom` pairing. Items
- * arriving from per-route topics + retry feedback enter via a single
- * `enqueueEffect` that pushes to `executeFlow.queue("execute")`.
- *
- * @module
- */
-
-import { monotonicNs, type Node, node, placeholderArgs } from "@graphrefly/pure-ts/core";
-import { merge, withLatestFrom } from "@graphrefly/pure-ts/extra";
-import { Graph } from "@graphrefly/pure-ts/graph";
-import { tryIncrementBounded } from "../../base/mutation/index.js";
-import { _oneShotLlmCall, stripFences } from "../../utils/ai/_internal.js";
-import type { ChatMessage, LLMAdapter } from "../../utils/ai/index.js";
-import { promptNode } from "../../utils/ai/index.js";
-import { trackingKey } from "../../utils/harness/_internal.js";
-import {
-	DEFAULT_DECAY_RATE,
-	DEFAULT_EXECUTE_PROMPT,
-	DEFAULT_QUEUE_CONFIGS,
-	DEFAULT_SEVERITY_WEIGHTS,
-	DEFAULT_TRIAGE_PROMPT,
-	DEFAULT_VERIFY_PROMPT,
-	defaultErrorClassifier,
-	QUEUE_NAMES,
-	resolvePromptFn,
-} from "../../utils/harness/defaults.js";
-import {
-	type StrategyModelGraph,
-	type StrategySnapshot,
-	strategyModel,
-} from "../../utils/harness/strategy.js";
-import type {
-	ErrorClassifier,
-	ExecuteOutput,
-	ExecutePromptFn,
-	ExecutionResult,
-	HarnessExecutor,
-	HarnessJobPayload,
-	HarnessLoopOptions,
-	HarnessVerifier,
-	IntakeItem,
-	QueueConfig,
-	QueueRoute,
-	TriagedItem,
-	VerifyOutput,
-	VerifyPromptFn,
-	VerifyResult,
-} from "../../utils/harness/types.js";
-import { DEFAULT_PRESET_ID, strategyKey } from "../../utils/harness/types.js";
-import {
-	type JobEnvelope,
-	type JobFlowGraph,
-	type JobQueueGraph,
-	jobFlow,
-	jobQueue,
-} from "../../utils/job-queue/index.js";
-import {
-	type MessagingHubGraph,
-	messagingHub,
-	type TopicGraph,
-	topicBridge,
-} from "../../utils/messaging/index.js";
-import { type GateController, pipelineGraph } from "../../utils/orchestration/index.js";
-
-// ---------------------------------------------------------------------------
-// Hub topic names (internal constants — strings are the routing API)
-// ---------------------------------------------------------------------------
-
-const TOPIC_INTAKE = "intake";
-const TOPIC_TRIAGE_OUTPUT = "triage-output";
-const TOPIC_RETRY = "retry";
-const TOPIC_VERIFY_RESULTS = "verify-results";
-const TOPIC_UNROUTED = "__unrouted";
-
-// ---------------------------------------------------------------------------
-// Default LLM executor / verifier work fns (Tier 6.5 C2)
-// ---------------------------------------------------------------------------
-
-/**
- * Build the default EXECUTE work fn — calls `adapter.invoke()` once per
- * claimed job, parses the JSON response into an `ExecuteOutput<A>`, and
- * returns a {@link HarnessJobPayload} with `execution` filled in.
- *
- * Errors (parse failure, adapter throw, malformed JSON) are caught and
- * surfaced as a `failure`-outcome payload — the dispatch effect routes
- * the item rather than dropping it via pump nack (see C2 contract on
- * {@link HarnessExecutor}).
- *
- * Subsumes the pre-Tier-6.5 `promptNode`-based default: per-claim LLM
- * calls don't benefit from `promptNode`'s cross-wave switchMap, and a
- * fresh per-claim subgraph would be wasteful. Direct `adapter.invoke`
- * is the right shape inside JobFlow pumps.
- *
- * @param adapter - LLMAdapter for the execute call.
- * @param prompt  - Prompt template (string or `(item) => string`). Defaults
- *                   to the harness's built-in execute prompt.
- */
-export function defaultLlmExecutor<A = unknown>(
-	adapter: LLMAdapter,
-	prompt?: string | ExecutePromptFn,
-): HarnessExecutor<A> {
-	const promptFn = resolvePromptFn<TriagedItem>(prompt, DEFAULT_EXECUTE_PROMPT, (tpl, item) =>
-		tpl.replace("{{item}}", JSON.stringify(item)),
-	);
-	return (job, opts) => {
-		const item = job.payload.item;
-		const messages: readonly ChatMessage[] = [{ role: "user", content: promptFn(item) }];
-		// Bridge-layer flakes get `outcome: "failure"` with no `errorClass`.
-		// The dispatch effect's `errorClassifier` runs over `detail` and the
-		// default classifier matches `parse|json|config|validation|syntax`,
-		// so parse-error flakes route to retry. Adapter HTTP/network failures
-		// without a keyword fall through to structural per the existing
-		// asymmetry (executor side relies on classifier; verifier side sets
-		// errorClass directly per qa F3).
-		const failurePayload = (detail: string): HarnessJobPayload<A> => ({
-			...job.payload,
-			execution: { item, outcome: "failure", detail },
-		});
-		const formatErr = (err: unknown): string => (err instanceof Error ? err.message : String(err));
-		// One-shot bridge via `_oneShotLlmCall` (patterns/ai/_internal.ts).
-		// Helper owns subscription / abort / first-DATA capture / COMPLETE
-		// arm; this site owns parse + validate + payload mapping. Pump-
-		// supplied `opts.signal` (Tier 6.5 2.5b) cascades into adapter +
-		// fromAny via `parentSignal`.
-		return _oneShotLlmCall<HarnessJobPayload<A>>(adapter, messages, {
-			parentSignal: opts?.signal,
-			onSuccess: (resp) => {
-				let parsed: unknown;
-				try {
-					parsed = JSON.parse(stripFences(String(resp.content)));
-				} catch (err) {
-					return failurePayload(`execute parse error: ${formatErr(err)}`);
-				}
-				// Validate plain object before field access — non-object JSON
-				// (`null` / number / array / string) silently masks malformed
-				// responses unless caught here. Surfaced via parse-error keyword
-				// for classifier routing.
-				if (parsed == null || typeof parsed !== "object" || Array.isArray(parsed)) {
-					return failurePayload(
-						`execute parse error: non-object response: ${JSON.stringify(parsed)}`,
-					);
-				}
-				const obj = parsed as Partial<ExecuteOutput<A>>;
-				return {
-					...job.payload,
-					execution: {
-						item,
-						outcome: obj.outcome ?? "failure",
-						detail: obj.detail ?? "unknown",
-						artifact: obj.artifact,
-					},
-				};
-			},
-			onFailure: (kind, err) => {
-				if (kind === "complete") {
-					return failurePayload("adapter completed without emitting DATA");
-				}
-				return failurePayload(`executor failed: ${formatErr(err)}`);
-			},
-		});
-	};
-}
-
-/**
- * Build the default VERIFY work fn — calls `adapter.invoke()` once per
- * claimed job to review the prior-stage execution, parses the JSON
- * response into a `VerifyOutput`, and returns a {@link HarnessJobPayload}
- * with `verify` filled in.
- *
- * Same C2 error semantics as {@link defaultLlmExecutor}: parse / adapter
- * failures are surfaced as a structural-failure verify payload so the
- * dispatch effect routes the item.
- */
-export function defaultLlmVerifier<A = unknown>(
-	adapter: LLMAdapter,
-	prompt?: string | VerifyPromptFn<A>,
-): HarnessVerifier<A> {
-	const promptFn = resolvePromptFn<readonly [ExecuteOutput<A> | null, TriagedItem | null]>(
-		prompt,
-		DEFAULT_VERIFY_PROMPT,
-		(tpl, pair) => {
-			const [execution, item] = pair;
-			return tpl
-				.replace("{{execution}}", JSON.stringify(execution))
-				.replace("{{item}}", JSON.stringify(item));
-		},
-	);
-	return (job, opts) => {
-		const { item, execution } = job.payload;
-		if (execution == null) {
-			// Defensive — verify stage runs after execute; if execution is
-			// missing, surface as STRUCTURAL failure rather than throw. This is
-			// the only structural-classified path here: it indicates a topology
-			// bug (verify ran without execute), not an LLM-bridge flake. Bridge
-			// flakes (parse / adapter throw / ERROR / COMPLETE-without-DATA) get
-			// `errorClass: "self-correctable"` below so the dispatch effect's
-			// retry budget absorbs them before reingest fires (qa F3).
-			return {
-				...job.payload,
-				verify: {
-					verified: false,
-					findings: ["verifier: prior execute stage produced no execution"],
-					errorClass: "structural",
-				},
-			} satisfies HarnessJobPayload<A>;
-		}
-		const messages: readonly ChatMessage[] = [
-			{ role: "user", content: promptFn([execution, item]) },
-		];
-		// Bridge-layer flakes: classify as self-correctable so the dispatch
-		// effect routes via the retry budget first. Persistent flakes still
-		// fall through to structural after `maxRetries` exhaustion (qa F3).
-		const failurePayload = (finding: string): HarnessJobPayload<A> => ({
-			...job.payload,
-			verify: {
-				verified: false,
-				findings: [finding],
-				errorClass: "self-correctable",
-			},
-		});
-		const formatErr = (err: unknown): string => (err instanceof Error ? err.message : String(err));
-		// One-shot bridge — see `_oneShotLlmCall` JSDoc. Helper owns the
-		// subscribe + capture + abort + COMPLETE arm; this site owns parse +
-		// validate + verify-payload mapping. Pump-supplied `opts.signal`
-		// (Tier 6.5 2.5b) cascades into adapter + fromAny via `parentSignal`.
-		return _oneShotLlmCall<HarnessJobPayload<A>>(adapter, messages, {
-			parentSignal: opts?.signal,
-			onSuccess: (resp) => {
-				let parsed: unknown;
-				try {
-					parsed = JSON.parse(stripFences(String(resp.content)));
-				} catch (err) {
-					return failurePayload(`verify parse error: ${formatErr(err)}`);
-				}
-				if (parsed == null || typeof parsed !== "object" || Array.isArray(parsed)) {
-					return failurePayload(
-						`verify parse error: non-object response: ${JSON.stringify(parsed)}`,
-					);
-				}
-				const obj = parsed as Partial<VerifyOutput>;
-				return {
-					...job.payload,
-					verify: {
-						verified: obj.verified === true,
-						findings: obj.findings ?? [],
-						errorClass: obj.errorClass,
-					},
-				};
-			},
-			onFailure: (kind, err) => {
-				if (kind === "complete") {
-					return failurePayload("verifier completed without emitting DATA");
-				}
-				return failurePayload(`verifier failed: ${formatErr(err)}`);
-			},
-		});
-	};
-}
-
-// ---------------------------------------------------------------------------
-// HarnessGraph
-// ---------------------------------------------------------------------------
-
-/**
- * The graph returned by {@link harnessLoop}. Wraps a single
- * {@link MessagingHubGraph} that owns all reactive-wire-crossing topics
- * (intake, per-route queues, `__unrouted`, retry, verify-results,
- * triage-output), plus an `executeFlow` JobFlow that owns the
- * EXECUTE → VERIFY pipeline (Tier 6.5 C2). Sugar getters expose the
- * canonical topics so the surface stays ergonomic.
- */
-export class HarnessGraph<A = unknown> extends Graph {
-	/** Messaging hub — the routing-data plane. Queue topics live here. */
-	readonly queues: MessagingHubGraph;
-
-	/**
-	 * EXECUTE → VERIFY JobFlow (Tier 6.5 C2). Pumps own claim/ack/nack
-	 * lifecycle for each stage. Inspect via:
-	 * - `harness.executeFlow.queue("execute").pending` — pending depth.
-	 * - `harness.executeFlow.queue("verify").pending` — items mid-execute.
-	 * - `harness.executeFlow.completed` — verified items waiting for the
-	 *   dispatch effect's 3-way routing.
-	 * - `harness.executeFlow.completedCount` — total terminal completions.
-	 */
-	readonly executeFlow: JobFlowGraph<HarnessJobPayload<A>>;
-
-	/**
-	 * Per-route JobQueueGraph audit mirrors. Each triaged item that reaches
-	 * a queue is also enqueued here, giving reactive `depth` + `pending` +
-	 * `jobs` observables per route. The dispatch effect ack/removeBy-id's
-	 * the matching job on terminal verdict. The executeFlow JobFlow handles
-	 * the EXECUTE → VERIFY data flow; this is a parallel audit-side ledger
-	 * for per-route depth metrics. Inspect via
-	 * `harness.jobs.get(route).depth.cache` for backpressure metrics.
-	 */
-	readonly jobs: ReadonlyMap<QueueRoute, JobQueueGraph<TriagedItem>>;
-
-	/** Per-route gate controllers (only for gated queues). */
-	readonly gates: ReadonlyMap<QueueRoute, GateController<TriagedItem>>;
-
-	/**
-	 * Per-route queue topics — typed accessor for the four
-	 * {@link QUEUE_NAMES} entries (`auto-fix`, `needs-decision`,
-	 * `investigation`, `backlog`). Mirrors the `gates` / `jobs` map
-	 * shape so callers can iterate `[route, topic]` pairs without
-	 * hand-rolling `harness.queues.topicNames()` + meta-topic exclusion.
-	 *
-	 * Excludes the meta topics that share the hub:
-	 * `intake` (use {@link intake}), `verify-results` (use
-	 * {@link verifyResults}), `retry` (use {@link retry}), `__unrouted`
-	 * (use {@link unrouted}), and the internal `triage-output` fan-in.
-	 */
-	readonly queueTopics: ReadonlyMap<QueueRoute, TopicGraph<TriagedItem>>;
-
-	/**
-	 * Strategy model — `auditedSuccessTracker` keyed by `StrategyKey`.
-	 *
-	 * **Ownership (EC10/EC15).** Owned by the harness: it is mounted as a
-	 * child subgraph (`harness.mount("strategy", strategy)`), so its disposal
-	 * cascades from `harness.destroy()` via the mount lifecycle. Do **not**
-	 * call `strategy.destroy()` independently — the harness's `triage-input`
-	 * node and (when `opts.priority` is set) `buildPriorityScores` hold
-	 * cross-graph deps on `strategy.entries`; destroying the strategy out of
-	 * band staleness those nodes while the rest of the loop keeps running.
-	 * Read/subscribe freely; let the harness own the lifecycle.
-	 */
-	readonly strategy: StrategyModelGraph;
-
-	/** Global retry count across all items (circuit breaker). Reactive — subscribable. */
-	readonly totalRetries: Node<number>;
-
-	/** Global reingestion count across all items (circuit breaker). Reactive — subscribable. */
-	readonly totalReingestions: Node<number>;
-
-	/**
-	 * Per-route priority score nodes, populated only when `opts.priority` is
-	 * set on {@link harnessLoop}. Each node emits a score combining severity,
-	 * attention decay, and strategy-model effectiveness for the route's
-	 * current head-of-queue item. `undefined` means the caller did not opt
-	 * in to priority scoring.
-	 */
-	readonly priorityScores?: ReadonlyMap<QueueRoute, Node<number>>;
-
-	/**
-	 * REFLECT-stage tick marker — emits one DATA per terminal verdict observed
-	 * on `executeFlow.completed`. `equals: () => false` so each completion
-	 * produces an observable tick (no Object.is collapse on identical
-	 * `null` payloads). Inspection tools (`harnessTrace`, dashboards) can
-	 * subscribe directly here instead of resolving by string path
-	 * (`harness.node("reflect")`) — the field is the lock against rename
-	 * drift.
-	 */
-	readonly reflect: Node<null>;
-
-	constructor(
-		name: string,
-		queues: MessagingHubGraph,
-		executeFlow: JobFlowGraph<HarnessJobPayload<A>>,
-		queueTopics: Map<QueueRoute, TopicGraph<TriagedItem>>,
-		jobs: Map<QueueRoute, JobQueueGraph<TriagedItem>>,
-		gates: Map<QueueRoute, GateController<TriagedItem>>,
-		strategy: StrategyModelGraph,
-		totalRetries: Node<number>,
-		totalReingestions: Node<number>,
-		reflect: Node<null>,
-		priorityScores?: Map<QueueRoute, Node<number>>,
-	) {
-		super(name);
-		this.queues = queues;
-		this.executeFlow = executeFlow;
-		this.queueTopics = queueTopics;
-		this.jobs = jobs;
-		this.gates = gates;
-		this.strategy = strategy;
-		this.totalRetries = totalRetries;
-		this.totalReingestions = totalReingestions;
-		this.reflect = reflect;
-		this.priorityScores = priorityScores;
-	}
-
-	/** Intake topic — publish items here to enter the loop. */
-	get intake(): TopicGraph<IntakeItem> {
-		return this.queues.topic<IntakeItem>(TOPIC_INTAKE);
-	}
-
-	/** Verify results topic — subscribe to see verification outcomes. */
-	get verifyResults(): TopicGraph<VerifyResult<A>> {
-		return this.queues.topic<VerifyResult<A>>(TOPIC_VERIFY_RESULTS);
-	}
-
-	/** Retry feedback topic — fast-retry re-entry point. */
-	get retry(): TopicGraph<TriagedItem> {
-		return this.queues.topic<TriagedItem>(TOPIC_RETRY);
-	}
-
-	/** Dead-letter topic for items whose LLM-chosen route is unknown. */
-	get unrouted(): TopicGraph<TriagedItem> {
-		return this.queues.topic<TriagedItem>(TOPIC_UNROUTED);
-	}
-
-	/**
-	 * Stage-label → observe-path map for the 7 pipeline stages.
-	 *
-	 * Decouples inspection tools (`harnessTrace`, `harnessProfile`, custom
-	 * dashboards) from mount-structure churn: hub migration, future stage
-	 * splits, gate remounting, or the Tier 6.5 C2 JobFlow rewire shouldn't
-	 * require edits to `trace.ts` as long as this method stays accurate.
-	 *
-	 * Each stage yields `{ label, paths }`; consumers iterate paths per
-	 * stage and attach observers. Tier 6.5: EXECUTE / VERIFY paths now
-	 * resolve to the `executeFlow` stage queues + the `verify-dispatch`
-	 * effect node.
-	 */
-	stageNodes(): ReadonlyArray<{ label: string; paths: readonly string[] }> {
-		const hub = this.queues;
-		const resolveHubPath = (name: string): string | null =>
-			hub.has(name) ? `queues::${name}::latest` : null;
-		const includeIf = <T>(value: T | null | undefined): readonly T[] =>
-			value == null ? [] : [value];
-
-		const queuePaths = QUEUE_NAMES.flatMap((r) => includeIf(resolveHubPath(r)));
-		const gatePaths: string[] = [];
-		for (const [route] of this.gates) {
-			gatePaths.push(`gates::${route}/gate`);
-		}
-		return [
-			{ label: "INTAKE", paths: includeIf(resolveHubPath("intake")) },
-			{ label: "TRIAGE", paths: ["triage"] },
-			{ label: "QUEUE", paths: queuePaths },
-			{ label: "GATE", paths: gatePaths },
-			{ label: "EXECUTE", paths: ["executeFlow::execute::events"] },
-			{ label: "VERIFY", paths: ["executeFlow::verify::events"] },
-			{ label: "REFLECT", paths: ["reflect"] },
-			{ label: "STRATEGY", paths: ["strategy::entries"] },
-		];
-	}
-}
-
-// ---------------------------------------------------------------------------
-// harnessLoop factory
-// ---------------------------------------------------------------------------
-
-/**
- * Wire the reactive collaboration loop as a static-topology graph.
- *
- * The loop has 7 stages:
- * 1. **INTAKE** — items arrive from multiple sources via `intake.publish()`
- * 2. **TRIAGE** — promptNode classifies, routes, and prioritizes
- * 3. **QUEUE** — 4 priority-ordered TopicGraphs (auto-fix, needs-decision, investigation, backlog)
- * 4. **GATE** — human approval on configurable queues
- * 5. **EXECUTE** — JobFlow `execute` stage; user-supplied or default work fn
- * 6. **VERIFY** — JobFlow `verify` stage; verifies the executed artifact
- * 7. **REFLECT** — strategy model records outcomes; dispatch effect routes 3-way
- *
- * @param name - Graph name.
- * @param opts - Configuration.
- * @returns HarnessGraph with controller accessors.
- */
-export function harnessLoop<A = unknown>(
-	name: string,
-	opts: HarnessLoopOptions<A>,
-): HarnessGraph<A> {
-	const adapter = opts.adapter;
-	const maxRetries = opts.maxRetries ?? 2;
-	const retainedLimit = opts.retainedLimit ?? 1000;
-	const errorClassifier: ErrorClassifier = opts.errorClassifier ?? defaultErrorClassifier;
-
-	const queueConfigs = new Map<QueueRoute, QueueConfig>();
-	for (const route of QUEUE_NAMES) {
-		queueConfigs.set(route, {
-			...DEFAULT_QUEUE_CONFIGS[route],
-			...opts.queues?.[route],
-		});
-	}
-
-	// --- Messaging hub (Wave B Q1 Option A) ---
-	const queuesHub = messagingHub(`${name}/queues`, {
-		defaultTopicOptions: { retainedLimit },
-	});
-
-	// Eagerly create canonical topics so they appear in `describe()` from
-	// construction time and `harness.queues.has(route)` answers `true`
-	// before any publish.
-	const intake = queuesHub.topic<IntakeItem>(TOPIC_INTAKE);
-	const triageOutput = queuesHub.topic<TriagedItem>(TOPIC_TRIAGE_OUTPUT);
-	const retryTopic = queuesHub.topic<TriagedItem>(TOPIC_RETRY);
-	const verifyResults = queuesHub.topic<VerifyResult<A>>(TOPIC_VERIFY_RESULTS);
-	const queueTopics = new Map<QueueRoute, TopicGraph<TriagedItem>>();
-	for (const route of QUEUE_NAMES) {
-		queueTopics.set(route, queuesHub.topic<TriagedItem>(route));
-	}
-	const unroutedTopic = queuesHub.topic<TriagedItem>(TOPIC_UNROUTED);
-
-	// --- Strategy model (used by triage + dispatch) ---
-	const strategy = strategyModel();
-
-	// --- Stage 2: TRIAGE ---
-	// triageInput pairs intake.latest (trigger) with strategy.entries
-	// (advisory, sampled via withLatestFrom). Breaks the feedback cycle
-	// (verify → strategy.record → strategy.entries would otherwise re-fire
-	// triage on every recorded outcome).
-	const triageInput = withLatestFrom(
-		intake.latest as Node<unknown>,
-		strategy.entries as Node<unknown>,
-	);
-
-	const triagePromptFn = resolvePromptFn<readonly [IntakeItem, StrategySnapshot]>(
-		opts.triagePrompt,
-		DEFAULT_TRIAGE_PROMPT,
-		(tpl, pair) => {
-			const [item, strat] = pair;
-			return tpl
-				.replace("{{strategy}}", JSON.stringify(Array.from(strat.entries())))
-				.replace("{{item}}", JSON.stringify(item));
-		},
-	);
-
-	const triageNode = promptNode<TriagedItem>(
-		adapter as LLMAdapter,
-		[triageInput as Node<unknown>],
-		(pair: unknown) => {
-			// `intake.latest` is now SENTINEL on empty (COMPOSITION-GUIDE §1a),
-			// so the `withLatestFrom partial:false` gate holds the fn until both
-			// deps deliver real DATA. The `=== undefined` guard catches the
-			// edge where the pair itself is unset (defensive — shouldn't fire
-			// in normal flow).
-			const asPair = pair as readonly [IntakeItem, StrategySnapshot] | undefined;
-			if (asPair === undefined) return "";
-			return triagePromptFn(asPair);
-		},
-		{
-			name: "triage",
-			format: "json",
-		},
-	);
-
-	// --- Stage 3: QUEUE (hub routing) ---
-	//
-	// Router is a thin effect that publishes the merged TriagedItem to
-	// `triage-output`. `topicBridge`s fan it out to per-route queues by
-	// filtering on `item.route`. Unknown routes flow into `__unrouted` so
-	// misclassified items become a subscribable dead-letter signal.
-	const routerInput = withLatestFrom(triageNode as Node<unknown>, triageInput as Node<unknown>);
-	const router = node(
-		[routerInput as Node<unknown>],
-		(batchData, _actions, ctx) => {
-			const data = batchData.map((batch, i) =>
-				batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-			);
-			const pair = data[0];
-			if (pair == null) return;
-			const [classification, triagePair] = pair as [
-				TriagedItem | null,
-				[IntakeItem | null, StrategySnapshot] | null,
-			];
-			if (!classification?.route) return;
-			const intakeItem = triagePair?.[0];
-			// Intake fields win over classification: the LLM only owns the five
-			// triage-classification fields (rootCause, intervention, route,
-			// priority, triageReasoning); any intake state it accidentally
-			// returns is overwritten by the real intake value via the trailing
-			// spread.
-			const merged: TriagedItem = { ...classification, ...intakeItem } as TriagedItem;
-			triageOutput.publish(merged);
-		},
-		{ describeKind: "effect" },
-	);
-	const routerUnsub = router.subscribe(() => {});
-
-	// TopicBridges fan triage-output into per-route queues (visible edges).
-	const knownRoutes = new Set<string>(QUEUE_NAMES);
-	for (const route of QUEUE_NAMES) {
-		topicBridge<TriagedItem>(`bridge/${route}`, triageOutput, queueTopics.get(route)!, {
-			map: (item) => (item.route === route ? item : undefined),
-		});
-	}
-	topicBridge<TriagedItem>("bridge/__unrouted", triageOutput, unroutedTopic, {
-		map: (item) => (knownRoutes.has(item.route) ? undefined : item),
-	});
-
-	// --- Per-route audit JobQueueGraphs (parallel ledger) ---
-	//
-	// One jobQueue per route mirrors the route topic's publishes so
-	// dashboards get a subscribable `depth` / `pending` / `jobs` view of
-	// in-progress items. Identity is established at enqueue time (the
-	// returned `id` is paired with `trackingKey(item)`); the dispatch
-	// effect calls `JobQueueGraph.removeById(id)` on terminal verdict.
-	//
-	// This audit ledger runs in parallel with the `executeFlow` JobFlow
-	// (Tier 6.5 C2). The two are complementary:
-	// - This ledger gives **per-route** depth/pending observables
-	//   ("how backed up is auto-fix?").
-	// - executeFlow gives **per-stage** depth/pending observables
-	//   ("how many items are mid-execute?").
-	//
-	// **Retry handling.** Retry items republished to `retryTopic` flow
-	// into executeFlow (via the enqueue effect) but NOT into per-route
-	// audit jq's (retryTopic isn't mirrored). The audit job stays alive
-	// across retries — only terminal (verified / structural) decisions
-	// remove it. `depth` reflects "items still being worked on".
-	//
-	// **Ring-buffer safety.** WeakSet keyed on item identity; once the
-	// topic's ring buffer trims the head, dropped entries become
-	// unreachable and the WeakSet auto-prunes.
-	const jobQueues = new Map<QueueRoute, JobQueueGraph<TriagedItem>>();
-	const routeJobIds = new Map<string, { route: QueueRoute; id: string }>();
-	for (const route of QUEUE_NAMES) {
-		jobQueues.set(route, jobQueue<TriagedItem>(`jobs/${route}`));
-	}
-	const jobMirrorUnsubs: Array<() => void> = [];
-	for (const route of QUEUE_NAMES) {
-		const topic = queueTopics.get(route)!;
-		const jq = jobQueues.get(route)!;
-		const seen = new WeakSet<object>();
-		const mirror = node(
-			[topic.events as Node<unknown>],
-			(batchData, _actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				const events = data[0];
-				const arr = (events ?? []) as readonly TriagedItem[];
-				for (const item of arr) {
-					if (seen.has(item as unknown as object)) continue;
-					seen.add(item as unknown as object);
-					const id = jq.enqueue(item);
-					routeJobIds.set(trackingKey(item), { route, id });
-				}
-			},
-			{ name: `jobs/${route}-mirror`, describeKind: "effect" },
-		);
-		jobMirrorUnsubs.push(mirror.subscribe(() => {}));
-	}
-
-	function ackJob(item: TriagedItem): void {
-		const key = trackingKey(item);
-		const entry = routeJobIds.get(key);
-		if (!entry) return;
-		jobQueues.get(entry.route)?.removeById(entry.id);
-		routeJobIds.delete(key);
-	}
-
-	// --- Stage 4: GATE ---
-	//
-	// Per-route gates between `topic.latest` and the executeFlow enqueue.
-	// Foreign-node-accept (Session B.1): pass `topic.latest` directly; the
-	// gate factory auto-adds the source under `${name}/source` inside its
-	// own graph if not already registered.
-	const gateGraph = pipelineGraph("gates");
-	const gateControllers = new Map<QueueRoute, GateController<TriagedItem>>();
-	for (const route of QUEUE_NAMES) {
-		const config = queueConfigs.get(route)!;
-		if (!config.gated) continue;
-		const topic = queueTopics.get(route)!;
-		const ctrl = gateGraph.approvalGate<TriagedItem>(
-			`${route}/gate`,
-			topic.latest as Node<unknown>,
-			{
-				maxPending: config.maxPending,
-				startOpen: config.startOpen,
-			},
-		);
-		gateControllers.set(route, ctrl);
-	}
-
-	// --- executeInput: merge of post-gate route latests + retry feedback ---
-	// All inputs are SENTINEL until first DATA (COMPOSITION-GUIDE §1a): topic
-	// `latest` returns `[]` on empty, gate `output` doesn't push pre-DATA.
-	const queueOutputs: Node<TriagedItem>[] = [];
-	for (const route of QUEUE_NAMES) {
-		const config = queueConfigs.get(route)!;
-		if (config.gated && gateControllers.has(route)) {
-			queueOutputs.push(gateControllers.get(route)!.output as Node<TriagedItem>);
-		} else {
-			queueOutputs.push(queueTopics.get(route)!.latest);
-		}
-	}
-	queueOutputs.push(retryTopic.latest);
-
-	const executeInput = merge<TriagedItem>(...queueOutputs);
-
-	// --- Stages 5+6: EXECUTE → VERIFY via JobFlow (Tier 6.5 C2) ---
-	const executor: HarnessExecutor<A> =
-		opts.executor ?? defaultLlmExecutor<A>(adapter as LLMAdapter, opts.executePrompt);
-	const verifier: HarnessVerifier<A> =
-		opts.verifier ?? defaultLlmVerifier<A>(adapter as LLMAdapter, opts.verifyPrompt);
-
-	// Per-stage `maxPerPump` caps via the JobFlow `StageDef.maxPerPump`
-	// extension (Tier 6.5 D1 follow-up). Each stage gets its own cap;
-	// callers can pin execute at a low concurrency for cost control while
-	// leaving verify unbounded (or vice versa). Defaults to
-	// `Number.MAX_SAFE_INTEGER` per stage — matches today's unbounded
-	// `merge()` parallelism.
-	const executeMaxPerPump = opts.executeMaxPerPump ?? Number.MAX_SAFE_INTEGER;
-	const verifyMaxPerPump = opts.verifyMaxPerPump ?? Number.MAX_SAFE_INTEGER;
-
-	const executeFlow = jobFlow<HarnessJobPayload<A>>(`${name}/executeFlow`, {
-		stages: [
-			{ name: "execute", work: (job) => executor(job), maxPerPump: executeMaxPerPump },
-			{ name: "verify", work: (job) => verifier(job), maxPerPump: verifyMaxPerPump },
-		],
-	});
-
-	// Enqueue effect: per-item bridge from the reactive `executeInput`
-	// stream into the JobFlow. Each non-null item becomes one JobEnvelope
-	// at the execute stage. Retry items (via `retryTopic`) re-enter the
-	// flow as fresh enqueues with their `$retries` counter bumped.
-	const enqueueEffect = node(
-		[executeInput as Node<unknown>],
-		(batchData, _actions, ctx) => {
-			const data = batchData.map((batch, i) =>
-				batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-			);
-			const item = data[0];
-			if (item === undefined) return;
-			executeFlow.enqueue({ item: item as TriagedItem });
-		},
-		{ name: "execute-enqueue", describeKind: "effect" },
-	);
-	const enqueueUnsub = enqueueEffect.subscribe(() => {});
-
-	// --- Stage 7: dispatch effect (REFLECT + retry/structural routing) ---
-	//
-	// Replaces the pre-Tier-6.5 `fastRetry` effect. Reads completed
-	// JobEnvelopes from `executeFlow.completed`, identifies new ones via
-	// WeakSet, and dispatches the 3-way verdict:
-	//
-	// 1. **Verified** → record success, publish VerifyResult, ack audit job.
-	// 2. **Self-correctable + retries available** → republish to retryTopic
-	//    with $retries bumped (no audit ack — retry stays in the audit ledger).
-	// 3. **Structural / retries exhausted** → record failure, publish
-	//    VerifyResult, ack audit job, reingest if reingestion budget remains.
-	//
-	// Imperative cross-graph publish from inside an effect is sanctioned
-	// per COMPOSITION-GUIDE §32 / §35 for terminal side-effects with audit
-	// trails (here: verifyResults / retry / intake topics).
-	const maxReingestions = opts.maxReingestions ?? 1;
-	const maxTotalRetries = Math.min(opts.maxTotalRetries ?? maxRetries * 10, 100);
-	const maxTotalReingestions = Math.min(opts.maxTotalReingestions ?? maxReingestions * 10, 100);
-	const totalRetries = node([], { initial: 0 });
-	const totalReingestions = node([], { initial: 0 });
-
-	function assembleResult(
-		execution: ExecutionResult<A>,
-		verify: VerifyOutput,
-		item: TriagedItem,
-	): VerifyResult<A> {
-		return {
-			item,
-			execution,
-			verified: verify.verified,
-			findings: verify.findings ?? [],
-			errorClass: verify.errorClass,
-		};
-	}
-
-	function handleVerified(vr: VerifyResult<A>, item: TriagedItem): void {
-		strategy.record(strategyKey(DEFAULT_PRESET_ID, item.rootCause, item.intervention), true, {
-			presetId: DEFAULT_PRESET_ID,
-			rootCause: item.rootCause,
-			intervention: item.intervention,
-		});
-		verifyResults.publish(vr);
-		ackJob(item);
-	}
-
-	function handleRetry(vr: VerifyResult<A>, item: TriagedItem): void {
-		const key = trackingKey(item);
-		const itemRetries = item.$retries ?? 0;
-		const retryItem: TriagedItem = {
-			...item,
-			$retries: itemRetries + 1,
-			summary: `[RETRY ${itemRetries + 1}/${maxRetries}] ${key} — Previous attempt failed: ${vr.findings.join("; ")}`,
-			relatedTo: [key],
-		};
-		retryTopic.publish(retryItem);
-		// Audit job stays alive across retries — only terminal (verified /
-		// structural) decisions remove it.
-	}
-
-	function handleStructural(vr: VerifyResult<A>, item: TriagedItem): void {
-		strategy.record(strategyKey(DEFAULT_PRESET_ID, item.rootCause, item.intervention), false, {
-			presetId: DEFAULT_PRESET_ID,
-			rootCause: item.rootCause,
-			intervention: item.intervention,
-		});
-		verifyResults.publish(vr);
-		ackJob(item);
-		const key = trackingKey(item);
-		const itemReingestions = item.$reingestions ?? 0;
-		if (
-			itemReingestions < maxReingestions &&
-			tryIncrementBounded(totalReingestions, maxTotalReingestions)
-		) {
-			intake.publish({
-				source: item.source,
-				summary: `Verification failed for: ${key}`,
-				evidence: vr.findings.join("\n"),
-				affectsAreas: item.affectsAreas,
-				affectsEvalTasks: item.affectsEvalTasks,
-				severity: item.severity ?? "high",
-				relatedTo: [key],
-				$reingestions: itemReingestions + 1,
-			});
-		}
-	}
-
-	// Monotonic length cursor (qa F4) — `executeFlow.completed` retains up to
-	// `DEFAULT_COMPLETED_RETAINED_LIMIT` (1024) entries; each new completion
-	// emits a fresh snapshot containing every retained job. A naive
-	// `WeakSet.has` walk is O(retainedLimit) per emit. Track the last-seen
-	// length and only iterate the new tail. The cursor is capped at the
-	// snapshot length to handle ring-buffer trims (when the retained log
-	// drops oldest entries past the limit, `arr.length` shrinks and the
-	// cursor catches up automatically).
-	let dispatchCursor = 0;
-	const dispatchEffect = node(
-		[executeFlow.completed as Node<unknown>],
-		(batchData, _actions, ctx) => {
-			const data = batchData.map((batch, i) =>
-				batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-			);
-			const log = data[0];
-			const arr = (log ?? []) as readonly JobEnvelope<HarnessJobPayload<A>>[];
-			// Trim handling: if the retained log shrunk below our cursor, the
-			// missing entries are gone (we already processed them or the trim
-			// happened mid-flight); just clamp.
-			if (dispatchCursor > arr.length) dispatchCursor = arr.length;
-			const start = dispatchCursor;
-			dispatchCursor = arr.length;
-			for (let i = start; i < arr.length; i++) {
-				const job = arr[i] as JobEnvelope<HarnessJobPayload<A>>;
-				const { item, execution, verify } = job.payload;
-				// Defensive — both should always be present in a verify-stage
-				// completion. If either is missing, log via verifyResults so the
-				// failure is observable but don't block the dispatch effect.
-				if (execution == null || verify == null) {
-					ackJob(item);
-					continue;
-				}
-				const vr = assembleResult(execution, verify, item);
-				if (vr.verified) {
-					handleVerified(vr, item);
-					continue;
-				}
-				const errClass =
-					vr.errorClass ??
-					errorClassifier({
-						item,
-						outcome: execution.outcome,
-						detail: vr.findings.join("; "),
-					});
-				const itemRetries = item.$retries ?? 0;
-				if (
-					errClass === "self-correctable" &&
-					itemRetries < maxRetries &&
-					tryIncrementBounded(totalRetries, maxTotalRetries)
-				) {
-					handleRetry(vr, item);
-				} else {
-					handleStructural(vr, item);
-				}
-			}
-		},
-		{ name: "verify-dispatch", describeKind: "effect" },
-	);
-	const dispatchUnsub = dispatchEffect.subscribe(() => {});
-
-	// REFLECT — topology marker derived from completed-log emissions.
-	// `equals: () => false` disables Object.is absorption so each
-	// completion produces an observable REFLECT tick (one per verify
-	// wave). Without this, `null === null` would collapse every emit
-	// after the first into RESOLVED and the trace would show a single
-	// REFLECT event over the whole run.
-	const reflectNode = node(
-		[executeFlow.completed as Node<unknown>],
-		(_batchData, actions) => {
-			actions.emit(null);
-		},
-		{
-			name: "reflect",
-			equals: () => false,
-		},
-	);
-
-	// --- Optional priority scoring (Unit 19) ---
-	let priorityScores: Map<QueueRoute, Node<number>> | undefined;
-	if (opts.priority) {
-		priorityScores = buildPriorityScores(queueTopics, strategy, opts);
-	}
-
-	// --- Assemble HarnessGraph ---
-	const harness = new HarnessGraph<A>(
-		name,
-		queuesHub,
-		executeFlow,
-		queueTopics,
-		jobQueues,
-		gateControllers,
-		strategy,
-		totalRetries,
-		totalReingestions,
-		reflectNode as Node<null>,
-		priorityScores,
-	);
-
-	// Register disposers for unregistered internal nodes.
-	harness.addDisposer(routerUnsub);
-	harness.addDisposer(enqueueUnsub);
-	harness.addDisposer(dispatchUnsub);
-	// Strategy is mounted as a child subgraph below; its disposal cascades
-	// via the mount lifecycle (no separate `addDisposer(strategy.dispose)`
-	// needed post Class B audit Alt E migration).
-	for (const unsub of jobMirrorUnsubs) harness.addDisposer(unsub);
-
-	// Register stage nodes for introspection (harnessTrace, describe,
-	// observe). Tier 6.3: triage-input + router-input named so
-	// `explain(intake.latest, reflect)` walks named nodes end-to-end with
-	// no `<anonymous>` entries.
-	harness.add(triageInput as Node<unknown>, { name: "triage-input" });
-	harness.add(triageNode as Node<unknown>, { name: "triage" });
-	harness.add(routerInput as Node<unknown>, { name: "router-input" });
-	harness.add(executeInput as Node<unknown>, { name: "execute-input" });
-	harness.add(enqueueEffect as Node<unknown>, { name: "execute-enqueue" });
-	harness.add(dispatchEffect as Node<unknown>, { name: "verify-dispatch" });
-	harness.add(reflectNode as Node<unknown>, { name: "reflect" });
-	// Reflect is a topology marker — subscribe so its fn registers as a
-	// reactive edge visible in `describe()` / `explain()` immediately on
-	// harness construction.
-	harness.addDisposer(reflectNode.subscribe(() => undefined));
-	if (priorityScores) {
-		for (const [route, score] of priorityScores) {
-			harness.add(score as Node<unknown>, { name: `priority/${route}` });
-			harness.addDisposer(score.subscribe(() => {}));
-		}
-	}
-
-	// Mount subgraphs
-	harness.mount("queues", queuesHub);
-	harness.mount("gates", gateGraph);
-	harness.mount("executeFlow", executeFlow);
-	harness.mount("strategy", strategy);
-	for (const [route, jq] of jobQueues) {
-		harness.mount(`jobs/${route}`, jq);
-	}
-
-	// Tier 1.5.3 Phase 2.5 (DG1=B): tag the Graph with its constructing
-	// factory so `describe()` exposes provenance.
-	harness.tagFactory("harnessLoop", placeholderArgs(opts as unknown as Record<string, unknown>));
-
-	return harness;
-}
-
-// ---------------------------------------------------------------------------
-// Priority scoring wiring (Unit 19 decision 2)
-// ---------------------------------------------------------------------------
-
-function buildPriorityScores<A>(
-	queueTopics: Map<QueueRoute, TopicGraph<TriagedItem>>,
-	strategy: StrategyModelGraph,
-	opts: HarnessLoopOptions<A>,
-): Map<QueueRoute, Node<number>> {
-	if (!opts.lastInteractionNs) {
-		throw new Error(
-			"harnessLoop: `opts.priority` requires `opts.lastInteractionNs` — pass a Node<number> (e.g. `fromTimer(60_000)` or a `state(monotonicNs())` you bump on human interaction). Priority scores only decay when this node settles; an internal default would freeze age at construction time.",
-		);
-	}
-	const lastInteractionNs = opts.lastInteractionNs;
-	const signals = opts.priority ?? {};
-	const severityWeights = {
-		...DEFAULT_SEVERITY_WEIGHTS,
-		...signals.severityWeights,
-	} as Record<string, number>;
-	const decayRate = signals.decayRate ?? DEFAULT_DECAY_RATE;
-	const effectivenessThreshold = signals.effectivenessThreshold ?? 0.7;
-	const effectivenessBoost = signals.effectivenessBoost ?? 15;
-
-	const scores = new Map<QueueRoute, Node<number>>();
-	for (const [route, topic] of queueTopics) {
-		const score = node<number>(
-			[
-				topic.latest as Node<unknown>,
-				strategy.entries as Node<unknown>,
-				lastInteractionNs as Node<unknown>,
-			],
-			(batchData, actions, ctx) => {
-				const vals = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				const item = vals[0] as TriagedItem | undefined;
-				if (item === undefined) {
-					actions.emit(0);
-					return;
-				}
-				const baseWeight = severityWeights[item.severity ?? "medium"] ?? 40;
-				const ageSeconds = (monotonicNs() - (vals[2] as number)) / 1e9;
-				let s = baseWeight * Math.exp(-decayRate * Math.max(0, ageSeconds));
-				const key = strategyKey(DEFAULT_PRESET_ID, item.rootCause, item.intervention);
-				const strat = vals[1] as ReadonlyMap<string, { successRate: number }>;
-				const entry = strat?.get(key);
-				if (entry && entry.successRate >= effectivenessThreshold) {
-					s += effectivenessBoost;
-				}
-				actions.emit(s);
-			},
-			{ name: `priority/${route}`, describeKind: "derived" },
-		);
-		scores.set(route, score);
-	}
-	return scores;
-}
diff --git a/src/presets/harness/index.ts b/src/presets/harness/index.ts
deleted file mode 100644
index f46c97f4..00000000
--- a/src/presets/harness/index.ts
+++ /dev/null
@@ -1,15 +0,0 @@
-/**
- * Harness presets — opinionated compositions of harness + ai utils.
- *
- * @module
- */
-
-export * from "./actor-pool.js";
-export * from "./eval-verifier.js";
-export * from "./harness-loop.js";
-export * from "./ownership-controller.js";
-export * from "./profile.js";
-export * from "./refine-executor.js";
-export * from "./refine-loop.js";
-export * from "./spawnable.js";
-export * from "./trace.js";
diff --git a/src/presets/harness/ownership-controller.ts b/src/presets/harness/ownership-controller.ts
deleted file mode 100644
index e208ce3d..00000000
--- a/src/presets/harness/ownership-controller.ts
+++ /dev/null
@@ -1,396 +0,0 @@
-/**
- * `ownershipController()` — multi-agent subgraph ownership preset
- * (DS-14.5.A delta #8; L5/L6 + Q1–Q10).
- *
- * **Placement (documented choice).** Lives in `presets/harness/` alongside
- * the other multi-agent coordination presets (`spawnable()`, `actorPool()`).
- * Per the 4-layer rubric this is a ≥3-utils composition (messaging `topic` +
- * `derived` arbitration + Guard ABAC) wiring multi-agent coordination — the
- * same charter as `harness/`'s existing `spawnable`/`actorPool`. A separate
- * `presets/multi-agent/` directory was rejected to avoid fragmenting the
- * multi-agent presets across two folders for a single factory (L6: "recipe +
- * preset, NO new primitive").
- *
- * **What it is.** A `Graph` that owns a shared ownership `topic` (Q3 — one
- * topic carries claim / release / override; subscribers narrow by `kind`),
- * a reactive `current` derivation that folds the ownership log applying the
- * L0–L3 staircase, and a `guard` (`policyAllowing` — the Q7 reactive-options
- * Guard widening) the caller mounts on the owned subgraph. It **consumes the
- * existing DS-14 {@link OwnershipChange}** envelope — it does NOT redefine it.
- *
- * **Staircase (Q10 — `level` is a priority axis, NOT a mechanism enum):**
- * - **L1 TTL** — a `claim` carries a level; the controller's `ttl` (ms)
- *   bounds the live window. L1 honors TTL strictly (Q4): a crash inside the
- *   window does NOT early-release; recommend `ttl ≤ 60s`.
- * - **L2 heartbeat** — `heartbeat?: NodeInput<unknown>` (Q2). Any reactive
- *   trigger Node; each emission resets the countdown ("max tolerance since
- *   last sign of life", unified across L1/L2). No library timer is shipped
- *   and no `claim.heartbeat()` method exists (`feedback_no_imperative` +
- *   `feedback_no_imperative_wrap_as_primitive`).
- * - **L3 supervisor** — a `kind:"override"` change wins by `level` priority
- *   regardless of expiry/heartbeat (priority axis independent of the expiry
- *   axis). Supervisor publishes to the SAME topic (Q3).
- *
- * **No polling / no timer (spec §5.8/§5.9/§5.10).** Expiry is evaluated
- * reactively: `current` recomputes whenever the ownership topic OR the
- * heartbeat OR the optional `clock` trigger emits, folding the whole log
- * from scratch (idempotent — no carried mutable cursor). Auto-release on
- * wall-clock TTL requires the caller to wire a reactive `clock` tick
- * (`fromTimer({ ms })` or an activity-derived Node) — the library does not
- * own a timer (L6 / Q2). Without `clock`, expiry still resolves at the next
- * topic/heartbeat emission and on any read that recomputes the derivation.
- *
- * @module
- */
-
-import { type Node, type NodeGuard, policyAllowing, wallClockNs } from "@graphrefly/pure-ts/core";
-import type { NodeInput, OwnershipChange, OwnershipChangePayload } from "@graphrefly/pure-ts/extra";
-import { fromAny } from "@graphrefly/pure-ts/extra";
-import { Graph } from "@graphrefly/pure-ts/graph";
-import { type TopicGraph, topic } from "../../utils/messaging/index.js";
-
-/** Ownership level — priority axis (Q10). Higher rank = higher priority. */
-const LEVEL_RANK = { L0: 0, L1: 1, L2: 2, L3: 3 } as const;
-type OwnershipLevel = keyof typeof LEVEL_RANK;
-
-/** Options for {@link ownershipController}. */
-export type OwnershipControllerOptions = {
-	/**
-	 * TTL (milliseconds) bounding the live window of a claim. Honored
-	 * strictly (Q4) — a crash inside the window does not early-release.
-	 * Recommend ≤ 60_000 for L1 holds; wire `heartbeat` (L2) for longer.
-	 */
-	readonly ttl: number;
-	/**
-	 * L2 heartbeat (Q2). Any reactive trigger Node — each emission resets the
-	 * TTL countdown. Simple: `fromTimer({ ms: ttl / 3 })`. Activity-based:
-	 * `derived([toolCalls.events], …)`. Omitted → pure L1 TTL semantics.
-	 */
-	readonly heartbeat?: NodeInput<unknown>;
-	/**
-	 * L3 supervisor id. A `kind:"override"` change whose `actor` equals this
-	 * id wins by `level` priority regardless of expiry/heartbeat. Override
-	 * delivery is the shared topic with the `kind:"override"` discriminant
-	 * (Q3) — not a separate priority topic.
-	 */
-	readonly supervisor?: string;
-	/**
-	 * Optional reactive clock trigger used ONLY to re-evaluate TTL expiry
-	 * (e.g. `fromTimer({ ms: 1_000 })`). The library ships no timer (L6/Q2);
-	 * wire this for wall-clock-driven auto-release without an intervening
-	 * claim/heartbeat. Without it, expiry resolves lazily on the next
-	 * topic/heartbeat emission.
-	 */
-	readonly clock?: NodeInput<unknown>;
-	/** Bounded retention for the ownership topic (default 256). */
-	readonly retainedLimit?: number;
-};
-
-/**
- * Resolved ownership state emitted by {@link OwnershipControllerGraph.current}.
- * `owner` is `null` when unclaimed or the live claim has expired.
- */
-export type OwnershipState = {
-	readonly owner: string | null;
-	readonly level: OwnershipLevel | null;
-	/** Allow-set fed to the Guard. `[]` (deny-all) when `owner === null`. */
-	readonly allowed: readonly string[];
-	/**
-	 * Internal (F3/F4) — last sign-of-life (wall-clock ns) for the *current*
-	 * claim: `max(claim.sinceNs, last in-window heartbeat)`. Carried in the
-	 * derivation's OWN emitted state (read back via `ctx.prevData`) so the
-	 * fold is pure — same (folded log, beat-this-wave, now, prevState) →
-	 * same output. NEVER an instance field. `null` when unclaimed. Scoped to
-	 * the active claim: a value older than the active claim's `sinceNs` (a
-	 * prior owner's beat) is discarded so it cannot extend a new owner.
-	 */
-	readonly signOfLifeNs: number | null;
-};
-
-const EMPTY_STATE: OwnershipState = {
-	owner: null,
-	level: null,
-	allowed: [],
-	signOfLifeNs: null,
-};
-
-type ActiveOwner = { owner: string; level: OwnershipLevel; sinceNs: number };
-
-/**
- * Multi-agent subgraph ownership controller. See module docs.
- *
- * Public surface:
- * - `topic` — the shared ownership `TopicGraph<OwnershipChange>` (Q3).
- *   Agents publish claim/release/override here (use the `claim`/`release`/
- *   `override` helpers — thin reactive wrappers over `topic.publish`, i.e.
- *   message flow, NOT imperative triggers).
- * - `current` — `Node<OwnershipState>`: the reactively-resolved owner after
- *   applying L1 TTL + L2 heartbeat + L3 supervisor arbitration.
- * - `allowed` — `Node<readonly string[]>`: the Guard allow-set (derived from
- *   `current`); re-points on claim/release/override with no rewire.
- * - `guard` — `NodeGuard` from `policyAllowing(this.allowed)`. Mount on the
- *   owned subgraph's nodes (`node({ guard })`) for the Q7 hard-block.
- */
-export class OwnershipControllerGraph extends Graph {
-	readonly topic: TopicGraph<OwnershipChange>;
-	readonly current: Node<OwnershipState>;
-	readonly allowed: Node<readonly string[]>;
-	readonly guard: NodeGuard;
-
-	private readonly _ttlNs: number;
-	private readonly _supervisor: string | undefined;
-	/**
-	 * Whether a heartbeat `NodeInput` was supplied at construction (F14 —
-	 * `claim()`'s `level` default is `"L2"` when wired, else `"L1"`). NOT a
-	 * mutable accumulator — set once in the constructor, read-only after.
-	 */
-	private readonly _hasHeartbeat: boolean;
-
-	constructor(name: string, opts: OwnershipControllerOptions) {
-		super(name);
-		this._ttlNs = Math.max(0, opts.ttl) * 1_000_000;
-		this._supervisor = opts.supervisor;
-		this._hasHeartbeat = opts.heartbeat != null;
-
-		this.topic = topic<OwnershipChange>(`${name}__ownership`, {
-			retainedLimit: opts.retainedLimit ?? 256,
-		});
-		// The topic is its own TopicGraph; tear it down with this controller.
-		// (Not mounted — `topic.events` already belongs to the TopicGraph; a
-		// re-`add` would violate single-graph node ownership. Consumers
-		// inspect ownership via `current` / `allowed`, not via a mount.)
-		this.addDisposer(() => {
-			this.topic.destroy();
-		});
-
-		// `current` recomputes whenever the ownership stream changes, the
-		// heartbeat fires, or the optional clock ticks — the only sources
-		// that can change the resolved owner. ALL deps wired BEFORE any claim
-		// can be published (observers before emitters — §47 rule 2).
-		const deps: Node<unknown>[] = [this.topic.events as Node<unknown>];
-		const heartbeatIdx = opts.heartbeat != null ? deps.push(fromAny(opts.heartbeat)) - 1 : -1;
-		if (opts.clock != null) deps.push(fromAny(opts.clock) as Node<unknown>);
-
-		this.current = this.derived<OwnershipState>(
-			"currentOwner",
-			deps,
-			(batchData, ctx) => {
-				// Wall-clock (F2) — must match `makeChange`'s `t_ns` stamp so
-				// `nowNs - active.sinceNs` compares like-for-like. Mixing
-				// monotonic + wall clocks (the prior bug) made TTL math
-				// nonsense once the two clocks diverged.
-				const nowNs = wallClockNs();
-				// Did the heartbeat dep emit this wave? `batchData[i]` is the
-				// array of values dep `i` emitted THIS wave; a non-empty
-				// heartbeat batch is one or more beats.
-				const beatThisWave =
-					heartbeatIdx >= 0 &&
-					(() => {
-						const hb = batchData[heartbeatIdx] as readonly unknown[] | null | undefined;
-						return hb != null && hb.length > 0;
-					})();
-
-				// Fold the WHOLE ownership log from scratch (idempotent — the
-				// topic emits the full retained array, so a cursor would be a
-				// bug surface; pure reduction is correct and simple, §47).
-				// `batchData[0]` is `(readonly OwnershipChange[])[]` — the
-				// snapshots emitted this wave; take the latest (mirrors
-				// `topic.latest`'s `batch.at(-1)` pattern). On a SENTINEL
-				// first-activation wave fall back to `ctx.prevData[0]`.
-				const topoBatch = batchData[0] as
-					| readonly (readonly OwnershipChange[])[]
-					| null
-					| undefined;
-				const log = (
-					topoBatch != null && topoBatch.length > 0
-						? topoBatch[topoBatch.length - 1]
-						: (ctx.prevData[0] as readonly OwnershipChange[] | undefined)
-				) as readonly OwnershipChange[] | undefined;
-				let active: ActiveOwner | null = null;
-				if (log != null) {
-					for (const ch of log) {
-						if (ch?.change == null) continue;
-						active = applyChange(active, ch, this._supervisor);
-					}
-				}
-
-				// F3/F4 — PURE sign-of-life. Read the prior `signOfLifeNs`
-				// from THIS derivation's own previously-emitted state
-				// (`ctx.prevData[0]` for the `current` node is unavailable —
-				// `prevData[0]` is the topic dep — so we read `ctx.cache`,
-				// the node's own last emit). No instance field anywhere.
-				const prevState = (ctx.cache ?? undefined) as OwnershipState | undefined;
-
-				let nextActive: ActiveOwner | null = active;
-				let signOfLifeNs: number | null = null;
-
-				if (active != null && this._ttlNs > 0) {
-					// Carry the prior sign-of-life ONLY if it belongs to THIS
-					// claim (>= the active claim's `sinceNs`). A value from a
-					// prior owner (older than `sinceNs`) is discarded so a
-					// stale beat cannot extend a freshly-claimed window. A new
-					// owner therefore starts from its own claim time.
-					const carried =
-						prevState?.signOfLifeNs != null && prevState.signOfLifeNs >= active.sinceNs
-							? prevState.signOfLifeNs
-							: active.sinceNs;
-					// Expire FIRST against the carried sign-of-life (Q4 strict —
-					// a late beat must NOT resurrect an already-lapsed claim),
-					// THEN accept a still-timely beat THIS wave. `signOfLifeNs`
-					// only ever advances on an actual beat-this-wave, so a
-					// recompute storm with no beat cannot renew a dead claim
-					// (idempotent re-fold).
-					const lapsed = nowNs - carried >= this._ttlNs;
-					if (lapsed) {
-						nextActive = null;
-						signOfLifeNs = null;
-					} else if (beatThisWave) {
-						signOfLifeNs = nowNs; // timely beat → renew
-					} else {
-						signOfLifeNs = carried; // unchanged — carry forward
-					}
-				} else if (active != null) {
-					// No TTL configured — never expires; sign-of-life still
-					// tracked (owner-scoped) for completeness/observability.
-					const carried =
-						prevState?.signOfLifeNs != null && prevState.signOfLifeNs >= active.sinceNs
-							? prevState.signOfLifeNs
-							: active.sinceNs;
-					signOfLifeNs = beatThisWave ? nowNs : carried;
-				}
-
-				return [
-					nextActive == null
-						? EMPTY_STATE
-						: {
-								owner: nextActive.owner,
-								level: nextActive.level,
-								allowed: [nextActive.owner],
-								signOfLifeNs,
-							},
-				];
-			},
-			{ keepAlive: true },
-		);
-
-		this.allowed = this.derived<readonly string[]>(
-			"allowed",
-			[this.current],
-			(batchData, ctx) => {
-				const batch = batchData[0] as readonly OwnershipState[] | null | undefined;
-				const s = (batch != null && batch.length > 0 ? batch[batch.length - 1] : ctx.prevData[0]) as
-					| OwnershipState
-					| undefined;
-				return [s?.allowed ?? []];
-			},
-			{ keepAlive: true },
-		);
-		// F12 — `keepAlive: true` above already installs a self-pruning
-		// keepalive subscription (same as `current`); a second
-		// `keepalive(this.allowed)` disposer was redundant double-subscription.
-
-		// Q7 — the reactive-options Guard. `policyAllowing` reads
-		// `this.allowed.cache` synchronously at write-check time, so
-		// claim/release/override re-point the allow-set with NO rewire.
-		this.guard = policyAllowing(this.allowed);
-	}
-
-	/**
-	 * Publish a `claim`. Thin reactive wrapper over `topic.publish` (message
-	 * flow per §29 — NOT an imperative trigger). `level` defaults to `"L2"`
-	 * when this controller has a heartbeat wired, else `"L1"`.
-	 */
-	claim(actor: string, level?: OwnershipLevel): void {
-		// F14 — documented default (JSDoc + §47): L2 when a heartbeat
-		// NodeInput was wired at construction, else L1.
-		const lvl = level ?? (this._hasHeartbeat ? "L2" : "L1");
-		this.topic.publish(makeChange({ kind: "claim", subgraphId: this.name, actor, level: lvl }));
-	}
-
-	/** Publish a `release`. Clears ownership iff `actor` is the current owner. */
-	release(actor: string): void {
-		this.topic.publish(makeChange({ kind: "release", subgraphId: this.name, actor }));
-	}
-
-	/**
-	 * Publish a supervisor `override` (L3). Wins by `level` priority
-	 * regardless of expiry (Q10). `actor` should be this controller's
-	 * `supervisor` id for the override to take precedence.
-	 */
-	override(actor: string, previousActor: string, reason: string): void {
-		this.topic.publish(
-			makeChange({ kind: "override", subgraphId: this.name, actor, previousActor, reason }),
-		);
-	}
-}
-
-/** Wrap an {@link OwnershipChangePayload} in the DS-14 {@link OwnershipChange} envelope. */
-function makeChange(payload: OwnershipChangePayload): OwnershipChange {
-	// F2 — `BaseChange.t_ns` is contractually wall-clock (`wallClockNs()`,
-	// see change.ts). The fold compares `nowNs (wallClockNs)` against
-	// `ch.t_ns` for TTL/expiry, so stamp + compare MUST use the same clock.
-	const t = wallClockNs();
-	return { structure: "ownership", version: t, t_ns: t, lifecycle: "ownership", change: payload };
-}
-
-/**
- * Fold one ownership change into the resolved-owner state.
- *
- * - `claim` — sets the active owner (records claim time for L1 TTL). A
- *   lower-priority claim cannot displace a higher-`level` live owner (Q10 —
- *   override arbitration is pure level comparison).
- * - `release` — clears ownership iff the releasing actor is the owner.
- * - `override` — supervisor override: wins by `level` priority. Carries
- *   `previousActor` + `reason` per DS-14 (Q3); modeled as an L3 hand-off to
- *   `p.actor`.
- */
-function applyChange(
-	active: ActiveOwner | null,
-	ch: OwnershipChange,
-	supervisor: string | undefined,
-): ActiveOwner | null {
-	const p = ch.change;
-	// Use the change's publish timestamp (`t_ns` — wall-clock, stamped in
-	// `makeChange`) as the claim time — NOT the fold time. The log is re-folded
-	// from scratch on every recompute (§47), so stamping a fresh clock read
-	// here would re-baseline the TTL window every recompute and the claim would
-	// never expire. The fold compares against `wallClockNs()` (F2 — same clock).
-	if (p.kind === "claim") {
-		if (active != null && LEVEL_RANK[active.level] > LEVEL_RANK[p.level]) return active;
-		return { owner: p.actor, level: p.level, sinceNs: ch.t_ns };
-	}
-	if (p.kind === "release") {
-		if (active != null && active.owner === p.actor) return null;
-		return active;
-	}
-	// override (F5) — a `kind:"override"` only seizes ownership when the
-	// publishing actor IS the configured supervisor. The prior disjunction
-	// `|| LEVEL_RANK.L3 >= LEVEL_RANK[active.level]` was a tautology (L3 is the
-	// max rank ⇒ always true), so ANY actor's override took over. If no
-	// supervisor is configured, overrides are explicitly disabled (a non-null
-	// `supervisor` is the gate, not an accidental fall-through).
-	const isSupervisor = supervisor != null && p.actor === supervisor;
-	if (isSupervisor) {
-		return { owner: p.actor, level: "L3", sinceNs: ch.t_ns };
-	}
-	return active;
-}
-
-/**
- * Create a multi-agent subgraph ownership controller (DS-14.5.A #8).
- *
- * @example
- * ```ts
- * const oc = ownershipController("payments", { ttl: 30_000, supervisor: "lead" });
- * // Mount the Guard on the owned subgraph:
- * const n = node([], { initial: 0, guard: oc.guard });
- * oc.claim("agent-a");                 // agent-a now owns; non-owner writes throw
- * oc.override("lead", "agent-a", "rebalance"); // supervisor takes over
- * ```
- */
-export function ownershipController(
-	name: string,
-	opts: OwnershipControllerOptions,
-): OwnershipControllerGraph {
-	return new OwnershipControllerGraph(name, opts);
-}
diff --git a/src/presets/harness/profile.ts b/src/presets/harness/profile.ts
deleted file mode 100644
index 4c3cd271..00000000
--- a/src/presets/harness/profile.ts
+++ /dev/null
@@ -1,75 +0,0 @@
-/**
- * Harness-specific graph profiling (roadmap §9.0).
- *
- * Extends {@link graphProfile} with harness domain counters:
- * queue depths, strategy entries, retry/reingestion tracker sizes.
- *
- * @module
- */
-
-import {
-	type GraphProfileOptions,
-	type GraphProfileResult,
-	graphProfile,
-} from "@graphrefly/pure-ts/graph";
-import { QUEUE_NAMES } from "../../utils/harness/defaults.js";
-import type { QueueRoute, TriagedItem } from "../../utils/harness/types.js";
-import type { HarnessGraph } from "./harness-loop.js";
-
-// ---------------------------------------------------------------------------
-// Types
-// ---------------------------------------------------------------------------
-
-/** Harness-specific profile extending the base graph profile. */
-export interface HarnessProfileResult extends GraphProfileResult {
-	/** Per-queue retained item counts. */
-	queueDepths: Record<QueueRoute, number>;
-	/** Number of rootCause→intervention entries in the strategy model. */
-	strategyEntries: number;
-	/** Global retry count across all items. */
-	totalRetries: number;
-	/** Global reingestion count across all items. */
-	totalReingestions: number;
-}
-
-// ---------------------------------------------------------------------------
-// Implementation
-// ---------------------------------------------------------------------------
-
-/**
- * Profile a harness graph with domain-specific counters.
- *
- * **Snapshot caveat (Unit 22 B).** Reads `.cache` values from the
- * strategy / retry / reingestion nodes + each queue topic's `.retained()`
- * view. These are point-in-time reads and are not transactional — if you
- * invoke this during an in-flight reactive wave the values may reflect
- * a partially-settled frame. For end-of-wave accuracy, call from outside
- * any batch boundary.
- *
- * @param harness - The HarnessGraph to profile.
- * @param opts - Optional base profile options.
- * @returns Harness profile with queue depths, strategy stats, and tracker sizes.
- */
-export function harnessProfile(
-	harness: HarnessGraph,
-	opts?: GraphProfileOptions,
-): HarnessProfileResult {
-	const base = graphProfile(harness, opts);
-
-	// Unit 22 B: iterate the hub's topic registry instead of a raw Map so
-	// queue topics added post-construction (dead-letter `__unrouted`, etc.)
-	// don't get silently ignored.
-	const queueDepths: Record<string, number> = {};
-	for (const route of QUEUE_NAMES) {
-		const t = harness.queues.has(route) ? harness.queues.topic<TriagedItem>(route) : null;
-		queueDepths[route] = t?.retained().length ?? 0;
-	}
-
-	return {
-		...base,
-		queueDepths: queueDepths as Record<QueueRoute, number>,
-		strategyEntries: harness.strategy.entries.cache?.size ?? 0,
-		totalRetries: harness.totalRetries.cache ?? 0,
-		totalReingestions: harness.totalReingestions.cache ?? 0,
-	};
-}
diff --git a/src/presets/harness/refine-executor.ts b/src/presets/harness/refine-executor.ts
deleted file mode 100644
index 992c1ecd..00000000
--- a/src/presets/harness/refine-executor.ts
+++ /dev/null
@@ -1,171 +0,0 @@
-/**
- * refineExecutor — bridge a `refineLoop` into the harness EXECUTE work fn.
- *
- * Each claimed job mounts a fresh `refineLoop`; when the loop reaches a
- * terminal status (`converged` / `budget` / `errored`), the work fn emits a
- * single {@link HarnessJobPayload} with `execution` filled in. The JobFlow
- * pump subscribes once, takes the first DATA, then unsubscribes — so the
- * inner loop tears down cleanly when the harness acks the job.
- *
- * **C2 lifecycle (Tier 6.5).** The work fn is invoked once per claim, so
- * no internal `switchMap` is needed (the prior pre-C2 shape used switchMap
- * to handle a stream of items). The pump owns the per-claim lifecycle:
- * activation when the work fn returns, teardown when the result Node is
- * unsubscribed.
- *
- * **Cross-item learning:** a fresh refineLoop per item means
- * `errorCritique`-style failure sampling does NOT accumulate across items
- * sharing a `rootCause`. A persistent-loop + re-seed surface is filed in
- * `docs/optimizations.md` as a long-term follow-up.
- *
- * @module
- */
-
-import { node } from "@graphrefly/pure-ts/core";
-import { filter } from "@graphrefly/pure-ts/extra";
-import type {
-	ExecuteOutput,
-	HarnessExecutor,
-	HarnessJobPayload,
-	TriagedItem,
-} from "../../utils/harness/types.js";
-import type { JobEnvelope } from "../../utils/job-queue/index.js";
-import {
-	type DatasetItem,
-	type Evaluator,
-	type RefineLoopOptions,
-	type RefineStatus,
-	type RefineStrategy,
-	refineLoop,
-} from "./refine-loop.js";
-
-/** Terminal-run snapshot passed to a custom `toOutput` mapper. */
-export interface RefineExecutorResult<T> {
-	/**
-	 * Best candidate the inner loop converged on. `undefined` (SENTINEL) if the
-	 * inner loop never produced a best — e.g. it `errored` before any iteration
-	 * settled. (`loop.best` is a SENTINEL `Node<T>` post the 2026-05-18
-	 * anti-pattern sweep — no `null` placeholder.)
-	 */
-	readonly best: T | undefined;
-	/** Aggregate score at termination. `-Infinity` if the batch was empty. */
-	readonly score: number;
-	/** Reason the loop terminated. */
-	readonly status: RefineStatus;
-}
-
-/** Configuration for {@link refineExecutor}. */
-export interface RefineExecutorConfig<T> {
-	/** Map a triaged item to the seed candidate (e.g. a catalog entry, prompt, patch). */
-	seedFrom: (item: TriagedItem) => T;
-
-	/** Reactive evaluator — same shape as passed to `refineLoop`. */
-	evaluator: Evaluator<T>;
-
-	/** Strategy (e.g. `errorCritique(teacher)`). Applied to every item's inner loop. */
-	strategy: RefineStrategy<T>;
-
-	/** Map a triaged item to the dataset rows the evaluator should score against. */
-	datasetFor: (item: TriagedItem) => readonly DatasetItem[];
-
-	/**
-	 * Optional mapper from the inner loop's terminal snapshot to an
-	 * `ExecuteOutput<T>`. Default: converged→success, budget→partial,
-	 * errored→failure.
-	 */
-	toOutput?: (result: RefineExecutorResult<T>) => ExecuteOutput<T>;
-
-	/** Convergence / budget options forwarded to each inner `refineLoop`. */
-	refine?: Omit<RefineLoopOptions, "dataset" | "name">;
-
-	/** Node name prefix for introspection. Default `"refine-executor"`. */
-	name?: string;
-}
-
-function defaultToOutput<T>(result: RefineExecutorResult<T>): ExecuteOutput<T> {
-	const { best, score, status } = result;
-	const scoreStr = Number.isFinite(score) ? score.toFixed(3) : String(score);
-	const artifact: T | undefined = best;
-	if (status === "converged") {
-		return {
-			outcome: "success",
-			detail: `refineLoop converged at score ${scoreStr}`,
-			artifact,
-		};
-	}
-	if (status === "budget") {
-		return {
-			outcome: "partial",
-			detail: `refineLoop hit budget at score ${scoreStr}`,
-			artifact,
-		};
-	}
-	return {
-		outcome: "failure",
-		detail: `refineLoop errored (status=${status})`,
-		artifact,
-	};
-}
-
-/**
- * Build a {@link HarnessExecutor} backed by a `refineLoop` per claimed
- * job.
- *
- * @example Eval-driven repair loop in the harness EXECUTE slot.
- * ```ts
- * const harness = harnessLoop("repair", {
- *   adapter,
- *   executor: refineExecutor({
- *     seedFrom: (item) => initialCatalogEntry(item),
- *     datasetFor: (item) => pickAffectedTasks(item, allTasks),
- *     evaluator: (cands, tasks) => runEvalBatch(cands, tasks),
- *     strategy: errorCritique({ teacher, width: 3 }),
- *     refine: { maxIterations: 5, minScore: 0.9 },
- *   }),
- * });
- * ```
- */
-export function refineExecutor<T>(config: RefineExecutorConfig<T>): HarnessExecutor<T> {
-	const name = config.name ?? "refine-executor";
-	const toOutput = config.toOutput ?? defaultToOutput<T>;
-
-	return (job: JobEnvelope<HarnessJobPayload<T>>) => {
-		const item = job.payload.item;
-		const loop = refineLoop<T>(config.seedFrom(item), config.evaluator, config.strategy, {
-			...config.refine,
-			dataset: config.datasetFor(item),
-			name: `${name}/inner`,
-		});
-		// Terminal-allowlist guard — emit non-null only on `converged` / `budget` /
-		// `errored`; intermediate `running` waves emit `null` (deduped via the
-		// node's default Object.is). The trailing `filter(v != null)` strips
-		// the null DATA so the JobFlow pump's first-DATA capture sees the
-		// terminal payload, not the intermediate null.
-		const raw = node<HarnessJobPayload<T> | null>(
-			[loop.status, loop.best, loop._score],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				const s = data[0] as RefineStatus;
-				if (s !== "converged" && s !== "budget" && s !== "errored") {
-					actions.emit(null);
-					return;
-				}
-				const exec = toOutput({
-					best: data[1] as T | undefined,
-					score: data[2] as number,
-					status: s,
-				});
-				actions.emit({
-					...job.payload,
-					execution: { item, ...exec },
-				});
-			},
-			{ name: `${name}/output`, describeKind: "derived" },
-		);
-		return filter(raw, (v) => v != null, { name: `${name}/gate-out` }) as ReturnType<
-			HarnessExecutor<T>
-		>;
-	};
-}
diff --git a/src/presets/harness/refine-loop.ts b/src/presets/harness/refine-loop.ts
deleted file mode 100644
index 75336d38..00000000
--- a/src/presets/harness/refine-loop.ts
+++ /dev/null
@@ -1,1526 +0,0 @@
-/**
- * refineLoop — universal prompt/artifact optimization loop as a reactive Graph.
- *
- * Roadmap §9.8 (Wave 2.5). The loop is a 4-topic reactive pipeline:
- *
- *   iterationTrigger ──▶ GENERATE ──▶ EVALUATE ──▶ ANALYZE ──▶ DECIDE
- *                            │                                   │
- *                            └───────  feedback + trigger  ◀─────┘
- *
- * Each stage is a `TopicGraph` so dispatches stay O(1) per subscriber (cursor-
- * based) and every iteration is observable, replayable, and checkpointable.
- *
- * Composition invariants (from COMPOSITION-GUIDE):
- *  - §7 feedback cycle: only `iterationTrigger` drives re-generation. Strategy
- *    + feedback + dataset are read via closure updaters (§28 factory-time seed)
- *    so mid-run swaps apply to the NEXT iteration, never retrigger the current.
- *  - §28 factory-time seed: strategy, lastFeedback, prevCandidates, dataset
- *    closures captured at wiring time + updated via subscribe handlers so the
- *    first activation doesn't drop the initial pair.
- *  - §32 nested-drain state-mirror: the decide-effect writes `lastFeedback`
- *    BEFORE bumping `iterationTrigger` inside its `batch()`, guaranteeing the
- *    mirror is current when the next-iteration wave reaches the generate fn.
- *  - §19 terminal-emission: history / best emit once per iteration (settled),
- *    not on every intermediate wave.
- *  - §27 attachSnapshotStorage: the whole graph is checkpointable — pause overnight,
- *    resume tomorrow from the exact iteration count, candidate set, strategy.
- *
- * Scope clamp (v1): core factory + `RefineStrategy<T>` + `blindVariation` and
- * `errorCritique` built-ins + budget gating + checkpoint/resume.
- * `mutateAndRefine` / registry / `autoSelectStrategy` / `optimizeCatalog` /
- * `refineExecutor` are deferred.
- *
- * @module
- */
-
-// `createNode` is the local alias for `node` so calls don't shadow
-// `Graph.prototype.node` when the file's body inadvertently references the
-// graph's `.node()` method. B5f keeps protocol-primitive construction visually
-// distinct from graph-instance method dispatch.
-import {
-	batch,
-	node as createNode,
-	DATA,
-	ERROR,
-	monotonicNs,
-	type Node,
-	placeholderArgs,
-	RESOLVED,
-} from "@graphrefly/pure-ts/core";
-import type { NodeInput } from "@graphrefly/pure-ts/extra";
-import { switchMap } from "@graphrefly/pure-ts/extra";
-import { Graph, type GraphOptions } from "@graphrefly/pure-ts/graph";
-import { tryIncrementBounded } from "../../base/mutation/index.js";
-import { messagingHub, type TopicGraph } from "../../utils/messaging/index.js";
-
-// ---------------------------------------------------------------------------
-// Core types
-// ---------------------------------------------------------------------------
-
-/** A single task row — the unit the evaluator scores one candidate against. */
-export interface DatasetItem {
-	readonly id: string;
-	readonly [k: string]: unknown;
-}
-
-/**
- * One candidate's score on one task. Higher is better by convention.
- *
- * Set `candidateIndex` when the evaluator fans out scores across multiple
- * candidates (e.g. `candidates × tasks`). `pickBest` aggregates mean scores
- * per `candidateIndex` when present; when absent, falls back to positional
- * alignment (`scores[i]` ↔ `candidates[i]`).
- */
-export interface EvalResult {
-	readonly taskId: string;
-	readonly score: number;
-	readonly error?: string;
-	readonly detail?: unknown;
-	/** 0-based index into the `candidates` batch this score belongs to. */
-	readonly candidateIndex?: number;
-}
-
-/** Aggregated feedback the strategy produces from a scores batch. */
-export interface Feedback {
-	readonly summary: string;
-	readonly critique?: unknown;
-	readonly weakTasks?: readonly string[];
-	readonly score: number;
-}
-
-/**
- * Strategy interface — plain object, no base class. Strategies implement three
- * pure hooks; the loop infrastructure wraps them in reactive nodes so every
- * decision is visible in `describe()`.
- *
- * `generate` may be sync or async. Async generates yield a microtask per
- * iteration — that's what gives `pause()` / `setStrategy()` a window to
- * interleave. **A fully synchronous `generate` will drain the entire loop
- * during factory activation** (all iterations run before `refineLoop()`
- * returns), which is usually not what you want for observable, steerable
- * loops. Real strategies that call LLMs / evals are async and Just Work;
- * custom sync strategies for tests are fine but should be marked `async`
- * to match real cadence.
- */
-export interface RefineStrategy<T> {
-	readonly name: string;
-	/** Produce initial candidates from the seed. Called at iteration 0. */
-	seed(seed: T): readonly T[];
-	/** Reduce scores to feedback. Pure function. */
-	analyze(scores: readonly EvalResult[], candidates: readonly T[]): Feedback;
-	/**
-	 * Generate next-iteration candidates from feedback + prior candidates.
-	 * Async allowed — the loop awaits via `fromAny`.
-	 */
-	generate(feedback: Feedback, candidates: readonly T[]): Promise<readonly T[]> | readonly T[];
-}
-
-/**
- * Evaluator shape — Shape 4 (2026-04-22): both `candidates` and `dataset` are
- * reactive nodes; the evaluator's returned node IS the EVALUATE topic's source
- * (no glue). Implementers can batch-eval (e.g. `funnel` with concurrency) or
- * map per-candidate — user's code.
- *
- * **Cancel-on-input contract (load-bearing).** Evaluators with async work
- * (LLM calls, network requests, etc.) MUST cancel any in-flight work when
- * `candidates` emits a new batch. The canonical pattern is `switchMap` over
- * `candidates`. If an evaluator does NOT cancel — e.g. naively kicks a
- * `Promise.all` per-batch and emits whatever resolves — late scores from a
- * prior iteration can arrive after the loop has already moved to the next
- * iteration (especially after `pause()` / `resume()`). Such stale scores
- * trip {@link refineLoop}'s `feedbackEnvelopeNode` with mismatched
- * `iter`/`scores`/`items`, producing an incorrect `DecideEvent` and (worse)
- * marking the iter as decided so the real iter's scores get skipped by
- * de-dup, stalling the loop. See `optimizations.md` "refineLoop async-
- * evaluator stale-scores follow-up" for the proposed `wrapEvaluator()`
- * helper that would enforce cancellation.
- *
- * **`EvalResult.candidateIndex` semantics.** Optional per-result field.
- * When present, multi-candidate aggregators ({@link errorCritique}'s
- * `pickBest`) score per index, picking the candidate with the highest
- * mean score. When absent across all results, those aggregators fall back
- * to positional matching against `candidates[0]` — meaning a strategy that
- * generates >1 candidate but emits unindexed scores effectively only ever
- * critiques the first candidate. Set `candidateIndex` whenever the
- * evaluator's score corresponds to a specific candidate in the batch.
- */
-export type Evaluator<T> = (
-	candidates: Node<readonly T[]>,
-	dataset: Node<readonly DatasetItem[]>,
-) => Node<readonly EvalResult[]>;
-
-// ---------------------------------------------------------------------------
-// Convergence
-// ---------------------------------------------------------------------------
-
-/**
- * Early-stop controls. Each field fans into its own derived node; the four
- * combine via `||` into `converged: Node<boolean>`. Callers see exactly
- * which rule tripped via `status` / the DECIDE topic's `reason`.
- */
-export interface ConvergenceOptions {
-	/** Stop when aggregate score has not improved for N iterations. */
-	patience?: number;
-	/** Stop when aggregate score reaches or exceeds this. */
-	minScore?: number;
-	/** Stop when absolute delta between consecutive scores falls below this. */
-	minDelta?: number;
-	/** Stop after N total evaluations (iteration count × per-iter candidates). */
-	maxEvaluations?: number;
-	/** Stop after N iterations. Always set a finite bound in production. */
-	maxIterations?: number;
-}
-
-// ---------------------------------------------------------------------------
-// Topic payloads (one per stage)
-// ---------------------------------------------------------------------------
-
-/** Emitted to the GENERATE topic each time the strategy produces a batch. */
-export interface GenerateEvent<T> {
-	readonly iteration: number;
-	readonly candidates: readonly T[];
-	readonly timestamp_ns: number;
-}
-
-/** Emitted to the EVALUATE topic when scores settle for an iteration. */
-export interface EvaluateEvent<T> {
-	readonly iteration: number;
-	readonly candidates: readonly T[];
-	readonly scores: readonly EvalResult[];
-	readonly timestamp_ns: number;
-}
-
-/** Emitted to the ANALYZE topic — strategy's reduction over scores. */
-export interface AnalyzeEvent<T> {
-	readonly iteration: number;
-	readonly candidates: readonly T[];
-	readonly feedback: Feedback;
-	readonly timestamp_ns: number;
-}
-
-/** Emitted to the DECIDE topic — branch taken this iteration. */
-export interface DecideEvent {
-	readonly iteration: number;
-	readonly decision: "continue" | "converged" | "budget" | "paused";
-	readonly reason?: string;
-	readonly timestamp_ns: number;
-}
-
-// ---------------------------------------------------------------------------
-// Status + history
-// ---------------------------------------------------------------------------
-
-export type RefineStatus = "running" | "converged" | "budget" | "paused" | "errored";
-
-/**
- * **Internal envelope** — carries the iteration number alongside the
- * candidates batch so `iter` rides the data wave through the pipeline. Lets
- * downstream stages read iter from a real reactive edge instead of from
- * `iterationTrigger.cache` (P3 violation; see /qa D1, 2026-05-01).
- *
- * Sidecar `candidatesItemsNode = derived([candidatesNode], ([env]) => env.items)`
- * preserves the user-facing `Evaluator<T>` API (which sees `Node<readonly T[]>`).
- */
-interface CandidatesEnvelope<T> {
-	readonly iter: number;
-	readonly items: readonly T[];
-}
-
-/**
- * **Internal envelope** — assembled by `feedbackEnvelopeNode` from
- * `userScoresNode` + `candidatesNode`. Carries iter + items + scores +
- * feedback together as the trigger payload for `decideEffect` (`§16` nested
- * `withLatestFrom` advisory-samples history / budget / pause). Lets
- * `decideEffect` read iter from the envelope (no `iterationTrigger.cache` read)
- * AND ensures decideEffect only fires when the user evaluator has actually
- * emitted fresh scores (gate via `batchData[scores]` length, eliminating
- * spurious decides on candidates-only fan-out waves).
- */
-interface FeedbackEnvelope<T> {
-	readonly iter: number;
-	readonly items: readonly T[];
-	readonly scores: readonly EvalResult[];
-	readonly feedback: Feedback;
-}
-
-export interface Iteration<T> {
-	readonly n: number;
-	readonly candidates: readonly T[];
-	readonly scores: readonly EvalResult[];
-	readonly feedback: Feedback;
-	/** `null` iff the candidate batch for this iteration was empty. */
-	readonly best: T | null;
-	readonly bestScore: number;
-	readonly timestamp_ns: number;
-}
-
-// ---------------------------------------------------------------------------
-// Factory + returned graph
-// ---------------------------------------------------------------------------
-
-export interface RefineLoopOptions extends ConvergenceOptions {
-	/** Reactive dataset OR a plain array (auto-wrapped into `state`). */
-	dataset: NodeInput<readonly DatasetItem[]> | readonly DatasetItem[];
-	/** Total teacher calls cap across iterations. Default: unlimited. */
-	budget?: number;
-	/** Graph name. Default: `"refine-loop"`. */
-	name?: string;
-	/** Extra graph options forwarded to the underlying `Graph`. */
-	graph?: GraphOptions;
-}
-
-/**
- * `class RefineLoopGraph<T> extends Graph` — the universal prompt/artifact
- * optimization loop as a reactive Graph subclass.
- *
- * Constructed via the {@link refineLoop} factory in normal use; exported as a
- * class so consumers can `instanceof`-narrow on returned values (Phase 13.G
- * `agent(spec)` is the consumer that motivated the migration). All
- * observability tools (`describe`, `explain`, `observe`, `attachSnapshotStorage`,
- * `snapshot`) Just Work since this `extends Graph`.
- *
- * **Phase 12.D (2026-04-30):** Migrated from `Object.assign(graph, ...)` factory
- * pattern to `class extends Graph` (Tier R5.1 deferral lifted; mirrors the
- * `MemoryWith*Graph` precedent). `setStrategy` / `pause` / `resume` are now
- * instance methods that read `this.strategy` / `this._pauseState` / `this.status`
- * / `this._iteration` instead of factory-local closures.
- */
-export class RefineLoopGraph<T> extends Graph {
-	/**
-	 * Best candidate so far. **SENTINEL until the first iteration settles** —
-	 * `loop.best.cache` is `undefined` (not `null`) before any iteration
-	 * produces a best, and a degenerate empty-candidate iteration leaves the
-	 * prior best in place rather than wiping it. Consumers guard with
-	 * `=== undefined` (spec §3 SENTINEL), not `== null`. (Anti-pattern sweep
-	 * 2026-05-18: dropped the `initial: null` eager-placeholder; `null` is
-	 * reserved for the per-iteration {@link Iteration.best} data field where an
-	 * empty batch is a valid domain value.)
-	 */
-	readonly best: Node<T>;
-	/**
-	 * Best score so far. Pseudo-private (`_score`) to avoid colliding with any
-	 * future `Graph.prototype.score` method (B5d forward-compat hazard
-	 * prevention). Typed-public — read via `loop._score.cache` /
-	 * `loop._score.subscribe(...)` from external code.
-	 */
-	readonly _score: Node<number>;
-	readonly status: Node<RefineStatus>;
-	readonly history: Node<readonly Iteration<T>[]>;
-	readonly strategy: Node<RefineStrategy<T>>;
-	/**
-	 * Monotonic iteration counter. Pseudo-private (`_iteration`) to avoid
-	 * colliding with any future `Graph.prototype.iteration` method (B5d
-	 * forward-compat hazard prevention). Typed-public — read via
-	 * `loop._iteration.cache` / `loop._iteration.subscribe(...)`.
-	 */
-	readonly _iteration: Node<number>;
-	/** Stage topic — subscribe for per-stage streaming / cursor consumers. */
-	readonly generate: TopicGraph<GenerateEvent<T>>;
-	/** Stage topic — subscribe for per-stage streaming / cursor consumers. */
-	readonly evaluate: TopicGraph<EvaluateEvent<T>>;
-	/** Stage topic — subscribe for per-stage streaming / cursor consumers. */
-	readonly analyze: TopicGraph<AnalyzeEvent<T>>;
-	/** Stage topic — subscribe for per-stage streaming / cursor consumers. */
-	readonly decide: TopicGraph<DecideEvent>;
-
-	/** Internal: paused-flag node. Mounted as "paused" in describe(). */
-	private readonly _pauseState: Node<boolean>;
-
-	constructor(
-		seed: T,
-		evaluator: Evaluator<T>,
-		initialStrategy: RefineStrategy<T>,
-		opts: RefineLoopOptions,
-	) {
-		const name = opts.name ?? "refine-loop";
-		super(name, opts.graph);
-
-		// /qa A2 (2026-04-30): tag the Graph with its constructing factory so
-		// `describe()` / `compileSpec` round-trip surfaces provenance — mirrors
-		// the `agentMemory` pattern. `seed` / `evaluator` / `initialStrategy`
-		// and option fields are non-JSON (functions, strategies); route through
-		// `placeholderArgs` (DG2=ii) which substitutes `"<function>"` /
-		// `"<Node>"` / `"<unserializable>"` for non-JSON values.
-		this.tagFactory(
-			"refineLoop",
-			placeholderArgs({ seed, evaluator, initialStrategy, ...opts } as unknown as Record<
-				string,
-				unknown
-			>),
-		);
-
-		// --- Dataset: auto-wrap arrays into a state node ------------------------
-		const datasetNode: Node<readonly DatasetItem[]> = isNode<readonly DatasetItem[]>(opts.dataset)
-			? opts.dataset
-			: createNode<readonly DatasetItem[]>([], {
-					name: "dataset",
-					initial: opts.dataset as readonly DatasetItem[],
-				});
-		this.add(datasetNode, { name: "dataset" });
-
-		// --- State nodes --------------------------------------------------------
-		const iterationTrigger = createNode<number>([], { name: "iteration", initial: 0 });
-		this.add(iterationTrigger, { name: "iteration" });
-
-		const strategyNode = createNode<RefineStrategy<T>>([], {
-			name: "strategy",
-			initial: initialStrategy,
-			equals: () => false, // always propagate strategy swaps
-		});
-		this.add(strategyNode, { name: "strategy" });
-
-		// SENTINEL until the first iteration mirrors feedback (anti-pattern
-		// sweep 2026-05-18 — dropped the `initial: null` eager-placeholder that
-		// pushed `[null]` to every fresh subscriber). Only ever carries a real
-		// `Feedback` (the decide-effect mirror at the bottom always emits a
-		// concrete `fb`), so SENTINEL-before-first cleanly means "no iteration
-		// has completed yet" rather than a spurious `null` DATA.
-		const lastFeedbackState = createNode<Feedback>([], {
-			name: "lastFeedback",
-		});
-		this.add(lastFeedbackState, { name: "lastFeedback" });
-
-		const prevCandidatesState = createNode<readonly T[]>([], {
-			name: "prevCandidates",
-			initial: [],
-		});
-		this.add(prevCandidatesState, { name: "prevCandidates" });
-
-		const pauseState = createNode<boolean>([], { name: "paused", initial: false });
-		this.add(pauseState, { name: "paused" });
-
-		const statusState = createNode<RefineStatus>([], { name: "status", initial: "running" });
-		this.add(statusState, { name: "status" });
-
-		const historyState = createNode<readonly Iteration<T>[]>([], {
-			name: "history",
-			initial: [],
-			equals: () => false, // append-style; reactive consumers want every push
-		});
-		this.add(historyState, { name: "history" });
-
-		// SENTINEL until the first iteration produces a best (anti-pattern
-		// sweep 2026-05-18). Never carries `null`: the decide-effect skips the
-		// emit when `pickBest` yields no best, so a degenerate empty-candidate
-		// iteration preserves the prior best instead of wiping it to `null`.
-		const bestState = createNode<T>([], { name: "best" });
-		this.add(bestState, { name: "best" });
-
-		const scoreState = createNode<number>([], { name: "score", initial: Number.NEGATIVE_INFINITY });
-		this.add(scoreState, { name: "score" });
-
-		// --- Budget counter -----------------------------------------------------
-		const budgetState = createNode<number>([], { name: "budget-used", initial: 0 });
-		this.add(budgetState, { name: "budget-used" });
-
-		// --- Stage hub (Shape B + C-aspects) ------------------------------------
-		// One messagingHub instead of four standalone TopicGraphs. Topics are
-		// eagerly created so the public accessors (loop.generate etc.) are
-		// available immediately without waiting for the first event to fire.
-		// The hub is mounted in this so all stage topics appear under "stages::"
-		// in describe()/explain() — visible edges, not closure-held singletons.
-		const hub = messagingHub("stages");
-		this.mount("stages", hub);
-		const hubGenerateTopic = hub.topic<GenerateEvent<T>>("generate");
-		const hubEvaluateTopic = hub.topic<EvaluateEvent<T>>("evaluate");
-		const hubAnalyzeTopic = hub.topic<AnalyzeEvent<T>>("analyze");
-		const hubDecideTopic = hub.topic<DecideEvent>("decide");
-
-		// /qa A1 (2026-04-30): assign the public field surface BEFORE wiring
-		// any effect / subscribe activation below. A synchronous strategy can
-		// drain the entire GENERATE → EVALUATE → ANALYZE → DECIDE cascade
-		// during the constructor body (see strategy doc above); fields must be
-		// reachable in case any future subscribe handler dereferences `this.X`
-		// during that synchronous drain. Defensive — no current handler reads
-		// `this.<field>`, but keeping construction-order safe avoids future
-		// undefined-field crashes.
-		this.best = bestState;
-		this._score = scoreState;
-		this.status = statusState;
-		this.history = historyState;
-		this.strategy = strategyNode;
-		this._iteration = iterationTrigger;
-		this.generate = hubGenerateTopic;
-		this.evaluate = hubEvaluateTopic;
-		this.analyze = hubAnalyzeTopic;
-		this.decide = hubDecideTopic;
-		this._pauseState = pauseState;
-
-		// --- Factory-time seed closures (§28) -----------------------------------
-		// These mirror the reactive dep values so the generate fn can read them
-		// without the multi-dep push-on-subscribe initial-pair drop. Per
-		// COMPOSITION-GUIDE-PROTOCOL.md §28: "The closure reads inside the
-		// reactive fn are NOT P3 violations — they read a closure variable,
-		// not a `.cache`." Subscribe handlers run synchronously on dep DATA,
-		// so the closure mirrors are always current by the time the generate
-		// fn fires for the next iter.
-		let latestStrategy: RefineStrategy<T> = initialStrategy;
-		let latestFeedback: Feedback | undefined;
-		let latestPrevCandidates: readonly T[] = [];
-		this.addDisposer(
-			strategyNode.subscribe((msgs) => {
-				for (const m of msgs) if (m[0] === DATA) latestStrategy = m[1] as RefineStrategy<T>;
-			}),
-		);
-		this.addDisposer(
-			lastFeedbackState.subscribe((msgs) => {
-				for (const m of msgs) if (m[0] === DATA) latestFeedback = m[1] as Feedback;
-			}),
-		);
-		this.addDisposer(
-			prevCandidatesState.subscribe((msgs) => {
-				for (const m of msgs) if (m[0] === DATA) latestPrevCandidates = m[1] as readonly T[];
-			}),
-		);
-
-		// --- GENERATE: iterationTrigger → candidates ----------------------------
-		// switchMap cancels any in-flight generate when a new iteration fires.
-		// At iteration 0, strategy.seed(seed). At iteration > 0, strategy.generate.
-		//
-		// Sync strategies emit in the same wave as `iterationTrigger` — no microtask
-		// bridge. This eliminates the per-topic iteration race (Edge #5): all four
-		// stage effects drain under one wave, so iteration numbers across
-		// GENERATE / EVALUATE / ANALYZE / DECIDE are guaranteed identical.
-		//
-		// Async strategies still cross a Promise boundary — that's the strategy's
-		// async-source contract (spec §5.10: async boundaries belong in sources).
-		// Cancellation on strategy swap / pause / new iteration uses switchMap's
-		// inner-node unsubscribe + a `cancelled` flag so late Promise resolutions
-		// don't emit into a torn-down switchMap slot.
-		//
-		// **/qa D1 (2026-05-01) — envelope shape:** the inner producer emits
-		// `{iter, items}` so `iter` rides the data wave through every downstream
-		// stage. Eliminates the cross-node `iterationTrigger.cache` P3 violation
-		// in `decideEffect` (and the resume-stall failure mode it caused). User-
-		// facing evaluator API stays `Node<readonly T[]>` via the
-		// `candidatesItemsNode` sidecar derived below.
-		const candidatesNode = switchMap<number, CandidatesEnvelope<T>>(
-			iterationTrigger,
-			(iter) => {
-				const strat = latestStrategy;
-				const isSeed = iter === 0 || latestFeedback === undefined;
-				return createNode<CandidatesEnvelope<T>>(
-					[],
-					(_data, actions) => {
-						let cancelled = false;
-						try {
-							const result = isSeed
-								? strat.seed(seed)
-								: strat.generate(latestFeedback as Feedback, latestPrevCandidates);
-							if (result instanceof Promise) {
-								result.then(
-									(v) => {
-										if (!cancelled) actions.emit({ iter, items: v });
-									},
-									(err) => {
-										if (!cancelled) actions.down([[ERROR, err]]);
-									},
-								);
-								return {
-									onDeactivation: () => {
-										cancelled = true;
-									},
-								};
-							}
-							actions.emit({ iter, items: result });
-						} catch (err) {
-							cancelled = true;
-							actions.down([[ERROR, err]]);
-						}
-						return undefined;
-					},
-					{ describeKind: "producer" },
-				);
-			},
-			{ name: "candidates" },
-		);
-		this.add(candidatesNode, { name: "candidates" });
-
-		// User-facing items sidecar: preserves the `Evaluator<T>` API
-		// (`(candidates: Node<readonly T[]>, dataset: Node<readonly DatasetItem[]>) => ...`)
-		// while the internal pipeline reads iter from the envelope.
-		const candidatesItemsNode = createNode<readonly T[]>(
-			[candidatesNode],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				const env = data[0] as CandidatesEnvelope<T> | undefined;
-				if (env === undefined) {
-					actions.down([[RESOLVED]]);
-					return;
-				}
-				actions.emit(env.items);
-			},
-			{ name: "candidates-items", describeKind: "derived" },
-		);
-		this.add(candidatesItemsNode, { name: "candidates-items" });
-
-		// Error watcher — strategy throws surface as ERROR on `candidatesNode`.
-		// Promote to `status = "errored"` so callers don't have to subscribe to
-		// the error channel directly.
-		const errorWatcher = createNode(
-			[candidatesNode],
-			(_batchData, _actions, ctx) => {
-				const terminal = ctx.terminalDeps[0];
-				if (terminal !== undefined && terminal !== true) {
-					statusState.emit("errored");
-				}
-			},
-			{ name: "error-watcher", describeKind: "effect", errorWhenDepsError: false },
-		);
-		this.add(errorWatcher, { name: "error-watcher" });
-		this.addDisposer(errorWatcher.subscribe(() => undefined));
-
-		// GENERATE stage: three nodes replace one monolithic effect.
-		// (1) derived computes the event payload — reactive edge visible in explain().
-		// (2) publish effect routes the derived event to the hub topic.
-		// (3) mirror effect keeps prevCandidatesState in sync for §28 closure reads.
-		// Budget accounting stays in decideEffect (single authority).
-		// /qa D1: iter + items both come from the candidates envelope — no
-		// separate `iterationTrigger` dep, no cross-node cache reads.
-		const generateEventNode = createNode<GenerateEvent<T>>(
-			[candidatesNode],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				const env = data[0] as CandidatesEnvelope<T>;
-				actions.emit({
-					iteration: env.iter,
-					candidates: env.items,
-					timestamp_ns: monotonicNs(),
-				});
-			},
-			{ name: "generate-event", describeKind: "derived" },
-		);
-		this.add(generateEventNode, { name: "generate-event" });
-		this.addDisposer(generateEventNode.subscribe(() => undefined));
-
-		const generatePublishEffect = createNode(
-			[generateEventNode],
-			(batchData, _actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				hubGenerateTopic.publish(data[0] as GenerateEvent<T>);
-			},
-			{ name: "generate-publish", describeKind: "effect" },
-		);
-		this.add(generatePublishEffect, { name: "generate-publish" });
-		this.addDisposer(generatePublishEffect.subscribe(() => undefined));
-
-		const generateMirrorEffect = createNode(
-			[candidatesNode],
-			(batchData, _actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				const env = data[0] as CandidatesEnvelope<T>;
-				prevCandidatesState.emit(env.items);
-			},
-			{ name: "generate-mirror", describeKind: "effect" },
-		);
-		this.add(generateMirrorEffect, { name: "generate-mirror" });
-		this.addDisposer(generateMirrorEffect.subscribe(() => undefined));
-
-		// --- EVALUATE: candidates × dataset → scores ----------------------------
-		// User evaluator sees the items sidecar (preserves `Evaluator<T>` API).
-		const scoresNode = evaluator(candidatesItemsNode, datasetNode);
-		this.add(scoresNode, { name: "scores" });
-
-		// EVALUATE stage: derived event node + publish effect.
-		// /qa D1: iter from candidates envelope; gate on `scoresFired` so a
-		// candidates-only fan-out wave (e.g. async eval still in flight) does
-		// NOT publish a stale evaluate event.
-		const evaluateEventNode = createNode<EvaluateEvent<T>>(
-			[scoresNode, candidatesNode],
-			(batchData, actions, ctx) => {
-				const scoresFired = batchData[0] != null && batchData[0].length > 0;
-				if (!scoresFired) {
-					actions.down([[RESOLVED]]);
-					return;
-				}
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				const scores = data[0] as readonly EvalResult[];
-				const env = data[1] as CandidatesEnvelope<T>;
-				actions.emit({
-					iteration: env.iter,
-					candidates: env.items,
-					scores,
-					timestamp_ns: monotonicNs(),
-				});
-			},
-			{ name: "evaluate-event", describeKind: "derived" },
-		);
-		this.add(evaluateEventNode, { name: "evaluate-event" });
-		this.addDisposer(evaluateEventNode.subscribe(() => undefined));
-
-		const evaluatePublishEffect = createNode(
-			[evaluateEventNode],
-			(batchData, _actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				hubEvaluateTopic.publish(data[0] as EvaluateEvent<T>);
-			},
-			{ name: "evaluate-publish", describeKind: "effect" },
-		);
-		this.add(evaluatePublishEffect, { name: "evaluate-publish" });
-		this.addDisposer(evaluatePublishEffect.subscribe(() => undefined));
-
-		// --- ANALYZE: strategy.analyze(scores, candidates) → feedbackEnvelope ---
-		// /qa D1: feedbackEnvelope is the canonical iter-tagged trigger payload
-		// for the DECIDE stage. Gates on `scoresFired` so a candidates-only
-		// wave (async eval not settled yet) does NOT emit stale feedback into
-		// `decideEffect`. When the user evaluator emits, both deps' caches are
-		// consistent (candidates envelope carries iter that matches the scores
-		// the user just produced — *assuming the user evaluator cancels async
-		// work on candidates change; see Evaluator<T> JSDoc contract*).
-		const feedbackEnvelopeNode = createNode<FeedbackEnvelope<T>>(
-			[scoresNode, candidatesNode],
-			(batchData, actions, ctx) => {
-				const scoresFired = batchData[0] != null && batchData[0].length > 0;
-				if (!scoresFired) {
-					actions.down([[RESOLVED]]);
-					return;
-				}
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				const scores = data[0] as readonly EvalResult[];
-				const env = data[1] as CandidatesEnvelope<T>;
-				actions.emit({
-					iter: env.iter,
-					items: env.items,
-					scores,
-					feedback: latestStrategy.analyze(scores, env.items),
-				});
-			},
-			{ name: "feedback-envelope", describeKind: "derived" },
-		);
-		this.add(feedbackEnvelopeNode, { name: "feedback-envelope" });
-
-		// User-facing feedback projection sidecar — preserves `feedback` path
-		// for observers that consume the bare `Feedback` shape via
-		// `loop.observe("feedback")` etc.
-		const feedbackNode = createNode<Feedback>(
-			[feedbackEnvelopeNode],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				const fbEnv = data[0] as FeedbackEnvelope<T>;
-				actions.emit(fbEnv.feedback);
-			},
-			{ name: "feedback", describeKind: "derived" },
-		);
-		this.add(feedbackNode, { name: "feedback" });
-
-		// ANALYZE stage: derived event node + publish effect.
-		// /qa D1: pull iter + items from feedbackEnvelopeNode (single source of
-		// truth for the analyze beat). No cross-node cache reads.
-		const analyzeEventNode = createNode<AnalyzeEvent<T>>(
-			[feedbackEnvelopeNode],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				const fbEnv = data[0] as FeedbackEnvelope<T>;
-				actions.emit({
-					iteration: fbEnv.iter,
-					candidates: fbEnv.items,
-					feedback: fbEnv.feedback,
-					timestamp_ns: monotonicNs(),
-				});
-			},
-			{ name: "analyze-event", describeKind: "derived" },
-		);
-		this.add(analyzeEventNode, { name: "analyze-event" });
-		this.addDisposer(analyzeEventNode.subscribe(() => undefined));
-
-		const analyzePublishEffect = createNode(
-			[analyzeEventNode],
-			(batchData, _actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				hubAnalyzeTopic.publish(data[0] as AnalyzeEvent<T>);
-			},
-			{ name: "analyze-publish", describeKind: "effect" },
-		);
-		this.add(analyzePublishEffect, { name: "analyze-publish" });
-		this.addDisposer(analyzePublishEffect.subscribe(() => undefined));
-
-		// --- Convergence: four derived nodes fanning into one boolean -----------
-		const patienceNode = createNode<boolean>(
-			[historyState],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				const h = data[0] as readonly Iteration<T>[];
-				if (opts.patience == null || h.length <= opts.patience) {
-					actions.emit(false);
-					return;
-				}
-				// No improvement over the last `patience` iterations.
-				const lookback = h.slice(-(opts.patience + 1));
-				const baseline = lookback[0]!.bestScore;
-				actions.emit(lookback.slice(1).every((i) => i.bestScore <= baseline));
-			},
-			{ name: "patience-check", describeKind: "derived" },
-		);
-		this.add(patienceNode, { name: "patience-check" });
-
-		const minScoreNode = createNode<boolean>(
-			[scoreState],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit(opts.minScore != null && (data[0] as number) >= opts.minScore);
-			},
-			{ name: "min-score-check", describeKind: "derived" },
-		);
-		this.add(minScoreNode, { name: "min-score-check" });
-
-		const minDeltaNode = createNode<boolean>(
-			[historyState],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				const h = data[0] as readonly Iteration<T>[];
-				if (opts.minDelta == null || h.length < 2) {
-					actions.emit(false);
-					return;
-				}
-				const prev = h[h.length - 2]!.bestScore;
-				const curr = h[h.length - 1]!.bestScore;
-				actions.emit(Math.abs(curr - prev) < opts.minDelta);
-			},
-			{ name: "min-delta-check", describeKind: "derived" },
-		);
-		this.add(minDeltaNode, { name: "min-delta-check" });
-
-		const maxEvalsNode = createNode<boolean>(
-			[budgetState],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit(opts.maxEvaluations != null && (data[0] as number) >= opts.maxEvaluations);
-			},
-			{ name: "max-evaluations-check", describeKind: "derived" },
-		);
-		this.add(maxEvalsNode, { name: "max-evaluations-check" });
-
-		const maxIterNode = createNode<boolean>(
-			[iterationTrigger],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit(opts.maxIterations != null && (data[0] as number) >= opts.maxIterations);
-			},
-			{ name: "max-iterations-check", describeKind: "derived" },
-		);
-		this.add(maxIterNode, { name: "max-iterations-check" });
-
-		const budgetExhaustedNode = createNode<boolean>(
-			[budgetState],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit(opts.budget != null && (data[0] as number) >= opts.budget);
-			},
-			{ name: "budget-exhausted-check", describeKind: "derived" },
-		);
-		this.add(budgetExhaustedNode, { name: "budget-exhausted-check" });
-
-		// Activate convergence derivations so their cache stays current — decideEffect
-		// reads their cache via external-boundary reads (§28). They must NOT be direct
-		// deps: that would create a feedback cycle (decideEffect writes history/score,
-		// convergence derives from those, cycle).
-		this.addDisposer(patienceNode.subscribe(() => undefined));
-		this.addDisposer(minScoreNode.subscribe(() => undefined));
-		this.addDisposer(minDeltaNode.subscribe(() => undefined));
-		this.addDisposer(maxEvalsNode.subscribe(() => undefined));
-		this.addDisposer(maxIterNode.subscribe(() => undefined));
-		this.addDisposer(budgetExhaustedNode.subscribe(() => undefined));
-
-		const convergedNode = createNode<{ converged: boolean; reason?: string }>(
-			[patienceNode, minScoreNode, minDeltaNode, maxEvalsNode, maxIterNode],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				const [p, ms, md, me, mi] = data;
-				if (p) {
-					actions.emit({ converged: true, reason: "patience" });
-					return;
-				}
-				if (ms) {
-					actions.emit({ converged: true, reason: "min-score" });
-					return;
-				}
-				if (md) {
-					actions.emit({ converged: true, reason: "min-delta" });
-					return;
-				}
-				if (me) {
-					actions.emit({ converged: true, reason: "max-evaluations" });
-					return;
-				}
-				if (mi) {
-					actions.emit({ converged: true, reason: "max-iterations" });
-					return;
-				}
-				actions.emit({ converged: false });
-			},
-			{ name: "converged", describeKind: "derived" },
-		);
-		this.add(convergedNode, { name: "converged" });
-		this.addDisposer(convergedNode.subscribe(() => undefined));
-
-		// --- DECIDE: feedbackEnvelope settles → fire next iteration OR terminate ---
-		// **/qa D1 (2026-05-01) — reactive form via §32 envelope + sole-owner
-		// `.cache` reads + reactive `pauseState` dep.** Two patterns at play:
-		//
-		// - **`iter` rides with the feedbackEnvelope payload** (§32 envelope).
-		//   Eliminates the original `iterationTrigger.cache` cross-node read
-		//   that caused the resume-stall (where iter.cache was bumped past
-		//   the candidates batch we're processing).
-		//
-		// - **`historyState` / `budgetState` are read via `.cache`** as a
-		//   sole-owner pattern: decideEffect is the SOLE WRITER + sole
-		//   reactive READER, both declared in the same enclosing constructor
-		//   scope. Reading their `.cache` here is "read your own scratchpad"
-		//   semantically, even though they're sibling Node objects. Adding
-		//   them as direct deps would create the §7 self-feedback cycle
-		//   (decideEffect writes them, would re-trigger itself); closure
-		//   mirrors would just duplicate state already held in the nodes
-		//   themselves. The comment block belongs to /qa D1 follow-up
-		//   (2026-05-01) — explicit user lock that sole-owner-and-reader
-		//   nodes in the same enclosing scope are a sanctioned `.cache` read
-		//   form.
-		//
-		// - **`pauseState` is a direct dep** because it's an EXTERNAL CONTROL
-		//   INPUT — written by `pause()` / `resume()` imperative methods at
-		//   the user-call boundary, NOT by decideEffect. Making it a real
-		//   declared edge surfaces "this decision considers pause state" in
-		//   `describe()` / `explain()` topology. The `feedbackFired` gate
-		//   below skips fn body execution when only pauseState fired (no new
-		//   iteration to decide).
-		//
-		// Trigger semantics: feedbackEnvelopeNode itself only fires when the
-		// user evaluator emits fresh scores (gate via `batchData[scoresIdx]`
-		// in feedbackEnvelopeNode), so a candidates-only fan-out wave (async
-		// eval still in flight after `resume()`) does NOT spuriously trigger
-		// decideEffect.
-		//
-		// **Score-staleness contract:** if the user's `Evaluator<T>` does NOT
-		// cancel its async work when `candidates` changes, late scores from a
-		// prior iter can emit to scoresNode and trip feedbackEnvelopeNode +
-		// decideEffect with the new candidates' iter tag but stale scores
-		// data. See `Evaluator<T>` JSDoc (cancel-on-input contract) and
-		// `optimizations.md` "refineLoop async-evaluator stale-scores
-		// follow-up" for the wrapper proposal.
-		//
-		// Track last-decided iteration to avoid re-deciding when feedbackEnv
-		// re-fires within one wave (e.g. async evaluator emits multiple
-		// scores per candidates change).
-		let lastDecidedIteration = -1;
-		const decideEffect = createNode(
-			[feedbackEnvelopeNode, pauseState],
-			(batchData, _actions, ctx) => {
-				// `pauseState` is declared dep #1 — gate skips fn body when
-				// only pauseState fired (no new iteration to decide; we just
-				// want pauseState's prevData to advance for the next feedback
-				// fire).
-				const feedbackFired = batchData[0] != null && batchData[0].length > 0;
-				if (!feedbackFired) return;
-
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				const fbEnv = data[0] as FeedbackEnvelope<T>;
-				const paused = data[1] as boolean;
-
-				const i = fbEnv.iter;
-				const fb = fbEnv.feedback;
-				const cs = fbEnv.items;
-				const scores = fbEnv.scores;
-
-				// De-dup: only run once per iteration. fn may fire multiple
-				// times per wave as feedbackEnvelopeNode settles.
-				if (i <= lastDecidedIteration) return;
-				lastDecidedIteration = i;
-
-				// Sole-owner `.cache` reads — decideEffect is the SOLE
-				// writer and sole reactive reader of these state nodes.
-				const currentHistory = historyState.cache as readonly Iteration<T>[];
-				const currentBudget = budgetState.cache as number;
-
-				// Compute next history / score.
-				const { best, bestScore } = pickBest(cs, scores);
-				const iteration: Iteration<T> = {
-					n: i,
-					candidates: cs,
-					scores,
-					feedback: fb,
-					best,
-					bestScore,
-					timestamp_ns: monotonicNs(),
-				};
-				const nextHistory = [...currentHistory, iteration];
-				// Budget accounting — decideEffect is the single authority.
-				const nextBudget = currentBudget + cs.length;
-
-				// Inline convergence checks — single source of truth. The derived
-				// `convergedNode` + friends exist for describe()/observe() surface;
-				// inlining here avoids a drain-round-trip deadlock where decideEffect
-				// would need convergedNode.cache to update before running, but
-				// convergedNode needs historyState.emit from inside decideEffect.
-				let decision: DecideEvent["decision"] = "continue";
-				let reason: string | undefined;
-				const budgetOut = opts.budget != null && nextBudget >= opts.budget;
-				if (budgetOut) {
-					decision = "budget";
-					reason = "budget";
-				} else if (opts.minScore != null && fb.score >= opts.minScore) {
-					decision = "converged";
-					reason = "min-score";
-				} else if (opts.maxIterations != null && i >= opts.maxIterations) {
-					decision = "converged";
-					reason = "max-iterations";
-				} else if (opts.maxEvaluations != null && nextBudget >= opts.maxEvaluations) {
-					decision = "converged";
-					reason = "max-evaluations";
-				} else if (opts.minDelta != null && nextHistory.length >= 2) {
-					const prev = nextHistory[nextHistory.length - 2]!.bestScore;
-					const curr = nextHistory[nextHistory.length - 1]!.bestScore;
-					if (Math.abs(curr - prev) < opts.minDelta) {
-						decision = "converged";
-						reason = "min-delta";
-					}
-				} else if (opts.patience != null && nextHistory.length > opts.patience) {
-					const lookback = nextHistory.slice(-(opts.patience + 1));
-					const baseline = lookback[0]!.bestScore;
-					if (lookback.slice(1).every((it) => it.bestScore <= baseline)) {
-						decision = "converged";
-						reason = "patience";
-					}
-				}
-				// paused takes precedence over continue — if paused AND no convergence,
-				// we pause. Otherwise if converged we stop for real.
-				if (decision === "continue" && paused) {
-					decision = "paused";
-				}
-
-				// All emissions in one batch — drain order is feedback mirror first
-				// (§32), then iterationTrigger, so the next generate sees fresh fb.
-				// `lastFeedbackState` is always mirrored (regardless of decision) so
-				// resume-after-pause gets current feedback; only `iterationTrigger`
-				// is gated on `continue`.
-				batch(() => {
-					// `best` is `T | null` from pickBest — `null` only on an empty
-					// candidate batch (strategies throw on empty, so unreachable in
-					// practice). Skip the emit rather than pushing `null` into the
-					// SENTINEL `Node<T>`: a degenerate iteration preserves the prior
-					// best instead of wiping it. (Anti-pattern sweep 2026-05-18.)
-					if (best !== null) bestState.emit(best);
-					scoreState.emit(fb.score);
-					historyState.emit(nextHistory);
-					budgetState.emit(nextBudget);
-					lastFeedbackState.emit(fb);
-					hubDecideTopic.publish({
-						iteration: i,
-						decision,
-						reason,
-						timestamp_ns: monotonicNs(),
-					});
-
-					if (decision === "continue") {
-						iterationTrigger.emit(i + 1);
-					} else {
-						statusState.emit(
-							decision === "converged" ? "converged" : decision === "budget" ? "budget" : "paused",
-						);
-					}
-				});
-			},
-			{ name: "decide-bridge", describeKind: "effect" },
-		);
-		this.add(decideEffect, { name: "decide-bridge" });
-		this.addDisposer(decideEffect.subscribe(() => undefined));
-
-		// /qa A1 (2026-04-30): public field surface (best / score / status /
-		// history / strategy / iteration / generate / evaluate / analyze /
-		// decide / _pauseState) is assigned EARLIER, immediately after the
-		// stage hub is mounted (search "qa A1" above). Doing the assignment
-		// before any subscribe activation keeps `this.<field>` reachable
-		// during a synchronous strategy drain.
-	}
-
-	/** Swap the active strategy mid-run (human-in-the-loop handoff). */
-	setStrategy(next: RefineStrategy<T>): void {
-		this.strategy.emit(next);
-	}
-
-	/** Pause after the current iteration completes. */
-	pause(): void {
-		this._pauseState.emit(true);
-	}
-
-	/**
-	 * Resume a paused loop. Idempotent: only un-pauses from the "paused"
-	 * terminal state. Converged / budget / errored are permanent — a user
-	 * wanting to start over should construct a fresh refineLoop.
-	 */
-	resume(): void {
-		if (this.status.cache !== "paused") return;
-		batch(() => {
-			this._pauseState.emit(false);
-			this.status.emit("running" as RefineStatus);
-			this._iteration.emit((this._iteration.cache as number) + 1);
-		});
-	}
-}
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-/**
- * Structural type-guard for `Node<T>`. Checks the three core Node methods
- * (`subscribe`, `down`, `emit`) as callable properties — rejects plain objects
- * with a single `subscribe` field that happen to look like a Node but aren't.
- */
-function isNode<T>(x: unknown): x is Node<T> {
-	if (typeof x !== "object" || x === null) return false;
-	const obj = x as Record<string, unknown>;
-	return (
-		typeof obj.subscribe === "function" &&
-		typeof obj.down === "function" &&
-		typeof obj.emit === "function"
-	);
-}
-
-function pickBest<T>(
-	candidates: readonly T[],
-	scores: readonly EvalResult[],
-): { best: T | null; bestScore: number } {
-	// Empty batch → no best. Use `null` per COMPOSITION-GUIDE §3: `undefined`
-	// is the protocol SENTINEL, `null` is the domain sentinel for "no value".
-	if (candidates.length === 0) {
-		return { best: null, bestScore: Number.NEGATIVE_INFINITY };
-	}
-	if (candidates.length === 1) {
-		const mean = meanScore(scores);
-		return { best: candidates[0]!, bestScore: mean };
-	}
-	// Fan-out aware: when any score carries `candidateIndex`, aggregate mean
-	// score per candidate. When absent, fall back to positional `scores[i]` ↔
-	// `candidates[i]` alignment (one-score-per-candidate convention).
-	const hasFanOut = scores.some((s) => typeof s.candidateIndex === "number");
-	if (hasFanOut) {
-		const sums = new Array<{ sum: number; count: number }>(candidates.length);
-		for (let i = 0; i < candidates.length; i++) sums[i] = { sum: 0, count: 0 };
-		for (const s of scores) {
-			const idx = s.candidateIndex;
-			if (typeof idx === "number" && idx >= 0 && idx < candidates.length) {
-				sums[idx]!.sum += s.score;
-				sums[idx]!.count += 1;
-			}
-		}
-		let best = candidates[0]!;
-		let bestScore = sums[0]!.count > 0 ? sums[0]!.sum / sums[0]!.count : Number.NEGATIVE_INFINITY;
-		for (let i = 1; i < candidates.length; i++) {
-			const avg = sums[i]!.count > 0 ? sums[i]!.sum / sums[i]!.count : Number.NEGATIVE_INFINITY;
-			if (avg > bestScore) {
-				bestScore = avg;
-				best = candidates[i]!;
-			}
-		}
-		return { best, bestScore };
-	}
-	let best = candidates[0]!;
-	let bestScore = scores[0]?.score ?? Number.NEGATIVE_INFINITY;
-	for (let i = 1; i < candidates.length; i++) {
-		const s = scores[i]?.score ?? Number.NEGATIVE_INFINITY;
-		if (s > bestScore) {
-			bestScore = s;
-			best = candidates[i]!;
-		}
-	}
-	return { best, bestScore };
-}
-
-function meanScore(scores: readonly EvalResult[]): number {
-	if (scores.length === 0) return Number.NEGATIVE_INFINITY;
-	let sum = 0;
-	for (const s of scores) sum += s.score;
-	return sum / scores.length;
-}
-
-// ---------------------------------------------------------------------------
-// refineLoop factory
-// ---------------------------------------------------------------------------
-
-/**
- * Construct a {@link RefineLoopGraph} — the universal prompt/artifact
- * optimization loop. Thin wrapper over `new RefineLoopGraph(...)` for
- * call-site ergonomics.
- */
-export function refineLoop<T>(
-	seed: T,
-	evaluator: Evaluator<T>,
-	initialStrategy: RefineStrategy<T>,
-	opts: RefineLoopOptions,
-): RefineLoopGraph<T> {
-	return new RefineLoopGraph<T>(seed, evaluator, initialStrategy, opts);
-}
-
-// ---------------------------------------------------------------------------
-// Built-in strategy: blindVariation
-// ---------------------------------------------------------------------------
-
-/**
- * Context passed to a `blindVariation` teacher per call. `reportCost` is a
- * per-call hook — see `BlindVariationOptions.tokens`.
- */
-export interface BlindVariationContext<T> {
-	readonly prior: T;
-	/**
-	 * Report tokens consumed by this teacher call. Aggregated per iteration
-	 * and flushed to `opts.tokens` in the strategy's `finally` block so
-	 * partial spend is preserved when the teacher throws mid-batch.
-	 */
-	readonly reportCost: (tokens: number) => void;
-}
-
-export interface BlindVariationOptions<T> {
-	/** Name — default: `"blindVariation"`. */
-	name?: string;
-	/** Number of candidates generated per iteration. Default: 4. */
-	width?: number;
-	/**
-	 * Run teacher calls in parallel via `Promise.all`. Default `true` — the
-	 * common case (independent LLM calls). Set `false` to run sequentially
-	 * via `for/await` when teachers share stateful resources (rate limiters,
-	 * rolling context, serial API ordering) that don't tolerate concurrency.
-	 */
-	parallel?: boolean;
-	/**
-	 * Optional cost counter node. Running total tokens reported via
-	 * `ctx.reportCost` during each iteration is added to this node in the
-	 * strategy's `finally` block — fires on success AND on teacher throw so
-	 * partial spend is never lost. User owns the node; wire to `budgetGate`,
-	 * `attachSnapshotStorage`, telemetry, etc.
-	 */
-	tokens?: Node<number>;
-	/**
-	 * Teacher — given `{prior, reportCost}`, produce one variant. Async
-	 * allowed. Called `width` times per iteration. Call `ctx.reportCost(n)`
-	 * to track tokens consumed per call (optional, no-op if `opts.tokens`
-	 * is not set).
-	 */
-	teacher: (ctx: BlindVariationContext<T>) => Promise<T> | T;
-}
-
-/**
- * Simplest built-in strategy: generate N variants per iteration via the
- * supplied `teacher`; no feedback-informed steering (equivalent to Random
- * Search). Validates the loop infrastructure end-to-end and is the baseline
- * every other strategy should outperform.
- *
- * `analyze` records the mean score and flags the worst task — strategies that
- * care about per-task critique layer on top.
- */
-export function blindVariation<T>(opts: BlindVariationOptions<T>): RefineStrategy<T> {
-	const width = opts.width ?? 4;
-	const name = opts.name ?? "blindVariation";
-	return {
-		name,
-		seed(seed) {
-			// Iteration 0 emits just the seed — strategy.seed is synchronous by
-			// contract, so we can't call an async teacher here. `width`-many
-			// teacher-produced variants begin at iteration 1 via `generate`.
-			return [seed];
-		},
-		analyze(scores, _candidates) {
-			const score = meanScore(scores);
-			let worst: EvalResult | null = null;
-			for (const s of scores) {
-				if (!worst || s.score < worst.score) worst = s;
-			}
-			return {
-				summary: `blindVariation iteration: mean=${score.toFixed(3)}, n=${scores.length}`,
-				score,
-				weakTasks: worst ? [worst.taskId] : [],
-			};
-		},
-		async generate(_feedback, candidates) {
-			if (candidates.length === 0) {
-				// Empty candidate batch is a contract violation — either the
-				// seed was empty or a previous generate returned nothing. Surface
-				// as an error rather than silently returning [] (which would
-				// stall the loop in an infinite zero-candidate cycle).
-				throw new Error(
-					"blindVariation.generate: empty candidate batch — cannot derive prior for teacher",
-				);
-			}
-			// Pick the current "recent best" — `null` IS a valid domain value
-			// per COMPOSITION-GUIDE §3; the length guard above has already
-			// filtered the `undefined` protocol sentinel.
-			const prior = candidates[candidates.length - 1] as T;
-			let iterCost = 0;
-			const reportCost = (n: number) => {
-				iterCost += n;
-			};
-			const ctx: BlindVariationContext<T> = { prior, reportCost };
-			try {
-				if (opts.parallel !== false) {
-					return await Promise.all(Array.from({ length: width }, () => opts.teacher(ctx)));
-				}
-				const out: T[] = [];
-				for (let i = 0; i < width; i++) {
-					out.push(await opts.teacher(ctx));
-				}
-				return out;
-			} finally {
-				if (opts.tokens != null && iterCost > 0) {
-					// /qa D1 follow-up (2026-05-01): replaced direct `.cache` read
-					// + emit with `tryIncrementBounded`, which encapsulates the
-					// self-owned-counter `.cache` access in the canonical helper
-					// (sole sanctioned site per its JSDoc). Cap is unbounded for
-					// the token meter.
-					tryIncrementBounded(opts.tokens, Number.MAX_SAFE_INTEGER, iterCost);
-				}
-			}
-		},
-	};
-}
-
-// ---------------------------------------------------------------------------
-// Built-in strategy: errorCritique
-// ---------------------------------------------------------------------------
-
-/**
- * Context passed to an `errorCritique` teacher. `critique` is the pre-formatted
- * summary a prompt template can drop in verbatim; `failures` carries the
- * structured evidence (per-task error / score / detail) for richer prompts.
- */
-export interface ErrorCritiqueContext<T> {
-	readonly prior: T;
-	readonly critique: string;
-	readonly failures: readonly EvalResult[];
-	/**
-	 * Report tokens consumed by this teacher call. Aggregated per iteration
-	 * and flushed to `opts.tokens` in the strategy's `finally` block so
-	 * partial spend is preserved when the teacher throws mid-batch.
-	 */
-	readonly reportCost: (tokens: number) => void;
-}
-
-export interface ErrorCritiqueOptions<T> {
-	/** Name — default: `"errorCritique"`. */
-	name?: string;
-	/** Number of candidates generated per iteration. Default: 4. */
-	width?: number;
-	/**
-	 * Cut-off below which a task is classified as a failure and fed into the
-	 * critique. Default: the batch mean — any task scoring below the batch
-	 * mean is a failure. Pass a number for an absolute cut-off, or a function
-	 * for per-batch computation (e.g. a percentile). When the default mean
-	 * is non-finite (NaN / ±Infinity from a degenerate evaluator), ALL scores
-	 * are treated as failures so the critique loop continues to steer.
-	 */
-	failureThreshold?: number | ((scores: readonly EvalResult[]) => number);
-	/** Cap on failure samples packed into the critique. Default: 5. */
-	maxFailureSamples?: number;
-	/**
-	 * Format failures into the `critique` string passed to the teacher. Default
-	 * joins `- taskId (score=N) | error: …` lines. Override to shape LLM prompts.
-	 *
-	 * **Note:** the `feedback` argument is a shell with `{score, weakTasks}`
-	 * populated; `summary` is empty because `analyze` computes the final summary
-	 * AFTER `formatCritique` runs (the summary embeds the formatted count).
-	 * Rely on `failures` and `feedback.score` — do not read `feedback.summary`
-	 * here.
-	 */
-	formatCritique?: (failures: readonly EvalResult[], feedback: Feedback) => string;
-	/**
-	 * Run teacher calls in parallel via `Promise.all`. Default `true` — the
-	 * common case (independent LLM calls). Set `false` to run sequentially
-	 * via `for/await` when teachers share stateful resources (rate limiters,
-	 * rolling context, serial API ordering) that don't tolerate concurrency.
-	 */
-	parallel?: boolean;
-	/**
-	 * Optional cost counter node. Running total tokens reported via
-	 * `ctx.reportCost` during each iteration is added to this node in the
-	 * strategy's `finally` block — fires on success AND on teacher throw so
-	 * partial spend is never lost. User owns the node; wire to `budgetGate`,
-	 * `attachSnapshotStorage`, telemetry, etc.
-	 */
-	tokens?: Node<number>;
-	/**
-	 * Teacher — given `{prior, critique, failures, reportCost}`, produce one
-	 * refined variant. Called `width` times per iteration. Async allowed.
-	 * Call `ctx.reportCost(n)` to track tokens consumed per call (optional,
-	 * no-op if `opts.tokens` is not set).
-	 */
-	teacher: (ctx: ErrorCritiqueContext<T>) => Promise<T> | T;
-}
-
-/**
- * Private payload stashed inside `Feedback.critique` so `generate` can recover
- * the analyze-time prior + failure set without another pass over scores.
- */
-interface ErrorCritiquePrivate<T> {
-	readonly kind: "errorCritique";
-	readonly best: T | null;
-	readonly failures: readonly EvalResult[];
-	readonly critiqueText: string;
-}
-
-function isErrorCritiquePrivate<T>(v: unknown): v is ErrorCritiquePrivate<T> {
-	return typeof v === "object" && v !== null && (v as { kind?: unknown }).kind === "errorCritique";
-}
-
-function defaultFormatCritique(failures: readonly EvalResult[], feedback: Feedback): string {
-	if (failures.length === 0) {
-		return `No task scored below the batch mean (${feedback.score.toFixed(3)}). Reinforce the current direction.`;
-	}
-	const lines = failures.map((f) => {
-		const err = f.error != null ? ` | error: ${f.error}` : "";
-		return `- ${f.taskId} (score=${f.score.toFixed(3)})${err}`;
-	});
-	return `Failures below threshold:\n${lines.join("\n")}`;
-}
-
-/**
- * Critique-driven strategy (ProTeGi-style "textual gradient"). Each iteration:
- *   1. `analyze` classifies tasks scoring below a threshold as failures, picks
- *      the best candidate from the batch, and packs both plus a formatted
- *      critique string into `feedback.critique` as a private payload.
- *   2. `generate` unpacks that payload and calls the teacher with
- *      `{prior, critique, failures, reportCost}` `width` times, returning the
- *      refined batch.
- *
- * The teacher receives a pre-formatted string (drop into an LLM prompt) AND
- * the structured failure list (for richer prompts that want per-task detail).
- * Throws on empty candidate batches — matches `blindVariation`'s contract
- * (no silent zero-candidate cycles).
- *
- * When `setStrategy()` swaps this strategy in mid-run, the first `generate`
- * may receive a `Feedback` produced by the prior strategy (no private payload);
- * the fallback path uses `candidates[last]` as the prior and the feedback
- * summary as the critique, so the loop keeps running without a stall. When a
- * private payload IS present, `priv.critiqueText` takes precedence over any
- * edits a caller made to `feedback.summary` — treat `critique` as the
- * strategy-owned channel.
- */
-export function errorCritique<T>(opts: ErrorCritiqueOptions<T>): RefineStrategy<T> {
-	const width = opts.width ?? 4;
-	const name = opts.name ?? "errorCritique";
-	const maxFailureSamples = opts.maxFailureSamples ?? 5;
-	const format = opts.formatCritique ?? defaultFormatCritique;
-
-	return {
-		name,
-		seed(seed) {
-			// Iteration 0 emits just the seed. The critique loop begins at
-			// iteration 1, once real scores exist to derive failures from.
-			return [seed];
-		},
-		analyze(scores, candidates) {
-			const score = meanScore(scores);
-			const userThreshold =
-				typeof opts.failureThreshold === "function"
-					? opts.failureThreshold(scores)
-					: opts.failureThreshold;
-			// A1: when the user didn't supply a threshold AND the batch-mean
-			// default is non-finite (e.g. evaluator produced NaN / ±Infinity),
-			// treat every score as a failure instead of filtering with `< NaN`
-			// (which would be false for every score → silent no-op).
-			const thresholdUnresolvable = userThreshold === undefined && !Number.isFinite(score);
-			const threshold = userThreshold ?? score;
-			const allFailures = thresholdUnresolvable
-				? [...scores].sort((a, b) => a.score - b.score)
-				: scores
-						.filter((s) => s.score < threshold)
-						.slice()
-						.sort((a, b) => a.score - b.score);
-			const failures = allFailures.slice(0, maxFailureSamples);
-
-			const { best, bestScore } = pickBest(candidates, scores);
-			const feedbackShell: Feedback = {
-				summary: "",
-				score,
-				weakTasks: failures.map((f) => f.taskId),
-			};
-			const critiqueText = format(failures, feedbackShell);
-
-			const priv: ErrorCritiquePrivate<T> = {
-				kind: "errorCritique",
-				best,
-				failures,
-				critiqueText,
-			};
-			const retainedSuffix =
-				allFailures.length > failures.length ? ` (top ${failures.length} retained)` : "";
-			return {
-				summary: `errorCritique iteration: mean=${score.toFixed(3)}, failures=${allFailures.length}${retainedSuffix}/${scores.length}, bestScore=${bestScore.toFixed(3)}`,
-				critique: priv,
-				weakTasks: failures.map((f) => f.taskId),
-				score,
-			};
-		},
-		async generate(feedback, candidates) {
-			// N1: Length guard FIRST. The only protocol-sentinel risk is
-			// `undefined` sneaking in via an empty candidates array; after
-			// this check, `null` values (including `priv.best === null` when
-			// T admits null) flow through as domain-valid per
-			// COMPOSITION-GUIDE §3 / spec §1.
-			if (candidates.length === 0) {
-				throw new Error(
-					"errorCritique.generate: empty candidate batch — cannot derive prior for teacher",
-				);
-			}
-			const priv = isErrorCritiquePrivate<T>(feedback.critique) ? feedback.critique : undefined;
-			const prior: T =
-				priv !== undefined ? (priv.best as T) : (candidates[candidates.length - 1] as T);
-			const critique = priv?.critiqueText ?? feedback.summary;
-			const failures = priv?.failures ?? [];
-			let iterCost = 0;
-			const reportCost = (n: number) => {
-				iterCost += n;
-			};
-			const ctx: ErrorCritiqueContext<T> = { prior, critique, failures, reportCost };
-			try {
-				if (opts.parallel !== false) {
-					return await Promise.all(Array.from({ length: width }, () => opts.teacher(ctx)));
-				}
-				const out: T[] = [];
-				for (let i = 0; i < width; i++) {
-					out.push(await opts.teacher(ctx));
-				}
-				return out;
-			} finally {
-				if (opts.tokens != null && iterCost > 0) {
-					// /qa D1 follow-up (2026-05-01): replaced direct `.cache` read
-					// + emit with `tryIncrementBounded`, which encapsulates the
-					// self-owned-counter `.cache` access in the canonical helper.
-					tryIncrementBounded(opts.tokens, Number.MAX_SAFE_INTEGER, iterCost);
-				}
-			}
-		},
-	};
-}
diff --git a/src/presets/harness/spawnable.ts b/src/presets/harness/spawnable.ts
deleted file mode 100644
index 509aaa0d..00000000
--- a/src/presets/harness/spawnable.ts
+++ /dev/null
@@ -1,385 +0,0 @@
-/**
- * Phase 13.I — `spawnable()` harness preset.
- *
- * Source: `archive/docs/SESSION-multi-agent-gap-analysis.md` G3 lock B + G5
- * reframe.
- *
- * Wraps a {@link MessagingHubGraph} + {@link presetRegistry} +
- * (per-request) {@link agent} mounting + depth-cap + termination contract.
- * Consumers emit a `TopicMessage<SpawnPayload>` to the well-known
- * {@link SPAWNS_TOPIC}; `spawnable()` mints a fresh agent from the
- * matching preset, mounts it, and tracks it in `activeSlot` until the
- * agent settles or expires. Out-of-policy requests (depth-cap exceeded,
- * unknown presetId, schema-invalid, expired) flow to the `rejected`
- * topic.
- *
- * **Cross-cut #1 lock (no `agent.run()`):** spawnable kicks each agent
- * via `bundle.in.emit(taskInput)`; status transitions are observed via
- * the agent's reactive `status` Node.
- *
- * **Termination contract:**
- * - `done` / `error` from the agent's `status` → unmount + remove from
- *   `activeSlot`.
- * - `expiresAt` (set on the request envelope, ISO 8601) — when the wall
- *   clock passes the deadline AND the agent is still active, the agent is
- *   aborted (via `loop.abort()`) and reported on `rejected` with
- *   `reason: "expired"`. (Per-spawn timeout via the `timeout` operator
- *   recipe is documented in COMPOSITION-GUIDE-PATTERNS.)
- *
- * **Depth-cap:** locked recipe (DS-13.I) is `valve(spawnTopic, derived(
- * [depthCounter], n => n < cap))`, but the practical pattern in
- * `spawnable()` checks depth per-request inside the request handler so
- * over-cap requests can be reported on `rejected`. Callers who want hard
- * cuts (no rejection signal) can wrap their own publish path with
- * `valve` per the recipe.
- */
-
-import { batch, DATA, type Node, node, wallClockNs } from "@graphrefly/pure-ts/core";
-import { keepalive } from "@graphrefly/pure-ts/extra";
-import { Graph } from "@graphrefly/pure-ts/graph";
-import { aiMeta } from "../../utils/ai/_internal.js";
-import type { LLMResponse } from "../../utils/ai/adapters/core/types.js";
-import {
-	type MessagingHubGraph,
-	SPAWNS_TOPIC,
-	type SubscriptionGraph,
-	subscription,
-	type TopicGraph,
-	type TopicMessage,
-	topic,
-} from "../../utils/messaging/index.js";
-import type { AgentBundle, AgentSpec, AgentStatus } from "../ai/agent.js";
-import type { PresetRegistryBundle } from "../ai/agents.js";
-import { agent } from "../ai/agents.js";
-
-// ---------------------------------------------------------------------------
-// Types
-// ---------------------------------------------------------------------------
-
-/**
- * Payload of a spawn request envelope. Wraps in a {@link Message}<...>:
- * the request body sets `presetId` (the preset registry key) and
- * `taskInput` (the typed input passed to the spawned agent's `bundle.in`).
- */
-export interface SpawnPayload<TIn> {
-	readonly presetId: string;
-	readonly taskInput: TIn;
-}
-
-/**
- * Rejection record published to the `rejected` topic when a spawn request
- * is denied. `reason` is a short human-readable code.
- */
-export interface SpawnRejection<TIn> {
-	readonly request: TopicMessage<SpawnPayload<TIn>>;
-	readonly reason: string;
-}
-
-/**
- * Options for {@link spawnable}.
- */
-export interface SpawnableOpts<TIn, TOut> {
-	/** Existing messaging hub. {@link SPAWNS_TOPIC} is created lazily on it. */
-	readonly hub: MessagingHubGraph;
-	/** Preset registry — keys must match `request.payload.presetId`. */
-	readonly registry: PresetRegistryBundle<AgentSpec<TIn, TOut>>;
-	/**
-	 * Local mount name on the hub for this spawnable's subgraph. Multiple
-	 * spawnable instances on the same hub must use distinct names. Default
-	 * `"spawnable"`.
-	 */
-	readonly name?: string;
-	/** Maximum concurrently-active agents. Default unbounded. */
-	readonly depthCap?: number;
-	/**
-	 * Initial cursor for the spawn-topic subscription. Default `"now"` —
-	 * pre-existing retained spawn requests are NOT replayed at construction.
-	 * Pass `"retained"` to replay or a number for explicit cursor offset.
-	 */
-	readonly from?: "now" | "retained" | number;
-	/**
-	 * Optional caller-supplied validator. Returns `true` to accept the
-	 * request, `false` to reject. Reject reason on the `rejected` topic is
-	 * `"schema validation failed"`. Pair with the `Message.schema` field carried
-	 * in the envelope when full JSON-Schema validation is needed (consumer
-	 * supplies the validator — ajv / zod / valibot — and reads the schema
-	 * from the envelope to gate). The substrate itself does NOT ship a
-	 * JSON-Schema validator; the `Message.schema` field is wire convention.
-	 */
-	readonly validate?: (request: TopicMessage<SpawnPayload<TIn>>) => boolean;
-}
-
-/**
- * The bundle returned by {@link spawnable}.
- */
-export interface SpawnableBundle<TIn, TOut> {
-	/** The well-known spawn topic — emit `TopicMessage<SpawnPayload<TIn>>` here. */
-	readonly spawnTopic: TopicGraph<TopicMessage<SpawnPayload<TIn>>>;
-	/** Reactive map of currently-active agent bundles, keyed by request id. */
-	readonly activeSlot: Node<ReadonlyMap<string, AgentBundle<TIn, TOut>>>;
-	/** Topic of rejected requests with reason. */
-	readonly rejected: TopicGraph<SpawnRejection<TIn>>;
-	/** The internal SpawnableGraph subgraph (mounted under the hub). */
-	readonly graph: SpawnableGraph<TIn, TOut>;
-}
-
-// ---------------------------------------------------------------------------
-// SpawnableGraph
-// ---------------------------------------------------------------------------
-
-/**
- * Graph subclass implementing {@link SpawnableBundle}'s topology.
- * Mounted under the hub at `opts.name` (default `"spawnable"`).
- *
- * Topology:
- * ```
- * <hub>
- * ├── spawns                (TopicGraph; well-known well-named spawn topic)
- * └── <name>                (SpawnableGraph)
- *     ├── spawn-sub         (SubscriptionGraph over hub::spawns::events)
- *     ├── rejected          (TopicGraph<SpawnRejection>)
- *     ├── active-slot       (Node<ReadonlyMap<id, AgentBundle>>)
- *     └── spawn-{req.id}/   (mounted AgentGraph per active spawn)
- * ```
- */
-export class SpawnableGraph<TIn, TOut> extends Graph {
-	readonly spawnTopic: TopicGraph<TopicMessage<SpawnPayload<TIn>>>;
-	readonly rejected: TopicGraph<SpawnRejection<TIn>>;
-	readonly activeSlot: Node<ReadonlyMap<string, AgentBundle<TIn, TOut>>>;
-	private readonly _spawnSub: SubscriptionGraph<TopicMessage<SpawnPayload<TIn>>>;
-	private readonly _registry: PresetRegistryBundle<AgentSpec<TIn, TOut>>;
-	private readonly _depthCap: number | undefined;
-	private readonly _validate: ((req: TopicMessage<SpawnPayload<TIn>>) => boolean) | undefined;
-	private _disposed = false;
-
-	constructor(opts: SpawnableOpts<TIn, TOut>) {
-		const name = opts.name ?? "spawnable";
-		super(name);
-
-		this._registry = opts.registry;
-		this._depthCap = opts.depthCap;
-		this._validate = opts.validate;
-
-		// Spawn topic on the hub (well-known name; lazy-created if absent).
-		this.spawnTopic = opts.hub.topic<TopicMessage<SpawnPayload<TIn>>>(SPAWNS_TOPIC);
-
-		// Rejected topic is private to this spawnable subgraph.
-		this.rejected = topic<SpawnRejection<TIn>>("rejected");
-		this.mount("rejected", this.rejected);
-
-		// Active-slot map. `equals: () => false` so each mutation emits a
-		// fresh snapshot even when callers pass an identity-equal Map ref.
-		const activeSlotNode = node<ReadonlyMap<string, AgentBundle<TIn, TOut>>>([], {
-			name: "active-slot",
-			describeKind: "state",
-			meta: aiMeta("spawnable_active_slot"),
-			initial: new Map(),
-			equals: () => false,
-		});
-		this.add(activeSlotNode, { name: "active-slot" });
-		this.activeSlot = activeSlotNode;
-
-		// Cursor-based subscription over hub.spawnTopic.events. Lives under
-		// this spawnable subgraph (NOT the hub), so multiple spawnable
-		// instances on the same hub get independent cursors.
-		// Default `from: "now"` skips pre-construction retained requests —
-		// older requests are NOT replayed unless the caller opts in.
-		this._spawnSub = subscription<TopicMessage<SpawnPayload<TIn>>>("spawn-sub", this.spawnTopic, {
-			from: opts.from ?? "now",
-		});
-		this.mount("spawn-sub", this._spawnSub);
-
-		// Subscribe to `available` to process new requests; ack as we go.
-		const subRef = this._spawnSub;
-		const unsub = subRef.available.subscribe((msgs) => {
-			if (this._disposed) return;
-			for (const m of msgs) {
-				if (m[0] !== DATA) continue;
-				const items = m[1] as readonly TopicMessage<SpawnPayload<TIn>>[];
-				if (items.length === 0) continue;
-				for (const req of items) {
-					if (this._disposed) return;
-					this._processRequest(req);
-				}
-				subRef.ack(items.length);
-			}
-		});
-		this.addDisposer(unsub);
-		this.addDisposer(() => {
-			this._disposed = true;
-		});
-		// Keepalive on the active-slot Node so external `cache` reads stay
-		// current even when no one is subscribed.
-		this.addDisposer(keepalive(activeSlotNode));
-	}
-
-	private _processRequest(req: TopicMessage<SpawnPayload<TIn>>): void {
-		if (this._disposed) return;
-
-		// Custom validation.
-		if (this._validate && !this._validate(req)) {
-			this.rejected.publish({ request: req, reason: "schema validation failed" });
-			return;
-		}
-
-		// Expiry check (only on entry — per-agent timeouts during run are a
-		// future iteration; recipe-style composition with `timeout` covers
-		// the in-flight case until then). Use `wallClockNs()` so test
-		// suites that monkey-patch the central clock can pin expiry decisions.
-		if (req.expiresAt != null) {
-			const expiry = Date.parse(req.expiresAt);
-			if (!Number.isFinite(expiry)) {
-				this.rejected.publish({ request: req, reason: "invalid expiresAt" });
-				return;
-			}
-			const nowMs = wallClockNs() / 1_000_000;
-			if (nowMs >= expiry) {
-				this.rejected.publish({ request: req, reason: "expired" });
-				return;
-			}
-		}
-
-		// Depth-cap check.
-		const currentMap =
-			(this.activeSlot.cache as ReadonlyMap<string, AgentBundle<TIn, TOut>> | undefined) ??
-			new Map();
-		if (this._depthCap != null && currentMap.size >= this._depthCap) {
-			this.rejected.publish({
-				request: req,
-				reason: `depth-cap exceeded (${currentMap.size}/${this._depthCap})`,
-			});
-			return;
-		}
-
-		// Look up preset.
-		const spec = this._registry.registry.get(req.payload.presetId);
-		if (!spec) {
-			this.rejected.publish({
-				request: req,
-				reason: `unknown presetId: ${req.payload.presetId}`,
-			});
-			return;
-		}
-
-		// Mint and mount the agent. Slot name is derived from the request id
-		// so it's traceable in describe / explain output.
-		const slotName = `spawn-${req.id}`;
-		let bundle: AgentBundle<TIn, TOut>;
-		try {
-			bundle = agent<TIn, TOut>(this, { ...spec, name: slotName });
-		} catch (e) {
-			this.rejected.publish({
-				request: req,
-				reason: `agent mint failed: ${(e as Error).message ?? "unknown"}`,
-			});
-			return;
-		}
-
-		// Update active-slot.
-		const updated = new Map(currentMap);
-		updated.set(req.id, bundle);
-		this.activeSlot.emit(updated);
-
-		// Watch for completion BEFORE kicking, so a synchronous adapter that
-		// drives status straight to "done" inside the kick still triggers
-		// cleanup. Subscribe to status; on terminal, unmount + remove. Each
-		// per-spawn statusUnsub releases inside `onTerminal` so we don't
-		// accumulate dead disposers per-spawn over the spawnable's lifetime.
-		let statusUnsub: (() => void) | undefined;
-		const onTerminal = (stat: AgentStatus): void => {
-			if (stat !== "done" && stat !== "error") return;
-			// Idempotent — guard against double-fire.
-			const live =
-				(this.activeSlot.cache as ReadonlyMap<string, AgentBundle<TIn, TOut>> | undefined) ??
-				new Map();
-			if (!live.has(req.id)) return;
-			batch(() => {
-				try {
-					this.remove(slotName);
-				} catch {
-					// Already removed (e.g., parent destroyed mid-flight).
-				}
-				const next = new Map(live);
-				next.delete(req.id);
-				this.activeSlot.emit(next);
-			});
-			// Release the per-spawn status subscription now that the spawn
-			// is finished — prevents disposer accumulation over many spawns.
-			statusUnsub?.();
-			statusUnsub = undefined;
-		};
-		statusUnsub = bundle.status.subscribe((msgs) => {
-			for (const m of msgs) {
-				if (m[0] === DATA) onTerminal(m[1] as AgentStatus);
-			}
-		});
-		// Defensive disposer — fires on SpawnableGraph.destroy() if the
-		// spawn is still in-flight. `onTerminal` clears `statusUnsub` so
-		// double-call is a no-op.
-		this.addDisposer(() => statusUnsub?.());
-
-		// Kick the agent reactively.
-		bundle.in.emit(req.payload.taskInput);
-	}
-}
-
-// ---------------------------------------------------------------------------
-// spawnable() factory
-// ---------------------------------------------------------------------------
-
-/**
- * Constructs a {@link SpawnableGraph}, mounts it under `opts.hub` at
- * `opts.name` (default `"spawnable"`), and returns the
- * {@link SpawnableBundle} contract.
- *
- * **Composition with Phase 13 substrate:**
- * - Builds on **13.B** ({@link Message} envelope, {@link SPAWNS_TOPIC}).
- * - Builds on **13.G/H** ({@link agent}, {@link AgentBundle}).
- * - Builds on **13.H** ({@link presetRegistry}).
- * - The depth-cap gate is documented as a **13.D recipe**
- *   (`valve(spawnTopic, derived([depthCounter], n => n < cap))`); inside
- *   `spawnable()` the depth check is per-request so over-cap requests
- *   surface on `rejected`. Callers wanting a hard cut (no rejection
- *   signal) can wrap their publish path with `valve`.
- *
- * **Strategy-key axis (DS-13.I):** when `harnessLoop` is wired to a
- * spawnable, downstream `strategy.record(...)` calls should pass the
- * spawning agent's `presetId` for the {@link strategyKey} first axis.
- * Single-agent harness keeps using {@link DEFAULT_PRESET_ID} as before.
- *
- * @example
- * ```ts
- * const hub = messagingHub("hub");
- * const presets = presetRegistry<AgentSpec<string, LLMResponse>>();
- * presets.put("researcher", { name: "researcher", adapter: openai, systemPrompt: "..." });
- * presets.put("coder", { name: "coder", adapter: anthropic, systemPrompt: "..." });
- *
- * const sp = spawnable({ hub, registry: presets, depthCap: 5 });
- *
- * // Trigger a spawn:
- * sp.spawnTopic.publish({
- *   id: "req-42",
- *   payload: { presetId: "researcher", taskInput: "what is reactive graph composition?" },
- * });
- *
- * // Observe active agents:
- * sp.activeSlot.subscribe((msgs) => { ... });
- *
- * // Observe rejections:
- * sp.rejected.events.subscribe((msgs) => { ... });
- * ```
- *
- * @category patterns
- */
-export function spawnable<TIn = string, TOut = LLMResponse>(
-	opts: SpawnableOpts<TIn, TOut>,
-): SpawnableBundle<TIn, TOut> {
-	const graph = new SpawnableGraph<TIn, TOut>(opts);
-	opts.hub.mount(opts.name ?? "spawnable", graph);
-	return {
-		spawnTopic: graph.spawnTopic,
-		activeSlot: graph.activeSlot,
-		rejected: graph.rejected,
-		graph,
-	};
-}
diff --git a/src/presets/harness/trace.ts b/src/presets/harness/trace.ts
deleted file mode 100644
index f6d4b7e4..00000000
--- a/src/presets/harness/trace.ts
+++ /dev/null
@@ -1,193 +0,0 @@
-/**
- * Harness pipeline trace — thin sugar over `graph.observe({ format: "stage-log" })`.
- *
- * Since 2026-04-22 (D2), stage-labeled tracing is a first-class observe format
- * on {@link Graph}. `harnessTrace` wires that format over the 7 pipeline stages
- * (INTAKE → TRIAGE → QUEUE → GATE → EXECUTE → VERIFY → STRATEGY) with sensible
- * defaults so harness consumers don't need to restate the stage map.
- *
- * For non-harness graphs, call `graph.observe({ format: "stage-log", stageLabels })`
- * directly — the format is domain-agnostic.
- *
- * @module
- */
-
-import { monotonicNs } from "@graphrefly/pure-ts/core";
-import type { ObserveEvent, ObserveResult } from "@graphrefly/pure-ts/graph";
-import type { HarnessGraph } from "./harness-loop.js";
-
-// ---------------------------------------------------------------------------
-// Types
-// ---------------------------------------------------------------------------
-
-/** Event type captured by structured trace. */
-export type TraceEventType = "data" | "error" | "complete";
-
-/** A single structured trace event. */
-export interface TraceEvent {
-	/** Elapsed seconds since trace was created. */
-	elapsed: number;
-	/** Pipeline stage label (INTAKE, TRIAGE, QUEUE, GATE, EXECUTE, VERIFY, STRATEGY). */
-	stage: string;
-	/** Event type. */
-	type: TraceEventType;
-	/** Data payload (present for "data" and "error" events). Omitted at "summary" detail. */
-	data?: unknown;
-	/** Human-readable summary of the data. Present at "standard" and "full" detail. */
-	summary?: string;
-}
-
-/** Detail level for trace output. */
-export type TraceDetail =
-	/** Stage + elapsed only. No data preview. Lowest overhead. */
-	| "summary"
-	/** Stage + elapsed + truncated data preview. Default. */
-	| "standard"
-	/** Stage + elapsed + full raw data. Use for debugging, not production. */
-	| "full";
-
-/** Handle returned by {@link harnessTrace}. Call `dispose()` to stop tracing. */
-export interface HarnessTraceHandle {
-	/** Stop tracing and detach all observers. Safe to call multiple times. */
-	dispose(): void;
-	/**
-	 * Structured trace events collected since creation. Plain array — no
-	 * subscription needed (COMPOSITION-GUIDE §1: avoid lazy-activation
-	 * friction for inspection tools). Populated reactively via observe().
-	 */
-	readonly events: readonly TraceEvent[];
-}
-
-/** Options for {@link harnessTrace}. */
-export interface HarnessTraceOptions {
-	/** Sink for rendered trace lines. Default: `console.log`. Pass `null` for structured-only. */
-	logger?: ((line: string) => void) | null;
-	/** Detail level for both string and structured output. Default: `"summary"`. */
-	detail?: TraceDetail;
-}
-
-// ---------------------------------------------------------------------------
-// Stage labels
-// ---------------------------------------------------------------------------
-
-/**
- * Observe paths → stage labels for the 7 harness stages. Path set is
- * sourced from {@link HarnessGraph.stageNodes} so inspection tools stay
- * decoupled from mount-structure changes (Unit 22 C).
- */
-function buildStageLabels(harness: HarnessGraph): Record<string, string> {
-	const labels: Record<string, string> = {};
-	for (const { label, paths } of harness.stageNodes()) {
-		for (const p of paths) labels[p] = label;
-	}
-	return labels;
-}
-
-// ---------------------------------------------------------------------------
-// Implementation
-// ---------------------------------------------------------------------------
-
-/**
- * Attach a stage-log trace over the harness pipeline. Delegates to
- * `harness.observe({ format: "stage-log", ... })` for each stage path —
- * every event is captured in `handle.events` (structured) AND rendered via
- * the `logger` (string output).
- *
- * **Detail levels:**
- * - `"summary"` — stage + elapsed only. Minimal overhead.
- * - `"standard"` (default) — stage + elapsed + truncated data preview.
- * - `"full"` — stage + elapsed + full raw data object in events.
- *
- * Elapsed timestamps are relative to the `harnessTrace()` invocation time,
- * not the first event.
- */
-export function harnessTrace(
-	harness: HarnessGraph,
-	opts?: HarnessTraceOptions,
-): HarnessTraceHandle {
-	const logger: ((line: string) => void) | null =
-		opts?.logger === null ? null : (opts?.logger ?? console.log);
-	const detail: TraceDetail = opts?.detail ?? "summary";
-	const startNs = monotonicNs();
-	const observations: ObserveResult[] = [];
-	const events: TraceEvent[] = [];
-	const stageLabels = buildStageLabels(harness);
-
-	function elapsedSecs(): number {
-		return (monotonicNs() - startNs) / 1e9;
-	}
-
-	function recordEvent(stage: string, type: TraceEventType, rawData: unknown): void {
-		const ev: TraceEvent = { elapsed: elapsedSecs(), stage, type };
-		if (detail !== "summary") ev.summary = summarize(rawData);
-		if (detail === "full") ev.data = rawData;
-		events.push(ev);
-	}
-
-	// One observe call per path — keeps per-stage elapsed offsets anchored to
-	// this invocation (the shared stage-log format uses its own elapsed clock
-	// per observation, which matches the legacy behavior). We also intercept
-	// each event through `onEvent` so structured `events[]` stays populated
-	// regardless of `logger`.
-	for (const [path, stage] of Object.entries(stageLabels)) {
-		try {
-			const obs = harness.observe(path, {
-				format: "stage-log",
-				stageLabels,
-				logger: logger ? (line: string) => logger(line) : () => {},
-				includeTypes: ["data", "error", "complete"],
-			});
-			obs.onEvent((event: ObserveEvent) => {
-				if (event.type === "data") recordEvent(stage, "data", (event as { data: unknown }).data);
-				else if (event.type === "error")
-					recordEvent(stage, "error", (event as { data: unknown }).data);
-				else if (event.type === "complete") recordEvent(stage, "complete", undefined);
-			});
-			observations.push(obs);
-		} catch (err) {
-			// Node may not exist yet (e.g., a gated-queue route that hasn't been
-			// mounted on this harness). Record a synthetic error trace event so
-			// consumers see WHICH stage dropped out and why — silent swallow
-			// breaks dry-run equivalence (a regression in stage wiring would
-			// not surface in the trace).
-			const msg = err instanceof Error ? err.message : String(err);
-			recordEvent(stage, "error", `observe-unavailable: ${path} — ${msg}`);
-			if (logger) {
-				logger(`[${elapsedSecs().toFixed(3)}s] ${stage.padEnd(9)} ✗ observe-unavailable: ${msg}`);
-			}
-		}
-	}
-
-	return {
-		get events(): readonly TraceEvent[] {
-			return events;
-		},
-		dispose() {
-			for (const obs of observations) obs.dispose();
-			observations.length = 0;
-		},
-	};
-}
-
-// ---------------------------------------------------------------------------
-// Helpers — kept here because `observe({ format: "stage-log" })` emits short
-// one-line previews; the structured `events[]` is free to carry richer
-// summaries with different truncation bounds (120 for JSON, 80 for strings).
-// ---------------------------------------------------------------------------
-
-function summarize(value: unknown): string {
-	if (value == null) return "null";
-	if (typeof value === "string") return truncate(value, 80);
-	if (typeof value === "number" || typeof value === "boolean") return String(value);
-	if (typeof value === "bigint") return String(value);
-	try {
-		const json = JSON.stringify(value);
-		return truncate(json, 120);
-	} catch {
-		return String(value);
-	}
-}
-
-function truncate(s: string, max: number): string {
-	return s.length > max ? `${s.slice(0, max - 1)}…` : s;
-}
diff --git a/src/presets/index.ts b/src/presets/index.ts
deleted file mode 100644
index 8ff0f163..00000000
--- a/src/presets/index.ts
+++ /dev/null
@@ -1,12 +0,0 @@
-/**
- * Presets layer — opinionated compositions of utils.
- *
- * Headline factory re-exports. For full catalog see solutions/index.ts.
- *
- * @module
- */
-
-export * from "./ai/index.js";
-export * from "./harness/index.js";
-export * from "./inspect/index.js";
-export * from "./resilience/index.js";
diff --git a/src/presets/inspect/composite.ts b/src/presets/inspect/composite.ts
deleted file mode 100644
index 2eb87ecf..00000000
--- a/src/presets/inspect/composite.ts
+++ /dev/null
@@ -1,270 +0,0 @@
-/**
- * `inspect()` preset — Tier 9.1 γ-form γ-II + Q5-6 medium scope.
- *
- * Composes graph observability into a single mounted facade:
- *   - `lens` (mounted as a `LensSubgraph` child) — exposes `topology` /
- *     `health` / `flow` Nodes via `inspect.lens.*`.
- *   - `audit` (mounted `AuditTrailGraph`) — every mutation on the wrapped
- *     target captured as an audit entry.
- *   - `explainTarget(from, to, opts?)` — facade over
- *     `target.describe({ explain: {...} })`; supports both static and
- *     reactive forms.
- *   - `complianceSnapshot()` — one-shot tamper-evident snapshot pairing the
- *     target's persisted state with the audit log.
- *
- * **Path-namespace boundary.** `inspect.describe()` shows InspectGraph's
- * OWN topology (the lens + audit subgraphs and any caller-added siblings) —
- * NOT the wrapped target's topology. Use `inspect.target.describe()` to
- * walk the target. `inspect.node("counter")` resolves under the inspect
- * graph, NOT the target.
- *
- * **Why a Graph subclass.** Per Tier 9.1 γ-II lock: closure-bundled returns
- * (`{lens, audit, explain, ...}` of independently-constructed primitives)
- * hide topology — `describe()` from the wrapper can't walk into the
- * audit/lens pieces. Mounting them under a real `InspectGraph` keeps every
- * contained primitive visible in describe / explain across the boundary,
- * which is the point of the inspect preset.
- *
- * **Why the lens lives in a child `LensSubgraph` mount.** `Graph.destroy()`
- * signals TEARDOWN through `this._nodes` after disposers drain. If the
- * lens nodes were `add()`ed directly to InspectGraph's path table, they
- * would receive TEARDOWN at parent destroy — invalidating any externally
- * held `view.lens.topology.subscribe(...)` reference. Mounting via a child
- * subgraph contains the cascade: inspect's TEARDOWN visits the lens
- * subgraph's nodes through `mount → child._destroyClearOnly`, which clears
- * structure but does NOT broadcast TEARDOWN. The `lens.dispose()` disposer
- * still tears down the underlying observe handle as designed (D1 fix per
- * /qa lock).
- *
- * **Why `inspect()` mounts `graphLens` rather than rebuilding `health` / `flow`.**
- * Per Q3 yellow lock: rebuilding would duplicate the `topology → health`
- * and `dataFlow → flow` deriveds, doubling subscription cost and risking
- * semantic drift. Mounting graphLens once lets `inspect.lens` and the
- * standalone `graphLens(target)` factory share a single source of truth.
- *
- * @module
- */
-
-import type { Actor, Node } from "@graphrefly/pure-ts/core";
-import { placeholderArgs } from "@graphrefly/pure-ts/core";
-import { type CausalChain, Graph } from "@graphrefly/pure-ts/graph";
-import {
-	type AuditTrailGraph,
-	type AuditTrailOptions,
-	auditTrail,
-	type ComplianceSnapshotResult,
-	complianceSnapshot,
-	type PolicyGateGraph,
-} from "../../utils/inspect/audit.js";
-import { type GraphLensView, graphLens } from "../../utils/inspect/lens.js";
-
-/** Options for {@link inspect}. */
-export interface InspectOptions {
-	/** Default actor recorded on `complianceSnapshot()` calls. */
-	actor?: Actor;
-	/**
-	 * Forwarded to the mounted {@link auditTrail} so callers can configure
-	 * retention / inclusion policy. Pre-allocated to keep `inspect()`
-	 * callable with no opts.
-	 */
-	audit?: AuditTrailOptions;
-	/** Optional name override for the `InspectGraph` itself. */
-	name?: string;
-}
-
-/**
- * Thin Graph-subclass shell that owns the `graphLens(target)` Nodes so
- * inspect's TEARDOWN cascade reaches them via `_destroyClearOnly` (which
- * clears structure WITHOUT broadcasting TEARDOWN) instead of via
- * `signal([[TEARDOWN]])` (which DOES broadcast and would invalidate any
- * externally held lens-node subscription).
- *
- * @internal
- */
-class LensSubgraph extends Graph {
-	readonly view: GraphLensView;
-
-	constructor(target: Graph) {
-		super("lens");
-		this.view = graphLens(target);
-		this.add(this.view.topology, { name: "topology" });
-		this.add(this.view.health, { name: "health" });
-		this.add(this.view.flow, { name: "flow" });
-	}
-}
-
-/**
- * Graph subclass returned by {@link inspect}. Mounts a `graphLens` view (as
- * a child `LensSubgraph`), an `auditTrail` (as a child subgraph), and
- * exposes `explainTarget()` + `complianceSnapshot()` facades over the
- * wrapped target.
- *
- * Mounted children (visible in `describe()`):
- *   - `lens::topology` / `lens::health` / `lens::flow` — `graphLens(target)` Nodes.
- *   - `audit::*` — the mounted {@link AuditTrailGraph}.
- *
- * @category observability
- */
-export class InspectGraph extends Graph {
-	readonly target: Graph;
-	/**
-	 * Underlying lens view — reach individual Nodes via
-	 * `inspect.lens.topology` / `inspect.lens.health` / `inspect.lens.flow`.
-	 *
-	 * Direct `inspect.topology` / `inspect.health` / `inspect.flow`
-	 * accessors are NOT shipped because `Graph.topology` is already an
-	 * accessor on the base class with a different shape (`Node<TopologyEvent>`
-	 * — the mount/unmount stream of THIS graph, not the wrapped target's
-	 * describe snapshot). Going through `.lens.*` keeps the two concepts
-	 * cleanly separated.
-	 */
-	readonly lens: GraphLensView;
-	/** Mounted audit trail subgraph. */
-	readonly audit: AuditTrailGraph;
-
-	private readonly _defaultActor?: Actor;
-	private readonly _lensSubgraph: LensSubgraph;
-
-	constructor(target: Graph, opts: InspectOptions = {}) {
-		super(opts.name ?? `inspect(${target.name})`);
-		this.target = target;
-		this._defaultActor = opts.actor;
-
-		// D1 (qa lock): lens lives inside a child mount so `inspect.destroy()`'s
-		// TEARDOWN signal cascade reaches the lens nodes via
-		// `_destroyClearOnly` (no broadcast) rather than via `_signalDeliver`
-		// over `inspect._nodes` (which WOULD broadcast). External holders of
-		// `view.lens.topology.subscribe(...)` see only the `lens.dispose()`
-		// teardown of the underlying observe handle, not a stray TEARDOWN
-		// from inspect's path table.
-		this._lensSubgraph = new LensSubgraph(target);
-		this.lens = this._lensSubgraph.view;
-		this.mount("lens", this._lensSubgraph);
-
-		this.audit = auditTrail(target, opts.audit ?? {});
-		this.mount("audit", this.audit);
-
-		// Tear down the lens's underlying observe subscription on destroy.
-		// The mounted subgraphs themselves tear down via mount lifecycle.
-		this.addDisposer(() => this.lens.dispose());
-	}
-
-	/**
-	 * Causal-chain facade over `target.describe({ explain: {...} })`. Supports
-	 * both static (one-shot {@link CausalChain}) and reactive
-	 * (`{ reactive: true }`) forms.
-	 *
-	 * Named `explainTarget` (not folded into a `describe` mode on this class)
-	 * because `inspect.describe(...)` walks `InspectGraph`'s OWN topology
-	 * (lens + audit subgraphs) rather than the wrapped target's. Use
-	 * `inspect.explainTarget(...)` for chains across the wrapped graph;
-	 * `inspect.describe({ explain: {...} })` for chains across the lens /
-	 * audit composition.
-	 */
-	explainTarget(
-		from: string | Node<string>,
-		to: string | Node<string>,
-		opts?: {
-			maxDepth?: number | Node<number>;
-			findCycle?: boolean | Node<boolean>;
-		},
-	): CausalChain;
-	explainTarget(
-		from: string | Node<string>,
-		to: string | Node<string>,
-		opts: {
-			reactive: true;
-			maxDepth?: number | Node<number>;
-			findCycle?: boolean | Node<boolean>;
-			name?: string;
-		},
-	): { node: Node<CausalChain>; dispose: () => void };
-	explainTarget(
-		from: string | Node<string>,
-		to: string | Node<string>,
-		opts?: {
-			reactive?: boolean;
-			maxDepth?: number | Node<number>;
-			findCycle?: boolean | Node<boolean>;
-			name?: string;
-		},
-	): CausalChain | { node: Node<CausalChain>; dispose: () => void } {
-		// Cast through the discriminated overload — TypeScript can't pick a
-		// signature on `target.describe({explain})` because `opts` has the
-		// union shape (reactive: boolean | undefined).
-		const explainArg: {
-			from: string | Node<string>;
-			to: string | Node<string>;
-			maxDepth?: number | Node<number>;
-			findCycle?: boolean | Node<boolean>;
-		} = { from, to };
-		if (opts?.maxDepth !== undefined) explainArg.maxDepth = opts.maxDepth;
-		if (opts?.findCycle !== undefined) explainArg.findCycle = opts.findCycle;
-		const describeOpts: Record<string, unknown> = { explain: explainArg };
-		if (opts?.reactive === true) describeOpts.reactive = true;
-		if (opts?.name !== undefined) describeOpts.name = opts.name;
-		return (
-			this.target.describe as unknown as (
-				o: typeof describeOpts,
-			) => CausalChain | { node: Node<CausalChain>; dispose: () => void }
-		)(describeOpts);
-	}
-
-	/**
-	 * One-shot tamper-evident snapshot pairing the target's persisted state
-	 * with the audit log + (optional) policy-gate violations.
-	 *
-	 * Uses the inspect's mounted `audit` by default; pair with a separate
-	 * `policyGate` (mounted elsewhere) by passing `policies` explicitly.
-	 *
-	 * **Cryptographic strength caveat (echoed from {@link complianceSnapshot}):**
-	 * the returned `fingerprint` is a truncated SHA-256 (16 hex chars / ~64
-	 * bits) optimized for compact archival. Sufficient for casual integrity
-	 * checks and content-addressed dedup; for adversarial tamper-evidence,
-	 * pair with a full SHA-256 over the canonical JSON externally.
-	 */
-	complianceSnapshot(opts?: {
-		actor?: Actor;
-		policies?: PolicyGateGraph;
-	}): ComplianceSnapshotResult {
-		const actor = opts?.actor ?? this._defaultActor;
-		return complianceSnapshot(this.target, {
-			audit: this.audit,
-			...(actor != null ? { actor } : {}),
-			...(opts?.policies != null ? { policies: opts.policies } : {}),
-		});
-	}
-}
-
-/**
- * Build an {@link InspectGraph} that mounts `graphLens` + `auditTrail` over
- * the wrapped target and exposes `explainTarget()` + `complianceSnapshot()`
- * facades.
- *
- * @example
- * ```ts
- * import { inspect } from "@graphrefly/graphrefly/presets/inspect";
- *
- * const target = buildMyApp();
- * const view = inspect(target, { actor: { id: "ops-bot", role: "monitor" } });
- *
- * // Live observability
- * view.lens.health.subscribe((msgs) => console.log("health:", msgs));
- * view.lens.flow.subscribe((msgs) => console.log("flow:", msgs));
- *
- * // Causal explainability across the wrapped target
- * const chain = view.explainTarget("input", "output");
- *
- * // Tamper-evident snapshot for archival
- * const snapshot = view.complianceSnapshot();
- * ```
- *
- * @category observability
- */
-export function inspect(target: Graph, opts: InspectOptions = {}): InspectGraph {
-	const g = new InspectGraph(target, opts);
-	// A1 (qa lock): self-tag so `inspect.describe().factory === "inspect"`,
-	// matching the policyGate / pipelineGraph / harnessLoop precedent.
-	g.tagFactory("inspect", placeholderArgs(opts as unknown as Record<string, unknown>));
-	return g;
-}
diff --git a/src/presets/inspect/guarded-execution.ts b/src/presets/inspect/guarded-execution.ts
deleted file mode 100644
index 0fdb83a9..00000000
--- a/src/presets/inspect/guarded-execution.ts
+++ /dev/null
@@ -1,449 +0,0 @@
-/**
- * Composable safety layer (roadmap §9.0b — Tier 5.1 Wave-B rebuild).
- *
- * {@link guardedExecution} wraps any {@link Graph} with:
- *
- * - {@link policyGate} — reactive ABAC (Tier 2.3 rename of `policyEnforcer`),
- *   policies stored as a `Node` so LLMs / humans can update them at runtime.
- *   Full transitive dynamic coverage via `watchTopologyTree`.
- * - Reactive {@link GuardedExecutionGraph.scopedDescribeNode} — a thin
- *   delegate over `target.describe({ reactive: true, actor })` that re-derives
- *   on every settle (topology change, error transition, actor swap).
- * - The enforcer's `violations` topic is republished as `violations` on
- *   the wrapper, composable with {@link graphLens}'s `health`.
- * - The wrapper-level `lints` topic surfaces non-policy diagnostic warnings
- *   (`empty-policies` / `audit-no-effect` / `no-actor`) so misconfigurations
- *   are caught reactively rather than via thrown errors at scattered call sites.
- * - The `scope` derived publishes the current configuration tuple
- *   (`{actor, mode, policiesCount}`) for dashboards.
- *
- * V1 scope: policies + actor + reactive scoped describe + lints + scope.
- * Budget-as-option is NOT in V1 — it requires a cost-tracking design that
- * hasn't landed yet. Callers who need a budget limit today append a
- * budget-aware {@link PolicyRuleData} to the policies list (check current
- * cost and `deny` when exhausted).
- *
- * @module
- */
-import type { Actor, PolicyRuleData } from "@graphrefly/pure-ts/core";
-import { DATA, monotonicNs, type Node, node } from "@graphrefly/pure-ts/core";
-import { keepalive } from "@graphrefly/pure-ts/extra";
-import {
-	type DescribeFilter,
-	Graph,
-	type GraphDescribeOptions,
-	type GraphDescribeOutput,
-	type GraphOptions,
-} from "@graphrefly/pure-ts/graph";
-import { domainMeta } from "../../base/meta/domain-meta.js";
-import {
-	type PolicyGateGraph,
-	type PolicyViolation,
-	policyGate,
-} from "../../utils/inspect/audit.js";
-import { TopicGraph } from "../../utils/messaging/index.js";
-
-function isNode<T>(x: unknown): x is Node<T> {
-	return (
-		typeof x === "object" && x !== null && "subscribe" in (x as object) && "down" in (x as object)
-	);
-}
-
-function guardedMeta(kind: string): Record<string, unknown> {
-	return domainMeta("guarded", kind);
-}
-
-/** Diagnostic warning published on {@link GuardedExecutionGraph.lints}. */
-export interface GuardedExecutionLint {
-	/**
-	 * - `"empty-policies"` — `policies` Node emitted an empty array in
-	 *   `mode: "enforce"`. Static empty arrays throw at construction; this
-	 *   covers the reactive case.
-	 * - `"audit-no-effect"` — `mode: "audit"` plus the target has no per-node
-	 *   guards, so `scopedDescribeNode` filters by per-node guards only and
-	 *   policies will never gate visibility (they still populate `violations`
-	 *   on writes).
-	 * - `"no-actor"` — neither a wrapper-configured nor per-call actor was
-	 *   supplied. `scopedDescribeNode` falls back to "describe everything"
-	 *   for the corresponding subscription.
-	 */
-	kind: "empty-policies" | "audit-no-effect" | "no-actor";
-	message: string;
-	timestamp_ns: number;
-}
-
-/** Configuration tuple published on {@link GuardedExecutionGraph.scope}. */
-export interface GuardedScope {
-	/** The wrapper-configured default actor, or `null` when none configured. */
-	actor: Actor | null;
-	mode: "audit" | "enforce";
-	/** Current policy count (reactive — re-emits on `policies` Node updates). */
-	policiesCount: number;
-}
-
-/** Options for {@link guardedExecution}. */
-export interface GuardedExecutionOptions {
-	/**
-	 * Policies enforced against every guarded write. Static list or a live
-	 * `Node<readonly PolicyRuleData[]>` (LLM-updatable).
-	 *
-	 * **Empty-policies handling:**
-	 * - Static empty array + `mode: "enforce"` throws `RangeError` at
-	 *   construction (deny-by-default is almost certainly a misconfiguration).
-	 * - Node-supplied empty array + `mode: "enforce"` emits a one-time
-	 *   `"empty-policies"` lint on first such emission (the wrapper can't
-	 *   throw mid-run — surface the warning reactively).
-	 * - `mode: "audit"` tolerates empty policies (no guards stacked; policies
-	 *   only feed the `violations` channel on writes).
-	 */
-	policies: readonly PolicyRuleData[] | Node<readonly PolicyRuleData[]>;
-	/**
-	 * Default actor used when the caller invokes
-	 * {@link GuardedExecutionGraph.scopedDescribeNode} without an override.
-	 * Accepts a static {@link Actor} or a `Node<Actor>` — when a Node is
-	 * supplied, the reactive describe re-derives on every actor emission so
-	 * harnesses binding a per-turn actor get a single live describe Node
-	 * instead of re-creating one per turn.
-	 *
-	 * Omit to scope per-call only. A `"no-actor"` lint fires once per instance
-	 * if neither a configured nor per-call actor is ever supplied (the
-	 * resulting describe is unscoped — full visibility).
-	 */
-	actor?: Actor | Node<Actor>;
-	/**
-	 * `"enforce"` (default) — push guards onto target nodes so disallowed
-	 * writes throw {@link GuardDenied}.
-	 * `"audit"` — record would-be denials to the `violations` topic without
-	 * blocking writes.
-	 */
-	mode?: "audit" | "enforce";
-	/** Ring-buffer cap for the `violations` topic. Default 1000 (inherited from policyGate). */
-	violationsLimit?: number;
-	/** Ring-buffer cap for the `lints` topic. Default 64 — each lint kind fires at most once per instance. */
-	lintsLimit?: number;
-	/** Wrapper graph name. Default `${target.name}_guarded`. */
-	name?: string;
-	/** Wrapper graph options. */
-	graph?: GraphOptions;
-}
-
-/**
- * Wrapper over a target {@link Graph} providing reactive ABAC + reactive
- * scoped describe + diagnostic lints. Mounts a {@link PolicyGateGraph} under
- * `enforcer`, a {@link TopicGraph} of {@link GuardedExecutionLint} under
- * `lints`, and a `scope` derived publishing `{actor, mode, policiesCount}`.
- *
- * @category patterns
- */
-export class GuardedExecutionGraph extends Graph {
-	readonly enforcer: PolicyGateGraph;
-	readonly violations: TopicGraph<PolicyViolation>;
-	readonly lints: TopicGraph<GuardedExecutionLint>;
-	readonly scope: Node<GuardedScope>;
-	/**
-	 * Canonical reactive describe scoped to the wrapper's configured `actor`.
-	 * Subscribes ONCE at construction; lifecycle owned by the wrapper (disposed
-	 * on `wrapper.destroy()`). Use this property for the common case
-	 * (long-lived consumer wanting "describe scoped to my actor"); use
-	 * {@link scopedDescribeNode} only when a per-call actor override or
-	 * different `detail`/`fields` is required.
-	 *
-	 * Re-derives on every settle of the target graph: structural changes,
-	 * status transitions (errors flip nodes into `"errored"`), and actor
-	 * emissions (when a `Node<Actor>` is bound, including the SENTINEL bridge
-	 * applied internally — see qa G1B).
-	 */
-	readonly scopedDescribe: Node<GraphDescribeOutput>;
-	private readonly _target: Graph;
-	private readonly _actorNode: Node<Actor | null>;
-	private readonly _mode: "audit" | "enforce";
-	private readonly _firedLintKinds = new Set<GuardedExecutionLint["kind"]>();
-
-	constructor(target: Graph, opts: GuardedExecutionOptions) {
-		super(opts.name ?? `${target.name}_guarded`, opts.graph);
-		this._target = target;
-		this._mode = opts.mode ?? "enforce";
-
-		const policiesOpt = opts.policies;
-		const policiesIsNode = isNode<readonly PolicyRuleData[]>(policiesOpt);
-		// Static empty + enforce → throw (deny-by-default = misconfig).
-		if (
-			!policiesIsNode &&
-			this._mode === "enforce" &&
-			(policiesOpt as readonly PolicyRuleData[]).length === 0
-		) {
-			throw new RangeError(
-				'guardedExecution: empty `policies` in `mode: "enforce"` denies every action. ' +
-					'Pass at least `{ effect: "allow", action: "*" }` and layer deny rules on top.',
-			);
-		}
-
-		// Lints topic — mounted before any potential first-DATA emission.
-		this.lints = new TopicGraph<GuardedExecutionLint>("lints", {
-			retainedLimit: opts.lintsLimit ?? 64,
-		});
-		this.mount("lints", this.lints);
-
-		// Normalize `actor` to a Node<Actor | null>. `null` (a valid DATA in
-		// the v5 sentinel-as-undefined model) means "no actor configured" —
-		// `target.describe({ reactive: true })`'s `resolveActorOption` treats
-		// `null` cache as "no scoping" (full visibility), and the `scope`
-		// derived can publish `actor: null` cleanly. Using `node([], { initial: undefined })`
-		// here would leave the actor node in sentinel state, which never fires
-		// DATA on subscribe and would block the `scope` derived's first-run
-		// gate from completing.
-		//
-		// qa G1B (EC2 fix): when the caller passes a `Node<Actor>`, that node's
-		// cache may itself be SENTINEL at construction (e.g. a `producer`
-		// awaiting first emission, or a deferred `derived`). Forwarding the raw
-		// Node would re-introduce the same sentinel-stall on `scope`. Bridge
-		// through a node bridge with a `null` initial so the
-		// internal `_actorNode` always carries non-sentinel cache; the bridge
-		// re-emits whenever the caller's Node emits, and forwards `null`
-		// through unchanged.
-		const actorOpt = opts.actor;
-		if (actorOpt == null) {
-			this._actorNode = node<Actor | null>([], { name: "actor", initial: null });
-		} else if (isNode<Actor>(actorOpt)) {
-			this._actorNode = node<Actor | null>(
-				[actorOpt],
-				(batchData, actions, ctx) => {
-					const data = batchData.map((batch, i) =>
-						batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-					);
-					actions.emit((data[0] as Actor | null | undefined) ?? null);
-				},
-				{ describeKind: "derived", name: "actor", initial: null },
-			);
-		} else {
-			this._actorNode = node<Actor | null>([], { name: "actor", initial: actorOpt });
-		}
-
-		// Mount the enforcer.
-		const enforcerOpts: { mode: "audit" | "enforce"; name: string; violationsLimit?: number } = {
-			mode: this._mode,
-			name: "enforcer",
-		};
-		if (opts.violationsLimit != null) enforcerOpts.violationsLimit = opts.violationsLimit;
-		this.enforcer = policyGate(target, opts.policies, enforcerOpts);
-		this.violations = this.enforcer.violations;
-		this.mount("enforcer", this.enforcer);
-
-		// Empty-policies one-time lint (Node form, enforce mode only).
-		if (policiesIsNode && this._mode === "enforce") {
-			const policiesNode = policiesOpt as Node<readonly PolicyRuleData[]>;
-			// Two paths here intentionally:
-			//   (1) Synchronous cache seed — fires immediately if the Node was
-			//       constructed with an empty array as its current cache. This
-			//       covers `node<…[]>([], { initial: [] })` and any pre-emitted derived.
-			//   (2) Subscribe path — catches subsequent empty emissions AND
-			//       handles the SENTINEL case (cache=undefined at construction)
-			//       where the Node fires its first DATA after the wrapper is
-			//       built. The `_firedLintKinds` Set keeps the lint one-shot
-			//       across both paths.
-			// qa F6 (deferred): if a Node's initial cache is SENTINEL (undefined)
-			// AND it never emits an empty array (only ever non-empty), the lint
-			// never fires — that's correct behavior, the configuration is
-			// effectively non-empty for the wrapper's lifetime.
-			const cached = policiesNode.cache as readonly PolicyRuleData[] | undefined;
-			if (cached != null && cached.length === 0) {
-				this._fireLint(
-					"empty-policies",
-					'`policies` Node cached an empty array in `mode: "enforce"` — every action will be denied. Add at least one allow rule.',
-				);
-			}
-			const offEmpty = policiesNode.subscribe((msgs) => {
-				for (const m of msgs) {
-					if (m[0] !== DATA) continue;
-					const v = m[1] as readonly PolicyRuleData[] | undefined;
-					if (v == null || v.length === 0) {
-						this._fireLint(
-							"empty-policies",
-							'`policies` Node emitted an empty array in `mode: "enforce"` — every action will be denied. Add at least one allow rule.',
-						);
-					}
-				}
-			});
-			this.addDisposer(offEmpty);
-		}
-
-		// Audit-mode + no per-node guards on the target → fire once.
-		// qa EC5 (deferred): the check is one-shot at construction. If the
-		// caller later mounts a guarded node into the target, the lint stays
-		// retained even though the configuration is now effective. Recommended
-		// pattern: mount per-node guards on the target BEFORE wrapping.
-		// Reactive recompute (subscribe to target.topology, clear lint when a
-		// guard appears) is filed in `docs/optimizations.md` as a follow-up.
-		if (this._mode === "audit") {
-			const described = target.describe({ detail: "full" });
-			const anyGuard = Object.values(described.nodes).some((n) => n.guard != null);
-			if (!anyGuard) {
-				this._fireLint(
-					"audit-no-effect",
-					'`mode: "audit"` + target has no per-node guards — `scopedDescribeNode` filters by per-node guards only, so policy rules will not affect describe() visibility. Policies still populate the `violations` topic on writes.',
-				);
-			}
-		}
-
-		// No-actor lint: fires at construction when neither configured nor
-		// implicitly carried via a Node-cache. Per-call overrides on
-		// `scopedDescribeNode` cannot retroactively suppress this — the
-		// configured-default branch is what callers most often miss.
-		if (actorOpt == null) {
-			this._fireLint(
-				"no-actor",
-				"no actor configured — `wrapper.scopedDescribe` and `scopedDescribeNode()` will return an unscoped describe (full visibility) unless a per-call actor is supplied.",
-			);
-		}
-
-		// Scope derived: live tuple of {actor, mode, policiesCount}.
-		this.scope = node<GuardedScope>(
-			[this._actorNode, this.enforcer.policies],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit({
-					actor: (data[0] as Actor | null | undefined) ?? null,
-					mode: this._mode,
-					policiesCount: (data[1] as readonly PolicyRuleData[]).length,
-				});
-			},
-			{
-				name: "scope",
-				describeKind: "derived",
-				meta: guardedMeta("scope"),
-			},
-		);
-		this.add(this.scope, { name: "scope" });
-		this.addDisposer(keepalive(this.scope));
-
-		// qa G1A "same concept": single canonical reactive describe bound to
-		// the configured actor, mounted once at construction. Removes the
-		// per-call handle proliferation from the prior `scopedDescribeNode`
-		// pattern (the method is retained as the per-call escape hatch). The
-		// reactive describe re-derives on actor swap / topology change /
-		// status transition; lifecycle owned by the wrapper.
-		const scopedHandle = target.describe({
-			reactive: true,
-			// F8 (resolved 2026-05-18): `GraphDescribeOptions.actor` is now
-			// `Actor | Node<Actor | null>`, so `_actorNode` (a
-			// `Node<Actor | null>`) passes without a cast. A `null`/`undefined`
-			// cache resolves to "no scoping" (full visibility) per
-			// `resolveActorOption`. See graph.ts § "Cache-undefined/null
-			// semantics".
-			actor: this._actorNode,
-			reactiveName: "scopedDescribe",
-		});
-		this.scopedDescribe = scopedHandle.node;
-		this.add(this.scopedDescribe, { name: "scopedDescribe" });
-		this.addDisposer(scopedHandle.dispose);
-	}
-
-	private _fireLint(kind: GuardedExecutionLint["kind"], message: string): void {
-		if (this._firedLintKinds.has(kind)) return;
-		this._firedLintKinds.add(kind);
-		this.lints.publish({ kind, message, timestamp_ns: monotonicNs() });
-	}
-
-	/**
-	 * **Per-call escape hatch.** Prefer {@link scopedDescribe} (the mounted
-	 * property) for the common case of "describe scoped to my actor." Use
-	 * this method ONLY when you need a per-call actor override or different
-	 * `detail`/`fields`/`filter`.
-	 *
-	 * Returns a live `Node<GraphDescribeOutput>` scoped to the supplied (or
-	 * configured) actor, plus an explicit `dispose` for caller-controlled
-	 * lifecycle. Re-derives on every settle of the target graph: structural
-	 * changes, status transitions, and actor emissions (when a `Node<Actor>`
-	 * is bound).
-	 *
-	 * **Lifecycle (qa G1A — EC1 fix).** Each call instantiates a fresh
-	 * `target.describe({reactive: true})` handle (with its own version state,
-	 * observe handle, transitive topology subscriptions, derived + keepalive).
-	 * The caller MUST invoke the returned `dispose()` when finished to release
-	 * these resources. Disposers ARE also tracked on the wrapper graph so
-	 * `wrapper.destroy()` cleans up any handles the caller forgot — but a
-	 * long-lived wrapper with heavy per-call usage will leak until destroy
-	 * unless `dispose()` is called explicitly.
-	 *
-	 * @param actorOverride - Optional per-call override. Static {@link Actor}
-	 *   or `Node<Actor>`. Omit to use the wrapper-configured default.
-	 * @param opts - Standard {@link GraphDescribeOptions} fields (`detail`,
-	 *   `fields`, `filter`). `actor` / `reactive` / `reactiveName` are
-	 *   controlled by the wrapper.
-	 * @returns `{node, dispose}` — `node` is the live describe Node; `dispose`
-	 *   tears down the underlying reactive describe subscription idempotently.
-	 */
-	scopedDescribeNode(
-		actorOverride?: Actor | Node<Actor>,
-		opts?: Omit<GraphDescribeOptions, "actor" | "reactive" | "reactiveName">,
-	): { node: Node<GraphDescribeOutput>; dispose: () => void } {
-		const actorNode =
-			actorOverride == null
-				? this._actorNode
-				: isNode<Actor>(actorOverride)
-					? actorOverride
-					: node<Actor>([], { name: "actor_override", initial: actorOverride });
-		const handle = this._target.describe({
-			reactive: true,
-			// F8 (resolved 2026-05-18): `actor` accepts `Node<Actor | null>`
-			// directly. `actorNode` is `_actorNode` (`Node<Actor | null>`) or
-			// an override (`Node<Actor>`/`Node<Actor | null>`); both assign
-			// without a cast. `_describeReactive` resolves via
-			// `resolveActorOption` (null/undefined cache → no scoping).
-			actor: actorNode,
-			...(opts ?? {}),
-		});
-		// Track on the wrapper as a safety net for callers who forget to
-		// dispose; explicit `dispose()` is still the canonical lifecycle path.
-		this.addDisposer(handle.dispose);
-		return { node: handle.node, dispose: handle.dispose };
-	}
-
-	/** The wrapped graph (escape hatch for tooling). */
-	get target(): Graph {
-		return this._target;
-	}
-}
-
-/**
- * Wrap a {@link Graph} with {@link policyGate} plus a reactive scoped describe
- * lens. Returns a {@link GuardedExecutionGraph} that can be mounted, diffed,
- * or composed with {@link graphLens}.
- *
- * @param target - The graph to guard.
- * @param opts - See {@link GuardedExecutionOptions}.
- *
- * @example
- * ```ts
- * const guarded = guardedExecution(app, {
- *   actor: node<Actor>([], { initial: { type: "human", id: "alice" } }), // reactive — re-derive on swap
- *   policies: [
- *     { effect: "allow", action: "read", actorType: "human" },
- *     { effect: "deny", action: "write", pathPattern: "system::*" },
- *   ],
- *   mode: "enforce",
- * });
- *
- * // Canonical: subscribe to the mounted reactive describe (no per-call leak).
- * guarded.scopedDescribe.subscribe((msgs) => { /* live describe per actor / topology change *\/ });
- * // Per-call escape hatch (different actor / detail) — caller manages dispose.
- * const detailed = guarded.scopedDescribeNode(undefined, { detail: "standard" });
- * try { detailed.node.subscribe(/* … *\/); } finally { detailed.dispose(); }
- * guarded.violations.events.subscribe(msgs => console.log("violations:", msgs));
- * guarded.lints.events.subscribe(msgs => console.warn("lints:", msgs));
- * guarded.scope.subscribe(msgs => console.log("scope:", msgs));
- * ```
- *
- * @category patterns
- */
-export function guardedExecution(
-	target: Graph,
-	opts: GuardedExecutionOptions,
-): GuardedExecutionGraph {
-	return new GuardedExecutionGraph(target, opts);
-}
-
-// Re-export types useful for call sites.
-export type { DescribeFilter };
diff --git a/src/presets/inspect/index.ts b/src/presets/inspect/index.ts
deleted file mode 100644
index dfcc72b5..00000000
--- a/src/presets/inspect/index.ts
+++ /dev/null
@@ -1,8 +0,0 @@
-/**
- * Inspect presets — opinionated compositions of inspect utils.
- *
- * @module
- */
-
-export * from "./composite.js";
-export * from "./guarded-execution.js";
diff --git a/src/presets/resilience/index.ts b/src/presets/resilience/index.ts
deleted file mode 100644
index e4f7baa1..00000000
--- a/src/presets/resilience/index.ts
+++ /dev/null
@@ -1,7 +0,0 @@
-/**
- * Resilience presets — opinionated compositions of resilience utils.
- *
- * @module
- */
-
-export * from "./resilient-pipeline.js";
diff --git a/src/presets/resilience/resilient-pipeline.ts b/src/presets/resilience/resilient-pipeline.ts
deleted file mode 100644
index e8b03e8f..00000000
--- a/src/presets/resilience/resilient-pipeline.ts
+++ /dev/null
@@ -1,537 +0,0 @@
-/**
- * Resilience composition with correct nesting order (roadmap §9.0b — Tier 5.2 Wave-B rebuild).
- *
- * {@link resilientPipeline} composes the resilience primitives from
- * `extra/resilience/` in the canonical nesting order:
- *
- * ```text
- *   rateLimit → budget → breaker → timeout → retry → fallback → status
- * ```
- *
- * Returns a {@link ResilientPipelineGraph} (Graph subclass) with mounted
- * intermediate nodes and per-layer status companions, replacing the prior
- * bundle return. Each intermediate is mounted under a stable name so
- * `pipeline.describe()` shows the resilience chain in topology snapshots,
- * mermaid renders, and `lens.health` aggregations.
- *
- * **Per-attempt timeout vs. retry ordering.** `timeout` is applied BEFORE
- * `retry` so each retry attempt resubscribes to a fresh deadline (per-attempt
- * semantics). If `timeout` wrapped `retry`, a single deadline would apply to
- * the entire retry chain — not what callers expect.
- *
- * **`breakerOnOpen` + `retry` interaction.** With `breakerOnOpen: "error"` AND
- * `retry`, retry sees `CircuitOpenError` and resubscribes; the next attempt
- * very likely also breaker-open → another error → retry burns its budget
- * against an open circuit. Either set retry's `backoff` long enough for the
- * breaker reset window OR keep the default `breakerOnOpen: "skip"` (emits
- * RESOLVED when open; downstream drops the beat without retry firing).
- *
- * **Reactive options (switchMap rebuild).** Every primitive option accepts a
- * `T | Node<T>` (precedent-aligned with `FallbackInput<T>`). When the caller
- * supplies a static value, the layer is built once at construction. When the
- * caller supplies a `Node<T>`, the pipeline subscribes via `switchMap` and
- * **rebuilds the layer on every option emission** — the chain stalls until
- * the option Node emits its first DATA. Each rebuild creates a fresh
- * primitive instance, so internal state is lost (rate-limiter pending buffer,
- * breaker failure count, retry attempt count, in-flight timeout). Per-layer
- * **companion Nodes** (`droppedCount`, `rateLimitState`, `breakerState`) are
- * therefore exposed ONLY for the static-options path. Primitive-side widening
- * (filed in `docs/optimizations.md` under "Tier 5.2 follow-up — primitive-side
- * reactive-options widening") will preserve internal state once it lands and
- * the pipeline will trivially forward Node-form options to the primitive.
- *
- * @module
- */
-import { ERROR, type Node, node, placeholderArgs } from "@graphrefly/pure-ts/core";
-import { switchMap } from "@graphrefly/pure-ts/extra";
-import { Graph, type GraphOptions } from "@graphrefly/pure-ts/graph";
-import { domainMeta } from "../../base/meta/domain-meta.js";
-import { NS_PER_MS } from "../../base/resilience/backoff.js";
-import {
-	type BreakerState,
-	type BudgetConstraint,
-	budgetGate,
-	type CircuitBreakerOptions,
-	circuitBreaker,
-	type FallbackInput,
-	fallback,
-	type NodeOrValue,
-	type RateLimiterOptions,
-	type RateLimiterState,
-	type RetryOptions,
-	type RetryState,
-	rateLimiter,
-	retry,
-	type StatusValue,
-	type TimeoutOptions,
-	type TimeoutState,
-	withBreaker,
-	withStatus,
-	withTimeout,
-} from "../../utils/resilience/index.js";
-
-// ---------------------------------------------------------------------------
-// Reactive-option helpers
-// ---------------------------------------------------------------------------
-
-/**
- * `T | Node<T>` for primitive options — precedent-aligned with
- * {@link FallbackInput} and `policyGate.policies`. When the caller supplies a
- * static value, the layer is built once at construction. When the caller
- * supplies a `Node<T>`, the pipeline subscribes via {@link switchMap}: the
- * layer is rebuilt on every option emission. **State-loss caveat:** each
- * rebuild creates a fresh primitive instance — `rateLimiter` loses its pending
- * buffer, `circuitBreaker` resets failure count, `retry` resets attempt
- * count, `timeout` cancels in-flight deadline. This is the documented
- * switchMap-pattern semantics; primitive-side widening (filed in
- * `docs/optimizations.md`) will preserve internal state once it lands and the
- * pipeline can forward Node-form options directly.
- *
- * Per-layer **companion Nodes** (`droppedCount`, `rateLimitState`,
- * `breakerState`) are exposed only for the static-options path — Node-form
- * leaves them as `undefined` because each rebuild creates new companion
- * instances and a switchMap-mirrored companion would track only the latest
- * bundle. Callers needing both reactive options AND companions wait for
- * primitive-side widening.
- */
-// NodeOrValue re-imported from utils/resilience (same type, avoid barrel duplicate).
-
-function isNode<T>(x: unknown): x is Node<T> {
-	return (
-		typeof x === "object" && x !== null && "subscribe" in (x as object) && "down" in (x as object)
-	);
-}
-
-/**
- * Validation shared by the static and reactive timeout paths. The reactive
- * path runs this inside the `switchMap` projection so an emitted bad value
- * surfaces as a thrown error at projection time (the consuming subscribe
- * routes it through the reactive ERROR channel rather than crashing
- * construction).
- */
-function assertTimeoutMsValid(ms: number): void {
-	if (ms <= 0) throw new RangeError("timeoutMs must be > 0");
-	// Guard against `timeoutMs * NS_PER_MS` overflowing
-	// `Number.MAX_SAFE_INTEGER` (~9.007e15). 9_000_000 ms ≈ 2.5 hours is a
-	// sane upper bound; callers needing longer deadlines should express them
-	// at the primitive level.
-	if (ms > 9_000_000) {
-		throw new RangeError(
-			"timeoutMs must be <= 9_000_000 (≈2.5h) to stay within safe ns arithmetic",
-		);
-	}
-}
-
-// ---------------------------------------------------------------------------
-// Options
-// ---------------------------------------------------------------------------
-
-/**
- * Options for {@link resilientPipeline}. Every layer is optional — omit a
- * field and that layer is skipped.
- *
- * Reactive (`Node<T>`) forms are accepted everywhere a primitive value would
- * fit; the pipeline subscribes via `switchMap` and rebuilds the layer on each
- * emission. See module JSDoc for the rebuild semantics + state-loss caveat.
- */
-export interface ResilientPipelineOptions<T> {
-	/**
-	 * Admission control — at most `maxEvents` `DATA` per `windowNs`. See
-	 * {@link rateLimiter}.
-	 *
-	 * **`maxBuffer` is required in BOTH the value form and the Node form** —
-	 * forwarded directly to {@link rateLimiter}, which is fail-loud (D4): an
-	 * un-seeded opts Node, or a value/cached value omitting `maxBuffer`, throws
-	 * `RangeError` at construction. Pass a finite positive integer for a bounded
-	 * queue, or the literal `Infinity` to explicitly opt in to unbounded (the
-	 * silent bounded/unbounded lock is the most common rateLimiter
-	 * mis-configuration). There is **no value-vs-Node asymmetry and no legacy
-	 * `?? Infinity` convenience injection** — both forms match the primitive's
-	 * fail-loud contract (F-B-root, 2026-05-18 smell sweep).
-	 */
-	rateLimit?: NodeOrValue<RateLimiterOptions>;
-	/** Cost/constraint gate. See {@link budgetGate}. */
-	budget?: NodeOrValue<ReadonlyArray<BudgetConstraint>>;
-	/** Circuit breaker — fail-fast when the downstream resource is unhealthy. See {@link circuitBreaker}. */
-	breaker?: NodeOrValue<CircuitBreakerOptions>;
-	/**
-	 * Behavior when the breaker is open:
-	 * - `"skip"` (default) — emit `RESOLVED` (lets downstream drop the beat).
-	 * - `"error"` — emit a `CircuitOpenError` so `retry` / `fallback` can react.
-	 *   See module JSDoc for the retry-budget burn caveat.
-	 *
-	 * Static (configuration-only — no reactive form).
-	 */
-	breakerOnOpen?: "skip" | "error";
-	/** Retry policy on terminal `ERROR`. See {@link retry}. */
-	retry?: NodeOrValue<RetryOptions>;
-	/**
-	 * Per-attempt deadline in milliseconds. Converted to ns internally. Omit
-	 * to skip the timeout wrap.
-	 *
-	 * Specified in ms (not ns) because callers consistently think in
-	 * millisecond deadlines; the underlying {@link timeout} primitive takes ns
-	 * internally.
-	 */
-	timeoutMs?: NodeOrValue<number>;
-	/** Final fallback value emitted on terminal `ERROR` after retry exhausts. See {@link fallback}. */
-	fallback?: FallbackInput<T>;
-	/**
-	 * Initial status reported by the status node. Default `"pending"`. Static.
-	 */
-	initialStatus?: StatusValue;
-	/** Wrapper graph name. Default `"resilient_pipeline"`. */
-	name?: string;
-	/** Wrapper graph options. */
-	graph?: GraphOptions;
-}
-
-// ---------------------------------------------------------------------------
-// ResilientPipelineGraph
-// ---------------------------------------------------------------------------
-
-/**
- * Graph subclass returned by {@link resilientPipeline}. Mounts each
- * configured intermediate under a stable name and exposes per-layer status
- * companions.
- *
- * @category patterns
- */
-export class ResilientPipelineGraph<T> extends Graph {
-	/**
-	 * Final resilient node — subscribe to this for `DATA` emissions.
-	 *
-	 * Named `output` (not `node`) because `Graph.node(name)` already names the
-	 * path-resolution method on the base class; a `readonly node` field would
-	 * shadow it.
-	 */
-	readonly output: Node<T>;
-	/** Live status: `"pending" | "running" | "completed" | "errored"`. */
-	readonly status: Node<StatusValue>;
-	/**
-	 * Last error payload, or `null` when not errored.
-	 *
-	 * Named `lastError` (not `error`) because `Graph.error(name, err)` already
-	 * names a method on the base class.
-	 */
-	readonly lastError: Node<unknown | null>;
-	/** Breaker state when `opts.breaker` is provided; `undefined` otherwise. */
-	readonly breakerState: Node<BreakerState> | undefined;
-	/**
-	 * Timeout state companion when `opts.timeoutMs` is supplied as a
-	 * `Node<Partial<TimeoutOptions>>`-like form; `undefined` otherwise
-	 * (DS-13.5.B forwarding contract — Node-form opts skip the switchMap
-	 * rebuild and lift the primitive's lifecycle companion onto the
-	 * pipeline bundle).
-	 */
-	readonly timeoutState: Node<TimeoutState> | undefined;
-	/**
-	 * Retry state companion when `opts.retry` is supplied as a
-	 * `Node<RetryOptions>`-like form; `undefined` otherwise
-	 * (DS-13.5.B forwarding contract).
-	 */
-	readonly retryState: Node<RetryState> | undefined;
-	/**
-	 * Drop-counter when `opts.rateLimit` is provided; `undefined` otherwise.
-	 *
-	 * **Lifetime note:** `droppedCount` retains its final value through
-	 * terminal (`COMPLETE` / `ERROR` / `TEARDOWN`); the underlying counter
-	 * resets to `0` only at the next subscription cycle.
-	 */
-	readonly droppedCount: Node<number> | undefined;
-	/**
-	 * Combined rate-limit state when `opts.rateLimit` is provided; `undefined`
-	 * otherwise. Same lifecycle as {@link droppedCount} but exposes
-	 * `pendingCount` and `paused` alongside the drop counter for richer
-	 * backpressure observability (Tier 5.2 D7).
-	 */
-	readonly rateLimitState: Node<RateLimiterState> | undefined;
-
-	constructor(source: Node<T>, opts: ResilientPipelineOptions<T> = {}) {
-		super(opts.name ?? "resilient_pipeline", opts.graph);
-
-		let current: Node<T> = source;
-		let droppedCount: Node<number> | undefined;
-		let rateLimitState: Node<RateLimiterState> | undefined;
-		let breakerState: Node<BreakerState> | undefined;
-		let timeoutState: Node<TimeoutState> | undefined;
-		let retryState: Node<RetryState> | undefined;
-
-		// 1. Admission control — cheapest to drop / queue before any other work.
-		if (opts.rateLimit != null) {
-			if (isNode<RateLimiterOptions>(opts.rateLimit)) {
-				// DS-13.5.B forwarding: rateLimiter primitive is widened to
-				// accept `NodeOrValue<RateLimiterOptions>` directly. Forward
-				// the Node form to preserve internal state (pending buffer,
-				// dropped counter) across opts swaps. Companion nodes
-				// (droppedCount / rateLimitState) lift onto the pipeline
-				// bundle. The pre-DS-13.5.B switchMap-rebuild path is gone.
-				const bundle = rateLimiter(current, opts.rateLimit);
-				current = bundle.node;
-				droppedCount = bundle.droppedCount;
-				rateLimitState = bundle.rateLimitState;
-				this.add(current, { name: "rateLimited" });
-				this.add(droppedCount, { name: "droppedCount" });
-				this.add(rateLimitState, { name: "rateLimitState" });
-			} else {
-				// F-B-root (2026-05-18 smell sweep): no `?? Infinity` injection.
-				// `maxBuffer` is required by the type and validated fail-loud by
-				// `rateLimiter` (D4) — `Infinity` is an explicit unbounded opt-in.
-				const rateOpts: RateLimiterOptions = {
-					...opts.rateLimit,
-					meta: domainMeta("resilient", "rate-limit"),
-				};
-				const bundle = rateLimiter(current, rateOpts);
-				current = bundle.node;
-				droppedCount = bundle.droppedCount;
-				rateLimitState = bundle.rateLimitState;
-				this.add(current, { name: "rateLimited" });
-				this.add(droppedCount, { name: "droppedCount" });
-				this.add(rateLimitState, { name: "rateLimitState" });
-			}
-		}
-
-		// 2. Budget — block when constraints are exhausted. Also cheap (no I/O).
-		if (opts.budget != null) {
-			if (isNode<ReadonlyArray<BudgetConstraint>>(opts.budget)) {
-				const inputForLayer = current;
-				const reactiveBudget = opts.budget;
-				current = switchMap(reactiveBudget, (constraints) =>
-					constraints.length > 0
-						? budgetGate(inputForLayer, constraints, {
-								meta: domainMeta("resilient", "budget"),
-							}).node
-						: inputForLayer,
-				);
-				this.add(current, { name: "budgetGated" });
-			} else if (opts.budget.length > 0) {
-				current = budgetGate(current, opts.budget, {
-					meta: domainMeta("resilient", "budget"),
-				}).node;
-				this.add(current, { name: "budgetGated" });
-			}
-		}
-
-		// 3. Breaker — skip the resource when unhealthy (fail-fast before retry wastes time).
-		if (opts.breaker != null) {
-			// DS-13.5.B forwarding: circuitBreaker primitive accepts
-			// `NodeOrValue<CircuitBreakerOptions>` directly. Pass the Node
-			// form straight through so internal state (`_state`,
-			// `_failureCount`, `_openCycle`, …) is preserved across opts
-			// swaps. Companion `breakerState` lifts onto the pipeline
-			// bundle in both static and Node-form paths.
-			const breaker = circuitBreaker(opts.breaker as NodeOrValue<CircuitBreakerOptions>);
-			const onOpen = opts.breakerOnOpen ?? "skip";
-			const wrapped = withBreaker<T>(breaker, {
-				onOpen,
-				meta: domainMeta("resilient", "breaker"),
-			})(current);
-			current = wrapped.node;
-			breakerState = wrapped.breakerState;
-			this.add(current, { name: "breakerWrapped" });
-			this.add(breakerState, { name: "breakerState" });
-		}
-
-		// 4. Timeout — per-attempt deadline. Applied BEFORE retry so each retry
-		//    resubscribes to a fresh timeout. Swapping the order (timeout
-		//    OUTSIDE retry) would apply one global deadline to the entire
-		//    retry chain — not what callers expect for "per-attempt timeout."
-		if (opts.timeoutMs != null) {
-			if (isNode<number>(opts.timeoutMs)) {
-				// DS-13.5.B forwarding: build a derived `Node<{ns}>` from
-				// the caller's `Node<number>` (ms) and pass directly to the
-				// widened timeout primitive. State preservation (in-flight
-				// deadline) is handled inside timeout's reactive opts path.
-				// Companion `timeoutState` lifts onto the pipeline bundle.
-				const reactiveTimeoutMs = opts.timeoutMs;
-				const initialMs = reactiveTimeoutMs.cache as number | undefined;
-				// QA A5 (2026-05-03): assert validity of the cached initial
-				// value at construction so a bad cache fails loud at wire
-				// time, not silently at first emit. Reactive emits with
-				// invalid values flow through the producer body's ERROR
-				// channel rather than throwing into the host scheduler.
-				if (initialMs !== undefined) assertTimeoutMsValid(initialMs);
-				const optsBridge = node<Partial<TimeoutOptions>>(
-					[reactiveTimeoutMs as Node<unknown>],
-					(batchData, actions, ctx) => {
-						const data = batchData.map((b, i) =>
-							b != null && b.length > 0 ? b.at(-1) : ctx.prevData[i],
-						);
-						const ms = data[0] as number | undefined;
-						if (ms === undefined) return;
-						// QA A5: route validation failures through the
-						// reactive ERROR channel — sync `throw` inside a
-						// producer body corrupts the host scheduler's
-						// wave dispatch (mirrors timeout primitive's
-						// "sync throw would corrupt the host scheduler"
-						// rationale).
-						if (typeof ms !== "number" || !Number.isFinite(ms) || ms <= 0 || ms > 9_000_000) {
-							actions.down([
-								[
-									ERROR,
-									new RangeError(
-										`resilientPipeline: timeoutMs reactive emit invalid (${ms}); must be > 0 and <= 9_000_000.`,
-									),
-								],
-							]);
-							return;
-						}
-						actions.emit({ ns: ms * NS_PER_MS });
-					},
-					{
-						describeKind: "derived",
-						name: "timeoutOptsBridge",
-						...(initialMs !== undefined
-							? { initial: { ns: initialMs * NS_PER_MS } as Partial<TimeoutOptions> }
-							: {}),
-					},
-				);
-				// QA A5: register the bridge on the pipeline graph so
-				// describe() walks see the full topology (dry-run /
-				// real-run equivalence per CLAUDE.md).
-				this.add(optsBridge, { name: "timeoutOptsBridge" });
-				const bundle = withTimeout(current, optsBridge, {
-					meta: domainMeta("resilient", "timeout"),
-				});
-				current = bundle.node;
-				timeoutState = bundle.timeoutState;
-				this.add(current, { name: "timeoutWrapped" });
-				this.add(timeoutState, { name: "timeoutState" });
-			} else {
-				assertTimeoutMsValid(opts.timeoutMs);
-				const bundle = withTimeout(
-					current,
-					{ ns: opts.timeoutMs * NS_PER_MS },
-					{
-						meta: domainMeta("resilient", "timeout"),
-					},
-				);
-				current = bundle.node;
-				timeoutState = bundle.timeoutState;
-				this.add(current, { name: "timeoutWrapped" });
-				this.add(timeoutState, { name: "timeoutState" });
-			}
-		}
-
-		// 5. Retry — resubscribe on `ERROR` up to `count` times. Wraps timeout
-		//    so each retry gets its own fresh deadline.
-		if (opts.retry != null) {
-			// DS-13.5.B forwarding: retry primitive accepts
-			// `NodeOrValue<RetryOptions>` directly. Forward Node form so
-			// `attempt` / `prevDelay` / in-flight timer survive opts swaps.
-			// Companion `retryState` lifts onto the pipeline bundle.
-			if (isNode<RetryOptions>(opts.retry)) {
-				const bundle = retry(current, opts.retry as NodeOrValue<RetryOptions>);
-				current = bundle.node;
-				retryState = bundle.retryState;
-				this.add(current, { name: "retryWrapped" });
-				this.add(retryState, { name: "retryState" });
-			} else {
-				const bundle = retry(current, {
-					...opts.retry,
-					meta: domainMeta("resilient", "retry"),
-				});
-				current = bundle.node;
-				retryState = bundle.retryState;
-				this.add(current, { name: "retryWrapped" });
-				this.add(retryState, { name: "retryState" });
-			}
-		}
-
-		// 6. Fallback — last resort after retry+timeout exhaust. Guard
-		//    `opts.fallback !== undefined` so `null` is a valid fallback.
-		if (opts.fallback !== undefined) {
-			current = fallback(current, opts.fallback, {
-				meta: domainMeta("resilient", "fallback"),
-			});
-			this.add(current, { name: "fallbackWrapped" });
-		}
-
-		// 7. Status wrapping — observability. Always last so it sees the final shape.
-		const statusBundle = withStatus(current, {
-			initialStatus: opts.initialStatus ?? "pending",
-			meta: domainMeta("resilient", "status"),
-		});
-
-		this.output = statusBundle.node;
-		this.status = statusBundle.status;
-		this.lastError = statusBundle.error;
-		this.breakerState = breakerState;
-		this.droppedCount = droppedCount;
-		this.rateLimitState = rateLimitState;
-		this.timeoutState = timeoutState;
-		this.retryState = retryState;
-
-		// Mount the externally-visible top-level entries by name. Each carries
-		// its own factoryTag meta from the underlying primitive (`withStatus`
-		// for `output`/`status`/`lastError`); domain-level provenance lives on
-		// the Graph itself via the `tagFactory("resilientPipeline", ...)` call
-		// in the public factory below. The mount names use `output` /
-		// `lastError` to match the property names — the previous `node` /
-		// `error` clashed with `Graph.node(name)` / `Graph.error(name, err)`.
-		this.add(this.output, { name: "output" });
-		this.add(this.status, { name: "status" });
-		this.add(this.lastError, { name: "lastError" });
-	}
-}
-
-// ---------------------------------------------------------------------------
-// Factory
-// ---------------------------------------------------------------------------
-
-/**
- * Compose a resilient pipeline around `source` in the canonical nesting
- * order — `rateLimit → budget → breaker → timeout → retry → fallback → status`.
- * Omit any option to skip that layer.
- *
- * Returns a {@link ResilientPipelineGraph} (Graph subclass) —
- * `pipeline.output` is the externally visible final node; `pipeline.status`
- * / `pipeline.lastError` / `pipeline.breakerState` / `pipeline.droppedCount`
- * are the per-layer companions. Call `pipeline.describe()` to see the
- * mounted intermediates; compose with {@link graphLens}'s `health` for
- * aggregate status.
- *
- * **Naming note:** `output` and `lastError` (not `node` / `error`) avoid
- * clashes with `Graph.node(name)` and `Graph.error(name, err)` on the base
- * class.
- *
- * @param source - Upstream node to wrap.
- * @param opts - See {@link ResilientPipelineOptions}. All fields optional.
- *
- * @example
- * ```ts
- * const safeFetch = resilientPipeline(fetchNode, {
- *   rateLimit: { maxEvents: 10, windowNs: NS_PER_SEC, maxBuffer: 100 },
- *   breaker: { failureThreshold: 5 },
- *   retry: { count: 3, backoff: "exponential" },
- *   timeoutMs: 10_000,
- *   fallback: null,
- * });
- * safeFetch.output.subscribe(msgs => console.log(msgs));
- * safeFetch.status.subscribe(msgs => console.log(msgs));
- * graphSpecToAscii(safeFetch.describe()); // visualize the chain
- * ```
- *
- * @category patterns
- */
-export function resilientPipeline<T>(
-	source: Node<T>,
-	opts: ResilientPipelineOptions<T> = {},
-): ResilientPipelineGraph<T> {
-	const g = new ResilientPipelineGraph<T>(source, opts);
-	// Self-tag for `graph.describe()` factory provenance (Phase 2.5 DG1=B).
-	// `placeholderArgs` substitutes Node-typed and function-typed fields with
-	// `"<Node>"` / `"<function>"` so `factoryArgs` stays JSON-serializable.
-	g.tagFactory("resilientPipeline", placeholderArgs(opts as unknown as Record<string, unknown>));
-	return g;
-}
-
-// Tag the underlying status / error / breaker / dropped companions with a
-// best-effort factoryTag too via the wrapper class's meta — already covered
-// by `domainMeta("resilient", kind)` on the mounted nodes.
-
-// Tier 9.1 γ-form: this module now lives inside `extra/resilience/`, so the
-// underlying primitive option types are already exported from the same barrel
-// (`./index.js`). The previous re-exports of `factoryTag` / `placeholderArgs` /
-// `NS_PER_MS` / `NS_PER_SEC` / option types were a workaround for the prior
-// `patterns/resilient-pipeline/` folder location and are now redundant.
diff --git a/src/solutions/index.ts b/src/solutions/index.ts
deleted file mode 100644
index 4f99aa39..00000000
--- a/src/solutions/index.ts
+++ /dev/null
@@ -1,20 +0,0 @@
-/**
- * Solutions — curated headline-product barrel.
- *
- * The front door for "I want a recipe." Re-exports headline factories from
- * presets so consumers can import from one place without knowing which preset
- * sub-domain each factory lives in.
- *
- * Verticals (solutions/<vertical>/) are deferred per D202 — added when
- * consumer pressure justifies a bundled vertical starter kit.
- *
- * @module
- */
-
-export { agentLoop } from "../presets/ai/agent-loop.js";
-export { agentMemory } from "../presets/ai/agent-memory.js";
-export { harnessLoop } from "../presets/harness/harness-loop.js";
-export { refineLoop } from "../presets/harness/refine-loop.js";
-export { spawnable } from "../presets/harness/spawnable.js";
-export { guardedExecution } from "../presets/inspect/guarded-execution.js";
-export { resilientPipeline } from "../presets/resilience/resilient-pipeline.js";
diff --git a/src/testing/index.ts b/src/testing/index.ts
deleted file mode 100644
index 1f87936f..00000000
--- a/src/testing/index.ts
+++ /dev/null
@@ -1,10 +0,0 @@
-/**
- * `@graphrefly/graphrefly/testing` — public test utilities.
- *
- * Universal tier (browser + Node safe). Test-time helpers for exercising
- * GraphReFly AI / harness patterns without a real LLM wire call.
- *
- * @module
- */
-
-export * from "./mock-llm.js";
diff --git a/src/testing/mock-llm.ts b/src/testing/mock-llm.ts
deleted file mode 100644
index ffe52195..00000000
--- a/src/testing/mock-llm.ts
+++ /dev/null
@@ -1,159 +0,0 @@
-/**
- * Scenario-scripted mock LLM adapter for harness and AI pattern testing.
- *
- * Detects the calling stage from prompt content and returns scripted responses.
- * Records all calls for assertions.
- *
- * @module
- */
-
-import type { ChatMessage, LLMAdapter, LLMResponse } from "../utils/ai/index.js";
-
-// ---------------------------------------------------------------------------
-// Types
-// ---------------------------------------------------------------------------
-
-/** A single recorded call to the mock adapter. */
-export interface MockCall {
-	stage: string;
-	messages: readonly ChatMessage[];
-	response: LLMResponse;
-}
-
-/** Per-stage response script. Cycles through responses on each call. */
-export interface StageScript {
-	/** Ordered responses — each call consumes the next; last one repeats. */
-	responses: unknown[];
-}
-
-/** Configuration for {@link mockLLM}. */
-export interface MockScript {
-	/** Stage-aware response scripts. Stage is detected from prompt keywords. */
-	stages?: Record<string, StageScript>;
-	/** Fallback response for unmatched prompts. */
-	fallback?: unknown;
-}
-
-/** Extended LLM adapter with call recording and inspection. */
-export interface MockLLMAdapter extends LLMAdapter {
-	/** All calls recorded in order. */
-	readonly calls: MockCall[];
-	/** Per-stage call counts. */
-	readonly stageCounts: ReadonlyMap<string, number>;
-	/** Calls filtered by stage name. */
-	callsFor(stage: string): MockCall[];
-	/** Reset all counters and call history. */
-	reset(): void;
-}
-
-// ---------------------------------------------------------------------------
-// Stage detection
-// ---------------------------------------------------------------------------
-
-/**
- * Default stage detection keywords (matched against lowercased prompt text).
- * Order matters: more specific phrases checked first to avoid substring
- * collisions (e.g. "triaged issue" in execute prompt matching "triage").
- */
-const STAGE_KEYWORDS: [string, string[]][] = [
-	["execute", ["implementation agent", "produce a fix"]],
-	["verify", ["qa reviewer", "verify whether"]],
-	["triage", ["triage classifier", "intake item"]],
-];
-
-function detectStage(text: string, customStages?: Record<string, StageScript>): string {
-	const lower = text.toLowerCase();
-
-	// Check built-in multi-word keywords first (more specific, avoids substring collisions
-	// like "triaged" matching "triage")
-	for (const [stage, keywords] of STAGE_KEYWORDS) {
-		if (keywords.some((kw) => lower.includes(kw))) return stage;
-	}
-
-	// Fall back to custom stage names as keywords
-	if (customStages) {
-		for (const stage of Object.keys(customStages)) {
-			if (lower.includes(stage.toLowerCase())) return stage;
-		}
-	}
-
-	return "unknown";
-}
-
-// ---------------------------------------------------------------------------
-// Factory
-// ---------------------------------------------------------------------------
-
-/**
- * Create a scenario-scripted mock LLM adapter.
- *
- * ```ts
- * const mock = mockLLM({
- *   stages: {
- *     triage:  { responses: [{ rootCause: "missing-fn", intervention: "catalog-fn", route: "auto-fix", priority: 80 }] },
- *     execute: { responses: [{ outcome: "success", detail: "Fixed" }] },
- *     verify:  { responses: [{ verified: false, findings: ["err"], errorClass: "self-correctable" },
- *                            { verified: true, findings: ["ok"] }] },
- *   },
- * });
- * ```
- */
-export function mockLLM(script: MockScript = {}): MockLLMAdapter {
-	const calls: MockCall[] = [];
-	const stageCounts = new Map<string, number>();
-	const stageIndices = new Map<string, number>();
-
-	function getResponse(stage: string): unknown {
-		const stageScript = script.stages?.[stage];
-		if (!stageScript) return script.fallback ?? {};
-
-		const idx = stageIndices.get(stage) ?? 0;
-		const responses = stageScript.responses;
-		const response = responses[Math.min(idx, responses.length - 1)];
-		stageIndices.set(stage, idx + 1);
-		return response;
-	}
-
-	function invoke(messages: readonly ChatMessage[]): Promise<LLMResponse> {
-		const text = messages.map((m) => m.content).join(" ");
-		const stage = detectStage(text, script.stages);
-
-		const count = stageCounts.get(stage) ?? 0;
-		stageCounts.set(stage, count + 1);
-
-		const responseData = getResponse(stage);
-		const response: LLMResponse = {
-			content: typeof responseData === "string" ? responseData : JSON.stringify(responseData),
-			usage: { input: { regular: 0 }, output: { regular: 0 } },
-		};
-
-		calls.push({ stage, messages, response });
-		return Promise.resolve(response);
-	}
-
-	async function* stream(): AsyncIterable<
-		import("../utils/ai/adapters/core/types.js").StreamDelta
-	> {
-		yield { type: "token", delta: "mock stream" };
-		yield { type: "usage", usage: { input: { regular: 0 }, output: { regular: 0 } } };
-		yield { type: "finish", reason: "stop" };
-	}
-
-	return {
-		provider: "mock",
-		calls,
-		get stageCounts() {
-			return stageCounts as ReadonlyMap<string, number>;
-		},
-		callsFor(stage: string) {
-			return calls.filter((c) => c.stage === stage);
-		},
-		reset() {
-			calls.length = 0;
-			stageCounts.clear();
-			stageIndices.clear();
-		},
-		invoke,
-		stream,
-	};
-}
diff --git a/src/utils/_errors/index.ts b/src/utils/_errors/index.ts
deleted file mode 100644
index 6a5a5909..00000000
--- a/src/utils/_errors/index.ts
+++ /dev/null
@@ -1,97 +0,0 @@
-/**
- * Shared pattern-layer error hierarchy (Audit 2 — locked 2026-04-24).
- *
- * Cross-primitive `instanceof` checks: gate, queue, cqrs.dispatch, saga,
- * projection, subscription, etc. all use these classes so consumer error
- * handlers can branch by kind rather than by message string.
- *
- * @internal — exposed via patterns/index for primitive impls; consumers
- * should import the relevant class from the primitive's barrel.
- */
-
-/** Root error class. All pattern-layer errors extend this. */
-export class GraphReFlyError extends Error {
-	constructor(message: string, options?: ErrorOptions) {
-		super(message, options);
-		this.name = this.constructor.name;
-	}
-}
-
-/** Re-registering a name that's already taken (command, gate, queue, saga, projection). */
-export class DuplicateRegistrationError extends GraphReFlyError {
-	constructor(
-		readonly kind: string,
-		readonly registrationName: string,
-	) {
-		super(`Duplicate ${kind} registration: "${registrationName}"`);
-	}
-}
-
-/** CQRS handler emitted an event type not in its declared `emits` set. */
-export class UndeclaredEmitError extends GraphReFlyError {
-	constructor(
-		readonly commandName: string,
-		readonly eventName: string,
-		readonly declaredEmits: readonly string[],
-	) {
-		super(
-			`Command "${commandName}" emitted undeclared event "${eventName}". Declared emits: [${declaredEmits.join(", ")}]`,
-		);
-	}
-}
-
-/** Aggregate version expected vs observed mismatch on dispatch. */
-export class OptimisticConcurrencyError extends GraphReFlyError {
-	constructor(
-		readonly aggregateId: string,
-		readonly expected: number,
-		readonly actual: number,
-	) {
-		super(
-			`Optimistic concurrency conflict on aggregate "${aggregateId}": expected version ${expected}, got ${actual}`,
-		);
-	}
-}
-
-/** `dispatch(name, ...)` for a name that wasn't registered via `command()`. */
-export class UnknownCommandError extends GraphReFlyError {
-	constructor(readonly commandName: string) {
-		super(`Unknown command: "${commandName}". Register with command() first.`);
-	}
-}
-
-/** Wrap any error thrown from inside a command handler. Original on `cause`. */
-export class CommandHandlerError extends GraphReFlyError {
-	constructor(
-		readonly commandName: string,
-		cause: unknown,
-	) {
-		super(
-			`Command handler "${commandName}" threw: ${cause instanceof Error ? cause.message : String(cause)}`,
-			{ cause },
-		);
-	}
-}
-
-/** Mutation method called after the primitive was torn down. */
-export class TeardownError extends GraphReFlyError {
-	constructor(
-		readonly kind: string,
-		readonly method: string,
-	) {
-		super(`${kind}: ${method}() called after teardown`);
-	}
-}
-
-/** Projection rebuild failure — adapter / decode / reducer error. */
-export class RebuildError extends GraphReFlyError {
-	constructor(
-		readonly projectionName: string,
-		cause: unknown,
-	) {
-		super(
-			`Projection "${projectionName}" rebuild failed: ${cause instanceof Error ? cause.message : String(cause)}`,
-			{ cause },
-		);
-	}
-}
diff --git a/src/utils/ai/_internal.ts b/src/utils/ai/_internal.ts
deleted file mode 100644
index 6895d881..00000000
--- a/src/utils/ai/_internal.ts
+++ /dev/null
@@ -1,275 +0,0 @@
-/**
- * @internal — shared helpers for the AI pattern modules.
- *
- * NOT part of the public API. Consumers reach public symbols through
- * `@graphrefly/graphrefly/utils/ai` (the barrel).
- *
- * @module
- */
-
-import {
-	COMPLETE,
-	DATA,
-	ERROR,
-	type Messages,
-	type Node,
-	node,
-	ResettableTimer,
-} from "@graphrefly/pure-ts/core";
-import { fromAny, type NodeInput } from "@graphrefly/pure-ts/extra";
-import { domainMeta } from "../../base/meta/domain-meta.js";
-import type {
-	ChatMessage,
-	LLMAdapter,
-	LLMInvokeOptions,
-	LLMResponse,
-} from "./adapters/core/types.js";
-
-export function aiMeta(kind: string, extra?: Record<string, unknown>): Record<string, unknown> {
-	return domainMeta("ai", kind, extra);
-}
-
-export function isPromiseLike(x: unknown): x is PromiseLike<unknown> {
-	return x != null && typeof (x as PromiseLike<unknown>).then === "function";
-}
-
-export function isNodeLike(x: unknown): x is Node<unknown> {
-	return (
-		typeof x === "object" &&
-		x !== null &&
-		"subscribe" in x &&
-		typeof (x as Node<unknown>).subscribe === "function" &&
-		"cache" in x
-	);
-}
-
-export function isAsyncIterableLike(x: unknown): x is AsyncIterable<unknown> {
-	return (
-		x != null &&
-		typeof x === "object" &&
-		Symbol.asyncIterator in x &&
-		typeof (x as AsyncIterable<unknown>)[Symbol.asyncIterator] === "function"
-	);
-}
-
-const DEFAULT_TIMEOUT_MS = 30_000;
-
-/** First settled `DATA` from a `Node` (do not pass plain strings — `fromAny` would iterate chars). */
-export function firstDataFromNode(
-	resolved: Node<unknown>,
-	opts?: { timeoutMs?: number },
-): Promise<unknown> {
-	if ((resolved as { status?: string }).status === "settled") {
-		const immediate = resolved.cache;
-		if (immediate !== undefined) {
-			return Promise.resolve(immediate);
-		}
-	}
-	const timeoutMs = opts?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
-	return new Promise((resolve, reject) => {
-		const timer = new ResettableTimer();
-		const unsub = resolved.subscribe((messages) => {
-			for (const msg of messages) {
-				if (msg[0] === DATA) {
-					timer.cancel();
-					unsub();
-					resolve(msg[1]);
-					return;
-				}
-				if (msg[0] === ERROR) {
-					timer.cancel();
-					unsub();
-					reject(msg[1]);
-					return;
-				}
-				if (msg[0] === COMPLETE) {
-					timer.cancel();
-					unsub();
-					reject(new Error("firstDataFromNode: completed without producing a value"));
-					return;
-				}
-			}
-		});
-		timer.start(timeoutMs, () => {
-			unsub();
-			reject(new Error(`firstDataFromNode: timed out after ${timeoutMs}ms`));
-		});
-	});
-}
-
-/** Await Promise-likes, then resolve `Node` / async-iterable inputs via `fromAny` + first `DATA`. */
-export async function resolveToolHandlerResult(value: unknown): Promise<unknown> {
-	if (isPromiseLike(value)) {
-		return resolveToolHandlerResult(await value);
-	}
-	if (isNodeLike(value)) {
-		return firstDataFromNode(value);
-	}
-	if (isAsyncIterableLike(value)) {
-		return firstDataFromNode(fromAny(value as NodeInput<unknown>));
-	}
-	return value;
-}
-
-/** Strip markdown code fences, handling trailing commentary after closing fence. */
-export function stripFences(text: string): string {
-	const match = text.match(/^```(?:json)?\s*([\s\S]*?)\s*```[\s\S]*$/);
-	return match ? match[1]! : text;
-}
-
-/**
- * Bridge-layer failure kind reported to {@link OneShotLlmCallConfig.onFailure}.
- *
- * - `"throw"` — synchronous throw from `adapter.invoke()`.
- * - `"error"` — `[ERROR, value]` message on the bridged Node.
- * - `"complete"` — the bridged Node closed without emitting DATA.
- * - `"onSuccess-threw"` — `onSuccess(resp)` itself threw (uncaught parse /
- *   builder error). Caller's `onFailure` decides the failure-payload shape.
- */
-export type OneShotLlmFailureKind = "throw" | "error" | "complete" | "onSuccess-threw";
-
-/** Configuration for {@link _oneShotLlmCall}. */
-export interface OneShotLlmCallConfig<T> {
-	/**
-	 * Build the success payload from the adapter's first DATA message.
-	 * MAY throw — the helper catches and routes through `onFailure(kind:
-	 * "onSuccess-threw", err)` so callers don't need their own try/catch.
-	 */
-	onSuccess: (resp: LLMResponse) => T;
-	/**
-	 * Build a failure payload when the bridge layer reports any of the
-	 * {@link OneShotLlmFailureKind} categories. Caller chooses the detail
-	 * string format and any error-class metadata.
-	 */
-	onFailure: (kind: OneShotLlmFailureKind, err: unknown) => T;
-	/**
-	 * Forwarded to `adapter.invoke(messages, opts)` — `signal` is set
-	 * by the helper from the producer's AbortController and CANNOT be
-	 * overridden here (cancellation is a hard contract of this helper).
-	 */
-	invokeOpts?: Omit<LLMInvokeOptions, "signal">;
-	/**
-	 * Optional parent abort signal (e.g. JobFlow pump's per-claim signal).
-	 * When the parent aborts, the helper aborts its inner AbortController —
-	 * so `adapter.invoke({ signal })` and `fromAny({ signal })` see the
-	 * cascade and cancel in-flight work. Pump-driven harness teardown
-	 * (`harness.destroy()`) propagates through this hook (Tier 6.5 2.5b).
-	 */
-	parentSignal?: AbortSignal;
-}
-
-/**
- * Internal — one-shot bridge from `adapter.invoke()` (a `NodeInput<LLMResponse>`)
- * into a producer that emits exactly one DATA + COMPLETE.
- *
- * **Why this exists.** The harness's `defaultLlmExecutor` and
- * `defaultLlmVerifier` (Tier 6.5 C2) both call `adapter.invoke()` once
- * per claimed JobFlow job and need to:
- *  1. Subscribe to the bridged Node, capture the first DATA, parse, emit
- *     a domain payload.
- *  2. Map adapter throws / ERROR / COMPLETE-without-DATA to a domain
- *     failure payload (rather than nack the JobFlow claim).
- *  3. Thread `signal: ac.signal` into BOTH `adapter.invoke()` (via
- *     `LLMInvokeOptions.signal`) and `fromAny()` (covers Node-shaped
- *     invokeResults) so teardown actually aborts in-flight HTTP work.
- *  4. Tear down the inner subscription cleanly when DATA captures or
- *     when the producer is unsubscribed.
- *
- * Pre-extraction this body was duplicated ~80 LOC across the two default
- * bridges; symmetric fixes had to land twice (qa F1 / F2 / F5). This
- * helper centralizes the producer body so future bridge-layer fixes apply
- * once.
- *
- * **Not part of the public API.** Callers in `patterns/ai/_internal.ts`'s
- * import surface (the harness defaults today) use this; user code should
- * use `promptNode` for cross-wave reactive transforms or call
- * `adapter.invoke()` directly.
- */
-export function _oneShotLlmCall<T>(
-	adapter: LLMAdapter,
-	messages: readonly ChatMessage[],
-	config: OneShotLlmCallConfig<T>,
-): NodeInput<T> {
-	return node<T>(
-		(_data, actions) => {
-			const ac = new AbortController();
-			// Link parent signal (e.g. pump per-claim signal) so cascading
-			// teardown propagates: parent abort → inner ac.abort → adapter +
-			// fromAny cancel.
-			const parentSignal = config.parentSignal;
-			let unlinkParent: () => void = () => undefined;
-			if (parentSignal) {
-				if (parentSignal.aborted) {
-					ac.abort();
-				} else {
-					const onParentAbort = (): void => ac.abort();
-					parentSignal.addEventListener("abort", onParentAbort, { once: true });
-					unlinkParent = () => parentSignal.removeEventListener("abort", onParentAbort);
-				}
-			}
-			let captured = false;
-			let unsub: (() => void) | null = null;
-			const emitOnce = (value: T): void => {
-				if (captured) return;
-				captured = true;
-				actions.down([[DATA, value], [COMPLETE]] satisfies Messages);
-				unsub?.();
-				unsub = null;
-			};
-			let invokeResult: NodeInput<LLMResponse>;
-			try {
-				invokeResult = adapter.invoke(messages, { ...config.invokeOpts, signal: ac.signal });
-			} catch (err) {
-				emitOnce(config.onFailure("throw", err));
-				return {
-					onDeactivation: () => {
-						unlinkParent();
-						ac.abort();
-					},
-				};
-			}
-			const callNode = fromAny<LLMResponse>(invokeResult, { signal: ac.signal });
-			unsub = callNode.subscribe((batch) => {
-				for (const m of batch) {
-					if (captured) return;
-					if (m[0] === DATA) {
-						try {
-							emitOnce(config.onSuccess(m[1] as LLMResponse));
-						} catch (err) {
-							emitOnce(config.onFailure("onSuccess-threw", err));
-						}
-						return;
-					}
-					if (m[0] === ERROR) {
-						emitOnce(config.onFailure("error", m[1]));
-						return;
-					}
-					if (m[0] === COMPLETE) {
-						// COMPLETE without prior DATA — without this arm the JobFlow
-						// pump's claim would stall (qa F1 regression). Helper handles
-						// for ALL callers; defaults can't regress.
-						emitOnce(config.onFailure("complete", undefined));
-						return;
-					}
-				}
-			});
-			// Sync DATA delivery (cached state / `fromAny` over a sync value):
-			// the callback ran reentrantly before `unsub` was assigned, so the
-			// `unsub?.()` call inside `emitOnce` was a no-op. Drop the upstream
-			// subscription now that we have the handle.
-			if (captured && unsub) {
-				unsub();
-				unsub = null;
-			}
-			return {
-				onDeactivation: () => {
-					unlinkParent();
-					ac.abort();
-					unsub?.();
-					unsub = null;
-				},
-			};
-		},
-		{ describeKind: "producer" },
-	);
-}
diff --git a/src/utils/ai/adapters/_internal/content-addressed-cache.ts b/src/utils/ai/adapters/_internal/content-addressed-cache.ts
deleted file mode 100644
index 7436a2a8..00000000
--- a/src/utils/ai/adapters/_internal/content-addressed-cache.ts
+++ /dev/null
@@ -1,180 +0,0 @@
-/**
- * LLM-specific content-addressed cache wrapper over the generic
- * {@link contentAddressedStorage} substrate in `src/extra/`. Handles the
- * ChatMessage + LLMInvokeOptions → stable key shape that both
- * `withReplayCache` and `fallbackAdapter` need, so the two middleware files
- * don't drift on key construction.
- *
- * The generic substrate does the sha256 + canonicalJson + tier IO; this
- * wrapper owns:
- * - Stripping non-serializable `signal` (AbortSignal) and `keyContext`
- *   (caller-opaque context) from the default key.
- * - Arity-dispatched legacy `keyFn` support (1-arg ctx-object form vs 2-arg
- *   `(messages, opts)` form).
- * - LLM-conventional `llm-replay` default key prefix (override via `keyPrefix`).
- *
- * @module
- */
-
-import type { KvStorageTier } from "@graphrefly/pure-ts/extra";
-import {
-	type ContentAddressedMode,
-	type ContentAddressedStorage,
-	contentAddressedStorage,
-} from "@graphrefly/pure-ts/extra";
-import type { ChatMessage, LLMInvokeOptions } from "../core/types.js";
-
-/**
- * Context object passed to the 1-arg {@link ContentAddressedCacheOptions.keyFn}
- * form. Adding fields here is forward-compatible — existing 1-arg consumers
- * that ignore unknowns keep working.
- */
-export interface LLMCacheKeyContext {
-	readonly messages: readonly ChatMessage[];
-	readonly opts: LLMInvokeOptions | undefined;
-	/** Shortcut to `opts?.keyContext` — no extra guard in callers. */
-	readonly context: unknown;
-}
-
-export interface ContentAddressedCacheOptions<V> {
-	storage: KvStorageTier;
-	mode?: ContentAddressedMode;
-	/**
-	 * Custom key function. Receives either {@link LLMCacheKeyContext} (1-arg
-	 * form) or `(messages, opts?)` (legacy 2-arg form) — the wrapper dispatches
-	 * on `Function.length`. Return `string` or `Promise<string>`.
-	 */
-	keyFn?:
-		| ((ctx: LLMCacheKeyContext) => string | Promise<string>)
-		| ((messages: readonly ChatMessage[], opts?: LLMInvokeOptions) => string | Promise<string>);
-	/** Prefix applied as `${keyPrefix}:${hash}`. Default `"llm-replay"`. */
-	keyPrefix?: string;
-	/**
-	 * Optional value type hint — callers may store anything JSON-serializable.
-	 * `withReplayCache` stores `CachedEntry` (response + stream cadence);
-	 * `fallbackAdapter` stores the raw `LLMResponse`.
-	 */
-	_valueType?: V;
-}
-
-/** Handle returned by {@link contentAddressedCache}. */
-export interface ContentAddressedCache<V> {
-	keyFor(messages: readonly ChatMessage[], invokeOpts?: LLMInvokeOptions): Promise<string>;
-	lookup(messages: readonly ChatMessage[], invokeOpts?: LLMInvokeOptions): Promise<V | undefined>;
-	store(
-		messages: readonly ChatMessage[],
-		invokeOpts: LLMInvokeOptions | undefined,
-		value: V,
-	): Promise<void>;
-	forget(messages: readonly ChatMessage[], invokeOpts?: LLMInvokeOptions): Promise<void>;
-}
-
-/**
- * Builds an LLM-shaped content-addressed cache over `storage`. Default keying
- * hashes `(messages, opts minus signal/keyContext)` via
- * {@link contentAddressedStorage} — the generic extra-tier substrate.
- *
- * Used by `withReplayCache` (full response cache) and `fallbackAdapter`
- * (fixture lookup). Both consumers wrap this to add their divergent features
- * (singleflight / stream cadence / canned miss response) around the shared
- * substrate.
- *
- * @category internal
- */
-export function contentAddressedCache<V>(
-	opts: ContentAddressedCacheOptions<V>,
-): ContentAddressedCache<V> {
-	const { storage, mode = "read-write", keyFn, keyPrefix = "llm-replay" } = opts;
-
-	// Substrate mode: translate `"read-strict"` to `"read"` so the substrate
-	// returns `undefined` on miss. The LLM-middleware callers (`withReplayCache`,
-	// `fallbackAdapter`) own the strict-mode throw because they emit
-	// domain-specific error types (`ReplayCacheMissError` / `FallbackMissError`)
-	// that carry context the substrate shouldn't know about.
-	const substrateMode = mode === "read-strict" ? "read" : mode;
-
-	// When `keyFn` is supplied, we wire it through the substrate's raw-key API
-	// (via a synthesized keyContext passthrough). When omitted, we let the
-	// substrate hash the default shape (messages + opts minus non-serializable
-	// fields) with the standard prefix.
-	const substrate: ContentAddressedStorage<
-		{ messages: readonly ChatMessage[]; opts: LLMInvokeOptions | undefined },
-		V
-	> = contentAddressedStorage({
-		storage,
-		keyPrefix,
-		mode: substrateMode,
-		keyContext: ({ messages, opts: invokeOpts }) => {
-			// Drop `signal` (not serializable) and `keyContext` (caller-opaque
-			// context should only participate when user opts in via keyFn).
-			const { signal: _signal, keyContext: _keyContext, ...rest } = invokeOpts ?? {};
-			return { messages, opts: rest };
-		},
-	});
-
-	async function keyFor(
-		messages: readonly ChatMessage[],
-		invokeOpts?: LLMInvokeOptions,
-	): Promise<string> {
-		if (keyFn) {
-			// Arity-dispatch: Function.length === 1 → ctx-object form;
-			// otherwise → legacy 2-arg (messages, opts). Both may return
-			// sync or async strings.
-			if (keyFn.length <= 1) {
-				const ctx: LLMCacheKeyContext = {
-					messages,
-					opts: invokeOpts,
-					context: invokeOpts?.keyContext,
-				};
-				const raw = await (keyFn as (c: LLMCacheKeyContext) => string | Promise<string>)(ctx);
-				return `${keyPrefix}:${raw}`;
-			}
-			const raw = await (
-				keyFn as (m: readonly ChatMessage[], o?: LLMInvokeOptions) => string | Promise<string>
-			)(messages, invokeOpts);
-			return `${keyPrefix}:${raw}`;
-		}
-		return substrate.keyFor({ messages, opts: invokeOpts });
-	}
-
-	return {
-		keyFor,
-
-		async lookup(messages, invokeOpts) {
-			if (mode === "write") return undefined;
-			if (keyFn) {
-				// Custom keyFn path: we can't use substrate.lookup (it hashes
-				// from its own keyContext). Build the key ourselves and load.
-				// Strict-mode throw is the CALLER'S responsibility — we return
-				// undefined on miss so callers can wrap the throw with their
-				// domain-specific error type.
-				const key = await keyFor(messages, invokeOpts);
-				const raw = await storage.load(key);
-				if (raw === undefined) return undefined;
-				return raw as V;
-			}
-			return substrate.lookup({ messages, opts: invokeOpts });
-		},
-
-		async store(messages, invokeOpts, value) {
-			if (mode === "read") return;
-			if (keyFn) {
-				const key = await keyFor(messages, invokeOpts);
-				await storage.save(key, value as unknown);
-				return;
-			}
-			await substrate.store({ messages, opts: invokeOpts }, value);
-		},
-
-		async forget(messages, invokeOpts) {
-			if (mode === "read" || mode === "write") return;
-			if (!storage.delete) return;
-			if (keyFn) {
-				const key = await keyFor(messages, invokeOpts);
-				await storage.delete(key);
-				return;
-			}
-			await substrate.forget({ messages, opts: invokeOpts });
-		},
-	};
-}
diff --git a/src/utils/ai/adapters/_internal/wrappers.ts b/src/utils/ai/adapters/_internal/wrappers.ts
deleted file mode 100644
index e6a3396c..00000000
--- a/src/utils/ai/adapters/_internal/wrappers.ts
+++ /dev/null
@@ -1,286 +0,0 @@
-/**
- * Shared shell + shape-dispatch helpers for the LLM adapter layer.
- *
- * Wave A Unit 11 decision: the 9 middleware files and the observable adapter
- * all repeated the same three boilerplate patterns:
- *
- * 1. Building the returned `LLMAdapter` shell (provider/model/capabilities
- *    pass-through). → `adapterWrapper(inner, {invoke, stream})`.
- * 2. Dispatching the adapter's `NodeInput<LLMResponse>` result across its
- *    three possible shapes (Promise / Node / plain value) + a `recordedOnce`
- *    double-record guard on the reactive path. → `adaptInvokeResult`.
- * 3. Constructing a `CallStatsEvent` from provider / model / tier / usage /
- *    latency. → `buildCallStats`.
- *
- * Two small additions:
- * - `withLayer(adapter, layerName)` stamps a `meta.middlewareLayer` tag on
- *   the returned adapter via a non-enumerable property, enabling
- *   `describeAdapterStack(adapter)` to walk the wrap chain bottom-up.
- * - `describeAdapterStack(adapter)` returns the list of layer names from
- *   innermost to outermost so users can inspect the resilient stack the same
- *   way they inspect graph topology.
- */
-
-import { ERROR, monotonicNs, type Node, node, wallClockNs } from "@graphrefly/pure-ts/core";
-import { fromAny, onFirstData } from "@graphrefly/pure-ts/extra";
-import type { CallStatsEvent } from "../core/observable.js";
-import type {
-	ChatMessage,
-	LLMAdapter,
-	LLMInvokeOptions,
-	LLMResponse,
-	NodeInput,
-	StreamDelta,
-	TokenUsage,
-} from "../core/types.js";
-
-// ---------------------------------------------------------------------------
-// adapterWrapper — LLMAdapter shell with provider/model/capabilities pass-through
-// ---------------------------------------------------------------------------
-
-/** Callable shape for the invoke / stream bodies that `adapterWrapper` composes. */
-export type AdapterInvokeFn = (
-	messages: readonly ChatMessage[],
-	opts?: LLMInvokeOptions,
-) => NodeInput<LLMResponse>;
-
-export type AdapterStreamFn = (
-	messages: readonly ChatMessage[],
-	opts?: LLMInvokeOptions,
-) => AsyncIterable<StreamDelta>;
-
-/**
- * Builds an `LLMAdapter` shell around the given `invoke` / `stream`
- * implementations. Pass-through fields — `provider`, `model`, `capabilities`
- * — come from `inner` unless the caller overrides (`override.provider` etc.).
- *
- * Middleware files used to repeat `provider: inner.provider, model: inner.model,
- * capabilities: inner.capabilities?.bind(inner)` verbatim; this helper
- * captures that once.
- *
- * @category internal
- */
-export function adapterWrapper(
-	inner: LLMAdapter,
-	impl: { invoke: AdapterInvokeFn; stream: AdapterStreamFn },
-	override?: Partial<Pick<LLMAdapter, "provider" | "model" | "capabilities">>,
-): LLMAdapter {
-	return {
-		provider: override?.provider ?? inner.provider,
-		model: override?.model ?? inner.model,
-		capabilities: override?.capabilities ?? inner.capabilities?.bind(inner),
-		invoke: impl.invoke,
-		stream: impl.stream,
-	};
-}
-
-// ---------------------------------------------------------------------------
-// adaptInvokeResult — shape-dispatch for NodeInput<LLMResponse>
-// ---------------------------------------------------------------------------
-
-/**
- * Shape-dispatch helper for `inner.invoke(...)` return values. Converts any of
- * the three `NodeInput<LLMResponse>` shapes (Promise, plain value, Node /
- * iterable) into the caller-requested output, applying `onResp` exactly once
- * on the first DATA emission.
- *
- * **Paths.**
- * - `Promise<LLMResponse>` → `Promise<R>` (chains `onResp` via `.then`; if
- *   `onError` is provided, wires `.catch` so rejected Promises flow to the
- *   error path just like the stream body does).
- * - Plain `LLMResponse` (object with `content` field) → `R` (calls `onResp`
- *   synchronously and returns the mapped value).
- * - Anything else → reactive `Node<R>` via `fromAny` + `onFirstData(onResp)`
- *   so late subscribers don't re-fire the side effect.
- *
- * @category internal
- */
-export function adaptInvokeResult<R>(
-	input: NodeInput<LLMResponse>,
-	opts: {
-		onResp: (resp: LLMResponse) => R;
-		/**
-		 * If provided, rejected Promises are piped through this handler (for
-		 * stats / budget recording) before re-throwing. Signature mirrors the
-		 * stream try/catch shape so callers can share a single error-recording
-		 * closure across both paths.
-		 */
-		onError?: (err: unknown) => void;
-		/** Optional node name for the reactive-path derived (describe-friendly). */
-		name?: string;
-	},
-): Promise<R> | R | Node<R> {
-	const { onResp, onError, name } = opts;
-
-	// Promise / thenable: chain .then, optionally .catch.
-	if (input != null && typeof (input as PromiseLike<LLMResponse>).then === "function") {
-		const p = input as Promise<LLMResponse>;
-		if (onError) {
-			return p.then(onResp).catch((err: unknown) => {
-				onError(err);
-				throw err;
-			});
-		}
-		return p.then(onResp);
-	}
-	// Plain LLMResponse (synchronous).
-	if (input != null && typeof input === "object" && "content" in (input as object)) {
-		return onResp(input as LLMResponse);
-	}
-	// Reactive / iterable — map inside a `derived` guarded by `onFirstData`
-	// so the side-effect fires exactly once per node lifetime (push-on-
-	// subscribe replay on late subscribers is silent).
-	const bridged = fromAny(input);
-	// Wire `onError` via a side-subscription on the bridged node. `onFirstData`
-	// only handles DATA — ERROR messages need their own hook so stats /
-	// budget recording fires symmetrically with the Promise path. The
-	// subscription runs for the lifetime of the derived below (keepalive via
-	// the downstream derived's activation), and fires at most once per ERROR
-	// frame. Without this, ERRORs on Node-shaped adapter returns silently
-	// bypass budget/observable recording.
-	if (onError) {
-		let errored = false;
-		bridged.subscribe((msgs) => {
-			for (const m of msgs) {
-				if (errored) return;
-				if ((m as readonly [symbol, unknown])[0] === ERROR) {
-					errored = true;
-					onError((m as readonly [symbol, unknown])[1]);
-				}
-			}
-		});
-	}
-	// `captured` holds the mapped value from the first DATA so re-subscribers
-	// and re-emissions see a stable mapped value without re-firing `onResp`.
-	// Use a distinct `mapped` sentinel (not nullish) because `onResp` may
-	// legitimately return `null` / `undefined` / `0` — the prior
-	// `captured ?? onResp(v)` guard re-fired `onResp` on falsy captured, which
-	// broke the "exactly once per node lifetime" contract.
-	let captured: R;
-	let mapped = false;
-	const tapped = onFirstData(bridged, (v) => {
-		captured = onResp(v);
-		mapped = true;
-	});
-	return node<R>(
-		[tapped],
-		(batchData, actions, ctx) => {
-			const data = batchData.map((batch, i) =>
-				batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-			);
-			const v = data[0];
-			if (v == null) {
-				actions.emit(null as R);
-				return;
-			}
-			if (mapped) {
-				actions.emit(captured);
-				return;
-			}
-			actions.emit(onResp(v as LLMResponse));
-		},
-		{ describeKind: "derived", name: name ?? "adapt/invokeTap" },
-	);
-}
-
-// ---------------------------------------------------------------------------
-// buildCallStats — CallStatsEvent constructor
-// ---------------------------------------------------------------------------
-
-export interface BuildCallStatsArgs {
-	provider: string;
-	model: string;
-	tier?: string;
-	usage: TokenUsage;
-	startNs: number;
-	method: "invoke" | "stream";
-	error?: { readonly type: string; readonly message: string };
-	/** Override the wall-clock stamp (useful for tests / replay). */
-	startWallClockNs?: number;
-	/** Override the monotonic end stamp (useful for tests). */
-	endNs?: number;
-}
-
-/**
- * Constructs a {@link CallStatsEvent} from the arguments observable.ts and
- * budget-gate.ts used to assemble inline. The `timestamp` / `latencyMs` are
- * computed from `startNs` + (optional) `endNs`; `wallClock` is snapshot at
- * call-start via `wallClockNs()` unless overridden.
- *
- * @category internal
- */
-export function buildCallStats(args: BuildCallStatsArgs): CallStatsEvent {
-	const end = args.endNs ?? monotonicNs();
-	return {
-		timestamp: end,
-		wallClock: args.startWallClockNs ?? wallClockNs(),
-		provider: args.provider,
-		model: args.model,
-		tier: args.tier,
-		usage: args.usage,
-		latencyMs: Math.max(0, (end - args.startNs) / 1e6),
-		method: args.method,
-		...(args.error ? { error: args.error } : {}),
-	};
-}
-
-/** Convenience — empty disaggregated usage stub used by every middleware. */
-export function emptyUsageStub(): TokenUsage {
-	return { input: { regular: 0 }, output: { regular: 0 } };
-}
-
-// ---------------------------------------------------------------------------
-// meta.middlewareLayer + describeAdapterStack (Unit 11 Q1 user directive)
-// ---------------------------------------------------------------------------
-
-/** Symbol key carrying the wrap chain on the returned adapter. Non-enumerable. */
-const MIDDLEWARE_LAYERS = Symbol.for("graphrefly.adapter.middlewareLayers");
-
-/**
- * Stamp `adapter` with a middleware-layer name and return it. The stamp is a
- * non-enumerable property keyed by `Symbol.for("graphrefly.adapter.middlewareLayers")`
- * — opaque to users, visible via {@link describeAdapterStack}.
- *
- * Each wrap prepends its layer to `inner`'s chain so the stack can be walked
- * bottom-up (innermost first). Providers have no layer stamp — they show up
- * as the bottom of the chain via their `provider` / `model` identity.
- *
- * @category internal
- */
-export function withLayer<A extends LLMAdapter>(
-	adapter: A,
-	layerName: string,
-	inner?: LLMAdapter,
-): A {
-	const innerLayers = inner ? readLayers(inner) : [];
-	const chain = [...innerLayers, layerName];
-	Object.defineProperty(adapter, MIDDLEWARE_LAYERS, {
-		value: Object.freeze(chain),
-		enumerable: false,
-		writable: false,
-		configurable: false,
-	});
-	return adapter;
-}
-
-/**
- * Returns the middleware-layer names stamped on `adapter`, innermost first.
- * An adapter that has never been wrapped returns `[]` — callers combine the
- * result with `adapter.provider` / `adapter.model` for a full stack render.
- *
- * @example
- * ```ts
- * const stack = describeAdapterStack(resilientAdapter(anthropicAdapter(), opts).adapter);
- * // → ["withLLMTimeout", "withRetry", "withLLMBreaker", "withBudgetGate", "withRateLimiter", "cascade"]
- * ```
- *
- * @category extra
- */
-export function describeAdapterStack(adapter: LLMAdapter): readonly string[] {
-	return readLayers(adapter);
-}
-
-function readLayers(adapter: LLMAdapter): readonly string[] {
-	const v = (adapter as unknown as Record<symbol, unknown>)[MIDDLEWARE_LAYERS];
-	return Array.isArray(v) ? (v as readonly string[]) : [];
-}
diff --git a/src/utils/ai/adapters/core/capabilities.ts b/src/utils/ai/adapters/core/capabilities.ts
deleted file mode 100644
index 324bf3a4..00000000
--- a/src/utils/ai/adapters/core/capabilities.ts
+++ /dev/null
@@ -1,265 +0,0 @@
-/**
- * Pluggable model capabilities (roadmap §9.3d).
- *
- * The library defines the **shape** of what's knowable about a model
- * (context window, rate limits, features, pricing reference) and provides
- * a registry factory. Capability **data** is user-supplied — no baked-in
- * tables, no drift-prone catalog.
- */
-
-import type { Node } from "@graphrefly/pure-ts/core";
-import { node } from "@graphrefly/pure-ts/core";
-
-import { reactiveMap } from "@graphrefly/pure-ts/extra";
-import type { ModelPricing } from "./pricing.js";
-
-// ---------------------------------------------------------------------------
-// Limits
-// ---------------------------------------------------------------------------
-
-/**
- * Rate and size limits for a single model at the user's service tier.
- *
- * Where providers expose distinct standard / batch / flex limits, register
- * each as a separate model id with its own `ModelLimits`.
- */
-export interface ModelLimits {
-	/** Total tokens the model can process per request (input + output). */
-	contextWindow?: number;
-	/** Max input tokens if distinct from contextWindow. */
-	maxInputTokens?: number;
-	/** Max generated output tokens (excludes reasoning unless provider folds them). */
-	maxOutputTokens?: number;
-	/** Max reasoning/thinking tokens budget. */
-	maxReasoningTokens?: number;
-	/** Minimum prompt size for prompt caching to activate. */
-	minCacheTokens?: number;
-	/** Requests-per-minute rate limit. */
-	rpm?: number;
-	/** Requests-per-day rate limit. */
-	rpd?: number;
-	/** Tokens-per-minute rate limit (input + output, per provider convention). */
-	tpm?: number;
-	/** Tokens-per-day rate limit. */
-	tpd?: number;
-	/** Max concurrent in-flight requests. */
-	concurrentRequests?: number;
-	/** Provider-specific limits not covered above. */
-	extensions?: Record<string, number>;
-}
-
-// ---------------------------------------------------------------------------
-// Features
-// ---------------------------------------------------------------------------
-
-export interface ModelFeatures {
-	toolUse?: boolean;
-	vision?: boolean;
-	audioInput?: boolean;
-	audioOutput?: boolean;
-	reasoning?: boolean;
-	streaming?: boolean;
-	promptCache?: boolean;
-	batchApi?: boolean;
-	/** Provider-specific feature flags. */
-	extensions?: Record<string, boolean>;
-}
-
-// ---------------------------------------------------------------------------
-// ModelCapabilities
-// ---------------------------------------------------------------------------
-
-/** Static facts about a model. Pricing is optional; keep a separate registry if preferred. */
-export interface ModelCapabilities {
-	id: string;
-	provider: string;
-	pricing?: ModelPricing;
-	limits?: ModelLimits;
-	features?: ModelFeatures;
-	/** Free-form metadata (release date, deprecation flag, provider notes). */
-	metadata?: Record<string, unknown>;
-}
-
-// ---------------------------------------------------------------------------
-// CapabilitiesRegistry
-// ---------------------------------------------------------------------------
-
-export interface CapabilitiesRegistry {
-	lookup(provider: string, model: string): ModelCapabilities | undefined;
-	register(cap: ModelCapabilities): void;
-	remove(provider: string, model: string): boolean;
-	entries(): IterableIterator<ModelCapabilities>;
-	// Reactive views (Unit 10 Q4) ---------------------------------------------
-	/**
-	 * Reactive view of `(provider, model)` → `ModelCapabilities`. Re-emits
-	 * whenever any `register()` / `remove()` touches the underlying store, so
-	 * UIs and gated middleware (capability-aware retry, feature flags) can
-	 * subscribe instead of polling. Prefix fallback mirrors the imperative
-	 * `lookup()`: exact match first, then longest-prefix within provider.
-	 */
-	lookupNode(provider: string, model: string): Node<ModelCapabilities | undefined>;
-	/** Reactive view of every registered entry. */
-	readonly entriesNode: Node<readonly ModelCapabilities[]>;
-	/** Reactive slice of entries for a single provider. */
-	byProvider(provider: string): Node<readonly ModelCapabilities[]>;
-}
-
-function capKey(provider: string, model: string): string {
-	return `${provider}::${model}`;
-}
-
-/** Create a fresh `CapabilitiesRegistry`. Optionally seed with entries. */
-export function createCapabilitiesRegistry(
-	initial?: readonly ModelCapabilities[],
-): CapabilitiesRegistry {
-	// Reactive storage (Unit 10 Q4). We keep the imperative `lookup` fast path
-	// (O(1) exact match + prefix fallback) by reading the bundle's snapshot via
-	// `.cache`. Reactive views (`lookupNode`, `entriesNode`, `byProvider`) are
-	// `derived` nodes over the bundle's `entries` node.
-	const bundle = reactiveMap<string, ModelCapabilities>({
-		name: "capabilitiesRegistry",
-	});
-
-	const register = (cap: ModelCapabilities): void => {
-		bundle.set(capKey(cap.provider, cap.id), cap);
-	};
-
-	if (initial) for (const cap of initial) register(cap);
-
-	const lookupSync = (provider: string, model: string): ModelCapabilities | undefined => {
-		const exact = bundle.get(capKey(provider, model));
-		if (exact) return exact;
-		// Prefix fallback within provider via snapshot iteration. The fast
-		// path (`maxSize` unset → all entries live) keeps this O(|models|).
-		const snapshot = bundle.entries.cache;
-		if (!snapshot) return undefined;
-		let best: ModelCapabilities | undefined;
-		for (const [, cap] of snapshot) {
-			if (cap.provider !== provider) continue;
-			const candidate = cap.id;
-			if (model.startsWith(candidate)) {
-				if (!best || candidate.length > best.id.length) {
-					best = cap;
-				}
-			}
-		}
-		return best;
-	};
-
-	// Reactive views — derived over the bundle's entries snapshot. Caches
-	// per-(provider, model) pair so re-invoking `lookupNode("anthropic", "X")`
-	// returns the same node (keepalive stays attached, no churn).
-	//
-	// LRU cap protects callers that mint `lookupNode(provider, userSupplied)`
-	// from unbounded growth. Native `Map` insertion-order iteration gives us
-	// O(1) eviction: the oldest insertion is the first key. 128 is large
-	// enough to cover realistic provider × model combos (every shipped
-	// Anthropic / OpenAI / Google model fits well under this).
-	const LOOKUP_CACHE_MAX = 128;
-	const lookupCache = new Map<string, Node<ModelCapabilities | undefined>>();
-	const byProviderCache = new Map<string, Node<readonly ModelCapabilities[]>>();
-	const lruTouch = <V>(cache: Map<string, V>, key: string, value: V, max: number): void => {
-		// Delete-then-reinsert moves the key to the LRU end; evict the oldest
-		// (first-inserted) entry when we overflow.
-		if (cache.has(key)) cache.delete(key);
-		cache.set(key, value);
-		while (cache.size > max) {
-			const oldest = cache.keys().next().value as string | undefined;
-			if (oldest === undefined) break;
-			cache.delete(oldest);
-		}
-	};
-
-	const entriesNode = node<readonly ModelCapabilities[]>(
-		[bundle.entries],
-		(batchData, actions, ctx) => {
-			const data = batchData.map((batch, i) =>
-				batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-			);
-			const snapshot = data[0];
-			// Defensive coercion: `ReactiveMapBundle.entries` always emits a
-			// real `Map` on the live emit path, but a snapshot-restore round
-			// trip can deliver a plain `{}` (the default codec serializes
-			// `Map` to a non-Map shape). Without the `instanceof` guard,
-			// `.values()` would be `undefined`. Same defense pattern as
-			// `mapFromSnapshot` in `extra/composite.ts`.
-			actions.emit(
-				snapshot instanceof Map
-					? Array.from((snapshot as ReadonlyMap<string, ModelCapabilities>).values())
-					: [],
-			);
-		},
-		{
-			describeKind: "derived",
-			name: "capabilitiesRegistry/entries",
-			initial: [] as ModelCapabilities[],
-		},
-	);
-
-	return {
-		register,
-		lookup: lookupSync,
-		remove(provider, model) {
-			const existed = bundle.has(capKey(provider, model));
-			if (existed) bundle.delete(capKey(provider, model));
-			return existed;
-		},
-		entries() {
-			// Snapshot via bundle — matches legacy behavior.
-			const snapshot = bundle.entries.cache;
-			return (function* () {
-				if (!snapshot) return;
-				for (const cap of snapshot.values()) yield cap;
-			})();
-		},
-		lookupNode(provider, model) {
-			const cacheKey = capKey(provider, model);
-			const cached = lookupCache.get(cacheKey);
-			if (cached) {
-				// LRU touch: move to end so it survives eviction.
-				lookupCache.delete(cacheKey);
-				lookupCache.set(cacheKey, cached);
-				return cached;
-			}
-			const lookupNode = node<ModelCapabilities | undefined>(
-				[bundle.entries],
-				(_batchData, actions) => {
-					actions.emit(lookupSync(provider, model));
-				},
-				{
-					describeKind: "derived",
-					name: `capabilitiesRegistry/lookup/${provider}::${model}`,
-					initial: undefined,
-				},
-			);
-			lruTouch(lookupCache, cacheKey, lookupNode, LOOKUP_CACHE_MAX);
-			return lookupNode;
-		},
-		entriesNode,
-		byProvider(provider) {
-			const cached = byProviderCache.get(provider);
-			if (cached) {
-				byProviderCache.delete(provider);
-				byProviderCache.set(provider, cached);
-				return cached;
-			}
-			const providerNode = node<readonly ModelCapabilities[]>(
-				[entriesNode],
-				(batchData, actions, ctx) => {
-					const data = batchData.map((batch, i) =>
-						batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-					);
-					const entries = data[0] as readonly ModelCapabilities[];
-					actions.emit(entries.filter((c) => c.provider === provider));
-				},
-				{
-					describeKind: "derived",
-					name: `capabilitiesRegistry/byProvider/${provider}`,
-					initial: [],
-				},
-			);
-			lruTouch(byProviderCache, provider, providerNode, LOOKUP_CACHE_MAX);
-			return providerNode;
-		},
-	};
-}
diff --git a/src/utils/ai/adapters/core/factory.ts b/src/utils/ai/adapters/core/factory.ts
deleted file mode 100644
index b5625ff7..00000000
--- a/src/utils/ai/adapters/core/factory.ts
+++ /dev/null
@@ -1,113 +0,0 @@
-/**
- * `createAdapter` — provider-dispatching factory.
- *
- * One entry point, one config object. Picks the right concrete adapter by
- * `provider`, forwards everything else. Users who want finer control import
- * the concrete adapter directly (`anthropicAdapter`, `openAICompatAdapter`,
- * `googleAdapter`, `dryRunAdapter`, `webllmAdapter`, `chromeNanoAdapter`).
- */
-
-import { type AnthropicAdapterOptions, anthropicAdapter } from "../providers/anthropic.js";
-import { type DryRunAdapterOptions, dryRunAdapter } from "../providers/dry-run.js";
-import { type FallbackAdapterOptions, fallbackAdapter } from "../providers/fallback.js";
-import { type GoogleAdapterOptions, googleAdapter } from "../providers/google.js";
-import {
-	type OpenAICompatAdapterOptions,
-	type OpenAICompatPreset,
-	openAICompatAdapter,
-} from "../providers/openai-compat.js";
-import type { LLMAdapter } from "./types.js";
-
-export type AdapterProvider =
-	| "anthropic"
-	| OpenAICompatPreset // "openai" | "openrouter" | "groq" | "ollama" | "deepseek" | "xai"
-	| "google"
-	| "dry-run"
-	| "fallback";
-
-export interface CreateAdapterOptions {
-	provider: AdapterProvider;
-	apiKey?: string;
-	model?: string;
-	baseURL?: string;
-	headers?: Record<string, string>;
-	/** OpenAI-compat bodyExtras (OpenRouter routing, etc.). */
-	bodyExtras?: Record<string, unknown>;
-	/** Provider-specific SDK instance (any of AnthropicSdkLike / OpenAISdkLike / GoogleSdkLike). */
-	sdk?: unknown;
-	/** Custom fetch (for tests). */
-	fetchImpl?: typeof fetch;
-	/** Extra per-provider options forwarded verbatim. */
-	extras?: Record<string, unknown>;
-}
-
-export function createAdapter(opts: CreateAdapterOptions): LLMAdapter {
-	switch (opts.provider) {
-		case "anthropic": {
-			const a: AnthropicAdapterOptions = {
-				apiKey: opts.apiKey,
-				model: opts.model,
-				baseURL: opts.baseURL,
-				headers: opts.headers,
-				sdk: opts.sdk as AnthropicAdapterOptions["sdk"],
-				fetchImpl: opts.fetchImpl,
-				...(opts.extras as AnthropicAdapterOptions | undefined),
-			};
-			return anthropicAdapter(a);
-		}
-		case "google": {
-			const g: GoogleAdapterOptions = {
-				apiKey: opts.apiKey,
-				model: opts.model,
-				baseURL: opts.baseURL,
-				headers: opts.headers,
-				sdk: opts.sdk as GoogleAdapterOptions["sdk"],
-				fetchImpl: opts.fetchImpl,
-				...(opts.extras as GoogleAdapterOptions | undefined),
-			};
-			return googleAdapter(g);
-		}
-		case "dry-run": {
-			const d: DryRunAdapterOptions = {
-				model: opts.model,
-				...(opts.extras as DryRunAdapterOptions | undefined),
-			};
-			return dryRunAdapter(d);
-		}
-		case "fallback": {
-			// `provider`/`model` threaded as labels; `fixtures`/`record`/etc.
-			// must come through `extras` since `CreateAdapterOptions` doesn't
-			// have dedicated slots for them.
-			const f: FallbackAdapterOptions = {
-				provider: opts.provider,
-				model: opts.model,
-				...(opts.extras as FallbackAdapterOptions | undefined),
-			};
-			return fallbackAdapter(f);
-		}
-		// OpenAI-compat presets
-		case "openai":
-		case "openrouter":
-		case "groq":
-		case "ollama":
-		case "deepseek":
-		case "xai": {
-			const c: OpenAICompatAdapterOptions = {
-				preset: opts.provider,
-				apiKey: opts.apiKey,
-				model: opts.model,
-				baseURL: opts.baseURL,
-				headers: opts.headers,
-				bodyExtras: opts.bodyExtras,
-				sdk: opts.sdk as OpenAICompatAdapterOptions["sdk"],
-				fetchImpl: opts.fetchImpl,
-				...(opts.extras as OpenAICompatAdapterOptions | undefined),
-			};
-			return openAICompatAdapter(c);
-		}
-		default: {
-			const never: never = opts.provider;
-			throw new Error(`createAdapter: unknown provider: ${String(never)}`);
-		}
-	}
-}
diff --git a/src/utils/ai/adapters/core/index.ts b/src/utils/ai/adapters/core/index.ts
deleted file mode 100644
index 0defe553..00000000
--- a/src/utils/ai/adapters/core/index.ts
+++ /dev/null
@@ -1,12 +0,0 @@
-/**
- * Core surface for LLM adapters — types, pricing, capabilities, stats.
- *
- * No model data, no provider SDKs, no middleware. Pure domain types +
- * pluggable registry factories.
- */
-
-export * from "./capabilities.js";
-export * from "./factory.js";
-export * from "./observable.js";
-export * from "./pricing.js";
-export * from "./types.js";
diff --git a/src/utils/ai/adapters/core/observable.ts b/src/utils/ai/adapters/core/observable.ts
deleted file mode 100644
index d9b13232..00000000
--- a/src/utils/ai/adapters/core/observable.ts
+++ /dev/null
@@ -1,277 +0,0 @@
-/**
- * Observable adapter wrapper — the "inverted statistics" surface.
- *
- * The library emits structured facts (token counts, latency, timestamps)
- * as reactive nodes. Users compose interpretation (pricing, dashboards,
- * telemetry, budget breakers) as derived layers on top.
- */
-
-import { monotonicNs, type Node, node, wallClockNs } from "@graphrefly/pure-ts/core";
-import { keepalive, type ReactiveLogBundle, reactiveLog } from "@graphrefly/pure-ts/extra";
-import {
-	adapterWrapper,
-	adaptInvokeResult,
-	buildCallStats,
-	emptyUsageStub,
-	withLayer,
-} from "../_internal/wrappers.js";
-import type {
-	ChatMessage,
-	LLMAdapter,
-	LLMInvokeOptions,
-	LLMResponse,
-	StreamDelta,
-	TokenUsage,
-} from "./types.js";
-import { sumInputTokens, sumOutputTokens } from "./types.js";
-
-// ---------------------------------------------------------------------------
-// CallStatsEvent
-// ---------------------------------------------------------------------------
-
-/** One call's structured statistics — emitted after `invoke()` / `stream()` settles. */
-export interface CallStatsEvent {
-	/** `monotonicNs()` at call completion — use for event ordering. */
-	readonly timestamp: number;
-	/** `wallClockNs()` at call start — use for human-readable attribution. */
-	readonly wallClock: number;
-	readonly provider: string;
-	readonly model: string;
-	readonly tier?: string;
-	readonly usage: TokenUsage;
-	readonly latencyMs: number;
-	/** `"invoke"` or `"stream"`. */
-	readonly method: "invoke" | "stream";
-	/** Populated when the call errored — usage may be zero or partial. */
-	readonly error?: { readonly type: string; readonly message: string };
-}
-
-// ---------------------------------------------------------------------------
-// AdapterStats bundle
-// ---------------------------------------------------------------------------
-
-export interface AdapterStats {
-	/**
-	 * Reactive node for the most-recent call event. Emits `null` initially
-	 * (no calls yet); emits a {@link CallStatsEvent} after each call. Subscribe
-	 * and filter `!= null` if you want a `Node<CallStatsEvent>`.
-	 */
-	readonly lastCall: Node<CallStatsEvent | null>;
-	/** Full event log (bounded by `opts.logMax`, default 1000). */
-	readonly allCalls: ReactiveLogBundle<CallStatsEvent>;
-	/** Total calls observed since last reset. */
-	readonly totalCalls: Node<number>;
-	/** Sum of every input-token class across observed calls. */
-	readonly totalInputTokens: Node<number>;
-	/** Sum of every output-token class across observed calls. */
-	readonly totalOutputTokens: Node<number>;
-	/** Reset all counters + clear the log. */
-	reset(): void;
-	/**
-	 * Release the internal keepalive subscriptions on the three counter
-	 * derives (`totalCalls` / `totalInputTokens` / `totalOutputTokens`) so the
-	 * bundle can be GC'd when the caller discards it. Idempotent. Long-lived
-	 * adapter bundles (module-level singletons) can ignore; transient bundles
-	 * (per-request / per-user) should call on teardown.
-	 */
-	dispose(): void;
-}
-
-// ---------------------------------------------------------------------------
-// observableAdapter
-// ---------------------------------------------------------------------------
-
-/**
- * Wrap any {@link LLMAdapter} with a reactive stats bundle.
- *
- * Implementation (Unit 10 B):
- * - `stats.lastCall` is a `state<CallStatsEvent | null>`.
- * - Counters (`totalCalls` / `totalInputTokens` / `totalOutputTokens`) are
- *   **derived views** over `allCalls.entries` — self-maintaining, no manual
- *   `.cache + 1 + emit` pattern, visible topology in `describe()`.
- * - `stats.allCalls` is a `reactiveLog<CallStatsEvent>` — bounded, supports
- *   `tail(n)` / `slice(start, stop)` for dashboard views.
- * - The wrapped adapter passes DATA through via `adaptInvokeResult`, which
- *   uses `onFirstData` internally to guard against re-subscription double-fire
- *   and wires `.catch` for Promise-path error recording (Unit 10 A).
- */
-export function observableAdapter(
-	inner: LLMAdapter,
-	opts?: { logMax?: number; name?: string },
-): { adapter: LLMAdapter; stats: AdapterStats } {
-	const logMax = opts?.logMax ?? 1000;
-	const allCalls = reactiveLog<CallStatsEvent>(undefined, {
-		name: opts?.name ? `${opts.name}/stats` : "adapterStats",
-		maxSize: logMax,
-	});
-
-	const lastCall = node<CallStatsEvent | null>([], {
-		name: "adapterStats/lastCall",
-		initial: null,
-	});
-
-	// Counters as derived views over the log — self-maintaining (Unit 10 B).
-	// `initial` seeds them so late subscribers see 0 before any call lands.
-	const totalCalls = node<number>(
-		[allCalls.entries],
-		(batchData, actions, ctx) => {
-			const data = batchData.map((batch, i) =>
-				batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-			);
-			const entries = data[0] as readonly CallStatsEvent[];
-			actions.emit(entries.length);
-		},
-		{ describeKind: "derived", name: "adapterStats/totalCalls", initial: 0 },
-	);
-	const totalInputTokens = node<number>(
-		[allCalls.entries],
-		(batchData, actions, ctx) => {
-			const data = batchData.map((batch, i) =>
-				batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-			);
-			const entries = data[0] as readonly CallStatsEvent[];
-			actions.emit(entries.reduce((acc, ev) => acc + sumInputTokens(ev.usage), 0));
-		},
-		{ describeKind: "derived", name: "adapterStats/totalInputTokens", initial: 0 },
-	);
-	const totalOutputTokens = node<number>(
-		[allCalls.entries],
-		(batchData, actions, ctx) => {
-			const data = batchData.map((batch, i) =>
-				batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-			);
-			const entries = data[0] as readonly CallStatsEvent[];
-			actions.emit(entries.reduce((acc, ev) => acc + sumOutputTokens(ev.usage), 0));
-		},
-		{ describeKind: "derived", name: "adapterStats/totalOutputTokens", initial: 0 },
-	);
-	// Keepalive — counters track the log whether or not an external subscriber
-	// is attached, so `.cache` on the counters stays current. Captured as an
-	// array so `AdapterStats.dispose()` can release them all.
-	const unsubKeepalives: Array<() => void> = [
-		keepalive(totalCalls),
-		keepalive(totalInputTokens),
-		keepalive(totalOutputTokens),
-	];
-
-	const record = (ev: CallStatsEvent): void => {
-		allCalls.append(ev);
-		lastCall.emit(ev);
-	};
-
-	const reset = (): void => {
-		allCalls.clear();
-		lastCall.emit(null);
-	};
-
-	const wrap = adapterWrapper(inner, {
-		invoke(messages, invokeOpts) {
-			const startNs = monotonicNs();
-			const startWallClockNs = wallClockNs();
-			const model = inner.model ?? invokeOpts?.model ?? "";
-			const recordResp = (resp: LLMResponse): LLMResponse => {
-				record(
-					buildCallStats({
-						provider: inner.provider,
-						model: inner.model ?? invokeOpts?.model ?? resp.model ?? "",
-						tier: invokeOpts?.tier ?? resp.tier,
-						usage: resp.usage ?? emptyUsageStub(),
-						startNs,
-						startWallClockNs,
-						method: "invoke",
-					}),
-				);
-				return resp;
-			};
-			const recordErr = (err: unknown): void => {
-				const e = err as Error | undefined;
-				record(
-					buildCallStats({
-						provider: inner.provider,
-						model,
-						tier: invokeOpts?.tier,
-						usage: emptyUsageStub(),
-						startNs,
-						startWallClockNs,
-						method: "invoke",
-						error: {
-							type: e?.name ?? "Error",
-							message: e?.message ?? String(err),
-						},
-					}),
-				);
-			};
-			return adaptInvokeResult(inner.invoke(messages, invokeOpts), {
-				onResp: recordResp,
-				onError: recordErr,
-				name: "adapterStats/invokeTap",
-			});
-		},
-
-		async *stream(messages, invokeOpts) {
-			const startNs = monotonicNs();
-			const startWallClockNs = wallClockNs();
-			const model = inner.model ?? invokeOpts?.model ?? "";
-			let finalUsage: TokenUsage | undefined;
-			try {
-				for await (const delta of inner.stream(messages, invokeOpts)) {
-					if (delta.type === "usage") finalUsage = delta.usage;
-					yield delta;
-				}
-				record(
-					buildCallStats({
-						provider: inner.provider,
-						model,
-						tier: invokeOpts?.tier,
-						usage: finalUsage ?? emptyUsageStub(),
-						startNs,
-						startWallClockNs,
-						method: "stream",
-					}),
-				);
-			} catch (err) {
-				const e = err as Error | undefined;
-				record(
-					buildCallStats({
-						provider: inner.provider,
-						model,
-						tier: invokeOpts?.tier,
-						usage: finalUsage ?? emptyUsageStub(),
-						startNs,
-						startWallClockNs,
-						method: "stream",
-						error: {
-							type: e?.name ?? "Error",
-							message: e?.message ?? String(err),
-						},
-					}),
-				);
-				throw err;
-			}
-		},
-	});
-
-	withLayer(wrap, "observableAdapter", inner);
-
-	let disposed = false;
-	const dispose = (): void => {
-		if (disposed) return;
-		disposed = true;
-		for (const fn of unsubKeepalives) fn();
-		unsubKeepalives.length = 0;
-	};
-
-	const stats: AdapterStats = {
-		lastCall,
-		allCalls,
-		totalCalls,
-		totalInputTokens,
-		totalOutputTokens,
-		reset,
-		dispose,
-	};
-
-	return { adapter: wrap, stats };
-}
-
-export type { ChatMessage, LLMAdapter, LLMInvokeOptions, LLMResponse, StreamDelta, TokenUsage };
diff --git a/src/utils/ai/adapters/core/pricing.ts b/src/utils/ai/adapters/core/pricing.ts
deleted file mode 100644
index 5e50f82d..00000000
--- a/src/utils/ai/adapters/core/pricing.ts
+++ /dev/null
@@ -1,373 +0,0 @@
-/**
- * Pluggable pricing for LLM adapters.
- *
- * The library ships the **shape** (types + computation helpers + registry
- * factory) and **zero model data**. Users populate a `PricingRegistry` with
- * the prices for the models they use — either by hand, from a curated table,
- * or by importing a third-party dataset (litellm JSON, etc.).
- *
- * Pricing is a pure function of raw `TokenUsage`. The library does not
- * know current prices, regional rates, tier thresholds, or promotional
- * discounts — those are all user domain.
- */
-
-import type { TokenUsage } from "./types.js";
-import { sumInputTokens } from "./types.js";
-
-// ---------------------------------------------------------------------------
-// Rate shape
-// ---------------------------------------------------------------------------
-
-/**
- * A rate per 1M tokens. Supports threshold-based tiering (Anthropic
- * long-context >200K, Gemini >200K) via optional `thresholdTokens` +
- * `pricePerMillionAbove`.
- *
- * `total input tokens` (sum of every input class) is the axis the threshold
- * applies to — matches how Anthropic and Gemini measure it.
- */
-export interface TieredRate {
-	pricePerMillion: number;
-	thresholdTokens?: number;
-	pricePerMillionAbove?: number;
-}
-
-/** Shorthand: a plain `number` stands for `{pricePerMillion: n}`. */
-export type Rate = TieredRate | number;
-
-function rateAt(rate: Rate | undefined, totalInput: number): number {
-	if (rate == null) return 0;
-	if (typeof rate === "number") return rate;
-	if (
-		rate.thresholdTokens != null &&
-		rate.pricePerMillionAbove != null &&
-		totalInput > rate.thresholdTokens
-	) {
-		return rate.pricePerMillionAbove;
-	}
-	return rate.pricePerMillion;
-}
-
-// ---------------------------------------------------------------------------
-// ModelPricing
-// ---------------------------------------------------------------------------
-
-/** USD-per-1M rates per token class. All fields optional. */
-export interface ModelPricing {
-	input?: {
-		regular?: Rate;
-		cacheRead?: Rate;
-		cacheWrite5m?: Rate;
-		cacheWrite1h?: Rate;
-		cacheWriteOther?: Rate;
-		audio?: Rate;
-		image?: Rate;
-		video?: Rate;
-		toolUse?: Rate;
-		extensions?: Record<string, Rate>;
-	};
-	output?: {
-		regular?: Rate;
-		reasoning?: Rate;
-		audio?: Rate;
-		predictionAccepted?: Rate;
-		predictionRejected?: Rate;
-		extensions?: Record<string, Rate>;
-	};
-	/**
-	 * Per-unit costs for non-token axes. Values are USD per unit; units
-	 * match `TokenUsage.auxiliary` keys (e.g. `webSearchRequests`, `cacheStorageHours`).
-	 */
-	auxiliary?: Record<string, number>;
-	/**
-	 * Service-tier multipliers. Applied to the summed per-class price.
-	 * E.g. `{ batch: 0.5, flex: 0.5, priority: 1.25 }`. Default (no tier or
-	 * tier not present in the map): multiplier = 1.
-	 */
-	tierMultipliers?: Record<string, number>;
-	/** Currency code (ISO 4217). Defaults to "USD" when constructed via helpers. */
-	currency: string;
-}
-
-// ---------------------------------------------------------------------------
-// Price breakdown
-// ---------------------------------------------------------------------------
-
-/** Result of computing a price from usage + pricing. */
-export interface PriceBreakdown {
-	/** Total charge in `currency`. */
-	total: number;
-	currency: string;
-	/**
-	 * Optional per-class subtotals. Keys are dot-separated paths like
-	 * `"input.regular"`, `"output.reasoning"`, `"auxiliary.webSearchRequests"`.
-	 */
-	breakdown?: Record<string, number>;
-}
-
-/** Zero-charge breakdown — returned when no pricing is available for a model. */
-export function zeroPrice(currency = "USD"): PriceBreakdown {
-	return { total: 0, currency };
-}
-
-// ---------------------------------------------------------------------------
-// computePrice — the math
-// ---------------------------------------------------------------------------
-
-/**
- * Compute price from a usage object + model pricing.
- *
- * - Tier-threshold math uses `sumInputTokens(usage)` as the axis.
- * - Service tier (`opts.tier`) multiplies the final total via `tierMultipliers`.
- * - Each token class is priced independently using the matching `Rate` lookup.
- * - `breakdown` is populated when `opts.withBreakdown = true` (default false
- *   to keep hot-path allocations low).
- */
-export function computePrice(
-	usage: TokenUsage,
-	pricing: ModelPricing,
-	opts?: { tier?: string; withBreakdown?: boolean },
-): PriceBreakdown {
-	const totalInput = sumInputTokens(usage);
-	const currency = pricing.currency ?? "USD";
-	const withBreakdown = opts?.withBreakdown === true;
-	const breakdown: Record<string, number> = withBreakdown ? {} : (null as never);
-
-	let total = 0;
-
-	const addLine = (key: string, tokens: number, rate: Rate | undefined): void => {
-		if (!tokens || rate == null) return;
-		const rateUsd = rateAt(rate, totalInput);
-		const line = (tokens * rateUsd) / 1_000_000;
-		total += line;
-		if (withBreakdown) breakdown[key] = (breakdown[key] ?? 0) + line;
-	};
-
-	// Input classes
-	const i = usage.input;
-	const pi = pricing.input;
-	if (pi) {
-		addLine("input.regular", i.regular, pi.regular);
-		addLine("input.cacheRead", i.cacheRead ?? 0, pi.cacheRead);
-		addLine("input.cacheWrite5m", i.cacheWrite5m ?? 0, pi.cacheWrite5m);
-		addLine("input.cacheWrite1h", i.cacheWrite1h ?? 0, pi.cacheWrite1h);
-		addLine("input.cacheWriteOther", i.cacheWriteOther ?? 0, pi.cacheWriteOther);
-		addLine("input.audio", i.audio ?? 0, pi.audio);
-		addLine("input.image", i.image ?? 0, pi.image);
-		addLine("input.video", i.video ?? 0, pi.video);
-		addLine("input.toolUse", i.toolUse ?? 0, pi.toolUse);
-		if (i.extensions && pi.extensions) {
-			for (const [k, v] of Object.entries(i.extensions)) {
-				addLine(`input.ext.${k}`, v, pi.extensions[k]);
-			}
-		}
-	}
-
-	// Output classes
-	const o = usage.output;
-	const po = pricing.output;
-	if (po) {
-		addLine("output.regular", o.regular, po.regular);
-		addLine("output.reasoning", o.reasoning ?? 0, po.reasoning);
-		addLine("output.audio", o.audio ?? 0, po.audio);
-		addLine("output.predictionAccepted", o.predictionAccepted ?? 0, po.predictionAccepted);
-		addLine("output.predictionRejected", o.predictionRejected ?? 0, po.predictionRejected);
-		if (o.extensions && po.extensions) {
-			for (const [k, v] of Object.entries(o.extensions)) {
-				addLine(`output.ext.${k}`, v, po.extensions[k]);
-			}
-		}
-	}
-
-	// Service-tier multiplier applies to token costs only. Auxiliary costs
-	// (per-request web-search fees, cache storage-hours, etc.) are typically
-	// priced flat regardless of tier — e.g., Anthropic batch discount applies
-	// to input/output tokens but NOT to web_search_requests. Apply the
-	// multiplier to the token total before adding auxiliary lines.
-	const tier = opts?.tier;
-	if (tier && pricing.tierMultipliers) {
-		const mult = pricing.tierMultipliers[tier];
-		if (mult != null) {
-			total *= mult;
-			if (withBreakdown) {
-				for (const k of Object.keys(breakdown)) breakdown[k] *= mult;
-			}
-		}
-	}
-
-	// Auxiliary (per-unit, not per-million; not tier-multiplied)
-	const aux = usage.auxiliary;
-	const paux = pricing.auxiliary;
-	if (aux && paux) {
-		for (const [k, units] of Object.entries(aux)) {
-			const rate = paux[k];
-			if (rate == null || !units) continue;
-			const line = units * rate;
-			total += line;
-			if (withBreakdown) breakdown[`auxiliary.${k}`] = line;
-		}
-	}
-
-	return withBreakdown ? { total, currency, breakdown } : { total, currency };
-}
-
-// ---------------------------------------------------------------------------
-// PricingFn
-// ---------------------------------------------------------------------------
-
-/** Pure function: given usage + call context, produce a price. */
-export type PricingFn = (
-	usage: TokenUsage,
-	ctx: { model: string; provider: string; tier?: string; withBreakdown?: boolean },
-) => PriceBreakdown;
-
-// ---------------------------------------------------------------------------
-// PricingRegistry
-// ---------------------------------------------------------------------------
-
-/**
- * A keyed store of `ModelPricing`. Users populate it at app startup.
- * The library ships the factory and zero data.
- *
- * Keys are `(provider, model)` pairs. Lookup attempts exact match first,
- * then longest-prefix match on model (e.g. `"claude-sonnet-4-6"` matches a
- * stored `"claude-sonnet-4-6"` entry when looking up
- * `"claude-sonnet-4-6-20260401"`).
- *
- * **Prefix-match footgun:** a registered `"gemini-1"` will also match a
- * lookup for `"gemini-1.5-pro"` (since `"gemini-1.5-pro".startsWith("gemini-1")`
- * is true). Longest-match tie-breaking mitigates most cases, but when
- * registering a short family-prefix alongside versioned descendants, make sure
- * the versioned entry is present — otherwise the family prefix wins. Best
- * practice: register exact versioned model ids; use short family aliases
- * sparingly and only when all version variants share one pricing schedule.
- */
-export interface PricingRegistry {
-	lookup(provider: string, model: string): ModelPricing | undefined;
-	register(provider: string, model: string, pricing: ModelPricing): void;
-	/** Remove a model's entry; returns `true` if it existed. */
-	remove(provider: string, model: string): boolean;
-	/** Enumerate all entries (for debugging / dump). */
-	entries(): IterableIterator<[string, string, ModelPricing]>;
-}
-
-function registryKey(provider: string, model: string): string {
-	return `${provider}::${model}`;
-}
-
-/** Create a fresh `PricingRegistry`. Optionally seed with entries. */
-export function createPricingRegistry(
-	initial?: ReadonlyArray<readonly [provider: string, model: string, pricing: ModelPricing]>,
-): PricingRegistry {
-	const map = new Map<string, { provider: string; model: string; pricing: ModelPricing }>();
-	const indexByProvider = new Map<string, Set<string>>();
-
-	const register = (provider: string, model: string, pricing: ModelPricing): void => {
-		map.set(registryKey(provider, model), { provider, model, pricing });
-		let models = indexByProvider.get(provider);
-		if (!models) {
-			models = new Set();
-			indexByProvider.set(provider, models);
-		}
-		models.add(model);
-	};
-
-	if (initial) {
-		for (const [p, m, pricing] of initial) register(p, m, pricing);
-	}
-
-	return {
-		register,
-		lookup(provider, model) {
-			const exact = map.get(registryKey(provider, model));
-			if (exact) return exact.pricing;
-			// Prefix fallback within provider.
-			const models = indexByProvider.get(provider);
-			if (!models) return undefined;
-			// Pick the longest prefix match for stability.
-			let best: { key: string; pricing: ModelPricing } | undefined;
-			for (const candidate of models) {
-				if (model.startsWith(candidate)) {
-					if (!best || candidate.length > best.key.length) {
-						const entry = map.get(registryKey(provider, candidate));
-						if (entry) best = { key: candidate, pricing: entry.pricing };
-					}
-				}
-			}
-			return best?.pricing;
-		},
-		remove(provider, model) {
-			const existed = map.delete(registryKey(provider, model));
-			if (existed) {
-				const models = indexByProvider.get(provider);
-				models?.delete(model);
-				if (models && models.size === 0) indexByProvider.delete(provider);
-			}
-			return existed;
-		},
-		entries(): IterableIterator<[string, string, ModelPricing]> {
-			const iter = map.values();
-			return (function* () {
-				for (const { provider, model, pricing } of iter) {
-					yield [provider, model, pricing];
-				}
-			})();
-		},
-	};
-}
-
-/**
- * Build a `PricingFn` from a `PricingRegistry`. If no entry matches, returns
- * `{ total: 0, currency: "USD" }` (never throws). Callers who need "unknown
- * model" failures can compose their own `PricingFn`.
- */
-export function registryPricing(registry: PricingRegistry, defaultCurrency = "USD"): PricingFn {
-	return (usage, ctx) => {
-		const pricing = registry.lookup(ctx.provider, ctx.model);
-		if (!pricing) return zeroPrice(defaultCurrency);
-		return computePrice(usage, pricing, { tier: ctx.tier, withBreakdown: ctx.withBreakdown });
-	};
-}
-
-/** Compose multiple `PricingFn`s — first non-zero wins. Useful for registry layering. */
-export function composePricing(...fns: readonly PricingFn[]): PricingFn {
-	return (usage, ctx) => {
-		for (const fn of fns) {
-			const p = fn(usage, ctx);
-			if (p.total !== 0) return p;
-		}
-		return fns.length > 0 ? fns[0](usage, ctx) : zeroPrice();
-	};
-}
-
-/**
- * Convenience: compute a {@link PriceBreakdown} directly from a
- * {@link import("./capabilities.js").ModelCapabilities} object + usage.
- *
- * When callers look up capabilities themselves (via
- * `capabilitiesRegistry.lookup(...)` or `adapter.capabilities?.(model)`),
- * this helper skips the pricing-registry round-trip and computes the price
- * from `capabilities.pricing` directly.
- *
- * Returns `zeroPrice()` when `capabilities.pricing` is undefined — never throws.
- *
- * @param capabilities - Model capabilities object (`capabilities.pricing` may be absent).
- * @param usage - Per-call usage to price.
- * @param opts - Pass-through to {@link computePrice}.
- *
- * @example
- * ```ts
- * const cap = registry.lookup("anthropic", "claude-sonnet-4-6");
- * const price = pricingFor(cap, resp.usage, { tier: "batch", withBreakdown: true });
- * ```
- *
- * @category ai
- */
-export function pricingFor(
-	capabilities: import("./capabilities.js").ModelCapabilities | undefined,
-	usage: TokenUsage,
-	opts?: { tier?: string; withBreakdown?: boolean },
-): PriceBreakdown {
-	if (!capabilities?.pricing) return zeroPrice();
-	return computePrice(usage, capabilities.pricing, opts);
-}
diff --git a/src/utils/ai/adapters/core/types.ts b/src/utils/ai/adapters/core/types.ts
deleted file mode 100644
index 1b173a12..00000000
--- a/src/utils/ai/adapters/core/types.ts
+++ /dev/null
@@ -1,308 +0,0 @@
-/**
- * Core types for LLM adapters (roadmap §9.3d).
- *
- * The library defines the shape of:
- *   - Token usage (raw, disaggregated; user decides how to combine)
- *   - Responses and streaming deltas
- *   - The `LLMAdapter` protocol (reactive-friendly via `NodeInput`)
- *   - Chat, tool, and invocation option shapes
- *
- * It ships **zero model data**. Pricing and capability registries are
- * user-populated (see `pricing.ts` and `capabilities.ts`).
- */
-
-import type { Node } from "@graphrefly/pure-ts/core";
-import type { NodeInput } from "@graphrefly/pure-ts/extra";
-
-// ---------------------------------------------------------------------------
-// Token usage — raw, disaggregated, extensible
-// ---------------------------------------------------------------------------
-
-/**
- * Input token classes.
- *
- * Every provider's native usage object maps into this shape without loss.
- * All fields except `regular` are optional — providers that don't expose
- * the class simply leave it undefined.
- */
-export interface InputTokens {
-	/** Uncached regular input tokens (cache miss or never-cached). */
-	regular: number;
-	/** Read from prompt cache (all TTLs — providers don't split reads by TTL today). */
-	cacheRead?: number;
-	/** Written to cache with 5-min TTL (Anthropic `ephemeral_5m_input_tokens`). */
-	cacheWrite5m?: number;
-	/** Written to cache with 1-hour TTL (Anthropic `ephemeral_1h_input_tokens`). */
-	cacheWrite1h?: number;
-	/** Written to cache with other/unspecified TTL (Gemini explicit caches). */
-	cacheWriteOther?: number;
-	/** Audio input tokens (OpenAI realtime, Gemini audio). */
-	audio?: number;
-	/** Image input tokens (Gemini per-modality). */
-	image?: number;
-	/** Video input tokens (Gemini per-modality). */
-	video?: number;
-	/** Tool-use result tokens fed back to the model (Gemini `toolUsePromptTokenCount`). */
-	toolUse?: number;
-	/** Provider-specific classes not covered above. Open-ended by design. */
-	extensions?: Record<string, number>;
-}
-
-/** Output token classes. */
-export interface OutputTokens {
-	/** Regular generated output (non-reasoning, non-audio). */
-	regular: number;
-	/** Reasoning / thinking tokens (OpenAI o-series, Gemini thoughts, Grok reasoning). */
-	reasoning?: number;
-	/** Audio output tokens. */
-	audio?: number;
-	/** Predicted-output tokens accepted (OpenAI predictions API). */
-	predictionAccepted?: number;
-	/** Predicted-output tokens rejected (still billed at output rate). */
-	predictionRejected?: number;
-	extensions?: Record<string, number>;
-}
-
-/** Per-call token usage in canonical shape. No pricing, no interpretation. */
-export interface TokenUsage {
-	input: InputTokens;
-	output: OutputTokens;
-	/**
-	 * Per-call non-token costs (web-search requests, tool invocations, cache
-	 * storage-hours, etc.). Units are domain-specific — pricing functions
-	 * interpret them via `ModelPricing.auxiliary`.
-	 */
-	auxiliary?: Record<string, number>;
-	/**
-	 * Raw provider usage object, unmodified. Escape hatch for anything the
-	 * canonical shape doesn't model.
-	 */
-	raw?: unknown;
-}
-
-/** Sum of every input-token class. Helper for pricing + budget gating. */
-export function sumInputTokens(u: TokenUsage): number {
-	const i = u.input;
-	const base =
-		i.regular +
-		(i.cacheRead ?? 0) +
-		(i.cacheWrite5m ?? 0) +
-		(i.cacheWrite1h ?? 0) +
-		(i.cacheWriteOther ?? 0) +
-		(i.audio ?? 0) +
-		(i.image ?? 0) +
-		(i.video ?? 0) +
-		(i.toolUse ?? 0);
-	if (!i.extensions) return base;
-	let ext = 0;
-	for (const v of Object.values(i.extensions)) ext += v;
-	return base + ext;
-}
-
-/** Sum of every output-token class. */
-export function sumOutputTokens(u: TokenUsage): number {
-	const o = u.output;
-	const base =
-		o.regular +
-		(o.reasoning ?? 0) +
-		(o.audio ?? 0) +
-		(o.predictionAccepted ?? 0) +
-		(o.predictionRejected ?? 0);
-	if (!o.extensions) return base;
-	let ext = 0;
-	for (const v of Object.values(o.extensions)) ext += v;
-	return base + ext;
-}
-
-/** Empty `TokenUsage` — useful as a default / starting point. */
-export function emptyUsage(): TokenUsage {
-	return { input: { regular: 0 }, output: { regular: 0 } };
-}
-
-// ---------------------------------------------------------------------------
-// Chat message / tool types (single source of truth for the AI layer)
-// ---------------------------------------------------------------------------
-
-/** A single chat message in a conversation. */
-export type ChatMessage = {
-	readonly role: "system" | "user" | "assistant" | "tool";
-	readonly content: string;
-	readonly name?: string;
-	readonly toolCallId?: string;
-	readonly toolCalls?: readonly ToolCall[];
-	readonly metadata?: Record<string, unknown>;
-};
-
-/** A tool invocation request from an LLM. */
-export type ToolCall = {
-	readonly id: string;
-	readonly name: string;
-	readonly arguments: Record<string, unknown>;
-};
-
-/** A tool definition for LLM consumption. */
-export type ToolDefinition = {
-	readonly name: string;
-	readonly description: string;
-	readonly parameters: Record<string, unknown>; // JSON Schema
-	/**
-	 * Handler invoked when the LLM requests this tool.
-	 *
-	 * The optional `opts.signal` fires when the reactive surface that owns
-	 * this invocation is torn down (e.g. the agent's `switchMap` over
-	 * `toolCalls` superseded with a fresh batch, the agent was aborted, or
-	 * the parent graph destroyed). Signal-aware handlers should thread it
-	 * into `fetch(url, {signal})`, child-process kill, DB cancel, etc., so
-	 * in-flight side effects actually stop. Handlers that ignore the
-	 * signal still work — but their work continues to completion regardless
-	 * of supersede.
-	 */
-	readonly handler: (
-		args: Record<string, unknown>,
-		opts?: { signal?: AbortSignal },
-	) => NodeInput<unknown>;
-	/**
-	 * V0 version of the backing node at tool-definition-creation time.
-	 * Snapshot — re-create the tool definition to refresh.
-	 */
-	readonly version?: { id: string; version: number };
-};
-
-// ---------------------------------------------------------------------------
-// Response / streaming
-// ---------------------------------------------------------------------------
-
-/** The response from an LLM invocation. */
-export interface LLMResponse {
-	readonly content: string;
-	readonly toolCalls?: readonly ToolCall[];
-	/**
-	 * Token usage. Optional — provider adapters should always populate it, but
-	 * test mocks and adapter middlewares that synthesize responses can omit it.
-	 * Downstream consumers that compute cost should default to {@link emptyUsage}.
-	 */
-	readonly usage?: TokenUsage;
-	readonly finishReason?: string;
-	readonly latencyMs?: number;
-	readonly model?: string;
-	readonly provider?: string;
-	/** Service tier the call was served with (standard / batch / flex / priority). */
-	readonly tier?: string;
-	readonly metadata?: Record<string, unknown>;
-}
-
-/**
- * Adapter-facing incremental stream event.
- *
- * Provider adapters emit these; higher-level surfaces (`streamingPromptNode`,
- * `agentLoop`) assemble them into consumer-facing `StreamChunk` with their own
- * `source`/`accumulated`/`index` context.
- *
- * **Shape rationale — why object tagged-union vs. the framework `[TYPE, data]`
- * tuple?** `StreamDelta` is an *application-layer event payload* that flows
- * inside a single framework `DATA` message, one abstraction level above the
- * reactive protocol. The framework's `[Type, Data?]` tuple (DIRTY / DATA /
- * RESOLVED / COMPLETE / ERROR) is the protocol message form delivered through
- * `subscribe`. Using the protocol form here would force us to invent new
- * framework-level symbols (`TOKEN`, `USAGE`, etc.) that leak into user code,
- * and TypeScript discriminated-union exhaustiveness works much better with
- * objects than tuples. Object-tagged unions match the idiomatic JS/TS
- * convention for discriminated events (Redux actions, DOM events).
- */
-export type StreamDelta =
-	| { readonly type: "token"; readonly delta: string }
-	| {
-			readonly type: "tool-call-delta";
-			readonly delta: {
-				readonly id?: string;
-				readonly name?: string;
-				readonly argumentsDelta?: string;
-			};
-	  }
-	| { readonly type: "thinking"; readonly delta: string }
-	| { readonly type: "usage"; readonly usage: TokenUsage }
-	| { readonly type: "finish"; readonly reason: string };
-
-// ---------------------------------------------------------------------------
-// Invocation options
-// ---------------------------------------------------------------------------
-
-/** Options passed to `invoke()` / `stream()`. */
-export interface LLMInvokeOptions {
-	model?: string;
-	temperature?: number;
-	maxTokens?: number;
-	/** Budget for reasoning/thinking tokens, if the model supports it. */
-	maxReasoningTokens?: number;
-	tools?: readonly ToolDefinition[];
-	systemPrompt?: string;
-	/** Hint the adapter to cache the prompt. TTL values depend on provider. */
-	cacheHint?: { ttl?: "5m" | "1h" | string; minTokens?: number };
-	/** Service tier: "standard" | "batch" | "flex" | "priority" | provider-custom. */
-	tier?: string;
-	signal?: AbortSignal;
-	/**
-	 * Provider-specific passthrough — merged into the native request body.
-	 * Escape hatch for features not yet in the canonical options.
-	 */
-	providerExtras?: Record<string, unknown>;
-	/**
-	 * Open-ended per-call context threaded to cache / fallback key functions.
-	 * Callers who want to shard caches by tenant, session, feature flag, or
-	 * any other dimension populate this and supply a custom `keyFn` that
-	 * incorporates it. Not sent to providers — stripped from canonical key
-	 * hashing when no custom `keyFn` is supplied. Type is `unknown` to avoid
-	 * prescribing a shape; callers pick their own.
-	 */
-	keyContext?: unknown;
-}
-
-// ---------------------------------------------------------------------------
-// LLMAdapter protocol
-// ---------------------------------------------------------------------------
-
-/**
- * Provider-agnostic LLM adapter (spec §5.10 compliant).
- *
- * - `invoke()` returns a `NodeInput<LLMResponse>` — the caller bridges to
- *   reactive via `fromAny(...)`. Adapter implementations may return a
- *   Promise (simplest), a Node (reactive), or a plain value (testing).
- * - `stream()` returns `AsyncIterable<StreamDelta>` — the terminal delta of
- *   type `"usage"` carries the final `TokenUsage` for the streamed call.
- */
-export interface LLMAdapter {
-	readonly provider: string;
-	readonly model?: string;
-	invoke(messages: readonly ChatMessage[], opts?: LLMInvokeOptions): NodeInput<LLMResponse>;
-	stream(messages: readonly ChatMessage[], opts?: LLMInvokeOptions): AsyncIterable<StreamDelta>;
-	/** Optional capability lookup; typically delegates to a `CapabilitiesRegistry`. */
-	capabilities?(model?: string): import("./capabilities.js").ModelCapabilities | undefined;
-	/**
-	 * DS-14.5 / AB-1 — honoring `opts.signal: AbortSignal` end-to-end is a
-	 * **hard adapter contract**, not an opt-in capability. Every adapter MUST
-	 * thread `opts.signal` into its underlying I/O (`fetch` request,
-	 * child-process kill, DB cancel) so a mid-call abort cancels the work and
-	 * surfaces as a rejection / thrown error. The prior optional
-	 * `abortCapable?: boolean` flag (Lock 3.C / QA D3) was removed pre-1.0:
-	 * the capability-flag escape hatch silently permitted token burn-through
-	 * past `valve`-close / `switchMap`-supersede / budget exhaustion. There is
-	 * no longer a flag to set and no dev-mode warning — abort just works.
-	 */
-}
-
-/** Discriminator for downstream type guards. */
-export function isLLMAdapter(x: unknown): x is LLMAdapter {
-	if (x == null || typeof x !== "object") return false;
-	const a = x as Partial<LLMAdapter>;
-	return (
-		typeof a.provider === "string" &&
-		typeof a.invoke === "function" &&
-		typeof a.stream === "function"
-	);
-}
-
-// ---------------------------------------------------------------------------
-// Public re-export surface
-// ---------------------------------------------------------------------------
-
-export type { Node, NodeInput };
diff --git a/src/utils/ai/adapters/index.ts b/src/utils/ai/adapters/index.ts
deleted file mode 100644
index 30a8ad09..00000000
--- a/src/utils/ai/adapters/index.ts
+++ /dev/null
@@ -1,18 +0,0 @@
-/**
- * LLM adapter layer (roadmap §9.3d).
- *
- * Layout:
- *   - `core/`       — types, pricing, capabilities, observable, factory
- *   - `providers/`  — Anthropic, OpenAI-compat, Google, DryRun
- *   - `providers/browser/` — WebLLM, ChromeNano (browser-only, import separately)
- *   - `middleware/` — budget-gate, rate-limiter, replay-cache, retry, timeout, breaker, dry-run
- *   - `routing/`    — cascadingLlmAdapter, presets
- *
- * The library ships zero pricing / capability data. Users populate registries
- * with their own data; the library provides the shape + composition primitives.
- */
-
-export * from "./core/index.js";
-export * from "./middleware/index.js";
-export * from "./providers/index.js";
-export * from "./routing/index.js";
diff --git a/src/utils/ai/adapters/middleware/breaker.ts b/src/utils/ai/adapters/middleware/breaker.ts
deleted file mode 100644
index 80f5979a..00000000
--- a/src/utils/ai/adapters/middleware/breaker.ts
+++ /dev/null
@@ -1,63 +0,0 @@
-/**
- * `withBreaker` — circuit-breaker middleware for LLM adapters.
- *
- * Reuses the library's existing `circuitBreaker` primitive from
- * `extra/resilience.ts`. When the breaker is open, calls throw
- * `CircuitOpenError` instead of hitting the provider.
- */
-
-import { fromAny } from "@graphrefly/pure-ts/extra";
-import { firstValueFrom } from "../../../../base/sources/settled.js";
-import {
-	type CircuitBreaker,
-	type CircuitBreakerOptions,
-	CircuitOpenError,
-	circuitBreaker,
-} from "../../../../utils/resilience/index.js";
-import { adapterWrapper, withLayer } from "../_internal/wrappers.js";
-import type { LLMAdapter, LLMResponse, StreamDelta } from "../core/types.js";
-
-export interface WithBreakerOptions extends CircuitBreakerOptions {
-	/**
-	 * Optional external breaker — pass a shared instance to wire the same
-	 * breaker across multiple adapters (e.g. all tiers of a `cascadingLlmAdapter`).
-	 */
-	breaker?: CircuitBreaker;
-}
-
-export function withLLMBreaker(
-	inner: LLMAdapter,
-	opts: WithBreakerOptions = {},
-): { adapter: LLMAdapter; breaker: CircuitBreaker } {
-	const breaker = opts.breaker ?? circuitBreaker(opts);
-
-	const adapter: LLMAdapter = adapterWrapper(inner, {
-		async invoke(messages, invokeOpts): Promise<LLMResponse> {
-			if (!breaker.canExecute()) throw new CircuitOpenError();
-			try {
-				const resp = await firstValueFrom(fromAny(inner.invoke(messages, invokeOpts)));
-				breaker.recordSuccess();
-				return resp;
-			} catch (err) {
-				breaker.recordFailure(err);
-				throw err;
-			}
-		},
-
-		async *stream(messages, invokeOpts): AsyncGenerator<StreamDelta> {
-			if (!breaker.canExecute()) throw new CircuitOpenError();
-			try {
-				for await (const d of inner.stream(messages, invokeOpts)) yield d;
-				breaker.recordSuccess();
-			} catch (err) {
-				breaker.recordFailure(err);
-				throw err;
-			}
-		},
-	});
-	withLayer(adapter, "withLLMBreaker", inner);
-
-	return { adapter, breaker };
-}
-
-export { CircuitOpenError };
diff --git a/src/utils/ai/adapters/middleware/budget-gate.ts b/src/utils/ai/adapters/middleware/budget-gate.ts
deleted file mode 100644
index 66eee771..00000000
--- a/src/utils/ai/adapters/middleware/budget-gate.ts
+++ /dev/null
@@ -1,454 +0,0 @@
-/**
- * `withBudgetGate` — cap an adapter by calls / tokens / USD.
- *
- * Totals are an O(1)-per-event running accumulator (a `state<BudgetTotals>`
- * updated imperatively inside `record()`), not a derived reduce over the
- * full log — avoids the quadratic cost at sustained traffic while preserving
- * the reactive surface. The full log is still exposed via the bundle for
- * dashboards / auditors.
- *
- * Budgets are enforced imperatively at `invoke()` / `stream()` entry — the
- * running totals + `isOpen.cache` are read; if closed, the call rejects /
- * throws `BudgetExhaustedError` without hitting the wrapped adapter. On
- * success, the call's usage is appended to the log AND debits the running
- * totals in a single synchronous update.
- *
- * Wave A Unit 11 Q4: rejected-Promise path now wires `.catch` (via
- * `adaptInvokeResult.onError`) so failed invoke calls record a CallStatsEvent
- * with `error` populated. Prior code silently dropped rejection from the
- * `totals` / `log` surface.
- */
-
-import { DATA, monotonicNs, type Node, node } from "@graphrefly/pure-ts/core";
-import { keepalive, type ReactiveLogBundle, reactiveLog } from "@graphrefly/pure-ts/extra";
-import {
-	adapterWrapper,
-	adaptInvokeResult,
-	buildCallStats,
-	emptyUsageStub,
-	withLayer,
-} from "../_internal/wrappers.js";
-import type { CallStatsEvent } from "../core/observable.js";
-import type { PricingFn } from "../core/pricing.js";
-import type {
-	ChatMessage,
-	LLMAdapter,
-	LLMInvokeOptions,
-	LLMResponse,
-	StreamDelta,
-	TokenUsage,
-} from "../core/types.js";
-import { sumInputTokens, sumOutputTokens } from "../core/types.js";
-
-export class BudgetExhaustedError extends Error {
-	override name = "BudgetExhaustedError";
-	constructor(
-		public readonly which: string,
-		public readonly limit: number,
-		public readonly observed: number,
-	) {
-		super(`Budget exhausted: ${which} (limit=${limit}, observed=${observed})`);
-	}
-}
-
-export interface BudgetCaps {
-	calls?: number;
-	inputTokens?: number;
-	outputTokens?: number;
-	usd?: number;
-}
-
-export interface BudgetTotals {
-	calls: number;
-	inputTokens: number;
-	outputTokens: number;
-	usd: number;
-}
-
-export interface LLMBudgetGateBundle {
-	totals: Node<BudgetTotals>;
-	isOpen: Node<boolean>;
-	log: ReactiveLogBundle<CallStatsEvent>;
-	reset(): void;
-	/**
-	 * QA D2 (Phase 13.6.B QA pass): release every long-lived
-	 * subscription this gate holds — `keepalive(isOpen)`, the optional
-	 * `onExhausted` subscription, and the Lock 3.C abort fan-out
-	 * subscription on `isOpen`. Aborts any in-flight controllers as a
-	 * defensive last gasp so callers waiting on a soon-to-be-disposed
-	 * adapter don't hang.
-	 *
-	 * Idempotent: subsequent calls are no-ops. After `dispose()` the
-	 * adapter wrapper continues to wrap `inner.invoke` / `inner.stream`
-	 * but the budget machinery is best-effort: `record()` no longer
-	 * emits `totals` updates, abort fan-out no longer fires. Treat the
-	 * bundle as terminated once disposed; long-running apps should
-	 * `dispose()` per gate instance to avoid the sub-leak documented
-	 * in `docs/optimizations.md`.
-	 */
-	dispose(): void;
-}
-
-export interface WithBudgetGateOptions {
-	caps: BudgetCaps;
-	/**
-	 * Optional pricing function for USD gating. If omitted, `caps.usd` is
-	 * ignored (caps.calls / caps.inputTokens / caps.outputTokens still apply).
-	 */
-	pricingFn?: PricingFn;
-	/**
-	 * Edge-triggered: fires exactly once when the gate transitions from
-	 * open to closed. Subsequent invoke/stream attempts against a closed
-	 * gate do NOT re-fire `onExhausted` — use the reactive `isOpen` node
-	 * if you need per-attempt notifications. Receives the cap key that
-	 * triggered the transition.
-	 */
-	onExhausted?: (which: keyof BudgetCaps) => void;
-	/** Name for logs / describe output. */
-	name?: string;
-	/** Max events retained in the log (default 1000). */
-	logMax?: number;
-}
-
-// Frozen baseline shared for `totals.cache ?? EMPTY_TOTALS` reads. Consumers
-// that mutate their snapshot in place would otherwise poison every budget-gate
-// instance in the process. `reset()` emits a freshly-constructed object so
-// downstream identity-equals checks on the frozen constant don't false-equal.
-const EMPTY_TOTALS: Readonly<BudgetTotals> = Object.freeze({
-	calls: 0,
-	inputTokens: 0,
-	outputTokens: 0,
-	usd: 0,
-});
-const makeEmptyTotals = (): BudgetTotals => ({
-	calls: 0,
-	inputTokens: 0,
-	outputTokens: 0,
-	usd: 0,
-});
-
-/**
- * Wrap an adapter with budget enforcement. Returns `{adapter, budget}` so
- * callers can subscribe to the bundle for dashboards.
- */
-export function withBudgetGate(
-	inner: LLMAdapter,
-	opts: WithBudgetGateOptions,
-): { adapter: LLMAdapter; budget: LLMBudgetGateBundle } {
-	const log = reactiveLog<CallStatsEvent>(undefined, {
-		name: opts.name ? `${opts.name}/log` : "budgetGate/log",
-		maxSize: opts.logMax ?? 1000,
-	});
-
-	// O(1) running totals — incremented per `record()` rather than reduced over
-	// the full log. Reactive surface preserved via `state<BudgetTotals>`.
-	const totals = node<BudgetTotals>([], {
-		name: opts.name ? `${opts.name}/totals` : "budgetGate/totals",
-		initial: makeEmptyTotals(),
-	});
-
-	const isOpen = node<boolean>(
-		[totals],
-		(batchData, actions, ctx) => {
-			const data = batchData.map((batch, i) =>
-				batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-			);
-			const tt = data[0] as BudgetTotals;
-			if (opts.caps.calls != null && tt.calls >= opts.caps.calls) {
-				actions.emit(false);
-				return;
-			}
-			if (opts.caps.inputTokens != null && tt.inputTokens >= opts.caps.inputTokens) {
-				actions.emit(false);
-				return;
-			}
-			if (opts.caps.outputTokens != null && tt.outputTokens >= opts.caps.outputTokens) {
-				actions.emit(false);
-				return;
-			}
-			if (opts.caps.usd != null && tt.usd >= opts.caps.usd) {
-				actions.emit(false);
-				return;
-			}
-			actions.emit(true);
-		},
-		{
-			describeKind: "derived",
-			name: opts.name ? `${opts.name}/isOpen` : "budgetGate/isOpen",
-			initial: true,
-		},
-	);
-	// QA D2: capture every subscription/keepalive disposer so `dispose()`
-	// can release the lot. Pre-D2 these were leaked for the process
-	// lifetime; the leak grew with B9's abort-wire subscription.
-	const disposers: Array<() => void> = [];
-	let disposed = false;
-	// Keep the isOpen derived live so `.cache` stays current without an external subscriber.
-	disposers.push(keepalive(isOpen));
-
-	// Edge-trigger `onExhausted` on the open→closed transition. Subscribing
-	// here (instead of firing from `buildClosedError`) ensures the callback
-	// fires exactly once per transition, regardless of how many invoke/stream
-	// attempts hit the closed gate afterward. Callers that want per-attempt
-	// notifications should subscribe to `isOpen` directly.
-	if (opts.onExhausted != null) {
-		const handler = opts.onExhausted;
-		// Seed `wasOpen` from the FIRST observed DATA rather than assuming
-		// `true`. If caps are already exhausted at construction (e.g.
-		// `calls: 0` or a pre-filled totals source), the push-on-subscribe
-		// DATA=`false` would otherwise be interpreted as an open→closed
-		// transition and fire `onExhausted` before any invoke has been
-		// attempted. `seeded` guards that first observation.
-		let seeded = false;
-		let wasOpen = true;
-		const unsub = isOpen.subscribe((msgs) => {
-			for (const m of msgs) {
-				if (m[0] === DATA) {
-					const v = m[1] as boolean;
-					if (seeded && wasOpen && v === false) {
-						const which = pickExhaustedKey(totals.cache ?? EMPTY_TOTALS, opts.caps);
-						if (which) handler(which);
-					}
-					wasOpen = v;
-					seeded = true;
-				}
-			}
-		});
-		disposers.push(unsub);
-	}
-
-	const buildClosedError = (): BudgetExhaustedError | undefined => {
-		if (isOpen.cache === false) {
-			const t = totals.cache ?? EMPTY_TOTALS;
-			const which = pickExhaustedKey(t, opts.caps);
-			return new BudgetExhaustedError(
-				which ?? "budget",
-				opts.caps[which ?? "calls"] ?? 0,
-				whichValue(t, which ?? "calls"),
-			);
-		}
-		return undefined;
-	};
-
-	const record = (
-		usage: TokenUsage,
-		meta: {
-			model: string;
-			tier?: string;
-			startNs: number;
-			method: "invoke" | "stream";
-			error?: { type: string; message: string };
-		},
-	): void => {
-		const provider = inner.provider;
-		const event: CallStatsEvent = buildCallStats({
-			provider,
-			model: meta.model,
-			tier: meta.tier,
-			usage,
-			startNs: meta.startNs,
-			method: meta.method,
-			...(meta.error ? { error: meta.error } : {}),
-		});
-		log.append(event);
-		const prev = totals.cache ?? EMPTY_TOTALS;
-		const usd = opts.pricingFn
-			? prev.usd + opts.pricingFn(usage, { model: meta.model, provider, tier: meta.tier }).total
-			: prev.usd;
-		totals.emit({
-			calls: prev.calls + 1,
-			inputTokens: prev.inputTokens + sumInputTokens(usage),
-			outputTokens: prev.outputTokens + sumOutputTokens(usage),
-			usd,
-		});
-	};
-
-	const reset = (): void => {
-		log.clear();
-		totals.emit(makeEmptyTotals());
-	};
-
-	// Lock 3.C (Phase 13.6.B): auto-wire adapter abort. Track in-flight
-	// controllers so the open→closed transition can cancel calls that
-	// started before the budget exhausted. Encodes L2.42-honest-cost's
-	// "two pieces needed" rule (observability bubble + auto-wired abort)
-	// into the primitive itself — no manual hookup required.
-	//
-	// DS-14.5 / AB-1: honoring `opts.signal` is now a hard adapter
-	// contract (the `abortCapable` flag + this dev-mode warning were
-	// removed pre-1.0). The budget gate fans out the AbortSignal on
-	// exhaustion and every adapter is required to cancel its underlying
-	// I/O — no escape hatch, no silent burn-through.
-	const inflight = new Set<AbortController>();
-	let isOpenSeeded = false;
-	let isOpenWasOpen = true;
-	const isOpenAbortUnsub = isOpen.subscribe((msgs) => {
-		for (const m of msgs) {
-			if (m[0] !== DATA) continue;
-			const v = m[1] as boolean;
-			if (isOpenSeeded && isOpenWasOpen && v === false && inflight.size > 0) {
-				const reason = buildClosedError() ?? new Error("budget exhausted");
-				for (const ctrl of inflight) {
-					try {
-						ctrl.abort(reason);
-					} catch {
-						/* best-effort abort fan-out */
-					}
-				}
-			}
-			isOpenWasOpen = v;
-			isOpenSeeded = true;
-		}
-	});
-	disposers.push(isOpenAbortUnsub);
-
-	function combineSignals(callerSignal: AbortSignal | undefined): {
-		ctrl: AbortController;
-		cleanup: () => void;
-	} {
-		const ctrl = new AbortController();
-		// If the budget is already closed when invoke starts, abort
-		// immediately so the inner call never starts.
-		if (isOpen.cache === false) {
-			ctrl.abort(buildClosedError() ?? new Error("budget exhausted"));
-		}
-		const onCallerAbort = (): void => {
-			if (!ctrl.signal.aborted) ctrl.abort((callerSignal as AbortSignal).reason);
-		};
-		if (callerSignal != null) {
-			if (callerSignal.aborted) {
-				ctrl.abort(callerSignal.reason);
-			} else {
-				callerSignal.addEventListener("abort", onCallerAbort, { once: true });
-			}
-		}
-		inflight.add(ctrl);
-		const cleanup = (): void => {
-			inflight.delete(ctrl);
-			if (callerSignal != null) callerSignal.removeEventListener("abort", onCallerAbort);
-		};
-		return { ctrl, cleanup };
-	}
-
-	const wrap: LLMAdapter = adapterWrapper(inner, {
-		invoke(messages, invokeOpts) {
-			const closedErr = buildClosedError();
-			if (closedErr) return Promise.reject(closedErr);
-			const startNs = monotonicNs();
-			const model = inner.model ?? invokeOpts?.model ?? "";
-			const { ctrl, cleanup } = combineSignals(invokeOpts?.signal);
-			const recordResp = (resp: LLMResponse): LLMResponse => {
-				cleanup();
-				record(resp.usage ?? emptyUsageStub(), {
-					model: inner.model ?? invokeOpts?.model ?? resp.model ?? "",
-					tier: invokeOpts?.tier ?? resp.tier,
-					startNs,
-					method: "invoke",
-				});
-				return resp;
-			};
-			const recordErr = (err: unknown): void => {
-				cleanup();
-				const e = err as Error | undefined;
-				record(emptyUsageStub(), {
-					model,
-					tier: invokeOpts?.tier,
-					startNs,
-					method: "invoke",
-					error: { type: e?.name ?? "Error", message: e?.message ?? String(err) },
-				});
-			};
-			const innerOpts = { ...(invokeOpts ?? {}), signal: ctrl.signal };
-			return adaptInvokeResult(inner.invoke(messages, innerOpts), {
-				onResp: recordResp,
-				onError: recordErr,
-				name: "budgetGate/invokeTap",
-			});
-		},
-
-		async *stream(messages, invokeOpts): AsyncGenerator<StreamDelta> {
-			const closedErr = buildClosedError();
-			if (closedErr) throw closedErr;
-			const startNs = monotonicNs();
-			let finalUsage: TokenUsage | undefined;
-			const { ctrl, cleanup } = combineSignals(invokeOpts?.signal);
-			const innerOpts = { ...(invokeOpts ?? {}), signal: ctrl.signal };
-			try {
-				for await (const delta of inner.stream(messages, innerOpts)) {
-					if (delta.type === "usage") finalUsage = delta.usage;
-					yield delta;
-				}
-				cleanup();
-				record(finalUsage ?? emptyUsageStub(), {
-					model: inner.model ?? invokeOpts?.model ?? "",
-					tier: invokeOpts?.tier,
-					startNs,
-					method: "stream",
-				});
-			} catch (err) {
-				cleanup();
-				const error = err as Error;
-				record(finalUsage ?? emptyUsageStub(), {
-					model: inner.model ?? invokeOpts?.model ?? "",
-					tier: invokeOpts?.tier,
-					startNs,
-					method: "stream",
-					error: { type: error?.name ?? "Error", message: error?.message ?? String(err) },
-				});
-				throw err;
-			}
-		},
-	});
-
-	withLayer(wrap, "withBudgetGate", inner);
-
-	const dispose = (): void => {
-		if (disposed) return;
-		disposed = true;
-		// Defensive last gasp: abort any in-flight controllers so the
-		// awaited Promises don't strand their callers waiting on a soon-
-		// to-be-disposed adapter.
-		const reason = new Error("withBudgetGate disposed");
-		for (const ctrl of inflight) {
-			try {
-				ctrl.abort(reason);
-			} catch {
-				/* best-effort */
-			}
-		}
-		inflight.clear();
-		for (const d of disposers) {
-			try {
-				d();
-			} catch {
-				/* best-effort */
-			}
-		}
-		disposers.length = 0;
-	};
-
-	return { adapter: wrap, budget: { totals, isOpen, log, reset, dispose } };
-}
-
-function pickExhaustedKey(t: BudgetTotals, caps: BudgetCaps): keyof BudgetCaps | undefined {
-	if (caps.calls != null && t.calls >= caps.calls) return "calls";
-	if (caps.inputTokens != null && t.inputTokens >= caps.inputTokens) return "inputTokens";
-	if (caps.outputTokens != null && t.outputTokens >= caps.outputTokens) return "outputTokens";
-	if (caps.usd != null && t.usd >= caps.usd) return "usd";
-	return undefined;
-}
-
-function whichValue(t: BudgetTotals, which: keyof BudgetCaps): number {
-	switch (which) {
-		case "calls":
-			return t.calls;
-		case "inputTokens":
-			return t.inputTokens;
-		case "outputTokens":
-			return t.outputTokens;
-		case "usd":
-			return t.usd;
-	}
-}
-
-export type { ChatMessage, LLMInvokeOptions };
diff --git a/src/utils/ai/adapters/middleware/dry-run.ts b/src/utils/ai/adapters/middleware/dry-run.ts
deleted file mode 100644
index 59aa177c..00000000
--- a/src/utils/ai/adapters/middleware/dry-run.ts
+++ /dev/null
@@ -1,78 +0,0 @@
-/**
- * `withDryRun` — short-circuit to a fake adapter when a flag is on.
- *
- * Useful for CI / preflight / cost-safety pipelines: wrap a real adapter,
- * pass `enabled: true` (or a reactive flag) to bypass the wire call. Default
- * shim is {@link dryRunAdapter}; callers can supply their own.
- *
- * **Returns `{adapter, dispose}`** — call `dispose()` to release the internal
- * keepalive on the reactive `enabled` input. Long-lived adapter instances
- * (module-level singletons) can ignore dispose; transient adapters (per-
- * request or per-user) should call it on teardown to allow the source to
- * be GC'd.
- */
-
-import { fromAny, keepalive, type NodeInput } from "@graphrefly/pure-ts/extra";
-import { adapterWrapper, withLayer } from "../_internal/wrappers.js";
-import type { LLMAdapter } from "../core/types.js";
-import { dryRunAdapter } from "../providers/dry-run.js";
-
-export interface WithDryRunOptions {
-	/**
-	 * Toggle — `true` always dry-runs; `false` always passes through; a
-	 * `NodeInput<boolean>` reads the current value at call time (factory-time
-	 * seed pattern, live-tunable).
-	 */
-	enabled: NodeInput<boolean>;
-	/** Dry-run adapter override. Default: `dryRunAdapter({ provider: inner.provider, model: inner.model })`. */
-	mock?: LLMAdapter;
-}
-
-export interface WithDryRunBundle {
-	adapter: LLMAdapter;
-	/**
-	 * Release the internal keepalive subscription on the reactive `enabled`
-	 * input. Idempotent. Safe to ignore on long-lived adapters.
-	 */
-	dispose(): void;
-}
-
-export function withDryRun(inner: LLMAdapter, opts: WithDryRunOptions): WithDryRunBundle {
-	const mock = opts.mock ?? dryRunAdapter({ provider: inner.provider, model: inner.model });
-
-	// Normalize the enabled input: literal boolean stays literal; NodeInput<boolean>
-	// gets bridged so we can read .cache at call time (factory-time seed per
-	// COMPOSITION-GUIDE §28). Keep the node alive so push-on-subscribe and
-	// derived-chain recomputation keep the cache current — otherwise a reactive
-	// flag would stay at its initial value forever.
-	const enabledLiteral = typeof opts.enabled === "boolean" ? (opts.enabled as boolean) : undefined;
-	const enabledNode =
-		enabledLiteral === undefined ? fromAny(opts.enabled as NodeInput<boolean>) : undefined;
-	let unsubKeepalive: (() => void) | undefined;
-	if (enabledNode) unsubKeepalive = keepalive(enabledNode);
-
-	const isEnabled = (): boolean => {
-		if (enabledLiteral !== undefined) return enabledLiteral;
-		return Boolean(enabledNode?.cache);
-	};
-
-	const adapter: LLMAdapter = adapterWrapper(inner, {
-		invoke(messages, invokeOpts) {
-			return isEnabled() ? mock.invoke(messages, invokeOpts) : inner.invoke(messages, invokeOpts);
-		},
-
-		stream(messages, invokeOpts) {
-			return isEnabled() ? mock.stream(messages, invokeOpts) : inner.stream(messages, invokeOpts);
-		},
-	});
-	withLayer(adapter, "withDryRun", inner);
-
-	const dispose = (): void => {
-		if (unsubKeepalive) {
-			unsubKeepalive();
-			unsubKeepalive = undefined;
-		}
-	};
-
-	return { adapter, dispose };
-}
diff --git a/src/utils/ai/adapters/middleware/http429-parser.ts b/src/utils/ai/adapters/middleware/http429-parser.ts
deleted file mode 100644
index 60ac8a5e..00000000
--- a/src/utils/ai/adapters/middleware/http429-parser.ts
+++ /dev/null
@@ -1,191 +0,0 @@
-/**
- * HTTP 429 / rate-limit parser.
- *
- * Produces a {@link RateLimitSignal} from provider HTTP errors so adaptive
- * rate limiters can tighten effective limits. Normalizes:
- * - `Retry-After` (seconds or HTTP-date)
- * - `x-ratelimit-reset` / `x-ratelimit-reset-tokens` (epoch secs or duration)
- * - `x-ratelimit-remaining-{requests,tokens}` + `x-ratelimit-limit-*`
- * - Anthropic `anthropic-ratelimit-*` headers
- * - OpenAI / OpenRouter / Groq headers (same family)
- * - Error message regex fallbacks for providers without structured headers
- */
-
-import type { RateLimitSignal } from "../../../resilience/adaptive-rate-limiter.js";
-
-export interface HttpErrorLike {
-	status?: number;
-	headers?: Headers | Record<string, string | string[] | undefined>;
-	message?: string;
-}
-
-/**
- * Extract a {@link RateLimitSignal} from a fetch-style error object, a Response,
- * or any object exposing `.status` + `.headers` + `.message`.
- *
- * Returns `undefined` if no rate-limit information can be extracted.
- */
-export function parseRateLimitFromError(err: unknown): RateLimitSignal | undefined {
-	if (err == null || typeof err !== "object") return undefined;
-	const like = err as HttpErrorLike;
-	const status = like.status;
-	const headerLookup = toHeaderGetter(like.headers);
-
-	// Only respond on 429 or 503 (some providers use 503 for rate-limits).
-	if (status !== 429 && status !== 503 && !looksLikeRateLimitMessage(like.message)) {
-		return undefined;
-	}
-
-	const sig: RateLimitSignal = {};
-
-	const retryAfter = headerLookup("retry-after");
-	const retryAfterMs = parseRetryAfter(retryAfter);
-	if (retryAfterMs != null) sig.retryAfterMs = retryAfterMs;
-
-	// Anthropic: anthropic-ratelimit-requests-reset (ISO-8601 timestamp)
-	const anthReqReset = headerLookup("anthropic-ratelimit-requests-reset");
-	if (anthReqReset) {
-		const ms = parseIsoResetHeaderToDelayMs(anthReqReset);
-		if (ms != null) sig.retryAfterMs = Math.max(sig.retryAfterMs ?? 0, ms);
-	}
-	const anthTokReset = headerLookup("anthropic-ratelimit-tokens-reset");
-	if (anthTokReset) {
-		const ms = parseIsoResetHeaderToDelayMs(anthTokReset);
-		if (ms != null) sig.retryAfterMs = Math.max(sig.retryAfterMs ?? 0, ms);
-	}
-
-	// OpenAI / OpenRouter / Groq: x-ratelimit-limit-requests, -reset-requests, etc.
-	const limitRequests = numHeader(headerLookup, "x-ratelimit-limit-requests");
-	if (limitRequests != null) sig.rpmCap = limitRequests;
-	const limitTokens = numHeader(headerLookup, "x-ratelimit-limit-tokens");
-	if (limitTokens != null) sig.tpmCap = limitTokens;
-
-	// Usage hint: remaining / limit
-	const remainingReq = numHeader(headerLookup, "x-ratelimit-remaining-requests");
-	const remainingTok = numHeader(headerLookup, "x-ratelimit-remaining-tokens");
-	if (remainingReq != null && limitRequests != null && limitRequests > 0) {
-		sig.usageHint ??= {};
-		sig.usageHint.rpm = 1 - remainingReq / limitRequests;
-	}
-	if (remainingTok != null && limitTokens != null && limitTokens > 0) {
-		sig.usageHint ??= {};
-		sig.usageHint.tpm = 1 - remainingTok / limitTokens;
-	}
-
-	// Fallback: parse retry-after from error message if no header was found.
-	if (sig.retryAfterMs == null && like.message) {
-		const msgMs = parseRetryAfterFromMessage(like.message);
-		if (msgMs != null) sig.retryAfterMs = msgMs;
-	}
-
-	// Preserve raw headers for user-specific downstream logic.
-	if (like.headers) sig.metadata = { headers: serializeHeaders(like.headers) };
-
-	if (
-		sig.retryAfterMs == null &&
-		sig.rpmCap == null &&
-		sig.tpmCap == null &&
-		sig.usageHint == null
-	) {
-		// Nothing actionable extracted — still emit empty signal so consumers can
-		// count occurrences (metadata carries the headers).
-		return sig.metadata ? sig : undefined;
-	}
-
-	return sig;
-}
-
-// ---------------------------------------------------------------------------
-// Header access
-// ---------------------------------------------------------------------------
-
-type HeaderGetter = (name: string) => string | undefined;
-
-function toHeaderGetter(h: HttpErrorLike["headers"]): HeaderGetter {
-	if (!h) return () => undefined;
-	if (typeof (h as Headers).get === "function") {
-		const hh = h as Headers;
-		return (name) => hh.get(name) ?? hh.get(name.toLowerCase()) ?? undefined;
-	}
-	const record = h as Record<string, string | string[] | undefined>;
-	const lc: Record<string, string | undefined> = {};
-	for (const [k, v] of Object.entries(record)) {
-		const sv = Array.isArray(v) ? v.join(", ") : v;
-		if (sv != null) lc[k.toLowerCase()] = sv;
-	}
-	return (name) => lc[name.toLowerCase()];
-}
-
-function serializeHeaders(h: NonNullable<HttpErrorLike["headers"]>): Record<string, string> {
-	const out: Record<string, string> = {};
-	if (typeof (h as Headers).forEach === "function") {
-		(h as Headers).forEach((v, k) => {
-			out[k] = v;
-		});
-		return out;
-	}
-	for (const [k, v] of Object.entries(h as Record<string, string | string[] | undefined>)) {
-		if (v != null) out[k] = Array.isArray(v) ? v.join(", ") : v;
-	}
-	return out;
-}
-
-function numHeader(getter: HeaderGetter, name: string): number | undefined {
-	const raw = getter(name);
-	if (raw == null) return undefined;
-	const n = Number(raw);
-	return Number.isFinite(n) ? n : undefined;
-}
-
-// ---------------------------------------------------------------------------
-// Retry-after parsing
-// ---------------------------------------------------------------------------
-
-function parseRetryAfter(raw: string | undefined): number | undefined {
-	if (!raw) return undefined;
-	const trimmed = raw.trim();
-	const asNum = Number(trimmed);
-	if (Number.isFinite(asNum) && asNum >= 0) return asNum * 1000;
-	// HTTP-date fallback.
-	const ts = Date.parse(trimmed);
-	if (Number.isFinite(ts)) {
-		const delta = ts - Date.now();
-		if (delta > 0) return delta;
-	}
-	return undefined;
-}
-
-/**
- * Parse an Anthropic `anthropic-ratelimit-{requests,tokens}-reset` header
- * into a delay (milliseconds until reset). These headers are documented
- * as ISO-8601 absolute timestamps; we use `Date.parse` and clamp to zero
- * for headers that have already elapsed. Returns `undefined` for unparseable
- * values — no numeric-epoch heuristic (providers don't send numeric resets
- * here, and the old heuristic was ambiguous across seconds-vs-millis).
- */
-function parseIsoResetHeaderToDelayMs(raw: string): number | undefined {
-	if (!raw) return undefined;
-	const ts = Date.parse(raw);
-	if (Number.isFinite(ts)) return Math.max(0, ts - Date.now());
-	return undefined;
-}
-
-const RETRY_MSG_RE = /retry\s+(?:in|after)\s+(\d+(?:\.\d+)?)\s*(ms|s|sec|seconds?|m|min|minutes?)/i;
-
-function parseRetryAfterFromMessage(msg: string): number | undefined {
-	const m = RETRY_MSG_RE.exec(msg);
-	if (!m) return undefined;
-	const n = Number(m[1]);
-	if (!Number.isFinite(n)) return undefined;
-	const unit = (m[2] ?? "s").toLowerCase();
-	if (unit === "ms") return n;
-	if (unit.startsWith("s")) return n * 1000;
-	if (unit.startsWith("m")) return n * 60_000;
-	return undefined;
-}
-
-const RATE_LIMIT_MSG_RE = /rate\s*limit|too\s*many\s*requests|quota|429/i;
-
-function looksLikeRateLimitMessage(msg: string | undefined): boolean {
-	return !!msg && RATE_LIMIT_MSG_RE.test(msg);
-}
diff --git a/src/utils/ai/adapters/middleware/index.ts b/src/utils/ai/adapters/middleware/index.ts
deleted file mode 100644
index 3746d35a..00000000
--- a/src/utils/ai/adapters/middleware/index.ts
+++ /dev/null
@@ -1,9 +0,0 @@
-export * from "./breaker.js";
-export * from "./budget-gate.js";
-export * from "./dry-run.js";
-export * from "./http429-parser.js";
-export * from "./rate-limiter.js";
-export * from "./replay-cache.js";
-export * from "./resilient-adapter.js";
-export * from "./retry.js";
-export * from "./timeout.js";
diff --git a/src/utils/ai/adapters/middleware/rate-limiter.ts b/src/utils/ai/adapters/middleware/rate-limiter.ts
deleted file mode 100644
index 981f006a..00000000
--- a/src/utils/ai/adapters/middleware/rate-limiter.ts
+++ /dev/null
@@ -1,135 +0,0 @@
-/**
- * `withRateLimiter` — adapter middleware bridging to the reactive
- * `adaptiveRateLimiter` primitive.
- *
- * - Consumes live `rpm`/`tpm` caps as reactive `NodeInput<number>` so
- *   callers can retune at runtime (e.g. from a `ModelLimits.rpm` node).
- * - Adapts to provider 429 responses via `http429Parser` fed into the
- *   limiter's `adaptation` signal.
- * - `costFn` estimates token cost pre-call (e.g. char-based approximation);
- *   the post-call actual usage is fed back via `limiter.recordUsage()`.
- */
-
-import { fromAny, type NodeInput } from "@graphrefly/pure-ts/extra";
-import { firstValueFrom } from "../../../../base/sources/settled.js";
-import {
-	type AdaptiveRateLimiterBundle,
-	adaptiveRateLimiter,
-	type RateLimitSignal,
-} from "../../../resilience/adaptive-rate-limiter.js";
-import { adapterWrapper, withLayer } from "../_internal/wrappers.js";
-import type {
-	ChatMessage,
-	LLMAdapter,
-	LLMInvokeOptions,
-	LLMResponse,
-	StreamDelta,
-} from "../core/types.js";
-import { emptyUsage, sumInputTokens, sumOutputTokens } from "../core/types.js";
-import { parseRateLimitFromError } from "./http429-parser.js";
-
-export interface WithRateLimiterOptions {
-	/** Live rpm cap (defaults to `Infinity`). */
-	rpm?: NodeInput<number>;
-	/** Live tpm cap (defaults to `Infinity`). */
-	tpm?: NodeInput<number>;
-	/**
-	 * Pre-call token-cost estimate. Default: 0 (only rpm gates). Override with
-	 * e.g. a char-based heuristic:
-	 * `(msgs) => Math.ceil(msgs.reduce((s, m) => s + m.content.length, 0) / 4)`.
-	 */
-	costFn?: (messages: readonly ChatMessage[], opts?: LLMInvokeOptions) => number;
-	/**
-	 * Manual adaptation signal source. Defaults to a signal derived from
-	 * provider errors via `parseRateLimitFromError` — users can supply a
-	 * custom signal chain if they route errors elsewhere.
-	 */
-	adaptation?: NodeInput<RateLimitSignal>;
-	burstMultiplier?: number;
-	name?: string;
-	/**
-	 * Share an existing {@link AdaptiveRateLimiterBundle} across multiple
-	 * adapter wraps. When provided, `withRateLimiter` reuses this bundle
-	 * instead of constructing a new one — useful when the RPM/TPM cap is
-	 * logically per-provider but the caller wants to harden multiple adapters
-	 * (e.g. primary + fallback of the same vendor) against the shared cap.
-	 *
-	 * When `limiter` is set, `rpm` / `tpm` / `adaptation` / `burstMultiplier`
-	 * / `name` are ignored (the supplied bundle owns those). `costFn` is still
-	 * used per-wrap — each wrap supplies its own cost estimator.
-	 */
-	limiter?: AdaptiveRateLimiterBundle;
-}
-
-/**
- * Wrap an adapter with adaptive rate limiting. Returns `{adapter, limiter}`
- * so callers can subscribe to limiter internals (rpmAvailable, pending, etc.)
- * for dashboards.
- */
-export function withRateLimiter(
-	inner: LLMAdapter,
-	opts: WithRateLimiterOptions = {},
-): { adapter: LLMAdapter; limiter: AdaptiveRateLimiterBundle } {
-	const limiter =
-		opts.limiter ??
-		adaptiveRateLimiter({
-			name: opts.name ?? "rateLimiter",
-			rpm: opts.rpm,
-			tpm: opts.tpm,
-			adaptation: opts.adaptation,
-			burstMultiplier: opts.burstMultiplier,
-		});
-
-	const estimateCost = (
-		messages: readonly ChatMessage[],
-		invokeOpts: LLMInvokeOptions | undefined,
-	): number => {
-		if (opts.costFn) return opts.costFn(messages, invokeOpts);
-		return 0;
-	};
-
-	const handleError = (err: unknown): void => {
-		const sig = parseRateLimitFromError(err);
-		if (sig) limiter.recordSignal(sig);
-	};
-
-	const wrap: LLMAdapter = adapterWrapper(inner, {
-		async invoke(messages, invokeOpts): Promise<LLMResponse> {
-			const tokenCost = estimateCost(messages, invokeOpts);
-			await limiter.acquire({ requestCost: 1, tokenCost, signal: invokeOpts?.signal });
-			try {
-				const resp = await firstValueFrom(fromAny(inner.invoke(messages, invokeOpts)));
-				const usage = resp.usage ?? emptyUsage();
-				const actual = sumInputTokens(usage) + sumOutputTokens(usage);
-				const delta = actual - tokenCost;
-				if (delta > 0) limiter.recordUsage(delta);
-				return resp;
-			} catch (err) {
-				handleError(err);
-				throw err;
-			}
-		},
-
-		async *stream(messages, invokeOpts): AsyncGenerator<StreamDelta> {
-			const tokenCost = estimateCost(messages, invokeOpts);
-			await limiter.acquire({ requestCost: 1, tokenCost, signal: invokeOpts?.signal });
-			try {
-				let finalTokens = 0;
-				for await (const delta of inner.stream(messages, invokeOpts)) {
-					if (delta.type === "usage") {
-						finalTokens = sumInputTokens(delta.usage) + sumOutputTokens(delta.usage);
-					}
-					yield delta;
-				}
-				const d = finalTokens - tokenCost;
-				if (d > 0) limiter.recordUsage(d);
-			} catch (err) {
-				handleError(err);
-				throw err;
-			}
-		},
-	});
-	withLayer(wrap, "withRateLimiter", inner);
-
-	return { adapter: wrap, limiter };
-}
diff --git a/src/utils/ai/adapters/middleware/replay-cache.ts b/src/utils/ai/adapters/middleware/replay-cache.ts
deleted file mode 100644
index 52d5a0ec..00000000
--- a/src/utils/ai/adapters/middleware/replay-cache.ts
+++ /dev/null
@@ -1,270 +0,0 @@
-/**
- * `withReplayCache` — content-addressed response cache over `KvStorageTier`.
- *
- * - Key: sha256 of canonicalized (messages + invoke options minus `signal`).
- * - `"read-write"` (default): returns cached response if present; on miss,
- *   passes through and stores the result.
- * - `"write-only"`: never reads; populates the cache for later runs.
- * - `"read"`: reads only; on miss, passes through without writing.
- * - `"read-strict"`: reads only; on miss, **throws `ReplayCacheMissError`**
- *   instead of passing through. Use for fixture-driven tests or offline
- *   fallback adapters where any cache miss is a test failure or a signal to
- *   degrade.
- *
- * Reuses the library's existing `KvStorageTier` abstraction — any kv tier
- * (memoryKv / fileKv / sqliteKv / indexedDbKv / custom).
- *
- * **Concurrent cache-miss dedup:** uses `singleFromAny` so two concurrent
- * calls with the same key share one upstream request. Second caller sees the
- * same response that the first caller fetched; no duplicate provider spend.
- *
- * **Circular-ref safe:** `canonicalJson` uses a seen-set replacer so
- * user-supplied `ToolDefinition.parameters` with `$ref` cycles don't stack-
- * overflow the key computation.
- *
- * **Stream cadence capture:** when `cacheStreaming: true` AND
- * `captureStreamCadence: true`, per-chunk delays (ms since previous chunk)
- * are recorded alongside the content. Replay honors the recorded cadence
- * unless `replaySpeed` is set, which multiplies the effective per-chunk
- * delay (`replaySpeed: 2` → 2× faster; `replaySpeed: 0` → instant).
- * Without `captureStreamCadence`, replay is instant regardless.
- */
-
-import { monotonicNs, ResettableTimer, wallClockNs } from "@graphrefly/pure-ts/core";
-import type { KvStorageTier } from "@graphrefly/pure-ts/extra";
-import { fromAny } from "@graphrefly/pure-ts/extra";
-import { singleFromAny } from "../../../../base/composition/single-from-any.js";
-import { firstValueFrom } from "../../../../base/sources/settled.js";
-import { contentAddressedCache } from "../_internal/content-addressed-cache.js";
-import { adapterWrapper, withLayer } from "../_internal/wrappers.js";
-import type {
-	ChatMessage,
-	LLMAdapter,
-	LLMInvokeOptions,
-	LLMResponse,
-	StreamDelta,
-} from "../core/types.js";
-
-export type ReplayCacheMode = "read" | "read-strict" | "write-only" | "read-write";
-
-export class ReplayCacheMissError extends Error {
-	override name = "ReplayCacheMissError";
-	constructor(
-		public readonly key: string,
-		public readonly method: "invoke" | "stream",
-	) {
-		super(`withReplayCache: no cached response for ${method} (key=${key}, mode=read-strict)`);
-	}
-}
-
-/**
- * Context object passed to {@link WithReplayCacheOptions.keyFn}. Extending
- * with additional fields is forward-compatible — current implementations
- * ignoring unknown fields continue to work.
- */
-export interface ReplayCacheKeyContext {
-	readonly messages: readonly ChatMessage[];
-	readonly opts: LLMInvokeOptions | undefined;
-	/** Shortcut to `opts?.keyContext` — avoids an extra guard in callers. */
-	readonly context: unknown;
-}
-
-export interface WithReplayCacheOptions {
-	storage: KvStorageTier;
-	mode?: ReplayCacheMode;
-	/**
-	 * Custom key function. Receives a {@link ReplayCacheKeyContext} with the
-	 * chat messages, the invoke options, and the caller-supplied
-	 * `opts.keyContext`. Defaults to sha256 of canonical JSON over
-	 * `(messages, opts without signal/keyContext)`.
-	 *
-	 * Legacy 2-arg form `(messages, opts?)` also accepted — the adapter
-	 * detects arity and dispatches. Prefer the object form for new code.
-	 */
-	keyFn?:
-		| ((ctx: ReplayCacheKeyContext) => string | Promise<string>)
-		| ((messages: readonly ChatMessage[], opts?: LLMInvokeOptions) => string | Promise<string>);
-	/** Prefix for cached keys (useful when sharing a tier across domains). */
-	keyPrefix?: string;
-	/**
-	 * Whether to cache streaming responses (by consuming the full stream
-	 * and replaying it as one synthetic token chunk). Default `false`.
-	 */
-	cacheStreaming?: boolean;
-	/**
-	 * When `cacheStreaming: true`, also record per-chunk delays (ms since
-	 * previous chunk) so replay can honor the original streaming cadence.
-	 * Default `false` (chunks replay instantly).
-	 */
-	captureStreamCadence?: boolean;
-	/**
-	 * Stream replay speed multiplier. `1` = original cadence (requires
-	 * `captureStreamCadence`). `2` = 2× faster. `0` = instant. Default `1`.
-	 */
-	replaySpeed?: number;
-}
-
-interface CachedEntry {
-	response: LLMResponse;
-	storedAtNs: number;
-	/**
-	 * Per-chunk deltas in milliseconds — populated only when `captureStreamCadence`
-	 * is `true` during the write. Replayed via `ResettableTimer` in stream().
-	 */
-	streamCadenceMs?: readonly number[];
-	/**
-	 * Per-chunk bodies in order (tokens only — `usage`/`finish` are reconstructed
-	 * from `response.usage` / `response.finishReason`). Populated only when
-	 * `captureStreamCadence` is `true`, used for cadence-faithful replay.
-	 */
-	streamChunks?: ReadonlyArray<{ delta: string }>;
-}
-
-type ResolveArgs = {
-	messages: readonly ChatMessage[];
-	invokeOpts: LLMInvokeOptions | undefined;
-};
-type ResolveArgsWithKey = ResolveArgs & { _precomputedKey: string };
-
-/** Wrap an adapter with a replay cache. */
-export function withReplayCache(inner: LLMAdapter, opts: WithReplayCacheOptions): LLMAdapter {
-	const mode = opts.mode ?? "read-write";
-	const cacheStreaming = opts.cacheStreaming ?? false;
-	const captureStreamCadence = opts.captureStreamCadence ?? false;
-	const replaySpeed = opts.replaySpeed ?? 1;
-	const keyPrefix = opts.keyPrefix ?? "llm-replay";
-	const isReadOnly = mode === "read" || mode === "read-strict";
-
-	// Content-addressed substrate — keys via canonicalJson + sha256 over
-	// (messages, opts minus signal/keyContext) or the caller's custom keyFn.
-	// Value type is `CachedEntry` so we can persist stream cadence alongside
-	// the response. Uses the shared substrate in `src/extra/content-addressed-
-	// storage.ts` via the LLM-specific wrapper in `_internal/`.
-	//
-	// Mode translation: `ReplayCacheMode` uses `"write-only"` (legacy name);
-	// the substrate uses `"write"`. All other modes map 1:1.
-	const cache = contentAddressedCache<CachedEntry>({
-		storage: opts.storage,
-		mode: mode === "write-only" ? "write" : mode,
-		keyFn: opts.keyFn,
-		keyPrefix,
-	});
-
-	const sleepMs = (ms: number): Promise<void> =>
-		ms <= 0
-			? Promise.resolve()
-			: new Promise<void>((resolve) => {
-					const t = new ResettableTimer();
-					t.start(ms, () => resolve());
-				});
-
-	// Singleflight — concurrent cache-miss requests with the same key share one
-	// upstream call. `keyFn` must be synchronous (singleflight needs the key
-	// before dispatching), so we compute the key eagerly in `invoke`/`stream`
-	// and thread it through as `_precomputedKey`. The passed `keyFn` reads
-	// that precomputed value instead of re-hashing.
-	const upstreamInFlight = singleFromAny<ResolveArgsWithKey, LLMResponse>(
-		async ({ messages, invokeOpts }) => {
-			return await firstValueFrom(fromAny(inner.invoke(messages, invokeOpts)));
-		},
-		{ keyFn: ({ _precomputedKey }) => _precomputedKey },
-	);
-
-	const wrap = adapterWrapper(inner, {
-		async invoke(messages, invokeOpts): Promise<LLMResponse> {
-			const key = await cache.keyFor(messages, invokeOpts);
-			const entry = await cache.lookup(messages, invokeOpts);
-			if (entry?.response) {
-				const cached = entry.response;
-				return { ...cached, metadata: { ...(cached.metadata ?? {}), replayCache: "hit" } };
-			}
-
-			if (mode === "read-strict") throw new ReplayCacheMissError(key, "invoke");
-			const resp = await upstreamInFlight({ messages, invokeOpts, _precomputedKey: key });
-			if (!isReadOnly) {
-				await cache.store(messages, invokeOpts, { response: resp, storedAtNs: wallClockNs() });
-			}
-			return resp;
-		},
-
-		async *stream(messages, invokeOpts): AsyncGenerator<StreamDelta> {
-			if (!cacheStreaming) {
-				// `read-strict` only applies to cache-checked paths. When
-				// `cacheStreaming: false` the cache isn't consulted for
-				// streams at all, so passthrough is correct — throwing would
-				// make the adapter's stream() permanently unusable.
-				for await (const delta of inner.stream(messages, invokeOpts)) yield delta;
-				return;
-			}
-			const key = await cache.keyFor(messages, invokeOpts);
-			const entry = await cache.lookup(messages, invokeOpts);
-			if (entry) {
-				const cached = entry.response;
-				// Cadence-faithful replay when both recorded chunks + delays are present.
-				if (entry.streamChunks && entry.streamCadenceMs) {
-					for (let i = 0; i < entry.streamChunks.length; i++) {
-						const delay = entry.streamCadenceMs[i] ?? 0;
-						const effective = replaySpeed > 0 ? delay / replaySpeed : 0;
-						if (effective > 0) await sleepMs(effective);
-						yield { type: "token", delta: entry.streamChunks[i]?.delta ?? "" };
-					}
-				} else if (cached.content) {
-					yield { type: "token", delta: cached.content };
-				}
-				if (cached.usage) yield { type: "usage", usage: cached.usage };
-				yield { type: "finish", reason: cached.finishReason ?? "stop" };
-				return;
-			}
-			if (mode === "read-strict") throw new ReplayCacheMissError(key, "stream");
-			// Miss: accumulate, store, re-yield.
-			let content = "";
-			let usage: LLMResponse["usage"] | undefined;
-			let finishReason: string | undefined;
-			const chunks: { delta: string }[] = [];
-			const delaysMs: number[] = [];
-			// Time-to-first-token (TTFT — provider latency / network / queue
-			// warmup) is NOT cadence; setting lastNs inside the loop on first
-			// chunk means chunk-0's delay is 0 (boundary-clean) and subsequent
-			// delays measure only inter-chunk gaps. Use the central clock so
-			// the scale matches every other cadence measurement in the library
-			// and the module stays browser-safe (spec §5.11).
-			let lastNs: number | undefined;
-			for await (const delta of inner.stream(messages, invokeOpts)) {
-				if (delta.type === "token") {
-					content += delta.delta;
-					if (captureStreamCadence) {
-						const now = monotonicNs();
-						const gap = lastNs === undefined ? 0 : (now - lastNs) / 1e6;
-						delaysMs.push(gap);
-						lastNs = now;
-						chunks.push({ delta: delta.delta });
-					}
-				}
-				if (delta.type === "usage") usage = delta.usage;
-				if (delta.type === "finish") finishReason = delta.reason;
-				yield delta;
-			}
-			if ((content || usage) && !isReadOnly) {
-				const resp: LLMResponse = {
-					content,
-					usage: usage ?? { input: { regular: 0 }, output: { regular: 0 } },
-					finishReason,
-					model: inner.model ?? invokeOpts?.model ?? "",
-					provider: inner.provider,
-				};
-				const entryToStore: CachedEntry = {
-					response: resp,
-					storedAtNs: wallClockNs(),
-					...(captureStreamCadence ? { streamChunks: chunks, streamCadenceMs: delaysMs } : {}),
-				};
-				await cache.store(messages, invokeOpts, entryToStore);
-			}
-		},
-	});
-	withLayer(wrap, "withReplayCache", inner);
-	return wrap;
-}
-
-// canonicalJson is no longer re-exported here — consumers import directly from
-// @graphrefly/pure-ts/extra. The presentation-layer re-export caused a
-// duplicate-export conflict at the root barrel level (A3 build gate).
diff --git a/src/utils/ai/adapters/middleware/resilient-adapter.ts b/src/utils/ai/adapters/middleware/resilient-adapter.ts
deleted file mode 100644
index f6ceb919..00000000
--- a/src/utils/ai/adapters/middleware/resilient-adapter.ts
+++ /dev/null
@@ -1,192 +0,0 @@
-/**
- * `resilientAdapter` — compose `withRateLimiter` + `withBudgetGate` +
- * `withLLMBreaker` + `withLLMTimeout` + `withRetry` + fallback over an {@link LLMAdapter}.
- *
- * Call-path peer of {@link resilientPipeline} (which operates on a reactive
- * `Node<T>` chain). Use `resilientPipeline` when composing graph sources; use
- * `resilientAdapter` when wrapping an adapter so downstream users see a
- * single hardened `invoke`/`stream` surface.
- *
- * Composition order (innermost to outermost, mirrors `resilientPipeline`):
- *
- * ```text
- *   rateLimit → budget → breaker → timeout → retry → fallback
- * ```
- *
- * Rationale:
- * - **rateLimit innermost** — each attempt acquires a fresh slot; a retry
- *   after a 429 waits for admission rather than bursting past the cap.
- * - **budget next** — per-attempt gate close short-circuits retries once a
- *   cap trips.
- * - **breaker next** — each attempt observes circuit health; open breaker
- *   fast-fails retries into fallback.
- * - **timeout before retry** — each retry re-arms a fresh per-attempt
- *   deadline. If `timeout` wrapped `retry`, a single deadline would cover
- *   the entire retry chain — surprising for callers.
- * - **retry before fallback** — fallback is entered only after the primary
- *   exhausts its retry budget (or immediately fails in a way the predicate
- *   doesn't retry).
- *
- * Every option is optional — omit the field and that layer is skipped. The
- * returned bundle exposes the primary adapter plus the internal bundles
- * (`rateLimiter`, `budget`, `breaker`) so callers can wire them into
- * dashboards, alerts, or `graphLens`.
- *
- * Fallback is implemented via {@link cascadingLlmAdapter}: when `fallback`
- * is provided, the wrapped primary adapter is placed at tier 0 and the
- * fallback adapter at tier 1. For N-tier cascades, use `cascadingLlmAdapter`
- * directly and wrap each tier with `resilientAdapter`.
- *
- * @module
- */
-
-import type { AdaptiveRateLimiterBundle } from "../../../resilience/adaptive-rate-limiter.js";
-import type { CircuitBreaker } from "../../../resilience/breaker.js";
-import type { LLMAdapter } from "../core/types.js";
-import type { CascadeExhaustionReport } from "../routing/cascading.js";
-import { cascadingLlmAdapter } from "../routing/cascading.js";
-import { type WithBreakerOptions, withLLMBreaker } from "./breaker.js";
-import {
-	type LLMBudgetGateBundle,
-	type WithBudgetGateOptions,
-	withBudgetGate,
-} from "./budget-gate.js";
-import { type WithRateLimiterOptions, withRateLimiter } from "./rate-limiter.js";
-import { type WithReplayCacheOptions, withReplayCache } from "./replay-cache.js";
-import { type WithRetryOptions, withRetry } from "./retry.js";
-import { withLLMTimeout } from "./timeout.js";
-
-/** Options for {@link resilientAdapter}. Every field is optional — omit to skip that layer. */
-export interface ResilientAdapterOptions {
-	/** Admission control. See {@link withRateLimiter}. */
-	rateLimit?: WithRateLimiterOptions;
-	/** Cost/cap gate. See {@link withBudgetGate}. */
-	budget?: WithBudgetGateOptions;
-	/** Circuit breaker. See {@link withBreaker}. */
-	breaker?: WithBreakerOptions;
-	/** Per-attempt deadline in milliseconds. Omit to skip the timeout wrap. */
-	timeoutMs?: number;
-	/** Retry policy on transient errors. See {@link withRetry}. */
-	retry?: WithRetryOptions;
-	/**
-	 * Fallback adapter engaged when the primary (post-retry) fails. Implemented
-	 * via {@link cascadingLlmAdapter} — the primary becomes tier 0, the
-	 * fallback becomes tier 1. For N-tier cascades, use `cascadingLlmAdapter`
-	 * directly and wrap each tier with `resilientAdapter` as needed.
-	 */
-	fallback?: LLMAdapter;
-	/** Name used as the primary tier name in the fallback cascade. Default `"primary"`. */
-	name?: string;
-	/**
-	 * Called when the cascade switches from one tier to the next after a
-	 * failure. Only fires when `fallback` is set. Threaded directly to the
-	 * inner {@link cascadingLlmAdapter}.
-	 */
-	onFallback?: (from: string, to: string, error: unknown) => void;
-	/**
-	 * Called when every tier in the cascade has been exhausted (all failed,
-	 * skipped by filter, or skipped by breaker). Only fires when `fallback`
-	 * is set. Threaded directly to the inner {@link cascadingLlmAdapter}.
-	 */
-	onExhausted?: (report: CascadeExhaustionReport) => void;
-	/**
-	 * Content-addressed replay cache wrapped OUTERMOST — a cache HIT short-
-	 * circuits the entire stack (rate-limit / budget / breaker / retry /
-	 * fallback), saving money and latency. Cache MISSes flow through the
-	 * normal stack; the successful result is stored on success. See
-	 * {@link withReplayCache}.
-	 */
-	cache?: WithReplayCacheOptions;
-}
-
-/** Output bundle of {@link resilientAdapter}. */
-export interface ResilientAdapterBundle {
-	/** The final hardened adapter. */
-	adapter: LLMAdapter;
-	/** Rate-limiter internals (for dashboards). Present only when `opts.rateLimit` was set. */
-	rateLimiter?: AdaptiveRateLimiterBundle;
-	/** Budget gate internals (for dashboards). Present only when `opts.budget` was set. */
-	budget?: LLMBudgetGateBundle;
-	/** Circuit breaker (for dashboards). Present only when `opts.breaker` was set. */
-	breaker?: CircuitBreaker;
-}
-
-/**
- * Wrap `inner` with the standard resilience stack. See module docs for the
- * composition order and rationale.
- *
- * @example
- * ```ts
- * const { adapter, budget, breaker } = resilientAdapter(openai, {
- *   rateLimit: { rpm: 60, tpm: 90_000 },
- *   budget: { caps: { usd: 5 } },
- *   breaker: { failureThreshold: 5, resetTimeoutMs: 30_000 },
- *   timeoutMs: 30_000,
- *   retry: { attempts: 3 },
- *   fallback: webllm,  // cascades to local on exhaustion
- * });
- *
- * // `adapter` is drop-in for anything expecting LLMAdapter.
- * // Subscribe to `budget.totals`, `breaker.state`, etc. for dashboards.
- * ```
- */
-export function resilientAdapter(
-	inner: LLMAdapter,
-	opts: ResilientAdapterOptions = {},
-): ResilientAdapterBundle {
-	const bundle: ResilientAdapterBundle = { adapter: inner };
-	let current: LLMAdapter = inner;
-
-	if (opts.rateLimit) {
-		const wrapped = withRateLimiter(current, opts.rateLimit);
-		current = wrapped.adapter;
-		bundle.rateLimiter = wrapped.limiter;
-	}
-	if (opts.budget) {
-		const wrapped = withBudgetGate(current, opts.budget);
-		current = wrapped.adapter;
-		bundle.budget = wrapped.budget;
-	}
-	if (opts.breaker) {
-		const wrapped = withLLMBreaker(current, opts.breaker);
-		current = wrapped.adapter;
-		bundle.breaker = wrapped.breaker;
-	}
-	if (opts.timeoutMs != null) {
-		current = withLLMTimeout(current, opts.timeoutMs);
-	}
-	if (opts.retry) {
-		current = withRetry(current, opts.retry);
-	}
-	if (opts.fallback) {
-		// Secondary tier is named `"fallback"` internally; reject the same
-		// label as the primary name so CascadeExhaustionReport.failed (a
-		// Map keyed by tier name) and `resp.metadata.tier` stamping stay
-		// unambiguous.
-		if (opts.name === "fallback") {
-			throw new RangeError(
-				'resilientAdapter: `name` cannot be "fallback" — collides with the secondary tier label.',
-			);
-		}
-		const cascadeOpts: {
-			onFallback?: (from: string, to: string, error: unknown) => void;
-			onExhausted?: (report: CascadeExhaustionReport) => void;
-		} = {};
-		if (opts.onFallback) cascadeOpts.onFallback = opts.onFallback;
-		if (opts.onExhausted) cascadeOpts.onExhausted = opts.onExhausted;
-		current = cascadingLlmAdapter(
-			[
-				{ name: opts.name ?? "primary", adapter: current },
-				{ name: "fallback", adapter: opts.fallback },
-			],
-			cascadeOpts,
-		);
-	}
-	if (opts.cache) {
-		// Outermost — a cache HIT skips the entire stack below.
-		current = withReplayCache(current, opts.cache);
-	}
-
-	bundle.adapter = current;
-	return bundle;
-}
diff --git a/src/utils/ai/adapters/middleware/retry.ts b/src/utils/ai/adapters/middleware/retry.ts
deleted file mode 100644
index 3ff7716c..00000000
--- a/src/utils/ai/adapters/middleware/retry.ts
+++ /dev/null
@@ -1,190 +0,0 @@
-/**
- * `withRetry` — retry `invoke()` / `stream()` on transient errors.
- *
- * Streaming retry is tricky: we retry only if the stream fails before
- * yielding any tokens. Once tokens have started flowing, we surface the
- * error to avoid replaying from scratch (which would double-bill and
- * confuse consumers). Opt out of streaming retry via `opts.retryStreaming = false`.
- *
- * Uses `ResettableTimer` for backoff sleeps (spec §5.10 escape hatch, same
- * pattern as `extra/resilience.ts`). Abort-aware — early-aborts before the
- * first attempt and cleans up the abort listener on both the timer-fires
- * and abort paths.
- */
-
-import { ResettableTimer } from "@graphrefly/pure-ts/core";
-import { fromAny } from "@graphrefly/pure-ts/extra";
-import { firstValueFrom } from "../../../../base/sources/settled.js";
-import { adapterWrapper, withLayer } from "../_internal/wrappers.js";
-import type { LLMAdapter, LLMResponse, StreamDelta } from "../core/types.js";
-
-export interface WithRetryOptions {
-	/** Max total attempts (including the first). Default 3. */
-	attempts?: number;
-	/** Base delay in ms. Default 500. */
-	baseDelayMs?: number;
-	/** Max delay in ms. Default 10_000. */
-	maxDelayMs?: number;
-	/**
-	 * Delay strategy. Default `"decorrelated"` — AWS-style `random(baseDelay,
-	 * min(maxDelay, prev * 3))` which smooths retry storms and matches common
-	 * SDK expectations. `"exp"` and `"linear"` produce deterministic schedules
-	 * when `jitter: false`.
-	 */
-	strategy?: "exp" | "linear" | "decorrelated";
-	/**
-	 * Add randomized jitter. Ignored for `strategy: "decorrelated"` (which is
-	 * inherently jittered). For `exp`/`linear`, symmetric jitter in `[0.5x,
-	 * 1.5x]` of the nominal delay.
-	 */
-	jitter?: boolean;
-	/**
-	 * Predicate: should this error trigger a retry? Default retries network /
-	 * 5xx / 429 / transient errors, but not 4xx (other than 429), aborts, or
-	 * `BudgetExhaustedError` from upstream middleware.
-	 */
-	shouldRetry?: (err: unknown, attempt: number) => boolean;
-	/** Retry streaming calls if they fail pre-first-token. Default true. */
-	retryStreaming?: boolean;
-}
-
-function makeAbortError(reason = "aborted"): Error {
-	const err = new Error(reason) as Error & { name: string };
-	err.name = "AbortError";
-	return err;
-}
-
-/**
- * Promise-based abort-aware sleep using `ResettableTimer`.
- * Spec §5.10 escape hatch — same pattern as `extra/resilience.ts`.
- */
-function sleep(ms: number, signal?: AbortSignal): Promise<void> {
-	if (ms <= 0) return Promise.resolve();
-	if (signal?.aborted) return Promise.reject(makeAbortError());
-	return new Promise((resolve, reject) => {
-		const timer = new ResettableTimer();
-		let onAbort: (() => void) | undefined;
-		const cleanup = (): void => {
-			timer.cancel();
-			if (signal && onAbort) signal.removeEventListener("abort", onAbort);
-		};
-		timer.start(ms, () => {
-			cleanup();
-			resolve();
-		});
-		if (signal) {
-			onAbort = (): void => {
-				cleanup();
-				reject(makeAbortError());
-			};
-			signal.addEventListener("abort", onAbort, { once: true });
-		}
-	});
-}
-
-export function withRetry(inner: LLMAdapter, opts: WithRetryOptions = {}): LLMAdapter {
-	const attempts = opts.attempts ?? 3;
-	const baseDelayMs = opts.baseDelayMs ?? 500;
-	const maxDelayMs = opts.maxDelayMs ?? 10_000;
-	const strategy = opts.strategy ?? "decorrelated";
-	const jitter = opts.jitter ?? true;
-	const shouldRetry = opts.shouldRetry ?? defaultShouldRetry;
-	const retryStreaming = opts.retryStreaming ?? true;
-
-	// Decorrelated state — carried across the same acquire's retries.
-	const delay = (attempt: number, prevDelay: number): number => {
-		if (strategy === "decorrelated") {
-			// AWS-style: random(baseDelay, min(maxDelay, prevDelay * 3))
-			const upper = Math.min(maxDelayMs, Math.max(baseDelayMs, prevDelay * 3));
-			return baseDelayMs + Math.random() * (upper - baseDelayMs);
-		}
-		const nominal = strategy === "exp" ? baseDelayMs * 2 ** (attempt - 1) : baseDelayMs * attempt;
-		const bounded = Math.min(maxDelayMs, nominal);
-		if (!jitter) return bounded;
-		// Symmetric jitter: bounded * [0.5, 1.5), clamped.
-		const jittered = bounded * (0.5 + Math.random());
-		return Math.min(maxDelayMs, jittered);
-	};
-
-	const wrap = adapterWrapper(inner, {
-		async invoke(messages, invokeOpts): Promise<LLMResponse> {
-			if (invokeOpts?.signal?.aborted) throw makeAbortError();
-			let lastErr: unknown;
-			let prevDelay = baseDelayMs;
-			for (let attempt = 1; attempt <= attempts; attempt++) {
-				try {
-					return await firstValueFrom(fromAny(inner.invoke(messages, invokeOpts)));
-				} catch (err) {
-					lastErr = err;
-					if (attempt >= attempts || !shouldRetry(err, attempt)) throw err;
-					const waitMs = delay(attempt, prevDelay);
-					prevDelay = waitMs;
-					await sleep(waitMs, invokeOpts?.signal);
-				}
-			}
-			throw lastErr;
-		},
-
-		async *stream(messages, invokeOpts): AsyncGenerator<StreamDelta> {
-			if (invokeOpts?.signal?.aborted) throw makeAbortError();
-			if (!retryStreaming) {
-				for await (const d of inner.stream(messages, invokeOpts)) yield d;
-				return;
-			}
-			let lastErr: unknown;
-			let prevDelay = baseDelayMs;
-			for (let attempt = 1; attempt <= attempts; attempt++) {
-				let yieldedAny = false;
-				try {
-					for await (const d of inner.stream(messages, invokeOpts)) {
-						yieldedAny = true;
-						yield d;
-					}
-					return;
-				} catch (err) {
-					lastErr = err;
-					if (yieldedAny) throw err;
-					if (attempt >= attempts || !shouldRetry(err, attempt)) throw err;
-					const waitMs = delay(attempt, prevDelay);
-					prevDelay = waitMs;
-					await sleep(waitMs, invokeOpts?.signal);
-				}
-			}
-			throw lastErr;
-		},
-	});
-	withLayer(wrap, "withRetry", inner);
-	return wrap;
-}
-
-function defaultShouldRetry(err: unknown, _attempt: number): boolean {
-	if (err == null) return false;
-	const e = err as { name?: string; status?: number; code?: string; message?: string };
-	// Timeout-family errors — retry by default so each attempt re-arms the
-	// per-attempt deadline set by `withLLMTimeout`. Checked BEFORE the abort
-	// guards below because `withLLMTimeout` re-throws its timer-fire path as
-	// `LLMTimeoutError` even when the underlying fetch rejected with
-	// AbortError.
-	if (e.name === "LLMTimeoutError") return true;
-	// Abort-family errors — never retry (caller initiated).
-	if (e.name === "AbortError") return false;
-	if (e.message === "aborted") return false;
-	if (e.name === "DOMException" && e.code != null && Number(e.code) === 20 /* ABORT_ERR */) {
-		return false;
-	}
-	if (e.name === "BudgetExhaustedError") return false;
-	if (e.name === "CircuitOpenError") return false;
-	if (e.status != null) {
-		if (e.status === 429) return true;
-		if (e.status >= 500 && e.status < 600) return true;
-		return false;
-	}
-	// Network-level errors often have codes like ECONNRESET, ENOTFOUND, etc.
-	if (e.code && typeof e.code === "string") {
-		if (/^E[A-Z]+$/.test(e.code)) return true;
-	}
-	if (e.message) {
-		return /network|timeout|socket|fetch|econn|eai_/i.test(e.message);
-	}
-	return false;
-}
diff --git a/src/utils/ai/adapters/middleware/timeout.ts b/src/utils/ai/adapters/middleware/timeout.ts
deleted file mode 100644
index f32d6869..00000000
--- a/src/utils/ai/adapters/middleware/timeout.ts
+++ /dev/null
@@ -1,120 +0,0 @@
-/**
- * `withLLMTimeout` — cancel `invoke()` / `stream()` after `ms` elapse.
- *
- * Wires a child AbortSignal so provider adapters can honor the cancellation
- * (all shipped adapters forward `signal` through to their fetch / SDK call).
- *
- * Uses `ResettableTimer` rather than raw `setTimeout` — same pattern as
- * `extra/resilience.ts` (spec §5.10 escape hatch documented on the class).
- */
-
-import { ResettableTimer } from "@graphrefly/pure-ts/core";
-import { fromAny } from "@graphrefly/pure-ts/extra";
-import { firstValueFrom } from "../../../../base/sources/settled.js";
-import { adapterWrapper, withLayer } from "../_internal/wrappers.js";
-import type { LLMAdapter, LLMResponse, StreamDelta } from "../core/types.js";
-
-export class LLMTimeoutError extends Error {
-	override name = "LLMTimeoutError";
-	constructor(public readonly ms: number) {
-		super(`LLM call timed out after ${ms}ms`);
-	}
-}
-
-export function withLLMTimeout(inner: LLMAdapter, ms: number): LLMAdapter {
-	if (ms <= 0) throw new RangeError("withLLMTimeout: ms must be > 0");
-
-	const linkedSignal = (
-		parent?: AbortSignal,
-	): {
-		signal: AbortSignal;
-		cancel: () => void;
-		/** `true` once our timer fired — distinguishes our-timeout vs external abort. */
-		timedOut: () => boolean;
-	} => {
-		const ac = new AbortController();
-		let timerFired = false;
-		let onParentAbort: (() => void) | undefined;
-		const timer = new ResettableTimer();
-		// Cancel the timer synchronously when the parent aborts — otherwise a
-		// parent-abort at `t = ms - ε` followed by our timer firing at
-		// `t = ms` would set `timerFired = true`, causing
-		// `convertAbortToTimeout` to incorrectly promote the user-initiated
-		// abort to an `LLMTimeoutError`.
-		if (parent) {
-			if (parent.aborted) ac.abort(parent.reason);
-			else {
-				onParentAbort = () => {
-					timer.cancel();
-					ac.abort(parent.reason);
-				};
-				parent.addEventListener("abort", onParentAbort, { once: true });
-			}
-		}
-		timer.start(ms, () => {
-			timerFired = true;
-			ac.abort(new LLMTimeoutError(ms));
-		});
-		return {
-			signal: ac.signal,
-			cancel: () => {
-				timer.cancel();
-				if (parent && onParentAbort) parent.removeEventListener("abort", onParentAbort);
-			},
-			timedOut: () => timerFired,
-		};
-	};
-
-	/**
-	 * When our own timer fired, real `fetch`/SDK adapters reject with
-	 * `AbortError`/DOMException regardless of `signal.reason`. We convert
-	 * that rejection into {@link LLMTimeoutError} so downstream predicates
-	 * (notably {@link defaultShouldRetry}) can distinguish "we hit the
-	 * deadline" from "caller aborted us" without relying on the adapter
-	 * preserving `signal.reason`.
-	 *
-	 * External aborts bubble through unchanged so caller-supplied
-	 * `invokeOpts.signal` still propagates as an abort.
-	 */
-	const convertAbortToTimeout = (err: unknown, timedOut: boolean): never => {
-		if (!timedOut) throw err;
-		if (err instanceof LLMTimeoutError) throw err;
-		const e = err as { name?: string; code?: string | number };
-		const isAbort =
-			e?.name === "AbortError" ||
-			(e?.name === "DOMException" && Number(e.code) === 20) /* ABORT_ERR */ ||
-			(err as Error)?.message === "aborted";
-		if (isAbort) {
-			const timeout = new LLMTimeoutError(ms);
-			(timeout as Error & { cause?: unknown }).cause = err;
-			throw timeout;
-		}
-		throw err;
-	};
-
-	const wrap = adapterWrapper(inner, {
-		async invoke(messages, invokeOpts): Promise<LLMResponse> {
-			const { signal, cancel, timedOut } = linkedSignal(invokeOpts?.signal);
-			try {
-				return await firstValueFrom(fromAny(inner.invoke(messages, { ...invokeOpts, signal })));
-			} catch (err) {
-				return convertAbortToTimeout(err, timedOut());
-			} finally {
-				cancel();
-			}
-		},
-
-		async *stream(messages, invokeOpts): AsyncGenerator<StreamDelta> {
-			const { signal, cancel, timedOut } = linkedSignal(invokeOpts?.signal);
-			try {
-				for await (const d of inner.stream(messages, { ...invokeOpts, signal })) yield d;
-			} catch (err) {
-				convertAbortToTimeout(err, timedOut());
-			} finally {
-				cancel();
-			}
-		},
-	});
-	withLayer(wrap, "withLLMTimeout", inner);
-	return wrap;
-}
diff --git a/src/utils/ai/adapters/providers/anthropic.ts b/src/utils/ai/adapters/providers/anthropic.ts
deleted file mode 100644
index fb48fc73..00000000
--- a/src/utils/ai/adapters/providers/anthropic.ts
+++ /dev/null
@@ -1,471 +0,0 @@
-/**
- * AnthropicAdapter — default fetch-backed, optional SDK-backed.
- *
- * - `anthropicAdapter({ apiKey })` uses native `fetch` + SSE parsing.
- * - `anthropicAdapter({ sdk })` delegates to a user-provided `@anthropic-ai/sdk` instance.
- *
- * Token usage mapping:
- * - `input_tokens`                                → `input.regular`
- * - `cache_read_input_tokens`                     → `input.cacheRead`
- * - `cache_creation.ephemeral_5m_input_tokens`    → `input.cacheWrite5m`
- * - `cache_creation.ephemeral_1h_input_tokens`    → `input.cacheWrite1h`
- * - `cache_creation_input_tokens` (legacy)        → `input.cacheWrite5m` (default TTL)
- * - `output_tokens`                               → `output.regular`
- * - `server_tool_use.web_search_requests`         → `auxiliary.webSearchRequests`
- */
-
-import { monotonicNs } from "@graphrefly/pure-ts/core";
-import { makeHttpError } from "../../../../base/io/http-error.js";
-import { parseSSEStream } from "../../../../base/io/sse.js";
-import type {
-	ChatMessage,
-	LLMAdapter,
-	LLMInvokeOptions,
-	LLMResponse,
-	StreamDelta,
-	TokenUsage,
-	ToolDefinition,
-} from "../core/types.js";
-
-// ---------------------------------------------------------------------------
-// Options
-// ---------------------------------------------------------------------------
-
-export interface AnthropicAdapterOptions {
-	/** API key. Falls back to `process.env.ANTHROPIC_API_KEY` on Node. */
-	apiKey?: string;
-	/** Default model (overridable per-call via `LLMInvokeOptions.model`). */
-	model?: string;
-	/** Override the base URL. Default `https://api.anthropic.com`. */
-	baseURL?: string;
-	/** API version header. Default `"2023-06-01"`. */
-	anthropicVersion?: string;
-	/** Additional headers to send on every request (overridden by per-call). */
-	headers?: Record<string, string>;
-	/**
-	 * User-provided SDK instance. When present, the adapter delegates to it
-	 * (uses `.messages.create`) instead of native fetch.
-	 * Shape matches `@anthropic-ai/sdk` `.messages` API; any object with a
-	 * compatible `create`/`stream` contract works.
-	 */
-	sdk?: AnthropicSdkLike;
-	/** Custom fetch (useful for tests). Default `globalThis.fetch`. */
-	fetchImpl?: typeof fetch;
-}
-
-/** Minimal SDK shape we interoperate with. */
-export interface AnthropicSdkLike {
-	messages: {
-		create(
-			params: Record<string, unknown>,
-			opts?: { signal?: AbortSignal },
-		): Promise<AnthropicMessageResponse>;
-		stream?(
-			params: Record<string, unknown>,
-			opts?: { signal?: AbortSignal },
-		): AsyncIterable<AnthropicStreamEvent>;
-	};
-}
-
-interface AnthropicMessageResponse {
-	id: string;
-	content: ReadonlyArray<
-		| { type: "text"; text: string }
-		| { type: "tool_use"; id: string; name: string; input: Record<string, unknown> }
-		| { type: "thinking"; thinking: string }
-		| { type: string; [key: string]: unknown }
-	>;
-	stop_reason?: string;
-	usage: AnthropicUsage;
-	model?: string;
-}
-
-interface AnthropicUsage {
-	input_tokens?: number;
-	output_tokens?: number;
-	cache_read_input_tokens?: number;
-	cache_creation_input_tokens?: number;
-	cache_creation?: {
-		ephemeral_5m_input_tokens?: number;
-		ephemeral_1h_input_tokens?: number;
-	};
-	server_tool_use?: {
-		web_search_requests?: number;
-	};
-}
-
-type AnthropicStreamEvent =
-	| { type: "message_start"; message: { usage: AnthropicUsage } }
-	| { type: "content_block_start"; index: number; content_block: Record<string, unknown> }
-	| { type: "content_block_delta"; index: number; delta: Record<string, unknown> }
-	| { type: "content_block_stop"; index: number }
-	| { type: "message_delta"; delta: { stop_reason?: string; usage?: AnthropicUsage } }
-	| { type: "message_stop" }
-	| { type: string; [key: string]: unknown };
-
-// ---------------------------------------------------------------------------
-// Factory
-// ---------------------------------------------------------------------------
-
-export function anthropicAdapter(opts: AnthropicAdapterOptions = {}): LLMAdapter {
-	if (opts.sdk) return sdkBackedAnthropic(opts);
-	return fetchBackedAnthropic(opts);
-}
-
-// ---------------------------------------------------------------------------
-// Request/response mapping
-// ---------------------------------------------------------------------------
-
-function toAnthropicRequest(
-	messages: readonly ChatMessage[],
-	invokeOpts: LLMInvokeOptions | undefined,
-	defaultModel: string | undefined,
-	stream: boolean,
-): Record<string, unknown> {
-	const model = invokeOpts?.model ?? defaultModel;
-	if (!model)
-		throw new Error("anthropicAdapter: model must be set via options.model or invokeOpts.model");
-
-	const { system, chat } = partitionSystem(messages, invokeOpts?.systemPrompt);
-
-	const body: Record<string, unknown> = {
-		model,
-		messages: chat.map(toAnthropicMessage),
-		max_tokens: invokeOpts?.maxTokens ?? 4096,
-	};
-	if (system) body.system = system;
-	if (invokeOpts?.temperature != null) body.temperature = invokeOpts.temperature;
-	if (invokeOpts?.tools && invokeOpts.tools.length > 0)
-		body.tools = invokeOpts.tools.map(toAnthropicTool);
-	if (invokeOpts?.maxReasoningTokens != null) {
-		body.thinking = { type: "enabled", budget_tokens: invokeOpts.maxReasoningTokens };
-	}
-	if (invokeOpts?.cacheHint) {
-		// Cache-control injected per-message by the user (Anthropic cache is
-		// block-level). We surface the hint via metadata, but the canonical
-		// cacheHint API is informational — power users pass cache_control
-		// directly on messages via providerExtras.
-	}
-	if (stream) body.stream = true;
-	if (invokeOpts?.providerExtras) Object.assign(body, invokeOpts.providerExtras);
-	return body;
-}
-
-function partitionSystem(
-	messages: readonly ChatMessage[],
-	systemPrompt: string | undefined,
-): { system: string | undefined; chat: readonly ChatMessage[] } {
-	const systemParts: string[] = [];
-	if (systemPrompt) systemParts.push(systemPrompt);
-	const chat: ChatMessage[] = [];
-	for (const m of messages) {
-		if (m.role === "system") systemParts.push(m.content);
-		else chat.push(m);
-	}
-	return { system: systemParts.length > 0 ? systemParts.join("\n\n") : undefined, chat };
-}
-
-function toAnthropicMessage(m: ChatMessage): Record<string, unknown> {
-	if (m.role === "tool") {
-		return {
-			role: "user",
-			content: [
-				{
-					type: "tool_result",
-					tool_use_id: m.toolCallId,
-					content: m.content,
-				},
-			],
-		};
-	}
-	if (m.role === "assistant" && m.toolCalls && m.toolCalls.length > 0) {
-		const blocks: unknown[] = [];
-		if (m.content) blocks.push({ type: "text", text: m.content });
-		for (const tc of m.toolCalls) {
-			blocks.push({ type: "tool_use", id: tc.id, name: tc.name, input: tc.arguments });
-		}
-		return { role: "assistant", content: blocks };
-	}
-	return { role: m.role, content: m.content };
-}
-
-function toAnthropicTool(t: ToolDefinition): Record<string, unknown> {
-	return {
-		name: t.name,
-		description: t.description,
-		input_schema: t.parameters,
-	};
-}
-
-/**
- * Merge an incoming Anthropic usage update into the running snapshot. Unlike
- * a shallow spread, this preserves nested `cache_creation` fields when the
- * update omits them (or sends an empty object). Applied to both SSE and SDK
- * streaming paths.
- */
-function mergeAnthropicUsage(
-	prev: AnthropicUsage | undefined,
-	next: AnthropicUsage,
-): AnthropicUsage {
-	if (!prev) return { ...next };
-	const merged: AnthropicUsage = { ...prev };
-	// Scalar fields: overwrite when present in `next`.
-	if (next.input_tokens != null) merged.input_tokens = next.input_tokens;
-	if (next.output_tokens != null) merged.output_tokens = next.output_tokens;
-	if (next.cache_read_input_tokens != null)
-		merged.cache_read_input_tokens = next.cache_read_input_tokens;
-	if (next.cache_creation_input_tokens != null)
-		merged.cache_creation_input_tokens = next.cache_creation_input_tokens;
-	// Nested `cache_creation`: shallow-merge its own fields so a non-empty
-	// update doesn't wipe a prior ephemeral_5m/1h value.
-	if (next.cache_creation) {
-		merged.cache_creation = {
-			...(prev.cache_creation ?? {}),
-			...next.cache_creation,
-		};
-	}
-	if (next.server_tool_use) {
-		merged.server_tool_use = {
-			...(prev.server_tool_use ?? {}),
-			...next.server_tool_use,
-		};
-	}
-	return merged;
-}
-
-function mapUsage(u: AnthropicUsage | undefined): TokenUsage {
-	const usage: TokenUsage = {
-		input: { regular: u?.input_tokens ?? 0 },
-		output: { regular: u?.output_tokens ?? 0 },
-		raw: u,
-	};
-	if (u?.cache_read_input_tokens) usage.input.cacheRead = u.cache_read_input_tokens;
-	if (u?.cache_creation) {
-		if (u.cache_creation.ephemeral_5m_input_tokens)
-			usage.input.cacheWrite5m = u.cache_creation.ephemeral_5m_input_tokens;
-		if (u.cache_creation.ephemeral_1h_input_tokens)
-			usage.input.cacheWrite1h = u.cache_creation.ephemeral_1h_input_tokens;
-	} else if (u?.cache_creation_input_tokens) {
-		// Legacy flat field — default to 5m TTL.
-		usage.input.cacheWrite5m = u.cache_creation_input_tokens;
-	}
-	if (u?.server_tool_use?.web_search_requests) {
-		usage.auxiliary = { webSearchRequests: u.server_tool_use.web_search_requests };
-	}
-	return usage;
-}
-
-function toLLMResponse(msg: AnthropicMessageResponse, latencyMs: number): LLMResponse {
-	const textParts: string[] = [];
-	const toolCalls: { id: string; name: string; arguments: Record<string, unknown> }[] = [];
-	for (const block of msg.content) {
-		if (block.type === "text" && typeof (block as { text?: unknown }).text === "string") {
-			textParts.push((block as { text: string }).text);
-		} else if (block.type === "tool_use") {
-			const tb = block as { id: string; name: string; input: Record<string, unknown> };
-			toolCalls.push({ id: tb.id, name: tb.name, arguments: tb.input ?? {} });
-		}
-	}
-	return {
-		content: textParts.join(""),
-		toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
-		usage: mapUsage(msg.usage),
-		finishReason: msg.stop_reason,
-		latencyMs,
-		model: msg.model,
-		provider: "anthropic",
-	};
-}
-
-// ---------------------------------------------------------------------------
-// Fetch-backed impl
-// ---------------------------------------------------------------------------
-
-function fetchBackedAnthropic(opts: AnthropicAdapterOptions): LLMAdapter {
-	const apiKey =
-		opts.apiKey ??
-		(globalThis as { process?: { env?: Record<string, string> } }).process?.env?.ANTHROPIC_API_KEY;
-	if (!apiKey) {
-		// Don't throw at construction — allow test harnesses / dry-run setups
-		// that never call invoke. Throw at first use instead.
-	}
-	const baseURL = opts.baseURL ?? "https://api.anthropic.com";
-	const anthropicVersion = opts.anthropicVersion ?? "2023-06-01";
-	const fetchImpl = opts.fetchImpl ?? fetch;
-
-	const commonHeaders = (): Record<string, string> => {
-		if (!apiKey)
-			throw new Error("anthropicAdapter: apiKey required for invoke/stream (or provide opts.sdk)");
-		return {
-			"x-api-key": apiKey,
-			"anthropic-version": anthropicVersion,
-			"content-type": "application/json",
-			...(opts.headers ?? {}),
-		};
-	};
-
-	return {
-		provider: "anthropic",
-		model: opts.model,
-
-		async invoke(messages, invokeOpts): Promise<LLMResponse> {
-			const body = toAnthropicRequest(messages, invokeOpts, opts.model, false);
-			const start = monotonicNs();
-			const resp = await fetchImpl(`${baseURL}/v1/messages`, {
-				method: "POST",
-				headers: commonHeaders(),
-				body: JSON.stringify(body),
-				signal: invokeOpts?.signal,
-			});
-			if (!resp.ok) throw await makeHttpError(resp, "Anthropic");
-			const json = (await resp.json()) as AnthropicMessageResponse;
-			const latencyMs = Math.max(0, (monotonicNs() - start) / 1e6);
-			return toLLMResponse(json, latencyMs);
-		},
-
-		async *stream(messages, invokeOpts): AsyncGenerator<StreamDelta> {
-			const body = toAnthropicRequest(messages, invokeOpts, opts.model, true);
-			const resp = await fetchImpl(`${baseURL}/v1/messages`, {
-				method: "POST",
-				headers: { ...commonHeaders(), accept: "text/event-stream" },
-				body: JSON.stringify(body),
-				signal: invokeOpts?.signal,
-			});
-			if (!resp.ok) throw await makeHttpError(resp, "Anthropic");
-			if (!resp.body) throw new Error("anthropicAdapter: streaming response has no body");
-
-			let finalUsage: AnthropicUsage | undefined;
-			let finishReason: string | undefined;
-			const toolCallsByIndex: Map<number, { id: string; name: string; argBuf: string }> = new Map();
-
-			for await (const event of parseSSEStream(resp.body, { signal: invokeOpts?.signal })) {
-				const data = event.data;
-				if (!data) continue;
-				let parsed: AnthropicStreamEvent;
-				try {
-					parsed = JSON.parse(data) as AnthropicStreamEvent;
-				} catch {
-					continue;
-				}
-				switch (parsed.type) {
-					case "message_start": {
-						const ms = parsed as { message: { usage: AnthropicUsage } };
-						finalUsage = mergeAnthropicUsage(finalUsage, ms.message.usage);
-						break;
-					}
-					case "content_block_start": {
-						const cb = parsed as { index: number; content_block: Record<string, unknown> };
-						const b = cb.content_block;
-						if (b.type === "tool_use") {
-							toolCallsByIndex.set(cb.index, {
-								id: String(b.id ?? ""),
-								name: String(b.name ?? ""),
-								argBuf: "",
-							});
-							yield {
-								type: "tool-call-delta",
-								delta: { id: String(b.id ?? ""), name: String(b.name ?? "") },
-							};
-						}
-						break;
-					}
-					case "content_block_delta": {
-						const cbd = parsed as { index: number; delta: Record<string, unknown> };
-						const d = cbd.delta;
-						if (d.type === "text_delta" && typeof d.text === "string") {
-							yield { type: "token", delta: d.text };
-						} else if (d.type === "input_json_delta" && typeof d.partial_json === "string") {
-							const existing = toolCallsByIndex.get(cbd.index);
-							if (existing) existing.argBuf += d.partial_json;
-							yield {
-								type: "tool-call-delta",
-								delta: { argumentsDelta: d.partial_json },
-							};
-						} else if (d.type === "thinking_delta" && typeof d.thinking === "string") {
-							yield { type: "thinking", delta: d.thinking };
-						}
-						break;
-					}
-					case "message_delta": {
-						const md = parsed as { delta: { stop_reason?: string; usage?: AnthropicUsage } };
-						if (md.delta.stop_reason) finishReason = md.delta.stop_reason;
-						if (md.delta.usage) {
-							finalUsage = mergeAnthropicUsage(finalUsage, md.delta.usage);
-						}
-						break;
-					}
-					case "message_stop":
-						// Fall through to finalize after the loop.
-						break;
-				}
-			}
-			if (finalUsage) yield { type: "usage", usage: mapUsage(finalUsage) };
-			yield { type: "finish", reason: finishReason ?? "stop" };
-		},
-	};
-}
-
-// ---------------------------------------------------------------------------
-// SDK-backed impl
-// ---------------------------------------------------------------------------
-
-function sdkBackedAnthropic(opts: AnthropicAdapterOptions): LLMAdapter {
-	const sdk = opts.sdk;
-	if (!sdk) throw new Error("sdkBackedAnthropic: sdk instance required");
-	return {
-		provider: "anthropic",
-		model: opts.model,
-
-		async invoke(messages, invokeOpts): Promise<LLMResponse> {
-			const body = toAnthropicRequest(messages, invokeOpts, opts.model, false);
-			const start = monotonicNs();
-			const resp = (await sdk.messages.create(body, {
-				signal: invokeOpts?.signal,
-			})) as AnthropicMessageResponse;
-			const latencyMs = Math.max(0, (monotonicNs() - start) / 1e6);
-			return toLLMResponse(resp, latencyMs);
-		},
-
-		async *stream(messages, invokeOpts): AsyncGenerator<StreamDelta> {
-			if (!sdk.messages.stream) {
-				throw new Error("sdkBackedAnthropic: SDK instance does not expose .messages.stream");
-			}
-			const body = toAnthropicRequest(messages, invokeOpts, opts.model, true);
-			let finalUsage: AnthropicUsage | undefined;
-			let finishReason: string | undefined;
-			for await (const event of sdk.messages.stream(body, { signal: invokeOpts?.signal })) {
-				switch (event.type) {
-					case "message_start":
-						finalUsage = mergeAnthropicUsage(
-							finalUsage,
-							(event as { message: { usage: AnthropicUsage } }).message.usage,
-						);
-						break;
-					case "content_block_delta": {
-						const d = (event as { delta: Record<string, unknown> }).delta;
-						if (d?.type === "text_delta" && typeof d.text === "string") {
-							yield { type: "token", delta: d.text };
-						} else if (d?.type === "input_json_delta" && typeof d.partial_json === "string") {
-							yield { type: "tool-call-delta", delta: { argumentsDelta: d.partial_json } };
-						} else if (d?.type === "thinking_delta" && typeof d.thinking === "string") {
-							yield { type: "thinking", delta: d.thinking };
-						}
-						break;
-					}
-					case "message_delta": {
-						const md = event as { delta: { stop_reason?: string; usage?: AnthropicUsage } };
-						if (md.delta.stop_reason) finishReason = md.delta.stop_reason;
-						if (md.delta.usage) finalUsage = mergeAnthropicUsage(finalUsage, md.delta.usage);
-						break;
-					}
-				}
-			}
-			if (finalUsage) yield { type: "usage", usage: mapUsage(finalUsage) };
-			yield { type: "finish", reason: finishReason ?? "stop" };
-		},
-	};
-}
-
-// ---------------------------------------------------------------------------
-// SSE parser
-// ---------------------------------------------------------------------------
diff --git a/src/utils/ai/adapters/providers/browser/chrome-nano.ts b/src/utils/ai/adapters/providers/browser/chrome-nano.ts
deleted file mode 100644
index 026adb0d..00000000
--- a/src/utils/ai/adapters/providers/browser/chrome-nano.ts
+++ /dev/null
@@ -1,157 +0,0 @@
-/**
- * ChromeNanoAdapter — Chrome Built-in AI Prompt API.
- *
- * Uses `navigator.ai.languageModel` (Chrome 131+, origin trial / flag gated).
- * Zero download, instant startup — but limited capability (no tool use on
- * most versions, no rich system prompts on some).
- *
- * **Stream mode:** Chrome AI has historically switched between emitting
- * accumulated (each chunk is the full text so far) and delta (each chunk is
- * only the new tokens) streams across versions. Default `streamMode: "accumulated"`
- * matches current behavior; pass `"delta"` if you've verified your browser
- * emits pure deltas.
- */
-
-import { monotonicNs } from "@graphrefly/pure-ts/core";
-import type {
-	ChatMessage,
-	LLMAdapter,
-	LLMInvokeOptions,
-	LLMResponse,
-	StreamDelta,
-	TokenUsage,
-} from "../../core/types.js";
-
-export interface ChromeNanoAdapterOptions {
-	/** Override the navigator object (for tests). */
-	navigatorOverride?: Navigator;
-	/** Initial system prompt for the session (Chrome AI supports it in 131+). */
-	systemPrompt?: string;
-	/** Temperature (0..1). */
-	temperature?: number;
-	/** Top-K sampling (Chrome AI only). */
-	topK?: number;
-	/**
-	 * Stream chunk shape. `"accumulated"` (default) — each chunk contains the
-	 * full cumulative text; adapter computes deltas by string diffing.
-	 * `"delta"` — each chunk already contains only the new tokens; adapter
-	 * forwards directly.
-	 */
-	streamMode?: "accumulated" | "delta";
-}
-
-interface ChromeAiSession {
-	prompt(input: string, opts?: { signal?: AbortSignal }): Promise<string>;
-	promptStreaming(input: string, opts?: { signal?: AbortSignal }): AsyncIterable<string>;
-	destroy?(): void;
-}
-
-interface ChromeAi {
-	languageModel?: {
-		create(params?: {
-			systemPrompt?: string;
-			temperature?: number;
-			topK?: number;
-			signal?: AbortSignal;
-		}): Promise<ChromeAiSession>;
-		capabilities?(): Promise<{ available?: "readily" | "after-download" | "no" }>;
-	};
-}
-
-function makeAbortError(): Error {
-	const err = new Error("aborted") as Error & { name: string };
-	err.name = "AbortError";
-	return err;
-}
-
-export function chromeNanoAdapter(opts: ChromeNanoAdapterOptions = {}): LLMAdapter {
-	const streamMode = opts.streamMode ?? "accumulated";
-	const nav = opts.navigatorOverride ?? (globalThis as { navigator?: Navigator }).navigator;
-	const getAi = (): ChromeAi => {
-		const ai = (nav as unknown as { ai?: ChromeAi })?.ai;
-		if (!ai?.languageModel)
-			throw new Error(
-				"chromeNanoAdapter: Chrome AI languageModel not available (requires Chrome 131+ with flag/OT).",
-			);
-		return ai;
-	};
-
-	const session = async (invokeOpts: LLMInvokeOptions | undefined): Promise<ChromeAiSession> => {
-		const ai = getAi();
-		return ai.languageModel!.create({
-			systemPrompt: invokeOpts?.systemPrompt ?? opts.systemPrompt,
-			temperature: invokeOpts?.temperature ?? opts.temperature,
-			topK: opts.topK,
-			signal: invokeOpts?.signal,
-		});
-	};
-
-	const flatten = (messages: readonly ChatMessage[]): string => {
-		// Chrome AI has no multi-message chat API; flatten to a single prompt
-		// with role-tagged sections. Assistant history is preserved as context.
-		const parts: string[] = [];
-		for (const m of messages) {
-			if (m.role === "system") continue; // already passed via systemPrompt
-			parts.push(`${m.role}: ${m.content}`);
-		}
-		return parts.join("\n\n");
-	};
-
-	// Chrome AI exposes no token count; we leave usage zeroed.
-	const zeroUsage = (): TokenUsage => ({ input: { regular: 0 }, output: { regular: 0 } });
-
-	return {
-		provider: "chrome-nano",
-		model: "chrome-nano",
-
-		async invoke(messages, invokeOpts): Promise<LLMResponse> {
-			const sess = await session(invokeOpts);
-			try {
-				const prompt = flatten(messages);
-				const start = monotonicNs();
-				const content = await sess.prompt(prompt, { signal: invokeOpts?.signal });
-				const latencyMs = Math.max(0, (monotonicNs() - start) / 1e6);
-				return {
-					content,
-					usage: zeroUsage(),
-					finishReason: "stop",
-					latencyMs,
-					model: "chrome-nano",
-					provider: "chrome-nano",
-				};
-			} finally {
-				sess.destroy?.();
-			}
-		},
-
-		async *stream(messages, invokeOpts): AsyncGenerator<StreamDelta> {
-			const sess = await session(invokeOpts);
-			try {
-				const prompt = flatten(messages);
-				if (streamMode === "delta") {
-					for await (const chunk of sess.promptStreaming(prompt, {
-						signal: invokeOpts?.signal,
-					})) {
-						if (invokeOpts?.signal?.aborted) throw makeAbortError();
-						if (chunk) yield { type: "token", delta: chunk };
-					}
-				} else {
-					let last = "";
-					for await (const chunk of sess.promptStreaming(prompt, {
-						signal: invokeOpts?.signal,
-					})) {
-						if (invokeOpts?.signal?.aborted) throw makeAbortError();
-						// Accumulated mode: compute the delta against the last cumulative value.
-						const delta = chunk.startsWith(last) ? chunk.slice(last.length) : chunk;
-						last = chunk;
-						if (delta) yield { type: "token", delta };
-					}
-				}
-				yield { type: "usage", usage: zeroUsage() };
-				yield { type: "finish", reason: "stop" };
-			} finally {
-				sess.destroy?.();
-			}
-		},
-	};
-}
diff --git a/src/utils/ai/adapters/providers/browser/index.ts b/src/utils/ai/adapters/providers/browser/index.ts
deleted file mode 100644
index 35bfd9e1..00000000
--- a/src/utils/ai/adapters/providers/browser/index.ts
+++ /dev/null
@@ -1,2 +0,0 @@
-export * from "./chrome-nano.js";
-export * from "./webllm.js";
diff --git a/src/utils/ai/adapters/providers/browser/webllm.ts b/src/utils/ai/adapters/providers/browser/webllm.ts
deleted file mode 100644
index 9244a819..00000000
--- a/src/utils/ai/adapters/providers/browser/webllm.ts
+++ /dev/null
@@ -1,152 +0,0 @@
-/**
- * WebLLMAdapter — browser-only, WebGPU-based inference via `@mlc-ai/web-llm`.
- *
- * Dynamic import + WebGPU feature detection. No server dependency. Typical
- * use: fallback tier in `cascadingLlmAdapter` after a BYOK cloud adapter.
- */
-
-import { monotonicNs } from "@graphrefly/pure-ts/core";
-import type {
-	ChatMessage,
-	LLMAdapter,
-	LLMInvokeOptions,
-	LLMResponse,
-	StreamDelta,
-	TokenUsage,
-} from "../../core/types.js";
-
-export interface WebLLMAdapterOptions {
-	model: string;
-	/**
-	 * User-provided engine instance (from `CreateMLCEngine(...)`). If omitted,
-	 * the adapter lazy-creates one on first call via dynamic import.
-	 */
-	engine?: WebLLMEngineLike;
-	/** Pass-through to `CreateMLCEngine`. */
-	initProgressCallback?: (progress: unknown) => void;
-	/** Navigator override (for tests). */
-	navigatorOverride?: Navigator;
-}
-
-export interface WebLLMEngineLike {
-	chat: {
-		completions: {
-			create(
-				params: Record<string, unknown>,
-				opts?: { signal?: AbortSignal },
-			): Promise<{
-				choices: ReadonlyArray<{ message?: { content?: string }; finish_reason?: string }>;
-				usage?: { prompt_tokens?: number; completion_tokens?: number };
-			}>;
-		};
-	};
-}
-
-function makeAbortError(): Error {
-	const err = new Error("aborted") as Error & { name: string };
-	err.name = "AbortError";
-	return err;
-}
-
-export function webllmAdapter(opts: WebLLMAdapterOptions): LLMAdapter {
-	let engine = opts.engine;
-
-	const ensureEngine = async (): Promise<WebLLMEngineLike> => {
-		if (engine) return engine;
-		if (!isWebGpuAvailable(opts.navigatorOverride))
-			throw new Error("webllmAdapter: WebGPU not available in this environment");
-		const mod = await import("@mlc-ai/web-llm" as string).catch(() => {
-			throw new Error(
-				"webllmAdapter: @mlc-ai/web-llm not installed. Add it as a peer dependency or pass opts.engine.",
-			);
-		});
-		const factory = (
-			mod as { CreateMLCEngine?: (m: string, o?: unknown) => Promise<WebLLMEngineLike> }
-		).CreateMLCEngine;
-		if (!factory) throw new Error("webllmAdapter: @mlc-ai/web-llm missing CreateMLCEngine export");
-		engine = await factory(opts.model, { initProgressCallback: opts.initProgressCallback });
-		return engine;
-	};
-
-	const flatten = (
-		messages: readonly ChatMessage[],
-		invokeOpts: LLMInvokeOptions | undefined,
-	): Array<{ role: string; content: string }> => {
-		const flat: Array<{ role: string; content: string }> = [];
-		if (invokeOpts?.systemPrompt) flat.push({ role: "system", content: invokeOpts.systemPrompt });
-		for (const m of messages)
-			flat.push({ role: m.role === "tool" ? "user" : m.role, content: m.content });
-		return flat;
-	};
-
-	const mapUsage = (
-		u: { prompt_tokens?: number; completion_tokens?: number } | undefined,
-	): TokenUsage => ({
-		input: { regular: u?.prompt_tokens ?? 0 },
-		output: { regular: u?.completion_tokens ?? 0 },
-		raw: u,
-	});
-
-	return {
-		provider: "webllm",
-		model: opts.model,
-
-		async invoke(messages, invokeOpts): Promise<LLMResponse> {
-			const eng = await ensureEngine();
-			const start = monotonicNs();
-			const resp = await eng.chat.completions.create(
-				{
-					model: invokeOpts?.model ?? opts.model,
-					messages: flatten(messages, invokeOpts),
-					max_tokens: invokeOpts?.maxTokens,
-					temperature: invokeOpts?.temperature,
-				},
-				{ signal: invokeOpts?.signal },
-			);
-			const latencyMs = Math.max(0, (monotonicNs() - start) / 1e6);
-			const choice = resp.choices?.[0];
-			return {
-				content: choice?.message?.content ?? "",
-				usage: mapUsage(resp.usage),
-				finishReason: choice?.finish_reason,
-				latencyMs,
-				model: opts.model,
-				provider: "webllm",
-			};
-		},
-
-		async *stream(messages, invokeOpts): AsyncGenerator<StreamDelta> {
-			const eng = await ensureEngine();
-			const asyncIter = (await eng.chat.completions.create(
-				{
-					model: invokeOpts?.model ?? opts.model,
-					messages: flatten(messages, invokeOpts),
-					max_tokens: invokeOpts?.maxTokens,
-					temperature: invokeOpts?.temperature,
-					stream: true,
-				},
-				{ signal: invokeOpts?.signal },
-			)) as unknown as AsyncIterable<{
-				choices?: ReadonlyArray<{ delta?: { content?: string }; finish_reason?: string }>;
-				usage?: { prompt_tokens?: number; completion_tokens?: number };
-			}>;
-
-			let finalUsage: { prompt_tokens?: number; completion_tokens?: number } | undefined;
-			let finishReason: string | undefined;
-			for await (const chunk of asyncIter) {
-				if (invokeOpts?.signal?.aborted) throw makeAbortError();
-				const c = chunk.choices?.[0];
-				if (c?.delta?.content) yield { type: "token", delta: c.delta.content };
-				if (c?.finish_reason) finishReason = c.finish_reason;
-				if (chunk.usage) finalUsage = chunk.usage;
-			}
-			if (finalUsage) yield { type: "usage", usage: mapUsage(finalUsage) };
-			yield { type: "finish", reason: finishReason ?? "stop" };
-		},
-	};
-}
-
-function isWebGpuAvailable(navOverride?: Navigator): boolean {
-	const nav = navOverride ?? (globalThis as { navigator?: Navigator }).navigator;
-	return !!(nav && "gpu" in nav && (nav as unknown as { gpu?: unknown }).gpu);
-}
diff --git a/src/utils/ai/adapters/providers/dry-run.ts b/src/utils/ai/adapters/providers/dry-run.ts
deleted file mode 100644
index b6393793..00000000
--- a/src/utils/ai/adapters/providers/dry-run.ts
+++ /dev/null
@@ -1,144 +0,0 @@
-/**
- * DryRunAdapter — zero-cost mock provider.
- *
- * Returns a deterministic fake response (plus a configurable hook for
- * customization). Useful for: pipeline smoke tests, CI without API keys,
- * local development, and as the leaf of a `cascadingLlmAdapter` when every
- * real tier fails.
- *
- * The library ships a minimal implementation only — richer scenario-
- * scripted mocks (per-stage responses, call recording) belong at the test
- * harness layer, not in the shipped library.
- *
- * Uses `ResettableTimer` for simulated latency (spec §5.10 escape hatch
- * documented on the class), and throws an `AbortError`-named Error on
- * abort so retry/timeout middleware can classify it.
- */
-
-import { ResettableTimer } from "@graphrefly/pure-ts/core";
-import type {
-	ChatMessage,
-	LLMAdapter,
-	LLMInvokeOptions,
-	LLMResponse,
-	StreamDelta,
-	TokenUsage,
-} from "../core/types.js";
-
-export interface DryRunAdapterOptions {
-	provider?: string;
-	model?: string;
-	/** Generate the fake response. Defaults to echoing the last user message. */
-	respond?: (messages: readonly ChatMessage[], opts?: LLMInvokeOptions) => string;
-	/**
-	 * Generate a fake usage object. Defaults to a simple character-count
-	 * heuristic (`input = sum(messages) / 4`, `output = content / 4`).
-	 */
-	usage?: (messages: readonly ChatMessage[], content: string) => TokenUsage;
-	/** Simulated latency in milliseconds (applied to both invoke and stream). */
-	latencyMs?: number;
-	/** Stream chunk size in characters. Default 16. */
-	streamChunkSize?: number;
-}
-
-function makeAbortError(): Error {
-	const err = new Error("aborted") as Error & { name: string };
-	err.name = "AbortError";
-	return err;
-}
-
-/**
- * Abort-aware sleep using `ResettableTimer`. Spec §5.10 escape hatch.
- * No-op if `ms <= 0`; rejects with `AbortError` if the signal aborts.
- */
-function sleep(ms: number, signal?: AbortSignal): Promise<void> {
-	if (ms <= 0) return Promise.resolve();
-	if (signal?.aborted) return Promise.reject(makeAbortError());
-	return new Promise((resolve, reject) => {
-		const timer = new ResettableTimer();
-		let onAbort: (() => void) | undefined;
-		const cleanup = (): void => {
-			timer.cancel();
-			if (signal && onAbort) signal.removeEventListener("abort", onAbort);
-		};
-		timer.start(ms, () => {
-			cleanup();
-			resolve();
-		});
-		if (signal) {
-			onAbort = (): void => {
-				cleanup();
-				reject(makeAbortError());
-			};
-			signal.addEventListener("abort", onAbort, { once: true });
-		}
-	});
-}
-
-/**
- * Create a DryRun adapter.
- *
- * @example
- * ```ts
- * const adapter = dryRunAdapter({ respond: (msgs) => "hello from dry-run" });
- * const resp = await Promise.resolve(adapter.invoke([{ role: "user", content: "hi" }]));
- * ```
- */
-export function dryRunAdapter(opts: DryRunAdapterOptions = {}): LLMAdapter {
-	const provider = opts.provider ?? "dry-run";
-	const model = opts.model ?? "dry-run-v1";
-	const latencyMs = opts.latencyMs ?? 0;
-	const streamChunkSize = Math.max(1, opts.streamChunkSize ?? 16);
-
-	const respondFn =
-		opts.respond ??
-		((msgs: readonly ChatMessage[]): string => {
-			const lastUser = [...msgs].reverse().find((m) => m.role === "user");
-			return lastUser ? `echo: ${lastUser.content}` : "dry-run: no user message";
-		});
-
-	const usageFn =
-		opts.usage ??
-		((msgs: readonly ChatMessage[], content: string): TokenUsage => {
-			const totalInput = msgs.reduce((s, m) => s + m.content.length, 0);
-			return {
-				input: { regular: Math.ceil(totalInput / 4) },
-				output: { regular: Math.ceil(content.length / 4) },
-			};
-		});
-
-	return {
-		provider,
-		model,
-
-		async invoke(messages, invokeOpts): Promise<LLMResponse> {
-			await sleep(latencyMs, invokeOpts?.signal);
-			if (invokeOpts?.signal?.aborted) throw makeAbortError();
-			const content = respondFn(messages, invokeOpts);
-			const usage = usageFn(messages, content);
-			return {
-				content,
-				usage,
-				finishReason: "stop",
-				model: invokeOpts?.model ?? model,
-				provider,
-				tier: invokeOpts?.tier,
-				metadata: { dryRun: true },
-			};
-		},
-
-		async *stream(messages, invokeOpts): AsyncGenerator<StreamDelta> {
-			const content = respondFn(messages, invokeOpts);
-			const usage = usageFn(messages, content);
-			const chunkCount = Math.ceil(content.length / streamChunkSize) || 1;
-			const perChunkMs = latencyMs > 0 ? latencyMs / chunkCount : 0;
-			for (let i = 0; i < content.length; i += streamChunkSize) {
-				if (invokeOpts?.signal?.aborted) throw makeAbortError();
-				await sleep(perChunkMs, invokeOpts?.signal);
-				yield { type: "token", delta: content.slice(i, i + streamChunkSize) };
-			}
-			yield { type: "usage", usage };
-			yield { type: "finish", reason: "stop" };
-		},
-	};
-}
diff --git a/src/utils/ai/adapters/providers/fallback-node.ts b/src/utils/ai/adapters/providers/fallback-node.ts
deleted file mode 100644
index 92f73309..00000000
--- a/src/utils/ai/adapters/providers/fallback-node.ts
+++ /dev/null
@@ -1,175 +0,0 @@
-/**
- * Node-subpath extension of {@link fallbackAdapter} — adds filesystem
- * directory convenience options (`fixturesDir`, `record.dir`) that rely on
- * `node:fs` / `node:path` / `fileKv`.
- *
- * This module intentionally lives outside the main `utils/ai` entry so
- * browser bundles don't pull `node:fs` / `node:path`. Import this variant
- * from `@graphrefly/graphrefly/utils/ai/node` in Node
- * environments when you want the ergonomic directory options.
- *
- * @module
- */
-
-import { existsSync, readdirSync, readFileSync } from "node:fs";
-import { join } from "node:path";
-import type { KvStorageTier } from "@graphrefly/pure-ts/extra";
-import { fileKv } from "@graphrefly/pure-ts/extra/node";
-import type { LLMAdapter } from "../core/types.js";
-import {
-	type FallbackAdapterOptions as BaseFallbackAdapterOptions,
-	fallbackAdapter as baseFallbackAdapter,
-} from "./fallback.js";
-
-/**
- * Options for the node-only `fallbackAdapter`. Adds `fixturesDir` and
- * `record.dir` to the base options.
- */
-export interface NodeFallbackAdapterOptions extends Omit<BaseFallbackAdapterOptions, "record"> {
-	/**
-	 * Directory of cache-format JSON files. Auto-namespaced to
-	 * `join(dir, keyPrefix)` so multiple adapters pointing at the same root
-	 * don't commingle files. Init-time validator throws a clear `TypeError`
-	 * if the namespaced subdirectory contains files that aren't in cache
-	 * format. Mutually exclusive with `fixtures` and `fixturesStorage`.
-	 */
-	readonly fixturesDir?: string;
-	/**
-	 * Record mode — same as the base, with `dir` as a convenience sibling to
-	 * `storage`. `dir` auto-namespaces to `join(dir, keyPrefix)`; `storage` is
-	 * pass-through. If `dir` is omitted and `fixturesDir` is set, record
-	 * defaults to writing to `fixturesDir` — the "read baseline, append
-	 * misses to same dir" pattern.
-	 */
-	readonly record?: {
-		readonly adapter: LLMAdapter;
-		readonly dir?: string;
-		readonly storage?: KvStorageTier;
-	};
-}
-
-/**
- * Validate that a namespaced `fixturesDir` subdirectory only contains files
- * in the cache format `withReplayCache` writes. Throws a clear `TypeError`
- * if a hand-authored `{messages, response}` JSON (or any non-cache JSON) is
- * present. Scans the first `.json` file found — doesn't read the whole set.
- * Silently returns if the directory doesn't exist yet (first-run case).
- */
-function validateDirShape(dir: string): void {
-	if (!existsSync(dir)) return;
-	const files = readdirSync(dir).filter((f) => f.endsWith(".json"));
-	if (files.length === 0) return;
-	const sample = files[0] as string;
-	const path = join(dir, sample);
-	let raw: unknown;
-	try {
-		raw = JSON.parse(readFileSync(path, "utf8"));
-	} catch (err) {
-		throw new TypeError(`fallbackAdapter: ${path} is not valid JSON (${(err as Error).message}).`);
-	}
-	const asObj = raw as {
-		response?: { content?: unknown };
-		storedAtNs?: unknown;
-		messages?: unknown;
-	} | null;
-	const looksLikeHandAuthored = asObj != null && "messages" in asObj;
-	const missingFields =
-		asObj == null ||
-		typeof asObj.response?.content !== "string" ||
-		typeof asObj.storedAtNs !== "number";
-	if (looksLikeHandAuthored || missingFields) {
-		const hint = looksLikeHandAuthored
-			? "`messages` at the top level means this looks hand-authored. "
-			: "";
-		throw new TypeError(
-			`fallbackAdapter: ${path} is not in cache-file format. ${hint}` +
-				"Expected `{ response: { content, usage, ... }, storedAtNs, ... }` " +
-				"(the shape `withReplayCache` and this adapter's `record` mode write). " +
-				"For hand-authored fixtures, use the inline `fixtures: FallbackFixture[]` " +
-				"option — the adapter hashes messages for you.",
-		);
-	}
-}
-
-/**
- * Node-only `fallbackAdapter` — the base variant extended with `fixturesDir`
- * and `record.dir` filesystem convenience options. Resolves those to
- * `fileKv(...)` tiers and delegates to the base `fallbackAdapter`.
- *
- * For browser-safe usage, import `fallbackAdapter` from
- * `@graphrefly/graphrefly/utils/ai` instead — that variant only accepts
- * `fixtures` and `fixturesStorage`, no `node:*` imports.
- */
-export function fallbackAdapter(opts: NodeFallbackAdapterOptions = {}): LLMAdapter {
-	const keyPrefix = opts.keyPrefix ?? "fallback";
-
-	// Enforce mutual exclusion across the three fixture sources — same rule as
-	// the base adapter, extended with `fixturesDir`.
-	const sources: string[] = [];
-	if (opts.fixtures != null) sources.push("fixtures");
-	if (opts.fixturesDir != null) sources.push("fixturesDir");
-	if (opts.fixturesStorage != null) sources.push("fixturesStorage");
-	if (sources.length > 1) {
-		throw new TypeError(
-			`fallbackAdapter: \`fixtures\`, \`fixturesDir\`, and \`fixturesStorage\` ` +
-				`are mutually exclusive; got both ${sources.join(" and ")}. Pick one source.`,
-		);
-	}
-
-	// Resolve `fixturesDir` → `fileKv(join(dir, keyPrefix))`.
-	let fixturesStorage = opts.fixturesStorage;
-	if (opts.fixturesDir != null) {
-		const namespaced = join(opts.fixturesDir, keyPrefix);
-		validateDirShape(namespaced);
-		fixturesStorage = fileKv(namespaced);
-	}
-
-	// Resolve record mode:
-	// - `record.storage` pass-through;
-	// - `record.dir` → `fileKv(join(record.dir, keyPrefix))`;
-	// - `record.dir` defaults to `fixturesDir` for "append to same dir".
-	let record: BaseFallbackAdapterOptions["record"] | undefined;
-	if (opts.record) {
-		if (opts.record.storage && opts.record.dir) {
-			throw new TypeError(
-				"fallbackAdapter: `record.storage` and `record.dir` are mutually exclusive; pick one.",
-			);
-		}
-		if (opts.record.storage) {
-			record = { adapter: opts.record.adapter, storage: opts.record.storage };
-		} else {
-			const recordDir = opts.record.dir ?? opts.fixturesDir;
-			if (recordDir == null) {
-				throw new TypeError(
-					"fallbackAdapter: record mode requires either `record.dir`, `record.storage`, " +
-						"or an inherited `fixturesDir`.",
-				);
-			}
-			record = {
-				adapter: opts.record.adapter,
-				storage: fileKv(join(recordDir, keyPrefix)),
-			};
-		}
-	}
-
-	// Hand off to the base adapter with resolved tiers. No filesystem handles
-	// leak beyond this module — the base sees only `StorageTier` abstractions.
-	// Destructure `fixturesDir` out up front rather than spread-then-delete so
-	// the forwarded shape stays frozen-friendly and doesn't carry the already-
-	// resolved directory option through to the base's (stricter) opt type.
-	const { fixturesDir: _omit, record: _recordOmit, ...restOpts } = opts;
-	const baseOpts: BaseFallbackAdapterOptions = {
-		...restOpts,
-		...(fixturesStorage ? { fixturesStorage } : {}),
-		...(record ? { record } : {}),
-	};
-	return baseFallbackAdapter(baseOpts);
-}
-
-// Re-export shared types so users can import everything from the node subpath.
-export type {
-	FallbackAdapterOptions as BaseFallbackAdapterOptions,
-	FallbackFixture,
-	FallbackMissError,
-	FallbackMissPolicy,
-} from "./fallback.js";
diff --git a/src/utils/ai/adapters/providers/fallback.ts b/src/utils/ai/adapters/providers/fallback.ts
deleted file mode 100644
index 496abf14..00000000
--- a/src/utils/ai/adapters/providers/fallback.ts
+++ /dev/null
@@ -1,398 +0,0 @@
-/**
- * `fallbackAdapter` — fixture-backed {@link LLMAdapter} for offline demos,
- * deterministic tests, and graceful degradation in production.
- *
- * A peer of `anthropicAdapter` / `openAICompatAdapter` / `googleAdapter` /
- * `ollamaAdapter` / `dryRunAdapter`, but whose role is to serve pre-recorded
- * or canned responses when real providers aren't reachable. Install it as a
- * tier via the existing routing primitives (no new composer needed):
- *
- * ```ts
- * // Graceful offline fallback for a user app:
- * resilientAdapter(anthropicAdapter({ ... }), {
- *   fallback: fallbackAdapter({ fixturesDir: "./fixtures" }),
- * });
- *
- * // Or the general N-tier shape:
- * cascadingLlmAdapter([
- *   { name: "primary",  adapter: anthropicAdapter({ ... }) },
- *   { name: "fallback", adapter: fallbackAdapter({ fixturesDir: "./fixtures" }) },
- * ]);
- * ```
- *
- * The `provider` field is `"fallback"` so its role is self-documenting in
- * logs, stats, cost tables, and audit trails.
- *
- * ## Three fixture sources (mutually exclusive)
- *
- * Pick exactly one of:
- *
- * 1. **`fixtures: FallbackFixture[]`** — inline, hand-authored. Supports
- *    both hash-keyed and messages-keyed shapes; the adapter computes the
- *    canonical hash for messages-keyed entries at init time. Ideal when you
- *    want full control in code (tests, small demos).
- *
- * 2. **`fixturesStorage: KvStorageTier`** — the escape hatch for any backend.
- *    Pass a `memoryKv()`, `indexedDbKv(...)`, `sqliteKv(...)`,
- *    `cascadingCache(...)`, or a custom tier. You own the layout — no
- *    auto-namespacing.
- *
- *    **Filesystem directories (Node only):** the core `fallbackAdapter`
- *    does NOT import `node:fs` / `node:path` — it's safe to bundle for
- *    browsers. For a directory convenience, import `fallbackAdapter` from
- *    `@graphrefly/graphrefly/utils/ai/node` (node subpath);
- *    that variant adds `fixturesDir: string` (auto-namespaced to
- *    `join(dir, keyPrefix)`, cache-format validated at init).
- *
- * ## Record mode
- *
- * `record: { adapter: real, storage }` proxies every call to `real` AND
- * persists the response through the provided tier. Use the node subpath's
- * `fallbackAdapter` for `record.dir` (auto-namespaced + `record.dir` defaults
- * to `fixturesDir` when both are file-backed).
- *
- * ## Three use cases, one implementation
- *
- * | Use case | Config |
- * |---|---|
- * | **User apps** — degrade when the cloud provider errors or network is down | `fallbackAdapter({ fixturesStorage: ... })` installed as a fallback tier |
- * | **Tests** — deterministic replays, fail loudly on miss | `fallbackAdapter({ fixturesStorage: ..., onMiss: "throw" })` |
- * | **Eval offline replay** — zero-spend repeat runs | `fallbackAdapter({ fixturesStorage: ... })` as the only adapter |
- *
- * ## Implementation
- *
- * Thin sugar over {@link withReplayCache}. Key shape comes from its
- * `canonicalJson` — fixtures written by either tool are interchangeable.
- *
- * @module
- */
-
-import { sha256Hex, wallClockNs } from "@graphrefly/pure-ts/core";
-import { canonicalJson, type KvStorageTier, memoryKv } from "@graphrefly/pure-ts/extra";
-import type {
-	ChatMessage,
-	LLMAdapter,
-	LLMInvokeOptions,
-	LLMResponse,
-	StreamDelta,
-} from "../core/types.js";
-import {
-	type ReplayCacheKeyContext,
-	ReplayCacheMissError,
-	withReplayCache,
-} from "../middleware/replay-cache.js";
-import { dryRunAdapter } from "./dry-run.js";
-
-export type FallbackMissPolicy = "throw" | "respond";
-
-/**
- * Thrown when `fallbackAdapter({ onMiss: "throw" })` receives a request that
- * has no matching fixture. Alias of `ReplayCacheMissError` for now — the
- * adapter is a thin sugar over `withReplayCache` and shares its miss-error.
- */
-export const FallbackMissError = ReplayCacheMissError;
-export type FallbackMissError = ReplayCacheMissError;
-
-/**
- * One recorded fixture. Two authoring shapes:
- * - **Hash-keyed** — `{ key, response, stream? }`. Key is `sha256(canonicalJson({messages, opts}))`
- *   with `fallback:` prefix. This is what `record` mode writes.
- * - **Messages-keyed** — `{ messages, invokeOpts?, response }`. The adapter
- *   computes the key at init time. Ergonomic for hand-authored fixtures.
- */
-export type FallbackFixture =
-	| {
-			readonly key: string;
-			readonly response: LLMResponse;
-			readonly stream?: {
-				readonly chunks: readonly StreamDelta[];
-				readonly delaysMs?: readonly number[];
-			};
-	  }
-	| {
-			readonly messages: readonly ChatMessage[];
-			readonly invokeOpts?: Omit<LLMInvokeOptions, "signal">;
-			readonly response: LLMResponse;
-	  };
-
-export interface FallbackAdapterOptions {
-	/** Adapter provider label. Default `"fallback"`. */
-	readonly provider?: string;
-	/** Adapter model label. Default `"fallback"`. */
-	readonly model?: string;
-	/**
-	 * Inline hand-authored fixtures. Supports both hash-keyed (`{key, response, stream?}`)
-	 * and messages-keyed (`{messages, invokeOpts?, response}`) shapes — the adapter
-	 * computes the canonical hash for messages-keyed entries at init time. Held in
-	 * an internal `memoryKv`. Mutually exclusive with `fixturesDir` and
-	 * `fixturesStorage`.
-	 */
-	readonly fixtures?: readonly FallbackFixture[];
-	/**
-	 * Bring-your-own `KvStorageTier` (`memoryKv`, `sqliteKv`,
-	 * `indexedDbKv`, `cascadingCache`, or a custom tier). You own the
-	 * layout — no auto-namespacing. Mutually exclusive with `fixtures`.
-	 *
-	 * For filesystem directories, use the node subpath's `fallbackAdapter`
-	 * with its `fixturesDir` option (auto-namespaced + validated).
-	 */
-	readonly fixturesStorage?: KvStorageTier;
-	/**
-	 * Called on fixture miss when `onMiss === "respond"`. If not provided and
-	 * `onMiss === "respond"`, a canned "service unavailable" response is
-	 * returned (marked with `metadata.degraded: true`).
-	 */
-	readonly respond?: (
-		messages: readonly ChatMessage[],
-		opts?: LLMInvokeOptions,
-	) => string | LLMResponse;
-	/** Miss policy. Default `"respond"`. */
-	readonly onMiss?: FallbackMissPolicy;
-	/**
-	 * Record mode. Proxies every call to `record.adapter` AND persists the
-	 * result through `record.storage`. For filesystem `record.dir` convenience,
-	 * use the node subpath's `fallbackAdapter`.
-	 */
-	readonly record?: {
-		readonly adapter: LLMAdapter;
-		readonly storage?: KvStorageTier;
-	};
-	/** Stream replay speed multiplier. See {@link withReplayCache}. Default `1`. */
-	readonly replaySpeed?: number;
-	/** Key prefix. Kept compatible with `withReplayCache` defaults. Default `"fallback"`. */
-	readonly keyPrefix?: string;
-	/**
-	 * Custom key function — forwarded directly to the underlying
-	 * {@link withReplayCache}. Use to shard fixtures by `invokeOpts.keyContext`
-	 * (tenant, session, feature flag). Accepts either the new
-	 * {@link ReplayCacheKeyContext} object form or the legacy 2-arg
-	 * `(messages, opts?)` form.
-	 */
-	readonly keyFn?:
-		| ((ctx: ReplayCacheKeyContext) => string)
-		| ((messages: readonly ChatMessage[], opts?: LLMInvokeOptions) => string);
-}
-
-// ---------------------------------------------------------------------------
-// Canned degraded response
-// ---------------------------------------------------------------------------
-
-function degradedResponse(provider: string, model: string): LLMResponse {
-	return {
-		content: "[fallback: no cached response available for this request]",
-		usage: { input: { regular: 0 }, output: { regular: 0 } },
-		finishReason: "stop",
-		model,
-		provider,
-		metadata: { degraded: true, reason: "no-fixture" },
-	};
-}
-
-function normalizeRespondResult(
-	raw: string | LLMResponse,
-	provider: string,
-	model: string,
-): LLMResponse {
-	if (typeof raw === "string") {
-		return {
-			content: raw,
-			usage: { input: { regular: 0 }, output: { regular: 0 } },
-			finishReason: "stop",
-			model,
-			provider,
-			metadata: { degraded: true, reason: "respond" },
-		};
-	}
-	return raw;
-}
-
-// ---------------------------------------------------------------------------
-// Fixture → storage tier conversion
-// ---------------------------------------------------------------------------
-
-/**
- * Compute the key a `FallbackFixture` would hash to. Messages-keyed fixtures
- * get their key derived on the spot; hash-keyed fixtures pass through. Async
- * because `sha256Hex` uses `globalThis.crypto.subtle` (universal, no
- * `node:crypto` leak) — see {@link sha256Hex}.
- */
-async function fixtureKey(fixture: FallbackFixture, keyPrefix: string): Promise<string> {
-	if ("key" in fixture) return fixture.key;
-	const canonical = canonicalJson({ messages: fixture.messages, opts: fixture.invokeOpts ?? {} });
-	const hex = await sha256Hex(canonical);
-	return `${keyPrefix}:${hex}`;
-}
-
-/**
- * `withReplayCache` stores values as `CachedEntry = { response, storedAtNs, streamChunks?, streamCadenceMs? }`.
- * Convert a `FallbackFixture` into that shape so inline fixtures can be
- * seeded into a memory tier alongside file-authored ones.
- */
-function toCachedEntry(fixture: FallbackFixture): unknown {
-	const base: { response: LLMResponse; storedAtNs: number } = {
-		response: fixture.response,
-		// Real timestamp so future TTL-aware tiers don't treat inline fixtures
-		// as Epoch-old and evict them on first pass. Matches the wall-clock
-		// write `withReplayCache` uses for disk-written entries.
-		storedAtNs: wallClockNs(),
-	};
-	if ("key" in fixture && fixture.stream) {
-		const tokenChunks = fixture.stream.chunks.filter(
-			(c): c is Extract<StreamDelta, { type: "token" }> => c.type === "token",
-		);
-		return {
-			...base,
-			streamChunks: tokenChunks.map((c) => ({ delta: c.delta })),
-			streamCadenceMs: fixture.stream.delaysMs ?? tokenChunks.map(() => 0),
-		};
-	}
-	return base;
-}
-
-/**
- * Resolve the fixture source to a `KvStorageTier`. Enforces mutual exclusion
- * between `fixtures` and `fixturesStorage`. When `fixtures` is provided, the
- * seeded memory tier is returned synchronously but keys are populated
- * asynchronously via the returned seeding promise (await before first use).
- */
-function resolveFixtureStorage(
-	opts: FallbackAdapterOptions,
-	keyPrefix: string,
-): { tier: KvStorageTier | undefined; seedReady: Promise<void> } {
-	const sources: string[] = [];
-	if (opts.fixtures != null) sources.push("fixtures");
-	if (opts.fixturesStorage != null) sources.push("fixturesStorage");
-	if (sources.length > 1) {
-		throw new TypeError(
-			`fallbackAdapter: \`fixtures\` and \`fixturesStorage\` are mutually ` +
-				`exclusive; got both ${sources.join(" and ")}. Pick one source. ` +
-				`For filesystem directories use the node subpath's \`fallbackAdapter\`.`,
-		);
-	}
-	if (opts.fixtures) {
-		const tier = memoryKv();
-		const fixtures = opts.fixtures;
-		const seedReady = (async () => {
-			for (const fixture of fixtures) {
-				const key = await fixtureKey(fixture, keyPrefix);
-				await tier.save(key, toCachedEntry(fixture));
-			}
-		})();
-		// Attach a no-op catch so a failure inside the IIFE (e.g. `sha256Hex`
-		// throws because `globalThis.crypto.subtle` is unavailable) does NOT
-		// become an unhandled rejection when the adapter is constructed but
-		// never invoked. V8 records the handler attachment via this branch
-		// of the promise graph, so the Node `unhandledRejection` hook stays
-		// silent — yet subsequent `await seedReady` inside `invoke`/`stream`
-		// still throws the original error for the caller to see.
-		seedReady.catch(() => {});
-		return { tier, seedReady };
-	}
-	if (opts.fixturesStorage) return { tier: opts.fixturesStorage, seedReady: Promise.resolve() };
-	return { tier: undefined, seedReady: Promise.resolve() };
-}
-
-// ---------------------------------------------------------------------------
-// fallbackAdapter
-// ---------------------------------------------------------------------------
-
-/**
- * Build a fixture-backed {@link LLMAdapter}. See module docs for use cases
- * (offline demo, tests, degraded-mode) and recipe snippets.
- */
-export function fallbackAdapter(opts: FallbackAdapterOptions = {}): LLMAdapter {
-	const provider = opts.provider ?? "fallback";
-	const model = opts.model ?? "fallback";
-	const onMiss: FallbackMissPolicy = opts.onMiss ?? "respond";
-	const keyPrefix = opts.keyPrefix ?? "fallback";
-
-	// Pick the inner leaf adapter based on mode.
-	const leaf: LLMAdapter = (() => {
-		if (opts.record) return opts.record.adapter;
-		if (onMiss === "throw") {
-			// `withReplayCache({ mode: "read-strict" })` throws on miss before
-			// ever calling the inner. Supply a no-op to satisfy the type.
-			return dryRunAdapter({
-				provider,
-				model,
-				respond: () => "[unreachable: read-strict mode throws on miss]",
-			});
-		}
-		// Custom leaf (not `dryRunAdapter`) so `metadata.degraded` is preserved
-		// — `dryRunAdapter` returns a string and constructs its own response,
-		// discarding our metadata. For the respond-on-miss path we want full
-		// `LLMResponse` control.
-		return {
-			provider,
-			model,
-			async invoke(messages, invokeOpts): Promise<LLMResponse> {
-				const raw = opts.respond
-					? opts.respond(messages, invokeOpts)
-					: degradedResponse(provider, model);
-				return normalizeRespondResult(raw, provider, model);
-			},
-			async *stream(messages, invokeOpts): AsyncGenerator<StreamDelta> {
-				const raw = opts.respond
-					? opts.respond(messages, invokeOpts)
-					: degradedResponse(provider, model);
-				const r = normalizeRespondResult(raw, provider, model);
-				yield { type: "token", delta: r.content };
-				if (r.usage) yield { type: "usage", usage: r.usage };
-				yield { type: "finish", reason: r.finishReason ?? "stop" };
-			},
-		} satisfies LLMAdapter;
-	})();
-
-	// Resolve the storage tier.
-	// - `record` mode: require `record.storage`.
-	// - Replay-only: `fixtures` seeds an in-memory tier (async) OR
-	//   `fixturesStorage` passes through.
-	let storage: KvStorageTier;
-	let seedReady: Promise<void> = Promise.resolve();
-	if (opts.record) {
-		if (!opts.record.storage) {
-			throw new TypeError(
-				"fallbackAdapter: `record.storage` is required in record mode. For filesystem " +
-					"`record.dir` convenience, use the node subpath's `fallbackAdapter`.",
-			);
-		}
-		storage = opts.record.storage;
-	} else {
-		const resolved = resolveFixtureStorage(opts, keyPrefix);
-		storage = resolved.tier ?? memoryKv();
-		seedReady = resolved.seedReady;
-	}
-
-	const mode = opts.record ? "read-write" : onMiss === "throw" ? "read-strict" : "read";
-
-	const cached = withReplayCache(leaf, {
-		storage,
-		mode,
-		keyPrefix,
-		cacheStreaming: true,
-		captureStreamCadence: true,
-		replaySpeed: opts.replaySpeed,
-		...(opts.keyFn ? { keyFn: opts.keyFn } : {}),
-	});
-
-	// Wrap invoke/stream so the first call awaits the seed-complete Promise.
-	// Adapter construction stays synchronous (`fallbackAdapter(...)` returns
-	// immediately); inline fixture hashing happens lazily on first use.
-	return {
-		provider,
-		model,
-		capabilities: cached.capabilities?.bind(cached),
-		async invoke(messages, invokeOpts): Promise<LLMResponse> {
-			await seedReady;
-			// `cached` came from `withReplayCache`, whose `invoke` always returns
-			// `Promise<LLMResponse>`. The `LLMAdapter` interface types it as the
-			// broader `NodeInput<LLMResponse>` union; narrow here to the actual
-			// shape so the wrapper surface stays `Promise<LLMResponse>`.
-			return cached.invoke(messages, invokeOpts) as Promise<LLMResponse>;
-		},
-		async *stream(messages, invokeOpts): AsyncGenerator<StreamDelta> {
-			await seedReady;
-			for await (const delta of cached.stream(messages, invokeOpts)) yield delta;
-		},
-	};
-}
diff --git a/src/utils/ai/adapters/providers/google.ts b/src/utils/ai/adapters/providers/google.ts
deleted file mode 100644
index 11b031fa..00000000
--- a/src/utils/ai/adapters/providers/google.ts
+++ /dev/null
@@ -1,454 +0,0 @@
-/**
- * GoogleAdapter — default fetch-backed, optional SDK-backed.
- *
- * The SDK-backed path targets the `@google/genai` SDK shape:
- * `client.models.generateContent({ model, contents, config })` — single
- * param, with generation params and `abortSignal` under `config`. The
- * legacy `@google/generative-ai` two-arg `(params, {signal})` shape is no
- * longer accepted; pass a `GoogleGenAI` instance via `opts.sdk`.
- *
- * Maps Gemini `usageMetadata`:
- * - `promptTokenCount` minus `cachedContentTokenCount` → `input.regular`
- * - `cachedContentTokenCount`                          → `input.cacheRead`
- * - `candidatesTokenCount`                             → `output.regular`
- * - `thoughtsTokenCount`                               → `output.reasoning`
- * - `toolUsePromptTokenCount`                          → `input.toolUse`
- * - `promptTokensDetails[]`                            → `input.{image,audio,video}` per modality
- */
-
-import { monotonicNs } from "@graphrefly/pure-ts/core";
-import { makeHttpError } from "../../../../base/io/http-error.js";
-import { parseSSEStream } from "../../../../base/io/sse.js";
-import type {
-	ChatMessage,
-	LLMAdapter,
-	LLMInvokeOptions,
-	LLMResponse,
-	StreamDelta,
-	TokenUsage,
-	ToolDefinition,
-} from "../core/types.js";
-
-export interface GoogleAdapterOptions {
-	/** API key. Falls back to `process.env.GOOGLE_API_KEY` / `GEMINI_API_KEY` on Node. */
-	apiKey?: string;
-	model?: string;
-	baseURL?: string;
-	/** Extra headers on every request. */
-	headers?: Record<string, string>;
-	/**
-	 * Optional `@google/genai` SDK instance (e.g. `new GoogleGenAI({apiKey})`).
-	 * When omitted, the adapter uses the fetch-backed path against the
-	 * Generative Language REST API.
-	 */
-	sdk?: GoogleSdkLike;
-	fetchImpl?: typeof fetch;
-}
-
-/**
- * Duck-type matching the `@google/genai` (`GoogleGenAI`) SDK shape:
- * single-param `generateContent({ model, contents, config })` where
- * generation parameters and `abortSignal` live under `config`.
- *
- * The `@google/generative-ai` predecessor's two-arg `(params, {signal})`
- * shape is no longer accepted.
- */
-export interface GoogleSdkLike {
-	models: {
-		generateContent(params: GoogleSdkRequestParams): Promise<GeminiResponse>;
-		generateContentStream?(
-			params: GoogleSdkRequestParams,
-		): Promise<AsyncIterable<GeminiResponse>> | AsyncIterable<GeminiResponse>;
-	};
-}
-
-/** Single-param request shape consumed by `@google/genai`'s `models.generateContent`. */
-export interface GoogleSdkRequestParams {
-	model: string;
-	contents: unknown;
-	config?: GoogleSdkRequestConfig;
-}
-
-/**
- * Generation config under the new SDK. `abortSignal` is the cancellation
- * channel — there is no second-arg `{signal}`.
- */
-export interface GoogleSdkRequestConfig {
-	abortSignal?: AbortSignal;
-	temperature?: number;
-	maxOutputTokens?: number;
-	systemInstruction?: unknown;
-	tools?: unknown;
-	thinkingConfig?: unknown;
-	[extra: string]: unknown;
-}
-
-interface GeminiResponse {
-	candidates?: ReadonlyArray<{
-		content?: {
-			role?: string;
-			parts?: ReadonlyArray<{
-				text?: string;
-				thought?: boolean;
-				functionCall?: { name: string; args: Record<string, unknown> };
-			}>;
-		};
-		finishReason?: string;
-	}>;
-	usageMetadata?: GeminiUsage;
-	modelVersion?: string;
-}
-
-interface GeminiUsage {
-	promptTokenCount?: number;
-	candidatesTokenCount?: number;
-	totalTokenCount?: number;
-	thoughtsTokenCount?: number;
-	cachedContentTokenCount?: number;
-	toolUsePromptTokenCount?: number;
-	promptTokensDetails?: ReadonlyArray<{ modality: string; tokenCount: number }>;
-	candidatesTokensDetails?: ReadonlyArray<{ modality: string; tokenCount: number }>;
-	cacheTokensDetails?: ReadonlyArray<{ modality: string; tokenCount: number }>;
-}
-
-export function googleAdapter(opts: GoogleAdapterOptions = {}): LLMAdapter {
-	if (opts.sdk) return sdkBackedGoogle(opts);
-	return fetchBackedGoogle(opts);
-}
-
-// ---------------------------------------------------------------------------
-// Mapping
-// ---------------------------------------------------------------------------
-
-function toGeminiRequest(
-	messages: readonly ChatMessage[],
-	invokeOpts: LLMInvokeOptions | undefined,
-): Record<string, unknown> {
-	const systemParts: string[] = [];
-	const contents: Array<{
-		role: string;
-		parts: Array<{ text?: string; functionCall?: unknown; functionResponse?: unknown }>;
-	}> = [];
-	if (invokeOpts?.systemPrompt) systemParts.push(invokeOpts.systemPrompt);
-
-	for (const m of messages) {
-		if (m.role === "system") {
-			systemParts.push(m.content);
-			continue;
-		}
-		if (m.role === "tool") {
-			contents.push({
-				role: "user",
-				parts: [
-					{
-						functionResponse: {
-							name: m.name ?? m.toolCallId ?? "tool",
-							response: { result: m.content },
-						},
-					},
-				],
-			});
-			continue;
-		}
-		if (m.role === "assistant" && m.toolCalls && m.toolCalls.length > 0) {
-			const parts: Array<{ text?: string; functionCall?: unknown }> = [];
-			if (m.content) parts.push({ text: m.content });
-			for (const tc of m.toolCalls) {
-				parts.push({ functionCall: { name: tc.name, args: tc.arguments } });
-			}
-			contents.push({ role: "model", parts });
-			continue;
-		}
-		contents.push({
-			role: m.role === "assistant" ? "model" : "user",
-			parts: [{ text: m.content }],
-		});
-	}
-
-	const body: Record<string, unknown> = { contents };
-	if (systemParts.length > 0) {
-		body.systemInstruction = { role: "system", parts: [{ text: systemParts.join("\n\n") }] };
-	}
-	const genConfig: Record<string, unknown> = {};
-	if (invokeOpts?.maxTokens != null) genConfig.maxOutputTokens = invokeOpts.maxTokens;
-	if (invokeOpts?.temperature != null) genConfig.temperature = invokeOpts.temperature;
-	if (invokeOpts?.maxReasoningTokens != null) {
-		genConfig.thinkingConfig = { thinkingBudget: invokeOpts.maxReasoningTokens };
-	}
-	if (Object.keys(genConfig).length > 0) body.generationConfig = genConfig;
-	if (invokeOpts?.tools && invokeOpts.tools.length > 0) {
-		body.tools = [{ functionDeclarations: invokeOpts.tools.map(toGeminiTool) }];
-	}
-	if (invokeOpts?.providerExtras) Object.assign(body, invokeOpts.providerExtras);
-	return body;
-}
-
-function toGeminiTool(t: ToolDefinition): Record<string, unknown> {
-	return {
-		name: t.name,
-		description: t.description,
-		parameters: t.parameters,
-	};
-}
-
-/**
- * Reshape the fetch-API request body into the SDK's `{ model, contents,
- * config }` form. Generation params (`temperature`, `maxOutputTokens`,
- * `thinkingConfig`) move from `body.generationConfig.*` to `config.*`;
- * `systemInstruction` and `tools` move from top-level body keys into
- * `config`; `abortSignal` is threaded into `config`. `providerExtras` keys
- * spread into `config` so escape-hatch usage remains identical.
- */
-function toSdkParams(
-	body: Record<string, unknown>,
-	model: string,
-	signal: AbortSignal | undefined,
-): GoogleSdkRequestParams {
-	const config: GoogleSdkRequestConfig = {};
-	const gen = body.generationConfig as Record<string, unknown> | undefined;
-	if (gen) {
-		if (typeof gen.maxOutputTokens === "number") config.maxOutputTokens = gen.maxOutputTokens;
-		if (typeof gen.temperature === "number") config.temperature = gen.temperature;
-		if (gen.thinkingConfig) config.thinkingConfig = gen.thinkingConfig;
-	}
-	if (body.systemInstruction) config.systemInstruction = body.systemInstruction;
-	if (body.tools) config.tools = body.tools;
-	for (const [k, v] of Object.entries(body)) {
-		if (
-			k === "contents" ||
-			k === "generationConfig" ||
-			k === "systemInstruction" ||
-			k === "tools" ||
-			// Skip `abortSignal` so a caller-supplied entry in `providerExtras`
-			// can't briefly land in `config.abortSignal` before being
-			// overwritten — the canonical signal channel is the second
-			// `signal` argument (set on `config.abortSignal` below).
-			k === "abortSignal" ||
-			// Skip `model` so a stray `body.model` (not produced by
-			// `toGeminiRequest` today, but defensively guarded) doesn't
-			// duplicate the top-level `model` field on the SDK request.
-			k === "model"
-		) {
-			continue;
-		}
-		config[k] = v;
-	}
-	if (signal) config.abortSignal = signal;
-	return {
-		model,
-		contents: body.contents,
-		config: Object.keys(config).length > 0 ? config : undefined,
-	};
-}
-
-function mapUsage(u: GeminiUsage | undefined): TokenUsage {
-	const usage: TokenUsage = {
-		input: { regular: 0 },
-		output: { regular: 0 },
-		raw: u,
-	};
-	if (!u) return usage;
-	const promptTotal = u.promptTokenCount ?? 0;
-	const cached = u.cachedContentTokenCount ?? 0;
-	usage.input.regular = Math.max(0, promptTotal - cached);
-	if (cached > 0) usage.input.cacheRead = cached;
-	if (u.toolUsePromptTokenCount) usage.input.toolUse = u.toolUsePromptTokenCount;
-	if (u.promptTokensDetails) {
-		for (const d of u.promptTokensDetails) {
-			const modality = d.modality?.toLowerCase();
-			if (modality === "image") usage.input.image = (usage.input.image ?? 0) + d.tokenCount;
-			else if (modality === "audio") usage.input.audio = (usage.input.audio ?? 0) + d.tokenCount;
-			else if (modality === "video") usage.input.video = (usage.input.video ?? 0) + d.tokenCount;
-		}
-	}
-	usage.output.regular = u.candidatesTokenCount ?? 0;
-	if (u.thoughtsTokenCount) usage.output.reasoning = u.thoughtsTokenCount;
-	return usage;
-}
-
-function toLLMResponse(json: GeminiResponse, latencyMs: number): LLMResponse {
-	const cand = json.candidates?.[0];
-	const parts = cand?.content?.parts ?? [];
-	const textParts: string[] = [];
-	const toolCalls: { id: string; name: string; arguments: Record<string, unknown> }[] = [];
-	let i = 0;
-	for (const p of parts) {
-		if (typeof p.text === "string") textParts.push(p.text);
-		if (p.functionCall) {
-			toolCalls.push({
-				id: `${p.functionCall.name}-${i++}`,
-				name: p.functionCall.name,
-				arguments: p.functionCall.args ?? {},
-			});
-		}
-	}
-	return {
-		content: textParts.join(""),
-		toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
-		usage: mapUsage(json.usageMetadata),
-		finishReason: cand?.finishReason,
-		latencyMs,
-		model: json.modelVersion,
-		provider: "google",
-	};
-}
-
-// ---------------------------------------------------------------------------
-// Fetch-backed
-// ---------------------------------------------------------------------------
-
-function resolveApiKey(opts: GoogleAdapterOptions): string | undefined {
-	if (opts.apiKey) return opts.apiKey;
-	const env = (globalThis as { process?: { env?: Record<string, string> } }).process?.env;
-	return env?.GOOGLE_API_KEY ?? env?.GEMINI_API_KEY;
-}
-
-function fetchBackedGoogle(opts: GoogleAdapterOptions): LLMAdapter {
-	const baseURL = opts.baseURL ?? "https://generativelanguage.googleapis.com/v1beta";
-	const fetchImpl = opts.fetchImpl ?? fetch;
-
-	const pickModel = (invokeOpts: LLMInvokeOptions | undefined): string => {
-		const model = invokeOpts?.model ?? opts.model;
-		if (!model)
-			throw new Error("googleAdapter: model must be set via options.model or invokeOpts.model");
-		return model;
-	};
-
-	const keyParam = (): string => {
-		const key = resolveApiKey(opts);
-		if (!key) throw new Error("googleAdapter: apiKey required for invoke/stream");
-		return `key=${encodeURIComponent(key)}`;
-	};
-
-	return {
-		provider: "google",
-		model: opts.model,
-
-		async invoke(messages, invokeOpts): Promise<LLMResponse> {
-			const model = pickModel(invokeOpts);
-			const body = toGeminiRequest(messages, invokeOpts);
-			const start = monotonicNs();
-			const url = `${baseURL}/models/${encodeURIComponent(model)}:generateContent?${keyParam()}`;
-			const resp = await fetchImpl(url, {
-				method: "POST",
-				headers: { "content-type": "application/json", ...(opts.headers ?? {}) },
-				body: JSON.stringify(body),
-				signal: invokeOpts?.signal,
-			});
-			if (!resp.ok) throw await makeHttpError(resp, "Google");
-			const json = (await resp.json()) as GeminiResponse;
-			const latencyMs = Math.max(0, (monotonicNs() - start) / 1e6);
-			return toLLMResponse(json, latencyMs);
-		},
-
-		async *stream(messages, invokeOpts): AsyncGenerator<StreamDelta> {
-			const model = pickModel(invokeOpts);
-			const body = toGeminiRequest(messages, invokeOpts);
-			const url = `${baseURL}/models/${encodeURIComponent(model)}:streamGenerateContent?alt=sse&${keyParam()}`;
-			const resp = await fetchImpl(url, {
-				method: "POST",
-				headers: {
-					"content-type": "application/json",
-					accept: "text/event-stream",
-					...(opts.headers ?? {}),
-				},
-				body: JSON.stringify(body),
-				signal: invokeOpts?.signal,
-			});
-			if (!resp.ok) throw await makeHttpError(resp, "Google");
-			if (!resp.body) throw new Error("googleAdapter: streaming response has no body");
-
-			let finalUsage: GeminiUsage | undefined;
-			let finishReason: string | undefined;
-
-			for await (const event of parseSSEStream(resp.body, { signal: invokeOpts?.signal })) {
-				if (!event.data) continue;
-				let parsed: GeminiResponse;
-				try {
-					parsed = JSON.parse(event.data) as GeminiResponse;
-				} catch {
-					continue;
-				}
-				const cand = parsed.candidates?.[0];
-				for (const p of cand?.content?.parts ?? []) {
-					if (typeof p.text === "string") {
-						if (p.thought) yield { type: "thinking", delta: p.text };
-						else yield { type: "token", delta: p.text };
-					}
-					if (p.functionCall) {
-						yield {
-							type: "tool-call-delta",
-							delta: {
-								name: p.functionCall.name,
-								argumentsDelta: JSON.stringify(p.functionCall.args ?? {}),
-							},
-						};
-					}
-				}
-				if (cand?.finishReason) finishReason = cand.finishReason;
-				if (parsed.usageMetadata) finalUsage = parsed.usageMetadata;
-			}
-			if (finalUsage) yield { type: "usage", usage: mapUsage(finalUsage) };
-			yield { type: "finish", reason: finishReason ?? "stop" };
-		},
-	};
-}
-
-function sdkBackedGoogle(opts: GoogleAdapterOptions): LLMAdapter {
-	const sdk = opts.sdk;
-	if (!sdk) throw new Error("sdkBackedGoogle: sdk instance required");
-
-	return {
-		provider: "google",
-		model: opts.model,
-
-		async invoke(messages, invokeOpts): Promise<LLMResponse> {
-			const body = toGeminiRequest(messages, invokeOpts);
-			const model = invokeOpts?.model ?? opts.model;
-			if (!model) throw new Error("googleAdapter: model required");
-			const params = toSdkParams(body, model, invokeOpts?.signal);
-			const start = monotonicNs();
-			const resp = await sdk.models.generateContent(params);
-			const latencyMs = Math.max(0, (monotonicNs() - start) / 1e6);
-			return toLLMResponse(resp, latencyMs);
-		},
-
-		async *stream(messages, invokeOpts): AsyncGenerator<StreamDelta> {
-			if (!sdk.models.generateContentStream) {
-				throw new Error("sdkBackedGoogle: SDK instance does not expose generateContentStream");
-			}
-			const body = toGeminiRequest(messages, invokeOpts);
-			const model = invokeOpts?.model ?? opts.model;
-			if (!model) throw new Error("googleAdapter: model required");
-			const params = toSdkParams(body, model, invokeOpts?.signal);
-			let finalUsage: GeminiUsage | undefined;
-			let finishReason: string | undefined;
-			// `@google/genai` returns `Promise<AsyncIterable<...>>`; older shapes
-			// returned the iterable directly. Awaiting a non-thenable resolves
-			// to itself, so this works for both.
-			const stream = await sdk.models.generateContentStream(params);
-			for await (const chunk of stream) {
-				const cand = chunk.candidates?.[0];
-				for (const p of cand?.content?.parts ?? []) {
-					if (typeof p.text === "string") {
-						if (p.thought) yield { type: "thinking", delta: p.text };
-						else yield { type: "token", delta: p.text };
-					}
-					if (p.functionCall) {
-						yield {
-							type: "tool-call-delta",
-							delta: {
-								name: p.functionCall.name,
-								argumentsDelta: JSON.stringify(p.functionCall.args ?? {}),
-							},
-						};
-					}
-				}
-				if (cand?.finishReason) finishReason = cand.finishReason;
-				if (chunk.usageMetadata) finalUsage = chunk.usageMetadata;
-			}
-			if (finalUsage) yield { type: "usage", usage: mapUsage(finalUsage) };
-			yield { type: "finish", reason: finishReason ?? "stop" };
-		},
-	};
-}
diff --git a/src/utils/ai/adapters/providers/index.ts b/src/utils/ai/adapters/providers/index.ts
deleted file mode 100644
index 8112f342..00000000
--- a/src/utils/ai/adapters/providers/index.ts
+++ /dev/null
@@ -1,7 +0,0 @@
-export * from "./anthropic.js";
-export * from "./dry-run.js";
-export * from "./fallback.js";
-export * from "./google.js";
-export * from "./openai-compat.js";
-// Browser adapters re-exported under a subpath to keep Node-only bundles lean:
-//   import { webllmAdapter } from "@graphrefly/graphrefly/utils/ai/browser";
diff --git a/src/utils/ai/adapters/providers/openai-compat.ts b/src/utils/ai/adapters/providers/openai-compat.ts
deleted file mode 100644
index 6259f10f..00000000
--- a/src/utils/ai/adapters/providers/openai-compat.ts
+++ /dev/null
@@ -1,472 +0,0 @@
-/**
- * OpenAICompatAdapter — default fetch-backed, optional SDK-backed.
- *
- * Covers any provider that speaks OpenAI chat/completions. Preset base URLs
- * for OpenAI, OpenRouter, Groq, Ollama, DeepSeek, xAI Grok (all expose the
- * same `/v1/chat/completions` shape).
- *
- * Token usage mapping:
- * - `prompt_tokens`                                     → `input.regular` (minus cached_tokens)
- * - `prompt_tokens_details.cached_tokens`               → `input.cacheRead`
- * - `prompt_tokens_details.audio_tokens`                → `input.audio`
- * - `completion_tokens`                                 → `output.regular` (minus reasoning)
- * - `completion_tokens_details.reasoning_tokens`        → `output.reasoning`
- * - `completion_tokens_details.audio_tokens`            → `output.audio`
- * - `completion_tokens_details.accepted_prediction_tokens` → `output.predictionAccepted`
- * - `completion_tokens_details.rejected_prediction_tokens` → `output.predictionRejected`
- *
- * DeepSeek compatibility: `prompt_cache_hit_tokens` / `prompt_cache_miss_tokens`
- * are surfaced in the `raw` field of `TokenUsage`; when present we prefer
- * them over the OpenAI-style `cached_tokens` for cache-read attribution.
- */
-
-import { monotonicNs } from "@graphrefly/pure-ts/core";
-import { makeHttpError } from "../../../../base/io/http-error.js";
-import { parseSSEStream } from "../../../../base/io/sse.js";
-import type {
-	ChatMessage,
-	LLMAdapter,
-	LLMInvokeOptions,
-	LLMResponse,
-	StreamDelta,
-	TokenUsage,
-	ToolDefinition,
-} from "../core/types.js";
-
-// ---------------------------------------------------------------------------
-// Options
-// ---------------------------------------------------------------------------
-
-export type OpenAICompatPreset = "openai" | "openrouter" | "groq" | "ollama" | "deepseek" | "xai";
-
-const PRESETS: Record<
-	OpenAICompatPreset,
-	{ baseURL: string; apiKeyEnv?: string; provider: string }
-> = {
-	openai: { baseURL: "https://api.openai.com/v1", apiKeyEnv: "OPENAI_API_KEY", provider: "openai" },
-	openrouter: {
-		baseURL: "https://openrouter.ai/api/v1",
-		apiKeyEnv: "OPENROUTER_API_KEY",
-		provider: "openrouter",
-	},
-	groq: { baseURL: "https://api.groq.com/openai/v1", apiKeyEnv: "GROQ_API_KEY", provider: "groq" },
-	ollama: { baseURL: "http://localhost:11434/v1", provider: "ollama" },
-	deepseek: {
-		baseURL: "https://api.deepseek.com/v1",
-		apiKeyEnv: "DEEPSEEK_API_KEY",
-		provider: "deepseek",
-	},
-	xai: { baseURL: "https://api.x.ai/v1", apiKeyEnv: "XAI_API_KEY", provider: "xai" },
-};
-
-export interface OpenAICompatAdapterOptions {
-	preset?: OpenAICompatPreset;
-	/** Explicit provider label (defaults to preset's provider). */
-	provider?: string;
-	/** API key. Falls back to the preset's default env var on Node. */
-	apiKey?: string;
-	model?: string;
-	/** Override base URL (wins over `preset`). */
-	baseURL?: string;
-	/** Extra request headers. */
-	headers?: Record<string, string>;
-	/** Extra request-body fields merged on every request (OpenRouter routing etc.). */
-	bodyExtras?: Record<string, unknown>;
-	/** User-provided SDK instance (OpenAI-family shape). */
-	sdk?: OpenAISdkLike;
-	/** Custom fetch (for tests). */
-	fetchImpl?: typeof fetch;
-}
-
-export interface OpenAISdkLike {
-	chat: {
-		completions: {
-			create(
-				params: Record<string, unknown>,
-				opts?: { signal?: AbortSignal },
-			): Promise<OpenAIChatResponse>;
-		};
-	};
-}
-
-interface OpenAIChatResponse {
-	id: string;
-	choices: ReadonlyArray<{
-		message: {
-			role: string;
-			content?: string | null;
-			tool_calls?: ReadonlyArray<{
-				id: string;
-				type: "function";
-				function: { name: string; arguments: string };
-			}>;
-			reasoning_content?: string;
-		};
-		finish_reason?: string;
-	}>;
-	usage?: OpenAIUsage;
-	model?: string;
-}
-
-interface OpenAIUsage {
-	prompt_tokens?: number;
-	completion_tokens?: number;
-	total_tokens?: number;
-	prompt_tokens_details?: {
-		cached_tokens?: number;
-		audio_tokens?: number;
-	};
-	completion_tokens_details?: {
-		reasoning_tokens?: number;
-		audio_tokens?: number;
-		accepted_prediction_tokens?: number;
-		rejected_prediction_tokens?: number;
-	};
-	// DeepSeek
-	prompt_cache_hit_tokens?: number;
-	prompt_cache_miss_tokens?: number;
-}
-
-// ---------------------------------------------------------------------------
-// Factory
-// ---------------------------------------------------------------------------
-
-export function openAICompatAdapter(opts: OpenAICompatAdapterOptions = {}): LLMAdapter {
-	if (opts.sdk) return sdkBackedOpenAI(opts);
-	return fetchBackedOpenAI(opts);
-}
-
-// ---------------------------------------------------------------------------
-// Mapping
-// ---------------------------------------------------------------------------
-
-function toOpenAIRequest(
-	messages: readonly ChatMessage[],
-	invokeOpts: LLMInvokeOptions | undefined,
-	defaultModel: string | undefined,
-	stream: boolean,
-	bodyExtras: Record<string, unknown> | undefined,
-): Record<string, unknown> {
-	const model = invokeOpts?.model ?? defaultModel;
-	if (!model)
-		throw new Error("openAICompatAdapter: model must be set via options.model or invokeOpts.model");
-	const mapped = messages.map(toOpenAIMessage);
-	if (invokeOpts?.systemPrompt && !messages.some((m) => m.role === "system")) {
-		mapped.unshift({ role: "system", content: invokeOpts.systemPrompt });
-	}
-	const body: Record<string, unknown> = { model, messages: mapped };
-	if (invokeOpts?.maxTokens != null) body.max_tokens = invokeOpts.maxTokens;
-	if (invokeOpts?.temperature != null) body.temperature = invokeOpts.temperature;
-	if (invokeOpts?.tools && invokeOpts.tools.length > 0) {
-		body.tools = invokeOpts.tools.map(toOpenAITool);
-	}
-	if (invokeOpts?.maxReasoningTokens != null) {
-		body.reasoning = { max_tokens: invokeOpts.maxReasoningTokens };
-	}
-	if (stream) {
-		body.stream = true;
-		body.stream_options = { include_usage: true };
-	}
-	if (bodyExtras) Object.assign(body, bodyExtras);
-	if (invokeOpts?.providerExtras) Object.assign(body, invokeOpts.providerExtras);
-	return body;
-}
-
-function toOpenAIMessage(m: ChatMessage): Record<string, unknown> {
-	if (m.role === "tool") {
-		return { role: "tool", tool_call_id: m.toolCallId, content: m.content };
-	}
-	if (m.role === "assistant" && m.toolCalls && m.toolCalls.length > 0) {
-		return {
-			role: "assistant",
-			content: m.content || null,
-			tool_calls: m.toolCalls.map((tc) => ({
-				id: tc.id,
-				type: "function",
-				function: { name: tc.name, arguments: JSON.stringify(tc.arguments) },
-			})),
-		};
-	}
-	return { role: m.role, content: m.content };
-}
-
-function toOpenAITool(t: ToolDefinition): Record<string, unknown> {
-	return {
-		type: "function",
-		function: {
-			name: t.name,
-			description: t.description,
-			parameters: t.parameters,
-		},
-	};
-}
-
-function mapUsage(u: OpenAIUsage | undefined): TokenUsage {
-	const usage: TokenUsage = {
-		input: { regular: 0 },
-		output: { regular: 0 },
-		raw: u,
-	};
-	if (!u) return usage;
-	const inputTotal = u.prompt_tokens ?? 0;
-	let cacheRead = u.prompt_tokens_details?.cached_tokens ?? 0;
-	if (u.prompt_cache_hit_tokens != null) {
-		// DeepSeek: prefer explicit hit/miss split when present
-		cacheRead = u.prompt_cache_hit_tokens;
-		usage.input.regular = u.prompt_cache_miss_tokens ?? Math.max(0, inputTotal - cacheRead);
-	} else {
-		usage.input.regular = Math.max(0, inputTotal - cacheRead);
-	}
-	if (cacheRead > 0) usage.input.cacheRead = cacheRead;
-	if (u.prompt_tokens_details?.audio_tokens)
-		usage.input.audio = u.prompt_tokens_details.audio_tokens;
-
-	const outputTotal = u.completion_tokens ?? 0;
-	const reasoning = u.completion_tokens_details?.reasoning_tokens ?? 0;
-	usage.output.regular = Math.max(0, outputTotal - reasoning);
-	if (reasoning > 0) usage.output.reasoning = reasoning;
-	if (u.completion_tokens_details?.audio_tokens)
-		usage.output.audio = u.completion_tokens_details.audio_tokens;
-	if (u.completion_tokens_details?.accepted_prediction_tokens) {
-		usage.output.predictionAccepted = u.completion_tokens_details.accepted_prediction_tokens;
-	}
-	if (u.completion_tokens_details?.rejected_prediction_tokens) {
-		usage.output.predictionRejected = u.completion_tokens_details.rejected_prediction_tokens;
-	}
-	return usage;
-}
-
-function toLLMResponse(json: OpenAIChatResponse, latencyMs: number, provider: string): LLMResponse {
-	const choice = json.choices[0];
-	const msg = choice?.message;
-	const content = msg?.content ?? "";
-	const toolCalls = (msg?.tool_calls ?? []).map((tc) => ({
-		id: tc.id,
-		name: tc.function.name,
-		arguments: safeJsonParse(tc.function.arguments),
-	}));
-	return {
-		content,
-		toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
-		usage: mapUsage(json.usage),
-		finishReason: choice?.finish_reason,
-		latencyMs,
-		model: json.model,
-		provider,
-	};
-}
-
-function safeJsonParse(s: string): Record<string, unknown> {
-	try {
-		const parsed = JSON.parse(s);
-		return typeof parsed === "object" && parsed != null
-			? (parsed as Record<string, unknown>)
-			: { _raw: s };
-	} catch {
-		return { _raw: s };
-	}
-}
-
-// ---------------------------------------------------------------------------
-// Fetch-backed
-// ---------------------------------------------------------------------------
-
-function resolveConfig(opts: OpenAICompatAdapterOptions): {
-	provider: string;
-	baseURL: string;
-	apiKey: string | undefined;
-} {
-	const preset = opts.preset ?? "openai";
-	const base = PRESETS[preset];
-	const baseURL = opts.baseURL ?? base.baseURL;
-	const provider = opts.provider ?? base.provider;
-	const envKey = base.apiKeyEnv;
-	const apiKey =
-		opts.apiKey ??
-		(envKey
-			? (globalThis as { process?: { env?: Record<string, string> } }).process?.env?.[envKey]
-			: undefined);
-	return { provider, baseURL, apiKey };
-}
-
-function fetchBackedOpenAI(opts: OpenAICompatAdapterOptions): LLMAdapter {
-	const { provider, baseURL, apiKey } = resolveConfig(opts);
-	const fetchImpl = opts.fetchImpl ?? fetch;
-	const needsKey = provider !== "ollama"; // Ollama local default: no key required.
-
-	const commonHeaders = (): Record<string, string> => {
-		const h: Record<string, string> = {
-			"content-type": "application/json",
-			...(opts.headers ?? {}),
-		};
-		if (needsKey) {
-			if (!apiKey)
-				throw new Error(`openAICompatAdapter[${provider}]: apiKey required for invoke/stream`);
-			h.authorization = `Bearer ${apiKey}`;
-		}
-		return h;
-	};
-
-	return {
-		provider,
-		model: opts.model,
-
-		async invoke(messages, invokeOpts): Promise<LLMResponse> {
-			const body = toOpenAIRequest(messages, invokeOpts, opts.model, false, opts.bodyExtras);
-			const start = monotonicNs();
-			const resp = await fetchImpl(`${baseURL}/chat/completions`, {
-				method: "POST",
-				headers: commonHeaders(),
-				body: JSON.stringify(body),
-				signal: invokeOpts?.signal,
-			});
-			if (!resp.ok) throw await makeHttpError(resp, provider);
-			const json = (await resp.json()) as OpenAIChatResponse;
-			const latencyMs = Math.max(0, (monotonicNs() - start) / 1e6);
-			return toLLMResponse(json, latencyMs, provider);
-		},
-
-		async *stream(messages, invokeOpts): AsyncGenerator<StreamDelta> {
-			const body = toOpenAIRequest(messages, invokeOpts, opts.model, true, opts.bodyExtras);
-			const resp = await fetchImpl(`${baseURL}/chat/completions`, {
-				method: "POST",
-				headers: { ...commonHeaders(), accept: "text/event-stream" },
-				body: JSON.stringify(body),
-				signal: invokeOpts?.signal,
-			});
-			if (!resp.ok) throw await makeHttpError(resp, provider);
-			if (!resp.body)
-				throw new Error(`openAICompatAdapter[${provider}]: streaming response has no body`);
-
-			let finalUsage: OpenAIUsage | undefined;
-			let finishReason: string | undefined;
-
-			for await (const event of parseSSEStream(resp.body, { signal: invokeOpts?.signal })) {
-				if (!event.data || event.data === "[DONE]") continue;
-				let parsed: Record<string, unknown>;
-				try {
-					parsed = JSON.parse(event.data) as Record<string, unknown>;
-				} catch {
-					continue;
-				}
-				// Streaming shape: choices[0].delta.{content?, tool_calls?, reasoning_content?}
-				const choices = parsed.choices as
-					| ReadonlyArray<{
-							delta?: {
-								content?: string;
-								tool_calls?: ReadonlyArray<{
-									index: number;
-									id?: string;
-									function?: { name?: string; arguments?: string };
-								}>;
-								reasoning_content?: string;
-							};
-							finish_reason?: string;
-					  }>
-					| undefined;
-				if (choices) {
-					const c = choices[0];
-					if (c?.delta?.content) yield { type: "token", delta: c.delta.content };
-					if (c?.delta?.reasoning_content) {
-						yield { type: "thinking", delta: c.delta.reasoning_content };
-					}
-					if (c?.delta?.tool_calls) {
-						for (const tc of c.delta.tool_calls) {
-							yield {
-								type: "tool-call-delta",
-								delta: {
-									id: tc.id,
-									name: tc.function?.name,
-									argumentsDelta: tc.function?.arguments,
-								},
-							};
-						}
-					}
-					if (c?.finish_reason) finishReason = c.finish_reason;
-				}
-				// Yield every usage delta the provider emits (Anthropic, Groq, and
-				// some OpenAI-compat providers can emit mid-stream usage). Downstream
-				// consumers treat the most-recent delta as authoritative. See D5b in
-				// adapter QA session.
-				if (parsed.usage) {
-					finalUsage = parsed.usage as OpenAIUsage;
-					yield { type: "usage", usage: mapUsage(finalUsage) };
-				}
-			}
-			yield { type: "finish", reason: finishReason ?? "stop" };
-		},
-	};
-}
-
-function sdkBackedOpenAI(opts: OpenAICompatAdapterOptions): LLMAdapter {
-	const sdk = opts.sdk;
-	if (!sdk) throw new Error("sdkBackedOpenAI: sdk instance required");
-	const { provider } = resolveConfig(opts);
-	return {
-		provider,
-		model: opts.model,
-
-		async invoke(messages, invokeOpts): Promise<LLMResponse> {
-			const body = toOpenAIRequest(messages, invokeOpts, opts.model, false, opts.bodyExtras);
-			const start = monotonicNs();
-			const resp = await sdk.chat.completions.create(body, { signal: invokeOpts?.signal });
-			const latencyMs = Math.max(0, (monotonicNs() - start) / 1e6);
-			return toLLMResponse(resp, latencyMs, provider);
-		},
-
-		async *stream(messages, invokeOpts): AsyncGenerator<StreamDelta> {
-			const body = toOpenAIRequest(messages, invokeOpts, opts.model, true, opts.bodyExtras);
-			const stream = (await sdk.chat.completions.create(body, {
-				signal: invokeOpts?.signal,
-			})) as unknown as AsyncIterable<Record<string, unknown>>;
-			let finalUsage: OpenAIUsage | undefined;
-			let finishReason: string | undefined;
-			for await (const chunk of stream) {
-				const choices = (
-					chunk as {
-						choices?: ReadonlyArray<{
-							delta?: {
-								content?: string;
-								tool_calls?: ReadonlyArray<{
-									id?: string;
-									function?: { name?: string; arguments?: string };
-								}>;
-								reasoning_content?: string;
-							};
-							finish_reason?: string;
-						}>;
-					}
-				).choices;
-				if (choices) {
-					const c = choices[0];
-					if (c?.delta?.content) yield { type: "token", delta: c.delta.content };
-					if (c?.delta?.reasoning_content)
-						yield { type: "thinking", delta: c.delta.reasoning_content };
-					if (c?.delta?.tool_calls) {
-						for (const tc of c.delta.tool_calls) {
-							yield {
-								type: "tool-call-delta",
-								delta: {
-									id: tc.id,
-									name: tc.function?.name,
-									argumentsDelta: tc.function?.arguments,
-								},
-							};
-						}
-					}
-					if (c?.finish_reason) finishReason = c.finish_reason;
-				}
-				const u = (chunk as { usage?: OpenAIUsage }).usage;
-				if (u) {
-					finalUsage = u;
-					yield { type: "usage", usage: mapUsage(u) };
-				}
-			}
-			if (!finalUsage) {
-				// No usage emitted — yield nothing; downstream consumers default
-				// to empty usage via their own fallback.
-			}
-			yield { type: "finish", reason: finishReason ?? "stop" };
-		},
-	};
-}
diff --git a/src/utils/ai/adapters/routing/browser-presets.ts b/src/utils/ai/adapters/routing/browser-presets.ts
deleted file mode 100644
index 6aa00b3e..00000000
--- a/src/utils/ai/adapters/routing/browser-presets.ts
+++ /dev/null
@@ -1,113 +0,0 @@
-/**
- * Curated `cascadingLlmAdapter` presets that depend on browser-only adapters
- * (`webllmAdapter`, `chromeNanoAdapter`).
- *
- * Split out from `routing/presets.ts` so that importing `utils/ai` in a
- * Node bundle doesn't transitively pull in `@mlc-ai/web-llm` / Chrome Nano
- * dynamic imports, and so browser-only consumers can opt in cleanly via
- * the `@graphrefly/graphrefly/utils/ai/browser` subpath.
- *
- * @module
- */
-
-import { createAdapter } from "../core/factory.js";
-import type { LLMAdapter } from "../core/types.js";
-import { chromeNanoAdapter } from "../providers/browser/chrome-nano.js";
-import { webllmAdapter } from "../providers/browser/webllm.js";
-import { type CascadingLlmAdapterOptions, cascadingLlmAdapter } from "./cascading.js";
-
-// ---------------------------------------------------------------------------
-// Cloud-first: BYOK → WebLLM → Chrome Nano
-// ---------------------------------------------------------------------------
-
-export interface CloudFirstPresetOptions {
-	/** BYOK config — passed directly to `createAdapter`. */
-	cloud: Parameters<typeof createAdapter>[0];
-	/** WebLLM model name. Pass `null` to skip the WebLLM tier. */
-	webllmModel?: string | null;
-	/** Pass `null` to skip the Chrome Nano tier. */
-	chromeNano?: boolean;
-	/** Cascade options. */
-	cascade?: CascadingLlmAdapterOptions;
-}
-
-/**
- * Cloud-first with local fallback: BYOK → WebLLM → Chrome Nano.
- */
-export function cloudFirstPreset(opts: CloudFirstPresetOptions): LLMAdapter {
-	const tiers = [{ name: "cloud", adapter: createAdapter(opts.cloud) }];
-	if (opts.webllmModel) {
-		tiers.push({ name: "webllm", adapter: webllmAdapter({ model: opts.webllmModel }) });
-	}
-	if (opts.chromeNano !== false) {
-		tiers.push({
-			name: "chrome-nano",
-			adapter: chromeNanoAdapter(),
-			filter: (_msgs, iOpts) => !iOpts?.tools || iOpts.tools.length === 0,
-		} as Parameters<typeof cascadingLlmAdapter>[0][number]);
-	}
-	return cascadingLlmAdapter(tiers, opts.cascade);
-}
-
-// ---------------------------------------------------------------------------
-// Local-first: Ollama → WebLLM → Chrome Nano
-// ---------------------------------------------------------------------------
-
-export interface LocalFirstPresetOptions {
-	/** Ollama model. */
-	ollamaModel: string;
-	/** Ollama base URL. Default http://localhost:11434/v1. */
-	ollamaBaseURL?: string;
-	webllmModel?: string | null;
-	chromeNano?: boolean;
-	cascade?: CascadingLlmAdapterOptions;
-}
-
-/**
- * Local-first: nothing leaves the machine. Ollama → WebLLM → Chrome Nano.
- */
-export function localFirstPreset(opts: LocalFirstPresetOptions): LLMAdapter {
-	const tiers = [
-		{
-			name: "ollama",
-			adapter: createAdapter({
-				provider: "ollama",
-				model: opts.ollamaModel,
-				baseURL: opts.ollamaBaseURL,
-			}),
-		},
-	];
-	if (opts.webllmModel) {
-		tiers.push({ name: "webllm", adapter: webllmAdapter({ model: opts.webllmModel }) });
-	}
-	if (opts.chromeNano !== false) {
-		tiers.push({
-			name: "chrome-nano",
-			adapter: chromeNanoAdapter(),
-			filter: (_msgs, iOpts) => !iOpts?.tools || iOpts.tools.length === 0,
-		} as Parameters<typeof cascadingLlmAdapter>[0][number]);
-	}
-	return cascadingLlmAdapter(tiers, opts.cascade);
-}
-
-// ---------------------------------------------------------------------------
-// Offline: WebLLM → Chrome Nano (no network)
-// ---------------------------------------------------------------------------
-
-export interface OfflinePresetOptions {
-	webllmModel: string;
-	chromeNano?: boolean;
-	cascade?: CascadingLlmAdapterOptions;
-}
-
-export function offlinePreset(opts: OfflinePresetOptions): LLMAdapter {
-	const tiers = [{ name: "webllm", adapter: webllmAdapter({ model: opts.webllmModel }) }];
-	if (opts.chromeNano !== false) {
-		tiers.push({
-			name: "chrome-nano",
-			adapter: chromeNanoAdapter(),
-			filter: (_msgs, iOpts) => !iOpts?.tools || iOpts.tools.length === 0,
-		} as Parameters<typeof cascadingLlmAdapter>[0][number]);
-	}
-	return cascadingLlmAdapter(tiers, opts.cascade);
-}
diff --git a/src/utils/ai/adapters/routing/cascading.ts b/src/utils/ai/adapters/routing/cascading.ts
deleted file mode 100644
index 3da98f67..00000000
--- a/src/utils/ai/adapters/routing/cascading.ts
+++ /dev/null
@@ -1,210 +0,0 @@
-/**
- * `cascadingLlmAdapter` — N-tier fallback over any mix of LLM adapters.
- *
- * Same structural pattern as `cascadingCache` and `Graph.attachSnapshotStorage`:
- * ordered list, first-success wins, per-tier breaker optional, filter gates
- * per request. Semantics:
- *
- * - `invoke()`: try tier 0 first. On error (or breaker-open), fall through
- *   to tier 1, 2, ... until one succeeds or all fail.
- * - `stream()`: tries to start the stream on tier 0; once tokens begin, it
- *   commits — failures in mid-stream surface rather than re-starting on the
- *   next tier (would double-bill and confuse consumers). **State-machine
- *   consumers (usage accounting, UI accumulators) must handle errors in a
- *   catch block — no synthetic `{type: "finish"}` is emitted after a thrown
- *   stream error.**
- * - `filter`: skips a tier for requests that use features it doesn't
- *   support (e.g., Chrome Nano can't do tool use).
- * - `breaker`: per-tier circuit; when open, cascade treats the tier as
- *   unavailable and moves on immediately.
- *
- * On exhaustion, throws `AllTiersExhaustedError` with separate `skipped` and
- * `failed` collections so consumers can distinguish "no tier applicable"
- * from "all tiers failed".
- */
-
-import { fromAny } from "@graphrefly/pure-ts/extra";
-import { firstValueFrom } from "../../../../base/sources/settled.js";
-import {
-	type CircuitBreaker,
-	type CircuitBreakerOptions,
-	circuitBreaker,
-} from "../../../../utils/resilience/index.js";
-import { withLayer } from "../_internal/wrappers.js";
-import type {
-	ChatMessage,
-	LLMAdapter,
-	LLMInvokeOptions,
-	LLMResponse,
-	StreamDelta,
-} from "../core/types.js";
-
-export interface AdapterTier {
-	name: string;
-	adapter: LLMAdapter;
-	/** Per-tier circuit breaker. If omitted, no breaker on this tier. */
-	breaker?: CircuitBreakerOptions | CircuitBreaker;
-	/** Skip this tier when the request doesn't fit (e.g. Chrome Nano + tools). */
-	filter?: (messages: readonly ChatMessage[], opts?: LLMInvokeOptions) => boolean;
-}
-
-export interface CascadeExhaustionReport {
-	/** Tiers that never ran (filter returned false, or breaker was open). */
-	readonly skipped: ReadonlyArray<{ name: string; reason: "filter" | "breaker" }>;
-	/** Tiers that ran and threw. */
-	readonly failed: ReadonlyMap<string, unknown>;
-}
-
-export interface CascadingLlmAdapterOptions {
-	onFallback?: (from: string, to: string, error: unknown) => void;
-	onExhausted?: (report: CascadeExhaustionReport) => void;
-	/** Whether to attempt stream retry on subsequent tiers before first chunk. Default true. */
-	streamRetryBeforeFirstChunk?: boolean;
-}
-
-interface ResolvedTier {
-	name: string;
-	adapter: LLMAdapter;
-	breaker?: CircuitBreaker;
-	filter?: (messages: readonly ChatMessage[], opts?: LLMInvokeOptions) => boolean;
-}
-
-export class AllTiersExhaustedError extends Error {
-	override name = "AllTiersExhaustedError";
-	readonly skipped: ReadonlyArray<{ name: string; reason: "filter" | "breaker" }>;
-	readonly failed: ReadonlyMap<string, unknown>;
-	constructor(report: CascadeExhaustionReport) {
-		const parts: string[] = [];
-		if (report.failed.size > 0) parts.push(`failed=[${[...report.failed.keys()].join(",")}]`);
-		if (report.skipped.length > 0) {
-			parts.push(`skipped=[${report.skipped.map((s) => `${s.name}(${s.reason})`).join(",")}]`);
-		}
-		super(`All LLM adapter tiers exhausted: ${parts.join(" ")}`);
-		this.skipped = report.skipped;
-		this.failed = report.failed;
-	}
-}
-
-export function cascadingLlmAdapter(
-	tiers: readonly AdapterTier[],
-	opts: CascadingLlmAdapterOptions = {},
-): LLMAdapter {
-	if (tiers.length === 0) throw new RangeError("cascadingLlmAdapter: tiers must be non-empty");
-
-	const resolved: ResolvedTier[] = tiers.map((t) => ({
-		name: t.name,
-		adapter: t.adapter,
-		filter: t.filter,
-		breaker: t.breaker
-			? "canExecute" in t.breaker
-				? (t.breaker as CircuitBreaker)
-				: circuitBreaker(t.breaker as CircuitBreakerOptions)
-			: undefined,
-	}));
-
-	const streamRetryBeforeFirstChunk = opts.streamRetryBeforeFirstChunk ?? true;
-
-	const cascade: LLMAdapter = {
-		provider: "cascading",
-		model: undefined,
-
-		async invoke(messages, invokeOpts): Promise<LLMResponse> {
-			const skipped: Array<{ name: string; reason: "filter" | "breaker" }> = [];
-			const failed = new Map<string, unknown>();
-			for (let i = 0; i < resolved.length; i++) {
-				const t = resolved[i];
-				if (t.filter && !t.filter(messages, invokeOpts)) {
-					skipped.push({ name: t.name, reason: "filter" });
-					continue;
-				}
-				if (t.breaker && !t.breaker.canExecute()) {
-					skipped.push({ name: t.name, reason: "breaker" });
-					continue;
-				}
-				try {
-					const resp = await firstValueFrom(fromAny(t.adapter.invoke(messages, invokeOpts)));
-					t.breaker?.recordSuccess();
-					return { ...resp, metadata: { ...(resp.metadata ?? {}), tier: t.name } };
-				} catch (err) {
-					failed.set(t.name, err);
-					t.breaker?.recordFailure(err);
-					const next = resolved[i + 1];
-					if (next) opts.onFallback?.(t.name, next.name, err);
-				}
-			}
-			const report: CascadeExhaustionReport = { skipped, failed };
-			opts.onExhausted?.(report);
-			throw new AllTiersExhaustedError(report);
-		},
-
-		async *stream(messages, invokeOpts): AsyncGenerator<StreamDelta> {
-			const skipped: Array<{ name: string; reason: "filter" | "breaker" }> = [];
-			const failed = new Map<string, unknown>();
-			for (let i = 0; i < resolved.length; i++) {
-				const t = resolved[i];
-				if (t.filter && !t.filter(messages, invokeOpts)) {
-					skipped.push({ name: t.name, reason: "filter" });
-					continue;
-				}
-				if (t.breaker && !t.breaker.canExecute()) {
-					skipped.push({ name: t.name, reason: "breaker" });
-					continue;
-				}
-				let yieldedAny = false;
-				try {
-					for await (const delta of t.adapter.stream(messages, invokeOpts)) {
-						yieldedAny = true;
-						yield delta;
-					}
-					t.breaker?.recordSuccess();
-					return;
-				} catch (err) {
-					failed.set(t.name, err);
-					t.breaker?.recordFailure(err);
-					if (yieldedAny || !streamRetryBeforeFirstChunk) {
-						// Past first chunk — stream commitment. Propagate immediately.
-						// Consumers handle the thrown error in their catch; no synthetic
-						// finish delta is emitted (see JSDoc at top of file). We do NOT
-						// call `onExhausted` here because other tiers were never tried —
-						// the error is a single-tier commitment failure, not a
-						// "no-tier-worked" condition.
-						throw err;
-					}
-					const next = resolved[i + 1];
-					if (next) opts.onFallback?.(t.name, next.name, err);
-				}
-			}
-			const report: CascadeExhaustionReport = { skipped, failed };
-			opts.onExhausted?.(report);
-			throw new AllTiersExhaustedError(report);
-		},
-	};
-	withLayer(cascade, `cascade[${resolved.map((t) => t.name).join(",")}]`);
-	return cascade;
-}
-
-/**
- * Tiny type-safe constructor for an {@link AdapterTier}. Cleans up the
- * heterogeneous array-type cast users (and `browser-presets.ts`) had to write
- * by hand. Per Wave A Unit 13 decision.
- *
- * @example
- * ```ts
- * cascadingLlmAdapter([
- *   tier("local", webllmAdapter(...)),
- *   tier("cloud", anthropicAdapter(...), { breaker: { failureThreshold: 5 } }),
- * ]);
- * ```
- *
- * @category ai
- */
-export function tier(
-	name: string,
-	adapter: LLMAdapter,
-	opts?: { breaker?: CircuitBreakerOptions | CircuitBreaker; filter?: AdapterTier["filter"] },
-): AdapterTier {
-	const out: AdapterTier = { name, adapter };
-	if (opts?.breaker) out.breaker = opts.breaker;
-	if (opts?.filter) out.filter = opts.filter;
-	return out;
-}
diff --git a/src/utils/ai/adapters/routing/index.ts b/src/utils/ai/adapters/routing/index.ts
deleted file mode 100644
index 401252af..00000000
--- a/src/utils/ai/adapters/routing/index.ts
+++ /dev/null
@@ -1 +0,0 @@
-export * from "./cascading.js";
diff --git a/src/utils/ai/agents/chat-stream.ts b/src/utils/ai/agents/chat-stream.ts
deleted file mode 100644
index f0d86b39..00000000
--- a/src/utils/ai/agents/chat-stream.ts
+++ /dev/null
@@ -1,103 +0,0 @@
-import { type Node, node, RESOLVED } from "@graphrefly/pure-ts/core";
-import { keepalive, type ReactiveLogBundle, reactiveLog } from "@graphrefly/pure-ts/extra";
-import { Graph, type GraphOptions } from "@graphrefly/pure-ts/graph";
-import { aiMeta } from "../_internal.js";
-import type { ChatMessage } from "../adapters/core/types.js";
-
-// ---------------------------------------------------------------------------
-// chatStream
-// ---------------------------------------------------------------------------
-
-export type ChatStreamOptions = {
-	graph?: GraphOptions;
-	maxMessages?: number;
-};
-
-export class ChatStreamGraph extends Graph {
-	private readonly _log: ReactiveLogBundle<ChatMessage>;
-	readonly messages: Node<readonly ChatMessage[]>;
-	/**
-	 * Most recently appended message. Stays in the protocol SENTINEL state
-	 * (`cache === undefined`, no DATA emitted) until the first append, then
-	 * tracks the latest entry. Per COMPOSITION-GUIDE §1a, the SENTINEL is
-	 * the canonical "no value yet" signal — consumers detect empty via
-	 * `data[i] === undefined` inside reactive fns or `latest.cache === undefined`
-	 * outside. No `T | null` placeholder, no `hasLatest` companion.
-	 */
-	readonly latest: Node<ChatMessage>;
-	readonly messageCount: Node<number>;
-
-	constructor(name: string, opts: ChatStreamOptions = {}) {
-		super(name, opts.graph);
-
-		this._log = reactiveLog<ChatMessage>([], {
-			name: "messages",
-			maxSize: opts.maxMessages,
-		});
-		this.messages = this._log.entries;
-		this.add(this.messages, { name: "messages" });
-
-		// SENTINEL on empty (COMPOSITION-GUIDE §1a): return `[]` for
-		// RESOLVED-only on empty stream, `[T]` to emit DATA. `latest.cache`
-		// stays `undefined` until the first append.
-		this.latest = node<ChatMessage>(
-			[this.messages],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				const entries = data[0] as readonly ChatMessage[];
-				if (entries.length === 0) {
-					actions.down([[RESOLVED]]);
-					return;
-				}
-				actions.emit(entries[entries.length - 1] as ChatMessage);
-			},
-			{
-				name: "latest",
-				describeKind: "derived",
-				meta: aiMeta("chat_latest"),
-			},
-		);
-		this.add(this.latest, { name: "latest" });
-		this.addDisposer(keepalive(this.latest));
-
-		this.messageCount = node<number>(
-			[this.messages],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as readonly ChatMessage[]).length);
-			},
-			{
-				name: "messageCount",
-				describeKind: "derived",
-				meta: aiMeta("chat_message_count"),
-				initial: 0,
-			},
-		);
-		this.add(this.messageCount, { name: "messageCount" });
-		this.addDisposer(keepalive(this.messageCount));
-	}
-
-	append(role: ChatMessage["role"], content: string, extra?: Partial<ChatMessage>): void {
-		this._log.append({ role, content, ...extra });
-	}
-
-	appendToolResult(callId: string, content: string): void {
-		this._log.append({ role: "tool", content, toolCallId: callId });
-	}
-
-	clear(): void {
-		this._log.clear();
-	}
-
-	allMessages(): readonly ChatMessage[] {
-		return this.messages.cache as readonly ChatMessage[];
-	}
-}
-
-export function chatStream(name: string, opts?: ChatStreamOptions): ChatStreamGraph {
-	return new ChatStreamGraph(name, opts);
-}
diff --git a/src/utils/ai/agents/handoff.ts b/src/utils/ai/agents/handoff.ts
deleted file mode 100644
index 630c129a..00000000
--- a/src/utils/ai/agents/handoff.ts
+++ /dev/null
@@ -1,130 +0,0 @@
-import { factoryTag, type Node, node } from "@graphrefly/pure-ts/core";
-import { fromAny, type NodeInput, switchMap } from "@graphrefly/pure-ts/extra";
-
-// ---------------------------------------------------------------------------
-// handoff — multi-agent routing sugar (B10)
-// ---------------------------------------------------------------------------
-
-/**
- * Options for {@link handoff}.
- */
-export type HandoffOptions = {
-	/**
-	 * Reactive gate: when this node's value is `true`, output flows from
-	 * `from` to the `to` specialist; when `false`, `from`'s output flows
-	 * through unchanged and `to` stays dormant. Omit to always hand off —
-	 * useful when `from` is itself a router whose output shape already
-	 * encodes routing intent.
-	 */
-	condition?: NodeInput<boolean>;
-	name?: string;
-};
-
-/**
- * Multi-agent handoff recipe — route `from`'s output into a specialist
- * agent `toFactory` when `condition` is open. Thin composition over
- * `switchMap` + gate; not a new primitive, just a named shape.
- *
- * The "handoff" pattern (popularized by the OpenAI Agents SDK) covers two
- * idioms:
- *
- * 1. **Full handoff** — a triage agent routes the conversation to a
- *    specialist, and the specialist becomes the active agent for the rest
- *    of the turn. Accumulated context (memory, tool definitions) can travel
- *    along by threading the same `agentMemory` bundle into both.
- * 2. **Agents-as-tools** — the manager keeps control and calls the
- *    specialist like a tool for a bounded subtask. Build this by registering
- *    a `promptNode` instance as a `ToolDefinition` on the parent via
- *    `toolRegistry`.
- *
- * This sugar covers (1) — a reactive route from one agent's output into a
- * specialist factory. For (2) wire a tool registry manually; the pattern is
- * additive with this one.
- *
- * @example Full handoff on a triage signal.
- * ```ts
- * import { handoff, promptNode } from "@graphrefly/graphrefly/utils/ai";
- *
- * const triage = promptNode(adapter, [userMessage], (msg) =>
- *   `Classify urgency of: ${msg}. Reply "high" or "normal".`);
- * const isUrgent = derived([triage], ([v]) => v === "high");
- *
- * const specialist = handoff(
- *   userMessage,
- *   (input) => promptNode(specialistAdapter, [input], (m) => `Respond urgently: ${m}`),
- *   { condition: isUrgent },
- * );
- * ```
- *
- * @param from - Source node whose value is threaded into the specialist.
- * @param toFactory - Factory that takes `from` (as a reactive source) and
- *   returns the specialist node. Called once, lazily, when the first
- *   subscriber activates.
- * @param opts - Optional reactive `condition` gate + name.
- * @returns Node emitting the specialist's output when the gate is open, or
- *   `from`'s value when the gate is closed. Null when `from` is null.
- *
- * **Performance caveat (Wave A Unit 5):** the specialist is mounted per
- * source emission — each `v != null` DATA on `from` allocates a fresh
- * `state<T>(v)` + invokes `toFactory`, and switchMap cancels the prior
- * branch. For per-turn routing (≤1 emit/sec) this is negligible. For
- * high-frequency sources (per-token routing, tight event loops), batch
- * upstream (e.g. via `audit`, `throttle`, or `distinctUntilChanged`) before
- * handing off — each mount/unmount cycle spins up full subgraphs
- * (`messagesNode` + adapter bridge + output for a `promptNode` specialist).
- *
- * @category patterns.ai
- */
-export function handoff<T>(
-	from: NodeInput<T | null>,
-	toFactory: (input: Node<T>) => Node<T | null>,
-	opts?: HandoffOptions,
-): Node<T | null> {
-	const src = fromAny(from);
-	const cond = opts?.condition != null ? fromAny(opts.condition) : null;
-
-	// Shared `null` state — reused across null source emissions so repeated
-	// nulls don't allocate a fresh node per switchMap project call.
-	const nullState: Node<T | null> = node<T | null>([], {
-		initial: null,
-		name: opts?.name ? `${opts.name}::null` : "handoff::null",
-	});
-
-	// When no condition is supplied, always route through the specialist.
-	if (cond == null) {
-		return switchMap<T | null, T | null>(
-			src,
-			(v) => {
-				if (v == null) return nullState as NodeInput<T | null>;
-				const input = node<T>([], { initial: v });
-				return toFactory(input) as NodeInput<T | null>;
-			},
-			{ meta: factoryTag("handoff") },
-		);
-	}
-
-	// With a condition: pair src + cond into a router object, then switchMap
-	// to either the specialist (when open) or a pass-through state (when
-	// closed). Each router emission may re-instantiate the specialist — the
-	// switchMap cancels the stale branch.
-	const router = node<{ v: T | null; open: boolean }>(
-		[src, cond],
-		(batchData, actions, ctx) => {
-			const data = batchData.map((batch, i) =>
-				batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-			);
-			actions.emit({ v: data[0] as T | null, open: data[1] === true });
-		},
-		{ name: opts?.name ? `${opts.name}::router` : "handoff::router", describeKind: "derived" },
-	);
-	return switchMap<{ v: T | null; open: boolean }, T | null>(
-		router,
-		({ v, open }) => {
-			if (v == null) return nullState as NodeInput<T | null>;
-			if (!open) return node<T | null>([], { initial: v }) as NodeInput<T | null>;
-			const input = node<T>([], { initial: v });
-			return toFactory(input) as NodeInput<T | null>;
-		},
-		{ meta: factoryTag("handoff") },
-	);
-}
diff --git a/src/utils/ai/agents/tool-execution.ts b/src/utils/ai/agents/tool-execution.ts
deleted file mode 100644
index acab12f1..00000000
--- a/src/utils/ai/agents/tool-execution.ts
+++ /dev/null
@@ -1,178 +0,0 @@
-/**
- * `toolExecution` — reactive per-tool-call executor with retry + rescue.
- *
- * Lifted from the inlined `executeToolReactively` helper inside `agent-loop.ts`
- * so it can be consumed standalone by any caller with a reactive `toolCalls`
- * batch — not just `agentLoop`. The shape is: one input `Node<readonly
- * ToolCall[]>` + a `ToolRegistryGraph` → one output `Node<readonly
- * ToolResult[]>`. Each call maps to a per-call `retrySource(executeReactive)`
- * → optional `rescue` chain that emits the handler result on success, or a
- * JSON-wrapped `{ error }` payload on terminal failure so the LLM can see the
- * error as tool output and decide whether to try again via another tool call.
- *
- * **Cancellation.** `executeReactive` mints a per-call `AbortController` and
- * threads its signal into the handler call. When `switchMap` supersedes the
- * inner (a fresh `toolCalls` batch arrives) or the outer graph tears down,
- * the per-call node unsubscribes and `ac.abort()` fires. Signal-aware
- * handlers (`fetch(url, {signal})`, child-process kill, DB cancel) actually
- * stop in-flight work; handlers that ignore the signal still complete to
- * their original termination, but their result is discarded.
- *
- * @module
- */
-
-import { type Node, node } from "@graphrefly/pure-ts/core";
-import { rescue, switchMap } from "@graphrefly/pure-ts/extra";
-import { retry } from "../../../base/resilience/retry.js";
-import type { ToolCall } from "../adapters/core/types.js";
-import type { ToolRegistryGraph } from "./tool-registry.js";
-
-// ---------------------------------------------------------------------------
-// Types
-// ---------------------------------------------------------------------------
-
-/** A single tool execution outcome: `{id, content}` where content is a JSON string. */
-export interface ToolResult {
-	readonly id: string;
-	readonly content: string;
-}
-
-export type ToolExecutionOptions = {
-	/**
-	 * Reactive tool-call batch. Each non-empty emission triggers a fresh
-	 * per-call execution fan-out; superseding emissions cancel the prior fan.
-	 */
-	toolCalls: Node<readonly ToolCall[]>;
-	/** Registry that resolves tool name → handler. */
-	tools: ToolRegistryGraph;
-	/**
-	 * Retry count per individual tool call. `retrySource({count: N})` retries
-	 * up to N times on error (N retries = N+1 total attempts). Default: 1.
-	 */
-	retryCount?: number;
-	/**
-	 * How to surface a terminal error after retries are exhausted.
-	 * - `"rescue"` (default): emit `{id, content: JSON.stringify({error})}`
-	 *   so the LLM sees the failure as structured tool output and can decide
-	 *   how to react. Sibling calls in the same batch continue to their own
-	 *   completion; one call's failure does not affect the others.
-	 * - `"propagate"`: let the ERROR propagate downstream. **Blast radius:**
-	 *   the per-batch `derived` join auto-errors when any per-call node
-	 *   terminates with ERROR, so one call's failure discards every sibling's
-	 *   DATA (even ones that already settled with a valid ToolResult). Use
-	 *   `"propagate"` only when a single tool failure should be fatal for the
-	 *   whole batch; prefer `"rescue"` when you want the LLM to see partial
-	 *   results plus per-call error markers.
-	 */
-	onError?: "rescue" | "propagate";
-};
-
-// ---------------------------------------------------------------------------
-// Public API
-// ---------------------------------------------------------------------------
-
-/**
- * Reactive executor for a batch of LLM tool calls.
- *
- * Each DATA emission on `toolCalls` dispatches a fresh per-call fan-out: for
- * every call in the batch, construct a `retrySource(fromAny(tools.execute(
- * name, args)))` node, optionally `rescue` it into a JSON error shape, and
- * join the results via a `derived` whose first-run gate waits for every call
- * to settle before emitting the batch. Empty batches (`calls.length === 0`)
- * are a caller-side invariant violation (the upstream gate should emit
- * RESOLVED for empty batches, not DATA) and trigger a loud error — callers
- * that want to accept empty batches should upstream-filter them first.
- *
- * Reference-equality + content-equality dedup is applied to the output batch
- * so duplicate re-emissions from a completing retrySource don't propagate.
- *
- * @param opts - `{ toolCalls, tools, retryCount?, onError? }`.
- * @returns `Node<readonly ToolResult[]>` — one ToolResult per input ToolCall.
- */
-export function toolExecution(opts: ToolExecutionOptions): Node<readonly ToolResult[]> {
-	const { toolCalls, tools } = opts;
-	const retryCount = opts.retryCount ?? 1;
-	const onError = opts.onError ?? "rescue";
-
-	const batchEquals = (a: readonly ToolResult[], b: readonly ToolResult[]): boolean => {
-		if (a === b) return true;
-		if (a.length !== b.length) return false;
-		for (let i = 0; i < a.length; i++) {
-			const ai = a[i];
-			const bi = b[i];
-			if (ai?.id !== bi?.id) return false;
-			if (ai?.content !== bi?.content) return false;
-		}
-		return true;
-	};
-
-	return switchMap<readonly ToolCall[], readonly ToolResult[]>(toolCalls, (calls) => {
-		if (calls == null || calls.length === 0) {
-			throw new Error(
-				"toolExecution: received an empty tool-call batch as DATA — callers must upstream-filter empty batches (emit RESOLVED) so switchMap is only dispatched for non-empty batches.",
-			);
-		}
-		const perCall = calls.map((call) => executeOne(call, tools, retryCount, onError));
-		// `executeOne` returns `Node<ToolResult>` in both "rescue" and
-		// "propagate" modes (the rescue handler builds a `ToolResult`
-		// shape; the success `derived` builds one directly). The join
-		// just forwards the per-call values — no shape coercion needed.
-		return node(
-			perCall,
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit(data as readonly ToolResult[]);
-			},
-			{ describeKind: "derived", name: "toolExecution::batch", equals: batchEquals },
-		);
-	});
-}
-
-// ---------------------------------------------------------------------------
-// Internals
-// ---------------------------------------------------------------------------
-
-/**
- * Per-call reactive executor. `retrySource` re-invokes the factory on ERROR
- * (each attempt mints a fresh `executeReactive` node, which in turn mints a
- * fresh `AbortController` and handler invocation). `executeReactive` itself
- * handles synchronous handler throws — they surface as `[[ERROR, err]]`
- * inside the producer, so `retrySource`'s reactive ERROR path fires
- * consistently regardless of handler shape. No `Promise.resolve().then(...)`
- * thunk needed — the reactive path is end-to-end.
- *
- * Handlers that return a plain string are surfaced as-is; anything else is
- * `JSON.stringify`'d so LLMs that parse tool results can roundtrip
- * structured data without surprise quoting.
- */
-function executeOne(
-	call: ToolCall,
-	tools: ToolRegistryGraph,
-	retryCount: number,
-	onError: "rescue" | "propagate",
-): Node<ToolResult> {
-	const attempted: Node<unknown> = retry(() => tools.executeReactive(call.name, call.arguments), {
-		count: retryCount,
-	}).node;
-	const onSuccess = node<ToolResult>(
-		[attempted],
-		(batchData, actions, ctx) => {
-			const data = batchData.map((batch, i) =>
-				batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-			);
-			const val = data[0];
-			actions.emit({
-				id: call.id,
-				content: typeof val === "string" ? val : JSON.stringify(val),
-			});
-		},
-		{ describeKind: "derived" },
-	);
-	if (onError === "propagate") return onSuccess;
-	return rescue(onSuccess, (err) => ({
-		id: call.id,
-		content: JSON.stringify({ error: String(err) }),
-	}));
-}
diff --git a/src/utils/ai/agents/tool-interceptor.ts b/src/utils/ai/agents/tool-interceptor.ts
deleted file mode 100644
index 220f2421..00000000
--- a/src/utils/ai/agents/tool-interceptor.ts
+++ /dev/null
@@ -1,186 +0,0 @@
-import { factoryTag, type Node, node, RESOLVED } from "@graphrefly/pure-ts/core";
-import { fromAny, type NodeInput } from "@graphrefly/pure-ts/extra";
-import { aiMeta } from "../_internal.js";
-import type { ToolCall } from "../adapters/core/types.js";
-
-// ---------------------------------------------------------------------------
-// toolInterceptor — reactive tool-call enforcement (D9 / COMPOSITION-GUIDE §31)
-// ---------------------------------------------------------------------------
-
-/**
- * Options for {@link toolInterceptor}.
- */
-export interface ToolInterceptorOptions {
-	readonly name?: string;
-	/**
-	 * Kill-switch. When this reactive Node emits `false`, **every** tool call
-	 * in the wave is denied and the turn collapses to a clean no-op (RESOLVED,
-	 * not an empty-array execution). An explicit `null` / `undefined` DATA
-	 * value is pass-through ("deny when explicitly `false`"). Like
-	 * {@link ToolInterceptorOptions.allow}, a switch node that has never
-	 * emitted has **unspecified** gating — **always seed it**
-	 * (`node([], { initial: true })`). Modelled as a reactive deny-signal, NOT
-	 * a buffering `valve`: a security kill-switch must DROP denied calls,
-	 * never buffer-and-replay them after re-enable — a re-enable with no fresh
-	 * `calls` wave is a no-op (see {@link ToolInterceptorOptions.allow}).
-	 */
-	readonly enabled?: NodeInput<boolean>;
-	/**
-	 * Per-call allow predicates. A tool call is forwarded iff **every**
-	 * predicate returns `true`. A predicate that has emitted an explicit
-	 * `null` / `undefined` DATA value is pass-through (the policy author's
-	 * "not-ready, allow" signal). **Always seed each predicate node with an
-	 * `initial`** (e.g. `node([], { initial: null })` for pass-through-while-
-	 * loading, or an initial predicate fn): a predicate node that has *never*
-	 * emitted DATA has **unspecified** gating — depending on activation order
-	 * the non-partial first-run gate may hold the tool turn or pass through,
-	 * so a never-seeded policy must not be relied on either way. A predicate
-	 * that **throws** is treated as **deny** for that call (a security gate
-	 * must never fail open on a buggy policy).
-	 *
-	 * **Re-filtering is calls-driven, not predicate-driven.** A predicate (or
-	 * {@link enabled}) change *alone* never re-emits an in-flight batch — that
-	 * would replay a previously-denied batch with no LLM in the loop
-	 * (confused-deputy). The post-intercept stream only re-evaluates on a
-	 * *fresh* `calls` wave; predicate/switch updates take effect on the next
-	 * tool-call batch.
-	 */
-	readonly allow?: readonly NodeInput<(call: ToolCall) => boolean>[];
-}
-
-/**
- * Reactive tool-call **enforcement** (COMPOSITION-GUIDE §31, Composition C).
- * The post-generation security counterpart to `toolSelector`'s
- * pre-generation UX: `toolSelector` controls what's *offered* to the LLM;
- * `toolInterceptor` gates what's *executed* after the LLM chooses.
- *
- * Returns a transform `(calls) => Node<readonly ToolCall[]>` shaped to slot
- * directly into `agentLoop`'s `interceptToolCalls` splice
- * (`agent-loop.ts` D9). The returned node is `derived`-kind: it sees the raw
- * tool-call batch, applies the kill-switch then the per-call predicates, and
- *
- * - emits the surviving subset when ≥1 call passes,
- * - emits `[RESOLVED]` when the switch is off OR every call is denied — a
- *   clean no-op turn, structurally identical to `toolCallsRaw`'s own
- *   empty-batch gate, so `toolExecution`'s non-empty contract is preserved.
- *
- * Because the splice replaces the public `agent.toolCalls` view with this
- * node, audit / telemetry observe the post-intercept reality.
- *
- * @example
- * ```ts
- * const killSwitch = node<boolean>([], { name: "tools-enabled", initial: true });
- * const loop = agentLoop("agent", {
- *   adapter,
- *   tools: [searchTool, deleteTool],
- *   interceptToolCalls: toolInterceptor({
- *     enabled: killSwitch,
- *     allow: [
- *       // deny destructive tools unless an external policy node says ok
- *       node([policyNode], (b, a, c) => {
- *         const d = b.map((x, i) => x != null && x.length > 0 ? x.at(-1) : c.prevData[i]);
- *         a.emit((call: ToolCall) => call.name !== "delete" || d[0] === true);
- *       }, { describeKind: "derived" }),
- *     ],
- *   }),
- * });
- * ```
- *
- * @param opts - {@link ToolInterceptorOptions}.
- * @returns A `(calls) => Node` transform for `agentLoop.interceptToolCalls`.
- *
- * @category ai
- */
-export function toolInterceptor(
-	opts: ToolInterceptorOptions = {},
-): (calls: Node<readonly ToolCall[]>) => Node<readonly ToolCall[]> {
-	return (calls) => {
-		const enabledNode = opts.enabled != null ? fromAny(opts.enabled) : undefined;
-		const predNodes = (opts.allow ?? []).map((p) => fromAny(p));
-		const deps = [calls, ...(enabledNode ? [enabledNode] : []), ...predNodes] as const;
-		return node<readonly ToolCall[]>(
-			deps,
-			(batchData, actions, ctx) => {
-				// Security gate: only re-evaluate on a FRESH `calls` wave. A
-				// re-run triggered by an `enabled`/predicate change with no new
-				// tool-call batch must NOT re-filter the stale `prevData[0]`
-				// batch — that would replay previously-denied calls into the
-				// executor with no LLM in the loop (confused-deputy hole the
-				// `enabled` JSDoc explicitly forbids). Settle no-op instead.
-				const callsBatch = batchData[0];
-				if (callsBatch == null || callsBatch.length === 0) {
-					actions.down([[RESOLVED]]);
-					return;
-				}
-
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				const incoming = (data[0] as readonly ToolCall[] | null | undefined) ?? [];
-
-				let cursor = 1;
-				if (enabledNode) {
-					const enabled = data[cursor++] as boolean | null | undefined;
-					// Deny-when-explicitly-false; null/undefined = pass-through.
-					if (enabled === false) {
-						actions.down([[RESOLVED]]);
-						return;
-					}
-				}
-
-				const preds = data.slice(cursor) as ReadonlyArray<
-					((call: ToolCall) => boolean) | null | undefined
-				>;
-				const kept = incoming.filter((call) => {
-					for (const pred of preds) {
-						// Not-yet-settled predicate ≠ deny (matches toolSelector).
-						if (pred == null) continue;
-						try {
-							if (!pred(call)) return false;
-						} catch {
-							// A throwing policy predicate fails CLOSED — deny this
-							// call rather than tearing down the whole tool stream
-							// with a terminal ERROR. A security gate must never
-							// fail open on a buggy predicate.
-							return false;
-						}
-					}
-					return true;
-				});
-
-				// Full-deny → clean no-op turn (Q-B). Mirrors `toolCallsRaw`'s
-				// own empty-batch RESOLVED gate so `toolExecution`'s "non-empty
-				// batch only" contract upstream-of-it stays satisfied.
-				if (kept.length === 0) {
-					actions.down([[RESOLVED]]);
-					return;
-				}
-				actions.emit(kept);
-			},
-			{
-				name: opts.name ?? "tool-interceptor",
-				describeKind: "derived",
-				// NON-partial (no `partial: true`) — deliberate. A seeded
-				// `enabled`/predicate (with an `initial`) emits on activation,
-				// so it is honoured before any tool call flows (the contract
-				// callers must follow — see `allow` JSDoc). `partial: true`
-				// was tried and REJECTED: it un-gates the node so `calls`
-				// races ahead of a slower seeded policy dep on the activation
-				// wave and leaks denied calls fail-OPEN. A *never-seeded*
-				// (pure SENTINEL) policy has unspecified gating under either
-				// setting — callers must seed an `initial`; not relied on.
-				// Cross-ref `tool-selector.ts` (same non-partial shape).
-				meta: { ...aiMeta("tool_interceptor"), ...factoryTag("toolInterceptor") },
-				equals: (a, b) => {
-					const la = a as readonly ToolCall[];
-					const lb = b as readonly ToolCall[];
-					if (la.length !== lb.length) return false;
-					for (let i = 0; i < la.length; i++) {
-						if (la[i] !== lb[i]) return false;
-					}
-					return true;
-				},
-			},
-		);
-	};
-}
diff --git a/src/utils/ai/agents/tool-registry.ts b/src/utils/ai/agents/tool-registry.ts
deleted file mode 100644
index 955385d4..00000000
--- a/src/utils/ai/agents/tool-registry.ts
+++ /dev/null
@@ -1,182 +0,0 @@
-import { ERROR, type Messages, type Node, node } from "@graphrefly/pure-ts/core";
-import { fromAsyncIter, fromPromise, keepalive, reactiveMap } from "@graphrefly/pure-ts/extra";
-import { Graph, type GraphOptions } from "@graphrefly/pure-ts/graph";
-import { aiMeta, isNodeLike } from "../_internal.js";
-import type { ToolDefinition } from "../adapters/core/types.js";
-
-// ---------------------------------------------------------------------------
-// toolRegistry
-// ---------------------------------------------------------------------------
-
-export type ToolRegistryOptions = {
-	graph?: GraphOptions;
-};
-
-/**
- * `ToolRegistryGraph` — name-keyed registry of {@link ToolDefinition}s.
- *
- * **Reactive-only execution.** The only execution path is
- * {@link executeReactive}, which returns a `Node<unknown>` for the handler
- * result. Composing factories (`toolExecution`, `agentLoop`) consume it
- * directly inside `retrySource` / `switchMap` chains. There is intentionally
- * no imperative `execute()` Promise method — the registry was originally a
- * dual-boundary class (imperative + reactive) and the imperative path was
- * the only thing in the codebase bridging through `Promise.resolve().then()`
- * to feed `fromAny`. Removing it left every consumer on a single
- * reactive-all-the-way path with real abort propagation.
- *
- * For non-reactive callers (debug scripts, one-shot tests), bridge with
- * `awaitSettled(toolRegistry.executeReactive(name, args))`.
- *
- * **Wave A Unit 6 refactor:** internal storage migrated from `state<Map>`
- * (O(N) Map-copy per mutation) to `ReactiveMapBundle<string, ToolDefinition>`
- * (O(1) mutations + version counter).
- */
-export class ToolRegistryGraph extends Graph {
-	readonly definitions: Node<ReadonlyMap<string, ToolDefinition>>;
-	readonly schemas: Node<readonly ToolDefinition[]>;
-	private readonly _bundle: ReturnType<typeof reactiveMap<string, ToolDefinition>>;
-
-	constructor(name: string, opts: ToolRegistryOptions = {}) {
-		super(name, opts.graph);
-
-		this._bundle = reactiveMap<string, ToolDefinition>({
-			name: "definitions",
-		});
-		this.definitions = this._bundle.entries;
-		this.add(this.definitions, { name: "definitions" });
-
-		this.schemas = node<readonly ToolDefinition[]>(
-			[this.definitions],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				const defs = data[0];
-				actions.emit([...((defs ?? new Map()) as ReadonlyMap<string, ToolDefinition>).values()]);
-			},
-			{
-				name: "schemas",
-				describeKind: "derived",
-				meta: aiMeta("tool_schemas"),
-				initial: [],
-			},
-		);
-		this.add(this.schemas, { name: "schemas" });
-		this.addDisposer(keepalive(this.schemas));
-	}
-
-	register(tool: ToolDefinition): void {
-		this._bundle.set(tool.name, tool);
-	}
-
-	unregister(name: string): void {
-		this._bundle.delete(name);
-	}
-
-	/**
-	 * Reactive execution — returns a `Node<unknown>` that emits the handler
-	 * result. The returned node is a `producer` that:
-	 *
-	 * 1. Mints a per-call `AbortController` whose `signal` is threaded into
-	 *    the handler call AND into `fromAny` (so a `fromPromise` /
-	 *    `fromAsyncIter` inner abandons cleanly when the consumer
-	 *    unsubscribes).
-	 * 2. Runs `tool.handler(args, {signal})` inside a try/catch — a
-	 *    synchronous throw surfaces as `[[ERROR, err]]` downstream instead
-	 *    of escaping the producer.
-	 * 3. Forwards every message from the inner `fromAny` chain to the
-	 *    producer's outputs.
-	 * 4. On teardown (subscriber count drops to zero, e.g. `switchMap`
-	 *    supersede) calls `ac.abort()` and unsubscribes the inner.
-	 *    Signal-aware handlers (e.g. `fetch(url, {signal})`) actually stop.
-	 *
-	 * Each call mints a fresh node tied to a fresh `handler(args, ...)`
-	 * invocation — call `executeReactive` again for repeated invocations.
-	 *
-	 * @throws `Error` synchronously when `name` is not registered (no node is
-	 *   constructed — the caller gets a pre-wiring failure rather than a
-	 *   silent ERROR wave on an empty graph).
-	 */
-	executeReactive(name: string, args: Record<string, unknown>): Node<unknown> {
-		const tool = this._bundle.get(name);
-		if (!tool) throw new Error(`toolRegistry: unknown tool "${name}"`);
-		return node<unknown>(
-			[],
-			(_data, actions) => {
-				const ac = new AbortController();
-				let inner: Node<unknown>;
-				try {
-					const raw = tool.handler(args, { signal: ac.signal });
-					inner = handlerResultToNode(raw, ac.signal);
-				} catch (err) {
-					// Synchronous throw from handler → ERROR. Producer cleanup
-					// still aborts the controller for symmetry (no-op if no
-					// signal listeners attached).
-					actions.down([[ERROR, err]] satisfies Messages);
-					return {
-						onDeactivation: () => {
-							ac.abort();
-						},
-					};
-				}
-				const unsub = inner.subscribe((batch) => {
-					actions.down(batch as Messages);
-				});
-				return {
-					onDeactivation: () => {
-						ac.abort();
-						unsub();
-					},
-				};
-			},
-			{
-				name: `executeReactive::${name}`,
-				describeKind: "producer",
-				meta: aiMeta("tool_execute_reactive"),
-			},
-		);
-	}
-
-	getDefinition(name: string): ToolDefinition | undefined {
-		// Pure read via the snapshot cache — avoids the bundle's
-		// `wrapMutation` path (which would run the version-bump check and
-		// any configured retention eviction on every lookup). Safe because
-		// `getDefinition` is a boundary API, not a reactive fn body.
-		return this._bundle.entries.cache?.get(name);
-	}
-}
-
-export function toolRegistry(name: string, opts?: ToolRegistryOptions): ToolRegistryGraph {
-	return new ToolRegistryGraph(name, opts);
-}
-
-/**
- * Coerce a tool handler return value into a `Node<unknown>`.
- *
- * Differs from `fromAny` by treating **strings, arrays, plain iterables, and
- * scalar objects as single DATA values** rather than iterating them. A tool
- * handler that returns `"hello world"` should surface as one `DATA("hello
- * world")`, not 11 `DATA` events of single characters; an array `[1, 2, 3]`
- * should surface as `DATA([1, 2, 3])`, not three separate emissions.
- *
- * Reactive shapes (Node, Promise, AsyncIterable) are unwrapped as expected.
- *
- * @internal
- */
-function handlerResultToNode(raw: unknown, signal: AbortSignal): Node<unknown> {
-	if (isNodeLike(raw)) {
-		return raw as Node<unknown>;
-	}
-	if (raw != null && typeof (raw as PromiseLike<unknown>).then === "function") {
-		return fromPromise(raw as PromiseLike<unknown>, { signal });
-	}
-	if (raw != null && typeof raw === "object" && Symbol.asyncIterator in (raw as object)) {
-		return fromAsyncIter(raw as AsyncIterable<unknown>, { signal });
-	}
-	// String, number, boolean, null, undefined, plain object, array,
-	// sync iterable — treat as a single DATA value via a resolved Promise so
-	// `fromPromise`'s scalar-DATA-emit + COMPLETE semantics match the
-	// pre-refactor `tools.execute` behavior (which always wrapped via async).
-	return fromPromise(Promise.resolve(raw), { signal });
-}
diff --git a/src/utils/ai/agents/tool-selector.ts b/src/utils/ai/agents/tool-selector.ts
deleted file mode 100644
index b700c10f..00000000
--- a/src/utils/ai/agents/tool-selector.ts
+++ /dev/null
@@ -1,113 +0,0 @@
-import { factoryTag, type Node, node } from "@graphrefly/pure-ts/core";
-import { fromAny, type NodeInput } from "@graphrefly/pure-ts/extra";
-import { aiMeta } from "../_internal.js";
-import type { ToolDefinition } from "../adapters/core/types.js";
-
-// ---------------------------------------------------------------------------
-// toolSelector — reactive tool availability (D8 / COMPOSITION-GUIDE §31)
-// ---------------------------------------------------------------------------
-
-/**
- * Options for {@link toolSelector}.
- */
-export interface ToolSelectorOptions {
-	readonly name?: string;
-}
-
-/**
- * Reactive tool availability (COMPOSITION-GUIDE §31). Given a base tool set
- * (reactive or static) and one or more reactive predicates, emit the filtered
- * subset of tools currently allowed. Feeds into `promptNode({ tools: Node<...> })`
- * so the LLM sees a reactive menu instead of a frozen config.
- *
- * Each predicate is a `NodeInput<(tool) => boolean>`. A tool is included iff
- * **every** predicate returns `true`. An *emitted* `null` / `undefined`
- * predicate DATA value is pass-through — the tool isn't excluded on its
- * basis ("deny when explicitly `false`, not when not-yet-ready"). **Always
- * seed each predicate node with an `initial`** (e.g.
- * `node([], { initial: null })` for pass-through-while-loading, or an
- * initial predicate fn): a predicate node that has *never* emitted DATA
- * (pure SENTINEL) has **unspecified** gating — depending on activation
- * order it may or may not participate in the first-run gate (the open core
- * SENTINEL-dep first-run-gate question), so a never-seeded predicate must
- * not be relied on either way. Mirrors `toolInterceptor`'s *seed-an-`initial`*
- * contract — but NOT its throwing-predicate behaviour: a constraint that
- * *throws* tears the wave with an ERROR (no fail-closed catch), because
- * selection is not a security boundary (a loud surface beats a silent
- * deny here; pair with `toolInterceptor` for enforcement).
- * Predicate updates recompute the selected set.
- *
- * Pairs with `toolInterceptor` (§D9 / §31): **selection** controls what's
- * offered to the LLM (pre-generation UX); **interception** gates what's
- * executed after the LLM chooses (post-generation security). Tool selection
- * is NOT a security boundary — an LLM can hallucinate tool calls outside
- * its offered set; always pair with `toolInterceptor` for enforcement.
- *
- * @example
- * ```ts
- * const hasBudget = node([costMeter], (batchData, actions, ctx) => {
- *   const data = batchData.map((batch, i) => batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i]);
- *   actions.emit((data[0] as CostMeter).total < BUDGET);
- * }, { describeKind: "derived" });
- * const canDestroy = node<boolean>([], { name: "destructive-allowed", initial: false });
- * const tools = toolSelector(registry.schemas, [
- *   node([hasBudget], (batchData, actions, ctx) => {
- *     const data = batchData.map((batch, i) => batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i]);
- *     actions.emit((t) => !t.meta?.expensive || data[0] === true);
- *   }, { describeKind: "derived" }),
- *   node([canDestroy], (batchData, actions, ctx) => {
- *     const data = batchData.map((batch, i) => batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i]);
- *     actions.emit((t) => !t.meta?.destructive || data[0] === true);
- *   }, { describeKind: "derived" }),
- * ]);
- * const agent = promptNode(graph, "agent", { ..., tools });
- * ```
- */
-export function toolSelector(
-	allTools: NodeInput<readonly ToolDefinition[]>,
-	constraints: readonly NodeInput<(tool: ToolDefinition) => boolean>[],
-	opts?: ToolSelectorOptions,
-): Node<readonly ToolDefinition[]> {
-	const allToolsNode = fromAny(allTools);
-	const constraintNodes = constraints.map((c) => fromAny(c));
-	const deps = [allToolsNode, ...constraintNodes] as const;
-	return node<readonly ToolDefinition[]>(
-		deps,
-		(batchData, actions, ctx) => {
-			const data = batchData.map((batch, i) =>
-				batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-			);
-			const tools = (data[0] as readonly ToolDefinition[] | null | undefined) ?? [];
-			const preds = data.slice(1) as ReadonlyArray<
-				((t: ToolDefinition) => boolean) | null | undefined
-			>;
-			actions.emit(
-				tools.filter((tool) => {
-					for (const pred of preds) {
-						// Pass-through when a predicate hasn't settled — callers with
-						// async constraints should not have every tool silently dropped
-						// on the first emit. Constraints are "deny when false", not
-						// "deny when not yet ready".
-						if (pred == null) continue;
-						if (!pred(tool)) return false;
-					}
-					return true;
-				}),
-			);
-		},
-		{
-			name: opts?.name ?? "tool-selector",
-			describeKind: "derived",
-			meta: { ...aiMeta("tool_selector"), ...factoryTag("toolSelector") },
-			equals: (a, b) => {
-				const la = a as readonly ToolDefinition[];
-				const lb = b as readonly ToolDefinition[];
-				if (la.length !== lb.length) return false;
-				for (let i = 0; i < la.length; i++) {
-					if (la[i] !== lb[i]) return false;
-				}
-				return true;
-			},
-		},
-	);
-}
diff --git a/src/utils/ai/browser.ts b/src/utils/ai/browser.ts
deleted file mode 100644
index 76f535bc..00000000
--- a/src/utils/ai/browser.ts
+++ /dev/null
@@ -1,15 +0,0 @@
-/**
- * Browser-only surface for the AI patterns package.
- *
- * Re-exports browser-native adapters (`webllmAdapter`, `chromeNanoAdapter`)
- * and curated cascade presets that compose them (`cloudFirstPreset`,
- * `localFirstPreset`, `offlinePreset`). Import from
- * `@graphrefly/graphrefly/utils/ai/browser` in a browser bundle to opt
- * into these; the universal `@graphrefly/graphrefly/utils/ai` entry does
- * not pull them, so Node bundles stay lean.
- *
- * @module
- */
-
-export * from "./adapters/providers/browser/index.js";
-export * from "./adapters/routing/browser-presets.js";
diff --git a/src/utils/ai/extractors/cost-meter.ts b/src/utils/ai/extractors/cost-meter.ts
deleted file mode 100644
index b67119e8..00000000
--- a/src/utils/ai/extractors/cost-meter.ts
+++ /dev/null
@@ -1,135 +0,0 @@
-/**
- * Cost meter extractor — derives live cost readings from the delta topic.
- *
- * **Wave A Unit 3 rewrite:** signature takes `deltaTopic: TopicGraph<StampedDelta>`
- * instead of the old `TopicGraph<StreamChunk>`. The meter prefers real
- * `usage` deltas from the adapter; when no `usage` has been seen yet it
- * falls back to a char-based estimate over token deltas and stamps
- * `estimated: true` on the reading. Chunk count is the count of
- * token-type deltas seen (was `chunk.index + 1`).
- *
- * @module
- */
-
-import { type Node, node } from "@graphrefly/pure-ts/core";
-import type { TopicGraph } from "../../messaging/index.js";
-import { aiMeta } from "../_internal.js";
-import { sumInputTokens, sumOutputTokens } from "../adapters/core/types.js";
-import type { StampedDelta } from "../prompts/streaming.js";
-
-/** A cost meter reading from the stream. */
-export type CostMeterReading = {
-	readonly chunkCount: number;
-	readonly charCount: number;
-	readonly estimatedTokens: number;
-	/**
-	 * `true` when no adapter `usage` delta has been observed yet —
-	 * `estimatedTokens` is a char-based heuristic and should be treated as an
-	 * approximation. Flips to `false` once a real `usage` delta arrives.
-	 */
-	readonly estimated: boolean;
-};
-
-export type CostMeterOptions = {
-	/** Characters per token approximation. Default: 4 (GPT-family). */
-	charsPerToken?: number;
-	name?: string;
-};
-
-const costMeterEqual = (a: CostMeterReading, b: CostMeterReading): boolean => {
-	if (a === b) return true;
-	return (
-		a.chunkCount === b.chunkCount &&
-		a.charCount === b.charCount &&
-		a.estimatedTokens === b.estimatedTokens &&
-		a.estimated === b.estimated
-	);
-};
-
-/**
- * Mounts a cost meter on the delta topic. Prefers real `usage` deltas from
- * the provider; falls back to char-based estimation on token deltas alone
- * (with `meta.estimated: true` on the reading).
- *
- * Default structural equals suppresses DATA emission when two consecutive
- * readings are identical.
- */
-export function costMeterExtractor(
-	deltaTopic: TopicGraph<StampedDelta>,
-	opts?: CostMeterOptions,
-): Node<CostMeterReading> {
-	const charsPerToken = opts?.charsPerToken ?? 4;
-	const ZERO: CostMeterReading = {
-		chunkCount: 0,
-		charCount: 0,
-		estimatedTokens: 0,
-		estimated: true,
-	};
-	// Lock 6.D (Phase 13.6.B): clear per-stream counters on deactivation
-	// so a resubscribed cost meter starts at zero on the next cycle.
-	let cleanup: { onDeactivation: () => void } | undefined;
-	return node<CostMeterReading>(
-		[deltaTopic.latest],
-		(batchData, actions, ctx) => {
-			if (cleanup === undefined) {
-				const store = ctx.store;
-				cleanup = {
-					onDeactivation: () => {
-						delete store.chunkCount;
-						delete store.charCount;
-						delete store.usageTokens;
-						delete store.sawUsage;
-					},
-				};
-			}
-			const data = batchData.map((batch, i) =>
-				batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-			);
-			const d = data[0];
-			if (d === undefined) {
-				actions.emit(ZERO);
-				return cleanup;
-			}
-			const delta = d as StampedDelta;
-
-			if (!("chunkCount" in ctx.store)) {
-				ctx.store.chunkCount = 0;
-				ctx.store.charCount = 0;
-				ctx.store.usageTokens = 0;
-				ctx.store.sawUsage = false;
-			}
-			const store = ctx.store as {
-				chunkCount: number;
-				charCount: number;
-				usageTokens: number;
-				sawUsage: boolean;
-			};
-
-			if (delta.type === "token") {
-				store.chunkCount += 1;
-				store.charCount += delta.delta.length;
-			} else if (delta.type === "usage") {
-				store.sawUsage = true;
-				store.usageTokens = sumInputTokens(delta.usage) + sumOutputTokens(delta.usage);
-			}
-
-			const estimatedTokens = store.sawUsage
-				? store.usageTokens
-				: Math.ceil(store.charCount / charsPerToken);
-			actions.emit({
-				chunkCount: store.chunkCount,
-				charCount: store.charCount,
-				estimatedTokens,
-				estimated: !store.sawUsage,
-			});
-			return cleanup;
-		},
-		{
-			name: opts?.name ?? "cost-meter",
-			describeKind: "derived",
-			initial: ZERO,
-			meta: aiMeta("cost_meter_extractor"),
-			equals: costMeterEqual,
-		},
-	);
-}
diff --git a/src/utils/ai/extractors/keyword-flag.ts b/src/utils/ai/extractors/keyword-flag.ts
deleted file mode 100644
index bbf33a8e..00000000
--- a/src/utils/ai/extractors/keyword-flag.ts
+++ /dev/null
@@ -1,147 +0,0 @@
-/**
- * Keyword-flag extractor — scans accumulated stream text for configured patterns.
- * @module
- */
-
-import { type Node, node } from "@graphrefly/pure-ts/core";
-import { aiMeta } from "../_internal.js";
-
-/** A keyword match detected in the stream. */
-export type KeywordFlag = {
-	readonly label: string;
-	readonly pattern: RegExp;
-	readonly match: string;
-	readonly position: number;
-};
-
-export type KeywordFlagExtractorOptions = {
-	patterns: readonly { pattern: RegExp; label: string }[];
-	name?: string;
-	/**
-	 * Maximum length of any pattern's literal text. Used as an overlap window
-	 * when cursoring through the accumulated stream so matches that span
-	 * chunk boundaries aren't missed. Default: 128.
-	 */
-	maxPatternLength?: number;
-};
-
-const keywordFlagsEqual = (
-	a: readonly KeywordFlag[] | null,
-	b: readonly KeywordFlag[] | null,
-): boolean => {
-	if (a === b) return true;
-	if (a == null || b == null) return a === b;
-	if (a.length !== b.length) return false;
-	for (let i = 0; i < a.length; i++) {
-		const x = a[i];
-		const y = b[i];
-		if (
-			x.label !== y.label ||
-			x.pattern !== y.pattern ||
-			x.match !== y.match ||
-			x.position !== y.position
-		) {
-			return false;
-		}
-	}
-	return true;
-};
-
-/**
- * Mounts a keyword-flag extractor on accumulated text. Scans for all
- * configured patterns and emits an array of matches.
- *
- * **Wave A Unit 3 rewrite:** signature takes `accumulatedText: Node<string>`
- * instead of the old `TopicGraph<StreamChunk>`. Patterns are compiled once
- * at factory time (was per-chunk). `maxPatternLength` is validated at
- * factory time — any pattern whose source exceeds the window throws
- * immediately.
- *
- * Use cases: design invariant violations (`setTimeout`, `EventEmitter`), PII
- * detection (SSN, email, phone), toxicity keywords, off-track reasoning.
- *
- * **Streaming optimization.** Maintains a cursor across waves in `ctx.store`
- * so each emission scans only the delta region `accumulated.slice(scannedTo -
- * maxPatternLength)` — not the full string. Reactivation clears `ctx.store`
- * and resumes from offset 0 (COMPOSITION-GUIDE §20 RAM semantics).
- *
- * Default structural equals suppresses DATA emission when no new flags were
- * found this wave.
- */
-export function keywordFlagExtractor(
-	accumulatedText: Node<string>,
-	opts: KeywordFlagExtractorOptions,
-): Node<readonly KeywordFlag[]> {
-	const maxPatternLength = opts.maxPatternLength ?? 128;
-	// Factory-time: validate pattern literal lengths + compile once.
-	for (const p of opts.patterns) {
-		if (p.pattern.source.length > maxPatternLength) {
-			throw new Error(
-				`keywordFlagExtractor: pattern "${p.label}" literal exceeds maxPatternLength (${p.pattern.source.length} > ${maxPatternLength}); raise the option or shorten the pattern.`,
-			);
-		}
-	}
-	const compiled = opts.patterns.map((p) => ({
-		label: p.label,
-		pattern: p.pattern,
-		compiled: new RegExp(p.pattern.source, `${p.pattern.flags.replace("g", "")}g`),
-	}));
-	// Lock 6.D (Phase 13.6.B): clear scan state on deactivation so a
-	// resubscribed extractor doesn't carry over per-stream cursors.
-	let cleanup: { onDeactivation: () => void } | undefined;
-	return node<readonly KeywordFlag[]>(
-		[accumulatedText],
-		(batchData, actions, ctx) => {
-			if (cleanup === undefined) {
-				const store = ctx.store;
-				cleanup = {
-					onDeactivation: () => {
-						delete store.flags;
-						delete store.scannedTo;
-					},
-				};
-			}
-			const data = batchData.map((batch, i) =>
-				batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-			);
-			const text = data[0];
-			if (text == null) {
-				actions.emit([]);
-				return cleanup;
-			}
-			const accumulated = text as string;
-
-			if (!("flags" in ctx.store)) {
-				ctx.store.flags = [] as KeywordFlag[];
-				ctx.store.scannedTo = 0;
-			}
-			const flags = ctx.store.flags as KeywordFlag[];
-			const scannedTo = ctx.store.scannedTo as number;
-
-			// Scan the delta plus an overlap window so matches that span
-			// chunk boundaries (e.g. "EventE" + "mitter") are still found.
-			const startOffset = Math.max(0, scannedTo - maxPatternLength);
-			const region = accumulated.slice(startOffset);
-			let added = false;
-			for (const { pattern, label, compiled: re } of compiled) {
-				re.lastIndex = 0;
-				for (const m of region.matchAll(re)) {
-					const pos = startOffset + (m.index ?? 0);
-					if (pos + m[0].length <= scannedTo) continue;
-					flags.push({ label, pattern, match: m[0], position: pos });
-					added = true;
-				}
-			}
-			ctx.store.scannedTo = accumulated.length;
-			actions.emit(added ? [...flags] : flags.slice());
-			return cleanup;
-		},
-		{
-			name: opts.name ?? "keyword-flag-extractor",
-			describeKind: "derived",
-			initial: [],
-			meta: aiMeta("keyword_flag_extractor"),
-			equals: keywordFlagsEqual,
-		},
-	);
-}
diff --git a/src/utils/ai/extractors/stream-extractor.ts b/src/utils/ai/extractors/stream-extractor.ts
deleted file mode 100644
index 813ad7d5..00000000
--- a/src/utils/ai/extractors/stream-extractor.ts
+++ /dev/null
@@ -1,60 +0,0 @@
-/**
- * Generic stream extractor — mounts an extract function on accumulated text.
- *
- * **Wave A Unit 3 rewrite:** signature changed from
- * `streamExtractor(topic: TopicGraph<StreamChunk>, fn)` to
- * `streamExtractor(accumulatedText: Node<string>, fn)`. The Unit 2 delta-
- * topic redesign removed the per-chunk `accumulated` field; callers pass
- * `streamingPromptNode(...).accumulatedText` (or any other `Node<string>`
- * source of accumulated text). Source-agnostic — the extractor doesn't care
- * whether the text came from an LLM, WebSocket, SSE tail, or file reader.
- *
- * @module
- */
-
-import { type Node, node } from "@graphrefly/pure-ts/core";
-import { aiMeta } from "../_internal.js";
-
-/**
- * Mounts an extractor function on a reactive accumulated-text source. Returns
- * a derived node that emits extracted values as the text grows.
- *
- * @param accumulatedText - Reactive `Node<string>` of accumulated text.
- * @param extractFn - `(accumulated: string) => T | null`.
- * @param opts - Optional name + structural equals.
- * @returns Derived node emitting extracted values.
- */
-export function streamExtractor<T>(
-	accumulatedText: Node<string>,
-	extractFn: (accumulated: string) => T | null,
-	opts?: {
-		name?: string;
-		/**
-		 * Optional structural equals for the extractor output. When two
-		 * consecutive chunks produce structurally-equal outputs, the framework
-		 * emits `RESOLVED` instead of `DATA`, saving downstream work. Default:
-		 * reference equality (`Object.is`). The library cannot know your
-		 * output shape — supply this when your `extractFn` returns structured
-		 * objects or arrays.
-		 */
-		equals?: (a: T | null, b: T | null) => boolean;
-	},
-): Node<T | null> {
-	return node<T | null>(
-		[accumulatedText],
-		(batchData, actions, ctx) => {
-			const data = batchData.map((batch, i) =>
-				batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-			);
-			const text = data[0];
-			actions.emit(text == null ? null : extractFn(text as string));
-		},
-		{
-			name: opts?.name ?? "extractor",
-			describeKind: "derived",
-			initial: null,
-			meta: aiMeta("stream_extractor"),
-			...(opts?.equals ? { equals: opts.equals } : {}),
-		},
-	);
-}
diff --git a/src/utils/ai/extractors/tool-call.ts b/src/utils/ai/extractors/tool-call.ts
deleted file mode 100644
index a9cbfc62..00000000
--- a/src/utils/ai/extractors/tool-call.ts
+++ /dev/null
@@ -1,155 +0,0 @@
-/**
- * Tool-call extractor — scans accumulated stream text for complete JSON tool call objects.
- * @module
- */
-
-import { type Node, node } from "@graphrefly/pure-ts/core";
-import { aiMeta } from "../_internal.js";
-
-/** A tool call detected in the stream. */
-export type ExtractedToolCall = {
-	readonly name: string;
-	readonly arguments: Record<string, unknown>;
-	readonly raw: string;
-	readonly startIndex: number;
-};
-
-const toolCallsEqual = (
-	a: readonly ExtractedToolCall[] | null,
-	b: readonly ExtractedToolCall[] | null,
-): boolean => {
-	if (a === b) return true;
-	if (a == null || b == null) return a === b;
-	if (a.length !== b.length) return false;
-	for (let i = 0; i < a.length; i++) {
-		const x = a[i];
-		const y = b[i];
-		if (x.startIndex !== y.startIndex || x.name !== y.name || x.raw !== y.raw) {
-			return false;
-		}
-	}
-	return true;
-};
-
-/**
- * Mounts a tool-call extractor on a streaming topic. Scans accumulated text
- * for complete JSON objects containing `"name"` and `"arguments"` keys (the
- * standard tool_call shape). Partial JSON is ignored until the closing brace.
- *
- * Feeds into the tool interception chain for reactive tool gating mid-stream.
- *
- * **Streaming optimization.** Maintains a cursor (`scanFrom`) in `ctx.store`
- * so each chunk resumes brace-scanning from the position after the last
- * complete parse (or the last incomplete open brace). Already-parsed objects
- * are not re-parsed. Default structural equals suppresses DATA emission when
- * no new tool call completed this chunk.
- */
-export function toolCallExtractor(
-	accumulatedText: Node<string>,
-	opts?: { name?: string },
-): Node<readonly ExtractedToolCall[]> {
-	// Lock 6.D (Phase 13.6.B): clear scan state on deactivation so a
-	// resubscribed extractor doesn't ship stale per-stream cursors.
-	let cleanup: { onDeactivation: () => void } | undefined;
-	return node<readonly ExtractedToolCall[]>(
-		[accumulatedText],
-		(batchData, actions, ctx) => {
-			if (cleanup === undefined) {
-				const store = ctx.store;
-				cleanup = {
-					onDeactivation: () => {
-						delete store.calls;
-						delete store.scanFrom;
-					},
-				};
-			}
-			const data = batchData.map((batch, i) =>
-				batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-			);
-			const text = data[0];
-			if (text == null) {
-				actions.emit([]);
-				return cleanup;
-			}
-			const accumulated = text as string;
-
-			if (!("calls" in ctx.store)) {
-				ctx.store.calls = [] as ExtractedToolCall[];
-				ctx.store.scanFrom = 0;
-			}
-			const calls = ctx.store.calls as ExtractedToolCall[];
-			let i = ctx.store.scanFrom as number;
-			let added = false;
-
-			while (i < accumulated.length) {
-				const start = accumulated.indexOf("{", i);
-				if (start === -1) {
-					ctx.store.scanFrom = accumulated.length;
-					break;
-				}
-				let depth = 0;
-				let end = -1;
-				let inString = false;
-				for (let j = start; j < accumulated.length; j++) {
-					const ch = accumulated[j];
-					if (inString) {
-						if (ch === "\\" && j + 1 < accumulated.length) {
-							j++; // skip escaped character
-						} else if (ch === '"') {
-							inString = false;
-						}
-					} else if (ch === '"') {
-						inString = true;
-					} else if (ch === "{") {
-						depth++;
-					} else if (ch === "}") {
-						depth--;
-						if (depth === 0) {
-							end = j;
-							break;
-						}
-					}
-				}
-				if (end === -1) {
-					// Incomplete — resume brace-scanning from this open brace
-					// next chunk. Do NOT advance past it.
-					ctx.store.scanFrom = start;
-					break;
-				}
-				const raw = accumulated.slice(start, end + 1);
-				try {
-					const parsed = JSON.parse(raw) as Record<string, unknown>;
-					if (
-						typeof parsed.name === "string" &&
-						parsed.arguments != null &&
-						typeof parsed.arguments === "object"
-					) {
-						calls.push({
-							name: parsed.name,
-							arguments: parsed.arguments as Record<string, unknown>,
-							raw,
-							startIndex: start,
-						});
-						added = true;
-					}
-				} catch {
-					// Not valid JSON — skip
-				}
-				i = end + 1;
-				ctx.store.scanFrom = i;
-			}
-
-			// Always return a fresh copy so downstream never holds a live
-			// reference to ctx.store.calls.
-			actions.emit(added ? [...calls] : calls.slice());
-			return cleanup;
-		},
-		{
-			name: opts?.name ?? "tool-call-extractor",
-			describeKind: "derived",
-			initial: [],
-			meta: aiMeta("tool_call_extractor"),
-			equals: toolCallsEqual,
-		},
-	);
-}
diff --git a/src/utils/ai/graph-integration/gauges-as-context.ts b/src/utils/ai/graph-integration/gauges-as-context.ts
deleted file mode 100644
index 69a85c77..00000000
--- a/src/utils/ai/graph-integration/gauges-as-context.ts
+++ /dev/null
@@ -1,124 +0,0 @@
-// ---------------------------------------------------------------------------
-// gaugesAsContext
-// ---------------------------------------------------------------------------
-
-import type { Actor } from "@graphrefly/pure-ts/core";
-import type { Graph } from "@graphrefly/pure-ts/graph";
-
-export type GaugesAsContextOptions = {
-	/** Group gauges by `meta.tags` (default true). */
-	groupByTags?: boolean;
-	/** Separator between gauge lines (default "\n"). */
-	separator?: string;
-	/**
-	 * V0 delta mode (§6.0b): only include nodes whose `v.version` exceeds
-	 * the corresponding entry in this map. Nodes without V0 or not in the
-	 * map are always included. Callers maintain this map across calls.
-	 *
-	 * The `id` field guards against node replacement: if a node is removed
-	 * and re-added under the same name (new id), it is always included.
-	 */
-	sinceVersion?: ReadonlyMap<string, { id: string; version: number }>;
-};
-
-/**
- * Format a graph's readable (gauge) nodes as a context string for LLM
- * system prompts.
- *
- * Gauges are nodes with `meta.description` or `meta.format`. Values are
- * formatted using `meta.format` and `meta.unit` hints.
- *
- * @param graph - The graph to introspect.
- * @param actor - Optional actor for guard-scoped describe.
- * @param options - Formatting options.
- * @returns A formatted string ready for system prompt injection.
- */
-export function gaugesAsContext(
-	graph: Graph,
-	actor?: Actor,
-	options?: GaugesAsContextOptions,
-): string {
-	const described = graph.describe({ actor, detail: "full" });
-	const groupByTags = options?.groupByTags ?? true;
-	const separator = options?.separator ?? "\n";
-
-	type GaugeEntry = { path: string; description: string; formatted: string };
-	const entries: GaugeEntry[] = [];
-
-	const sinceVersion = options?.sinceVersion;
-	for (const [path, node] of Object.entries(described.nodes)) {
-		const meta = node.meta ?? {};
-		const desc = meta.description as string | undefined;
-		const format = meta.format as string | undefined;
-		// Must have description or format to be a gauge
-		if (!desc && !format) continue;
-		// V0 delta filter: skip nodes unchanged since last seen version (§6.0b).
-		if (sinceVersion != null && node.v != null) {
-			const lastSeen = sinceVersion.get(path);
-			if (lastSeen != null && lastSeen.id === node.v.id && node.v.version <= lastSeen.version)
-				continue;
-		}
-
-		const label = desc ?? path;
-		const value = node.value;
-		const unit = meta.unit as string | undefined;
-
-		let formatted: string;
-		if (format === "currency" && typeof value === "number") {
-			formatted = `$${value.toFixed(2)}`;
-		} else if (format === "percentage" && typeof value === "number") {
-			formatted = `${(value * 100).toFixed(1)}%`;
-		} else if (value === undefined || value === null) {
-			formatted = "(no value)";
-		} else {
-			formatted = String(value);
-		}
-
-		if (unit && format !== "currency" && format !== "percentage") {
-			formatted = `${formatted} ${unit}`;
-		}
-
-		entries.push({ path, description: label, formatted });
-	}
-
-	if (entries.length === 0) return "";
-
-	if (groupByTags) {
-		const tagGroups = new Map<string, GaugeEntry[]>();
-		const ungrouped: GaugeEntry[] = [];
-
-		for (const entry of entries) {
-			const node = described.nodes[entry.path]!;
-			const tags = node.meta?.tags as string[] | undefined;
-			if (tags && tags.length > 0) {
-				// Use first tag for grouping to avoid duplicating entries across groups
-				const tag = tags[0]!;
-				let group = tagGroups.get(tag);
-				if (!group) {
-					group = [];
-					tagGroups.set(tag, group);
-				}
-				group.push(entry);
-			} else {
-				ungrouped.push(entry);
-			}
-		}
-
-		if (tagGroups.size === 0) {
-			return entries.map((e) => `- ${e.description}: ${e.formatted}`).join(separator);
-		}
-
-		const sections: string[] = [];
-		for (const [tag, group] of [...tagGroups.entries()].sort((a, b) => a[0].localeCompare(b[0]))) {
-			sections.push(
-				`[${tag}]${separator}${group.map((e) => `- ${e.description}: ${e.formatted}`).join(separator)}`,
-			);
-		}
-		if (ungrouped.length > 0) {
-			sections.push(ungrouped.map((e) => `- ${e.description}: ${e.formatted}`).join(separator));
-		}
-		return sections.join(separator + separator);
-	}
-
-	return entries.map((e) => `- ${e.description}: ${e.formatted}`).join(separator);
-}
diff --git a/src/utils/ai/graph-integration/graph-from-spec.ts b/src/utils/ai/graph-integration/graph-from-spec.ts
deleted file mode 100644
index ff61e71e..00000000
--- a/src/utils/ai/graph-integration/graph-from-spec.ts
+++ /dev/null
@@ -1,183 +0,0 @@
-// ---------------------------------------------------------------------------
-// graphFromSpec
-// ---------------------------------------------------------------------------
-
-import { COMPLETE, ERROR, type Node, node } from "@graphrefly/pure-ts/core";
-import { fromAny, type NodeInput, switchMap } from "@graphrefly/pure-ts/extra";
-import type { Graph } from "@graphrefly/pure-ts/graph";
-import { compileSpec, type GraphSpec, type GraphSpecCatalog } from "../../graphspec/index.js";
-import { resolveToolHandlerResult, stripFences } from "../_internal.js";
-import type { ChatMessage, LLMAdapter, LLMResponse } from "../adapters/core/types.js";
-
-export type GraphFromSpecOptions = {
-	model?: string;
-	temperature?: number;
-	maxTokens?: number;
-	/** Fn/source catalog for resolving named node factories from the LLM-generated spec. */
-	catalog?: GraphSpecCatalog;
-	/** Extra instructions appended to the system prompt. */
-	systemPromptExtra?: string;
-	/**
-	 * Optional AbortSignal forwarded to `adapter.invoke({ signal })`. Lets
-	 * callers cancel the in-flight LLM call (e.g. when the reactive variant
-	 * supersedes mid-flight). When the signal aborts, the underlying call
-	 * propagates the abort and `graphFromSpec` rejects with the abort reason.
-	 */
-	signal?: AbortSignal;
-};
-
-const GRAPH_FROM_SPEC_SYSTEM_PROMPT = `You are a graph architect for GraphReFly, a reactive graph protocol.
-
-Given a natural-language description, produce a JSON graph specification with this structure:
-
-{
-  "name": "<graph_name>",
-  "nodes": {
-    "<node_name>": {
-      "type": "state" | "derived" | "producer" | "effect" | "operator",
-      "initial": <initial_value_for_state_nodes>,
-      "deps": ["<dep_node_name>", ...],
-      "meta": {
-        "description": "<human-readable purpose>",
-        "type": "string" | "number" | "boolean" | "integer" | "enum",
-        "range": [min, max],
-        "values": ["a", "b"],
-        "format": "currency" | "percentage" | "status",
-        "access": "human" | "llm" | "both" | "system",
-        "unit": "<unit>",
-        "tags": ["<tag>"]
-      }
-    }
-  }
-}
-
-Rules:
-- "state" nodes have no deps and hold user/LLM-writable values (knobs). Use "initial" for the starting value.
-- "derived" nodes have deps and compute from them (pure, no side effects).
-- "effect" nodes have deps but produce side effects (no return value).
-- "producer" nodes have no deps but generate values asynchronously.
-- "operator" nodes are parameterized transformations with deps.
-- Use "deps" inside each node to declare dependencies — no separate "edges" array.
-- meta.description is required for every node.
-- Return ONLY valid JSON, no markdown fences or commentary.`;
-
-/**
- * Ask an LLM to compose a Graph from a natural-language description.
- *
- * The LLM returns a JSON {@link GraphSpec} which is validated, catalog-expanded,
- * and instantiated via {@link compileSpec} (gains catalog validation, template
- * expansion, and feedback wiring that `Graph.fromSnapshot` bypasses).
- *
- * @param naturalLanguage - The problem/use-case description.
- * @param adapter - LLM adapter for the generation call.
- * @param opts - Model options and optional catalog for named node factories.
- * @returns A constructed Graph.
- * @throws On invalid LLM output, validation failure, or unresolvable deps.
- */
-export async function graphFromSpec(
-	naturalLanguage: string,
-	adapter: LLMAdapter,
-	opts?: GraphFromSpecOptions,
-): Promise<Graph> {
-	const systemPrompt = opts?.systemPromptExtra
-		? `${GRAPH_FROM_SPEC_SYSTEM_PROMPT}\n\n${opts.systemPromptExtra}`
-		: GRAPH_FROM_SPEC_SYSTEM_PROMPT;
-
-	const messages: ChatMessage[] = [
-		{ role: "system", content: systemPrompt },
-		{ role: "user", content: naturalLanguage },
-	];
-
-	const rawResult = adapter.invoke(messages, {
-		model: opts?.model,
-		temperature: opts?.temperature ?? 0,
-		maxTokens: opts?.maxTokens,
-		signal: opts?.signal,
-	});
-
-	const response = (await resolveToolHandlerResult(rawResult)) as LLMResponse;
-	let content = response.content.trim();
-
-	// Strip markdown fences if present (handles trailing commentary after ```)
-	if (content.startsWith("```")) {
-		content = stripFences(content);
-	}
-
-	let parsed: unknown;
-	try {
-		parsed = JSON.parse(content);
-	} catch {
-		throw new Error(`graphFromSpec: LLM response is not valid JSON: ${content.slice(0, 200)}`);
-	}
-
-	return compileSpec(parsed as GraphSpec, { catalog: opts?.catalog });
-}
-
-/**
- * Reactive variant of {@link graphFromSpec}: re-invokes the LLM and
- * recompiles the graph whenever `input` emits a new natural-language
- * description. Useful inside the harness or refine loop when the spec text
- * itself is a reactive value (e.g. fed by a `node([], { initial: ... })` knob, a memory
- * snapshot, or an upstream `promptNode` output).
- *
- * **Supersede:** when the input changes mid-flight, switchMap tears the
- * inner producer down. The producer's cleanup aborts the in-flight LLM
- * call via an internal `AbortController` (threaded into `graphFromSpec`'s
- * new `signal` option) AND destroys any Graph that lands after cancel —
- * no token leak, no unreferenced compiled graphs. If the user's input
- * already changed by the time the LLM responds, the about-to-be-discarded
- * Graph is freed instead of orphaned.
- *
- * **Lifetime of the latest emitted Graph:** the caller owns each Graph
- * that actually reaches them. If you keep multiple historical values, call
- * `prev?.destroy()` before storing the new one.
- *
- * @param input - Reactive source of natural-language descriptions.
- * @param adapter - LLM adapter for the generation call.
- * @param opts - Model options and optional catalog for named node factories.
- * @returns `Node<Graph | null>` — emits the latest compiled graph, or `null`
- *           while the input is empty / unsettled.
- */
-export function graphFromSpecReactive(
-	input: NodeInput<string>,
-	adapter: LLMAdapter,
-	opts?: GraphFromSpecOptions,
-): Node<Graph | null> {
-	const inputNode = fromAny(input);
-	return switchMap<string, Graph | null>(inputNode, (nl) => {
-		if (!nl || typeof nl !== "string" || nl.trim().length === 0) {
-			return node<Graph | null>([], { initial: null });
-		}
-		// Producer guarantees a single DATA + COMPLETE per upstream wave —
-		// matches the `promptNode` shape (see Unit 1 review). On supersede,
-		// switchMap tears down the producer; cleanup aborts the in-flight LLM
-		// call AND destroys any Graph that lands post-abort (would otherwise
-		// leak its mounted state nodes / storage handles until GC).
-		return node<Graph | null>(
-			(_data, actions) => {
-				const controller = new AbortController();
-				let cancelled = false;
-				graphFromSpec(nl, adapter, { ...opts, signal: controller.signal })
-					.then((g) => {
-						if (cancelled) {
-							g.destroy();
-							return;
-						}
-						actions.emit(g);
-						actions.down([[COMPLETE]]);
-					})
-					.catch((err) => {
-						if (cancelled) return;
-						actions.down([[ERROR, err]]);
-					});
-				return {
-					onDeactivation: () => {
-						cancelled = true;
-						controller.abort();
-					},
-				};
-			},
-			{ describeKind: "producer", ...{ name: "graphFromSpec::call" } },
-		);
-	});
-}
diff --git a/src/utils/ai/graph-integration/knobs-as-tools.ts b/src/utils/ai/graph-integration/knobs-as-tools.ts
deleted file mode 100644
index 8d9f00a7..00000000
--- a/src/utils/ai/graph-integration/knobs-as-tools.ts
+++ /dev/null
@@ -1,162 +0,0 @@
-// ---------------------------------------------------------------------------
-// 5.4 — LLM tool integration
-// ---------------------------------------------------------------------------
-
-import type { Actor } from "@graphrefly/pure-ts/core";
-import type { Graph } from "@graphrefly/pure-ts/graph";
-import type { ToolDefinition } from "../adapters/core/types.js";
-
-/** OpenAI function-calling tool schema. */
-export type OpenAIToolSchema = {
-	readonly type: "function";
-	readonly function: {
-		readonly name: string;
-		readonly description: string;
-		readonly parameters: Record<string, unknown>;
-	};
-};
-
-/** MCP (Model Context Protocol) tool schema. */
-export type McpToolSchema = {
-	readonly name: string;
-	readonly description: string;
-	readonly inputSchema: Record<string, unknown>;
-};
-
-/** Result of {@link knobsAsTools}. */
-export type KnobsAsToolsResult = {
-	/** OpenAI function-calling tool schemas. */
-	readonly openai: readonly OpenAIToolSchema[];
-	/** MCP tool schemas. */
-	readonly mcp: readonly McpToolSchema[];
-	/** GraphReFly ToolDefinitions with handlers that call `graph.set()`. */
-	readonly definitions: readonly ToolDefinition[];
-};
-
-/**
- * Build a JSON Schema `properties.value` descriptor from a node's meta fields.
- *
- * Maps `meta.type`, `meta.range`, `meta.values`, `meta.format`, and `meta.unit`
- * to a JSON Schema property definition.
- */
-function metaToJsonSchema(meta: Record<string, unknown>): Record<string, unknown> {
-	const schema: Record<string, unknown> = {};
-
-	const metaType = meta.type as string | undefined;
-	if (metaType === "enum" && Array.isArray(meta.values)) {
-		schema.type = "string";
-		schema.enum = meta.values;
-	} else if (metaType === "integer") {
-		schema.type = "integer";
-	} else if (metaType === "number") {
-		schema.type = "number";
-	} else if (metaType === "boolean") {
-		schema.type = "boolean";
-	} else if (metaType === "string") {
-		schema.type = "string";
-	} else {
-		// Unknown or unspecified — accept anything
-		schema.type = ["string", "number", "boolean"];
-	}
-
-	if (Array.isArray(meta.range) && meta.range.length === 2) {
-		schema.minimum = meta.range[0];
-		schema.maximum = meta.range[1];
-	}
-
-	if (typeof meta.format === "string") {
-		schema.description = `Format: ${meta.format}`;
-	}
-
-	if (typeof meta.unit === "string") {
-		if (schema.description) {
-			schema.description += ` (${meta.unit})`;
-		} else {
-			schema.description = `Unit: ${meta.unit}`;
-		}
-	}
-
-	return schema;
-}
-
-/**
- * Derive tool schemas from a graph's writable (knob) nodes.
- *
- * Knobs are state nodes whose `meta.access` is `"llm"`, `"both"`, or absent
- * (default: writable). Each knob becomes a tool that calls `graph.set()`.
- *
- * Speaks **domain language** (spec §5.4): the returned schemas use node names
- * and meta descriptions — no protocol internals exposed.
- *
- * @param graph - The graph to introspect.
- * @param actor - Optional actor for guard-scoped describe.
- * @returns OpenAI, MCP, and GraphReFly tool schemas.
- */
-export function knobsAsTools(graph: Graph, actor?: Actor): KnobsAsToolsResult {
-	const described = graph.describe({ actor, detail: "full" });
-	const openai: OpenAIToolSchema[] = [];
-	const mcp: McpToolSchema[] = [];
-	const definitions: ToolDefinition[] = [];
-
-	for (const [path, node] of Object.entries(described.nodes)) {
-		// Only state nodes are writable knobs
-		if (node.type !== "state") continue;
-
-		// Skip meta companion nodes (§2.3)
-		if (path.includes("::__meta__::")) continue;
-
-		// Skip terminal-state nodes (§1.3.4 — no further messages after COMPLETE/ERROR)
-		if (node.status === "completed" || node.status === "errored") continue;
-
-		// Skip if access explicitly excludes LLM
-		const meta = node.meta ?? {};
-		const access = meta.access as string | undefined;
-		if (access === "human" || access === "system") continue;
-
-		const description = (meta.description as string) ?? `Set the value of ${path}`;
-		const valueSchema = metaToJsonSchema(meta);
-
-		const parameterSchema: Record<string, unknown> = {
-			type: "object",
-			required: ["value"],
-			properties: {
-				value: valueSchema,
-			},
-			additionalProperties: false,
-		};
-
-		// OpenAI requires [a-zA-Z0-9_-] in function names; sanitize :: separators
-		const sanitizedName = path.replace(/::/g, "__");
-
-		openai.push({
-			type: "function",
-			function: {
-				name: sanitizedName,
-				description,
-				parameters: parameterSchema,
-			},
-		});
-
-		mcp.push({
-			name: path,
-			description,
-			inputSchema: parameterSchema,
-		});
-
-		const graphRef = graph;
-		const actorRef = actor;
-		const nv = node.v;
-		definitions.push({
-			name: path,
-			description,
-			parameters: parameterSchema,
-			handler(args: Record<string, unknown>) {
-				graphRef.set(path, args.value, actorRef ? { actor: actorRef } : undefined);
-				return args.value;
-			},
-			...(nv != null ? { version: { id: nv.id, version: nv.version } } : {}),
-		});
-	}
-
-	return { openai, mcp, definitions };
-}
diff --git a/src/utils/ai/graph-integration/suggest-strategy.ts b/src/utils/ai/graph-integration/suggest-strategy.ts
deleted file mode 100644
index 18525bbf..00000000
--- a/src/utils/ai/graph-integration/suggest-strategy.ts
+++ /dev/null
@@ -1,211 +0,0 @@
-// ---------------------------------------------------------------------------
-// suggestStrategy
-// ---------------------------------------------------------------------------
-
-import type { Actor, Node } from "@graphrefly/pure-ts/core";
-import { COMPLETE, ERROR, node } from "@graphrefly/pure-ts/core";
-import { fromAny, type NodeInput, switchMap, withLatestFrom } from "@graphrefly/pure-ts/extra";
-import type { Graph } from "@graphrefly/pure-ts/graph";
-import { resolveToolHandlerResult } from "../_internal.js";
-import type { ChatMessage, LLMAdapter, LLMResponse } from "../adapters/core/types.js";
-
-/** A single operation in a strategy plan. */
-export type StrategyOperation =
-	| {
-			readonly type: "add_node";
-			readonly name: string;
-			readonly nodeType: string;
-			readonly meta?: Record<string, unknown>;
-			readonly initial?: unknown;
-	  }
-	| { readonly type: "remove_node"; readonly name: string }
-	| { readonly type: "connect"; readonly from: string; readonly to: string }
-	| { readonly type: "disconnect"; readonly from: string; readonly to: string }
-	| { readonly type: "set_value"; readonly name: string; readonly value: unknown }
-	| {
-			readonly type: "update_meta";
-			readonly name: string;
-			readonly key: string;
-			readonly value: unknown;
-	  };
-
-/** Structured strategy plan returned by {@link suggestStrategy}. */
-export type StrategyPlan = {
-	readonly summary: string;
-	readonly operations: readonly StrategyOperation[];
-	readonly reasoning: string;
-};
-
-export type SuggestStrategyOptions = {
-	model?: string;
-	temperature?: number;
-	maxTokens?: number;
-	actor?: Actor;
-	/**
-	 * Optional AbortSignal forwarded to `adapter.invoke({ signal })`. Lets
-	 * callers cancel the in-flight LLM call (e.g. when the reactive variant
-	 * supersedes mid-flight). When the signal aborts, the underlying call
-	 * propagates the abort and `suggestStrategy` rejects with the abort reason.
-	 */
-	signal?: AbortSignal;
-};
-
-const SUGGEST_STRATEGY_SYSTEM_PROMPT = `You are a reactive graph optimizer for GraphReFly.
-
-Given a graph's current structure (from describe()) and a problem statement, suggest topology and parameter changes to solve the problem.
-
-Return ONLY valid JSON with this structure:
-{
-  "summary": "<one-line summary of the strategy>",
-  "reasoning": "<explanation of why these changes help>",
-  "operations": [
-    { "type": "add_node", "name": "<name>", "nodeType": "state|derived|effect|producer|operator", "meta": {...}, "initial": <value> },
-    { "type": "remove_node", "name": "<name>" },
-    { "type": "connect", "from": "<source>", "to": "<target>" },
-    { "type": "disconnect", "from": "<source>", "to": "<target>" },
-    { "type": "set_value", "name": "<name>", "value": <new_value> },
-    { "type": "update_meta", "name": "<name>", "key": "<meta_key>", "value": <new_value> }
-  ]
-}
-
-Rules:
-- Only suggest operations that reference existing nodes (for remove/disconnect/set_value/update_meta) or new nodes you define (for add_node).
-- Keep changes minimal — prefer the smallest set of operations that solves the problem.
-- Return ONLY valid JSON, no markdown fences or commentary.`;
-
-/**
- * Ask an LLM to analyze a graph and suggest topology/parameter changes
- * to solve a stated problem.
- *
- * Returns a structured plan — does NOT auto-apply. The caller reviews
- * and selectively applies operations.
- *
- * @param graph - The graph to analyze.
- * @param problem - Natural-language problem statement.
- * @param adapter - LLM adapter for the analysis call.
- * @param opts - Model and actor options.
- * @returns A structured strategy plan.
- * @throws On invalid LLM output.
- */
-export async function suggestStrategy(
-	graph: Graph,
-	problem: string,
-	adapter: LLMAdapter,
-	opts?: SuggestStrategyOptions,
-): Promise<StrategyPlan> {
-	const { expand: _, ...described } = graph.describe({ actor: opts?.actor, detail: "standard" });
-
-	const messages: ChatMessage[] = [
-		{ role: "system", content: SUGGEST_STRATEGY_SYSTEM_PROMPT },
-		{
-			role: "user",
-			content: JSON.stringify({
-				graph: described,
-				problem,
-			}),
-		},
-	];
-
-	const rawResult = adapter.invoke(messages, {
-		model: opts?.model,
-		temperature: opts?.temperature ?? 0,
-		maxTokens: opts?.maxTokens,
-		signal: opts?.signal,
-	});
-
-	const response = (await resolveToolHandlerResult(rawResult)) as LLMResponse;
-	let content = response.content.trim();
-
-	if (content.startsWith("```")) {
-		content = content.replace(/^```(?:json)?\s*/, "").replace(/\s*```$/, "");
-	}
-
-	let parsed: unknown;
-	try {
-		parsed = JSON.parse(content);
-	} catch {
-		throw new Error(`suggestStrategy: LLM response is not valid JSON: ${content.slice(0, 200)}`);
-	}
-
-	const plan = parsed as Record<string, unknown>;
-
-	if (typeof plan.summary !== "string") {
-		throw new Error("suggestStrategy: missing 'summary' in response");
-	}
-	if (typeof plan.reasoning !== "string") {
-		throw new Error("suggestStrategy: missing 'reasoning' in response");
-	}
-	if (!Array.isArray(plan.operations)) {
-		throw new Error("suggestStrategy: missing 'operations' array in response");
-	}
-
-	return {
-		summary: plan.summary,
-		reasoning: plan.reasoning,
-		operations: plan.operations as readonly StrategyOperation[],
-	};
-}
-
-/**
- * Reactive variant of {@link suggestStrategy}: re-invokes the LLM whenever
- * the `problem` source emits, sampling the latest `graph` value (via
- * `withLatestFrom`) to describe. The graph is the *secondary* dep — only
- * problem changes re-trigger analysis. This breaks the feedback cycle that
- * would otherwise arise if downstream consumers wired `apply(plan)` back
- * into the same graph node (graph mutation must not auto-fire a re-analysis).
- *
- * @param graph - Reactive source of graphs to analyze.
- * @param problem - Reactive source of natural-language problem statements.
- * @param adapter - LLM adapter for the analysis call.
- * @param opts - Model and actor options.
- * @returns `Node<StrategyPlan | null>` — emits the latest plan, or `null`
- *           while inputs are unsettled.
- */
-export function suggestStrategyReactive(
-	graph: Node<Graph | null>,
-	problem: NodeInput<string>,
-	adapter: LLMAdapter,
-	opts?: SuggestStrategyOptions,
-): Node<StrategyPlan | null> {
-	const problemNode = fromAny(problem);
-	// problem is primary (re-triggers on change); graph is sampled — no
-	// graph-edit-feedback loop to suggestStrategy when callers apply ops.
-	const paired = withLatestFrom(problemNode as Node<unknown>, graph as Node<unknown>);
-	return switchMap<unknown, StrategyPlan | null>(paired, (pair) => {
-		if (pair == null) return node<StrategyPlan | null>([], { initial: null });
-		const [pText, g] = pair as [string | null, Graph | null];
-		if (!g || !pText || typeof pText !== "string" || pText.trim().length === 0) {
-			return node<StrategyPlan | null>([], { initial: null });
-		}
-		// QA-fix: skip rather than ERROR if the sampled Graph was destroyed
-		// between the `withLatestFrom` sample and this project fn. Common when
-		// a caller's reactive `graph: Node<Graph | null>` cycles graphs faster
-		// than `suggestStrategy` resolves; the supersede was the user's intent,
-		// so emitting null here matches "input not ready" semantics rather
-		// than surfacing a spurious ERROR on the StrategyPlan stream.
-		if (g.destroyed) return node<StrategyPlan | null>([], { initial: null });
-		return node<StrategyPlan | null>(
-			(_data, actions) => {
-				const controller = new AbortController();
-				let cancelled = false;
-				suggestStrategy(g, pText, adapter, { ...opts, signal: controller.signal })
-					.then((plan) => {
-						if (cancelled) return;
-						actions.emit(plan);
-						actions.down([[COMPLETE]]);
-					})
-					.catch((err) => {
-						if (cancelled) return;
-						actions.down([[ERROR, err]]);
-					});
-				return {
-					onDeactivation: () => {
-						cancelled = true;
-						controller.abort();
-					},
-				};
-			},
-			{ describeKind: "producer", ...{ name: "suggestStrategy::call" } },
-		);
-	});
-}
diff --git a/src/utils/ai/graph-integration/validate-graph-def.ts b/src/utils/ai/graph-integration/validate-graph-def.ts
deleted file mode 100644
index acfddf64..00000000
--- a/src/utils/ai/graph-integration/validate-graph-def.ts
+++ /dev/null
@@ -1,95 +0,0 @@
-// ---------------------------------------------------------------------------
-// validateGraphDef
-// ---------------------------------------------------------------------------
-
-/** Validation result from {@link validateGraphDef}. */
-export type GraphDefValidation = {
-	readonly valid: boolean;
-	readonly errors: readonly string[];
-};
-
-const VALID_NODE_TYPES = new Set(["state", "derived", "producer", "operator", "effect"]);
-
-/**
- * Validate an LLM-generated graph definition before passing to
- * `Graph.fromSnapshot()`.
- *
- * Checks:
- * - Required fields: `name`, `nodes`, `edges`
- * - Node types are valid enum values
- * - Edge `from`/`to` reference existing nodes
- * - No duplicate edge entries
- *
- * @param def - The graph definition to validate (parsed JSON).
- * @returns Validation result with errors array.
- */
-export function validateGraphDef(def: unknown): GraphDefValidation {
-	const errors: string[] = [];
-
-	if (def == null || typeof def !== "object") {
-		return { valid: false, errors: ["Definition must be a non-null object"] };
-	}
-
-	const d = def as Record<string, unknown>;
-
-	if (typeof d.name !== "string" || d.name.length === 0) {
-		errors.push("Missing or empty 'name' field");
-	}
-
-	if (d.nodes == null || typeof d.nodes !== "object" || Array.isArray(d.nodes)) {
-		errors.push("Missing or invalid 'nodes' field (must be an object)");
-		return { valid: false, errors };
-	}
-
-	const nodeNames = new Set(Object.keys(d.nodes as object));
-
-	for (const [name, raw] of Object.entries(d.nodes as Record<string, unknown>)) {
-		if (raw == null || typeof raw !== "object") {
-			errors.push(`Node "${name}": must be an object`);
-			continue;
-		}
-		const node = raw as Record<string, unknown>;
-		if (typeof node.type !== "string" || !VALID_NODE_TYPES.has(node.type)) {
-			errors.push(
-				`Node "${name}": invalid type "${String(node.type)}" (expected: ${[...VALID_NODE_TYPES].join(", ")})`,
-			);
-		}
-		if (Array.isArray(node.deps)) {
-			for (const dep of node.deps) {
-				if (typeof dep === "string" && !nodeNames.has(dep)) {
-					errors.push(`Node "${name}": dep "${dep}" does not reference an existing node`);
-				}
-			}
-		}
-	}
-
-	if (!Array.isArray(d.edges)) {
-		if (d.edges !== undefined) {
-			errors.push("'edges' must be an array");
-		}
-		// edges are optional — no error if absent
-	} else {
-		const seen = new Set<string>();
-		for (let i = 0; i < (d.edges as unknown[]).length; i++) {
-			const edge = (d.edges as unknown[])[i];
-			if (edge == null || typeof edge !== "object") {
-				errors.push(`Edge [${i}]: must be an object`);
-				continue;
-			}
-			const e = edge as Record<string, unknown>;
-			if (typeof e.from !== "string" || !nodeNames.has(e.from)) {
-				errors.push(`Edge [${i}]: 'from' "${String(e.from)}" does not reference an existing node`);
-			}
-			if (typeof e.to !== "string" || !nodeNames.has(e.to)) {
-				errors.push(`Edge [${i}]: 'to' "${String(e.to)}" does not reference an existing node`);
-			}
-			const key = `${e.from}->${e.to}`;
-			if (seen.has(key)) {
-				errors.push(`Edge [${i}]: duplicate edge ${key}`);
-			}
-			seen.add(key);
-		}
-	}
-
-	return { valid: errors.length === 0, errors };
-}
diff --git a/src/utils/ai/index.ts b/src/utils/ai/index.ts
deleted file mode 100644
index aea19c3a..00000000
--- a/src/utils/ai/index.ts
+++ /dev/null
@@ -1,112 +0,0 @@
-/**
- * AI surface patterns (roadmap §4.4).
- *
- * Domain-layer factories for LLM-backed agents, chat, tool registries, and
- * agentic memory. Composed from core + extra + Phase 3–4.3 primitives.
- *
- * This file is the public barrel — it re-exports symbols from the sibling
- * folders (`prompts/`, `extractors/`, `safety/`, `agents/`, `memory/`,
- * `graph-integration/`, and the existing `adapters/` tree). No implementation
- * code lives here; see each sibling folder for the actual primitives.
- *
- * @module
- */
-
-// ---------------------------------------------------------------------------
-// Adapter layer (§9.3d) — providers, middleware, routing primitives.
-// Browser-only adapters (WebLLM, ChromeNano) stay behind the `patterns/ai/browser`
-// subpath to keep Node bundles lean.
-// ---------------------------------------------------------------------------
-
-export * from "./adapters/core/capabilities.js";
-export * from "./adapters/core/factory.js";
-export * from "./adapters/core/observable.js";
-export * from "./adapters/core/pricing.js";
-export * from "./adapters/middleware/breaker.js";
-export * from "./adapters/middleware/budget-gate.js";
-export * from "./adapters/middleware/dry-run.js";
-export * from "./adapters/middleware/http429-parser.js";
-export * from "./adapters/middleware/rate-limiter.js";
-export * from "./adapters/middleware/replay-cache.js";
-export * from "./adapters/middleware/resilient-adapter.js";
-export * from "./adapters/middleware/retry.js";
-export * from "./adapters/middleware/timeout.js";
-export * from "./adapters/providers/anthropic.js";
-export * from "./adapters/providers/dry-run.js";
-export * from "./adapters/providers/fallback.js";
-export * from "./adapters/providers/google.js";
-export * from "./adapters/providers/openai-compat.js";
-export * from "./adapters/routing/cascading.js";
-
-// ---------------------------------------------------------------------------
-// Types — single source of truth lives in ./adapters/core/types.ts
-// ---------------------------------------------------------------------------
-
-export type {
-	ChatMessage,
-	LLMAdapter,
-	LLMInvokeOptions,
-	LLMResponse,
-	StreamDelta,
-	TokenUsage,
-	ToolCall,
-	ToolDefinition,
-} from "./adapters/core/types.js";
-
-// ---------------------------------------------------------------------------
-// Prompt primitives
-// ---------------------------------------------------------------------------
-
-// `fromLLM` was folded into `promptNode({ format: "raw", tools })` per
-// Tier 2.3 — see `prompts/prompt-node.ts`.
-export * from "./prompts/frozen-context.js";
-export * from "./prompts/prompt-call.js";
-export * from "./prompts/prompt-node.js";
-export * from "./prompts/streaming.js";
-export * from "./prompts/system-prompt.js";
-
-// ---------------------------------------------------------------------------
-// Stream extractors (taps on streamingPromptNode.stream topics)
-// ---------------------------------------------------------------------------
-
-export * from "./extractors/cost-meter.js";
-export * from "./extractors/keyword-flag.js";
-export * from "./extractors/stream-extractor.js";
-export * from "./extractors/tool-call.js";
-
-// ---------------------------------------------------------------------------
-// Content safety
-// ---------------------------------------------------------------------------
-
-export * from "./safety/content-gate.js";
-export * from "./safety/redactor.js";
-
-// ---------------------------------------------------------------------------
-// Agents (chat, tools, multi-agent routing — building blocks)
-// ---------------------------------------------------------------------------
-
-export * from "./agents/chat-stream.js";
-export * from "./agents/handoff.js";
-export * from "./agents/tool-execution.js";
-export * from "./agents/tool-interceptor.js";
-export * from "./agents/tool-registry.js";
-export * from "./agents/tool-selector.js";
-
-// ---------------------------------------------------------------------------
-// Agentic memory building blocks (admission, composers, retrieval, tiers)
-// ---------------------------------------------------------------------------
-
-export * from "./memory/admission.js";
-export * from "./memory/memory-composers.js";
-export * from "./memory/retrieval.js";
-export * from "./memory/tiers.js";
-
-// ---------------------------------------------------------------------------
-// Graph ↔ LLM integration (knobs, gauges, spec round-trip)
-// ---------------------------------------------------------------------------
-
-export * from "./graph-integration/gauges-as-context.js";
-export * from "./graph-integration/graph-from-spec.js";
-export * from "./graph-integration/knobs-as-tools.js";
-export * from "./graph-integration/suggest-strategy.js";
-export * from "./graph-integration/validate-graph-def.js";
diff --git a/src/utils/ai/memory/admission.ts b/src/utils/ai/memory/admission.ts
deleted file mode 100644
index 744d9387..00000000
--- a/src/utils/ai/memory/admission.ts
+++ /dev/null
@@ -1,114 +0,0 @@
-// ---------------------------------------------------------------------------
-// Admission scoring (generic + 3D sugar)
-// ---------------------------------------------------------------------------
-//
-// `admissionScored<Dims>` is the generic primitive: a user-supplied scoreFn
-// returns one number per named dimension; the filter rejects whenever any
-// scored dimension falls below its configured threshold. Dimensions absent
-// from the thresholds config are ignored — they may still be useful for
-// telemetry, but don't gate admission.
-//
-// `admissionFilter3D` is a thin wrapper for the persistence / structure /
-// personalValue triple borrowed from the LLM memory literature; ship this
-// when callers want the named-axes shape, otherwise compose `admissionScored`
-// directly with whatever dimensions fit the domain.
-//
-// The earlier `defaultAdmissionScorer` (always-0.5 across all dims) was
-// retired in Unit 8 — it admitted everything in disguise. Callers must
-// supply a real `scoreFn`.
-
-/** Generic per-dimension thresholds. Any dim below its threshold → reject. */
-export type AdmissionThresholds<Dims extends string> = Partial<Record<Dims, number>>;
-
-export type AdmissionScoredOptions<Dims extends string, TRaw = unknown> = {
-	/** Score function — must return a finite number for every dimension named in `thresholds`. */
-	scoreFn: (raw: TRaw) => Readonly<Record<Dims, number>>;
-	/** Per-dim minimums. Dims absent here are scored but not gated. */
-	thresholds?: AdmissionThresholds<Dims>;
-};
-
-/**
- * Generic N-dimension admission filter. Rejects any input where one of the
- * configured threshold dimensions scores below its minimum. Missing scores
- * (`undefined` / `null`) AND non-finite values (`NaN`, `±Infinity`) are
- * treated as below all thresholds — reject by default rather than admit.
- *
- * @example
- * ```ts
- * const filter = admissionScored({
- *   scoreFn: (raw: Note) => ({ relevance: scoreRelevance(raw), age: ageScore(raw) }),
- *   thresholds: { relevance: 0.4 },  // age scored but ungated
- * });
- * ```
- */
-export function admissionScored<Dims extends string, TRaw = unknown>(
-	opts: AdmissionScoredOptions<Dims, TRaw>,
-): (raw: TRaw) => boolean {
-	const thresholds = opts.thresholds ?? ({} as AdmissionThresholds<Dims>);
-	return (raw: TRaw): boolean => {
-		const scores = opts.scoreFn(raw);
-		for (const dim of Object.keys(thresholds) as Dims[]) {
-			const min = thresholds[dim];
-			if (min === undefined) continue;
-			const s = scores[dim];
-			// `??` falls back on null/undefined but lets NaN through; we want
-			// non-finite to also reject so a buggy scoreFn returning NaN doesn't
-			// silently admit. `Number.isFinite(NaN) === false`.
-			const safe = Number.isFinite(s) ? (s as number) : Number.NEGATIVE_INFINITY;
-			if (safe < min) return false;
-		}
-		return true;
-	};
-}
-
-// ---------------------------------------------------------------------------
-// 3D sugar
-// ---------------------------------------------------------------------------
-
-/** Scores for the three admission dimensions. Each 0–1. */
-export type AdmissionScores = {
-	readonly persistence: number;
-	readonly structure: number;
-	readonly personalValue: number;
-};
-
-export type AdmissionScore3DOptions = {
-	/** Custom scoring function. Required — the previous always-0.5 default was misleading. */
-	scoreFn: (raw: unknown) => AdmissionScores;
-	/** Minimum persistence score to admit (default 0.3). */
-	persistenceThreshold?: number;
-	/** Minimum personalValue score to admit (default 0.3). */
-	personalValueThreshold?: number;
-	/** Require structure score > 0 to admit (default false). */
-	requireStructured?: boolean;
-};
-
-/**
- * 3D admission sugar — the persistence / structure / personalValue triple
- * commonly used in agent-memory literature. Composes `admissionScored`
- * with thresholds derived from the option fields. Use directly when those
- * three named dimensions match your domain, or use `admissionScored` with
- * an arbitrary dimension set instead.
- *
- * `requireStructured: true` rejects entries where `structure <= 0` (matches
- * the pre-Unit-8 `requireStructured && scores.structure <= 0` check).
- * Implemented as a final-step predicate around `admissionScored` rather
- * than a `Number.MIN_VALUE` threshold, which would have been a footgun for
- * future readers.
- */
-export function admissionFilter3D(opts: AdmissionScore3DOptions): (raw: unknown) => boolean {
-	const thresholds: AdmissionThresholds<keyof AdmissionScores> = {
-		persistence: opts.persistenceThreshold ?? 0.3,
-		personalValue: opts.personalValueThreshold ?? 0.3,
-	};
-	const base = admissionScored<keyof AdmissionScores, unknown>({
-		scoreFn: opts.scoreFn,
-		thresholds,
-	});
-	if (!opts.requireStructured) return base;
-	return (raw: unknown): boolean => {
-		if (!base(raw)) return false;
-		const s = opts.scoreFn(raw).structure;
-		return Number.isFinite(s) && s > 0;
-	};
-}
diff --git a/src/utils/ai/memory/memory-composers.ts b/src/utils/ai/memory/memory-composers.ts
deleted file mode 100644
index 44372698..00000000
--- a/src/utils/ai/memory/memory-composers.ts
+++ /dev/null
@@ -1,943 +0,0 @@
-// ---------------------------------------------------------------------------
-// memory composers — Unit 7 C-factoring (2026-04-23 doc decision).
-//
-// Each composer attaches one capability (vectors, KG, tiers, retrieval) to a
-// `DistillBundle`. `agentMemory` continues to ship as the ergonomic sugar
-// over the full pipeline; power users who want a subset call these factories
-// directly.
-//
-// Class B audit (2026-04-30): the composers were migrated from
-// bundle-returning factories to **Graph subclasses** so they participate in
-// `describe()` / `destroy()` like every other Phase 4+ Graph (mirrors
-// `AuditTrailGraph`, `PolicyGateGraph`, `CqrsGraph`). The factory functions
-// remain as ergonomic constructors (`memoryWithVectors(opts) → MemoryWithVectorsGraph`).
-//
-// Tier 4.1 B + 4.3 B (2026-04-29): `memoryWithTiers` is the construction site
-// for the distill bundle when tiers are configured (`reactiveMap.retention`
-// wired at construction eliminates the §7 feedback cycle the prior
-// `tierClassifier` effect carried). `permanentKeys` and `entryCreatedAtNs`
-// are reactive maps mounted on the graph (not closure state) so
-// `describe()`/`explain()` can walk to the inputs that fed an archival
-// decision.
-// ---------------------------------------------------------------------------
-
-import { batch, DATA, monotonicNs, type Node, node } from "@graphrefly/pure-ts/core";
-import type { StorageHandle } from "@graphrefly/pure-ts/extra";
-import {
-	fromAny,
-	keepalive,
-	type NodeInput,
-	type ReactiveMapBundle,
-	type ReactiveMapRetention,
-	reactiveMap,
-} from "@graphrefly/pure-ts/extra";
-import { Graph, type GraphOptions } from "@graphrefly/pure-ts/graph";
-import {
-	type DistillBundle,
-	type DistillOptions,
-	distill,
-	type Extraction,
-} from "../../../base/composition/distill.js";
-import { decay } from "../../../base/utils/decay.js";
-import {
-	collection,
-	cosineSimilarity,
-	type KnowledgeEdge,
-	type KnowledgeGraph,
-	knowledgeGraph,
-	type VectorIndexGraph,
-	type VectorRecord,
-	type VectorSearchResult,
-	vectorIndex,
-} from "../../memory/index.js";
-import { aiMeta } from "../_internal.js";
-import type { RetrievalEntry, RetrievalQuery, RetrievalTrace } from "./retrieval.js";
-import {
-	DEFAULT_DECAY_RATE,
-	type MemoryTier,
-	type MemoryTiersBundle,
-	type MemoryTiersOptions,
-} from "./tiers.js";
-
-// Tier 4.7 (Wave AM Unit 5 carry): the pre-rebuild defensive `extractStoreMap`
-// helper (runtime `instanceof Map` check before casting) was deleted in favor
-// of a typed `as` cast at each callsite. The upstream `ReactiveMapBundle`
-// always emits a real Map on the live emit path; non-Map snapshots only
-// surface on `Graph.restore` from a codec that round-tripped Map → JSON →
-// plain object (handled in `extra/composite.ts:mapFromSnapshot` for distill
-// internals). Empty map is the canonical "no entries yet" value —
-// `node([], { initial: undefined })` would stall a derived/effect's first-run gate.
-//
-// qa F3 (deferred): the typed cast lies if upstream contract ever breaks
-// (e.g. `entries` emits a non-Map non-undefined value). Failure mode is a
-// TypeError at iteration instead of a silent empty-map fallback —
-// deliberate trade-off, surfacing real upstream-contract violations beats
-// hiding them. Upstream-narrowing follow-up filed in `docs/optimizations.md`
-// under "Tier 4.7 follow-up — narrow `ReactiveMapBundle.entries` callback typing".
-
-// ---------------------------------------------------------------------------
-// memoryWithVectors
-// ---------------------------------------------------------------------------
-
-export interface MemoryWithVectorsOptions<TMem> {
-	/** Optional Graph identity — passed through to the underlying `Graph` ctor. */
-	graph?: GraphOptions;
-	/** Subgraph name. Default: `"memory-vectors"`. */
-	name?: string;
-	/** The substrate distill store to index. */
-	store: DistillBundle<TMem>;
-	/** Embedding dimension. Must match the `embedFn` output length. */
-	dimension: number;
-	/** Extract an embedding vector for a memory entry. */
-	embedFn: (mem: TMem) => readonly number[] | undefined;
-}
-
-/**
- * Graph subclass that attaches a vector index to a `DistillBundle`. The inner
- * `VectorIndexGraph` is mounted at `"vectorIndex"`; an internal effect
- * subscribes to the substrate store and re-indexes on every change.
- *
- * Mirrors `AuditTrailGraph` / `PolicyGateGraph` shape — fully self-contained,
- * teardown via the Graph's `destroy()` cascade.
- */
-export class MemoryWithVectorsGraph<TMem> extends Graph {
-	readonly vectors: VectorIndexGraph<TMem>;
-
-	constructor(opts: MemoryWithVectorsOptions<TMem>) {
-		super(opts.name ?? "memory-vectors", opts.graph);
-		this.vectors = vectorIndex<TMem>({ dimension: opts.dimension });
-		this.mount("vectorIndex", this.vectors);
-
-		const embedFn = opts.embedFn;
-		const vectorsRef = this.vectors;
-
-		// Indexer effect — subscribes to the substrate's store entries, upserts
-		// vectors. Pure side-effect; restricted `effect` fn (no emit/down).
-		// Cross-graph dep on `opts.store.store.entries` is fine — the substrate
-		// is the upstream wired in by the parent factory.
-		const indexer = node(
-			[opts.store.store.entries],
-			(batchData, _actions, ctx) => {
-				const data = batchData.map((b, i) =>
-					b != null && b.length > 0 ? b.at(-1) : ctx.prevData[i],
-				);
-				const storeMap =
-					(data[0] as ReadonlyMap<string, TMem> | undefined) ?? new Map<string, TMem>();
-				for (const [key, mem] of storeMap) {
-					const vec = embedFn(mem);
-					if (vec) vectorsRef.upsert(key, vec, mem);
-				}
-			},
-			{ name: "indexer", describeKind: "effect" },
-		);
-		this.add(indexer, { name: "indexer" });
-		this.addDisposer(keepalive(indexer));
-	}
-}
-
-/**
- * Attach a vector index to a `DistillBundle`. Indexes every entry in the
- * store as it changes. Returns the `MemoryWithVectorsGraph` whose `vectors`
- * field exposes the underlying `VectorIndexGraph`.
- *
- * Teardown is handled by `Graph.destroy()` — typically inherited via
- * mounting the result on a parent graph (see `agentMemory`).
- */
-export function memoryWithVectors<TMem>(
-	opts: MemoryWithVectorsOptions<TMem>,
-): MemoryWithVectorsGraph<TMem> {
-	return new MemoryWithVectorsGraph<TMem>(opts);
-}
-
-// ---------------------------------------------------------------------------
-// memoryWithKG
-// ---------------------------------------------------------------------------
-
-export interface MemoryWithKGOptions<TMem> {
-	/** Optional Graph identity. */
-	graph?: GraphOptions;
-	/** Subgraph name. Default: `"memory-kg"`. */
-	name?: string;
-	/** The substrate distill store to index. */
-	store: DistillBundle<TMem>;
-	/** Inner KnowledgeGraph name. Default: `${name}-kg`. */
-	kgName?: string;
-	/**
-	 * Mount path within this Graph for the KnowledgeGraph. Default:
-	 * `"knowledge-kg"` (B5c — symmetric with the outer `knowledge` mount so
-	 * describe paths render `knowledge::knowledge-kg::*`).
-	 */
-	mountPath?: string;
-	/**
-	 * Extract entities + relations for a memory entry. Omit to mount an empty
-	 * KG without an indexer effect — caller upserts entities / relations
-	 * directly on the `kg` field.
-	 */
-	entityFn?: (
-		key: string,
-		mem: TMem,
-	) =>
-		| {
-				entities?: Array<{ id: string; value: unknown }>;
-				relations?: Array<{ from: string; to: string; relation: string; weight?: number }>;
-		  }
-		| undefined;
-}
-
-/**
- * Graph subclass that attaches a knowledge graph alongside a `DistillBundle`.
- * Mounts the inner `KnowledgeGraph` at `mountPath` (default `"knowledge-kg"`); when
- * `entityFn` is provided, an indexer effect populates entities/relations on
- * every store change.
- */
-export class MemoryWithKGGraph<TMem> extends Graph {
-	readonly kg: KnowledgeGraph<unknown, string>;
-
-	constructor(opts: MemoryWithKGOptions<TMem>) {
-		const name = opts.name ?? "memory-kg";
-		super(name, opts.graph);
-		const kgName = opts.kgName ?? `${name}-kg`;
-		const mountPath = opts.mountPath ?? "knowledge-kg";
-		this.kg = knowledgeGraph<unknown, string>(kgName);
-		this.mount(mountPath, this.kg);
-
-		if (!opts.entityFn) return;
-		const entityFn = opts.entityFn;
-		const kgRef = this.kg;
-		const indexer = node(
-			[opts.store.store.entries],
-			(batchData, _actions, ctx) => {
-				const data = batchData.map((b, i) =>
-					b != null && b.length > 0 ? b.at(-1) : ctx.prevData[i],
-				);
-				const storeMap =
-					(data[0] as ReadonlyMap<string, TMem> | undefined) ?? new Map<string, TMem>();
-				for (const [key, mem] of storeMap) {
-					const extracted = entityFn(key, mem);
-					if (!extracted) continue;
-					for (const ent of extracted.entities ?? []) {
-						kgRef.upsertEntity(ent.id, ent.value);
-					}
-					for (const rel of extracted.relations ?? []) {
-						kgRef.link(rel.from, rel.to, rel.relation, rel.weight);
-					}
-				}
-			},
-			{ name: "indexer", describeKind: "effect" },
-		);
-		this.add(indexer, { name: "indexer" });
-		this.addDisposer(keepalive(indexer));
-	}
-}
-
-/**
- * Attach a knowledge graph alongside a `DistillBundle`. Returns the
- * `MemoryWithKGGraph` whose `kg` field exposes the inner `KnowledgeGraph`.
- */
-export function memoryWithKG<TMem>(opts: MemoryWithKGOptions<TMem>): MemoryWithKGGraph<TMem> {
-	return new MemoryWithKGGraph<TMem>(opts);
-}
-
-// ---------------------------------------------------------------------------
-// memoryWithTiers
-// ---------------------------------------------------------------------------
-
-/**
- * Full options for {@link memoryWithTiers} (Tier 4.1 B + 4.3 B refactor,
- * 2026-04-29). Combines tier-policy options with the distill-side options
- * needed to construct the underlying store — `memoryWithTiers` is the
- * **construction site** for the distill bundle so it can wire
- * `reactiveMap.retention` into the store at construction (eliminating the
- * §7 feedback cycle the previous `tierClassifier` effect carried).
- */
-export type MemoryWithTiersOptions<TRaw, TMem> = MemoryTiersOptions<TMem> &
-	Omit<DistillOptions<TMem>, "mapOptions" | "score" | "context"> & {
-		/** Optional Graph identity. */
-		graph?: GraphOptions;
-		/** Subgraph name. Default: `"memory-tiers"`. */
-		name?: string;
-		/** Raw source feeding distill. */
-		source: NodeInput<TRaw>;
-		/** Reactive extraction wiring (same shape as `distill`). */
-		extractFn: (
-			raw: Node<TRaw>,
-			existing: Node<ReadonlyMap<string, TMem>>,
-		) => NodeInput<Extraction<TMem>>;
-		/** Score function — same signature as `agentMemory.score`. */
-		score: (mem: TMem, context: unknown) => number;
-		/** Optional reactive context node (passed to `score`). */
-		context?: NodeInput<unknown>;
-	};
-
-/**
- * Graph subclass attaching 3-tier storage (active / archived / permanent) to
- * a fresh distill store, wiring `reactiveMap.retention` at construction so
- * archival happens synchronously inside the substrate's mutation pipeline
- * (no §7 feedback cycle). Promotes `permanentKeys` and `entryCreatedAtNs` to
- * reactive maps registered on this graph (Tier 4.3 B — Unit 7 Q3) so
- * `describe()` / `explain()` can walk to "why was X archived?".
- *
- * Public-face fields:
- * - `store` — the distill bundle (construction site, exposed for downstream
- *   composers).
- * - `tiers` — tier classification + permanent promotion handles.
- * - `compact`, `size` — alias for `store.compact` / `store.size` (registered
- *   under their canonical names so `describe()` keys match `agentMemory`'s
- *   pre-migration layout).
- */
-export class MemoryWithTiersGraph<TRaw, TMem> extends Graph {
-	readonly store: DistillBundle<TMem>;
-	readonly tiers: MemoryTiersBundle<TMem>;
-	readonly compact: Node<Array<{ key: string; value: TMem; score: number }>>;
-	readonly size: Node<number>;
-	readonly permanent: ReturnType<typeof collection<TMem>>;
-	readonly permanentKeys: ReactiveMapBundle<string, true>;
-	readonly entryCreatedAtNs: ReactiveMapBundle<string, number>;
-
-	constructor(opts: MemoryWithTiersOptions<TRaw, TMem>) {
-		super(opts.name ?? "memory-tiers", opts.graph);
-
-		const decayRate = opts.decayRate ?? DEFAULT_DECAY_RATE;
-		const maxActive = opts.maxActive ?? 1000;
-		const archiveThreshold = opts.archiveThreshold ?? 0.1;
-		const permanentFilter = opts.permanentFilter ?? (() => false);
-
-		// Tier 2.3 fold: `lightCollection` was merged into
-		// `collection({ranked: false})`. The unified factory returns a Graph (not
-		// a detached bundle), so it's mounted as a subgraph for `describe()`.
-		this.permanent = collection<TMem>("permanent", { ranked: false });
-		this.mount("permanent", this.permanent);
-
-		// 4.3 B (Unit 7 Q3, 2026-04-29): closure-state promotion. `permanentKeys`
-		// and `entryCreatedAtNs` are reactive maps registered on this graph so
-		// `describe()` can walk to them and `explain()` can trace the inputs
-		// that fed an archival decision.
-		this.permanentKeys = reactiveMap<string, true>({ name: "permanentKeys" });
-		this.add(this.permanentKeys.entries, { name: "permanentKeys" });
-		this.entryCreatedAtNs = reactiveMap<string, number>({ name: "entryCreatedAtNs" });
-		this.add(this.entryCreatedAtNs.entries, { name: "entryCreatedAtNs" });
-
-		// Closure-mirror for ctx (§28 factory-time seed). `score(mem, ctx)` runs
-		// inside `retention.score` which is invoked synchronously from store
-		// mutations — no reactive dep on contextNode there. The mirror keeps
-		// `latestCtx` current via subscribe.
-		//
-		// Topology visibility: the local-default branch registers the context
-		// state node so it appears in `describe()`. The user-supplied-Node
-		// branch deliberately leaves the node unregistered — `fromAny` returns
-		// the caller's owned Node, which is owned by their graph; mounting it
-		// here would corrupt cross-graph ownership.
-		let contextNode: Node<unknown>;
-		if (opts.context) {
-			contextNode = fromAny(opts.context);
-		} else {
-			contextNode = node<unknown>([], { initial: null });
-			this.add(contextNode, { name: "context" });
-		}
-		let latestCtx: unknown = contextNode.cache;
-		const ctxUnsub = contextNode.subscribe((msgs) => {
-			for (const m of msgs) if (m[0] === DATA) latestCtx = m[1];
-		});
-		this.addDisposer(ctxUnsub);
-
-		const permanentKeysRef = this.permanentKeys;
-		const entryCreatedAtNsRef = this.entryCreatedAtNs;
-		const score = opts.score;
-
-		// Build retention. `score` runs synchronously inside store mutations.
-		// Permanent matches return Infinity to bypass eviction.
-		//
-		// DS-13.5.F (2026-05-01): `score` is read-only against
-		// `entryCreatedAtNs` — the first-write side-effect was extracted into
-		// the `entryCreatedAtNs/sync` effect below. Race window for the very
-		// first call on a new key is mitigated by the `?? nowNs` fallback
-		// (yields ageSeconds = 0, i.e. fresh-decay), and the sync effect
-		// populates the map after the wave settles so subsequent score calls
-		// see the persisted timestamp.
-		const retention: ReactiveMapRetention<string, TMem> = {
-			score: (key, value) => {
-				if (permanentFilter(key, value)) return Number.POSITIVE_INFINITY;
-				if (permanentKeysRef.has(key)) return Number.POSITIVE_INFINITY;
-				const nowNs = monotonicNs();
-				const createdNs = entryCreatedAtNsRef.get(key) ?? nowNs;
-				const ageSeconds = Number(nowNs - createdNs) / 1e9;
-				return decay(score(value, latestCtx), ageSeconds, decayRate);
-			},
-			archiveThreshold,
-			maxSize: maxActive,
-		};
-
-		// Construct distill with retention wired into mapOptions.
-		this.store = distill<TRaw, TMem>(opts.source, opts.extractFn, {
-			score: opts.score,
-			cost: opts.cost,
-			...(opts.budget !== undefined ? { budget: opts.budget } : {}),
-			...(opts.evict !== undefined ? { evict: opts.evict } : {}),
-			...(opts.consolidate !== undefined ? { consolidate: opts.consolidate } : {}),
-			...(opts.consolidateTrigger !== undefined
-				? { consolidateTrigger: opts.consolidateTrigger }
-				: {}),
-			...(opts.context !== undefined ? { context: opts.context } : {}),
-			mapOptions: { retention },
-		});
-
-		// Register the distill bundle's exposed nodes under their canonical
-		// names so consumers (and `describe()`) see the same shape as the
-		// pre-migration top-level surface on `agentMemory`.
-		this.add(this.store.store.entries, { name: "store" });
-		this.compact = this.store.compact;
-		this.add(this.compact, { name: "compact" });
-		this.size = this.store.size;
-		this.add(this.size, { name: "size" });
-
-		const storeRef = this.store;
-		const tierOf = (key: string): MemoryTier => {
-			if (permanentKeysRef.has(key)) return "permanent";
-			const m =
-				(storeRef.store.entries.cache as ReadonlyMap<string, TMem> | undefined) ??
-				new Map<string, TMem>();
-			if (m.has(key)) return "active";
-			return "archived";
-		};
-		const permanentRef = this.permanent;
-		const markPermanent = (key: string, value: TMem): void => {
-			permanentKeysRef.set(key, true);
-			permanentRef.upsert(key, value);
-		};
-
-		// DS-13.5.F (2026-05-01): first-write of `entryCreatedAtNs[key]` runs
-		// here (extracted from `retention.score` to keep score pure). Reads
-		// `store.store.entries`, writes `entryCreatedAtNs` — distinct nodes,
-		// no §7 feedback cycle. Idempotent: re-emissions for already-tracked
-		// keys skip via `entryCreatedAtNsRef.has(key)`.
-		const syncCreatedAt = node(
-			[this.store.store.entries],
-			(batchData, _actions, ctx) => {
-				const data = batchData.map((b, i) =>
-					b != null && b.length > 0 ? b.at(-1) : ctx.prevData[i],
-				);
-				const map = (data[0] as ReadonlyMap<string, TMem> | undefined) ?? new Map<string, TMem>();
-				const nowNs = monotonicNs();
-				const toAdd: string[] = [];
-				for (const key of map.keys()) {
-					if (!entryCreatedAtNsRef.has(key)) toAdd.push(key);
-				}
-				if (toAdd.length > 0) {
-					batch(() => {
-						for (const key of toAdd) entryCreatedAtNsRef.set(key, nowNs);
-					});
-				}
-			},
-			{ name: "entryCreatedAtNs/sync", describeKind: "effect" },
-		);
-		this.add(syncCreatedAt, { name: "entryCreatedAtNs/sync" });
-		this.addDisposer(keepalive(syncCreatedAt));
-
-		// GC entryCreatedAtNs entries that no longer exist in the active store.
-		// (Adds happen via the syncCreatedAt effect above; removals piggyback
-		// on the store-snapshot subscriber here so the map stays in sync.)
-		const entriesUnsub = this.store.store.entries.subscribe((msgs) => {
-			for (const m of msgs) {
-				if (m[0] !== DATA) continue;
-				const map = m[1] as ReadonlyMap<string, TMem>;
-				const created = entryCreatedAtNsRef.entries.cache as
-					| ReadonlyMap<string, number>
-					| undefined;
-				if (created == null) continue;
-				const toDelete: string[] = [];
-				for (const key of created.keys()) {
-					if (!map.has(key)) toDelete.push(key);
-				}
-				if (toDelete.length > 0) {
-					batch(() => {
-						for (const key of toDelete) entryCreatedAtNsRef.delete(key);
-					});
-				}
-			}
-		});
-		this.addDisposer(entriesUnsub);
-
-		// Permanent-promotion effect. Writes to `permanent` collection +
-		// `permanentKeys` (NOT to the active store), so no §7 cycle: the effect's
-		// dep is `store.store.entries`, but it doesn't write back to that node.
-		const promoter = node(
-			[this.store.store.entries],
-			(batchData, _actions, ctx) => {
-				const data = batchData.map((b, i) =>
-					b != null && b.length > 0 ? b.at(-1) : ctx.prevData[i],
-				);
-				const map = (data[0] as ReadonlyMap<string, TMem> | undefined) ?? new Map<string, TMem>();
-				for (const [key, mem] of map) {
-					if (permanentKeysRef.has(key)) continue;
-					if (permanentFilter(key, mem)) {
-						batch(() => {
-							markPermanent(key, mem);
-						});
-					}
-				}
-			},
-			{ name: "promoter", describeKind: "effect" },
-		);
-		this.add(promoter, { name: "promoter" });
-		this.addDisposer(keepalive(promoter));
-
-		let archiveHandle: StorageHandle | null = null;
-		if (opts.archiveTier) {
-			archiveHandle = this.attachSnapshotStorage(
-				[{ snapshot: opts.archiveTier }],
-				opts.archiveStorageOptions ?? {},
-			);
-			this.addDisposer(() => archiveHandle?.dispose());
-		}
-
-		this.tiers = {
-			permanent: this.permanent,
-			activeEntries: this.store.store.entries,
-			archiveHandle,
-			tierOf,
-			markPermanent,
-		};
-	}
-}
-
-/**
- * Attach 3-tier storage (active / archived / permanent) over a fresh distill
- * store. Returns a `MemoryWithTiersGraph` whose `store` and `tiers` fields
- * mirror the previous bundle shape.
- *
- * **API shape** (Class B audit, 2026-04-30 — breaking change vs.
- * pre-migration): the factory takes a single opts bag including `source`
- * and `extractFn`. The bundle is exposed as `result.store` for downstream
- * composers (vectors / KG / retrieval).
- *
- * - `permanentFilter`-matching entries score `Infinity` in retention →
- *   never archived. Independent permanent-promotion effect upserts them
- *   into the `permanent` collection.
- * - Below-threshold entries → retention archives synchronously.
- * - Over-`maxActive` entries → retention's `maxSize` evicts lowest-scored.
- */
-export function memoryWithTiers<TRaw, TMem>(
-	opts: MemoryWithTiersOptions<TRaw, TMem>,
-): MemoryWithTiersGraph<TRaw, TMem> {
-	return new MemoryWithTiersGraph<TRaw, TMem>(opts);
-}
-
-// ---------------------------------------------------------------------------
-// memoryRetrieval
-// ---------------------------------------------------------------------------
-
-export interface MemoryRetrievalOptions<TMem> {
-	/** Optional Graph identity. */
-	graph?: GraphOptions;
-	/** Subgraph name. Default: `"memory-retrieval"`. */
-	name?: string;
-	/** The substrate distill store. */
-	store: DistillBundle<TMem>;
-	/** Optional vector index for similarity search. */
-	vectors?: VectorIndexGraph<TMem> | null;
-	/** Optional knowledge graph for entity-relation expansion. */
-	kg?: KnowledgeGraph<unknown, string> | null;
-	/** Score function (same shape as `agentMemory.score`). */
-	score: (mem: TMem, context: unknown) => number;
-	/** Cost function for budget packing. */
-	cost: (mem: TMem) => number;
-	/** Token / cost budget. Default 2000. */
-	budget?: number;
-	/** Top-K vector candidates. Default 20. */
-	topK?: number;
-	/** KG expansion depth in hops. Default 1. */
-	graphDepth?: number;
-	/** Hierarchical-context boost weight. Default 0. */
-	contextWeight?: number;
-	/** Hierarchical-context accessor for entries. */
-	contextOf?: (mem: TMem) => readonly string[] | undefined;
-	/** Optional reactive context node (passed to `score`). */
-	context?: NodeInput<unknown>;
-}
-
-function sharedPrefixDepth(
-	q: readonly string[] | undefined,
-	e: readonly string[] | undefined,
-): number {
-	if (!q || !e) return 0;
-	const n = Math.min(q.length, e.length);
-	let i = 0;
-	while (i < n && q[i] === e[i]) i++;
-	return i;
-}
-
-// QA-fix: element-wise reference-equality dedup so subscribers don't wake
-// up when an identical packed array lands (runRetrieval allocates a new
-// outer array reference every call).
-const packedEquals = <T>(a: readonly T[], b: readonly T[]): boolean => {
-	if (a === b) return true;
-	if (a.length !== b.length) return false;
-	for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;
-	return true;
-};
-
-/**
- * Graph subclass that builds the retrieval pipeline (vector + KG + budget
- * packing) over a `DistillBundle` and optional vectors / kg substrates.
- *
- * **C1 rework (2026-04-30):** retrieval is reactive-only. Each
- * `retrieveReactive(input)` call constructs its own per-input subgraph
- * mounted at `retrieve_${id}` with named nodes `context`, `result`, and
- * `projection`. Subgraphs register their own scoped disposers so teardown
- * is local to the per-call mount.
- *
- * **QA F-9 (2026-04-30):** the shared `retrieval` / `retrievalTrace`
- * state-node mirrors are dropped — they were last-writer-wins under
- * concurrent `retrieveReactive(...)` calls. Consumers must subscribe to
- * the per-call `projection` node directly. One-shot consumers use
- * `awaitSettled(retrieveReactive(input))`.
- *
- * **QA F-6 (2026-04-30):** the per-call `result` derived declares
- * `vectors.entries` / `kg.adjacencyOut` / `kg.adjacencyIn` as deps when
- * configured, so a vector upsert / KG mutation re-runs retrieval even
- * when the query / context / store-snapshot are unchanged. Resolves the
- * §28 closure-mirror gap where these `.cache` reads were undeclared.
- */
-export class MemoryRetrievalGraph<TMem> extends Graph {
-	private readonly _store: DistillBundle<TMem>;
-	private readonly _vectors: VectorIndexGraph<TMem> | null;
-	private readonly _kg: KnowledgeGraph<unknown, string> | null;
-	private readonly _opts: MemoryRetrievalOptions<TMem>;
-	private readonly _contextNode: Node<unknown>;
-	private readonly _topK: number;
-	private readonly _graphDepth: number;
-	private readonly _budget: number;
-	private readonly _contextWeight: number;
-	private _retrieveSeq = 0;
-
-	constructor(opts: MemoryRetrievalOptions<TMem>) {
-		super(opts.name ?? "memory-retrieval", opts.graph);
-
-		this._store = opts.store;
-		this._vectors = opts.vectors ?? null;
-		this._kg = opts.kg ?? null;
-		this._opts = opts;
-		this._topK = opts.topK ?? 20;
-		this._graphDepth = opts.graphDepth ?? 1;
-		this._budget = opts.budget ?? 2000;
-		this._contextWeight = opts.contextWeight ?? 0;
-		// DS-13.5.C: synthesized branch (no `opts.context` supplied) registers
-		// on this graph as `_context` so describe()/explain() can walk to it.
-		// User-supplied branch stays unregistered — `fromAny` returns the
-		// caller's owned Node, which is owned by their graph; mounting it
-		// here would corrupt cross-graph ownership (mirrors MemoryWithTiers's
-		// context-branch policy).
-		if (opts.context) {
-			this._contextNode = fromAny(opts.context);
-		} else {
-			this._contextNode = this.state<unknown>("_context", null);
-		}
-	}
-
-	private _runRetrieval(
-		storeMap: ReadonlyMap<string, TMem>,
-		ctx: unknown,
-		query: RetrievalQuery,
-	): { packed: RetrievalEntry<TMem>[]; trace: RetrievalTrace<TMem> } {
-		const opts = this._opts;
-		const candidateMap = new Map<
-			string,
-			{ value: TMem; sources: Set<"vector" | "graph" | "store"> }
-		>();
-
-		let vectorCandidates: VectorSearchResult<TMem>[] = [];
-		if (this._vectors && query.vector) {
-			// Wave A migrated `vectorIndex` to a reactive-only read API
-			// (`searchNode`); inline the equivalent flat-cosine snapshot scan
-			// here since `_runRetrieval` is sync and `searchNode` is async-shaped.
-			// `patterns/ai/memory/` is queued for its own audit per the Wave A
-			// session doc § D.1.
-			const q = query.vector;
-			const snapshot = this._vectors.entries.cache as
-				| ReadonlyMap<string, VectorRecord<TMem>>
-				| undefined;
-			if (snapshot && snapshot.size > 0 && this._topK > 0) {
-				const scored = [...snapshot.values()]
-					.map(
-						(row): VectorSearchResult<TMem> => ({
-							id: row.id,
-							score: cosineSimilarity(q, row.vector),
-							...(row.meta !== undefined ? { meta: row.meta } : {}),
-						}),
-					)
-					.sort((a, b) => b.score - a.score)
-					.slice(0, this._topK);
-				vectorCandidates = scored;
-				for (const vc of vectorCandidates) {
-					const mem = storeMap.get(vc.id);
-					if (mem) candidateMap.set(vc.id, { value: mem, sources: new Set(["vector"]) });
-				}
-			}
-		}
-
-		const graphExpanded: string[] = [];
-		if (this._kg) {
-			// Wave A migrated `knowledgeGraph` to a reactive-only `relatedNode`
-			// API; inline the equivalent adjacency-snapshot scan here for the
-			// sync expansion. `adjacencyOut` / `adjacencyIn` are kept warm by
-			// the kg's own internal keepalive disposers, so `.cache` is always
-			// populated post-construction.
-			const adjOut = this._kg.adjacencyOut.cache as
-				| ReadonlyMap<string, readonly KnowledgeEdge<string>[]>
-				| undefined;
-			const adjIn = this._kg.adjacencyIn.cache as
-				| ReadonlyMap<string, readonly KnowledgeEdge<string>[]>
-				| undefined;
-			const seedIds = [...(query.entityIds ?? []), ...[...candidateMap.keys()]];
-			const visited = new Set<string>();
-			let frontier = seedIds;
-			for (let depth = 0; depth < this._graphDepth; depth++) {
-				const nextFrontier: string[] = [];
-				for (const id of frontier) {
-					if (visited.has(id)) continue;
-					visited.add(id);
-					const outEdges = adjOut?.get(id) ?? [];
-					const inEdges = adjIn?.get(id) ?? [];
-					for (const edge of outEdges) {
-						const targetId = edge.to;
-						if (!visited.has(targetId)) {
-							nextFrontier.push(targetId);
-							const mem = storeMap.get(targetId);
-							if (mem) {
-								const existing = candidateMap.get(targetId);
-								if (existing) existing.sources.add("graph");
-								else candidateMap.set(targetId, { value: mem, sources: new Set(["graph"]) });
-								graphExpanded.push(targetId);
-							}
-						}
-					}
-					// Inbound edges: traverse to the `from` side. Match the
-					// previous `kg.related(id)` semantics, which returned both
-					// `from === id` and `to === id` matches.
-					for (const edge of inEdges) {
-						const targetId = edge.from;
-						if (!visited.has(targetId)) {
-							nextFrontier.push(targetId);
-							const mem = storeMap.get(targetId);
-							if (mem) {
-								const existing = candidateMap.get(targetId);
-								if (existing) existing.sources.add("graph");
-								else candidateMap.set(targetId, { value: mem, sources: new Set(["graph"]) });
-								graphExpanded.push(targetId);
-							}
-						}
-					}
-				}
-				frontier = nextFrontier;
-			}
-		}
-		for (const [key, mem] of storeMap) {
-			if (!candidateMap.has(key)) {
-				candidateMap.set(key, { value: mem, sources: new Set(["store"]) });
-			}
-		}
-
-		const qDepth = query.context?.length ?? 0;
-		const ranked: RetrievalEntry<TMem>[] = [];
-		for (const [key, { value, sources }] of candidateMap) {
-			const entryContext = opts.contextOf ? opts.contextOf(value) : undefined;
-			let score = opts.score(value, ctx);
-			if (this._contextWeight > 0 && qDepth > 0) {
-				const shared = sharedPrefixDepth(query.context, entryContext);
-				if (shared > 0) score = score * (1 + (this._contextWeight * shared) / qDepth);
-			}
-			const entry: RetrievalEntry<TMem> = entryContext
-				? { key, value, score, sources: [...sources], context: entryContext }
-				: { key, value, score, sources: [...sources] };
-			ranked.push(entry);
-		}
-		ranked.sort((a, b) => b.score - a.score);
-
-		const packed: RetrievalEntry<TMem>[] = [];
-		let usedBudget = 0;
-		for (const entry of ranked) {
-			const c = opts.cost(entry.value);
-			if (usedBudget + c > this._budget && packed.length > 0) break;
-			packed.push(entry);
-			usedBudget += c;
-		}
-
-		return { packed, trace: { vectorCandidates, graphExpanded, ranked, packed } };
-	}
-
-	/**
-	 * Reactive consumer API — chain into the graph.
-	 *
-	 * Each call constructs its own per-input subgraph mounted at
-	 * `retrieve_${id}` (auto-incrementing within this MemoryRetrievalGraph
-	 * instance) with named nodes:
-	 *
-	 * - `context` — `fromAny(queryInput)` projection (so the input node is
-	 *   visible to `describe()` even when callers pass a raw value).
-	 * - `result` — pure derived `{ packed, trace }`.
-	 * - `projection` — the packed-array node returned to the caller.
-	 *
-	 * `result` declares the substrate's `store.entries`, the optional
-	 * `context` Node, the local `context` projection, and (when configured)
-	 * `vectors.entries` / `kg.adjacencyOut` / `kg.adjacencyIn` as deps —
-	 * so vector upserts and KG mutations re-trigger retrieval even when
-	 * the input is unchanged.
-	 *
-	 * **Lifecycle contract (DS-13.5.C, 2026-05-01).** The per-call subgraph
-	 * stays mounted while the returned `projection` has at least one
-	 * subscriber. When the last subscriber unsubscribes, projection's
-	 * `deactivate` cleanup hook fires (canonical "last unsubscribe" signal
-	 * via the existing `NodeFnCleanup.onDeactivation` protocol), which calls
-	 * `parent.remove(retrieve_${id})` and tears the per-call topology
-	 * down via TEARDOWN cascade (post-DS-13.5.A Q16, COMPLETE auto-precedes).
-	 *
-	 * **Single-shot lifecycle.** This auto-unmount is keyed to the FIRST
-	 * last-unsubscribe event — projection is non-resubscribable from the
-	 * caller's perspective. Callers who need to subscribe / unsubscribe /
-	 * re-subscribe should hold a long-lived subscription externally (e.g.
-	 * `keepalive(projection)`) or call `retrieveReactive(...)` again to
-	 * mount a fresh per-call subgraph.
-	 *
-	 * **Caller obligation.** Either subscribe to `projection` (and
-	 * eventually unsubscribe to trigger cleanup) OR drop the returned
-	 * reference without subscribing — in the no-subscribe case the
-	 * subgraph is dormant (no compute fires) and a parent `destroy()`
-	 * cascade reclaims it. Holding `projection` without subscribing AND
-	 * without ever destroying the parent is the leak case the JSDoc above
-	 * the C1 rework covers.
-	 *
-	 * One-shot callers use `awaitSettled(retrieveReactive(input))`.
-	 */
-	retrieveReactive(
-		queryInput: NodeInput<RetrievalQuery | null>,
-	): Node<ReadonlyArray<RetrievalEntry<TMem>>> {
-		const id = ++this._retrieveSeq;
-		const segment = `retrieve_${id}`;
-
-		// Per-call subgraph — owns the wiring, the keepalive, and the
-		// teardown. Mounted on `this` so it's visible in `describe()` and
-		// reachable via `${parent}::retrieve_${id}::result` etc.
-		const sub = new Graph(segment);
-
-		// Wrap the input as a local pass-through so the per-call subgraph
-		// shows the query source in `describe()` regardless of where the
-		// caller's node lives in the broader topology. `fromAny` returns
-		// the original Node when given a Node, otherwise wraps a
-		// value/promise into a producer.
-		//
-		// DS-13.5.C: registered via `sub.derived(...)` (Graph helper) for
-		// equals plumbing + automatic registration; replaces the prior raw
-		// `node([inputNode], fn) + sub.add(...)` shape.
-		const inputNode = fromAny(queryInput);
-		const localContext = sub.derived<RetrievalQuery | null>(
-			"context",
-			[inputNode],
-			(batchData, ctx) => {
-				const data = batchData.map((b, i) =>
-					b != null && b.length > 0 ? b.at(-1) : ctx.prevData[i],
-				);
-				return [(data[0] as RetrievalQuery | null) ?? null];
-			},
-			{
-				meta: aiMeta("retrieval_query_input"),
-				initial: null,
-			},
-		);
-
-		// /qa F-6 (2026-04-30): declare vectors / kg substrate Node refs as
-		// deps so vector upserts / KG mutations re-trigger retrieval even
-		// when query / context / store snapshots are unchanged. The
-		// `_runRetrieval` body reads `.cache` from these substrates; before
-		// this fix those reads were undeclared §28 closure-mirrors.
-		const resultDeps: (string | Node<unknown>)[] = [
-			this._store.store.entries,
-			this._contextNode,
-			localContext,
-		];
-		if (this._vectors) resultDeps.push(this._vectors.entries as Node<unknown>);
-		if (this._kg) {
-			resultDeps.push(this._kg.adjacencyOut as Node<unknown>);
-			resultDeps.push(this._kg.adjacencyIn as Node<unknown>);
-		}
-
-		// DS-13.5.C: migrated to `sub.derived(...)` for equals plumbing +
-		// automatic registration.
-		const result = sub.derived<{
-			packed: ReadonlyArray<RetrievalEntry<TMem>>;
-			trace: RetrievalTrace<TMem> | null;
-		}>(
-			"result",
-			resultDeps,
-			(batchData, ctx) => {
-				const data = batchData.map((b, i) =>
-					b != null && b.length > 0 ? b.at(-1) : ctx.prevData[i],
-				);
-				const query = data[2];
-				if (query == null) {
-					return [{ packed: [] as ReadonlyArray<RetrievalEntry<TMem>>, trace: null }];
-				}
-				const storeMap =
-					(data[0] as ReadonlyMap<string, TMem> | undefined) ?? new Map<string, TMem>();
-				const { packed, trace } = this._runRetrieval(storeMap, data[1], query as RetrievalQuery);
-				return [{ packed, trace }];
-			},
-			{
-				meta: aiMeta("retrieval_reactive_result"),
-				initial: { packed: [] as ReadonlyArray<RetrievalEntry<TMem>>, trace: null },
-			},
-		);
-
-		// DS-13.5.C: projection stays as raw `node()` (not `sub.derived`)
-		// because the keepalive disposer is wired via the fn's
-		// `NodeFnCleanup.onDeactivation` hook — projection's cleanup-on-last-
-		// unsubscribe is what drives `parent.remove(segment)`. The Graph
-		// `.derived()` helper drops the cleanup return, so the raw form
-		// is required here. `equals: packedEquals` is preserved verbatim.
-		const projection = node<ReadonlyArray<RetrievalEntry<TMem>>>(
-			[result],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((b, i) =>
-					b != null && b.length > 0 ? b.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as { packed: ReadonlyArray<RetrievalEntry<TMem>> }).packed);
-				return {
-					onDeactivation: () => {
-						// Auto-unmount on last unsubscribe (DS-13.5.C).
-						// Idempotent: try/catch covers the case where the
-						// segment was already removed (e.g. parent destroy
-						// cascade ran first, or the caller called remove()
-						// manually).
-						try {
-							this.remove(segment);
-						} catch {
-							/* best-effort cleanup */
-						}
-					},
-				};
-			},
-			{
-				name: "projection",
-				describeKind: "derived",
-				meta: aiMeta("retrieval_reactive"),
-				initial: [] as ReadonlyArray<RetrievalEntry<TMem>>,
-				equals: packedEquals,
-			},
-		);
-		sub.add(projection, { name: "projection" });
-
-		this.mount(segment, sub);
-		return projection;
-	}
-}
-
-/**
- * Build the retrieval pipeline (vector + KG + budget packing) over a
- * `DistillBundle` and optional `vectors` / `kg` substrates. Returns a
- * `MemoryRetrievalGraph` exposing `retrieval` / `retrievalTrace` reactive
- * state and the `retrieveReactive(input)` consumer method.
- */
-export function memoryRetrieval<TMem>(
-	opts: MemoryRetrievalOptions<TMem>,
-): MemoryRetrievalGraph<TMem> {
-	return new MemoryRetrievalGraph<TMem>(opts);
-}
diff --git a/src/utils/ai/memory/retrieval.ts b/src/utils/ai/memory/retrieval.ts
deleted file mode 100644
index b1ebcc7d..00000000
--- a/src/utils/ai/memory/retrieval.ts
+++ /dev/null
@@ -1,68 +0,0 @@
-// ---------------------------------------------------------------------------
-// Retrieval Pipeline
-// ---------------------------------------------------------------------------
-
-import type { VectorSearchResult } from "../../memory/index.js";
-
-export type RetrievalQuery = {
-	readonly text?: string;
-	readonly vector?: readonly number[];
-	readonly entityIds?: readonly string[];
-	/**
-	 * Optional hierarchical context breadcrumb — e.g.
-	 * `["projects", "auth", "tokens"]`. When both the query and a candidate
-	 * entry supply a `context`, the retrieval pipeline applies a score boost
-	 * proportional to `contextWeight` for entries whose context overlaps
-	 * (shared prefix). Entries or queries without `context` are scored
-	 * flatly (backward-compatible).
-	 */
-	readonly context?: readonly string[];
-};
-
-export type RetrievalPipelineOptions<TMem> = {
-	/** Max candidates from vector search (default 20). */
-	topK?: number;
-	/** KG expansion depth in hops (default 1). */
-	graphDepth?: number;
-	/** Token budget for final packing (default 2000). */
-	budget?: number;
-	/** Cost function for budget packing. */
-	cost: (mem: TMem) => number;
-	/** Score function for ranking. */
-	score: (mem: TMem, context: unknown) => number;
-	/**
-	 * Optional accessor: extracts the hierarchical context breadcrumb from a
-	 * memory entry. Used with {@link RetrievalQuery.context} and
-	 * `contextWeight` to boost entries whose context overlaps the query.
-	 * Entries that don't expose context stay at flat behavior.
-	 */
-	contextOf?: (mem: TMem) => readonly string[] | undefined;
-	/**
-	 * Boost multiplier applied to a candidate's score when its `context`
-	 * shares a prefix with the query's `context`. Score is multiplied by
-	 * `(1 + contextWeight * sharedDepth / queryDepth)`. Default: 0 (no
-	 * context boost).
-	 */
-	contextWeight?: number;
-};
-
-/** A single entry in the retrieval result, with causal trace metadata. */
-export type RetrievalEntry<TMem> = {
-	readonly key: string;
-	readonly value: TMem;
-	readonly score: number;
-	readonly sources: ReadonlyArray<"vector" | "graph" | "store">;
-	/**
-	 * Hierarchical context breadcrumb for this entry, when
-	 * `RetrievalPipelineOptions.contextOf` is supplied and returns a value.
-	 */
-	readonly context?: readonly string[];
-};
-
-/** Causal trace for a retrieval run. */
-export type RetrievalTrace<TMem> = {
-	readonly vectorCandidates: ReadonlyArray<VectorSearchResult<TMem>>;
-	readonly graphExpanded: ReadonlyArray<string>;
-	readonly ranked: ReadonlyArray<RetrievalEntry<TMem>>;
-	readonly packed: ReadonlyArray<RetrievalEntry<TMem>>;
-};
diff --git a/src/utils/ai/memory/tiers.ts b/src/utils/ai/memory/tiers.ts
deleted file mode 100644
index a70f21d5..00000000
--- a/src/utils/ai/memory/tiers.ts
+++ /dev/null
@@ -1,49 +0,0 @@
-// ---------------------------------------------------------------------------
-// Memory Tiers
-// ---------------------------------------------------------------------------
-
-import type { Node } from "@graphrefly/pure-ts/core";
-import type { SnapshotStorageTier, StorageHandle } from "@graphrefly/pure-ts/extra";
-import type { GraphAttachStorageOptions, GraphCheckpointRecord } from "@graphrefly/pure-ts/graph";
-import { DEFAULT_DECAY_RATE } from "../../../base/utils/decay.js";
-import type { CollectionGraph } from "../../memory/index.js";
-
-export type MemoryTier = "permanent" | "active" | "archived";
-
-export type MemoryTiersOptions<TMem> = {
-	/** Exponential decay rate per second for active tier.
-	 *  Default: 7-day half-life ≈ ln(2)/(7×86400) ≈ 0.00000114. */
-	decayRate?: number;
-	/** Max entries in the active tier before archiving lowest-scored (default 1000). */
-	maxActive?: number;
-	/** Score threshold below which active entries get archived (default 0.1). */
-	archiveThreshold?: number;
-	/** Predicate: true → entry belongs in permanent tier (default: never). */
-	permanentFilter?: (key: string, mem: TMem) => boolean;
-	/** Storage tier for the archive. Omit to disable archiving. */
-	archiveTier?: SnapshotStorageTier<GraphCheckpointRecord>;
-	/** Options forwarded to `graph.attachSnapshotStorage` for the archive tier. */
-	archiveStorageOptions?: GraphAttachStorageOptions;
-};
-
-// `DEFAULT_DECAY_RATE` is canonical at `extra/utils/decay.ts` (Tier 4.4
-// Wave AM Unit 1). Re-exported here for backward-compat with existing
-// `patterns/ai/memory/` consumers.
-export { DEFAULT_DECAY_RATE };
-
-export type MemoryTiersBundle<TMem> = {
-	/**
-	 * Permanent tier: never evicted. Backed by a `collection({ranked:false})`
-	 * Graph (Tier 2.3 — was previously a `LightCollectionBundle`; the no-Graph
-	 * bundle shape was folded into the unified `CollectionGraph`).
-	 */
-	readonly permanent: CollectionGraph<TMem>;
-	/** Active entries node (reactive, holds ReadonlyMap). */
-	readonly activeEntries: Node<unknown>;
-	/** Archive storage handle (null if no tier configured). */
-	readonly archiveHandle: StorageHandle | null;
-	/** Classify a key into its current tier. */
-	tierOf: (key: string) => MemoryTier;
-	/** Move a key to the permanent tier. */
-	markPermanent: (key: string, value: TMem) => void;
-};
diff --git a/src/utils/ai/node.ts b/src/utils/ai/node.ts
deleted file mode 100644
index 612a66b0..00000000
--- a/src/utils/ai/node.ts
+++ /dev/null
@@ -1,20 +0,0 @@
-/**
- * Node-only surface for the AI patterns package.
- *
- * Re-exports the Node-specific `fallbackAdapter` variant (with filesystem
- * convenience options like `fixturesDir` / `record.dir`). Import from
- * `@graphrefly/graphrefly/utils/ai/node` in Node environments when you
- * want those ergonomics; otherwise the universal `@graphrefly/graphrefly/utils/ai`
- * entry covers everything without `node:*` imports.
- *
- * @module
- */
-
-export {
-	type BaseFallbackAdapterOptions,
-	type FallbackFixture,
-	type FallbackMissError,
-	type FallbackMissPolicy,
-	fallbackAdapter,
-	type NodeFallbackAdapterOptions,
-} from "./adapters/providers/fallback-node.js";
diff --git a/src/utils/ai/prompts/frozen-context.ts b/src/utils/ai/prompts/frozen-context.ts
deleted file mode 100644
index d13b698a..00000000
--- a/src/utils/ai/prompts/frozen-context.ts
+++ /dev/null
@@ -1,149 +0,0 @@
-/**
- * `frozenContext` — prefix-cache-friendly snapshot of upstream context.
- *
- * @module
- */
-
-import { factoryTag, type Node, node as nodeFactory } from "@graphrefly/pure-ts/core";
-import { fromAny, type NodeInput } from "@graphrefly/pure-ts/extra";
-import { aiMeta } from "../_internal.js";
-
-export type FrozenContextOptions = {
-	/**
-	 * Reactive signal that triggers re-materialization. Each `DATA` emission
-	 * from this node re-reads the source and refreshes the frozen value.
-	 * Typical shapes: `fromTimer(ms)` for periodic refresh, a stage-transition
-	 * node for event-driven refresh, or a manual `state<number>` the caller
-	 * increments via `setState(n + 1)`.
-	 *
-	 * When omitted, the frozen value is materialized exactly once (on first
-	 * subscribe) and never refreshes for the lifetime of the activation —
-	 * use this for session-start snapshots that must stay stable. The
-	 * single-shot latch IS reset on `INVALIDATE` (graph-wide flush via
-	 * `graph.signal([[INVALIDATE]])`), so callers who need an "evict and
-	 * re-materialize" escape hatch get one through the standard graph
-	 * lifecycle without having to wire a `refreshTrigger`.
-	 */
-	refreshTrigger?: NodeInput<unknown>;
-	name?: string;
-};
-
-/**
- * Freeze a reactive source into a stable snapshot that only re-materializes
- * on explicit trigger. Built for long-running harness loops where system
- * prompts include `agentMemory` / stage context — every reactive change to
- * the source invalidates the LLM provider's prefix cache, so re-rendering
- * the prompt every turn is expensive.
- *
- * `frozenContext(source)` reads the source once and caches the value;
- * downstream `promptNode` compositions see a stable reference until the
- * optional `refreshTrigger` fires.
- *
- * Trade-off: slightly stale context vs. prefix cache hit rate. For most
- * harness apps, the memory snapshot at session start is "good enough" —
- * refreshing on a coarse-grained trigger (`fromCron("*\/30min")`, stage
- * transition) preserves 90%+ prefix cache hits while keeping context useful.
- *
- * @example
- * ```ts
- * // Freeze agent memory for the duration of a stage.
- * const frozen = frozenContext(memory.context, {
- *   refreshTrigger: stage,  // re-materialize on stage change
- * });
- * const reply = promptNode({ context: frozen, ... });
- * ```
- *
- * @category patterns.ai
- */
-export function frozenContext<T>(
-	source: NodeInput<T>,
-	opts?: FrozenContextOptions,
-): Node<T | null> {
-	const src = fromAny(source);
-	const trigger = opts?.refreshTrigger != null ? fromAny(opts.refreshTrigger) : null;
-
-	// JSON-serializable subset of opts: omit `refreshTrigger` (a NodeInput).
-	const frozenArgs: Record<string, unknown> | undefined =
-		opts?.name !== undefined ? { name: opts.name } : undefined;
-	const frozenTag = factoryTag("frozenContext", frozenArgs);
-
-	// Single-shot path: deps = [src] only. Emit the first src value and then
-	// hold regardless of source drift.
-	if (trigger == null) {
-		return nodeFactory<T | null>(
-			[src],
-			(data, actions, ctx) => {
-				const alreadyEmitted = ctx.store.emitted === true;
-				if (alreadyEmitted) return;
-				const srcBatch = data[0];
-				const srcValue =
-					srcBatch != null && srcBatch.length > 0 ? srcBatch.at(-1) : ctx.prevData[0];
-				// Only emit once src has produced a settled value.
-				if (srcValue === undefined) return;
-				ctx.store.emitted = true;
-				actions.emit(srcValue as T);
-				// On INVALIDATE (graph-wide flush), reset the "already emitted"
-				// latch so the next fn re-run captures a fresh snapshot.
-				// Without this, INVALIDATE clears the cache but the latch stays
-				// armed, so subscribers stay on the cleared (null) state forever.
-				//
-				// Lock 6.D (Phase 13.6.B): clear `emitted` on deactivation —
-				// the pre-flip auto-wipe handled this implicitly.
-				//
-				// QA D1 (Phase 13.6.B QA pass): `onResubscribableReset` covers
-				// the multi-sub-stayed terminal-resubscribable path where
-				// `_deactivate` does NOT run but the lifecycle reset still
-				// needs to clear the latch. Without this slot, a sibling sink
-				// that keeps the node alive past terminal would pin
-				// `emitted === true` into the next subscription cycle and
-				// suppress every future emission.
-				const store = ctx.store;
-				return {
-					onInvalidate: () => {
-						store.emitted = false;
-					},
-					onDeactivation: () => {
-						delete store.emitted;
-					},
-					onResubscribableReset: () => {
-						delete store.emitted;
-					},
-				};
-			},
-			{
-				name: opts?.name ?? "frozenContext",
-				describeKind: "derived",
-				initial: null,
-				meta: aiMeta("frozen_context", { ...frozenTag }),
-			},
-		);
-	}
-
-	// Refresh-on-trigger path: deps = [src, trigger]. Emit the current src
-	// value ONLY when the trigger dep is involved in the wave. Source-only
-	// changes are silently held so downstream prompt composition sees the
-	// same value between triggers, preserving the LLM provider's prefix cache.
-	//
-	// Uses raw `node()` to inspect per-dep wave involvement — `derived` fires
-	// on any dep change and can't distinguish. The declaration-order semantic
-	// gap in multi-dep push-on-subscribe (§2.7) works in our favor on
-	// activation: src fires first (captured into ctx.prevData), trigger fires
-	// in a second wave → emit via prevData[0] fallback.
-	return nodeFactory<T | null>(
-		[src, trigger],
-		(data, actions, ctx) => {
-			const triggerBatch = data[1];
-			const triggered = triggerBatch != null && triggerBatch.length > 0;
-			if (!triggered) return;
-			const srcBatch = data[0];
-			const srcValue = srcBatch != null && srcBatch.length > 0 ? srcBatch.at(-1) : ctx.prevData[0];
-			actions.emit(srcValue as T);
-		},
-		{
-			name: opts?.name ?? "frozenContext",
-			describeKind: "derived",
-			initial: null,
-			meta: aiMeta("frozen_context", { ...frozenTag }),
-		},
-	);
-}
diff --git a/src/utils/ai/prompts/prompt-call.ts b/src/utils/ai/prompts/prompt-call.ts
deleted file mode 100644
index ac1f903a..00000000
--- a/src/utils/ai/prompts/prompt-call.ts
+++ /dev/null
@@ -1,144 +0,0 @@
-// ---------------------------------------------------------------------------
-// promptCall — public single-shot LLM JSON helper (Tier 4.6 Wave AM Unit 4
-// promotion from the previously-internal `llmJsonCall` in
-// `patterns/ai/memory/llm-memory.ts`).
-//
-// Wraps {@link promptNode} for the common "one-shot LLM JSON call per input"
-// shape: a per-call `node([], { initial: input })` is wrapped, the prompt builder runs against
-// it, and the returned `NodeInput<TOut>` slots into reactive callbacks like
-// `distill`'s `extractFn` / `consolidateFn`. Inherits markdown-fence stripping
-// and content-preview parse errors from `promptNode({format: "json"})`.
-//
-// `llmExtractor` / `llmConsolidator` are now thin wrappers over `promptCall`.
-// ---------------------------------------------------------------------------
-
-import { node } from "@graphrefly/pure-ts/core";
-import type { NodeInput } from "@graphrefly/pure-ts/extra";
-import type { Extraction } from "../../../base/composition/distill.js";
-import type { LLMAdapter } from "../adapters/core/types.js";
-import { promptNode } from "./prompt-node.js";
-
-/** Options accepted by {@link promptCall}, {@link llmExtractor}, and {@link llmConsolidator}. */
-export type PromptCallOptions = {
-	adapter: LLMAdapter;
-	model?: string;
-	temperature?: number;
-	maxTokens?: number;
-	/**
-	 * Optional name forwarded to the underlying `promptNode` (used as the
-	 * `<name>::messages` / `<name>::response` / `<name>::output` path prefix).
-	 * Defaults differ per call site so multiple `promptCall`s wired into the
-	 * same graph don't collide on `prompt_node::output`.
-	 */
-	name?: string;
-};
-
-/**
- * Build a one-shot LLM JSON-call factory: each invocation wraps `input` in a
- * fresh `node([], { initial: input })`, delegates to `promptNode({format: "json"})`, and
- * returns a `NodeInput<TOut>` that the caller plugs into `distill` /
- * `agentLoop` / any reactive composition that accepts `NodeInput`.
- *
- * **Per-call lifecycle.** The returned `NodeInput<TOut>` is a producer that
- * emits exactly one `DATA` per upstream input (per Tier 1.2 Session C lock —
- * `promptNode` guarantees one DATA per wave). When the consumer's switchMap
- * supersedes it, the per-call `node([], { initial: input })` and the inner `prompt_node::response`
- * tear down together.
- *
- * @param systemPrompt - System message sent on every call.
- * @param buildUserContent - Per-input user-content builder (must be JSON-stringifiable).
- * @param opts - Adapter + model/temperature/maxTokens + optional name prefix.
- * @param defaultName - Path-prefix fallback when `opts.name` is omitted.
- * @returns Factory `(input: TIn) => NodeInput<TOut>`.
- *
- * @category patterns
- */
-export function promptCall<TIn, TOut>(
-	systemPrompt: string,
-	buildUserContent: (input: TIn) => string,
-	opts: PromptCallOptions,
-	defaultName: string,
-): (input: TIn) => NodeInput<TOut> {
-	const name = opts.name ?? defaultName;
-	return (input: TIn) => {
-		// One-shot node([], { initial: input }) per call — switchMap teardown inside the
-		// consumer (e.g. distill) reclaims the node when the next upstream
-		// arrives or the bundle disposes.
-		const inputState = node<TIn>([], { initial: input });
-		return promptNode<TOut>(
-			opts.adapter,
-			[inputState as never],
-			(value: unknown) => buildUserContent(value as TIn),
-			{
-				name,
-				format: "json",
-				systemPrompt,
-				model: opts.model,
-				temperature: opts.temperature ?? 0,
-				maxTokens: opts.maxTokens,
-			},
-		) as NodeInput<TOut>;
-	};
-}
-
-/** Options accepted by {@link llmExtractor} and {@link llmConsolidator}. */
-export type LLMExtractorOptions = PromptCallOptions & {
-	/**
-	 * Cap the dedup-hint slice of `existingKeys` passed to the LLM. Larger
-	 * stores ship more keys (better dedup recall) at the cost of prompt size.
-	 * Default 100. Set to `Infinity` to forward every key.
-	 */
-	maxExistingKeys?: number;
-};
-
-/** Alias for backward compatibility. */
-export type LLMConsolidatorOptions = LLMExtractorOptions;
-
-/**
- * Returns an `extractFn` callback for `distill()` that invokes an LLM to
- * extract structured memories from raw input.
- *
- * The system prompt should instruct the LLM to return JSON matching
- * `Extraction<TMem>` shape: `{ upsert: [{ key, value }], remove?: [key] }`.
- *
- * Built on `promptNode({format: "json"})` — inherits markdown-fence stripping
- * and content-preview parse errors. Stack `withRetry` on the adapter for
- * transient-error tolerance (see `patterns/ai/adapters/middleware/retry.ts`).
- */
-export function llmExtractor<TRaw, TMem>(
-	systemPrompt: string,
-	opts: LLMExtractorOptions,
-): (raw: TRaw, existing: ReadonlyMap<string, TMem>) => NodeInput<Extraction<TMem>> {
-	const cap = opts.maxExistingKeys ?? 100;
-	const call = promptCall<{ raw: TRaw; existingKeys: string[] }, Extraction<TMem>>(
-		systemPrompt,
-		(input) => JSON.stringify({ input: input.raw, existingKeys: input.existingKeys }),
-		opts,
-		"llmExtractor",
-	);
-	return (raw: TRaw, existing: ReadonlyMap<string, TMem>) => {
-		const existingKeys =
-			cap === Number.POSITIVE_INFINITY ? [...existing.keys()] : [...existing.keys()].slice(0, cap);
-		return call({ raw, existingKeys });
-	};
-}
-
-/**
- * Returns a `consolidateFn` callback for `distill()` that invokes an LLM to
- * cluster and merge related memories.
- */
-export function llmConsolidator<TMem>(
-	systemPrompt: string,
-	opts: LLMConsolidatorOptions,
-): (entries: ReadonlyMap<string, TMem>) => NodeInput<Extraction<TMem>> {
-	const call = promptCall<readonly { key: string; value: TMem }[], Extraction<TMem>>(
-		systemPrompt,
-		(memories) => JSON.stringify({ memories }),
-		opts,
-		"llmConsolidator",
-	);
-	return (entries: ReadonlyMap<string, TMem>) => {
-		const memories = [...entries.entries()].map(([key, value]) => ({ key, value }));
-		return call(memories);
-	};
-}
diff --git a/src/utils/ai/prompts/prompt-node.ts b/src/utils/ai/prompts/prompt-node.ts
deleted file mode 100644
index e240ec4a..00000000
--- a/src/utils/ai/prompts/prompt-node.ts
+++ /dev/null
@@ -1,423 +0,0 @@
-/**
- * `promptNode` — universal LLM transform as a reactive derived node.
- *
- * The shape: `deps → messagesNode (derived) → switchMap → response (producer) → output`.
- * Each upstream wave is one LLM call; superseding waves cancel the in-flight
- * call via the abort signal threaded through `nodeSignal(opts.abort)`.
- *
- * The producer-shape on the inner is load-bearing: it emits exactly one DATA
- * + COMPLETE per wave, so the outer switchMap sees one DATA per wave (matches
- * the `HarnessExecutor` contract). A `node([response], (batchData, actions, ctx) => {
- *   const data = ...; actions.emit(parse(data[0]));
- * }, { describeKind: "derived" })` would have its
- * own first-run / push-on-subscribe semantics that can leak a transient null
- * before the real response arrives — observed and reverted in an earlier
- * attempt; see SESSION-ai-harness-module-review.md line 3654 for context.
- * Locked as path (b) producer-based by Session C (2026-04-27); inner-node
- * naming aligned to `prompt_node::response` per the C+D widening (2026-04-30).
- *
- * **Retry / replay-cache.** Stack middleware on the adapter:
- *
- * ```ts
- * import { withRetry, withReplayCache } from "@graphrefly/graphrefly/utils/ai";
- *
- * const adapter = withRetry(
- *   withReplayCache(baseAdapter, { keyFn: (ctx) => ctx.messages[0].content }),
- *   { count: 3, backoff: 200 },
- * );
- * const result = promptNode(adapter, [input], (q) => q);
- * ```
- *
- * `promptNode` no longer ships `retries` / `cache` options — they duplicated
- * middleware already at the adapter layer.
- *
- * **Cross-wave cache (COMPOSITION-GUIDE §32).** The switchMap output cache
- * survives across new outer DATAs — `promptNode`'s cached value persists
- * until the next wave fully resolves. Consumers that need to distinguish
- * "fresh value for THIS session" from "stale cache from a prior session"
- * (e.g. `agentLoop` resetting on new `run()`) must add a `node([])` mirror
- * at their session boundary and depend on the mirror, not the `promptNode`
- * output directly. `promptNode` itself stays primitive — it does not
- * embed a state-mirror.
- *
- * @module
- */
-
-import { COMPLETE, DATA, ERROR, type Node, node } from "@graphrefly/pure-ts/core";
-import { fromAny, type NodeInput, switchMap } from "@graphrefly/pure-ts/extra";
-import { nodeSignal } from "../../../base/sources/settled.js";
-import { aiMeta, stripFences } from "../_internal.js";
-import type {
-	ChatMessage,
-	LLMAdapter,
-	LLMInvokeOptions,
-	LLMResponse,
-	ToolDefinition,
-} from "../adapters/core/types.js";
-
-export type PromptNodeOptions = {
-	name?: string;
-	model?: string;
-	temperature?: number;
-	maxTokens?: number;
-	/**
-	 * Output format:
-	 * - `"text"` (default) — emit the response content as a string.
-	 * - `"json"` — `JSON.parse` the content (markdown fences stripped).
-	 * - `"raw"` — emit the full {@link LLMResponse} object (subsumes the
-	 *   pre-Tier-2.3 `fromLLM` shape; use this when you need `usage` /
-	 *   `toolCalls` / `finishReason` alongside `content`).
-	 */
-	format?: "text" | "json" | "raw";
-	/**
-	 * Reactive tool definitions forwarded to the adapter. Pair with
-	 * `format: "raw"` (or read `toolCalls` from a downstream parser) when
-	 * tool-calling is in scope.
-	 *
-	 * **Reactive declared edge** (DF12, Tier 7): `tools` is a `Node` so the
-	 * tools list participates in `describe()` topology and `explain()` causal
-	 * chains. The tools Node is added to `messagesNode`'s declared deps —
-	 * tools changes re-invoke the LLM (treated as a new call envelope).
-	 * Wrap with `distinctUntilChanged` upstream if your tool selector emits
-	 * noisy duplicates that would otherwise spam the adapter. See
-	 * COMPOSITION-GUIDE §31 (Dynamic tool selection) for the canonical
-	 * `toolSelector` pattern that produces this Node.
-	 *
-	 * **Activation note:** since `tools` is a real declared dep, `messagesNode`
-	 * waits for the tools Node to DATA at least once before firing
-	 * (push-on-subscribe SENTINEL gate). Pass a `node<ToolDefinition[]>([], { initial: [] })`
-	 * if you want immediate activation with no tools, or the latest published
-	 * `toolSelector.tools` Node.
-	 */
-	tools?: Node<readonly ToolDefinition[]>;
-	/**
-	 * Optional system prompt. Forwarded via `opts.systemPrompt` to the adapter
-	 * only — never pushed as a `{role:"system"}` message (avoiding the
-	 * double-send class of bug where adapters that normalize both shapes end
-	 * up with two system entries).
-	 */
-	systemPrompt?: string;
-	/**
-	 * Optional reactive abort signal. When the node emits `true`, the in-flight
-	 * `adapter.invoke()` call is cancelled via `AbortController.abort()`.
-	 * Threaded through `nodeSignal(abort)` — a one-shot bridge. Useful inside
-	 * agent state machines where a separate `aborted` state should cancel the
-	 * current LLM call without superseding via switchMap.
-	 */
-	abort?: Node<boolean>;
-	meta?: Record<string, unknown>;
-};
-
-/** Extract text content from an LLM response, handling various response shapes. */
-function extractContent(resp: unknown): string {
-	if (resp != null && typeof resp === "object" && "content" in resp) {
-		return String((resp as LLMResponse).content);
-	}
-	if (typeof resp === "string") return resp;
-	return String(resp);
-}
-
-function previewContent(text: string, max = 200): string {
-	if (text.length <= max) return text;
-	return `${text.slice(0, max)}…`;
-}
-
-/**
- * Universal LLM transform: wraps a prompt template + model adapter into a reactive derived node.
- * Re-invokes the LLM whenever any dep changes. Suitable for triage, QA, hypothesis, parity, etc.
- *
- * **Topology** (visible in `describe()`):
- * ```
- * <deps...>, [tools?]  → <name>::messages   (derived, meta.ai = prompt_node::messages)
- * <name>::messages     → <name>::output     (switchMap product, meta.ai = prompt_node::output)
- *   per-wave inner:    <name>::response     (producer, meta.ai = prompt_node::response)
- * ```
- * When `opts.tools` is supplied, the tools `Node` is appended to
- * `messagesNode`'s declared deps so it appears as a real edge in `describe()`
- * / `explain()` (DF12, Tier 7).
- *
- * **No-input semantics** (matches the codebase-wide SENTINEL convention):
- * - **Initial no-input** (no real input has ever arrived) — emits nothing.
- *   Outer cache stays `undefined`; `subscribe` consumers see no DATA event.
- *   Use this to keep downstream gating clean: a `withLatestFrom`-paired
- *   trigger won't fire until the LLM has actually produced something.
- * - **Mid-flow no-input** (input dropped to nullish after at least one
- *   real LLM call) — emits `null` as a domain "input went away" signal.
- *   Downstream consumers can distinguish "haven't started" from "input
- *   gone."
- *
- * **Retries / caching:** stack `withRetry` / `withReplayCache` middleware on the
- * `adapter` argument — `promptNode` no longer ships its own duplicated retry /
- * cache loops (pre-1.0 cleanup, see review session 1).
- *
- * @param adapter - LLM adapter (provider-agnostic). Wrap with `withRetry` /
- *                   `withReplayCache` middleware for transient-error tolerance
- *                   or replay caching.
- * @param deps - Input nodes whose values feed the prompt.
- * @param prompt - Static string or template function receiving dep values.
- * @param opts - Optional configuration.
- * @returns `Node` emitting LLM responses (string or parsed JSON).
- */
-// Overload 1: `format: "raw"` constrains the emit type to `LLMResponse | null`
-// (the full adapter response, with `usage` / `toolCalls` / `finishReason`).
-// Subsumes the pre-Tier-2.3 `fromLLM` shape.
-export function promptNode(
-	adapter: LLMAdapter,
-	deps: readonly Node<unknown>[],
-	prompt: string | ((...depValues: unknown[]) => string),
-	opts: PromptNodeOptions & { format: "raw" },
-): Node<LLMResponse | null>;
-// Overload 2: `format: "text" | "json"` (default text) — emit-type is the
-// caller's `T` (defaults to `string`). For `"json"` callers typically pass
-// the parsed shape (e.g. `promptNode<MyShape>(...)`).
-export function promptNode<T = string>(
-	adapter: LLMAdapter,
-	deps: readonly Node<unknown>[],
-	prompt: string | ((...depValues: unknown[]) => string),
-	opts?: Omit<PromptNodeOptions, "format"> & { format?: "text" | "json" },
-): Node<T | null>;
-export function promptNode<T = string>(
-	adapter: LLMAdapter,
-	deps: readonly Node<unknown>[],
-	prompt: string | ((...depValues: unknown[]) => string),
-	opts?: PromptNodeOptions,
-): Node<T | null> {
-	const format = opts?.format ?? "text";
-	const baseName = opts?.name ?? "prompt_node";
-
-	// qa A8: tools without `format: "raw"` is a footgun — adapter receives
-	// the tool definitions and may produce `toolCalls`, but the emit path
-	// only extracts `content`. Warn at construction; downstream parsers
-	// reading `toolCalls` from a custom `format: "raw"` consumer pattern
-	// can ignore by setting `format: "raw"` (intent now matches behavior).
-	if (opts?.tools !== undefined && format !== "raw") {
-		console.warn(
-			"promptNode: `tools` is set but `format !== 'raw'`. " +
-				"Tool calls in the response will be silently dropped — set " +
-				"`format: 'raw'` to receive the full LLMResponse with `toolCalls`.",
-		);
-	}
-
-	// SENTINEL semantics rely on the universal first-run gate + standard
-	// prevData semantics (undefined = SENTINEL, any other value = DATA seen):
-	//   - **Initial no-input** (no dep has ever DATA'd, so prevData is
-	//     undefined across the board): the `derived`'s first-run gate blocks
-	//     `messagesNode`'s fn entirely. It never emits, switchMap never
-	//     fires, outer cache stays `undefined`.
-	//   - **Mid-flow no-input** (deps previously DATA'd then went nullish):
-	//     fn runs, returns `[]`, switchMap dispatches the `node([], { initial: null })`
-	//     branch → outer emits `null` as the domain "input went away" signal.
-	// No `initial: []` and no closure flag — `prevData === undefined` is
-	// already the sentinel marker, and the gate already enforces "don't fire
-	// fn until every dep has DATA'd at least once."
-	//
-	// DF12: when `opts.tools` is a Node, it's appended to `messagesNode`'s
-	// declared deps. The fn slices values into user-deps + tools, and emits
-	// an envelope `{ messages, tools }` so switchMap's per-wave inner can
-	// read the latest tools via the reactive edge instead of a closure.
-	type Envelope = {
-		messages: readonly ChatMessage[];
-		tools: readonly ToolDefinition[] | undefined;
-	};
-	const userDepsLength = deps.length;
-	const allDeps: readonly Node<unknown>[] =
-		opts?.tools !== undefined ? [...deps, opts.tools as Node<unknown>] : deps;
-	const messagesNode = node<Envelope>(
-		allDeps as Node<unknown>[],
-		(batchData, actions, ctx) => {
-			const data = batchData.map((batch, i) =>
-				batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-			);
-			const userValues = data.slice(0, userDepsLength);
-			const toolsValue =
-				opts?.tools !== undefined
-					? (data[userDepsLength] as readonly ToolDefinition[] | undefined)
-					: undefined;
-			// Dep-level null guard (composition guide §8): if any USER dep is
-			// nullish, emit empty messages → switchMap emits null (mid-flow
-			// drop-out). The tools dep can legitimately be empty `[]`; only
-			// user deps gate the call.
-			if (userValues.some((v) => v == null)) {
-				actions.emit({ messages: [], tools: toolsValue });
-				return;
-			}
-			const text = typeof prompt === "string" ? prompt : prompt(...userValues);
-			if (!text) {
-				actions.emit({ messages: [], tools: toolsValue });
-				return;
-			}
-			// systemPrompt forwarded through invoke opts only (no double-send).
-			actions.emit({
-				messages: [{ role: "user" as const, content: text }],
-				tools: toolsValue,
-			});
-		},
-		{
-			name: `${baseName}::messages`,
-			meta: aiMeta("prompt_node::messages"),
-		},
-	);
-
-	const result = switchMap<Envelope, T | null>(
-		messagesNode,
-		(envelope) => {
-			const { messages: msgs, tools } = envelope;
-			if (!msgs || msgs.length === 0) {
-				return node<T | null>([], { initial: null }) as NodeInput<T | null>;
-			}
-
-			// Producer ensures exactly one DATA + COMPLETE per wave; switchMap
-			// sees one DATA, the harness's "one emission per wave" contract is
-			// honored. Earlier attempts using a derived node leaked
-			// transient nulls via the derived's first-run gate.
-			return node<T | null>(
-				(_data, actions) => {
-					let done = false;
-					let cancelled = false;
-					let abortDispose: (() => void) | undefined;
-
-					const invokeOpts: LLMInvokeOptions = {
-						model: opts?.model,
-						temperature: opts?.temperature,
-						maxTokens: opts?.maxTokens,
-						systemPrompt: opts?.systemPrompt,
-						...(tools !== undefined ? { tools } : {}),
-					};
-					if (opts?.abort) {
-						const sig = nodeSignal(opts.abort);
-						invokeOpts.signal = sig.signal;
-						abortDispose = sig.dispose;
-					}
-
-					let invokeResult: NodeInput<LLMResponse>;
-					try {
-						invokeResult = adapter.invoke(msgs, invokeOpts);
-					} catch (err) {
-						done = true;
-						actions.down([[ERROR, err]]);
-						return {
-							onDeactivation: () => {
-								abortDispose?.();
-							},
-						};
-					}
-
-					const callNode = fromAny(invokeResult);
-
-					const sub = callNode.subscribe((batch) => {
-						if (cancelled || done) return;
-						for (const msg of batch) {
-							// F-11: re-check `cancelled` (and `done`) at the top of
-							// each per-message iteration so a teardown / abort that
-							// fires synchronously between messages stops processing
-							// further batched messages immediately.
-							if (cancelled || done) return;
-							if (msg[0] === DATA) {
-								const resp = msg[1] as LLMResponse;
-								// `format: "raw"` bypasses parsing — emit the full
-								// LLMResponse object (subsumes the pre-Tier-2.3 `fromLLM`
-								// output shape).
-								if (format === "raw") {
-									actions.emit(resp as unknown as T);
-								} else {
-									// F-12: cache the extracted content once on the
-									// parse-failure path so we don't call
-									// `extractContent(resp)` twice (once for parsing,
-									// once for the error-message preview).
-									let content: string;
-									try {
-										content = extractContent(resp);
-									} catch (err) {
-										// extractContent itself failed — propagate as
-										// an ERROR with a generic raw-extraction message.
-										const wrapped = new Error(
-											`promptNode: failed to extract content from LLM response: ${
-												(err as Error).message
-											}`,
-										);
-										// F-7: dispose abort hook on terminal-error
-										// branches so we don't retain the AbortController
-										// after the wave terminates. Idempotent.
-										abortDispose?.();
-										abortDispose = undefined;
-										done = true;
-										actions.down([[ERROR, wrapped]]);
-										return;
-									}
-									try {
-										const parsed: T =
-											format === "json"
-												? (JSON.parse(stripFences(content)) as T)
-												: (content as unknown as T);
-										actions.emit(parsed);
-									} catch (err) {
-										const wrapped = new Error(
-											`promptNode: failed to parse LLM response as JSON: ${
-												(err as Error).message
-											}\n  Raw content (first 200 chars): ${previewContent(content)}`,
-										);
-										// F-7: dispose abort hook on parse-error
-										// terminal branch.
-										abortDispose?.();
-										abortDispose = undefined;
-										done = true;
-										actions.down([[ERROR, wrapped]]);
-										return;
-									}
-								}
-							} else if (msg[0] === ERROR) {
-								// F-7: dispose abort hook on terminal ERROR branch.
-								abortDispose?.();
-								abortDispose = undefined;
-								done = true;
-								actions.down([[ERROR, msg[1]]]);
-								return;
-							} else if (msg[0] === COMPLETE) {
-								// Adapter completed — propagate. emit() above already
-								// queued the parsed value so the wave carries DATA + COMPLETE.
-								// F-7: dispose abort hook on terminal COMPLETE branch.
-								abortDispose?.();
-								abortDispose = undefined;
-								done = true;
-								actions.down([[COMPLETE]]);
-								return;
-							} else {
-								// Spec §1.3.6 forward-unknown — DIRTY/RESOLVED/INVALIDATE/
-								// PAUSE/RESUME etc. should propagate so downstream caches /
-								// flow-control hooks aren't starved. Re-typed `as never`
-								// because the call's NodeInput<LLMResponse> message tuple
-								// is wider than the unbound `T` projection.
-								actions.down([msg as never]);
-							}
-						}
-					});
-
-					return {
-						onDeactivation: () => {
-							cancelled = true;
-							sub();
-							// F-7: cleanup callback's abortDispose call is idempotent —
-							// the terminal-branch dispose above sets `abortDispose =
-							// undefined` so this is a no-op when terminal-fired.
-							abortDispose?.();
-							abortDispose = undefined;
-						},
-					};
-				},
-				{
-					describeKind: "producer",
-					name: `${baseName}::response`,
-					meta: aiMeta("prompt_node::response"),
-				},
-			) as NodeInput<T | null>;
-		},
-		{
-			name: `${baseName}::output`,
-			meta: opts?.meta
-				? { ...aiMeta("prompt_node::output"), ...opts.meta }
-				: aiMeta("prompt_node::output"),
-		},
-	);
-
-	return result;
-}
diff --git a/src/utils/ai/prompts/streaming.ts b/src/utils/ai/prompts/streaming.ts
deleted file mode 100644
index 6a621242..00000000
--- a/src/utils/ai/prompts/streaming.ts
+++ /dev/null
@@ -1,481 +0,0 @@
-/**
- * `streamingPromptNode` + `gatedStream` — streaming LLM transforms.
- *
- * **Wave A Unit 2 rewrite:**
- * - `StreamChunk` retired. The live stream surface is now `deltaTopic:
- *   TopicGraph<StreamDelta & {seq, ts}>` — every adapter delta (token,
- *   thinking, tool-call, usage, finish) is published in order. The previous
- *   shape retained the accumulated text per-chunk, producing O(N²) memory;
- *   the new shape stores only per-delta payloads (O(N)).
- * - New `accumulatedText: Node<string>` on the bundle — lazy-built via
- *   `ctx.store` over token-type deltas. Text-only extractors (`streamExtractor`,
- *   `keywordFlagExtractor`, `toolCallExtractor`) consume this node.
- * - `retainedLimit?: number` option exposed for the delta topic (no default —
- *   session scale is domain-specific per Unit 2 Q2).
- * - Unconditional `keepalive(output)` removed — callers subscribe as needed.
- * - System-prompt double-send fixed (matches promptNode Unit 1 fix).
- * - `format: "json"` throws on parse error with a content-preview diagnostic
- *   (parity with `promptNode`).
- * - Shared body between `streamingPromptNode` and `gatedStream` extracted
- *   into `streamingInvoke` per Unit 2 locked scope.
- *
- * @module
- */
-
-import { batch, factoryTag, type Node, node, wallClockNs } from "@graphrefly/pure-ts/core";
-import { filter, fromAny, keepalive, type NodeInput, switchMap } from "@graphrefly/pure-ts/extra";
-import type { Graph } from "@graphrefly/pure-ts/graph";
-import { type TopicGraph, topic } from "../../messaging/index.js";
-import { type GateController, type GateOptions, pipelineGraph } from "../../orchestration/index.js";
-import { aiMeta, stripFences } from "../_internal.js";
-import type { ChatMessage, LLMAdapter, StreamDelta } from "../adapters/core/types.js";
-
-/**
- * A single delta published to the `deltaTopic`. Every adapter emission is
- * forwarded — not just token deltas — so consumers see the full event log
- * (thinking, tool-call-delta, usage, finish).
- */
-export type StampedDelta = StreamDelta & {
-	/** Monotonic per-stream counter starting at 0. */
-	readonly seq: number;
-	/** Wall-clock nanoseconds at publish time (spec §5.11 central timer). */
-	readonly ts: number;
-};
-
-export type StreamingPromptNodeOptions = {
-	name?: string;
-	model?: string;
-	temperature?: number;
-	maxTokens?: number;
-	/** Output format — `"json"` attempts JSON.parse on accumulated text. Throws on parse failure. Default: `"text"`. */
-	format?: "text" | "json";
-	systemPrompt?: string;
-	meta?: Record<string, unknown>;
-	/**
-	 * Optional retention cap on the delta topic. Omit for unbounded retention
-	 * (the topic grows until `dispose()`). Recommended values: `8_192` for
-	 * single-shot 8K-token responses, `1_000_000` for persistent session
-	 * topics, or explicit `dispose()` for worker-pool patterns.
-	 */
-	retainedLimit?: number;
-};
-
-/**
- * Bundle returned by {@link streamingPromptNode}.
- */
-export type StreamingPromptNodeHandle<T> = {
-	/** Final parsed result (emits once per invocation, after stream completes). */
-	output: Node<T | null>;
-	/** Live delta topic — every adapter delta in order, stamped with `seq` + `ts`. */
-	deltaTopic: TopicGraph<StampedDelta>;
-	/**
-	 * Reactive accumulated-text view — lazy-built over `deltaTopic.latest`
-	 * filtered on `type === "token"`. Text-only extractors compose on this.
-	 * Emits the empty string before any token arrives.
-	 */
-	accumulatedText: Node<string>;
-	/** Tear down the delta topic and release resources. */
-	dispose: () => void;
-};
-
-/**
- * Internal pump: open a stream against `adapter`, stamp each delta, publish
- * to `deltaTopic`, and return the final accumulated text. Extracted so
- * `gatedStream` can reuse the body (Unit 2 locked scope).
- */
-async function streamingInvoke(
-	adapter: LLMAdapter,
-	msgs: readonly ChatMessage[],
-	invokeOpts: {
-		model?: string;
-		temperature?: number;
-		maxTokens?: number;
-		systemPrompt?: string;
-		signal: AbortSignal;
-	},
-	deltaTopic: TopicGraph<StampedDelta>,
-): Promise<string> {
-	let accumulated = "";
-	let seq = 0;
-	for await (const delta of adapter.stream(msgs, invokeOpts)) {
-		deltaTopic.publish({ ...delta, seq: seq++, ts: wallClockNs() } as StampedDelta);
-		if (delta.type === "token") accumulated += delta.delta;
-	}
-	return accumulated;
-}
-
-/** Parse accumulated text per `format`. Throws on JSON parse failure. */
-function parseAccumulated<T>(accumulated: string, format: "text" | "json"): T | null {
-	if (format === "json") {
-		try {
-			return JSON.parse(stripFences(accumulated)) as T;
-		} catch (err) {
-			const preview = accumulated.slice(0, 160);
-			throw new Error(
-				`streamingPromptNode: format:"json" — failed to parse accumulated text as JSON: ${(err as Error).message}; content preview: ${preview}`,
-			);
-		}
-	}
-	return accumulated as unknown as T;
-}
-
-/**
- * Build the lazy `accumulatedText` derived that maintains a running string
- * over `deltaTopic.latest` filtered on token deltas. Uses `ctx.store` per
- * COMPOSITION-GUIDE §20 — accumulator clears on deactivation.
- */
-function makeAccumulatedText(deltaTopic: TopicGraph<StampedDelta>, name: string): Node<string> {
-	// Lock 6.D (Phase 13.6.B): clear acc on deactivation so a resubscribed
-	// accumulator starts fresh. Pre-flip this came for free via
-	// `_deactivate`'s store wipe.
-	let cleanup: { onDeactivation: () => void } | undefined;
-	return node<string>(
-		[deltaTopic.latest],
-		(batchData, actions, ctx) => {
-			if (cleanup === undefined) {
-				const store = ctx.store;
-				cleanup = {
-					onDeactivation: () => {
-						delete store.acc;
-					},
-				};
-			}
-			const data = batchData.map((batch, i) =>
-				batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-			);
-			const d = data[0];
-			const store = ctx.store as { acc?: string };
-			if (d === undefined) {
-				actions.emit(store.acc ?? "");
-				return cleanup;
-			}
-			const delta = d as StampedDelta;
-			// `seq === 0` marks the first delta of a fresh invocation — reset
-			// the accumulator so runs don't concatenate across switchMap
-			// supersedes. Without this, invocation 2's text would be appended
-			// to invocation 1's text (the `deltaTopic` outlives each switchMap
-			// inner, so `ctx.store.acc` would otherwise persist).
-			if (delta.seq === 0) store.acc = "";
-			if (delta.type === "token") {
-				store.acc = (store.acc ?? "") + delta.delta;
-			}
-			actions.emit(store.acc ?? "");
-			return cleanup;
-		},
-		{
-			name,
-			describeKind: "derived",
-			meta: aiMeta("accumulated_text"),
-			initial: "",
-		},
-	);
-}
-
-/**
- * Streaming LLM transform: wraps a prompt template + adapter into a reactive
- * streaming pipeline. Re-invokes the LLM whenever any dep changes; the
- * previous in-flight stream is canceled automatically via `switchMap`.
- *
- * Every adapter delta is published to `deltaTopic` stamped with `seq` + `ts`.
- * Text consumers subscribe to `accumulatedText` (auto-maintained). Delta-
- * specific consumers (`costMeterExtractor` on `usage` deltas) subscribe to
- * `deltaTopic` directly and filter by `delta.type`.
- *
- * The async boundary is handled by `fromAny(asyncGenerator)` (spec §5.10).
- */
-export function streamingPromptNode<T = string>(
-	adapter: LLMAdapter,
-	deps: readonly Node<unknown>[],
-	prompt: string | ((...depValues: unknown[]) => string),
-	opts?: StreamingPromptNodeOptions,
-): StreamingPromptNodeHandle<T> {
-	const sourceName = opts?.name ?? "llm";
-	const format = opts?.format ?? "text";
-	const deltaTopic = topic<StampedDelta>(`${sourceName}/stream`, {
-		...(opts?.retainedLimit != null ? { retainedLimit: opts.retainedLimit } : {}),
-	});
-
-	const messagesNode = node<readonly ChatMessage[]>(
-		deps as Node<unknown>[],
-		(batchData, actions, ctx) => {
-			const data = batchData.map((batch, i) =>
-				batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-			);
-			if (data.some((v) => v == null)) {
-				actions.emit([]);
-				return;
-			}
-			const text = typeof prompt === "string" ? prompt : prompt(...data);
-			if (!text) {
-				actions.emit([]);
-				return;
-			}
-			actions.emit([{ role: "user", content: text }]);
-		},
-		{
-			name: `${sourceName}::messages`,
-			meta: aiMeta("prompt_node::messages"),
-			initial: [] as readonly ChatMessage[],
-		},
-	);
-
-	const output = switchMap(
-		messagesNode,
-		(msgs) => {
-			const chatMsgs = msgs as readonly ChatMessage[];
-			if (!chatMsgs || chatMsgs.length === 0) {
-				return node<T | null>([], { initial: null }) as NodeInput<T | null>;
-			}
-			const ac = new AbortController();
-			async function* pumpAndCollect(): AsyncGenerator<T | null> {
-				try {
-					const accumulated = await streamingInvoke(
-						adapter,
-						chatMsgs,
-						{
-							model: opts?.model,
-							temperature: opts?.temperature,
-							maxTokens: opts?.maxTokens,
-							systemPrompt: opts?.systemPrompt,
-							signal: ac.signal,
-						},
-						deltaTopic,
-					);
-					yield parseAccumulated<T>(accumulated, format);
-				} finally {
-					ac.abort();
-				}
-			}
-			return fromAny(pumpAndCollect());
-		},
-		{ meta: factoryTag("streamingPromptNode") },
-	);
-
-	const accumulatedText = makeAccumulatedText(deltaTopic, `${sourceName}::accumulatedText`);
-
-	// Keepalive on `output` — a caller who subscribes ONLY to `deltaTopic` or
-	// `accumulatedText` expects the stream to run (that's the bundle contract
-	// — three reactive surfaces, any one of them activates the pipeline).
-	// Without this, the lazy `switchMap` stays cold until someone subscribes
-	// to `.output` directly, and deltas never flow. The original
-	// `streamingPromptNode` carried this keepalive; the Unit 2 "zero overhead
-	// if nobody subscribes" removal broke the bundle-activation contract.
-	// Restored here with explicit dispose so the keepalive follows the bundle.
-	const unsubOutput = keepalive(output);
-
-	return {
-		output,
-		deltaTopic,
-		accumulatedText,
-		dispose: () => {
-			unsubOutput();
-			deltaTopic.destroy();
-		},
-	};
-}
-
-export type GatedStreamOptions = StreamingPromptNodeOptions & {
-	/** Gate options (maxPending, startOpen). */
-	gate?: Omit<GateOptions, "meta">;
-};
-
-/**
- * Bundle returned by {@link gatedStream}.
- */
-export type GatedStreamHandle<T> = {
-	/** Final parsed result (after gate approval). */
-	output: Node<T | null>;
-	/** Live delta topic — every adapter delta in order, stamped with `seq` + `ts`. */
-	deltaTopic: TopicGraph<StampedDelta>;
-	/** Reactive accumulated-text view. */
-	accumulatedText: Node<string>;
-	/**
-	 * Gate controller — approve, reject (aborts in-flight stream), modify.
-	 * The gate's DATA domain is `T` (not `T | null`): the pre-gate `filter`
-	 * drops nulls, so the pending queue never holds a null. The controller's
-	 * `node` output type stays `T | null` only because `gate.approve()` on an
-	 * empty queue would surface `null` — callers should treat `null` as "no
-	 * value" rather than as a modeled null signal.
-	 */
-	gate: GateController<T>;
-	/** Tear down the delta topic + gate keepalive. */
-	dispose: () => void;
-};
-
-/**
- * Streaming LLM transform with human-in-the-loop gate integration.
- *
- * Composes {@link streamingPromptNode} with `gate` so that:
- * - `gate.reject()` discards the pending value **and** aborts the in-flight
- *   stream (toggles an internal cancel signal → switchMap restart → abort).
- * - `gate.modify()` transforms the pending value before forwarding downstream.
- * - `gate.approve()` forwards the final result as normal.
- *
- * Wave A Unit 2 defers full `gatedStream` review to Wave B Unit 17 (the
- * `gate()` primitive itself is reviewed there). This implementation retains
- * the existing gate API while adopting the Unit 2 delta-topic shape.
- */
-export function gatedStream<T = string>(
-	graph: Graph,
-	name: string,
-	adapter: LLMAdapter,
-	deps: readonly Node<unknown>[],
-	prompt: string | ((...depValues: unknown[]) => string),
-	opts?: GatedStreamOptions,
-): GatedStreamHandle<T> {
-	const cancelSignal = node<number>([], { name: `${name}/cancel`, initial: 0 });
-	let cancelCounter = 0;
-
-	const allDeps = [...deps, cancelSignal] as readonly Node<unknown>[];
-
-	const sourceName = opts?.name ?? name;
-	const format = opts?.format ?? "text";
-	const deltaTopic = topic<StampedDelta>(`${sourceName}/stream`, {
-		...(opts?.retainedLimit != null ? { retainedLimit: opts.retainedLimit } : {}),
-	});
-
-	const messagesNode = node<readonly ChatMessage[]>(
-		allDeps as Node<unknown>[],
-		(batchData, actions, ctx) => {
-			const data = batchData.map((batch, i) =>
-				batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-			);
-			// Last dep is the cancel signal — exclude from prompt args.
-			const depValues = data.slice(0, -1);
-			if (depValues.some((v) => v == null)) {
-				actions.emit([]);
-				return;
-			}
-			const text = typeof prompt === "string" ? prompt : prompt(...depValues);
-			if (!text) {
-				actions.emit([]);
-				return;
-			}
-			actions.emit([{ role: "user", content: text }]);
-		},
-		{
-			name: `${sourceName}::messages`,
-			meta: aiMeta("prompt_node::messages"),
-			initial: [] as readonly ChatMessage[],
-		},
-	);
-
-	const output = switchMap(
-		messagesNode,
-		(msgs) => {
-			const chatMsgs = msgs as readonly ChatMessage[];
-			if (!chatMsgs || chatMsgs.length === 0) {
-				return node<T | null>([], { initial: null }) as NodeInput<T | null>;
-			}
-			const ac = new AbortController();
-			async function* pumpAndCollect(): AsyncGenerator<T | null> {
-				try {
-					const accumulated = await streamingInvoke(
-						adapter,
-						chatMsgs,
-						{
-							model: opts?.model,
-							temperature: opts?.temperature,
-							maxTokens: opts?.maxTokens,
-							systemPrompt: opts?.systemPrompt,
-							signal: ac.signal,
-						},
-						deltaTopic,
-					);
-					yield parseAccumulated<T>(accumulated, format);
-				} finally {
-					ac.abort();
-				}
-			}
-			return fromAny(pumpAndCollect());
-		},
-		{ meta: factoryTag("gatedStream") },
-	);
-
-	const accumulatedText = makeAccumulatedText(deltaTopic, `${sourceName}::accumulatedText`);
-
-	// Filter out null stream results so the gate only sees real values. Using
-	// `filter()` (not a `derived` with `return undefined`) is load-bearing:
-	// `derived`'s wrapper always calls `actions.emit(fn(data))`, so returning
-	// `undefined` would still emit `DATA(undefined)` into the gate's pending
-	// queue — approve/modify would then surface `undefined` to downstream
-	// consumers. `filter` propagates RESOLVED for falsey matches, keeping the
-	// queue clean. (This was the second half of the gatedStream activation
-	// fix — the first was keepalive-ing `gateCtrl.output`.)
-	const nonNullOutput = filter<T | null>(output, (v) => v != null) as Node<T>;
-	graph.add(nonNullOutput, { name: `${name}/raw` });
-
-	// Wire gate on the output. Type parameter is `T` (not `T | null`) — the
-	// `filter` above drops nulls before they reach the gate, so the pending
-	// queue's DATA domain is `T` only.
-	//
-	// C3 — `nonNullOutput` is owned by the parent `graph`. Pass it as a Node
-	// ref to `approvalGate`; the gate's foreign-source path wraps it in a
-	// local proxy derived registered under `${name}/gate/source` inside
-	// gateSubgraph. The dual-add pattern (`graph.add` + `gateSubgraph.add`)
-	// is retired — Session B.1's "no wrapper" invariant gave way to the
-	// single-owner invariant per the C3 lock.
-	const gateSubgraph = pipelineGraph(`${name}/gate-graph`);
-	graph.mount(`${name}/gate-graph`, gateSubgraph);
-	const gateCtrl = gateSubgraph.approvalGate<T>(
-		`${name}/gate`,
-		nonNullOutput as Node<unknown>,
-		opts?.gate,
-	);
-
-	// Keepalive the switchMap product, the gate's output node, AND the
-	// accumulator so the full bundle contract ("three reactive surfaces, any
-	// one activates the pipeline") holds:
-	//
-	// - `keepalive(output)` activates the streaming switchMap so the adapter
-	//   generator runs even before a downstream subscriber attaches.
-	// - `keepalive(gateCtrl.output)` activates the gate's fn body — which is
-	//   what writes into the internal `pending` queue. Without it, a caller
-	//   that only subscribes to `gate.count` / `gate.pending` / `deltaTopic`
-	//   (but not `gate.output`) would see `count` stuck at 0 indefinitely:
-	//   stream values reach the gate's input but the gate's fn never runs.
-	// - `keepalive(accumulatedText)` ensures `.cache` reflects the running
-	//   total for callers that read the accumulator as a snapshot instead of
-	//   subscribing to it.
-	//
-	// Dropping any of the three surfaces as a silent stall in `ai.test.ts`'s
-	// gatedStream suite.
-	//
-	// All three unsubs are also registered with the host graph so
-	// `parent.destroy()` reclaims them even if the caller forgets to call
-	// `dispose()`. `dispose()` itself runs them eagerly for prompt teardown.
-	const unsubOutput = keepalive(output);
-	const unsubGate = keepalive(gateCtrl.output);
-	const unsubAccumulated = keepalive(accumulatedText);
-	graph.addDisposer(unsubOutput);
-	graph.addDisposer(unsubGate);
-	graph.addDisposer(unsubAccumulated);
-
-	// Wrap reject to also abort the in-flight stream. Both mutations happen
-	// inside `batch()` so downstream subscribers never observe a torn state
-	// where `gate.count` has decremented but `cancelSignal` hasn't yet
-	// advanced (spec §2 two-phase DIRTY-before-DATA atomicity).
-	const originalReject = gateCtrl.reject.bind(gateCtrl);
-	const gateWithAbort: GateController<T> = {
-		...gateCtrl,
-		reject(count = 1) {
-			batch(() => {
-				originalReject(count);
-				cancelSignal.emit(++cancelCounter);
-			});
-		},
-	};
-
-	return {
-		output: gateCtrl.output,
-		deltaTopic,
-		accumulatedText,
-		gate: gateWithAbort,
-		dispose: () => {
-			unsubOutput();
-			unsubGate();
-			unsubAccumulated();
-			deltaTopic.destroy();
-		},
-	};
-}
diff --git a/src/utils/ai/prompts/system-prompt.ts b/src/utils/ai/prompts/system-prompt.ts
deleted file mode 100644
index f7fe9609..00000000
--- a/src/utils/ai/prompts/system-prompt.ts
+++ /dev/null
@@ -1,43 +0,0 @@
-/**
- * `systemPromptBuilder` — assembles a reactive system prompt from sections.
- *
- * @module
- */
-
-import { type Node, node } from "@graphrefly/pure-ts/core";
-
-import { fromAny, keepalive, type NodeInput } from "@graphrefly/pure-ts/extra";
-import { aiMeta } from "../_internal.js";
-
-/**
- * Assembles a system prompt from reactive sections. Each section is a
- * `NodeInput<string>` — the prompt updates when any section changes.
- */
-export type SystemPromptHandle = Node<string> & { dispose: () => void };
-
-export function systemPromptBuilder(
-	sections: readonly NodeInput<string>[],
-	opts?: { separator?: string; name?: string },
-): SystemPromptHandle {
-	const separator = opts?.separator ?? "\n\n";
-	const sectionNodes = sections.map((s) =>
-		typeof s === "string" ? node([], { initial: s }) : fromAny(s),
-	);
-	const prompt = node(
-		sectionNodes,
-		(batchData, actions, ctx) => {
-			const data = batchData.map((batch, i) =>
-				batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-			);
-			actions.emit((data as string[]).filter((v) => v != null && v !== "").join(separator));
-		},
-		{
-			name: opts?.name ?? "systemPrompt",
-			describeKind: "derived",
-			meta: aiMeta("system_prompt"),
-			initial: "",
-		},
-	);
-	const unsub = keepalive(prompt);
-	return Object.assign(prompt, { dispose: unsub });
-}
diff --git a/src/utils/ai/safety/content-gate.ts b/src/utils/ai/safety/content-gate.ts
deleted file mode 100644
index 3932929e..00000000
--- a/src/utils/ai/safety/content-gate.ts
+++ /dev/null
@@ -1,81 +0,0 @@
-/**
- * Content gate — classifies accumulated stream text as allow / review / block.
- * @module
- */
-
-import { type Node, node } from "@graphrefly/pure-ts/core";
-
-/** Content safety decision. */
-export type ContentDecision = "allow" | "block" | "review";
-
-/** Options for {@link contentGate}. */
-export type ContentGateOptions = {
-	/**
-	 * Hard-block threshold multiplier (default 1.5).
-	 * Scores above `threshold * hardMultiplier` emit `"block"`.
-	 * Scores between `threshold` and that emit `"review"`.
-	 */
-	hardMultiplier?: number;
-	name?: string;
-};
-
-/**
- * Derived node that classifies accumulated stream text as `"allow"`,
- * `"review"`, or `"block"` based on a classifier score.
- *
- * **Wave A Unit 3 rewrite:** signature now takes `accumulatedText: Node<string>`
- * instead of a `TopicGraph<StreamChunk>` (the `StreamChunk` shape was retired
- * when the delta topic replaced the per-chunk accumulated-text shape).
- *
- * Emits a three-way decision on every text change:
- * - `"allow"` — score below `threshold`
- * - `"review"` — score in `[threshold, threshold × hardMultiplier)`
- * - `"block"` — score at or above `threshold × hardMultiplier`
- *
- * @param accumulatedText - Reactive accumulated-text source
- *                          (`streamingPromptNode(...).accumulatedText`).
- * @param classifier - `(accumulated: string) => number` scoring function, or
- *                     a `Node<number>` for live scores.
- * @param threshold - Score at which output becomes `"review"` or `"block"`.
- */
-export function contentGate(
-	accumulatedText: Node<string>,
-	classifier: ((accumulated: string) => number) | Node<number>,
-	threshold: number,
-	opts?: ContentGateOptions,
-): Node<ContentDecision> {
-	const hardThreshold = threshold * (opts?.hardMultiplier ?? 1.5);
-	const isNodeClassifier = typeof classifier !== "function";
-
-	const deps: Node<unknown>[] = [accumulatedText];
-	if (isNodeClassifier) deps.push(classifier as Node<unknown>);
-
-	return node<ContentDecision>(
-		deps,
-		(batchData, actions, ctx) => {
-			const data = batchData.map((batch, i) =>
-				batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-			);
-			const text = (data[0] as string | undefined) ?? "";
-			if (text.length === 0) {
-				actions.emit("allow");
-				return;
-			}
-
-			const score = isNodeClassifier
-				? ((data[1] as number | undefined) ?? 0)
-				: (classifier as (t: string) => number)(text);
-
-			if (score >= hardThreshold) {
-				actions.emit("block");
-				return;
-			}
-			if (score >= threshold) {
-				actions.emit("review");
-				return;
-			}
-			actions.emit("allow");
-		},
-		{ describeKind: "derived", name: opts?.name ?? "content-gate", initial: "allow" },
-	);
-}
diff --git a/src/utils/ai/safety/redactor.ts b/src/utils/ai/safety/redactor.ts
deleted file mode 100644
index 8815d01f..00000000
--- a/src/utils/ai/safety/redactor.ts
+++ /dev/null
@@ -1,54 +0,0 @@
-/**
- * Redactor — stream extractor that replaces matched patterns in accumulated text.
- *
- * **Wave A Unit 3 rewrite:** signature now takes `accumulatedText: Node<string>`
- * instead of the retired `TopicGraph<StreamChunk>`. The output is a
- * `Node<string>` carrying the sanitized accumulated text — compose with
- * `contentGate` or downstream UI directly.
- *
- * @module
- */
-
-import { type Node, node } from "@graphrefly/pure-ts/core";
-
-/** Options for {@link redactor}. */
-export type RedactorOptions = {
-	name?: string;
-};
-
-/**
- * Derived node that replaces matched patterns in accumulated text.
- *
- * @param accumulatedText - Reactive accumulated-text source.
- * @param patterns - Array of RegExps to match against the text.
- * @param replaceFn - Replacement producer (default: always `"[REDACTED]"`).
- * @returns `Node<string>` emitting the sanitized accumulated text.
- */
-export function redactor(
-	accumulatedText: Node<string>,
-	patterns: RegExp[],
-	replaceFn?: (match: string, pattern: RegExp) => string,
-	opts?: RedactorOptions,
-): Node<string> {
-	const replace = replaceFn ?? (() => "[REDACTED]");
-
-	function sanitize(text: string): string {
-		let result = text;
-		for (const pat of patterns) {
-			const global = pat.global ? pat : new RegExp(pat.source, `${pat.flags}g`);
-			result = result.replace(global, (m) => replace(m, pat));
-		}
-		return result;
-	}
-
-	return node<string>(
-		[accumulatedText],
-		(batchData, actions, ctx) => {
-			const data = batchData.map((batch, i) =>
-				batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-			);
-			actions.emit(sanitize((data[0] as string | undefined) ?? ""));
-		},
-		{ describeKind: "derived", name: opts?.name ?? "redactor", initial: "" },
-	);
-}
diff --git a/src/utils/cqrs/index.ts b/src/utils/cqrs/index.ts
deleted file mode 100644
index f0074c30..00000000
--- a/src/utils/cqrs/index.ts
+++ /dev/null
@@ -1,1377 +0,0 @@
-/**
- * CQRS patterns (roadmap §4.5).
- *
- * Composition layer over reactiveLog (3.2), pipeline/sagas (4.1), event bus (4.2),
- * projections (4.3). Guards (1.5) enforce command/query boundary.
- *
- * - `cqrs(name, opts?)` → `CqrsGraph` — top-level factory
- * - `CqrsGraph.command(name, handler)` — write-only node; guard rejects `observe`
- * - `CqrsGraph.event(name)` — backed by `reactiveLog`; append-only
- * - `CqrsGraph.projection(name, events, reducer, initial)` — read-only derived; guard rejects `write`
- * - `CqrsGraph.saga(name, events, handler)` — event-driven side effects
- */
-
-import {
-	DATA,
-	type Node,
-	node,
-	placeholderArgs,
-	policy,
-	wallClockNs,
-} from "@graphrefly/pure-ts/core";
-import type { AppendLogStorageTier } from "@graphrefly/pure-ts/extra";
-import { type ReactiveLogBundle, reactiveLog } from "@graphrefly/pure-ts/extra";
-import { Graph, type GraphOptions } from "@graphrefly/pure-ts/graph";
-import {
-	type BaseAuditRecord,
-	createAuditLog,
-	mutate,
-	type ReadonlyAuditLog,
-	readonlyAuditLog,
-	registerCursor,
-	registerCursorMap,
-} from "../../base/mutation/index.js";
-import {
-	CommandHandlerError,
-	DuplicateRegistrationError,
-	OptimisticConcurrencyError,
-	RebuildError,
-	UndeclaredEmitError,
-	UnknownCommandError,
-} from "../_errors/index.js";
-
-// ---------------------------------------------------------------------------
-// Guards
-// ---------------------------------------------------------------------------
-
-/** Commands: write + signal allowed, observe denied. */
-const COMMAND_GUARD = policy((allow, deny) => {
-	allow("write");
-	allow("signal");
-	deny("observe");
-});
-
-/** Projections: observe + signal allowed, write denied. */
-const PROJECTION_GUARD = policy((allow, deny) => {
-	allow("observe");
-	allow("signal");
-	deny("write");
-});
-
-/** Events: observe + signal allowed, write denied (appended internally). */
-const EVENT_GUARD = policy((allow, deny) => {
-	allow("observe");
-	allow("signal");
-	deny("write");
-});
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-import { keepalive } from "@graphrefly/pure-ts/extra";
-import { domainMeta } from "../../base/meta/domain-meta.js";
-
-function cqrsMeta(kind: string, extra?: Record<string, unknown>): Record<string, unknown> {
-	return domainMeta("cqrs", kind, extra);
-}
-
-function deepFreeze<T>(value: T): T {
-	if (value === null || typeof value !== "object" || Object.isFrozen(value)) return value;
-	for (const k of Object.keys(value as Record<string, unknown>)) {
-		deepFreeze((value as Record<string, unknown>)[k]);
-	}
-	return Object.freeze(value);
-}
-
-// ---------------------------------------------------------------------------
-// Event envelope
-// ---------------------------------------------------------------------------
-
-/**
- * Immutable envelope for events emitted by command handlers.
- *
- * **Wave C.1 Unit 17 (locked 2026-04-24):** Extended ES standard fields —
- * `aggregateId` / `aggregateVersion` for per-aggregate streams; correlation /
- * causation IDs for distributed tracing; `metadata` for free-form context.
- * Optional `handlerVersion` (Audit 5) traces which handler version produced
- * the event.
- *
- * `seq` is a per-graph monotonic counter that provides stable ordering when
- * multiple events share the same `timestampNs` (same wall-clock tick).
- */
-export type CqrsEvent<T = unknown> = {
-	type: string;
-	payload: T;
-	/** Wall-clock nanoseconds (via `wallClockNs()`). */
-	timestampNs: number;
-	/** Monotonic sequence within this CqrsGraph instance. */
-	seq: number;
-	/** Aggregate identifier (per-aggregate streams). */
-	aggregateId?: string;
-	/** Per-aggregate monotonic version (set when `aggregateId` is provided). */
-	aggregateVersion?: number;
-	/** Distributed-trace correlation id. */
-	correlationId?: string;
-	/** Causation chain id (this event was caused by event `causationId`). */
-	causationId?: string;
-	/** Free-form metadata frozen at append. */
-	metadata?: Readonly<Record<string, unknown>>;
-	/** V0 identity of the event log node at append time (§6.0b). */
-	v0?: { id: string; version: number };
-	/** Handler version stamped on emit (Audit 5). */
-	handlerVersion?: { id: string; version: string | number };
-};
-
-/** Compile-time event-map registry: `{ "orderPlaced": OrderPayload, ... }`. */
-export type CqrsEventMap = Record<string, unknown>;
-
-/** Recommended `keyOf` for CQRS event-store storage tiers (Audit 4). */
-export const cqrsEventKeyOf = (e: CqrsEvent): string =>
-	`${e.type}::${e.aggregateId ?? "__default__"}`;
-
-// ── Audit records (Audit 2 cross-cutting) ────────────────────────────────
-
-export interface DispatchRecord<T = unknown> extends BaseAuditRecord {
-	readonly commandName: string;
-	readonly payload: T;
-	/** Action result. Tier 1.6.2 canonical enum (renamed from `status`). */
-	readonly outcome: "success" | "failure";
-	readonly error?: unknown;
-	readonly errorType?: string;
-	/**
-	 * Event names emitted by the handler.
-	 * - `outcome: "success"`: events that persisted in the event log.
-	 * - `outcome: "failure"`: events the handler ATTEMPTED to emit before throwing;
-	 *   they were rolled back and did NOT persist. Documents the failed attempt's
-	 *   intentions for debugging handler logic. The actual event log shows only
-	 *   what's durable.
-	 */
-	readonly emittedEvents?: readonly string[];
-}
-
-export const dispatchKeyOf = <T>(r: DispatchRecord<T>): string => r.commandName;
-
-export interface SagaInvocation<T = unknown> extends BaseAuditRecord {
-	readonly eventType: string;
-	/** Action result. Tier 1.6.2 canonical enum (renamed from `status`). */
-	readonly outcome: "success" | "failure";
-	readonly error?: unknown;
-	readonly errorType?: string;
-	readonly aggregateId?: string;
-	readonly event?: CqrsEvent<T>;
-}
-
-export const sagaInvocationKeyOf = <T>(i: SagaInvocation<T>): string => i.eventType;
-
-/**
- * Saga registration result (M10) — a typed bundle replacing the prior
- * `Node<unknown>` return that side-attached `_saga` via an unsafe cast.
- *
- * `node` is the saga's effect node (subscribe to observe processing
- * activity). `invocations` is the per-event-type audit log; `audit` is a
- * **read-only view** of `invocations` (Audit 2 `.audit` duplication; M7 —
- * the alias can no longer silently `append`/`clear` the canonical log).
- * `cursors` exposes the per-event-type cursor state nodes for monitoring /
- * testing.
- *
- * @category patterns
- */
-export interface SagaController<T = unknown> {
-	readonly node: Node<unknown>;
-	readonly invocations: ReactiveLogBundle<SagaInvocation<T>>;
-	readonly audit: ReadonlyAuditLog<SagaInvocation<T>>;
-	readonly cursors: { readonly [eventName: string]: Node<number> };
-}
-
-// ---------------------------------------------------------------------------
-// Handler types
-// ---------------------------------------------------------------------------
-
-export type CommandActions = {
-	/** Append an event to a named event log (bypasses event guard). */
-	emit: (eventName: string, payload: unknown) => void;
-};
-
-/**
- * Command handler receives the dispatch payload and actions to emit events.
- *
- * **Purity:** Handlers should not mutate the payload. Event emission via
- * `actions.emit()` is the only sanctioned side effect.
- */
-export type CommandHandler<T = unknown> = (payload: T, actions: CommandActions) => void;
-
-/**
- * Projection reducer folds events into a read model.
- *
- * **Purity contract:** Reducers MUST be pure — return a new state value
- * without mutating `state` or any event.
- *
- * - In **`"replay"`** mode the `state` parameter is always the original
- *   `initial` value (full event-sourcing replay on every recompute).
- * - In **`"scan"`** mode the `state` parameter is the _previous_ output
- *   (incremental fold); `events` contains only the events appended since
- *   the last computation.
- */
-export type ProjectionReducer<TState = unknown, TEvent = unknown> = (
-	state: TState,
-	events: readonly CqrsEvent<TEvent>[],
-) => TState;
-
-/**
- * Snapshot integration for {@link ProjectionOptions}.
- *
- * `load` is called once at projection construction and the returned value
- * seeds the initial state. `save` (optional) is called after each reducer
- * run, debounced by `saveDebounceMs` (default 1000 ms) and capped by
- * `saveEvery` (default 1000 events).
- */
-export type ProjectionSnapshotOpts<TState> = {
-	/** Load a previously-saved state. `undefined` → start from `initial`. */
-	load: () => TState | undefined | Promise<TState | undefined>;
-	/** Persist the current state. Called after reducer; may be async. */
-	save?: (state: TState) => void | Promise<void>;
-	/**
-	 * Debounce window (ms) before `save` fires after the last event. Default 1000.
-	 */
-	saveDebounceMs?: number;
-	/**
-	 * Force a save after every Nth state change regardless of debounce.
-	 * Default 1000. Both knobs compose: save fires at whichever condition is
-	 * met first.
-	 */
-	saveEvery?: number;
-};
-
-/**
- * Options for {@link CqrsGraph.projection}.
- *
- * **Wave C.3 Unit 21 (locked 2026-04-24):**
- * - `mode: "scan"` (default) — incremental fold; `"replay"` — full replay
- *   each wave.
- * - `snapshot` — load/save integration for cold-start + auto-checkpoint.
- * - `freezeInputs` (default `true`) — freeze event arrays before passing
- *   to reducer (purity enforcement).
- * - `rebuild()` / `reset()` on the returned {@link ProjectionController}.
- *
- * @category patterns
- */
-export type ProjectionOptions<TState> = {
-	name: string;
-	events: readonly string[];
-	reducer: ProjectionReducer<TState>;
-	initial: TState;
-	/**
-	 * Fold strategy. Default `"scan"` (incremental). `"replay"` = full replay.
-	 *
-	 * **Scan-mode ordering caveat:** scan-mode assumes monotonic per-stream
-	 * arrival order. When multiple event streams are merged for a projection,
-	 * events arriving with a `timestampNs` earlier than the current sort cursor
-	 * are skipped from the incremental sweep. This is an acceptable trade-off
-	 * for incremental fold; use `mode: "replay"` for strict cross-stream
-	 * ordering.
-	 */
-	mode?: "replay" | "scan";
-	/** Snapshot integration for rebuild + auto-checkpoint. */
-	snapshot?: ProjectionSnapshotOpts<TState>;
-	/**
-	 * Freeze event arrays before passing to reducer (default `true`).
-	 * Set to `false` only if your reducer intentionally mutates the input
-	 * (strongly discouraged — prefer immutable reducers).
-	 */
-	freezeInputs?: boolean;
-};
-
-/**
- * Controller returned by {@link CqrsGraph.projection}.
- *
- * `node` is the reactive read model. `rebuild()` performs a paginated
- * cold-storage replay (requires `attachEventStorage` tiers). `reset()`
- * reloads from `snapshot.load()` and re-folds the live event log on top.
- *
- * @category patterns
- */
-export interface ProjectionController<TState> {
-	readonly node: Node<TState>;
-	/**
-	 * Async paginated rebuild from attached storage tiers. Throws
-	 * {@link RebuildError} on adapter / decode / reducer failure.
-	 *
-	 * @param opts.fromTier - Storage tier to read from (default: first attached).
-	 * @param opts.pageSize - Entries per page (default 1000).
-	 */
-	rebuild(opts?: {
-		fromTier?: AppendLogStorageTier<CqrsEvent>;
-		pageSize?: number;
-	}): Promise<TState>;
-	/**
-	 * Reload from `snapshot.load()` (if configured) and re-fold the live
-	 * in-memory event log on top. Returns the rebuilt state. No-op on the
-	 * reactive node if the state is unchanged.
-	 */
-	reset(): Promise<TState>;
-}
-
-export type SagaHandler<T = unknown> = (event: CqrsEvent<T>) => void;
-
-// ---------------------------------------------------------------------------
-// Options
-// ---------------------------------------------------------------------------
-
-export type CqrsOptions = {
-	graph?: GraphOptions;
-	/** Bounded retention for event streams; default 1024 (cross-cutting). */
-	retainedLimit?: number;
-	/** Freeze command payloads on dispatch (default `true`). */
-	freezeCommandPayload?: boolean;
-	/** Freeze event payloads on emit (default `true`). */
-	freezeEventPayload?: boolean;
-	/** LRU eviction threshold for per-aggregate streams (default 10_000). */
-	maxAggregates?: number;
-};
-
-export type CommandRegistration<TPayload = unknown> = {
-	handler: CommandHandler<TPayload>;
-	emits?: readonly string[];
-	handlerVersion?: { id: string; version: string | number };
-};
-
-export type DispatchOptions = {
-	correlationId?: string;
-	causationId?: string;
-	metadata?: Record<string, unknown>;
-	/**
-	 * Optimistic-concurrency check: if set, dispatch verifies the aggregate
-	 * (identified by `aggregateId`) is at this version. On mismatch, dispatch
-	 * throws {@link OptimisticConcurrencyError} BEFORE the handler runs.
-	 *
-	 * Requires `aggregateId` to be set. Without it the check is a no-op.
-	 */
-	expectedAggregateVersion?: number;
-	/**
-	 * Aggregate this dispatch targets. Events emitted by the handler that
-	 * also carry this `aggregateId` participate in per-aggregate versioning
-	 * and LRU eviction (see {@link CqrsOptions.maxAggregates}). Events whose
-	 * handler-supplied `aggregateId` differs from the dispatch's `aggregateId`
-	 * are emitted untouched (their own `aggregateVersion` is computed from
-	 * their own aggregate's stream).
-	 */
-	aggregateId?: string;
-};
-
-export type SagaOptions = {
-	aggregateId?: string;
-	errorPolicy?: "advance" | "hold";
-	handlerVersion?: { id: string; version: string | number };
-};
-
-// ---------------------------------------------------------------------------
-// CqrsGraph
-// ---------------------------------------------------------------------------
-
-type EventEntry = {
-	log: ReturnType<typeof reactiveLog<CqrsEvent>>;
-	node: Node<readonly CqrsEvent[]>;
-};
-
-/**
- * Eviction record emitted on `aggregateEvictions` when an aggregate's
- * per-aggregate stream is removed under `maxAggregates` LRU pressure. The
- * eviction does NOT delete events from the fan-in stream — only the
- * per-aggregate dedicated stream and its version counter.
- */
-export interface AggregateEvictionRecord {
-	readonly aggregateId: string;
-	readonly type: string;
-	readonly t_ns: number;
-	/** The version count the aggregate reached before eviction (for diagnostics). */
-	readonly lastVersion: number;
-}
-
-export class CqrsGraph<_EM extends CqrsEventMap = Record<string, unknown>> extends Graph {
-	/** Fan-in event streams (one per type, all aggregates merged). */
-	private readonly _eventLogs = new Map<string, EventEntry>();
-	/**
-	 * Per-aggregate event streams: type → aggregateId → entry. Used for
-	 * `event(type, aggregateId)` dual-form access and per-aggregate version
-	 * tracking. Only populated when an event with `aggregateId` is emitted.
-	 */
-	private readonly _eventLogsByAggregate = new Map<string, Map<string, EventEntry>>();
-	/** Per-aggregate version counters: `${type}::${aggregateId}` → current version. */
-	private readonly _aggregateVersions = new Map<string, number>();
-	/**
-	 * LRU access order for `${type}::${aggregateId}`. Map insertion order
-	 * tracks recency — `delete` + `set` on access moves to the end.
-	 */
-	private readonly _aggregateLru = new Map<string, true>();
-	private readonly _commandRegs = new Map<
-		string,
-		{
-			handler: CommandHandler<any>;
-			emits?: readonly string[];
-			handlerVersion?: { id: string; version: string | number };
-		}
-	>();
-	private readonly _projections = new Set<string>();
-	private readonly _sagas = new Set<string>();
-	private _seq = 0;
-	private readonly _retainedLimit: number;
-	private readonly _freezeCommandPayload: boolean;
-	private readonly _freezeEventPayload: boolean;
-	private readonly _maxAggregates: number;
-	private readonly _dispatchSeqCursor: Node<number>;
-	/** Audit log of every command dispatch (Audit 2). */
-	readonly dispatches: ReactiveLogBundle<DispatchRecord>;
-	/**
-	 * Read-only view of {@link CqrsGraph.dispatches} (Audit 2 `.audit`
-	 * duplication; M7 — cannot mutate the canonical log via the alias).
-	 */
-	readonly audit: ReadonlyAuditLog<DispatchRecord>;
-	/** Per-aggregate LRU eviction observability; secondary log to `dispatches`. */
-	readonly aggregateEvictions: ReactiveLogBundle<AggregateEvictionRecord>;
-
-	constructor(name: string, opts: CqrsOptions = {}) {
-		super(name, opts.graph);
-		this._retainedLimit = opts.retainedLimit ?? 1024;
-		this._freezeCommandPayload = opts.freezeCommandPayload ?? true;
-		this._freezeEventPayload = opts.freezeEventPayload ?? true;
-		this._maxAggregates = opts.maxAggregates ?? 10_000;
-		this.dispatches = createAuditLog<DispatchRecord>({
-			name: "dispatches",
-			retainedLimit: this._retainedLimit,
-			graph: this,
-		});
-		this.audit = readonlyAuditLog(this.dispatches);
-		this.aggregateEvictions = createAuditLog<AggregateEvictionRecord>({
-			name: "aggregateEvictions",
-			retainedLimit: this._retainedLimit,
-			graph: this,
-		});
-		this._dispatchSeqCursor = registerCursor(this, "dispatch_seq", 0);
-	}
-
-	/**
-	 * Read the current per-aggregate version (last emitted `aggregateVersion`
-	 * for that `(type, aggregateId)` pair). Returns `0` if no events have been
-	 * emitted yet for this aggregate. Useful for callers preparing
-	 * {@link DispatchOptions.expectedAggregateVersion}.
-	 */
-	aggregateVersion(type: string, aggregateId: string): number {
-		return this._aggregateVersions.get(`${type}::${aggregateId}`) ?? 0;
-	}
-
-	/** LRU touch — moves the key to the end of the access order. */
-	private _touchAggregate(key: string): void {
-		// Delete + set re-inserts at the end of Map iteration order.
-		this._aggregateLru.delete(key);
-		this._aggregateLru.set(key, true);
-	}
-
-	/**
-	 * Evict the oldest aggregate streams (least-recently-touched) until the
-	 * aggregate count is back within `_maxAggregates`. Emits one
-	 * `AggregateEvictionRecord` per eviction. The fan-in stream is NOT touched
-	 * — events stay in the type-level log; only the per-aggregate stream and
-	 * version counter are removed.
-	 */
-	private _enforceAggregateLru(): void {
-		while (this._aggregateLru.size > this._maxAggregates) {
-			const oldest = this._aggregateLru.keys().next();
-			if (oldest.done) break;
-			const key = oldest.value;
-			this._aggregateLru.delete(key);
-			const sep = key.indexOf("::");
-			if (sep < 0) continue;
-			const type = key.slice(0, sep);
-			const aggregateId = key.slice(sep + 2);
-			const lastVersion = this._aggregateVersions.get(key) ?? 0;
-			this._aggregateVersions.delete(key);
-			const byType = this._eventLogsByAggregate.get(type);
-			if (byType) {
-				byType.delete(aggregateId);
-				if (byType.size === 0) this._eventLogsByAggregate.delete(type);
-			}
-			this.aggregateEvictions.append({
-				aggregateId,
-				type,
-				lastVersion,
-				t_ns: wallClockNs(),
-			});
-		}
-	}
-
-	/** Tiers attached via {@link attachEventStorage}; auto-wired into future event streams. */
-	private readonly _attachedEventTiers: Array<readonly AppendLogStorageTier<CqrsEvent>[]> = [];
-	private readonly _attachedTierDisposers = new Map<string, Array<() => void>>();
-
-	/**
-	 * Wire append-log storage tiers for ALL CQRS event streams — both currently
-	 * registered AND any future streams created via `event(name)` /
-	 * `event(name, aggregateId)` / handler emit. (M4 fix.)
-	 *
-	 * Returns a disposer that releases all storage subscriptions wired by this
-	 * call (including those for streams that were created after the call).
-	 */
-	attachEventStorage(tiers: readonly AppendLogStorageTier<CqrsEvent>[]): () => void {
-		this._attachedEventTiers.push(tiers);
-		// Wire currently-existing streams.
-		for (const [name, entry] of this._eventLogs) {
-			const dispose = entry.log.attachStorage(tiers);
-			let arr = this._attachedTierDisposers.get(name);
-			if (!arr) {
-				arr = [];
-				this._attachedTierDisposers.set(name, arr);
-			}
-			arr.push(dispose);
-		}
-		// Per-aggregate streams existing now.
-		for (const [type, byAgg] of this._eventLogsByAggregate) {
-			for (const [aggId, entry] of byAgg) {
-				const key = `${type}::${aggId}`;
-				const dispose = entry.log.attachStorage(tiers);
-				let arr = this._attachedTierDisposers.get(key);
-				if (!arr) {
-					arr = [];
-					this._attachedTierDisposers.set(key, arr);
-				}
-				arr.push(dispose);
-			}
-		}
-		return () => {
-			// Remove from auto-wire list so newly-created streams skip.
-			const idx = this._attachedEventTiers.indexOf(tiers);
-			if (idx >= 0) this._attachedEventTiers.splice(idx, 1);
-			// We can't precisely undo the per-stream attach for THIS tier set
-			// alone (Map values commingle disposers across multiple
-			// attachEventStorage calls). Caller wanting fine-grained control
-			// should call `tier.flush()` / dispose tiers themselves. This
-			// disposer is best-effort: it stops auto-wiring future streams.
-		};
-	}
-
-	/** Wire newly-created event stream into all currently-attached tier sets. */
-	private _autoWireStreamStorage(
-		key: string,
-		log: ReturnType<typeof reactiveLog<CqrsEvent>>,
-	): void {
-		if (this._attachedEventTiers.length === 0) return;
-		let arr = this._attachedTierDisposers.get(key);
-		if (!arr) {
-			arr = [];
-			this._attachedTierDisposers.set(key, arr);
-		}
-		for (const tiers of this._attachedEventTiers) {
-			arr.push(log.attachStorage(tiers));
-		}
-	}
-
-	// -- Events ---------------------------------------------------------------
-
-	/**
-	 * Register a named event stream backed by `reactiveLog`.
-	 * Guard denies external `write` — only commands append internally.
-	 */
-	event(name: string): Node<readonly CqrsEvent[]>;
-	event(name: string, aggregateId: string): Node<readonly CqrsEvent[]>;
-	event(name: string, aggregateId?: string): Node<readonly CqrsEvent[]> {
-		if (aggregateId !== undefined) {
-			return this._ensureAggregateStream(name, aggregateId).node;
-		}
-		const existing = this._eventLogs.get(name);
-		if (existing) return existing.node;
-
-		// V0 versioning is attached at construction — post-hoc
-		// `_applyVersioning` was deleted because it opened a re-entrance
-		// window where a wave could observe `_versioning` transitioning from
-		// `undefined` to a fresh state. Construction-time-only means the
-		// flag is frozen at birth.
-		const log = reactiveLog<CqrsEvent>([], {
-			name,
-			versioning: 0,
-			maxSize: this._retainedLimit,
-		});
-		log.withLatest();
-		const entries = log.entries;
-		const guarded = this.derived<readonly CqrsEvent[]>(
-			name,
-			[entries],
-			(batchData, ctx) => {
-				const latest =
-					batchData[0] != null && batchData[0].length > 0
-						? (batchData[0].at(-1) as readonly CqrsEvent[])
-						: (ctx.prevData[0] as readonly CqrsEvent[]);
-				return [latest];
-			},
-			{
-				meta: cqrsMeta("event", { event_name: name }),
-				guard: EVENT_GUARD,
-				initial: entries.cache as readonly CqrsEvent[],
-			},
-		);
-		this.addDisposer(keepalive(guarded));
-		this._eventLogs.set(name, { log, node: guarded });
-		// M4: auto-wire any storage tiers attached via `attachEventStorage`.
-		this._autoWireStreamStorage(name, log);
-		return guarded;
-	}
-
-	/**
-	 * Get-or-create the per-aggregate event stream for `(type, aggregateId)`.
-	 * Mounts the stream as a sibling node named `<type>_<aggregateId>` so it
-	 * appears in `describe()`. LRU access is touched on every call.
-	 */
-	private _ensureAggregateStream(type: string, aggregateId: string): EventEntry {
-		// Ensure the fan-in stream exists too (call sites usually expect both).
-		if (!this._eventLogs.has(type)) this.event(type);
-
-		let byType = this._eventLogsByAggregate.get(type);
-		if (!byType) {
-			byType = new Map();
-			this._eventLogsByAggregate.set(type, byType);
-		}
-		const lruKey = `${type}::${aggregateId}`;
-		this._touchAggregate(lruKey);
-		const existing = byType.get(aggregateId);
-		if (existing) return existing;
-
-		const nodeName = `${type}_${aggregateId.replace(/[^a-zA-Z0-9_-]/g, "_")}`;
-		const log = reactiveLog<CqrsEvent>([], {
-			name: nodeName,
-			versioning: 0,
-			maxSize: this._retainedLimit,
-		});
-		log.withLatest();
-		const entries = log.entries;
-		// Avoid name collisions if multiple aggregates have ids that sanitize
-		// to the same node-name; suffix with a counter when necessary.
-		// Resolve the mount name BEFORE constructing the derived (the
-		// `this.derived(...)` form registers under the supplied `name`).
-		let mountName = nodeName;
-		let collisionIdx = 0;
-		while (this.resolveOptional(mountName) !== undefined) {
-			collisionIdx += 1;
-			mountName = `${nodeName}_${collisionIdx}`;
-		}
-		let guarded: Node<readonly CqrsEvent[]>;
-		try {
-			guarded = this.derived<readonly CqrsEvent[]>(
-				mountName,
-				[entries],
-				(batchData, ctx) => {
-					const latest =
-						batchData[0] != null && batchData[0].length > 0
-							? (batchData[0].at(-1) as readonly CqrsEvent[])
-							: (ctx.prevData[0] as readonly CqrsEvent[]);
-					return [latest];
-				},
-				{
-					meta: cqrsMeta("event_aggregate", {
-						event_name: type,
-						aggregate_id: aggregateId,
-					}),
-					guard: EVENT_GUARD,
-					initial: entries.cache as readonly CqrsEvent[],
-				},
-			);
-		} catch {
-			// Name collision raced with another constructor — fall back to a
-			// raw, unmounted node so the per-aggregate stream still functions
-			// (just not graph-visible). Mirrors the prior best-effort branch.
-			// F-CATCH D-4: surface-loud — the fallback node silently vanishes
-			// from `graph.describe()`, which contradicts the dynamic-graph
-			// observability guarantee. Warn once so the visibility loss is
-			// diagnosable rather than mysterious.
-			console.warn(
-				`[GraphReFly] cqrs: per-aggregate event node "${mountName}" hit a ` +
-					`name-collision race (event "${type}", aggregate "${aggregateId}") — ` +
-					`falling back to an unmounted node; this aggregate's stream still ` +
-					`works but will NOT appear in graph.describe()/observe().`,
-			);
-			guarded = node<readonly CqrsEvent[]>(
-				[entries],
-				(batchData, actions, ctx) => {
-					const latest =
-						batchData[0] != null && batchData[0].length > 0 ? batchData[0].at(-1) : ctx.prevData[0];
-					actions.emit(latest as readonly CqrsEvent[]);
-				},
-				{
-					name: nodeName,
-					describeKind: "derived",
-					meta: cqrsMeta("event_aggregate", {
-						event_name: type,
-						aggregate_id: aggregateId,
-					}),
-					guard: EVENT_GUARD,
-					initial: entries.cache as readonly CqrsEvent[],
-				},
-			);
-		}
-		this.addDisposer(keepalive(guarded));
-		const entry = { log, node: guarded };
-		byType.set(aggregateId, entry);
-		// M4: auto-wire any tiers attached via `attachEventStorage`.
-		this._autoWireStreamStorage(`${type}::${aggregateId}`, log);
-		this._enforceAggregateLru();
-		return entry;
-	}
-
-	/** Try `resolve(path)`; return `undefined` instead of throwing on missing. */
-	private resolveOptional(path: string): Node | undefined {
-		try {
-			return this.resolve(path);
-		} catch {
-			return undefined;
-		}
-	}
-
-	/** Internal: append to an event log, auto-registering if needed. */
-	private _appendEvent(
-		eventName: string,
-		payload: unknown,
-		extra?: {
-			aggregateId?: string;
-			correlationId?: string;
-			causationId?: string;
-			metadata?: Readonly<Record<string, unknown>>;
-			handlerVersion?: { id: string; version: string | number };
-		},
-	): CqrsEvent {
-		let entry = this._eventLogs.get(eventName);
-		if (!entry) {
-			this.event(eventName);
-			entry = this._eventLogs.get(eventName)!;
-		}
-		if (entry.node.status === "completed" || entry.node.status === "errored") {
-			throw new Error(
-				`Cannot dispatch to terminated event stream "${eventName}" (status: ${entry.node.status}).`,
-			);
-		}
-
-		// Per-aggregate version + stream wiring (D1).
-		let aggregateVersion: number | undefined;
-		let aggregateEntry: EventEntry | undefined;
-		if (extra?.aggregateId !== undefined) {
-			const lruKey = `${eventName}::${extra.aggregateId}`;
-			aggregateVersion = (this._aggregateVersions.get(lruKey) ?? 0) + 1;
-			this._aggregateVersions.set(lruKey, aggregateVersion);
-			aggregateEntry = this._ensureAggregateStream(eventName, extra.aggregateId);
-		}
-
-		const nv = entry.log.entries.v;
-		const frozenPayload = this._freezeEventPayload ? deepFreeze(payload) : payload;
-		const evt: CqrsEvent = {
-			type: eventName,
-			payload: frozenPayload,
-			timestampNs: wallClockNs(),
-			seq: ++this._seq,
-			...(extra?.aggregateId !== undefined ? { aggregateId: extra.aggregateId } : {}),
-			...(aggregateVersion !== undefined ? { aggregateVersion } : {}),
-			...(extra?.correlationId !== undefined ? { correlationId: extra.correlationId } : {}),
-			...(extra?.causationId !== undefined ? { causationId: extra.causationId } : {}),
-			...(extra?.metadata !== undefined ? { metadata: Object.freeze({ ...extra.metadata }) } : {}),
-			...(extra?.handlerVersion !== undefined ? { handlerVersion: extra.handlerVersion } : {}),
-			...(nv != null ? { v0: { id: nv.id, version: nv.version } } : {}),
-		};
-		// Append to fan-in stream (always) and per-aggregate stream (when set).
-		entry.log.append(evt);
-		if (aggregateEntry) {
-			aggregateEntry.log.append(evt);
-		}
-		return evt;
-	}
-
-	// -- Commands -------------------------------------------------------------
-
-	/**
-	 * Register a command with its handler. Guard denies `observe` (write-only).
-	 * Use `dispatch(name, payload)` to execute.
-	 *
-	 * The command node carries dynamic `meta.error` — a reactive companion
-	 * that holds the last handler error (or `null` on success).
-	 */
-	command<T = unknown>(
-		name: string,
-		handlerOrReg: CommandHandler<T> | CommandRegistration<T>,
-	): Node<T> {
-		if (this._commandRegs.has(name)) {
-			throw new DuplicateRegistrationError("command", name);
-		}
-		const reg: CommandRegistration<T> =
-			typeof handlerOrReg === "function" ? { handler: handlerOrReg } : handlerOrReg;
-		const cmdNode = this.state<T>(name, undefined as T, {
-			meta: {
-				...cqrsMeta("command", { command_name: name }),
-				error: null,
-			},
-			guard: COMMAND_GUARD,
-		});
-		this._commandRegs.set(name, {
-			handler: reg.handler as CommandHandler<unknown>,
-			...(reg.emits !== undefined ? { emits: reg.emits } : {}),
-			...(reg.handlerVersion !== undefined ? { handlerVersion: reg.handlerVersion } : {}),
-		});
-		// Pre-register declared event streams so describe() shows them.
-		if (reg.emits) {
-			for (const e of reg.emits) {
-				if (!this._eventLogs.has(e)) this.event(e);
-			}
-		}
-		return cmdNode;
-	}
-
-	/**
-	 * Execute a registered command. Wraps the entire dispatch in `batch()` so
-	 * the command node DATA and all emitted events settle atomically.
-	 *
-	 * If the handler throws, `meta.error` on the command node is set to the
-	 * error and the exception is re-thrown.
-	 *
-	 * **Tier 8 / COMPOSITION-GUIDE §35:** dispatch routes through the shared
-	 * {@link mutate} framework so freeze / rollback-on-throw / seq-cursor
-	 * advance / audit-record stamping flow through one centralized helper.
-	 * Failure records emit OUTSIDE the rolled-back batch (M5 / C4 invariants
-	 * preserved by the framework).
-	 */
-	dispatch<T = unknown>(commandName: string, payload: T, opts?: DispatchOptions): void {
-		const reg = this._commandRegs.get(commandName);
-		if (!reg) throw new UnknownCommandError(commandName);
-
-		// D1: optimistic-concurrency check fires BEFORE the handler runs and
-		// BEFORE the batch opens, so a stale-version dispatch is a clean
-		// no-op (no audit record, no rollback). Only meaningful when both
-		// aggregateId and expectedAggregateVersion are set; otherwise no-op.
-		if (
-			opts?.aggregateId !== undefined &&
-			opts.expectedAggregateVersion !== undefined &&
-			reg.emits !== undefined
-		) {
-			// Verify against ANY of the declared `emits` types — the dispatch's
-			// aggregate version is per (type, aggregateId), but a single
-			// dispatch may emit across multiple types. We check the FIRST
-			// declared `emits` type that has a version recorded for this
-			// aggregate; if none has a version, the aggregate is considered
-			// at version 0.
-			let observedVersion = 0;
-			for (const t of reg.emits) {
-				const v = this._aggregateVersions.get(`${t}::${opts.aggregateId}`);
-				if (v !== undefined && v > observedVersion) observedVersion = v;
-			}
-			if (observedVersion !== opts.expectedAggregateVersion) {
-				throw new OptimisticConcurrencyError(
-					opts.aggregateId,
-					opts.expectedAggregateVersion,
-					observedVersion,
-				);
-			}
-		}
-
-		const cmdNode = this.resolve(commandName);
-		const emittedEvents: string[] = [];
-		// `actionThrew` distinguishes user-handler failures (where we want to
-		// stamp `cmdNode.meta.error`) from framework-internal failures (which
-		// shouldn't leak as a "command failed" signal).
-		let actionThrew = false;
-
-		const action = (sealed: T): void => {
-			cmdNode.emit(sealed, { internal: true });
-			try {
-				reg.handler(sealed, {
-					emit: (eName, data) => {
-						// Wave C.2 Unit 19: if emits was declared, reject undeclared names.
-						if (reg.emits !== undefined && !reg.emits.includes(eName)) {
-							throw new UndeclaredEmitError(commandName, eName, reg.emits);
-						}
-						emittedEvents.push(eName);
-						this._appendEvent(eName, data, {
-							// D1: thread the dispatch's aggregateId through so events
-							// participate in per-aggregate versioning. Handlers can
-							// override per-emit by passing their own through a richer
-							// emit signature (future extension).
-							...(opts?.aggregateId !== undefined ? { aggregateId: opts.aggregateId } : {}),
-							...(opts?.correlationId !== undefined ? { correlationId: opts.correlationId } : {}),
-							...(opts?.causationId !== undefined ? { causationId: opts.causationId } : {}),
-							...(opts?.metadata !== undefined
-								? { metadata: Object.freeze({ ...opts.metadata }) }
-								: {}),
-							...(reg.handlerVersion !== undefined ? { handlerVersion: reg.handlerVersion } : {}),
-						});
-					},
-				});
-				cmdNode.meta.error.emit(null, { internal: true });
-			} catch (err) {
-				actionThrew = true;
-				throw err;
-			}
-		};
-
-		try {
-			mutate<[T], void, DispatchRecord>(action, {
-				frame: "transactional",
-				log: this.dispatches,
-				seq: this._dispatchSeqCursor,
-				freeze: this._freezeCommandPayload,
-				onSuccessRecord: ([sealed], _result, { t_ns, seq }) => ({
-					commandName,
-					payload: sealed,
-					outcome: "success",
-					emittedEvents: [...emittedEvents],
-					t_ns,
-					seq: seq ?? 0,
-					...(reg.handlerVersion !== undefined ? { handlerVersion: reg.handlerVersion } : {}),
-				}),
-				onFailureRecord: ([sealed], err, { t_ns, seq, errorType }) => {
-					const wrapped =
-						err instanceof CommandHandlerError ? err : new CommandHandlerError(commandName, err);
-					return {
-						commandName,
-						payload: sealed,
-						outcome: "failure",
-						error: wrapped,
-						errorType,
-						emittedEvents: [...emittedEvents],
-						t_ns,
-						seq: seq ?? 0,
-						...(reg.handlerVersion !== undefined ? { handlerVersion: reg.handlerVersion } : {}),
-					};
-				},
-			})(payload);
-		} catch (outerErr) {
-			// C4 preservation: only stamp `cmdNode.meta.error` when the user
-			// handler threw (not when framework infra threw before the action
-			// ran). The framework already routed onFailure for the action-throw
-			// case via `mutate` outside the rolled-back batch.
-			if (actionThrew) {
-				cmdNode.meta.error.emit(outerErr, { internal: true });
-			}
-			throw outerErr;
-		}
-	}
-
-	// -- Projections ----------------------------------------------------------
-
-	/**
-	 * Register a read-only projection derived from event streams.
-	 * Guard denies `write` — value is computed from events only.
-	 *
-	 * **Wave C.3 Unit 21 (locked 2026-04-24):**
-	 * - Object-bag signature replaces the positional `(name, events, reducer, initial)` form.
-	 * - `mode: "scan"` (default) — incremental fold; `"replay"` — full replay each wave.
-	 * - `snapshot` integration for cold-start load + auto-checkpoint save.
-	 * - `freezeInputs` (default `true`) — freeze the event array before passing to reducer.
-	 * - Returns `ProjectionController<TState>` with `.node`, `.rebuild()`, `.reset()`.
-	 *
-	 * Fan-in across `events` is implemented by depending on all event-type fan-in
-	 * nodes directly, which preserves `describe()` edges (e.g. `orderPlaced →
-	 * orderCount`). Events are sorted by `(timestampNs, seq, aggregateId)` before
-	 * passing to the reducer (Option-3 cross-aggregate ordering, C.3).
-	 */
-	projection<TState>(opts: ProjectionOptions<TState>): ProjectionController<TState> {
-		const { name, events: eventNames, reducer, initial } = opts;
-		const mode = opts.mode ?? "scan";
-		const freezeInputs = opts.freezeInputs ?? true;
-		const snapshotOpts = opts.snapshot;
-
-		// Ensure each event stream exists and collect its node.
-		// Using the event-type fan-in nodes directly as deps preserves
-		// `describe()` edges (orderPlaced → orderCount) per Audit 1 §24.
-		const eventNodes = eventNames.map((eName) => {
-			if (!this._eventLogs.has(eName)) this.event(eName);
-			return this._eventLogs.get(eName)!.node;
-		});
-
-		// Sort comparator: timestampNs → seq → aggregateId lex (Option-3, C.3).
-		function sortEvents(evts: CqrsEvent[]): void {
-			evts.sort(
-				(a, b) =>
-					a.timestampNs - b.timestampNs ||
-					a.seq - b.seq ||
-					(a.aggregateId ?? "").localeCompare(b.aggregateId ?? ""),
-			);
-		}
-
-		// Collect all events from the current snapshots (for seeding + rebuild).
-		function collectAllEvents(snapshots: readonly (readonly CqrsEvent[])[]): CqrsEvent[] {
-			const evts: CqrsEvent[] = [];
-			for (const snap of snapshots) evts.push(...snap);
-			sortEvents(evts);
-			return evts;
-		}
-
-		// Seed: collect any events already present at construction time.
-		const seedSnapshots = eventNodes.map(
-			(n) => (n.cache as readonly CqrsEvent[] | undefined) ?? ([] as readonly CqrsEvent[]),
-		);
-		const sortedSeed = collectAllEvents(seedSnapshots);
-		const frozenSeed = (
-			freezeInputs ? Object.freeze(sortedSeed) : sortedSeed
-		) as readonly CqrsEvent[];
-
-		// Scan state: tracks count of events processed in last run.
-		let lastProcessedCount = 0;
-		let scanState: TState = initial;
-
-		if (mode === "scan" && sortedSeed.length > 0) {
-			scanState = reducer(initial, frozenSeed);
-			lastProcessedCount = sortedSeed.length;
-		}
-		const seedState = mode === "replay" ? reducer(initial, frozenSeed) : scanState;
-
-		// Snapshot save state — debounce + saveEvery.
-		const saveDebounceMs = snapshotOpts?.saveDebounceMs ?? 1000;
-		const saveEvery = snapshotOpts?.saveEvery ?? 1000;
-		let saveTimer: ReturnType<typeof setTimeout> | undefined;
-		let savesSinceLastFlush = 0;
-
-		function scheduleSave(currentState: TState): void {
-			if (!snapshotOpts?.save) return;
-			savesSinceLastFlush += 1;
-			if (savesSinceLastFlush >= saveEvery) {
-				savesSinceLastFlush = 0;
-				if (saveTimer !== undefined) {
-					clearTimeout(saveTimer);
-					saveTimer = undefined;
-				}
-				const result = snapshotOpts.save(currentState);
-				if (result instanceof Promise) result.catch(() => undefined);
-				return;
-			}
-			if (saveTimer !== undefined) clearTimeout(saveTimer);
-			saveTimer = setTimeout(() => {
-				saveTimer = undefined;
-				savesSinceLastFlush = 0;
-				const result = snapshotOpts!.save!(currentState);
-				if (result instanceof Promise) result.catch(() => undefined);
-			}, saveDebounceMs);
-		}
-
-		const projNode = this.derived<TState>(
-			name,
-			eventNames as readonly string[],
-			(batchData, ctx) => {
-				const snapshots = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				const allEvents = collectAllEvents(snapshots as readonly (readonly CqrsEvent[])[]);
-
-				let newState: TState;
-				if (mode === "replay") {
-					// m1: freeze only in the replay branch where `frozen` is actually used.
-					const frozen = (
-						freezeInputs ? Object.freeze(allEvents) : allEvents
-					) as readonly CqrsEvent[];
-					newState = reducer(initial, frozen);
-				} else {
-					// scan: only fold NEW events since last run.
-					const newOnly = allEvents.slice(lastProcessedCount);
-					lastProcessedCount = allEvents.length;
-					const frozenNew = (
-						freezeInputs ? Object.freeze(newOnly) : newOnly
-					) as readonly CqrsEvent[];
-					newState = reducer(scanState, frozenNew);
-					scanState = newState;
-				}
-
-				scheduleSave(newState);
-				return [newState];
-			},
-			{
-				meta: cqrsMeta("projection", { projection_name: name, source_events: eventNames }),
-				guard: PROJECTION_GUARD,
-				initial: seedState,
-			},
-		);
-
-		this.addDisposer(keepalive(projNode));
-		this.addDisposer(() => {
-			if (saveTimer !== undefined) {
-				clearTimeout(saveTimer);
-				saveTimer = undefined;
-			}
-		});
-		this._projections.add(name);
-
-		// -- Controller methods ---------------------------------------------------
-
-		const rebuild = async (rebuildOpts?: {
-			fromTier?: AppendLogStorageTier<CqrsEvent>;
-			pageSize?: number;
-		}): Promise<TState> => {
-			try {
-				const pageSize = rebuildOpts?.pageSize ?? 1000;
-				const tier = rebuildOpts?.fromTier ?? this._attachedEventTiers[0]?.[0];
-
-				// M5: snapshot in-memory event count BEFORE any async work so we can
-				// drain events that arrive concurrently during the paginated rebuild.
-				const preBuildCount = collectAllEvents(
-					eventNodes.map((n) => (n.cache as readonly CqrsEvent[] | undefined) ?? []),
-				).length;
-
-				// Seed from snapshot.load if provided.
-				let rebuildState: TState = initial;
-				if (snapshotOpts?.load) {
-					const loaded = await snapshotOpts.load();
-					if (loaded !== undefined) rebuildState = loaded;
-				}
-
-				if (!tier || !tier.loadEntries) {
-					// No storage tier — fold in-memory events as a best-effort rebuild.
-					const inMemory = collectAllEvents(
-						eventNodes.map((n) => (n.cache as readonly CqrsEvent[] | undefined) ?? []),
-					);
-					const frozen = (
-						freezeInputs ? Object.freeze(inMemory) : inMemory
-					) as readonly CqrsEvent[];
-					rebuildState = reducer(rebuildState, frozen);
-				} else {
-					// Paginated load from tier.
-					// m3: only fold events that belong to this projection's event-type set.
-					// Tiers may hold events from other projections; filtering keeps reducer
-					// correctness when the tier is shared across projections.
-					const watchedEvents = new Set<string>(eventNames as readonly string[]);
-					let cursor: import("@graphrefly/pure-ts/extra").AppendCursor | undefined;
-					let done = false;
-					while (!done) {
-						const result = await tier.loadEntries({ cursor, pageSize });
-						const page = [...result.entries].filter((e) => watchedEvents.has(e.type));
-						sortEvents(page);
-						const frozenPage = (freezeInputs ? Object.freeze(page) : page) as readonly CqrsEvent[];
-						rebuildState = reducer(rebuildState, frozenPage);
-						cursor = result.cursor;
-						done = !cursor || result.entries.length === 0;
-					}
-				}
-
-				// Update the live projection node with the rebuilt state.
-				if (mode === "scan") {
-					// M5: drain events that arrived during the async rebuild so they are
-					// not lost (race between paginated load and concurrent dispatch).
-					const allInMemory = collectAllEvents(
-						eventNodes.map((n) => (n.cache as readonly CqrsEvent[] | undefined) ?? []),
-					);
-					const pendingEvents = allInMemory.slice(preBuildCount);
-					if (pendingEvents.length > 0) {
-						const frozenPending = (
-							freezeInputs ? Object.freeze(pendingEvents) : pendingEvents
-						) as readonly CqrsEvent[];
-						rebuildState = reducer(rebuildState, frozenPending);
-					}
-					scanState = rebuildState;
-					lastProcessedCount = allInMemory.length;
-				}
-				projNode.emit(rebuildState, { internal: true });
-				return rebuildState;
-			} catch (err) {
-				throw new RebuildError(name, err);
-			}
-		};
-
-		const reset = async (): Promise<TState> => {
-			try {
-				// Reload from snapshot.load (if configured).
-				let baseState: TState = initial;
-				if (snapshotOpts?.load) {
-					const loaded = await snapshotOpts.load();
-					if (loaded !== undefined) baseState = loaded;
-				}
-
-				// Re-fold all in-memory events on top of the snapshot state.
-				const inMemory = collectAllEvents(
-					eventNodes.map((n) => (n.cache as readonly CqrsEvent[] | undefined) ?? []),
-				);
-				const frozen = (freezeInputs ? Object.freeze(inMemory) : inMemory) as readonly CqrsEvent[];
-				const newState = reducer(baseState, frozen);
-
-				if (mode === "scan") {
-					scanState = newState;
-					lastProcessedCount = inMemory.length;
-				}
-				projNode.emit(newState, { internal: true });
-				return newState;
-			} catch (err) {
-				throw new RebuildError(name, err);
-			}
-		};
-
-		return { node: projNode, rebuild, reset };
-	}
-
-	// -- Sagas ----------------------------------------------------------------
-
-	/**
-	 * Register an event-driven side effect. Runs handler for each **new** event
-	 * from the specified streams (tracks last-processed entry count per stream).
-	 *
-	 * The saga node carries dynamic `meta.error` — a reactive companion that
-	 * holds the last handler error (or `null` on success). Handler errors do
-	 * not propagate out of the saga run (the event cursor still advances so
-	 * the same entry is not delivered twice).
-	 */
-	saga<T = unknown>(
-		name: string,
-		eventNames: readonly string[],
-		handler: SagaHandler<T>,
-		opts: SagaOptions = {},
-	): SagaController<T> {
-		const _eventNodes = eventNames.map((eName) => {
-			if (!this._eventLogs.has(eName)) this.event(eName);
-			return this._eventLogs.get(eName)!.node;
-		});
-
-		// Audit 2: per-event-type cursor state nodes (replaces closure Map).
-		// Mount under `<saga>_cursor` (no `::` — that's the path separator).
-		const cursors = registerCursorMap(this, `${name}_cursor`, eventNames as readonly string[], 0);
-		// Audit 2: invocations log (companion + alias).
-		const invocations = createAuditLog<SagaInvocation<T>>({
-			name: `${name}_invocations`,
-			retainedLimit: this._retainedLimit,
-			graph: this,
-		});
-		const aggregateFilter = opts.aggregateId;
-		const errorPolicy = opts.errorPolicy ?? "advance";
-
-		// D2: subscribe-and-capture-mirror for cursor reads — avoid `.cache`
-		// access from inside the saga node's fn. Each cursor mirrors into a
-		// closure variable updated by an external subscription. Cursor writes
-		// (`cursor.emit(advancedTo)`) and `invocations.append(...)` from inside
-		// the fn are sanctioned effect-side-effects (saga's `describeKind:
-		// "effect"`) — not §5.9 imperative-trigger violations.
-		const latestCursors = new Map<string, number>();
-		for (const eName of eventNames) {
-			const cursor = cursors[eName]!;
-			latestCursors.set(eName, (cursor.cache as number | undefined) ?? 0);
-			const sub = cursor.subscribe((msgs) => {
-				for (const m of msgs) if (m[0] === DATA) latestCursors.set(eName, m[1] as number);
-			});
-			this.addDisposer(sub);
-		}
-
-		// Tier 8 / COMPOSITION-GUIDE §35: per-event handler invocation routes
-		// through `mutate` so handler-version stamping + audit-record
-		// shape stay centralized. Failure path re-throws — the saga's outer
-		// try/catch honors `errorPolicy` ("advance" vs "hold"). Action takes
-		// `(ev, eName)` so the wrapper can be hoisted once for all event types.
-		const auditedHandler = mutate<[CqrsEvent<T>, string], void, SagaInvocation<T>>(
-			(ev, _eName) => {
-				handler(ev);
-			},
-			{
-				frame: "inline",
-				log: invocations,
-				freeze: false,
-				...(opts.handlerVersion !== undefined ? { handlerVersion: opts.handlerVersion } : {}),
-				// D5 (qa lock): always include the `aggregateId` key (even when
-				// undefined) for parity with the pre-Tier-8 saga record shape.
-				// Consumers using `Object.hasOwn(record, "aggregateId")` or JSON
-				// serialization shape would observe a pre-1.0 break otherwise.
-				onSuccessRecord: ([ev, eName], _r, { t_ns }) => ({
-					eventType: eName,
-					outcome: "success",
-					aggregateId: ev.aggregateId,
-					event: ev,
-					t_ns,
-				}),
-				onFailureRecord: ([ev, eName], err, { t_ns, errorType }) => ({
-					eventType: eName,
-					outcome: "failure",
-					error: err,
-					errorType,
-					aggregateId: ev.aggregateId,
-					event: ev,
-					t_ns,
-				}),
-			},
-		);
-
-		const sagaRef: { n?: Node<unknown> } = {};
-		const sagaNode = this.effect(
-			name,
-			eventNames as readonly string[],
-			(snapshots, _up) => {
-				const errNode = sagaRef.n!.meta.error as Node<unknown>;
-				for (let i = 0; i < snapshots.length; i++) {
-					const batch = snapshots[i];
-					if (batch == null || batch.length === 0) continue;
-					const entries = batch.at(-1) as readonly CqrsEvent<T>[] | undefined;
-					if (!entries) continue;
-					const eName = eventNames[i] as string;
-					const cursor = cursors[eName]!;
-					const lastCount = latestCursors.get(eName) ?? 0;
-					if (entries.length > lastCount) {
-						const newEntries = entries.slice(lastCount);
-						let advancedTo = lastCount;
-						for (const entry of newEntries) {
-							const ev = entry as CqrsEvent<T>;
-							if (aggregateFilter !== undefined && ev.aggregateId !== aggregateFilter) {
-								advancedTo += 1;
-								continue;
-							}
-							try {
-								auditedHandler(ev, eName);
-								errNode.emit(null, { internal: true });
-								advancedTo += 1;
-							} catch (err) {
-								errNode.emit(err, { internal: true });
-								if (errorPolicy === "hold") break;
-								// "advance" — skip past failure, keep going.
-								advancedTo += 1;
-							}
-						}
-						cursor.emit(advancedTo);
-					}
-				}
-			},
-			{
-				meta: {
-					...cqrsMeta("saga", { saga_name: name, source_events: eventNames }),
-					error: null,
-				},
-			},
-		) as Node<unknown>;
-		sagaRef.n = sagaNode;
-
-		this.addDisposer(keepalive(sagaNode));
-		this._sagas.add(name);
-		return {
-			node: sagaNode,
-			invocations,
-			audit: readonlyAuditLog(invocations),
-			cursors,
-		};
-	}
-}
-
-// ---------------------------------------------------------------------------
-// Factory
-// ---------------------------------------------------------------------------
-
-/**
- * Create a CQRS graph container.
- *
- * @example
- * ```ts
- * const app = cqrs("orders");
- * app.event("orderPlaced");
- * app.command("placeOrder", (payload, { emit }) => {
- *   emit("orderPlaced", { orderId: payload.id, amount: payload.amount });
- * });
- * const { node: orderCount } = app.projection({
- *   name: "orderCount",
- *   events: ["orderPlaced"],
- *   reducer: (_s, events) => events.length,
- *   initial: 0,
- * });
- * app.dispatch("placeOrder", { id: "1", amount: 100 });
- * ```
- */
-export function cqrs<EM extends CqrsEventMap = Record<string, unknown>>(
-	name: string,
-	opts?: CqrsOptions,
-): CqrsGraph<EM> {
-	const g = new CqrsGraph<EM>(name, opts);
-	// Tier 1.5.3 Phase 2.5 (DG1=B): tag the Graph with its constructing
-	// factory so `describe()` surfaces provenance. Route through
-	// `placeholderArgs` since `CqrsOptions.graph` may carry non-JSON fields.
-	const { factory: _f, factoryArgs: _fa, ...tagArgs } = (opts ?? {}) as Record<string, unknown>;
-	g.tagFactory("cqrs", placeholderArgs(tagArgs));
-	return g;
-}
diff --git a/src/utils/demo-shell/index.ts b/src/utils/demo-shell/index.ts
deleted file mode 100644
index b6886232..00000000
--- a/src/utils/demo-shell/index.ts
+++ /dev/null
@@ -1,553 +0,0 @@
-/**
- * Three-pane demo shell (roadmap §7.2).
- *
- * A `Graph("demo-shell")` that dogfoods reactive coordination for the
- * main/side split layout with synchronized cross-highlighting.
- *
- * **Zero framework dependency** — framework bindings wrap pane components only.
- * The shell graph is headless and fully testable.
- */
-
-import { batch, node } from "@graphrefly/pure-ts/core";
-import { Graph } from "@graphrefly/pure-ts/graph";
-import { graphSpecToMermaid } from "../../base/render/index.js";
-import type { MeasurementAdapter } from "../reactive-layout/reactive-layout.js";
-import { analyzeAndMeasure, computeLineBreaks } from "../reactive-layout/reactive-layout.js";
-
-// ——————————————————————————————————————————————————————————
-//  Types
-// ——————————————————————————————————————————————————————————
-
-/** Identifies which pane is the source of a hover event. */
-export type HoverPaneType = "visual" | "graph" | "code";
-
-/** Cross-highlighting hover target. `null` means nothing hovered. */
-export type HoverTarget = { pane: HoverPaneType; id: string } | null;
-
-/** Which pane is full-screened (null = normal layout). */
-export type FullscreenPane = "main" | "graph" | "code" | null;
-
-/**
- * Cross-referencing registry: maps node paths to code line numbers and
- * visual element selectors. Provided by each demo's `store.ts`.
- */
-export type NodeRegistry = Map<string, { codeLine: number; visualSelector: string }>;
-
-/** Callbacks for cross-highlighting effect nodes. */
-export type HighlightCallbacks = {
-	/** Called when code-scroll highlight target changes. */
-	codeScroll?: (line: number | null) => void;
-	/** Called when visual highlight target changes. */
-	visual?: (selector: string | null) => void;
-	/** Called when graph highlight target changes. */
-	graph?: (nodeId: string | null) => void;
-};
-
-/** Label dimensions for graph node sizing. */
-export type GraphLabelSize = { width: number; height: number };
-
-/** Options for {@link demoShell}. */
-export type DemoShellOptions = {
-	/** Initial main/side split ratio (0–1). Default: `0.65`. */
-	mainRatio?: number;
-	/** Initial graph/code vertical split in the side pane (0–1). Default: `0.5`. */
-	sideSplit?: number;
-	/** Initial viewport width in pixels. Default: `1280`. */
-	viewportWidth?: number;
-	/** Cross-referencing registry for hover→code/visual/graph mapping. */
-	nodeRegistry?: NodeRegistry;
-	/** Measurement adapter for layout engine integration. When provided, enables layout/* derived nodes. */
-	adapter?: MeasurementAdapter;
-	/** Font string for layout measurement. Default: `"14px monospace"`. */
-	layoutFont?: string;
-	/** Callbacks for cross-highlighting effect nodes. When provided, creates effect nodes visible in describe(). */
-	onHighlight?: HighlightCallbacks;
-};
-
-/** Return type of {@link demoShell}. */
-export type DemoShellHandle = {
-	/** The demo-shell graph. */
-	graph: Graph;
-
-	// ── Convenience setters (shorthand for graph.set) ──────────
-	setMainRatio(ratio: number): void;
-	setSideSplit(ratio: number): void;
-	setFullscreen(pane: FullscreenPane): void;
-	setViewportWidth(width: number): void;
-	setHoverTarget(target: HoverTarget): void;
-	setDemoGraph(g: Graph | null): void;
-	bumpGraphTick(): void;
-	selectNode(path: string | null): void;
-	setMetaDebug(on: boolean): void;
-	/** Set code text for layout/code-lines measurement (requires adapter). */
-	setCodeText(text: string): void;
-	/** Atomic multi-set — wraps core `batch()` for glitch-free updates. */
-	batch(fn: () => void): void;
-	destroy(): void;
-};
-
-// ——————————————————————————————————————————————————————————
-//  Helpers
-// ——————————————————————————————————————————————————————————
-
-function clamp01(v: number): number {
-	return Math.max(0, Math.min(1, v));
-}
-
-// ——————————————————————————————————————————————————————————
-//  Factory
-// ——————————————————————————————————————————————————————————
-
-/**
- * Creates the three-pane demo shell graph (roadmap §7.2).
- *
- * All coordination is reactive — no polling, no imperative triggers.
- * Framework bindings subscribe to named nodes and drive `state` inputs.
- */
-export function demoShell(opts?: DemoShellOptions): DemoShellHandle {
-	const mainRatioInit = clamp01(opts?.mainRatio ?? 0.65);
-	const sideSplitInit = clamp01(opts?.sideSplit ?? 0.5);
-	const viewportInit = Math.max(0, opts?.viewportWidth ?? 1280);
-	const registry = opts?.nodeRegistry ?? new Map();
-	const adapter = opts?.adapter ?? null;
-	const layoutFont = opts?.layoutFont ?? "14px monospace";
-	const onHighlight = opts?.onHighlight;
-
-	const g = new Graph("demo-shell");
-
-	// ── Layout state ─────────────────────────────────────
-	const paneMainRatio = node([], { ...{ name: "pane/main-ratio" }, initial: mainRatioInit });
-	const paneSideSplit = node([], { ...{ name: "pane/side-split" }, initial: sideSplitInit });
-	const paneFullscreen = node<FullscreenPane>([], {
-		...{
-			name: "pane/fullscreen",
-		},
-		initial: null,
-	});
-	const viewportWidth = node([], { ...{ name: "viewport/width" }, initial: viewportInit });
-
-	g.add(paneMainRatio, { name: "pane/main-ratio" });
-	g.add(paneSideSplit, { name: "pane/side-split" });
-	g.add(paneFullscreen, { name: "pane/fullscreen" });
-	g.add(viewportWidth, { name: "viewport/width" });
-
-	// ── Derived pane dimensions ──────────────────────────
-	const paneMainWidth = node(
-		[paneMainRatio, viewportWidth, paneFullscreen],
-		(batchData, actions, ctx) => {
-			const data = batchData.map((batch, i) =>
-				batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-			);
-			const r = data[0] as number;
-			const w = data[1] as number;
-			const fullscreen = data[2] as FullscreenPane;
-			if (fullscreen === "main") actions.emit(w);
-			else if (fullscreen === "graph" || fullscreen === "code") actions.emit(0);
-			else actions.emit(Math.round(w * r));
-		},
-		{ describeKind: "derived", ...{ name: "pane/main-width" } },
-	);
-
-	const paneSideWidth = node(
-		[paneMainWidth, viewportWidth, paneFullscreen],
-		(batchData, actions, ctx) => {
-			const data = batchData.map((batch, i) =>
-				batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-			);
-			const main = data[0] as number;
-			const w = data[1] as number;
-			const fullscreen = data[2] as FullscreenPane;
-			if (fullscreen === "main") actions.emit(0);
-			else if (fullscreen === "graph" || fullscreen === "code") actions.emit(w);
-			else actions.emit(w - main);
-		},
-		{ describeKind: "derived", ...{ name: "pane/side-width" } },
-	);
-
-	const paneGraphHeight = node(
-		[paneSideSplit, paneFullscreen],
-		(batchData, actions, ctx) => {
-			const data = batchData.map((batch, i) =>
-				batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-			);
-			const split = data[0] as number;
-			const fullscreen = data[1] as FullscreenPane;
-			if (fullscreen === "graph") actions.emit(1);
-			else if (fullscreen === "code") actions.emit(0);
-			else if (fullscreen === "main") actions.emit(0);
-			else actions.emit(clamp01(split));
-		},
-		{ describeKind: "derived", ...{ name: "pane/graph-height-ratio" } },
-	);
-
-	const paneCodeHeight = node(
-		[paneGraphHeight, paneFullscreen],
-		(batchData, actions, ctx) => {
-			const data = batchData.map((batch, i) =>
-				batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-			);
-			const graphH = data[0] as number;
-			const fullscreen = data[1] as FullscreenPane;
-			if (fullscreen === "code") actions.emit(1);
-			else if (fullscreen === "graph" || fullscreen === "main") actions.emit(0);
-			else actions.emit(1 - graphH);
-		},
-		{ describeKind: "derived", ...{ name: "pane/code-height-ratio" } },
-	);
-
-	g.add(paneMainWidth, { name: "pane/main-width" });
-	g.add(paneSideWidth, { name: "pane/side-width" });
-	g.add(paneGraphHeight, { name: "pane/graph-height-ratio" });
-	g.add(paneCodeHeight, { name: "pane/code-height-ratio" });
-
-	// ── External graph observation ───────────────────────
-	const demoGraphRef = node<Graph | null>([], {
-		...{
-			name: "demo/graph-ref",
-		},
-		initial: null,
-	});
-	const demoGraphTick = node([], { ...{ name: "demo/graph-tick" }, initial: 0 });
-
-	g.add(demoGraphRef, { name: "demo/graph-ref" });
-	g.add(demoGraphTick, { name: "demo/graph-tick" });
-
-	const graphMermaid = node(
-		[demoGraphRef, demoGraphTick],
-		(batchData, actions, ctx) => {
-			const data = batchData.map((batch, i) =>
-				batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-			);
-			const demo = data[0] as Graph | null;
-			actions.emit(demo ? graphSpecToMermaid(demo.describe()) : "");
-		},
-		{ describeKind: "derived", ...{ name: "graph/mermaid" } },
-	);
-
-	const graphDescribe = node(
-		[demoGraphRef, demoGraphTick],
-		(batchData, actions, ctx) => {
-			const data = batchData.map((batch, i) =>
-				batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-			);
-			const demo = data[0] as Graph | null;
-			if (!demo) {
-				actions.emit(null);
-				return;
-			}
-			const { expand: _, ...snapshot } = demo.describe({ detail: "standard" });
-			actions.emit(snapshot);
-		},
-		{ describeKind: "derived", ...{ name: "graph/describe" } },
-	);
-
-	g.add(graphMermaid, { name: "graph/mermaid" });
-	g.add(graphDescribe, { name: "graph/describe" });
-
-	// ── Cross-highlighting ───────────────────────────────
-	const hoverTarget = node<HoverTarget>([], { ...{ name: "hover/target" }, initial: null });
-	g.add(hoverTarget, { name: "hover/target" });
-
-	const highlightCodeScroll = node(
-		[hoverTarget],
-		(batchData, actions, ctx) => {
-			const data = batchData.map((batch, i) =>
-				batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-			);
-			const t = data[0] as HoverTarget;
-			if (!t) {
-				actions.emit(null);
-				return;
-			}
-			const entry = registry.get(t.id);
-			actions.emit(entry ? entry.codeLine : null);
-		},
-		{ describeKind: "derived", ...{ name: "highlight/code-scroll" } },
-	);
-
-	const highlightVisual = node(
-		[hoverTarget],
-		(batchData, actions, ctx) => {
-			const data = batchData.map((batch, i) =>
-				batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-			);
-			const t = data[0] as HoverTarget;
-			if (!t) {
-				actions.emit(null);
-				return;
-			}
-			const entry = registry.get(t.id);
-			actions.emit(entry ? entry.visualSelector : null);
-		},
-		{ describeKind: "derived", ...{ name: "highlight/visual" } },
-	);
-
-	const highlightGraph = node(
-		[hoverTarget],
-		(batchData, actions, ctx) => {
-			const data = batchData.map((batch, i) =>
-				batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-			);
-			const t = data[0] as HoverTarget;
-			actions.emit(t ? t.id : null);
-		},
-		{ describeKind: "derived", ...{ name: "highlight/graph" } },
-	);
-
-	g.add(highlightCodeScroll, { name: "highlight/code-scroll" });
-	g.add(highlightVisual, { name: "highlight/visual" });
-	g.add(highlightGraph, { name: "highlight/graph" });
-
-	// ── Cross-highlighting effect nodes (optional) ─────
-	// Created when onHighlight callbacks are provided, making the full
-	// source→derived→effect chain visible in describe()/graphSpecToMermaid().
-
-	if (onHighlight?.codeScroll) {
-		const cb = onHighlight.codeScroll;
-		const applyCodeScroll = node(
-			[highlightCodeScroll],
-			(batchData, _actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				cb(data[0] as number | null);
-			},
-			{ describeKind: "effect" },
-		);
-		g.add(applyCodeScroll, { name: "highlight/apply-code-scroll" });
-	}
-
-	if (onHighlight?.visual) {
-		const cb = onHighlight.visual;
-		const applyVisual = node(
-			[highlightVisual],
-			(batchData, _actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				cb(data[0] as string | null);
-			},
-			{ describeKind: "effect" },
-		);
-		g.add(applyVisual, { name: "highlight/apply-visual" });
-	}
-
-	if (onHighlight?.graph) {
-		const cb = onHighlight.graph;
-		const applyGraph = node(
-			[highlightGraph],
-			(batchData, _actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				cb(data[0] as string | null);
-			},
-			{ describeKind: "effect" },
-		);
-		g.add(applyGraph, { name: "highlight/apply-graph" });
-	}
-
-	// ── Inspect panel ────────────────────────────────────
-	const inspectSelected = node<string | null>([], {
-		...{
-			name: "inspect/selected-node",
-		},
-		initial: null,
-	});
-	g.add(inspectSelected, { name: "inspect/selected-node" });
-
-	const inspectNodeDetail = node(
-		[inspectSelected, demoGraphRef, demoGraphTick],
-		(batchData, actions, ctx) => {
-			const data = batchData.map((batch, i) =>
-				batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-			);
-			const p = data[0] as string | null;
-			const demo = data[1] as Graph | null;
-			if (!demo || !p) {
-				actions.emit(null);
-				return;
-			}
-			try {
-				const snap = demo.describe({ detail: "standard" });
-				const nodeDesc = snap.nodes[p];
-				if (!nodeDesc) {
-					actions.emit(null);
-					return;
-				}
-				actions.emit({ path: p, ...nodeDesc });
-			} catch {
-				actions.emit(null);
-			}
-		},
-		{ describeKind: "derived", ...{ name: "inspect/node-detail" } },
-	);
-
-	const inspectTraceLog = node(
-		[demoGraphRef, demoGraphTick],
-		(batchData, actions, ctx) => {
-			const data = batchData.map((batch, i) =>
-				batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-			);
-			const demo = data[0] as Graph | null;
-			actions.emit(demo ? demo.trace() : []);
-		},
-		{ describeKind: "derived", ...{ name: "inspect/trace-log" } },
-	);
-
-	g.add(inspectNodeDetail, { name: "inspect/node-detail" });
-	g.add(inspectTraceLog, { name: "inspect/trace-log" });
-
-	// ── Meta debug toggle ────────────────────────────────
-	const metaDebug = node([], { ...{ name: "meta/debug" }, initial: false });
-	g.add(metaDebug, { name: "meta/debug" });
-
-	const metaShellMermaid = node(
-		[metaDebug, demoGraphTick],
-		(batchData, actions, ctx) => {
-			const data = batchData.map((batch, i) =>
-				batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-			);
-			actions.emit((data[0] as boolean) ? graphSpecToMermaid(g.describe()) : "");
-		},
-		{ describeKind: "derived", ...{ name: "meta/shell-mermaid" } },
-	);
-	g.add(metaShellMermaid, { name: "meta/shell-mermaid" });
-
-	// ── Layout engine integration (optional, requires adapter) ──
-	const codeTextNode = node([], { ...{ name: "layout/code-text" }, initial: "" });
-	g.add(codeTextNode, { name: "layout/code-text" });
-
-	if (adapter) {
-		const measureCache = new Map<string, Map<string, number>>();
-
-		const graphLabels = node(
-			[graphDescribe],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				const d = data[0] as { nodes: Record<string, { type: string }> } | null;
-				if (!d) {
-					actions.emit(new Map<string, GraphLabelSize>());
-					return;
-				}
-				const result = new Map<string, GraphLabelSize>();
-				for (const [name] of Object.entries(d.nodes)) {
-					const segments = analyzeAndMeasure(name, layoutFont, adapter, measureCache);
-					const lb = computeLineBreaks(segments, Infinity, adapter, layoutFont, measureCache);
-					const width = lb.lines.reduce((max, l) => Math.max(max, l.width), 0);
-					const height = lb.lineCount * 20; // line-height approximation
-					result.set(name, { width, height });
-				}
-				actions.emit(result);
-			},
-			{
-				describeKind: "derived",
-				...{
-					name: "layout/graph-labels",
-					equals: (a, b) => {
-						if (a === b) return true;
-						const ma = a as Map<string, GraphLabelSize>;
-						const mb = b as Map<string, GraphLabelSize>;
-						if (ma.size !== mb.size) return false;
-						for (const [k, v] of ma) {
-							const bv = mb.get(k);
-							if (!bv || bv.width !== v.width || bv.height !== v.height) return false;
-						}
-						return true;
-					},
-				},
-			},
-		);
-
-		const codeLines = node(
-			[codeTextNode, paneSideWidth],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				const t = data[0] as string;
-				if (!t) {
-					actions.emit({ lineCount: 0, lines: [] });
-					return;
-				}
-				const segments = analyzeAndMeasure(t, layoutFont, adapter, measureCache);
-				const maxW = (data[1] as number) - 40; // side pane minus padding
-				actions.emit(
-					computeLineBreaks(segments, Math.max(100, maxW), adapter, layoutFont, measureCache),
-				);
-			},
-			{ describeKind: "derived", name: "layout/code-lines" },
-		);
-
-		const sideWidthHint = node(
-			[graphLabels],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				const m = data[0] as Map<string, GraphLabelSize>;
-				if (m.size === 0) {
-					actions.emit(200);
-					return;
-				}
-				let maxW = 0;
-				for (const { width } of m.values()) {
-					if (width > maxW) maxW = width;
-				}
-				// widest label + padding (node box chrome + margin)
-				actions.emit(Math.max(200, Math.round(maxW + 80)));
-			},
-			{ describeKind: "derived", name: "layout/side-width-hint" },
-		);
-
-		g.add(graphLabels, { name: "layout/graph-labels" });
-		g.add(codeLines, { name: "layout/code-lines" });
-		g.add(sideWidthHint, { name: "layout/side-width-hint" });
-	}
-
-	// ── Edges (explicit wiring for describe/graphSpecToMermaid) ───
-
-	// ── Handle ───────────────────────────────────────────
-	let tickCounter = 0;
-	return {
-		graph: g,
-		setMainRatio(ratio: number) {
-			g.set("pane/main-ratio", clamp01(ratio));
-		},
-		setSideSplit(ratio: number) {
-			g.set("pane/side-split", clamp01(ratio));
-		},
-		setFullscreen(pane: FullscreenPane) {
-			g.set("pane/fullscreen", pane);
-		},
-		setViewportWidth(width: number) {
-			g.set("viewport/width", Math.max(0, width));
-		},
-		setHoverTarget(target: HoverTarget) {
-			g.set("hover/target", target);
-		},
-		setDemoGraph(demo: Graph | null) {
-			g.set("demo/graph-ref", demo);
-		},
-		bumpGraphTick() {
-			g.set("demo/graph-tick", ++tickCounter);
-		},
-		selectNode(path: string | null) {
-			g.set("inspect/selected-node", path);
-		},
-		setMetaDebug(on: boolean) {
-			g.set("meta/debug", on);
-		},
-		setCodeText(text: string) {
-			g.set("layout/code-text", text);
-		},
-		batch(fn: () => void) {
-			batch(fn);
-		},
-		destroy() {
-			g.destroy();
-		},
-	};
-}
diff --git a/src/utils/domain-templates/index.ts b/src/utils/domain-templates/index.ts
deleted file mode 100644
index e8a674c9..00000000
--- a/src/utils/domain-templates/index.ts
+++ /dev/null
@@ -1,919 +0,0 @@
-/**
- * Domain templates (roadmap §8.2).
- *
- * Opinionated Graph factories for common "info → action" domains.
- * Each template wires up §8.1 reduction primitives (stratify, funnel, feedback,
- * budgetGate, scorer) with domain-specific stages. Users fork/extend by
- * accessing named nodes and swapping stages.
- *
- * **Source injection (option B):** templates accept a `source` node, not a
- * hardcoded adapter. Pass `fromOTel(...)`, `fromGitHook(...)`, or a test
- * `state()` — the topology is the same.
- *
- * @module
- */
-
-import { batch, type Node, node } from "@graphrefly/pure-ts/core";
-import { reactiveLog, type StratifyRule, stratify } from "@graphrefly/pure-ts/extra";
-import { Graph, type GraphOptions } from "@graphrefly/pure-ts/graph";
-import { feedback, scorer } from "../reduction/index.js";
-
-// ---------------------------------------------------------------------------
-// Shared
-// ---------------------------------------------------------------------------
-
-import { keepalive } from "@graphrefly/pure-ts/extra";
-import { domainMeta } from "../../base/meta/domain-meta.js";
-
-function baseMeta(kind: string, extra?: Record<string, unknown>): Record<string, unknown> {
-	return domainMeta("domain_template", kind, extra);
-}
-
-// ---------------------------------------------------------------------------
-// 1. observabilityGraph
-// ---------------------------------------------------------------------------
-
-/** Stratification branch config for observability signals. */
-export type ObservabilityBranch = {
-	name: string;
-	classify: (value: unknown) => boolean;
-};
-
-/** Options for {@link observabilityGraph}. */
-export type ObservabilityGraphOptions = GraphOptions & {
-	/** Ingested signal source (e.g. fromOTel(...) or test state). */
-	source: Node<unknown>;
-
-	/**
-	 * Classification rules for signal stratification.
-	 * Default: errors / traces / metrics branches.
-	 */
-	branches?: ObservabilityBranch[];
-
-	/**
-	 * Correlation function: receives stratified branch values and produces
-	 * correlated insights. Default: identity pass-through.
-	 */
-	correlate?: (values: unknown[]) => unknown;
-
-	/**
-	 * SLO verification function: returns a verification result for a
-	 * correlated insight. Default: always passes.
-	 */
-	sloCheck?: (value: unknown) => unknown;
-
-	/**
-	 * Scorer weights for alert prioritization. One per branch.
-	 * Default: equal weights [1, 1, 1].
-	 */
-	weights?: number[];
-
-	/** Max feedback iterations for false-positive learning. Default: 5. */
-	maxFeedbackIterations?: number;
-};
-
-/**
- * OTel ingest → stratified reduction → correlation → SLO verification →
- * alert prioritization → output.
- *
- * Well-known node names:
- * - `"source"` — injected signal source
- * - `"stratify::branch/<name>"` — per-branch classification
- * - `"correlate"` — cross-branch correlation
- * - `"slo_value"`, `"slo_verified"` — SLO verification pair
- * - `"alerts"` — scored, prioritized output
- * - `"output"` — final output (alias for alerts)
- *
- * @category patterns
- */
-export function observabilityGraph(name: string, opts: ObservabilityGraphOptions): Graph {
-	const g = new Graph(name, opts);
-
-	// --- Source ---
-	g.add(opts.source, { name: "source" });
-
-	// --- Stratify ---
-	const defaultBranches: ObservabilityBranch[] = [
-		{ name: "errors", classify: (v) => isTagged(v, "error") },
-		{ name: "traces", classify: (v) => isTagged(v, "trace") },
-		{ name: "metrics", classify: (v) => isTagged(v, "metric") },
-	];
-	const branches = opts.branches ?? defaultBranches;
-	const rules: StratifyRule<unknown>[] = branches.map((b) => ({
-		name: b.name,
-		classify: b.classify,
-	}));
-	const strat = stratify("stratify", opts.source, rules);
-	g.mount("stratify", strat);
-
-	// --- Correlate ---
-	// Collect latest value from each branch, produce correlated output.
-	// Wrap each branch in a derived with `initial: null` so every branch has
-	// a seed value at subscribe time — this lets the correlate wave reach its
-	// first-run gate even when the classifier only routes to one branch.
-	const branchNodes = branches.map((b) => {
-		try {
-			const raw = g.resolve(`stratify::branch/${b.name}`);
-			return node(
-				[raw as Node],
-				(batchData, actions, ctx) => {
-					const data = batchData.map((batch, i) =>
-						batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-					);
-					actions.emit(data[0]);
-				},
-				{ initial: null, describeKind: "derived" },
-			);
-		} catch {
-			return node<unknown>([], { initial: null });
-		}
-	});
-	const correlateFn = opts.correlate ?? ((vals: unknown[]) => vals);
-	const correlateNode = node<unknown>(
-		branchNodes as Node[],
-		(batchData, actions, ctx) => {
-			const vals = batchData.map((batch, i) =>
-				batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-			);
-			actions.emit(correlateFn(vals as unknown[]));
-		},
-		{
-			describeKind: "derived",
-			meta: baseMeta("observability", { stage: "correlate" }),
-		},
-	);
-	g.add(correlateNode, { name: "correlate" });
-
-	// --- SLO verification ---
-	const sloCheckFn = opts.sloCheck ?? (() => ({ pass: true }));
-	const sloValue = node<unknown>(
-		[correlateNode],
-		(batchData, actions, ctx) => {
-			const data = batchData.map((batch, i) =>
-				batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-			);
-			actions.emit(data[0]);
-		},
-		{
-			describeKind: "derived",
-			meta: baseMeta("observability", { stage: "slo_value" }),
-		},
-	);
-	const sloVerified = node<unknown>(
-		[sloValue],
-		(batchData, actions, ctx) => {
-			const data = batchData.map((batch, i) =>
-				batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-			);
-			actions.emit(sloCheckFn(data[0]));
-		},
-		{
-			describeKind: "derived",
-			meta: baseMeta("observability", { stage: "slo_verified" }),
-		},
-	);
-	g.add(sloValue, { name: "slo_value" });
-	g.add(sloVerified, { name: "slo_verified" });
-
-	// --- Alert scorer ---
-	const weightValues = opts.weights ?? branches.map(() => 1);
-	const signalNodes = branchNodes.map((bn) =>
-		node<number>(
-			[bn],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit(data[0] != null ? 1 : 0);
-			},
-			{ describeKind: "derived" },
-		),
-	);
-	const weightNodes = weightValues.map((w) => node<number>([], { initial: w }));
-	for (let i = 0; i < signalNodes.length; i++) {
-		g.add(signalNodes[i] as Node<unknown>, { name: `__signal_${i}` });
-		g.add(weightNodes[i] as Node<unknown>, { name: `__weight_${i}` });
-	}
-	const alerts = scorer(
-		signalNodes as ReadonlyArray<Node<number>>,
-		weightNodes as ReadonlyArray<Node<number>>,
-	);
-	g.add(alerts as Node<unknown>, { name: "alerts" });
-
-	// --- Output alias ---
-	const output = node<unknown>(
-		[alerts as Node, sloVerified],
-		(batchData, actions, ctx) => {
-			const vals = batchData.map((batch, i) =>
-				batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-			);
-			actions.emit({
-				scored: vals[0],
-				slo: vals[1],
-			});
-		},
-		{
-			describeKind: "derived",
-			meta: baseMeta("observability", { stage: "output" }),
-		},
-	);
-	g.add(output, { name: "output" });
-
-	// --- Feedback (false-positive learning) ---
-	// SLO failures feed back to re-check with updated context.
-	const fbReentry = node<unknown>([], {
-		initial: null,
-		meta: baseMeta("observability", { stage: "feedback_reentry" }),
-	});
-	g.add(fbReentry, { name: "feedback_reentry" });
-	const fbCondition = node<unknown>(
-		[sloVerified],
-		(batchData, actions, ctx) => {
-			const data = batchData.map((batch, i) =>
-				batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-			);
-			const result = data[0] as Record<string, unknown> | null;
-			actions.emit(result && result.pass === false ? result : null);
-		},
-		{
-			describeKind: "derived",
-			meta: baseMeta("observability", { stage: "feedback_condition" }),
-		},
-	);
-	g.add(fbCondition as Node<unknown>, { name: "feedback_condition" });
-	feedback(g, "feedback_condition", "feedback_reentry", {
-		maxIterations: opts.maxFeedbackIterations ?? 5,
-	});
-
-	return g;
-}
-
-// ---------------------------------------------------------------------------
-// 2. issueTrackerGraph
-// ---------------------------------------------------------------------------
-
-/** A structured issue extracted from raw findings. */
-export type ExtractedIssue = {
-	id: string;
-	title: string;
-	severity: number;
-	source: string;
-	raw: unknown;
-};
-
-/** Options for {@link issueTrackerGraph}. */
-export type IssueTrackerGraphOptions = GraphOptions & {
-	/** Findings source (e.g. fromGitHook(...), fromFSWatch(...)). */
-	source: Node<unknown>;
-
-	/**
-	 * Extract structured issues from raw findings.
-	 * Default: wraps raw value as a single issue.
-	 */
-	extract?: (raw: unknown) => ExtractedIssue;
-
-	/**
-	 * Verify an extracted issue (assertion check).
-	 * Default: always valid.
-	 */
-	verify?: (issue: ExtractedIssue) => unknown;
-
-	/**
-	 * Detect regression by comparing against known patterns.
-	 * Receives (current issue, known patterns).
-	 * Default: no regression detected.
-	 */
-	detectRegression?: (issue: ExtractedIssue, known: unknown) => unknown;
-
-	/** Max feedback iterations for re-scanning. Default: 3. */
-	maxFeedbackIterations?: number;
-};
-
-/**
- * Findings ingest → extraction → verification → regression detection →
- * distillation → prioritized queue.
- *
- * Well-known node names:
- * - `"source"` — injected findings source
- * - `"extract"` — structured issue extraction
- * - `"verify"` — issue verification
- * - `"known_patterns"` — accumulated known issue patterns (state)
- * - `"regression"` — regression detection
- * - `"priority"` — severity-based prioritization
- * - `"output"` — final prioritized output
- *
- * @category patterns
- */
-export function issueTrackerGraph(name: string, opts: IssueTrackerGraphOptions): Graph {
-	const g = new Graph(name, opts);
-
-	// --- Source ---
-	g.add(opts.source, { name: "source" });
-
-	// --- Extract ---
-	let _issueCounter = 0;
-	const defaultExtract = (raw: unknown): ExtractedIssue => ({
-		id: `issue-${++_issueCounter}`,
-		title: String(raw),
-		severity: 1,
-		source: "unknown",
-		raw,
-	});
-	const extractFn = opts.extract ?? defaultExtract;
-	const extractNode = node<ExtractedIssue>(
-		[opts.source],
-		(batchData, actions, ctx) => {
-			const data = batchData.map((batch, i) =>
-				batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-			);
-			actions.emit(extractFn(data[0]));
-		},
-		{
-			describeKind: "derived",
-			meta: baseMeta("issue_tracker", { stage: "extract" }),
-		},
-	);
-	g.add(extractNode as Node<unknown>, { name: "extract" });
-
-	// --- Verify ---
-	const verifyFn = opts.verify ?? (() => ({ valid: true }));
-	const verifyNode = node<unknown>(
-		[extractNode as Node],
-		(batchData, actions, ctx) => {
-			const data = batchData.map((batch, i) =>
-				batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-			);
-			const issue = data[0] as ExtractedIssue;
-			actions.emit({ issue, verification: verifyFn(issue) });
-		},
-		{
-			describeKind: "derived",
-			meta: baseMeta("issue_tracker", { stage: "verify" }),
-		},
-	);
-	g.add(verifyNode, { name: "verify" });
-
-	// --- Known patterns (memory / distillation state) ---
-	const knownPatterns = node<unknown[]>([], {
-		initial: [],
-		meta: baseMeta("issue_tracker", { stage: "known_patterns" }),
-	});
-	g.add(knownPatterns as Node<unknown>, { name: "known_patterns" });
-
-	// --- Regression detection ---
-	const detectFn = opts.detectRegression ?? (() => ({ regression: false }));
-	const regressionNode = node<unknown>(
-		[extractNode as Node, knownPatterns as Node],
-		(batchData, actions, ctx) => {
-			const data = batchData.map((batch, i) =>
-				batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-			);
-			const issue = data[0] as ExtractedIssue;
-			const known = data[1];
-			actions.emit({ issue, regression: detectFn(issue, known) });
-		},
-		{ describeKind: "derived", meta: baseMeta("issue_tracker", { stage: "regression" }) },
-	);
-	g.add(regressionNode, { name: "regression" });
-
-	// --- Priority scoring ---
-	const severitySignal = node<number>(
-		[extractNode as Node],
-		(batchData, actions, ctx) => {
-			const data = batchData.map((batch, i) =>
-				batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-			);
-			const issue = data[0] as ExtractedIssue;
-			actions.emit(issue?.severity ?? 0);
-		},
-		{ describeKind: "derived" },
-	);
-	const regressionSignal = node<number>(
-		[regressionNode],
-		(batchData, actions, ctx) => {
-			const data = batchData.map((batch, i) =>
-				batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-			);
-			const r = data[0] as Record<string, unknown> | null;
-			actions.emit(r?.regression ? 2 : 0);
-		},
-		{ describeKind: "derived" },
-	);
-	g.add(severitySignal as Node<unknown>, { name: "__severity_signal" });
-	g.add(regressionSignal as Node<unknown>, { name: "__regression_signal" });
-
-	const severityWeight = node<number>([], { initial: 1 });
-	const regressionWeight = node<number>([], { initial: 1.5 });
-	g.add(severityWeight as Node<unknown>, { name: "__severity_weight" });
-	g.add(regressionWeight as Node<unknown>, { name: "__regression_weight" });
-
-	const priority = scorer([severitySignal, regressionSignal], [severityWeight, regressionWeight]);
-	g.add(priority as Node<unknown>, { name: "priority" });
-
-	// --- Output ---
-	const output = node<unknown>(
-		[verifyNode, regressionNode, priority as Node],
-		(batchData, actions, ctx) => {
-			const vals = batchData.map((batch, i) =>
-				batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-			);
-			actions.emit({
-				verified: vals[0],
-				regression: vals[1],
-				priority: vals[2],
-			});
-		},
-		{ describeKind: "derived", meta: baseMeta("issue_tracker", { stage: "output" }) },
-	);
-	g.add(output, { name: "output" });
-
-	// --- Feedback (re-scan on verification failure) ---
-	const fbReentry = node<unknown>([], {
-		initial: null,
-		meta: baseMeta("issue_tracker", { stage: "feedback_reentry" }),
-	});
-	g.add(fbReentry, { name: "feedback_reentry" });
-	const fbCondition = node<unknown>(
-		[verifyNode],
-		(batchData, actions, ctx) => {
-			const data = batchData.map((batch, i) =>
-				batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-			);
-			const result = data[0] as Record<string, unknown> | null;
-			if (result) {
-				const v = result.verification as Record<string, unknown> | null;
-				if (v && v.valid === false) {
-					actions.emit(result);
-					return;
-				}
-			}
-			actions.emit(null);
-		},
-		{
-			describeKind: "derived",
-			meta: baseMeta("issue_tracker", { stage: "feedback_condition" }),
-		},
-	);
-	g.add(fbCondition as Node<unknown>, { name: "feedback_condition" });
-	feedback(g, "feedback_condition", "feedback_reentry", {
-		maxIterations: opts.maxFeedbackIterations ?? 3,
-	});
-
-	return g;
-}
-
-// ---------------------------------------------------------------------------
-// 3. contentModerationGraph
-// ---------------------------------------------------------------------------
-
-/** Classification result from LLM moderation. */
-export type ModerationResult = {
-	label: "safe" | "review" | "block";
-	confidence: number;
-	reason?: string;
-	original: unknown;
-};
-
-/** Options for {@link contentModerationGraph}. */
-export type ContentModerationGraphOptions = GraphOptions & {
-	/** Content source (text/multimedia ingest). */
-	source: Node<unknown>;
-
-	/**
-	 * Classification function: returns a ModerationResult.
-	 * Default: labels everything "review" with confidence 0.5.
-	 */
-	classify?: (content: unknown) => ModerationResult;
-
-	/** System prompt for LLM classification. */
-	systemPrompt?: string;
-
-	/** Scorer weights: [safe, review, block]. Default: [0.1, 1, 2]. */
-	weights?: [number, number, number];
-
-	/** Max feedback iterations for policy refinement. Default: 5. */
-	maxFeedbackIterations?: number;
-
-	/** Max review queue size. When set, oldest entries are trimmed on overflow. */
-	maxQueueSize?: number;
-};
-
-/**
- * Content ingest → LLM/rule classification → stratified routing (safe/review/block) →
- * human review queue → scorer → feedback (false positives → policy refinement) → output.
- *
- * Well-known node names:
- * - `"source"` — content ingest
- * - `"classify"` — LLM or rule-based classification
- * - `"stratify::branch/safe"`, `"stratify::branch/review"`, `"stratify::branch/block"` — routed branches
- * - `"review_queue"` — state node for human review items
- * - `"priority"` — scored priority output
- * - `"policy"` — writable state for policy refinement
- * - `"output"` — final moderation output
- *
- * @category patterns
- */
-export function contentModerationGraph(name: string, opts: ContentModerationGraphOptions): Graph {
-	const g = new Graph(name, opts);
-
-	// --- Source ---
-	g.add(opts.source, { name: "source" });
-
-	// --- Classify ---
-	const defaultClassify = (content: unknown): ModerationResult => ({
-		label: "review",
-		confidence: 0.5,
-		original: content,
-	});
-	const classifyFn = opts.classify ?? defaultClassify;
-	const classifyNode = node<ModerationResult>(
-		[opts.source],
-		(batchData, actions, ctx) => {
-			const data = batchData.map((batch, i) =>
-				batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-			);
-			actions.emit(classifyFn(data[0]));
-		},
-		{
-			describeKind: "derived",
-			meta: baseMeta("content_moderation", { stage: "classify" }),
-		},
-	);
-	g.add(classifyNode as Node<unknown>, { name: "classify" });
-
-	// --- Stratify (safe / review / block) ---
-	const strat = stratify<ModerationResult>("stratify", classifyNode, [
-		{ name: "safe", classify: (v) => v.label === "safe" },
-		{ name: "review", classify: (v) => v.label === "review" },
-		{ name: "block", classify: (v) => v.label === "block" },
-	]);
-	g.mount("stratify", strat);
-
-	// --- Review queue (reactiveLog — O(1) append, bounded) ---
-	const reviewLog = reactiveLog<ModerationResult>([], {
-		name: "review_queue",
-		maxSize: opts.maxQueueSize,
-	});
-	g.add(reviewLog.entries as Node<unknown>, { name: "review_queue" });
-
-	// Bridge review branch → review queue accumulator
-	let reviewBranch: Node<unknown>;
-	try {
-		reviewBranch = g.resolve("stratify::branch/review");
-	} catch {
-		reviewBranch = node<unknown>([], { initial: null });
-		g.add(reviewBranch, { name: "__review_fallback" });
-	}
-	const reviewAccumulator = node(
-		[reviewBranch],
-		(batchData, _actions, ctx) => {
-			const data = batchData.map((batch, i) =>
-				batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-			);
-			const item = data[0] as ModerationResult | null;
-			if (item) {
-				reviewLog.append(item);
-			}
-		},
-		{ describeKind: "effect" },
-	);
-	g.add(reviewAccumulator as Node<unknown>, { name: "__review_accumulator" });
-	g.addDisposer(keepalive(reviewAccumulator as Node<unknown>));
-	try {
-	} catch {
-		// fallback branch — no stratify edge to register
-	}
-
-	// --- Policy state (human/LLM writable) ---
-	const policy = node<Record<string, unknown>>([], {
-		initial: {},
-		meta: baseMeta("content_moderation", {
-			stage: "policy",
-			access: "both",
-			description: "Moderation policy rules — updated via feedback",
-		}),
-	});
-	g.add(policy as Node<unknown>, { name: "policy" });
-
-	// --- Priority scorer ---
-	const weights = opts.weights ?? [0.1, 1, 2];
-	const confidenceSignal = node<number>(
-		[classifyNode as Node],
-		(batchData, actions, ctx) => {
-			const data = batchData.map((batch, i) =>
-				batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-			);
-			const r = data[0] as ModerationResult | null;
-			actions.emit(r?.confidence ?? 0);
-		},
-		{ describeKind: "derived" },
-	);
-	const severitySignal = node<number>(
-		[classifyNode as Node],
-		(batchData, actions, ctx) => {
-			const data = batchData.map((batch, i) =>
-				batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-			);
-			const r = data[0] as ModerationResult | null;
-			if (!r) {
-				actions.emit(0);
-				return;
-			}
-			actions.emit(
-				r.label === "block" ? weights[2] : r.label === "review" ? weights[1] : weights[0],
-			);
-		},
-		{ describeKind: "derived" },
-	);
-	g.add(confidenceSignal as Node<unknown>, { name: "__confidence_signal" });
-	g.add(severitySignal as Node<unknown>, { name: "__severity_signal" });
-
-	const wConfidence = node<number>([], { initial: 1 });
-	const wSeverity = node<number>([], { initial: 1 });
-	g.add(wConfidence as Node<unknown>, { name: "__w_confidence" });
-	g.add(wSeverity as Node<unknown>, { name: "__w_severity" });
-
-	const priority = scorer([confidenceSignal, severitySignal], [wConfidence, wSeverity]);
-	g.add(priority as Node<unknown>, { name: "priority" });
-
-	// --- Output ---
-	const output = node<unknown>(
-		[classifyNode as Node, priority as Node],
-		(batchData, actions, ctx) => {
-			const vals = batchData.map((batch, i) =>
-				batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-			);
-			actions.emit({
-				classification: vals[0],
-				priority: vals[1],
-			});
-		},
-		{ describeKind: "derived", meta: baseMeta("content_moderation", { stage: "output" }) },
-	);
-	g.add(output, { name: "output" });
-
-	// --- Feedback (false positive → policy refinement) ---
-	// Feedback condition: human marks a review item as false positive.
-	// When review_queue changes and policy exists, signal for update.
-	const fbCondition = node<unknown>(
-		[reviewLog.entries as Node, policy as Node],
-		(batchData, actions, ctx) => {
-			const vals = batchData.map((batch, i) =>
-				batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-			);
-			const entries = vals[0] as readonly ModerationResult[] | null;
-			if (entries && entries.length > 0) {
-				const latest = entries[entries.length - 1];
-				// Items explicitly marked as false positive feed back
-				if (latest && (latest as unknown as Record<string, unknown>).falsePositive) {
-					actions.emit(latest);
-					return;
-				}
-			}
-			actions.emit(null);
-		},
-		{
-			describeKind: "derived",
-			meta: baseMeta("content_moderation", { stage: "feedback_condition" }),
-		},
-	);
-	g.add(fbCondition as Node<unknown>, { name: "feedback_condition" });
-	feedback(g, "feedback_condition", "policy", {
-		maxIterations: opts.maxFeedbackIterations ?? 5,
-	});
-
-	return g;
-}
-
-// ---------------------------------------------------------------------------
-// 4. dataQualityGraph
-// ---------------------------------------------------------------------------
-
-/** Schema validation result. */
-export type ValidationResult = {
-	valid: boolean;
-	errors: string[];
-	record: unknown;
-};
-
-/** Anomaly detection result. */
-export type AnomalyResult = {
-	anomaly: boolean;
-	score: number;
-	detail?: string;
-	record: unknown;
-};
-
-/** Options for {@link dataQualityGraph}. */
-export type DataQualityGraphOptions = GraphOptions & {
-	/** Data source (e.g. fromPrisma(...), fromKysely(...)). */
-	source: Node<unknown>;
-
-	/**
-	 * Schema validation function.
-	 * Default: always valid.
-	 */
-	validate?: (record: unknown) => ValidationResult;
-
-	/**
-	 * Anomaly detection function.
-	 * Default: no anomaly.
-	 */
-	detectAnomaly?: (record: unknown) => AnomalyResult;
-
-	/**
-	 * Drift detection: compares current record against baseline.
-	 * Default: no drift.
-	 */
-	detectDrift?: (record: unknown, baseline: unknown) => unknown;
-
-	/**
-	 * Remediation suggestion function.
-	 * Default: no suggestion.
-	 */
-	suggest?: (result: { validation: ValidationResult; anomaly: AnomalyResult }) => unknown;
-
-	/** Max feedback iterations for rule refinement. Default: 3. */
-	maxFeedbackIterations?: number;
-};
-
-/**
- * Data ingest → schema validation → anomaly detection → drift alerting →
- * auto-remediation suggestions → output.
- *
- * Well-known node names:
- * - `"source"` — data ingest
- * - `"validate"` — schema validation
- * - `"anomaly"` — anomaly detection
- * - `"baseline"` — rolling baseline state
- * - `"drift"` — drift detection
- * - `"remediate"` — auto-remediation suggestions
- * - `"output"` — combined quality report
- *
- * @category patterns
- */
-export function dataQualityGraph(name: string, opts: DataQualityGraphOptions): Graph {
-	const g = new Graph(name, opts);
-
-	// --- Source ---
-	g.add(opts.source, { name: "source" });
-
-	// --- Schema validation ---
-	const validateFn =
-		opts.validate ??
-		((record: unknown): ValidationResult => ({
-			valid: true,
-			errors: [],
-			record,
-		}));
-	const validateNode = node<ValidationResult | undefined>(
-		[opts.source],
-		(batchData, actions, ctx) => {
-			const data = batchData.map((batch, i) =>
-				batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-			);
-			actions.emit(data[0] != null ? validateFn(data[0]) : undefined);
-		},
-		{ describeKind: "derived", meta: baseMeta("data_quality", { stage: "validate" }) },
-	);
-	g.add(validateNode as Node<unknown>, { name: "validate" });
-
-	// --- Anomaly detection ---
-	const detectAnomalyFn =
-		opts.detectAnomaly ??
-		((record: unknown): AnomalyResult => ({
-			anomaly: false,
-			score: 0,
-			record,
-		}));
-	const anomalyNode = node<AnomalyResult | undefined>(
-		[opts.source],
-		(batchData, actions, ctx) => {
-			const data = batchData.map((batch, i) =>
-				batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-			);
-			actions.emit(data[0] != null ? detectAnomalyFn(data[0]) : undefined);
-		},
-		{ describeKind: "derived", meta: baseMeta("data_quality", { stage: "anomaly" }) },
-	);
-	g.add(anomalyNode as Node<unknown>, { name: "anomaly" });
-
-	// --- Baseline (rolling state) ---
-	const baseline = node<unknown>([], {
-		initial: null,
-		meta: baseMeta("data_quality", {
-			stage: "baseline",
-			description: "Rolling baseline for drift detection",
-		}),
-	});
-	g.add(baseline, { name: "baseline" });
-
-	// Update baseline on valid records
-	const baselineUpdater = node(
-		[validateNode as Node],
-		(batchData, _actions, ctx) => {
-			const data = batchData.map((batch, i) =>
-				batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-			);
-			const result = data[0] as ValidationResult;
-			if (result?.valid) {
-				batch(() => {
-					baseline.emit(result.record);
-				});
-			}
-		},
-		{ describeKind: "effect" },
-	);
-	g.add(baselineUpdater as Node<unknown>, { name: "__baseline_updater" });
-	keepalive(baselineUpdater as Node<unknown>);
-
-	// --- Drift detection ---
-	const detectDriftFn = opts.detectDrift ?? (() => ({ drift: false }));
-	const driftNode = node<unknown>(
-		[opts.source, baseline],
-		(batchData, actions, ctx) => {
-			const data = batchData.map((batch, i) =>
-				batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-			);
-			actions.emit(detectDriftFn(data[0], data[1]));
-		},
-		{ describeKind: "derived", meta: baseMeta("data_quality", { stage: "drift" }) },
-	);
-	g.add(driftNode, { name: "drift" });
-
-	// --- Remediation suggestions ---
-	const suggestFn = opts.suggest ?? (() => null);
-	const remediateNode = node<unknown>(
-		[validateNode as Node, anomalyNode as Node],
-		(batchData, actions, ctx) => {
-			const data = batchData.map((batch, i) =>
-				batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-			);
-			actions.emit(
-				suggestFn({
-					validation: data[0] as ValidationResult,
-					anomaly: data[1] as AnomalyResult,
-				}),
-			);
-		},
-		{ describeKind: "derived", meta: baseMeta("data_quality", { stage: "remediate" }) },
-	);
-	g.add(remediateNode, { name: "remediate" });
-
-	// --- Output ---
-	const output = node<unknown>(
-		[validateNode as Node, anomalyNode as Node, driftNode, remediateNode],
-		(batchData, actions, ctx) => {
-			const vals = batchData.map((batch, i) =>
-				batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-			);
-			actions.emit({
-				validation: vals[0],
-				anomaly: vals[1],
-				drift: vals[2],
-				remediation: vals[3],
-			});
-		},
-		{ describeKind: "derived", meta: baseMeta("data_quality", { stage: "output" }) },
-	);
-	g.add(output, { name: "output" });
-
-	// --- Feedback (anomaly → validation rule refinement) ---
-	const validationRules = node<unknown[]>([], {
-		initial: [],
-		meta: baseMeta("data_quality", { stage: "validation_rules" }),
-	});
-	g.add(validationRules as Node<unknown>, { name: "validation_rules" });
-
-	const fbCondition = node<unknown>(
-		[anomalyNode as Node],
-		(batchData, actions, ctx) => {
-			const data = batchData.map((batch, i) =>
-				batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-			);
-			const a = data[0] as AnomalyResult | null;
-			actions.emit(a?.anomaly ? a : null);
-		},
-		{
-			describeKind: "derived",
-			meta: baseMeta("data_quality", { stage: "feedback_condition" }),
-		},
-	);
-	g.add(fbCondition as Node<unknown>, { name: "feedback_condition" });
-	feedback(g, "feedback_condition", "validation_rules", {
-		maxIterations: opts.maxFeedbackIterations ?? 3,
-	});
-
-	return g;
-}
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-/** Check if a value has a `type` or `kind` tag matching the given label. */
-function isTagged(value: unknown, tag: string): boolean {
-	if (value == null || typeof value !== "object") return false;
-	const v = value as Record<string, unknown>;
-	return v.type === tag || v.kind === tag;
-}
diff --git a/src/utils/graphspec/index.ts b/src/utils/graphspec/index.ts
deleted file mode 100644
index 8eccd7f0..00000000
--- a/src/utils/graphspec/index.ts
+++ /dev/null
@@ -1,1812 +0,0 @@
-/**
- * LLM graph composition (roadmap §8.3).
- *
- * Declarative GraphSpec schema + compiler/decompiler for graph topology.
- * The LLM designs graphs as JSON; `compileSpec` instantiates them;
- * `decompileSpec` extracts them back. Templates support reusable subgraph
- * patterns. Feedback edges express bounded cycles via §8.1 feedback().
- *
- * **Tier 1.5.3 Phase 3 (2026-04-27):** `GraphSpec` is a structural alias of
- * {@link GraphDescribeOutput} with two LLM-author-friendly extras
- * (`templates?` / `feedback?`). Per-node factory references are encoded in
- * `meta.factory` + `meta.factoryArgs` (no more `fn` / `source` / `config` /
- * `initial` fields). State node initial values live in
- * `meta.factoryArgs.initial` (state self-tags with
- * `factoryTag("state", { initial })`).
- *
- * @module
- */
-
-import type { DescribeNodeOutput } from "@graphrefly/pure-ts/core";
-import { type Node, node } from "@graphrefly/pure-ts/core";
-import { GRAPH_META_SEGMENT, Graph, type GraphDescribeOutput } from "@graphrefly/pure-ts/graph";
-import type { ChatMessage, LLMAdapter, LLMResponse } from "../ai/index.js";
-import { feedback as feedbackPrimitive } from "../reduction/index.js";
-
-// ---------------------------------------------------------------------------
-// GraphSpec types — structural alias of GraphDescribeOutput
-// ---------------------------------------------------------------------------
-
-/**
- * A single node declaration in a GraphSpec — structural alias of
- * {@link DescribeNodeOutput}.
- *
- * Per-node factory provenance lives in `meta.factory` + `meta.factoryArgs`
- * (use {@link factoryTag} to stamp them at construction time). State node
- * initial values come through `meta.factoryArgs.initial` for tagged states,
- * with fallback to `value` (since spec projection retains state values).
- */
-export type GraphSpecNode = DescribeNodeOutput;
-
-/** Template instantiation node — expanded at compile time. */
-export type GraphSpecTemplateRef = {
-	type: "template";
-	/** Name of the template to instantiate. */
-	template: string;
-	/** Parameter bindings: template param name → node name. */
-	bind: Record<string, string>;
-};
-
-/** A reusable subgraph pattern with parameter substitution. */
-export type GraphSpecTemplate = {
-	/** Parameter names (prefixed with $ in node refs). */
-	params: string[];
-	/** Node declarations within the template. */
-	nodes: Record<string, GraphSpecNode>;
-	/** Which node's output is the template's output. */
-	output: string;
-};
-
-/** A feedback edge: bounded cycle from condition to reentry. */
-export type GraphSpecFeedbackEdge = {
-	/** Node whose DATA triggers the feedback. */
-	from: string;
-	/** State node that receives the feedback value. */
-	to: string;
-	/** Max iterations before stopping (default: 10). */
-	maxIterations?: number;
-};
-
-/**
- * Declarative graph topology for LLM composition (§8.3).
- *
- * Tier 1.5.3 Phase 3 (2026-04-27): structural alias of
- * {@link GraphDescribeOutput} extended with optional `templates` /
- * `feedback` fields for LLM-author convenience. Top-level `factory` /
- * `factoryArgs` (Phase 2.5 carry) ride along on every describe output.
- *
- * Round-trip property: `decompileSpec(g) === g.describe({ detail: "spec" })`
- * (modulo the small feedback-edge extraction sugar).
- */
-export type GraphSpec = Omit<GraphDescribeOutput, "nodes" | "expand"> & {
-	/** Node declarations (keyed by node name). Either a structural describe entry or a template ref. */
-	nodes: Record<string, GraphSpecNode | GraphSpecTemplateRef>;
-	/** Reusable subgraph templates (LLM-author extra; not present in `describe()` output). */
-	templates?: Record<string, GraphSpecTemplate>;
-	/** Feedback edges (bounded cycles, LLM-author extra). */
-	feedback?: GraphSpecFeedbackEdge[];
-};
-
-/**
- * Extract `meta.factory` from a node, if any. Pure read — no normalization.
- */
-function readFactory(node: GraphSpecNode): string | undefined {
-	const f = (node.meta as Record<string, unknown> | undefined)?.factory;
-	return typeof f === "string" ? f : undefined;
-}
-
-/**
- * Extract `meta.factoryArgs` from a node as a plain Record. Pure read.
- */
-function readFactoryArgs(node: GraphSpecNode): Record<string, unknown> {
-	const a = (node.meta as Record<string, unknown> | undefined)?.factoryArgs;
-	return a != null && typeof a === "object" ? (a as Record<string, unknown>) : {};
-}
-
-/**
- * Resolve the initial value for a state node. Prefers
- * `meta.factoryArgs.initial` (the path the `state()` factory itself stamps)
- * and falls back to `value` (in case the spec carries the resolved value
- * without a factory tag, e.g. from a hand-written spec).
- */
-function readStateInitial(node: GraphSpecNode): unknown {
-	const args = readFactoryArgs(node);
-	if ("initial" in args) return args.initial;
-	return node.value;
-}
-
-// ---------------------------------------------------------------------------
-// Catalog types
-// ---------------------------------------------------------------------------
-
-/**
- * Factory for creating a derived/effect/operator node from catalog.
- * Receives resolved dep nodes and the config from the spec.
- */
-export type FnFactory = (deps: Node<unknown>[], config: Record<string, unknown>) => Node<unknown>;
-
-/**
- * Factory for creating a producer node from catalog.
- * Receives the config from the spec.
- */
-export type SourceFactory = (config: Record<string, unknown>) => Node<unknown>;
-
-// ---------------------------------------------------------------------------
-// Rich catalog entries (§9.1b — auto-prompt, catalog-aware validation)
-// ---------------------------------------------------------------------------
-
-/** Simple config field descriptor for LLM prompt generation and validation. */
-export type ConfigFieldSchema = {
-	/** Human-readable type: "string", "number", "boolean", "string[]", etc. */
-	type: string;
-	/** Whether this field is required (default: true). */
-	required?: boolean;
-	/** Allowed values (enum constraint). */
-	enum?: readonly (string | number | boolean)[];
-	/** Human-readable description for LLM context. */
-	description?: string;
-	/** Default value if omitted. */
-	default?: unknown;
-};
-
-/**
- * Rich catalog entry: bundles a runtime factory with LLM-facing metadata.
- *
- * The metadata is used to:
- * 1. Auto-generate prompt text for {@link llmCompose} (replaces manual `catalogDescription`)
- * 2. Validate LLM output in {@link validateSpec} (catch wrong fn names, invalid config)
- * 3. Provide actionable error messages for {@link llmRefine} feedback loops
- *
- * Developers register ONE object; the library handles prompt generation and validation.
- */
-export type CatalogFnEntry = {
-	/** Runtime factory. */
-	factory: FnFactory;
-	/** One-line description for LLM prompt (what it does, not how). */
-	description: string;
-	/** Config field schemas. Keys are config field names. */
-	configSchema?: Record<string, ConfigFieldSchema>;
-	/** Example config objects (shown in prompt for complex fns). */
-	examples?: Record<string, unknown>[];
-	/** Category tags for grouping in prompt (e.g., "resilience", "reduction", "ai"). */
-	tags?: string[];
-};
-
-/** Rich catalog entry for producer sources. */
-export type CatalogSourceEntry = {
-	/** Runtime factory. */
-	factory: SourceFactory;
-	/** One-line description for LLM prompt. */
-	description: string;
-	/** Config field schemas. */
-	configSchema?: Record<string, ConfigFieldSchema>;
-	/** Example config objects. */
-	examples?: Record<string, unknown>[];
-	/** Category tags. */
-	tags?: string[];
-};
-
-/**
- * Top-level Graph factory — used when a spec was produced from a graph that
- * called `Graph.prototype.tagFactory(name, args)`. The catalog supplies a
- * function that takes the recorded `factoryArgs` (JSON-serializable subset)
- * and returns a fully-wired Graph. Runtime context (LLMAdapter instances,
- * callbacks, embedders) is captured by the closure — the args themselves are
- * a documentation fragment, not a complete construction recipe.
- *
- * Tier 1.5.3 Phase 2.5 (DG1=B, 2026-04-27).
- */
-export type GraphSpecFactory = (factoryArgs: unknown) => Graph;
-
-/**
- * Fn/source lookup table passed to compileSpec and llmCompose.
- *
- * Accepts both bare factories (backward-compatible) and rich {@link CatalogFnEntry}
- * / {@link CatalogSourceEntry} objects. When rich entries are provided, the library
- * auto-generates LLM prompts and validates LLM output against the catalog.
- *
- * `graphFactories` (Tier 1.5.3 Phase 2.5) handles top-level Graph-returning
- * factories — when `spec.factory` matches a key, `compileSpec` delegates the
- * entire reconstruction to that factory.
- */
-export type GraphSpecCatalog = {
-	fns?: Record<string, FnFactory | CatalogFnEntry>;
-	sources?: Record<string, SourceFactory | CatalogSourceEntry>;
-	graphFactories?: Record<string, GraphSpecFactory>;
-};
-
-// ---------------------------------------------------------------------------
-// Catalog helpers
-// ---------------------------------------------------------------------------
-
-/** Type guard: is this a rich catalog fn entry (vs bare factory)? */
-export function isRichFnEntry(entry: FnFactory | CatalogFnEntry): entry is CatalogFnEntry {
-	return typeof entry === "object" && entry !== null && "factory" in entry;
-}
-
-/** Type guard: is this a rich catalog source entry (vs bare factory)? */
-export function isRichSourceEntry(
-	entry: SourceFactory | CatalogSourceEntry,
-): entry is CatalogSourceEntry {
-	return typeof entry === "object" && entry !== null && "factory" in entry;
-}
-
-/** Extract the runtime factory from a catalog entry (rich or bare). */
-export function extractFnFactory(entry: FnFactory | CatalogFnEntry): FnFactory {
-	return isRichFnEntry(entry) ? entry.factory : entry;
-}
-
-/** Extract the runtime factory from a catalog source entry (rich or bare). */
-export function extractSourceFactory(entry: SourceFactory | CatalogSourceEntry): SourceFactory {
-	return isRichSourceEntry(entry) ? entry.factory : entry;
-}
-
-/**
- * Auto-generate catalog prompt text from rich catalog entries.
- *
- * Groups fns by tag, formats each as `- name: description. Config: { ... }`.
- * Falls back to listing names only for bare factories.
- */
-export function generateCatalogPrompt(catalog: GraphSpecCatalog): string {
-	const sections: string[] = [];
-
-	if (catalog.fns) {
-		// Group by first tag (or "Other")
-		const groups = new Map<string, string[]>();
-		for (const [name, entry] of Object.entries(catalog.fns)) {
-			const tag = isRichFnEntry(entry) ? (entry.tags?.[0] ?? "Other") : "Other";
-			if (!groups.has(tag)) groups.set(tag, []);
-			groups.get(tag)!.push(formatFnEntry(name, entry));
-		}
-		for (const [tag, lines] of groups) {
-			sections.push(`${tag}:\n${lines.join("\n")}`);
-		}
-	}
-
-	if (catalog.sources) {
-		const lines: string[] = [];
-		for (const [name, entry] of Object.entries(catalog.sources)) {
-			lines.push(formatSourceEntry(name, entry));
-		}
-		if (lines.length > 0) {
-			sections.push(`Sources:\n${lines.join("\n")}`);
-		}
-	}
-
-	return sections.join("\n\n");
-}
-
-function formatFnEntry(name: string, entry: FnFactory | CatalogFnEntry): string {
-	if (!isRichFnEntry(entry)) return `- ${name}`;
-	let line = `- ${name}: ${entry.description}`;
-	if (entry.configSchema) {
-		const fields = Object.entries(entry.configSchema).map(([k, v]) => {
-			let desc = `${k}: ${v.type}`;
-			if (v.enum) desc += ` (${v.enum.join("|")})`;
-			if (v.required === false) desc += "?";
-			return desc;
-		});
-		line += `. Config: { ${fields.join(", ")} }`;
-	}
-	return line;
-}
-
-function formatSourceEntry(name: string, entry: SourceFactory | CatalogSourceEntry): string {
-	if (!isRichSourceEntry(entry)) return `- ${name}`;
-	let line = `- ${name}: ${entry.description}`;
-	if (entry.configSchema) {
-		const fields = Object.entries(entry.configSchema).map(([k, v]) => {
-			let desc = `${k}: ${v.type}`;
-			if (v.required === false) desc += "?";
-			return desc;
-		});
-		line += `. Config: { ${fields.join(", ")} }`;
-	}
-	return line;
-}
-
-/**
- * Validate a GraphSpec against a catalog.
- *
- * Checks that fn/source names reference actual catalog entries, and validates
- * config fields against configSchema when rich entries are available.
- * Returns additional errors beyond structural {@link validateSpec} checks.
- */
-export function validateSpecAgainstCatalog(
-	spec: GraphSpec,
-	catalog: GraphSpecCatalog,
-): GraphSpecValidation {
-	const errors: string[] = [];
-	const fnNames = new Set(Object.keys(catalog.fns ?? {}));
-	const sourceNames = new Set(Object.keys(catalog.sources ?? {}));
-
-	for (const [nodeName, nodeRaw] of Object.entries(spec.nodes)) {
-		if (nodeRaw.type === "template") continue;
-		const node = nodeRaw as GraphSpecNode;
-		const factoryName = readFactory(node);
-		if (factoryName == null) continue;
-
-		const isProducer = node.type === "producer";
-		// State nodes self-tag with `factory: "state"` — never expected to live
-		// in the catalog. Skip.
-		if (node.type === "state" && factoryName === "state") continue;
-
-		// Producers may resolve via either sources (preferred) or fns; non-
-		// producers only resolve via fns. Mismatched-side suggestions (e.g.
-		// using a source name on a derived node) match the legacy diagnostic.
-		if (isProducer) {
-			const inSources = sourceNames.has(factoryName);
-			const inFns = fnNames.has(factoryName);
-			if (!inSources && !inFns && (sourceNames.size > 0 || fnNames.size > 0)) {
-				const suggestion =
-					findClosest(factoryName, sourceNames) ?? findClosest(factoryName, fnNames);
-				errors.push(
-					`Node "${nodeName}": source "${factoryName}" not found in catalog` +
-						(suggestion ? `. Did you mean "${suggestion}"?` : ""),
-				);
-			}
-		} else {
-			if (fnNames.size > 0 && !fnNames.has(factoryName)) {
-				if (sourceNames.has(factoryName)) {
-					errors.push(
-						`Node "${nodeName}": fn "${factoryName}" is a source, not a function. ` +
-							`Use it as a producer source instead, or use a function from: ${[...fnNames].join(", ")}`,
-					);
-				} else {
-					const suggestion = findClosest(factoryName, fnNames);
-					errors.push(
-						`Node "${nodeName}": fn "${factoryName}" not found in catalog` +
-							(suggestion ? `. Did you mean "${suggestion}"?` : ""),
-					);
-				}
-			}
-		}
-
-		// Validate config (`meta.factoryArgs`) against schema (if rich entry).
-		const factoryArgs = readFactoryArgs(node);
-		if (!isProducer && catalog.fns?.[factoryName]) {
-			const entry = catalog.fns[factoryName];
-			if (isRichFnEntry(entry) && entry.configSchema) {
-				for (const [field, schema] of Object.entries(entry.configSchema)) {
-					if (schema.required !== false && !(field in factoryArgs)) {
-						errors.push(`Node "${nodeName}": config missing required field "${field}"`);
-					}
-					if (field in factoryArgs && schema.enum) {
-						const val = factoryArgs[field];
-						if (!schema.enum.includes(val as string | number | boolean)) {
-							errors.push(
-								`Node "${nodeName}": config.${field} = ${JSON.stringify(val)}, ` +
-									`expected one of: ${schema.enum.join(", ")}`,
-							);
-						}
-					}
-				}
-			}
-		}
-		if (isProducer && catalog.sources?.[factoryName]) {
-			const entry = catalog.sources[factoryName];
-			if (isRichSourceEntry(entry) && entry.configSchema) {
-				for (const [field, schema] of Object.entries(entry.configSchema)) {
-					if (schema.required !== false && !(field in factoryArgs)) {
-						errors.push(`Node "${nodeName}": config missing required field "${field}"`);
-					}
-					if (field in factoryArgs && schema.enum) {
-						const val = factoryArgs[field];
-						if (!schema.enum.includes(val as string | number | boolean)) {
-							errors.push(
-								`Node "${nodeName}": config.${field} = ${JSON.stringify(val)}, ` +
-									`expected one of: ${schema.enum.join(", ")}`,
-							);
-						}
-					}
-				}
-			}
-		}
-	}
-
-	// Also check template inner nodes
-	if (spec.templates) {
-		for (const [tName, template] of Object.entries(spec.templates)) {
-			for (const [nodeName, node] of Object.entries(template.nodes)) {
-				const factoryName = readFactory(node);
-				if (factoryName == null) continue;
-				if (node.type === "state" && factoryName === "state") continue;
-				if (node.type === "producer") continue; // template producer/source skipped (parity with legacy)
-				if (fnNames.size > 0 && !fnNames.has(factoryName)) {
-					const suggestion = findClosest(factoryName, fnNames);
-					errors.push(
-						`Template "${tName}" node "${nodeName}": fn "${factoryName}" not found in catalog` +
-							(suggestion ? `. Did you mean "${suggestion}"?` : ""),
-					);
-				}
-			}
-		}
-	}
-
-	return { valid: errors.length === 0, errors, warnings: [] };
-}
-
-/** Simple Levenshtein-based closest match for "did you mean?" suggestions. */
-function findClosest(input: string, candidates: Set<string>): string | null {
-	let best: string | null = null;
-	let bestDist = Infinity;
-	const lower = input.toLowerCase();
-	for (const c of candidates) {
-		const dist = levenshtein(lower, c.toLowerCase());
-		if (dist < bestDist && dist <= Math.max(3, Math.floor(input.length / 2))) {
-			bestDist = dist;
-			best = c;
-		}
-	}
-	return best;
-}
-
-function levenshtein(a: string, b: string): number {
-	const m = a.length;
-	const n = b.length;
-	const dp: number[][] = Array.from({ length: m + 1 }, (_, i) =>
-		Array.from({ length: n + 1 }, (_, j) => (i === 0 ? j : j === 0 ? i : 0)),
-	);
-	for (let i = 1; i <= m; i++) {
-		for (let j = 1; j <= n; j++) {
-			dp[i][j] =
-				a[i - 1] === b[j - 1]
-					? dp[i - 1][j - 1]
-					: 1 + Math.min(dp[i - 1][j], dp[i][j - 1], dp[i - 1][j - 1]);
-		}
-	}
-	return dp[m][n];
-}
-
-// ---------------------------------------------------------------------------
-// Validation
-// ---------------------------------------------------------------------------
-
-/** Validation result from {@link validateSpec}. */
-export type GraphSpecValidation = {
-	valid: boolean;
-	errors: string[];
-	/**
-	 * Non-fatal advisories. Currently includes feedback edges whose `from`
-	 * refers to an `effect` node (effects produce no DATA — the feedback
-	 * counter will never advance). Always present (empty array when nothing
-	 * is flagged) — symmetry with `errors` so callers can read
-	 * `result.warnings.length` without a null check.
-	 */
-	warnings: string[];
-};
-
-const VALID_NODE_TYPES = new Set([
-	"state",
-	"producer",
-	"derived",
-	"effect",
-	"operator",
-	"template",
-]);
-
-const INNER_NODE_TYPES = new Set(["state", "producer", "derived", "effect", "operator"]);
-
-/**
- * Validate a GraphSpec JSON object.
- *
- * Checks structural validity: required fields, node types, dep references,
- * template references, feedback edge targets, self-cycles, and bind completeness.
- *
- * **Effect-node feedback advisory (C24-3).** When a feedback edge's `from`
- * refers to an `effect` node, the validator flags it via `warnings` (not
- * `errors`) — effect nodes produce no DATA emission, so a feedback counter
- * targeting one will never advance. The spec compiles either way; the
- * advisory exists because the misconfiguration is silent at runtime
- * (counter at 0 forever) without it.
- */
-export function validateSpec(spec: unknown): GraphSpecValidation {
-	const errors: string[] = [];
-	const warnings: string[] = [];
-
-	if (spec == null || typeof spec !== "object") {
-		return { valid: false, errors: ["GraphSpec must be a non-null object"], warnings };
-	}
-
-	const s = spec as Record<string, unknown>;
-
-	if (typeof s.name !== "string" || s.name.length === 0) {
-		errors.push("Missing or empty 'name' field");
-	}
-
-	if (s.nodes == null || typeof s.nodes !== "object" || Array.isArray(s.nodes)) {
-		errors.push("Missing or invalid 'nodes' field (must be an object)");
-		return { valid: false, errors, warnings };
-	}
-
-	const nodeNames = new Set(Object.keys(s.nodes as object));
-	const nodeTypes = new Map<string, string>();
-	const templateDefs = new Map<string, { params: string[] }>();
-
-	// Pre-scan template definitions for param validation
-	if (s.templates != null && typeof s.templates === "object" && !Array.isArray(s.templates)) {
-		for (const [tName, tRaw] of Object.entries(s.templates as Record<string, unknown>)) {
-			if (tRaw != null && typeof tRaw === "object") {
-				const t = tRaw as Record<string, unknown>;
-				templateDefs.set(tName, {
-					params: Array.isArray(t.params) ? (t.params as string[]) : [],
-				});
-			}
-		}
-	}
-
-	// Validate templates
-	if (s.templates != null) {
-		if (typeof s.templates !== "object" || Array.isArray(s.templates)) {
-			errors.push("'templates' must be an object");
-		} else {
-			for (const [tName, tRaw] of Object.entries(s.templates as Record<string, unknown>)) {
-				if (tRaw == null || typeof tRaw !== "object") {
-					errors.push(`Template "${tName}": must be an object`);
-					continue;
-				}
-				const t = tRaw as Record<string, unknown>;
-				if (!Array.isArray(t.params)) {
-					errors.push(`Template "${tName}": missing 'params' array`);
-				}
-				if (t.nodes == null || typeof t.nodes !== "object" || Array.isArray(t.nodes)) {
-					errors.push(`Template "${tName}": missing or invalid 'nodes' object`);
-				} else {
-					const paramSet = new Set(Array.isArray(t.params) ? (t.params as string[]) : []);
-					const innerNames = new Set(Object.keys(t.nodes as object));
-					for (const [nName, nRaw] of Object.entries(t.nodes as Record<string, unknown>)) {
-						if (nRaw == null || typeof nRaw !== "object") {
-							errors.push(`Template "${tName}" node "${nName}": must be an object`);
-							continue;
-						}
-						const n = nRaw as Record<string, unknown>;
-						if (typeof n.type !== "string" || !INNER_NODE_TYPES.has(n.type)) {
-							errors.push(`Template "${tName}" node "${nName}": invalid type`);
-						}
-						if (Array.isArray(n.deps)) {
-							for (const dep of n.deps as string[]) {
-								if (!innerNames.has(dep) && !paramSet.has(dep)) {
-									errors.push(
-										`Template "${tName}" node "${nName}": dep "${dep}" is not an inner node or param`,
-									);
-								}
-							}
-						}
-					}
-					if (typeof t.output !== "string") {
-						errors.push(`Template "${tName}": missing 'output' string`);
-					} else if (!(t.nodes as Record<string, unknown>)[t.output as string]) {
-						errors.push(`Template "${tName}": output "${t.output}" is not a declared node`);
-					}
-				}
-			}
-		}
-	}
-
-	// Validate nodes
-	for (const [name, raw] of Object.entries(s.nodes as Record<string, unknown>)) {
-		if (raw == null || typeof raw !== "object") {
-			errors.push(`Node "${name}": must be an object`);
-			continue;
-		}
-		const n = raw as Record<string, unknown>;
-		if (typeof n.type !== "string" || !VALID_NODE_TYPES.has(n.type)) {
-			errors.push(
-				`Node "${name}": invalid type "${String(n.type)}" (expected: ${[...VALID_NODE_TYPES].join(", ")})`,
-			);
-			continue;
-		}
-		nodeTypes.set(name, n.type);
-
-		if (n.type === "template") {
-			if (typeof n.template !== "string" || !templateDefs.has(n.template)) {
-				errors.push(`Node "${name}": template "${String(n.template)}" not found in templates`);
-			} else {
-				// Check bind completeness: all template params must be bound
-				if (n.bind == null || typeof n.bind !== "object" || Array.isArray(n.bind)) {
-					errors.push(`Node "${name}": template ref requires 'bind' object`);
-				} else {
-					const tmpl = templateDefs.get(n.template as string)!;
-					const bind = n.bind as Record<string, string>;
-					for (const param of tmpl.params) {
-						if (!(param in bind)) {
-							errors.push(
-								`Node "${name}": template param "${param}" is not bound (template "${n.template}")`,
-							);
-						}
-					}
-					for (const [, target] of Object.entries(bind)) {
-						if (typeof target === "string" && !nodeNames.has(target)) {
-							errors.push(
-								`Node "${name}": bind target "${target}" does not reference an existing node`,
-							);
-						}
-					}
-				}
-			}
-		} else {
-			if (Array.isArray(n.deps)) {
-				for (const dep of n.deps as string[]) {
-					// Self-referencing dep
-					if (dep === name) {
-						errors.push(`Node "${name}": self-referencing dep`);
-					} else if (!nodeNames.has(dep)) {
-						errors.push(`Node "${name}": dep "${dep}" does not reference an existing node`);
-					}
-				}
-			}
-			// Warn: derived/effect/operator without deps
-			if (
-				(n.type === "derived" || n.type === "effect" || n.type === "operator") &&
-				!Array.isArray(n.deps)
-			) {
-				errors.push(`Node "${name}": ${n.type} node should have a 'deps' array`);
-			}
-		}
-	}
-
-	// Validate feedback edges
-	if (s.feedback != null) {
-		if (!Array.isArray(s.feedback)) {
-			errors.push("'feedback' must be an array");
-		} else {
-			for (let i = 0; i < (s.feedback as unknown[]).length; i++) {
-				const edge = (s.feedback as unknown[])[i];
-				if (edge == null || typeof edge !== "object") {
-					errors.push(`Feedback [${i}]: must be an object`);
-					continue;
-				}
-				const e = edge as Record<string, unknown>;
-				if (typeof e.from !== "string" || !nodeNames.has(e.from)) {
-					errors.push(
-						`Feedback [${i}]: 'from' "${String(e.from)}" does not reference an existing node`,
-					);
-				} else if (nodeTypes.get(e.from) === "effect") {
-					// Effect nodes produce no DATA — a feedback edge from one will
-					// never trigger the counter / re-entry. Almost certainly a
-					// modelling mistake (caller probably meant the upstream
-					// derived/state node). Warn but don't reject — the spec is
-					// structurally valid; some advanced uses might still be ok.
-					warnings.push(
-						`Feedback [${i}]: 'from' "${e.from}" is an effect node — effects emit no DATA, so the feedback edge will never fire. Did you mean a derived/state node upstream?`,
-					);
-				}
-				if (typeof e.from === "string" && e.from === e.to) {
-					errors.push(`Feedback [${i}]: 'from' and 'to' must be different nodes`);
-				}
-				if (typeof e.to !== "string" || !nodeNames.has(e.to)) {
-					errors.push(
-						`Feedback [${i}]: 'to' "${String(e.to)}" does not reference an existing node`,
-					);
-				} else if (typeof e.to === "string" && nodeTypes.get(e.to) !== "state") {
-					errors.push(
-						`Feedback [${i}]: 'to' node "${e.to}" must be a state node (got "${nodeTypes.get(e.to) ?? "unknown"}")`,
-					);
-				}
-			}
-		}
-	}
-
-	return {
-		valid: errors.length === 0,
-		errors,
-		warnings,
-	};
-}
-
-// ---------------------------------------------------------------------------
-// validateOwnership — multi-agent subgraph ownership PR lint (DS-14.5.A #5)
-// ---------------------------------------------------------------------------
-
-/**
- * Read `meta.owner` from a spec node. Pure read — no normalization.
- * Empty / non-string is treated as "no annotation" (silent, INV-OWNER-2).
- */
-function readOwner(node: GraphSpecNode): string | undefined {
-	const o = (node.meta as Record<string, unknown> | undefined)?.owner;
-	return typeof o === "string" && o.length > 0 ? o : undefined;
-}
-
-/**
- * The change-set fed to {@link validateOwnership}. Mirrors the minimal slice
- * of a PR diff the lint needs: the set of factory identifiers whose
- * implementation the diff touches, plus the PR author and (optionally) the
- * raw commit-message text so the `Override-Owner:` trailer can be detected.
- *
- * **Why factory-keyed (not path-keyed) — locked decision (DS-14.5.A Q5
- * sub-flag).** PR-diff → spec-node mapping resolves through `meta.factory`
- * provenance, NOT a `meta.ownerPath` glob. A diff that edits the
- * implementation of factory `"rateLimiter"` maps to *every* spec node whose
- * `meta.factory === "rateLimiter"`. This reuses the existing
- * `factoryTag` / `decompileSpec` round-trip (the same `meta.factory` field
- * `compileSpec` consumes) — no parallel ownership-path indexing scheme.
- */
-export type OwnershipPrDiff = {
-	/**
-	 * Factory identifiers (the `meta.factory` value) whose source the PR
-	 * modifies. A spec node is "edited by this PR" iff its `meta.factory` is
-	 * in this set. Nodes without `meta.factory` cannot be mapped from a code
-	 * diff and are therefore never flagged (silent — consistent with the
-	 * un-annotated rule).
-	 */
-	readonly editedFactories: readonly string[];
-	/** PR author's `Actor.id`. Compared against each edited node's `meta.owner`. */
-	readonly author: string;
-	/**
-	 * Raw commit message(s) text. If any line is an `Override-Owner: <reason>`
-	 * trailer (case-insensitive key, non-empty reason) the lint hard-fail is
-	 * bypassed and recorded as an audit-trail override (Q5 sub-lock i — any
-	 * committer may use it; it is recorded, never silently granted).
-	 */
-	readonly commitMessage?: string;
-};
-
-/** One cross-owner violation surfaced by {@link validateOwnership}. */
-export type OwnershipViolation = {
-	/** Spec node path that carries `meta.owner` and was edited by a non-owner. */
-	readonly node: string;
-	/** The `meta.owner` value on that node. */
-	readonly owner: string;
-	/** The PR author who edited it. */
-	readonly author: string;
-	/** The `meta.factory` that mapped the diff onto this node. */
-	readonly factory: string;
-};
-
-/** Result of {@link validateOwnership}. */
-export type OwnershipValidation = {
-	/**
-	 * `true` when no hard-fail applies — either no cross-owner edit, or every
-	 * cross-owner edit is bypassed by a valid `Override-Owner:` trailer.
-	 */
-	readonly ok: boolean;
-	/** Cross-owner edits that hard-fail (empty when `ok`). */
-	readonly violations: readonly OwnershipViolation[];
-	/**
-	 * Cross-owner edits that WOULD have failed but were bypassed by an
-	 * `Override-Owner:` commit trailer. Pure audit trail — CI / reviewers
-	 * grep this to surface override abuse. Present (possibly empty) so callers
-	 * can read `.overridden.length` without a null check.
-	 */
-	readonly overridden: readonly OwnershipViolation[];
-	/**
-	 * The override reason parsed from the `Override-Owner:` trailer, when one
-	 * was present and applied. `undefined` when no trailer was used.
-	 */
-	readonly overrideReason?: string;
-};
-
-const OVERRIDE_OWNER_TRAILER = /^\s*override-owner\s*:\s*(.+?)\s*$/im;
-
-/**
- * Detect an `Override-Owner: <reason>` commit trailer (case-insensitive key;
- * reason must be non-empty after trim). Returns the trimmed reason, or
- * `undefined` when absent.
- */
-function parseOverrideOwner(commitMessage: string | undefined): string | undefined {
-	if (commitMessage == null) return undefined;
-	const m = OVERRIDE_OWNER_TRAILER.exec(commitMessage);
-	const reason = m?.[1]?.trim();
-	return reason != null && reason.length > 0 ? reason : undefined;
-}
-
-/**
- * Multi-agent subgraph ownership PR lint (DS-14.5.A delta #5, L0 rung;
- * spec §2.3a INV-OWNER-2).
- *
- * Hard-fails a pull request whose code diff edits a spec node carrying
- * `meta.owner` when the PR author is not that owner. Nodes **without**
- * `meta.owner` are silent (no advisory, no failure) — "shared infrastructure"
- * is exactly the un-annotated case; no separate allow-list is maintained.
- *
- * **Rules (Q5 lock):**
- * - Edited node has no `meta.owner` → silent.
- * - Edited node has `meta.owner` AND `author === meta.owner` → OK.
- * - Edited node has `meta.owner` AND `author !== meta.owner` → **violation**
- *   (hard-fail) unless an `Override-Owner: <reason>` commit trailer is present,
- *   in which case the violation is moved to `overridden` (audit trail) and
- *   `ok` stays `true`.
- *
- * **PR-diff → spec-node mapping (Q5 sub-flag lock):** `meta.factory`
- * resolution. A node is "edited" iff its `meta.factory` appears in
- * `prDiff.editedFactories`. This reuses the `factoryTag` / `decompileSpec`
- * round-trip rather than introducing a `meta.ownerPath` glob. Nodes without
- * `meta.factory` can't be mapped from a code diff and are never flagged.
- *
- * Pure function — no `Node` / `Graph` returned, no side effects. Designed to
- * be called from a `graphrefly check-spec`-adjacent CI step (delta #6, Phase
- * 16) or any host PR gate.
- *
- * @param spec - The committed GraphSpec (or any `describe({ detail: "spec" })`
- *   projection / structural superset).
- * @param prDiff - The factory-keyed diff slice + author + commit text.
- */
-export function validateOwnership(spec: unknown, prDiff: OwnershipPrDiff): OwnershipValidation {
-	const violations: OwnershipViolation[] = [];
-	const overridden: OwnershipViolation[] = [];
-
-	if (spec == null || typeof spec !== "object") {
-		return { ok: true, violations, overridden };
-	}
-	const s = spec as Record<string, unknown>;
-	const nodes = s.nodes;
-	if (nodes == null || typeof nodes !== "object" || Array.isArray(nodes)) {
-		return { ok: true, violations, overridden };
-	}
-
-	const edited = new Set(prDiff.editedFactories);
-	if (edited.size > 0) {
-		for (const [path, nRaw] of Object.entries(nodes as Record<string, unknown>)) {
-			if (nRaw == null || typeof nRaw !== "object") continue;
-			const n = nRaw as GraphSpecNode;
-			const factory = readFactory(n);
-			// Unmappable from a code diff (no factory provenance) → silent.
-			if (factory == null || !edited.has(factory)) continue;
-			const owner = readOwner(n);
-			// No annotation → silent (INV-OWNER-2: un-annotated == shared).
-			if (owner == null) continue;
-			// Author IS the owner → OK.
-			if (owner === prDiff.author) continue;
-			violations.push({ node: path, owner, author: prDiff.author, factory });
-		}
-	}
-
-	const overrideReason = parseOverrideOwner(prDiff.commitMessage);
-	if (violations.length > 0 && overrideReason != null) {
-		// Trailer bypasses ALL cross-owner violations in this PR (the trailer
-		// is PR-scoped and a pure audit-trail record per Q5 sub-lock i).
-		overridden.push(...violations);
-		return { ok: true, violations: [], overridden, overrideReason };
-	}
-
-	return {
-		ok: violations.length === 0,
-		violations,
-		overridden,
-		...(overrideReason != null ? { overrideReason } : {}),
-	};
-}
-
-// ---------------------------------------------------------------------------
-// compileSpec
-// ---------------------------------------------------------------------------
-
-/** Options for {@link compileSpec}. */
-export type CompileSpecOptions = {
-	/** Fn/source catalog for resolving named factories. */
-	catalog?: GraphSpecCatalog;
-	/**
-	 * How to handle nodes whose `fn` / `source` is missing from the catalog.
-	 * - `"placeholder"` (default): silently substitute identity passthroughs
-	 *   (`node([], () => {})` / `node(deps, (bd, a, ctx) => a.emit(bd[0]?.at(-1)))`). Backward-
-	 *   compatible — preserves the historical "soft compile" behavior.
-	 * - `"warn"`: substitute placeholders AND log each missing entry via
-	 *   `console.warn`, or via the `onWarn` callback if supplied.
-	 * - `"error"`: collect every missing entry across the whole spec, then
-	 *   throw an `Error` listing them all (no partial graph returned).
-	 */
-	onMissing?: "error" | "warn" | "placeholder";
-	/** Custom warning sink. Used only when `onMissing === "warn"`. Defaults to `console.warn`. */
-	onWarn?: (message: string) => void;
-};
-
-interface MissingCatalogEntry {
-	/** Node path (template-prefixed where applicable, e.g. `myMount.inner`). */
-	path: string;
-	/** The catalog kind (`"fn"` or `"source"`) that was looked up. */
-	kind: "fn" | "source";
-	/** The catalog name string supplied in the spec. */
-	name: string;
-}
-
-/**
- * Instantiate a Graph from a GraphSpec.
- *
- * Handles template expansion (mounted subgraphs), feedback wiring via §8.1
- * feedback(), node factory lookup from the catalog, and topology validation.
- *
- * @param spec - Declarative graph topology.
- * @param opts - Catalog and compile options.
- * @returns A running Graph.
- * @throws On validation failure, missing catalog entries, or unresolvable deps.
- *
- * @category patterns
- */
-export function compileSpec(spec: GraphSpec, opts?: CompileSpecOptions): Graph {
-	// QA F4: validate FIRST, even when the early-dispatch path will delegate to
-	// a Graph-level factory. The early-dispatch is a *constructor* short-circuit,
-	// not a *validation* short-circuit — we still want malformed specs to throw
-	// so a catalog-tagged spec with bogus nodes/templates surfaces the error.
-	const validation = validateSpec(spec);
-	if (!validation.valid) {
-		throw new Error(`compileSpec: invalid GraphSpec:\n${validation.errors.join("\n")}`);
-	}
-
-	// Tier 1.5.3 Phase 2.5 (DG1=B): if the spec carries a top-level `factory`
-	// tag and the catalog has a matching `graphFactories` entry, delegate the
-	// full reconstruction. This lets Graph-returning factories
-	// (`agentMemory`, `harnessLoop`, etc.) own their own rebuild path with
-	// access to user-supplied runtime ctx (LLMAdapter, callbacks).
-	const specFactory = spec.factory;
-	const specFactoryArgs = spec.factoryArgs;
-	if (typeof specFactory === "string") {
-		const graphFactory = opts?.catalog?.graphFactories?.[specFactory];
-		if (graphFactory) return graphFactory(specFactoryArgs);
-		// No catalog entry for the named factory — fall through to per-node
-		// compile so the per-node-tagged paths still work.
-	}
-
-	const catalog = opts?.catalog ?? {};
-	const onMissing = opts?.onMissing ?? "placeholder";
-	const g = new Graph(spec.name);
-	const templates = spec.templates ?? {};
-
-	// Catalog-aware validation (when rich entries are available)
-	const catalogValidation = validateSpecAgainstCatalog(spec, catalog);
-	if (!catalogValidation.valid) {
-		throw new Error(
-			`compileSpec: catalog validation errors:\n${catalogValidation.errors.join("\n")}`,
-		);
-	}
-
-	// Track missing catalog entries across both top-level and template passes;
-	// the chosen `onMissing` policy is applied once after compile so callers see
-	// every miss in a single error / warn batch instead of one-at-a-time.
-	const missingEntries: MissingCatalogEntry[] = [];
-
-	const recordMissing = (nodePath: string, kind: "fn" | "source", name: string): void => {
-		missingEntries.push({ path: nodePath, kind, name });
-	};
-
-	// Helper: resolve fn/source factories from catalog (handles rich + bare entries)
-	const resolveFn = (fnName: string): FnFactory | undefined => {
-		const entry = catalog.fns?.[fnName];
-		return entry ? extractFnFactory(entry) : undefined;
-	};
-	const resolveSource = (sourceName: string): SourceFactory | undefined => {
-		const entry = catalog.sources?.[sourceName];
-		return entry ? extractSourceFactory(entry) : undefined;
-	};
-
-	/**
-	 * Strip the `factory` / `factoryArgs` keys from a spec node's `meta`
-	 * before forwarding to the construction factory. The factory itself
-	 * re-stamps its own `factoryTag(...)` (so the rebuilt node carries the
-	 * canonical factoryArgs); leaving the spec's pre-stamped meta in place
-	 * would shadow that with stale args (esp. after `placeholderArgs`
-	 * scrubbed non-JSON fields).
-	 */
-	const stripFactoryMeta = (
-		meta: Record<string, unknown> | undefined,
-	): Record<string, unknown> | undefined => {
-		if (!meta) return undefined;
-		const out: Record<string, unknown> = {};
-		for (const [k, v] of Object.entries(meta)) {
-			if (k === "factory" || k === "factoryArgs") continue;
-			out[k] = v;
-		}
-		return Object.keys(out).length > 0 ? out : undefined;
-	};
-
-	// Phase 1: Create non-template nodes (state/producer first, then derived/effect/operator)
-	const created = new Map<string, Node<unknown>>();
-	const deferred: [string, GraphSpecNode][] = [];
-
-	for (const [name, raw] of Object.entries(spec.nodes)) {
-		if (raw.type === "template") continue; // handled in Phase 2
-
-		const n = raw as GraphSpecNode;
-		const factoryName = readFactory(n);
-		const factoryArgs = readFactoryArgs(n);
-
-		if (n.type === "state") {
-			const initial = readStateInitial(n);
-			const nd = node([], {
-				name,
-				initial,
-				meta: stripFactoryMeta(n.meta),
-			});
-			g.add(nd, { name: name });
-			created.set(name, nd);
-		} else if (n.type === "producer") {
-			// Producer: try sources first (matching the legacy precedence) then fns.
-			const sourceFactory = factoryName ? resolveSource(factoryName) : undefined;
-			const fnFactory = factoryName ? resolveFn(factoryName) : undefined;
-			if (sourceFactory) {
-				const nd = sourceFactory(factoryArgs);
-				g.add(nd, { name: name });
-				created.set(name, nd);
-			} else if (fnFactory) {
-				const nd = fnFactory([], factoryArgs);
-				g.add(nd, { name: name });
-				created.set(name, nd);
-			} else {
-				// No catalog entry — create a bare producer placeholder.
-				if (factoryName) recordMissing(name, "source", factoryName);
-				const nd = node([], () => {}, {
-					name,
-					describeKind: "producer",
-					meta: { ...stripFactoryMeta(n.meta), _specSource: factoryName },
-				});
-				g.add(nd, { name: name });
-				created.set(name, nd);
-			}
-		} else {
-			deferred.push([name, n]);
-		}
-	}
-
-	// Resolve deferred nodes (derived/effect/operator) in dependency order
-	let progressed = true;
-	const pending = new Map(deferred);
-	while (pending.size > 0 && progressed) {
-		progressed = false;
-		for (const [name, n] of [...pending.entries()]) {
-			const deps = n.deps ?? [];
-			if (!deps.every((dep) => created.has(dep))) continue;
-
-			const resolvedDeps = deps.map((dep) => created.get(dep)!);
-			const factoryName = readFactory(n);
-			const factoryArgs = readFactoryArgs(n);
-			const fnFactory = factoryName ? resolveFn(factoryName) : undefined;
-
-			let nd: Node<unknown>;
-			if (fnFactory) {
-				nd = fnFactory(resolvedDeps, factoryArgs);
-			} else if (n.type === "effect") {
-				if (factoryName) recordMissing(name, "fn", factoryName);
-				nd = node(resolvedDeps, () => {}, { describeKind: "effect" });
-			} else {
-				// derived without catalog fn — identity passthrough
-				if (factoryName) recordMissing(name, "fn", factoryName);
-				nd = node(
-					resolvedDeps,
-					(batchData, actions, ctx) => {
-						const data = batchData.map((batch, i) =>
-							batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-						);
-						actions.emit(data[0]);
-					},
-					{ describeKind: "derived" },
-				);
-			}
-			g.add(nd, { name: name });
-			created.set(name, nd);
-			pending.delete(name);
-			progressed = true;
-		}
-	}
-	if (pending.size > 0) {
-		const unresolved = [...pending.keys()].sort().join(", ");
-		throw new Error(`compileSpec: unresolvable deps for nodes: ${unresolved}`);
-	}
-
-	// Phase 2: Expand template instantiations as mounted subgraphs
-	for (const [name, raw] of Object.entries(spec.nodes)) {
-		if (raw.type !== "template") continue;
-		const ref = raw as GraphSpecTemplateRef;
-		const tmpl = templates[ref.template]!;
-
-		const sub = new Graph(name);
-		const subCreated = new Map<string, Node<unknown>>();
-		const subDeferred: [string, GraphSpecNode][] = [];
-
-		// Create inner nodes, resolving $params to bound nodes
-		for (const [nName, nSpec] of Object.entries(tmpl.nodes)) {
-			const resolvedDeps = (nSpec.deps ?? []).map((dep) => {
-				if (dep.startsWith("$") && ref.bind[dep]) {
-					return ref.bind[dep];
-				}
-				return dep;
-			});
-			const specWithResolvedDeps: GraphSpecNode = { ...nSpec, deps: resolvedDeps };
-			const factoryName = readFactory(nSpec);
-			const factoryArgs = readFactoryArgs(nSpec);
-
-			if (nSpec.type === "state") {
-				const initial = readStateInitial(nSpec);
-				const nd = node([], {
-					name: nName,
-					initial,
-					meta: stripFactoryMeta(nSpec.meta),
-				});
-				sub.add(nd, { name: nName });
-				subCreated.set(nName, nd);
-			} else if (nSpec.type === "producer") {
-				const sourceFactory = factoryName ? resolveSource(factoryName) : undefined;
-				const fnFactory = factoryName ? resolveFn(factoryName) : undefined;
-				if (sourceFactory) {
-					const nd = sourceFactory(factoryArgs);
-					sub.add(nd, { name: nName });
-					subCreated.set(nName, nd);
-				} else if (fnFactory) {
-					const nd = fnFactory([], factoryArgs);
-					sub.add(nd, { name: nName });
-					subCreated.set(nName, nd);
-				} else {
-					if (factoryName) recordMissing(`${name}.${nName}`, "source", factoryName);
-					const nd = node([], () => {}, {
-						name: nName,
-						describeKind: "producer",
-						meta: { ...stripFactoryMeta(nSpec.meta), _specSource: factoryName },
-					});
-					sub.add(nd, { name: nName });
-					subCreated.set(nName, nd);
-				}
-			} else {
-				subDeferred.push([nName, specWithResolvedDeps]);
-			}
-		}
-
-		// Resolve deferred inner nodes
-		let subProgressed = true;
-		const subPending = new Map(subDeferred);
-		while (subPending.size > 0 && subProgressed) {
-			subProgressed = false;
-			for (const [nName, nSpec] of [...subPending.entries()]) {
-				const deps = nSpec.deps ?? [];
-				const allReady = deps.every((dep) => subCreated.has(dep) || created.has(dep));
-				if (!allReady) continue;
-
-				const resolvedDeps = deps.map((dep) => subCreated.get(dep) ?? created.get(dep)!);
-				const factoryName = readFactory(nSpec);
-				const factoryArgs = readFactoryArgs(nSpec);
-				const fnFactory = factoryName ? resolveFn(factoryName) : undefined;
-
-				let nd: Node<unknown>;
-				if (fnFactory) {
-					nd = fnFactory(resolvedDeps, factoryArgs);
-				} else if (nSpec.type === "effect") {
-					if (factoryName) recordMissing(`${name}.${nName}`, "fn", factoryName);
-					nd = node(resolvedDeps, () => {}, { describeKind: "effect" });
-				} else {
-					if (factoryName) recordMissing(`${name}.${nName}`, "fn", factoryName);
-					nd = node(
-						resolvedDeps,
-						(batchData, actions, ctx) => {
-							const data = batchData.map((batch, i) =>
-								batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-							);
-							actions.emit(data[0]);
-						},
-						{ describeKind: "derived" },
-					);
-				}
-				sub.add(nd, { name: nName });
-				subCreated.set(nName, nd);
-				subPending.delete(nName);
-				subProgressed = true;
-			}
-		}
-		if (subPending.size > 0) {
-			const unresolved = [...subPending.keys()].sort().join(", ");
-			throw new Error(
-				`compileSpec: template "${ref.template}" has unresolvable deps: ${unresolved}`,
-			);
-		}
-
-		g.mount(name, sub);
-		// Register template output as a reachable node path
-		const outputPath = `${name}::${tmpl.output}`;
-		created.set(name, g.resolve(outputPath));
-
-		// Store template origin meta on the mounted subgraph's output node
-		// so decompile-style introspection can recover the template name.
-		try {
-			const outputNode = g.resolve(outputPath);
-			outputNode.meta._templateName?.emit(ref.template);
-			outputNode.meta._templateBind?.emit(ref.bind);
-		} catch {
-			/* meta nodes may not exist; template origin is best-effort */
-		}
-	}
-
-	// Edges are derived from node `_deps` (Unit 7) — no explicit edge wiring step.
-
-	// Phase 4: Wire feedback edges via §8.1 feedback()
-	for (const fb of spec.feedback ?? []) {
-		feedbackPrimitive(g, fb.from, fb.to, {
-			maxIterations: fb.maxIterations,
-		});
-	}
-
-	// Apply onMissing policy. We always finish compilation first (for "warn"
-	// + "placeholder") so the caller still gets a usable graph in non-strict
-	// modes. In "error" mode we throw before returning.
-	if (missingEntries.length > 0) {
-		if (onMissing === "error") {
-			const lines = missingEntries.map((e) => `  - ${e.path}: missing ${e.kind} "${e.name}"`);
-			throw new Error(
-				`compileSpec: ${missingEntries.length} catalog entr${
-					missingEntries.length === 1 ? "y" : "ies"
-				} missing — pass them via opts.catalog or set opts.onMissing to "warn"/"placeholder":\n${lines.join("\n")}`,
-			);
-		}
-		if (onMissing === "warn") {
-			const warn = opts?.onWarn ?? ((m: string): void => console.warn(m));
-			for (const e of missingEntries) {
-				warn(
-					`compileSpec: ${e.path} references missing ${e.kind} "${e.name}" — substituted placeholder`,
-				);
-			}
-		}
-	}
-
-	return g;
-}
-
-// ---------------------------------------------------------------------------
-// decompileGraph
-// ---------------------------------------------------------------------------
-
-/** Internal meta keys used by compileSpec/feedback — stripped from output. */
-const INTERNAL_META_KEYS = new Set([
-	"reduction",
-	"reduction_type",
-	"_specFn",
-	"_specSource",
-	"_templateName",
-	"_templateBind",
-	"feedbackFrom",
-	"feedbackTo",
-	"_internal",
-]);
-
-/**
- * Extract a {@link GraphSpec} from a running graph.
- *
- * Tier 1.5.3 Phase 3 (2026-04-27): thin projection over
- * `graph.describe({ detail: "spec" })`. The describe-output already carries
- * structural fields (`type`, `deps`, optional `value`) plus per-node
- * `meta.factory` / `meta.factoryArgs` for tagged factories and top-level
- * `factory` / `factoryArgs` for graph-level tags. The only sugar this helper
- * adds is a feedback-edge recovery scan over `meta.feedbackFrom` /
- * `meta.feedbackTo` companion fields stamped by the §8.1 `feedback()`
- * primitive.
- *
- * **Removed in Phase 3:** template fingerprinting / `_templateName` /
- * `_templateBind` recovery. Mounted subgraphs surface as nested `subname::*`
- * paths in `desc.nodes`; if you need the template-instantiation form, build
- * the spec by hand or read the meta companions directly.
- *
- * @param graph - Running graph to decompile.
- * @returns A GraphSpec representation.
- *
- * @category patterns
- */
-export function decompileSpec(graph: Graph): GraphSpec {
-	const desc = graph.describe({ detail: "spec" }) as GraphDescribeOutput;
-	const metaSegment = `::${GRAPH_META_SEGMENT}::`;
-	const feedbackCounterPattern = /^__feedback_(?!effect_)(.+)$/;
-	const feedbackEdges: GraphSpecFeedbackEdge[] = [];
-
-	// qa D1 — Pre-pass: collect paths whose own node carries `meta.factory`.
-	// These are "factory parents" (e.g. `prompt_node` for the `promptNode`
-	// compound factory). Their `::`-prefixed sibling paths (`prompt_node::messages`,
-	// `prompt_node::output`, etc.) are factory-internal and SHOULD NOT round-trip
-	// as separate spec nodes — `compileSpec` will recreate them when the factory
-	// runs against the parent's `meta.factory` / `meta.factoryArgs` tag. Without
-	// this filter, every compound-factory internal would be emitted as a top-level
-	// spec node, then `compileSpec` would try to re-add them via `g.add(nd, {name})`
-	// alongside the factory's own outputs — duplicate-name failures or split topology.
-	const compoundFactoryPrefixes = new Set<string>();
-	for (const [path, nodeDesc] of Object.entries(desc.nodes)) {
-		const meta = nodeDesc.meta as Record<string, unknown> | undefined;
-		if (meta?.factory != null && !path.includes("::")) {
-			// A12 (QA fix 2026-05-01): skip the `proxy` factoryTag — proxies
-			// are local wrappers around foreign-source Nodes (used by
-			// `pipelineGraph.approvalGate`, `gatedStream`, `stratify` after
-			// the C3 ownership migration). They're regenerated by their
-			// parent factory and don't have their own catalog entry; treating
-			// them as compound-factory roots would cause `compileSpec` to
-			// look up "proxy" as a registered factory name and fail.
-			if (meta.factory === "proxy") continue;
-			compoundFactoryPrefixes.add(path);
-		}
-	}
-
-	// 5.6 (b) — DF1 hard-require (Tier 5, 2026-04-29). Locked: any `::`-path
-	// whose parent prefix exists in the graph but does NOT carry
-	// `meta.factory` is an untagged compound factory. `compileSpec` cannot
-	// reconstruct it, so the spec round-trip would silently break. Fail
-	// loud at decompile time so the offending factory author tags the
-	// parent. Skip well-known internal prefixes that are not factory output
-	// (meta companions, feedback / bridge infrastructure).
-	const allPaths = new Set(Object.keys(desc.nodes));
-	for (const path of allPaths) {
-		const sepIdx = path.indexOf("::");
-		if (sepIdx <= 0) continue;
-		const parent = path.slice(0, sepIdx);
-		// Skip internal infrastructure prefixes (handled below in the main loop).
-		if (path.includes(metaSegment)) continue;
-		if (path.startsWith("__feedback_effect_") || path.startsWith("__bridge_")) continue;
-		// Parent is a tagged compound factory → covered by the existing pre-pass.
-		if (compoundFactoryPrefixes.has(parent)) continue;
-		// Parent doesn't appear in the graph (untagged child path with no
-		// matching parent) — treat as a regular `::`-named node, not a
-		// compound factory. Allowed.
-		if (!allPaths.has(parent)) continue;
-		// Parent IS in the graph but lacks `meta.factory` — untagged compound
-		// factory. Refuse to round-trip.
-		throw new Error(
-			`decompileSpec: untagged compound factory at "${parent}" (child: "${path}"). ` +
-				"Compound factories that ship `parent::child` topology MUST set `meta.factory` " +
-				"on the parent so `compileSpec` can reconstruct the internals via the catalog. " +
-				"Either tag the parent (`{ meta: factoryTag('myFactory', args) }`) OR rename the " +
-				"child to use `/` instead of `::` if it's not a compound-factory internal " +
-				"(see COMPOSITION-GUIDE §38).",
-		);
-	}
-
-	// Build the spec-shaped node map by walking describe's output. Strip
-	// meta-companion paths, bridge / feedback-effect internals, AND compound-
-	// factory `::` internals (per pre-pass above); preserve everything else verbatim.
-	const nodes: Record<string, GraphSpecNode | GraphSpecTemplateRef> = {};
-	for (const [path, nodeDesc] of Object.entries(desc.nodes)) {
-		if (path.includes(metaSegment)) continue;
-
-		// qa D1 — skip compound-factory `::` internals (e.g. `prompt_node::messages`)
-		// when their parent is a tagged factory. The factory recreates them.
-		const sepIdx = path.indexOf("::");
-		if (sepIdx > 0 && compoundFactoryPrefixes.has(path.slice(0, sepIdx))) continue;
-
-		const match = feedbackCounterPattern.exec(path);
-		if (match) {
-			const meta = nodeDesc.meta as Record<string, unknown> | undefined;
-			if (meta?.feedbackFrom && meta?.feedbackTo) {
-				feedbackEdges.push({
-					from: meta.feedbackFrom as string,
-					to: meta.feedbackTo as string,
-					...(meta.maxIterations ? { maxIterations: meta.maxIterations as number } : {}),
-				});
-			}
-			continue;
-		}
-		// Skip internal infrastructure nodes (feedback-effect, bridge).
-		if (nodeDesc.meta?._internal) continue;
-		if (path.startsWith("__feedback_effect_")) continue;
-		if (path.startsWith("__bridge_")) continue;
-
-		// QA F5 carry: strip runtime-state sibling keys for known stateful factory
-		// tags so the spec doesn't carry transient runtime state into round-trips.
-		const meta = nodeDesc.meta as Record<string, unknown> | undefined;
-		let cleanedMeta: Record<string, unknown> | undefined = meta;
-		if (meta && Object.keys(meta).length > 0) {
-			const out: Record<string, unknown> = {};
-			for (const [k, v] of Object.entries(meta)) {
-				if (INTERNAL_META_KEYS.has(k)) continue;
-				out[k] = v;
-			}
-			if (out.factory === "withStatus") {
-				delete out.status;
-				delete out.error;
-			} else if (out.factory === "withBreaker") {
-				delete out.breakerState;
-			} else if (out.factory === "verifiable") {
-				delete out.sourceVersion;
-			}
-			cleanedMeta = Object.keys(out).length > 0 ? out : undefined;
-		}
-
-		const cleaned: GraphSpecNode = { ...nodeDesc };
-		if (cleanedMeta === undefined) delete cleaned.meta;
-		else cleaned.meta = cleanedMeta;
-		nodes[path] = cleaned;
-	}
-
-	const result: GraphSpec = { ...desc, nodes };
-	// `expand` (a closure injected onto live describe outputs) is not part of
-	// the GraphSpec wire shape — it leaks function refs into JSON-stringified
-	// specs. Drop it.
-	delete (result as { expand?: unknown }).expand;
-	if (feedbackEdges.length > 0) result.feedback = feedbackEdges;
-	return result;
-}
-
-// ---------------------------------------------------------------------------
-// specDiff
-// ---------------------------------------------------------------------------
-
-/** A single change in a spec diff. */
-export type SpecDiffEntry = {
-	type: "added" | "removed" | "changed";
-	path: string;
-	detail?: string;
-};
-
-/** Structural diff between two GraphSpecs. */
-export type SpecDiffResult = {
-	entries: SpecDiffEntry[];
-	summary: string;
-};
-
-/**
- * Compute a structural diff between two GraphSpecs.
- *
- * Template-aware: reports "changed template definition" vs "changed
- * instantiation bindings." No runtime needed — pure JSON comparison.
- *
- * @param specA - The "before" spec.
- * @param specB - The "after" spec.
- * @returns Diff entries and a human-readable summary.
- *
- * @category patterns
- */
-export function specDiff(specA: GraphSpec, specB: GraphSpec): SpecDiffResult {
-	const entries: SpecDiffEntry[] = [];
-
-	// Diff name
-	if (specA.name !== specB.name) {
-		entries.push({
-			type: "changed",
-			path: "name",
-			detail: `"${specA.name}" → "${specB.name}"`,
-		});
-	}
-
-	// Diff nodes
-	const nodesA = new Set(Object.keys(specA.nodes));
-	const nodesB = new Set(Object.keys(specB.nodes));
-
-	for (const name of nodesB) {
-		if (!nodesA.has(name)) {
-			const n = specB.nodes[name]!;
-			entries.push({
-				type: "added",
-				path: `nodes.${name}`,
-				detail: `type: ${n.type}`,
-			});
-		}
-	}
-	for (const name of nodesA) {
-		if (!nodesB.has(name)) {
-			entries.push({ type: "removed", path: `nodes.${name}` });
-		}
-	}
-	for (const name of nodesA) {
-		if (!nodesB.has(name)) continue;
-		const a = specA.nodes[name]!;
-		const b = specB.nodes[name]!;
-		if (JSON.stringify(a) !== JSON.stringify(b)) {
-			const details: string[] = [];
-			if (a.type !== b.type) details.push(`type: ${a.type} → ${b.type}`);
-			if (JSON.stringify((a as GraphSpecNode).deps) !== JSON.stringify((b as GraphSpecNode).deps)) {
-				details.push("deps changed");
-			}
-			const aFactory = a.type === "template" ? undefined : readFactory(a as GraphSpecNode);
-			const bFactory = b.type === "template" ? undefined : readFactory(b as GraphSpecNode);
-			if (aFactory !== bFactory) {
-				details.push(`fn: ${aFactory} → ${bFactory}`);
-			}
-			const aArgs = a.type === "template" ? undefined : readFactoryArgs(a as GraphSpecNode);
-			const bArgs = b.type === "template" ? undefined : readFactoryArgs(b as GraphSpecNode);
-			if (JSON.stringify(aArgs) !== JSON.stringify(bArgs)) {
-				details.push("config changed");
-			}
-			entries.push({
-				type: "changed",
-				path: `nodes.${name}`,
-				detail: details.join("; ") || "modified",
-			});
-		}
-	}
-
-	// Diff templates
-	const tmplA = specA.templates ?? {};
-	const tmplB = specB.templates ?? {};
-	const tmplNamesA = new Set(Object.keys(tmplA));
-	const tmplNamesB = new Set(Object.keys(tmplB));
-
-	for (const name of tmplNamesB) {
-		if (!tmplNamesA.has(name)) {
-			entries.push({ type: "added", path: `templates.${name}` });
-		}
-	}
-	for (const name of tmplNamesA) {
-		if (!tmplNamesB.has(name)) {
-			entries.push({ type: "removed", path: `templates.${name}` });
-		}
-	}
-	for (const name of tmplNamesA) {
-		if (!tmplNamesB.has(name)) continue;
-		if (JSON.stringify(tmplA[name]) !== JSON.stringify(tmplB[name])) {
-			entries.push({
-				type: "changed",
-				path: `templates.${name}`,
-				detail: "template definition changed",
-			});
-		}
-	}
-
-	// Diff feedback
-	const fbA = specA.feedback ?? [];
-	const fbB = specB.feedback ?? [];
-	const fbKeyA = new Set(fbA.map((e) => `${e.from}->${e.to}`));
-	const fbKeyB = new Set(fbB.map((e) => `${e.from}->${e.to}`));
-
-	for (const fb of fbB) {
-		const key = `${fb.from}->${fb.to}`;
-		if (!fbKeyA.has(key)) {
-			entries.push({
-				type: "added",
-				path: `feedback.${key}`,
-				detail: `maxIterations: ${fb.maxIterations ?? 10}`,
-			});
-		}
-	}
-	for (const fb of fbA) {
-		const key = `${fb.from}->${fb.to}`;
-		if (!fbKeyB.has(key)) {
-			entries.push({ type: "removed", path: `feedback.${key}` });
-		}
-	}
-	for (const fb of fbA) {
-		const key = `${fb.from}->${fb.to}`;
-		const counterpart = fbB.find((b) => b.from === fb.from && b.to === fb.to);
-		if (counterpart && JSON.stringify(fb) !== JSON.stringify(counterpart)) {
-			entries.push({
-				type: "changed",
-				path: `feedback.${key}`,
-				detail: `maxIterations: ${fb.maxIterations ?? 10} → ${counterpart.maxIterations ?? 10}`,
-			});
-		}
-	}
-
-	// Build summary
-	const added = entries.filter((e) => e.type === "added").length;
-	const removed = entries.filter((e) => e.type === "removed").length;
-	const changed = entries.filter((e) => e.type === "changed").length;
-	const parts: string[] = [];
-	if (added) parts.push(`${added} added`);
-	if (removed) parts.push(`${removed} removed`);
-	if (changed) parts.push(`${changed} changed`);
-	const summary = parts.length > 0 ? parts.join(", ") : "no changes";
-
-	return { entries, summary };
-}
-
-// ---------------------------------------------------------------------------
-// llmCompose
-// ---------------------------------------------------------------------------
-
-/** Options for {@link llmCompose}. */
-export type LLMComposeOptions = {
-	model?: string;
-	temperature?: number;
-	maxTokens?: number;
-	/** Extra instructions appended to the system prompt. */
-	systemPromptExtra?: string;
-	/**
-	 * Available fn/source catalog names for the LLM to reference.
-	 * When omitted and `catalog` contains rich {@link CatalogFnEntry} entries,
-	 * the prompt is auto-generated via {@link generateCatalogPrompt}.
-	 */
-	catalogDescription?: string;
-	/**
-	 * Catalog for auto-prompt generation and catalog-aware validation.
-	 * When rich entries are provided, the catalog prompt is auto-generated
-	 * and LLM output is validated against fn/source names and config schemas.
-	 */
-	catalog?: GraphSpecCatalog;
-	/**
-	 * Max auto-refine attempts when the LLM output fails catalog validation.
-	 * Each attempt feeds the validation errors back to the LLM via llmRefine.
-	 * Default: 0 (no auto-refine). Set to 2-3 for production use.
-	 */
-	maxAutoRefine?: number;
-};
-
-const LLM_COMPOSE_SYSTEM_PROMPT = `You are a graph architect for GraphReFly, a reactive graph protocol.
-
-Given a natural-language description, produce a JSON GraphSpec with this structure:
-
-{
-  "name": "<graph_name>",
-  "nodes": {
-    "<node_name>": {
-      "type": "state" | "derived" | "producer" | "effect",
-      "deps": ["<dep_node_name>", ...],
-      "value": <initial_value>,
-      "meta": {
-        "factory": "<catalog_factory_name>",
-        "factoryArgs": { ... },
-        "description": "<purpose>"
-      }
-    },
-    "<template_instance>": {
-      "type": "template",
-      "template": "<template_name>",
-      "bind": { "$param": "node_name" }
-    }
-  },
-  "templates": {
-    "<template_name>": {
-      "params": ["$param1", "$param2"],
-      "nodes": { ... },
-      "output": "<output_node>"
-    }
-  },
-  "feedback": [
-    { "from": "<condition_node>", "to": "<state_node>", "maxIterations": 10 }
-  ]
-}
-
-Rules:
-- "state" nodes hold user/LLM-writable values (knobs). Stamp the initial value
-  in "meta.factoryArgs.initial" (or as the top-level "value" field — both work).
-- "derived" nodes compute from deps using a catalog function named in
-  "meta.factory"; pass any config via "meta.factoryArgs".
-- "effect" nodes produce side effects from deps; same meta.factory shape as derived.
-- "producer" nodes generate values from a catalog source named in "meta.factory";
-  pass any config via "meta.factoryArgs".
-- Use "templates" when the same subgraph pattern repeats (e.g., per-source resilience).
-- Use "feedback" for bounded cycles where a derived value writes back to a state node.
-- meta.description is required for every node.
-- Return ONLY valid JSON, no markdown fences or commentary.`;
-
-/** Strip markdown code fences. */
-function stripFences(text: string): string {
-	const match = text.match(/^```(?:json)?\s*([\s\S]*?)\s*```[\s\S]*$/);
-	return match ? match[1]! : text;
-}
-
-/**
- * Ask an LLM to compose a GraphSpec from a natural-language problem description.
- *
- * The LLM generates a GraphSpec (with templates + feedback), validated before
- * returning. The spec is for human review before compilation via compileSpec().
- *
- * @param problem - Natural language problem description.
- * @param adapter - LLM adapter for the generation call.
- * @param opts - Model options and catalog description.
- * @returns A validated GraphSpec.
- * @throws On invalid LLM output or validation failure.
- *
- * @category patterns
- */
-export async function llmCompose(
-	problem: string,
-	adapter: LLMAdapter,
-	opts?: LLMComposeOptions,
-): Promise<GraphSpec> {
-	let systemPrompt = LLM_COMPOSE_SYSTEM_PROMPT;
-
-	// Auto-generate catalog prompt from rich entries, or use manual description
-	const catalogPrompt =
-		opts?.catalogDescription ?? (opts?.catalog ? generateCatalogPrompt(opts.catalog) : undefined);
-	if (catalogPrompt) {
-		systemPrompt += `\n\nAvailable catalog (use ONLY these names):\n${catalogPrompt}`;
-	}
-	if (opts?.systemPromptExtra) {
-		systemPrompt += `\n\n${opts.systemPromptExtra}`;
-	}
-
-	const messages: ChatMessage[] = [
-		{ role: "system", content: systemPrompt },
-		{ role: "user", content: problem },
-	];
-
-	const rawResult = adapter.invoke(messages, {
-		model: opts?.model,
-		temperature: opts?.temperature ?? 0,
-		maxTokens: opts?.maxTokens,
-	});
-
-	// System boundary: await the adapter's response (Promise, plain value).
-	const response = (await rawResult) as LLMResponse;
-	let content = response.content.trim();
-
-	if (content.startsWith("```")) {
-		content = stripFences(content);
-	}
-
-	let parsed: unknown;
-	try {
-		parsed = JSON.parse(content);
-	} catch {
-		throw new Error(`llmCompose: LLM response is not valid JSON: ${content.slice(0, 200)}`);
-	}
-
-	const validation = validateSpec(parsed);
-	if (!validation.valid) {
-		throw new Error(`llmCompose: invalid GraphSpec:\n${validation.errors.join("\n")}`);
-	}
-
-	let spec = parsed as GraphSpec;
-
-	// Catalog-aware validation + auto-refine loop
-	if (opts?.catalog) {
-		const maxRefine = opts.maxAutoRefine ?? 0;
-		for (let attempt = 0; attempt <= maxRefine; attempt++) {
-			const catalogValidation = validateSpecAgainstCatalog(spec, opts.catalog);
-			if (catalogValidation.valid) break;
-
-			if (attempt === maxRefine) {
-				// Last attempt failed — return with errors attached as meta
-				throw new Error(
-					`llmCompose: catalog validation failed after ${maxRefine} refine attempts:\n${catalogValidation.errors.join("\n")}`,
-				);
-			}
-
-			// Auto-refine: feed catalog errors back to LLM
-			spec = await llmRefine(
-				spec,
-				`Fix these catalog errors:\n${catalogValidation.errors.join("\n")}\n\nUse ONLY functions and sources from the catalog.`,
-				adapter,
-				{ ...opts, catalogDescription: catalogPrompt },
-			);
-		}
-	}
-
-	return spec;
-}
-
-// ---------------------------------------------------------------------------
-// llmRefine
-// ---------------------------------------------------------------------------
-
-/** Options for {@link llmRefine}. */
-export type LLMRefineOptions = LLMComposeOptions;
-
-/**
- * Ask an LLM to modify an existing GraphSpec based on feedback or changed requirements.
- *
- * @param currentSpec - The current GraphSpec to modify.
- * @param feedback - Natural language feedback or changed requirements.
- * @param adapter - LLM adapter for the generation call.
- * @param opts - Model options.
- * @returns A new GraphSpec incorporating the feedback.
- * @throws On invalid LLM output or validation failure.
- *
- * @category patterns
- */
-export async function llmRefine(
-	currentSpec: GraphSpec,
-	feedback: string,
-	adapter: LLMAdapter,
-	opts?: LLMRefineOptions,
-): Promise<GraphSpec> {
-	let systemPrompt = LLM_COMPOSE_SYSTEM_PROMPT;
-	if (opts?.catalogDescription) {
-		systemPrompt += `\n\nAvailable catalog:\n${opts.catalogDescription}`;
-	}
-	if (opts?.systemPromptExtra) {
-		systemPrompt += `\n\n${opts.systemPromptExtra}`;
-	}
-
-	const messages: ChatMessage[] = [
-		{ role: "system", content: systemPrompt },
-		{
-			role: "user",
-			content: `Current GraphSpec:\n${JSON.stringify(currentSpec, null, 2)}\n\nModification request: ${feedback}\n\nReturn the complete modified GraphSpec as JSON.`,
-		},
-	];
-
-	const rawResult = adapter.invoke(messages, {
-		model: opts?.model,
-		temperature: opts?.temperature ?? 0,
-		maxTokens: opts?.maxTokens,
-	});
-
-	// System boundary: await the adapter's response.
-	const response = (await rawResult) as LLMResponse;
-	let content = response.content.trim();
-
-	if (content.startsWith("```")) {
-		content = stripFences(content);
-	}
-
-	let parsed: unknown;
-	try {
-		parsed = JSON.parse(content);
-	} catch {
-		throw new Error(`llmRefine: LLM response is not valid JSON: ${content.slice(0, 200)}`);
-	}
-
-	const validation = validateSpec(parsed);
-	if (!validation.valid) {
-		throw new Error(`llmRefine: invalid GraphSpec:\n${validation.errors.join("\n")}`);
-	}
-
-	return parsed as GraphSpec;
-}
diff --git a/src/utils/harness/_internal.ts b/src/utils/harness/_internal.ts
deleted file mode 100644
index 3828fc0c..00000000
--- a/src/utils/harness/_internal.ts
+++ /dev/null
@@ -1,42 +0,0 @@
-/**
- * Harness-domain internal helpers.
- *
- * trackingKey extracted from patterns/_internal/index.ts during cleave A2.
- * Destination decided per STOP #1 resolution: harness-domain shape,
- * used only by utils/harness/types.ts and presets/harness/harness-loop.ts.
- */
-
-// trackingKey
-// ---------------------------------------------------------------------------
-
-/**
- * Stable tracking key for an item with retry/reingestion decoration.
- *
- * Uses `relatedTo[0]` if present (carries the original key forward through
- * retries and reingestions). Falls back to `summary` for first-time items.
- *
- * This avoids deriving keys from mutated summary strings — retries decorate
- * the summary with `[RETRY N/M]` and failure context, so regex-stripping
- * would be fragile and any new decoration pattern would risk infinite loops
- * by generating novel keys.
- *
- * **Caller contract — uniqueness (qa D1, 2026-04-29).** Two distinct intake
- * items sharing the same `summary` (and neither carrying `relatedTo`)
- * produce the SAME tracking key. The harness's `routeJobIds` map is keyed
- * by this value: a duplicate-key publish overwrites the prior mapping, and
- * a later `ackJob` for the original publish acks the wrong audit job.
- * Single-threaded JS makes the typical structural-failure path safe (the
- * ack runs before reingest publishes), but multi-publisher concurrency or
- * batched intake of two items with identical summaries can race.
- *
- * **Caller responsibility:** ensure `summary` uniqueness OR carry an
- * explicit stable id via `relatedTo[0]` for items that may collide. For
- * retry/reingestion paths the `relatedTo` array MUST start with the
- * original tracking key — `[originalKey, ...]` — so the carried-forward
- * identity matches the audit log entry created at first publish.
- *
- * @internal
- */
-export function trackingKey(item: { summary: string; relatedTo?: string[] }): string {
-	return item.relatedTo?.[0] ?? item.summary;
-}
diff --git a/src/utils/harness/actuator-executor.ts b/src/utils/harness/actuator-executor.ts
deleted file mode 100644
index e5dc0441..00000000
--- a/src/utils/harness/actuator-executor.ts
+++ /dev/null
@@ -1,282 +0,0 @@
-/**
- * actuatorExecutor — bridge a side-effecting actuator into the harness
- * EXECUTE work fn.
- *
- * `refineExecutor` covers the artifact-typed case (refine a candidate
- * `T` against an evaluator); `actuatorExecutor` covers the side-effecting
- * case (write a catalog entry, mutate a template registry, edit a doc on
- * disk). The user's `apply` callback owns the side effect; the executor
- * wraps it in the per-claim lifecycle:
- *
- * 1. **One DATA per claim.** The producer captures the first DATA from
- *    the bridged `apply` result, emits a {@link HarnessJobPayload} with
- *    `execution` filled in, and completes. Subsequent inner DATAs are
- *    ignored.
- * 2. **Cancel-on-teardown.** When the JobFlow pump unsubscribes (after
- *    capturing first DATA, or on graph teardown), the producer's cleanup
- *    fires `ac.abort()` which propagates into `apply`'s `signal`.
- * 3. **Errors surfaced as failure payload.** A thrown / ERROR result is
- *    mapped via `onError` into a `failure`-outcome `ExecuteOutput` so the
- *    dispatch effect can route the item rather than silently dropping it.
- *
- * **What `apply` may return.** Anything `fromAny` accepts: `Promise<R>`,
- * `Node<R>`, `AsyncIterable<R>`, `Iterable<R>`, or a synchronous `R`.
- * `Promise<R>` is the typical shape (`writeFile`, `fetch`, `db.execute`).
- *
- * **Pairing with `evalVerifier`.** `ExecuteOutput.artifact` is set to
- * the actuation record; an `evalVerifier<R>` whose `extractArtifact`
- * returns the record (or the post-apply world state) closes EXECUTE →
- * VERIFY with consistent typing end-to-end.
- *
- * @module
- */
-
-import { COMPLETE, DATA, ERROR, type Messages, type Node, node } from "@graphrefly/pure-ts/core";
-import { fromAny, type NodeInput } from "@graphrefly/pure-ts/extra";
-import type { JobEnvelope } from "../job-queue/index.js";
-
-import type { ExecuteOutput, HarnessExecutor, HarnessJobPayload, TriagedItem } from "./types.js";
-
-/**
- * What an actuator's `apply` may return. Mirrors `NodeInput<R>` plus a
- * raw `R` for synchronous side effects.
- */
-export type ActuatorResult<R> = NodeInput<R>;
-
-/** Configuration for {@link actuatorExecutor}. */
-export interface ActuatorExecutorConfig<R> {
-	/**
-	 * Apply the side effect for this triaged item. Receives the abort
-	 * signal — actuators that own real I/O should thread `signal` into
-	 * `fetch`, `fs.writeFile`, child-process kills, etc. so that the
-	 * pump's teardown actually cancels in-flight work.
-	 *
-	 * The first DATA emitted by the bridged result wins; later DATAs are
-	 * discarded. ERROR (or a synchronous throw) is mapped via `onError`.
-	 */
-	apply: (item: TriagedItem, opts: { signal: AbortSignal }) => ActuatorResult<R>;
-
-	/**
-	 * Optional gate — when provided and returning `false`, the actuator
-	 * is skipped and the executor emits an `ExecuteOutput` with
-	 * `outcome: "failure"`. Use to route interventions the actuator can't
-	 * handle into the failure path.
-	 */
-	shouldApply?: (item: TriagedItem) => boolean;
-
-	/** Detail string for the skip path. Default: includes intervention name. */
-	skipDetail?: (item: TriagedItem) => string;
-
-	/**
-	 * Map a successfully-applied actuation record into an `ExecuteOutput<R>`.
-	 */
-	toOutput?: (record: R, item: TriagedItem) => ExecuteOutput<R>;
-
-	/**
-	 * Map a thrown / ERROR result into an `ExecuteOutput<R>`.
-	 */
-	onError?: (err: unknown, item: TriagedItem) => ExecuteOutput<R>;
-
-	/** Node name prefix for `describe()` introspection. */
-	name?: string;
-}
-
-function defaultToOutput<R>(record: R, item: TriagedItem): ExecuteOutput<R> {
-	return {
-		outcome: "success",
-		detail: `actuator applied ${item.intervention} for ${truncate(item.summary)}`,
-		artifact: record,
-	};
-}
-
-function defaultOnError<R>(err: unknown, item: TriagedItem): ExecuteOutput<R> {
-	const message = err instanceof Error ? err.message : String(err);
-	return {
-		outcome: "failure",
-		detail: `actuator threw on ${item.intervention}: ${message}`,
-	};
-}
-
-function defaultSkipDetail(item: TriagedItem): string {
-	return `actuator skipped ${item.intervention} (shouldApply returned false)`;
-}
-
-function truncate(s: string, max = 80): string {
-	return s.length <= max ? s : `${s.slice(0, max - 1)}…`;
-}
-
-/**
- * Build a {@link HarnessExecutor} backed by a side-effecting actuator.
- *
- * @example File-system actuator that writes a catalog entry and emits the diff.
- * ```ts
- * const harness = harnessLoop("repair", {
- *   adapter,
- *   executor: actuatorExecutor<CatalogPatch>({
- *     async apply(item, { signal }) {
- *       const patch = patchFromItem(item);
- *       await fs.writeFile(patch.path, patch.contents, { signal });
- *       return patch;
- *     },
- *     shouldApply: (item) => item.intervention === "catalog-fn",
- *   }),
- *   verifier: evalVerifier<CatalogPatch>({ ... }),
- * });
- * ```
- */
-export function actuatorExecutor<R>(config: ActuatorExecutorConfig<R>): HarnessExecutor<R> {
-	const name = config.name ?? "actuator-executor";
-	const toOutput = config.toOutput ?? defaultToOutput<R>;
-	const onError = config.onError ?? defaultOnError<R>;
-	const skipDetail = config.skipDetail ?? defaultSkipDetail;
-
-	return (job: JobEnvelope<HarnessJobPayload<R>>, opts) => {
-		const item = job.payload.item;
-
-		if (config.shouldApply && !config.shouldApply(item)) {
-			// Synchronous failure payload — return as a plain object;
-			// `fromAny` accepts the bare value and emits one DATA.
-			return {
-				...job.payload,
-				execution: { item, outcome: "failure", detail: skipDetail(item) },
-			} satisfies HarnessJobPayload<R>;
-		}
-
-		return node<HarnessJobPayload<R>>(
-			[],
-			(_data, actions) => {
-				const ac = new AbortController();
-				// Link pump-supplied signal (Tier 6.5 2.5b): parent abort
-				// (e.g. `harness.destroy()`) cascades into the inner AC and
-				// thus into `apply(item, { signal })` + `fromAny({ signal })`.
-				const parentSignal = opts?.signal;
-				let unlinkParent: () => void = () => undefined;
-				if (parentSignal) {
-					if (parentSignal.aborted) {
-						ac.abort();
-					} else {
-						const onParentAbort = (): void => ac.abort();
-						parentSignal.addEventListener("abort", onParentAbort, { once: true });
-						unlinkParent = () => parentSignal.removeEventListener("abort", onParentAbort);
-					}
-				}
-				let captured = false;
-				let unsub: (() => void) | null = null;
-				const emitOnce = (out: ExecuteOutput<R>): void => {
-					if (captured) return;
-					captured = true;
-					actions.down([
-						[DATA, { ...job.payload, execution: { item, ...out } }],
-						[COMPLETE],
-					] satisfies Messages);
-					unsub?.();
-					unsub = null;
-				};
-				let inner: Node<R>;
-				try {
-					const rawResult = config.apply(item, { signal: ac.signal });
-					inner = fromAny<R>(rawResult, { signal: ac.signal });
-				} catch (err) {
-					emitOnce(onError(err, item));
-					return {
-						onDeactivation: () => {
-							unlinkParent();
-							ac.abort();
-						},
-					};
-				}
-				unsub = inner.subscribe((batch) => {
-					for (const m of batch) {
-						if (captured) return;
-						if (m[0] === DATA) {
-							emitOnce(toOutput(m[1] as R, item));
-							return;
-						}
-						if (m[0] === ERROR) {
-							emitOnce(onError(m[1], item));
-							return;
-						}
-						if (m[0] === COMPLETE) {
-							emitOnce(onError(new Error("actuator inner completed without emitting DATA"), item));
-							return;
-						}
-					}
-				});
-				// Sync DATA delivery (cached state / `fromAny` over a sync value):
-				// the callback ran reentrantly before `unsub` was assigned, so
-				// `emitOnce`'s `unsub?.()` was a no-op. Drop the upstream subscription
-				// now that we have the handle. Without this, the inner stays
-				// subscribed until producer teardown — leaks at high volume.
-				if (captured && unsub) {
-					unsub();
-					unsub = null;
-				}
-				return {
-					onDeactivation: () => {
-						unlinkParent();
-						ac.abort();
-						unsub?.();
-						unsub = null;
-					},
-				};
-			},
-			{ name: `${name}/inner`, describeKind: "producer" },
-		);
-	};
-}
-
-// ---------------------------------------------------------------------------
-// dispatchActuator
-// ---------------------------------------------------------------------------
-
-/**
- * Apply callback shape consumed by {@link dispatchActuator}. Same shape as
- * {@link ActuatorExecutorConfig.apply}.
- */
-export type ActuatorApplyFn<R> = (
-	item: TriagedItem,
-	opts: { signal: AbortSignal },
-) => ActuatorResult<R>;
-
-/** Configuration for {@link dispatchActuator}. */
-export interface DispatchActuatorConfig<R> {
-	/**
-	 * Per-intervention apply callbacks. Keyed by `TriagedItem.intervention`.
-	 * Items whose intervention is not in `routes` fall through to `default`
-	 * (when set) or emit a skip-failure `ExecuteOutput`.
-	 */
-	routes: Readonly<Partial<Record<TriagedItem["intervention"], ActuatorApplyFn<R>>>>;
-	/** Fallback apply callback for items whose intervention is not in `routes`. */
-	default?: ActuatorApplyFn<R>;
-	/** Node name prefix for `describe()` introspection. */
-	name?: string;
-}
-
-/**
- * Multi-intervention actuator — dispatches each `TriagedItem` to one of
- * several `apply` callbacks based on `item.intervention`.
- *
- * Internally builds a single `actuatorExecutor` whose `apply` resolves the
- * intervention → callback at call-time. Items with no matching route and no
- * `default` emit a skip-failure with detail
- * `"no route for intervention 'X'"`.
- */
-export function dispatchActuator<R>(config: DispatchActuatorConfig<R>): HarnessExecutor<R> {
-	const name = config.name ?? "dispatch-actuator";
-	const defaultFn = config.default ?? null;
-	const hasDefault = defaultFn != null;
-	return actuatorExecutor<R>({
-		apply: (item, opts) => {
-			const fn = Object.hasOwn(config.routes, item.intervention)
-				? config.routes[item.intervention]!
-				: defaultFn;
-			if (!fn) {
-				throw new Error(`dispatchActuator: no route for intervention '${item.intervention}'`);
-			}
-			return fn(item, opts);
-		},
-		shouldApply: (item) => Object.hasOwn(config.routes, item.intervention) || hasDefault,
-		skipDetail: (item) => `no route for intervention '${item.intervention}'`,
-		name,
-	});
-}
diff --git a/src/utils/harness/auto-solidify.ts b/src/utils/harness/auto-solidify.ts
deleted file mode 100644
index 04c33e5d..00000000
--- a/src/utils/harness/auto-solidify.ts
+++ /dev/null
@@ -1,194 +0,0 @@
-/**
- * autoSolidify — promote successful VERIFY runs into a durable artifact
- * (catalog entry, skill, template, doc edit, …).
- *
- * Closes the dogfood retrospective loop: when the harness's VERIFY
- * stage reports `verified: true`, the validated intervention should
- * become an authoring artifact the next loop run can rely on. This
- * primitive is the generic substrate — pass a `write` callback that
- * does the actual promotion (e.g. `overlay.upsertTemplate` for the
- * dogfood catalog overlay; `fs.writeFile` for a doc edit; `ctx.skill`
- * for a Hermes-style skill registry).
- *
- * @example Wire the catalog overlay as the solidify target.
- * ```ts
- * const solidified = autoSolidify({
- *   verifyResults: harness.verifyResults.latest,
- *   extract: (vr) => vr.execution.artifact ?? null,
- *   write: (entry, vr) => overlay.upsertFn(`learned-${vr.item.summary}`, entry),
- * });
- * solidified.subscribe(() => {}); // keep alive for log
- * ```
- *
- * **Why a node and not just an effect.** The returned `Node<R>` emits
- * each promoted artifact, so callers can pipe solidifications through
- * the standard reactive surface (`describe()`, `observe()`, replay
- * buffers) instead of side-channel logging. An audit / dashboard that
- * wants "what was learned this run?" subscribes to the returned node;
- * the `write` callback owns the durable side effect.
- *
- * **Idempotency is the caller's responsibility.** The primitive
- * promotes every `verified: true` wave that passes the predicate. If
- * the harness re-verifies the same item (e.g. via reingestion), the
- * `write` callback is invoked again. Wrap your write fn with a
- * dedup-by-key guard if your target store would otherwise bloat. The
- * inner `seen` set inside this factory is intentionally absent — the
- * harness already retains via topic logs and the user may want
- * re-promotion semantics that are domain-specific.
- *
- * @module
- */
-
-import { COMPLETE, DATA, ERROR, type Messages, type Node, node } from "@graphrefly/pure-ts/core";
-
-import type { VerifyResult } from "./types.js";
-
-/**
- * Configuration for {@link autoSolidify}.
- *
- * `R` is the artifact type the upstream EXECUTE stage produced (and
- * `evalVerifier` carries through `execution.artifact`). `T` is the
- * promotion shape — what `write` consumes and what the returned node
- * emits. Often `T = R`, but they diverge when the actuator's raw
- * artifact needs a transform before storing (e.g. wrap a `CatalogPatch`
- * into a `CatalogEntry` with effectiveness metadata).
- */
-export interface AutoSolidifyConfig<R, T = R> {
-	/** Reactive verify-result stream. Typically `harness.verifyResults.latest`. */
-	verifyResults: Node<VerifyResult<R> | null>;
-	/**
-	 * Pull the value-to-promote out of a verified VerifyResult.
-	 * Default: `(vr) => vr.execution.artifact as T | null`. Return `null`
-	 * to skip a particular VerifyResult even when `verified: true` (e.g.
-	 * an LLM-default executor produces no artifact and there's nothing to
-	 * solidify).
-	 */
-	extract?: (vr: VerifyResult<R>) => T | null;
-	/**
-	 * Optional gate beyond `verified === true`. When provided, the
-	 * primitive only promotes when this returns `true`. Default: pass
-	 * everything verified.
-	 *
-	 * Useful predicates:
-	 *  - `(vr) => vr.item.intervention === "catalog-fn"` — only catalog work.
-	 *  - `(vr) => (vr.findings ?? []).every(f => !/regression/i.test(f))` —
-	 *    skip even-passes that mention regressions.
-	 */
-	predicate?: (vr: VerifyResult<R>) => boolean;
-	/**
-	 * Promote — usually a side effect (write to overlay, fs, KG, etc.).
-	 * Receives the extracted artifact AND the originating VerifyResult so
-	 * the writer can use any context it needs (item summary, eval task
-	 * IDs, finding text, …) when shaping the durable record.
-	 */
-	write: (artifact: T, vr: VerifyResult<R>) => void;
-	/** Node name for `describe()` introspection. Default `"auto-solidify"`. */
-	name?: string;
-}
-
-/**
- * Build a `Node<T>` that subscribes to `verifyResults`, filters to
- * verified passes that produced an extractable artifact, runs `write`,
- * and emits the artifact. Use the returned node as a subscription
- * point for audit / dashboard / log pipelines.
- *
- * **Terminal-on-error semantics.** A throw from `predicate`, `extract`,
- * or `write` surfaces as `[[ERROR]]` on the returned node and
- * **terminates** it — the upstream subscription tears down and no
- * further DATA is emitted. This matches the spec's terminal-frame
- * contract for ERROR. If you want the solidify node to stay live
- * across user-callback throws, wrap your callbacks with try/catch
- * internally and emit a sentinel value or no-op on failure. A future
- * non-terminal `errors: Node<unknown>` companion may surface failures
- * without terminating the success stream — flagged as a follow-up.
- *
- * @returns A `Node<T>` that emits one DATA per promoted artifact.
- *   Stays live as long as `verifyResults` is live AND no user callback
- *   has thrown.
- */
-export function autoSolidify<R, T = R>(config: AutoSolidifyConfig<R, T>): Node<T> {
-	const name = config.name ?? "auto-solidify";
-	const extract =
-		config.extract ?? ((vr: VerifyResult<R>) => (vr.execution.artifact ?? null) as T | null);
-	const predicate = config.predicate ?? (() => true);
-
-	return node<T>(
-		[],
-		(_data, actions) => {
-			let unsub: (() => void) | null = null;
-			let terminated = false;
-			const tearDown = (): void => {
-				if (terminated) return;
-				terminated = true;
-				unsub?.();
-				unsub = null;
-			};
-			const emitTerminalError = (err: unknown): void => {
-				if (terminated) return;
-				actions.down([[ERROR, err]] satisfies Messages);
-				tearDown();
-			};
-			unsub = config.verifyResults.subscribe((batch) => {
-				if (terminated) return;
-				for (const m of batch) {
-					if (terminated) return;
-					if (m[0] !== DATA) {
-						if (m[0] === COMPLETE) {
-							// Upstream verifyResults completed (rare; harness destroy).
-							// Forward COMPLETE and tear down — solidify is terminal too.
-							actions.down([[COMPLETE]] satisfies Messages);
-							tearDown();
-							return;
-						}
-						continue;
-					}
-					const vr = m[1] as VerifyResult<R> | null;
-					if (vr == null) continue;
-					if (!vr.verified) continue;
-					// User callbacks (predicate / extract / write) are isolated
-					// in try/catch so a throw lands as a single terminal ERROR
-					// rather than propagating into the upstream emitter where
-					// it would skip later messages in the same batch and leave
-					// the solidify node un-terminated.
-					let pass: boolean;
-					try {
-						pass = predicate(vr);
-					} catch (err) {
-						emitTerminalError(err);
-						return;
-					}
-					if (!pass) continue;
-					let artifact: T | null;
-					try {
-						artifact = extract(vr);
-					} catch (err) {
-						emitTerminalError(err);
-						return;
-					}
-					if (artifact == null) continue;
-					try {
-						config.write(artifact, vr);
-					} catch (err) {
-						emitTerminalError(err);
-						return;
-					}
-					actions.down([[DATA, artifact]] satisfies Messages);
-				}
-			});
-			// If `subscribe` fired terminally during the call (push-on-subscribe
-			// of an already-COMPLETE upstream), `tearDown()` ran inside the
-			// callback before `unsub` was assigned, so the unsub is still
-			// dangling. Drop it now if we're already terminated.
-			if (terminated && unsub) {
-				unsub();
-				unsub = null;
-			}
-			return {
-				onDeactivation: () => {
-					tearDown();
-				},
-			};
-		},
-		{ name, describeKind: "producer" },
-	);
-}
diff --git a/src/utils/harness/bridge.ts b/src/utils/harness/bridge.ts
deleted file mode 100644
index 7a135468..00000000
--- a/src/utils/harness/bridge.ts
+++ /dev/null
@@ -1,565 +0,0 @@
-/**
- * Harness bridge factories (roadmap §9.0).
- *
- * Intake bridges, eval source wrapper, before/after comparison,
- * affected-task filter, code-change bridge, and notification effect.
- * All are compositions of existing primitives — no new abstractions.
- *
- * @module
- */
-
-import { type Node, node } from "@graphrefly/pure-ts/core";
-import { fromAny, switchMap } from "@graphrefly/pure-ts/extra";
-import type { Graph } from "@graphrefly/pure-ts/graph";
-import type { TopicGraph } from "../messaging/index.js";
-
-import type { IntakeItem, Severity, TriagedItem } from "./types.js";
-
-// ---------------------------------------------------------------------------
-// Generic intake bridge
-// ---------------------------------------------------------------------------
-
-/** Options for {@link createIntakeBridge}. */
-export interface CreateIntakeBridgeOptions<T> {
-	/** Graph to register the effect node on (B.1 narrow-waist visibility). */
-	graph: Graph;
-	/** Reactive node emitting domain-specific data. */
-	source: Node<T>;
-	/** TopicGraph to publish IntakeItem entries to. */
-	intakeTopic: TopicGraph<IntakeItem>;
-	/** Converts source data into IntakeItem[]. Return empty array to skip. */
-	parser: (value: T) => IntakeItem[];
-	/** Effect-node name (default `"intake-bridge"`). */
-	name?: string;
-}
-
-/**
- * Generic source→intake bridge factory.
- *
- * Watches a source node for new values, passes each through a user-supplied
- * `parser` that produces zero or more `IntakeItem`s, and publishes them to
- * the given intake topic.
- *
- * This is the generalized pattern behind {@link evalIntakeBridge}. Use it for
- * CI results, test failures, Slack messages, monitoring alerts, or any domain
- * where structured results should flow into a harness loop.
- *
- * The effect node is registered on the supplied `graph` so it appears in
- * `describe()` and is owned by the graph's lifecycle.
- *
- * @returns The effect node (for lifecycle management).
- */
-export function createIntakeBridge<T>(opts: CreateIntakeBridgeOptions<T>): Node<unknown> {
-	const { graph, source, intakeTopic, parser, name = "intake-bridge" } = opts;
-	const eff = node(
-		[source as Node<unknown>],
-		(batchData, _actions, ctx) => {
-			const data = batchData.map((batch, i) =>
-				batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-			);
-			const value = data[0];
-			if (value === undefined) return;
-			const items = parser(value as T);
-			for (const item of items) {
-				intakeTopic.publish(item);
-			}
-		},
-		{ describeKind: "effect" },
-	);
-	graph.add(eff, { name });
-	return eff;
-}
-
-// ---------------------------------------------------------------------------
-// Generic eval result shape
-// ---------------------------------------------------------------------------
-
-/**
- * Minimal eval result shape accepted by the bridge.
- *
- * TS eval runner uses `EvalRun` from `evals/lib/types.ts` which is a superset
- * of this shape. The bridge only reads what it needs.
- */
-export interface EvalRunResult {
-	run_id: string;
-	model: string;
-	tasks: EvalTaskResult[];
-}
-
-export interface EvalTaskResult {
-	task_id: string;
-	valid: boolean;
-	judge_scores?: EvalJudgeScore[];
-}
-
-export interface EvalJudgeScore {
-	claim: string;
-	pass: boolean;
-	reasoning: string;
-}
-
-// ---------------------------------------------------------------------------
-// Bridge factory
-// ---------------------------------------------------------------------------
-
-export interface EvalIntakeBridgeOptions {
-	/** Graph to register the effect node on (B.1 narrow-waist visibility). */
-	graph: Graph;
-	/** Node emitting EvalRunResult (or EvalRunResult[]). */
-	source: Node<EvalRunResult | EvalRunResult[]>;
-	/** TopicGraph to publish IntakeItem entries to. */
-	intakeTopic: TopicGraph<IntakeItem>;
-	/** Effect-node name (default `"eval-intake-bridge"`). */
-	name?: string;
-	/** Minimum severity for eval-sourced items (default `"medium"`). */
-	defaultSeverity?: Severity;
-}
-
-/**
- * Create an effect node that watches an eval results source and publishes
- * per-criterion findings to an intake topic.
- *
- * Each failing judge criterion produces a separate IntakeItem — not one
- * item per task. This gives the triage stage granular findings to classify.
- *
- * The effect node is registered on the supplied `graph` so it appears in
- * `describe()` and is owned by the graph's lifecycle.
- *
- * @returns The effect node (for lifecycle management).
- */
-export function evalIntakeBridge(opts: EvalIntakeBridgeOptions): Node<unknown> {
-	const {
-		graph,
-		source,
-		intakeTopic,
-		name = "eval-intake-bridge",
-		defaultSeverity = "medium",
-	} = opts;
-
-	const eff = node(
-		[source as Node<unknown>],
-		(batchData, _actions, ctx) => {
-			const data = batchData.map((batch, i) =>
-				batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-			);
-			const results = data[0];
-			if (results === undefined) return;
-			const runs = Array.isArray(results)
-				? (results as EvalRunResult[])
-				: [results as EvalRunResult];
-
-			for (const run of runs) {
-				for (const task of run.tasks) {
-					// Only process tasks with failures
-					if (task.valid && task.judge_scores?.every((s) => s.pass)) continue;
-
-					// Task-level validity failure (no judge scores or overall invalid)
-					if (!task.valid && (!task.judge_scores || task.judge_scores.length === 0)) {
-						intakeTopic.publish({
-							source: "eval",
-							summary: `Task ${task.task_id} invalid (model: ${run.model})`,
-							evidence: `Run ${run.run_id}: task produced invalid output`,
-							affectsAreas: ["graphspec"],
-							affectsEvalTasks: [task.task_id],
-							severity: defaultSeverity,
-						});
-						continue;
-					}
-
-					// Per-criterion findings
-					if (task.judge_scores) {
-						for (const score of task.judge_scores) {
-							if (score.pass) continue;
-							intakeTopic.publish({
-								source: "eval",
-								summary: `${task.task_id}: ${score.claim} (model: ${run.model})`,
-								evidence: score.reasoning,
-								affectsAreas: ["graphspec"],
-								affectsEvalTasks: [task.task_id],
-								severity: defaultSeverity,
-							});
-						}
-					}
-				}
-			}
-		},
-		{ describeKind: "effect" },
-	);
-	graph.add(eff, { name });
-	return eff;
-}
-
-// ---------------------------------------------------------------------------
-// Composition A: Eval-driven improvement loop
-// ---------------------------------------------------------------------------
-
-/**
- * Wrap any eval runner as a reactive producer node.
- *
- * When `trigger` emits, calls `runner()` and emits the result downstream.
- * Uses `switchMap` + `fromAny` — the async boundary stays in the source
- * layer (spec §5.10). A new trigger cancels any in-flight run.
- *
- * Pure transform via operator composition — does not construct an
- * effect/derived node, so no `graph` parameter is needed.
- *
- * ```ts
- * const trigger = state(0);         // bump to trigger a new run
- * const results = evalSource(trigger, () => runEvals(config));
- * results.subscribe(msgs => { ... });
- * trigger.emit(1);                   // fires the runner
- * ```
- *
- * @param trigger - Any node; each new DATA emission fires the runner.
- * @param runner  - Returns an EvalRunResult (or promise of one).
- */
-export function evalSource<T extends EvalRunResult>(
-	trigger: Node<unknown>,
-	runner: () => T | Promise<T>,
-): Node<T> {
-	return switchMap(trigger, () => fromAny(runner()) as Node<T>);
-}
-
-// ---------------------------------------------------------------------------
-
-/** Per-task delta produced by {@link beforeAfterCompare}. */
-export interface EvalTaskDelta {
-	taskId: string;
-	before: boolean;
-	after: boolean;
-	/** Score-level diff (after − before), undefined if no scores present. */
-	scoreDiff?: number;
-}
-
-/** Output of {@link beforeAfterCompare}. */
-export interface EvalDelta {
-	/** Task IDs that newly fail in `after` (were passing in `before`). */
-	newFailures: string[];
-	/** Task IDs that now pass in `after` (were failing in `before`). */
-	resolved: string[];
-	/** Full per-task breakdown. */
-	taskDeltas: EvalTaskDelta[];
-	/** True when net resolutions > net failures. */
-	overallImproved: boolean;
-}
-
-/** Options for {@link beforeAfterCompare}. */
-export interface BeforeAfterCompareOptions {
-	/** Graph to register the derived node on (B.1 narrow-waist visibility). */
-	graph: Graph;
-	/** Node holding the baseline eval result. */
-	before: Node<EvalRunResult>;
-	/** Node holding the new eval result. */
-	after: Node<EvalRunResult>;
-	/** Derived-node name (default `"eval-delta"`). */
-	name?: string;
-}
-
-/**
- * Derived node that computes before/after eval deltas.
- *
- * Pure computation: no LLM, no async. Compares per-task validity and
- * pass counts between two `EvalRunResult` snapshots.
- *
- * The derived node is registered on the supplied `graph` so it appears in
- * `describe()` and is owned by the graph's lifecycle.
- */
-export function beforeAfterCompare(opts: BeforeAfterCompareOptions): Node<EvalDelta> {
-	const { graph, before, after, name = "eval-delta" } = opts;
-	const der = node<EvalDelta>(
-		[before as Node<unknown>, after as Node<unknown>],
-		(batchData, actions, ctx) => {
-			const data = batchData.map((batch, i) =>
-				batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-			);
-			const bRes = data[0] as EvalRunResult;
-			const aRes = data[1] as EvalRunResult;
-
-			const beforeMap = new Map<string, EvalTaskResult>(bRes.tasks.map((t) => [t.task_id, t]));
-			const afterMap = new Map<string, EvalTaskResult>(aRes.tasks.map((t) => [t.task_id, t]));
-
-			const allIds = new Set([...beforeMap.keys(), ...afterMap.keys()]);
-			const taskDeltas: EvalTaskDelta[] = [];
-			const newFailures: string[] = [];
-			const resolved: string[] = [];
-
-			for (const id of allIds) {
-				const bt = beforeMap.get(id);
-				const at = afterMap.get(id);
-				const beforeValid = bt?.valid ?? false;
-				const afterValid = at?.valid ?? false;
-
-				const beforeScore = bt?.judge_scores
-					? bt.judge_scores.filter((s) => s.pass).length
-					: undefined;
-				const afterScore = at?.judge_scores
-					? at.judge_scores.filter((s) => s.pass).length
-					: undefined;
-				const scoreDiff =
-					beforeScore !== undefined && afterScore !== undefined
-						? afterScore - beforeScore
-						: undefined;
-
-				taskDeltas.push({ taskId: id, before: beforeValid, after: afterValid, scoreDiff });
-				if (beforeValid && !afterValid) newFailures.push(id);
-				if (!beforeValid && afterValid) resolved.push(id);
-			}
-
-			actions.emit({
-				newFailures,
-				resolved,
-				taskDeltas,
-				overallImproved: resolved.length > newFailures.length,
-			});
-		},
-		{ describeKind: "derived" },
-	);
-	graph.add(der as Node<unknown>, { name });
-	return der;
-}
-
-// ---------------------------------------------------------------------------
-
-/** Options for {@link affectedTaskFilter}. */
-export interface AffectedTaskFilterOptions {
-	/** Graph to register the derived node on (B.1 narrow-waist visibility). */
-	graph: Graph;
-	/** Node holding the current list of triaged items. */
-	issues: Node<readonly TriagedItem[]>;
-	/**
-	 * Optional node (or plain array) of all known task IDs.
-	 * When provided, output is the intersection.
-	 */
-	fullTaskSet?: Node<readonly string[]> | readonly string[];
-	/** Derived-node name (default `"affected-task-filter"`). */
-	name?: string;
-}
-
-/**
- * Derived node that selects which eval task IDs to re-run.
- *
- * Collects `affectsEvalTasks` from all triaged items, deduplicates, then
- * optionally intersects with `fullTaskSet`. Returns a sorted array of IDs.
- *
- * Use this to avoid re-running the full eval suite after each fix: only the
- * tasks that the triaged items claim to affect are returned.
- *
- * The derived node is registered on the supplied `graph` so it appears in
- * `describe()` and is owned by the graph's lifecycle.
- */
-export function affectedTaskFilter(opts: AffectedTaskFilterOptions): Node<string[]> {
-	const { graph, issues, fullTaskSet, name = "affected-task-filter" } = opts;
-
-	let taskSetNode: Node<unknown> | null = null;
-	if (fullTaskSet != null) {
-		if (Array.isArray(fullTaskSet)) {
-			// Static-array form: register the inline state node so it appears
-			// in `describe()`/`explain()` walks (EC8 — qa 2026-04-30).
-			const inlineSet = node([], { initial: fullTaskSet as readonly string[] });
-			graph.add(inlineSet, { name: `${name}/fullTaskSet` });
-			taskSetNode = inlineSet as Node<unknown>;
-		} else {
-			// User-supplied Node — owned by the caller's graph; don't re-add.
-			taskSetNode = fullTaskSet as Node<unknown>;
-		}
-	}
-
-	const deps: Node<unknown>[] = [issues as Node<unknown>];
-	if (taskSetNode) deps.push(taskSetNode);
-
-	const der = node<string[]>(
-		deps,
-		(batchData, actions, ctx) => {
-			const data = batchData.map((batch, i) =>
-				batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-			);
-			const items = data[0] as readonly TriagedItem[];
-			const all = taskSetNode ? new Set(data[1] as readonly string[]) : null;
-
-			const affected = new Set<string>();
-			for (const item of items) {
-				for (const id of item.affectsEvalTasks ?? []) {
-					if (all == null || all.has(id)) affected.add(id);
-				}
-			}
-			actions.emit([...affected].sort());
-		},
-		{ describeKind: "derived" },
-	);
-	graph.add(der as Node<unknown>, { name });
-	return der;
-}
-
-// ---------------------------------------------------------------------------
-// Composition D: Quality gate (CI/CD)
-// ---------------------------------------------------------------------------
-
-/** A single lint error emitted by a CI tool. */
-export interface LintError {
-	file: string;
-	line: number;
-	col: number;
-	rule: string;
-	message: string;
-}
-
-/** A single test failure emitted by a test runner. */
-export interface TestFailure {
-	testId: string;
-	file: string;
-	message: string;
-}
-
-/** Structured code-change / CI event. */
-export interface CodeChange {
-	/** Files touched by the change. */
-	files: string[];
-	lintErrors?: LintError[];
-	testFailures?: TestFailure[];
-}
-
-/** Options for {@link codeChangeBridge}. */
-export interface CodeChangeBridgeOptions {
-	/** Graph to register the effect node on (B.1 narrow-waist visibility). */
-	graph: Graph;
-	/** Node emitting CodeChange events. */
-	source: Node<CodeChange>;
-	/** TopicGraph to publish IntakeItem entries to. */
-	intakeTopic: TopicGraph<IntakeItem>;
-	/** Optional custom parser (overrides default). */
-	parser?: (change: CodeChange) => IntakeItem[];
-	/** Effect-node name (default `"code-change-bridge"`). */
-	name?: string;
-	/** Default severity for generated IntakeItems (default `"high"`). */
-	defaultSeverity?: Severity;
-}
-
-/**
- * Intake bridge for code-change / CI events.
- *
- * Watches a source node for `CodeChange` events and publishes one
- * `IntakeItem` per lint error and per test failure to the intake topic.
- * Pass a custom `parser` to override the default mapping.
- *
- * The effect node is registered on the supplied `graph` so it appears in
- * `describe()` and is owned by the graph's lifecycle.
- */
-export function codeChangeBridge(opts: CodeChangeBridgeOptions): Node<unknown> {
-	const {
-		graph,
-		source,
-		intakeTopic,
-		parser,
-		name = "code-change-bridge",
-		defaultSeverity = "high",
-	} = opts;
-
-	function defaultParser(change: CodeChange): IntakeItem[] {
-		const items: IntakeItem[] = [];
-		for (const err of change.lintErrors ?? []) {
-			items.push({
-				source: "code-change",
-				summary: `Lint: ${err.rule} in ${err.file}:${err.line}`,
-				evidence: err.message,
-				affectsAreas: [err.file],
-				severity: defaultSeverity,
-			});
-		}
-		for (const fail of change.testFailures ?? []) {
-			items.push({
-				source: "test",
-				summary: `Test failure: ${fail.testId}`,
-				evidence: fail.message,
-				affectsAreas: [fail.file],
-				affectsEvalTasks: [fail.testId],
-				severity: defaultSeverity,
-			});
-		}
-		return items;
-	}
-
-	const resolve = parser ?? defaultParser;
-
-	const eff = node(
-		[source as Node<unknown>],
-		(batchData, _actions, ctx) => {
-			const data = batchData.map((batch, i) =>
-				batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-			);
-			const change = data[0];
-			if (change === undefined) return;
-			for (const item of resolve(change as CodeChange)) {
-				intakeTopic.publish(item);
-			}
-		},
-		{ describeKind: "effect" },
-	);
-	graph.add(eff, { name });
-	return eff;
-}
-
-// ---------------------------------------------------------------------------
-
-/** Transport function for {@link notifyEffect}. Sync or async. */
-export type NotifyTransport<T> = (item: T) => void | Promise<void>;
-
-/** Options for {@link notifyEffect}. */
-export interface NotifyEffectOptions<T> {
-	/** Graph to register the effect node on (B.1 narrow-waist visibility). */
-	graph: Graph;
-	/** TopicGraph whose latest entry triggers the notification. */
-	topic: TopicGraph<T>;
-	/** Called with each new item. May return a Promise. */
-	transport: NotifyTransport<T>;
-	/** Effect-node name (default `"notify-effect"`). */
-	name?: string;
-}
-
-/**
- * Effect node that sends each new topic entry to an external channel.
- *
- * The `transport` function is called for every item published to `topic`.
- * Async transports are bridged via `fromAny` (spec §5.10 compliant).
- *
- * Typical use: Slack webhook, GitHub PR comment, email notification, etc.
- * The factory provides reactive wiring; the transport supplies domain logic.
- *
- * The effect node is registered on the supplied `graph` so it appears in
- * `describe()` and is owned by the graph's lifecycle.
- *
- * ```ts
- * notifyEffect({ graph, topic: alertQueue, transport: async (item) => {
- *   await fetch(SLACK_WEBHOOK, { method: 'POST', body: JSON.stringify({ text: item.summary }) });
- * }});
- * ```
- */
-export function notifyEffect<T>(opts: NotifyEffectOptions<T>): Node<unknown> {
-	const { graph, topic, transport, name = "notify-effect" } = opts;
-	// SENTINEL contract on `topic.latest` (COMPOSITION-GUIDE §1a + spec §5.12):
-	// - `topic.publish(undefined)` is rejected at the publish boundary, so
-	//   `undefined` is exclusively the protocol SENTINEL on the read side.
-	// - `topic.latest` stays SENTINEL on empty (no eager DATA emission), so
-	//   the partial-false first-run gate holds this fn until the first publish.
-	// - Legit `null` DATA (when `T` includes `null`) reaches `transport`;
-	//   user transports must handle `null` themselves per v5.
-	// The `=== undefined` guard below is defense-in-depth for any future
-	// empty-batch wave where `prevData[0]` is still SENTINEL — in normal flow
-	// the first-run gate has already filtered the empty case.
-	const eff = node(
-		[topic.latest as Node<unknown>],
-		(batchData, _actions, ctx) => {
-			const data = batchData.map((batch, i) =>
-				batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-			);
-			const item = data[0];
-			if (item === undefined) return;
-			// transport is a side effect (webhook, Slack, email). Async transports
-			// are fire-and-forget — the Promise result does not feed back into the
-			// graph. Suppress unhandled-rejection noise by voiding the return.
-			void transport(item as T);
-		},
-		{ describeKind: "effect" },
-	);
-	graph.add(eff, { name });
-	return eff;
-}
diff --git a/src/utils/harness/defaults.ts b/src/utils/harness/defaults.ts
deleted file mode 100644
index 930413f9..00000000
--- a/src/utils/harness/defaults.ts
+++ /dev/null
@@ -1,176 +0,0 @@
-/**
- * Harness runtime defaults (roadmap §9.0).
- *
- * Split out from `types.ts` in Wave B Unit 15 G so the type file holds
- * only type declarations and plug-in contracts. Runtime constants and
- * helpers live here; the harness barrel (`index.ts`) re-exports both so
- * external consumers see a single surface.
- *
- * @module
- */
-
-import type {
-	ErrorClass,
-	ErrorClassifier,
-	ExecutionResult,
-	Intervention,
-	PresetId,
-	QueueConfig,
-	QueueRoute,
-	RootCause,
-	Severity,
-	StrategyKey,
-} from "./types.js";
-
-// ---------------------------------------------------------------------------
-// Route / queue
-// ---------------------------------------------------------------------------
-
-/** Ordered queue route names for iteration. */
-export const QUEUE_NAMES: readonly QueueRoute[] = [
-	"auto-fix",
-	"needs-decision",
-	"investigation",
-	"backlog",
-];
-
-/** Default queue configurations. */
-export const DEFAULT_QUEUE_CONFIGS: Record<QueueRoute, QueueConfig> = {
-	"auto-fix": { gated: false },
-	"needs-decision": { gated: true },
-	investigation: { gated: true },
-	// `startOpen` intentionally omitted — backlog is not gated, so the flag
-	// would be meaningless. Dropped in Unit 15 G trim pass.
-	backlog: { gated: false },
-};
-
-// ---------------------------------------------------------------------------
-// Priority scoring
-// ---------------------------------------------------------------------------
-
-/** Default severity weights. */
-export const DEFAULT_SEVERITY_WEIGHTS: Record<Severity, number> = {
-	critical: 100,
-	high: 70,
-	medium: 40,
-	low: 10,
-};
-
-/** Default decay rate: ~7-day half-life. Re-exported from `base/utils/decay.ts`. */
-export { DEFAULT_DECAY_RATE } from "../../base/utils/decay.js";
-
-// ---------------------------------------------------------------------------
-// Strategy model
-// ---------------------------------------------------------------------------
-
-/**
- * Canonical 3-axis composite-key factory: `${presetId}|${rootCause}→${intervention}`.
- *
- * **Phase 13.I axis extension (DS-13.I, 2026-05-01).** Pre-multi-agent
- * callers without a preset registry pass {@link DEFAULT_PRESET_ID}
- * (`"default"`) for the first arg. Pre-1.0 breaking signature change;
- * persisted strategy-model snapshots from before this date are NOT portable.
- */
-export function strategyKey(
-	presetId: PresetId,
-	rootCause: RootCause,
-	intervention: Intervention,
-): StrategyKey {
-	return `${presetId}|${rootCause}→${intervention}`;
-}
-
-// ---------------------------------------------------------------------------
-// Error classifier
-// ---------------------------------------------------------------------------
-
-/**
- * Regex-word-boundary match over a closed keyword set. Callers needing
- * domain-specific failure modes should supply a custom
- * {@link ErrorClassifier}; this default exists so zero-config harness runs
- * still distinguish parse-class failures (fast-retry) from everything
- * else (full loop via reingestion).
- */
-const SELF_CORRECTABLE_RE = /\b(parse|json|config|validation|syntax)\b/i;
-
-/** Default error classifier: parse/config errors are self-correctable. */
-export const defaultErrorClassifier: ErrorClassifier = (result: ExecutionResult): ErrorClass =>
-	SELF_CORRECTABLE_RE.test(result.detail) ? "self-correctable" : "structural";
-
-// ---------------------------------------------------------------------------
-// Default stage prompts
-// ---------------------------------------------------------------------------
-
-/** Default TRIAGE prompt — LLM classifies intake items into root-cause + intervention + route + priority. */
-export const DEFAULT_TRIAGE_PROMPT = `You are a triage classifier for a reactive collaboration harness.
-
-Given an intake item, classify it and output JSON:
-{
-  "rootCause": "composition" | "missing-fn" | "bad-docs" | "schema-gap" | "regression" | "unknown",
-  "intervention": "template" | "catalog-fn" | "docs" | "wrapper" | "schema-change" | "investigate",
-  "route": "auto-fix" | "needs-decision" | "investigation" | "backlog",
-  "priority": <number 0-100>,
-  "triageReasoning": "<one sentence>"
-}
-
-Strategy model (past effectiveness):
-{{strategy}}
-
-Intake item:
-{{item}}`;
-
-/** Default EXECUTE prompt — LLM produces a fix given a triaged issue. */
-export const DEFAULT_EXECUTE_PROMPT = `You are an implementation agent.
-
-Given a triaged issue with root cause and intervention type, produce a fix.
-
-Issue:
-{{item}}
-
-Output JSON:
-{
-  "outcome": "success" | "failure" | "partial",
-  "detail": "<description of what was done or what failed>"
-}`;
-
-/** Default VERIFY prompt — LLM reviews an execution result against the original issue. */
-export const DEFAULT_VERIFY_PROMPT = `You are a QA reviewer.
-
-Given an execution result, verify whether the fix is correct.
-
-Execution:
-{{execution}}
-
-Original issue:
-{{item}}
-
-Output JSON:
-{
-  "verified": true/false,
-  "findings": ["<finding1>", ...],
-  "errorClass": "self-correctable" | "structural"  // only if verified=false
-}`;
-
-// ---------------------------------------------------------------------------
-// Prompt resolver helper
-// ---------------------------------------------------------------------------
-
-/**
- * Collapse the `string | ((input: In) => string) | undefined` prompt-template
- * pattern into a single `(input: In) => string`. A function `raw` is used as-is
- * (the caller opted into full control). Otherwise `raw ?? fallbackTemplate`
- * is fed through `substitute`, which does the placeholder replacement.
- *
- * Used by the three harness stages (TRIAGE / EXECUTE / VERIFY), which each
- * accept a `string | function` config but use different placeholder schemes
- * (`{{item}}`, `{{execution}}`, `{{strategy}}`). The helper absorbs only the
- * branch logic; the per-stage placeholder substitution lives at the call site.
- */
-export function resolvePromptFn<In>(
-	raw: string | ((input: In) => string) | undefined,
-	fallbackTemplate: string,
-	substitute: (template: string, input: In) => string,
-): (input: In) => string {
-	if (typeof raw === "function") return raw;
-	const template = raw ?? fallbackTemplate;
-	return (input) => substitute(template, input);
-}
diff --git a/src/utils/harness/index.ts b/src/utils/harness/index.ts
deleted file mode 100644
index 6d93737a..00000000
--- a/src/utils/harness/index.ts
+++ /dev/null
@@ -1,20 +0,0 @@
-/**
- * Harness wiring (roadmap §9.0).
- *
- * Reactive collaboration loop: static-topology, flowing data.
- * Composes orchestration (gate), AI (promptNode), reduction (scorer/stratify),
- * and messaging (TopicGraph/bridge) into a 7-stage loop.
- *
- * @module
- */
-
-export * from "./actuator-executor.js";
-export * from "./auto-solidify.js";
-export * from "./bridge.js";
-export * from "./defaults.js";
-// `effectivenessTracker` was deleted per Class B audit Alt E (2026-04-30).
-// The shared substrate now lives in `extra/composition/audited-success-tracker.ts`
-// — re-exported via `@graphrefly/graphrefly/extra` for general use. The
-// (zero-consumer) `effectivenessTracker(opts?)` factory shape was not retained.
-export * from "./strategy.js";
-export * from "./types.js";
diff --git a/src/utils/harness/strategy.ts b/src/utils/harness/strategy.ts
deleted file mode 100644
index b6744016..00000000
--- a/src/utils/harness/strategy.ts
+++ /dev/null
@@ -1,146 +0,0 @@
-/**
- * Strategy model and priority scoring (roadmap §9.0).
- *
- * `strategyModel` returns a typed alias of {@link AuditedSuccessTrackerGraph}
- * keyed by `StrategyKey` (the composite `rootCause→intervention` string).
- * The shared substrate (Class B audit Alt E collapse, 2026-04-30) replaces
- * the prior bespoke bundle shape; composite-key callers use {@link strategyKey}
- * to compute the key and pass `{ rootCause, intervention }` as record decoration.
- *
- * @module
- */
-
-import { monotonicNs, type Node, node } from "@graphrefly/pure-ts/core";
-import { decay } from "../../base/utils/decay.js";
-import {
-	type AuditedSuccessTrackerGraph,
-	auditedSuccessTracker,
-} from "../orchestration/audited-success-tracker.js";
-
-import {
-	DEFAULT_DECAY_RATE,
-	DEFAULT_PRESET_ID,
-	DEFAULT_SEVERITY_WEIGHTS,
-	type PrioritySignals,
-	type StrategyEntry,
-	type StrategyKey,
-	strategyKey,
-	type TriagedItem,
-} from "./types.js";
-
-// ---------------------------------------------------------------------------
-// Strategy model
-// ---------------------------------------------------------------------------
-
-/** Snapshot shape for the strategy-model `entries` node. */
-export type StrategySnapshot = ReadonlyMap<StrategyKey, StrategyEntry>;
-
-/** Strategy-model graph: a typed alias of {@link AuditedSuccessTrackerGraph}. */
-export type StrategyModelGraph = AuditedSuccessTrackerGraph<StrategyKey, StrategyEntry>;
-
-/**
- * Create a strategy model that tracks
- * `presetId × rootCause × intervention → successRate` over completed
- * issues (presetId axis added in Phase 13.I, 2026-05-01). Returns an
- * {@link AuditedSuccessTrackerGraph} keyed by {@link StrategyKey}.
- *
- * The reactive `entries` field is a `Node<StrategySnapshot>` suitable for
- * `describe()` / `withLatestFrom` composition.
- *
- * Composite-key conversion happens at the call site:
- * ```ts
- * const strategy = strategyModel();
- * strategy.record(strategyKey(presetId, rootCause, intervention), success, {
- *   presetId,
- *   rootCause,
- *   intervention,
- * });
- * strategy.lookup(strategyKey(presetId, rootCause, intervention));
- * ```
- *
- * Pass {@link DEFAULT_PRESET_ID} (`"default"`) for the presetId axis when
- * no preset registry is wired (single-agent harness).
- *
- * The model feeds back into TRIAGE for routing hints.
- */
-export function strategyModel(): StrategyModelGraph {
-	return auditedSuccessTracker<StrategyKey, StrategyEntry>({ name: "strategy" });
-}
-
-// ---------------------------------------------------------------------------
-// Priority scoring
-// ---------------------------------------------------------------------------
-
-/**
- * Create a priority scoring derived node for a single triaged item.
- *
- * Combines severity weight, attention decay, strategy model effectiveness,
- * and an optional external urgency signal.
- *
- * **Age sampling caveat.** The `ageSeconds` term is computed as
- * `monotonicNs() - lastInteractionNs.cache` at *each reactive update*. If
- * nothing upstream settles, the score node does not recompute — so a
- * long-idle queue may show a stale score. Pass a `fromTimer(...)`-driven
- * node as a dep (or re-emit on `lastInteractionNs`) when live age decay
- * matters.
- *
- * **Not the same as `TriagedItem.priority`.** The LLM-emitted
- * `priority: 0..100` field on each triaged item is decorative today — the
- * queue consumption order ignores it (tracked in `docs/optimizations.md`
- * as a priority-ordered queue enhancement). This function computes an
- * orthogonal reactive score; it does NOT override the LLM's per-item
- * priority, nor does it drive queue ordering. Wire it to
- * `HarnessGraph.priorityScores` to surface per-route pressure.
- *
- * @param item - Node holding the triaged item.
- * @param strategy - Strategy model node.
- * @param lastInteractionNs - Node holding the monotonic timestamp (ns) of last human interaction.
- * @param urgency - Optional external urgency signal node (0–1 scale).
- * @param signals - Configurable scoring parameters.
- */
-export function priorityScore(
-	item: Node<TriagedItem>,
-	strategy: Node<StrategySnapshot>,
-	lastInteractionNs: Node<number>,
-	urgency?: Node<number>,
-	signals?: PrioritySignals,
-): Node<number> {
-	const severityWeights = { ...DEFAULT_SEVERITY_WEIGHTS, ...signals?.severityWeights };
-	const decayRate = signals?.decayRate ?? DEFAULT_DECAY_RATE;
-	const effectivenessThreshold = signals?.effectivenessThreshold ?? 0.7;
-	const effectivenessBoost = signals?.effectivenessBoost ?? 15;
-
-	const deps: Node<unknown>[] = [item, strategy, lastInteractionNs];
-	if (urgency) deps.push(urgency);
-
-	return node<number>(
-		deps,
-		(batchData, actions, ctx) => {
-			const values = batchData.map((batch, i) =>
-				batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-			);
-			const itm = values[0] as TriagedItem;
-			const strat = values[1] as StrategySnapshot;
-			const lastNs = values[2] as number;
-			const urg = urgency ? (values[3] as number) : 0;
-
-			// Base score from severity
-			const baseWeight = severityWeights[itm.severity ?? "medium"];
-			const ageSeconds = (monotonicNs() - lastNs) / 1e9;
-			let score = decay(baseWeight, ageSeconds, decayRate, 0);
-
-			// Strategy model boost
-			const key = strategyKey(DEFAULT_PRESET_ID, itm.rootCause, itm.intervention);
-			const entry = strat.get(key);
-			if (entry && entry.successRate >= effectivenessThreshold) {
-				score += effectivenessBoost;
-			}
-
-			// External urgency boost (0–1 scale → 0–20 points)
-			score += urg * 20;
-
-			actions.emit(score);
-		},
-		{ name: "priority-score", describeKind: "derived" },
-	);
-}
diff --git a/src/utils/harness/types.ts b/src/utils/harness/types.ts
deleted file mode 100644
index 36aa8c2c..00000000
--- a/src/utils/harness/types.ts
+++ /dev/null
@@ -1,487 +0,0 @@
-/**
- * Harness wiring types (roadmap §9.0).
- *
- * Shared types for the reactive collaboration loop: intake, triage, queue,
- * gate, execute, verify, reflect. These types are intentionally domain-agnostic
- * — the harness loop is not specific to eval workflows.
- *
- * Runtime constants and helpers live in `./defaults.ts`. The harness barrel
- * (`./index.ts`) re-exports both so external consumers see a single surface.
- *
- * @module
- */
-
-import type { Node } from "@graphrefly/pure-ts/core";
-import type { NodeInput } from "@graphrefly/pure-ts/extra";
-// Type-only import avoids a runtime cycle with `patterns/ai`.
-import type { LLMAdapter } from "../ai/index.js";
-import type { JobEnvelope } from "../job-queue/index.js";
-
-// ---------------------------------------------------------------------------
-// Intake
-// ---------------------------------------------------------------------------
-
-/** Known intake source tags. */
-export type KnownIntakeSource = "eval" | "test" | "human" | "code-change" | "hypothesis" | "parity";
-
-/**
- * Sources that can produce intake items. Open union — the known tags
- * retain IDE autocomplete while user-supplied strings (e.g. `"schema"`,
- * `"slack"`) pass through without a type change.
- */
-export type IntakeSource = KnownIntakeSource | (string & {});
-
-/** Severity levels for intake items. */
-export type Severity = "critical" | "high" | "medium" | "low";
-
-/** Root cause categories for triage classification. */
-export type RootCause =
-	| "composition"
-	| "missing-fn"
-	| "bad-docs"
-	| "schema-gap"
-	| "regression"
-	| "unknown";
-
-/** Intervention types that address root causes. */
-export type Intervention =
-	| "template"
-	| "catalog-fn"
-	| "docs"
-	| "wrapper"
-	| "schema-change"
-	| "investigate";
-
-/** Routing destinations after triage. Closed union — iterated via `QUEUE_NAMES`. */
-export type QueueRoute = "auto-fix" | "needs-decision" | "investigation" | "backlog";
-
-/**
- * An item entering the harness loop via the INTAKE stage.
- *
- * All intake sources produce this uniform shape — the intake topic
- * doesn't care where items came from.
- *
- * `$`-prefix keys (`$reingestions`, `$retries` on {@link TriagedItem}) are
- * framework-only — an LLM round-tripping the serialized item is far less
- * likely to echo back a `$`-prefixed key than an `_`-prefixed one, which
- * neutralizes the field-collision class that surfaced earlier in the
- * router's spread order.
- */
-export interface IntakeItem {
-	source: IntakeSource;
-	summary: string;
-	evidence: string;
-	affectsAreas: string[];
-	affectsEvalTasks?: string[];
-	severity?: Severity;
-	/**
-	 * Identity-preservation key for retried / reingested items.
-	 *
-	 * `relatedTo[0]` MUST carry the original tracking key for retry /
-	 * reingest items so the harness's `routeJobIds` map preserves
-	 * identity across decorated retry summaries (per qa D1, 2026-04-29).
-	 * First-time publishes leave this `undefined`; the tracking key
-	 * falls back to `summary` via {@link trackingKey}.
-	 *
-	 * **Collision contract (DS-13.5.D.3, locked 2026-05-01).** Items
-	 * lacking `relatedTo[0]` and producing colliding `trackingKey()`
-	 * derivations overwrite the prior `routeJobIds` entry —
-	 * **last-write-wins**. Framework-enforced uniqueness was rejected
-	 * because it would break legitimate retry / reingest patterns where
-	 * an explicit `relatedTo[0]` carries the original key forward.
-	 *
-	 * **Single-threaded contract.** Ack runs before reingest publishes
-	 * (harness flow invariant) — under the standard single-threaded JS
-	 * pump this collapses the only practical race window. Multi-publisher
-	 * concurrency or batched intake of two first-time items with identical
-	 * `summary` can still race at boundaries; callers carrying their own
-	 * stable id should set `relatedTo[0]`.
-	 *
-	 * See {@link trackingKey} JSDoc in `patterns/_internal/index.ts` for
-	 * the uniqueness caller contract.
-	 *
-	 * Spec: docs/implementation-plan.md DS-13.5.D.3
-	 */
-	relatedTo?: string[];
-	/** Item-carried reingestion count. Incremented on each full-loop reingestion. */
-	$reingestions?: number;
-}
-
-// ---------------------------------------------------------------------------
-// Triage output
-// ---------------------------------------------------------------------------
-
-/** Output of the TRIAGE stage — enriched intake item with classification. */
-export interface TriagedItem extends IntakeItem {
-	rootCause: RootCause;
-	intervention: Intervention;
-	route: QueueRoute;
-	priority: number;
-	triageReasoning?: string;
-	/** Item-carried retry count. Incremented on each fast-retry pass. */
-	$retries?: number;
-}
-
-// ---------------------------------------------------------------------------
-// Strategy model
-// ---------------------------------------------------------------------------
-
-/**
- * Preset / persona / skill identifier. Open string set; conventionally
- * matches keys used in {@link presetRegistry} (Phase 13.H). Use
- * {@link DEFAULT_PRESET_ID} ("default") when no preset registry is wired.
- */
-export type PresetId = string;
-
-/** Default presetId used when no preset registry is wired (back-compat for 2-axis callers). */
-export const DEFAULT_PRESET_ID: PresetId = "default";
-
-/**
- * Key format: `${presetId}|${rootCause}→${intervention}`.
- *
- * **Phase 13.I axis extension (DS-13.I, 2026-05-01).** Widened from the
- * pre-multi-agent 2-axis `${rootCause}→${intervention}` to a 3-axis key
- * carrying the presetId of the agent that ran. Pre-1.0 breaking change;
- * existing callsites pass {@link DEFAULT_PRESET_ID} for the new axis when
- * they don't have a preset registry wired. The strategy-model storage
- * (`auditedSuccessTracker<StrategyKey, StrategyEntry>`) is unchanged
- * structurally — the key shape change cascades through the existing
- * tracker without surface refactor.
- */
-export type StrategyKey = `${PresetId}|${RootCause}→${Intervention}`;
-
-/**
- * Effectiveness record for a `(presetId, rootCause, intervention)` triple.
- * Stored under `auditedSuccessTracker<StrategyKey, StrategyEntry>` (Class B
- * audit Alt E collapse, 2026-04-30; presetId axis added Phase 13.I,
- * 2026-05-01) — `key` is the composite `strategyKey(presetId, rc, intv)`
- * computed at the call site; `presetId` / `rootCause` / `intervention` are
- * decoration carried via `record(...)` so consumers can read them without
- * re-parsing the key.
- */
-export interface StrategyEntry {
-	key: StrategyKey;
-	presetId: PresetId;
-	rootCause: RootCause;
-	intervention: Intervention;
-	attempts: number;
-	successes: number;
-	successRate: number;
-}
-
-// ---------------------------------------------------------------------------
-// Execution & verification
-// ---------------------------------------------------------------------------
-
-/**
- * LLM output shape from the EXECUTE stage (partial — lacks `item`).
- *
- * Generic over the artifact type `A` so typed executors like
- * `refineExecutor<T>` can flow `T` through to an `evalVerifier<T>` without
- * the caller casting `artifact` at the boundary. Defaults to `unknown`
- * for escape-hatch executors that carry opaque state.
- */
-export type ExecuteOutput<A = unknown> = {
-	/**
-	 * Execution outcome classification:
-	 *
-	 * - `"success"`: execution completed cleanly and the artifact (if any) is
-	 *   ready for verification. The verifier should proceed with a full
-	 *   evaluation pass.
-	 * - `"failure"`: execution did not produce a usable artifact — the actuator
-	 *   threw, a prompt parse failed, or `shouldApply` skipped the item. The
-	 *   verifier should treat this as a non-result and route accordingly.
-	 * - `"partial"`: execution produced a candidate that converged but did not
-	 *   fully meet verification criteria. Used by `refineExecutor` when the
-	 *   iteration cap is reached without full convergence; the artifact holds
-	 *   the best candidate achieved.
-	 */
-	outcome: "success" | "failure" | "partial";
-	detail: string;
-	/**
-	 * Optional opaque artifact that a custom executor (e.g. `refineExecutor`)
-	 * may attach so downstream verifiers can re-run evaluation against the
-	 * thing that was produced. LLM-backed default executors never populate
-	 * this — it's an escape hatch for reactive executors carrying structured
-	 * output (a refined prompt, a patched spec, a generated template, ...).
-	 */
-	artifact?: A;
-};
-
-/** Full execution result assembled downstream (LLM output + context). */
-export interface ExecutionResult<A = unknown> {
-	item: TriagedItem;
-	/**
-	 * Execution outcome classification. Same semantics as
-	 * {@link ExecuteOutput.outcome}:
-	 *
-	 * - `"success"`: execution completed cleanly; artifact is ready for
-	 *   verification.
-	 * - `"failure"`: no usable artifact was produced.
-	 * - `"partial"`: best candidate produced but convergence criteria not met
-	 *   (iteration cap reached in `refineExecutor`).
-	 */
-	outcome: "success" | "failure" | "partial";
-	detail: string;
-	/**
-	 * Passthrough of {@link ExecuteOutput.artifact} when the executor emitted
-	 * one. Reactive executors like `refineExecutor` populate this; LLM-backed
-	 * default executors leave it undefined.
-	 */
-	artifact?: A;
-}
-
-/** Whether an error is self-correctable (fast-retry) or structural (full loop). */
-export type ErrorClass = "self-correctable" | "structural";
-
-/** Classifier for fast-retry path. */
-export type ErrorClassifier = (result: ExecutionResult) => ErrorClass;
-
-// ---------------------------------------------------------------------------
-// Verification output
-// ---------------------------------------------------------------------------
-
-/** Result of the VERIFY stage. */
-export interface VerifyResult<A = unknown> {
-	item: TriagedItem;
-	execution: ExecutionResult<A>;
-	verified: boolean;
-	findings: string[];
-	errorClass?: ErrorClass;
-}
-
-/**
- * Verifier output shape — what a custom verifier emits. The harness
- * assembles this into the full {@link VerifyResult} using the triaged
- * item + execute output sampled from `executeContextNode`.
- */
-export interface VerifyOutput {
-	verified: boolean;
-	findings: string[];
-	errorClass?: ErrorClass;
-}
-
-// ---------------------------------------------------------------------------
-// Priority scoring
-// ---------------------------------------------------------------------------
-
-/** Configurable signals for priority scoring. */
-export interface PrioritySignals {
-	/** Per-severity base weight (default: critical=100, high=70, medium=40, low=10). */
-	severityWeights?: Partial<Record<Severity, number>>;
-	/** Decay rate per second for attention decay (default ~1.15e-6 ≈ 7-day half-life). */
-	decayRate?: number;
-	/** Strategy model effectiveness boost threshold (default 0.7). */
-	effectivenessThreshold?: number;
-	/** Strategy model effectiveness boost amount (default 15). */
-	effectivenessBoost?: number;
-}
-
-// ---------------------------------------------------------------------------
-// Harness loop configuration
-// ---------------------------------------------------------------------------
-
-import type { StrategySnapshot } from "./strategy.js";
-
-/** Per-queue configuration in the harness loop. */
-export interface QueueConfig {
-	/** Whether this queue is gated (requires human approval). */
-	gated: boolean;
-	/** Maximum pending items in the gate (default Infinity). */
-	maxPending?: number;
-	/** Start the gate in open (auto-approve) mode? Only meaningful when `gated: true`. */
-	startOpen?: boolean;
-}
-
-/**
- * Accumulating per-job payload threaded through the harness's
- * `executeFlow` ({@link harnessLoop} Tier 6.5 C2 lock). Each stage's work fn
- * receives the prior payload and returns a new one with its own field
- * filled in:
- *
- * - The `enqueueEffect` seeds with `{ item }` only.
- * - The execute work fn fills `execution`.
- * - The verify work fn fills `verify`.
- *
- * The post-completed dispatch effect reads `verify.verified` /
- * `verify.errorClass` to route the item to `verifyResults` /
- * `retryTopic.publish(...)` / `intake.publish(...)` (3-way verdict).
- *
- * Carrying `item` through stage payloads (rather than re-pairing via a
- * separate `withLatestFrom` node) is the C2 deviation from today's
- * `executeContextNode` design: each `JobEnvelope` is self-contained, so the
- * verify pump can run multiple in-flight jobs in parallel without an
- * external pairing node.
- */
-export interface HarnessJobPayload<A = unknown> {
-	/** The triaged item flowing through execute → verify → dispatch. */
-	item: TriagedItem;
-	/** Filled by the execute work fn. Verify reads this; dispatch routes. */
-	execution?: ExecutionResult<A>;
-	/** Filled by the verify work fn. Dispatch reads `verified` / `errorClass`. */
-	verify?: VerifyOutput;
-}
-
-/**
- * Pluggable EXECUTE work fn — receives a {@link JobEnvelope} carrying a
- * {@link HarnessJobPayload} (with `item` set, `execution` / `verify`
- * unset), returns a {@link NodeInput} that emits the same payload with
- * `execution` filled.
- *
- * **C2 contract (Tier 6.5 lock, 2026-04-28):**
- * 1. Emit DATA exactly once per claimed job. The JobFlow pump subscribes
- *    once, takes the first DATA, then unsubscribes. Subsequent emissions
- *    are ignored.
- * 2. Errors must be caught and surfaced as a `failure` outcome inside the
- *    payload — never throw / return ERROR. A pump nack would drop the
- *    item from JobFlow before the dispatch effect could route it.
- * 3. The work fn runs once per claim — no internal `switchMap` needed.
- *    Per-item subgraphs (e.g. a fresh `refineLoop` per claim) are
- *    instantiated inside the work fn body.
- *
- * `defaultLlmExecutor` (in `defaults.ts`) is a thin `adapter.invoke()`
- * wrapper. `refineExecutor` builds a per-claim `refineLoop`.
- * `actuatorExecutor` runs a side-effecting `apply(item, signal)`.
- */
-export type HarnessExecutor<A = unknown> = (
-	job: JobEnvelope<HarnessJobPayload<A>>,
-	opts?: { signal: AbortSignal },
-) => NodeInput<HarnessJobPayload<A>>;
-
-/**
- * Pluggable VERIFY work fn — receives a {@link JobEnvelope} whose payload
- * has `item` + `execution` populated, returns a {@link NodeInput} that
- * emits the same payload with `verify` filled.
- *
- * Same C2 contract rules 1–3 as {@link HarnessExecutor}. The dispatch
- * effect downstream reads `verify.verified` (success → ack +
- * verifyResults publish), `verify.errorClass === "self-correctable"`
- * (retry → republish to retry topic with `$retries` bumped), or anything
- * else (structural → reingest to intake if budget remains).
- *
- * Verify-LLM-call failures (parse error, adapter throw, timeout) MUST be
- * caught and surfaced as a structural-failure `verify` payload (`{
- * verified: false, findings: [...], errorClass: "structural" }`) so the
- * dispatch effect can route the item rather than silently drop it.
- */
-export type HarnessVerifier<A = unknown> = (
-	job: JobEnvelope<HarnessJobPayload<A>>,
-	opts?: { signal: AbortSignal },
-) => NodeInput<HarnessJobPayload<A>>;
-
-/** Triage prompt callable shape — pair of `[intake item, strategy snapshot]`. */
-export type TriagePromptFn = (pair: readonly [IntakeItem, StrategySnapshot]) => string;
-/** Execute prompt callable shape. */
-export type ExecutePromptFn = (item: TriagedItem) => string;
-/** Verify prompt callable shape — pair of `[execute output, triaged item]`. */
-export type VerifyPromptFn<A = unknown> = (
-	pair: readonly [ExecuteOutput<A> | null, TriagedItem | null],
-) => string;
-
-/** Options for {@link harnessLoop}. */
-export interface HarnessLoopOptions<A = unknown> {
-	/** LLM adapter for promptNode-based stages (triage + any default executor/verifier). */
-	adapter: LLMAdapter;
-
-	/** Custom triage prompt (receives IntakeItem + strategy snapshot as a tuple). */
-	triagePrompt?: string | TriagePromptFn;
-
-	/**
-	 * Execute prompt — sugar over the default LLM executor. Ignored when
-	 * `executor` is set.
-	 */
-	executePrompt?: string | ExecutePromptFn;
-
-	/**
-	 * Verify prompt — sugar over the default LLM verifier. Ignored when
-	 * `verifier` is set.
-	 */
-	verifyPrompt?: string | VerifyPromptFn<A>;
-
-	/**
-	 * Pluggable EXECUTE slot. When omitted, the harness uses a `promptNode`
-	 * driven by `adapter` + `executePrompt`. Replace to plug in a
-	 * `refineExecutor`, tool-using agent, or any reactive execution pipeline.
-	 */
-	executor?: HarnessExecutor<A>;
-
-	/**
-	 * Pluggable VERIFY slot. When omitted, the harness uses a `promptNode`
-	 * driven by `adapter` + `verifyPrompt`. Replace to plug in an
-	 * `evalVerifier` that re-runs affected eval tasks.
-	 */
-	verifier?: HarnessVerifier<A>;
-
-	/** Per-queue configuration overrides. */
-	queues?: Partial<Record<QueueRoute, QueueConfig>>;
-
-	/** Priority scoring signals. */
-	priority?: PrioritySignals;
-
-	/**
-	 * Reactive last-human-interaction timestamp (monotonic ns). Drives the
-	 * priority score age-decay term for `HarnessGraph.priorityScores`.
-	 *
-	 * **Required when `opts.priority` is set.** Priority score nodes only
-	 * re-derive when `topic.latest`, `strategy.snapshot`, or this tick settles —
-	 * an idle queue would freeze its age at construction time if we
-	 * auto-defaulted. Typical sources:
-	 *  - `fromTimer(60_000)` — steady tick, uniform decay.
-	 *  - `state(monotonicNs())` — bumped from a human-interaction handler.
-	 *  - A reactive view over a DB column / external metrics source.
-	 */
-	lastInteractionNs?: Node<number>;
-
-	/** Error classifier for fast-retry path. */
-	errorClassifier?: ErrorClassifier;
-
-	/** Max fast-retries per item before routing to full intake (default 2). */
-	maxRetries?: number;
-
-	/** Global retry cap across all items — circuit breaker (default maxRetries × 10). */
-	maxTotalRetries?: number;
-
-	/** Max re-ingestions from verify→intake before giving up (default 1). */
-	maxReingestions?: number;
-
-	/** Global reingestion cap across all items — circuit breaker (default maxReingestions × 10). */
-	maxTotalReingestions?: number;
-
-	/** Retained limit for topic logs (default 1000). */
-	retainedLimit?: number;
-
-	/**
-	 * Per-pump-tick claim cap on the internal `executeFlow` JobFlow's `execute`
-	 * stage (Tier 6.5 C2). Default `Number.MAX_SAFE_INTEGER` — every pending
-	 * claim is processed in one tick (matches today's unbounded `merge()`
-	 * parallelism). Lower this to bound LLM cost spikes on bursty intake.
-	 *
-	 * **Caveat.** This caps **claims per pump tick**, not total concurrent
-	 * inflight. Bounded-inflight is a separate primitive concern — see
-	 * `docs/optimizations.md` "Tier 6.5 follow-up — bounded concurrent inflight
-	 * on JobFlow stages".
-	 */
-	executeMaxPerPump?: number;
-
-	/**
-	 * Per-pump-tick claim cap on the internal `executeFlow` JobFlow's
-	 * `verify` stage. Default `Number.MAX_SAFE_INTEGER`. Same caveat as
-	 * {@link HarnessLoopOptions.executeMaxPerPump}. Honored independently
-	 * of the execute cap via `StageDef.maxPerPump` (Tier 6.5 D1).
-	 */
-	verifyMaxPerPump?: number;
-}
-
-// ---------------------------------------------------------------------------
-// Barrel re-exports from defaults.ts — preserves the pre-split import
-// surface (`import { QUEUE_NAMES, defaultErrorClassifier } from ".../types"`).
-// ---------------------------------------------------------------------------
-
-export {
-	DEFAULT_DECAY_RATE,
-	DEFAULT_QUEUE_CONFIGS,
-	DEFAULT_SEVERITY_WEIGHTS,
-	defaultErrorClassifier,
-	QUEUE_NAMES,
-	strategyKey,
-} from "./defaults.js";
diff --git a/src/utils/index.ts b/src/utils/index.ts
deleted file mode 100644
index a85d4819..00000000
--- a/src/utils/index.ts
+++ /dev/null
@@ -1,26 +0,0 @@
-/**
- * Utils layer — domain building blocks.
- *
- * Single-purpose factories returning Node or Graph, organized by domain.
- *
- * @module
- */
-
-export * from "./_errors/index.js";
-export * from "./ai/index.js";
-export * from "./cqrs/index.js";
-export * from "./demo-shell/index.js";
-export * from "./domain-templates/index.js";
-export * from "./graphspec/index.js";
-export * from "./harness/index.js";
-export * from "./inspect/index.js";
-export * from "./job-queue/index.js";
-export * from "./memory/index.js";
-export * from "./messaging/index.js";
-export * from "./orchestration/index.js";
-export * from "./process/index.js";
-export * from "./reactive-layout/index.js";
-export * from "./reduction/index.js";
-export * from "./resilience/index.js";
-export * from "./surface/index.js";
-export * from "./topology-view/index.js";
diff --git a/src/utils/inspect/audit.ts b/src/utils/inspect/audit.ts
deleted file mode 100644
index fe36afc8..00000000
--- a/src/utils/inspect/audit.ts
+++ /dev/null
@@ -1,852 +0,0 @@
-/**
- * Audit, policy enforcement, and compliance export (roadmap §9.2).
- *
- * Three composed factories that wrap any {@link Graph} with the harness
- * accountability layer:
- *
- * - {@link auditTrail} — reactive mutation log with by-node/by-actor/by-time
- *   queries.
- * - {@link policyGate} — reactive ABAC gate (Tier 2.3 rename of
- *   `policyEnforcer`); in `"audit"` mode records would-be denials, in
- *   `"enforce"` mode pushes guards onto target nodes so subsequent writes
- *   throw {@link GuardDenied}.
- * - {@link complianceSnapshot} — point-in-time export of graph state +
- *   audit trail + policies for regulatory archival.
- *
- * @module
- */
-import type { Actor, GuardAction, NodeGuard, PolicyRuleData } from "@graphrefly/pure-ts/core";
-import {
-	batch,
-	DATA,
-	defaultHash,
-	monotonicNs,
-	type Node,
-	NodeImpl,
-	node,
-	placeholderArgs,
-	policyFromRules,
-	wallClockNs,
-} from "@graphrefly/pure-ts/core";
-import { keepalive, reactiveLog } from "@graphrefly/pure-ts/extra";
-import {
-	Graph,
-	type GraphOptions,
-	type GraphPersistSnapshot,
-	type TopologyEvent,
-	watchTopologyTree,
-} from "@graphrefly/pure-ts/graph";
-import { domainMeta } from "../../base/meta/domain-meta.js";
-import { TopicGraph } from "../messaging/index.js";
-
-// ---------------------------------------------------------------------------
-// Shared types
-// ---------------------------------------------------------------------------
-
-/** A single recorded mutation/event in an {@link AuditTrailGraph}. */
-export interface AuditEntry {
-	seq: number;
-	timestamp_ns: number;
-	wall_clock_ns: number;
-	path: string;
-	type:
-		| "data"
-		| "dirty"
-		| "resolved"
-		| "invalidate"
-		| "pause"
-		| "resume"
-		| "complete"
-		| "error"
-		| "teardown";
-	actor?: Actor;
-	value?: unknown;
-	error?: unknown;
-	annotation?: string;
-}
-
-function auditMeta(kind: string, extra?: Record<string, unknown>): Record<string, unknown> {
-	return domainMeta("audit", kind, extra);
-}
-
-// ---------------------------------------------------------------------------
-// auditTrail
-// ---------------------------------------------------------------------------
-
-const DEFAULT_INCLUDE_TYPES: ReadonlySet<AuditEntry["type"]> = new Set([
-	"data",
-	"error",
-	"complete",
-	"teardown",
-]);
-
-/** Options for {@link auditTrail}. */
-export interface AuditTrailOptions {
-	name?: string;
-	graph?: GraphOptions;
-	/** Ring-buffer cap for the underlying `reactiveLog`. Default: unbounded. */
-	maxSize?: number;
-	/**
-	 * Which event types to record. Default: `["data", "error", "complete",
-	 * "teardown"]` — the user-meaningful set. Opt in to mid-wave protocol
-	 * events (`"dirty"`, `"resolved"`, `"invalidate"`, `"pause"`, `"resume"`)
-	 * by listing them explicitly. Note: those tier-1/tier-2 events do not
-	 * carry an `actor` (no `lastMutation` populated) — record them only for
-	 * protocol-level diagnostics.
-	 */
-	includeTypes?: readonly AuditEntry["type"][];
-	/** Per-event filter; return false to skip. */
-	filter?: (entry: AuditEntry) => boolean;
-}
-
-/**
- * Mounted audit log — `entries` exposes the reactive `AuditEntry[]`; query
- * helpers are sync convenience wrappers over the cached snapshot.
- */
-export class AuditTrailGraph extends Graph {
-	readonly entries: Node<readonly AuditEntry[]>;
-	readonly count: Node<number>;
-	/**
-	 * Effective set of event types this trail records (EH-18). Reflects
-	 * either the caller-supplied `opts.includeTypes` or the default set
-	 * (`["data", "error", "complete", "teardown"]`). Captured at construction
-	 * — each instance owns its own clone, so a default-using trail can never
-	 * leak mutations into the module-level default set.
-	 *
-	 * **Mutation contract.** Type-system read-only via `ReadonlySet`. Runtime
-	 * mutation through an unsafe cast (`(audit.includeTypes as Set<...>)
-	 * .add(...)`) is unsupported — it would desync the field from the
-	 * recording closure, which captured the original `Set` reference at
-	 * construction. The runtime does NOT enforce immutability beyond the
-	 * type contract; consumers must respect it.
-	 *
-	 * Use this to validate that a `complianceSnapshot.fingerprint` was
-	 * computed against the same recording surface — fingerprints are stable
-	 * only when the recording set is identical across snapshots.
-	 */
-	readonly includeTypes: ReadonlySet<AuditEntry["type"]>;
-	private readonly _log;
-	private readonly _target: Graph;
-
-	constructor(target: Graph, opts: AuditTrailOptions) {
-		super(opts.name ?? `${target.name}_audit`, opts.graph);
-		this._target = target;
-		this._log = reactiveLog<AuditEntry>([], {
-			name: "entries",
-			...(opts.maxSize != null ? { maxSize: opts.maxSize } : {}),
-		});
-		this.entries = this._log.entries;
-		this.add(this.entries, { name: "entries" });
-
-		this.count = this.derived<number>(
-			"count",
-			["entries"],
-			(batchData, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				return [(data[0] as readonly AuditEntry[]).length];
-			},
-			{ meta: auditMeta("count") },
-		);
-		this.addDisposer(keepalive(this.count));
-
-		// Always clone — DEFAULT_INCLUDE_TYPES is a module-level singleton and
-		// must not be shared across instances (a cast-and-mutate via
-		// `audit.includeTypes` would otherwise corrupt every default audit
-		// trail in the process).
-		const includeTypes: Set<AuditEntry["type"]> =
-			opts.includeTypes != null ? new Set(opts.includeTypes) : new Set(DEFAULT_INCLUDE_TYPES);
-		this.includeTypes = includeTypes;
-		const filter = opts.filter;
-
-		// Monotonic per-trail. **Stagnates** (does not wrap) past
-		// `Number.MAX_SAFE_INTEGER` — IEEE-754 imprecision means `seq + 1 === seq`
-		// once `seq` exceeds 2^53; subsequent records would carry the same
-		// stagnant value and break uniqueness. At 100k events/sec that's
-		// ~3000 years — not a practical concern.
-		let seq = 0;
-		const handle = target.observe({ timeline: true, structured: true });
-		const offEvent = handle.onEvent((event) => {
-			// `event.type` includes "derived" (causal-trace recompute marker) which
-			// isn't a recordable mutation — skip it. Cast through narrowed type
-			// after the discriminator check.
-			if (event.type === "derived") return;
-			const type = event.type as AuditEntry["type"];
-			if (!includeTypes.has(type)) return;
-			const path = event.path ?? "";
-			const entry: AuditEntry = {
-				seq: seq++,
-				timestamp_ns: event.timestamp_ns ?? monotonicNs(),
-				wall_clock_ns: wallClockNs(),
-				path,
-				type,
-			};
-			// Attribution + value enrichment.
-			const node = path ? safeNode(target, path) : undefined;
-			const lastMutation = node?.lastMutation;
-			if (lastMutation != null) entry.actor = lastMutation.actor;
-			if (type === "data") entry.value = (event as { data: unknown }).data;
-			if (type === "error") entry.error = (event as { data: unknown }).data;
-			const annotation = path ? safeAnnotation(target, path) : undefined;
-			if (annotation != null) entry.annotation = annotation;
-			if (filter != null && !filter(entry)) return;
-			this._log.append(entry);
-		});
-
-		this.addDisposer(() => {
-			offEvent();
-			handle.dispose();
-		});
-		this.addDisposer(() => this._log.disposeAllViews());
-	}
-
-	/** All entries currently in the ring (snapshot). */
-	all(): readonly AuditEntry[] {
-		return (this.entries.cache as readonly AuditEntry[] | undefined) ?? [];
-	}
-
-	/** Entries matching `path`. Order preserved. */
-	byNode(path: string): readonly AuditEntry[] {
-		return this.all().filter((e) => e.path === path);
-	}
-
-	/** Entries whose `actor.id` matches. Use `byActorType` for type filtering. */
-	byActor(actorId: string): readonly AuditEntry[] {
-		return this.all().filter((e) => e.actor?.id === actorId);
-	}
-
-	/** Entries whose `actor.type` matches (e.g. `"llm"`, `"human"`). */
-	byActorType(type: string): readonly AuditEntry[] {
-		return this.all().filter((e) => e.actor?.type === type);
-	}
-
-	/**
-	 * Entries with `timestamp_ns` in `[start_ns, end_ns)` (end exclusive).
-	 * Omit `end_ns` to query open-ended.
-	 */
-	byTimeRange(start_ns: number, end_ns?: number): readonly AuditEntry[] {
-		return this.all().filter((e) => {
-			if (e.timestamp_ns < start_ns) return false;
-			if (end_ns != null && e.timestamp_ns >= end_ns) return false;
-			return true;
-		});
-	}
-
-	/** Reference to the audited graph (escape hatch for tooling). */
-	get target(): Graph {
-		return this._target;
-	}
-}
-
-/**
- * Wraps any {@link Graph} with a reactive audit trail recording every event
- * matching `includeTypes` (default: data + error + complete + teardown).
- *
- * Each entry carries `seq`, `timestamp_ns` (monotonic), `wall_clock_ns`,
- * `path`, `type`, and — when available — `actor`, `value`, `error`, and the
- * `graph.trace()` reasoning annotation for the path.
- *
- * The returned graph mounts an `entries` node + `count` derived. Query
- * helpers (`byNode`, `byActor`, `byTimeRange`) operate on the cached
- * snapshot synchronously.
- */
-export function auditTrail(target: Graph, opts: AuditTrailOptions = {}): AuditTrailGraph {
-	return new AuditTrailGraph(target, opts);
-}
-
-// ---------------------------------------------------------------------------
-// policyGate (renamed from `policyEnforcer` per Tier 2.3 — joins the
-// gate-family disambiguation: `valve` (boolean) / `budgetGate` (numeric) /
-// `approvalGate` (human judgment) / `policyGate` (ABAC rules))
-// ---------------------------------------------------------------------------
-
-/** A single policy denial recorded by {@link PolicyGateGraph}. */
-export interface PolicyViolation {
-	timestamp_ns: number;
-	wall_clock_ns: number;
-	path: string;
-	actor: Actor;
-	action: GuardAction;
-	mode: "audit" | "enforce";
-	/** `"observed"` (audit mode after-the-fact) or `"blocked"` (enforce mode pre-write). */
-	result: "observed" | "blocked";
-}
-
-/** Options for {@link policyGate}. */
-export interface PolicyGateOptions {
-	name?: string;
-	graph?: GraphOptions;
-	/**
-	 * `"audit"` (default) — observe events and record would-be denials;
-	 * does not block writes. Audit mode requires `lastMutation` attribution
-	 * on the audited node — anonymous/internal writes (no `actor` passed,
-	 * unguarded node) are skipped silently because the policy cannot be
-	 * evaluated without an actor.
-	 *
-	 * `"enforce"` — push guards onto target nodes so disallowed writes
-	 * throw {@link GuardDenied}. Reverted on dispose.
-	 */
-	mode?: "audit" | "enforce";
-	/**
-	 * Restrict enforcement to specific node paths (qualified). When omitted,
-	 * applies to every node visible in `target.describe()` at construction
-	 * time (subgraphs are walked transitively) AND subscribes to the full
-	 * topology tree via {@link watchTopologyTree}, so nodes added to
-	 * `target` OR any transitively-mounted subgraph after construction are
-	 * guarded automatically (enforce mode only).
-	 *
-	 * Accepts a static `readonly string[]` or a reactive
-	 * `Node<readonly string[]>` (Tier 3.4 — F.9 reactive primitive carve-out).
-	 * When a `Node` is passed, the enforcer rebinds the guarded path set on
-	 * every emission: paths added to the new set get wrapped, paths removed
-	 * from the new set get released, and the audit-mode allow-list filter
-	 * uses the latest cached value. Static-array callers retain the current
-	 * "caller owns the path set" semantics.
-	 *
-	 * **Cost:** unrestricted mode runs `describe({detail:"minimal"})` once
-	 * at construction (O(N) over the graph tree) plus one topology
-	 * subscription per graph instance in the mount tree. Restricted mode
-	 * (static or reactive) skips both and disables `watchTopologyTree`
-	 * dynamic coverage — for reactive callers, the path-set Node is the
-	 * single source of truth for which paths are guarded.
-	 */
-	paths?: readonly string[] | Node<readonly string[]>;
-	/**
-	 * Ring-buffer cap for the violations topic. Default: 1000. Static
-	 * number only — reactive form is deferred pending TopicGraph reactive
-	 * `retainedLimit` support (see Tier 10.8 design follow-up in
-	 * `docs/optimizations.md`).
-	 */
-	violationsLimit?: number;
-}
-
-/**
- * Reactive ABAC enforcement layer. Policies are reactive — pass a
- * `Node<readonly PolicyRuleData[]>` to allow LLMs (or any reactive source)
- * to update them at runtime; the enforcer rebinds its internal
- * {@link NodeGuard} on every push.
- */
-export class PolicyGateGraph extends Graph {
-	readonly policies: Node<readonly PolicyRuleData[]>;
-	readonly violations: TopicGraph<PolicyViolation>;
-	readonly violationCount: Node<number>;
-	private readonly _target: Graph;
-	private readonly _mode: "audit" | "enforce";
-	private _currentGuard: NodeGuard;
-
-	constructor(
-		target: Graph,
-		policies: readonly PolicyRuleData[] | Node<readonly PolicyRuleData[]>,
-		opts: PolicyGateOptions,
-	) {
-		super(opts.name ?? `${target.name}_policy`, opts.graph);
-		this._target = target;
-		this._mode = opts.mode ?? "audit";
-
-		const policiesNode = isNode(policies)
-			? policies
-			: node<readonly PolicyRuleData[]>([], { name: "policies", initial: policies });
-		this.policies = policiesNode;
-		this.add(this.policies, { name: "policies" });
-
-		this.violations = new TopicGraph<PolicyViolation>("violations", {
-			retainedLimit: opts.violationsLimit ?? 1000,
-		});
-		this.mount("violations", this.violations);
-
-		this.violationCount = this.derived<number>(
-			"violationCount",
-			["violations::events"],
-			(batchData, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				return [(data[0] as readonly PolicyViolation[]).length];
-			},
-			{
-				meta: auditMeta("policy_violation_count"),
-			},
-		);
-		this.addDisposer(keepalive(this.violationCount));
-
-		// Factory-time seed (COMPOSITION-GUIDE §28): cache the latest rules
-		// inside a closure, refresh on each subscribe-pushed update, and read
-		// closure inside the guard so policy updates take effect immediately.
-		const initialRules = (policiesNode.cache as readonly PolicyRuleData[] | undefined) ?? [];
-		let latestRules: readonly PolicyRuleData[] = initialRules;
-		this._currentGuard = policyFromRules(latestRules);
-		const offPolicies = policiesNode.subscribe((msgs) => {
-			for (const m of msgs) {
-				if (m[0] === DATA) {
-					latestRules = (m[1] as readonly PolicyRuleData[] | undefined) ?? [];
-					this._currentGuard = policyFromRules(latestRules);
-				}
-			}
-		});
-		this.addDisposer(offPolicies);
-
-		// Resolve `paths` option to its three modes:
-		//   (a) undefined → dynamic coverage via watchTopologyTree
-		//   (b) static readonly string[] → caller owns the set
-		//   (c) Node<readonly string[]> → reactive set; rebind on each emission
-		// `latestPaths` is the closure-mirror of the current path set (or
-		// undefined for dynamic coverage). It is read by:
-		//   - the audit-mode observe callback (allow-list filter)
-		//   - the reactive-paths rebind subscription (diff against next set)
-		// Mirrors the `latestRules` pattern used for `policiesNode` above
-		// (COMPOSITION-GUIDE §28 factory-time seed).
-		const pathsOpt = opts.paths;
-		const pathsNode: Node<readonly string[]> | undefined = isNode(pathsOpt)
-			? (pathsOpt as Node<readonly string[]>)
-			: undefined;
-		// `pathsExplicit` mirrors the legacy "caller provided a path set" branch
-		// — true for both static-array and Node-of-array forms; false only when
-		// `opts.paths` is omitted (dynamic-coverage mode).
-		const pathsExplicit = pathsOpt != null;
-		const initialPaths: readonly string[] | undefined =
-			pathsNode != null
-				? ((pathsNode.cache as readonly string[] | undefined) ?? [])
-				: pathsExplicit
-					? [...(pathsOpt as readonly string[])]
-					: undefined;
-		// `latestPaths` is undefined ONLY in dynamic-coverage mode.
-		let latestPaths: readonly string[] | undefined = initialPaths;
-		// Initial sweep set for the enforce-mode wrap loop.
-		const paths = latestPaths ?? collectPaths(target);
-
-		// Audit-mode reactive-paths subscription. Enforce mode handles its own
-		// subscription (it also needs to diff old↔new to wrap/release guards);
-		// audit mode just needs `latestPaths` to track the latest cache so the
-		// allow-list filter stays current. Wired here, before the mode branch,
-		// so it runs in audit mode only — enforce mode wires its own
-		// rebinding subscription with diffing logic (DRY would require an
-		// always-on tracker that enforce mode then ignores; the small
-		// duplication keeps the enforce-mode branch self-contained).
-		if (this._mode !== "enforce" && pathsNode != null) {
-			const offAuditPaths = pathsNode.subscribe((msgs) => {
-				for (const m of msgs) {
-					if (m[0] !== DATA) continue;
-					latestPaths = (m[1] as readonly string[] | undefined) ?? [];
-				}
-			});
-			this.addDisposer(offAuditPaths);
-		}
-
-		if (this._mode === "enforce") {
-			// Track which paths are currently guarded so dynamic adds don't
-			// double-wrap and removed nodes release guard handles.
-			const restorers = new Map<string, () => void>();
-			const wrapAndPush = (path: string): void => {
-				if (restorers.has(path)) return;
-				const node = safeNode(target, path);
-				if (!(node instanceof NodeImpl)) return;
-				const pathGuard: NodeGuard = (actor, action) => {
-					const ok = this._currentGuard(actor, action);
-					if (!ok) {
-						this._publishViolation(actor, action, path, "blocked");
-					}
-					return ok;
-				};
-				restorers.set(path, node._pushGuard(pathGuard));
-			};
-			// Initial sweep: guard every path present at construction.
-			for (const path of paths) wrapAndPush(path);
-
-			// Reactive paths rebind: when `paths` is a Node, every DATA emission
-			// replaces `latestPaths` and diffs against the previous set —
-			// added paths get wrapped, removed paths release their guard. No
-			// imperative orchestration; the diff falls out of the closure-mirror
-			// + subscribe pattern (mirrors `policiesNode` above).
-			if (pathsNode != null) {
-				const offReactivePaths = pathsNode.subscribe((msgs) => {
-					for (const m of msgs) {
-						if (m[0] !== DATA) continue;
-						const next = (m[1] as readonly string[] | undefined) ?? [];
-						const nextSet = new Set(next);
-						const prevSet = new Set(latestPaths ?? []);
-						// Wrap rebind in `batch()` (qa D7) — guards are imperative
-						// graph mutations; if `paths` and `policies` co-emit in an
-						// outer batch (atomic config swap), each handler's mutations
-						// would otherwise unwind in arbitrary order, letting an
-						// in-flight write hit a half-rebound guard set. Batching
-						// coalesces release + wrap into a single deferred drain.
-						batch(() => {
-							// Release paths that fell out of the new set.
-							for (const p of prevSet) {
-								if (nextSet.has(p)) continue;
-								const r = restorers.get(p);
-								if (r != null) {
-									r();
-									restorers.delete(p);
-								}
-							}
-							// Wrap newly-added paths.
-							for (const p of nextSet) {
-								if (prevSet.has(p)) continue;
-								wrapAndPush(p);
-							}
-							latestPaths = next;
-						});
-					}
-				});
-				this.addDisposer(offReactivePaths);
-			}
-
-			// Dynamic coverage: when `paths` was NOT explicitly provided, follow
-			// the full topology tree (target + every transitively-mounted
-			// subgraph, including subgraphs mounted after construction) so late
-			// adds at any depth get guarded. `prefix` carries the qualified
-			// path-prefix from `target` to the emitter graph.
-			if (!pathsExplicit) {
-				const offTopology = watchTopologyTree(target, (event, emitter, prefix) => {
-					if (event.kind === "added") {
-						if (event.nodeKind === "node") {
-							wrapAndPush(`${prefix}${event.name}`);
-						} else {
-							// Mount added. Walk just the newly-mounted subgraph's local
-							// paths (scoped describe — O(M) in the mounted subtree)
-							// rather than re-describing the entire target tree. The
-							// emitter is the PARENT of the new mount; resolve the child
-							// via its `_mounts` map.
-							const child = emitter._mounts.get(event.name);
-							if (!(child instanceof Graph)) return;
-							const mountPrefix = `${prefix}${event.name}::`;
-							const localPaths = collectPaths(child);
-							for (const localPath of localPaths) {
-								// `localPath` is relative to `child`; qualify with the
-								// mount prefix so guard keys stay target-rooted.
-								wrapAndPush(
-									localPath === "" ? `${prefix}${event.name}` : `${mountPrefix}${localPath}`,
-								);
-							}
-						}
-					} else if (event.kind === "removed") {
-						// TEARDOWN already unhooks the guard; release bookkeeping so
-						// re-adds under the same qualified path re-wrap cleanly.
-						if (event.nodeKind === "node") {
-							const qp = `${prefix}${event.name}`;
-							const r = restorers.get(qp);
-							if (r != null) {
-								r();
-								restorers.delete(qp);
-							}
-						} else {
-							const mountQp = `${prefix}${event.name}`;
-							const mountPrefix = `${mountQp}::`;
-							for (const [p, r] of restorers) {
-								if (p === mountQp || p.startsWith(mountPrefix)) {
-									r();
-									restorers.delete(p);
-								}
-							}
-						}
-					}
-				});
-				this.addDisposer(offTopology);
-			} else {
-				// Restricted mode: subscribe to target.topology (own-graph only —
-				// explicit `paths` means caller owns the path set) so node removals
-				// release their restorers instead of leaking until enforcer dispose.
-				const offCleanup = target.topology.subscribe((msgs) => {
-					for (const m of msgs) {
-						if (m[0] !== DATA) continue;
-						const event = m[1] as TopologyEvent;
-						if (event.kind !== "removed" || event.nodeKind !== "node") continue;
-						const r = restorers.get(event.name);
-						if (r != null) {
-							r();
-							restorers.delete(event.name);
-						}
-					}
-				});
-				this.addDisposer(offCleanup);
-			}
-			this.addDisposer(() => {
-				for (const r of restorers.values()) r();
-				restorers.clear();
-			});
-		} else {
-			// Audit mode: observe writes, evaluate against current guard, record
-			// violations without blocking. Use the structured observe stream so
-			// `path` and `actor` attribution are supplied without per-node
-			// subscription bookkeeping. B9: unattributed writes no longer skip
-			// — the ObserveEvent always carries a well-formed `actor` (falling
-			// back to `DEFAULT_ACTOR` for anonymous/internal writes), so the
-			// policy is evaluated against every write.
-			const handle = target.observe({ timeline: true, structured: true });
-			const off = handle.onEvent((event) => {
-				if (event.type !== "data" && event.type !== "error") return;
-				const path = event.path ?? "";
-				if (!path) return;
-				// `latestPaths` is the closure-mirror of the (possibly reactive)
-				// path allow-list. Undefined = no restriction (dynamic-coverage
-				// mode); reactive callers see the filter rebind on each emission
-				// without re-creating the enforcer (Tier 3.4).
-				if (latestPaths != null && !latestPaths.includes(path)) return;
-				// Prefer the event-stamped actor (always populated for DATA/ERROR
-				// post-B9). Fall back to lastMutation for back-compat with any
-				// consumer stubbing observe events without the field.
-				const actor =
-					(event as { actor?: Actor }).actor ?? safeNode(target, path)?.lastMutation?.actor;
-				if (actor == null) return; // defensive — shouldn't happen post-B9
-				const action: GuardAction = "write";
-				if (this._currentGuard(actor, action)) return;
-				this._publishViolation(actor, action, path, "observed");
-			});
-			this.addDisposer(() => {
-				off();
-				handle.dispose();
-			});
-		}
-	}
-
-	private _publishViolation(
-		actor: Actor,
-		action: GuardAction,
-		path: string,
-		result: "observed" | "blocked",
-	): void {
-		this.violations.publish({
-			timestamp_ns: monotonicNs(),
-			wall_clock_ns: wallClockNs(),
-			path,
-			actor,
-			action,
-			mode: this._mode,
-			result,
-		});
-	}
-
-	/** Snapshot of recorded violations. */
-	all(): readonly PolicyViolation[] {
-		return this.violations.retained();
-	}
-
-	get mode(): "audit" | "enforce" {
-		return this._mode;
-	}
-
-	get target(): Graph {
-		return this._target;
-	}
-}
-
-/**
- * Wraps a {@link Graph} with reactive policy enforcement. Pass either a
- * static rule list or a {@link Node} of rules (LLM-updatable). Records
- * `PolicyViolation` entries to `violations` topic; in `"enforce"` mode also
- * pushes guards onto target nodes so disallowed writes throw.
- *
- * Self-tags via `g.tagFactory("policyGate", placeholderArgs(opts))` so
- * `graph.describe()` surfaces `factory: "policyGate"` provenance (Phase 2.5
- * DT5 ride-along, locked with the Tier 2.3 rename).
- */
-export function policyGate(
-	target: Graph,
-	policies: readonly PolicyRuleData[] | Node<readonly PolicyRuleData[]>,
-	opts: PolicyGateOptions = {},
-): PolicyGateGraph {
-	const g = new PolicyGateGraph(target, policies, opts);
-	// `placeholderArgs` walks `opts` for non-JSON fields (e.g. `policies` may
-	// be a Node when the caller wants live-updatable rules; `opts.graph` is
-	// `GraphOptions`). DT5 deferred tag; Tier 2.3 ride-along.
-	g.tagFactory("policyGate", placeholderArgs(opts as unknown as Record<string, unknown>));
-	return g;
-}
-
-// ---------------------------------------------------------------------------
-// complianceSnapshot
-// ---------------------------------------------------------------------------
-
-/** Options for {@link complianceSnapshot}. */
-export interface ComplianceSnapshotOptions {
-	audit?: AuditTrailGraph;
-	policies?: PolicyGateGraph;
-	/** Actor recorded as the snapshot taker. */
-	actor?: Actor;
-}
-
-/** Output of {@link complianceSnapshot}. JSON-serializable. */
-export interface ComplianceSnapshotResult {
-	format_version: 1;
-	timestamp_ns: number;
-	wall_clock_ns: number;
-	actor?: Actor;
-	graph: GraphPersistSnapshot;
-	audit?: { count: number; entries: AuditEntry[] };
-	policies?: {
-		mode: "audit" | "enforce";
-		rules: readonly PolicyRuleData[];
-		violations: readonly PolicyViolation[];
-	};
-	/**
-	 * Truncated SHA-256 hex (16 chars / ~64 bits) over a canonical encoding
-	 * of every field above (excluding `fingerprint` itself). Deterministic
-	 * across runs given identical inputs. Suitable for casual tamper-evidence
-	 * and content-addressed dedup; for full cryptographic strength, hash the
-	 * canonical JSON externally with Web Crypto / Node `crypto`.
-	 */
-	fingerprint: string;
-}
-
-/**
- * One-shot point-in-time export of a {@link Graph}'s state plus optional
- * audit + policy bundles. Returns a JSON-serializable object with a
- * deterministic truncated-SHA-256 {@link ComplianceSnapshotResult.fingerprint}
- * over the canonical payload for tamper-evidence in regulatory archival.
- *
- * **Cryptographic strength:** the fingerprint is truncated to 64 bits for
- * compact archival. Collision-resistant for casual integrity checks but NOT
- * sufficient for adversarial tamper-evidence — pair with a full SHA-256
- * (or stronger) over the canonical JSON when regulatory requirements demand
- * collision resistance.
- */
-export function complianceSnapshot(
-	target: Graph,
-	opts: ComplianceSnapshotOptions = {},
-): ComplianceSnapshotResult {
-	const result: Omit<ComplianceSnapshotResult, "fingerprint"> = {
-		format_version: 1,
-		timestamp_ns: monotonicNs(),
-		wall_clock_ns: wallClockNs(),
-		graph: target.snapshot() as GraphPersistSnapshot,
-	};
-	if (opts.actor != null) result.actor = opts.actor;
-	if (opts.audit != null) {
-		const entries = [...opts.audit.all()];
-		result.audit = { count: entries.length, entries };
-	}
-	if (opts.policies != null) {
-		const rules = (opts.policies.policies.cache as readonly PolicyRuleData[] | undefined) ?? [];
-		result.policies = {
-			mode: opts.policies.mode,
-			rules,
-			violations: [...opts.policies.all()],
-		};
-	}
-	const fingerprint = computeFingerprint(result);
-	return { ...result, fingerprint };
-}
-
-// ---------------------------------------------------------------------------
-// Internals
-// ---------------------------------------------------------------------------
-
-function isNode<T>(x: unknown): x is Node<T> {
-	return typeof x === "object" && x !== null && "subscribe" in (x as object);
-}
-
-function safeNode(target: Graph, path: string): Node | undefined {
-	try {
-		return target.node(path);
-	} catch {
-		// F-CATCH deliberate-exception: read-only introspection helper. Paths
-		// come from a describe()-derived walk that can race node removal; a
-		// missing node is a normal condition here, not an error to surface.
-		return undefined;
-	}
-}
-
-function safeAnnotation(target: Graph, path: string): string | undefined {
-	try {
-		return target.annotation(path);
-	} catch {
-		// F-CATCH deliberate-exception: same rationale as safeNode — a missing
-		// annotation during a best-effort audit walk is expected, not an error.
-		return undefined;
-	}
-}
-
-/**
- * Walks every locally-registered node path in `target`, descending through
- * mounted subgraphs. Returns qualified paths.
- */
-function collectPaths(target: Graph): string[] {
-	const described = target.describe({ detail: "minimal" });
-	return Object.keys(described.nodes);
-}
-
-/**
- * Stable canonical JSON → truncated SHA-256 hex fingerprint (16 hex chars,
- * ~64-bit). Uses the same vendored sync SHA-256 as `core/versioning.ts`
- * `defaultHash`, so cross-module fingerprints stay consistent.
- *
- * Canonicalization handles cycles (recursion-stack tracker), `undefined`,
- * `bigint`, `Map`, `Set`, `Date`, `RegExp`, and typed arrays via typed
- * markers — see {@link canonicalize}.
- *
- * **Note:** truncated to 16 hex chars (~64-bit) for compact archival. For
- * full 256-bit cryptographic strength, hash {@link complianceSnapshot} JSON
- * externally with Web Crypto / Node `crypto`.
- */
-function computeFingerprint(value: unknown): string {
-	// Pre-stringify our canonical form so `defaultHash`'s
-	// `canonicalizeForHash` (which rejects unsafe integers) only ever sees a
-	// JSON string. Compliance payloads carry `timestamp_ns` values that
-	// exceed `Number.MAX_SAFE_INTEGER` — JSON.stringify handles them fine,
-	// the hash function only cares about deterministic input bytes.
-	return defaultHash(JSON.stringify(canonicalize(value)));
-}
-
-/**
- * Cycle-safe canonical encoding. Uses a recursion-stack `Set` (push on
- * descent, pop on return) so legitimate DAG re-references are encoded as
- * themselves; only true cycles produce a `__circular: true` marker. Typed
- * markers preserve `undefined` / `bigint` / `Map` / `Set` / `Date` / `RegExp`
- * / typed-array information that bare `JSON.stringify` would silently drop
- * or collide with strings.
- */
-function canonicalize(value: unknown): unknown {
-	const stack = new Set<object>();
-	const walk = (v: unknown): unknown => {
-		if (v === undefined) return { __undefined: true };
-		if (v === null) return null;
-		const t = typeof v;
-		if (t === "bigint") return { __bigint: (v as bigint).toString() };
-		if (t !== "object") return v;
-		const obj = v as object;
-		if (stack.has(obj)) return { __circular: true };
-		stack.add(obj);
-		try {
-			if (Array.isArray(obj)) {
-				return (obj as unknown[]).map(walk);
-			}
-			if (obj instanceof Date) {
-				return { __date: obj.toISOString() };
-			}
-			if (obj instanceof RegExp) {
-				return { __regexp: { source: obj.source, flags: obj.flags } };
-			}
-			if (obj instanceof Map) {
-				const entries = [...(obj as Map<unknown, unknown>).entries()].map(([k, mv]) => [
-					walk(k),
-					walk(mv),
-				]);
-				return { __map: entries };
-			}
-			if (obj instanceof Set) {
-				const items = [...(obj as Set<unknown>)].map(walk);
-				return { __set: items };
-			}
-			if (ArrayBuffer.isView(obj)) {
-				const ta = obj as unknown as { length: number; [i: number]: number };
-				const arr: number[] = new Array(ta.length);
-				for (let i = 0; i < ta.length; i++) arr[i] = ta[i] ?? 0;
-				return { __typed_array: { ctor: obj.constructor.name, data: arr } };
-			}
-			const out: Record<string, unknown> = {};
-			for (const k of Object.keys(obj as Record<string, unknown>).sort()) {
-				out[k] = walk((obj as Record<string, unknown>)[k]);
-			}
-			return out;
-		} finally {
-			stack.delete(obj);
-		}
-	};
-	return walk(value);
-}
-
-// `explainPath` / `CausalChain` / `CausalStep` are exported from `graph/`
-// at module root; do not re-export here to keep the namespace boundary clean
-// and avoid duplicate-identifier issues in bundled .d.ts.
diff --git a/src/utils/inspect/index.ts b/src/utils/inspect/index.ts
deleted file mode 100644
index 7939ce46..00000000
--- a/src/utils/inspect/index.ts
+++ /dev/null
@@ -1,21 +0,0 @@
-/**
- * Inspect — graph observability primitives (Tier 9.1 γ-form γ-ii merge).
- *
- * Merges the former `patterns/audit/` and `patterns/lens/` folders into a
- * single domain. Sub-files preserve the legacy folder boundaries for clarity,
- * then export through this barrel.
- *
- * Building blocks (this barrel + sub-files):
- *  - `auditTrail` / `policyGate` / `complianceSnapshot` / `explainPath` —
- *    audit + policy + causal explainability primitives.
- *  - `graphLens` / `computeHealthReport` / `healthReportEqual` /
- *    `watchTopologyTree` — topology-driven health and flow views.
- *
- * The `inspect()` and `guardedExecution()` presets that compose these
- * primitives live in `presets/inspect/` (exported via `presets/index.js`).
- *
- * @module
- */
-
-export * from "./audit.js";
-export * from "./lens.js";
diff --git a/src/utils/inspect/lens.ts b/src/utils/inspect/lens.ts
deleted file mode 100644
index 152a8292..00000000
--- a/src/utils/inspect/lens.ts
+++ /dev/null
@@ -1,411 +0,0 @@
-/**
- * Reactive graph observability preset (Tier 5.3 reshape — Session A.4 lock).
- *
- * `graphLens(target)` is a thin compositor (~30 LOC of glue) over two
- * already-shipped reactive primitives:
- *
- * - `target.describe({ reactive: true })` — live topology snapshot.
- * - `target.observe({ reactive: true, tiers: ["data"] })` — coalesced data
- *   changesets per outermost batch flush.
- *
- * It returns three Nodes plus a dispose function:
- *
- * - `topology: Node<GraphDescribeOutput>` — the live describe snapshot,
- *   re-emitting on every settle of the target tree (structural change,
- *   error/complete/teardown transition).
- * - `health: Node<HealthReport>` — `{ok, problems[]}` aggregated from the
- *   live describe; `ok=false` when any node enters `"errored"` status,
- *   with `upstreamCause` walked backward through deps.
- * - `flow: Node<ReadonlyMap<string, FlowEntry>>` — per-path DATA counters
- *   accumulating as `target.observe({reactive: true, tiers: ["data"]})`
- *   delivers changesets. The map is reconciled against `topology` on each
- *   topology change so removed nodes drop their entries.
- *
- * Pre-Tier-5.3 shipped a `LensGraph` class with `stats` / `health` / `flow`
- * (as a `ReactiveMapBundle`) / `why(from, to)` / `flowEntryNode(...)`. The
- * surface collapsed because every concern was already a one-liner over
- * `describe({reactive:true})` + `observe({reactive:true, tiers})` once those
- * landed in Tier 1.5.1 / 1.5.2 — the class added no protocol-level concept,
- * just glue. Callers who need topology stats compose a derived over
- * `topology` directly; callers who need a causal chain call
- * `target.describe({ explain: { from, to }, reactive: true })`.
- *
- * The transitive topology-subscription helper {@link watchTopologyTree} is
- * re-exported here for downstream factories that need full-tree dynamic
- * coverage without taking a dep on `graph/`.
- *
- * @module
- */
-import { type Node, node, wallClockNs } from "@graphrefly/pure-ts/core";
-import {
-	keepalive,
-	type LensFlowChange,
-	type LensFlowChangePayload,
-	type ReactiveLogBundle,
-	reactiveLog,
-} from "@graphrefly/pure-ts/extra";
-import {
-	type Graph,
-	type GraphDescribeOutput,
-	type ObserveChangeset,
-	type ObserveEvent,
-	reachable,
-} from "@graphrefly/pure-ts/graph";
-import { domainMeta } from "../../base/meta/domain-meta.js";
-
-export { watchTopologyTree } from "@graphrefly/pure-ts/graph";
-
-// ---------------------------------------------------------------------------
-// Payload types
-// ---------------------------------------------------------------------------
-
-/** A single health problem entry. */
-export interface HealthProblem {
-	path: string;
-	/** V1 only reports `"errored"`. Future versions may add `"completed"`, `"disconnected"`. */
-	status: "errored";
-	/** First errored upstream ancestor along the dep chain, when one exists and is distinct from `path`. */
-	upstreamCause?: string;
-}
-
-/** Aggregate health snapshot. `ok=true` iff `problems.length === 0`. */
-export interface HealthReport {
-	ok: boolean;
-	problems: readonly HealthProblem[];
-}
-
-/** Per-path flow entry stored in the {@link GraphLensView.flow} map. */
-export interface FlowEntry {
-	path: string;
-	/** Cumulative DATA emissions observed since the lens activated. */
-	count: number;
-	/** Monotonic ns at the most recent DATA emission for this path, or `null` if none yet. */
-	lastUpdate_ns: number | null;
-}
-
-/**
- * Options for {@link graphLens}.
- *
- * Shape mirrors `reactiveMap`/`pubsub`'s `mutationLog` option so the
- * delta-companion ergonomics are uniform across structures.
- */
-export interface GraphLensOptions {
-	/**
-	 * Enable the {@link GraphLensView.flowMutations} delta companion log.
-	 * `true` for defaults, or `{ maxSize, name }` to bound / name the
-	 * underlying `reactiveLog`. Off by default — zero overhead (no buffer
-	 * accumulation, no companion node) when omitted.
-	 */
-	mutations?: true | { maxSize?: number; name?: string };
-}
-
-/** Output of {@link graphLens}. */
-export interface GraphLensView {
-	/** Live describe snapshot. Re-emits on structural change AND status transitions. */
-	topology: Node<GraphDescribeOutput>;
-	/** Live `{ok, problems[]}`. Aggregated from `topology`; equality-deduped. */
-	health: Node<HealthReport>;
-	/** Per-path DATA counter map. Re-emits per outermost batch flush. */
-	flow: Node<ReadonlyMap<string, FlowEntry>>;
-	/**
-	 * Delta companion to {@link flow}. Present iff {@link GraphLensOptions.mutations}
-	 * was configured. Each per-path `tick` (a DATA emission incremented
-	 * the counter) and each `evict` (a path dropped during topology
-	 * reconciliation) appends one typed {@link LensFlowChange} record in
-	 * the same batch frame as the corresponding `flow` snapshot — an
-	 * O(1)-per-event peer of the snapshot, mirroring `reactiveMap`'s
-	 * `mutationLog`. Lets consumers tail *what changed* without diffing
-	 * successive `flow` map snapshots.
-	 */
-	flowMutations?: ReactiveLogBundle<LensFlowChange>;
-	/**
-	 * Tear down the underlying `describe({reactive:true})` subscription.
-	 * The `flow` node activates lazily; subscribing-then-unsubscribing reclaims
-	 * its observe stream automatically. Call `dispose()` once when finished.
-	 */
-	dispose(): void;
-}
-
-// ---------------------------------------------------------------------------
-// Pure helpers (exported for testing / composition)
-// ---------------------------------------------------------------------------
-
-/** Build a `HealthReport` from a fresh `GraphDescribeOutput`. */
-export function computeHealthReport(described: GraphDescribeOutput): HealthReport {
-	const problems: HealthProblem[] = [];
-	for (const [path, desc] of Object.entries(described.nodes)) {
-		if (desc.status !== "errored") continue;
-		const entry: HealthProblem = { path, status: "errored" };
-		// Walk upstream to find the first errored ancestor (if any) distinct from `path`.
-		// Explicit empty options disambiguates the overload (otherwise both match
-		// and TS picks the `withDetail:true` signature first).
-		const upstream = reachable(described, path, "upstream", {});
-		for (const p of upstream) {
-			if (p === path) continue;
-			if (described.nodes[p]?.status === "errored") {
-				entry.upstreamCause = p;
-				break;
-			}
-		}
-		problems.push(entry);
-	}
-	problems.sort((a, b) => (a.path < b.path ? -1 : a.path > b.path ? 1 : 0));
-	return { ok: problems.length === 0, problems };
-}
-
-/** Structural equality for {@link HealthReport} — used as the `health` derived's `equals`. */
-export function healthReportEqual(a: HealthReport, b: HealthReport): boolean {
-	if (a.ok !== b.ok) return false;
-	if (a.problems.length !== b.problems.length) return false;
-	for (let i = 0; i < a.problems.length; i++) {
-		const x = a.problems[i]!;
-		const y = b.problems[i]!;
-		if (x.path !== y.path) return false;
-		if (x.status !== y.status) return false;
-		if (x.upstreamCause !== y.upstreamCause) return false;
-	}
-	return true;
-}
-
-// ---------------------------------------------------------------------------
-// graphLens preset
-// ---------------------------------------------------------------------------
-
-/**
- * Reactive observability preset over a target {@link Graph}.
- *
- * @param target - The graph to observe.
- *
- * @example
- * ```ts
- * const g = new Graph("app");
- * g.add(state(0, { name: "counter" }), { name: "counter" });
- *
- * const lens = graphLens(g);
- * lens.topology.subscribe((msgs) => console.log("topology:", msgs));
- * lens.health.subscribe((msgs) => console.log("health:", msgs));
- * lens.flow.subscribe((msgs) => {
- *   for (const [type, payload] of msgs) {
- *     if (type === DATA) console.log("flow map size:", (payload as ReadonlyMap<string, FlowEntry>).size);
- *   }
- * });
- *
- * // Causal chains: use the underlying primitive directly — `graphLens` no
- * // longer wraps it, since `graph.describe({ explain: {...}, reactive: true })`
- * // already provides everything the old `lens.why()` did.
- * const why = g.describe({
- *   explain: { from: "counter", to: "consumer" },
- *   reactive: true,
- * });
- *
- * // Tear down when done.
- * lens.dispose();
- * ```
- *
- * @category observability
- */
-export function graphLens(target: Graph, opts: GraphLensOptions = {}): GraphLensView {
-	const mutLogOpt = opts.mutations;
-	const mutationsEnabled = mutLogOpt != null;
-	// Closure buffer: the `flow` derived fills this per wave with the
-	// tick/evict deltas it just applied; a sibling effect drains it into
-	// `flowMutations` in the SAME wave (sanctioned side-effect-in-effect
-	// pattern — mirrors the bridge.ts `topic.publish`-from-effect and
-	// reactiveMap's pending-changes-flushed-in-the-snapshot-batch shape).
-	// Single source of truth for the diff stays the `flow` fn.
-	const pendingFlowChanges: LensFlowChangePayload[] = [];
-	// Hoisted (QA-P3) so the `flow` fn's buffer push can short-circuit
-	// once `dispose()` ran — a still-warm `flow` (external subscriber)
-	// must not keep growing `pendingFlowChanges` with no drain alive.
-	let disposed = false;
-
-	const topologyHandle = target.describe({
-		reactive: true,
-		detail: "standard",
-		reactiveName: "graphLens.topology",
-	});
-	const topology = topologyHandle.node;
-
-	const health = node<HealthReport>(
-		[topology],
-		(batchData, actions, ctx) => {
-			const data = batchData.map((batch, i) =>
-				batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-			);
-			actions.emit(computeHealthReport(data[0] as GraphDescribeOutput));
-		},
-		{
-			name: "graphLens.health",
-			describeKind: "derived",
-			equals: healthReportEqual,
-			meta: domainMeta("lens", "health"),
-		},
-	);
-	// `topology` is already kept alive by `_describeReactive`'s internal
-	// keepalive; `health` needs its own so the derived stays warm even if
-	// the consumer subscribes lazily.
-	const stopHealthKeep = keepalive(health);
-
-	// `flow` accumulates per-path counters across emissions. Closure-mirror
-	// (COMPOSITION-GUIDE §28) holds the canonical map; the derived returns a
-	// fresh ReadonlyMap projection per emit so consumers never observe an
-	// in-place mutation. Topology drives reconciliation: paths that disappear
-	// from the describe drop their counter entry.
-	//
-	// `lastAppliedFlush_ns` guards against double-applying the same changeset
-	// when topology re-emits without a new dataFlow event (e.g. a node remove
-	// re-fires `topology` while `dataFlow.cache` still holds the previous
-	// changeset by reference). Using the monotonic `flushedAt_ns` cursor (qa
-	// G2A — EC4 fix) is more robust than ref-comparison: an empty changeset
-	// re-emitted with a fresh object identity but the same `flushedAt_ns`
-	// won't trigger a stale-events replay, and a genuinely-new changeset
-	// always advances the cursor.
-	const flowMap = new Map<string, FlowEntry>();
-	let lastAppliedFlush_ns = -1;
-	const dataFlow = target.observe({ reactive: true, tiers: ["data"] });
-	const flow = node<ReadonlyMap<string, FlowEntry>>(
-		[dataFlow, topology],
-		(batchData, actions, ctx) => {
-			const data = batchData.map((batch, i) =>
-				batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-			);
-			const changeset = data[0];
-			const described = data[1];
-			const c = changeset as ObserveChangeset | undefined;
-			const desc = described as GraphDescribeOutput | undefined;
-
-			// Apply NEW changeset events first so a freshly-emitted node-remove
-			// observed below cleanly drops the entry. (If we reconciled first
-			// then applied, an event referencing a path the topology had already
-			// dropped would re-create the entry only to be wiped on the next
-			// topology re-emit — order events-then-topology to avoid that.)
-			//
-			// Skip when `events.length === 0`: an empty changeset has no work
-			// to do. The cursor advances anyway so a future identical-content
-			// changeset (different ref, same flushedAt_ns) is also skipped.
-			if (c != null && c.flushedAt_ns > lastAppliedFlush_ns) {
-				lastAppliedFlush_ns = c.flushedAt_ns;
-				for (const event of c.events as readonly ObserveEvent[]) {
-					if (event.type !== "data") continue;
-					const path = event.path;
-					if (path == null || path === "") continue;
-					const prior = flowMap.get(path);
-					const count = (prior?.count ?? 0) + 1;
-					flowMap.set(path, {
-						path,
-						count,
-						lastUpdate_ns: c.flushedAt_ns,
-					});
-					if (mutationsEnabled && !disposed) {
-						pendingFlowChanges.push({ kind: "tick", path, count });
-					}
-				}
-			}
-
-			// Reconcile against current topology — drop entries whose paths
-			// no longer exist in the describe.
-			if (desc != null && flowMap.size > 0) {
-				const valid = new Set(Object.keys(desc.nodes));
-				for (const k of [...flowMap.keys()]) {
-					if (!valid.has(k)) {
-						flowMap.delete(k);
-						if (mutationsEnabled && !disposed) {
-							pendingFlowChanges.push({ kind: "evict", path: k });
-						}
-					}
-				}
-			}
-
-			// Snapshot — consumers receive a frozen view.
-			actions.emit(new Map(flowMap) as ReadonlyMap<string, FlowEntry>);
-		},
-		{
-			name: "graphLens.flow",
-			describeKind: "derived",
-			meta: domainMeta("lens", "flow"),
-		},
-	);
-	// ── flow delta companion (Phase 14 — last DS-14-substrate thread) ────────
-	// `flow` is otherwise just a snapshot map; tailing *what changed*
-	// previously required diffing successive map snapshots. The companion
-	// surfaces each per-path `tick` / `evict` as a typed `LensFlowChange`,
-	// O(1) per event, in the same batch frame as the snapshot — mirroring
-	// `reactiveMap`/`pubsub` `mutationLog`. Opt-in (zero overhead off).
-	//
-	// QA-P1: the drain effect is created + kept alive BEFORE
-	// `keepalive(flow)` (below) so it is subscribed to `flow` before
-	// `flow`'s first activation. Otherwise `keepalive(flow)`'s
-	// push-on-subscribe would replay cached changeset(s) into
-	// `pendingFlowChanges` before the drain exists, collapsing pre-wiring
-	// deltas into the drain's first flush and breaking the "same batch
-	// frame as the snapshot" contract (COMPOSITION-GUIDE §2 — wire
-	// observers before emitters).
-	let flowMutations: ReactiveLogBundle<LensFlowChange> | undefined;
-	let stopFlowMutKeep: (() => void) | undefined;
-	if (mutLogOpt != null) {
-		const log = reactiveLog<LensFlowChange>(undefined, {
-			name:
-				mutLogOpt === true
-					? "graphLens.flowMutations"
-					: (mutLogOpt.name ?? "graphLens.flowMutations"),
-			maxSize: mutLogOpt === true ? undefined : mutLogOpt.maxSize,
-		});
-		flowMutations = log;
-		let mutVersion = 0;
-		// Effect dependent on `flow`: it fires in the SAME wave `flow`
-		// emits, so the appended records coalesce into the same outermost
-		// batch flush as the snapshot (the `mutationLog` "same batch
-		// frame" contract). Side-effecting append from an `effect` node is
-		// the sanctioned home (cf. bridge.ts `topic.publish`-from-effect);
-		// `flow`'s fn stays the single source of the diff.
-		const flowMutationsDrain = node(
-			[flow],
-			(_batchData, _actions, _ctx) => {
-				if (pendingFlowChanges.length === 0) return;
-				const drained = pendingFlowChanges.splice(0);
-				for (const change of drained) {
-					log.append({
-						structure: "lensFlow",
-						version: ++mutVersion,
-						t_ns: wallClockNs(),
-						lifecycle: "data",
-						change,
-					});
-				}
-			},
-			{
-				name: "graphLens.flowMutationsDrain",
-				describeKind: "effect",
-				meta: domainMeta("lens", "flowMutations"),
-			},
-		);
-		stopFlowMutKeep = keepalive(flowMutationsDrain);
-	}
-
-	// AFTER the drain is wired (QA-P1) so `flow`'s push-on-subscribe
-	// reaches the drain in the same wave.
-	const stopFlowKeep = keepalive(flow);
-
-	return {
-		topology,
-		health,
-		flow,
-		...(flowMutations ? { flowMutations } : {}),
-		dispose() {
-			if (disposed) return;
-			disposed = true;
-			stopFlowMutKeep?.();
-			// QA-P2: release the reactiveLog bundle's own internal
-			// keepalives (view caches / lastValue / nested mutLog), not
-			// just the drain effect's keepalive.
-			flowMutations?.dispose();
-			// QA-P3: a still-warm `flow` (external subscriber) keeps
-			// running its fn post-dispose; the buffer push is gated on
-			// `!disposed`, but drop any residue so it can't be replayed.
-			pendingFlowChanges.length = 0;
-			stopFlowKeep();
-			stopHealthKeep();
-			topologyHandle.dispose();
-		},
-	};
-}
diff --git a/src/utils/job-queue/index.ts b/src/utils/job-queue/index.ts
deleted file mode 100644
index 21a38754..00000000
--- a/src/utils/job-queue/index.ts
+++ /dev/null
@@ -1,857 +0,0 @@
-/**
- * Job queue patterns (roadmap §4.2).
- *
- * Queue / flow primitives modeled as graph factories:
- * - `jobQueue()` — claim/ack/nack workflow with reactive depth.
- * - `jobFlow()` — multi-stage queue chain.
- *
- * Topic / subscription / hub primitives live in `patterns/messaging`.
- */
-
-import {
-	batch,
-	DATA,
-	ERROR,
-	type Node,
-	node,
-	placeholderArgs,
-	wallClockNs,
-} from "@graphrefly/pure-ts/core";
-import type { AppendLogStorageTier } from "@graphrefly/pure-ts/extra";
-import {
-	fromAny,
-	keepalive,
-	type NodeInput,
-	type ReactiveLogBundle,
-	reactiveList,
-	reactiveLog,
-	reactiveMap,
-} from "@graphrefly/pure-ts/extra";
-import { Graph, type GraphOptions } from "@graphrefly/pure-ts/graph";
-import { domainMeta } from "../../base/meta/domain-meta.js";
-import {
-	type BaseAuditRecord,
-	bumpCursor,
-	createAuditLog,
-	mutate,
-	type ReadonlyAuditLog,
-	readonlyAuditLog,
-	registerCursor,
-} from "../../base/mutation/index.js";
-
-const DEFAULT_MAX_PER_PUMP = 256;
-const DEFAULT_COMPLETED_RETAINED_LIMIT = 1024;
-
-function requireNonNegativeInt(value: number, label: string): number {
-	if (!Number.isFinite(value) || !Number.isInteger(value) || value < 0) {
-		throw new Error(`${label} must be a non-negative integer`);
-	}
-	return value;
-}
-
-function jobQueueMeta(kind: string, extra?: Record<string, unknown>): Record<string, unknown> {
-	return domainMeta("job_queue", kind, extra);
-}
-
-export type JobState = "queued" | "inflight";
-
-export type JobEnvelope<T> = {
-	id: string;
-	payload: T;
-	attempts: number;
-	metadata: Readonly<Record<string, unknown>>;
-	state: JobState;
-};
-
-/** Audit record for a job-queue mutation (Audit 2 cross-cutting). */
-export type JobEventAction = "enqueue" | "claim" | "ack" | "nack" | "remove";
-
-export interface JobEvent<T = unknown> extends BaseAuditRecord {
-	readonly action: JobEventAction;
-	readonly id: string;
-	readonly attempts?: number;
-	readonly payload?: T;
-	/**
-	 * The failure cause for a no-requeue `"nack"` (F-CATCH D-3). Present only
-	 * when a job was nack'd-without-requeue because its work threw
-	 * synchronously or its result Node emitted `ERROR`. Without this, a failed
-	 * job is observable as a `"nack"` event but the *reason* it failed is
-	 * unrecoverable from the event stream. Carries the raw thrown value /
-	 * ERROR payload (not normalized) so callers keep full fidelity.
-	 *
-	 * Caveats: a thrown `undefined` (legal but pathological) is not recorded —
-	 * it carries no diagnostic payload and the `"nack"` action itself already
-	 * surfaces the failure. And like {@link JobEvent.payload}, a raw `Error` is
-	 * not JSON-round-trippable, so keyed-storage codecs wired via
-	 * `attachEventStorage` should normalize this field (e.g. capture
-	 * `message`/`stack`) before serializing.
-	 */
-	readonly error?: unknown;
-}
-
-/** Recommended `keyOf` for keyed-storage adapters (Audit 2 #7). */
-export const jobEventKeyOf = <T>(e: JobEvent<T>): string => e.action;
-
-export type JobQueueOptions = {
-	graph?: GraphOptions;
-};
-
-export class JobQueueGraph<T> extends Graph {
-	private readonly _pending;
-	private readonly _jobs;
-	private readonly _seqCursor: Node<number>;
-	readonly pending: Node<readonly string[]>;
-	readonly jobs: Node<ReadonlyMap<string, JobEnvelope<T>>>;
-	readonly depth: Node<number>;
-	/** Audit log of every queue mutation (Audit 2). */
-	readonly events: ReactiveLogBundle<JobEvent<T>>;
-	/**
-	 * Read-only view of {@link JobQueueGraph.events} — Audit 2 `.audit`
-	 * duplication; M7 (cannot mutate the canonical log via the alias).
-	 */
-	readonly audit: ReadonlyAuditLog<JobEvent<T>>;
-
-	// Tier 8 / COMPOSITION-GUIDE §35: mutate wrappers for the four
-	// single-record mutation methods. Assigned in the constructor (NOT via
-	// class-field initializers) because field initializers run before the
-	// constructor body — `this.events` and `this._seqCursor` aren't ready yet.
-	// `claim` stays inline because it emits one record per claimed job.
-	private readonly _enqueueImpl: (
-		payload: T,
-		opts: { id?: string; metadata?: Record<string, unknown> },
-	) => string;
-	private readonly _ackImpl: (id: string, job: JobEnvelope<T>) => void;
-	private readonly _nackImpl: (
-		id: string,
-		job: JobEnvelope<T>,
-		requeue: boolean,
-		error?: unknown,
-	) => void;
-	private readonly _removeByIdImpl: (id: string, job: JobEnvelope<T>) => void;
-
-	constructor(name: string, opts: JobQueueOptions = {}) {
-		super(name, opts.graph);
-		this._pending = reactiveList<string>([], { name: "pending" });
-		this._jobs = reactiveMap<string, JobEnvelope<T>>({ name: "jobs" });
-		this.pending = this._pending.items;
-		this.jobs = this._jobs.entries;
-		this.add(this.pending, { name: "pending" });
-		this.add(this.jobs, { name: "jobs" });
-		this.depth = node(
-			[this.pending],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as readonly string[]).length);
-			},
-			{
-				name: "depth",
-				describeKind: "derived",
-				meta: jobQueueMeta("queue_depth"),
-				initial: 0,
-			},
-		);
-		this.add(this.depth, { name: "depth" });
-		this.addDisposer(keepalive(this.depth));
-
-		this.events = createAuditLog<JobEvent<T>>({
-			name: "events",
-			retainedLimit: 1024,
-			graph: this,
-		});
-		this.audit = readonlyAuditLog(this.events);
-		this._seqCursor = registerCursor(this, "seq", 0);
-
-		// `freeze: false` everywhere because the payload may be large and
-		// per-mutation cost matters on hot paths. mutate bumps `seq` via
-		// the registered cursor BEFORE the action runs, so action bodies that
-		// need the just-bumped value (e.g. enqueue's auto-id) read
-		// `this._seqCursor.cache`.
-		this._enqueueImpl = mutate<
-			[T, { id?: string; metadata?: Record<string, unknown> }],
-			string,
-			JobEvent<T>
-		>(
-			(payload, enqueueOpts): string => {
-				const seq = this._seqCursor.cache as number;
-				const id = enqueueOpts.id ?? `${this.name}-${seq}`;
-				if (this._jobs.get(id) !== undefined) {
-					throw new Error(`jobQueue("${this.name}"): duplicate job id "${id}"`);
-				}
-				const job: JobEnvelope<T> = {
-					id,
-					payload,
-					attempts: 0,
-					metadata: Object.freeze({ ...(enqueueOpts.metadata ?? {}) }),
-					state: "queued",
-				};
-				this._jobs.set(id, job);
-				this._pending.append(id);
-				return id;
-			},
-			{
-				frame: "inline",
-				log: this.events,
-				seq: this._seqCursor,
-				freeze: false,
-				onSuccessRecord: ([payload], id, { t_ns, seq }) => ({
-					action: "enqueue",
-					id,
-					payload,
-					t_ns,
-					seq: seq ?? 0,
-				}),
-			},
-		);
-
-		this._ackImpl = mutate<[string, JobEnvelope<T>], void, JobEvent<T>>(
-			(id, _job): void => {
-				this._jobs.delete(id);
-			},
-			{
-				frame: "inline",
-				log: this.events,
-				seq: this._seqCursor,
-				freeze: false,
-				onSuccessRecord: ([id, job], _r, { t_ns, seq }) => ({
-					action: "ack",
-					id,
-					attempts: job.attempts,
-					t_ns,
-					seq: seq ?? 0,
-				}),
-			},
-		);
-
-		this._nackImpl = mutate<[string, JobEnvelope<T>, boolean, unknown], void, JobEvent<T>>(
-			(id, job, requeue, _error): void => {
-				if (requeue) {
-					this._jobs.set(id, { ...job, state: "queued" });
-					this._pending.append(id);
-				} else {
-					this._jobs.delete(id);
-				}
-			},
-			{
-				frame: "inline",
-				log: this.events,
-				seq: this._seqCursor,
-				freeze: false,
-				onSuccessRecord: ([id, job, requeue, error], _r, { t_ns, seq }) => ({
-					action: "nack",
-					id,
-					attempts: job.attempts,
-					t_ns,
-					seq: seq ?? 0,
-					// F-CATCH D-3: surface the failure cause on the no-requeue
-					// (terminal-failure) nack only. A requeue nack is a retry,
-					// not a failure, so it carries no error.
-					...(!requeue && error !== undefined ? { error } : {}),
-				}),
-			},
-		);
-
-		this._removeByIdImpl = mutate<[string, JobEnvelope<T>], void, JobEvent<T>>(
-			(id, job): void => {
-				if (job.state === "queued") {
-					const pending = this.pending.cache as readonly string[];
-					const idx = pending.indexOf(id);
-					if (idx >= 0) this._pending.pop(idx);
-				}
-				this._jobs.delete(id);
-			},
-			{
-				frame: "inline",
-				log: this.events,
-				seq: this._seqCursor,
-				freeze: false,
-				onSuccessRecord: ([id, job], _r, { t_ns, seq }) => ({
-					action: "remove",
-					id,
-					attempts: job.attempts,
-					t_ns,
-					seq: seq ?? 0,
-				}),
-			},
-		);
-	}
-
-	/**
-	 * Wire append-log storage tiers (Audit 4). Returns a disposer.
-	 *
-	 * Named `attachEventStorage` to avoid colliding with {@link Graph.attachSnapshotStorage}.
-	 */
-	attachEventStorage(tiers: readonly AppendLogStorageTier<JobEvent<T>>[]): () => void {
-		return this.events.attachStorage(tiers);
-	}
-
-	enqueue(payload: T, opts: { id?: string; metadata?: Record<string, unknown> } = {}): string {
-		return this._enqueueImpl(payload, opts);
-	}
-
-	claim(limit = 1): readonly JobEnvelope<T>[] {
-		const max = requireNonNegativeInt(limit, "job queue claim limit");
-		if (max === 0) return [];
-		const out: JobEnvelope<T>[] = [];
-		while (out.length < max) {
-			const ids = this.pending.cache as readonly string[];
-			if (ids.length === 0) break;
-			const id = this._pending.pop(0);
-			const job = this._jobs.get(id);
-			if (!job || job.state !== "queued") continue;
-			const inflight: JobEnvelope<T> = {
-				...job,
-				state: "inflight",
-				attempts: job.attempts + 1,
-			};
-			this._jobs.set(id, inflight);
-			out.push(inflight);
-			// claim emits one audit record per claimed job; mutate wraps a
-			// single call → single record, so claim stays inline and bumps the
-			// cursor directly via the shared `bumpCursor` helper.
-			this.events.append({
-				action: "claim",
-				id,
-				attempts: inflight.attempts,
-				t_ns: wallClockNs(),
-				seq: bumpCursor(this._seqCursor),
-			});
-		}
-		return out;
-	}
-
-	ack(id: string): boolean {
-		const job = this._jobs.get(id);
-		if (!job || job.state !== "inflight") return false;
-		this._ackImpl(id, job);
-		return true;
-	}
-
-	/**
-	 * Negatively-acknowledge an inflight job.
-	 *
-	 * @param opts.requeue - `true` (default) returns the job to the queue for
-	 *   retry; `false` drops it permanently (terminal failure).
-	 * @param opts.error - Optional failure cause for a `requeue: false` nack.
-	 *   Recorded on the emitted `"nack"` {@link JobEvent} as `error` so the
-	 *   reason a job failed is recoverable from the event stream (F-CATCH
-	 *   D-3). Ignored when `requeue` is `true` (a retry is not a failure).
-	 */
-	nack(id: string, opts: { requeue?: boolean; error?: unknown } = {}): boolean {
-		const job = this._jobs.get(id);
-		if (!job || job.state !== "inflight") return false;
-		this._nackImpl(id, job, opts.requeue ?? true, opts.error);
-		return true;
-	}
-
-	/**
-	 * Remove a job by id regardless of its current state. Returns `true` if
-	 * the job existed and was removed, `false` if no job has this id.
-	 *
-	 * `ack` only works on inflight; `nack` only works on inflight.
-	 * `removeById` is the state-agnostic escape hatch — useful for
-	 * audit/observability layers that enqueue but never claim, and need to
-	 * finalize a job when an external decision (e.g. harness verify
-	 * outcome) resolves it. Distinct name from the inherited
-	 * {@link Graph.remove}, which removes a mounted child subgraph by path.
-	 *
-	 * When the job is in `queued` state, its id is also pulled from the
-	 * `pending` list — depth + pending snapshot stay consistent.
-	 */
-	removeById(id: string): boolean {
-		const job = this._jobs.get(id);
-		if (!job) return false;
-		this._removeByIdImpl(id, job);
-		return true;
-	}
-
-	/**
-	 * Subscribe to a Node and enqueue each DATA payload into this queue.
-	 * Returns a disposer that stops consuming when called.
-	 *
-	 * Used internally by {@link JobFlowGraph} for stage-to-stage wiring but
-	 * also useful for users wiring an external source into a job queue.
-	 *
-	 * @param source - Node whose DATA values are enqueued.
-	 * @param opts - Optional enqueue options (id generator, metadata prefix).
-	 */
-	consumeFrom(
-		source: Node<T>,
-		opts?: {
-			metadata?: Record<string, unknown>;
-		},
-	): () => void {
-		return source.subscribe((msgs) => {
-			for (const m of msgs) {
-				if (m[0] !== DATA) continue;
-				const payload = m[1] as T;
-				this.enqueue(payload, opts ? { metadata: opts.metadata } : undefined);
-			}
-		});
-	}
-}
-
-// ── StageDef ─────────────────────────────────────────────────────────────
-
-/**
- * Work function for a job flow stage. Receives the full job envelope and
- * an optional per-claim options object carrying an `AbortSignal`; returns
- * a `NodeInput<T>` — raw value (sync), Promise (async), or Node (composed
- * pipeline). `fromAny` coerces any of these shapes.
- *
- * On error / rejection: the stage nacks the job (no requeue by default).
- *
- * **Per-claim signal (Tier 6.5 2.5b, 2026-04-29).** The pump mints an
- * `AbortController` per claim and supplies its `signal` via `opts`. The
- * signal aborts when (a) the result node settles (first DATA / first
- * ERROR — auto-cleanup after the pump captures), OR (b) the pump itself
- * tears down (e.g. parent Graph `destroy()`). User-supplied work fns that
- * do long-running async (HTTP, LLM streams, evaluator subgraphs) can
- * forward this signal into `fetch({ signal })`, `adapter.invoke({ signal
- * })`, etc. for cooperative cancellation. Sync work fns ignore `opts` —
- * the second arg is optional, no behavior change for legacy callers.
- *
- * Mirrors the `LLMInvokeOptions.signal` / `apply(item, { signal })` /
- * tool-handler `(args, { signal })` precedents — same shape across the
- * library's user-callback boundaries.
- */
-export type WorkFn<T> = (job: JobEnvelope<T>, opts?: { signal: AbortSignal }) => NodeInput<T>;
-
-/**
- * Stage definition for {@link JobFlowGraph}. Either a bare name string
- * (no work hook, pure pass-through) or a full definition object.
- */
-export type StageDef<T> =
-	| string
-	| {
-			name: string;
-			work?: WorkFn<T>;
-			handlerVersion?: { id: string; version: string | number };
-			/**
-			 * Per-stage cap on `claim → work → ack` cycles per pump tick.
-			 * Overrides {@link JobFlowOptions.maxPerPump} for this stage. Useful
-			 * when stages have asymmetric cost (e.g. an LLM-execute stage capped
-			 * at 4 concurrent calls while a cheap verify stage runs unbounded).
-			 *
-			 * Falls back to the top-level `JobFlowOptions.maxPerPump`, which in
-			 * turn falls back to `DEFAULT_MAX_PER_PUMP` (256).
-			 */
-			maxPerPump?: number;
-			/**
-			 * Per-stage cap on TOTAL concurrent inflight claims (Tier 6.5 3.1,
-			 * 2026-04-29). Distinct from {@link maxPerPump}: `maxPerPump` caps
-			 * claims per pump tick, while `maxInflight` caps the number of
-			 * unsettled in-flight claims at any moment across all ticks. Use
-			 * for rigorous LLM cost ceilings (e.g. "no more than 4 concurrent
-			 * adapter.invoke calls regardless of pending depth").
-			 *
-			 * When set, the stage mounts an internal `state(0)` counter as a
-			 * pump dep so the pump re-fires on each settle — pending items
-			 * resume claiming as soon as inflight drops below the cap.
-			 *
-			 * Unset (default): unbounded inflight, gated only by `maxPerPump`.
-			 */
-			maxInflight?: number;
-	  };
-
-export type JobFlowOptions<T = unknown> = {
-	graph?: GraphOptions;
-	/**
-	 * Stage definitions. Each stage is either a bare name string (pure
-	 * pass-through) or a `{ name, work?, handlerVersion?, maxPerPump? }` object.
-	 *
-	 * For back-compat, `string[]` values behave as stages with no work hook.
-	 */
-	stages?: readonly StageDef<T>[];
-	/**
-	 * Default cap on claims per pump tick across all stages. Per-stage
-	 * overrides can be set on each {@link StageDef.maxPerPump}; if neither is
-	 * set, falls back to `DEFAULT_MAX_PER_PUMP` (256).
-	 */
-	maxPerPump?: number;
-};
-
-export class JobFlowGraph<T> extends Graph {
-	private readonly _stageNames: readonly string[];
-	private readonly _stageWorkFns: ReadonlyMap<string, WorkFn<T>>;
-	private readonly _queues = new Map<string, JobQueueGraph<T>>();
-	private readonly _completed;
-	readonly completed: Node<readonly JobEnvelope<T>[]>;
-	readonly completedCount: Node<number>;
-
-	constructor(name: string, opts: JobFlowOptions<T> = {}) {
-		super(name, opts.graph);
-
-		// Normalise stage definitions.
-		const rawStages = opts.stages ?? (["incoming", "processing", "done"] as readonly StageDef<T>[]);
-		const stageNames: string[] = [];
-		const stageWorkFns = new Map<string, WorkFn<T>>();
-		const stageMaxPerPump = new Map<string, number>();
-		const stageMaxInflight = new Map<string, number>();
-
-		for (const raw of rawStages) {
-			const stageName = typeof raw === "string" ? raw.trim() : raw.name.trim();
-			if (typeof raw !== "string" && raw.work) {
-				stageWorkFns.set(stageName, raw.work);
-			}
-			if (typeof raw !== "string" && raw.maxPerPump != null) {
-				stageMaxPerPump.set(
-					stageName,
-					Math.max(
-						1,
-						requireNonNegativeInt(raw.maxPerPump, `job flow stage "${stageName}" maxPerPump`),
-					),
-				);
-			}
-			if (typeof raw !== "string" && raw.maxInflight != null) {
-				stageMaxInflight.set(
-					stageName,
-					Math.max(
-						1,
-						requireNonNegativeInt(raw.maxInflight, `job flow stage "${stageName}" maxInflight`),
-					),
-				);
-			}
-			stageNames.push(stageName);
-		}
-
-		if (stageNames.length < 2) {
-			throw new Error(`jobFlow("${name}"): requires at least 2 stages`);
-		}
-		const unique = new Set(stageNames);
-		if (unique.size !== stageNames.length) {
-			throw new Error(`jobFlow("${name}"): stage names must be unique`);
-		}
-		this._stageNames = Object.freeze([...stageNames]);
-		this._stageWorkFns = stageWorkFns;
-
-		for (const stage of this._stageNames) {
-			const q = jobQueue<T>(`${name}-${stage}`);
-			this._queues.set(stage, q);
-			this.mount(stage, q);
-		}
-
-		this._completed = reactiveLog<JobEnvelope<T>>([], {
-			name: "completed",
-			maxSize: DEFAULT_COMPLETED_RETAINED_LIMIT,
-		});
-		this.completed = this._completed.entries;
-		this.add(this.completed, { name: "completed" });
-		this.completedCount = node(
-			[this.completed],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				actions.emit((data[0] as readonly JobEnvelope<T>[]).length);
-			},
-			{
-				name: "completedCount",
-				describeKind: "derived",
-				meta: jobQueueMeta("job_flow_completed_count"),
-				initial: 0,
-			},
-		);
-		this.add(this.completedCount, { name: "completedCount" });
-		this.addDisposer(keepalive(this.completedCount));
-
-		const defaultMaxPerPump = Math.max(
-			1,
-			requireNonNegativeInt(opts.maxPerPump ?? DEFAULT_MAX_PER_PUMP, "job flow maxPerPump"),
-		);
-
-		// Wire up per-stage pumps.
-		for (let i = 0; i < this._stageNames.length; i += 1) {
-			const stage = this._stageNames[i] as string;
-			const current = this.queue(stage);
-			const next =
-				i + 1 < this._stageNames.length ? this.queue(this._stageNames[i + 1] as string) : null;
-			const workFn = this._stageWorkFns.get(stage);
-			// Per-stage `maxPerPump` override falls back to the top-level cap.
-			// Captured per stage so each pump's loop sees its own resolved limit.
-			const stagePerPump = stageMaxPerPump.get(stage) ?? defaultMaxPerPump;
-			const stageMaxInflightCap = stageMaxInflight.get(stage);
-			// When `maxInflight` is set, mount a state(0) counter on the graph
-			// and wire it as an extra pump dep — settles `inflightCounter.emit`
-			// re-fire the pump so pending items resume claiming after each
-			// settle (without a counter, the pump only fires on `pending`
-			// changes, which `ack` does not affect → maxInflight at saturation
-			// would deadlock the queue).
-			// qa F-D (Tier 5 /qa pass, 2026-04-29): mount under `__inflight__/`
-			// internal namespace so the counter cannot collide with a user-named
-			// stage (e.g. `inflight_my-stage`). Matches the EH-16
-			// `__processManagers__/<name>` convention (COMPOSITION-GUIDE §38 —
-			// internal infrastructure paths use the `__` prefix).
-			const inflightCounter =
-				stageMaxInflightCap !== undefined
-					? node<number>([], { name: `__inflight__/${stage}`, initial: 0 })
-					: null;
-			if (inflightCounter) {
-				this.add(inflightCounter, { name: `__inflight__/${stage}` });
-			}
-
-			// `isTerminal` marks the last stage — completed jobs go into
-			// `_completed` log instead of a next queue.
-			const isTerminal = next === null;
-
-			if (workFn) {
-				// ── Stage with work hook ──────────────────────────────────────
-				// Pump effect: claim one job, run work(job), forward result on
-				// success; nack on failure.
-				// Per B.3 lock: effects ARE sanctioned for side-effects.
-				// `fromAny` bridges sync value / Promise / Node → Node<T>.
-				//
-				// **Inflight teardown drain (Tier 6.5 2.5a, 2026-04-29).** Each
-				// claim mints a per-claim `AbortController` and tracks the
-				// `(unsub, ac)` pair in a `ctx.store.inflight` Set. The
-				// per-claim signal is supplied to the work fn via the optional
-				// second-arg `{ signal }` (mirrors `LLMInvokeOptions.signal` /
-				// `apply(item, {signal})` / tool-handler precedents). On the
-				// pump's `deactivate` hook (parent Graph TEARDOWN cascade —
-				// e.g. `harness.destroy()`), every inflight entry is aborted +
-				// unsubscribed so user-supplied async work (LLM streams, eval
-				// HTTP calls, refineLoop iterations) gets cooperative
-				// cancellation instead of leaking past the harness lifetime.
-				type InflightEntry = { unsub: () => void; ac: AbortController };
-				type InflightStore = { entries: Set<InflightEntry>; terminated: boolean };
-				const pumpDeps: Node[] =
-					inflightCounter != null ? [current.pending, inflightCounter] : [current.pending];
-				const pump = node<unknown>(
-					pumpDeps,
-					(_data, _actions, ctx) => {
-						if (!("inflight" in ctx.store)) {
-							ctx.store.inflight = {
-								entries: new Set<InflightEntry>(),
-								terminated: false,
-							} satisfies InflightStore;
-						}
-						const inflightStore = ctx.store.inflight as InflightStore;
-						const inflight = inflightStore.entries;
-						let processed = 0;
-						while (processed < stagePerPump) {
-							// 3.1 maxInflight gate: cap concurrent inflight across pump
-							// ticks. The inflightCounter (mounted as a pump dep) re-fires
-							// the pump when a settle decrements it, so pending items
-							// resume claiming when capacity frees up.
-							if (stageMaxInflightCap !== undefined && inflight.size >= stageMaxInflightCap) {
-								break;
-							}
-							const claims = current.claim(1);
-							if (claims.length === 0) break;
-							const job = claims[0] as JobEnvelope<T>;
-							if (!job) break;
-
-							// Build the updated path accumulator.
-							const prevPath = (job.metadata.job_flow_path as readonly string[] | undefined) ?? [];
-							const newPath = [...prevPath, stage];
-
-							const ac = new AbortController();
-							const entry: InflightEntry = { unsub: () => undefined, ac };
-							inflight.add(entry);
-							inflightCounter?.emit(inflight.size);
-
-							let result: NodeInput<T>;
-							try {
-								result = workFn(job, { signal: ac.signal });
-							} catch (err) {
-								// Sync throw → nack no-requeue. F-CATCH D-3: thread
-								// the thrown value onto the nack event so the
-								// failure is diagnosable, not just observable.
-								inflight.delete(entry);
-								inflightCounter?.emit(inflight.size);
-								current.nack(job.id, { requeue: false, error: err });
-								processed += 1;
-								continue;
-							}
-
-							// Coerce to Node<T> via fromAny.
-							const resultNode = fromAny<T>(result);
-
-							// M8: Subscribe once to the result node; on DATA forward; on ERROR nack.
-							// Use `let unsub` + TDZ guard (same pattern as toPromise) so sync
-							// DATA delivery inside subscribe() doesn't hit TDZ on `unsub`.
-							let settled = false;
-							let unsub: (() => void) | undefined;
-							const cleanupSub = (): void => {
-								if (unsub) {
-									unsub();
-								} else {
-									Promise.resolve().then(() => unsub?.());
-								}
-								inflight.delete(entry);
-								// qa F-F (Tier 5 /qa pass, 2026-04-29): skip the counter
-								// emit after teardown — the counter Node is itself in the
-								// cascade. Late ERROR/DATA arriving via the deferred
-								// `Promise.resolve().then(unsub)` path could otherwise emit
-								// on a torn-down node.
-								if (!inflightStore.terminated) {
-									inflightCounter?.emit(inflight.size);
-								}
-							};
-							unsub = resultNode.subscribe((msgs) => {
-								if (settled) return;
-								for (const m of msgs) {
-									if (m[0] === DATA) {
-										settled = true;
-										cleanupSub();
-										const newPayload = m[1] as T;
-										const newMetadata = {
-											...job.metadata,
-											job_flow_path: newPath,
-										};
-										if (isTerminal) {
-											const completedJob: JobEnvelope<T> = {
-												...job,
-												payload: newPayload,
-												metadata: Object.freeze(newMetadata),
-											};
-											batch(() => {
-												current.ack(job.id);
-												this._completed.append(completedJob);
-											});
-										} else {
-											batch(() => {
-												current.ack(job.id);
-												(next as JobQueueGraph<T>).enqueue(newPayload, {
-													metadata: newMetadata,
-												});
-											});
-										}
-										return;
-									} else if (m[0] === ERROR) {
-										settled = true;
-										cleanupSub();
-										// F-CATCH D-3: carry the ERROR payload onto
-										// the nack event (symmetric with the sync
-										// -throw path) so failed jobs are diagnosable.
-										current.nack(job.id, { requeue: false, error: m[1] });
-										return;
-									}
-								}
-							});
-							entry.unsub = () => unsub?.();
-
-							processed += 1;
-						}
-						return {
-							onDeactivation: () => {
-								// qa F-F: set terminated BEFORE draining so any
-								// `cleanupSub` racing via the deferred-microtask path
-								// (`Promise.resolve().then(() => unsub?.())`) sees
-								// `terminated === true` and skips its `inflightCounter.emit`.
-								inflightStore.terminated = true;
-								for (const e of inflight) {
-									try {
-										e.ac.abort();
-									} catch {
-										// best-effort
-									}
-									try {
-										e.unsub();
-									} catch {
-										// best-effort
-									}
-								}
-								inflight.clear();
-								// Lock 6.D (Phase 13.6.B): drop the `inflight` key
-								// so the next activation re-initializes a fresh
-								// `InflightStore` with `terminated: false`. Without
-								// this, post-flip preserve-by-default keeps the
-								// stale `terminated: true` flag and silently
-								// suppresses inflight-counter emits forever.
-								delete ctx.store.inflight;
-							},
-						};
-					},
-					{
-						meta: jobQueueMeta("job_flow_pump", { stage, has_work: true }),
-					},
-				);
-				this.addDisposer(keepalive(pump));
-			} else {
-				// ── Stage without work hook (pass-through ferry) ──────────────
-				// Claim, accumulate path, forward to next stage or completed.
-				const pump = this.effect(
-					`pump_${stage}`,
-					[`${stage}::pending`],
-					() => {
-						let moved = 0;
-						while (moved < stagePerPump) {
-							const claim = current.claim(1);
-							if (claim.length === 0) break;
-							const job = claim[0] as JobEnvelope<T>;
-							if (!job) break;
-
-							const prevPath = (job.metadata.job_flow_path as readonly string[] | undefined) ?? [];
-							const newPath = [...prevPath, stage];
-							const newMetadata = { ...job.metadata, job_flow_path: newPath };
-
-							if (isTerminal) {
-								const completedJob: JobEnvelope<T> = {
-									...job,
-									metadata: Object.freeze(newMetadata),
-								};
-								batch(() => {
-									current.ack(job.id);
-									this._completed.append(completedJob);
-								});
-							} else {
-								batch(() => {
-									current.ack(job.id);
-									(next as JobQueueGraph<T>).enqueue(job.payload, {
-										metadata: newMetadata,
-									});
-								});
-							}
-							moved += 1;
-						}
-					},
-					{
-						meta: jobQueueMeta("job_flow_pump", { stage, has_work: false }),
-					},
-				);
-				this.addDisposer(keepalive(pump));
-			}
-		}
-	}
-
-	stages(): readonly string[] {
-		return this._stageNames;
-	}
-
-	queue(stage: string): JobQueueGraph<T> {
-		const q = this._queues.get(stage);
-		if (!q) throw new Error(`jobFlow("${this.name}"): unknown stage "${stage}"`);
-		return q;
-	}
-
-	enqueue(payload: T, opts: { id?: string; metadata?: Record<string, unknown> } = {}): string {
-		return this.queue(this._stageNames[0] as string).enqueue(payload, opts);
-	}
-
-	retainedCompleted(): readonly JobEnvelope<T>[] {
-		return this.completed.cache as readonly JobEnvelope<T>[];
-	}
-}
-
-/**
- * Creates a Pulsar-inspired job queue graph with claim/ack/nack workflow.
- */
-export function jobQueue<T>(name: string, opts?: JobQueueOptions): JobQueueGraph<T> {
-	return new JobQueueGraph<T>(name, opts);
-}
-
-/**
- * Creates an autonomous multi-stage queue chain graph.
- */
-export function jobFlow<T>(name: string, opts?: JobFlowOptions<T>): JobFlowGraph<T> {
-	const g = new JobFlowGraph<T>(name, opts);
-	// Tier 1.5.3 Phase 2.5 (DG1=B): tag the Graph with its constructing
-	// factory so `describe()` surfaces provenance. Route through
-	// `placeholderArgs` since `stages[].work` is a function and
-	// `opts.graph` may carry non-JSON fields.
-	const { factory: _f, factoryArgs: _fa, ...tagArgs } = (opts ?? {}) as Record<string, unknown>;
-	g.tagFactory("jobFlow", placeholderArgs(tagArgs));
-	return g;
-}
diff --git a/src/utils/memory/fact-store.ts b/src/utils/memory/fact-store.ts
deleted file mode 100644
index cb106b65..00000000
--- a/src/utils/memory/fact-store.ts
+++ /dev/null
@@ -1,1153 +0,0 @@
-/**
- * DS-14.7 — Reactive Fact Store / Live Knowledge Graph (locked 2026-05-13).
- *
- * Static-topology agent-memory substrate that satisfies MEME L2 (cascade
- * invalidation) and L3 (obsolescence reasoning) plus Hassabis's
- * filter/consolidate/continual-learning frame, **without** materializing one
- * reactive node per fact. ~12 fixed operator nodes never grow regardless of how
- * many facts the store holds; facts live as columnar DATA inside an indexed
- * `state<FactStore>` (optionally sharded), and cascade is implemented as
- * bounded recursive message emission. Termination rests on a per-root
- * semantic contract — a fact only drives the cascade when it transitions to
- * obsolete (`validTo` set), and each obsolete root emits its cascade exactly
- * once across all waves — plus an empty-array fixpoint short-circuit. The
- * cascade is modeled as DATA arrays (NOT INVALIDATE messages), so spec §1.4's
- * idempotent-within-a-wave INVALIDATE guarantee does NOT govern this loop;
- * convergence is the per-root contract, not a spec §1.4 diamond-merge.
- *
- * Canonical design: `archive/docs/SESSION-DS-14.7-reactive-fact-store.md`
- * (9Q walk complete; Q9-open items 1–9 all resolved).
- *
- * Locked decisions baked in here:
- * - `cascadeMaxIterations` default **8**; overflow emits a per-batch summary
- *   `{ droppedCount, sample, rootFactId }` to `cascadeOverflow` (Q9-open-4).
- *   The overflow `sample` is capped at `OVERFLOW_SAMPLE_SIZE` (8),
- *   independent of `cascadeMaxIterations`.
- * - `shardBy` default hash-mod **4**; caller override; `dependentsIndex`
- *   unsharded for v1 (Q9-open-1).
- * - `MemoryFragment` adds `embedding? / parent_fragment_id? / provenance?`
- *   (Q9-open-3).
- * - `dependentsIndex` updates synchronous + atomic with `factStore` commit
- *   (Q9-open-2).
- * - Scoring contract `(fragment, storeReadHandle) => number` — read-only
- *   handle, no mutation exposure (Q9-open-5).
- * - Consolidator emits to a dedicated `consolidated` topic that the pattern
- *   default-wires back to `ingest`; caller can intercept (Q9-open-6).
- * - Query surface = structured `MemoryQuery` via the `query` topic (default);
- *   function-shaped is caller-side `derived` over `factStore` (Q9-open-7).
- * - Bi-temporal is pattern-layer only — no DS-14 envelope shape change
- *   (Q9-open-9); `simpleFactStore()` deferred to v1.1 (Q9-open-8 — NOT built).
- *
- * **Cascade cycle visibility.** `cascadeProcessor` stays synchronous (preserves
- * spec §1.4 batch-dedupe — LLM-driven dependency extraction lives UPSTREAM of
- * the cascade topic, never inside the recursion). Every cascade message carries
- * a `causalReason` field and the cycle nodes are tagged `meta.cycle:"cascade"`
- * so `describe()` / `explain()` surface the otherwise-invisible
- * `dependentsIndex` fn-body lookup.
- *
- * @module
- */
-
-import { monotonicNs, type Node, node, wallClockNs } from "@graphrefly/pure-ts/core";
-import type { ReactiveLogBundle } from "@graphrefly/pure-ts/extra";
-import { keepalive, reactiveLog } from "@graphrefly/pure-ts/extra";
-import { Graph } from "@graphrefly/pure-ts/graph";
-import { domainMeta } from "../../base/meta/domain-meta.js";
-import {
-	type BaseAuditRecord,
-	bumpCursor,
-	createAuditLog,
-	registerCursor,
-} from "../../base/mutation/index.js";
-
-// ── Public types ─────────────────────────────────────────────────────────
-
-/** Stable identity for a stored fact. */
-export type FactId = string;
-
-/** Shard partition key (string | number — any hashable scalar). */
-export type ShardKey = string | number;
-
-/**
- * A single stored memory fact. Pattern convention only — NOT a spec primitive
- * and NOT a DS-14 envelope field (bi-temporal stays pattern-layer per
- * Q9-open-9). Each field is a reactive lever (see design PART 2.3):
- * `validTo` set → cascade fires; `confidence < θ` → review; `sources` →
- * `dependentsIndex` edges feeding cascade.
- */
-export interface MemoryFragment<T> {
-	readonly id: FactId;
-	readonly payload: T;
-	/** Transaction time (when learned). `bigint` ns (e.g. `BigInt(monotonicNs())`). */
-	readonly t_ns: bigint;
-	/** Valid-time start. `undefined` = unbounded past. */
-	readonly validFrom?: bigint;
-	/** Valid-time end. Setting this is the MEME L3 obsolescence lever. */
-	readonly validTo?: bigint;
-	/** Confidence 0..1. Dropping below the review threshold emits a review. */
-	readonly confidence: number;
-	readonly tags: readonly string[];
-	/** Dependency edges — fact IDs this fact is derived from / depends on. */
-	readonly sources: readonly FactId[];
-	/** Optional dense embedding (recipes use it for retrieval). */
-	readonly embedding?: readonly number[];
-	/** Version-chain pointer — consolidator emits successor fragments. */
-	readonly parent_fragment_id?: FactId;
-	/** Free-form provenance string for audit. */
-	readonly provenance?: string;
-}
-
-/**
- * Columnar in-memory store. Held as DATA inside a `state<FactStore<T>>` node
- * (one per shard). `byId` is the authoritative map; the typed companions are
- * kept for the recipe layer (`bitemporal-query`, `influence-analysis`) — v1
- * stores fragments directly and lazily projects columns on demand.
- */
-export interface FactStore<T> {
-	readonly byId: ReadonlyMap<FactId, MemoryFragment<T>>;
-}
-
-/** Reverse dependency index: fact → IDs that depend on it. Unsharded (v1). */
-export type DependentsIndex = ReadonlyMap<FactId, readonly FactId[]>;
-
-/** Read-only projection passed to scoring policies (no mutation surface). */
-export interface StoreReadHandle<T> {
-	get(id: FactId): MemoryFragment<T> | undefined;
-	has(id: FactId): boolean;
-	readonly size: number;
-	values(): IterableIterator<MemoryFragment<T>>;
-}
-
-export type ScoringPolicy<T> = (fragment: MemoryFragment<T>, store: StoreReadHandle<T>) => number;
-export type DecayPolicy = (confidence: number, ageNs: bigint) => number;
-export type AdmissionFilter<T> = (fragment: MemoryFragment<T>) => boolean;
-
-/** Outcome / RL signal — write-back lever for continual learning. */
-export interface OutcomeSignal {
-	readonly factId: FactId;
-	readonly reward: number;
-}
-
-/** Structured query (Q9-open-7 default surface). Serializable + inspectable. */
-export interface MemoryQuery {
-	/** Match any of these tags (OR). Omit for no tag filter. */
-	readonly tags?: readonly string[];
-	/** Bi-temporal "as of" — only facts valid at this instant. */
-	readonly asOf?: bigint;
-	/** Minimum confidence (inclusive). */
-	readonly minConfidence?: number;
-	/** Cap results (sorted by confidence desc, then t_ns desc). */
-	readonly limit?: number;
-}
-
-export interface MemoryAnswer<T> {
-	readonly query: MemoryQuery;
-	readonly results: readonly MemoryFragment<T>[];
-}
-
-export type CascadeReason = "cascade" | "obsolete" | "manual";
-
-/** A single cascade invalidation message flowing through the cascade cycle. */
-export interface CascadeEvent {
-	readonly factId: FactId;
-	readonly rootFactId: FactId;
-	readonly reason: CascadeReason;
-	/**
-	 * The triggering root fact's own `validTo`. Cascade-invalidated dependents
-	 * inherit this (NOT a fresh wall-clock read), so the store is a
-	 * deterministic rebuildable projection: replaying the same ingest stream
-	 * yields byte-identical `validTo` on cascade-invalidated fragments. Each
-	 * dependent inherits the `validTo` of the *nearest obsolete fact that
-	 * drove its invalidation*: in a pure chain A→B→C where only A is
-	 * explicitly obsoleted, B and C both inherit A's `validTo` (B has no own
-	 * `validTo`, so when B becomes a cascade root the detector reads
-	 * `B.validTo` === A's value). If an intermediate B is itself explicitly
-	 * obsoleted with its *own* `validTo`, B's dependents inherit B's value,
-	 * not A's — "stale from when its driving source was invalidated."
-	 * Deterministic either way. Always defined: only obsolete facts
-	 * (`validTo` set) drive the cascade as roots.
-	 */
-	readonly rootValidTo: bigint;
-	/** Cascade recursion depth (1 = first wave). Bounded by `cascadeMaxIterations`. */
-	readonly iteration: number;
-	/**
-	 * Human-readable causal chain — makes the `dependentsIndex` fn-body lookup
-	 * visible in `explain()` output even though it is not a topology edge
-	 * (design Q3 / COMPOSITION-GUIDE §24 mitigation).
-	 */
-	readonly causalReason: string;
-}
-
-/** Per-batch overflow summary (Q9-open-4 — never per-message). */
-export interface CascadeOverflow {
-	readonly droppedCount: number;
-	readonly sample: readonly FactId[];
-	readonly rootFactId: FactId;
-}
-
-export interface ReviewRequest {
-	readonly factId: FactId;
-	readonly confidence: number;
-	readonly threshold: number;
-}
-
-export interface FactStoreAuditRecord extends BaseAuditRecord {
-	readonly action: "ingest" | "invalidate" | "outcome" | "consolidate" | "decay" | "overflow";
-	readonly id?: FactId;
-	readonly reason?: CascadeReason;
-	/**
-	 * Number of facts whose state actually changed in a batch action
-	 * (post-filter — excludes no-op / non-finite / resurrection-guard
-	 * skips; equals the length of the emitted `decay_processor` value
-	 * array). Populated for `"decay"` (a per-tick batch over many facts
-	 * with no single `id` — the bare `{action,t_ns,seq}` record was opaque
-	 * to audit-log forensics). Absent for single-fact actions (`id`
-	 * carries those).
-	 */
-	readonly count?: number;
-}
-
-export interface ReactiveFactStoreConfig<T> {
-	// ① Function hooks (no reactive policy needed).
-	readonly extractDependencies: (f: MemoryFragment<T>) => readonly FactId[];
-	/** Shard partition fn. Default: FNV-1a hash of `id` mod `shardCount`. */
-	readonly shardBy?: (f: MemoryFragment<T>) => ShardKey;
-	/** Shard count for the default hash-mod sharder. Default 4 (§3.2). */
-	readonly shardCount?: number;
-
-	// ② Node<Policy> hooks (reactive — policy itself can evolve).
-	readonly scoring?: Node<ScoringPolicy<T>>;
-	/**
-	 * Forgetting-curve policy `(confidence, ageNs) => confidence'` (MEME L1
-	 * time-drift / Hassabis forgetting curve, DS-14.7 PART 4.1 face ②). `ageNs`
-	 * is the fact's monotonic age (`monotonicNs() - t_ns`, a `bigint`
-	 * nanosecond duration — `Number()` it for float math; precision degrades
-	 * for ages beyond `Number.MAX_SAFE_INTEGER` ns ≈ 104 days of process
-	 * uptime). Reactive: the policy itself can evolve (e.g.
-	 * `derived([outcome], …)` for continual learning — spec §1.4
-	 * push-on-update).
-	 *
-	 * **Activation contract.** The decay processor exists only when
-	 * {@link decayTrigger} is *configured*. Once it is, **both** a
-	 * `decayTrigger` tick **and** a `decay` policy emit drive a full pass
-	 * (push-on-update — the `outcomeProcessor`+`scoring` precedent). A policy
-	 * Node's *initial* value therefore runs a pass on first resolution: if you
-	 * build `decay` via `derived(...)`, expect a store-wide pass when it first
-	 * settles. With no `decayTrigger` configured the face is fully inert
-	 * (mirrors {@link consolidate}/{@link consolidateTrigger}).
-	 *
-	 * Each pass applies the current policy to every *live* fact (`validTo`
-	 * unset), clamps to `[0, 1]`, and writes back only facts whose confidence
-	 * actually changed (a fact obsoleted earlier in the same tick is never
-	 * resurrected). A drop below {@link reviewThreshold} surfaces via the
-	 * `review` topic; decay never sets `validTo`, so it cannot itself drive the
-	 * cascade.
-	 *
-	 * **Quiescence is the policy's responsibility.** The only no-op guard is
-	 * exact-equality (`next === confidence`). A policy with no reachable
-	 * fixpoint (e.g. plain geometric `c => c * 0.5`) therefore re-decays and
-	 * re-emits **every** live fact on **every** tick forever (silent CPU/GC +
-	 * audit-log churn — never an error). Bound it in the policy: clamp to a
-	 * floor and return `confidence` unchanged once at/below it (so the
-	 * exact-equality guard quiesces the store). The {@link decayExponential}
-	 * recipe is the ergonomic alternative that owns its own `fromTimer` +
-	 * `floor`/`epsilon` and writes through the `ingest` face (no
-	 * `decay`/`decayTrigger` wiring). Use this face when you want the store to
-	 * own decay as a reactive, swappable policy and you are providing the floor.
-	 */
-	readonly decay?: Node<DecayPolicy>;
-	readonly admissionFilter?: Node<AdmissionFilter<T>>;
-
-	// ③ Topic inputs (caller wires upstream sources).
-	readonly ingest: Node<MemoryFragment<T>>;
-	readonly outcome?: Node<OutcomeSignal>;
-	readonly query?: Node<MemoryQuery>;
-	/**
-	 * Decay trigger — a reactive timer/cron Node (e.g. `fromTimer(...)` /
-	 * `fromCron(...)`). Configuring it creates the decay processor; each tick
-	 * then re-applies the current {@link decay} policy to every live fact (a
-	 * `decay` policy emit also drives a pass — see {@link decay}'s "Activation
-	 * contract"). A tick before any `decay` policy has emitted is a no-op.
-	 * Without this field the `decay` face is fully inert (mirrors
-	 * {@link consolidateTrigger}/{@link consolidate}).
-	 */
-	readonly decayTrigger?: Node<unknown>;
-	/**
-	 * Consolidator trigger — a reactive timer/cron Node (e.g. `fromCron(...)`).
-	 * When supplied, the `consolidated` node maps each tick to summarized
-	 * fragments emitted on the `consolidated` topic and default-wired back to
-	 * the internal ingest path.
-	 */
-	readonly consolidateTrigger?: Node<unknown>;
-	/**
-	 * Consolidation summarizer. Reads a store snapshot, returns successor
-	 * fragments (typically with `parent_fragment_id` set). Default: no-op
-	 * (emits nothing) so the cron tick is observable without forcing a policy.
-	 */
-	readonly consolidate?: (store: StoreReadHandle<T>) => readonly MemoryFragment<T>[];
-
-	// Invariants.
-	/** Cascade recursion cap (§3.1). Default 8. */
-	readonly cascadeMaxIterations?: number;
-	/** Confidence below which a {@link ReviewRequest} is emitted. Default 0.3. */
-	readonly reviewThreshold?: number;
-
-	// Persistence.
-	/**
-	 * Record every committed fragment (post-admission-filter, with full
-	 * payload) into a replayable {@link ReactiveFactStoreGraph.ingestLog}.
-	 * Default `false` (the log retains every fragment in memory — opt in only
-	 * when you intend to persist + replay).
-	 *
-	 * Enables the canonical **rebuildable-projection** recipe: the store is a
-	 * deterministic projection of its ingest stream (cascade `validTo` is
-	 * derived from the triggering root, not wall-clock; consolidator successors
-	 * are re-derived from replayed state, not logged — the projection is still
-	 * deterministic), so persisting the ingest log and replaying it on restart
-	 * reconstructs a byte-identical store. Pair with the BigInt-safe codec
-	 * ({@link MemoryFragment} carries `bigint` time fields). The tier MUST be
-	 * `mode:"append"` (the default) — `attachStorage` ships per-wave deltas, so
-	 * an `"overwrite"` tier would truncate the log (and `attachStorage` now
-	 * throws on one).
-	 *
-	 * **First run — persist:**
-	 * ```ts
-	 * import { reactiveFactStore } from "@graphrefly/graphrefly";
-	 * import { appendLogStorage, bigintJsonCodecFor } from "@graphrefly/pure-ts/extra";
-	 *
-	 * const tier = appendLogStorage(backend, {
-	 *   name: "facts-ingest",
-	 *   codec: bigintJsonCodecFor<readonly MemoryFragment<Doc>[]>(),
-	 * });
-	 * const mem = reactiveFactStore<Doc>({ ingest, extractDependencies, recordIngest: true });
-	 * mem.ingestLog!.attachStorage([tier]); // forwards every committed fragment
-	 * ```
-	 *
-	 * **Restart — replay (rebuild the projection):** read the persisted entries
-	 * and feed them through `config.ingest`. Replay is just the reactive input —
-	 * there is no imperative restore primitive.
-	 * ```ts
-	 * const { entries } = await tier.loadEntries!();
-	 * const mem = reactiveFactStore<Doc>({ ingest, extractDependencies });
-	 * for (const f of entries) ingest.emit(f); // identical store rebuilt
-	 * ```
-	 *
-	 * **Do NOT do both at once.** On restart, either replay through `ingest`
-	 * (above) **or** rely on `attachStorage`'s auto-restore — never both:
-	 * `attachStorage` restores the persisted entries into a fresh `ingestLog`,
-	 * and a manual replay loop would then re-append + re-persist them (doubling
-	 * the durable log every restart). If you want continued persistence on the
-	 * rebuilt store, set `recordIngest:true` and call `attachStorage([tier])`
-	 * **after** the replay loop completes (the log already holds the replayed
-	 * fragments, so `attachStorage` ships no spurious deltas).
-	 *
-	 * **Memory:** the in-memory log is unbounded (every committed fragment is
-	 * retained for the store's lifetime). For a long-lived high-volume store,
-	 * `ingestLog.trimHead(n)` after a confirmed `tier.flush()` bounds it (the
-	 * durable tier remains the full record).
-	 */
-	readonly recordIngest?: boolean;
-}
-
-// `ReactiveFactStoreGraph<T>` is a `class extends Graph` defined below
-// (alongside the wiring it owns) so `instanceof` narrowing + constructor
-// invariants hold, consistent with the other `extends Graph` subclasses.
-// The thin {@link reactiveFactStore} factory wraps `new`.
-
-// ── Constants ────────────────────────────────────────────────────────────
-
-/**
- * Max number of dropped cascade-target ids included in a {@link CascadeOverflow}
- * `sample`. Deliberately decoupled from `cascadeMaxIterations` — it bounds the
- * diagnostic payload size, not the recursion budget.
- */
-const OVERFLOW_SAMPLE_SIZE = 8;
-
-// ── Helpers ──────────────────────────────────────────────────────────────
-
-function factMeta(kind: string, extra?: Record<string, unknown>): Record<string, unknown> {
-	return domainMeta("memory", kind, extra);
-}
-
-/** Deterministic, universal-safe FNV-1a 32-bit string hash (no `node:crypto`). */
-function fnv1a(s: string): number {
-	let h = 0x811c9dc5;
-	for (let i = 0; i < s.length; i += 1) {
-		h ^= s.charCodeAt(i);
-		// 32-bit FNV prime multiply via shifts (avoids BigInt / float drift).
-		h = (h + ((h << 1) + (h << 4) + (h << 7) + (h << 8) + (h << 24))) >>> 0;
-	}
-	return h >>> 0;
-}
-
-function makeReadHandle<T>(byId: ReadonlyMap<FactId, MemoryFragment<T>>): StoreReadHandle<T> {
-	return {
-		get: (id) => byId.get(id),
-		has: (id) => byId.has(id),
-		get size() {
-			return byId.size;
-		},
-		values: () => byId.values(),
-	};
-}
-
-/** Bi-temporal validity test: is `f` valid at instant `asOf`? */
-function currentlyValid<T>(f: MemoryFragment<T>, asOf?: bigint): boolean {
-	if (asOf === undefined) return f.validTo === undefined;
-	if (f.validFrom !== undefined && asOf < f.validFrom) return false;
-	if (f.validTo !== undefined && asOf >= f.validTo) return false;
-	return true;
-}
-
-function lastOf<X>(batch: readonly unknown[] | undefined, prev: unknown): X | undefined {
-	return batch != null && batch.length > 0 ? (batch.at(-1) as X) : (prev as X | undefined);
-}
-
-// ── Factory ──────────────────────────────────────────────────────────────
-
-/**
- * Build a static-topology reactive fact store (DS-14.7 architecture C).
- *
- * Topology (~12 fixed nodes — never grows with fact count):
- *  - `shards[0..N]` — `state<FactStore<T>>` columnar stores (default 4 shards).
- *  - `factStore` — derived union read view across shards.
- *  - `dependentsIndex` — `state<DependentsIndex>` reverse-dep map, unsharded,
- *    updated synchronously + atomically with each commit (Q9-open-2).
- *  - `extractOp` — derived: ingest → admission-filtered fragment + dep edges.
- *  - `invalidationDetector` — derived: scans committed store for `validTo`-set
- *    / low-confidence facts, resolves dependents via `dependentsIndex`, emits
- *    cascade messages.
- *  - `cascade` — topic node carrying `CascadeEvent[]`.
- *  - `cascadeProcessor` — derived, **synchronous**, `meta.cycle:"cascade"`:
- *    dedupes by factId, writes invalidations back to shards, recurses until
- *    fixpoint OR `cascadeMaxIterations` → `cascadeOverflow`.
- *  - `cascadeOverflow` — per-batch overflow summary node.
- *  - `queryOp` / `answer` — structured `MemoryQuery` → results (SENTINEL-safe).
- *  - `outcomeProcessor` — outcome signal → confidence write-back.
- *  - `consolidated` — cron-tick → summarized fragments on the
- *    `consolidated` topic,
- *    default-wired back into the ingest path.
- *  - `review` — low-confidence proactive-verification requests.
- *
- * The cascade cycle (`invalidationDetector → cascade → cascadeProcessor →
- * shards → invalidationDetector`) is a real, bounded reactive cycle. Both
- * `invalidationDetector` and `cascadeProcessor` are tagged
- * `meta.cycle:"cascade"` and every cascade message carries `causalReason`, so
- * `describe()` / `explain()` surface the otherwise-invisible
- * `dependentsIndex` lookup (COMPOSITION-GUIDE §24).
- *
- * @category memory
- */
-export class ReactiveFactStoreGraph<T> extends Graph {
-	// ④ Topic outputs (caller subscribes for custom processing).
-	/** Per-shard `state<FactStore<T>>` nodes (length = shard count). */
-	readonly shards: readonly Node<FactStore<T>>[];
-	/** Unified read view across all shards (derived). */
-	readonly factStore: Node<FactStore<T>>;
-	readonly dependentsIndex: Node<DependentsIndex>;
-	readonly answer: Node<MemoryAnswer<T> | null>;
-	readonly cascade: Node<readonly CascadeEvent[]>;
-	readonly cascadeOverflow: Node<CascadeOverflow | null>;
-	readonly review: Node<ReviewRequest | null>;
-	readonly consolidated: Node<readonly MemoryFragment<T>[]>;
-	readonly events: ReactiveLogBundle<FactStoreAuditRecord>;
-	/**
-	 * Payload-carrying, replayable log of every committed fragment. Present iff
-	 * {@link ReactiveFactStoreConfig.recordIngest} is `true`. Unlike
-	 * {@link ReactiveFactStoreGraph.events} (action-only audit), each entry is
-	 * the full {@link MemoryFragment} — `attachStorage` it for a durable,
-	 * replayable projection source (see `recordIngest` docs for the recipe).
-	 */
-	readonly ingestLog?: ReactiveLogBundle<MemoryFragment<T>>;
-
-	constructor(config: ReactiveFactStoreConfig<T>) {
-		const shardCount = Math.max(1, config.shardCount ?? 4);
-		const maxIterations = Math.max(1, config.cascadeMaxIterations ?? 8);
-		const reviewThreshold = config.reviewThreshold ?? 0.3;
-		const shardBy = config.shardBy ?? ((f: MemoryFragment<T>) => fnv1a(String(f.id)) % shardCount);
-
-		// Cascade recursion depth counter. Reset to 0 on every external ingest
-		// (a fresh root = a fresh cascade budget) and on a true fixpoint (detector
-		// emits `[]`). Bounded by `maxIterations`; overflow stops the recursion.
-		// This counter is a *backstop* for pathological cycles only — primary
-		// termination is the per-root semantic contract below (F1/F5).
-		let cascadeIteration = 0;
-
-		// F1/F5 — per-root cascade dedupe across waves. A fact only enters the
-		// cascade as a root when it transitions to obsolete (`validTo` set), and
-		// a given obsolete root emits its cascade exactly ONCE across all waves.
-		// `processedRoots` tracks root ids that have already emitted; a root
-		// re-detected in a later wave WITHOUT a new obsolescence transition does
-		// not re-emit. This bounds the loop by the finite set of newly-obsolete
-		// roots per external change, independent of `cascadeIteration` resets
-		// (which an ingest / consolidator wire-back would otherwise defeat).
-		const processedRoots = new Set<FactId>();
-
-		super("reactive_fact_store");
-
-		const events = createAuditLog<FactStoreAuditRecord>({
-			name: "events",
-			retainedLimit: 1024,
-			graph: this,
-		});
-		const seqCursor = registerCursor(this, "seq", 0);
-
-		// Opt-in payload-carrying ingest log (rebuildable-projection source).
-		// Fed from `ingestAudit` (every committed fragment, post-admission).
-		const ingestLog: ReactiveLogBundle<MemoryFragment<T>> | undefined = config.recordIngest
-			? reactiveLog<MemoryFragment<T>>([], { name: "ingest_log" })
-			: undefined;
-		if (ingestLog) this.addDisposer(() => ingestLog.dispose());
-
-		// ── shards: state<FactStore<T>> ──────────────────────────────────────
-		const emptyStore = (): FactStore<T> => ({ byId: new Map() });
-		const shards: Node<FactStore<T>>[] = [];
-		for (let s = 0; s < shardCount; s += 1) {
-			const shard = node<FactStore<T>>([], {
-				initial: emptyStore(),
-				name: `shard_${s}`,
-				describeKind: "state",
-				meta: factMeta("factstore", { shard: s }),
-			});
-			this.add(shard, { name: `shard_${s}` });
-			this.addDisposer(keepalive(shard));
-			shards.push(shard);
-		}
-
-		const shardIndexFor = (f: MemoryFragment<T>): number => {
-			const key = shardBy(f);
-			const n = typeof key === "number" ? key : fnv1a(String(key));
-			const idx = ((n % shardCount) + shardCount) % shardCount;
-			return idx;
-		};
-
-		// Resolve which shard a given id lives in by scanning current snapshots
-		// (cascade write-backs reference ids without re-deriving the fragment).
-		const findShardOf = (id: FactId): number => {
-			for (let s = 0; s < shardCount; s += 1) {
-				const fs = shards[s]!.cache as FactStore<T> | undefined;
-				if (fs?.byId.has(id)) return s;
-			}
-			return -1;
-		};
-
-		const allFacts = (): Map<FactId, MemoryFragment<T>> => {
-			const out = new Map<FactId, MemoryFragment<T>>();
-			for (const sh of shards) {
-				const fs = sh.cache as FactStore<T> | undefined;
-				if (!fs) continue;
-				for (const [k, v] of fs.byId) out.set(k, v);
-			}
-			return out;
-		};
-
-		const commitFragment = (f: MemoryFragment<T>): void => {
-			const idx = shardIndexFor(f);
-			const cur = (shards[idx]!.cache as FactStore<T> | undefined) ?? emptyStore();
-			const next = new Map(cur.byId);
-			next.set(f.id, f);
-			shards[idx]!.emit({ byId: next });
-		};
-
-		const replaceFragment = (
-			id: FactId,
-			mut: (prev: MemoryFragment<T>) => MemoryFragment<T>,
-		): boolean => {
-			const idx = findShardOf(id);
-			if (idx < 0) return false;
-			const cur = shards[idx]!.cache as FactStore<T>;
-			const prev = cur.byId.get(id);
-			if (!prev) return false;
-			const next = new Map(cur.byId);
-			next.set(id, mut(prev));
-			shards[idx]!.emit({ byId: next });
-			return true;
-		};
-
-		// ── dependentsIndex: state<DependentsIndex>, unsharded ───────────────
-		const dependentsIndex = node<DependentsIndex>([], {
-			initial: new Map() as DependentsIndex,
-			name: "dependents_index",
-			describeKind: "state",
-			meta: factMeta("factstore", { role: "dependents_index" }),
-		});
-		this.add(dependentsIndex, { name: "dependents_index" });
-		this.addDisposer(keepalive(dependentsIndex));
-
-		// Synchronous + atomic with the commit (Q9-open-2): add reverse edges
-		// `source → [..., fact.id]` for every dependency the fragment declares.
-		const indexFragment = (f: MemoryFragment<T>, deps: readonly FactId[]): void => {
-			const cur = dependentsIndex.cache as DependentsIndex;
-			const next = new Map<FactId, FactId[]>();
-			for (const [k, v] of cur) next.set(k, [...v]);
-			for (const src of deps) {
-				const bucket = next.get(src) ?? [];
-				if (!bucket.includes(f.id)) bucket.push(f.id);
-				next.set(src, bucket);
-			}
-			dependentsIndex.emit(next as DependentsIndex);
-		};
-
-		// ── factStore: unified read view (derived union over shards) ─────────
-		const factStore = node<FactStore<T>>(
-			shards,
-			(batchData, actions, ctx) => {
-				void batchData;
-				void ctx;
-				actions.emit({ byId: allFacts() });
-			},
-			{
-				name: "fact_store",
-				describeKind: "derived",
-				initial: emptyStore(),
-				meta: factMeta("factstore", { role: "read_view" }),
-				// F10a: `allFacts()` builds a fresh Map every detector retrigger.
-				// Fragments are immutable (replaced wholesale on mutation), so a
-				// same-size + per-key-identity check is a sound structural equality
-				// that stops `factStore` (and its `review` dependent) from re-firing
-				// every cascade wave when nothing actually changed.
-				equals: (a: FactStore<T>, b: FactStore<T>) => {
-					if (a === b) return true;
-					if (a.byId.size !== b.byId.size) return false;
-					for (const [k, v] of a.byId) {
-						if (b.byId.get(k) !== v) return false;
-					}
-					return true;
-				},
-			},
-		);
-		this.add(factStore, { name: "fact_store" });
-		this.addDisposer(keepalive(factStore));
-
-		// ── extractOp: ingest → admission filter → commit + index ────────────
-		const extractOp = node<MemoryFragment<T> | null>(
-			config.admissionFilter ? [config.ingest, config.admissionFilter] : [config.ingest],
-			(batchData, actions, ctx) => {
-				const f = lastOf<MemoryFragment<T>>(batchData[0], ctx.prevData[0]);
-				if (f == null) {
-					actions.emit(null);
-					return;
-				}
-				if (config.admissionFilter) {
-					const filter = lastOf<AdmissionFilter<T>>(batchData[1], ctx.prevData[1]);
-					if (filter && !filter(f)) {
-						actions.emit(null);
-						return;
-					}
-				}
-				const deps = config.extractDependencies(f);
-				// External ingest = a fresh cascade root → reset the depth budget.
-				cascadeIteration = 0;
-				// F1/F5: a (re-)ingested id is a fresh fact version. Clear it from
-				// `processedRoots` so a NEW obsolescence transition on this id
-				// (e.g. re-ingest with `validTo` set) re-drives the cascade exactly
-				// once, rather than being permanently suppressed.
-				processedRoots.delete(f.id);
-				// Synchronous + atomic: commit fragment, then index its dep edges.
-				commitFragment(f);
-				indexFragment(f, deps);
-				actions.emit(f);
-			},
-			{
-				name: "extract_op",
-				describeKind: "derived",
-				meta: factMeta("extract"),
-			},
-		);
-		this.add(extractOp, { name: "extract_op" });
-		this.addDisposer(keepalive(extractOp));
-
-		// ── invalidationDetector: store → cascade messages ───────────────────
-		// F1/F5 per-root semantic contract: a fact drives the cascade as a root
-		// ONLY when it is obsolete (`validTo` set). A low-confidence-but-still-live
-		// fact (no `validTo`) does NOT by itself emit a cascade — it surfaces via
-		// the `review` topic instead, so it cannot perpetually re-emit a cascade
-		// every detector pass. Each obsolete root emits its cascade exactly once
-		// across all waves (`processedRoots` dedupe): a root re-detected in a later
-		// wave without a fresh obsolescence transition is skipped. Termination is
-		// therefore bounded by the finite set of newly-obsolete roots per external
-		// change — robust against `cascadeIteration` resets from ingest /
-		// consolidator wire-back. The empty-array emit is the fixpoint
-		// short-circuit; `cascadeMaxIterations` remains a backstop for pathological
-		// LLM-extracted cycles (A→B→A) only.
-		const invalidationDetector = node<readonly CascadeEvent[]>(
-			[...shards],
-			(batchData, actions, ctx) => {
-				void batchData;
-				void ctx;
-				const facts = allFacts();
-				const index = dependentsIndex.cache as DependentsIndex;
-				const out: CascadeEvent[] = [];
-				const seen = new Set<FactId>();
-				for (const f of facts.values()) {
-					// F1/F5(a): ONLY obsolete facts drive the cascade as roots. A
-					// low-confidence-but-still-live fact is handled by `review`,
-					// never by the cascade loop.
-					const obsolete = f.validTo !== undefined;
-					if (!obsolete) continue;
-					// F1/F5(b): each obsolete root emits its cascade exactly once
-					// across all waves. A root re-detected later (still obsolete,
-					// no fresh transition) is skipped — convergence is independent
-					// of `cascadeIteration` resets.
-					if (processedRoots.has(f.id)) continue;
-					const dependents = index.get(f.id) ?? [];
-					for (const dep of dependents) {
-						// F3: only cascade onto dependents that are still live. A
-						// non-existent fact (phantom edge — `extractDependencies`
-						// named an un-ingested FactId) is NOT a live dependent;
-						// neither is a dependent already carrying `validTo`.
-						const depFact = facts.get(dep);
-						if (!depFact || depFact.validTo !== undefined) continue;
-						const k = `${f.id}->${dep}`;
-						if (seen.has(k)) continue;
-						seen.add(k);
-						out.push({
-							factId: dep,
-							rootFactId: f.id,
-							reason: "obsolete",
-							// `obsolete` guard above guarantees `f.validTo` is set.
-							rootValidTo: f.validTo as bigint,
-							iteration: cascadeIteration + 1,
-							causalReason: `dependentsIndex[${f.id}] → ${dep} (obsolete: validTo set)`,
-						});
-					}
-					// Mark the root processed once considered (whether or not it
-					// had a still-live dependent) — it must not re-drive a later
-					// wave without a fresh obsolescence transition.
-					processedRoots.add(f.id);
-				}
-				if (out.length === 0) {
-					// True fixpoint — reset the depth counter so the next external
-					// root starts a fresh cascade budget.
-					cascadeIteration = 0;
-				}
-				actions.emit(out);
-			},
-			{
-				name: "invalidation_detector",
-				describeKind: "derived",
-				initial: [] as readonly CascadeEvent[],
-				meta: factMeta("invalidation", { cycle: "cascade" }),
-			},
-		);
-		this.add(invalidationDetector, { name: "invalidation_detector" });
-		this.addDisposer(keepalive(invalidationDetector));
-
-		// ── cascade topic node ───────────────────────────────────────────────
-		const cascade = node<readonly CascadeEvent[]>(
-			[invalidationDetector],
-			(batchData, actions, ctx) => {
-				const evts = lastOf<readonly CascadeEvent[]>(batchData[0], ctx.prevData[0]) ?? [];
-				actions.emit(evts);
-			},
-			{
-				name: "cascade",
-				describeKind: "derived",
-				initial: [] as readonly CascadeEvent[],
-				meta: factMeta("cascade_topic", { cycle: "cascade" }),
-			},
-		);
-		this.add(cascade, { name: "cascade" });
-		this.addDisposer(keepalive(cascade));
-
-		// ── cascadeOverflow (per-batch summary, Q9-open-4) ───────────────────
-		const cascadeOverflow = node<CascadeOverflow | null>([], {
-			initial: null,
-			name: "cascade_overflow",
-			describeKind: "state",
-			meta: factMeta("cascade_overflow"),
-		});
-		this.add(cascadeOverflow, { name: "cascade_overflow" });
-		this.addDisposer(keepalive(cascadeOverflow));
-
-		// ── cascadeProcessor (SYNCHRONOUS, meta.cycle:"cascade") ─────────────
-		// Per-wave dedupe by target factId, mark each dependent obsolete
-		// (write-back → re-triggers invalidationDetector), bounded by
-		// `cascadeMaxIterations`. NOTE: this is DATA-array dedupe, NOT spec §1.4
-		// INVALIDATE idempotency — termination comes from the detector's
-		// obsolete-only + per-root-once contract plus the empty-array fixpoint
-		// short-circuit, not a spec §1.4 guarantee.
-		const cascadeProcessor = node<readonly CascadeEvent[]>(
-			[cascade],
-			(batchData, actions, ctx) => {
-				const evts = lastOf<readonly CascadeEvent[]>(batchData[0], ctx.prevData[0]) ?? [];
-				if (evts.length === 0) {
-					actions.emit([]);
-					return;
-				}
-				// Dedupe by target factId (diamond-merge at message granularity).
-				const byId = new Map<FactId, CascadeEvent>();
-				for (const e of evts) if (!byId.has(e.factId)) byId.set(e.factId, e);
-
-				cascadeIteration += 1;
-				if (cascadeIteration > maxIterations) {
-					// Cap hit (pathological dependency web / cycle). Emit a
-					// per-batch overflow summary (Q9-open-4) and STOP the recursion
-					// definitively: do NOT write back (no shard mutation → detector
-					// does not re-fire) and settle the cascade topic with `[]` so
-					// the cycle breaks. `cascadeIteration` stays above the cap until
-					// the next external ingest resets it (via extractOp), so a
-					// degenerate cycle cannot immediately re-enter.
-					const sample = [...byId.keys()].slice(0, OVERFLOW_SAMPLE_SIZE);
-					const rootFactId = evts[0]?.rootFactId ?? "";
-					cascadeOverflow.emit({
-						droppedCount: byId.size,
-						sample,
-						rootFactId,
-					});
-					events.append({
-						action: "overflow",
-						reason: "cascade",
-						id: rootFactId,
-						t_ns: wallClockNs(),
-						seq: bumpCursor(seqCursor),
-					});
-					actions.emit([]);
-					return;
-				}
-
-				// Write-back: mark each dependent obsolete iff not already. Each
-				// shard `emit` re-triggers `invalidationDetector` (it deps on
-				// `[...shards]`) — that IS the recursion edge. No separate trigger
-				// node is needed; the detector's "still live" predicate plus the
-				// empty-emit fixpoint reset terminate the cycle.
-				// Deterministic: the dependent inherits the triggering root's own
-				// `validTo` (NOT a fresh `monotonicNs()` read), so replaying the
-				// same ingest stream yields byte-identical `validTo`. Transitive
-				// chains inherit the original root's time.
-				for (const [id, e] of byId) {
-					replaceFragment(id, (prev) =>
-						prev.validTo !== undefined ? prev : { ...prev, validTo: e.rootValidTo },
-					);
-				}
-				actions.emit([...byId.values()]);
-			},
-			{
-				name: "cascade_processor",
-				describeKind: "derived",
-				initial: [] as readonly CascadeEvent[],
-				meta: factMeta("cascade_processor", { cycle: "cascade" }),
-			},
-		);
-		this.add(cascadeProcessor, { name: "cascade_processor" });
-		this.addDisposer(keepalive(cascadeProcessor));
-
-		// ── review: low-confidence proactive verification ────────────────────
-		const review = node<ReviewRequest | null>(
-			[factStore],
-			(batchData, actions, ctx) => {
-				const fs = lastOf<FactStore<T>>(batchData[0], ctx.prevData[0]);
-				if (fs == null) {
-					actions.emit(null);
-					return;
-				}
-				for (const f of fs.byId.values()) {
-					if (f.confidence < reviewThreshold && f.validTo === undefined) {
-						actions.emit({
-							factId: f.id,
-							confidence: f.confidence,
-							threshold: reviewThreshold,
-						});
-						return;
-					}
-				}
-				actions.emit(null);
-			},
-			{
-				name: "review",
-				describeKind: "derived",
-				initial: null,
-				meta: factMeta("review"),
-				// F10a: dedupe on the requested factId (null === no request) so a
-				// stable low-confidence fact does not re-emit a review every wave.
-				equals: (a: ReviewRequest | null, b: ReviewRequest | null) =>
-					(a?.factId ?? null) === (b?.factId ?? null),
-			},
-		);
-		this.add(review, { name: "review" });
-		this.addDisposer(keepalive(review));
-
-		// ── outcomeProcessor: RL signal → confidence write-back ──────────────
-		if (config.outcome) {
-			const outcomeProcessor = node<OutcomeSignal | null>(
-				config.scoring ? [config.outcome, config.scoring] : [config.outcome],
-				(batchData, actions, ctx) => {
-					const sig = lastOf<OutcomeSignal>(batchData[0], ctx.prevData[0]);
-					if (sig == null) {
-						actions.emit(null);
-						return;
-					}
-					replaceFragment(sig.factId, (prev) => {
-						let nextConf = prev.confidence;
-						if (config.scoring) {
-							const policy = lastOf<ScoringPolicy<T>>(batchData[1], ctx.prevData[1]);
-							if (policy) {
-								nextConf = policy(prev, makeReadHandle(allFacts()));
-							}
-						} else {
-							nextConf = Math.max(0, Math.min(1, prev.confidence + sig.reward));
-						}
-						return { ...prev, confidence: nextConf };
-					});
-					actions.emit(sig);
-				},
-				{
-					name: "outcome_processor",
-					describeKind: "derived",
-					initial: null,
-					meta: factMeta("outcome"),
-				},
-			);
-			this.add(outcomeProcessor, { name: "outcome_processor" });
-			this.addDisposer(keepalive(outcomeProcessor));
-		}
-
-		// ── queryOp / answer (structured MemoryQuery, SENTINEL-safe) ─────────
-		// Per COMPOSITION-GUIDE §3/§10: `answer` emits `null` while there has been
-		// no query yet (SENTINEL on the query dep). Downstream consumers use the
-		// `=== null` guard.
-		const answer = node<MemoryAnswer<T> | null>(
-			config.query ? [config.query, factStore] : [factStore],
-			(batchData, actions, ctx) => {
-				if (!config.query) {
-					actions.emit(null);
-					return;
-				}
-				const q = lastOf<MemoryQuery>(batchData[0], ctx.prevData[0]);
-				const fs = lastOf<FactStore<T>>(batchData[1], ctx.prevData[1]);
-				if (q == null) {
-					// No query has been issued yet — null per the SENTINEL guard.
-					actions.emit(null);
-					return;
-				}
-				const store = fs ?? emptyStore();
-				let results = [...store.byId.values()].filter((f) => {
-					if (q.tags && q.tags.length > 0 && !q.tags.some((t) => f.tags.includes(t))) {
-						return false;
-					}
-					if (q.minConfidence !== undefined && f.confidence < q.minConfidence) return false;
-					if (!currentlyValid(f, q.asOf)) return false;
-					return true;
-				});
-				results.sort((a, b) => b.confidence - a.confidence || Number(b.t_ns - a.t_ns));
-				if (q.limit !== undefined) results = results.slice(0, Math.max(0, q.limit));
-				actions.emit({ query: q, results });
-			},
-			{
-				name: "answer",
-				describeKind: "derived",
-				initial: null,
-				meta: factMeta("query", { role: "output" }),
-			},
-		);
-		this.add(answer, { name: "answer" });
-		this.addDisposer(keepalive(answer));
-
-		// ── consolidator (cron-fed) → consolidated topic → wired back ────────
-		const consolidated = node<readonly MemoryFragment<T>[]>(
-			config.consolidateTrigger ? [config.consolidateTrigger] : [],
-			(batchData, actions, ctx) => {
-				void batchData;
-				void ctx;
-				if (!config.consolidateTrigger || !config.consolidate) {
-					actions.emit([]);
-					return;
-				}
-				const fragments = config.consolidate(makeReadHandle(allFacts()));
-				// Default wire-back into the ingest path (Q9-open-6): the pattern
-				// commits + indexes successor fragments; callers that need to gate
-				// can subscribe to `consolidated` and intercept.
-				for (const f of fragments) {
-					const deps = config.extractDependencies(f);
-					// F1/F5: wired-back successor is a fresh fact version — same
-					// processedRoots reset as the ingest path so a later obsolescence
-					// of this id can re-cascade exactly once.
-					processedRoots.delete(f.id);
-					commitFragment(f);
-					indexFragment(f, deps);
-					events.append({
-						action: "consolidate",
-						id: f.id,
-						t_ns: wallClockNs(),
-						seq: bumpCursor(seqCursor),
-					});
-				}
-				actions.emit(fragments);
-			},
-			{
-				name: "consolidated",
-				describeKind: "derived",
-				initial: [] as readonly MemoryFragment<T>[],
-				// Inspection completeness (COMPOSITION-GUIDE §24 "make the
-				// invisible edge visible"): `consolidated` write-backs feed the
-				// bounded cascade store (commit → shard emit →
-				// `invalidationDetector`) exactly like `cascadeProcessor`, but
-				// is NOT a cascade-cycle node. `feeds:"cascade"` surfaces it as
-				// a cascade-store mutator in `describe()`/`explain()`;
-				// `drivesRoot:false` — by the consolidator contract successors
-				// are fresh live facts (no `validTo`), so on the contract path
-				// they do not root the cascade. (An out-of-contract `consolidate`
-				// that emits a `validTo`-set fragment WOULD root it via the
-				// detector — the tag reflects the documented contract, not a
-				// structural impossibility. Contrast `decay_processor` below,
-				// whose `drivesRoot:false` IS structurally provable.)
-				meta: factMeta("consolidator", { feeds: "cascade", drivesRoot: false }),
-			},
-		);
-		this.add(consolidated, { name: "consolidated" });
-		this.addDisposer(keepalive(consolidated));
-
-		// ── decayProcessor: trigger tick → apply DecayPolicy → confidence drift ─
-		// Face ② `decay` (DS-14.7 PART 4.1 / §5.8). Deps on the caller's reactive
-		// trigger (+ the policy Node so a policy swap is push-on-update, the
-		// `outcomeProcessor`/`extractOp` ②-face precedent). Reads the store
-		// advisory off `allFacts()` (COMPOSITION-GUIDE-GRAPH §7 — NOT a shards dep,
-		// no within-wave cycle); write-back via `replaceFragment` re-triggers
-		// `invalidationDetector` exactly like `consolidated`/`cascadeProcessor`
-		// (already-bounded recursion edge). Decay only mutates `confidence`, never
-		// `validTo`, so it cannot itself become a cascade root — a confidence drop
-		// below `reviewThreshold` surfaces through `review` instead.
-		if (config.decayTrigger) {
-			const decayProcessor = node<readonly MemoryFragment<T>[]>(
-				config.decay ? [config.decayTrigger, config.decay] : [config.decayTrigger],
-				(batchData, actions, ctx) => {
-					const policy = config.decay
-						? lastOf<DecayPolicy>(batchData[1], ctx.prevData[1])
-						: undefined;
-					// Inert until a policy exists (SENTINEL guard) or if `decay` was
-					// never supplied — `decayTrigger` alone is documented no-op.
-					if (!policy) {
-						actions.emit([]);
-						return;
-					}
-					// `ageNs` is a DURATION → monotonic clock (CLAUDE.md "Time utility
-					// rule"); `MemoryFragment.t_ns` is monotonic-stamped (field JSDoc
-					// + fixture). Wall-clock here would mix domains and hand the
-					// policy a ~epoch-sized garbage age. The `decay` audit record
-					// below keeps `wallClockNs()` (wall-clock attribution, like every
-					// other audit append).
-					const now = BigInt(monotonicNs());
-					const changes: { id: FactId; next: number }[] = [];
-					for (const f of allFacts().values()) {
-						if (f.validTo !== undefined) continue; // obsolete — don't drift
-						const ageNs = now - f.t_ns;
-						const raw = policy(f.confidence, ageNs);
-						if (!Number.isFinite(raw)) continue; // policy overflow guard
-						const next = raw < 0 ? 0 : raw > 1 ? 1 : raw;
-						if (next === f.confidence) continue; // no-op → quiescent store
-						changes.push({ id: f.id, next });
-					}
-					const decayed: MemoryFragment<T>[] = [];
-					for (const { id, next } of changes) {
-						// Resurrection guard: re-read the LIVE shard — a fact obsoleted
-						// by an in-flight cascade earlier this same tick must not be
-						// re-confidence'd from the pre-cascade snapshot.
-						const idx = findShardOf(id);
-						const fs = idx < 0 ? undefined : (shards[idx]!.cache as FactStore<T> | undefined);
-						const live = fs?.byId.get(id);
-						if (!live || live.validTo !== undefined) continue;
-						replaceFragment(id, (prev) =>
-							prev.validTo !== undefined ? prev : { ...prev, confidence: next },
-						);
-						decayed.push({ ...live, confidence: next });
-					}
-					if (decayed.length > 0) {
-						events.append({
-							action: "decay",
-							t_ns: wallClockNs(),
-							seq: bumpCursor(seqCursor),
-							count: decayed.length,
-						});
-					}
-					actions.emit(decayed);
-				},
-				{
-					name: "decay_processor",
-					describeKind: "derived",
-					initial: [] as readonly MemoryFragment<T>[],
-					// Inspection completeness (same convention as `consolidated`
-					// above — kept uniform): `decay_processor` write-backs feed
-					// the cascade store via `replaceFragment` → shard emit →
-					// `invalidationDetector`. `feeds:"cascade"` surfaces it as a
-					// cascade-store mutator; `drivesRoot:false` — decay only
-					// mutates `confidence`, never `validTo`, and the detector
-					// roots on `validTo` only, so it provably cannot root.
-					meta: factMeta("decay", { feeds: "cascade", drivesRoot: false }),
-				},
-			);
-			this.add(decayProcessor, { name: "decay_processor" });
-			this.addDisposer(keepalive(decayProcessor));
-		}
-
-		// ── ingest audit (records every committed fragment) ──────────────────
-		const ingestAudit = node<MemoryFragment<T> | null>(
-			[extractOp],
-			(batchData, actions, ctx) => {
-				const f = lastOf<MemoryFragment<T> | null>(batchData[0], ctx.prevData[0]);
-				if (f != null) {
-					events.append({
-						action: "ingest",
-						id: f.id,
-						t_ns: wallClockNs(),
-						seq: bumpCursor(seqCursor),
-					});
-					// Payload-carrying replay log (opt-in). Append the full
-					// committed fragment so the store is a rebuildable projection.
-					ingestLog?.append(f);
-				}
-				actions.emit(f ?? null);
-			},
-			{
-				name: "_ingest_audit",
-				describeKind: "derived",
-				initial: null,
-				meta: factMeta("audit"),
-			},
-		);
-		this.add(ingestAudit, { name: "_ingest_audit" });
-		this.addDisposer(keepalive(ingestAudit));
-
-		// ── Assemble public surface (readonly fields) ────────────────────────
-		this.shards = shards as readonly Node<FactStore<T>>[];
-		this.factStore = factStore;
-		this.dependentsIndex = dependentsIndex;
-		this.answer = answer;
-		this.cascade = cascade;
-		this.cascadeOverflow = cascadeOverflow;
-		this.review = review;
-		this.consolidated = consolidated;
-		this.events = events;
-		if (ingestLog) this.ingestLog = ingestLog;
-	}
-
-	// ── itemNode reactive read ───────────────────────────────────────────
-	/** Reactive read: a single fact by id (SENTINEL until the fact exists). */
-	itemNode(id: FactId): Node<MemoryFragment<T> | undefined> {
-		return node<MemoryFragment<T> | undefined>(
-			[this.factStore],
-			(batchData, actions, ctx) => {
-				const fs = lastOf<FactStore<T>>(batchData[0], ctx.prevData[0]);
-				actions.emit(fs?.byId.get(id));
-			},
-			{
-				name: `item_${id}`,
-				describeKind: "derived",
-				meta: factMeta("item"),
-			},
-		);
-	}
-}
-
-/**
- * Build a static-topology reactive fact store (DS-14.7 architecture C).
- *
- * Thin factory over {@link ReactiveFactStoreGraph} — see that class for the
- * full topology / locked-decision docs and the `instanceof`-narrowable type.
- *
- * @category memory
- */
-export function reactiveFactStore<T>(
-	config: ReactiveFactStoreConfig<T>,
-): ReactiveFactStoreGraph<T> {
-	return new ReactiveFactStoreGraph<T>(config);
-}
diff --git a/src/utils/memory/index.ts b/src/utils/memory/index.ts
deleted file mode 100644
index d1311775..00000000
--- a/src/utils/memory/index.ts
+++ /dev/null
@@ -1,1466 +0,0 @@
-/**
- * Memory patterns (roadmap §4.3) — public-face Phase-4 primitives audited under
- * `archive/docs/SESSION-public-face-blocks-review.md` (Wave A, locked 2026-04-25).
- *
- * Three primitives (the pure `decay` helper was promoted to `extra/utils/decay.ts`
- * per Tier 2.2 and is no longer re-exported here; `lightCollection` was folded
- * into `collection({ranked:false})` per Tier 2.3 and is no longer a separate
- * factory):
- * - {@link collection} / {@link CollectionGraph} — keyed memory store with
- *   optional decay-aware ranking. Pass `{ ranked: false }` for the previous
- *   `lightCollection` shape (Map + LRU + audit, no scoring).
- * - {@link vectorIndex} / {@link VectorIndexGraph} — reactive vector store with
- *   optional HNSW backend, retention, and reactive {@link VectorIndexGraph.searchNode}.
- * - {@link knowledgeGraph} / {@link KnowledgeGraph} — entities + typed edges with
- *   symmetric adjacency indexes and reactive {@link KnowledgeGraph.relatedNode}.
- *
- * **No imperative reads.** Per the API-style policy locked 2026-04-25, public-face
- * primitives expose reactive reads only — `itemNode` / `hasNode` / `searchNode` /
- * `relatedNode`. One-shot snapshots use `node.cache` after `awaitSettled`, or
- * `firstValueFrom(node)`.
- *
- * **Audit logs.** Every imperative mutation (`upsert / remove / clear / link /
- * unlink / rescore / reindex`) is wrapped via {@link mutate} and appends a
- * typed record to a public `events` log on the bundle / graph.
- *
- * @module
- */
-
-import { monotonicNs, type Node, NodeImpl, node, wallClockNs } from "@graphrefly/pure-ts/core";
-import type { ReactiveLogBundle } from "@graphrefly/pure-ts/extra";
-import { fromTimer, keepalive, reactiveMap } from "@graphrefly/pure-ts/extra";
-import { Graph } from "@graphrefly/pure-ts/graph";
-import { domainMeta } from "../../base/meta/domain-meta.js";
-import {
-	type BaseAuditRecord,
-	bumpCursor,
-	createAuditLog,
-	mutate,
-	registerCursor,
-} from "../../base/mutation/index.js";
-import type { NodeOrValue } from "../../base/resilience/_internal.js";
-import { decay } from "../../base/utils/decay.js";
-
-// ── Shared helpers ───────────────────────────────────────────────────────
-
-const NS_PER_SEC = 1_000_000_000;
-
-function memoryMeta(kind: string, extra?: Record<string, unknown>): Record<string, unknown> {
-	return domainMeta("memory", kind, extra);
-}
-
-/**
- * Coerce a value-or-Node argument into a `Node<T>`. Pass-through if already a
- * Node; otherwise wraps in `state(value, {name})`. Used by reactive read
- * factories (`itemNode` / `searchNode` / `relatedNode`) so callers can supply
- * a static value without manually creating a state node.
- *
- * Heuristic: anything that is a `NodeImpl` instance is a Node; everything else
- * is treated as a raw value to wrap.
- */
-function toNode<T>(v: T | Node<T>, name?: string): Node<T> {
-	if (v instanceof NodeImpl) return v as Node<T>;
-	return node<T>([], { initial: v as T, ...(name ? { name } : undefined) });
-}
-
-function ageSeconds(now: number, lastNs: number): number {
-	return (now - lastNs) / NS_PER_SEC;
-}
-
-// `decay` was promoted to `extra/utils/decay.ts` per Tier 2.2 — it is no longer
-// re-exported from this module. Import from `@graphrefly/graphrefly/extra` (or
-// `../../extra/utils/decay.js` internally) instead.
-
-/**
- * Cosine similarity over `(a, b)`. When lengths differ, the shorter is
- * implicitly zero-padded to the longer length. Returns `0` if either vector
- * has zero norm. Public utility — used by {@link VectorIndexGraph.searchNode}
- * and exposed for downstream consumers (e.g. `patterns/ai/memory/`) that need
- * the same scoring at the boundary.
- *
- * **Numeric guards.** Returns `0` for non-finite results (overflow producing
- * `Infinity`/`NaN` from very-large vectors, or `NaN` propagating from any
- * `NaN`/`Infinity` component). Without this guard, downstream sort
- * comparators would order NaN-scored rows arbitrarily.
- *
- * **Depth.** This is a per-call computation; no internal caching. For very
- * large indexes (>10k) consider precomputing norms or using HNSW.
- *
- * @category memory
- */
-export function cosineSimilarity(a: readonly number[], b: readonly number[]): number {
-	const n = Math.max(a.length, b.length);
-	let dot = 0;
-	let na = 0;
-	let nb = 0;
-	for (let i = 0; i < n; i += 1) {
-		const av = a[i] ?? 0;
-		const bv = b[i] ?? 0;
-		dot += av * bv;
-		na += av * av;
-		nb += bv * bv;
-	}
-	if (na === 0 || nb === 0) return 0;
-	const score = dot / Math.sqrt(na * nb);
-	return Number.isFinite(score) ? score : 0;
-}
-
-/**
- * Equality predicate for {@link VectorIndexGraph.searchNode} results. Compares
- * `id` AND `score` AND `meta` reference per position so that score-only changes
- * (re-upsert with new vector keeping the same top-K order) propagate to
- * downstream subscribers. The previous id-only comparator silently dropped
- * those updates.
- */
-function searchResultsEqual<TMeta>(
-	a: readonly VectorSearchResult<TMeta>[] | undefined,
-	b: readonly VectorSearchResult<TMeta>[] | undefined,
-): boolean {
-	if (a === b) return true;
-	if (a == null || b == null) return false;
-	if (a.length !== b.length) return false;
-	for (let i = 0; i < a.length; i += 1) {
-		const x = a[i]!;
-		const y = b[i]!;
-		if (x.id !== y.id || x.score !== y.score || x.meta !== y.meta) return false;
-	}
-	return true;
-}
-
-// ── Common types ─────────────────────────────────────────────────────────
-
-/** Public alias for the `Node | value` shape accepted by reactive read factories. */
-export type { NodeOrValue } from "../../base/resilience/_internal.js";
-
-// ── Unit 2 (Tier 2.3 fold): collection (formerly lightCollection + collection)
-//
-// Pre-Tier-2.3 the module shipped `lightCollection` (no Graph, no ranking,
-// just LRU + audit) alongside `collection` (Graph-mounted with timer-driven
-// decay-aware ranking). Per the consolidation plan §1 Rule 4, the two are
-// folded into a single `collection({ranked: true|false})` factory: when
-// `ranked: false`, no `ranked` derived / refresh tick / scoring is wired.
-// `LightCollectionEntry` is gone — `CollectionEntry<T>` is the unified entry
-// shape (`baseScore` reads `0` in unranked mode).
-
-export type CollectionEntry<T> = {
-	readonly id: string;
-	readonly value: T;
-	readonly createdAtNs: number;
-	readonly lastAccessNs: number;
-	readonly baseScore: number;
-};
-
-export type RankedCollectionEntry<T> = CollectionEntry<T> & {
-	readonly score: number;
-};
-
-export type CollectionScoreFn<T> = (value: T) => number;
-
-export type CollectionOptions<T> = {
-	maxSize?: number;
-	/**
-	 * Whether to expose a live decay-aware `ranked` node + `rescore` mutator.
-	 * Default `true`. Pass `false` to fold in the previous `lightCollection`
-	 * shape — entries are still keyed/audited/LRU-evicted, but the timer-driven
-	 * `ranked` + scoring machinery is skipped. `ranked` then resolves to a
-	 * static empty array Node and `rescore()` is a no-op (so callers writing
-	 * type-generic code don't need to special-case the unranked path).
-	 */
-	ranked?: boolean;
-	/**
-	 * Produces a base score at insert/update time. Static fn or a reactive
-	 * `Node<(value: T) => number>` — when supplied as a Node, `ranked` re-derives
-	 * whenever the score fn changes, but `baseScore` on each entry is only
-	 * recomputed via {@link CollectionGraph.rescore}. Default `() => 1`.
-	 *
-	 * Ignored when `ranked: false` (entries record `baseScore: 0`).
-	 */
-	score?: CollectionScoreFn<T> | Node<CollectionScoreFn<T>>;
-	/**
-	 * Exponential decay rate per second. `0` disables decay (default). When
-	 * positive, `ranked` becomes fully reactive on time via a `fromTimer` source
-	 * (cadence auto-derived from `decayRate` unless overridden via
-	 * `refreshIntervalMs`). Half-life: `ratePerSecond = Math.LN2 / halfLifeSeconds`.
-	 *
-	 * Ignored when `ranked: false`.
-	 */
-	decayRate?: number;
-	/** Minimum score floor after decay. Default `0`. */
-	minScore?: number;
-	/**
-	 * Override for the `ranked` refresh tick cadence (milliseconds). When
-	 * unset and `decayRate > 0`, defaults to `1000 * Math.LN2 / (10 * decayRate)`
-	 * — roughly one tick per 10% of the half-life (~10% staleness budget).
-	 */
-	refreshIntervalMs?: number;
-};
-
-export interface CollectionAuditRecord extends BaseAuditRecord {
-	readonly action: "upsert" | "remove" | "clear" | "rescore";
-	readonly id?: string;
-}
-
-export type CollectionGraph<T> = Graph & {
-	readonly events: ReactiveLogBundle<CollectionAuditRecord>;
-	readonly items: Node<ReadonlyMap<string, CollectionEntry<T>>>;
-	/**
-	 * Live decay-aware ranking, sorted by score descending. When the
-	 * collection was constructed with `ranked: false`, this is a static
-	 * empty-array Node (kept for type uniformity).
-	 */
-	readonly ranked: Node<readonly RankedCollectionEntry<T>[]>;
-	readonly size: Node<number>;
-	upsert: (id: string, value: T, opts?: { score?: number }) => void;
-	remove: (id: string) => void;
-	clear: () => void;
-	/**
-	 * Recompute every entry's `baseScore` via the latest score fn. O(N). Useful
-	 * when a reactive `score` Node has emitted a new fn and the caller wants
-	 * existing entries re-scored without an explicit re-upsert.
-	 *
-	 * No-op (still records an audit entry) when constructed with
-	 * `ranked: false`.
-	 */
-	rescore: () => void;
-	itemNode: (id: NodeOrValue<string>) => Node<CollectionEntry<T> | undefined>;
-	/** Reactive `true` once the entry exists; tracks upsert / remove. */
-	hasNode: (id: NodeOrValue<string>) => Node<boolean>;
-};
-
-function rankedEqual<T>(
-	a: readonly RankedCollectionEntry<T>[] | undefined,
-	b: readonly RankedCollectionEntry<T>[] | undefined,
-): boolean {
-	if (a === b) return true;
-	if (a == null || b == null) return false;
-	if (a.length !== b.length) return false;
-	for (let i = 0; i < a.length; i += 1) {
-		const x = a[i]!;
-		const y = b[i]!;
-		// Compare value reference too — if `upsert(id, newValue)` runs and
-		// `score(newValue) === score(oldValue)` AND timestamps coincide
-		// (rare on platforms where consecutive `monotonicNs()` calls in the
-		// same microtask collide), the prior comparator suppressed the
-		// emission and consumers reading `entry.value` saw stale data.
-		// Value identity catches it cheaply (`value !== value` only on NaN
-		// payloads, which behave correctly here).
-		if (
-			x.id !== y.id ||
-			x.score !== y.score ||
-			x.lastAccessNs !== y.lastAccessNs ||
-			x.value !== y.value
-		)
-			return false;
-	}
-	return true;
-}
-
-/**
- * Scored memory store with live decay-aware ranking.
- *
- * Topology (mounted on the returned graph):
- *  - `items` — `reactiveMap<id, CollectionEntry<T>>` (with `retention` configured
- *    for score-based eviction when `maxSize` is set).
- *  - `ranked` — `Node<readonly RankedCollectionEntry<T>[]>`, sorted by live
- *    decayed score. **Lazy** — does NOT compute until subscribed (no internal
- *    keepalive). Use `keepalive(coll.ranked)` for eager activation.
- *  - `size` — `Node<number>`, count of entries.
- *  - `_refreshTick` — `fromTimer`-driven `monotonicNs()` source, mounted only
- *    when `decayRate > 0`. Drives `ranked`'s time-dependent re-derivation.
- *  - `_seq` — sequence cursor for the audit log.
- *  - `events` — bounded reactive log of every mutation.
- *
- * **Time as a reactive dep.** When `decayRate > 0`, `ranked`'s deps are
- * `[items, refreshTick]` — the tick payload IS `monotonicNs()`, so the fn is
- * pure of deps and dry-run-reproducible with a mocked clock.
- *
- * **Lazy timer.** With no subscriber to `ranked`, the timer source does not
- * fire — the activation chain is downstream-driven. To keep the timer warm
- * without consuming results, register `graph.addDisposer(keepalive(coll.ranked))`.
- *
- * **Eviction at write-time.** Score-based retention runs on every successful
- * `upsert / remove / clear` (it is mutation-driven, not tick-driven). The
- * retention scorer reads `monotonicNs()` to compute decayed scores at eviction
- * time — this is a deliberate impurity vs. `ReactiveMapRetention.score`'s
- * "pure of `(key, value)`" docstring: write-time is the right moment to evict
- * stale-by-decay entries.
- *
- * **No imperative reads.** Subscribe to `items` / `ranked` for live snapshots,
- * or use `itemNode(id)` for single-key reactive reads.
- *
- * **`rescore` ordering caveat.** `rescore()` reads `items.entries.cache`
- * (the post-emission snapshot) and writes via `setMany`. When called
- * stand-alone it sees the latest committed state. When wrapped inside a
- * user-level `batch(() => { coll.upsert(...); coll.rescore(); })`, the
- * `cache` snapshot reflects state BEFORE the batch — so a just-staged
- * upsert is invisible to the rescore scan. If you need rescore to include
- * the staged upsert, either call `rescore()` after the batch settles or
- * pass the new `baseScore` directly via `upsert(id, value, { score })`.
- *
- * **Audit no-op records.** Like `lightCollection`, mutations record audit
- * entries even when the impl was a no-op (e.g., `rescore()` on an empty
- * store). Intentional — the framework records attempts.
- *
- * @category memory
- */
-export function collection<T>(name: string, opts: CollectionOptions<T> = {}): CollectionGraph<T> {
-	const maxSize = opts.maxSize;
-	const ranked = opts.ranked ?? true;
-	// `decayRate` / `score` / `refreshIntervalMs` are no-ops when ranked is off
-	// (they only feed the `ranked` derived). The audit + LRU paths still run.
-	const decayRate = ranked ? (opts.decayRate ?? 0) : 0;
-	const minScore = opts.minScore ?? 0;
-	if (maxSize !== undefined && maxSize < 1) {
-		throw new RangeError("collection: maxSize must be >= 1");
-	}
-
-	// Resolve score fn — supports static fn or reactive Node<fn>. When
-	// `ranked: false` the score is constant `0` and `readScoreFn` is unused
-	// (the upsert path takes the `_opts.score ?? readScoreFn()(value)` branch
-	// only when ranking is requested).
-	const scoreFnDefault: CollectionScoreFn<T> = () => (ranked ? 1 : 0);
-	const scoreInput = opts.score ?? scoreFnDefault;
-	const scoreNode: Node<CollectionScoreFn<T>> | undefined =
-		ranked && scoreInput instanceof NodeImpl
-			? (scoreInput as Node<CollectionScoreFn<T>>)
-			: undefined;
-	const readScoreFn = (): CollectionScoreFn<T> => {
-		if (scoreNode) return scoreNode.cache ?? scoreFnDefault;
-		return scoreInput as CollectionScoreFn<T>;
-	};
-
-	const graph = new Graph(name);
-
-	// Score-based retention scorer for `reactiveMap`. When unranked the base
-	// score is `0`, so retention falls back to LRU-by-`lastAccessNs` (the
-	// older the access, the lower the decayed score → first to evict).
-	const retentionScore = (_k: string, v: CollectionEntry<T>): number =>
-		ranked
-			? decay(v.baseScore, ageSeconds(monotonicNs(), v.lastAccessNs), decayRate, minScore)
-			: v.lastAccessNs;
-
-	const items = reactiveMap<string, CollectionEntry<T>>({
-		name: "items",
-		...(maxSize !== undefined ? { retention: { score: retentionScore, maxSize } } : {}),
-	});
-
-	graph.add(items.entries, { name: "items" });
-
-	// Refresh tick — only mounted when ranking + decay are configured. Tick
-	// payload is `monotonicNs()`, so `rankedNode`'s fn is pure-of-deps and
-	// dry-run-reproducible.
-	let refreshTick: Node<number> | undefined;
-	if (ranked && decayRate > 0) {
-		const intervalMs = opts.refreshIntervalMs ?? Math.max(1, (1000 * Math.LN2) / (10 * decayRate));
-		const tickCounter = fromTimer(intervalMs, { period: intervalMs });
-		// Map each tick to the wall-clock `monotonicNs` — the tick payload IS
-		// the time stamp downstream consumers use. Reading the central clock
-		// inside this fn is sanctioned: this derived's purpose is to publish
-		// "now" reactively (cf. spec §5.11 — central timer), and downstream
-		// `rankedNode` reads it from its dep array, never from the clock
-		// directly.
-		//
-		// `initial: monotonicNs()` seeds the cache with construction-time
-		// `now` so push-on-subscribe delivers DATA to `rankedNode` before the
-		// first tick fires — without this, `rankedNode` would stall in pending
-		// status until ~`refreshIntervalMs` after first activation, and a
-		// caller reading `rankedNode.cache` immediately after `upsert` would
-		// see `undefined`.
-		refreshTick = node(
-			[tickCounter],
-			(_batchData, actions) => {
-				actions.emit(monotonicNs());
-			},
-			{
-				name: "refresh_tick_ns",
-				describeKind: "derived",
-				initial: monotonicNs(),
-				meta: memoryMeta("clock"),
-			},
-		);
-		graph.add(refreshTick, { name: "refresh_tick_ns" });
-	}
-
-	// `rankedNode` derived — pure of (items, refreshTick?, scoreNode?). When
-	// `ranked: false`, `rankedNode` is a static empty-array node so the
-	// public type stays uniform without re-running the sort.
-	let rankedNode: Node<readonly RankedCollectionEntry<T>[]>;
-	if (ranked) {
-		const rankedDeps: Node<unknown>[] = [items.entries];
-		if (refreshTick) rankedDeps.push(refreshTick);
-		if (scoreNode) rankedDeps.push(scoreNode);
-		rankedNode = node(
-			rankedDeps,
-			(batchData, actions, ctx) => {
-				const values = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				const snapshot = values[0] as ReadonlyMap<string, CollectionEntry<T>> | undefined;
-				let now: number;
-				if (refreshTick) {
-					const tickValue = values[1] as number | undefined;
-					now = typeof tickValue === "number" ? tickValue : monotonicNs();
-				} else {
-					now = monotonicNs();
-				}
-				if (!snapshot || snapshot.size === 0) {
-					actions.emit([] as readonly RankedCollectionEntry<T>[]);
-					return;
-				}
-				const out: RankedCollectionEntry<T>[] = [];
-				for (const entry of snapshot.values()) {
-					out.push({
-						...entry,
-						score: decay(entry.baseScore, ageSeconds(now, entry.lastAccessNs), decayRate, minScore),
-					});
-				}
-				out.sort((a, b) => b.score - a.score || b.lastAccessNs - a.lastAccessNs);
-				actions.emit(out as readonly RankedCollectionEntry<T>[]);
-			},
-			{
-				name: "ranked",
-				describeKind: "derived",
-				equals: rankedEqual,
-				meta: memoryMeta("ranked"),
-			},
-		) as Node<readonly RankedCollectionEntry<T>[]>;
-		graph.add(rankedNode, { name: "ranked" });
-	} else {
-		rankedNode = node<readonly RankedCollectionEntry<T>[]>([], {
-			initial: [] as readonly RankedCollectionEntry<T>[],
-			name: "ranked",
-			describeKind: "state",
-			meta: memoryMeta("ranked_disabled"),
-		}) as Node<readonly RankedCollectionEntry<T>[]>;
-		graph.add(rankedNode, { name: "ranked" });
-	}
-
-	const size = node(
-		[items.entries],
-		(batchData, actions, ctx) => {
-			const data = batchData.map((batch, i) =>
-				batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-			);
-			const snapshot = data[0] as ReadonlyMap<string, CollectionEntry<T>> | undefined;
-			actions.emit(((snapshot ?? new Map()) as ReadonlyMap<string, CollectionEntry<T>>).size);
-		},
-		{
-			name: "size",
-			describeKind: "derived",
-			initial: 0,
-			meta: memoryMeta("size"),
-		},
-	);
-	graph.add(size, { name: "size" });
-	// Keepalive only on `size` (cheap; pure of items). `ranked` is intentionally
-	// lazy so the refresh timer doesn't fire when nothing consumes the ranking.
-	graph.addDisposer(keepalive(size));
-
-	// Audit log + seq cursor.
-	const events = createAuditLog<CollectionAuditRecord>({
-		name: "events",
-		retainedLimit: 1024,
-		graph,
-	});
-	const seqCursor = registerCursor(graph, "seq", 0);
-
-	const upsertImpl = (id: string, value: T, _opts?: { score?: number }): void => {
-		const now = monotonicNs();
-		const prev = items.get(id);
-		const baseScore = _opts?.score ?? readScoreFn()(value);
-		items.set(id, {
-			id,
-			value,
-			baseScore,
-			createdAtNs: prev?.createdAtNs ?? now,
-			lastAccessNs: now,
-		});
-	};
-	const removeImpl = (id: string): void => {
-		if (!items.has(id)) return;
-		items.delete(id);
-	};
-	const clearImpl = (): void => {
-		if (items.size === 0) return;
-		items.clear();
-	};
-	const rescoreImpl = (): void => {
-		// `ranked: false` short-circuit — there's no live `ranked` node to
-		// re-derive and `baseScore` is held at its insertion-time value, so
-		// rescore is a no-op. The audit record is still emitted so consumers
-		// see the attempt.
-		if (!ranked) return;
-		const fn = readScoreFn();
-		const snapshot = items.entries.cache as ReadonlyMap<string, CollectionEntry<T>> | undefined;
-		if (!snapshot || snapshot.size === 0) return;
-		const updates: Array<[string, CollectionEntry<T>]> = [];
-		for (const entry of snapshot.values()) {
-			updates.push([entry.id, { ...entry, baseScore: fn(entry.value) }]);
-		}
-		items.setMany(updates);
-	};
-
-	const upsert = mutate(upsertImpl, {
-		frame: "inline",
-		log: events,
-		seq: seqCursor,
-		onSuccessRecord: ([id], _r, m) => ({ action: "upsert" as const, id, t_ns: m.t_ns, seq: m.seq }),
-	});
-	const remove = mutate(removeImpl, {
-		frame: "inline",
-		log: events,
-		seq: seqCursor,
-		onSuccessRecord: ([id], _r, m) => ({ action: "remove" as const, id, t_ns: m.t_ns, seq: m.seq }),
-	});
-	const clear = mutate(clearImpl, {
-		frame: "inline",
-		log: events,
-		seq: seqCursor,
-		onSuccessRecord: (_args, _r, m) => ({ action: "clear" as const, t_ns: m.t_ns, seq: m.seq }),
-	});
-	const rescore = mutate(rescoreImpl, {
-		frame: "inline",
-		log: events,
-		seq: seqCursor,
-		onSuccessRecord: (_args, _r, m) => ({ action: "rescore" as const, t_ns: m.t_ns, seq: m.seq }),
-	});
-
-	function itemNode(id: NodeOrValue<string>): Node<CollectionEntry<T> | undefined> {
-		const idN = toNode(id, "id");
-		return node(
-			[items.entries, idN],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				const map = data[0] as ReadonlyMap<string, CollectionEntry<T>> | undefined;
-				const key = data[1] as string;
-				actions.emit(map?.get(key));
-			},
-			{
-				describeKind: "derived",
-				meta: memoryMeta("collection_item"),
-			},
-		);
-	}
-
-	function hasNode(id: NodeOrValue<string>): Node<boolean> {
-		const idN = toNode(id, "id");
-		return node(
-			[items.entries, idN],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				const map = data[0] as ReadonlyMap<string, CollectionEntry<T>> | undefined;
-				const key = data[1] as string;
-				actions.emit(map?.has(key) ?? false);
-			},
-			{
-				describeKind: "derived",
-				meta: memoryMeta("collection_has"),
-			},
-		);
-	}
-
-	const out = Object.assign(graph, {
-		events,
-		items: items.entries,
-		ranked: rankedNode,
-		size,
-		upsert,
-		remove,
-		clear,
-		rescore,
-		itemNode,
-		hasNode,
-	}) as CollectionGraph<T>;
-	return out;
-}
-
-// ── Unit 4: vectorIndex ──────────────────────────────────────────────────
-
-export type VectorBackend = "flat" | "hnsw";
-
-export type VectorRecord<TMeta> = {
-	readonly id: string;
-	readonly vector: readonly number[];
-	readonly meta?: TMeta;
-	/** Wall-clock-monotonic timestamp at last upsert; used for the default LRU retention. */
-	readonly upsertedAtNs: number;
-};
-
-export type VectorSearchResult<TMeta> = {
-	readonly id: string;
-	readonly score: number;
-	readonly meta?: TMeta;
-};
-
-export type HnswAdapter<TMeta> = {
-	upsert: (id: string, vector: readonly number[], meta?: TMeta) => void;
-	remove: (id: string) => void;
-	clear: () => void;
-	search: (query: readonly number[], k: number) => ReadonlyArray<VectorSearchResult<TMeta>>;
-	/** Optional adapter teardown. Called from `graph.destroy()` via `addDisposer`. */
-	dispose?: () => void;
-};
-
-export type VectorIndexOptions<TMeta> = {
-	name?: string;
-	backend?: VectorBackend;
-	dimension?: number;
-	/**
-	 * Strict-dimension default. When `true` (default) AND `dimension` is unset,
-	 * mixed-length upserts throw `RangeError`. Set `false` to opt into the
-	 * lenient zero-padding behavior of {@link VectorIndexGraph.searchNode}.
-	 */
-	strictDimension?: boolean;
-	/** Optional dependency seam for HNSW. */
-	hnswFactory?: () => HnswAdapter<TMeta>;
-	/** Maximum live entries (LRU-by-upsert-time when set; user-overridable via `retentionScore`). */
-	maxSize?: number;
-	/** Custom retention scorer. Higher score = kept. Defaults to `r => r.upsertedAtNs`. */
-	retentionScore?: (record: VectorRecord<TMeta>) => number;
-};
-
-export interface VectorIndexAuditRecord extends BaseAuditRecord {
-	readonly action: "upsert" | "remove" | "clear" | "reindex" | "evict";
-	readonly id?: string;
-}
-
-export type VectorIndexGraph<TMeta> = Graph & {
-	readonly backend: VectorBackend;
-	readonly events: ReactiveLogBundle<VectorIndexAuditRecord>;
-	readonly entries: Node<ReadonlyMap<string, VectorRecord<TMeta>>>;
-	upsert: (id: string, vector: readonly number[], meta?: TMeta) => void;
-	remove: (id: string) => void;
-	clear: () => void;
-	/** Re-push every live entry into the optional HNSW adapter. No-op for `flat`. */
-	reindex: () => void;
-	/**
-	 * Reactive top-K search. Re-derives whenever entries / query / k change.
-	 * Lazy. Use `firstValueFrom(searchNode(...))` for one-shot reads.
-	 */
-	searchNode: (
-		query: Node<readonly number[]>,
-		k?: NodeOrValue<number>,
-	) => Node<readonly VectorSearchResult<TMeta>[]>;
-};
-
-/**
- * Reactive vector store with optional HNSW backend.
- *
- * **Storage on `reactiveMap`.** `entries` is a `reactiveMap<id, VectorRecord<TMeta>>`
- * with optional score-based retention (`maxSize` + LRU-by-`upsertedAtNs` by
- * default; user can supply a custom `retentionScore`). On retention eviction,
- * the HNSW adapter (if configured) is also notified via `adapter.remove(id)`.
- *
- * **Reactive search.** `searchNode(queryNode, k)` returns a `Node<readonly
- * VectorSearchResult<TMeta>[]>` that re-derives on entries / query / k change.
- * Lazy — only computes when subscribed. Imperative `search()` is intentionally
- * not exposed (no-imperative-reads policy). Use `firstValueFrom(searchNode(...))`
- * for one-shot reads.
- *
- * **Strict dimension.** Default `strictDimension: true` — if `dimension` is
- * unset and an upsert produces a vector of a different length than the first
- * upserted, throws `RangeError`. Pass `strictDimension: false` to opt into
- * the lenient zero-padding fallback (the previous default).
- *
- * **Adapter lifecycle.** When the HNSW adapter exposes a `dispose()` method,
- * it is bound to the graph's teardown via `addDisposer`. When retention
- * evicts an entry, `adapter.remove(id)` is invoked synchronously inside the
- * retention `onArchive` callback.
- *
- * **Cosine zero-pad.** The flat backend uses cosine similarity over the
- * pairwise max-length zero-pad. Mixing dimensions silently degrades scores
- * unless strict mode catches it at upsert time. For embedding-model vectors,
- * L2-normalize at the source — `vectorIndex` does not normalize.
- *
- * @category memory
- */
-export function vectorIndex<TMeta>(opts: VectorIndexOptions<TMeta> = {}): VectorIndexGraph<TMeta> {
-	const backend = opts.backend ?? "flat";
-	const dimension = opts.dimension;
-	const strictDimension = opts.strictDimension ?? true;
-	const maxSize = opts.maxSize;
-	const userRetentionScore = opts.retentionScore;
-
-	let hnsw: HnswAdapter<TMeta> | undefined;
-	if (backend === "hnsw") {
-		hnsw = opts.hnswFactory?.();
-		if (!hnsw) {
-			throw new Error(
-				'vectorIndex backend "hnsw" requires an optional dependency adapter; install your HNSW package and provide `hnswFactory`.',
-			);
-		}
-	}
-
-	const graph = new Graph(opts.name ?? "vector_index");
-
-	// Track an inferred dimension when the user didn't lock it but strict mode
-	// is on — first upsert sets it; subsequent mismatches throw.
-	let inferredDimension: number | undefined;
-	function assertDimension(vector: readonly number[]): void {
-		if (dimension !== undefined) {
-			if (vector.length !== dimension) {
-				throw new RangeError(
-					`vector dimension mismatch: expected ${dimension}, got ${vector.length}`,
-				);
-			}
-			return;
-		}
-		if (!strictDimension) return;
-		if (inferredDimension === undefined) {
-			inferredDimension = vector.length;
-			return;
-		}
-		if (vector.length !== inferredDimension) {
-			throw new RangeError(
-				`vector dimension mismatch: inferred ${inferredDimension} from first upsert, got ${vector.length}. ` +
-					`Pass \`strictDimension: false\` to opt into zero-pad behavior, or set an explicit \`dimension\`.`,
-			);
-		}
-	}
-
-	const baseRetentionScore = userRetentionScore ?? ((r: VectorRecord<TMeta>) => r.upsertedAtNs);
-	// `clearInProgress` lets us short-circuit the per-entry `onArchive` →
-	// `hnsw.remove(id)` cascade when the user calls `clearImpl()`. Retention
-	// fires `onArchive` for every evicted entry; followed by an explicit
-	// `hnsw.clear()` we'd double-touch the adapter. Inside `clearImpl` we
-	// flip this flag, then call `hnsw.clear()` once at the end. (G fix.)
-	let clearInProgress = false;
-
-	// `clearAuditPending` defers the per-entry `evict` audit emission when a
-	// `clear()` is in flight — those evictions are reported as a single
-	// `clear` action, not a flurry of `evict` records.
-	const events = createAuditLog<VectorIndexAuditRecord>({
-		name: "events",
-		retainedLimit: 1024,
-		graph,
-	});
-	const seqCursor = registerCursor(graph, "seq", 0);
-
-	const entries = reactiveMap<string, VectorRecord<TMeta>>({
-		name: "entries",
-		...(maxSize !== undefined
-			? {
-					retention: {
-						score: (_k, v) => baseRetentionScore(v),
-						maxSize,
-						onArchive: (key) => {
-							if (clearInProgress) return;
-							if (backend === "hnsw") hnsw!.remove(key);
-							// E1: surface retention-driven evictions in the audit log
-							// so replay consumers can reconstruct the live snapshot
-							// from `events` alone. `seq` is bumped via the cursor;
-							// the `t_ns` matches `wallClockNs()` for consistency
-							// with `lightMutation`'s record stamping.
-							events.append({
-								action: "evict" as const,
-								id: key,
-								t_ns: wallClockNs(),
-								seq: bumpCursor(seqCursor),
-							});
-						},
-					},
-				}
-			: {}),
-	});
-	graph.add(entries.entries, { name: "entries" });
-	// F1: keep `entries` warm so downstream consumers reading
-	// `vectors.entries.cache` (e.g. `patterns/ai/memory/runRetrieval`) don't
-	// rely on an external subscriber to activate the node. State nodes are
-	// ROM and retain `.cache` regardless of subscribers — this `keepalive`
-	// is defense-in-depth and matches the kg's adjacency keepalive pattern.
-	graph.addDisposer(keepalive(entries.entries));
-
-	// HNSW dispose runs BEFORE state-node teardown via standard disposer
-	// ordering (disposers drain first, then `[[TEARDOWN]]` propagates per
-	// `Graph.destroy()`). This is the right ordering: free the adapter's
-	// native resources before the reactive layer tears down.
-	if (hnsw?.dispose) {
-		const disposeAdapter = hnsw.dispose.bind(hnsw);
-		graph.addDisposer(() => disposeAdapter());
-	}
-
-	const upsertImpl = (id: string, vector: readonly number[], meta?: TMeta): void => {
-		assertDimension(vector);
-		// B1: mutate HNSW first so a throw aborts the reactive write. With
-		// the prior order (entries.set then hnsw.upsert), an adapter throw
-		// would leave entries holding a row HNSW didn't index. Now: HNSW
-		// commits first; if it throws, entries is untouched and audit log
-		// records the failure.
-		if (backend === "hnsw") hnsw!.upsert(id, vector, meta);
-		// Defensive copies: vector via `[...vector]`; meta via shallow spread
-		// when it's a non-null object (Array.isArray covered first since arrays
-		// are objects). Primitives, `null`, functions etc. pass through
-		// unchanged. Documented depth limitation: nested objects in `meta` are
-		// shared by reference.
-		const copiedMeta: TMeta | undefined = (() => {
-			if (meta === undefined) return undefined;
-			if (meta === null || typeof meta !== "object") return meta;
-			return Array.isArray(meta) ? ([...meta] as unknown as TMeta) : ({ ...meta } as TMeta);
-		})();
-		const record: VectorRecord<TMeta> = {
-			id,
-			vector: [...vector],
-			...(copiedMeta !== undefined ? { meta: copiedMeta } : {}),
-			upsertedAtNs: monotonicNs(),
-		};
-		entries.set(id, record);
-	};
-	const removeImpl = (id: string): void => {
-		if (!entries.has(id)) return;
-		// B1: HNSW first, then entries.
-		if (backend === "hnsw") hnsw!.remove(id);
-		entries.delete(id);
-	};
-	const clearImpl = (): void => {
-		if (entries.size === 0) return;
-		// B1 + G: mark the clear-in-progress flag so retention `onArchive`
-		// suppresses per-entry HNSW removes AND per-entry `evict` audit
-		// records. Then call `entries.clear()` (drains the backend through
-		// retention archival without side effects), and finally call
-		// `hnsw.clear()` once. Reset `inferredDimension` so a fresh start
-		// re-infers from the next upsert.
-		clearInProgress = true;
-		try {
-			entries.clear();
-			if (backend === "hnsw") hnsw!.clear();
-		} finally {
-			clearInProgress = false;
-		}
-		inferredDimension = undefined;
-	};
-	const reindexImpl = (): void => {
-		if (backend !== "hnsw") return;
-		const snapshot = entries.entries.cache as ReadonlyMap<string, VectorRecord<TMeta>> | undefined;
-		if (!snapshot) return;
-		hnsw!.clear();
-		for (const r of snapshot.values()) {
-			hnsw!.upsert(r.id, r.vector, r.meta);
-		}
-	};
-
-	// `freeze: false` for `upsert` — deep-freezing a 768-dim vector is a
-	// measurable hot-path tax, and the wrapper does its own defensive copy
-	// (`vector: [...vector]`) before persisting. See §B.2 of the audit lock.
-	const upsert = mutate(upsertImpl, {
-		frame: "inline",
-		log: events,
-		freeze: false,
-		seq: seqCursor,
-		onSuccessRecord: ([id], _r, m) => ({ action: "upsert" as const, id, t_ns: m.t_ns, seq: m.seq }),
-	});
-	const remove = mutate(removeImpl, {
-		frame: "inline",
-		log: events,
-		seq: seqCursor,
-		onSuccessRecord: ([id], _r, m) => ({ action: "remove" as const, id, t_ns: m.t_ns, seq: m.seq }),
-	});
-	const clear = mutate(clearImpl, {
-		frame: "inline",
-		log: events,
-		seq: seqCursor,
-		onSuccessRecord: (_args, _r, m) => ({ action: "clear" as const, t_ns: m.t_ns, seq: m.seq }),
-	});
-	const reindex = mutate(reindexImpl, {
-		frame: "inline",
-		log: events,
-		seq: seqCursor,
-		onSuccessRecord: (_args, _r, m) => ({ action: "reindex" as const, t_ns: m.t_ns, seq: m.seq }),
-	});
-
-	function searchNode(
-		query: Node<readonly number[]>,
-		k: NodeOrValue<number> = 5,
-	): Node<readonly VectorSearchResult<TMeta>[]> {
-		const kN = toNode<number>(k, "k");
-		return node(
-			[entries.entries, query, kN],
-			(batchData, actions, ctx) => {
-				const values = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				const snapshot = values[0] as ReadonlyMap<string, VectorRecord<TMeta>> | undefined;
-				const q = values[1] as readonly number[] | undefined;
-				const kRaw = values[2] as number;
-				// Auto-fix: `Math.max(0, Math.floor(k))` — `| 0` is a 32-bit
-				// signed truncation that collapses Infinity to 0 and wraps
-				// values > 2^31. Use a proper floor with a non-negative floor.
-				const kVal = Number.isFinite(kRaw) ? Math.max(0, Math.floor(kRaw)) : 0;
-				if (!snapshot || snapshot.size === 0 || kVal <= 0) {
-					actions.emit([] as readonly VectorSearchResult<TMeta>[]);
-					return;
-				}
-				// Auto-fix: defensive guard for unset / empty query — earlier
-				// the fn would TypeError on `q.length` reading `undefined`,
-				// or compute meaningless all-zero scores against an empty
-				// vector. With strict-dimension OR an explicit `dimension`,
-				// also reject mismatched-length queries (the imperative path
-				// used to throw; reactive deriveds shouldn't throw, so
-				// degrade to empty results).
-				if (q == null || q.length === 0) {
-					actions.emit([] as readonly VectorSearchResult<TMeta>[]);
-					return;
-				}
-				const expectedDim = dimension ?? (strictDimension ? inferredDimension : undefined);
-				if (expectedDim !== undefined && q.length !== expectedDim) {
-					actions.emit([] as readonly VectorSearchResult<TMeta>[]);
-					return;
-				}
-				if (backend === "hnsw") {
-					// Defensive copy of the adapter's return — HNSW libs
-					// sometimes hand back internal buffers; downstream
-					// subscribers must not be able to corrupt adapter state.
-					const adapterResults = hnsw!.search(q, kVal);
-					actions.emit([...adapterResults] as readonly VectorSearchResult<TMeta>[]);
-					return;
-				}
-				const ranked = [...snapshot.values()]
-					.map((row) => {
-						const result: VectorSearchResult<TMeta> = {
-							id: row.id,
-							score: cosineSimilarity(q, row.vector),
-							...(row.meta !== undefined ? { meta: row.meta } : {}),
-						};
-						return result;
-					})
-					.sort((a, b) => b.score - a.score)
-					.slice(0, kVal);
-				actions.emit(ranked as readonly VectorSearchResult<TMeta>[]);
-			},
-			{
-				describeKind: "derived",
-				// A1: include `score` in equality. The previous id-only
-				// comparator suppressed re-emissions when the same set of
-				// IDs/order had different scores (re-upsert with new
-				// vector; query change preserving ranking order).
-				equals: (a, b) => searchResultsEqual(a, b),
-				meta: memoryMeta("vector_search"),
-			},
-		) as Node<readonly VectorSearchResult<TMeta>[]>;
-	}
-
-	const out = Object.assign(graph, {
-		backend,
-		events,
-		entries: entries.entries,
-		upsert,
-		remove,
-		clear,
-		reindex,
-		searchNode,
-	}) as VectorIndexGraph<TMeta>;
-	return out;
-}
-
-// ── Unit 5: knowledgeGraph ───────────────────────────────────────────────
-
-export type KnowledgeEdge<TRelation extends string = string> = {
-	readonly from: string;
-	readonly to: string;
-	readonly relation: TRelation;
-	readonly weight: number;
-};
-
-export type KnowledgeGraphOptions = {
-	/** Cap on entity count (LRU-by-upsert-time when set). */
-	entitiesMaxSize?: number;
-	/** Cap on edge count (LRU-by-upsert-time when set). */
-	edgesMaxSize?: number;
-	/**
-	 * Orphan-entity garbage collection. `"keep"` (default) leaves entities
-	 * untouched when their last edge is unlinked; `"remove"` deletes the
-	 * entity post-`unlink` if no edges reference it.
-	 */
-	orphanGC?: "keep" | "remove";
-};
-
-export interface KnowledgeGraphAuditRecord extends BaseAuditRecord {
-	readonly action: "upsertEntity" | "removeEntity" | "link" | "unlink" | "orphanRemove";
-	readonly id?: string;
-	readonly from?: string;
-	readonly to?: string;
-	readonly relation?: string;
-	/** Edge weight at the time of the `link`. Omitted for non-edge actions. */
-	readonly weight?: number;
-}
-
-export type KnowledgeGraph<TEntity, TRelation extends string = string> = Graph & {
-	readonly events: ReactiveLogBundle<KnowledgeGraphAuditRecord>;
-	readonly entities: Node<ReadonlyMap<string, TEntity>>;
-	readonly edges: Node<ReadonlyMap<string, KnowledgeEdge<TRelation>>>;
-	readonly adjacencyOut: Node<ReadonlyMap<string, readonly KnowledgeEdge<TRelation>[]>>;
-	readonly adjacencyIn: Node<ReadonlyMap<string, readonly KnowledgeEdge<TRelation>[]>>;
-	readonly entityCount: Node<number>;
-	readonly edgeCount: Node<number>;
-	upsertEntity: (id: string, value: TEntity) => void;
-	removeEntity: (id: string) => void;
-	link: (from: string, to: string, relation: TRelation, weight?: number) => void;
-	unlink: (from: string, to: string, relation?: TRelation) => void;
-	relatedNode: (
-		id: NodeOrValue<string>,
-		relation?: NodeOrValue<TRelation>,
-	) => Node<readonly KnowledgeEdge<TRelation>[]>;
-};
-
-const TRIPLE_SEP = "";
-function tripleKey(from: string, to: string, relation: string): string {
-	return `${from}${TRIPLE_SEP}${to}${TRIPLE_SEP}${relation}`;
-}
-
-function buildAdjacency<TRelation extends string>(
-	edges: ReadonlyMap<string, KnowledgeEdge<TRelation>> | undefined,
-	side: "from" | "to",
-): ReadonlyMap<string, readonly KnowledgeEdge<TRelation>[]> {
-	if (!edges || edges.size === 0) return new Map();
-	const buckets = new Map<string, KnowledgeEdge<TRelation>[]>();
-	for (const edge of edges.values()) {
-		const key = side === "from" ? edge.from : edge.to;
-		let bucket = buckets.get(key);
-		if (!bucket) {
-			bucket = [];
-			buckets.set(key, bucket);
-		}
-		bucket.push(edge);
-	}
-	const out = new Map<string, readonly KnowledgeEdge<TRelation>[]>();
-	for (const [key, bucket] of buckets) out.set(key, Object.freeze(bucket));
-	return out;
-}
-
-function adjacencyEqual<TRelation extends string>(
-	a: ReadonlyMap<string, readonly KnowledgeEdge<TRelation>[]> | undefined,
-	b: ReadonlyMap<string, readonly KnowledgeEdge<TRelation>[]> | undefined,
-): boolean {
-	if (a === b) return true;
-	if (a == null || b == null) return false;
-	if (a.size !== b.size) return false;
-	for (const [k, av] of a) {
-		const bv = b.get(k);
-		if (!bv || av.length !== bv.length) return false;
-		for (let i = 0; i < av.length; i += 1) {
-			const ae = av[i]!;
-			const be = bv[i]!;
-			if (
-				ae.from !== be.from ||
-				ae.to !== be.to ||
-				ae.relation !== be.relation ||
-				ae.weight !== be.weight
-			)
-				return false;
-		}
-	}
-	return true;
-}
-
-/**
- * Reactive knowledge graph: entities + typed edges + symmetric adjacency.
- *
- * Topology (mounted on the returned graph):
- *  - `entities` — `reactiveMap<id, TEntity>` (optional `entitiesMaxSize` LRU).
- *  - `edges` — `reactiveMap<tripleKey, KnowledgeEdge<TRelation>>` keyed by
- *    `${from}${to}${relation}` (optional `edgesMaxSize` LRU).
- *    Entity IDs / relations must NOT contain ``.
- *  - `adjacencyOut` — `Node<ReadonlyMap<from, readonly edge[]>>`. **Full O(E)
- *    rebuild on every `link` / `unlink` mutation.** (Prior JSDoc claim of
- *    "O(E) build" referred to a single rebuild — the per-mutation cost is
- *    O(E), not O(1) amortized. For very large graphs with frequent edge
- *    churn, consider batching via `reactiveMap.setMany`.)
- *  - `adjacencyIn` — `Node<ReadonlyMap<to, readonly edge[]>>`. Same O(E) per
- *    mutation rebuild characteristic.
- *  - `entityCount` / `edgeCount` — observability deriveds.
- *  - `events` — bounded reactive audit log.
- *
- * **`link()` semantics.** Calling `link(a, b, rel, w)` twice with different
- * weights replaces the weight on the existing edge (keyed by the triple).
- * `unlink` then `link` re-creates the edge (and bumps `lastUpsertNs` for
- * retention purposes).
- *
- * **Edge weight convention.** Higher weight = stronger relation. Default `1`.
- *
- * **Orphan GC.** `orphanGC: "remove"` deletes an entity from `entities` after
- * an `unlink` that empties its adjacency on both sides. Default `"keep"`.
- *
- * **No imperative reads.** Use `relatedNode(id, relation?)` for reactive reads.
- *
- * @category memory
- */
-export function knowledgeGraph<TEntity, TRelation extends string = string>(
-	name: string,
-	opts: KnowledgeGraphOptions = {},
-): KnowledgeGraph<TEntity, TRelation> {
-	const orphanGC = opts.orphanGC ?? "keep";
-	if (opts.entitiesMaxSize !== undefined && opts.entitiesMaxSize < 1) {
-		throw new RangeError("knowledgeGraph: entitiesMaxSize must be >= 1");
-	}
-	if (opts.edgesMaxSize !== undefined && opts.edgesMaxSize < 1) {
-		throw new RangeError("knowledgeGraph: edgesMaxSize must be >= 1");
-	}
-
-	const graph = new Graph(name);
-
-	const entitiesMap = reactiveMap<string, TEntity>({
-		name: "entities",
-		...(opts.entitiesMaxSize !== undefined ? { maxSize: opts.entitiesMaxSize } : {}),
-	});
-	const edgesMap = reactiveMap<string, KnowledgeEdge<TRelation>>({
-		name: "edges",
-		...(opts.edgesMaxSize !== undefined ? { maxSize: opts.edgesMaxSize } : {}),
-	});
-	graph.add(entitiesMap.entries, { name: "entities" });
-	graph.add(edgesMap.entries, { name: "edges" });
-
-	const adjacencyOut = node(
-		[edgesMap.entries],
-		(batchData, actions, ctx) => {
-			const data = batchData.map((batch, i) =>
-				batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-			);
-			const snapshot = data[0] as ReadonlyMap<string, KnowledgeEdge<TRelation>> | undefined;
-			actions.emit(buildAdjacency<TRelation>(snapshot, "from"));
-		},
-		{
-			name: "adjacencyOut",
-			describeKind: "derived",
-			initial: new Map() as ReadonlyMap<string, readonly KnowledgeEdge<TRelation>[]>,
-			equals: adjacencyEqual,
-			meta: memoryMeta("adjacency_out"),
-		},
-	) as Node<ReadonlyMap<string, readonly KnowledgeEdge<TRelation>[]>>;
-	const adjacencyIn = node(
-		[edgesMap.entries],
-		(batchData, actions, ctx) => {
-			const data = batchData.map((batch, i) =>
-				batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-			);
-			const snapshot = data[0] as ReadonlyMap<string, KnowledgeEdge<TRelation>> | undefined;
-			actions.emit(buildAdjacency<TRelation>(snapshot, "to"));
-		},
-		{
-			name: "adjacencyIn",
-			describeKind: "derived",
-			initial: new Map() as ReadonlyMap<string, readonly KnowledgeEdge<TRelation>[]>,
-			equals: adjacencyEqual,
-			meta: memoryMeta("adjacency_in"),
-		},
-	) as Node<ReadonlyMap<string, readonly KnowledgeEdge<TRelation>[]>>;
-	graph.add(adjacencyOut, { name: "adjacencyOut" });
-	graph.add(adjacencyIn, { name: "adjacencyIn" });
-	graph.addDisposer(keepalive(adjacencyOut));
-	graph.addDisposer(keepalive(adjacencyIn));
-
-	const entityCount = node(
-		[entitiesMap.entries],
-		(batchData, actions, ctx) => {
-			const data = batchData.map((batch, i) =>
-				batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-			);
-			const m = data[0] as ReadonlyMap<string, TEntity> | undefined;
-			actions.emit(((m ?? new Map()) as ReadonlyMap<string, TEntity>).size);
-		},
-		{ name: "entityCount", describeKind: "derived", initial: 0, meta: memoryMeta("entity_count") },
-	);
-	const edgeCount = node(
-		[edgesMap.entries],
-		(batchData, actions, ctx) => {
-			const data = batchData.map((batch, i) =>
-				batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-			);
-			const m = data[0] as ReadonlyMap<string, KnowledgeEdge<TRelation>> | undefined;
-			actions.emit(((m ?? new Map()) as ReadonlyMap<string, KnowledgeEdge<TRelation>>).size);
-		},
-		{ name: "edgeCount", describeKind: "derived", initial: 0, meta: memoryMeta("edge_count") },
-	);
-	graph.add(entityCount, { name: "entityCount" });
-	graph.add(edgeCount, { name: "edgeCount" });
-	graph.addDisposer(keepalive(entityCount));
-	graph.addDisposer(keepalive(edgeCount));
-
-	const events = createAuditLog<KnowledgeGraphAuditRecord>({
-		name: "events",
-		retainedLimit: 1024,
-		graph,
-	});
-	const seqCursor = registerCursor(graph, "seq", 0);
-
-	/**
-	 * O(1) orphan check via the kept-warm `adjacency*` deriveds. Reading
-	 * `adjacencyOut.cache` / `adjacencyIn.cache` is safe here because both
-	 * are activated via `addDisposer(keepalive(...))` at construction time
-	 * (a derived's RAM cache only persists with at least one subscriber, and
-	 * the keepalive registers exactly that). The previous implementation
-	 * scanned `edgesMap.entries.cache` post-`deleteMany`, which depended on
-	 * the (sync) snapshot-emit timing of `reactiveMap` — fragile. The
-	 * `adjacency*.cache` approach is both faster (O(1) vs O(E) per check)
-	 * and timing-robust because the reactiveMap snapshot has already
-	 * propagated through the derived chain by the time we read.
-	 */
-	function entityHasReferences(id: string): boolean {
-		const out = adjacencyOut.cache as
-			| ReadonlyMap<string, readonly KnowledgeEdge<TRelation>[]>
-			| undefined;
-		const inb = adjacencyIn.cache as
-			| ReadonlyMap<string, readonly KnowledgeEdge<TRelation>[]>
-			| undefined;
-		if ((out?.get(id)?.length ?? 0) > 0) return true;
-		if ((inb?.get(id)?.length ?? 0) > 0) return true;
-		return false;
-	}
-
-	/**
-	 * Apply orphan GC to a list of candidate entity ids. Used by both
-	 * {@link unlinkImpl} (post-edge-removal) and {@link removeEntityImpl}
-	 * (post-cascade) so semantics are consistent. Each removed entity
-	 * records a separate `orphanRemove` audit entry with its own monotonic
-	 * `seq` value (D1 fix — the previous bare `events.append(...)` skipped
-	 * the cursor advance, leaving gaps in the audit replay sequence).
-	 */
-	function applyOrphanGC(candidates: readonly string[]): void {
-		if (orphanGC !== "remove") return;
-		for (const candidate of candidates) {
-			if (!entitiesMap.has(candidate)) continue;
-			if (entityHasReferences(candidate)) continue;
-			entitiesMap.delete(candidate);
-			events.append({
-				action: "orphanRemove" as const,
-				id: candidate,
-				t_ns: wallClockNs(),
-				seq: bumpCursor(seqCursor),
-			});
-		}
-	}
-
-	const upsertEntityImpl = (id: string, value: TEntity): void => {
-		entitiesMap.set(id, value);
-	};
-	const removeEntityImpl = (id: string): void => {
-		const snapshot = edgesMap.entries.cache as
-			| ReadonlyMap<string, KnowledgeEdge<TRelation>>
-			| undefined;
-		// Collect both the edge-keys to drop AND the entity ids those edges
-		// reference (other than `id` itself) — the latter become orphan-GC
-		// candidates after the cascade. (C1 fix — the previous impl only
-		// applied orphan GC inside `unlink`, so cascading entity removal
-		// could leave dangling orphans.)
-		const cascadedNeighbors = new Set<string>();
-		if (snapshot) {
-			const toDrop: string[] = [];
-			for (const [key, edge] of snapshot) {
-				if (edge.from === id || edge.to === id) {
-					toDrop.push(key);
-					if (edge.from !== id) cascadedNeighbors.add(edge.from);
-					if (edge.to !== id) cascadedNeighbors.add(edge.to);
-				}
-			}
-			if (toDrop.length > 0) edgesMap.deleteMany(toDrop);
-		}
-		if (entitiesMap.has(id)) entitiesMap.delete(id);
-		applyOrphanGC([...cascadedNeighbors]);
-	};
-	const linkImpl = (from: string, to: string, relation: TRelation, weight = 1): void => {
-		edgesMap.set(tripleKey(from, to, relation), { from, to, relation, weight });
-	};
-	const unlinkImpl = (from: string, to: string, relation?: TRelation): void => {
-		if (relation !== undefined) {
-			edgesMap.delete(tripleKey(from, to, relation));
-		} else {
-			const snapshot = edgesMap.entries.cache as
-				| ReadonlyMap<string, KnowledgeEdge<TRelation>>
-				| undefined;
-			if (!snapshot) return;
-			const toDrop: string[] = [];
-			for (const [key, edge] of snapshot) {
-				if (edge.from === from && edge.to === to) toDrop.push(key);
-			}
-			if (toDrop.length > 0) edgesMap.deleteMany(toDrop);
-		}
-		applyOrphanGC([from, to]);
-	};
-
-	const upsertEntity = mutate(upsertEntityImpl, {
-		frame: "inline",
-		log: events,
-		seq: seqCursor,
-		onSuccessRecord: ([id], _r, m) => ({
-			action: "upsertEntity" as const,
-			id,
-			t_ns: m.t_ns,
-			seq: m.seq,
-		}),
-	});
-	const removeEntity = mutate(removeEntityImpl, {
-		frame: "inline",
-		log: events,
-		seq: seqCursor,
-		onSuccessRecord: ([id], _r, m) => ({
-			action: "removeEntity" as const,
-			id,
-			t_ns: m.t_ns,
-			seq: m.seq,
-		}),
-	});
-	const link = mutate(linkImpl, {
-		frame: "inline",
-		log: events,
-		seq: seqCursor,
-		onSuccessRecord: ([from, to, relation, weight], _r, m) => ({
-			action: "link" as const,
-			from,
-			to,
-			relation: relation as string,
-			weight: weight ?? 1,
-			t_ns: m.t_ns,
-			seq: m.seq,
-		}),
-	});
-	const unlink = mutate(unlinkImpl, {
-		frame: "inline",
-		log: events,
-		seq: seqCursor,
-		onSuccessRecord: ([from, to, relation], _r, m) => ({
-			action: "unlink" as const,
-			from,
-			to,
-			...(relation !== undefined ? { relation: relation as string } : {}),
-			t_ns: m.t_ns,
-			seq: m.seq,
-		}),
-	});
-
-	function relatedNode(
-		id: NodeOrValue<string>,
-		relation?: NodeOrValue<TRelation>,
-	): Node<readonly KnowledgeEdge<TRelation>[]> {
-		const idN = toNode(id, "id");
-		// `relation` is OPTIONAL. We deliberately do NOT include it as a dep
-		// when omitted — `state(undefined)` would be a SENTINEL and the
-		// derived's first-run gate would never open. Callers pass a Node
-		// when they want reactive filtering; pass a value to lock the
-		// filter; omit to disable filtering.
-		const relN = relation !== undefined ? toNode(relation, "relation") : undefined;
-		const deps: Node<unknown>[] = relN
-			? [adjacencyOut, adjacencyIn, idN, relN]
-			: [adjacencyOut, adjacencyIn, idN];
-		return node(
-			deps,
-			(batchData, actions, ctx) => {
-				const values = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				const out = values[0] as ReadonlyMap<string, readonly KnowledgeEdge<TRelation>[]>;
-				const inb = values[1] as ReadonlyMap<string, readonly KnowledgeEdge<TRelation>[]>;
-				const key = values[2] as string;
-				const rel = relN ? (values[3] as TRelation | undefined) : undefined;
-				const outE = out?.get(key) ?? [];
-				const inE = inb?.get(key) ?? [];
-				// Concatenate, then dedupe by triple key (a self-loop would appear in both).
-				const seen = new Set<string>();
-				const acc: KnowledgeEdge<TRelation>[] = [];
-				for (const edge of outE) {
-					const k = tripleKey(edge.from, edge.to, edge.relation);
-					if (seen.has(k)) continue;
-					if (rel !== undefined && edge.relation !== rel) continue;
-					seen.add(k);
-					acc.push(edge);
-				}
-				for (const edge of inE) {
-					const k = tripleKey(edge.from, edge.to, edge.relation);
-					if (seen.has(k)) continue;
-					if (rel !== undefined && edge.relation !== rel) continue;
-					seen.add(k);
-					acc.push(edge);
-				}
-				actions.emit(acc as readonly KnowledgeEdge<TRelation>[]);
-			},
-			{
-				describeKind: "derived",
-				equals: (a, b) => {
-					const av = a as readonly KnowledgeEdge<TRelation>[] | undefined;
-					const bv = b as readonly KnowledgeEdge<TRelation>[] | undefined;
-					if (av === bv) return true;
-					if (av == null || bv == null) return false;
-					if (av.length !== bv.length) return false;
-					for (let i = 0; i < av.length; i += 1) {
-						const x = av[i]!;
-						const y = bv[i]!;
-						if (
-							x.from !== y.from ||
-							x.to !== y.to ||
-							x.relation !== y.relation ||
-							x.weight !== y.weight
-						)
-							return false;
-					}
-					return true;
-				},
-				meta: memoryMeta("related"),
-			},
-		) as Node<readonly KnowledgeEdge<TRelation>[]>;
-	}
-
-	const out = Object.assign(graph, {
-		events,
-		entities: entitiesMap.entries,
-		edges: edgesMap.entries,
-		adjacencyOut,
-		adjacencyIn,
-		entityCount,
-		edgeCount,
-		upsertEntity,
-		removeEntity,
-		link,
-		unlink,
-		relatedNode,
-	}) as KnowledgeGraph<TEntity, TRelation>;
-	return out;
-}
-
-// ── DS-14.7: reactiveFactStore (static-topology MEME L2/L3 substrate) ─────
-// Lives in its own file (`fact-store.ts`) — re-exported here so the
-// `utils/memory` barrel stays the single import surface alongside
-// collection / vectorIndex / knowledgeGraph.
-export {
-	type AdmissionFilter,
-	type CascadeEvent,
-	type CascadeOverflow,
-	type CascadeReason,
-	type DecayPolicy,
-	type DependentsIndex,
-	type FactId,
-	type FactStore,
-	type FactStoreAuditRecord,
-	type MemoryAnswer,
-	type MemoryFragment,
-	type MemoryQuery,
-	type OutcomeSignal,
-	type ReactiveFactStoreConfig,
-	ReactiveFactStoreGraph,
-	type ReviewRequest,
-	reactiveFactStore,
-	type ScoringPolicy,
-	type ShardKey,
-	type StoreReadHandle,
-} from "./fact-store.js";
-// DS-14.7 follow-up #2 (persistence half) — durable, event-sourced fact store
-// with substrate-owned replay/dedup (memo:Re Story 6.4 back-derivation).
-export {
-	type PersistentReactiveFactStoreConfig,
-	type PersistentReactiveFactStoreGraph,
-	persistentReactiveFactStore,
-} from "./persistent-fact-store.js";
-// DS-14.7 follow-up #1: recipe library — 8 shipped compositions over the
-// four extension faces. Re-exported here so `utils/memory` stays the single
-// import surface.
-export * from "./recipes/index.js";
-// DS-14.7 follow-up #2 — `simpleFactStore()` 80%-case ergonomic wrapper:
-// one-call `remember`, optional storage, decay-on-by-default.
-export {
-	DEFAULT_DECAY_HALF_LIFE_NS,
-	DEFAULT_DECAY_PERIOD_MS,
-	type RememberOptions,
-	type SimpleFactStoreGraph,
-	type SimpleFactStoreOptions,
-	simpleFactStore,
-} from "./simple-fact-store.js";
diff --git a/src/utils/memory/persistent-fact-store.ts b/src/utils/memory/persistent-fact-store.ts
deleted file mode 100644
index a0ca57a6..00000000
--- a/src/utils/memory/persistent-fact-store.ts
+++ /dev/null
@@ -1,320 +0,0 @@
-/**
- * Promotion 1 (memo:Re Story 6.4 back-derivation; DS-14.7 follow-up #2 —
- * the persistence half of `simpleFactStore()`). Design-review-locked
- * 2026-05-16.
- *
- * memo:Re hand-rolled `createPersistentMemoryStore` (217 LOC): a
- * `reactiveLog.attach(ingest)` side-log + an `appendLogStorage` tier +
- * paginated replay + a `persistedCount` suffix-cursor for replay-dedup +
- * flush/dispose lifecycle. Its code-review's *only High* finding (flush
- * partial-failure double-append) + several Meds (concurrent-flush race,
- * `persistedCount` baseline fragility, `loadAllHistory` silent truncation)
- * were all artifacts of the first consumer hand-rolling substrate-general
- * orchestration. This factory owns log↔store↔replay↔dedup correctly so the
- * whole silent-corruption bug class disappears for every future consumer.
- *
- * **Key design properties (locked):**
- * - **Synchronous factory.** Returns the `Graph` immediately like every other
- *   `utils/memory` factory — `utils/` is composed by presets/solutions and
- *   must stay reactive (no `await` in a construction path). The inherently-IO
- *   durable load + replay is the ONE async boundary and it lives in a single
- *   isolated reactive source node (`fromAny` over a paginated `loadEntries`
- *   async-iterator), per spec §5.10 — not in the factory signature.
- * - **Substrate-owned durable cursor.** Persistence is wired AFTER the replay
- *   source drains; `ReactiveLogBundle.attachStorage` initialises its
- *   delivered-cursor to `ingestLog.size` at attach time, so the replayed
- *   history is NOT re-persisted and only post-replay live fragments ship.
- *   The cursor is entirely internal — the consumer tracks nothing (no
- *   `persistedCount`). Observability is the read-only `position` Node.
- * - **Flush delegated** to the already-QA-hardened `appendLogStorage.flush`
- *   (reject-on-prior-failure + rollback-epoch + chained-drain) — the High
- *   double-append dissolves because nothing here hand-rolls `appendEntries`
- *   + a cursor.
- * - **No silent partial-history loss.** Replay reads the durable history in a
- *   single `tier.loadEntries()` call — the substrate append-log tier returns
- *   the COMPLETE log (it does not paginate / windowed-truncate), so memo:Re's
- *   `loadAllHistory` partial-page-truncation bug class is absent by
- *   construction (not "detected"). Any `loadEntries` rejection propagates as
- *   `ERROR` on the replay source (observable), not a swallowed partial load.
- *   (Real cursor pagination for very large logs is a deferred substrate
- *   enhancement — see `docs/optimizations.md`.)
- *
- * Determinism: `reactiveFactStore`'s cascade `validTo` is derived from the
- * triggering root (not wall-clock), so replaying the persisted ingest stream
- * rebuilds a byte-identical store — the rebuildable-projection contract
- * documented on {@link ReactiveFactStoreConfig.recordIngest}.
- *
- * Only the bytes-`StorageBackend` adapter stays userland; the BigInt-safe
- * codec is upstream (`bigintJsonCodecFor`, the default here).
- *
- * @module
- */
-
-import { COMPLETE, type Node, node } from "@graphrefly/pure-ts/core";
-import {
-	type AppendLogStorageTier,
-	appendLogStorage,
-	bigintJsonCodecFor,
-	type Codec,
-	fromAny,
-	keepalive,
-	type StorageBackend,
-} from "@graphrefly/pure-ts/extra";
-import { domainMeta } from "../../base/meta/domain-meta.js";
-import {
-	type MemoryFragment,
-	type ReactiveFactStoreConfig,
-	type ReactiveFactStoreGraph,
-	reactiveFactStore,
-} from "./fact-store.js";
-
-function persistMeta(kind: string): Record<string, unknown> {
-	return domainMeta("memory", kind);
-}
-
-export interface PersistentReactiveFactStoreConfig<T>
-	// `admissionFilter` is intentionally omitted (QA-A): `ingestLog` records the
-	// POST-admission stream, so replaying it through a `config.ingest` that
-	// re-applies admission would double-filter — and any stateful/non-
-	// deterministic filter desyncs the durable log from the rebuilt store
-	// (silent corruption). Apply admission ONCE, upstream of `config.ingest`
-	// (e.g. a `.filter` before emitting); the durable log is the post-admission
-	// truth. Use the non-persistent `reactiveFactStore` if you need the
-	// reactive `admissionFilter` face.
-	extends Omit<ReactiveFactStoreConfig<T>, "recordIngest" | "admissionFilter"> {
-	/**
-	 * Bytes backend the durable ingest log is persisted through. The ONLY
-	 * userland piece — e.g. memo:Re's Drizzle/Expo-SQLite `StorageBackend`,
-	 * or `memoryBackend()` for tests.
-	 */
-	readonly storage: StorageBackend;
-	/** Backend key / tier name. Default `"fact_store_ingest"`. */
-	readonly persistName?: string;
-	/** Codec for the durable bucket. Default `bigintJsonCodecFor` (BigInt-safe). */
-	readonly codec?: Codec<readonly MemoryFragment<T>[]>;
-}
-
-export interface PersistentReactiveFactStoreGraph<T> extends ReactiveFactStoreGraph<T> {
-	/**
-	 * Reactive count of durably-persisted fragments. `0` until startup replay
-	 * completes; thereafter the committed-fragment count (replayed history —
-	 * loaded FROM the durable tier — plus live fragments shipped by the
-	 * substrate-owned `attachStorage` cursor; call {@link flush} to force them
-	 * physically durable). Observability only — the cursor is internal.
-	 */
-	readonly position: Node<number>;
-	/**
-	 * Reactive count of fragments rebuilt from durable history at startup.
-	 * `0` until the first replayed fragment; final value once replay
-	 * `COMPLETE`s.
-	 */
-	readonly replayedCount: Node<number>;
-	/** The durable append-log tier (shared backend; e.g. for projector cursors). */
-	readonly tier: AppendLogStorageTier<MemoryFragment<T>>;
-	/**
-	 * Force-drain the durable tier. Delegates to the QA-hardened
-	 * `appendLogStorage.flush` (rejects if a prior in-flight write failed;
-	 * honours the rollback epoch). Resolves once all shipped fragments are
-	 * physically durable.
-	 *
-	 * **Pre-attach-live durability (QA-E):** a fragment emitted into
-	 * `config.ingest` in the same synchronous tick as construction (before the
-	 * async replay drains) is shipped by a one-shot, fire-and-forget
-	 * reconciliation write whose rejection is NOT surfaced inline. Call
-	 * `flush()` after construction settles to (a) confirm that slice is
-	 * physically durable and (b) surface any write failure as a rejection. The
-	 * normal pattern — observe `replayedCount`/`position` before feeding live
-	 * ingest — avoids the window entirely.
-	 */
-	flush(): Promise<void>;
-}
-
-/**
- * Build a durable, event-sourced {@link reactiveFactStore} that owns
- * log↔store↔replay↔dedup correctly. Synchronous factory; the only async is
- * an isolated internal replay source. See module docstring for the locked
- * design rationale.
- *
- * @example
- * ```ts
- * import { persistentReactiveFactStore } from "@graphrefly/graphrefly";
- * import { memoryBackend } from "@graphrefly/pure-ts/extra";
- *
- * const ingest = node<MemoryFragment<Doc>>([], { initial: undefined });
- * const mem = persistentReactiveFactStore<Doc>({
- *   ingest,
- *   extractDependencies: (f) => f.sources,
- *   storage: memoryBackend(),
- * });
- * // Restart is automatic: the durable history is replayed through `ingest`
- * // on construction; observe `mem.replayedCount` / `mem.position`.
- * ingest.emit(myFragment);            // live — persisted (not re-persisted)
- * await mem.flush();                  // force physically durable
- * ```
- *
- * @category memory
- */
-export function persistentReactiveFactStore<T>(
-	config: PersistentReactiveFactStoreConfig<T>,
-): PersistentReactiveFactStoreGraph<T> {
-	const persistName = config.persistName ?? "fact_store_ingest";
-	const codec = config.codec ?? bigintJsonCodecFor<readonly MemoryFragment<T>[]>();
-	const tier = appendLogStorage<MemoryFragment<T>>(config.storage, {
-		name: persistName,
-		codec,
-	});
-
-	// `recordIngest:true` is implied — the rebuildable-projection source.
-	const store = reactiveFactStore<T>({ ...config, recordIngest: true });
-	const ingestLog = store.ingestLog!;
-
-	// Durable-history async iterator. The substrate `appendLogStorage` tier's
-	// `loadEntries()` returns the COMPLETE log in one call (it does not honor
-	// `cursor`/`pageSize` windowing), so a single read yields the full history
-	// — no partial-page-truncation risk (QA-B). A `loadEntries` rejection
-	// propagates as ERROR on the replay source (not swallowed).
-	async function* loadHistory(): AsyncGenerator<MemoryFragment<T>> {
-		if (typeof tier.loadEntries !== "function") return;
-		const page = await tier.loadEntries();
-		for (const f of page.entries) yield f;
-	}
-
-	// Replay = a reactive async source feeding `config.ingest` (spec §5.10 —
-	// the ONLY async lives in this one source node; the factory is sync).
-	const replaySource = fromAny<MemoryFragment<T>>(loadHistory(), {
-		name: "_replay_source",
-		meta: persistMeta("persist_replay_source"),
-	});
-	store.add(replaySource, { name: "_replay_source" });
-
-	// replayPump: re-feed each replayed fragment through `config.ingest`
-	// (the documented rebuildable-projection replay — `.emit` into a source is
-	// the sanctioned reactive entry, mirroring the `decay` recipe precedent).
-	// Emits the running replayed count (consumers observe `replayedCount`).
-	let replayed = 0;
-	const replayPump = node<number>(
-		[replaySource],
-		(batchData, actions) => {
-			const b = batchData[0] as readonly MemoryFragment<T>[] | undefined;
-			if (b != null && b.length > 0) {
-				for (const f of b) {
-					config.ingest.emit(f);
-					replayed += 1;
-				}
-				actions.emit(replayed);
-			}
-		},
-		{
-			name: "_replay_pump",
-			describeKind: "derived",
-			initial: 0,
-			meta: persistMeta("persist_replay_pump"),
-		},
-	);
-	store.add(replayPump, { name: "_replay_pump" });
-	store.addDisposer(keepalive(replayPump));
-
-	// `attached` flips reactively when the replay source COMPLETEs — gates
-	// `position` so it can advance from 0 the instant replay drains.
-	const attached = node<boolean>([], {
-		initial: false,
-		name: "_storage_attached",
-		describeKind: "state",
-		meta: persistMeta("persist_attached"),
-	});
-	store.add(attached, { name: "_storage_attached" });
-	store.addDisposer(keepalive(attached));
-
-	// Wire durable persistence AFTER replay drains. By COMPLETE, `ingestLog`
-	// holds the full replayed history (synchronous per-wave propagation), so
-	// `attachStorage` initialises its delivered-cursor to `ingestLog.size` →
-	// the replayed history is NOT re-persisted; only live post-replay
-	// fragments ship. The cursor is the substrate's `delivered` map; the
-	// consumer tracks nothing. Catching the replay source's COMPLETE terminal
-	// is reactive (spec §2.2 terminal propagation); `attachStorage` is the
-	// IO-sink wiring, analogous to its own internal `fromTimer`/teardown-drain
-	// wiring (§24 internal subscription, invisible in describe).
-	//
-	// **Pre-attach live-ingest window.** A caller that emits a live fragment
-	// in the same synchronous tick as construction feeds `config.ingest`
-	// BEFORE the async replay drains, so `ingestLog.size` at COMPLETE is
-	// `replayed + (pre-attach live)`. `attachStorage`'s delivered-cursor
-	// starts at `ingestLog.size` and can't tell that slice from replayed
-	// history → it would never ship it (silent loss). Ship that one slice
-	// once here (the same `appendEntries` API attachStorage uses — a one-shot
-	// reconciliation, NOT a maintained consumer cursor); steady-state
-	// delta-shipping stays the substrate-owned `delivered` cursor.
-	let detachStorage: (() => void) | undefined;
-	const replaySub = replaySource.subscribe((msgs) => {
-		for (const m of msgs) {
-			if (m[0] === COMPLETE && detachStorage === undefined) {
-				const sizeAtAttach = ingestLog.size;
-				detachStorage = ingestLog.attachStorage([tier]);
-				if (sizeAtAttach > replayed) {
-					const slice: MemoryFragment<T>[] = [];
-					for (let i = replayed; i < sizeAtAttach; i += 1) {
-						const v = ingestLog.at(i);
-						if (v === undefined) {
-							// QA-F: the slice is contiguous + fully-present by
-							// invariant (`ingestLog` indices [replayed,size) are the
-							// pre-attach live fragments). A hole here is a real bug —
-							// fail loud rather than silently gap the durable log
-							// (matches this file's "no silent loss" contract).
-							throw new Error(
-								`persistentReactiveFactStore: ingestLog hole at index ${i} ` +
-									`in reconciliation slice [${replayed}, ${sizeAtAttach}); ` +
-									`pre-attach-live durability cannot be guaranteed.`,
-							);
-						}
-						slice.push(v);
-					}
-					if (slice.length > 0) {
-						const r = tier.appendEntries(slice);
-						if (r instanceof Promise) r.catch(() => {});
-					}
-				}
-				attached.emit(true);
-			}
-		}
-	});
-	store.addDisposer(() => {
-		replaySub();
-		detachStorage?.();
-	});
-
-	// position: durably-persisted fragment count. `0` until replay completes;
-	// then the `ingestLog` size (replayed history was loaded FROM the tier; new
-	// fragments are shipped by the substrate-owned attachStorage cursor).
-	const position = node<number>(
-		[ingestLog.entries, attached],
-		(batchData, actions, ctx) => {
-			const eb = batchData[0];
-			const arr = (eb != null && eb.length > 0 ? eb.at(-1) : ctx.prevData[0]) as
-				| readonly MemoryFragment<T>[]
-				| undefined;
-			const ab = batchData[1];
-			const isAttached = (ab != null && ab.length > 0 ? ab.at(-1) : ctx.prevData[1]) as
-				| boolean
-				| undefined;
-			actions.emit(isAttached === true ? (arr?.length ?? 0) : 0);
-		},
-		{
-			name: "_durable_position",
-			describeKind: "derived",
-			initial: 0,
-			meta: persistMeta("persist_position"),
-		},
-	);
-	store.add(position, { name: "_durable_position" });
-	store.addDisposer(keepalive(position));
-
-	const out = Object.assign(store, {
-		position,
-		replayedCount: replayPump,
-		tier,
-		async flush(): Promise<void> {
-			await tier.flush?.();
-		},
-	}) as PersistentReactiveFactStoreGraph<T>;
-	return out;
-}
diff --git a/src/utils/memory/recipes/_shared.ts b/src/utils/memory/recipes/_shared.ts
deleted file mode 100644
index c2071603..00000000
--- a/src/utils/memory/recipes/_shared.ts
+++ /dev/null
@@ -1,33 +0,0 @@
-/**
- * Shared internals for the {@link reactiveFactStore} recipe library
- * (DS-14.7 follow-up #1). Not part of the public surface — recipes re-export
- * only their own factory.
- *
- * @module
- */
-
-import type { MemoryFragment } from "../fact-store.js";
-
-/**
- * Last-value-of-wave helper, mirroring the `lastOf` in `fact-store.ts`: prefer
- * the most recent value emitted on dep slot `i` this wave, else fall back to
- * the dep's prior cached value (`ctx.prevData[i]`). Returns `undefined` at
- * SENTINEL (dep has never emitted DATA).
- */
-export function lastOf<X>(batch: readonly unknown[] | undefined, prev: unknown): X | undefined {
-	return batch != null && batch.length > 0 ? (batch.at(-1) as X) : (prev as X | undefined);
-}
-
-/**
- * Bi-temporal validity test — re-implemented locally so recipes stay
- * self-contained (the `fact-store.ts` `currentlyValid` is private; widening its
- * export for two recipe consumers would creep the substrate surface). Semantics
- * are identical: with no `asOf`, "currently valid" === not obsolete
- * (`validTo` unset); with `asOf`, the instant must fall in `[validFrom, validTo)`.
- */
-export function validAt<T>(f: MemoryFragment<T>, asOf?: bigint): boolean {
-	if (asOf === undefined) return f.validTo === undefined;
-	if (f.validFrom !== undefined && asOf < f.validFrom) return false;
-	if (f.validTo !== undefined && asOf >= f.validTo) return false;
-	return true;
-}
diff --git a/src/utils/memory/recipes/admission-llm-judge.ts b/src/utils/memory/recipes/admission-llm-judge.ts
deleted file mode 100644
index 8998a761..00000000
--- a/src/utils/memory/recipes/admission-llm-judge.ts
+++ /dev/null
@@ -1,83 +0,0 @@
-/**
- * Recipe — **LLM gatekeeper** admission filter.
- *
- * `ReactiveFactStoreConfig.admissionFilter` is a **synchronous** face — it runs
- * inside `extract_op` at ingest time, so it cannot itself `await` an LLM (spec
- * §5.10 forbids raw async in the reactive layer; the LLM call belongs in a
- * source / `promptNode` upstream). This recipe adapts a **precomputed verdict
- * stream** to the sync face: the caller runs the judge upstream (a `promptNode`
- * over the candidate fragment stream) and feeds its `Map<FactId, boolean>`
- * verdicts in; the recipe returns a `Node<AdmissionFilter<T>>` that consults
- * the latest verdicts synchronously.
- *
- * ```ts
- * // upstream: async LLM judge produces verdicts (id → admit?)
- * const verdicts = promptNode(adapter, [candidates], judgeFragmentsFn); // Node<Map<FactId,boolean>>
- * const mem = reactiveFactStore<Doc>({
- *   ingest, extractDependencies,
- *   admissionFilter: admissionLlmJudge<Doc>(verdicts), // ② sync-face adapter
- * });
- * ```
- *
- * **Deny-by-default.** A fragment with no verdict yet is rejected
- * (`defaultVerdict` default `false`) — the store never admits an unjudged fact.
- * Set `defaultVerdict: true` for an allow-then-prune posture instead.
- *
- * **⚠️ The filter only gates admission AT ingest, synchronously.**
- * - A fragment ingested **before** its verdict lands is rejected (with the
- *   default `false`) and is **permanently lost** — there is no buffering or
- *   retry; a later verdict admitting that id does NOT retroactively ingest it.
- *   If you cannot guarantee verdict-before-fragment ordering, buffer/replay
- *   the candidate stream upstream (e.g. gate ingest behind the verdict Node).
- * - "Prune" in `defaultVerdict: true` is a misnomer for *post-hoc removal*: a
- *   verdict flipping `true → false` after a fact is committed does nothing
- *   (the fact stays). It only means "admit unjudged, reject explicitly-denied
- *   at ingest". True pruning requires a separate obsoletion path.
- *
- * @module
- */
-
-import { type Node, node } from "@graphrefly/pure-ts/core";
-import type { AdmissionFilter, FactId } from "../fact-store.js";
-
-export interface AdmissionLlmJudgeOptions {
-	/** Verdict for a fragment the judge hasn't ruled on yet. Default `false` (strict gate). */
-	readonly defaultVerdict?: boolean;
-	/** Node name. Default `admission_llm_judge`. */
-	readonly name?: string;
-}
-
-/**
- * Adapt an upstream LLM-verdict stream to the synchronous `admissionFilter`
- * face. `verdicts` is a Node carrying the current `factId → admit?` map (e.g.
- * a `promptNode` accumulating judgements).
- *
- * @category memory
- */
-export function admissionLlmJudge<T>(
-	verdicts: Node<ReadonlyMap<FactId, boolean>>,
-	opts: AdmissionLlmJudgeOptions = {},
-): Node<AdmissionFilter<T>> {
-	const dflt = opts.defaultVerdict ?? false;
-	const buildFilter =
-		(m: ReadonlyMap<FactId, boolean>): AdmissionFilter<T> =>
-		(f) =>
-			m.get(f.id) ?? dflt;
-
-	return node<AdmissionFilter<T>>(
-		[verdicts],
-		(batchData, actions, ctx) => {
-			const m =
-				(batchData[0] as readonly ReadonlyMap<FactId, boolean>[] | undefined)?.at(-1) ??
-				(ctx.prevData[0] as ReadonlyMap<FactId, boolean> | undefined) ??
-				new Map<FactId, boolean>();
-			actions.emit(buildFilter(m));
-		},
-		{
-			name: opts.name ?? "admission_llm_judge",
-			describeKind: "derived",
-			// Before any verdict arrives, apply the default policy.
-			initial: buildFilter(new Map<FactId, boolean>()),
-		},
-	);
-}
diff --git a/src/utils/memory/recipes/bitemporal-query.ts b/src/utils/memory/recipes/bitemporal-query.ts
deleted file mode 100644
index bfe07b25..00000000
--- a/src/utils/memory/recipes/bitemporal-query.ts
+++ /dev/null
@@ -1,89 +0,0 @@
-/**
- * Recipe — **"as of t" historical view** (MEME L3 obsolescence reasoning).
- *
- * `reactiveFactStore`'s built-in `query`/`answer` face answers a structured
- * `MemoryQuery` (which already supports `asOf`), but a common need is a
- * *standing, reactive* historical projection that re-derives whenever either
- * the store changes **or** the as-of instant moves (e.g. a scrubber in a debug
- * UI). This recipe is that projection over face ④ + a reactive `asOf` input:
- * `derived([asOf, mem.factStore])` → only fragments valid at `asOf`
- * (bi-temporal `[validFrom, validTo)` test), giving Graphiti/Zep-style
- * "what did we believe at time T" without committing anything to the spec.
- *
- * ```ts
- * const asOf = node<bigint>([], { initial: undefined });
- * const view = bitemporalQuery(mem, asOf, { tags: ["policy"] });
- * asOf.emit(lastTuesdayNs);  // view re-derives to the policy facts valid then
- * ```
- *
- * Pass `asOf` SENTINEL (no emit yet) → the view is the **currently-valid** set
- * (live facts, `validTo` unset), so it's useful before any scrub too.
- *
- * @module
- */
-
-import { type Node, node } from "@graphrefly/pure-ts/core";
-import type { FactStore, MemoryFragment, ReactiveFactStoreGraph } from "../fact-store.js";
-import { lastOf, validAt } from "./_shared.js";
-
-export interface BitemporalQueryOptions {
-	/** Restrict to fragments carrying any of these tags (OR). */
-	readonly tags?: readonly string[];
-	/** Minimum confidence (inclusive). */
-	readonly minConfidence?: number;
-	/** Node name. Default `bitemporal_query`. */
-	readonly name?: string;
-}
-
-/**
- * Build a standing bi-temporal historical view over a {@link reactiveFactStore}.
- * Emits the fragments valid at the latest `asOf` (sorted confidence desc, then
- * `t_ns` desc — same order as the built-in `answer`).
- *
- * @category memory
- */
-export function bitemporalQuery<T>(
-	mem: ReactiveFactStoreGraph<T>,
-	asOf: Node<bigint>,
-	opts: BitemporalQueryOptions = {},
-): Node<readonly MemoryFragment<T>[]> {
-	// Wrap the caller's `asOf` to a non-SENTINEL `bigint | null` (initial
-	// `null` = "no scrub yet ⇒ currently-valid"). Without this, an `asOf` that
-	// hasn't emitted is SENTINEL and the first-run gate (COMPOSITION-GUIDE-GRAPH
-	// §10 cascading SENTINEL) would silence the whole view until the first
-	// scrub. `null` is DATA, so the gate opens immediately; a later `asOf.emit`
-	// still re-triggers the view (it remains a reactive dep).
-	const asOfOrNull = node<bigint | null>(
-		[asOf],
-		(b, a, c) => a.emit(lastOf<bigint>(b[0], c.prevData[0]) ?? null),
-		{ name: `${opts.name ?? "bitemporal_query"}_asof`, describeKind: "derived", initial: null },
-	);
-
-	return node<readonly MemoryFragment<T>[]>(
-		[asOfOrNull, mem.factStore],
-		(batchData, actions, ctx) => {
-			const raw = lastOf<bigint | null>(batchData[0], ctx.prevData[0]);
-			const at = raw ?? undefined; // null/SENTINEL ⇒ currently-valid
-			const fs = lastOf<FactStore<T>>(batchData[1], ctx.prevData[1]);
-			if (fs == null) {
-				actions.emit([]);
-				return;
-			}
-			const results = [...fs.byId.values()].filter((f) => {
-				if (!validAt(f, at)) return false;
-				if (opts.tags && opts.tags.length > 0 && !opts.tags.some((t) => f.tags.includes(t))) {
-					return false;
-				}
-				if (opts.minConfidence !== undefined && f.confidence < opts.minConfidence) return false;
-				return true;
-			});
-			results.sort((a, b) => b.confidence - a.confidence || Number(b.t_ns - a.t_ns));
-			actions.emit(results);
-		},
-		{
-			name: opts.name ?? "bitemporal_query",
-			describeKind: "derived",
-			initial: [] as readonly MemoryFragment<T>[],
-		},
-	);
-}
diff --git a/src/utils/memory/recipes/consolidation-rem.ts b/src/utils/memory/recipes/consolidation-rem.ts
deleted file mode 100644
index 68bdf689..00000000
--- a/src/utils/memory/recipes/consolidation-rem.ts
+++ /dev/null
@@ -1,99 +0,0 @@
-/**
- * Recipe — **REM-style replay consolidation**.
- *
- * Hassabis's sleep-consolidation frame: periodically replay the
- * highest-confidence × most-recent facts and synthesize a compressed successor
- * fragment (version-chained via `parent_fragment_id`). Builds the two config
- * fields the `consolidate` extension face needs — a reactive `consolidateTrigger`
- * (a `fromTimer` source, spec §5.8-compliant) and the `consolidate(store)`
- * summarizer — so the caller just spreads them in:
- *
- * ```ts
- * const mem = reactiveFactStore<Doc>({
- *   ingest, extractDependencies,
- *   ...consolidationRem<Doc>({
- *     periodMs: 60_000,
- *     topK: 8,
- *     recentWindowNs: 3_600_000_000_000n,           // 1h
- *     summarize: (frags) => mergeDocs(frags),       // domain-specific
- *   }),
- * });
- * ```
- *
- * The pattern default-wires consolidator output back into ingest (Q9-open-6),
- * so the successor fragment becomes a first-class fact; the originals are left
- * intact (callers obsolete them via their own `validTo` policy if desired —
- * keeping that out of the recipe preserves "the recipe never decides what to
- * forget").
- *
- * **Selection order & assumptions.** `recentWindowNs` filters the *pool* first
- * (facts within `recentWindowNs` of the newest live fact's `t_ns`); the pool
- * is then sorted by `confidence desc, t_ns desc` and `topK`-sliced — so an
- * old-but-in-window high-confidence fact can beat a brand-new low-confidence
- * one (recency gates the pool, confidence picks the winners). If every fact
- * falls outside the window the pool is empty and `summarize` is not called
- * (the consolidator emits `[]` — indistinguishable from an empty store).
- * `recentWindowNs` math assumes all fragments' `t_ns` come from the **same
- * clock** (`monotonicNs` xor `wallClockNs`, not mixed) — the window is
- * meaningless across mixed clocks.
- *
- * @module
- */
-
-import type { Node } from "@graphrefly/pure-ts/core";
-import { fromTimer } from "@graphrefly/pure-ts/extra";
-import type { MemoryFragment, StoreReadHandle } from "../fact-store.js";
-
-export interface ConsolidationRemOptions<T> {
-	/** Replay period in milliseconds. */
-	readonly periodMs: number;
-	/** How many top facts to replay per pass. */
-	readonly topK: number;
-	/**
-	 * Synthesize successor fragment(s) from the replayed set. Domain-specific —
-	 * required (the pattern's default `consolidate` is a no-op). Set
-	 * `parent_fragment_id` on the result to chain versions.
-	 */
-	readonly summarize: (replayed: readonly MemoryFragment<T>[]) => readonly MemoryFragment<T>[];
-	/**
-	 * Only replay facts whose `t_ns` is within this many ns of the most-recent
-	 * fact's `t_ns` (recency gate). Omit to consider all live facts.
-	 */
-	readonly recentWindowNs?: bigint;
-}
-
-export interface ConsolidationRemConfig<T> {
-	readonly consolidateTrigger: Node<number>;
-	readonly consolidate: (store: StoreReadHandle<T>) => readonly MemoryFragment<T>[];
-}
-
-/**
- * Build the `{ consolidateTrigger, consolidate }` pair for a REM-replay
- * consolidation policy. Spread into {@link reactiveFactStore}'s config.
- *
- * @category memory
- */
-export function consolidationRem<T>(opts: ConsolidationRemOptions<T>): ConsolidationRemConfig<T> {
-	// Raw `fromTimer` is the trigger — the factory's `consolidated` node deps on
-	// it and is keepalive'd, so it stays hot. (An intermediate equals-defaulted
-	// wrapper would collapse the timer's first tick `0` against an `initial: 0`
-	// via Object.is dedupe — timer ticks are events, not values.)
-	const consolidateTrigger = fromTimer(opts.periodMs, { period: opts.periodMs });
-
-	const consolidate = (store: StoreReadHandle<T>): readonly MemoryFragment<T>[] => {
-		// Live facts only (obsolete ones aren't worth replaying).
-		const live = [...store.values()].filter((f) => f.validTo === undefined);
-		if (live.length === 0) return [];
-		let pool = live;
-		if (opts.recentWindowNs !== undefined) {
-			const newest = live.reduce((m, f) => (f.t_ns > m ? f.t_ns : m), live[0]!.t_ns);
-			const cutoff = newest - opts.recentWindowNs;
-			pool = live.filter((f) => f.t_ns >= cutoff);
-		}
-		pool.sort((a, b) => b.confidence - a.confidence || Number(b.t_ns - a.t_ns));
-		const replayed = pool.slice(0, Math.max(0, opts.topK));
-		return replayed.length > 0 ? opts.summarize(replayed) : [];
-	};
-
-	return { consolidateTrigger, consolidate };
-}
diff --git a/src/utils/memory/recipes/decay-exponential.ts b/src/utils/memory/recipes/decay-exponential.ts
deleted file mode 100644
index 597f189b..00000000
--- a/src/utils/memory/recipes/decay-exponential.ts
+++ /dev/null
@@ -1,149 +0,0 @@
-/**
- * Recipe — **standard forgetting curve** (Hassabis confidence drift).
- *
- * Periodically decays every live fact's `confidence` toward a floor on an
- * exponential half-life schedule, re-ingesting the drifted fragment (MEME L1
- * direct-replace). The periodic trigger is a reactive `fromTimer` source
- * (spec §5.8 no-polling / §5.10 no raw `setTimeout` — `fromTimer` is the
- * sanctioned reactive timer) and the only reactive dep, so there is no
- * within-wave feedback loop (COMPOSITION-GUIDE-GRAPH §7): the store snapshot is
- * read **advisory** off `mem.factStore.cache`, never as a reactive dep; the
- * re-ingest write commits **synchronously this tick** (graphrefly push is
- * synchronous) and the next tick decays from there.
- *
- * > **Recipe vs the `decay` face.** `ReactiveFactStoreConfig.decay:
- * > Node<DecayPolicy>` (DS-14.7 PART 4.1 face ②) **is wired** in the factory —
- * > pair it with `decayTrigger` and the store owns decay as a reactive,
- * > swappable policy. This recipe is the **ergonomic alternative**: it owns its
- * > own `fromTimer` and writes through the already-wired `ingest` face, so the
- * > caller wires no `decay`/`decayTrigger` and the recipe composes whether or
- * > not the face is also used. Both deliver the §5.8 "`fromTimer` for periodic
- * > confidence drift" behavior; pick the face for a caller-controlled policy
- * > Node, this recipe for a self-contained drop-in forgetting curve.
- *
- * **Convergence (conditional — read this).** Per-id decay is computed against
- * the elapsed time since this fact was last decayed (recipe-owned closure
- * clock — `t_ns` provenance is preserved, never overwritten; a re-ingested
- * *new version* — fresher `t_ns` than the last tick — restarts from its own
- * `t_ns`, not the stale prior-version tick). A fragment is skipped (no
- * re-ingest) when it is obsolete (`validTo` set), already at/below `floor`, or
- * the drift is below `epsilon`. Quiescence ("timer keeps ticking, recipe emits
- * `[]`, no churn") therefore holds **only when `epsilon > 0` AND `floor` is
- * reachable** — with `epsilon <= 0` and a finite half-life the geometric
- * drift toward `floor` is always `> 0`, so the loop re-ingests every live fact
- * forever (silent CPU/GC churn, never an error). `epsilon` is clamped to a
- * tiny positive minimum to make accidental non-quiescence impossible.
- * Obsoletion safety: the obsolete guard is re-checked against the **live**
- * store immediately before re-ingest, so a fact obsoleted by an in-flight
- * cascade earlier in the same tick is never resurrected by a stale snapshot
- * read.
- *
- * @module
- */
-
-import { type Node, node, wallClockNs } from "@graphrefly/pure-ts/core";
-import { fromTimer, keepalive } from "@graphrefly/pure-ts/extra";
-import type { FactId, MemoryFragment, ReactiveFactStoreGraph } from "../fact-store.js";
-
-export interface DecayExponentialOptions {
-	/** Half-life in nanoseconds — confidence halves every `halfLifeNs` of fact age. */
-	readonly halfLifeNs: bigint;
-	/** Timer period in milliseconds (how often the forgetting pass runs). */
-	readonly periodMs: number;
-	/** Confidence floor; facts at/below it are left untouched. Default `0`. */
-	readonly floor?: number;
-	/**
-	 * Minimum confidence drift to bother re-ingesting. Default `1e-4`. Clamped
-	 * to a tiny positive minimum (`<= 0` would prevent quiescence — see the
-	 * module "Convergence" note).
-	 */
-	readonly epsilon?: number;
-	/** Node name. Default `decay_exponential`. */
-	readonly name?: string;
-}
-
-/**
- * Wire an exponential-decay forgetting loop onto a {@link reactiveFactStore}.
- * Self-adds a driver Node to the store's graph (`describe()`-visible) and
- * returns it; each emission is the batch of fragments decayed that tick (also
- * fed back through `ingest`).
- *
- * @category memory
- */
-export function decayExponential<T>(
-	mem: ReactiveFactStoreGraph<T>,
-	ingest: Node<MemoryFragment<T>>,
-	opts: DecayExponentialOptions,
-): Node<readonly MemoryFragment<T>[]> {
-	const floor = opts.floor ?? 0;
-	// Clamp to a tiny positive min: epsilon <= 0 would make the geometric
-	// drift never fall below it ⇒ the loop never quiesces (module note).
-	const epsilon = Math.max(opts.epsilon ?? 1e-4, Number.EPSILON);
-	const half = Number(opts.halfLifeNs);
-	// Recipe-owned per-id "last decayed at" clock — keeps `t_ns` provenance
-	// intact while still giving correct per-interval exponential drift.
-	const lastTick = new Map<FactId, bigint>();
-
-	const timer = fromTimer(opts.periodMs, { period: opts.periodMs });
-
-	const driver = node<readonly MemoryFragment<T>[]>(
-		[timer],
-		(_batchData, actions) => {
-			const fs = mem.factStore.cache as
-				| { byId: ReadonlyMap<FactId, MemoryFragment<T>> }
-				| undefined;
-			if (!fs) {
-				actions.emit([]);
-				return;
-			}
-			const now = BigInt(wallClockNs());
-			const decayed: MemoryFragment<T>[] = [];
-			const liveIds = new Set<FactId>();
-			for (const f of fs.byId.values()) {
-				liveIds.add(f.id);
-				if (f.validTo !== undefined) continue; // obsolete — dead, don't drift
-				if (f.confidence <= floor) continue; // already forgotten
-				// Version-aware "since": if our last tick predates the fact's own
-				// t_ns, this is a freshly re-ingested version — restart from its
-				// t_ns, not the stale prior-version tick (which would over-decay
-				// across time the new version didn't exist).
-				const lt = lastTick.get(f.id);
-				const since = lt !== undefined && lt >= f.t_ns ? lt : f.t_ns;
-				const elapsed = Number(now - since);
-				if (elapsed <= 0) continue;
-				const factor = 0.5 ** (half > 0 ? elapsed / half : 0);
-				if (!Number.isFinite(factor)) continue; // bigint→Number overflow guard
-				let next = f.confidence * factor;
-				if (next < floor) next = floor;
-				if (f.confidence - next < epsilon) continue; // drift too small
-				// Resurrection guard: re-read the LIVE store — a fact obsoleted by
-				// an in-flight cascade triggered by an earlier re-ingest this same
-				// tick must not be re-ingested from this (pre-cascade) snapshot.
-				const liveNow = (
-					mem.factStore.cache as { byId: ReadonlyMap<FactId, MemoryFragment<T>> } | undefined
-				)?.byId.get(f.id);
-				if (liveNow && liveNow.validTo !== undefined) continue;
-				lastTick.set(f.id, now);
-				const drifted: MemoryFragment<T> = { ...f, confidence: next };
-				decayed.push(drifted);
-				ingest.emit(drifted); // MEME L1 direct-replace (the wired face)
-			}
-			// Prune the closure clock of ids no longer in the store (bounds the
-			// Map to live facts; obsoleted-but-present ids stay until removed).
-			if (lastTick.size > liveIds.size) {
-				for (const id of lastTick.keys()) if (!liveIds.has(id)) lastTick.delete(id);
-			}
-			actions.emit(decayed);
-		},
-		{
-			name: opts.name ?? "decay_exponential",
-			describeKind: "derived",
-			initial: [] as readonly MemoryFragment<T>[],
-		},
-	);
-
-	mem.add(driver, { name: opts.name ?? "decay_exponential" });
-	mem.addDisposer(keepalive(timer));
-	mem.addDisposer(keepalive(driver));
-	return driver;
-}
diff --git a/src/utils/memory/recipes/index.ts b/src/utils/memory/recipes/index.ts
deleted file mode 100644
index a27e4c42..00000000
--- a/src/utils/memory/recipes/index.ts
+++ /dev/null
@@ -1,76 +0,0 @@
-/**
- * DS-14.7 — `reactiveFactStore` recipe library (follow-up #1).
- *
- * Eight shipped, tested compositions over the four extension faces (① plain fn,
- * ② `Node<Policy>`, ③ topic input, ④ topic-output subscribe). They mitigate the
- * factory's deliberate steeper learning curve (DS-14.7 PART 4.2) by packaging
- * the canonical patterns as first-class factories instead of register-as-hook
- * machinery — each is small, single-purpose, and copy-paste-modify friendly.
- *
- * | Recipe | Face | Closes |
- * |---|---|---|
- * | {@link scoringByOutcome}    | ② `scoring`        | Hassabis continual learning |
- * | {@link decayExponential}    | ③ `ingest` (timer) | Forgetting curve (ergonomic self-contained alternative to the wired `decay`/`decayTrigger` face) |
- * | {@link consolidationRem}    | ① `consolidate`+③  | REM replay consolidation |
- * | {@link admissionLlmJudge}   | ② `admissionFilter`| LLM gatekeeper (sync-face adapter) |
- * | {@link shardByTenant}       | ① `shardBy`        | Multi-tenant isolation |
- * | {@link invalidationTracer}  | ④ `cascade`        | Cascade debugging (invisible-edge tracer) |
- * | {@link bitemporalQuery}     | ④ `factStore`      | MEME L3 "as of t" historical view |
- * | {@link influenceAnalysis}   | ④ `dependentsIndex`| MEME write-time blast-radius |
- *
- * **Lifecycle model — two shapes (intentional, not an inconsistency):**
- * - *Config-input / returned-projection* (`scoringByOutcome`, `admissionLlmJudge`,
- *   `consolidationRem`, `shardByTenant`, `bitemporalQuery`): produce a value
- *   the **caller or factory** owns — a `Node`/fn spread into config (the
- *   factory keepalives it transitively) or a view Node returned for the caller
- *   to subscribe (the `itemNode` precedent — no `keepalive`, so no forced
- *   retention; lifecycle follows the caller's subscription).
- * - *`mem`-attached observer/driver* (`decayExponential`, `invalidationTracer`,
- *   `influenceAnalysis`): self-`mem.add` + `keepalive` + disposer so they are
- *   `describe()`-visible and torn down on `mem.destroy()`.
- *
- * **Single-apply per store.** Attached recipes add fixed-named nodes;
- * `Graph.add` throws on a duplicate name. Apply an attached recipe more than
- * once on the same `mem` only with a distinct `opts.name`. `influenceOf(id)`
- * is memoized per-`id` (repeat calls return the same node — safe & idempotent).
- *
- * @module
- */
-
-export {
-	type AdmissionLlmJudgeOptions,
-	admissionLlmJudge,
-} from "./admission-llm-judge.js";
-export {
-	type BitemporalQueryOptions,
-	bitemporalQuery,
-} from "./bitemporal-query.js";
-export {
-	type ConsolidationRemConfig,
-	type ConsolidationRemOptions,
-	consolidationRem,
-} from "./consolidation-rem.js";
-export {
-	type DecayExponentialOptions,
-	decayExponential,
-} from "./decay-exponential.js";
-export {
-	type InfluenceAnalysis,
-	type InfluenceAnalysisOptions,
-	type InfluenceRow,
-	influenceAnalysis,
-} from "./influence-analysis.js";
-export {
-	type InvalidationTraceEntry,
-	type InvalidationTracerOptions,
-	invalidationTracer,
-} from "./invalidation-tracer.js";
-export {
-	type ScoringByOutcomeOptions,
-	scoringByOutcome,
-} from "./scoring-by-outcome.js";
-export {
-	type ShardByTenantConfig,
-	type ShardByTenantOptions,
-	shardByTenant,
-} from "./shard-by-tenant.js";
diff --git a/src/utils/memory/recipes/influence-analysis.ts b/src/utils/memory/recipes/influence-analysis.ts
deleted file mode 100644
index 16cb5e06..00000000
--- a/src/utils/memory/recipes/influence-analysis.ts
+++ /dev/null
@@ -1,139 +0,0 @@
-/**
- * Recipe — **write-time influence analysis** (MEME write-time `reachable`).
- *
- * The store's `dependents_index` is a one-hop reverse-dependency map; "if I
- * obsolete fact X, what *transitively* gets invalidated?" is its closure. This
- * recipe exposes that closure as a reactive projection over face ④
- * (`mem.dependentsIndex`), so a writer can see blast-radius **before**
- * committing an obsolescence — the same reachability the cascade loop walks,
- * surfaced for inspection.
- *
- * ```ts
- * const inf = influenceAnalysis(mem);
- * inf.influenceOf("home").subscribe(ids => console.log("obsoleting home hits", ids));
- * inf.ranked.subscribe(rows => rows.slice(0,5)); // most-influential facts
- * ```
- *
- * Pure observer — never writes back, so it cannot perturb cascade
- * convergence. **Single-apply per store** (it adds an `${name}_ranked` node);
- * apply twice on the same `mem` only with a distinct `opts.name`.
- *
- * **Cost.** `ranked` runs a BFS closure per index key on every
- * `dependents_index` emit — O(keys · (V+E)), NOT O(maxRanked); `maxRanked`
- * caps only the emitted slice, not the computation. Acceptable because
- * `dependents_index` is metadata (≪ the fact store, per DS-14.7 Q9-open-1);
- * for a pathologically dense index prefer `influenceOf(id)` (single-root BFS)
- * over subscribing `ranked`. In a cyclic reverse-dep graph
- * (LLM-extracted `A→B→A`) `closureOf` still terminates (`seen` set) but every
- * SCC member reports the same closure size — a *reachability* count, not the
- * cascade's actual obsolete-only propagation reach (which `processedRoots`
- * bounds further).
- *
- * @module
- */
-
-import { type Node, node } from "@graphrefly/pure-ts/core";
-import { keepalive } from "@graphrefly/pure-ts/extra";
-import type { DependentsIndex, FactId, ReactiveFactStoreGraph } from "../fact-store.js";
-import { lastOf } from "./_shared.js";
-
-export interface InfluenceRow {
-	readonly factId: FactId;
-	/** Size of the transitive dependent closure (blast radius if obsoleted). */
-	readonly influence: number;
-}
-
-export interface InfluenceAnalysisOptions {
-	/** Cap on rows emitted by `ranked` (top-N by influence). Default `64`. */
-	readonly maxRanked?: number;
-	/** Node name prefix. Default `influence`. */
-	readonly name?: string;
-}
-
-export interface InfluenceAnalysis {
-	/** Reactive transitive dependent closure of `rootId` (excludes the root). */
-	influenceOf(rootId: FactId): Node<readonly FactId[]>;
-	/** Facts ranked by transitive-closure size (desc), capped at `maxRanked`. */
-	readonly ranked: Node<readonly InfluenceRow[]>;
-}
-
-/** BFS the reverse-dep index from `root`; returns reachable ids (root excluded). */
-function closureOf(index: DependentsIndex, root: FactId): FactId[] {
-	const seen = new Set<FactId>();
-	const queue: FactId[] = [root];
-	while (queue.length > 0) {
-		const cur = queue.shift()!;
-		for (const dep of index.get(cur) ?? []) {
-			if (seen.has(dep) || dep === root) continue;
-			seen.add(dep);
-			queue.push(dep);
-		}
-	}
-	return [...seen];
-}
-
-/**
- * Attach influence/blast-radius analysis to a {@link reactiveFactStore}.
- *
- * @category memory
- */
-export function influenceAnalysis<T>(
-	mem: ReactiveFactStoreGraph<T>,
-	opts: InfluenceAnalysisOptions = {},
-): InfluenceAnalysis {
-	const prefix = opts.name ?? "influence";
-	const maxRanked = Math.max(1, opts.maxRanked ?? 64);
-
-	const ranked = node<readonly InfluenceRow[]>(
-		[mem.dependentsIndex],
-		(batchData, actions, ctx) => {
-			const index = lastOf<DependentsIndex>(batchData[0], ctx.prevData[0]);
-			if (index == null) {
-				actions.emit([]);
-				return;
-			}
-			const rows: InfluenceRow[] = [];
-			for (const key of index.keys()) {
-				rows.push({ factId: key, influence: closureOf(index, key).length });
-			}
-			rows.sort((a, b) => b.influence - a.influence);
-			actions.emit(rows.slice(0, maxRanked));
-		},
-		{
-			name: `${prefix}_ranked`,
-			describeKind: "derived",
-			initial: [] as readonly InfluenceRow[],
-		},
-	);
-	mem.add(ranked, { name: `${prefix}_ranked` });
-	mem.addDisposer(keepalive(ranked));
-
-	// Memoize per-rootId: a recipe node is added to `mem` under a unique name,
-	// and `Graph.add` throws on a duplicate name — so `influenceOf("a")` called
-	// twice (two call sites, or a re-derive) MUST return the same node, not
-	// re-add. Also bounds growth (one node per distinct queried root, not per
-	// call) for the store's lifetime.
-	const builtFor = new Map<FactId, Node<readonly FactId[]>>();
-	function influenceOf(rootId: FactId): Node<readonly FactId[]> {
-		const existing = builtFor.get(rootId);
-		if (existing) return existing;
-		const n = node<readonly FactId[]>(
-			[mem.dependentsIndex],
-			(batchData, actions, ctx) => {
-				const index = lastOf<DependentsIndex>(batchData[0], ctx.prevData[0]);
-				actions.emit(index == null ? [] : closureOf(index, rootId));
-			},
-			{
-				name: `${prefix}_of_${rootId}`,
-				describeKind: "derived",
-				initial: [] as readonly FactId[],
-			},
-		);
-		mem.add(n, { name: `${prefix}_of_${rootId}` });
-		mem.addDisposer(keepalive(n));
-		builtFor.set(rootId, n);
-		return n;
-	}
-
-	return { influenceOf, ranked };
-}
diff --git a/src/utils/memory/recipes/invalidation-tracer.ts b/src/utils/memory/recipes/invalidation-tracer.ts
deleted file mode 100644
index 40be7574..00000000
--- a/src/utils/memory/recipes/invalidation-tracer.ts
+++ /dev/null
@@ -1,107 +0,0 @@
-/**
- * Recipe — **cascade-event tracer** (debugging the invisible edge).
- *
- * The `dependents_index` lookup that drives cascade invalidation is a fn-body
- * map read, not a topology edge — `describe()` / `explain()` can't see *why*
- * fact C got invalidated. This recipe is the pure-observer (face ④) companion
- * that subscribes `mem.cascade` + `mem.cascadeOverflow` and keeps a bounded
- * ring of human-readable trace entries (each carries the `causalReason` string
- * the store stamps for exactly this purpose), so a developer can answer
- * "what obsoleted this?" without instrumenting the store.
- *
- * ```ts
- * const trace = invalidationTracer(mem, { limit: 256 });
- * trace.subscribe((entries) => entries.forEach(e => log(e.causalReason)));
- * ```
- *
- * Read-only: it never writes back into the store, so it cannot perturb cascade
- * convergence.
- *
- * @module
- */
-
-import { type Node, node } from "@graphrefly/pure-ts/core";
-import { keepalive } from "@graphrefly/pure-ts/extra";
-import type {
-	CascadeEvent,
-	CascadeOverflow,
-	CascadeReason,
-	FactId,
-	ReactiveFactStoreGraph,
-} from "../fact-store.js";
-
-export interface InvalidationTraceEntry {
-	readonly kind: "cascade" | "overflow";
-	readonly factId: FactId;
-	readonly rootFactId: FactId;
-	readonly reason: CascadeReason | "overflow";
-	readonly iteration?: number;
-	readonly causalReason: string;
-}
-
-export interface InvalidationTracerOptions {
-	/** Ring-buffer size (most-recent N trace entries retained). Default `256`. */
-	readonly limit?: number;
-	/** Node name. Default `invalidation_tracer`. */
-	readonly name?: string;
-}
-
-/**
- * Attach a bounded cascade-event tracer to a {@link reactiveFactStore}.
- * Self-adds a `describe()`-visible observer Node and returns it; each emission
- * is the current trace ring (oldest → newest).
- *
- * @category memory
- */
-export function invalidationTracer<T>(
-	mem: ReactiveFactStoreGraph<T>,
-	opts: InvalidationTracerOptions = {},
-): Node<readonly InvalidationTraceEntry[]> {
-	const limit = Math.max(1, opts.limit ?? 256);
-	const ring: InvalidationTraceEntry[] = []; // sole-owner bounded fold
-
-	const push = (e: InvalidationTraceEntry): void => {
-		ring.push(e);
-		if (ring.length > limit) ring.splice(0, ring.length - limit);
-	};
-
-	const tracer = node<readonly InvalidationTraceEntry[]>(
-		[mem.cascade, mem.cascadeOverflow],
-		(batchData, actions) => {
-			const cascadeWaves = (batchData[0] as readonly (readonly CascadeEvent[])[] | undefined) ?? [];
-			for (const wave of cascadeWaves) {
-				for (const ev of wave) {
-					push({
-						kind: "cascade",
-						factId: ev.factId,
-						rootFactId: ev.rootFactId,
-						reason: ev.reason,
-						iteration: ev.iteration,
-						causalReason: ev.causalReason,
-					});
-				}
-			}
-			const overflows = (batchData[1] as readonly (CascadeOverflow | null)[] | undefined) ?? [];
-			for (const ov of overflows) {
-				if (ov == null) continue;
-				push({
-					kind: "overflow",
-					factId: ov.sample[0] ?? "",
-					rootFactId: ov.rootFactId,
-					reason: "overflow",
-					causalReason: `cascade overflow: ${ov.droppedCount} dropped (root ${ov.rootFactId})`,
-				});
-			}
-			actions.emit([...ring]);
-		},
-		{
-			name: opts.name ?? "invalidation_tracer",
-			describeKind: "derived",
-			initial: [] as readonly InvalidationTraceEntry[],
-		},
-	);
-
-	mem.add(tracer, { name: opts.name ?? "invalidation_tracer" });
-	mem.addDisposer(keepalive(tracer));
-	return tracer;
-}
diff --git a/src/utils/memory/recipes/scoring-by-outcome.ts b/src/utils/memory/recipes/scoring-by-outcome.ts
deleted file mode 100644
index 54d14264..00000000
--- a/src/utils/memory/recipes/scoring-by-outcome.ts
+++ /dev/null
@@ -1,101 +0,0 @@
-/**
- * Recipe — **self-evolving scoring policy** (continual learning).
- *
- * Closes Hassabis's continual-learning frame against the `scoring` extension
- * face (②): an outcome / RL signal stream feeds back into the policy that
- * `reactiveFactStore` applies on `outcome` write-back, so the agent's memory
- * *learns* which facts proved useful.
- *
- * ```ts
- * const outcomes = node<OutcomeSignal>([], { initial: undefined });
- * const mem = reactiveFactStore<Doc>({
- *   ingest, extractDependencies,
- *   outcome:  outcomes,                       // ③ topic input (RL signal)
- *   scoring:  scoringByOutcome(outcomes),     // ② policy that evolves with it
- * });
- * ```
- *
- * The returned `Node<ScoringPolicy<T>>` re-emits a fresh policy closure every
- * time an `OutcomeSignal` arrives; the closure scores a fragment as
- * `clamp01(base(f) + learningRate · Σ reward(f.id))`. The reward accumulator is
- * a recipe-owned closure Map (sole-owner mutation inside the derived fn — the
- * COMPOSITION-GUIDE-sanctioned pattern for a fold the node alone advances),
- * keyed by `factId`, so learning is cumulative across episodes and survives
- * policy re-emission.
- *
- * **Contract (load-bearing — do not "normalize"):**
- * - The fn folds **every signal in the wave** (`for (const sig of batchData[0])`),
- *   NOT `lastOf` last-only like the other recipes — a batched wave carrying N
- *   `OutcomeSignal`s must accumulate all N. Replacing this with `lastOf` would
- *   silently drop all-but-last reward in a batch.
- * - `outcomes` MUST be a non-replaying event source (each physical signal
- *   delivered once). The fold has no per-signal idempotency key (two identical
- *   `{factId, reward}` are legitimately distinct events); a source that
- *   push-on-subscribe **re-delivers** a cached signal to a re-subscribe would
- *   double-count it. The normal wiring (single keepalive'd consumer via the
- *   factory's `outcomeProcessor`, subscribed at construction before any emit)
- *   is safe.
- * - The policy node carries **no `equals`** by design: every emit is a fresh
- *   closure identity so the factory's `outcomeProcessor` always re-fires and
- *   re-reads the freshly-folded `acc` (the closure reads `acc` lazily at call
- *   time). Adding an `equals` would make outcome write-back lag one signal.
- * - `acc` retains one entry per rewarded `factId` for the store's lifetime
- *   (same bounded-growth class as `ingestLog`; acceptable — it is metadata).
- *
- * @module
- */
-
-import { type Node, node } from "@graphrefly/pure-ts/core";
-import type { FactId, MemoryFragment, OutcomeSignal, ScoringPolicy } from "../fact-store.js";
-
-export interface ScoringByOutcomeOptions<T> {
-	/**
-	 * Base score before accumulated reward. Default: the fragment's own
-	 * `confidence` (so an un-rewarded fact keeps its ingested confidence).
-	 */
-	readonly base?: (f: MemoryFragment<T>) => number;
-	/** Multiplier on accumulated reward. Default `1`. */
-	readonly learningRate?: number;
-	/** Node name (collision-safe if you build more than one). Default `scoring_by_outcome`. */
-	readonly name?: string;
-}
-
-const clamp01 = (n: number): number => (n < 0 ? 0 : n > 1 ? 1 : n);
-
-/**
- * Build a continual-learning {@link ScoringPolicy} Node from an
- * {@link OutcomeSignal} stream. Pass the SAME `outcomes` Node as both
- * `config.outcome` and (via this recipe) `config.scoring`.
- *
- * @category memory
- */
-export function scoringByOutcome<T>(
-	outcomes: Node<OutcomeSignal>,
-	opts: ScoringByOutcomeOptions<T> = {},
-): Node<ScoringPolicy<T>> {
-	const base = opts.base ?? ((f: MemoryFragment<T>) => f.confidence);
-	const learningRate = opts.learningRate ?? 1;
-	// Sole-owner reward accumulator (recipe-level fold; only this node writes it).
-	const acc = new Map<FactId, number>();
-
-	const buildPolicy = (): ScoringPolicy<T> => (fragment) =>
-		clamp01(base(fragment) + learningRate * (acc.get(fragment.id) ?? 0));
-
-	return node<ScoringPolicy<T>>(
-		[outcomes],
-		(batchData, actions) => {
-			// Apply every signal in the wave (batched outcomes accumulate in order).
-			// Empty wave (push-on-subscribe / SENTINEL) → re-emit the current policy
-			// so a late subscriber still gets a usable scorer.
-			const wave = (batchData[0] as readonly OutcomeSignal[] | undefined) ?? [];
-			for (const sig of wave) acc.set(sig.factId, (acc.get(sig.factId) ?? 0) + sig.reward);
-			actions.emit(buildPolicy());
-		},
-		{
-			name: opts.name ?? "scoring_by_outcome",
-			describeKind: "derived",
-			// Usable scorer before any outcome arrives (base-only).
-			initial: buildPolicy(),
-		},
-	);
-}
diff --git a/src/utils/memory/recipes/shard-by-tenant.ts b/src/utils/memory/recipes/shard-by-tenant.ts
deleted file mode 100644
index 15796a83..00000000
--- a/src/utils/memory/recipes/shard-by-tenant.ts
+++ /dev/null
@@ -1,79 +0,0 @@
-/**
- * Recipe — **multi-tenant isolation** sharding.
- *
- * Two postures over the `shardBy` + `shardCount` faces (plain-fn face ①):
- *
- * - **Strict isolation** (`tenants` listed): one shard per tenant, fixed
- *   `tenant → index` mapping. A tenant's facts never share a shard with
- *   another's — the strongest in-process isolation the static-topology store
- *   offers (per-shard `state<FactStore>` nodes). Unknown tenants fall to a
- *   dedicated overflow shard (last index).
- * - **Soft partition** (no `tenants`): hash the tenant key into `shardCount`
- *   buckets — even load, tenants *may* co-reside (collision), but cross-tenant
- *   reads still require an explicit query (no accidental leakage of the *index*,
- *   just shared physical storage).
- *
- * **Caveats.** Soft "even load" holds only at sufficient tenant cardinality —
- * with few tenants vs `shardCount`, FNV-1a-mod can collide several onto one
- * shard (use **strict** mode for a guaranteed-per-tenant shard). `tenantOf`
- * must return a defined, stable key: a `undefined`/`null` return is coerced to
- * the string `"undefined"` by the factory's hash and silently pools all
- * tenant-less facts together. Strict mode's overflow shard intentionally pools
- * **all** unconfigured tenants together (isolated from configured ones, not
- * from each other).
- *
- * ```ts
- * const mem = reactiveFactStore<Doc>({
- *   ingest, extractDependencies,
- *   ...shardByTenant<Doc>((f) => f.payload.tenantId, {
- *     tenants: ["acme", "globex"],   // strict: 3 shards (2 + overflow)
- *   }),
- * });
- * ```
- *
- * @module
- */
-
-import type { MemoryFragment, ShardKey } from "../fact-store.js";
-
-export interface ShardByTenantOptions {
-	/**
-	 * Known tenants for strict 1-shard-per-tenant isolation. Omit for soft
-	 * hash partitioning. The strict layout adds one trailing **overflow** shard
-	 * for tenants not in this list (so an unconfigured tenant is still isolated
-	 * from the configured ones, just pooled together).
-	 */
-	readonly tenants?: readonly string[];
-	/** Bucket count for the soft (non-strict) posture. Default `4`. */
-	readonly shardCount?: number;
-}
-
-export interface ShardByTenantConfig<T> {
-	readonly shardBy: (f: MemoryFragment<T>) => ShardKey;
-	readonly shardCount: number;
-}
-
-/**
- * Build the `{ shardBy, shardCount }` pair for tenant-isolated sharding.
- * `tenantOf` extracts the tenant key from a fragment. Spread into
- * {@link reactiveFactStore}'s config.
- *
- * @category memory
- */
-export function shardByTenant<T>(
-	tenantOf: (f: MemoryFragment<T>) => string,
-	opts: ShardByTenantOptions = {},
-): ShardByTenantConfig<T> {
-	if (opts.tenants && opts.tenants.length > 0) {
-		const idx = new Map(opts.tenants.map((t, i) => [t, i] as const));
-		const overflow = opts.tenants.length; // trailing shard for unknown tenants
-		return {
-			shardBy: (f) => idx.get(tenantOf(f)) ?? overflow,
-			shardCount: opts.tenants.length + 1,
-		};
-	}
-	const shardCount = Math.max(1, opts.shardCount ?? 4);
-	// Return the tenant string itself — the factory's default FNV-1a hash-mod
-	// sharder buckets it deterministically into `shardCount`.
-	return { shardBy: (f) => tenantOf(f), shardCount };
-}
diff --git a/src/utils/memory/simple-fact-store.ts b/src/utils/memory/simple-fact-store.ts
deleted file mode 100644
index db48c6f5..00000000
--- a/src/utils/memory/simple-fact-store.ts
+++ /dev/null
@@ -1,243 +0,0 @@
-/**
- * `simpleFactStore()` — the 80%-case ergonomic wrapper over
- * {@link reactiveFactStore} / {@link persistentReactiveFactStore}
- * (DS-14.7 follow-up #2; design LOCKED 2026-05-17 `/dev-dispatch` Q-walk,
- * Q1–Q6 + sub-decisions resolved).
- *
- * Closes the gap where a consumer wanting durable agent memory had to
- * hand-compose: an `ingest` source + `extractDependencies` + (optionally) a
- * `StorageBackend` + decay/consolidation recipes + the
- * `BigInt(monotonicNs())` fragment boilerplate. `simpleFactStore` owns all
- * of that and exposes a single ergonomic `remember(id, payload, opts?)`.
- *
- * **Q-walk locks (canonical: `docs/optimizations.md` DS-14.7 follow-up #2):**
- * - **Q1** — `extractDependencies` defaults to `() => []` (flat store;
- *   cascade inert by default — dependency-tracking is opt-in).
- * - **Q2** — single factory, **optional `storage`**: present → wraps
- *   {@link persistentReactiveFactStore} (durable, event-sourced); absent →
- *   in-memory {@link reactiveFactStore}.
- * - **Q3** — the wrapper **owns** the internal `ingest` source and exposes
- *   {@link SimpleFactStoreGraph.remember}. `remember` `.emit`s into the
- *   owned leaf source — this is the *sanctioned* external push that the
- *   `reactiveFactStore` ingest contract documents (same shape as the
- *   `decay`/replay recipes' `.emit`-into-source), **not** a spec-§5.9
- *   imperative trigger: it feeds DATA into a source node, it does not
- *   bypass topology for control flow. Reactive reads (`answer` / `review` /
- *   `events`) stay the canonical observation surface.
- * - **Q4** — auto-wire **default recipes** with internal `fromTimer`
- *   cadences (batteries-included; user-blessed 2026-05-17). `decay` is
- *   generically meaningful (confidence forgetting needs no domain
- *   knowledge) → **ON by default** with conservative defaults
- *   ({@link DEFAULT_DECAY_HALF_LIFE_NS} / {@link DEFAULT_DECAY_PERIOD_MS}),
- *   tunable or `false` to disable. `consolidate` is **domain-bound** —
- *   {@link consolidationRem} *requires* a `summarize` (there is no generic
- *   default; an arbitrary `T` cannot be summarized blindly), so it is wired
- *   **iff** the caller supplies `opts.consolidate`. This consolidation
- *   asymmetry is dictated by the recipe's own required contract, not an
- *   autonomous downgrade of the Q4 lock.
- * - **Q5** — minimal input: `remember(id, payload, { tags? })` auto-fills
- *   `t_ns = BigInt(monotonicNs())` (per the {@link MemoryFragment.t_ns}
- *   contract + the clock-return-type rule — `monotonicNs()` is `number`,
- *   the `BigInt(...)` wrap is load-bearing) and `confidence = 1`.
- * - **Q6** — **wraps** the existing factories (not a parallel impl).
- *
- * Presentation-only (`@graphrefly/graphrefly`, `utils/memory` barrel),
- * universal tier (`fromTimer` only, no `node:*`/DOM — the optional
- * `StorageBackend` impl's tier is the *caller's* concern, forwarded
- * verbatim, exactly as {@link persistentReactiveFactStore} does).
- *
- * @module
- */
-
-import { monotonicNs, node } from "@graphrefly/pure-ts/core";
-import type { Codec, StorageBackend } from "@graphrefly/pure-ts/extra";
-import type { FactId, MemoryFragment, ReactiveFactStoreGraph } from "./fact-store.js";
-import { reactiveFactStore } from "./fact-store.js";
-import type { PersistentReactiveFactStoreGraph } from "./persistent-fact-store.js";
-import { persistentReactiveFactStore } from "./persistent-fact-store.js";
-import { type ConsolidationRemOptions, consolidationRem } from "./recipes/consolidation-rem.js";
-import { type DecayExponentialOptions, decayExponential } from "./recipes/decay-exponential.js";
-
-/**
- * Default exponential-decay half-life: **7 days** in nanoseconds. Confidence
- * halves once per week of fact age — gentle forgetting suitable for the
- * 80%-case agent memory. Override via `opts.decay.halfLifeNs`.
- */
-export const DEFAULT_DECAY_HALF_LIFE_NS = 604_800_000_000_000n; // 7 * 24 * 3600 * 1e9
-
-/**
- * Default decay tick cadence: **1 hour** (ms). How often the forgetting pass
- * runs. Override via `opts.decay.periodMs`.
- */
-export const DEFAULT_DECAY_PERIOD_MS = 3_600_000; // 60 * 60 * 1000
-
-/** Per-fact override fields accepted by {@link SimpleFactStoreGraph.remember}. */
-export interface RememberOptions {
-	/** Tags. Default `[]`. */
-	readonly tags?: readonly string[];
-	/** Dependency edges (fact IDs this fact derives from). Default `[]`. */
-	readonly sources?: readonly FactId[];
-	/** Confidence 0..1. Default `1`. */
-	readonly confidence?: number;
-	/** Valid-time end — set to obsolete a fact (MEME L3 lever). */
-	readonly validTo?: bigint;
-	/** Valid-time start — `undefined` = unbounded past. */
-	readonly validFrom?: bigint;
-	/** Free-form provenance string. */
-	readonly provenance?: string;
-}
-
-export interface SimpleFactStoreOptions<T> {
-	/**
-	 * Durable backing. Present → delegates to
-	 * {@link persistentReactiveFactStore} (event-sourced, replay-on-start,
-	 * substrate-owned cursor). Absent → in-memory {@link reactiveFactStore}.
-	 * The backend's runtime tier (node / browser) is the caller's concern —
-	 * forwarded verbatim.
-	 */
-	readonly storage?: StorageBackend;
-	/**
-	 * Cascade dependency extractor. **Default `() => []`** — flat store, no
-	 * cascade. Supply to opt into MEME L2 cascade invalidation.
-	 */
-	readonly extractDependencies?: (f: MemoryFragment<T>) => readonly FactId[];
-	/**
-	 * Exponential-decay forgetting. **Default: ON** with
-	 * {@link DEFAULT_DECAY_HALF_LIFE_NS} / {@link DEFAULT_DECAY_PERIOD_MS}.
-	 * Pass a partial to tune; pass `false` to disable. Wires an internal
-	 * `fromTimer` (the user-blessed batteries-included cadence).
-	 */
-	readonly decay?: false | Partial<DecayExponentialOptions>;
-	/**
-	 * REM-replay consolidation. **Domain-bound** — requires a `summarize`
-	 * (no generic default exists). Supply the full
-	 * {@link ConsolidationRemOptions} to enable; omit to disable. Wires an
-	 * internal `fromTimer` at `consolidate.periodMs`.
-	 */
-	readonly consolidate?: ConsolidationRemOptions<T>;
-	/** Persistent-only: durable bucket name. Default `fact_store_ingest`. */
-	readonly persistName?: string;
-	/** Persistent-only: durable codec. Default `bigintJsonCodecFor`. */
-	readonly codec?: Codec<readonly MemoryFragment<T>[]>;
-}
-
-/**
- * The ergonomic write added to every `simpleFactStore` graph. Normalizes to a
- * {@link MemoryFragment} (auto `t_ns = BigInt(monotonicNs())`,
- * `confidence = 1`, `tags`/`sources` = `[]`) and `.emit`s it into the owned
- * `ingest` source. Re-`remember`ing an existing `id` is the MEME L1
- * direct-replace lever; set `opts.validTo` to obsolete (MEME L3).
- */
-export type SimpleFactStoreRemember<T> = (id: FactId, payload: T, opts?: RememberOptions) => void;
-
-/**
- * In-memory `simpleFactStore` graph (no `storage`) augmented with
- * {@link SimpleFactStoreRemember}.
- */
-export interface SimpleFactStoreGraph<T> extends ReactiveFactStoreGraph<T> {
-	remember: SimpleFactStoreRemember<T>;
-}
-
-/**
- * Durable (`storage`-backed) `simpleFactStore` graph — the **type-honest**
- * persistent surface. EC-LOW-1 (`/qa` 2026-05-17): the `storage` overload
- * returns this so `position` / `replayedCount` / `flush` / `tier` are typed
- * without a hand-cast (the durable path is the headline 80%-case).
- */
-export type PersistentSimpleFactStoreGraph<T> = PersistentReactiveFactStoreGraph<T> & {
-	remember: SimpleFactStoreRemember<T>;
-};
-
-/**
- * Build a fact store with sensible defaults and a one-call `remember`.
- *
- * @example
- * ```ts
- * import { simpleFactStore } from "@graphrefly/graphrefly/utils/memory";
- * import { memoryBackend } from "@graphrefly/graphrefly/extra";
- *
- * const mem = simpleFactStore<string>(); // in-memory, decay ON
- * mem.remember("user:lang", "TypeScript", { tags: ["pref"] });
- * mem.answer.subscribe((a) => console.log(a)); // reactive read
- *
- * // Durable: the `storage` overload returns the typed persistent surface
- * // (no hand-cast needed for `position` / `flush`).
- * const durable = simpleFactStore<string>({ storage: memoryBackend() });
- * durable.remember("k", "v");
- * await durable.flush();
- * ```
- *
- * @category memory
- */
-export function simpleFactStore<T>(
-	opts: SimpleFactStoreOptions<T> & { storage: StorageBackend },
-): PersistentSimpleFactStoreGraph<T>;
-export function simpleFactStore<T>(opts?: SimpleFactStoreOptions<T>): SimpleFactStoreGraph<T>;
-export function simpleFactStore<T>(opts: SimpleFactStoreOptions<T> = {}): SimpleFactStoreGraph<T> {
-	// Q3: the wrapper OWNS the ingest source (a leaf source — no deps).
-	const ingest = node<MemoryFragment<T>>([], { initial: undefined });
-	const extractDependencies = opts.extractDependencies ?? (() => []);
-
-	// Consolidation is config-time (recipe returns `{consolidateTrigger,
-	// consolidate}` to spread BEFORE construction) — unlike decay, which is a
-	// post-construction self-add. Wire it iff a domain `summarize` was given.
-	const consolidationCfg = opts.consolidate ? consolidationRem<T>(opts.consolidate) : undefined;
-
-	const baseCfg = {
-		ingest,
-		extractDependencies,
-		...(consolidationCfg ?? {}),
-	};
-
-	const mem = opts.storage
-		? persistentReactiveFactStore<T>({
-				...baseCfg,
-				storage: opts.storage,
-				...(opts.persistName !== undefined ? { persistName: opts.persistName } : {}),
-				...(opts.codec !== undefined ? { codec: opts.codec } : {}),
-			})
-		: reactiveFactStore<T>(baseCfg);
-
-	// Q4: decay ON by default (generic; needs no domain knowledge).
-	if (opts.decay !== false) {
-		const d = opts.decay ?? {};
-		// EC-LOW-2 (/qa 2026-05-17): spread-then-default forwards ANY future
-		// `DecayExponentialOptions` field automatically (the prior key-by-key
-		// enumeration would silently drop a newly-added recipe knob). `d` is
-		// `Partial<DecayExponentialOptions>`; under `exactOptionalPropertyTypes`
-		// a present-but-`undefined` optional is rejected at the *caller's* site,
-		// so `...d` only ever carries defined values or absent keys — the two
-		// required fields are explicitly defaulted after the spread.
-		decayExponential<T>(mem, ingest, {
-			...d,
-			halfLifeNs: d.halfLifeNs ?? DEFAULT_DECAY_HALF_LIFE_NS,
-			periodMs: d.periodMs ?? DEFAULT_DECAY_PERIOD_MS,
-		});
-	}
-
-	const remember = (id: FactId, payload: T, ro?: RememberOptions): void => {
-		// Q5: minimal input → full MemoryFragment. `t_ns` MUST `BigInt`-wrap
-		// `monotonicNs()` (it returns `number`; the wrap is load-bearing per
-		// the clock-return-type rule + the `MemoryFragment.t_ns` contract).
-		const fragment: MemoryFragment<T> = {
-			id,
-			payload,
-			t_ns: BigInt(monotonicNs()),
-			confidence: ro?.confidence ?? 1,
-			tags: ro?.tags ?? [],
-			sources: ro?.sources ?? [],
-			...(ro?.validTo !== undefined ? { validTo: ro.validTo } : {}),
-			...(ro?.validFrom !== undefined ? { validFrom: ro.validFrom } : {}),
-			...(ro?.provenance !== undefined ? { provenance: ro.provenance } : {}),
-		};
-		ingest.emit(fragment);
-	};
-
-	// Augment the constructed graph in place (it IS the returned product;
-	// `remember` is the only addition over the wrapped factory's surface).
-	const out = mem as ReactiveFactStoreGraph<T> & {
-		remember: SimpleFactStoreGraph<T>["remember"];
-	};
-	out.remember = remember;
-	return out;
-}
diff --git a/src/utils/messaging/audit-records.ts b/src/utils/messaging/audit-records.ts
deleted file mode 100644
index f2c45605..00000000
--- a/src/utils/messaging/audit-records.ts
+++ /dev/null
@@ -1,160 +0,0 @@
-/**
- * Messaging audit-record schemas (DS-13.5.E, locked 2026-05-01 alt A).
- *
- * Per-site discriminated-union audit records for the four messaging mutation
- * sites that route through `mutate`:
- *
- * - {@link TopicPublishRecord} — `Topic.publish`
- * - {@link SubscriptionAckRecord} — `Subscription.ack`
- * - {@link SubscriptionPullAndAckRecord} — `Subscription.pullAndAck`
- * - {@link HubRemoveTopicRecord} — `Hub.removeTopic`
- *
- * **Opt-in usage.** None of the four mutation sites enable an audit log by
- * default — caller wires audit visibility by composing `mutate` with
- * an audit `ReactiveLogBundle<R>` of the matching record type and an
- * `onSuccess`/`onFailure` builder:
- *
- * ```ts
- * import {
- *   createAuditLog,
- *   mutate,
- *   type TopicPublishRecord,
- *   topicPublishKeyOf,
- * } from "@graphrefly/graphrefly";
- *
- * const audit = createAuditLog<TopicPublishRecord>({ name: "publishes" });
- * const publish = mutate(
- *   (item: MyMessage) => topic.publish(item),
- *   {
- *     frame: "inline",
- *     log: audit,
- *     onSuccessRecord: ([item], _r, m) => ({
- *       t_ns: m.t_ns,
- *       seq: m.seq,
- *       kind: "topic.publish",
- *       topicName: topic.name,
- *       itemKey: keyOf(item),
- *     }),
- *   },
- * );
- * ```
- *
- * **Stability.** The `kind` discriminator strings are pre-1.0 stable;
- * renaming downstream breaks external auditors.
- *
- * **Composability.** All four records extend {@link BaseAuditRecord} so they
- * carry the cross-cutting `t_ns` / `seq?` / `handlerVersion?` fields stamped
- * by `mutate` (Audit 2 / Audit 5).
- *
- * **Per-record keyOf.** Each record exports a recommended `keyOf` for
- * keyed-storage adapters (Rule G.27-keyOf-recommended) — partition the audit
- * log by the most natural identity (`topicName::itemKey`,
- * `subscriptionId::cursor`, etc.).
- *
- * **Hub.addTopic deferred.** No `HubAddTopicRecord` ships now; the lazy
- * topic-creation site has no caller signal asking for an audit record.
- * Re-add when a consumer surfaces.
- *
- * @category patterns
- * @module patterns/messaging/audit-records
- */
-
-import type { BaseAuditRecord } from "../../base/mutation/index.js";
-
-// ── Topic.publish ────────────────────────────────────────────────────────
-
-/**
- * Audit record for a single {@link TopicGraph.publish} call.
- *
- * - `topicName` — the topic the publish targeted.
- * - `itemKey` — caller-supplied identity for the published item (typically
- *   the result of the topic's own `keyOf` derivation, when one exists).
- */
-export interface TopicPublishRecord extends BaseAuditRecord {
-	readonly kind: "topic.publish";
-	readonly topicName: string;
-	readonly itemKey: string;
-}
-
-/**
- * Recommended `keyOf` for {@link TopicPublishRecord} — formats as
- * `${topicName}::${itemKey}` for keyed-storage partitioning. Caller may
- * override per Rule G.27-keyOf-recommended.
- */
-export const topicPublishKeyOf = (r: TopicPublishRecord): string => `${r.topicName}::${r.itemKey}`;
-
-// ── Subscription.ack ─────────────────────────────────────────────────────
-
-/**
- * Audit record for a single {@link SubscriptionGraph.ack} call.
- *
- * - `subscriptionId` — the subscription the ack advanced.
- * - `cursor` — the post-ack cursor position.
- */
-export interface SubscriptionAckRecord extends BaseAuditRecord {
-	readonly kind: "subscription.ack";
-	readonly subscriptionId: string;
-	readonly cursor: number;
-}
-
-/**
- * Recommended `keyOf` for {@link SubscriptionAckRecord} — formats as
- * `${subscriptionId}::${cursor}`.
- */
-export const subscriptionAckKeyOf = (r: SubscriptionAckRecord): string =>
-	`${r.subscriptionId}::${r.cursor}`;
-
-// ── Subscription.pullAndAck ──────────────────────────────────────────────
-
-/**
- * Audit record for a single {@link SubscriptionGraph.pullAndAck} call.
- *
- * - `subscriptionId` — the subscription the pullAndAck advanced.
- * - `cursor` — the post-pullAndAck cursor position.
- * - `itemCount` — number of items returned to the caller in this call.
- */
-export interface SubscriptionPullAndAckRecord extends BaseAuditRecord {
-	readonly kind: "subscription.pullAndAck";
-	readonly subscriptionId: string;
-	readonly cursor: number;
-	readonly itemCount: number;
-}
-
-/**
- * Recommended `keyOf` for {@link SubscriptionPullAndAckRecord} — formats as
- * `${subscriptionId}::${cursor}` (identical shape to ack records so the
- * combined audit-log partitioning matches a per-cursor-frame view).
- */
-export const subscriptionPullAndAckKeyOf = (r: SubscriptionPullAndAckRecord): string =>
-	`${r.subscriptionId}::${r.cursor}`;
-
-// ── Hub.removeTopic ──────────────────────────────────────────────────────
-
-/**
- * Audit record for a single {@link MessagingHubGraph.removeTopic} call.
- *
- * - `topicName` — the topic that was unmounted from the hub.
- */
-export interface HubRemoveTopicRecord extends BaseAuditRecord {
-	readonly kind: "hub.removeTopic";
-	readonly topicName: string;
-}
-
-/**
- * Recommended `keyOf` for {@link HubRemoveTopicRecord} — the topic name itself
- * is already the natural identity.
- */
-export const hubRemoveTopicKeyOf = (r: HubRemoveTopicRecord): string => r.topicName;
-
-// ── Discriminated-union convenience ──────────────────────────────────────
-
-/**
- * Discriminated union over every messaging audit record. Useful for callers
- * that aggregate records from multiple sites into one log; switch on
- * `record.kind` to narrow.
- */
-export type MessagingAuditRecord =
-	| TopicPublishRecord
-	| SubscriptionAckRecord
-	| SubscriptionPullAndAckRecord
-	| HubRemoveTopicRecord;
diff --git a/src/utils/messaging/index.ts b/src/utils/messaging/index.ts
deleted file mode 100644
index 4aa7999e..00000000
--- a/src/utils/messaging/index.ts
+++ /dev/null
@@ -1,1074 +0,0 @@
-/**
- * Messaging patterns (roadmap §4.2).
- *
- * Pulsar-inspired messaging primitives modeled as graph factories:
- * - `topic()` for append-only topic streams with a retained window.
- * - `subscription()` for cursor-based consumers.
- * - `topicBridge()` for autonomous topic-to-topic relay.
- * - `messagingHub()` for a lazy topic registry.
- *
- * Plus the Phase 13.B standard `Message<T>` envelope and well-known topic
- * name constants ({@link PROMPTS_TOPIC} / {@link RESPONSES_TOPIC} /
- * {@link INJECTIONS_TOPIC} / {@link DEFERRED_TOPIC} / {@link SPAWNS_TOPIC})
- * — recommended (not enforced) wire shape for cross-graph topic payloads.
- *
- * Job queue / job flow primitives live in `patterns/job-queue` — they are a
- * distinct domain that happens to share reactive-log / reactive-map
- * infrastructure with topics.
- */
-
-export {
-	type HubRemoveTopicRecord,
-	hubRemoveTopicKeyOf,
-	type MessagingAuditRecord,
-	type SubscriptionAckRecord,
-	type SubscriptionPullAndAckRecord,
-	subscriptionAckKeyOf,
-	subscriptionPullAndAckKeyOf,
-	type TopicPublishRecord,
-	topicPublishKeyOf,
-} from "./audit-records.js";
-export {
-	CONTEXT_TOPIC,
-	DEFERRED_TOPIC,
-	INJECTIONS_TOPIC,
-	type JsonSchema,
-	PROMPTS_TOPIC,
-	RESPONSES_TOPIC,
-	SPAWNS_TOPIC,
-	STANDARD_TOPICS,
-	type StandardTopic,
-	TODOS_TOPIC,
-	type TopicMessage,
-} from "./message.js";
-
-import { batch, COMPLETE, type Node, node } from "@graphrefly/pure-ts/core";
-import { keepalive, type ReactiveLogBundle, reactiveLog } from "@graphrefly/pure-ts/extra";
-import { Graph, type GraphOptions } from "@graphrefly/pure-ts/graph";
-import { attachEdgeMeta } from "../../base/meta/attach-edge-meta.js";
-import { domainMeta } from "../../base/meta/domain-meta.js";
-import { mutate } from "../../base/mutation/index.js";
-
-const DEFAULT_MAX_PER_PUMP = 256;
-
-function requireNonNegativeInt(value: number, label: string): number {
-	if (!Number.isFinite(value) || !Number.isInteger(value) || value < 0) {
-		throw new Error(`${label} must be a non-negative integer`);
-	}
-	return value;
-}
-
-function messagingMeta(kind: string, extra?: Record<string, unknown>): Record<string, unknown> {
-	return domainMeta("messaging", kind, extra);
-}
-
-export type TopicOptions = {
-	graph?: GraphOptions;
-	/** Bounded retention; default 1024 per cross-cutting policy (Audit 2/4). */
-	retainedLimit?: number;
-};
-
-const DEFAULT_TOPIC_RETAINED_LIMIT = 1024;
-
-export class TopicGraph<T> extends Graph {
-	private readonly _log;
-	private readonly _publishImpl: (value: T) => void;
-	readonly events: Node<readonly T[]>;
-	/**
-	 * Most recently published value. Stays in the protocol SENTINEL state
-	 * (`cache === undefined`, no DATA emitted) until the first publish, then
-	 * tracks the latest entry. Spec §5.12 reserves `undefined` as the
-	 * "never sent DATA" sentinel — and `TopicGraph.publish(undefined)` is
-	 * rejected — so `cache === undefined` unambiguously signals "empty topic"
-	 * even when `T` itself includes `null` (i.e., `topic<number | null>`).
-	 *
-	 * **Within a reactive fn:** detect the empty-topic case via
-	 * `ctx.prevData[i] === undefined` for the dep slot holding `topic.latest`,
-	 * or check `latest.cache === undefined` outside reactive code. No
-	 * separate `hasLatest` companion needed — the SENTINEL is the answer.
-	 */
-	readonly latest: Node<T>;
-
-	constructor(name: string, opts: TopicOptions = {}) {
-		super(name, opts.graph);
-		this._log = reactiveLog<T>([], {
-			name: "events",
-			maxSize: opts.retainedLimit ?? DEFAULT_TOPIC_RETAINED_LIMIT,
-		});
-		this.events = this._log.entries;
-		this.add(this.events, { name: "events" });
-		// `this.derived("latest", ["events"], …)` is expressible after the
-		// 2026-04-30 self-resolve fix in `Graph._resolveFromSegments` — a
-		// single-segment path matching the graph's own name (e.g.
-		// `topic("events").resolve("events")`) no longer collapses to empty
-		// and falls through to local-node lookup. Replaces the prior
-		// `node([events], …) + this.add(...)` workaround.
-		//
-		// SENTINEL on empty: returning `[]` here yields a RESOLVED-only wave
-		// (no DATA), so `latest.cache` stays `undefined` until the first
-		// publish. `TopicGraph.publish(undefined)` is rejected (line below),
-		// so `undefined` cache is unambiguously "empty topic" even when `T`
-		// itself includes `null`. Drops the prior `hasLatest` companion as
-		// redundant.
-		this.latest = this.derived<T>(
-			"latest",
-			["events"],
-			(batchData, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				const entries = data[0] as readonly T[];
-				return entries.length === 0 ? [] : [entries[entries.length - 1] as T];
-			},
-			{ meta: messagingMeta("topic_latest") },
-		);
-		this.addDisposer(keepalive(this.latest));
-
-		// D1(a): on teardown, propagate COMPLETE on `events` so downstream
-		// derived chains (including any externally-held SubscriptionGraph
-		// sources) see the termination via their `terminalDeps` and can stop
-		// serving stale caches. Tier-3 terminal per spec §2.2.
-		//
-		// EC16 (verified 2026-04-30): the COMPLETE-then-disposeAllViews order
-		// is intentional. COMPLETE propagates SYNCHRONOUSLY through every
-		// subscriber (cursor views, derived chains) so they self-unsubscribe
-		// in their terminal handler before `disposeAllViews` runs. Swapping
-		// the order would clear view caches before subscribers receive the
-		// terminal — strictly worse. Reading `.cache` outside a reactive fn
-		// across teardown is an anti-pattern (spec §5.12) and not a use case
-		// this ordering needs to preserve.
-		this.addDisposer(() => {
-			this.events.down([[COMPLETE]]);
-		});
-		// P9: release any memoized tail/slice view keepalives held by the log.
-		// TopicGraph itself doesn't call log.tail/slice, but plugins may have
-		// attached views via `_log` — defensive (typical reactive subscribers
-		// have already unsubscribed in their COMPLETE handler above).
-		this.addDisposer(() => this._log.disposeAllViews());
-
-		// Tier 8 / COMPOSITION-GUIDE §35: route publish through `mutate`
-		// for centralized freeze + re-throw semantics. No audit log surface
-		// (per Tier 8 γ-0): the topic's `events` log already records every
-		// successful publish, so a separate audit Node would be redundant.
-		// `freeze: false` because topic payloads can be large and per-publish
-		// cost matters on hot paths.
-		this._publishImpl = mutate<[T], void, never>(
-			(value): void => {
-				this._log.append(value);
-			},
-			{ frame: "inline", freeze: false },
-		);
-	}
-
-	publish(value: T): void {
-		// SENTINEL alignment (Wave B.1 Unit 11 lock): `undefined` is the
-		// protocol-level "never sent DATA" sentinel — refusing it here
-		// preserves `lastValue: Node<T | undefined>` semantics.
-		if (value === undefined) {
-			throw new TypeError(
-				`TopicGraph "${this.name}": publish(undefined) is not allowed (spec §5.12 SENTINEL).`,
-			);
-		}
-		this._publishImpl(value);
-	}
-
-	/**
-	 * Wire one or more append-log storage tiers (Audit 4). Each tier receives
-	 * appended events per wave; rollback honors the wave-as-transaction model.
-	 *
-	 * Named `attachEventStorage` (not `attachStorage`) to avoid colliding with
-	 * the inherited {@link Graph.attachSnapshotStorage} which takes the
-	 * paired `AttachSnapshotTierPair[]` shape (Phase 14.6) — distinct
-	 * concerns, distinct surfaces.
-	 *
-	 * @returns Disposer.
-	 */
-	attachEventStorage(
-		tiers: readonly import("@graphrefly/pure-ts/extra").AppendLogStorageTier<T>[],
-	): () => void {
-		return this._log.attachStorage(tiers);
-	}
-
-	retained(): readonly T[] {
-		return this.events.cache as readonly T[];
-	}
-
-	/** Internal log bundle — used by TopicBridgeGraph for `attach`. */
-	get _logBundle() {
-		return this._log;
-	}
-}
-
-export type SubscriptionOptions = {
-	graph?: GraphOptions;
-	/**
-	 * Starting cursor position.
-	 * @deprecated Use `from` instead.
-	 */
-	cursor?: number;
-	/**
-	 * Starting position for the subscription.
-	 * - `"retained"` (default) — cursor starts at 0; consumer sees all retained history.
-	 * - `"now"` — cursor starts at current topic length; consumer ignores history.
-	 * - `number` — explicit cursor position.
-	 */
-	from?: "now" | "retained" | number;
-	/**
-	 * When this signal node emits DATA, the subscription auto-advances cursor
-	 * to current `available.length`. Useful for "ack everything when X happens"
-	 * patterns. The reactive edge `advanceOn → cursor` is visible in `explain()`.
-	 */
-	advanceOn?: Node<unknown>;
-};
-
-/** Result of {@link SubscriptionGraph.pullAndAck}. */
-export type PullAndAckResult<T> = {
-	items: readonly T[];
-	cursor: number;
-};
-
-export class SubscriptionGraph<T> extends Graph {
-	readonly cursor: Node<number>;
-	readonly available: Node<readonly T[]>;
-	/**
-	 * Reference to the upstream topic graph. Intentionally NOT mounted
-	 * under this subscription: a subscription is a VIEW over an
-	 * externally-owned topic. Double-mounting (e.g. hub-owned topic +
-	 * sub-mount here) would make either-side teardown leave the other
-	 * holding a dead reference. Node-level `derived([topicEvents], …)`
-	 * still wires the data dependency across graph boundaries. D1(e).
-	 */
-	readonly topic: TopicGraph<T>;
-
-	private _disposed = false;
-	private readonly _ackImpl: (count: number | undefined) => number;
-	private readonly _pullAndAckImpl: (limit: number | undefined) => PullAndAckResult<T>;
-
-	constructor(name: string, topicGraph: TopicGraph<T>, opts: SubscriptionOptions = {}) {
-		super(name, opts.graph);
-		this.topic = topicGraph;
-
-		// Resolve initial cursor from `from` option, falling back to legacy `cursor` option.
-		let initialCursor: number;
-		if (opts.from !== undefined) {
-			if (opts.from === "retained") {
-				initialCursor = 0;
-			} else if (opts.from === "now") {
-				// §28 sanctioned factory-time boundary read.
-				initialCursor = (topicGraph.events.cache as readonly T[]).length;
-			} else {
-				initialCursor = requireNonNegativeInt(opts.from, "subscription from");
-			}
-		} else {
-			initialCursor = requireNonNegativeInt(opts.cursor ?? 0, "subscription cursor");
-		}
-
-		this.cursor = this.state<number>("cursor", initialCursor, {
-			meta: messagingMeta("subscription_cursor"),
-		});
-
-		// B.1 Unit 12 lock: `available` depends directly on topic.events + cursor
-		// via `view({ kind: "fromCursor" })`. No `source` passthrough node —
-		// describe shows `topic::events → available` (cross-graph edge) and
-		// `cursor → available` (local edge). One fewer node per subscription.
-		this.available = topicGraph._logBundle.view({ kind: "fromCursor", cursor: this.cursor });
-		this.add(this.available, { name: "available" });
-		this.addDisposer(keepalive(this.available));
-
-		// Optional reactive auto-advance: when `advanceOn` emits a NEW DATA
-		// (after construction), cursor advances by `available.length` atomically.
-		// Edge visible in describe: advancePump depends on advanceOn.
-		// `_advanceInitialized` guards against the initial push-on-subscribe fire
-		// that would advance cursor before the user has a chance to read.
-		if (opts.advanceOn !== undefined) {
-			const advanceOn = opts.advanceOn;
-			let advanceInitialized = false;
-			const advancePump = node<unknown>(
-				[advanceOn],
-				() => {
-					// Skip the initial push-on-subscribe wave.
-					if (!advanceInitialized) {
-						advanceInitialized = true;
-						return;
-					}
-					if (this._disposed) return;
-					const avail = this.available.cache as readonly T[];
-					if (avail.length === 0) return;
-					const next = (this.cursor.cache as number) + avail.length;
-					this.cursor.emit(next);
-				},
-				{
-					name: "advancePump",
-					describeKind: "effect",
-					meta: messagingMeta("subscription_advance_pump"),
-				},
-			);
-			this.add(advancePump, { name: "advancePump" });
-			this.addDisposer(keepalive(advancePump));
-		}
-
-		// Tier 8 / COMPOSITION-GUIDE §35: route ack + pullAndAck through
-		// `mutate` for centralized freeze + re-throw semantics. No audit
-		// log surface (per Tier 8 γ-0): the cursor's own emission stream already
-		// records every advance, so a separate audit Node would be redundant.
-		// `freeze: false` because count/limit are simple numbers; freezing is
-		// pointless overhead. Disposed-checks stay outside the wrapper so a
-		// no-op call doesn't unnecessarily run the wrapper.
-		this._ackImpl = mutate<[number | undefined], number, never>(
-			(count): number => {
-				const available = this.available.cache as readonly T[];
-				const requested =
-					count === undefined
-						? available.length
-						: requireNonNegativeInt(count, "subscription ack count");
-				const step = Math.min(requested, available.length);
-				if (step <= 0) return this.cursor.cache as number;
-				const next = (this.cursor.cache as number) + step;
-				// F8: use emit() so the pipeline auto-prefixes DIRTY, runs equals
-				// substitution, and produces a proper two-phase wave (the raw
-				// `down([[DATA, next]])` path bypassed those contracts).
-				this.cursor.emit(next);
-				return next;
-			},
-			{ frame: "inline", freeze: false },
-		);
-
-		this._pullAndAckImpl = mutate<[number | undefined], PullAndAckResult<T>, never>(
-			(limit): PullAndAckResult<T> => {
-				const available = this.available.cache as readonly T[];
-				const max =
-					limit === undefined
-						? available.length
-						: requireNonNegativeInt(limit, "subscription pullAndAck limit");
-				const items = available.slice(0, max);
-				if (items.length === 0) return { items, cursor: this.cursor.cache as number };
-				const next = (this.cursor.cache as number) + items.length;
-				this.cursor.emit(next);
-				return { items, cursor: next };
-			},
-			{ frame: "inline", freeze: false },
-		);
-	}
-
-	ack(count?: number): number {
-		if (this._disposed) return this.cursor.cache as number;
-		return this._ackImpl(count);
-	}
-
-	pull(limit?: number): readonly T[] {
-		if (this._disposed) return [];
-		const available = this.available.cache as readonly T[];
-		const max =
-			limit === undefined
-				? available.length
-				: requireNonNegativeInt(limit, "subscription pull limit");
-		return available.slice(0, max);
-	}
-
-	/**
-	 * Atomic pull-and-acknowledge. Returns `{ items, cursor }` where `cursor`
-	 * is the new cursor position after advancing. Under single-threaded JS the
-	 * snapshot and advance are atomic; PY callers use a per-subscription Lock.
-	 *
-	 * Replaces `pull(limit, { ack: true })`.
-	 */
-	pullAndAck(limit?: number): PullAndAckResult<T> {
-		if (this._disposed) return { items: [], cursor: this.cursor.cache as number };
-		return this._pullAndAckImpl(limit);
-	}
-
-	/**
-	 * Release internal subscriptions and mark the subscription torn-down.
-	 * Subsequent `pull`, `pullAndAck`, `ack` return empty / current cursor.
-	 * Emits COMPLETE on `cursor` so derived consumers (e.g. `available`) see
-	 * the termination signal. Also drains `addDisposer` callbacks (including
-	 * the `keepalive(advancePump)` subscription) so no keepalive leak occurs.
-	 */
-	dispose(): void {
-		if (this._disposed) return;
-		this._disposed = true;
-		this.cursor.down([[COMPLETE]]);
-		// m4: drain addDisposer callbacks to release the keepalive subscription.
-		this.destroy();
-	}
-}
-
-export type TopicBridgeOptions<TIn, TOut> = {
-	graph?: GraphOptions;
-	cursor?: number;
-	maxPerPump?: number;
-	/**
-	 * Optional transform/filter applied to each item before republishing.
-	 *
-	 * **At-most-once with silent drop:** when `map` returns `undefined`, the
-	 * input is consumed from the source cursor but NOT republished. Filtered
-	 * items are not retained for retry. If you need filter-with-retry
-	 * semantics, do the filtering in a downstream subscription on the bridged
-	 * output rather than in the `map` function.
-	 */
-	map?: (value: TIn) => TOut | undefined;
-};
-
-export class TopicBridgeGraph<TIn, TOut = TIn> extends Graph {
-	private readonly _sourceSub;
-	readonly bridgedCount: Node<number>;
-	/**
-	 * Emits each mapped batch as DATA — gives downstream observers a reactive
-	 * stream of bridged values. Also the link target for `target._log.attach`.
-	 */
-	readonly output: Node<readonly TOut[]>;
-
-	constructor(
-		name: string,
-		sourceTopic: TopicGraph<TIn>,
-		targetTopic: TopicGraph<TOut>,
-		opts: TopicBridgeOptions<TIn, TOut> = {},
-	) {
-		super(name, opts.graph);
-		this._sourceSub = subscription<TIn>(`${name}-subscription`, sourceTopic, {
-			cursor: opts.cursor,
-		});
-		this.mount("subscription", this._sourceSub);
-
-		const maxPerPump = Math.max(
-			1,
-			requireNonNegativeInt(opts.maxPerPump ?? DEFAULT_MAX_PER_PUMP, "topic bridge maxPerPump"),
-		);
-		const mapValue = opts.map ?? ((value: TIn) => value as unknown as TOut);
-
-		// Reactive output node: derives a mapped batch from `available`.
-		// §24 compliant — output is a real derived edge, visible in describe.
-		// Replaces imperative publish loop. Items where mapValue returns undefined
-		// are filtered out (opt-out / filter).
-		this.output = node<readonly TOut[]>(
-			[this._sourceSub.available],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				const arr = data[0] as readonly TIn[];
-				const outBatch: TOut[] = [];
-				const take = Math.min(arr.length, maxPerPump);
-				for (let i = 0; i < take; i++) {
-					const mapped = mapValue(arr[i] as TIn);
-					if (mapped !== undefined) outBatch.push(mapped);
-				}
-				actions.emit(outBatch);
-			},
-			{
-				name: "output",
-				describeKind: "derived",
-				meta: messagingMeta("topic_bridge_output", { targetRef: targetTopic.name }),
-				initial: [],
-			},
-		);
-		this.add(this.output, { name: "output" });
-		this.addDisposer(keepalive(this.output));
-
-		// bridgedCount: state node accumulating total bridged items.
-		// Updated by ackPump after each batch — edge visible via ackPump dep on output.
-		this.bridgedCount = this.state<number>("bridgedCount", 0, {
-			meta: messagingMeta("topic_bridge_count"),
-		});
-		this.addDisposer(keepalive(this.bridgedCount));
-
-		// ackPump: effect that advances the subscription cursor and updates
-		// bridgedCount after each batch. Runs after `output` settles.
-		// Captures refs to `this.output`, `this._sourceSub`, `this.bridgedCount`
-		// to avoid `this` inside the fn body.
-		const outputRef = this.output;
-		const subRef = this._sourceSub;
-		const countRef = this.bridgedCount;
-		const ackPump = this.effect(
-			"ackPump",
-			["output"],
-			() => {
-				const outBatch = outputRef.cache as readonly TOut[];
-				if (outBatch.length === 0) return;
-				const availLen = (subRef.available.cache as readonly TIn[]).length;
-				const toAck = Math.min(availLen, maxPerPump);
-				if (toAck > 0) {
-					subRef.ack(toAck);
-					const prev = (countRef.cache as number) ?? 0;
-					countRef.emit(prev + outBatch.length);
-				}
-			},
-			{
-				meta: messagingMeta("topic_bridge_ack_pump"),
-			},
-		);
-		this.addDisposer(keepalive(ackPump));
-
-		// Wire `output` into the target topic's events log via a declared
-		// effect mount. The effect's dep on `output` is the protocol-level
-		// edge; the soft forward edge `attach → targetTopic.events` is
-		// declared in `meta.attachTarget` and surfaces in `Graph.describe()`
-		// + `explainPath()`. Wave propagation does NOT follow the soft edge
-		// — the wave flows because `targetTopic.publish(v)` synchronously
-		// emits into the target's events node (sanctioned imperative escape
-		// per spec §5.9). Equivalent in behavior to the prior `_attachArray
-		// ToLog` helper, but now visible to inspection tooling (mirrors
-		// `ackPump`'s declared-effect shape; Phase 13.K resolution).
-		const attach = this.effect(
-			"attach",
-			["output"],
-			() => {
-				const outBatch = outputRef.cache as readonly TOut[];
-				if (outBatch.length === 0) return;
-				batch(() => {
-					for (const v of outBatch) targetTopic.publish(v);
-				});
-			},
-			{
-				meta: {
-					...messagingMeta("topic_bridge_attach"),
-					...attachEdgeMeta(targetTopic.events),
-				},
-			},
-		);
-		this.addDisposer(keepalive(attach));
-	}
-}
-
-// ── TopicRegistry ─────────────────────────────────────────────────────────
-
-/**
- * Private pure data structure managing a named set of {@link TopicGraph}
- * instances. Extracted from {@link MessagingHubGraph} for separation of
- * concerns (B.2 Unit 14 lock: D — split into TopicRegistry + facade).
- *
- * Reusable if other domain consumers (e.g. cqrs.eventLogs) want a shared
- * topic registry later.
- *
- * @internal
- */
-export class TopicRegistry {
-	private readonly _map = new Map<string, TopicGraph<unknown>>();
-	/** Reactive monotonic version counter. Advances on topic create/remove. */
-	readonly version: Node<number>;
-
-	constructor(versionNode: Node<number>) {
-		this.version = versionNode;
-	}
-
-	get size(): number {
-		return this._map.size;
-	}
-
-	has(name: string): boolean {
-		return this._map.has(name);
-	}
-
-	get<T>(name: string): TopicGraph<T> | undefined {
-		return this._map.get(name) as TopicGraph<T> | undefined;
-	}
-
-	set<T>(name: string, t: TopicGraph<T>): void {
-		this._map.set(name, t as TopicGraph<unknown>);
-	}
-
-	delete(name: string): boolean {
-		return this._map.delete(name);
-	}
-
-	keys(): IterableIterator<string> {
-		return this._map.keys();
-	}
-}
-
-// ── MessagingHubGraph ─────────────────────────────────────────────────────
-
-export type MessagingHubOptions = {
-	graph?: GraphOptions;
-	/**
-	 * Default `TopicOptions` applied to every topic created via `topic(name)`
-	 * without explicit options. Per-call opts override. Default: `{}`
-	 * (unbounded retention per topic unless `retainedLimit` is set per call).
-	 */
-	defaultTopicOptions?: TopicOptions;
-};
-
-/**
- * Lazy Pulsar-inspired topic registry. Manages a named set of {@link TopicGraph}
- * instances with retention + cursor semantics. Topics are created on first
- * access; `removeTopic(name)` unmounts and tears down via {@link Graph.remove}.
- *
- * Internally delegates to {@link TopicRegistry} for topic map management
- * (B.2 Unit 14 lock: D facade split).
- *
- * **Relationship to `pubsub()` in `src/extra/pubsub.ts`:** `pubsub` is a
- * lightweight last-value state hub (no retention, no cursors). `MessagingHubGraph`
- * is the full messaging hub — retained message logs, cursor-based subscriptions,
- * and pattern-layer lifecycle management.
- *
- * @category patterns
- */
-export class MessagingHubGraph extends Graph {
-	private readonly _registry: TopicRegistry;
-	/** Reactive monotonic version counter — advances on topic create/remove. */
-	readonly version: Node<number>;
-	private readonly _defaultTopicOptions: TopicOptions;
-	private readonly _removeTopicImpl: (name: string) => void;
-
-	constructor(name: string, opts: MessagingHubOptions = {}) {
-		super(name, opts.graph);
-		// B.2 Unit 14 lock: promote _version → version: Node<number>.
-		const versionNode = this.state<number>("version", 0, {
-			meta: messagingMeta("hub_version"),
-		});
-		this.version = versionNode;
-		this._registry = new TopicRegistry(versionNode);
-		// P8: shallow-copy caller-provided defaults so post-construction
-		// mutations by the caller don't leak into every future `topic()` call.
-		this._defaultTopicOptions = { ...(opts.defaultTopicOptions ?? {}) };
-
-		// Tier 8 / COMPOSITION-GUIDE §35: route the registry-delete branch of
-		// `removeTopic` through `mutate` for centralized re-throw
-		// semantics. No audit log surface (per Tier 8 γ-0).
-		// `freeze: false` because the only arg is a string name (freeze pointless).
-		// **Closure-state caveat (γ-4):** the inner `try/finally` mutates
-		// `_registry` (a `Map`) and emits the version bump. mutate has no
-		// `batch()` frame, so reactive emissions are NOT rolled back on throw —
-		// and even if it did, `Map.delete` on closure state is invisible to the
-		// batch and can't be unwound. The pre-existing try/finally on
-		// `Graph.remove` is what guarantees registry/version converge to a
-		// consistent state when `remove()` throws; `mutate` adds nothing
-		// to that contract beyond the re-throw.
-		this._removeTopicImpl = mutate<[string], void, never>(
-			(topicName): void => {
-				try {
-					this.remove(topicName); // unmounts, drops edges, tears down
-				} finally {
-					this._registry.delete(topicName);
-					const cur = (this.version.cache as number) ?? 0;
-					this.version.emit(cur + 1);
-				}
-			},
-			{ frame: "inline", freeze: false },
-		);
-	}
-
-	/** Number of topics currently in the hub. */
-	get size(): number {
-		return this._registry.size;
-	}
-
-	/** Checks topic existence without creating. */
-	has(name: string): boolean {
-		return this._registry.has(name);
-	}
-
-	/** Iterator over topic names. */
-	topicNames(): IterableIterator<string> {
-		return this._registry.keys();
-	}
-
-	/**
-	 * Returns the {@link TopicGraph} for `name`, creating lazily on first call.
-	 * Subsequent calls with the same name return the same instance (options on
-	 * repeat calls are ignored — the topic is already configured).
-	 */
-	topic<T = unknown>(name: string, opts?: TopicOptions): TopicGraph<T> {
-		let t = this._registry.get<T>(name);
-		if (t === undefined) {
-			const effective: TopicOptions = { ...this._defaultTopicOptions, ...(opts ?? {}) };
-			t = new TopicGraph<T>(name, effective);
-			this._registry.set(name, t);
-			this.mount(name, t);
-			const cur = (this.version.cache as number) ?? 0;
-			this.version.emit(cur + 1);
-		}
-		return t;
-	}
-
-	/**
-	 * Publishes a value to the topic, lazily creating it on first publish.
-	 *
-	 * **Late-subscriber caveat:** the topic is created lazily, so subscribers
-	 * that attach AFTER a publish only see the retained window (governed by
-	 * `retainedLimit` on `TopicOptions` / `defaultTopicOptions`). If
-	 * `retainedLimit === 0` is set explicitly, early publishes are
-	 * effectively dropped — prefer an unset `retainedLimit` (unbounded
-	 * retention) or subscribe before publishing when late-subscribers matter.
-	 */
-	publish<T = unknown>(name: string, value: T): void {
-		this.topic<T>(name).publish(value);
-	}
-
-	/**
-	 * Bulk publish — issues all publishes inside one outer batch. New topics
-	 * are created on demand. No-op if `entries` yields nothing.
-	 *
-	 * **Iterable consumption (F6):** `entries` is consumed once (single-pass)
-	 * INSIDE the batch frame. If the iterator throws mid-way, the batch is
-	 * discarded and NO publishes are visible to subscribers (all-or-nothing).
-	 * Pass an array or `Set` for multi-shot callers.
-	 */
-	publishMany(entries: Iterable<[string, unknown]>): void {
-		// P2: iterate inside batch — no `[...entries]` materialization so large
-		// / infinite iterables don't OOM, and iterator throws are contained.
-		batch(() => {
-			for (const [name, value] of entries) {
-				this.topic(name).publish(value);
-			}
-		});
-	}
-
-	/**
-	 * Creates a {@link SubscriptionGraph} over a named topic. The topic is
-	 * lazily created if missing. Subscription lifecycle is owned by the caller —
-	 * the hub does NOT mount the subscription.
-	 *
-	 * @param subName - Local name for the subscription graph.
-	 * @param topicName - Hub topic to subscribe to.
-	 * @param opts - `SubscriptionOptions` (initial cursor, etc.).
-	 */
-	subscribe<T = unknown>(
-		subName: string,
-		topicName: string,
-		opts?: SubscriptionOptions,
-	): SubscriptionGraph<T> {
-		const t = this.topic<T>(topicName);
-		return new SubscriptionGraph<T>(subName, t, opts);
-	}
-
-	/**
-	 * Unmounts and tears down the topic's graph. Returns `true` if the topic
-	 * existed. Subscribers receive `TEARDOWN` via {@link Graph.remove}.
-	 *
-	 * **Closure-state caveat:** the registry mutation (`_registry.delete`) and
-	 * version bump happen in a `try/finally`, so registry/version converge to
-	 * a consistent state even when {@link Graph.remove} throws. `mutate`
-	 * does not roll back this mutation on throw — `Map.delete` on closure
-	 * state is invisible to any batch frame. The pre-existing try/finally is
-	 * load-bearing for that invariant.
-	 */
-	removeTopic(name: string): boolean {
-		if (!this._registry.has(name)) return false;
-		// P1 / P3: Graph.remove first — if it throws, `_registry` must NOT still
-		// hold the broken half-disposed topic (otherwise the next
-		// `hub.topic(name)` returns the corrupted reference). The `try/finally`
-		// inside `_removeTopicImpl`'s action body preserves that invariant.
-		this._removeTopicImpl(name);
-		return true;
-	}
-}
-
-/**
- * Creates a Pulsar-inspired topic graph (append-only retained stream + latest value).
- */
-export function topic<T>(name: string, opts?: TopicOptions): TopicGraph<T> {
-	return new TopicGraph<T>(name, opts);
-}
-
-/**
- * Creates a lazy Pulsar-inspired messaging hub. Topics are created on first access
- * via `hub.topic(name)`; `hub.publish(name, value)` shortcuts through the registry.
- *
- * @example
- * ```ts
- * import { messagingHub } from "@graphrefly/graphrefly";
- *
- * const hub = messagingHub("main", { defaultTopicOptions: { retainedLimit: 256 } });
- * hub.publish("orders", { id: 1 });
- * hub.publishMany([["shipments", { id: 1 }], ["orders", { id: 2 }]]);
- * const sub = hub.subscribe("orders-worker", "orders", { cursor: 0 });
- * ```
- */
-export function messagingHub(name: string, opts?: MessagingHubOptions): MessagingHubGraph {
-	return new MessagingHubGraph(name, opts);
-}
-
-/**
- * Creates a cursor-based subscription graph over a topic.
- */
-export function subscription<T>(
-	name: string,
-	topicGraph: TopicGraph<T>,
-	opts?: SubscriptionOptions,
-): SubscriptionGraph<T> {
-	return new SubscriptionGraph<T>(name, topicGraph, opts);
-}
-
-/**
- * Creates an autonomous cursor-based topic relay graph.
- *
- * When `opts.map` is provided, items where `map` returns `undefined` are
- * consumed from the source cursor but NOT republished (at-most-once with
- * silent drop). For filter-with-retry semantics, apply the filter in a
- * downstream subscription on the bridge's `output` node instead.
- */
-export function topicBridge<TIn, TOut = TIn>(
-	name: string,
-	sourceTopic: TopicGraph<TIn>,
-	targetTopic: TopicGraph<TOut>,
-	opts?: TopicBridgeOptions<TIn, TOut>,
-): TopicBridgeGraph<TIn, TOut> {
-	return new TopicBridgeGraph<TIn, TOut>(name, sourceTopic, targetTopic, opts);
-}
-
-// ── LogProjector ──────────────────────────────────────────────────────────
-//
-// Promotion 2 (memo:Re Story 6.4 back-derivation, design-review-locked
-// 2026-05-16). A cursor-driven projector over a log/topic where a per-item
-// sink can poison-fail. memo:Re hand-rolled `createProjectorCursor` and got
-// the failure mode wrong: a bare `catch { break; }` conflated a *transient*
-// condition (a native feature not yet available → retry later) with a
-// *poison* entry (will never project) → a permanent head-of-line block of
-// every newer entry. The fix is a real, observable, subscribable dead-letter
-// topic + a typed failure policy.
-//
-// Built ON `subscription()` (TopicGraph source) / the bundle's `fromCursor`
-// view (ReactiveLogBundle source) — the same hardened cursor machinery
-// `SubscriptionGraph` itself uses — so the consumer never hand-rolls cursor
-// persistence/durability (the Med "durability skew" + parse-leniency findings
-// dissolve). Scope is deliberately bounded: `halt | deadLetter` only, NO
-// programmatic retry/backoff (compose a downstream subscription on
-// `deadLetter` for that — avoids the §44 wrap-imperative-as-primitive trap).
-
-export type ProjectorPoisonPolicy = "halt" | "deadLetter";
-
-/** A poison entry routed to {@link LogProjectorGraph.deadLetter}. */
-export type DeadLetterEntry<T> = {
-	readonly item: T;
-	/** `Error.message` (or `String(thrown)`) from the failing `sink`. */
-	readonly error: string;
-	/** Absolute 0-based log position of the poisoned item. */
-	readonly cursorPos: number;
-};
-
-export type LogProjectorOptions<T> = {
-	graph?: GraphOptions;
-	/**
-	 * Per-item side-effecting projection.
-	 *
-	 * **Transient-vs-poison contract (read this).** The projector cannot tell
-	 * "this will project later" from "this will never project" — only the sink
-	 * knows. So the contract is:
-	 * - **Return normally** (sync return, or a resolved Promise) → the item is
-	 *   *handled*; the cursor advances. Use this for the success path AND for
-	 *   any transient/skip condition the sink wants to no-op (e.g. an optional
-	 *   native feature not yet available — return without throwing; the entry
-	 *   is simply considered done for this projector).
-	 * - **Throw / reject** → the item is *poison*; the {@link onPoison} policy
-	 *   applies. Do NOT throw for transient conditions or the item is
-	 *   dead-lettered (or halts the stream).
-	 */
-	readonly sink: (item: T) => void | Promise<void>;
-	/**
-	 * Behaviour when `sink` throws/rejects on an item (poison):
-	 * - `"halt"` (default) — stop projecting at the poison item; the cursor
-	 *   does NOT advance past it (head-of-line stop). `position` stalls — that
-	 *   is the observable signal. No retry/backoff is built in.
-	 * - `"deadLetter"` — publish `{ item, error, cursorPos }` to the
-	 *   {@link LogProjectorGraph.deadLetter} topic and advance past it, so
-	 *   newer entries still project.
-	 */
-	readonly onPoison?: ProjectorPoisonPolicy;
-	/**
-	 * Initial cursor position. `"retained"` (default) projects all history;
-	 * `"now"` skips existing entries (project only future appends); a number
-	 * starts at that absolute index.
-	 */
-	readonly from?: "retained" | "now" | number;
-	/** Retained window for the `deadLetter` topic. Default 1024. */
-	readonly deadLetterRetainedLimit?: number;
-};
-
-/**
- * Cursor-driven projector over a {@link TopicGraph} or {@link ReactiveLogBundle}.
- *
- * Topology (mounted on the returned graph):
- *  - `subscription` (TopicGraph source only) — the hardened
- *    {@link SubscriptionGraph} cursor; or a local `cursor` state + the
- *    bundle's `fromCursor` view (ReactiveLogBundle source).
- *  - `drain` — an `effect` that, on every not-yet-projected wave, schedules a
- *    serialized async pass that calls `sink` per item (mirrors the
- *    `SubscriptionGraph.ackPump` / `TopicBridge.ackPump` effect precedent +
- *    memo:Re's `inFlight` chain — one wave processed at a time).
- *  - `deadLetter` — a real {@link TopicGraph} (NOT a callback): poison entries
- *    are observable in `describe()` and subscribable, instead of memo:Re's
- *    silent `break`.
- *
- * **No imperative reads.** Observe `position` (cursor) / subscribe to
- * `deadLetter`. `idle()` is a test-only await convenience.
- *
- * @category patterns
- */
-export class LogProjectorGraph<T> extends Graph {
-	/** Reactive count of fully-projected entries (the cursor; read-only). */
-	readonly position: Node<number>;
-	/**
-	 * Poison entries (populated when `onPoison: "deadLetter"`). A real topic —
-	 * subscribable + visible in `describe()`.
-	 */
-	readonly deadLetter: TopicGraph<DeadLetterEntry<T>>;
-	private _inFlight: Promise<void> = Promise.resolve();
-
-	constructor(
-		name: string,
-		source: TopicGraph<T> | ReactiveLogBundle<T>,
-		opts: LogProjectorOptions<T>,
-	) {
-		super(name, opts.graph);
-		const onPoison: ProjectorPoisonPolicy = opts.onPoison ?? "halt";
-		const sink = opts.sink;
-
-		const dl = new TopicGraph<DeadLetterEntry<T>>(`${name}_dead_letter`, {
-			retainedLimit: opts.deadLetterRetainedLimit ?? DEFAULT_TOPIC_RETAINED_LIMIT,
-		});
-		this.mount("deadLetter", dl);
-		this.deadLetter = dl;
-
-		// Uniform cursor surface over either source kind. A TopicGraph reuses
-		// the hardened SubscriptionGraph cursor; a ReactiveLogBundle uses a
-		// local state cursor + the bundle's `fromCursor` view — the very
-		// machinery SubscriptionGraph is itself built on.
-		let available: Node<readonly T[]>;
-		let cursorBase: () => number;
-		let advance: (n: number) => void;
-
-		if (source instanceof TopicGraph) {
-			const sub = new SubscriptionGraph<T>(`${name}_subscription`, source, {
-				from: opts.from ?? "retained",
-			});
-			this.mount("subscription", sub);
-			available = sub.available;
-			this.position = sub.cursor;
-			cursorBase = () => sub.cursor.cache as number;
-			advance = (n) => {
-				if (n > 0) sub.ack(n);
-			};
-		} else {
-			const log = source;
-			let initialCursor: number;
-			if (opts.from === "now") {
-				initialCursor = log.size;
-			} else if (typeof opts.from === "number") {
-				initialCursor = requireNonNegativeInt(opts.from, "logProjector from");
-			} else {
-				initialCursor = 0; // "retained"
-			}
-			const cursor = this.state<number>("cursor", initialCursor, {
-				meta: messagingMeta("log_projector_cursor"),
-			});
-			this.position = cursor;
-			cursorBase = () => cursor.cache as number;
-			available = log.view({ kind: "fromCursor", cursor });
-			advance = (n) => {
-				if (n > 0) cursor.emit((cursor.cache as number) + n);
-			};
-		}
-
-		// `halt` is a HARD LATCH (QA-C): on the first poison under `onPoison:
-		// "halt"`, `sink` has been invoked exactly once on the poison item;
-		// the projector then freezes — no further `sink` calls, no rescheduled
-		// drains — so a later unrelated append cannot re-invoke the (possibly
-		// side-effecting, non-idempotent) sink on the poison. The stalled
-		// `position` + frozen stream IS the observable signal. v1 has no retry
-		// (compose downstream of `deadLetter` if you need that).
-		let halted = false;
-
-		// Serialized async drain. One wave processed at a time (the inFlight
-		// chain) so an async `sink` cannot interleave; the cursor is advanced
-		// ONCE per pass after the captured snapshot is processed (mirrors
-		// memo:Re's `runPump` + the ackPump effect precedent).
-		const runDrain = async (): Promise<void> => {
-			if (halted) return;
-			const snapshot = (available.cache as readonly T[] | undefined) ?? [];
-			if (snapshot.length === 0) return;
-			let consumed = 0;
-			for (let i = 0; i < snapshot.length; i += 1) {
-				const item = snapshot[i] as T;
-				try {
-					await sink(item);
-					consumed += 1;
-				} catch (e) {
-					const error = e instanceof Error ? e.message : String(e);
-					if (onPoison === "deadLetter") {
-						dl.publish({ item, error, cursorPos: cursorBase() + consumed });
-						consumed += 1; // advance past the poison
-						continue;
-					}
-					// "halt" — latch and stop here; do NOT advance past the
-					// poison, do NOT re-invoke `sink` on any later wave.
-					halted = true;
-					break;
-				}
-			}
-			if (consumed > 0) advance(consumed);
-		};
-		const schedule = (): void => {
-			if (halted) return; // latched — no further drains
-			this._inFlight = this._inFlight.then(runDrain, runDrain);
-		};
-
-		// Effect: every wave that exposes not-yet-projected entries schedules a
-		// drain. Side-effecting (sink / cursor advance / dead-letter publish) →
-		// an `effect` node, not a pure derived (COMPOSITION-GUIDE §35; exact
-		// `SubscriptionGraph.advancePump` precedent — never calls `emit` on its
-		// own node, kept warm via `keepalive`).
-		const drain = node<unknown>(
-			[available],
-			(batchData, _actions, ctx) => {
-				const b = batchData[0];
-				const snap = (b != null && b.length > 0 ? b.at(-1) : ctx.prevData[0]) as
-					| readonly T[]
-					| undefined;
-				if (snap && snap.length > 0) schedule();
-			},
-			{
-				name: "drain",
-				describeKind: "effect",
-				meta: messagingMeta("log_projector_drain"),
-			},
-		);
-		this.add(drain, { name: "drain" });
-		this.addDisposer(keepalive(drain));
-	}
-
-	/**
-	 * Await any in-flight drain pass. **Test convenience only** — the canonical
-	 * reactive observable is {@link LogProjectorGraph.position}.
-	 */
-	idle(): Promise<void> {
-		return this._inFlight;
-	}
-}
-
-/**
- * Creates a cursor-driven log/topic projector with a typed poison-failure
- * policy and an observable dead-letter topic.
- *
- * @example
- * ```ts
- * import { logProjector, topic } from "@graphrefly/graphrefly";
- *
- * const events = topic<Doc>("docs");
- * const proj = logProjector("indexer", events, {
- *   sink: async (doc) => { await index(doc); },   // throw ⇒ poison
- *   onPoison: "deadLetter",
- * });
- * proj.deadLetter.events.subscribe(/* observe poison *​/);
- * ```
- *
- * @remarks
- * **Use an UNBOUNDED source for durable / long-lived projection.** The cursor
- * is an absolute index; the underlying `fromCursor` view slices the source's
- * *current* entries array. A `TopicGraph` with a `retainedLimit` (or a
- * `ReactiveLogBundle` with `maxSize`) trims its head, so an absolute cursor
- * past the retained window reads the wrong offset (skips entries or stalls).
- * This is inherited `subscription()` / `fromCursor` behaviour, not specific to
- * `logProjector` — but it matters here because projection is typically
- * long-lived. For unbounded projection pass a source with NO `retainedLimit` /
- * `maxSize` (memo:Re's `changesetLog` is unbounded ✓).
- *
- * @category patterns
- */
-export function logProjector<T>(
-	name: string,
-	source: TopicGraph<T> | ReactiveLogBundle<T>,
-	opts: LogProjectorOptions<T>,
-): LogProjectorGraph<T> {
-	return new LogProjectorGraph<T>(name, source, opts);
-}
diff --git a/src/utils/messaging/message.ts b/src/utils/messaging/message.ts
deleted file mode 100644
index 0ff0b824..00000000
--- a/src/utils/messaging/message.ts
+++ /dev/null
@@ -1,191 +0,0 @@
-/**
- * Standard `TopicMessage<T>` envelope for hub topics + well-known topic name
- * constants (Phase 13.B; spec source: archive/docs/SESSION-human-llm-intervention-primitives.md
- * §6 + archive/docs/SESSION-multi-agent-gap-analysis.md §6 cross-cut).
- *
- * `TopicMessage<T>` is the **recommended** wrapper for cross-agent / cross-graph
- * topic payloads — it carries identity, schema, deadline, and correlation
- * metadata alongside the typed `payload`. It is NOT a required protocol
- * type; raw `topic<T>` continues to work for in-process payloads where the
- * envelope fields would be noise.
- *
- * Use the envelope when:
- * - Two or more graphs (or human + LLM consumers) communicate over a topic
- *   and need a stable wire shape — `correlationId` is the join key, `schema`
- *   gates payload validation, `expiresAt` enables TTL enforcement.
- * - A topic carries multiple payload kinds and consumers need to discriminate
- *   without parsing structurally.
- *
- * The standard well-known topic constants below are **conventions** — string
- * literals callers can pass to `messagingHub().topic(NAME)` to get a
- * predictable lookup. The hub does not enforce any topic to actually exist;
- * topics are still lazy on first access.
- */
-
-// ---------------------------------------------------------------------------
-// JSON Schema — minimal local type
-// ---------------------------------------------------------------------------
-
-/**
- * Minimal JSON Schema shape, scoped to what `TopicMessage<T>` validates against.
- * Locked DS-13.B (2026-04-30): zero-dep posture, structural shape only — no
- * full validator shipped. Callers that want full validation supply their own
- * (e.g. `ajv`, `zod`, `valibot`) and read `Message.schema` as the rule
- * source. The shape covers the JSON-Schema-7 subset that hub-topic payload
- * descriptions actually need:
- * - `type` / `properties` / `required` / `additionalProperties` for objects.
- * - `items` for arrays.
- * - `enum` / `const` for value constraints.
- * - `$ref` / `definitions` for shared sub-schemas.
- *
- * If a concrete consumer needs a richer shape (oneOf, allOf, format, etc.),
- * extend this type — it's a structural contract, not a tagged union, so
- * additive fields don't break existing producers.
- */
-export interface JsonSchema {
-	readonly type?:
-		| "string"
-		| "number"
-		| "integer"
-		| "boolean"
-		| "object"
-		| "array"
-		| "null"
-		| readonly ("string" | "number" | "integer" | "boolean" | "object" | "array" | "null")[];
-	readonly properties?: Readonly<Record<string, JsonSchema>>;
-	readonly required?: readonly string[];
-	readonly additionalProperties?: boolean | JsonSchema;
-	readonly items?: JsonSchema | readonly JsonSchema[];
-	readonly enum?: readonly unknown[];
-	readonly const?: unknown;
-	readonly $ref?: string;
-	readonly definitions?: Readonly<Record<string, JsonSchema>>;
-	readonly description?: string;
-	readonly title?: string;
-}
-
-// ---------------------------------------------------------------------------
-// TopicMessage<T> envelope
-// ---------------------------------------------------------------------------
-
-/**
- * Recommended envelope for hub topic payloads. Carries identity, optional
- * schema reference, optional expiry, optional correlation, and the typed
- * payload itself.
- *
- * - `id` — globally-unique identifier for this message instance. Producers
- *   mint it (UUID, ULID, hash, etc.); consumers use it for deduplication and
- *   trace correlation. **Required.**
- * - `schema` — optional structural description of `payload`. Validators
- *   (caller-supplied) read this to gate or shape consumption. Writers MAY
- *   include the schema inline for self-describing topics, or omit when the
- *   payload type is statically known to all consumers.
- * - `expiresAt` — ISO 8601 timestamp; consumers SHOULD drop / fallback past
- *   this point. Substrate enforcement is via composition (`timeout(source,
- *   ms)` + `fallback`), not a hub-level rule.
- * - `correlationId` — links related messages across topics (request /
- *   response pairs, conversation threads, multi-agent handoffs). Producers
- *   propagate it; consumers filter / group on it.
- * - `payload` — the typed body. Type parameter `T` is the consumer-agreed
- *   shape; the envelope adds metadata around it without coupling consumers
- *   to a concrete payload type.
- *
- * Reactive composition with the envelope:
- *
- * ```ts
- * const requests = hub.topic<TopicMessage<RequestBody>>(PROMPTS_TOPIC);
- * const responses = hub.topic<TopicMessage<ResponseBody>>(RESPONSES_TOPIC);
- *
- * // Filter responses to one correlation
- * const myResponse = derived([responses.latest], ([msg]) =>
- *   msg?.correlationId === requestId ? [msg.payload] : [],
- * );
- * ```
- */
-export interface TopicMessage<T> {
-	readonly id: string;
-	readonly schema?: JsonSchema;
-	readonly expiresAt?: string;
-	readonly correlationId?: string;
-	readonly payload: T;
-}
-
-// ---------------------------------------------------------------------------
-// Standard topic name constants
-// ---------------------------------------------------------------------------
-
-/**
- * Well-known topic name for human / LLM prompts directed at the harness.
- * Example payload: `TopicMessage<{ prompt: string; context?: object }>`.
- *
- * Co-locked with {@link RESPONSES_TOPIC} per the human-LLM intervention
- * session §6 #4 (paired request / response convention).
- */
-export const PROMPTS_TOPIC = "prompts";
-
-/**
- * Well-known topic name for responses to {@link PROMPTS_TOPIC} entries.
- * Producers pair the response to its prompt via `correlationId`. Example
- * payload: `TopicMessage<{ content: string; finishReason?: string }>`.
- */
-export const RESPONSES_TOPIC = "responses";
-
-/**
- * Well-known topic name for out-of-band injections — runtime overrides /
- * hot-fixes / human nudges that bypass the normal request flow. Example
- * payload: `TopicMessage<{ kind: "context-patch" | "policy-override" | ...;
- * data: unknown }>`. Per-injection consumers decide how (and whether) to
- * apply.
- */
-export const INJECTIONS_TOPIC = "injections";
-
-/**
- * Well-known topic name for items the harness deferred for later attention
- * (parked queue, follow-up tracker, "I'll get back to this"). Producer is
- * usually the harness itself; consumer is a tracker / dashboard / human.
- * Example payload: `TopicMessage<{ reason: string; original: unknown }>`.
- */
-export const DEFERRED_TOPIC = "deferred";
-
-/**
- * Well-known topic name for spawn requests (Phase 13.I `spawnable()`
- * surface). Producer emits a `TopicMessage<SpawnRequest>` to request a child
- * agent / subgraph; consumer is the materializer that mints the slot.
- * Example payload: `TopicMessage<{ presetId: string; taskInput: unknown;
- * depth?: number }>`. `correlationId` links the spawn to its parent
- * conversation; `expiresAt` enforces TTL on long-lived requests.
- */
-export const SPAWNS_TOPIC = "spawns";
-
-/**
- * DS-14.6.A D-B3 — well-known topic for the dynamic `actorPool()` shared
- * tagged-context pool. Actors publish `ContextEntry` here; per-actor views
- * render their own compressed slice.
- */
-export const CONTEXT_TOPIC = "context";
-
-/**
- * DS-14.6.A D-B3 — well-known topic for the `actorPool()` shared todo list.
- * Any actor may `enqueueTodo`; actors pull assigned todos via their cursor.
- */
-export const TODOS_TOPIC = "todos";
-
-/**
- * Tuple of all well-known topic constants — useful for "register all
- * standard topics on a hub" patterns and for compile-time exhaustiveness
- * checks.
- */
-export const STANDARD_TOPICS = [
-	PROMPTS_TOPIC,
-	RESPONSES_TOPIC,
-	INJECTIONS_TOPIC,
-	DEFERRED_TOPIC,
-	SPAWNS_TOPIC,
-	CONTEXT_TOPIC,
-	TODOS_TOPIC,
-] as const;
-
-/**
- * Union of all well-known topic name string literals.
- */
-export type StandardTopic = (typeof STANDARD_TOPICS)[number];
diff --git a/src/utils/orchestration/audited-success-tracker.ts b/src/utils/orchestration/audited-success-tracker.ts
deleted file mode 100644
index 33a398d5..00000000
--- a/src/utils/orchestration/audited-success-tracker.ts
+++ /dev/null
@@ -1,169 +0,0 @@
-/**
- * `auditedSuccessTracker` — domain-agnostic per-key success-rate tracker.
- *
- * Reactive `key → { attempts, successes, successRate }` map mounted as a
- * Graph subclass. Reusable substrate for any domain that needs to track
- * outcomes per identifier (routing strategy effectiveness, A/B-test arms,
- * cache-policy tuning, retry-strategy selection, etc.).
- *
- * Replaces the prior `effectivenessTracker` and `strategyModel` factories
- * (Class B audit Alt E collapse, 2026-04-30). Composite-key callers (e.g.
- * `rootCause × intervention`) convert to a string key at the call site.
- *
- * @module
- */
-
-import type { Node } from "@graphrefly/pure-ts/core";
-import { keepalive, type ReactiveMapBundle, reactiveMap } from "@graphrefly/pure-ts/extra";
-import { Graph, type GraphOptions } from "@graphrefly/pure-ts/graph";
-
-/** A single success-rate record for one key. */
-export interface AuditedSuccessEntry<TKey extends string = string> {
-	readonly key: TKey;
-	readonly attempts: number;
-	readonly successes: number;
-	readonly successRate: number;
-}
-
-/** Snapshot shape — fresh `ReadonlyMap` on every mutation. */
-export type AuditedSuccessSnapshot<
-	TKey extends string = string,
-	TEntry extends AuditedSuccessEntry<TKey> = AuditedSuccessEntry<TKey>,
-> = ReadonlyMap<TKey, TEntry>;
-
-/** Options for {@link auditedSuccessTracker}. */
-export interface AuditedSuccessTrackerOptions {
-	/** Optional graph identity (passed to the underlying Graph constructor). */
-	graph?: GraphOptions;
-	/** Name of the tracker subgraph. Default `"audited-success-tracker"`. */
-	name?: string;
-}
-
-/**
- * Reactive success-rate tracker mounted as a Graph subclass.
- *
- * `key → AuditedSuccessEntry` with `record(key, success, extra?)` /
- * `lookup(key)` methods. The {@link entries} field is a
- * `Node<ReadonlyMap<TKey, TEntry>>` suitable for graph composition —
- * exposed under name `"entries"` for `describe()` / `explain()`.
- *
- * Backed by the {@link reactiveMap} substrate; each successful `record(...)`
- * fires a DATA emission carrying the post-mutation map.
- *
- * **Field name.** This Graph subclass uses `entries` (not `snapshot`) for
- * the public-face Node because `Graph.prototype.snapshot()` is the
- * built-in persistence-snapshot method on the parent class — using
- * `snapshot` here would shadow it and break DTS generation.
- *
- * @typeParam TKey - String-typed key shape. Composite-key domains (e.g.
- *   `rootCause × intervention`) convert to a string at the call site.
- * @typeParam TEntry - Entry shape; defaults to {@link AuditedSuccessEntry}.
- *   Domains that need extra fields (e.g. `rootCause`/`intervention`) extend
- *   this interface and pass the extra fields via `record(...)`'s `extra` arg.
- */
-export class AuditedSuccessTrackerGraph<
-	TKey extends string = string,
-	TEntry extends AuditedSuccessEntry<TKey> = AuditedSuccessEntry<TKey>,
-> extends Graph {
-	/** Reactive entries — `Node<ReadonlyMap<TKey, TEntry>>`, fresh map per mutation. */
-	readonly entries: Node<AuditedSuccessSnapshot<TKey, TEntry>>;
-
-	private readonly _map: ReactiveMapBundle<TKey, TEntry>;
-
-	constructor(opts?: AuditedSuccessTrackerOptions) {
-		super(opts?.name ?? "audited-success-tracker", opts?.graph);
-		this._map = reactiveMap<TKey, TEntry>({ name: "entries" });
-		this.entries = this._map.entries;
-		this.add(this.entries, { name: "entries" });
-
-		// Keep the entries node activated without external subscribers so
-		// `tracker.entries.cache` is readable from sync code paths and
-		// `lookup()` callers don't have to manage subscriptions. Released on
-		// Graph dispose along with the underlying reactiveMap.
-		this.addDisposer(keepalive(this.entries));
-		this.addDisposer(() => this._map.dispose());
-	}
-
-	/**
-	 * Record a completed attempt. `extra` fields are merged into the stored
-	 * entry — use for domain-specific decoration (e.g. `{ rootCause,
-	 * intervention }` on the strategy-model collapse path).
-	 *
-	 * **Caller contract for typed `TEntry`.** When `TEntry` extends
-	 * {@link AuditedSuccessEntry} with required fields beyond
-	 * `key`/`attempts`/`successes`/`successRate`, the caller must supply
-	 * those required fields in `extra` on the **first** `record(key, ...)`
-	 * for that key. The internal `as TEntry` cast trusts this. Subsequent
-	 * `record(key, ...)` calls inherit the prior entry's fields, so `extra`
-	 * may be omitted or partial. Forgetting required fields on the first
-	 * record produces an entry whose typed-required fields are `undefined`
-	 * at runtime — TS won't catch it. Strategy callers always pass
-	 * `{ rootCause, intervention }`, so the StrategyEntry case is safe.
-	 */
-	record(
-		key: TKey,
-		success: boolean,
-		extra?: Partial<Omit<TEntry, "key" | "attempts" | "successes" | "successRate">>,
-	): void {
-		const existing = this._map.get(key);
-		const attempts = (existing?.attempts ?? 0) + 1;
-		const successes = (existing?.successes ?? 0) + (success ? 1 : 0);
-		this._map.set(key, {
-			...(existing ?? {}),
-			...(extra ?? {}),
-			key,
-			attempts,
-			successes,
-			successRate: successes / attempts,
-		} as TEntry);
-	}
-
-	/**
-	 * Look up the entry for a key.
-	 *
-	 * Pure read: this tracker doesn't configure a TTL on the underlying
-	 * `reactiveMap`, so `_map.get(key)` never triggers TTL-expiry pruning
-	 * (which would otherwise be an observable side effect emitting a fresh
-	 * `entries` snapshot). If `AuditedSuccessTrackerOptions` ever gains a
-	 * `mapOptions` carve-out exposing TTL, revisit this contract.
-	 */
-	lookup(key: TKey): TEntry | undefined {
-		return this._map.get(key);
-	}
-}
-
-/**
- * Construct an {@link AuditedSuccessTrackerGraph}. Replaces the prior
- * `effectivenessTracker()` and `strategyModel()` factories.
- *
- * @example
- * ```ts
- * // Generic per-action tracker
- * const tracker = auditedSuccessTracker({ name: "ab-test" });
- * tracker.record("variant-a", true);
- * tracker.record("variant-b", false);
- * tracker.entries.subscribe(snap => console.log(snap.get("variant-a")));
- *
- * // Composite-key (rootCause × intervention) tracker — caller computes the key
- * type StrategyEntry = AuditedSuccessEntry<StrategyKey> & {
- *   rootCause: RootCause;
- *   intervention: Intervention;
- * };
- * const strategy = auditedSuccessTracker<StrategyKey, StrategyEntry>({
- *   name: "strategy",
- * });
- * strategy.record(
- *   strategyKey(rootCause, intervention),
- *   true,
- *   { rootCause, intervention },
- * );
- * ```
- *
- * @category extra
- */
-export function auditedSuccessTracker<
-	TKey extends string = string,
-	TEntry extends AuditedSuccessEntry<TKey> = AuditedSuccessEntry<TKey>,
->(opts?: AuditedSuccessTrackerOptions): AuditedSuccessTrackerGraph<TKey, TEntry> {
-	return new AuditedSuccessTrackerGraph<TKey, TEntry>(opts);
-}
diff --git a/src/utils/orchestration/human-input.ts b/src/utils/orchestration/human-input.ts
deleted file mode 100644
index a60265a7..00000000
--- a/src/utils/orchestration/human-input.ts
+++ /dev/null
@@ -1,232 +0,0 @@
-/**
- * Phase 13.F — `humanInput<T>` sibling preset.
- *
- * Source: `archive/docs/SESSION-human-llm-intervention-primitives.md` §5
- * "Sibling presets on the substrate" + §9 Phase 2.
- *
- * **Role.** LLM↔human runtime Q&A channel. The agent (or any consumer)
- * reactively asks for human input by emitting a prompt; humanInput
- * publishes a {@link Message} envelope to the well-known
- * {@link PROMPTS_TOPIC} on the hub and watches {@link RESPONSES_TOPIC} for
- * the matching `correlationId`. When the response arrives, humanInput's
- * output Node emits the typed payload `T`.
- *
- * **Sibling to `approvalGate`** ([pipeline-graph.ts](pipeline-graph.ts)):
- * approvalGate is design-time veto on a topology edge; humanInput is a
- * runtime Q&A channel. They share substrate (hub + envelope) but differ
- * in role and initiator.
- *
- * **No imperative `.run()` / `.ask()`** — caller writes to `prompt` (any
- * `NodeInput<string>`) and reads `humanInput()`'s output Node.
- *
- * **Multi-prompt.** Each new `prompt` DATA mints a fresh correlationId
- * and a new pending request. The output Node's emission tracks the latest
- * correlationId — earlier in-flight requests are abandoned (switchMap
- * semantics). To run parallel requests, instantiate two humanInput nodes.
- */
-
-import { COMPLETE, DATA, type Node, node, wallClockNs } from "@graphrefly/pure-ts/core";
-import { fromAny, type NodeInput } from "@graphrefly/pure-ts/extra";
-import {
-	type JsonSchema,
-	type MessagingHubGraph,
-	PROMPTS_TOPIC,
-	RESPONSES_TOPIC,
-	type TopicMessage,
-} from "../messaging/index.js";
-
-// ---------------------------------------------------------------------------
-// Types
-// ---------------------------------------------------------------------------
-
-/** Outbound prompt envelope payload. */
-export interface HumanPromptPayload {
-	readonly prompt: string;
-	readonly schema?: JsonSchema;
-}
-
-/**
- * Options for {@link humanInput}.
- */
-export interface HumanInputOpts {
-	/**
-	 * Messaging hub. {@link PROMPTS_TOPIC} is created lazily for outbound
-	 * prompts; {@link RESPONSES_TOPIC} is read for incoming responses.
-	 */
-	readonly hub: MessagingHubGraph;
-	/**
-	 * Reactive prompt source. Any `NodeInput<string>` is accepted (Node,
-	 * Promise, AsyncIterable, scalar) — coerced via `fromAny`. Each new
-	 * DATA on this input mints a fresh request.
-	 */
-	readonly prompt: NodeInput<string>;
-	/**
-	 * Optional response-shape schema. Carried in the prompt envelope for
-	 * UI / consumer-side validation. Caller-supplied validators (ajv,
-	 * zod, valibot) consume this field; the substrate doesn't validate.
-	 */
-	readonly schema?: JsonSchema;
-	/**
-	 * Optional ID generator for the per-prompt correlationId. Default is
-	 * a monotonic counter derived from a tight closure (sufficient for
-	 * in-process correlation; cross-process consumers should supply UUID
-	 * / ULID generation).
-	 */
-	readonly idGenerator?: () => string;
-}
-
-// ---------------------------------------------------------------------------
-// humanInput
-// ---------------------------------------------------------------------------
-
-/**
- * Constructs a reactive human-input request channel. Each DATA on
- * `prompt` mints a fresh request:
- *
- * 1. Mints a fresh `correlationId` (via `opts.idGenerator` if provided).
- * 2. Publishes `TopicMessage<HumanPromptPayload>` to {@link PROMPTS_TOPIC}
- *    (`{ id, schema?, correlationId, payload: { prompt, schema? } }`).
- * 3. Watches {@link RESPONSES_TOPIC} for an envelope whose
- *    `correlationId` matches.
- * 4. When matched, emits the response payload as the output Node's DATA.
- *
- * **Switchmap semantics.** A new prompt arriving before the prior
- * response abandons the prior wait. Output Node emits the response for
- * the latest in-flight request only.
- *
- * **Output type `T`** is the response payload type. Caller is responsible
- * for ensuring the response producer (UI / human-side) sends the right
- * shape — `schema` is the wire-level convention for validation.
- *
- * @example
- * ```ts
- * import {
- *   humanInput,
- *   messagingHub,
- *   PROMPTS_TOPIC,
- *   RESPONSES_TOPIC,
- * } from "@graphrefly/graphrefly";
- *
- * const hub = messagingHub("hub");
- * const promptN = state<string>("prompt");
- * const reply = humanInput<{ ok: boolean; reason: string }>({
- *   hub,
- *   prompt: promptN,
- *   schema: { type: "object", required: ["ok", "reason"] },
- * });
- *
- * // UI / human side: subscribe to PROMPTS_TOPIC, present, then publish to
- * // RESPONSES_TOPIC with the matching correlationId.
- * promptN.emit("Approve change?");
- * const decision = await awaitSettled(reply);  // resolves when human responds
- * ```
- *
- * @category patterns
- */
-export function humanInput<T>(opts: HumanInputOpts): Node<T> {
-	const { hub, prompt, schema, idGenerator } = opts;
-	const promptNode = fromAny<string>(prompt);
-	const promptsTopic = hub.topic<TopicMessage<HumanPromptPayload>>(PROMPTS_TOPIC);
-	const responsesTopic = hub.topic<TopicMessage<T>>(RESPONSES_TOPIC);
-
-	const nextId = idGenerator ?? defaultIdGenerator();
-
-	return node<T>(
-		(_data, a) => {
-			let activeCorrelationId: string | undefined;
-			let respUnsub: (() => void) | undefined;
-
-			const promptUnsub = promptNode.subscribe((msgs) => {
-				for (const m of msgs) {
-					if (m[0] === COMPLETE) {
-						respUnsub?.();
-						respUnsub = undefined;
-						a.down([[COMPLETE]]);
-						return;
-					}
-					if (m[0] !== DATA) continue;
-					const promptStr = m[1] as string;
-					// Switch-map semantics: drop the prior in-flight watcher.
-					respUnsub?.();
-					respUnsub = undefined;
-					// Mint new correlationId.
-					const correlationId = nextId();
-					activeCorrelationId = correlationId;
-
-					// Snapshot the responses topic length BEFORE publishing so
-					// we only consider envelopes that arrive AFTER this
-					// subscription. Eliminates the stale-replay-on-subscribe
-					// hazard (push-on-subscribe of `events` delivers the full
-					// retained log, which could include an unrelated old
-					// envelope whose `correlationId` happens to match if the
-					// caller's id-generator is non-unique).
-					const responseCursorAtSubscribe =
-						(responsesTopic.events.cache as readonly TopicMessage<T>[] | undefined)?.length ?? 0;
-
-					// Publish the prompt envelope. Schema is carried at
-					// envelope-level only (Phase 13.B TopicMessage<T> contract);
-					// the payload itself is `HumanPromptPayload` and stays
-					// schema-free.
-					const envelope: TopicMessage<HumanPromptPayload> = {
-						id: correlationId,
-						correlationId,
-						payload: { prompt: promptStr },
-						...(schema != null && { schema }),
-					};
-					promptsTopic.publish(envelope);
-
-					// Watch responses topic for matching correlationId, but
-					// skip the retained log (only consider envelopes at index
-					// >= responseCursorAtSubscribe).
-					respUnsub = responsesTopic.events.subscribe((rspMsgs) => {
-						for (const rm of rspMsgs) {
-							if (rm[0] !== DATA) continue;
-							const arr = rm[1] as readonly TopicMessage<T>[];
-							for (let i = responseCursorAtSubscribe; i < arr.length; i++) {
-								const env = arr[i] as TopicMessage<T>;
-								if (env.correlationId === activeCorrelationId) {
-									a.emit(env.payload);
-									// One-shot per prompt — next prompt re-arms the watcher.
-									respUnsub?.();
-									respUnsub = undefined;
-									return;
-								}
-							}
-						}
-					});
-				}
-			});
-
-			return {
-				onDeactivation: () => {
-					promptUnsub();
-					respUnsub?.();
-				},
-			};
-		},
-		{
-			describeKind: "derived",
-			name: "humanInput",
-			// Each new prompt may produce a structurally-equal response (e.g.
-			// from a deterministic UI mock) — disable framework dedup so
-			// repeat emissions propagate. Same precedent as `agent.out`.
-			equals: () => false,
-		},
-	);
-}
-
-// ---------------------------------------------------------------------------
-// Default ID generator
-// ---------------------------------------------------------------------------
-
-function defaultIdGenerator(): () => string {
-	let n = 0;
-	// `wallClockNs()` routes through the central clock per CLAUDE.md "Time
-	// utility rule" — testing harnesses that monkey-patch the clock can pin
-	// id generation deterministically.
-	const base = wallClockNs().toString(36);
-	return () => {
-		n += 1;
-		return `humanInput-${base}-${n.toString(36)}`;
-	};
-}
diff --git a/src/utils/orchestration/index.ts b/src/utils/orchestration/index.ts
deleted file mode 100644
index 7e43e849..00000000
--- a/src/utils/orchestration/index.ts
+++ /dev/null
@@ -1,31 +0,0 @@
-/**
- * Orchestration patterns (roadmap §4.1).
- *
- * Domain-layer helpers that build workflow shapes on top of core + extra primitives.
- * Exported under the `patterns.orchestration` namespace to avoid collisions with
- * Phase 2 operator names (for example `gate`, `forEach`).
- */
-
-export {
-	type HumanInputOpts,
-	type HumanPromptPayload,
-	humanInput,
-} from "./human-input.js";
-export {
-	type CatchOptions,
-	type ClassifyResult,
-	type Decision,
-	type DecisionAction,
-	decisionKeyOf,
-	type GateController,
-	type GateOptions,
-	PipelineGraph,
-	pipelineGraph,
-	type StepRef,
-	type TerminalCause,
-} from "./pipeline-graph.js";
-export {
-	type TrackerBundle,
-	type TrackerOpts,
-	tracker,
-} from "./tracker.js";
diff --git a/src/utils/orchestration/pipeline-graph.ts b/src/utils/orchestration/pipeline-graph.ts
deleted file mode 100644
index 6e939751..00000000
--- a/src/utils/orchestration/pipeline-graph.ts
+++ /dev/null
@@ -1,679 +0,0 @@
-/**
- * PipelineGraph subclass (Wave A.1 Unit 1 — locked 2026-04-24).
- *
- * Specialized {@link Graph} that hosts workflow-DAG sugar methods:
- * `task` / `classify` / `combine` / `approval` / `approvalGate` / `catch`.
- * The legacy `pipeline` / `task` / `branch` / `join` / `subPipeline` /
- * `approval` / `loop` / `onFailure` factories from {@link ./index} continue
- * to work for migration ease; new code should prefer methods on this class.
- *
- * **Tier 2.3 rename:** the prior `gate(...)` method is now `approvalGate(...)`,
- * disambiguating it from the other gate-family primitives (`budgetGate` for
- * numeric constraints, `valve` for boolean switching, `policyGate` for ABAC
- * rules). The "gating dimension" here is **human judgment**.
- *
- * Construction: `pipelineGraph(name, opts?)` or `new PipelineGraph(name, opts)`.
- */
-
-import type { NodeActions } from "@graphrefly/pure-ts/core";
-import {
-	batch,
-	COMPLETE,
-	DATA,
-	ERROR,
-	factoryTag,
-	type Node,
-	type NodeOptions,
-	node,
-	placeholderArgs,
-	RESOLVED,
-	wallClockNs,
-} from "@graphrefly/pure-ts/core";
-import type { ReactiveLogBundle } from "@graphrefly/pure-ts/extra";
-import { Graph, type GraphOptions } from "@graphrefly/pure-ts/graph";
-import { domainMeta } from "../../base/meta/domain-meta.js";
-import { type BaseAuditRecord, createAuditLog, mutate } from "../../base/mutation/index.js";
-
-export type StepRef = string | Node<unknown>;
-
-function meta(kind: string, extra?: Record<string, unknown>): Record<string, unknown> {
-	return domainMeta("orchestration", kind, extra);
-}
-
-// ── Decision audit record (Audit 2 + Wave A.2 Unit 8) ─────────────────────
-
-export type DecisionAction =
-	| "approve"
-	| "reject"
-	| "modify"
-	| "drop"
-	| "open"
-	| "close"
-	| "teardown";
-
-export interface Decision<T = unknown> extends BaseAuditRecord {
-	readonly action: DecisionAction;
-	readonly count?: number;
-	readonly items?: readonly T[];
-	readonly unflushed?: number;
-}
-
-/** Recommended `keyOf` for keyed-storage adapters (Audit 2 #7). */
-export const decisionKeyOf = <T>(d: Decision<T>): string => d.action;
-
-// ── Gate ─────────────────────────────────────────────────────────────────
-
-export interface GateOptions<_T = unknown> {
-	/** Bounded default 1000 (Audit 2 cross-cutting). `Infinity` is opt-in. */
-	maxPending?: number;
-	startOpen?: boolean;
-	/**
-	 * Reactive auto-approve: gate's `latestIsOpen` mirrors this node's truthy
-	 * value. False→true transition drains the pending queue.
-	 *
-	 * **`COMPLETE` / `ERROR` on the approver are silently ignored** — the gate
-	 * stays in its current state. For permanent-open latching, use
-	 * `onceOnly: true` (the first truthy approval latches; subsequent falsy
-	 * values are ignored). The gate has no graceful terminal-state behavior
-	 * for the approver itself.
-	 */
-	approver?: Node<unknown>;
-	/** Latch — first truthy approval opens permanently; `close()` becomes no-op. */
-	onceOnly?: boolean;
-	meta?: Record<string, unknown>;
-	handlerVersion?: { id: string; version: string | number };
-}
-
-export interface GateController<T> {
-	/**
-	 * The post-gate output node. Renamed from `node` (Tier 5.2 / EC6,
-	 * 2026-04-29) to avoid shadowing `Graph.node(name)` when a gate is
-	 * accessed off a `PipelineGraph` instance.
-	 */
-	readonly output: Node<T>;
-	readonly pending: Node<readonly T[]>;
-	readonly count: Node<number>;
-	readonly isOpen: Node<boolean>;
-	readonly droppedCount: Node<number>;
-	readonly decisions: ReactiveLogBundle<Decision<T>>;
-	readonly audit: ReactiveLogBundle<Decision<T>>;
-	approve(count?: number): void;
-	reject(count?: number): void;
-	modify(fn: (value: T, index: number, pending: readonly T[]) => T, count?: number): void;
-	open(): void;
-	close(): void;
-}
-
-// ── catch (rename of onFailure; Wave A.2 Unit 10) ─────────────────────────
-
-/**
- * Terminal-cause discriminator for the {@link PipelineGraph.catch} recovery
- * handler. Tier 1.6.3 status-enum migration: was `{ kind: "complete" | "error" }`
- * pre-1.0; aligned with the canonical lifecycle enum
- * (`status: "running" | "completed" | "errored" | "cancelled"`). The variant
- * structure is preserved — `errored` still carries `error: unknown` and
- * `completed` carries no payload.
- */
-export type TerminalCause = { kind: "errored"; error: unknown } | { kind: "completed" };
-
-export interface CatchOptions<_T> {
-	/**
-	 * Which terminal cause to recover. Default `"errored"` (Tier 1.6.3 rename
-	 * of `"error"`). `"completed"` recovers COMPLETE; `"terminal"` recovers
-	 * either. Aligns with the canonical lifecycle enum that
-	 * {@link TerminalCause.kind} now uses.
-	 */
-	on?: "errored" | "completed" | "terminal";
-	completeWhenDepsComplete?: boolean;
-	meta?: Record<string, unknown>;
-	handlerVersion?: { id: string; version: string | number };
-}
-
-// ── classify result envelope (Wave A.1 Unit 3) ───────────────────────────
-
-export interface ClassifyResult<TTag extends string, T> {
-	readonly tag: TTag | "error";
-	readonly value: T;
-	readonly error?: unknown;
-}
-
-// ── PipelineGraph ────────────────────────────────────────────────────────
-
-export class PipelineGraph extends Graph {
-	// -- task -----------------------------------------------------------------
-
-	/**
-	 * Register a workflow task (`node` + auto-add). String deps resolve via
-	 * `this.resolve(path)`; Node deps via {@link Graph.nameOf} O(1) lookup.
-	 *
-	 * `run` receives `(data: readonly unknown[], ctx)` — the snapshot of latest
-	 * values per dep (same shape as the old `DerivedFn` sugar).
-	 */
-	task<T>(
-		name: string,
-		run: (data: readonly unknown[], ctx: { prevData: readonly unknown[] }) => T | undefined | null,
-		opts: { deps?: ReadonlyArray<StepRef>; meta?: Record<string, unknown> } = {},
-	): Node<T> {
-		const deps = (opts.deps ?? []).map((d) => this._resolveStep(d));
-		const step = node<T>(
-			deps,
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				const result = run(data, ctx);
-				if (result !== undefined && result !== null) actions.emit(result);
-			},
-			{
-				name,
-				describeKind: "derived",
-				meta: meta("task", opts.meta),
-			} as NodeOptions<T>,
-		);
-		this.add(step, { name });
-		return step;
-	}
-
-	// -- classify (n-way; replaces binary `branch`) --------------------------
-
-	classify<TTag extends string, T>(
-		name: string,
-		source: StepRef,
-		tagger: (value: T) => TTag,
-		opts: { meta?: Record<string, unknown> } = {},
-	): Node<ClassifyResult<TTag, T>> {
-		const src = this._resolveStep(source);
-		const step = node<ClassifyResult<TTag, T>>(
-			[src],
-			(batchData, actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				const value = data[0];
-				try {
-					actions.emit({ tag: tagger(value as T), value: value as T });
-				} catch (error) {
-					actions.emit({ tag: "error" as const, value: value as T, error });
-				}
-			},
-			{
-				name,
-				describeKind: "derived",
-				meta: meta("classify", opts.meta),
-			} as NodeOptions<ClassifyResult<TTag, T>>,
-		);
-		this.add(step, { name });
-		return step;
-	}
-
-	// -- combine (keyed-record fan-in; replaces positional `join`) -----------
-
-	combine<R extends Record<string, StepRef>>(
-		name: string,
-		deps: R,
-		opts: { meta?: Record<string, unknown> } = {},
-	): Node<{ [K in keyof R]: unknown }> {
-		const keys = Object.keys(deps) as Array<keyof R & string>;
-		const nodes = keys.map((k) => this._resolveStep(deps[k] as StepRef));
-		const step = node<{ [K in keyof R]: unknown }>(
-			nodes,
-			(batchData, actions, ctx) => {
-				const values = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				const out = {} as { [K in keyof R]: unknown };
-				for (let i = 0; i < keys.length; i++) {
-					(out as Record<string, unknown>)[keys[i] as string] = values[i];
-				}
-				actions.emit(out);
-			},
-			{
-				name,
-				describeKind: "derived",
-				meta: meta("combine", opts.meta),
-			} as NodeOptions<{ [K in keyof R]: unknown }>,
-		);
-		this.add(step, { name });
-		return step;
-	}
-
-	// -- approvalGate ---------------------------------------------------------
-
-	approvalGate<T>(name: string, source: StepRef, opts: GateOptions<T> = {}): GateController<T> {
-		const maxPending = opts.maxPending ?? 1000;
-		if (maxPending < 1 && maxPending !== Number.POSITIVE_INFINITY) {
-			throw new RangeError("approvalGate: maxPending must be >= 1");
-		}
-		const startOpen = opts.startOpen ?? false;
-
-		// C3 — wrap a foreign Node source in a local proxy derived. The proxy
-		// is owned by THIS graph; downstream wiring uses the proxy (not the
-		// foreign Node) so the cross-graph ownership invariant holds. Causal
-		// chain is preserved via the dep edge — `describe()` still surfaces
-		// the foreign Node's path through the proxy.
-		let src: Node<unknown>;
-		if (typeof source === "string") {
-			src = this._resolveStep(source);
-		} else if (this.nameOf(source) !== undefined) {
-			src = source;
-		} else {
-			const proxy = node<unknown>(
-				[source],
-				(batchData, actions) => {
-					const batch0 = batchData[0];
-					if (batch0 == null || batch0.length === 0) return;
-					for (const v of batch0) actions.emit(v);
-				},
-				{
-					describeKind: "derived",
-					meta: factoryTag("proxy"),
-				},
-			);
-			this.add(proxy, { name: `${name}/source` });
-			src = proxy;
-		}
-
-		// State subgraph
-		const internal = new Graph(`${name}-state`);
-		const pendingNode = internal.state<readonly T[]>("pending", [], {
-			equals: () => false,
-		});
-		const isOpenNode = internal.state<boolean>("isOpen", startOpen);
-		const countNode = internal.derived<number>("count", ["pending"], (batchData, ctx) => {
-			const data = batchData.map((batch, i) =>
-				batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-			);
-			return [(data[0] as readonly T[]).length];
-		});
-		const droppedCountNode = internal.state<number>("droppedCount", 0);
-		const decisions = createAuditLog<Decision<T>>({
-			name: "decisions",
-			retainedLimit: 1024,
-			graph: internal,
-		});
-		this.mount(`${name}-state`, internal);
-
-		let queue: T[] = [];
-		let torn = false;
-		let latched = false;
-		// Closure-mirror per COMPOSITION-GUIDE §28 factory-time seed pattern.
-		// `output` samples `latestIsOpen` inside its fn body when deciding
-		// emit-vs-enqueue; reading a closure variable is NOT a P3 violation
-		// (§28). An in-session Phase 9 plan would have relocated the value to
-		// `internal.derived("latestIsOpen", ...)` + `.cache` reads (which IS
-		// a P3 violation); plan was reverted at the design level after
-		// re-reading §28 — pattern preserved here. See `archive/docs/SESSION-
-		// graph-narrow-waist.md` § "Status of existing modifications".
-		let latestIsOpen = startOpen;
-		const isOpenUnsub = isOpenNode.subscribe((msgs) => {
-			for (const m of msgs) {
-				if (m[0] === DATA) latestIsOpen = m[1] as boolean;
-			}
-		});
-		this.addDisposer(isOpenUnsub);
-
-		function syncPending(): void {
-			pendingNode.emit([...queue]);
-		}
-
-		function recordDecision(
-			action: DecisionAction,
-			items?: readonly T[],
-			unflushed?: number,
-		): void {
-			decisions.append({
-				action,
-				t_ns: wallClockNs(),
-				...(items !== undefined ? { items, count: items.length } : {}),
-				...(unflushed !== undefined ? { unflushed } : {}),
-				...(opts.handlerVersion != null ? { handlerVersion: opts.handlerVersion } : {}),
-			} as Decision<T>);
-		}
-
-		function enqueue(value: T): void {
-			queue.push(value);
-			if (queue.length > maxPending) {
-				const dropped = queue.shift() as T;
-				droppedCountNode.emit((droppedCountNode.cache as number) + 1);
-				recordDecision("drop", [dropped]);
-			}
-			syncPending();
-		}
-
-		function dequeue(n: number): T[] {
-			const items = queue.splice(0, n);
-			syncPending();
-			return items;
-		}
-
-		const output = node<T>(
-			[src],
-			(batchData, actions, ctx) => {
-				const terminal = ctx.terminalDeps[0];
-				if (terminal !== undefined) {
-					torn = true;
-					const unflushed = queue.length;
-					queue = [];
-					syncPending();
-					recordDecision("teardown", undefined, unflushed);
-					actions.down(terminal === true ? [[COMPLETE]] : [[ERROR, terminal]]);
-					return;
-				}
-				const batch0 = batchData[0];
-				if (batch0 == null || batch0.length === 0) {
-					actions.down([[RESOLVED]]);
-					return;
-				}
-				for (const v of batch0 as T[]) {
-					if (latestIsOpen) {
-						actions.emit(v);
-					} else {
-						enqueue(v);
-						actions.down([[RESOLVED]]);
-					}
-				}
-			},
-			{
-				name,
-				describeKind: "derived",
-				// Spec §2.7 R2.7.1 (DS-2.7.A). fn must fire on
-				// upstream-COMPLETE/ERROR-only-without-DATA so the
-				// teardown-decision record + downstream terminal forward run.
-				terminalAsRealInput: true,
-				meta: meta("approval_gate", opts.meta),
-			},
-		);
-		this.add(output, { name });
-
-		// Reactive approver mode: mirror latestIsOpen to the approver's value.
-		// **m1:** approver `COMPLETE` / `ERROR` are silently ignored — gate stays
-		// in current state. For latching behavior, use `onceOnly: true`.
-		if (opts.approver != null) {
-			const initialApproved = Boolean(opts.approver.cache);
-			if (initialApproved) {
-				isOpenNode.emit(true);
-				latestIsOpen = true;
-				if (opts.onceOnly) latched = true;
-			}
-			const approverSub = opts.approver.subscribe((msgs) => {
-				for (const m of msgs) {
-					if (m[0] !== DATA) continue;
-					const truthy = Boolean(m[1]);
-					if (truthy && !latestIsOpen) {
-						// false → true transition
-						if (opts.onceOnly) {
-							if (latched) continue;
-							latched = true;
-						}
-						batch(() => {
-							isOpenNode.emit(true);
-							const items = dequeue(queue.length);
-							// M11: include items count in approver-driven open decisions
-							// so audit consumers see how many items were flushed.
-							recordDecision("open", items);
-							for (const item of items) {
-								if (torn) break;
-								output.emit(item);
-							}
-						});
-					} else if (!truthy && latestIsOpen) {
-						if (opts.onceOnly && latched) continue;
-						batch(() => {
-							isOpenNode.emit(false);
-							recordDecision("close");
-						});
-					}
-				}
-			});
-			this.addDisposer(approverSub);
-		}
-
-		const guardTorn = (method: string): void => {
-			if (torn) throw new Error(`approvalGate: ${method}() called after the gate was torn down`);
-		};
-
-		const approveImpl = (count = 1): void => {
-			guardTorn("approve");
-			const items = dequeue(count);
-			for (const item of items) {
-				if (torn) break;
-				output.emit(item);
-			}
-		};
-		const rejectImpl = (count = 1): void => {
-			guardTorn("reject");
-			dequeue(count);
-		};
-		const modifyImpl = (
-			fn: (value: T, index: number, pending: readonly T[]) => T,
-			count = 1,
-		): void => {
-			guardTorn("modify");
-			const snapshot = [...queue] as readonly T[];
-			const items = dequeue(count);
-			for (let i = 0; i < items.length; i++) {
-				if (torn) break;
-				output.emit(fn(items[i], i, snapshot));
-			}
-		};
-		const openImpl = (): void => {
-			guardTorn("open");
-			isOpenNode.emit(true);
-			const items = dequeue(queue.length);
-			for (const item of items) {
-				if (torn) break;
-				output.emit(item);
-			}
-		};
-		const closeImpl = (): void => {
-			guardTorn("close");
-			if (opts.onceOnly && latched) return;
-			isOpenNode.emit(false);
-		};
-
-		const approve = mutate(approveImpl, {
-			frame: "transactional",
-			log: decisions,
-			freeze: false,
-			onSuccessRecord: (args, _r, m) =>
-				({
-					action: "approve",
-					count: (args[0] as number | undefined) ?? 1,
-					t_ns: m.t_ns,
-					...(opts.handlerVersion != null ? { handlerVersion: opts.handlerVersion } : {}),
-				}) as Decision<T>,
-			onFailureRecord: (_a, _e, m) =>
-				({
-					action: "drop",
-					t_ns: m.t_ns,
-					errorType: m.errorType,
-					...(opts.handlerVersion != null ? { handlerVersion: opts.handlerVersion } : {}),
-				}) as Decision<T>,
-		});
-		const reject = mutate(rejectImpl, {
-			frame: "transactional",
-			log: decisions,
-			freeze: false,
-			onSuccessRecord: (args, _r, m) =>
-				({
-					action: "reject",
-					count: (args[0] as number | undefined) ?? 1,
-					t_ns: m.t_ns,
-					...(opts.handlerVersion != null ? { handlerVersion: opts.handlerVersion } : {}),
-				}) as Decision<T>,
-			onFailureRecord: (_a, _e, m) =>
-				({
-					action: "drop",
-					t_ns: m.t_ns,
-					errorType: m.errorType,
-					...(opts.handlerVersion != null ? { handlerVersion: opts.handlerVersion } : {}),
-				}) as Decision<T>,
-		});
-		const modify = mutate(modifyImpl, {
-			frame: "transactional",
-			log: decisions,
-			freeze: false,
-			onSuccessRecord: (args, _r, m) =>
-				({
-					action: "modify",
-					count: (args[1] as number | undefined) ?? 1,
-					t_ns: m.t_ns,
-					...(opts.handlerVersion != null ? { handlerVersion: opts.handlerVersion } : {}),
-				}) as Decision<T>,
-			onFailureRecord: (_a, _e, m) =>
-				({
-					action: "drop",
-					t_ns: m.t_ns,
-					errorType: m.errorType,
-					...(opts.handlerVersion != null ? { handlerVersion: opts.handlerVersion } : {}),
-				}) as Decision<T>,
-		});
-		const open = mutate(openImpl, {
-			frame: "transactional",
-			log: decisions,
-			freeze: false,
-			onSuccessRecord: (_a, _r, m) =>
-				({
-					action: "open",
-					t_ns: m.t_ns,
-					...(opts.handlerVersion != null ? { handlerVersion: opts.handlerVersion } : {}),
-				}) as Decision<T>,
-			onFailureRecord: (_a, _e, m) =>
-				({
-					action: "drop",
-					t_ns: m.t_ns,
-					errorType: m.errorType,
-					...(opts.handlerVersion != null ? { handlerVersion: opts.handlerVersion } : {}),
-				}) as Decision<T>,
-		});
-		const close = mutate(closeImpl, {
-			frame: "transactional",
-			log: decisions,
-			freeze: false,
-			onSuccessRecord: (_a, _r, m) =>
-				({
-					action: "close",
-					t_ns: m.t_ns,
-					...(opts.handlerVersion != null ? { handlerVersion: opts.handlerVersion } : {}),
-				}) as Decision<T>,
-			onFailureRecord: (_a, _e, m) =>
-				({
-					action: "drop",
-					t_ns: m.t_ns,
-					errorType: m.errorType,
-					...(opts.handlerVersion != null ? { handlerVersion: opts.handlerVersion } : {}),
-				}) as Decision<T>,
-		});
-
-		this.addDisposer(countNode.subscribe(() => undefined));
-
-		const controller: GateController<T> = {
-			output,
-			pending: pendingNode,
-			count: countNode,
-			isOpen: isOpenNode,
-			droppedCount: droppedCountNode,
-			decisions,
-			audit: decisions,
-			approve,
-			reject,
-			modify,
-			open,
-			close,
-		};
-		return controller;
-	}
-
-	// -- approval (thin alias over approvalGate({ approver, maxPending: 1 })) -
-
-	/**
-	 * Reactive approval step: passes items through when `approver` is truthy;
-	 * holds at most one pending item (maxPending: 1) when falsy. A thin alias
-	 * over `approvalGate({ approver, maxPending: 1 })` — use `approvalGate()`
-	 * directly for finer control (maxPending, onceOnly, manual approve/reject).
-	 */
-	approval<T>(
-		name: string,
-		source: StepRef,
-		approver: Node<unknown>,
-		opts: Omit<GateOptions<T>, "approver" | "maxPending"> = {},
-	): GateController<T> {
-		return this.approvalGate<T>(name, source, { ...opts, approver, maxPending: 1 });
-	}
-
-	// -- catch (renamed onFailure; dep-channel intercept) -------------------
-
-	catch<T>(
-		name: string,
-		source: StepRef,
-		recover: (cause: TerminalCause, actions: NodeActions) => T,
-		opts: CatchOptions<T> = {},
-	): Node<T> {
-		const src = this._resolveStep(source);
-		const mode = opts.on ?? "errored";
-		const step = node<T>(
-			[src],
-			(batchData, actions, ctx) => {
-				const terminal = ctx.terminalDeps[0];
-				if (terminal !== undefined) {
-					const cause: TerminalCause =
-						terminal === true ? { kind: "completed" } : { kind: "errored", error: terminal };
-					if (mode === "terminal" || mode === cause.kind) {
-						actions.emit(recover(cause, actions));
-						return;
-					}
-					actions.down(cause.kind === "completed" ? [[COMPLETE]] : [[ERROR, cause.error]]);
-					return;
-				}
-				const batch0 = batchData[0];
-				if (batch0 == null || batch0.length === 0) {
-					actions.down([[RESOLVED]]);
-					return;
-				}
-				for (const v of batch0 as T[]) actions.emit(v);
-			},
-			{
-				name,
-				describeKind: "derived",
-				completeWhenDepsComplete:
-					opts.completeWhenDepsComplete ?? !(mode === "completed" || mode === "terminal"),
-				errorWhenDepsError: !(mode === "errored" || mode === "terminal"),
-				// Spec §2.7 R2.7.1 (DS-2.7.A). `catch` exists to fire on a
-				// source terminal — its whole job is `recover(cause, …)` on a
-				// terminal-only wave. Without this opt-in the gate holds and
-				// the recover branch never runs.
-				terminalAsRealInput: true,
-				meta: meta("catch", opts.meta),
-			} as NodeOptions<T>,
-		);
-		this.add(step, { name });
-		return step;
-	}
-
-	// -- internals ----------------------------------------------------------
-
-	private _resolveStep(dep: StepRef): Node<unknown> {
-		if (typeof dep === "string") return this.resolve(dep);
-		const existing = this.nameOf(dep);
-		if (existing === undefined) {
-			throw new Error(
-				`PipelineGraph "${this.name}": Node dep is not registered. Pass a string path or call graph.add(node) first.`,
-			);
-		}
-		return dep;
-	}
-}
-
-/** Factory wrapper — `pipelineGraph(name, opts?)`. Equivalent to `new PipelineGraph(name, opts)`. */
-export function pipelineGraph(name: string, opts?: GraphOptions): PipelineGraph {
-	const g = new PipelineGraph(name, opts);
-	// Tier 1.5.3 Phase 2.5 (DG1=B): tag the Graph with its constructing
-	// factory so `describe()` exposes provenance. `factoryArgs` is the
-	// constructor opts (sans the `factory`/`factoryArgs` keys themselves to
-	// avoid recursive nesting). QA F13: route through `placeholderArgs` for
-	// consistency with sibling factories — `GraphOptions[key: string]: unknown`
-	// is open-ended, so user-extension keys may carry non-JSON content.
-	const { factory: _f, factoryArgs: _fa, ...tagArgs } = (opts ?? {}) as Record<string, unknown>;
-	g.tagFactory("pipelineGraph", placeholderArgs(tagArgs));
-	return g;
-}
diff --git a/src/utils/orchestration/tracker.ts b/src/utils/orchestration/tracker.ts
deleted file mode 100644
index 6d3e5d0e..00000000
--- a/src/utils/orchestration/tracker.ts
+++ /dev/null
@@ -1,175 +0,0 @@
-/**
- * Phase 13.F — `tracker` sibling preset.
- *
- * Source: `archive/docs/SESSION-human-llm-intervention-primitives.md` §5
- * "Sibling presets on the substrate" + `archive/docs/SKETCH-reactive-tracker-factory.md`
- * + `project_reactive_tracker` memory.
- *
- * **Role.** Park-as-deferred queue consumer. The tracker is the
- * cursor-based read surface over the well-known {@link DEFERRED_TOPIC}
- * — items the harness (or any consumer) defers for later attention.
- * Sibling to `humanInput` and `approvalGate`; all three share substrate
- * (hub + envelope + reactive cursor) but differ in role.
- *
- * **Cursor handle.** Per the SESSION's "Cursor handle" return — tracker
- * exposes the cursor-based pull / ack surface so the consumer (a
- * dashboard, a post-run review, an LLM watcher) can iterate over
- * unconsumed items in order.
- *
- * **Naming locked (open question §11 #3 resolved):** `tracker`. The
- * SESSION mentioned `tracker` vs `parkedQueue` vs `deferredTracker`;
- * `tracker` is the simplest and most general — the deferred-queue
- * semantic is a recipe, not a name overload. Other use cases (issue
- * tracker, todo tracker, retrospective tracker per
- * `project_reactive_tracker`) reuse the same primitive.
- */
-
-import type { Node } from "@graphrefly/pure-ts/core";
-import {
-	DEFERRED_TOPIC,
-	type MessagingHubGraph,
-	type SubscriptionGraph,
-	subscription,
-	type TopicGraph,
-} from "../messaging/index.js";
-
-// ---------------------------------------------------------------------------
-// Bundle
-// ---------------------------------------------------------------------------
-
-/**
- * Bundle returned by {@link tracker}. Wraps a topic + cursor-based
- * subscription with imperative `add` / `ack` helpers.
- */
-export interface TrackerBundle<T> {
-	/**
-	 * The underlying topic. Either freshly minted on the hub at
-	 * `topicName` (default {@link DEFERRED_TOPIC}) or reused if the topic
-	 * already exists.
-	 */
-	readonly topic: TopicGraph<T>;
-	/** Cursor-based subscription view over `topic.events`. */
-	readonly subscription: SubscriptionGraph<T>;
-	/**
-	 * Items beyond the current cursor — i.e. the deferred queue's
-	 * "pending" head. Reactive `Node<readonly T[]>`.
-	 */
-	readonly pending: Node<readonly T[]>;
-	/** Current cursor position (number of items already acked). */
-	readonly cursor: Node<number>;
-	/**
-	 * Reactive total count of items added since construction (matches the
-	 * topic's retained-events length until the topic's retention cap is
-	 * reached).
-	 */
-	readonly total: Node<number>;
-	/** Append an item to the deferred queue. */
-	add(item: T): void;
-	/**
-	 * Advance the cursor past `n` items (default 1). Acks the next batch
-	 * of pending items; subsequent reads of `pending` exclude them.
-	 */
-	ack(n?: number): void;
-	/**
-	 * Pull-and-ack at most `limit` items in one shot. Returns the items
-	 * + the new cursor position (matches `subscription.pullAndAck`).
-	 */
-	pullAndAck(limit?: number): { items: readonly T[]; cursor: number };
-}
-
-// ---------------------------------------------------------------------------
-// tracker()
-// ---------------------------------------------------------------------------
-
-/**
- * Options for {@link tracker}.
- */
-export interface TrackerOpts {
-	/**
-	 * Messaging hub. The tracker creates / reuses a topic on this hub
-	 * named `topicName` (default {@link DEFERRED_TOPIC}).
-	 */
-	readonly hub: MessagingHubGraph;
-	/**
-	 * Topic name on the hub. Default {@link DEFERRED_TOPIC}. Override to
-	 * use a non-deferred topic (e.g. a custom domain queue).
-	 */
-	readonly topicName?: string;
-	/**
-	 * Subscription graph name. Default `"tracker"`. Multiple trackers on
-	 * the same hub topic must use distinct names.
-	 */
-	readonly name?: string;
-	/**
-	 * Initial cursor. Forwarded to the underlying subscription. See
-	 * {@link SubscriptionOptions.from}.
-	 */
-	readonly from?: "now" | "retained" | number;
-}
-
-/**
- * Mints a tracker bundle over a hub topic.
- *
- * @example
- * ```ts
- * import { messagingHub, tracker } from "@graphrefly/graphrefly";
- *
- * const hub = messagingHub("hub");
- * const issues = tracker<{ summary: string }>({ hub });
- *
- * issues.add({ summary: "investigate flaky test" });
- * issues.add({ summary: "follow up on auth refactor" });
- *
- * // Subscribe to the pending queue (for a dashboard, watcher, etc.)
- * issues.pending.subscribe((msgs) => { ... });
- *
- * // Imperative pull + ack
- * const next = issues.pullAndAck(1);
- * console.log(next.items[0]?.summary);
- * ```
- *
- * @category patterns
- */
-export function tracker<T>(opts: TrackerOpts): TrackerBundle<T> {
-	const { hub, topicName, name, from } = opts;
-	const effectiveTopicName = topicName ?? DEFERRED_TOPIC;
-	const effectiveName = name ?? "tracker";
-
-	// Reuse existing topic on the hub or lazy-create.
-	const topicGraph = hub.topic<T>(effectiveTopicName);
-
-	// Cursor-based subscription. The subscription is owned by the tracker
-	// (not mounted on the hub) — multiple trackers can share the topic with
-	// independent cursors.
-	const sub: SubscriptionGraph<T> = subscription<T>(effectiveName, topicGraph, {
-		...(from != null && { from }),
-	});
-
-	// `total` derives from topic.events.length. Use a derived node owned by
-	// the subscription for a self-contained surface. `keepAlive: true` so
-	// `total.cache` stays current even without external subscribers.
-	const total = sub.derived<number>(
-		"tracker-total",
-		[topicGraph.events],
-		(data, ctx) => {
-			const b0 = data[0];
-			const arr =
-				b0 != null && b0.length > 0
-					? (b0.at(-1) as readonly T[])
-					: ((ctx.prevData[0] as readonly T[] | undefined) ?? []);
-			return [arr.length];
-		},
-		{ keepAlive: true },
-	);
-
-	return {
-		topic: topicGraph,
-		subscription: sub,
-		pending: sub.available,
-		cursor: sub.cursor,
-		total,
-		add: (item) => topicGraph.publish(item),
-		ack: (n) => sub.ack(n ?? 1),
-		pullAndAck: (limit) => sub.pullAndAck(limit),
-	};
-}
diff --git a/src/utils/process/index.ts b/src/utils/process/index.ts
deleted file mode 100644
index be905d29..00000000
--- a/src/utils/process/index.ts
+++ /dev/null
@@ -1,1361 +0,0 @@
-/**
- * Process Manager pattern (Phase 7 — roadmap §4.6, Audit 3 — locked 2026-04-24).
- *
- * Reactive long-running workflow primitive over CQRS event nodes.
- * Correlates events across aggregates, tracks per-instance state, supports
- * retries with backoff, and runs compensation on failure or explicit cancel.
- *
- * ## Architecture
- *
- * - Per-instance state lives in a `Map<correlationId, TState>` closure (in-memory).
- *   The `_process_<name>_started` synthetic event is dispatched per `start()`
- *   for an event-sourced audit trail using `correlationId` as `aggregateId`.
- *   Cross-restart state recovery is opt-in via
- *   `opts.persistence.stateStorage` (kv-tier per-correlationId snapshot,
- *   Tier 6.5 3.5) plus an explicit `restore()` call after construction.
- * - Watched-event subscriptions are imperative (coordinator role) — each
- *   watched CQRS event type is subscribed to via `entries.subscribe(...)`.
- *   These are NOT reactive node edges; the process manager is intentionally
- *   a coordinator that bridges reactive CQRS events into imperative instance logic.
- * - Step execution uses `fromAny` to uniformly handle sync and async handlers.
- * - Retry delays use `setTimeout` (same sanctioned pattern as `extra/resilience.ts`
- *   retry helper — this primitive is a coordinator, not a reactive pipeline stage).
- * - Timer scheduling uses `fromTimer` from `extra/sources.ts` per spec §5.8.
- * - Audit log uses `createAuditLog` per Audit 2.
- *
- * @module
- */
-
-import {
-	batch,
-	COMPLETE,
-	DATA,
-	ERROR,
-	type Messages,
-	type Node,
-	node,
-	wallClockNs,
-} from "@graphrefly/pure-ts/core";
-import type {
-	AppendLogStorageTier,
-	KvStorageTier,
-	ReactiveLogBundle,
-} from "@graphrefly/pure-ts/extra";
-import {
-	fromAny,
-	fromIter,
-	fromTimer,
-	mergeMap,
-	type NodeInput,
-	valve,
-} from "@graphrefly/pure-ts/extra";
-import { Graph } from "@graphrefly/pure-ts/graph";
-import {
-	type BaseAuditRecord,
-	createAuditLog,
-	mutate,
-	type ReadonlyAuditLog,
-	readonlyAuditLog,
-	registerCursor,
-} from "../../base/mutation/index.js";
-import type { StatusValue } from "../../base/resilience/status.js";
-import { firstWhere } from "../../base/sources/settled.js";
-import type { CqrsEvent, CqrsEventMap, CqrsGraph } from "../cqrs/index.js";
-
-// ---------------------------------------------------------------------------
-// Public types
-// ---------------------------------------------------------------------------
-
-/**
- * Discriminated union returned by each step handler.
- *
- * - `"success"` — step ran cleanly; update state, optionally emit
- *   side-effect events and schedule a future synthetic event. The process
- *   instance stays `"running"`.
- * - `"terminate"` — workflow complete; instance moves to `"completed"`.
- *   Process-specific extension to the canonical outcome enum.
- * - `"failure"` — triggers compensation; instance moves to `"cancelled"` /
- *   `"errored"`.
- *
- * Field name is `outcome` (matching `cqrs.DispatchRecord.outcome` and the
- * canonical Tier 1.6.2 / 2.3 enum). `"success"` and `"failure"` are the
- * canonical values; `"terminate"` is the process-specific extension for
- * "early-return success".
- */
-export type ProcessStepResult<TState> =
-	| {
-			outcome: "success";
-			state: TState;
-			emit?: readonly { type: string; payload: unknown }[];
-			schedule?: ProcessSchedule;
-	  }
-	| {
-			outcome: "terminate";
-			state: TState;
-			emit?: readonly { type: string; payload: unknown }[];
-			reason?: string;
-	  }
-	| { outcome: "failure"; error: unknown };
-
-/**
- * Schedule a synthetic timer event after `afterMs` milliseconds.
- * When the timer fires, the synthetic event of `eventType` is routed to the
- * matching step (if one is registered) for this correlationId.
- */
-export type ProcessSchedule = { afterMs: number; eventType: string };
-
-/**
- * Step handler signature.
- *
- * Receives the current instance state and the triggering CQRS event.
- * Returns a {@link ProcessStepResult} — sync value, Promise, or any
- * {@link NodeInput} consumed via `fromAny`.
- */
-export type ProcessStep<TState, EM extends CqrsEventMap, K extends keyof EM & string> = (
-	state: TState,
-	event: CqrsEvent<EM[K]>,
-) => NodeInput<ProcessStepResult<TState>>;
-
-/**
- * Compensation handler. Runs when a step returns `outcome: "failure"`, throws, or
- * when `cancel(correlationId)` is called on a running instance.
- *
- * Should undo any side effects performed by prior steps (refund, cancel
- * reservation, etc.). Errors thrown inside compensate are swallowed and
- * recorded in the audit log with `status: "errored"` to prevent cascading
- * failure loops.
- */
-export type ProcessCompensate<TState> = (state: TState, error: unknown) => NodeInput<void>;
-
-/**
- * Audit record for a single process instance state transition.
- *
- * Every status change (start → running → completed / errored / cancelled)
- * appends one record. `correlationId` is the stable process key.
- *
- * Extends {@link BaseAuditRecord} so records carry `t_ns` / `seq` /
- * `handlerVersion` from the cross-cutting Audit 2 schema.
- */
-export interface ProcessInstance<TState> extends BaseAuditRecord {
-	/** Stable correlation key that identifies this process instance. */
-	readonly correlationId: string;
-	/** Most-recent instance state at this transition. */
-	readonly state: TState;
-	/** Current lifecycle status after this transition. */
-	readonly status: "running" | "completed" | "errored" | "cancelled";
-	/** Wall-clock nanoseconds when `start()` was called. */
-	readonly startedAt: number;
-	/** Wall-clock nanoseconds of this transition. */
-	readonly updatedAt: number;
-	/** Handler version stamped at transition time (Audit 5). */
-	readonly handlerVersion?: { id: string; version: string | number };
-	/** Optional human-readable reason for cancellation. Present only on `"cancelled"` records produced by `cancel()`. */
-	readonly reason?: string;
-}
-
-/**
- * Recommended `keyOf` for storage tiers keyed by correlationId (Audit 2).
- */
-export const processInstanceKeyOf = <TState>(i: ProcessInstance<TState>): string => i.correlationId;
-
-/**
- * Per-correlationId state snapshot persisted via
- * {@link ProcessManagerOpts.persistence.stateStorage} (Tier 6.5 3.5,
- * 2026-04-29). Captures the running instance's current state plus
- * lifecycle metadata so a fresh `processManager` can resume in-flight
- * workflows after restart via {@link ProcessManagerResult.restore}.
- *
- * Terminal records (`status` ∈ `"completed" | "errored" | "cancelled"`)
- * are deleted from the kv tier on transition — only running instances
- * persist between restarts.
- */
-export interface ProcessStateSnapshot<TState> {
-	readonly correlationId: string;
-	readonly state: TState;
-	readonly status: "running" | "completed" | "errored" | "cancelled";
-	readonly startedAt: number;
-	readonly updatedAt: number;
-	readonly handlerVersion?: { id: string; version: string | number };
-}
-
-/** Recommended `keyOf` for `KvStorageTier<ProcessStateSnapshot<...>>`. */
-export const processStateKeyOf = <TState>(s: ProcessStateSnapshot<TState>): string =>
-	s.correlationId;
-
-/**
- * Options for {@link processManager}.
- */
-export interface ProcessManagerOpts<TState, EM extends CqrsEventMap> {
-	/** Initial state value for every new process instance. */
-	readonly initial: TState;
-	/** CQRS event types to watch for correlation routing. */
-	readonly watching: readonly (keyof EM & string)[];
-	/**
-	 * Per-event-type step handlers. A step is invoked when a watched event's
-	 * `correlationId` matches a running instance and the event type is in
-	 * `steps`. Events with no matching step are silently ignored.
-	 */
-	readonly steps: { [K in keyof EM & string]?: ProcessStep<TState, EM, K> };
-	/**
-	 * Optional compensation handler. Runs on step `outcome: "failure"` / step throw
-	 * and on explicit `cancel()`. If omitted, instances fail silently with
-	 * status `"errored"` instead of `"cancelled"`.
-	 */
-	readonly compensate?: ProcessCompensate<TState>;
-	/**
-	 * Optional predicate called after each `"success"` step. When it returns
-	 * `true`, the instance is moved to `"completed"` immediately without
-	 * waiting for a `"terminate"` step result.
-	 */
-	readonly isTerminal?: (state: TState) => boolean;
-	/**
-	 * Maximum number of retry attempts after a step throws (not counting the
-	 * first attempt). Default: `0` (no retry — fail immediately on throw).
-	 */
-	readonly retryMax?: number;
-	/**
-	 * Per-retry backoff delays in milliseconds. `backoffMs[i]` is the delay
-	 * before attempt `i + 1`. If fewer entries than `retryMax`, the last entry
-	 * is repeated. Default: `[0]` (no delay).
-	 *
-	 * **Implementation note:** retry delays are implemented with `setTimeout`
-	 * (same sanctioned exception as `extra/resilience.ts`). This is a
-	 * coordinator-layer primitive — `fromTimer` would require subscribing to
-	 * an additional node per attempt, which would leak timer nodes without a
-	 * clear disposal scope.
-	 */
-	readonly backoffMs?: readonly number[];
-	/** Handler version tag stamped onto audit records (Audit 5). */
-	readonly handlerVersion?: { id: string; version: string | number };
-	/**
-	 * When `true`, do NOT auto-restore on construction. The caller must invoke
-	 * {@link ProcessManagerResult.restore} explicitly to load persisted
-	 * snapshots and arm watch dispatch.
-	 *
-	 * **Default `false`:** the factory kicks off restoration immediately so
-	 * watch dispatch arms as soon as snapshots have loaded (or instantly when
-	 * no `stateStorage` tier is configured). Until restoration completes,
-	 * watched events accumulate at the source but are valve-blocked from
-	 * reaching the per-instance step pipeline (B5 — locked 2026-05-01).
-	 */
-	readonly deferRestore?: boolean;
-	/**
-	 * Maximum number of concurrent `tier.load(key)` calls during restore.
-	 *
-	 * The restore pipeline streams keys from `tier.list()` through
-	 * `mergeMap`, which by default subscribes to inner sources unbounded
-	 * (parallel up to the number of keys). For storage tiers with large
-	 * persisted-instance counts (10K+), unbounded concurrency can exhaust
-	 * file handles, connection pools, or the backend's concurrent-request
-	 * budget. This option caps the in-flight load count.
-	 *
-	 * **Default `8`** (D2 lock 2026-05-01). Set higher for backends with
-	 * generous concurrency budgets; set to `Number.POSITIVE_INFINITY` for
-	 * the prior unbounded behavior.
-	 */
-	readonly restoreConcurrency?: number;
-	/** Optional persistence wiring (Audit 4). */
-	readonly persistence?: {
-		/**
-		 * Wire the per-process synthetic state event stream to append-log tiers.
-		 * Reuses `CqrsGraph.attachEventStorage` so events persist across restarts.
-		 */
-		eventStorage?: readonly AppendLogStorageTier<CqrsEvent>[];
-		/**
-		 * Wire per-correlationId state snapshots to kv tiers (Tier 6.5 3.5,
-		 * 2026-04-29). Each `start()` and step transition writes the running
-		 * instance's state under its `correlationId`; terminal transitions
-		 * (`completed` / `errored` / `cancelled`) `delete` the key. After
-		 * restart, callers invoke {@link ProcessManagerResult.restore} to
-		 * reload running instances from the first tier.
-		 *
-		 * Uses {@link KvStorageTier} (not snapshot tier) because per-instance
-		 * state is N records keyed by correlationId, not a single global
-		 * snapshot. {@link processStateKeyOf} is the recommended `keyOf`
-		 * (already aligned with the kv tier's `save(key, value)` shape).
-		 *
-		 * Terminal records are NOT preserved — historical lifecycle is the
-		 * audit log's job. State persistence covers crash-recovery only.
-		 */
-		stateStorage?: readonly KvStorageTier<ProcessStateSnapshot<TState>>[];
-	};
-}
-
-/**
- * Result handle returned by {@link processManager}.
- */
-export interface ProcessManagerResult<TState> {
-	/**
-	 * Reactive audit log of every process instance state transition.
-	 * Every `start()`, step result, retry, cancellation, and compensation
-	 * appends a {@link ProcessInstance} record.
-	 */
-	readonly instances: ReactiveLogBundle<ProcessInstance<TState>>;
-	/**
-	 * Read-only view of {@link instances} (Audit 2 `.audit` duplication
-	 * convention; M7 — cannot mutate the canonical log via the alias).
-	 */
-	readonly audit: ReadonlyAuditLog<ProcessInstance<TState>>;
-	/**
-	 * Start a new process instance identified by `correlationId`.
-	 *
-	 * Emits a synthetic `_process_<name>_started` event into the CQRS graph
-	 * with `correlationId` as `aggregateId` so per-aggregate streams record
-	 * the process lifecycle. If the correlationId already has an active
-	 * (running) instance, this call is a no-op (idempotent).
-	 *
-	 * @param correlationId - Stable key for this workflow instance.
-	 * @param initialPayload - Optional payload carried on the start event.
-	 */
-	start(correlationId: string, initialPayload?: unknown): void;
-	/**
-	 * Cancel a running instance by correlationId.
-	 *
-	 * Triggers the `compensate` handler (if configured), then marks the
-	 * instance as `"cancelled"`. If the instance is not running, this is
-	 * a no-op.
-	 *
-	 * @param correlationId - Instance to cancel.
-	 * @param reason - Optional human-readable reason recorded in the audit log.
-	 */
-	cancel(correlationId: string, reason?: string): void;
-	/**
-	 * Synchronous read of the current in-memory state for a correlationId.
-	 * Returns `undefined` if the instance does not exist or has terminated.
-	 */
-	getState(correlationId: string): TState | undefined;
-	/**
-	 * Reactive lifecycle of the restore pipeline. Typed as the central
-	 * {@link StatusValue} enum (`"pending" | "running" | "completed" | "errored"`);
-	 * the process-manager restore state machine currently emits the `"pending"`
-	 * and `"completed"` literals only — `"running"` / `"errored"` reserved
-	 * for future fine-grained restore observability. Starts at `"pending"`,
-	 * flips to `"completed"` once snapshot loads complete (or immediately when
-	 * no `stateStorage` is configured). On {@link dispose}, the node receives
-	 * TEARDOWN via the standard subgraph teardown cascade — there is no
-	 * `"disposed"` literal; consumers detect tear-down via subscription
-	 * COMPLETE on {@link dispose}. Watched events are valve-gated on this
-	 * node: dispatch is blocked while `restoreState !== "completed"`.
-	 *
-	 * Exposed for observability and tests. Subscribers can compose
-	 * `derived([restoreState], …)` to build their own gates / readouts.
-	 */
-	readonly restoreState: Node<StatusValue>;
-	/**
-	 * Trigger restoration of running instances from the first
-	 * {@link ProcessManagerOpts.persistence.stateStorage} tier (Tier 6.5
-	 * 3.5, 2026-04-29). Loads every record in the tier reactively and
-	 * re-hydrates `instanceStates` / `activeInstances` / `startedAt` for
-	 * any record whose `status === "running"`. Terminal records, if any
-	 * persisted before delete fired, are silently skipped.
-	 *
-	 * **Reactive composition (B5 — locked 2026-05-01):** internally,
-	 * `tier.list()` and `tier.load()` are wrapped in `fromAny` sources
-	 * (handles sync values, Promises, async iterables, and existing Nodes
-	 * uniformly per `~/src/graphrefly/COMPOSITION-GUIDE.md` §3 source
-	 * bridging); a `mergeMap` flattens per-key load results; an `effect`
-	 * populates closure state and flips {@link restoreState} to
-	 * `"completed"` on the `COMPLETE` boundary. No `await` inside the
-	 * reactive interior — the single async boundary is the returned
-	 * `Promise<void>`, which resolves when {@link restoreState} transitions
-	 * to `"completed"` OR when {@link dispose} tears down the restore node
-	 * (in which case `firstWhere`'s COMPLETE-rejection is swallowed and
-	 * the promise resolves to `undefined`).
-	 *
-	 * Idempotent — calling twice subscribes to the same restore pipeline
-	 * and resolves on the same gate flip. No-op when no `stateStorage`
-	 * tier is configured OR the first tier lacks a `list?` method:
-	 * `restoreState` flips to `"completed"` immediately so watches can arm.
-	 *
-	 * **Auto-restore default.** With `deferRestore: false` (the default),
-	 * the factory invokes `restore()` once at construction so callers do
-	 * not need to remember to wire it. Pass `deferRestore: true` to
-	 * suppress auto-restore and call `restore()` manually.
-	 */
-	restore(): Promise<void>;
-	/**
-	 * Release all watched-event subscriptions and stop processing new events.
-	 *
-	 * After `dispose()`, subsequent `start()` and `cancel()` calls are no-ops.
-	 * In-flight async steps complete naturally; no new steps are dispatched.
-	 *
-	 * Tears down the {@link restoreState} node via the standard subgraph
-	 * teardown cascade. Any pending `restore()` Promise resolves (the
-	 * COMPLETE-rejection from `firstWhere` is swallowed at the API edge);
-	 * the watch valve closes via TEARDOWN propagation; no further dispatch
-	 * even if a `fromAny(tier.load…)` would resolve later (the per-key
-	 * load source's cleanup sets `settled = true`, dropping the late DATA).
-	 */
-	dispose(): void;
-}
-
-// ---------------------------------------------------------------------------
-// Internal helpers
-// ---------------------------------------------------------------------------
-
-/**
- * Materialise a `NodeInput<T>` into a Promise.
- * Uses `fromAny` to normalise Node / Promise / iterable / scalar, then
- * collects the first DATA message.
- *
- * - If `input` is `null` or `undefined`, resolves immediately with `undefined`
- *   (skips constructing a `fromAny` source).
- * - On COMPLETE without prior DATA, resolves with `undefined` (supports `void`
- *   compensate handlers whose `NodeInput<void>` delivers COMPLETE only).
- *
- * Implementation note: `fromAny` over a scalar (e.g. `void` / `undefined`) or
- * sync iterable delivers DATA synchronously inside `n.subscribe()`, BEFORE the
- * `subscribe()` call returns. We therefore use `let unsub` (not `const`) and
- * avoid calling `unsub()` until after `subscribe()` has returned — deferring
- * the cleanup to a microtask via `Promise.resolve().then(unsub)` to sidestep
- * the Temporal Dead Zone.
- */
-function toPromise<T>(input: NodeInput<T>): Promise<T> {
-	// Short-circuit: null/undefined input resolves immediately.
-	if (input == null) return Promise.resolve(undefined as T);
-
-	const n = fromAny<T>(input);
-	return new Promise<T>((resolve, reject) => {
-		let settled = false;
-		// `let` instead of `const` so that synchronous DATA delivery during
-		// n.subscribe() (before the assignment completes) doesn't hit TDZ.
-		let unsub: (() => void) | undefined;
-		const cleanup = () => {
-			if (unsub) {
-				unsub();
-			}
-		};
-		unsub = n.subscribe((msgs) => {
-			if (settled) return;
-			for (const m of msgs) {
-				if (m[0] === DATA) {
-					settled = true;
-					// Defer cleanup to after the subscribe() call returns (TDZ-safe).
-					Promise.resolve().then(cleanup);
-					resolve(m[1] as T);
-					return;
-				}
-				if (m[0] === ERROR) {
-					settled = true;
-					Promise.resolve().then(cleanup);
-					reject(m[1] as unknown);
-					return;
-				}
-				if (m[0] === COMPLETE) {
-					// COMPLETE without prior DATA — resolve with undefined.
-					// Supports void compensate handlers that return without emitting DATA.
-					settled = true;
-					Promise.resolve().then(cleanup);
-					resolve(undefined as T);
-					return;
-				}
-			}
-		});
-	});
-}
-
-/** Run `step(state, event)` with retry logic. Returns the step result. */
-async function runWithRetry<TState>(
-	step: (state: TState, event: CqrsEvent) => NodeInput<ProcessStepResult<TState>>,
-	state: TState,
-	event: CqrsEvent,
-	retryMax: number,
-	backoffMs: readonly number[],
-): Promise<ProcessStepResult<TState>> {
-	let lastError: unknown;
-	for (let attempt = 0; attempt <= retryMax; attempt++) {
-		if (attempt > 0) {
-			// Sanctioned setTimeout for retry backoff in coordinator primitives.
-			// Same pattern as extra/resilience.ts retry implementation.
-			const delayMs = backoffMs[Math.min(attempt - 1, backoffMs.length - 1)] ?? 0;
-			if (delayMs > 0) {
-				await new Promise<void>((r) => setTimeout(r, delayMs));
-			}
-		}
-		try {
-			const result = await toPromise(step(state, event));
-			return result;
-		} catch (err) {
-			lastError = err;
-			// If we've exhausted retries, fall through to return a fail result.
-		}
-	}
-	return { outcome: "failure", error: lastError };
-}
-
-// ---------------------------------------------------------------------------
-// processManager factory
-// ---------------------------------------------------------------------------
-
-/**
- * Create a process manager that coordinates long-running reactive workflows
- * over a {@link CqrsGraph}.
- *
- * Process instances are identified by `correlationId`. Events from the watched
- * event types are routed to per-instance step handlers when the event's
- * `correlationId` matches a running instance.
- *
- * ```ts
- * const app = cqrs<{ orderPlaced: { orderId: string }; paymentReceived: { amount: number } }>("orders");
- *
- * const pm = processManager(app, "fulfillment", {
- *   initial: { step: "awaiting-payment", total: 0 },
- *   watching: ["orderPlaced", "paymentReceived"],
- *   steps: {
- *     orderPlaced(state, event) {
- *       return { outcome: "success", state: { ...state, orderId: event.payload.orderId } };
- *     },
- *     paymentReceived(state, event) {
- *       return { outcome: "terminate", state: { ...state, total: event.payload.amount } };
- *     },
- *   },
- *   compensate(state, _error) {
- *     // undo reservation, issue refund, etc.
- *   },
- *   retryMax: 2,
- *   backoffMs: [100, 500],
- * });
- *
- * pm.start("order-123");
- * app.dispatch("orderPlaced", { orderId: "order-123" }, { correlationId: "order-123" });
- * ```
- *
- * @param cqrsGraph - The CQRS graph whose event streams the manager watches.
- * @param name - Stable identifier for this process type; used for the
- *   synthetic event-type prefix `_process_<name>_*`. Currently emits
- *   `_process_<name>_started` per `start()`; the prefix is reserved for
- *   future `_state` / `_timer` channels.
- * @param opts - Configuration: initial state, watched events, steps, retry,
- *   compensation, and optional persistence.
- * @returns {@link ProcessManagerResult} with `instances` audit log and
- *   `start`, `cancel`, `getState` imperative controls.
- *
- * @category patterns
- */
-export function processManager<TState, EM extends CqrsEventMap = Record<string, unknown>>(
-	cqrsGraph: CqrsGraph<EM>,
-	name: string,
-	opts: ProcessManagerOpts<TState, EM>,
-): ProcessManagerResult<TState> {
-	const retryMax = opts.retryMax ?? 0;
-	const backoffMs: readonly number[] = opts.backoffMs ?? [0];
-	const retainedLimit = 1024;
-
-	// ── Per-instance in-memory state ──────────────────────────────────────
-	// Map from correlationId → current TState for running instances.
-	// Imperative coordinator state — documented pattern for this primitive.
-	const instanceStates = new Map<string, TState>();
-	// Track which instances are "active" (running) to prevent double-start
-	// and to gate step delivery.
-	const activeInstances = new Set<string>();
-	// Track startedAt per instance.
-	const startedAt = new Map<string, number>();
-
-	// ── Audit log + seq cursor ────────────────────────────────────────────
-	// EH-16 (Tier 6.5 3.3, 2026-04-29): the audit log + seq cursor are
-	// mounted under a per-instance child Graph (`__processManagers__/<name>`)
-	// rather than directly under `cqrsGraph._nodes`. `dispose()` then calls
-	// `cqrsGraph.remove(...)` to unmount the subgraph cleanly via the
-	// existing mount/removeMount lifecycle — no leaked nodes after repeated
-	// create/dispose cycles. Pre-1.0 path-schema change: paths shift from
-	// `${name}_process_instances` / `${name}_process_seq` (top-level) to
-	// `__processManagers__/${name}::instances` / `::seq` (mounted).
-	const mountName = `__processManagers__/${name}`;
-	const subgraph = new Graph(name);
-	try {
-		cqrsGraph.mount(mountName, subgraph);
-	} catch (err) {
-		// `Graph.mount` throws if the mount name is in use; surface a
-		// processManager-specific message so callers see actionable context.
-		const detail = err instanceof Error ? err.message : String(err);
-		throw new Error(
-			`processManager: name "${name}" is already in use on this CQRS graph ` +
-				`(mount path "${mountName}" collides). Call .dispose() on the prior ` +
-				`manager OR pick a different name before re-creating. (${detail})`,
-		);
-	}
-
-	const instances = createAuditLog<ProcessInstance<TState>>({
-		name: "instances",
-		retainedLimit,
-		graph: subgraph,
-	});
-
-	// Tier 8 γ-7-A (2026-04-28): seq cursor promoted from `let seq = 0` closure
-	// to a `state(0)` node mounted on the per-process subgraph (visible in
-	// `describe()` at `__processManagers__/<name>::seq`). The audit-record
-	// stamping routes through `mutate` for centralized freeze + seq
-	// advance + `handlerVersion` stamping + batch-frame rollback. The batch
-	// frame closes EH-17 (re-entrancy hazard).
-	const seqCursor = registerCursor(subgraph, "seq", 0);
-
-	// D4 (qa lock): `freeze: true` so step-handler-supplied state values
-	// captured into audit records cannot be mutated post-record. Process
-	// states are typically small workflow records (an order ID + a few
-	// flags), so the `deepFreeze` tax is negligible — the safety vs. mutation
-	// trade-off favors freeze. (The 768-dim-vector concern that motivates
-	// `freeze: false` in memory primitives doesn't apply here.)
-	const appendRecord = mutate<
-		[string, TState, ProcessInstance<TState>["status"], string | undefined],
-		void,
-		ProcessInstance<TState>
-	>(
-		// No closure-state mutation in the action — the audit-record append IS
-		// the effect, performed by the framework via `onSuccessRecord`.
-		() => undefined,
-		{
-			frame: "transactional",
-			log: instances,
-			seq: seqCursor,
-			freeze: true,
-			...(opts.handlerVersion !== undefined ? { handlerVersion: opts.handlerVersion } : {}),
-			onSuccessRecord: ([correlationId, state, status, reason], _r, { t_ns, seq }) => ({
-				correlationId,
-				state,
-				status,
-				startedAt: startedAt.get(correlationId) ?? t_ns,
-				updatedAt: t_ns,
-				t_ns,
-				seq: seq ?? 0,
-				...(reason !== undefined ? { reason } : {}),
-			}),
-		},
-	);
-
-	// ── State-snapshot persistence (Tier 6.5 3.5) ─────────────────────────
-	const stateStorageTiers = opts.persistence?.stateStorage ?? [];
-
-	/**
-	 * Build the snapshot payload + iterate tiers. Returns the iterator over
-	 * tiers so the caller decides whether sync throws propagate (B4 — start
-	 * path inside mutate) or are swallowed (step path, fire-and-forget).
-	 */
-	const buildSnapshot = (
-		correlationId: string,
-		status: ProcessStateSnapshot<TState>["status"],
-	): ProcessStateSnapshot<TState> | undefined => {
-		const stateValue = instanceStates.get(correlationId);
-		if (stateValue === undefined) return undefined;
-		return {
-			correlationId,
-			state: stateValue,
-			status,
-			startedAt: startedAt.get(correlationId) ?? wallClockNs(),
-			updatedAt: wallClockNs(),
-			...(opts.handlerVersion !== undefined ? { handlerVersion: opts.handlerVersion } : {}),
-		};
-	};
-
-	/**
-	 * Best-effort persistence (used by step transitions). Sync throws are
-	 * swallowed so persistence failures do NOT poison reactive step dispatch.
-	 * Async rejections are caught at the Promise boundary.
-	 */
-	const persistState = (
-		correlationId: string,
-		status: ProcessStateSnapshot<TState>["status"],
-	): void => {
-		if (stateStorageTiers.length === 0) return;
-		const snapshot = buildSnapshot(correlationId, status);
-		if (snapshot === undefined) return;
-		for (const tier of stateStorageTiers) {
-			try {
-				const r = tier.save(correlationId, snapshot);
-				// Tier may return Promise — fire-and-forget. Storage errors
-				// surface via the tier's own onError plumbing (Tier 4 storage).
-				if (r != null && typeof (r as Promise<void>).then === "function") {
-					(r as Promise<void>).catch(() => undefined);
-				}
-			} catch {
-				// best-effort; persistence failures don't block step execution
-			}
-		}
-	};
-
-	/**
-	 * Throwing variant (B4 — used inside `startInternal`'s mutate
-	 * action body so a sync-throwing tier rolls back the audit-log append +
-	 * seq cursor advance). Async rejections from `tier.save()` still cannot
-	 * unwind the synchronous batch frame — that's a known limitation of
-	 * Promise-returning storage; sync-throwing tiers (the actual D2 hazard)
-	 * are fully covered.
-	 */
-	const persistStateThrowing = (
-		correlationId: string,
-		status: ProcessStateSnapshot<TState>["status"],
-	): void => {
-		if (stateStorageTiers.length === 0) return;
-		const snapshot = buildSnapshot(correlationId, status);
-		if (snapshot === undefined) return;
-		for (const tier of stateStorageTiers) {
-			const r = tier.save(correlationId, snapshot);
-			if (r != null && typeof (r as Promise<void>).then === "function") {
-				(r as Promise<void>).catch(() => undefined);
-			}
-		}
-	};
-	const removeState = (correlationId: string): void => {
-		if (stateStorageTiers.length === 0) return;
-		for (const tier of stateStorageTiers) {
-			if (!tier.delete) continue;
-			try {
-				const r = tier.delete(correlationId);
-				if (r != null && typeof (r as Promise<void>).then === "function") {
-					(r as Promise<void>).catch(() => undefined);
-				}
-			} catch {
-				// best-effort
-			}
-		}
-	};
-
-	// ── Synthetic event helpers ───────────────────────────────────────────
-	const startedEventType = `_process_${name}_started`;
-
-	// Pre-register the started event stream so it appears in describe().
-	// Side-effect events (result.emit) dispatch using their own declared event type
-	// via _appendEvent directly — no separate state event stream needed.
-	cqrsGraph.event(startedEventType);
-
-	// Wire persistence: event storage for synthetic state stream.
-	if (opts.persistence?.eventStorage) {
-		cqrsGraph.attachEventStorage(opts.persistence.eventStorage);
-	}
-
-	// ── Compensation helper ───────────────────────────────────────────────
-	async function runCompensate(
-		correlationId: string,
-		state: TState,
-		error: unknown,
-		reason?: string,
-	): Promise<void> {
-		// Eagerly remove from active state BEFORE any await so that concurrent
-		// cancel() calls or in-flight step completions that arrive while we are
-		// awaiting the compensate handler find the instance already gone and
-		// exit early (C1 — double-compensation race fix).
-		activeInstances.delete(correlationId);
-		instanceStates.delete(correlationId);
-		startedAt.delete(correlationId);
-
-		if (opts.compensate) {
-			try {
-				await toPromise(opts.compensate(state, error) as NodeInput<void>);
-				appendRecord(correlationId, state, "cancelled", reason);
-				removeState(correlationId);
-			} catch (_compErr) {
-				// Compensation itself failed — still mark as errored so instance
-				// doesn't stay in limbo. Swallow error to prevent cascading.
-				appendRecord(correlationId, state, "errored", undefined);
-				removeState(correlationId);
-			}
-		} else {
-			appendRecord(correlationId, state, "errored", undefined);
-			removeState(correlationId);
-		}
-	}
-
-	// ── Step result handler ───────────────────────────────────────────────
-	async function handleStepResult(
-		correlationId: string,
-		result: ProcessStepResult<TState>,
-	): Promise<void> {
-		if (!activeInstances.has(correlationId)) return; // cancelled during async step
-
-		if (result.outcome === "failure") {
-			// Capture state before eager delete (C1 — step-fail eager-delete).
-			const state = instanceStates.get(correlationId) ?? opts.initial;
-			// runCompensate handles the eager delete; the early-exit guard above
-			// ensures we won't double-compensate for an already-inactive instance.
-			await runCompensate(correlationId, state, result.error);
-			return;
-		}
-
-		if (result.outcome === "success") {
-			instanceStates.set(correlationId, result.state);
-
-			// Emit side-effect CQRS events.
-			if (result.emit) {
-				for (const ev of result.emit) {
-					// Dispatch via _appendEvent is internal. Use a synthetic command
-					// channel via the public `dispatch` API by pre-registering a
-					// passthrough command, OR emit directly via an internal event.
-					// Strategy: use event stream directly — the process manager is
-					// an internal coordinator allowed to call internal CQRS APIs.
-					// We use the synthetic stateEventType to carry side-effect events
-					// so they appear in the aggregate stream.
-					try {
-						// Emit side-effect events using the process state event stream with
-						// the correlationId as aggregateId, but use the declared event type
-						// as the type field for downstream sagas/projections to react to.
-						// We do this by directly dispatching into the CQRS graph via the
-						// dedicated per-process synthetic event channel.
-						(
-							cqrsGraph as unknown as {
-								_appendEvent(
-									name: string,
-									payload: unknown,
-									extra?: { correlationId?: string; aggregateId?: string },
-								): void;
-							}
-						)._appendEvent(ev.type, ev.payload, {
-							correlationId,
-							aggregateId: correlationId,
-						});
-					} catch (_emitErr) {
-						// Non-fatal: side-effect event emission failures are not
-						// step-fatal (they are fire-and-forget coordination signals).
-					}
-				}
-			}
-
-			appendRecord(correlationId, result.state, "running", undefined);
-			persistState(correlationId, "running");
-
-			// Check isTerminal predicate.
-			if (opts.isTerminal?.(result.state)) {
-				activeInstances.delete(correlationId);
-				instanceStates.delete(correlationId);
-				startedAt.delete(correlationId); // M3 — cleanup startedAt on isTerminal terminate
-				appendRecord(correlationId, result.state, "completed", undefined);
-				removeState(correlationId);
-				return;
-			}
-
-			// Handle schedule: fire synthetic event after delay via fromTimer.
-			if (result.schedule) {
-				const { afterMs, eventType } = result.schedule;
-				// fromTimer per spec §5.8 — reactive timer source.
-				// Subscribe to fire once and deliver the synthetic event.
-				// M6: use `let timerUnsub` + TDZ guard to avoid referencing the
-				// variable before its assignment if the callback fires synchronously.
-				let timerUnsub: (() => void) | undefined;
-				const timerNode = fromTimer(afterMs);
-				const timerCb: Parameters<typeof timerNode.subscribe>[0] = (msgs) => {
-					for (const m of msgs) {
-						if (m[0] === DATA) {
-							// TDZ guard: if subscribe() hasn't returned yet, defer cleanup.
-							if (timerUnsub) {
-								timerUnsub();
-							} else {
-								// fromTimer is async (setTimeout-backed) so this path is
-								// never hit in practice, but guard for safety.
-								queueMicrotask(() => timerUnsub?.());
-							}
-							if (!activeInstances.has(correlationId)) return;
-							const currentState = instanceStates.get(correlationId);
-							if (currentState === undefined) return;
-							const step = (
-								opts.steps as unknown as Record<string, ProcessStep<TState, EM, string>>
-							)[eventType];
-							if (!step) return;
-							const syntheticEvent: CqrsEvent = {
-								type: eventType,
-								// m5: null payload (not undefined) to avoid soft §1.2 risk.
-								// seq: Number.NaN — sentinel for synthetic events that do not
-								// participate in cross-event ordering.
-								payload: null,
-								timestampNs: wallClockNs(),
-								seq: Number.NaN,
-								correlationId,
-								aggregateId: correlationId,
-							};
-							dispatchStep(correlationId, step, currentState, syntheticEvent);
-						}
-					}
-				};
-				timerUnsub = timerNode.subscribe(timerCb);
-			}
-			return;
-		}
-
-		if (result.outcome === "terminate") {
-			instanceStates.set(correlationId, result.state);
-			// Emit side-effect events.
-			if (result.emit) {
-				for (const ev of result.emit) {
-					try {
-						(
-							cqrsGraph as unknown as {
-								_appendEvent(
-									name: string,
-									payload: unknown,
-									extra?: { correlationId?: string; aggregateId?: string },
-								): void;
-							}
-						)._appendEvent(ev.type, ev.payload, {
-							correlationId,
-							aggregateId: correlationId,
-						});
-					} catch (_emitErr) {
-						// non-fatal
-					}
-				}
-			}
-			activeInstances.delete(correlationId);
-			instanceStates.delete(correlationId);
-			startedAt.delete(correlationId); // M3 — cleanup startedAt on terminate
-			appendRecord(correlationId, result.state, "completed", undefined);
-			removeState(correlationId);
-		}
-	}
-
-	// ── Step dispatch ─────────────────────────────────────────────────────
-	// C2: Per-correlationId in-flight serialization map.
-	// Multiple events for the same correlationId in one DATA wave both read the
-	// same instanceStates snapshot if dispatched concurrently. Serializing via a
-	// promise chain ensures the second step sees the first step's written state.
-	// Cross-correlationId events still parallelize (separate map entries).
-	const inFlight = new Map<string, Promise<void>>();
-
-	function dispatchStep(
-		correlationId: string,
-		step: ProcessStep<TState, EM, string>,
-		_state: TState, // C2: state is re-read inside the serialized closure; this param is kept for call-site clarity
-		event: CqrsEvent,
-	): void {
-		const prior = inFlight.get(correlationId) ?? Promise.resolve();
-		const next = prior.then(async () => {
-			// Re-read current state at execution time (prior steps may have updated it).
-			const currentState = instanceStates.get(correlationId);
-			if (currentState === undefined) return; // instance was cancelled/terminated in prior step
-			if (!activeInstances.has(correlationId)) return;
-			let result: ProcessStepResult<TState>;
-			try {
-				result = await runWithRetry(
-					step as (s: TState, e: CqrsEvent) => NodeInput<ProcessStepResult<TState>>,
-					currentState,
-					event,
-					retryMax,
-					backoffMs,
-				);
-			} catch (err) {
-				// runWithRetry itself should not throw (it returns fail on exhaustion),
-				// but guard against unexpected errors.
-				await runCompensate(correlationId, instanceStates.get(correlationId) ?? opts.initial, err);
-				return;
-			}
-			await handleStepResult(correlationId, result);
-		});
-		inFlight.set(correlationId, next);
-		next.finally(() => {
-			if (inFlight.get(correlationId) === next) inFlight.delete(correlationId);
-		});
-	}
-
-	// C3: disposal flag — set true by dispose(); gates start() and cancel().
-	// Synchronous liveness check used by start() / cancel() to avoid
-	// reaching into the reactive layer (and to short-circuit before the
-	// teardown cascade has propagated through restoreState).
-	let _disposed = false;
-
-	// ── Restore lifecycle state (B5 — locked 2026-05-01; post-fix using
-	// central StatusValue enum 2026-05-01) ───────────────────────────────
-	// Reactive lifecycle node typed as the central StatusValue enum
-	// (`"pending" | "running" | "completed" | "errored"`). Currently emits
-	// the "pending" → "completed" subset only:
-	//   "pending"   → constructed; restore not yet finished. Watched events
-	//                 arrive at the source but are valve-blocked from
-	//                 reaching step dispatch.
-	//   "completed" → restoration complete. Watch valve is open; events
-	//                 accumulated during "pending" are delivered as the
-	//                 latest cumulative cqrs log array; the per-watch
-	//                 cursor catches up to that array in one step.
-	//   ("running" / "errored" reserved for future fine-grained restore
-	//    observability; not emitted today.)
-	// Disposal: no "disposed" literal — dispose() unmounts the subgraph
-	// which TEARDOWNs restoreState; the gateOpen valve closes via standard
-	// cascade; pending restore() Promise resolves via the .catch at the
-	// public API edge.
-	const restoreState = node<StatusValue>([], {
-		initial: "pending",
-		name: "restoreState",
-		describeKind: "state",
-	});
-	subgraph.add(restoreState, { name: "restoreState" });
-
-	// `gateOpen` is the valve control: true only while
-	// restoreState === "completed". Lazy: activates when the first valve
-	// subscribes.
-	const gateOpen = node<boolean>(
-		[restoreState as Node],
-		(data, a, ctx) => {
-			const batch0 = data[0];
-			const v = (batch0 != null && batch0.length > 0 ? batch0.at(-1) : ctx.prevData[0]) as
-				| StatusValue
-				| undefined;
-			a.emit(v === "completed");
-		},
-		{ name: "gateOpen", describeKind: "derived" },
-	);
-	subgraph.add(gateOpen, { name: "gateOpen" });
-
-	// ── Watched event subscriptions (valve-gated) ────────────────────────
-	// COMPOSITION-GUIDE §28 cursor pattern + valve(eventNode, gateOpen):
-	// per watched event type, subscribe to a valve over the cqrs event
-	// stream. While restoreState !== "completed", valve emits RESOLVED so
-	// no DATA reaches the cursor — events are NOT lost; the cqrs event
-	// log retains them. When the gate flips open, valve re-emits the
-	// latest cumulative event array (control-only wave path inside
-	// `valve`); the cursor processes everything from `lastCount` (still
-	// 0 at that point) in one shot.
-	const watchDisposers: Array<() => void> = [];
-
-	for (const eventType of opts.watching) {
-		const eventNode = cqrsGraph.event(eventType as string);
-		const gated = valve(eventNode, gateOpen, { name: `gatedEvent:${eventType as string}` });
-
-		// Cursor starts at 0 — pre-restore events are NOT pre-counted because
-		// they may be pre-restart events that the persisted snapshot already
-		// consumed. The restore pipeline's job is to seed instanceStates /
-		// activeInstances; events for instances NOT in activeInstances after
-		// restore drop on the floor (the per-event activeInstances.has guard).
-		let lastCount = 0;
-
-		const unsub = gated.subscribe((msgs: Messages) => {
-			for (const m of msgs) {
-				if (m[0] !== DATA) continue;
-				const events = m[1] as readonly CqrsEvent[];
-				if (events.length <= lastCount) continue;
-				const newEvents = events.slice(lastCount);
-				lastCount = events.length;
-
-				for (const ev of newEvents) {
-					const corrId = ev.correlationId;
-					if (corrId === undefined) continue;
-					if (!activeInstances.has(corrId)) continue;
-
-					const step = (opts.steps as unknown as Record<string, ProcessStep<TState, EM, string>>)[
-						eventType as string
-					];
-					if (!step) continue;
-
-					const state = instanceStates.get(corrId);
-					if (state === undefined) continue;
-
-					dispatchStep(corrId, step, state, ev);
-				}
-			}
-		});
-		watchDisposers.push(unsub);
-	}
-
-	// ── Public API ────────────────────────────────────────────────────────
-
-	// Tier 8 γ-7-A (2026-04-28): `start()` body is mutate-wrapped so the
-	// synthetic-start-event emit + the running audit record commit in one
-	// batch frame. If `_appendEvent` throws (e.g. event stream terminated),
-	// mutate rolls back the in-band batch (audit append discarded, seq
-	// cursor advance discarded) and re-throws to the caller. Pre-1.0 behavior
-	// change vs. γ-7-B: the previous form silently swallowed `_appendEvent`
-	// failures and still appended the running record. Per COMPOSITION-GUIDE
-	// §35, closure mutations are NOT rolled back — so they are deferred to
-	// after `_appendEvent` succeeds inside the action body.
-	//
-	// B4 (D2 — locked 2026-05-01): `persistState(...)` lives INSIDE the action
-	// body (after the closure mutations that seed `instanceStates`) so a
-	// sync-throwing `stateStorage` tier rolls back the in-band batch the same
-	// way `_appendEvent` failures do — neither the audit log entry nor the
-	// state snapshot ends up in the "running" record store. Per §35 the
-	// closure mutations stay (instanceStates / activeInstances / startedAt
-	// are already set), but the audit-log + persisted-snapshot are coherent
-	// with each other: both absent on throw, both present on success.
-	const startInternal = mutate<[string, unknown], void, ProcessInstance<TState>>(
-		(correlationId, initialPayload) => {
-			// Synthetic start event first (potentially throws). Closure
-			// mutations below only run if this call succeeds — per §35,
-			// rollback does not undo them, so they must come after the
-			// throwing work.
-			(
-				cqrsGraph as unknown as {
-					_appendEvent(
-						name: string,
-						payload: unknown,
-						extra?: { correlationId?: string; aggregateId?: string },
-					): void;
-				}
-			)._appendEvent(startedEventType, initialPayload ?? null, {
-				correlationId,
-				aggregateId: correlationId,
-			});
-			startedAt.set(correlationId, wallClockNs());
-			instanceStates.set(correlationId, opts.initial);
-			activeInstances.add(correlationId);
-			// B4: inside the rollback boundary so a sync-throwing tier
-			// discards the audit-log append + seq cursor advance.
-			persistStateThrowing(correlationId, "running");
-		},
-		{
-			frame: "transactional",
-			log: instances,
-			seq: seqCursor,
-			freeze: true,
-			...(opts.handlerVersion !== undefined ? { handlerVersion: opts.handlerVersion } : {}),
-			onSuccessRecord: ([correlationId], _r, { t_ns, seq }) => ({
-				correlationId,
-				state: opts.initial,
-				status: "running",
-				startedAt: startedAt.get(correlationId) ?? t_ns,
-				updatedAt: t_ns,
-				t_ns,
-				seq: seq ?? 0,
-			}),
-		},
-	);
-
-	/**
-	 * Start a new process instance.
-	 *
-	 * Idempotent: if a running instance with the same `correlationId` already
-	 * exists, the call is a no-op. Also a no-op after `dispose()`.
-	 *
-	 * **Throws** if the synthetic `_process_<name>_started` event stream is
-	 * terminated (γ-7-A, 2026-04-28). The audit log is not appended in that
-	 * case — the in-band batch rolls back so the seq cursor and audit log
-	 * stay consistent with the pre-call state.
-	 */
-	function start(correlationId: string, initialPayload?: unknown): void {
-		if (_disposed) return;
-		if (activeInstances.has(correlationId)) return;
-		// B4 (D2): persistState now lives INSIDE `startInternal`'s mutate
-		// action body so sync-throwing tiers roll back the audit-log entry too.
-		startInternal(correlationId, initialPayload);
-	}
-
-	/**
-	 * Cancel a running instance and trigger compensation.
-	 *
-	 * No-op if the instance is not currently running (or after `dispose()`).
-	 */
-	function cancel(correlationId: string, reason?: string): void {
-		if (_disposed) return;
-		if (!activeInstances.has(correlationId)) return;
-
-		// Capture state before the async compensate path.
-		const state = instanceStates.get(correlationId) ?? opts.initial;
-		// Run compensation asynchronously (fire-and-forget from caller perspective).
-		// C1: runCompensate does the eager activeInstances.delete before any await,
-		// so concurrent calls or in-flight steps that complete concurrently find the
-		// instance already removed and exit early.
-		// M4: pass reason through so it lands on the audit record.
-		runCompensate(
-			correlationId,
-			state,
-			new Error(`cancelled: ${reason ?? "no reason given"}`),
-			reason,
-		);
-	}
-
-	/**
-	 * Read the current in-memory state for a correlationId.
-	 *
-	 * Returns `undefined` if the instance does not exist or has terminated.
-	 */
-	function getState(correlationId: string): TState | undefined {
-		return instanceStates.get(correlationId);
-	}
-
-	/**
-	 * Reactive restore pipeline (B5 — locked 2026-05-01; post-fix using
-	 * fromAny + StatusValue 2026-05-01).
-	 *
-	 * `restoreSubscription` is the single keepalive over the snapshot-load
-	 * effect. Set on first `restore()` call (or on construction when
-	 * `deferRestore !== true`). The effect:
-	 *
-	 * 1. Subscribes to `mergeMap(fromAny(tier.list()), keys =>
-	 *    mergeMap(fromIter(keys), key => fromAny(tier.load(key))))` —
-	 *    a fully reactive chain whose only async boundaries are the source
-	 *    `fromAny` nodes (spec §5.10). `fromAny` accepts sync values,
-	 *    Promises, async iterables, and existing Nodes — future-proof
-	 *    against tier impls that decide to expose paginated/streaming
-	 *    `list()` or batched `load()`.
-	 * 2. On each per-key load DATA, populates `instanceStates` /
-	 *    `activeInstances` / `startedAt` for `status === "running"` records.
-	 * 3. On `COMPLETE` (all loads finished), flips `restoreState` to
-	 *    `"completed"` — the watch valve opens, queued cqrs events become
-	 *    deliverable, and any `firstWhere(restoreState …)` awaiter resolves.
-	 *
-	 * Idempotent: subsequent calls reuse the same subscription and resolve
-	 * on the same gate flip.
-	 */
-	let restoreSubscription: (() => void) | undefined;
-
-	function startRestorePipeline(): void {
-		if (restoreSubscription !== undefined) return;
-		const tier = stateStorageTiers[0];
-		if (tier == null || tier.list == null || tier.load == null) {
-			// No snapshot tier — flip immediately so watches can arm.
-			// `restoreState` is a state node so write directly.
-			if (!_disposed) restoreState.emit("completed");
-			restoreSubscription = () => undefined;
-			return;
-		}
-		const tierLoad = tier.load.bind(tier);
-		const tierList = tier.list.bind(tier);
-
-		// Reactive source chain. `tier.list()` and `tier.load(key)` are the
-		// only async boundaries. Bridged via `fromAny`, which (post DS-13.5
-		// follow-up, 2026-05-01) treats sync iterables as single DATA values
-		// by default — `tier.list()`'s `readonly string[]` flows through as
-		// ONE DATA carrying the whole list, not as a per-key stream. Sync
-		// tier returns emit immediately at subscribe time; async tier
-		// returns emit on resolve.
-		const listSource = fromAny<readonly string[]>(tierList());
-		const flattened = mergeMap(listSource, (keys: readonly string[]) => {
-			if (keys.length === 0) {
-				// fromIter([]) emits no DATA, only COMPLETE — which
-				// propagates up through mergeMap so the effect sees its
-				// own COMPLETE.
-				return fromIter<ProcessStateSnapshot<TState> | undefined>([]);
-			}
-			// Inner: per-key load via fromAny, flattened across keys.
-			// Outer fromIter(keys) DOES want per-element emission here —
-			// each key triggers a fresh load via mergeMap.
-			return mergeMap(
-				fromIter(keys),
-				(key: string) => fromAny(tierLoad(key)) as Node<ProcessStateSnapshot<TState> | undefined>,
-				// Bound concurrent in-flight loads (D2, 2026-05-01) so a
-				// large persisted-instance count doesn't exhaust file
-				// handles / connection pools on the storage backend.
-				{ concurrent: opts.restoreConcurrency ?? 8 },
-			);
-		});
-
-		// Effect node: populate closure state on each load, flip the gate on
-		// COMPLETE. Reactive — no awaits.
-		//
-		// Re-entrancy guard (A3, 2026-05-01): wrap the closure-mutation loop
-		// + the gate flip in a single `batch()`. Without it, the synchronous
-		// `restoreState.emit("completed")` mid-fn-body would cascade through
-		// gateOpen → valves → cqrs cursors → step dispatch BEFORE the
-		// snapshot loop returns — external observers would see a half-
-		// populated `instanceStates` map.
-		//
-		// Mid-iteration dispose hoisting (A4, 2026-05-01): the `_disposed`
-		// check is hoisted to BEFORE the snapshot loop. The previous per-
-		// snapshot check leaked state when `dispose()` fired between
-		// snapshots N and N+1: snapshots 0..N populated `instanceStates`,
-		// then dispose flipped `_disposed`, the terminalDeps branch
-		// short-circuited the gate flip, and the cleanup path tore down the
-		// watch valve — leaving orphan entries that subsequent `start()`
-		// calls would treat as "already active" via `activeInstances.has`.
-		const restoreEffect = node(
-			[flattened as Node],
-			(data, _a, ctx) => {
-				if (_disposed) return;
-				const batch0 = data[0];
-				const hasSnapshots = batch0 != null && batch0.length > 0;
-				const allDone = ctx.terminalDeps[0] === true;
-				if (!hasSnapshots && !allDone) return;
-				batch(() => {
-					if (hasSnapshots) {
-						for (const snap of batch0 as readonly (ProcessStateSnapshot<TState> | undefined)[]) {
-							if (snap == null) continue;
-							if (snap.status !== "running") continue;
-							instanceStates.set(snap.correlationId, snap.state);
-							activeInstances.add(snap.correlationId);
-							startedAt.set(snap.correlationId, snap.startedAt);
-						}
-					}
-					if (allDone) restoreState.emit("completed");
-				});
-			},
-			{
-				name: "restoreEffect",
-				describeKind: "effect",
-				// Spec §2.7 R2.7.1 (DS-2.7.A). Empty-tier restore: `flattened`
-				// delivers COMPLETE without any DATA (no keys → inner
-				// `fromIter([])` COMPLETEs immediately). fn MUST fire on that
-				// terminal-only wave to call `restoreState.emit("completed")`
-				// — otherwise the watch valve never opens and dispatched
-				// events never reach `handleStepResult`.
-				terminalAsRealInput: true,
-			},
-		);
-		subgraph.add(restoreEffect, { name: "restoreEffect" });
-		restoreSubscription = restoreEffect.subscribe(() => undefined);
-	}
-
-	/**
-	 * Trigger restoration (idempotent) and return a Promise that resolves
-	 * when `restoreState` transitions to `"completed"` OR when {@link dispose}
-	 * tears down the restore node (firstWhere's COMPLETE-rejection is
-	 * swallowed at the API edge so the caller's promise settles cleanly).
-	 */
-	function restore(): Promise<void> {
-		startRestorePipeline();
-		if (_disposed) return Promise.resolve();
-		if (restoreState.cache === "completed") return Promise.resolve();
-		// firstWhere is the canonical reactive→Promise bridge (spec §5.10);
-		// async boundary lives at the public API edge, not in the graph.
-		// .catch distinguishes the COMPLETE-without-match shape (which is
-		// the dispose-tears-down case — swallow + resolve undefined) from
-		// any other rejection (re-throw — caller sees a real failure).
-		return firstWhere(restoreState, (s) => s === "completed")
-			.then(() => undefined)
-			.catch((err: unknown) => {
-				if (err instanceof Error && err.message === "completed without matching value") {
-					return undefined;
-				}
-				throw err;
-			});
-	}
-
-	function dispose(): void {
-		if (_disposed) return;
-		_disposed = true;
-		// Pending `firstWhere(restoreState, ...)` awaiters (i.e. a `restore()`
-		// Promise still waiting on the gate flip) settle via the framework's
-		// DS-13.5.A Q16 auto-precede rule: TEARDOWN delivery on a non-terminal
-		// node automatically prepends [COMPLETE] in `_frameBatch`, so sinks
-		// see [[COMPLETE], [TEARDOWN]] in order. firstWhere rejects on
-		// COMPLETE-without-match; the .catch in `restore()` swallows that
-		// rejection and the public Promise resolves cleanly.
-		// Tear down the restore pipeline keepalive. fromAny.cleanup sets
-		// `settled = true`, so when the underlying tier.list/load promises
-		// finally resolve, the DATA never propagates — the closure mutations
-		// in `restoreEffect` are never invoked (D5 belt + suspenders).
-		if (restoreSubscription) {
-			try {
-				restoreSubscription();
-			} catch {
-				// non-fatal
-			}
-			restoreSubscription = undefined;
-		}
-		// Release all watched-event subscriptions (C3 — watchDisposers leak fix).
-		for (const unsub of watchDisposers) {
-			try {
-				unsub();
-			} catch (_err) {
-				// non-fatal: best-effort teardown
-			}
-		}
-		watchDisposers.length = 0;
-		// EH-16 (Tier 6.5 3.3): unmount the per-instance subgraph so the
-		// audit log + seq cursor nodes are removed from the CQRS graph and
-		// don't leak across repeated create/dispose cycles. `Graph.remove`
-		// fires TEARDOWN through the subtree.
-		try {
-			cqrsGraph.remove(mountName);
-		} catch (_err) {
-			// non-fatal: best-effort teardown (e.g. cqrsGraph already destroyed)
-		}
-	}
-
-	// Auto-restore on construction unless explicitly deferred (B5).
-	if (opts.deferRestore !== true) {
-		startRestorePipeline();
-	}
-
-	return {
-		instances,
-		audit: readonlyAuditLog(instances),
-		restoreState,
-		start,
-		cancel,
-		getState,
-		restore,
-		dispose,
-	};
-}
diff --git a/src/utils/reactive-layout/index.ts b/src/utils/reactive-layout/index.ts
deleted file mode 100644
index d3f9d1f0..00000000
--- a/src/utils/reactive-layout/index.ts
+++ /dev/null
@@ -1,12 +0,0 @@
-/**
- * Reactive layout pattern — standalone subpath export.
- *
- * ```ts
- * import { reactiveLayout, CliMeasureAdapter } from "@graphrefly/graphrefly/utils/reactive-layout";
- * ```
- */
-
-export * from "./measurement-adapters.js";
-export * from "./reactive-block-layout.js";
-export * from "./reactive-flow-layout.js";
-export * from "./reactive-layout.js";
diff --git a/src/utils/reactive-layout/measurement-adapters.ts b/src/utils/reactive-layout/measurement-adapters.ts
deleted file mode 100644
index 682ad97b..00000000
--- a/src/utils/reactive-layout/measurement-adapters.ts
+++ /dev/null
@@ -1,500 +0,0 @@
-/**
- * MeasurementAdapter implementations (roadmap §7.1 — pluggable backends).
- *
- * All adapters implement {@link MeasurementAdapter} from `reactive-layout.ts`.
- * Sync constructors, sync `measureSegment()` — no async, no polling.
- */
-
-import { countCells } from "../../base/render/_ascii-width.js";
-import type { MeasurementAdapter, SegmentAdapter, SegmentInfo } from "./reactive-layout.js";
-
-// ---------------------------------------------------------------------------
-// IntlSegmentAdapter (universal default — wraps the platform `Intl.Segmenter`)
-// ---------------------------------------------------------------------------
-
-/**
- * Reference {@link SegmentAdapter} backed by the platform `Intl.Segmenter`
- * — the substrate's default on engines that ship `Intl.Segmenter` (V8,
- * SpiderMonkey, JSC, modern Node, browsers).
- *
- * **Hermes / RN consumers must not use this** — Hermes ships without
- * `Intl.Segmenter`, and the constructor below throws a clear `TypeError`
- * naming the polyfill path (`optimizations.md` 🟠 (d), 2026-05-20). Wire a
- * custom {@link SegmentAdapter} via `reactiveLayout({ segmentAdapter })`
- * instead — see the {@link SegmentAdapter} JSDoc for the recipe.
- *
- * Per-granularity `Intl.Segmenter` instances are lazy-cached internally
- * (matches the pre-DS module-scoped lazy that this class replaces — see
- * the pre-2026-05-20 `_graphemeSegmenter` helper in `reactive-layout.ts`).
- * Construction is eager (`new IntlSegmentAdapter()` throws on Hermes) so
- * the failure surfaces at factory boot, not at first text-measure call.
- *
- * @remarks
- * Construction policy is **fail-fast**: an engine without `Intl.Segmenter`
- * is fundamentally unable to use this adapter, and silently lazy-deferring
- * the throw would just shift it from `reactiveLayout({})` into the first
- * `analyzeAndMeasure` invocation deep in a reactive wave (the original
- * memo:Re Story 3.6 failure shape — non-resubscribable terminal on
- * `measured-blocks`, cryptic `Cannot read property 'prototype' of
- * undefined`). Eager throw with the polyfill recipe is the better DX.
- */
-export class IntlSegmentAdapter implements SegmentAdapter {
-	private wordSeg: Intl.Segmenter | null = null;
-	private graphemeSeg: Intl.Segmenter | null = null;
-
-	constructor() {
-		if (typeof Intl === "undefined" || typeof Intl.Segmenter !== "function") {
-			throw new TypeError(
-				"IntlSegmentAdapter: Intl.Segmenter is not available in this runtime " +
-					"(Hermes / older embedded JS engines). Pass a custom SegmentAdapter via " +
-					"`reactiveLayout({ segmentAdapter })` — see the SegmentAdapter JSDoc for the " +
-					"polyfill recipe (e.g. `intl-segmenter-polyfill` or `@formatjs/intl-segmenter`).",
-			);
-		}
-	}
-
-	segmentWords(text: string): Iterable<SegmentInfo> {
-		if (this.wordSeg === null) {
-			this.wordSeg = new Intl.Segmenter(undefined, { granularity: "word" });
-		}
-		return this.wordSeg.segment(text);
-	}
-
-	segmentGraphemes(text: string): Iterable<SegmentInfo> {
-		if (this.graphemeSeg === null) {
-			this.graphemeSeg = new Intl.Segmenter(undefined, { granularity: "grapheme" });
-		}
-		return this.graphemeSeg.segment(text);
-	}
-}
-
-/**
- * Module-shared lazy default {@link SegmentAdapter}. Constructed at most once,
- * on first call. Throws via {@link IntlSegmentAdapter}'s constructor if the
- * runtime lacks `Intl.Segmenter`.
- *
- * Used by the substrate's `analyzeAndMeasure` / `computeLineBreaks` /
- * `computeCharPositions` / `layoutNextLine` helpers when the caller did not
- * supply an explicit `segmentAdapter`. Public factories
- * (`reactiveLayout`/`reactiveBlockLayout`/`reactiveFlowLayout`) expose
- * `segmentAdapter?` in their options — Hermes consumers wire their own and
- * never reach this default.
- */
-let _defaultSegmentAdapter: SegmentAdapter | null = null;
-export function getDefaultSegmentAdapter(): SegmentAdapter {
-	if (_defaultSegmentAdapter === null) {
-		_defaultSegmentAdapter = new IntlSegmentAdapter();
-	}
-	return _defaultSegmentAdapter;
-}
-
-/**
- * Test-only: reset the module-shared default. Use in `afterEach` after stubbing
- * `Intl.Segmenter` so a subsequent unstubbed test rebuilds a fresh default.
- *
- * @internal
- */
-export function _resetDefaultSegmentAdapterForTests(): void {
-	_defaultSegmentAdapter = null;
-}
-
-// ---------------------------------------------------------------------------
-// CliMeasureAdapter
-// ---------------------------------------------------------------------------
-
-export type CliMeasureAdapterOptions = {
-	/** Pixel width per terminal cell (default: 8). */
-	cellPx?: number;
-};
-
-/**
- * Monospace terminal measurement adapter.
- *
- * Width = cell count × `cellPx`. CJK / fullwidth characters count as 2 cells.
- * No external dependencies. Works in any JS environment.
- */
-export class CliMeasureAdapter implements MeasurementAdapter {
-	private readonly cellPx: number;
-
-	constructor(opts?: CliMeasureAdapterOptions) {
-		this.cellPx = opts?.cellPx ?? 8;
-	}
-
-	measureSegment(text: string, _font: string): { width: number } {
-		return { width: countCells(text) * this.cellPx };
-	}
-}
-
-// ---------------------------------------------------------------------------
-// InjectedMeasureAdapter (universal — React Native / Hermes reference adapter)
-// ---------------------------------------------------------------------------
-
-/**
- * A synchronous text-measurement function.
- *
- * `(text, font) => widthPx`. Must be **synchronous** (the layout engine is a
- * pure-arithmetic reactive graph — no async, no polling per spec §5.8/§5.10)
- * and **pure** for a given `(text, font)` pair within a layout pass.
- *
- * `font` is the same CSS-`font`-shorthand string the rest of Reactive Layout
- * uses (e.g. `"16px Kalam"`). A host backend that keys on a parsed
- * size/family instead can ignore parts it does not need.
- */
-export type MeasureFn = (text: string, font: string) => number;
-
-/**
- * Backend-agnostic measurement adapter — wraps an injected synchronous
- * `(text, font) => widthPx` function.
- *
- * This is the **React Native / Hermes reference adapter** and the documented
- * RN measure-adapter contract. RN has no DOM/`OffscreenCanvas`, so
- * {@link CanvasMeasureAdapter} cannot run there; instead the host supplies a
- * sync measure function bound to its native text engine and passes it here.
- * The substrate ships only this generic seam + contract — the concrete
- * native binding stays userland (same split as the `bytes`-`StorageBackend`
- * Drizzle/Expo-SQLite adapter vs. the upstream `bigintJsonCodecFor`).
- *
- * ### React Native (Skia) reference wiring — userland
- *
- * ```ts
- * import { Skia } from "@shopify/react-native-skia";
- * import { InjectedMeasureAdapter } from "@graphrefly/graphrefly/utils/reactive-layout";
- *
- * // Build the font(s) you lay out with once, outside the measure fn.
- * const typeface = Skia.Typeface.MakeFreeTypeFaceFromData(kalamTtf);
- * const skFont = Skia.Font(typeface, 16);
- *
- * const adapter = new InjectedMeasureAdapter((text, _font) => {
- *   // Skia Font.measureText / getGlyphWidths is synchronous — perfect fit.
- *   return skFont.measureText(text).width;
- * });
- * ```
- *
- * RN core (no Skia) can instead inject a precomputed per-glyph metric table
- * lookup, or `@shopify/react-native-skia`'s `Paragraph` builder measured
- * synchronously. The only contract is **sync + pure**.
- *
- * @remarks
- * - **Hermes-safe:** this adapter has zero `node:*` and zero DOM globals —
- *   the injected fn is the sole boundary to the host text engine. The
- *   root-package browser-safety bundle assertion enforces no `node:*` and
- *   that DOM globals in the `reactive-layout` graph stay `typeof`-guarded
- *   (the `CanvasMeasureAdapter` convention) — see the `reactive-layout`
- *   solution doc for the precise guarantee.
- * - An optional `cache: true` memoizes by the `(font, text)` pair (an internal `\u0000` delimiter, collision-safe). Leave it
- *   off (default) when the host engine is already fast or when the working
- *   set is unbounded; turn it on for repeated re-layout of stable content.
- */
-export class InjectedMeasureAdapter implements MeasurementAdapter {
-	private readonly fn: MeasureFn;
-	private readonly cache: Map<string, number> | null;
-
-	constructor(fn: MeasureFn, opts?: { cache?: boolean }) {
-		if (typeof fn !== "function") {
-			throw new TypeError(
-				"InjectedMeasureAdapter: a synchronous (text, font) => widthPx function is required",
-			);
-		}
-		this.fn = fn;
-		this.cache = opts?.cache ? new Map<string, number>() : null;
-	}
-
-	measureSegment(text: string, font: string): { width: number } {
-		if (this.cache) {
-			const key = `${font}\u0000${text}`;
-			const hit = this.cache.get(key);
-			if (hit !== undefined) return { width: hit };
-			const w = this.fn(text, font);
-			this.cache.set(key, w);
-			return { width: w };
-		}
-		return { width: this.fn(text, font) };
-	}
-
-	clearCache(): void {
-		this.cache?.clear();
-	}
-}
-
-// ---------------------------------------------------------------------------
-// PrecomputedAdapter
-// ---------------------------------------------------------------------------
-
-export type PrecomputedAdapterOptions = {
-	/**
-	 * Pre-computed metrics: `{ font: { segment: widthPx } }`.
-	 * Outer key is the CSS font string; inner key is the text segment.
-	 */
-	metrics: Record<string, Record<string, number>>;
-	/**
-	 * Fallback when a segment is not found in the metrics map.
-	 * - `"per-char"`: sum individual character widths from the same font map (default)
-	 * - `"error"`: throw an error for unknown segments
-	 */
-	fallback?: "per-char" | "error";
-};
-
-class PrecomputedAdapterKeyError extends Error {
-	name = "KeyError";
-}
-
-/**
- * Pre-computed measurement adapter for SSR / snapshot replay.
- *
- * Reads from a static metrics object — zero measurement at runtime.
- * Ideal for server-side rendering or replaying snapshotted layouts.
- */
-export class PrecomputedAdapter implements MeasurementAdapter {
-	private readonly metrics: Record<string, Record<string, number>>;
-	private readonly fallback: "per-char" | "error";
-
-	constructor(opts: PrecomputedAdapterOptions) {
-		this.metrics = opts.metrics;
-		const fb = opts.fallback ?? "per-char";
-		if (fb !== "per-char" && fb !== "error") {
-			// Keep parity with Python: validate at runtime.
-			throw new Error(
-				`fallback must be 'per-char' or 'error', got ${JSON.stringify(opts.fallback)}`,
-			);
-		}
-		this.fallback = fb;
-	}
-
-	measureSegment(text: string, font: string): { width: number } {
-		const fontMap = this.metrics[font];
-		if (fontMap) {
-			const w = fontMap[text];
-			if (w !== undefined) return { width: w };
-		}
-
-		if (this.fallback === "error") {
-			throw new PrecomputedAdapterKeyError(
-				`PrecomputedAdapter: no metrics for segment ${JSON.stringify(text)} in font ${JSON.stringify(font)}`,
-			);
-		}
-
-		// per-char fallback: sum individual character widths
-		let total = 0;
-		if (fontMap) {
-			for (const ch of text) {
-				const cw = fontMap[ch];
-				if (cw !== undefined) {
-					total += cw;
-				}
-				// unknown char contributes 0 (best-effort)
-			}
-		}
-		return { width: total };
-	}
-}
-
-// ---------------------------------------------------------------------------
-// CanvasMeasureAdapter (browser)
-// ---------------------------------------------------------------------------
-
-export type CanvasMeasureAdapterOptions = {
-	/** Emoji width correction factor (default: 1, no correction). */
-	emojiCorrection?: number;
-};
-
-/**
- * Browser measurement adapter using `OffscreenCanvas.measureText()`.
- *
- * Lazily creates an OffscreenCanvas and 2D context on first call.
- * Requires a browser environment with OffscreenCanvas support.
- */
-export class CanvasMeasureAdapter implements MeasurementAdapter {
-	private ctx: OffscreenCanvasRenderingContext2D | null = null;
-	private currentFont = "";
-	private readonly emojiCorrection: number;
-
-	constructor(opts?: CanvasMeasureAdapterOptions) {
-		this.emojiCorrection = opts?.emojiCorrection ?? 1;
-	}
-
-	private getContext(): OffscreenCanvasRenderingContext2D {
-		if (!this.ctx) {
-			if (typeof OffscreenCanvas === "undefined") {
-				throw new Error(
-					"CanvasMeasureAdapter requires a browser environment with OffscreenCanvas support. " +
-						"Use CliMeasureAdapter or NodeCanvasMeasureAdapter for Node.js.",
-				);
-			}
-			const canvas = new OffscreenCanvas(0, 0);
-			const ctx = canvas.getContext("2d");
-			if (!ctx) throw new Error("CanvasMeasureAdapter: failed to get 2d context");
-			this.ctx = ctx;
-		}
-		return this.ctx;
-	}
-
-	measureSegment(text: string, font: string): { width: number } {
-		const ctx = this.getContext();
-		if (font !== this.currentFont) {
-			ctx.font = font;
-			this.currentFont = font;
-		}
-		let width = ctx.measureText(text).width;
-		// Apply emoji correction if configured
-		if (this.emojiCorrection !== 1 && /\p{Emoji_Presentation}/u.test(text)) {
-			width *= this.emojiCorrection;
-		}
-		return { width };
-	}
-
-	clearCache(): void {
-		// No segment cache; context font is the only state.
-		this.currentFont = "";
-	}
-}
-
-// ---------------------------------------------------------------------------
-// NodeCanvasMeasureAdapter (Node.js / CLI with canvas package)
-// ---------------------------------------------------------------------------
-
-/**
- * Canvas API subset expected from `@napi-rs/canvas` or `skia-canvas`.
- * Passed via dependency injection — no dynamic import, no polling.
- */
-export type CanvasModule = {
-	createCanvas(
-		width: number,
-		height: number,
-	): {
-		getContext(type: "2d"): {
-			font: string;
-			measureText(text: string): { width: number };
-		};
-	};
-};
-
-/**
- * Node.js measurement adapter using an injected canvas module.
- *
- * ```ts
- * import * as canvas from "@napi-rs/canvas";
- * const adapter = new NodeCanvasMeasureAdapter(canvas);
- * ```
- *
- * Works with `@napi-rs/canvas`, `skia-canvas`, or any module exposing
- * `createCanvas(w, h).getContext("2d").measureText(text)`.
- */
-export class NodeCanvasMeasureAdapter implements MeasurementAdapter {
-	private ctx: { font: string; measureText(text: string): { width: number } } | null = null;
-	private currentFont = "";
-	private readonly canvasModule: CanvasModule;
-
-	constructor(canvasModule: CanvasModule) {
-		this.canvasModule = canvasModule;
-	}
-
-	private getContext(): { font: string; measureText(text: string): { width: number } } {
-		if (!this.ctx) {
-			const canvas = this.canvasModule.createCanvas(0, 0);
-			const ctx = canvas.getContext("2d");
-			if (!ctx) throw new Error("NodeCanvasMeasureAdapter: failed to get 2d context");
-			this.ctx = ctx;
-		}
-		return this.ctx;
-	}
-
-	measureSegment(text: string, font: string): { width: number } {
-		const ctx = this.getContext();
-		if (font !== this.currentFont) {
-			ctx.font = font;
-			this.currentFont = font;
-		}
-		return { width: ctx.measureText(text).width };
-	}
-
-	clearCache(): void {
-		this.currentFont = "";
-	}
-}
-
-// ---------------------------------------------------------------------------
-// SvgBoundsAdapter
-// ---------------------------------------------------------------------------
-
-/**
- * SVG measurement adapter — extracts dimensions from `viewBox` attribute
- * or explicit `width`/`height` attributes in the SVG string.
- *
- * Pure arithmetic: parses the SVG string for dimension attributes.
- * No DOM required. Works in any JS environment.
- *
- * Browser users who need `getBBox()` should pre-measure and pass explicit
- * `viewBox` on the content block instead.
- */
-export class SvgBoundsAdapter {
-	measureSvg(content: string): { width: number; height: number } {
-		// Try viewBox first: viewBox="minX minY width height"
-		const viewBoxMatch = content.match(/viewBox\s*=\s*["']([^"']+)["']/);
-		if (viewBoxMatch) {
-			const parts = viewBoxMatch[1]!.trim().split(/[\s,]+/);
-			if (parts.length >= 4) {
-				const w = Number.parseFloat(parts[2]!);
-				const h = Number.parseFloat(parts[3]!);
-				if (Number.isFinite(w) && Number.isFinite(h) && w > 0 && h > 0) {
-					return { width: w, height: h };
-				}
-				throw new Error(
-					"SvgBoundsAdapter: viewBox width/height are missing, non-finite, or not positive",
-				);
-			}
-		}
-
-		// Fall back to explicit width/height attributes
-		const widthMatch = content.match(/<svg[^>]*\bwidth\s*=\s*["']?([\d.]+)/);
-		const heightMatch = content.match(/<svg[^>]*\bheight\s*=\s*["']?([\d.]+)/);
-		if (widthMatch && heightMatch) {
-			const w = Number.parseFloat(widthMatch[1]!);
-			const h = Number.parseFloat(heightMatch[1]!);
-			if (Number.isFinite(w) && Number.isFinite(h) && w > 0 && h > 0) {
-				return { width: w, height: h };
-			}
-			throw new Error(
-				"SvgBoundsAdapter: svg width/height attributes are non-finite or not positive",
-			);
-		}
-
-		throw new Error(
-			"SvgBoundsAdapter: cannot determine dimensions — SVG has no viewBox or width/height attributes",
-		);
-	}
-}
-
-// ---------------------------------------------------------------------------
-// ImageSizeAdapter
-// ---------------------------------------------------------------------------
-
-/**
- * Image measurement adapter — returns pre-registered dimensions by src key.
- *
- * Sync-only: dimensions must be provided upfront via the `sizes` map.
- * No I/O, no polling, no async. For browser use, pre-measure via
- * `Image.onload` and pass natural dimensions on the content block directly,
- * or register them here.
- *
- * ```ts
- * const adapter = new ImageSizeAdapter({
- *   "hero.png": { width: 1200, height: 630 },
- *   "logo.svg": { width: 120, height: 40 },
- * });
- * ```
- */
-export class ImageSizeAdapter {
-	private readonly sizes: Map<string, { width: number; height: number }>;
-
-	constructor(sizes: Record<string, { width: number; height: number }>) {
-		this.sizes = new Map(Object.entries(sizes));
-	}
-
-	measureImage(src: string): { width: number; height: number } {
-		const dims = this.sizes.get(src);
-		if (!dims) {
-			throw new Error(`ImageSizeAdapter: no dimensions registered for ${JSON.stringify(src)}`);
-		}
-		return { width: dims.width, height: dims.height };
-	}
-}
diff --git a/src/utils/reactive-layout/reactive-block-layout.ts b/src/utils/reactive-layout/reactive-block-layout.ts
deleted file mode 100644
index 9e916e5f..00000000
--- a/src/utils/reactive-layout/reactive-block-layout.ts
+++ /dev/null
@@ -1,446 +0,0 @@
-/**
- * Reactive multi-content block layout engine (roadmap §7.1 — mixed content).
- *
- * Extends the text-only `reactiveLayout` with support for image and SVG blocks.
- * Pure-arithmetic layout over measured child sizes — no DOM, no async.
- *
- * Graph shape:
- * ```
- * Graph("reactive-block-layout")
- * ├── node([], { initial: "blocks" })              — ContentBlock[] input
- * ├── node([], { initial: "max-width" })           — container constraint
- * ├── node([], { initial: "gap" })                 — vertical gap between blocks (px)
- * ├── derived("measured-blocks")   — blocks → MeasuredBlock[] (per-type measurement)
- * ├── derived("block-flow")        — measured-blocks + max-width + gap → PositionedBlock[]
- * ├── derived("total-height")      — block-flow → total height
- * └── meta: { block-count, layout-time-ns }
- * ```
- */
-import { monotonicNs, type Node, node } from "@graphrefly/pure-ts/core";
-
-import { Graph } from "@graphrefly/pure-ts/graph";
-import { emitToMeta } from "../../base/meta/emit-to-meta.js";
-import { getDefaultSegmentAdapter } from "./measurement-adapters.js";
-import {
-	analyzeAndMeasure,
-	type CharPosition,
-	computeCharPositions,
-	computeLineBreaks,
-	type LineBreaksResult,
-	type MeasurementAdapter,
-	type PreparedSegment,
-	type SegmentAdapter,
-} from "./reactive-layout.js";
-
-// ---------------------------------------------------------------------------
-// Types
-// ---------------------------------------------------------------------------
-
-/** Pluggable measurement backend for SVG content. */
-export interface SvgMeasurer {
-	measureSvg(content: string): { width: number; height: number };
-}
-
-/** Pluggable measurement backend for image content. */
-export interface ImageMeasurer {
-	measureImage(src: string): { width: number; height: number };
-}
-
-/** Adapters map for `reactiveBlockLayout`. */
-export type BlockAdapters = {
-	/** Text measurement adapter (required — delegates to `reactiveLayout` internals). */
-	text: MeasurementAdapter;
-	/**
-	 * Text segmentation adapter (optional). Defaults to a lazy
-	 * {@link IntlSegmentAdapter}; **must be supplied on Hermes / RN** to avoid
-	 * the missing-`Intl.Segmenter` runtime throw — see {@link SegmentAdapter}.
-	 */
-	segment?: SegmentAdapter;
-	/** SVG measurement (optional — required only if SVG blocks are present). */
-	svg?: SvgMeasurer;
-	/** Image measurement (optional — required only if image blocks without explicit dimensions are present). */
-	image?: ImageMeasurer;
-};
-
-/** A content block — text, image, or SVG. */
-export type ContentBlock =
-	| {
-			type: "text";
-			text: string;
-			font?: string;
-			lineHeight?: number;
-	  }
-	| {
-			type: "image";
-			src: string;
-			/** Natural width in px. Required if no ImageMeasurer adapter is provided. */
-			naturalWidth?: number;
-			/** Natural height in px. Required if no ImageMeasurer adapter is provided. */
-			naturalHeight?: number;
-	  }
-	| {
-			type: "svg";
-			content: string;
-			/** Explicit viewBox dimensions. Required if no SvgMeasurer adapter is provided. */
-			viewBox?: { width: number; height: number };
-	  };
-
-/**
- * A block after measurement — knows its natural dimensions.
- *
- * **Equality note:** The reactive `measured-blocks` node uses dimension-only equality
- * (`type`, `width`, `height`, `index`). Inner text layout data (`textSegments`,
- * `textLineBreaks`, `textCharPositions`) is NOT compared for change detection.
- * If you need text-level reactivity, use `reactiveLayout()` directly per text block.
- */
-export type MeasuredBlock = {
-	index: number;
-	type: "text" | "image" | "svg";
-	width: number;
-	height: number;
-	/** For text blocks: the inner layout results. */
-	textSegments?: PreparedSegment[];
-	textLineBreaks?: LineBreaksResult;
-	textCharPositions?: CharPosition[];
-};
-
-/** A block after flow — positioned in the container. */
-export type PositionedBlock = MeasuredBlock & {
-	x: number;
-	y: number;
-};
-
-/** Options for `reactiveBlockLayout`. */
-export type ReactiveBlockLayoutOptions = {
-	adapters: BlockAdapters;
-	name?: string;
-	blocks?: ContentBlock[];
-	/** Container max width in px (clamped to ≥ 0 on init and `setMaxWidth`). */
-	maxWidth?: number;
-	/** Vertical gap between blocks in px (default 0). */
-	gap?: number;
-	/** Default font for text blocks that don't specify one. */
-	defaultFont?: string;
-	/** Default line height for text blocks that don't specify one. */
-	defaultLineHeight?: number;
-};
-
-/** Result bundle from `reactiveBlockLayout`. */
-export type ReactiveBlockLayoutBundle = {
-	graph: Graph;
-	setBlocks: (blocks: ContentBlock[]) => void;
-	setMaxWidth: (maxWidth: number) => void;
-	setGap: (gap: number) => void;
-	measuredBlocks: Node<MeasuredBlock[]>;
-	blockFlow: Node<PositionedBlock[]>;
-	totalHeight: Node<number>;
-};
-
-// ---------------------------------------------------------------------------
-// Block measurement (pure functions)
-// ---------------------------------------------------------------------------
-
-/**
- * Measure a single content block, returning natural (unconstrained) dimensions.
- * Text blocks use the text layout pipeline; image/SVG use adapters or explicit dims.
- */
-export function measureBlock(
-	block: ContentBlock,
-	maxWidth: number,
-	adapters: BlockAdapters,
-	measureCache: Map<string, Map<string, number>>,
-	defaultFont: string,
-	defaultLineHeight: number,
-	index: number,
-): MeasuredBlock {
-	switch (block.type) {
-		case "text": {
-			const font = block.font ?? defaultFont;
-			const lineHeight = block.lineHeight ?? defaultLineHeight;
-			const segAdapter = adapters.segment ?? getDefaultSegmentAdapter();
-			const segments = analyzeAndMeasure(
-				block.text,
-				font,
-				adapters.text,
-				measureCache,
-				undefined,
-				segAdapter,
-			);
-			const lineBreaks = computeLineBreaks(
-				segments,
-				maxWidth,
-				adapters.text,
-				font,
-				measureCache,
-				segAdapter,
-			);
-			const charPositions = computeCharPositions(lineBreaks, segments, lineHeight, segAdapter);
-			const height = lineBreaks.lineCount * lineHeight;
-			// Width is the max line width (clamped to maxWidth)
-			let width = 0;
-			for (const line of lineBreaks.lines) {
-				if (line.width > width) width = line.width;
-			}
-			return {
-				index,
-				type: "text",
-				width: Math.min(width, maxWidth),
-				height,
-				textSegments: segments,
-				textLineBreaks: lineBreaks,
-				textCharPositions: charPositions,
-			};
-		}
-		case "image": {
-			let w: number;
-			let h: number;
-			if (block.naturalWidth != null && block.naturalHeight != null) {
-				w = block.naturalWidth;
-				h = block.naturalHeight;
-			} else if (adapters.image) {
-				const dims = adapters.image.measureImage(block.src);
-				w = dims.width;
-				h = dims.height;
-			} else {
-				throw new Error(
-					`Image block at index ${index} has no naturalWidth/naturalHeight and no ImageMeasurer adapter`,
-				);
-			}
-			// Scale proportionally to fit maxWidth
-			if (w > maxWidth) {
-				h = (h * maxWidth) / w;
-				w = maxWidth;
-			}
-			return { index, type: "image", width: w, height: h };
-		}
-		case "svg": {
-			let w: number;
-			let h: number;
-			if (block.viewBox) {
-				w = block.viewBox.width;
-				h = block.viewBox.height;
-			} else if (adapters.svg) {
-				const dims = adapters.svg.measureSvg(block.content);
-				w = dims.width;
-				h = dims.height;
-			} else {
-				throw new Error(`SVG block at index ${index} has no viewBox and no SvgMeasurer adapter`);
-			}
-			// Scale proportionally to fit maxWidth
-			if (w > maxWidth) {
-				h = (h * maxWidth) / w;
-				w = maxWidth;
-			}
-			return { index, type: "svg", width: w, height: h };
-		}
-	}
-}
-
-/**
- * Measure all blocks in a content array.
- */
-export function measureBlocks(
-	blocks: ContentBlock[],
-	maxWidth: number,
-	adapters: BlockAdapters,
-	measureCache: Map<string, Map<string, number>>,
-	defaultFont: string,
-	defaultLineHeight: number,
-): MeasuredBlock[] {
-	return blocks.map((block, i) =>
-		measureBlock(block, maxWidth, adapters, measureCache, defaultFont, defaultLineHeight, i),
-	);
-}
-
-// ---------------------------------------------------------------------------
-// Block flow (pure function)
-// ---------------------------------------------------------------------------
-
-/**
- * Vertical stacking flow: blocks are placed top-to-bottom, left-aligned,
- * separated by `gap` pixels. Pure arithmetic over measured sizes.
- */
-export function computeBlockFlow(measured: MeasuredBlock[], gap: number): PositionedBlock[] {
-	const result: PositionedBlock[] = [];
-	let y = 0;
-	for (let i = 0; i < measured.length; i++) {
-		const m = measured[i]!;
-		result.push({ ...m, x: 0, y });
-		y += m.height + (i < measured.length - 1 ? gap : 0);
-	}
-	return result;
-}
-
-/**
- * Compute total height from positioned blocks.
- */
-export function computeTotalHeight(flow: PositionedBlock[]): number {
-	if (flow.length === 0) return 0;
-	const last = flow[flow.length - 1]!;
-	return last.y + last.height;
-}
-
-// ---------------------------------------------------------------------------
-// Reactive graph factory
-// ---------------------------------------------------------------------------
-
-/**
- * Create a reactive block layout graph for mixed content (text + image + SVG).
- *
- * ```
- * Graph("reactive-block-layout")
- * ├── node([], { initial: "blocks" })              — ContentBlock[] input
- * ├── node([], { initial: "max-width" })           — container constraint
- * ├── node([], { initial: "gap" })                 — vertical gap (px)
- * ├── derived("measured-blocks")   — blocks + max-width → MeasuredBlock[]
- * ├── derived("block-flow")        — measured-blocks + gap → PositionedBlock[]
- * ├── derived("total-height")      — block-flow → number
- * └── meta: { block-count, layout-time-ns }
- * ```
- */
-export function reactiveBlockLayout(opts: ReactiveBlockLayoutOptions): ReactiveBlockLayoutBundle {
-	const {
-		adapters,
-		name = "reactive-block-layout",
-		defaultFont = "16px sans-serif",
-		defaultLineHeight = 20,
-	} = opts;
-	const g = new Graph(name);
-
-	// Shared text measurement cache (same structure as reactiveLayout)
-	const measureCache = new Map<string, Map<string, number>>();
-
-	// --- State nodes ---
-	const blocksNode = node<ContentBlock[]>([], { name: "blocks", initial: opts.blocks ?? [] });
-	const maxWidthNode = node<number>([], {
-		name: "max-width",
-		initial: Math.max(0, opts.maxWidth ?? 800),
-	});
-	const gapNode = node<number>([], { name: "gap", initial: opts.gap ?? 0 });
-
-	// --- Derived: measured-blocks ---
-	// Raw `node(...)` instead of `derived(...)` so the fn can return a
-	// cleanup function. Core fires function-form cleanup on INVALIDATE (see
-	// `node.ts:_updateState` INVALIDATE branch), which lets us flush the
-	// measure cache and the downstream adapter cache reactively — replaces
-	// the old v4 per-node `onMessage` hook that watched for INVALIDATE.
-	const measuredBlocksNode: Node<MeasuredBlock[]> = node<MeasuredBlock[]>(
-		[blocksNode, maxWidthNode],
-		(data, actions, ctx) => {
-			const blocksVal = data[0] != null && data[0].length > 0 ? data[0].at(-1) : ctx.prevData[0];
-			const mwVal = data[1] != null && data[1].length > 0 ? data[1].at(-1) : ctx.prevData[1];
-			const t0 = monotonicNs();
-			const result = measureBlocks(
-				blocksVal as ContentBlock[],
-				mwVal as number,
-				adapters,
-				measureCache,
-				defaultFont,
-				defaultLineHeight,
-			);
-			const elapsed = monotonicNs() - t0;
-
-			// Phase-3 meta deferral (parity with reactiveLayout)
-			const meta = measuredBlocksNode.meta;
-			if (meta) {
-				emitToMeta(meta["block-count"], result.length);
-				emitToMeta(meta["layout-time-ns"], elapsed);
-			}
-
-			actions.emit(result);
-
-			// Object-form cleanup: flush on deactivation + INVALIDATE only,
-			// NOT before fn re-runs. Preserves cached measurements across
-			// block edits so a single-block change doesn't wipe entries from
-			// the other blocks. Image/SVG measurers don't expose a cache hook.
-			const flush = (): void => {
-				measureCache.clear();
-				adapters.text.clearCache?.();
-			};
-			return { onDeactivation: flush, onInvalidate: flush };
-		},
-		{
-			name: "measured-blocks",
-			describeKind: "derived",
-			meta: { "block-count": 0, "layout-time-ns": 0 },
-			equals: (a, b) => {
-				const ma = a as MeasuredBlock[] | null;
-				const mb = b as MeasuredBlock[] | null;
-				if (ma == null || mb == null) return ma === mb;
-				if (ma.length !== mb.length) return false;
-				for (let i = 0; i < ma.length; i++) {
-					const ba = ma[i]!;
-					const bb = mb[i]!;
-					if (
-						ba.type !== bb.type ||
-						ba.width !== bb.width ||
-						ba.height !== bb.height ||
-						ba.index !== bb.index
-					)
-						return false;
-				}
-				return true;
-			},
-		},
-	);
-
-	// --- Derived: block-flow ---
-	const blockFlowNode = node<PositionedBlock[]>(
-		[measuredBlocksNode, gapNode],
-		(batchData, actions, ctx) => {
-			const data = batchData.map((batch, i) =>
-				batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-			);
-			actions.emit(computeBlockFlow(data[0] as MeasuredBlock[], data[1] as number));
-		},
-		{
-			name: "block-flow",
-			describeKind: "derived",
-			equals: (a, b) => {
-				const fa = a as PositionedBlock[] | null;
-				const fb = b as PositionedBlock[] | null;
-				if (fa == null || fb == null) return fa === fb;
-				if (fa.length !== fb.length) return false;
-				for (let i = 0; i < fa.length; i++) {
-					const pa = fa[i]!;
-					const pb = fb[i]!;
-					if (pa.x !== pb.x || pa.y !== pb.y || pa.width !== pb.width || pa.height !== pb.height)
-						return false;
-				}
-				return true;
-			},
-		},
-	);
-
-	// --- Derived: total-height ---
-	const totalHeightNode = node<number>(
-		[blockFlowNode],
-		(batchData, actions, ctx) => {
-			const data = batchData.map((batch, i) =>
-				batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-			);
-			actions.emit(computeTotalHeight(data[0] as PositionedBlock[]));
-		},
-		{ describeKind: "derived", name: "total-height" },
-	);
-
-	// --- Register in graph ---
-	g.add(blocksNode, { name: "blocks" });
-	g.add(maxWidthNode, { name: "max-width" });
-	g.add(gapNode, { name: "gap" });
-	g.add(measuredBlocksNode, { name: "measured-blocks" });
-	g.add(blockFlowNode, { name: "block-flow" });
-	g.add(totalHeightNode, { name: "total-height" });
-
-	// --- Edges (for describe() visibility) ---
-
-	return {
-		graph: g,
-		setBlocks: (blocks: ContentBlock[]) => g.set("blocks", blocks),
-		setMaxWidth: (mw: number) => g.set("max-width", Math.max(0, mw)),
-		setGap: (gap: number) => g.set("gap", gap),
-		measuredBlocks: measuredBlocksNode,
-		blockFlow: blockFlowNode,
-		totalHeight: totalHeightNode,
-	};
-}
diff --git a/src/utils/reactive-layout/reactive-flow-layout.ts b/src/utils/reactive-layout/reactive-flow-layout.ts
deleted file mode 100644
index 35bea766..00000000
--- a/src/utils/reactive-layout/reactive-flow-layout.ts
+++ /dev/null
@@ -1,524 +0,0 @@
-/**
- * Reactive flow layout — multi-column text flowing around shape obstacles
- * (roadmap §7.1, extends `reactiveLayout`).
- *
- * Unlike `reactiveLayout` (single-column, one `maxWidth`) and
- * `reactiveBlockLayout` (vertical stack of heterogeneous blocks), this engine
- * lays out a single stream of text across **N columns** while wrapping around
- * arbitrary **shape obstacles** (circles, rectangles). Each line's available
- * width can differ from every other line's, enabling magazine-style editorial
- * layouts — and the cursor carries seamlessly from column to column so text
- * never duplicates or gaps at boundaries.
- *
- * ```
- * Graph("reactive-flow-layout")
- * ├── node([], { initial: "text" })
- * ├── node([], { initial: "font" })
- * ├── node([], { initial: "line-height" })
- * ├── node([], { initial: "container" })           — { width, height, paddingX, paddingY }
- * ├── node([], { initial: "columns" })             — { count, gap }
- * ├── node([], { initial: "obstacles" })           — Obstacle[] (moves reactively — rAF-friendly)
- * ├── derived("segments")          — text + font → PreparedSegment[]  (from reactiveLayout)
- * ├── derived("flow-lines")        — segments + container + columns + obstacles + line-height
- * │                                  → PositionedLine[]
- * └── meta: { line-count, layout-time-ns, overflow-segments }
- * ```
- *
- * Obstacle positions change every frame; `flow-lines` re-runs per change, but
- * `segments` stays cached (text hasn't changed). Callers drive obstacles via a
- * reactive source like `fromRaf()` piped into a state node.
- */
-import { monotonicNs, type Node, node } from "@graphrefly/pure-ts/core";
-
-import { Graph } from "@graphrefly/pure-ts/graph";
-import { emitToMeta } from "../../base/meta/emit-to-meta.js";
-import { getDefaultSegmentAdapter } from "./measurement-adapters.js";
-import {
-	analyzeAndMeasure,
-	carveTextLineSlots,
-	type Interval,
-	type LayoutCursor,
-	layoutNextLine,
-	type MeasurementAdapter,
-	type PreparedSegment,
-	type SegmentAdapter,
-} from "./reactive-layout.js";
-
-// ---------------------------------------------------------------------------
-// Obstacle types
-// ---------------------------------------------------------------------------
-
-/** A circle obstacle. Center `(cx, cy)`, radius `r`; text keeps `padding` distance. */
-export type CircleObstacle = {
-	kind: "circle";
-	cx: number;
-	cy: number;
-	r: number;
-	/** Horizontal padding between obstacle and wrapped text (default 0). */
-	hPad?: number;
-	/** Vertical padding — band overlap tolerance (default 0). */
-	vPad?: number;
-};
-
-/** A rectangle obstacle. Top-left `(x, y)`, size `(w, h)`. */
-export type RectObstacle = {
-	kind: "rect";
-	x: number;
-	y: number;
-	w: number;
-	h: number;
-	hPad?: number;
-	vPad?: number;
-};
-
-/** Union of built-in obstacle shapes. */
-export type Obstacle = CircleObstacle | RectObstacle;
-
-/**
- * Compute the horizontal interval occluded by a circle at vertical band
- * `[bandTop, bandBottom]`, or `null` if no occlusion.
- *
- * Exported so consumers that render obstacle outlines in sync with the flow
- * can reuse the same geometry the flow engine uses — no divergence.
- */
-export function circleIntervalForBand(
-	o: CircleObstacle,
-	bandTop: number,
-	bandBottom: number,
-): Interval | null {
-	const hPad = o.hPad ?? 0;
-	const vPad = o.vPad ?? 0;
-	const top = bandTop - vPad;
-	const bottom = bandBottom + vPad;
-	if (top >= o.cy + o.r || bottom <= o.cy - o.r) return null;
-	const minDy = o.cy >= top && o.cy <= bottom ? 0 : o.cy < top ? top - o.cy : o.cy - bottom;
-	if (minDy >= o.r) return null;
-	const maxDx = Math.sqrt(o.r * o.r - minDy * minDy);
-	return { left: o.cx - maxDx - hPad, right: o.cx + maxDx + hPad };
-}
-
-/** Same as `circleIntervalForBand` for rectangles. */
-export function rectIntervalForBand(
-	o: RectObstacle,
-	bandTop: number,
-	bandBottom: number,
-): Interval | null {
-	const hPad = o.hPad ?? 0;
-	const vPad = o.vPad ?? 0;
-	if (bandBottom <= o.y - vPad) return null;
-	if (bandTop >= o.y + o.h + vPad) return null;
-	return { left: o.x - hPad, right: o.x + o.w + hPad };
-}
-
-function obstacleIntervalForBand(
-	o: Obstacle,
-	bandTop: number,
-	bandBottom: number,
-): Interval | null {
-	return o.kind === "circle"
-		? circleIntervalForBand(o, bandTop, bandBottom)
-		: rectIntervalForBand(o, bandTop, bandBottom);
-}
-
-// ---------------------------------------------------------------------------
-// Flow layout types
-// ---------------------------------------------------------------------------
-
-export type FlowContainer = {
-	width: number;
-	height: number;
-	paddingX?: number;
-	paddingY?: number;
-};
-
-export type FlowColumns = {
-	count: number;
-	gap: number;
-};
-
-/** A single positioned line after flow layout. */
-export type PositionedLine = {
-	x: number;
-	y: number;
-	/** Natural measured width of the text content. */
-	width: number;
-	/** Width of the slot this line was placed in — use this as the DOM element's
-	 *  `width` when applying `text-align: justify` so the line stretches to the
-	 *  obstacle edge on both sides. */
-	slotWidth: number;
-	text: string;
-	/** Which column index this line belongs to (0-based). */
-	columnIndex: number;
-	/** `true` iff the slot's right edge was carved short by an obstacle (the
-	 *  slot sits to the LEFT of an obstacle). Renderers can right-align text
-	 *  in these slots so single-word lines still hug the obstacle — CSS
-	 *  `text-align: justify` can't stretch single-word lines, which otherwise
-	 *  produces a visible asymmetry vs. the slot on the other side of the
-	 *  obstacle (which is flush by default). */
-	flushToRight: boolean;
-};
-
-/** Options for `reactiveFlowLayout`. */
-export type ReactiveFlowLayoutOptions = {
-	adapter: MeasurementAdapter;
-	/**
-	 * Segmentation backend (optional). Defaults to a lazy {@link IntlSegmentAdapter};
-	 * **must be supplied on Hermes / RN** — see {@link SegmentAdapter}.
-	 */
-	segmentAdapter?: SegmentAdapter;
-	name?: string;
-	text?: string;
-	font?: string;
-	lineHeight?: number;
-	container?: FlowContainer;
-	columns?: FlowColumns;
-	obstacles?: Obstacle[];
-	/** Minimum slot width (px) below which a slot is discarded rather than squeezed. Default `20`. */
-	minSlotWidth?: number;
-	/**
-	 * Vertical gap (px) inserted after a hard-break segment (the spacing
-	 * between paragraphs). When unset (or explicitly set to `null`), tracks
-	 * the current `lineHeight` reactively — one line-height of visible
-	 * paragraph gap, matching dense editorial layouts. Set to `0` for
-	 * paragraph-preserving layout that reclaims the break line; set larger
-	 * (e.g. `2 * lineHeight`) for looser manuscript settings. Reactive —
-	 * update via `setParagraphSpacing(n)` or restore to track-lineHeight
-	 * mode via `setParagraphSpacing(null)`.
-	 */
-	paragraphSpacing?: number | null;
-};
-
-/** Result bundle from `reactiveFlowLayout`. */
-export type ReactiveFlowLayoutBundle = {
-	graph: Graph;
-	setText: (text: string) => void;
-	setFont: (font: string) => void;
-	setLineHeight: (lh: number) => void;
-	setContainer: (c: FlowContainer) => void;
-	setColumns: (c: FlowColumns) => void;
-	setObstacles: (o: Obstacle[]) => void;
-	setParagraphSpacing: (ps: number | null) => void;
-	segments: Node<PreparedSegment[]>;
-	flowLines: Node<PositionedLine[]>;
-};
-
-// ---------------------------------------------------------------------------
-// Pure flow-layout compute
-// ---------------------------------------------------------------------------
-
-/** Result of `computeFlowLines`. */
-export type FlowLinesResult = {
-	/** Positioned lines in render order (columns inner-ordered top-to-bottom). */
-	lines: PositionedLine[];
-	/** Cursor position after the last line was placed. If
-	 *  `cursor.segmentIndex < segments.length`, the layout **truncated** — the
-	 *  container couldn't fit all text. */
-	cursor: LayoutCursor;
-};
-
-/** Optional tuning knobs for {@link computeFlowLines}. */
-export type ComputeFlowLinesOptions = {
-	/**
-	 * Vertical gap (px) inserted after a hard-break segment (the spacing
-	 * between paragraphs). Defaults to `lineHeight` — one line-height of
-	 * visible paragraph gap, which matches dense editorial layouts. Set to
-	 * `0` for paragraph-preserving layout that reclaims the break line;
-	 * set larger (e.g. `2 * lineHeight`) for looser manuscript settings.
-	 */
-	paragraphSpacing?: number;
-	/**
-	 * Segmentation adapter passed through to internal `layoutNextLine` calls
-	 * (the grapheme-slicing path triggers on partial-segment breaks). Defaults
-	 * to the lazy {@link IntlSegmentAdapter}; **wire a polyfilled
-	 * {@link SegmentAdapter} on Hermes / RN.**
-	 */
-	segmentAdapter?: SegmentAdapter;
-};
-
-/**
- * Lay out `segments` across N columns, wrapping each line around `obstacles`.
- * Pure function — no reactive wiring. Exported for testing and for consumers
- * who want to run flow layout outside a Graph.
- *
- * `carveTextLineSlots` guarantees left-to-right-ordered, non-overlapping slots,
- * so this function does not sort them.
- */
-export function computeFlowLines(
-	segments: PreparedSegment[],
-	container: FlowContainer,
-	columns: FlowColumns,
-	obstacles: Obstacle[],
-	lineHeight: number,
-	minSlotWidth: number,
-	opts?: ComputeFlowLinesOptions,
-): FlowLinesResult {
-	const paragraphSpacing = opts?.paragraphSpacing ?? lineHeight;
-	const segmentAdapterCtx = opts?.segmentAdapter;
-	const lines: PositionedLine[] = [];
-	let cursor: LayoutCursor = { segmentIndex: 0, graphemeIndex: 0 };
-	if (segments.length === 0 || columns.count <= 0 || lineHeight <= 0) {
-		return { lines, cursor };
-	}
-
-	const padX = container.paddingX ?? 0;
-	const padY = container.paddingY ?? 0;
-	const availWidth = Math.max(0, container.width - padX * 2);
-	const availHeight = Math.max(0, container.height - padY * 2);
-	const gapTotal = columns.gap * Math.max(0, columns.count - 1);
-	const colWidth = Math.max(0, (availWidth - gapTotal) / columns.count);
-	if (colWidth <= 0) return { lines, cursor };
-
-	outerCol: for (let col = 0; col < columns.count; col++) {
-		const colLeft = padX + col * (colWidth + columns.gap);
-		const colRight = colLeft + colWidth;
-		let bandTop = padY;
-
-		while (bandTop + lineHeight <= padY + availHeight) {
-			const bandBottom = bandTop + lineHeight;
-			const blocked: Interval[] = [];
-			for (let oi = 0; oi < obstacles.length; oi++) {
-				const iv = obstacleIntervalForBand(obstacles[oi]!, bandTop, bandBottom);
-				if (iv !== null) blocked.push(iv);
-			}
-			const slots = carveTextLineSlots({ left: colLeft, right: colRight }, blocked, minSlotWidth);
-
-			if (slots.length === 0) {
-				bandTop += lineHeight;
-				continue;
-			}
-
-			let hardBreakThisBand = false;
-			for (let si = 0; si < slots.length; si++) {
-				const slot = slots[si]!;
-				const slotW = slot.right - slot.left;
-				const line = layoutNextLine(
-					segments,
-					cursor,
-					slotW,
-					segmentAdapterCtx ? { segmentAdapter: segmentAdapterCtx } : undefined,
-				);
-				if (line === null) {
-					return { lines, cursor };
-				}
-				if (line.text.length === 0 && line.width === 0) {
-					// Hard-break — advance cursor past the break segment and end
-					// THIS band so the break produces a visible paragraph gap
-					// rather than being silently absorbed across remaining slots.
-					cursor = line.end;
-					hardBreakThisBand = true;
-					break;
-				}
-				lines.push({
-					x: slot.left,
-					y: bandTop,
-					width: line.width,
-					slotWidth: slotW,
-					text: line.text,
-					columnIndex: col,
-					flushToRight: slot.right < colRight - 0.5,
-				});
-				cursor = line.end;
-			}
-
-			if (hardBreakThisBand) {
-				// Paragraph gap: `paragraphSpacing` (default lineHeight) of
-				// vertical space after the break. `0` reclaims the break line;
-				// larger values space paragraphs further apart.
-				bandTop += paragraphSpacing;
-				continue;
-			}
-			bandTop += lineHeight;
-			if (cursor.segmentIndex >= segments.length) break outerCol;
-		}
-
-		if (cursor.segmentIndex >= segments.length) break;
-	}
-
-	return { lines, cursor };
-}
-
-// ---------------------------------------------------------------------------
-// Reactive graph factory
-// ---------------------------------------------------------------------------
-
-/**
- * Create a reactive flow-layout graph: N columns of text wrapping around
- * shape obstacles. Re-runs only the dependent derived nodes on any input
- * change. Obstacle movement (e.g. rAF-driven) invalidates `flow-lines` only;
- * `segments` stays cached as long as `text`/`font` don't change.
- *
- * @example
- * ```ts
- * import { reactiveFlowLayout } from "@graphrefly/graphrefly/utils/reactive-layout";
- * import { fromRaf } from "@graphrefly/graphrefly/base/sources/browser";
- *
- * const flow = reactiveFlowLayout({
- *   adapter: new CanvasMeasureAdapter(),
- *   text: longEssay,
- *   font: "18px serif",
- *   lineHeight: 26,
- *   container: { width: 900, height: 600, paddingX: 40, paddingY: 40 },
- *   columns: { count: 2, gap: 32 },
- *   obstacles: [{ kind: "circle", cx: 450, cy: 300, r: 80 }],
- * });
- *
- * // Animate the obstacle via rAF:
- * fromRaf().subscribe(([[, t]]) => {
- *   const x = 450 + 120 * Math.sin((t as number) * 0.001);
- *   flow.setObstacles([{ kind: "circle", cx: x, cy: 300, r: 80 }]);
- * });
- * ```
- */
-export function reactiveFlowLayout(opts: ReactiveFlowLayoutOptions): ReactiveFlowLayoutBundle {
-	const {
-		adapter,
-		segmentAdapter: segmentAdapterOpt,
-		name = "reactive-flow-layout",
-		minSlotWidth = 20,
-	} = opts;
-	// Eager resolve — fail-fast on Hermes-without-explicit-adapter at factory construction.
-	const segmentAdapter: SegmentAdapter = segmentAdapterOpt ?? getDefaultSegmentAdapter();
-	const g = new Graph(name);
-
-	const measureCache = new Map<string, Map<string, number>>();
-
-	const textNode = node<string>([], { name: "text", initial: opts.text ?? "" });
-	const fontNode = node<string>([], { name: "font", initial: opts.font ?? "16px sans-serif" });
-	const lineHeightNode = node<number>([], { name: "line-height", initial: opts.lineHeight ?? 20 });
-	const containerNode = node<FlowContainer>([], {
-		name: "container",
-		initial: opts.container ?? { width: 800, height: 600, paddingX: 0, paddingY: 0 },
-	});
-	const columnsNode = node<FlowColumns>([], {
-		name: "columns",
-		initial: opts.columns ?? { count: 1, gap: 0 },
-	});
-	const obstaclesNode = node<Obstacle[]>([], { name: "obstacles", initial: opts.obstacles ?? [] });
-	// `paragraphSpacing` is reactive with a "track lineHeight" default. The
-	// state node holds `number | null` — when `null`, `flow-lines` substitutes
-	// the CURRENT `lineHeight` value, so the default stays truly reactive
-	// as lineHeight updates. A caller who wants a fixed independent gap sets
-	// an explicit number via the constructor or `setParagraphSpacing`; passing
-	// `null` back restores the track-lineHeight behavior.
-	const paragraphSpacingNode = node<number | null>([], {
-		name: "paragraph-spacing",
-		initial: opts.paragraphSpacing ?? null,
-	});
-
-	const segmentsNode: Node<PreparedSegment[]> = node<PreparedSegment[]>(
-		[textNode, fontNode],
-		(data, actions, ctx) => {
-			const b0 = data[0];
-			const textVal = (b0 != null && b0.length > 0 ? b0.at(-1) : ctx.prevData[0]) as string;
-			const b1 = data[1];
-			const fontVal = (b1 != null && b1.length > 0 ? b1.at(-1) : ctx.prevData[1]) as string;
-			const result = analyzeAndMeasure(
-				textVal,
-				fontVal,
-				adapter,
-				measureCache,
-				undefined,
-				segmentAdapter,
-			);
-			actions.emit(result);
-			// Flush on deactivation + INVALIDATE only — preserve cache across
-			// fn re-runs so text/font edits don't wipe per-segment entries that
-			// still match the new text.
-			const flush = (): void => {
-				measureCache.clear();
-				adapter.clearCache?.();
-			};
-			return { onDeactivation: flush, onInvalidate: flush };
-		},
-		{ name: "segments", describeKind: "derived" },
-	);
-
-	const flowLinesNode = node<PositionedLine[]>(
-		[segmentsNode, containerNode, columnsNode, obstaclesNode, lineHeightNode, paragraphSpacingNode],
-		(batchData, actions, ctx) => {
-			const data = batchData.map((batch, i) =>
-				batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-			);
-			const segments = data[0] as PreparedSegment[];
-			const t0 = monotonicNs();
-			// `ps === null` → track current lineHeight. Any explicit number
-			// (0, 60, …) overrides; passing `null` via `setParagraphSpacing`
-			// restores tracking.
-			const effectiveSpacing = (data[5] as number | null) ?? (data[4] as number);
-			const { lines: result, cursor } = computeFlowLines(
-				segments,
-				data[1] as FlowContainer,
-				data[2] as FlowColumns,
-				data[3] as Obstacle[],
-				data[4] as number,
-				minSlotWidth,
-				{ paragraphSpacing: effectiveSpacing, segmentAdapter },
-			);
-			const elapsed = monotonicNs() - t0;
-			// Overflow signal: segments left unlaid-out after the container is
-			// exhausted. `0` means all text fit; `N > 0` means the container
-			// occluded/overflowed N segments — consumers can surface a "…more"
-			// indicator, grow the container, or discard obstacles.
-			const overflow = Math.max(0, segments.length - cursor.segmentIndex);
-			const meta = flowLinesNode.meta;
-			if (meta) {
-				emitToMeta(meta["line-count"], result.length);
-				emitToMeta(meta["layout-time-ns"], elapsed);
-				emitToMeta(meta["overflow-segments"], overflow);
-			}
-			actions.emit(result);
-		},
-		{
-			describeKind: "derived",
-			name: "flow-lines",
-			meta: {
-				"line-count": 0,
-				"layout-time-ns": 0,
-				"overflow-segments": 0,
-			},
-			equals: (a, b) => {
-				const la = a as PositionedLine[];
-				const lb = b as PositionedLine[];
-				if (la.length !== lb.length) return false;
-				for (let i = 0; i < la.length; i++) {
-					const pa = la[i]!;
-					const pb = lb[i]!;
-					if (
-						pa.x !== pb.x ||
-						pa.y !== pb.y ||
-						pa.width !== pb.width ||
-						pa.slotWidth !== pb.slotWidth ||
-						pa.text !== pb.text ||
-						pa.columnIndex !== pb.columnIndex ||
-						pa.flushToRight !== pb.flushToRight
-					)
-						return false;
-				}
-				return true;
-			},
-		},
-	);
-
-	g.add(textNode, { name: "text" });
-	g.add(fontNode, { name: "font" });
-	g.add(lineHeightNode, { name: "line-height" });
-	g.add(containerNode, { name: "container" });
-	g.add(columnsNode, { name: "columns" });
-	g.add(obstaclesNode, { name: "obstacles" });
-	g.add(paragraphSpacingNode, { name: "paragraph-spacing" });
-	g.add(segmentsNode, { name: "segments" });
-	g.add(flowLinesNode, { name: "flow-lines" });
-
-	return {
-		graph: g,
-		setText: (t: string) => g.set("text", t),
-		setFont: (f: string) => g.set("font", f),
-		setLineHeight: (lh: number) => g.set("line-height", lh),
-		setContainer: (c: FlowContainer) => g.set("container", c),
-		setColumns: (c: FlowColumns) => g.set("columns", c),
-		setObstacles: (o: Obstacle[]) => g.set("obstacles", o),
-		setParagraphSpacing: (ps: number | null) => g.set("paragraph-spacing", ps),
-		segments: segmentsNode,
-		flowLines: flowLinesNode,
-	};
-}
diff --git a/src/utils/reactive-layout/reactive-layout.ts b/src/utils/reactive-layout/reactive-layout.ts
deleted file mode 100644
index 3e215850..00000000
--- a/src/utils/reactive-layout/reactive-layout.ts
+++ /dev/null
@@ -1,1475 +0,0 @@
-/**
- * Reactive text layout engine (roadmap §7.1 — Pretext parity).
- *
- * Pure-arithmetic text measurement and line breaking without DOM thrashing.
- * Inspired by [Pretext](https://github.com/chenglou/pretext), rebuilt as a
- * GraphReFly graph — inspectable via `describe()`, snapshotable, debuggable.
- *
- * Two-tier DX:
- * - `reactiveLayout({ adapter, text?, font?, lineHeight?, maxWidth?, name? })` — convenience factory
- * - `MeasurementAdapter` — pluggable backends (`measureSegment`; optional `clearCache`)
- */
-import { monotonicNs, type Node, node } from "@graphrefly/pure-ts/core";
-
-import { Graph } from "@graphrefly/pure-ts/graph";
-import { emitToMeta } from "../../base/meta/emit-to-meta.js";
-import { getDefaultSegmentAdapter } from "./measurement-adapters.js";
-
-// ---------------------------------------------------------------------------
-// Types
-// ---------------------------------------------------------------------------
-
-/** Pluggable measurement backend. */
-export interface MeasurementAdapter {
-	measureSegment(text: string, font: string): { width: number };
-	/** Optional; adapters may omit for read-only / stateless measurement. */
-	clearCache?(): void;
-}
-
-/**
- * A single segmented piece — the structurally-narrowed common shape across
- * `Intl.Segmenter`'s `Intl.SegmentData` and host-provided polyfills.
- *
- * Drops `input` (redundant — the caller already has the text) and narrows
- * `isWordLike` to "may be missing" so grapheme-granularity callers ignore it
- * cleanly.
- */
-export type SegmentInfo = {
-	/** The segmented substring. */
-	segment: string;
-	/** Code-unit offset of `segment` within the input. */
-	index: number;
-	/** True if the word-granularity segment looks like a word (letters / kana / etc.). Always undefined for grapheme granularity. */
-	isWordLike?: boolean;
-};
-
-/**
- * Pluggable text-segmentation backend (separate from {@link MeasurementAdapter}
- * because measurement and segmentation are different host concerns —
- * Skia/Canvas measure widths, ICU segments graphemes/words).
- *
- * **Why this exists (DS-2026-05-20 — `optimizations.md` 🟠 (d)).**
- * `reactive-layout`'s default backend uses `new Intl.Segmenter(...)` for word /
- * grapheme iteration. Hermes (iOS 26.5 / RN 0.83) ships **without**
- * `Intl.Segmenter` — `typeof Intl.Segmenter === "undefined"` — and the
- * constructor throws `Cannot read property 'prototype' of undefined`. This
- * interface lets RN/Hermes consumers inject their own segmenter (typically a
- * polyfill wrapper) so the substrate never touches the missing global.
- *
- * **Contract:** sync, pure, idempotent. `segmentWords` must mirror
- * `Intl.Segmenter(undefined, { granularity: "word" }).segment(text)`'s shape
- * (an iterable of `{ segment, index, isWordLike }`); `segmentGraphemes`
- * mirrors `{ granularity: "grapheme" }`. The reference implementation is
- * {@link IntlSegmentAdapter}.
- *
- * **Polyfill recipe (RN/Hermes consumer userland — NOT shipped here per the
- * `bigintJsonCodecFor` userland-binding precedent):**
- *
- * ```ts
- * // Userland — at app entry, before any reactive-layout import:
- * import "intl-segmenter-polyfill/dist/polyfill"; // or @formatjs/intl-segmenter
- * // Then the substrate's default IntlSegmentAdapter works:
- * import { reactiveLayout } from "@graphrefly/graphrefly/utils/reactive-layout";
- * ```
- *
- * Or, without polyfilling the global (preferred — keeps ICU bytes scoped):
- *
- * ```ts
- * // Userland — wrap any segmenter implementation:
- * import { createIntlSegmenterPolyfill } from "intl-segmenter-polyfill";
- * import type { SegmentAdapter, SegmentInfo } from "@graphrefly/graphrefly/utils/reactive-layout";
- *
- * const wordSeg = await createIntlSegmenterPolyfill({ granularity: "word" });
- * const graphemeSeg = await createIntlSegmenterPolyfill({ granularity: "grapheme" });
- * const segmentAdapter: SegmentAdapter = {
- *   segmentWords: (text) => wordSeg.segment(text) as Iterable<SegmentInfo>,
- *   segmentGraphemes: (text) => graphemeSeg.segment(text) as Iterable<SegmentInfo>,
- * };
- * reactiveLayout({ adapter, segmentAdapter, ... });
- * ```
- */
-export interface SegmentAdapter {
-	/** Word-granularity segmentation — yields `{ segment, index, isWordLike }`. */
-	segmentWords(text: string): Iterable<SegmentInfo>;
-	/** Grapheme-granularity segmentation — yields `{ segment, index }`. `isWordLike` is unused / undefined. */
-	segmentGraphemes(text: string): Iterable<SegmentInfo>;
-}
-
-/** Mutable counters for `analyzeAndMeasure` cache hit ratio (hits / (hits + misses)). */
-export type SegmentMeasureStats = { hits: number; misses: number };
-
-/** Break kind for each segment (ported from Pretext analysis.ts). */
-export type SegmentBreakKind = "text" | "space" | "zero-width-break" | "soft-hyphen" | "hard-break";
-
-/** A measured text segment ready for line breaking. */
-export type PreparedSegment = {
-	text: string;
-	width: number;
-	kind: SegmentBreakKind;
-	/** Grapheme widths for overflow-wrap: break-word (null if single grapheme). */
-	graphemeWidths: number[] | null;
-};
-
-/** A laid-out line with start/end cursors. */
-export type LayoutLine = {
-	text: string;
-	width: number;
-	startSegment: number;
-	startGrapheme: number;
-	endSegment: number;
-	endGrapheme: number;
-};
-
-/** Per-character position for hit testing. */
-export type CharPosition = {
-	x: number;
-	y: number;
-	width: number;
-	height: number;
-	line: number;
-};
-
-/** Full layout result from the line-breaks derived node. */
-export type LineBreaksResult = {
-	lines: LayoutLine[];
-	lineCount: number;
-};
-
-/**
- * A position within `PreparedSegment[]` — segment + grapheme offset.
- * `graphemeIndex: 0` at segment boundaries.
- *
- * Used by {@link layoutNextLine} for cursor-based line walking; needed when
- * lines have varying widths (multi-column flow, text wrapping around obstacles).
- */
-export type LayoutCursor = {
-	segmentIndex: number;
-	graphemeIndex: number;
-};
-
-/** A horizontal span `[left, right]` in pixels — used by flow-layout slot carving. */
-export type Interval = { left: number; right: number };
-
-/** Result of a single `layoutNextLine` call. */
-export type LayoutNextLineResult = {
-	text: string;
-	width: number;
-	start: LayoutCursor;
-	end: LayoutCursor;
-};
-
-/** Optional context for `layoutNextLine` — enables soft-hyphen visible-hyphen rendering. */
-export type LayoutNextLineContext = {
-	adapter?: MeasurementAdapter;
-	font?: string;
-	cache?: Map<string, Map<string, number>>;
-	/**
-	 * Optional {@link SegmentAdapter} for grapheme slicing during partial-segment
-	 * line builds. Defaults to {@link IntlSegmentAdapter} (lazy module shared);
-	 * Hermes / RN consumers wire their own to avoid the missing-`Intl.Segmenter`
-	 * runtime throw — see {@link SegmentAdapter} JSDoc.
-	 */
-	segmentAdapter?: SegmentAdapter;
-};
-
-/** Result of the reactive layout graph's describe-accessible state. */
-export type ReactiveLayoutBundle = {
-	graph: Graph;
-	/** Set input text. */
-	setText: (text: string) => void;
-	/** Set CSS font string. */
-	setFont: (font: string) => void;
-	/** Set line height (px). */
-	setLineHeight: (lineHeight: number) => void;
-	/** Set max width constraint (px). */
-	setMaxWidth: (maxWidth: number) => void;
-	/** Segments node. */
-	segments: Node<PreparedSegment[]>;
-	/** Line breaks node. */
-	lineBreaks: Node<LineBreaksResult>;
-	/** Total height node. */
-	height: Node<number>;
-	/** Per-character positions node. */
-	charPositions: Node<CharPosition[]>;
-};
-
-// ---------------------------------------------------------------------------
-// Text analysis (ported from Pretext analysis.ts — core subset)
-// ---------------------------------------------------------------------------
-
-// CJK detection (Unicode CJK Unified Ideographs + common ranges)
-function isCJK(s: string): boolean {
-	for (const ch of s) {
-		const c = ch.codePointAt(0)!;
-		if (
-			(c >= 0x4e00 && c <= 0x9fff) || // CJK Unified Ideographs
-			(c >= 0x3400 && c <= 0x4dbf) || // CJK Extension A
-			(c >= 0x3000 && c <= 0x303f) || // CJK Symbols and Punctuation
-			(c >= 0x3040 && c <= 0x309f) || // Hiragana
-			(c >= 0x30a0 && c <= 0x30ff) || // Katakana
-			(c >= 0xac00 && c <= 0xd7af) || // Hangul
-			(c >= 0xff00 && c <= 0xffef) // Fullwidth Forms
-		) {
-			return true;
-		}
-	}
-	return false;
-}
-
-// Kinsoku: characters that cannot start a line (CJK punctuation)
-const kinsokuStart = new Set([
-	"\uff0c",
-	"\uff0e",
-	"\uff01",
-	"\uff1a",
-	"\uff1b",
-	"\uff1f",
-	"\u3001",
-	"\u3002",
-	"\u30fb",
-	"\uff09",
-	"\u3015",
-	"\u3009",
-	"\u300b",
-	"\u300d",
-	"\u300f",
-	"\u3011",
-]);
-
-// Left-sticky punctuation (merges into preceding segment)
-const leftStickyPunctuation = new Set([
-	".",
-	",",
-	"!",
-	"?",
-	":",
-	";",
-	")",
-	"]",
-	"}",
-	"%",
-	'"',
-	"\u201d",
-	"\u2019",
-	"\u00bb",
-	"\u203a",
-	"\u2026",
-]);
-
-/** Normalize collapsible whitespace (CSS white-space: normal). */
-function normalizeWhitespace(text: string): string {
-	return text.replace(/[\t\n\r\f ]+/g, " ").replace(/^ | $/g, "");
-}
-
-/**
- * Segment text using the supplied {@link SegmentAdapter} (word granularity)
- * and classify break kinds. Returns raw segmentation pieces before merging.
- */
-function segmentText(
-	normalized: string,
-	segmentAdapter: SegmentAdapter,
-): {
-	texts: string[];
-	isWordLike: boolean[];
-	kinds: SegmentBreakKind[];
-}[] {
-	const pieces: {
-		texts: string[];
-		isWordLike: boolean[];
-		kinds: SegmentBreakKind[];
-	}[] = [];
-
-	for (const s of segmentAdapter.segmentWords(normalized)) {
-		const text = s.segment;
-		const isWordLike = s.isWordLike ?? false;
-
-		// Split segment by break-relevant characters
-		const texts: string[] = [];
-		const wordLikes: boolean[] = [];
-		const kinds: SegmentBreakKind[] = [];
-
-		let currentText = "";
-		let currentKind: SegmentBreakKind | null = null;
-
-		for (const ch of text) {
-			let kind: SegmentBreakKind;
-			if (ch === " ") kind = "space";
-			else if (ch === "\u200b") kind = "zero-width-break";
-			else if (ch === "\u00ad") kind = "soft-hyphen";
-			else if (ch === "\n") kind = "hard-break";
-			else kind = "text";
-
-			if (currentKind !== null && kind === currentKind) {
-				currentText += ch;
-			} else {
-				if (currentKind !== null) {
-					texts.push(currentText);
-					wordLikes.push(currentKind === "text" && isWordLike);
-					kinds.push(currentKind);
-				}
-				currentText = ch;
-				currentKind = kind;
-			}
-		}
-
-		if (currentKind !== null) {
-			texts.push(currentText);
-			wordLikes.push(currentKind === "text" && isWordLike);
-			kinds.push(currentKind);
-		}
-
-		pieces.push({ texts, isWordLike: wordLikes, kinds });
-	}
-	return pieces;
-}
-
-/**
- * Merge segmentation pieces: sticky punctuation, CJK per-grapheme splitting,
- * and produce the final measured segment list.
- */
-export function analyzeAndMeasure(
-	text: string,
-	font: string,
-	adapter: MeasurementAdapter,
-	cache: Map<string, Map<string, number>>,
-	stats?: SegmentMeasureStats,
-	segmentAdapter?: SegmentAdapter,
-): PreparedSegment[] {
-	const normalized = normalizeWhitespace(text);
-	if (normalized.length === 0) return [];
-
-	const segAdapter = segmentAdapter ?? getDefaultSegmentAdapter();
-	const pieces = segmentText(normalized, segAdapter);
-
-	// Flatten pieces into a single segment list with merging
-	const rawTexts: string[] = [];
-	const rawKinds: SegmentBreakKind[] = [];
-	const rawWordLike: boolean[] = [];
-
-	for (const piece of pieces) {
-		for (let i = 0; i < piece.texts.length; i++) {
-			rawTexts.push(piece.texts[i]!);
-			rawKinds.push(piece.kinds[i]!);
-			rawWordLike.push(piece.isWordLike[i]!);
-		}
-	}
-
-	// Merge: left-sticky punctuation and kinsoku-start into preceding text segment
-	const mergedTexts: string[] = [];
-	const mergedKinds: SegmentBreakKind[] = [];
-	const mergedWordLike: boolean[] = [];
-
-	for (let i = 0; i < rawTexts.length; i++) {
-		const t = rawTexts[i]!;
-		const k = rawKinds[i]!;
-		const wl = rawWordLike[i]!;
-
-		// Merge left-sticky punctuation into preceding text
-		if (
-			k === "text" &&
-			!wl &&
-			mergedTexts.length > 0 &&
-			mergedKinds[mergedKinds.length - 1] === "text"
-		) {
-			const isSticky = t.length === 1 && (leftStickyPunctuation.has(t) || kinsokuStart.has(t));
-			if (isSticky) {
-				mergedTexts[mergedTexts.length - 1] += t;
-				continue;
-			}
-		}
-
-		// Merge hyphen after word into preceding text ("well-known" stays together)
-		if (
-			t === "-" &&
-			mergedTexts.length > 0 &&
-			mergedKinds[mergedKinds.length - 1] === "text" &&
-			mergedWordLike[mergedWordLike.length - 1]
-		) {
-			mergedTexts[mergedTexts.length - 1] += t;
-			continue;
-		}
-
-		mergedTexts.push(t);
-		mergedKinds.push(k);
-		mergedWordLike.push(wl);
-	}
-
-	// Get or create font-specific cache
-	let fontCache = cache.get(font);
-	if (!fontCache) {
-		fontCache = new Map<string, number>();
-		cache.set(font, fontCache);
-	}
-
-	function measureCached(seg: string): number {
-		let w = fontCache!.get(seg);
-		if (w === undefined) {
-			if (stats) stats.misses += 1;
-			const raw = adapter.measureSegment(seg, font).width;
-			// Coerce adapter misbehavior (NaN / Infinity / negative) to 0 — downstream
-			// arithmetic would propagate NaN widths, breaking line-break decisions and
-			// rendering. Cached so the coercion happens once per (font, segment).
-			w = Number.isFinite(raw) && raw >= 0 ? raw : 0;
-			fontCache!.set(seg, w);
-		} else if (stats) {
-			stats.hits += 1;
-		}
-		return w;
-	}
-
-	// Build final prepared segments, splitting CJK into per-grapheme
-	const segments: PreparedSegment[] = [];
-
-	for (let i = 0; i < mergedTexts.length; i++) {
-		const t = mergedTexts[i]!;
-		const k = mergedKinds[i]!;
-
-		if (k !== "text") {
-			// Non-text segments: space, hard-break, soft-hyphen, zero-width-break
-			segments.push({
-				text: t,
-				width: k === "space" ? measureCached(" ") * t.length : 0,
-				kind: k,
-				graphemeWidths: null,
-			});
-			continue;
-		}
-
-		// CJK text: split into per-grapheme segments for line breaking
-		if (isCJK(t)) {
-			let unitText = "";
-			for (const gs of segAdapter.segmentGraphemes(t)) {
-				const grapheme = gs.segment;
-
-				// Kinsoku: line-start-prohibited chars stick to preceding unit
-				if (unitText.length > 0 && kinsokuStart.has(grapheme)) {
-					unitText += grapheme;
-					continue;
-				}
-
-				if (unitText.length > 0) {
-					const w = measureCached(unitText);
-					segments.push({
-						text: unitText,
-						width: w,
-						kind: "text",
-						graphemeWidths: null,
-					});
-				}
-				unitText = grapheme;
-			}
-			if (unitText.length > 0) {
-				const w = measureCached(unitText);
-				segments.push({
-					text: unitText,
-					width: w,
-					kind: "text",
-					graphemeWidths: null,
-				});
-			}
-			continue;
-		}
-
-		// Non-CJK text: measure whole segment, pre-compute grapheme widths for break-word
-		const w = measureCached(t);
-		let graphemeWidths: number[] | null = null;
-
-		if (mergedWordLike[i] && t.length > 1) {
-			const gWidths: number[] = [];
-			for (const gs of segAdapter.segmentGraphemes(t)) {
-				gWidths.push(measureCached(gs.segment));
-			}
-			if (gWidths.length > 1) {
-				graphemeWidths = gWidths;
-			}
-		}
-
-		segments.push({ text: t, width: w, kind: "text", graphemeWidths });
-	}
-
-	return segments;
-}
-
-// ---------------------------------------------------------------------------
-// Line breaking (greedy, ported from Pretext line-break.ts — core subset)
-// ---------------------------------------------------------------------------
-
-/**
- * Greedy line-breaking algorithm.
- *
- * Walks segments left to right, accumulating width. Breaks when a segment would
- * overflow maxWidth. Supports:
- * - Trailing space hang (spaces don't trigger breaks)
- * - overflow-wrap: break-word via grapheme widths
- * - Soft hyphens (break opportunity, adds visible hyphen width)
- * - Hard breaks (forced newline)
- */
-export function computeLineBreaks(
-	segments: PreparedSegment[],
-	maxWidth: number,
-	adapter: MeasurementAdapter,
-	font: string,
-	cache: Map<string, Map<string, number>>,
-	segmentAdapter?: SegmentAdapter,
-): LineBreaksResult {
-	if (segments.length === 0) {
-		return { lines: [], lineCount: 0 };
-	}
-	const segAdapter = segmentAdapter ?? getDefaultSegmentAdapter();
-
-	const lines: LayoutLine[] = [];
-	let lineW = 0;
-	let hasContent = false;
-	let lineStartSeg = 0;
-	let lineStartGrapheme = 0;
-	let lineEndSeg = 0;
-	let lineEndGrapheme = 0;
-	let pendingBreakSeg = -1;
-	let pendingBreakWidth = 0;
-
-	// Measure hyphen for soft-hyphen support
-	let fontCache = cache.get(font);
-	if (!fontCache) {
-		fontCache = new Map<string, number>();
-		cache.set(font, fontCache);
-	}
-	let hyphenWidth = fontCache.get("-");
-	if (hyphenWidth === undefined) {
-		hyphenWidth = adapter.measureSegment("-", font).width;
-		fontCache.set("-", hyphenWidth);
-	}
-
-	function flushLine(endSeg = lineEndSeg, endGrapheme = lineEndGrapheme, width = lineW) {
-		// Build line text
-		let text = "";
-		for (let i = lineStartSeg; i < endSeg; i++) {
-			const seg = segments[i]!;
-			if (seg.kind === "soft-hyphen" || seg.kind === "hard-break") continue;
-			if (i === lineStartSeg && lineStartGrapheme > 0 && seg.graphemeWidths) {
-				// Partial segment from grapheme break
-				const graphemes = [...segAdapter.segmentGraphemes(seg.text)].map((g) => g.segment);
-				text += graphemes.slice(lineStartGrapheme).join("");
-			} else {
-				text += seg.text;
-			}
-		}
-		// Handle partial end segment
-		if (endGrapheme > 0 && endSeg < segments.length) {
-			const seg = segments[endSeg]!;
-			const graphemes = [...segAdapter.segmentGraphemes(seg.text)].map((g) => g.segment);
-			const startG = lineStartSeg === endSeg ? lineStartGrapheme : 0;
-			text += graphemes.slice(startG, endGrapheme).join("");
-		}
-		// Add visible hyphen if line ends at soft-hyphen
-		if (
-			endSeg > 0 &&
-			segments[endSeg - 1]?.kind === "soft-hyphen" &&
-			!(lineStartSeg === endSeg && lineStartGrapheme > 0)
-		) {
-			text += "-";
-		}
-
-		lines.push({
-			text,
-			width,
-			startSegment: lineStartSeg,
-			startGrapheme: lineStartGrapheme,
-			endSegment: endSeg,
-			endGrapheme,
-		});
-		lineW = 0;
-		hasContent = false;
-		pendingBreakSeg = -1;
-		pendingBreakWidth = 0;
-	}
-
-	function canBreakAfter(kind: SegmentBreakKind): boolean {
-		return kind === "space" || kind === "zero-width-break" || kind === "soft-hyphen";
-	}
-
-	function startLine(segIdx: number, graphemeIdx: number, width: number) {
-		hasContent = true;
-		lineStartSeg = segIdx;
-		lineStartGrapheme = graphemeIdx;
-		lineEndSeg = segIdx + 1;
-		lineEndGrapheme = 0;
-		lineW = width;
-	}
-
-	function startLineAtGrapheme(segIdx: number, graphemeIdx: number, width: number) {
-		hasContent = true;
-		lineStartSeg = segIdx;
-		lineStartGrapheme = graphemeIdx;
-		lineEndSeg = segIdx;
-		lineEndGrapheme = graphemeIdx + 1;
-		lineW = width;
-	}
-
-	for (let i = 0; i < segments.length; i++) {
-		const seg = segments[i]!;
-
-		// Hard break: emit current line, start fresh
-		if (seg.kind === "hard-break") {
-			if (hasContent) {
-				flushLine();
-			} else {
-				// Empty line
-				lines.push({
-					text: "",
-					width: 0,
-					startSegment: i,
-					startGrapheme: 0,
-					endSegment: i,
-					endGrapheme: 0,
-				});
-			}
-			lineStartSeg = i + 1;
-			lineStartGrapheme = 0;
-			continue;
-		}
-
-		const w = seg.width;
-
-		if (!hasContent) {
-			// First content on a new line
-			if (w > maxWidth && seg.graphemeWidths) {
-				// Word wider than maxWidth: break at grapheme level
-				appendBreakableSegment(i, 0, seg.graphemeWidths);
-			} else {
-				startLine(i, 0, w);
-			}
-			if (canBreakAfter(seg.kind)) {
-				pendingBreakSeg = i + 1;
-				pendingBreakWidth = seg.kind === "space" ? lineW - w : lineW;
-			}
-			continue;
-		}
-
-		const newW = lineW + w;
-
-		if (newW > maxWidth + 0.005) {
-			// Overflow
-			if (canBreakAfter(seg.kind)) {
-				// Trailing space: hang past edge, then break
-				lineW += w;
-				lineEndSeg = i + 1;
-				lineEndGrapheme = 0;
-				flushLine(i + 1, 0, seg.kind === "space" ? lineW - w : lineW);
-				continue;
-			}
-
-			if (pendingBreakSeg >= 0) {
-				// Break at last break opportunity
-				flushLine(pendingBreakSeg, 0, pendingBreakWidth);
-				// Don't advance i — re-process current segment on new line
-				i--;
-				continue;
-			}
-
-			if (w > maxWidth && seg.graphemeWidths) {
-				// Break-word: split at grapheme level
-				flushLine();
-				appendBreakableSegment(i, 0, seg.graphemeWidths);
-				continue;
-			}
-
-			// No break opportunity: force break before this segment
-			flushLine();
-			i--;
-			continue;
-		}
-
-		// Fits on current line
-		lineW = newW;
-		lineEndSeg = i + 1;
-		lineEndGrapheme = 0;
-
-		if (canBreakAfter(seg.kind)) {
-			pendingBreakSeg = i + 1;
-			pendingBreakWidth = seg.kind === "space" ? lineW - w : lineW;
-		}
-	}
-
-	if (hasContent) {
-		flushLine();
-	}
-
-	return { lines, lineCount: lines.length };
-
-	function appendBreakableSegment(segIdx: number, startG: number, gWidths: number[]) {
-		for (let g = startG; g < gWidths.length; g++) {
-			const gw = gWidths[g]!;
-			if (!hasContent) {
-				startLineAtGrapheme(segIdx, g, gw);
-				continue;
-			}
-			if (lineW + gw > maxWidth + 0.005) {
-				flushLine();
-				startLineAtGrapheme(segIdx, g, gw);
-			} else {
-				lineW += gw;
-				lineEndSeg = segIdx;
-				lineEndGrapheme = g + 1;
-			}
-		}
-		// If we consumed the whole segment, advance end past it
-		if (hasContent && lineEndSeg === segIdx && lineEndGrapheme === gWidths.length) {
-			lineEndSeg = segIdx + 1;
-			lineEndGrapheme = 0;
-		}
-	}
-}
-
-// ---------------------------------------------------------------------------
-// Cursor-based single-line layout (for multi-column flow / shape wrapping)
-// ---------------------------------------------------------------------------
-
-function canBreakAfter(kind: SegmentBreakKind): boolean {
-	return kind === "space" || kind === "zero-width-break" || kind === "soft-hyphen";
-}
-
-function sliceSegmentText(
-	seg: PreparedSegment,
-	startG: number,
-	endG: number,
-	segmentAdapter: SegmentAdapter,
-): string {
-	if (startG === 0 && endG < 0) return seg.text;
-	const graphemes = [...segmentAdapter.segmentGraphemes(seg.text)].map((g) => g.segment);
-	const stop = endG < 0 ? graphemes.length : endG;
-	return graphemes.slice(startG, stop).join("");
-}
-
-function buildLineText(
-	segments: PreparedSegment[],
-	startSeg: number,
-	startG: number,
-	endSeg: number,
-	endG: number,
-	appendHyphen: boolean,
-	segmentAdapter: SegmentAdapter,
-): string {
-	let text = "";
-	for (let i = startSeg; i < endSeg; i++) {
-		const seg = segments[i]!;
-		if (seg.kind === "soft-hyphen" || seg.kind === "hard-break") continue;
-		if (i === startSeg && startG > 0) {
-			text += sliceSegmentText(seg, startG, -1, segmentAdapter);
-		} else {
-			text += seg.text;
-		}
-	}
-	if (endG > 0 && endSeg < segments.length) {
-		const seg = segments[endSeg]!;
-		const from = startSeg === endSeg ? startG : 0;
-		text += sliceSegmentText(seg, from, endG, segmentAdapter);
-	}
-	if (appendHyphen) text += "-";
-	return text;
-}
-
-function resolveHyphenWidth(ctx: LayoutNextLineContext | undefined): number {
-	if (!ctx?.adapter || !ctx.font) return 0;
-	const cache = ctx.cache;
-	if (cache) {
-		let fc = cache.get(ctx.font);
-		if (!fc) {
-			fc = new Map<string, number>();
-			cache.set(ctx.font, fc);
-		}
-		let hw = fc.get("-");
-		if (hw === undefined) {
-			hw = ctx.adapter.measureSegment("-", ctx.font).width;
-			fc.set("-", hw);
-		}
-		return hw;
-	}
-	return ctx.adapter.measureSegment("-", ctx.font).width;
-}
-
-/**
- * Lay out the next single line starting from `cursor`, fitting into `slotWidth`.
- *
- * Unlike `computeLineBreaks`, which consumes whole text with one `maxWidth`,
- * this is the cursor-based primitive needed when successive lines have different
- * widths (multi-column flow, text wrapping around shape obstacles, mixed
- * column+pullquote layouts).
- *
- * Returns `null` when the cursor is past all segments (text exhausted).
- * At a hard-break with no preceding content, returns an empty line and advances
- * the cursor past the break so the caller can continue.
- *
- * ```ts
- * let cursor: LayoutCursor = { segmentIndex: 0, graphemeIndex: 0 };
- * while (true) {
- *   const line = layoutNextLine(segments, cursor, availableWidth);
- *   if (line === null) break;
- *   render(line);
- *   cursor = line.end;
- * }
- * ```
- */
-export function layoutNextLine(
-	segments: PreparedSegment[],
-	cursor: LayoutCursor,
-	slotWidth: number,
-	ctx?: LayoutNextLineContext,
-): LayoutNextLineResult | null {
-	let i = cursor.segmentIndex;
-	const initialG = cursor.graphemeIndex;
-	const segAdapter = ctx?.segmentAdapter ?? getDefaultSegmentAdapter();
-
-	if (i >= segments.length) return null;
-
-	if (initialG === 0) {
-		while (i < segments.length) {
-			const seg = segments[i]!;
-			if (seg.kind === "hard-break") {
-				return {
-					text: "",
-					width: 0,
-					start: { segmentIndex: cursor.segmentIndex, graphemeIndex: 0 },
-					end: { segmentIndex: i + 1, graphemeIndex: 0 },
-				};
-			}
-			if (seg.kind === "space" || seg.kind === "zero-width-break" || seg.kind === "soft-hyphen") {
-				i += 1;
-				continue;
-			}
-			break;
-		}
-		if (i >= segments.length) return null;
-	}
-
-	const hyphenWidth = resolveHyphenWidth(ctx);
-
-	const startSeg = i;
-	const startG = i === cursor.segmentIndex ? initialG : 0;
-
-	let lineW = 0;
-	let lineEndSeg = startSeg;
-	let lineEndG = 0;
-	let hasContent = false;
-	let pendingBreakSeg = -1;
-	let pendingBreakG = 0;
-	let pendingBreakWidth = 0;
-	let pendingBreakSoftHyphen = false;
-
-	const recordPending = (
-		sIdx: number,
-		gIdx: number,
-		widthAtBreak: number,
-		kind: SegmentBreakKind,
-	): void => {
-		pendingBreakSeg = sIdx;
-		pendingBreakG = gIdx;
-		pendingBreakWidth = widthAtBreak;
-		pendingBreakSoftHyphen = kind === "soft-hyphen";
-	};
-
-	const consumeBreakable = (segIdx: number, gStart: number, gWidths: number[]): boolean => {
-		for (let g = gStart; g < gWidths.length; g++) {
-			const gw = gWidths[g]!;
-			if (!hasContent) {
-				lineW = gw;
-				lineEndSeg = segIdx;
-				lineEndG = g + 1;
-				hasContent = true;
-				continue;
-			}
-			if (lineW + gw > slotWidth + 0.005) {
-				return true;
-			}
-			lineW += gw;
-			lineEndSeg = segIdx;
-			lineEndG = g + 1;
-		}
-		if (lineEndSeg === segIdx && lineEndG === gWidths.length) {
-			lineEndSeg = segIdx + 1;
-			lineEndG = 0;
-		}
-		return false;
-	};
-
-	if (startG > 0 && startSeg < segments.length) {
-		const seg = segments[startSeg]!;
-		if (seg.graphemeWidths) {
-			const overflowed = consumeBreakable(startSeg, startG, seg.graphemeWidths);
-			if (overflowed) {
-				const text = buildLineText(
-					segments,
-					startSeg,
-					startG,
-					lineEndSeg,
-					lineEndG,
-					false,
-					segAdapter,
-				);
-				return {
-					text,
-					width: lineW,
-					start: { segmentIndex: startSeg, graphemeIndex: startG },
-					end: { segmentIndex: lineEndSeg, graphemeIndex: lineEndG },
-				};
-			}
-			i = lineEndSeg;
-		} else {
-			// Mid-segment cursor on a non-breakable segment is an invariant
-			// violation (cursor should only advance to a grapheme boundary via
-			// `consumeBreakable` on a segment that HAS graphemeWidths). Treat as
-			// segment-start so the caller gets well-formed output instead of
-			// silently re-including the prefix.
-			//
-			// Not reachable through `computeFlowLines` but possible with
-			// externally-constructed cursors.
-		}
-	}
-
-	for (; i < segments.length; ) {
-		const seg = segments[i]!;
-
-		if (seg.kind === "hard-break") {
-			if (hasContent) {
-				const endsAtSoftHyphen = lineEndSeg > 0 && segments[lineEndSeg - 1]?.kind === "soft-hyphen";
-				const text = buildLineText(
-					segments,
-					startSeg,
-					startG,
-					lineEndSeg,
-					lineEndG,
-					endsAtSoftHyphen,
-					segAdapter,
-				);
-				return {
-					text,
-					width: lineW + (endsAtSoftHyphen ? hyphenWidth : 0),
-					start: { segmentIndex: startSeg, graphemeIndex: startG },
-					end: { segmentIndex: lineEndSeg, graphemeIndex: lineEndG },
-				};
-			}
-			return {
-				text: "",
-				width: 0,
-				start: { segmentIndex: startSeg, graphemeIndex: startG },
-				end: { segmentIndex: i + 1, graphemeIndex: 0 },
-			};
-		}
-
-		const w = seg.width;
-
-		if (!hasContent) {
-			if (w > slotWidth && seg.graphemeWidths) {
-				const overflowed = consumeBreakable(i, 0, seg.graphemeWidths);
-				if (overflowed) {
-					const text = buildLineText(
-						segments,
-						startSeg,
-						startG,
-						lineEndSeg,
-						lineEndG,
-						false,
-						segAdapter,
-					);
-					return {
-						text,
-						width: lineW,
-						start: { segmentIndex: startSeg, graphemeIndex: startG },
-						end: { segmentIndex: lineEndSeg, graphemeIndex: lineEndG },
-					};
-				}
-				// No `recordPending` here: segments with `graphemeWidths` are always
-				// `kind === "text"` (see `analyzeAndMeasure`), which is not a break-
-				// after kind, so the check would always fail.
-				i = lineEndSeg;
-				continue;
-			}
-			lineW = w;
-			lineEndSeg = i + 1;
-			lineEndG = 0;
-			hasContent = true;
-			if (canBreakAfter(seg.kind)) {
-				recordPending(i + 1, 0, seg.kind === "space" ? lineW - w : lineW, seg.kind);
-			}
-			i += 1;
-			continue;
-		}
-
-		const newW = lineW + w;
-
-		if (newW > slotWidth + 0.005) {
-			if (canBreakAfter(seg.kind)) {
-				// `lineW` is carried from before this segment — no mutation needed;
-				// trailing space/soft-hyphen width is excluded from the line width.
-				lineEndSeg = i + 1;
-				lineEndG = 0;
-				const endsAtSoftHyphen = seg.kind === "soft-hyphen";
-				const finalWidth =
-					seg.kind === "space" ? lineW : lineW + (endsAtSoftHyphen ? hyphenWidth : 0);
-				const text = buildLineText(
-					segments,
-					startSeg,
-					startG,
-					lineEndSeg,
-					lineEndG,
-					endsAtSoftHyphen,
-					segAdapter,
-				);
-				return {
-					text,
-					width: finalWidth,
-					start: { segmentIndex: startSeg, graphemeIndex: startG },
-					end: { segmentIndex: lineEndSeg, graphemeIndex: lineEndG },
-				};
-			}
-
-			if (pendingBreakSeg >= 0) {
-				const text = buildLineText(
-					segments,
-					startSeg,
-					startG,
-					pendingBreakSeg,
-					pendingBreakG,
-					pendingBreakSoftHyphen,
-					segAdapter,
-				);
-				return {
-					text,
-					width: pendingBreakWidth + (pendingBreakSoftHyphen ? hyphenWidth : 0),
-					start: { segmentIndex: startSeg, graphemeIndex: startG },
-					end: { segmentIndex: pendingBreakSeg, graphemeIndex: pendingBreakG },
-				};
-			}
-
-			if (w > slotWidth && seg.graphemeWidths) {
-				const text = buildLineText(
-					segments,
-					startSeg,
-					startG,
-					lineEndSeg,
-					lineEndG,
-					false,
-					segAdapter,
-				);
-				return {
-					text,
-					width: lineW,
-					start: { segmentIndex: startSeg, graphemeIndex: startG },
-					end: { segmentIndex: lineEndSeg, graphemeIndex: lineEndG },
-				};
-			}
-
-			const text = buildLineText(
-				segments,
-				startSeg,
-				startG,
-				lineEndSeg,
-				lineEndG,
-				false,
-				segAdapter,
-			);
-			return {
-				text,
-				width: lineW,
-				start: { segmentIndex: startSeg, graphemeIndex: startG },
-				end: { segmentIndex: lineEndSeg, graphemeIndex: lineEndG },
-			};
-		}
-
-		lineW = newW;
-		lineEndSeg = i + 1;
-		lineEndG = 0;
-		if (canBreakAfter(seg.kind)) {
-			recordPending(i + 1, 0, seg.kind === "space" ? lineW - w : lineW, seg.kind);
-		}
-		i += 1;
-	}
-
-	if (!hasContent) return null;
-
-	const endsAtSoftHyphen = lineEndSeg > 0 && segments[lineEndSeg - 1]?.kind === "soft-hyphen";
-	const text = buildLineText(
-		segments,
-		startSeg,
-		startG,
-		lineEndSeg,
-		lineEndG,
-		endsAtSoftHyphen,
-		segAdapter,
-	);
-	return {
-		text,
-		width: lineW + (endsAtSoftHyphen ? hyphenWidth : 0),
-		start: { segmentIndex: startSeg, graphemeIndex: startG },
-		end: { segmentIndex: lineEndSeg, graphemeIndex: lineEndG },
-	};
-}
-
-// ---------------------------------------------------------------------------
-// Slot carving (flow-layout helper)
-// ---------------------------------------------------------------------------
-
-/**
- * Subtract blocked horizontal intervals from a base interval, producing
- * remaining ordered, non-overlapping slots wide enough to fit text.
- *
- * Pure geometry — no text dependency. Used by flow-layout to turn obstacle
- * intersections into per-line layout slots.
- *
- * ```ts
- * carveTextLineSlots({left: 0, right: 600}, [{left: 200, right: 280}])
- * // → [{left: 0, right: 200}, {left: 280, right: 600}]
- * ```
- */
-export function carveTextLineSlots(
-	base: Interval,
-	blocked: Interval[],
-	minSlotWidth = 0,
-): Interval[] {
-	let slots: Interval[] = [base];
-	for (let bi = 0; bi < blocked.length; bi++) {
-		const block = blocked[bi]!;
-		const next: Interval[] = [];
-		for (let si = 0; si < slots.length; si++) {
-			const slot = slots[si]!;
-			if (block.right <= slot.left || block.left >= slot.right) {
-				next.push(slot);
-				continue;
-			}
-			if (block.left > slot.left) next.push({ left: slot.left, right: block.left });
-			if (block.right < slot.right) next.push({ left: block.right, right: slot.right });
-		}
-		slots = next;
-	}
-	if (minSlotWidth > 0) {
-		return slots.filter((s) => s.right - s.left >= minSlotWidth);
-	}
-	return slots;
-}
-
-// ---------------------------------------------------------------------------
-// Character positions
-// ---------------------------------------------------------------------------
-
-/** Compute per-character x,y positions from line breaks and segments. */
-export function computeCharPositions(
-	lineBreaks: LineBreaksResult,
-	segments: PreparedSegment[],
-	lineHeight: number,
-	segmentAdapter?: SegmentAdapter,
-): CharPosition[] {
-	const positions: CharPosition[] = [];
-	const segAdapter = segmentAdapter ?? getDefaultSegmentAdapter();
-
-	for (let lineIdx = 0; lineIdx < lineBreaks.lines.length; lineIdx++) {
-		const line = lineBreaks.lines[lineIdx]!;
-		const y = lineIdx * lineHeight;
-		let x = 0;
-
-		for (let si = line.startSegment; si < segments.length; si++) {
-			const seg = segments[si]!;
-			if (seg.kind === "soft-hyphen" || seg.kind === "hard-break") {
-				// Skip non-visual segments but stop if past the line
-				if (si >= line.endSegment && line.endGrapheme === 0) break;
-				continue;
-			}
-
-			const graphemes = [...segAdapter.segmentGraphemes(seg.text)].map((g) => g.segment);
-			if (graphemes.length === 0) continue;
-			const startG = si === line.startSegment ? line.startGrapheme : 0;
-
-			// Determine how many graphemes of this segment belong to this line
-			let endG: number;
-			if (si < line.endSegment) {
-				// Full segment is on this line
-				endG = graphemes.length;
-			} else if (si === line.endSegment && line.endGrapheme > 0) {
-				// Partial segment (grapheme-level break)
-				endG = line.endGrapheme;
-			} else {
-				// Past the line's content
-				break;
-			}
-
-			for (let g = startG; g < endG; g++) {
-				const gWidth = seg.graphemeWidths ? seg.graphemeWidths[g]! : seg.width / graphemes.length;
-				positions.push({ x, y, width: gWidth, height: lineHeight, line: lineIdx });
-				x += gWidth;
-			}
-		}
-	}
-
-	return positions;
-}
-
-// ---------------------------------------------------------------------------
-// Reactive graph factory
-// ---------------------------------------------------------------------------
-
-export type ReactiveLayoutOptions = {
-	/** Measurement backend (required). */
-	adapter: MeasurementAdapter;
-	/**
-	 * Segmentation backend (optional). Defaults to a lazy {@link IntlSegmentAdapter}
-	 * (uses platform `Intl.Segmenter`). **Required on Hermes / RN** where
-	 * `Intl.Segmenter` is undefined — wire a polyfilled {@link SegmentAdapter}
-	 * here. See {@link SegmentAdapter} JSDoc for the polyfill recipe.
-	 */
-	segmentAdapter?: SegmentAdapter;
-	/** Graph name (default: "reactive-layout"). */
-	name?: string;
-	/** Initial text. */
-	text?: string;
-	/** Initial CSS font string. */
-	font?: string;
-	/** Initial line height in px. */
-	lineHeight?: number;
-	/** Initial max width in px (clamped to ≥ 0). */
-	maxWidth?: number;
-};
-
-/**
- * Create a reactive text layout graph.
- *
- * ```
- * Graph("reactive-layout")
- * ├── node([], { initial: "text" })
- * ├── node([], { initial: "font" })
- * ├── node([], { initial: "line-height" })
- * ├── node([], { initial: "max-width" })
- * ├── derived("segments")      — text + font → PreparedSegment[]
- * ├── derived("line-breaks")   — segments + max-width → LineBreaksResult
- * ├── derived("height")        — line-breaks → number
- * └── derived("char-positions") — line-breaks + segments → CharPosition[]
- * ```
- */
-export function reactiveLayout(opts: ReactiveLayoutOptions): ReactiveLayoutBundle {
-	const { adapter, segmentAdapter: segmentAdapterOpt, name = "reactive-layout" } = opts;
-	// Resolve eagerly so a Hermes consumer without an explicit `segmentAdapter`
-	// sees the clear `IntlSegmentAdapter` "supply a SegmentAdapter" error at
-	// factory construction time (not later, on first text wave). When the
-	// caller wires their own, no `Intl.Segmenter` access happens here.
-	const segmentAdapter: SegmentAdapter = segmentAdapterOpt ?? getDefaultSegmentAdapter();
-	const g = new Graph(name);
-
-	// Shared measurement cache: Map<font, Map<segment, width>>
-	const measureCache = new Map<string, Map<string, number>>();
-
-	// --- State nodes ---
-	const textNode = node<string>([], { name: "text", initial: opts.text ?? "" });
-	const fontNode = node<string>([], {
-		name: "font",
-		initial: opts.font ?? "16px sans-serif",
-	});
-	const lineHeightNode = node<number>([], {
-		name: "line-height",
-		initial: opts.lineHeight ?? 20,
-	});
-	const maxWidthNode = node<number>([], {
-		name: "max-width",
-		initial: Math.max(0, opts.maxWidth ?? 800),
-	});
-
-	// --- Derived: segments (text + font → PreparedSegment[]) ---
-	function graphemeWidthsEqual(a: number[] | null, b: number[] | null): boolean {
-		if (a === null || b === null) return a === b;
-		if (a.length !== b.length) return false;
-		for (let i = 0; i < a.length; i++) {
-			if (a[i] !== b[i]!) return false;
-		}
-		return true;
-	}
-
-	// Raw `node(...)` instead of `derived(...)` so the fn can return a
-	// cleanup function. Core fires function-form cleanup on INVALIDATE (see
-	// `node.ts:_updateState` INVALIDATE branch), which replaces the old v4
-	// per-node `onMessage` hook that watched for INVALIDATE/TEARDOWN to flush
-	// measurement caches.
-	const segmentsNode: Node<PreparedSegment[]> = node<PreparedSegment[]>(
-		[textNode, fontNode],
-		(data, actions, ctx) => {
-			const b0 = data[0];
-			const textVal = (b0 != null && b0.length > 0 ? b0.at(-1) : ctx.prevData[0]) as string;
-			const b1 = data[1];
-			const fontVal = (b1 != null && b1.length > 0 ? b1.at(-1) : ctx.prevData[1]) as string;
-			const t0 = monotonicNs();
-			const measureStats: SegmentMeasureStats = { hits: 0, misses: 0 };
-			const result = analyzeAndMeasure(
-				textVal as string,
-				fontVal as string,
-				adapter,
-				measureCache,
-				measureStats,
-				segmentAdapter,
-			);
-			const elapsed = monotonicNs() - t0;
-
-			const lookups = measureStats.hits + measureStats.misses;
-			const hitRate = lookups === 0 ? 1 : measureStats.hits / lookups;
-
-			// After parent `segments` emits, deliver metrics via phase-3 deferral
-			// so observers see the parent value first.
-			// Forwards via `emitToMeta` (see `patterns/_internal.ts`).
-			const meta = segmentsNode.meta;
-			if (meta) {
-				emitToMeta(meta["cache-hit-rate"], hitRate);
-				emitToMeta(meta["segment-count"], result.length);
-				emitToMeta(meta["layout-time-ns"], elapsed);
-			}
-
-			actions.emit(result);
-
-			// Object-form cleanup: fires on deactivation AND on INVALIDATE, but
-			// NOT before re-runs. Re-runs that edit text / font retain the
-			// measurement cache — the per-segment entries still valid for the
-			// new text overlap the previous set and are reused. Before-run
-			// flushing (previous behaviour) wiped 100-segment caches on a
-			// one-character edit; this shape keeps cache hit-rate proportional
-			// to content overlap rather than invalidation frequency.
-			const flush = (): void => {
-				measureCache.clear();
-				adapter.clearCache?.();
-			};
-			return { onDeactivation: flush, onInvalidate: flush };
-		},
-		{
-			name: "segments",
-			describeKind: "derived",
-			meta: {
-				"cache-hit-rate": 0,
-				"segment-count": 0,
-				"layout-time-ns": 0,
-			},
-			equals: (a, b) => {
-				const sa = a as PreparedSegment[] | null;
-				const sb = b as PreparedSegment[] | null;
-				if (sa == null || sb == null) return sa === sb;
-				if (sa.length !== sb.length) return false;
-				for (let i = 0; i < sa.length; i++) {
-					const pa = sa[i]!;
-					const pb = sb[i]!;
-					if (
-						pa.text !== pb.text ||
-						pa.width !== pb.width ||
-						pa.kind !== pb.kind ||
-						!graphemeWidthsEqual(pa.graphemeWidths ?? null, pb.graphemeWidths ?? null)
-					)
-						return false;
-				}
-				return true;
-			},
-		},
-	);
-
-	// --- Derived: line-breaks (segments + max-width + font → LineBreaksResult) ---
-	const lineBreaksNode = node<LineBreaksResult>(
-		[segmentsNode, maxWidthNode, fontNode],
-		(batchData, actions, ctx) => {
-			const data = batchData.map((batch, i) =>
-				batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-			);
-			actions.emit(
-				computeLineBreaks(
-					data[0] as PreparedSegment[],
-					data[1] as number,
-					adapter,
-					data[2] as string,
-					measureCache,
-					segmentAdapter,
-				),
-			);
-		},
-		{
-			name: "line-breaks",
-			describeKind: "derived",
-			equals: (a, b) => {
-				const la = a as LineBreaksResult | null;
-				const lb = b as LineBreaksResult | null;
-				if (la == null || lb == null) return la === lb;
-				if (la.lineCount !== lb.lineCount) return false;
-				for (let i = 0; i < la.lines.length; i++) {
-					const lineA = la.lines[i]!;
-					const lineB = lb.lines[i]!;
-					if (
-						lineA.text !== lineB.text ||
-						lineA.width !== lineB.width ||
-						lineA.startSegment !== lineB.startSegment ||
-						lineA.startGrapheme !== lineB.startGrapheme ||
-						lineA.endSegment !== lineB.endSegment ||
-						lineA.endGrapheme !== lineB.endGrapheme
-					)
-						return false;
-				}
-				return true;
-			},
-		},
-	);
-
-	// --- Derived: height ---
-	const heightNode = node<number>(
-		[lineBreaksNode, lineHeightNode],
-		(batchData, actions, ctx) => {
-			const data = batchData.map((batch, i) =>
-				batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-			);
-			actions.emit((data[0] as LineBreaksResult).lineCount * (data[1] as number));
-		},
-		{ describeKind: "derived", name: "height" },
-	);
-
-	// --- Derived: char-positions ---
-	const charPositionsNode = node<CharPosition[]>(
-		[lineBreaksNode, segmentsNode, lineHeightNode],
-		(batchData, actions, ctx) => {
-			const data = batchData.map((batch, i) =>
-				batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-			);
-			actions.emit(
-				computeCharPositions(
-					data[0] as LineBreaksResult,
-					data[1] as PreparedSegment[],
-					data[2] as number,
-					segmentAdapter,
-				),
-			);
-		},
-		{
-			name: "char-positions",
-			describeKind: "derived",
-			equals: (a, b) => {
-				const ca = a as CharPosition[] | null;
-				const cb = b as CharPosition[] | null;
-				if (ca == null || cb == null) return ca === cb;
-				if (ca.length !== cb.length) return false;
-				for (let i = 0; i < ca.length; i++) {
-					if (ca[i]!.x !== cb[i]!.x || ca[i]!.y !== cb[i]!.y || ca[i]!.width !== cb[i]!.width)
-						return false;
-				}
-				return true;
-			},
-		},
-	);
-
-	// --- Register in graph ---
-	g.add(textNode, { name: "text" });
-	g.add(fontNode, { name: "font" });
-	g.add(lineHeightNode, { name: "line-height" });
-	g.add(maxWidthNode, { name: "max-width" });
-	g.add(segmentsNode, { name: "segments" });
-	g.add(lineBreaksNode, { name: "line-breaks" });
-	g.add(heightNode, { name: "height" });
-	g.add(charPositionsNode, { name: "char-positions" });
-
-	// --- Edges (for describe() visibility) ---
-
-	return {
-		graph: g,
-		setText: (text: string) => g.set("text", text),
-		setFont: (font: string) => g.set("font", font),
-		setLineHeight: (lh: number) => g.set("line-height", lh),
-		setMaxWidth: (mw: number) => g.set("max-width", Math.max(0, mw)),
-		segments: segmentsNode,
-		lineBreaks: lineBreaksNode,
-		height: heightNode,
-		charPositions: charPositionsNode,
-	};
-}
diff --git a/src/utils/reduction/index.ts b/src/utils/reduction/index.ts
deleted file mode 100644
index 7864d080..00000000
--- a/src/utils/reduction/index.ts
+++ /dev/null
@@ -1,341 +0,0 @@
-/**
- * Reduction primitives (roadmap §8.1).
- *
- * Composable building blocks for taking heterogeneous massive inputs and producing
- * prioritized, auditable, human-actionable output. Each primitive is either a Graph
- * factory or a Node factory, built on top of core + extra primitives.
- *
- * @module
- */
-
-import {
-	batch,
-	COMPLETE,
-	DATA,
-	ERROR,
-	type Message,
-	type Node,
-	type NodeOptions,
-	node,
-} from "@graphrefly/pure-ts/core";
-
-import { merge } from "@graphrefly/pure-ts/extra";
-import { Graph, type GraphOptions } from "@graphrefly/pure-ts/graph";
-
-// ---------------------------------------------------------------------------
-// Shared helpers (same pattern as orchestration.ts)
-// ---------------------------------------------------------------------------
-
-export type { StepRef } from "../orchestration/pipeline-graph.js";
-
-import { keepalive } from "@graphrefly/pure-ts/extra";
-import { domainMeta } from "../../base/meta/domain-meta.js";
-import { tryIncrementBounded } from "../../base/mutation/index.js";
-import type { StepRef } from "../orchestration/pipeline-graph.js";
-
-function baseMeta(kind: string, meta?: Record<string, unknown>): Record<string, unknown> {
-	return domainMeta("reduction", kind, meta);
-}
-
-// stratify moved to `src/extra/stratify.ts` (protocol-level primitive).
-
-// ---------------------------------------------------------------------------
-// funnel
-// ---------------------------------------------------------------------------
-
-/** A named stage for {@link funnel}. */
-export type FunnelStage = {
-	/** Stage name (mounted as subgraph). */
-	name: string;
-	/** Builder: receives a sub-graph, should add an `"input"` and `"output"` node. */
-	build: (sub: Graph) => void;
-};
-
-/** Options for {@link funnel}. */
-export type FunnelOptions = GraphOptions & {
-	meta?: Record<string, unknown>;
-};
-
-/**
- * Multi-source merge with sequential reduction stages.
- *
- * Sources are merged into a single stream. Each stage is a named subgraph
- * (mounted via `graph.mount()`). Stages connect linearly:
- * `merged → stage[0].input → stage[0].output → stage[1].input → ...`
- *
- * @param name - Graph name.
- * @param sources - Input nodes to merge.
- * @param stages - Sequential reduction stages.
- * @param opts - Optional graph/meta options.
- * @returns Graph with `"merged"` and mounted stage subgraphs.
- *
- * @category patterns
- */
-export function funnel<T>(
-	name: string,
-	sources: ReadonlyArray<Node<T>>,
-	stages: ReadonlyArray<FunnelStage>,
-	opts?: FunnelOptions,
-): Graph {
-	if (sources.length === 0) throw new RangeError("funnel requires at least one source");
-	if (stages.length === 0) throw new RangeError("funnel requires at least one stage");
-
-	const g = new Graph(name, opts);
-
-	// Merge all sources
-	const merged = sources.length === 1 ? sources[0] : merge(...(sources as unknown as Node<T>[]));
-	g.add(merged as Node<unknown>, { name: "merged" });
-
-	// Build and mount each stage linearly.
-	// Stage inputs are standalone state nodes, so we bridge via subscribe
-	// (connect() requires constructor deps). Bridge effects forward DATA
-	// from the previous output to the next stage's input.
-	let prevOutputPath = "merged";
-	for (let i = 0; i < stages.length; i++) {
-		const stage = stages[i];
-		const sub = new Graph(stage.name);
-		stage.build(sub);
-
-		// Validate that the stage has input and output nodes
-		try {
-			sub.resolve("input");
-		} catch {
-			throw new Error(`funnel stage "${stage.name}" must define an "input" node`);
-		}
-		try {
-			sub.resolve("output");
-		} catch {
-			throw new Error(`funnel stage "${stage.name}" must define an "output" node`);
-		}
-
-		g.mount(stage.name, sub);
-
-		// Bridge replacement: effect that forwards DATA from previous output
-		// to the next stage's input. TEARDOWN excluded because stage lifecycle
-		// is managed by the parent graph. Shows up in describe().
-		const prevNode = g.resolve(prevOutputPath);
-		const stageInputPath = `${stage.name}::input`;
-		const stageInput = g.resolve(stageInputPath);
-		const bridgeName = `__bridge_${prevOutputPath}→${stage.name}_input`;
-		const br = node(
-			[prevNode],
-			(batchData, _actions, ctx) => {
-				const data = batchData.map((batch, i) =>
-					batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-				);
-				stageInput.emit(data[0]);
-				return undefined;
-			},
-			{ describeKind: "effect", name: bridgeName },
-		);
-		g.add(br as Node<unknown>, { name: bridgeName });
-		g.addDisposer(keepalive(br));
-
-		prevOutputPath = `${stage.name}::output`;
-	}
-
-	return g;
-}
-
-// ---------------------------------------------------------------------------
-// feedback
-// ---------------------------------------------------------------------------
-
-/** Options for {@link feedback}. */
-export type FeedbackOptions = {
-	/** Maximum feedback iterations before stopping (default: 10). */
-	maxIterations?: number;
-	/** Optional budget gate node path for cost-bounded iteration. */
-	budgetNode?: StepRef;
-	meta?: Record<string, unknown>;
-};
-
-/**
- * Introduce a bounded reactive cycle into an existing graph.
- *
- * When `condition` emits a non-null DATA value, the feedback effect routes it
- * back to the `reentry` state node — creating a cycle. Bounded by
- * `maxIterations` (default 10). The counter node (`__feedback_<condition>`)
- * is the source of truth — reset it to 0 to allow more iterations.
- *
- * To remove the feedback cycle, call `graph.remove("__feedback_<condition>")`.
- *
- * @param graph - Existing graph to augment with a feedback cycle.
- * @param condition - Path to a node whose DATA triggers feedback.
- * @param reentry - Path to a state node that receives the feedback value.
- * @param opts - Iteration bounds and metadata.
- * @returns The same graph (mutated with feedback nodes added).
- *
- * @category patterns
- */
-export function feedback(
-	graph: Graph,
-	condition: string,
-	reentry: string,
-	opts?: FeedbackOptions,
-): Graph {
-	const maxIter = opts?.maxIterations ?? 10;
-
-	// Internal counter node — source of truth for iteration bound.
-	// Reset to 0 to allow more iterations.
-	const counterName = `__feedback_${condition}`;
-	const counter = node<number>([], {
-		...{
-			meta: baseMeta("feedback_counter", {
-				maxIterations: maxIter,
-				feedbackFrom: condition,
-				feedbackTo: reentry,
-			}),
-		},
-		initial: 0,
-	});
-	graph.add(counter as Node<unknown>, { name: counterName });
-
-	// Resolve the condition and reentry nodes
-	const condNode = graph.resolve(condition);
-	const reentryNode = graph.resolve(reentry);
-
-	// Graph-visible feedback effect: intercepts condition DATA, routes back to
-	// reentry with iteration counting. Registered in the graph so it shows up
-	// in describe() and cleans up on graph.destroy().
-	// Feedback effect: subscribe to condition node for per-message interception
-	// (onMessage removed in v5 — use producer+subscribe instead)
-	const feedbackEffectName = `__feedback_effect_${condition}`;
-	const feedbackEffect = node(
-		[],
-		(_data, _feedbackActions) => {
-			const unsub = condNode.subscribe((msgs) => {
-				for (const msg of msgs) {
-					const t = msg[0];
-					if (t === DATA) {
-						const condValue = msg[1];
-						if (condValue == null) return;
-						batch(() => {
-							if (tryIncrementBounded(counter, maxIter)) {
-								reentryNode.emit(condValue);
-							}
-						});
-					} else if (t === COMPLETE || t === ERROR) {
-						const terminal: Message = t === ERROR && msg.length > 1 ? [ERROR, msg[1]] : [t];
-						counter.down([terminal]);
-					}
-				}
-			});
-			return { onDeactivation: () => unsub() };
-		},
-		{
-			name: feedbackEffectName,
-			describeKind: "effect",
-			meta: {
-				...baseMeta("feedback_effect", {
-					feedbackFrom: condition,
-					feedbackTo: reentry,
-				}),
-				_internal: true,
-			},
-		},
-	);
-	graph.add(feedbackEffect as Node<unknown>, { name: feedbackEffectName });
-	graph.addDisposer(keepalive(feedbackEffect));
-
-	return graph;
-}
-
-// `budgetGate` was promoted to `extra/resilience/budget-gate.ts` per Tier 2.2.
-// Import from `@graphrefly/graphrefly/extra` (or `../../extra/resilience/budget-gate.js`
-// internally) instead. See the resilience family for sibling primitives:
-// `retry`, `circuitBreaker`, `rateLimiter`, `tokenBucket`, `fallback`, `withStatus`.
-
-// ---------------------------------------------------------------------------
-// scorer
-// ---------------------------------------------------------------------------
-
-/** A scored item with full breakdown. */
-export type ScoredItem<T = unknown> = {
-	/** Original value. */
-	value: T;
-	/** Final weighted score. */
-	score: number;
-	/** Per-signal breakdown: signal index → weighted contribution. */
-	breakdown: number[];
-};
-
-/** Options for {@link scorer}. */
-export type ScorerOptions = Omit<NodeOptions<unknown>, "describeKind" | "name" | "meta"> & {
-	meta?: Record<string, unknown>;
-	/** Custom scoring function per signal. Default: identity (signal value IS the score). */
-	scoreFns?: ReadonlyArray<(value: unknown) => number>;
-};
-
-/**
- * Reactive multi-signal scoring with live weights.
- *
- * Each source emits items to score. Weights are reactive state nodes that
- * LLM or human can adjust live. Output is sorted scored items with full
- * breakdown.
- *
- * @param sources - Signal nodes (each emits a numeric score dimension).
- * @param weights - Reactive weight nodes (one per source).
- * @param opts - Optional node/meta options.
- * @returns Node emitting scored output.
- *
- * @category patterns
- */
-export function scorer(
-	sources: ReadonlyArray<Node<number>>,
-	weights: ReadonlyArray<Node<number>>,
-	opts?: ScorerOptions,
-): Node<ScoredItem<number[]>> {
-	if (sources.length === 0) throw new RangeError("scorer requires at least one source");
-	if (sources.length !== weights.length) {
-		throw new RangeError("scorer requires the same number of sources and weights");
-	}
-
-	const allDeps = [...(sources as unknown as Node[]), ...(weights as unknown as Node[])];
-	const n = sources.length;
-	const scoreFns = opts?.scoreFns;
-
-	return node<ScoredItem<number[]>>(
-		allDeps,
-		(batchData, actions, ctx) => {
-			const vals = batchData.map((batch, i) =>
-				batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-			);
-			const signals = vals.slice(0, n) as number[];
-			const weightValues = vals.slice(n) as number[];
-
-			const breakdown: number[] = [];
-			let totalScore = 0;
-
-			for (let i = 0; i < n; i++) {
-				const sig = signals[i] ?? 0;
-				const wt = weightValues[i] ?? 0;
-				const rawScore = scoreFns?.[i] ? scoreFns[i](sig) : sig;
-				const weighted = (rawScore as number) * wt;
-				breakdown.push(weighted);
-				totalScore += weighted;
-			}
-
-			actions.emit({
-				value: signals,
-				score: totalScore,
-				breakdown,
-			});
-		},
-		{
-			...(opts
-				? {
-						equals: opts.equals,
-						resubscribable: opts.resubscribable,
-						resetOnTeardown: opts.resetOnTeardown,
-					}
-				: {}),
-			describeKind: "derived",
-			meta: baseMeta("scorer", opts?.meta),
-		},
-	);
-}
-
-// `effectivenessTracker` was deleted per Class B audit Alt E (2026-04-30).
-// The shared substrate now lives in `extra/composition/audited-success-tracker.ts`
-// — re-exported via `@graphrefly/graphrefly/extra` for general use.
diff --git a/src/utils/resilience/adaptive-rate-limiter.ts b/src/utils/resilience/adaptive-rate-limiter.ts
deleted file mode 100644
index 7e410675..00000000
--- a/src/utils/resilience/adaptive-rate-limiter.ts
+++ /dev/null
@@ -1,437 +0,0 @@
-/**
- * Adaptive rate limiter — reactive, live-tunable, 429-aware.
- *
- * Wraps two `tokenBucket` instances (requests, tokens) with:
- *   - Reactive `rpm` / `tpm` knobs that can be re-tuned at runtime via `NodeInput<number>`.
- *   - An adaptation signal input (`Node<RateLimitSignal>`) that feeds back
- *     provider 429 / retry-after / x-ratelimit-* headers to tighten limits.
- *   - A `clampCooldownMs` TTL on signal-induced caps so a transient 429 doesn't
- *     permanently throttle — caps decay back to user-configured values after
- *     the cooldown elapses.
- *   - TPM-miss recovery: consumed RPM tokens are returned to the request
- *     bucket when the TPM admit fails, via `TokenBucket.putBack`.
- *   - Imperative `acquire()` for bridging to Promise-based call paths
- *     (used by the `withRateLimiter` adapter middleware).
- *
- * **Timer policy:** sleeps use `ResettableTimer` (documented spec §5.10
- * escape hatch in `src/extra/timer.ts`) rather than `fromTimer` to avoid
- * allocating a new Node per acquire cycle.
- *
- * Design lives in `docs/optimizations.md` § "Reactive adaptive rate limiter".
- */
-
-import { DATA, monotonicNs, type Node, node, ResettableTimer } from "@graphrefly/pure-ts/core";
-import { fromAny, type NodeInput } from "@graphrefly/pure-ts/extra";
-import { NS_PER_SEC } from "../../base/resilience/backoff.js";
-import { type TokenBucket, tokenBucket } from "./rate-limiter.js";
-
-// ---------------------------------------------------------------------------
-// Signal shape
-// ---------------------------------------------------------------------------
-
-/**
- * Rate-limit signal emitted by an adaptation source (e.g., an HTTP 429 parser).
- *
- * Any subset of fields may be present. The adaptive rate limiter uses:
- * - `retryAfterMs` — blocks acquire() for this duration.
- * - `rpmCap` / `tpmCap` — tightens effective rpm/tpm to this value (decays
- *   back to the user-configured cap after `clampCooldownMs`).
- * - `usageHint` — updates the last-known rpm/tpm usage ratio for logging.
- */
-export interface RateLimitSignal {
-	/** Throttle duration — pause acquire() for this long. */
-	retryAfterMs?: number;
-	/** Hard cap for requests-per-minute; effective rpm = min(current, rpmCap) while clamp is active. */
-	rpmCap?: number;
-	/** Hard cap for tokens-per-minute; effective tpm = min(current, tpmCap) while clamp is active. */
-	tpmCap?: number;
-	/** Observed usage-percentage hint (0..1) — for observability, not gating. */
-	usageHint?: { rpm?: number; tpm?: number };
-	/** Free-form provider-specific payload. */
-	metadata?: Record<string, unknown>;
-}
-
-// ---------------------------------------------------------------------------
-// Options
-// ---------------------------------------------------------------------------
-
-export interface AdaptiveRateLimiterOptions {
-	name?: string;
-	/** Effective requests-per-minute cap. Reactive — reads push-on-subscribe. */
-	rpm?: NodeInput<number>;
-	/** Effective tokens-per-minute cap. Reactive. */
-	tpm?: NodeInput<number>;
-	/** Source of adaptation signals (429 parser output, etc.). */
-	adaptation?: NodeInput<RateLimitSignal>;
-	/**
-	 * How long (ms) a signal-induced `rpmCap` / `tpmCap` stays in effect before
-	 * relaxing back to the user-configured value. Default 60_000 (one minute).
-	 * Set to `Infinity` to make signal caps sticky until manually cleared.
-	 * A fresh signal with the same cap resets the cooldown.
-	 */
-	clampCooldownMs?: number;
-	/** Burst capacity overshoot above the steady-state rpm/tpm. Default 1 (no burst). */
-	burstMultiplier?: number;
-}
-
-// ---------------------------------------------------------------------------
-// Bundle
-// ---------------------------------------------------------------------------
-
-export interface AdaptiveRateLimiterBundle {
-	/** Effective requests-per-minute (post-signal-clamp). Reactive. */
-	readonly effectiveRpm: Node<number>;
-	/** Effective tokens-per-minute (post-signal-clamp). Reactive. */
-	readonly effectiveTpm: Node<number>;
-	/** Last adaptation signal observed. */
-	readonly lastSignal: Node<RateLimitSignal>;
-	/** Pending `acquire()` callers waiting for capacity. */
-	readonly pending: Node<number>;
-	/** Current request-token-bucket fill (approximate). */
-	readonly rpmAvailable: Node<number>;
-	/** Current token-bucket fill (approximate). */
-	readonly tpmAvailable: Node<number>;
-	/**
-	 * Imperative bridge: wait until `requestCost` request-tokens and
-	 * `tokenCost` tokens are available, then consume them. Honors the
-	 * most recent `retryAfterMs` from adaptation signals. Rejects with
-	 * an `AbortError`-named error if `signal` aborts while waiting.
-	 * `requestCost` defaults to 1; `tokenCost` defaults to 0 (rpm-only gating).
-	 */
-	acquire(opts?: { requestCost?: number; tokenCost?: number; signal?: AbortSignal }): Promise<void>;
-	/**
-	 * Feed back observed token usage (post-call) so the TPM bucket reflects
-	 * real consumption rather than the pre-call estimate. A positive `delta`
-	 * debits additional TPM (undershot estimate); a negative `delta` credits
-	 * back overshoot (`putBack`).
-	 */
-	recordUsage(delta: number): void;
-	/** Manually feed an adaptation signal — useful for tests. */
-	recordSignal(sig: RateLimitSignal): void;
-	/** Dispose internal subscriptions and pending timers. */
-	dispose(): void;
-}
-
-// ---------------------------------------------------------------------------
-// Error construction
-// ---------------------------------------------------------------------------
-
-function makeAbortError(reason: string): Error {
-	const err = new Error(reason) as Error & { name: string };
-	err.name = "AbortError";
-	return err;
-}
-
-// ---------------------------------------------------------------------------
-// Implementation
-// ---------------------------------------------------------------------------
-
-/**
- * Create an adaptive rate limiter. Compose with any call source via
- * `await limiter.acquire({ requestCost, tokenCost, signal })`.
- */
-export function adaptiveRateLimiter(
-	opts: AdaptiveRateLimiterOptions = {},
-): AdaptiveRateLimiterBundle {
-	const burst = Math.max(1, opts.burstMultiplier ?? 1);
-	const clampCooldownMs = opts.clampCooldownMs ?? 60_000;
-
-	// Resolve reactive rpm/tpm inputs. Callers may pass `NodeInput` which
-	// could be a literal number or a Node. `fromAny` normalizes to a Node.
-	const rpmInputNode =
-		opts.rpm != null
-			? fromAny(opts.rpm as NodeInput<number>)
-			: node<number>([], { initial: Number.POSITIVE_INFINITY });
-	const tpmInputNode =
-		opts.tpm != null
-			? fromAny(opts.tpm as NodeInput<number>)
-			: node<number>([], { initial: Number.POSITIVE_INFINITY });
-
-	// Signal cap state — updated by recordSignal() / adaptation source.
-	// The decay timer relaxes the cap back to Infinity after `clampCooldownMs`.
-	const signalRpmCap = node<number>([], {
-		initial: Number.POSITIVE_INFINITY,
-		name: "adaptiveRateLimiter/signalRpmCap",
-	});
-	const signalTpmCap = node<number>([], {
-		initial: Number.POSITIVE_INFINITY,
-		name: "adaptiveRateLimiter/signalTpmCap",
-	});
-	const lastSignal = node<RateLimitSignal>([], {
-		initial: {},
-		name: "adaptiveRateLimiter/lastSignal",
-	});
-
-	// Compute effective rpm/tpm: min of user-configured cap and signal cap.
-	const effectiveRpm = node<number>(
-		[rpmInputNode, signalRpmCap],
-		(batchData, actions, ctx) => {
-			const data = batchData.map((batch, i) =>
-				batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-			);
-			actions.emit(Math.min(Number(data[0] ?? Infinity), Number(data[1] ?? Infinity)));
-		},
-		{ name: "adaptiveRateLimiter/effectiveRpm", describeKind: "derived" },
-	);
-	const effectiveTpm = node<number>(
-		[tpmInputNode, signalTpmCap],
-		(batchData, actions, ctx) => {
-			const data = batchData.map((batch, i) =>
-				batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],
-			);
-			actions.emit(Math.min(Number(data[0] ?? Infinity), Number(data[1] ?? Infinity)));
-		},
-		{ name: "adaptiveRateLimiter/effectiveTpm", describeKind: "derived" },
-	);
-
-	// Token buckets — rebuilt when effective caps change.
-	let rpmBucket: TokenBucket = makeBucket(
-		Number(rpmInputNode.cache ?? Number.POSITIVE_INFINITY),
-		burst,
-	);
-	let tpmBucket: TokenBucket = makeBucket(
-		Number(tpmInputNode.cache ?? Number.POSITIVE_INFINITY),
-		burst,
-	);
-
-	// A signal `rpmCap`/`tpmCap` of 0 means "halt admission entirely" (e.g.,
-	// some providers emit this during hard quota exhaustion). We honor it by
-	// marking the bucket as closed via a long throttle-until; the bucket itself
-	// stays at its previous capacity so decay can relax it naturally.
-	let rpmHardStop = false;
-	let tpmHardStop = false;
-
-	const unsubRpm = effectiveRpm.subscribe((msgs) => {
-		for (const msg of msgs) {
-			if (msg[0] === DATA) {
-				const v = Number(msg[1]);
-				if (Number.isFinite(v) && v > 0) {
-					rpmBucket = makeBucket(v, burst);
-					rpmHardStop = false;
-				} else if (v === Infinity) {
-					rpmBucket = makeBucket(Infinity, burst);
-					rpmHardStop = false;
-				} else if (v <= 0) {
-					// Hard stop — no admission until cap relaxes.
-					rpmHardStop = true;
-				}
-			}
-		}
-	});
-	const unsubTpm = effectiveTpm.subscribe((msgs) => {
-		for (const msg of msgs) {
-			if (msg[0] === DATA) {
-				const v = Number(msg[1]);
-				if (Number.isFinite(v) && v > 0) {
-					tpmBucket = makeBucket(v, burst);
-					tpmHardStop = false;
-				} else if (v === Infinity) {
-					tpmBucket = makeBucket(Infinity, burst);
-					tpmHardStop = false;
-				} else if (v <= 0) {
-					tpmHardStop = true;
-				}
-			}
-		}
-	});
-
-	// Throttle-until: set by retryAfterMs signals.
-	let throttleUntilNs = 0;
-
-	// Clamp-decay timers — when they fire, the signal cap is relaxed back to Infinity.
-	const rpmDecayTimer = new ResettableTimer();
-	const tpmDecayTimer = new ResettableTimer();
-
-	// Adaptation source subscription.
-	let unsubAdapt: (() => void) | undefined;
-	if (opts.adaptation != null) {
-		const adaptNode = fromAny(opts.adaptation as NodeInput<RateLimitSignal>);
-		unsubAdapt = adaptNode.subscribe((msgs) => {
-			for (const msg of msgs) {
-				if (msg[0] === DATA) applySignal(msg[1] as RateLimitSignal);
-			}
-		});
-	}
-
-	function applySignal(sig: RateLimitSignal): void {
-		lastSignal.emit(sig);
-		// Accept `rpmCap`/`tpmCap` of 0 as a valid hard-stop signal. Only
-		// reject non-finite caps (NaN/Infinity).
-		if (sig.rpmCap != null && Number.isFinite(sig.rpmCap) && sig.rpmCap >= 0) {
-			signalRpmCap.emit(sig.rpmCap);
-			// Schedule decay. Uses ResettableTimer — each new clamp resets the cooldown.
-			if (Number.isFinite(clampCooldownMs) && clampCooldownMs > 0) {
-				rpmDecayTimer.start(clampCooldownMs, () => signalRpmCap.emit(Number.POSITIVE_INFINITY));
-			}
-		}
-		if (sig.tpmCap != null && Number.isFinite(sig.tpmCap) && sig.tpmCap >= 0) {
-			signalTpmCap.emit(sig.tpmCap);
-			if (Number.isFinite(clampCooldownMs) && clampCooldownMs > 0) {
-				tpmDecayTimer.start(clampCooldownMs, () => signalTpmCap.emit(Number.POSITIVE_INFINITY));
-			}
-		}
-		if (sig.retryAfterMs != null && sig.retryAfterMs > 0) {
-			const resumeAt = monotonicNs() + sig.retryAfterMs * 1_000_000;
-			if (resumeAt > throttleUntilNs) throttleUntilNs = resumeAt;
-		}
-	}
-
-	const pending = node<number>([], { initial: 0, name: "adaptiveRateLimiter/pending" });
-	const rpmAvailableNode = node<number>([], {
-		initial: Number.POSITIVE_INFINITY,
-		name: "adaptiveRateLimiter/rpmAvailable",
-	});
-	const tpmAvailableNode = node<number>([], {
-		initial: Number.POSITIVE_INFINITY,
-		name: "adaptiveRateLimiter/tpmAvailable",
-	});
-
-	const bumpPending = (delta: number): void => {
-		pending.emit((pending.cache ?? 0) + delta);
-	};
-	const refreshAvailable = (): void => {
-		rpmAvailableNode.emit(rpmBucket.available());
-		tpmAvailableNode.emit(tpmBucket.available());
-	};
-
-	async function acquire(
-		acquireOpts: { requestCost?: number; tokenCost?: number; signal?: AbortSignal } = {},
-	): Promise<void> {
-		const requestCost = acquireOpts.requestCost ?? 1;
-		const tokenCost = acquireOpts.tokenCost ?? 0;
-		const abortSignal = acquireOpts.signal;
-
-		bumpPending(1);
-		try {
-			while (true) {
-				if (abortSignal?.aborted) throw makeAbortError("AdaptiveRateLimiter.acquire aborted");
-
-				// Honor retry-after window.
-				const now = monotonicNs();
-				if (throttleUntilNs > now) {
-					const waitMs = Math.ceil((throttleUntilNs - now) / 1_000_000);
-					await sleepReactive(waitMs, abortSignal);
-					continue;
-				}
-
-				// Hard-stop (cap=0) → wait for the decay timer to relax.
-				if ((requestCost > 0 && rpmHardStop) || (tokenCost > 0 && tpmHardStop)) {
-					await sleepReactive(250, abortSignal);
-					continue;
-				}
-
-				// Capture local refs so a concurrent rpm/tpm cap-change rebuilding
-				// the bucket doesn't send `putBack` to a different bucket than
-				// `tryConsume` debited. If the cap relaxes mid-flight, the OLD
-				// bucket gets the credit (safe — it's closed over a closure the
-				// new acquires don't see), and new acquires pick up the new
-				// bucket on their own next iteration.
-				const rpmAtAcquire = rpmBucket;
-				const tpmAtAcquire = tpmBucket;
-
-				// Try consume RPM first.
-				const gotRpm = rpmAtAcquire.tryConsume(requestCost);
-				if (!gotRpm) {
-					await sleepReactive(estimateWaitMs(rpmAtAcquire, requestCost), abortSignal);
-					continue;
-				}
-				// Then TPM — if it fails, return the RPM token (no wasted slot).
-				const gotTpm = tokenCost > 0 ? tpmAtAcquire.tryConsume(tokenCost) : true;
-				if (!gotTpm) {
-					rpmAtAcquire.putBack(requestCost);
-					await sleepReactive(estimateWaitMs(tpmAtAcquire, tokenCost), abortSignal);
-					continue;
-				}
-				refreshAvailable();
-				return;
-			}
-		} finally {
-			bumpPending(-1);
-		}
-	}
-
-	function recordUsage(delta: number): void {
-		if (delta > 0) {
-			// Undershoot: debit additional tokens. Non-blocking — if it fails, the
-			// next acquire will just wait longer.
-			tpmBucket.tryConsume(delta);
-		} else if (delta < 0) {
-			// Overshoot: credit back.
-			tpmBucket.putBack(-delta);
-		}
-		refreshAvailable();
-	}
-
-	function dispose(): void {
-		unsubRpm();
-		unsubTpm();
-		unsubAdapt?.();
-		rpmDecayTimer.cancel();
-		tpmDecayTimer.cancel();
-	}
-
-	return {
-		effectiveRpm,
-		effectiveTpm,
-		lastSignal,
-		pending,
-		rpmAvailable: rpmAvailableNode,
-		tpmAvailable: tpmAvailableNode,
-		acquire,
-		recordUsage,
-		recordSignal: applySignal,
-		dispose,
-	};
-}
-
-// ---------------------------------------------------------------------------
-// Internals
-// ---------------------------------------------------------------------------
-
-function makeBucket(perMinute: number, burst: number): TokenBucket {
-	if (!Number.isFinite(perMinute) || perMinute === Infinity) {
-		return tokenBucket(Number.MAX_SAFE_INTEGER, Number.MAX_SAFE_INTEGER);
-	}
-	const capacity = Math.max(1, perMinute * burst);
-	const refillPerSecond = perMinute / 60;
-	return tokenBucket(capacity, refillPerSecond);
-}
-
-function estimateWaitMs(bucket: TokenBucket, needed: number): number {
-	const have = bucket.available();
-	const deficit = Math.max(0, needed - have);
-	if (deficit <= 0) return 25; // retry quickly; primary path already failed so pacing is forced
-	// Heuristic: wait 100ms per missing unit, clamped.
-	return Math.min(5_000, Math.max(50, deficit * 100));
-}
-
-/**
- * Promise-based sleep using `ResettableTimer` (spec §5.10 escape hatch).
- * Cleanly removes abort listener on both the timer-fires and abort paths;
- * no leaked `AbortSignal.addEventListener` registrations.
- */
-function sleepReactive(ms: number, signal?: AbortSignal): Promise<void> {
-	if (ms <= 0) return Promise.resolve();
-	if (signal?.aborted) return Promise.reject(makeAbortError("AdaptiveRateLimiter.acquire aborted"));
-	return new Promise((resolve, reject) => {
-		const timer = new ResettableTimer();
-		let onAbort: (() => void) | undefined;
-		const cleanup = (): void => {
-			timer.cancel();
-			if (signal && onAbort) signal.removeEventListener("abort", onAbort);
-		};
-		timer.start(ms, () => {
-			cleanup();
-			resolve();
-		});
-		if (signal) {
-			onAbort = (): void => {
-				cleanup();
-				reject(makeAbortError("AdaptiveRateLimiter.acquire aborted"));
-			};
-			signal.addEventListener("abort", onAbort, { once: true });
-		}
-	});
-}
-
-export { NS_PER_SEC };
diff --git a/src/utils/resilience/breaker.ts b/src/utils/resilience/breaker.ts
deleted file mode 100644
index 7be7bad4..00000000
--- a/src/utils/resilience/breaker.ts
+++ /dev/null
@@ -1,428 +0,0 @@
-/**
- * Circuit breaker — open/half-open/closed state machine + companion bundle.
- *
- * - {@link circuitBreaker} returns a synchronous breaker handle (counters,
- *   state machine, optional reactive-options subscription).
- * - {@link withBreaker} wraps a `Node<T>` and surfaces a reactive
- *   `Node<CircuitState>` companion (`bundle.breakerState`) for telemetry.
- */
-
-import {
-	COMPLETE,
-	DATA,
-	DIRTY,
-	ERROR,
-	factoryTag,
-	monotonicNs,
-	type Node,
-	node,
-	RESOLVED,
-} from "@graphrefly/pure-ts/core";
-import {
-	clampNonNegative,
-	isNode,
-	msgVal,
-	type NodeOrValue,
-	operatorOpts,
-} from "../../base/resilience/_internal.js";
-import { type BackoffStrategy, NS_PER_SEC } from "../../base/resilience/backoff.js";
-import type { GateState } from "./gate-state.js";
-
-export type CircuitState = "closed" | "open" | "half-open";
-
-/**
- * Lifecycle-shaped state companion emitted by {@link withBreaker}
- * (DS-13.5.B, locked 2026-05-01). Pre-1.0 break vs the prior
- * `Node<CircuitState>` (string-only) shape.
- *
- * `status` extends {@link GateState} with `"half-open"`. The numeric
- * fields surface the breaker's full internal state for telemetry and
- * `describe()` traversal.
- *
- * @category extra/resilience
- */
-export interface BreakerState {
-	readonly status: GateState | "half-open";
-	readonly failureCount: number;
-	readonly openCycle: number;
-	readonly lastOpenedAtNs: number;
-	readonly halfOpenAttempts: number;
-	readonly lastCooldownNs: number;
-}
-
-/**
- * Thrown when {@link withBreaker} is configured with `onOpen: "error"` and the breaker rejects work.
- *
- * @category extra
- */
-export class CircuitOpenError extends Error {
-	override name = "CircuitOpenError";
-	constructor() {
-		super("Circuit breaker is open");
-	}
-}
-
-export interface CircuitBreakerOptions {
-	/** Number of consecutive failures before opening. Default: 5. */
-	failureThreshold?: number;
-	/** Base cooldown in nanoseconds before transitioning to half-open. Default: 30s. */
-	cooldownNs?: number;
-	/** Backoff strategy for cooldown escalation across consecutive open cycles. Overrides `cooldownNs` when provided. */
-	cooldown?: BackoffStrategy;
-	/** Max trial requests allowed in half-open state. Default: 1. */
-	halfOpenMax?: number;
-	/**
-	 * Clock function returning **nanoseconds** with `monotonicNs()` semantics
-	 * (monotonically non-decreasing; suitable for elapsed-time arithmetic — never
-	 * use `Date.now()` because wall-clock skew can flip elapsed math negative).
-	 * Default: `monotonicNs` from `core/clock`. Override for deterministic tests.
-	 */
-	now?: () => number;
-}
-
-export interface CircuitBreaker {
-	/** Whether a request should be allowed through. Triggers open→half-open transition when cooldown expires. */
-	canExecute(): boolean;
-	/** Record a successful execution. Resets to closed. */
-	recordSuccess(): void;
-	/** Record a failed execution. May transition to open. */
-	recordFailure(error?: unknown): void;
-	/**
-	 * Current circuit state (read-only, does not trigger transitions).
-	 *
-	 * **Telemetry:** wrap with {@link withBreaker} to surface this as a reactive
-	 * `Node<CircuitState>` companion (`bundle.breakerState`) — every state
-	 * transition (`closed`/`open`/`half-open`) emits to subscribers.
-	 */
-	readonly state: CircuitState;
-	/** Number of consecutive failures in the current closed period. */
-	readonly failureCount: number;
-	/** Manually reset to closed state, clearing all counters. */
-	reset(): void;
-	/**
-	 * Release the reactive-options subscription (Tier 6.5 3.2.4, 2026-04-29).
-	 * No-op when constructed with static options. Call when retiring a
-	 * breaker whose options came from a `Node<CircuitBreakerOptions>` to
-	 * avoid leaking the option-Node subscription.
-	 */
-	dispose(): void;
-}
-
-/**
- * Factory for a synchronous circuit breaker with `closed`, `open`, and `half-open` states.
- *
- * Supports escalating cooldown via an optional {@link BackoffStrategy} — each consecutive
- * open→half-open→open cycle increments the backoff attempt.
- *
- * @param options - Threshold, cooldown, half-open limit, and optional clock
- *   override; OR a `Node<CircuitBreakerOptions>` carrying the same shape
- *   reactively (Tier 6.5 3.2.4).
- * @returns {@link CircuitBreaker} instance.
- *
- * @remarks
- * **Timing:** Uses `monotonicNs()` by default (nanoseconds). Override `now` for tests.
- *
- * **Reactive options (locked semantics, Tier 6.5 3.2.4, 2026-04-29).**
- * When `options` is a `Node<CircuitBreakerOptions>`, the breaker
- * subscribes at construction and re-reads `failureThreshold` /
- * `cooldownNs` / `cooldown` / `halfOpenMax` / `now` on each DATA. **An
- * option swap RESETS the breaker to `"closed"`** with all counters
- * cleared — operators tuning a runaway breaker get a clean baseline.
- * If retaining failure history across re-tunings matters, derive a new
- * breaker per-tuning instead. Call `breaker.dispose()` when retiring to
- * release the option-Node subscription.
- *
- * @example
- * ```ts
- * import { circuitBreaker, exponential, NS_PER_SEC } from "@graphrefly/graphrefly";
- *
- * const b = circuitBreaker({
- *   failureThreshold: 3,
- *   cooldown: exponential({ baseNs: 1 * NS_PER_SEC }),
- * });
- * ```
- *
- * @category extra
- */
-export function circuitBreaker(options?: NodeOrValue<CircuitBreakerOptions>): CircuitBreaker {
-	let threshold = 5;
-	let baseCooldownNs = 30 * NS_PER_SEC;
-	let cooldownStrategy: BackoffStrategy | null = null;
-	let halfOpenMax = 1;
-	let now: () => number = monotonicNs;
-
-	function applyOptions(o: CircuitBreakerOptions | undefined): void {
-		threshold = Math.max(1, o?.failureThreshold ?? 5);
-		baseCooldownNs = clampNonNegative(o?.cooldownNs ?? 30 * NS_PER_SEC);
-		cooldownStrategy = o?.cooldown ?? null;
-		halfOpenMax = Math.max(1, o?.halfOpenMax ?? 1);
-		now = o?.now ?? monotonicNs;
-	}
-
-	let _state: CircuitState = "closed";
-	let _failureCount = 0;
-	let _openCycle = 0;
-	let _lastOpenedAt = 0;
-	let _lastCooldownNs = baseCooldownNs;
-	let _halfOpenAttempts = 0;
-
-	// DS-13.5.B (locked 2026-05-01): reactive option swaps preserve
-	// internal state — no reset across rebind. `now` is mode-locked at
-	// construction (clock override is structural); a mid-flight `now`
-	// change is logged and skipped (the prior `now` is preserved).
-	// Empty `{}` emits are no-ops.
-	//
-	// QA A2 (2026-05-03): bad-`now` mid-flight does NOT throw — sync
-	// throw inside a subscribe callback corrupts host scheduler state
-	// (mirrors timeout's `actions.down([[ERROR]])` rationale; sink-side
-	// throws break the wave's dispatch contract).
-	//
-	// QA A8 (2026-05-03): the push-on-subscribe re-delivery of the
-	// cached opts fires the subscribe callback once at attach time with
-	// the same value used for the eager `applyOptions(initialOpts)`
-	// call above. Skip the first cached emit so opts are not re-applied
-	// twice on construction.
-	let initialOpts: CircuitBreakerOptions | undefined;
-	let optsUnsub: (() => void) | undefined;
-	if (isNode(options)) {
-		const optsNode = options as Node<CircuitBreakerOptions>;
-		initialOpts = optsNode.cache as CircuitBreakerOptions | undefined;
-		applyOptions(initialOpts);
-		const lockedNow = initialOpts?.now;
-		const hadInitialCache = initialOpts !== undefined;
-		let firstEmit = hadInitialCache;
-		optsUnsub = optsNode.subscribe((msgs) => {
-			for (const m of msgs) {
-				if (m[0] !== DATA) continue;
-				if (firstEmit) {
-					firstEmit = false;
-					continue; // QA A8: skip push-on-subscribe replay of cached opts
-				}
-				const next = m[1] as CircuitBreakerOptions | undefined;
-				if (next == null || typeof next !== "object") continue;
-				if (Object.keys(next).length === 0) continue; // empty {} no-op
-				if ("now" in next && next.now !== lockedNow) {
-					// QA A2: log + skip; do NOT throw inside a subscribe
-					// callback — host scheduler corruption hazard.
-					console.error(
-						"circuitBreaker: ignoring mid-flight `now` change — clock override is mode-locked at construction. Prior `now` preserved.",
-					);
-					continue;
-				}
-				// State-preserving merge: only re-apply the axes that
-				// changed; preserve `_state`, `_failureCount`, etc.
-				const merged: CircuitBreakerOptions = {
-					...(initialOpts ?? {}),
-					...next,
-					...(lockedNow !== undefined ? { now: lockedNow } : {}),
-				};
-				applyOptions(merged);
-				initialOpts = merged;
-			}
-		});
-	} else {
-		applyOptions(options as CircuitBreakerOptions | undefined);
-	}
-	_lastCooldownNs = baseCooldownNs;
-
-	function getCooldownNs(): number {
-		if (!cooldownStrategy) return baseCooldownNs;
-		const delayNs = cooldownStrategy(_openCycle);
-		return delayNs !== null ? delayNs : baseCooldownNs;
-	}
-
-	function transitionToOpen(): void {
-		_state = "open";
-		_lastCooldownNs = getCooldownNs();
-		_lastOpenedAt = now();
-		_halfOpenAttempts = 0;
-	}
-
-	const breaker: CircuitBreaker = {
-		canExecute(): boolean {
-			if (_state === "closed") return true;
-
-			if (_state === "open") {
-				const elapsed = now() - _lastOpenedAt;
-				if (elapsed >= _lastCooldownNs) {
-					_state = "half-open";
-					_halfOpenAttempts = 1;
-					return true;
-				}
-				return false;
-			}
-
-			if (_halfOpenAttempts < halfOpenMax) {
-				_halfOpenAttempts++;
-				return true;
-			}
-			return false;
-		},
-
-		recordSuccess(): void {
-			if (_state === "half-open") {
-				_state = "closed";
-				_failureCount = 0;
-				_openCycle = 0;
-			} else if (_state === "closed") {
-				_failureCount = 0;
-			}
-		},
-
-		recordFailure(_error?: unknown): void {
-			if (_state === "half-open") {
-				_openCycle++;
-				transitionToOpen();
-				return;
-			}
-
-			if (_state === "closed") {
-				_failureCount++;
-				if (_failureCount >= threshold) {
-					transitionToOpen();
-				}
-			}
-		},
-
-		get state(): CircuitState {
-			return _state;
-		},
-
-		get failureCount(): number {
-			return _failureCount;
-		},
-
-		reset(): void {
-			_state = "closed";
-			_failureCount = 0;
-			_openCycle = 0;
-			_halfOpenAttempts = 0;
-		},
-
-		dispose(): void {
-			optsUnsub?.();
-		},
-
-		// Internal accessors used by withBreaker for the BreakerState
-		// companion (DS-13.5.B). Not part of the public CircuitBreaker
-		// interface but exposed for the bundle wiring.
-	};
-	(breaker as unknown as { _stateSnapshot: () => BreakerState })._stateSnapshot = () => ({
-		status: _state,
-		failureCount: _failureCount,
-		openCycle: _openCycle,
-		lastOpenedAtNs: _lastOpenedAt,
-		halfOpenAttempts: _halfOpenAttempts,
-		lastCooldownNs: _lastCooldownNs,
-	});
-
-	return breaker;
-}
-
-export type WithBreakerBundle<T> = {
-	node: Node<T>;
-	breakerState: Node<BreakerState>;
-};
-
-/**
- * Returns a unary wrapper that gates upstream `DATA` through a {@link CircuitBreaker}.
- *
- * @param breaker - Shared breaker instance (typically one per resource).
- * @param options - `onOpen: "skip"` emits `RESOLVED` when open; `"error"` emits {@link CircuitOpenError}.
- * @returns Function mapping `Node<T>` to `{ node, breakerState }` companion nodes.
- *
- * @remarks
- * **Success path:** `COMPLETE` calls {@link CircuitBreaker.recordSuccess}. **Failure path:** upstream `ERROR` calls {@link CircuitBreaker.recordFailure} and is forwarded.
- *
- * **State telemetry:** `breakerState: Node<CircuitState>` is a reactive companion that mirrors `breaker.state` — every transition (`closed`/`open`/`half-open`) emits a `DATA`. Also accessible via `node.meta.breakerState` for `describe()` traversal.
- *
- * @example
- * ```ts
- * import { state, withBreaker, circuitBreaker } from "@graphrefly/graphrefly";
- *
- * const b = circuitBreaker({ failureThreshold: 2 });
- * const s = state(1);
- * const { node, breakerState } = withBreaker(b)(s);
- * ```
- *
- * @category extra
- */
-export function withBreaker<T>(
-	breaker: CircuitBreaker,
-	options?: { onOpen?: "skip" | "error"; meta?: Record<string, unknown> },
-): (source: Node<T>) => WithBreakerBundle<T> {
-	const onOpen = options?.onOpen ?? "skip";
-	const callerMeta = options?.meta;
-
-	return (source: Node<T>): WithBreakerBundle<T> => {
-		const snapshot = (breaker as unknown as { _stateSnapshot?: () => BreakerState })._stateSnapshot;
-		const initialSnapshot: BreakerState = snapshot
-			? snapshot()
-			: {
-					status: breaker.state,
-					failureCount: breaker.failureCount,
-					openCycle: 0,
-					lastOpenedAtNs: 0,
-					halfOpenAttempts: 0,
-					lastCooldownNs: 0,
-				};
-		const wrapped = node<T>(
-			[],
-			(_deps, a) => {
-				function syncState(): void {
-					const s = snapshot
-						? snapshot()
-						: {
-								status: breaker.state,
-								failureCount: breaker.failureCount,
-								openCycle: 0,
-								lastOpenedAtNs: 0,
-								halfOpenAttempts: 0,
-								lastCooldownNs: 0,
-							};
-					wrapped.meta.breakerState.down([[DIRTY], [DATA, s]]);
-				}
-
-				const unsub = source.subscribe((msgs) => {
-					for (const m of msgs) {
-						const t = m[0];
-						if (t === DIRTY) a.down([[DIRTY]]);
-						else if (t === DATA) {
-							if (breaker.canExecute()) {
-								syncState();
-								a.emit(m[1] as T);
-							} else {
-								syncState();
-								if (onOpen === "error") a.down([[ERROR, new CircuitOpenError()]]);
-								else a.down([[RESOLVED]]);
-							}
-						} else if (t === RESOLVED) a.down([[RESOLVED]]);
-						else if (t === COMPLETE) {
-							breaker.recordSuccess();
-							syncState();
-							a.down([[COMPLETE]]);
-						} else if (t === ERROR) {
-							breaker.recordFailure(msgVal(m));
-							syncState();
-							a.down([m]);
-						} else a.down([m]);
-					}
-				});
-				syncState();
-				return { onDeactivation: unsub };
-			},
-			{
-				...operatorOpts(),
-				meta: {
-					...(callerMeta ?? {}),
-					breakerState: initialSnapshot,
-					...factoryTag("withBreaker", { onOpen }),
-				},
-				completeWhenDepsComplete: false,
-				initial: source.cache,
-			},
-		);
-
-		return { node: wrapped, breakerState: wrapped.meta.breakerState as Node<BreakerState> };
-	};
-}
diff --git a/src/utils/resilience/budget-gate.ts b/src/utils/resilience/budget-gate.ts
deleted file mode 100644
index 8382aabf..00000000
--- a/src/utils/resilience/budget-gate.ts
+++ /dev/null
@@ -1,495 +0,0 @@
-/**
- * `budgetGate` — numeric-constraint flow gate (Tier 2.2 promotion from
- * `patterns/reduction/`).
- *
- * Lives alongside the other `extra/resilience/` flow controls (`retry`,
- * `circuitBreaker`, `rateLimiter`, `tokenBucket`, `fallback`, `withStatus`).
- *
- * @module
- */
-
-import type { NodeActions } from "@graphrefly/pure-ts/core";
-import {
-	COMPLETE,
-	DATA,
-	DIRTY,
-	ERROR,
-	type Message,
-	type Node,
-	type NodeOptions,
-	node,
-	PAUSE,
-	RESOLVED,
-	RESUME,
-} from "@graphrefly/pure-ts/core";
-import { domainMeta } from "../../base/meta/domain-meta.js";
-import type { GateState } from "./gate-state.js";
-
-/** A reactive constraint for {@link budgetGate}. */
-export type BudgetConstraint<T = unknown> = {
-	/** Constraint node whose value is checked. */
-	node: Node<T>;
-	/** Returns `true` when the constraint is satisfied (budget available). */
-	check: (value: T) => boolean;
-	/**
-	 * Optional human-readable name for `BudgetGateState.constraintsSnapshot`.
-	 * Defaults to the constraint Node's `.name` (or `""` when unset).
-	 */
-	name?: string;
-};
-
-/** Options for {@link budgetGate}. */
-export type BudgetGateOptions = Omit<NodeOptions<unknown>, "describeKind" | "name" | "meta"> & {
-	meta?: Record<string, unknown>;
-};
-
-/**
- * Per-constraint snapshot inside {@link BudgetGateState}. The `value` field is
- * typed as `unknown` because constraint values are generic — most callers
- * carry numeric budgets but the gate doesn't enforce that. Cast at the
- * subscriber site if you need a narrower type.
- *
- * @category extra/resilience
- */
-export interface BudgetConstraintSnapshot {
-	readonly name: string;
-	readonly satisfied: boolean;
-	readonly value: unknown;
-}
-
-/**
- * Lifecycle-shaped state companion emitted by {@link budgetGate} (DS-13.5.B,
- * locked 2026-05-01). `status` is `"open"` when every constraint's `check`
- * returns true; `"closed"` otherwise. The `constraintsSnapshot` array
- * preserves constraint ordering and reflects the most recent values seen
- * via per-constraint reactive updates.
- *
- * @category extra/resilience
- */
-export interface BudgetGateState {
-	readonly status: GateState;
-	readonly constraintsSnapshot: ReadonlyArray<BudgetConstraintSnapshot>;
-}
-
-/**
- * Bundle returned by {@link budgetGate}: the gated output node and its
- * gate-state companion. Pre-1.0 break vs. the prior `Node<T>` return —
- * unwrap via `.node` for downstream wiring.
- *
- * @category extra/resilience
- */
-export interface BudgetGateBundle<T> {
-	node: Node<T>;
-	budgetGateState: Node<BudgetGateState>;
-}
-
-/**
- * Unbounded head-index queue with O(1) `push` and O(1) `shift`.
- *
- * Distinct from {@link RingBuffer} (drop-oldest, fixed capacity) because
- * `budgetGate` MUST NOT silently drop buffered DATA when the gate is closed —
- * upstream is asked to PAUSE and the buffered items are guaranteed to flush
- * once the constraint relaxes (or on terminal force-flush). A drop-oldest
- * eviction would break that contract by losing items between PAUSE and
- * RESUME.
- *
- * Storage grows on demand and is compacted opportunistically: once the head
- * pointer crosses the midpoint of the underlying array, we slice the consumed
- * prefix away. Memory bound is **worst-case ~3× live size** (DF3, 2026-04-29
- * doc tighten — a queue that grows to N, drains to 0.6N, then re-pushes 0.4N
- * retains ~3× live size between compactions). Amortized footprint trends
- * lower under steady-state usage. Trade-off: keeps `push` and `shift` O(1) —
- * replacing the prior `buffer.slice(1)` per drain which was O(N²) over a
- * long-lived bucket (Tier 3.3.1 fix).
- */
-class HeadIndexQueue<T> {
-	private buf: T[] = [];
-	private head = 0;
-
-	get size(): number {
-		return this.buf.length - this.head;
-	}
-
-	push(item: T): void {
-		this.buf.push(item);
-	}
-
-	/** O(1) — removes and returns the oldest item, or `undefined` when empty. */
-	shift(): T | undefined {
-		if (this.head >= this.buf.length) return undefined;
-		const item = this.buf[this.head]!;
-		// Release the slot for GC. Cheaper than splice; cost folded into the
-		// periodic compaction below.
-		(this.buf as Array<T | undefined>)[this.head] = undefined;
-		this.head++;
-		// Compact when more than half the array is consumed prefix.
-		if (this.head > 32 && this.head * 2 > this.buf.length) {
-			this.buf = this.buf.slice(this.head);
-			this.head = 0;
-		}
-		return item;
-	}
-
-	clear(): void {
-		this.buf = [];
-		this.head = 0;
-	}
-}
-
-/**
- * Pass-through that respects reactive constraint nodes.
- *
- * DATA flows through when all constraints are satisfied. When any constraint
- * is exceeded, `PAUSE` is sent upstream and DATA is buffered in a FIFO queue.
- * When constraints relax, the queue drains in arrival order and `RESUME` is
- * sent upstream.
- *
- * ## Invariants (do not refactor without preserving)
- *
- * 1. **Terminal force-flush.** On `COMPLETE` / `ERROR` arriving from `source`,
- *    every buffered item is emitted downstream BEFORE the terminal message is
- *    forwarded. The constraint is intentionally bypassed for the flush — once
- *    upstream is done, the caller must see the buffered work, not lose it.
- *    See COMPOSITION-GUIDE §19 (terminal-emission operators).
- *
- * 2. **PAUSE-release ordering.** When a constraint flips from saturated →
- *    released, the queue drains in FIFO order downstream BEFORE `RESUME` is
- *    sent upstream. Reversing the order (RESUME-then-drain) would let new
- *    upstream DATA interleave with the queue tail, breaking arrival-order
- *    delivery. See COMPOSITION-GUIDE §9, §9a (diamond + batch coalescing).
- *
- * 3. **Deferred RESOLVED.** A `RESOLVED` from `source` while the queue is
- *    non-empty is held until the queue drains, then forwarded — so downstream
- *    sees `[buffered DATA…, RESOLVED]` in causal order rather than
- *    `[RESOLVED, buffered DATA…]`.
- *
- *    **Stall risk (qa D4):** if the constraint never relaxes AND no terminal
- *    arrives from `source`, the deferred RESOLVED is held forever. Downstream
- *    consumers that depend on `RESOLVED` for an `awaitSettled`-style
- *    coordination wait stall in this case. PAUSE is sent upstream so source
- *    backpressure stops further DATA, but the gate itself has no escape
- *    hatch — by design (the producer-pattern is fire-and-forget; recovery
- *    happens at the compositor level via timeout, retry, or cancellation).
- *
- * 4. **Constraint DIRTY suppression.** Constraint-node DIRTY does NOT
- *    propagate downstream — only `source`-DIRTY does. The gate's downstream
- *    semantics track `source`'s wave, not constraint waves.
- *
- * 5. **Lazy PAUSE (qa D3).** PAUSE is sent upstream ONLY when a `source` DATA
- *    arrives that fails the constraint check (the first blocked item). A
- *    constraint flipping closed BEFORE any source DATA arrives does NOT emit
- *    a preemptive PAUSE — upstream may push DATA freely until the first
- *    item is buffered. This matches the producer-pattern lazy-activation
- *    philosophy (don't impose backpressure for hypothetical future blocks).
- *    For eager-PAUSE semantics, wrap the gate in a compositor that watches
- *    constraints + source independently.
- *
- * ## Queue
- *
- * The internal buffer is an unbounded {@link HeadIndexQueue} (O(1) push,
- * O(1) shift, opportunistic compaction). It does NOT use {@link RingBuffer}
- * because RingBuffer's drop-oldest eviction would silently lose buffered
- * items between PAUSE and RESUME. Backpressure (PAUSE) is the upstream
- * contract for bounding the queue, not capacity-driven eviction here.
- *
- * ## Producer-pattern: source edge is invisible to `describe()`
- *
- * `budgetGate` is constructed via `node([], fn)` and subscribes to `source`
- * and the constraint nodes manually inside its activation fn. Because no
- * dep is declared at construction, **`describe()` shows no edge from
- * `source` (or any constraint) into the returned node** — the gate looks
- * like a standalone leaf source. This is intentional (see COMPOSITION-GUIDE
- * §24 "Edges are derived, not declared"): if you want the constraint /
- * source dependency to appear in describe output, surface it at the
- * compositor level (e.g. annotate via `meta.ai.upstream`, or wrap the gate
- * in a parent factory that exposes the deps as constructor args).
- *
- * ## Reference equality + Tier 6.5 3.2.5 locked semantics
- *
- * **Constraint VALUES are reactive.** Each `BudgetConstraint.node` is
- * subscribed at activation; per-value changes flip the gate (re-evaluate
- * in the same wave) and trigger PAUSE/RESUME upstream. Per the locked
- * semantic rule for the reactive-options-widening batch (Tier 6.5 3.2.5,
- * 2026-04-29): "constraints array re-evaluated immediately against
- * current source; adding/removing constraints triggers gate
- * re-evaluation in the same wave" — the per-value half is shipped via
- * the existing constraint-Node subscription model.
- *
- * **The constraints ARRAY shape is static.** The factory captures the
- * `constraints` array reference and each `check` function at
- * construction; it does NOT diff subsequent arrays. To add or remove
- * constraints reactively, build the swap at the compositor level (a
- * `switchMap` rebuild over a constraint-shape Node), or construct a new
- * gate. Dynamic constraint-array reactivity is intentionally deferred —
- * the subscription churn (resub on every constraint add/remove) and
- * `latestValues` shape mutation overshoot the budget-gate's
- * fire-and-forget ergonomics.
- *
- * @param source - Input node.
- * @param constraints - Reactive constraint checks. MUST be non-empty.
- * @param opts - Optional node options.
- * @returns Gated node.
- *
- * @throws {RangeError} when `constraints.length === 0`. The gate has no
- *   meaningful identity without at least one check — degenerate to plain
- *   pass-through (e.g. via `derived([source], ([v]) => v)`) instead.
- *
- * @category resilience
- */
-export function budgetGate<T>(
-	source: Node<T>,
-	constraints: ReadonlyArray<BudgetConstraint>,
-	opts?: BudgetGateOptions,
-): BudgetGateBundle<T> {
-	if (constraints.length === 0) throw new RangeError("budgetGate requires at least one constraint");
-
-	const constraintNodes = constraints.map((c) => c.node);
-	const allDeps = [source as Node, ...constraintNodes] as Node[];
-
-	const buffer = new HeadIndexQueue<T>();
-	let paused = false;
-	let pendingResolved = false;
-	const lockId = Symbol("budget-gate");
-
-	// Latest DATA from each constraint. Seeded at **activation time** (inside the
-	// producer fn below) — a wiring-time boundary read, not a reactive-callback
-	// read — so concurrent constraint updates between factory-time and
-	// activation-time are reflected before `checkBudget()` first runs. The
-	// subscribe handler updates this array on each constraint DATA message, so
-	// `checkBudget` never reads `.cache` from inside a reactive callback.
-	const latestValues: unknown[] = new Array(constraints.length);
-
-	function checkBudget(): boolean {
-		return constraints.every((c, i) => c.check(latestValues[i]));
-	}
-
-	// DS-13.5.B (locked 2026-05-01): lifecycle-shaped state companion.
-	// Initialized with `status: "closed"` until activation seeds the values
-	// and the first `checkBudget()` runs.
-	//
-	// QA A3 (2026-05-03): equality uses structural compare on
-	// `(status, name, satisfied, value)` tuples via `Object.is` per
-	// `value` — NOT `JSON.stringify`. Caller-supplied constraint values
-	// (`unknown`) can be circular, BigInt, or otherwise non-serializable;
-	// `JSON.stringify` would throw and corrupt the wave dispatch.
-	function budgetGateStateEqual(a: BudgetGateState, b: BudgetGateState): boolean {
-		if (a === b) return true;
-		if (a.status !== b.status) return false;
-		const sa = a.constraintsSnapshot;
-		const sb = b.constraintsSnapshot;
-		if (sa.length !== sb.length) return false;
-		for (let i = 0; i < sa.length; i++) {
-			const ai = sa[i];
-			const bi = sb[i];
-			if (ai === undefined || bi === undefined) return false;
-			if (ai.name !== bi.name) return false;
-			if (ai.satisfied !== bi.satisfied) return false;
-			if (!Object.is(ai.value, bi.value)) return false;
-		}
-		return true;
-	}
-
-	const budgetGateState = node<BudgetGateState>([], {
-		name: "budgetGateState",
-		describeKind: "state",
-		initial: {
-			status: "closed",
-			constraintsSnapshot: constraints.map((c) => ({
-				name: c.name ?? c.node.name ?? "",
-				satisfied: false,
-				value: undefined,
-			})),
-		},
-		equals: budgetGateStateEqual,
-	});
-
-	let lastEmittedState: BudgetGateState | null = null;
-
-	function publishState(): void {
-		const snapshot: BudgetConstraintSnapshot[] = constraints.map((c, i) => {
-			const v = latestValues[i];
-			let satisfied = false;
-			try {
-				satisfied = c.check(v as never);
-			} catch (err) {
-				// QA A3: log the bug-throw rather than silently mapping to
-				// `satisfied=false`. The constraint's check function failing
-				// is a programmer error — at minimum surface it to console.
-				console.error(
-					`budgetGate: constraint "${c.name ?? c.node.name ?? `[${i}]`}" check threw; treating as not satisfied.`,
-					err,
-				);
-				satisfied = false;
-			}
-			return {
-				name: c.name ?? c.node.name ?? "",
-				satisfied,
-				value: v,
-			};
-		});
-		const status: GateState = snapshot.every((s) => s.satisfied) ? "open" : "closed";
-		const next: BudgetGateState = { status, constraintsSnapshot: snapshot };
-		if (lastEmittedState != null && budgetGateStateEqual(lastEmittedState, next)) {
-			return;
-		}
-		lastEmittedState = next;
-		budgetGateState.down([[DIRTY], [DATA, next]]);
-	}
-
-	function flushBuffer(actions: NodeActions): void {
-		// FIFO drain — invariant 2 (PAUSE-release ordering). Stop early if a
-		// later constraint check flips false mid-drain (the queue's tail stays
-		// buffered for the next RESUME).
-		while (buffer.size > 0 && checkBudget()) {
-			const item = buffer.shift()!;
-			actions.emit(item);
-		}
-		// Drain deferred RESOLVED once buffer is empty (invariant 3).
-		if (buffer.size === 0 && pendingResolved) {
-			pendingResolved = false;
-			actions.down([[RESOLVED]]);
-		}
-	}
-
-	// Producer pattern: manually subscribe to all deps for per-message interception.
-	// Source / constraint edges are intentionally NOT declared as `_deps` — see
-	// the JSDoc "Producer-pattern" section above and COMPOSITION-GUIDE §24.
-	const out = node<T>(
-		[],
-		(_data, gateActions) => {
-			// Seed `latestValues` at activation (not factory time) so any constraint
-			// updates between factory return and first subscribe are captured before
-			// source's push-on-subscribe fires `checkBudget()`.
-			for (let i = 0; i < constraints.length; i++) {
-				latestValues[i] = constraints[i]!.node.cache;
-			}
-			// Seed the companion state at activation as well.
-			publishState();
-			const unsubs: Array<() => void> = [];
-			for (let depIdx = 0; depIdx < allDeps.length; depIdx++) {
-				const dep = allDeps[depIdx];
-				unsubs.push(
-					dep.subscribe((msgs) => {
-						for (const msg of msgs) {
-							_handleBudgetMessage(msg, depIdx, gateActions);
-						}
-					}),
-				);
-			}
-			return {
-				onDeactivation: () => {
-					for (const u of unsubs) u();
-				},
-			};
-		},
-		{
-			...opts,
-			describeKind: "derived",
-			meta: domainMeta("resilience", "budget_gate", opts?.meta),
-		} as NodeOptions<T>,
-	);
-
-	return { node: out, budgetGateState };
-
-	function _handleBudgetMessage(msg: Message, depIndex: number, actions: NodeActions): boolean {
-		const t = msg[0];
-
-		// Source messages (dep 0)
-		if (depIndex === 0) {
-			if (t === DATA) {
-				if (checkBudget() && buffer.size === 0) {
-					actions.emit(msg[1] as T);
-				} else {
-					buffer.push(msg[1] as T);
-					if (!paused) {
-						paused = true;
-						actions.up([[PAUSE, lockId]]);
-					}
-				}
-				return true;
-			}
-			if (t === DIRTY) {
-				actions.down([[DIRTY]]);
-				return true;
-			}
-			if (t === RESOLVED) {
-				if (buffer.size === 0) {
-					actions.down([[RESOLVED]]);
-				} else {
-					// Buffer non-empty: defer RESOLVED until buffer drains (invariant 3).
-					pendingResolved = true;
-				}
-				return true;
-			}
-			if (t === COMPLETE || t === ERROR) {
-				// Invariant 1: terminal force-flush. Drain every buffered item
-				// downstream BEFORE forwarding the terminal — bypass the constraint
-				// since "upstream done" must not lose buffered work.
-				while (buffer.size > 0) {
-					actions.emit(buffer.shift()!);
-				}
-				pendingResolved = false;
-				// Release PAUSE lock before forwarding terminal so upstream sees a
-				// clean release rather than a still-paused terminal.
-				if (paused) {
-					paused = false;
-					actions.up([[RESUME, lockId]]);
-				}
-				actions.down([msg]);
-				return true;
-			}
-			return false;
-		}
-
-		// Constraint node messages (dep 1+): capture DATA then re-check budget
-		if (t === DATA) {
-			latestValues[depIndex - 1] = msg[1];
-		}
-		if (t === DATA || t === RESOLVED) {
-			// qa A2: hoist `checkBudget()` to a local — both branches consult it
-			// and `c.check(value)` may be expensive or non-pure (closes over time,
-			// counters, etc.); calling it twice was a 2× cost amplifier and an
-			// inconsistency risk if the predicate flips between calls.
-			//
-			// qa A3: each constraint's `c.check(latestValues[i])` runs against
-			// the constraint's last cached value. If a constraint's cache is
-			// `undefined` (constraint Node hasn't emitted DATA yet OR was
-			// activated before any push-on-subscribe), the predicate sees
-			// `undefined`. Treat undefined as "constraint not ready ⇒ closed"
-			// (conservative — don't release the gate on incomplete state).
-			const ok = checkBudget();
-			if (ok && buffer.size > 0) {
-				// Invariant 2: drain FIFO downstream BEFORE releasing PAUSE upstream.
-				flushBuffer(actions);
-				if (buffer.size === 0 && paused) {
-					paused = false;
-					actions.up([[RESUME, lockId]]);
-				}
-			} else if (!ok && !paused && buffer.size > 0) {
-				// Defensive — buffer.size > 0 implies paused=true under normal flow
-				// (a buffered source DATA always sets paused). Kept for clarity if
-				// invariants ever shift.
-				paused = true;
-				actions.up([[PAUSE, lockId]]);
-			}
-			// DS-13.5.B: re-publish gate state on constraint update.
-			if (t === DATA) publishState();
-			return true;
-		}
-		if (t === DIRTY) {
-			// Invariant 4: constraint DIRTY does not propagate downstream.
-			return true;
-		}
-		if (t === ERROR) {
-			// Constraint error → forward downstream
-			actions.down([msg]);
-			return true;
-		}
-		if (t === COMPLETE) {
-			// Constraint completed — locked at last value, no-op
-			return true;
-		}
-		// Unknown constraint types → default forwarding
-		return false;
-	}
-}
diff --git a/src/utils/resilience/fallback.ts b/src/utils/resilience/fallback.ts
deleted file mode 100644
index 6741ee10..00000000
--- a/src/utils/resilience/fallback.ts
+++ /dev/null
@@ -1,129 +0,0 @@
-/**
- * Fallback — replace upstream ERROR with a static or computed source.
- *
- * Accepts scalar / `Node` / `PromiseLike` / `AsyncIterable` fallbacks; non-Node
- * inputs are routed through `fromAny` so the fallback participates in the
- * reactive protocol uniformly.
- */
-
-import {
-	COMPLETE,
-	DATA,
-	DIRTY,
-	ERROR,
-	factoryTag,
-	type Node,
-	node,
-	RESOLVED,
-	TEARDOWN,
-} from "@graphrefly/pure-ts/core";
-import { fromAny } from "@graphrefly/pure-ts/extra";
-import {
-	isAsyncIterable,
-	isNode,
-	isThenable,
-	operatorOpts,
-} from "../../base/resilience/_internal.js";
-
-/** Inputs accepted by {@link fallback}. */
-export type FallbackInput<T> = T | Node<T> | PromiseLike<T> | AsyncIterable<T>;
-
-/**
- * On upstream terminal `ERROR`, switch to a fallback source instead of propagating the error.
- *
- * Accepts any of:
- * - **scalar value** — emits `[[DATA, fb], [COMPLETE]]`
- * - **`Node<T>`** — subscribes and forwards all messages (push-on-subscribe delivers current cache)
- * - **`Promise<T>` / thenable** — resolves into a one-shot `DATA` then `COMPLETE` (via {@link fromAny})
- * - **`AsyncIterable<T>`** — streams each yielded value as `DATA`, then `COMPLETE` (via {@link fromAny})
- *
- * Non-`Node` inputs are routed through {@link fromAny} so the fallback participates in the
- * reactive protocol uniformly. Bare strings, arrays, and other synchronous scalars are treated
- * as single values (NOT split into characters / elements) to avoid the `fromAny`-on-string
- * iteration gotcha.
- *
- * Composes naturally with {@link retry}:
- * `pipe(source, retry({count:3}), fallback("default"))`.
- *
- * @param source - Upstream node.
- * @param fb - Fallback value, node, promise, or async iterable.
- * @returns Node that replaces errors with the fallback.
- *
- * @example
- * ```ts
- * import { fallback, throwError } from "@graphrefly/graphrefly";
- *
- * const safe = fallback(throwError(new Error("boom")), "default");
- * safe.cache; // "default" after subscribe
- * ```
- *
- * @category extra
- */
-export function fallback<T>(
-	source: Node<T>,
-	fb: FallbackInput<T>,
-	options?: { meta?: Record<string, unknown> },
-): Node<T> {
-	const callerMeta = options?.meta;
-	return node<T>(
-		(_data, a) => {
-			let fallbackUnsub: (() => void) | undefined;
-			let sourceUnsub: (() => void) | undefined;
-
-			function switchToFallback(): void {
-				sourceUnsub?.();
-				sourceUnsub = undefined;
-				if (isNode(fb) || isThenable(fb) || isAsyncIterable(fb)) {
-					const fbNode = fromAny(fb as Node<T> | PromiseLike<T> | AsyncIterable<T>);
-					fallbackUnsub = fbNode.subscribe((fMsgs) => {
-						a.down(fMsgs);
-						// qa A14: clear fallbackUnsub on terminal so the teardown
-						// closure doesn't double-call it. Idempotency of
-						// fromAny's unsub is implementation-defined; explicit
-						// self-clear is safer.
-						for (const fm of fMsgs) {
-							const ft = fm[0];
-							if (ft === COMPLETE || ft === ERROR || ft === TEARDOWN) {
-								fallbackUnsub = undefined;
-								return;
-							}
-						}
-					});
-				} else {
-					a.emit(fb as T);
-					a.down([[COMPLETE]]);
-				}
-			}
-
-			sourceUnsub = source.subscribe((msgs) => {
-				for (const m of msgs) {
-					const t = m[0];
-					if (t === DIRTY) a.down([[DIRTY]]);
-					else if (t === DATA) a.emit(m[1] as T);
-					else if (t === RESOLVED) a.down([[RESOLVED]]);
-					else if (t === COMPLETE) a.down([[COMPLETE]]);
-					else if (t === ERROR) {
-						switchToFallback();
-						return;
-					} else if (t === TEARDOWN) {
-						fallbackUnsub?.();
-						a.down([m]);
-						return;
-					} else a.down([m]);
-				}
-			});
-
-			return {
-				onDeactivation: () => {
-					sourceUnsub?.();
-					fallbackUnsub?.();
-				},
-			};
-		},
-		{
-			...operatorOpts(),
-			initial: source.cache,
-			meta: { ...(callerMeta ?? {}), ...factoryTag("fallback") },
-		},
-	);
-}
diff --git a/src/utils/resilience/gate-state.ts b/src/utils/resilience/gate-state.ts
deleted file mode 100644
index b86b0e34..00000000
--- a/src/utils/resilience/gate-state.ts
+++ /dev/null
@@ -1,18 +0,0 @@
-/**
- * Central gate-state vocabulary for resilience primitives.
- *
- * **DS-13.5.B follow-on (locked 2026-05-01).** Two-state base enum
- * (`"open" | "closed"`) used as the literal vocabulary inside
- * gate-shaped `<Primitive>State` companions on `budgetGate`. Other
- * primitives extend this base with primitive-specific values:
- *
- * - `rateLimiter` → `GateState | "throttled"`.
- * - `circuitBreaker` → `GateState | "half-open"`.
- *
- * Keeping the base as a separate exported type lets callers narrow
- * generic gate-state consumers without coupling to any one primitive's
- * extension axis.
- *
- * @category extra/resilience
- */
-export type GateState = "open" | "closed";
diff --git a/src/utils/resilience/index.ts b/src/utils/resilience/index.ts
deleted file mode 100644
index cbecc4c7..00000000
--- a/src/utils/resilience/index.ts
+++ /dev/null
@@ -1,33 +0,0 @@
-/**
- * Resilience utilities — roadmap §3.1 + §3.1c (retry, breaker, rate limit, status,
- * fallback, cache, timeout, budgetGate).
- *
- * This module is a thin barrel: domain-level primitives live in their own
- * sub-file (`breaker.ts`, `rate-limiter.ts`, `fallback.ts`, plus the
- * standalone `budget-gate.ts`). The zero-domain reactive operators
- * (`retry`, `withStatus`, `withTimeout`, backoff strategies, `NodeOrValue<T>`)
- * are base-layer — they live in `base/resilience/` and are re-surfaced here
- * so the resilience family ships through one barrel. The `resilientPipeline`
- * preset that composes these lives in `presets/resilience/`.
- */
-
-// Zero-domain reactive operators — base-layer, re-surfaced here so the
-// resilience family ships through one barrel.
-export type { NodeOrValue } from "../../base/resilience/_internal.js";
-export * from "../../base/resilience/retry.js";
-export * from "../../base/resilience/status.js";
-export * from "../../base/resilience/timeout.js";
-export * from "./breaker.js";
-// budgetGate lives in its own file per Tier 2.2 (promoted from
-// patterns/reduction/) — re-export here so it ships through the barrel.
-export {
-	type BudgetConstraint,
-	type BudgetConstraintSnapshot,
-	type BudgetGateBundle,
-	type BudgetGateOptions,
-	type BudgetGateState,
-	budgetGate,
-} from "./budget-gate.js";
-export * from "./fallback.js";
-export type { GateState } from "./gate-state.js";
-export * from "./rate-limiter.js";
diff --git a/src/utils/resilience/rate-limiter.ts b/src/utils/resilience/rate-limiter.ts
deleted file mode 100644
index 400f107a..00000000
--- a/src/utils/resilience/rate-limiter.ts
+++ /dev/null
@@ -1,648 +0,0 @@
-/**
- * Rate limiters — `tokenBucket` (raw meter), `rateLimiter` (operator with
- * bounded queue + reactive backpressure companions), and the re-export of
- * `adaptiveRateLimiter` from its standalone module.
- */
-
-import {
-	COMPLETE,
-	DATA,
-	DIRTY,
-	ERROR,
-	factoryTag,
-	monotonicNs,
-	type Node,
-	node,
-	RESOLVED,
-	ResettableTimer,
-	RingBuffer,
-	TEARDOWN,
-} from "@graphrefly/pure-ts/core";
-import {
-	isNode,
-	type NodeOrValue,
-	operatorOpts,
-	resolveReactiveOption,
-} from "../../base/resilience/_internal.js";
-import { NS_PER_MS, NS_PER_SEC } from "../../base/resilience/backoff.js";
-import type { GateState } from "./gate-state.js";
-
-// `adaptiveRateLimiter` lives in extra/adaptive-rate-limiter.ts (kept independent
-// because it has its own internal control-loop machinery).
-export * from "./adaptive-rate-limiter.js";
-
-export interface TokenBucket {
-	/**
-	 * Number of tokens currently available (after refill).
-	 *
-	 * **Float-valued.** When `refillPerSecond` is fractional (or `capacity` × elapsed-fraction
-	 * yields a non-integer), the bucket accumulates fractional refill credit between
-	 * `tryConsume`s. Consumers should not assume integer tokens — e.g. with
-	 * `tokenBucket(10, 2.5)` after 100ms of elapsed time `available()` may report `0.25`.
-	 */
-	available(): number;
-	/** Try to consume `cost` tokens. Returns `true` if successful. */
-	tryConsume(cost?: number): boolean;
-	/**
-	 * Return `cost` tokens to the bucket (capped at capacity). Used when a
-	 * multi-bucket admission fails partway — e.g., `adaptiveRateLimiter`
-	 * consumes from an rpm bucket, then a tpm bucket; if tpm fails, call
-	 * `rpmBucket.putBack(requestCost)` so the rpm slot isn't wasted.
-	 * No-op for non-positive `cost`.
-	 */
-	putBack(cost?: number): void;
-}
-
-/** Optional configuration for {@link tokenBucket}. */
-export interface TokenBucketOptions {
-	/**
-	 * Clock function returning **nanoseconds** with `monotonicNs()` semantics
-	 * (monotonically non-decreasing). Default: `monotonicNs` from `core/clock`.
-	 * Override for deterministic tests — eliminates the need for `vi.useFakeTimers`
-	 * to drive token-refill scheduling.
-	 */
-	clock?: () => number;
-}
-
-/**
- * Token-bucket meter (capacity + refill rate per second). Use with {@link rateLimiter} or custom gates.
- *
- * @param capacity - Maximum tokens (must be positive).
- * @param refillPerSecond - Tokens added per elapsed second (non-negative; may be fractional).
- * @param opts - Optional `clock` override for deterministic testing.
- * @returns {@link TokenBucket} instance.
- *
- * @remarks
- * **Float behavior:** the internal token counter is float-valued — fractional refill
- * accumulates between `tryConsume` calls. See {@link TokenBucket.available} for caveats.
- *
- * **Clock injection:** pass `opts.clock` to drive refill scheduling deterministically
- * in tests. The contract matches {@link circuitBreaker}'s `now` option: must return
- * `monotonicNs()`-style nanoseconds, never `Date.now()` (wall-clock skew breaks
- * elapsed math).
- *
- * @example
- * ```ts
- * import { tokenBucket } from "@graphrefly/graphrefly";
- *
- * const bucket = tokenBucket(10, 2); // capacity 10, refill 2 tokens/sec
- * bucket.tryConsume(3); // true — 7 tokens remaining
- * bucket.available();   // ~7 (plus any elapsed refill — float-valued)
- *
- * // Deterministic test:
- * let t = 0;
- * const tb = tokenBucket(5, 1, { clock: () => t });
- * tb.tryConsume(5);    // exhausts
- * t = 1_000_000_000;   // advance 1s → +1 refill
- * tb.tryConsume(1);    // true
- * ```
- *
- * @category extra
- */
-export function tokenBucket(
-	capacity: number,
-	refillPerSecond: number,
-	opts?: TokenBucketOptions,
-): TokenBucket {
-	if (capacity <= 0) throw new RangeError("capacity must be > 0");
-	if (refillPerSecond < 0) throw new RangeError("refillPerSecond must be >= 0");
-
-	const clock = opts?.clock ?? monotonicNs;
-
-	let tokens = capacity;
-	let updatedAt = clock();
-
-	function refill(now: number): void {
-		if (refillPerSecond > 0) {
-			const elapsedNs = now - updatedAt;
-			tokens = Math.min(capacity, tokens + (elapsedNs / NS_PER_SEC) * refillPerSecond);
-		}
-		updatedAt = now;
-	}
-
-	return {
-		available(): number {
-			refill(clock());
-			return tokens;
-		},
-		tryConsume(cost = 1): boolean {
-			if (cost <= 0) return true;
-			const now = clock();
-			refill(now);
-			if (tokens >= cost) {
-				tokens -= cost;
-				return true;
-			}
-			return false;
-		},
-		putBack(cost = 1): void {
-			if (cost <= 0) return;
-			refill(clock());
-			tokens = Math.min(capacity, tokens + cost);
-		},
-	};
-}
-
-export type RateLimiterOverflowPolicy = "drop-oldest" | "drop-newest" | "error";
-
-export type RateLimiterOptions = {
-	/** Maximum `DATA` emissions per window (must be > 0). */
-	maxEvents: number;
-	/** Window length in nanoseconds (must be > 0). */
-	windowNs: number;
-	/**
-	 * Cap on items queued while waiting for token refill.
-	 *
-	 * **Required.** Pass a finite positive integer (>= 1) for a bounded queue, OR
-	 * the literal `Infinity` to opt in to an unbounded queue (caller acknowledges
-	 * the unbounded-memory-growth risk on a high-rate source). Omitting this
-	 * throws at construction time — the silent-unbounded-buffer footgun is the
-	 * most common rateLimiter mis-configuration.
-	 */
-	maxBuffer: number;
-	/** Overflow policy when `maxBuffer` is exceeded. Default: `"drop-newest"`. */
-	onOverflow?: RateLimiterOverflowPolicy;
-	/**
-	 * Caller-supplied metadata merged into the produced node's `meta` (Tier 5.2
-	 * D8 widening). Use {@link domainMeta} to tag the layer for `describe()` /
-	 * mermaid grouping (e.g. `domainMeta("resilient", "rate-limit")`). The
-	 * primitive's own `factoryTag("rateLimiter", opts)` and the `droppedCount`
-	 * / `rateLimitState` companion seeds always win against caller-supplied
-	 * keys so the audit trail can't be silently overwritten.
-	 */
-	meta?: Record<string, unknown>;
-};
-
-/**
- * Thrown by {@link rateLimiter} when `onOverflow: "error"` and the pending buffer is full.
- *
- * @category extra
- */
-export class RateLimiterOverflowError extends Error {
-	override name = "RateLimiterOverflowError";
-	constructor(maxBuffer: number) {
-		super(`rateLimiter buffer overflow (maxBuffer=${maxBuffer})`);
-	}
-}
-
-/**
- * Combined runtime state surfaced by {@link rateLimiter} alongside `droppedCount`.
- * Tier 5.2 D7 widening — exposes pending-buffer occupancy and a `paused`
- * flag so consumers can render backpressure (UI), feed `lens.health`, or
- * gate downstream effects.
- */
-/**
- * Lifecycle-shaped state companion emitted by {@link rateLimiter}.
- *
- * **DS-13.5.B widening (2026-05-01).** `status` extends {@link GateState}
- * with `"throttled"` (= `paused === true`). Pre-1.0 break vs the prior
- * shape (which omitted `status`).
- *
- * - `"open"` — passing through (no buffering, no recent overflow drops).
- * - `"throttled"` — at least one item queued awaiting a token refill.
- * - `"closed"` — reserved for future terminal lifecycle reporting.
- */
-export type RateLimiterState = {
-	/** DS-13.5.B status field — `"open" | "closed" | "throttled"`. */
-	status: GateState | "throttled";
-	/** Cumulative `DATA` items dropped due to overflow since this subscription cycle started. */
-	droppedCount: number;
-	/** Items currently buffered awaiting a token refill. `0` when the limiter is passing through. */
-	pendingCount: number;
-	/** `true` when at least one item is queued (the limiter is actively throttling). */
-	paused: boolean;
-};
-
-function rateLimiterStateEqual(a: RateLimiterState, b: RateLimiterState): boolean {
-	return (
-		a.status === b.status &&
-		a.droppedCount === b.droppedCount &&
-		a.pendingCount === b.pendingCount &&
-		a.paused === b.paused
-	);
-}
-
-const RATE_LIMITER_INITIAL_STATE: RateLimiterState = Object.freeze({
-	status: "open" as const,
-	droppedCount: 0,
-	pendingCount: 0,
-	paused: false,
-});
-
-/** Bundle returned by {@link rateLimiter}. */
-export type RateLimiterBundle<T> = {
-	/** The throttled stream — at most `maxEvents` `DATA` per `windowNs`. */
-	node: Node<T>;
-	/**
-	 * Reactive companion: count of `DATA` items dropped since the producer
-	 * activated.
-	 *
-	 * - Increments on every drop under any overflow policy (`drop-newest`,
-	 *   `drop-oldest`). The `error` policy terminates the stream after a single
-	 *   overflow, so `droppedCount` increments at most once in that path.
-	 * - **Lifecycle scoping (qa A1 + EC7):** the counter retains its final
-	 *   value through terminal (`COMPLETE` / `ERROR` / `TEARDOWN`) so consumers
-	 *   see the final drop count, not zero. The closure-held counter resets to
-	 *   `0` only when the producer fn re-runs — which only happens on a new
-	 *   subscription cycle, and only if the producer was constructed with
-	 *   `resubscribable: true`. The default `rateLimiter` producer is NOT
-	 *   resubscribable, so a single producer-fn run is the typical lifetime.
-	 * - Producer-pattern note: this companion is invisible to `describe()`
-	 *   traversal from `node` (effect-mirror limitation; same shape as
-	 *   `withBreaker.breakerState` and `withStatus.status`). Surface it via
-	 *   `node.meta.droppedCount` if you need it in topology snapshots.
-	 */
-	droppedCount: Node<number>;
-	/**
-	 * Reactive companion: combined `{droppedCount, pendingCount, paused}` view.
-	 *
-	 * - `pendingCount` reflects the live buffer occupancy and updates on every
-	 *   push / shift / overflow drop; `paused` is shorthand for
-	 *   `pendingCount > 0`.
-	 * - Equality-deduped — re-emits only when one of the three fields actually
-	 *   changes (so a busy steady-state where every DATA passes immediately
-	 *   produces one `paused: false` emission, not one per DATA).
-	 * - **Lifecycle scoping (qa EC7):** same contract as `droppedCount` —
-	 *   retains its final value through terminal; resets to the initial
-	 *   `{droppedCount: 0, pendingCount: 0, paused: false}` only on a new
-	 *   producer-fn run (resubscribable upstream required).
-	 * - Same producer-pattern caveat as `droppedCount` re: `describe()` visibility.
-	 */
-	rateLimitState: Node<RateLimiterState>;
-};
-
-/** Shared opts validation gate — used by both the static-form and the reactive-swap paths. */
-function validateRateLimiterOpts(o: RateLimiterOptions): void {
-	if (o.maxEvents <= 0) throw new RangeError("maxEvents must be > 0");
-	if (o.windowNs <= 0) throw new RangeError("windowNs must be > 0");
-	if (o.maxBuffer === undefined) {
-		throw new RangeError(
-			"rateLimiter requires explicit maxBuffer (use Infinity to opt in to unbounded)",
-		);
-	}
-	const isUnbounded = o.maxBuffer === Infinity;
-	if (!isUnbounded && (!Number.isInteger(o.maxBuffer) || o.maxBuffer < 1)) {
-		throw new RangeError("maxBuffer must be a positive integer (or Infinity for unbounded)");
-	}
-}
-
-/**
- * Resolve the construction-time lock value for reactive (Node-form) opts.
- * Throws (D4) when the opts Node has no cached value — the mode + initial
- * cap are locked here and the swap handler rejects mode toggles, so a silent
- * bounded-`maxBuffer:1` default would be an undebuggable footgun.
- */
-function resolveInitialReactiveOpts(optsNode: Node<RateLimiterOptions>): RateLimiterOptions {
-	const cached = optsNode.cache as RateLimiterOptions | undefined;
-	if (cached === undefined) {
-		throw new RangeError(
-			"rateLimiter: reactive (Node-form) opts must carry a cached value at " +
-				"construction — seed the opts Node with `initial`. Mode (bounded vs " +
-				"unbounded) and the initial cap are LOCKED from `.cache` at construction " +
-				"and the swap handler rejects mode toggles; an un-seeded Node would " +
-				"silently lock bounded `maxBuffer: 1` (D4).",
-		);
-	}
-	return cached;
-}
-
-/**
- * Token-bucket rate limiter: at most `maxEvents` `DATA` values per `windowNs`.
- *
- * Uses {@link tokenBucket} internally (capacity = `maxEvents`, refill = `maxEvents / windowSeconds`).
- * Excess items are queued FIFO (in a fixed-capacity {@link RingBuffer} for O(1) push/shift)
- * until a token is available. The queue is bounded by the **required** `maxBuffer` option
- * with a configurable overflow policy.
- *
- * @param source - Upstream node.
- * @param opts - Rate + bounded-buffer configuration. `maxBuffer` is required (use `Infinity` to opt in to unbounded).
- * @returns `{ node, droppedCount }` bundle. Subscribe to `node` for the throttled stream and to `droppedCount` for backpressure pressure.
- *
- * @throws {RangeError} when `maxEvents` / `windowNs` is non-positive, when
- * `maxBuffer` is omitted, when `maxBuffer` is a finite value < 1, or when
- * `opts` is a Node (reactive form) with **no cached value at construction**
- * (D4 — the mode + initial cap are locked from `.cache` at construction;
- * seed the opts Node with `initial`).
- *
- * @remarks
- * **Reactive opts (Node form) must be seeded.** Mode (bounded vs unbounded)
- * and the initial cap are read from `opts.cache` at construction and the swap
- * handler rejects mode toggles. An un-seeded opts Node therefore throws at
- * construction rather than silently locking bounded `maxBuffer: 1` (D4).
- *
- * **Terminal:** `COMPLETE` / `ERROR` cancel the refill timer, drop the pending queue,
- * reset `droppedCount` to `0`, and propagate.
- *
- * @example
- * ```ts
- * import { rateLimiter, state, NS_PER_SEC } from "@graphrefly/graphrefly";
- *
- * const src = state(0);
- * // Allow at most 5 DATA values per second; queue up to 100 excess items, drop newest beyond.
- * const { node: limited, droppedCount } = rateLimiter(src, {
- *   maxEvents: 5,
- *   windowNs: NS_PER_SEC,
- *   maxBuffer: 100,
- * });
- * droppedCount.subscribe(([m]) => console.log("dropped so far:", m[1]));
- * ```
- *
- * @category extra
- */
-export function rateLimiter<T>(
-	source: Node<T>,
-	opts: NodeOrValue<RateLimiterOptions>,
-): RateLimiterBundle<T> {
-	// Mode (bounded vs unbounded) + the initial cap are LOCKED at construction
-	// from the resolved opts (Tier 6.5 3.2.3 swap rule — runtime swaps change
-	// the cap WITHIN the same mode; toggling bounded↔unbounded requires
-	// re-mounting). For reactive (Node-form) opts the lock is read from
-	// `.cache` at construction — so an un-seeded opts Node is a hard error
-	// (D4, relaxed 2026-05-18): silently defaulting to bounded `maxBuffer: 1`
-	// and then no-op-ing every mode-changing emit is the worst kind of
-	// footgun. Fail loud — seed the opts Node with `initial`. The resolved
-	// value is validated by the same gate static-form opts use; reactive
-	// *swaps* still re-validate softly in the producer body (a bad runtime
-	// emit keeps the previous values rather than throwing into the dataplane).
-	const isReactive = isNode(opts);
-	const initialOpts: RateLimiterOptions = isReactive
-		? resolveInitialReactiveOpts(opts as Node<RateLimiterOptions>)
-		: (opts as RateLimiterOptions);
-	validateRateLimiterOpts(initialOpts);
-	const initialMaxBuffer = initialOpts.maxBuffer;
-	const isUnbounded = initialMaxBuffer === Infinity;
-
-	const out = node<T>(
-		(_data, a) => {
-			// Mutable closure-state — replaced on each option swap. `initialOpts`
-			// is fully resolved + validated at construction (D4), so these reads
-			// are unconditional (no `?? placeholder` fallback).
-			let maxEvents = initialOpts.maxEvents;
-			let windowNs = initialOpts.windowNs;
-			let maxBuffer = initialMaxBuffer;
-			let onOverflow: RateLimiterOverflowPolicy = initialOpts.onOverflow ?? "drop-newest";
-			let refillPerSec = (maxEvents * NS_PER_SEC) / windowNs;
-			let tokenTimeNs = NS_PER_SEC / refillPerSec;
-			let bucket = tokenBucket(maxEvents, refillPerSec);
-
-			// RingBuffer for O(1) push + shift. Unbounded mode falls back to a plain
-			// array (RingBuffer requires a positive integer capacity); the caller
-			// explicitly opted in via `maxBuffer: Infinity` and accepts the cost.
-			// Bounded mode allocates with the INITIAL `maxBuffer`; runtime cap
-			// reductions enforce drop-oldest at push time without resizing the ring.
-			const pending: { push: (v: T) => void; shift: () => T | undefined; size: number } =
-				isUnbounded ? makeArrayQueue<T>() : ringBufferQueue<T>(Math.max(1, maxBuffer));
-			const timer = new ResettableTimer();
-			let terminated = false;
-			let dropped = 0;
-
-			// Mirror the dropped counter + combined state to the meta companions.
-			// The `emit` call is the same subscribe-callback effect-mirror
-			// pattern used by `withBreaker.breakerState` / `withStatus.status`
-			// (sanctioned per audit § F.7).
-			const droppedNode = out.meta.droppedCount;
-			const stateNode = out.meta.rateLimitState;
-			let lastState: RateLimiterState = RATE_LIMITER_INITIAL_STATE;
-			function syncState(): void {
-				droppedNode.emit(dropped);
-				const isPaused = pending.size > 0;
-				const next: RateLimiterState = {
-					status: isPaused ? "throttled" : "open",
-					droppedCount: dropped,
-					pendingCount: pending.size,
-					paused: isPaused,
-				};
-				// Equality-dedup at the emit boundary so steady-state pass-through
-				// (every DATA passes immediately — pendingCount stays 0, paused
-				// stays false) doesn't generate one state DATA per source DATA.
-				if (!rateLimiterStateEqual(lastState, next)) {
-					lastState = next;
-					stateNode.emit(next);
-				}
-			}
-
-			// Reset for this subscription cycle — `dropped` is the closure
-			// variable (already 0 at construction); `pending.size` is also 0
-			// (fresh queue per producer activation). The companion Node caches
-			// may still hold a prior cycle's terminal values, so re-emit the
-			// initial state explicitly.
-			lastState = RATE_LIMITER_INITIAL_STATE;
-			droppedNode.emit(0);
-			stateNode.emit(RATE_LIMITER_INITIAL_STATE);
-
-			// Tier 6.5 3.2.3 (2026-04-29): reactive option swap handler.
-			// Locked semantics: `maxEvents`/`windowNs` swap rebuilds the
-			// token bucket at the next refill window (tokens reset to new
-			// capacity, refill rate updates immediately). `maxBuffer` shrink
-			// drops oldest pending entries until size ≤ new cap. `onOverflow`
-			// swap takes effect at the next overflow check. Mode toggling
-			// (bounded ↔ unbounded) is NOT supported — locked at construction.
-			const optMirror = resolveReactiveOption<RateLimiterOptions>(
-				opts as NodeOrValue<RateLimiterOptions>,
-				(next) => {
-					if (terminated) return;
-					if (next == null) return;
-					// QA A9 (2026-05-03): explicit empty `{}` short-circuit
-					// for symmetry with timeout / retry / circuitBreaker
-					// (DS-13.5.B locked rule: empty `{}` is a no-op — no
-					// rebind, no companion fire). Pre-fix, empty `{}` was
-					// implicitly a no-op via the validation gate's
-					// `next.maxEvents > 0` check on `undefined`; this
-					// makes the rule explicit and resilient to future
-					// validation refactors.
-					if (typeof next === "object" && Object.keys(next).length === 0) return;
-					// Validate; if invalid, keep previous values (no throw into dataplane).
-					if (!(next.maxEvents > 0) || !(next.windowNs > 0)) return;
-					const nextBuf = next.maxBuffer;
-					if (nextBuf === undefined) return;
-					const nextUnbounded = nextBuf === Infinity;
-					if (nextUnbounded !== isUnbounded) {
-						// Mode toggle not supported — skip silently. Caller using
-						// reactive opts must keep maxBuffer in the same mode.
-						return;
-					}
-					if (!nextUnbounded && (!Number.isInteger(nextBuf) || nextBuf < 1)) return;
-
-					// qa F-C (Tier 5 /qa pass, 2026-04-29): reactive `maxBuffer`
-					// is monotonically non-increasing. The pending RingBuffer is
-					// allocated once at construction; growing the cap reactively
-					// would let the overflow check pass more pushes than the
-					// ring's capacity → silent drop-oldest at the substrate level
-					// (RingBuffer.push wraps), bypassing our `dropped` counter
-					// and `onOverflow: "error"` arm. Reject grow swaps with a
-					// console.warn and keep the previous cap. Shrink stays
-					// supported (drop-oldest below).
-					if (!nextUnbounded && nextBuf > maxBuffer) {
-						console.warn(
-							`rateLimiter: reactive maxBuffer grow (${maxBuffer} → ${nextBuf}) ` +
-								"rejected. The pending ring buffer is allocated at construction; " +
-								"reactive maxBuffer is monotonically non-increasing. Recreate " +
-								"the rateLimiter with the larger cap if growth is required.",
-						);
-						return;
-					}
-
-					maxEvents = next.maxEvents;
-					windowNs = next.windowNs;
-					maxBuffer = nextBuf;
-					onOverflow = next.onOverflow ?? "drop-newest";
-					refillPerSec = (maxEvents * NS_PER_SEC) / windowNs;
-					tokenTimeNs = NS_PER_SEC / refillPerSec;
-					// Rebuild bucket — tokens snap to new capacity. The old refill
-					// timer continues to fire `tryEmit` which will use the new
-					// bucket (same closure variable).
-					bucket = tokenBucket(maxEvents, refillPerSec);
-
-					// Drop-oldest until pending.size <= maxBuffer (bounded only).
-					if (!nextUnbounded) {
-						while (pending.size > maxBuffer) {
-							pending.shift();
-							dropped += 1;
-						}
-					}
-					syncState();
-				},
-			);
-
-			function tryEmit(): void {
-				while (pending.size > 0) {
-					if (bucket.tryConsume(1)) {
-						a.emit(pending.shift() as T);
-						syncState();
-					} else {
-						// Wait one full token-refill interval. Avoids calling bucket.available()
-						// which would advance the internal refill clock and steal fractional credit.
-						// §5.10: setTimeout (not fromTimer) — refill-delay scheduling needs clearTimeout/setTimeout;
-						// fromTimer creates a new Node per reset, adding lifecycle overhead per retry.
-						timer.start(Math.max(1, tokenTimeNs / NS_PER_MS), tryEmit);
-						return;
-					}
-				}
-			}
-
-			function recordDrop(): void {
-				dropped += 1;
-				syncState();
-			}
-
-			function resetForTerminal(): void {
-				terminated = true;
-				timer.cancel();
-				// RingBuffer.clear-equivalent: drain remaining slots so refs GC.
-				while (pending.size > 0) pending.shift();
-				// qa A1: companions retain their last-emitted DATA value
-				// through terminal (consumer sees the final drop count, not 0).
-				// The closure-held `dropped` resets to 0 so a re-subscribe
-				// cycle starts fresh; the activation block above re-emits
-				// `RATE_LIMITER_INITIAL_STATE` at that point.
-				dropped = 0;
-			}
-
-			const unsub = source.subscribe((msgs) => {
-				for (const m of msgs) {
-					if (terminated) return;
-					const t = m[0];
-					if (t === DIRTY) a.down([[DIRTY]]);
-					else if (t === DATA) {
-						if (!isUnbounded && pending.size >= maxBuffer) {
-							if (onOverflow === "drop-newest") {
-								recordDrop();
-							} else if (onOverflow === "drop-oldest") {
-								pending.shift();
-								pending.push(m[1] as T);
-								recordDrop();
-							} else {
-								recordDrop();
-								resetForTerminal();
-								a.down([[ERROR, new RateLimiterOverflowError(maxBuffer)]]);
-								return;
-							}
-						} else {
-							pending.push(m[1] as T);
-							syncState();
-						}
-						tryEmit();
-					} else if (t === RESOLVED) a.down([[RESOLVED]]);
-					else if (t === COMPLETE) {
-						resetForTerminal();
-						a.down([[COMPLETE]]);
-					} else if (t === ERROR) {
-						resetForTerminal();
-						a.down([m]);
-					} else if (t === TEARDOWN) {
-						resetForTerminal();
-						a.down([m]);
-						return;
-					} else a.down([m]);
-				}
-			});
-
-			return {
-				onDeactivation: () => {
-					terminated = true;
-					timer.cancel();
-					unsub();
-					optMirror.unsub();
-				},
-			};
-		},
-		{
-			...operatorOpts(),
-			initial: source.cache,
-			meta: {
-				// Caller-supplied meta first; companion seeds + factoryTag
-				// override below so they always win.
-				...(isReactive ? {} : ((opts as RateLimiterOptions).meta ?? {})),
-				droppedCount: 0,
-				rateLimitState: RATE_LIMITER_INITIAL_STATE,
-				...factoryTag("rateLimiter", isReactive ? { reactiveOpts: true } : opts),
-			},
-		},
-	);
-
-	return {
-		node: out,
-		droppedCount: out.meta.droppedCount as Node<number>,
-		rateLimitState: out.meta.rateLimitState as Node<RateLimiterState>,
-	};
-}
-
-/**
- * RingBuffer-backed queue adapter — exposes the small `{ push, shift, size }`
- * shape rateLimiter needs without leaking the rest of `RingBuffer`'s API.
- */
-function ringBufferQueue<T>(capacity: number): {
-	push: (v: T) => void;
-	shift: () => T | undefined;
-	size: number;
-} {
-	const buf = new RingBuffer<T>(capacity);
-	return {
-		push: (v: T) => buf.push(v),
-		shift: () => buf.shift(),
-		get size(): number {
-			return buf.size;
-		},
-	} as { push: (v: T) => void; shift: () => T | undefined; size: number };
-}
-
-/**
- * Plain-array fallback queue for `maxBuffer: Infinity`. Accepts the O(N) shift
- * cost — the caller opted in to unbounded growth.
- */
-function makeArrayQueue<T>(): {
-	push: (v: T) => void;
-	shift: () => T | undefined;
-	size: number;
-} {
-	const arr: T[] = [];
-	return {
-		push: (v: T) => {
-			arr.push(v);
-		},
-		shift: () => arr.shift(),
-		get size(): number {
-			return arr.length;
-		},
-	} as { push: (v: T) => void; shift: () => T | undefined; size: number };
-}
diff --git a/src/utils/surface/create.ts b/src/utils/surface/create.ts
deleted file mode 100644
index cdafafe5..00000000
--- a/src/utils/surface/create.ts
+++ /dev/null
@@ -1,55 +0,0 @@
-/**
- * Surface: create a graph from a {@link GraphSpec} (§9.3-core).
- *
- * Thin wrapper over {@link compileSpec} that converts the two failure modes
- * ({@link validateSpec} structural errors, and catalog-aware validation
- * errors) into typed {@link SurfaceError} throws. Consumers are MCP/CLI
- * wrappers, not end-user graph code — those should import `compileSpec`
- * directly.
- *
- * @module
- */
-
-import type { Graph } from "@graphrefly/pure-ts/graph";
-import type { CompileSpecOptions, GraphSpec } from "../graphspec/index.js";
-import { compileSpec, validateSpec, validateSpecAgainstCatalog } from "../graphspec/index.js";
-import { SurfaceError } from "./errors.js";
-
-/** Options for {@link createGraph}. Same shape as {@link CompileSpecOptions}. */
-export type CreateGraphOptions = CompileSpecOptions;
-
-/**
- * Build a {@link Graph} from a parsed {@link GraphSpec} with surface-layer
- * error typing.
- *
- * @throws {SurfaceError} `invalid-spec` for structural errors;
- *   `catalog-error` when fn/source names or config don't match the catalog.
- */
-export function createGraph(spec: GraphSpec, opts?: CreateGraphOptions): Graph {
-	const structural = validateSpec(spec);
-	if (!structural.valid) {
-		throw new SurfaceError(
-			"invalid-spec",
-			`GraphSpec validation failed:\n${structural.errors.join("\n")}`,
-			{ errors: structural.errors },
-		);
-	}
-	const catalog = opts?.catalog ?? {};
-	const catalogValidation = validateSpecAgainstCatalog(spec, catalog);
-	if (!catalogValidation.valid) {
-		throw new SurfaceError(
-			"catalog-error",
-			`Catalog validation failed:\n${catalogValidation.errors.join("\n")}`,
-			{ errors: catalogValidation.errors },
-		);
-	}
-	try {
-		return compileSpec(spec, opts);
-	} catch (err) {
-		// compileSpec re-throws validation errors plus may throw on missing
-		// catalog entries for template-inner deferred nodes. Surface as
-		// catalog-error; callers can inspect the wrapped message.
-		const message = err instanceof Error ? err.message : String(err);
-		throw new SurfaceError("catalog-error", message);
-	}
-}
diff --git a/src/utils/surface/errors.ts b/src/utils/surface/errors.ts
deleted file mode 100644
index d39c121b..00000000
--- a/src/utils/surface/errors.ts
+++ /dev/null
@@ -1,97 +0,0 @@
-/**
- * Typed errors for the surface layer (§9.3-core).
- *
- * The surface layer is consumed by `@graphrefly/mcp-server` and
- * `@graphrefly/cli`. Both have native error channels (MCP's `isError` flag,
- * CLI's exit codes), so surface functions throw a {@link SurfaceError}
- * carrying a structured code + details payload that wrappers can map to
- * their native shape. No `Result` envelope — keep the callsite idiom
- * `try/catch` and let each wrapper surface the error its own way.
- *
- * @module
- */
-
-/** Structured error codes emitted by the surface layer. JSON-safe. */
-export type SurfaceErrorCode =
-	| "invalid-spec"
-	| "graph-not-found"
-	| "graph-exists"
-	| "snapshot-not-found"
-	| "node-not-found"
-	| "reduce-timeout"
-	| "catalog-error"
-	| "restore-failed"
-	| "snapshot-failed"
-	| "tier-no-list"
-	| "compose-not-configured"
-	| "compose-failed"
-	| "internal-error";
-
-/** JSON-safe shape surfaces should echo back through the wrapper. */
-export interface SurfaceErrorPayload {
-	code: SurfaceErrorCode;
-	message: string;
-	/** Optional structured detail; must be JSON-safe. */
-	details?: Readonly<Record<string, unknown>>;
-}
-
-/**
- * Thrown by surface layer functions on failure. `code` is the stable
- * machine-readable identifier; `details` carries structured context
- * (e.g. `validateSpec` errors, missing path name). Both fields round-trip
- * through `toJSON()` for wrappers that serialize errors over the wire.
- */
-export class SurfaceError extends Error {
-	readonly code: SurfaceErrorCode;
-	readonly details?: Readonly<Record<string, unknown>>;
-
-	constructor(
-		code: SurfaceErrorCode,
-		message: string,
-		details?: Readonly<Record<string, unknown>>,
-	) {
-		super(message);
-		this.name = "SurfaceError";
-		this.code = code;
-		if (details !== undefined) this.details = details;
-	}
-
-	/**
-	 * JSON-safe payload for wire serialization. Defensively validates
-	 * `details` — if it can't be round-tripped through `JSON.stringify`
-	 * (cyclic refs, `BigInt`, `Error` instance not pre-toJSON'd), the
-	 * payload falls back to `{code, message}` only rather than crashing
-	 * the MCP/CLI wrapper when it serializes this error onto the wire.
-	 */
-	toJSON(): SurfaceErrorPayload {
-		const out: SurfaceErrorPayload = { code: this.code, message: this.message };
-		if (this.details !== undefined) {
-			const safe = safeDetails(this.details);
-			if (safe !== undefined) out.details = safe;
-		}
-		return out;
-	}
-}
-
-function safeDetails(
-	details: Readonly<Record<string, unknown>>,
-): Readonly<Record<string, unknown>> | undefined {
-	try {
-		// Round-trip through JSON to strip non-serializable values (functions,
-		// undefined) and reject cyclic structures with a thrown TypeError. The
-		// round-trip result is the canonical wire shape.
-		return JSON.parse(JSON.stringify(details)) as Readonly<Record<string, unknown>>;
-	} catch {
-		return undefined;
-	}
-}
-
-/** Wrap any thrown value as a SurfaceError. Idempotent on existing SurfaceError. */
-export function asSurfaceError(
-	err: unknown,
-	fallbackCode: SurfaceErrorCode = "internal-error",
-): SurfaceError {
-	if (err instanceof SurfaceError) return err;
-	const message = err instanceof Error ? err.message : String(err);
-	return new SurfaceError(fallbackCode, message);
-}
diff --git a/src/utils/surface/index.ts b/src/utils/surface/index.ts
deleted file mode 100644
index 2befe667..00000000
--- a/src/utils/surface/index.ts
+++ /dev/null
@@ -1,58 +0,0 @@
-/**
- * Surface layer (§9.3-core) — shared, JSON-safe operations consumed by
- * `@graphrefly/mcp-server` and `@graphrefly/cli`.
- *
- * The surface is a thin projection of existing Graph APIs (`describe`,
- * `observe`, `explain`, `snapshot`, `restore`, static `diff`), plus two
- * genuinely new operations:
- *
- * 1. {@link createGraph} — `compileSpec` wrapped with typed surface errors.
- * 2. {@link reduce} — one-shot `input → pipeline → output`.
- *
- * Snapshot persistence reuses the {@link KvStorageTier} substrate introduced
- * for `Graph.attachSnapshotStorage`, so one-shot snapshots and auto-checkpoints
- * share the {@link GraphCheckpointRecord} envelope. No new wire format.
- *
- * Errors throw as {@link SurfaceError} — wrappers map to their native
- * error channel (MCP `isError`, CLI exit code). No `Result<T, E>` wrapper.
- *
- * @module
- */
-
-// Re-export the graphspec types the surface operates on, so MCP/CLI
-// wrappers get `GraphSpec`/`GraphSpecCatalog` from one import. The
-// runtime functions (`compileSpec`, `validateSpec`, `decompileSpec`,
-// etc.) stay inside `patterns.graphspec` — surface callers use
-// {@link createGraph}, not those directly.
-export type {
-	CatalogFnEntry,
-	CatalogSourceEntry,
-	ConfigFieldSchema,
-	FnFactory,
-	GraphSpec,
-	GraphSpecCatalog,
-	GraphSpecFeedbackEdge,
-	GraphSpecNode,
-	GraphSpecTemplate,
-	GraphSpecTemplateRef,
-	GraphSpecValidation,
-	SourceFactory,
-} from "../graphspec/index.js";
-export type { CreateGraphOptions } from "./create.js";
-export { createGraph } from "./create.js";
-export type { SurfaceErrorCode, SurfaceErrorPayload } from "./errors.js";
-export { asSurfaceError, SurfaceError } from "./errors.js";
-export type { ReduceOptions } from "./reduce.js";
-export { runReduction } from "./reduce.js";
-export type {
-	RestoreSnapshotOptions,
-	SaveSnapshotResult,
-} from "./snapshot.js";
-export {
-	deleteSnapshot,
-	diffSnapshots,
-	listSnapshots,
-	restoreSnapshot,
-	SNAPSHOT_WIRE_VERSION,
-	saveSnapshot,
-} from "./snapshot.js";
diff --git a/src/utils/surface/reduce.ts b/src/utils/surface/reduce.ts
deleted file mode 100644
index 13190e38..00000000
--- a/src/utils/surface/reduce.ts
+++ /dev/null
@@ -1,219 +0,0 @@
-/**
- * Surface: one-shot `input → pipeline → output` (§9.3-core).
- *
- * `runReduction` compiles a {@link GraphSpec}, pushes an input value to a
- * named state node, awaits the first post-push DATA emission on a named
- * output, then disposes the graph. Stateless per call — no graphId, no
- * registry.
- *
- * Named `runReduction` (not `reduce`) to avoid collision with the
- * reactive {@link reduce} operator in `extra/operators.ts`. The MCP tool
- * name (`graphrefly_reduce`) and CLI subcommand (`graphrefly reduce`) use
- * the short form; the library export carries the verb.
- *
- * The subscribe-before-push ordering is deliberate. `graph.set` propagates
- * synchronously for sync derived/operator chains; for async sources
- * (`fromPromise`, `fromAsyncIter`, LLM adapters) the first post-push DATA
- * arrives on a later tick. Subscribing before the push catches both, and
- * skipping the priming push-on-subscribe emission avoids resolving with the
- * stale pre-push cache (spec §2.2).
- *
- * @module
- */
-
-import type { Node } from "@graphrefly/pure-ts/core";
-import { COMPLETE, DATA, ERROR, RESOLVED } from "@graphrefly/pure-ts/core";
-import type { GraphSpec, GraphSpecCatalog } from "../graphspec/index.js";
-import { createGraph } from "./create.js";
-import { SurfaceError } from "./errors.js";
-
-/** Options for {@link reduce}. */
-export interface ReduceOptions {
-	/** Fn/source catalog for {@link createGraph}. */
-	catalog?: GraphSpecCatalog;
-	/** Path of the state node that receives the input. Default `"input"`. */
-	inputPath?: string;
-	/** Path of the node whose first post-push DATA is the result. Default `"output"`. */
-	outputPath?: string;
-	/** Hard deadline in milliseconds. Default `30_000`. */
-	timeoutMs?: number;
-}
-
-const DEFAULT_TIMEOUT_MS = 30_000;
-
-/**
- * Run a spec as a one-shot reduction: `input → graph → output`.
- *
- * Resolves on the first `[DATA, v]` **or** `[RESOLVED]` emitted by
- * `outputPath` after the input push. The RESOLVED path handles spec
- * §1.3.3 equals-substitution (output recomputed to a value equal to its
- * cache, so the graph skips the DATA push) by returning `outputNode.cache`
- * — the caller always gets the settled value, never hangs on idempotent
- * inputs.
- *
- * @throws {SurfaceError} `invalid-spec` / `catalog-error` (propagated from
- *   {@link createGraph}), `node-not-found` when `inputPath`/`outputPath`
- *   can't be resolved, `reduce-timeout` when `timeoutMs` elapses without
- *   a post-push emission, or the ERROR payload from the graph re-thrown
- *   as `internal-error`.
- */
-export async function runReduction(
-	spec: GraphSpec,
-	input: unknown,
-	opts?: ReduceOptions,
-): Promise<unknown> {
-	const inputPath = opts?.inputPath ?? "input";
-	const outputPath = opts?.outputPath ?? "output";
-	const timeoutMs = opts?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
-
-	const graph = createGraph(spec, { catalog: opts?.catalog });
-	let outputNode: Node<unknown>;
-	try {
-		outputNode = graph.resolve(outputPath);
-	} catch {
-		graph.destroy();
-		throw new SurfaceError(
-			"node-not-found",
-			`reduce: output path "${outputPath}" is not registered`,
-			{ path: outputPath },
-		);
-	}
-	// Verify input path exists before we subscribe and push.
-	try {
-		graph.resolve(inputPath);
-	} catch {
-		graph.destroy();
-		throw new SurfaceError(
-			"node-not-found",
-			`reduce: input path "${inputPath}" is not registered`,
-			{ path: inputPath },
-		);
-	}
-
-	try {
-		return await new Promise<unknown>((resolve, reject) => {
-			let primed = false;
-			let settled = false;
-			let timer: ReturnType<typeof setTimeout> | undefined;
-			let unsub: (() => void) | undefined;
-			// Sync-settle deferred-unsubscribe invariant (C24-4):
-			// `outputNode.subscribe(cb)` may invoke `cb` synchronously during
-			// the call (push-on-subscribe per spec §2.2). If `cb` reaches
-			// `finish()` BEFORE `subscribe()` returns, `unsub` is still
-			// `undefined` and we'd leak the subscription if we tried `unsub?.()`
-			// immediately. The contract: `finish()` toggles `shouldUnsub = true`;
-			// the post-subscribe block (after `unsub` is assigned) checks that
-			// flag and tears down. Two-phase ensures exactly one unsubscribe
-			// regardless of whether settlement happened during or after the
-			// subscribe call.
-			let shouldUnsub = false;
-
-			const finish = (action: () => void): void => {
-				if (settled) return;
-				settled = true;
-				if (timer !== undefined) clearTimeout(timer);
-				if (unsub !== undefined) {
-					unsub();
-					unsub = undefined;
-				} else {
-					shouldUnsub = true;
-				}
-				action();
-			};
-
-			unsub = outputNode.subscribe((msgs) => {
-				for (const m of msgs) {
-					if (settled) return;
-					// Skip push-on-subscribe emissions that land before we
-					// trigger the input push — those carry pre-push state.
-					if (!primed) continue;
-					if (m[0] === DATA) {
-						finish(() => resolve(m[1]));
-						return;
-					}
-					if (m[0] === RESOLVED) {
-						// Spec §1.3.3 equals-substitution: the output recomputed to
-						// a value equal to its cached value, so the graph emits
-						// RESOLVED instead of DATA. For a one-shot reduce the
-						// caller wants the output value — read the cache **before**
-						// finish() runs unsub (which can trigger lazy deactivation
-						// and clear the cache per the RAM-cache rule).
-						const cached = outputNode.cache;
-						finish(() => resolve(cached));
-						return;
-					}
-					if (m[0] === ERROR) {
-						const payload = m[1];
-						const message = payload instanceof Error ? payload.message : String(payload);
-						const cause = payload instanceof Error ? payload : undefined;
-						finish(() =>
-							reject(
-								new SurfaceError(
-									"internal-error",
-									`reduce: output emitted ERROR: ${message}`,
-									cause != null ? { cause } : undefined,
-								),
-							),
-						);
-						return;
-					}
-					if (m[0] === COMPLETE) {
-						finish(() =>
-							reject(
-								new SurfaceError(
-									"internal-error",
-									`reduce: output COMPLETEd without a post-push DATA`,
-								),
-							),
-						);
-						return;
-					}
-				}
-			});
-			if (shouldUnsub) {
-				unsub?.();
-				unsub = undefined;
-			}
-
-			primed = true;
-			try {
-				graph.set(inputPath, input);
-			} catch (err) {
-				const message = err instanceof Error ? err.message : String(err);
-				const cause = err instanceof Error ? err : undefined;
-				finish(() =>
-					reject(
-						new SurfaceError(
-							"internal-error",
-							`reduce: failed to set input on "${inputPath}": ${message}`,
-							cause != null ? { path: inputPath, cause } : { path: inputPath },
-						),
-					),
-				);
-				return;
-			}
-
-			// Synchronous wave may have already settled the promise via the
-			// subscribe callback above; skip the timer in that case so we
-			// don't leak an orphan setTimeout into the event loop (A1, E4).
-			if (!settled && Number.isFinite(timeoutMs) && timeoutMs > 0) {
-				timer = setTimeout(() => {
-					finish(() =>
-						reject(
-							new SurfaceError(
-								"reduce-timeout",
-								`reduce: no output emitted within ${timeoutMs}ms`,
-								{ timeoutMs, outputPath },
-							),
-						),
-					);
-				}, timeoutMs);
-				// Belt-and-suspenders: if the caller drops the returned promise
-				// we shouldn't keep the process alive.
-				timer.unref?.();
-			}
-		});
-	} finally {
-		graph.destroy();
-	}
-}
diff --git a/src/utils/surface/snapshot.ts b/src/utils/surface/snapshot.ts
deleted file mode 100644
index 2bb536a5..00000000
--- a/src/utils/surface/snapshot.ts
+++ /dev/null
@@ -1,326 +0,0 @@
-/**
- * Surface: snapshot save/restore/diff/list over {@link KvStorageTier} (§9.3-core).
- *
- * One-shot snapshot management for stateless callers (MCP tools, CLI
- * commands) layered on the existing multi-tier auto-checkpoint substrate.
- * A saved snapshot is a `mode: "full"` {@link GraphCheckpointRecord} with
- * `seq: 0` — byte-identical to the baseline anchor
- * {@link Graph.attachSnapshotStorage} writes on its first flush. An
- * auto-checkpointed graph can therefore be restored through this surface,
- * and a surface-saved snapshot can be picked up by `attachSnapshotStorage({
- * autoRestore: true })`.
- *
- * The wire envelope stays at {@link SNAPSHOT_WIRE_VERSION}; no new format.
- *
- * @module
- */
-
-import { wallClockNs } from "@graphrefly/pure-ts/core";
-import type { KvStorageTier } from "@graphrefly/pure-ts/extra";
-import type {
-	GraphCheckpointRecord,
-	GraphDiffResult,
-	GraphNodeFactory,
-	GraphPersistSnapshot,
-} from "@graphrefly/pure-ts/graph";
-import { Graph, SNAPSHOT_VERSION } from "@graphrefly/pure-ts/graph";
-import { SurfaceError } from "./errors.js";
-
-/**
- * Current envelope version. Re-exported from `graph.ts` so the one-shot
- * surface path and `Graph.attachSnapshotStorage` write byte-identical
- * `format_version` fields — no silent wire drift.
- */
-export const SNAPSHOT_WIRE_VERSION = SNAPSHOT_VERSION;
-
-/** Shape returned by {@link saveSnapshot}. */
-export interface SaveSnapshotResult {
-	snapshotId: string;
-	timestamp_ns: number;
-}
-
-/** Options for {@link restoreSnapshot}. */
-export interface RestoreSnapshotOptions {
-	/** Passthrough to `Graph.fromSnapshot`. First matching pattern wins. */
-	factories?: Record<string, GraphNodeFactory>;
-}
-
-/**
- * Key prefix applied to every surface-written snapshot record. Isolates
- * surface-saved snapshots from other keys on the same tier (notably
- * `attachSnapshotStorage` baseline/WAL keys written under `graph.name`).
- */
-export const SNAPSHOT_KEY_PREFIX = "snapshot:";
-
-/**
- * Reject caller-supplied ids that start with {@link SNAPSHOT_KEY_PREFIX}.
- *
- * Surface ids are keyed in the caller's external namespace; the `"snapshot:"`
- * prefix is an implementation detail of tier layout. Allowing `"snapshot:foo"`
- * through would produce surprising round-trips — `deleteSnapshot("foo")` and
- * `deleteSnapshot("snapshot:foo")` would both target the same tier key, while
- * `listSnapshots()` decodes to `"foo"` — so we enforce disjointness at the API
- * boundary (pre-1.0, no back-compat).
- */
-function assertExternalId(snapshotId: string): void {
-	if (snapshotId.startsWith(SNAPSHOT_KEY_PREFIX)) {
-		throw new SurfaceError(
-			"snapshot-failed",
-			`snapshot id must not start with "${SNAPSHOT_KEY_PREFIX}" (reserved); got "${snapshotId}"`,
-			{ snapshotId },
-		);
-	}
-}
-
-function encodeKey(snapshotId: string): string {
-	return `${SNAPSHOT_KEY_PREFIX}${snapshotId}`;
-}
-
-function decodeKey(key: string): string | undefined {
-	return key.startsWith(SNAPSHOT_KEY_PREFIX) ? key.slice(SNAPSHOT_KEY_PREFIX.length) : undefined;
-}
-
-function unwrapCheckpoint(raw: unknown, snapshotId: string): GraphPersistSnapshot {
-	if (raw == null || typeof raw !== "object") {
-		throw new SurfaceError("snapshot-not-found", `snapshot "${snapshotId}" not found in tier`, {
-			snapshotId,
-		});
-	}
-	// Accept both wrapped (GraphCheckpointRecord) and bare
-	// (GraphPersistSnapshot) payloads — attachSnapshotStorage writes wrapped, a user
-	// may also hand us a bare one via dictKv for tests.
-	const record = raw as Record<string, unknown>;
-	if ("mode" in record) {
-		if (record.mode === "full" && "snapshot" in record) {
-			return record.snapshot as GraphPersistSnapshot;
-		}
-		if (record.mode === "diff") {
-			throw new SurfaceError(
-				"restore-failed",
-				`snapshot "${snapshotId}" is a diff record (legacy/non-paired tier write); under the Phase 14.6 paired-tier shape snapshot tiers hold only baselines. For WAL replay use Graph.restoreSnapshot({ mode: "diff", source: { tier, walTier } }).`,
-				{ snapshotId, mode: "diff" },
-			);
-		}
-		throw new SurfaceError(
-			"restore-failed",
-			`snapshot "${snapshotId}" has unknown mode "${String(record.mode)}"`,
-			{ snapshotId, mode: String(record.mode) },
-		);
-	}
-	if ("nodes" in record && "edges" in record && "subgraphs" in record && "name" in record) {
-		return record as unknown as GraphPersistSnapshot;
-	}
-	throw new SurfaceError(
-		"restore-failed",
-		`snapshot "${snapshotId}" payload is not a GraphCheckpointRecord or GraphPersistSnapshot`,
-		{ snapshotId },
-	);
-}
-
-/**
- * Write a graph's current state as a one-shot `mode: "full"` record.
- *
- * Uses the same {@link GraphCheckpointRecord} envelope as
- * {@link Graph.attachSnapshotStorage} so the two persistence paths interoperate.
- *
- * @throws {SurfaceError} `snapshot-failed` when the tier's `save` throws.
- */
-export async function saveSnapshot(
-	graph: Graph,
-	snapshotId: string,
-	tier: KvStorageTier,
-): Promise<SaveSnapshotResult> {
-	assertExternalId(snapshotId);
-	let snapshot: GraphPersistSnapshot;
-	try {
-		snapshot = graph.snapshot();
-	} catch (err) {
-		const message = err instanceof Error ? err.message : String(err);
-		throw new SurfaceError(
-			"snapshot-failed",
-			`snapshot "${snapshotId}" serialization failed: ${message}`,
-			{ snapshotId },
-		);
-	}
-	const record: GraphCheckpointRecord = {
-		name: graph.name,
-		mode: "full",
-		seq: 0,
-		timestamp_ns: wallClockNs(),
-		format_version: SNAPSHOT_WIRE_VERSION,
-		snapshot,
-	};
-	try {
-		await tier.save(encodeKey(snapshotId), record);
-	} catch (err) {
-		const message = err instanceof Error ? err.message : String(err);
-		throw new SurfaceError("snapshot-failed", `snapshot "${snapshotId}" save failed: ${message}`, {
-			snapshotId,
-		});
-	}
-	return { snapshotId, timestamp_ns: record.timestamp_ns };
-}
-
-/**
- * Load a snapshot from a tier and materialize it as a new {@link Graph}.
- *
- * Uses {@link Graph.fromSnapshot} to reconstruct topology; pass
- * `factories` when the graph includes non-state nodes that the default
- * hydrator can't rebuild on its own.
- *
- * **Requires a `mode: "full"` record.** Surface-written snapshots from
- * {@link saveSnapshot} always qualify. Records written by
- * {@link Graph.attachSnapshotStorage} with `compactEvery > 1` may be
- * `mode: "diff"` between compacts — those throw `restore-failed` until
- * the tier's next compact flush (or until Phase 8.7 WAL replay lands).
- * If you need interop during development, either call
- * {@link saveSnapshot} explicitly (always full) or configure
- * `attachSnapshotStorage({compactEvery: 1})`.
- *
- * @throws {SurfaceError} `snapshot-not-found` on miss; `restore-failed`
- *   when the payload shape doesn't match, when the record is
- *   `mode: "diff"`, or when `Graph.fromSnapshot` rejects.
- */
-export async function restoreSnapshot(
-	snapshotId: string,
-	tier: KvStorageTier,
-	opts?: RestoreSnapshotOptions,
-): Promise<Graph> {
-	assertExternalId(snapshotId);
-	// Try namespaced key first (surface-written records), fall back to raw key
-	// so callers restoring snapshots that predate the namespacing change (or
-	// bare `GraphPersistSnapshot` payloads written by user test fixtures)
-	// still resolve. Once all writers are on encodeKey, the fallback can go.
-	const key = encodeKey(snapshotId);
-	let raw = await tier.load(key);
-	if (raw === undefined) {
-		raw = await tier.load(snapshotId);
-	}
-	const snapshot = unwrapCheckpoint(raw, snapshotId);
-	try {
-		return Graph.fromSnapshot(
-			snapshot,
-			opts?.factories ? { factories: opts.factories } : undefined,
-		);
-	} catch (err) {
-		const message = err instanceof Error ? err.message : String(err);
-		throw new SurfaceError(
-			"restore-failed",
-			`snapshot "${snapshotId}" restore failed: ${message}`,
-			{
-				snapshotId,
-			},
-		);
-	}
-}
-
-/**
- * Load two snapshots and compute a {@link GraphDiffResult} via static
- * {@link Graph.diff}. Returns the audit shape (structural + value diff,
- * no payload); use {@link diffForWAL} directly for WAL-oriented diffs.
- *
- * @throws {SurfaceError} `snapshot-not-found` on either miss.
- */
-export async function diffSnapshots(
-	snapshotIdA: string,
-	snapshotIdB: string,
-	tier: KvStorageTier,
-): Promise<GraphDiffResult> {
-	assertExternalId(snapshotIdA);
-	assertExternalId(snapshotIdB);
-	const loadWithFallback = async (id: string): Promise<unknown> => {
-		const key = encodeKey(id);
-		let raw = await tier.load(key);
-		if (raw === undefined) raw = await tier.load(id);
-		return raw;
-	};
-	const [rawA, rawB] = await Promise.all([
-		loadWithFallback(snapshotIdA),
-		loadWithFallback(snapshotIdB),
-	]);
-	const snapshotA = unwrapCheckpoint(rawA, snapshotIdA);
-	const snapshotB = unwrapCheckpoint(rawB, snapshotIdB);
-	return Graph.diff(snapshotA, snapshotB);
-}
-
-/**
- * Enumerate snapshot ids on a tier.
- *
- * Only keys written by {@link saveSnapshot} are returned. Surface-written
- * records are stored under the `"snapshot:"` key prefix and decoded back to
- * the caller-visible id before being returned — other keys on the same tier
- * (notably `attachSnapshotStorage` baseline/WAL keys written under `graph.name`) are
- * filtered out automatically. This lets a single tier back both the surface
- * and `attachSnapshotStorage` without leaking graph names through `listSnapshots`.
- *
- * @param tier — the storage tier to enumerate.
- * @param opts.includeUnprefixed — when `true`, also return keys that are
- *   NOT under the namespacing prefix. Off by default; set this when reading
- *   pre-namespacing snapshot sets.
- *
- *   **Caveat:** when a tier is shared with {@link Graph.attachSnapshotStorage}, its
- *   auto-checkpoint baseline + WAL keys (written under `graph.name`) are
- *   unprefixed. Calling with `includeUnprefixed: true` returns those keys
- *   alongside surface snapshots — and subsequent `restoreSnapshot` /
- *   `deleteSnapshot` will operate on them via the fallback-lookup path,
- *   potentially overwriting or deleting live auto-checkpoint state. Use
- *   `includeUnprefixed` only against tiers you know are NOT shared with
- *   `attachSnapshotStorage`, or follow up with a predicate filter to separate
- *   ids you own from ones owned by other subsystems.
- *
- * @throws {SurfaceError} `tier-no-list` when the tier does not implement
- *   the optional `list()` method. Check `typeof tier.list === "function"`
- *   before calling if you want to branch on capability.
- */
-export async function listSnapshots(
-	tier: KvStorageTier,
-	opts?: { includeUnprefixed?: boolean },
-): Promise<readonly string[]> {
-	if (typeof tier.list !== "function") {
-		throw new SurfaceError(
-			"tier-no-list",
-			"KvStorageTier does not implement list(); wrap the tier with an enumerator or use a different backend",
-		);
-	}
-	const keys = await tier.list();
-	const result: string[] = [];
-	const includeUnprefixed = opts?.includeUnprefixed === true;
-	for (const k of keys) {
-		const decoded = decodeKey(k);
-		if (decoded !== undefined) result.push(decoded);
-		else if (includeUnprefixed) result.push(k);
-	}
-	return result;
-}
-
-/**
- * Delete a snapshot from a tier.
- *
- * Silent on miss (clear semantics). `tier.clear` is optional — throws
- * `snapshot-failed` when the tier is append-only.
- *
- * @throws {SurfaceError} `snapshot-failed` when `clear` is unsupported
- *   or throws.
- */
-export async function deleteSnapshot(snapshotId: string, tier: KvStorageTier): Promise<void> {
-	assertExternalId(snapshotId);
-	if (typeof tier.delete !== "function") {
-		throw new SurfaceError(
-			"snapshot-failed",
-			`KvStorageTier is append-only (no delete()); cannot delete "${snapshotId}"`,
-			{ snapshotId },
-		);
-	}
-	try {
-		await tier.delete(encodeKey(snapshotId));
-	} catch (err) {
-		const message = err instanceof Error ? err.message : String(err);
-		throw new SurfaceError(
-			"snapshot-failed",
-			`snapshot "${snapshotId}" delete failed: ${message}`,
-			{
-				snapshotId,
-			},
-		);
-	}
-}
diff --git a/src/utils/topology-view/_internal.ts b/src/utils/topology-view/_internal.ts
deleted file mode 100644
index 1c707014..00000000
--- a/src/utils/topology-view/_internal.ts
+++ /dev/null
@@ -1,105 +0,0 @@
-/**
- * Default layout for `topologyView` — wraps the bundled Sugiyama-style layered
- * DAG layout from `extra/render/_layout-sugiyama.ts`.
- *
- * The library ships zero deps and is browser-safe by default; the bundled
- * layout matches that ethos. Users wanting production-quality layout can swap
- * in `dagre`, `elk`, etc. by passing `opts.layout` to {@link topologyView}.
- *
- * Direction-agnostic (defaults to `"LR"`). Per-node label sizing is
- * conservative: 1 cell tall, label-length-derived width capped at 24 cells.
- *
- * @module
- */
-
-import type { GraphDescribeOutput } from "@graphrefly/pure-ts/graph";
-import {
-	type LayoutDirection,
-	type LayoutEdgePoint,
-	sugiyamaLayout,
-} from "../../base/render/_layout-sugiyama.js";
-import type { LayoutFn, LayoutFrame } from "./types.js";
-
-const MIN_W = 3;
-const MAX_W = 24;
-const NODE_H = 1;
-const LAYER_GAP = 4;
-const NODE_GAP = 1;
-
-/**
- * Best-effort label-width estimate (cells). Caller can override by providing
- * its own {@link LayoutFn}; this default treats every visible character as
- * one cell. Local-segment is preferred over qualified path so the label
- * stays compact on cells with deep mounts.
- */
-function widthOf(id: string): number {
-	const local = id.includes("::") ? (id.split("::").pop() ?? id) : id;
-	return Math.max(MIN_W, Math.min(MAX_W, local.length + 2));
-}
-
-function heightOf(_id: string): number {
-	return NODE_H;
-}
-
-/**
- * Default layered-DAG layout for `topologyView`. Pure fn over a describe
- * snapshot; deterministic for a given input ordering.
- */
-export function defaultLayout(
-	spec: GraphDescribeOutput,
-	direction: LayoutDirection = "LR",
-): Pick<LayoutFrame, "boxes" | "edges"> {
-	const ids = Object.keys(spec.nodes).sort();
-	const edges = spec.edges.map((e) => ({ from: e.from, to: e.to }));
-	if (ids.length === 0) {
-		return { boxes: [], edges: [] };
-	}
-	const result = sugiyamaLayout({
-		nodes: ids,
-		edges,
-		widthCells: widthOf,
-		heightCells: heightOf,
-		layerGap: LAYER_GAP,
-		nodeGap: NODE_GAP,
-		direction,
-	});
-
-	// Map back to the public LayoutFrame shape, attaching per-node meta from
-	// the describe snapshot for downstream renderers (kind/factory/domain).
-	const boxes = result.boxes.map((b) => ({
-		id: b.id,
-		x: b.x,
-		y: b.y,
-		w: b.w,
-		h: b.h,
-		meta: spec.nodes[b.id]?.meta,
-	}));
-
-	// Build a quick "to → ordered deps" lookup for `depIndex` attribution. The
-	// describe snapshot's `nodes[id].deps` is the positional dep array; the
-	// edge's depIndex is the position of `from` in `to`'s deps.
-	//
-	// /qa F-22: when the same upstream appears multiple times in `to.deps`
-	// (diamond / duplicate-dep patterns), each (from, to) edge gets a distinct
-	// depIndex via a per-`to` running cursor over occurrences in `toDeps`.
-	const seenPerTo = new Map<string, number>();
-	const edgeOut = result.edges.map((e) => {
-		const toDeps = spec.nodes[e.to]?.deps ?? [];
-		const cursorKey = `${e.to}::${e.from}`;
-		const startFrom = seenPerTo.get(cursorKey) ?? 0;
-		const depIndex = toDeps.indexOf(e.from, startFrom);
-		seenPerTo.set(cursorKey, depIndex >= 0 ? depIndex + 1 : startFrom);
-		const points = e.points.map((p: LayoutEdgePoint) => [p.x, p.y] as const);
-		return {
-			from: e.from,
-			to: e.to,
-			depIndex: depIndex >= 0 ? depIndex : -1,
-			points: points as ReadonlyArray<readonly [number, number]>,
-		};
-	});
-
-	return { boxes, edges: edgeOut };
-}
-
-/** Adapter — narrows `defaultLayout` to the {@link LayoutFn} signature. */
-export const defaultLayoutFn: LayoutFn = (spec) => defaultLayout(spec, "LR");
diff --git a/src/utils/topology-view/index.ts b/src/utils/topology-view/index.ts
deleted file mode 100644
index e2f095b8..00000000
--- a/src/utils/topology-view/index.ts
+++ /dev/null
@@ -1,207 +0,0 @@
-/**
- * `topologyView({ graph, layout? }): TopologyViewGraph` — D3 of the
- * three-layer view (`docs/optimizations.md` line "D — Three-layer view").
- *
- * Composes a target {@link Graph} with a pluggable layered-DAG layout into a
- * live {@link LayoutFrame} stream:
- *
- * ```text
- * target graph
- *   └─ observe({ changeset: true })  →  Node<GraphChange>
- *        └─ filter(topology)         →  recompute layout
- *        └─ each change              →  merge into a LayoutFrame
- * ```
- *
- * **Initial frame** is delivered on subscribe (push-on-subscribe per spec
- * §2.2) — the layout is seeded from `graph.describe()` at construction. A
- * consumer that wants deltas only can `pipe(skip(1))` from the output node.
- *
- * **Pluggable layout** — pass `opts.layout` to swap in `dagre`, `elk`, or
- * any layered-DAG library. The default is a minimal Sugiyama in
- * `_internal.ts` (matches the library's "no deps, browser-safe" ethos).
- *
- * **No timers** — animation is driven by the changeset's batch boundaries.
- * Each batch IS a frame; CSS transitions handle visual fade.
- *
- * @module
- */
-
-import type { Node } from "@graphrefly/pure-ts/core";
-import { Graph, type GraphChange, type GraphOptions } from "@graphrefly/pure-ts/graph";
-import { defaultLayout } from "./_internal.js";
-import type { LayoutFn, LayoutFrame } from "./types.js";
-
-export type {
-	LayoutBox,
-	LayoutEdge,
-	LayoutFn,
-	LayoutFrame,
-} from "./types.js";
-
-/** Topology variants from {@link GraphChange} that invalidate layout. */
-const TOPOLOGY_TYPES = new Set<GraphChange["type"]>([
-	"node-added",
-	"node-removed",
-	"mount",
-	"unmount",
-]);
-
-function isTopologyChange(c: GraphChange): boolean {
-	return TOPOLOGY_TYPES.has(c.type);
-}
-
-/** Options for {@link topologyView}. */
-export interface TopologyViewOptions {
-	/** The target graph to observe. */
-	readonly graph: Graph;
-	/**
-	 * Pluggable layout function. Defaults to the bundled Sugiyama layout.
-	 * Adapt `dagre` / `elk` / etc. by wrapping their output in the
-	 * {@link LayoutFn} shape.
-	 */
-	readonly layout?: LayoutFn;
-	/** Optional name for the {@link TopologyViewGraph}. Defaults to `"topology-view"`. */
-	readonly name?: string;
-	/**
-	 * Forward extra options to the underlying {@link Graph} constructor
-	 * (e.g. `versioning`, `traceCapacity`).
-	 */
-	readonly graphOptions?: GraphOptions;
-}
-
-/**
- * Live topology view — a {@link Graph} subclass that exposes a single
- * output node {@link TopologyViewGraph.frame} emitting {@link LayoutFrame}s.
- */
-export class TopologyViewGraph extends Graph {
-	readonly target: Graph;
-	readonly layout: LayoutFn;
-	readonly frame: Node<LayoutFrame>;
-
-	constructor(opts: TopologyViewOptions) {
-		const name = opts.name ?? "topology-view";
-		super(name, opts.graphOptions);
-		this.target = opts.graph;
-		this.layout = opts.layout ?? ((spec) => defaultLayout(spec, "LR"));
-
-		// 1. Source node — discrete GraphChange events from the target graph.
-		//    Every change (data + topology + batch boundaries) flows here.
-		const changeset = this.target.observe({
-			changeset: true,
-			changesetName: "target-changeset",
-		});
-		this.add(changeset, { name: "changeset" });
-
-		// 2. Layout — recomputes only on topology changes. Reads
-		//    `target.describe()` inside the fn body — this is a method call on
-		//    the stored Graph reference, NOT a `.cache` read of another
-		//    reactive node, so it does not violate spec §5.12. Initial value
-		//    is seeded from the construction-time describe so the first
-		//    push-on-subscribe delivers a valid frame before any change
-		//    arrives. `partial: true` opts out of the first-run gate (§2.7) —
-		//    the seeded `initial` is correct from construction; we don't need
-		//    to wait for the upstream changeset to deliver its first DATA.
-		const seedLayout = this._computeLayout();
-		const layoutNode = this.derived<Pick<LayoutFrame, "boxes" | "edges">>(
-			"layout",
-			["changeset"],
-			(data, _ctx) => {
-				const batch0 = data[0];
-				if (batch0 == null || batch0.length === 0) {
-					// No changeset DATA this wave (or this is the seed activation
-					// before changeset has fired). Settle as RESOLVED — caller
-					// will read `prevData[0]` if it needs the current layout.
-					return [];
-				}
-				let topologyHit = false;
-				for (const c of batch0 as readonly GraphChange[]) {
-					if (isTopologyChange(c)) {
-						topologyHit = true;
-						break;
-					}
-				}
-				if (!topologyHit) {
-					// Data-only wave: keep layout unchanged. The cached layout
-					// (from `initial` or a prior emit) is still valid.
-					return [];
-				}
-				return [this._computeLayout()];
-			},
-			{ initial: seedLayout, partial: true },
-		);
-		void layoutNode;
-
-		// 3. Frame — merges latest layout with the per-wave changes from the
-		//    changeset. Two deps: layout (slow-moving — re-emits only on
-		//    topology) and changeset (fast-moving — re-emits per change event).
-		//    The fn collapses each wave into one LayoutFrame.
-		//
-		//    `partial: true` opts out of the first-run gate so that a
-		//    data-only wave (where the layout dep settles RESOLVED but
-		//    changeset emits DATA) still triggers fn — without it, frame
-		//    would never run for data events because layout settled RESOLVED
-		//    and `_depSettledAsResolved` does NOT exit the sentinel state on
-		//    a dep, leaving the gate closed indefinitely.
-		this.frame = this.derived<LayoutFrame>(
-			"frame",
-			["layout", "changeset"],
-			(data, ctx) => {
-				const layoutBatch = data[0];
-				const changesetBatch = data[1];
-				const layout =
-					layoutBatch != null && layoutBatch.length > 0
-						? (layoutBatch.at(-1) as Pick<LayoutFrame, "boxes" | "edges">)
-						: (ctx.prevData[0] as Pick<LayoutFrame, "boxes" | "edges"> | undefined);
-				if (layout == null) {
-					// No layout yet — defer (skip emit). With `initial:` on
-					// `layout`, this should never happen on the activation
-					// wave, but guard for the edge case.
-					return [];
-				}
-				const changes: GraphChange[] = [];
-				if (changesetBatch != null) {
-					for (const c of changesetBatch) changes.push(c as GraphChange);
-				}
-				return [
-					{
-						boxes: layout.boxes,
-						edges: layout.edges,
-						changes,
-					},
-				];
-			},
-			{
-				initial: { boxes: seedLayout.boxes, edges: seedLayout.edges, changes: [] },
-				partial: true,
-			},
-		);
-
-		// No external keepalive — the chain `frame → layout → changeset` is
-		// activated by external subscribers on `frame`. When the last consumer
-		// unsubscribes, the chain tears down and releases the target observe
-		// handle. Producer-bound lifecycle, no leaks.
-	}
-
-	private _computeLayout(): Pick<LayoutFrame, "boxes" | "edges"> {
-		// /qa F-5: short-circuit if the target was destroyed. `target.describe()`
-		// on a destroyed graph returns empty topology silently — without this
-		// guard, frame consumers would see a degraded layout (empty boxes /
-		// edges) with no signal that the underlying graph is gone. The COMPLETE
-		// propagation is handled by the changeset stream's teardown variant
-		// flowing through `frame`.
-		if (this.target.destroyed) {
-			return { boxes: [], edges: [] };
-		}
-		const spec = this.target.describe();
-		return this.layout(spec);
-	}
-}
-
-/**
- * Factory wrapper — `topologyView({ graph, layout? })`.
- */
-export function topologyView(opts: TopologyViewOptions): TopologyViewGraph {
-	const view = new TopologyViewGraph(opts);
-	view.tagFactory("topologyView");
-	return view;
-}
diff --git a/src/utils/topology-view/types.ts b/src/utils/topology-view/types.ts
deleted file mode 100644
index 94d7cbbb..00000000
--- a/src/utils/topology-view/types.ts
+++ /dev/null
@@ -1,17 +0,0 @@
-/**
- * Public types for `topologyView` (D3 — Three-layer view).
- *
- * /qa F-17 (2026-04-30): the canonical type definitions live in
- * `src/extra/render/layout-types.ts` so the SVG renderer there can consume
- * them without inverting the layering (extra/ → patterns/). This module
- * re-exports them for the pattern's public surface.
- *
- * @module
- */
-
-export type {
-	LayoutBox,
-	LayoutEdge,
-	LayoutFn,
-	LayoutFrame,
-} from "../../base/render/layout-types.js";
diff --git a/tsconfig.json b/tsconfig.json
deleted file mode 100644
index 05b91250..00000000
--- a/tsconfig.json
+++ /dev/null
@@ -1,16 +0,0 @@
-{
-	"compilerOptions": {
-		"target": "ES2022",
-		"module": "ES2022",
-		"moduleResolution": "bundler",
-		"declaration": true,
-		"outDir": "dist",
-		"rootDir": "src",
-		"strict": true,
-		"esModuleInterop": true,
-		"skipLibCheck": true,
-		"forceConsistentCasingInFileNames": true
-	},
-	"include": ["src"],
-	"exclude": ["node_modules", "dist", "**/*.test.ts"]
-}
diff --git a/tsup.config.ts b/tsup.config.ts
deleted file mode 100644
index c4ae09b0..00000000
--- a/tsup.config.ts
+++ /dev/null
@@ -1,418 +0,0 @@
-import { readdir, readFile } from "node:fs/promises";
-import { join } from "node:path";
-import { defineConfig } from "tsup";
-
-/**
- * @graphrefly/graphrefly — presentation layer build (cleave A3, 2026-05-14).
- *
- * Entry structure mirrors the 4-layer model:
- *   substrate → base → utils → presets → solutions (compat sits alongside)
- *
- * Browser-safety: presentation files may import from @graphrefly/pure-ts (external)
- * and from within src/. Node-only subpaths are identified in nodeOnlyEntries.
- * The universal entries must not transitively import node:* — validated by
- * assertBrowserSafeBundles in @graphrefly/pure-ts's tsup config; this config
- * relies on correct layer segregation (node-only behind node/ subpaths).
- *
- * Consumer-driven browser-safety guard (memo:Re RN/Hermes, 2026-05-19):
- * pure-ts's `assertBrowserSafeBundles` only covers the *substrate* package.
- * Presentation entries this repo ships had NO post-build guard. We add a
- * **scoped** mirror of that mechanism here for the entries a Hermes consumer
- * actually pulls (`GUARDED_UNIVERSAL_ENTRIES`) — same bar/precedent as the
- * pure-ts `fromAny`/`fromAsyncIter` audit (assertBrowserSafeBundles clean ⇒
- * Hermes-safe). Scoped (not all-entries) on purpose: a flag-day audit of
- * every presentation entry is out of this slice's scope; add an entry here
- * when a consumer needs it Hermes-safe.
- */
-
-const ENTRY_POINTS = [
-	// Root barrel — substrate re-export + full presentation
-	"src/index.ts",
-	// Base layer
-	"src/base/index.ts",
-	"src/base/composition/index.ts",
-	"src/base/io/index.ts",
-	"src/base/meta/index.ts",
-	"src/base/mutation/index.ts",
-	"src/base/render/index.ts",
-	"src/base/sources/index.ts",
-	"src/base/sources/event/index.ts",
-	"src/base/sources/node/index.ts", // Node-only
-	"src/base/sources/browser/index.ts", // Browser-only
-	"src/base/utils/index.ts",
-	"src/base/worker/index.ts",
-	// Utils layer
-	"src/utils/index.ts",
-	"src/utils/ai/index.ts",
-	"src/utils/cqrs/index.ts",
-	"src/utils/demo-shell/index.ts",
-	"src/utils/domain-templates/index.ts",
-	"src/utils/graphspec/index.ts",
-	"src/utils/harness/index.ts",
-	"src/utils/inspect/index.ts",
-	"src/utils/job-queue/index.ts",
-	"src/utils/memory/index.ts",
-	"src/utils/messaging/index.ts",
-	"src/utils/orchestration/index.ts",
-	"src/utils/process/index.ts",
-	"src/utils/reactive-layout/index.ts",
-	"src/utils/reduction/index.ts",
-	"src/utils/resilience/index.ts",
-	"src/utils/surface/index.ts",
-	"src/utils/topology-view/index.ts",
-	// Presets layer
-	"src/presets/index.ts",
-	"src/presets/ai/index.ts",
-	"src/presets/harness/index.ts",
-	"src/presets/inspect/index.ts",
-	"src/presets/resilience/index.ts",
-	// Solutions layer
-	"src/solutions/index.ts",
-	// Testing — public test utilities (universal)
-	"src/testing/index.ts",
-	// Compat — per-framework adapters
-	"src/compat/index.ts",
-	"src/compat/jotai/index.ts",
-	"src/compat/nanostores/index.ts",
-	"src/compat/nestjs/index.ts",
-	"src/compat/react/index.ts",
-	"src/compat/solid/index.ts",
-	"src/compat/svelte/index.ts",
-	"src/compat/vue/index.ts",
-	"src/compat/zustand/index.ts",
-	// AI platform subpaths (browser + node variants)
-	"src/utils/ai/node.ts",
-	"src/utils/ai/browser.ts",
-];
-
-export default defineConfig({
-	entry: ENTRY_POINTS,
-	format: ["esm", "cjs"],
-	dts: true,
-	clean: true,
-	sourcemap: process.env.NODE_ENV !== "production",
-	minify: process.env.NODE_ENV === "production",
-	platform: "neutral",
-	target: "es2022",
-	external: [
-		"@graphrefly/pure-ts",
-		"@graphrefly/native",
-		"@nestjs/common",
-		"@nestjs/core",
-		"@nestjs/microservices",
-		"@nestjs/platform-express",
-		"@nestjs/websockets",
-		"rxjs",
-		"reflect-metadata",
-		"react",
-		"react-dom",
-		"vue",
-		"solid-js",
-		"svelte",
-	],
-	async onSuccess() {
-		await assertBrowserSafeBundles("dist");
-	},
-});
-
-// ---------------------------------------------------------------------------
-// Scoped browser-safety bundle assertion (mirror of pure-ts's guard)
-// ---------------------------------------------------------------------------
-
-/**
- * Universal presentation entries (relative to `dist/`, no ext) that a
- * Hermes/RN consumer pulls and that MUST stay free of `node:*` builtins.
- *
- * Add an entry here when a consumer needs it Hermes-safe — do NOT switch to
- * "all entries minus an allow-list": many presentation entries were never
- * audited and a flag-day sweep is a separate effort.
- */
-const GUARDED_UNIVERSAL_ENTRIES = [
-	// memo:Re §15 zoom-hierarchy spatial UI (Story 3.6 spike-gate). The
-	// browser `CanvasMeasureAdapter` touches `OffscreenCanvas` only behind a
-	// runtime `typeof OffscreenCanvas` guard; RN consumers plug in
-	// `InjectedMeasureAdapter` instead. The guard below verifies (1) no
-	// `node:*` imports and (2) every DOM global referenced in a reachable
-	// chunk is `typeof`-guarded in its own file — the codebase convention
-	// that keeps such refs Hermes-crash-safe. (2) is a heuristic, not a
-	// proof of DOM-freedom — see the JSDoc on `assertBrowserSafeBundles`.
-	"utils/reactive-layout/index",
-	// fromPushNotification + fromCron — the universal event-source island
-	// (memo:Re premium-backend push transport). Both import only pure-ts/core.
-	"base/sources/event/index",
-];
-
-/**
- * DOM globals absent (or crash-on-touch) under React Native / Hermes. A
- * reference to one of these in a guarded chunk is only Hermes-safe if it is
- * `typeof`-guarded before use (the codebase convention — e.g.
- * `CanvasMeasureAdapter`'s `typeof OffscreenCanvas === "undefined"` bail).
- *
- * Deliberately excludes identifiers that exist on Hermes/Node or are
- * universal (`performance`, `setTimeout`, `fetch`, `globalThis`, `URL`,
- * `TextEncoder`, …) — flagging those would be all false-positives.
- */
-const DOM_GLOBALS = [
-	"document",
-	"window",
-	"navigator",
-	"requestAnimationFrame",
-	"cancelAnimationFrame",
-	"indexedDB",
-	"localStorage",
-	"sessionStorage",
-	"OffscreenCanvas",
-	"Worker",
-	"MessageChannel",
-	"customElements",
-	"HTMLElement",
-	"getComputedStyle",
-	"matchMedia",
-];
-
-// Node's builtin module set — matched both as `node:*` and bare specifiers
-// (esbuild with `platform:"neutral"` may strip the `node:` prefix). Mirrors
-// the pure-ts NODE_BUILTINS list.
-const NODE_BUILTIN_SET = new Set<string>([
-	"assert",
-	"assert/strict",
-	"async_hooks",
-	"buffer",
-	"child_process",
-	"cluster",
-	"console",
-	"constants",
-	"crypto",
-	"dgram",
-	"diagnostics_channel",
-	"dns",
-	"dns/promises",
-	"domain",
-	"events",
-	"fs",
-	"fs/promises",
-	"http",
-	"http2",
-	"https",
-	"inspector",
-	"inspector/promises",
-	"module",
-	"net",
-	"os",
-	"path",
-	"path/posix",
-	"path/win32",
-	"perf_hooks",
-	"process",
-	"punycode",
-	"querystring",
-	"readline",
-	"readline/promises",
-	"repl",
-	"sqlite",
-	"stream",
-	"stream/consumers",
-	"stream/promises",
-	"stream/web",
-	"string_decoder",
-	"sys",
-	"test",
-	"timers",
-	"timers/promises",
-	"tls",
-	"trace_events",
-	"tty",
-	"url",
-	"util",
-	"util/types",
-	"v8",
-	"vm",
-	"wasi",
-	"worker_threads",
-	"zlib",
-]);
-
-/**
- * Post-build regression check over each {@link GUARDED_UNIVERSAL_ENTRIES}
- * entry's dist chunk graph. Two invariants:
- *
- * 1. **No `node:*` builtins** — sound: a transitive `import`/`require` of a
- *    Node builtin (matched as `node:*` OR bare, since esbuild with
- *    `platform:"neutral"` may strip the prefix) fails the build.
- * 2. **DOM globals must be `typeof`-guarded** — *heuristic, not a DOM-freedom
- *    proof*: if a reachable chunk references a {@link DOM_GLOBALS} identifier
- *    (bare read — not a property access) and that file contains **no**
- *    `typeof <id>` anywhere, it fails. This catches the realistic regression
- *    (a new unguarded `document.x` / static DOM dep) while passing the
- *    sanctioned `typeof OffscreenCanvas` bail. It does NOT prove the absence
- *    of DOM (a file could `typeof document` once yet use it unguarded
- *    elsewhere) — Hermes-crash-safety still rests on the runtime guards +
- *    audit; this only mechanically enforces the guard *convention*.
- *
- * The graph walk is also **sound about its own coverage**: an unresolvable
- * relative specifier (a traversal gap that could hide a `node:*`/DOM reach)
- * fails the build loud rather than being silently skipped.
- *
- * Trimmed mirror of pure-ts's `assertBrowserSafeBundles` (no
- * version-token / `restoreNodePrefix` — pure-ts D4 concerns) plus the DOM
- * heuristic + unresolved-spec soundness, which the substrate guard omits.
- */
-async function assertBrowserSafeBundles(dir: string): Promise<void> {
-	type FileInfo = {
-		rel: string;
-		ext: "js" | "cjs" | "mjs";
-		imports: string[];
-		nodeBuiltins: string[];
-		/** DOM globals referenced bare with NO `typeof <id>` guard in-file. */
-		domUnguarded: string[];
-	};
-	const files = new Map<string, FileInfo>();
-	await walkBuild(dir, async (abs) => {
-		const m = abs.match(/\.(js|cjs|mjs)$/);
-		if (!m) return;
-		const ext = m[1] as "js" | "cjs" | "mjs";
-		const rel = abs.slice(dir.length + 1);
-		const src = await readFile(abs, "utf8");
-		const imports = extractImportSpecs(src);
-		// `node:` prefix OR bare builtin (prefix-strip case). No dead ternary.
-		const nodeBuiltins = imports.filter(
-			(p) => p.startsWith("node:") || NODE_BUILTIN_SET.has(p.startsWith("node:") ? p.slice(5) : p),
-		);
-		const domUnguarded: string[] = [];
-		for (const g of DOM_GLOBALS) {
-			// Bare identifier read: not preceded by `.`/word-char, not part of
-			// a longer identifier. Captures `g`, `g(`, `new g`, `g.x`, AND the
-			// `typeof g` occurrence itself (harmless — presence-of-typeof is
-			// exactly the allow signal).
-			const referenced = new RegExp(`(?<![.\\w$])${g}(?![\\w$])`).test(src);
-			if (!referenced) continue;
-			const typeofGuarded = new RegExp(`\\btypeof\\s+${g}\\b`).test(src);
-			if (!typeofGuarded) domUnguarded.push(g);
-		}
-		files.set(rel, { rel, ext, imports, nodeBuiltins, domUnguarded });
-	});
-
-	function resolveSpec(
-		fromRel: string,
-		fromExt: "js" | "cjs" | "mjs",
-		spec: string,
-	): string | null {
-		if (spec.startsWith("node:") || !spec.startsWith(".")) return null;
-		const baseDir = fromRel.includes("/") ? fromRel.slice(0, fromRel.lastIndexOf("/")) : "";
-		const parts = (baseDir ? `${baseDir}/${spec}` : spec).split("/");
-		const stack: string[] = [];
-		for (const p of parts) {
-			if (p === "" || p === ".") continue;
-			if (p === "..") stack.pop();
-			else stack.push(p);
-		}
-		const joined = stack.join("/");
-		const exts = fromExt === "cjs" ? ["cjs"] : ["js", "mjs"];
-		const candidates: string[] = [];
-		if (/\.(js|cjs|mjs)$/.test(joined)) candidates.push(joined);
-		for (const e of exts) candidates.push(`${joined}.${e}`);
-		for (const e of exts) candidates.push(`${joined}/index.${e}`);
-		for (const cand of candidates) if (files.has(cand)) return cand;
-		return null;
-	}
-
-	const offenders: Array<{ entry: string; chain: string[]; reason: string }> = [];
-	// F3: an unresolvable RELATIVE specifier is a traversal gap that could
-	// hide a `node:*`/DOM reach — collect and fail loud (externals and
-	// `node:` specifiers are intentionally not resolved and not tracked).
-	const unresolved: Array<{ entry: string; from: string; spec: string }> = [];
-	for (const noExt of GUARDED_UNIVERSAL_ENTRIES) {
-		// Each guarded entry is emitted as both ESM (.js) and CJS (.cjs).
-		for (const ext of ["js", "cjs"] as const) {
-			const entry = `${noExt}.${ext}`;
-			if (!files.has(entry)) {
-				throw new Error(
-					`Browser-safety guard: guarded entry "${entry}" not found in dist — ` +
-						`GUARDED_UNIVERSAL_ENTRIES is stale (entry renamed/removed?).`,
-				);
-			}
-			const visited = new Set<string>();
-			const queue: Array<{ rel: string; chain: string[] }> = [{ rel: entry, chain: [entry] }];
-			while (queue.length > 0) {
-				const { rel, chain } = queue.shift()!;
-				if (visited.has(rel)) continue;
-				visited.add(rel);
-				const info = files.get(rel);
-				if (!info) continue;
-				if (info.nodeBuiltins.length > 0) {
-					offenders.push({
-						entry,
-						chain,
-						reason: `Node builtin "${info.nodeBuiltins[0]!}"`,
-					});
-					break;
-				}
-				if (info.domUnguarded.length > 0) {
-					offenders.push({
-						entry,
-						chain,
-						reason: `unguarded DOM global "${info.domUnguarded[0]!}" (no \`typeof\` guard in ${rel})`,
-					});
-					break;
-				}
-				for (const spec of info.imports) {
-					const resolved = resolveSpec(rel, info.ext, spec);
-					if (resolved) {
-						if (!visited.has(resolved)) queue.push({ rel: resolved, chain: [...chain, resolved] });
-					} else if (spec.startsWith(".")) {
-						unresolved.push({ entry, from: rel, spec });
-					}
-				}
-			}
-		}
-	}
-
-	if (unresolved.length > 0) {
-		const msg = unresolved
-			.map(({ entry, from, spec }) => `  entry ${entry}: ${from} → unresolved "${spec}"`)
-			.join("\n");
-		throw new Error(
-			`Browser-safety guard: unresolvable relative specifier(s) — the chunk-graph walk is ` +
-				`incomplete, so the node:*/DOM scan cannot be trusted for the affected entry.\n${msg}\n` +
-				"Fix the resolver (or the build output) so every relative import resolves to a dist file.",
-		);
-	}
-
-	if (offenders.length > 0) {
-		const msg = offenders
-			.map(
-				({ entry, chain, reason }) => `  entry ${entry} → ${reason}\n    via ${chain.join(" → ")}`,
-			)
-			.join("\n");
-		throw new Error(
-			`Browser-safety regression: guarded universal entries are not Hermes-safe.\n${msg}\n` +
-				"Fix (node:*): route the node-only dependency through a `<x>/node` subpath, or move the " +
-				"symbol out of the guarded entry. Fix (DOM global): wrap the reference in a runtime " +
-				'`typeof <id> !== "undefined"` guard (the `CanvasMeasureAdapter` convention), or move it ' +
-				"behind a `<x>/browser` subpath.",
-		);
-	}
-}
-
-/** Extract module specifiers from a bundled JS/CJS/MJS source string. */
-function extractImportSpecs(src: string): string[] {
-	const specs: string[] = [];
-	const patterns: RegExp[] = [
-		/\b(?:import|export)\b[\s\S]*?\bfrom\s*["']([^"']+)["']/g,
-		/\bimport\s*["']([^"']+)["']/g,
-		/\b(?:import|require)\s*\(\s*["']([^"']+)["']\s*\)/g,
-	];
-	for (const re of patterns) {
-		for (const mm of src.matchAll(re)) specs.push(mm[1]!);
-	}
-	return specs;
-}
-
-async function walkBuild(dir: string, visit: (absPath: string) => Promise<void>): Promise<void> {
-	const entries = await readdir(dir, { withFileTypes: true });
-	for (const e of entries) {
-		const p = join(dir, e.name);
-		if (e.isDirectory()) await walkBuild(p, visit);
-		else if (e.isFile()) await visit(p);
-	}
-}
diff --git a/vitest.config.ts b/vitest.config.ts
deleted file mode 100644
index 0c8a9bff..00000000
--- a/vitest.config.ts
+++ /dev/null
@@ -1,25 +0,0 @@
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-import { defineConfig } from "vitest/config";
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-
-export default defineConfig({
-	resolve: {
-		alias: [
-			{
-				find: /^@graphrefly\/pure-ts\/(.+)$/,
-				replacement: path.resolve(__dirname, "packages/pure-ts/src/$1"),
-			},
-			{
-				find: "@graphrefly/pure-ts",
-				replacement: path.resolve(__dirname, "packages/pure-ts/src/index.ts"),
-			},
-		],
-	},
-	test: {
-		include: ["src/**/*.test.ts"],
-		exclude: ["**/node_modules/**", "dist/**", "**/*.bench.ts"],
-		environment: "node",
-	},
-});
diff --git a/website/astro.config.mjs b/website/astro.config.mjs
index b506cbe3..94506435 100644
--- a/website/astro.config.mjs
+++ b/website/astro.config.mjs
@@ -89,221 +89,26 @@ export default defineConfig({
 					],
 				},
 				{
-					label: "API — Core",
-						items: [
-							{ label: "node()", link: "/api/node" },
-							{ label: "state()", link: "/api/state" },
-							{ label: "derived()", link: "/api/derived" },
-							{ label: "producer()", link: "/api/producer" },
-							{ label: "effect()", link: "/api/effect" },
-							{ label: "pipe()", link: "/api/pipe" },
-							{ label: "batch()", link: "/api/batch" },
-							{ label: "dynamicNode()", link: "/api/dynamicnode" },
-						],
-					},
-					{
-						label: "Sources",
-						collapsed: true,
-						items: [
-							{ label: "fromTimer()", link: "/api/fromtimer" },
-							{ label: "fromCron()", link: "/api/fromcron" },
-							{ label: "fromEvent()", link: "/api/fromevent" },
-							{ label: "fromWebhook()", link: "/api/fromwebhook" },
-							{ label: "fromPromise()", link: "/api/frompromise" },
-							{ label: "fromIter()", link: "/api/fromiter" },
-							{ label: "fromAsyncIter()", link: "/api/fromasynciter" },
-							{ label: "fromAny()", link: "/api/fromany" },
-							{ label: "of()", link: "/api/of" },
-							{ label: "empty()", link: "/api/empty" },
-							{ label: "never()", link: "/api/never" },
-							{ label: "throwError()", link: "/api/throwerror" },
-							{ label: "forEach()", link: "/api/foreach" },
-							{ label: "toArray()", link: "/api/toarray" },
-							{ label: "firstValueFrom()", link: "/api/firstvaluefrom" },
-							{ label: "cached()", link: "/api/cached" },
-							{ label: "replay()", link: "/api/replay" },
-							{ label: "shareReplay()", link: "/api/sharereplay" },
-							{ label: "share()", link: "/api/share" },
-						],
-					},
-					{
-						label: "Operators",
-						collapsed: true,
-						items: [
-							{ label: "map()", link: "/api/map" },
-							{ label: "filter()", link: "/api/filter" },
-							{ label: "scan()", link: "/api/scan" },
-							{ label: "reduce()", link: "/api/reduce" },
-							{ label: "take()", link: "/api/take" },
-							{ label: "skip()", link: "/api/skip" },
-							{ label: "first()", link: "/api/first" },
-							{ label: "last()", link: "/api/last" },
-							{ label: "find()", link: "/api/find" },
-							{ label: "elementAt()", link: "/api/elementat" },
-							{ label: "takeWhile()", link: "/api/takewhile" },
-							{ label: "takeUntil()", link: "/api/takeuntil" },
-							{ label: "tap()", link: "/api/tap" },
-							{ label: "distinctUntilChanged()", link: "/api/distinctuntilchanged" },
-							{ label: "pairwise()", link: "/api/pairwise" },
-						],
-					},
-					{
-						label: "Combinators",
-						collapsed: true,
-						items: [
-							{ label: "combine()", link: "/api/combine" },
-							{ label: "combineLatest()", link: "/api/combinelatest" },
-							{ label: "withLatestFrom()", link: "/api/withlatestfrom" },
-							{ label: "merge()", link: "/api/merge" },
-							{ label: "zip()", link: "/api/zip" },
-							{ label: "concat()", link: "/api/concat" },
-							{ label: "race()", link: "/api/race" },
-						],
-					},
-					{
-						label: "Async & timers",
-						collapsed: true,
-						items: [
-							{ label: "switchMap()", link: "/api/switchmap" },
-							{ label: "exhaustMap()", link: "/api/exhaustmap" },
-							{ label: "concatMap()", link: "/api/concatmap" },
-							{ label: "mergeMap()", link: "/api/mergemap" },
-							{ label: "flatMap()", link: "/api/flatmap" },
-							{ label: "delay()", link: "/api/delay" },
-							{ label: "debounce()", link: "/api/debounce" },
-							{ label: "debounceTime()", link: "/api/debouncetime" },
-							{ label: "throttle()", link: "/api/throttle" },
-							{ label: "throttleTime()", link: "/api/throttletime" },
-							{ label: "sample()", link: "/api/sample" },
-							{ label: "audit()", link: "/api/audit" },
-							{ label: "timeout()", link: "/api/timeout" },
-							{ label: "buffer()", link: "/api/buffer" },
-							{ label: "bufferCount()", link: "/api/buffercount" },
-							{ label: "bufferTime()", link: "/api/buffertime" },
-							{ label: "window()", link: "/api/window" },
-							{ label: "windowCount()", link: "/api/windowcount" },
-							{ label: "windowTime()", link: "/api/windowtime" },
-							{ label: "interval()", link: "/api/interval" },
-							{ label: "repeat()", link: "/api/repeat" },
-							{ label: "pausable()", link: "/api/pausable" },
-							{ label: "rescue()", link: "/api/rescue" },
-							{ label: "catchError()", link: "/api/catcherror" },
-							{ label: "gate()", link: "/api/gate" },
-						],
-					},
-					{
-						label: "Resilience & checkpoints",
-						collapsed: true,
-						items: [
-							{ label: "constant()", link: "/api/constant" },
-							{ label: "linear()", link: "/api/linear" },
-							{ label: "exponential()", link: "/api/exponential" },
-							{ label: "fibonacci()", link: "/api/fibonacci" },
-							{ label: "resolveBackoffPreset()", link: "/api/resolvebackoffpreset" },
-							{ label: "retry()", link: "/api/retry" },
-							{ label: "circuitBreaker()", link: "/api/circuitbreaker" },
-							{ label: "CircuitOpenError", link: "/api/circuitopenerror" },
-							{ label: "tokenBucket()", link: "/api/tokenbucket" },
-							{ label: "tokenTracker()", link: "/api/tokentracker" },
-							{ label: "rateLimiter()", link: "/api/ratelimiter" },
-							{ label: "withBreaker()", link: "/api/withbreaker" },
-							{ label: "withStatus()", link: "/api/withstatus" },
-							{ label: "memoryStorage()", link: "/api/memorystorage" },
-							{ label: "dictStorage()", link: "/api/dictstorage" },
-							{ label: "fileStorage()", link: "/api/filestorage" },
-							{ label: "sqliteStorage()", link: "/api/sqlitestorage" },
-							{ label: "indexedDbStorage()", link: "/api/indexeddbstorage" },
-							{ label: "fromIDBRequest()", link: "/api/fromidbrequest" },
-							{ label: "fromIDBTransaction()", link: "/api/fromidbtransaction" },
-						],
-					},
-					{
-						label: "Data structures",
-						collapsed: true,
-						items: [
-							{ label: "reactiveMap()", link: "/api/reactivemap" },
-							{ label: "reactiveLog()", link: "/api/reactivelog" },
-							{ label: "reactiveIndex()", link: "/api/reactiveindex" },
-							{ label: "reactiveList()", link: "/api/reactivelist" },
-							{ label: "pubsub()", link: "/api/pubsub" },
-							{ label: "verifiable()", link: "/api/verifiable" },
-							{ label: "distill()", link: "/api/distill" },
-						],
-					},
-					{
-						label: "Backpressure & flow",
-						collapsed: true,
-						items: [
-							{ label: "createWatermarkController()", link: "/api/createwatermarkcontroller" },
-						],
-					},
-					{
-						label: "Observable interop",
-						collapsed: true,
-						items: [
-							{ label: "toObservable()", link: "/api/toobservable" },
-						],
-					},
-					{
-						label: "Internals",
-						collapsed: true,
-						items: [
-							{ label: "isBatching()", link: "/api/isbatching" },
-							{ label: "partitionForBatch()", link: "/api/partitionforbatch" },
-							{ label: "downWithBatch()", link: "/api/downwithbatch" },
-							{ label: "policy()", link: "/api/policy" },
-							{ label: "GuardDenied", link: "/api/guarddenied" },
-							{ label: "accessHintForGuard()", link: "/api/accesshintforguard" },
-							{ label: "reachable()", link: "/api/reachable" },
-							{ label: "parseCron()", link: "/api/parsecron" },
-							{ label: "matchesCron()", link: "/api/matchescron" },
-							{ label: "decorrelatedJitter()", link: "/api/decorrelatedjitter" },
-							{ label: "withMaxAttempts()", link: "/api/withmaxattempts" },
-							{ label: "resolveBackoffPreset()", link: "/api/resolvebackoffpreset" },
-						],
-					},
-					{
-						label: "Layout engine",
-						collapsed: true,
-						items: [
-							{ label: "reactiveLayout()", link: "/api/reactivelayout" },
-							{ label: "reactiveBlockLayout()", link: "/api/reactiveblocklayout" },
-							{ label: "analyzeAndMeasure()", link: "/api/analyzeandmeasure" },
-							{ label: "computeLineBreaks()", link: "/api/computelinebreaks" },
-							{ label: "computeCharPositions()", link: "/api/computecharpositions" },
-						],
-					},
-					{
-						label: "Worker bridge",
-						collapsed: true,
-						items: [
-							{ label: "workerBridge()", link: "/api/workerbridge" },
-							{ label: "workerSelf()", link: "/api/workerself" },
-							{ label: "createTransport()", link: "/api/createtransport" },
-						],
-					},
-					{
-						label: "Graph",
-						collapsed: true,
-						items: [{ label: "Graph", link: "/api/graph" }],
-					},
+					label: "API — Reactive Layout",
+					collapsed: true,
+					items: [
+						{ label: "reactiveLayout()", link: "/api/reactivelayout" },
+						{ label: "reactiveBlockLayout()", link: "/api/reactiveblocklayout" },
+						{ label: "fromRaf()", link: "/api/fromraf" },
+						{ label: "analyzeAndMeasure()", link: "/api/analyzeandmeasure" },
+						{ label: "computeLineBreaks()", link: "/api/computelinebreaks" },
+						{ label: "computeCharPositions()", link: "/api/computecharpositions" },
+					],
+				},
 				{
 					label: "Comparisons",
 					items: [
-						{ label: "vs Zustand", link: "/comparisons/zustand" },
-						{ label: "vs Jotai", link: "/comparisons/jotai" },
-						{ label: "vs Pretext", link: "/comparisons/pretext" },
-						{ label: "vs RxJS", link: "/comparisons/rxjs" },
-						{ label: "vs LangGraph.js", link: "/comparisons/langgraph" },
-						{ label: "vs Vercel AI SDK", link: "/comparisons/vercel-ai-sdk" },
-						{ label: "vs n8n", link: "/comparisons/n8n" },
-						{ label: "vs Apache Airflow", link: "/comparisons/airflow" },
+						{ label: "Reactive Layout vs Pretext", link: "/comparisons/pretext" },
 					],
 				},
 				{
 					label: "Recipes",
 					items: [
-						{ label: "From callbag-recharge", link: "/recipes/from-callbag-recharge" },
 						{ label: "NestJS Integration", link: "/recipes/nestjs-integration" },
 					],
 				},
@@ -313,17 +118,14 @@ export default defineConfig({
 						{ label: "Overview", link: "/integrations" },
 						{ label: "Integration Matrix", link: "/integrations/matrix" },
 						{ label: "Adapters", link: "/integrations/adapters" },
-						{ label: "Compat", link: "/integrations/compat" },
 					],
 				},
 				{
 					label: "Demos",
 					items: [
 						{ label: "Overview", link: "/demos" },
-						{ label: "Compat matrix", link: "/demos/compat-matrix/" },
 						{ label: "Reactive layout", link: "/demos/reactive-layout/" },
-						{ label: "Knowledge graph", link: "/demos/knowledge-graph/" },
-						{ label: "PagerDuty triage", link: "/demos/pagerduty-triage/" },
+						{ label: "Spending alerts", link: "/demos/spending-alerts/" },
 					],
 				},
 			],
diff --git a/website/package.json b/website/package.json
index 4c0680bf..c49a6e93 100644
--- a/website/package.json
+++ b/website/package.json
@@ -5,10 +5,8 @@
 	"scripts": {
 		"sync-docs": "node scripts/sync-docs.mjs",
 		"sync-docs:check": "node scripts/sync-docs.mjs --check",
-		"docs:gen": "node scripts/gen-api-docs.mjs",
-		"docs:gen:check": "node scripts/gen-api-docs.mjs --check",
-		"predev": "pnpm sync-docs && pnpm docs:gen",
-		"prebuild": "pnpm sync-docs && pnpm docs:gen",
+		"predev": "pnpm sync-docs",
+		"prebuild": "pnpm sync-docs",
 		"dev": "astro dev",
 		"start": "astro dev",
 		"build": "astro build",
diff --git a/website/public/llms.txt b/website/public/llms.txt
index e56026bd..3f00fa56 100644
--- a/website/public/llms.txt
+++ b/website/public/llms.txt
@@ -1,161 +1,53 @@
-# GraphReFly — TypeScript packages (`@graphrefly/graphrefly`, `@graphrefly/pure-ts`, `@graphrefly/native`)
+# GraphReFly — TypeScript clean-slate implementation
 
-The reactive harness layer for agent workflows. Reactive graph runtime for human + LLM co-operation — causal tracing, persistent checkpoints, policy enforcement, zero dependencies.
+GraphReFly is a reactive universal reduction layer: high fan-in/out data becomes explicit graph facts, reductions, effects, and inspectable topology. This repo is the TypeScript implementation, published as `@graphrefly/ts`.
 
-Keywords: harness engineering, agent harness, reactive graph, causal trace, explain, agent orchestration, LLM co-operation, human-in-the-loop, reactive middleware, universal reduction layer.
+## Current Package Truth
 
-This file is an AI-oriented index for the TypeScript repos. It intentionally points to generated API docs and source-of-truth docs instead of duplicating a long API list that can drift.
+- `@graphrefly/ts` is the only active TypeScript implementation.
+- `@graphrefly/graphrefly` is a retired root package identity only.
+- `@graphrefly/pure-ts` is a frozen read-only reference for old behavior and edge cases until B66 deletion.
+- `archive/packages/parity-tests` preserves the old structural `Impl` parity harness for history only.
+- Cross-runtime parity is behavioral conformance in `~/src/graphrefly/spec/conformance.jsonl`, not symbol-set matching.
 
-## Canonical behavior and docs authority
+## Authority
 
-- Behavior spec: `~/src/graphrefly/GRAPHREFLY-SPEC.md`
-- Composition guidance: `~/src/graphrefly/COMPOSITION-GUIDE.md`
-- Docs conventions: `docs/docs-guidance.md`
-- Active sequencer + decision log: `docs/implementation-plan.md`, `docs/rust-port-decisions.md`
-- Cross-track-ledger (TS ↔ native couplings): `docs/cross-track-ledger.md`
-- Roadmap / vision frame: `docs/roadmap.md`
-- Testing standard: `docs/test-guidance.md`
+The language-neutral authority lives in `~/src/graphrefly`:
 
-## Active strategy docs (read for current direction)
+- Decisions: `decisions/decisions.jsonl`
+- Protocol rules: `spec/rules.jsonl`
+- Conformance scenarios: `spec/conformance.jsonl`
+- Formal model: `formal/*.tla`
+- Sequencer/backlog: `plan/*.jsonl`
+- Dashboard check: `node ~/src/graphrefly/dashboard/build.mjs --check`
 
-- `archive/docs/SESSION-DS-14.5-A-narrative-reframe.md` — spec-as-projection reframe, multi-agent subgraph ownership protocol (L0–L3), catalog reframed as user-host concern. Wave 2 narrative source-of-truth.
-- `archive/docs/SESSION-DS-14-changesets-design.md` — universal `BaseChange<T>` envelope, `mutations` companion bundles, `mutate(act, opts)` factory.
-- `archive/docs/SESSION-reactive-collaboration-harness.md` — 7-stage reactive collaboration loop (INTAKE→TRIAGE→QUEUE→GATE→EXECUTE→VERIFY→REFLECT), `harnessLoop()` factory.
-- `archive/docs/SESSION-marketing-promotion-strategy.md` — positioning pillars, wave plan, reply-marketing playbooks, competitive intel.
+When this repo and the authority repo disagree, the authority repo wins.
 
-## Primary links
+## Useful Entry Points
 
-- Site: https://graphrefly.dev
-- API reference: https://graphrefly.dev/api/node/
-- Python docs: https://graphrefly.dev/py/api/
+- Package source: `packages/ts/src`
+- Core protocol/substrate: `@graphrefly/ts/core`
+- Graph layer and inspection: `@graphrefly/ts/graph`
+- Operators: `@graphrefly/ts/operators`
+- Sources: `@graphrefly/ts/sources`, `@graphrefly/ts/sources/browser`, `@graphrefly/ts/sources/node`
+- Storage: `@graphrefly/ts/storage`, `@graphrefly/ts/storage/browser`, `@graphrefly/ts/storage/node`
+- Render helpers: `@graphrefly/ts/render`
+- Reactive layout solution: `@graphrefly/ts/solutions/reactive-layout`
 
-## Three-package install-time model (Unit 6 D198, locked 2026-05-14)
+## Commands
 
-Consumers pick a substrate provider at **install time**. Both substrate packages expose the same public API — enforced cross-arm by `packages/parity-tests/`.
+```bash
+pnpm --filter @graphrefly/ts test
+pnpm --filter @graphrefly/ts build
+pnpm run lint
+pnpm run dashboard:check
+```
 
-| Package | What it is | Build artifact | Role |
-|---|---|---|---|
-| `@graphrefly/graphrefly` | Presentation layer: IO adapters, AI patterns, composition helpers, framework adapters, render helpers. Re-exports the chosen substrate's surface for ergonomic single-import UX. | TS only (browser + Node) | presentation |
-| `@graphrefly/pure-ts` | Pure-TypeScript substrate: `node` primitive, `Graph`, operators, sources, data structures, storage tiers. Default sync substrate; universal browser + Node. | TS only | substrate |
-| `@graphrefly/native` | Rust substrate via napi-rs. Async-only public surface (Node-only). | `.node` binary + TS wrapper | substrate (async) |
+## Clean-Slate Floor
 
-`@graphrefly/pure-ts` is the **sole working sync substrate** for `@graphrefly/graphrefly` today (D206). `@graphrefly/native` is a real shipping substrate + parity arm but NOT a sync drop-in via overrides — the async-everywhere presentation rebase (D080) stays deferred until consumer pressure. A future `@graphrefly/wasm` is deferred per D196 until a browser-Rust consumer surfaces.
-
-## Package entry points
-
-- Presentation root: `@graphrefly/graphrefly`
-- Substrate roots: `@graphrefly/pure-ts`, `@graphrefly/native`
-
-### `@graphrefly/graphrefly` subpaths (presentation)
-
-The presentation package follows a 4-layer model (D200, 2026-05-14): `base/` (domain-agnostic infrastructure) → `utils/` (domain building blocks) → `presets/` (opinionated compositions) → `solutions/` (user-facing products). All re-exported at the root barrel.
-
-- `@graphrefly/graphrefly` — root barrel; re-exports substrate (`@graphrefly/pure-ts`) + all four layers + `compat/*`.
-- `@graphrefly/graphrefly/base`, `base/io`, `base/composition`, `base/meta`, `base/mutation`, `base/render`, `base/sources`, `base/sources/event`, `base/sources/node`, `base/sources/browser`, `base/utils`, `base/worker` — base-layer subpaths.
-- `@graphrefly/graphrefly/utils`, `utils/ai`, `utils/ai/node`, `utils/ai/browser`, `utils/cqrs`, `utils/demo-shell`, `utils/domain-templates`, `utils/graphspec`, `utils/harness`, `utils/inspect`, `utils/job-queue`, `utils/memory`, `utils/messaging`, `utils/orchestration`, `utils/process`, `utils/reactive-layout`, `utils/reduction`, `utils/resilience`.
-- `@graphrefly/graphrefly/presets`, `presets/ai`, `presets/harness`, `presets/inspect`, `presets/memory`, `presets/resilience`.
-- `@graphrefly/graphrefly/solutions` — vertical packages (deferred until consumer pressure; barrel present, vertical folders not shipped).
-- `@graphrefly/graphrefly/compat/{react,vue,svelte,solid,nestjs,jotai,zustand,nanostores,signals}` — framework adapters.
-- `@graphrefly/graphrefly/extra/node` + `extra/browser` — runtime-specific re-exports of the substrate's Node-only / browser-only surface.
-
-### `@graphrefly/pure-ts` subpaths (substrate)
-
-- `@graphrefly/pure-ts` — universal default (browser + Node safe).
-- `@graphrefly/pure-ts/core` — `node` primitive, `batch`, `Actor`, `policy`, central clock.
-- `@graphrefly/pure-ts/graph` — `Graph` container, `describe`/`observe`/`snapshot`/`mount`.
-- `@graphrefly/pure-ts/extra` — operators, sync sources, data structures, universal storage.
-- `@graphrefly/pure-ts/extra/operators`, `extra/sources`, `extra/storage`, `extra/storage/wal`.
-- `@graphrefly/pure-ts/extra/node`, `extra/storage/node` — Node-only (may import `node:*`).
-- `@graphrefly/pure-ts/extra/browser`, `extra/storage/browser` — browser-only (may use DOM globals).
-- `@graphrefly/pure-ts/testing` — test helpers for parity / regression suites.
-
-## Public API by layer (presentation 4-layer model, D200)
-
-Full export lists live in the generated API pages under `website/src/content/docs/api/`. The descriptions below explain *what lives in each layer and why* so an LLM reading this cold can navigate without consuming the drift-prone catalog. The CI-enforced layer boundary is in `scripts/check-layer-boundary.ts` (D201).
-
-### Substrate (re-exported from `@graphrefly/pure-ts` at the root barrel)
-
-The minimal reactive substrate. One primitive (`node`) plus a `Graph` container that exposes the **sugar as methods** (`g.state(name, …)`, `g.derived(name, deps, fn)`, `g.effect(deps, fn)`, `g.producer(name, factory)`); freestanding `pipe`, `dynamicNode`, `autoTrackNode` are available for off-`Graph` composition. Protocol internals: message types (`DATA`, `DIRTY`, `RESOLVED`, `COMPLETE`, `ERROR`, `TEARDOWN`, `INVALIDATE`, `PAUSE`, `RESUME`), two-phase batch semantics (`batch`, `isBatching`, `partitionForBatch`), guard/policy (`policy`, `GuardDenied`, `accessHintForGuard`), actor identity (`Actor`), the central clock (`monotonicNs`, `wallClockNs`). **Anything outside the substrate must not call `Date.now()` / `performance.now()` directly — use `core/clock.ts`.** Spec §5.8–5.12 invariants are enforced here.
-
-The `Graph` container exposes `describe` / `observe` / `snapshot` / `restoreSnapshot` / `mount` / `attachSnapshotStorage` / `teardown`. Causal walkback is `g.describe({ explain: { from, to } })` (there is no `graph.explain()` method). Diagram rendering is a pure renderer over a describe snapshot: `graphSpecToMermaid(g.describe())`, `graphSpecToPretty`, `graphSpecToD2` — exported from `@graphrefly/graphrefly/base/render`. `reachable(graph, startPath)` computes the dependency closure.
-
-### `base/` — domain-agnostic infrastructure
-
-- `base/io` — fromHttp, fromWebSocket, fromSSE, fromWebhook, fromKafka, fromNats, fromPulsar, fromRabbitMQ, drizzle, prisma, kysely, clickhouse, otel, prometheus, statsd, syslog, csv, ndjson.
-- `base/composition` — verifiable, distill, pubsub, backpressure (`createWatermarkController`), externalProducer, materialize, externalRegister.
-- `base/mutation` — `mutate(act, opts)` factory + lightMutation, auditLog helpers.
-- `base/render` — `graphSpecToMermaid`, `graphSpecToD2`, `graphSpecToPretty`, mermaid URL helpers.
-- `base/sources/event` — fromCron, dom event sources.
-- `base/sources/node` — fromGitHook, fromFSWatch, server-side event sources (Node-only).
-- `base/sources/browser` — DOM-using browser sources.
-- `base/meta` — domainMeta, keepalive helpers.
-- `base/worker` — worker bridge.
-
-### `utils/` — domain building blocks
-
-- `utils/messaging` — `topic`, `subscription` (cursor / `pull` / `ack`), `topicBridge`, `messagingHub` (Pulsar-inspired lazy topic registry).
-- `utils/orchestration` — `pipelineGraph` (with `approvalGate` method — the human-approval gate; this replaced the older `gate(...)` name), `humanInput`, `tracker`, `classify`, `catch`.
-- `utils/memory` — `reactiveFactStore<T>()` (DS-14.7 v1 substrate; cascade + temporal + dependentsIndex), `simpleFactStore` (deferred to v1.1), `persistentFactStore`.
-- `utils/ai` — `chatStream`, `toolRegistry`, `systemPromptBuilder`, `llmExtractor`, `llmConsolidator`, `fromLLM`, `streamingPromptNode`, `streamExtractor`, `knobsAsTools`, `gaugesAsContext`. AI provider adapters under `utils/ai/adapters/` (Anthropic, OpenAI, Google, etc.); Node-only and browser-only variants split via `utils/ai/node` and `utils/ai/browser`.
-- `utils/resilience` — `circuitBreaker`, `withBreaker`, `withStatus`, `rateLimiter`, `withMaxAttempts`, fallback, budgetGate.
-- `utils/cqrs` — `cqrs(name, opts?)` Graph (commands / events / projections / sagas).
-- `utils/harness` — stage type primitives, evalSource, beforeAfterCompare, actuatorExecutor, evalIntakeBridge, HarnessExecutor, HarnessVerifier.
-- `utils/inspect` — `graphLens`, `audit`, `policyGate`, structured introspection.
-- `utils/job-queue` — `jobQueue`, `jobFlow`.
-- `utils/graphspec` — spec compile/decompile + `validateOwnership(spec, prDiff)` (multi-agent claim linter).
-- `utils/reactive-layout` — `reactiveLayout`, `reactiveBlockLayout`, Knuth-Plass-style line breaking as a state→derived graph (Pretext-inspired).
-- `utils/reduction` — universal reduction primitives for massive-info → actionable-items pipelines.
-
-### `presets/` — opinionated compositions
-
-- `presets/ai` — `agentLoop` (ReAct inner loop), `agentMemory` (distill + vectors + KG + tiers with OpenViking decay).
-- `presets/harness` — `harnessLoop` (INTAKE → TRIAGE → QUEUE → GATE → EXECUTE → VERIFY → REFLECT), `refineLoop`, `harnessProfile`, `ownershipController` (L0 static / L1 TTL / L2 heartbeat / L3 supervisor staircase).
-- `presets/resilience` — `resilientPipeline` (rateLimiter → breaker → retry → timeout → fallback in the correct order).
-- `presets/inspect` — `guardedExecution` (Actor / Guard ABAC + policy + budgetGate + scoped describe).
-- `presets/memory` — composed memory products on top of `reactiveFactStore`.
-
-### `solutions/` — user-facing products
-
-Barrel re-exports preset combinations. Vertical folders (`solutions/customer-support-bot/`, `solutions/code-review-agent/`, etc.) are deferred until consumer pressure (D202).
-
-### `compat/*` — framework adapters
-
-React (`useNode`), Vue (`useNode → Ref`), Svelte (`toStore`), Solid (`useNode → Signal`), NestJS (`GraphReflyModule.forRoot()`), plus interop shims for Jotai, Zustand, Nanostores, TC39 Signals proposal. Each compat layer lives in its own subpath so unused adapters tree-shake out.
-
-## Design docs that back the above
-
-- Phase 4+ factory authors must read `~/src/graphrefly/COMPOSITION-GUIDE.md` before composing primitives — covers lazy activation, subscription ordering, null guards, feedback cycles, `promptNode` SENTINEL, wiring order.
-- Backlog / anti-patterns / deferred follow-ups: `docs/optimizations.md`.
-- Historical design decisions and parity notes: `archive/optimizations/`.
-- Cross-track coupling between TS and native: `docs/cross-track-ledger.md` (the single place to log `Impl`-widening changes; see also `~/src/graphrefly-rs/docs/migration-status.md`).
-
-## Generated docs workflow
-
-TypeScript API pages are generated from JSDoc:
-
-- Generator: `website/scripts/gen-api-docs.mjs`
-- Output: `website/src/content/docs/api/*.md`
-- Commands:
-  - `pnpm --dir website docs:gen`
-  - `pnpm --dir website docs:gen:check`
-  - `pnpm --dir website sync-docs`
-  - `pnpm --dir website sync-docs:check`
-
-Do not hand-edit generated API pages or `website/public/llms.txt` (mirror of root `llms.txt`).
-
-## Core design invariants
-
-- No polling; propagation is reactive.
-- No imperative triggers outside graph/message flow.
-- No raw async primitives inside reactive layer logic.
-- Use central clock (`monotonicNs` / `wallClockNs`) and `messageTier` helpers for timing/tier semantics.
-- Keep Phase 4+ surfaces developer-oriented (hide protocol internals from primary API docs).
-- Substrate vs presentation classification follows the layering predicate in `~/src/graphrefly-rs/CLAUDE.md` § "Layering predicate — substrate vs presentation".
-
-## Harness engineering coverage
-
-GraphReFly covers the 8 requirements of a production agent harness — context/state control, execution boundary, control flow, verification, observability, policy/safety, human governance, continuous improvement. Mapping lives in `README.md` and `archive/docs/SESSION-harness-engineering-strategy.md` (with Wave 2 framing reframed by `archive/docs/SESSION-DS-14.5-A-narrative-reframe.md`).
-
-## Reactive collaboration loop (§9.0)
-
-`harnessLoop()` wires a static topology: INTAKE → TRIAGE → QUEUE → GATE → EXECUTE → VERIFY → REFLECT. Static topology + flowing data (the Kafka insight). Humans steer via `approvalGate.modify((value, index, pending) => T, n?)`. Strategy model (`rootCause × intervention → successRate`) feeds TRIAGE routing. Design source: `archive/docs/SESSION-reactive-collaboration-harness.md`.
+- Eight verbs only: `node`, `graph`, `batch`, `state`, `producer`, `derived`, `effect`, `mount`.
+- All user functions go through the dispatcher.
+- The wave protocol implementation is synchronous; async belongs at source, pool, storage, or wire-bridge boundaries.
+- DATA moves through messages, not hidden cache peeks inside reactive functions.
+- Operators are node sugar and per-language; they are not parity verbs.
+- No restoration of old `compat/*`, `utils/*`, `presets/*`, `base/*`, `GraphSpec`, `factoryTag`, `Actor`, `guard`, old structural `Impl` parity, fake topology streams, or storage-owned hydration/restore.
diff --git a/website/scripts/gen-api-docs.mjs b/website/scripts/gen-api-docs.mjs
deleted file mode 100644
index 28779809..00000000
--- a/website/scripts/gen-api-docs.mjs
+++ /dev/null
@@ -1,948 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Generate API docs from TypeScript source JSDoc.
- *
- * Usage:
- *   node scripts/gen-api-docs.mjs                    # all registered entries
- *   node scripts/gen-api-docs.mjs node map            # specific functions
- *   node scripts/gen-api-docs.mjs --check             # dry-run, exit 1 if stale
- *
- * Reads structured JSDoc from source, outputs website/src/content/docs/api/<name>.md.
- *
- * Ported from callbag-recharge/scripts/gen-api-docs.mjs, adapted for:
- *   - GraphReFly source layout (packages/pure-ts/src/core, packages/pure-ts/src/extra, packages/pure-ts/src/graph)
- *   - Starlight frontmatter (title, description)
- *   - Starlight-safe HTML entity escaping (no Vue/VitePress)
- */
-
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { dirname, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
-import ts from "typescript";
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const ROOT = resolve(__dirname, "..", ".."); // graphrefly-ts root
-const OUT_DIR = resolve(__dirname, "..", "src", "content", "docs", "api");
-
-// ─── Registry: map function names to source files ───────────────────────────
-
-const REGISTRY = {
-	// Core — node primitive + sugar constructors
-	node: "packages/pure-ts/src/core/node.ts",
-	pipe: "packages/pure-ts/src/core/sugar.ts",
-
-	// Extra — timer
-	ResettableTimer: "packages/pure-ts/src/core/_internal/timer.ts",
-
-	// Core — batch
-	batch: "packages/pure-ts/src/core/batch.ts",
-	isBatching: "packages/pure-ts/src/core/batch.ts",
-	downWithBatch: "packages/pure-ts/src/core/batch.ts",
-
-	// Core — guard
-	policy: "packages/pure-ts/src/core/guard.ts",
-	GuardDenied: "packages/pure-ts/src/core/guard.ts",
-	accessHintForGuard: "packages/pure-ts/src/core/guard.ts",
-
-	// Extra — operators
-	map: "packages/pure-ts/src/extra/operators/transform.ts",
-	filter: "packages/pure-ts/src/extra/operators/transform.ts",
-	scan: "packages/pure-ts/src/extra/operators/transform.ts",
-	reduce: "packages/pure-ts/src/extra/operators/transform.ts",
-	take: "packages/pure-ts/src/extra/operators/take.ts",
-	skip: "packages/pure-ts/src/extra/operators/take.ts",
-	takeWhile: "packages/pure-ts/src/extra/operators/take.ts",
-	takeUntil: "packages/pure-ts/src/extra/operators/take.ts",
-	first: "packages/pure-ts/src/extra/operators/take.ts",
-	last: "packages/pure-ts/src/extra/operators/take.ts",
-	find: "packages/pure-ts/src/extra/operators/take.ts",
-	elementAt: "packages/pure-ts/src/extra/operators/take.ts",
-	tap: "packages/pure-ts/src/extra/operators/control.ts",
-	distinctUntilChanged: "packages/pure-ts/src/extra/operators/transform.ts",
-	pairwise: "packages/pure-ts/src/extra/operators/transform.ts",
-	combine: "packages/pure-ts/src/extra/operators/combine.ts",
-	withLatestFrom: "packages/pure-ts/src/extra/operators/combine.ts",
-	merge: "packages/pure-ts/src/extra/operators/combine.ts",
-	zip: "packages/pure-ts/src/extra/operators/combine.ts",
-	concat: "packages/pure-ts/src/extra/operators/combine.ts",
-	race: "packages/pure-ts/src/extra/operators/combine.ts",
-	switchMap: "packages/pure-ts/src/extra/operators/higher-order.ts",
-	exhaustMap: "packages/pure-ts/src/extra/operators/higher-order.ts",
-	concatMap: "packages/pure-ts/src/extra/operators/higher-order.ts",
-	mergeMap: "packages/pure-ts/src/extra/operators/higher-order.ts",
-	delay: "packages/pure-ts/src/extra/operators/time.ts",
-	debounce: "packages/pure-ts/src/extra/operators/time.ts",
-	throttle: "packages/pure-ts/src/extra/operators/time.ts",
-	sample: "packages/pure-ts/src/extra/operators/time.ts",
-	audit: "packages/pure-ts/src/extra/operators/time.ts",
-	timeout: "packages/pure-ts/src/extra/operators/control.ts",
-	buffer: "packages/pure-ts/src/extra/operators/buffer.ts",
-	bufferCount: "packages/pure-ts/src/extra/operators/buffer.ts",
-	bufferTime: "packages/pure-ts/src/extra/operators/buffer.ts",
-	window: "packages/pure-ts/src/extra/operators/buffer.ts",
-	windowCount: "packages/pure-ts/src/extra/operators/buffer.ts",
-	windowTime: "packages/pure-ts/src/extra/operators/buffer.ts",
-	interval: "packages/pure-ts/src/extra/operators/time.ts",
-	repeat: "packages/pure-ts/src/extra/operators/control.ts",
-	pausable: "packages/pure-ts/src/extra/operators/control.ts",
-	rescue: "packages/pure-ts/src/extra/operators/control.ts",
-	flatMap: "packages/pure-ts/src/extra/operators/higher-order.ts",
-	combineLatest: "packages/pure-ts/src/extra/operators/combine.ts",
-	debounceTime: "packages/pure-ts/src/extra/operators/time.ts",
-	throttleTime: "packages/pure-ts/src/extra/operators/time.ts",
-	catchError: "packages/pure-ts/src/extra/operators/control.ts",
-
-	// Extra — backoff + resilience + checkpoint (roadmap §3.1)
-	constant: "src/base/resilience/backoff.ts",
-	linear: "src/base/resilience/backoff.ts",
-	exponential: "src/base/resilience/backoff.ts",
-	fibonacci: "src/base/resilience/backoff.ts",
-	decorrelatedJitter: "src/base/resilience/backoff.ts",
-	withMaxAttempts: "src/base/resilience/backoff.ts",
-	resolveBackoffPreset: "src/base/resilience/backoff.ts",
-	retry: "src/base/resilience/retry.ts",
-	circuitBreaker: "src/utils/resilience/breaker.ts",
-	CircuitOpenError: "src/utils/resilience/breaker.ts",
-	tokenBucket: "src/utils/resilience/rate-limiter.ts",
-	tokenBucket: "src/utils/resilience/rate-limiter.ts",
-	rateLimiter: "src/utils/resilience/rate-limiter.ts",
-	withBreaker: "src/utils/resilience/breaker.ts",
-	withStatus: "src/base/resilience/status.ts",
-	// Storage tiers — three-layer backend + tier model (Audit 4, 2026-04-24).
-	// Layer 1 — backends (bytes-level keyed I/O).
-	memoryBackend: "packages/pure-ts/src/extra/storage/tiers.ts",
-	fileBackend: "packages/pure-ts/src/extra/storage/tiers-node.ts",
-	sqliteBackend: "packages/pure-ts/src/extra/storage/tiers-node.ts",
-	indexedDbBackend: "packages/pure-ts/src/extra/storage/tiers-browser.ts",
-	// Layer 2 — tier factories (snapshot / append-log / kv over a backend).
-	snapshotStorage: "packages/pure-ts/src/extra/storage/tiers.ts",
-	appendLogStorage: "packages/pure-ts/src/extra/storage/tiers.ts",
-	kvStorage: "packages/pure-ts/src/extra/storage/tiers.ts",
-	// Convenience tier factories.
-	memorySnapshot: "packages/pure-ts/src/extra/storage/tiers.ts",
-	memoryAppendLog: "packages/pure-ts/src/extra/storage/tiers.ts",
-	memoryKv: "packages/pure-ts/src/extra/storage/tiers.ts",
-	dictKv: "packages/pure-ts/src/extra/storage/tiers.ts",
-	dictSnapshot: "packages/pure-ts/src/extra/storage/tiers.ts",
-	fileSnapshot: "packages/pure-ts/src/extra/storage/tiers-node.ts",
-	fileAppendLog: "packages/pure-ts/src/extra/storage/tiers-node.ts",
-	fileKv: "packages/pure-ts/src/extra/storage/tiers-node.ts",
-	sqliteSnapshot: "packages/pure-ts/src/extra/storage/tiers-node.ts",
-	sqliteAppendLog: "packages/pure-ts/src/extra/storage/tiers-node.ts",
-	sqliteKv: "packages/pure-ts/src/extra/storage/tiers-node.ts",
-	indexedDbSnapshot: "packages/pure-ts/src/extra/storage/tiers-browser.ts",
-	indexedDbAppendLog: "packages/pure-ts/src/extra/storage/tiers-browser.ts",
-	indexedDbKv: "packages/pure-ts/src/extra/storage/tiers-browser.ts",
-	// Codec helpers.
-	// jsonCodec / bigintJsonCodec are `export const` object literals — not supported by the function/class parser.
-	jsonCodecFor: "packages/pure-ts/src/extra/storage/tiers.ts",
-	bigintJsonCodecFor: "packages/pure-ts/src/extra/storage/tiers.ts",
-	// IDB reactive sources (DOM globals).
-	fromIDBRequest: "src/base/sources/browser/idb.ts",
-	fromIDBTransaction: "src/base/sources/browser/idb.ts",
-
-	// Extra — data structures (roadmap §3.2)
-	reactiveMap: "packages/pure-ts/src/extra/data-structures/reactive-map.ts",
-	reactiveLog: "packages/pure-ts/src/extra/data-structures/reactive-log.ts",
-	reactiveIndex: "packages/pure-ts/src/extra/data-structures/reactive-index.ts",
-	reactiveList: "packages/pure-ts/src/extra/data-structures/reactive-list.ts",
-	pubsub: "src/base/composition/pubsub.ts",
-
-	// Extra — cron
-	parseCron: "src/base/sources/event/cron.ts",
-	matchesCron: "src/base/sources/event/cron.ts",
-
-	// Extra — sources
-	fromTimer: "packages/pure-ts/src/extra/sources/event/timer.ts",
-	fromCron: "src/base/sources/event/cron.ts",
-	fromPromise: "packages/pure-ts/src/extra/sources/async.ts",
-	fromIter: "packages/pure-ts/src/extra/sources/sync/iter.ts",
-	fromAsyncIter: "packages/pure-ts/src/extra/sources/async.ts",
-	of: "packages/pure-ts/src/extra/sources/sync/iter.ts",
-	empty: "packages/pure-ts/src/extra/sources/sync/iter.ts",
-	never: "packages/pure-ts/src/extra/sources/sync/iter.ts",
-	throwError: "packages/pure-ts/src/extra/sources/sync/iter.ts",
-	cached: "src/base/sources/async.ts",
-	replay: "src/base/sources/async.ts",
-	share: "src/base/sources/async.ts",
-	fromEvent: "src/base/sources/event/dom.ts",
-	fromRaf: "src/base/sources/event/dom.ts",
-	fromPushNotification: "src/base/sources/event/push.ts",
-	fromWebhook: "src/base/io/webhook.ts",
-	fromAny: "packages/pure-ts/src/extra/sources/async.ts",
-	forEach: "src/base/sources/async.ts",
-	toArray: "src/base/sources/async.ts",
-	firstValueFrom: "src/base/sources/settled.ts",
-	shareReplay: "src/base/sources/async.ts",
-
-	// Extra — composite (roadmap §3.2b)
-	verifiable: "src/base/composition/verifiable.ts",
-	distill: "src/base/composition/distill.ts",
-
-	// Extra — backpressure (roadmap §5.1)
-	createWatermarkController: "src/base/composition/backpressure.ts",
-
-	// Extra — observable (RxJS interop)
-	toObservable: "src/base/composition/observable.ts",
-
-	// Patterns — reactive layout (roadmap §7.1)
-	reactiveLayout: "src/utils/reactive-layout/reactive-layout.ts",
-	analyzeAndMeasure: "src/utils/reactive-layout/reactive-layout.ts",
-	computeLineBreaks: "src/utils/reactive-layout/reactive-layout.ts",
-	computeCharPositions: "src/utils/reactive-layout/reactive-layout.ts",
-	reactiveBlockLayout: "src/utils/reactive-layout/reactive-block-layout.ts",
-
-	// Extra — worker bridge (roadmap §5.3)
-	workerBridge: "src/base/worker/bridge.ts",
-	workerSelf: "src/base/worker/self.ts",
-	createTransport: "src/base/worker/transport.ts",
-
-	// Patterns — reduction (roadmap §8.1)
-	stratify: "packages/pure-ts/src/extra/composition/stratify.ts",
-	funnel: "src/utils/reduction/index.ts",
-	feedback: "src/utils/reduction/index.ts",
-	budgetGate: "src/utils/resilience/budget-gate.ts",
-	scorer: "src/utils/reduction/index.ts",
-
-	// Patterns — graphspec (roadmap §8.3)
-	validateSpec: "src/utils/graphspec/index.ts",
-	compileSpec: "src/utils/graphspec/index.ts",
-	llmCompose: "src/utils/graphspec/index.ts",
-	llmRefine: "src/utils/graphspec/index.ts",
-	specDiff: "src/utils/graphspec/index.ts",
-
-	// Graph container
-	Graph: "packages/pure-ts/src/graph/graph.ts",
-	reachable: "packages/pure-ts/src/graph/graph.ts",
-	explainPath: "packages/pure-ts/src/graph/explain.ts",
-	mermaidLiveUrl: "src/base/render/graph-spec-to-mermaid-url.ts",
-	validateGraphObservability: "src/base/validate-observability.ts",
-	validateNoIslands: "packages/pure-ts/src/graph/validate-no-islands.ts",
-	watchTopologyTree: "packages/pure-ts/src/graph/topology-tree.ts",
-
-	// Inspect domain (Tier 9.1 γ-form γ-ii merge of audit + lens + guarded-execution)
-	auditTrail: "src/utils/inspect/audit.ts",
-	policyGate: "src/utils/inspect/audit.ts",
-	complianceSnapshot: "src/utils/inspect/audit.ts",
-	graphLens: "src/utils/inspect/lens.ts",
-	guardedExecution: "src/presets/inspect/guarded-execution.ts",
-	inspect: "src/presets/inspect/composite.ts",
-
-	// Resilience preset (Tier 9.1 γ-R-2)
-	resilientPipeline: "src/presets/resilience/resilient-pipeline.ts",
-
-	// Extra — singleflight + adaptive rate limiter (roadmap §9.3d)
-	singleFromAny: "src/base/composition/single-from-any.ts",
-	singleNodeFromAny: "src/base/composition/single-from-any.ts",
-	adaptiveRateLimiter: "src/utils/resilience/adaptive-rate-limiter.ts",
-
-	// LLM Adapter Layer — core (roadmap §9.3d)
-	createAdapter: "src/utils/ai/adapters/core/factory.ts",
-	createPricingRegistry: "src/utils/ai/adapters/core/pricing.ts",
-	registryPricing: "src/utils/ai/adapters/core/pricing.ts",
-	composePricing: "src/utils/ai/adapters/core/pricing.ts",
-	computePrice: "src/utils/ai/adapters/core/pricing.ts",
-	createCapabilitiesRegistry: "src/utils/ai/adapters/core/capabilities.ts",
-	observableAdapter: "src/utils/ai/adapters/core/observable.ts",
-
-	// LLM Adapter Layer — providers
-	anthropicAdapter: "src/utils/ai/adapters/providers/anthropic.ts",
-	openAICompatAdapter: "src/utils/ai/adapters/providers/openai-compat.ts",
-	googleAdapter: "src/utils/ai/adapters/providers/google.ts",
-	dryRunAdapter: "src/utils/ai/adapters/providers/dry-run.ts",
-	webllmAdapter: "src/utils/ai/adapters/providers/browser/webllm.ts",
-	chromeNanoAdapter: "src/utils/ai/adapters/providers/browser/chrome-nano.ts",
-
-	// LLM Adapter Layer — middleware
-	withBudgetGate: "src/utils/ai/adapters/middleware/budget-gate.ts",
-	withRateLimiter: "src/utils/ai/adapters/middleware/rate-limiter.ts",
-	withReplayCache: "src/utils/ai/adapters/middleware/replay-cache.ts",
-	withRetry: "src/utils/ai/adapters/middleware/retry.ts",
-	withTimeout: "src/base/resilience/timeout.ts",
-	withBreaker: "src/utils/resilience/breaker.ts",
-	resilientAdapter: "src/utils/ai/adapters/middleware/resilient-adapter.ts",
-	parseRateLimitFromError: "src/utils/ai/adapters/middleware/http429-parser.ts",
-	withDryRun: "src/utils/ai/adapters/middleware/dry-run.ts",
-
-	// LLM Adapter Layer — routing
-	cascadingLlmAdapter: "src/utils/ai/adapters/routing/cascading.ts",
-	cloudFirstPreset: "src/utils/ai/adapters/routing/browser-presets.ts",
-	localFirstPreset: "src/utils/ai/adapters/routing/browser-presets.ts",
-	offlinePreset: "src/utils/ai/adapters/routing/browser-presets.ts",
-
-	// AI memory — agentic-memory factory + composers (roadmap §4.4)
-	// Tier 9.1 γ-β: `agentMemory` and `agentLoop` physically moved to `ai/presets/`.
-	agentMemory: "src/presets/ai/agent-memory.ts",
-	agentLoop: "src/presets/ai/agent-loop.ts",
-	memoryWithVectors: "src/utils/ai/memory/memory-composers.ts",
-	memoryWithKG: "src/utils/ai/memory/memory-composers.ts",
-	memoryWithTiers: "src/utils/ai/memory/memory-composers.ts",
-	memoryRetrieval: "src/utils/ai/memory/memory-composers.ts",
-
-	// DS-14.7 — reactive fact store + persistence + recipe library
-	reactiveFactStore: "src/utils/memory/fact-store.ts",
-	persistentReactiveFactStore: "src/utils/memory/persistent-fact-store.ts",
-	simpleFactStore: "src/utils/memory/simple-fact-store.ts",
-	scoringByOutcome: "src/utils/memory/recipes/scoring-by-outcome.ts",
-	decayExponential: "src/utils/memory/recipes/decay-exponential.ts",
-	consolidationRem: "src/utils/memory/recipes/consolidation-rem.ts",
-	admissionLlmJudge: "src/utils/memory/recipes/admission-llm-judge.ts",
-	shardByTenant: "src/utils/memory/recipes/shard-by-tenant.ts",
-	invalidationTracer: "src/utils/memory/recipes/invalidation-tracer.ts",
-	bitemporalQuery: "src/utils/memory/recipes/bitemporal-query.ts",
-	influenceAnalysis: "src/utils/memory/recipes/influence-analysis.ts",
-	logProjector: "src/utils/messaging/index.ts",
-
-	// extra/composition — domain-agnostic substrates (Class B audit Alt E, 2026-04-30)
-	auditedSuccessTracker: "src/utils/orchestration/audited-success-tracker.ts",
-	llmExtractor: "src/utils/ai/prompts/prompt-call.ts",
-	llmConsolidator: "src/utils/ai/prompts/prompt-call.ts",
-	promptCall: "src/utils/ai/prompts/prompt-call.ts",
-
-	// Phase 4+ patterns: messaging (Tier 5.3, 2026-04-29)
-	topic: "src/utils/messaging/index.ts",
-	messagingHub: "src/utils/messaging/index.ts",
-	subscription: "src/utils/messaging/index.ts",
-	topicBridge: "src/utils/messaging/index.ts",
-
-	// Phase 4+ patterns: orchestration
-	pipelineGraph: "src/utils/orchestration/pipeline-graph.ts",
-	decisionKeyOf: "src/utils/orchestration/pipeline-graph.ts",
-
-	// Phase 4+ patterns: job-queue / job-flow
-	jobQueue: "src/utils/job-queue/index.ts",
-	jobFlow: "src/utils/job-queue/index.ts",
-	jobEventKeyOf: "src/utils/job-queue/index.ts",
-
-	// Phase 4+ patterns: cqrs
-	cqrs: "src/utils/cqrs/index.ts",
-	cqrsEventKeyOf: "src/utils/cqrs/index.ts",
-	dispatchKeyOf: "src/utils/cqrs/index.ts",
-	sagaInvocationKeyOf: "src/utils/cqrs/index.ts",
-
-	// Phase 4+ patterns: process manager
-	processManager: "src/utils/process/index.ts",
-	processInstanceKeyOf: "src/utils/process/index.ts",
-	processStateKeyOf: "src/utils/process/index.ts",
-};
-
-// ─── TypeScript parsing ─────────────────────────────────────────────────────
-
-function parseSource(filePath) {
-	const absPath = resolve(ROOT, filePath);
-	const source = readFileSync(absPath, "utf-8");
-	const sourceFile = ts.createSourceFile(absPath, source, ts.ScriptTarget.Latest, true);
-	return { sourceFile, source };
-}
-
-/**
- * Find the exported function declaration (or overload signatures)
- * for a given function name.
- */
-function findExportedFunction(sourceFile, name) {
-	let fn = null;
-	const overloads = [];
-
-	ts.forEachChild(sourceFile, (node) => {
-		if (ts.isFunctionDeclaration(node) && node.name?.text === name) {
-			const isExported =
-				node.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) ?? false;
-			if (isExported) {
-				if (node.body) {
-					fn = node; // implementation
-				} else {
-					overloads.push(node); // overload signature
-				}
-			}
-		}
-	});
-
-	return { implementation: fn, overloads };
-}
-
-/**
- * Find an exported class declaration.
- */
-function findExportedClass(sourceFile, name) {
-	let cls = null;
-	ts.forEachChild(sourceFile, (node) => {
-		if (ts.isClassDeclaration(node) && node.name?.text === name) {
-			cls = node;
-		}
-	});
-	return cls;
-}
-
-/**
- * `export const foo = bar` where `bar` is an identifier — reuse `bar`'s signature for docs.
- */
-function findExportedConstAlias(sourceFile, name) {
-	let hit = null;
-	function walk(node) {
-		if (hit != null) return;
-		if (ts.isVariableStatement(node)) {
-			const isExported = node.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword);
-			if (isExported) {
-				for (const d of node.declarationList.declarations) {
-					if (!ts.isIdentifier(d.name) || d.name.text !== name) continue;
-					const init = d.initializer;
-					if (init && ts.isIdentifier(init)) {
-						hit = { statement: node, declaration: d, targetName: init.text };
-						return;
-					}
-				}
-			}
-		}
-		ts.forEachChild(node, walk);
-	}
-	walk(sourceFile);
-	return hit;
-}
-
-/**
- * `export const foo = (...) => ...` (or a function expression) — an arrow/function
- * literal bound to an exported const. JSDoc lives on the VariableStatement, params
- * and return type live on the arrow node itself.
- */
-function findExportedConstArrow(sourceFile, name) {
-	let hit = null;
-	function walk(node) {
-		if (hit != null) return;
-		if (ts.isVariableStatement(node)) {
-			const isExported = node.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword);
-			if (isExported) {
-				for (const d of node.declarationList.declarations) {
-					if (!ts.isIdentifier(d.name) || d.name.text !== name) continue;
-					const init = d.initializer;
-					if (init && (ts.isArrowFunction(init) || ts.isFunctionExpression(init))) {
-						hit = { statement: node, declaration: d, arrow: init };
-						return;
-					}
-				}
-			}
-		}
-		ts.forEachChild(node, walk);
-	}
-	walk(sourceFile);
-	return hit;
-}
-
-// ─── JSDoc extraction ───────────────────────────────────────────────────────
-
-/**
- * Turn TypeScript-parsed JSDoc comment parts into plain text.
- * `{@link Foo}` is stored as link nodes with empty `.text` in some positions; joining `.text`
- * only produced broken markdown ("Creates a reactive —").
- */
-function flattenJSDocComment(comment) {
-	if (comment == null) return "";
-	if (typeof comment === "string") return comment;
-	if (!Array.isArray(comment)) return "";
-	const parts = [];
-	for (const c of comment) {
-		if (typeof c === "string") {
-			parts.push(c);
-		} else if (c.kind === ts.SyntaxKind.JSDocText) {
-			parts.push(c.text);
-		} else if (
-			c.kind === ts.SyntaxKind.JSDocLink ||
-			c.kind === ts.SyntaxKind.JSDocLinkCode ||
-			c.kind === ts.SyntaxKind.JSDocLinkPlain
-		) {
-			const tail = (c.text ?? "").trim();
-			if (tail.length > 0) parts.push(tail);
-			else if (c.name) parts.push(c.name.getText());
-		}
-	}
-	return parts.join("");
-}
-
-function getJSDoc(node) {
-	const jsDocs = node.jsDoc;
-	if (!jsDocs || jsDocs.length === 0) return null;
-	return jsDocs[jsDocs.length - 1];
-}
-
-/**
- * Re-indent code that lost its indentation from JSDoc * stripping.
- */
-function reindentCode(code) {
-	const lines = code.split("\n");
-	const result = [];
-	let depth = 0;
-
-	for (const line of lines) {
-		const trimmed = line.trim();
-		if (!trimmed) {
-			result.push("");
-			continue;
-		}
-		if (/^[}\])]/.test(trimmed)) {
-			depth = Math.max(0, depth - 1);
-		}
-		result.push("  ".repeat(depth) + trimmed);
-		const opens = (trimmed.match(/[{([\[]/g) || []).length;
-		const closes = (trimmed.match(/[})\]]/g) || []).length;
-		depth += opens - closes;
-		if (depth < 0) depth = 0;
-	}
-
-	while (result.length > 0 && result[result.length - 1] === "") result.pop();
-	return result.join("\n");
-}
-
-function extractJSDocData(jsDoc) {
-	const result = {
-		description: "",
-		params: [],
-		returns: "",
-		remarks: [],
-		examples: [],
-		seeAlso: [],
-		optionsType: "",
-		optionsRows: [],
-		returnsTable: [],
-		category: "",
-	};
-	if (!jsDoc) return result;
-
-	if (jsDoc.comment) {
-		result.description = flattenJSDocComment(jsDoc.comment);
-	}
-
-	if (!jsDoc.tags) return result;
-
-	for (const tag of jsDoc.tags) {
-		const tagName = tag.tagName.text;
-		const comment = flattenJSDocComment(tag.comment);
-
-		switch (tagName) {
-			case "param": {
-				const name = tag.name?.getText() || "";
-				const desc = comment.trim().replace(/^-\s*/, "");
-				result.params.push({ name, description: desc });
-				break;
-			}
-			case "returns":
-			case "return":
-				result.returns = comment.trim();
-				break;
-			case "remarks":
-				result.remarks.push(comment.trim());
-				break;
-			case "example": {
-				const raw = comment.trim();
-				const codeMatch = raw.match(/^([\s\S]*?)```(\w*)\n([\s\S]*?)```\s*$/);
-				if (codeMatch) {
-					const title = codeMatch[1].trim();
-					const lang = codeMatch[2] || "ts";
-					const code = codeMatch[3];
-					const reindented = reindentCode(code);
-					result.examples.push({ title, lang, code: reindented });
-				} else {
-					result.examples.push({ title: "", lang: "ts", code: raw });
-				}
-				break;
-			}
-			case "seeAlso":
-				result.seeAlso = comment
-					.split(",")
-					.map((s) => s.trim())
-					.filter(Boolean);
-				break;
-			case "optionsType":
-				result.optionsType = comment.trim();
-				break;
-			case "option": {
-				const parts = comment.split("|").map((s) => s.trim());
-				if (parts.length >= 4) {
-					result.optionsRows.push({
-						property: parts[0],
-						type: parts[1],
-						default: parts[2],
-						description: parts[3],
-					});
-				}
-				break;
-			}
-			case "returnsTable":
-				for (const line of comment.split("\n")) {
-					const parts = line.split("|").map((s) => s.trim());
-					if (parts.length >= 3) {
-						result.returnsTable.push({
-							method: parts[0],
-							signature: parts[1],
-							description: parts[2],
-						});
-					}
-				}
-				break;
-			case "category":
-				result.category = comment.trim();
-				break;
-		}
-	}
-
-	return result;
-}
-
-// ─── Signature extraction ───────────────────────────────────────────────────
-
-function getSignatureText(node, source) {
-	const start = node.getStart();
-	const bodyStart = node.body ? node.body.getStart() : node.getEnd();
-	let sig = source.substring(start, bodyStart).trim();
-	sig = sig.replace(/^export\s+/, "");
-	sig = sig.replace(/\s*\{?\s*$/, "");
-	return sig;
-}
-
-function getOverloadSignatures(overloads, source) {
-	return overloads.map((o) => {
-		let sig = source.substring(o.getStart(), o.getEnd()).trim();
-		sig = sig.replace(/^export\s+/, "");
-		sig = sig.replace(/;$/, "");
-		return sig;
-	});
-}
-
-/**
- * Build a declaration-style signature for an arrow/function-expression const
- * (the arrow node itself carries no name, so reattach it).
- */
-function getArrowSignatureText(name, arrow) {
-	const asyncMod = arrow.modifiers?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword)
-		? "async "
-		: "";
-	const tps =
-		arrow.typeParameters && arrow.typeParameters.length > 0
-			? `<${arrow.typeParameters.map((t) => t.getText()).join(", ")}>`
-			: "";
-	const ps = arrow.parameters.map((p) => p.getText()).join(", ");
-	const rt = arrow.type ? `: ${arrow.type.getText()}` : "";
-	return `${asyncMod}${name}${tps}(${ps})${rt}`;
-}
-
-// ─── Parameter table from function params ───────────────────────────────────
-
-function extractParams(node, jsdocParams, source) {
-	const params = [];
-	if (!node.parameters) return params;
-
-	for (const p of node.parameters) {
-		const name = p.name.getText();
-		if (name === "...ops") continue;
-
-		const typeText = p.type ? source.substring(p.type.getStart(), p.type.getEnd()) : "unknown";
-		const isOptional = !!p.questionToken || !!p.initializer;
-
-		const jsdoc = jsdocParams.find((jp) => jp.name === name);
-		const description = jsdoc?.description || "";
-
-		params.push({ name, type: typeText, description, optional: isOptional });
-	}
-
-	return params;
-}
-
-// ─── Markdown helpers ───────────────────────────────────────────────────────
-
-function escapeHtml(str) {
-	return str.replace(/</g, "&lt;").replace(/>/g, "&gt;");
-}
-
-/** Plain table cell — escape HTML and pipe delimiters. */
-function escapeTableText(str) {
-	return escapeHtml(str).replace(/\|/g, "\\|");
-}
-
-/**
- * Code in a markdown table cell. Use HTML `<code>` (not backticks) so MDX/Starlight
- * renders generics (`&lt;T&gt;` → `<T>`) and union `|` does not split columns.
- */
-function formatTableCode(str) {
-	return `<code>${escapeHtml(str)}</code>`;
-}
-
-// ─── Markdown generation ────────────────────────────────────────────────────
-
-function generateMarkdown(name, data) {
-	const lines = [];
-
-	// Starlight frontmatter
-	const title = `${name}()`;
-	const desc = data.description ? data.description.slice(0, 160) : `API reference for ${name}.`;
-	lines.push("---");
-	lines.push(`title: ${JSON.stringify(title)}`);
-	lines.push(`description: ${JSON.stringify(desc)}`);
-	lines.push("---");
-	lines.push("");
-
-	// Description
-	if (data.description) {
-		lines.push(escapeHtml(data.description));
-		lines.push("");
-	}
-
-	// Signature
-	lines.push("## Signature");
-	lines.push("");
-	lines.push("```ts");
-	for (const sig of data.signatures) {
-		lines.push(sig);
-	}
-	lines.push("```");
-	lines.push("");
-
-	// Parameters
-	if (data.params.length > 0) {
-		lines.push("## Parameters");
-		lines.push("");
-		lines.push("| Parameter | Type | Description |");
-		lines.push("|-----------|------|-------------|");
-		for (const p of data.params) {
-			lines.push(
-				`| ${formatTableCode(p.name)} | ${formatTableCode(p.type)} | ${escapeTableText(p.description)} |`,
-			);
-		}
-		lines.push("");
-	}
-
-	// Options type expansion
-	if (data.optionsRows && data.optionsRows.length > 0) {
-		lines.push(`### ${data.optionsTypeName}`);
-		lines.push("");
-		lines.push("| Property | Type | Default | Description |");
-		lines.push("|----------|------|---------|-------------|");
-		for (const row of data.optionsRows) {
-			lines.push(
-				`| ${formatTableCode(row.property)} | ${formatTableCode(row.type)} | ${formatTableCode(row.default)} | ${escapeTableText(row.description)} |`,
-			);
-		}
-		lines.push("");
-	}
-
-	// Returns
-	if (data.returns) {
-		lines.push("## Returns");
-		lines.push("");
-		lines.push(escapeHtml(data.returns));
-		lines.push("");
-	}
-
-	// Returns table
-	if (data.returnsTable && data.returnsTable.length > 0) {
-		lines.push("| Method | Signature | Description |");
-		lines.push("|--------|-----------|-------------|");
-		for (const row of data.returnsTable) {
-			lines.push(
-				`| ${formatTableCode(row.method)} | ${formatTableCode(row.signature)} | ${escapeTableText(row.description)} |`,
-			);
-		}
-		lines.push("");
-	}
-
-	// Basic Usage (first example)
-	if (data.examples.length > 0) {
-		const first = data.examples[0];
-		lines.push("## Basic Usage");
-		lines.push("");
-		lines.push(`\`\`\`${first.lang}`);
-		lines.push(first.code);
-		lines.push("```");
-		lines.push("");
-	}
-
-	// Behavior details
-	if (data.remarks.length > 0) {
-		lines.push("## Behavior Details");
-		lines.push("");
-		for (const r of data.remarks) {
-			lines.push(`- ${r}`);
-		}
-		lines.push("");
-	}
-
-	// Additional examples
-	if (data.examples.length > 1) {
-		lines.push("## Examples");
-		lines.push("");
-		for (let i = 1; i < data.examples.length; i++) {
-			const ex = data.examples[i];
-			const exTitle = ex.title || `Example ${i + 1}`;
-			lines.push(`### ${exTitle}`);
-			lines.push("");
-			lines.push(`\`\`\`${ex.lang}`);
-			lines.push(ex.code);
-			lines.push("```");
-			lines.push("");
-		}
-	}
-
-	// See Also
-	if (data.seeAlso.length > 0) {
-		lines.push("## See Also");
-		lines.push("");
-		for (const link of data.seeAlso) {
-			lines.push(`- ${link}`);
-		}
-		lines.push("");
-	}
-
-	return lines.join("\n");
-}
-
-// ─── Main pipeline ──────────────────────────────────────────────────────────
-
-function processFunction(name, filePath) {
-	const { sourceFile, source } = parseSource(filePath);
-	let { implementation, overloads } = findExportedFunction(sourceFile, name);
-	let alias = null;
-	if (!implementation && overloads.length === 0) {
-		alias = findExportedConstAlias(sourceFile, name);
-		if (alias) {
-			const inner = findExportedFunction(sourceFile, alias.targetName);
-			implementation = inner.implementation;
-			overloads = inner.overloads;
-		}
-	}
-
-	const primaryNode = implementation || overloads[overloads.length - 1];
-	if (!primaryNode) {
-		// `export const x = (...) => ...` — arrow/function-expression literal.
-		const arrowConst = findExportedConstArrow(sourceFile, name);
-		if (arrowConst) {
-			const jsDoc = getJSDoc(arrowConst.statement) ?? getJSDoc(arrowConst.declaration);
-			const jsdocData = extractJSDocData(jsDoc);
-			return {
-				name,
-				description: jsdocData.description,
-				signatures: [getArrowSignatureText(name, arrowConst.arrow)],
-				params: extractParams(arrowConst.arrow, jsdocData.params ?? [], source),
-				returns: jsdocData.returns,
-				returnsTable: jsdocData.returnsTable,
-				remarks: jsdocData.remarks,
-				examples: jsdocData.examples,
-				seeAlso: jsdocData.seeAlso,
-				optionsRows: jsdocData.optionsRows || [],
-				optionsTypeName: jsdocData.optionsType,
-			};
-		}
-		// Try as a class (e.g., Graph)
-		const cls = findExportedClass(sourceFile, name);
-		if (cls) {
-			const jsDoc = getJSDoc(cls);
-			const jsdocData = extractJSDocData(jsDoc);
-			return {
-				name,
-				description: jsdocData.description,
-				signatures: [`class ${name}`],
-				params: [],
-				returns: jsdocData.returns,
-				returnsTable: jsdocData.returnsTable,
-				remarks: jsdocData.remarks,
-				examples: jsdocData.examples,
-				seeAlso: jsdocData.seeAlso,
-				optionsRows: jsdocData.optionsRows || [],
-				optionsTypeName: jsdocData.optionsType,
-			};
-		}
-		console.error(`  ⚠ No exported function or class '${name}' found in ${filePath}`);
-		return null;
-	}
-
-	const implJsDoc = getJSDoc(primaryNode);
-	const implDoc = extractJSDocData(implJsDoc);
-	let jsdocData = implDoc;
-	if (alias) {
-		const aliasJs = getJSDoc(alias.declaration) ?? getJSDoc(alias.statement);
-		const aliasDoc = extractJSDocData(aliasJs);
-		jsdocData = {
-			description: aliasDoc.description || implDoc.description,
-			params: implDoc.params,
-			returns: aliasDoc.returns || implDoc.returns,
-			remarks: aliasDoc.remarks.length > 0 ? aliasDoc.remarks : implDoc.remarks,
-			examples: aliasDoc.examples.length > 0 ? aliasDoc.examples : implDoc.examples,
-			seeAlso: aliasDoc.seeAlso.length > 0 ? aliasDoc.seeAlso : implDoc.seeAlso,
-			optionsRows: implDoc.optionsRows,
-			optionsType: implDoc.optionsType,
-			returnsTable: implDoc.returnsTable,
-			category: aliasDoc.category || implDoc.category,
-		};
-	}
-
-	let signatures;
-	if (overloads.length > 0) {
-		signatures = getOverloadSignatures(overloads, source);
-	} else {
-		signatures = [getSignatureText(primaryNode, source)];
-	}
-
-	const paramNode = implementation || overloads[overloads.length - 1];
-	const params = extractParams(paramNode, jsdocData.params ?? [], source);
-
-	return {
-		name,
-		description: jsdocData.description,
-		signatures,
-		params,
-		returns: jsdocData.returns,
-		returnsTable: jsdocData.returnsTable,
-		remarks: jsdocData.remarks,
-		examples: jsdocData.examples,
-		seeAlso: jsdocData.seeAlso,
-		optionsRows: jsdocData.optionsRows || [],
-		optionsTypeName: jsdocData.optionsType,
-	};
-}
-
-// ─── CLI ────────────────────────────────────────────────────────────────────
-
-const args = process.argv.slice(2);
-const checkMode = args.includes("--check");
-const targets = args.filter((a) => !a.startsWith("--"));
-
-const entries =
-	targets.length > 0
-		? targets.map((t) => [t, REGISTRY[t]]).filter(([, v]) => v)
-		: Object.entries(REGISTRY);
-
-mkdirSync(OUT_DIR, { recursive: true });
-
-let stale = 0;
-
-for (const [name, filePath] of entries) {
-	const data = processFunction(name, filePath);
-	if (!data) continue;
-
-	const md = generateMarkdown(name, data);
-	const outPath = resolve(OUT_DIR, `${name}.md`);
-
-	if (checkMode) {
-		if (existsSync(outPath)) {
-			const existing = readFileSync(outPath, "utf-8");
-			if (existing !== md) {
-				console.log(`  ⚠ ${name}.md is stale`);
-				stale++;
-			} else {
-				console.log(`  ✓ ${name}.md is up to date`);
-			}
-		} else {
-			console.log(`  ⚠ ${name}.md does not exist`);
-			stale++;
-		}
-	} else {
-		writeFileSync(outPath, md);
-		console.log(`  ✓ wrote ${name}.md`);
-	}
-}
-
-if (checkMode && stale > 0) {
-	console.log(`\n${stale} file(s) stale. Run 'node scripts/gen-api-docs.mjs' to regenerate.`);
-	process.exit(1);
-}
-
-if (!checkMode) {
-	console.log(`\n[gen-api-docs] done. ${entries.length} entries processed.`);
-}
diff --git a/website/src/components/GraphreflyHero.astro b/website/src/components/GraphreflyHero.astro
index ddb78a79..61d7f7ae 100644
--- a/website/src/components/GraphreflyHero.astro
+++ b/website/src/components/GraphreflyHero.astro
@@ -25,7 +25,7 @@ const base = import.meta.env.BASE_URL;
 
   <div class="gr-hero-ctas">
     <a href="#gr-install" class="gr-btn-primary">Get started <span class="gr-arrow">→</span></a>
-    <button class="gr-btn-secondary gr-show" data-gr-lang-target="ts" data-gr-copy="npm i @graphrefly/graphrefly"><span class="gr-prompt">$</span>npm i @graphrefly/graphrefly</button>
+    <button class="gr-btn-secondary gr-show" data-gr-lang-target="ts" data-gr-copy="npm i @graphrefly/ts"><span class="gr-prompt">$</span>npm i @graphrefly/ts</button>
     <button class="gr-btn-secondary" data-gr-lang-target="py" data-gr-copy="pip install graphrefly"><span class="gr-prompt">$</span>pip install graphrefly</button>
   </div>
 </section>
@@ -539,7 +539,7 @@ const base = import.meta.env.BASE_URL;
         <div class="gr-gap-badge"><span class="gr-gap-badge-dot"></span>GraphReFly</div>
         <h3 class="gr-gap-h">Reactive <em>state harness</em>.</h3>
         <p>A single reactive topology connects every source. State pushes to dependents automatically — no re-reading, no stale snapshots. One graph sees what ten dashboards can't.</p>
-        <a href={`${base}demos/pagerduty-triage/`} class="gr-gap-demo">Demo: PagerDuty Triage →</a>
+        <a href={`${base}demos/`} class="gr-gap-demo">Current demos →</a>
       </div>
     </div>
 
@@ -569,7 +569,7 @@ const base = import.meta.env.BASE_URL;
         <div class="gr-gap-badge"><span class="gr-gap-badge-dot"></span>GraphReFly</div>
         <h3 class="gr-gap-h">Declarative <em>GraphSpec</em>.</h3>
         <p>Describe workflows in a declarative schema — like SQL for data flows. LLMs compose structurally, not imperatively. Policy enforcement, persistent checkpoints, atomic mutations built in.</p>
-        <a href={`${base}demos/knowledge-graph/`} class="gr-gap-demo">Demo: Knowledge Graph →</a>
+        <a href={`${base}demos/reactive-layout/`} class="gr-gap-demo">Demo: Reactive Layout →</a>
       </div>
     </div>
 
@@ -684,9 +684,9 @@ const base = import.meta.env.BASE_URL;
     </div>
 
     <div class="gr-install-cards">
-      <div class="gr-install-card" data-gr-copy="npm i @graphrefly/graphrefly">
+      <div class="gr-install-card" data-gr-copy="npm i @graphrefly/ts">
         <div class="gr-install-lang">TypeScript</div>
-        <div class="gr-install-cmd"><span class="gr-install-pr">$</span>npm i @graphrefly/graphrefly</div>
+        <div class="gr-install-cmd"><span class="gr-install-pr">$</span>npm i @graphrefly/ts</div>
         <a href="https://github.com/graphrefly/graphrefly-ts" class="gr-install-gh" target="_blank" rel="noopener noreferrer">View on GitHub ↗</a>
       </div>
       <div class="gr-install-card" data-gr-copy="pip install graphrefly">
@@ -704,23 +704,22 @@ const base = import.meta.env.BASE_URL;
   <div class="gr-foot-col">
     <b>Product</b>
     <a href={`${base}spec/`}>Spec</a>
-    <a href={`${base}api/node/`}>API</a>
+    <a href={`${base}api/reactivelayout/`}>API</a>
     <a href={`${base}integrations/`}>Integrations</a>
     <a href={`${base}solutions/`}>Solutions</a>
   </div>
   <div class="gr-foot-col">
     <b>Examples</b>
     <a href={`${base}demos/`}>All demos</a>
-    <a href={`${base}demos/pagerduty-triage/`}>PagerDuty Triage</a>
     <a href={`${base}demos/spending-alerts/`}>Spending Alerts</a>
-    <a href={`${base}demos/knowledge-graph/`}>Knowledge Graph</a>
+    <a href={`${base}demos/reactive-layout/`}>Reactive Layout</a>
   </div>
   <div class="gr-foot-col">
     <b>Resources</b>
     <a href={`${base}benchmark/`}>Benchmarks</a>
-    <a href={`${base}comparisons/zustand/`}>Comparisons</a>
+    <a href={`${base}comparisons/pretext/`}>Comparisons</a>
     <a href={`${base}roadmap/`}>Roadmap</a>
-    <a href={`${base}recipes/from-callbag-recharge/`}>Recipes</a>
+    <a href={`${base}recipes/nestjs-integration/`}>Recipes</a>
   </div>
   <div class="gr-foot-col">
     <b>Community</b>
diff --git a/website/src/components/Header.astro b/website/src/components/Header.astro
index e996350d..232f0c09 100644
--- a/website/src/components/Header.astro
+++ b/website/src/components/Header.astro
@@ -10,15 +10,15 @@ const shouldRenderSearch =
 	config.pagefind || config.components.Search !== '@astrojs/starlight/components/Search.astro';
 
 const base = import.meta.env.BASE_URL;
-const apiHref = `${base}api/node/`;
+const apiHref = `${base}api/reactivelayout/`;
 
 const navLinks = [
 	{ href: `${base}spec/`, label: 'SPEC' },
 	{ href: `${base}solutions/`, label: 'SOLUTIONS' },
 	{ href: apiHref, label: 'API' },
-	{ href: `${base}comparisons/zustand/`, label: 'COMPARE' },
+	{ href: `${base}comparisons/pretext/`, label: 'COMPARE' },
 	{ href: `${base}integrations/`, label: 'INTEGRATIONS' },
-	{ href: `${base}recipes/from-callbag-recharge/`, label: 'RECIPES' },
+	{ href: `${base}recipes/nestjs-integration/`, label: 'RECIPES' },
 	{ href: `${base}blog/welcome/`, label: 'BLOG' },
 	{ href: `${base}demos/`, label: 'DEMOS' },
 ];
diff --git a/website/src/components/MobileMenuFooter.astro b/website/src/components/MobileMenuFooter.astro
index 561fbace..2d2bc42b 100644
--- a/website/src/components/MobileMenuFooter.astro
+++ b/website/src/components/MobileMenuFooter.astro
@@ -4,14 +4,14 @@ import SocialIcons from 'virtual:starlight/components/SocialIcons';
 import ThemeSelect from 'virtual:starlight/components/ThemeSelect';
 
 const base = import.meta.env.BASE_URL;
-const apiHref = `${base}api/node/`;
+const apiHref = `${base}api/reactivelayout/`;
 ---
 
 <nav class="gr-mobile-nav" aria-label="Quick links">
 	<a href={`${base}spec/`} class="gr-mobile-nav-link">SPEC</a>
 	<a href={apiHref} class="gr-mobile-nav-link">API</a>
-	<a href={`${base}comparisons/zustand/`} class="gr-mobile-nav-link">COMPARE</a>
-	<a href={`${base}recipes/from-callbag-recharge/`} class="gr-mobile-nav-link">RECIPES</a>
+	<a href={`${base}comparisons/pretext/`} class="gr-mobile-nav-link">COMPARE</a>
+	<a href={`${base}recipes/nestjs-integration/`} class="gr-mobile-nav-link">RECIPES</a>
 	<a href={`${base}blog/welcome/`} class="gr-mobile-nav-link">BLOG</a>
 </nav>
 <nav class="gr-mobile-lang" aria-label="Language">
diff --git a/website/src/content/docs/api/CircuitBreaker.md b/website/src/content/docs/api/CircuitBreaker.md
deleted file mode 100644
index d774bf3b..00000000
--- a/website/src/content/docs/api/CircuitBreaker.md
+++ /dev/null
@@ -1,48 +0,0 @@
----
-title: "circuitBreaker()"
-description: "Factory for a synchronous circuit breaker with `closed`, `open`, and `half-open` states.\n\nSupports escalating cooldown via an optional BackoffStrategy — each co"
----
-
-Factory for a synchronous circuit breaker with `closed`, `open`, and `half-open` states.
-
-Supports escalating cooldown via an optional BackoffStrategy — each consecutive
-open→half-open→open cycle increments the backoff attempt.
-
-## Signature
-
-```ts
-function circuitBreaker(options?: NodeOrValue<CircuitBreakerOptions>): CircuitBreaker
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>options</code> | <code>NodeOrValue&lt;CircuitBreakerOptions&gt;</code> | Threshold, cooldown, half-open limit, and optional clock
-override; OR a `Node&lt;CircuitBreakerOptions&gt;` carrying the same shape
-reactively (Tier 6.5 3.2.4). |
-
-## Basic Usage
-
-```ts
-import { circuitBreaker, exponential, NS_PER_SEC } from "@graphrefly/graphrefly";
-
-const b = circuitBreaker({
-    failureThreshold: 3,
-    cooldown: exponential({ baseNs: 1 * NS_PER_SEC }),
-  });
-```
-
-## Behavior Details
-
-- **Timing:** Uses `monotonicNs()` by default (nanoseconds). Override `now` for tests.
-
-**Reactive options (locked semantics, Tier 6.5 3.2.4, 2026-04-29).**
-When `options` is a `Node<CircuitBreakerOptions>`, the breaker
-subscribes at construction and re-reads `failureThreshold` /
-`cooldownNs` / `cooldown` / `halfOpenMax` / `now` on each DATA. **An
-option swap RESETS the breaker to `"closed"`** with all counters
-cleared — operators tuning a runaway breaker get a clean baseline.
-If retaining failure history across re-tunings matters, derive a new
-breaker per-tuning instead. Call `breaker.dispose()` when retiring to
-release the option-Node subscription.
diff --git a/website/src/content/docs/api/CircuitOpenError.md b/website/src/content/docs/api/CircuitOpenError.md
deleted file mode 100644
index 48db3bbd..00000000
--- a/website/src/content/docs/api/CircuitOpenError.md
+++ /dev/null
@@ -1,12 +0,0 @@
----
-title: "CircuitOpenError()"
-description: "Thrown when withBreaker is configured with `onOpen: \"error\"` and the breaker rejects work."
----
-
-Thrown when withBreaker is configured with `onOpen: "error"` and the breaker rejects work.
-
-## Signature
-
-```ts
-class CircuitOpenError
-```
diff --git a/website/src/content/docs/api/Graph.md b/website/src/content/docs/api/Graph.md
deleted file mode 100644
index e12e1588..00000000
--- a/website/src/content/docs/api/Graph.md
+++ /dev/null
@@ -1,10 +0,0 @@
----
-title: "Graph()"
-description: "API reference for Graph."
----
-
-## Signature
-
-```ts
-class Graph
-```
diff --git a/website/src/content/docs/api/GuardDenied.md b/website/src/content/docs/api/GuardDenied.md
deleted file mode 100644
index 9420c63f..00000000
--- a/website/src/content/docs/api/GuardDenied.md
+++ /dev/null
@@ -1,32 +0,0 @@
----
-title: "GuardDenied()"
-description: "Thrown when a NodeGuard denies an action for a given actor.\n\nCarries the rejected `actor`, `action`, and optional `nodeName` for diagnostic\nmessages and middlew"
----
-
-Thrown when a NodeGuard denies an action for a given actor.
-
-Carries the rejected `actor`, `action`, and optional `nodeName` for diagnostic
-messages and middleware error handling.
-
-## Signature
-
-```ts
-class GuardDenied
-```
-
-## Basic Usage
-
-```ts
-import { GuardDenied, policy } from "@graphrefly/pure-ts";
-
-const guard = policy((allow) => { allow("observe"); });
-try {
-  if (!guard({ type: "llm", id: "agent-1" }, "write")) {
-    throw new GuardDenied(
-      { actor: { type: "llm", id: "agent-1" }, action: "write", nodeName: "userInput" },
-    );
-}
-} catch (e) {
-if (e instanceof GuardDenied) console.error(e.action, e.actor.type); // "write" "llm"
-}
-```
diff --git a/website/src/content/docs/api/ResettableTimer.md b/website/src/content/docs/api/ResettableTimer.md
deleted file mode 100644
index 2db9f265..00000000
--- a/website/src/content/docs/api/ResettableTimer.md
+++ /dev/null
@@ -1,33 +0,0 @@
----
-title: "ResettableTimer()"
-description: "Creates a resettable deadline timer for internal timeout, retry, and rate-limiting use."
----
-
-Creates a resettable deadline timer for internal timeout, retry, and rate-limiting use.
-
-## Signature
-
-```ts
-class ResettableTimer
-```
-
-## Basic Usage
-
-```ts
-import { ResettableTimer } from "@graphrefly/pure-ts";
-
-const timer = new ResettableTimer();
-timer.start(1000, () => console.log("fired"));
-timer.cancel();          // cancels before firing
-timer.start(500, () => console.log("new deadline"));
-console.log(timer.pending); // true
-```
-
-## Behavior Details
-
-- **Centralised primitive:** wraps `setTimeout`/`clearTimeout` with a generation guard
-so that stale callbacks never fire after `cancel()` or a new `start()`.
-- **Spec §5.10 exception:** resilience operators (`timeout`, `retry`, `rateLimiter`)
-need raw timers — `fromTimer` creates a new Node per reset, which is too heavy here.
-Lives in `src/extra/` (not `src/core/`) because it is a documented escape hatch from
-the protocol-pure core layer.
diff --git a/website/src/content/docs/api/TokenBucket.md b/website/src/content/docs/api/TokenBucket.md
deleted file mode 100644
index 24d7fd2a..00000000
--- a/website/src/content/docs/api/TokenBucket.md
+++ /dev/null
@@ -1,51 +0,0 @@
----
-title: "tokenBucket()"
-description: "Token-bucket meter (capacity + refill rate per second). Use with rateLimiter or custom gates."
----
-
-Token-bucket meter (capacity + refill rate per second). Use with rateLimiter or custom gates.
-
-## Signature
-
-```ts
-function tokenBucket(
-	capacity: number,
-	refillPerSecond: number,
-	opts?: TokenBucketOptions,
-): TokenBucket
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>capacity</code> | <code>number</code> | Maximum tokens (must be positive). |
-| <code>refillPerSecond</code> | <code>number</code> | Tokens added per elapsed second (non-negative; may be fractional). |
-| <code>opts</code> | <code>TokenBucketOptions</code> | Optional `clock` override for deterministic testing. |
-
-## Basic Usage
-
-```ts
-import { tokenBucket } from "@graphrefly/graphrefly";
-
-const bucket = tokenBucket(10, 2); // capacity 10, refill 2 tokens/sec
-bucket.tryConsume(3); // true — 7 tokens remaining
-bucket.available();   // ~7 (plus any elapsed refill — float-valued)
-
-// Deterministic test:
-let t = 0;
-const tb = tokenBucket(5, 1, { clock: () => t });
-tb.tryConsume(5);    // exhausts
-t = 1_000_000_000;   // advance 1s → +1 refill
-tb.tryConsume(1);    // true
-```
-
-## Behavior Details
-
-- **Float behavior:** the internal token counter is float-valued — fractional refill
-accumulates between `tryConsume` calls. See TokenBucket.available for caveats.
-
-**Clock injection:** pass `opts.clock` to drive refill scheduling deterministically
-in tests. The contract matches circuitBreaker's `now` option: must return
-`monotonicNs()`-style nanoseconds, never `Date.now()` (wall-clock skew breaks
-elapsed math).
diff --git a/website/src/content/docs/api/accessHintForGuard.md b/website/src/content/docs/api/accessHintForGuard.md
deleted file mode 100644
index 1dbd3c1d..00000000
--- a/website/src/content/docs/api/accessHintForGuard.md
+++ /dev/null
@@ -1,40 +0,0 @@
----
-title: "accessHintForGuard()"
-description: "Derives a best-effort `meta.access` hint string by probing `guard` with the\nstandard actor types `human`, `llm`, `wallet`, `system` for the `\"write\"` action\n(ro"
----
-
-Derives a best-effort `meta.access` hint string by probing `guard` with the
-standard actor types `human`, `llm`, `wallet`, `system` for the `"write"` action
-(roadmap 1.5). Aligned with graphrefly-py `access_hint_for_guard`.
-
-## Signature
-
-```ts
-function accessHintForGuard(guard: NodeGuard): string
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>guard</code> | <code>NodeGuard</code> | Guard function to probe (typically from policy). |
-
-## Returns
-
-`"restricted"` when no standard type is allowed; `"both"` when both
-`human` and `llm` are allowed (plus optionally `system`); the single allowed
-type name when only one passes; or a `"+"` joined list otherwise.
-
-## Basic Usage
-
-```ts
-import { policy, accessHintForGuard } from "@graphrefly/pure-ts";
-
-const guardBoth = policy((allow) => { allow("write"); });
-accessHintForGuard(guardBoth); // "both"
-
-const guardHuman = policy((allow) => {
-    allow("write", { where: (a) => a.type === "human" });
-  });
-accessHintForGuard(guardHuman); // "human"
-```
diff --git a/website/src/content/docs/api/adaptiveRateLimiter.md b/website/src/content/docs/api/adaptiveRateLimiter.md
deleted file mode 100644
index 7789a876..00000000
--- a/website/src/content/docs/api/adaptiveRateLimiter.md
+++ /dev/null
@@ -1,21 +0,0 @@
----
-title: "adaptiveRateLimiter()"
-description: "Create an adaptive rate limiter. Compose with any call source via\n`await limiter.acquire({ requestCost, tokenCost, signal })`."
----
-
-Create an adaptive rate limiter. Compose with any call source via
-`await limiter.acquire({ requestCost, tokenCost, signal })`.
-
-## Signature
-
-```ts
-function adaptiveRateLimiter(
-	opts: AdaptiveRateLimiterOptions = {},
-): AdaptiveRateLimiterBundle
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>opts</code> | <code>AdaptiveRateLimiterOptions</code> |  |
diff --git a/website/src/content/docs/api/admissionLlmJudge.md b/website/src/content/docs/api/admissionLlmJudge.md
deleted file mode 100644
index ec151939..00000000
--- a/website/src/content/docs/api/admissionLlmJudge.md
+++ /dev/null
@@ -1,24 +0,0 @@
----
-title: "admissionLlmJudge()"
-description: "Adapt an upstream LLM-verdict stream to the synchronous `admissionFilter`\nface. `verdicts` is a Node carrying the current `factId → admit?` map (e.g.\na `promptN"
----
-
-Adapt an upstream LLM-verdict stream to the synchronous `admissionFilter`
-face. `verdicts` is a Node carrying the current `factId → admit?` map (e.g.
-a `promptNode` accumulating judgements).
-
-## Signature
-
-```ts
-function admissionLlmJudge<T>(
-	verdicts: Node<ReadonlyMap<FactId, boolean>>,
-	opts: AdmissionLlmJudgeOptions = {},
-): Node<AdmissionFilter<T>>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>verdicts</code> | <code>Node&lt;ReadonlyMap&lt;FactId, boolean&gt;&gt;</code> |  |
-| <code>opts</code> | <code>AdmissionLlmJudgeOptions</code> |  |
diff --git a/website/src/content/docs/api/agentLoop.md b/website/src/content/docs/api/agentLoop.md
deleted file mode 100644
index bf207b22..00000000
--- a/website/src/content/docs/api/agentLoop.md
+++ /dev/null
@@ -1,17 +0,0 @@
----
-title: "agentLoop()"
-description: "API reference for agentLoop."
----
-
-## Signature
-
-```ts
-function agentLoop(name: string, opts: AgentLoopOptions): AgentLoopGraph
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>name</code> | <code>string</code> |  |
-| <code>opts</code> | <code>AgentLoopOptions</code> |  |
diff --git a/website/src/content/docs/api/agentMemory.md b/website/src/content/docs/api/agentMemory.md
deleted file mode 100644
index 21c207fa..00000000
--- a/website/src/content/docs/api/agentMemory.md
+++ /dev/null
@@ -1,30 +0,0 @@
----
-title: "agentMemory()"
-description: "Pre-wired agentic memory graph. Sugar over `distill` plus the\n`memoryWithVectors` / `memoryWithKG` / `memoryWithTiers` / `memoryRetrieval`\ncomposers. Power user"
----
-
-Pre-wired agentic memory graph. Sugar over `distill` plus the
-`memoryWithVectors` / `memoryWithKG` / `memoryWithTiers` / `memoryRetrieval`
-composers. Power users who want a subset of capabilities can call those
-composers directly; this factory bundles them into one ergonomic call.
-
-Returns an AgentMemoryGraph subclass instance — `instanceof
-AgentMemoryGraph` narrows in callers (e.g. Phase 13.G `agent(spec)`).
-
-## Signature
-
-```ts
-function agentMemory<TMem = unknown>(
-	name: string,
-	source: NodeInput<unknown>,
-	opts: AgentMemoryOptions<TMem>,
-): AgentMemoryGraph<TMem>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>name</code> | <code>string</code> |  |
-| <code>source</code> | <code>NodeInput&lt;unknown&gt;</code> |  |
-| <code>opts</code> | <code>AgentMemoryOptions&lt;TMem&gt;</code> |  |
diff --git a/website/src/content/docs/api/anthropicAdapter.md b/website/src/content/docs/api/anthropicAdapter.md
deleted file mode 100644
index 7d844c4b..00000000
--- a/website/src/content/docs/api/anthropicAdapter.md
+++ /dev/null
@@ -1,16 +0,0 @@
----
-title: "anthropicAdapter()"
-description: "API reference for anthropicAdapter."
----
-
-## Signature
-
-```ts
-function anthropicAdapter(opts: AnthropicAdapterOptions = {}): LLMAdapter
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>opts</code> | <code>AnthropicAdapterOptions</code> |  |
diff --git a/website/src/content/docs/api/appendLogStorage.md b/website/src/content/docs/api/appendLogStorage.md
deleted file mode 100644
index a780c449..00000000
--- a/website/src/content/docs/api/appendLogStorage.md
+++ /dev/null
@@ -1,52 +0,0 @@
----
-title: "appendLogStorage()"
-description: "Wraps a `StorageBackend` as a typed append-log tier.\n\nBuffer model: `appendEntries(entries)` accumulates per-key buckets in\nmemory. `flush()` encodes each bucke"
----
-
-Wraps a `StorageBackend` as a typed append-log tier.
-
-Buffer model: `appendEntries(entries)` accumulates per-key buckets in
-memory. `flush()` encodes each bucket as a JSON array via codec and writes
-under that bucket key. `rollback()` discards pending appends.
-
-Storage shape & semantics: each backend key holds a JSON array of entries
-for that partition. This is a true **logical append log** — `mode:"append"`
-(default) read-merges the key's existing array and persists
-`[...prior, ...pending]`, so the key accumulates monotonically and a
-*fresh* tier over an existing key continues the accumulation (no entries
-lost). The *physical* write rewrites the whole per-key array each flush
-(not a byte-level backend append); that is an implementation detail, not a
-semantic limitation — callers do **not** need to layer their own tier for
-append semantics. Set `mode:"overwrite"` for snapshot semantics (each flush
-replaces the key with only that flush's entries, no read-merge).
-
-## Signature
-
-```ts
-function appendLogStorage<T>(
-	backend: StorageBackend,
-	opts: AppendLogStorageOptions<T> = {},
-): AppendLogStorageTier<T>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>backend</code> | <code>StorageBackend</code> | Bytes-level backend to persist log entries into. |
-| <code>opts</code> | <code>AppendLogStorageOptions&lt;T&gt;</code> | Optional name, codec, per-entry key extractor, debounce window, and compaction interval. |
-
-## Returns
-
-`AppendLogStorageTier&lt;T&gt;` that buffers pending entries and flushes per-key buckets on wave-close.
-
-## Basic Usage
-
-```ts
-import { memoryBackend, appendLogStorage } from "@graphrefly/graphrefly/extra";
-
-const backend = memoryBackend();
-const tier = appendLogStorage<{ type: string; payload: unknown }>(backend, { name: "events" });
-await tier.appendEntries([{ type: "created", payload: { id: 1 } }]);
-const result = await tier.loadEntries?.();
-```
diff --git a/website/src/content/docs/api/audit.md b/website/src/content/docs/api/audit.md
deleted file mode 100644
index df989793..00000000
--- a/website/src/content/docs/api/audit.md
+++ /dev/null
@@ -1,32 +0,0 @@
----
-title: "audit()"
-description: "After each source `DATA`, waits `ms` then emits the latest value if another `DATA` has not arrived (`auditTime` / trailing window)."
----
-
-After each source `DATA`, waits `ms` then emits the latest value if another `DATA` has not arrived (`auditTime` / trailing window).
-
-## Signature
-
-```ts
-function audit<T>(source: Node<T>, ms: number, opts?: ExtraOpts): Node<T>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>source</code> | <code>Node&lt;T&gt;</code> | Upstream node. |
-| <code>ms</code> | <code>number</code> | Window in milliseconds after each `DATA`. |
-| <code>opts</code> | <code>ExtraOpts</code> | Optional NodeOptions (excluding `describeKind`). |
-
-## Returns
-
-`Node&lt;T&gt;` - Trailing-edge sampled stream.
-
-## Basic Usage
-
-```ts
-import { audit, state } from "@graphrefly/pure-ts";
-
-audit(state(0), 100);
-```
diff --git a/website/src/content/docs/api/auditTrail.md b/website/src/content/docs/api/auditTrail.md
deleted file mode 100644
index 1c1bb14f..00000000
--- a/website/src/content/docs/api/auditTrail.md
+++ /dev/null
@@ -1,28 +0,0 @@
----
-title: "auditTrail()"
-description: "Wraps any Graph with a reactive audit trail recording every event\nmatching `includeTypes` (default: data + error + complete + teardown).\n\nEach entry carries `se"
----
-
-Wraps any Graph with a reactive audit trail recording every event
-matching `includeTypes` (default: data + error + complete + teardown).
-
-Each entry carries `seq`, `timestamp_ns` (monotonic), `wall_clock_ns`,
-`path`, `type`, and — when available — `actor`, `value`, `error`, and the
-`graph.trace()` reasoning annotation for the path.
-
-The returned graph mounts an `entries` node + `count` derived. Query
-helpers (`byNode`, `byActor`, `byTimeRange`) operate on the cached
-snapshot synchronously.
-
-## Signature
-
-```ts
-function auditTrail(target: Graph, opts: AuditTrailOptions = {}): AuditTrailGraph
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>target</code> | <code>Graph</code> |  |
-| <code>opts</code> | <code>AuditTrailOptions</code> |  |
diff --git a/website/src/content/docs/api/auditedSuccessTracker.md b/website/src/content/docs/api/auditedSuccessTracker.md
deleted file mode 100644
index ff21570c..00000000
--- a/website/src/content/docs/api/auditedSuccessTracker.md
+++ /dev/null
@@ -1,46 +0,0 @@
----
-title: "auditedSuccessTracker()"
-description: "Construct an AuditedSuccessTrackerGraph. Replaces the prior\n`effectivenessTracker()` and `strategyModel()` factories."
----
-
-Construct an AuditedSuccessTrackerGraph. Replaces the prior
-`effectivenessTracker()` and `strategyModel()` factories.
-
-## Signature
-
-```ts
-function auditedSuccessTracker<
-	TKey extends string = string,
-	TEntry extends AuditedSuccessEntry<TKey> = AuditedSuccessEntry<TKey>,
->(opts?: AuditedSuccessTrackerOptions): AuditedSuccessTrackerGraph<TKey, TEntry>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>opts</code> | <code>AuditedSuccessTrackerOptions</code> |  |
-
-## Basic Usage
-
-```ts
-// Generic per-action tracker
-const tracker = auditedSuccessTracker({ name: "ab-test" });
-tracker.record("variant-a", true);
-tracker.record("variant-b", false);
-tracker.entries.subscribe(snap => console.log(snap.get("variant-a")));
-
-// Composite-key (rootCause × intervention) tracker — caller computes the key
-type StrategyEntry = AuditedSuccessEntry<StrategyKey> & {
-  rootCause: RootCause;
-  intervention: Intervention;
-};
-const strategy = auditedSuccessTracker<StrategyKey, StrategyEntry>({
-    name: "strategy",
-  });
-strategy.record(
-  strategyKey(rootCause, intervention),
-  true,
-  { rootCause, intervention },
-);
-```
diff --git a/website/src/content/docs/api/batch.md b/website/src/content/docs/api/batch.md
deleted file mode 100644
index a7a89887..00000000
--- a/website/src/content/docs/api/batch.md
+++ /dev/null
@@ -1,20 +0,0 @@
----
-title: "batch()"
-description: "Runs `fn` inside a batch scope. Nested `batch()` calls share one deferral\nqueue. If `fn` throws, deferred work for the outer frame is discarded\n(unless a drain "
----
-
-Runs `fn` inside a batch scope. Nested `batch()` calls share one deferral
-queue. If `fn` throws, deferred work for the outer frame is discarded
-(unless a drain is already in progress — cross-language decision A4).
-
-## Signature
-
-```ts
-function batch(fn: () => void): void
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>fn</code> | <code>() =&gt; void</code> |  |
diff --git a/website/src/content/docs/api/bigintJsonCodecFor.md b/website/src/content/docs/api/bigintJsonCodecFor.md
deleted file mode 100644
index c4579cab..00000000
--- a/website/src/content/docs/api/bigintJsonCodecFor.md
+++ /dev/null
@@ -1,24 +0,0 @@
----
-title: "bigintJsonCodecFor()"
-description: "Returns the bigintJsonCodec cast to `Codec<T>`. Pure typing helper —\nno runtime overhead. Use when a generic tier API requires a `Codec<T>` and\n`T` carries `big"
----
-
-Returns the bigintJsonCodec cast to `Codec&lt;T&gt;`. Pure typing helper —
-no runtime overhead. Use when a generic tier API requires a `Codec&lt;T&gt;` and
-`T` carries `bigint` fields.
-
-## Signature
-
-```ts
-function bigintJsonCodecFor<T>(): Codec<T>
-```
-
-## Basic Usage
-
-```ts
-import { memoryBackend, snapshotStorage, bigintJsonCodecFor } from "@graphrefly/pure-ts/extra";
-
-const tier = snapshotStorage<FactStore>(memoryBackend(), {
-    codec: bigintJsonCodecFor<FactStore>(),
-  });
-```
diff --git a/website/src/content/docs/api/bitemporalQuery.md b/website/src/content/docs/api/bitemporalQuery.md
deleted file mode 100644
index 76d8660b..00000000
--- a/website/src/content/docs/api/bitemporalQuery.md
+++ /dev/null
@@ -1,26 +0,0 @@
----
-title: "bitemporalQuery()"
-description: "Build a standing bi-temporal historical view over a reactiveFactStore.\nEmits the fragments valid at the latest `asOf` (sorted confidence desc, then\n`t_ns` desc "
----
-
-Build a standing bi-temporal historical view over a reactiveFactStore.
-Emits the fragments valid at the latest `asOf` (sorted confidence desc, then
-`t_ns` desc — same order as the built-in `answer`).
-
-## Signature
-
-```ts
-function bitemporalQuery<T>(
-	mem: ReactiveFactStoreGraph<T>,
-	asOf: Node<bigint>,
-	opts: BitemporalQueryOptions = {},
-): Node<readonly MemoryFragment<T>[]>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>mem</code> | <code>ReactiveFactStoreGraph&lt;T&gt;</code> |  |
-| <code>asOf</code> | <code>Node&lt;bigint&gt;</code> |  |
-| <code>opts</code> | <code>BitemporalQueryOptions</code> |  |
diff --git a/website/src/content/docs/api/budgetGate.md b/website/src/content/docs/api/budgetGate.md
deleted file mode 100644
index 51fa738c..00000000
--- a/website/src/content/docs/api/budgetGate.md
+++ /dev/null
@@ -1,114 +0,0 @@
----
-title: "budgetGate()"
-description: "Pass-through that respects reactive constraint nodes.\n\nDATA flows through when all constraints are satisfied. When any constraint\nis exceeded, `PAUSE` is sent u"
----
-
-Pass-through that respects reactive constraint nodes.
-
-DATA flows through when all constraints are satisfied. When any constraint
-is exceeded, `PAUSE` is sent upstream and DATA is buffered in a FIFO queue.
-When constraints relax, the queue drains in arrival order and `RESUME` is
-sent upstream.
-
-## Invariants (do not refactor without preserving)
-
-1. **Terminal force-flush.** On `COMPLETE` / `ERROR` arriving from `source`,
-   every buffered item is emitted downstream BEFORE the terminal message is
-   forwarded. The constraint is intentionally bypassed for the flush — once
-   upstream is done, the caller must see the buffered work, not lose it.
-   See COMPOSITION-GUIDE §19 (terminal-emission operators).
-
-2. **PAUSE-release ordering.** When a constraint flips from saturated →
-   released, the queue drains in FIFO order downstream BEFORE `RESUME` is
-   sent upstream. Reversing the order (RESUME-then-drain) would let new
-   upstream DATA interleave with the queue tail, breaking arrival-order
-   delivery. See COMPOSITION-GUIDE §9, §9a (diamond + batch coalescing).
-
-3. **Deferred RESOLVED.** A `RESOLVED` from `source` while the queue is
-   non-empty is held until the queue drains, then forwarded — so downstream
-   sees `[buffered DATA…, RESOLVED]` in causal order rather than
-   `[RESOLVED, buffered DATA…]`.
-
-   **Stall risk (qa D4):** if the constraint never relaxes AND no terminal
-   arrives from `source`, the deferred RESOLVED is held forever. Downstream
-   consumers that depend on `RESOLVED` for an `awaitSettled`-style
-   coordination wait stall in this case. PAUSE is sent upstream so source
-   backpressure stops further DATA, but the gate itself has no escape
-   hatch — by design (the producer-pattern is fire-and-forget; recovery
-   happens at the compositor level via timeout, retry, or cancellation).
-
-4. **Constraint DIRTY suppression.** Constraint-node DIRTY does NOT
-   propagate downstream — only `source`-DIRTY does. The gate's downstream
-   semantics track `source`'s wave, not constraint waves.
-
-5. **Lazy PAUSE (qa D3).** PAUSE is sent upstream ONLY when a `source` DATA
-   arrives that fails the constraint check (the first blocked item). A
-   constraint flipping closed BEFORE any source DATA arrives does NOT emit
-   a preemptive PAUSE — upstream may push DATA freely until the first
-   item is buffered. This matches the producer-pattern lazy-activation
-   philosophy (don't impose backpressure for hypothetical future blocks).
-   For eager-PAUSE semantics, wrap the gate in a compositor that watches
-   constraints + source independently.
-
-## Queue
-
-The internal buffer is an unbounded HeadIndexQueue (O(1) push,
-O(1) shift, opportunistic compaction). It does NOT use RingBuffer
-because RingBuffer's drop-oldest eviction would silently lose buffered
-items between PAUSE and RESUME. Backpressure (PAUSE) is the upstream
-contract for bounding the queue, not capacity-driven eviction here.
-
-## Producer-pattern: source edge is invisible to `describe()`
-
-`budgetGate` is constructed via `node([], fn)` and subscribes to `source`
-and the constraint nodes manually inside its activation fn. Because no
-dep is declared at construction, **`describe()` shows no edge from
-`source` (or any constraint) into the returned node** — the gate looks
-like a standalone leaf source. This is intentional (see COMPOSITION-GUIDE
-§24 "Edges are derived, not declared"): if you want the constraint /
-source dependency to appear in describe output, surface it at the
-compositor level (e.g. annotate via `meta.ai.upstream`, or wrap the gate
-in a parent factory that exposes the deps as constructor args).
-
-## Reference equality + Tier 6.5 3.2.5 locked semantics
-
-**Constraint VALUES are reactive.** Each `BudgetConstraint.node` is
-subscribed at activation; per-value changes flip the gate (re-evaluate
-in the same wave) and trigger PAUSE/RESUME upstream. Per the locked
-semantic rule for the reactive-options-widening batch (Tier 6.5 3.2.5,
-2026-04-29): "constraints array re-evaluated immediately against
-current source; adding/removing constraints triggers gate
-re-evaluation in the same wave" — the per-value half is shipped via
-the existing constraint-Node subscription model.
-
-**The constraints ARRAY shape is static.** The factory captures the
-`constraints` array reference and each `check` function at
-construction; it does NOT diff subsequent arrays. To add or remove
-constraints reactively, build the swap at the compositor level (a
-`switchMap` rebuild over a constraint-shape Node), or construct a new
-gate. Dynamic constraint-array reactivity is intentionally deferred —
-the subscription churn (resub on every constraint add/remove) and
-`latestValues` shape mutation overshoot the budget-gate's
-fire-and-forget ergonomics.
-
-## Signature
-
-```ts
-function budgetGate<T>(
-	source: Node<T>,
-	constraints: ReadonlyArray<BudgetConstraint>,
-	opts?: BudgetGateOptions,
-): BudgetGateBundle<T>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>source</code> | <code>Node&lt;T&gt;</code> | Input node. |
-| <code>constraints</code> | <code>ReadonlyArray&lt;BudgetConstraint&gt;</code> | Reactive constraint checks. MUST be non-empty. |
-| <code>opts</code> | <code>BudgetGateOptions</code> | Optional node options. |
-
-## Returns
-
-Gated node.
diff --git a/website/src/content/docs/api/buffer.md b/website/src/content/docs/api/buffer.md
deleted file mode 100644
index f2aac83d..00000000
--- a/website/src/content/docs/api/buffer.md
+++ /dev/null
@@ -1,32 +0,0 @@
----
-title: "buffer()"
-description: "Buffers source `DATA` values; flushes an array when `notifier` settles (`buffer`)."
----
-
-Buffers source `DATA` values; flushes an array when `notifier` settles (`buffer`).
-
-## Signature
-
-```ts
-function buffer<T>(source: Node<T>, notifier: Node<unknown>, opts?: ExtraOpts): Node<T[]>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>source</code> | <code>Node&lt;T&gt;</code> | Upstream node. |
-| <code>notifier</code> | <code>Node&lt;unknown&gt;</code> | Flush trigger on each settlement. |
-| <code>opts</code> | <code>ExtraOpts</code> | Optional NodeOptions (excluding `describeKind`). |
-
-## Returns
-
-`Node&lt;T[]&gt;` - Emits buffered arrays (may be empty-handled via `RESOLVED` when nothing buffered).
-
-## Basic Usage
-
-```ts
-import { buffer, state } from "@graphrefly/pure-ts";
-
-buffer(state(0), state(0));
-```
diff --git a/website/src/content/docs/api/bufferCount.md b/website/src/content/docs/api/bufferCount.md
deleted file mode 100644
index 5ce517e4..00000000
--- a/website/src/content/docs/api/bufferCount.md
+++ /dev/null
@@ -1,32 +0,0 @@
----
-title: "bufferCount()"
-description: "Batches consecutive `DATA` values into arrays of length `count` (`bufferCount` / `windowCount`)."
----
-
-Batches consecutive `DATA` values into arrays of length `count` (`bufferCount` / `windowCount`).
-
-## Signature
-
-```ts
-function bufferCount<T>(source: Node<T>, count: number, opts?: ExtraOpts): Node<T[]>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>source</code> | <code>Node&lt;T&gt;</code> | Upstream node. |
-| <code>count</code> | <code>number</code> | Buffer size before emit; must be &gt; 0. |
-| <code>opts</code> | <code>ExtraOpts</code> | Optional NodeOptions (excluding `describeKind`). |
-
-## Returns
-
-`Node&lt;T[]&gt;` - Emits fixed-size arrays; remainder flushes on `COMPLETE`.
-
-## Basic Usage
-
-```ts
-import { bufferCount, state } from "@graphrefly/pure-ts";
-
-bufferCount(state(0), 3);
-```
diff --git a/website/src/content/docs/api/bufferTime.md b/website/src/content/docs/api/bufferTime.md
deleted file mode 100644
index 3804adef..00000000
--- a/website/src/content/docs/api/bufferTime.md
+++ /dev/null
@@ -1,32 +0,0 @@
----
-title: "bufferTime()"
-description: "Flushes buffered `DATA` values every `ms` (`bufferTime` / `windowTime`)."
----
-
-Flushes buffered `DATA` values every `ms` (`bufferTime` / `windowTime`).
-
-## Signature
-
-```ts
-function bufferTime<T>(source: Node<T>, ms: number, opts?: ExtraOpts): Node<T[]>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>source</code> | <code>Node&lt;T&gt;</code> | Upstream node. |
-| <code>ms</code> | <code>number</code> | Flush interval in milliseconds. |
-| <code>opts</code> | <code>ExtraOpts</code> | Optional NodeOptions (excluding `describeKind`). |
-
-## Returns
-
-`Node&lt;T[]&gt;` - Time-windowed batches.
-
-## Basic Usage
-
-```ts
-import { bufferTime, state } from "@graphrefly/pure-ts";
-
-bufferTime(state(0), 250);
-```
diff --git a/website/src/content/docs/api/cached.md b/website/src/content/docs/api/cached.md
deleted file mode 100644
index 67cdd8dd..00000000
--- a/website/src/content/docs/api/cached.md
+++ /dev/null
@@ -1,31 +0,0 @@
----
-title: "cached()"
-description: "replay with `bufferSize === 1` — replays the latest `DATA` to new subscribers."
----
-
-replay with `bufferSize === 1` — replays the latest `DATA` to new subscribers.
-
-## Signature
-
-```ts
-function cached<T>(source: Node<T>, opts?: ExtraOpts): Node<T>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>source</code> | <code>Node&lt;T&gt;</code> | Upstream node. |
-| <code>opts</code> | <code>ExtraOpts</code> | Producer options. |
-
-## Returns
-
-`Node&lt;T&gt;` — share + last-value replay.
-
-## Basic Usage
-
-```ts
-import { cached, state } from "@graphrefly/graphrefly";
-
-cached(state(0));
-```
diff --git a/website/src/content/docs/api/cascadingLlmAdapter.md b/website/src/content/docs/api/cascadingLlmAdapter.md
deleted file mode 100644
index 4e6f6d52..00000000
--- a/website/src/content/docs/api/cascadingLlmAdapter.md
+++ /dev/null
@@ -1,20 +0,0 @@
----
-title: "cascadingLlmAdapter()"
-description: "API reference for cascadingLlmAdapter."
----
-
-## Signature
-
-```ts
-function cascadingLlmAdapter(
-	tiers: readonly AdapterTier[],
-	opts: CascadingLlmAdapterOptions = {},
-): LLMAdapter
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>tiers</code> | <code>readonly AdapterTier[]</code> |  |
-| <code>opts</code> | <code>CascadingLlmAdapterOptions</code> |  |
diff --git a/website/src/content/docs/api/catchError.md b/website/src/content/docs/api/catchError.md
deleted file mode 100644
index 01331672..00000000
--- a/website/src/content/docs/api/catchError.md
+++ /dev/null
@@ -1,36 +0,0 @@
----
-title: "catchError()"
-description: "RxJS-named alias for rescue — replaces upstream `ERROR` with a recovered value."
----
-
-RxJS-named alias for rescue — replaces upstream `ERROR` with a recovered value.
-
-## Signature
-
-```ts
-function rescue<T>(
-	source: Node<T>,
-	recover: (err: unknown) => T,
-	opts?: ExtraOpts,
-): Node<T>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>source</code> | <code>Node&lt;T&gt;</code> | Upstream node. |
-| <code>recover</code> | <code>(err: unknown) =&gt; T</code> | Maps the error payload to a replacement value; if it throws, `ERROR` is forwarded. |
-| <code>opts</code> | <code>ExtraOpts</code> | Optional NodeOptions (excluding `describeKind`). |
-
-## Returns
-
-Recovered stream; behavior matches `rescue`.
-
-## Basic Usage
-
-```ts
-import { catchError, state } from "@graphrefly/pure-ts";
-
-catchError(state(0), () => 0);
-```
diff --git a/website/src/content/docs/api/chromeNanoAdapter.md b/website/src/content/docs/api/chromeNanoAdapter.md
deleted file mode 100644
index 6e60d883..00000000
--- a/website/src/content/docs/api/chromeNanoAdapter.md
+++ /dev/null
@@ -1,16 +0,0 @@
----
-title: "chromeNanoAdapter()"
-description: "API reference for chromeNanoAdapter."
----
-
-## Signature
-
-```ts
-function chromeNanoAdapter(opts: ChromeNanoAdapterOptions = {}): LLMAdapter
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>opts</code> | <code>ChromeNanoAdapterOptions</code> |  |
diff --git a/website/src/content/docs/api/cloudFirstPreset.md b/website/src/content/docs/api/cloudFirstPreset.md
deleted file mode 100644
index cb925e04..00000000
--- a/website/src/content/docs/api/cloudFirstPreset.md
+++ /dev/null
@@ -1,18 +0,0 @@
----
-title: "cloudFirstPreset()"
-description: "Cloud-first with local fallback: BYOK → WebLLM → Chrome Nano."
----
-
-Cloud-first with local fallback: BYOK → WebLLM → Chrome Nano.
-
-## Signature
-
-```ts
-function cloudFirstPreset(opts: CloudFirstPresetOptions): LLMAdapter
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>opts</code> | <code>CloudFirstPresetOptions</code> |  |
diff --git a/website/src/content/docs/api/combine.md b/website/src/content/docs/api/combine.md
deleted file mode 100644
index 4992c775..00000000
--- a/website/src/content/docs/api/combine.md
+++ /dev/null
@@ -1,37 +0,0 @@
----
-title: "combine()"
-description: "Combines the latest value from each dependency whenever any dep settles (combineLatest)."
----
-
-Combines the latest value from each dependency whenever any dep settles (combineLatest).
-
-## Signature
-
-```ts
-function combine<const T extends readonly unknown[]>(
-	...sources: { [K in keyof T]: Node<T[K]> }
-): Node<T>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>sources</code> | <code>{ [K in keyof T]: Node&lt;T[K]&gt; }</code> | Nodes to combine (variadic). |
-
-## Returns
-
-`Node&lt;T&gt;` - Tuple of latest values.
-
-## Basic Usage
-
-```ts
-import { combine, state } from "@graphrefly/pure-ts";
-
-const n = combine(state(1), state("a"));
-```
-
-## Behavior Details
-
-- Unlike RxJS `combineLatest`, this is named `combine`. Use the combineLatest alias
-if you prefer the RxJS name. Seed is always required for `scan`/`reduce` (no seedless mode).
diff --git a/website/src/content/docs/api/combineLatest.md b/website/src/content/docs/api/combineLatest.md
deleted file mode 100644
index 83bca4e9..00000000
--- a/website/src/content/docs/api/combineLatest.md
+++ /dev/null
@@ -1,37 +0,0 @@
----
-title: "combineLatest()"
-description: "RxJS-named alias for combine — emits when any dep updates with latest tuple of values."
----
-
-RxJS-named alias for combine — emits when any dep updates with latest tuple of values.
-
-## Signature
-
-```ts
-function combine<const T extends readonly unknown[]>(
-	...sources: { [K in keyof T]: Node<T[K]> }
-): Node<T>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>sources</code> | <code>{ [K in keyof T]: Node&lt;T[K]&gt; }</code> | Nodes to combine (variadic). |
-
-## Returns
-
-Combined node; signature matches `combine`.
-
-## Basic Usage
-
-```ts
-import { combineLatest, state } from "@graphrefly/pure-ts";
-
-const n = combineLatest(state(1), state("a"));
-```
-
-## Behavior Details
-
-- Unlike RxJS `combineLatest`, this is named `combine`. Use the combineLatest alias
-if you prefer the RxJS name. Seed is always required for `scan`/`reduce` (no seedless mode).
diff --git a/website/src/content/docs/api/compileSpec.md b/website/src/content/docs/api/compileSpec.md
deleted file mode 100644
index a458a891..00000000
--- a/website/src/content/docs/api/compileSpec.md
+++ /dev/null
@@ -1,26 +0,0 @@
----
-title: "compileSpec()"
-description: "Instantiate a Graph from a GraphSpec.\n\nHandles template expansion (mounted subgraphs), feedback wiring via §8.1\nfeedback(), node factory lookup from the catalog"
----
-
-Instantiate a Graph from a GraphSpec.
-
-Handles template expansion (mounted subgraphs), feedback wiring via §8.1
-feedback(), node factory lookup from the catalog, and topology validation.
-
-## Signature
-
-```ts
-function compileSpec(spec: GraphSpec, opts?: CompileSpecOptions): Graph
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>spec</code> | <code>GraphSpec</code> | Declarative graph topology. |
-| <code>opts</code> | <code>CompileSpecOptions</code> | Catalog and compile options. |
-
-## Returns
-
-A running Graph.
diff --git a/website/src/content/docs/api/complianceSnapshot.md b/website/src/content/docs/api/complianceSnapshot.md
deleted file mode 100644
index 88062da4..00000000
--- a/website/src/content/docs/api/complianceSnapshot.md
+++ /dev/null
@@ -1,31 +0,0 @@
----
-title: "complianceSnapshot()"
-description: "One-shot point-in-time export of a Graph's state plus optional\naudit + policy bundles. Returns a JSON-serializable object with a\ndeterministic truncated-SHA-256"
----
-
-One-shot point-in-time export of a Graph's state plus optional
-audit + policy bundles. Returns a JSON-serializable object with a
-deterministic truncated-SHA-256 ComplianceSnapshotResult.fingerprint
-over the canonical payload for tamper-evidence in regulatory archival.
-
-**Cryptographic strength:** the fingerprint is truncated to 64 bits for
-compact archival. Collision-resistant for casual integrity checks but NOT
-sufficient for adversarial tamper-evidence — pair with a full SHA-256
-(or stronger) over the canonical JSON when regulatory requirements demand
-collision resistance.
-
-## Signature
-
-```ts
-function complianceSnapshot(
-	target: Graph,
-	opts: ComplianceSnapshotOptions = {},
-): ComplianceSnapshotResult
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>target</code> | <code>Graph</code> |  |
-| <code>opts</code> | <code>ComplianceSnapshotOptions</code> |  |
diff --git a/website/src/content/docs/api/composePricing.md b/website/src/content/docs/api/composePricing.md
deleted file mode 100644
index 0766c3fd..00000000
--- a/website/src/content/docs/api/composePricing.md
+++ /dev/null
@@ -1,18 +0,0 @@
----
-title: "composePricing()"
-description: "Compose multiple `PricingFn`s — first non-zero wins. Useful for registry layering."
----
-
-Compose multiple `PricingFn`s — first non-zero wins. Useful for registry layering.
-
-## Signature
-
-```ts
-function composePricing(...fns: readonly PricingFn[]): PricingFn
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>fns</code> | <code>readonly PricingFn[]</code> |  |
diff --git a/website/src/content/docs/api/computeLineBreaks.md b/website/src/content/docs/api/computeLineBreaks.md
index 2b213edf..6d18942d 100644
--- a/website/src/content/docs/api/computeLineBreaks.md
+++ b/website/src/content/docs/api/computeLineBreaks.md
@@ -18,10 +18,7 @@ overflow maxWidth. Supports:
 function computeLineBreaks(
 	segments: PreparedSegment[],
 	maxWidth: number,
-	adapter: MeasurementAdapter,
-	font: string,
-	cache: Map<string, Map<string, number>>,
-	segmentAdapter?: SegmentAdapter,
+	opts?: { hyphenWidth?: number; segmentAdapter?: SegmentAdapter },
 ): LineBreaksResult
 ```
 
@@ -29,9 +26,6 @@ function computeLineBreaks(
 
 | Parameter | Type | Description |
 |-----------|------|-------------|
-| <code>segments</code> | <code>PreparedSegment[]</code> |  |
-| <code>maxWidth</code> | <code>number</code> |  |
-| <code>adapter</code> | <code>MeasurementAdapter</code> |  |
-| <code>font</code> | <code>string</code> |  |
-| <code>cache</code> | <code>Map&lt;string, Map&lt;string, number&gt;&gt;</code> |  |
-| <code>segmentAdapter</code> | <code>SegmentAdapter</code> |  |
+| <code>segments</code> | <code>PreparedSegment[]</code> | Already measured text segments. |
+| <code>maxWidth</code> | <code>number</code> | Line width constraint. |
+| <code>opts</code> | <code>{ hyphenWidth?: number; segmentAdapter?: SegmentAdapter }</code> | Optional premeasured hyphen width and segmentation helper. |
diff --git a/website/src/content/docs/api/computePrice.md b/website/src/content/docs/api/computePrice.md
deleted file mode 100644
index 4ddefc00..00000000
--- a/website/src/content/docs/api/computePrice.md
+++ /dev/null
@@ -1,30 +0,0 @@
----
-title: "computePrice()"
-description: "Compute price from a usage object + model pricing.\n\n- Tier-threshold math uses `sumInputTokens(usage)` as the axis.\n- Service tier (`opts.tier`) multiplies the "
----
-
-Compute price from a usage object + model pricing.
-
-- Tier-threshold math uses `sumInputTokens(usage)` as the axis.
-- Service tier (`opts.tier`) multiplies the final total via `tierMultipliers`.
-- Each token class is priced independently using the matching `Rate` lookup.
-- `breakdown` is populated when `opts.withBreakdown = true` (default false
-  to keep hot-path allocations low).
-
-## Signature
-
-```ts
-function computePrice(
-	usage: TokenUsage,
-	pricing: ModelPricing,
-	opts?: { tier?: string; withBreakdown?: boolean },
-): PriceBreakdown
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>usage</code> | <code>TokenUsage</code> |  |
-| <code>pricing</code> | <code>ModelPricing</code> |  |
-| <code>opts</code> | <code>{ tier?: string; withBreakdown?: boolean }</code> |  |
diff --git a/website/src/content/docs/api/concat.md b/website/src/content/docs/api/concat.md
deleted file mode 100644
index d5bd60c6..00000000
--- a/website/src/content/docs/api/concat.md
+++ /dev/null
@@ -1,32 +0,0 @@
----
-title: "concat()"
-description: "Plays all of `firstSrc`, then all of `secondSrc`. **`DATA`** from `secondSrc` during phase one is buffered until handoff."
----
-
-Plays all of `firstSrc`, then all of `secondSrc`. **`DATA`** from `secondSrc` during phase one is buffered until handoff.
-
-## Signature
-
-```ts
-function concat<T>(firstSrc: Node<T>, secondSrc: Node<T>, opts?: ExtraOpts): Node<T>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>firstSrc</code> | <code>Node&lt;T&gt;</code> | First segment. |
-| <code>secondSrc</code> | <code>Node&lt;T&gt;</code> | Second segment. |
-| <code>opts</code> | <code>ExtraOpts</code> | Optional NodeOptions (excluding `describeKind`). |
-
-## Returns
-
-`Node&lt;T&gt;` - Concatenated stream.
-
-## Basic Usage
-
-```ts
-import { concat, state } from "@graphrefly/pure-ts";
-
-const n = concat(state(1), state(2));
-```
diff --git a/website/src/content/docs/api/concatMap.md b/website/src/content/docs/api/concatMap.md
deleted file mode 100644
index a4a61783..00000000
--- a/website/src/content/docs/api/concatMap.md
+++ /dev/null
@@ -1,36 +0,0 @@
----
-title: "concatMap()"
-description: "Enqueues each outer value and subscribes to inners one at a time (`concatMap`)."
----
-
-Enqueues each outer value and subscribes to inners one at a time (`concatMap`).
-
-## Signature
-
-```ts
-function concatMap<T, R>(
-	source: Node<T>,
-	project: (value: T) => NodeInput<R>,
-	opts?: HigherOrderOpts & { maxBuffer?: number },
-): Node<R>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>source</code> | <code>Node&lt;T&gt;</code> | Upstream node. |
-| <code>project</code> | <code>(value: T) =&gt; NodeInput&lt;R&gt;</code> | Maps each outer value to an inner source shape (`Node`, scalar, `PromiseLike`, `Iterable`, or `AsyncIterable`) coerced via fromAny. |
-| <code>opts</code> | <code>HigherOrderOpts & { maxBuffer?: number }</code> | Optional NodeOptions (excluding `describeKind`). |
-
-## Returns
-
-`Node&lt;R&gt;` - Sequential concatenation of inner streams.
-
-## Basic Usage
-
-```ts
-import { concatMap, state } from "@graphrefly/pure-ts";
-
-concatMap(state(0), (n) => state((n as number) + 1));
-```
diff --git a/website/src/content/docs/api/consolidationRem.md b/website/src/content/docs/api/consolidationRem.md
deleted file mode 100644
index 74b872f1..00000000
--- a/website/src/content/docs/api/consolidationRem.md
+++ /dev/null
@@ -1,19 +0,0 @@
----
-title: "consolidationRem()"
-description: "Build the `{ consolidateTrigger, consolidate }` pair for a REM-replay\nconsolidation policy. Spread into reactiveFactStore's config."
----
-
-Build the `{ consolidateTrigger, consolidate }` pair for a REM-replay
-consolidation policy. Spread into reactiveFactStore's config.
-
-## Signature
-
-```ts
-function consolidationRem<T>(opts: ConsolidationRemOptions<T>): ConsolidationRemConfig<T>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>opts</code> | <code>ConsolidationRemOptions&lt;T&gt;</code> |  |
diff --git a/website/src/content/docs/api/constant.md b/website/src/content/docs/api/constant.md
deleted file mode 100644
index c15f5311..00000000
--- a/website/src/content/docs/api/constant.md
+++ /dev/null
@@ -1,30 +0,0 @@
----
-title: "constant()"
-description: "Builds a strategy that always returns the same delay in nanoseconds."
----
-
-Builds a strategy that always returns the same delay in nanoseconds.
-
-## Signature
-
-```ts
-function constant(delayNs: number): BackoffStrategy
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>delayNs</code> | <code>number</code> | Non-negative delay in nanoseconds; values below zero are clamped to zero. |
-
-## Returns
-
-`BackoffStrategy` for use with retry or custom timers.
-
-## Basic Usage
-
-```ts
-import { constant, retry, NS_PER_SEC } from "@graphrefly/graphrefly";
-
-const out = retry(source, { count: 3, backoff: constant(0.25 * NS_PER_SEC) });
-```
diff --git a/website/src/content/docs/api/cqrs.md b/website/src/content/docs/api/cqrs.md
deleted file mode 100644
index d39e8df7..00000000
--- a/website/src/content/docs/api/cqrs.md
+++ /dev/null
@@ -1,39 +0,0 @@
----
-title: "cqrs()"
-description: "Create a CQRS graph container."
----
-
-Create a CQRS graph container.
-
-## Signature
-
-```ts
-function cqrs<EM extends CqrsEventMap = Record<string, unknown>>(
-	name: string,
-	opts?: CqrsOptions,
-): CqrsGraph<EM>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>name</code> | <code>string</code> |  |
-| <code>opts</code> | <code>CqrsOptions</code> |  |
-
-## Basic Usage
-
-```ts
-const app = cqrs("orders");
-app.event("orderPlaced");
-app.command("placeOrder", (payload, { emit }) => {
-    emit("orderPlaced", { orderId: payload.id, amount: payload.amount });
-  });
-const { node: orderCount } = app.projection({
-    name: "orderCount",
-    events: ["orderPlaced"],
-    reducer: (_s, events) => events.length,
-    initial: 0,
-  });
-app.dispatch("placeOrder", { id: "1", amount: 100 });
-```
diff --git a/website/src/content/docs/api/cqrsEventKeyOf.md b/website/src/content/docs/api/cqrsEventKeyOf.md
deleted file mode 100644
index bc5b2a60..00000000
--- a/website/src/content/docs/api/cqrsEventKeyOf.md
+++ /dev/null
@@ -1,18 +0,0 @@
----
-title: "cqrsEventKeyOf()"
-description: "Recommended `keyOf` for CQRS event-store storage tiers (Audit 4)."
----
-
-Recommended `keyOf` for CQRS event-store storage tiers (Audit 4).
-
-## Signature
-
-```ts
-cqrsEventKeyOf(e: CqrsEvent): string
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>e</code> | <code>CqrsEvent</code> |  |
diff --git a/website/src/content/docs/api/createAdapter.md b/website/src/content/docs/api/createAdapter.md
deleted file mode 100644
index 71f2582d..00000000
--- a/website/src/content/docs/api/createAdapter.md
+++ /dev/null
@@ -1,16 +0,0 @@
----
-title: "createAdapter()"
-description: "API reference for createAdapter."
----
-
-## Signature
-
-```ts
-function createAdapter(opts: CreateAdapterOptions): LLMAdapter
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>opts</code> | <code>CreateAdapterOptions</code> |  |
diff --git a/website/src/content/docs/api/createCapabilitiesRegistry.md b/website/src/content/docs/api/createCapabilitiesRegistry.md
deleted file mode 100644
index 514fe866..00000000
--- a/website/src/content/docs/api/createCapabilitiesRegistry.md
+++ /dev/null
@@ -1,20 +0,0 @@
----
-title: "createCapabilitiesRegistry()"
-description: "Create a fresh `CapabilitiesRegistry`. Optionally seed with entries."
----
-
-Create a fresh `CapabilitiesRegistry`. Optionally seed with entries.
-
-## Signature
-
-```ts
-function createCapabilitiesRegistry(
-	initial?: readonly ModelCapabilities[],
-): CapabilitiesRegistry
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>initial</code> | <code>readonly ModelCapabilities[]</code> |  |
diff --git a/website/src/content/docs/api/createPricingRegistry.md b/website/src/content/docs/api/createPricingRegistry.md
deleted file mode 100644
index 2e34a529..00000000
--- a/website/src/content/docs/api/createPricingRegistry.md
+++ /dev/null
@@ -1,20 +0,0 @@
----
-title: "createPricingRegistry()"
-description: "Create a fresh `PricingRegistry`. Optionally seed with entries."
----
-
-Create a fresh `PricingRegistry`. Optionally seed with entries.
-
-## Signature
-
-```ts
-function createPricingRegistry(
-	initial?: ReadonlyArray<readonly [provider: string, model: string, pricing: ModelPricing]>,
-): PricingRegistry
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>initial</code> | <code>ReadonlyArray&lt;readonly [provider: string, model: string, pricing: ModelPricing]&gt;</code> |  |
diff --git a/website/src/content/docs/api/createTransport.md b/website/src/content/docs/api/createTransport.md
deleted file mode 100644
index ed07cb89..00000000
--- a/website/src/content/docs/api/createTransport.md
+++ /dev/null
@@ -1,25 +0,0 @@
----
-title: "createTransport()"
-description: "Auto-detect transport type and create a normalized WorkerTransport.\n\nSupports:\n- `Worker` — direct postMessage/onmessage\n- `SharedWorker` — port-based postMessa"
----
-
-Auto-detect transport type and create a normalized WorkerTransport.
-
-Supports:
-- `Worker` — direct postMessage/onmessage
-- `SharedWorker` — port-based postMessage/onmessage
-- `ServiceWorker` — postMessage via controller, listen via navigator.serviceWorker
-- `BroadcastChannel` — postMessage/onmessage (no Transferable support)
-- `MessagePort` — direct postMessage/onmessage (worker-side SharedWorker port)
-
-## Signature
-
-```ts
-function createTransport(target: unknown): WorkerTransport
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>target</code> | <code>unknown</code> |  |
diff --git a/website/src/content/docs/api/createWatermarkController.md b/website/src/content/docs/api/createWatermarkController.md
deleted file mode 100644
index 6510729e..00000000
--- a/website/src/content/docs/api/createWatermarkController.md
+++ /dev/null
@@ -1,50 +0,0 @@
----
-title: "createWatermarkController()"
-description: "Creates a watermark-based backpressure controller."
----
-
-Creates a watermark-based backpressure controller.
-
-## Signature
-
-```ts
-function createWatermarkController(
-	sendUp: (messages: Messages) => void,
-	opts: WatermarkOptions,
-): WatermarkController
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>sendUp</code> | <code>(messages: Messages) =&gt; void</code> | Callback that delivers messages upstream (typically `handle.up`). |
-| <code>opts</code> | <code>WatermarkOptions</code> | High/low watermark thresholds (item counts). |
-
-## Returns
-
-A WatermarkController.
-
-## Basic Usage
-
-```ts
-const handle = graph.observe("fast-source");
-const wm = createWatermarkController(
-  (msgs) => handle.up(msgs),
-  { highWaterMark: 64, lowWaterMark: 16 },
-);
-
-// In sink callback:
-handle.subscribe((msgs) => {
-    for (const msg of msgs) {
-      if (msg[0] === DATA) {
-        buffer.push(msg[1]);
-        wm.onEnqueue();
-      }
-  }
-});
-
-// When consumer drains:
-const item = buffer.shift();
-wm.onDequeue();
-```
diff --git a/website/src/content/docs/api/debounce.md b/website/src/content/docs/api/debounce.md
deleted file mode 100644
index 0816346e..00000000
--- a/website/src/content/docs/api/debounce.md
+++ /dev/null
@@ -1,32 +0,0 @@
----
-title: "debounce()"
-description: "Emits the latest value only after `ms` quiet time since the last trigger (`debounce`)."
----
-
-Emits the latest value only after `ms` quiet time since the last trigger (`debounce`).
-
-## Signature
-
-```ts
-function debounce<T>(source: Node<T>, ms: number, opts?: ExtraOpts): Node<T>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>source</code> | <code>Node&lt;T&gt;</code> | Upstream node. |
-| <code>ms</code> | <code>number</code> | Quiet window in milliseconds. |
-| <code>opts</code> | <code>ExtraOpts</code> | Optional NodeOptions (excluding `describeKind`). |
-
-## Returns
-
-`Node&lt;T&gt;` - Debounced stream.
-
-## Basic Usage
-
-```ts
-import { debounce, state } from "@graphrefly/pure-ts";
-
-debounce(state(0), 50);
-```
diff --git a/website/src/content/docs/api/debounceTime.md b/website/src/content/docs/api/debounceTime.md
deleted file mode 100644
index 8938a5fc..00000000
--- a/website/src/content/docs/api/debounceTime.md
+++ /dev/null
@@ -1,32 +0,0 @@
----
-title: "debounceTime()"
-description: "RxJS-named alias for debounce — drops rapid `DATA` until `ms` of quiet."
----
-
-RxJS-named alias for debounce — drops rapid `DATA` until `ms` of quiet.
-
-## Signature
-
-```ts
-function debounce<T>(source: Node<T>, ms: number, opts?: ExtraOpts): Node<T>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>source</code> | <code>Node&lt;T&gt;</code> | Upstream node. |
-| <code>ms</code> | <code>number</code> | Quiet window in milliseconds. |
-| <code>opts</code> | <code>ExtraOpts</code> | Optional NodeOptions (excluding `describeKind`). |
-
-## Returns
-
-Debounced node; behavior matches `debounce`.
-
-## Basic Usage
-
-```ts
-import { debounceTime, state } from "@graphrefly/pure-ts";
-
-debounceTime(state(0), 100);
-```
diff --git a/website/src/content/docs/api/decayExponential.md b/website/src/content/docs/api/decayExponential.md
deleted file mode 100644
index 4ff6bb30..00000000
--- a/website/src/content/docs/api/decayExponential.md
+++ /dev/null
@@ -1,27 +0,0 @@
----
-title: "decayExponential()"
-description: "Wire an exponential-decay forgetting loop onto a reactiveFactStore.\nSelf-adds a driver Node to the store's graph (`describe()`-visible) and\nreturns it; each emi"
----
-
-Wire an exponential-decay forgetting loop onto a reactiveFactStore.
-Self-adds a driver Node to the store's graph (`describe()`-visible) and
-returns it; each emission is the batch of fragments decayed that tick (also
-fed back through `ingest`).
-
-## Signature
-
-```ts
-function decayExponential<T>(
-	mem: ReactiveFactStoreGraph<T>,
-	ingest: Node<MemoryFragment<T>>,
-	opts: DecayExponentialOptions,
-): Node<readonly MemoryFragment<T>[]>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>mem</code> | <code>ReactiveFactStoreGraph&lt;T&gt;</code> |  |
-| <code>ingest</code> | <code>Node&lt;MemoryFragment&lt;T&gt;&gt;</code> |  |
-| <code>opts</code> | <code>DecayExponentialOptions</code> |  |
diff --git a/website/src/content/docs/api/decisionKeyOf.md b/website/src/content/docs/api/decisionKeyOf.md
deleted file mode 100644
index 222d644f..00000000
--- a/website/src/content/docs/api/decisionKeyOf.md
+++ /dev/null
@@ -1,18 +0,0 @@
----
-title: "decisionKeyOf()"
-description: "Recommended `keyOf` for keyed-storage adapters (Audit 2 #7)."
----
-
-Recommended `keyOf` for keyed-storage adapters (Audit 2 #7).
-
-## Signature
-
-```ts
-decisionKeyOf<T>(d: Decision<T>): string
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>d</code> | <code>Decision&lt;T&gt;</code> |  |
diff --git a/website/src/content/docs/api/decompileGraph.md b/website/src/content/docs/api/decompileGraph.md
deleted file mode 100644
index 5719e440..00000000
--- a/website/src/content/docs/api/decompileGraph.md
+++ /dev/null
@@ -1,27 +0,0 @@
----
-title: "decompileGraph()"
-description: "Extract a GraphSpec from a running graph.\n\nUses `describe({ detail: \"standard\" })` as a starting point, then enriches:\n- Feedback edges recovered from counter n"
----
-
-Extract a GraphSpec from a running graph.
-
-Uses `describe({ detail: "standard" })` as a starting point, then enriches:
-- Feedback edges recovered from counter node meta (`feedbackFrom`/`feedbackTo`)
-- Template refs recovered from output node meta (`_templateName`/`_templateBind`)
-- Structural fingerprinting as fallback for 2+ identical mounted subgraphs
-
-## Signature
-
-```ts
-function decompileGraph(graph: Graph): GraphSpec
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| `graph` | `Graph` | Running graph to decompile. |
-
-## Returns
-
-A GraphSpec representation.
diff --git a/website/src/content/docs/api/decorrelatedJitter.md b/website/src/content/docs/api/decorrelatedJitter.md
deleted file mode 100644
index d11552c8..00000000
--- a/website/src/content/docs/api/decorrelatedJitter.md
+++ /dev/null
@@ -1,40 +0,0 @@
----
-title: "decorrelatedJitter()"
-description: "Decorrelated jitter (AWS-recommended): `random(baseNs, min(maxNs, lastDelay * 3))`.\n\nStateless — uses `prevDelayNs` (passed by the consumer) instead of closure "
----
-
-Decorrelated jitter (AWS-recommended): `random(baseNs, min(maxNs, lastDelay * 3))`.
-
-Stateless — uses `prevDelayNs` (passed by the consumer) instead of closure state.
-Safe to share across concurrent retry sequences.
-
-## Signature
-
-```ts
-function decorrelatedJitter(
-	baseNs = 100 * NS_PER_MS,
-	maxNs = 30 * NS_PER_SEC,
-): BackoffStrategy
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>baseNs</code> | <code>unknown</code> | Floor of the random range (default `100ms` in nanoseconds). |
-| <code>maxNs</code> | <code>unknown</code> | Ceiling cap (default `30s` in nanoseconds). |
-
-## Returns
-
-`BackoffStrategy` for retry.
-
-## Basic Usage
-
-```ts
-import { decorrelatedJitter, retry, NS_PER_MS, NS_PER_SEC } from "@graphrefly/graphrefly";
-
-const out = retry(source, {
-    count: 6,
-    backoff: decorrelatedJitter(100 * NS_PER_MS, 10 * NS_PER_SEC),
-  });
-```
diff --git a/website/src/content/docs/api/delay.md b/website/src/content/docs/api/delay.md
deleted file mode 100644
index 47a4a0c3..00000000
--- a/website/src/content/docs/api/delay.md
+++ /dev/null
@@ -1,32 +0,0 @@
----
-title: "delay()"
-description: "Delays phase-2 emissions by `ms` (timers). `DIRTY` still forwards immediately."
----
-
-Delays phase-2 emissions by `ms` (timers). `DIRTY` still forwards immediately.
-
-## Signature
-
-```ts
-function delay<T>(source: Node<T>, ms: number, opts?: ExtraOpts): Node<T>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>source</code> | <code>Node&lt;T&gt;</code> | Upstream node. |
-| <code>ms</code> | <code>number</code> | Delay in milliseconds. |
-| <code>opts</code> | <code>ExtraOpts</code> | Optional NodeOptions (excluding `describeKind`). |
-
-## Returns
-
-`Node&lt;T&gt;` - Same values, shifted in time.
-
-## Basic Usage
-
-```ts
-import { delay, state } from "@graphrefly/pure-ts";
-
-delay(state(1), 100);
-```
diff --git a/website/src/content/docs/api/derived.md b/website/src/content/docs/api/derived.md
deleted file mode 100644
index abf4119f..00000000
--- a/website/src/content/docs/api/derived.md
+++ /dev/null
@@ -1,43 +0,0 @@
----
-title: "derived()"
-description: "Creates a derived node that computes **one output per wave** from the latest\nvalue of each dependency — **snapshot / combine semantics**.\n\n`fn` receives one sca"
----
-
-Creates a derived node that computes **one output per wave** from the latest
-value of each dependency — **snapshot / combine semantics**.
-
-`fn` receives one scalar per dep (the last DATA value seen this wave, or the
-prior-wave value as fallback). It is called once per settled wave and emits
-a single value via `actions.emit`. The equals check then suppresses the
-emission as `RESOLVED` if the output has not changed.
-
-**Not for streaming one-to-one transforms.** If each DATA value in a batch
-must produce a corresponding output (e.g. transforming every item emitted by
-`fromIter` individually), use map or raw `node()` with full batch
-iteration instead. `derived` only sees the *last* value per dep when a batch
-carries multiple DATAs.
-
-## Signature
-
-```ts
-function derived<T = unknown>(
-	deps: readonly Node[],
-	fn: DerivedFn<T>,
-	opts?: NodeOptions<T>,
-): Node<T>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| `deps` | `readonly Node[]` |  |
-| `fn` | `DerivedFn&lt;T&gt;` |  |
-| `opts` | `NodeOptions&lt;T&gt;` |  |
-
-## Basic Usage
-
-```ts
-const a = state(1);
-const b = derived([a], ([x]) => (x as number) * 2);
-```
diff --git a/website/src/content/docs/api/derivedT.md b/website/src/content/docs/api/derivedT.md
deleted file mode 100644
index 7933afdf..00000000
--- a/website/src/content/docs/api/derivedT.md
+++ /dev/null
@@ -1,47 +0,0 @@
----
-title: "derivedT()"
-description: "Typed-tuple variant of derived. Use when the dep types matter at\nthe callback boundary — `data` is inferred as a tuple of dep value types\ninstead of `readonly u"
----
-
-Typed-tuple variant of derived. Use when the dep types matter at
-the callback boundary — `data` is inferred as a tuple of dep value types
-instead of `readonly unknown[]`.
-
-Same runtime semantics as derived (first-run gate, snapshot
-combine semantics, equals substitution).
-
-**`partial: true` is rejected at the type level (qa F-E, 2026-04-29).**
-Tuple slots in `NodeValues&lt;TDeps&gt;` resolve to `V` (never `V | undefined`),
-but `partial: true` lets fn run before every dep has fired. The two are
-unsound together — fn would receive `undefined` for an unfired dep but
-see it typed as `V`. Callers needing partial firing keep using untyped
-derived where `data` is `readonly unknown[]` and the
-`=== undefined` guard is sanctioned (COMPOSITION-GUIDE §3 partial-true
-exception).
-
-## Signature
-
-```ts
-function derivedT<TDeps extends readonly Node<unknown>[], TOut>(
-	deps: TDeps,
-	fn: DerivedTFn<TDeps, TOut>,
-	opts?: Omit<NodeOptions<TOut>, "partial"> & { partial?: false },
-): Node<TOut>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| `deps` | `TDeps` |  |
-| `fn` | `DerivedTFn&lt;TDeps, TOut&gt;` |  |
-| `opts` | `Omit&lt;NodeOptions&lt;TOut&gt;, "partial"&gt; & { partial?: false }` |  |
-
-## Basic Usage
-
-```ts
-const a = state(1);
-const b = state("hi");
-// sum: number, label: string — no casts needed.
-const out = derivedT([a, b], ([sum, label]) => `${label}:${sum * 2}`);
-```
diff --git a/website/src/content/docs/api/dictKv.md b/website/src/content/docs/api/dictKv.md
deleted file mode 100644
index 8a24eadd..00000000
--- a/website/src/content/docs/api/dictKv.md
+++ /dev/null
@@ -1,41 +0,0 @@
----
-title: "dictKv()"
-description: "Creates a kv tier backed by a caller-owned plain object (`Record<string, Uint8Array>`).\n\nUseful for embedding storage inside a parent state shape or for tests t"
----
-
-Creates a kv tier backed by a caller-owned plain object (`Record&lt;string, Uint8Array&gt;`).
-
-Useful for embedding storage inside a parent state shape or for tests that
-need direct access to the raw bytes. The dict stores raw encoded bytes as
-`Uint8Array`. Use `opts.name` to control the tier's diagnostic name
-(defaults to `"dict-kv"`).
-
-## Signature
-
-```ts
-function dictKv<T>(
-	storage: Record<string, Uint8Array>,
-	opts?: Omit<KvStorageOptions<T>, "name"> & { name?: string },
-): KvStorageTier<T>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>storage</code> | <code>Record&lt;string, Uint8Array&gt;</code> | Caller-owned `Record&lt;string, Uint8Array&gt;` to use as the backing store. |
-| <code>opts</code> | <code>Omit&lt;KvStorageOptions&lt;T&gt;, "name"&gt; & { name?: string }</code> | Optional kv storage options (name, codec, filter, debounce, compactEvery). |
-
-## Returns
-
-`KvStorageTier&lt;T&gt;` backed by the provided dict object.
-
-## Basic Usage
-
-```ts
-import { dictKv } from "@graphrefly/graphrefly/extra";
-
-const store: Record<string, Uint8Array> = {};
-const tier = dictKv<{ score: number }>(store);
-await tier.save("player1", { score: 100 });
-```
diff --git a/website/src/content/docs/api/dictSnapshot.md b/website/src/content/docs/api/dictSnapshot.md
deleted file mode 100644
index dcb3cb2a..00000000
--- a/website/src/content/docs/api/dictSnapshot.md
+++ /dev/null
@@ -1,44 +0,0 @@
----
-title: "dictSnapshot()"
-description: "Creates a snapshot tier backed by a caller-owned plain object (`Record<string, Uint8Array>`).\n\nUseful for embedding checkpoints inside a parent state shape or f"
----
-
-Creates a snapshot tier backed by a caller-owned plain object (`Record&lt;string, Uint8Array&gt;`).
-
-Useful for embedding checkpoints inside a parent state shape or for tests
-that need direct access to the raw bytes. The dict stores raw JSON bytes as
-`Uint8Array`. Use `opts.name` to control the storage key (defaults to
-`"snapshot"`).
-
-## Signature
-
-```ts
-function dictSnapshot<T>(
-	storage: Record<string, Uint8Array>,
-	opts?: Omit<SnapshotStorageOptions<T>, "name"> & { name?: string },
-): SnapshotStorageTier<T>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>storage</code> | <code>Record&lt;string, Uint8Array&gt;</code> | Caller-owned `Record&lt;string, Uint8Array&gt;` to use as the backing store. |
-| <code>opts</code> | <code>Omit&lt;SnapshotStorageOptions&lt;T&gt;, "name"&gt; & { name?: string }</code> | Optional snapshot storage options (name, codec, filter, keyOf, debounce, compactEvery). |
-
-## Returns
-
-`SnapshotStorageTier&lt;T&gt;` backed by the provided dict object.
-
-## Basic Usage
-
-```ts
-import { dictKv, dictSnapshot } from "@graphrefly/graphrefly/extra";
-
-const store: Record<string, Uint8Array> = {};
-// Phase 14.6 paired-tier shape — pair with a kv tier for WAL replay,
-// or omit `wal` for baseline-only persistence.
-graph.attachSnapshotStorage([
-    { snapshot: dictSnapshot(store, { name: graph.name }), wal: dictKv(store) },
-  ]);
-```
diff --git a/website/src/content/docs/api/dictStorage.md b/website/src/content/docs/api/dictStorage.md
deleted file mode 100644
index cbb140f2..00000000
--- a/website/src/content/docs/api/dictStorage.md
+++ /dev/null
@@ -1,32 +0,0 @@
----
-title: "dictStorage()"
-description: "Dict-backed storage tier — stores JSON-cloned values under caller keys in\na caller-owned plain object. Useful for embedding in a parent state shape."
----
-
-Dict-backed storage tier — stores JSON-cloned values under caller keys in
-a caller-owned plain object. Useful for embedding in a parent state shape.
-
-## Signature
-
-```ts
-function dictStorage(storage: Record<string, unknown>): StorageTier
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| `storage` | `Record&lt;string, unknown&gt;` | Caller-owned object used as the backing store. |
-
-## Returns
-
-Sync StorageTier.
-
-## Basic Usage
-
-```ts
-import { dictStorage } from "@graphrefly/graphrefly-ts";
-
-const state: Record<string, unknown> = {};
-graph.attachStorage([dictStorage(state)]);
-```
diff --git a/website/src/content/docs/api/dispatchKeyOf.md b/website/src/content/docs/api/dispatchKeyOf.md
deleted file mode 100644
index 58ed4c57..00000000
--- a/website/src/content/docs/api/dispatchKeyOf.md
+++ /dev/null
@@ -1,16 +0,0 @@
----
-title: "dispatchKeyOf()"
-description: "API reference for dispatchKeyOf."
----
-
-## Signature
-
-```ts
-dispatchKeyOf<T>(r: DispatchRecord<T>): string
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>r</code> | <code>DispatchRecord&lt;T&gt;</code> |  |
diff --git a/website/src/content/docs/api/distill.md b/website/src/content/docs/api/distill.md
deleted file mode 100644
index bacc7e2d..00000000
--- a/website/src/content/docs/api/distill.md
+++ /dev/null
@@ -1,37 +0,0 @@
----
-title: "distill()"
-description: "Budget-constrained reactive memory composition.\n\n**Tier 1.5.4 (Session A.5 lock, 2026-04-27):** `extractFn` receives the\nsource and existing-store as `Node`s. D"
----
-
-Budget-constrained reactive memory composition.
-
-**Tier 1.5.4 (Session A.5 lock, 2026-04-27):** `extractFn` receives the
-source and existing-store as `Node`s. Distill calls `extractFn` ONCE at
-wiring time and consumes the returned stream of extractions. The user
-controls reactive composition — wrap with `switchMap` for cancel-on-new-input,
-`mergeMap` for parallel, `derived` for sync transforms. See COMPOSITION-GUIDE
-§40 for the recipe.
-
-## Signature
-
-```ts
-function distill<TRaw, TMem>(
-	source: NodeInput<TRaw>,
-	extractFn: (
-		raw: Node<TRaw>,
-		existing: Node<ReadonlyMap<string, TMem>>,
-	) => NodeInput<Extraction<TMem>>,
-	opts: DistillOptions<TMem>,
-): DistillBundle<TMem>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>source</code> | <code>NodeInput&lt;TRaw&gt;</code> |  |
-| <code>extractFn</code> | <code>(
-		raw: Node&lt;TRaw&gt;,
-		existing: Node&lt;ReadonlyMap&lt;string, TMem&gt;&gt;,
-	) =&gt; NodeInput&lt;Extraction&lt;TMem&gt;&gt;</code> |  |
-| <code>opts</code> | <code>DistillOptions&lt;TMem&gt;</code> |  |
diff --git a/website/src/content/docs/api/distinctUntilChanged.md b/website/src/content/docs/api/distinctUntilChanged.md
deleted file mode 100644
index 5b0d5869..00000000
--- a/website/src/content/docs/api/distinctUntilChanged.md
+++ /dev/null
@@ -1,36 +0,0 @@
----
-title: "distinctUntilChanged()"
-description: "Suppresses adjacent duplicates using `equals` (default `Object.is`)."
----
-
-Suppresses adjacent duplicates using `equals` (default `Object.is`).
-
-## Signature
-
-```ts
-function distinctUntilChanged<T>(
-	source: Node<T>,
-	equals: (a: T, b: T) => boolean = Object.is,
-	opts?: ExtraOpts,
-): Node<T>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>source</code> | <code>Node&lt;T&gt;</code> | Upstream node. |
-| <code>equals</code> | <code>(a: T, b: T) =&gt; boolean</code> | Optional equality for consecutive values. |
-| <code>opts</code> | <code>ExtraOpts</code> | Optional NodeOptions (excluding `describeKind`). |
-
-## Returns
-
-`Node&lt;T&gt;` - Deduped stream.
-
-## Basic Usage
-
-```ts
-import { distinctUntilChanged, state } from "@graphrefly/pure-ts";
-
-const n = distinctUntilChanged(state(1));
-```
diff --git a/website/src/content/docs/api/downWithBatch.md b/website/src/content/docs/api/downWithBatch.md
deleted file mode 100644
index 56be29f4..00000000
--- a/website/src/content/docs/api/downWithBatch.md
+++ /dev/null
@@ -1,42 +0,0 @@
----
-title: "downWithBatch()"
-description: "Deliver pre-sorted messages through `sink` with tier-based deferral applied.\n\n`messages` MUST be in ascending tier order (produced by `_frameBatch` in\n`node.ts`"
----
-
-Deliver pre-sorted messages through `sink` with tier-based deferral applied.
-
-`messages` MUST be in ascending tier order (produced by `_frameBatch` in
-`node.ts`); the walker exploits that invariant to find phase cuts in one
-pass without re-sorting.
-
-Behavior (post-DS-13.5.A tier renumbering):
-- Tier 0–2 — delivered synchronously.
-- Tier 3 (DATA/RESOLVED) — deferred to drainPhase2 when batching.
-- Tier 4 (INVALIDATE) — deferred to drainPhase2 alongside the value
-  settlements (the "settle slice" — INVALIDATE settles a wave so it must
-  land in the same drain phase as DATA/RESOLVED).
-- Tier 5 (COMPLETE/ERROR) — deferred to drainPhase3 when batching.
-- Tier 6 (TEARDOWN) — deferred to drainPhase4 when batching.
-
-Tier-classification uses the caller-supplied `tierOf` so that batch stays
-decoupled from `GraphReFlyConfig`. NodeImpl passes `config.tierOf` (a
-pre-bound closure built once in the config constructor) at the emit site;
-alternate configs can pass their own lookup.
-
-## Signature
-
-```ts
-function downWithBatch(
-	sink: (messages: Messages) => void,
-	messages: Messages,
-	tierOf: (t: symbol) => number,
-): void
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>sink</code> | <code>(messages: Messages) =&gt; void</code> |  |
-| <code>messages</code> | <code>Messages</code> |  |
-| <code>tierOf</code> | <code>(t: symbol) =&gt; number</code> |  |
diff --git a/website/src/content/docs/api/dryRunAdapter.md b/website/src/content/docs/api/dryRunAdapter.md
deleted file mode 100644
index 4b59e5cd..00000000
--- a/website/src/content/docs/api/dryRunAdapter.md
+++ /dev/null
@@ -1,25 +0,0 @@
----
-title: "dryRunAdapter()"
-description: "Create a DryRun adapter."
----
-
-Create a DryRun adapter.
-
-## Signature
-
-```ts
-function dryRunAdapter(opts: DryRunAdapterOptions = {}): LLMAdapter
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>opts</code> | <code>DryRunAdapterOptions</code> |  |
-
-## Basic Usage
-
-```ts
-const adapter = dryRunAdapter({ respond: (msgs) => "hello from dry-run" });
-const resp = await Promise.resolve(adapter.invoke([{ role: "user", content: "hi" }]));
-```
diff --git a/website/src/content/docs/api/dryRunPreset.md b/website/src/content/docs/api/dryRunPreset.md
deleted file mode 100644
index 206f043d..00000000
--- a/website/src/content/docs/api/dryRunPreset.md
+++ /dev/null
@@ -1,10 +0,0 @@
----
-title: "dryRunPreset()"
-description: "API reference for dryRunPreset."
----
-
-## Signature
-
-```ts
-function dryRunPreset(): LLMAdapter
-```
diff --git a/website/src/content/docs/api/dynamicNode.md b/website/src/content/docs/api/dynamicNode.md
deleted file mode 100644
index 47881995..00000000
--- a/website/src/content/docs/api/dynamicNode.md
+++ /dev/null
@@ -1,52 +0,0 @@
----
-title: "dynamicNode()"
-description: "Creates a node with runtime dep tracking. Deps are discovered each time the\ncompute function runs by tracking which nodes are passed to the `get()` proxy.\n\nAfte"
----
-
-Creates a node with runtime dep tracking. Deps are discovered each time the
-compute function runs by tracking which nodes are passed to the `get()` proxy.
-
-After each recompute:
-- New deps (not in previous set) are subscribed
-- Removed deps (not in current set) are unsubscribed
-- Kept deps retain their existing subscriptions
-
-The node participates in diamond resolution via the pre-set dirty mask
-(shared with NodeImpl).
-
-**Lazy-dep composition:** when a tracked dep is itself a lazy compute node
-whose first subscribe causes a fresh value to arrive, the rewire buffer
-detects the discrepancy and re-runs fn once so it observes the real value.
-Capped at MAX_RERUN iterations.
-
-## Signature
-
-```ts
-function dynamicNode<T = unknown>(fn: DynamicNodeFn<T>, opts?: DynamicNodeOptions): Node<T>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| `fn` | `DynamicNodeFn&lt;T&gt;` | Compute function receiving a tracking `get` proxy. |
-| `opts` | `DynamicNodeOptions` | Optional configuration. |
-
-## Returns
-
-`Node&lt;T&gt;` with dynamic dep tracking.
-
-## Basic Usage
-
-```ts
-import { dynamicNode, state } from "@graphrefly/graphrefly-ts";
-
-const cond = state(true);
-const a = state(1);
-const b = state(2);
-
-const d = dynamicNode((get) => {
-    const useA = get(cond);
-    return useA ? get(a) : get(b);
-  });
-```
diff --git a/website/src/content/docs/api/effect.md b/website/src/content/docs/api/effect.md
deleted file mode 100644
index 48d9fe0c..00000000
--- a/website/src/content/docs/api/effect.md
+++ /dev/null
@@ -1,32 +0,0 @@
----
-title: "effect()"
-description: "Runs a side-effect when deps settle. Return value is not auto-emitted."
----
-
-Runs a side-effect when deps settle. Return value is not auto-emitted.
-
-## Signature
-
-```ts
-function effect(
-	deps: readonly Node[],
-	fn: EffectFn,
-	opts?: NodeOptions<unknown>,
-): Node<unknown>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| `deps` | `readonly Node[]` |  |
-| `fn` | `EffectFn` |  |
-| `opts` | `NodeOptions&lt;unknown&gt;` |  |
-
-## Basic Usage
-
-```ts
-effect([source], ([v]) => {
-    console.log(v);
-  });
-```
diff --git a/website/src/content/docs/api/effectT.md b/website/src/content/docs/api/effectT.md
deleted file mode 100644
index 26dd397e..00000000
--- a/website/src/content/docs/api/effectT.md
+++ /dev/null
@@ -1,42 +0,0 @@
----
-title: "effectT()"
-description: "Typed-tuple variant of effect. Use when the dep types matter at\nthe callback boundary — `data` is inferred as a tuple of dep value types\ninstead of `readonly un"
----
-
-Typed-tuple variant of effect. Use when the dep types matter at
-the callback boundary — `data` is inferred as a tuple of dep value types
-instead of `readonly unknown[]`.
-
-Same runtime semantics as effect (first-run gate, no auto-emit,
-cleanup contract).
-
-**`partial: true` is rejected at the type level (qa F-E, 2026-04-29).**
-See derivedT for the soundness rationale.
-
-## Signature
-
-```ts
-function effectT<TDeps extends readonly Node<unknown>[]>(
-	deps: TDeps,
-	fn: EffectTFn<TDeps>,
-	opts?: Omit<NodeOptions<unknown>, "partial"> & { partial?: false },
-): Node<unknown>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| `deps` | `TDeps` |  |
-| `fn` | `EffectTFn&lt;TDeps&gt;` |  |
-| `opts` | `Omit&lt;NodeOptions&lt;unknown&gt;, "partial"&gt; & { partial?: false }` |  |
-
-## Basic Usage
-
-```ts
-const user = state<User | null>(null);
-const cfg = state<Config>(defaultCfg);
-effectT([user, cfg], ([u, c]) => {
-    if (u != null) hydrate(u, c);
-  });
-```
diff --git a/website/src/content/docs/api/elementAt.md b/website/src/content/docs/api/elementAt.md
deleted file mode 100644
index b82d5731..00000000
--- a/website/src/content/docs/api/elementAt.md
+++ /dev/null
@@ -1,32 +0,0 @@
----
-title: "elementAt()"
-description: "Emits the `index`th **`DATA`** (zero-based), then **`COMPLETE`**."
----
-
-Emits the `index`th **`DATA`** (zero-based), then **`COMPLETE`**.
-
-## Signature
-
-```ts
-function elementAt<T>(source: Node<T>, index: number, opts?: ExtraOpts): Node<T>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>source</code> | <code>Node&lt;T&gt;</code> | Upstream node. |
-| <code>index</code> | <code>number</code> | Zero-based emission index. |
-| <code>opts</code> | <code>ExtraOpts</code> | Optional NodeOptions (excluding `describeKind`). |
-
-## Returns
-
-`Node&lt;T&gt;` - Single indexed value.
-
-## Basic Usage
-
-```ts
-import { elementAt, state } from "@graphrefly/pure-ts";
-
-const n = elementAt(state(0), 2);
-```
diff --git a/website/src/content/docs/api/empty.md b/website/src/content/docs/api/empty.md
deleted file mode 100644
index e0f869b9..00000000
--- a/website/src/content/docs/api/empty.md
+++ /dev/null
@@ -1,30 +0,0 @@
----
-title: "empty()"
-description: "Completes immediately with no `DATA` (cold `EMPTY` analogue)."
----
-
-Completes immediately with no `DATA` (cold `EMPTY` analogue).
-
-## Signature
-
-```ts
-function empty<T = never>(opts?: ExtraOpts): Node<T>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>opts</code> | <code>ExtraOpts</code> | Optional producer options. |
-
-## Returns
-
-`Node&lt;T&gt;` — terminal `COMPLETE` only.
-
-## Basic Usage
-
-```ts
-import { empty } from "@graphrefly/pure-ts";
-
-empty();
-```
diff --git a/website/src/content/docs/api/exhaustMap.md b/website/src/content/docs/api/exhaustMap.md
deleted file mode 100644
index 487c83c7..00000000
--- a/website/src/content/docs/api/exhaustMap.md
+++ /dev/null
@@ -1,36 +0,0 @@
----
-title: "exhaustMap()"
-description: "Like switchMap, but ignores outer `DATA` while an inner subscription is active (`exhaustMap`)."
----
-
-Like switchMap, but ignores outer `DATA` while an inner subscription is active (`exhaustMap`).
-
-## Signature
-
-```ts
-function exhaustMap<T, R>(
-	source: Node<T>,
-	project: (value: T) => NodeInput<R>,
-	opts?: HigherOrderOpts,
-): Node<R>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>source</code> | <code>Node&lt;T&gt;</code> | Upstream node. |
-| <code>project</code> | <code>(value: T) =&gt; NodeInput&lt;R&gt;</code> | Maps each outer value to an inner source shape (`Node`, scalar, `PromiseLike`, `Iterable`, or `AsyncIterable`) coerced via fromAny. |
-| <code>opts</code> | <code>HigherOrderOpts</code> | Optional NodeOptions (excluding `describeKind`). |
-
-## Returns
-
-`Node&lt;R&gt;` - Emissions from the active inner while it runs.
-
-## Basic Usage
-
-```ts
-import { exhaustMap, state } from "@graphrefly/pure-ts";
-
-exhaustMap(state(0), () => state(1));
-```
diff --git a/website/src/content/docs/api/explainPath.md b/website/src/content/docs/api/explainPath.md
deleted file mode 100644
index c8896da6..00000000
--- a/website/src/content/docs/api/explainPath.md
+++ /dev/null
@@ -1,39 +0,0 @@
----
-title: "explainPath()"
-description: "Walks backward from `to` through `deps` to find the shortest path to `from`,\nthen assembles an ordered, enriched CausalChain."
----
-
-Walks backward from `to` through `deps` to find the shortest path to `from`,
-then assembles an ordered, enriched CausalChain.
-
-## Signature
-
-```ts
-function explainPath(
-	described: GraphDescribeOutput,
-	from: string,
-	to: string,
-	opts: ExplainPathOptions = {},
-): CausalChain
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>described</code> | <code>GraphDescribeOutput</code> | `graph.describe()` output (any detail level; richer detail → richer steps). |
-| <code>from</code> | <code>string</code> | Path of the upstream node (the cause). |
-| <code>to</code> | <code>string</code> | Path of the downstream node (the effect). |
-| <code>opts</code> | <code>ExplainPathOptions</code> | Optional `maxDepth` and per-path annotation overlays. |
-
-## Returns
-
-A CausalChain — `found:false` with a `reason` when no path exists.
-
-## Basic Usage
-
-```ts
-import { explainPath } from "@graphrefly/pure-ts";
-const chain = explainPath(graph.describe({ detail: "standard" }), "input", "result");
-console.log(chain.text);
-```
diff --git a/website/src/content/docs/api/exponential.md b/website/src/content/docs/api/exponential.md
deleted file mode 100644
index c0b23de3..00000000
--- a/website/src/content/docs/api/exponential.md
+++ /dev/null
@@ -1,38 +0,0 @@
----
-title: "exponential()"
-description: "Builds exponential backoff in nanoseconds, capped by `maxDelayNs`, with optional jitter."
----
-
-Builds exponential backoff in nanoseconds, capped by `maxDelayNs`, with optional jitter.
-
-## Signature
-
-```ts
-function exponential(options?: ExponentialBackoffOptions): BackoffStrategy
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>options</code> | <code>ExponentialBackoffOptions</code> | Base, factor, cap, and jitter mode. |
-
-## Returns
-
-`BackoffStrategy` for retry.
-
-## Basic Usage
-
-```ts
-import { exponential, retry, NS_PER_SEC } from "@graphrefly/graphrefly";
-
-// 100 ms → 200 ms → 400 ms … capped at 30 s, with full jitter
-const out = retry(source, {
-    count: 5,
-    backoff: exponential({ baseNs: 100 * NS_PER_SEC / 1000, jitter: "full" }),
-  });
-```
-
-## Behavior Details
-
-- **Jitter:** `"full"` spreads delay across `[0, delay]`; `"equal"` uses `[delay/2, delay]`.
diff --git a/website/src/content/docs/api/feedback.md b/website/src/content/docs/api/feedback.md
deleted file mode 100644
index 4b3650dd..00000000
--- a/website/src/content/docs/api/feedback.md
+++ /dev/null
@@ -1,37 +0,0 @@
----
-title: "feedback()"
-description: "Introduce a bounded reactive cycle into an existing graph.\n\nWhen `condition` emits a non-null DATA value, the feedback effect routes it\nback to the `reentry` st"
----
-
-Introduce a bounded reactive cycle into an existing graph.
-
-When `condition` emits a non-null DATA value, the feedback effect routes it
-back to the `reentry` state node — creating a cycle. Bounded by
-`maxIterations` (default 10). The counter node (`__feedback_&lt;condition&gt;`)
-is the source of truth — reset it to 0 to allow more iterations.
-
-To remove the feedback cycle, call `graph.remove("__feedback_&lt;condition&gt;")`.
-
-## Signature
-
-```ts
-function feedback(
-	graph: Graph,
-	condition: string,
-	reentry: string,
-	opts?: FeedbackOptions,
-): Graph
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>graph</code> | <code>Graph</code> | Existing graph to augment with a feedback cycle. |
-| <code>condition</code> | <code>string</code> | Path to a node whose DATA triggers feedback. |
-| <code>reentry</code> | <code>string</code> | Path to a state node that receives the feedback value. |
-| <code>opts</code> | <code>FeedbackOptions</code> | Iteration bounds and metadata. |
-
-## Returns
-
-The same graph (mutated with feedback nodes added).
diff --git a/website/src/content/docs/api/fibonacci.md b/website/src/content/docs/api/fibonacci.md
deleted file mode 100644
index 25c66a32..00000000
--- a/website/src/content/docs/api/fibonacci.md
+++ /dev/null
@@ -1,32 +0,0 @@
----
-title: "fibonacci()"
-description: "Builds Fibonacci-scaled delays: `1, 2, 3, 5, … × baseNs`, capped at `maxDelayNs`."
----
-
-Builds Fibonacci-scaled delays: `1, 2, 3, 5, … × baseNs`, capped at `maxDelayNs`.
-
-## Signature
-
-```ts
-function fibonacci(baseNs = 100 * NS_PER_MS, maxDelayNs = 30 * NS_PER_SEC): BackoffStrategy
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>baseNs</code> | <code>unknown</code> | Multiplier applied to the Fibonacci unit (default `100ms` in nanoseconds). |
-| <code>maxDelayNs</code> | <code>unknown</code> | Upper bound in nanoseconds (default `30s`). |
-
-## Returns
-
-`BackoffStrategy` for retry.
-
-## Basic Usage
-
-```ts
-import { fibonacci, retry, NS_PER_MS } from "@graphrefly/graphrefly";
-
-// Delays: 100 ms, 200 ms, 300 ms, 500 ms, 800 ms … (× 100 ms base)
-const out = retry(source, { count: 5, backoff: fibonacci(100 * NS_PER_MS) });
-```
diff --git a/website/src/content/docs/api/fileAppendLog.md b/website/src/content/docs/api/fileAppendLog.md
deleted file mode 100644
index fb88f2ce..00000000
--- a/website/src/content/docs/api/fileAppendLog.md
+++ /dev/null
@@ -1,38 +0,0 @@
----
-title: "fileAppendLog()"
-description: "Creates a filesystem append-log tier backed by a `fileBackend` under `dir`.\n\nConvenience wrapper for `appendLogStorage(fileBackend(dir), opts)`.\nWrites are atom"
----
-
-Creates a filesystem append-log tier backed by a `fileBackend` under `dir`.
-
-Convenience wrapper for `appendLogStorage(fileBackend(dir), opts)`.
-Writes are atomic (temp + rename). Requires Node.js with filesystem access.
-
-## Signature
-
-```ts
-function fileAppendLog<T>(
-	dir: string,
-	opts?: Omit<AppendLogStorageOptions<T>, "name"> & { name?: string },
-): AppendLogStorageTier<T>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>dir</code> | <code>string</code> | Directory path where append-log files are stored. |
-| <code>opts</code> | <code>Omit&lt;AppendLogStorageOptions&lt;T&gt;, "name"&gt; & { name?: string }</code> | Optional append-log storage options (name, codec, keyOf, debounce, compactEvery). |
-
-## Returns
-
-`AppendLogStorageTier&lt;T&gt;` backed by the filesystem.
-
-## Basic Usage
-
-```ts
-import { fileAppendLog } from "@graphrefly/graphrefly/extra/node";
-
-const tier = fileAppendLog<{ type: string; id: number }>("../events");
-await tier.appendEntries([{ type: "created", id: 1 }]);
-```
diff --git a/website/src/content/docs/api/fileBackend.md b/website/src/content/docs/api/fileBackend.md
deleted file mode 100644
index 77391dc3..00000000
--- a/website/src/content/docs/api/fileBackend.md
+++ /dev/null
@@ -1,35 +0,0 @@
----
-title: "fileBackend()"
-description: "Creates a filesystem backend that maps each key to a file under `dir`.\n\nWrites are atomic via temp + rename. Keys are percent-encoded to safe\nfilenames; `list(p"
----
-
-Creates a filesystem backend that maps each key to a file under `dir`.
-
-Writes are atomic via temp + rename. Keys are percent-encoded to safe
-filenames; `list(prefix)` enumerates `.bin` files in the directory.
-
-## Signature
-
-```ts
-function fileBackend(dir: string): StorageBackend
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>dir</code> | <code>string</code> | Directory path where key files are stored (created on first write). |
-
-## Returns
-
-`StorageBackend` backed by the filesystem under `dir`.
-
-## Basic Usage
-
-```ts
-import { fileBackend, snapshotStorage } from "@graphrefly/graphrefly/extra/node";
-
-const backend = fileBackend("../checkpoints");
-const tier = snapshotStorage(backend, { name: "my-graph" });
-await tier.save({ name: "my-graph", state: { count: 1 } });
-```
diff --git a/website/src/content/docs/api/fileKv.md b/website/src/content/docs/api/fileKv.md
deleted file mode 100644
index 46c00c91..00000000
--- a/website/src/content/docs/api/fileKv.md
+++ /dev/null
@@ -1,39 +0,0 @@
----
-title: "fileKv()"
-description: "Creates a filesystem key-value tier backed by a `fileBackend` under `dir`.\n\nConvenience wrapper for `kvStorage(fileBackend(dir), opts)`.\nEach key is stored as a"
----
-
-Creates a filesystem key-value tier backed by a `fileBackend` under `dir`.
-
-Convenience wrapper for `kvStorage(fileBackend(dir), opts)`.
-Each key is stored as a separate file; writes are atomic (temp + rename).
-
-## Signature
-
-```ts
-function fileKv<T>(
-	dir: string,
-	opts?: Omit<KvStorageOptions<T>, "name"> & { name?: string },
-): KvStorageTier<T>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>dir</code> | <code>string</code> | Directory path where key files are stored. |
-| <code>opts</code> | <code>Omit&lt;KvStorageOptions&lt;T&gt;, "name"&gt; & { name?: string }</code> | Optional kv storage options (name, codec, filter, debounce, compactEvery). |
-
-## Returns
-
-`KvStorageTier&lt;T&gt;` backed by the filesystem.
-
-## Basic Usage
-
-```ts
-import { fileKv } from "@graphrefly/graphrefly/extra/node";
-
-const kv = fileKv<{ score: number }>("../scores");
-await kv.save("player1", { score: 100 });
-const val = await kv.load("player1");
-```
diff --git a/website/src/content/docs/api/fileSnapshot.md b/website/src/content/docs/api/fileSnapshot.md
deleted file mode 100644
index 46273e99..00000000
--- a/website/src/content/docs/api/fileSnapshot.md
+++ /dev/null
@@ -1,38 +0,0 @@
----
-title: "fileSnapshot()"
-description: "Creates a filesystem snapshot tier backed by a `fileBackend` under `dir`.\n\nConvenience wrapper for `snapshotStorage(fileBackend(dir), opts)`.\nWrites are atomic "
----
-
-Creates a filesystem snapshot tier backed by a `fileBackend` under `dir`.
-
-Convenience wrapper for `snapshotStorage(fileBackend(dir), opts)`.
-Writes are atomic (temp + rename). Requires Node.js with filesystem access.
-
-## Signature
-
-```ts
-function fileSnapshot<T>(
-	dir: string,
-	opts?: Omit<SnapshotStorageOptions<T>, "name"> & { name?: string },
-): SnapshotStorageTier<T>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>dir</code> | <code>string</code> | Directory path where snapshot files are stored. |
-| <code>opts</code> | <code>Omit&lt;SnapshotStorageOptions&lt;T&gt;, "name"&gt; & { name?: string }</code> | Optional snapshot storage options (name, codec, filter, keyOf, debounce, compactEvery). |
-
-## Returns
-
-`SnapshotStorageTier&lt;T&gt;` backed by the filesystem.
-
-## Basic Usage
-
-```ts
-import { fileSnapshot } from "@graphrefly/graphrefly/extra/node";
-
-const tier = fileSnapshot<{ count: number }>("../checkpoints", { name: "counter" });
-await tier.save({ count: 1 });
-```
diff --git a/website/src/content/docs/api/fileStorage.md b/website/src/content/docs/api/fileStorage.md
deleted file mode 100644
index 7cf169c3..00000000
--- a/website/src/content/docs/api/fileStorage.md
+++ /dev/null
@@ -1,33 +0,0 @@
----
-title: "fileStorage()"
-description: "Atomic JSON file storage tier (one file per key in a directory, temp + rename).\n\nKeys are sanitized to filesystem-safe names (`[^a-zA-Z0-9_-]` → `%<hex>`).\n`loa"
----
-
-Atomic JSON file storage tier (one file per key in a directory, temp + rename).
-
-Keys are sanitized to filesystem-safe names (`[^a-zA-Z0-9_-]` → `%&lt;hex&gt;`).
-`load` returns `null` for missing files, empty files, or invalid JSON.
-
-## Signature
-
-```ts
-function fileStorage(dir: string): StorageTier
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| `dir` | `string` | Directory where per-key JSON files are written. |
-
-## Returns
-
-Sync StorageTier.
-
-## Basic Usage
-
-```ts
-import { fileStorage, memoryStorage } from "@graphrefly/graphrefly-ts";
-
-graph.attachStorage([memoryStorage(), fileStorage("./checkpoints")]);
-```
diff --git a/website/src/content/docs/api/filter.md b/website/src/content/docs/api/filter.md
deleted file mode 100644
index ecc1f146..00000000
--- a/website/src/content/docs/api/filter.md
+++ /dev/null
@@ -1,44 +0,0 @@
----
-title: "filter()"
-description: "Forwards values that satisfy `predicate`; otherwise emits `RESOLVED` with no `DATA` (two-phase semantics).\n\n**Wave-exclusivity contract** (COMPOSITION-GUIDE §41"
----
-
-Forwards values that satisfy `predicate`; otherwise emits `RESOLVED` with no `DATA` (two-phase semantics).
-
-**Wave-exclusivity contract** (COMPOSITION-GUIDE §41 / spec §1.3.3): the
-`RESOLVED` is emitted only when the entire wave produces zero passing
-values — never per-dropped-item, never trailing a wave that already
-emitted `DATA`. Mixed-batch inputs like `[v_pass, v_fail, v_pass2]`
-forward `[DATA, v_pass]` and `[DATA, v_pass2]` with no `RESOLVED` for
-the dropped middle entry. Consumers needing per-input drain accounting
-count upstream of `filter`, not on its output.
-
-## Signature
-
-```ts
-function filter<T>(
-	source: Node<T>,
-	predicate: (value: T) => boolean,
-	opts?: ExtraOpts,
-): Node<T>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>source</code> | <code>Node&lt;T&gt;</code> | Upstream node. |
-| <code>predicate</code> | <code>(value: T) =&gt; boolean</code> | Inclusion test. |
-| <code>opts</code> | <code>ExtraOpts</code> | Optional NodeOptions (excluding `describeKind`). |
-
-## Returns
-
-`Node&lt;T&gt;` - Filtered node.
-
-## Basic Usage
-
-```ts
-import { filter, state } from "@graphrefly/pure-ts";
-
-const n = filter(state(1), (x) => x > 0);
-```
diff --git a/website/src/content/docs/api/find.md b/website/src/content/docs/api/find.md
deleted file mode 100644
index b2593aac..00000000
--- a/website/src/content/docs/api/find.md
+++ /dev/null
@@ -1,36 +0,0 @@
----
-title: "find()"
-description: "Emits the first value matching `predicate`, then **`COMPLETE`**."
----
-
-Emits the first value matching `predicate`, then **`COMPLETE`**.
-
-## Signature
-
-```ts
-function find<T>(
-	source: Node<T>,
-	predicate: (value: T) => boolean,
-	opts?: ExtraOpts,
-): Node<T>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>source</code> | <code>Node&lt;T&gt;</code> | Upstream node. |
-| <code>predicate</code> | <code>(value: T) =&gt; boolean</code> | Match test. |
-| <code>opts</code> | <code>ExtraOpts</code> | Optional NodeOptions (excluding `describeKind`). |
-
-## Returns
-
-`Node&lt;T&gt;` - First-match stream.
-
-## Basic Usage
-
-```ts
-import { find, state } from "@graphrefly/pure-ts";
-
-const n = find(state(1), (x) => x > 0);
-```
diff --git a/website/src/content/docs/api/first.md b/website/src/content/docs/api/first.md
deleted file mode 100644
index 701a4d6b..00000000
--- a/website/src/content/docs/api/first.md
+++ /dev/null
@@ -1,31 +0,0 @@
----
-title: "first()"
-description: "Emits the first **`DATA`** then **`COMPLETE`** (same as `take(source, 1)`)."
----
-
-Emits the first **`DATA`** then **`COMPLETE`** (same as `take(source, 1)`).
-
-## Signature
-
-```ts
-function first<T>(source: Node<T>, opts?: ExtraOpts): Node<T>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>source</code> | <code>Node&lt;T&gt;</code> | Upstream node. |
-| <code>opts</code> | <code>ExtraOpts</code> | Optional NodeOptions (excluding `describeKind`). |
-
-## Returns
-
-`Node&lt;T&gt;` - Single-value stream.
-
-## Basic Usage
-
-```ts
-import { first, state } from "@graphrefly/pure-ts";
-
-const n = first(state(42));
-```
diff --git a/website/src/content/docs/api/firstValueFrom.md b/website/src/content/docs/api/firstValueFrom.md
deleted file mode 100644
index 19c358cc..00000000
--- a/website/src/content/docs/api/firstValueFrom.md
+++ /dev/null
@@ -1,35 +0,0 @@
----
-title: "firstValueFrom()"
-description: "Converts the first `DATA` on `source` into a Promise; rejects on `ERROR` or `COMPLETE` without data.\n\n**Important:** This subscribes and waits for a **future** "
----
-
-Converts the first `DATA` on `source` into a Promise; rejects on `ERROR` or `COMPLETE` without data.
-
-**Important:** This subscribes and waits for a **future** emission. Data that
-has already flowed is gone and will not be seen. Call this *before* the upstream
-emits, or use `source.cache` / `source.status` for already-cached state.
-See COMPOSITION-GUIDE §2 (subscription ordering).
-
-## Signature
-
-```ts
-function firstValueFrom<T>(source: Node<T>): Promise<T>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>source</code> | <code>Node&lt;T&gt;</code> | Node to read once. |
-
-## Returns
-
-Promise of the first value.
-
-## Basic Usage
-
-```ts
-import { firstValueFrom, of } from "@graphrefly/graphrefly";
-
-await firstValueFrom(of(42));
-```
diff --git a/website/src/content/docs/api/flatMap.md b/website/src/content/docs/api/flatMap.md
deleted file mode 100644
index 5e76076f..00000000
--- a/website/src/content/docs/api/flatMap.md
+++ /dev/null
@@ -1,45 +0,0 @@
----
-title: "flatMap()"
-description: "RxJS-named alias for mergeMap — projects each `DATA` to an inner node and merges outputs."
----
-
-RxJS-named alias for mergeMap — projects each `DATA` to an inner node and merges outputs.
-
-## Signature
-
-```ts
-function mergeMap<T, R>(
-	source: Node<T>,
-	project: (value: T) => NodeInput<R>,
-	opts?: MergeMapOptions,
-): Node<R>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>source</code> | <code>Node&lt;T&gt;</code> | Upstream node. |
-| <code>project</code> | <code>(value: T) =&gt; NodeInput&lt;R&gt;</code> | Maps each outer value to an inner source shape (`Node`, scalar, `PromiseLike`, `Iterable`, or `AsyncIterable`) coerced via fromAny. |
-| <code>opts</code> | <code>MergeMapOptions</code> | Optional options including `concurrent` limit. |
-
-## Returns
-
-Merged projection; behavior matches `mergeMap`.
-
-## Basic Usage
-
-```ts
-import { flatMap, state } from "@graphrefly/pure-ts";
-
-flatMap(state(0), (n) => state(n));
-```
-
-## Behavior Details
-
-- **ERROR handling:** An `ERROR` from the outer source cancels all active inner
-subscriptions and propagates the error downstream. An `ERROR` from an inner
-subscription propagates downstream immediately but does **not** cancel sibling
-inner subscriptions — other active inners continue until they complete or the
-outer errors/completes. This is intentional: for parallel work, isolating
-failures per-inner is more useful than Rx-style "first error cancels all."
diff --git a/website/src/content/docs/api/forEach.md b/website/src/content/docs/api/forEach.md
deleted file mode 100644
index d5116023..00000000
--- a/website/src/content/docs/api/forEach.md
+++ /dev/null
@@ -1,33 +0,0 @@
----
-title: "forEach()"
-description: "Subscribes immediately and runs `fn` for each upstream `DATA`; returns unsubscribe."
----
-
-Subscribes immediately and runs `fn` for each upstream `DATA`; returns unsubscribe.
-
-## Signature
-
-```ts
-function forEach<T>(source: Node<T>, fn: (value: T) => void, opts?: ExtraOpts): () => void
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>source</code> | <code>Node&lt;T&gt;</code> | Upstream node. |
-| <code>fn</code> | <code>(value: T) =&gt; void</code> | Side effect per value. |
-| <code>opts</code> | <code>ExtraOpts</code> | Effect node options. |
-
-## Returns
-
-Unsubscribe function (idempotent).
-
-## Basic Usage
-
-```ts
-import { forEach, state } from "@graphrefly/graphrefly";
-
-const u = forEach(state(1), (v) => console.log(v));
-u();
-```
diff --git a/website/src/content/docs/api/fromAny.md b/website/src/content/docs/api/fromAny.md
deleted file mode 100644
index e47fc7ba..00000000
--- a/website/src/content/docs/api/fromAny.md
+++ /dev/null
@@ -1,26 +0,0 @@
----
-title: "fromAny()"
-description: "Coerces a `NodeInput<T>` (Node, scalar, Promise, Iterable, or AsyncIterable)\nto a `Node<T>`. Used by higher-order operators to normalise project returns.\n\nPass "
----
-
-Coerces a `NodeInput&lt;T&gt;` (Node, scalar, Promise, Iterable, or AsyncIterable)
-to a `Node&lt;T&gt;`. Used by higher-order operators to normalise project returns.
-
-Pass `{ iter: true }` to opt into fromIter dispatch for Iterables
-(otherwise Iterables are treated as single-value scalars via `of`).
-
-## Signature
-
-```ts
-function fromAny<T>(
-	input: NodeInput<T>,
-	opts?: AsyncSourceOpts & { iter?: boolean },
-): Node<T>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>input</code> | <code>NodeInput&lt;T&gt;</code> |  |
-| <code>opts</code> | <code>AsyncSourceOpts & { iter?: boolean }</code> |  |
diff --git a/website/src/content/docs/api/fromAsyncIter.md b/website/src/content/docs/api/fromAsyncIter.md
deleted file mode 100644
index e1152a28..00000000
--- a/website/src/content/docs/api/fromAsyncIter.md
+++ /dev/null
@@ -1,24 +0,0 @@
----
-title: "fromAsyncIter()"
-description: "Reads an async iterable; each `next()` value becomes `DATA`; `COMPLETE`\nwhen done; `ERROR` on failure."
----
-
-Reads an async iterable; each `next()` value becomes `DATA`; `COMPLETE`
-when done; `ERROR` on failure.
-
-## Signature
-
-```ts
-function fromAsyncIter<T>(iterable: AsyncIterable<T>, opts?: AsyncSourceOpts): Node<T>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>iterable</code> | <code>AsyncIterable&lt;T&gt;</code> | Async source (`for await` shape). |
-| <code>opts</code> | <code>AsyncSourceOpts</code> | Producer options plus optional `signal` to abort the pump. |
-
-## Returns
-
-`Node&lt;T&gt;` — async pull stream.
diff --git a/website/src/content/docs/api/fromCron.md b/website/src/content/docs/api/fromCron.md
deleted file mode 100644
index f5447a21..00000000
--- a/website/src/content/docs/api/fromCron.md
+++ /dev/null
@@ -1,18 +0,0 @@
----
-title: "fromCron()"
-description: "API reference for fromCron."
----
-
-## Signature
-
-```ts
-function fromCron(expr: string, opts?: FromCronOptions & { output: "date" }): Node<Date>
-function fromCron(expr: string, opts?: FromCronOptions): Node<number>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>expr</code> | <code>string</code> |  |
-| <code>opts</code> | <code>FromCronOptions</code> |  |
diff --git a/website/src/content/docs/api/fromEvent.md b/website/src/content/docs/api/fromEvent.md
deleted file mode 100644
index f1c29eb3..00000000
--- a/website/src/content/docs/api/fromEvent.md
+++ /dev/null
@@ -1,36 +0,0 @@
----
-title: "fromEvent()"
-description: "Wraps a DOM-style `addEventListener` target; each event becomes a `DATA` emission."
----
-
-Wraps a DOM-style `addEventListener` target; each event becomes a `DATA` emission.
-
-## Signature
-
-```ts
-function fromEvent<T = unknown>(
-	target: EventTargetLike,
-	type: string,
-	opts?: ExtraOpts & { capture?: boolean; passive?: boolean; once?: boolean },
-): Node<T>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>target</code> | <code>EventTargetLike</code> | Object with `addEventListener` / `removeEventListener`. |
-| <code>type</code> | <code>string</code> | Event name (e.g. `"click"`). |
-| <code>opts</code> | <code>ExtraOpts & { capture?: boolean; passive?: boolean; once?: boolean }</code> | Producer options plus listener options (`capture`, `passive`, `once`). |
-
-## Returns
-
-`Node&lt;T&gt;` — event payloads; teardown removes the listener.
-
-## Basic Usage
-
-```ts
-import { fromEvent } from "@graphrefly/graphrefly";
-
-fromEvent(document.body, "click");
-```
diff --git a/website/src/content/docs/api/fromIDBRequest.md b/website/src/content/docs/api/fromIDBRequest.md
deleted file mode 100644
index e1d1ecf5..00000000
--- a/website/src/content/docs/api/fromIDBRequest.md
+++ /dev/null
@@ -1,23 +0,0 @@
----
-title: "fromIDBRequest()"
-description: "Wraps an `IDBRequest` as a one-shot reactive source."
----
-
-Wraps an `IDBRequest` as a one-shot reactive source.
-
-## Signature
-
-```ts
-function fromIDBRequest<T>(req: IDBRequest<T>): Node<T>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>req</code> | <code>IDBRequest&lt;T&gt;</code> | Request whose callbacks are converted to protocol messages. |
-
-## Returns
-
-`Node&lt;T&gt;` that emits `DATA` once on success then `COMPLETE`;
-emits `ERROR` on failure.
diff --git a/website/src/content/docs/api/fromIDBTransaction.md b/website/src/content/docs/api/fromIDBTransaction.md
deleted file mode 100644
index c59345c5..00000000
--- a/website/src/content/docs/api/fromIDBTransaction.md
+++ /dev/null
@@ -1,23 +0,0 @@
----
-title: "fromIDBTransaction()"
-description: "Wraps an `IDBTransaction` terminal lifecycle as a one-shot reactive source."
----
-
-Wraps an `IDBTransaction` terminal lifecycle as a one-shot reactive source.
-
-## Signature
-
-```ts
-function fromIDBTransaction(tx: IDBTransaction): Node<void>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>tx</code> | <code>IDBTransaction</code> | Transaction to observe. |
-
-## Returns
-
-`Node&lt;void&gt;` that emits `DATA` (`undefined`) then `COMPLETE` on
-success; emits `ERROR` on `error`/`abort`.
diff --git a/website/src/content/docs/api/fromIter.md b/website/src/content/docs/api/fromIter.md
deleted file mode 100644
index 03901000..00000000
--- a/website/src/content/docs/api/fromIter.md
+++ /dev/null
@@ -1,31 +0,0 @@
----
-title: "fromIter()"
-description: "Drains a synchronous iterable; each item is `DATA`, then `COMPLETE`, or `ERROR` if iteration throws."
----
-
-Drains a synchronous iterable; each item is `DATA`, then `COMPLETE`, or `ERROR` if iteration throws.
-
-## Signature
-
-```ts
-function fromIter<T>(iterable: Iterable<T>, opts?: ExtraOpts): Node<T>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>iterable</code> | <code>Iterable&lt;T&gt;</code> | Values to emit in order. |
-| <code>opts</code> | <code>ExtraOpts</code> | Optional producer options. |
-
-## Returns
-
-`Node&lt;T&gt;` — one emission per element.
-
-## Basic Usage
-
-```ts
-import { fromIter } from "@graphrefly/pure-ts";
-
-fromIter([1, 2, 3]);
-```
diff --git a/website/src/content/docs/api/fromPromise.md b/website/src/content/docs/api/fromPromise.md
deleted file mode 100644
index 59ff697d..00000000
--- a/website/src/content/docs/api/fromPromise.md
+++ /dev/null
@@ -1,24 +0,0 @@
----
-title: "fromPromise()"
-description: "Lifts a Promise (or thenable) to a single-value stream: one `DATA` then\n`COMPLETE`, or `ERROR` on rejection."
----
-
-Lifts a Promise (or thenable) to a single-value stream: one `DATA` then
-`COMPLETE`, or `ERROR` on rejection.
-
-## Signature
-
-```ts
-function fromPromise<T>(p: Promise<T> | PromiseLike<T>, opts?: AsyncSourceOpts): Node<T>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>p</code> | <code>Promise&lt;T&gt; | PromiseLike&lt;T&gt;</code> | Promise to await. |
-| <code>opts</code> | <code>AsyncSourceOpts</code> | Producer options plus optional `signal` for abort → `ERROR`. |
-
-## Returns
-
-`Node&lt;T&gt;` — settles once.
diff --git a/website/src/content/docs/api/fromPushNotification.md b/website/src/content/docs/api/fromPushNotification.md
deleted file mode 100644
index e784f7f2..00000000
--- a/website/src/content/docs/api/fromPushNotification.md
+++ /dev/null
@@ -1,48 +0,0 @@
----
-title: "fromPushNotification()"
-description: "Wraps a host push transport; each delivered message becomes a `DATA`\nemission. Teardown invokes the registration's unsubscribe."
----
-
-Wraps a host push transport; each delivered message becomes a `DATA`
-emission. Teardown invokes the registration's unsubscribe.
-
-## Signature
-
-```ts
-function fromPushNotification<T = unknown>(
-	register: PushRegister<T>,
-	opts?: ExtraOpts,
-): Node<T>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>register</code> | <code>PushRegister&lt;T&gt;</code> | Called on activation with a `deliver(payload)` sink;
-returns an optional unsubscribe. |
-| <code>opts</code> | <code>ExtraOpts</code> | Producer node options (`name`, `meta`, …). |
-
-## Returns
-
-`Node&lt;T&gt;` — push payloads as a reactive stream.
-
-## Basic Usage
-
-```ts
-import { fromPushNotification } from "@graphrefly/graphrefly";
-
-// memo:Re premium backend — opt-in cloud audit pushed (not polled).
-const auditPushes = fromPushNotification<AuditEvent>((deliver) => {
-    const sub = messaging.onMessage((msg) => deliver(msg.data as AuditEvent));
-    return () => sub.remove();
-  });
-```
-
-## Behavior Details
-
-- A synchronous throw inside `register` propagates as an activation failure
-(it is not caught here) — same shape as `fromEvent`. Push transports are
-open-ended: this source never emits `COMPLETE`/`ERROR` on its own; the
-stream ends only via `onDeactivation` (unsubscribe). Surface a terminal
-yourself (e.g. compose a downstream operator) if the host needs one.
diff --git a/website/src/content/docs/api/fromRaf.md b/website/src/content/docs/api/fromRaf.md
index f20c8d0f..8a474e10 100644
--- a/website/src/content/docs/api/fromRaf.md
+++ b/website/src/content/docs/api/fromRaf.md
@@ -1,16 +1,26 @@
 ---
 title: "fromRaf()"
-description: "API reference for fromRaf."
+description: "Browser animation-frame source for @graphrefly/ts."
 ---
 
+Browser animation-frame source. It belongs to `@graphrefly/ts/sources/browser`, not the
+reactive-layout solution subpath.
+
 ## Signature
 
 ```ts
-function fromRaf(opts?: FromRafOptions): Node<number>
+import { fromRaf } from "@graphrefly/ts/sources/browser";
+
+function fromRaf(opts?: FromRafOptions): Operator<never, number>
 ```
 
 ## Parameters
 
 | Parameter | Type | Description |
 |-----------|------|-------------|
-| <code>opts</code> | <code>FromRafOptions</code> |  |
+| <code>opts</code> | <code>FromRafOptions</code> | Optional host scheduler, timer fallback cadence, and `pauseWhenHidden` visibility parking. |
+
+Bind it with `graph.initNode(fromRaf(), [])` or another existing operator-binding path. Each frame
+timestamp is emitted as protocol `DATA` by the resulting source node. Cleanup cancels the pending
+host frame. This is a browser/source boundary, so it does not add protocol behavior and does not
+belong to universal core.
diff --git a/website/src/content/docs/api/fromTimer.md b/website/src/content/docs/api/fromTimer.md
deleted file mode 100644
index 0d6ab90d..00000000
--- a/website/src/content/docs/api/fromTimer.md
+++ /dev/null
@@ -1,31 +0,0 @@
----
-title: "fromTimer()"
-description: "Builds a timer-driven source: one-shot (first tick then `COMPLETE`) or periodic (`0`, `1`, `2`, …)."
----
-
-Builds a timer-driven source: one-shot (first tick then `COMPLETE`) or periodic (`0`, `1`, `2`, …).
-
-## Signature
-
-```ts
-function fromTimer(ms: number, opts?: AsyncSourceOpts & { period?: number }): Node<number>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>ms</code> | <code>number</code> | Milliseconds before the first emission. |
-| <code>opts</code> | <code>AsyncSourceOpts & { period?: number }</code> | Producer options plus optional `period` for repeating ticks and optional `signal` (`AbortSignal`) to cancel with `ERROR`. |
-
-## Returns
-
-`Node&lt;number&gt;` — tick counter from `0`; teardown clears timers.
-
-## Basic Usage
-
-```ts
-import { fromTimer } from "@graphrefly/pure-ts";
-
-fromTimer(250, { period: 1_000 });
-```
diff --git a/website/src/content/docs/api/fromWebhook.md b/website/src/content/docs/api/fromWebhook.md
deleted file mode 100644
index 9f2a3f8f..00000000
--- a/website/src/content/docs/api/fromWebhook.md
+++ /dev/null
@@ -1,78 +0,0 @@
----
-title: "fromWebhook()"
-description: "Bridges HTTP webhook callbacks into a GraphReFly source.\n\nThe `register` callback wires your runtime/framework callback to GraphReFly and may return a\ncleanup f"
----
-
-Bridges HTTP webhook callbacks into a GraphReFly source.
-
-The `register` callback wires your runtime/framework callback to GraphReFly and may return a
-cleanup function. This keeps the adapter runtime-agnostic while following the same producer
-pattern as fromEvent.
-
-## Signature
-
-```ts
-function fromWebhook<T = unknown>(register: WebhookRegister<T>, opts?: ExtraOpts): Node<T>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>register</code> | <code>WebhookRegister&lt;T&gt;</code> | Registers webhook handlers (`emit`, `error`, `complete`) and optionally returns cleanup. |
-| <code>opts</code> | <code>ExtraOpts</code> | Optional producer options. |
-
-## Returns
-
-`Node&lt;T&gt;` — webhook payloads as `DATA`; teardown runs returned cleanup.
-
-## Basic Usage
-
-```ts
-import express from "express";
-import { fromWebhook } from "@graphrefly/graphrefly";
-
-type HookPayload = { event: string; data: unknown };
-const app = express();
-app.use(express.json());
-
-const hook$ = fromWebhook<HookPayload>(({ emit, error }) => {
-    const handler = (req: express.Request, res: express.Response) => {
-      try {
-        emit(req.body as HookPayload);
-        res.status(200).send("ok");
-      } catch (e) {
-      error(e);
-      res.status(500).send("error");
-    }
-};
-app.post("/webhook", handler);
-return () => {
-  // Express has no direct route-removal API in common use.
-};
-});
-```
-
-## Examples
-
-### Fastify
-
-```ts
-import Fastify from "fastify";
-import { fromWebhook } from "@graphrefly/graphrefly";
-
-const fastify = Fastify();
-const hook$ = fromWebhook<any>(({ emit, error }) => {
-    const handler = async (req: any, reply: any) => {
-      try {
-        emit(req.body);
-        reply.code(200).send({ ok: true });
-      } catch (e) {
-      error(e);
-      reply.code(500).send({ ok: false });
-    }
-};
-fastify.post("/webhook", handler);
-return () => {};
-});
-```
diff --git a/website/src/content/docs/api/funnel.md b/website/src/content/docs/api/funnel.md
deleted file mode 100644
index 69be6312..00000000
--- a/website/src/content/docs/api/funnel.md
+++ /dev/null
@@ -1,34 +0,0 @@
----
-title: "funnel()"
-description: "Multi-source merge with sequential reduction stages.\n\nSources are merged into a single stream. Each stage is a named subgraph\n(mounted via `graph.mount()`). Sta"
----
-
-Multi-source merge with sequential reduction stages.
-
-Sources are merged into a single stream. Each stage is a named subgraph
-(mounted via `graph.mount()`). Stages connect linearly:
-`merged → stage[0].input → stage[0].output → stage[1].input → ...`
-
-## Signature
-
-```ts
-function funnel<T>(
-	name: string,
-	sources: ReadonlyArray<Node<T>>,
-	stages: ReadonlyArray<FunnelStage>,
-	opts?: FunnelOptions,
-): Graph
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>name</code> | <code>string</code> | Graph name. |
-| <code>sources</code> | <code>ReadonlyArray&lt;Node&lt;T&gt;&gt;</code> | Input nodes to merge. |
-| <code>stages</code> | <code>ReadonlyArray&lt;FunnelStage&gt;</code> | Sequential reduction stages. |
-| <code>opts</code> | <code>FunnelOptions</code> | Optional graph/meta options. |
-
-## Returns
-
-Graph with `"merged"` and mounted stage subgraphs.
diff --git a/website/src/content/docs/api/googleAdapter.md b/website/src/content/docs/api/googleAdapter.md
deleted file mode 100644
index 0d23250e..00000000
--- a/website/src/content/docs/api/googleAdapter.md
+++ /dev/null
@@ -1,16 +0,0 @@
----
-title: "googleAdapter()"
-description: "API reference for googleAdapter."
----
-
-## Signature
-
-```ts
-function googleAdapter(opts: GoogleAdapterOptions = {}): LLMAdapter
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>opts</code> | <code>GoogleAdapterOptions</code> |  |
diff --git a/website/src/content/docs/api/graphLens.md b/website/src/content/docs/api/graphLens.md
deleted file mode 100644
index b0bbd259..00000000
--- a/website/src/content/docs/api/graphLens.md
+++ /dev/null
@@ -1,46 +0,0 @@
----
-title: "graphLens()"
-description: "Reactive observability preset over a target Graph."
----
-
-Reactive observability preset over a target Graph.
-
-## Signature
-
-```ts
-function graphLens(target: Graph, opts: GraphLensOptions = {}): GraphLensView
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>target</code> | <code>Graph</code> | The graph to observe. |
-| <code>opts</code> | <code>GraphLensOptions</code> |  |
-
-## Basic Usage
-
-```ts
-const g = new Graph("app");
-g.add(state(0, { name: "counter" }), { name: "counter" });
-
-const lens = graphLens(g);
-lens.topology.subscribe((msgs) => console.log("topology:", msgs));
-lens.health.subscribe((msgs) => console.log("health:", msgs));
-lens.flow.subscribe((msgs) => {
-    for (const [type, payload] of msgs) {
-      if (type === DATA) console.log("flow map size:", (payload as ReadonlyMap<string, FlowEntry>).size);
-    }
-});
-
-// Causal chains: use the underlying primitive directly — `graphLens` no
-// longer wraps it, since `graph.describe({ explain: {...}, reactive: true })`
-// already provides everything the old `lens.why()` did.
-const why = g.describe({
-    explain: { from: "counter", to: "consumer" },
-    reactive: true,
-  });
-
-// Tear down when done.
-lens.dispose();
-```
diff --git a/website/src/content/docs/api/guardedExecution.md b/website/src/content/docs/api/guardedExecution.md
deleted file mode 100644
index 51ac755e..00000000
--- a/website/src/content/docs/api/guardedExecution.md
+++ /dev/null
@@ -1,46 +0,0 @@
----
-title: "guardedExecution()"
-description: "Wrap a Graph with policyGate plus a reactive scoped describe\nlens. Returns a GuardedExecutionGraph that can be mounted, diffed,\nor composed with graphLens."
----
-
-Wrap a Graph with policyGate plus a reactive scoped describe
-lens. Returns a GuardedExecutionGraph that can be mounted, diffed,
-or composed with graphLens.
-
-## Signature
-
-```ts
-function guardedExecution(
-	target: Graph,
-	opts: GuardedExecutionOptions,
-): GuardedExecutionGraph
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>target</code> | <code>Graph</code> | The graph to guard. |
-| <code>opts</code> | <code>GuardedExecutionOptions</code> | See GuardedExecutionOptions. |
-
-## Basic Usage
-
-```ts
-const guarded = guardedExecution(app, {
-    actor: node<Actor>([], { initial: { type: "human", id: "alice" } }), // reactive — re-derive on swap
-    policies: [
-      { effect: "allow", action: "read", actorType: "human" },
-      { effect: "deny", action: "write", pathPattern: "system::*" },
-    ],
-  mode: "enforce",
-});
-
-// Canonical: subscribe to the mounted reactive describe (no per-call leak).
-guarded.scopedDescribe.subscribe((msgs) => { /* live describe per actor / topology change *\/ });
-// Per-call escape hatch (different actor / detail) — caller manages dispose.
-const detailed = guarded.scopedDescribeNode(undefined, { detail: "standard" });
-try { detailed.node.subscribe(/* … *\/); } finally { detailed.dispose(); }
-guarded.violations.events.subscribe(msgs => console.log("violations:", msgs));
-guarded.lints.events.subscribe(msgs => console.warn("lints:", msgs));
-guarded.scope.subscribe(msgs => console.log("scope:", msgs));
-```
diff --git a/website/src/content/docs/api/indexedDbAppendLog.md b/website/src/content/docs/api/indexedDbAppendLog.md
deleted file mode 100644
index 5e794540..00000000
--- a/website/src/content/docs/api/indexedDbAppendLog.md
+++ /dev/null
@@ -1,41 +0,0 @@
----
-title: "indexedDbAppendLog()"
-description: "Creates an IndexedDB append-log tier backed by an `indexedDbBackend`.\n\nConvenience wrapper for `appendLogStorage(indexedDbBackend(spec), opts)`.\nAll reads and w"
----
-
-Creates an IndexedDB append-log tier backed by an `indexedDbBackend`.
-
-Convenience wrapper for `appendLogStorage(indexedDbBackend(spec), opts)`.
-All reads and writes are async via IndexedDB. Requires a browser or
-browser-compatible environment.
-
-## Signature
-
-```ts
-function indexedDbAppendLog<T>(
-	spec: IndexedDbBackendSpec,
-	opts?: Omit<AppendLogStorageOptions<T>, "name"> & { name?: string },
-): AppendLogStorageTier<T>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>spec</code> | <code>IndexedDbBackendSpec</code> | Database name, object store name, and optional schema version. |
-| <code>opts</code> | <code>Omit&lt;AppendLogStorageOptions&lt;T&gt;, "name"&gt; & { name?: string }</code> | Optional append-log storage options (name, codec, keyOf, debounce, compactEvery). |
-
-## Returns
-
-`AppendLogStorageTier&lt;T&gt;` backed by IndexedDB.
-
-## Basic Usage
-
-```ts
-import { indexedDbAppendLog } from "@graphrefly/graphrefly/extra/browser";
-
-const tier = indexedDbAppendLog<{ type: string }>(
-  { dbName: "my-app", storeName: "events" },
-);
-await tier.appendEntries([{ type: "init" }]);
-```
diff --git a/website/src/content/docs/api/indexedDbBackend.md b/website/src/content/docs/api/indexedDbBackend.md
deleted file mode 100644
index 7f930d87..00000000
--- a/website/src/content/docs/api/indexedDbBackend.md
+++ /dev/null
@@ -1,36 +0,0 @@
----
-title: "indexedDbBackend()"
-description: "Creates an IndexedDB backend for browser-based persistent storage.\n\nAll operations (`read`, `write`, `delete`, `list`) are async and return\n`Promise`. The backi"
----
-
-Creates an IndexedDB backend for browser-based persistent storage.
-
-All operations (`read`, `write`, `delete`, `list`) are async and return
-`Promise`. The backing object store is created automatically on first open
-if it does not already exist.
-
-## Signature
-
-```ts
-function indexedDbBackend(spec: IndexedDbBackendSpec): StorageBackend
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>spec</code> | <code>IndexedDbBackendSpec</code> | Database name, object store name, and optional schema version. |
-
-## Returns
-
-`StorageBackend` backed by an IndexedDB object store.
-
-## Basic Usage
-
-```ts
-import { indexedDbBackend, snapshotStorage } from "@graphrefly/graphrefly/extra/browser";
-
-const backend = indexedDbBackend({ dbName: "my-app", storeName: "snapshots" });
-const tier = snapshotStorage(backend, { name: "graph1" });
-await tier.save({ name: "graph1", state: {} });
-```
diff --git a/website/src/content/docs/api/indexedDbKv.md b/website/src/content/docs/api/indexedDbKv.md
deleted file mode 100644
index e9be3406..00000000
--- a/website/src/content/docs/api/indexedDbKv.md
+++ /dev/null
@@ -1,42 +0,0 @@
----
-title: "indexedDbKv()"
-description: "Creates an IndexedDB key-value tier backed by an `indexedDbBackend`.\n\nConvenience wrapper for `kvStorage(indexedDbBackend(spec), opts)`.\nAll reads and writes ar"
----
-
-Creates an IndexedDB key-value tier backed by an `indexedDbBackend`.
-
-Convenience wrapper for `kvStorage(indexedDbBackend(spec), opts)`.
-All reads and writes are async via IndexedDB. Requires a browser or
-browser-compatible environment.
-
-## Signature
-
-```ts
-function indexedDbKv<T>(
-	spec: IndexedDbBackendSpec,
-	opts?: Omit<KvStorageOptions<T>, "name"> & { name?: string },
-): KvStorageTier<T>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>spec</code> | <code>IndexedDbBackendSpec</code> | Database name, object store name, and optional schema version. |
-| <code>opts</code> | <code>Omit&lt;KvStorageOptions&lt;T&gt;, "name"&gt; & { name?: string }</code> | Optional kv storage options (name, codec, filter, debounce, compactEvery). |
-
-## Returns
-
-`KvStorageTier&lt;T&gt;` backed by IndexedDB.
-
-## Basic Usage
-
-```ts
-import { indexedDbKv } from "@graphrefly/graphrefly/extra/browser";
-
-const kv = indexedDbKv<{ score: number }>(
-  { dbName: "my-app", storeName: "scores" },
-);
-await kv.save("player1", { score: 100 });
-const val = await kv.load("player1");
-```
diff --git a/website/src/content/docs/api/indexedDbSnapshot.md b/website/src/content/docs/api/indexedDbSnapshot.md
deleted file mode 100644
index 968af533..00000000
--- a/website/src/content/docs/api/indexedDbSnapshot.md
+++ /dev/null
@@ -1,42 +0,0 @@
----
-title: "indexedDbSnapshot()"
-description: "Creates an IndexedDB snapshot tier backed by an `indexedDbBackend`.\n\nConvenience wrapper for `snapshotStorage(indexedDbBackend(spec), opts)`.\nAll reads and writ"
----
-
-Creates an IndexedDB snapshot tier backed by an `indexedDbBackend`.
-
-Convenience wrapper for `snapshotStorage(indexedDbBackend(spec), opts)`.
-All reads and writes are async via IndexedDB. Requires a browser or
-browser-compatible environment.
-
-## Signature
-
-```ts
-function indexedDbSnapshot<T>(
-	spec: IndexedDbBackendSpec,
-	opts?: Omit<SnapshotStorageOptions<T>, "name"> & { name?: string },
-): SnapshotStorageTier<T>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>spec</code> | <code>IndexedDbBackendSpec</code> | Database name, object store name, and optional schema version. |
-| <code>opts</code> | <code>Omit&lt;SnapshotStorageOptions&lt;T&gt;, "name"&gt; & { name?: string }</code> | Optional snapshot storage options (name, codec, filter, keyOf, debounce, compactEvery). |
-
-## Returns
-
-`SnapshotStorageTier&lt;T&gt;` backed by IndexedDB.
-
-## Basic Usage
-
-```ts
-import { indexedDbSnapshot } from "@graphrefly/graphrefly/extra/browser";
-
-const tier = indexedDbSnapshot<{ count: number }>(
-  { dbName: "my-app", storeName: "snapshots" },
-  { name: "counter" },
-);
-await tier.save({ count: 1 });
-```
diff --git a/website/src/content/docs/api/indexedDbStorage.md b/website/src/content/docs/api/indexedDbStorage.md
deleted file mode 100644
index 1d4a8f9d..00000000
--- a/website/src/content/docs/api/indexedDbStorage.md
+++ /dev/null
@@ -1,39 +0,0 @@
----
-title: "indexedDbStorage()"
-description: "IndexedDB-backed async storage tier (browser runtime).\n\nAll three methods return `Promise`s — pairs naturally with a warm/cold\ncadence where async writes are de"
----
-
-IndexedDB-backed async storage tier (browser runtime).
-
-All three methods return `Promise`s — pairs naturally with a warm/cold
-cadence where async writes are debounced per tier via
-`Graph.attachStorage`. Writes use `readwrite` transactions; reads use
-`readonly`. Missing records resolve to `null`.
-
-## Signature
-
-```ts
-function indexedDbStorage(spec: IndexedDbStorageSpec): StorageTier
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| `spec` | `IndexedDbStorageSpec` | Database name, store name, optional `key` (default
-`"graphrefly_checkpoint"`) and schema `version` (default `1`). |
-
-## Returns
-
-Async StorageTier.
-
-## Basic Usage
-
-```ts
-import { indexedDbStorage, memoryStorage } from "@graphrefly/graphrefly-ts";
-
-graph.attachStorage([
-    memoryStorage(),
-    indexedDbStorage({ dbName: "myApp", storeName: "checkpoints" }),
-  ]);
-```
diff --git a/website/src/content/docs/api/influenceAnalysis.md b/website/src/content/docs/api/influenceAnalysis.md
deleted file mode 100644
index 1e5769ca..00000000
--- a/website/src/content/docs/api/influenceAnalysis.md
+++ /dev/null
@@ -1,22 +0,0 @@
----
-title: "influenceAnalysis()"
-description: "Attach influence/blast-radius analysis to a reactiveFactStore."
----
-
-Attach influence/blast-radius analysis to a reactiveFactStore.
-
-## Signature
-
-```ts
-function influenceAnalysis<T>(
-	mem: ReactiveFactStoreGraph<T>,
-	opts: InfluenceAnalysisOptions = {},
-): InfluenceAnalysis
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>mem</code> | <code>ReactiveFactStoreGraph&lt;T&gt;</code> |  |
-| <code>opts</code> | <code>InfluenceAnalysisOptions</code> |  |
diff --git a/website/src/content/docs/api/inspect.md b/website/src/content/docs/api/inspect.md
deleted file mode 100644
index 404c7c1f..00000000
--- a/website/src/content/docs/api/inspect.md
+++ /dev/null
@@ -1,40 +0,0 @@
----
-title: "inspect()"
-description: "Build an InspectGraph that mounts `graphLens` + `auditTrail` over\nthe wrapped target and exposes `explainTarget()` + `complianceSnapshot()`\nfacades."
----
-
-Build an InspectGraph that mounts `graphLens` + `auditTrail` over
-the wrapped target and exposes `explainTarget()` + `complianceSnapshot()`
-facades.
-
-## Signature
-
-```ts
-function inspect(target: Graph, opts: InspectOptions = {}): InspectGraph
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>target</code> | <code>Graph</code> |  |
-| <code>opts</code> | <code>InspectOptions</code> |  |
-
-## Basic Usage
-
-```ts
-import { inspect } from "@graphrefly/graphrefly/presets/inspect";
-
-const target = buildMyApp();
-const view = inspect(target, { actor: { id: "ops-bot", role: "monitor" } });
-
-// Live observability
-view.lens.health.subscribe((msgs) => console.log("health:", msgs));
-view.lens.flow.subscribe((msgs) => console.log("flow:", msgs));
-
-// Causal explainability across the wrapped target
-const chain = view.explainTarget("input", "output");
-
-// Tamper-evident snapshot for archival
-const snapshot = view.complianceSnapshot();
-```
diff --git a/website/src/content/docs/api/interval.md b/website/src/content/docs/api/interval.md
deleted file mode 100644
index 5e352e1d..00000000
--- a/website/src/content/docs/api/interval.md
+++ /dev/null
@@ -1,31 +0,0 @@
----
-title: "interval()"
-description: "Increments on each tick (`interval`); uses `setInterval` via producer."
----
-
-Increments on each tick (`interval`); uses `setInterval` via producer.
-
-## Signature
-
-```ts
-function interval(periodMs: number, opts?: ExtraOpts): Node<number>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>periodMs</code> | <code>number</code> | Time between ticks. |
-| <code>opts</code> | <code>ExtraOpts</code> | Optional NodeOptions (excluding `describeKind`). |
-
-## Returns
-
-`Node&lt;number&gt;` - Emits `0`, `1`, `2`, … while subscribed.
-
-## Basic Usage
-
-```ts
-import { interval } from "@graphrefly/pure-ts";
-
-interval(1_000);
-```
diff --git a/website/src/content/docs/api/invalidationTracer.md b/website/src/content/docs/api/invalidationTracer.md
deleted file mode 100644
index 8e47672a..00000000
--- a/website/src/content/docs/api/invalidationTracer.md
+++ /dev/null
@@ -1,24 +0,0 @@
----
-title: "invalidationTracer()"
-description: "Attach a bounded cascade-event tracer to a reactiveFactStore.\nSelf-adds a `describe()`-visible observer Node and returns it; each emission\nis the current trace "
----
-
-Attach a bounded cascade-event tracer to a reactiveFactStore.
-Self-adds a `describe()`-visible observer Node and returns it; each emission
-is the current trace ring (oldest → newest).
-
-## Signature
-
-```ts
-function invalidationTracer<T>(
-	mem: ReactiveFactStoreGraph<T>,
-	opts: InvalidationTracerOptions = {},
-): Node<readonly InvalidationTraceEntry[]>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>mem</code> | <code>ReactiveFactStoreGraph&lt;T&gt;</code> |  |
-| <code>opts</code> | <code>InvalidationTracerOptions</code> |  |
diff --git a/website/src/content/docs/api/isBatching.md b/website/src/content/docs/api/isBatching.md
deleted file mode 100644
index b16d7bea..00000000
--- a/website/src/content/docs/api/isBatching.md
+++ /dev/null
@@ -1,14 +0,0 @@
----
-title: "isBatching()"
-description: "Returns whether the current call stack is inside a batch scope **or** while\na deferred drain is in progress. Nested `downWithBatch` calls during drain\nstill def"
----
-
-Returns whether the current call stack is inside a batch scope **or** while
-a deferred drain is in progress. Nested `downWithBatch` calls during drain
-still defer (they bump the drain loop).
-
-## Signature
-
-```ts
-function isBatching(): boolean
-```
diff --git a/website/src/content/docs/api/jobEventKeyOf.md b/website/src/content/docs/api/jobEventKeyOf.md
deleted file mode 100644
index f91aa862..00000000
--- a/website/src/content/docs/api/jobEventKeyOf.md
+++ /dev/null
@@ -1,18 +0,0 @@
----
-title: "jobEventKeyOf()"
-description: "Recommended `keyOf` for keyed-storage adapters (Audit 2 #7)."
----
-
-Recommended `keyOf` for keyed-storage adapters (Audit 2 #7).
-
-## Signature
-
-```ts
-jobEventKeyOf<T>(e: JobEvent<T>): string
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>e</code> | <code>JobEvent&lt;T&gt;</code> |  |
diff --git a/website/src/content/docs/api/jobFlow.md b/website/src/content/docs/api/jobFlow.md
deleted file mode 100644
index 0652ef37..00000000
--- a/website/src/content/docs/api/jobFlow.md
+++ /dev/null
@@ -1,19 +0,0 @@
----
-title: "jobFlow()"
-description: "Creates an autonomous multi-stage queue chain graph."
----
-
-Creates an autonomous multi-stage queue chain graph.
-
-## Signature
-
-```ts
-function jobFlow<T>(name: string, opts?: JobFlowOptions<T>): JobFlowGraph<T>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>name</code> | <code>string</code> |  |
-| <code>opts</code> | <code>JobFlowOptions&lt;T&gt;</code> |  |
diff --git a/website/src/content/docs/api/jobQueue.md b/website/src/content/docs/api/jobQueue.md
deleted file mode 100644
index d2350cf8..00000000
--- a/website/src/content/docs/api/jobQueue.md
+++ /dev/null
@@ -1,19 +0,0 @@
----
-title: "jobQueue()"
-description: "Creates a Pulsar-inspired job queue graph with claim/ack/nack workflow."
----
-
-Creates a Pulsar-inspired job queue graph with claim/ack/nack workflow.
-
-## Signature
-
-```ts
-function jobQueue<T>(name: string, opts?: JobQueueOptions): JobQueueGraph<T>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>name</code> | <code>string</code> |  |
-| <code>opts</code> | <code>JobQueueOptions</code> |  |
diff --git a/website/src/content/docs/api/jsonCodecFor.md b/website/src/content/docs/api/jsonCodecFor.md
deleted file mode 100644
index 19e3a485..00000000
--- a/website/src/content/docs/api/jsonCodecFor.md
+++ /dev/null
@@ -1,30 +0,0 @@
----
-title: "jsonCodecFor()"
-description: "Returns the default `jsonCodec` cast to `Codec<T>`.\n\nPure typing helper — no runtime overhead. Use when a generic API requires a\n`Codec<T>` and the value is kno"
----
-
-Returns the default `jsonCodec` cast to `Codec&lt;T&gt;`.
-
-Pure typing helper — no runtime overhead. Use when a generic API requires a
-`Codec&lt;T&gt;` and the value is known to be JSON-serializable.
-
-## Signature
-
-```ts
-function jsonCodecFor<T>(): Codec<T>
-```
-
-## Returns
-
-`Codec&lt;T&gt;` backed by the shared `jsonCodec` (UTF-8 JSON, stable key order).
-
-## Basic Usage
-
-```ts
-import { memoryBackend, snapshotStorage, jsonCodecFor } from "@graphrefly/graphrefly/extra";
-
-type MyState = { count: number; label: string };
-const tier = snapshotStorage<MyState>(memoryBackend(), {
-    codec: jsonCodecFor<MyState>(),
-  });
-```
diff --git a/website/src/content/docs/api/kvStorage.md b/website/src/content/docs/api/kvStorage.md
deleted file mode 100644
index c034c53a..00000000
--- a/website/src/content/docs/api/kvStorage.md
+++ /dev/null
@@ -1,41 +0,0 @@
----
-title: "kvStorage()"
-description: "Wraps a `StorageBackend` as a typed key-value tier.\n\nBuffer model: `save(k, v)` encodes via codec and writes to the backend\nunless debounced. Pending writes are"
----
-
-Wraps a `StorageBackend` as a typed key-value tier.
-
-Buffer model: `save(k, v)` encodes via codec and writes to the backend
-unless debounced. Pending writes are committed on `flush()` and discarded
-on `rollback()` — the wave-as-transaction model.
-
-## Signature
-
-```ts
-function kvStorage<T>(
-	backend: StorageBackend,
-	opts: KvStorageOptions<T> = {},
-): KvStorageTier<T>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>backend</code> | <code>StorageBackend</code> | Bytes-level backend to persist records into. |
-| <code>opts</code> | <code>KvStorageOptions&lt;T&gt;</code> | Optional name, codec, debounce window, compaction interval, and pre-save filter. |
-
-## Returns
-
-`KvStorageTier&lt;T&gt;` that supports `save`, `load`, `delete`, and `list` operations.
-
-## Basic Usage
-
-```ts
-import { memoryBackend, kvStorage } from "@graphrefly/graphrefly/extra";
-
-const backend = memoryBackend();
-const kv = kvStorage<{ score: number }>(backend, { name: "scores" });
-await kv.save("player1", { score: 100 });
-const val = await kv.load("player1");
-```
diff --git a/website/src/content/docs/api/last.md b/website/src/content/docs/api/last.md
deleted file mode 100644
index f36e5e5f..00000000
--- a/website/src/content/docs/api/last.md
+++ /dev/null
@@ -1,31 +0,0 @@
----
-title: "last()"
-description: "Buffers values and emits the last **`DATA`** on **`COMPLETE`**; optional `defaultValue` if none arrived."
----
-
-Buffers values and emits the last **`DATA`** on **`COMPLETE`**; optional `defaultValue` if none arrived.
-
-## Signature
-
-```ts
-function last<T>(source: Node<T>, options?: ExtraOpts & { defaultValue?: T }): Node<T>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>source</code> | <code>Node&lt;T&gt;</code> | Upstream node. |
-| <code>options</code> | <code>ExtraOpts & { defaultValue?: T }</code> | Optional NodeOptions and `defaultValue` when empty. |
-
-## Returns
-
-`Node&lt;T&gt;` - Last-or-default node.
-
-## Basic Usage
-
-```ts
-import { last, state } from "@graphrefly/pure-ts";
-
-const n = last(state(1), { defaultValue: 0 });
-```
diff --git a/website/src/content/docs/api/linear.md b/website/src/content/docs/api/linear.md
deleted file mode 100644
index 5d0c9b9c..00000000
--- a/website/src/content/docs/api/linear.md
+++ /dev/null
@@ -1,32 +0,0 @@
----
-title: "linear()"
-description: "Builds linear backoff: `baseNs + stepNs * attempt` (`stepNs` defaults to `baseNs`)."
----
-
-Builds linear backoff: `baseNs + stepNs * attempt` (`stepNs` defaults to `baseNs`).
-
-## Signature
-
-```ts
-function linear(baseNs: number, stepNs?: number): BackoffStrategy
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>baseNs</code> | <code>number</code> | Base delay in nanoseconds (clamped non-negative). |
-| <code>stepNs</code> | <code>number</code> | Added per retry attempt in nanoseconds (clamped non-negative). |
-
-## Returns
-
-`BackoffStrategy` for retry.
-
-## Basic Usage
-
-```ts
-import { linear, retry, NS_PER_SEC } from "@graphrefly/graphrefly";
-
-// Attempt 0 → 1 s, attempt 1 → 2 s, attempt 2 → 3 s …
-const out = retry(source, { count: 4, backoff: linear(NS_PER_SEC) });
-```
diff --git a/website/src/content/docs/api/llmCompose.md b/website/src/content/docs/api/llmCompose.md
deleted file mode 100644
index 52fa87ff..00000000
--- a/website/src/content/docs/api/llmCompose.md
+++ /dev/null
@@ -1,31 +0,0 @@
----
-title: "llmCompose()"
-description: "Ask an LLM to compose a GraphSpec from a natural-language problem description.\n\nThe LLM generates a GraphSpec (with templates + feedback), validated before\nretu"
----
-
-Ask an LLM to compose a GraphSpec from a natural-language problem description.
-
-The LLM generates a GraphSpec (with templates + feedback), validated before
-returning. The spec is for human review before compilation via compileSpec().
-
-## Signature
-
-```ts
-async function llmCompose(
-	problem: string,
-	adapter: LLMAdapter,
-	opts?: LLMComposeOptions,
-): Promise<GraphSpec>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>problem</code> | <code>string</code> | Natural language problem description. |
-| <code>adapter</code> | <code>LLMAdapter</code> | LLM adapter for the generation call. |
-| <code>opts</code> | <code>LLMComposeOptions</code> | Model options and catalog description. |
-
-## Returns
-
-A validated GraphSpec.
diff --git a/website/src/content/docs/api/llmConsolidator.md b/website/src/content/docs/api/llmConsolidator.md
deleted file mode 100644
index 21bd9177..00000000
--- a/website/src/content/docs/api/llmConsolidator.md
+++ /dev/null
@@ -1,23 +0,0 @@
----
-title: "llmConsolidator()"
-description: "Returns a `consolidateFn` callback for `distill()` that invokes an LLM to\ncluster and merge related memories."
----
-
-Returns a `consolidateFn` callback for `distill()` that invokes an LLM to
-cluster and merge related memories.
-
-## Signature
-
-```ts
-function llmConsolidator<TMem>(
-	systemPrompt: string,
-	opts: LLMConsolidatorOptions,
-): (entries: ReadonlyMap<string, TMem>) => NodeInput<Extraction<TMem>>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>systemPrompt</code> | <code>string</code> |  |
-| <code>opts</code> | <code>LLMConsolidatorOptions</code> |  |
diff --git a/website/src/content/docs/api/llmExtractor.md b/website/src/content/docs/api/llmExtractor.md
deleted file mode 100644
index f456d0eb..00000000
--- a/website/src/content/docs/api/llmExtractor.md
+++ /dev/null
@@ -1,30 +0,0 @@
----
-title: "llmExtractor()"
-description: "Returns an `extractFn` callback for `distill()` that invokes an LLM to\nextract structured memories from raw input.\n\nThe system prompt should instruct the LLM to"
----
-
-Returns an `extractFn` callback for `distill()` that invokes an LLM to
-extract structured memories from raw input.
-
-The system prompt should instruct the LLM to return JSON matching
-`Extraction&lt;TMem&gt;` shape: `{ upsert: [{ key, value }], remove?: [key] }`.
-
-Built on `promptNode({format: "json"})` — inherits markdown-fence stripping
-and content-preview parse errors. Stack `withRetry` on the adapter for
-transient-error tolerance (see `patterns/ai/adapters/middleware/retry.ts`).
-
-## Signature
-
-```ts
-function llmExtractor<TRaw, TMem>(
-	systemPrompt: string,
-	opts: LLMExtractorOptions,
-): (raw: TRaw, existing: ReadonlyMap<string, TMem>) => NodeInput<Extraction<TMem>>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>systemPrompt</code> | <code>string</code> |  |
-| <code>opts</code> | <code>LLMExtractorOptions</code> |  |
diff --git a/website/src/content/docs/api/llmRefine.md b/website/src/content/docs/api/llmRefine.md
deleted file mode 100644
index daa6e0dc..00000000
--- a/website/src/content/docs/api/llmRefine.md
+++ /dev/null
@@ -1,30 +0,0 @@
----
-title: "llmRefine()"
-description: "Ask an LLM to modify an existing GraphSpec based on feedback or changed requirements."
----
-
-Ask an LLM to modify an existing GraphSpec based on feedback or changed requirements.
-
-## Signature
-
-```ts
-async function llmRefine(
-	currentSpec: GraphSpec,
-	feedback: string,
-	adapter: LLMAdapter,
-	opts?: LLMRefineOptions,
-): Promise<GraphSpec>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>currentSpec</code> | <code>GraphSpec</code> | The current GraphSpec to modify. |
-| <code>feedback</code> | <code>string</code> | Natural language feedback or changed requirements. |
-| <code>adapter</code> | <code>LLMAdapter</code> | LLM adapter for the generation call. |
-| <code>opts</code> | <code>LLMRefineOptions</code> | Model options. |
-
-## Returns
-
-A new GraphSpec incorporating the feedback.
diff --git a/website/src/content/docs/api/localFirstPreset.md b/website/src/content/docs/api/localFirstPreset.md
deleted file mode 100644
index 650bca17..00000000
--- a/website/src/content/docs/api/localFirstPreset.md
+++ /dev/null
@@ -1,18 +0,0 @@
----
-title: "localFirstPreset()"
-description: "Local-first: nothing leaves the machine. Ollama → WebLLM → Chrome Nano."
----
-
-Local-first: nothing leaves the machine. Ollama → WebLLM → Chrome Nano.
-
-## Signature
-
-```ts
-function localFirstPreset(opts: LocalFirstPresetOptions): LLMAdapter
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>opts</code> | <code>LocalFirstPresetOptions</code> |  |
diff --git a/website/src/content/docs/api/logProjector.md b/website/src/content/docs/api/logProjector.md
deleted file mode 100644
index a1ab720c..00000000
--- a/website/src/content/docs/api/logProjector.md
+++ /dev/null
@@ -1,50 +0,0 @@
----
-title: "logProjector()"
-description: "Creates a cursor-driven log/topic projector with a typed poison-failure\npolicy and an observable dead-letter topic."
----
-
-Creates a cursor-driven log/topic projector with a typed poison-failure
-policy and an observable dead-letter topic.
-
-## Signature
-
-```ts
-function logProjector<T>(
-	name: string,
-	source: TopicGraph<T> | ReactiveLogBundle<T>,
-	opts: LogProjectorOptions<T>,
-): LogProjectorGraph<T>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>name</code> | <code>string</code> |  |
-| <code>source</code> | <code>TopicGraph&lt;T&gt; | ReactiveLogBundle&lt;T&gt;</code> |  |
-| <code>opts</code> | <code>LogProjectorOptions&lt;T&gt;</code> |  |
-
-## Basic Usage
-
-```ts
-import { logProjector, topic } from "@graphrefly/graphrefly";
-
-const events = topic<Doc>("docs");
-const proj = logProjector("indexer", events, {
-    sink: async (doc) => { await index(doc); },   // throw ⇒ poison
-    onPoison: "deadLetter",
-  });
-proj.deadLetter.events.subscribe(/* observe poison *​/);
-```
-
-## Behavior Details
-
-- **Use an UNBOUNDED source for durable / long-lived projection.** The cursor
-is an absolute index; the underlying `fromCursor` view slices the source's
-*current* entries array. A `TopicGraph` with a `retainedLimit` (or a
-`ReactiveLogBundle` with `maxSize`) trims its head, so an absolute cursor
-past the retained window reads the wrong offset (skips entries or stalls).
-This is inherited `subscription()` / `fromCursor` behaviour, not specific to
-`logProjector` — but it matters here because projection is typically
-long-lived. For unbounded projection pass a source with NO `retainedLimit` /
-`maxSize` (memo:Re's `changesetLog` is unbounded ✓).
diff --git a/website/src/content/docs/api/map.md b/website/src/content/docs/api/map.md
deleted file mode 100644
index 33451744..00000000
--- a/website/src/content/docs/api/map.md
+++ /dev/null
@@ -1,32 +0,0 @@
----
-title: "map()"
-description: "Maps each settled value from `source` through `project`."
----
-
-Maps each settled value from `source` through `project`.
-
-## Signature
-
-```ts
-function map<T, R>(source: Node<T>, project: (value: T) => R, opts?: ExtraOpts): Node<R>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>source</code> | <code>Node&lt;T&gt;</code> | Upstream node. |
-| <code>project</code> | <code>(value: T) =&gt; R</code> | Transform for each value. |
-| <code>opts</code> | <code>ExtraOpts</code> | Optional NodeOptions (excluding `describeKind`). |
-
-## Returns
-
-`Node&lt;R&gt;` - Derived node emitting mapped values.
-
-## Basic Usage
-
-```ts
-import { map, state } from "@graphrefly/pure-ts";
-
-const n = map(state(2), (x) => x * 3);
-```
diff --git a/website/src/content/docs/api/matchesCron.md b/website/src/content/docs/api/matchesCron.md
deleted file mode 100644
index 59b536e2..00000000
--- a/website/src/content/docs/api/matchesCron.md
+++ /dev/null
@@ -1,33 +0,0 @@
----
-title: "matchesCron()"
-description: "Returns `true` if `date` satisfies every field of `schedule`."
----
-
-Returns `true` if `date` satisfies every field of `schedule`.
-
-## Signature
-
-```ts
-function matchesCron(schedule: CronSchedule, date: Date): boolean
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>schedule</code> | <code>CronSchedule</code> | Parsed schedule from parseCron. |
-| <code>date</code> | <code>Date</code> | Moment to test (local time via `getMinutes`, `getHours`, etc.). |
-
-## Returns
-
-`true` when all five cron fields match the given date.
-
-## Basic Usage
-
-```ts
-import { parseCron, matchesCron } from "@graphrefly/graphrefly";
-
-const sched = parseCron("30 8 * * 1"); // Mondays at 08:30
-const monday = new Date("2026-03-30T08:30:00"); // a Monday
-matchesCron(sched, monday); // true
-```
diff --git a/website/src/content/docs/api/memoryAppendLog.md b/website/src/content/docs/api/memoryAppendLog.md
deleted file mode 100644
index d6297121..00000000
--- a/website/src/content/docs/api/memoryAppendLog.md
+++ /dev/null
@@ -1,36 +0,0 @@
----
-title: "memoryAppendLog()"
-description: "Creates an in-memory append-log tier backed by a fresh `memoryBackend`.\n\nConvenience wrapper for `appendLogStorage(memoryBackend(), opts)`. All writes\nare synch"
----
-
-Creates an in-memory append-log tier backed by a fresh `memoryBackend`.
-
-Convenience wrapper for `appendLogStorage(memoryBackend(), opts)`. All writes
-are synchronous and in-process — useful for tests and hot-path event buffering.
-
-## Signature
-
-```ts
-function memoryAppendLog<T>(
-	opts?: Omit<AppendLogStorageOptions<T>, "name"> & { name?: string },
-): AppendLogStorageTier<T>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>opts</code> | <code>Omit&lt;AppendLogStorageOptions&lt;T&gt;, "name"&gt; & { name?: string }</code> | Optional append-log storage options (name, codec, keyOf, debounce, compactEvery). |
-
-## Returns
-
-`AppendLogStorageTier&lt;T&gt;` backed by an in-memory store.
-
-## Basic Usage
-
-```ts
-import { memoryAppendLog } from "@graphrefly/graphrefly/extra";
-
-const tier = memoryAppendLog<{ type: string }>({ name: "events" });
-await tier.appendEntries([{ type: "init" }]);
-```
diff --git a/website/src/content/docs/api/memoryBackend.md b/website/src/content/docs/api/memoryBackend.md
deleted file mode 100644
index a8edb05b..00000000
--- a/website/src/content/docs/api/memoryBackend.md
+++ /dev/null
@@ -1,29 +0,0 @@
----
-title: "memoryBackend()"
-description: "Creates an in-process bytes backend backed by `Map<string, Uint8Array>`.\n\nUseful for tests, hot tiers, and as the default backend for the convenience\nfactories "
----
-
-Creates an in-process bytes backend backed by `Map&lt;string, Uint8Array&gt;`.
-
-Useful for tests, hot tiers, and as the default backend for the convenience
-factories in this module. All operations are synchronous.
-
-## Signature
-
-```ts
-function memoryBackend(): StorageBackend
-```
-
-## Returns
-
-`StorageBackend` instance backed by an in-memory `Map`.
-
-## Basic Usage
-
-```ts
-import { memoryBackend, snapshotStorage } from "@graphrefly/graphrefly/extra";
-
-const backend = memoryBackend();
-const tier = snapshotStorage(backend, { name: "my-graph" });
-await tier.save({ name: "my-graph", data: { count: 1 } });
-```
diff --git a/website/src/content/docs/api/memoryKv.md b/website/src/content/docs/api/memoryKv.md
deleted file mode 100644
index bc7069a7..00000000
--- a/website/src/content/docs/api/memoryKv.md
+++ /dev/null
@@ -1,37 +0,0 @@
----
-title: "memoryKv()"
-description: "Creates an in-memory key-value tier backed by a fresh `memoryBackend`.\n\nConvenience wrapper for `kvStorage(memoryBackend(), opts)`. All writes are\nsynchronous a"
----
-
-Creates an in-memory key-value tier backed by a fresh `memoryBackend`.
-
-Convenience wrapper for `kvStorage(memoryBackend(), opts)`. All writes are
-synchronous and in-process — useful for tests and ephemeral record caches.
-
-## Signature
-
-```ts
-function memoryKv<T>(
-	opts?: Omit<KvStorageOptions<T>, "name"> & { name?: string },
-): KvStorageTier<T>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>opts</code> | <code>Omit&lt;KvStorageOptions&lt;T&gt;, "name"&gt; & { name?: string }</code> | Optional kv storage options (name, codec, filter, debounce, compactEvery). |
-
-## Returns
-
-`KvStorageTier&lt;T&gt;` backed by an in-memory store.
-
-## Basic Usage
-
-```ts
-import { memoryKv } from "@graphrefly/graphrefly/extra";
-
-const kv = memoryKv<{ value: number }>();
-await kv.save("key1", { value: 42 });
-const loaded = await kv.load("key1");
-```
diff --git a/website/src/content/docs/api/memoryRetrieval.md b/website/src/content/docs/api/memoryRetrieval.md
deleted file mode 100644
index 36867465..00000000
--- a/website/src/content/docs/api/memoryRetrieval.md
+++ /dev/null
@@ -1,23 +0,0 @@
----
-title: "memoryRetrieval()"
-description: "Build the retrieval pipeline (vector + KG + budget packing) over a\n`DistillBundle` and optional `vectors` / `kg` substrates. Returns a\n`MemoryRetrievalGraph` ex"
----
-
-Build the retrieval pipeline (vector + KG + budget packing) over a
-`DistillBundle` and optional `vectors` / `kg` substrates. Returns a
-`MemoryRetrievalGraph` exposing `retrieval` / `retrievalTrace` reactive
-state and the `retrieveReactive(input)` consumer method.
-
-## Signature
-
-```ts
-function memoryRetrieval<TMem>(
-	opts: MemoryRetrievalOptions<TMem>,
-): MemoryRetrievalGraph<TMem>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>opts</code> | <code>MemoryRetrievalOptions&lt;TMem&gt;</code> |  |
diff --git a/website/src/content/docs/api/memorySnapshot.md b/website/src/content/docs/api/memorySnapshot.md
deleted file mode 100644
index 7a5bd200..00000000
--- a/website/src/content/docs/api/memorySnapshot.md
+++ /dev/null
@@ -1,36 +0,0 @@
----
-title: "memorySnapshot()"
-description: "Creates an in-memory snapshot tier backed by a fresh `memoryBackend`.\n\nConvenience wrapper for `snapshotStorage(memoryBackend(), opts)`. All writes\nare synchron"
----
-
-Creates an in-memory snapshot tier backed by a fresh `memoryBackend`.
-
-Convenience wrapper for `snapshotStorage(memoryBackend(), opts)`. All writes
-are synchronous and in-process — useful for tests and hot-path caching.
-
-## Signature
-
-```ts
-function memorySnapshot<T>(
-	opts?: Omit<SnapshotStorageOptions<T>, "name"> & { name?: string },
-): SnapshotStorageTier<T>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>opts</code> | <code>Omit&lt;SnapshotStorageOptions&lt;T&gt;, "name"&gt; & { name?: string }</code> | Optional snapshot storage options (name, codec, filter, keyOf, debounce, compactEvery). |
-
-## Returns
-
-`SnapshotStorageTier&lt;T&gt;` backed by an in-memory store.
-
-## Basic Usage
-
-```ts
-import { memorySnapshot } from "@graphrefly/graphrefly/extra";
-
-const tier = memorySnapshot<{ count: number }>({ name: "counter" });
-await tier.save({ count: 1 });
-```
diff --git a/website/src/content/docs/api/memoryStorage.md b/website/src/content/docs/api/memoryStorage.md
deleted file mode 100644
index 0e9688a3..00000000
--- a/website/src/content/docs/api/memoryStorage.md
+++ /dev/null
@@ -1,25 +0,0 @@
----
-title: "memoryStorage()"
-description: "In-memory storage tier (process-local; useful for tests and hot tier)."
----
-
-In-memory storage tier (process-local; useful for tests and hot tier).
-
-## Signature
-
-```ts
-function memoryStorage(): StorageTier
-```
-
-## Returns
-
-Sync StorageTier with JSON-cloned isolation.
-
-## Basic Usage
-
-```ts
-import { memoryStorage } from "@graphrefly/graphrefly-ts";
-
-const hot = memoryStorage();
-graph.attachStorage([hot]);
-```
diff --git a/website/src/content/docs/api/memoryWithKG.md b/website/src/content/docs/api/memoryWithKG.md
deleted file mode 100644
index 1242dd1a..00000000
--- a/website/src/content/docs/api/memoryWithKG.md
+++ /dev/null
@@ -1,19 +0,0 @@
----
-title: "memoryWithKG()"
-description: "Attach a knowledge graph alongside a `DistillBundle`. Returns the\n`MemoryWithKGGraph` whose `kg` field exposes the inner `KnowledgeGraph`."
----
-
-Attach a knowledge graph alongside a `DistillBundle`. Returns the
-`MemoryWithKGGraph` whose `kg` field exposes the inner `KnowledgeGraph`.
-
-## Signature
-
-```ts
-function memoryWithKG<TMem>(opts: MemoryWithKGOptions<TMem>): MemoryWithKGGraph<TMem>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>opts</code> | <code>MemoryWithKGOptions&lt;TMem&gt;</code> |  |
diff --git a/website/src/content/docs/api/memoryWithTiers.md b/website/src/content/docs/api/memoryWithTiers.md
deleted file mode 100644
index 4f9ac239..00000000
--- a/website/src/content/docs/api/memoryWithTiers.md
+++ /dev/null
@@ -1,33 +0,0 @@
----
-title: "memoryWithTiers()"
-description: "Attach 3-tier storage (active / archived / permanent) over a fresh distill\nstore. Returns a `MemoryWithTiersGraph` whose `store` and `tiers` fields\nmirror the p"
----
-
-Attach 3-tier storage (active / archived / permanent) over a fresh distill
-store. Returns a `MemoryWithTiersGraph` whose `store` and `tiers` fields
-mirror the previous bundle shape.
-
-**API shape** (Class B audit, 2026-04-30 — breaking change vs.
-pre-migration): the factory takes a single opts bag including `source`
-and `extractFn`. The bundle is exposed as `result.store` for downstream
-composers (vectors / KG / retrieval).
-
-- `permanentFilter`-matching entries score `Infinity` in retention →
-  never archived. Independent permanent-promotion effect upserts them
-  into the `permanent` collection.
-- Below-threshold entries → retention archives synchronously.
-- Over-`maxActive` entries → retention's `maxSize` evicts lowest-scored.
-
-## Signature
-
-```ts
-function memoryWithTiers<TRaw, TMem>(
-	opts: MemoryWithTiersOptions<TRaw, TMem>,
-): MemoryWithTiersGraph<TRaw, TMem>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>opts</code> | <code>MemoryWithTiersOptions&lt;TRaw, TMem&gt;</code> |  |
diff --git a/website/src/content/docs/api/memoryWithVectors.md b/website/src/content/docs/api/memoryWithVectors.md
deleted file mode 100644
index 2ac73ec4..00000000
--- a/website/src/content/docs/api/memoryWithVectors.md
+++ /dev/null
@@ -1,25 +0,0 @@
----
-title: "memoryWithVectors()"
-description: "Attach a vector index to a `DistillBundle`. Indexes every entry in the\nstore as it changes. Returns the `MemoryWithVectorsGraph` whose `vectors`\nfield exposes t"
----
-
-Attach a vector index to a `DistillBundle`. Indexes every entry in the
-store as it changes. Returns the `MemoryWithVectorsGraph` whose `vectors`
-field exposes the underlying `VectorIndexGraph`.
-
-Teardown is handled by `Graph.destroy()` — typically inherited via
-mounting the result on a parent graph (see `agentMemory`).
-
-## Signature
-
-```ts
-function memoryWithVectors<TMem>(
-	opts: MemoryWithVectorsOptions<TMem>,
-): MemoryWithVectorsGraph<TMem>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>opts</code> | <code>MemoryWithVectorsOptions&lt;TMem&gt;</code> |  |
diff --git a/website/src/content/docs/api/merge.md b/website/src/content/docs/api/merge.md
deleted file mode 100644
index 64447fde..00000000
--- a/website/src/content/docs/api/merge.md
+++ /dev/null
@@ -1,17 +0,0 @@
----
-title: "merge()"
-description: "API reference for merge."
----
-
-## Signature
-
-```ts
-function merge<T>(...sources: readonly Node<T>[]): Node<T>
-function merge<T>(...args: readonly [...Node<T>[], ExtraOpts]): Node<T>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>args</code> | <code>ReadonlyArray&lt;Node&lt;T&gt; | ExtraOpts | undefined&gt;</code> |  |
diff --git a/website/src/content/docs/api/mergeMap.md b/website/src/content/docs/api/mergeMap.md
deleted file mode 100644
index 1c862cd3..00000000
--- a/website/src/content/docs/api/mergeMap.md
+++ /dev/null
@@ -1,49 +0,0 @@
----
-title: "mergeMap()"
-description: "Subscribes to inner nodes in parallel (up to `concurrent`) and merges outputs (`mergeMap` / `flatMap`)."
----
-
-Subscribes to inner nodes in parallel (up to `concurrent`) and merges outputs (`mergeMap` / `flatMap`).
-
-## Signature
-
-```ts
-function mergeMap<T, R>(
-	source: Node<T>,
-	project: (value: T) => NodeInput<R>,
-	opts?: MergeMapOptions,
-): Node<R>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>source</code> | <code>Node&lt;T&gt;</code> | Upstream node. |
-| <code>project</code> | <code>(value: T) =&gt; NodeInput&lt;R&gt;</code> | Maps each outer value to an inner source shape (`Node`, scalar, `PromiseLike`, `Iterable`, or `AsyncIterable`) coerced via fromAny. |
-| <code>opts</code> | <code>MergeMapOptions</code> | Optional options including `concurrent` limit. |
-
-## Returns
-
-`Node&lt;R&gt;` - Merged output of all active inners; completes when the outer and every inner complete.
-
-## Basic Usage
-
-```ts
-import { mergeMap, state } from "@graphrefly/pure-ts";
-
-// Unbounded (default)
-mergeMap(state(0), (n) => state((n as number) + 1));
-
-// Limited concurrency
-mergeMap(state(0), (n) => state((n as number) + 1), { concurrent: 3 });
-```
-
-## Behavior Details
-
-- **ERROR handling:** An `ERROR` from the outer source cancels all active inner
-subscriptions and propagates the error downstream. An `ERROR` from an inner
-subscription propagates downstream immediately but does **not** cancel sibling
-inner subscriptions — other active inners continue until they complete or the
-outer errors/completes. This is intentional: for parallel work, isolating
-failures per-inner is more useful than Rx-style "first error cancels all."
diff --git a/website/src/content/docs/api/mermaidLiveUrl.md b/website/src/content/docs/api/mermaidLiveUrl.md
deleted file mode 100644
index 887e0c20..00000000
--- a/website/src/content/docs/api/mermaidLiveUrl.md
+++ /dev/null
@@ -1,24 +0,0 @@
----
-title: "mermaidLiveUrl()"
-description: "Encode an arbitrary mermaid source string to a `mermaid.live` deep link.\nExported separately so callers that already rendered mermaid text can\nupgrade to a live"
----
-
-Encode an arbitrary mermaid source string to a `mermaid.live` deep link.
-Exported separately so callers that already rendered mermaid text can
-upgrade to a live-editor URL without re-rendering.
-
-## Signature
-
-```ts
-function mermaidLiveUrl(
-	mermaidSrc: string,
-	opts?: { theme?: MermaidLiveTheme; autoSync?: boolean },
-): string
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>mermaidSrc</code> | <code>string</code> |  |
-| <code>opts</code> | <code>{ theme?: MermaidLiveTheme; autoSync?: boolean }</code> |  |
diff --git a/website/src/content/docs/api/messagingHub.md b/website/src/content/docs/api/messagingHub.md
deleted file mode 100644
index 3160d884..00000000
--- a/website/src/content/docs/api/messagingHub.md
+++ /dev/null
@@ -1,31 +0,0 @@
----
-title: "messagingHub()"
-description: "Creates a lazy Pulsar-inspired messaging hub. Topics are created on first access\nvia `hub.topic(name)`; `hub.publish(name, value)` shortcuts through the registr"
----
-
-Creates a lazy Pulsar-inspired messaging hub. Topics are created on first access
-via `hub.topic(name)`; `hub.publish(name, value)` shortcuts through the registry.
-
-## Signature
-
-```ts
-function messagingHub(name: string, opts?: MessagingHubOptions): MessagingHubGraph
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>name</code> | <code>string</code> |  |
-| <code>opts</code> | <code>MessagingHubOptions</code> |  |
-
-## Basic Usage
-
-```ts
-import { messagingHub } from "@graphrefly/graphrefly";
-
-const hub = messagingHub("main", { defaultTopicOptions: { retainedLimit: 256 } });
-hub.publish("orders", { id: 1 });
-hub.publishMany([["shipments", { id: 1 }], ["orders", { id: 2 }]]);
-const sub = hub.subscribe("orders-worker", "orders", { cursor: 0 });
-```
diff --git a/website/src/content/docs/api/never.md b/website/src/content/docs/api/never.md
deleted file mode 100644
index 80eaadee..00000000
--- a/website/src/content/docs/api/never.md
+++ /dev/null
@@ -1,30 +0,0 @@
----
-title: "never()"
-description: "Never emits and never completes until teardown (cold `NEVER` analogue)."
----
-
-Never emits and never completes until teardown (cold `NEVER` analogue).
-
-## Signature
-
-```ts
-function never<T = never>(opts?: ExtraOpts): Node<T>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>opts</code> | <code>ExtraOpts</code> | Optional producer options. |
-
-## Returns
-
-`Node&lt;T&gt;` — silent until unsubscribed.
-
-## Basic Usage
-
-```ts
-import { never } from "@graphrefly/pure-ts";
-
-never();
-```
diff --git a/website/src/content/docs/api/node.md b/website/src/content/docs/api/node.md
deleted file mode 100644
index 2296a1d0..00000000
--- a/website/src/content/docs/api/node.md
+++ /dev/null
@@ -1,34 +0,0 @@
----
-title: "node()"
-description: "Creates a reactive Node — the single GraphReFly primitive (§2).\n\nTypical shapes:\n- `node([])` / `node({ initial: v })` — a manual source (state node).\n- `node(p"
----
-
-Creates a reactive Node — the single GraphReFly primitive (§2).
-
-Typical shapes:
-- `node([])` / `node({ initial: v })` — a manual source (state node).
-- `node(producerFn, opts)` — a producer that runs on first-subscribe.
-- `node(deps, computeFn, opts)` — a derived / effect node.
-
-For value-returning computations, prefer the sugar factories in `sugar.ts`
-(`state`, `derived`, `effect`, `producer`, `dynamicNode`), which wrap user
-fns with `actions.emit(userFn(data))`. Calling `node()` directly gives you
-the raw `NodeFn` contract: explicit emission via `actions`, cleanup return.
-
-## Signature
-
-```ts
-function node<T = unknown>(
-	depsOrFn?: readonly Node[] | NodeFn | NodeOptions<T>,
-	fnOrOpts?: NodeFn | NodeOptions<T>,
-	optsArg?: NodeOptions<T>,
-): Node<T>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>depsOrFn</code> | <code>readonly Node[] | NodeFn | NodeOptions&lt;T&gt;</code> |  |
-| <code>fnOrOpts</code> | <code>NodeFn | NodeOptions&lt;T&gt;</code> |  |
-| <code>optsArg</code> | <code>NodeOptions&lt;T&gt;</code> |  |
diff --git a/website/src/content/docs/api/observableAdapter.md b/website/src/content/docs/api/observableAdapter.md
deleted file mode 100644
index b317c225..00000000
--- a/website/src/content/docs/api/observableAdapter.md
+++ /dev/null
@@ -1,33 +0,0 @@
----
-title: "observableAdapter()"
-description: "Wrap any LLMAdapter with a reactive stats bundle.\n\nImplementation (Unit 10 B):\n- `stats.lastCall` is a `state<CallStatsEvent | null>`.\n- Counters (`totalCalls` "
----
-
-Wrap any LLMAdapter with a reactive stats bundle.
-
-Implementation (Unit 10 B):
-- `stats.lastCall` is a `state&lt;CallStatsEvent | null&gt;`.
-- Counters (`totalCalls` / `totalInputTokens` / `totalOutputTokens`) are
-  **derived views** over `allCalls.entries` — self-maintaining, no manual
-  `.cache + 1 + emit` pattern, visible topology in `describe()`.
-- `stats.allCalls` is a `reactiveLog&lt;CallStatsEvent&gt;` — bounded, supports
-  `tail(n)` / `slice(start, stop)` for dashboard views.
-- The wrapped adapter passes DATA through via `adaptInvokeResult`, which
-  uses `onFirstData` internally to guard against re-subscription double-fire
-  and wires `.catch` for Promise-path error recording (Unit 10 A).
-
-## Signature
-
-```ts
-function observableAdapter(
-	inner: LLMAdapter,
-	opts?: { logMax?: number; name?: string },
-): { adapter: LLMAdapter; stats: AdapterStats }
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>inner</code> | <code>LLMAdapter</code> |  |
-| <code>opts</code> | <code>{ logMax?: number; name?: string }</code> |  |
diff --git a/website/src/content/docs/api/of.md b/website/src/content/docs/api/of.md
deleted file mode 100644
index 8cf1e592..00000000
--- a/website/src/content/docs/api/of.md
+++ /dev/null
@@ -1,30 +0,0 @@
----
-title: "of()"
-description: "Emits each argument as `DATA` in order, then `COMPLETE` (implemented via fromIter)."
----
-
-Emits each argument as `DATA` in order, then `COMPLETE` (implemented via fromIter).
-
-## Signature
-
-```ts
-function of<T>(...values: T[]): Node<T>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>values</code> | <code>T[]</code> | Values to emit. |
-
-## Returns
-
-`Node&lt;T&gt;` — finite sequence.
-
-## Basic Usage
-
-```ts
-import { of } from "@graphrefly/pure-ts";
-
-of(1, 2, 3);
-```
diff --git a/website/src/content/docs/api/offlinePreset.md b/website/src/content/docs/api/offlinePreset.md
deleted file mode 100644
index ec30ed67..00000000
--- a/website/src/content/docs/api/offlinePreset.md
+++ /dev/null
@@ -1,16 +0,0 @@
----
-title: "offlinePreset()"
-description: "API reference for offlinePreset."
----
-
-## Signature
-
-```ts
-function offlinePreset(opts: OfflinePresetOptions): LLMAdapter
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>opts</code> | <code>OfflinePresetOptions</code> |  |
diff --git a/website/src/content/docs/api/openAICompatAdapter.md b/website/src/content/docs/api/openAICompatAdapter.md
deleted file mode 100644
index 1495e8a7..00000000
--- a/website/src/content/docs/api/openAICompatAdapter.md
+++ /dev/null
@@ -1,16 +0,0 @@
----
-title: "openAICompatAdapter()"
-description: "API reference for openAICompatAdapter."
----
-
-## Signature
-
-```ts
-function openAICompatAdapter(opts: OpenAICompatAdapterOptions = {}): LLMAdapter
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>opts</code> | <code>OpenAICompatAdapterOptions</code> |  |
diff --git a/website/src/content/docs/api/pairwise.md b/website/src/content/docs/api/pairwise.md
deleted file mode 100644
index 77a5535b..00000000
--- a/website/src/content/docs/api/pairwise.md
+++ /dev/null
@@ -1,31 +0,0 @@
----
-title: "pairwise()"
-description: "Emits `[previous, current]` pairs starting after the second value (first pair uses `RESOLVED` only)."
----
-
-Emits `[previous, current]` pairs starting after the second value (first pair uses `RESOLVED` only).
-
-## Signature
-
-```ts
-function pairwise<T>(source: Node<T>, opts?: ExtraOpts): Node<readonly [T, T]>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>source</code> | <code>Node&lt;T&gt;</code> | Upstream node. |
-| <code>opts</code> | <code>ExtraOpts</code> | Optional NodeOptions (excluding `describeKind`). |
-
-## Returns
-
-`Node&lt;readonly [T, T]&gt;` - Pair stream.
-
-## Basic Usage
-
-```ts
-import { pairwise, state } from "@graphrefly/pure-ts";
-
-const n = pairwise(state(0));
-```
diff --git a/website/src/content/docs/api/parseCron.md b/website/src/content/docs/api/parseCron.md
deleted file mode 100644
index cbb542ff..00000000
--- a/website/src/content/docs/api/parseCron.md
+++ /dev/null
@@ -1,36 +0,0 @@
----
-title: "parseCron()"
-description: "Parses a standard 5-field cron expression into a CronSchedule.\n\nSupports `*`, ranges (`1-5`), steps (`*\\/5`, `0-30/10`), and comma-separated\nlists. Fields are: "
----
-
-Parses a standard 5-field cron expression into a CronSchedule.
-
-Supports `*`, ranges (`1-5`), steps (`*\/5`, `0-30/10`), and comma-separated
-lists. Fields are: minute (0–59), hour (0–23), day-of-month (1–31),
-month (1–12), day-of-week (0–6, Sunday = 0).
-
-## Signature
-
-```ts
-function parseCron(expr: string): CronSchedule
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>expr</code> | <code>string</code> | Five-field whitespace-separated cron string (e.g. `"0 9 * * 1-5"`). |
-
-## Returns
-
-Parsed CronSchedule with one `Set&lt;number&gt;` per field.
-
-## Basic Usage
-
-```ts
-import { parseCron } from "@graphrefly/graphrefly";
-
-const sched = parseCron("0 9 * * 1-5"); // weekdays at 09:00
-sched.hours;      // Set { 9 }
-sched.daysOfWeek; // Set { 1, 2, 3, 4, 5 }
-```
diff --git a/website/src/content/docs/api/parseRateLimitFromError.md b/website/src/content/docs/api/parseRateLimitFromError.md
deleted file mode 100644
index 109164c9..00000000
--- a/website/src/content/docs/api/parseRateLimitFromError.md
+++ /dev/null
@@ -1,21 +0,0 @@
----
-title: "parseRateLimitFromError()"
-description: "Extract a RateLimitSignal from a fetch-style error object, a Response,\nor any object exposing `.status` + `.headers` + `.message`.\n\nReturns `undefined` if no ra"
----
-
-Extract a RateLimitSignal from a fetch-style error object, a Response,
-or any object exposing `.status` + `.headers` + `.message`.
-
-Returns `undefined` if no rate-limit information can be extracted.
-
-## Signature
-
-```ts
-function parseRateLimitFromError(err: unknown): RateLimitSignal | undefined
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>err</code> | <code>unknown</code> |  |
diff --git a/website/src/content/docs/api/pausable.md b/website/src/content/docs/api/pausable.md
deleted file mode 100644
index 2e612694..00000000
--- a/website/src/content/docs/api/pausable.md
+++ /dev/null
@@ -1,33 +0,0 @@
----
-title: "pausable()"
-description: "Identity passthrough — `pausable()` has been promoted to default node behavior in v5 (§4)."
----
-
-Identity passthrough — `pausable()` has been promoted to default node behavior in v5 (§4).
-
-## Signature
-
-```ts
-function pausable<T>(source: Node<T>, opts?: ExtraOpts): Node<T>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>source</code> | <code>Node&lt;T&gt;</code> | Upstream node. |
-| <code>opts</code> | <code>ExtraOpts</code> | Optional NodeOptions (excluding `describeKind`). |
-
-## Returns
-
-`Node&lt;T&gt;` - Pass-through (identity).
-
-## Basic Usage
-
-```ts
-import { pausable, state } from "@graphrefly/pure-ts";
-
-// No longer needed — default nodes handle PAUSE/RESUME.
-const s = state(0);
-pausable(s); // identity passthrough
-```
diff --git a/website/src/content/docs/api/persistentReactiveFactStore.md b/website/src/content/docs/api/persistentReactiveFactStore.md
deleted file mode 100644
index 692299c5..00000000
--- a/website/src/content/docs/api/persistentReactiveFactStore.md
+++ /dev/null
@@ -1,41 +0,0 @@
----
-title: "persistentReactiveFactStore()"
-description: "Build a durable, event-sourced reactiveFactStore that owns\nlog↔store↔replay↔dedup correctly. Synchronous factory; the only async is\nan isolated internal replay "
----
-
-Build a durable, event-sourced reactiveFactStore that owns
-log↔store↔replay↔dedup correctly. Synchronous factory; the only async is
-an isolated internal replay source. See module docstring for the locked
-design rationale.
-
-## Signature
-
-```ts
-function persistentReactiveFactStore<T>(
-	config: PersistentReactiveFactStoreConfig<T>,
-): PersistentReactiveFactStoreGraph<T>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>config</code> | <code>PersistentReactiveFactStoreConfig&lt;T&gt;</code> |  |
-
-## Basic Usage
-
-```ts
-import { persistentReactiveFactStore } from "@graphrefly/graphrefly";
-import { memoryBackend } from "@graphrefly/pure-ts/extra";
-
-const ingest = node<MemoryFragment<Doc>>([], { initial: undefined });
-const mem = persistentReactiveFactStore<Doc>({
-    ingest,
-    extractDependencies: (f) => f.sources,
-    storage: memoryBackend(),
-  });
-// Restart is automatic: the durable history is replayed through `ingest`
-// on construction; observe `mem.replayedCount` / `mem.position`.
-ingest.emit(myFragment);            // live — persisted (not re-persisted)
-await mem.flush();                  // force physically durable
-```
diff --git a/website/src/content/docs/api/pipe.md b/website/src/content/docs/api/pipe.md
deleted file mode 100644
index 4792380d..00000000
--- a/website/src/content/docs/api/pipe.md
+++ /dev/null
@@ -1,29 +0,0 @@
----
-title: "pipe()"
-description: "Composes unary operators left-to-right; returns the final node."
----
-
-Composes unary operators left-to-right; returns the final node.
-
-## Signature
-
-```ts
-function pipe(source: Node, ...ops: PipeOperator[]): Node
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>source</code> | <code>Node</code> |  |
-| <code>ops</code> | <code>PipeOperator[]</code> |  |
-
-## Basic Usage
-
-```ts
-const out = pipe(
-  source,
-  (n) => map(n, (x) => x + 1),
-  (n) => filter(n, (x) => x > 0),
-);
-```
diff --git a/website/src/content/docs/api/pipelineGraph.md b/website/src/content/docs/api/pipelineGraph.md
deleted file mode 100644
index 1c42f7d2..00000000
--- a/website/src/content/docs/api/pipelineGraph.md
+++ /dev/null
@@ -1,19 +0,0 @@
----
-title: "pipelineGraph()"
-description: "Factory wrapper — `pipelineGraph(name, opts?)`. Equivalent to `new PipelineGraph(name, opts)`."
----
-
-Factory wrapper — `pipelineGraph(name, opts?)`. Equivalent to `new PipelineGraph(name, opts)`.
-
-## Signature
-
-```ts
-function pipelineGraph(name: string, opts?: GraphOptions): PipelineGraph
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>name</code> | <code>string</code> |  |
-| <code>opts</code> | <code>GraphOptions</code> |  |
diff --git a/website/src/content/docs/api/policy.md b/website/src/content/docs/api/policy.md
deleted file mode 100644
index 6374c177..00000000
--- a/website/src/content/docs/api/policy.md
+++ /dev/null
@@ -1,32 +0,0 @@
----
-title: "policy()"
-description: "Declarative guard builder. Precedence: any matching **deny** blocks even if an allow also matches.\nIf no rule matches, the guard returns `false` (deny-by-defaul"
----
-
-Declarative guard builder. Precedence: any matching **deny** blocks even if an allow also matches.
-If no rule matches, the guard returns `false` (deny-by-default). Aligned with graphrefly-py `policy()`.
-
-## Signature
-
-```ts
-function policy(build: (allow: PolicyAllow, deny: PolicyDeny) => void): NodeGuard
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>build</code> | <code>(allow: PolicyAllow, deny: PolicyDeny) =&gt; void</code> | Callback that registers `allow(...)` / `deny(...)` rules in order. |
-
-## Returns
-
-A `NodeGuard` for use as `node({ guard })`.
-
-## Basic Usage
-
-```ts
-const guard = policy((allow, deny) => {
-    allow("observe");
-    deny("write", { where: (a) => a.type === "llm" });
-  });
-```
diff --git a/website/src/content/docs/api/policyEnforcer.md b/website/src/content/docs/api/policyEnforcer.md
deleted file mode 100644
index f4da4b1d..00000000
--- a/website/src/content/docs/api/policyEnforcer.md
+++ /dev/null
@@ -1,27 +0,0 @@
----
-title: "policyEnforcer()"
-description: "Wraps a Graph with reactive policy enforcement. Pass either a\nstatic rule list or a Node of rules (LLM-updatable). Records\n`PolicyViolation` entries to `violati"
----
-
-Wraps a Graph with reactive policy enforcement. Pass either a
-static rule list or a Node of rules (LLM-updatable). Records
-`PolicyViolation` entries to `violations` topic; in `"enforce"` mode also
-pushes guards onto target nodes so disallowed writes throw.
-
-## Signature
-
-```ts
-function policyEnforcer(
-	target: Graph,
-	policies: readonly PolicyRuleData[] | Node<readonly PolicyRuleData[]>,
-	opts: PolicyEnforcerOptions = {},
-): PolicyEnforcerGraph
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| `target` | `Graph` |  |
-| `policies` | `readonly PolicyRuleData[] | Node&lt;readonly PolicyRuleData[]&gt;` |  |
-| `opts` | `PolicyEnforcerOptions` |  |
diff --git a/website/src/content/docs/api/policyGate.md b/website/src/content/docs/api/policyGate.md
deleted file mode 100644
index a00e73f3..00000000
--- a/website/src/content/docs/api/policyGate.md
+++ /dev/null
@@ -1,31 +0,0 @@
----
-title: "policyGate()"
-description: "Wraps a Graph with reactive policy enforcement. Pass either a\nstatic rule list or a Node of rules (LLM-updatable). Records\n`PolicyViolation` entries to `violati"
----
-
-Wraps a Graph with reactive policy enforcement. Pass either a
-static rule list or a Node of rules (LLM-updatable). Records
-`PolicyViolation` entries to `violations` topic; in `"enforce"` mode also
-pushes guards onto target nodes so disallowed writes throw.
-
-Self-tags via `g.tagFactory("policyGate", placeholderArgs(opts))` so
-`graph.describe()` surfaces `factory: "policyGate"` provenance (Phase 2.5
-DT5 ride-along, locked with the Tier 2.3 rename).
-
-## Signature
-
-```ts
-function policyGate(
-	target: Graph,
-	policies: readonly PolicyRuleData[] | Node<readonly PolicyRuleData[]>,
-	opts: PolicyGateOptions = {},
-): PolicyGateGraph
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>target</code> | <code>Graph</code> |  |
-| <code>policies</code> | <code>readonly PolicyRuleData[] | Node&lt;readonly PolicyRuleData[]&gt;</code> |  |
-| <code>opts</code> | <code>PolicyGateOptions</code> |  |
diff --git a/website/src/content/docs/api/processInstanceKeyOf.md b/website/src/content/docs/api/processInstanceKeyOf.md
deleted file mode 100644
index 12a57186..00000000
--- a/website/src/content/docs/api/processInstanceKeyOf.md
+++ /dev/null
@@ -1,18 +0,0 @@
----
-title: "processInstanceKeyOf()"
-description: "Recommended `keyOf` for storage tiers keyed by correlationId (Audit 2)."
----
-
-Recommended `keyOf` for storage tiers keyed by correlationId (Audit 2).
-
-## Signature
-
-```ts
-processInstanceKeyOf<TState>(i: ProcessInstance<TState>): string
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>i</code> | <code>ProcessInstance&lt;TState&gt;</code> |  |
diff --git a/website/src/content/docs/api/processManager.md b/website/src/content/docs/api/processManager.md
deleted file mode 100644
index cdbd1585..00000000
--- a/website/src/content/docs/api/processManager.md
+++ /dev/null
@@ -1,58 +0,0 @@
----
-title: "processManager()"
-description: "Create a process manager that coordinates long-running reactive workflows\nover a CqrsGraph.\n\nProcess instances are identified by `correlationId`. Events from th"
----
-
-Create a process manager that coordinates long-running reactive workflows
-over a CqrsGraph.
-
-Process instances are identified by `correlationId`. Events from the watched
-event types are routed to per-instance step handlers when the event's
-`correlationId` matches a running instance.
-
-```ts
-const app = cqrs&lt;{ orderPlaced: { orderId: string }; paymentReceived: { amount: number } }&gt;("orders");
-
-const pm = processManager(app, "fulfillment", {
-  initial: { step: "awaiting-payment", total: 0 },
-  watching: ["orderPlaced", "paymentReceived"],
-  steps: {
-    orderPlaced(state, event) {
-      return { outcome: "success", state: { ...state, orderId: event.payload.orderId } };
-    },
-    paymentReceived(state, event) {
-      return { outcome: "terminate", state: { ...state, total: event.payload.amount } };
-    },
-  },
-  compensate(state, _error) {
-    // undo reservation, issue refund, etc.
-  },
-  retryMax: 2,
-  backoffMs: [100, 500],
-});
-
-pm.start("order-123");
-app.dispatch("orderPlaced", { orderId: "order-123" }, { correlationId: "order-123" });
-```
-
-## Signature
-
-```ts
-function processManager<TState, EM extends CqrsEventMap = Record<string, unknown>>(
-	cqrsGraph: CqrsGraph<EM>,
-	name: string,
-	opts: ProcessManagerOpts<TState, EM>,
-): ProcessManagerResult<TState>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>cqrsGraph</code> | <code>CqrsGraph&lt;EM&gt;</code> | The CQRS graph whose event streams the manager watches. |
-| <code>name</code> | <code>string</code> | Stable identifier for this process type; used for the
-synthetic event-type prefix `_process_&lt;name&gt;_*`. Currently emits
-`_process_&lt;name&gt;_started` per `start()`; the prefix is reserved for
-future `_state` / `_timer` channels. |
-| <code>opts</code> | <code>ProcessManagerOpts&lt;TState, EM&gt;</code> | Configuration: initial state, watched events, steps, retry,
-compensation, and optional persistence. |
diff --git a/website/src/content/docs/api/processStateKeyOf.md b/website/src/content/docs/api/processStateKeyOf.md
deleted file mode 100644
index ad50d51e..00000000
--- a/website/src/content/docs/api/processStateKeyOf.md
+++ /dev/null
@@ -1,18 +0,0 @@
----
-title: "processStateKeyOf()"
-description: "Recommended `keyOf` for `KvStorageTier<ProcessStateSnapshot<...>>`."
----
-
-Recommended `keyOf` for `KvStorageTier&lt;ProcessStateSnapshot&lt;...&gt;&gt;`.
-
-## Signature
-
-```ts
-processStateKeyOf<TState>(s: ProcessStateSnapshot<TState>): string
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>s</code> | <code>ProcessStateSnapshot&lt;TState&gt;</code> |  |
diff --git a/website/src/content/docs/api/producer.md b/website/src/content/docs/api/producer.md
deleted file mode 100644
index 00c6c474..00000000
--- a/website/src/content/docs/api/producer.md
+++ /dev/null
@@ -1,32 +0,0 @@
----
-title: "producer()"
-description: "Creates a producer node with no deps; `fn` runs once when the first\nsubscriber connects. Return a cleanup function (`() => void` — fires on\nevery transition) or"
----
-
-Creates a producer node with no deps; `fn` runs once when the first
-subscriber connects. Return a cleanup function (`() =&gt; void` — fires on
-every transition) or an object with granular hooks
-(`{ beforeRun?, deactivate?, invalidate? }` — each hook fires on its named
-transition only) to register teardown. See NodeFnCleanup.
-
-## Signature
-
-```ts
-function producer<T = unknown>(fn: ProducerFn, opts?: NodeOptions<T>): Node<T>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| `fn` | `ProducerFn` |  |
-| `opts` | `NodeOptions&lt;T&gt;` |  |
-
-## Basic Usage
-
-```ts
-const ticker = producer((actions) => {
-    const id = setInterval(() => actions.emit(Date.now()), 1000);
-    return () => clearInterval(id);
-  });
-```
diff --git a/website/src/content/docs/api/promptCall.md b/website/src/content/docs/api/promptCall.md
deleted file mode 100644
index a841b458..00000000
--- a/website/src/content/docs/api/promptCall.md
+++ /dev/null
@@ -1,39 +0,0 @@
----
-title: "promptCall()"
-description: "Build a one-shot LLM JSON-call factory: each invocation wraps `input` in a\nfresh `node([], { initial: input })`, delegates to `promptNode({format: \"json\"})`, an"
----
-
-Build a one-shot LLM JSON-call factory: each invocation wraps `input` in a
-fresh `node([], { initial: input })`, delegates to `promptNode({format: "json"})`, and
-returns a `NodeInput&lt;TOut&gt;` that the caller plugs into `distill` /
-`agentLoop` / any reactive composition that accepts `NodeInput`.
-
-**Per-call lifecycle.** The returned `NodeInput&lt;TOut&gt;` is a producer that
-emits exactly one `DATA` per upstream input (per Tier 1.2 Session C lock —
-`promptNode` guarantees one DATA per wave). When the consumer's switchMap
-supersedes it, the per-call `node([], { initial: input })` and the inner `prompt_node::response`
-tear down together.
-
-## Signature
-
-```ts
-function promptCall<TIn, TOut>(
-	systemPrompt: string,
-	buildUserContent: (input: TIn) => string,
-	opts: PromptCallOptions,
-	defaultName: string,
-): (input: TIn) => NodeInput<TOut>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>systemPrompt</code> | <code>string</code> | System message sent on every call. |
-| <code>buildUserContent</code> | <code>(input: TIn) =&gt; string</code> | Per-input user-content builder (must be JSON-stringifiable). |
-| <code>opts</code> | <code>PromptCallOptions</code> | Adapter + model/temperature/maxTokens + optional name prefix. |
-| <code>defaultName</code> | <code>string</code> | Path-prefix fallback when `opts.name` is omitted. |
-
-## Returns
-
-Factory `(input: TIn) =&gt; NodeInput&lt;TOut&gt;`.
diff --git a/website/src/content/docs/api/pubsub.md b/website/src/content/docs/api/pubsub.md
deleted file mode 100644
index f97e86e2..00000000
--- a/website/src/content/docs/api/pubsub.md
+++ /dev/null
@@ -1,45 +0,0 @@
----
-title: "pubsub()"
-description: "Creates a lazy per-topic state hub."
----
-
-Creates a lazy per-topic state hub.
-
-## Signature
-
-```ts
-function pubsub(options: PubSubHubOptions = {}): PubSubHub
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>options</code> | <code>PubSubHubOptions</code> | Optional pluggable `backend` (defaults to `NativePubSubBackend`). |
-
-## Returns
-
-Hub with lazy `topic()` / `publish()` / `publishMany()` / `removeTopic()` /
-`has()` / `size` / `topicNames()`.
-
-## Basic Usage
-
-```ts
-import { pubsub } from "@graphrefly/graphrefly";
-
-const hub = pubsub();
-const t = hub.topic("events");
-t.subscribe((msgs) => console.log(msgs));
-hub.publish("events", { ok: true });
-hub.publishMany([["events", 1], ["status", "ready"]]);
-```
-
-## Behavior Details
-
-- **Scope:** Each topic is a sentinel node — retains only the last published
-value (no push-on-subscribe before the first publish). For Pulsar-inspired
-retention + cursor reading, use `messagingHub()` in `utils/messaging`.
-
-**`removeTopic`:** Sends `TEARDOWN` to the topic node; all subscribers receive
-the TEARDOWN message. Subsequent `publish(name, value)` silently recreates the
-topic with a fresh node — existing subscribers to the old node do NOT reconnect.
diff --git a/website/src/content/docs/api/race.md b/website/src/content/docs/api/race.md
deleted file mode 100644
index bef593d7..00000000
--- a/website/src/content/docs/api/race.md
+++ /dev/null
@@ -1,30 +0,0 @@
----
-title: "race()"
-description: "First source to emit **`DATA`** wins; later traffic follows only the winner (Rx-style `race`)."
----
-
-First source to emit **`DATA`** wins; later traffic follows only the winner (Rx-style `race`).
-
-## Signature
-
-```ts
-function race<T>(...sources: readonly Node<T>[]): Node<T>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>sources</code> | <code>readonly Node&lt;T&gt;[]</code> | Contestants (variadic; throws at construction when empty; one node is identity). |
-
-## Returns
-
-`Node&lt;T&gt;` - Winning stream.
-
-## Basic Usage
-
-```ts
-import { race, state } from "@graphrefly/pure-ts";
-
-const n = race(state(1), state(2));
-```
diff --git a/website/src/content/docs/api/rateLimiter.md b/website/src/content/docs/api/rateLimiter.md
deleted file mode 100644
index 12c36cf4..00000000
--- a/website/src/content/docs/api/rateLimiter.md
+++ /dev/null
@@ -1,56 +0,0 @@
----
-title: "rateLimiter()"
-description: "Token-bucket rate limiter: at most `maxEvents` `DATA` values per `windowNs`.\n\nUses tokenBucket internally (capacity = `maxEvents`, refill = `maxEvents / windowS"
----
-
-Token-bucket rate limiter: at most `maxEvents` `DATA` values per `windowNs`.
-
-Uses tokenBucket internally (capacity = `maxEvents`, refill = `maxEvents / windowSeconds`).
-Excess items are queued FIFO (in a fixed-capacity RingBuffer for O(1) push/shift)
-until a token is available. The queue is bounded by the **required** `maxBuffer` option
-with a configurable overflow policy.
-
-## Signature
-
-```ts
-function rateLimiter<T>(
-	source: Node<T>,
-	opts: NodeOrValue<RateLimiterOptions>,
-): RateLimiterBundle<T>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>source</code> | <code>Node&lt;T&gt;</code> | Upstream node. |
-| <code>opts</code> | <code>NodeOrValue&lt;RateLimiterOptions&gt;</code> | Rate + bounded-buffer configuration. `maxBuffer` is required (use `Infinity` to opt in to unbounded). |
-
-## Returns
-
-`{ node, droppedCount }` bundle. Subscribe to `node` for the throttled stream and to `droppedCount` for backpressure pressure.
-
-## Basic Usage
-
-```ts
-import { rateLimiter, state, NS_PER_SEC } from "@graphrefly/graphrefly";
-
-const src = state(0);
-// Allow at most 5 DATA values per second; queue up to 100 excess items, drop newest beyond.
-const { node: limited, droppedCount } = rateLimiter(src, {
-    maxEvents: 5,
-    windowNs: NS_PER_SEC,
-    maxBuffer: 100,
-  });
-droppedCount.subscribe(([m]) => console.log("dropped so far:", m[1]));
-```
-
-## Behavior Details
-
-- **Reactive opts (Node form) must be seeded.** Mode (bounded vs unbounded)
-and the initial cap are read from `opts.cache` at construction and the swap
-handler rejects mode toggles. An un-seeded opts Node therefore throws at
-construction rather than silently locking bounded `maxBuffer: 1` (D4).
-
-**Terminal:** `COMPLETE` / `ERROR` cancel the refill timer, drop the pending queue,
-reset `droppedCount` to `0`, and propagate.
diff --git a/website/src/content/docs/api/reachable.md b/website/src/content/docs/api/reachable.md
deleted file mode 100644
index a1fe190b..00000000
--- a/website/src/content/docs/api/reachable.md
+++ /dev/null
@@ -1,30 +0,0 @@
----
-title: "reachable()"
-description: "API reference for reachable."
----
-
-## Signature
-
-```ts
-function reachable(
-	described: GraphDescribeOutput,
-	from: string,
-	direction: ReachableDirection,
-	options?: ReachableOptions & { withDetail: true },
-): ReachableResult
-function reachable(
-	described: GraphDescribeOutput,
-	from: string,
-	direction: ReachableDirection,
-	options?: ReachableOptions,
-): string[]
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>described</code> | <code>GraphDescribeOutput</code> |  |
-| <code>from</code> | <code>string</code> |  |
-| <code>direction</code> | <code>ReachableDirection</code> |  |
-| <code>options</code> | <code>ReachableOptions</code> |  |
diff --git a/website/src/content/docs/api/reactiveBlockLayout.md b/website/src/content/docs/api/reactiveBlockLayout.md
index d4a79851..2fe971c5 100644
--- a/website/src/content/docs/api/reactiveBlockLayout.md
+++ b/website/src/content/docs/api/reactiveBlockLayout.md
@@ -1,24 +1,26 @@
 ---
 title: "reactiveBlockLayout()"
-description: "Create a reactive block layout graph for mixed content (text + image + SVG).\n\n```\nGraph(\"reactive-block-layout\")\n├── node([], { initial: \"blocks\" })            "
+description: "Create a DOM-free reactive block layout bundle for text, image, and SVG blocks."
 ---
 
-Create a reactive block layout graph for mixed content (text + image + SVG).
+Create a DOM-free reactive block layout bundle for mixed content.
 
 ```
 Graph("reactive-block-layout")
-├── node([], { initial: "blocks" })              — ContentBlock[] input
-├── node([], { initial: "max-width" })           — container constraint
-├── node([], { initial: "gap" })                 — vertical gap (px)
-├── derived("measured-blocks")   — blocks + max-width → MeasuredBlock[]
-├── derived("block-flow")        — measured-blocks + gap → PositionedBlock[]
-├── derived("total-height")      — block-flow → number
-└── meta: { block-count, layout-time-ns }
+├── state("blocks")       — ContentBlock[] input
+├── state("max-width")    — container constraint
+├── state("gap")          — vertical gap
+├── node("blocks-measurements") — blocks + max-width -> Measurements
+├── node("measured-blocks") — measurements -> MeasuredBlock[]
+├── node("block-flow")      — measured-blocks + gap -> PositionedBlock[]
+└── node("total-height")    — block-flow -> number
 ```
 
 ## Signature
 
 ```ts
+import { reactiveBlockLayout } from "@graphrefly/ts/solutions/reactive-layout";
+
 function reactiveBlockLayout(opts: ReactiveBlockLayoutOptions): ReactiveBlockLayoutBundle
 ```
 
@@ -26,4 +28,8 @@ function reactiveBlockLayout(opts: ReactiveBlockLayoutOptions): ReactiveBlockLay
 
 | Parameter | Type | Description |
 |-----------|------|-------------|
-| <code>opts</code> | <code>ReactiveBlockLayoutOptions</code> |  |
+| <code>opts</code> | <code>ReactiveBlockLayoutOptions</code> | Requires `graph` and a graph-visible `measurements` node; optional gap, target id, and bundle name. Blocks and max width belong to the upstream provider composition. |
+
+Use `blockMeasurementProvider` upstream when you want GraphReFly to build the block measurement
+facts from sync text/image/SVG capabilities. Missing image/SVG/text measurement is emitted by the
+provider as DATA-level `DataIssue`; layout defaults to no-op for issue-only facts.
diff --git a/website/src/content/docs/api/reactiveFactStore.md b/website/src/content/docs/api/reactiveFactStore.md
deleted file mode 100644
index 7323ca70..00000000
--- a/website/src/content/docs/api/reactiveFactStore.md
+++ /dev/null
@@ -1,23 +0,0 @@
----
-title: "reactiveFactStore()"
-description: "Build a static-topology reactive fact store (DS-14.7 architecture C).\n\nThin factory over ReactiveFactStoreGraph — see that class for the\nfull topology / locked-"
----
-
-Build a static-topology reactive fact store (DS-14.7 architecture C).
-
-Thin factory over ReactiveFactStoreGraph — see that class for the
-full topology / locked-decision docs and the `instanceof`-narrowable type.
-
-## Signature
-
-```ts
-function reactiveFactStore<T>(
-	config: ReactiveFactStoreConfig<T>,
-): ReactiveFactStoreGraph<T>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>config</code> | <code>ReactiveFactStoreConfig&lt;T&gt;</code> |  |
diff --git a/website/src/content/docs/api/reactiveIndex.md b/website/src/content/docs/api/reactiveIndex.md
deleted file mode 100644
index e3f426c7..00000000
--- a/website/src/content/docs/api/reactiveIndex.md
+++ /dev/null
@@ -1,45 +0,0 @@
----
-title: "reactiveIndex()"
-description: "Creates a reactive index: unique primary key per row, rows sorted by `(secondary, primary)` for ordered scans."
----
-
-Creates a reactive index: unique primary key per row, rows sorted by `(secondary, primary)` for ordered scans.
-
-## Signature
-
-```ts
-function reactiveIndex<K, V = unknown>(
-	options: ReactiveIndexOptions<K, V> = {},
-): ReactiveIndexBundle<K, V>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>options</code> | <code>ReactiveIndexOptions&lt;K, V&gt;</code> | Optional `name` for `describe()` / debugging, and optional `backend` (see IndexBackend). |
-
-## Returns
-
-Bundle with `ordered` (sorted rows), `byPrimary` (map), O(1) `has` / `get` / `size`,
-imperative `upsert` / `upsertMany` / `delete` / `deleteMany` / `clear`.
-
-## Basic Usage
-
-```ts
-import { reactiveIndex } from "@graphrefly/pure-ts";
-
-const idx = reactiveIndex<string, string>();
-idx.upsert("id1", 10, "row-a");
-idx.upsert("id2", 5, "row-b");
-```
-
-## Behavior Details
-
-- **Ordering:** `secondary` and `primary` are compared via a small total order: same primitive `typeof` uses
-numeric/string/boolean/bigint comparison; mixed or object keys fall back to `String(a).localeCompare(String(b))`
-(not identical to Python's rich comparison for exotic types).
-
-**Backend:** The default NativeIndexBackend offers O(1) primary-key lookups and O(n) upserts.
-For scale beyond a few thousand rows, supply a user-pluggable persistent/B-tree backend via the
-`backend` option — reactive emission semantics are unchanged.
diff --git a/website/src/content/docs/api/reactiveLayout.md b/website/src/content/docs/api/reactiveLayout.md
index 89ee9a6e..49f5969f 100644
--- a/website/src/content/docs/api/reactiveLayout.md
+++ b/website/src/content/docs/api/reactiveLayout.md
@@ -1,25 +1,28 @@
 ---
 title: "reactiveLayout()"
-description: "Create a reactive text layout graph.\n\n```\nGraph(\"reactive-layout\")\n├── node([], { initial: \"text\" })\n├── node([], { initial: \"font\" })\n├── node([], { initial: \""
+description: "Create a DOM-free, graph-visible text layout bundle."
 ---
 
-Create a reactive text layout graph.
+Create a DOM-free, graph-visible text layout bundle.
 
 ```
 Graph("reactive-layout")
-├── node([], { initial: "text" })
-├── node([], { initial: "font" })
-├── node([], { initial: "line-height" })
-├── node([], { initial: "max-width" })
-├── derived("segments")      — text + font → PreparedSegment[]
-├── derived("line-breaks")   — segments + max-width → LineBreaksResult
-├── derived("height")        — line-breaks → number
-└── derived("char-positions") — line-breaks + segments → CharPosition[]
+├── state("text")
+├── state("font")
+├── state("line-height")
+├── state("max-width")
+├── node("text-measurements") — text + font -> Measurements
+├── node("segments")       — measurements -> PreparedSegment[]
+├── node("line-breaks")    — segments + max-width + measurements -> LineBreaksResult
+├── node("height")         — line-breaks + line-height -> number
+└── node("char-positions") — line-breaks + segments + line-height -> CharPosition[]
 ```
 
 ## Signature
 
 ```ts
+import { reactiveLayout } from "@graphrefly/ts/solutions/reactive-layout";
+
 function reactiveLayout(opts: ReactiveLayoutOptions): ReactiveLayoutBundle
 ```
 
@@ -27,4 +30,21 @@ function reactiveLayout(opts: ReactiveLayoutOptions): ReactiveLayoutBundle
 
 | Parameter | Type | Description |
 |-----------|------|-------------|
-| <code>opts</code> | <code>ReactiveLayoutOptions</code> |  |
+| <code>opts</code> | <code>ReactiveLayoutOptions</code> | Requires `graph` and a graph-visible `measurements` node; optional `lineHeight`, `maxWidth`, `segmentAdapter`, `targetId`, and bundle `name`. |
+
+Measurement providers are upstream graph nodes. Browser Canvas measurement is browser-only:
+
+```ts
+import { graph } from "@graphrefly/ts";
+import { reactiveLayout, cellTextMeasurements } from "@graphrefly/ts/solutions/reactive-layout";
+
+const g = graph({ name: "article" });
+const text = g.state("Hello", { name: "text" });
+const font = g.state("16px system-ui", { name: "font" });
+const measurements = cellTextMeasurements({ graph: g, text, font });
+
+const layout = reactiveLayout({ graph: g, measurements });
+```
+
+Missing or failed measurements are `DataIssue` facts inside ordinary `DATA`; the default layout
+consumer ignores them for measurement purposes and does not emit protocol `ERROR`.
diff --git a/website/src/content/docs/api/reactiveList.md b/website/src/content/docs/api/reactiveList.md
deleted file mode 100644
index 990e4050..00000000
--- a/website/src/content/docs/api/reactiveList.md
+++ /dev/null
@@ -1,47 +0,0 @@
----
-title: "reactiveList()"
-description: "Creates a reactive list with immutable array snapshots."
----
-
-Creates a reactive list with immutable array snapshots.
-
-## Signature
-
-```ts
-function reactiveList<T>(
-	initial?: readonly T[],
-	options: ReactiveListOptions<T> = {},
-): ReactiveListBundle<T>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>initial</code> | <code>readonly T[]</code> | Optional initial items (copied). |
-| <code>options</code> | <code>ReactiveListOptions&lt;T&gt;</code> | Optional `name` for `describe()` / debugging, or pluggable `backend`. |
-
-## Returns
-
-Bundle with `items` (state node), `size` / `at`, `append` / `appendMany` / `insert` /
-`insertMany` / `pop` / `clear`.
-
-## Basic Usage
-
-```ts
-import { reactiveList } from "@graphrefly/pure-ts";
-
-const list = reactiveList<string>(["a"], { name: "queue" });
-list.append("b");
-list.insertMany(1, ["x", "y"]);
-```
-
-## Behavior Details
-
-- **No `maxSize`:** insert/pop-anywhere semantics make eviction-under-cap ambiguous.
-For bounded append-heavy workloads use `reactiveLog` (head-trim is well-defined for
-append-only).
-
-**Backend:** Default NativeListBackend. For persistent / RRB-tree semantics
-supply a custom ListBackend. If you provide a `backend`, `initial` is ignored
-— seed the backend directly.
diff --git a/website/src/content/docs/api/reactiveLog.md b/website/src/content/docs/api/reactiveLog.md
deleted file mode 100644
index e8b505f3..00000000
--- a/website/src/content/docs/api/reactiveLog.md
+++ /dev/null
@@ -1,51 +0,0 @@
----
-title: "reactiveLog()"
-description: "Creates an append-only reactive log that emits immutable `readonly T[]` snapshots.\n\nEach structural mutation (`append`, `appendMany`, `clear`, `trimHead`) trigg"
----
-
-Creates an append-only reactive log that emits immutable `readonly T[]` snapshots.
-
-Each structural mutation (`append`, `appendMany`, `clear`, `trimHead`) triggers
-a two-phase `[DIRTY, DATA]` emission on the `entries` node so downstream
-derived nodes update reactively. Views (`tail`, `slice`, `fromCursor`) are
-memoized derived nodes — subscribe once and they stay live.
-
-## Signature
-
-```ts
-function reactiveLog<T>(
-	initial?: readonly T[],
-	options: ReactiveLogOptions<T> = {},
-): ReactiveLogBundle<T>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>initial</code> | <code>readonly T[]</code> | Optional initial entries loaded into the log at construction. |
-| <code>options</code> | <code>ReactiveLogOptions&lt;T&gt;</code> | Optional name, max size (ring buffer), versioning level, guard policy, and custom backend. |
-
-## Returns
-
-`ReactiveLogBundle&lt;T&gt;` with `entries`, `append`, `appendMany`, `clear`, `trimHead`, `view`, `attach`, `attachStorage`, and disposal methods.
-
-## Basic Usage
-
-```ts
-import { reactiveLog } from "@graphrefly/graphrefly/extra";
-
-const log = reactiveLog<string>([], { name: "messages" });
-log.entries.subscribe((msgs) => {
-    for (const m of msgs) {
-      if (m[0] === 1) console.log("entries:", m[1]);
-    }
-});
-log.append("hello");
-log.append("world");
-```
-
-## Behavior Details
-
-- **Ring buffer:** Pass `maxSize` to cap the log length; older entries are evicted on overflow.
-**Storage:** Call `attachStorage(tiers)` to wire one or more `AppendLogStorageTier` instances for persistence.
diff --git a/website/src/content/docs/api/reactiveMap.md b/website/src/content/docs/api/reactiveMap.md
deleted file mode 100644
index d5b43eee..00000000
--- a/website/src/content/docs/api/reactiveMap.md
+++ /dev/null
@@ -1,50 +0,0 @@
----
-title: "reactiveMap()"
-description: "Creates a reactive `Map` with optional per-key TTL and optional LRU max size."
----
-
-Creates a reactive `Map` with optional per-key TTL and optional LRU max size.
-
-## Signature
-
-```ts
-function reactiveMap<K, V>(options: ReactiveMapOptions<K, V> = {}): ReactiveMapBundle<K, V>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>options</code> | <code>ReactiveMapOptions&lt;K, V&gt;</code> | `name`, `maxSize`, `defaultTtl` (seconds), or custom `backend`. |
-
-## Returns
-
-`ReactiveMapBundle` — imperative methods (`has`/`get`/`set`/`setMany`/`delete`/
-`deleteMany`/`clear`/`pruneExpired`), reactive `entries` node, and O(1)-ish `size`.
-
-## Basic Usage
-
-```ts
-import { reactiveMap } from "@graphrefly/pure-ts";
-
-const m = reactiveMap<string, number>({ name: "cache", maxSize: 100, defaultTtl: 60 });
-m.set("x", 1);
-m.setMany([["y", 2], ["z", 3]]);
-m.entries.subscribe((msgs) => { console.log(msgs); });
-```
-
-## Behavior Details
-
-- **TTL:** Expiry is checked on `get`, `has`, `size`, `pruneExpired`, and before each
-snapshot emission (expired keys are pruned first). Reads that discover expired keys
-emit a snapshot so subscribers see state consistent with the read's return value.
-There is no background timer; monotonic-clock expiry is immune to wall-clock changes.
-
-**LRU:** Uses native `Map` insertion order — `get` / `has` refreshes position via
-delete-then-reinsert; under `maxSize` pressure the first key in iteration order is
-evicted. LRU touching does NOT trigger emission (internal optimization).
-
-**Backend:** The default NativeMapBackend owns LRU/TTL. For persistent /
-HAMT / shared-state semantics plug in a custom MapBackend. `maxSize` and
-`defaultTtl` on the options object are only applied to the default backend — if
-you supply `backend`, configure those on your backend directly.
diff --git a/website/src/content/docs/api/reduce.md b/website/src/content/docs/api/reduce.md
deleted file mode 100644
index 69c65dda..00000000
--- a/website/src/content/docs/api/reduce.md
+++ /dev/null
@@ -1,41 +0,0 @@
----
-title: "reduce()"
-description: "Reduces to one value emitted when `source` completes; if no `DATA` arrived, emits `seed`.\n\nUnlike RxJS, `seed` is always required. If the source completes witho"
----
-
-Reduces to one value emitted when `source` completes; if no `DATA` arrived, emits `seed`.
-
-Unlike RxJS, `seed` is always required. If the source completes without emitting
-DATA, the seed value is emitted (RxJS would throw without a seed).
-
-## Signature
-
-```ts
-function reduce<T, R>(
-	source: Node<T>,
-	reducer: (acc: R, value: T) => R,
-	seed: R,
-	opts?: ExtraOpts,
-): Node<R>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>source</code> | <code>Node&lt;T&gt;</code> | Upstream node. |
-| <code>reducer</code> | <code>(acc: R, value: T) =&gt; R</code> | `(acc, value) =&gt; nextAcc`. |
-| <code>seed</code> | <code>R</code> | Empty-completion default and initial accumulator (required). |
-| <code>opts</code> | <code>ExtraOpts</code> | Optional NodeOptions (excluding `describeKind`). |
-
-## Returns
-
-`Node&lt;R&gt;` - Node that emits once on completion.
-
-## Basic Usage
-
-```ts
-import { reduce, state } from "@graphrefly/pure-ts";
-
-const n = reduce(state(1), (a, x) => a + x, 0);
-```
diff --git a/website/src/content/docs/api/registryPricing.md b/website/src/content/docs/api/registryPricing.md
deleted file mode 100644
index 762efc4e..00000000
--- a/website/src/content/docs/api/registryPricing.md
+++ /dev/null
@@ -1,21 +0,0 @@
----
-title: "registryPricing()"
-description: "Build a `PricingFn` from a `PricingRegistry`. If no entry matches, returns\n`{ total: 0, currency: \"USD\" }` (never throws). Callers who need \"unknown\nmodel\" fail"
----
-
-Build a `PricingFn` from a `PricingRegistry`. If no entry matches, returns
-`{ total: 0, currency: "USD" }` (never throws). Callers who need "unknown
-model" failures can compose their own `PricingFn`.
-
-## Signature
-
-```ts
-function registryPricing(registry: PricingRegistry, defaultCurrency = "USD"): PricingFn
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>registry</code> | <code>PricingRegistry</code> |  |
-| <code>defaultCurrency</code> | <code>unknown</code> |  |
diff --git a/website/src/content/docs/api/repeat.md b/website/src/content/docs/api/repeat.md
deleted file mode 100644
index 291f8758..00000000
--- a/website/src/content/docs/api/repeat.md
+++ /dev/null
@@ -1,32 +0,0 @@
----
-title: "repeat()"
-description: "Subscribes to `source` repeatedly (`count` times, sequentially). Best with a fresh or `resubscribable` source."
----
-
-Subscribes to `source` repeatedly (`count` times, sequentially). Best with a fresh or `resubscribable` source.
-
-## Signature
-
-```ts
-function repeat<T>(source: Node<T>, count: number, opts?: ExtraOpts): Node<T>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>source</code> | <code>Node&lt;T&gt;</code> | Upstream node to replay. |
-| <code>count</code> | <code>number</code> | Number of subscription rounds. |
-| <code>opts</code> | <code>ExtraOpts</code> | Optional NodeOptions (excluding `describeKind`). |
-
-## Returns
-
-`Node&lt;T&gt;` - Forwards each round then completes after the last inner `COMPLETE`.
-
-## Basic Usage
-
-```ts
-import { repeat, state } from "@graphrefly/pure-ts";
-
-repeat(state(1, { resubscribable: true }), 2);
-```
diff --git a/website/src/content/docs/api/replay.md b/website/src/content/docs/api/replay.md
deleted file mode 100644
index 8f5cdffa..00000000
--- a/website/src/content/docs/api/replay.md
+++ /dev/null
@@ -1,33 +0,0 @@
----
-title: "replay()"
-description: "Like share with a bounded replay buffer: new subscribers receive the last `bufferSize`\n`DATA` payloads (as separate batches) before live updates."
----
-
-Like share with a bounded replay buffer: new subscribers receive the last `bufferSize`
-`DATA` payloads (as separate batches) before live updates.
-
-## Signature
-
-```ts
-function replay<T>(source: Node<T>, bufferSize: number, opts?: ExtraOpts): Node<T>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>source</code> | <code>Node&lt;T&gt;</code> | Upstream node. |
-| <code>bufferSize</code> | <code>number</code> | Maximum past values to replay (≥ 1). |
-| <code>opts</code> | <code>ExtraOpts</code> | Producer options. |
-
-## Returns
-
-`Node&lt;T&gt;` — multicast with replay on subscribe.
-
-## Basic Usage
-
-```ts
-import { replay, state } from "@graphrefly/graphrefly";
-
-replay(state(0), 3);
-```
diff --git a/website/src/content/docs/api/rescue.md b/website/src/content/docs/api/rescue.md
deleted file mode 100644
index b29e7b33..00000000
--- a/website/src/content/docs/api/rescue.md
+++ /dev/null
@@ -1,36 +0,0 @@
----
-title: "rescue()"
-description: "Replaces an upstream `ERROR` with a recovered value (`catchError`-style)."
----
-
-Replaces an upstream `ERROR` with a recovered value (`catchError`-style).
-
-## Signature
-
-```ts
-function rescue<T>(
-	source: Node<T>,
-	recover: (err: unknown) => T,
-	opts?: ExtraOpts,
-): Node<T>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>source</code> | <code>Node&lt;T&gt;</code> | Upstream node. |
-| <code>recover</code> | <code>(err: unknown) =&gt; T</code> | Maps the error payload to a replacement value; if it throws, `ERROR` is forwarded. |
-| <code>opts</code> | <code>ExtraOpts</code> | Optional NodeOptions (excluding `describeKind`). |
-
-## Returns
-
-`Node&lt;T&gt;` - Recovered stream.
-
-## Basic Usage
-
-```ts
-import { rescue, state } from "@graphrefly/pure-ts";
-
-rescue(state(0), () => 0);
-```
diff --git a/website/src/content/docs/api/resilientAdapter.md b/website/src/content/docs/api/resilientAdapter.md
deleted file mode 100644
index 1eca17ca..00000000
--- a/website/src/content/docs/api/resilientAdapter.md
+++ /dev/null
@@ -1,39 +0,0 @@
----
-title: "resilientAdapter()"
-description: "Wrap `inner` with the standard resilience stack. See module docs for the\ncomposition order and rationale."
----
-
-Wrap `inner` with the standard resilience stack. See module docs for the
-composition order and rationale.
-
-## Signature
-
-```ts
-function resilientAdapter(
-	inner: LLMAdapter,
-	opts: ResilientAdapterOptions = {},
-): ResilientAdapterBundle
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>inner</code> | <code>LLMAdapter</code> |  |
-| <code>opts</code> | <code>ResilientAdapterOptions</code> |  |
-
-## Basic Usage
-
-```ts
-const { adapter, budget, breaker } = resilientAdapter(openai, {
-    rateLimit: { rpm: 60, tpm: 90_000 },
-    budget: { caps: { usd: 5 } },
-    breaker: { failureThreshold: 5, resetTimeoutMs: 30_000 },
-    timeoutMs: 30_000,
-    retry: { attempts: 3 },
-    fallback: webllm,  // cascades to local on exhaustion
-  });
-
-// `adapter` is drop-in for anything expecting LLMAdapter.
-// Subscribe to `budget.totals`, `breaker.state`, etc. for dashboards.
-```
diff --git a/website/src/content/docs/api/resilientPipeline.md b/website/src/content/docs/api/resilientPipeline.md
deleted file mode 100644
index 821ea9db..00000000
--- a/website/src/content/docs/api/resilientPipeline.md
+++ /dev/null
@@ -1,50 +0,0 @@
----
-title: "resilientPipeline()"
-description: "Compose a resilient pipeline around `source` in the canonical nesting\norder — `rateLimit → budget → breaker → timeout → retry → fallback → status`.\nOmit any opt"
----
-
-Compose a resilient pipeline around `source` in the canonical nesting
-order — `rateLimit → budget → breaker → timeout → retry → fallback → status`.
-Omit any option to skip that layer.
-
-Returns a ResilientPipelineGraph (Graph subclass) —
-`pipeline.output` is the externally visible final node; `pipeline.status`
-/ `pipeline.lastError` / `pipeline.breakerState` / `pipeline.droppedCount`
-are the per-layer companions. Call `pipeline.describe()` to see the
-mounted intermediates; compose with graphLens's `health` for
-aggregate status.
-
-**Naming note:** `output` and `lastError` (not `node` / `error`) avoid
-clashes with `Graph.node(name)` and `Graph.error(name, err)` on the base
-class.
-
-## Signature
-
-```ts
-function resilientPipeline<T>(
-	source: Node<T>,
-	opts: ResilientPipelineOptions<T> = {},
-): ResilientPipelineGraph<T>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>source</code> | <code>Node&lt;T&gt;</code> | Upstream node to wrap. |
-| <code>opts</code> | <code>ResilientPipelineOptions&lt;T&gt;</code> | See ResilientPipelineOptions. All fields optional. |
-
-## Basic Usage
-
-```ts
-const safeFetch = resilientPipeline(fetchNode, {
-    rateLimit: { maxEvents: 10, windowNs: NS_PER_SEC, maxBuffer: 100 },
-    breaker: { failureThreshold: 5 },
-    retry: { count: 3, backoff: "exponential" },
-    timeoutMs: 10_000,
-    fallback: null,
-  });
-safeFetch.output.subscribe(msgs => console.log(msgs));
-safeFetch.status.subscribe(msgs => console.log(msgs));
-graphSpecToAscii(safeFetch.describe()); // visualize the chain
-```
diff --git a/website/src/content/docs/api/resolveBackoffPreset.md b/website/src/content/docs/api/resolveBackoffPreset.md
deleted file mode 100644
index e04e723b..00000000
--- a/website/src/content/docs/api/resolveBackoffPreset.md
+++ /dev/null
@@ -1,31 +0,0 @@
----
-title: "resolveBackoffPreset()"
-description: "Maps a preset name to a concrete BackoffStrategy with library-default parameters."
----
-
-Maps a preset name to a concrete BackoffStrategy with library-default parameters.
-
-## Signature
-
-```ts
-function resolveBackoffPreset(name: BackoffPreset): BackoffStrategy
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>name</code> | <code>BackoffPreset</code> | One of `constant`, `linear`, `exponential`, `fibonacci`, or `decorrelatedJitter`. |
-
-## Returns
-
-Configured strategy with default parameters.
-
-## Basic Usage
-
-```ts
-import { resolveBackoffPreset, retry } from "@graphrefly/graphrefly";
-
-const out = retry(source, { count: 3, backoff: resolveBackoffPreset("exponential") });
-// Equivalent to retry(source, { count: 3, backoff: exponential() })
-```
diff --git a/website/src/content/docs/api/retry.md b/website/src/content/docs/api/retry.md
deleted file mode 100644
index 6b5a4f69..00000000
--- a/website/src/content/docs/api/retry.md
+++ /dev/null
@@ -1,21 +0,0 @@
----
-title: "retry()"
-description: "API reference for retry."
----
-
-## Signature
-
-```ts
-function retry<T>(input: Node<T>, opts?: NodeOrValue<RetryOptions>): RetryBundle<T>
-function retry<T>(
-	input: () => Node<T>,
-	opts?: NodeOrValue<RetryFactoryOptions<T>>,
-): RetryBundle<T>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>input</code> | <code>Node&lt;T&gt; | (() =&gt; Node&lt;T&gt;)</code> |  |
-| <code>opts</code> | <code>NodeOrValue&lt;RetryOptions | RetryFactoryOptions&lt;T&gt;&gt;</code> |  |
diff --git a/website/src/content/docs/api/sagaInvocationKeyOf.md b/website/src/content/docs/api/sagaInvocationKeyOf.md
deleted file mode 100644
index dedb3f3d..00000000
--- a/website/src/content/docs/api/sagaInvocationKeyOf.md
+++ /dev/null
@@ -1,16 +0,0 @@
----
-title: "sagaInvocationKeyOf()"
-description: "API reference for sagaInvocationKeyOf."
----
-
-## Signature
-
-```ts
-sagaInvocationKeyOf<T>(i: SagaInvocation<T>): string
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>i</code> | <code>SagaInvocation&lt;T&gt;</code> |  |
diff --git a/website/src/content/docs/api/sample.md b/website/src/content/docs/api/sample.md
deleted file mode 100644
index e7da5b2c..00000000
--- a/website/src/content/docs/api/sample.md
+++ /dev/null
@@ -1,36 +0,0 @@
----
-title: "sample()"
-description: "Emits the most recent source value whenever `notifier` emits `DATA` (`sample`).\n\nSource `COMPLETE` stops sampling (clears held value); notifier `COMPLETE` termi"
----
-
-Emits the most recent source value whenever `notifier` emits `DATA` (`sample`).
-
-Source `COMPLETE` stops sampling (clears held value); notifier `COMPLETE` terminates the
-operator. `ERROR` from either dep terminates immediately. At most one terminal message is
-emitted downstream (latch). Supports `resubscribable` — `ctx.store` resets automatically.
-
-## Signature
-
-```ts
-function sample<T>(source: Node<T>, notifier: Node<unknown>, opts?: ExtraOpts): Node<T>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>source</code> | <code>Node&lt;T&gt;</code> | Node whose latest value is sampled. |
-| <code>notifier</code> | <code>Node&lt;unknown&gt;</code> | When this node emits `DATA`, a sample is taken. |
-| <code>opts</code> | <code>ExtraOpts</code> | Optional NodeOptions (excluding `describeKind`). |
-
-## Returns
-
-`Node&lt;T&gt;` - Sampled snapshots of `source`.
-
-## Basic Usage
-
-```ts
-import { sample, state } from "@graphrefly/pure-ts";
-
-sample(state(1), state(0));
-```
diff --git a/website/src/content/docs/api/scan.md b/website/src/content/docs/api/scan.md
deleted file mode 100644
index ec36f0ba..00000000
--- a/website/src/content/docs/api/scan.md
+++ /dev/null
@@ -1,41 +0,0 @@
----
-title: "scan()"
-description: "Folds each upstream value into an accumulator; emits the new accumulator every time.\n\nUnlike RxJS, `seed` is always required — there is no seedless mode where t"
----
-
-Folds each upstream value into an accumulator; emits the new accumulator every time.
-
-Unlike RxJS, `seed` is always required — there is no seedless mode where the first
-value silently becomes the accumulator.
-
-## Signature
-
-```ts
-function scan<T, R>(
-	source: Node<T>,
-	reducer: (acc: R, value: T) => R,
-	seed: R,
-	opts?: ExtraOpts,
-): Node<R>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>source</code> | <code>Node&lt;T&gt;</code> | Upstream node. |
-| <code>reducer</code> | <code>(acc: R, value: T) =&gt; R</code> | `(acc, value) =&gt; nextAcc`. |
-| <code>seed</code> | <code>R</code> | Initial accumulator (required). |
-| <code>opts</code> | <code>ExtraOpts</code> | Optional NodeOptions (excluding `describeKind`). |
-
-## Returns
-
-`Node&lt;R&gt;` - Scan node.
-
-## Basic Usage
-
-```ts
-import { scan, state } from "@graphrefly/pure-ts";
-
-const n = scan(state(1), (a, x) => a + x, 0);
-```
diff --git a/website/src/content/docs/api/scorer.md b/website/src/content/docs/api/scorer.md
deleted file mode 100644
index 699bb01b..00000000
--- a/website/src/content/docs/api/scorer.md
+++ /dev/null
@@ -1,32 +0,0 @@
----
-title: "scorer()"
-description: "Reactive multi-signal scoring with live weights.\n\nEach source emits items to score. Weights are reactive state nodes that\nLLM or human can adjust live. Output i"
----
-
-Reactive multi-signal scoring with live weights.
-
-Each source emits items to score. Weights are reactive state nodes that
-LLM or human can adjust live. Output is sorted scored items with full
-breakdown.
-
-## Signature
-
-```ts
-function scorer(
-	sources: ReadonlyArray<Node<number>>,
-	weights: ReadonlyArray<Node<number>>,
-	opts?: ScorerOptions,
-): Node<ScoredItem<number[]>>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>sources</code> | <code>ReadonlyArray&lt;Node&lt;number&gt;&gt;</code> | Signal nodes (each emits a numeric score dimension). |
-| <code>weights</code> | <code>ReadonlyArray&lt;Node&lt;number&gt;&gt;</code> | Reactive weight nodes (one per source). |
-| <code>opts</code> | <code>ScorerOptions</code> | Optional node/meta options. |
-
-## Returns
-
-Node emitting scored output.
diff --git a/website/src/content/docs/api/scoringByOutcome.md b/website/src/content/docs/api/scoringByOutcome.md
deleted file mode 100644
index 41b0d9f4..00000000
--- a/website/src/content/docs/api/scoringByOutcome.md
+++ /dev/null
@@ -1,24 +0,0 @@
----
-title: "scoringByOutcome()"
-description: "Build a continual-learning ScoringPolicy Node from an\nOutcomeSignal stream. Pass the SAME `outcomes` Node as both\n`config.outcome` and (via this recipe) `config"
----
-
-Build a continual-learning ScoringPolicy Node from an
-OutcomeSignal stream. Pass the SAME `outcomes` Node as both
-`config.outcome` and (via this recipe) `config.scoring`.
-
-## Signature
-
-```ts
-function scoringByOutcome<T>(
-	outcomes: Node<OutcomeSignal>,
-	opts: ScoringByOutcomeOptions<T> = {},
-): Node<ScoringPolicy<T>>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>outcomes</code> | <code>Node&lt;OutcomeSignal&gt;</code> |  |
-| <code>opts</code> | <code>ScoringByOutcomeOptions&lt;T&gt;</code> |  |
diff --git a/website/src/content/docs/api/shardByTenant.md b/website/src/content/docs/api/shardByTenant.md
deleted file mode 100644
index 23a8a0fe..00000000
--- a/website/src/content/docs/api/shardByTenant.md
+++ /dev/null
@@ -1,24 +0,0 @@
----
-title: "shardByTenant()"
-description: "Build the `{ shardBy, shardCount }` pair for tenant-isolated sharding.\n`tenantOf` extracts the tenant key from a fragment. Spread into\nreactiveFactStore's confi"
----
-
-Build the `{ shardBy, shardCount }` pair for tenant-isolated sharding.
-`tenantOf` extracts the tenant key from a fragment. Spread into
-reactiveFactStore's config.
-
-## Signature
-
-```ts
-function shardByTenant<T>(
-	tenantOf: (f: MemoryFragment<T>) => string,
-	opts: ShardByTenantOptions = {},
-): ShardByTenantConfig<T>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>tenantOf</code> | <code>(f: MemoryFragment&lt;T&gt;) =&gt; string</code> |  |
-| <code>opts</code> | <code>ShardByTenantOptions</code> |  |
diff --git a/website/src/content/docs/api/share.md b/website/src/content/docs/api/share.md
deleted file mode 100644
index 7653231f..00000000
--- a/website/src/content/docs/api/share.md
+++ /dev/null
@@ -1,31 +0,0 @@
----
-title: "share()"
-description: "Multicasts upstream: one subscription to `source` while this wrapper has subscribers (via producer)."
----
-
-Multicasts upstream: one subscription to `source` while this wrapper has subscribers (via producer).
-
-## Signature
-
-```ts
-function share<T>(source: Node<T>, opts?: ExtraOpts): Node<T>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>source</code> | <code>Node&lt;T&gt;</code> | Upstream node to share. |
-| <code>opts</code> | <code>ExtraOpts</code> | Producer options; `initial` seeds from `source.cache` when set by factory. |
-
-## Returns
-
-`Node&lt;T&gt;` — hot ref-counted bridge.
-
-## Basic Usage
-
-```ts
-import { share, state } from "@graphrefly/graphrefly";
-
-share(state(0));
-```
diff --git a/website/src/content/docs/api/shareReplay.md b/website/src/content/docs/api/shareReplay.md
deleted file mode 100644
index 141098ff..00000000
--- a/website/src/content/docs/api/shareReplay.md
+++ /dev/null
@@ -1,32 +0,0 @@
----
-title: "shareReplay()"
-description: "RxJS-named alias for replay — multicast with a replay buffer of size `bufferSize`."
----
-
-RxJS-named alias for replay — multicast with a replay buffer of size `bufferSize`.
-
-## Signature
-
-```ts
-function replay<T>(source: Node<T>, bufferSize: number, opts?: ExtraOpts): Node<T>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>source</code> | <code>Node&lt;T&gt;</code> | Upstream node. |
-| <code>bufferSize</code> | <code>number</code> | Maximum past values to replay (≥ 1). |
-| <code>opts</code> | <code>ExtraOpts</code> | Producer options. |
-
-## Returns
-
-Same behavior as `replay`.
-
-## Basic Usage
-
-```ts
-import { shareReplay, state } from "@graphrefly/graphrefly";
-
-shareReplay(state(0), 5);
-```
diff --git a/website/src/content/docs/api/simpleFactStore.md b/website/src/content/docs/api/simpleFactStore.md
deleted file mode 100644
index 08a72216..00000000
--- a/website/src/content/docs/api/simpleFactStore.md
+++ /dev/null
@@ -1,19 +0,0 @@
----
-title: "simpleFactStore()"
-description: "API reference for simpleFactStore."
----
-
-## Signature
-
-```ts
-function simpleFactStore<T>(
-	opts: SimpleFactStoreOptions<T> & { storage: StorageBackend },
-): PersistentSimpleFactStoreGraph<T>
-function simpleFactStore<T>(opts?: SimpleFactStoreOptions<T>): SimpleFactStoreGraph<T>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>opts</code> | <code>SimpleFactStoreOptions&lt;T&gt;</code> |  |
diff --git a/website/src/content/docs/api/singleFromAny.md b/website/src/content/docs/api/singleFromAny.md
deleted file mode 100644
index b1460994..00000000
--- a/website/src/content/docs/api/singleFromAny.md
+++ /dev/null
@@ -1,26 +0,0 @@
----
-title: "singleFromAny()"
-description: "Dedupe concurrent `factory(key)` invocations. Returns a bound callable."
----
-
-Dedupe concurrent `factory(key)` invocations. Returns a bound callable.
-
-## Signature
-
-```ts
-function singleFromAny<K, T>(
-	factory: (key: K) => NodeInput<T>,
-	opts: SingleFromAnyOptions<K> = {},
-): (key: K) => Promise<T>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>factory</code> | <code>(key: K) =&gt; NodeInput&lt;T&gt;</code> | Produces a `NodeInput&lt;T&gt;` for each unique key. |
-| <code>opts</code> | <code>SingleFromAnyOptions&lt;K&gt;</code> | Optional key-stringification. |
-
-## Returns
-
-A function `(key: K) =&gt; Promise&lt;T&gt;` whose inflight results are shared per key.
diff --git a/website/src/content/docs/api/singleNodeFromAny.md b/website/src/content/docs/api/singleNodeFromAny.md
deleted file mode 100644
index e3d2acb1..00000000
--- a/website/src/content/docs/api/singleNodeFromAny.md
+++ /dev/null
@@ -1,39 +0,0 @@
----
-title: "singleNodeFromAny()"
-description: "Reactive variant: returns a bound callable that hands out `Node<T>` values.\nAll concurrent callers with the same key during an in-flight source share\nthe same N"
----
-
-Reactive variant: returns a bound callable that hands out `Node&lt;T&gt;` values.
-All concurrent callers with the same key during an in-flight source share
-the same Node. The cache entry is evicted (so the next call re-invokes
-`factory`) when the underlying source either:
-
-- **terminally settles** — `ERROR` or `COMPLETE`; or
-- **tears down** — `TEARDOWN` (M8 fix). A DATA-only source (e.g. a
-  long-lived `state(...)`) never emits `ERROR`/`COMPLETE`, so without
-  the TEARDOWN arm a destroyed shared Node — plus this watcher
-  subscription — would be pinned in the `inFlight` Map forever. Evicting
-  on TEARDOWN bounds the entry's lifetime to the Node's own lifetime.
-
-DATA is NOT an eviction trigger — callers subscribing after the first
-DATA still receive the shared Node (and push-on-subscribe per the spec's
-cached-DATA contract). The Node stays shared while alive (the dedup
-contract); only its death (terminal or teardown) releases the entry.
-
-Use when downstream wants reactive subscription (not a one-shot Promise).
-
-## Signature
-
-```ts
-function singleNodeFromAny<K, T>(
-	factory: (key: K) => NodeInput<T>,
-	opts: SingleFromAnyOptions<K> = {},
-): (key: K) => Node<T>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>factory</code> | <code>(key: K) =&gt; NodeInput&lt;T&gt;</code> |  |
-| <code>opts</code> | <code>SingleFromAnyOptions&lt;K&gt;</code> |  |
diff --git a/website/src/content/docs/api/skip.md b/website/src/content/docs/api/skip.md
deleted file mode 100644
index 76a5d7c0..00000000
--- a/website/src/content/docs/api/skip.md
+++ /dev/null
@@ -1,32 +0,0 @@
----
-title: "skip()"
-description: "Skips the first `count` **`DATA`** emissions. `RESOLVED` does not advance the counter."
----
-
-Skips the first `count` **`DATA`** emissions. `RESOLVED` does not advance the counter.
-
-## Signature
-
-```ts
-function skip<T>(source: Node<T>, count: number, opts?: ExtraOpts): Node<T>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>source</code> | <code>Node&lt;T&gt;</code> | Upstream node. |
-| <code>count</code> | <code>number</code> | Number of `DATA` values to drop. |
-| <code>opts</code> | <code>ExtraOpts</code> | Optional NodeOptions (excluding `describeKind`). |
-
-## Returns
-
-`Node&lt;T&gt;` - Skipped stream.
-
-## Basic Usage
-
-```ts
-import { skip, state } from "@graphrefly/pure-ts";
-
-const n = skip(state(0), 2);
-```
diff --git a/website/src/content/docs/api/snapshotStorage.md b/website/src/content/docs/api/snapshotStorage.md
deleted file mode 100644
index 22251d6c..00000000
--- a/website/src/content/docs/api/snapshotStorage.md
+++ /dev/null
@@ -1,43 +0,0 @@
----
-title: "snapshotStorage()"
-description: "Wraps a `StorageBackend` as a typed snapshot tier.\n\nBuffer model: `save(snapshot)` accumulates one pending snapshot in memory.\n`flush()` encodes via codec and w"
----
-
-Wraps a `StorageBackend` as a typed snapshot tier.
-
-Buffer model: `save(snapshot)` accumulates one pending snapshot in memory.
-`flush()` encodes via codec and writes to the backend under
-`keyOf(snapshot)` (default `name ?? "snapshot"`). `rollback()` discards
-the pending write.
-
-## Signature
-
-```ts
-function snapshotStorage<T>(
-	backend: StorageBackend,
-	opts: SnapshotStorageOptions<T> = {},
-): SnapshotStorageTier<T>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>backend</code> | <code>StorageBackend</code> | Bytes-level backend to persist snapshots into. |
-| <code>opts</code> | <code>SnapshotStorageOptions&lt;T&gt;</code> | Optional name, codec, debounce window, compaction interval, pre-save filter, and key extractor. |
-
-## Returns
-
-`SnapshotStorageTier&lt;T&gt;` that buffers one pending snapshot and flushes on wave-close.
-
-## Basic Usage
-
-```ts
-import { memoryBackend, snapshotStorage } from "@graphrefly/graphrefly/extra";
-
-const backend = memoryBackend();
-const tier = snapshotStorage<{ count: number }>(backend, { name: "counter" });
-await tier.save({ count: 42 });
-// Load back:
-const loaded = await tier.load?.();
-```
diff --git a/website/src/content/docs/api/specDiff.md b/website/src/content/docs/api/specDiff.md
deleted file mode 100644
index 4091e2a4..00000000
--- a/website/src/content/docs/api/specDiff.md
+++ /dev/null
@@ -1,26 +0,0 @@
----
-title: "specDiff()"
-description: "Compute a structural diff between two GraphSpecs.\n\nTemplate-aware: reports \"changed template definition\" vs \"changed\ninstantiation bindings.\" No runtime needed "
----
-
-Compute a structural diff between two GraphSpecs.
-
-Template-aware: reports "changed template definition" vs "changed
-instantiation bindings." No runtime needed — pure JSON comparison.
-
-## Signature
-
-```ts
-function specDiff(specA: GraphSpec, specB: GraphSpec): SpecDiffResult
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>specA</code> | <code>GraphSpec</code> | The "before" spec. |
-| <code>specB</code> | <code>GraphSpec</code> | The "after" spec. |
-
-## Returns
-
-Diff entries and a human-readable summary.
diff --git a/website/src/content/docs/api/sqliteAppendLog.md b/website/src/content/docs/api/sqliteAppendLog.md
deleted file mode 100644
index 7cab7b9d..00000000
--- a/website/src/content/docs/api/sqliteAppendLog.md
+++ /dev/null
@@ -1,40 +0,0 @@
----
-title: "sqliteAppendLog()"
-description: "Creates a SQLite append-log tier; caller owns the connection lifetime.\n\nConvenience wrapper for `appendLogStorage(sqliteBackend(path), opts)`.\nThe returned tier"
----
-
-Creates a SQLite append-log tier; caller owns the connection lifetime.
-
-Convenience wrapper for `appendLogStorage(sqliteBackend(path), opts)`.
-The returned tier exposes an extra `close()` method — call it for explicit
-teardown of the underlying SQLite connection.
-
-## Signature
-
-```ts
-function sqliteAppendLog<T>(
-	path: string,
-	opts?: Omit<AppendLogStorageOptions<T>, "name"> & { name?: string },
-): AppendLogStorageTier<T> & { close(): void }
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>path</code> | <code>string</code> | Filesystem path to the SQLite database file. |
-| <code>opts</code> | <code>Omit&lt;AppendLogStorageOptions&lt;T&gt;, "name"&gt; & { name?: string }</code> | Optional append-log storage options (name, codec, keyOf, debounce, compactEvery). |
-
-## Returns
-
-`AppendLogStorageTier&lt;T&gt;` with a `close()` method for connection teardown.
-
-## Basic Usage
-
-```ts
-import { sqliteAppendLog } from "@graphrefly/graphrefly/extra/node";
-
-const tier = sqliteAppendLog<{ type: string }>("../events.db", { name: "events" });
-await tier.appendEntries([{ type: "created" }]);
-tier.close();
-```
diff --git a/website/src/content/docs/api/sqliteBackend.md b/website/src/content/docs/api/sqliteBackend.md
deleted file mode 100644
index dfaf8bc0..00000000
--- a/website/src/content/docs/api/sqliteBackend.md
+++ /dev/null
@@ -1,37 +0,0 @@
----
-title: "sqliteBackend()"
-description: "Creates a SQLite backend using Node 22.5+ `node:sqlite`.\n\nStores byte values under string keys in a single `graphrefly_storage` table.\nThe caller owns the conne"
----
-
-Creates a SQLite backend using Node 22.5+ `node:sqlite`.
-
-Stores byte values under string keys in a single `graphrefly_storage` table.
-The caller owns the connection lifetime — call `.close()` for explicit teardown.
-Requires Node 22.5 or later for `node:sqlite`.
-
-## Signature
-
-```ts
-function sqliteBackend(path: string): StorageBackend & { close(): void }
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>path</code> | <code>string</code> | Filesystem path to the SQLite database file (created if absent). |
-
-## Returns
-
-`StorageBackend` with an extra `close()` method for explicit teardown.
-
-## Basic Usage
-
-```ts
-import { sqliteBackend, snapshotStorage } from "@graphrefly/graphrefly/extra/node";
-
-const backend = sqliteBackend("../state.db");
-const tier = snapshotStorage(backend, { name: "my-graph" });
-await tier.save({ name: "my-graph", state: { count: 1 } });
-backend.close();
-```
diff --git a/website/src/content/docs/api/sqliteKv.md b/website/src/content/docs/api/sqliteKv.md
deleted file mode 100644
index 64ebcf31..00000000
--- a/website/src/content/docs/api/sqliteKv.md
+++ /dev/null
@@ -1,40 +0,0 @@
----
-title: "sqliteKv()"
-description: "Creates a SQLite key-value tier; caller owns the connection lifetime.\n\nConvenience wrapper for `kvStorage(sqliteBackend(path), opts)`.\nThe returned tier exposes"
----
-
-Creates a SQLite key-value tier; caller owns the connection lifetime.
-
-Convenience wrapper for `kvStorage(sqliteBackend(path), opts)`.
-The returned tier exposes an extra `close()` method — call it for explicit
-teardown of the underlying SQLite connection.
-
-## Signature
-
-```ts
-function sqliteKv<T>(
-	path: string,
-	opts?: Omit<KvStorageOptions<T>, "name"> & { name?: string },
-): KvStorageTier<T> & { close(): void }
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>path</code> | <code>string</code> | Filesystem path to the SQLite database file. |
-| <code>opts</code> | <code>Omit&lt;KvStorageOptions&lt;T&gt;, "name"&gt; & { name?: string }</code> | Optional kv storage options (name, codec, filter, debounce, compactEvery). |
-
-## Returns
-
-`KvStorageTier&lt;T&gt;` with a `close()` method for connection teardown.
-
-## Basic Usage
-
-```ts
-import { sqliteKv } from "@graphrefly/graphrefly/extra/node";
-
-const kv = sqliteKv<{ score: number }>("../scores.db");
-await kv.save("player1", { score: 100 });
-kv.close();
-```
diff --git a/website/src/content/docs/api/sqliteSnapshot.md b/website/src/content/docs/api/sqliteSnapshot.md
deleted file mode 100644
index cfc7f22e..00000000
--- a/website/src/content/docs/api/sqliteSnapshot.md
+++ /dev/null
@@ -1,40 +0,0 @@
----
-title: "sqliteSnapshot()"
-description: "Creates a SQLite snapshot tier; caller owns the connection lifetime.\n\nConvenience wrapper for `snapshotStorage(sqliteBackend(path), opts)`.\nThe returned tier ex"
----
-
-Creates a SQLite snapshot tier; caller owns the connection lifetime.
-
-Convenience wrapper for `snapshotStorage(sqliteBackend(path), opts)`.
-The returned tier exposes an extra `close()` method — call it for explicit
-teardown of the underlying SQLite connection.
-
-## Signature
-
-```ts
-function sqliteSnapshot<T>(
-	path: string,
-	opts?: Omit<SnapshotStorageOptions<T>, "name"> & { name?: string },
-): SnapshotStorageTier<T> & { close(): void }
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>path</code> | <code>string</code> | Filesystem path to the SQLite database file. |
-| <code>opts</code> | <code>Omit&lt;SnapshotStorageOptions&lt;T&gt;, "name"&gt; & { name?: string }</code> | Optional snapshot storage options (name, codec, filter, keyOf, debounce, compactEvery). |
-
-## Returns
-
-`SnapshotStorageTier&lt;T&gt;` with a `close()` method for connection teardown.
-
-## Basic Usage
-
-```ts
-import { sqliteSnapshot } from "@graphrefly/graphrefly/extra/node";
-
-const tier = sqliteSnapshot<{ count: number }>("../state.db", { name: "counter" });
-await tier.save({ count: 42 });
-tier.close();
-```
diff --git a/website/src/content/docs/api/sqliteStorage.md b/website/src/content/docs/api/sqliteStorage.md
deleted file mode 100644
index 6c609999..00000000
--- a/website/src/content/docs/api/sqliteStorage.md
+++ /dev/null
@@ -1,38 +0,0 @@
----
-title: "sqliteStorage()"
-description: "SQLite storage tier using Node.js `node:sqlite` (DatabaseSync).\n\nReturns a StorageTier extended with `close()` — the caller owns the\nconnection and should close"
----
-
-SQLite storage tier using Node.js `node:sqlite` (DatabaseSync).
-
-Returns a StorageTier extended with `close()` — the caller owns the
-connection and should close it when discarding the tier.
-
-**Runtime:** Requires Node 22.5+ with `node:sqlite` enabled.
-
-## Signature
-
-```ts
-function sqliteStorage(path: string): StorageTier & { close(): void }
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| `path` | `string` | SQLite database file path. |
-
-## Returns
-
-Sync StorageTier with an idempotent `close()` method.
-
-## Basic Usage
-
-```ts
-import { sqliteStorage, memoryStorage } from "@graphrefly/graphrefly-ts";
-
-const cold = sqliteStorage("./graphs.sqlite");
-graph.attachStorage([memoryStorage(), cold]);
-// ... later, on shutdown:
-cold.close();
-```
diff --git a/website/src/content/docs/api/state.md b/website/src/content/docs/api/state.md
deleted file mode 100644
index e4f0a3b4..00000000
--- a/website/src/content/docs/api/state.md
+++ /dev/null
@@ -1,42 +0,0 @@
----
-title: "state()"
-description: "Creates a manual source node. Drive it with `state.emit(v)` (framed,\ndiamond-safe) or `state.down([[DATA, v]])` (raw compat path).\n\n**Sentinel form.** Omit `ini"
----
-
-Creates a manual source node. Drive it with `state.emit(v)` (framed,
-diamond-safe) or `state.down([[DATA, v]])` (raw compat path).
-
-**Sentinel form.** Omit `initial` (or pass `undefined`) to leave the
-node in `"sentinel"` status — the canonical "no value yet" state.
-Downstream `derived` first-run gate then waits for the first real DATA
-before firing. Pass an explicit `null` to cache `null` as DATA — `null`
-is a valid DATA value per spec §2.2 ("`T | null` is the only valid DATA
-domain; `undefined` is reserved as the global SENTINEL").
-
-## Signature
-
-```ts
-function state<T>(initial?: T, opts?: Omit<NodeOptions<T>, "initial">): Node<T>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| `initial` | `T` | Starting cached value (optional). Omit or pass
-`undefined` for the sentinel form; pass `null` to cache `null`. |
-| `opts` | `Omit&lt;NodeOptions&lt;T&gt;, "initial"&gt;` | Optional NodeOptions (excluding `initial`). |
-
-## Basic Usage
-
-```ts
-import { state, derived } from "@graphrefly/graphrefly";
-
-// Cached form — starts at 10, derived fires immediately on subscribe.
-const counter = state(10);
-
-// Sentinel form — derived's first-run gate waits for the first emit.
-const candidates = state<readonly string[]>();
-const ready = derived([candidates], ([cands]) => cands.length > 0);
-candidates.emit(["v1"]); // ready fires now
-```
diff --git a/website/src/content/docs/api/stratify.md b/website/src/content/docs/api/stratify.md
deleted file mode 100644
index 6eb0abe8..00000000
--- a/website/src/content/docs/api/stratify.md
+++ /dev/null
@@ -1,36 +0,0 @@
----
-title: "stratify()"
-description: "Route input to different branches based on classifier functions.\n\nEach branch gets an independent operator chain. Branch nodes are structural —\ncreated at const"
----
-
-Route input to different branches based on classifier functions.
-
-Each branch gets an independent operator chain. Branch nodes are structural —
-created at construction time and persist for the graph's lifetime. If a rule
-name is removed from the rules array, the corresponding branch silently
-drops items (classifier not found). To tear down a dead branch, call
-`graph.remove("branch/&lt;name&gt;")`.
-
-## Signature
-
-```ts
-function stratify<T>(
-	name: string,
-	source: Node<T>,
-	rules: ReadonlyArray<StratifyRule<T>>,
-	opts?: StratifyOptions,
-): Graph
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>name</code> | <code>string</code> | Graph name. |
-| <code>source</code> | <code>Node&lt;T&gt;</code> | Input node (registered as `"source"`). |
-| <code>rules</code> | <code>ReadonlyArray&lt;StratifyRule&lt;T&gt;&gt;</code> | Initial routing rules. |
-| <code>opts</code> | <code>StratifyOptions</code> | Optional graph/meta options. |
-
-## Returns
-
-Graph with `"source"`, `"rules"`, and `"branch/&lt;name&gt;"` nodes.
diff --git a/website/src/content/docs/api/subscription.md b/website/src/content/docs/api/subscription.md
deleted file mode 100644
index 2c9a24ce..00000000
--- a/website/src/content/docs/api/subscription.md
+++ /dev/null
@@ -1,24 +0,0 @@
----
-title: "subscription()"
-description: "Creates a cursor-based subscription graph over a topic."
----
-
-Creates a cursor-based subscription graph over a topic.
-
-## Signature
-
-```ts
-function subscription<T>(
-	name: string,
-	topicGraph: TopicGraph<T>,
-	opts?: SubscriptionOptions,
-): SubscriptionGraph<T>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>name</code> | <code>string</code> |  |
-| <code>topicGraph</code> | <code>TopicGraph&lt;T&gt;</code> |  |
-| <code>opts</code> | <code>SubscriptionOptions</code> |  |
diff --git a/website/src/content/docs/api/switchMap.md b/website/src/content/docs/api/switchMap.md
deleted file mode 100644
index a0dcb15c..00000000
--- a/website/src/content/docs/api/switchMap.md
+++ /dev/null
@@ -1,37 +0,0 @@
----
-title: "switchMap()"
-description: "Maps each settled value to an inner node; unsubscribes the previous inner (Rx-style `switchMap`)."
----
-
-Maps each settled value to an inner node; unsubscribes the previous inner (Rx-style `switchMap`).
-
-## Signature
-
-```ts
-function switchMap<T, R>(
-	source: Node<T>,
-	project: (value: T) => NodeInput<R>,
-	opts?: HigherOrderOpts,
-): Node<R>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>source</code> | <code>Node&lt;T&gt;</code> | Upstream node. |
-| <code>project</code> | <code>(value: T) =&gt; NodeInput&lt;R&gt;</code> | Maps each outer value to an inner source shape (`Node`, scalar, `PromiseLike`, `Iterable`, or `AsyncIterable`) coerced via fromAny. |
-| <code>opts</code> | <code>HigherOrderOpts</code> | Optional NodeOptions (excluding `describeKind`). |
-
-## Returns
-
-`Node&lt;R&gt;` - Emissions from the active inner subscription.
-
-## Basic Usage
-
-```ts
-import { switchMap, state } from "@graphrefly/pure-ts";
-
-const src = state(0);
-switchMap(src, (n) => state((n as number) * 2));
-```
diff --git a/website/src/content/docs/api/take.md b/website/src/content/docs/api/take.md
deleted file mode 100644
index bcb554bb..00000000
--- a/website/src/content/docs/api/take.md
+++ /dev/null
@@ -1,32 +0,0 @@
----
-title: "take()"
-description: "Emits at most `count` **`DATA`** values, then **`COMPLETE`**. `RESOLVED` does not advance the counter."
----
-
-Emits at most `count` **`DATA`** values, then **`COMPLETE`**. `RESOLVED` does not advance the counter.
-
-## Signature
-
-```ts
-function take<T>(source: Node<T>, count: number, opts?: ExtraOpts): Node<T>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>source</code> | <code>Node&lt;T&gt;</code> | Upstream node. |
-| <code>count</code> | <code>number</code> | Maximum `DATA` emissions (≤0 completes immediately). |
-| <code>opts</code> | <code>ExtraOpts</code> | Optional NodeOptions (excluding `describeKind`). |
-
-## Returns
-
-`Node&lt;T&gt;` - Limited stream.
-
-## Basic Usage
-
-```ts
-import { take, state } from "@graphrefly/pure-ts";
-
-const n = take(state(0), 3);
-```
diff --git a/website/src/content/docs/api/takeUntil.md b/website/src/content/docs/api/takeUntil.md
deleted file mode 100644
index 48c9205a..00000000
--- a/website/src/content/docs/api/takeUntil.md
+++ /dev/null
@@ -1,38 +0,0 @@
----
-title: "takeUntil()"
-description: "Forwards `source` until `notifier` matches `predicate` (default: notifier **`DATA`**), then **`COMPLETE`**."
----
-
-Forwards `source` until `notifier` matches `predicate` (default: notifier **`DATA`**), then **`COMPLETE`**.
-
-## Signature
-
-```ts
-function takeUntil<T>(
-	source: Node<T>,
-	notifier: Node,
-	opts?: ExtraOpts & { predicate?: (msg: Message) => boolean },
-): Node<T>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>source</code> | <code>Node&lt;T&gt;</code> | Main upstream. |
-| <code>notifier</code> | <code>Node</code> | Triggers completion when `predicate(msg)` is true. |
-| <code>opts</code> | <code>ExtraOpts & { predicate?: (msg: Message) =&gt; boolean }</code> | Optional NodeOptions, plus `predicate` for custom notifier matching. |
-
-## Returns
-
-`Node&lt;T&gt;` - Truncated stream.
-
-## Basic Usage
-
-```ts
-import { producer, takeUntil, state } from "@graphrefly/pure-ts";
-
-const src = state(1);
-const stop = producer((_d, a) => a.emit(undefined));
-const n = takeUntil(src, stop);
-```
diff --git a/website/src/content/docs/api/takeWhile.md b/website/src/content/docs/api/takeWhile.md
deleted file mode 100644
index 0a576817..00000000
--- a/website/src/content/docs/api/takeWhile.md
+++ /dev/null
@@ -1,36 +0,0 @@
----
-title: "takeWhile()"
-description: "Emits while `predicate` holds; on first false, sends **`COMPLETE`**."
----
-
-Emits while `predicate` holds; on first false, sends **`COMPLETE`**.
-
-## Signature
-
-```ts
-function takeWhile<T>(
-	source: Node<T>,
-	predicate: (value: T) => boolean,
-	opts?: ExtraOpts,
-): Node<T>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>source</code> | <code>Node&lt;T&gt;</code> | Upstream node. |
-| <code>predicate</code> | <code>(value: T) =&gt; boolean</code> | Continuation test. |
-| <code>opts</code> | <code>ExtraOpts</code> | Optional NodeOptions (excluding `describeKind`). |
-
-## Returns
-
-`Node&lt;T&gt;` - Truncated stream.
-
-## Basic Usage
-
-```ts
-import { takeWhile, state } from "@graphrefly/pure-ts";
-
-const n = takeWhile(state(1), (x) => x < 10);
-```
diff --git a/website/src/content/docs/api/tap.md b/website/src/content/docs/api/tap.md
deleted file mode 100644
index dde8e40f..00000000
--- a/website/src/content/docs/api/tap.md
+++ /dev/null
@@ -1,43 +0,0 @@
----
-title: "tap()"
-description: "Invokes side effects; values pass through unchanged.\n\nAccepts either a function (called on each DATA) or an observer object\n`{ data?, error?, complete? }` for l"
----
-
-Invokes side effects; values pass through unchanged.
-
-Accepts either a function (called on each DATA) or an observer object
-`{ data?, error?, complete? }` for lifecycle-aware side effects.
-
-## Signature
-
-```ts
-function tap<T>(
-	source: Node<T>,
-	fnOrObserver: ((value: T) => void) | TapObserver<T>,
-	opts?: ExtraOpts,
-): Node<T>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>source</code> | <code>Node&lt;T&gt;</code> | Upstream node. |
-| <code>fnOrObserver</code> | <code>((value: T) =&gt; void) | TapObserver&lt;T&gt;</code> | Side effect function or observer object. |
-| <code>opts</code> | <code>ExtraOpts</code> | Optional NodeOptions (excluding `describeKind`). |
-
-## Returns
-
-`Node&lt;T&gt;` - Passthrough node.
-
-## Basic Usage
-
-```ts
-import { tap, state } from "@graphrefly/pure-ts";
-
-// Function form (DATA only)
-tap(state(1), (x) => console.log(x));
-
-// Observer form (DATA + ERROR + COMPLETE)
-tap(state(1), { data: console.log, error: console.error, complete: () => console.log("done") });
-```
diff --git a/website/src/content/docs/api/throttle.md b/website/src/content/docs/api/throttle.md
deleted file mode 100644
index 603d7afe..00000000
--- a/website/src/content/docs/api/throttle.md
+++ /dev/null
@@ -1,41 +0,0 @@
----
-title: "throttle()"
-description: "Rate-limits emissions to at most once per `ms` window (`throttleTime`).\n\nWhen `trailing: true`, pending trailing values are flushed on source\nCOMPLETE (and on D"
----
-
-Rate-limits emissions to at most once per `ms` window (`throttleTime`).
-
-When `trailing: true`, pending trailing values are flushed on source
-COMPLETE (and on Dead-source R2.2.7.b). This intentionally diverges from
-RxJS `throttleTime` v7 (which drops trailing pending on COMPLETE) for
-symmetry with `debounce`'s live-COMPLETE behavior.
-
-## Signature
-
-```ts
-function throttle<T>(
-	source: Node<T>,
-	ms: number,
-	opts?: ExtraOpts & ThrottleOptions,
-): Node<T>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>source</code> | <code>Node&lt;T&gt;</code> | Upstream node. |
-| <code>ms</code> | <code>number</code> | Minimum spacing in milliseconds. |
-| <code>opts</code> | <code>ExtraOpts & ThrottleOptions</code> | Optional NodeOptions (excluding `describeKind`) plus `leading` / `trailing`. |
-
-## Returns
-
-`Node&lt;T&gt;` - Throttled stream.
-
-## Basic Usage
-
-```ts
-import { throttle, state } from "@graphrefly/pure-ts";
-
-throttle(state(0), 1_000, { trailing: false });
-```
diff --git a/website/src/content/docs/api/throttleTime.md b/website/src/content/docs/api/throttleTime.md
deleted file mode 100644
index a3ad07d4..00000000
--- a/website/src/content/docs/api/throttleTime.md
+++ /dev/null
@@ -1,36 +0,0 @@
----
-title: "throttleTime()"
-description: "RxJS-named alias for throttle — emits on leading/trailing edges within `ms`."
----
-
-RxJS-named alias for throttle — emits on leading/trailing edges within `ms`.
-
-## Signature
-
-```ts
-function throttle<T>(
-	source: Node<T>,
-	ms: number,
-	opts?: ExtraOpts & ThrottleOptions,
-): Node<T>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>source</code> | <code>Node&lt;T&gt;</code> | Upstream node. |
-| <code>ms</code> | <code>number</code> | Minimum spacing in milliseconds. |
-| <code>opts</code> | <code>ExtraOpts & ThrottleOptions</code> | Optional NodeOptions (excluding `describeKind`) plus `leading` / `trailing`. |
-
-## Returns
-
-Throttled node; behavior matches `throttle`.
-
-## Basic Usage
-
-```ts
-import { throttleTime, state } from "@graphrefly/pure-ts";
-
-throttleTime(state(0), 100);
-```
diff --git a/website/src/content/docs/api/throwError.md b/website/src/content/docs/api/throwError.md
deleted file mode 100644
index d6fe4afe..00000000
--- a/website/src/content/docs/api/throwError.md
+++ /dev/null
@@ -1,31 +0,0 @@
----
-title: "throwError()"
-description: "Emits `ERROR` as soon as the producer starts (cold error source)."
----
-
-Emits `ERROR` as soon as the producer starts (cold error source).
-
-## Signature
-
-```ts
-function throwError(err: unknown, opts?: ExtraOpts): Node<never>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>err</code> | <code>unknown</code> | Error payload forwarded as `ERROR` data. |
-| <code>opts</code> | <code>ExtraOpts</code> | Optional producer options. |
-
-## Returns
-
-`Node&lt;never&gt;` — terminates with `ERROR`.
-
-## Basic Usage
-
-```ts
-import { throwError } from "@graphrefly/pure-ts";
-
-throwError(new Error("fail"));
-```
diff --git a/website/src/content/docs/api/timeout.md b/website/src/content/docs/api/timeout.md
deleted file mode 100644
index d1374838..00000000
--- a/website/src/content/docs/api/timeout.md
+++ /dev/null
@@ -1,36 +0,0 @@
----
-title: "timeout()"
-description: "Errors if no `DATA` arrives within `ms` after subscribe or after the previous `DATA`."
----
-
-Errors if no `DATA` arrives within `ms` after subscribe or after the previous `DATA`.
-
-## Signature
-
-```ts
-function timeout<T>(
-	source: Node<T>,
-	ms: number,
-	opts?: ExtraOpts & { with?: unknown },
-): Node<T>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>source</code> | <code>Node&lt;T&gt;</code> | Upstream node. |
-| <code>ms</code> | <code>number</code> | Idle budget in milliseconds. |
-| <code>opts</code> | <code>ExtraOpts & { with?: unknown }</code> | Optional NodeOptions (excluding `describeKind`) and `with` for a custom error payload. |
-
-## Returns
-
-`Node&lt;T&gt;` - Pass-through with idle watchdog.
-
-## Basic Usage
-
-```ts
-import { timeout, state } from "@graphrefly/pure-ts";
-
-timeout(state(0), 5_000);
-```
diff --git a/website/src/content/docs/api/toArray.md b/website/src/content/docs/api/toArray.md
deleted file mode 100644
index 16aa28ff..00000000
--- a/website/src/content/docs/api/toArray.md
+++ /dev/null
@@ -1,31 +0,0 @@
----
-title: "toArray()"
-description: "Buffers every `DATA`; on upstream `COMPLETE` emits one `DATA` with the full array then `COMPLETE`."
----
-
-Buffers every `DATA`; on upstream `COMPLETE` emits one `DATA` with the full array then `COMPLETE`.
-
-## Signature
-
-```ts
-function toArray<T>(source: Node<T>, opts?: ExtraOpts): Node<T[]>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>source</code> | <code>Node&lt;T&gt;</code> | Upstream node. |
-| <code>opts</code> | <code>ExtraOpts</code> | Optional node options (derived describe kind). |
-
-## Returns
-
-`Node&lt;T[]&gt;` — single array emission before completion.
-
-## Basic Usage
-
-```ts
-import { of, toArray } from "@graphrefly/graphrefly";
-
-toArray(of(1, 2, 3));
-```
diff --git a/website/src/content/docs/api/toObservable.md b/website/src/content/docs/api/toObservable.md
deleted file mode 100644
index 7bc101d4..00000000
--- a/website/src/content/docs/api/toObservable.md
+++ /dev/null
@@ -1,24 +0,0 @@
----
-title: "toObservable()"
-description: "API reference for toObservable."
----
-
-## Signature
-
-```ts
-function toObservable<T>(
-	node: Node<T>,
-	options?: ToObservableOptions & { raw?: false },
-): InteropObservable<T>
-function toObservable<T>(
-	node: Node<T>,
-	options: ToObservableOptions & { raw: true },
-): InteropObservable<Messages>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>node</code> | <code>Node&lt;T&gt;</code> |  |
-| <code>options</code> | <code>ToObservableOptions</code> |  |
diff --git a/website/src/content/docs/api/topic.md b/website/src/content/docs/api/topic.md
deleted file mode 100644
index 7e19c1b5..00000000
--- a/website/src/content/docs/api/topic.md
+++ /dev/null
@@ -1,19 +0,0 @@
----
-title: "topic()"
-description: "Creates a Pulsar-inspired topic graph (append-only retained stream + latest value)."
----
-
-Creates a Pulsar-inspired topic graph (append-only retained stream + latest value).
-
-## Signature
-
-```ts
-function topic<T>(name: string, opts?: TopicOptions): TopicGraph<T>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>name</code> | <code>string</code> |  |
-| <code>opts</code> | <code>TopicOptions</code> |  |
diff --git a/website/src/content/docs/api/topicBridge.md b/website/src/content/docs/api/topicBridge.md
deleted file mode 100644
index 70149ced..00000000
--- a/website/src/content/docs/api/topicBridge.md
+++ /dev/null
@@ -1,31 +0,0 @@
----
-title: "topicBridge()"
-description: "Creates an autonomous cursor-based topic relay graph.\n\nWhen `opts.map` is provided, items where `map` returns `undefined` are\nconsumed from the source cursor bu"
----
-
-Creates an autonomous cursor-based topic relay graph.
-
-When `opts.map` is provided, items where `map` returns `undefined` are
-consumed from the source cursor but NOT republished (at-most-once with
-silent drop). For filter-with-retry semantics, apply the filter in a
-downstream subscription on the bridge's `output` node instead.
-
-## Signature
-
-```ts
-function topicBridge<TIn, TOut = TIn>(
-	name: string,
-	sourceTopic: TopicGraph<TIn>,
-	targetTopic: TopicGraph<TOut>,
-	opts?: TopicBridgeOptions<TIn, TOut>,
-): TopicBridgeGraph<TIn, TOut>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>name</code> | <code>string</code> |  |
-| <code>sourceTopic</code> | <code>TopicGraph&lt;TIn&gt;</code> |  |
-| <code>targetTopic</code> | <code>TopicGraph&lt;TOut&gt;</code> |  |
-| <code>opts</code> | <code>TopicBridgeOptions&lt;TIn, TOut&gt;</code> |  |
diff --git a/website/src/content/docs/api/validateGraphObservability.md b/website/src/content/docs/api/validateGraphObservability.md
deleted file mode 100644
index 562b0b62..00000000
--- a/website/src/content/docs/api/validateGraphObservability.md
+++ /dev/null
@@ -1,40 +0,0 @@
----
-title: "validateGraphObservability()"
-description: "Exercise every observability surface on `graph` and report failures.\n\nDoes NOT throw — returns a structured result so callers (dry-run blocks,\nCLI smoke tests, "
----
-
-Exercise every observability surface on `graph` and report failures.
-
-Does NOT throw — returns a structured result so callers (dry-run blocks,
-CLI smoke tests, MCP reduce-path validators) can exit non-zero with a
-diagnostic instead of letting the process crash mid-inspection.
-
-## Signature
-
-```ts
-function validateGraphObservability(
-	graph: Graph,
-	opts: ValidateObservabilityOptions = {},
-): ValidateObservabilityResult
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>graph</code> | <code>Graph</code> |  |
-| <code>opts</code> | <code>ValidateObservabilityOptions</code> |  |
-
-## Basic Usage
-
-```ts
-const result = validateGraphObservability(graph, {
-    paths: ["input", "output"],
-    pairs: [["input", "output"]],
-  });
-if (!result.ok) {
-  console.error(result.summary());
-  for (const f of result.failures) console.error(f);
-  process.exit(3);
-}
-```
diff --git a/website/src/content/docs/api/validateNoIslands.md b/website/src/content/docs/api/validateNoIslands.md
deleted file mode 100644
index aae11bd7..00000000
--- a/website/src/content/docs/api/validateNoIslands.md
+++ /dev/null
@@ -1,29 +0,0 @@
----
-title: "validateNoIslands()"
-description: "Walk the graph's describe output and report island nodes (zero in + zero out edges)."
----
-
-Walk the graph's describe output and report island nodes (zero in + zero out edges).
-
-## Signature
-
-```ts
-function validateNoIslands(graph: Graph): ValidateNoIslandsResult
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>graph</code> | <code>Graph</code> |  |
-
-## Basic Usage
-
-```ts
-const result = validateNoIslands(graph);
-if (!result.ok) {
-  console.error(result.summary());
-  for (const o of result.orphans) console.error(`  - ${o.path} (${o.kind})`);
-  process.exit(3);
-}
-```
diff --git a/website/src/content/docs/api/validateSpec.md b/website/src/content/docs/api/validateSpec.md
deleted file mode 100644
index 49051bb8..00000000
--- a/website/src/content/docs/api/validateSpec.md
+++ /dev/null
@@ -1,28 +0,0 @@
----
-title: "validateSpec()"
-description: "Validate a GraphSpec JSON object.\n\nChecks structural validity: required fields, node types, dep references,\ntemplate references, feedback edge targets, self-cyc"
----
-
-Validate a GraphSpec JSON object.
-
-Checks structural validity: required fields, node types, dep references,
-template references, feedback edge targets, self-cycles, and bind completeness.
-
-**Effect-node feedback advisory (C24-3).** When a feedback edge's `from`
-refers to an `effect` node, the validator flags it via `warnings` (not
-`errors`) — effect nodes produce no DATA emission, so a feedback counter
-targeting one will never advance. The spec compiles either way; the
-advisory exists because the misconfiguration is silent at runtime
-(counter at 0 forever) without it.
-
-## Signature
-
-```ts
-function validateSpec(spec: unknown): GraphSpecValidation
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>spec</code> | <code>unknown</code> |  |
diff --git a/website/src/content/docs/api/verifiable.md b/website/src/content/docs/api/verifiable.md
deleted file mode 100644
index cdf1aa36..00000000
--- a/website/src/content/docs/api/verifiable.md
+++ /dev/null
@@ -1,26 +0,0 @@
----
-title: "verifiable()"
-description: "Composes a value node with a reactive verification companion.\n\nUses `switchMap` so newer triggers cancel stale in-flight verification work."
----
-
-Composes a value node with a reactive verification companion.
-
-Uses `switchMap` so newer triggers cancel stale in-flight verification work.
-
-## Signature
-
-```ts
-function verifiable<T, TVerify = VerifyValue>(
-	source: NodeInput<T>,
-	verifyFn: (value: T) => NodeInput<TVerify>,
-	opts?: VerifiableOptions<TVerify>,
-): VerifiableBundle<T, TVerify>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>source</code> | <code>NodeInput&lt;T&gt;</code> |  |
-| <code>verifyFn</code> | <code>(value: T) =&gt; NodeInput&lt;TVerify&gt;</code> |  |
-| <code>opts</code> | <code>VerifiableOptions&lt;TVerify&gt;</code> |  |
diff --git a/website/src/content/docs/api/watchTopologyTree.md b/website/src/content/docs/api/watchTopologyTree.md
deleted file mode 100644
index 259b90d5..00000000
--- a/website/src/content/docs/api/watchTopologyTree.md
+++ /dev/null
@@ -1,37 +0,0 @@
----
-title: "watchTopologyTree()"
-description: "Subscribe to structural changes across `graph` and every transitively\nmounted subgraph. `cb` fires on every TopologyEvent from any\ngraph in the tree. Newly-moun"
----
-
-Subscribe to structural changes across `graph` and every transitively
-mounted subgraph. `cb` fires on every TopologyEvent from any
-graph in the tree. Newly-mounted subgraphs are auto-wired when their
-parent emits `{kind: "added", nodeKind: "mount"}`; newly-unmounted
-subgraphs' subscriptions are disposed via the parent's
-`{kind: "removed", nodeKind: "mount"}` event plus the returned
-`GraphRemoveAudit`.
-
-The callback receives a third argument `prefix`: the `::`-delimited
-path from the root watched graph to the emitter, ending with `"::"`
-(empty string when the event comes from the root itself). Compute
-a qualified path for an added/removed entry as `prefix + event.name`.
-
-## Signature
-
-```ts
-function watchTopologyTree(
-	graph: Graph,
-	cb: (event: TopologyEvent, emitter: Graph, prefix: string) => void,
-): () => void
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>graph</code> | <code>Graph</code> | Root graph to watch. |
-| <code>cb</code> | <code>(event: TopologyEvent, emitter: Graph, prefix: string) =&gt; void</code> | Receives `(event, emitterGraph, prefix)`. |
-
-## Returns
-
-Dispose function — tears down every active subscription.
diff --git a/website/src/content/docs/api/webllmAdapter.md b/website/src/content/docs/api/webllmAdapter.md
deleted file mode 100644
index 88738006..00000000
--- a/website/src/content/docs/api/webllmAdapter.md
+++ /dev/null
@@ -1,16 +0,0 @@
----
-title: "webllmAdapter()"
-description: "API reference for webllmAdapter."
----
-
-## Signature
-
-```ts
-function webllmAdapter(opts: WebLLMAdapterOptions): LLMAdapter
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>opts</code> | <code>WebLLMAdapterOptions</code> |  |
diff --git a/website/src/content/docs/api/window.md b/website/src/content/docs/api/window.md
deleted file mode 100644
index 2a4d5b15..00000000
--- a/website/src/content/docs/api/window.md
+++ /dev/null
@@ -1,36 +0,0 @@
----
-title: "window()"
-description: "Splits source `DATA` into sub-nodes, opening a new window each time `notifier` emits `DATA`."
----
-
-Splits source `DATA` into sub-nodes, opening a new window each time `notifier` emits `DATA`.
-
-## Signature
-
-```ts
-function window<T>(
-	source: Node<T>,
-	notifier: Node<unknown>,
-	opts?: ExtraOpts,
-): Node<Node<T>>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>source</code> | <code>Node&lt;T&gt;</code> | Upstream node. |
-| <code>notifier</code> | <code>Node&lt;unknown&gt;</code> | Each `DATA` from `notifier` closes the current window and opens a new one. |
-| <code>opts</code> | <code>ExtraOpts</code> | Optional NodeOptions (excluding `describeKind`). |
-
-## Returns
-
-`Node&lt;Node&lt;T&gt;&gt;` - Each emission is a sub-node carrying that window's values.
-
-## Basic Usage
-
-```ts
-import { state, window } from "@graphrefly/pure-ts";
-
-window(state(0), state(0));
-```
diff --git a/website/src/content/docs/api/windowCount.md b/website/src/content/docs/api/windowCount.md
deleted file mode 100644
index 989544b8..00000000
--- a/website/src/content/docs/api/windowCount.md
+++ /dev/null
@@ -1,32 +0,0 @@
----
-title: "windowCount()"
-description: "Splits source `DATA` into sub-nodes of `count` values each. Each sub-node completes after `count` items or when source completes."
----
-
-Splits source `DATA` into sub-nodes of `count` values each. Each sub-node completes after `count` items or when source completes.
-
-## Signature
-
-```ts
-function windowCount<T>(source: Node<T>, count: number, opts?: ExtraOpts): Node<Node<T>>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>source</code> | <code>Node&lt;T&gt;</code> | Upstream node. |
-| <code>count</code> | <code>number</code> | Items per window. |
-| <code>opts</code> | <code>ExtraOpts</code> | Optional NodeOptions (excluding `describeKind`). |
-
-## Returns
-
-`Node&lt;Node&lt;T&gt;&gt;` - Each emission is a sub-node carrying that window's values.
-
-## Basic Usage
-
-```ts
-import { windowCount, state } from "@graphrefly/pure-ts";
-
-windowCount(state(0), 3);
-```
diff --git a/website/src/content/docs/api/windowTime.md b/website/src/content/docs/api/windowTime.md
deleted file mode 100644
index bd3d1e0b..00000000
--- a/website/src/content/docs/api/windowTime.md
+++ /dev/null
@@ -1,32 +0,0 @@
----
-title: "windowTime()"
-description: "Splits source `DATA` into time-windowed sub-nodes; each window lasts `ms`."
----
-
-Splits source `DATA` into time-windowed sub-nodes; each window lasts `ms`.
-
-## Signature
-
-```ts
-function windowTime<T>(source: Node<T>, ms: number, opts?: ExtraOpts): Node<Node<T>>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>source</code> | <code>Node&lt;T&gt;</code> | Upstream node. |
-| <code>ms</code> | <code>number</code> | Window duration in milliseconds. |
-| <code>opts</code> | <code>ExtraOpts</code> | Optional NodeOptions (excluding `describeKind`). |
-
-## Returns
-
-`Node&lt;Node&lt;T&gt;&gt;` - Each emission is a sub-node carrying that window's values.
-
-## Basic Usage
-
-```ts
-import { windowTime, state } from "@graphrefly/pure-ts";
-
-windowTime(state(0), 500);
-```
diff --git a/website/src/content/docs/api/withBreaker.md b/website/src/content/docs/api/withBreaker.md
deleted file mode 100644
index 286b5fe7..00000000
--- a/website/src/content/docs/api/withBreaker.md
+++ /dev/null
@@ -1,42 +0,0 @@
----
-title: "withBreaker()"
-description: "Returns a unary wrapper that gates upstream `DATA` through a CircuitBreaker."
----
-
-Returns a unary wrapper that gates upstream `DATA` through a CircuitBreaker.
-
-## Signature
-
-```ts
-function withBreaker<T>(
-	breaker: CircuitBreaker,
-	options?: { onOpen?: "skip" | "error"; meta?: Record<string, unknown> },
-): (source: Node<T>) => WithBreakerBundle<T>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>breaker</code> | <code>CircuitBreaker</code> | Shared breaker instance (typically one per resource). |
-| <code>options</code> | <code>{ onOpen?: "skip" | "error"; meta?: Record&lt;string, unknown&gt; }</code> | `onOpen: "skip"` emits `RESOLVED` when open; `"error"` emits CircuitOpenError. |
-
-## Returns
-
-Function mapping `Node&lt;T&gt;` to `{ node, breakerState }` companion nodes.
-
-## Basic Usage
-
-```ts
-import { state, withBreaker, circuitBreaker } from "@graphrefly/graphrefly";
-
-const b = circuitBreaker({ failureThreshold: 2 });
-const s = state(1);
-const { node, breakerState } = withBreaker(b)(s);
-```
-
-## Behavior Details
-
-- **Success path:** `COMPLETE` calls CircuitBreaker.recordSuccess. **Failure path:** upstream `ERROR` calls CircuitBreaker.recordFailure and is forwarded.
-
-**State telemetry:** `breakerState: Node<CircuitState>` is a reactive companion that mirrors `breaker.state` — every transition (`closed`/`open`/`half-open`) emits a `DATA`. Also accessible via `node.meta.breakerState` for `describe()` traversal.
diff --git a/website/src/content/docs/api/withBudgetGate.md b/website/src/content/docs/api/withBudgetGate.md
deleted file mode 100644
index d20c387c..00000000
--- a/website/src/content/docs/api/withBudgetGate.md
+++ /dev/null
@@ -1,23 +0,0 @@
----
-title: "withBudgetGate()"
-description: "Wrap an adapter with budget enforcement. Returns `{adapter, budget}` so\ncallers can subscribe to the bundle for dashboards."
----
-
-Wrap an adapter with budget enforcement. Returns `{adapter, budget}` so
-callers can subscribe to the bundle for dashboards.
-
-## Signature
-
-```ts
-function withBudgetGate(
-	inner: LLMAdapter,
-	opts: WithBudgetGateOptions,
-): { adapter: LLMAdapter; budget: LLMBudgetGateBundle }
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>inner</code> | <code>LLMAdapter</code> |  |
-| <code>opts</code> | <code>WithBudgetGateOptions</code> |  |
diff --git a/website/src/content/docs/api/withDryRun.md b/website/src/content/docs/api/withDryRun.md
deleted file mode 100644
index bd598947..00000000
--- a/website/src/content/docs/api/withDryRun.md
+++ /dev/null
@@ -1,17 +0,0 @@
----
-title: "withDryRun()"
-description: "API reference for withDryRun."
----
-
-## Signature
-
-```ts
-function withDryRun(inner: LLMAdapter, opts: WithDryRunOptions): WithDryRunBundle
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>inner</code> | <code>LLMAdapter</code> |  |
-| <code>opts</code> | <code>WithDryRunOptions</code> |  |
diff --git a/website/src/content/docs/api/withLatestFrom.md b/website/src/content/docs/api/withLatestFrom.md
deleted file mode 100644
index fb37b00f..00000000
--- a/website/src/content/docs/api/withLatestFrom.md
+++ /dev/null
@@ -1,36 +0,0 @@
----
-title: "withLatestFrom()"
-description: "When `primary` settles, emits `[primary, latestSecondary]`. `secondary` alone updates cache only."
----
-
-When `primary` settles, emits `[primary, latestSecondary]`. `secondary` alone updates cache only.
-
-## Signature
-
-```ts
-function withLatestFrom<A, B>(
-	primary: Node<A>,
-	secondary: Node<B>,
-	opts?: ExtraOpts,
-): Node<readonly [A, B]>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>primary</code> | <code>Node&lt;A&gt;</code> | Main stream. |
-| <code>secondary</code> | <code>Node&lt;B&gt;</code> | Latest value is paired on each primary emission. |
-| <code>opts</code> | <code>ExtraOpts</code> | Optional NodeOptions (excluding `describeKind`). |
-
-## Returns
-
-`Node&lt;readonly [A, B]&gt;` - Paired stream.
-
-## Basic Usage
-
-```ts
-import { state, withLatestFrom } from "@graphrefly/pure-ts";
-
-const n = withLatestFrom(state(1), state("x"));
-```
diff --git a/website/src/content/docs/api/withMaxAttempts.md b/website/src/content/docs/api/withMaxAttempts.md
deleted file mode 100644
index 2e670aff..00000000
--- a/website/src/content/docs/api/withMaxAttempts.md
+++ /dev/null
@@ -1,32 +0,0 @@
----
-title: "withMaxAttempts()"
-description: "Decorator that caps any strategy at `maxAttempts`. Returns `null` (stop retrying) after the cap."
----
-
-Decorator that caps any strategy at `maxAttempts`. Returns `null` (stop retrying) after the cap.
-
-## Signature
-
-```ts
-function withMaxAttempts(strategy: BackoffStrategy, maxAttempts: number): BackoffStrategy
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>strategy</code> | <code>BackoffStrategy</code> | Inner strategy to wrap. |
-| <code>maxAttempts</code> | <code>number</code> | Maximum number of attempts (inclusive). |
-
-## Returns
-
-Wrapped `BackoffStrategy`.
-
-## Basic Usage
-
-```ts
-import { withMaxAttempts, exponential } from "@graphrefly/graphrefly";
-
-const capped = withMaxAttempts(exponential(), 3);
-capped(3); // null — no more retries beyond attempt 3
-```
diff --git a/website/src/content/docs/api/withRateLimiter.md b/website/src/content/docs/api/withRateLimiter.md
deleted file mode 100644
index fb95cacc..00000000
--- a/website/src/content/docs/api/withRateLimiter.md
+++ /dev/null
@@ -1,24 +0,0 @@
----
-title: "withRateLimiter()"
-description: "Wrap an adapter with adaptive rate limiting. Returns `{adapter, limiter}`\nso callers can subscribe to limiter internals (rpmAvailable, pending, etc.)\nfor dashbo"
----
-
-Wrap an adapter with adaptive rate limiting. Returns `{adapter, limiter}`
-so callers can subscribe to limiter internals (rpmAvailable, pending, etc.)
-for dashboards.
-
-## Signature
-
-```ts
-function withRateLimiter(
-	inner: LLMAdapter,
-	opts: WithRateLimiterOptions = {},
-): { adapter: LLMAdapter; limiter: AdaptiveRateLimiterBundle }
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>inner</code> | <code>LLMAdapter</code> |  |
-| <code>opts</code> | <code>WithRateLimiterOptions</code> |  |
diff --git a/website/src/content/docs/api/withReplayCache.md b/website/src/content/docs/api/withReplayCache.md
deleted file mode 100644
index e70f45e4..00000000
--- a/website/src/content/docs/api/withReplayCache.md
+++ /dev/null
@@ -1,19 +0,0 @@
----
-title: "withReplayCache()"
-description: "Wrap an adapter with a replay cache."
----
-
-Wrap an adapter with a replay cache.
-
-## Signature
-
-```ts
-function withReplayCache(inner: LLMAdapter, opts: WithReplayCacheOptions): LLMAdapter
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>inner</code> | <code>LLMAdapter</code> |  |
-| <code>opts</code> | <code>WithReplayCacheOptions</code> |  |
diff --git a/website/src/content/docs/api/withRetry.md b/website/src/content/docs/api/withRetry.md
deleted file mode 100644
index 6c59a1e0..00000000
--- a/website/src/content/docs/api/withRetry.md
+++ /dev/null
@@ -1,17 +0,0 @@
----
-title: "withRetry()"
-description: "API reference for withRetry."
----
-
-## Signature
-
-```ts
-function withRetry(inner: LLMAdapter, opts: WithRetryOptions = {}): LLMAdapter
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>inner</code> | <code>LLMAdapter</code> |  |
-| <code>opts</code> | <code>WithRetryOptions</code> |  |
diff --git a/website/src/content/docs/api/withStatus.md b/website/src/content/docs/api/withStatus.md
deleted file mode 100644
index cdc1a984..00000000
--- a/website/src/content/docs/api/withStatus.md
+++ /dev/null
@@ -1,68 +0,0 @@
----
-title: "withStatus()"
-description: "Wraps `src` with `status` and `error` state companions for UI or meta snapshots."
----
-
-Wraps `src` with `status` and `error` state companions for UI or meta snapshots.
-
-## Signature
-
-```ts
-function withStatus<T>(
-	src: Node<T>,
-	options?: { initialStatus?: StatusValue; meta?: Record<string, unknown> },
-): WithStatusBundle<T>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>src</code> | <code>Node&lt;T&gt;</code> | Upstream node to mirror. |
-| <code>options</code> | <code>{ initialStatus?: StatusValue; meta?: Record&lt;string, unknown&gt; }</code> | `initialStatus` defaults to `"pending"`. |
-
-## Returns
-
-`{ node, status, error }` where `out` is the mirrored stream, `status` is a
-reactive `Node&lt;StatusValue&gt;` (`"pending" | "running" | "completed" | "errored"`),
-and `error` holds the last `ERROR` payload (cleared to `null` on the next `DATA`
-after `errored`).
-
-## Basic Usage
-
-```ts
-import { withStatus, state } from "@graphrefly/graphrefly";
-
-const src = state<number>(0);
-const { node, status, error } = withStatus(src);
-
-status.subscribe((msgs) => console.log("status:", msgs));
-src.down([[DATA, 42]]); // status → "running"
-```
-
-## Behavior Details
-
-- **Lifecycle:** `pending` (no DATA yet) → `running` (on first DATA) → `completed`
-(on COMPLETE) or `errored` (on ERROR). After `errored`, the next `DATA` clears
-`error` and re-enters `running` inside a batch so subscribers see one
-consistent transition (matches graphrefly-py).
-
-**Producer-pattern visibility:** `out` is built via `node([], fn, …)`, so `src`
-appears as the source dependency in `describe()` traversal but the `status` /
-`error` companions are mirrored via subscribe-callback effects — they appear
-under `out.meta.status` / `out.meta.error` (and as `<name>::__meta__::status`
-paths in `describe()`) rather than as separate top-level edges. Subscribers
-to `out` see the throttled DATA stream; `status` / `error` companions may not
-appear as edges in `describe()` if no consumer subscribes to them (per
-COMPOSITION-GUIDE §1, push-on-subscribe semantics).
-
-**Per-subscribe lifecycle (DF8, 2026-04-29 doc lock).** When the wrapped
-source is `resubscribable: true` and multiple consumers attach in
-sequence, each new subscription cycle re-runs the producer fn AND
-re-emits the initial `pending` + `null` companion DATAs. Downstream
-subscribers to the `status` / `error` companions see thrash:
-`pending → running → completed → pending → running …`. This is the
-intended fresh-cycle semantic (each subscription cycle reports its own
-lifecycle); consumers that need a "stable" status across cycles should
-derive a snapshot via a separate `state()` mirror rather than depending
-on the per-cycle reset.
diff --git a/website/src/content/docs/api/withTimeout.md b/website/src/content/docs/api/withTimeout.md
deleted file mode 100644
index 90ec7b33..00000000
--- a/website/src/content/docs/api/withTimeout.md
+++ /dev/null
@@ -1,49 +0,0 @@
----
-title: "withTimeout()"
-description: "Wrap `source` with a deadline. If no `DATA` arrives within `opts.ns`\nnanoseconds, the result node emits `[[ERROR, TimeoutError]]` and\ntransitions `timeoutState`"
----
-
-Wrap `source` with a deadline. If no `DATA` arrives within `opts.ns`
-nanoseconds, the result node emits `[[ERROR, TimeoutError]]` and
-transitions `timeoutState` to `"errored"`.
-
-The timer starts on subscription and resets on each `DATA`. `DIRTY`
-does NOT reset the timer. Terminal messages (`COMPLETE` / `ERROR`)
-cancel the timer.
-
-**Reactive opts (DS-13.5.B, locked 2026-05-01).**
-
-- Static-form callers pass `Partial&lt;TimeoutOptions&gt;` (today's path).
-  `ns` is validated at construction; missing / non-positive throws
-  `RangeError`.
-- Reactive-form callers pass `Node&lt;Partial&lt;TimeoutOptions&gt;&gt;` — each
-  emission shallow-merges over the prior opts. Empty `{}` emissions
-  are no-ops (no rebind, no companion fire). Mid-flight opts swap
-  does NOT reset the in-flight deadline; new `ns` applies to the
-  next `startTimer()` call.
-- When the opts Node has `cache === undefined` (SENTINEL: no opts
-  emitted yet), the source is paused until the first valid opts
-  settle. The first valid settle must carry `ns &gt; 0` or the timer
-  layer emits an ERROR (downstream observable) — distinct from the
-  construction-time `RangeError` thrown for static / cache-defined
-  invalid values.
-
-## Signature
-
-```ts
-function withTimeout<T>(
-	source: Node<T>,
-	opts: Partial<TimeoutOptions> | Node<Partial<TimeoutOptions>>,
-	extraOpts?: TimeoutExtraOpts,
-): TimeoutBundle<T>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>source</code> | <code>Node&lt;T&gt;</code> | Upstream node. |
-| <code>opts</code> | <code>Partial&lt;TimeoutOptions&gt; | Node&lt;Partial&lt;TimeoutOptions&gt;&gt;</code> | `Partial&lt;TimeoutOptions&gt;` (static) or
-`Node&lt;Partial&lt;TimeoutOptions&gt;&gt;` (reactive). |
-| <code>extraOpts</code> | <code>TimeoutExtraOpts</code> | Forwarded factory metadata (meta field merged
-onto the result node). |
diff --git a/website/src/content/docs/api/workerBridge.md b/website/src/content/docs/api/workerBridge.md
deleted file mode 100644
index 15612077..00000000
--- a/website/src/content/docs/api/workerBridge.md
+++ /dev/null
@@ -1,23 +0,0 @@
----
-title: "workerBridge()"
-description: "API reference for workerBridge."
----
-
-## Signature
-
-```ts
-function workerBridge<
-	TExpose extends Record<string, Node<any>>,
-	TImport extends readonly string[],
->(
-	target: unknown | WorkerTransport,
-	opts: WorkerBridgeOptions<TExpose, TImport>,
-): WorkerBridge<TExpose, TImport>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>target</code> | <code>unknown | WorkerTransport</code> |  |
-| <code>opts</code> | <code>WorkerBridgeOptions&lt;TExpose, TImport&gt;</code> |  |
diff --git a/website/src/content/docs/api/workerSelf.md b/website/src/content/docs/api/workerSelf.md
deleted file mode 100644
index 680efab7..00000000
--- a/website/src/content/docs/api/workerSelf.md
+++ /dev/null
@@ -1,20 +0,0 @@
----
-title: "workerSelf()"
-description: "API reference for workerSelf."
----
-
-## Signature
-
-```ts
-function workerSelf<TImport extends readonly string[]>(
-	target: unknown | WorkerTransport,
-	opts: WorkerSelfOptions<TImport>,
-): WorkerSelfHandle
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>target</code> | <code>unknown | WorkerTransport</code> |  |
-| <code>opts</code> | <code>WorkerSelfOptions&lt;TImport&gt;</code> |  |
diff --git a/website/src/content/docs/api/zip.md b/website/src/content/docs/api/zip.md
deleted file mode 100644
index 4464438a..00000000
--- a/website/src/content/docs/api/zip.md
+++ /dev/null
@@ -1,32 +0,0 @@
----
-title: "zip()"
-description: "Zips one **`DATA`** from each source per cycle into a tuple. Only **`DATA`** enqueues (spec §1.3.3)."
----
-
-Zips one **`DATA`** from each source per cycle into a tuple. Only **`DATA`** enqueues (spec §1.3.3).
-
-## Signature
-
-```ts
-function zip<const T extends readonly unknown[]>(
-	...sources: { [K in keyof T]: Node<T[K]> }
-): Node<T>
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| <code>sources</code> | <code>{ [K in keyof T]: Node&lt;T[K]&gt; }</code> | Nodes to zip (variadic). |
-
-## Returns
-
-`Node&lt;T&gt;` - Zipped tuples.
-
-## Basic Usage
-
-```ts
-import { state, zip } from "@graphrefly/pure-ts";
-
-const n = zip(state(1), state(2));
-```
diff --git a/website/src/content/docs/blog/01-the-road-to-graphrefly.md b/website/src/content/docs/blog/01-the-road-to-graphrefly.md
index 4c4fa3a9..37c99275 100644
--- a/website/src/content/docs/blog/01-the-road-to-graphrefly.md
+++ b/website/src/content/docs/blog/01-the-road-to-graphrefly.md
@@ -9,6 +9,10 @@ tags: [origins, design-philosophy, architecture]
 
 *Arc 1, Post 1 — Origins: From Callbag to GraphReFly*
 
+> Historical note (CSP-9): this post preserves the pre-clean-slate/root-package
+> story. Current TypeScript guidance uses `@graphrefly/ts` and focused subpaths;
+> do not copy `@graphrefly/graphrefly` imports from historical snippets.
+
 ---
 
 In 2018, Andre Staltz published [callbag](https://github.com/callbag/callbag), a spec for reactive programming based on a single function signature. No classes. No inheritance. No framework. Just functions calling functions.
diff --git a/website/src/content/docs/blog/02-protocol-first-thinking.md b/website/src/content/docs/blog/02-protocol-first-thinking.md
index a5226516..5cc404c5 100644
--- a/website/src/content/docs/blog/02-protocol-first-thinking.md
+++ b/website/src/content/docs/blog/02-protocol-first-thinking.md
@@ -9,6 +9,10 @@ tags: [architecture, design-philosophy, protocol]
 
 *Arc 1, Post 2 — Origins: From Callbag to GraphReFly*
 
+> Historical note (CSP-9): this post preserves the pre-clean-slate/root-package
+> story. Current TypeScript guidance uses `@graphrefly/ts` and focused subpaths;
+> do not copy `@graphrefly/graphrefly` or `/extra` imports from historical snippets.
+
 ---
 
 Most reactive libraries start with an API. You get `Observable`, `Signal`, `Atom`, `Store` — a set of classes or functions that encode a specific model of reactivity. The protocol is an implementation detail, hidden behind the public surface.
diff --git a/website/src/content/docs/blog/03-signals-are-not-enough.md b/website/src/content/docs/blog/03-signals-are-not-enough.md
index 9717222c..8a465f50 100644
--- a/website/src/content/docs/blog/03-signals-are-not-enough.md
+++ b/website/src/content/docs/blog/03-signals-are-not-enough.md
@@ -10,6 +10,10 @@ tags: [architecture, design-philosophy]
 
 *Arc 1, Post 3 — Origins: Why Revive Callbag?*
 
+> Historical note (CSP-9): this post preserves the pre-clean-slate/root-package
+> story. Current TypeScript guidance uses `@graphrefly/ts` and focused subpaths;
+> do not copy `@graphrefly/graphrefly` imports from historical snippets.
+
 ---
 
 Let's be clear upfront: TC39 Signals are a good idea. Standardizing fine-grained reactivity at the language level is the right move. Preact Signals, SolidJS, Angular Signals, Vue's ref system — they've all converged on roughly the same model. A standard is overdue.
@@ -215,14 +219,13 @@ You shouldn't need to choose between "reactive counter" and "cancelable debounce
 
 ## The compatibility layer approach
 
-We're not asking anyone to abandon Signals. We built compatibility wrappers:
+We're not asking anyone to abandon Signals. The retired compat wrappers proved the bridge pattern; clean-slate keeps framework bridges under focused adapter subpaths.
 
 ```ts
-import { SignalState, SignalComputed } from '@graphrefly/graphrefly/compat/signals';
+import { signalFromNode } from '@graphrefly/ts/adapters';
 
-// TC39 Signals API, GraphReFly engine
-const count = new SignalState(0);
-const doubled = new SignalComputed(() => count.get() * 2);
+// Signal-style facade over a caller-owned GraphReFly node
+const countSignal = signalFromNode(countNode);
 
 // But now you can also do this:
 pipe(
@@ -235,7 +238,7 @@ pipe(
 
 Same API you already know. But when you need stream operators, diamond resolution, completion semantics, or observability — it's there. No second library.
 
-We also have compat layers for [Zustand](/recipes/zustand-migration), [Jotai](/recipes/jotai-migration), and [Nanostores](/recipes/nanostores-migration). The point isn't to replace what works. It's to extend it into territory Signals can't reach.
+Focused framework adapters live under `@graphrefly/ts/adapters/*`, without reviving the retired `compat/*` runtime model. The point isn't to replace what works. It's to extend it into territory Signals can't reach.
 
 ## What GraphReFly costs you
 
diff --git a/website/src/content/docs/blog/05-explicit-dependencies.md b/website/src/content/docs/blog/05-explicit-dependencies.md
index 998ebe6b..a857822b 100644
--- a/website/src/content/docs/blog/05-explicit-dependencies.md
+++ b/website/src/content/docs/blog/05-explicit-dependencies.md
@@ -50,7 +50,7 @@ That split is deliberate. Subscriptions are **graph structure**. Reads are **com
 
 ## Why we rejected "just track like Jotai"
 
-The trade-off shows up clearly when you compare APIs side by side — see [GraphReFly vs Jotai](/comparisons/jotai) for the full picture.
+The trade-off shows up clearly when you compare implicit atoms with explicit dependency arrays.
 
 **Implicit tracking** needs a runtime mechanism: a stack or zone of "who is computing right now," hooks in `get()`, dependency diffing when the set changes, and rules for async boundaries. It is powerful — Jotai proves you can ship a minimal API on top — but when something goes wrong, you debug **the tracking implementation**, not just your business logic.
 
@@ -90,7 +90,7 @@ We still use plain `.get()` inside computations. We did not throw away pull sema
 
 - [Push Dirty, Pull Values: Our First Diamond Solution](./04-push-dirty-pull-values) — how pull chains interacted with explicit wiring in v1
 - [Signals Are Not Enough](./03-signals-are-not-enough) — where fine-grained UI signals stop and streaming begins
-- [GraphReFly vs Jotai](/comparisons/jotai) — implicit atoms vs explicit `derived([...], fn)` deps
+- [Signals Are Not Enough](./03-signals-are-not-enough) — where fine-grained UI signals stop and streaming begins
 
 ---
 
diff --git a/website/src/content/docs/blog/07-data-flows-through-graph.md b/website/src/content/docs/blog/07-data-flows-through-graph.md
index dc45e239..f3d6b4c1 100644
--- a/website/src/content/docs/blog/07-data-flows-through-graph.md
+++ b/website/src/content/docs/blog/07-data-flows-through-graph.md
@@ -9,6 +9,10 @@ tags: [architecture, two-phase-push, design-philosophy]
 
 *Arc 3, Post 7 — Architecture Evolution: The Great Unification*
 
+> Historical note (CSP-9): this post preserves the pre-clean-slate/root-package
+> story. Current TypeScript guidance uses `@graphrefly/ts` and focused subpaths;
+> do not copy `@graphrefly/graphrefly` imports from historical snippets.
+
 ---
 
 In the predecessor (callbag-recharge), callbag was already doing the hard work: **talkback**, explicit sinks, a graph you could reason about. In our first architecture pass, we still treated it like a **notification bus** while the real numbers moved through a side door.
diff --git a/website/src/content/docs/blog/23-stores-all-the-way-down.md b/website/src/content/docs/blog/23-stores-all-the-way-down.md
index d7226305..ad3a9885 100644
--- a/website/src/content/docs/blog/23-stores-all-the-way-down.md
+++ b/website/src/content/docs/blog/23-stores-all-the-way-down.md
@@ -46,7 +46,7 @@ This keeps reactive semantics intact while giving app code predictable state acc
 Once every node speaks store, higher layers become straightforward:
 
 - adapters can load/save against a stable state shape
-- compat wrappers can mirror familiar APIs (like Zustand-style stores via `@graphrefly/graphrefly/compat/zustand`)
+- focused adapters can mirror familiar APIs, such as Zustand-style stores via `zustandStore(...)` from `@graphrefly/ts/adapters`
 - orchestration flows can coordinate around explicit status stores
 - `graph.describe()` can snapshot the entire graph's state for inspection or persistence
 
diff --git a/website/src/content/docs/blog/25-zustand-to-orchestration.md b/website/src/content/docs/blog/25-zustand-to-orchestration.md
index e1b37f43..fc67cc5c 100644
--- a/website/src/content/docs/blog/25-zustand-to-orchestration.md
+++ b/website/src/content/docs/blog/25-zustand-to-orchestration.md
@@ -27,10 +27,10 @@ Asking teams to jump directly into `node`, `derived()`, and `graph.describe()` i
 
 ## What the wrapper does
 
-The compat layer at `@graphrefly/graphrefly/compat/zustand` maps known patterns onto GraphReFly internals:
+The clean-slate store facade `zustandStore(...)` from `@graphrefly/ts/adapters` maps caller-owned GraphReFly nodes into a Zustand-style shape:
 
 ```ts
-import { createStore } from '@graphrefly/graphrefly/compat/zustand';
+import { zustandStore } from '@graphrefly/ts/adapters';
 
 const useStore = createStore((set) => ({
   count: 0,
@@ -60,7 +60,7 @@ You keep adoption friction low while changing what is possible.
 
 Successful migrations usually follow:
 
-1. Replace store creation with `@graphrefly/graphrefly/compat/zustand` wrapper
+1. Bind existing state nodes through `zustandStore(...)` from `@graphrefly/ts/adapters`
 2. Keep existing actions/selectors stable — components do not change
 3. Move async flows into reactive operators and orchestration nodes
 4. Gradually replace wrapper surfaces with native `state()`, `derived()`, and `effect()` where beneficial
diff --git a/website/src/content/docs/blog/40-versioned-nodes.md b/website/src/content/docs/blog/40-versioned-nodes.md
index bad2f393..2db2427e 100644
--- a/website/src/content/docs/blog/40-versioned-nodes.md
+++ b/website/src/content/docs/blog/40-versioned-nodes.md
@@ -15,6 +15,11 @@ tags:
 
 *Arc 7, Post 40 — NodeV0/V1 and Safe Schema Evolution*
 
+> Historical note (CSP-9): this post preserves the pre-clean-slate/root-package
+> versioning story. Current TypeScript guidance uses `@graphrefly/ts` and
+> focused subpaths; do not copy `@graphrefly/graphrefly` imports from historical
+> snippets.
+
 ---
 
 Here's the scenario every team building long-running agent workflows eventually faces: you have a graph running in production, checkpointing state every few minutes. You need to change the schema — add a field, rename a key, split a node into two. And you can't afford to lose the accumulated state.
diff --git a/website/src/content/docs/blog/42-one-describe.md b/website/src/content/docs/blog/42-one-describe.md
index 3c402cdf..d252aad9 100644
--- a/website/src/content/docs/blog/42-one-describe.md
+++ b/website/src/content/docs/blog/42-one-describe.md
@@ -17,7 +17,7 @@ tags:
 
 ---
 
-> **Update (post-v0.4 — D1 three-layer view):** the `format` sugar option on `describe()` was removed. `describe()` now returns data only (`GraphDescribeOutput` / `GraphSpec`); rendering moved to the pure functions in `@graphrefly/graphrefly/extra/render` — `graphSpecToMermaid`, `graphSpecToAscii`, `graphSpecToD2`, `graphSpecToPretty`, `graphSpecToJson`, `graphSpecToMermaidUrl`. The four-entry-points-into-one consolidation story below still holds — but the "one entry point" is now the data snapshot, with rendering composed on top via `derived` for live formatted output. The cognitive-cost argument carries over.
+> **Update (post-v0.4 — D1 three-layer view):** the `format` sugar option on `describe()` was removed. `describe()` now returns data only (`DescribeSnapshot`); rendering moved to the pure functions in `@graphrefly/ts/render` — `describeToMermaid`, `describeToAscii`, `describeToD2`, `describeToPretty`, `describeToJson`, `describeToMermaidUrl`. The four-entry-points-into-one consolidation story below still holds — but the "one entry point" is now the data snapshot, with rendering composed on top via `derived` for live formatted output. The cognitive-cost argument carries over.
 
 ---
 
diff --git a/website/src/content/docs/blog/45-ai-first-engineering.md b/website/src/content/docs/blog/45-ai-first-engineering.md
index f9f8ffb3..dec40c8b 100644
--- a/website/src/content/docs/blog/45-ai-first-engineering.md
+++ b/website/src/content/docs/blog/45-ai-first-engineering.md
@@ -31,9 +31,9 @@ The traditional product process is: write a specification, implement it, test it
 
 The AI-First version is different: describe what you need in natural language, have AI compose the topology that implements it, review the topology visually before it runs, then run it and iterate by talking — not by coding.
 
-GraphReFly's GraphSpec is designed for exactly this. It's a declarative schema that constrains what an LLM can produce to structural operations: add this node with these deps, connect these sources, apply this operator. The constraint space is narrow, like SQL constraining database operations — which means the LLM gets it right more often, and when it gets it wrong, the error is structural and obvious, not subtle and hidden in code.
+GraphReFly's describe snapshot is designed for exactly this. It's a declarative topology view that constrains review to structural operations: add this node with these deps, connect these sources, apply this operator. The constraint space is narrow, like SQL constraining database operations — which means the LLM gets it right more often, and when it gets it wrong, the error is structural and obvious, not subtle and hidden in code.
 
-The review step happens at the `graphSpecToMermaid(graph.describe())` level (any of the `graphSpecTo*` pure renderers from `@graphrefly/graphrefly/extra/render` works the same way): before a graph runs, the engineer reviews a simplified flow view. Not code. Not a wall of JSON. A node graph that shows what connects to what and in what order.
+The review step happens at the `describeToMermaid(graph.describe())` level (any of the `describeTo*` pure renderers from `@graphrefly/ts/render` works the same way): before a graph runs, the engineer reviews a simplified flow view. Not code. Not a wall of JSON. A node graph that shows what connects to what and in what order.
 
 ```
 A ──► B ──► D ──► output
@@ -79,7 +79,7 @@ The v0.4 work hardened the three layers that AI-First architectures depend on:
 
 **Correctness foundation (P2/P3):** When AI generates the topology and that topology runs in production, the correctness invariants need to be unconditional. An AI-generated graph shouldn't fail because of a wave-timing race or a stale cache read. The foundation redesign makes correctness structural, not dependent on knowing which composition patterns to avoid.
 
-**Observable state (unified `describe`):** AI-generated systems are harder to debug when you can't see their runtime state. The unified `describe()` snapshot — paired with the `graphSpecTo*` pure renderers in `@graphrefly/graphrefly/extra/render` — plus `trace()` and `resourceProfile()` give AI models the same structured access to runtime state that human engineers have. When an AI agent debugging a running harness can call `graph.describe()` and get the same structured output a human engineer would use, the debugging process becomes collaborative — not "the engineer debugs what the AI produced" but "both use the same tools."
+**Observable state (unified `describe`):** AI-generated systems are harder to debug when you can't see their runtime state. The unified `describe()` snapshot — paired with the `describeTo*` pure renderers in `@graphrefly/ts/render` — plus `trace()` and `resourceProfile()` give AI models the same structured access to runtime state that human engineers have. When an AI agent debugging a running harness can call `graph.describe()` and get the same structured output a human engineer would use, the debugging process becomes collaborative — not "the engineer debugs what the AI produced" but "both use the same tools."
 
 **Durable execution (`attachStorage`):** AI-First workflows run for hours or days. They need to survive restarts, handle partial failures, and resume from checkpoints without losing state. `attachStorage` with cascading tiers and V0 version-counter shortcuts makes this operational without requiring custom storage infrastructure per deployment.
 
diff --git a/website/src/content/docs/comparisons/airflow.md b/website/src/content/docs/comparisons/airflow.md
index ef42166c..2b04e474 100644
--- a/website/src/content/docs/comparisons/airflow.md
+++ b/website/src/content/docs/comparisons/airflow.md
@@ -1,10 +1,14 @@
 ---
 title: "GraphReFly vs Apache Airflow"
 description: "Both orchestrate data pipelines with DAG semantics — GraphReFly is lightweight, reactive, runs anywhere, and requires no infrastructure."
+draft: true
+pagefind: false
 ---
 
 Both orchestrate data pipelines with DAG semantics. GraphReFly is lightweight, reactive, runs anywhere, and requires no infrastructure.
 
+> Historical note (CSP-9): this comparison describes the pre-clean-slate/root-package era and is no longer active import or API guidance. Current TypeScript guidance uses `@graphrefly/ts` and focused subpaths; do not copy `@graphrefly/graphrefly` imports from this historical page.
+
 ## At a Glance
 
 | Feature | Airflow | GraphReFly |
@@ -24,7 +28,7 @@ Both orchestrate data pipelines with DAG semantics. GraphReFly is lightweight, r
 
 ## The Key Difference
 
-Airflow is a platform — you deploy it, manage it, and build on it. GraphReFly is a library — `npm i @graphrefly/graphrefly` and compose pipelines in your existing TypeScript codebase.
+Airflow is a platform — you deploy it, manage it, and build on it. GraphReFly is a library — `npm i @graphrefly/ts` and compose pipelines in your existing TypeScript codebase.
 
 ```python
 # Airflow (Python)
diff --git a/website/src/content/docs/comparisons/jotai.md b/website/src/content/docs/comparisons/jotai.md
index 32debccb..f4801ba8 100644
--- a/website/src/content/docs/comparisons/jotai.md
+++ b/website/src/content/docs/comparisons/jotai.md
@@ -1,10 +1,14 @@
 ---
 title: "GraphReFly vs Jotai"
 description: "Comparing GraphReFly and Jotai for atomic state — diamond resolution, framework independence, and streaming operators."
+draft: true
+pagefind: false
 ---
 
 Both GraphReFly and Jotai use atomic state with derived computations. GraphReFly adds glitch-free diamond resolution, streaming operators, and works without React.
 
+> Historical note (CSP-9): this comparison describes the pre-clean-slate/root-package era and is no longer active import or API guidance. Current TypeScript guidance uses `@graphrefly/ts` and focused subpaths; do not copy `@graphrefly/graphrefly` or `compat/*` imports from this historical page.
+
 ## At a Glance
 
 | Feature | Jotai | GraphReFly |
@@ -63,18 +67,17 @@ d.get(); // "4-6" — always consistent, never "4-3"
 
 ## Migration Path
 
-### Drop-in Compat Layer
+### Clean-Slate Facade
 
-For incremental migration, use the Jotai-compatible adapter:
+For incremental migration, bind caller-owned GraphReFly nodes through the Jotai-style facade:
 
 ```ts
-import { atom } from '@graphrefly/graphrefly/compat/jotai';
+import { jotaiAtom } from '@graphrefly/ts/adapters';
 
-const countAtom = atom(0);
-const doubledAtom = atom((get) => get(countAtom) * 2);
+const countAtom = jotaiAtom(countNode);
 ```
 
-This preserves Jotai's `atom((get) => ...)` API while adding diamond resolution under the hood.
+The old `@graphrefly/graphrefly/compat/jotai` path is retired.
 
 ### Native API
 
diff --git a/website/src/content/docs/comparisons/langgraph.md b/website/src/content/docs/comparisons/langgraph.md
index 93cb0c67..c3ddd457 100644
--- a/website/src/content/docs/comparisons/langgraph.md
+++ b/website/src/content/docs/comparisons/langgraph.md
@@ -1,10 +1,14 @@
 ---
 title: "GraphReFly vs LangGraph.js"
 description: "Comparing GraphReFly and LangGraph.js for AI agent orchestration — reactive nodes vs state dictionaries, built-in observability, and streaming."
+draft: true
+pagefind: false
 ---
 
 Both GraphReFly and LangGraph.js orchestrate AI agent workflows with graph semantics. GraphReFly uses reactive nodes with automatic dependency resolution; LangGraph uses state dictionaries and channel-based message passing with explicit edge definitions.
 
+> Historical note (CSP-9): this comparison describes the pre-clean-slate/root-package era and is no longer active import or API guidance. Current TypeScript guidance uses `@graphrefly/ts` and focused subpaths; do not copy `@graphrefly/graphrefly` or `/extra` imports from this historical page.
+
 ## At a Glance
 
 | Feature | LangGraph.js | GraphReFly |
diff --git a/website/src/content/docs/comparisons/n8n.md b/website/src/content/docs/comparisons/n8n.md
index 781136dd..cf8ca1b3 100644
--- a/website/src/content/docs/comparisons/n8n.md
+++ b/website/src/content/docs/comparisons/n8n.md
@@ -1,10 +1,14 @@
 ---
 title: "GraphReFly vs n8n"
 description: "Both wire together multi-step workflows — n8n is a visual automation platform; GraphReFly is a code-first reactive library."
+draft: true
+pagefind: false
 ---
 
 Both wire together multi-step workflows. n8n is a visual automation platform; GraphReFly is a code-first reactive library.
 
+> Historical note (CSP-9): this comparison describes the pre-clean-slate/root-package era and is no longer active import or API guidance. Current TypeScript guidance uses `@graphrefly/ts` and focused subpaths; do not copy `@graphrefly/graphrefly` imports from this historical page.
+
 ## At a Glance
 
 | Feature | n8n | GraphReFly |
diff --git a/website/src/content/docs/comparisons/pretext.md b/website/src/content/docs/comparisons/pretext.md
index 78840023..157309af 100644
--- a/website/src/content/docs/comparisons/pretext.md
+++ b/website/src/content/docs/comparisons/pretext.md
@@ -15,7 +15,7 @@ This page is the **consideration-stage** comparison. For setup, APIs, and compos
 | **Bundle** | ~15 KB min+gz, zero-dep | GraphReFly core + `reactive-layout` (tree-shakeable) |
 | **Reactivity** | Bring your own (store, observers, manual) | Native — only dependent nodes recompute |
 | **Beyond single-column text** | You compose by hand | `reactiveBlockLayout`, `reactiveFlowLayout`, exported slot primitives |
-| **Headless / SSR** | DOM-oriented measurement path | `CliMeasureAdapter`, `PrecomputedAdapter`, etc. |
+| **Headless / SSR** | DOM-oriented measurement path | `cellTextMeasurements`, `precomputedTextMeasurements`, etc. |
 | **Observability** | None built-in | `graph.describe()` → mermaid; meta companions; snapshots |
 | **Full i18n (bidi, tab stops, emoji width)** | Strong | **Subset** — see below |
 
@@ -27,11 +27,11 @@ Pretext is a **focused library**: measure and break lines with minimal surface a
 
 | Problem | Pretext | Reactive Layout |
 |---|---|---|
-| Measure text width without DOM reflow | `prepare(text, font)` + `layout(prepared, maxWidth, lineHeight)` | `reactiveLayout({ adapter, text, font, lineHeight, maxWidth })` — canvas-based measurement in a reactive graph |
+| Measure text width without DOM reflow | `prepare(text, font)` + `layout(prepared, maxWidth, lineHeight)` | `text/font -> measurements -> reactiveLayout({ measurements })` — measurement facts in a reactive graph |
 | Cursor-based single-line layout (multi-slot, multi-column) | `layoutNextLine(prepared, cursor, width)` | `layoutNextLine(segments, cursor, slotWidth)` — same shape, same cursor semantics |
 | Carve blocked intervals from a column | Hand-rolled per call site | `carveTextLineSlots(base, blocked, minSlotWidth)` — exported primitive |
-| Stacked heterogeneous blocks (text + image + SVG) | Not in core | `reactiveBlockLayout({ adapters, blocks, maxWidth, gap })` |
-| Multi-column flow around shape obstacles | Hand-rolled over `layoutNextLine` | `reactiveFlowLayout({ text, container, columns, obstacles })` + `Obstacle = Circle \| Rect` + built-in slot carving |
+| Stacked heterogeneous blocks (text + image + SVG) | Not in core | `blockMeasurementProvider(...) -> reactiveBlockLayout({ measurements })` |
+| Multi-column flow around shape obstacles | Hand-rolled over `layoutNextLine` | `textMeasurements -> reactiveFlowLayout({ measurements, container, columns, obstacles })` + `Obstacle = Circle \| Rect` + built-in slot carving |
 | Observability | None | `graph.describe()` → mermaid; `.meta` companions; snapshot serialization |
 | Composable with other reactive work | Bring your own | Native — same protocol as harness, orchestration, messaging, resilience |
 
@@ -43,7 +43,7 @@ Pretext is a **focused library**: measure and break lines with minimal surface a
 
 - **You want inspectability.** Meta companions (`cache-hit-rate`, `layout-time-ns`, `line-count`, …) and one-call graph snapshots for tests and debugging.
 
-- **You're already composing GraphReFly.** Streaming harness output into `setText`, resilience around sources, virtualization with exact heights — layout stays on the same protocol.
+- **You're already composing GraphReFly.** Streaming harness output into the upstream text node, resilience around sources, virtualization with exact heights — layout stays on the same protocol.
 
 ## When to Choose Pretext
 
@@ -80,7 +80,7 @@ Roughly **15 lines** subscribe to `lineBreaks` and drive inputs on `reactiveLayo
 ## See Also
 
 - **[Reactive Layout solution guide](/solutions/reactive-layout/)** — quick start, advanced notes, composition recipes, demo links
-- **[Live demo →](/demos/reactive-layout/)** — playground, adapters, blocks, flow, batching
+- **[Reactive layout solution →](/solutions/reactive-layout/)** — playground, adapters, blocks, flow, batching
 - **[API: `reactiveLayout()`](/api/reactivelayout)** · **[API: `reactiveBlockLayout()`](/api/reactiveblocklayout)** · **[API: `analyzeAndMeasure()`](/api/analyzeandmeasure)** · **[API: `computeLineBreaks()`](/api/computelinebreaks)**
 
 ---
diff --git a/website/src/content/docs/comparisons/rxjs.md b/website/src/content/docs/comparisons/rxjs.md
index dfbab4d4..ff17969b 100644
--- a/website/src/content/docs/comparisons/rxjs.md
+++ b/website/src/content/docs/comparisons/rxjs.md
@@ -1,10 +1,14 @@
 ---
 title: "GraphReFly vs RxJS"
 description: "Comparing GraphReFly and RxJS — first-class state, diamond resolution, and streaming operators in a unified model."
+draft: true
+pagefind: false
 ---
 
 Both GraphReFly and RxJS provide streaming operators for composing asynchronous data flows. GraphReFly adds first-class state (`.get()`/`.set()`), diamond-safe derived computations, and a simpler API surface.
 
+> Historical note (CSP-9): this comparison describes the pre-clean-slate/root-package era and is no longer active import or API guidance. Current TypeScript guidance uses `@graphrefly/ts` and focused subpaths; do not copy `@graphrefly/graphrefly` or `/extra` imports from this historical page.
+
 ## At a Glance
 
 | Feature | RxJS | GraphReFly |
diff --git a/website/src/content/docs/comparisons/vercel-ai-sdk.md b/website/src/content/docs/comparisons/vercel-ai-sdk.md
index a5660da0..f82f64c8 100644
--- a/website/src/content/docs/comparisons/vercel-ai-sdk.md
+++ b/website/src/content/docs/comparisons/vercel-ai-sdk.md
@@ -1,10 +1,14 @@
 ---
 title: "GraphReFly vs Vercel AI SDK"
 description: "Both handle LLM streaming — Vercel AI SDK provides React hooks for chat UIs; GraphReFly provides a full reactive graph for streaming state, orchestration, and multi-model coordination."
+draft: true
+pagefind: false
 ---
 
 Both handle LLM streaming. Vercel AI SDK provides React hooks for chat UIs; GraphReFly provides a full reactive graph for streaming state, orchestration, and multi-model coordination.
 
+> Historical note (CSP-9): this comparison describes the pre-clean-slate/root-package era and is no longer active import or API guidance. Current TypeScript guidance uses `@graphrefly/ts` and focused subpaths; do not copy `@graphrefly/graphrefly` imports or old AI utility paths from this historical page.
+
 ## At a Glance
 
 | Feature | Vercel AI SDK | GraphReFly |
diff --git a/website/src/content/docs/comparisons/zustand.md b/website/src/content/docs/comparisons/zustand.md
index 69785296..4265913c 100644
--- a/website/src/content/docs/comparisons/zustand.md
+++ b/website/src/content/docs/comparisons/zustand.md
@@ -1,10 +1,14 @@
 ---
 title: "GraphReFly vs Zustand"
 description: "Comparing GraphReFly and Zustand for state management — ergonomics, computed values, diamond resolution, and migration paths."
+draft: true
+pagefind: false
 ---
 
 Both GraphReFly and Zustand are simple, ergonomic state management libraries that prize small APIs and minimal boilerplate. GraphReFly adds diamond-safe computed values, streaming operators, and runtime graph inspectability while preserving a familiar API shape.
 
+> Historical note (CSP-9): this comparison describes the pre-clean-slate/root-package era and is no longer active import or API guidance. Current TypeScript guidance uses `@graphrefly/ts` and focused subpaths; do not copy `@graphrefly/graphrefly` or `compat/*` imports from this historical page.
+
 ## At a Glance
 
 | Feature | Zustand | GraphReFly |
@@ -59,19 +63,18 @@ count.set(1);
 doubled.get();  // 2 — automatically recomputed
 ```
 
-### Option 2: Drop-in Compat Layer
+### Option 2: Clean-Slate Facade
 
-For incremental migration, use the Zustand-compatible adapter:
+For incremental migration, bind a caller-owned state node through the Zustand-style facade:
 
 ```ts
-import { create } from '@graphrefly/graphrefly/compat/zustand';
+import { zustandStore } from '@graphrefly/ts/adapters';
 
-const useStore = create((set, get) => ({
-  count: 0,
-  increment: () => set((s) => ({ count: s.count + 1 })),
-}));
+const store = zustandStore(countNode);
 ```
 
+The old `@graphrefly/graphrefly/compat/zustand` path is retired.
+
 This gives you the same `create((set, get) => ...)` API while allowing you to incrementally adopt `derived()` and streaming operators on top.
 
 ## What Zustand Lacks
diff --git a/website/src/content/docs/demos/index.md b/website/src/content/docs/demos/index.md
index 95411f54..2ba9db04 100644
--- a/website/src/content/docs/demos/index.md
+++ b/website/src/content/docs/demos/index.md
@@ -1,43 +1,41 @@
 ---
 title: "Demos"
-description: "Interactive demos showing GraphReFly compat layers across frameworks and state libraries."
+description: "Interactive demos showing clean-slate GraphReFly compositions."
 ---
 
-Live demos that show GraphReFly working alongside popular state libraries inside every major UI framework.
-
-## Compat matrix
-
-**4 state libraries × 4 frameworks** — all on one page per framework.
-
-| Framework | State libraries shown |
-|-----------|----------------------|
-| React | GraphReFly, Jotai, Nanostores, Zustand |
-| Vue | GraphReFly, Jotai, Nanostores, Zustand |
-| SolidJS | GraphReFly, Jotai, Nanostores, Zustand |
-| Svelte | GraphReFly, Jotai, Nanostores, Zustand |
-
-Each page exercises all three framework binding APIs: `useStore`, `useSubscribe`, and `useSubscribeRecord`.
-
-[Run the compat matrix demo →](/demos/compat-matrix/)
+Live demos and runnable walkthroughs that show GraphReFly clean-slate graph
+composition, inspection, and host boundaries.
 
 ## Reactive layout
 
-Text measurement and line-breaking as a reactive graph — five chapters walk through incremental recomputation, `batch()` coalescing, pluggable measurement backends, and mixed-content block flow. The demo is hosted inside the same `demo-shell` used by compat matrix, so the topology mermaid and the source code driving each chapter are always visible to the right of the main canvas.
+Text measurement and line-breaking as a reactive graph — five chapters walk through incremental recomputation, `batch()` coalescing, pluggable measurement backends, and mixed-content block flow. The demo uses the shared clean-slate demo shell, so the topology mermaid and the source code driving each chapter are always visible to the right of the main canvas.
 
-[Run the reactive layout demo →](/demos/reactive-layout/)
+[Read the reactive layout solution →](/solutions/reactive-layout/)
 
-## Knowledge graph extraction
+## Spending alerts
 
-Live KG extraction from a long paper using Chrome's built-in Gemini Nano — runs on-device, zero API key, zero cost. Four chapters take you from `knowledgeGraph()` as a fancy Map to a reactive `paper → promptNode → kg → adjacency` pipeline with `graph.describe({ explain: {...}, reactive: true })` causal tracing and `policyEnforcer` guardrails. The KG renders as a force-directed SVG distinct from the topology mermaid in the side pane.
+Node-runnable causal tracing walkthrough for a deterministic spending-alert
+pipeline. It uses current `@graphrefly/ts` graph APIs and keeps the source at
+`examples/spending-alerts/`, so it is buildable as part of the clean-slate
+examples set.
 
-[Run the knowledge-graph demo →](/demos/knowledge-graph/)
+[Read the spending-alerts walkthrough →](/demos/spending-alerts/)
 
-## PagerDuty triage
+## Historical browser demo notes
 
-Two-mode alert triage — Baseline (manual every time) vs GraphReFly (`agentMemory` learns your decisions and auto-classifies). A 3-minute stream of synthetic PagerDuty alerts flows through a `promptNode` classifier; in GraphReFly mode each user decision trains a pattern that is matched programmatically on future alerts (zero token cost). Runs with Chrome Nano, BYOK, or a deterministic dry-run adapter. The token counter is honest — local cache hits are separated from real LLM calls.
+`demos/knowledge-graph/` and `demos/pagerduty-triage/` were retired from the
+active tree during CSP-9/B66 closeout. The notes remain as historical
+pre-CSP-9 context because those browser demos depended on retired root/pure-ts
+surfaces such as old AI utilities and `utils/demo-shell`. Re-activating either
+concept needs a separate migration/design slice over current `@graphrefly/ts`
+public subpaths, not compatibility shims.
 
-[Run the PagerDuty triage demo →](/demos/pagerduty-triage/)
+[Historical knowledge-graph notes →](/demos/knowledge-graph/) ·
+[Historical PagerDuty notes →](/demos/pagerduty-triage/)
 
 ## Source
 
-Demo source lives at `demos/compat-matrix/`, `demos/reactive-layout/`, `demos/knowledge-graph/`, and `demos/pagerduty-triage/` in the repo.
+Active demo/walkthrough source lives at `demos/reactive-layout/` and
+`examples/spending-alerts/` in the repo. The compat matrix remains a
+package-surface showcase, while the knowledge-graph and PagerDuty browser demo
+concepts are historical references until redesigned over clean-slate surfaces.
diff --git a/website/src/content/docs/demos/knowledge-graph.md b/website/src/content/docs/demos/knowledge-graph.md
index 50030294..5a7b25c6 100644
--- a/website/src/content/docs/demos/knowledge-graph.md
+++ b/website/src/content/docs/demos/knowledge-graph.md
@@ -1,17 +1,32 @@
 ---
-title: "Knowledge graph extraction"
-description: "Live KG extraction from a long paper using Chrome's built-in Gemini Nano — zero API key, on-device. Four chapters: baseline → reactive → inspect → guard."
+title: "Historical knowledge graph extraction demo"
+description: "Historical pre-CSP-9 browser demo notes. The active clean-slate successor is examples/knowledge-graph."
 ---
 
-The knowledge-graph demo extracts entities and relations from a long paper one paragraph at a time. The extractor is **Chrome's built-in Gemini Nano** (`window.LanguageModel`) — runs on-device, no API key, no cost. When the Prompt API isn't available the demo falls back to a deterministic mock extractor so the page works on every browser.
+These notes describe the historical pre-CSP-9 browser demo for knowledge-graph
+extraction. Its source was retired from the active tree during CSP-9/B66
+closeout because it depended on retired root/pure-ts demo surfaces such as old
+AI utilities, policy helpers, and `utils/demo-shell`, so it is not an active
+clean-slate demo.
 
-[Run the knowledge-graph demo →](/demos/knowledge-graph/)
+Use [`examples/knowledge-graph/`](https://github.com/graphrefly/graphrefly-ts/tree/main/examples/knowledge-graph)
+for the active clean-slate version. That example is Node-runnable, deterministic,
+and built on current `@graphrefly/ts` public subpaths.
 
-The page uses the same three-pane `demoShell` as [reactive layout](/demos/reactive-layout/): main pane (paper text + force-directed KG), side-top (`describe(graph)` mermaid topology), side-bottom (the chapter's source code with cross-highlighting).
+The historical page extracted entities and relations from a long paper one
+paragraph at a time. The extractor was **Chrome's built-in Gemini Nano**
+(`window.LanguageModel`) with a deterministic mock fallback.
 
-## What the four chapters teach
+The page used the old three-pane `demoShell` pattern: main pane (paper text +
+force-directed KG), side-top topology, side-bottom chapter source with
+cross-highlighting. That shell is not a current package surface.
 
-**1. Baseline — "this is just a fancy Map so far."** Hand-seeded entities and links, calls to `upsertEntity` / `link` / `related`. Exists to dispel the "knowledgeGraph() is Obsidian" misconception up front: the user-facing types are whatever you set as `TEntity` and `TRelation`; `entities` / `edges` / `adjacency` are internal node names.
+## What the four chapters taught
+
+**1. Baseline — "this is just a fancy Map so far."** Hand-seeded entities and
+links, using the old `upsertEntity` / `link` / `related` browser-demo helpers.
+This existed to dispel the "knowledgeGraph() is Obsidian" misconception up
+front; those helpers are historical, not current public package guidance.
 
 **2. Reactive turn — the moment Graph beats Map.** A real pipeline:
 
@@ -25,24 +40,35 @@ paper-text → paragraphs → current-paragraph → promptNode (Gemini Nano)
                                            force-directed SVG (subscribes)
 ```
 
-`promptNode` is the universal LLM transform — it re-fires whenever any dep changes. The structured JSON output is shaped by a `responseConstraint` JSON schema. `apply-extraction` is the only imperative line in the whole pipeline; everything downstream is reactive. Click **Extract next paragraph** and watch entities accumulate in the canvas.
+In the old demo, `promptNode` acted as the LLM transform and re-fired whenever
+any dep changed. The structured JSON output was shaped by a
+`responseConstraint` JSON schema. Treat that as provenance for the retired demo,
+not as current `@graphrefly/ts` AI adapter guidance.
 
 The textbox at the top accepts any URL. The page fetches it via [`r.jina.ai`](https://jina.ai/reader) (anonymous, 20 RPM) — paywalled or aggressively-throttled sources may fail; the bundled sample (Mohit Sewak's "What is AI Harness Engineering?") always works.
 
-**3. Inspect & trace.** Same pipeline; adds `kg.describe({ explain: { from: "paper-text", to: "adjacency" }, reactive: true })` — a `Node<CausalChain>` that re-derives whenever any node along the path fires. Subscribe; render the chain. This is the answer to "why did this entity end up here?" — the homepage pain point 02 closure.
+**3. Inspect & trace.** Same historical pipeline; added
+`kg.describe({ explain: { from: "paper-text", to: "adjacency" }, reactive: true })`
+to render a causal chain for "why did this entity end up here?"
 
-**4. Guardrails.** Same pipeline; wraps the KG in `policyEnforcer([…], { mode: "enforce" })`. The legitimate extraction effect (`system` actor) writes freely. Click **Try malicious write** to attempt a write as `untrusted-llm`: the guard throws `GuardDenied` and a violation is recorded — the closure for homepage pain point 03.
+**4. Guardrails.** Same historical pipeline; wrapped the KG in the old
+`policyEnforcer` demo helper. That helper is also retired with the browser demo.
 
 ## Why a force-directed SVG (not mermaid)
 
 The right-side mermaid pane already shows the **graph topology** — `paper-text → … → adjacency` and friends. The KG itself (entities and their relations) is a *different* graph — domain data, not pipeline structure. A force-directed layout makes that distinction visually obvious. Drag a node to pin it; double-click empty space to reset zoom. The simulation is hand-rolled (~200 LOC) — no d3 dependency.
 
-## Why a real LLM in a demo
+## Why the historical demo used a real LLM
 
 The session note in `archive/docs/SESSION-strategy-roadmap-demo-reprioritization.md` says "do not use a real LLM API call in the example." That rule still holds for [`examples/knowledge-graph/`](https://github.com/graphrefly/graphrefly-ts/blob/main/examples/knowledge-graph/index.ts), the Node-runnable companion that uses pre-parsed documents and runs in CI with no key.
 
-For the **browser demo**, Chrome Nano changes the calculus: it's on-device, free, and visually intuitive. The same `LLMAdapter` interface accepts both the Chrome adapter and the mock — only the extraction quality differs.
+For that **historical browser demo**, Chrome Nano changed the calculus because it
+was on-device, free, and visually intuitive. Re-activating the idea now should
+use current `@graphrefly/ts` public subpaths rather than the old `LLMAdapter`
+surface.
 
 ## Source
 
-Demo source lives at [`demos/knowledge-graph/`](https://github.com/graphrefly/graphrefly-ts/tree/main/demos/knowledge-graph) in the repo. The Node-runnable mirror is at [`examples/knowledge-graph/`](https://github.com/graphrefly/graphrefly-ts/tree/main/examples/knowledge-graph).
+The historical browser source was removed from the active workspace rather than
+migrated through compatibility shims. The Node-runnable clean-slate successor is
+[`examples/knowledge-graph/`](https://github.com/graphrefly/graphrefly-ts/tree/main/examples/knowledge-graph).
diff --git a/website/src/content/docs/demos/pagerduty-triage.md b/website/src/content/docs/demos/pagerduty-triage.md
index e93a5ea0..993b71e0 100644
--- a/website/src/content/docs/demos/pagerduty-triage.md
+++ b/website/src/content/docs/demos/pagerduty-triage.md
@@ -1,17 +1,29 @@
 ---
-title: "PagerDuty triage"
-description: "Two-mode alert triage — Baseline vs GraphReFly agentMemory. A 3-minute stream of synthetic PD alerts; the GraphReFly pipeline learns your decisions and auto-classifies future matches at zero token cost."
+title: "Historical PagerDuty triage demo"
+description: "Historical pre-CSP-9 browser demo notes retained for reference."
 ---
 
-The PagerDuty triage demo streams 60 synthetic alerts through a reactive classify-and-route pipeline. Run it twice — once in **Baseline** mode, once in **GraphReFly** mode — and watch the auto-classify counter climb as `agentMemory` recognises your decision patterns.
+These notes describe the historical pre-CSP-9 PagerDuty triage browser demo. Its
+source was retired from the active tree during CSP-9/B66 closeout because it
+depended on retired root/pure-ts demo surfaces such as old AI utilities,
+`agentMemory`, and `utils/demo-shell`, so it is not an active clean-slate demo or
+workspace package.
 
-[Run the PagerDuty triage demo →](/demos/pagerduty-triage/)
+The historical demo streamed 60 synthetic alerts through a reactive
+classify-and-route pipeline. Run twice, once in **Baseline** mode and once in
+**GraphReFly** mode, it showed the auto-classify counter climb as old
+`agentMemory` recognised decision patterns.
 
-## Two pipeline modes
+## Historical pipeline modes
 
-**Baseline** — every alert goes through the LLM classifier, is either auto-routed at ≥80% confidence or queued for you. No learning happens between sessions.
+**Baseline** — every alert went through the LLM classifier, was either
+auto-routed at >=80% confidence or queued for the user, and learned nothing
+between sessions.
 
-**GraphReFly** — same classifier, plus `agentMemory` watching your decisions. After 2 consistent decisions for the same (service, error-category) pair, a `LearnedPattern` is written to `patternsState`. From that point on, matching alerts are routed programmatically — no LLM call, no user prompt, instant. Token counter stays honest: local cache hits are counted separately from real calls.
+**GraphReFly** — same old classifier, plus the retired `agentMemory` helper
+watching decisions. After 2 consistent decisions for the same
+(service, error-category) pair, the demo wrote a `LearnedPattern` to
+`patternsState`; matching alerts were then routed programmatically.
 
 ## Graph topology
 
@@ -30,20 +42,26 @@ decisionLog ──► agentMemory.compact ──► patternsState
                               (snapshot read in classifyNode callback)
 ```
 
-`classifyNode` depends only on `currentAlert`. `patternsState` is read as a cold snapshot inside the callback so pattern updates never re-trigger the LLM on the current alert — the feedback cycle is structurally impossible.
+In the historical design, `classifyNode` depended only on `currentAlert`.
+`patternsState` was read as a cold snapshot inside the callback so pattern
+updates never re-triggered the LLM on the current alert.
 
-`routeEffect` depends only on `classifyNode` and uses a `pendingAlerts` map keyed by `alertId` (echoed by the LLM in its JSON response) to guard against stale in-flight results when alerts arrive faster than the classifier responds.
+`routeEffect` depended only on `classifyNode` and used a `pendingAlerts` map
+keyed by `alertId` to guard against stale in-flight results when alerts arrived
+faster than the classifier responded.
 
-Deferred alerts use `fromTimer` source nodes rather than raw `setTimeout`, keeping all scheduling inside the reactive graph.
+Deferred alerts used old source helpers rather than raw `setTimeout`; this is
+historical provenance, not current source guidance.
 
 ## Option 5 pattern matching
 
 Classification is two-tier:
 
-1. **LLM** — `promptNode` classifies the alert and returns `{alertId, disposition, confidence, brief}`.
-2. **Programmatic** — if `agentMemory` has a matching `LearnedPattern` with confidence ≥70%, `routeEffect` routes without ever invoking the LLM. Matching uses service equality, severity range intersection, and a ≥70% keyword overlap on the error category extracted from the summary.
+1. **LLM** — the old `promptNode` demo utility classified the alert and returned `{alertId, disposition, confidence, brief}`.
+2. **Programmatic** — if the retired `agentMemory` helper had a matching `LearnedPattern` with confidence >=70%, `routeEffect` routed without invoking the LLM.
 
-The LLM decides what attributes matter (it picks the disposition); the matching is deterministic structural comparison. Zero tokens for auto-classifies.
+The matching idea may still be useful later, but a current implementation should
+be designed over `@graphrefly/ts` orchestration/pattern subpaths.
 
 ## Token accounting
 
@@ -63,4 +81,7 @@ The token bar at the bottom of the main pane shows cumulative `inputTokens`, `ou
 
 ## Source
 
-Demo source lives at [`demos/pagerduty-triage/`](https://github.com/graphrefly/graphrefly-ts/tree/main/demos/pagerduty-triage) in the repo.
+The historical browser source was removed from the active workspace rather than
+migrated through compatibility shims. Re-activating this concept should be a new
+slice over current `@graphrefly/ts` orchestration/pattern public subpaths, not a
+compatibility shim.
diff --git a/website/src/content/docs/demos/spending-alerts.md b/website/src/content/docs/demos/spending-alerts.md
index 8e6712a4..02ccaf80 100644
--- a/website/src/content/docs/demos/spending-alerts.md
+++ b/website/src/content/docs/demos/spending-alerts.md
@@ -94,33 +94,18 @@ console.log(chain.text);
 
 That's the full teaching. No special "explainability mode", no after-the-fact log mining — the instrumentation is _that_ there is a graph.
 
-## Try it from your terminal — or your agent
+## Try it from your agent
 
-Zero-install via the CLI (ships in [@graphrefly/cli](https://github.com/graphrefly/graphrefly-ts/tree/main/packages/cli)):
+The old zero-install `@graphrefly/cli` GraphSpec shell was retired during CSP-9/B66 cleanup.
+Use the `@graphrefly/ts` graph APIs directly while the clean-slate package surface settles.
 
-```bash
-npx @graphrefly/cli explain spending-alerts.json \
-  --from txFeed --to alertMessage
-```
-
-## Extending to an agent (and why it still works)
-
-The demo's `alertMessage` uses a deterministic template. Swap it for a `promptNode` wrapping Chrome Nano (or any [adapter](https://github.com/graphrefly/graphrefly-ts/tree/main/src/patterns/ai/adapters) — Anthropic, OpenAI-compat, Google) and `graph.describe({ explain })` works identically:
-
-```ts
-const alertMessage = patterns.ai.promptNode({
-  deps: { reason: reasonFactors },
-  adapter: resilientAdapter(createAdapter({ provider: "chrome-nano" }), {
-    retry: { attempts: 2 }, fallback: mockAdapter,
-  }),
-  prompt: ({ reason }) => `Explain in one sentence why this was flagged: ${JSON.stringify(reason)}`,
-});
-```
-
-The LLM step now lives inside the graph. Its output shows up in the causal chain like any other node — same `chain.text`, same reasoning, now with the agent's language attached. **The agent's decision is traceable the same way the deterministic pipeline's was.** That's the general shape; the demo proves it out in the simplest possible setting.
+## Extending to an agent
 
-> **Teardown note when going async.** The Node example calls `graph.destroy()` synchronously after the feed loop because every node is synchronous, so subscribers (including the `graph.describe({ explain })` call) all fire inside `feed()`. If you swap `alertMessage` for a `promptNode`, the subscribe callback becomes async — drain it with `firstValueFrom(alertMessage)` or an explicit settle before `destroy()`, otherwise `graph.describe({ explain })` may run against a torn-down graph.
+The demo's `alertMessage` uses a deterministic template on purpose. A future
+agent-backed version should be designed against current `@graphrefly/ts`
+orchestration/pattern public subpaths and explicit async boundary rules. The old
+pre-CSP-9 `promptNode` / AI adapter examples are not current package guidance.
 
 ## Source
 
-Runnable Node-only pipeline: [`examples/spending-alerts/`](https://github.com/graphrefly/graphrefly-ts/tree/main/examples/spending-alerts). Related: homepage pain point 02, [`explainPath`](https://github.com/graphrefly/graphrefly-ts/blob/main/src/graph/explain.ts), [§9.3e in the roadmap](/roadmap/). An interactive 3-pane browser version with Chrome Nano as the `alertMessage` justifier is planned as a Wave 2 follow-up — this page stays the canonical walkthrough.
+Runnable Node-only pipeline: [`examples/spending-alerts/`](https://github.com/graphrefly/graphrefly-ts/tree/main/examples/spending-alerts). Related: homepage pain point 02, [`explainPath`](https://github.com/graphrefly/graphrefly-ts/blob/main/src/graph/explain.ts), [§9.3e in the roadmap](/roadmap/). This page stays the canonical clean-slate walkthrough until an agent-backed browser version is designed separately.
diff --git a/website/src/content/docs/integrations/compat.md b/website/src/content/docs/integrations/compat.md
index aa9cb056..78aa8a11 100644
--- a/website/src/content/docs/integrations/compat.md
+++ b/website/src/content/docs/integrations/compat.md
@@ -1,25 +1,22 @@
 ---
-title: "Compat"
-description: "Framework compatibility layers that embed GraphReFly into application runtimes."
+title: "Retired Compat"
+description: "Historical note for the retired pre-clean-slate compatibility layers."
 ---
 
-Compat packages make GraphReFly feel native inside framework ecosystems.
+The old `@graphrefly/graphrefly/compat/*` runtime model is retired. Clean-slate framework and host bindings now live under focused `@graphrefly/ts/adapters/*` subpaths.
 
-## Current compat layers
+## Current replacements
 
-- **NestJS**: Graph module wiring, CQRS helpers, guards, and stream bridges.
-- **Jotai**: Bind graph nodes into atom-driven React state.
-- **Nanostores**: Expose graph values through store-first reactive APIs.
-- **Zustand**: Bridge graph updates into lightweight store slices.
+- **NestJS structural metadata**: `@graphrefly/ts/adapters/nestjs` keyed ingress/egress boundary nodes plus decorators over existing graph nodes.
+- **NestJS HTTP/native providers**: `@graphrefly/ts/adapters/nestjs/native` explicit D494 provider bundles for interceptor, guard, filter, cron, and lifecycle phases.
+- **NestJS WebSocket/message providers**: `@graphrefly/ts/adapters/nestjs/websockets` and `@graphrefly/ts/adapters/nestjs/microservices` focused D495 provider bundles over the existing D488 bridges.
+- **React/Vue/Solid/Svelte**: focused framework adapter subpaths.
+- **Jotai/Nanostores/Zustand-style facades**: small store facades from `@graphrefly/ts/adapters`.
 
 See the full walkthrough in [NestJS Integration](/recipes/nestjs-integration/).
 
-## When to use compat
+## What stayed retired
 
-- You want framework-native dependency injection and lifecycle hooks.
-- You are integrating GraphReFly into an existing app architecture incrementally.
-- You want framework ergonomics without losing graph observability and checkpointing.
+Do not use `compat/nestjs`, `GraphReflyModule`, `GraphReflyGuard`, `Actor`, `CqrsGraph`, hidden event buses, root `@graphrefly/graphrefly` imports, container scanning, hidden graph creation, or transport retry/session/reconnect ownership for clean-slate work.
 
-## When to use raw API instead
-
-Use core/extra APIs directly when you are building standalone runtimes or libraries that should stay framework-agnostic.
+Adapter diagnostics are not a callback or logging API. Use host-side `diagnostics()` snapshots for local bridge state, or wire `fromNestDiagnostics(...)` explicitly when diagnostics should become sanitized graph DATA.
diff --git a/website/src/content/docs/integrations/index.md b/website/src/content/docs/integrations/index.md
index f10aa083..f9dc02a0 100644
--- a/website/src/content/docs/integrations/index.md
+++ b/website/src/content/docs/integrations/index.md
@@ -5,16 +5,16 @@ description: "Connect GraphReFly to frameworks and infrastructure systems."
 
 GraphReFly integrations are organized by role so teams can quickly choose the right entry point:
 
-- **Adapters**: Connect external systems (Kafka, OTel, Postgres, Webhooks, SSE, MCP, and more) to graph nodes.
-- **Compat**: Framework-facing compatibility layers (for example, NestJS, Jotai, Nanostores, and Zustand) that embed GraphReFly into app runtimes.
+- **Adapters**: Connect external systems and host runtimes to graph nodes through focused subpaths.
+- **Framework bindings**: React, Vue, Solid, Svelte, and NestJS live under focused adapter subpaths without reviving the retired `compat/*` runtime model.
 
 ## Start here
 
 - If you need to answer **"Can GraphReFly connect to X?"**, use the [Integration Matrix](/integrations/matrix/).
 - If you need **system connectors**, start with [Adapters](/integrations/adapters/).
-- If you need **framework integration**, start with [Compat](/integrations/compat/).
+- If you need **NestJS**, start with [NestJS Integration](/recipes/nestjs-integration/).
 
 ## Related docs
 
-- Recipe examples live under [Recipes](/recipes/from-callbag-recharge/), where integrations are used to solve end-to-end workflows.
-- API-level references live under the [API docs](/api/node/).
+- Recipe examples live under [NestJS Integration](/recipes/nestjs-integration/), where focused adapters are used in a host workflow.
+- API-level references live under the [API docs](/api/reactivelayout/).
diff --git a/website/src/content/docs/integrations/matrix.md b/website/src/content/docs/integrations/matrix.md
index c3406928..65051a4f 100644
--- a/website/src/content/docs/integrations/matrix.md
+++ b/website/src/content/docs/integrations/matrix.md
@@ -1,30 +1,79 @@
 ---
 title: "Integration Matrix"
-description: "Current integration surface across adapters and compat layers."
+description: "Current package, adapter, application, and framework surfaces across focused clean-slate subpaths."
 ---
 
 This matrix is the fast inventory view. Use it to find what exists today, where to look next, and which package or doc path to start from.
 
-## Adapters
+## Focused Package Surfaces
 
-| Integration | Type | Entry |
+| Surface | Type | Entry |
 |---|---|---|
-| OpenTelemetry | Adapter | `fromOTel` |
-| Kafka | Adapter | `fromKafka` |
-| Webhook | Adapter | `fromWebhook` |
-| SSE | Adapter | `toSSE` |
-| MCP | Adapter | `fromMCP` |
-| Postgres | Adapter | `toPostgres` |
+| Root convenience surface | Primary package entry | `@graphrefly/ts` |
+| Core graph layer | Graph API | `@graphrefly/ts/graph` |
+| Protocol/core primitives | Node, ctx, and message-level API | `@graphrefly/ts/core` |
+| Data contracts | Data-only result and issue types | `@graphrefly/ts/data` |
+| Operators | Tree-shakeable operator factories | `@graphrefly/ts/operators` |
+| Sources | Universal source factories | `@graphrefly/ts/sources` |
+| Browser sources | Browser-only source factories | `@graphrefly/ts/sources/browser` |
+| Node sources | Node-only source factories | `@graphrefly/ts/sources/node` |
+| Render | Pure describe snapshot renderers | `@graphrefly/ts/render` |
+| Composition | Topology composition helpers | `@graphrefly/ts/composition` |
+| Data structures | Reactive list/map/index/log helpers | `@graphrefly/ts/data-structures` |
+| Passive storage | Storage codecs, KV, append-log, WAL, and read-through helpers | `@graphrefly/ts/storage` |
+| Browser storage | IndexedDB-backed storage helpers | `@graphrefly/ts/storage/browser` |
+| Node storage | File and SQLite-backed storage helpers | `@graphrefly/ts/storage/node` |
+| Testing helpers | Package-level assertions for tests | `@graphrefly/ts/testing` |
 
 See [Adapters](/integrations/adapters/) for usage guidance and naming conventions.
 
-## Compat
+## Adapter and Application Surfaces
+
+| Surface | Type | Entry |
+|---|---|---|
+| Generic adapters | Store facades, environment projections, bridge helpers, and persistence adapters | `@graphrefly/ts/adapters` |
+| Observe storage adapter | Graph-observe egress into passive storage sinks/logs | `@graphrefly/ts/adapters/observe-storage` |
+| Messaging | Topic message helpers and bus projections | `@graphrefly/ts/messaging` |
+| CQRS | CQRS helpers | `@graphrefly/ts/cqrs` |
+| CQRS messaging recipe | Focused CQRS messaging recipe | `@graphrefly/ts/cqrs/messaging` |
+| CQRS work-queue recipe | Focused CQRS work-queue recipe | `@graphrefly/ts/cqrs/work-queue` |
+| Work queue | Work queue facts and projections | `@graphrefly/ts/work-queue` |
+| Orchestration | Process, retry, timeout, tool-provider, and scheduled-readiness projectors | `@graphrefly/ts/orchestration` |
+| Orchestration messaging recipe | Focused orchestration messaging recipe | `@graphrefly/ts/orchestration/messaging` |
+| Orchestration work-queue recipe | Focused orchestration work-queue recipe | `@graphrefly/ts/orchestration/work-queue` |
+| Executor work-queue recipe | Focused executor work-queue recipe | `@graphrefly/ts/executors/work-queue` |
+| Tool-provider execution recipe | Focused tool-provider execution recipe | `@graphrefly/ts/executors/tool-provider` |
+| Tool-provider runtime | Explicit low-level adapter runtime attach boundary; runtime handles stay private data | `@graphrefly/ts/executors/tool-provider-runtime` |
+| Tool-provider adapter pack | Local builtin, process, and HTTP adapter helpers | `@graphrefly/ts/executors/tool-provider-adapters` |
+| Boundary inspection | Boundary manifest inspection helpers | `@graphrefly/ts/inspection/boundary` |
+| Patterns | Reusable projection patterns | `@graphrefly/ts/patterns` |
+| Event-flow pattern | Focused event-flow pattern | `@graphrefly/ts/patterns/event-flow` |
+| Solutions | Vertical solution kits | `@graphrefly/ts/solutions` |
+| Reactive layout | DOM-free reactive layout solution core | `@graphrefly/ts/solutions/reactive-layout` |
+| Reactive layout browser | Browser measurement helpers | `@graphrefly/ts/solutions/reactive-layout/browser` |
+| Reactive layout node-canvas | Node canvas measurement helpers | `@graphrefly/ts/solutions/reactive-layout/node-canvas` |
+| Reactive layout React Native | React Native measurement helpers | `@graphrefly/ts/solutions/reactive-layout/react-native` |
+| Reactive layout Skia | Skia measurement helpers | `@graphrefly/ts/solutions/reactive-layout/skia` |
+| Work-item actions | Focused work-item action projectors | `@graphrefly/ts/solutions/work-item/actions` |
+| Work-item scheduling | Focused work-item scheduling projectors | `@graphrefly/ts/solutions/work-item/scheduling` |
+| Work-item work-queue recipe | Focused work-item work-queue recipe | `@graphrefly/ts/solutions/work-item/work-queue` |
+
+## Framework and Host Bindings
 
 | Integration | Type | Entry |
 |---|---|---|
-| NestJS | Compat | `@graphrefly/graphrefly/compat/nestjs` |
-| Jotai | Compat | `@graphrefly/graphrefly/compat/jotai` |
-| Nanostores | Compat | `@graphrefly/graphrefly/compat/nanostores` |
-| Zustand | Compat | `@graphrefly/graphrefly/compat/zustand` |
+| React | Framework adapter | `@graphrefly/ts/adapters/react` |
+| Vue | Framework adapter | `@graphrefly/ts/adapters/vue` |
+| Solid | Framework adapter | `@graphrefly/ts/adapters/solid` |
+| Svelte | Framework adapter | `@graphrefly/ts/adapters/svelte` |
+| NestJS structural metadata | D484 dependency-light boundary factories/decorators | `@graphrefly/ts/adapters/nestjs` |
+| NestJS native providers | D494 HTTP/guard/filter/cron/lifecycle provider bundles and explicit targets | `@graphrefly/ts/adapters/nestjs/native` |
+| NestJS WebSocket boundary | D488 focused optional-peer gateway bridge plus D495 provider bundle | `@graphrefly/ts/adapters/nestjs/websockets` |
+| NestJS microservice boundary | D488 focused optional-peer message-pattern bridge plus D495 provider bundle | `@graphrefly/ts/adapters/nestjs/microservices` |
+| Jotai-style facade | Framework-neutral store facade | `jotaiAtom` from `@graphrefly/ts/adapters` |
+| Nanostores-style facade | Framework-neutral store facade | `nanoAtom` from `@graphrefly/ts/adapters` |
+| Zustand-style facade | Framework-neutral store facade | `zustandStore` from `@graphrefly/ts/adapters` |
+
+Legacy `@graphrefly/graphrefly/compat/*` imports are retired.
 
-See [Compat](/integrations/compat/) for framework integration guidance.
+NestJS provider bundles are explicit arrays over existing options. They are not modules, do not scan the container, do not create graphs, and do not own retry, session, reconnect, or transport lifecycle policy. Graph-visible adapter diagnostics require an explicitly wired sanitized diagnostics ingress boundary; there is no diagnostics callback or logging API.
diff --git a/website/src/content/docs/recipes/from-callbag-recharge.md b/website/src/content/docs/recipes/from-callbag-recharge.md
index bd66a41d..f07d9692 100644
--- a/website/src/content/docs/recipes/from-callbag-recharge.md
+++ b/website/src/content/docs/recipes/from-callbag-recharge.md
@@ -1,10 +1,14 @@
 ---
 title: "Migrating from callbag-recharge"
 description: "Step-by-step guide for migrating from callbag-recharge to GraphReFly — API mapping, import changes, and behavioral differences."
+draft: true
+pagefind: false
 ---
 
 # Migrating from callbag-recharge
 
+> Historical note (CSP-9): this migration guide is retained as an old callbag/root-package note, not active clean-slate import or API guidance. Current TypeScript guidance uses `@graphrefly/ts` and focused subpaths; do not copy `@graphrefly/graphrefly`, `/extra`, or `compat/*` imports from this historical page.
+
 GraphReFly is the successor to callbag-recharge. The core reactive model (two-phase push, diamond resolution, push-phase memoization) is identical. The differences are in API naming, module structure, and the single-primitive architecture.
 
 ## Install
@@ -14,20 +18,20 @@ GraphReFly is the successor to callbag-recharge. The core reactive model (two-ph
 npm uninstall @callbag-recharge/callbag-recharge
 
 # Install GraphReFly
-npm install @graphrefly/graphrefly
+npm install @graphrefly/ts
 ```
 
 ## Import changes
 
 ```diff
 - import { state, derived, effect, producer } from 'callbag-recharge'
-+ import { state, derived, effect, producer } from '@graphrefly/graphrefly'
++ import { graph } from '@graphrefly/ts/graph'
 
 - import { switchMap, debounce, retry } from 'callbag-recharge/extra'
-+ import { switchMap, debounce, retry } from '@graphrefly/graphrefly/extra'
++ import { switchMap, debounce, retry } from '@graphrefly/ts/operators'
 
 - import { Graph } from 'callbag-recharge/graph'
-+ import { Graph } from '@graphrefly/graphrefly/graph'
++ import { Graph } from '@graphrefly/ts/graph'
 ```
 
 ## API mapping
@@ -75,19 +79,19 @@ All 70+ operators carry forward with the same names and semantics. A few notes:
 | `wrap(store)` | `toObservable(node)` | Renamed for clarity |
 | `route(source, pred)` | Use `dynamicNode` or conditional `derived` | `route()` removed; use reactive patterns |
 | `select(store, fn)` | `derived([store], fn)` | `select` removed; `derived` does the same |
-| `createStore(fn)` | Use `@graphrefly/graphrefly/compat/zustand` | Compat layer available |
+| `createStore(fn)` | Use `zustandStore(...)` from `@graphrefly/ts/adapters` over caller-owned nodes | Legacy compat is retired |
 
-### Compat layers
+### Framework adapters
 
 | callbag-recharge | GraphReFly |
 |---|---|
-| `callbag-recharge/compat/zustand` | `@graphrefly/graphrefly/compat/zustand` |
-| `callbag-recharge/compat/jotai` | `@graphrefly/graphrefly/compat/jotai` |
-| `callbag-recharge/compat/react` | `@graphrefly/graphrefly/compat/react` |
-| `callbag-recharge/compat/vue` | `@graphrefly/graphrefly/compat/vue` |
-| `callbag-recharge/compat/svelte` | `@graphrefly/graphrefly/compat/svelte` |
-| `callbag-recharge/compat/solid` | `@graphrefly/graphrefly/compat/solid` |
-| — | `@graphrefly/graphrefly/compat/nestjs` (new) |
+| `callbag-recharge/compat/zustand` | `zustandStore(...)` from `@graphrefly/ts/adapters` |
+| `callbag-recharge/compat/jotai` | `jotaiAtom(...)` from `@graphrefly/ts/adapters` |
+| `callbag-recharge/compat/react` | `@graphrefly/ts/adapters/react` |
+| `callbag-recharge/compat/vue` | `@graphrefly/ts/adapters/vue` |
+| `callbag-recharge/compat/svelte` | `@graphrefly/ts/adapters/svelte` |
+| `callbag-recharge/compat/solid` | `@graphrefly/ts/adapters/solid` |
+| — | `@graphrefly/ts/adapters/nestjs` keyed boundary nodes |
 
 ### Messages
 
@@ -145,7 +149,7 @@ callbag-recharge used numeric types (`0`, `1`, `2`, `3`) with positional payload
 
 ## Quick migration checklist
 
-- [ ] Replace `@callbag-recharge/callbag-recharge` with `@graphrefly/graphrefly` in `package.json`
+- [ ] Replace `@callbag-recharge/callbag-recharge` with `@graphrefly/ts` in `package.json`
 - [ ] Update all import paths
 - [ ] Rename `dynamicDerived` → `dynamicNode`
 - [ ] Replace `operator()` calls with `derived()`
diff --git a/website/src/content/docs/recipes/nestjs-integration.md b/website/src/content/docs/recipes/nestjs-integration.md
index d98af650..76a510ed 100644
--- a/website/src/content/docs/recipes/nestjs-integration.md
+++ b/website/src/content/docs/recipes/nestjs-integration.md
@@ -1,328 +1,343 @@
 ---
 title: "NestJS Integration"
-description: "Build a reactive NestJS backend with GraphReFly — CQRS, scheduled jobs, WebSocket streaming, SSE, and actor-scoped guards."
+description: "Clean-slate NestJS integration with D495 focused provider ergonomics and explicit diagnostics."
 ---
 
 # NestJS Integration
 
-GraphReFly ships a first-class NestJS adapter at `@graphrefly/graphrefly/compat/nestjs`. It gives you a reactive graph inside NestJS's dependency injection, with CQRS event flows, scheduled jobs, real-time streaming, and actor-scoped guards — all wired through the graph protocol.
+Install GraphReFly plus the Nest peers for the phases you use:
 
-This recipe walks through a complete order-flow backend. The full runnable example lives at [`examples/nestjs-order-flow.ts`](https://github.com/graphrefly/graphrefly-ts/blob/main/examples/nestjs-order-flow.ts).
-
-## Install
-
-```bash frame="none"
-npm install @graphrefly/graphrefly @nestjs/common @nestjs/core @nestjs/platform-express reflect-metadata
-# For WebSocket support:
-npm install @nestjs/platform-ws @nestjs/websockets
+```bash
+pnpm add @graphrefly/ts @nestjs/common @nestjs/core rxjs
+pnpm add @nestjs/websockets @nestjs/platform-ws      # only for the WebSocket bridge
+pnpm add @nestjs/microservices                       # only for the message bridge
 ```
 
-## Module registration
+The clean-slate NestJS adapter has focused subpaths:
 
-`GraphReflyModule.forRoot()` creates a global graph singleton. `GraphReflyModule.forCqrs()` mounts a CQRS subgraph that auto-namespaces under the root.
+| Import path | Use |
+|---|---|
+| `@graphrefly/ts/adapters/nestjs` | Dependency-light structural metadata: boundary factories, binding decorators, envelopes, and lowering types. |
+| `@graphrefly/ts/adapters/nestjs/native` | Nest/RxJS native phase bridges for HTTP interceptor, guard, filter, cron, and lifecycle phases. |
+| `@graphrefly/ts/adapters/nestjs/websockets` | Focused optional-peer native bridge for `@nestjs/websockets` gateway ingress plus ack/reply egress. |
+| `@graphrefly/ts/adapters/nestjs/microservices` | Focused optional-peer native bridge for `@nestjs/microservices` message-pattern ingress plus reply egress. |
 
-```ts
-import { Module } from "@nestjs/common";
-import { GraphReflyModule } from "@graphrefly/graphrefly/compat/nestjs";
+HTTP/native imports do not pull `@nestjs/websockets` or `@nestjs/microservices`. The WebSocket and message subpaths import only their matching optional peer.
 
-@Module({
-  imports: [
-    // Root graph singleton (global)
-    GraphReflyModule.forRoot({ name: "app" }),
-
-    // CQRS orders subgraph — auto-mounts as app::orders
-    GraphReflyModule.forCqrs({
-      name: "orders",
-      build: (g) => {
-        g.event("orderPlaced");
-      },
-    }),
-  ],
-})
-class AppModule {}
-```
+Decorators are binding metadata. Providers are Nest phase bridges. Graph nodes are ordinary topology. D494/D495 are ergonomics and testability slices. NestJS provider bundle helpers and explicit target helpers reduce module boilerplate, but they never scan the Nest container, create graphs, own business graphs, add hidden route registries, introduce hidden event buses, or own retry/session/transport lifecycle policy.
 
-Inject the graph or a named CQRS subgraph anywhere:
+## Envelope
 
 ```ts
-import { Inject } from "@nestjs/common";
-import { GRAPHREFLY_ROOT_GRAPH, getGraphToken } from "@graphrefly/graphrefly/compat/nestjs";
-import type { Graph } from "@graphrefly/graphrefly/graph";
-import type { CqrsGraph } from "@graphrefly/graphrefly/patterns";
-
-class OrderController {
-  constructor(
-    @Inject(GRAPHREFLY_ROOT_GRAPH) private graph: Graph,
-    @Inject(getGraphToken("orders")) private orders: CqrsGraph,
-  ) {}
-}
+type NestBoundaryEnvelope<T = unknown> = {
+  bindingId: string;
+  version: 1;
+  payload: T;
+  requestId?: string;
+};
+
+type NestReplyEnvelope<T = unknown> =
+  NestBoundaryEnvelope<T> & { requestId: string };
 ```
 
-## CQRS order flow
-
-Wire commands, events, projections, and sagas through the `CqrsGraph` API:
+`requestId` is optional on the base envelope so lifecycle, cron, and other non-request ingress do not need fake request identity. HTTP replies and other reply-capable egress use `NestReplyEnvelope` and require a present `requestId`.
 
-### Command handler
+`bindingId` belongs to the Nest binding, usually supplied on `GraphReq(...)` or `GraphHttpReply(...)`. The graph node remains ordinary topology; its node name is not the durable Nest binding identity. Envelope `version` is the adapter envelope schema version, and v1 is the only accepted default.
 
-Dispatch a command that emits an event:
+## Decorator Path
 
 ```ts
-this.orders.command<OrderPayload>("placeOrder", (payload, { emit }) => {
-  emit("orderPlaced", {
-    orderId: payload.id,
-    item: payload.item,
-    amount: payload.amount,
-  });
-});
-```
-
-### Projection
-
-Fold events into a read model:
-
-```ts
-this.orders.projection<OrderSummary>(
-  "orderSummary",
-  ["orderPlaced"],
-  (current, events) => {
-    let summary = { ...current };
-    for (const evt of events) {
-      const p = evt.payload as { orderId: string; amount: number };
-      summary = {
-        totalOrders: summary.totalOrders + 1,
-        totalRevenue: summary.totalRevenue + p.amount,
-        lastOrderId: p.orderId,
-      };
-    }
-    return summary;
+import { graph, depLatest } from "@graphrefly/ts";
+import {
+  fromNestReq,
+  GraphReq,
+  GraphHttpReply,
+  type NestBoundaryEnvelope,
+  type NestReplyEnvelope,
+} from "@graphrefly/ts/adapters/nestjs";
+
+const g = graph({ name: "orders" });
+
+const ordersIn = fromNestReq(g, { bindingId: "node.orders.in" });
+
+const ordersOut = g.node<NestReplyEnvelope>(
+  [ordersIn.node],
+  (ctx) => {
+    const envelope = depLatest(ctx, 0) as NestBoundaryEnvelope;
+    if (envelope.requestId === undefined) return;
+    ctx.down([[
+      "DATA",
+      {
+        requestId: envelope.requestId,
+        bindingId: "http.orders.out",
+        version: 1,
+        payload: { status: 202, body: { accepted: true } },
+      },
+    ]]);
   },
-  { totalOrders: 0, totalRevenue: 0, lastOrderId: null },
+  { name: "http.orders.out" },
 );
-```
-
-### Saga
 
-Orchestrate side effects in response to events:
-
-```ts
-this.orders.saga("fulfillment", ["orderPlaced"], (event) => {
-  const p = event.payload as { orderId: string };
-  console.log(`Fulfillment for ${p.orderId} — shipping initiated`);
-});
+class OrdersController {
+  @GraphReq(ordersIn, {
+    bindingId: "http.orders.in",
+    requestId: (req: { requestId: string }) => req.requestId,
+    payload: (req: { body: unknown }) => req.body,
+  })
+  @GraphHttpReply(ordersOut, { bindingId: "http.orders.out" })
+  createOrder() {}
+}
 ```
 
-### Dispatch and query
+Register the native phase bridge with Nest providers:
 
 ```ts
-// POST /orders/place
-@Post("place")
-placeOrder(@Body() body: OrderPayload) {
-  this.orders.dispatch("placeOrder", body);
-  return { status: "ok", orderId: body.id };
-}
+import { provideGraphBoundaryInterceptor } from "@graphrefly/ts/adapters/nestjs/native";
 
-// GET /orders/summary
-@Get("summary")
-getSummary() {
-  return this.orders.resolve("orderSummary").get();
-}
+@Module({
+  providers: [
+    provideGraphBoundaryInterceptor({
+      host: (context) => context.switchToHttp().getRequest(),
+    }),
+  ],
+})
+class AppModule {}
 ```
 
-## Actor guard
+The provider reads metadata for the current class/handler only, attaches host-private pending reply handles, emits ingress DATA, lowers HTTP DATA replies, and cleans up. Controller users do not call `attach` on the decorator path. Low-level `emit(...)` and `toNestHttp(...)` remain available for custom hosts.
 
-`GraphReflyGuard` extracts an `Actor` from the request, making it available to graph operations. The guard supports header-based extraction (for development) and JWT payload extraction (for production).
+For common native wiring, use the explicit provider bundles:
 
 ```ts
-import { GraphReflyGuard, fromHeader, getActor } from "@graphrefly/graphrefly/compat/nestjs";
+import {
+  graphCronTarget,
+  graphLifecycleTarget,
+  provideGraphNativeProviders,
+} from "@graphrefly/ts/adapters/nestjs/native";
+
+const cronTargets = [
+  graphCronTarget(OrdersController, "cronTick", {
+    expr: "* * * * *",
+    timezone: "UTC",
+  }),
+];
 
-// Reads Actor from the `x-actor` header (JSON-parsed)
-const actorGuard = GraphReflyGuard(fromHeader());
+@Module({
+  providers: [
+    ...provideGraphNativeProviders({
+      http: {
+        boundaryInterceptor: {
+          host: (context) => context.switchToHttp().getRequest(),
+        },
+        guard: {},
+      },
+      cronScheduler: { targets: cronTargets },
+      lifecycleHooks: {
+        targets: [
+          graphLifecycleTarget(OrdersController, "teardown", {
+            event: "module-destroy",
+          }),
+        ],
+      },
+    }),
+  ],
+})
+class AppModule {}
+```
 
-@Controller("admin")
-@UseGuards(actorGuard)
-class AdminController {
-  constructor(@Inject(GRAPHREFLY_ROOT_GRAPH) private graph: Graph) {}
+The bundle returns ordinary `Provider[]`. It is not a module, does not create a graph, and does not discover targets. Targets remain explicit data supplied by the host app.
 
-  @Get("describe")
-  describe(@Req() req: unknown) {
-    const actor = getActor(req);
-    return this.graph.describe({ actor, detail: "standard" });
-  }
-}
-```
+## WebSocket and Message Bridges
 
-```bash frame="none"
-# Test with actor context:
-curl http://localhost:3000/admin/describe \
-  -H 'x-actor: {"type":"human","id":"admin-1"}'
-```
+D495 extends the NestJS ergonomics slice to focused transport subpaths. WebSocket modules may use `provideGraphWsProviders(...)` from `@graphrefly/ts/adapters/nestjs/websockets`, and message-pattern modules may use `provideGraphMessageProviders(...)` from `@graphrefly/ts/adapters/nestjs/microservices`. Each helper returns an ordinary explicit Nest provider array over existing bridge options. These helpers are not modules, do not create graphs, do not scan the container, do not discover routes or handlers, and do not own retry, session, or transport lifecycle policy.
 
-For production, swap to JWT extraction:
+Use `GraphWs(...)` with `GraphWsAck(...)` or `GraphWsReply(...)` through `provideGraphWsProviders(...)` or the primitive `provideGraphWsBridge(...)` from `@graphrefly/ts/adapters/nestjs/websockets`. Use `GraphMessage(...)` with `GraphMessageReply(...)` through `provideGraphMessageProviders(...)` or the primitive `provideGraphMessageBridge(...)` from `@graphrefly/ts/adapters/nestjs/microservices`.
 
 ```ts
-import { fromJwtPayload } from "@graphrefly/graphrefly/compat/nestjs";
+import { provideGraphMessageProviders } from "@graphrefly/ts/adapters/nestjs/microservices";
+import { provideGraphWsProviders } from "@graphrefly/ts/adapters/nestjs/websockets";
 
-const actorGuard = GraphReflyGuard(fromJwtPayload());
+@Module({
+  providers: [
+    ...provideGraphWsProviders({
+      bridge: {
+        ack: (host: WsHost) => host.ack,
+        client: (host: WsHost) => host.client,
+        diagnosticBoundary: nestDiagnostics,
+      },
+    }),
+    ...provideGraphMessageProviders({
+      bridge: { diagnosticBoundary: nestDiagnostics },
+    }),
+  ],
+})
+class AppModule {}
 ```
 
-## Scheduled jobs
+These native phase bridges read only the metadata for the current gateway/controller method, require explicit payload selectors, and correlate reply-capable egress by both `requestId` and `bindingId`. Sockets, clients, ack callbacks, message contexts, transport clients, Observables, Promises, and reply handles stay host-private pending handles; graph-visible DATA carries only the selected payload envelope. Wrong-binding, stale, malformed, terminal, timeout, disconnect, and dispose cases are adapter diagnostics and cleanup paths, not protocol `ERROR`.
 
-Use `fromTimer()` and `fromCron()` as reactive graph nodes — no imperative `setInterval` or cron libraries needed.
+The optional-peer boundary remains strict: `@nestjs/websockets` is imported only by the WebSocket subpath, and `@nestjs/microservices` is imported only by the microservice/message subpath. The structural `@graphrefly/ts/adapters/nestjs` surface and HTTP/native `@graphrefly/ts/adapters/nestjs/native` surface do not pull those transport peers.
 
-```ts
-import { fromTimer, fromCron } from "@graphrefly/graphrefly/extra";
+## Guards, Filters, and Issues
+
+Use `GraphGuard(...)` with `GraphGuardDecision(...)` for guard phase decisions. Missing, malformed, rejected, or requestId-less decisions fail closed. Guard denial is graph-visible DATA, not protocol `ERROR`; response status/body/headers are written by the targeted GraphReFly guard-denial filter.
 
-// Metrics heartbeat every 10s
-const timerNode = fromTimer(10_000, { period: 10_000, name: "__schedule__.metrics" });
-this.graph.add(timerNode);
+```ts
+import { UseFilters } from "@nestjs/common";
+import { GraphGuardDeniedFilter } from "@graphrefly/ts/adapters/nestjs/native";
+
+class OrdersController {
+  @UseFilters(GraphGuardDeniedFilter)
+  @GraphGuard(ordersGuardIn, { bindingId: "guard.orders.in" })
+  @GraphGuardDecision(ordersGuardOut, { bindingId: "guard.orders.out" })
+  createOrder() {}
+}
 
-// Daily cleanup at midnight
-const cronNode = fromCron("0 0 * * *", { name: "__schedule__.dailyCleanup" });
-this.graph.add(cronNode);
+// A deny payload can carry status/body/headers directly:
+const denied = {
+  kind: "deny",
+  status: 403,
+  body: { accepted: false },
+  headers: { "x-graphrefly-guard": "orders.denied" },
+} satisfies GraphGuardDecision;
 ```
 
-Both are visible in `graph.describe()` and participate in the reactive topology like any other node.
+`createGraphGuardDeniedFilter()` returns the same narrow helper as an instance, and `provideGraphGuardDeniedFilter()` registers the class-token provider used by `@UseFilters(GraphGuardDeniedFilter)`. The helper catches only the GraphReFly-owned guard denial exception; it is not a catch-all `APP_FILTER` and does not own ordinary Nest exceptions.
 
-## Real-time streaming
+`GraphGuardDecision(...)` supports binding-level `issueResponse` for deny issues and binding-level `protocolError` for reply-node `ERROR`, with binding options taking precedence over provider defaults.
 
-### WebSocket observe
+Use `GraphFilter(...)` for generic filter bindings; `GraphError(...)` is exception-oriented sugar. Filter/error bindings default to handle mode and can opt into observe mode.
 
-`ObserveGateway` bridges the graph's observe protocol to WebSocket clients:
+For exception handling, prefer the targeted helper:
 
 ```ts
-import { ObserveGateway } from "@graphrefly/graphrefly/compat/nestjs";
-
-@WebSocketGateway()
-class GraphWsGateway implements OnModuleDestroy {
-  private gw: ObserveGateway;
-
-  constructor(@Inject(GRAPHREFLY_ROOT_GRAPH) graph: Graph) {
-    this.gw = new ObserveGateway(graph);
-  }
-
-  handleConnection(client: unknown) { this.gw.handleConnection(client); }
-  handleDisconnect(client: unknown) { this.gw.handleDisconnect(client); }
+import { UseFilters } from "@nestjs/common";
+import { createGraphExceptionFilter } from "@graphrefly/ts/adapters/nestjs/native";
 
-  @SubscribeMessage("observe")
-  onObserve(client: unknown, data: unknown) {
-    this.gw.handleMessage(client, data);
-  }
+const graphErrorFilter = createGraphExceptionFilter({
+  target: () => ({ target: OrdersController, methodKey: "handledError" }),
+});
 
-  onModuleDestroy() { this.gw.destroy(); }
+class OrdersController {
+  @UseFilters(graphErrorFilter)
+  @GraphError(errorIn, { bindingId: "error.orders.in" })
+  @GraphHttpReply(errorOut, { bindingId: "http.error.out" })
+  handledError() {}
 }
 ```
 
-Clients send `{ event: "observe", data: { node: "orders::orderPlaced" } }` and receive reactive updates as the node changes.
-
-### SSE stream
+`provideGraphExceptionFilter(...)` exposes the same helper through a GraphReFly token for explicit Nest DI wiring. It is not registered as a catch-all `APP_FILTER`: Nest's global `ArgumentsHost` does not reliably expose the current route class/handler, and GraphReFly does not scan the container or own pass-through routing between unrelated filters.
 
-`observeSSE()` returns a `ReadableStream` for Server-Sent Events:
+HTTP business failures are DATA payloads, either `{ status, body, headers? }` or `HttpDataIssue`:
 
 ```ts
-import { observeSSE, getActor } from "@graphrefly/graphrefly/compat/nestjs";
+const issue = {
+  kind: "issue",
+  code: "orders.not_admitted",
+  message: "Order was not admitted.",
+  status: 403,
+  body: { accepted: false },
+} satisfies HttpDataIssue;
+```
 
-@Get("stream")
-streamOrders(@Req() req: unknown, @Res() res: Response) {
-  res.setHeader("Content-Type", "text/event-stream");
-  res.setHeader("Cache-Control", "no-cache");
-  res.writeHead(200);
+Plain `DataIssue` values lower through `issueResponse(issue, host)`. Protocol `ERROR` from a reply node is graph/reply pipeline failure, not a business error path; it lowers through `protocolError(errorPayload, host)` with binding override before provider override before the safe 500 fallback.
 
-  const stream = observeSSE(this.graph, "orders::orderPlaced", {
-    actor: getActor(req),
-    keepAliveMs: 15_000,
-  });
+## Cron
 
-  // Pipe ReadableStream to HTTP response...
-}
-```
+`GraphCron(...)` is consumed by `provideGraphCronScheduler(...)`; it does not require `@nestjs/schedule`. The scheduler is a Nest/source boundary that starts and stops host-private timers on module lifecycle hooks and emits ordinary cron ingress DATA.
 
-```bash frame="none"
-curl -N http://localhost:3000/orders/stream
-```
-
-## Admin introspection
+`fromCron(...)` and `GraphCron` support IANA timezone strings through runtime `Intl` support. Defaults are explicit: nonexistent DST wall-clock minutes are skipped, repeated wall-clock minutes fire at most once, and missed ticks while the host app/provider/event loop is unavailable are skipped by default. Restart or resume continues from the current time only; no missed-status or catch-up DATA is synthesized.
 
-Every node in the graph — CQRS events, projections, scheduled jobs, custom nodes — is visible through `graph.describe()`:
+The deterministic controller is for manual checks and tests:
 
 ```ts
-@Get("describe")
-describe() {
-  return this.graph.describe();
-}
-```
+import { createGraphCronController, graphCronTarget } from "@graphrefly/ts/adapters/nestjs/native";
 
-```bash frame="none"
-curl http://localhost:3000/admin/describe | jq .
-```
+const controller = createGraphCronController({
+  targets: [
+    graphCronTarget(OrdersController, "cronTick", {
+      expr: "30 8 * * 1",
+      timezone: "UTC",
+    }),
+  ],
+});
 
-Returns the full topology: node names, types, dependency edges, current values, and metadata.
+controller.check(new Date("2026-01-05T08:30:00.000Z"));
+```
 
-You can also export diagrams directly from the running graph by composing
-the pure renderers from `@graphrefly/graphrefly/extra/render` over
-`graph.describe()`:
+Cron remains five-field, minute-granularity, skip/current-time-only, and deduped per matched wall-clock minute. The deterministic cron controller does not add seconds grammar, missed-status DATA, catch-up replay DATA, scheduledAt/actualAt/missedCount payloads, or a graph-core scheduler.
 
-```ts
-import { graphSpecToD2, graphSpecToMermaid } from "@graphrefly/graphrefly/extra/render";
+## Inspection and Logging
 
-@Get("mermaid")
-mermaid() {
-  return graphSpecToMermaid(this.graph.describe(), { direction: "LR" });
-}
+Adapter diagnostics are host-side snapshots by default. `diagnostics()` on reply/bridge objects remains a host diagnostic snapshot and does not emit graph DATA by itself. Adapter diagnostics are not a stable logging callback and are not graph inspection. Use graph-visible audit/status/issues nodes and observe them:
 
-@Get("d2")
-d2() {
-  return graphSpecToD2(this.graph.describe(), { direction: "LR" });
-}
+```ts
+const stop = g.observe("orders.audit").subscribe((event) => {
+  if (event.msg[0] === "DATA") {
+    nestLogger.log(JSON.stringify(event.msg[1]));
+  }
+});
 ```
 
-```bash frame="none"
-curl http://localhost:3000/admin/mermaid
-curl http://localhost:3000/admin/d2
-```
+`graph.describe()` and `graph.observe()` remain the inspection path. Ordinary business HTTP failures are DATA payloads such as `{ status, body }`, not protocol `ERROR`.
 
-## Running the example
+Graph-visible adapter diagnostics require an explicitly wired diagnostic ingress boundary:
 
-The complete, bootable example is at `examples/nestjs-order-flow.ts`:
+```ts
+import { fromNestDiagnostics } from "@graphrefly/ts/adapters/nestjs";
+import { provideGraphMessageProviders } from "@graphrefly/ts/adapters/nestjs/microservices";
+import { provideGraphNativeProviders } from "@graphrefly/ts/adapters/nestjs/native";
+import { provideGraphWsProviders } from "@graphrefly/ts/adapters/nestjs/websockets";
 
-```bash frame="none"
-# Default port (3000)
-pnpm exec tsx --tsconfig examples/tsconfig.json examples/nestjs-order-flow.ts
+const nestDiagnostics = fromNestDiagnostics(g, {
+  bindingId: "node.nest.diagnostics",
+});
 
-# Or choose a different port if 3000 is already in use
-PORT=3001 pnpm exec tsx --tsconfig examples/tsconfig.json examples/nestjs-order-flow.ts
+@Module({
+  providers: [
+    ...provideGraphNativeProviders({
+      http: {
+        boundaryInterceptor: { diagnosticBoundary: nestDiagnostics },
+        guard: { diagnosticBoundary: nestDiagnostics },
+      },
+    }),
+    ...provideGraphWsProviders({
+      bridge: { diagnosticBoundary: nestDiagnostics },
+    }),
+    ...provideGraphMessageProviders({
+      bridge: { diagnosticBoundary: nestDiagnostics },
+    }),
+  ],
+})
+class AppModule {}
 ```
 
-Then try:
+Graph-visible diagnostics emit only sanitized data-only payloads: `kind`, `phase`, `requestId`, `bindingId`, `expectedBindingId`, `message`, and optional `{ name, message }` error summary. Raw sockets, clients, contexts, callbacks, transport handles, Promises, Observables, and raw Error objects never enter graph DATA. WS and message diagnostics use the same explicit ingress recipe as HTTP/native diagnostics; they do not get a separate logging channel.
 
-```bash frame="none"
-# Place an order
-curl -X POST http://localhost:3000/orders/place \
-  -H "Content-Type: application/json" \
-  -d '{"id":"order-1","item":"Widget","amount":29.99}'
+There is no `onDiagnostic` callback or logging API. Log or audit diagnostics by composing explicit graph nodes and subscribing with `graph.observe(...)`, the same as other graph-visible status.
 
-# Check the projection
-curl http://localhost:3000/orders/summary
+## Runnable Example
 
-# Stream events via SSE
-curl -N http://localhost:3000/orders/stream
+The example lives at `examples/nestjs-graph-boundary/`:
 
-# Inspect the graph topology
-curl http://localhost:3000/admin/describe | jq .
-
-# Export diagrams
-curl http://localhost:3000/admin/mermaid
-curl http://localhost:3000/admin/d2
+```bash
+pnpm --filter @graphrefly-examples/nestjs-graph-boundary start
 ```
 
-## Key concepts
+It includes:
+
+- `POST /echo`
+- `POST /policy`
+- `POST /orders`
+- `POST /handled-error`
+- `POST /cron/tick`
+- `POST /cron/check`
+- `GET /audit/:requestId`
+- `POST /lifecycle/teardown`
+- `GET /graph`
+- WebSocket `orders.reserve` on `/graphrefly`
+- TCP microservice pattern `orders.reserve` on `MICRO_HOST:MICRO_PORT` (default `127.0.0.1:3001`)
 
-| Concept | GraphReFly NestJS | Traditional NestJS |
-|---|---|---|
-| State management | Reactive graph nodes | Services with mutable fields |
-| CQRS | `CqrsGraph` — command/event/projection/saga | `@nestjs/cqrs` — separate buses |
-| Scheduling | `fromTimer()` / `fromCron()` as graph nodes | `@nestjs/schedule` decorators |
-| Real-time | `ObserveGateway` / `observeSSE()` | Manual WebSocket/SSE wiring |
-| Introspection | `graph.describe()` — full topology | None built-in |
-| Actor context | `GraphReflyGuard` + `getActor()` | Custom guards |
+`POST /echo` and `POST /orders` use the D494 native provider bundle. The WebSocket and message-pattern methods use the D495 focused optional-peer provider bundles with `requestId` plus `bindingId` correlation. `POST /orders` shows guard denial response headers through `GraphGuardDeniedFilter`. `POST /handled-error` uses the targeted exception helper with Nest `@UseFilters(...)`. `POST /cron/check` demonstrates the deterministic manual cron controller. The example also includes a Nest Logger provider that subscribes to the graph-visible `orders.audit` node with `graph.observe(...)` and an explicit diagnostic boundary for sanitized adapter diagnostics.
 
-The graph approach means every piece of state — commands, events, projections, timers, custom nodes — lives in a single observable topology. You get introspection, snapshotting, and reactive composition for free.
+WebSocket and microservice helpers stay in their focused optional-peer subpaths. Live WebSocket and TCP tests are acceptance coverage over the existing public APIs; they do not define new public transport policy.
diff --git a/website/src/content/docs/solutions/reactive-layout.md b/website/src/content/docs/solutions/reactive-layout.md
index 98276c29..d2551a42 100644
--- a/website/src/content/docs/solutions/reactive-layout.md
+++ b/website/src/content/docs/solutions/reactive-layout.md
@@ -1,244 +1,158 @@
 ---
 title: Reactive Layout
-description: "DOM-free text layout as a reactive graph: pretext-class measurement, cached derived nodes, block and flow layouts, adapters, and hooks into the rest of GraphReFly."
+description: "D203 reactive-layout solution: DOM-free layout core, graph-visible measurement facts, and focused provider helpers."
 ---
 
 ## What it is
 
-**Reactive Layout** wraps pretext-class text analysis and canvas-based measurement in a **GraphReFly graph**. You get `state` inputs (text, font, line height, max width) and **derived** nodes (`segments`, line breaks, heights, character positions) that **recompute only when their dependencies change** — with measurement caching and meta companions (`cache-hit-rate`, `layout-time-ns`, …) for debugging.
+Reactive Layout is a clean-slate `@graphrefly/ts` solution kit for text and simple document layout.
+The universal core lives at `@graphrefly/ts/solutions/reactive-layout`; browser measurement lives at
+`@graphrefly/ts/solutions/reactive-layout/browser`.
 
-On top of single-column `reactiveLayout`, the module adds **heterogeneous vertical stacks** (`reactiveBlockLayout`), **multi-column flow around obstacles** (`reactiveFlowLayout`), and **adapters** from browser canvas to CLI fixed-width measurement.
+The core exposes pure layout helpers plus graph-visible bundles:
 
-**Choosing vs raw [pretext](https://github.com/chenglou/pretext)?** See **[Reactive Layout vs Pretext](/comparisons/pretext/)** for bundle size, i18n coverage, and primitive-by-primitive tradeoffs.
+- `reactiveLayout` for single-column text layout.
+- `reactiveBlockLayout` for vertical text/image/SVG block flows.
+- `reactiveFlowLayout` for columns and rectangle/circle obstacles.
 
-## Quick start
+The bundles return ordinary graph nodes such as `segments`, `lineBreaks`, `height`,
+`charPositions`, `measuredBlocks`, and `flowLines`. React, Canvas, DOM, CLI, or native renderers
+consume those nodes through their own binding layer; layout itself does not draw.
 
-```ts
-import {
-  reactiveLayout,
-  CanvasMeasureAdapter,
-} from "@graphrefly/graphrefly/utils/reactive-layout";
-import { DATA } from "@graphrefly/graphrefly/core";
-
-const layout = reactiveLayout({
-  adapter: new CanvasMeasureAdapter(),
-  text: "GraphReFly — text layout as a reactive graph.",
-  font: "14px Fira Code",
-  lineHeight: 22,
-  maxWidth: 480,
-});
-
-layout.lineBreaks.subscribe(([[type, lb]]) => {
-  if (type === DATA) render(lb);
-});
-
-layout.setMaxWidth(320);           // segments can stay cached
-layout.setText("Try typing here.");
-layout.setFont("16px serif");      // new font key → segments + line-breaks
-```
-
-Change any input — only dependent derived nodes re-run. For batching multiple writes into one recompute, use `batch()` like any other GraphReFly graph.
+Measurement is explicit graph input. Providers emit ordered `MeasurementResult` / `DataIssue` facts
+into a user-composed `measurements` node. Layout consumes the latest DATA from that node; users own
+merge, ordering, fallback, and dedupe policy.
 
-## Rendering from `layout`
-
-**Reactive Layout does not draw to the screen by itself.** The bundle exposes graph **nodes** (`lineBreaks`, `height`, `segments`, `charPositions`). Implement `render` (or map to JSX) by consuming **`LineBreaksResult`** from `lineBreaks` — `{ lines, lineCount }` where each line has `text`, `width`, and segment bounds (see [`LineBreaksResult`](/api/reactivelayout)). Below: vanilla DOM and React using the same subscription pattern.
-
-### Vanilla: subscribe and paint DOM
+## Imports
 
 ```ts
 import {
+  cellTextMeasurements,
   reactiveLayout,
-  CanvasMeasureAdapter,
   type LineBreaksResult,
-} from "@graphrefly/graphrefly/utils/reactive-layout";
-import { DATA } from "@graphrefly/graphrefly/core";
-
-const lineHeightPx = 22;
+} from "@graphrefly/ts/solutions/reactive-layout";
+import { graph } from "@graphrefly/ts";
 
+const g = graph({ name: "article" });
+const text = g.state("GraphReFly text layout as a reactive graph.", { name: "text" });
+const font = g.state("14px Fira Code", { name: "font" });
+const measurements = cellTextMeasurements({ graph: g, text, font });
 const layout = reactiveLayout({
-  adapter: new CanvasMeasureAdapter(),
-  text: "GraphReFly — text layout as a reactive graph.",
-  font: "14px Fira Code",
-  lineHeight: lineHeightPx,
+  graph: g,
+  measurements,
+  lineHeight: 22,
   maxWidth: 480,
 });
 
-function paint(container: HTMLElement, lb: LineBreaksResult) {
-  container.replaceChildren();
-  for (const line of lb.lines) {
-    const row = document.createElement("div");
-    row.style.height = `${lineHeightPx}px`;
-    row.style.width = `${line.width}px`;
-    row.textContent = line.text || "\u00a0";
-    container.append(row);
-  }
-}
-
-const el = document.getElementById("body")!;
-layout.lineBreaks.subscribe(([[type, lb]]) => {
-  if (type === DATA) paint(el, lb);
+layout.lineBreaks.subscribe((msg) => {
+  const [type, value] = msg;
+  if (type === "DATA") render(value as LineBreaksResult);
 });
-const initial = layout.lineBreaks.cache as LineBreaksResult | undefined;
-if (initial) paint(el, initial);
-```
 
-You can also subscribe with `layout.lineBreaks.subscribe(() => { paint(el, layout.lineBreaks.cache as LineBreaksResult); })` and read **`node.cache`** after each push — the **[reactive-layout demo](/demos/reactive-layout/)** does this from React via a tiny `useNodeValue` helper.
-
-### React: `useSubscribe` on output nodes
-
-**`useSubscribe(node)`** from `@graphrefly/graphrefly/compat/react` bridges any `Node<T>` (including `layout.lineBreaks`) to React via `useSyncExternalStore`. There is no layout-specific hook.
-
-```tsx
-import { useMemo } from "react";
-import { reactiveLayout, CanvasMeasureAdapter } from "@graphrefly/graphrefly/utils/reactive-layout";
-import { useSubscribe } from "@graphrefly/graphrefly/compat/react";
-
-const lineHeightPx = 22;
-
-function Paragraph() {
-  const layout = useMemo(
-    () =>
-      reactiveLayout({
-        adapter: new CanvasMeasureAdapter(),
-        text: "Hello",
-        font: "14px system-ui",
-        lineHeight: lineHeightPx,
-        maxWidth: 480,
-      }),
-    [],
-  );
-  const lb = useSubscribe(layout.lineBreaks);
-  const h = useSubscribe(layout.height);
-  if (!lb) return null;
-  return (
-    <div style={{ minHeight: h ?? 0, lineHeight: `${lineHeightPx}px`, font: "14px system-ui" }}>
-      {lb.lines.map((line, i) => (
-        <div key={i} style={{ height: lineHeightPx, width: line.width }}>
-          {line.text || "\u00a0"}
-        </div>
-      ))}
-    </div>
-  );
-}
+layout.setMaxWidth(320);
+text.set("Try typing here.");
 ```
 
-Create the bundle **once** per logical paragraph (`useMemo`, module scope, or context), not on every render.
-
-## Advanced usage
-
-### Block and flow layouts
-
-- **`reactiveBlockLayout`** — vertically stack heterogeneous blocks (text, SVG, image) with per-block measurement adapters and a shared `maxWidth` / `gap`.
-- **`reactiveFlowLayout`** — flow body text across columns with **circle / rectangle obstacles** (editorial-style wraps, pull quotes, images). Uses the same measurement pipeline with slot carving helpers.
-
-Use the **[interactive demo](/demos/reactive-layout/)** Blocks and Flow chapters to see topology and parameters in motion.
-
-### Adapters and headless measurement
-
-- **Browser:** `CanvasMeasureAdapter` (uses `OffscreenCanvas` when available).
-- **Terminal / snapshots:** `CliMeasureAdapter` for fixed character width without a DOM.
-- **React Native / Hermes:** `InjectedMeasureAdapter` for text measurement + `SegmentAdapter` for text segmentation (Hermes has no `Intl.Segmenter`) — wrap a host sync measure fn and a segmenter polyfill (see below).
-- **Precomputed / shared cache:** swap adapters without changing consumer code — the demo's **Adapters** chapter runs multiple backends against the same graph shape.
-
-First measurement on a **new font** is slower while the font loads; later calls hit the per-font cache.
-
-### React Native / Hermes
-
-`@graphrefly/graphrefly/utils/reactive-layout` is **Hermes-safe at import**: its core imports only `@graphrefly/pure-ts/core` + `@graphrefly/pure-ts/graph` — zero `node:*`, and the only DOM touchpoint is `CanvasMeasureAdapter`'s `OffscreenCanvas`, reached behind a runtime `typeof OffscreenCanvas === "undefined"` guard (no static import). The engine loads on Hermes; **two host-injected adapters** are required to also be Hermes-safe **at runtime**:
-
-1. **`segmentAdapter`** — text segmentation. The default `IntlSegmentAdapter` wraps platform `Intl.Segmenter`, which Hermes (iOS 26.5 / RN 0.83) does **not** ship. Without an injected `SegmentAdapter`, `reactiveLayout({ ... })` throws a clear `TypeError` at factory construction (the eager fail-fast is better DX than the deep-stack `Cannot read property 'prototype' of undefined` you'd see otherwise).
-2. **`adapter`** (already shipped 2026-05-19) — text measurement. RN has no DOM/`OffscreenCanvas`. Use `InjectedMeasureAdapter` with any sync `(text, font) => widthPx`.
-
-The build-time bundle assertion (described below) confirms zero `node:*` + zero unguarded DOM globals at *import* surface; runtime `Intl.Segmenter` access is **not** an import-time signal, which is why this RN block now documents the `segmentAdapter` injection explicitly.
-
-A scoped browser-safety bundle assertion over the `utils/reactive-layout` entry runs at build time (same bar/precedent as the substrate's `assertBrowserSafeBundles`). It **soundly** fails the build on any transitive `node:*` import, and **heuristically** fails it if a reachable chunk references a DOM global (`document`, `OffscreenCanvas`, …) that is *not* `typeof`-guarded in its file — i.e. it mechanically enforces the `typeof`-guard convention and catches a new unguarded DOM regression. It is **not** a proof of DOM-freedom (a file could `typeof`-guard a global once yet misuse it elsewhere); ultimate Hermes-crash-safety still rests on the runtime guards plus the manual audit plus the two host-injected adapters above.
-
-The substrate ships the generic seams + contracts (`MeasurementAdapter`, `SegmentAdapter`); the concrete native bindings stay userland (same split as the userland `bytes`-`StorageBackend` adapter vs. the upstream `bigintJsonCodecFor`).
+## Core Subpath
+
+`@graphrefly/ts/solutions/reactive-layout` is DOM-free. It exports the layout types, pure helpers,
+and sync provider helpers:
+
+- `injectedTextMeasurements`
+- `precomputedTextMeasurements`
+- `cellTextMeasurements`
+- `capabilityTextMeasurements`
+- `readinessTextMeasurements`
+- `readinessMeasurements`
+- `imageSizeMeasurements`
+- `svgBoundsMeasurements`
+- `blockAdaptersProvider`
+- `blockMeasurementProvider`
+- `ImageSizeAdapter`
+- `SvgBoundsAdapter`
+
+`SvgBoundsAdapter` is only a minimal width/height or `viewBox` reader. It is not a DOM SVG parser.
+`ImageSizeAdapter` uses caller-provided sizes. It does not load images.
+
+Provider helpers are cache-safe across capability identity changes. If a text adapter changes,
+provider-local segment caches are cleared before the next measurement. If hyphen-width measurement
+fails after segments were measured, the provider still emits the OK segment measurement and adds a
+DATA-level issue; layout can continue with `hyphenWidth` omitted. Numeric graph inputs such as
+widths, line heights, gaps, columns, and obstacle dimensions are clamped when layout consumes them,
+including when callers provide writable `Node<number>` inputs directly.
+
+`capabilityTextMeasurements` is the lightweight D203 shape for caller-injected platform text
+capabilities such as NodeCanvas, Skia, or React Native measurement functions. The capability is an
+explicit graph dependency; the universal core still imports no native package or platform global.
+`readinessTextMeasurements` makes font or resource readiness an explicit graph fact: not-ready emits
+a `DataIssue`, ready delegates to the normal text measurement path.
+
+`readinessMeasurements`, `imageSizeMeasurements`, and `svgBoundsMeasurements` are lightweight fact
+providers. They emit ordinary `MeasurementResult` / `DataIssue` facts for readiness, caller-registered
+image sizes, and caller-injected SVG bounds readers. They do not load fonts or images, parse DOM SVG,
+merge provider outputs, or make layout consume image/SVG facts directly.
+Target ids are measurement fact keys; duplicate ids and cross-provider precedence are caller-owned
+composition policy.
+
+## Browser Subpath
+
+`@graphrefly/ts/solutions/reactive-layout/browser` exports `canvasTextMeasurements`, which lazily
+uses `OffscreenCanvas` behind the browser subpath.
+
+Animation-frame sources are separate browser sources:
 
 ```ts
-import { Skia } from "@shopify/react-native-skia";
-import {
-  reactiveLayout,
-  InjectedMeasureAdapter,
-  type SegmentAdapter,
-  type SegmentInfo,
-} from "@graphrefly/graphrefly/utils/reactive-layout";
-import { createIntlSegmenterPolyfill } from "intl-segmenter-polyfill"; // or @formatjs/intl-segmenter
-
-// 1. Build segmenters from your polyfill of choice (Hermes ships no Intl.Segmenter).
-const wordSeg = await createIntlSegmenterPolyfill({ granularity: "word" });
-const graphemeSeg = await createIntlSegmenterPolyfill({ granularity: "grapheme" });
-const segmentAdapter: SegmentAdapter = {
-  segmentWords: (text) => wordSeg.segment(text) as Iterable<SegmentInfo>,
-  segmentGraphemes: (text) => graphemeSeg.segment(text) as Iterable<SegmentInfo>,
-};
-
-// 2. Build the Skia measure fn (synchronous — perfect fit for the reactive graph).
-const skFont = Skia.Font(typeface, 16); // built once, outside the measure fn
-const layout = reactiveLayout({
-  adapter: new InjectedMeasureAdapter((text) => skFont.measureText(text).width),
-  segmentAdapter,
-  font: "16px Kalam",
-  maxWidth: screenWidth,
-});
+import { fromRaf } from "@graphrefly/ts/sources/browser";
 ```
 
-Alternative: install a global polyfill at app entry (`import "intl-segmenter-polyfill/dist/polyfill"` before any reactive-layout import); the default `IntlSegmentAdapter` then picks it up automatically. The injected `SegmentAdapter` path is preferred because it keeps the ICU bytes scoped to consumers that need them.
-
-`Skia.Font.measureText` (and RN core text metrics) are synchronous — a perfect fit for the pure-arithmetic layout graph. Pass `{ cache: true }` on `InjectedMeasureAdapter` to memoize widths by `font + text` for repeated re-layout of stable content.
-
-### Fidelity and runtime caveats
+`fromRaf` is not exported from reactive-layout.
 
-- **Measurement subset.** CJK (per-grapheme breaking), soft-hyphen, break-word, kinsoku, left-sticky punctuation — yes. Full bidi, keep-all word-break, emoji-width correction, tab stops — **not yet**. If you depend on those, compare with pretext on **[Reactive Layout vs Pretext](/comparisons/pretext/)**.
+## Focused Platform Subpaths
 
-- **`fromRaf` semantics.** Animation-frame sources tick via `requestAnimationFrame` when the tab is visible and fall back to `setTimeout` when hidden, so downstream layout state keeps updating. For strict “pause in background” behavior (mobile battery-correctness), pass `fromRaf({ pauseWhenHidden: true })`: it fully parks while `document.visibilityState === "hidden"` (no rAF, no `setTimeout` keep-alive) and resumes from the next frame on `visibilitychange`. With no `document` (React Native / Hermes) there is no visibility signal to observe — the host drives background pause itself (e.g. an `AppState`-fed gate, or unsubscribing the node on background).
+Focused platform subpaths expose dependency-free API shapes for native text measurement:
 
-## With the rest of GraphReFly
+- `@graphrefly/ts/solutions/reactive-layout/node-canvas`
+  exports `nodeCanvasTextMeasurements` for caller-owned NodeCanvas-style 2D contexts.
+- `@graphrefly/ts/solutions/reactive-layout/skia`
+  exports `skiaTextMeasurements` for caller-owned synchronous Skia measurement capabilities.
+- `@graphrefly/ts/solutions/reactive-layout/react-native`
+  exports `reactNativeTextMeasurements` for caller-owned synchronous React Native measurement
+  capabilities.
 
-Reactive Layout is meant to compose with other primitives on the **same protocol**:
+These subpaths do not import `canvas`, Skia, or React Native packages. They keep platform packages
+caller-owned while making the measurement capability a graph-visible dependency. Async font or
+native layout readiness should still be modeled with explicit readiness or measurement facts.
 
-### Layout × Harness
+## Recipes
 
-The agent harness streams LLM output; `reactiveLayout` rewraps partial text each tick while `segments` stays cached until the font changes — cost is re-layout, not full re-measurement. Gates, verify, and retry live in the harness; layout only reacts.
+The example recipes under `examples/reactive-layout/recipes/` show the user-land glue boundaries:
 
-```ts
-const harness = harnessLoop({ /* … */ });
-const layout = reactiveLayout({ adapter, font, lineHeight, maxWidth });
-
-harness.outputs.subscribe(([[t, v]]) => {
-  if (t === DATA) layout.setText(v.text);
-});
-```
-
-### Layout × Resilience
-
-Wrap a fragile websocket in `circuitBreaker` + `retry`, debounce into `reactiveFlowLayout`'s text state: when the breaker opens, layout holds the last good text; when it closes, layout resumes.
+- React Native `onLayout` or native probe callbacks update a graph `state` node, then
+  `reactNativeLayoutMeasurements` projects those async host results into measurement facts.
+- React Native Skia `useFonts` readiness stays explicit: callers write readiness facts and a ready
+  Paragraph capability, then compose `skiaParagraphTextMeasureCapability` with
+  `skiaReadyTextMeasurements`.
+- Text, readiness, image, and SVG providers are merged upstream with `mergeMeasurements` into the
+  single measurements node consumed by layout. `mergeMeasurements` preserves source order; it is not
+  a generic priority, fallback, dedupe, or stale-policy API.
 
-### Layout × Virtualization
+These recipes intentionally do not introduce public RN hooks/components, hidden font loading,
+optional native dependencies in the universal core, or layout-owned provider policy.
 
-`reactiveList` + per-item `reactiveLayout`: **exact predicted heights** before paint — less scroll-anchor drift than estimate-then-correct patterns.
+## Deferred
 
-### Layout × CQRS
+These are intentionally not implemented by D203:
 
-Event-sourced document → projection drives `reactiveBlockLayout`'s blocks. `graph.snapshot()` can capture document + downstream layout; collaborators mutate blocks and layout reflows per keystroke without redundant measurement where caches apply.
+- Required NodeCanvas, React Native, Skia, or other native measurement dependencies.
+- Async image loading.
+- DOM SVG parsing.
+- GraphSpec ownership, storage restore, hydration, or adapter serialization.
 
-### Layout × Layout
+Concrete package-bound adapters and async loaders remain caller-owned or future optional-peer
+focused subpaths.
 
-Multiple layout bundles can **share warm adapter caches** (for example two flow layouts with the same adapter). The demo's Adapters chapter shows **Canvas, Offscreen, and CLI** behind one interface.
-
-## Live demo
-
-**[Reactive layout demo →](/demos/reactive-layout/)** — six chapters: **Playground**, **Recomputes**, **Batch**, **Adapters**, **Blocks**, **Flow**.
-
-## Where next
-
-- **[Reactive Layout vs Pretext](/comparisons/pretext/)** — when to pick each, primitive mapping, i18n and bundle tradeoffs
-- **[API: `reactiveLayout()`](/api/reactivelayout)**
-- **[API: `reactiveBlockLayout()`](/api/reactiveblocklayout)**
-- **[API: `analyzeAndMeasure()`](/api/analyzeandmeasure)** · **[API: `computeLineBreaks()`](/api/computelinebreaks)**
-- **[Specification](/spec)** — the reactive protocol Reactive Layout builds on
-- **[vs RxJS](/comparisons/rxjs)** — how `derived` + `batch` compare to streaming libraries
-
----
+## API
 
-*Credit: Reactive Layout stands on [Cheng Lou's pretext](https://github.com/chenglou/pretext) — algorithms, naming, and the insight that text measurement can be pure arithmetic over cached widths. GraphReFly adds the reactive graph on top.*
+- [API: `reactiveLayout()`](/api/reactivelayout)
+- [API: `reactiveBlockLayout()`](/api/reactiveblocklayout)
+- [API: `fromRaf()`](/api/fromraf)